1 /* 2 * AIRcable USB Bluetooth Dongle Driver. 3 * 4 * Copyright (C) 2006 Manuel Francisco Naranjo (naranjo.manuel@gmail.com) 5 * This program is free software; you can redistribute it and/or modify it under 6 * the terms of the GNU General Public License version 2 as published by the 7 * Free Software Foundation. 8 * 9 * The device works as an standard CDC device, it has 2 interfaces, the first 10 * one is for firmware access and the second is the serial one. 11 * The protocol is very simply, there are two posibilities reading or writing. 12 * When writing the first urb must have a Header that starts with 0x20 0x29 the 13 * next two bytes must say how much data will be sended. 14 * When reading the process is almost equal except that the header starts with 15 * 0x00 0x20. 16 * 17 * The device simply need some stuff to understand data comming from the usb 18 * buffer: The First and Second byte is used for a Header, the Third and Fourth 19 * tells the device the amount of information the package holds. 20 * Packages are 60 bytes long Header Stuff. 21 * When writing to the device the first two bytes of the header are 0x20 0x29 22 * When reading the bytes are 0x00 0x20, or 0x00 0x10, there is an strange 23 * situation, when too much data arrives to the device because it sends the data 24 * but with out the header. I will use a simply hack to override this situation, 25 * if there is data coming that does not contain any header, then that is data 26 * that must go directly to the tty, as there is no documentation about if there 27 * is any other control code, I will simply check for the first 28 * one. 29 * 30 * The driver registers himself with the USB-serial core and the USB Core. I had 31 * to implement a probe function agains USB-serial, because other way, the 32 * driver was attaching himself to both interfaces. I have tryed with different 33 * configurations of usb_serial_driver with out exit, only the probe function 34 * could handle this correctly. 35 * 36 * I have taken some info from a Greg Kroah-Hartman article: 37 * http://www.linuxjournal.com/article/6573 38 * And from Linux Device Driver Kit CD, which is a great work, the authors taken 39 * the work to recompile lots of information an knowladge in drivers development 40 * and made it all avaible inside a cd. 41 * URL: http://kernel.org/pub/linux/kernel/people/gregkh/ddk/ 42 * 43 */ 44 45 #include <linux/tty.h> 46 #include <linux/tty_flip.h> 47 #include <linux/circ_buf.h> 48 #include <linux/usb.h> 49 #include <linux/usb/serial.h> 50 51 static int debug; 52 53 /* Vendor and Product ID */ 54 #define AIRCABLE_VID 0x16CA 55 #define AIRCABLE_USB_PID 0x1502 56 57 /* write buffer size defines */ 58 #define AIRCABLE_BUF_SIZE 2048 59 60 /* Protocol Stuff */ 61 #define HCI_HEADER_LENGTH 0x4 62 #define TX_HEADER_0 0x20 63 #define TX_HEADER_1 0x29 64 #define RX_HEADER_0 0x00 65 #define RX_HEADER_1 0x20 66 #define MAX_HCI_FRAMESIZE 60 67 #define HCI_COMPLETE_FRAME 64 68 69 /* rx_flags */ 70 #define THROTTLED 0x01 71 #define ACTUALLY_THROTTLED 0x02 72 73 /* 74 * Version Information 75 */ 76 #define DRIVER_VERSION "v1.0b2" 77 #define DRIVER_AUTHOR "Naranjo, Manuel Francisco <naranjo.manuel@gmail.com>" 78 #define DRIVER_DESC "AIRcable USB Driver" 79 80 /* ID table that will be registered with USB core */ 81 static struct usb_device_id id_table [] = { 82 { USB_DEVICE(AIRCABLE_VID, AIRCABLE_USB_PID) }, 83 { }, 84 }; 85 MODULE_DEVICE_TABLE(usb, id_table); 86 87 88 /* Internal Structure */ 89 struct aircable_private { 90 spinlock_t rx_lock; /* spinlock for the receive lines */ 91 struct circ_buf *tx_buf; /* write buffer */ 92 struct circ_buf *rx_buf; /* read buffer */ 93 int rx_flags; /* for throttilng */ 94 struct work_struct rx_work; /* work cue for the receiving line */ 95 struct usb_serial_port *port; /* USB port with which associated */ 96 }; 97 98 /* Private methods */ 99 100 /* Circular Buffer Methods, code from ti_usb_3410_5052 used */ 101 /* 102 * serial_buf_clear 103 * 104 * Clear out all data in the circular buffer. 105 */ 106 static void serial_buf_clear(struct circ_buf *cb) 107 { 108 cb->head = cb->tail = 0; 109 } 110 111 /* 112 * serial_buf_alloc 113 * 114 * Allocate a circular buffer and all associated memory. 115 */ 116 static struct circ_buf *serial_buf_alloc(void) 117 { 118 struct circ_buf *cb; 119 cb = kmalloc(sizeof(struct circ_buf), GFP_KERNEL); 120 if (cb == NULL) 121 return NULL; 122 cb->buf = kmalloc(AIRCABLE_BUF_SIZE, GFP_KERNEL); 123 if (cb->buf == NULL) { 124 kfree(cb); 125 return NULL; 126 } 127 serial_buf_clear(cb); 128 return cb; 129 } 130 131 /* 132 * serial_buf_free 133 * 134 * Free the buffer and all associated memory. 135 */ 136 static void serial_buf_free(struct circ_buf *cb) 137 { 138 kfree(cb->buf); 139 kfree(cb); 140 } 141 142 /* 143 * serial_buf_data_avail 144 * 145 * Return the number of bytes of data available in the circular 146 * buffer. 147 */ 148 static int serial_buf_data_avail(struct circ_buf *cb) 149 { 150 return CIRC_CNT(cb->head, cb->tail, AIRCABLE_BUF_SIZE); 151 } 152 153 /* 154 * serial_buf_put 155 * 156 * Copy data data from a user buffer and put it into the circular buffer. 157 * Restrict to the amount of space available. 158 * 159 * Return the number of bytes copied. 160 */ 161 static int serial_buf_put(struct circ_buf *cb, const char *buf, int count) 162 { 163 int c, ret = 0; 164 while (1) { 165 c = CIRC_SPACE_TO_END(cb->head, cb->tail, AIRCABLE_BUF_SIZE); 166 if (count < c) 167 c = count; 168 if (c <= 0) 169 break; 170 memcpy(cb->buf + cb->head, buf, c); 171 cb->head = (cb->head + c) & (AIRCABLE_BUF_SIZE-1); 172 buf += c; 173 count -= c; 174 ret = c; 175 } 176 return ret; 177 } 178 179 /* 180 * serial_buf_get 181 * 182 * Get data from the circular buffer and copy to the given buffer. 183 * Restrict to the amount of data available. 184 * 185 * Return the number of bytes copied. 186 */ 187 static int serial_buf_get(struct circ_buf *cb, char *buf, int count) 188 { 189 int c, ret = 0; 190 while (1) { 191 c = CIRC_CNT_TO_END(cb->head, cb->tail, AIRCABLE_BUF_SIZE); 192 if (count < c) 193 c = count; 194 if (c <= 0) 195 break; 196 memcpy(buf, cb->buf + cb->tail, c); 197 cb->tail = (cb->tail + c) & (AIRCABLE_BUF_SIZE-1); 198 buf += c; 199 count -= c; 200 ret = c; 201 } 202 return ret; 203 } 204 205 /* End of circula buffer methods */ 206 207 static void aircable_send(struct usb_serial_port *port) 208 { 209 int count, result; 210 struct aircable_private *priv = usb_get_serial_port_data(port); 211 unsigned char *buf; 212 __le16 *dbuf; 213 dbg("%s - port %d", __func__, port->number); 214 if (port->write_urb_busy) 215 return; 216 217 count = min(serial_buf_data_avail(priv->tx_buf), MAX_HCI_FRAMESIZE); 218 if (count == 0) 219 return; 220 221 buf = kzalloc(count + HCI_HEADER_LENGTH, GFP_ATOMIC); 222 if (!buf) { 223 err("%s- kzalloc(%d) failed.", __func__, 224 count + HCI_HEADER_LENGTH); 225 return; 226 } 227 228 buf[0] = TX_HEADER_0; 229 buf[1] = TX_HEADER_1; 230 dbuf = (__le16 *)&buf[2]; 231 *dbuf = cpu_to_le16((u16)count); 232 serial_buf_get(priv->tx_buf, buf + HCI_HEADER_LENGTH, 233 MAX_HCI_FRAMESIZE); 234 235 memcpy(port->write_urb->transfer_buffer, buf, 236 count + HCI_HEADER_LENGTH); 237 238 kfree(buf); 239 port->write_urb_busy = 1; 240 usb_serial_debug_data(debug, &port->dev, __func__, 241 count + HCI_HEADER_LENGTH, 242 port->write_urb->transfer_buffer); 243 port->write_urb->transfer_buffer_length = count + HCI_HEADER_LENGTH; 244 port->write_urb->dev = port->serial->dev; 245 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 246 247 if (result) { 248 dev_err(&port->dev, 249 "%s - failed submitting write urb, error %d\n", 250 __func__, result); 251 port->write_urb_busy = 0; 252 } 253 254 schedule_work(&port->work); 255 } 256 257 static void aircable_read(struct work_struct *work) 258 { 259 struct aircable_private *priv = 260 container_of(work, struct aircable_private, rx_work); 261 struct usb_serial_port *port = priv->port; 262 struct tty_struct *tty; 263 unsigned char *data; 264 int count; 265 if (priv->rx_flags & THROTTLED) { 266 if (priv->rx_flags & ACTUALLY_THROTTLED) 267 schedule_work(&priv->rx_work); 268 return; 269 } 270 271 /* By now I will flush data to the tty in packages of no more than 272 * 64 bytes, to ensure I do not get throttled. 273 * Ask USB mailing list for better aproach. 274 */ 275 tty = port->port.tty; 276 277 if (!tty) { 278 schedule_work(&priv->rx_work); 279 err("%s - No tty available", __func__); 280 return ; 281 } 282 283 count = min(64, serial_buf_data_avail(priv->rx_buf)); 284 285 if (count <= 0) 286 return; /* We have finished sending everything. */ 287 288 tty_prepare_flip_string(tty, &data, count); 289 if (!data) { 290 err("%s- kzalloc(%d) failed.", __func__, count); 291 return; 292 } 293 294 serial_buf_get(priv->rx_buf, data, count); 295 296 tty_flip_buffer_push(tty); 297 298 if (serial_buf_data_avail(priv->rx_buf)) 299 schedule_work(&priv->rx_work); 300 301 return; 302 } 303 /* End of private methods */ 304 305 static int aircable_probe(struct usb_serial *serial, 306 const struct usb_device_id *id) 307 { 308 struct usb_host_interface *iface_desc = serial->interface-> 309 cur_altsetting; 310 struct usb_endpoint_descriptor *endpoint; 311 int num_bulk_out = 0; 312 int i; 313 314 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { 315 endpoint = &iface_desc->endpoint[i].desc; 316 if (usb_endpoint_is_bulk_out(endpoint)) { 317 dbg("found bulk out on endpoint %d", i); 318 ++num_bulk_out; 319 } 320 } 321 322 if (num_bulk_out == 0) { 323 dbg("Invalid interface, discarding"); 324 return -ENODEV; 325 } 326 327 return 0; 328 } 329 330 static int aircable_attach(struct usb_serial *serial) 331 { 332 struct usb_serial_port *port = serial->port[0]; 333 struct aircable_private *priv; 334 335 priv = kzalloc(sizeof(struct aircable_private), GFP_KERNEL); 336 if (!priv) { 337 err("%s- kmalloc(%Zd) failed.", __func__, 338 sizeof(struct aircable_private)); 339 return -ENOMEM; 340 } 341 342 /* Allocation of Circular Buffers */ 343 priv->tx_buf = serial_buf_alloc(); 344 if (priv->tx_buf == NULL) { 345 kfree(priv); 346 return -ENOMEM; 347 } 348 349 priv->rx_buf = serial_buf_alloc(); 350 if (priv->rx_buf == NULL) { 351 kfree(priv->tx_buf); 352 kfree(priv); 353 return -ENOMEM; 354 } 355 356 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED); 357 priv->port = port; 358 INIT_WORK(&priv->rx_work, aircable_read); 359 360 usb_set_serial_port_data(serial->port[0], priv); 361 362 return 0; 363 } 364 365 static void aircable_shutdown(struct usb_serial *serial) 366 { 367 368 struct usb_serial_port *port = serial->port[0]; 369 struct aircable_private *priv = usb_get_serial_port_data(port); 370 371 dbg("%s", __func__); 372 373 if (priv) { 374 serial_buf_free(priv->tx_buf); 375 serial_buf_free(priv->rx_buf); 376 usb_set_serial_port_data(port, NULL); 377 kfree(priv); 378 } 379 } 380 381 static int aircable_write_room(struct tty_struct *tty) 382 { 383 struct usb_serial_port *port = tty->driver_data; 384 struct aircable_private *priv = usb_get_serial_port_data(port); 385 return serial_buf_data_avail(priv->tx_buf); 386 } 387 388 static int aircable_write(struct tty_struct *tty, struct usb_serial_port *port, 389 const unsigned char *source, int count) 390 { 391 struct aircable_private *priv = usb_get_serial_port_data(port); 392 int temp; 393 394 dbg("%s - port %d, %d bytes", __func__, port->number, count); 395 396 usb_serial_debug_data(debug, &port->dev, __func__, count, source); 397 398 if (!count) { 399 dbg("%s - write request of 0 bytes", __func__); 400 return count; 401 } 402 403 temp = serial_buf_put(priv->tx_buf, source, count); 404 405 aircable_send(port); 406 407 if (count > AIRCABLE_BUF_SIZE) 408 count = AIRCABLE_BUF_SIZE; 409 410 return count; 411 412 } 413 414 static void aircable_write_bulk_callback(struct urb *urb) 415 { 416 struct usb_serial_port *port = urb->context; 417 int status = urb->status; 418 int result; 419 420 dbg("%s - urb status: %d", __func__ , status); 421 422 /* This has been taken from cypress_m8.c cypress_write_int_callback */ 423 switch (status) { 424 case 0: 425 /* success */ 426 break; 427 case -ECONNRESET: 428 case -ENOENT: 429 case -ESHUTDOWN: 430 /* this urb is terminated, clean up */ 431 dbg("%s - urb shutting down with status: %d", 432 __func__, status); 433 port->write_urb_busy = 0; 434 return; 435 default: 436 /* error in the urb, so we have to resubmit it */ 437 dbg("%s - Overflow in write", __func__); 438 dbg("%s - nonzero write bulk status received: %d", 439 __func__, status); 440 port->write_urb->transfer_buffer_length = 1; 441 port->write_urb->dev = port->serial->dev; 442 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 443 if (result) 444 dev_err(&urb->dev->dev, 445 "%s - failed resubmitting write urb, error %d\n", 446 __func__, result); 447 else 448 return; 449 } 450 451 port->write_urb_busy = 0; 452 453 aircable_send(port); 454 } 455 456 static void aircable_read_bulk_callback(struct urb *urb) 457 { 458 struct usb_serial_port *port = urb->context; 459 struct aircable_private *priv = usb_get_serial_port_data(port); 460 struct tty_struct *tty; 461 unsigned long no_packages, remaining, package_length, i; 462 int result, shift = 0; 463 unsigned char *temp; 464 int status = urb->status; 465 466 dbg("%s - port %d", __func__, port->number); 467 468 if (status) { 469 dbg("%s - urb status = %d", __func__, status); 470 if (!port->port.count) { 471 dbg("%s - port is closed, exiting.", __func__); 472 return; 473 } 474 if (status == -EPROTO) { 475 dbg("%s - caught -EPROTO, resubmitting the urb", 476 __func__); 477 usb_fill_bulk_urb(port->read_urb, port->serial->dev, 478 usb_rcvbulkpipe(port->serial->dev, 479 port->bulk_in_endpointAddress), 480 port->read_urb->transfer_buffer, 481 port->read_urb->transfer_buffer_length, 482 aircable_read_bulk_callback, port); 483 484 result = usb_submit_urb(urb, GFP_ATOMIC); 485 if (result) 486 dev_err(&urb->dev->dev, 487 "%s - failed resubmitting read urb, error %d\n", 488 __func__, result); 489 return; 490 } 491 dbg("%s - unable to handle the error, exiting.", __func__); 492 return; 493 } 494 495 usb_serial_debug_data(debug, &port->dev, __func__, 496 urb->actual_length, urb->transfer_buffer); 497 498 tty = port->port.tty; 499 if (tty && urb->actual_length) { 500 if (urb->actual_length <= 2) { 501 /* This is an incomplete package */ 502 serial_buf_put(priv->rx_buf, urb->transfer_buffer, 503 urb->actual_length); 504 } else { 505 temp = urb->transfer_buffer; 506 if (temp[0] == RX_HEADER_0) 507 shift = HCI_HEADER_LENGTH; 508 509 remaining = urb->actual_length; 510 no_packages = urb->actual_length / (HCI_COMPLETE_FRAME); 511 512 if (urb->actual_length % HCI_COMPLETE_FRAME != 0) 513 no_packages++; 514 515 for (i = 0; i < no_packages; i++) { 516 if (remaining > (HCI_COMPLETE_FRAME)) 517 package_length = HCI_COMPLETE_FRAME; 518 else 519 package_length = remaining; 520 remaining -= package_length; 521 522 serial_buf_put(priv->rx_buf, 523 urb->transfer_buffer + shift + 524 (HCI_COMPLETE_FRAME) * (i), 525 package_length - shift); 526 } 527 } 528 aircable_read(&priv->rx_work); 529 } 530 531 /* Schedule the next read _if_ we are still open */ 532 if (port->port.count) { 533 usb_fill_bulk_urb(port->read_urb, port->serial->dev, 534 usb_rcvbulkpipe(port->serial->dev, 535 port->bulk_in_endpointAddress), 536 port->read_urb->transfer_buffer, 537 port->read_urb->transfer_buffer_length, 538 aircable_read_bulk_callback, port); 539 540 result = usb_submit_urb(urb, GFP_ATOMIC); 541 if (result) 542 dev_err(&urb->dev->dev, 543 "%s - failed resubmitting read urb, error %d\n", 544 __func__, result); 545 } 546 547 return; 548 } 549 550 /* Based on ftdi_sio.c throttle */ 551 static void aircable_throttle(struct tty_struct *tty) 552 { 553 struct usb_serial_port *port = tty->driver_data; 554 struct aircable_private *priv = usb_get_serial_port_data(port); 555 unsigned long flags; 556 557 dbg("%s - port %d", __func__, port->number); 558 559 spin_lock_irqsave(&priv->rx_lock, flags); 560 priv->rx_flags |= THROTTLED; 561 spin_unlock_irqrestore(&priv->rx_lock, flags); 562 } 563 564 /* Based on ftdi_sio.c unthrottle */ 565 static void aircable_unthrottle(struct tty_struct *tty) 566 { 567 struct usb_serial_port *port = tty->driver_data; 568 struct aircable_private *priv = usb_get_serial_port_data(port); 569 int actually_throttled; 570 unsigned long flags; 571 572 dbg("%s - port %d", __func__, port->number); 573 574 spin_lock_irqsave(&priv->rx_lock, flags); 575 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED; 576 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED); 577 spin_unlock_irqrestore(&priv->rx_lock, flags); 578 579 if (actually_throttled) 580 schedule_work(&priv->rx_work); 581 } 582 583 static struct usb_driver aircable_driver = { 584 .name = "aircable", 585 .probe = usb_serial_probe, 586 .disconnect = usb_serial_disconnect, 587 .id_table = id_table, 588 .no_dynamic_id = 1, 589 }; 590 591 static struct usb_serial_driver aircable_device = { 592 .driver = { 593 .owner = THIS_MODULE, 594 .name = "aircable", 595 }, 596 .usb_driver = &aircable_driver, 597 .id_table = id_table, 598 .num_ports = 1, 599 .attach = aircable_attach, 600 .probe = aircable_probe, 601 .shutdown = aircable_shutdown, 602 .write = aircable_write, 603 .write_room = aircable_write_room, 604 .write_bulk_callback = aircable_write_bulk_callback, 605 .read_bulk_callback = aircable_read_bulk_callback, 606 .throttle = aircable_throttle, 607 .unthrottle = aircable_unthrottle, 608 }; 609 610 static int __init aircable_init(void) 611 { 612 int retval; 613 retval = usb_serial_register(&aircable_device); 614 if (retval) 615 goto failed_serial_register; 616 retval = usb_register(&aircable_driver); 617 if (retval) 618 goto failed_usb_register; 619 return 0; 620 621 failed_serial_register: 622 usb_serial_deregister(&aircable_device); 623 failed_usb_register: 624 return retval; 625 } 626 627 static void __exit aircable_exit(void) 628 { 629 usb_deregister(&aircable_driver); 630 usb_serial_deregister(&aircable_device); 631 } 632 633 MODULE_AUTHOR(DRIVER_AUTHOR); 634 MODULE_DESCRIPTION(DRIVER_DESC); 635 MODULE_VERSION(DRIVER_VERSION); 636 MODULE_LICENSE("GPL"); 637 638 module_init(aircable_init); 639 module_exit(aircable_exit); 640 641 module_param(debug, bool, S_IRUGO | S_IWUSR); 642 MODULE_PARM_DESC(debug, "Debug enabled or not"); 643