1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include "qemu-common.h"
28#include "hw/ppc/mac.h"
29#include "hw/qdev-properties.h"
30#include "migration/vmstate.h"
31#include "hw/input/adb.h"
32#include "hw/misc/mos6522.h"
33#include "hw/misc/macio/cuda.h"
34#include "qemu/timer.h"
35#include "sysemu/runstate.h"
36#include "qemu/cutils.h"
37#include "qemu/log.h"
38#include "qemu/module.h"
39#include "trace.h"
40
41
42#define TREQ 0x08
43#define TACK 0x10
44#define TIP 0x20
45
46
47#define ADB_PACKET 0
48#define CUDA_PACKET 1
49#define ERROR_PACKET 2
50#define TIMER_PACKET 3
51#define POWER_PACKET 4
52#define MACIIC_PACKET 5
53#define PMU_PACKET 6
54
55#define CUDA_TIMER_FREQ (4700000 / 6)
56
57
58#define RTC_OFFSET 2082844800
59
60static void cuda_receive_packet_from_host(CUDAState *s,
61 const uint8_t *data, int len);
62
63
64
65
66
67
68
69static uint64_t cuda_get_counter_value(MOS6522State *s, MOS6522Timer *ti)
70{
71 MOS6522CUDAState *mcs = container_of(s, MOS6522CUDAState, parent_obj);
72 CUDAState *cs = container_of(mcs, CUDAState, mos6522_cuda);
73
74
75 uint64_t tb_diff = muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL),
76 cs->tb_frequency, NANOSECONDS_PER_SECOND) -
77 ti->load_time;
78
79 return (tb_diff * 0xBF401675E5DULL) / (cs->tb_frequency << 24);
80}
81
82static uint64_t cuda_get_load_time(MOS6522State *s, MOS6522Timer *ti)
83{
84 MOS6522CUDAState *mcs = container_of(s, MOS6522CUDAState, parent_obj);
85 CUDAState *cs = container_of(mcs, CUDAState, mos6522_cuda);
86
87 uint64_t load_time = muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL),
88 cs->tb_frequency, NANOSECONDS_PER_SECOND);
89 return load_time;
90}
91
92static void cuda_set_sr_int(void *opaque)
93{
94 CUDAState *s = opaque;
95 MOS6522CUDAState *mcs = &s->mos6522_cuda;
96 MOS6522State *ms = MOS6522(mcs);
97 MOS6522DeviceClass *mdc = MOS6522_DEVICE_GET_CLASS(ms);
98
99 mdc->set_sr_int(ms);
100}
101
102static void cuda_delay_set_sr_int(CUDAState *s)
103{
104 int64_t expire;
105
106 trace_cuda_delay_set_sr_int();
107
108 expire = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->sr_delay_ns;
109 timer_mod(s->sr_delay_timer, expire);
110}
111
112
113static void cuda_update(CUDAState *s)
114{
115 MOS6522CUDAState *mcs = &s->mos6522_cuda;
116 MOS6522State *ms = MOS6522(mcs);
117 int packet_received, len;
118
119 packet_received = 0;
120 if (!(ms->b & TIP)) {
121
122
123 if (ms->acr & SR_OUT) {
124
125 if ((ms->b & (TACK | TIP)) != (s->last_b & (TACK | TIP))) {
126 if (s->data_out_index < sizeof(s->data_out)) {
127 trace_cuda_data_send(ms->sr);
128 s->data_out[s->data_out_index++] = ms->sr;
129 cuda_delay_set_sr_int(s);
130 }
131 }
132 } else {
133 if (s->data_in_index < s->data_in_size) {
134
135 if ((ms->b & (TACK | TIP)) != (s->last_b & (TACK | TIP))) {
136 ms->sr = s->data_in[s->data_in_index++];
137 trace_cuda_data_recv(ms->sr);
138
139 if (s->data_in_index >= s->data_in_size) {
140 ms->b = (ms->b | TREQ);
141 }
142 cuda_delay_set_sr_int(s);
143 }
144 }
145 }
146 } else {
147
148 if ((s->last_b & TIP) && (ms->b & TACK) != (s->last_b & TACK)) {
149
150 if (ms->b & TACK) {
151 ms->b = (ms->b | TREQ);
152 } else {
153 ms->b = (ms->b & ~TREQ);
154 }
155 cuda_delay_set_sr_int(s);
156 } else {
157 if (!(s->last_b & TIP)) {
158
159 packet_received = (s->data_out_index > 0);
160
161 cuda_delay_set_sr_int(s);
162 }
163
164 if (s->data_in_index < s->data_in_size) {
165 ms->b = (ms->b & ~TREQ);
166 }
167 }
168 }
169
170 s->last_acr = ms->acr;
171 s->last_b = ms->b;
172
173
174
175 if (packet_received) {
176 len = s->data_out_index;
177 s->data_out_index = 0;
178 cuda_receive_packet_from_host(s, s->data_out, len);
179 }
180}
181
182static void cuda_send_packet_to_host(CUDAState *s,
183 const uint8_t *data, int len)
184{
185 int i;
186
187 trace_cuda_packet_send(len);
188 for (i = 0; i < len; i++) {
189 trace_cuda_packet_send_data(i, data[i]);
190 }
191
192 memcpy(s->data_in, data, len);
193 s->data_in_size = len;
194 s->data_in_index = 0;
195 cuda_update(s);
196 cuda_delay_set_sr_int(s);
197}
198
199static void cuda_adb_poll(void *opaque)
200{
201 CUDAState *s = opaque;
202 uint8_t obuf[ADB_MAX_OUT_LEN + 2];
203 int olen;
204
205 olen = adb_poll(&s->adb_bus, obuf + 2, s->adb_poll_mask);
206 if (olen > 0) {
207 obuf[0] = ADB_PACKET;
208 obuf[1] = 0x40;
209 cuda_send_packet_to_host(s, obuf, olen + 2);
210 }
211 timer_mod(s->adb_poll_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
212 (NANOSECONDS_PER_SECOND / (1000 / s->autopoll_rate_ms)));
213}
214
215
216typedef struct CudaCommand {
217 uint8_t command;
218 const char *name;
219 bool (*handler)(CUDAState *s,
220 const uint8_t *in_args, int in_len,
221 uint8_t *out_args, int *out_len);
222} CudaCommand;
223
224static bool cuda_cmd_autopoll(CUDAState *s,
225 const uint8_t *in_data, int in_len,
226 uint8_t *out_data, int *out_len)
227{
228 int autopoll;
229
230 if (in_len != 1) {
231 return false;
232 }
233
234 autopoll = (in_data[0] != 0);
235 if (autopoll != s->autopoll) {
236 s->autopoll = autopoll;
237 if (autopoll) {
238 timer_mod(s->adb_poll_timer,
239 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
240 (NANOSECONDS_PER_SECOND / (1000 / s->autopoll_rate_ms)));
241 } else {
242 timer_del(s->adb_poll_timer);
243 }
244 }
245 return true;
246}
247
248static bool cuda_cmd_set_autorate(CUDAState *s,
249 const uint8_t *in_data, int in_len,
250 uint8_t *out_data, int *out_len)
251{
252 if (in_len != 1) {
253 return false;
254 }
255
256
257
258 if (in_data[0] == 0) {
259 return false;
260 }
261
262 s->autopoll_rate_ms = in_data[0];
263 if (s->autopoll) {
264 timer_mod(s->adb_poll_timer,
265 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
266 (NANOSECONDS_PER_SECOND / (1000 / s->autopoll_rate_ms)));
267 }
268 return true;
269}
270
271static bool cuda_cmd_set_device_list(CUDAState *s,
272 const uint8_t *in_data, int in_len,
273 uint8_t *out_data, int *out_len)
274{
275 if (in_len != 2) {
276 return false;
277 }
278
279 s->adb_poll_mask = (((uint16_t)in_data[0]) << 8) | in_data[1];
280 return true;
281}
282
283static bool cuda_cmd_powerdown(CUDAState *s,
284 const uint8_t *in_data, int in_len,
285 uint8_t *out_data, int *out_len)
286{
287 if (in_len != 0) {
288 return false;
289 }
290
291 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
292 return true;
293}
294
295static bool cuda_cmd_reset_system(CUDAState *s,
296 const uint8_t *in_data, int in_len,
297 uint8_t *out_data, int *out_len)
298{
299 if (in_len != 0) {
300 return false;
301 }
302
303 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
304 return true;
305}
306
307static bool cuda_cmd_set_file_server_flag(CUDAState *s,
308 const uint8_t *in_data, int in_len,
309 uint8_t *out_data, int *out_len)
310{
311 if (in_len != 1) {
312 return false;
313 }
314
315 qemu_log_mask(LOG_UNIMP,
316 "CUDA: unimplemented command FILE_SERVER_FLAG %d\n",
317 in_data[0]);
318 return true;
319}
320
321static bool cuda_cmd_set_power_message(CUDAState *s,
322 const uint8_t *in_data, int in_len,
323 uint8_t *out_data, int *out_len)
324{
325 if (in_len != 1) {
326 return false;
327 }
328
329 qemu_log_mask(LOG_UNIMP,
330 "CUDA: unimplemented command SET_POWER_MESSAGE %d\n",
331 in_data[0]);
332 return true;
333}
334
335static bool cuda_cmd_get_time(CUDAState *s,
336 const uint8_t *in_data, int in_len,
337 uint8_t *out_data, int *out_len)
338{
339 uint32_t ti;
340
341 if (in_len != 0) {
342 return false;
343 }
344
345 ti = s->tick_offset + (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)
346 / NANOSECONDS_PER_SECOND);
347 out_data[0] = ti >> 24;
348 out_data[1] = ti >> 16;
349 out_data[2] = ti >> 8;
350 out_data[3] = ti;
351 *out_len = 4;
352 return true;
353}
354
355static bool cuda_cmd_set_time(CUDAState *s,
356 const uint8_t *in_data, int in_len,
357 uint8_t *out_data, int *out_len)
358{
359 uint32_t ti;
360
361 if (in_len != 4) {
362 return false;
363 }
364
365 ti = (((uint32_t)in_data[0]) << 24) + (((uint32_t)in_data[1]) << 16)
366 + (((uint32_t)in_data[2]) << 8) + in_data[3];
367 s->tick_offset = ti - (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)
368 / NANOSECONDS_PER_SECOND);
369 return true;
370}
371
372static const CudaCommand handlers[] = {
373 { CUDA_AUTOPOLL, "AUTOPOLL", cuda_cmd_autopoll },
374 { CUDA_SET_AUTO_RATE, "SET_AUTO_RATE", cuda_cmd_set_autorate },
375 { CUDA_SET_DEVICE_LIST, "SET_DEVICE_LIST", cuda_cmd_set_device_list },
376 { CUDA_POWERDOWN, "POWERDOWN", cuda_cmd_powerdown },
377 { CUDA_RESET_SYSTEM, "RESET_SYSTEM", cuda_cmd_reset_system },
378 { CUDA_FILE_SERVER_FLAG, "FILE_SERVER_FLAG",
379 cuda_cmd_set_file_server_flag },
380 { CUDA_SET_POWER_MESSAGES, "SET_POWER_MESSAGES",
381 cuda_cmd_set_power_message },
382 { CUDA_GET_TIME, "GET_TIME", cuda_cmd_get_time },
383 { CUDA_SET_TIME, "SET_TIME", cuda_cmd_set_time },
384};
385
386static void cuda_receive_packet(CUDAState *s,
387 const uint8_t *data, int len)
388{
389 uint8_t obuf[16] = { CUDA_PACKET, 0, data[0] };
390 int i, out_len = 0;
391
392 for (i = 0; i < ARRAY_SIZE(handlers); i++) {
393 const CudaCommand *desc = &handlers[i];
394 if (desc->command == data[0]) {
395 trace_cuda_receive_packet_cmd(desc->name);
396 out_len = 0;
397 if (desc->handler(s, data + 1, len - 1, obuf + 3, &out_len)) {
398 cuda_send_packet_to_host(s, obuf, 3 + out_len);
399 } else {
400 qemu_log_mask(LOG_GUEST_ERROR,
401 "CUDA: %s: wrong parameters %d\n",
402 desc->name, len);
403 obuf[0] = ERROR_PACKET;
404 obuf[1] = 0x5;
405 obuf[2] = CUDA_PACKET;
406 obuf[3] = data[0];
407 cuda_send_packet_to_host(s, obuf, 4);
408 }
409 return;
410 }
411 }
412
413 qemu_log_mask(LOG_GUEST_ERROR, "CUDA: unknown command 0x%02x\n", data[0]);
414 obuf[0] = ERROR_PACKET;
415 obuf[1] = 0x2;
416 obuf[2] = CUDA_PACKET;
417 obuf[3] = data[0];
418 cuda_send_packet_to_host(s, obuf, 4);
419}
420
421static void cuda_receive_packet_from_host(CUDAState *s,
422 const uint8_t *data, int len)
423{
424 int i;
425
426 trace_cuda_packet_receive(len);
427 for (i = 0; i < len; i++) {
428 trace_cuda_packet_receive_data(i, data[i]);
429 }
430
431 switch(data[0]) {
432 case ADB_PACKET:
433 {
434 uint8_t obuf[ADB_MAX_OUT_LEN + 3];
435 int olen;
436 olen = adb_request(&s->adb_bus, obuf + 2, data + 1, len - 1);
437 if (olen > 0) {
438 obuf[0] = ADB_PACKET;
439 obuf[1] = 0x00;
440 cuda_send_packet_to_host(s, obuf, olen + 2);
441 } else {
442
443 obuf[0] = ADB_PACKET;
444 obuf[1] = -olen;
445 obuf[2] = data[1];
446 olen = 0;
447 cuda_send_packet_to_host(s, obuf, olen + 3);
448 }
449 }
450 break;
451 case CUDA_PACKET:
452 cuda_receive_packet(s, data + 1, len - 1);
453 break;
454 }
455}
456
457static uint64_t mos6522_cuda_read(void *opaque, hwaddr addr, unsigned size)
458{
459 CUDAState *s = opaque;
460 MOS6522CUDAState *mcs = &s->mos6522_cuda;
461 MOS6522State *ms = MOS6522(mcs);
462
463 addr = (addr >> 9) & 0xf;
464 return mos6522_read(ms, addr, size);
465}
466
467static void mos6522_cuda_write(void *opaque, hwaddr addr, uint64_t val,
468 unsigned size)
469{
470 CUDAState *s = opaque;
471 MOS6522CUDAState *mcs = &s->mos6522_cuda;
472 MOS6522State *ms = MOS6522(mcs);
473
474 addr = (addr >> 9) & 0xf;
475 mos6522_write(ms, addr, val, size);
476}
477
478static const MemoryRegionOps mos6522_cuda_ops = {
479 .read = mos6522_cuda_read,
480 .write = mos6522_cuda_write,
481 .endianness = DEVICE_BIG_ENDIAN,
482 .valid = {
483 .min_access_size = 1,
484 .max_access_size = 1,
485 },
486};
487
488static const VMStateDescription vmstate_cuda = {
489 .name = "cuda",
490 .version_id = 5,
491 .minimum_version_id = 5,
492 .fields = (VMStateField[]) {
493 VMSTATE_STRUCT(mos6522_cuda.parent_obj, CUDAState, 0, vmstate_mos6522,
494 MOS6522State),
495 VMSTATE_UINT8(last_b, CUDAState),
496 VMSTATE_UINT8(last_acr, CUDAState),
497 VMSTATE_INT32(data_in_size, CUDAState),
498 VMSTATE_INT32(data_in_index, CUDAState),
499 VMSTATE_INT32(data_out_index, CUDAState),
500 VMSTATE_UINT8(autopoll, CUDAState),
501 VMSTATE_UINT8(autopoll_rate_ms, CUDAState),
502 VMSTATE_UINT16(adb_poll_mask, CUDAState),
503 VMSTATE_BUFFER(data_in, CUDAState),
504 VMSTATE_BUFFER(data_out, CUDAState),
505 VMSTATE_UINT32(tick_offset, CUDAState),
506 VMSTATE_TIMER_PTR(adb_poll_timer, CUDAState),
507 VMSTATE_TIMER_PTR(sr_delay_timer, CUDAState),
508 VMSTATE_END_OF_LIST()
509 }
510};
511
512static void cuda_reset(DeviceState *dev)
513{
514 CUDAState *s = CUDA(dev);
515
516 s->data_in_size = 0;
517 s->data_in_index = 0;
518 s->data_out_index = 0;
519 s->autopoll = 0;
520}
521
522static void cuda_realize(DeviceState *dev, Error **errp)
523{
524 CUDAState *s = CUDA(dev);
525 SysBusDevice *sbd;
526 MOS6522State *ms;
527 DeviceState *d;
528 struct tm tm;
529
530
531 d = DEVICE(&s->mos6522_cuda);
532 ms = MOS6522(d);
533 sbd = SYS_BUS_DEVICE(s);
534 sysbus_pass_irq(sbd, SYS_BUS_DEVICE(ms));
535
536 qemu_get_timedate(&tm, 0);
537 s->tick_offset = (uint32_t)mktimegm(&tm) + RTC_OFFSET;
538
539 s->sr_delay_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, cuda_set_sr_int, s);
540 s->sr_delay_ns = 20 * SCALE_US;
541
542 s->adb_poll_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, cuda_adb_poll, s);
543 s->adb_poll_mask = 0xffff;
544 s->autopoll_rate_ms = 20;
545}
546
547static void cuda_init(Object *obj)
548{
549 CUDAState *s = CUDA(obj);
550 SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
551
552 sysbus_init_child_obj(obj, "mos6522-cuda", &s->mos6522_cuda,
553 sizeof(s->mos6522_cuda), TYPE_MOS6522_CUDA);
554
555 memory_region_init_io(&s->mem, obj, &mos6522_cuda_ops, s, "cuda", 0x2000);
556 sysbus_init_mmio(sbd, &s->mem);
557
558 qbus_create_inplace(&s->adb_bus, sizeof(s->adb_bus), TYPE_ADB_BUS,
559 DEVICE(obj), "adb.0");
560}
561
562static Property cuda_properties[] = {
563 DEFINE_PROP_UINT64("timebase-frequency", CUDAState, tb_frequency, 0),
564 DEFINE_PROP_END_OF_LIST()
565};
566
567static void cuda_class_init(ObjectClass *oc, void *data)
568{
569 DeviceClass *dc = DEVICE_CLASS(oc);
570
571 dc->realize = cuda_realize;
572 dc->reset = cuda_reset;
573 dc->vmsd = &vmstate_cuda;
574 dc->props = cuda_properties;
575 set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
576}
577
578static const TypeInfo cuda_type_info = {
579 .name = TYPE_CUDA,
580 .parent = TYPE_SYS_BUS_DEVICE,
581 .instance_size = sizeof(CUDAState),
582 .instance_init = cuda_init,
583 .class_init = cuda_class_init,
584};
585
586static void mos6522_cuda_portB_write(MOS6522State *s)
587{
588 MOS6522CUDAState *mcs = container_of(s, MOS6522CUDAState, parent_obj);
589 CUDAState *cs = container_of(mcs, CUDAState, mos6522_cuda);
590
591 cuda_update(cs);
592}
593
594static void mos6522_cuda_reset(DeviceState *dev)
595{
596 MOS6522State *ms = MOS6522(dev);
597 MOS6522DeviceClass *mdc = MOS6522_DEVICE_GET_CLASS(ms);
598
599 mdc->parent_reset(dev);
600
601 ms->timers[0].frequency = CUDA_TIMER_FREQ;
602 ms->timers[1].frequency = (SCALE_US * 6000) / 4700;
603}
604
605static void mos6522_cuda_class_init(ObjectClass *oc, void *data)
606{
607 DeviceClass *dc = DEVICE_CLASS(oc);
608 MOS6522DeviceClass *mdc = MOS6522_DEVICE_CLASS(oc);
609
610 dc->reset = mos6522_cuda_reset;
611 mdc->portB_write = mos6522_cuda_portB_write;
612 mdc->get_timer1_counter_value = cuda_get_counter_value;
613 mdc->get_timer2_counter_value = cuda_get_counter_value;
614 mdc->get_timer1_load_time = cuda_get_load_time;
615 mdc->get_timer2_load_time = cuda_get_load_time;
616}
617
618static const TypeInfo mos6522_cuda_type_info = {
619 .name = TYPE_MOS6522_CUDA,
620 .parent = TYPE_MOS6522,
621 .instance_size = sizeof(MOS6522CUDAState),
622 .class_init = mos6522_cuda_class_init,
623};
624
625static void cuda_register_types(void)
626{
627 type_register_static(&mos6522_cuda_type_info);
628 type_register_static(&cuda_type_info);
629}
630
631type_init(cuda_register_types)
632