[deliverable/linux.git] / drivers / usb / serial / ir-usb.c

/*
 * USB IR Dongle driver
 *
 *	Copyright (C) 2001-2002	Greg Kroah-Hartman (greg@kroah.com)
 *	Copyright (C) 2002	Gary Brubaker (xavyer@ix.netcom.com)
 *	Copyright (C) 2010	Johan Hovold (jhovold@gmail.com)
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *
 * This driver allows a USB IrDA device to be used as a "dumb" serial device.
 * This can be useful if you do not have access to a full IrDA stack on the
 * other side of the connection.  If you do have an IrDA stack on both devices,
 * please use the usb-irda driver, as it contains the proper error checking and
 * other goodness of a full IrDA stack.
 *
 * Portions of this driver were taken from drivers/net/irda/irda-usb.c, which
 * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli
 * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com>
 *
 * See Documentation/usb/usb-serial.txt for more information on using this
 * driver
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/usb/irda.h>

#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Johan Hovold <jhovold@gmail.com>"
#define DRIVER_DESC "USB IR Dongle driver"

/* if overridden by the user, then use their value for the size of the read and
 * write urbs */
static int buffer_size;

/* if overridden by the user, then use the specified number of XBOFs */
static int xbof = -1;

static int  ir_startup (struct usb_serial *serial);
static int  ir_open(struct tty_struct *tty, struct usb_serial_port *port);
static int ir_prepare_write_buffer(struct usb_serial_port *port,
						void *dest, size_t size);
static void ir_process_read_urb(struct urb *urb);
static void ir_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios);

/* Not that this lot means you can only have one per system */
static u8 ir_baud;
static u8 ir_xbof;
static u8 ir_add_bof;

static const struct usb_device_id ir_id_table[] = {
	{ USB_DEVICE(0x050f, 0x0180) },		/* KC Technology, KC-180 */
	{ USB_DEVICE(0x08e9, 0x0100) },		/* XTNDAccess */
	{ USB_DEVICE(0x09c4, 0x0011) },		/* ACTiSys ACT-IR2000U */
	{ USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, USB_SUBCLASS_IRDA, 0) },
	{ }					/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, ir_id_table);

static struct usb_serial_driver ir_device = {
	.driver	= {
		.owner	= THIS_MODULE,
		.name	= "ir-usb",
	},
	.description		= "IR Dongle",
	.id_table		= ir_id_table,
	.num_ports		= 1,
	.set_termios		= ir_set_termios,
	.attach			= ir_startup,
	.open			= ir_open,
	.prepare_write_buffer	= ir_prepare_write_buffer,
	.process_read_urb	= ir_process_read_urb,
};

static struct usb_serial_driver * const serial_drivers[] = {
	&ir_device, NULL
};

static inline void irda_usb_dump_class_desc(struct usb_serial *serial,
					    struct usb_irda_cs_descriptor *desc)
{
	struct device *dev = &serial->dev->dev;

	dev_dbg(dev, "bLength=%x\n", desc->bLength);
	dev_dbg(dev, "bDescriptorType=%x\n", desc->bDescriptorType);
	dev_dbg(dev, "bcdSpecRevision=%x\n", __le16_to_cpu(desc->bcdSpecRevision));
	dev_dbg(dev, "bmDataSize=%x\n", desc->bmDataSize);
	dev_dbg(dev, "bmWindowSize=%x\n", desc->bmWindowSize);
	dev_dbg(dev, "bmMinTurnaroundTime=%d\n", desc->bmMinTurnaroundTime);
	dev_dbg(dev, "wBaudRate=%x\n", __le16_to_cpu(desc->wBaudRate));
	dev_dbg(dev, "bmAdditionalBOFs=%x\n", desc->bmAdditionalBOFs);
	dev_dbg(dev, "bIrdaRateSniff=%x\n", desc->bIrdaRateSniff);
	dev_dbg(dev, "bMaxUnicastList=%x\n", desc->bMaxUnicastList);
}

/*------------------------------------------------------------------*/
/*
 * Function irda_usb_find_class_desc(dev, ifnum)
 *
 *    Returns instance of IrDA class descriptor, or NULL if not found
 *
 * The class descriptor is some extra info that IrDA USB devices will
 * offer to us, describing their IrDA characteristics. We will use that in
 * irda_usb_init_qos()
 *
 * Based on the same function in drivers/net/irda/irda-usb.c
 */
static struct usb_irda_cs_descriptor *
irda_usb_find_class_desc(struct usb_serial *serial, unsigned int ifnum)
{
	struct usb_device *dev = serial->dev;
	struct usb_irda_cs_descriptor *desc;
	int ret;

	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
	if (!desc)
		return NULL;

	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			USB_REQ_CS_IRDA_GET_CLASS_DESC,
			USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
			0, ifnum, desc, sizeof(*desc), 1000);

	dev_dbg(&serial->dev->dev, "%s -  ret=%d\n", __func__, ret);
	if (ret < sizeof(*desc)) {
		dev_dbg(&serial->dev->dev,
			"%s - class descriptor read %s (%d)\n", __func__,
			(ret < 0) ? "failed" : "too short", ret);
		goto error;
	}
	if (desc->bDescriptorType != USB_DT_CS_IRDA) {
		dev_dbg(&serial->dev->dev, "%s - bad class descriptor type\n",
			__func__);
		goto error;
	}

	irda_usb_dump_class_desc(serial, desc);
	return desc;

error:
	kfree(desc);
	return NULL;
}

static u8 ir_xbof_change(u8 xbof)
{
	u8 result;

	/* reference irda-usb.c */
	switch (xbof) {
	case 48:
		result = 0x10;
		break;
	case 28:
	case 24:
		result = 0x20;
		break;
	default:
	case 12:
		result = 0x30;
		break;
	case  5:
	case  6:
		result = 0x40;
		break;
	case  3:
		result = 0x50;
		break;
	case  2:
		result = 0x60;
		break;
	case  1:
		result = 0x70;
		break;
	case  0:
		result = 0x80;
		break;
	}

	return(result);
}

static int ir_startup(struct usb_serial *serial)
{
	struct usb_irda_cs_descriptor *irda_desc;

	irda_desc = irda_usb_find_class_desc(serial, 0);
	if (!irda_desc) {
		dev_err(&serial->dev->dev,
			"IRDA class descriptor not found, device not bound\n");
		return -ENODEV;
	}

	dev_dbg(&serial->dev->dev,
		"%s - Baud rates supported:%s%s%s%s%s%s%s%s%s\n",
		__func__,
		(irda_desc->wBaudRate & USB_IRDA_BR_2400) ? " 2400" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_9600) ? " 9600" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_19200) ? " 19200" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_38400) ? " 38400" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_57600) ? " 57600" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_115200) ? " 115200" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_576000) ? " 576000" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_1152000) ? " 1152000" : "",
		(irda_desc->wBaudRate & USB_IRDA_BR_4000000) ? " 4000000" : "");

	switch (irda_desc->bmAdditionalBOFs) {
	case USB_IRDA_AB_48:
		ir_add_bof = 48;
		break;
	case USB_IRDA_AB_24:
		ir_add_bof = 24;
		break;
	case USB_IRDA_AB_12:
		ir_add_bof = 12;
		break;
	case USB_IRDA_AB_6:
		ir_add_bof = 6;
		break;
	case USB_IRDA_AB_3:
		ir_add_bof = 3;
		break;
	case USB_IRDA_AB_2:
		ir_add_bof = 2;
		break;
	case USB_IRDA_AB_1:
		ir_add_bof = 1;
		break;
	case USB_IRDA_AB_0:
		ir_add_bof = 0;
		break;
	default:
		break;
	}

	kfree(irda_desc);

	return 0;
}

static int ir_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
		port->write_urbs[i]->transfer_flags = URB_ZERO_PACKET;

	/* Start reading from the device */
	return usb_serial_generic_open(tty, port);
}

static int ir_prepare_write_buffer(struct usb_serial_port *port,
						void *dest, size_t size)
{
	unsigned char *buf = dest;
	int count;

	/*
	 * The first byte of the packet we send to the device contains an
	 * inbound header which indicates an additional number of BOFs and
	 * a baud rate change.
	 *
	 * See section 5.4.2.2 of the USB IrDA spec.
	 */
	*buf = ir_xbof | ir_baud;

	count = kfifo_out_locked(&port->write_fifo, buf + 1, size - 1,
								&port->lock);
	return count + 1;
}

static void ir_process_read_urb(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	unsigned char *data = urb->transfer_buffer;
	struct tty_struct *tty;

	if (!urb->actual_length)
		return;
	/*
	 * The first byte of the packet we get from the device
	 * contains a busy indicator and baud rate change.
	 * See section 5.4.1.2 of the USB IrDA spec.
	 */
	if (*data & 0x0f)
		ir_baud = *data & 0x0f;

	if (urb->actual_length == 1)
		return;

	tty = tty_port_tty_get(&port->port);
	if (!tty)
		return;
	tty_insert_flip_string(tty, data + 1, urb->actual_length - 1);
	tty_flip_buffer_push(tty);
	tty_kref_put(tty);
}

static void ir_set_termios_callback(struct urb *urb)
{
	kfree(urb->transfer_buffer);

	if (urb->status)
		dev_dbg(&urb->dev->dev, "%s - non-zero urb status: %d\n",
			__func__, urb->status);
}

static void ir_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios)
{
	struct urb *urb;
	unsigned char *transfer_buffer;
	int result;
	speed_t baud;
	int ir_baud;

	baud = tty_get_baud_rate(tty);

	/*
	 * FIXME, we should compare the baud request against the
	 * capability stated in the IR header that we got in the
	 * startup function.
	 */

	switch (baud) {
	case 2400:
		ir_baud = USB_IRDA_BR_2400;
		break;
	case 9600:
		ir_baud = USB_IRDA_BR_9600;
		break;
	case 19200:
		ir_baud = USB_IRDA_BR_19200;
		break;
	case 38400:
		ir_baud = USB_IRDA_BR_38400;
		break;
	case 57600:
		ir_baud = USB_IRDA_BR_57600;
		break;
	case 115200:
		ir_baud = USB_IRDA_BR_115200;
		break;
	case 576000:
		ir_baud = USB_IRDA_BR_576000;
		break;
	case 1152000:
		ir_baud = USB_IRDA_BR_1152000;
		break;
	case 4000000:
		ir_baud = USB_IRDA_BR_4000000;
		break;
	default:
		ir_baud = USB_IRDA_BR_9600;
		baud = 9600;
	}

	if (xbof == -1)
		ir_xbof = ir_xbof_change(ir_add_bof);
	else
		ir_xbof = ir_xbof_change(xbof) ;

	/* Only speed changes are supported */
	tty_termios_copy_hw(&tty->termios, old_termios);
	tty_encode_baud_rate(tty, baud, baud);

	/*
	 * send the baud change out on an "empty" data packet
	 */
	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!urb) {
		dev_err(&port->dev, "%s - no more urbs\n", __func__);
		return;
	}
	transfer_buffer = kmalloc(1, GFP_KERNEL);
	if (!transfer_buffer) {
		dev_err(&port->dev, "%s - out of memory\n", __func__);
		goto err_buf;
	}

	*transfer_buffer = ir_xbof | ir_baud;

	usb_fill_bulk_urb(
		urb,
		port->serial->dev,
		usb_sndbulkpipe(port->serial->dev,
			port->bulk_out_endpointAddress),
		transfer_buffer,
		1,
		ir_set_termios_callback,
		port);

	urb->transfer_flags = URB_ZERO_PACKET;

	result = usb_submit_urb(urb, GFP_KERNEL);
	if (result) {
		dev_err(&port->dev, "%s - failed to submit urb: %d\n",
							__func__, result);
		goto err_subm;
	}

	usb_free_urb(urb);

	return;
err_subm:
	kfree(transfer_buffer);
err_buf:
	usb_free_urb(urb);
}

static int __init ir_init(void)
{
	if (buffer_size) {
		ir_device.bulk_in_size = buffer_size;
		ir_device.bulk_out_size = buffer_size;
	}

	return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, ir_id_table);
}

static void __exit ir_exit(void)
{
	usb_serial_deregister_drivers(serial_drivers);
}


module_init(ir_init);
module_exit(ir_exit);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

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