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