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