hw/usb-bt.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
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22
  23 #include "qemu-common.h"
  24 #include "usb.h"
  25 #include "net.h"
  26 #include "bt.h"
  27
  28 struct USBBtState {
  29     USBDevice dev;
  30     struct HCIInfo *hci;
  31
  32     int altsetting;
  33     int config;
  34
  35 #define CFIFO_LEN_MASK  255
  36 #define DFIFO_LEN_MASK  4095
  37     struct usb_hci_in_fifo_s {
  38         uint8_t data[(DFIFO_LEN_MASK + 1) * 2];
  39         struct {
  40             uint8_t *data;
  41             int len;
  42         } fifo[CFIFO_LEN_MASK + 1];
  43         int dstart, dlen, dsize, start, len;
  44     } evt, acl, sco;
  45
  46     struct usb_hci_out_fifo_s {
  47         uint8_t data[4096];
  48         int len;
  49     } outcmd, outacl, outsco;
  50 };
  51
  52 #define USB_EVT_EP      1
  53 #define USB_ACL_EP      2
  54 #define USB_SCO_EP      3
  55
  56 static const uint8_t qemu_bt_dev_descriptor[] = {
  57     0x12,               /*  u8 bLength; */
  58     USB_DT_DEVICE,      /*  u8 bDescriptorType; Device */
  59     0x10, 0x01,         /*  u16 bcdUSB; v1.10 */
  60
  61     0xe0,       /*  u8  bDeviceClass; Wireless */
  62     0x01,       /*  u8  bDeviceSubClass; Radio Frequency */
  63     0x01,       /*  u8  bDeviceProtocol; Bluetooth */
  64     0x40,       /*  u8  bMaxPacketSize0; 64 Bytes */
  65
  66     0x12, 0x0a, /*  u16 idVendor; */
  67     0x01, 0x00, /*  u16 idProduct; Bluetooth Dongle (HCI mode) */
  68     0x58, 0x19, /*  u16 bcdDevice; (some devices have 0x48, 0x02) */
  69
  70     0x00,       /*  u8  iManufacturer; */
  71     0x00,       /*  u8  iProduct; */
  72     0x00,       /*  u8  iSerialNumber; */
  73     0x01,       /*  u8  bNumConfigurations; */
  74 };
  75
  76 static const uint8_t qemu_bt_config_descriptor[] = {
  77     /* one configuration */
  78     0x09,               /*  u8  bLength; */
  79     USB_DT_CONFIG,      /*  u8  bDescriptorType; */
  80     0xb1, 0x00,         /*  u16 wTotalLength; */
  81     0x02,               /*  u8  bNumInterfaces; (2) */
  82     0x01,               /*  u8  bConfigurationValue; */
  83     0x00,               /*  u8  iConfiguration; */
  84     0xc0,               /*  u8  bmAttributes;
  85                                      Bit 7: must be set,
  86                                          6: Self-powered,
  87                                          5: Remote wakeup,
  88                                          4..0: resvd */
  89     0x00,               /*  u8  MaxPower; */
  90
  91     /* USB 1.1:
  92      * USB 2.0, single TT organization (mandatory):
  93      *  one interface, protocol 0
  94      *
  95      * USB 2.0, multiple TT organization (optional):
  96      *  two interfaces, protocols 1 (like single TT)
  97      *  and 2 (multiple TT mode) ... config is
  98      *  sometimes settable
  99      *  NOT IMPLEMENTED
 100      */
 101
 102     /* interface one */
 103     0x09,               /*  u8  if_bLength; */
 104     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 105     0x00,               /*  u8  if_bInterfaceNumber; */
 106     0x00,               /*  u8  if_bAlternateSetting; */
 107     0x03,               /*  u8  if_bNumEndpoints; */
 108     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 109     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 110     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 111     0x00,               /*  u8  if_iInterface; */
 112
 113     /* endpoint one */
 114     0x07,               /*  u8  ep_bLength; */
 115     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 116     USB_DIR_IN | USB_EVT_EP,    /*  u8  ep_bEndpointAddress; */
 117     0x03,               /*  u8  ep_bmAttributes; Interrupt */
 118     0x10, 0x00,         /*  u16 ep_wMaxPacketSize; */
 119     0x02,               /*  u8  ep_bInterval; */
 120
 121     /* endpoint two */
 122     0x07,               /*  u8  ep_bLength; */
 123     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 124     USB_DIR_OUT | USB_ACL_EP,   /*  u8  ep_bEndpointAddress; */
 125     0x02,               /*  u8  ep_bmAttributes; Bulk */
 126     0x40, 0x00,         /*  u16 ep_wMaxPacketSize; */
 127     0x0a,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 128
 129     /* endpoint three */
 130     0x07,               /*  u8  ep_bLength; */
 131     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 132     USB_DIR_IN | USB_ACL_EP,    /*  u8  ep_bEndpointAddress; */
 133     0x02,               /*  u8  ep_bmAttributes; Bulk */
 134     0x40, 0x00,         /*  u16 ep_wMaxPacketSize; */
 135     0x0a,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 136
 137     /* interface two setting one */
 138     0x09,               /*  u8  if_bLength; */
 139     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 140     0x01,               /*  u8  if_bInterfaceNumber; */
 141     0x00,               /*  u8  if_bAlternateSetting; */
 142     0x02,               /*  u8  if_bNumEndpoints; */
 143     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 144     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 145     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 146     0x00,               /*  u8  if_iInterface; */
 147
 148     /* endpoint one */
 149     0x07,               /*  u8  ep_bLength; */
 150     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 151     USB_DIR_OUT | USB_SCO_EP,   /*  u8  ep_bEndpointAddress; */
 152     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 153     0x00, 0x00,         /*  u16 ep_wMaxPacketSize; */
 154     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 155
 156     /* endpoint two */
 157     0x07,               /*  u8  ep_bLength; */
 158     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 159     USB_DIR_IN | USB_SCO_EP,    /*  u8  ep_bEndpointAddress; */
 160     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 161     0x00, 0x00,         /*  u16 ep_wMaxPacketSize; */
 162     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 163
 164     /* interface two setting two */
 165     0x09,               /*  u8  if_bLength; */
 166     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 167     0x01,               /*  u8  if_bInterfaceNumber; */
 168     0x01,               /*  u8  if_bAlternateSetting; */
 169     0x02,               /*  u8  if_bNumEndpoints; */
 170     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 171     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 172     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 173     0x00,               /*  u8  if_iInterface; */
 174
 175     /* endpoint one */
 176     0x07,               /*  u8  ep_bLength; */
 177     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 178     USB_DIR_OUT | USB_SCO_EP,   /*  u8  ep_bEndpointAddress; */
 179     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 180     0x09, 0x00,         /*  u16 ep_wMaxPacketSize; */
 181     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 182
 183     /* endpoint two */
 184     0x07,               /*  u8  ep_bLength; */
 185     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 186     USB_DIR_IN | USB_SCO_EP,    /*  u8  ep_bEndpointAddress; */
 187     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 188     0x09, 0x00,         /*  u16 ep_wMaxPacketSize; */
 189     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 190
 191     /* interface two setting three */
 192     0x09,               /*  u8  if_bLength; */
 193     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 194     0x01,               /*  u8  if_bInterfaceNumber; */
 195     0x02,               /*  u8  if_bAlternateSetting; */
 196     0x02,               /*  u8  if_bNumEndpoints; */
 197     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 198     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 199     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 200     0x00,               /*  u8  if_iInterface; */
 201
 202     /* endpoint one */
 203     0x07,               /*  u8  ep_bLength; */
 204     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 205     USB_DIR_OUT | USB_SCO_EP,   /*  u8  ep_bEndpointAddress; */
 206     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 207     0x11, 0x00,         /*  u16 ep_wMaxPacketSize; */
 208     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 209
 210     /* endpoint two */
 211     0x07,               /*  u8  ep_bLength; */
 212     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 213     USB_DIR_IN | USB_SCO_EP,    /*  u8  ep_bEndpointAddress; */
 214     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 215     0x11, 0x00,         /*  u16 ep_wMaxPacketSize; */
 216     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 217
 218     /* interface two setting four */
 219     0x09,               /*  u8  if_bLength; */
 220     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 221     0x01,               /*  u8  if_bInterfaceNumber; */
 222     0x03,               /*  u8  if_bAlternateSetting; */
 223     0x02,               /*  u8  if_bNumEndpoints; */
 224     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 225     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 226     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 227     0x00,               /*  u8  if_iInterface; */
 228
 229     /* endpoint one */
 230     0x07,               /*  u8  ep_bLength; */
 231     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 232     USB_DIR_OUT | USB_SCO_EP,   /*  u8  ep_bEndpointAddress; */
 233     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 234     0x19, 0x00,         /*  u16 ep_wMaxPacketSize; */
 235     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 236
 237     /* endpoint two */
 238     0x07,               /*  u8  ep_bLength; */
 239     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 240     USB_DIR_IN | USB_SCO_EP,    /*  u8  ep_bEndpointAddress; */
 241     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 242     0x19, 0x00,         /*  u16 ep_wMaxPacketSize; */
 243     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 244
 245     /* interface two setting five */
 246     0x09,               /*  u8  if_bLength; */
 247     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 248     0x01,               /*  u8  if_bInterfaceNumber; */
 249     0x04,               /*  u8  if_bAlternateSetting; */
 250     0x02,               /*  u8  if_bNumEndpoints; */
 251     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 252     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 253     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 254     0x00,               /*  u8  if_iInterface; */
 255
 256     /* endpoint one */
 257     0x07,               /*  u8  ep_bLength; */
 258     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 259     USB_DIR_OUT | USB_SCO_EP,   /*  u8  ep_bEndpointAddress; */
 260     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 261     0x21, 0x00,         /*  u16 ep_wMaxPacketSize; */
 262     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 263
 264     /* endpoint two */
 265     0x07,               /*  u8  ep_bLength; */
 266     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 267     USB_DIR_IN | USB_SCO_EP,    /*  u8  ep_bEndpointAddress; */
 268     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 269     0x21, 0x00,         /*  u16 ep_wMaxPacketSize; */
 270     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 271
 272     /* interface two setting six */
 273     0x09,               /*  u8  if_bLength; */
 274     USB_DT_INTERFACE,   /*  u8  if_bDescriptorType; */
 275     0x01,               /*  u8  if_bInterfaceNumber; */
 276     0x05,               /*  u8  if_bAlternateSetting; */
 277     0x02,               /*  u8  if_bNumEndpoints; */
 278     0xe0,               /*  u8  if_bInterfaceClass; Wireless */
 279     0x01,               /*  u8  if_bInterfaceSubClass; Radio Frequency */
 280     0x01,               /*  u8  if_bInterfaceProtocol; Bluetooth */
 281     0x00,               /*  u8  if_iInterface; */
 282
 283     /* endpoint one */
 284     0x07,               /*  u8  ep_bLength; */
 285     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 286     USB_DIR_OUT | USB_SCO_EP,   /*  u8  ep_bEndpointAddress; */
 287     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 288     0x31, 0x00,         /*  u16 ep_wMaxPacketSize; */
 289     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 290
 291     /* endpoint two */
 292     0x07,               /*  u8  ep_bLength; */
 293     USB_DT_ENDPOINT,    /*  u8  ep_bDescriptorType; */
 294     USB_DIR_IN | USB_SCO_EP,    /*  u8  ep_bEndpointAddress; */
 295     0x01,               /*  u8  ep_bmAttributes; Isochronous */
 296     0x31, 0x00,         /*  u16 ep_wMaxPacketSize; */
 297     0x01,               /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 298
 299     /* If implemented, the DFU interface descriptor goes here with no
 300      * endpoints or alternative settings.  */
 301 };
 302
 303 static void usb_bt_fifo_reset(struct usb_hci_in_fifo_s *fifo)
 304 {
 305     fifo->dstart = 0;
 306     fifo->dlen = 0;
 307     fifo->dsize = DFIFO_LEN_MASK + 1;
 308     fifo->start = 0;
 309     fifo->len = 0;
 310 }
 311
 312 static void usb_bt_fifo_enqueue(struct usb_hci_in_fifo_s *fifo,
 313                 const uint8_t *data, int len)
 314 {
 315     int off = fifo->dstart + fifo->dlen;
 316     uint8_t *buf;
 317
 318     fifo->dlen += len;
 319     if (off <= DFIFO_LEN_MASK) {
 320         if (off + len > DFIFO_LEN_MASK + 1 &&
 321                         (fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) {
 322             fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
 323             exit(-1);
 324         }
 325         buf = fifo->data + off;
 326     } else {
 327         if (fifo->dlen > fifo->dsize) {
 328             fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
 329             exit(-1);
 330         }
 331         buf = fifo->data + off - fifo->dsize;
 332     }
 333
 334     off = (fifo->start + fifo->len ++) & CFIFO_LEN_MASK;
 335     fifo->fifo[off].data = memcpy(buf, data, len);
 336     fifo->fifo[off].len = len;
 337 }
 338
 339 static inline int usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
 340                 USBPacket *p)
 341 {
 342     int len;
 343
 344     if (likely(!fifo->len))
 345         return USB_RET_STALL;
 346
 347     len = MIN(p->len, fifo->fifo[fifo->start].len);
 348     memcpy(p->data, fifo->fifo[fifo->start].data, len);
 349     if (len == p->len) {
 350         fifo->fifo[fifo->start].len -= len;
 351         fifo->fifo[fifo->start].data += len;
 352     } else {
 353         fifo->start ++;
 354         fifo->start &= CFIFO_LEN_MASK;
 355         fifo->len --;
 356     }
 357
 358     fifo->dstart += len;
 359     fifo->dlen -= len;
 360     if (fifo->dstart >= fifo->dsize) {
 361         fifo->dstart = 0;
 362         fifo->dsize = DFIFO_LEN_MASK + 1;
 363     }
 364
 365     return len;
 366 }
 367
 368 static void inline usb_bt_fifo_out_enqueue(struct USBBtState *s,
 369                 struct usb_hci_out_fifo_s *fifo,
 370                 void (*send)(struct HCIInfo *, const uint8_t *, int),
 371                 int (*complete)(const uint8_t *, int),
 372                 const uint8_t *data, int len)
 373 {
 374     if (fifo->len) {
 375         memcpy(fifo->data + fifo->len, data, len);
 376         fifo->len += len;
 377         if (complete(fifo->data, fifo->len)) {
 378             send(s->hci, fifo->data, fifo->len);
 379             fifo->len = 0;
 380         }
 381     } else if (complete(data, len))
 382         send(s->hci, data, len);
 383     else {
 384         memcpy(fifo->data, data, len);
 385         fifo->len = len;
 386     }
 387
 388     /* TODO: do we need to loop? */
 389 }
 390
 391 static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
 392 {
 393     len -= HCI_COMMAND_HDR_SIZE;
 394     return len >= 0 &&
 395             len >= ((struct hci_command_hdr *) data)->plen;
 396 }
 397
 398 static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
 399 {
 400     len -= HCI_ACL_HDR_SIZE;
 401     return len >= 0 &&
 402             len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
 403 }
 404
 405 static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
 406 {
 407     len -= HCI_SCO_HDR_SIZE;
 408     return len >= 0 &&
 409             len >= ((struct hci_sco_hdr *) data)->dlen;
 410 }
 411
 412 static void usb_bt_handle_reset(USBDevice *dev)
 413 {
 414     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 415
 416     usb_bt_fifo_reset(&s->evt);
 417     usb_bt_fifo_reset(&s->acl);
 418     usb_bt_fifo_reset(&s->sco);
 419     s->outcmd.len = 0;
 420     s->outacl.len = 0;
 421     s->outsco.len = 0;
 422     s->altsetting = 0;
 423 }
 424
 425 static int usb_bt_handle_control(USBDevice *dev, int request, int value,
 426                 int index, int length, uint8_t *data)
 427 {
 428     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 429     int ret = 0;
 430
 431     switch (request) {
 432     case DeviceRequest | USB_REQ_GET_STATUS:
 433     case InterfaceRequest | USB_REQ_GET_STATUS:
 434     case EndpointRequest | USB_REQ_GET_STATUS:
 435         data[0] = (1 << USB_DEVICE_SELF_POWERED) |
 436             (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
 437         data[1] = 0x00;
 438         ret = 2;
 439         break;
 440     case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
 441     case InterfaceOutRequest | USB_REQ_CLEAR_FEATURE:
 442     case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
 443         if (value == USB_DEVICE_REMOTE_WAKEUP) {
 444             dev->remote_wakeup = 0;
 445         } else {
 446             goto fail;
 447         }
 448         ret = 0;
 449         break;
 450     case DeviceOutRequest | USB_REQ_SET_FEATURE:
 451     case InterfaceOutRequest | USB_REQ_SET_FEATURE:
 452     case EndpointOutRequest | USB_REQ_SET_FEATURE:
 453         if (value == USB_DEVICE_REMOTE_WAKEUP) {
 454             dev->remote_wakeup = 1;
 455         } else {
 456             goto fail;
 457         }
 458         ret = 0;
 459         break;
 460     case DeviceOutRequest | USB_REQ_SET_ADDRESS:
 461         dev->addr = value;
 462         ret = 0;
 463         break;
 464     case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
 465         switch (value >> 8) {
 466         case USB_DT_DEVICE:
 467             ret = sizeof(qemu_bt_dev_descriptor);
 468             memcpy(data, qemu_bt_dev_descriptor, ret);
 469             break;
 470         case USB_DT_CONFIG:
 471             ret = sizeof(qemu_bt_config_descriptor);
 472             memcpy(data, qemu_bt_config_descriptor, ret);
 473             break;
 474         case USB_DT_STRING:
 475             switch(value & 0xff) {
 476             case 0:
 477                 /* language ids */
 478                 data[0] = 4;
 479                 data[1] = 3;
 480                 data[2] = 0x09;
 481                 data[3] = 0x04;
 482                 ret = 4;
 483                 break;
 484             default:
 485                 goto fail;
 486             }
 487             break;
 488         default:
 489             goto fail;
 490         }
 491         break;
 492     case DeviceRequest | USB_REQ_GET_CONFIGURATION:
 493         data[0] = qemu_bt_config_descriptor[0x5];
 494         ret = 1;
 495         s->config = 0;
 496         break;
 497     case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
 498         ret = 0;
 499         if (value != qemu_bt_config_descriptor[0x5] && value != 0) {
 500             printf("%s: Wrong SET_CONFIGURATION request (%i)\n",
 501                             __FUNCTION__, value);
 502             goto fail;
 503         }
 504         s->config = 1;
 505         usb_bt_fifo_reset(&s->evt);
 506         usb_bt_fifo_reset(&s->acl);
 507         usb_bt_fifo_reset(&s->sco);
 508         break;
 509     case InterfaceRequest | USB_REQ_GET_INTERFACE:
 510         if (value != 0 || (index & ~1) || length != 1)
 511             goto fail;
 512         if (index == 1)
 513             data[0] = s->altsetting;
 514         else
 515             data[0] = 0;
 516         ret = 1;
 517         break;
 518     case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
 519         if ((index & ~1) || length != 0 ||
 520                         (index == 1 && (value < 0 || value > 4)) ||
 521                         (index == 0 && value != 0)) {
 522             printf("%s: Wrong SET_INTERFACE request (%i, %i)\n",
 523                             __FUNCTION__, index, value);
 524             goto fail;
 525         }
 526         s->altsetting = value;
 527         ret = 0;
 528         break;
 529     case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_DEVICE) << 8):
 530         if (s->config)
 531             usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
 532                             usb_bt_hci_cmd_complete, data, length);
 533         break;
 534     default:
 535     fail:
 536         ret = USB_RET_STALL;
 537         break;
 538     }
 539     return ret;
 540 }
 541
 542 static int usb_bt_handle_data(USBDevice *dev, USBPacket *p)
 543 {
 544     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 545     int ret = 0;
 546
 547     if (!s->config)
 548         goto fail;
 549
 550     switch (p->pid) {
 551     case USB_TOKEN_IN:
 552         switch (p->devep & 0xf) {
 553         case USB_EVT_EP:
 554             ret = usb_bt_fifo_dequeue(&s->evt, p);
 555             break;
 556
 557         case USB_ACL_EP:
 558             ret = usb_bt_fifo_dequeue(&s->acl, p);
 559             break;
 560
 561         case USB_SCO_EP:
 562             ret = usb_bt_fifo_dequeue(&s->sco, p);
 563             break;
 564
 565         default:
 566             goto fail;
 567         }
 568         break;
 569
 570     case USB_TOKEN_OUT:
 571         switch (p->devep & 0xf) {
 572         case USB_ACL_EP:
 573             usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
 574                             usb_bt_hci_acl_complete, p->data, p->len);
 575             break;
 576
 577         case USB_SCO_EP:
 578             usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
 579                             usb_bt_hci_sco_complete, p->data, p->len);
 580             break;
 581
 582         default:
 583             goto fail;
 584         }
 585         break;
 586
 587     default:
 588     fail:
 589         ret = USB_RET_STALL;
 590         break;
 591     }
 592
 593     return ret;
 594 }
 595
 596 static void usb_bt_out_hci_packet_event(void *opaque,
 597                 const uint8_t *data, int len)
 598 {
 599     struct USBBtState *s = (struct USBBtState *) opaque;
 600
 601     usb_bt_fifo_enqueue(&s->evt, data, len);
 602 }
 603
 604 static void usb_bt_out_hci_packet_acl(void *opaque,
 605                 const uint8_t *data, int len)
 606 {
 607     struct USBBtState *s = (struct USBBtState *) opaque;
 608
 609     usb_bt_fifo_enqueue(&s->acl, data, len);
 610 }
 611
 612 static void usb_bt_handle_destroy(USBDevice *dev)
 613 {
 614     struct USBBtState *s = (struct USBBtState *) dev->opaque;
 615
 616     s->hci->opaque = 0;
 617     s->hci->evt_recv = 0;
 618     s->hci->acl_recv = 0;
 619     qemu_free(s);
 620 }
 621
 622 USBDevice *usb_bt_init(HCIInfo *hci)
 623 {
 624     struct USBBtState *s;
 625
 626     if (!hci)
 627         return NULL;
 628     s = qemu_mallocz(sizeof(struct USBBtState));
 629     if (!s)
 630         return NULL;
 631     s->dev.opaque = s;
 632     s->dev.speed = USB_SPEED_HIGH;
 633     s->dev.handle_packet = usb_generic_handle_packet;
 634     pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU BT dongle");
 635
 636     s->dev.handle_reset = usb_bt_handle_reset;
 637     s->dev.handle_control = usb_bt_handle_control;
 638     s->dev.handle_data = usb_bt_handle_data;
 639     s->dev.handle_destroy = usb_bt_handle_destroy;
 640
 641     s->hci = hci;
 642     s->hci->opaque = s;
 643     s->hci->evt_recv = usb_bt_out_hci_packet_event;
 644     s->hci->acl_recv = usb_bt_out_hci_packet_acl;
 645
 646     usb_bt_handle_reset(&s->dev);
 647
 648     return &s->dev;
 649 }