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 #include <linux/firmware.h> 27 28 #include <net/bluetooth/bluetooth.h> 29 #include <net/bluetooth/hci_core.h> 30 31 #define VERSION "0.6" 32 33 static bool ignore_dga; 34 static bool ignore_csr; 35 static bool ignore_sniffer; 36 static bool disable_scofix; 37 static bool force_scofix; 38 39 static bool reset = 1; 40 41 static struct usb_driver btusb_driver; 42 43 #define BTUSB_IGNORE 0x01 44 #define BTUSB_DIGIANSWER 0x02 45 #define BTUSB_CSR 0x04 46 #define BTUSB_SNIFFER 0x08 47 #define BTUSB_BCM92035 0x10 48 #define BTUSB_BROKEN_ISOC 0x20 49 #define BTUSB_WRONG_SCO_MTU 0x40 50 #define BTUSB_ATH3012 0x80 51 #define BTUSB_INTEL 0x100 52 53 static struct usb_device_id btusb_table[] = { 54 /* Generic Bluetooth USB device */ 55 { USB_DEVICE_INFO(0xe0, 0x01, 0x01) }, 56 57 /* Apple-specific (Broadcom) devices */ 58 { USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) }, 59 60 /* MediaTek MT76x0E */ 61 { USB_DEVICE(0x0e8d, 0x763f) }, 62 63 /* Broadcom SoftSailing reporting vendor specific */ 64 { USB_DEVICE(0x0a5c, 0x21e1) }, 65 66 /* Apple MacBookPro 7,1 */ 67 { USB_DEVICE(0x05ac, 0x8213) }, 68 69 /* Apple iMac11,1 */ 70 { USB_DEVICE(0x05ac, 0x8215) }, 71 72 /* Apple MacBookPro6,2 */ 73 { USB_DEVICE(0x05ac, 0x8218) }, 74 75 /* Apple MacBookAir3,1, MacBookAir3,2 */ 76 { USB_DEVICE(0x05ac, 0x821b) }, 77 78 /* Apple MacBookAir4,1 */ 79 { USB_DEVICE(0x05ac, 0x821f) }, 80 81 /* Apple MacBookPro8,2 */ 82 { USB_DEVICE(0x05ac, 0x821a) }, 83 84 /* Apple MacMini5,1 */ 85 { USB_DEVICE(0x05ac, 0x8281) }, 86 87 /* AVM BlueFRITZ! USB v2.0 */ 88 { USB_DEVICE(0x057c, 0x3800) }, 89 90 /* Bluetooth Ultraport Module from IBM */ 91 { USB_DEVICE(0x04bf, 0x030a) }, 92 93 /* ALPS Modules with non-standard id */ 94 { USB_DEVICE(0x044e, 0x3001) }, 95 { USB_DEVICE(0x044e, 0x3002) }, 96 97 /* Ericsson with non-standard id */ 98 { USB_DEVICE(0x0bdb, 0x1002) }, 99 100 /* Canyon CN-BTU1 with HID interfaces */ 101 { USB_DEVICE(0x0c10, 0x0000) }, 102 103 /* Broadcom BCM20702A0 */ 104 { USB_DEVICE(0x0b05, 0x17b5) }, 105 { USB_DEVICE(0x0b05, 0x17cb) }, 106 { USB_DEVICE(0x04ca, 0x2003) }, 107 { USB_DEVICE(0x0489, 0xe042) }, 108 { USB_DEVICE(0x413c, 0x8197) }, 109 110 /* Foxconn - Hon Hai */ 111 { USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) }, 112 113 /*Broadcom devices with vendor specific id */ 114 { USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01) }, 115 116 /* Belkin F8065bf - Broadcom based */ 117 { USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01) }, 118 119 { } /* Terminating entry */ 120 }; 121 122 MODULE_DEVICE_TABLE(usb, btusb_table); 123 124 static struct usb_device_id blacklist_table[] = { 125 /* CSR BlueCore devices */ 126 { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR }, 127 128 /* Broadcom BCM2033 without firmware */ 129 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE }, 130 131 /* Atheros 3011 with sflash firmware */ 132 { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE }, 133 { USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE }, 134 { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE }, 135 { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE }, 136 { USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE }, 137 { USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE }, 138 139 /* Atheros AR9285 Malbec with sflash firmware */ 140 { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE }, 141 142 /* Atheros 3012 with sflash firmware */ 143 { USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 }, 144 { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 }, 145 { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 }, 146 { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 }, 147 { USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 }, 148 { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 }, 149 { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 }, 150 { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 }, 151 { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 }, 152 { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 }, 153 { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 }, 154 { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 }, 155 { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 }, 156 { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 }, 157 { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 }, 158 { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 }, 159 { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 }, 160 { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 }, 161 { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 }, 162 { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 }, 163 { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 }, 164 { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 }, 165 { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 }, 166 167 /* Atheros AR5BBU12 with sflash firmware */ 168 { USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE }, 169 170 /* Atheros AR5BBU12 with sflash firmware */ 171 { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 }, 172 { USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 }, 173 174 /* Broadcom BCM2035 */ 175 { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU }, 176 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU }, 177 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 }, 178 179 /* Broadcom BCM2045 */ 180 { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU }, 181 { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU }, 182 183 /* IBM/Lenovo ThinkPad with Broadcom chip */ 184 { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU }, 185 { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU }, 186 187 /* HP laptop with Broadcom chip */ 188 { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU }, 189 190 /* Dell laptop with Broadcom chip */ 191 { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU }, 192 193 /* Dell Wireless 370 and 410 devices */ 194 { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU }, 195 { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU }, 196 197 /* Belkin F8T012 and F8T013 devices */ 198 { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU }, 199 { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU }, 200 201 /* Asus WL-BTD202 device */ 202 { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU }, 203 204 /* Kensington Bluetooth USB adapter */ 205 { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU }, 206 207 /* RTX Telecom based adapters with buggy SCO support */ 208 { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC }, 209 { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC }, 210 211 /* CONWISE Technology based adapters with buggy SCO support */ 212 { USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC }, 213 214 /* Digianswer devices */ 215 { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER }, 216 { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE }, 217 218 /* CSR BlueCore Bluetooth Sniffer */ 219 { USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER }, 220 221 /* Frontline ComProbe Bluetooth Sniffer */ 222 { USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER }, 223 224 /* Intel Bluetooth device */ 225 { USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL }, 226 227 { } /* Terminating entry */ 228 }; 229 230 #define BTUSB_MAX_ISOC_FRAMES 10 231 232 #define BTUSB_INTR_RUNNING 0 233 #define BTUSB_BULK_RUNNING 1 234 #define BTUSB_ISOC_RUNNING 2 235 #define BTUSB_SUSPENDING 3 236 #define BTUSB_DID_ISO_RESUME 4 237 238 struct btusb_data { 239 struct hci_dev *hdev; 240 struct usb_device *udev; 241 struct usb_interface *intf; 242 struct usb_interface *isoc; 243 244 spinlock_t lock; 245 246 unsigned long flags; 247 248 struct work_struct work; 249 struct work_struct waker; 250 251 struct usb_anchor tx_anchor; 252 struct usb_anchor intr_anchor; 253 struct usb_anchor bulk_anchor; 254 struct usb_anchor isoc_anchor; 255 struct usb_anchor deferred; 256 int tx_in_flight; 257 spinlock_t txlock; 258 259 struct usb_endpoint_descriptor *intr_ep; 260 struct usb_endpoint_descriptor *bulk_tx_ep; 261 struct usb_endpoint_descriptor *bulk_rx_ep; 262 struct usb_endpoint_descriptor *isoc_tx_ep; 263 struct usb_endpoint_descriptor *isoc_rx_ep; 264 265 __u8 cmdreq_type; 266 267 unsigned int sco_num; 268 int isoc_altsetting; 269 int suspend_count; 270 }; 271 272 static int inc_tx(struct btusb_data *data) 273 { 274 unsigned long flags; 275 int rv; 276 277 spin_lock_irqsave(&data->txlock, flags); 278 rv = test_bit(BTUSB_SUSPENDING, &data->flags); 279 if (!rv) 280 data->tx_in_flight++; 281 spin_unlock_irqrestore(&data->txlock, flags); 282 283 return rv; 284 } 285 286 static void btusb_intr_complete(struct urb *urb) 287 { 288 struct hci_dev *hdev = urb->context; 289 struct btusb_data *data = hci_get_drvdata(hdev); 290 int err; 291 292 BT_DBG("%s urb %p status %d count %d", hdev->name, 293 urb, urb->status, urb->actual_length); 294 295 if (!test_bit(HCI_RUNNING, &hdev->flags)) 296 return; 297 298 if (urb->status == 0) { 299 hdev->stat.byte_rx += urb->actual_length; 300 301 if (hci_recv_fragment(hdev, HCI_EVENT_PKT, 302 urb->transfer_buffer, 303 urb->actual_length) < 0) { 304 BT_ERR("%s corrupted event packet", hdev->name); 305 hdev->stat.err_rx++; 306 } 307 } 308 309 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags)) 310 return; 311 312 usb_mark_last_busy(data->udev); 313 usb_anchor_urb(urb, &data->intr_anchor); 314 315 err = usb_submit_urb(urb, GFP_ATOMIC); 316 if (err < 0) { 317 /* -EPERM: urb is being killed; 318 * -ENODEV: device got disconnected */ 319 if (err != -EPERM && err != -ENODEV) 320 BT_ERR("%s urb %p failed to resubmit (%d)", 321 hdev->name, urb, -err); 322 usb_unanchor_urb(urb); 323 } 324 } 325 326 static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags) 327 { 328 struct btusb_data *data = hci_get_drvdata(hdev); 329 struct urb *urb; 330 unsigned char *buf; 331 unsigned int pipe; 332 int err, size; 333 334 BT_DBG("%s", hdev->name); 335 336 if (!data->intr_ep) 337 return -ENODEV; 338 339 urb = usb_alloc_urb(0, mem_flags); 340 if (!urb) 341 return -ENOMEM; 342 343 size = le16_to_cpu(data->intr_ep->wMaxPacketSize); 344 345 buf = kmalloc(size, mem_flags); 346 if (!buf) { 347 usb_free_urb(urb); 348 return -ENOMEM; 349 } 350 351 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress); 352 353 usb_fill_int_urb(urb, data->udev, pipe, buf, size, 354 btusb_intr_complete, hdev, 355 data->intr_ep->bInterval); 356 357 urb->transfer_flags |= URB_FREE_BUFFER; 358 359 usb_anchor_urb(urb, &data->intr_anchor); 360 361 err = usb_submit_urb(urb, mem_flags); 362 if (err < 0) { 363 if (err != -EPERM && err != -ENODEV) 364 BT_ERR("%s urb %p submission failed (%d)", 365 hdev->name, urb, -err); 366 usb_unanchor_urb(urb); 367 } 368 369 usb_free_urb(urb); 370 371 return err; 372 } 373 374 static void btusb_bulk_complete(struct urb *urb) 375 { 376 struct hci_dev *hdev = urb->context; 377 struct btusb_data *data = hci_get_drvdata(hdev); 378 int err; 379 380 BT_DBG("%s urb %p status %d count %d", hdev->name, 381 urb, urb->status, urb->actual_length); 382 383 if (!test_bit(HCI_RUNNING, &hdev->flags)) 384 return; 385 386 if (urb->status == 0) { 387 hdev->stat.byte_rx += urb->actual_length; 388 389 if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT, 390 urb->transfer_buffer, 391 urb->actual_length) < 0) { 392 BT_ERR("%s corrupted ACL packet", hdev->name); 393 hdev->stat.err_rx++; 394 } 395 } 396 397 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags)) 398 return; 399 400 usb_anchor_urb(urb, &data->bulk_anchor); 401 usb_mark_last_busy(data->udev); 402 403 err = usb_submit_urb(urb, GFP_ATOMIC); 404 if (err < 0) { 405 /* -EPERM: urb is being killed; 406 * -ENODEV: device got disconnected */ 407 if (err != -EPERM && err != -ENODEV) 408 BT_ERR("%s urb %p failed to resubmit (%d)", 409 hdev->name, urb, -err); 410 usb_unanchor_urb(urb); 411 } 412 } 413 414 static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags) 415 { 416 struct btusb_data *data = hci_get_drvdata(hdev); 417 struct urb *urb; 418 unsigned char *buf; 419 unsigned int pipe; 420 int err, size = HCI_MAX_FRAME_SIZE; 421 422 BT_DBG("%s", hdev->name); 423 424 if (!data->bulk_rx_ep) 425 return -ENODEV; 426 427 urb = usb_alloc_urb(0, mem_flags); 428 if (!urb) 429 return -ENOMEM; 430 431 buf = kmalloc(size, mem_flags); 432 if (!buf) { 433 usb_free_urb(urb); 434 return -ENOMEM; 435 } 436 437 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress); 438 439 usb_fill_bulk_urb(urb, data->udev, pipe, 440 buf, size, btusb_bulk_complete, hdev); 441 442 urb->transfer_flags |= URB_FREE_BUFFER; 443 444 usb_mark_last_busy(data->udev); 445 usb_anchor_urb(urb, &data->bulk_anchor); 446 447 err = usb_submit_urb(urb, mem_flags); 448 if (err < 0) { 449 if (err != -EPERM && err != -ENODEV) 450 BT_ERR("%s urb %p submission failed (%d)", 451 hdev->name, urb, -err); 452 usb_unanchor_urb(urb); 453 } 454 455 usb_free_urb(urb); 456 457 return err; 458 } 459 460 static void btusb_isoc_complete(struct urb *urb) 461 { 462 struct hci_dev *hdev = urb->context; 463 struct btusb_data *data = hci_get_drvdata(hdev); 464 int i, err; 465 466 BT_DBG("%s urb %p status %d count %d", hdev->name, 467 urb, urb->status, urb->actual_length); 468 469 if (!test_bit(HCI_RUNNING, &hdev->flags)) 470 return; 471 472 if (urb->status == 0) { 473 for (i = 0; i < urb->number_of_packets; i++) { 474 unsigned int offset = urb->iso_frame_desc[i].offset; 475 unsigned int length = urb->iso_frame_desc[i].actual_length; 476 477 if (urb->iso_frame_desc[i].status) 478 continue; 479 480 hdev->stat.byte_rx += length; 481 482 if (hci_recv_fragment(hdev, HCI_SCODATA_PKT, 483 urb->transfer_buffer + offset, 484 length) < 0) { 485 BT_ERR("%s corrupted SCO packet", hdev->name); 486 hdev->stat.err_rx++; 487 } 488 } 489 } 490 491 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags)) 492 return; 493 494 usb_anchor_urb(urb, &data->isoc_anchor); 495 496 err = usb_submit_urb(urb, GFP_ATOMIC); 497 if (err < 0) { 498 /* -EPERM: urb is being killed; 499 * -ENODEV: device got disconnected */ 500 if (err != -EPERM && err != -ENODEV) 501 BT_ERR("%s urb %p failed to resubmit (%d)", 502 hdev->name, urb, -err); 503 usb_unanchor_urb(urb); 504 } 505 } 506 507 static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu) 508 { 509 int i, offset = 0; 510 511 BT_DBG("len %d mtu %d", len, mtu); 512 513 for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu; 514 i++, offset += mtu, len -= mtu) { 515 urb->iso_frame_desc[i].offset = offset; 516 urb->iso_frame_desc[i].length = mtu; 517 } 518 519 if (len && i < BTUSB_MAX_ISOC_FRAMES) { 520 urb->iso_frame_desc[i].offset = offset; 521 urb->iso_frame_desc[i].length = len; 522 i++; 523 } 524 525 urb->number_of_packets = i; 526 } 527 528 static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags) 529 { 530 struct btusb_data *data = hci_get_drvdata(hdev); 531 struct urb *urb; 532 unsigned char *buf; 533 unsigned int pipe; 534 int err, size; 535 536 BT_DBG("%s", hdev->name); 537 538 if (!data->isoc_rx_ep) 539 return -ENODEV; 540 541 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags); 542 if (!urb) 543 return -ENOMEM; 544 545 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) * 546 BTUSB_MAX_ISOC_FRAMES; 547 548 buf = kmalloc(size, mem_flags); 549 if (!buf) { 550 usb_free_urb(urb); 551 return -ENOMEM; 552 } 553 554 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress); 555 556 usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete, 557 hdev, data->isoc_rx_ep->bInterval); 558 559 urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP; 560 561 __fill_isoc_descriptor(urb, size, 562 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize)); 563 564 usb_anchor_urb(urb, &data->isoc_anchor); 565 566 err = usb_submit_urb(urb, mem_flags); 567 if (err < 0) { 568 if (err != -EPERM && err != -ENODEV) 569 BT_ERR("%s urb %p submission failed (%d)", 570 hdev->name, urb, -err); 571 usb_unanchor_urb(urb); 572 } 573 574 usb_free_urb(urb); 575 576 return err; 577 } 578 579 static void btusb_tx_complete(struct urb *urb) 580 { 581 struct sk_buff *skb = urb->context; 582 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 583 struct btusb_data *data = hci_get_drvdata(hdev); 584 585 BT_DBG("%s urb %p status %d count %d", hdev->name, 586 urb, urb->status, urb->actual_length); 587 588 if (!test_bit(HCI_RUNNING, &hdev->flags)) 589 goto done; 590 591 if (!urb->status) 592 hdev->stat.byte_tx += urb->transfer_buffer_length; 593 else 594 hdev->stat.err_tx++; 595 596 done: 597 spin_lock(&data->txlock); 598 data->tx_in_flight--; 599 spin_unlock(&data->txlock); 600 601 kfree(urb->setup_packet); 602 603 kfree_skb(skb); 604 } 605 606 static void btusb_isoc_tx_complete(struct urb *urb) 607 { 608 struct sk_buff *skb = urb->context; 609 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 610 611 BT_DBG("%s urb %p status %d count %d", hdev->name, 612 urb, urb->status, urb->actual_length); 613 614 if (!test_bit(HCI_RUNNING, &hdev->flags)) 615 goto done; 616 617 if (!urb->status) 618 hdev->stat.byte_tx += urb->transfer_buffer_length; 619 else 620 hdev->stat.err_tx++; 621 622 done: 623 kfree(urb->setup_packet); 624 625 kfree_skb(skb); 626 } 627 628 static int btusb_open(struct hci_dev *hdev) 629 { 630 struct btusb_data *data = hci_get_drvdata(hdev); 631 int err; 632 633 BT_DBG("%s", hdev->name); 634 635 err = usb_autopm_get_interface(data->intf); 636 if (err < 0) 637 return err; 638 639 data->intf->needs_remote_wakeup = 1; 640 641 if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) 642 goto done; 643 644 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags)) 645 goto done; 646 647 err = btusb_submit_intr_urb(hdev, GFP_KERNEL); 648 if (err < 0) 649 goto failed; 650 651 err = btusb_submit_bulk_urb(hdev, GFP_KERNEL); 652 if (err < 0) { 653 usb_kill_anchored_urbs(&data->intr_anchor); 654 goto failed; 655 } 656 657 set_bit(BTUSB_BULK_RUNNING, &data->flags); 658 btusb_submit_bulk_urb(hdev, GFP_KERNEL); 659 660 done: 661 usb_autopm_put_interface(data->intf); 662 return 0; 663 664 failed: 665 clear_bit(BTUSB_INTR_RUNNING, &data->flags); 666 clear_bit(HCI_RUNNING, &hdev->flags); 667 usb_autopm_put_interface(data->intf); 668 return err; 669 } 670 671 static void btusb_stop_traffic(struct btusb_data *data) 672 { 673 usb_kill_anchored_urbs(&data->intr_anchor); 674 usb_kill_anchored_urbs(&data->bulk_anchor); 675 usb_kill_anchored_urbs(&data->isoc_anchor); 676 } 677 678 static int btusb_close(struct hci_dev *hdev) 679 { 680 struct btusb_data *data = hci_get_drvdata(hdev); 681 int err; 682 683 BT_DBG("%s", hdev->name); 684 685 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 686 return 0; 687 688 cancel_work_sync(&data->work); 689 cancel_work_sync(&data->waker); 690 691 clear_bit(BTUSB_ISOC_RUNNING, &data->flags); 692 clear_bit(BTUSB_BULK_RUNNING, &data->flags); 693 clear_bit(BTUSB_INTR_RUNNING, &data->flags); 694 695 btusb_stop_traffic(data); 696 err = usb_autopm_get_interface(data->intf); 697 if (err < 0) 698 goto failed; 699 700 data->intf->needs_remote_wakeup = 0; 701 usb_autopm_put_interface(data->intf); 702 703 failed: 704 usb_scuttle_anchored_urbs(&data->deferred); 705 return 0; 706 } 707 708 static int btusb_flush(struct hci_dev *hdev) 709 { 710 struct btusb_data *data = hci_get_drvdata(hdev); 711 712 BT_DBG("%s", hdev->name); 713 714 usb_kill_anchored_urbs(&data->tx_anchor); 715 716 return 0; 717 } 718 719 static int btusb_send_frame(struct sk_buff *skb) 720 { 721 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 722 struct btusb_data *data = hci_get_drvdata(hdev); 723 struct usb_ctrlrequest *dr; 724 struct urb *urb; 725 unsigned int pipe; 726 int err; 727 728 BT_DBG("%s", hdev->name); 729 730 if (!test_bit(HCI_RUNNING, &hdev->flags)) 731 return -EBUSY; 732 733 switch (bt_cb(skb)->pkt_type) { 734 case HCI_COMMAND_PKT: 735 urb = usb_alloc_urb(0, GFP_ATOMIC); 736 if (!urb) 737 return -ENOMEM; 738 739 dr = kmalloc(sizeof(*dr), GFP_ATOMIC); 740 if (!dr) { 741 usb_free_urb(urb); 742 return -ENOMEM; 743 } 744 745 dr->bRequestType = data->cmdreq_type; 746 dr->bRequest = 0; 747 dr->wIndex = 0; 748 dr->wValue = 0; 749 dr->wLength = __cpu_to_le16(skb->len); 750 751 pipe = usb_sndctrlpipe(data->udev, 0x00); 752 753 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr, 754 skb->data, skb->len, btusb_tx_complete, skb); 755 756 hdev->stat.cmd_tx++; 757 break; 758 759 case HCI_ACLDATA_PKT: 760 if (!data->bulk_tx_ep) 761 return -ENODEV; 762 763 urb = usb_alloc_urb(0, GFP_ATOMIC); 764 if (!urb) 765 return -ENOMEM; 766 767 pipe = usb_sndbulkpipe(data->udev, 768 data->bulk_tx_ep->bEndpointAddress); 769 770 usb_fill_bulk_urb(urb, data->udev, pipe, 771 skb->data, skb->len, btusb_tx_complete, skb); 772 773 hdev->stat.acl_tx++; 774 break; 775 776 case HCI_SCODATA_PKT: 777 if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1) 778 return -ENODEV; 779 780 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC); 781 if (!urb) 782 return -ENOMEM; 783 784 pipe = usb_sndisocpipe(data->udev, 785 data->isoc_tx_ep->bEndpointAddress); 786 787 usb_fill_int_urb(urb, data->udev, pipe, 788 skb->data, skb->len, btusb_isoc_tx_complete, 789 skb, data->isoc_tx_ep->bInterval); 790 791 urb->transfer_flags = URB_ISO_ASAP; 792 793 __fill_isoc_descriptor(urb, skb->len, 794 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize)); 795 796 hdev->stat.sco_tx++; 797 goto skip_waking; 798 799 default: 800 return -EILSEQ; 801 } 802 803 err = inc_tx(data); 804 if (err) { 805 usb_anchor_urb(urb, &data->deferred); 806 schedule_work(&data->waker); 807 err = 0; 808 goto done; 809 } 810 811 skip_waking: 812 usb_anchor_urb(urb, &data->tx_anchor); 813 814 err = usb_submit_urb(urb, GFP_ATOMIC); 815 if (err < 0) { 816 if (err != -EPERM && err != -ENODEV) 817 BT_ERR("%s urb %p submission failed (%d)", 818 hdev->name, urb, -err); 819 kfree(urb->setup_packet); 820 usb_unanchor_urb(urb); 821 } else { 822 usb_mark_last_busy(data->udev); 823 } 824 825 done: 826 usb_free_urb(urb); 827 return err; 828 } 829 830 static void btusb_notify(struct hci_dev *hdev, unsigned int evt) 831 { 832 struct btusb_data *data = hci_get_drvdata(hdev); 833 834 BT_DBG("%s evt %d", hdev->name, evt); 835 836 if (hdev->conn_hash.sco_num != data->sco_num) { 837 data->sco_num = hdev->conn_hash.sco_num; 838 schedule_work(&data->work); 839 } 840 } 841 842 static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting) 843 { 844 struct btusb_data *data = hci_get_drvdata(hdev); 845 struct usb_interface *intf = data->isoc; 846 struct usb_endpoint_descriptor *ep_desc; 847 int i, err; 848 849 if (!data->isoc) 850 return -ENODEV; 851 852 err = usb_set_interface(data->udev, 1, altsetting); 853 if (err < 0) { 854 BT_ERR("%s setting interface failed (%d)", hdev->name, -err); 855 return err; 856 } 857 858 data->isoc_altsetting = altsetting; 859 860 data->isoc_tx_ep = NULL; 861 data->isoc_rx_ep = NULL; 862 863 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { 864 ep_desc = &intf->cur_altsetting->endpoint[i].desc; 865 866 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) { 867 data->isoc_tx_ep = ep_desc; 868 continue; 869 } 870 871 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) { 872 data->isoc_rx_ep = ep_desc; 873 continue; 874 } 875 } 876 877 if (!data->isoc_tx_ep || !data->isoc_rx_ep) { 878 BT_ERR("%s invalid SCO descriptors", hdev->name); 879 return -ENODEV; 880 } 881 882 return 0; 883 } 884 885 static void btusb_work(struct work_struct *work) 886 { 887 struct btusb_data *data = container_of(work, struct btusb_data, work); 888 struct hci_dev *hdev = data->hdev; 889 int new_alts; 890 int err; 891 892 if (hdev->conn_hash.sco_num > 0) { 893 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) { 894 err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf); 895 if (err < 0) { 896 clear_bit(BTUSB_ISOC_RUNNING, &data->flags); 897 usb_kill_anchored_urbs(&data->isoc_anchor); 898 return; 899 } 900 901 set_bit(BTUSB_DID_ISO_RESUME, &data->flags); 902 } 903 904 if (hdev->voice_setting & 0x0020) { 905 static const int alts[3] = { 2, 4, 5 }; 906 new_alts = alts[hdev->conn_hash.sco_num - 1]; 907 } else { 908 new_alts = hdev->conn_hash.sco_num; 909 } 910 911 if (data->isoc_altsetting != new_alts) { 912 clear_bit(BTUSB_ISOC_RUNNING, &data->flags); 913 usb_kill_anchored_urbs(&data->isoc_anchor); 914 915 if (__set_isoc_interface(hdev, new_alts) < 0) 916 return; 917 } 918 919 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) { 920 if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0) 921 clear_bit(BTUSB_ISOC_RUNNING, &data->flags); 922 else 923 btusb_submit_isoc_urb(hdev, GFP_KERNEL); 924 } 925 } else { 926 clear_bit(BTUSB_ISOC_RUNNING, &data->flags); 927 usb_kill_anchored_urbs(&data->isoc_anchor); 928 929 __set_isoc_interface(hdev, 0); 930 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags)) 931 usb_autopm_put_interface(data->isoc ? data->isoc : data->intf); 932 } 933 } 934 935 static void btusb_waker(struct work_struct *work) 936 { 937 struct btusb_data *data = container_of(work, struct btusb_data, waker); 938 int err; 939 940 err = usb_autopm_get_interface(data->intf); 941 if (err < 0) 942 return; 943 944 usb_autopm_put_interface(data->intf); 945 } 946 947 static int btusb_setup_bcm92035(struct hci_dev *hdev) 948 { 949 struct sk_buff *skb; 950 u8 val = 0x00; 951 952 BT_DBG("%s", hdev->name); 953 954 skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT); 955 if (IS_ERR(skb)) 956 BT_ERR("BCM92035 command failed (%ld)", -PTR_ERR(skb)); 957 else 958 kfree_skb(skb); 959 960 return 0; 961 } 962 963 struct intel_version { 964 u8 status; 965 u8 hw_platform; 966 u8 hw_variant; 967 u8 hw_revision; 968 u8 fw_variant; 969 u8 fw_revision; 970 u8 fw_build_num; 971 u8 fw_build_ww; 972 u8 fw_build_yy; 973 u8 fw_patch_num; 974 } __packed; 975 976 static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev, 977 struct intel_version *ver) 978 { 979 const struct firmware *fw; 980 char fwname[64]; 981 int ret; 982 983 snprintf(fwname, sizeof(fwname), 984 "intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq", 985 ver->hw_platform, ver->hw_variant, ver->hw_revision, 986 ver->fw_variant, ver->fw_revision, ver->fw_build_num, 987 ver->fw_build_ww, ver->fw_build_yy); 988 989 ret = request_firmware(&fw, fwname, &hdev->dev); 990 if (ret < 0) { 991 if (ret == -EINVAL) { 992 BT_ERR("%s Intel firmware file request failed (%d)", 993 hdev->name, ret); 994 return NULL; 995 } 996 997 BT_ERR("%s failed to open Intel firmware file: %s(%d)", 998 hdev->name, fwname, ret); 999 1000 /* If the correct firmware patch file is not found, use the 1001 * default firmware patch file instead 1002 */ 1003 snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq", 1004 ver->hw_platform, ver->hw_variant); 1005 if (request_firmware(&fw, fwname, &hdev->dev) < 0) { 1006 BT_ERR("%s failed to open default Intel fw file: %s", 1007 hdev->name, fwname); 1008 return NULL; 1009 } 1010 } 1011 1012 BT_INFO("%s: Intel Bluetooth firmware file: %s", hdev->name, fwname); 1013 1014 return fw; 1015 } 1016 1017 static int btusb_setup_intel_patching(struct hci_dev *hdev, 1018 const struct firmware *fw, 1019 const u8 **fw_ptr, int *disable_patch) 1020 { 1021 struct sk_buff *skb; 1022 struct hci_command_hdr *cmd; 1023 const u8 *cmd_param; 1024 struct hci_event_hdr *evt = NULL; 1025 const u8 *evt_param = NULL; 1026 int remain = fw->size - (*fw_ptr - fw->data); 1027 1028 /* The first byte indicates the types of the patch command or event. 1029 * 0x01 means HCI command and 0x02 is HCI event. If the first bytes 1030 * in the current firmware buffer doesn't start with 0x01 or 1031 * the size of remain buffer is smaller than HCI command header, 1032 * the firmware file is corrupted and it should stop the patching 1033 * process. 1034 */ 1035 if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) { 1036 BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name); 1037 return -EINVAL; 1038 } 1039 (*fw_ptr)++; 1040 remain--; 1041 1042 cmd = (struct hci_command_hdr *)(*fw_ptr); 1043 *fw_ptr += sizeof(*cmd); 1044 remain -= sizeof(*cmd); 1045 1046 /* Ensure that the remain firmware data is long enough than the length 1047 * of command parameter. If not, the firmware file is corrupted. 1048 */ 1049 if (remain < cmd->plen) { 1050 BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name); 1051 return -EFAULT; 1052 } 1053 1054 /* If there is a command that loads a patch in the firmware 1055 * file, then enable the patch upon success, otherwise just 1056 * disable the manufacturer mode, for example patch activation 1057 * is not required when the default firmware patch file is used 1058 * because there are no patch data to load. 1059 */ 1060 if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e) 1061 *disable_patch = 0; 1062 1063 cmd_param = *fw_ptr; 1064 *fw_ptr += cmd->plen; 1065 remain -= cmd->plen; 1066 1067 /* This reads the expected events when the above command is sent to the 1068 * device. Some vendor commands expects more than one events, for 1069 * example command status event followed by vendor specific event. 1070 * For this case, it only keeps the last expected event. so the command 1071 * can be sent with __hci_cmd_sync_ev() which returns the sk_buff of 1072 * last expected event. 1073 */ 1074 while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) { 1075 (*fw_ptr)++; 1076 remain--; 1077 1078 evt = (struct hci_event_hdr *)(*fw_ptr); 1079 *fw_ptr += sizeof(*evt); 1080 remain -= sizeof(*evt); 1081 1082 if (remain < evt->plen) { 1083 BT_ERR("%s Intel fw corrupted: invalid evt len", 1084 hdev->name); 1085 return -EFAULT; 1086 } 1087 1088 evt_param = *fw_ptr; 1089 *fw_ptr += evt->plen; 1090 remain -= evt->plen; 1091 } 1092 1093 /* Every HCI commands in the firmware file has its correspond event. 1094 * If event is not found or remain is smaller than zero, the firmware 1095 * file is corrupted. 1096 */ 1097 if (!evt || !evt_param || remain < 0) { 1098 BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name); 1099 return -EFAULT; 1100 } 1101 1102 skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen, 1103 cmd_param, evt->evt, HCI_INIT_TIMEOUT); 1104 if (IS_ERR(skb)) { 1105 BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)", 1106 hdev->name, cmd->opcode, PTR_ERR(skb)); 1107 return PTR_ERR(skb); 1108 } 1109 1110 /* It ensures that the returned event matches the event data read from 1111 * the firmware file. At fist, it checks the length and then 1112 * the contents of the event. 1113 */ 1114 if (skb->len != evt->plen) { 1115 BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name, 1116 le16_to_cpu(cmd->opcode)); 1117 kfree_skb(skb); 1118 return -EFAULT; 1119 } 1120 1121 if (memcmp(skb->data, evt_param, evt->plen)) { 1122 BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)", 1123 hdev->name, le16_to_cpu(cmd->opcode)); 1124 kfree_skb(skb); 1125 return -EFAULT; 1126 } 1127 kfree_skb(skb); 1128 1129 return 0; 1130 } 1131 1132 static int btusb_setup_intel(struct hci_dev *hdev) 1133 { 1134 struct sk_buff *skb; 1135 const struct firmware *fw; 1136 const u8 *fw_ptr; 1137 int disable_patch; 1138 struct intel_version *ver; 1139 1140 const u8 mfg_enable[] = { 0x01, 0x00 }; 1141 const u8 mfg_disable[] = { 0x00, 0x00 }; 1142 const u8 mfg_reset_deactivate[] = { 0x00, 0x01 }; 1143 const u8 mfg_reset_activate[] = { 0x00, 0x02 }; 1144 1145 BT_DBG("%s", hdev->name); 1146 1147 /* The controller has a bug with the first HCI command sent to it 1148 * returning number of completed commands as zero. This would stall the 1149 * command processing in the Bluetooth core. 1150 * 1151 * As a workaround, send HCI Reset command first which will reset the 1152 * number of completed commands and allow normal command processing 1153 * from now on. 1154 */ 1155 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT); 1156 if (IS_ERR(skb)) { 1157 BT_ERR("%s sending initial HCI reset command failed (%ld)", 1158 hdev->name, PTR_ERR(skb)); 1159 return PTR_ERR(skb); 1160 } 1161 kfree_skb(skb); 1162 1163 /* Read Intel specific controller version first to allow selection of 1164 * which firmware file to load. 1165 * 1166 * The returned information are hardware variant and revision plus 1167 * firmware variant, revision and build number. 1168 */ 1169 skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT); 1170 if (IS_ERR(skb)) { 1171 BT_ERR("%s reading Intel fw version command failed (%ld)", 1172 hdev->name, PTR_ERR(skb)); 1173 return PTR_ERR(skb); 1174 } 1175 1176 if (skb->len != sizeof(*ver)) { 1177 BT_ERR("%s Intel version event length mismatch", hdev->name); 1178 kfree_skb(skb); 1179 return -EIO; 1180 } 1181 1182 ver = (struct intel_version *)skb->data; 1183 if (ver->status) { 1184 BT_ERR("%s Intel fw version event failed (%02x)", hdev->name, 1185 ver->status); 1186 kfree_skb(skb); 1187 return -bt_to_errno(ver->status); 1188 } 1189 1190 BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x", 1191 hdev->name, ver->hw_platform, ver->hw_variant, 1192 ver->hw_revision, ver->fw_variant, ver->fw_revision, 1193 ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy, 1194 ver->fw_patch_num); 1195 1196 /* fw_patch_num indicates the version of patch the device currently 1197 * have. If there is no patch data in the device, it is always 0x00. 1198 * So, if it is other than 0x00, no need to patch the deivce again. 1199 */ 1200 if (ver->fw_patch_num) { 1201 BT_INFO("%s: Intel device is already patched. patch num: %02x", 1202 hdev->name, ver->fw_patch_num); 1203 kfree_skb(skb); 1204 return 0; 1205 } 1206 1207 /* Opens the firmware patch file based on the firmware version read 1208 * from the controller. If it fails to open the matching firmware 1209 * patch file, it tries to open the default firmware patch file. 1210 * If no patch file is found, allow the device to operate without 1211 * a patch. 1212 */ 1213 fw = btusb_setup_intel_get_fw(hdev, ver); 1214 if (!fw) { 1215 kfree_skb(skb); 1216 return 0; 1217 } 1218 fw_ptr = fw->data; 1219 1220 /* This Intel specific command enables the manufacturer mode of the 1221 * controller. 1222 * 1223 * Only while this mode is enabled, the driver can download the 1224 * firmware patch data and configuration parameters. 1225 */ 1226 skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT); 1227 if (IS_ERR(skb)) { 1228 BT_ERR("%s entering Intel manufacturer mode failed (%ld)", 1229 hdev->name, PTR_ERR(skb)); 1230 release_firmware(fw); 1231 return PTR_ERR(skb); 1232 } 1233 1234 if (skb->data[0]) { 1235 u8 evt_status = skb->data[0]; 1236 BT_ERR("%s enable Intel manufacturer mode event failed (%02x)", 1237 hdev->name, evt_status); 1238 kfree_skb(skb); 1239 release_firmware(fw); 1240 return -bt_to_errno(evt_status); 1241 } 1242 kfree_skb(skb); 1243 1244 disable_patch = 1; 1245 1246 /* The firmware data file consists of list of Intel specific HCI 1247 * commands and its expected events. The first byte indicates the 1248 * type of the message, either HCI command or HCI event. 1249 * 1250 * It reads the command and its expected event from the firmware file, 1251 * and send to the controller. Once __hci_cmd_sync_ev() returns, 1252 * the returned event is compared with the event read from the firmware 1253 * file and it will continue until all the messages are downloaded to 1254 * the controller. 1255 * 1256 * Once the firmware patching is completed successfully, 1257 * the manufacturer mode is disabled with reset and activating the 1258 * downloaded patch. 1259 * 1260 * If the firmware patching fails, the manufacturer mode is 1261 * disabled with reset and deactivating the patch. 1262 * 1263 * If the default patch file is used, no reset is done when disabling 1264 * the manufacturer. 1265 */ 1266 while (fw->size > fw_ptr - fw->data) { 1267 int ret; 1268 1269 ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr, 1270 &disable_patch); 1271 if (ret < 0) 1272 goto exit_mfg_deactivate; 1273 } 1274 1275 release_firmware(fw); 1276 1277 if (disable_patch) 1278 goto exit_mfg_disable; 1279 1280 /* Patching completed successfully and disable the manufacturer mode 1281 * with reset and activate the downloaded firmware patches. 1282 */ 1283 skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_activate), 1284 mfg_reset_activate, HCI_INIT_TIMEOUT); 1285 if (IS_ERR(skb)) { 1286 BT_ERR("%s exiting Intel manufacturer mode failed (%ld)", 1287 hdev->name, PTR_ERR(skb)); 1288 return PTR_ERR(skb); 1289 } 1290 kfree_skb(skb); 1291 1292 BT_INFO("%s: Intel Bluetooth firmware patch completed and activated", 1293 hdev->name); 1294 1295 return 0; 1296 1297 exit_mfg_disable: 1298 /* Disable the manufacturer mode without reset */ 1299 skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_disable), mfg_disable, 1300 HCI_INIT_TIMEOUT); 1301 if (IS_ERR(skb)) { 1302 BT_ERR("%s exiting Intel manufacturer mode failed (%ld)", 1303 hdev->name, PTR_ERR(skb)); 1304 return PTR_ERR(skb); 1305 } 1306 kfree_skb(skb); 1307 1308 BT_INFO("%s: Intel Bluetooth firmware patch completed", hdev->name); 1309 return 0; 1310 1311 exit_mfg_deactivate: 1312 release_firmware(fw); 1313 1314 /* Patching failed. Disable the manufacturer mode with reset and 1315 * deactivate the downloaded firmware patches. 1316 */ 1317 skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_deactivate), 1318 mfg_reset_deactivate, HCI_INIT_TIMEOUT); 1319 if (IS_ERR(skb)) { 1320 BT_ERR("%s exiting Intel manufacturer mode failed (%ld)", 1321 hdev->name, PTR_ERR(skb)); 1322 return PTR_ERR(skb); 1323 } 1324 kfree_skb(skb); 1325 1326 BT_INFO("%s: Intel Bluetooth firmware patch completed and deactivated", 1327 hdev->name); 1328 1329 return 0; 1330 } 1331 1332 static int btusb_probe(struct usb_interface *intf, 1333 const struct usb_device_id *id) 1334 { 1335 struct usb_endpoint_descriptor *ep_desc; 1336 struct btusb_data *data; 1337 struct hci_dev *hdev; 1338 int i, err; 1339 1340 BT_DBG("intf %p id %p", intf, id); 1341 1342 /* interface numbers are hardcoded in the spec */ 1343 if (intf->cur_altsetting->desc.bInterfaceNumber != 0) 1344 return -ENODEV; 1345 1346 if (!id->driver_info) { 1347 const struct usb_device_id *match; 1348 match = usb_match_id(intf, blacklist_table); 1349 if (match) 1350 id = match; 1351 } 1352 1353 if (id->driver_info == BTUSB_IGNORE) 1354 return -ENODEV; 1355 1356 if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER) 1357 return -ENODEV; 1358 1359 if (ignore_csr && id->driver_info & BTUSB_CSR) 1360 return -ENODEV; 1361 1362 if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER) 1363 return -ENODEV; 1364 1365 if (id->driver_info & BTUSB_ATH3012) { 1366 struct usb_device *udev = interface_to_usbdev(intf); 1367 1368 /* Old firmware would otherwise let ath3k driver load 1369 * patch and sysconfig files */ 1370 if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001) 1371 return -ENODEV; 1372 } 1373 1374 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL); 1375 if (!data) 1376 return -ENOMEM; 1377 1378 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { 1379 ep_desc = &intf->cur_altsetting->endpoint[i].desc; 1380 1381 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) { 1382 data->intr_ep = ep_desc; 1383 continue; 1384 } 1385 1386 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) { 1387 data->bulk_tx_ep = ep_desc; 1388 continue; 1389 } 1390 1391 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) { 1392 data->bulk_rx_ep = ep_desc; 1393 continue; 1394 } 1395 } 1396 1397 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) 1398 return -ENODEV; 1399 1400 data->cmdreq_type = USB_TYPE_CLASS; 1401 1402 data->udev = interface_to_usbdev(intf); 1403 data->intf = intf; 1404 1405 spin_lock_init(&data->lock); 1406 1407 INIT_WORK(&data->work, btusb_work); 1408 INIT_WORK(&data->waker, btusb_waker); 1409 spin_lock_init(&data->txlock); 1410 1411 init_usb_anchor(&data->tx_anchor); 1412 init_usb_anchor(&data->intr_anchor); 1413 init_usb_anchor(&data->bulk_anchor); 1414 init_usb_anchor(&data->isoc_anchor); 1415 init_usb_anchor(&data->deferred); 1416 1417 hdev = hci_alloc_dev(); 1418 if (!hdev) 1419 return -ENOMEM; 1420 1421 hdev->bus = HCI_USB; 1422 hci_set_drvdata(hdev, data); 1423 1424 data->hdev = hdev; 1425 1426 SET_HCIDEV_DEV(hdev, &intf->dev); 1427 1428 hdev->open = btusb_open; 1429 hdev->close = btusb_close; 1430 hdev->flush = btusb_flush; 1431 hdev->send = btusb_send_frame; 1432 hdev->notify = btusb_notify; 1433 1434 if (id->driver_info & BTUSB_BCM92035) 1435 hdev->setup = btusb_setup_bcm92035; 1436 1437 if (id->driver_info & BTUSB_INTEL) 1438 hdev->setup = btusb_setup_intel; 1439 1440 /* Interface numbers are hardcoded in the specification */ 1441 data->isoc = usb_ifnum_to_if(data->udev, 1); 1442 1443 if (!reset) 1444 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); 1445 1446 if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) { 1447 if (!disable_scofix) 1448 set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks); 1449 } 1450 1451 if (id->driver_info & BTUSB_BROKEN_ISOC) 1452 data->isoc = NULL; 1453 1454 if (id->driver_info & BTUSB_DIGIANSWER) { 1455 data->cmdreq_type = USB_TYPE_VENDOR; 1456 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); 1457 } 1458 1459 if (id->driver_info & BTUSB_CSR) { 1460 struct usb_device *udev = data->udev; 1461 1462 /* Old firmware would otherwise execute USB reset */ 1463 if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117) 1464 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); 1465 } 1466 1467 if (id->driver_info & BTUSB_SNIFFER) { 1468 struct usb_device *udev = data->udev; 1469 1470 /* New sniffer firmware has crippled HCI interface */ 1471 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997) 1472 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); 1473 1474 data->isoc = NULL; 1475 } 1476 1477 if (data->isoc) { 1478 err = usb_driver_claim_interface(&btusb_driver, 1479 data->isoc, data); 1480 if (err < 0) { 1481 hci_free_dev(hdev); 1482 return err; 1483 } 1484 } 1485 1486 err = hci_register_dev(hdev); 1487 if (err < 0) { 1488 hci_free_dev(hdev); 1489 return err; 1490 } 1491 1492 usb_set_intfdata(intf, data); 1493 1494 return 0; 1495 } 1496 1497 static void btusb_disconnect(struct usb_interface *intf) 1498 { 1499 struct btusb_data *data = usb_get_intfdata(intf); 1500 struct hci_dev *hdev; 1501 1502 BT_DBG("intf %p", intf); 1503 1504 if (!data) 1505 return; 1506 1507 hdev = data->hdev; 1508 usb_set_intfdata(data->intf, NULL); 1509 1510 if (data->isoc) 1511 usb_set_intfdata(data->isoc, NULL); 1512 1513 hci_unregister_dev(hdev); 1514 1515 if (intf == data->isoc) 1516 usb_driver_release_interface(&btusb_driver, data->intf); 1517 else if (data->isoc) 1518 usb_driver_release_interface(&btusb_driver, data->isoc); 1519 1520 hci_free_dev(hdev); 1521 } 1522 1523 #ifdef CONFIG_PM 1524 static int btusb_suspend(struct usb_interface *intf, pm_message_t message) 1525 { 1526 struct btusb_data *data = usb_get_intfdata(intf); 1527 1528 BT_DBG("intf %p", intf); 1529 1530 if (data->suspend_count++) 1531 return 0; 1532 1533 spin_lock_irq(&data->txlock); 1534 if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) { 1535 set_bit(BTUSB_SUSPENDING, &data->flags); 1536 spin_unlock_irq(&data->txlock); 1537 } else { 1538 spin_unlock_irq(&data->txlock); 1539 data->suspend_count--; 1540 return -EBUSY; 1541 } 1542 1543 cancel_work_sync(&data->work); 1544 1545 btusb_stop_traffic(data); 1546 usb_kill_anchored_urbs(&data->tx_anchor); 1547 1548 return 0; 1549 } 1550 1551 static void play_deferred(struct btusb_data *data) 1552 { 1553 struct urb *urb; 1554 int err; 1555 1556 while ((urb = usb_get_from_anchor(&data->deferred))) { 1557 err = usb_submit_urb(urb, GFP_ATOMIC); 1558 if (err < 0) 1559 break; 1560 1561 data->tx_in_flight++; 1562 } 1563 usb_scuttle_anchored_urbs(&data->deferred); 1564 } 1565 1566 static int btusb_resume(struct usb_interface *intf) 1567 { 1568 struct btusb_data *data = usb_get_intfdata(intf); 1569 struct hci_dev *hdev = data->hdev; 1570 int err = 0; 1571 1572 BT_DBG("intf %p", intf); 1573 1574 if (--data->suspend_count) 1575 return 0; 1576 1577 if (!test_bit(HCI_RUNNING, &hdev->flags)) 1578 goto done; 1579 1580 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) { 1581 err = btusb_submit_intr_urb(hdev, GFP_NOIO); 1582 if (err < 0) { 1583 clear_bit(BTUSB_INTR_RUNNING, &data->flags); 1584 goto failed; 1585 } 1586 } 1587 1588 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) { 1589 err = btusb_submit_bulk_urb(hdev, GFP_NOIO); 1590 if (err < 0) { 1591 clear_bit(BTUSB_BULK_RUNNING, &data->flags); 1592 goto failed; 1593 } 1594 1595 btusb_submit_bulk_urb(hdev, GFP_NOIO); 1596 } 1597 1598 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) { 1599 if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0) 1600 clear_bit(BTUSB_ISOC_RUNNING, &data->flags); 1601 else 1602 btusb_submit_isoc_urb(hdev, GFP_NOIO); 1603 } 1604 1605 spin_lock_irq(&data->txlock); 1606 play_deferred(data); 1607 clear_bit(BTUSB_SUSPENDING, &data->flags); 1608 spin_unlock_irq(&data->txlock); 1609 schedule_work(&data->work); 1610 1611 return 0; 1612 1613 failed: 1614 usb_scuttle_anchored_urbs(&data->deferred); 1615 done: 1616 spin_lock_irq(&data->txlock); 1617 clear_bit(BTUSB_SUSPENDING, &data->flags); 1618 spin_unlock_irq(&data->txlock); 1619 1620 return err; 1621 } 1622 #endif 1623 1624 static struct usb_driver btusb_driver = { 1625 .name = "btusb", 1626 .probe = btusb_probe, 1627 .disconnect = btusb_disconnect, 1628 #ifdef CONFIG_PM 1629 .suspend = btusb_suspend, 1630 .resume = btusb_resume, 1631 .reset_resume = btusb_resume, 1632 #endif 1633 .id_table = btusb_table, 1634 .supports_autosuspend = 1, 1635 .disable_hub_initiated_lpm = 1, 1636 }; 1637 1638 module_usb_driver(btusb_driver); 1639 1640 module_param(ignore_dga, bool, 0644); 1641 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001"); 1642 1643 module_param(ignore_csr, bool, 0644); 1644 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001"); 1645 1646 module_param(ignore_sniffer, bool, 0644); 1647 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002"); 1648 1649 module_param(disable_scofix, bool, 0644); 1650 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size"); 1651 1652 module_param(force_scofix, bool, 0644); 1653 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size"); 1654 1655 module_param(reset, bool, 0644); 1656 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization"); 1657 1658 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 1659 MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION); 1660 MODULE_VERSION(VERSION); 1661 MODULE_LICENSE("GPL"); 1662