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