drivers/bluetooth/hci_usb.c

   1 /*
   2    HCI USB driver for Linux Bluetooth protocol stack (BlueZ)
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   5
   6    Copyright (C) 2003 Maxim Krasnyansky <maxk@qualcomm.com>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License version 2 as
  10    published by the Free Software Foundation;
  11
  12    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  13    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  14    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  15    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  16    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  17    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  19    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20
  21    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  22    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  23    SOFTWARE IS DISCLAIMED.
  24 */
  25
  26 /*
  27  * Bluetooth HCI USB driver.
  28  * Based on original USB Bluetooth driver for Linux kernel
  29  *    Copyright (c) 2000 Greg Kroah-Hartman        <greg@kroah.com>
  30  *    Copyright (c) 2000 Mark Douglas Corner       <mcorner@umich.edu>
  31  *
  32  */
  33
  34 #include <linux/config.h>
  35 #include <linux/module.h>
  36
  37 #include <linux/kernel.h>
  38 #include <linux/init.h>
  39 #include <linux/sched.h>
  40 #include <linux/unistd.h>
  41 #include <linux/types.h>
  42 #include <linux/interrupt.h>
  43 #include <linux/moduleparam.h>
  44
  45 #include <linux/slab.h>
  46 #include <linux/errno.h>
  47 #include <linux/string.h>
  48 #include <linux/skbuff.h>
  49
  50 #include <linux/usb.h>
  51
  52 #include <net/bluetooth/bluetooth.h>
  53 #include <net/bluetooth/hci_core.h>
  54
  55 #include "hci_usb.h"
  56
  57 #ifndef CONFIG_BT_HCIUSB_DEBUG
  58 #undef  BT_DBG
  59 #define BT_DBG(D...)
  60 #undef  BT_DMP
  61 #define BT_DMP(D...)
  62 #endif
  63
  64 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
  65 #undef  URB_ZERO_PACKET
  66 #define URB_ZERO_PACKET 0
  67 #endif
  68
  69 static int ignore = 0;
  70 static int reset = 0;
  71
  72 #ifdef CONFIG_BT_HCIUSB_SCO
  73 static int isoc = 2;
  74 #endif
  75
  76 #define VERSION "2.8"
  77
  78 static struct usb_driver hci_usb_driver;
  79
  80 static struct usb_device_id bluetooth_ids[] = {
  81         /* Generic Bluetooth USB device */
  82         { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
  83
  84         /* AVM BlueFRITZ! USB v2.0 */
  85         { USB_DEVICE(0x057c, 0x3800) },
  86
  87         /* Bluetooth Ultraport Module from IBM */
  88         { USB_DEVICE(0x04bf, 0x030a) },
  89
  90         /* ALPS Modules with non-standard id */
  91         { USB_DEVICE(0x044e, 0x3001) },
  92         { USB_DEVICE(0x044e, 0x3002) },
  93
  94         /* Ericsson with non-standard id */
  95         { USB_DEVICE(0x0bdb, 0x1002) },
  96
  97         { }     /* Terminating entry */
  98 };
  99
 100 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
 101
 102 static struct usb_device_id blacklist_ids[] = {
 103         /* Broadcom BCM2033 without firmware */
 104         { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
 105
 106         /* Broadcom BCM2035 */
 107         { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET | HCI_BROKEN_ISOC },
 108         { USB_DEVICE(0x0a5c, 0x2009), .driver_info = HCI_BCM92035 },
 109
 110         /* Microsoft Wireless Transceiver for Bluetooth 2.0 */
 111         { USB_DEVICE(0x045e, 0x009c), .driver_info = HCI_RESET },
 112
 113         /* Kensington Bluetooth USB adapter */
 114         { USB_DEVICE(0x047d, 0x105d), .driver_info = HCI_RESET },
 115
 116         /* ISSC Bluetooth Adapter v3.1 */
 117         { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
 118
 119         /* RTX Telecom based adapter with buggy SCO support */
 120         { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
 121
 122         /* Digianswer devices */
 123         { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
 124         { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
 125
 126         /* CSR BlueCore Bluetooth Sniffer */
 127         { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
 128
 129         { }     /* Terminating entry */
 130 };
 131
 132 static struct _urb *_urb_alloc(int isoc, int gfp)
 133 {
 134         struct _urb *_urb = kmalloc(sizeof(struct _urb) +
 135                                 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
 136         if (_urb) {
 137                 memset(_urb, 0, sizeof(*_urb));
 138                 usb_init_urb(&_urb->urb);
 139         }
 140         return _urb;
 141 }
 142
 143 static struct _urb *_urb_dequeue(struct _urb_queue *q)
 144 {
 145         struct _urb *_urb = NULL;
 146         unsigned long flags;
 147         spin_lock_irqsave(&q->lock, flags);
 148         {
 149                 struct list_head *head = &q->head;
 150                 struct list_head *next = head->next;
 151                 if (next != head) {
 152                         _urb = list_entry(next, struct _urb, list);
 153                         list_del(next); _urb->queue = NULL;
 154                 }
 155         }
 156         spin_unlock_irqrestore(&q->lock, flags);
 157         return _urb;
 158 }
 159
 160 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
 161 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
 162
 163 #define __pending_tx(husb, type)  (&husb->pending_tx[type-1])
 164 #define __pending_q(husb, type)   (&husb->pending_q[type-1])
 165 #define __completed_q(husb, type) (&husb->completed_q[type-1])
 166 #define __transmit_q(husb, type)  (&husb->transmit_q[type-1])
 167 #define __reassembly(husb, type)  (husb->reassembly[type-1])
 168
 169 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
 170 {
 171         return _urb_dequeue(__completed_q(husb, type));
 172 }
 173
 174 #ifdef CONFIG_BT_HCIUSB_SCO
 175 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
 176 {
 177         int offset = 0, i;
 178
 179         BT_DBG("len %d mtu %d", len, mtu);
 180
 181         for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
 182                 urb->iso_frame_desc[i].offset = offset;
 183                 urb->iso_frame_desc[i].length = mtu;
 184                 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
 185         }
 186         if (len && i < HCI_MAX_ISOC_FRAMES) {
 187                 urb->iso_frame_desc[i].offset = offset;
 188                 urb->iso_frame_desc[i].length = len;
 189                 BT_DBG("desc %d offset %d len %d", i, offset, len);
 190                 i++;
 191         }
 192         urb->number_of_packets = i;
 193 }
 194 #endif
 195
 196 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
 197 {
 198         struct _urb *_urb;
 199         struct urb *urb;
 200         int err, pipe, interval, size;
 201         void *buf;
 202
 203         BT_DBG("%s", husb->hdev->name);
 204
 205         size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
 206
 207         buf = kmalloc(size, GFP_ATOMIC);
 208         if (!buf)
 209                 return -ENOMEM;
 210
 211         _urb = _urb_alloc(0, GFP_ATOMIC);
 212         if (!_urb) {
 213                 kfree(buf);
 214                 return -ENOMEM;
 215         }
 216         _urb->type = HCI_EVENT_PKT;
 217         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 218
 219         urb = &_urb->urb;
 220         pipe     = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
 221         interval = husb->intr_in_ep->desc.bInterval;
 222         usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
 223
 224         err = usb_submit_urb(urb, GFP_ATOMIC);
 225         if (err) {
 226                 BT_ERR("%s intr rx submit failed urb %p err %d",
 227                                 husb->hdev->name, urb, err);
 228                 _urb_unlink(_urb);
 229                 _urb_free(_urb);
 230                 kfree(buf);
 231         }
 232         return err;
 233 }
 234
 235 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
 236 {
 237         struct _urb *_urb;
 238         struct urb *urb;
 239         int err, pipe, size = HCI_MAX_FRAME_SIZE;
 240         void *buf;
 241
 242         buf = kmalloc(size, GFP_ATOMIC);
 243         if (!buf)
 244                 return -ENOMEM;
 245
 246         _urb = _urb_alloc(0, GFP_ATOMIC);
 247         if (!_urb) {
 248                 kfree(buf);
 249                 return -ENOMEM;
 250         }
 251         _urb->type = HCI_ACLDATA_PKT;
 252         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 253
 254         urb  = &_urb->urb;
 255         pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
 256         usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
 257         urb->transfer_flags = 0;
 258
 259         BT_DBG("%s urb %p", husb->hdev->name, urb);
 260
 261         err = usb_submit_urb(urb, GFP_ATOMIC);
 262         if (err) {
 263                 BT_ERR("%s bulk rx submit failed urb %p err %d",
 264                                 husb->hdev->name, urb, err);
 265                 _urb_unlink(_urb);
 266                 _urb_free(_urb);
 267                 kfree(buf);
 268         }
 269         return err;
 270 }
 271
 272 #ifdef CONFIG_BT_HCIUSB_SCO
 273 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
 274 {
 275         struct _urb *_urb;
 276         struct urb *urb;
 277         int err, mtu, size;
 278         void *buf;
 279
 280         mtu  = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
 281         size = mtu * HCI_MAX_ISOC_FRAMES;
 282
 283         buf = kmalloc(size, GFP_ATOMIC);
 284         if (!buf)
 285                 return -ENOMEM;
 286
 287         _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
 288         if (!_urb) {
 289                 kfree(buf);
 290                 return -ENOMEM;
 291         }
 292         _urb->type = HCI_SCODATA_PKT;
 293         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 294
 295         urb = &_urb->urb;
 296
 297         urb->context  = husb;
 298         urb->dev      = husb->udev;
 299         urb->pipe     = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
 300         urb->complete = hci_usb_rx_complete;
 301
 302         urb->interval = husb->isoc_in_ep->desc.bInterval;
 303
 304         urb->transfer_buffer_length = size;
 305         urb->transfer_buffer = buf;
 306         urb->transfer_flags  = URB_ISO_ASAP;
 307
 308         __fill_isoc_desc(urb, size, mtu);
 309
 310         BT_DBG("%s urb %p", husb->hdev->name, urb);
 311
 312         err = usb_submit_urb(urb, GFP_ATOMIC);
 313         if (err) {
 314                 BT_ERR("%s isoc rx submit failed urb %p err %d",
 315                                 husb->hdev->name, urb, err);
 316                 _urb_unlink(_urb);
 317                 _urb_free(_urb);
 318                 kfree(buf);
 319         }
 320         return err;
 321 }
 322 #endif
 323
 324 /* Initialize device */
 325 static int hci_usb_open(struct hci_dev *hdev)
 326 {
 327         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 328         int i, err;
 329         unsigned long flags;
 330
 331         BT_DBG("%s", hdev->name);
 332
 333         if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
 334                 return 0;
 335
 336         write_lock_irqsave(&husb->completion_lock, flags);
 337
 338         err = hci_usb_intr_rx_submit(husb);
 339         if (!err) {
 340                 for (i = 0; i < HCI_MAX_BULK_RX; i++)
 341                         hci_usb_bulk_rx_submit(husb);
 342
 343 #ifdef CONFIG_BT_HCIUSB_SCO
 344                 if (husb->isoc_iface)
 345                         for (i = 0; i < HCI_MAX_ISOC_RX; i++)
 346                                 hci_usb_isoc_rx_submit(husb);
 347 #endif
 348         } else {
 349                 clear_bit(HCI_RUNNING, &hdev->flags);
 350         }
 351
 352         write_unlock_irqrestore(&husb->completion_lock, flags);
 353         return err;
 354 }
 355
 356 /* Reset device */
 357 static int hci_usb_flush(struct hci_dev *hdev)
 358 {
 359         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 360         int i;
 361
 362         BT_DBG("%s", hdev->name);
 363
 364         for (i = 0; i < 4; i++)
 365                 skb_queue_purge(&husb->transmit_q[i]);
 366         return 0;
 367 }
 368
 369 static void hci_usb_unlink_urbs(struct hci_usb *husb)
 370 {
 371         int i;
 372
 373         BT_DBG("%s", husb->hdev->name);
 374
 375         for (i = 0; i < 4; i++) {
 376                 struct _urb *_urb;
 377                 struct urb *urb;
 378
 379                 /* Kill pending requests */
 380                 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
 381                         urb = &_urb->urb;
 382                         BT_DBG("%s unlinking _urb %p type %d urb %p",
 383                                         husb->hdev->name, _urb, _urb->type, urb);
 384                         usb_kill_urb(urb);
 385                         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 386                 }
 387
 388                 /* Release completed requests */
 389                 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
 390                         urb = &_urb->urb;
 391                         BT_DBG("%s freeing _urb %p type %d urb %p",
 392                                         husb->hdev->name, _urb, _urb->type, urb);
 393                         if (urb->setup_packet)
 394                                 kfree(urb->setup_packet);
 395                         if (urb->transfer_buffer)
 396                                 kfree(urb->transfer_buffer);
 397                         _urb_free(_urb);
 398                 }
 399
 400                 /* Release reassembly buffers */
 401                 if (husb->reassembly[i]) {
 402                         kfree_skb(husb->reassembly[i]);
 403                         husb->reassembly[i] = NULL;
 404                 }
 405         }
 406 }
 407
 408 /* Close device */
 409 static int hci_usb_close(struct hci_dev *hdev)
 410 {
 411         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 412         unsigned long flags;
 413
 414         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 415                 return 0;
 416
 417         BT_DBG("%s", hdev->name);
 418
 419         /* Synchronize with completion handlers */
 420         write_lock_irqsave(&husb->completion_lock, flags);
 421         write_unlock_irqrestore(&husb->completion_lock, flags);
 422
 423         hci_usb_unlink_urbs(husb);
 424         hci_usb_flush(hdev);
 425         return 0;
 426 }
 427
 428 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
 429 {
 430         struct urb *urb = &_urb->urb;
 431         int err;
 432
 433         BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
 434
 435         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 436         err = usb_submit_urb(urb, GFP_ATOMIC);
 437         if (err) {
 438                 BT_ERR("%s tx submit failed urb %p type %d err %d",
 439                                 husb->hdev->name, urb, _urb->type, err);
 440                 _urb_unlink(_urb);
 441                 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 442         } else
 443                 atomic_inc(__pending_tx(husb, _urb->type));
 444
 445         return err;
 446 }
 447
 448 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
 449 {
 450         struct _urb *_urb = __get_completed(husb, skb->pkt_type);
 451         struct usb_ctrlrequest *dr;
 452         struct urb *urb;
 453
 454         if (!_urb) {
 455                 _urb = _urb_alloc(0, GFP_ATOMIC);
 456                 if (!_urb)
 457                         return -ENOMEM;
 458                 _urb->type = skb->pkt_type;
 459
 460                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 461                 if (!dr) {
 462                         _urb_free(_urb);
 463                         return -ENOMEM;
 464                 }
 465         } else
 466                 dr = (void *) _urb->urb.setup_packet;
 467
 468         dr->bRequestType = husb->ctrl_req;
 469         dr->bRequest = 0;
 470         dr->wIndex   = 0;
 471         dr->wValue   = 0;
 472         dr->wLength  = __cpu_to_le16(skb->len);
 473
 474         urb = &_urb->urb;
 475         usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
 476                 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
 477
 478         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 479
 480         _urb->priv = skb;
 481         return __tx_submit(husb, _urb);
 482 }
 483
 484 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
 485 {
 486         struct _urb *_urb = __get_completed(husb, skb->pkt_type);
 487         struct urb *urb;
 488         int pipe;
 489
 490         if (!_urb) {
 491                 _urb = _urb_alloc(0, GFP_ATOMIC);
 492                 if (!_urb)
 493                         return -ENOMEM;
 494                 _urb->type = skb->pkt_type;
 495         }
 496
 497         urb  = &_urb->urb;
 498         pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
 499         usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
 500                         hci_usb_tx_complete, husb);
 501         urb->transfer_flags = URB_ZERO_PACKET;
 502
 503         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 504
 505         _urb->priv = skb;
 506         return __tx_submit(husb, _urb);
 507 }
 508
 509 #ifdef CONFIG_BT_HCIUSB_SCO
 510 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
 511 {
 512         struct _urb *_urb = __get_completed(husb, skb->pkt_type);
 513         struct urb *urb;
 514
 515         if (!_urb) {
 516                 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
 517                 if (!_urb)
 518                         return -ENOMEM;
 519                 _urb->type = skb->pkt_type;
 520         }
 521
 522         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 523
 524         urb = &_urb->urb;
 525
 526         urb->context  = husb;
 527         urb->dev      = husb->udev;
 528         urb->pipe     = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
 529         urb->complete = hci_usb_tx_complete;
 530         urb->transfer_flags = URB_ISO_ASAP;
 531
 532         urb->interval = husb->isoc_out_ep->desc.bInterval;
 533
 534         urb->transfer_buffer = skb->data;
 535         urb->transfer_buffer_length = skb->len;
 536
 537         __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
 538
 539         _urb->priv = skb;
 540         return __tx_submit(husb, _urb);
 541 }
 542 #endif
 543
 544 static void hci_usb_tx_process(struct hci_usb *husb)
 545 {
 546         struct sk_buff_head *q;
 547         struct sk_buff *skb;
 548
 549         BT_DBG("%s", husb->hdev->name);
 550
 551         do {
 552                 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
 553
 554                 /* Process command queue */
 555                 q = __transmit_q(husb, HCI_COMMAND_PKT);
 556                 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
 557                                 (skb = skb_dequeue(q))) {
 558                         if (hci_usb_send_ctrl(husb, skb) < 0)
 559                                 skb_queue_head(q, skb);
 560                 }
 561
 562 #ifdef CONFIG_BT_HCIUSB_SCO
 563                 /* Process SCO queue */
 564                 q = __transmit_q(husb, HCI_SCODATA_PKT);
 565                 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
 566                                 (skb = skb_dequeue(q))) {
 567                         if (hci_usb_send_isoc(husb, skb) < 0)
 568                                 skb_queue_head(q, skb);
 569                 }
 570 #endif
 571
 572                 /* Process ACL queue */
 573                 q = __transmit_q(husb, HCI_ACLDATA_PKT);
 574                 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
 575                                 (skb = skb_dequeue(q))) {
 576                         if (hci_usb_send_bulk(husb, skb) < 0) {
 577                                 skb_queue_head(q, skb);
 578                                 break;
 579                         }
 580                 }
 581         } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
 582 }
 583
 584 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
 585 {
 586         /* Serialize TX queue processing to avoid data reordering */
 587         if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
 588                 hci_usb_tx_process(husb);
 589                 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
 590         } else
 591                 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
 592 }
 593
 594 /* Send frames from HCI layer */
 595 static int hci_usb_send_frame(struct sk_buff *skb)
 596 {
 597         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 598         struct hci_usb *husb;
 599
 600         if (!hdev) {
 601                 BT_ERR("frame for uknown device (hdev=NULL)");
 602                 return -ENODEV;
 603         }
 604
 605         if (!test_bit(HCI_RUNNING, &hdev->flags))
 606                 return -EBUSY;
 607
 608         BT_DBG("%s type %d len %d", hdev->name, skb->pkt_type, skb->len);
 609
 610         husb = (struct hci_usb *) hdev->driver_data;
 611
 612         switch (skb->pkt_type) {
 613         case HCI_COMMAND_PKT:
 614                 hdev->stat.cmd_tx++;
 615                 break;
 616
 617         case HCI_ACLDATA_PKT:
 618                 hdev->stat.acl_tx++;
 619                 break;
 620
 621 #ifdef CONFIG_BT_HCIUSB_SCO
 622         case HCI_SCODATA_PKT:
 623                 hdev->stat.sco_tx++;
 624                 break;
 625 #endif
 626
 627         default:
 628                 kfree_skb(skb);
 629                 return 0;
 630         }
 631
 632         read_lock(&husb->completion_lock);
 633
 634         skb_queue_tail(__transmit_q(husb, skb->pkt_type), skb);
 635         hci_usb_tx_wakeup(husb);
 636
 637         read_unlock(&husb->completion_lock);
 638         return 0;
 639 }
 640
 641 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
 642 {
 643         BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
 644
 645         husb->hdev->stat.byte_rx += count;
 646
 647         while (count) {
 648                 struct sk_buff *skb = __reassembly(husb, type);
 649                 struct { int expect; } *scb;
 650                 int len = 0;
 651
 652                 if (!skb) {
 653                         /* Start of the frame */
 654
 655                         switch (type) {
 656                         case HCI_EVENT_PKT:
 657                                 if (count >= HCI_EVENT_HDR_SIZE) {
 658                                         struct hci_event_hdr *h = data;
 659                                         len = HCI_EVENT_HDR_SIZE + h->plen;
 660                                 } else
 661                                         return -EILSEQ;
 662                                 break;
 663
 664                         case HCI_ACLDATA_PKT:
 665                                 if (count >= HCI_ACL_HDR_SIZE) {
 666                                         struct hci_acl_hdr *h = data;
 667                                         len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
 668                                 } else
 669                                         return -EILSEQ;
 670                                 break;
 671 #ifdef CONFIG_BT_HCIUSB_SCO
 672                         case HCI_SCODATA_PKT:
 673                                 if (count >= HCI_SCO_HDR_SIZE) {
 674                                         struct hci_sco_hdr *h = data;
 675                                         len = HCI_SCO_HDR_SIZE + h->dlen;
 676                                 } else
 677                                         return -EILSEQ;
 678                                 break;
 679 #endif
 680                         }
 681                         BT_DBG("new packet len %d", len);
 682
 683                         skb = bt_skb_alloc(len, GFP_ATOMIC);
 684                         if (!skb) {
 685                                 BT_ERR("%s no memory for the packet", husb->hdev->name);
 686                                 return -ENOMEM;
 687                         }
 688                         skb->dev = (void *) husb->hdev;
 689                         skb->pkt_type = type;
 690
 691                         __reassembly(husb, type) = skb;
 692
 693                         scb = (void *) skb->cb;
 694                         scb->expect = len;
 695                 } else {
 696                         /* Continuation */
 697                         scb = (void *) skb->cb;
 698                         len = scb->expect;
 699                 }
 700
 701                 len = min(len, count);
 702
 703                 memcpy(skb_put(skb, len), data, len);
 704
 705                 scb->expect -= len;
 706                 if (!scb->expect) {
 707                         /* Complete frame */
 708                         __reassembly(husb, type) = NULL;
 709                         hci_recv_frame(skb);
 710                 }
 711
 712                 count -= len; data += len;
 713         }
 714         return 0;
 715 }
 716
 717 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
 718 {
 719         struct _urb *_urb = container_of(urb, struct _urb, urb);
 720         struct hci_usb *husb = (void *) urb->context;
 721         struct hci_dev *hdev = husb->hdev;
 722         int err, count = urb->actual_length;
 723
 724         BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
 725                         _urb->type, urb->status, count, urb->transfer_flags);
 726
 727         read_lock(&husb->completion_lock);
 728
 729         if (!test_bit(HCI_RUNNING, &hdev->flags))
 730                 goto unlock;
 731
 732         if (urb->status || !count)
 733                 goto resubmit;
 734
 735         if (_urb->type == HCI_SCODATA_PKT) {
 736 #ifdef CONFIG_BT_HCIUSB_SCO
 737                 int i;
 738                 for (i=0; i < urb->number_of_packets; i++) {
 739                         BT_DBG("desc %d status %d offset %d len %d", i,
 740                                         urb->iso_frame_desc[i].status,
 741                                         urb->iso_frame_desc[i].offset,
 742                                         urb->iso_frame_desc[i].actual_length);
 743
 744                         if (!urb->iso_frame_desc[i].status)
 745                                 __recv_frame(husb, _urb->type,
 746                                         urb->transfer_buffer + urb->iso_frame_desc[i].offset,
 747                                         urb->iso_frame_desc[i].actual_length);
 748                 }
 749 #else
 750                 ;
 751 #endif
 752         } else {
 753                 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
 754                 if (err < 0) {
 755                         BT_ERR("%s corrupted packet: type %d count %d",
 756                                         husb->hdev->name, _urb->type, count);
 757                         hdev->stat.err_rx++;
 758                 }
 759         }
 760
 761 resubmit:
 762         urb->dev = husb->udev;
 763         err = usb_submit_urb(urb, GFP_ATOMIC);
 764         BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
 765                         _urb->type, err);
 766
 767 unlock:
 768         read_unlock(&husb->completion_lock);
 769 }
 770
 771 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
 772 {
 773         struct _urb *_urb = container_of(urb, struct _urb, urb);
 774         struct hci_usb *husb = (void *) urb->context;
 775         struct hci_dev *hdev = husb->hdev;
 776
 777         BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
 778                         urb->status, urb->transfer_flags);
 779
 780         atomic_dec(__pending_tx(husb, _urb->type));
 781
 782         urb->transfer_buffer = NULL;
 783         kfree_skb((struct sk_buff *) _urb->priv);
 784
 785         if (!test_bit(HCI_RUNNING, &hdev->flags))
 786                 return;
 787
 788         if (!urb->status)
 789                 hdev->stat.byte_tx += urb->transfer_buffer_length;
 790         else
 791                 hdev->stat.err_tx++;
 792
 793         read_lock(&husb->completion_lock);
 794
 795         _urb_unlink(_urb);
 796         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 797
 798         hci_usb_tx_wakeup(husb);
 799
 800         read_unlock(&husb->completion_lock);
 801 }
 802
 803 static void hci_usb_destruct(struct hci_dev *hdev)
 804 {
 805         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 806
 807         BT_DBG("%s", hdev->name);
 808
 809         kfree(husb);
 810 }
 811
 812 static void hci_usb_notify(struct hci_dev *hdev, unsigned int evt)
 813 {
 814         BT_DBG("%s evt %d", hdev->name, evt);
 815 }
 816
 817 static int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 818 {
 819         struct usb_device *udev = interface_to_usbdev(intf);
 820         struct usb_host_endpoint *bulk_out_ep = NULL;
 821         struct usb_host_endpoint *bulk_in_ep = NULL;
 822         struct usb_host_endpoint *intr_in_ep = NULL;
 823         struct usb_host_endpoint  *ep;
 824         struct usb_host_interface *uif;
 825         struct usb_interface *isoc_iface;
 826         struct hci_usb *husb;
 827         struct hci_dev *hdev;
 828         int i, e, size, isoc_ifnum, isoc_alts;
 829
 830         BT_DBG("udev %p intf %p", udev, intf);
 831
 832         if (!id->driver_info) {
 833                 const struct usb_device_id *match;
 834                 match = usb_match_id(intf, blacklist_ids);
 835                 if (match)
 836                         id = match;
 837         }
 838
 839         if (ignore || id->driver_info & HCI_IGNORE)
 840                 return -ENODEV;
 841
 842         if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
 843                 return -ENODEV;
 844
 845         /* Find endpoints that we need */
 846         uif = intf->cur_altsetting;
 847         for (e = 0; e < uif->desc.bNumEndpoints; e++) {
 848                 ep = &uif->endpoint[e];
 849
 850                 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
 851                 case USB_ENDPOINT_XFER_INT:
 852                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
 853                                 intr_in_ep = ep;
 854                         break;
 855
 856                 case USB_ENDPOINT_XFER_BULK:
 857                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
 858                                 bulk_in_ep  = ep;
 859                         else
 860                                 bulk_out_ep = ep;
 861                         break;
 862                 }
 863         }
 864
 865         if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
 866                 BT_DBG("Bulk endpoints not found");
 867                 goto done;
 868         }
 869
 870         if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
 871                 BT_ERR("Can't allocate: control structure");
 872                 goto done;
 873         }
 874
 875         memset(husb, 0, sizeof(struct hci_usb));
 876
 877         husb->udev = udev;
 878         husb->bulk_out_ep = bulk_out_ep;
 879         husb->bulk_in_ep  = bulk_in_ep;
 880         husb->intr_in_ep  = intr_in_ep;
 881
 882         if (id->driver_info & HCI_DIGIANSWER)
 883                 husb->ctrl_req = USB_TYPE_VENDOR;
 884         else
 885                 husb->ctrl_req = USB_TYPE_CLASS;
 886
 887         /* Find isochronous endpoints that we can use */
 888         size = 0;
 889         isoc_iface = NULL;
 890         isoc_alts  = 0;
 891         isoc_ifnum = 1;
 892
 893 #ifdef CONFIG_BT_HCIUSB_SCO
 894         if (isoc && !(id->driver_info & (HCI_BROKEN_ISOC | HCI_SNIFFER)))
 895                 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
 896
 897         if (isoc_iface) {
 898                 int a;
 899                 struct usb_host_endpoint *isoc_out_ep = NULL;
 900                 struct usb_host_endpoint *isoc_in_ep = NULL;
 901
 902                 for (a = 0; a < isoc_iface->num_altsetting; a++) {
 903                         uif = &isoc_iface->altsetting[a];
 904                         for (e = 0; e < uif->desc.bNumEndpoints; e++) {
 905                                 ep = &uif->endpoint[e];
 906
 907                                 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
 908                                 case USB_ENDPOINT_XFER_ISOC:
 909                                         if (le16_to_cpu(ep->desc.wMaxPacketSize) < size ||
 910                                                         uif->desc.bAlternateSetting != isoc)
 911                                                 break;
 912                                         size = le16_to_cpu(ep->desc.wMaxPacketSize);
 913
 914                                         isoc_alts = uif->desc.bAlternateSetting;
 915
 916                                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
 917                                                 isoc_in_ep  = ep;
 918                                         else
 919                                                 isoc_out_ep = ep;
 920                                         break;
 921                                 }
 922                         }
 923                 }
 924
 925                 if (!isoc_in_ep || !isoc_out_ep)
 926                         BT_DBG("Isoc endpoints not found");
 927                 else {
 928                         BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
 929                         if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
 930                                 BT_ERR("Can't claim isoc interface");
 931                         else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
 932                                 BT_ERR("Can't set isoc interface settings");
 933                                 husb->isoc_iface = isoc_iface;
 934                                 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
 935                                 husb->isoc_iface = NULL;
 936                         } else {
 937                                 husb->isoc_iface  = isoc_iface;
 938                                 husb->isoc_in_ep  = isoc_in_ep;
 939                                 husb->isoc_out_ep = isoc_out_ep;
 940                         }
 941                 }
 942         }
 943 #endif
 944
 945         rwlock_init(&husb->completion_lock);
 946
 947         for (i = 0; i < 4; i++) {
 948                 skb_queue_head_init(&husb->transmit_q[i]);
 949                 _urb_queue_init(&husb->pending_q[i]);
 950                 _urb_queue_init(&husb->completed_q[i]);
 951         }
 952
 953         /* Initialize and register HCI device */
 954         hdev = hci_alloc_dev();
 955         if (!hdev) {
 956                 BT_ERR("Can't allocate HCI device");
 957                 goto probe_error;
 958         }
 959
 960         husb->hdev = hdev;
 961
 962         hdev->type = HCI_USB;
 963         hdev->driver_data = husb;
 964         SET_HCIDEV_DEV(hdev, &intf->dev);
 965
 966         hdev->open     = hci_usb_open;
 967         hdev->close    = hci_usb_close;
 968         hdev->flush    = hci_usb_flush;
 969         hdev->send     = hci_usb_send_frame;
 970         hdev->destruct = hci_usb_destruct;
 971         hdev->notify   = hci_usb_notify;
 972
 973         hdev->owner = THIS_MODULE;
 974
 975         if (reset || id->driver_info & HCI_RESET)
 976                 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
 977
 978         if (id->driver_info & HCI_SNIFFER) {
 979                 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
 980                         set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 981         }
 982
 983         if (id->driver_info & HCI_BCM92035) {
 984                 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
 985                 struct sk_buff *skb;
 986
 987                 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
 988                 if (skb) {
 989                         memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
 990                         skb_queue_tail(&hdev->driver_init, skb);
 991                 }
 992         }
 993
 994         if (hci_register_dev(hdev) < 0) {
 995                 BT_ERR("Can't register HCI device");
 996                 hci_free_dev(hdev);
 997                 goto probe_error;
 998         }
 999
1000         usb_set_intfdata(intf, husb);
1001         return 0;
1002
1003 probe_error:
1004         if (husb->isoc_iface)
1005                 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1006         kfree(husb);
1007
1008 done:
1009         return -EIO;
1010 }
1011
1012 static void hci_usb_disconnect(struct usb_interface *intf)
1013 {
1014         struct hci_usb *husb = usb_get_intfdata(intf);
1015         struct hci_dev *hdev;
1016
1017         if (!husb || intf == husb->isoc_iface)
1018                 return;
1019
1020         usb_set_intfdata(intf, NULL);
1021         hdev = husb->hdev;
1022
1023         BT_DBG("%s", hdev->name);
1024
1025         hci_usb_close(hdev);
1026
1027         if (husb->isoc_iface)
1028                 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1029
1030         if (hci_unregister_dev(hdev) < 0)
1031                 BT_ERR("Can't unregister HCI device %s", hdev->name);
1032
1033         hci_free_dev(hdev);
1034 }
1035
1036 static struct usb_driver hci_usb_driver = {
1037         .owner          = THIS_MODULE,
1038         .name           = "hci_usb",
1039         .probe          = hci_usb_probe,
1040         .disconnect     = hci_usb_disconnect,
1041         .id_table       = bluetooth_ids,
1042 };
1043
1044 static int __init hci_usb_init(void)
1045 {
1046         int err;
1047
1048         BT_INFO("HCI USB driver ver %s", VERSION);
1049
1050         if ((err = usb_register(&hci_usb_driver)) < 0)
1051                 BT_ERR("Failed to register HCI USB driver");
1052
1053         return err;
1054 }
1055
1056 static void __exit hci_usb_exit(void)
1057 {
1058         usb_deregister(&hci_usb_driver);
1059 }
1060
1061 module_init(hci_usb_init);
1062 module_exit(hci_usb_exit);
1063
1064 module_param(ignore, bool, 0644);
1065 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
1066
1067 module_param(reset, bool, 0644);
1068 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1069
1070 #ifdef CONFIG_BT_HCIUSB_SCO
1071 module_param(isoc, int, 0644);
1072 MODULE_PARM_DESC(isoc, "Set isochronous transfers for SCO over HCI support");
1073 #endif
1074
1075 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1076 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1077 MODULE_VERSION(VERSION);
1078 MODULE_LICENSE("GPL");