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