1/*
2 *
3 * keyboard input driver for i2c IR remote controls
4 *
5 * Copyright (c) 2000-2003 Gerd Knorr <kraxel@bytesex.org>
6 * modified for PixelView (BT878P+W/FM) by
7 *      Michal Kochanowicz <mkochano@pld.org.pl>
8 *      Christoph Bartelmus <lirc@bartelmus.de>
9 * modified for KNC ONE TV Station/Anubis Typhoon TView Tuner by
10 *      Ulrich Mueller <ulrich.mueller42@web.de>
11 * modified for em2820 based USB TV tuners by
12 *      Markus Rechberger <mrechberger@gmail.com>
13 * modified for DViCO Fusion HDTV 5 RT GOLD by
14 *      Chaogui Zhang <czhang1974@gmail.com>
15 * modified for MSI TV@nywhere Plus by
16 *      Henry Wong <henry@stuffedcow.net>
17 *      Mark Schultz <n9xmj@yahoo.com>
18 *      Brian Rogers <brian_rogers@comcast.net>
19 * modified for AVerMedia Cardbus by
20 *      Oldrich Jedlicka <oldium.pro@seznam.cz>
21 *
22 *  This program is free software; you can redistribute it and/or modify
23 *  it under the terms of the GNU General Public License as published by
24 *  the Free Software Foundation; either version 2 of the License, or
25 *  (at your option) any later version.
26 *
27 *  This program is distributed in the hope that it will be useful,
28 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
29 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30 *  GNU General Public License for more details.
31 *
32 *  You should have received a copy of the GNU General Public License
33 *  along with this program; if not, write to the Free Software
34 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
35 *
36 */
37
38#include <linux/module.h>
39#include <linux/init.h>
40#include <linux/kernel.h>
41#include <linux/string.h>
42#include <linux/timer.h>
43#include <linux/delay.h>
44#include <linux/errno.h>
45#include <linux/slab.h>
46#include <linux/i2c.h>
47#include <linux/workqueue.h>
48
49#include <media/rc-core.h>
50#include <media/ir-kbd-i2c.h>
51
52/* ----------------------------------------------------------------------- */
53/* insmod parameters                                                       */
54
55static int debug;
56module_param(debug, int, 0644);    /* debug level (0,1,2) */
57
58
59#define MODULE_NAME "ir-kbd-i2c"
60#define dprintk(level, fmt, arg...)	if (debug >= level) \
61	printk(KERN_DEBUG MODULE_NAME ": " fmt , ## arg)
62
63/* ----------------------------------------------------------------------- */
64
65static int get_key_haup_common(struct IR_i2c *ir, enum rc_type *protocol,
66			       u32 *scancode, u8 *ptoggle, int size, int offset)
67{
68	unsigned char buf[6];
69	int start, range, toggle, dev, code, ircode;
70
71	/* poll IR chip */
72	if (size != i2c_master_recv(ir->c, buf, size))
73		return -EIO;
74
75	/* split rc5 data block ... */
76	start  = (buf[offset] >> 7) &    1;
77	range  = (buf[offset] >> 6) &    1;
78	toggle = (buf[offset] >> 5) &    1;
79	dev    =  buf[offset]       & 0x1f;
80	code   = (buf[offset+1] >> 2) & 0x3f;
81
82	/* rc5 has two start bits
83	 * the first bit must be one
84	 * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
85	 */
86	if (!start)
87		/* no key pressed */
88		return 0;
89
90	/* filter out invalid key presses */
91	ircode = (start << 12) | (toggle << 11) | (dev << 6) | code;
92	if ((ircode & 0x1fff) == 0x1fff)
93		return 0;
94
95	if (!range)
96		code += 64;
97
98	dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
99		start, range, toggle, dev, code);
100
101	*protocol = RC_TYPE_RC5;
102	*scancode = RC_SCANCODE_RC5(dev, code);
103	*ptoggle = toggle;
104	return 1;
105}
106
107static int get_key_haup(struct IR_i2c *ir, enum rc_type *protocol,
108			u32 *scancode, u8 *toggle)
109{
110	return get_key_haup_common (ir, protocol, scancode, toggle, 3, 0);
111}
112
113static int get_key_haup_xvr(struct IR_i2c *ir, enum rc_type *protocol,
114			    u32 *scancode, u8 *toggle)
115{
116	int ret;
117	unsigned char buf[1] = { 0 };
118
119	/*
120	 * This is the same apparent "are you ready?" poll command observed
121	 * watching Windows driver traffic and implemented in lirc_zilog. With
122	 * this added, we get far saner remote behavior with z8 chips on usb
123	 * connected devices, even with the default polling interval of 100ms.
124	 */
125	ret = i2c_master_send(ir->c, buf, 1);
126	if (ret != 1)
127		return (ret < 0) ? ret : -EINVAL;
128
129	return get_key_haup_common(ir, protocol, scancode, toggle, 6, 3);
130}
131
132static int get_key_pixelview(struct IR_i2c *ir, enum rc_type *protocol,
133			     u32 *scancode, u8 *toggle)
134{
135	unsigned char b;
136
137	/* poll IR chip */
138	if (1 != i2c_master_recv(ir->c, &b, 1)) {
139		dprintk(1,"read error\n");
140		return -EIO;
141	}
142
143	*protocol = RC_TYPE_OTHER;
144	*scancode = b;
145	*toggle = 0;
146	return 1;
147}
148
149static int get_key_fusionhdtv(struct IR_i2c *ir, enum rc_type *protocol,
150			      u32 *scancode, u8 *toggle)
151{
152	unsigned char buf[4];
153
154	/* poll IR chip */
155	if (4 != i2c_master_recv(ir->c, buf, 4)) {
156		dprintk(1,"read error\n");
157		return -EIO;
158	}
159
160	if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
161		dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
162			buf[0], buf[1], buf[2], buf[3]);
163
164	/* no key pressed or signal from other ir remote */
165	if(buf[0] != 0x1 ||  buf[1] != 0xfe)
166		return 0;
167
168	*protocol = RC_TYPE_UNKNOWN;
169	*scancode = buf[2];
170	*toggle = 0;
171	return 1;
172}
173
174static int get_key_knc1(struct IR_i2c *ir, enum rc_type *protocol,
175			u32 *scancode, u8 *toggle)
176{
177	unsigned char b;
178
179	/* poll IR chip */
180	if (1 != i2c_master_recv(ir->c, &b, 1)) {
181		dprintk(1,"read error\n");
182		return -EIO;
183	}
184
185	/* it seems that 0xFE indicates that a button is still hold
186	   down, while 0xff indicates that no button is hold
187	   down. 0xfe sequences are sometimes interrupted by 0xFF */
188
189	dprintk(2,"key %02x\n", b);
190
191	if (b == 0xff)
192		return 0;
193
194	if (b == 0xfe)
195		/* keep old data */
196		return 1;
197
198	*protocol = RC_TYPE_UNKNOWN;
199	*scancode = b;
200	*toggle = 0;
201	return 1;
202}
203
204static int get_key_avermedia_cardbus(struct IR_i2c *ir, enum rc_type *protocol,
205				     u32 *scancode, u8 *toggle)
206{
207	unsigned char subaddr, key, keygroup;
208	struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0,
209				   .buf = &subaddr, .len = 1},
210				 { .addr = ir->c->addr, .flags = I2C_M_RD,
211				  .buf = &key, .len = 1} };
212	subaddr = 0x0d;
213	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
214		dprintk(1, "read error\n");
215		return -EIO;
216	}
217
218	if (key == 0xff)
219		return 0;
220
221	subaddr = 0x0b;
222	msg[1].buf = &keygroup;
223	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
224		dprintk(1, "read error\n");
225		return -EIO;
226	}
227
228	if (keygroup == 0xff)
229		return 0;
230
231	dprintk(1, "read key 0x%02x/0x%02x\n", key, keygroup);
232	if (keygroup < 2 || keygroup > 4) {
233		/* Only a warning */
234		dprintk(1, "warning: invalid key group 0x%02x for key 0x%02x\n",
235								keygroup, key);
236	}
237	key |= (keygroup & 1) << 6;
238
239	*protocol = RC_TYPE_UNKNOWN;
240	*scancode = key;
241	if (ir->c->addr == 0x41) /* AVerMedia EM78P153 */
242		*scancode |= keygroup << 8;
243	*toggle = 0;
244	return 1;
245}
246
247/* ----------------------------------------------------------------------- */
248
249static int ir_key_poll(struct IR_i2c *ir)
250{
251	enum rc_type protocol;
252	u32 scancode;
253	u8 toggle;
254	int rc;
255
256	dprintk(3, "%s\n", __func__);
257	rc = ir->get_key(ir, &protocol, &scancode, &toggle);
258	if (rc < 0) {
259		dprintk(2,"error\n");
260		return rc;
261	}
262
263	if (rc) {
264		dprintk(1, "%s: proto = 0x%04x, scancode = 0x%08x\n",
265			__func__, protocol, scancode);
266		rc_keydown(ir->rc, protocol, scancode, toggle);
267	}
268	return 0;
269}
270
271static void ir_work(struct work_struct *work)
272{
273	int rc;
274	struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work);
275
276	rc = ir_key_poll(ir);
277	if (rc == -ENODEV) {
278		rc_unregister_device(ir->rc);
279		ir->rc = NULL;
280		return;
281	}
282
283	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling_interval));
284}
285
286/* ----------------------------------------------------------------------- */
287
288static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
289{
290	char *ir_codes = NULL;
291	const char *name = NULL;
292	u64 rc_type = RC_BIT_UNKNOWN;
293	struct IR_i2c *ir;
294	struct rc_dev *rc = NULL;
295	struct i2c_adapter *adap = client->adapter;
296	unsigned short addr = client->addr;
297	int err;
298
299	ir = devm_kzalloc(&client->dev, sizeof(*ir), GFP_KERNEL);
300	if (!ir)
301		return -ENOMEM;
302
303	ir->c = client;
304	ir->polling_interval = DEFAULT_POLLING_INTERVAL;
305	i2c_set_clientdata(client, ir);
306
307	switch(addr) {
308	case 0x64:
309		name        = "Pixelview";
310		ir->get_key = get_key_pixelview;
311		rc_type     = RC_BIT_OTHER;
312		ir_codes    = RC_MAP_EMPTY;
313		break;
314	case 0x18:
315	case 0x1f:
316	case 0x1a:
317		name        = "Hauppauge";
318		ir->get_key = get_key_haup;
319		rc_type     = RC_BIT_RC5;
320		ir_codes    = RC_MAP_HAUPPAUGE;
321		break;
322	case 0x30:
323		name        = "KNC One";
324		ir->get_key = get_key_knc1;
325		rc_type     = RC_BIT_OTHER;
326		ir_codes    = RC_MAP_EMPTY;
327		break;
328	case 0x6b:
329		name        = "FusionHDTV";
330		ir->get_key = get_key_fusionhdtv;
331		rc_type     = RC_BIT_UNKNOWN;
332		ir_codes    = RC_MAP_FUSIONHDTV_MCE;
333		break;
334	case 0x40:
335		name        = "AVerMedia Cardbus remote";
336		ir->get_key = get_key_avermedia_cardbus;
337		rc_type     = RC_BIT_OTHER;
338		ir_codes    = RC_MAP_AVERMEDIA_CARDBUS;
339		break;
340	case 0x41:
341		name        = "AVerMedia EM78P153";
342		ir->get_key = get_key_avermedia_cardbus;
343		rc_type     = RC_BIT_OTHER;
344		/* RM-KV remote, seems to be same as RM-K6 */
345		ir_codes    = RC_MAP_AVERMEDIA_M733A_RM_K6;
346		break;
347	case 0x71:
348		name        = "Hauppauge/Zilog Z8";
349		ir->get_key = get_key_haup_xvr;
350		rc_type     = RC_BIT_RC5;
351		ir_codes    = RC_MAP_HAUPPAUGE;
352		break;
353	}
354
355	/* Let the caller override settings */
356	if (client->dev.platform_data) {
357		const struct IR_i2c_init_data *init_data =
358						client->dev.platform_data;
359
360		ir_codes = init_data->ir_codes;
361		rc = init_data->rc_dev;
362
363		name = init_data->name;
364		if (init_data->type)
365			rc_type = init_data->type;
366
367		if (init_data->polling_interval)
368			ir->polling_interval = init_data->polling_interval;
369
370		switch (init_data->internal_get_key_func) {
371		case IR_KBD_GET_KEY_CUSTOM:
372			/* The bridge driver provided us its own function */
373			ir->get_key = init_data->get_key;
374			break;
375		case IR_KBD_GET_KEY_PIXELVIEW:
376			ir->get_key = get_key_pixelview;
377			break;
378		case IR_KBD_GET_KEY_HAUP:
379			ir->get_key = get_key_haup;
380			break;
381		case IR_KBD_GET_KEY_KNC1:
382			ir->get_key = get_key_knc1;
383			break;
384		case IR_KBD_GET_KEY_FUSIONHDTV:
385			ir->get_key = get_key_fusionhdtv;
386			break;
387		case IR_KBD_GET_KEY_HAUP_XVR:
388			ir->get_key = get_key_haup_xvr;
389			break;
390		case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS:
391			ir->get_key = get_key_avermedia_cardbus;
392			break;
393		}
394	}
395
396	if (!rc) {
397		/*
398		 * If platform_data doesn't specify rc_dev, initialize it
399		 * internally
400		 */
401		rc = rc_allocate_device();
402		if (!rc)
403			return -ENOMEM;
404	}
405	ir->rc = rc;
406
407	/* Make sure we are all setup before going on */
408	if (!name || !ir->get_key || !rc_type || !ir_codes) {
409		dprintk(1, ": Unsupported device at address 0x%02x\n",
410			addr);
411		err = -ENODEV;
412		goto err_out_free;
413	}
414
415	/* Sets name */
416	snprintf(ir->name, sizeof(ir->name), "i2c IR (%s)", name);
417	ir->ir_codes = ir_codes;
418
419	snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
420		 dev_name(&adap->dev),
421		 dev_name(&client->dev));
422
423	/*
424	 * Initialize input_dev fields
425	 * It doesn't make sense to allow overriding them via platform_data
426	 */
427	rc->input_id.bustype = BUS_I2C;
428	rc->input_phys       = ir->phys;
429	rc->input_name	     = ir->name;
430
431	/*
432	 * Initialize the other fields of rc_dev
433	 */
434	rc->map_name       = ir->ir_codes;
435	rc->allowed_protocols = rc_type;
436	rc->enabled_protocols = rc_type;
437	if (!rc->driver_name)
438		rc->driver_name = MODULE_NAME;
439
440	err = rc_register_device(rc);
441	if (err)
442		goto err_out_free;
443
444	printk(MODULE_NAME ": %s detected at %s [%s]\n",
445	       ir->name, ir->phys, adap->name);
446
447	/* start polling via eventd */
448	INIT_DELAYED_WORK(&ir->work, ir_work);
449	schedule_delayed_work(&ir->work, 0);
450
451	return 0;
452
453 err_out_free:
454	/* Only frees rc if it were allocated internally */
455	rc_free_device(rc);
456	return err;
457}
458
459static int ir_remove(struct i2c_client *client)
460{
461	struct IR_i2c *ir = i2c_get_clientdata(client);
462
463	/* kill outstanding polls */
464	cancel_delayed_work_sync(&ir->work);
465
466	/* unregister device */
467	rc_unregister_device(ir->rc);
468
469	/* free memory */
470	return 0;
471}
472
473static const struct i2c_device_id ir_kbd_id[] = {
474	/* Generic entry for any IR receiver */
475	{ "ir_video", 0 },
476	/* IR device specific entries should be added here */
477	{ "ir_rx_z8f0811_haup", 0 },
478	{ "ir_rx_z8f0811_hdpvr", 0 },
479	{ }
480};
481
482static struct i2c_driver ir_kbd_driver = {
483	.driver = {
484		.name   = "ir-kbd-i2c",
485	},
486	.probe          = ir_probe,
487	.remove         = ir_remove,
488	.id_table       = ir_kbd_id,
489};
490
491module_i2c_driver(ir_kbd_driver);
492
493/* ----------------------------------------------------------------------- */
494
495MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
496MODULE_DESCRIPTION("input driver for i2c IR remote controls");
497MODULE_LICENSE("GPL");
498