hw/input/adb.c

   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
 366     adc->devreq = adb_kbd_request;
 367     dc->reset = adb_kbd_reset;
 368     dc->vmsd = &vmstate_adb_kbd;
 369 }
 370
 371 static const TypeInfo adb_kbd_type_info = {
 372     .name = TYPE_ADB_KEYBOARD,
 373     .parent = TYPE_ADB_DEVICE,
 374     .instance_size = sizeof(KBDState),
 375     .instance_init = adb_kbd_initfn,
 376     .class_init = adb_kbd_class_init,
 377     .class_size = sizeof(ADBKeyboardClass),
 378 };
 379
 380 /***************************************************************/
 381 /* Mouse ADB device */
 382
 383 #define ADB_MOUSE(obj) OBJECT_CHECK(MouseState, (obj), TYPE_ADB_MOUSE)
 384
 385 typedef struct MouseState {
 386     /*< public >*/
 387     ADBDevice parent_obj;
 388     /*< private >*/
 389
 390     int buttons_state, last_buttons_state;
 391     int dx, dy, dz;
 392 } MouseState;
 393
 394 #define ADB_MOUSE_CLASS(class) \
 395     OBJECT_CLASS_CHECK(ADBMouseClass, (class), TYPE_ADB_MOUSE)
 396 #define ADB_MOUSE_GET_CLASS(obj) \
 397     OBJECT_GET_CLASS(ADBMouseClass, (obj), TYPE_ADB_MOUSE)
 398
 399 typedef struct ADBMouseClass {
 400     /*< public >*/
 401     ADBDeviceClass parent_class;
 402     /*< private >*/
 403
 404     DeviceRealize parent_realize;
 405 } ADBMouseClass;
 406
 407 static void adb_mouse_event(void *opaque,
 408                             int dx1, int dy1, int dz1, int buttons_state)
 409 {
 410     MouseState *s = opaque;
 411
 412     s->dx += dx1;
 413     s->dy += dy1;
 414     s->dz += dz1;
 415     s->buttons_state = buttons_state;
 416 }
 417
 418
 419 static int adb_mouse_poll(ADBDevice *d, uint8_t *obuf)
 420 {
 421     MouseState *s = ADB_MOUSE(d);
 422     int dx, dy;
 423
 424     if (s->last_buttons_state == s->buttons_state &&
 425         s->dx == 0 && s->dy == 0)
 426         return 0;
 427
 428     dx = s->dx;
 429     if (dx < -63)
 430         dx = -63;
 431     else if (dx > 63)
 432         dx = 63;
 433
 434     dy = s->dy;
 435     if (dy < -63)
 436         dy = -63;
 437     else if (dy > 63)
 438         dy = 63;
 439
 440     s->dx -= dx;
 441     s->dy -= dy;
 442     s->last_buttons_state = s->buttons_state;
 443
 444     dx &= 0x7f;
 445     dy &= 0x7f;
 446
 447     if (!(s->buttons_state & MOUSE_EVENT_LBUTTON))
 448         dy |= 0x80;
 449     if (!(s->buttons_state & MOUSE_EVENT_RBUTTON))
 450         dx |= 0x80;
 451
 452     obuf[0] = dy;
 453     obuf[1] = dx;
 454     return 2;
 455 }
 456
 457 static int adb_mouse_request(ADBDevice *d, uint8_t *obuf,
 458                              const uint8_t *buf, int len)
 459 {
 460     MouseState *s = ADB_MOUSE(d);
 461     int cmd, reg, olen;
 462
 463     if ((buf[0] & 0x0f) == ADB_FLUSH) {
 464         /* flush mouse fifo */
 465         s->buttons_state = s->last_buttons_state;
 466         s->dx = 0;
 467         s->dy = 0;
 468         s->dz = 0;
 469         return 0;
 470     }
 471
 472     cmd = buf[0] & 0xc;
 473     reg = buf[0] & 0x3;
 474     olen = 0;
 475     switch(cmd) {
 476     case ADB_WRITEREG:
 477         ADB_DPRINTF("write reg %d val 0x%2.2x\n", reg, buf[1]);
 478         switch(reg) {
 479         case 2:
 480             break;
 481         case 3:
 482             switch(buf[2]) {
 483             case ADB_CMD_SELF_TEST:
 484                 break;
 485             case ADB_CMD_CHANGE_ID:
 486             case ADB_CMD_CHANGE_ID_AND_ACT:
 487             case ADB_CMD_CHANGE_ID_AND_ENABLE:
 488                 d->devaddr = buf[1] & 0xf;
 489                 break;
 490             default:
 491                 /* XXX: check this */
 492                 d->devaddr = buf[1] & 0xf;
 493                 break;
 494             }
 495         }
 496         break;
 497     case ADB_READREG:
 498         switch(reg) {
 499         case 0:
 500             olen = adb_mouse_poll(d, obuf);
 501             break;
 502         case 1:
 503             break;
 504         case 3:
 505             obuf[0] = d->handler;
 506             obuf[1] = d->devaddr;
 507             olen = 2;
 508             break;
 509         }
 510         ADB_DPRINTF("read reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x\n", reg,
 511                     obuf[0], obuf[1]);
 512         break;
 513     }
 514     return olen;
 515 }
 516
 517 static void adb_mouse_reset(DeviceState *dev)
 518 {
 519     ADBDevice *d = ADB_DEVICE(dev);
 520     MouseState *s = ADB_MOUSE(dev);
 521
 522     d->handler = 2;
 523     d->devaddr = ADB_DEVID_MOUSE;
 524     s->last_buttons_state = s->buttons_state = 0;
 525     s->dx = s->dy = s->dz = 0;
 526 }
 527
 528 static const VMStateDescription vmstate_adb_mouse = {
 529     .name = "adb_mouse",
 530     .version_id = 2,
 531     .minimum_version_id = 2,
 532     .fields = (VMStateField[]) {
 533         VMSTATE_STRUCT(parent_obj, MouseState, 0, vmstate_adb_device,
 534                        ADBDevice),
 535         VMSTATE_INT32(buttons_state, MouseState),
 536         VMSTATE_INT32(last_buttons_state, MouseState),
 537         VMSTATE_INT32(dx, MouseState),
 538         VMSTATE_INT32(dy, MouseState),
 539         VMSTATE_INT32(dz, MouseState),
 540         VMSTATE_END_OF_LIST()
 541     }
 542 };
 543
 544 static void adb_mouse_realizefn(DeviceState *dev, Error **errp)
 545 {
 546     MouseState *s = ADB_MOUSE(dev);
 547     ADBMouseClass *amc = ADB_MOUSE_GET_CLASS(dev);
 548
 549     amc->parent_realize(dev, errp);
 550
 551     qemu_add_mouse_event_handler(adb_mouse_event, s, 0, "QEMU ADB Mouse");
 552 }
 553
 554 static void adb_mouse_initfn(Object *obj)
 555 {
 556     ADBDevice *d = ADB_DEVICE(obj);
 557
 558     d->devaddr = ADB_DEVID_MOUSE;
 559 }
 560
 561 static void adb_mouse_class_init(ObjectClass *oc, void *data)
 562 {
 563     DeviceClass *dc = DEVICE_CLASS(oc);
 564     ADBDeviceClass *adc = ADB_DEVICE_CLASS(oc);
 565     ADBMouseClass *amc = ADB_MOUSE_CLASS(oc);
 566
 567     amc->parent_realize = dc->realize;
 568     dc->realize = adb_mouse_realizefn;
 569
 570     adc->devreq = adb_mouse_request;
 571     dc->reset = adb_mouse_reset;
 572     dc->vmsd = &vmstate_adb_mouse;
 573 }
 574
 575 static const TypeInfo adb_mouse_type_info = {
 576     .name = TYPE_ADB_MOUSE,
 577     .parent = TYPE_ADB_DEVICE,
 578     .instance_size = sizeof(MouseState),
 579     .instance_init = adb_mouse_initfn,
 580     .class_init = adb_mouse_class_init,
 581     .class_size = sizeof(ADBMouseClass),
 582 };
 583
 584
 585 static void adb_register_types(void)
 586 {
 587     type_register_static(&adb_bus_type_info);
 588     type_register_static(&adb_device_type_info);
 589     type_register_static(&adb_kbd_type_info);
 590     type_register_static(&adb_mouse_type_info);
 591 }
 592
 593 type_init(adb_register_types)