1 /* 2 * QEMU ADB support 3 * 4 * Copyright (c) 2004 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu/osdep.h" 25 #include "hw/hw.h" 26 #include "hw/input/adb.h" 27 #include "ui/console.h" 28 29 /* debug ADB */ 30 //#define DEBUG_ADB 31 32 #ifdef DEBUG_ADB 33 #define ADB_DPRINTF(fmt, ...) \ 34 do { printf("ADB: " fmt , ## __VA_ARGS__); } while (0) 35 #else 36 #define ADB_DPRINTF(fmt, ...) 37 #endif 38 39 /* ADB commands */ 40 #define ADB_BUSRESET 0x00 41 #define ADB_FLUSH 0x01 42 #define ADB_WRITEREG 0x08 43 #define ADB_READREG 0x0c 44 45 /* ADB device commands */ 46 #define ADB_CMD_SELF_TEST 0xff 47 #define ADB_CMD_CHANGE_ID 0xfe 48 #define ADB_CMD_CHANGE_ID_AND_ACT 0xfd 49 #define ADB_CMD_CHANGE_ID_AND_ENABLE 0x00 50 51 /* ADB default device IDs (upper 4 bits of ADB command byte) */ 52 #define ADB_DEVID_DONGLE 1 53 #define ADB_DEVID_KEYBOARD 2 54 #define ADB_DEVID_MOUSE 3 55 #define ADB_DEVID_TABLET 4 56 #define ADB_DEVID_MODEM 5 57 #define ADB_DEVID_MISC 7 58 59 /* error codes */ 60 #define ADB_RET_NOTPRESENT (-2) 61 62 static void adb_device_reset(ADBDevice *d) 63 { 64 qdev_reset_all(DEVICE(d)); 65 } 66 67 int adb_request(ADBBusState *s, uint8_t *obuf, const uint8_t *buf, int len) 68 { 69 ADBDevice *d; 70 int devaddr, cmd, i; 71 72 cmd = buf[0] & 0xf; 73 if (cmd == ADB_BUSRESET) { 74 for(i = 0; i < s->nb_devices; i++) { 75 d = s->devices[i]; 76 adb_device_reset(d); 77 } 78 return 0; 79 } 80 devaddr = buf[0] >> 4; 81 for(i = 0; i < s->nb_devices; i++) { 82 d = s->devices[i]; 83 if (d->devaddr == devaddr) { 84 ADBDeviceClass *adc = ADB_DEVICE_GET_CLASS(d); 85 return adc->devreq(d, obuf, buf, len); 86 } 87 } 88 return ADB_RET_NOTPRESENT; 89 } 90 91 /* XXX: move that to cuda ? */ 92 int adb_poll(ADBBusState *s, uint8_t *obuf, uint16_t poll_mask) 93 { 94 ADBDevice *d; 95 int olen, i; 96 uint8_t buf[1]; 97 98 olen = 0; 99 for(i = 0; i < s->nb_devices; i++) { 100 if (s->poll_index >= s->nb_devices) 101 s->poll_index = 0; 102 d = s->devices[s->poll_index]; 103 if ((1 << d->devaddr) & poll_mask) { 104 buf[0] = ADB_READREG | (d->devaddr << 4); 105 olen = adb_request(s, obuf + 1, buf, 1); 106 /* if there is data, we poll again the same device */ 107 if (olen > 0) { 108 obuf[0] = buf[0]; 109 olen++; 110 break; 111 } 112 } 113 s->poll_index++; 114 } 115 return olen; 116 } 117 118 static const TypeInfo adb_bus_type_info = { 119 .name = TYPE_ADB_BUS, 120 .parent = TYPE_BUS, 121 .instance_size = sizeof(ADBBusState), 122 }; 123 124 static const VMStateDescription vmstate_adb_device = { 125 .name = "adb_device", 126 .version_id = 0, 127 .minimum_version_id = 0, 128 .fields = (VMStateField[]) { 129 VMSTATE_INT32(devaddr, ADBDevice), 130 VMSTATE_INT32(handler, ADBDevice), 131 VMSTATE_END_OF_LIST() 132 } 133 }; 134 135 static void adb_device_realizefn(DeviceState *dev, Error **errp) 136 { 137 ADBDevice *d = ADB_DEVICE(dev); 138 ADBBusState *bus = ADB_BUS(qdev_get_parent_bus(dev)); 139 140 if (bus->nb_devices >= MAX_ADB_DEVICES) { 141 return; 142 } 143 144 bus->devices[bus->nb_devices++] = d; 145 } 146 147 static void adb_device_class_init(ObjectClass *oc, void *data) 148 { 149 DeviceClass *dc = DEVICE_CLASS(oc); 150 151 dc->realize = adb_device_realizefn; 152 dc->bus_type = TYPE_ADB_BUS; 153 } 154 155 static const TypeInfo adb_device_type_info = { 156 .name = TYPE_ADB_DEVICE, 157 .parent = TYPE_DEVICE, 158 .instance_size = sizeof(ADBDevice), 159 .abstract = true, 160 .class_init = adb_device_class_init, 161 }; 162 163 /***************************************************************/ 164 /* Keyboard ADB device */ 165 166 #define ADB_KEYBOARD(obj) OBJECT_CHECK(KBDState, (obj), TYPE_ADB_KEYBOARD) 167 168 typedef struct KBDState { 169 /*< private >*/ 170 ADBDevice parent_obj; 171 /*< public >*/ 172 173 uint8_t data[128]; 174 int rptr, wptr, count; 175 } KBDState; 176 177 #define ADB_KEYBOARD_CLASS(class) \ 178 OBJECT_CLASS_CHECK(ADBKeyboardClass, (class), TYPE_ADB_KEYBOARD) 179 #define ADB_KEYBOARD_GET_CLASS(obj) \ 180 OBJECT_GET_CLASS(ADBKeyboardClass, (obj), TYPE_ADB_KEYBOARD) 181 182 typedef struct ADBKeyboardClass { 183 /*< private >*/ 184 ADBDeviceClass parent_class; 185 /*< public >*/ 186 187 DeviceRealize parent_realize; 188 } ADBKeyboardClass; 189 190 static const uint8_t pc_to_adb_keycode[256] = { 191 0, 53, 18, 19, 20, 21, 23, 22, 26, 28, 25, 29, 27, 24, 51, 48, 192 12, 13, 14, 15, 17, 16, 32, 34, 31, 35, 33, 30, 36, 54, 0, 1, 193 2, 3, 5, 4, 38, 40, 37, 41, 39, 50, 56, 42, 6, 7, 8, 9, 194 11, 45, 46, 43, 47, 44,123, 67, 58, 49, 57,122,120, 99,118, 96, 195 97, 98,100,101,109, 71,107, 89, 91, 92, 78, 86, 87, 88, 69, 83, 196 84, 85, 82, 65, 0, 0, 10,103,111, 0, 0,110, 81, 0, 0, 0, 197 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 199 0, 0, 0, 94, 0, 93, 0, 0, 0, 0, 0, 0,104,102, 0, 0, 200 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 76,125, 0, 0, 201 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,105, 0, 0, 0, 0, 0, 202 0, 0, 0, 0, 0, 75, 0, 0,124, 0, 0, 0, 0, 0, 0, 0, 203 0, 0, 0, 0, 0, 0, 0,115, 62,116, 0, 59, 0, 60, 0,119, 204 61,121,114,117, 0, 0, 0, 0, 0, 0, 0, 55,126, 0,127, 0, 205 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 206 0, 0, 0, 0, 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 207 }; 208 209 static void adb_kbd_put_keycode(void *opaque, int keycode) 210 { 211 KBDState *s = opaque; 212 213 if (s->count < sizeof(s->data)) { 214 s->data[s->wptr] = keycode; 215 if (++s->wptr == sizeof(s->data)) 216 s->wptr = 0; 217 s->count++; 218 } 219 } 220 221 static int adb_kbd_poll(ADBDevice *d, uint8_t *obuf) 222 { 223 static int ext_keycode; 224 KBDState *s = ADB_KEYBOARD(d); 225 int adb_keycode, keycode; 226 int olen; 227 228 olen = 0; 229 for(;;) { 230 if (s->count == 0) 231 break; 232 keycode = s->data[s->rptr]; 233 if (++s->rptr == sizeof(s->data)) 234 s->rptr = 0; 235 s->count--; 236 237 if (keycode == 0xe0) { 238 ext_keycode = 1; 239 } else { 240 if (ext_keycode) 241 adb_keycode = pc_to_adb_keycode[keycode | 0x80]; 242 else 243 adb_keycode = pc_to_adb_keycode[keycode & 0x7f]; 244 obuf[0] = adb_keycode | (keycode & 0x80); 245 /* NOTE: could put a second keycode if needed */ 246 obuf[1] = 0xff; 247 olen = 2; 248 ext_keycode = 0; 249 break; 250 } 251 } 252 return olen; 253 } 254 255 static int adb_kbd_request(ADBDevice *d, uint8_t *obuf, 256 const uint8_t *buf, int len) 257 { 258 KBDState *s = ADB_KEYBOARD(d); 259 int cmd, reg, olen; 260 261 if ((buf[0] & 0x0f) == ADB_FLUSH) { 262 /* flush keyboard fifo */ 263 s->wptr = s->rptr = s->count = 0; 264 return 0; 265 } 266 267 cmd = buf[0] & 0xc; 268 reg = buf[0] & 0x3; 269 olen = 0; 270 switch(cmd) { 271 case ADB_WRITEREG: 272 switch(reg) { 273 case 2: 274 /* LED status */ 275 break; 276 case 3: 277 switch(buf[2]) { 278 case ADB_CMD_SELF_TEST: 279 break; 280 case ADB_CMD_CHANGE_ID: 281 case ADB_CMD_CHANGE_ID_AND_ACT: 282 case ADB_CMD_CHANGE_ID_AND_ENABLE: 283 d->devaddr = buf[1] & 0xf; 284 break; 285 default: 286 /* XXX: check this */ 287 d->devaddr = buf[1] & 0xf; 288 d->handler = buf[2]; 289 break; 290 } 291 } 292 break; 293 case ADB_READREG: 294 switch(reg) { 295 case 0: 296 olen = adb_kbd_poll(d, obuf); 297 break; 298 case 1: 299 break; 300 case 2: 301 obuf[0] = 0x00; /* XXX: check this */ 302 obuf[1] = 0x07; /* led status */ 303 olen = 2; 304 break; 305 case 3: 306 obuf[0] = d->handler; 307 obuf[1] = d->devaddr; 308 olen = 2; 309 break; 310 } 311 break; 312 } 313 return olen; 314 } 315 316 static const VMStateDescription vmstate_adb_kbd = { 317 .name = "adb_kbd", 318 .version_id = 2, 319 .minimum_version_id = 2, 320 .fields = (VMStateField[]) { 321 VMSTATE_STRUCT(parent_obj, KBDState, 0, vmstate_adb_device, ADBDevice), 322 VMSTATE_BUFFER(data, KBDState), 323 VMSTATE_INT32(rptr, KBDState), 324 VMSTATE_INT32(wptr, KBDState), 325 VMSTATE_INT32(count, KBDState), 326 VMSTATE_END_OF_LIST() 327 } 328 }; 329 330 static void adb_kbd_reset(DeviceState *dev) 331 { 332 ADBDevice *d = ADB_DEVICE(dev); 333 KBDState *s = ADB_KEYBOARD(dev); 334 335 d->handler = 1; 336 d->devaddr = ADB_DEVID_KEYBOARD; 337 memset(s->data, 0, sizeof(s->data)); 338 s->rptr = 0; 339 s->wptr = 0; 340 s->count = 0; 341 } 342 343 static void adb_kbd_realizefn(DeviceState *dev, Error **errp) 344 { 345 ADBDevice *d = ADB_DEVICE(dev); 346 ADBKeyboardClass *akc = ADB_KEYBOARD_GET_CLASS(dev); 347 348 akc->parent_realize(dev, errp); 349 350 qemu_add_kbd_event_handler(adb_kbd_put_keycode, d); 351 } 352 353 static void adb_kbd_initfn(Object *obj) 354 { 355 ADBDevice *d = ADB_DEVICE(obj); 356 357 d->devaddr = ADB_DEVID_KEYBOARD; 358 } 359 360 static void adb_kbd_class_init(ObjectClass *oc, void *data) 361 { 362 DeviceClass *dc = DEVICE_CLASS(oc); 363 ADBDeviceClass *adc = ADB_DEVICE_CLASS(oc); 364 ADBKeyboardClass *akc = ADB_KEYBOARD_CLASS(oc); 365 366 akc->parent_realize = dc->realize; 367 dc->realize = adb_kbd_realizefn; 368 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 369 370 adc->devreq = adb_kbd_request; 371 dc->reset = adb_kbd_reset; 372 dc->vmsd = &vmstate_adb_kbd; 373 } 374 375 static const TypeInfo adb_kbd_type_info = { 376 .name = TYPE_ADB_KEYBOARD, 377 .parent = TYPE_ADB_DEVICE, 378 .instance_size = sizeof(KBDState), 379 .instance_init = adb_kbd_initfn, 380 .class_init = adb_kbd_class_init, 381 .class_size = sizeof(ADBKeyboardClass), 382 }; 383 384 /***************************************************************/ 385 /* Mouse ADB device */ 386 387 #define ADB_MOUSE(obj) OBJECT_CHECK(MouseState, (obj), TYPE_ADB_MOUSE) 388 389 typedef struct MouseState { 390 /*< public >*/ 391 ADBDevice parent_obj; 392 /*< private >*/ 393 394 int buttons_state, last_buttons_state; 395 int dx, dy, dz; 396 } MouseState; 397 398 #define ADB_MOUSE_CLASS(class) \ 399 OBJECT_CLASS_CHECK(ADBMouseClass, (class), TYPE_ADB_MOUSE) 400 #define ADB_MOUSE_GET_CLASS(obj) \ 401 OBJECT_GET_CLASS(ADBMouseClass, (obj), TYPE_ADB_MOUSE) 402 403 typedef struct ADBMouseClass { 404 /*< public >*/ 405 ADBDeviceClass parent_class; 406 /*< private >*/ 407 408 DeviceRealize parent_realize; 409 } ADBMouseClass; 410 411 static void adb_mouse_event(void *opaque, 412 int dx1, int dy1, int dz1, int buttons_state) 413 { 414 MouseState *s = opaque; 415 416 s->dx += dx1; 417 s->dy += dy1; 418 s->dz += dz1; 419 s->buttons_state = buttons_state; 420 } 421 422 423 static int adb_mouse_poll(ADBDevice *d, uint8_t *obuf) 424 { 425 MouseState *s = ADB_MOUSE(d); 426 int dx, dy; 427 428 if (s->last_buttons_state == s->buttons_state && 429 s->dx == 0 && s->dy == 0) 430 return 0; 431 432 dx = s->dx; 433 if (dx < -63) 434 dx = -63; 435 else if (dx > 63) 436 dx = 63; 437 438 dy = s->dy; 439 if (dy < -63) 440 dy = -63; 441 else if (dy > 63) 442 dy = 63; 443 444 s->dx -= dx; 445 s->dy -= dy; 446 s->last_buttons_state = s->buttons_state; 447 448 dx &= 0x7f; 449 dy &= 0x7f; 450 451 if (!(s->buttons_state & MOUSE_EVENT_LBUTTON)) 452 dy |= 0x80; 453 if (!(s->buttons_state & MOUSE_EVENT_RBUTTON)) 454 dx |= 0x80; 455 456 obuf[0] = dy; 457 obuf[1] = dx; 458 return 2; 459 } 460 461 static int adb_mouse_request(ADBDevice *d, uint8_t *obuf, 462 const uint8_t *buf, int len) 463 { 464 MouseState *s = ADB_MOUSE(d); 465 int cmd, reg, olen; 466 467 if ((buf[0] & 0x0f) == ADB_FLUSH) { 468 /* flush mouse fifo */ 469 s->buttons_state = s->last_buttons_state; 470 s->dx = 0; 471 s->dy = 0; 472 s->dz = 0; 473 return 0; 474 } 475 476 cmd = buf[0] & 0xc; 477 reg = buf[0] & 0x3; 478 olen = 0; 479 switch(cmd) { 480 case ADB_WRITEREG: 481 ADB_DPRINTF("write reg %d val 0x%2.2x\n", reg, buf[1]); 482 switch(reg) { 483 case 2: 484 break; 485 case 3: 486 switch(buf[2]) { 487 case ADB_CMD_SELF_TEST: 488 break; 489 case ADB_CMD_CHANGE_ID: 490 case ADB_CMD_CHANGE_ID_AND_ACT: 491 case ADB_CMD_CHANGE_ID_AND_ENABLE: 492 d->devaddr = buf[1] & 0xf; 493 break; 494 default: 495 /* XXX: check this */ 496 d->devaddr = buf[1] & 0xf; 497 break; 498 } 499 } 500 break; 501 case ADB_READREG: 502 switch(reg) { 503 case 0: 504 olen = adb_mouse_poll(d, obuf); 505 break; 506 case 1: 507 break; 508 case 3: 509 obuf[0] = d->handler; 510 obuf[1] = d->devaddr; 511 olen = 2; 512 break; 513 } 514 ADB_DPRINTF("read reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x\n", reg, 515 obuf[0], obuf[1]); 516 break; 517 } 518 return olen; 519 } 520 521 static void adb_mouse_reset(DeviceState *dev) 522 { 523 ADBDevice *d = ADB_DEVICE(dev); 524 MouseState *s = ADB_MOUSE(dev); 525 526 d->handler = 2; 527 d->devaddr = ADB_DEVID_MOUSE; 528 s->last_buttons_state = s->buttons_state = 0; 529 s->dx = s->dy = s->dz = 0; 530 } 531 532 static const VMStateDescription vmstate_adb_mouse = { 533 .name = "adb_mouse", 534 .version_id = 2, 535 .minimum_version_id = 2, 536 .fields = (VMStateField[]) { 537 VMSTATE_STRUCT(parent_obj, MouseState, 0, vmstate_adb_device, 538 ADBDevice), 539 VMSTATE_INT32(buttons_state, MouseState), 540 VMSTATE_INT32(last_buttons_state, MouseState), 541 VMSTATE_INT32(dx, MouseState), 542 VMSTATE_INT32(dy, MouseState), 543 VMSTATE_INT32(dz, MouseState), 544 VMSTATE_END_OF_LIST() 545 } 546 }; 547 548 static void adb_mouse_realizefn(DeviceState *dev, Error **errp) 549 { 550 MouseState *s = ADB_MOUSE(dev); 551 ADBMouseClass *amc = ADB_MOUSE_GET_CLASS(dev); 552 553 amc->parent_realize(dev, errp); 554 555 qemu_add_mouse_event_handler(adb_mouse_event, s, 0, "QEMU ADB Mouse"); 556 } 557 558 static void adb_mouse_initfn(Object *obj) 559 { 560 ADBDevice *d = ADB_DEVICE(obj); 561 562 d->devaddr = ADB_DEVID_MOUSE; 563 } 564 565 static void adb_mouse_class_init(ObjectClass *oc, void *data) 566 { 567 DeviceClass *dc = DEVICE_CLASS(oc); 568 ADBDeviceClass *adc = ADB_DEVICE_CLASS(oc); 569 ADBMouseClass *amc = ADB_MOUSE_CLASS(oc); 570 571 amc->parent_realize = dc->realize; 572 dc->realize = adb_mouse_realizefn; 573 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 574 575 adc->devreq = adb_mouse_request; 576 dc->reset = adb_mouse_reset; 577 dc->vmsd = &vmstate_adb_mouse; 578 } 579 580 static const TypeInfo adb_mouse_type_info = { 581 .name = TYPE_ADB_MOUSE, 582 .parent = TYPE_ADB_DEVICE, 583 .instance_size = sizeof(MouseState), 584 .instance_init = adb_mouse_initfn, 585 .class_init = adb_mouse_class_init, 586 .class_size = sizeof(ADBMouseClass), 587 }; 588 589 590 static void adb_register_types(void) 591 { 592 type_register_static(&adb_bus_type_info); 593 type_register_static(&adb_device_type_info); 594 type_register_static(&adb_kbd_type_info); 595 type_register_static(&adb_mouse_type_info); 596 } 597 598 type_init(adb_register_types) 599