2 * QEMU m68k Macintosh VIA device support
4 * Copyright (c) 2011-2018 Laurent Vivier
5 * Copyright (c) 2018 Mark Cave-Ayland
7 * Some parts from hw/misc/macio/cuda.c
9 * Copyright (c) 2004-2007 Fabrice Bellard
10 * Copyright (c) 2007 Jocelyn Mayer
12 * some parts from linux-2.6.29, arch/m68k/include/asm/mac_via.h
14 * This work is licensed under the terms of the GNU GPL, version 2 or later.
15 * See the COPYING file in the top-level directory.
18 #include "qemu/osdep.h"
19 #include "qemu-common.h"
20 #include "migration/vmstate.h"
21 #include "hw/sysbus.h"
23 #include "qemu/timer.h"
24 #include "hw/misc/mac_via.h"
25 #include "hw/misc/mos6522.h"
26 #include "hw/input/adb.h"
27 #include "sysemu/runstate.h"
28 #include "qapi/error.h"
29 #include "qemu/cutils.h"
33 * VIAs: There are two in every machine,
36 #define VIA_SIZE (0x2000)
39 * Not all of these are true post MacII I think.
40 * CSA: probably the ones CHRP marks as 'unused' change purposes
41 * when the IWM becomes the SWIM.
42 * http://www.rs6000.ibm.com/resource/technology/chrpio/via5.mak.html
43 * ftp://ftp.austin.ibm.com/pub/technology/spec/chrp/inwork/CHRP_IORef_1.0.pdf
45 * also, http://developer.apple.com/technotes/hw/hw_09.html claims the
46 * following changes for IIfx:
47 * VIA1A_vSccWrReq not available and that VIA1A_vSync has moved to an IOP.
48 * Also, "All of the functionality of VIA2 has been moved to other chips".
51 #define VIA1A_vSccWrReq 0x80 /*
53 * [CHRP] SCC WREQ: Reflects the state of the
54 * Wait/Request pins from the SCC.
55 * [Macintosh Family Hardware]
56 * as CHRP on SE/30,II,IIx,IIcx,IIci.
57 * on IIfx, "0 means an active request"
59 #define VIA1A_vRev8 0x40 /*
60 * Revision 8 board ???
61 * [CHRP] En WaitReqB: Lets the WaitReq_L
62 * signal from port B of the SCC appear on
63 * the PA7 input pin. Output.
64 * [Macintosh Family] On the SE/30, this
65 * is the bit to flip screen buffers.
66 * 0=alternate, 1=main.
67 * on II,IIx,IIcx,IIci,IIfx this is a bit
68 * for Rev ID. 0=II,IIx, 1=IIcx,IIci,IIfx
70 #define VIA1A_vHeadSel 0x20 /*
71 * Head select for IWM.
73 * [Macintosh Family] "Floppy disk
74 * state-control line SEL" on all but IIfx
76 #define VIA1A_vOverlay 0x10 /*
77 * [Macintosh Family] On SE/30,II,IIx,IIcx
78 * this bit enables the "Overlay" address
79 * map in the address decoders as it is on
80 * reset for mapping the ROM over the reset
81 * vector. 1=use overlay map.
82 * On the IIci,IIfx it is another bit of the
83 * CPU ID: 0=normal IIci, 1=IIci with parity
85 * [CHRP] En WaitReqA: Lets the WaitReq_L
86 * signal from port A of the SCC appear
87 * on the PA7 input pin (CHRP). Output.
88 * [MkLinux] "Drive Select"
89 * (with 0x20 being 'disk head select')
91 #define VIA1A_vSync 0x08 /*
92 * [CHRP] Sync Modem: modem clock select:
93 * 1: select the external serial clock to
94 * drive the SCC's /RTxCA pin.
95 * 0: Select the 3.6864MHz clock to drive
97 * [Macintosh Family] Correct on all but IIfx
101 * Macintosh Family Hardware sez: bits 0-2 of VIA1A are volume control
102 * on Macs which had the PWM sound hardware. Reserved on newer models.
103 * On IIci,IIfx, bits 1-2 are the rest of the CPU ID:
104 * bit 2: 1=IIci, 0=IIfx
105 * bit 1: 1 on both IIci and IIfx.
106 * MkLinux sez bit 0 is 'burnin flag' in this case.
107 * CHRP sez: VIA1A bits 0-2 and 5 are 'unused': if programmed as
108 * inputs, these bits will read 0.
110 #define VIA1A_vVolume 0x07 /* Audio volume mask for PWM */
111 #define VIA1A_CPUID0 0x02 /* CPU id bit 0 on RBV, others */
112 #define VIA1A_CPUID1 0x04 /* CPU id bit 0 on RBV, others */
113 #define VIA1A_CPUID2 0x10 /* CPU id bit 0 on RBV, others */
114 #define VIA1A_CPUID3 0x40 /* CPU id bit 0 on RBV, others */
117 * Info on VIA1B is from Macintosh Family Hardware & MkLinux.
118 * CHRP offers no info.
120 #define VIA1B_vSound 0x80 /*
121 * Sound enable (for compatibility with
122 * PWM hardware) 0=enabled.
123 * Also, on IIci w/parity, shows parity error
126 #define VIA1B_vMystery 0x40 /*
127 * On IIci, parity enable. 0=enabled,1=disabled
128 * On SE/30, vertical sync interrupt enable.
129 * 0=enabled. This vSync interrupt shows up
130 * as a slot $E interrupt.
132 #define VIA1B_vADBS2 0x20 /* ADB state input bit 1 (unused on IIfx) */
133 #define VIA1B_vADBS1 0x10 /* ADB state input bit 0 (unused on IIfx) */
134 #define VIA1B_vADBInt 0x08 /* ADB interrupt 0=interrupt (unused on IIfx)*/
135 #define VIA1B_vRTCEnb 0x04 /* Enable Real time clock. 0=enabled. */
136 #define VIA1B_vRTCClk 0x02 /* Real time clock serial-clock line. */
137 #define VIA1B_vRTCData 0x01 /* Real time clock serial-data line. */
140 * VIA2 A register is the interrupt lines raised off the nubus
142 * The below info is from 'Macintosh Family Hardware.'
143 * MkLinux calls the 'IIci internal video IRQ' below the 'RBV slot 0 irq.'
144 * It also notes that the slot $9 IRQ is the 'Ethernet IRQ' and
145 * defines the 'Video IRQ' as 0x40 for the 'EVR' VIA work-alike.
146 * Perhaps OSS uses vRAM1 and vRAM2 for ADB.
149 #define VIA2A_vRAM1 0x80 /* RAM size bit 1 (IIci: reserved) */
150 #define VIA2A_vRAM0 0x40 /* RAM size bit 0 (IIci: internal video IRQ) */
151 #define VIA2A_vIRQE 0x20 /* IRQ from slot $E */
152 #define VIA2A_vIRQD 0x10 /* IRQ from slot $D */
153 #define VIA2A_vIRQC 0x08 /* IRQ from slot $C */
154 #define VIA2A_vIRQB 0x04 /* IRQ from slot $B */
155 #define VIA2A_vIRQA 0x02 /* IRQ from slot $A */
156 #define VIA2A_vIRQ9 0x01 /* IRQ from slot $9 */
159 * RAM size bits decoded as follows:
160 * bit1 bit0 size of ICs in bank A
168 * Register B has the fun stuff in it
171 #define VIA2B_vVBL 0x80 /*
172 * VBL output to VIA1 (60.15Hz) driven by
174 * on IIci, parity test: 0=test mode.
175 * [MkLinux] RBV_PARODD: 1=odd,0=even.
177 #define VIA2B_vSndJck 0x40 /*
178 * External sound jack status.
179 * 0=plug is inserted. On SE/30, always 0
181 #define VIA2B_vTfr0 0x20 /* Transfer mode bit 0 ack from NuBus */
182 #define VIA2B_vTfr1 0x10 /* Transfer mode bit 1 ack from NuBus */
183 #define VIA2B_vMode32 0x08 /*
184 * 24/32bit switch - doubles as cache flush
185 * on II, AMU/PMMU control.
186 * if AMU, 0=24bit to 32bit translation
187 * if PMMU, 1=PMMU is accessing page table.
189 * on IIx,IIcx,IIfx, unused.
190 * on IIci/RBV, cache control. 0=flush cache.
192 #define VIA2B_vPower 0x04 /*
193 * Power off, 0=shut off power.
194 * on SE/30 this signal sent to PDS card.
196 #define VIA2B_vBusLk 0x02 /*
197 * Lock NuBus transactions, 0=locked.
198 * on SE/30 sent to PDS card.
200 #define VIA2B_vCDis 0x01 /*
201 * Cache control. On IIci, 1=disable cache card
202 * on others, 0=disable processor's instruction
206 /* interrupt flags */
212 #define VIA_IRQ_TIMER1 0x40
213 #define VIA_IRQ_TIMER2 0x20
216 * Apple sez: http://developer.apple.com/technotes/ov/ov_04.html
217 * Another example of a valid function that has no ROM support is the use
218 * of the alternate video page for page-flipping animation. Since there
219 * is no ROM call to flip pages, it is necessary to go play with the
220 * right bit in the VIA chip (6522 Versatile Interface Adapter).
221 * [CSA: don't know which one this is, but it's one of 'em!]
225 * 6522 registers - see databook.
226 * CSA: Assignments for VIA1 confirmed from CHRP spec.
229 /* partial address decode. 0xYYXX : XX part for RBV, YY part for VIA */
230 /* Note: 15 VIA regs, 8 RBV regs */
232 #define vBufB 0x0000 /* [VIA/RBV] Register B */
233 #define vBufAH 0x0200 /* [VIA only] Buffer A, with handshake. DON'T USE! */
234 #define vDirB 0x0400 /* [VIA only] Data Direction Register B. */
235 #define vDirA 0x0600 /* [VIA only] Data Direction Register A. */
236 #define vT1CL 0x0800 /* [VIA only] Timer one counter low. */
237 #define vT1CH 0x0a00 /* [VIA only] Timer one counter high. */
238 #define vT1LL 0x0c00 /* [VIA only] Timer one latches low. */
239 #define vT1LH 0x0e00 /* [VIA only] Timer one latches high. */
240 #define vT2CL 0x1000 /* [VIA only] Timer two counter low. */
241 #define vT2CH 0x1200 /* [VIA only] Timer two counter high. */
242 #define vSR 0x1400 /* [VIA only] Shift register. */
243 #define vACR 0x1600 /* [VIA only] Auxilary control register. */
244 #define vPCR 0x1800 /* [VIA only] Peripheral control register. */
246 * CHRP sez never ever to *write* this.
247 * Mac family says never to *change* this.
248 * In fact we need to initialize it once at start.
250 #define vIFR 0x1a00 /* [VIA/RBV] Interrupt flag register. */
251 #define vIER 0x1c00 /* [VIA/RBV] Interrupt enable register. */
252 #define vBufA 0x1e00 /* [VIA/RBV] register A (no handshake) */
254 /* from linux 2.6 drivers/macintosh/via-macii.c */
258 #define VIA1ACR_vShiftCtrl 0x1c /* Shift register control bits */
259 #define VIA1ACR_vShiftExtClk 0x0c /* Shift on external clock */
260 #define VIA1ACR_vShiftOut 0x10 /* Shift out if 1 */
263 * Apple Macintosh Family Hardware Refenece
264 * Table 19-10 ADB transaction states
267 #define ADB_STATE_NEW 0
268 #define ADB_STATE_EVEN 1
269 #define ADB_STATE_ODD 2
270 #define ADB_STATE_IDLE 3
272 #define VIA1B_vADB_StateMask (VIA1B_vADBS1 | VIA1B_vADBS2)
273 #define VIA1B_vADB_StateShift 4
275 #define VIA_TIMER_FREQ (783360)
276 #define VIA_ADB_POLL_FREQ 50 /* XXX: not real */
278 /* VIA returns time offset from Jan 1, 1904, not 1970 */
279 #define RTC_OFFSET 2082844800
281 static void via1_VBL_update(MOS6522Q800VIA1State
*v1s
)
283 MOS6522State
*s
= MOS6522(v1s
);
286 v1s
->next_VBL
= (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + 16630) /
289 if (s
->ier
& VIA1_IRQ_VBLANK
) {
290 timer_mod(v1s
->VBL_timer
, v1s
->next_VBL
);
292 timer_del(v1s
->VBL_timer
);
296 static void via1_one_second_update(MOS6522Q800VIA1State
*v1s
)
298 MOS6522State
*s
= MOS6522(v1s
);
300 v1s
->next_second
= (qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 1000) /
302 if (s
->ier
& VIA1_IRQ_ONE_SECOND
) {
303 timer_mod(v1s
->one_second_timer
, v1s
->next_second
);
305 timer_del(v1s
->one_second_timer
);
309 static void via1_VBL(void *opaque
)
311 MOS6522Q800VIA1State
*v1s
= opaque
;
312 MOS6522State
*s
= MOS6522(v1s
);
313 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(s
);
315 s
->ifr
|= VIA1_IRQ_VBLANK
;
318 via1_VBL_update(v1s
);
321 static void via1_one_second(void *opaque
)
323 MOS6522Q800VIA1State
*v1s
= opaque
;
324 MOS6522State
*s
= MOS6522(v1s
);
325 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(s
);
327 s
->ifr
|= VIA1_IRQ_ONE_SECOND
;
330 via1_one_second_update(v1s
);
333 static void via1_irq_request(void *opaque
, int irq
, int level
)
335 MOS6522Q800VIA1State
*v1s
= opaque
;
336 MOS6522State
*s
= MOS6522(v1s
);
337 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(s
);
342 s
->ifr
&= ~(1 << irq
);
348 static void via2_irq_request(void *opaque
, int irq
, int level
)
350 MOS6522Q800VIA2State
*v2s
= opaque
;
351 MOS6522State
*s
= MOS6522(v2s
);
352 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(s
);
357 s
->ifr
&= ~(1 << irq
);
363 static void via1_rtc_update(MacVIAState
*m
)
365 MOS6522Q800VIA1State
*v1s
= &m
->mos6522_via1
;
366 MOS6522State
*s
= MOS6522(v1s
);
368 if (s
->b
& VIA1B_vRTCEnb
) {
372 if (s
->dirb
& VIA1B_vRTCData
) {
373 /* send bits to the RTC */
374 if (!(v1s
->last_b
& VIA1B_vRTCClk
) && (s
->b
& VIA1B_vRTCClk
)) {
376 m
->data_out
|= s
->b
& VIA1B_vRTCData
;
380 /* receive bits from the RTC */
381 if ((v1s
->last_b
& VIA1B_vRTCClk
) &&
382 !(s
->b
& VIA1B_vRTCClk
) &&
384 s
->b
= (s
->b
& ~VIA1B_vRTCData
) |
385 ((m
->data_in
>> 7) & VIA1B_vRTCData
);
391 if (m
->data_out_cnt
== 8) {
395 if (m
->data_out
& 0x80) {
396 /* this is a read command */
397 uint32_t time
= m
->tick_offset
+
398 (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) /
399 NANOSECONDS_PER_SECOND
);
400 if (m
->data_out
== 0x81) { /* seconds register 0 */
401 m
->data_in
= time
& 0xff;
403 } else if (m
->data_out
== 0x85) { /* seconds register 1 */
404 m
->data_in
= (time
>> 8) & 0xff;
406 } else if (m
->data_out
== 0x89) { /* seconds register 2 */
407 m
->data_in
= (time
>> 16) & 0xff;
409 } else if (m
->data_out
== 0x8d) { /* seconds register 3 */
410 m
->data_in
= (time
>> 24) & 0xff;
412 } else if ((m
->data_out
& 0xf3) == 0xa1) {
413 /* PRAM address 0x10 -> 0x13 */
414 int addr
= (m
->data_out
>> 2) & 0x03;
415 m
->data_in
= v1s
->PRAM
[addr
];
417 } else if ((m
->data_out
& 0xf3) == 0xa1) {
418 /* PRAM address 0x00 -> 0x0f */
419 int addr
= (m
->data_out
>> 2) & 0x0f;
420 m
->data_in
= v1s
->PRAM
[addr
];
422 } else if ((m
->data_out
& 0xf8) == 0xb8) {
423 /* extended memory designator and sector number */
424 m
->cmd
= m
->data_out
;
427 /* this is a write command */
428 m
->cmd
= m
->data_out
;
432 if ((m
->cmd
& 0xf8) == 0xb8) {
433 /* extended memory designator and sector number */
434 int sector
= m
->cmd
& 0x07;
435 int addr
= (m
->data_out
>> 2) & 0x1f;
437 m
->data_in
= v1s
->PRAM
[sector
* 8 + addr
];
440 } else if (!m
->wprotect
) {
441 /* this is a write command */
443 /* extended memory designator and sector number */
444 int sector
= m
->cmd
& 0x07;
445 int addr
= (m
->alt
>> 2) & 0x1f;
447 v1s
->PRAM
[sector
* 8 + addr
] = m
->data_out
;
450 } else if (m
->cmd
== 0x01) { /* seconds register 0 */
452 } else if (m
->cmd
== 0x05) { /* seconds register 1 */
454 } else if (m
->cmd
== 0x09) { /* seconds register 2 */
456 } else if (m
->cmd
== 0x0d) { /* seconds register 3 */
458 } else if (m
->cmd
== 0x31) {
460 } else if (m
->cmd
== 0x35) {
461 /* Write Protect register */
462 m
->wprotect
= m
->data_out
& 1;
463 } else if ((m
->cmd
& 0xf3) == 0xa1) {
464 /* PRAM address 0x10 -> 0x13 */
465 int addr
= (m
->cmd
>> 2) & 0x03;
466 v1s
->PRAM
[addr
] = m
->data_out
;
467 } else if ((m
->cmd
& 0xf3) == 0xa1) {
468 /* PRAM address 0x00 -> 0x0f */
469 int addr
= (m
->cmd
>> 2) & 0x0f;
470 v1s
->PRAM
[addr
] = m
->data_out
;
471 } else if ((m
->cmd
& 0xf8) == 0xb8) {
472 /* extended memory designator and sector number */
481 static int adb_via_poll(MacVIAState
*s
, int state
, uint8_t *data
)
483 if (state
!= ADB_STATE_IDLE
) {
487 if (s
->adb_data_in_size
< s
->adb_data_in_index
) {
491 if (s
->adb_data_out_index
!= 0) {
495 s
->adb_data_in_index
= 0;
496 s
->adb_data_out_index
= 0;
497 s
->adb_data_in_size
= adb_poll(&s
->adb_bus
, s
->adb_data_in
, 0xffff);
499 if (s
->adb_data_in_size
) {
500 *data
= s
->adb_data_in
[s
->adb_data_in_index
++];
501 qemu_irq_raise(s
->adb_data_ready
);
504 return s
->adb_data_in_size
;
507 static int adb_via_send(MacVIAState
*s
, int state
, uint8_t data
)
511 s
->adb_data_out_index
= 0;
514 if ((s
->adb_data_out_index
& 1) == 0) {
519 if (s
->adb_data_out_index
& 1) {
527 assert(s
->adb_data_out_index
< sizeof(s
->adb_data_out
) - 1);
529 s
->adb_data_out
[s
->adb_data_out_index
++] = data
;
530 qemu_irq_raise(s
->adb_data_ready
);
534 static int adb_via_receive(MacVIAState
*s
, int state
, uint8_t *data
)
541 if (s
->adb_data_in_size
<= 0) {
542 qemu_irq_raise(s
->adb_data_ready
);
546 if (s
->adb_data_in_index
>= s
->adb_data_in_size
) {
548 qemu_irq_raise(s
->adb_data_ready
);
552 if ((s
->adb_data_in_index
& 1) == 0) {
559 if (s
->adb_data_in_size
<= 0) {
560 qemu_irq_raise(s
->adb_data_ready
);
564 if (s
->adb_data_in_index
>= s
->adb_data_in_size
) {
566 qemu_irq_raise(s
->adb_data_ready
);
570 if (s
->adb_data_in_index
& 1) {
577 if (s
->adb_data_out_index
== 0) {
581 s
->adb_data_in_size
= adb_request(&s
->adb_bus
, s
->adb_data_in
,
583 s
->adb_data_out_index
);
584 s
->adb_data_out_index
= 0;
585 s
->adb_data_in_index
= 0;
586 if (s
->adb_data_in_size
< 0) {
588 qemu_irq_raise(s
->adb_data_ready
);
592 if (s
->adb_data_in_size
== 0) {
599 assert(s
->adb_data_in_index
< sizeof(s
->adb_data_in
) - 1);
601 *data
= s
->adb_data_in
[s
->adb_data_in_index
++];
602 qemu_irq_raise(s
->adb_data_ready
);
603 if (*data
== 0xff || *data
== 0) {
609 static void via1_adb_update(MacVIAState
*m
)
611 MOS6522Q800VIA1State
*v1s
= MOS6522_Q800_VIA1(&m
->mos6522_via1
);
612 MOS6522State
*s
= MOS6522(v1s
);
616 state
= (s
->b
& VIA1B_vADB_StateMask
) >> VIA1B_vADB_StateShift
;
618 if (s
->acr
& VIA1ACR_vShiftOut
) {
620 ret
= adb_via_send(m
, state
, s
->sr
);
622 s
->b
&= ~VIA1B_vADBInt
;
624 s
->b
|= VIA1B_vADBInt
;
628 ret
= adb_via_receive(m
, state
, &s
->sr
);
629 if (ret
> 0 && s
->sr
!= 0xff) {
630 s
->b
&= ~VIA1B_vADBInt
;
632 s
->b
|= VIA1B_vADBInt
;
637 static void via_adb_poll(void *opaque
)
639 MacVIAState
*m
= opaque
;
640 MOS6522Q800VIA1State
*v1s
= MOS6522_Q800_VIA1(&m
->mos6522_via1
);
641 MOS6522State
*s
= MOS6522(v1s
);
644 if (s
->b
& VIA1B_vADBInt
) {
645 state
= (s
->b
& VIA1B_vADB_StateMask
) >> VIA1B_vADB_StateShift
;
646 if (adb_via_poll(m
, state
, &s
->sr
)) {
647 s
->b
&= ~VIA1B_vADBInt
;
651 timer_mod(m
->adb_poll_timer
,
652 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
653 (NANOSECONDS_PER_SECOND
/ VIA_ADB_POLL_FREQ
));
656 static uint64_t mos6522_q800_via1_read(void *opaque
, hwaddr addr
, unsigned size
)
658 MOS6522Q800VIA1State
*s
= MOS6522_Q800_VIA1(opaque
);
659 MOS6522State
*ms
= MOS6522(s
);
660 int64_t now
= qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
);
663 * If IRQs are disabled, timers are disabled, but we need to update
664 * VIA1_IRQ_VBLANK and VIA1_IRQ_ONE_SECOND bits in the IFR
667 if (now
>= s
->next_VBL
) {
668 ms
->ifr
|= VIA1_IRQ_VBLANK
;
671 if (now
>= s
->next_second
) {
672 ms
->ifr
|= VIA1_IRQ_ONE_SECOND
;
673 via1_one_second_update(s
);
676 addr
= (addr
>> 9) & 0xf;
677 return mos6522_read(ms
, addr
, size
);
680 static void mos6522_q800_via1_write(void *opaque
, hwaddr addr
, uint64_t val
,
683 MOS6522Q800VIA1State
*v1s
= MOS6522_Q800_VIA1(opaque
);
684 MOS6522State
*ms
= MOS6522(v1s
);
686 addr
= (addr
>> 9) & 0xf;
687 mos6522_write(ms
, addr
, val
, size
);
689 via1_one_second_update(v1s
);
690 via1_VBL_update(v1s
);
693 static const MemoryRegionOps mos6522_q800_via1_ops
= {
694 .read
= mos6522_q800_via1_read
,
695 .write
= mos6522_q800_via1_write
,
696 .endianness
= DEVICE_BIG_ENDIAN
,
698 .min_access_size
= 1,
699 .max_access_size
= 1,
703 static uint64_t mos6522_q800_via2_read(void *opaque
, hwaddr addr
, unsigned size
)
705 MOS6522Q800VIA2State
*s
= MOS6522_Q800_VIA2(opaque
);
706 MOS6522State
*ms
= MOS6522(s
);
708 addr
= (addr
>> 9) & 0xf;
709 return mos6522_read(ms
, addr
, size
);
712 static void mos6522_q800_via2_write(void *opaque
, hwaddr addr
, uint64_t val
,
715 MOS6522Q800VIA2State
*s
= MOS6522_Q800_VIA2(opaque
);
716 MOS6522State
*ms
= MOS6522(s
);
718 addr
= (addr
>> 9) & 0xf;
719 mos6522_write(ms
, addr
, val
, size
);
722 static const MemoryRegionOps mos6522_q800_via2_ops
= {
723 .read
= mos6522_q800_via2_read
,
724 .write
= mos6522_q800_via2_write
,
725 .endianness
= DEVICE_BIG_ENDIAN
,
727 .min_access_size
= 1,
728 .max_access_size
= 1,
732 static void mac_via_reset(DeviceState
*dev
)
734 MacVIAState
*m
= MAC_VIA(dev
);
735 MOS6522Q800VIA1State
*v1s
= &m
->mos6522_via1
;
737 timer_mod(m
->adb_poll_timer
,
738 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
739 (NANOSECONDS_PER_SECOND
/ VIA_ADB_POLL_FREQ
));
741 timer_del(v1s
->VBL_timer
);
743 timer_del(v1s
->one_second_timer
);
744 v1s
->next_second
= 0;
747 static void mac_via_realize(DeviceState
*dev
, Error
**errp
)
749 MacVIAState
*m
= MAC_VIA(dev
);
753 /* Init VIAs 1 and 2 */
754 sysbus_init_child_obj(OBJECT(dev
), "via1", &m
->mos6522_via1
,
755 sizeof(m
->mos6522_via1
), TYPE_MOS6522_Q800_VIA1
);
757 sysbus_init_child_obj(OBJECT(dev
), "via2", &m
->mos6522_via2
,
758 sizeof(m
->mos6522_via2
), TYPE_MOS6522_Q800_VIA2
);
760 /* Pass through mos6522 output IRQs */
761 ms
= MOS6522(&m
->mos6522_via1
);
762 object_property_add_alias(OBJECT(dev
), "irq[0]", OBJECT(ms
),
763 SYSBUS_DEVICE_GPIO_IRQ
"[0]", &error_abort
);
764 ms
= MOS6522(&m
->mos6522_via2
);
765 object_property_add_alias(OBJECT(dev
), "irq[1]", OBJECT(ms
),
766 SYSBUS_DEVICE_GPIO_IRQ
"[0]", &error_abort
);
768 /* Pass through mos6522 input IRQs */
769 qdev_pass_gpios(DEVICE(&m
->mos6522_via1
), dev
, "via1-irq");
770 qdev_pass_gpios(DEVICE(&m
->mos6522_via2
), dev
, "via2-irq");
773 m
->mos6522_via1
.one_second_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
776 m
->mos6522_via1
.VBL_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, via1_VBL
,
779 qemu_get_timedate(&tm
, 0);
780 m
->tick_offset
= (uint32_t)mktimegm(&tm
) + RTC_OFFSET
;
782 m
->adb_poll_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, via_adb_poll
, m
);
783 m
->adb_data_ready
= qdev_get_gpio_in_named(dev
, "via1-irq",
784 VIA1_IRQ_ADB_READY_BIT
);
787 static void mac_via_init(Object
*obj
)
789 SysBusDevice
*sbd
= SYS_BUS_DEVICE(obj
);
790 MacVIAState
*m
= MAC_VIA(obj
);
793 memory_region_init(&m
->mmio
, obj
, "mac-via", 2 * VIA_SIZE
);
794 sysbus_init_mmio(sbd
, &m
->mmio
);
796 memory_region_init_io(&m
->via1mem
, obj
, &mos6522_q800_via1_ops
,
797 &m
->mos6522_via1
, "via1", VIA_SIZE
);
798 memory_region_add_subregion(&m
->mmio
, 0x0, &m
->via1mem
);
800 memory_region_init_io(&m
->via2mem
, obj
, &mos6522_q800_via2_ops
,
801 &m
->mos6522_via2
, "via2", VIA_SIZE
);
802 memory_region_add_subregion(&m
->mmio
, VIA_SIZE
, &m
->via2mem
);
805 qbus_create_inplace((BusState
*)&m
->adb_bus
, sizeof(m
->adb_bus
),
806 TYPE_ADB_BUS
, DEVICE(obj
), "adb.0");
809 static const VMStateDescription vmstate_mac_via
= {
812 .minimum_version_id
= 1,
813 .fields
= (VMStateField
[]) {
815 VMSTATE_STRUCT(mos6522_via1
.parent_obj
, MacVIAState
, 0, vmstate_mos6522
,
817 VMSTATE_UINT8(mos6522_via1
.last_b
, MacVIAState
),
818 VMSTATE_BUFFER(mos6522_via1
.PRAM
, MacVIAState
),
819 VMSTATE_TIMER_PTR(mos6522_via1
.one_second_timer
, MacVIAState
),
820 VMSTATE_INT64(mos6522_via1
.next_second
, MacVIAState
),
821 VMSTATE_TIMER_PTR(mos6522_via1
.VBL_timer
, MacVIAState
),
822 VMSTATE_INT64(mos6522_via1
.next_VBL
, MacVIAState
),
823 VMSTATE_STRUCT(mos6522_via2
.parent_obj
, MacVIAState
, 0, vmstate_mos6522
,
826 VMSTATE_UINT32(tick_offset
, MacVIAState
),
827 VMSTATE_UINT8(data_out
, MacVIAState
),
828 VMSTATE_INT32(data_out_cnt
, MacVIAState
),
829 VMSTATE_UINT8(data_in
, MacVIAState
),
830 VMSTATE_UINT8(data_in_cnt
, MacVIAState
),
831 VMSTATE_UINT8(cmd
, MacVIAState
),
832 VMSTATE_INT32(wprotect
, MacVIAState
),
833 VMSTATE_INT32(alt
, MacVIAState
),
835 VMSTATE_TIMER_PTR(adb_poll_timer
, MacVIAState
),
836 VMSTATE_INT32(adb_data_in_size
, MacVIAState
),
837 VMSTATE_INT32(adb_data_in_index
, MacVIAState
),
838 VMSTATE_INT32(adb_data_out_index
, MacVIAState
),
839 VMSTATE_BUFFER(adb_data_in
, MacVIAState
),
840 VMSTATE_BUFFER(adb_data_out
, MacVIAState
),
841 VMSTATE_END_OF_LIST()
845 static void mac_via_class_init(ObjectClass
*oc
, void *data
)
847 DeviceClass
*dc
= DEVICE_CLASS(oc
);
849 dc
->realize
= mac_via_realize
;
850 dc
->reset
= mac_via_reset
;
851 dc
->vmsd
= &vmstate_mac_via
;
854 static TypeInfo mac_via_info
= {
855 .name
= TYPE_MAC_VIA
,
856 .parent
= TYPE_SYS_BUS_DEVICE
,
857 .instance_size
= sizeof(MacVIAState
),
858 .instance_init
= mac_via_init
,
859 .class_init
= mac_via_class_init
,
863 static void mos6522_q800_via1_portB_write(MOS6522State
*s
)
865 MOS6522Q800VIA1State
*v1s
= container_of(s
, MOS6522Q800VIA1State
,
867 MacVIAState
*m
= container_of(v1s
, MacVIAState
, mos6522_via1
);
875 static void mos6522_q800_via1_reset(DeviceState
*dev
)
877 MOS6522State
*ms
= MOS6522(dev
);
878 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(ms
);
880 mdc
->parent_reset(dev
);
882 ms
->timers
[0].frequency
= VIA_TIMER_FREQ
;
883 ms
->timers
[1].frequency
= VIA_TIMER_FREQ
;
885 ms
->b
= VIA1B_vADB_StateMask
| VIA1B_vADBInt
| VIA1B_vRTCEnb
;
888 static void mos6522_q800_via1_init(Object
*obj
)
890 qdev_init_gpio_in_named(DEVICE(obj
), via1_irq_request
, "via1-irq",
894 static void mos6522_q800_via1_class_init(ObjectClass
*oc
, void *data
)
896 DeviceClass
*dc
= DEVICE_CLASS(oc
);
897 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_CLASS(oc
);
899 dc
->reset
= mos6522_q800_via1_reset
;
900 mdc
->portB_write
= mos6522_q800_via1_portB_write
;
903 static const TypeInfo mos6522_q800_via1_type_info
= {
904 .name
= TYPE_MOS6522_Q800_VIA1
,
905 .parent
= TYPE_MOS6522
,
906 .instance_size
= sizeof(MOS6522Q800VIA1State
),
907 .instance_init
= mos6522_q800_via1_init
,
908 .class_init
= mos6522_q800_via1_class_init
,
912 static void mos6522_q800_via2_portB_write(MOS6522State
*s
)
914 if (s
->dirb
& VIA2B_vPower
&& (s
->b
& VIA2B_vPower
) == 0) {
916 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
920 static void mos6522_q800_via2_reset(DeviceState
*dev
)
922 MOS6522State
*ms
= MOS6522(dev
);
923 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(ms
);
925 mdc
->parent_reset(dev
);
927 ms
->timers
[0].frequency
= VIA_TIMER_FREQ
;
928 ms
->timers
[1].frequency
= VIA_TIMER_FREQ
;
934 static void mos6522_q800_via2_init(Object
*obj
)
936 qdev_init_gpio_in_named(DEVICE(obj
), via2_irq_request
, "via2-irq",
940 static void mos6522_q800_via2_class_init(ObjectClass
*oc
, void *data
)
942 DeviceClass
*dc
= DEVICE_CLASS(oc
);
943 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_CLASS(oc
);
945 dc
->reset
= mos6522_q800_via2_reset
;
946 mdc
->portB_write
= mos6522_q800_via2_portB_write
;
949 static const TypeInfo mos6522_q800_via2_type_info
= {
950 .name
= TYPE_MOS6522_Q800_VIA2
,
951 .parent
= TYPE_MOS6522
,
952 .instance_size
= sizeof(MOS6522Q800VIA2State
),
953 .instance_init
= mos6522_q800_via2_init
,
954 .class_init
= mos6522_q800_via2_class_init
,
957 static void mac_via_register_types(void)
959 type_register_static(&mos6522_q800_via1_type_info
);
960 type_register_static(&mos6522_q800_via2_type_info
);
961 type_register_static(&mac_via_info
);
964 type_init(mac_via_register_types
);