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