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