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