em28xx-input.c revision 4b92253acc723f365ad6b2f32e4118e38133b7b8 
1/*
2  handle em28xx IR remotes via linux kernel input layer.
3
4   Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
5		      Markus Rechberger <mrechberger@gmail.com>
6		      Mauro Carvalho Chehab <mchehab@infradead.org>
7		      Sascha Sommer <saschasommer@freenet.de>
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  You should have received a copy of the GNU General Public License
20  along with this program; if not, write to the Free Software
21  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/delay.h>
27#include <linux/interrupt.h>
28#include <linux/input.h>
29#include <linux/usb.h>
30
31#include "em28xx.h"
32
33#define EM28XX_SNAPSHOT_KEY KEY_CAMERA
34#define EM28XX_SBUTTON_QUERY_INTERVAL 500
35#define EM28XX_R0C_USBSUSP_SNAPSHOT 0x20
36
37static unsigned int ir_debug;
38module_param(ir_debug, int, 0644);
39MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
40
41#define i2cdprintk(fmt, arg...) \
42	if (ir_debug) { \
43		printk(KERN_DEBUG "%s/ir: " fmt, ir->c.name , ## arg); \
44	}
45
46#define dprintk(fmt, arg...) \
47	if (ir_debug) { \
48		printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
49	}
50
51/**********************************************************
52 Polling structure used by em28xx IR's
53 **********************************************************/
54
55struct em28xx_ir_poll_result {
56	unsigned int toggle_bit:1;
57	unsigned int read_count:7;
58	u8 rc_address;
59	u8 rc_data[4]; /* 1 byte on em2860/2880, 4 on em2874 */
60};
61
62struct em28xx_IR {
63	struct em28xx *dev;
64	struct input_dev *input;
65	struct ir_input_state ir;
66	char name[32];
67	char phys[32];
68
69	/* poll external decoder */
70	int polling;
71	struct work_struct work;
72	struct timer_list timer;
73	unsigned int last_toggle:1;
74	unsigned int last_readcount;
75	unsigned int repeat_interval;
76
77	int  (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
78};
79
80/**********************************************************
81 I2C IR based get keycodes - should be used with ir-kbd-i2c
82 **********************************************************/
83
84int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
85{
86	unsigned char b;
87
88	/* poll IR chip */
89	if (1 != i2c_master_recv(&ir->c, &b, 1)) {
90		i2cdprintk("read error\n");
91		return -EIO;
92	}
93
94	/* it seems that 0xFE indicates that a button is still hold
95	   down, while 0xff indicates that no button is hold
96	   down. 0xfe sequences are sometimes interrupted by 0xFF */
97
98	i2cdprintk("key %02x\n", b);
99
100	if (b == 0xff)
101		return 0;
102
103	if (b == 0xfe)
104		/* keep old data */
105		return 1;
106
107	*ir_key = b;
108	*ir_raw = b;
109	return 1;
110}
111
112int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
113{
114	unsigned char buf[2];
115	unsigned char code;
116
117	/* poll IR chip */
118	if (2 != i2c_master_recv(&ir->c, buf, 2))
119		return -EIO;
120
121	/* Does eliminate repeated parity code */
122	if (buf[1] == 0xff)
123		return 0;
124
125	ir->old = buf[1];
126
127	/* Rearranges bits to the right order */
128	code =   ((buf[0]&0x01)<<5) | /* 0010 0000 */
129		 ((buf[0]&0x02)<<3) | /* 0001 0000 */
130		 ((buf[0]&0x04)<<1) | /* 0000 1000 */
131		 ((buf[0]&0x08)>>1) | /* 0000 0100 */
132		 ((buf[0]&0x10)>>3) | /* 0000 0010 */
133		 ((buf[0]&0x20)>>5);  /* 0000 0001 */
134
135	i2cdprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x)\n",
136			code, buf[0]);
137
138	/* return key */
139	*ir_key = code;
140	*ir_raw = code;
141	return 1;
142}
143
144int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
145				     u32 *ir_raw)
146{
147	unsigned char buf[3];
148
149	/* poll IR chip */
150
151	if (3 != i2c_master_recv(&ir->c, buf, 3)) {
152		i2cdprintk("read error\n");
153		return -EIO;
154	}
155
156	i2cdprintk("key %02x\n", buf[2]&0x3f);
157	if (buf[0] != 0x00)
158		return 0;
159
160	*ir_key = buf[2]&0x3f;
161	*ir_raw = buf[2]&0x3f;
162
163	return 1;
164}
165
166/**********************************************************
167 Poll based get keycode functions
168 **********************************************************/
169
170/* This is for the em2860/em2880 */
171static int default_polling_getkey(struct em28xx_IR *ir,
172				  struct em28xx_ir_poll_result *poll_result)
173{
174	struct em28xx *dev = ir->dev;
175	int rc;
176	u8 msg[3] = { 0, 0, 0 };
177
178	/* Read key toggle, brand, and key code
179	   on registers 0x45, 0x46 and 0x47
180	 */
181	rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR,
182					  msg, sizeof(msg));
183	if (rc < 0)
184		return rc;
185
186	/* Infrared toggle (Reg 0x45[7]) */
187	poll_result->toggle_bit = (msg[0] >> 7);
188
189	/* Infrared read count (Reg 0x45[6:0] */
190	poll_result->read_count = (msg[0] & 0x7f);
191
192	/* Remote Control Address (Reg 0x46) */
193	poll_result->rc_address = msg[1];
194
195	/* Remote Control Data (Reg 0x47) */
196	poll_result->rc_data[0] = msg[2];
197
198	return 0;
199}
200
201static int em2874_polling_getkey(struct em28xx_IR *ir,
202				 struct em28xx_ir_poll_result *poll_result)
203{
204	struct em28xx *dev = ir->dev;
205	int rc;
206	u8 msg[5] = { 0, 0, 0, 0, 0 };
207
208	/* Read key toggle, brand, and key code
209	   on registers 0x51-55
210	 */
211	rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR,
212					  msg, sizeof(msg));
213	if (rc < 0)
214		return rc;
215
216	/* Infrared toggle (Reg 0x51[7]) */
217	poll_result->toggle_bit = (msg[0] >> 7);
218
219	/* Infrared read count (Reg 0x51[6:0] */
220	poll_result->read_count = (msg[0] & 0x7f);
221
222	/* Remote Control Address (Reg 0x52) */
223	poll_result->rc_address = msg[1];
224
225	/* Remote Control Data (Reg 0x53-55) */
226	poll_result->rc_data[0] = msg[2];
227	poll_result->rc_data[1] = msg[3];
228	poll_result->rc_data[2] = msg[4];
229
230	return 0;
231}
232
233/**********************************************************
234 Polling code for em28xx
235 **********************************************************/
236
237static void em28xx_ir_handle_key(struct em28xx_IR *ir)
238{
239	int result;
240	int do_sendkey = 0;
241	struct em28xx_ir_poll_result poll_result;
242
243	/* read the registers containing the IR status */
244	result = ir->get_key(ir, &poll_result);
245	if (result < 0) {
246		dprintk("ir->get_key() failed %d\n", result);
247		return;
248	}
249
250	dprintk("ir->get_key result tb=%02x rc=%02x lr=%02x data=%02x\n",
251		poll_result.toggle_bit, poll_result.read_count,
252		ir->last_readcount, poll_result.rc_data[0]);
253
254	if (ir->dev->chip_id == CHIP_ID_EM2874) {
255		/* The em2874 clears the readcount field every time the
256		   register is read.  The em2860/2880 datasheet says that it
257		   is supposed to clear the readcount, but it doesn't.  So with
258		   the em2874, we are looking for a non-zero read count as
259		   opposed to a readcount that is incrementing */
260		ir->last_readcount = 0;
261	}
262
263	if (poll_result.read_count == 0) {
264		/* The button has not been pressed since the last read */
265	} else if (ir->last_toggle != poll_result.toggle_bit) {
266		/* A button has been pressed */
267		dprintk("button has been pressed\n");
268		ir->last_toggle = poll_result.toggle_bit;
269		ir->repeat_interval = 0;
270		do_sendkey = 1;
271	} else if (poll_result.toggle_bit == ir->last_toggle &&
272		   poll_result.read_count > 0 &&
273		   poll_result.read_count != ir->last_readcount) {
274		/* The button is still being held down */
275		dprintk("button being held down\n");
276
277		/* Debouncer for first keypress */
278		if (ir->repeat_interval++ > 9) {
279			/* Start repeating after 1 second */
280			do_sendkey = 1;
281		}
282	}
283
284	if (do_sendkey) {
285		dprintk("sending keypress\n");
286		ir_input_keydown(ir->input, &ir->ir, poll_result.rc_data[0],
287				 poll_result.rc_data[0]);
288		ir_input_nokey(ir->input, &ir->ir);
289	}
290
291	ir->last_readcount = poll_result.read_count;
292	return;
293}
294
295static void ir_timer(unsigned long data)
296{
297	struct em28xx_IR *ir = (struct em28xx_IR *)data;
298
299	schedule_work(&ir->work);
300}
301
302static void em28xx_ir_work(struct work_struct *work)
303{
304	struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work);
305
306	em28xx_ir_handle_key(ir);
307	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling));
308}
309
310void em28xx_ir_start(struct em28xx_IR *ir)
311{
312	setup_timer(&ir->timer, ir_timer, (unsigned long)ir);
313	INIT_WORK(&ir->work, em28xx_ir_work);
314	schedule_work(&ir->work);
315}
316
317static void em28xx_ir_stop(struct em28xx_IR *ir)
318{
319	del_timer_sync(&ir->timer);
320	flush_scheduled_work();
321}
322
323int em28xx_ir_init(struct em28xx *dev)
324{
325	struct em28xx_IR *ir;
326	struct input_dev *input_dev;
327	u8 ir_config;
328	int err = -ENOMEM;
329
330	if (dev->ir_codes == NULL) {
331		/* No remote control support */
332		return 0;
333	}
334
335	ir = kzalloc(sizeof(*ir), GFP_KERNEL);
336	input_dev = input_allocate_device();
337	if (!ir || !input_dev)
338		goto err_out_free;
339
340	ir->input = input_dev;
341
342	/* Setup the proper handler based on the chip */
343	switch (dev->chip_id) {
344	case CHIP_ID_EM2860:
345	case CHIP_ID_EM2883:
346		ir->get_key = default_polling_getkey;
347		break;
348	case CHIP_ID_EM2874:
349		ir->get_key = em2874_polling_getkey;
350		/* For now we only support RC5, so enable it */
351		ir_config = EM2874_IR_RC5;
352		em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
353		break;
354	default:
355		printk("Unrecognized em28xx chip id: IR not supported\n");
356		goto err_out_free;
357	}
358
359	/* This is how often we ask the chip for IR information */
360	ir->polling = 100; /* ms */
361
362	/* init input device */
363	snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)",
364						dev->name);
365
366	usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
367	strlcat(ir->phys, "/input0", sizeof(ir->phys));
368
369	ir_input_init(input_dev, &ir->ir, IR_TYPE_OTHER, dev->ir_codes);
370	input_dev->name = ir->name;
371	input_dev->phys = ir->phys;
372	input_dev->id.bustype = BUS_USB;
373	input_dev->id.version = 1;
374	input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
375	input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
376
377	input_dev->dev.parent = &dev->udev->dev;
378	/* record handles to ourself */
379	ir->dev = dev;
380	dev->ir = ir;
381
382	em28xx_ir_start(ir);
383
384	/* all done */
385	err = input_register_device(ir->input);
386	if (err)
387		goto err_out_stop;
388
389	return 0;
390 err_out_stop:
391	em28xx_ir_stop(ir);
392	dev->ir = NULL;
393 err_out_free:
394	input_free_device(input_dev);
395	kfree(ir);
396	return err;
397}
398
399int em28xx_ir_fini(struct em28xx *dev)
400{
401	struct em28xx_IR *ir = dev->ir;
402
403	/* skip detach on non attached boards */
404	if (!ir)
405		return 0;
406
407	em28xx_ir_stop(ir);
408	input_unregister_device(ir->input);
409	kfree(ir);
410
411	/* done */
412	dev->ir = NULL;
413	return 0;
414}
415
416/**********************************************************
417 Handle Webcam snapshot button
418 **********************************************************/
419
420static void em28xx_query_sbutton(struct work_struct *work)
421{
422	/* Poll the register and see if the button is depressed */
423	struct em28xx *dev =
424		container_of(work, struct em28xx, sbutton_query_work.work);
425	int ret;
426
427	ret = em28xx_read_reg(dev, EM28XX_R0C_USBSUSP);
428
429	if (ret & EM28XX_R0C_USBSUSP_SNAPSHOT) {
430		u8 cleared;
431		/* Button is depressed, clear the register */
432		cleared = ((u8) ret) & ~EM28XX_R0C_USBSUSP_SNAPSHOT;
433		em28xx_write_regs(dev, EM28XX_R0C_USBSUSP, &cleared, 1);
434
435		/* Not emulate the keypress */
436		input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
437				 1);
438		/* Now unpress the key */
439		input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
440				 0);
441	}
442
443	/* Schedule next poll */
444	schedule_delayed_work(&dev->sbutton_query_work,
445			      msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL));
446}
447
448void em28xx_register_snapshot_button(struct em28xx *dev)
449{
450	struct input_dev *input_dev;
451	int err;
452
453	em28xx_info("Registering snapshot button...\n");
454	input_dev = input_allocate_device();
455	if (!input_dev) {
456		em28xx_errdev("input_allocate_device failed\n");
457		return;
458	}
459
460	usb_make_path(dev->udev, dev->snapshot_button_path,
461		      sizeof(dev->snapshot_button_path));
462	strlcat(dev->snapshot_button_path, "/sbutton",
463		sizeof(dev->snapshot_button_path));
464	INIT_DELAYED_WORK(&dev->sbutton_query_work, em28xx_query_sbutton);
465
466	input_dev->name = "em28xx snapshot button";
467	input_dev->phys = dev->snapshot_button_path;
468	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
469	set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit);
470	input_dev->keycodesize = 0;
471	input_dev->keycodemax = 0;
472	input_dev->id.bustype = BUS_USB;
473	input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
474	input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
475	input_dev->id.version = 1;
476	input_dev->dev.parent = &dev->udev->dev;
477
478	err = input_register_device(input_dev);
479	if (err) {
480		em28xx_errdev("input_register_device failed\n");
481		input_free_device(input_dev);
482		return;
483	}
484
485	dev->sbutton_input_dev = input_dev;
486	schedule_delayed_work(&dev->sbutton_query_work,
487			      msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL));
488	return;
489
490}
491
492void em28xx_deregister_snapshot_button(struct em28xx *dev)
493{
494	if (dev->sbutton_input_dev != NULL) {
495		em28xx_info("Deregistering snapshot button\n");
496		cancel_rearming_delayed_work(&dev->sbutton_query_work);
497		input_unregister_device(dev->sbutton_input_dev);
498		dev->sbutton_input_dev = NULL;
499	}
500	return;
501}
502