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"
28 #include "hw/qdev-properties.h"
29 #include "migration/vmstate.h"
30 #include "hw/misc/macio/cuda.h"
31 #include "qemu/timer.h"
32 #include "sysemu/runstate.h"
33 #include "sysemu/rtc.h"
34 #include "qapi/error.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 qemu_irq irq
= qdev_get_gpio_in(DEVICE(ms
), SR_INT_BIT
);
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 ADBBusState
*adb_bus
= &s
->adb_bus
;
117 int packet_received
, len
;
120 if (!(ms
->b
& TIP
)) {
121 /* transfer requested from host */
123 if (ms
->acr
& SR_OUT
) {
125 if ((ms
->b
& (TACK
| TIP
)) != (s
->last_b
& (TACK
| TIP
))) {
126 if (s
->data_out_index
< sizeof(s
->data_out
)) {
127 if (s
->data_out_index
== 0) {
128 adb_autopoll_block(adb_bus
);
130 trace_cuda_data_send(ms
->sr
);
131 s
->data_out
[s
->data_out_index
++] = ms
->sr
;
132 cuda_delay_set_sr_int(s
);
136 if (s
->data_in_index
< s
->data_in_size
) {
138 if ((ms
->b
& (TACK
| TIP
)) != (s
->last_b
& (TACK
| TIP
))) {
139 ms
->sr
= s
->data_in
[s
->data_in_index
++];
140 trace_cuda_data_recv(ms
->sr
);
141 /* indicate end of transfer */
142 if (s
->data_in_index
>= s
->data_in_size
) {
143 ms
->b
= (ms
->b
| TREQ
);
144 adb_autopoll_unblock(adb_bus
);
146 cuda_delay_set_sr_int(s
);
151 /* no transfer requested: handle sync case */
152 if ((s
->last_b
& TIP
) && (ms
->b
& TACK
) != (s
->last_b
& TACK
)) {
153 /* update TREQ state each time TACK change state */
155 ms
->b
= (ms
->b
| TREQ
);
157 ms
->b
= (ms
->b
& ~TREQ
);
159 cuda_delay_set_sr_int(s
);
161 if (!(s
->last_b
& TIP
)) {
162 /* handle end of host to cuda transfer */
163 packet_received
= (s
->data_out_index
> 0);
164 /* always an IRQ at the end of transfer */
165 cuda_delay_set_sr_int(s
);
167 /* signal if there is data to read */
168 if (s
->data_in_index
< s
->data_in_size
) {
169 ms
->b
= (ms
->b
& ~TREQ
);
174 s
->last_acr
= ms
->acr
;
177 /* NOTE: cuda_receive_packet_from_host() can call cuda_update()
179 if (packet_received
) {
180 len
= s
->data_out_index
;
181 s
->data_out_index
= 0;
182 cuda_receive_packet_from_host(s
, s
->data_out
, len
);
186 static void cuda_send_packet_to_host(CUDAState
*s
,
187 const uint8_t *data
, int len
)
191 trace_cuda_packet_send(len
);
192 for (i
= 0; i
< len
; i
++) {
193 trace_cuda_packet_send_data(i
, data
[i
]);
196 memcpy(s
->data_in
, data
, len
);
197 s
->data_in_size
= len
;
198 s
->data_in_index
= 0;
200 cuda_delay_set_sr_int(s
);
203 static void cuda_adb_poll(void *opaque
)
205 CUDAState
*s
= opaque
;
206 ADBBusState
*adb_bus
= &s
->adb_bus
;
207 uint8_t obuf
[ADB_MAX_OUT_LEN
+ 2];
210 olen
= adb_poll(adb_bus
, obuf
+ 2, adb_bus
->autopoll_mask
);
212 obuf
[0] = ADB_PACKET
;
213 obuf
[1] = 0x40; /* polled data */
214 cuda_send_packet_to_host(s
, obuf
, olen
+ 2);
218 /* description of commands */
219 typedef struct CudaCommand
{
222 bool (*handler
)(CUDAState
*s
,
223 const uint8_t *in_args
, int in_len
,
224 uint8_t *out_args
, int *out_len
);
227 static bool cuda_cmd_autopoll(CUDAState
*s
,
228 const uint8_t *in_data
, int in_len
,
229 uint8_t *out_data
, int *out_len
)
231 ADBBusState
*adb_bus
= &s
->adb_bus
;
238 autopoll
= (in_data
[0] != 0) ? true : false;
240 adb_set_autopoll_enabled(adb_bus
, autopoll
);
244 static bool cuda_cmd_set_autorate(CUDAState
*s
,
245 const uint8_t *in_data
, int in_len
,
246 uint8_t *out_data
, int *out_len
)
248 ADBBusState
*adb_bus
= &s
->adb_bus
;
254 /* we don't want a period of 0 ms */
255 /* FIXME: check what real hardware does */
256 if (in_data
[0] == 0) {
260 adb_set_autopoll_rate_ms(adb_bus
, in_data
[0]);
264 static bool cuda_cmd_set_device_list(CUDAState
*s
,
265 const uint8_t *in_data
, int in_len
,
266 uint8_t *out_data
, int *out_len
)
268 ADBBusState
*adb_bus
= &s
->adb_bus
;
275 mask
= (((uint16_t)in_data
[0]) << 8) | in_data
[1];
277 adb_set_autopoll_mask(adb_bus
, mask
);
281 static bool cuda_cmd_powerdown(CUDAState
*s
,
282 const uint8_t *in_data
, int in_len
,
283 uint8_t *out_data
, int *out_len
)
289 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
293 static bool cuda_cmd_reset_system(CUDAState
*s
,
294 const uint8_t *in_data
, int in_len
,
295 uint8_t *out_data
, int *out_len
)
301 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
305 static bool cuda_cmd_set_file_server_flag(CUDAState
*s
,
306 const uint8_t *in_data
, int in_len
,
307 uint8_t *out_data
, int *out_len
)
313 qemu_log_mask(LOG_UNIMP
,
314 "CUDA: unimplemented command FILE_SERVER_FLAG %d\n",
319 static bool cuda_cmd_set_power_message(CUDAState
*s
,
320 const uint8_t *in_data
, int in_len
,
321 uint8_t *out_data
, int *out_len
)
327 qemu_log_mask(LOG_UNIMP
,
328 "CUDA: unimplemented command SET_POWER_MESSAGE %d\n",
333 static bool cuda_cmd_get_time(CUDAState
*s
,
334 const uint8_t *in_data
, int in_len
,
335 uint8_t *out_data
, int *out_len
)
343 ti
= s
->tick_offset
+ (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
344 / NANOSECONDS_PER_SECOND
);
345 out_data
[0] = ti
>> 24;
346 out_data
[1] = ti
>> 16;
347 out_data
[2] = ti
>> 8;
353 static bool cuda_cmd_set_time(CUDAState
*s
,
354 const uint8_t *in_data
, int in_len
,
355 uint8_t *out_data
, int *out_len
)
363 ti
= (((uint32_t)in_data
[0]) << 24) + (((uint32_t)in_data
[1]) << 16)
364 + (((uint32_t)in_data
[2]) << 8) + in_data
[3];
365 s
->tick_offset
= ti
- (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
366 / NANOSECONDS_PER_SECOND
);
370 static const CudaCommand handlers
[] = {
371 { CUDA_AUTOPOLL
, "AUTOPOLL", cuda_cmd_autopoll
},
372 { CUDA_SET_AUTO_RATE
, "SET_AUTO_RATE", cuda_cmd_set_autorate
},
373 { CUDA_SET_DEVICE_LIST
, "SET_DEVICE_LIST", cuda_cmd_set_device_list
},
374 { CUDA_POWERDOWN
, "POWERDOWN", cuda_cmd_powerdown
},
375 { CUDA_RESET_SYSTEM
, "RESET_SYSTEM", cuda_cmd_reset_system
},
376 { CUDA_FILE_SERVER_FLAG
, "FILE_SERVER_FLAG",
377 cuda_cmd_set_file_server_flag
},
378 { CUDA_SET_POWER_MESSAGES
, "SET_POWER_MESSAGES",
379 cuda_cmd_set_power_message
},
380 { CUDA_GET_TIME
, "GET_TIME", cuda_cmd_get_time
},
381 { CUDA_SET_TIME
, "SET_TIME", cuda_cmd_set_time
},
384 static void cuda_receive_packet(CUDAState
*s
,
385 const uint8_t *data
, int len
)
387 uint8_t obuf
[16] = { CUDA_PACKET
, 0, data
[0] };
390 for (i
= 0; i
< ARRAY_SIZE(handlers
); i
++) {
391 const CudaCommand
*desc
= &handlers
[i
];
392 if (desc
->command
== data
[0]) {
393 trace_cuda_receive_packet_cmd(desc
->name
);
395 if (desc
->handler(s
, data
+ 1, len
- 1, obuf
+ 3, &out_len
)) {
396 cuda_send_packet_to_host(s
, obuf
, 3 + out_len
);
398 qemu_log_mask(LOG_GUEST_ERROR
,
399 "CUDA: %s: wrong parameters %d\n",
401 obuf
[0] = ERROR_PACKET
;
402 obuf
[1] = 0x5; /* bad parameters */
403 obuf
[2] = CUDA_PACKET
;
405 cuda_send_packet_to_host(s
, obuf
, 4);
411 qemu_log_mask(LOG_GUEST_ERROR
, "CUDA: unknown command 0x%02x\n", data
[0]);
412 obuf
[0] = ERROR_PACKET
;
413 obuf
[1] = 0x2; /* unknown command */
414 obuf
[2] = CUDA_PACKET
;
416 cuda_send_packet_to_host(s
, obuf
, 4);
419 static void cuda_receive_packet_from_host(CUDAState
*s
,
420 const uint8_t *data
, int len
)
424 trace_cuda_packet_receive(len
);
425 for (i
= 0; i
< len
; i
++) {
426 trace_cuda_packet_receive_data(i
, data
[i
]);
432 uint8_t obuf
[ADB_MAX_OUT_LEN
+ 3];
434 olen
= adb_request(&s
->adb_bus
, obuf
+ 2, data
+ 1, len
- 1);
436 obuf
[0] = ADB_PACKET
;
438 cuda_send_packet_to_host(s
, obuf
, olen
+ 2);
441 obuf
[0] = ADB_PACKET
;
445 cuda_send_packet_to_host(s
, obuf
, olen
+ 3);
450 cuda_receive_packet(s
, data
+ 1, len
- 1);
455 static uint64_t mos6522_cuda_read(void *opaque
, hwaddr addr
, unsigned size
)
457 CUDAState
*s
= opaque
;
458 MOS6522CUDAState
*mcs
= &s
->mos6522_cuda
;
459 MOS6522State
*ms
= MOS6522(mcs
);
461 addr
= (addr
>> 9) & 0xf;
462 return mos6522_read(ms
, addr
, size
);
465 static void mos6522_cuda_write(void *opaque
, hwaddr addr
, uint64_t val
,
468 CUDAState
*s
= opaque
;
469 MOS6522CUDAState
*mcs
= &s
->mos6522_cuda
;
470 MOS6522State
*ms
= MOS6522(mcs
);
472 addr
= (addr
>> 9) & 0xf;
473 mos6522_write(ms
, addr
, val
, size
);
476 static const MemoryRegionOps mos6522_cuda_ops
= {
477 .read
= mos6522_cuda_read
,
478 .write
= mos6522_cuda_write
,
479 .endianness
= DEVICE_BIG_ENDIAN
,
481 .min_access_size
= 1,
482 .max_access_size
= 1,
486 static const VMStateDescription vmstate_cuda
= {
489 .minimum_version_id
= 6,
490 .fields
= (const VMStateField
[]) {
491 VMSTATE_STRUCT(mos6522_cuda
.parent_obj
, CUDAState
, 0, vmstate_mos6522
,
493 VMSTATE_UINT8(last_b
, CUDAState
),
494 VMSTATE_UINT8(last_acr
, CUDAState
),
495 VMSTATE_INT32(data_in_size
, CUDAState
),
496 VMSTATE_INT32(data_in_index
, CUDAState
),
497 VMSTATE_INT32(data_out_index
, CUDAState
),
498 VMSTATE_BUFFER(data_in
, CUDAState
),
499 VMSTATE_BUFFER(data_out
, CUDAState
),
500 VMSTATE_UINT32(tick_offset
, CUDAState
),
501 VMSTATE_TIMER_PTR(sr_delay_timer
, CUDAState
),
502 VMSTATE_END_OF_LIST()
506 static void cuda_reset(DeviceState
*dev
)
508 CUDAState
*s
= CUDA(dev
);
509 ADBBusState
*adb_bus
= &s
->adb_bus
;
512 s
->data_in_index
= 0;
513 s
->data_out_index
= 0;
515 adb_set_autopoll_enabled(adb_bus
, false);
518 static void cuda_realize(DeviceState
*dev
, Error
**errp
)
520 CUDAState
*s
= CUDA(dev
);
522 ADBBusState
*adb_bus
= &s
->adb_bus
;
525 if (!sysbus_realize(SYS_BUS_DEVICE(&s
->mos6522_cuda
), errp
)) {
529 /* Pass IRQ from 6522 */
530 sbd
= SYS_BUS_DEVICE(s
);
531 sysbus_pass_irq(sbd
, SYS_BUS_DEVICE(&s
->mos6522_cuda
));
533 qemu_get_timedate(&tm
, 0);
534 s
->tick_offset
= (uint32_t)mktimegm(&tm
) + RTC_OFFSET
;
536 s
->sr_delay_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, cuda_set_sr_int
, s
);
537 s
->sr_delay_ns
= 20 * SCALE_US
;
539 adb_register_autopoll_callback(adb_bus
, cuda_adb_poll
, s
);
542 static void cuda_init(Object
*obj
)
544 CUDAState
*s
= CUDA(obj
);
545 SysBusDevice
*sbd
= SYS_BUS_DEVICE(obj
);
547 object_initialize_child(obj
, "mos6522-cuda", &s
->mos6522_cuda
,
550 memory_region_init_io(&s
->mem
, obj
, &mos6522_cuda_ops
, s
, "cuda", 0x2000);
551 sysbus_init_mmio(sbd
, &s
->mem
);
553 qbus_init(&s
->adb_bus
, sizeof(s
->adb_bus
), TYPE_ADB_BUS
,
554 DEVICE(obj
), "adb.0");
557 static Property cuda_properties
[] = {
558 DEFINE_PROP_UINT64("timebase-frequency", CUDAState
, tb_frequency
, 0),
559 DEFINE_PROP_END_OF_LIST()
562 static void cuda_class_init(ObjectClass
*oc
, void *data
)
564 DeviceClass
*dc
= DEVICE_CLASS(oc
);
566 dc
->realize
= cuda_realize
;
567 dc
->reset
= cuda_reset
;
568 dc
->vmsd
= &vmstate_cuda
;
569 device_class_set_props(dc
, cuda_properties
);
570 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
573 static const TypeInfo cuda_type_info
= {
575 .parent
= TYPE_SYS_BUS_DEVICE
,
576 .instance_size
= sizeof(CUDAState
),
577 .instance_init
= cuda_init
,
578 .class_init
= cuda_class_init
,
581 static void mos6522_cuda_portB_write(MOS6522State
*s
)
583 MOS6522CUDAState
*mcs
= container_of(s
, MOS6522CUDAState
, parent_obj
);
584 CUDAState
*cs
= container_of(mcs
, CUDAState
, mos6522_cuda
);
589 static void mos6522_cuda_reset_hold(Object
*obj
, ResetType type
)
591 MOS6522State
*ms
= MOS6522(obj
);
592 MOS6522DeviceClass
*mdc
= MOS6522_GET_CLASS(ms
);
594 if (mdc
->parent_phases
.hold
) {
595 mdc
->parent_phases
.hold(obj
, type
);
598 ms
->timers
[0].frequency
= CUDA_TIMER_FREQ
;
599 ms
->timers
[1].frequency
= (SCALE_US
* 6000) / 4700;
602 static void mos6522_cuda_class_init(ObjectClass
*oc
, void *data
)
604 ResettableClass
*rc
= RESETTABLE_CLASS(oc
);
605 MOS6522DeviceClass
*mdc
= MOS6522_CLASS(oc
);
607 resettable_class_set_parent_phases(rc
, NULL
, mos6522_cuda_reset_hold
,
608 NULL
, &mdc
->parent_phases
);
609 mdc
->portB_write
= mos6522_cuda_portB_write
;
610 mdc
->get_timer1_counter_value
= cuda_get_counter_value
;
611 mdc
->get_timer2_counter_value
= cuda_get_counter_value
;
612 mdc
->get_timer1_load_time
= cuda_get_load_time
;
613 mdc
->get_timer2_load_time
= cuda_get_load_time
;
616 static const TypeInfo mos6522_cuda_type_info
= {
617 .name
= TYPE_MOS6522_CUDA
,
618 .parent
= TYPE_MOS6522
,
619 .instance_size
= sizeof(MOS6522CUDAState
),
620 .class_init
= mos6522_cuda_class_init
,
623 static void cuda_register_types(void)
625 type_register_static(&mos6522_cuda_type_info
);
626 type_register_static(&cuda_type_info
);
629 type_init(cuda_register_types
)