ir-usb.c revision 90ab5ee94171b3e28de6bb42ee30b527014e0be7
1/* 2 * USB IR Dongle driver 3 * 4 * Copyright (C) 2001-2002 Greg Kroah-Hartman (greg@kroah.com) 5 * Copyright (C) 2002 Gary Brubaker (xavyer@ix.netcom.com) 6 * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) 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 driver allows a USB IrDA device to be used as a "dumb" serial device. 14 * This can be useful if you do not have access to a full IrDA stack on the 15 * other side of the connection. If you do have an IrDA stack on both devices, 16 * please use the usb-irda driver, as it contains the proper error checking and 17 * other goodness of a full IrDA stack. 18 * 19 * Portions of this driver were taken from drivers/net/irda/irda-usb.c, which 20 * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli 21 * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com> 22 * 23 * See Documentation/usb/usb-serial.txt for more information on using this 24 * driver 25 */ 26 27#include <linux/kernel.h> 28#include <linux/errno.h> 29#include <linux/init.h> 30#include <linux/slab.h> 31#include <linux/tty.h> 32#include <linux/tty_driver.h> 33#include <linux/tty_flip.h> 34#include <linux/module.h> 35#include <linux/spinlock.h> 36#include <linux/uaccess.h> 37#include <linux/usb.h> 38#include <linux/usb/serial.h> 39#include <linux/usb/irda.h> 40 41/* 42 * Version Information 43 */ 44#define DRIVER_VERSION "v0.5" 45#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Johan Hovold <jhovold@gmail.com>" 46#define DRIVER_DESC "USB IR Dongle driver" 47 48static bool debug; 49 50/* if overridden by the user, then use their value for the size of the read and 51 * write urbs */ 52static int buffer_size; 53 54/* if overridden by the user, then use the specified number of XBOFs */ 55static int xbof = -1; 56 57static int ir_startup (struct usb_serial *serial); 58static int ir_open(struct tty_struct *tty, struct usb_serial_port *port); 59static int ir_prepare_write_buffer(struct usb_serial_port *port, 60 void *dest, size_t size); 61static void ir_process_read_urb(struct urb *urb); 62static void ir_set_termios(struct tty_struct *tty, 63 struct usb_serial_port *port, struct ktermios *old_termios); 64 65/* Not that this lot means you can only have one per system */ 66static u8 ir_baud; 67static u8 ir_xbof; 68static u8 ir_add_bof; 69 70static const struct usb_device_id ir_id_table[] = { 71 { USB_DEVICE(0x050f, 0x0180) }, /* KC Technology, KC-180 */ 72 { USB_DEVICE(0x08e9, 0x0100) }, /* XTNDAccess */ 73 { USB_DEVICE(0x09c4, 0x0011) }, /* ACTiSys ACT-IR2000U */ 74 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, USB_SUBCLASS_IRDA, 0) }, 75 { } /* Terminating entry */ 76}; 77 78MODULE_DEVICE_TABLE(usb, ir_id_table); 79 80static struct usb_driver ir_driver = { 81 .name = "ir-usb", 82 .probe = usb_serial_probe, 83 .disconnect = usb_serial_disconnect, 84 .id_table = ir_id_table, 85 .no_dynamic_id = 1, 86}; 87 88static struct usb_serial_driver ir_device = { 89 .driver = { 90 .owner = THIS_MODULE, 91 .name = "ir-usb", 92 }, 93 .description = "IR Dongle", 94 .usb_driver = &ir_driver, 95 .id_table = ir_id_table, 96 .num_ports = 1, 97 .set_termios = ir_set_termios, 98 .attach = ir_startup, 99 .open = ir_open, 100 .prepare_write_buffer = ir_prepare_write_buffer, 101 .process_read_urb = ir_process_read_urb, 102}; 103 104static inline void irda_usb_dump_class_desc(struct usb_irda_cs_descriptor *desc) 105{ 106 dbg("bLength=%x", desc->bLength); 107 dbg("bDescriptorType=%x", desc->bDescriptorType); 108 dbg("bcdSpecRevision=%x", __le16_to_cpu(desc->bcdSpecRevision)); 109 dbg("bmDataSize=%x", desc->bmDataSize); 110 dbg("bmWindowSize=%x", desc->bmWindowSize); 111 dbg("bmMinTurnaroundTime=%d", desc->bmMinTurnaroundTime); 112 dbg("wBaudRate=%x", __le16_to_cpu(desc->wBaudRate)); 113 dbg("bmAdditionalBOFs=%x", desc->bmAdditionalBOFs); 114 dbg("bIrdaRateSniff=%x", desc->bIrdaRateSniff); 115 dbg("bMaxUnicastList=%x", desc->bMaxUnicastList); 116} 117 118/*------------------------------------------------------------------*/ 119/* 120 * Function irda_usb_find_class_desc(dev, ifnum) 121 * 122 * Returns instance of IrDA class descriptor, or NULL if not found 123 * 124 * The class descriptor is some extra info that IrDA USB devices will 125 * offer to us, describing their IrDA characteristics. We will use that in 126 * irda_usb_init_qos() 127 * 128 * Based on the same function in drivers/net/irda/irda-usb.c 129 */ 130static struct usb_irda_cs_descriptor * 131irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum) 132{ 133 struct usb_irda_cs_descriptor *desc; 134 int ret; 135 136 desc = kzalloc(sizeof(*desc), GFP_KERNEL); 137 if (!desc) 138 return NULL; 139 140 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 141 USB_REQ_CS_IRDA_GET_CLASS_DESC, 142 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 143 0, ifnum, desc, sizeof(*desc), 1000); 144 145 dbg("%s - ret=%d", __func__, ret); 146 if (ret < sizeof(*desc)) { 147 dbg("%s - class descriptor read %s (%d)", 148 __func__, 149 (ret < 0) ? "failed" : "too short", 150 ret); 151 goto error; 152 } 153 if (desc->bDescriptorType != USB_DT_CS_IRDA) { 154 dbg("%s - bad class descriptor type", __func__); 155 goto error; 156 } 157 158 irda_usb_dump_class_desc(desc); 159 return desc; 160 161error: 162 kfree(desc); 163 return NULL; 164} 165 166static u8 ir_xbof_change(u8 xbof) 167{ 168 u8 result; 169 170 /* reference irda-usb.c */ 171 switch (xbof) { 172 case 48: 173 result = 0x10; 174 break; 175 case 28: 176 case 24: 177 result = 0x20; 178 break; 179 default: 180 case 12: 181 result = 0x30; 182 break; 183 case 5: 184 case 6: 185 result = 0x40; 186 break; 187 case 3: 188 result = 0x50; 189 break; 190 case 2: 191 result = 0x60; 192 break; 193 case 1: 194 result = 0x70; 195 break; 196 case 0: 197 result = 0x80; 198 break; 199 } 200 201 return(result); 202} 203 204static int ir_startup(struct usb_serial *serial) 205{ 206 struct usb_irda_cs_descriptor *irda_desc; 207 208 irda_desc = irda_usb_find_class_desc(serial->dev, 0); 209 if (!irda_desc) { 210 dev_err(&serial->dev->dev, 211 "IRDA class descriptor not found, device not bound\n"); 212 return -ENODEV; 213 } 214 215 dbg("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s", 216 __func__, 217 (irda_desc->wBaudRate & USB_IRDA_BR_2400) ? " 2400" : "", 218 (irda_desc->wBaudRate & USB_IRDA_BR_9600) ? " 9600" : "", 219 (irda_desc->wBaudRate & USB_IRDA_BR_19200) ? " 19200" : "", 220 (irda_desc->wBaudRate & USB_IRDA_BR_38400) ? " 38400" : "", 221 (irda_desc->wBaudRate & USB_IRDA_BR_57600) ? " 57600" : "", 222 (irda_desc->wBaudRate & USB_IRDA_BR_115200) ? " 115200" : "", 223 (irda_desc->wBaudRate & USB_IRDA_BR_576000) ? " 576000" : "", 224 (irda_desc->wBaudRate & USB_IRDA_BR_1152000) ? " 1152000" : "", 225 (irda_desc->wBaudRate & USB_IRDA_BR_4000000) ? " 4000000" : ""); 226 227 switch (irda_desc->bmAdditionalBOFs) { 228 case USB_IRDA_AB_48: 229 ir_add_bof = 48; 230 break; 231 case USB_IRDA_AB_24: 232 ir_add_bof = 24; 233 break; 234 case USB_IRDA_AB_12: 235 ir_add_bof = 12; 236 break; 237 case USB_IRDA_AB_6: 238 ir_add_bof = 6; 239 break; 240 case USB_IRDA_AB_3: 241 ir_add_bof = 3; 242 break; 243 case USB_IRDA_AB_2: 244 ir_add_bof = 2; 245 break; 246 case USB_IRDA_AB_1: 247 ir_add_bof = 1; 248 break; 249 case USB_IRDA_AB_0: 250 ir_add_bof = 0; 251 break; 252 default: 253 break; 254 } 255 256 kfree(irda_desc); 257 258 return 0; 259} 260 261static int ir_open(struct tty_struct *tty, struct usb_serial_port *port) 262{ 263 int i; 264 265 dbg("%s - port %d", __func__, port->number); 266 267 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 268 port->write_urbs[i]->transfer_flags = URB_ZERO_PACKET; 269 270 /* Start reading from the device */ 271 return usb_serial_generic_open(tty, port); 272} 273 274static int ir_prepare_write_buffer(struct usb_serial_port *port, 275 void *dest, size_t size) 276{ 277 unsigned char *buf = dest; 278 int count; 279 280 /* 281 * The first byte of the packet we send to the device contains an 282 * inbound header which indicates an additional number of BOFs and 283 * a baud rate change. 284 * 285 * See section 5.4.2.2 of the USB IrDA spec. 286 */ 287 *buf = ir_xbof | ir_baud; 288 289 count = kfifo_out_locked(&port->write_fifo, buf + 1, size - 1, 290 &port->lock); 291 return count + 1; 292} 293 294static void ir_process_read_urb(struct urb *urb) 295{ 296 struct usb_serial_port *port = urb->context; 297 unsigned char *data = urb->transfer_buffer; 298 struct tty_struct *tty; 299 300 if (!urb->actual_length) 301 return; 302 /* 303 * The first byte of the packet we get from the device 304 * contains a busy indicator and baud rate change. 305 * See section 5.4.1.2 of the USB IrDA spec. 306 */ 307 if (*data & 0x0f) 308 ir_baud = *data & 0x0f; 309 310 if (urb->actual_length == 1) 311 return; 312 313 tty = tty_port_tty_get(&port->port); 314 if (!tty) 315 return; 316 tty_insert_flip_string(tty, data + 1, urb->actual_length - 1); 317 tty_flip_buffer_push(tty); 318 tty_kref_put(tty); 319} 320 321static void ir_set_termios_callback(struct urb *urb) 322{ 323 struct usb_serial_port *port = urb->context; 324 int status = urb->status; 325 326 dbg("%s - port %d", __func__, port->number); 327 328 kfree(urb->transfer_buffer); 329 330 if (status) 331 dbg("%s - non-zero urb status: %d", __func__, status); 332} 333 334static void ir_set_termios(struct tty_struct *tty, 335 struct usb_serial_port *port, struct ktermios *old_termios) 336{ 337 struct urb *urb; 338 unsigned char *transfer_buffer; 339 int result; 340 speed_t baud; 341 int ir_baud; 342 343 dbg("%s - port %d", __func__, port->number); 344 345 baud = tty_get_baud_rate(tty); 346 347 /* 348 * FIXME, we should compare the baud request against the 349 * capability stated in the IR header that we got in the 350 * startup function. 351 */ 352 353 switch (baud) { 354 case 2400: 355 ir_baud = USB_IRDA_BR_2400; 356 break; 357 case 9600: 358 ir_baud = USB_IRDA_BR_9600; 359 break; 360 case 19200: 361 ir_baud = USB_IRDA_BR_19200; 362 break; 363 case 38400: 364 ir_baud = USB_IRDA_BR_38400; 365 break; 366 case 57600: 367 ir_baud = USB_IRDA_BR_57600; 368 break; 369 case 115200: 370 ir_baud = USB_IRDA_BR_115200; 371 break; 372 case 576000: 373 ir_baud = USB_IRDA_BR_576000; 374 break; 375 case 1152000: 376 ir_baud = USB_IRDA_BR_1152000; 377 break; 378 case 4000000: 379 ir_baud = USB_IRDA_BR_4000000; 380 break; 381 default: 382 ir_baud = USB_IRDA_BR_9600; 383 baud = 9600; 384 } 385 386 if (xbof == -1) 387 ir_xbof = ir_xbof_change(ir_add_bof); 388 else 389 ir_xbof = ir_xbof_change(xbof) ; 390 391 /* Only speed changes are supported */ 392 tty_termios_copy_hw(tty->termios, old_termios); 393 tty_encode_baud_rate(tty, baud, baud); 394 395 /* 396 * send the baud change out on an "empty" data packet 397 */ 398 urb = usb_alloc_urb(0, GFP_KERNEL); 399 if (!urb) { 400 dev_err(&port->dev, "%s - no more urbs\n", __func__); 401 return; 402 } 403 transfer_buffer = kmalloc(1, GFP_KERNEL); 404 if (!transfer_buffer) { 405 dev_err(&port->dev, "%s - out of memory\n", __func__); 406 goto err_buf; 407 } 408 409 *transfer_buffer = ir_xbof | ir_baud; 410 411 usb_fill_bulk_urb( 412 urb, 413 port->serial->dev, 414 usb_sndbulkpipe(port->serial->dev, 415 port->bulk_out_endpointAddress), 416 transfer_buffer, 417 1, 418 ir_set_termios_callback, 419 port); 420 421 urb->transfer_flags = URB_ZERO_PACKET; 422 423 result = usb_submit_urb(urb, GFP_KERNEL); 424 if (result) { 425 dev_err(&port->dev, "%s - failed to submit urb: %d\n", 426 __func__, result); 427 goto err_subm; 428 } 429 430 usb_free_urb(urb); 431 432 return; 433err_subm: 434 kfree(transfer_buffer); 435err_buf: 436 usb_free_urb(urb); 437} 438 439static int __init ir_init(void) 440{ 441 int retval; 442 443 if (buffer_size) { 444 ir_device.bulk_in_size = buffer_size; 445 ir_device.bulk_out_size = buffer_size; 446 } 447 448 retval = usb_serial_register(&ir_device); 449 if (retval) 450 goto failed_usb_serial_register; 451 452 retval = usb_register(&ir_driver); 453 if (retval) 454 goto failed_usb_register; 455 456 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 457 DRIVER_DESC "\n"); 458 459 return 0; 460 461failed_usb_register: 462 usb_serial_deregister(&ir_device); 463 464failed_usb_serial_register: 465 return retval; 466} 467 468static void __exit ir_exit(void) 469{ 470 usb_deregister(&ir_driver); 471 usb_serial_deregister(&ir_device); 472} 473 474 475module_init(ir_init); 476module_exit(ir_exit); 477 478MODULE_AUTHOR(DRIVER_AUTHOR); 479MODULE_DESCRIPTION(DRIVER_DESC); 480MODULE_LICENSE("GPL"); 481 482module_param(debug, bool, S_IRUGO | S_IWUSR); 483MODULE_PARM_DESC(debug, "Debug enabled or not"); 484module_param(xbof, int, 0); 485MODULE_PARM_DESC(xbof, "Force specific number of XBOFs"); 486module_param(buffer_size, int, 0); 487MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers"); 488 489