aircable.c revision c4d0f8cbca3a97900f85b082064a63c7a5928bd7
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 51static 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 */ 81static struct usb_device_id id_table [] = { 82 { USB_DEVICE(AIRCABLE_VID, AIRCABLE_USB_PID) }, 83 { }, 84}; 85MODULE_DEVICE_TABLE(usb, id_table); 86 87 88/* Internal Structure */ 89struct 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 */ 106static 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 */ 116static 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 */ 136static 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 */ 148static 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 */ 161static 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 */ 187static 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 207static 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 257static 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->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 305static 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 330static 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 365static 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 381static int aircable_write_room(struct usb_serial_port *port) 382{ 383 struct aircable_private *priv = usb_get_serial_port_data(port); 384 return serial_buf_data_avail(priv->tx_buf); 385} 386 387static int aircable_write(struct usb_serial_port *port, 388 const unsigned char *source, int count) 389{ 390 struct aircable_private *priv = usb_get_serial_port_data(port); 391 int temp; 392 393 dbg("%s - port %d, %d bytes", __func__, port->number, count); 394 395 usb_serial_debug_data(debug, &port->dev, __func__, count, source); 396 397 if (!count) { 398 dbg("%s - write request of 0 bytes", __func__); 399 return count; 400 } 401 402 temp = serial_buf_put(priv->tx_buf, source, count); 403 404 aircable_send(port); 405 406 if (count > AIRCABLE_BUF_SIZE) 407 count = AIRCABLE_BUF_SIZE; 408 409 return count; 410 411} 412 413static void aircable_write_bulk_callback(struct urb *urb) 414{ 415 struct usb_serial_port *port = urb->context; 416 int status = urb->status; 417 int result; 418 419 dbg("%s - urb status: %d", __func__ , status); 420 421 /* This has been taken from cypress_m8.c cypress_write_int_callback */ 422 switch (status) { 423 case 0: 424 /* success */ 425 break; 426 case -ECONNRESET: 427 case -ENOENT: 428 case -ESHUTDOWN: 429 /* this urb is terminated, clean up */ 430 dbg("%s - urb shutting down with status: %d", 431 __func__, status); 432 port->write_urb_busy = 0; 433 return; 434 default: 435 /* error in the urb, so we have to resubmit it */ 436 dbg("%s - Overflow in write", __func__); 437 dbg("%s - nonzero write bulk status received: %d", 438 __func__, status); 439 port->write_urb->transfer_buffer_length = 1; 440 port->write_urb->dev = port->serial->dev; 441 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 442 if (result) 443 dev_err(&urb->dev->dev, 444 "%s - failed resubmitting write urb, error %d\n", 445 __func__, result); 446 else 447 return; 448 } 449 450 port->write_urb_busy = 0; 451 452 aircable_send(port); 453} 454 455static void aircable_read_bulk_callback(struct urb *urb) 456{ 457 struct usb_serial_port *port = urb->context; 458 struct aircable_private *priv = usb_get_serial_port_data(port); 459 struct tty_struct *tty; 460 unsigned long no_packages, remaining, package_length, i; 461 int result, shift = 0; 462 unsigned char *temp; 463 int status = urb->status; 464 465 dbg("%s - port %d", __func__, port->number); 466 467 if (status) { 468 dbg("%s - urb status = %d", __func__, status); 469 if (!port->open_count) { 470 dbg("%s - port is closed, exiting.", __func__); 471 return; 472 } 473 if (status == -EPROTO) { 474 dbg("%s - caught -EPROTO, resubmitting the urb", 475 __func__); 476 usb_fill_bulk_urb(port->read_urb, port->serial->dev, 477 usb_rcvbulkpipe(port->serial->dev, 478 port->bulk_in_endpointAddress), 479 port->read_urb->transfer_buffer, 480 port->read_urb->transfer_buffer_length, 481 aircable_read_bulk_callback, port); 482 483 result = usb_submit_urb(urb, GFP_ATOMIC); 484 if (result) 485 dev_err(&urb->dev->dev, 486 "%s - failed resubmitting read urb, error %d\n", 487 __func__, result); 488 return; 489 } 490 dbg("%s - unable to handle the error, exiting.", __func__); 491 return; 492 } 493 494 usb_serial_debug_data(debug, &port->dev, __func__, 495 urb->actual_length, urb->transfer_buffer); 496 497 tty = port->tty; 498 if (tty && urb->actual_length) { 499 if (urb->actual_length <= 2) { 500 /* This is an incomplete package */ 501 serial_buf_put(priv->rx_buf, urb->transfer_buffer, 502 urb->actual_length); 503 } else { 504 temp = urb->transfer_buffer; 505 if (temp[0] == RX_HEADER_0) 506 shift = HCI_HEADER_LENGTH; 507 508 remaining = urb->actual_length; 509 no_packages = urb->actual_length / (HCI_COMPLETE_FRAME); 510 511 if (urb->actual_length % HCI_COMPLETE_FRAME != 0) 512 no_packages++; 513 514 for (i = 0; i < no_packages; i++) { 515 if (remaining > (HCI_COMPLETE_FRAME)) 516 package_length = HCI_COMPLETE_FRAME; 517 else 518 package_length = remaining; 519 remaining -= package_length; 520 521 serial_buf_put(priv->rx_buf, 522 urb->transfer_buffer + shift + 523 (HCI_COMPLETE_FRAME) * (i), 524 package_length - shift); 525 } 526 } 527 aircable_read(&priv->rx_work); 528 } 529 530 /* Schedule the next read _if_ we are still open */ 531 if (port->open_count) { 532 usb_fill_bulk_urb(port->read_urb, port->serial->dev, 533 usb_rcvbulkpipe(port->serial->dev, 534 port->bulk_in_endpointAddress), 535 port->read_urb->transfer_buffer, 536 port->read_urb->transfer_buffer_length, 537 aircable_read_bulk_callback, port); 538 539 result = usb_submit_urb(urb, GFP_ATOMIC); 540 if (result) 541 dev_err(&urb->dev->dev, 542 "%s - failed resubmitting read urb, error %d\n", 543 __func__, result); 544 } 545 546 return; 547} 548 549/* Based on ftdi_sio.c throttle */ 550static void aircable_throttle(struct usb_serial_port *port) 551{ 552 struct aircable_private *priv = usb_get_serial_port_data(port); 553 unsigned long flags; 554 555 dbg("%s - port %d", __func__, port->number); 556 557 spin_lock_irqsave(&priv->rx_lock, flags); 558 priv->rx_flags |= THROTTLED; 559 spin_unlock_irqrestore(&priv->rx_lock, flags); 560} 561 562/* Based on ftdi_sio.c unthrottle */ 563static void aircable_unthrottle(struct usb_serial_port *port) 564{ 565 struct aircable_private *priv = usb_get_serial_port_data(port); 566 int actually_throttled; 567 unsigned long flags; 568 569 dbg("%s - port %d", __func__, port->number); 570 571 spin_lock_irqsave(&priv->rx_lock, flags); 572 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED; 573 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED); 574 spin_unlock_irqrestore(&priv->rx_lock, flags); 575 576 if (actually_throttled) 577 schedule_work(&priv->rx_work); 578} 579 580static struct usb_driver aircable_driver = { 581 .name = "aircable", 582 .probe = usb_serial_probe, 583 .disconnect = usb_serial_disconnect, 584 .id_table = id_table, 585 .no_dynamic_id = 1, 586}; 587 588static struct usb_serial_driver aircable_device = { 589 .driver = { 590 .owner = THIS_MODULE, 591 .name = "aircable", 592 }, 593 .usb_driver = &aircable_driver, 594 .id_table = id_table, 595 .num_ports = 1, 596 .attach = aircable_attach, 597 .probe = aircable_probe, 598 .shutdown = aircable_shutdown, 599 .write = aircable_write, 600 .write_room = aircable_write_room, 601 .write_bulk_callback = aircable_write_bulk_callback, 602 .read_bulk_callback = aircable_read_bulk_callback, 603 .throttle = aircable_throttle, 604 .unthrottle = aircable_unthrottle, 605}; 606 607static int __init aircable_init(void) 608{ 609 int retval; 610 retval = usb_serial_register(&aircable_device); 611 if (retval) 612 goto failed_serial_register; 613 retval = usb_register(&aircable_driver); 614 if (retval) 615 goto failed_usb_register; 616 return 0; 617 618failed_serial_register: 619 usb_serial_deregister(&aircable_device); 620failed_usb_register: 621 return retval; 622} 623 624static void __exit aircable_exit(void) 625{ 626 usb_deregister(&aircable_driver); 627 usb_serial_deregister(&aircable_device); 628} 629 630MODULE_AUTHOR(DRIVER_AUTHOR); 631MODULE_DESCRIPTION(DRIVER_DESC); 632MODULE_VERSION(DRIVER_VERSION); 633MODULE_LICENSE("GPL"); 634 635module_init(aircable_init); 636module_exit(aircable_exit); 637 638module_param(debug, bool, S_IRUGO | S_IWUSR); 639MODULE_PARM_DESC(debug, "Debug enabled or not"); 640