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"
33 #include "hw/ppc/mac.h"
34 #include "hw/input/adb.h"
35 #include "hw/misc/mos6522.h"
36 #include "hw/misc/macio/gpio.h"
37 #include "hw/misc/macio/pmu.h"
38 #include "qemu/timer.h"
39 #include "sysemu/sysemu.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_update_irq(PMUState
*s
)
57 MOS6522PMUState
*mps
= MOS6522_PMU(&s
->mos6522_pmu
);
58 MOS6522State
*ms
= MOS6522(mps
);
60 bool new_state
= !!(ms
->ifr
& ms
->ier
& (SR_INT
| T1_INT
| T2_INT
));
62 if (new_state
!= s
->via_irq_state
) {
63 s
->via_irq_state
= new_state
;
64 qemu_set_irq(s
->via_irq
, new_state
);
68 static void via_set_sr_int(void *opaque
)
71 MOS6522PMUState
*mps
= MOS6522_PMU(&s
->mos6522_pmu
);
72 MOS6522State
*ms
= MOS6522(mps
);
73 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(ms
);
78 static void pmu_update_extirq(PMUState
*s
)
80 if ((s
->intbits
& s
->intmask
) != 0) {
81 macio_set_gpio(s
->gpio
, 1, false);
83 macio_set_gpio(s
->gpio
, 1, true);
87 static void pmu_adb_poll(void *opaque
)
92 if (!(s
->intbits
& PMU_INT_ADB
)) {
93 olen
= adb_poll(&s
->adb_bus
, s
->adb_reply
, s
->adb_poll_mask
);
94 trace_pmu_adb_poll(olen
);
97 s
->adb_reply_size
= olen
;
98 s
->intbits
|= PMU_INT_ADB
| PMU_INT_ADB_AUTO
;
103 timer_mod(s
->adb_poll_timer
,
104 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 30);
107 static void pmu_one_sec_timer(void *opaque
)
109 PMUState
*s
= opaque
;
111 trace_pmu_one_sec_timer();
113 s
->intbits
|= PMU_INT_TICK
;
114 pmu_update_extirq(s
);
115 s
->one_sec_target
+= 1000;
117 timer_mod(s
->one_sec_timer
, s
->one_sec_target
);
120 static void pmu_cmd_int_ack(PMUState
*s
,
121 const uint8_t *in_data
, uint8_t in_len
,
122 uint8_t *out_data
, uint8_t *out_len
)
125 qemu_log_mask(LOG_GUEST_ERROR
,
126 "PMU: INT_ACK command, invalid len: %d want: 0\n",
131 /* Make appropriate reply packet */
132 if (s
->intbits
& PMU_INT_ADB
) {
133 if (!s
->adb_reply_size
) {
134 qemu_log_mask(LOG_GUEST_ERROR
,
135 "Odd, PMU_INT_ADB set with no reply in buffer\n");
138 memcpy(out_data
+ 1, s
->adb_reply
, s
->adb_reply_size
);
139 out_data
[0] = s
->intbits
& (PMU_INT_ADB
| PMU_INT_ADB_AUTO
);
140 *out_len
= s
->adb_reply_size
+ 1;
141 s
->intbits
&= ~(PMU_INT_ADB
| PMU_INT_ADB_AUTO
);
142 s
->adb_reply_size
= 0;
144 out_data
[0] = s
->intbits
;
149 pmu_update_extirq(s
);
152 static void pmu_cmd_set_int_mask(PMUState
*s
,
153 const uint8_t *in_data
, uint8_t in_len
,
154 uint8_t *out_data
, uint8_t *out_len
)
157 qemu_log_mask(LOG_GUEST_ERROR
,
158 "PMU: SET_INT_MASK command, invalid len: %d want: 1\n",
163 trace_pmu_cmd_set_int_mask(s
->intmask
);
164 s
->intmask
= in_data
[0];
166 pmu_update_extirq(s
);
169 static void pmu_cmd_set_adb_autopoll(PMUState
*s
, uint16_t mask
)
171 trace_pmu_cmd_set_adb_autopoll(mask
);
173 if (s
->autopoll_mask
== mask
) {
177 s
->autopoll_mask
= mask
;
179 timer_mod(s
->adb_poll_timer
,
180 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 30);
182 timer_del(s
->adb_poll_timer
);
186 static void pmu_cmd_adb(PMUState
*s
,
187 const uint8_t *in_data
, uint8_t in_len
,
188 uint8_t *out_data
, uint8_t *out_len
)
191 uint8_t adb_cmd
[255];
194 qemu_log_mask(LOG_GUEST_ERROR
,
195 "PMU: ADB PACKET, invalid len: %d want at least 2\n",
203 trace_pmu_cmd_adb_nobus();
207 /* Set autopoll is a special form of the command */
208 if (in_data
[0] == 0 && in_data
[1] == 0x86) {
209 uint16_t mask
= in_data
[2];
210 mask
= (mask
<< 8) | in_data
[3];
212 qemu_log_mask(LOG_GUEST_ERROR
,
213 "PMU: ADB Autopoll requires 4 bytes, got %d\n",
218 pmu_cmd_set_adb_autopoll(s
, mask
);
222 trace_pmu_cmd_adb_request(in_len
, in_data
[0], in_data
[1], in_data
[2],
223 in_data
[3], in_data
[4]);
229 if (adblen
> (in_len
- 3)) {
230 qemu_log_mask(LOG_GUEST_ERROR
,
231 "PMU: ADB len is %d > %d (in_len -3)...erroring\n",
234 } else if (adblen
> 252) {
235 qemu_log_mask(LOG_GUEST_ERROR
, "PMU: ADB command too big!\n");
239 adb_cmd
[0] = in_data
[0];
240 memcpy(&adb_cmd
[1], &in_data
[3], in_len
- 3);
241 len
= adb_request(&s
->adb_bus
, s
->adb_reply
+ 2, adb_cmd
, in_len
- 2);
243 trace_pmu_cmd_adb_reply(len
);
248 s
->adb_reply_size
= len
+ 2;
249 s
->adb_reply
[0] = 0x01;
250 s
->adb_reply
[1] = len
;
253 s
->adb_reply_size
= 1;
254 s
->adb_reply
[0] = 0x00;
257 s
->intbits
|= PMU_INT_ADB
;
258 pmu_update_extirq(s
);
261 static void pmu_cmd_adb_poll_off(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: ADB POLL OFF command, invalid len: %d want: 0\n",
272 if (s
->has_adb
&& s
->autopoll_mask
) {
273 timer_del(s
->adb_poll_timer
);
274 s
->autopoll_mask
= false;
278 static void pmu_cmd_shutdown(PMUState
*s
,
279 const uint8_t *in_data
, uint8_t in_len
,
280 uint8_t *out_data
, uint8_t *out_len
)
283 qemu_log_mask(LOG_GUEST_ERROR
,
284 "PMU: SHUTDOWN command, invalid len: %d want: 4\n",
292 if (in_data
[0] != 'M' || in_data
[1] != 'A' || in_data
[2] != 'T' ||
295 qemu_log_mask(LOG_GUEST_ERROR
,
296 "PMU: SHUTDOWN command, Bad MATT signature\n");
300 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
303 static void pmu_cmd_reset(PMUState
*s
,
304 const uint8_t *in_data
, uint8_t in_len
,
305 uint8_t *out_data
, uint8_t *out_len
)
308 qemu_log_mask(LOG_GUEST_ERROR
,
309 "PMU: RESET command, invalid len: %d want: 0\n",
314 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
317 static void pmu_cmd_get_rtc(PMUState
*s
,
318 const uint8_t *in_data
, uint8_t in_len
,
319 uint8_t *out_data
, uint8_t *out_len
)
324 qemu_log_mask(LOG_GUEST_ERROR
,
325 "PMU: GET_RTC command, invalid len: %d want: 0\n",
330 ti
= s
->tick_offset
+ (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
331 / NANOSECONDS_PER_SECOND
);
332 out_data
[0] = ti
>> 24;
333 out_data
[1] = ti
>> 16;
334 out_data
[2] = ti
>> 8;
339 static void pmu_cmd_set_rtc(PMUState
*s
,
340 const uint8_t *in_data
, uint8_t in_len
,
341 uint8_t *out_data
, uint8_t *out_len
)
346 qemu_log_mask(LOG_GUEST_ERROR
,
347 "PMU: SET_RTC command, invalid len: %d want: 4\n",
352 ti
= (((uint32_t)in_data
[0]) << 24) + (((uint32_t)in_data
[1]) << 16)
353 + (((uint32_t)in_data
[2]) << 8) + in_data
[3];
355 s
->tick_offset
= ti
- (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
356 / NANOSECONDS_PER_SECOND
);
359 static void pmu_cmd_system_ready(PMUState
*s
,
360 const uint8_t *in_data
, uint8_t in_len
,
361 uint8_t *out_data
, uint8_t *out_len
)
366 static void pmu_cmd_get_version(PMUState
*s
,
367 const uint8_t *in_data
, uint8_t in_len
,
368 uint8_t *out_data
, uint8_t *out_len
)
371 *out_data
= 1; /* ??? Check what Apple does */
374 static void pmu_cmd_power_events(PMUState
*s
,
375 const uint8_t *in_data
, uint8_t in_len
,
376 uint8_t *out_data
, uint8_t *out_len
)
379 qemu_log_mask(LOG_GUEST_ERROR
,
380 "PMU: POWER EVENTS command, invalid len %d, want at least 1\n",
385 switch (in_data
[0]) {
386 /* Dummies for now */
387 case PMU_PWR_GET_POWERUP_EVENTS
:
392 case PMU_PWR_SET_POWERUP_EVENTS
:
393 case PMU_PWR_CLR_POWERUP_EVENTS
:
395 case PMU_PWR_GET_WAKEUP_EVENTS
:
400 case PMU_PWR_SET_WAKEUP_EVENTS
:
401 case PMU_PWR_CLR_WAKEUP_EVENTS
:
404 qemu_log_mask(LOG_GUEST_ERROR
,
405 "PMU: POWER EVENTS unknown subcommand 0x%02x\n",
410 static void pmu_cmd_get_cover(PMUState
*s
,
411 const uint8_t *in_data
, uint8_t in_len
,
412 uint8_t *out_data
, uint8_t *out_len
)
414 /* Not 100% sure here, will have to check what a real Mac
415 * returns other than byte 0 bit 0 is LID closed on laptops
421 static void pmu_cmd_download_status(PMUState
*s
,
422 const uint8_t *in_data
, uint8_t in_len
,
423 uint8_t *out_data
, uint8_t *out_len
)
425 /* This has to do with PMU firmware updates as far as I can tell.
427 * We return 0x62 which is what OpenPMU expects
433 static void pmu_cmd_read_pmu_ram(PMUState
*s
,
434 const uint8_t *in_data
, uint8_t in_len
,
435 uint8_t *out_data
, uint8_t *out_len
)
438 qemu_log_mask(LOG_GUEST_ERROR
,
439 "PMU: READ_PMU_RAM command, invalid len %d, expected 3\n",
444 qemu_log_mask(LOG_GUEST_ERROR
,
445 "PMU: Unsupported READ_PMU_RAM, args: %02x %02x %02x\n",
446 in_data
[0], in_data
[1], in_data
[2]);
451 /* description of commands */
452 typedef struct PMUCmdHandler
{
455 void (*handler
)(PMUState
*s
,
456 const uint8_t *in_args
, uint8_t in_len
,
457 uint8_t *out_args
, uint8_t *out_len
);
460 static const PMUCmdHandler PMUCmdHandlers
[] = {
461 { PMU_INT_ACK
, "INT ACK", pmu_cmd_int_ack
},
462 { PMU_SET_INTR_MASK
, "SET INT MASK", pmu_cmd_set_int_mask
},
463 { PMU_ADB_CMD
, "ADB COMMAND", pmu_cmd_adb
},
464 { PMU_ADB_POLL_OFF
, "ADB POLL OFF", pmu_cmd_adb_poll_off
},
465 { PMU_RESET
, "REBOOT", pmu_cmd_reset
},
466 { PMU_SHUTDOWN
, "SHUTDOWN", pmu_cmd_shutdown
},
467 { PMU_READ_RTC
, "GET RTC", pmu_cmd_get_rtc
},
468 { PMU_SET_RTC
, "SET RTC", pmu_cmd_set_rtc
},
469 { PMU_SYSTEM_READY
, "SYSTEM READY", pmu_cmd_system_ready
},
470 { PMU_GET_VERSION
, "GET VERSION", pmu_cmd_get_version
},
471 { PMU_POWER_EVENTS
, "POWER EVENTS", pmu_cmd_power_events
},
472 { PMU_GET_COVER
, "GET_COVER", pmu_cmd_get_cover
},
473 { PMU_DOWNLOAD_STATUS
, "DOWNLOAD STATUS", pmu_cmd_download_status
},
474 { PMU_READ_PMU_RAM
, "READ PMGR RAM", pmu_cmd_read_pmu_ram
},
477 static void pmu_dispatch_cmd(PMUState
*s
)
481 /* No response by default */
484 for (i
= 0; i
< ARRAY_SIZE(PMUCmdHandlers
); i
++) {
485 const PMUCmdHandler
*desc
= &PMUCmdHandlers
[i
];
487 if (desc
->command
!= s
->cmd
) {
491 trace_pmu_dispatch_cmd(desc
->name
);
492 desc
->handler(s
, s
->cmd_buf
, s
->cmd_buf_pos
,
493 s
->cmd_rsp
, &s
->cmd_rsp_sz
);
495 if (s
->rsplen
!= -1 && s
->rsplen
!= s
->cmd_rsp_sz
) {
496 trace_pmu_debug_protocol_string("QEMU internal cmd resp mismatch!");
498 trace_pmu_debug_protocol_resp_size(s
->cmd_rsp_sz
);
504 trace_pmu_dispatch_unknown_cmd(s
->cmd
);
506 /* Manufacture fake response with 0's */
507 if (s
->rsplen
== -1) {
510 s
->cmd_rsp_sz
= s
->rsplen
;
511 memset(s
->cmd_rsp
, 0, s
->rsplen
);
515 static void pmu_update(PMUState
*s
)
517 MOS6522PMUState
*mps
= &s
->mos6522_pmu
;
518 MOS6522State
*ms
= MOS6522(mps
);
520 /* Only react to changes in reg B */
521 if (ms
->b
== s
->last_b
) {
526 /* Check the TREQ / TACK state */
527 switch (ms
->b
& (TREQ
| TACK
)) {
529 /* This is an ack release, handle it and bail out */
533 trace_pmu_debug_protocol_string("handshake: TREQ high, setting TACK");
536 /* This is a valid request, handle below */
539 /* This is an idle state */
542 /* Invalid state, log and ignore */
543 trace_pmu_debug_protocol_error(ms
->b
);
547 /* If we wanted to handle commands asynchronously, this is where
548 * we would delay the clearing of TACK until we are ready to send
552 /* We have a request, handshake TACK so we don't stay in
553 * an invalid state. If we were concurrent with the OS we
554 * should only do this after we grabbed the SR but that isn't
558 trace_pmu_debug_protocol_clear_treq(s
->cmd_state
);
563 /* Act according to state */
564 switch (s
->cmd_state
) {
566 if (!(ms
->acr
& SR_OUT
)) {
567 trace_pmu_debug_protocol_string("protocol error! "
568 "state idle, ACR reading");
574 s
->cmdlen
= pmu_data_len
[s
->cmd
][0];
575 s
->rsplen
= pmu_data_len
[s
->cmd
][1];
578 s
->cmd_state
= pmu_state_cmd
;
580 trace_pmu_debug_protocol_cmd(s
->cmd
, s
->cmdlen
, s
->rsplen
);
584 if (!(ms
->acr
& SR_OUT
)) {
585 trace_pmu_debug_protocol_string("protocol error! "
586 "state cmd, ACR reading");
590 if (s
->cmdlen
== -1) {
591 trace_pmu_debug_protocol_cmdlen(ms
->sr
);
594 if (s
->cmdlen
> sizeof(s
->cmd_buf
)) {
595 trace_pmu_debug_protocol_cmd_toobig(s
->cmdlen
);
597 } else if (s
->cmd_buf_pos
< sizeof(s
->cmd_buf
)) {
598 s
->cmd_buf
[s
->cmd_buf_pos
++] = ms
->sr
;
605 if (ms
->acr
& SR_OUT
) {
606 trace_pmu_debug_protocol_string("protocol error! "
607 "state resp, ACR writing");
611 if (s
->rsplen
== -1) {
612 trace_pmu_debug_protocol_cmd_send_resp_size(s
->cmd_rsp_sz
);
614 ms
->sr
= s
->cmd_rsp_sz
;
615 s
->rsplen
= s
->cmd_rsp_sz
;
616 } else if (s
->cmd_rsp_pos
< s
->cmd_rsp_sz
) {
617 trace_pmu_debug_protocol_cmd_send_resp(s
->cmd_rsp_pos
, s
->rsplen
);
619 ms
->sr
= s
->cmd_rsp
[s
->cmd_rsp_pos
++];
626 /* Check for state completion */
627 if (s
->cmd_state
== pmu_state_cmd
&& s
->cmdlen
== s
->cmd_buf_pos
) {
628 trace_pmu_debug_protocol_string("Command reception complete, "
632 s
->cmd_state
= pmu_state_rsp
;
635 if (s
->cmd_state
== pmu_state_rsp
&& s
->rsplen
== s
->cmd_rsp_pos
) {
636 trace_pmu_debug_protocol_cmd_resp_complete(ms
->ier
);
638 s
->cmd_state
= pmu_state_idle
;
642 static uint64_t mos6522_pmu_read(void *opaque
, hwaddr addr
, unsigned size
)
644 PMUState
*s
= opaque
;
645 MOS6522PMUState
*mps
= &s
->mos6522_pmu
;
646 MOS6522State
*ms
= MOS6522(mps
);
648 addr
= (addr
>> 9) & 0xf;
649 return mos6522_read(ms
, addr
, size
);
652 static void mos6522_pmu_write(void *opaque
, hwaddr addr
, uint64_t val
,
655 PMUState
*s
= opaque
;
656 MOS6522PMUState
*mps
= &s
->mos6522_pmu
;
657 MOS6522State
*ms
= MOS6522(mps
);
659 addr
= (addr
>> 9) & 0xf;
660 mos6522_write(ms
, addr
, val
, size
);
663 static const MemoryRegionOps mos6522_pmu_ops
= {
664 .read
= mos6522_pmu_read
,
665 .write
= mos6522_pmu_write
,
666 .endianness
= DEVICE_BIG_ENDIAN
,
668 .min_access_size
= 1,
669 .max_access_size
= 1,
673 static bool pmu_adb_state_needed(void *opaque
)
675 PMUState
*s
= opaque
;
680 static const VMStateDescription vmstate_pmu_adb
= {
683 .minimum_version_id
= 0,
684 .needed
= pmu_adb_state_needed
,
685 .fields
= (VMStateField
[]) {
686 VMSTATE_UINT16(adb_poll_mask
, PMUState
),
687 VMSTATE_TIMER_PTR(adb_poll_timer
, PMUState
),
688 VMSTATE_UINT8(adb_reply_size
, PMUState
),
689 VMSTATE_BUFFER(adb_reply
, PMUState
),
690 VMSTATE_END_OF_LIST()
694 static const VMStateDescription vmstate_pmu
= {
697 .minimum_version_id
= 0,
698 .fields
= (VMStateField
[]) {
699 VMSTATE_STRUCT(mos6522_pmu
.parent_obj
, PMUState
, 0, vmstate_mos6522
,
701 VMSTATE_UINT8(last_b
, PMUState
),
702 VMSTATE_UINT8(cmd
, PMUState
),
703 VMSTATE_UINT32(cmdlen
, PMUState
),
704 VMSTATE_UINT32(rsplen
, PMUState
),
705 VMSTATE_UINT8(cmd_buf_pos
, PMUState
),
706 VMSTATE_BUFFER(cmd_buf
, PMUState
),
707 VMSTATE_UINT8(cmd_rsp_pos
, PMUState
),
708 VMSTATE_UINT8(cmd_rsp_sz
, PMUState
),
709 VMSTATE_BUFFER(cmd_rsp
, PMUState
),
710 VMSTATE_UINT8(intbits
, PMUState
),
711 VMSTATE_UINT8(intmask
, PMUState
),
712 VMSTATE_UINT8(autopoll_rate_ms
, PMUState
),
713 VMSTATE_UINT8(autopoll_mask
, PMUState
),
714 VMSTATE_UINT32(tick_offset
, PMUState
),
715 VMSTATE_TIMER_PTR(one_sec_timer
, PMUState
),
716 VMSTATE_INT64(one_sec_target
, PMUState
),
717 VMSTATE_END_OF_LIST()
719 .subsections
= (const VMStateDescription
* []) {
724 static void pmu_reset(DeviceState
*dev
)
726 PMUState
*s
= VIA_PMU(dev
);
728 /* OpenBIOS needs to do this? MacOS 9 needs it */
729 s
->intmask
= PMU_INT_ADB
| PMU_INT_TICK
;
732 s
->cmd_state
= pmu_state_idle
;
733 s
->autopoll_mask
= 0;
736 static void pmu_realize(DeviceState
*dev
, Error
**errp
)
738 PMUState
*s
= VIA_PMU(dev
);
744 /* Pass IRQ from 6522 */
745 d
= DEVICE(&s
->mos6522_pmu
);
747 sbd
= SYS_BUS_DEVICE(s
);
748 sysbus_pass_irq(sbd
, SYS_BUS_DEVICE(ms
));
750 qemu_get_timedate(&tm
, 0);
751 s
->tick_offset
= (uint32_t)mktimegm(&tm
) + RTC_OFFSET
;
752 s
->one_sec_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, pmu_one_sec_timer
, s
);
753 s
->one_sec_target
= qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 1000;
754 timer_mod(s
->one_sec_timer
, s
->one_sec_target
);
757 qbus_create_inplace(&s
->adb_bus
, sizeof(s
->adb_bus
), TYPE_ADB_BUS
,
758 DEVICE(dev
), "adb.0");
759 s
->adb_poll_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, pmu_adb_poll
, s
);
760 s
->adb_poll_mask
= 0xffff;
761 s
->autopoll_rate_ms
= 20;
765 static void pmu_init(Object
*obj
)
767 SysBusDevice
*d
= SYS_BUS_DEVICE(obj
);
768 PMUState
*s
= VIA_PMU(obj
);
770 object_property_add_link(obj
, "gpio", TYPE_MACIO_GPIO
,
771 (Object
**) &s
->gpio
,
772 qdev_prop_allow_set_link_before_realize
,
775 sysbus_init_child_obj(obj
, "mos6522-pmu", &s
->mos6522_pmu
,
776 sizeof(s
->mos6522_pmu
), TYPE_MOS6522_PMU
);
778 memory_region_init_io(&s
->mem
, obj
, &mos6522_pmu_ops
, s
, "via-pmu",
780 sysbus_init_mmio(d
, &s
->mem
);
783 static Property pmu_properties
[] = {
784 DEFINE_PROP_BOOL("has-adb", PMUState
, has_adb
, true),
785 DEFINE_PROP_END_OF_LIST()
788 static void pmu_class_init(ObjectClass
*oc
, void *data
)
790 DeviceClass
*dc
= DEVICE_CLASS(oc
);
792 dc
->realize
= pmu_realize
;
793 dc
->reset
= pmu_reset
;
794 dc
->vmsd
= &vmstate_pmu
;
795 dc
->props
= pmu_properties
;
796 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
799 static const TypeInfo pmu_type_info
= {
800 .name
= TYPE_VIA_PMU
,
801 .parent
= TYPE_SYS_BUS_DEVICE
,
802 .instance_size
= sizeof(PMUState
),
803 .instance_init
= pmu_init
,
804 .class_init
= pmu_class_init
,
807 static void mos6522_pmu_portB_write(MOS6522State
*s
)
809 MOS6522PMUState
*mps
= container_of(s
, MOS6522PMUState
, parent_obj
);
810 PMUState
*ps
= container_of(mps
, PMUState
, mos6522_pmu
);
812 if ((s
->pcr
& 0xe0) == 0x20 || (s
->pcr
& 0xe0) == 0x60) {
821 static void mos6522_pmu_portA_write(MOS6522State
*s
)
823 MOS6522PMUState
*mps
= container_of(s
, MOS6522PMUState
, parent_obj
);
824 PMUState
*ps
= container_of(mps
, PMUState
, mos6522_pmu
);
826 if ((s
->pcr
& 0x0e) == 0x02 || (s
->pcr
& 0x0e) == 0x06) {
834 static void mos6522_pmu_reset(DeviceState
*dev
)
836 MOS6522State
*ms
= MOS6522(dev
);
837 MOS6522PMUState
*mps
= container_of(ms
, MOS6522PMUState
, parent_obj
);
838 PMUState
*s
= container_of(mps
, PMUState
, mos6522_pmu
);
839 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(ms
);
841 mdc
->parent_reset(dev
);
843 ms
->timers
[0].frequency
= VIA_TIMER_FREQ
;
844 ms
->timers
[1].frequency
= (SCALE_US
* 6000) / 4700;
846 s
->last_b
= ms
->b
= TACK
| TREQ
;
849 static void mos6522_pmu_class_init(ObjectClass
*oc
, void *data
)
851 DeviceClass
*dc
= DEVICE_CLASS(oc
);
852 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_CLASS(oc
);
854 dc
->reset
= mos6522_pmu_reset
;
855 mdc
->portB_write
= mos6522_pmu_portB_write
;
856 mdc
->portA_write
= mos6522_pmu_portA_write
;
859 static const TypeInfo mos6522_pmu_type_info
= {
860 .name
= TYPE_MOS6522_PMU
,
861 .parent
= TYPE_MOS6522
,
862 .instance_size
= sizeof(MOS6522PMUState
),
863 .class_init
= mos6522_pmu_class_init
,
866 static void pmu_register_types(void)
868 type_register_static(&pmu_type_info
);
869 type_register_static(&mos6522_pmu_type_info
);
872 type_init(pmu_register_types
)