Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
em28xx-input.c
Go to the documentation of this file.
1 /*
2  handle em28xx IR remotes via linux kernel input layer.
3 
4  Copyright (C) 2005 Ludovico Cavedon <[email protected]>
5  Markus Rechberger <[email protected]>
6  Mauro Carvalho Chehab <[email protected]>
7  Sascha Sommer <[email protected]>
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/usb.h>
29 #include <linux/slab.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 MODULE_NAME "em28xx"
42 
43 #define i2cdprintk(fmt, arg...) \
44  if (ir_debug) { \
45  printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
46  }
47 
48 #define dprintk(fmt, arg...) \
49  if (ir_debug) { \
50  printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
51  }
52 
53 /**********************************************************
54  Polling structure used by em28xx IR's
55  **********************************************************/
56 
58  unsigned int toggle_bit:1;
59  unsigned int read_count:7;
61  u8 rc_data[4]; /* 1 byte on em2860/2880, 4 on em2874 */
62 };
63 
64 struct em28xx_IR {
65  struct em28xx *dev;
66  struct rc_dev *rc;
67  char name[32];
68  char phys[32];
69 
70  /* poll external decoder */
71  int polling;
73  unsigned int full_code:1;
74  unsigned int last_readcount;
75 
76  int (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
77 };
78 
79 /**********************************************************
80  I2C IR based get keycodes - should be used with ir-kbd-i2c
81  **********************************************************/
82 
83 static int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
84 {
85  unsigned char b;
86 
87  /* poll IR chip */
88  if (1 != i2c_master_recv(ir->c, &b, 1)) {
89  i2cdprintk("read error\n");
90  return -EIO;
91  }
92 
93  /* it seems that 0xFE indicates that a button is still hold
94  down, while 0xff indicates that no button is hold
95  down. 0xfe sequences are sometimes interrupted by 0xFF */
96 
97  i2cdprintk("key %02x\n", b);
98 
99  if (b == 0xff)
100  return 0;
101 
102  if (b == 0xfe)
103  /* keep old data */
104  return 1;
105 
106  *ir_key = b;
107  *ir_raw = b;
108  return 1;
109 }
110 
111 static int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
112 {
113  unsigned char buf[2];
114  u16 code;
115  int size;
116 
117  /* poll IR chip */
118  size = i2c_master_recv(ir->c, buf, sizeof(buf));
119 
120  if (size != 2)
121  return -EIO;
122 
123  /* Does eliminate repeated parity code */
124  if (buf[1] == 0xff)
125  return 0;
126 
127  ir->old = buf[1];
128 
129  /*
130  * Rearranges bits to the right order.
131  * The bit order were determined experimentally by using
132  * The original Hauppauge Grey IR and another RC5 that uses addr=0x08
133  * The RC5 code has 14 bits, but we've experimentally determined
134  * the meaning for only 11 bits.
135  * So, the code translation is not complete. Yet, it is enough to
136  * work with the provided RC5 IR.
137  */
138  code =
139  ((buf[0] & 0x01) ? 0x0020 : 0) | /* 0010 0000 */
140  ((buf[0] & 0x02) ? 0x0010 : 0) | /* 0001 0000 */
141  ((buf[0] & 0x04) ? 0x0008 : 0) | /* 0000 1000 */
142  ((buf[0] & 0x08) ? 0x0004 : 0) | /* 0000 0100 */
143  ((buf[0] & 0x10) ? 0x0002 : 0) | /* 0000 0010 */
144  ((buf[0] & 0x20) ? 0x0001 : 0) | /* 0000 0001 */
145  ((buf[1] & 0x08) ? 0x1000 : 0) | /* 0001 0000 */
146  ((buf[1] & 0x10) ? 0x0800 : 0) | /* 0000 1000 */
147  ((buf[1] & 0x20) ? 0x0400 : 0) | /* 0000 0100 */
148  ((buf[1] & 0x40) ? 0x0200 : 0) | /* 0000 0010 */
149  ((buf[1] & 0x80) ? 0x0100 : 0); /* 0000 0001 */
150 
151  i2cdprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x%02x)\n",
152  code, buf[1], buf[0]);
153 
154  /* return key */
155  *ir_key = code;
156  *ir_raw = code;
157  return 1;
158 }
159 
160 static int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
161  u32 *ir_raw)
162 {
163  unsigned char buf[3];
164 
165  /* poll IR chip */
166 
167  if (3 != i2c_master_recv(ir->c, buf, 3)) {
168  i2cdprintk("read error\n");
169  return -EIO;
170  }
171 
172  i2cdprintk("key %02x\n", buf[2]&0x3f);
173  if (buf[0] != 0x00)
174  return 0;
175 
176  *ir_key = buf[2]&0x3f;
177  *ir_raw = buf[2]&0x3f;
178 
179  return 1;
180 }
181 
182 static int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key,
183  u32 *ir_raw)
184 {
185  unsigned char subaddr, keydetect, key;
186 
187  struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0, .buf = &subaddr, .len = 1},
188 
189  { .addr = ir->c->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} };
190 
191  subaddr = 0x10;
192  if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
193  i2cdprintk("read error\n");
194  return -EIO;
195  }
196  if (keydetect == 0x00)
197  return 0;
198 
199  subaddr = 0x00;
200  msg[1].buf = &key;
201  if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
202  i2cdprintk("read error\n");
203  return -EIO;
204  }
205  if (key == 0x00)
206  return 0;
207 
208  *ir_key = key;
209  *ir_raw = key;
210  return 1;
211 }
212 
213 /**********************************************************
214  Poll based get keycode functions
215  **********************************************************/
216 
217 /* This is for the em2860/em2880 */
218 static int default_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[3] = { 0, 0, 0 };
224 
225  /* Read key toggle, brand, and key code
226  on registers 0x45, 0x46 and 0x47
227  */
228  rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR,
229  msg, sizeof(msg));
230  if (rc < 0)
231  return rc;
232 
233  /* Infrared toggle (Reg 0x45[7]) */
234  poll_result->toggle_bit = (msg[0] >> 7);
235 
236  /* Infrared read count (Reg 0x45[6:0] */
237  poll_result->read_count = (msg[0] & 0x7f);
238 
239  /* Remote Control Address (Reg 0x46) */
240  poll_result->rc_address = msg[1];
241 
242  /* Remote Control Data (Reg 0x47) */
243  poll_result->rc_data[0] = msg[2];
244 
245  return 0;
246 }
247 
248 static int em2874_polling_getkey(struct em28xx_IR *ir,
249  struct em28xx_ir_poll_result *poll_result)
250 {
251  struct em28xx *dev = ir->dev;
252  int rc;
253  u8 msg[5] = { 0, 0, 0, 0, 0 };
254 
255  /* Read key toggle, brand, and key code
256  on registers 0x51-55
257  */
258  rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR,
259  msg, sizeof(msg));
260  if (rc < 0)
261  return rc;
262 
263  /* Infrared toggle (Reg 0x51[7]) */
264  poll_result->toggle_bit = (msg[0] >> 7);
265 
266  /* Infrared read count (Reg 0x51[6:0] */
267  poll_result->read_count = (msg[0] & 0x7f);
268 
269  /* Remote Control Address (Reg 0x52) */
270  poll_result->rc_address = msg[1];
271 
272  /* Remote Control Data (Reg 0x53-55) */
273  poll_result->rc_data[0] = msg[2];
274  poll_result->rc_data[1] = msg[3];
275  poll_result->rc_data[2] = msg[4];
276 
277  return 0;
278 }
279 
280 /**********************************************************
281  Polling code for em28xx
282  **********************************************************/
283 
284 static void em28xx_ir_handle_key(struct em28xx_IR *ir)
285 {
286  int result;
287  struct em28xx_ir_poll_result poll_result;
288 
289  /* read the registers containing the IR status */
290  result = ir->get_key(ir, &poll_result);
291  if (unlikely(result < 0)) {
292  dprintk("ir->get_key() failed %d\n", result);
293  return;
294  }
295 
296  if (unlikely(poll_result.read_count != ir->last_readcount)) {
297  dprintk("%s: toggle: %d, count: %d, key 0x%02x%02x\n", __func__,
298  poll_result.toggle_bit, poll_result.read_count,
299  poll_result.rc_address, poll_result.rc_data[0]);
300  if (ir->full_code)
301  rc_keydown(ir->rc,
302  poll_result.rc_address << 8 |
303  poll_result.rc_data[0],
304  poll_result.toggle_bit);
305  else
306  rc_keydown(ir->rc,
307  poll_result.rc_data[0],
308  poll_result.toggle_bit);
309 
310  if (ir->dev->chip_id == CHIP_ID_EM2874 ||
311  ir->dev->chip_id == CHIP_ID_EM2884)
312  /* The em2874 clears the readcount field every time the
313  register is read. The em2860/2880 datasheet says that it
314  is supposed to clear the readcount, but it doesn't. So with
315  the em2874, we are looking for a non-zero read count as
316  opposed to a readcount that is incrementing */
317  ir->last_readcount = 0;
318  else
319  ir->last_readcount = poll_result.read_count;
320  }
321 }
322 
323 static void em28xx_ir_work(struct work_struct *work)
324 {
325  struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work);
326 
327  em28xx_ir_handle_key(ir);
329 }
330 
331 static int em28xx_ir_start(struct rc_dev *rc)
332 {
333  struct em28xx_IR *ir = rc->priv;
334 
335  INIT_DELAYED_WORK(&ir->work, em28xx_ir_work);
336  schedule_delayed_work(&ir->work, 0);
337 
338  return 0;
339 }
340 
341 static void em28xx_ir_stop(struct rc_dev *rc)
342 {
343  struct em28xx_IR *ir = rc->priv;
344 
346 }
347 
348 static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 rc_type)
349 {
350  int rc = 0;
351  struct em28xx_IR *ir = rc_dev->priv;
352  struct em28xx *dev = ir->dev;
353  u8 ir_config = EM2874_IR_RC5;
354 
355  /* Adjust xclk based o IR table for RC5/NEC tables */
356 
357  if (rc_type == RC_TYPE_RC5) {
358  dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
359  ir->full_code = 1;
360  } else if (rc_type == RC_TYPE_NEC) {
361  dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
362  ir_config = EM2874_IR_NEC;
363  ir->full_code = 1;
364  } else if (rc_type != RC_TYPE_UNKNOWN)
365  rc = -EINVAL;
366 
369 
370  /* Setup the proper handler based on the chip */
371  switch (dev->chip_id) {
372  case CHIP_ID_EM2860:
373  case CHIP_ID_EM2883:
374  ir->get_key = default_polling_getkey;
375  break;
376  case CHIP_ID_EM2884:
377  case CHIP_ID_EM2874:
378  case CHIP_ID_EM28174:
379  ir->get_key = em2874_polling_getkey;
380  em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
381  break;
382  default:
383  printk("Unrecognized em28xx chip id 0x%02x: IR not supported\n",
384  dev->chip_id);
385  rc = -EINVAL;
386  }
387 
388  return rc;
389 }
390 
391 static void em28xx_register_i2c_ir(struct em28xx *dev)
392 {
393  /* Leadtek winfast tv USBII deluxe can find a non working IR-device */
394  /* at address 0x18, so if that address is needed for another board in */
395  /* the future, please put it after 0x1f. */
396  struct i2c_board_info info;
397  const unsigned short addr_list[] = {
398  0x1f, 0x30, 0x47, I2C_CLIENT_END
399  };
400 
401  memset(&info, 0, sizeof(struct i2c_board_info));
402  memset(&dev->init_data, 0, sizeof(dev->init_data));
403  strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
404 
405  /* detect & configure */
406  switch (dev->model) {
409  dev->init_data.ir_codes = RC_MAP_EM_TERRATEC;
410  dev->init_data.get_key = em28xx_get_key_terratec;
411  dev->init_data.name = "i2c IR (EM28XX Terratec)";
412  break;
414  dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
415  dev->init_data.get_key = em28xx_get_key_pinnacle_usb_grey;
416  dev->init_data.name = "i2c IR (EM28XX Pinnacle PCTV)";
417  break;
419  dev->init_data.ir_codes = RC_MAP_HAUPPAUGE;
420  dev->init_data.get_key = em28xx_get_key_em_haup;
421  dev->init_data.name = "i2c IR (EM2840 Hauppauge)";
422  break;
424  dev->init_data.ir_codes = RC_MAP_WINFAST_USBII_DELUXE;
425  dev->init_data.get_key = em28xx_get_key_winfast_usbii_deluxe;
426  dev->init_data.name = "i2c IR (EM2820 Winfast TV USBII Deluxe)";
427  break;
428  }
429 
430  if (dev->init_data.name)
431  info.platform_data = &dev->init_data;
432  i2c_new_probed_device(&dev->i2c_adap, &info, addr_list, NULL);
433 }
434 
435 /**********************************************************
436  Handle Webcam snapshot button
437  **********************************************************/
438 
439 static void em28xx_query_sbutton(struct work_struct *work)
440 {
441  /* Poll the register and see if the button is depressed */
442  struct em28xx *dev =
443  container_of(work, struct em28xx, sbutton_query_work.work);
444  int ret;
445 
447 
448  if (ret & EM28XX_R0C_USBSUSP_SNAPSHOT) {
449  u8 cleared;
450  /* Button is depressed, clear the register */
451  cleared = ((u8) ret) & ~EM28XX_R0C_USBSUSP_SNAPSHOT;
452  em28xx_write_regs(dev, EM28XX_R0C_USBSUSP, &cleared, 1);
453 
454  /* Not emulate the keypress */
455  input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
456  1);
457  /* Now unpress the key */
458  input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
459  0);
460  }
461 
462  /* Schedule next poll */
465 }
466 
467 static void em28xx_register_snapshot_button(struct em28xx *dev)
468 {
469  struct input_dev *input_dev;
470  int err;
471 
472  em28xx_info("Registering snapshot button...\n");
473  input_dev = input_allocate_device();
474  if (!input_dev) {
475  em28xx_errdev("input_allocate_device failed\n");
476  return;
477  }
478 
479  usb_make_path(dev->udev, dev->snapshot_button_path,
480  sizeof(dev->snapshot_button_path));
481  strlcat(dev->snapshot_button_path, "/sbutton",
482  sizeof(dev->snapshot_button_path));
483  INIT_DELAYED_WORK(&dev->sbutton_query_work, em28xx_query_sbutton);
484 
485  input_dev->name = "em28xx snapshot button";
486  input_dev->phys = dev->snapshot_button_path;
487  input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
488  set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit);
489  input_dev->keycodesize = 0;
490  input_dev->keycodemax = 0;
491  input_dev->id.bustype = BUS_USB;
492  input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
493  input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
494  input_dev->id.version = 1;
495  input_dev->dev.parent = &dev->udev->dev;
496 
497  err = input_register_device(input_dev);
498  if (err) {
499  em28xx_errdev("input_register_device failed\n");
500  input_free_device(input_dev);
501  return;
502  }
503 
504  dev->sbutton_input_dev = input_dev;
507  return;
508 
509 }
510 
511 static void em28xx_deregister_snapshot_button(struct em28xx *dev)
512 {
513  if (dev->sbutton_input_dev != NULL) {
514  em28xx_info("Deregistering snapshot button\n");
516  input_unregister_device(dev->sbutton_input_dev);
517  dev->sbutton_input_dev = NULL;
518  }
519  return;
520 }
521 
522 static int em28xx_ir_init(struct em28xx *dev)
523 {
524  struct em28xx_IR *ir;
525  struct rc_dev *rc;
526  int err = -ENOMEM;
527 
528  if (dev->board.ir_codes == NULL) {
529  /* No remote control support */
530  em28xx_warn("Remote control support is not available for "
531  "this card.\n");
532  return 0;
533  }
534 
535  ir = kzalloc(sizeof(*ir), GFP_KERNEL);
536  rc = rc_allocate_device();
537  if (!ir || !rc)
538  goto err_out_free;
539 
540  /* record handles to ourself */
541  ir->dev = dev;
542  dev->ir = ir;
543  ir->rc = rc;
544 
545  /*
546  * em2874 supports more protocols. For now, let's just announce
547  * the two protocols that were already tested
548  */
550  rc->priv = ir;
551  rc->change_protocol = em28xx_ir_change_protocol;
552  rc->open = em28xx_ir_start;
553  rc->close = em28xx_ir_stop;
554 
555  /* By default, keep protocol field untouched */
556  err = em28xx_ir_change_protocol(rc, RC_TYPE_UNKNOWN);
557  if (err)
558  goto err_out_free;
559 
560  /* This is how often we ask the chip for IR information */
561  ir->polling = 100; /* ms */
562 
563  /* init input device */
564  snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)",
565  dev->name);
566 
567  usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
568  strlcat(ir->phys, "/input0", sizeof(ir->phys));
569 
570  rc->input_name = ir->name;
571  rc->input_phys = ir->phys;
572  rc->input_id.bustype = BUS_USB;
573  rc->input_id.version = 1;
574  rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
575  rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
576  rc->dev.parent = &dev->udev->dev;
577  rc->map_name = dev->board.ir_codes;
578  rc->driver_name = MODULE_NAME;
579 
580  /* all done */
581  err = rc_register_device(rc);
582  if (err)
583  goto err_out_stop;
584 
585  em28xx_register_i2c_ir(dev);
586 
587 #if defined(CONFIG_MODULES) && defined(MODULE)
588  if (dev->board.has_ir_i2c)
589  request_module("ir-kbd-i2c");
590 #endif
591  if (dev->board.has_snapshot_button)
592  em28xx_register_snapshot_button(dev);
593 
594  return 0;
595 
596  err_out_stop:
597  dev->ir = NULL;
598  err_out_free:
599  rc_free_device(rc);
600  kfree(ir);
601  return err;
602 }
603 
604 static int em28xx_ir_fini(struct em28xx *dev)
605 {
606  struct em28xx_IR *ir = dev->ir;
607 
608  em28xx_deregister_snapshot_button(dev);
609 
610  /* skip detach on non attached boards */
611  if (!ir)
612  return 0;
613 
614  if (ir->rc)
616 
617  /* done */
618  kfree(ir);
619  dev->ir = NULL;
620  return 0;
621 }
622 
623 static struct em28xx_ops rc_ops = {
624  .id = EM28XX_RC,
625  .name = "Em28xx Input Extension",
626  .init = em28xx_ir_init,
627  .fini = em28xx_ir_fini,
628 };
629 
630 static int __init em28xx_rc_register(void)
631 {
632  return em28xx_register_extension(&rc_ops);
633 }
634 
635 static void __exit em28xx_rc_unregister(void)
636 {
638 }
639 
640 MODULE_LICENSE("GPL");
641 MODULE_AUTHOR("Mauro Carvalho Chehab <[email protected]>");
642 MODULE_DESCRIPTION("Em28xx Input driver");
643 
644 module_init(em28xx_rc_register);
645 module_exit(em28xx_rc_unregister);