2 * QEMU M48T59 and M48T08 NVRAM emulation for PPC PREP and Sparc platforms
4 * Copyright (c) 2003-2005, 2007 Jocelyn Mayer
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 #if defined(DEBUG_NVRAM)
30 #define NVRAM_PRINTF(fmt, args...) do { printf(fmt , ##args); } while (0)
32 #define NVRAM_PRINTF(fmt, args...) do { } while (0)
36 * The M48T08 and M48T59 chips are very similar. The newer '59 has
37 * alarm and a watchdog timer and related control registers. In the
38 * PPC platform there is also a nvram lock function.
41 /* Model parameters */
42 int type
; // 8 = m48t08, 59 = m48t59
43 /* Hardware parameters */
46 target_phys_addr_t mem_base
;
52 /* Alarm & watchdog */
54 struct QEMUTimer
*alrm_timer
;
55 struct QEMUTimer
*wd_timer
;
62 /* Fake timer functions */
63 /* Generic helpers for BCD */
64 static inline uint8_t toBCD (uint8_t value
)
66 return (((value
/ 10) % 10) << 4) | (value
% 10);
69 static inline uint8_t fromBCD (uint8_t BCD
)
71 return ((BCD
>> 4) * 10) + (BCD
& 0x0F);
74 /* RTC management helpers */
75 static void get_time (m48t59_t
*NVRAM
, struct tm
*tm
)
79 t
= time(NULL
) + NVRAM
->time_offset
;
81 memcpy(tm
,localtime(&t
),sizeof(*tm
));
86 localtime_r (&t
, tm
) ;
90 static void set_time (m48t59_t
*NVRAM
, struct tm
*tm
)
94 new_time
= mktime(tm
);
96 NVRAM
->time_offset
= new_time
- now
;
99 /* Alarm management */
100 static void alarm_cb (void *opaque
)
102 struct tm tm
, tm_now
;
104 m48t59_t
*NVRAM
= opaque
;
106 qemu_set_irq(NVRAM
->IRQ
, 1);
107 if ((NVRAM
->buffer
[0x1FF5] & 0x80) == 0 &&
108 (NVRAM
->buffer
[0x1FF4] & 0x80) == 0 &&
109 (NVRAM
->buffer
[0x1FF3] & 0x80) == 0 &&
110 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
111 /* Repeat once a month */
112 get_time(NVRAM
, &tm_now
);
113 memcpy(&tm
, &tm_now
, sizeof(struct tm
));
115 if (tm
.tm_mon
== 13) {
119 next_time
= mktime(&tm
);
120 } else if ((NVRAM
->buffer
[0x1FF5] & 0x80) != 0 &&
121 (NVRAM
->buffer
[0x1FF4] & 0x80) == 0 &&
122 (NVRAM
->buffer
[0x1FF3] & 0x80) == 0 &&
123 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
124 /* Repeat once a day */
125 next_time
= 24 * 60 * 60 + mktime(&tm_now
);
126 } else if ((NVRAM
->buffer
[0x1FF5] & 0x80) != 0 &&
127 (NVRAM
->buffer
[0x1FF4] & 0x80) != 0 &&
128 (NVRAM
->buffer
[0x1FF3] & 0x80) == 0 &&
129 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
130 /* Repeat once an hour */
131 next_time
= 60 * 60 + mktime(&tm_now
);
132 } else if ((NVRAM
->buffer
[0x1FF5] & 0x80) != 0 &&
133 (NVRAM
->buffer
[0x1FF4] & 0x80) != 0 &&
134 (NVRAM
->buffer
[0x1FF3] & 0x80) != 0 &&
135 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
136 /* Repeat once a minute */
137 next_time
= 60 + mktime(&tm_now
);
139 /* Repeat once a second */
140 next_time
= 1 + mktime(&tm_now
);
142 qemu_mod_timer(NVRAM
->alrm_timer
, next_time
* 1000);
143 qemu_set_irq(NVRAM
->IRQ
, 0);
147 static void get_alarm (m48t59_t
*NVRAM
, struct tm
*tm
)
150 memcpy(tm
,localtime(&NVRAM
->alarm
),sizeof(*tm
));
153 gmtime_r (&NVRAM
->alarm
, tm
);
155 localtime_r (&NVRAM
->alarm
, tm
);
159 static void set_alarm (m48t59_t
*NVRAM
, struct tm
*tm
)
161 NVRAM
->alarm
= mktime(tm
);
162 if (NVRAM
->alrm_timer
!= NULL
) {
163 qemu_del_timer(NVRAM
->alrm_timer
);
164 if (NVRAM
->alarm
- time(NULL
) > 0)
165 qemu_mod_timer(NVRAM
->alrm_timer
, NVRAM
->alarm
* 1000);
169 /* Watchdog management */
170 static void watchdog_cb (void *opaque
)
172 m48t59_t
*NVRAM
= opaque
;
174 NVRAM
->buffer
[0x1FF0] |= 0x80;
175 if (NVRAM
->buffer
[0x1FF7] & 0x80) {
176 NVRAM
->buffer
[0x1FF7] = 0x00;
177 NVRAM
->buffer
[0x1FFC] &= ~0x40;
178 /* May it be a hw CPU Reset instead ? */
179 qemu_system_reset_request();
181 qemu_set_irq(NVRAM
->IRQ
, 1);
182 qemu_set_irq(NVRAM
->IRQ
, 0);
186 static void set_up_watchdog (m48t59_t
*NVRAM
, uint8_t value
)
188 uint64_t interval
; /* in 1/16 seconds */
190 NVRAM
->buffer
[0x1FF0] &= ~0x80;
191 if (NVRAM
->wd_timer
!= NULL
) {
192 qemu_del_timer(NVRAM
->wd_timer
);
194 interval
= (1 << (2 * (value
& 0x03))) * ((value
>> 2) & 0x1F);
195 qemu_mod_timer(NVRAM
->wd_timer
, ((uint64_t)time(NULL
) * 1000) +
196 ((interval
* 1000) >> 4));
201 /* Direct access to NVRAM */
202 void m48t59_write (m48t59_t
*NVRAM
, uint32_t addr
, uint32_t val
)
207 if (addr
> 0x1FF8 && addr
< 0x2000)
208 NVRAM_PRINTF("%s: 0x%08x => 0x%08x\n", __func__
, addr
, val
);
209 if (NVRAM
->type
== 8 &&
210 (addr
>= 0x1ff0 && addr
<= 0x1ff7))
214 /* flags register : read-only */
221 tmp
= fromBCD(val
& 0x7F);
222 if (tmp
>= 0 && tmp
<= 59) {
223 get_alarm(NVRAM
, &tm
);
225 NVRAM
->buffer
[0x1FF2] = val
;
226 set_alarm(NVRAM
, &tm
);
231 tmp
= fromBCD(val
& 0x7F);
232 if (tmp
>= 0 && tmp
<= 59) {
233 get_alarm(NVRAM
, &tm
);
235 NVRAM
->buffer
[0x1FF3] = val
;
236 set_alarm(NVRAM
, &tm
);
241 tmp
= fromBCD(val
& 0x3F);
242 if (tmp
>= 0 && tmp
<= 23) {
243 get_alarm(NVRAM
, &tm
);
245 NVRAM
->buffer
[0x1FF4] = val
;
246 set_alarm(NVRAM
, &tm
);
251 tmp
= fromBCD(val
& 0x1F);
253 get_alarm(NVRAM
, &tm
);
255 NVRAM
->buffer
[0x1FF5] = val
;
256 set_alarm(NVRAM
, &tm
);
261 NVRAM
->buffer
[0x1FF6] = val
;
265 NVRAM
->buffer
[0x1FF7] = val
;
266 set_up_watchdog(NVRAM
, val
);
270 NVRAM
->buffer
[0x1FF8] = (val
& ~0xA0) | 0x90;
274 tmp
= fromBCD(val
& 0x7F);
275 if (tmp
>= 0 && tmp
<= 59) {
276 get_time(NVRAM
, &tm
);
278 set_time(NVRAM
, &tm
);
280 if ((val
& 0x80) ^ (NVRAM
->buffer
[0x1FF9] & 0x80)) {
282 NVRAM
->stop_time
= time(NULL
);
284 NVRAM
->time_offset
+= NVRAM
->stop_time
- time(NULL
);
285 NVRAM
->stop_time
= 0;
288 NVRAM
->buffer
[0x1FF9] = val
& 0x80;
292 tmp
= fromBCD(val
& 0x7F);
293 if (tmp
>= 0 && tmp
<= 59) {
294 get_time(NVRAM
, &tm
);
296 set_time(NVRAM
, &tm
);
301 tmp
= fromBCD(val
& 0x3F);
302 if (tmp
>= 0 && tmp
<= 23) {
303 get_time(NVRAM
, &tm
);
305 set_time(NVRAM
, &tm
);
309 /* day of the week / century */
310 tmp
= fromBCD(val
& 0x07);
311 get_time(NVRAM
, &tm
);
313 set_time(NVRAM
, &tm
);
314 NVRAM
->buffer
[0x1FFC] = val
& 0x40;
318 tmp
= fromBCD(val
& 0x1F);
320 get_time(NVRAM
, &tm
);
322 set_time(NVRAM
, &tm
);
327 tmp
= fromBCD(val
& 0x1F);
328 if (tmp
>= 1 && tmp
<= 12) {
329 get_time(NVRAM
, &tm
);
331 set_time(NVRAM
, &tm
);
337 if (tmp
>= 0 && tmp
<= 99) {
338 get_time(NVRAM
, &tm
);
339 if (NVRAM
->type
== 8)
340 tm
.tm_year
= fromBCD(val
) + 68; // Base year is 1968
342 tm
.tm_year
= fromBCD(val
);
343 set_time(NVRAM
, &tm
);
347 /* Check lock registers state */
348 if (addr
>= 0x20 && addr
<= 0x2F && (NVRAM
->lock
& 1))
350 if (addr
>= 0x30 && addr
<= 0x3F && (NVRAM
->lock
& 2))
353 if (addr
< NVRAM
->size
) {
354 NVRAM
->buffer
[addr
] = val
& 0xFF;
360 uint32_t m48t59_read (m48t59_t
*NVRAM
, uint32_t addr
)
363 uint32_t retval
= 0xFF;
365 if (NVRAM
->type
== 8 &&
366 (addr
>= 0x1ff0 && addr
<= 0x1ff7))
392 /* A read resets the watchdog */
393 set_up_watchdog(NVRAM
, NVRAM
->buffer
[0x1FF7]);
400 get_time(NVRAM
, &tm
);
401 retval
= (NVRAM
->buffer
[0x1FF9] & 0x80) | toBCD(tm
.tm_sec
);
405 get_time(NVRAM
, &tm
);
406 retval
= toBCD(tm
.tm_min
);
410 get_time(NVRAM
, &tm
);
411 retval
= toBCD(tm
.tm_hour
);
414 /* day of the week / century */
415 get_time(NVRAM
, &tm
);
416 retval
= NVRAM
->buffer
[0x1FFC] | tm
.tm_wday
;
420 get_time(NVRAM
, &tm
);
421 retval
= toBCD(tm
.tm_mday
);
425 get_time(NVRAM
, &tm
);
426 retval
= toBCD(tm
.tm_mon
+ 1);
430 get_time(NVRAM
, &tm
);
431 if (NVRAM
->type
== 8)
432 retval
= toBCD(tm
.tm_year
- 68); // Base year is 1968
434 retval
= toBCD(tm
.tm_year
);
437 /* Check lock registers state */
438 if (addr
>= 0x20 && addr
<= 0x2F && (NVRAM
->lock
& 1))
440 if (addr
>= 0x30 && addr
<= 0x3F && (NVRAM
->lock
& 2))
443 if (addr
< NVRAM
->size
) {
444 retval
= NVRAM
->buffer
[addr
];
448 if (addr
> 0x1FF9 && addr
< 0x2000)
449 NVRAM_PRINTF("0x%08x <= 0x%08x\n", addr
, retval
);
454 void m48t59_set_addr (m48t59_t
*NVRAM
, uint32_t addr
)
459 void m48t59_toggle_lock (m48t59_t
*NVRAM
, int lock
)
461 NVRAM
->lock
^= 1 << lock
;
464 /* IO access to NVRAM */
465 static void NVRAM_writeb (void *opaque
, uint32_t addr
, uint32_t val
)
467 m48t59_t
*NVRAM
= opaque
;
469 addr
-= NVRAM
->io_base
;
470 NVRAM_PRINTF("0x%08x => 0x%08x\n", addr
, val
);
473 NVRAM
->addr
&= ~0x00FF;
477 NVRAM
->addr
&= ~0xFF00;
478 NVRAM
->addr
|= val
<< 8;
481 m48t59_write(NVRAM
, val
, NVRAM
->addr
);
482 NVRAM
->addr
= 0x0000;
489 static uint32_t NVRAM_readb (void *opaque
, uint32_t addr
)
491 m48t59_t
*NVRAM
= opaque
;
494 addr
-= NVRAM
->io_base
;
497 retval
= m48t59_read(NVRAM
, NVRAM
->addr
);
503 NVRAM_PRINTF("0x%08x <= 0x%08x\n", addr
, retval
);
508 static void nvram_writeb (void *opaque
, target_phys_addr_t addr
, uint32_t value
)
510 m48t59_t
*NVRAM
= opaque
;
512 addr
-= NVRAM
->mem_base
;
513 m48t59_write(NVRAM
, addr
, value
& 0xff);
516 static void nvram_writew (void *opaque
, target_phys_addr_t addr
, uint32_t value
)
518 m48t59_t
*NVRAM
= opaque
;
520 addr
-= NVRAM
->mem_base
;
521 m48t59_write(NVRAM
, addr
, (value
>> 8) & 0xff);
522 m48t59_write(NVRAM
, addr
+ 1, value
& 0xff);
525 static void nvram_writel (void *opaque
, target_phys_addr_t addr
, uint32_t value
)
527 m48t59_t
*NVRAM
= opaque
;
529 addr
-= NVRAM
->mem_base
;
530 m48t59_write(NVRAM
, addr
, (value
>> 24) & 0xff);
531 m48t59_write(NVRAM
, addr
+ 1, (value
>> 16) & 0xff);
532 m48t59_write(NVRAM
, addr
+ 2, (value
>> 8) & 0xff);
533 m48t59_write(NVRAM
, addr
+ 3, value
& 0xff);
536 static uint32_t nvram_readb (void *opaque
, target_phys_addr_t addr
)
538 m48t59_t
*NVRAM
= opaque
;
541 addr
-= NVRAM
->mem_base
;
542 retval
= m48t59_read(NVRAM
, addr
);
546 static uint32_t nvram_readw (void *opaque
, target_phys_addr_t addr
)
548 m48t59_t
*NVRAM
= opaque
;
551 addr
-= NVRAM
->mem_base
;
552 retval
= m48t59_read(NVRAM
, addr
) << 8;
553 retval
|= m48t59_read(NVRAM
, addr
+ 1);
557 static uint32_t nvram_readl (void *opaque
, target_phys_addr_t addr
)
559 m48t59_t
*NVRAM
= opaque
;
562 addr
-= NVRAM
->mem_base
;
563 retval
= m48t59_read(NVRAM
, addr
) << 24;
564 retval
|= m48t59_read(NVRAM
, addr
+ 1) << 16;
565 retval
|= m48t59_read(NVRAM
, addr
+ 2) << 8;
566 retval
|= m48t59_read(NVRAM
, addr
+ 3);
570 static CPUWriteMemoryFunc
*nvram_write
[] = {
576 static CPUReadMemoryFunc
*nvram_read
[] = {
582 static void m48t59_save(QEMUFile
*f
, void *opaque
)
584 m48t59_t
*s
= opaque
;
586 qemu_put_8s(f
, &s
->lock
);
587 qemu_put_be16s(f
, &s
->addr
);
588 qemu_put_buffer(f
, s
->buffer
, s
->size
);
591 static int m48t59_load(QEMUFile
*f
, void *opaque
, int version_id
)
593 m48t59_t
*s
= opaque
;
598 qemu_get_8s(f
, &s
->lock
);
599 qemu_get_be16s(f
, &s
->addr
);
600 qemu_get_buffer(f
, s
->buffer
, s
->size
);
605 static void m48t59_reset(void *opaque
)
607 m48t59_t
*NVRAM
= opaque
;
609 if (NVRAM
->alrm_timer
!= NULL
)
610 qemu_del_timer(NVRAM
->alrm_timer
);
612 if (NVRAM
->wd_timer
!= NULL
)
613 qemu_del_timer(NVRAM
->wd_timer
);
616 /* Initialisation routine */
617 m48t59_t
*m48t59_init (qemu_irq IRQ
, target_phys_addr_t mem_base
,
618 uint32_t io_base
, uint16_t size
,
622 target_phys_addr_t save_base
;
624 s
= qemu_mallocz(sizeof(m48t59_t
));
627 s
->buffer
= qemu_mallocz(size
);
634 s
->mem_base
= mem_base
;
635 s
->io_base
= io_base
;
639 register_ioport_read(io_base
, 0x04, 1, NVRAM_readb
, s
);
640 register_ioport_write(io_base
, 0x04, 1, NVRAM_writeb
, s
);
643 s
->mem_index
= cpu_register_io_memory(0, nvram_read
, nvram_write
, s
);
644 cpu_register_physical_memory(mem_base
, 0x4000, s
->mem_index
);
647 s
->alrm_timer
= qemu_new_timer(vm_clock
, &alarm_cb
, s
);
648 s
->wd_timer
= qemu_new_timer(vm_clock
, &watchdog_cb
, s
);
652 qemu_register_reset(m48t59_reset
, s
);
653 save_base
= mem_base
? mem_base
: io_base
;
654 register_savevm("m48t59", save_base
, 1, m48t59_save
, m48t59_load
, s
);