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