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