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