linux/drivers/bluetooth/btusb.c
<<
>>
Prefs
   1/*
   2 *
   3 *  Generic Bluetooth USB driver
   4 *
   5 *  Copyright (C) 2005-2008  Marcel Holtmann <marcel@holtmann.org>
   6 *
   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 as published by
  10 *  the Free Software Foundation; either version 2 of the License, or
  11 *  (at your option) any later version.
  12 *
  13 *  This program is distributed in the hope that it will be useful,
  14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 *  GNU General Public License for more details.
  17 *
  18 *  You should have received a copy of the GNU General Public License
  19 *  along with this program; if not, write to the Free Software
  20 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 *
  22 */
  23
  24#include <linux/module.h>
  25#include <linux/usb.h>
  26
  27#include <net/bluetooth/bluetooth.h>
  28#include <net/bluetooth/hci_core.h>
  29
  30#define VERSION "0.6"
  31
  32static bool ignore_dga;
  33static bool ignore_csr;
  34static bool ignore_sniffer;
  35static bool disable_scofix;
  36static bool force_scofix;
  37
  38static bool reset = 1;
  39
  40static struct usb_driver btusb_driver;
  41
  42#define BTUSB_IGNORE            0x01
  43#define BTUSB_DIGIANSWER        0x02
  44#define BTUSB_CSR               0x04
  45#define BTUSB_SNIFFER           0x08
  46#define BTUSB_BCM92035          0x10
  47#define BTUSB_BROKEN_ISOC       0x20
  48#define BTUSB_WRONG_SCO_MTU     0x40
  49#define BTUSB_ATH3012           0x80
  50
  51static struct usb_device_id btusb_table[] = {
  52        /* Generic Bluetooth USB device */
  53        { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
  54
  55        /* Apple-specific (Broadcom) devices */
  56        { USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) },
  57
  58        /* Broadcom SoftSailing reporting vendor specific */
  59        { USB_DEVICE(0x0a5c, 0x21e1) },
  60
  61        /* Apple MacBookPro 7,1 */
  62        { USB_DEVICE(0x05ac, 0x8213) },
  63
  64        /* Apple iMac11,1 */
  65        { USB_DEVICE(0x05ac, 0x8215) },
  66
  67        /* Apple MacBookPro6,2 */
  68        { USB_DEVICE(0x05ac, 0x8218) },
  69
  70        /* Apple MacBookAir3,1, MacBookAir3,2 */
  71        { USB_DEVICE(0x05ac, 0x821b) },
  72
  73        /* Apple MacBookAir4,1 */
  74        { USB_DEVICE(0x05ac, 0x821f) },
  75
  76        /* Apple MacBookPro8,2 */
  77        { USB_DEVICE(0x05ac, 0x821a) },
  78
  79        /* Apple MacMini5,1 */
  80        { USB_DEVICE(0x05ac, 0x8281) },
  81
  82        /* AVM BlueFRITZ! USB v2.0 */
  83        { USB_DEVICE(0x057c, 0x3800) },
  84
  85        /* Bluetooth Ultraport Module from IBM */
  86        { USB_DEVICE(0x04bf, 0x030a) },
  87
  88        /* ALPS Modules with non-standard id */
  89        { USB_DEVICE(0x044e, 0x3001) },
  90        { USB_DEVICE(0x044e, 0x3002) },
  91
  92        /* Ericsson with non-standard id */
  93        { USB_DEVICE(0x0bdb, 0x1002) },
  94
  95        /* Canyon CN-BTU1 with HID interfaces */
  96        { USB_DEVICE(0x0c10, 0x0000) },
  97
  98        /* Broadcom BCM20702A0 */
  99        { USB_DEVICE(0x0b05, 0x17b5) },
 100        { USB_DEVICE(0x04ca, 0x2003) },
 101        { USB_DEVICE(0x0489, 0xe042) },
 102        { USB_DEVICE(0x413c, 0x8197) },
 103
 104        /* Foxconn - Hon Hai */
 105        { USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },
 106
 107        /*Broadcom devices with vendor specific id */
 108        { USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) },
 109
 110        { }     /* Terminating entry */
 111};
 112
 113MODULE_DEVICE_TABLE(usb, btusb_table);
 114
 115static struct usb_device_id blacklist_table[] = {
 116        /* CSR BlueCore devices */
 117        { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
 118
 119        /* Broadcom BCM2033 without firmware */
 120        { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
 121
 122        /* Atheros 3011 with sflash firmware */
 123        { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
 124        { USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },
 125        { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
 126        { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
 127        { USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
 128        { USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
 129
 130        /* Atheros AR9285 Malbec with sflash firmware */
 131        { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
 132
 133        /* Atheros 3012 with sflash firmware */
 134        { USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
 135        { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
 136        { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
 137        { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
 138        { USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },
 139        { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
 140        { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
 141        { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
 142        { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
 143        { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
 144        { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
 145        { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
 146        { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
 147        { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
 148        { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
 149        { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
 150        { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
 151
 152        /* Atheros AR5BBU12 with sflash firmware */
 153        { USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },
 154
 155        /* Atheros AR5BBU12 with sflash firmware */
 156        { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
 157        { USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },
 158
 159        /* Broadcom BCM2035 */
 160        { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
 161        { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
 162        { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
 163
 164        /* Broadcom BCM2045 */
 165        { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
 166        { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
 167
 168        /* IBM/Lenovo ThinkPad with Broadcom chip */
 169        { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
 170        { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
 171
 172        /* HP laptop with Broadcom chip */
 173        { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
 174
 175        /* Dell laptop with Broadcom chip */
 176        { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
 177
 178        /* Dell Wireless 370 and 410 devices */
 179        { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
 180        { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
 181
 182        /* Belkin F8T012 and F8T013 devices */
 183        { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
 184        { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
 185
 186        /* Asus WL-BTD202 device */
 187        { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
 188
 189        /* Kensington Bluetooth USB adapter */
 190        { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
 191
 192        /* RTX Telecom based adapters with buggy SCO support */
 193        { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
 194        { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
 195
 196        /* CONWISE Technology based adapters with buggy SCO support */
 197        { USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },
 198
 199        /* Digianswer devices */
 200        { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
 201        { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
 202
 203        /* CSR BlueCore Bluetooth Sniffer */
 204        { USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },
 205
 206        /* Frontline ComProbe Bluetooth Sniffer */
 207        { USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },
 208
 209        { }     /* Terminating entry */
 210};
 211
 212#define BTUSB_MAX_ISOC_FRAMES   10
 213
 214#define BTUSB_INTR_RUNNING      0
 215#define BTUSB_BULK_RUNNING      1
 216#define BTUSB_ISOC_RUNNING      2
 217#define BTUSB_SUSPENDING        3
 218#define BTUSB_DID_ISO_RESUME    4
 219
 220struct btusb_data {
 221        struct hci_dev       *hdev;
 222        struct usb_device    *udev;
 223        struct usb_interface *intf;
 224        struct usb_interface *isoc;
 225
 226        spinlock_t lock;
 227
 228        unsigned long flags;
 229
 230        struct work_struct work;
 231        struct work_struct waker;
 232
 233        struct usb_anchor tx_anchor;
 234        struct usb_anchor intr_anchor;
 235        struct usb_anchor bulk_anchor;
 236        struct usb_anchor isoc_anchor;
 237        struct usb_anchor deferred;
 238        int tx_in_flight;
 239        spinlock_t txlock;
 240
 241        struct usb_endpoint_descriptor *intr_ep;
 242        struct usb_endpoint_descriptor *bulk_tx_ep;
 243        struct usb_endpoint_descriptor *bulk_rx_ep;
 244        struct usb_endpoint_descriptor *isoc_tx_ep;
 245        struct usb_endpoint_descriptor *isoc_rx_ep;
 246
 247        __u8 cmdreq_type;
 248
 249        unsigned int sco_num;
 250        int isoc_altsetting;
 251        int suspend_count;
 252};
 253
 254static int inc_tx(struct btusb_data *data)
 255{
 256        unsigned long flags;
 257        int rv;
 258
 259        spin_lock_irqsave(&data->txlock, flags);
 260        rv = test_bit(BTUSB_SUSPENDING, &data->flags);
 261        if (!rv)
 262                data->tx_in_flight++;
 263        spin_unlock_irqrestore(&data->txlock, flags);
 264
 265        return rv;
 266}
 267
 268static void btusb_intr_complete(struct urb *urb)
 269{
 270        struct hci_dev *hdev = urb->context;
 271        struct btusb_data *data = hci_get_drvdata(hdev);
 272        int err;
 273
 274        BT_DBG("%s urb %p status %d count %d", hdev->name,
 275                                        urb, urb->status, urb->actual_length);
 276
 277        if (!test_bit(HCI_RUNNING, &hdev->flags))
 278                return;
 279
 280        if (urb->status == 0) {
 281                hdev->stat.byte_rx += urb->actual_length;
 282
 283                if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
 284                                                urb->transfer_buffer,
 285                                                urb->actual_length) < 0) {
 286                        BT_ERR("%s corrupted event packet", hdev->name);
 287                        hdev->stat.err_rx++;
 288                }
 289        }
 290
 291        if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
 292                return;
 293
 294        usb_mark_last_busy(data->udev);
 295        usb_anchor_urb(urb, &data->intr_anchor);
 296
 297        err = usb_submit_urb(urb, GFP_ATOMIC);
 298        if (err < 0) {
 299                /* -EPERM: urb is being killed;
 300                 * -ENODEV: device got disconnected */
 301                if (err != -EPERM && err != -ENODEV)
 302                        BT_ERR("%s urb %p failed to resubmit (%d)",
 303                                                hdev->name, urb, -err);
 304                usb_unanchor_urb(urb);
 305        }
 306}
 307
 308static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
 309{
 310        struct btusb_data *data = hci_get_drvdata(hdev);
 311        struct urb *urb;
 312        unsigned char *buf;
 313        unsigned int pipe;
 314        int err, size;
 315
 316        BT_DBG("%s", hdev->name);
 317
 318        if (!data->intr_ep)
 319                return -ENODEV;
 320
 321        urb = usb_alloc_urb(0, mem_flags);
 322        if (!urb)
 323                return -ENOMEM;
 324
 325        size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
 326
 327        buf = kmalloc(size, mem_flags);
 328        if (!buf) {
 329                usb_free_urb(urb);
 330                return -ENOMEM;
 331        }
 332
 333        pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
 334
 335        usb_fill_int_urb(urb, data->udev, pipe, buf, size,
 336                                                btusb_intr_complete, hdev,
 337                                                data->intr_ep->bInterval);
 338
 339        urb->transfer_flags |= URB_FREE_BUFFER;
 340
 341        usb_anchor_urb(urb, &data->intr_anchor);
 342
 343        err = usb_submit_urb(urb, mem_flags);
 344        if (err < 0) {
 345                if (err != -EPERM && err != -ENODEV)
 346                        BT_ERR("%s urb %p submission failed (%d)",
 347                                                hdev->name, urb, -err);
 348                usb_unanchor_urb(urb);
 349        }
 350
 351        usb_free_urb(urb);
 352
 353        return err;
 354}
 355
 356static void btusb_bulk_complete(struct urb *urb)
 357{
 358        struct hci_dev *hdev = urb->context;
 359        struct btusb_data *data = hci_get_drvdata(hdev);
 360        int err;
 361
 362        BT_DBG("%s urb %p status %d count %d", hdev->name,
 363                                        urb, urb->status, urb->actual_length);
 364
 365        if (!test_bit(HCI_RUNNING, &hdev->flags))
 366                return;
 367
 368        if (urb->status == 0) {
 369                hdev->stat.byte_rx += urb->actual_length;
 370
 371                if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
 372                                                urb->transfer_buffer,
 373                                                urb->actual_length) < 0) {
 374                        BT_ERR("%s corrupted ACL packet", hdev->name);
 375                        hdev->stat.err_rx++;
 376                }
 377        }
 378
 379        if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
 380                return;
 381
 382        usb_anchor_urb(urb, &data->bulk_anchor);
 383        usb_mark_last_busy(data->udev);
 384
 385        err = usb_submit_urb(urb, GFP_ATOMIC);
 386        if (err < 0) {
 387                /* -EPERM: urb is being killed;
 388                 * -ENODEV: device got disconnected */
 389                if (err != -EPERM && err != -ENODEV)
 390                        BT_ERR("%s urb %p failed to resubmit (%d)",
 391                                                hdev->name, urb, -err);
 392                usb_unanchor_urb(urb);
 393        }
 394}
 395
 396static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
 397{
 398        struct btusb_data *data = hci_get_drvdata(hdev);
 399        struct urb *urb;
 400        unsigned char *buf;
 401        unsigned int pipe;
 402        int err, size = HCI_MAX_FRAME_SIZE;
 403
 404        BT_DBG("%s", hdev->name);
 405
 406        if (!data->bulk_rx_ep)
 407                return -ENODEV;
 408
 409        urb = usb_alloc_urb(0, mem_flags);
 410        if (!urb)
 411                return -ENOMEM;
 412
 413        buf = kmalloc(size, mem_flags);
 414        if (!buf) {
 415                usb_free_urb(urb);
 416                return -ENOMEM;
 417        }
 418
 419        pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
 420
 421        usb_fill_bulk_urb(urb, data->udev, pipe,
 422                                        buf, size, btusb_bulk_complete, hdev);
 423
 424        urb->transfer_flags |= URB_FREE_BUFFER;
 425
 426        usb_mark_last_busy(data->udev);
 427        usb_anchor_urb(urb, &data->bulk_anchor);
 428
 429        err = usb_submit_urb(urb, mem_flags);
 430        if (err < 0) {
 431                if (err != -EPERM && err != -ENODEV)
 432                        BT_ERR("%s urb %p submission failed (%d)",
 433                                                hdev->name, urb, -err);
 434                usb_unanchor_urb(urb);
 435        }
 436
 437        usb_free_urb(urb);
 438
 439        return err;
 440}
 441
 442static void btusb_isoc_complete(struct urb *urb)
 443{
 444        struct hci_dev *hdev = urb->context;
 445        struct btusb_data *data = hci_get_drvdata(hdev);
 446        int i, err;
 447
 448        BT_DBG("%s urb %p status %d count %d", hdev->name,
 449                                        urb, urb->status, urb->actual_length);
 450
 451        if (!test_bit(HCI_RUNNING, &hdev->flags))
 452                return;
 453
 454        if (urb->status == 0) {
 455                for (i = 0; i < urb->number_of_packets; i++) {
 456                        unsigned int offset = urb->iso_frame_desc[i].offset;
 457                        unsigned int length = urb->iso_frame_desc[i].actual_length;
 458
 459                        if (urb->iso_frame_desc[i].status)
 460                                continue;
 461
 462                        hdev->stat.byte_rx += length;
 463
 464                        if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
 465                                                urb->transfer_buffer + offset,
 466                                                                length) < 0) {
 467                                BT_ERR("%s corrupted SCO packet", hdev->name);
 468                                hdev->stat.err_rx++;
 469                        }
 470                }
 471        }
 472
 473        if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
 474                return;
 475
 476        usb_anchor_urb(urb, &data->isoc_anchor);
 477
 478        err = usb_submit_urb(urb, GFP_ATOMIC);
 479        if (err < 0) {
 480                /* -EPERM: urb is being killed;
 481                 * -ENODEV: device got disconnected */
 482                if (err != -EPERM && err != -ENODEV)
 483                        BT_ERR("%s urb %p failed to resubmit (%d)",
 484                                                hdev->name, urb, -err);
 485                usb_unanchor_urb(urb);
 486        }
 487}
 488
 489static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
 490{
 491        int i, offset = 0;
 492
 493        BT_DBG("len %d mtu %d", len, mtu);
 494
 495        for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
 496                                        i++, offset += mtu, len -= mtu) {
 497                urb->iso_frame_desc[i].offset = offset;
 498                urb->iso_frame_desc[i].length = mtu;
 499        }
 500
 501        if (len && i < BTUSB_MAX_ISOC_FRAMES) {
 502                urb->iso_frame_desc[i].offset = offset;
 503                urb->iso_frame_desc[i].length = len;
 504                i++;
 505        }
 506
 507        urb->number_of_packets = i;
 508}
 509
 510static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
 511{
 512        struct btusb_data *data = hci_get_drvdata(hdev);
 513        struct urb *urb;
 514        unsigned char *buf;
 515        unsigned int pipe;
 516        int err, size;
 517
 518        BT_DBG("%s", hdev->name);
 519
 520        if (!data->isoc_rx_ep)
 521                return -ENODEV;
 522
 523        urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
 524        if (!urb)
 525                return -ENOMEM;
 526
 527        size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
 528                                                BTUSB_MAX_ISOC_FRAMES;
 529
 530        buf = kmalloc(size, mem_flags);
 531        if (!buf) {
 532                usb_free_urb(urb);
 533                return -ENOMEM;
 534        }
 535
 536        pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
 537
 538        usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
 539                                hdev, data->isoc_rx_ep->bInterval);
 540
 541        urb->transfer_flags  = URB_FREE_BUFFER | URB_ISO_ASAP;
 542
 543        __fill_isoc_descriptor(urb, size,
 544                        le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
 545
 546        usb_anchor_urb(urb, &data->isoc_anchor);
 547
 548        err = usb_submit_urb(urb, mem_flags);
 549        if (err < 0) {
 550                if (err != -EPERM && err != -ENODEV)
 551                        BT_ERR("%s urb %p submission failed (%d)",
 552                                                hdev->name, urb, -err);
 553                usb_unanchor_urb(urb);
 554        }
 555
 556        usb_free_urb(urb);
 557
 558        return err;
 559}
 560
 561static void btusb_tx_complete(struct urb *urb)
 562{
 563        struct sk_buff *skb = urb->context;
 564        struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 565        struct btusb_data *data = hci_get_drvdata(hdev);
 566
 567        BT_DBG("%s urb %p status %d count %d", hdev->name,
 568                                        urb, urb->status, urb->actual_length);
 569
 570        if (!test_bit(HCI_RUNNING, &hdev->flags))
 571                goto done;
 572
 573        if (!urb->status)
 574                hdev->stat.byte_tx += urb->transfer_buffer_length;
 575        else
 576                hdev->stat.err_tx++;
 577
 578done:
 579        spin_lock(&data->txlock);
 580        data->tx_in_flight--;
 581        spin_unlock(&data->txlock);
 582
 583        kfree(urb->setup_packet);
 584
 585        kfree_skb(skb);
 586}
 587
 588static void btusb_isoc_tx_complete(struct urb *urb)
 589{
 590        struct sk_buff *skb = urb->context;
 591        struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 592
 593        BT_DBG("%s urb %p status %d count %d", hdev->name,
 594                                        urb, urb->status, urb->actual_length);
 595
 596        if (!test_bit(HCI_RUNNING, &hdev->flags))
 597                goto done;
 598
 599        if (!urb->status)
 600                hdev->stat.byte_tx += urb->transfer_buffer_length;
 601        else
 602                hdev->stat.err_tx++;
 603
 604done:
 605        kfree(urb->setup_packet);
 606
 607        kfree_skb(skb);
 608}
 609
 610static int btusb_open(struct hci_dev *hdev)
 611{
 612        struct btusb_data *data = hci_get_drvdata(hdev);
 613        int err;
 614
 615        BT_DBG("%s", hdev->name);
 616
 617        err = usb_autopm_get_interface(data->intf);
 618        if (err < 0)
 619                return err;
 620
 621        data->intf->needs_remote_wakeup = 1;
 622
 623        if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
 624                goto done;
 625
 626        if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
 627                goto done;
 628
 629        err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
 630        if (err < 0)
 631                goto failed;
 632
 633        err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
 634        if (err < 0) {
 635                usb_kill_anchored_urbs(&data->intr_anchor);
 636                goto failed;
 637        }
 638
 639        set_bit(BTUSB_BULK_RUNNING, &data->flags);
 640        btusb_submit_bulk_urb(hdev, GFP_KERNEL);
 641
 642done:
 643        usb_autopm_put_interface(data->intf);
 644        return 0;
 645
 646failed:
 647        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
 648        clear_bit(HCI_RUNNING, &hdev->flags);
 649        usb_autopm_put_interface(data->intf);
 650        return err;
 651}
 652
 653static void btusb_stop_traffic(struct btusb_data *data)
 654{
 655        usb_kill_anchored_urbs(&data->intr_anchor);
 656        usb_kill_anchored_urbs(&data->bulk_anchor);
 657        usb_kill_anchored_urbs(&data->isoc_anchor);
 658}
 659
 660static int btusb_close(struct hci_dev *hdev)
 661{
 662        struct btusb_data *data = hci_get_drvdata(hdev);
 663        int err;
 664
 665        BT_DBG("%s", hdev->name);
 666
 667        if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 668                return 0;
 669
 670        cancel_work_sync(&data->work);
 671        cancel_work_sync(&data->waker);
 672
 673        clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 674        clear_bit(BTUSB_BULK_RUNNING, &data->flags);
 675        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
 676
 677        btusb_stop_traffic(data);
 678        err = usb_autopm_get_interface(data->intf);
 679        if (err < 0)
 680                goto failed;
 681
 682        data->intf->needs_remote_wakeup = 0;
 683        usb_autopm_put_interface(data->intf);
 684
 685failed:
 686        usb_scuttle_anchored_urbs(&data->deferred);
 687        return 0;
 688}
 689
 690static int btusb_flush(struct hci_dev *hdev)
 691{
 692        struct btusb_data *data = hci_get_drvdata(hdev);
 693
 694        BT_DBG("%s", hdev->name);
 695
 696        usb_kill_anchored_urbs(&data->tx_anchor);
 697
 698        return 0;
 699}
 700
 701static int btusb_send_frame(struct sk_buff *skb)
 702{
 703        struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 704        struct btusb_data *data = hci_get_drvdata(hdev);
 705        struct usb_ctrlrequest *dr;
 706        struct urb *urb;
 707        unsigned int pipe;
 708        int err;
 709
 710        BT_DBG("%s", hdev->name);
 711
 712        if (!test_bit(HCI_RUNNING, &hdev->flags))
 713                return -EBUSY;
 714
 715        switch (bt_cb(skb)->pkt_type) {
 716        case HCI_COMMAND_PKT:
 717                urb = usb_alloc_urb(0, GFP_ATOMIC);
 718                if (!urb)
 719                        return -ENOMEM;
 720
 721                dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 722                if (!dr) {
 723                        usb_free_urb(urb);
 724                        return -ENOMEM;
 725                }
 726
 727                dr->bRequestType = data->cmdreq_type;
 728                dr->bRequest     = 0;
 729                dr->wIndex       = 0;
 730                dr->wValue       = 0;
 731                dr->wLength      = __cpu_to_le16(skb->len);
 732
 733                pipe = usb_sndctrlpipe(data->udev, 0x00);
 734
 735                usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
 736                                skb->data, skb->len, btusb_tx_complete, skb);
 737
 738                hdev->stat.cmd_tx++;
 739                break;
 740
 741        case HCI_ACLDATA_PKT:
 742                if (!data->bulk_tx_ep)
 743                        return -ENODEV;
 744
 745                urb = usb_alloc_urb(0, GFP_ATOMIC);
 746                if (!urb)
 747                        return -ENOMEM;
 748
 749                pipe = usb_sndbulkpipe(data->udev,
 750                                        data->bulk_tx_ep->bEndpointAddress);
 751
 752                usb_fill_bulk_urb(urb, data->udev, pipe,
 753                                skb->data, skb->len, btusb_tx_complete, skb);
 754
 755                hdev->stat.acl_tx++;
 756                break;
 757
 758        case HCI_SCODATA_PKT:
 759                if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)
 760                        return -ENODEV;
 761
 762                urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
 763                if (!urb)
 764                        return -ENOMEM;
 765
 766                pipe = usb_sndisocpipe(data->udev,
 767                                        data->isoc_tx_ep->bEndpointAddress);
 768
 769                usb_fill_int_urb(urb, data->udev, pipe,
 770                                skb->data, skb->len, btusb_isoc_tx_complete,
 771                                skb, data->isoc_tx_ep->bInterval);
 772
 773                urb->transfer_flags  = URB_ISO_ASAP;
 774
 775                __fill_isoc_descriptor(urb, skb->len,
 776                                le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
 777
 778                hdev->stat.sco_tx++;
 779                goto skip_waking;
 780
 781        default:
 782                return -EILSEQ;
 783        }
 784
 785        err = inc_tx(data);
 786        if (err) {
 787                usb_anchor_urb(urb, &data->deferred);
 788                schedule_work(&data->waker);
 789                err = 0;
 790                goto done;
 791        }
 792
 793skip_waking:
 794        usb_anchor_urb(urb, &data->tx_anchor);
 795
 796        err = usb_submit_urb(urb, GFP_ATOMIC);
 797        if (err < 0) {
 798                if (err != -EPERM && err != -ENODEV)
 799                        BT_ERR("%s urb %p submission failed (%d)",
 800                                                hdev->name, urb, -err);
 801                kfree(urb->setup_packet);
 802                usb_unanchor_urb(urb);
 803        } else {
 804                usb_mark_last_busy(data->udev);
 805        }
 806
 807done:
 808        usb_free_urb(urb);
 809        return err;
 810}
 811
 812static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
 813{
 814        struct btusb_data *data = hci_get_drvdata(hdev);
 815
 816        BT_DBG("%s evt %d", hdev->name, evt);
 817
 818        if (hdev->conn_hash.sco_num != data->sco_num) {
 819                data->sco_num = hdev->conn_hash.sco_num;
 820                schedule_work(&data->work);
 821        }
 822}
 823
 824static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
 825{
 826        struct btusb_data *data = hci_get_drvdata(hdev);
 827        struct usb_interface *intf = data->isoc;
 828        struct usb_endpoint_descriptor *ep_desc;
 829        int i, err;
 830
 831        if (!data->isoc)
 832                return -ENODEV;
 833
 834        err = usb_set_interface(data->udev, 1, altsetting);
 835        if (err < 0) {
 836                BT_ERR("%s setting interface failed (%d)", hdev->name, -err);
 837                return err;
 838        }
 839
 840        data->isoc_altsetting = altsetting;
 841
 842        data->isoc_tx_ep = NULL;
 843        data->isoc_rx_ep = NULL;
 844
 845        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 846                ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 847
 848                if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
 849                        data->isoc_tx_ep = ep_desc;
 850                        continue;
 851                }
 852
 853                if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
 854                        data->isoc_rx_ep = ep_desc;
 855                        continue;
 856                }
 857        }
 858
 859        if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
 860                BT_ERR("%s invalid SCO descriptors", hdev->name);
 861                return -ENODEV;
 862        }
 863
 864        return 0;
 865}
 866
 867static void btusb_work(struct work_struct *work)
 868{
 869        struct btusb_data *data = container_of(work, struct btusb_data, work);
 870        struct hci_dev *hdev = data->hdev;
 871        int new_alts;
 872        int err;
 873
 874        if (hdev->conn_hash.sco_num > 0) {
 875                if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
 876                        err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
 877                        if (err < 0) {
 878                                clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 879                                usb_kill_anchored_urbs(&data->isoc_anchor);
 880                                return;
 881                        }
 882
 883                        set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
 884                }
 885
 886                if (hdev->voice_setting & 0x0020) {
 887                        static const int alts[3] = { 2, 4, 5 };
 888                        new_alts = alts[hdev->conn_hash.sco_num - 1];
 889                } else {
 890                        new_alts = hdev->conn_hash.sco_num;
 891                }
 892
 893                if (data->isoc_altsetting != new_alts) {
 894                        clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 895                        usb_kill_anchored_urbs(&data->isoc_anchor);
 896
 897                        if (__set_isoc_interface(hdev, new_alts) < 0)
 898                                return;
 899                }
 900
 901                if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
 902                        if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
 903                                clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 904                        else
 905                                btusb_submit_isoc_urb(hdev, GFP_KERNEL);
 906                }
 907        } else {
 908                clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
 909                usb_kill_anchored_urbs(&data->isoc_anchor);
 910
 911                __set_isoc_interface(hdev, 0);
 912                if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
 913                        usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
 914        }
 915}
 916
 917static void btusb_waker(struct work_struct *work)
 918{
 919        struct btusb_data *data = container_of(work, struct btusb_data, waker);
 920        int err;
 921
 922        err = usb_autopm_get_interface(data->intf);
 923        if (err < 0)
 924                return;
 925
 926        usb_autopm_put_interface(data->intf);
 927}
 928
 929static int btusb_probe(struct usb_interface *intf,
 930                                const struct usb_device_id *id)
 931{
 932        struct usb_endpoint_descriptor *ep_desc;
 933        struct btusb_data *data;
 934        struct hci_dev *hdev;
 935        int i, err;
 936
 937        BT_DBG("intf %p id %p", intf, id);
 938
 939        /* interface numbers are hardcoded in the spec */
 940        if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
 941                return -ENODEV;
 942
 943        if (!id->driver_info) {
 944                const struct usb_device_id *match;
 945                match = usb_match_id(intf, blacklist_table);
 946                if (match)
 947                        id = match;
 948        }
 949
 950        if (id->driver_info == BTUSB_IGNORE)
 951                return -ENODEV;
 952
 953        if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)
 954                return -ENODEV;
 955
 956        if (ignore_csr && id->driver_info & BTUSB_CSR)
 957                return -ENODEV;
 958
 959        if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)
 960                return -ENODEV;
 961
 962        if (id->driver_info & BTUSB_ATH3012) {
 963                struct usb_device *udev = interface_to_usbdev(intf);
 964
 965                /* Old firmware would otherwise let ath3k driver load
 966                 * patch and sysconfig files */
 967                if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)
 968                        return -ENODEV;
 969        }
 970
 971        data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
 972        if (!data)
 973                return -ENOMEM;
 974
 975        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 976                ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 977
 978                if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
 979                        data->intr_ep = ep_desc;
 980                        continue;
 981                }
 982
 983                if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
 984                        data->bulk_tx_ep = ep_desc;
 985                        continue;
 986                }
 987
 988                if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
 989                        data->bulk_rx_ep = ep_desc;
 990                        continue;
 991                }
 992        }
 993
 994        if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
 995                return -ENODEV;
 996
 997        data->cmdreq_type = USB_TYPE_CLASS;
 998
 999        data->udev = interface_to_usbdev(intf);
1000        data->intf = intf;
1001
1002        spin_lock_init(&data->lock);
1003
1004        INIT_WORK(&data->work, btusb_work);
1005        INIT_WORK(&data->waker, btusb_waker);
1006        spin_lock_init(&data->txlock);
1007
1008        init_usb_anchor(&data->tx_anchor);
1009        init_usb_anchor(&data->intr_anchor);
1010        init_usb_anchor(&data->bulk_anchor);
1011        init_usb_anchor(&data->isoc_anchor);
1012        init_usb_anchor(&data->deferred);
1013
1014        hdev = hci_alloc_dev();
1015        if (!hdev)
1016                return -ENOMEM;
1017
1018        hdev->bus = HCI_USB;
1019        hci_set_drvdata(hdev, data);
1020
1021        data->hdev = hdev;
1022
1023        SET_HCIDEV_DEV(hdev, &intf->dev);
1024
1025        hdev->open     = btusb_open;
1026        hdev->close    = btusb_close;
1027        hdev->flush    = btusb_flush;
1028        hdev->send     = btusb_send_frame;
1029        hdev->notify   = btusb_notify;
1030
1031        /* Interface numbers are hardcoded in the specification */
1032        data->isoc = usb_ifnum_to_if(data->udev, 1);
1033
1034        if (!reset)
1035                set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
1036
1037        if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
1038                if (!disable_scofix)
1039                        set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
1040        }
1041
1042        if (id->driver_info & BTUSB_BROKEN_ISOC)
1043                data->isoc = NULL;
1044
1045        if (id->driver_info & BTUSB_DIGIANSWER) {
1046                data->cmdreq_type = USB_TYPE_VENDOR;
1047                set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
1048        }
1049
1050        if (id->driver_info & BTUSB_CSR) {
1051                struct usb_device *udev = data->udev;
1052
1053                /* Old firmware would otherwise execute USB reset */
1054                if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)
1055                        set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
1056        }
1057
1058        if (id->driver_info & BTUSB_SNIFFER) {
1059                struct usb_device *udev = data->udev;
1060
1061                /* New sniffer firmware has crippled HCI interface */
1062                if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
1063                        set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
1064
1065                data->isoc = NULL;
1066        }
1067
1068        if (id->driver_info & BTUSB_BCM92035) {
1069                unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
1070                struct sk_buff *skb;
1071
1072                skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1073                if (skb) {
1074                        memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1075                        skb_queue_tail(&hdev->driver_init, skb);
1076                }
1077        }
1078
1079        if (data->isoc) {
1080                err = usb_driver_claim_interface(&btusb_driver,
1081                                                        data->isoc, data);
1082                if (err < 0) {
1083                        hci_free_dev(hdev);
1084                        return err;
1085                }
1086        }
1087
1088        err = hci_register_dev(hdev);
1089        if (err < 0) {
1090                hci_free_dev(hdev);
1091                return err;
1092        }
1093
1094        usb_set_intfdata(intf, data);
1095
1096        return 0;
1097}
1098
1099static void btusb_disconnect(struct usb_interface *intf)
1100{
1101        struct btusb_data *data = usb_get_intfdata(intf);
1102        struct hci_dev *hdev;
1103
1104        BT_DBG("intf %p", intf);
1105
1106        if (!data)
1107                return;
1108
1109        hdev = data->hdev;
1110        usb_set_intfdata(data->intf, NULL);
1111
1112        if (data->isoc)
1113                usb_set_intfdata(data->isoc, NULL);
1114
1115        hci_unregister_dev(hdev);
1116
1117        if (intf == data->isoc)
1118                usb_driver_release_interface(&btusb_driver, data->intf);
1119        else if (data->isoc)
1120                usb_driver_release_interface(&btusb_driver, data->isoc);
1121
1122        hci_free_dev(hdev);
1123}
1124
1125#ifdef CONFIG_PM
1126static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
1127{
1128        struct btusb_data *data = usb_get_intfdata(intf);
1129
1130        BT_DBG("intf %p", intf);
1131
1132        if (data->suspend_count++)
1133                return 0;
1134
1135        spin_lock_irq(&data->txlock);
1136        if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
1137                set_bit(BTUSB_SUSPENDING, &data->flags);
1138                spin_unlock_irq(&data->txlock);
1139        } else {
1140                spin_unlock_irq(&data->txlock);
1141                data->suspend_count--;
1142                return -EBUSY;
1143        }
1144
1145        cancel_work_sync(&data->work);
1146
1147        btusb_stop_traffic(data);
1148        usb_kill_anchored_urbs(&data->tx_anchor);
1149
1150        return 0;
1151}
1152
1153static void play_deferred(struct btusb_data *data)
1154{
1155        struct urb *urb;
1156        int err;
1157
1158        while ((urb = usb_get_from_anchor(&data->deferred))) {
1159                err = usb_submit_urb(urb, GFP_ATOMIC);
1160                if (err < 0)
1161                        break;
1162
1163                data->tx_in_flight++;
1164        }
1165        usb_scuttle_anchored_urbs(&data->deferred);
1166}
1167
1168static int btusb_resume(struct usb_interface *intf)
1169{
1170        struct btusb_data *data = usb_get_intfdata(intf);
1171        struct hci_dev *hdev = data->hdev;
1172        int err = 0;
1173
1174        BT_DBG("intf %p", intf);
1175
1176        if (--data->suspend_count)
1177                return 0;
1178
1179        if (!test_bit(HCI_RUNNING, &hdev->flags))
1180                goto done;
1181
1182        if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
1183                err = btusb_submit_intr_urb(hdev, GFP_NOIO);
1184                if (err < 0) {
1185                        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1186                        goto failed;
1187                }
1188        }
1189
1190        if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
1191                err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
1192                if (err < 0) {
1193                        clear_bit(BTUSB_BULK_RUNNING, &data->flags);
1194                        goto failed;
1195                }
1196
1197                btusb_submit_bulk_urb(hdev, GFP_NOIO);
1198        }
1199
1200        if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1201                if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
1202                        clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1203                else
1204                        btusb_submit_isoc_urb(hdev, GFP_NOIO);
1205        }
1206
1207        spin_lock_irq(&data->txlock);
1208        play_deferred(data);
1209        clear_bit(BTUSB_SUSPENDING, &data->flags);
1210        spin_unlock_irq(&data->txlock);
1211        schedule_work(&data->work);
1212
1213        return 0;
1214
1215failed:
1216        usb_scuttle_anchored_urbs(&data->deferred);
1217done:
1218        spin_lock_irq(&data->txlock);
1219        clear_bit(BTUSB_SUSPENDING, &data->flags);
1220        spin_unlock_irq(&data->txlock);
1221
1222        return err;
1223}
1224#endif
1225
1226static struct usb_driver btusb_driver = {
1227        .name           = "btusb",
1228        .probe          = btusb_probe,
1229        .disconnect     = btusb_disconnect,
1230#ifdef CONFIG_PM
1231        .suspend        = btusb_suspend,
1232        .resume         = btusb_resume,
1233#endif
1234        .id_table       = btusb_table,
1235        .supports_autosuspend = 1,
1236        .disable_hub_initiated_lpm = 1,
1237};
1238
1239module_usb_driver(btusb_driver);
1240
1241module_param(ignore_dga, bool, 0644);
1242MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1243
1244module_param(ignore_csr, bool, 0644);
1245MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1246
1247module_param(ignore_sniffer, bool, 0644);
1248MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1249
1250module_param(disable_scofix, bool, 0644);
1251MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
1252
1253module_param(force_scofix, bool, 0644);
1254MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
1255
1256module_param(reset, bool, 0644);
1257MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1258
1259MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1260MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
1261MODULE_VERSION(VERSION);
1262MODULE_LICENSE("GPL");
1263
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.