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