[mirror_ubuntu-artful-kernel.git] / drivers / media / usb / au0828 / au0828-input.c

/*
  handle au0828 IR remotes via linux kernel input layer.

   Copyright (C) 2014 Mauro Carvalho Chehab <mchehab@samsung.com>
   Copyright (c) 2014 Samsung Electronics Co., Ltd.

  Based on em28xx-input.c.

  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 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.
 */

#include "au0828.h"

#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/usb.h>
#include <linux/slab.h>
#include <media/rc-core.h>

static int disable_ir;
module_param(disable_ir,        int, 0444);
MODULE_PARM_DESC(disable_ir, "disable infrared remote support");

struct au0828_rc {
	struct au0828_dev *dev;
	struct rc_dev *rc;
	char name[32];
	char phys[32];

	/* poll decoder */
	int polling;
	struct delayed_work work;

	/* i2c slave address of external device (if used) */
	u16 i2c_dev_addr;

	int  (*get_key_i2c)(struct au0828_rc *ir);
};

/*
 * AU8522 has a builtin IR receiver. Add functions to get IR from it
 */

static int au8522_rc_write(struct au0828_rc *ir, u16 reg, u8 data)
{
	int rc;
	char buf[] = { (reg >> 8) | 0x80, reg & 0xff, data };
	struct i2c_msg msg = { .addr = ir->i2c_dev_addr, .flags = 0,
			       .buf = buf, .len = sizeof(buf) };

	rc = i2c_transfer(ir->dev->i2c_client.adapter, &msg, 1);

	if (rc < 0)
		return rc;

	return (rc == 1) ? 0 : -EIO;
}

static int au8522_rc_read(struct au0828_rc *ir, u16 reg, int val,
				 char *buf, int size)
{
	int rc;
	char obuf[3];
	struct i2c_msg msg[2] = { { .addr = ir->i2c_dev_addr, .flags = 0,
				    .buf = obuf, .len = 2 },
				  { .addr = ir->i2c_dev_addr, .flags = I2C_M_RD,
				    .buf = buf, .len = size } };

	obuf[0] = 0x40 | reg >> 8;
	obuf[1] = reg & 0xff;
	if (val >= 0) {
		obuf[2] = val;
		msg[0].len++;
	}

	rc = i2c_transfer(ir->dev->i2c_client.adapter, msg, 2);

	if (rc < 0)
		return rc;

	return (rc == 2) ? 0 : -EIO;
}

static int au8522_rc_andor(struct au0828_rc *ir, u16 reg, u8 mask, u8 value)
{
	int rc;
	char buf, oldbuf;

	rc = au8522_rc_read(ir, reg, -1, &buf, 1);
	if (rc < 0)
		return rc;

	oldbuf = buf;
	buf = (buf & ~mask) | (value & mask);

	/* Nothing to do, just return */
	if (buf == oldbuf)
		return 0;

	return au8522_rc_write(ir, reg, buf);
}

#define au8522_rc_set(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), (bit))
#define au8522_rc_clear(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), 0)

/* Remote Controller time units */

#define AU8522_UNIT		200000 /* ns */
#define NEC_START_SPACE		(4500000 / AU8522_UNIT)
#define NEC_START_PULSE		(562500 * 16)
#define RC5_START_SPACE		(4 * AU8522_UNIT)
#define RC5_START_PULSE		888888

static int au0828_get_key_au8522(struct au0828_rc *ir)
{
	unsigned char buf[40];
	DEFINE_IR_RAW_EVENT(rawir);
	int i, j, rc;
	int prv_bit, bit, width;
	bool first = true;

	/* do nothing if device is disconnected */
	if (test_bit(DEV_DISCONNECTED, &ir->dev->dev_state))
		return 0;

	/* Check IR int */
	rc = au8522_rc_read(ir, 0xe1, -1, buf, 1);
	if (rc < 0 || !(buf[0] & (1 << 4))) {
		/* Be sure that IR is enabled */
		au8522_rc_set(ir, 0xe0, 1 << 4);
		return 0;
	}

	/* Something arrived. Get the data */
	rc = au8522_rc_read(ir, 0xe3, 0x11, buf, sizeof(buf));


	if (rc < 0)
		return rc;

	/* Disable IR */
	au8522_rc_clear(ir, 0xe0, 1 << 4);

	/* Enable IR */
	au8522_rc_set(ir, 0xe0, 1 << 4);

	dprintk(16, "RC data received: %*ph\n", 40, buf);

	prv_bit = (buf[0] >> 7) & 0x01;
	width = 0;
	for (i = 0; i < sizeof(buf); i++) {
		for (j = 7; j >= 0; j--) {
			bit = (buf[i] >> j) & 0x01;
			if (bit == prv_bit) {
				width++;
				continue;
			}

			/*
			 * Fix an au8522 bug: the first pulse event
			 * is lost. So, we need to fake it, based on the
			 * protocol. That means that not all raw decoders
			 * will work, as we need to add a hack for each
			 * protocol, based on the first space.
			 * So, we only support RC5 and NEC.
			 */

			if (first) {
				first = false;

				init_ir_raw_event(&rawir);
				rawir.pulse = true;
				if (width > NEC_START_SPACE - 2 &&
				    width < NEC_START_SPACE + 2) {
					/* NEC protocol */
					rawir.duration = NEC_START_PULSE;
					dprintk(16, "Storing NEC start %s with duration %d",
						rawir.pulse ? "pulse" : "space",
						rawir.duration);
				} else {
					/* RC5 protocol */
					rawir.duration = RC5_START_PULSE;
					dprintk(16, "Storing RC5 start %s with duration %d",
						rawir.pulse ? "pulse" : "space",
						rawir.duration);
				}
				ir_raw_event_store(ir->rc, &rawir);
			}

			init_ir_raw_event(&rawir);
			rawir.pulse = prv_bit ? false : true;
			rawir.duration = AU8522_UNIT * width;
			dprintk(16, "Storing %s with duration %d",
				rawir.pulse ? "pulse" : "space",
				rawir.duration);
			ir_raw_event_store(ir->rc, &rawir);

			width = 1;
			prv_bit = bit;
		}
	}

	init_ir_raw_event(&rawir);
	rawir.pulse = prv_bit ? false : true;
	rawir.duration = AU8522_UNIT * width;
	dprintk(16, "Storing end %s with duration %d",
		rawir.pulse ? "pulse" : "space",
		rawir.duration);
	ir_raw_event_store(ir->rc, &rawir);

	ir_raw_event_handle(ir->rc);

	return 1;
}

/*
 * Generic IR code
 */

static void au0828_rc_work(struct work_struct *work)
{
	struct au0828_rc *ir = container_of(work, struct au0828_rc, work.work);
	int rc;

	rc = ir->get_key_i2c(ir);
	if (rc < 0)
		pr_info("Error while getting RC scancode\n");

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

static int au0828_rc_start(struct rc_dev *rc)
{
	struct au0828_rc *ir = rc->priv;

	INIT_DELAYED_WORK(&ir->work, au0828_rc_work);

	/* Enable IR */
	au8522_rc_set(ir, 0xe0, 1 << 4);

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

	return 0;
}

static void au0828_rc_stop(struct rc_dev *rc)
{
	struct au0828_rc *ir = rc->priv;

	cancel_delayed_work_sync(&ir->work);

	/* do nothing if device is disconnected */
	if (!test_bit(DEV_DISCONNECTED, &ir->dev->dev_state)) {
		/* Disable IR */
		au8522_rc_clear(ir, 0xe0, 1 << 4);
	}
}

static int au0828_probe_i2c_ir(struct au0828_dev *dev)
{
	int i = 0;
	const unsigned short addr_list[] = {
		 0x47, I2C_CLIENT_END
	};

	while (addr_list[i] != I2C_CLIENT_END) {
		if (i2c_probe_func_quick_read(dev->i2c_client.adapter,
					      addr_list[i]) == 1)
			return addr_list[i];
		i++;
	}

	return -ENODEV;
}

int au0828_rc_register(struct au0828_dev *dev)
{
	struct au0828_rc *ir;
	struct rc_dev *rc;
	int err = -ENOMEM;
	u16 i2c_rc_dev_addr = 0;

	if (!dev->board.has_ir_i2c || disable_ir)
		return 0;

	i2c_rc_dev_addr = au0828_probe_i2c_ir(dev);
	if (!i2c_rc_dev_addr)
		return -ENODEV;

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

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

	rc->priv = ir;
	rc->open = au0828_rc_start;
	rc->close = au0828_rc_stop;

	if (dev->board.has_ir_i2c) {	/* external i2c device */
		switch (dev->boardnr) {
		case AU0828_BOARD_HAUPPAUGE_HVR950Q:
			rc->map_name = RC_MAP_HAUPPAUGE;
			ir->get_key_i2c = au0828_get_key_au8522;
			break;
		default:
			err = -ENODEV;
			goto error;
		}

		ir->i2c_dev_addr = i2c_rc_dev_addr;
	}

	/* This is how often we ask the chip for IR information */
	ir->polling = 100; /* ms */

	/* init input device */
	snprintf(ir->name, sizeof(ir->name), "au0828 IR (%s)",
		 dev->board.name);

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

	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->usbdev->descriptor.idVendor);
	rc->input_id.product = le16_to_cpu(dev->usbdev->descriptor.idProduct);
	rc->dev.parent = &dev->usbdev->dev;
	rc->driver_name = "au0828-input";
	rc->allowed_protocols = RC_BIT_NEC | RC_BIT_NECX | RC_BIT_NEC32 |
								RC_BIT_RC5;

	/* all done */
	err = rc_register_device(rc);
	if (err)
		goto error;

	pr_info("Remote controller %s initialized\n", ir->name);

	return 0;

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

void au0828_rc_unregister(struct au0828_dev *dev)
{
	struct au0828_rc *ir = dev->ir;

	/* skip detach on non attached boards */
	if (!ir)
		return;

	rc_unregister_device(ir->rc);

	/* done */
	kfree(ir);
	dev->ir = NULL;
}

int au0828_rc_suspend(struct au0828_dev *dev)
{
	struct au0828_rc *ir = dev->ir;

	if (!ir)
		return 0;

	pr_info("Stopping RC\n");

	cancel_delayed_work_sync(&ir->work);

	/* Disable IR */
	au8522_rc_clear(ir, 0xe0, 1 << 4);

	return 0;
}

int au0828_rc_resume(struct au0828_dev *dev)
{
	struct au0828_rc *ir = dev->ir;

	if (!ir)
		return 0;

	pr_info("Restarting RC\n");

	/* Enable IR */
	au8522_rc_set(ir, 0xe0, 1 << 4);

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

	return 0;
}
Commit	Line	Data
2fcfd317 MCC	1	/*
	2	handle au0828 IR remotes via linux kernel input layer.
	3
	4	Copyright (C) 2014 Mauro Carvalho Chehab <mchehab@samsung.com>
	5	Copyright (c) 2014 Samsung Electronics Co., Ltd.
	6
	7	Based on em28xx-input.c.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18	*/
	19
83afb32a MCC	20	#include "au0828.h"
83afb32a MCC	21
2fcfd317 MCC	22	#include <linux/module.h>
	23	#include <linux/init.h>
	24	#include <linux/delay.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/usb.h>
	27	#include <linux/slab.h>
	28	#include <media/rc-core.h>
	29
ff346b0f MCC	30	static int disable_ir;
	31	module_param(disable_ir, int, 0444);
	32	MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
	33
2fcfd317 MCC	34	struct au0828_rc {
	35	struct au0828_dev *dev;
	36	struct rc_dev *rc;
	37	char name[32];
	38	char phys[32];
	39
	40	/* poll decoder */
	41	int polling;
	42	struct delayed_work work;
	43
	44	/* i2c slave address of external device (if used) */
	45	u16 i2c_dev_addr;
	46
	47	int (get_key_i2c)(struct au0828_rc ir);
	48	};
	49
	50	/*
	51	* AU8522 has a builtin IR receiver. Add functions to get IR from it
	52	*/
	53
	54	static int au8522_rc_write(struct au0828_rc *ir, u16 reg, u8 data)
	55	{
	56	int rc;
	57	char buf[] = { (reg >> 8) \| 0x80, reg & 0xff, data };
	58	struct i2c_msg msg = { .addr = ir->i2c_dev_addr, .flags = 0,
	59	.buf = buf, .len = sizeof(buf) };
	60
	61	rc = i2c_transfer(ir->dev->i2c_client.adapter, &msg, 1);
	62
	63	if (rc < 0)
	64	return rc;
	65
	66	return (rc == 1) ? 0 : -EIO;
	67	}
	68
	69	static int au8522_rc_read(struct au0828_rc *ir, u16 reg, int val,
	70	char *buf, int size)
	71	{
	72	int rc;
	73	char obuf[3];
	74	struct i2c_msg msg[2] = { { .addr = ir->i2c_dev_addr, .flags = 0,
	75	.buf = obuf, .len = 2 },
	76	{ .addr = ir->i2c_dev_addr, .flags = I2C_M_RD,
	77	.buf = buf, .len = size } };
	78
	79	obuf[0] = 0x40 \| reg >> 8;
	80	obuf[1] = reg & 0xff;
	81	if (val >= 0) {
	82	obuf[2] = val;
	83	msg[0].len++;
	84	}
	85
	86	rc = i2c_transfer(ir->dev->i2c_client.adapter, msg, 2);
	87
	88	if (rc < 0)
	89	return rc;
	90
	91	return (rc == 2) ? 0 : -EIO;
	92	}
	93
	94	static int au8522_rc_andor(struct au0828_rc *ir, u16 reg, u8 mask, u8 value)
	95	{
	96	int rc;
2e0cc7ee	97	char buf, oldbuf;
2fcfd317 MCC	98
	99	rc = au8522_rc_read(ir, reg, -1, &buf, 1);
	100	if (rc < 0)
	101	return rc;
	102
2e0cc7ee	103	oldbuf = buf;
2fcfd317 MCC	104	buf = (buf & ~mask) \| (value & mask);
2fcfd317 MCC	105
2e0cc7ee MCC	106	/* Nothing to do, just return */
	107	if (buf == oldbuf)
	108	return 0;
	109
2fcfd317 MCC	110	return au8522_rc_write(ir, reg, buf);
	111	}
	112
	113	#define au8522_rc_set(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), (bit))
	114	#define au8522_rc_clear(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), 0)
	115
	116	/* Remote Controller time units */
	117
	118	#define AU8522_UNIT 200000 /* ns */
	119	#define NEC_START_SPACE (4500000 / AU8522_UNIT)
	120	#define NEC_START_PULSE (562500 * 16)
	121	#define RC5_START_SPACE (4 * AU8522_UNIT)
	122	#define RC5_START_PULSE 888888
	123
	124	static int au0828_get_key_au8522(struct au0828_rc *ir)
	125	{
	126	unsigned char buf[40];
	127	DEFINE_IR_RAW_EVENT(rawir);
	128	int i, j, rc;
	129	int prv_bit, bit, width;
	130	bool first = true;
	131
eb336eab	132	/* do nothing if device is disconnected */
e8e3039f	133	if (test_bit(DEV_DISCONNECTED, &ir->dev->dev_state))
eb336eab SK	134	return 0;
eb336eab SK	135
2fcfd317 MCC	136	/* Check IR int */
2fcfd317 MCC	137	rc = au8522_rc_read(ir, 0xe1, -1, buf, 1);
2e0cc7ee MCC	138	if (rc < 0 \|\| !(buf[0] & (1 << 4))) {
2e0cc7ee MCC	139	/* Be sure that IR is enabled */
3d8de92e	140	au8522_rc_set(ir, 0xe0, 1 << 4);
2fcfd317	141	return 0;
2e0cc7ee	142	}
2fcfd317 MCC	143
	144	/* Something arrived. Get the data */
	145	rc = au8522_rc_read(ir, 0xe3, 0x11, buf, sizeof(buf));
	146
	147
	148	if (rc < 0)
	149	return rc;
	150
	151	/* Disable IR */
	152	au8522_rc_clear(ir, 0xe0, 1 << 4);
	153
2fcfd317 MCC	154	/* Enable IR */
	155	au8522_rc_set(ir, 0xe0, 1 << 4);
	156
	157	dprintk(16, "RC data received: %*ph\n", 40, buf);
	158
	159	prv_bit = (buf[0] >> 7) & 0x01;
	160	width = 0;
	161	for (i = 0; i < sizeof(buf); i++) {
	162	for (j = 7; j >= 0; j--) {
	163	bit = (buf[i] >> j) & 0x01;
	164	if (bit == prv_bit) {
	165	width++;
	166	continue;
	167	}
	168
	169	/*
	170	* Fix an au8522 bug: the first pulse event
	171	* is lost. So, we need to fake it, based on the
	172	* protocol. That means that not all raw decoders
	173	* will work, as we need to add a hack for each
	174	* protocol, based on the first space.
	175	* So, we only support RC5 and NEC.
	176	*/
	177
	178	if (first) {
	179	first = false;
	180
	181	init_ir_raw_event(&rawir);
	182	rawir.pulse = true;
	183	if (width > NEC_START_SPACE - 2 &&
	184	width < NEC_START_SPACE + 2) {
	185	/* NEC protocol */
	186	rawir.duration = NEC_START_PULSE;
	187	dprintk(16, "Storing NEC start %s with duration %d",
	188	rawir.pulse ? "pulse" : "space",
	189	rawir.duration);
	190	} else {
	191	/* RC5 protocol */
	192	rawir.duration = RC5_START_PULSE;
	193	dprintk(16, "Storing RC5 start %s with duration %d",
	194	rawir.pulse ? "pulse" : "space",
	195	rawir.duration);
	196	}
	197	ir_raw_event_store(ir->rc, &rawir);
	198	}
	199
	200	init_ir_raw_event(&rawir);
	201	rawir.pulse = prv_bit ? false : true;
	202	rawir.duration = AU8522_UNIT * width;
	203	dprintk(16, "Storing %s with duration %d",
	204	rawir.pulse ? "pulse" : "space",
	205	rawir.duration);
	206	ir_raw_event_store(ir->rc, &rawir);
	207
	208	width = 1;
	209	prv_bit = bit;
	210	}
	211	}
	212
	213	init_ir_raw_event(&rawir);
	214	rawir.pulse = prv_bit ? false : true;
	215	rawir.duration = AU8522_UNIT * width;
	216	dprintk(16, "Storing end %s with duration %d",
	217	rawir.pulse ? "pulse" : "space",
218	rawir.duration);
219	ir_raw_event_store(ir->rc, &rawir);
220
221	ir_raw_event_handle(ir->rc);
222
223	return 1;
224	}
225
226	/*
227	* Generic IR code
228	*/
229
230	static void au0828_rc_work(struct work_struct *work)
231	{
232	struct au0828_rc *ir = container_of(work, struct au0828_rc, work.work);
233	int rc;
234
235	rc = ir->get_key_i2c(ir);
236	if (rc < 0)
237	pr_info("Error while getting RC scancode\n");
238
239	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
240	}
241
242	static int au0828_rc_start(struct rc_dev *rc)
243	{
244	struct au0828_rc *ir = rc->priv;
245
246	INIT_DELAYED_WORK(&ir->work, au0828_rc_work);
247
248	/* Enable IR */
249	au8522_rc_set(ir, 0xe0, 1 << 4);
250
251	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
252
253	return 0;
254	}
255
256	static void au0828_rc_stop(struct rc_dev *rc)
257	{
258	struct au0828_rc *ir = rc->priv;
259
e9018af0 MCC	260	cancel_delayed_work_sync(&ir->work);
e9018af0 MCC	261
eb336eab	262	/* do nothing if device is disconnected */
e8e3039f	263	if (!test_bit(DEV_DISCONNECTED, &ir->dev->dev_state)) {
eb336eab SK	264	/* Disable IR */
	265	au8522_rc_clear(ir, 0xe0, 1 << 4);
	266	}
2fcfd317 MCC	267	}
	268
	269	static int au0828_probe_i2c_ir(struct au0828_dev *dev)
	270	{
	271	int i = 0;
	272	const unsigned short addr_list[] = {
	273	0x47, I2C_CLIENT_END
	274	};
	275
	276	while (addr_list[i] != I2C_CLIENT_END) {
	277	if (i2c_probe_func_quick_read(dev->i2c_client.adapter,
	278	addr_list[i]) == 1)
	279	return addr_list[i];
	280	i++;
	281	}
	282
	283	return -ENODEV;
	284	}
	285
	286	int au0828_rc_register(struct au0828_dev *dev)
	287	{
	288	struct au0828_rc *ir;
	289	struct rc_dev *rc;
	290	int err = -ENOMEM;
	291	u16 i2c_rc_dev_addr = 0;
	292
ff346b0f	293	if (!dev->board.has_ir_i2c \|\| disable_ir)
2fcfd317 MCC	294	return 0;
	295
	296	i2c_rc_dev_addr = au0828_probe_i2c_ir(dev);
	297	if (!i2c_rc_dev_addr)
	298	return -ENODEV;
	299
	300	ir = kzalloc(sizeof(*ir), GFP_KERNEL);
0f7499fd	301	rc = rc_allocate_device(RC_DRIVER_IR_RAW);
2fcfd317 MCC	302	if (!ir \|\| !rc)
	303	goto error;
	304
	305	/* record handles to ourself */
	306	ir->dev = dev;
	307	dev->ir = ir;
	308	ir->rc = rc;
	309
	310	rc->priv = ir;
	311	rc->open = au0828_rc_start;
	312	rc->close = au0828_rc_stop;
	313
	314	if (dev->board.has_ir_i2c) { /* external i2c device */
	315	switch (dev->boardnr) {
	316	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
	317	rc->map_name = RC_MAP_HAUPPAUGE;
	318	ir->get_key_i2c = au0828_get_key_au8522;
	319	break;
	320	default:
	321	err = -ENODEV;
	322	goto error;
	323	}
	324
	325	ir->i2c_dev_addr = i2c_rc_dev_addr;
	326	}
	327
	328	/* This is how often we ask the chip for IR information */
	329	ir->polling = 100; /* ms */
	330
	331	/* init input device */
	332	snprintf(ir->name, sizeof(ir->name), "au0828 IR (%s)",
	333	dev->board.name);
	334
	335	usb_make_path(dev->usbdev, ir->phys, sizeof(ir->phys));
	336	strlcat(ir->phys, "/input0", sizeof(ir->phys));
	337
	338	rc->input_name = ir->name;
	339	rc->input_phys = ir->phys;
	340	rc->input_id.bustype = BUS_USB;
	341	rc->input_id.version = 1;
	342	rc->input_id.vendor = le16_to_cpu(dev->usbdev->descriptor.idVendor);
	343	rc->input_id.product = le16_to_cpu(dev->usbdev->descriptor.idProduct);
	344	rc->dev.parent = &dev->usbdev->dev;
	345	rc->driver_name = "au0828-input";
2ceeca04 SY	346	rc->allowed_protocols = RC_BIT_NEC \| RC_BIT_NECX \| RC_BIT_NEC32 \|
2ceeca04 SY	347	RC_BIT_RC5;
2fcfd317 MCC	348
	349	/* all done */
	350	err = rc_register_device(rc);
	351	if (err)
	352	goto error;
	353
1250a85b	354	pr_info("Remote controller %s initialized\n", ir->name);
2fcfd317 MCC	355
	356	return 0;
	357
	358	error:
	359	dev->ir = NULL;
	360	rc_free_device(rc);
	361	kfree(ir);
	362	return err;
	363	}
	364
	365	void au0828_rc_unregister(struct au0828_dev *dev)
	366	{
	367	struct au0828_rc *ir = dev->ir;
	368
	369	/* skip detach on non attached boards */
	370	if (!ir)
	371	return;
	372
83f56f7c	373	rc_unregister_device(ir->rc);
2fcfd317 MCC	374
	375	/* done */
	376	kfree(ir);
	377	dev->ir = NULL;
	378	}
	379
	380	int au0828_rc_suspend(struct au0828_dev *dev)
	381	{
	382	struct au0828_rc *ir = dev->ir;
	383
	384	if (!ir)
	385	return 0;
	386
81187240 MCC	387	pr_info("Stopping RC\n");
81187240 MCC	388
2fcfd317 MCC	389	cancel_delayed_work_sync(&ir->work);
2fcfd317 MCC	390
345e3bfd MCC	391	/* Disable IR */
	392	au8522_rc_clear(ir, 0xe0, 1 << 4);
	393
2fcfd317 MCC	394	return 0;
	395	}
	396
	397	int au0828_rc_resume(struct au0828_dev *dev)
	398	{
	399	struct au0828_rc *ir = dev->ir;
	400
	401	if (!ir)
	402	return 0;
	403
81187240 MCC	404	pr_info("Restarting RC\n");
81187240 MCC	405
345e3bfd MCC	406	/* Enable IR */
	407	au8522_rc_set(ir, 0xe0, 1 << 4);
	408
2fcfd317 MCC	409	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
	410
	411	return 0;
	412	}