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