[deliverable/linux.git] / drivers / staging / tm6000 / tm6000-input.c

/*
 *  tm6000-input.c - driver for TM5600/TM6000/TM6010 USB video capture devices
 *
 *  Copyright (C) 2010 Stefan Ringel <stefan.ringel@arcor.de>
 *
 *  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 version 2
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>

#include <linux/input.h>
#include <linux/usb.h>

#include <media/ir-core.h>

#include "tm6000.h"
#include "tm6000-regs.h"

static unsigned int ir_debug;
module_param(ir_debug, int, 0644);
MODULE_PARM_DESC(ir_debug, "enable debug message [IR]");

static unsigned int enable_ir = 1;
module_param(enable_ir, int, 0644);
MODULE_PARM_DESC(enable_ir, "enable ir (default is enable)");

#undef dprintk

#define dprintk(fmt, arg...) \
	if (ir_debug) { \
		printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
	}

struct tm6000_ir_poll_result {
	u16 rc_data;
};

struct tm6000_IR {
	struct tm6000_core	*dev;
	struct rc_dev		*rc;
	char			name[32];
	char			phys[32];

	/* poll expernal decoder */
	int			polling;
	struct delayed_work	work;
	u8			wait:1;
	u8			key:1;
	struct urb		*int_urb;
	u8			*urb_data;

	int (*get_key) (struct tm6000_IR *, struct tm6000_ir_poll_result *);

	/* IR device properties */
	u64			ir_type;
};


void tm6000_ir_wait(struct tm6000_core *dev, u8 state)
{
	struct tm6000_IR *ir = dev->ir;

	if (!dev->ir)
		return;

	if (state)
		ir->wait = 1;
	else
		ir->wait = 0;
}


static int tm6000_ir_config(struct tm6000_IR *ir)
{
	struct tm6000_core *dev = ir->dev;
	u8 buf[10];
	int rc;

	/* hack */
	buf[0] = 0xff;
	buf[1] = 0xff;
	buf[2] = 0xf2;
	buf[3] = 0x2b;
	buf[4] = 0x20;
	buf[5] = 0x35;
	buf[6] = 0x60;
	buf[7] = 0x04;
	buf[8] = 0xc0;
	buf[9] = 0x08;

	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
		USB_RECIP_DEVICE, REQ_00_SET_IR_VALUE, 0, 0, buf, 0x0a);
	msleep(100);

	if (rc < 0) {
		printk(KERN_INFO "IR configuration failed");
		return rc;
	}
	return 0;
}

static void tm6000_ir_urb_received(struct urb *urb)
{
	struct tm6000_core *dev = urb->context;
	struct tm6000_IR *ir = dev->ir;
	int rc;

	if (urb->status != 0)
		printk(KERN_INFO "not ready\n");
	else if (urb->actual_length > 0) {
		memcpy(ir->urb_data, urb->transfer_buffer, urb->actual_length);

		dprintk("data %02x %02x %02x %02x\n", ir->urb_data[0],
			ir->urb_data[1], ir->urb_data[2], ir->urb_data[3]);

		ir->key = 1;
	}

	rc = usb_submit_urb(urb, GFP_ATOMIC);
}

static int default_polling_getkey(struct tm6000_IR *ir,
				struct tm6000_ir_poll_result *poll_result)
{
	struct tm6000_core *dev = ir->dev;
	int rc;
	u8 buf[2];

	if (ir->wait && !&dev->int_in)
		return 0;

	if (&dev->int_in) {
		if (ir->ir_type == IR_TYPE_RC5)
			poll_result->rc_data = ir->urb_data[0];
		else
			poll_result->rc_data = ir->urb_data[0] | ir->urb_data[1] << 8;
	} else {
		tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 0);
		msleep(10);
		tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 1);
		msleep(10);

		if (ir->ir_type == IR_TYPE_RC5) {
			rc = tm6000_read_write_usb(dev, USB_DIR_IN |
				USB_TYPE_VENDOR | USB_RECIP_DEVICE,
				REQ_02_GET_IR_CODE, 0, 0, buf, 1);

			msleep(10);

			dprintk("read data=%02x\n", buf[0]);
			if (rc < 0)
				return rc;

			poll_result->rc_data = buf[0];
		} else {
			rc = tm6000_read_write_usb(dev, USB_DIR_IN |
				USB_TYPE_VENDOR | USB_RECIP_DEVICE,
				REQ_02_GET_IR_CODE, 0, 0, buf, 2);

			msleep(10);

			dprintk("read data=%04x\n", buf[0] | buf[1] << 8);
			if (rc < 0)
				return rc;

			poll_result->rc_data = buf[0] | buf[1] << 8;
		}
		if ((poll_result->rc_data & 0x00ff) != 0xff)
			ir->key = 1;
	}
	return 0;
}

static void tm6000_ir_handle_key(struct tm6000_IR *ir)
{
	int result;
	struct tm6000_ir_poll_result poll_result;

	/* read the registers containing the IR status */
	result = ir->get_key(ir, &poll_result);
	if (result < 0) {
		printk(KERN_INFO "ir->get_key() failed %d\n", result);
		return;
	}

	dprintk("ir->get_key result data=%04x\n", poll_result.rc_data);

	if (ir->key) {
		ir_keydown(ir->rc, poll_result.rc_data, 0);
		ir->key = 0;
	}
	return;
}

static void tm6000_ir_work(struct work_struct *work)
{
	struct tm6000_IR *ir = container_of(work, struct tm6000_IR, work.work);

	tm6000_ir_handle_key(ir);
	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
}

static int tm6000_ir_start(struct rc_dev *rc)
{
	struct tm6000_IR *ir = rc->priv;

	INIT_DELAYED_WORK(&ir->work, tm6000_ir_work);
	schedule_delayed_work(&ir->work, 0);

	return 0;
}

static void tm6000_ir_stop(struct rc_dev *rc)
{
	struct tm6000_IR *ir = rc->priv;

	cancel_delayed_work_sync(&ir->work);
}

int tm6000_ir_change_protocol(struct rc_dev *rc, u64 ir_type)
{
	struct tm6000_IR *ir = rc->priv;

	ir->get_key = default_polling_getkey;

	tm6000_ir_config(ir);
	/* TODO */
	return 0;
}

int tm6000_ir_init(struct tm6000_core *dev)
{
	struct tm6000_IR *ir;
	struct rc_dev *rc;
	int err = -ENOMEM;
	int pipe, size;

	if (!enable_ir)
		return -ENODEV;

	if (!dev->caps.has_remote)
		return 0;

	if (!dev->ir_codes)
		return 0;

	ir = kzalloc(sizeof(*ir), GFP_KERNEL);
	rc = rc_allocate_device();
	if (!ir | !rc)
		goto out;

	/* record handles to ourself */
	ir->dev = dev;
	dev->ir = ir;
	ir->rc = rc;

	/* input einrichten */
	rc->allowed_protos = IR_TYPE_RC5 | IR_TYPE_NEC;
	rc->priv = ir;
	rc->change_protocol = tm6000_ir_change_protocol;
	rc->open = tm6000_ir_start;
	rc->close = tm6000_ir_stop;
	rc->driver_type = RC_DRIVER_SCANCODE;

	ir->polling = 50;

	snprintf(ir->name, sizeof(ir->name), "tm5600/60x0 IR (%s)",
						dev->name);

	usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
	strlcat(ir->phys, "/input0", sizeof(ir->phys));

	tm6000_ir_change_protocol(rc, IR_TYPE_UNKNOWN);

	rc->input_name = ir->name;
	rc->input_phys = ir->phys;
	rc->input_id.bustype = BUS_USB;
	rc->input_id.version = 1;
	rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
	rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
	rc->map_name = dev->ir_codes;
	rc->driver_name = "tm6000";
	rc->dev.parent = &dev->udev->dev;

	if (&dev->int_in) {
		dprintk("IR over int\n");

		ir->int_urb = usb_alloc_urb(0, GFP_KERNEL);

		pipe = usb_rcvintpipe(dev->udev,
			dev->int_in.endp->desc.bEndpointAddress
			& USB_ENDPOINT_NUMBER_MASK);

		size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));
		dprintk("IR max size: %d\n", size);

		ir->int_urb->transfer_buffer = kzalloc(size, GFP_KERNEL);
		if (ir->int_urb->transfer_buffer == NULL) {
			usb_free_urb(ir->int_urb);
			goto out;
		}
		dprintk("int interval: %d\n", dev->int_in.endp->desc.bInterval);
		usb_fill_int_urb(ir->int_urb, dev->udev, pipe,
			ir->int_urb->transfer_buffer, size,
			tm6000_ir_urb_received, dev,
			dev->int_in.endp->desc.bInterval);
		err = usb_submit_urb(ir->int_urb, GFP_KERNEL);
		if (err) {
			kfree(ir->int_urb->transfer_buffer);
			usb_free_urb(ir->int_urb);
			goto out;
		}
		ir->urb_data = kzalloc(size, GFP_KERNEL);
	}

	/* ir register */
	err = rc_register_device(rc);
	if (err)
		goto out;

	return 0;

out:
	dev->ir = NULL;
	rc_free_device(rc);
	kfree(ir);
	return err;
}

int tm6000_ir_fini(struct tm6000_core *dev)
{
	struct tm6000_IR *ir = dev->ir;

	/* skip detach on non attached board */

	if (!ir)
		return 0;

	rc_unregister_device(ir->rc);

	if (ir->int_urb) {
		usb_kill_urb(ir->int_urb);
		kfree(ir->int_urb->transfer_buffer);
		usb_free_urb(ir->int_urb);
		ir->int_urb = NULL;
		kfree(ir->urb_data);
		ir->urb_data = NULL;
	}

	kfree(ir);
	dev->ir = NULL;

	return 0;
}
Commit	Line	Data
d064f960	1	/*
d0058645 RP	2	* tm6000-input.c - driver for TM5600/TM6000/TM6010 USB video capture devices
	3	*
	4	* Copyright (C) 2010 Stefan Ringel <stefan.ringel@arcor.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation version 2
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
d064f960 SR	18	*/
	19
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/delay.h>
	23
	24	#include <linux/input.h>
	25	#include <linux/usb.h>
	26
	27	#include <media/ir-core.h>
d064f960 SR	28
	29	#include "tm6000.h"
	30	#include "tm6000-regs.h"
	31
	32	static unsigned int ir_debug;
	33	module_param(ir_debug, int, 0644);
	34	MODULE_PARM_DESC(ir_debug, "enable debug message [IR]");
	35
	36	static unsigned int enable_ir = 1;
	37	module_param(enable_ir, int, 0644);
401ad278	38	MODULE_PARM_DESC(enable_ir, "enable ir (default is enable)");
d064f960 SR	39
	40	#undef dprintk
	41
02c71055	42	#define dprintk(fmt, arg...) \
d064f960 SR	43	if (ir_debug) { \
	44	printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
	45	}
	46
	47	struct tm6000_ir_poll_result {
1b376dac	48	u16 rc_data;
d064f960 SR	49	};
	50
	51	struct tm6000_IR {
	52	struct tm6000_core *dev;
d8b4b582	53	struct rc_dev *rc;
d064f960 SR	54	char name[32];
	55	char phys[32];
	56
	57	/* poll expernal decoder */
	58	int polling;
	59	struct delayed_work work;
	60	u8 wait:1;
1b376dac	61	u8 key:1;
d064f960 SR	62	struct urb *int_urb;
d064f960 SR	63	u8 *urb_data;
d064f960 SR	64
	65	int (get_key) (struct tm6000_IR , struct tm6000_ir_poll_result *);
	66
	67	/* IR device properties */
62c65031	68	u64 ir_type;
d064f960 SR	69	};
	70
	71
	72	void tm6000_ir_wait(struct tm6000_core *dev, u8 state)
	73	{
	74	struct tm6000_IR *ir = dev->ir;
	75
	76	if (!dev->ir)
	77	return;
	78
	79	if (state)
	80	ir->wait = 1;
	81	else
	82	ir->wait = 0;
	83	}
	84
	85
	86	static int tm6000_ir_config(struct tm6000_IR *ir)
	87	{
	88	struct tm6000_core *dev = ir->dev;
	89	u8 buf[10];
	90	int rc;
	91
	92	/* hack */
	93	buf[0] = 0xff;
	94	buf[1] = 0xff;
	95	buf[2] = 0xf2;
	96	buf[3] = 0x2b;
	97	buf[4] = 0x20;
	98	buf[5] = 0x35;
	99	buf[6] = 0x60;
	100	buf[7] = 0x04;
	101	buf[8] = 0xc0;
	102	buf[9] = 0x08;
	103
	104	rc = tm6000_read_write_usb(dev, USB_DIR_OUT \| USB_TYPE_VENDOR \|
	105	USB_RECIP_DEVICE, REQ_00_SET_IR_VALUE, 0, 0, buf, 0x0a);
	106	msleep(100);
	107
	108	if (rc < 0) {
	109	printk(KERN_INFO "IR configuration failed");
	110	return rc;
	111	}
	112	return 0;
	113	}
	114
	115	static void tm6000_ir_urb_received(struct urb *urb)
	116	{
	117	struct tm6000_core *dev = urb->context;
	118	struct tm6000_IR *ir = dev->ir;
	119	int rc;
02c71055	120
d064f960 SR	121	if (urb->status != 0)
d064f960 SR	122	printk(KERN_INFO "not ready\n");
1b376dac	123	else if (urb->actual_length > 0) {
02c71055	124	memcpy(ir->urb_data, urb->transfer_buffer, urb->actual_length);
d064f960	125
1b376dac SR	126	dprintk("data %02x %02x %02x %02x\n", ir->urb_data[0],
1b376dac SR	127	ir->urb_data[1], ir->urb_data[2], ir->urb_data[3]);
d064f960	128
1b376dac SR	129	ir->key = 1;
1b376dac SR	130	}
d064f960 SR	131
	132	rc = usb_submit_urb(urb, GFP_ATOMIC);
	133	}
	134
	135	static int default_polling_getkey(struct tm6000_IR *ir,
	136	struct tm6000_ir_poll_result *poll_result)
	137	{
	138	struct tm6000_core *dev = ir->dev;
	139	int rc;
	140	u8 buf[2];
	141
1b376dac	142	if (ir->wait && !&dev->int_in)
d064f960	143	return 0;
d064f960 SR	144
d064f960 SR	145	if (&dev->int_in) {
62c65031	146	if (ir->ir_type == IR_TYPE_RC5)
1b376dac SR	147	poll_result->rc_data = ir->urb_data[0];
	148	else
	149	poll_result->rc_data = ir->urb_data[0] \| ir->urb_data[1] << 8;
d064f960 SR	150	} else {
	151	tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 0);
	152	msleep(10);
	153	tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 1);
	154	msleep(10);
	155
62c65031	156	if (ir->ir_type == IR_TYPE_RC5) {
1b376dac SR	157	rc = tm6000_read_write_usb(dev, USB_DIR_IN \|
	158	USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	159	REQ_02_GET_IR_CODE, 0, 0, buf, 1);
d064f960	160
1b376dac SR	161	msleep(10);
	162
	163	dprintk("read data=%02x\n", buf[0]);
	164	if (rc < 0)
	165	return rc;
	166
	167	poll_result->rc_data = buf[0];
	168	} else {
	169	rc = tm6000_read_write_usb(dev, USB_DIR_IN \|
	170	USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	171	REQ_02_GET_IR_CODE, 0, 0, buf, 2);
	172
	173	msleep(10);
d064f960	174
1b376dac SR	175	dprintk("read data=%04x\n", buf[0] \| buf[1] << 8);
	176	if (rc < 0)
	177	return rc;
02c71055	178
1b376dac SR	179	poll_result->rc_data = buf[0] \| buf[1] << 8;
	180	}
	181	if ((poll_result->rc_data & 0x00ff) != 0xff)
	182	ir->key = 1;
d064f960 SR	183	}
	184	return 0;
	185	}
	186
	187	static void tm6000_ir_handle_key(struct tm6000_IR *ir)
	188	{
	189	int result;
	190	struct tm6000_ir_poll_result poll_result;
	191
	192	/* read the registers containing the IR status */
	193	result = ir->get_key(ir, &poll_result);
	194	if (result < 0) {
	195	printk(KERN_INFO "ir->get_key() failed %d\n", result);
	196	return;
	197	}
	198
1b376dac	199	dprintk("ir->get_key result data=%04x\n", poll_result.rc_data);
d064f960	200
1b376dac	201	if (ir->key) {
d8b4b582	202	ir_keydown(ir->rc, poll_result.rc_data, 0);
d064f960 SR	203	ir->key = 0;
	204	}
	205	return;
	206	}
	207
	208	static void tm6000_ir_work(struct work_struct *work)
	209	{
	210	struct tm6000_IR *ir = container_of(work, struct tm6000_IR, work.work);
	211
	212	tm6000_ir_handle_key(ir);
	213	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
	214	}
	215
d8b4b582	216	static int tm6000_ir_start(struct rc_dev *rc)
d064f960	217	{
d8b4b582	218	struct tm6000_IR *ir = rc->priv;
d064f960 SR	219
	220	INIT_DELAYED_WORK(&ir->work, tm6000_ir_work);
	221	schedule_delayed_work(&ir->work, 0);
	222
	223	return 0;
	224	}
	225
d8b4b582	226	static void tm6000_ir_stop(struct rc_dev *rc)
d064f960	227	{
d8b4b582	228	struct tm6000_IR *ir = rc->priv;
d064f960 SR	229
	230	cancel_delayed_work_sync(&ir->work);
	231	}
	232
d8b4b582	233	int tm6000_ir_change_protocol(struct rc_dev *rc, u64 ir_type)
d064f960	234	{
d8b4b582	235	struct tm6000_IR *ir = rc->priv;
d064f960 SR	236
	237	ir->get_key = default_polling_getkey;
	238
	239	tm6000_ir_config(ir);
	240	/* TODO */
	241	return 0;
	242	}
	243
	244	int tm6000_ir_init(struct tm6000_core *dev)
	245	{
	246	struct tm6000_IR *ir;
d8b4b582	247	struct rc_dev *rc;
d064f960	248	int err = -ENOMEM;
d8b4b582	249	int pipe, size;
d064f960 SR	250
	251	if (!enable_ir)
	252	return -ENODEV;
	253
	254	if (!dev->caps.has_remote)
	255	return 0;
	256
	257	if (!dev->ir_codes)
	258	return 0;
	259
	260	ir = kzalloc(sizeof(*ir), GFP_KERNEL);
d8b4b582 DH	261	rc = rc_allocate_device();
	262	if (!ir \| !rc)
	263	goto out;
d064f960 SR	264
	265	/* record handles to ourself */
	266	ir->dev = dev;
	267	dev->ir = ir;
d8b4b582	268	ir->rc = rc;
d064f960 SR	269
d064f960 SR	270	/* input einrichten */
d8b4b582 DH	271	rc->allowed_protos = IR_TYPE_RC5 \| IR_TYPE_NEC;
	272	rc->priv = ir;
	273	rc->change_protocol = tm6000_ir_change_protocol;
	274	rc->open = tm6000_ir_start;
	275	rc->close = tm6000_ir_stop;
	276	rc->driver_type = RC_DRIVER_SCANCODE;
d064f960 SR	277
	278	ir->polling = 50;
	279
	280	snprintf(ir->name, sizeof(ir->name), "tm5600/60x0 IR (%s)",
	281	dev->name);
	282
	283	usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
	284	strlcat(ir->phys, "/input0", sizeof(ir->phys));
	285
d8b4b582	286	tm6000_ir_change_protocol(rc, IR_TYPE_UNKNOWN);
d064f960	287
d8b4b582 DH	288	rc->input_name = ir->name;
	289	rc->input_phys = ir->phys;
	290	rc->input_id.bustype = BUS_USB;
	291	rc->input_id.version = 1;
	292	rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
	293	rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
	294	rc->map_name = dev->ir_codes;
	295	rc->driver_name = "tm6000";
	296	rc->dev.parent = &dev->udev->dev;
d064f960 SR	297
	298	if (&dev->int_in) {
	299	dprintk("IR over int\n");
	300
	301	ir->int_urb = usb_alloc_urb(0, GFP_KERNEL);
	302
	303	pipe = usb_rcvintpipe(dev->udev,
	304	dev->int_in.endp->desc.bEndpointAddress
	305	& USB_ENDPOINT_NUMBER_MASK);
	306
	307	size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));
	308	dprintk("IR max size: %d\n", size);
	309
	310	ir->int_urb->transfer_buffer = kzalloc(size, GFP_KERNEL);
	311	if (ir->int_urb->transfer_buffer == NULL) {
	312	usb_free_urb(ir->int_urb);
d8b4b582	313	goto out;
d064f960 SR	314	}
	315	dprintk("int interval: %d\n", dev->int_in.endp->desc.bInterval);
	316	usb_fill_int_urb(ir->int_urb, dev->udev, pipe,
	317	ir->int_urb->transfer_buffer, size,
	318	tm6000_ir_urb_received, dev,
	319	dev->int_in.endp->desc.bInterval);
d8b4b582 DH	320	err = usb_submit_urb(ir->int_urb, GFP_KERNEL);
d8b4b582 DH	321	if (err) {
d064f960 SR	322	kfree(ir->int_urb->transfer_buffer);
d064f960 SR	323	usb_free_urb(ir->int_urb);
d8b4b582	324	goto out;
d064f960 SR	325	}
	326	ir->urb_data = kzalloc(size, GFP_KERNEL);
	327	}
	328
	329	/* ir register */
d8b4b582	330	err = rc_register_device(rc);
d064f960	331	if (err)
d8b4b582	332	goto out;
d064f960 SR	333
	334	return 0;
	335
d8b4b582	336	out:
d064f960	337	dev->ir = NULL;
d8b4b582	338	rc_free_device(rc);
d064f960 SR	339	kfree(ir);
	340	return err;
	341	}
	342
	343	int tm6000_ir_fini(struct tm6000_core *dev)
	344	{
	345	struct tm6000_IR *ir = dev->ir;
	346
	347	/* skip detach on non attached board */
	348
	349	if (!ir)
	350	return 0;
	351
d8b4b582	352	rc_unregister_device(ir->rc);
d064f960 SR	353
	354	if (ir->int_urb) {
	355	usb_kill_urb(ir->int_urb);
	356	kfree(ir->int_urb->transfer_buffer);
	357	usb_free_urb(ir->int_urb);
	358	ir->int_urb = NULL;
	359	kfree(ir->urb_data);
	360	ir->urb_data = NULL;
	361	}
	362
d064f960 SR	363	kfree(ir);
	364	dev->ir = NULL;
	365
	366	return 0;
	367	}