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