2 * QEMU M48T59 and M48T08 NVRAM emulation for PPC PREP and Sparc platforms
4 * Copyright (c) 2003-2005, 2007 Jocelyn Mayer
5 * Copyright (c) 2013 Hervé Poussineau
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #include "hw/timer/m48t59.h"
27 #include "qemu/timer.h"
28 #include "sysemu/sysemu.h"
29 #include "hw/sysbus.h"
30 #include "hw/isa/isa.h"
31 #include "exec/address-spaces.h"
35 #if defined(DEBUG_NVRAM)
36 #define NVRAM_PRINTF(fmt, ...) do { printf(fmt , ## __VA_ARGS__); } while (0)
38 #define NVRAM_PRINTF(fmt, ...) do { } while (0)
41 #define TYPE_M48TXX_SYS_BUS "sysbus-m48txx"
42 #define M48TXX_SYS_BUS_GET_CLASS(obj) \
43 OBJECT_GET_CLASS(M48txxSysBusDeviceClass, (obj), TYPE_M48TXX_SYS_BUS)
44 #define M48TXX_SYS_BUS_CLASS(klass) \
45 OBJECT_CLASS_CHECK(M48txxSysBusDeviceClass, (klass), TYPE_M48TXX_SYS_BUS)
46 #define M48TXX_SYS_BUS(obj) \
47 OBJECT_CHECK(M48txxSysBusState, (obj), TYPE_M48TXX_SYS_BUS)
49 #define TYPE_M48TXX_ISA "isa-m48txx"
50 #define M48TXX_ISA_GET_CLASS(obj) \
51 OBJECT_GET_CLASS(M48txxISADeviceClass, (obj), TYPE_M48TXX_ISA)
52 #define M48TXX_ISA_CLASS(klass) \
53 OBJECT_CLASS_CHECK(M48txxISADeviceClass, (klass), TYPE_M48TXX_ISA)
54 #define M48TXX_ISA(obj) \
55 OBJECT_CHECK(M48txxISAState, (obj), TYPE_M48TXX_ISA)
58 * The M48T02, M48T08 and M48T59 chips are very similar. The newer '59 has
59 * alarm and a watchdog timer and related control registers. In the
60 * PPC platform there is also a nvram lock function.
63 typedef struct M48txxInfo
{
65 const char *sysbus_name
;
66 uint32_t model
; /* 2 = m48t02, 8 = m48t08, 59 = m48t59 */
72 * http://www.st.com/stonline/products/literature/ds/2410/m48t02.pdf
73 * http://www.st.com/stonline/products/literature/ds/2411/m48t08.pdf
74 * http://www.st.com/stonline/products/literature/od/7001/m48t59y.pdf
77 typedef struct M48t59State
{
78 /* Hardware parameters */
86 /* Alarm & watchdog */
88 QEMUTimer
*alrm_timer
;
92 /* Model parameters */
93 uint32_t model
; /* 2 = m48t02, 8 = m48t08, 59 = m48t59 */
99 typedef struct M48txxISAState
{
100 ISADevice parent_obj
;
106 typedef struct M48txxISADeviceClass
{
107 ISADeviceClass parent_class
;
109 } M48txxISADeviceClass
;
111 typedef struct M48txxSysBusState
{
112 SysBusDevice parent_obj
;
117 typedef struct M48txxSysBusDeviceClass
{
118 SysBusDeviceClass parent_class
;
120 } M48txxSysBusDeviceClass
;
122 static M48txxInfo m48txx_info
[] = {
124 .sysbus_name
= "sysbus-m48t02",
128 .sysbus_name
= "sysbus-m48t08",
132 .isa_name
= "isa-m48t59",
139 /* Fake timer functions */
141 /* Alarm management */
142 static void alarm_cb (void *opaque
)
146 M48t59State
*NVRAM
= opaque
;
148 qemu_set_irq(NVRAM
->IRQ
, 1);
149 if ((NVRAM
->buffer
[0x1FF5] & 0x80) == 0 &&
150 (NVRAM
->buffer
[0x1FF4] & 0x80) == 0 &&
151 (NVRAM
->buffer
[0x1FF3] & 0x80) == 0 &&
152 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
153 /* Repeat once a month */
154 qemu_get_timedate(&tm
, NVRAM
->time_offset
);
156 if (tm
.tm_mon
== 13) {
160 next_time
= qemu_timedate_diff(&tm
) - NVRAM
->time_offset
;
161 } else if ((NVRAM
->buffer
[0x1FF5] & 0x80) != 0 &&
162 (NVRAM
->buffer
[0x1FF4] & 0x80) == 0 &&
163 (NVRAM
->buffer
[0x1FF3] & 0x80) == 0 &&
164 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
165 /* Repeat once a day */
166 next_time
= 24 * 60 * 60;
167 } else if ((NVRAM
->buffer
[0x1FF5] & 0x80) != 0 &&
168 (NVRAM
->buffer
[0x1FF4] & 0x80) != 0 &&
169 (NVRAM
->buffer
[0x1FF3] & 0x80) == 0 &&
170 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
171 /* Repeat once an hour */
173 } else if ((NVRAM
->buffer
[0x1FF5] & 0x80) != 0 &&
174 (NVRAM
->buffer
[0x1FF4] & 0x80) != 0 &&
175 (NVRAM
->buffer
[0x1FF3] & 0x80) != 0 &&
176 (NVRAM
->buffer
[0x1FF2] & 0x80) == 0) {
177 /* Repeat once a minute */
180 /* Repeat once a second */
183 timer_mod(NVRAM
->alrm_timer
, qemu_clock_get_ns(rtc_clock
) +
185 qemu_set_irq(NVRAM
->IRQ
, 0);
188 static void set_alarm(M48t59State
*NVRAM
)
191 if (NVRAM
->alrm_timer
!= NULL
) {
192 timer_del(NVRAM
->alrm_timer
);
193 diff
= qemu_timedate_diff(&NVRAM
->alarm
) - NVRAM
->time_offset
;
195 timer_mod(NVRAM
->alrm_timer
, diff
* 1000);
199 /* RTC management helpers */
200 static inline void get_time(M48t59State
*NVRAM
, struct tm
*tm
)
202 qemu_get_timedate(tm
, NVRAM
->time_offset
);
205 static void set_time(M48t59State
*NVRAM
, struct tm
*tm
)
207 NVRAM
->time_offset
= qemu_timedate_diff(tm
);
211 /* Watchdog management */
212 static void watchdog_cb (void *opaque
)
214 M48t59State
*NVRAM
= opaque
;
216 NVRAM
->buffer
[0x1FF0] |= 0x80;
217 if (NVRAM
->buffer
[0x1FF7] & 0x80) {
218 NVRAM
->buffer
[0x1FF7] = 0x00;
219 NVRAM
->buffer
[0x1FFC] &= ~0x40;
220 /* May it be a hw CPU Reset instead ? */
221 qemu_system_reset_request();
223 qemu_set_irq(NVRAM
->IRQ
, 1);
224 qemu_set_irq(NVRAM
->IRQ
, 0);
228 static void set_up_watchdog(M48t59State
*NVRAM
, uint8_t value
)
230 uint64_t interval
; /* in 1/16 seconds */
232 NVRAM
->buffer
[0x1FF0] &= ~0x80;
233 if (NVRAM
->wd_timer
!= NULL
) {
234 timer_del(NVRAM
->wd_timer
);
236 interval
= (1 << (2 * (value
& 0x03))) * ((value
>> 2) & 0x1F);
237 timer_mod(NVRAM
->wd_timer
, ((uint64_t)time(NULL
) * 1000) +
238 ((interval
* 1000) >> 4));
243 /* Direct access to NVRAM */
244 static void m48t59_write(M48t59State
*NVRAM
, uint32_t addr
, uint32_t val
)
249 if (addr
> 0x1FF8 && addr
< 0x2000)
250 NVRAM_PRINTF("%s: 0x%08x => 0x%08x\n", __func__
, addr
, val
);
252 /* check for NVRAM access */
253 if ((NVRAM
->model
== 2 && addr
< 0x7f8) ||
254 (NVRAM
->model
== 8 && addr
< 0x1ff8) ||
255 (NVRAM
->model
== 59 && addr
< 0x1ff0)) {
262 /* flags register : read-only */
269 tmp
= from_bcd(val
& 0x7F);
270 if (tmp
>= 0 && tmp
<= 59) {
271 NVRAM
->alarm
.tm_sec
= tmp
;
272 NVRAM
->buffer
[0x1FF2] = val
;
278 tmp
= from_bcd(val
& 0x7F);
279 if (tmp
>= 0 && tmp
<= 59) {
280 NVRAM
->alarm
.tm_min
= tmp
;
281 NVRAM
->buffer
[0x1FF3] = val
;
287 tmp
= from_bcd(val
& 0x3F);
288 if (tmp
>= 0 && tmp
<= 23) {
289 NVRAM
->alarm
.tm_hour
= tmp
;
290 NVRAM
->buffer
[0x1FF4] = val
;
296 tmp
= from_bcd(val
& 0x3F);
298 NVRAM
->alarm
.tm_mday
= tmp
;
299 NVRAM
->buffer
[0x1FF5] = val
;
305 NVRAM
->buffer
[0x1FF6] = val
;
309 NVRAM
->buffer
[0x1FF7] = val
;
310 set_up_watchdog(NVRAM
, val
);
315 NVRAM
->buffer
[addr
] = (val
& ~0xA0) | 0x90;
320 tmp
= from_bcd(val
& 0x7F);
321 if (tmp
>= 0 && tmp
<= 59) {
322 get_time(NVRAM
, &tm
);
324 set_time(NVRAM
, &tm
);
326 if ((val
& 0x80) ^ (NVRAM
->buffer
[addr
] & 0x80)) {
328 NVRAM
->stop_time
= time(NULL
);
330 NVRAM
->time_offset
+= NVRAM
->stop_time
- time(NULL
);
331 NVRAM
->stop_time
= 0;
334 NVRAM
->buffer
[addr
] = val
& 0x80;
339 tmp
= from_bcd(val
& 0x7F);
340 if (tmp
>= 0 && tmp
<= 59) {
341 get_time(NVRAM
, &tm
);
343 set_time(NVRAM
, &tm
);
349 tmp
= from_bcd(val
& 0x3F);
350 if (tmp
>= 0 && tmp
<= 23) {
351 get_time(NVRAM
, &tm
);
353 set_time(NVRAM
, &tm
);
358 /* day of the week / century */
359 tmp
= from_bcd(val
& 0x07);
360 get_time(NVRAM
, &tm
);
362 set_time(NVRAM
, &tm
);
363 NVRAM
->buffer
[addr
] = val
& 0x40;
368 tmp
= from_bcd(val
& 0x3F);
370 get_time(NVRAM
, &tm
);
372 set_time(NVRAM
, &tm
);
378 tmp
= from_bcd(val
& 0x1F);
379 if (tmp
>= 1 && tmp
<= 12) {
380 get_time(NVRAM
, &tm
);
382 set_time(NVRAM
, &tm
);
389 if (tmp
>= 0 && tmp
<= 99) {
390 get_time(NVRAM
, &tm
);
391 tm
.tm_year
= from_bcd(val
) + NVRAM
->base_year
- 1900;
392 set_time(NVRAM
, &tm
);
396 /* Check lock registers state */
397 if (addr
>= 0x20 && addr
<= 0x2F && (NVRAM
->lock
& 1))
399 if (addr
>= 0x30 && addr
<= 0x3F && (NVRAM
->lock
& 2))
402 if (addr
< NVRAM
->size
) {
403 NVRAM
->buffer
[addr
] = val
& 0xFF;
409 static uint32_t m48t59_read(M48t59State
*NVRAM
, uint32_t addr
)
412 uint32_t retval
= 0xFF;
414 /* check for NVRAM access */
415 if ((NVRAM
->model
== 2 && addr
< 0x078f) ||
416 (NVRAM
->model
== 8 && addr
< 0x1ff8) ||
417 (NVRAM
->model
== 59 && addr
< 0x1ff0)) {
446 /* A read resets the watchdog */
447 set_up_watchdog(NVRAM
, NVRAM
->buffer
[0x1FF7]);
456 get_time(NVRAM
, &tm
);
457 retval
= (NVRAM
->buffer
[addr
] & 0x80) | to_bcd(tm
.tm_sec
);
462 get_time(NVRAM
, &tm
);
463 retval
= to_bcd(tm
.tm_min
);
468 get_time(NVRAM
, &tm
);
469 retval
= to_bcd(tm
.tm_hour
);
473 /* day of the week / century */
474 get_time(NVRAM
, &tm
);
475 retval
= NVRAM
->buffer
[addr
] | tm
.tm_wday
;
480 get_time(NVRAM
, &tm
);
481 retval
= to_bcd(tm
.tm_mday
);
486 get_time(NVRAM
, &tm
);
487 retval
= to_bcd(tm
.tm_mon
+ 1);
492 get_time(NVRAM
, &tm
);
493 retval
= to_bcd((tm
.tm_year
+ 1900 - NVRAM
->base_year
) % 100);
496 /* Check lock registers state */
497 if (addr
>= 0x20 && addr
<= 0x2F && (NVRAM
->lock
& 1))
499 if (addr
>= 0x30 && addr
<= 0x3F && (NVRAM
->lock
& 2))
502 if (addr
< NVRAM
->size
) {
503 retval
= NVRAM
->buffer
[addr
];
507 if (addr
> 0x1FF9 && addr
< 0x2000)
508 NVRAM_PRINTF("%s: 0x%08x <= 0x%08x\n", __func__
, addr
, retval
);
513 static void m48t59_toggle_lock(M48t59State
*NVRAM
, int lock
)
515 NVRAM
->lock
^= 1 << lock
;
518 /* IO access to NVRAM */
519 static void NVRAM_writeb(void *opaque
, hwaddr addr
, uint64_t val
,
522 M48t59State
*NVRAM
= opaque
;
524 NVRAM_PRINTF("%s: 0x%08x => 0x%08x\n", __func__
, addr
, val
);
527 NVRAM
->addr
&= ~0x00FF;
531 NVRAM
->addr
&= ~0xFF00;
532 NVRAM
->addr
|= val
<< 8;
535 m48t59_write(NVRAM
, NVRAM
->addr
, val
);
536 NVRAM
->addr
= 0x0000;
543 static uint64_t NVRAM_readb(void *opaque
, hwaddr addr
, unsigned size
)
545 M48t59State
*NVRAM
= opaque
;
550 retval
= m48t59_read(NVRAM
, NVRAM
->addr
);
556 NVRAM_PRINTF("%s: 0x%08x <= 0x%08x\n", __func__
, addr
, retval
);
561 static void nvram_writeb (void *opaque
, hwaddr addr
, uint32_t value
)
563 M48t59State
*NVRAM
= opaque
;
565 m48t59_write(NVRAM
, addr
, value
& 0xff);
568 static void nvram_writew (void *opaque
, hwaddr addr
, uint32_t value
)
570 M48t59State
*NVRAM
= opaque
;
572 m48t59_write(NVRAM
, addr
, (value
>> 8) & 0xff);
573 m48t59_write(NVRAM
, addr
+ 1, value
& 0xff);
576 static void nvram_writel (void *opaque
, hwaddr addr
, uint32_t value
)
578 M48t59State
*NVRAM
= opaque
;
580 m48t59_write(NVRAM
, addr
, (value
>> 24) & 0xff);
581 m48t59_write(NVRAM
, addr
+ 1, (value
>> 16) & 0xff);
582 m48t59_write(NVRAM
, addr
+ 2, (value
>> 8) & 0xff);
583 m48t59_write(NVRAM
, addr
+ 3, value
& 0xff);
586 static uint32_t nvram_readb (void *opaque
, hwaddr addr
)
588 M48t59State
*NVRAM
= opaque
;
591 retval
= m48t59_read(NVRAM
, addr
);
595 static uint32_t nvram_readw (void *opaque
, hwaddr addr
)
597 M48t59State
*NVRAM
= opaque
;
600 retval
= m48t59_read(NVRAM
, addr
) << 8;
601 retval
|= m48t59_read(NVRAM
, addr
+ 1);
605 static uint32_t nvram_readl (void *opaque
, hwaddr addr
)
607 M48t59State
*NVRAM
= opaque
;
610 retval
= m48t59_read(NVRAM
, addr
) << 24;
611 retval
|= m48t59_read(NVRAM
, addr
+ 1) << 16;
612 retval
|= m48t59_read(NVRAM
, addr
+ 2) << 8;
613 retval
|= m48t59_read(NVRAM
, addr
+ 3);
617 static const MemoryRegionOps nvram_ops
= {
619 .read
= { nvram_readb
, nvram_readw
, nvram_readl
, },
620 .write
= { nvram_writeb
, nvram_writew
, nvram_writel
, },
622 .endianness
= DEVICE_NATIVE_ENDIAN
,
625 static const VMStateDescription vmstate_m48t59
= {
628 .minimum_version_id
= 1,
629 .fields
= (VMStateField
[]) {
630 VMSTATE_UINT8(lock
, M48t59State
),
631 VMSTATE_UINT16(addr
, M48t59State
),
632 VMSTATE_VBUFFER_UINT32(buffer
, M48t59State
, 0, NULL
, 0, size
),
633 VMSTATE_END_OF_LIST()
637 static void m48t59_reset_common(M48t59State
*NVRAM
)
641 if (NVRAM
->alrm_timer
!= NULL
)
642 timer_del(NVRAM
->alrm_timer
);
644 if (NVRAM
->wd_timer
!= NULL
)
645 timer_del(NVRAM
->wd_timer
);
648 static void m48t59_reset_isa(DeviceState
*d
)
650 M48txxISAState
*isa
= M48TXX_ISA(d
);
651 M48t59State
*NVRAM
= &isa
->state
;
653 m48t59_reset_common(NVRAM
);
656 static void m48t59_reset_sysbus(DeviceState
*d
)
658 M48txxSysBusState
*sys
= M48TXX_SYS_BUS(d
);
659 M48t59State
*NVRAM
= &sys
->state
;
661 m48t59_reset_common(NVRAM
);
664 static const MemoryRegionOps m48t59_io_ops
= {
666 .write
= NVRAM_writeb
,
668 .min_access_size
= 1,
669 .max_access_size
= 1,
671 .endianness
= DEVICE_LITTLE_ENDIAN
,
674 /* Initialisation routine */
675 Nvram
*m48t59_init(qemu_irq IRQ
, hwaddr mem_base
,
676 uint32_t io_base
, uint16_t size
, int base_year
,
683 for (i
= 0; i
< ARRAY_SIZE(m48txx_info
); i
++) {
684 if (!m48txx_info
[i
].sysbus_name
||
685 m48txx_info
[i
].size
!= size
||
686 m48txx_info
[i
].model
!= model
) {
690 dev
= qdev_create(NULL
, m48txx_info
[i
].sysbus_name
);
691 qdev_prop_set_int32(dev
, "base-year", base_year
);
692 qdev_init_nofail(dev
);
693 s
= SYS_BUS_DEVICE(dev
);
694 sysbus_connect_irq(s
, 0, IRQ
);
696 memory_region_add_subregion(get_system_io(), io_base
,
697 sysbus_mmio_get_region(s
, 1));
700 sysbus_mmio_map(s
, 0, mem_base
);
710 Nvram
*m48t59_init_isa(ISABus
*bus
, uint32_t io_base
, uint16_t size
,
711 int base_year
, int model
)
716 for (i
= 0; i
< ARRAY_SIZE(m48txx_info
); i
++) {
717 if (!m48txx_info
[i
].isa_name
||
718 m48txx_info
[i
].size
!= size
||
719 m48txx_info
[i
].model
!= model
) {
723 dev
= DEVICE(isa_create(bus
, m48txx_info
[i
].isa_name
));
724 qdev_prop_set_uint32(dev
, "iobase", io_base
);
725 qdev_prop_set_int32(dev
, "base-year", base_year
);
726 qdev_init_nofail(dev
);
734 static void m48t59_realize_common(M48t59State
*s
, Error
**errp
)
736 s
->buffer
= g_malloc0(s
->size
);
737 if (s
->model
== 59) {
738 s
->alrm_timer
= timer_new_ns(rtc_clock
, &alarm_cb
, s
);
739 s
->wd_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, &watchdog_cb
, s
);
741 qemu_get_timedate(&s
->alarm
, 0);
743 vmstate_register(NULL
, -1, &vmstate_m48t59
, s
);
746 static void m48t59_isa_realize(DeviceState
*dev
, Error
**errp
)
748 M48txxISADeviceClass
*u
= M48TXX_ISA_GET_CLASS(dev
);
749 ISADevice
*isadev
= ISA_DEVICE(dev
);
750 M48txxISAState
*d
= M48TXX_ISA(dev
);
751 M48t59State
*s
= &d
->state
;
753 s
->model
= u
->info
.model
;
754 s
->size
= u
->info
.size
;
755 isa_init_irq(isadev
, &s
->IRQ
, 8);
756 m48t59_realize_common(s
, errp
);
757 memory_region_init_io(&d
->io
, OBJECT(dev
), &m48t59_io_ops
, s
, "m48t59", 4);
758 if (d
->io_base
!= 0) {
759 isa_register_ioport(isadev
, &d
->io
, d
->io_base
);
763 static int m48t59_init1(SysBusDevice
*dev
)
765 M48txxSysBusDeviceClass
*u
= M48TXX_SYS_BUS_GET_CLASS(dev
);
766 M48txxSysBusState
*d
= M48TXX_SYS_BUS(dev
);
767 Object
*o
= OBJECT(dev
);
768 M48t59State
*s
= &d
->state
;
771 s
->model
= u
->info
.model
;
772 s
->size
= u
->info
.size
;
773 sysbus_init_irq(dev
, &s
->IRQ
);
775 memory_region_init_io(&s
->iomem
, o
, &nvram_ops
, s
, "m48t59.nvram",
777 memory_region_init_io(&d
->io
, o
, &m48t59_io_ops
, s
, "m48t59", 4);
778 sysbus_init_mmio(dev
, &s
->iomem
);
779 sysbus_init_mmio(dev
, &d
->io
);
780 m48t59_realize_common(s
, &err
);
789 static uint32_t m48txx_isa_read(Nvram
*obj
, uint32_t addr
)
791 M48txxISAState
*d
= M48TXX_ISA(obj
);
792 return m48t59_read(&d
->state
, addr
);
795 static void m48txx_isa_write(Nvram
*obj
, uint32_t addr
, uint32_t val
)
797 M48txxISAState
*d
= M48TXX_ISA(obj
);
798 m48t59_write(&d
->state
, addr
, val
);
801 static void m48txx_isa_toggle_lock(Nvram
*obj
, int lock
)
803 M48txxISAState
*d
= M48TXX_ISA(obj
);
804 m48t59_toggle_lock(&d
->state
, lock
);
807 static Property m48t59_isa_properties
[] = {
808 DEFINE_PROP_INT32("base-year", M48txxISAState
, state
.base_year
, 0),
809 DEFINE_PROP_UINT32("iobase", M48txxISAState
, io_base
, 0x74),
810 DEFINE_PROP_END_OF_LIST(),
813 static void m48txx_isa_class_init(ObjectClass
*klass
, void *data
)
815 DeviceClass
*dc
= DEVICE_CLASS(klass
);
816 NvramClass
*nc
= NVRAM_CLASS(klass
);
818 dc
->realize
= m48t59_isa_realize
;
819 dc
->reset
= m48t59_reset_isa
;
820 dc
->props
= m48t59_isa_properties
;
821 nc
->read
= m48txx_isa_read
;
822 nc
->write
= m48txx_isa_write
;
823 nc
->toggle_lock
= m48txx_isa_toggle_lock
;
826 static void m48txx_isa_concrete_class_init(ObjectClass
*klass
, void *data
)
828 M48txxISADeviceClass
*u
= M48TXX_ISA_CLASS(klass
);
829 M48txxInfo
*info
= data
;
834 static uint32_t m48txx_sysbus_read(Nvram
*obj
, uint32_t addr
)
836 M48txxSysBusState
*d
= M48TXX_SYS_BUS(obj
);
837 return m48t59_read(&d
->state
, addr
);
840 static void m48txx_sysbus_write(Nvram
*obj
, uint32_t addr
, uint32_t val
)
842 M48txxSysBusState
*d
= M48TXX_SYS_BUS(obj
);
843 m48t59_write(&d
->state
, addr
, val
);
846 static void m48txx_sysbus_toggle_lock(Nvram
*obj
, int lock
)
848 M48txxSysBusState
*d
= M48TXX_SYS_BUS(obj
);
849 m48t59_toggle_lock(&d
->state
, lock
);
852 static Property m48t59_sysbus_properties
[] = {
853 DEFINE_PROP_INT32("base-year", M48txxSysBusState
, state
.base_year
, 0),
854 DEFINE_PROP_END_OF_LIST(),
857 static void m48txx_sysbus_class_init(ObjectClass
*klass
, void *data
)
859 DeviceClass
*dc
= DEVICE_CLASS(klass
);
860 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
861 NvramClass
*nc
= NVRAM_CLASS(klass
);
863 k
->init
= m48t59_init1
;
864 dc
->reset
= m48t59_reset_sysbus
;
865 dc
->props
= m48t59_sysbus_properties
;
866 nc
->read
= m48txx_sysbus_read
;
867 nc
->write
= m48txx_sysbus_write
;
868 nc
->toggle_lock
= m48txx_sysbus_toggle_lock
;
871 static void m48txx_sysbus_concrete_class_init(ObjectClass
*klass
, void *data
)
873 M48txxSysBusDeviceClass
*u
= M48TXX_SYS_BUS_CLASS(klass
);
874 M48txxInfo
*info
= data
;
879 static const TypeInfo nvram_info
= {
881 .parent
= TYPE_INTERFACE
,
882 .class_size
= sizeof(NvramClass
),
885 static const TypeInfo m48txx_sysbus_type_info
= {
886 .name
= TYPE_M48TXX_SYS_BUS
,
887 .parent
= TYPE_SYS_BUS_DEVICE
,
888 .instance_size
= sizeof(M48txxSysBusState
),
890 .class_init
= m48txx_sysbus_class_init
,
891 .interfaces
= (InterfaceInfo
[]) {
897 static const TypeInfo m48txx_isa_type_info
= {
898 .name
= TYPE_M48TXX_ISA
,
899 .parent
= TYPE_ISA_DEVICE
,
900 .instance_size
= sizeof(M48txxISAState
),
902 .class_init
= m48txx_isa_class_init
,
903 .interfaces
= (InterfaceInfo
[]) {
909 static void m48t59_register_types(void)
911 TypeInfo sysbus_type_info
= {
912 .parent
= TYPE_M48TXX_SYS_BUS
,
913 .class_size
= sizeof(M48txxSysBusDeviceClass
),
914 .class_init
= m48txx_sysbus_concrete_class_init
,
916 TypeInfo isa_type_info
= {
917 .parent
= TYPE_M48TXX_ISA
,
918 .class_size
= sizeof(M48txxISADeviceClass
),
919 .class_init
= m48txx_isa_concrete_class_init
,
923 type_register_static(&nvram_info
);
924 type_register_static(&m48txx_sysbus_type_info
);
925 type_register_static(&m48txx_isa_type_info
);
927 for (i
= 0; i
< ARRAY_SIZE(m48txx_info
); i
++) {
928 if (m48txx_info
[i
].sysbus_name
) {
929 sysbus_type_info
.name
= m48txx_info
[i
].sysbus_name
;
930 sysbus_type_info
.class_data
= &m48txx_info
[i
];
931 type_register(&sysbus_type_info
);
934 if (m48txx_info
[i
].isa_name
) {
935 isa_type_info
.name
= m48txx_info
[i
].isa_name
;
936 isa_type_info
.class_data
= &m48txx_info
[i
];
937 type_register(&isa_type_info
);
942 type_init(m48t59_register_types
)