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