drivers/bluetooth/hci_usb.c

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