2 * QEMU PowerMac PMU device support
4 * Copyright (c) 2016 Benjamin Herrenschmidt, IBM Corp.
5 * Copyright (c) 2018 Mark Cave-Ayland
7 * Based on the CUDA device by:
9 * Copyright (c) 2004-2007 Fabrice Bellard
10 * Copyright (c) 2007 Jocelyn Mayer
12 * Permission is hereby granted, free of charge, to any person obtaining a copy
13 * of this software and associated documentation files (the "Software"), to deal
14 * in the Software without restriction, including without limitation the rights
15 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16 * copies of the Software, and to permit persons to whom the Software is
17 * furnished to do so, subject to the following conditions:
19 * The above copyright notice and this permission notice shall be included in
20 * all copies or substantial portions of the Software.
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
31 #include "qemu/osdep.h"
32 #include "hw/qdev-properties.h"
33 #include "migration/vmstate.h"
35 #include "hw/misc/macio/pmu.h"
36 #include "qemu/timer.h"
37 #include "sysemu/runstate.h"
38 #include "sysemu/rtc.h"
39 #include "qapi/error.h"
40 #include "qemu/cutils.h"
42 #include "qemu/module.h"
46 /* Bits in B data register: all active low */
47 #define TACK 0x08 /* Transfer request (input) */
48 #define TREQ 0x10 /* Transfer acknowledge (output) */
50 /* PMU returns time_t's offset from Jan 1, 1904, not 1970 */
51 #define RTC_OFFSET 2082844800
53 #define VIA_TIMER_FREQ (4700000 / 6)
55 static void via_set_sr_int(void *opaque
)
58 MOS6522PMUState
*mps
= MOS6522_PMU(&s
->mos6522_pmu
);
59 MOS6522State
*ms
= MOS6522(mps
);
60 qemu_irq irq
= qdev_get_gpio_in(DEVICE(ms
), SR_INT_BIT
);
65 static void pmu_update_extirq(PMUState
*s
)
67 if ((s
->intbits
& s
->intmask
) != 0) {
68 macio_set_gpio(s
->gpio
, 1, false);
70 macio_set_gpio(s
->gpio
, 1, true);
74 static void pmu_adb_poll(void *opaque
)
77 ADBBusState
*adb_bus
= &s
->adb_bus
;
80 if (!(s
->intbits
& PMU_INT_ADB
)) {
81 olen
= adb_poll(adb_bus
, s
->adb_reply
, adb_bus
->autopoll_mask
);
82 trace_pmu_adb_poll(olen
);
85 s
->adb_reply_size
= olen
;
86 s
->intbits
|= PMU_INT_ADB
| PMU_INT_ADB_AUTO
;
92 static void pmu_one_sec_timer(void *opaque
)
96 trace_pmu_one_sec_timer();
98 s
->intbits
|= PMU_INT_TICK
;
100 s
->one_sec_target
+= 1000;
102 timer_mod(s
->one_sec_timer
, s
->one_sec_target
);
105 static void pmu_cmd_int_ack(PMUState
*s
,
106 const uint8_t *in_data
, uint8_t in_len
,
107 uint8_t *out_data
, uint8_t *out_len
)
110 qemu_log_mask(LOG_GUEST_ERROR
,
111 "PMU: INT_ACK command, invalid len: %d want: 0\n",
116 /* Make appropriate reply packet */
117 if (s
->intbits
& PMU_INT_ADB
) {
118 if (!s
->adb_reply_size
) {
119 qemu_log_mask(LOG_GUEST_ERROR
,
120 "Odd, PMU_INT_ADB set with no reply in buffer\n");
123 memcpy(out_data
+ 1, s
->adb_reply
, s
->adb_reply_size
);
124 out_data
[0] = s
->intbits
& (PMU_INT_ADB
| PMU_INT_ADB_AUTO
);
125 *out_len
= s
->adb_reply_size
+ 1;
126 s
->intbits
&= ~(PMU_INT_ADB
| PMU_INT_ADB_AUTO
);
127 s
->adb_reply_size
= 0;
129 out_data
[0] = s
->intbits
;
134 pmu_update_extirq(s
);
137 static void pmu_cmd_set_int_mask(PMUState
*s
,
138 const uint8_t *in_data
, uint8_t in_len
,
139 uint8_t *out_data
, uint8_t *out_len
)
142 qemu_log_mask(LOG_GUEST_ERROR
,
143 "PMU: SET_INT_MASK command, invalid len: %d want: 1\n",
148 trace_pmu_cmd_set_int_mask(s
->intmask
);
149 s
->intmask
= in_data
[0];
151 pmu_update_extirq(s
);
154 static void pmu_cmd_set_adb_autopoll(PMUState
*s
, uint16_t mask
)
156 ADBBusState
*adb_bus
= &s
->adb_bus
;
158 trace_pmu_cmd_set_adb_autopoll(mask
);
161 adb_set_autopoll_mask(adb_bus
, mask
);
162 adb_set_autopoll_enabled(adb_bus
, true);
164 adb_set_autopoll_enabled(adb_bus
, false);
168 static void pmu_cmd_adb(PMUState
*s
,
169 const uint8_t *in_data
, uint8_t in_len
,
170 uint8_t *out_data
, uint8_t *out_len
)
173 uint8_t adb_cmd
[255];
176 qemu_log_mask(LOG_GUEST_ERROR
,
177 "PMU: ADB PACKET, invalid len: %d want at least 2\n",
185 trace_pmu_cmd_adb_nobus();
189 /* Set autopoll is a special form of the command */
190 if (in_data
[0] == 0 && in_data
[1] == 0x86) {
191 uint16_t mask
= in_data
[2];
192 mask
= (mask
<< 8) | in_data
[3];
194 qemu_log_mask(LOG_GUEST_ERROR
,
195 "PMU: ADB Autopoll requires 4 bytes, got %d\n",
200 pmu_cmd_set_adb_autopoll(s
, mask
);
204 trace_pmu_cmd_adb_request(in_len
, in_data
[0], in_data
[1], in_data
[2],
205 in_data
[3], in_data
[4]);
211 if (adblen
> (in_len
- 3)) {
212 qemu_log_mask(LOG_GUEST_ERROR
,
213 "PMU: ADB len is %d > %d (in_len -3)...erroring\n",
216 } else if (adblen
> 252) {
217 qemu_log_mask(LOG_GUEST_ERROR
, "PMU: ADB command too big!\n");
221 adb_cmd
[0] = in_data
[0];
222 memcpy(&adb_cmd
[1], &in_data
[3], in_len
- 3);
223 len
= adb_request(&s
->adb_bus
, s
->adb_reply
+ 2, adb_cmd
, in_len
- 2);
225 trace_pmu_cmd_adb_reply(len
);
230 s
->adb_reply_size
= len
+ 2;
231 s
->adb_reply
[0] = 0x01;
232 s
->adb_reply
[1] = len
;
235 s
->adb_reply_size
= 1;
236 s
->adb_reply
[0] = 0x00;
239 s
->intbits
|= PMU_INT_ADB
;
240 pmu_update_extirq(s
);
243 static void pmu_cmd_adb_poll_off(PMUState
*s
,
244 const uint8_t *in_data
, uint8_t in_len
,
245 uint8_t *out_data
, uint8_t *out_len
)
247 ADBBusState
*adb_bus
= &s
->adb_bus
;
250 qemu_log_mask(LOG_GUEST_ERROR
,
251 "PMU: ADB POLL OFF command, invalid len: %d want: 0\n",
257 adb_set_autopoll_enabled(adb_bus
, false);
261 static void pmu_cmd_shutdown(PMUState
*s
,
262 const uint8_t *in_data
, uint8_t in_len
,
263 uint8_t *out_data
, uint8_t *out_len
)
266 qemu_log_mask(LOG_GUEST_ERROR
,
267 "PMU: SHUTDOWN command, invalid len: %d want: 4\n",
275 if (in_data
[0] != 'M' || in_data
[1] != 'A' || in_data
[2] != 'T' ||
278 qemu_log_mask(LOG_GUEST_ERROR
,
279 "PMU: SHUTDOWN command, Bad MATT signature\n");
283 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
286 static void pmu_cmd_reset(PMUState
*s
,
287 const uint8_t *in_data
, uint8_t in_len
,
288 uint8_t *out_data
, uint8_t *out_len
)
291 qemu_log_mask(LOG_GUEST_ERROR
,
292 "PMU: RESET command, invalid len: %d want: 0\n",
297 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
300 static void pmu_cmd_get_rtc(PMUState
*s
,
301 const uint8_t *in_data
, uint8_t in_len
,
302 uint8_t *out_data
, uint8_t *out_len
)
307 qemu_log_mask(LOG_GUEST_ERROR
,
308 "PMU: GET_RTC command, invalid len: %d want: 0\n",
313 ti
= s
->tick_offset
+ (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
314 / NANOSECONDS_PER_SECOND
);
315 out_data
[0] = ti
>> 24;
316 out_data
[1] = ti
>> 16;
317 out_data
[2] = ti
>> 8;
322 static void pmu_cmd_set_rtc(PMUState
*s
,
323 const uint8_t *in_data
, uint8_t in_len
,
324 uint8_t *out_data
, uint8_t *out_len
)
329 qemu_log_mask(LOG_GUEST_ERROR
,
330 "PMU: SET_RTC command, invalid len: %d want: 4\n",
335 ti
= (((uint32_t)in_data
[0]) << 24) + (((uint32_t)in_data
[1]) << 16)
336 + (((uint32_t)in_data
[2]) << 8) + in_data
[3];
338 s
->tick_offset
= ti
- (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
339 / NANOSECONDS_PER_SECOND
);
342 static void pmu_cmd_system_ready(PMUState
*s
,
343 const uint8_t *in_data
, uint8_t in_len
,
344 uint8_t *out_data
, uint8_t *out_len
)
349 static void pmu_cmd_get_version(PMUState
*s
,
350 const uint8_t *in_data
, uint8_t in_len
,
351 uint8_t *out_data
, uint8_t *out_len
)
354 *out_data
= 1; /* ??? Check what Apple does */
357 static void pmu_cmd_power_events(PMUState
*s
,
358 const uint8_t *in_data
, uint8_t in_len
,
359 uint8_t *out_data
, uint8_t *out_len
)
362 qemu_log_mask(LOG_GUEST_ERROR
,
363 "PMU: POWER EVENTS command, invalid len %d, want at least 1\n",
368 switch (in_data
[0]) {
369 /* Dummies for now */
370 case PMU_PWR_GET_POWERUP_EVENTS
:
375 case PMU_PWR_SET_POWERUP_EVENTS
:
376 case PMU_PWR_CLR_POWERUP_EVENTS
:
378 case PMU_PWR_GET_WAKEUP_EVENTS
:
383 case PMU_PWR_SET_WAKEUP_EVENTS
:
384 case PMU_PWR_CLR_WAKEUP_EVENTS
:
387 qemu_log_mask(LOG_GUEST_ERROR
,
388 "PMU: POWER EVENTS unknown subcommand 0x%02x\n",
393 static void pmu_cmd_get_cover(PMUState
*s
,
394 const uint8_t *in_data
, uint8_t in_len
,
395 uint8_t *out_data
, uint8_t *out_len
)
397 /* Not 100% sure here, will have to check what a real Mac
398 * returns other than byte 0 bit 0 is LID closed on laptops
404 static void pmu_cmd_download_status(PMUState
*s
,
405 const uint8_t *in_data
, uint8_t in_len
,
406 uint8_t *out_data
, uint8_t *out_len
)
408 /* This has to do with PMU firmware updates as far as I can tell.
410 * We return 0x62 which is what OpenPMU expects
416 static void pmu_cmd_read_pmu_ram(PMUState
*s
,
417 const uint8_t *in_data
, uint8_t in_len
,
418 uint8_t *out_data
, uint8_t *out_len
)
421 qemu_log_mask(LOG_GUEST_ERROR
,
422 "PMU: READ_PMU_RAM command, invalid len %d, expected 3\n",
427 qemu_log_mask(LOG_GUEST_ERROR
,
428 "PMU: Unsupported READ_PMU_RAM, args: %02x %02x %02x\n",
429 in_data
[0], in_data
[1], in_data
[2]);
434 /* description of commands */
435 typedef struct PMUCmdHandler
{
438 void (*handler
)(PMUState
*s
,
439 const uint8_t *in_args
, uint8_t in_len
,
440 uint8_t *out_args
, uint8_t *out_len
);
443 static const PMUCmdHandler PMUCmdHandlers
[] = {
444 { PMU_INT_ACK
, "INT ACK", pmu_cmd_int_ack
},
445 { PMU_SET_INTR_MASK
, "SET INT MASK", pmu_cmd_set_int_mask
},
446 { PMU_ADB_CMD
, "ADB COMMAND", pmu_cmd_adb
},
447 { PMU_ADB_POLL_OFF
, "ADB POLL OFF", pmu_cmd_adb_poll_off
},
448 { PMU_RESET
, "REBOOT", pmu_cmd_reset
},
449 { PMU_SHUTDOWN
, "SHUTDOWN", pmu_cmd_shutdown
},
450 { PMU_READ_RTC
, "GET RTC", pmu_cmd_get_rtc
},
451 { PMU_SET_RTC
, "SET RTC", pmu_cmd_set_rtc
},
452 { PMU_SYSTEM_READY
, "SYSTEM READY", pmu_cmd_system_ready
},
453 { PMU_GET_VERSION
, "GET VERSION", pmu_cmd_get_version
},
454 { PMU_POWER_EVENTS
, "POWER EVENTS", pmu_cmd_power_events
},
455 { PMU_GET_COVER
, "GET_COVER", pmu_cmd_get_cover
},
456 { PMU_DOWNLOAD_STATUS
, "DOWNLOAD STATUS", pmu_cmd_download_status
},
457 { PMU_READ_PMU_RAM
, "READ PMGR RAM", pmu_cmd_read_pmu_ram
},
460 static void pmu_dispatch_cmd(PMUState
*s
)
464 /* No response by default */
467 for (i
= 0; i
< ARRAY_SIZE(PMUCmdHandlers
); i
++) {
468 const PMUCmdHandler
*desc
= &PMUCmdHandlers
[i
];
470 if (desc
->command
!= s
->cmd
) {
474 trace_pmu_dispatch_cmd(desc
->name
);
475 desc
->handler(s
, s
->cmd_buf
, s
->cmd_buf_pos
,
476 s
->cmd_rsp
, &s
->cmd_rsp_sz
);
478 if (s
->rsplen
!= -1 && s
->rsplen
!= s
->cmd_rsp_sz
) {
479 trace_pmu_debug_protocol_string("QEMU internal cmd resp mismatch!");
481 trace_pmu_debug_protocol_resp_size(s
->cmd_rsp_sz
);
487 trace_pmu_dispatch_unknown_cmd(s
->cmd
);
489 /* Manufacture fake response with 0's */
490 if (s
->rsplen
== -1) {
493 s
->cmd_rsp_sz
= s
->rsplen
;
494 memset(s
->cmd_rsp
, 0, s
->rsplen
);
498 static void pmu_update(PMUState
*s
)
500 MOS6522PMUState
*mps
= &s
->mos6522_pmu
;
501 MOS6522State
*ms
= MOS6522(mps
);
502 ADBBusState
*adb_bus
= &s
->adb_bus
;
504 /* Only react to changes in reg B */
505 if (ms
->b
== s
->last_b
) {
510 /* Check the TREQ / TACK state */
511 switch (ms
->b
& (TREQ
| TACK
)) {
513 /* This is an ack release, handle it and bail out */
517 trace_pmu_debug_protocol_string("handshake: TREQ high, setting TACK");
520 /* This is a valid request, handle below */
523 /* This is an idle state */
526 /* Invalid state, log and ignore */
527 trace_pmu_debug_protocol_error(ms
->b
);
531 /* If we wanted to handle commands asynchronously, this is where
532 * we would delay the clearing of TACK until we are ready to send
536 /* We have a request, handshake TACK so we don't stay in
537 * an invalid state. If we were concurrent with the OS we
538 * should only do this after we grabbed the SR but that isn't
542 trace_pmu_debug_protocol_clear_treq(s
->cmd_state
);
547 /* Act according to state */
548 switch (s
->cmd_state
) {
550 if (!(ms
->acr
& SR_OUT
)) {
551 trace_pmu_debug_protocol_string("protocol error! "
552 "state idle, ACR reading");
558 s
->cmdlen
= pmu_data_len
[s
->cmd
][0];
559 s
->rsplen
= pmu_data_len
[s
->cmd
][1];
562 s
->cmd_state
= pmu_state_cmd
;
564 adb_autopoll_block(adb_bus
);
565 trace_pmu_debug_protocol_cmd(s
->cmd
, s
->cmdlen
, s
->rsplen
);
569 if (!(ms
->acr
& SR_OUT
)) {
570 trace_pmu_debug_protocol_string("protocol error! "
571 "state cmd, ACR reading");
575 if (s
->cmdlen
== -1) {
576 trace_pmu_debug_protocol_cmdlen(ms
->sr
);
579 if (s
->cmdlen
> sizeof(s
->cmd_buf
)) {
580 trace_pmu_debug_protocol_cmd_toobig(s
->cmdlen
);
582 } else if (s
->cmd_buf_pos
< sizeof(s
->cmd_buf
)) {
583 s
->cmd_buf
[s
->cmd_buf_pos
++] = ms
->sr
;
590 if (ms
->acr
& SR_OUT
) {
591 trace_pmu_debug_protocol_string("protocol error! "
592 "state resp, ACR writing");
596 if (s
->rsplen
== -1) {
597 trace_pmu_debug_protocol_cmd_send_resp_size(s
->cmd_rsp_sz
);
599 ms
->sr
= s
->cmd_rsp_sz
;
600 s
->rsplen
= s
->cmd_rsp_sz
;
601 } else if (s
->cmd_rsp_pos
< s
->cmd_rsp_sz
) {
602 trace_pmu_debug_protocol_cmd_send_resp(s
->cmd_rsp_pos
, s
->rsplen
);
604 ms
->sr
= s
->cmd_rsp
[s
->cmd_rsp_pos
++];
611 /* Check for state completion */
612 if (s
->cmd_state
== pmu_state_cmd
&& s
->cmdlen
== s
->cmd_buf_pos
) {
613 trace_pmu_debug_protocol_string("Command reception complete, "
617 s
->cmd_state
= pmu_state_rsp
;
620 if (s
->cmd_state
== pmu_state_rsp
&& s
->rsplen
== s
->cmd_rsp_pos
) {
621 trace_pmu_debug_protocol_cmd_resp_complete(ms
->ier
);
623 adb_autopoll_unblock(adb_bus
);
624 s
->cmd_state
= pmu_state_idle
;
628 static uint64_t mos6522_pmu_read(void *opaque
, hwaddr addr
, unsigned size
)
630 PMUState
*s
= opaque
;
631 MOS6522PMUState
*mps
= &s
->mos6522_pmu
;
632 MOS6522State
*ms
= MOS6522(mps
);
634 addr
= (addr
>> 9) & 0xf;
635 return mos6522_read(ms
, addr
, size
);
638 static void mos6522_pmu_write(void *opaque
, hwaddr addr
, uint64_t val
,
641 PMUState
*s
= opaque
;
642 MOS6522PMUState
*mps
= &s
->mos6522_pmu
;
643 MOS6522State
*ms
= MOS6522(mps
);
645 addr
= (addr
>> 9) & 0xf;
646 mos6522_write(ms
, addr
, val
, size
);
649 static const MemoryRegionOps mos6522_pmu_ops
= {
650 .read
= mos6522_pmu_read
,
651 .write
= mos6522_pmu_write
,
652 .endianness
= DEVICE_BIG_ENDIAN
,
654 .min_access_size
= 1,
655 .max_access_size
= 1,
659 static bool pmu_adb_state_needed(void *opaque
)
661 PMUState
*s
= opaque
;
666 static const VMStateDescription vmstate_pmu_adb
= {
669 .minimum_version_id
= 1,
670 .needed
= pmu_adb_state_needed
,
671 .fields
= (const VMStateField
[]) {
672 VMSTATE_UINT8(adb_reply_size
, PMUState
),
673 VMSTATE_BUFFER(adb_reply
, PMUState
),
674 VMSTATE_END_OF_LIST()
678 static const VMStateDescription vmstate_pmu
= {
681 .minimum_version_id
= 1,
682 .fields
= (const VMStateField
[]) {
683 VMSTATE_STRUCT(mos6522_pmu
.parent_obj
, PMUState
, 0, vmstate_mos6522
,
685 VMSTATE_UINT8(last_b
, PMUState
),
686 VMSTATE_UINT8(cmd
, PMUState
),
687 VMSTATE_UINT32(cmdlen
, PMUState
),
688 VMSTATE_UINT32(rsplen
, PMUState
),
689 VMSTATE_UINT8(cmd_buf_pos
, PMUState
),
690 VMSTATE_BUFFER(cmd_buf
, PMUState
),
691 VMSTATE_UINT8(cmd_rsp_pos
, PMUState
),
692 VMSTATE_UINT8(cmd_rsp_sz
, PMUState
),
693 VMSTATE_BUFFER(cmd_rsp
, PMUState
),
694 VMSTATE_UINT8(intbits
, PMUState
),
695 VMSTATE_UINT8(intmask
, PMUState
),
696 VMSTATE_UINT32(tick_offset
, PMUState
),
697 VMSTATE_TIMER_PTR(one_sec_timer
, PMUState
),
698 VMSTATE_INT64(one_sec_target
, PMUState
),
699 VMSTATE_END_OF_LIST()
701 .subsections
= (const VMStateDescription
* const []) {
707 static void pmu_reset(DeviceState
*dev
)
709 PMUState
*s
= VIA_PMU(dev
);
711 /* OpenBIOS needs to do this? MacOS 9 needs it */
712 s
->intmask
= PMU_INT_ADB
| PMU_INT_TICK
;
715 s
->cmd_state
= pmu_state_idle
;
718 static void pmu_realize(DeviceState
*dev
, Error
**errp
)
720 PMUState
*s
= VIA_PMU(dev
);
722 ADBBusState
*adb_bus
= &s
->adb_bus
;
725 if (!sysbus_realize(SYS_BUS_DEVICE(&s
->mos6522_pmu
), errp
)) {
729 /* Pass IRQ from 6522 */
730 sbd
= SYS_BUS_DEVICE(s
);
731 sysbus_pass_irq(sbd
, SYS_BUS_DEVICE(&s
->mos6522_pmu
));
733 qemu_get_timedate(&tm
, 0);
734 s
->tick_offset
= (uint32_t)mktimegm(&tm
) + RTC_OFFSET
;
735 s
->one_sec_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, pmu_one_sec_timer
, s
);
736 s
->one_sec_target
= qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 1000;
737 timer_mod(s
->one_sec_timer
, s
->one_sec_target
);
740 qbus_init(adb_bus
, sizeof(*adb_bus
), TYPE_ADB_BUS
, dev
, "adb.0");
741 adb_register_autopoll_callback(adb_bus
, pmu_adb_poll
, s
);
745 static void pmu_init(Object
*obj
)
747 SysBusDevice
*d
= SYS_BUS_DEVICE(obj
);
748 PMUState
*s
= VIA_PMU(obj
);
750 object_property_add_link(obj
, "gpio", TYPE_MACIO_GPIO
,
751 (Object
**) &s
->gpio
,
752 qdev_prop_allow_set_link_before_realize
,
755 object_initialize_child(obj
, "mos6522-pmu", &s
->mos6522_pmu
,
758 memory_region_init_io(&s
->mem
, obj
, &mos6522_pmu_ops
, s
, "via-pmu",
760 sysbus_init_mmio(d
, &s
->mem
);
763 static Property pmu_properties
[] = {
764 DEFINE_PROP_BOOL("has-adb", PMUState
, has_adb
, true),
765 DEFINE_PROP_END_OF_LIST()
768 static void pmu_class_init(ObjectClass
*oc
, void *data
)
770 DeviceClass
*dc
= DEVICE_CLASS(oc
);
772 dc
->realize
= pmu_realize
;
773 dc
->reset
= pmu_reset
;
774 dc
->vmsd
= &vmstate_pmu
;
775 device_class_set_props(dc
, pmu_properties
);
776 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
779 static const TypeInfo pmu_type_info
= {
780 .name
= TYPE_VIA_PMU
,
781 .parent
= TYPE_SYS_BUS_DEVICE
,
782 .instance_size
= sizeof(PMUState
),
783 .instance_init
= pmu_init
,
784 .class_init
= pmu_class_init
,
787 static void mos6522_pmu_portB_write(MOS6522State
*s
)
789 MOS6522PMUState
*mps
= container_of(s
, MOS6522PMUState
, parent_obj
);
790 PMUState
*ps
= container_of(mps
, PMUState
, mos6522_pmu
);
795 static void mos6522_pmu_reset_hold(Object
*obj
)
797 MOS6522State
*ms
= MOS6522(obj
);
798 MOS6522PMUState
*mps
= container_of(ms
, MOS6522PMUState
, parent_obj
);
799 PMUState
*s
= container_of(mps
, PMUState
, mos6522_pmu
);
800 MOS6522DeviceClass
*mdc
= MOS6522_GET_CLASS(ms
);
802 if (mdc
->parent_phases
.hold
) {
803 mdc
->parent_phases
.hold(obj
);
806 ms
->timers
[0].frequency
= VIA_TIMER_FREQ
;
807 ms
->timers
[1].frequency
= (SCALE_US
* 6000) / 4700;
809 s
->last_b
= ms
->b
= TACK
| TREQ
;
812 static void mos6522_pmu_class_init(ObjectClass
*oc
, void *data
)
814 ResettableClass
*rc
= RESETTABLE_CLASS(oc
);
815 MOS6522DeviceClass
*mdc
= MOS6522_CLASS(oc
);
817 resettable_class_set_parent_phases(rc
, NULL
, mos6522_pmu_reset_hold
,
818 NULL
, &mdc
->parent_phases
);
819 mdc
->portB_write
= mos6522_pmu_portB_write
;
822 static const TypeInfo mos6522_pmu_type_info
= {
823 .name
= TYPE_MOS6522_PMU
,
824 .parent
= TYPE_MOS6522
,
825 .instance_size
= sizeof(MOS6522PMUState
),
826 .class_init
= mos6522_pmu_class_init
,
829 static void pmu_register_types(void)
831 type_register_static(&pmu_type_info
);
832 type_register_static(&mos6522_pmu_type_info
);
835 type_init(pmu_register_types
)