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 48 static bool debug; 49 50 /* if overridden by the user, then use their value for the size of the read and 51 * write urbs */ 52 static int buffer_size; 53 54 /* if overridden by the user, then use the specified number of XBOFs */ 55 static int xbof = -1; 56 57 static int ir_startup (struct usb_serial *serial); 58 static int ir_open(struct tty_struct *tty, struct usb_serial_port *port); 59 static int ir_prepare_write_buffer(struct usb_serial_port *port, 60 void *dest, size_t size); 61 static void ir_process_read_urb(struct urb *urb); 62 static 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 */ 66 static u8 ir_baud; 67 static u8 ir_xbof; 68 static u8 ir_add_bof; 69 70 static 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 78 MODULE_DEVICE_TABLE(usb, ir_id_table); 79 80 static struct usb_driver ir_driver = { 81 .name = "ir-usb", 82 .id_table = ir_id_table, 83 }; 84 85 static struct usb_serial_driver ir_device = { 86 .driver = { 87 .owner = THIS_MODULE, 88 .name = "ir-usb", 89 }, 90 .description = "IR Dongle", 91 .id_table = ir_id_table, 92 .num_ports = 1, 93 .set_termios = ir_set_termios, 94 .attach = ir_startup, 95 .open = ir_open, 96 .prepare_write_buffer = ir_prepare_write_buffer, 97 .process_read_urb = ir_process_read_urb, 98 }; 99 100 static struct usb_serial_driver * const serial_drivers[] = { 101 &ir_device, NULL 102 }; 103 104 static 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 */ 130 static struct usb_irda_cs_descriptor * 131 irda_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 161 error: 162 kfree(desc); 163 return NULL; 164 } 165 166 static 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 204 static 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 261 static int ir_open(struct tty_struct *tty, struct usb_serial_port *port) 262 { 263 int i; 264 265 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 266 port->write_urbs[i]->transfer_flags = URB_ZERO_PACKET; 267 268 /* Start reading from the device */ 269 return usb_serial_generic_open(tty, port); 270 } 271 272 static int ir_prepare_write_buffer(struct usb_serial_port *port, 273 void *dest, size_t size) 274 { 275 unsigned char *buf = dest; 276 int count; 277 278 /* 279 * The first byte of the packet we send to the device contains an 280 * inbound header which indicates an additional number of BOFs and 281 * a baud rate change. 282 * 283 * See section 5.4.2.2 of the USB IrDA spec. 284 */ 285 *buf = ir_xbof | ir_baud; 286 287 count = kfifo_out_locked(&port->write_fifo, buf + 1, size - 1, 288 &port->lock); 289 return count + 1; 290 } 291 292 static void ir_process_read_urb(struct urb *urb) 293 { 294 struct usb_serial_port *port = urb->context; 295 unsigned char *data = urb->transfer_buffer; 296 struct tty_struct *tty; 297 298 if (!urb->actual_length) 299 return; 300 /* 301 * The first byte of the packet we get from the device 302 * contains a busy indicator and baud rate change. 303 * See section 5.4.1.2 of the USB IrDA spec. 304 */ 305 if (*data & 0x0f) 306 ir_baud = *data & 0x0f; 307 308 if (urb->actual_length == 1) 309 return; 310 311 tty = tty_port_tty_get(&port->port); 312 if (!tty) 313 return; 314 tty_insert_flip_string(tty, data + 1, urb->actual_length - 1); 315 tty_flip_buffer_push(tty); 316 tty_kref_put(tty); 317 } 318 319 static void ir_set_termios_callback(struct urb *urb) 320 { 321 kfree(urb->transfer_buffer); 322 323 if (urb->status) 324 dbg("%s - non-zero urb status: %d", __func__, urb->status); 325 } 326 327 static void ir_set_termios(struct tty_struct *tty, 328 struct usb_serial_port *port, struct ktermios *old_termios) 329 { 330 struct urb *urb; 331 unsigned char *transfer_buffer; 332 int result; 333 speed_t baud; 334 int ir_baud; 335 336 baud = tty_get_baud_rate(tty); 337 338 /* 339 * FIXME, we should compare the baud request against the 340 * capability stated in the IR header that we got in the 341 * startup function. 342 */ 343 344 switch (baud) { 345 case 2400: 346 ir_baud = USB_IRDA_BR_2400; 347 break; 348 case 9600: 349 ir_baud = USB_IRDA_BR_9600; 350 break; 351 case 19200: 352 ir_baud = USB_IRDA_BR_19200; 353 break; 354 case 38400: 355 ir_baud = USB_IRDA_BR_38400; 356 break; 357 case 57600: 358 ir_baud = USB_IRDA_BR_57600; 359 break; 360 case 115200: 361 ir_baud = USB_IRDA_BR_115200; 362 break; 363 case 576000: 364 ir_baud = USB_IRDA_BR_576000; 365 break; 366 case 1152000: 367 ir_baud = USB_IRDA_BR_1152000; 368 break; 369 case 4000000: 370 ir_baud = USB_IRDA_BR_4000000; 371 break; 372 default: 373 ir_baud = USB_IRDA_BR_9600; 374 baud = 9600; 375 } 376 377 if (xbof == -1) 378 ir_xbof = ir_xbof_change(ir_add_bof); 379 else 380 ir_xbof = ir_xbof_change(xbof) ; 381 382 /* Only speed changes are supported */ 383 tty_termios_copy_hw(tty->termios, old_termios); 384 tty_encode_baud_rate(tty, baud, baud); 385 386 /* 387 * send the baud change out on an "empty" data packet 388 */ 389 urb = usb_alloc_urb(0, GFP_KERNEL); 390 if (!urb) { 391 dev_err(&port->dev, "%s - no more urbs\n", __func__); 392 return; 393 } 394 transfer_buffer = kmalloc(1, GFP_KERNEL); 395 if (!transfer_buffer) { 396 dev_err(&port->dev, "%s - out of memory\n", __func__); 397 goto err_buf; 398 } 399 400 *transfer_buffer = ir_xbof | ir_baud; 401 402 usb_fill_bulk_urb( 403 urb, 404 port->serial->dev, 405 usb_sndbulkpipe(port->serial->dev, 406 port->bulk_out_endpointAddress), 407 transfer_buffer, 408 1, 409 ir_set_termios_callback, 410 port); 411 412 urb->transfer_flags = URB_ZERO_PACKET; 413 414 result = usb_submit_urb(urb, GFP_KERNEL); 415 if (result) { 416 dev_err(&port->dev, "%s - failed to submit urb: %d\n", 417 __func__, result); 418 goto err_subm; 419 } 420 421 usb_free_urb(urb); 422 423 return; 424 err_subm: 425 kfree(transfer_buffer); 426 err_buf: 427 usb_free_urb(urb); 428 } 429 430 static int __init ir_init(void) 431 { 432 int retval; 433 434 if (buffer_size) { 435 ir_device.bulk_in_size = buffer_size; 436 ir_device.bulk_out_size = buffer_size; 437 } 438 439 retval = usb_serial_register_drivers(&ir_driver, serial_drivers); 440 if (retval == 0) 441 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 442 DRIVER_DESC "\n"); 443 return retval; 444 } 445 446 static void __exit ir_exit(void) 447 { 448 usb_serial_deregister_drivers(&ir_driver, serial_drivers); 449 } 450 451 452 module_init(ir_init); 453 module_exit(ir_exit); 454 455 MODULE_AUTHOR(DRIVER_AUTHOR); 456 MODULE_DESCRIPTION(DRIVER_DESC); 457 MODULE_LICENSE("GPL"); 458 459 module_param(debug, bool, S_IRUGO | S_IWUSR); 460 MODULE_PARM_DESC(debug, "Debug enabled or not"); 461 module_param(xbof, int, 0); 462 MODULE_PARM_DESC(xbof, "Force specific number of XBOFs"); 463 module_param(buffer_size, int, 0); 464 MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers"); 465 466