4 * Copyright (C) 2001-2002 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2002 Gary Brubaker (xavyer@ix.netcom.com)
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver allows a USB IrDA device to be used as a "dumb" serial device.
13 * This can be useful if you do not have access to a full IrDA stack on the
14 * other side of the connection. If you do have an IrDA stack on both devices,
15 * please use the usb-irda driver, as it contains the proper error checking and
16 * other goodness of a full IrDA stack.
18 * Portions of this driver were taken from drivers/net/irda/irda-usb.c, which
19 * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli
20 * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com>
22 * See Documentation/usb/usb-serial.txt for more information on using this driver
25 * moved some needed structures and #define values from the
26 * net/irda/irda-usb.h file into our file, as we don't want to depend on
27 * that codebase compiling correctly :)
30 * Added module parameter to force specific number of XBOFs.
31 * Added ir_xbof_change().
32 * Reorganized read_bulk_callback error handling.
33 * Switched from FILL_BULK_URB() to usb_fill_bulk_urb().
36 * Changed the irda_usb_find_class_desc() function based on comments and
37 * code from Martin Diehl.
40 * Added support for more IrDA USB devices.
41 * Added support for zero packet. Added buffer override paramater, so
42 * users can transfer larger packets at once if they wish. Both patches
43 * came from Dag Brattli <dag@obexcode.com>.
46 * initial version released.
49 #include <linux/config.h>
50 #include <linux/kernel.h>
51 #include <linux/errno.h>
52 #include <linux/init.h>
53 #include <linux/slab.h>
54 #include <linux/tty.h>
55 #include <linux/tty_driver.h>
56 #include <linux/tty_flip.h>
57 #include <linux/module.h>
58 #include <linux/spinlock.h>
59 #include <asm/uaccess.h>
60 #include <linux/usb.h>
62 #ifdef CONFIG_USB_SERIAL_DEBUG
68 #include "usb-serial.h"
73 #define DRIVER_VERSION "v0.4"
74 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
75 #define DRIVER_DESC "USB IR Dongle driver"
77 /* USB IrDA class spec information */
78 #define USB_CLASS_IRDA 0x02
79 #define USB_DT_IRDA 0x21
80 #define IU_REQ_GET_CLASS_DESC 0x06
81 #define SPEED_2400 0x01
82 #define SPEED_9600 0x02
83 #define SPEED_19200 0x03
84 #define SPEED_38400 0x04
85 #define SPEED_57600 0x05
86 #define SPEED_115200 0x06
87 #define SPEED_576000 0x07
88 #define SPEED_1152000 0x08
89 #define SPEED_4000000 0x09
91 struct irda_class_desc {
97 u8 bmMinTurnaroundTime;
102 } __attribute__ ((packed));
104 /* if overridden by the user, then use their value for the size of the read and
106 static int buffer_size = 0;
107 /* if overridden by the user, then use the specified number of XBOFs */
108 static int xbof = -1;
110 static int ir_startup (struct usb_serial *serial);
111 static int ir_open (struct usb_serial_port *port, struct file *filep);
112 static void ir_close (struct usb_serial_port *port, struct file *filep);
113 static int ir_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
114 static void ir_write_bulk_callback (struct urb *urb);
115 static void ir_read_bulk_callback (struct urb *urb);
116 static void ir_set_termios (struct usb_serial_port *port, struct termios *old_termios);
118 static u8 ir_baud = 0;
119 static u8 ir_xbof = 0;
120 static u8 ir_add_bof = 0;
122 static struct usb_device_id id_table [] = {
123 { USB_DEVICE(0x050f, 0x0180) }, /* KC Technology, KC-180 */
124 { USB_DEVICE(0x08e9, 0x0100) }, /* XTNDAccess */
125 { USB_DEVICE(0x09c4, 0x0011) }, /* ACTiSys ACT-IR2000U */
126 { USB_INTERFACE_INFO (USB_CLASS_APP_SPEC, USB_CLASS_IRDA, 0) },
127 { } /* Terminating entry */
130 MODULE_DEVICE_TABLE (usb, id_table);
133 struct usb_serial_device_type ir_device = {
134 .owner = THIS_MODULE,
136 .id_table = id_table,
137 .num_interrupt_in = 1,
141 .set_termios = ir_set_termios,
142 .startup = ir_startup,
146 .write_bulk_callback = ir_write_bulk_callback,
147 .read_bulk_callback = ir_read_bulk_callback,
150 static inline void irda_usb_dump_class_desc(struct irda_class_desc *desc)
152 dbg("bLength=%x", desc->bLength);
153 dbg("bDescriptorType=%x", desc->bDescriptorType);
154 dbg("bcdSpecRevision=%x", desc->bcdSpecRevision);
155 dbg("bmDataSize=%x", desc->bmDataSize);
156 dbg("bmWindowSize=%x", desc->bmWindowSize);
157 dbg("bmMinTurnaroundTime=%d", desc->bmMinTurnaroundTime);
158 dbg("wBaudRate=%x", desc->wBaudRate);
159 dbg("bmAdditionalBOFs=%x", desc->bmAdditionalBOFs);
160 dbg("bIrdaRateSniff=%x", desc->bIrdaRateSniff);
161 dbg("bMaxUnicastList=%x", desc->bMaxUnicastList);
164 /*------------------------------------------------------------------*/
166 * Function irda_usb_find_class_desc(dev, ifnum)
168 * Returns instance of IrDA class descriptor, or NULL if not found
170 * The class descriptor is some extra info that IrDA USB devices will
171 * offer to us, describing their IrDA characteristics. We will use that in
172 * irda_usb_init_qos()
174 * Based on the same function in drivers/net/irda/irda-usb.c
176 static struct irda_class_desc *irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum)
178 struct irda_class_desc *desc;
181 desc = kmalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
184 memset(desc, 0, sizeof(struct irda_class_desc));
186 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
187 IU_REQ_GET_CLASS_DESC,
188 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
189 0, ifnum, desc, sizeof(*desc), HZ);
191 dbg("%s - ret=%d", __FUNCTION__, ret);
192 if (ret < sizeof(*desc)) {
193 dbg("%s - class descriptor read %s (%d)",
195 (ret<0) ? "failed" : "too short",
199 if (desc->bDescriptorType != USB_DT_IRDA) {
200 dbg("%s - bad class descriptor type", __FUNCTION__);
204 irda_usb_dump_class_desc(desc);
212 static u8 ir_xbof_change(u8 xbof)
215 /* reference irda-usb.c */
217 case 48: result = 0x10; break;
219 case 24: result = 0x20; break;
221 case 12: result = 0x30; break;
223 case 6: result = 0x40; break;
224 case 3: result = 0x50; break;
225 case 2: result = 0x60; break;
226 case 1: result = 0x70; break;
227 case 0: result = 0x80; break;
233 static int ir_startup (struct usb_serial *serial)
235 struct irda_class_desc *irda_desc;
237 irda_desc = irda_usb_find_class_desc (serial->dev, 0);
238 if (irda_desc == NULL) {
239 err ("IRDA class descriptor not found, device not bound");
243 dbg ("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s",
245 (irda_desc->wBaudRate & 0x0001) ? " 2400" : "",
246 (irda_desc->wBaudRate & 0x0002) ? " 9600" : "",
247 (irda_desc->wBaudRate & 0x0004) ? " 19200" : "",
248 (irda_desc->wBaudRate & 0x0008) ? " 38400" : "",
249 (irda_desc->wBaudRate & 0x0010) ? " 57600" : "",
250 (irda_desc->wBaudRate & 0x0020) ? " 115200" : "",
251 (irda_desc->wBaudRate & 0x0040) ? " 576000" : "",
252 (irda_desc->wBaudRate & 0x0080) ? " 1152000" : "",
253 (irda_desc->wBaudRate & 0x0100) ? " 4000000" : "");
255 switch( irda_desc->bmAdditionalBOFs ) {
256 case 0x01: ir_add_bof = 48; break;
257 case 0x02: ir_add_bof = 24; break;
258 case 0x04: ir_add_bof = 12; break;
259 case 0x08: ir_add_bof = 6; break;
260 case 0x10: ir_add_bof = 3; break;
261 case 0x20: ir_add_bof = 2; break;
262 case 0x40: ir_add_bof = 1; break;
263 case 0x80: ir_add_bof = 0; break;
272 static int ir_open (struct usb_serial_port *port, struct file *filp)
274 struct usb_serial *serial = port->serial;
278 if (port_paranoia_check (port, __FUNCTION__))
281 dbg("%s - port %d", __FUNCTION__, port->number);
284 /* override the default buffer sizes */
285 buffer = kmalloc (buffer_size, GFP_KERNEL);
287 err ("%s - out of memory.", __FUNCTION__);
290 kfree (port->read_urb->transfer_buffer);
291 port->read_urb->transfer_buffer = buffer;
292 port->read_urb->transfer_buffer_length = buffer_size;
294 buffer = kmalloc (buffer_size, GFP_KERNEL);
296 err ("%s - out of memory.", __FUNCTION__);
299 kfree (port->write_urb->transfer_buffer);
300 port->write_urb->transfer_buffer = buffer;
301 port->write_urb->transfer_buffer_length = buffer_size;
302 port->bulk_out_size = buffer_size;
305 /* Start reading from the device */
309 usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
310 port->read_urb->transfer_buffer,
311 port->read_urb->transfer_buffer_length,
312 ir_read_bulk_callback,
314 port->read_urb->transfer_flags = USB_QUEUE_BULK;
315 result = usb_submit_urb(port->read_urb);
317 err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
322 static void ir_close (struct usb_serial_port *port, struct file * filp)
324 struct usb_serial *serial;
326 if (port_paranoia_check (port, __FUNCTION__))
329 dbg("%s - port %d", __FUNCTION__, port->number);
331 serial = get_usb_serial (port, __FUNCTION__);
336 /* shutdown our bulk read */
337 usb_unlink_urb (port->read_urb);
341 static int ir_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count)
343 unsigned char *transfer_buffer;
347 dbg("%s - port = %d, count = %d", __FUNCTION__, port->number, count);
350 err ("%s - no tty???", __FUNCTION__);
357 if (port->write_urb->status == -EINPROGRESS) {
358 dbg ("%s - already writing", __FUNCTION__);
362 transfer_buffer = port->write_urb->transfer_buffer;
363 transfer_size = min(count, port->bulk_out_size - 1);
366 * The first byte of the packet we send to the device contains an
367 * inband header which indicates an additional number of BOFs and
368 * a baud rate change.
370 * See section 5.4.2.2 of the USB IrDA spec.
372 *transfer_buffer = ir_xbof | ir_baud;
376 if (copy_from_user (transfer_buffer, buf, transfer_size))
379 memcpy (transfer_buffer, buf, transfer_size);
385 usb_sndbulkpipe(port->serial->dev,
386 port->bulk_out_endpointAddress),
387 port->write_urb->transfer_buffer,
389 ir_write_bulk_callback,
392 port->write_urb->transfer_flags
396 result = usb_submit_urb (port->write_urb);
398 err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
400 result = transfer_size;
405 static void ir_write_bulk_callback (struct urb *urb)
407 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
409 if (port_paranoia_check (port, __FUNCTION__))
412 dbg("%s - port %d", __FUNCTION__, port->number);
415 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
419 usb_serial_debug_data (
423 urb->transfer_buffer);
425 queue_task(&port->tqueue, &tq_immediate);
426 mark_bh(IMMEDIATE_BH);
431 static void ir_read_bulk_callback (struct urb *urb)
433 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
434 struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
435 struct tty_struct *tty;
436 unsigned char *data = urb->transfer_buffer;
439 if (port_paranoia_check (port, __FUNCTION__))
442 dbg("%s - port %d", __FUNCTION__, port->number);
445 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
449 if (!port->open_count) {
450 dbg("%s - port closed.", __FUNCTION__);
454 switch (urb->status) {
456 case 0: /* Successful */
459 * The first byte of the packet we get from the device
460 * contains a busy indicator and baud rate change.
461 * See section 5.4.1.2 of the USB IrDA spec.
463 if((*data & 0x0f) > 0) ir_baud = *data & 0x0f;
465 usb_serial_debug_data (
472 * Bypass flip-buffers, and feed the ldisc directly
473 * due to our potentally large buffer size. Since we
474 * used to set low_latency, this is exactly what the
475 * tty layer did anyway :)
479 tty->ldisc.receive_buf(
483 urb->actual_length-1);
487 * We want to resubmit the urb so we can read
491 case -EPROTO: /* taking inspiration from pl2303.c */
493 /* Continue trying to always read */
497 usb_rcvbulkpipe(serial->dev,
498 port->bulk_in_endpointAddress),
499 port->read_urb->transfer_buffer,
500 port->read_urb->transfer_buffer_length,
501 ir_read_bulk_callback,
504 port->read_urb->transfer_flags = USB_QUEUE_BULK;
506 result = usb_submit_urb(port->read_urb);
509 err("%s - failed resubmitting read urb, error %d",
516 dbg("%s - nonzero read bulk status received: %d",
526 static void ir_set_termios (struct usb_serial_port *port, struct termios *old_termios)
528 unsigned char *transfer_buffer;
532 dbg("%s - port %d", __FUNCTION__, port->number);
534 if ((!port->tty) || (!port->tty->termios)) {
535 dbg("%s - no tty structures", __FUNCTION__);
539 cflag = port->tty->termios->c_cflag;
540 /* check that they really want us to change something */
542 if ((cflag == old_termios->c_cflag) &&
543 (RELEVANT_IFLAG(port->tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) {
544 dbg("%s - nothing to change...", __FUNCTION__);
549 /* All we can change is the baud rate */
552 dbg ("%s - asking for baud %d",
554 tty_get_baud_rate(port->tty));
557 * FIXME, we should compare the baud request against the
558 * capability stated in the IR header that we got in the
561 switch (cflag & CBAUD) {
562 case B2400: ir_baud = SPEED_2400; break;
564 case B9600: ir_baud = SPEED_9600; break;
565 case B19200: ir_baud = SPEED_19200; break;
566 case B38400: ir_baud = SPEED_38400; break;
567 case B57600: ir_baud = SPEED_57600; break;
568 case B115200: ir_baud = SPEED_115200; break;
569 case B576000: ir_baud = SPEED_576000; break;
570 case B1152000: ir_baud = SPEED_1152000; break;
572 case B4000000: ir_baud = SPEED_4000000; break;
577 ir_xbof = ir_xbof_change(ir_add_bof);
579 ir_xbof = ir_xbof_change(xbof) ;
582 /* Notify the tty driver that the termios have changed. */
583 port->tty->ldisc.set_termios(port->tty, NULL);
585 /* FIXME need to check to see if our write urb is busy right
586 * now, or use a urb pool.
588 * send the baud change out on an "empty" data packet
590 transfer_buffer = port->write_urb->transfer_buffer;
591 *transfer_buffer = ir_xbof | ir_baud;
596 usb_sndbulkpipe(port->serial->dev,
597 port->bulk_out_endpointAddress),
598 port->write_urb->transfer_buffer,
600 ir_write_bulk_callback,
603 port->write_urb->transfer_flags
607 result = usb_submit_urb (port->write_urb);
609 err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
615 static int __init ir_init (void)
617 usb_serial_register (&ir_device);
618 info(DRIVER_DESC " " DRIVER_VERSION);
623 static void __exit ir_exit (void)
625 usb_serial_deregister (&ir_device);
629 module_init(ir_init);
630 module_exit(ir_exit);
632 MODULE_AUTHOR(DRIVER_AUTHOR);
633 MODULE_DESCRIPTION(DRIVER_DESC);
634 MODULE_LICENSE("GPL");
636 MODULE_PARM(debug, "i");
637 MODULE_PARM_DESC(debug, "Debug enabled or not");
638 MODULE_PARM(xbof, "i");
639 MODULE_PARM_DESC(xbof, "Force specific number of XBOFs");
640 MODULE_PARM(buffer_size, "i");
641 MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers");