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