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