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