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