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