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