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         /* ISSC Bluetooth Adapter v3.1 */
 114         { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
 115
 116         /* RTX Telecom based adapter with buggy SCO support */
 117         { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
 118
 119         /* Digianswer devices */
 120         { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
 121         { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
 122
 123         /* CSR BlueCore Bluetooth Sniffer */
 124         { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
 125
 126         { }     /* Terminating entry */
 127 };
 128
 129 static struct _urb *_urb_alloc(int isoc, int gfp)
 130 {
 131         struct _urb *_urb = kmalloc(sizeof(struct _urb) +
 132                                 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
 133         if (_urb) {
 134                 memset(_urb, 0, sizeof(*_urb));
 135                 usb_init_urb(&_urb->urb);
 136         }
 137         return _urb;
 138 }
 139
 140 static struct _urb *_urb_dequeue(struct _urb_queue *q)
 141 {
 142         struct _urb *_urb = NULL;
 143         unsigned long flags;
 144         spin_lock_irqsave(&q->lock, flags);
 145         {
 146                 struct list_head *head = &q->head;
 147                 struct list_head *next = head->next;
 148                 if (next != head) {
 149                         _urb = list_entry(next, struct _urb, list);
 150                         list_del(next); _urb->queue = NULL;
 151                 }
 152         }
 153         spin_unlock_irqrestore(&q->lock, flags);
 154         return _urb;
 155 }
 156
 157 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
 158 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
 159
 160 #define __pending_tx(husb, type)  (&husb->pending_tx[type-1])
 161 #define __pending_q(husb, type)   (&husb->pending_q[type-1])
 162 #define __completed_q(husb, type) (&husb->completed_q[type-1])
 163 #define __transmit_q(husb, type)  (&husb->transmit_q[type-1])
 164 #define __reassembly(husb, type)  (husb->reassembly[type-1])
 165
 166 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
 167 {
 168         return _urb_dequeue(__completed_q(husb, type));
 169 }
 170
 171 #ifdef CONFIG_BT_HCIUSB_SCO
 172 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
 173 {
 174         int offset = 0, i;
 175
 176         BT_DBG("len %d mtu %d", len, mtu);
 177
 178         for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
 179                 urb->iso_frame_desc[i].offset = offset;
 180                 urb->iso_frame_desc[i].length = mtu;
 181                 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
 182         }
 183         if (len && i < HCI_MAX_ISOC_FRAMES) {
 184                 urb->iso_frame_desc[i].offset = offset;
 185                 urb->iso_frame_desc[i].length = len;
 186                 BT_DBG("desc %d offset %d len %d", i, offset, len);
 187                 i++;
 188         }
 189         urb->number_of_packets = i;
 190 }
 191 #endif
 192
 193 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
 194 {
 195         struct _urb *_urb;
 196         struct urb *urb;
 197         int err, pipe, interval, size;
 198         void *buf;
 199
 200         BT_DBG("%s", husb->hdev->name);
 201
 202         size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
 203
 204         buf = kmalloc(size, GFP_ATOMIC);
 205         if (!buf)
 206                 return -ENOMEM;
 207
 208         _urb = _urb_alloc(0, GFP_ATOMIC);
 209         if (!_urb) {
 210                 kfree(buf);
 211                 return -ENOMEM;
 212         }
 213         _urb->type = HCI_EVENT_PKT;
 214         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 215
 216         urb = &_urb->urb;
 217         pipe     = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
 218         interval = husb->intr_in_ep->desc.bInterval;
 219         usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
 220
 221         err = usb_submit_urb(urb, GFP_ATOMIC);
 222         if (err) {
 223                 BT_ERR("%s intr rx submit failed urb %p err %d",
 224                                 husb->hdev->name, urb, err);
 225                 _urb_unlink(_urb);
 226                 _urb_free(_urb);
 227                 kfree(buf);
 228         }
 229         return err;
 230 }
 231
 232 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
 233 {
 234         struct _urb *_urb;
 235         struct urb *urb;
 236         int err, pipe, size = HCI_MAX_FRAME_SIZE;
 237         void *buf;
 238
 239         buf = kmalloc(size, GFP_ATOMIC);
 240         if (!buf)
 241                 return -ENOMEM;
 242
 243         _urb = _urb_alloc(0, GFP_ATOMIC);
 244         if (!_urb) {
 245                 kfree(buf);
 246                 return -ENOMEM;
 247         }
 248         _urb->type = HCI_ACLDATA_PKT;
 249         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 250
 251         urb  = &_urb->urb;
 252         pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
 253         usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
 254         urb->transfer_flags = 0;
 255
 256         BT_DBG("%s urb %p", husb->hdev->name, urb);
 257
 258         err = usb_submit_urb(urb, GFP_ATOMIC);
 259         if (err) {
 260                 BT_ERR("%s bulk rx submit failed urb %p err %d",
 261                                 husb->hdev->name, urb, err);
 262                 _urb_unlink(_urb);
 263                 _urb_free(_urb);
 264                 kfree(buf);
 265         }
 266         return err;
 267 }
 268
 269 #ifdef CONFIG_BT_HCIUSB_SCO
 270 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
 271 {
 272         struct _urb *_urb;
 273         struct urb *urb;
 274         int err, mtu, size;
 275         void *buf;
 276
 277         mtu  = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
 278         size = mtu * HCI_MAX_ISOC_FRAMES;
 279
 280         buf = kmalloc(size, GFP_ATOMIC);
 281         if (!buf)
 282                 return -ENOMEM;
 283
 284         _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
 285         if (!_urb) {
 286                 kfree(buf);
 287                 return -ENOMEM;
 288         }
 289         _urb->type = HCI_SCODATA_PKT;
 290         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 291
 292         urb = &_urb->urb;
 293
 294         urb->context  = husb;
 295         urb->dev      = husb->udev;
 296         urb->pipe     = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
 297         urb->complete = hci_usb_rx_complete;
 298
 299         urb->interval = husb->isoc_in_ep->desc.bInterval;
 300
 301         urb->transfer_buffer_length = size;
 302         urb->transfer_buffer = buf;
 303         urb->transfer_flags  = URB_ISO_ASAP;
 304
 305         __fill_isoc_desc(urb, size, mtu);
 306
 307         BT_DBG("%s urb %p", husb->hdev->name, urb);
 308
 309         err = usb_submit_urb(urb, GFP_ATOMIC);
 310         if (err) {
 311                 BT_ERR("%s isoc rx submit failed urb %p err %d",
 312                                 husb->hdev->name, urb, err);
 313                 _urb_unlink(_urb);
 314                 _urb_free(_urb);
 315                 kfree(buf);
 316         }
 317         return err;
 318 }
 319 #endif
 320
 321 /* Initialize device */
 322 static int hci_usb_open(struct hci_dev *hdev)
 323 {
 324         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 325         int i, err;
 326         unsigned long flags;
 327
 328         BT_DBG("%s", hdev->name);
 329
 330         if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
 331                 return 0;
 332
 333         write_lock_irqsave(&husb->completion_lock, flags);
 334
 335         err = hci_usb_intr_rx_submit(husb);
 336         if (!err) {
 337                 for (i = 0; i < HCI_MAX_BULK_RX; i++)
 338                         hci_usb_bulk_rx_submit(husb);
 339
 340 #ifdef CONFIG_BT_HCIUSB_SCO
 341                 if (husb->isoc_iface)
 342                         for (i = 0; i < HCI_MAX_ISOC_RX; i++)
 343                                 hci_usb_isoc_rx_submit(husb);
 344 #endif
 345         } else {
 346                 clear_bit(HCI_RUNNING, &hdev->flags);
 347         }
 348
 349         write_unlock_irqrestore(&husb->completion_lock, flags);
 350         return err;
 351 }
 352
 353 /* Reset device */
 354 static int hci_usb_flush(struct hci_dev *hdev)
 355 {
 356         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 357         int i;
 358
 359         BT_DBG("%s", hdev->name);
 360
 361         for (i = 0; i < 4; i++)
 362                 skb_queue_purge(&husb->transmit_q[i]);
 363         return 0;
 364 }
 365
 366 static void hci_usb_unlink_urbs(struct hci_usb *husb)
 367 {
 368         int i;
 369
 370         BT_DBG("%s", husb->hdev->name);
 371
 372         for (i = 0; i < 4; i++) {
 373                 struct _urb *_urb;
 374                 struct urb *urb;
 375
 376                 /* Kill pending requests */
 377                 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
 378                         urb = &_urb->urb;
 379                         BT_DBG("%s unlinking _urb %p type %d urb %p",
 380                                         husb->hdev->name, _urb, _urb->type, urb);
 381                         usb_kill_urb(urb);
 382                         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 383                 }
 384
 385                 /* Release completed requests */
 386                 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
 387                         urb = &_urb->urb;
 388                         BT_DBG("%s freeing _urb %p type %d urb %p",
 389                                         husb->hdev->name, _urb, _urb->type, urb);
 390                         if (urb->setup_packet)
 391                                 kfree(urb->setup_packet);
 392                         if (urb->transfer_buffer)
 393                                 kfree(urb->transfer_buffer);
 394                         _urb_free(_urb);
 395                 }
 396
 397                 /* Release reassembly buffers */
 398                 if (husb->reassembly[i]) {
 399                         kfree_skb(husb->reassembly[i]);
 400                         husb->reassembly[i] = NULL;
 401                 }
 402         }
 403 }
 404
 405 /* Close device */
 406 static int hci_usb_close(struct hci_dev *hdev)
 407 {
 408         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 409         unsigned long flags;
 410
 411         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 412                 return 0;
 413
 414         BT_DBG("%s", hdev->name);
 415
 416         /* Synchronize with completion handlers */
 417         write_lock_irqsave(&husb->completion_lock, flags);
 418         write_unlock_irqrestore(&husb->completion_lock, flags);
 419
 420         hci_usb_unlink_urbs(husb);
 421         hci_usb_flush(hdev);
 422         return 0;
 423 }
 424
 425 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
 426 {
 427         struct urb *urb = &_urb->urb;
 428         int err;
 429
 430         BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
 431
 432         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 433         err = usb_submit_urb(urb, GFP_ATOMIC);
 434         if (err) {
 435                 BT_ERR("%s tx submit failed urb %p type %d err %d",
 436                                 husb->hdev->name, urb, _urb->type, err);
 437                 _urb_unlink(_urb);
 438                 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 439         } else
 440                 atomic_inc(__pending_tx(husb, _urb->type));
 441
 442         return err;
 443 }
 444
 445 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
 446 {
 447         struct _urb *_urb = __get_completed(husb, skb->pkt_type);
 448         struct usb_ctrlrequest *dr;
 449         struct urb *urb;
 450
 451         if (!_urb) {
 452                 _urb = _urb_alloc(0, GFP_ATOMIC);
 453                 if (!_urb)
 454                         return -ENOMEM;
 455                 _urb->type = skb->pkt_type;
 456
 457                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 458                 if (!dr) {
 459                         _urb_free(_urb);
 460                         return -ENOMEM;
 461                 }
 462         } else
 463                 dr = (void *) _urb->urb.setup_packet;
 464
 465         dr->bRequestType = husb->ctrl_req;
 466         dr->bRequest = 0;
 467         dr->wIndex   = 0;
 468         dr->wValue   = 0;
 469         dr->wLength  = __cpu_to_le16(skb->len);
 470
 471         urb = &_urb->urb;
 472         usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
 473                 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
 474
 475         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 476
 477         _urb->priv = skb;
 478         return __tx_submit(husb, _urb);
 479 }
 480
 481 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
 482 {
 483         struct _urb *_urb = __get_completed(husb, skb->pkt_type);
 484         struct urb *urb;
 485         int pipe;
 486
 487         if (!_urb) {
 488                 _urb = _urb_alloc(0, GFP_ATOMIC);
 489                 if (!_urb)
 490                         return -ENOMEM;
 491                 _urb->type = skb->pkt_type;
 492         }
 493
 494         urb  = &_urb->urb;
 495         pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
 496         usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
 497                         hci_usb_tx_complete, husb);
 498         urb->transfer_flags = URB_ZERO_PACKET;
 499
 500         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 501
 502         _urb->priv = skb;
 503         return __tx_submit(husb, _urb);
 504 }
 505
 506 #ifdef CONFIG_BT_HCIUSB_SCO
 507 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
 508 {
 509         struct _urb *_urb = __get_completed(husb, skb->pkt_type);
 510         struct urb *urb;
 511
 512         if (!_urb) {
 513                 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
 514                 if (!_urb)
 515                         return -ENOMEM;
 516                 _urb->type = skb->pkt_type;
 517         }
 518
 519         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 520
 521         urb = &_urb->urb;
 522
 523         urb->context  = husb;
 524         urb->dev      = husb->udev;
 525         urb->pipe     = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
 526         urb->complete = hci_usb_tx_complete;
 527         urb->transfer_flags = URB_ISO_ASAP;
 528
 529         urb->interval = husb->isoc_out_ep->desc.bInterval;
 530
 531         urb->transfer_buffer = skb->data;
 532         urb->transfer_buffer_length = skb->len;
 533
 534         __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
 535
 536         _urb->priv = skb;
 537         return __tx_submit(husb, _urb);
 538 }
 539 #endif
 540
 541 static void hci_usb_tx_process(struct hci_usb *husb)
 542 {
 543         struct sk_buff_head *q;
 544         struct sk_buff *skb;
 545
 546         BT_DBG("%s", husb->hdev->name);
 547
 548         do {
 549                 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
 550
 551                 /* Process command queue */
 552                 q = __transmit_q(husb, HCI_COMMAND_PKT);
 553                 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
 554                                 (skb = skb_dequeue(q))) {
 555                         if (hci_usb_send_ctrl(husb, skb) < 0)
 556                                 skb_queue_head(q, skb);
 557                 }
 558
 559 #ifdef CONFIG_BT_HCIUSB_SCO
 560                 /* Process SCO queue */
 561                 q = __transmit_q(husb, HCI_SCODATA_PKT);
 562                 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
 563                                 (skb = skb_dequeue(q))) {
 564                         if (hci_usb_send_isoc(husb, skb) < 0)
 565                                 skb_queue_head(q, skb);
 566                 }
 567 #endif
 568
 569                 /* Process ACL queue */
 570                 q = __transmit_q(husb, HCI_ACLDATA_PKT);
 571                 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
 572                                 (skb = skb_dequeue(q))) {
 573                         if (hci_usb_send_bulk(husb, skb) < 0) {
 574                                 skb_queue_head(q, skb);
 575                                 break;
 576                         }
 577                 }
 578         } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
 579 }
 580
 581 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
 582 {
 583         /* Serialize TX queue processing to avoid data reordering */
 584         if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
 585                 hci_usb_tx_process(husb);
 586                 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
 587         } else
 588                 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
 589 }
 590
 591 /* Send frames from HCI layer */
 592 static int hci_usb_send_frame(struct sk_buff *skb)
 593 {
 594         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 595         struct hci_usb *husb;
 596
 597         if (!hdev) {
 598                 BT_ERR("frame for uknown device (hdev=NULL)");
 599                 return -ENODEV;
 600         }
 601
 602         if (!test_bit(HCI_RUNNING, &hdev->flags))
 603                 return -EBUSY;
 604
 605         BT_DBG("%s type %d len %d", hdev->name, skb->pkt_type, skb->len);
 606
 607         husb = (struct hci_usb *) hdev->driver_data;
 608
 609         switch (skb->pkt_type) {
 610         case HCI_COMMAND_PKT:
 611                 hdev->stat.cmd_tx++;
 612                 break;
 613
 614         case HCI_ACLDATA_PKT:
 615                 hdev->stat.acl_tx++;
 616                 break;
 617
 618 #ifdef CONFIG_BT_HCIUSB_SCO
 619         case HCI_SCODATA_PKT:
 620                 hdev->stat.sco_tx++;
 621                 break;
 622 #endif
 623
 624         default:
 625                 kfree_skb(skb);
 626                 return 0;
 627         }
 628
 629         read_lock(&husb->completion_lock);
 630
 631         skb_queue_tail(__transmit_q(husb, skb->pkt_type), skb);
 632         hci_usb_tx_wakeup(husb);
 633
 634         read_unlock(&husb->completion_lock);
 635         return 0;
 636 }
 637
 638 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
 639 {
 640         BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
 641
 642         husb->hdev->stat.byte_rx += count;
 643
 644         while (count) {
 645                 struct sk_buff *skb = __reassembly(husb, type);
 646                 struct { int expect; } *scb;
 647                 int len = 0;
 648
 649                 if (!skb) {
 650                         /* Start of the frame */
 651
 652                         switch (type) {
 653                         case HCI_EVENT_PKT:
 654                                 if (count >= HCI_EVENT_HDR_SIZE) {
 655                                         struct hci_event_hdr *h = data;
 656                                         len = HCI_EVENT_HDR_SIZE + h->plen;
 657                                 } else
 658                                         return -EILSEQ;
 659                                 break;
 660
 661                         case HCI_ACLDATA_PKT:
 662                                 if (count >= HCI_ACL_HDR_SIZE) {
 663                                         struct hci_acl_hdr *h = data;
 664                                         len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
 665                                 } else
 666                                         return -EILSEQ;
 667                                 break;
 668 #ifdef CONFIG_BT_HCIUSB_SCO
 669                         case HCI_SCODATA_PKT:
 670                                 if (count >= HCI_SCO_HDR_SIZE) {
 671                                         struct hci_sco_hdr *h = data;
 672                                         len = HCI_SCO_HDR_SIZE + h->dlen;
 673                                 } else
 674                                         return -EILSEQ;
 675                                 break;
 676 #endif
 677                         }
 678                         BT_DBG("new packet len %d", len);
 679
 680                         skb = bt_skb_alloc(len, GFP_ATOMIC);
 681                         if (!skb) {
 682                                 BT_ERR("%s no memory for the packet", husb->hdev->name);
 683                                 return -ENOMEM;
 684                         }
 685                         skb->dev = (void *) husb->hdev;
 686                         skb->pkt_type = type;
 687
 688                         __reassembly(husb, type) = skb;
 689
 690                         scb = (void *) skb->cb;
 691                         scb->expect = len;
 692                 } else {
 693                         /* Continuation */
 694                         scb = (void *) skb->cb;
 695                         len = scb->expect;
 696                 }
 697
 698                 len = min(len, count);
 699
 700                 memcpy(skb_put(skb, len), data, len);
 701
 702                 scb->expect -= len;
 703                 if (!scb->expect) {
 704                         /* Complete frame */
 705                         __reassembly(husb, type) = NULL;
 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");