ir-usb.c revision 7dbe2460989b10644651e779b17b683627feea48
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}; 86 87static struct usb_serial_driver ir_device = { 88 .driver = { 89 .owner = THIS_MODULE, 90 .name = "ir-usb", 91 }, 92 .description = "IR Dongle", 93 .id_table = ir_id_table, 94 .num_ports = 1, 95 .set_termios = ir_set_termios, 96 .attach = ir_startup, 97 .open = ir_open, 98 .prepare_write_buffer = ir_prepare_write_buffer, 99 .process_read_urb = ir_process_read_urb, 100}; 101 102static struct usb_serial_driver * const serial_drivers[] = { 103 &ir_device, NULL 104}; 105 106static inline void irda_usb_dump_class_desc(struct usb_irda_cs_descriptor *desc) 107{ 108 dbg("bLength=%x", desc->bLength); 109 dbg("bDescriptorType=%x", desc->bDescriptorType); 110 dbg("bcdSpecRevision=%x", __le16_to_cpu(desc->bcdSpecRevision)); 111 dbg("bmDataSize=%x", desc->bmDataSize); 112 dbg("bmWindowSize=%x", desc->bmWindowSize); 113 dbg("bmMinTurnaroundTime=%d", desc->bmMinTurnaroundTime); 114 dbg("wBaudRate=%x", __le16_to_cpu(desc->wBaudRate)); 115 dbg("bmAdditionalBOFs=%x", desc->bmAdditionalBOFs); 116 dbg("bIrdaRateSniff=%x", desc->bIrdaRateSniff); 117 dbg("bMaxUnicastList=%x", desc->bMaxUnicastList); 118} 119 120/*------------------------------------------------------------------*/ 121/* 122 * Function irda_usb_find_class_desc(dev, ifnum) 123 * 124 * Returns instance of IrDA class descriptor, or NULL if not found 125 * 126 * The class descriptor is some extra info that IrDA USB devices will 127 * offer to us, describing their IrDA characteristics. We will use that in 128 * irda_usb_init_qos() 129 * 130 * Based on the same function in drivers/net/irda/irda-usb.c 131 */ 132static struct usb_irda_cs_descriptor * 133irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum) 134{ 135 struct usb_irda_cs_descriptor *desc; 136 int ret; 137 138 desc = kzalloc(sizeof(*desc), GFP_KERNEL); 139 if (!desc) 140 return NULL; 141 142 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 143 USB_REQ_CS_IRDA_GET_CLASS_DESC, 144 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 145 0, ifnum, desc, sizeof(*desc), 1000); 146 147 dbg("%s - ret=%d", __func__, ret); 148 if (ret < sizeof(*desc)) { 149 dbg("%s - class descriptor read %s (%d)", 150 __func__, 151 (ret < 0) ? "failed" : "too short", 152 ret); 153 goto error; 154 } 155 if (desc->bDescriptorType != USB_DT_CS_IRDA) { 156 dbg("%s - bad class descriptor type", __func__); 157 goto error; 158 } 159 160 irda_usb_dump_class_desc(desc); 161 return desc; 162 163error: 164 kfree(desc); 165 return NULL; 166} 167 168static u8 ir_xbof_change(u8 xbof) 169{ 170 u8 result; 171 172 /* reference irda-usb.c */ 173 switch (xbof) { 174 case 48: 175 result = 0x10; 176 break; 177 case 28: 178 case 24: 179 result = 0x20; 180 break; 181 default: 182 case 12: 183 result = 0x30; 184 break; 185 case 5: 186 case 6: 187 result = 0x40; 188 break; 189 case 3: 190 result = 0x50; 191 break; 192 case 2: 193 result = 0x60; 194 break; 195 case 1: 196 result = 0x70; 197 break; 198 case 0: 199 result = 0x80; 200 break; 201 } 202 203 return(result); 204} 205 206static int ir_startup(struct usb_serial *serial) 207{ 208 struct usb_irda_cs_descriptor *irda_desc; 209 210 irda_desc = irda_usb_find_class_desc(serial->dev, 0); 211 if (!irda_desc) { 212 dev_err(&serial->dev->dev, 213 "IRDA class descriptor not found, device not bound\n"); 214 return -ENODEV; 215 } 216 217 dbg("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s", 218 __func__, 219 (irda_desc->wBaudRate & USB_IRDA_BR_2400) ? " 2400" : "", 220 (irda_desc->wBaudRate & USB_IRDA_BR_9600) ? " 9600" : "", 221 (irda_desc->wBaudRate & USB_IRDA_BR_19200) ? " 19200" : "", 222 (irda_desc->wBaudRate & USB_IRDA_BR_38400) ? " 38400" : "", 223 (irda_desc->wBaudRate & USB_IRDA_BR_57600) ? " 57600" : "", 224 (irda_desc->wBaudRate & USB_IRDA_BR_115200) ? " 115200" : "", 225 (irda_desc->wBaudRate & USB_IRDA_BR_576000) ? " 576000" : "", 226 (irda_desc->wBaudRate & USB_IRDA_BR_1152000) ? " 1152000" : "", 227 (irda_desc->wBaudRate & USB_IRDA_BR_4000000) ? " 4000000" : ""); 228 229 switch (irda_desc->bmAdditionalBOFs) { 230 case USB_IRDA_AB_48: 231 ir_add_bof = 48; 232 break; 233 case USB_IRDA_AB_24: 234 ir_add_bof = 24; 235 break; 236 case USB_IRDA_AB_12: 237 ir_add_bof = 12; 238 break; 239 case USB_IRDA_AB_6: 240 ir_add_bof = 6; 241 break; 242 case USB_IRDA_AB_3: 243 ir_add_bof = 3; 244 break; 245 case USB_IRDA_AB_2: 246 ir_add_bof = 2; 247 break; 248 case USB_IRDA_AB_1: 249 ir_add_bof = 1; 250 break; 251 case USB_IRDA_AB_0: 252 ir_add_bof = 0; 253 break; 254 default: 255 break; 256 } 257 258 kfree(irda_desc); 259 260 return 0; 261} 262 263static int ir_open(struct tty_struct *tty, struct usb_serial_port *port) 264{ 265 int i; 266 267 dbg("%s - port %d", __func__, port->number); 268 269 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 270 port->write_urbs[i]->transfer_flags = URB_ZERO_PACKET; 271 272 /* Start reading from the device */ 273 return usb_serial_generic_open(tty, port); 274} 275 276static int ir_prepare_write_buffer(struct usb_serial_port *port, 277 void *dest, size_t size) 278{ 279 unsigned char *buf = dest; 280 int count; 281 282 /* 283 * The first byte of the packet we send to the device contains an 284 * inbound header which indicates an additional number of BOFs and 285 * a baud rate change. 286 * 287 * See section 5.4.2.2 of the USB IrDA spec. 288 */ 289 *buf = ir_xbof | ir_baud; 290 291 count = kfifo_out_locked(&port->write_fifo, buf + 1, size - 1, 292 &port->lock); 293 return count + 1; 294} 295 296static void ir_process_read_urb(struct urb *urb) 297{ 298 struct usb_serial_port *port = urb->context; 299 unsigned char *data = urb->transfer_buffer; 300 struct tty_struct *tty; 301 302 if (!urb->actual_length) 303 return; 304 /* 305 * The first byte of the packet we get from the device 306 * contains a busy indicator and baud rate change. 307 * See section 5.4.1.2 of the USB IrDA spec. 308 */ 309 if (*data & 0x0f) 310 ir_baud = *data & 0x0f; 311 312 if (urb->actual_length == 1) 313 return; 314 315 tty = tty_port_tty_get(&port->port); 316 if (!tty) 317 return; 318 tty_insert_flip_string(tty, data + 1, urb->actual_length - 1); 319 tty_flip_buffer_push(tty); 320 tty_kref_put(tty); 321} 322 323static void ir_set_termios_callback(struct urb *urb) 324{ 325 struct usb_serial_port *port = urb->context; 326 int status = urb->status; 327 328 dbg("%s - port %d", __func__, port->number); 329 330 kfree(urb->transfer_buffer); 331 332 if (status) 333 dbg("%s - non-zero urb status: %d", __func__, status); 334} 335 336static void ir_set_termios(struct tty_struct *tty, 337 struct usb_serial_port *port, struct ktermios *old_termios) 338{ 339 struct urb *urb; 340 unsigned char *transfer_buffer; 341 int result; 342 speed_t baud; 343 int ir_baud; 344 345 dbg("%s - port %d", __func__, port->number); 346 347 baud = tty_get_baud_rate(tty); 348 349 /* 350 * FIXME, we should compare the baud request against the 351 * capability stated in the IR header that we got in the 352 * startup function. 353 */ 354 355 switch (baud) { 356 case 2400: 357 ir_baud = USB_IRDA_BR_2400; 358 break; 359 case 9600: 360 ir_baud = USB_IRDA_BR_9600; 361 break; 362 case 19200: 363 ir_baud = USB_IRDA_BR_19200; 364 break; 365 case 38400: 366 ir_baud = USB_IRDA_BR_38400; 367 break; 368 case 57600: 369 ir_baud = USB_IRDA_BR_57600; 370 break; 371 case 115200: 372 ir_baud = USB_IRDA_BR_115200; 373 break; 374 case 576000: 375 ir_baud = USB_IRDA_BR_576000; 376 break; 377 case 1152000: 378 ir_baud = USB_IRDA_BR_1152000; 379 break; 380 case 4000000: 381 ir_baud = USB_IRDA_BR_4000000; 382 break; 383 default: 384 ir_baud = USB_IRDA_BR_9600; 385 baud = 9600; 386 } 387 388 if (xbof == -1) 389 ir_xbof = ir_xbof_change(ir_add_bof); 390 else 391 ir_xbof = ir_xbof_change(xbof) ; 392 393 /* Only speed changes are supported */ 394 tty_termios_copy_hw(tty->termios, old_termios); 395 tty_encode_baud_rate(tty, baud, baud); 396 397 /* 398 * send the baud change out on an "empty" data packet 399 */ 400 urb = usb_alloc_urb(0, GFP_KERNEL); 401 if (!urb) { 402 dev_err(&port->dev, "%s - no more urbs\n", __func__); 403 return; 404 } 405 transfer_buffer = kmalloc(1, GFP_KERNEL); 406 if (!transfer_buffer) { 407 dev_err(&port->dev, "%s - out of memory\n", __func__); 408 goto err_buf; 409 } 410 411 *transfer_buffer = ir_xbof | ir_baud; 412 413 usb_fill_bulk_urb( 414 urb, 415 port->serial->dev, 416 usb_sndbulkpipe(port->serial->dev, 417 port->bulk_out_endpointAddress), 418 transfer_buffer, 419 1, 420 ir_set_termios_callback, 421 port); 422 423 urb->transfer_flags = URB_ZERO_PACKET; 424 425 result = usb_submit_urb(urb, GFP_KERNEL); 426 if (result) { 427 dev_err(&port->dev, "%s - failed to submit urb: %d\n", 428 __func__, result); 429 goto err_subm; 430 } 431 432 usb_free_urb(urb); 433 434 return; 435err_subm: 436 kfree(transfer_buffer); 437err_buf: 438 usb_free_urb(urb); 439} 440 441static int __init ir_init(void) 442{ 443 int retval; 444 445 if (buffer_size) { 446 ir_device.bulk_in_size = buffer_size; 447 ir_device.bulk_out_size = buffer_size; 448 } 449 450 retval = usb_serial_register_drivers(&ir_driver, serial_drivers); 451 if (retval == 0) 452 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 453 DRIVER_DESC "\n"); 454 return retval; 455} 456 457static void __exit ir_exit(void) 458{ 459 usb_serial_deregister_drivers(&ir_driver, serial_drivers); 460} 461 462 463module_init(ir_init); 464module_exit(ir_exit); 465 466MODULE_AUTHOR(DRIVER_AUTHOR); 467MODULE_DESCRIPTION(DRIVER_DESC); 468MODULE_LICENSE("GPL"); 469 470module_param(debug, bool, S_IRUGO | S_IWUSR); 471MODULE_PARM_DESC(debug, "Debug enabled or not"); 472module_param(xbof, int, 0); 473MODULE_PARM_DESC(xbof, "Force specific number of XBOFs"); 474module_param(buffer_size, int, 0); 475MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers"); 476 477