hw/usb/dev-bluetooth.c

   1 /*
   2  * QEMU Bluetooth HCI USB Transport Layer v1.0
   3  *
   4  * Copyright (C) 2007 OpenMoko, Inc.
   5  * Copyright (C) 2008 Andrzej Zaborowski  <balrog@zabor.org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 or
  10  * (at your option) version 3 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "qemu/error-report.h"
  23 #include "qemu/module.h"
  24 #include "hw/usb.h"
  25 #include "migration/vmstate.h"
  26 #include "desc.h"
  27 #include "sysemu/bt.h"
  28 #include "hw/bt.h"
  29
  30 struct USBBtState {
  31     USBDevice dev;
  32     struct HCIInfo *hci;
  33     USBEndpoint *intr;
  34
  35     int config;
  36
  37 #define CFIFO_LEN_MASK  255
  38 #define DFIFO_LEN_MASK  4095
  39     struct usb_hci_in_fifo_s {
  40         uint8_t data[(DFIFO_LEN_MASK + 1) * 2];
  41         struct {
  42             uint8_t *data;
  43             int len;
  44         } fifo[CFIFO_LEN_MASK + 1];
  45         int dstart, dlen, dsize, start, len;
  46     } evt, acl, sco;
  47
  48     struct usb_hci_out_fifo_s {
  49         uint8_t data[4096];
  50         int len;
  51     } outcmd, outacl, outsco;
  52 };
  53
  54 #define TYPE_USB_BT "usb-bt-dongle"
  55 #define USB_BT(obj) OBJECT_CHECK(struct USBBtState, (obj), TYPE_USB_BT)
  56
  57 #define USB_EVT_EP      1
  58 #define USB_ACL_EP      2
  59 #define USB_SCO_EP      3
  60
  61 enum {
  62     STR_MANUFACTURER = 1,
  63     STR_SERIALNUMBER,
  64 };
  65
  66 static const USBDescStrings desc_strings = {
  67     [STR_MANUFACTURER]     = "QEMU",
  68     [STR_SERIALNUMBER]     = "1",
  69 };
  70
  71 static const USBDescIface desc_iface_bluetooth[] = {
  72     {
  73         .bInterfaceNumber              = 0,
  74         .bNumEndpoints                 = 3,
  75         .bInterfaceClass               = 0xe0, /* Wireless */
  76         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
  77         .bInterfaceProtocol            = 0x01, /* Bluetooth */
  78         .eps = (USBDescEndpoint[]) {
  79             {
  80                 .bEndpointAddress      = USB_DIR_IN | USB_EVT_EP,
  81                 .bmAttributes          = USB_ENDPOINT_XFER_INT,
  82                 .wMaxPacketSize        = 0x10,
  83                 .bInterval             = 0x02,
  84             },
  85             {
  86                 .bEndpointAddress      = USB_DIR_OUT | USB_ACL_EP,
  87                 .bmAttributes          = USB_ENDPOINT_XFER_BULK,
  88                 .wMaxPacketSize        = 0x40,
  89                 .bInterval             = 0x0a,
  90             },
  91             {
  92                 .bEndpointAddress      = USB_DIR_IN | USB_ACL_EP,
  93                 .bmAttributes          = USB_ENDPOINT_XFER_BULK,
  94                 .wMaxPacketSize        = 0x40,
  95                 .bInterval             = 0x0a,
  96             },
  97         },
  98     },{
  99         .bInterfaceNumber              = 1,
 100         .bAlternateSetting             = 0,
 101         .bNumEndpoints                 = 2,
 102         .bInterfaceClass               = 0xe0, /* Wireless */
 103         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
 104         .bInterfaceProtocol            = 0x01, /* Bluetooth */
 105         .eps = (USBDescEndpoint[]) {
 106             {
 107                 .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
 108                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 109                 .wMaxPacketSize        = 0,
 110                 .bInterval             = 0x01,
 111             },
 112             {
 113                 .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
 114                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 115                 .wMaxPacketSize        = 0,
 116                 .bInterval             = 0x01,
 117             },
 118         },
 119     },{
 120         .bInterfaceNumber              = 1,
 121         .bAlternateSetting             = 1,
 122         .bNumEndpoints                 = 2,
 123         .bInterfaceClass               = 0xe0, /* Wireless */
 124         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
 125         .bInterfaceProtocol            = 0x01, /* Bluetooth */
 126         .eps = (USBDescEndpoint[]) {
 127             {
 128                 .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
 129                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 130                 .wMaxPacketSize        = 0x09,
 131                 .bInterval             = 0x01,
 132             },
 133             {
 134                 .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
 135                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 136                 .wMaxPacketSize        = 0x09,
 137                 .bInterval             = 0x01,
 138             },
 139         },
 140     },{
 141         .bInterfaceNumber              = 1,
 142         .bAlternateSetting             = 2,
 143         .bNumEndpoints                 = 2,
 144         .bInterfaceClass               = 0xe0, /* Wireless */
 145         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
 146         .bInterfaceProtocol            = 0x01, /* Bluetooth */
 147         .eps = (USBDescEndpoint[]) {
 148             {
 149                 .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
 150                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 151                 .wMaxPacketSize        = 0x11,
 152                 .bInterval             = 0x01,
 153             },
 154             {
 155                 .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
 156                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 157                 .wMaxPacketSize        = 0x11,
 158                 .bInterval             = 0x01,
 159             },
 160         },
 161     },{
 162         .bInterfaceNumber              = 1,
 163         .bAlternateSetting             = 3,
 164         .bNumEndpoints                 = 2,
 165         .bInterfaceClass               = 0xe0, /* Wireless */
 166         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
 167         .bInterfaceProtocol            = 0x01, /* Bluetooth */
 168         .eps = (USBDescEndpoint[]) {
 169             {
 170                 .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
 171                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 172                 .wMaxPacketSize        = 0x19,
 173                 .bInterval             = 0x01,
 174             },
 175             {
 176                 .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
 177                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 178                 .wMaxPacketSize        = 0x19,
 179                 .bInterval             = 0x01,
 180             },
 181         },
 182     },{
 183         .bInterfaceNumber              = 1,
 184         .bAlternateSetting             = 4,
 185         .bNumEndpoints                 = 2,
 186         .bInterfaceClass               = 0xe0, /* Wireless */
 187         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
 188         .bInterfaceProtocol            = 0x01, /* Bluetooth */
 189         .eps = (USBDescEndpoint[]) {
 190             {
 191                 .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
 192                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 193                 .wMaxPacketSize        = 0x21,
 194                 .bInterval             = 0x01,
 195             },
 196             {
 197                 .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
 198                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 199                 .wMaxPacketSize        = 0x21,
 200                 .bInterval             = 0x01,
 201             },
 202         },
 203     },{
 204         .bInterfaceNumber              = 1,
 205         .bAlternateSetting             = 5,
 206         .bNumEndpoints                 = 2,
 207         .bInterfaceClass               = 0xe0, /* Wireless */
 208         .bInterfaceSubClass            = 0x01, /* Radio Frequency */
 209         .bInterfaceProtocol            = 0x01, /* Bluetooth */
 210         .eps = (USBDescEndpoint[]) {
 211             {
 212                 .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
 213                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 214                 .wMaxPacketSize        = 0x31,
 215                 .bInterval             = 0x01,
 216             },
 217             {
 218                 .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
 219                 .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
 220                 .wMaxPacketSize        = 0x31,
 221                 .bInterval             = 0x01,
 222             },
 223         },
 224     }
 225 };
 226
 227 static const USBDescDevice desc_device_bluetooth = {
 228     .bcdUSB                        = 0x0110,
 229     .bDeviceClass                  = 0xe0, /* Wireless */
 230     .bDeviceSubClass               = 0x01, /* Radio Frequency */
 231     .bDeviceProtocol               = 0x01, /* Bluetooth */
 232     .bMaxPacketSize0               = 64,
 233     .bNumConfigurations            = 1,
 234     .confs = (USBDescConfig[]) {
 235         {
 236             .bNumInterfaces        = 2,
 237             .bConfigurationValue   = 1,
 238             .bmAttributes          = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
 239             .bMaxPower             = 0,
 240             .nif = ARRAY_SIZE(desc_iface_bluetooth),
 241             .ifs = desc_iface_bluetooth,
 242         },
 243     },
 244 };
 245
 246 static const USBDesc desc_bluetooth = {
 247     .id = {
 248         .idVendor          = 0x0a12,
 249         .idProduct         = 0x0001,
 250         .bcdDevice         = 0x1958,
 251         .iManufacturer     = STR_MANUFACTURER,
 252         .iProduct          = 0,
 253         .iSerialNumber     = STR_SERIALNUMBER,
 254     },
 255     .full = &desc_device_bluetooth,
 256     .str  = desc_strings,
 257 };
 258
 259 static void usb_bt_fifo_reset(struct usb_hci_in_fifo_s *fifo)
 260 {
 261     fifo->dstart = 0;
 262     fifo->dlen = 0;
 263     fifo->dsize = DFIFO_LEN_MASK + 1;
 264     fifo->start = 0;
 265     fifo->len = 0;
 266 }
 267
 268 static void usb_bt_fifo_enqueue(struct usb_hci_in_fifo_s *fifo,
 269                 const uint8_t *data, int len)
 270 {
 271     int off = fifo->dstart + fifo->dlen;
 272     uint8_t *buf;
 273
 274     fifo->dlen += len;
 275     if (off <= DFIFO_LEN_MASK) {
 276         if (off + len > DFIFO_LEN_MASK + 1 &&
 277                         (fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) {
 278             fprintf(stderr, "%s: can't alloc %i bytes\n", __func__, len);
 279             exit(-1);
 280         }
 281         buf = fifo->data + off;
 282     } else {
 283         if (fifo->dlen > fifo->dsize) {
 284             fprintf(stderr, "%s: can't alloc %i bytes\n", __func__, len);
 285             exit(-1);
 286         }
 287         buf = fifo->data + off - fifo->dsize;
 288     }
 289
 290     off = (fifo->start + fifo->len ++) & CFIFO_LEN_MASK;
 291     fifo->fifo[off].data = memcpy(buf, data, len);
 292     fifo->fifo[off].len = len;
 293 }
 294
 295 static inline void usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
 296                 USBPacket *p)
 297 {
 298     int len;
 299
 300     assert(fifo->len != 0);
 301
 302     len = MIN(p->iov.size, fifo->fifo[fifo->start].len);
 303     usb_packet_copy(p, fifo->fifo[fifo->start].data, len);
 304     if (len == p->iov.size) {
 305         fifo->fifo[fifo->start].len -= len;
 306         fifo->fifo[fifo->start].data += len;
 307     } else {
 308         fifo->start ++;
 309         fifo->start &= CFIFO_LEN_MASK;
 310         fifo->len --;
 311     }
 312
 313     fifo->dstart += len;
 314     fifo->dlen -= len;
 315     if (fifo->dstart >= fifo->dsize) {
 316         fifo->dstart = 0;
 317         fifo->dsize = DFIFO_LEN_MASK + 1;
 318     }
 319 }
 320
 321 static inline void usb_bt_fifo_out_enqueue(struct USBBtState *s,
 322                 struct usb_hci_out_fifo_s *fifo,
 323                 void (*send)(struct HCIInfo *, const uint8_t *, int),
 324                 int (*complete)(const uint8_t *, int),
 325                 USBPacket *p)
 326 {
 327     usb_packet_copy(p, fifo->data + fifo->len, p->iov.size);
 328     fifo->len += p->iov.size;
 329     if (complete(fifo->data, fifo->len)) {
 330         send(s->hci, fifo->data, fifo->len);
 331         fifo->len = 0;
 332     }
 333
 334     /* TODO: do we need to loop? */
 335 }
 336
 337 static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
 338 {
 339     len -= HCI_COMMAND_HDR_SIZE;
 340     return len >= 0 &&
 341             len >= ((struct hci_command_hdr *) data)->plen;
 342 }
 343
 344 static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
 345 {
 346     len -= HCI_ACL_HDR_SIZE;
 347     return len >= 0 &&
 348             len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
 349 }
 350
 351 static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
 352 {
 353     len -= HCI_SCO_HDR_SIZE;
 354     return len >= 0 &&
 355             len >= ((struct hci_sco_hdr *) data)->dlen;
 356 }
 357
 358 static void usb_bt_handle_reset(USBDevice *dev)
 359 {
 360     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 361
 362     usb_bt_fifo_reset(&s->evt);
 363     usb_bt_fifo_reset(&s->acl);
 364     usb_bt_fifo_reset(&s->sco);
 365     s->outcmd.len = 0;
 366     s->outacl.len = 0;
 367     s->outsco.len = 0;
 368 }
 369
 370 static void usb_bt_handle_control(USBDevice *dev, USBPacket *p,
 371                int request, int value, int index, int length, uint8_t *data)
 372 {
 373     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 374     int ret;
 375
 376     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
 377     if (ret >= 0) {
 378         switch (request) {
 379         case DeviceRequest | USB_REQ_GET_CONFIGURATION:
 380             s->config = 0;
 381             break;
 382         case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
 383             s->config = 1;
 384             usb_bt_fifo_reset(&s->evt);
 385             usb_bt_fifo_reset(&s->acl);
 386             usb_bt_fifo_reset(&s->sco);
 387             break;
 388         }
 389         return;
 390     }
 391
 392     switch (request) {
 393     case InterfaceRequest | USB_REQ_GET_STATUS:
 394     case EndpointRequest | USB_REQ_GET_STATUS:
 395         data[0] = 0x00;
 396         data[1] = 0x00;
 397         p->actual_length = 2;
 398         break;
 399     case InterfaceOutRequest | USB_REQ_CLEAR_FEATURE:
 400     case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
 401         goto fail;
 402     case InterfaceOutRequest | USB_REQ_SET_FEATURE:
 403     case EndpointOutRequest | USB_REQ_SET_FEATURE:
 404         goto fail;
 405         break;
 406     case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_DEVICE) << 8):
 407         if (s->config)
 408             usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
 409                             usb_bt_hci_cmd_complete, p);
 410         break;
 411     default:
 412     fail:
 413         p->status = USB_RET_STALL;
 414         break;
 415     }
 416 }
 417
 418 static void usb_bt_handle_data(USBDevice *dev, USBPacket *p)
 419 {
 420     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 421
 422     if (!s->config)
 423         goto fail;
 424
 425     switch (p->pid) {
 426     case USB_TOKEN_IN:
 427         switch (p->ep->nr) {
 428         case USB_EVT_EP:
 429             if (s->evt.len == 0) {
 430                 p->status = USB_RET_NAK;
 431                 break;
 432             }
 433             usb_bt_fifo_dequeue(&s->evt, p);
 434             break;
 435
 436         case USB_ACL_EP:
 437             if (s->evt.len == 0) {
 438                 p->status = USB_RET_STALL;
 439                 break;
 440             }
 441             usb_bt_fifo_dequeue(&s->acl, p);
 442             break;
 443
 444         case USB_SCO_EP:
 445             if (s->evt.len == 0) {
 446                 p->status = USB_RET_STALL;
 447                 break;
 448             }
 449             usb_bt_fifo_dequeue(&s->sco, p);
 450             break;
 451
 452         default:
 453             goto fail;
 454         }
 455         break;
 456
 457     case USB_TOKEN_OUT:
 458         switch (p->ep->nr) {
 459         case USB_ACL_EP:
 460             usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
 461                             usb_bt_hci_acl_complete, p);
 462             break;
 463
 464         case USB_SCO_EP:
 465             usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
 466                             usb_bt_hci_sco_complete, p);
 467             break;
 468
 469         default:
 470             goto fail;
 471         }
 472         break;
 473
 474     default:
 475     fail:
 476         p->status = USB_RET_STALL;
 477         break;
 478     }
 479 }
 480
 481 static void usb_bt_out_hci_packet_event(void *opaque,
 482                 const uint8_t *data, int len)
 483 {
 484     struct USBBtState *s = (struct USBBtState *) opaque;
 485
 486     if (s->evt.len == 0) {
 487         usb_wakeup(s->intr, 0);
 488     }
 489     usb_bt_fifo_enqueue(&s->evt, data, len);
 490 }
 491
 492 static void usb_bt_out_hci_packet_acl(void *opaque,
 493                 const uint8_t *data, int len)
 494 {
 495     struct USBBtState *s = (struct USBBtState *) opaque;
 496
 497     usb_bt_fifo_enqueue(&s->acl, data, len);
 498 }
 499
 500 static void usb_bt_unrealize(USBDevice *dev, Error **errp)
 501 {
 502     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 503
 504     s->hci->opaque = NULL;
 505     s->hci->evt_recv = NULL;
 506     s->hci->acl_recv = NULL;
 507 }
 508
 509 static void usb_bt_realize(USBDevice *dev, Error **errp)
 510 {
 511     struct USBBtState *s = USB_BT(dev);
 512
 513     usb_desc_create_serial(dev);
 514     usb_desc_init(dev);
 515     s->dev.opaque = s;
 516     if (!s->hci) {
 517         s->hci = bt_new_hci(qemu_find_bt_vlan(0));
 518     }
 519     s->hci->opaque = s;
 520     s->hci->evt_recv = usb_bt_out_hci_packet_event;
 521     s->hci->acl_recv = usb_bt_out_hci_packet_acl;
 522     usb_bt_handle_reset(&s->dev);
 523     s->intr = usb_ep_get(dev, USB_TOKEN_IN, USB_EVT_EP);
 524 }
 525
 526 static USBDevice *usb_bt_init(USBBus *bus, const char *cmdline)
 527 {
 528     USBDevice *dev;
 529     struct USBBtState *s;
 530     HCIInfo *hci;
 531     const char *name = TYPE_USB_BT;
 532
 533     if (*cmdline) {
 534         hci = hci_init(cmdline);
 535     } else {
 536         hci = bt_new_hci(qemu_find_bt_vlan(0));
 537     }
 538     if (!hci)
 539         return NULL;
 540
 541     dev = usb_create(bus, name);
 542     s = USB_BT(dev);
 543     s->hci = hci;
 544     return dev;
 545 }
 546
 547 static const VMStateDescription vmstate_usb_bt = {
 548     .name = "usb-bt",
 549     .unmigratable = 1,
 550 };
 551
 552 static void usb_bt_class_initfn(ObjectClass *klass, void *data)
 553 {
 554     DeviceClass *dc = DEVICE_CLASS(klass);
 555     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
 556
 557     uc->realize        = usb_bt_realize;
 558     uc->product_desc   = "QEMU BT dongle";
 559     uc->usb_desc       = &desc_bluetooth;
 560     uc->handle_reset   = usb_bt_handle_reset;
 561     uc->handle_control = usb_bt_handle_control;
 562     uc->handle_data    = usb_bt_handle_data;
 563     uc->unrealize      = usb_bt_unrealize;
 564     dc->vmsd = &vmstate_usb_bt;
 565     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
 566 }
 567
 568 static const TypeInfo bt_info = {
 569     .name          = TYPE_USB_BT,
 570     .parent        = TYPE_USB_DEVICE,
 571     .instance_size = sizeof(struct USBBtState),
 572     .class_init    = usb_bt_class_initfn,
 573 };
 574
 575 static void usb_bt_register_types(void)
 576 {
 577     type_register_static(&bt_info);
 578     usb_legacy_register(TYPE_USB_BT, "bt", usb_bt_init);
 579 }
 580
 581 type_init(usb_bt_register_types)