5ddeb421ed586270216817401ea2e31d740606e1
[linux-2.6.git] / drivers / media / video / em28xx / em28xx-input.c
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
37 static unsigned int ir_debug;
38 module_param(ir_debug, int, 0644);
39 MODULE_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->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
55 struct 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
62 struct 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 delayed_work work;
72         unsigned int last_toggle:1;
73         unsigned int full_code: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
84 int 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
112 int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
113 {
114         unsigned char buf[2];
115         u16 code;
116         int size;
117
118         /* poll IR chip */
119         size = i2c_master_recv(ir->c, buf, sizeof(buf));
120
121         if (size != 2)
122                 return -EIO;
123
124         /* Does eliminate repeated parity code */
125         if (buf[1] == 0xff)
126                 return 0;
127
128         ir->old = buf[1];
129
130         /*
131          * Rearranges bits to the right order.
132          * The bit order were determined experimentally by using
133          * The original Hauppauge Grey IR and another RC5 that uses addr=0x08
134          * The RC5 code has 14 bits, but we've experimentally determined
135          * the meaning for only 11 bits.
136          * So, the code translation is not complete. Yet, it is enough to
137          * work with the provided RC5 IR.
138          */
139         code =
140                  ((buf[0] & 0x01) ? 0x0020 : 0) | /*            0010 0000 */
141                  ((buf[0] & 0x02) ? 0x0010 : 0) | /*            0001 0000 */
142                  ((buf[0] & 0x04) ? 0x0008 : 0) | /*            0000 1000 */
143                  ((buf[0] & 0x08) ? 0x0004 : 0) | /*            0000 0100 */
144                  ((buf[0] & 0x10) ? 0x0002 : 0) | /*            0000 0010 */
145                  ((buf[0] & 0x20) ? 0x0001 : 0) | /*            0000 0001 */
146                  ((buf[1] & 0x08) ? 0x1000 : 0) | /* 0001 0000            */
147                  ((buf[1] & 0x10) ? 0x0800 : 0) | /* 0000 1000            */
148                  ((buf[1] & 0x20) ? 0x0400 : 0) | /* 0000 0100            */
149                  ((buf[1] & 0x40) ? 0x0200 : 0) | /* 0000 0010            */
150                  ((buf[1] & 0x80) ? 0x0100 : 0);  /* 0000 0001            */
151
152         i2cdprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x%02x)\n",
153                         code, buf[1], buf[0]);
154
155         /* return key */
156         *ir_key = code;
157         *ir_raw = code;
158         return 1;
159 }
160
161 int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
162                                      u32 *ir_raw)
163 {
164         unsigned char buf[3];
165
166         /* poll IR chip */
167
168         if (3 != i2c_master_recv(ir->c, buf, 3)) {
169                 i2cdprintk("read error\n");
170                 return -EIO;
171         }
172
173         i2cdprintk("key %02x\n", buf[2]&0x3f);
174         if (buf[0] != 0x00)
175                 return 0;
176
177         *ir_key = buf[2]&0x3f;
178         *ir_raw = buf[2]&0x3f;
179
180         return 1;
181 }
182
183 /**********************************************************
184  Poll based get keycode functions
185  **********************************************************/
186
187 /* This is for the em2860/em2880 */
188 static int default_polling_getkey(struct em28xx_IR *ir,
189                                   struct em28xx_ir_poll_result *poll_result)
190 {
191         struct em28xx *dev = ir->dev;
192         int rc;
193         u8 msg[3] = { 0, 0, 0 };
194
195         /* Read key toggle, brand, and key code
196            on registers 0x45, 0x46 and 0x47
197          */
198         rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR,
199                                           msg, sizeof(msg));
200         if (rc < 0)
201                 return rc;
202
203         /* Infrared toggle (Reg 0x45[7]) */
204         poll_result->toggle_bit = (msg[0] >> 7);
205
206         /* Infrared read count (Reg 0x45[6:0] */
207         poll_result->read_count = (msg[0] & 0x7f);
208
209         /* Remote Control Address (Reg 0x46) */
210         poll_result->rc_address = msg[1];
211
212         /* Remote Control Data (Reg 0x47) */
213         poll_result->rc_data[0] = msg[2];
214
215         return 0;
216 }
217
218 static int em2874_polling_getkey(struct em28xx_IR *ir,
219                                  struct em28xx_ir_poll_result *poll_result)
220 {
221         struct em28xx *dev = ir->dev;
222         int rc;
223         u8 msg[5] = { 0, 0, 0, 0, 0 };
224
225         /* Read key toggle, brand, and key code
226            on registers 0x51-55
227          */
228         rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR,
229                                           msg, sizeof(msg));
230         if (rc < 0)
231                 return rc;
232
233         /* Infrared toggle (Reg 0x51[7]) */
234         poll_result->toggle_bit = (msg[0] >> 7);
235
236         /* Infrared read count (Reg 0x51[6:0] */
237         poll_result->read_count = (msg[0] & 0x7f);
238
239         /* Remote Control Address (Reg 0x52) */
240         poll_result->rc_address = msg[1];
241
242         /* Remote Control Data (Reg 0x53-55) */
243         poll_result->rc_data[0] = msg[2];
244         poll_result->rc_data[1] = msg[3];
245         poll_result->rc_data[2] = msg[4];
246
247         return 0;
248 }
249
250 /**********************************************************
251  Polling code for em28xx
252  **********************************************************/
253
254 static void em28xx_ir_handle_key(struct em28xx_IR *ir)
255 {
256         int result;
257         int do_sendkey = 0;
258         struct em28xx_ir_poll_result poll_result;
259
260         /* read the registers containing the IR status */
261         result = ir->get_key(ir, &poll_result);
262         if (result < 0) {
263                 dprintk("ir->get_key() failed %d\n", result);
264                 return;
265         }
266
267         dprintk("ir->get_key result tb=%02x rc=%02x lr=%02x data=%02x%02x\n",
268                 poll_result.toggle_bit, poll_result.read_count,
269                 ir->last_readcount, poll_result.rc_address,
270                 poll_result.rc_data[0]);
271
272         if (ir->dev->chip_id == CHIP_ID_EM2874) {
273                 /* The em2874 clears the readcount field every time the
274                    register is read.  The em2860/2880 datasheet says that it
275                    is supposed to clear the readcount, but it doesn't.  So with
276                    the em2874, we are looking for a non-zero read count as
277                    opposed to a readcount that is incrementing */
278                 ir->last_readcount = 0;
279         }
280
281         if (poll_result.read_count == 0) {
282                 /* The button has not been pressed since the last read */
283         } else if (ir->last_toggle != poll_result.toggle_bit) {
284                 /* A button has been pressed */
285                 dprintk("button has been pressed\n");
286                 ir->last_toggle = poll_result.toggle_bit;
287                 ir->repeat_interval = 0;
288                 do_sendkey = 1;
289         } else if (poll_result.toggle_bit == ir->last_toggle &&
290                    poll_result.read_count > 0 &&
291                    poll_result.read_count != ir->last_readcount) {
292                 /* The button is still being held down */
293                 dprintk("button being held down\n");
294
295                 /* Debouncer for first keypress */
296                 if (ir->repeat_interval++ > 9) {
297                         /* Start repeating after 1 second */
298                         do_sendkey = 1;
299                 }
300         }
301
302         if (do_sendkey) {
303                 dprintk("sending keypress\n");
304
305                 if (ir->full_code)
306                         ir_input_keydown(ir->input, &ir->ir,
307                                          poll_result.rc_address << 8 |
308                                          poll_result.rc_data[0]);
309                 else
310                         ir_input_keydown(ir->input, &ir->ir,
311                                          poll_result.rc_data[0]);
312
313                 ir_input_nokey(ir->input, &ir->ir);
314         }
315
316         ir->last_readcount = poll_result.read_count;
317         return;
318 }
319
320 static void em28xx_ir_work(struct work_struct *work)
321 {
322         struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work);
323
324         em28xx_ir_handle_key(ir);
325         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
326 }
327
328 static void em28xx_ir_start(struct em28xx_IR *ir)
329 {
330         INIT_DELAYED_WORK(&ir->work, em28xx_ir_work);
331         schedule_delayed_work(&ir->work, 0);
332 }
333
334 static void em28xx_ir_stop(struct em28xx_IR *ir)
335 {
336         cancel_delayed_work_sync(&ir->work);
337 }
338
339 int em28xx_ir_init(struct em28xx *dev)
340 {
341         struct em28xx_IR *ir;
342         struct input_dev *input_dev;
343         u8 ir_config;
344         int err = -ENOMEM;
345
346         if (dev->board.ir_codes == NULL) {
347                 /* No remote control support */
348                 return 0;
349         }
350
351         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
352         input_dev = input_allocate_device();
353         if (!ir || !input_dev)
354                 goto err_out_free;
355
356         ir->input = input_dev;
357         ir_config = EM2874_IR_RC5;
358
359         /* Adjust xclk based o IR table for RC5/NEC tables */
360         if (dev->board.ir_codes->ir_type == IR_TYPE_RC5) {
361                 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
362                 ir->full_code = 1;
363         } else  if (dev->board.ir_codes->ir_type == IR_TYPE_NEC) {
364                 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
365                 ir_config = EM2874_IR_NEC;
366                 ir->full_code = 1;
367         }
368         em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
369                               EM28XX_XCLK_IR_RC5_MODE);
370
371         /* Setup the proper handler based on the chip */
372         switch (dev->chip_id) {
373         case CHIP_ID_EM2860:
374         case CHIP_ID_EM2883:
375                 ir->get_key = default_polling_getkey;
376                 break;
377         case CHIP_ID_EM2874:
378                 ir->get_key = em2874_polling_getkey;
379                 em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
380                 break;
381         default:
382                 printk("Unrecognized em28xx chip id: IR not supported\n");
383                 goto err_out_free;
384         }
385
386         /* This is how often we ask the chip for IR information */
387         ir->polling = 100; /* ms */
388
389         /* init input device */
390         snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)",
391                                                 dev->name);
392
393         usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
394         strlcat(ir->phys, "/input0", sizeof(ir->phys));
395
396         err = ir_input_init(input_dev, &ir->ir, IR_TYPE_OTHER,
397                              dev->board.ir_codes);
398         if (err < 0)
399                 goto err_out_free;
400
401         input_dev->name = ir->name;
402         input_dev->phys = ir->phys;
403         input_dev->id.bustype = BUS_USB;
404         input_dev->id.version = 1;
405         input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
406         input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
407
408         input_dev->dev.parent = &dev->udev->dev;
409         /* record handles to ourself */
410         ir->dev = dev;
411         dev->ir = ir;
412
413         em28xx_ir_start(ir);
414
415         /* all done */
416         err = input_register_device(ir->input);
417         if (err)
418                 goto err_out_stop;
419
420         return 0;
421  err_out_stop:
422         em28xx_ir_stop(ir);
423         dev->ir = NULL;
424  err_out_free:
425         ir_input_free(input_dev);
426         input_free_device(input_dev);
427         kfree(ir);
428         return err;
429 }
430
431 int em28xx_ir_fini(struct em28xx *dev)
432 {
433         struct em28xx_IR *ir = dev->ir;
434
435         /* skip detach on non attached boards */
436         if (!ir)
437                 return 0;
438
439         em28xx_ir_stop(ir);
440         ir_input_free(ir->input);
441         input_unregister_device(ir->input);
442         kfree(ir);
443
444         /* done */
445         dev->ir = NULL;
446         return 0;
447 }
448
449 /**********************************************************
450  Handle Webcam snapshot button
451  **********************************************************/
452
453 static void em28xx_query_sbutton(struct work_struct *work)
454 {
455         /* Poll the register and see if the button is depressed */
456         struct em28xx *dev =
457                 container_of(work, struct em28xx, sbutton_query_work.work);
458         int ret;
459
460         ret = em28xx_read_reg(dev, EM28XX_R0C_USBSUSP);
461
462         if (ret & EM28XX_R0C_USBSUSP_SNAPSHOT) {
463                 u8 cleared;
464                 /* Button is depressed, clear the register */
465                 cleared = ((u8) ret) & ~EM28XX_R0C_USBSUSP_SNAPSHOT;
466                 em28xx_write_regs(dev, EM28XX_R0C_USBSUSP, &cleared, 1);
467
468                 /* Not emulate the keypress */
469                 input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
470                                  1);
471                 /* Now unpress the key */
472                 input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
473                                  0);
474         }
475
476         /* Schedule next poll */
477         schedule_delayed_work(&dev->sbutton_query_work,
478                               msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL));
479 }
480
481 void em28xx_register_snapshot_button(struct em28xx *dev)
482 {
483         struct input_dev *input_dev;
484         int err;
485
486         em28xx_info("Registering snapshot button...\n");
487         input_dev = input_allocate_device();
488         if (!input_dev) {
489                 em28xx_errdev("input_allocate_device failed\n");
490                 return;
491         }
492
493         usb_make_path(dev->udev, dev->snapshot_button_path,
494                       sizeof(dev->snapshot_button_path));
495         strlcat(dev->snapshot_button_path, "/sbutton",
496                 sizeof(dev->snapshot_button_path));
497         INIT_DELAYED_WORK(&dev->sbutton_query_work, em28xx_query_sbutton);
498
499         input_dev->name = "em28xx snapshot button";
500         input_dev->phys = dev->snapshot_button_path;
501         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
502         set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit);
503         input_dev->keycodesize = 0;
504         input_dev->keycodemax = 0;
505         input_dev->id.bustype = BUS_USB;
506         input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
507         input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
508         input_dev->id.version = 1;
509         input_dev->dev.parent = &dev->udev->dev;
510
511         err = input_register_device(input_dev);
512         if (err) {
513                 em28xx_errdev("input_register_device failed\n");
514                 input_free_device(input_dev);
515                 return;
516         }
517
518         dev->sbutton_input_dev = input_dev;
519         schedule_delayed_work(&dev->sbutton_query_work,
520                               msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL));
521         return;
522
523 }
524
525 void em28xx_deregister_snapshot_button(struct em28xx *dev)
526 {
527         if (dev->sbutton_input_dev != NULL) {
528                 em28xx_info("Deregistering snapshot button\n");
529                 cancel_rearming_delayed_work(&dev->sbutton_query_work);
530                 input_unregister_device(dev->sbutton_input_dev);
531                 dev->sbutton_input_dev = NULL;
532         }
533         return;
534 }