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