2 * QEMU PowerMac CUDA device support
4 * Copyright (c) 2004-2007 Fabrice Bellard
5 * Copyright (c) 2007 Jocelyn Mayer
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 "qemu/osdep.h"
27 #include "qemu-common.h"
28 #include "hw/ppc/mac.h"
29 #include "migration/vmstate.h"
30 #include "hw/input/adb.h"
31 #include "hw/misc/mos6522.h"
32 #include "hw/misc/macio/cuda.h"
33 #include "qemu/timer.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/cutils.h"
37 #include "qemu/module.h"
40 /* Bits in B data register: all active low */
41 #define TREQ 0x08 /* Transfer request (input) */
42 #define TACK 0x10 /* Transfer acknowledge (output) */
43 #define TIP 0x20 /* Transfer in progress (output) */
45 /* commands (1st byte) */
48 #define ERROR_PACKET 2
49 #define TIMER_PACKET 3
50 #define POWER_PACKET 4
51 #define MACIIC_PACKET 5
54 #define CUDA_TIMER_FREQ (4700000 / 6)
56 /* CUDA returns time_t's offset from Jan 1, 1904, not 1970 */
57 #define RTC_OFFSET 2082844800
59 static void cuda_receive_packet_from_host(CUDAState
*s
,
60 const uint8_t *data
, int len
);
62 /* MacOS uses timer 1 for calibration on startup, so we use
63 * the timebase frequency and cuda_get_counter_value() with
64 * cuda_get_load_time() to steer MacOS to calculate calibrate its timers
65 * correctly for both TCG and KVM (see commit b981289c49 "PPC: Cuda: Use cuda
66 * timer to expose tbfreq to guest" for more information) */
68 static uint64_t cuda_get_counter_value(MOS6522State
*s
, MOS6522Timer
*ti
)
70 MOS6522CUDAState
*mcs
= container_of(s
, MOS6522CUDAState
, parent_obj
);
71 CUDAState
*cs
= container_of(mcs
, CUDAState
, mos6522_cuda
);
73 /* Reverse of the tb calculation algorithm that Mac OS X uses on bootup */
74 uint64_t tb_diff
= muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
),
75 cs
->tb_frequency
, NANOSECONDS_PER_SECOND
) -
78 return (tb_diff
* 0xBF401675E5DULL
) / (cs
->tb_frequency
<< 24);
81 static uint64_t cuda_get_load_time(MOS6522State
*s
, MOS6522Timer
*ti
)
83 MOS6522CUDAState
*mcs
= container_of(s
, MOS6522CUDAState
, parent_obj
);
84 CUDAState
*cs
= container_of(mcs
, CUDAState
, mos6522_cuda
);
86 uint64_t load_time
= muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
),
87 cs
->tb_frequency
, NANOSECONDS_PER_SECOND
);
91 static void cuda_set_sr_int(void *opaque
)
93 CUDAState
*s
= opaque
;
94 MOS6522CUDAState
*mcs
= &s
->mos6522_cuda
;
95 MOS6522State
*ms
= MOS6522(mcs
);
96 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(ms
);
101 static void cuda_delay_set_sr_int(CUDAState
*s
)
105 trace_cuda_delay_set_sr_int();
107 expire
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + s
->sr_delay_ns
;
108 timer_mod(s
->sr_delay_timer
, expire
);
111 /* NOTE: TIP and TREQ are negated */
112 static void cuda_update(CUDAState
*s
)
114 MOS6522CUDAState
*mcs
= &s
->mos6522_cuda
;
115 MOS6522State
*ms
= MOS6522(mcs
);
116 int packet_received
, len
;
119 if (!(ms
->b
& TIP
)) {
120 /* transfer requested from host */
122 if (ms
->acr
& SR_OUT
) {
124 if ((ms
->b
& (TACK
| TIP
)) != (s
->last_b
& (TACK
| TIP
))) {
125 if (s
->data_out_index
< sizeof(s
->data_out
)) {
126 trace_cuda_data_send(ms
->sr
);
127 s
->data_out
[s
->data_out_index
++] = ms
->sr
;
128 cuda_delay_set_sr_int(s
);
132 if (s
->data_in_index
< s
->data_in_size
) {
134 if ((ms
->b
& (TACK
| TIP
)) != (s
->last_b
& (TACK
| TIP
))) {
135 ms
->sr
= s
->data_in
[s
->data_in_index
++];
136 trace_cuda_data_recv(ms
->sr
);
137 /* indicate end of transfer */
138 if (s
->data_in_index
>= s
->data_in_size
) {
139 ms
->b
= (ms
->b
| TREQ
);
141 cuda_delay_set_sr_int(s
);
146 /* no transfer requested: handle sync case */
147 if ((s
->last_b
& TIP
) && (ms
->b
& TACK
) != (s
->last_b
& TACK
)) {
148 /* update TREQ state each time TACK change state */
150 ms
->b
= (ms
->b
| TREQ
);
152 ms
->b
= (ms
->b
& ~TREQ
);
154 cuda_delay_set_sr_int(s
);
156 if (!(s
->last_b
& TIP
)) {
157 /* handle end of host to cuda transfer */
158 packet_received
= (s
->data_out_index
> 0);
159 /* always an IRQ at the end of transfer */
160 cuda_delay_set_sr_int(s
);
162 /* signal if there is data to read */
163 if (s
->data_in_index
< s
->data_in_size
) {
164 ms
->b
= (ms
->b
& ~TREQ
);
169 s
->last_acr
= ms
->acr
;
172 /* NOTE: cuda_receive_packet_from_host() can call cuda_update()
174 if (packet_received
) {
175 len
= s
->data_out_index
;
176 s
->data_out_index
= 0;
177 cuda_receive_packet_from_host(s
, s
->data_out
, len
);
181 static void cuda_send_packet_to_host(CUDAState
*s
,
182 const uint8_t *data
, int len
)
186 trace_cuda_packet_send(len
);
187 for (i
= 0; i
< len
; i
++) {
188 trace_cuda_packet_send_data(i
, data
[i
]);
191 memcpy(s
->data_in
, data
, len
);
192 s
->data_in_size
= len
;
193 s
->data_in_index
= 0;
195 cuda_delay_set_sr_int(s
);
198 static void cuda_adb_poll(void *opaque
)
200 CUDAState
*s
= opaque
;
201 uint8_t obuf
[ADB_MAX_OUT_LEN
+ 2];
204 olen
= adb_poll(&s
->adb_bus
, obuf
+ 2, s
->adb_poll_mask
);
206 obuf
[0] = ADB_PACKET
;
207 obuf
[1] = 0x40; /* polled data */
208 cuda_send_packet_to_host(s
, obuf
, olen
+ 2);
210 timer_mod(s
->adb_poll_timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
211 (NANOSECONDS_PER_SECOND
/ (1000 / s
->autopoll_rate_ms
)));
214 /* description of commands */
215 typedef struct CudaCommand
{
218 bool (*handler
)(CUDAState
*s
,
219 const uint8_t *in_args
, int in_len
,
220 uint8_t *out_args
, int *out_len
);
223 static bool cuda_cmd_autopoll(CUDAState
*s
,
224 const uint8_t *in_data
, int in_len
,
225 uint8_t *out_data
, int *out_len
)
233 autopoll
= (in_data
[0] != 0);
234 if (autopoll
!= s
->autopoll
) {
235 s
->autopoll
= autopoll
;
237 timer_mod(s
->adb_poll_timer
,
238 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
239 (NANOSECONDS_PER_SECOND
/ (1000 / s
->autopoll_rate_ms
)));
241 timer_del(s
->adb_poll_timer
);
247 static bool cuda_cmd_set_autorate(CUDAState
*s
,
248 const uint8_t *in_data
, int in_len
,
249 uint8_t *out_data
, int *out_len
)
255 /* we don't want a period of 0 ms */
256 /* FIXME: check what real hardware does */
257 if (in_data
[0] == 0) {
261 s
->autopoll_rate_ms
= in_data
[0];
263 timer_mod(s
->adb_poll_timer
,
264 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
265 (NANOSECONDS_PER_SECOND
/ (1000 / s
->autopoll_rate_ms
)));
270 static bool cuda_cmd_set_device_list(CUDAState
*s
,
271 const uint8_t *in_data
, int in_len
,
272 uint8_t *out_data
, int *out_len
)
278 s
->adb_poll_mask
= (((uint16_t)in_data
[0]) << 8) | in_data
[1];
282 static bool cuda_cmd_powerdown(CUDAState
*s
,
283 const uint8_t *in_data
, int in_len
,
284 uint8_t *out_data
, int *out_len
)
290 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
294 static bool cuda_cmd_reset_system(CUDAState
*s
,
295 const uint8_t *in_data
, int in_len
,
296 uint8_t *out_data
, int *out_len
)
302 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
306 static bool cuda_cmd_set_file_server_flag(CUDAState
*s
,
307 const uint8_t *in_data
, int in_len
,
308 uint8_t *out_data
, int *out_len
)
314 qemu_log_mask(LOG_UNIMP
,
315 "CUDA: unimplemented command FILE_SERVER_FLAG %d\n",
320 static bool cuda_cmd_set_power_message(CUDAState
*s
,
321 const uint8_t *in_data
, int in_len
,
322 uint8_t *out_data
, int *out_len
)
328 qemu_log_mask(LOG_UNIMP
,
329 "CUDA: unimplemented command SET_POWER_MESSAGE %d\n",
334 static bool cuda_cmd_get_time(CUDAState
*s
,
335 const uint8_t *in_data
, int in_len
,
336 uint8_t *out_data
, int *out_len
)
344 ti
= s
->tick_offset
+ (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
345 / NANOSECONDS_PER_SECOND
);
346 out_data
[0] = ti
>> 24;
347 out_data
[1] = ti
>> 16;
348 out_data
[2] = ti
>> 8;
354 static bool cuda_cmd_set_time(CUDAState
*s
,
355 const uint8_t *in_data
, int in_len
,
356 uint8_t *out_data
, int *out_len
)
364 ti
= (((uint32_t)in_data
[0]) << 24) + (((uint32_t)in_data
[1]) << 16)
365 + (((uint32_t)in_data
[2]) << 8) + in_data
[3];
366 s
->tick_offset
= ti
- (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
367 / NANOSECONDS_PER_SECOND
);
371 static const CudaCommand handlers
[] = {
372 { CUDA_AUTOPOLL
, "AUTOPOLL", cuda_cmd_autopoll
},
373 { CUDA_SET_AUTO_RATE
, "SET_AUTO_RATE", cuda_cmd_set_autorate
},
374 { CUDA_SET_DEVICE_LIST
, "SET_DEVICE_LIST", cuda_cmd_set_device_list
},
375 { CUDA_POWERDOWN
, "POWERDOWN", cuda_cmd_powerdown
},
376 { CUDA_RESET_SYSTEM
, "RESET_SYSTEM", cuda_cmd_reset_system
},
377 { CUDA_FILE_SERVER_FLAG
, "FILE_SERVER_FLAG",
378 cuda_cmd_set_file_server_flag
},
379 { CUDA_SET_POWER_MESSAGES
, "SET_POWER_MESSAGES",
380 cuda_cmd_set_power_message
},
381 { CUDA_GET_TIME
, "GET_TIME", cuda_cmd_get_time
},
382 { CUDA_SET_TIME
, "SET_TIME", cuda_cmd_set_time
},
385 static void cuda_receive_packet(CUDAState
*s
,
386 const uint8_t *data
, int len
)
388 uint8_t obuf
[16] = { CUDA_PACKET
, 0, data
[0] };
391 for (i
= 0; i
< ARRAY_SIZE(handlers
); i
++) {
392 const CudaCommand
*desc
= &handlers
[i
];
393 if (desc
->command
== data
[0]) {
394 trace_cuda_receive_packet_cmd(desc
->name
);
396 if (desc
->handler(s
, data
+ 1, len
- 1, obuf
+ 3, &out_len
)) {
397 cuda_send_packet_to_host(s
, obuf
, 3 + out_len
);
399 qemu_log_mask(LOG_GUEST_ERROR
,
400 "CUDA: %s: wrong parameters %d\n",
402 obuf
[0] = ERROR_PACKET
;
403 obuf
[1] = 0x5; /* bad parameters */
404 obuf
[2] = CUDA_PACKET
;
406 cuda_send_packet_to_host(s
, obuf
, 4);
412 qemu_log_mask(LOG_GUEST_ERROR
, "CUDA: unknown command 0x%02x\n", data
[0]);
413 obuf
[0] = ERROR_PACKET
;
414 obuf
[1] = 0x2; /* unknown command */
415 obuf
[2] = CUDA_PACKET
;
417 cuda_send_packet_to_host(s
, obuf
, 4);
420 static void cuda_receive_packet_from_host(CUDAState
*s
,
421 const uint8_t *data
, int len
)
425 trace_cuda_packet_receive(len
);
426 for (i
= 0; i
< len
; i
++) {
427 trace_cuda_packet_receive_data(i
, data
[i
]);
433 uint8_t obuf
[ADB_MAX_OUT_LEN
+ 3];
435 olen
= adb_request(&s
->adb_bus
, obuf
+ 2, data
+ 1, len
- 1);
437 obuf
[0] = ADB_PACKET
;
439 cuda_send_packet_to_host(s
, obuf
, olen
+ 2);
442 obuf
[0] = ADB_PACKET
;
446 cuda_send_packet_to_host(s
, obuf
, olen
+ 3);
451 cuda_receive_packet(s
, data
+ 1, len
- 1);
456 static uint64_t mos6522_cuda_read(void *opaque
, hwaddr addr
, unsigned size
)
458 CUDAState
*s
= opaque
;
459 MOS6522CUDAState
*mcs
= &s
->mos6522_cuda
;
460 MOS6522State
*ms
= MOS6522(mcs
);
462 addr
= (addr
>> 9) & 0xf;
463 return mos6522_read(ms
, addr
, size
);
466 static void mos6522_cuda_write(void *opaque
, hwaddr addr
, uint64_t val
,
469 CUDAState
*s
= opaque
;
470 MOS6522CUDAState
*mcs
= &s
->mos6522_cuda
;
471 MOS6522State
*ms
= MOS6522(mcs
);
473 addr
= (addr
>> 9) & 0xf;
474 mos6522_write(ms
, addr
, val
, size
);
477 static const MemoryRegionOps mos6522_cuda_ops
= {
478 .read
= mos6522_cuda_read
,
479 .write
= mos6522_cuda_write
,
480 .endianness
= DEVICE_BIG_ENDIAN
,
482 .min_access_size
= 1,
483 .max_access_size
= 1,
487 static const VMStateDescription vmstate_cuda
= {
490 .minimum_version_id
= 5,
491 .fields
= (VMStateField
[]) {
492 VMSTATE_STRUCT(mos6522_cuda
.parent_obj
, CUDAState
, 0, vmstate_mos6522
,
494 VMSTATE_UINT8(last_b
, CUDAState
),
495 VMSTATE_UINT8(last_acr
, CUDAState
),
496 VMSTATE_INT32(data_in_size
, CUDAState
),
497 VMSTATE_INT32(data_in_index
, CUDAState
),
498 VMSTATE_INT32(data_out_index
, CUDAState
),
499 VMSTATE_UINT8(autopoll
, CUDAState
),
500 VMSTATE_UINT8(autopoll_rate_ms
, CUDAState
),
501 VMSTATE_UINT16(adb_poll_mask
, CUDAState
),
502 VMSTATE_BUFFER(data_in
, CUDAState
),
503 VMSTATE_BUFFER(data_out
, CUDAState
),
504 VMSTATE_UINT32(tick_offset
, CUDAState
),
505 VMSTATE_TIMER_PTR(adb_poll_timer
, CUDAState
),
506 VMSTATE_TIMER_PTR(sr_delay_timer
, CUDAState
),
507 VMSTATE_END_OF_LIST()
511 static void cuda_reset(DeviceState
*dev
)
513 CUDAState
*s
= CUDA(dev
);
516 s
->data_in_index
= 0;
517 s
->data_out_index
= 0;
521 static void cuda_realize(DeviceState
*dev
, Error
**errp
)
523 CUDAState
*s
= CUDA(dev
);
529 /* Pass IRQ from 6522 */
530 d
= DEVICE(&s
->mos6522_cuda
);
532 sbd
= SYS_BUS_DEVICE(s
);
533 sysbus_pass_irq(sbd
, SYS_BUS_DEVICE(ms
));
535 qemu_get_timedate(&tm
, 0);
536 s
->tick_offset
= (uint32_t)mktimegm(&tm
) + RTC_OFFSET
;
538 s
->sr_delay_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, cuda_set_sr_int
, s
);
539 s
->sr_delay_ns
= 20 * SCALE_US
;
541 s
->adb_poll_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, cuda_adb_poll
, s
);
542 s
->adb_poll_mask
= 0xffff;
543 s
->autopoll_rate_ms
= 20;
546 static void cuda_init(Object
*obj
)
548 CUDAState
*s
= CUDA(obj
);
549 SysBusDevice
*sbd
= SYS_BUS_DEVICE(obj
);
551 sysbus_init_child_obj(obj
, "mos6522-cuda", &s
->mos6522_cuda
,
552 sizeof(s
->mos6522_cuda
), TYPE_MOS6522_CUDA
);
554 memory_region_init_io(&s
->mem
, obj
, &mos6522_cuda_ops
, s
, "cuda", 0x2000);
555 sysbus_init_mmio(sbd
, &s
->mem
);
557 qbus_create_inplace(&s
->adb_bus
, sizeof(s
->adb_bus
), TYPE_ADB_BUS
,
558 DEVICE(obj
), "adb.0");
561 static Property cuda_properties
[] = {
562 DEFINE_PROP_UINT64("timebase-frequency", CUDAState
, tb_frequency
, 0),
563 DEFINE_PROP_END_OF_LIST()
566 static void cuda_class_init(ObjectClass
*oc
, void *data
)
568 DeviceClass
*dc
= DEVICE_CLASS(oc
);
570 dc
->realize
= cuda_realize
;
571 dc
->reset
= cuda_reset
;
572 dc
->vmsd
= &vmstate_cuda
;
573 dc
->props
= cuda_properties
;
574 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
577 static const TypeInfo cuda_type_info
= {
579 .parent
= TYPE_SYS_BUS_DEVICE
,
580 .instance_size
= sizeof(CUDAState
),
581 .instance_init
= cuda_init
,
582 .class_init
= cuda_class_init
,
585 static void mos6522_cuda_portB_write(MOS6522State
*s
)
587 MOS6522CUDAState
*mcs
= container_of(s
, MOS6522CUDAState
, parent_obj
);
588 CUDAState
*cs
= container_of(mcs
, CUDAState
, mos6522_cuda
);
593 static void mos6522_cuda_reset(DeviceState
*dev
)
595 MOS6522State
*ms
= MOS6522(dev
);
596 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_GET_CLASS(ms
);
598 mdc
->parent_reset(dev
);
600 ms
->timers
[0].frequency
= CUDA_TIMER_FREQ
;
601 ms
->timers
[1].frequency
= (SCALE_US
* 6000) / 4700;
604 static void mos6522_cuda_class_init(ObjectClass
*oc
, void *data
)
606 DeviceClass
*dc
= DEVICE_CLASS(oc
);
607 MOS6522DeviceClass
*mdc
= MOS6522_DEVICE_CLASS(oc
);
609 dc
->reset
= mos6522_cuda_reset
;
610 mdc
->portB_write
= mos6522_cuda_portB_write
;
611 mdc
->get_timer1_counter_value
= cuda_get_counter_value
;
612 mdc
->get_timer2_counter_value
= cuda_get_counter_value
;
613 mdc
->get_timer1_load_time
= cuda_get_load_time
;
614 mdc
->get_timer2_load_time
= cuda_get_load_time
;
617 static const TypeInfo mos6522_cuda_type_info
= {
618 .name
= TYPE_MOS6522_CUDA
,
619 .parent
= TYPE_MOS6522
,
620 .instance_size
= sizeof(MOS6522CUDAState
),
621 .class_init
= mos6522_cuda_class_init
,
624 static void cuda_register_types(void)
626 type_register_static(&mos6522_cuda_type_info
);
627 type_register_static(&cuda_type_info
);
630 type_init(cuda_register_types
)