1 /* 2 * 3 * Generic Bluetooth USB driver 4 * 5 * Copyright (C) 2005-2007 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/kernel.h> 25 #include <linux/module.h> 26 #include <linux/init.h> 27 #include <linux/slab.h> 28 #include <linux/types.h> 29 #include <linux/sched.h> 30 #include <linux/errno.h> 31 #include <linux/skbuff.h> 32 33 #include <linux/usb.h> 34 35 #include <net/bluetooth/bluetooth.h> 36 #include <net/bluetooth/hci_core.h> 37 38 //#define CONFIG_BT_HCIBTUSB_DEBUG 39 #ifndef CONFIG_BT_HCIBTUSB_DEBUG 40 #undef BT_DBG 41 #define BT_DBG(D...) 42 #endif 43 44 #define VERSION "0.1" 45 46 static struct usb_device_id btusb_table[] = { 47 /* Generic Bluetooth USB device */ 48 { USB_DEVICE_INFO(0xe0, 0x01, 0x01) }, 49 50 { } /* Terminating entry */ 51 }; 52 53 MODULE_DEVICE_TABLE(usb, btusb_table); 54 55 static struct usb_device_id blacklist_table[] = { 56 { } /* Terminating entry */ 57 }; 58 59 #define BTUSB_INTR_RUNNING 0 60 #define BTUSB_BULK_RUNNING 1 61 62 struct btusb_data { 63 struct hci_dev *hdev; 64 struct usb_device *udev; 65 66 spinlock_t lock; 67 68 unsigned long flags; 69 70 struct work_struct work; 71 72 struct usb_anchor tx_anchor; 73 struct usb_anchor intr_anchor; 74 struct usb_anchor bulk_anchor; 75 76 struct usb_endpoint_descriptor *intr_ep; 77 struct usb_endpoint_descriptor *bulk_tx_ep; 78 struct usb_endpoint_descriptor *bulk_rx_ep; 79 }; 80 81 static void btusb_intr_complete(struct urb *urb) 82 { 83 struct hci_dev *hdev = urb->context; 84 struct btusb_data *data = hdev->driver_data; 85 int err; 86 87 BT_DBG("%s urb %p status %d count %d", hdev->name, 88 urb, urb->status, urb->actual_length); 89 90 if (!test_bit(HCI_RUNNING, &hdev->flags)) 91 return; 92 93 if (urb->status == 0) { 94 if (hci_recv_fragment(hdev, HCI_EVENT_PKT, 95 urb->transfer_buffer, 96 urb->actual_length) < 0) { 97 BT_ERR("%s corrupted event packet", hdev->name); 98 hdev->stat.err_rx++; 99 } 100 } 101 102 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags)) 103 return; 104 105 usb_anchor_urb(urb, &data->intr_anchor); 106 107 err = usb_submit_urb(urb, GFP_ATOMIC); 108 if (err < 0) { 109 BT_ERR("%s urb %p failed to resubmit (%d)", 110 hdev->name, urb, -err); 111 usb_unanchor_urb(urb); 112 } 113 } 114 115 static inline int btusb_submit_intr_urb(struct hci_dev *hdev) 116 { 117 struct btusb_data *data = hdev->driver_data; 118 struct urb *urb; 119 unsigned char *buf; 120 unsigned int pipe; 121 int err, size; 122 123 BT_DBG("%s", hdev->name); 124 125 urb = usb_alloc_urb(0, GFP_ATOMIC); 126 if (!urb) 127 return -ENOMEM; 128 129 size = le16_to_cpu(data->intr_ep->wMaxPacketSize); 130 131 buf = kmalloc(size, GFP_ATOMIC); 132 if (!buf) { 133 usb_free_urb(urb); 134 return -ENOMEM; 135 } 136 137 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress); 138 139 usb_fill_int_urb(urb, data->udev, pipe, buf, size, 140 btusb_intr_complete, hdev, 141 data->intr_ep->bInterval); 142 143 urb->transfer_flags |= URB_FREE_BUFFER; 144 145 usb_anchor_urb(urb, &data->intr_anchor); 146 147 err = usb_submit_urb(urb, GFP_ATOMIC); 148 if (err < 0) { 149 BT_ERR("%s urb %p submission failed (%d)", 150 hdev->name, urb, -err); 151 usb_unanchor_urb(urb); 152 kfree(buf); 153 } 154 155 usb_free_urb(urb); 156 157 return err; 158 } 159 160 static void btusb_bulk_complete(struct urb *urb) 161 { 162 struct hci_dev *hdev = urb->context; 163 struct btusb_data *data = hdev->driver_data; 164 int err; 165 166 BT_DBG("%s urb %p status %d count %d", hdev->name, 167 urb, urb->status, urb->actual_length); 168 169 if (!test_bit(HCI_RUNNING, &hdev->flags)) 170 return; 171 172 if (urb->status == 0) { 173 if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT, 174 urb->transfer_buffer, 175 urb->actual_length) < 0) { 176 BT_ERR("%s corrupted ACL packet", hdev->name); 177 hdev->stat.err_rx++; 178 } 179 } 180 181 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags)) 182 return; 183 184 usb_anchor_urb(urb, &data->bulk_anchor); 185 186 err = usb_submit_urb(urb, GFP_ATOMIC); 187 if (err < 0) { 188 BT_ERR("%s urb %p failed to resubmit (%d)", 189 hdev->name, urb, -err); 190 usb_unanchor_urb(urb); 191 } 192 } 193 194 static inline int btusb_submit_bulk_urb(struct hci_dev *hdev) 195 { 196 struct btusb_data *data = hdev->driver_data; 197 struct urb *urb; 198 unsigned char *buf; 199 unsigned int pipe; 200 int err, size; 201 202 BT_DBG("%s", hdev->name); 203 204 urb = usb_alloc_urb(0, GFP_KERNEL); 205 if (!urb) 206 return -ENOMEM; 207 208 size = le16_to_cpu(data->bulk_rx_ep->wMaxPacketSize); 209 210 buf = kmalloc(size, GFP_KERNEL); 211 if (!buf) { 212 usb_free_urb(urb); 213 return -ENOMEM; 214 } 215 216 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress); 217 218 usb_fill_bulk_urb(urb, data->udev, pipe, 219 buf, size, btusb_bulk_complete, hdev); 220 221 urb->transfer_flags |= URB_FREE_BUFFER; 222 223 usb_anchor_urb(urb, &data->bulk_anchor); 224 225 err = usb_submit_urb(urb, GFP_KERNEL); 226 if (err < 0) { 227 BT_ERR("%s urb %p submission failed (%d)", 228 hdev->name, urb, -err); 229 usb_unanchor_urb(urb); 230 kfree(buf); 231 } 232 233 usb_free_urb(urb); 234 235 return err; 236 } 237 238 static void btusb_tx_complete(struct urb *urb) 239 { 240 struct sk_buff *skb = urb->context; 241 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 242 243 BT_DBG("%s urb %p status %d count %d", hdev->name, 244 urb, urb->status, urb->actual_length); 245 246 if (!test_bit(HCI_RUNNING, &hdev->flags)) 247 goto done; 248 249 if (!urb->status) 250 hdev->stat.byte_tx += urb->transfer_buffer_length; 251 else 252 hdev->stat.err_tx++; 253 254 done: 255 kfree(urb->setup_packet); 256 257 kfree_skb(skb); 258 } 259 260 static int btusb_open(struct hci_dev *hdev) 261 { 262 struct btusb_data *data = hdev->driver_data; 263 int err; 264 265 BT_DBG("%s", hdev->name); 266 267 if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) 268 return 0; 269 270 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags)) 271 return 0; 272 273 err = btusb_submit_intr_urb(hdev); 274 if (err < 0) { 275 clear_bit(BTUSB_INTR_RUNNING, &hdev->flags); 276 clear_bit(HCI_RUNNING, &hdev->flags); 277 } 278 279 return err; 280 } 281 282 static int btusb_close(struct hci_dev *hdev) 283 { 284 struct btusb_data *data = hdev->driver_data; 285 286 BT_DBG("%s", hdev->name); 287 288 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 289 return 0; 290 291 clear_bit(BTUSB_BULK_RUNNING, &data->flags); 292 usb_kill_anchored_urbs(&data->bulk_anchor); 293 294 clear_bit(BTUSB_INTR_RUNNING, &data->flags); 295 usb_kill_anchored_urbs(&data->intr_anchor); 296 297 return 0; 298 } 299 300 static int btusb_flush(struct hci_dev *hdev) 301 { 302 struct btusb_data *data = hdev->driver_data; 303 304 BT_DBG("%s", hdev->name); 305 306 usb_kill_anchored_urbs(&data->tx_anchor); 307 308 return 0; 309 } 310 311 static int btusb_send_frame(struct sk_buff *skb) 312 { 313 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 314 struct btusb_data *data = hdev->driver_data; 315 struct usb_ctrlrequest *dr; 316 struct urb *urb; 317 unsigned int pipe; 318 int err; 319 320 BT_DBG("%s", hdev->name); 321 322 if (!test_bit(HCI_RUNNING, &hdev->flags)) 323 return -EBUSY; 324 325 switch (bt_cb(skb)->pkt_type) { 326 case HCI_COMMAND_PKT: 327 urb = usb_alloc_urb(0, GFP_ATOMIC); 328 if (!urb) 329 return -ENOMEM; 330 331 dr = kmalloc(sizeof(*dr), GFP_ATOMIC); 332 if (!dr) { 333 usb_free_urb(urb); 334 return -ENOMEM; 335 } 336 337 dr->bRequestType = USB_TYPE_CLASS; 338 dr->bRequest = 0; 339 dr->wIndex = 0; 340 dr->wValue = 0; 341 dr->wLength = __cpu_to_le16(skb->len); 342 343 pipe = usb_sndctrlpipe(data->udev, 0x00); 344 345 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr, 346 skb->data, skb->len, btusb_tx_complete, skb); 347 348 hdev->stat.cmd_tx++; 349 break; 350 351 case HCI_ACLDATA_PKT: 352 urb = usb_alloc_urb(0, GFP_ATOMIC); 353 if (!urb) 354 return -ENOMEM; 355 356 pipe = usb_sndbulkpipe(data->udev, 357 data->bulk_tx_ep->bEndpointAddress); 358 359 usb_fill_bulk_urb(urb, data->udev, pipe, 360 skb->data, skb->len, btusb_tx_complete, skb); 361 362 hdev->stat.acl_tx++; 363 break; 364 365 case HCI_SCODATA_PKT: 366 hdev->stat.sco_tx++; 367 kfree_skb(skb); 368 return 0; 369 370 default: 371 return -EILSEQ; 372 } 373 374 usb_anchor_urb(urb, &data->tx_anchor); 375 376 err = usb_submit_urb(urb, GFP_ATOMIC); 377 if (err < 0) { 378 BT_ERR("%s urb %p submission failed", hdev->name, urb); 379 kfree(urb->setup_packet); 380 usb_unanchor_urb(urb); 381 } 382 383 usb_free_urb(urb); 384 385 return err; 386 } 387 388 static void btusb_destruct(struct hci_dev *hdev) 389 { 390 struct btusb_data *data = hdev->driver_data; 391 392 BT_DBG("%s", hdev->name); 393 394 kfree(data); 395 } 396 397 static void btusb_notify(struct hci_dev *hdev, unsigned int evt) 398 { 399 struct btusb_data *data = hdev->driver_data; 400 401 BT_DBG("%s evt %d", hdev->name, evt); 402 403 if (evt == HCI_NOTIFY_CONN_ADD || evt == HCI_NOTIFY_CONN_DEL) 404 schedule_work(&data->work); 405 } 406 407 static void btusb_work(struct work_struct *work) 408 { 409 struct btusb_data *data = container_of(work, struct btusb_data, work); 410 struct hci_dev *hdev = data->hdev; 411 412 if (hdev->conn_hash.acl_num == 0) { 413 clear_bit(BTUSB_BULK_RUNNING, &data->flags); 414 usb_kill_anchored_urbs(&data->bulk_anchor); 415 return; 416 } 417 418 if (!test_and_set_bit(BTUSB_BULK_RUNNING, &data->flags)) { 419 if (btusb_submit_bulk_urb(hdev) < 0) 420 clear_bit(BTUSB_BULK_RUNNING, &data->flags); 421 else 422 btusb_submit_bulk_urb(hdev); 423 } 424 } 425 426 static int btusb_probe(struct usb_interface *intf, 427 const struct usb_device_id *id) 428 { 429 struct usb_endpoint_descriptor *ep_desc; 430 struct btusb_data *data; 431 struct hci_dev *hdev; 432 int i, err; 433 434 BT_DBG("intf %p id %p", intf, id); 435 436 if (intf->cur_altsetting->desc.bInterfaceNumber != 0) 437 return -ENODEV; 438 439 if (!id->driver_info) { 440 const struct usb_device_id *match; 441 match = usb_match_id(intf, blacklist_table); 442 if (match) 443 id = match; 444 } 445 446 data = kzalloc(sizeof(*data), GFP_KERNEL); 447 if (!data) 448 return -ENOMEM; 449 450 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { 451 ep_desc = &intf->cur_altsetting->endpoint[i].desc; 452 453 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) { 454 data->intr_ep = ep_desc; 455 continue; 456 } 457 458 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) { 459 data->bulk_tx_ep = ep_desc; 460 continue; 461 } 462 463 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) { 464 data->bulk_rx_ep = ep_desc; 465 continue; 466 } 467 } 468 469 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) { 470 kfree(data); 471 return -ENODEV; 472 } 473 474 data->udev = interface_to_usbdev(intf); 475 476 spin_lock_init(&data->lock); 477 478 INIT_WORK(&data->work, btusb_work); 479 480 init_usb_anchor(&data->tx_anchor); 481 init_usb_anchor(&data->intr_anchor); 482 init_usb_anchor(&data->bulk_anchor); 483 484 hdev = hci_alloc_dev(); 485 if (!hdev) { 486 kfree(data); 487 return -ENOMEM; 488 } 489 490 hdev->type = HCI_USB; 491 hdev->driver_data = data; 492 493 data->hdev = hdev; 494 495 SET_HCIDEV_DEV(hdev, &intf->dev); 496 497 hdev->open = btusb_open; 498 hdev->close = btusb_close; 499 hdev->flush = btusb_flush; 500 hdev->send = btusb_send_frame; 501 hdev->destruct = btusb_destruct; 502 hdev->notify = btusb_notify; 503 504 hdev->owner = THIS_MODULE; 505 506 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks); 507 508 err = hci_register_dev(hdev); 509 if (err < 0) { 510 hci_free_dev(hdev); 511 kfree(data); 512 return err; 513 } 514 515 usb_set_intfdata(intf, data); 516 517 return 0; 518 } 519 520 static void btusb_disconnect(struct usb_interface *intf) 521 { 522 struct btusb_data *data = usb_get_intfdata(intf); 523 struct hci_dev *hdev; 524 525 BT_DBG("intf %p", intf); 526 527 if (!data) 528 return; 529 530 hdev = data->hdev; 531 532 usb_set_intfdata(intf, NULL); 533 534 hci_unregister_dev(hdev); 535 536 hci_free_dev(hdev); 537 } 538 539 static struct usb_driver btusb_driver = { 540 .name = "btusb", 541 .probe = btusb_probe, 542 .disconnect = btusb_disconnect, 543 .id_table = btusb_table, 544 }; 545 546 static int __init btusb_init(void) 547 { 548 BT_INFO("Generic Bluetooth USB driver ver %s", VERSION); 549 550 return usb_register(&btusb_driver); 551 } 552 553 static void __exit btusb_exit(void) 554 { 555 usb_deregister(&btusb_driver); 556 } 557 558 module_init(btusb_init); 559 module_exit(btusb_exit); 560 561 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 562 MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION); 563 MODULE_VERSION(VERSION); 564 MODULE_LICENSE("GPL"); 565