1 /* 2 * 3 * Digianswer Bluetooth USB driver 4 * 5 * Copyright (C) 2004-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 #ifndef CONFIG_BT_HCIBPA10X_DEBUG 39 #undef BT_DBG 40 #define BT_DBG(D...) 41 #endif 42 43 #define VERSION "0.9" 44 45 static int ignore = 0; 46 47 static struct usb_device_id bpa10x_table[] = { 48 /* Tektronix BPA 100/105 (Digianswer) */ 49 { USB_DEVICE(0x08fd, 0x0002) }, 50 51 { } /* Terminating entry */ 52 }; 53 54 MODULE_DEVICE_TABLE(usb, bpa10x_table); 55 56 struct bpa10x_data { 57 struct hci_dev *hdev; 58 struct usb_device *udev; 59 60 struct usb_anchor tx_anchor; 61 struct usb_anchor rx_anchor; 62 63 struct sk_buff *rx_skb[2]; 64 }; 65 66 #define HCI_VENDOR_HDR_SIZE 5 67 68 struct hci_vendor_hdr { 69 __u8 type; 70 __le16 snum; 71 __le16 dlen; 72 } __attribute__ ((packed)); 73 74 static int bpa10x_recv(struct hci_dev *hdev, int queue, void *buf, int count) 75 { 76 struct bpa10x_data *data = hdev->driver_data; 77 78 BT_DBG("%s queue %d buffer %p count %d", hdev->name, 79 queue, buf, count); 80 81 if (queue < 0 || queue > 1) 82 return -EILSEQ; 83 84 hdev->stat.byte_rx += count; 85 86 while (count) { 87 struct sk_buff *skb = data->rx_skb[queue]; 88 struct { __u8 type; int expect; } *scb; 89 int type, len = 0; 90 91 if (!skb) { 92 /* Start of the frame */ 93 94 type = *((__u8 *) buf); 95 count--; buf++; 96 97 switch (type) { 98 case HCI_EVENT_PKT: 99 if (count >= HCI_EVENT_HDR_SIZE) { 100 struct hci_event_hdr *h = buf; 101 len = HCI_EVENT_HDR_SIZE + h->plen; 102 } else 103 return -EILSEQ; 104 break; 105 106 case HCI_ACLDATA_PKT: 107 if (count >= HCI_ACL_HDR_SIZE) { 108 struct hci_acl_hdr *h = buf; 109 len = HCI_ACL_HDR_SIZE + 110 __le16_to_cpu(h->dlen); 111 } else 112 return -EILSEQ; 113 break; 114 115 case HCI_SCODATA_PKT: 116 if (count >= HCI_SCO_HDR_SIZE) { 117 struct hci_sco_hdr *h = buf; 118 len = HCI_SCO_HDR_SIZE + h->dlen; 119 } else 120 return -EILSEQ; 121 break; 122 123 case HCI_VENDOR_PKT: 124 if (count >= HCI_VENDOR_HDR_SIZE) { 125 struct hci_vendor_hdr *h = buf; 126 len = HCI_VENDOR_HDR_SIZE + 127 __le16_to_cpu(h->dlen); 128 } else 129 return -EILSEQ; 130 break; 131 } 132 133 skb = bt_skb_alloc(len, GFP_ATOMIC); 134 if (!skb) { 135 BT_ERR("%s no memory for packet", hdev->name); 136 return -ENOMEM; 137 } 138 139 skb->dev = (void *) hdev; 140 141 data->rx_skb[queue] = skb; 142 143 scb = (void *) skb->cb; 144 scb->type = type; 145 scb->expect = len; 146 } else { 147 /* Continuation */ 148 149 scb = (void *) skb->cb; 150 len = scb->expect; 151 } 152 153 len = min(len, count); 154 155 memcpy(skb_put(skb, len), buf, len); 156 157 scb->expect -= len; 158 159 if (scb->expect == 0) { 160 /* Complete frame */ 161 162 data->rx_skb[queue] = NULL; 163 164 bt_cb(skb)->pkt_type = scb->type; 165 hci_recv_frame(skb); 166 } 167 168 count -= len; buf += len; 169 } 170 171 return 0; 172 } 173 174 static void bpa10x_tx_complete(struct urb *urb) 175 { 176 struct sk_buff *skb = urb->context; 177 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 178 179 BT_DBG("%s urb %p status %d count %d", hdev->name, 180 urb, urb->status, urb->actual_length); 181 182 if (!test_bit(HCI_RUNNING, &hdev->flags)) 183 goto done; 184 185 if (!urb->status) 186 hdev->stat.byte_tx += urb->transfer_buffer_length; 187 else 188 hdev->stat.err_tx++; 189 190 done: 191 kfree(urb->setup_packet); 192 193 kfree_skb(skb); 194 } 195 196 static void bpa10x_rx_complete(struct urb *urb) 197 { 198 struct hci_dev *hdev = urb->context; 199 struct bpa10x_data *data = hdev->driver_data; 200 int err; 201 202 BT_DBG("%s urb %p status %d count %d", hdev->name, 203 urb, urb->status, urb->actual_length); 204 205 if (!test_bit(HCI_RUNNING, &hdev->flags)) 206 return; 207 208 if (urb->status == 0) { 209 if (bpa10x_recv(hdev, usb_pipebulk(urb->pipe), 210 urb->transfer_buffer, 211 urb->actual_length) < 0) { 212 BT_ERR("%s corrupted event packet", hdev->name); 213 hdev->stat.err_rx++; 214 } 215 } 216 217 usb_anchor_urb(urb, &data->rx_anchor); 218 219 err = usb_submit_urb(urb, GFP_ATOMIC); 220 if (err < 0) { 221 BT_ERR("%s urb %p failed to resubmit (%d)", 222 hdev->name, urb, -err); 223 usb_unanchor_urb(urb); 224 } 225 } 226 227 static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev) 228 { 229 struct bpa10x_data *data = hdev->driver_data; 230 struct urb *urb; 231 unsigned char *buf; 232 unsigned int pipe; 233 int err, size = 16; 234 235 BT_DBG("%s", hdev->name); 236 237 urb = usb_alloc_urb(0, GFP_KERNEL); 238 if (!urb) 239 return -ENOMEM; 240 241 buf = kmalloc(size, GFP_KERNEL); 242 if (!buf) { 243 usb_free_urb(urb); 244 return -ENOMEM; 245 } 246 247 pipe = usb_rcvintpipe(data->udev, 0x81); 248 249 usb_fill_int_urb(urb, data->udev, pipe, buf, size, 250 bpa10x_rx_complete, hdev, 1); 251 252 urb->transfer_flags |= URB_FREE_BUFFER; 253 254 usb_anchor_urb(urb, &data->rx_anchor); 255 256 err = usb_submit_urb(urb, GFP_KERNEL); 257 if (err < 0) { 258 BT_ERR("%s urb %p submission failed (%d)", 259 hdev->name, urb, -err); 260 usb_unanchor_urb(urb); 261 kfree(buf); 262 } 263 264 usb_free_urb(urb); 265 266 return err; 267 } 268 269 static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev) 270 { 271 struct bpa10x_data *data = hdev->driver_data; 272 struct urb *urb; 273 unsigned char *buf; 274 unsigned int pipe; 275 int err, size = 64; 276 277 BT_DBG("%s", hdev->name); 278 279 urb = usb_alloc_urb(0, GFP_KERNEL); 280 if (!urb) 281 return -ENOMEM; 282 283 buf = kmalloc(size, GFP_KERNEL); 284 if (!buf) { 285 usb_free_urb(urb); 286 return -ENOMEM; 287 } 288 289 pipe = usb_rcvbulkpipe(data->udev, 0x82); 290 291 usb_fill_bulk_urb(urb, data->udev, pipe, 292 buf, size, bpa10x_rx_complete, hdev); 293 294 urb->transfer_flags |= URB_FREE_BUFFER; 295 296 usb_anchor_urb(urb, &data->rx_anchor); 297 298 err = usb_submit_urb(urb, GFP_KERNEL); 299 if (err < 0) { 300 BT_ERR("%s urb %p submission failed (%d)", 301 hdev->name, urb, -err); 302 usb_unanchor_urb(urb); 303 kfree(buf); 304 } 305 306 usb_free_urb(urb); 307 308 return err; 309 } 310 311 static int bpa10x_open(struct hci_dev *hdev) 312 { 313 struct bpa10x_data *data = hdev->driver_data; 314 int err; 315 316 BT_DBG("%s", hdev->name); 317 318 if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) 319 return 0; 320 321 err = bpa10x_submit_intr_urb(hdev); 322 if (err < 0) 323 goto error; 324 325 err = bpa10x_submit_bulk_urb(hdev); 326 if (err < 0) 327 goto error; 328 329 return 0; 330 331 error: 332 usb_kill_anchored_urbs(&data->rx_anchor); 333 334 clear_bit(HCI_RUNNING, &hdev->flags); 335 336 return err; 337 } 338 339 static int bpa10x_close(struct hci_dev *hdev) 340 { 341 struct bpa10x_data *data = hdev->driver_data; 342 343 BT_DBG("%s", hdev->name); 344 345 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) 346 return 0; 347 348 usb_kill_anchored_urbs(&data->rx_anchor); 349 350 return 0; 351 } 352 353 static int bpa10x_flush(struct hci_dev *hdev) 354 { 355 struct bpa10x_data *data = hdev->driver_data; 356 357 BT_DBG("%s", hdev->name); 358 359 usb_kill_anchored_urbs(&data->tx_anchor); 360 361 return 0; 362 } 363 364 static int bpa10x_send_frame(struct sk_buff *skb) 365 { 366 struct hci_dev *hdev = (struct hci_dev *) skb->dev; 367 struct bpa10x_data *data = hdev->driver_data; 368 struct usb_ctrlrequest *dr; 369 struct urb *urb; 370 unsigned int pipe; 371 int err; 372 373 BT_DBG("%s", hdev->name); 374 375 if (!test_bit(HCI_RUNNING, &hdev->flags)) 376 return -EBUSY; 377 378 urb = usb_alloc_urb(0, GFP_ATOMIC); 379 if (!urb) 380 return -ENOMEM; 381 382 /* Prepend skb with frame type */ 383 *skb_push(skb, 1) = bt_cb(skb)->pkt_type; 384 385 switch (bt_cb(skb)->pkt_type) { 386 case HCI_COMMAND_PKT: 387 dr = kmalloc(sizeof(*dr), GFP_ATOMIC); 388 if (!dr) { 389 usb_free_urb(urb); 390 return -ENOMEM; 391 } 392 393 dr->bRequestType = USB_TYPE_VENDOR; 394 dr->bRequest = 0; 395 dr->wIndex = 0; 396 dr->wValue = 0; 397 dr->wLength = __cpu_to_le16(skb->len); 398 399 pipe = usb_sndctrlpipe(data->udev, 0x00); 400 401 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr, 402 skb->data, skb->len, bpa10x_tx_complete, skb); 403 404 hdev->stat.cmd_tx++; 405 break; 406 407 case HCI_ACLDATA_PKT: 408 pipe = usb_sndbulkpipe(data->udev, 0x02); 409 410 usb_fill_bulk_urb(urb, data->udev, pipe, 411 skb->data, skb->len, bpa10x_tx_complete, skb); 412 413 hdev->stat.acl_tx++; 414 break; 415 416 case HCI_SCODATA_PKT: 417 pipe = usb_sndbulkpipe(data->udev, 0x02); 418 419 usb_fill_bulk_urb(urb, data->udev, pipe, 420 skb->data, skb->len, bpa10x_tx_complete, skb); 421 422 hdev->stat.sco_tx++; 423 break; 424 425 default: 426 usb_free_urb(urb); 427 return -EILSEQ; 428 } 429 430 usb_anchor_urb(urb, &data->tx_anchor); 431 432 err = usb_submit_urb(urb, GFP_ATOMIC); 433 if (err < 0) { 434 BT_ERR("%s urb %p submission failed", hdev->name, urb); 435 kfree(urb->setup_packet); 436 usb_unanchor_urb(urb); 437 } 438 439 usb_free_urb(urb); 440 441 return 0; 442 } 443 444 static void bpa10x_destruct(struct hci_dev *hdev) 445 { 446 struct bpa10x_data *data = hdev->driver_data; 447 448 BT_DBG("%s", hdev->name); 449 450 kfree(data->rx_skb[0]); 451 kfree(data->rx_skb[1]); 452 kfree(data); 453 } 454 455 static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id) 456 { 457 struct bpa10x_data *data; 458 struct hci_dev *hdev; 459 int err; 460 461 BT_DBG("intf %p id %p", intf, id); 462 463 if (ignore) 464 return -ENODEV; 465 466 if (intf->cur_altsetting->desc.bInterfaceNumber != 0) 467 return -ENODEV; 468 469 data = kzalloc(sizeof(*data), GFP_KERNEL); 470 if (!data) 471 return -ENOMEM; 472 473 data->udev = interface_to_usbdev(intf); 474 475 init_usb_anchor(&data->tx_anchor); 476 init_usb_anchor(&data->rx_anchor); 477 478 hdev = hci_alloc_dev(); 479 if (!hdev) { 480 kfree(data); 481 return -ENOMEM; 482 } 483 484 hdev->type = HCI_USB; 485 hdev->driver_data = data; 486 487 data->hdev = hdev; 488 489 SET_HCIDEV_DEV(hdev, &intf->dev); 490 491 hdev->open = bpa10x_open; 492 hdev->close = bpa10x_close; 493 hdev->flush = bpa10x_flush; 494 hdev->send = bpa10x_send_frame; 495 hdev->destruct = bpa10x_destruct; 496 497 hdev->owner = THIS_MODULE; 498 499 err = hci_register_dev(hdev); 500 if (err < 0) { 501 hci_free_dev(hdev); 502 kfree(data); 503 return err; 504 } 505 506 usb_set_intfdata(intf, data); 507 508 return 0; 509 } 510 511 static void bpa10x_disconnect(struct usb_interface *intf) 512 { 513 struct bpa10x_data *data = usb_get_intfdata(intf); 514 515 BT_DBG("intf %p", intf); 516 517 if (!data) 518 return; 519 520 usb_set_intfdata(intf, NULL); 521 522 hci_unregister_dev(data->hdev); 523 524 hci_free_dev(data->hdev); 525 } 526 527 static struct usb_driver bpa10x_driver = { 528 .name = "bpa10x", 529 .probe = bpa10x_probe, 530 .disconnect = bpa10x_disconnect, 531 .id_table = bpa10x_table, 532 }; 533 534 static int __init bpa10x_init(void) 535 { 536 BT_INFO("Digianswer Bluetooth USB driver ver %s", VERSION); 537 538 return usb_register(&bpa10x_driver); 539 } 540 541 static void __exit bpa10x_exit(void) 542 { 543 usb_deregister(&bpa10x_driver); 544 } 545 546 module_init(bpa10x_init); 547 module_exit(bpa10x_exit); 548 549 module_param(ignore, bool, 0644); 550 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table"); 551 552 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 553 MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION); 554 MODULE_VERSION(VERSION); 555 MODULE_LICENSE("GPL"); 556