3 * keyboard input driver for i2c IR remote controls
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>
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.
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.
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
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/i2c-id.h>
48 #include <linux/workqueue.h>
50 #include <media/ir-common.h>
51 #include <media/ir-kbd-i2c.h>
53 /* ----------------------------------------------------------------------- */
54 /* insmod parameters */
57 module_param(debug, int, 0644); /* debug level (0,1,2) */
60 module_param(hauppauge, int, 0644); /* Choose Hauppauge remote */
61 MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
64 #define DEVNAME "ir-kbd-i2c"
65 #define dprintk(level, fmt, arg...) if (debug >= level) \
66 printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
68 /* ----------------------------------------------------------------------- */
70 static int get_key_haup_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
74 int start, range, toggle, dev, code, ircode;
77 if (size != i2c_master_recv(&ir->c,buf,size))
80 /* split rc5 data block ... */
81 start = (buf[offset] >> 7) & 1;
82 range = (buf[offset] >> 6) & 1;
83 toggle = (buf[offset] >> 5) & 1;
84 dev = buf[offset] & 0x1f;
85 code = (buf[offset+1] >> 2) & 0x3f;
87 /* rc5 has two start bits
88 * the first bit must be one
89 * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
95 * Hauppauge remotes (black/silver) always use
96 * specific device ids. If we do not filter the
97 * device ids then messages destined for devices
98 * such as TVs (id=0) will get through causing
101 * We also filter out invalid key presses which
102 * produce annoying debug log entries.
104 ircode= (start << 12) | (toggle << 11) | (dev << 6) | code;
105 if ((ircode & 0x1fff)==0x1fff)
106 /* invalid key press */
109 if (dev!=0x1e && dev!=0x1f)
110 /* not a hauppauge remote */
116 dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
117 start, range, toggle, dev, code);
125 static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
127 return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
130 static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
132 return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
135 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
140 if (1 != i2c_master_recv(&ir->c,&b,1)) {
141 dprintk(1,"read error\n");
149 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
154 if (1 != i2c_master_recv(&ir->c,&b,1)) {
155 dprintk(1,"read error\n");
162 dprintk(2,"key %02x\n", b);
169 static int get_key_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
171 unsigned char buf[4];
174 if (4 != i2c_master_recv(&ir->c,buf,4)) {
175 dprintk(1,"read error\n");
179 if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
180 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
181 buf[0], buf[1], buf[2], buf[3]);
183 /* no key pressed or signal from other ir remote */
184 if(buf[0] != 0x1 || buf[1] != 0xfe)
188 *ir_raw = (buf[2] << 8) | buf[3];
193 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
198 if (1 != i2c_master_recv(&ir->c,&b,1)) {
199 dprintk(1,"read error\n");
203 /* it seems that 0xFE indicates that a button is still hold
204 down, while 0xff indicates that no button is hold
205 down. 0xfe sequences are sometimes interrupted by 0xFF */
207 dprintk(2,"key %02x\n", b);
221 static int get_key_avermedia_cardbus(struct IR_i2c *ir,
222 u32 *ir_key, u32 *ir_raw)
224 unsigned char subaddr, key, keygroup;
225 struct i2c_msg msg[] = { { .addr = ir->c.addr, .flags = 0,
226 .buf = &subaddr, .len = 1},
227 { .addr = ir->c.addr, .flags = I2C_M_RD,
228 .buf = &key, .len = 1} };
230 if (2 != i2c_transfer(ir->c.adapter, msg, 2)) {
231 dprintk(1, "read error\n");
239 msg[1].buf = &keygroup;
240 if (2 != i2c_transfer(ir->c.adapter, msg, 2)) {
241 dprintk(1, "read error\n");
245 if (keygroup == 0xff)
248 dprintk(1, "read key 0x%02x/0x%02x\n", key, keygroup);
249 if (keygroup < 2 || keygroup > 3) {
251 dprintk(1, "warning: invalid key group 0x%02x for key 0x%02x\n",
254 key |= (keygroup & 1) << 6;
261 /* ----------------------------------------------------------------------- */
263 static void ir_key_poll(struct IR_i2c *ir)
265 static u32 ir_key, ir_raw;
268 dprintk(2,"ir_poll_key\n");
269 rc = ir->get_key(ir, &ir_key, &ir_raw);
271 dprintk(2,"error\n");
276 ir_input_nokey(ir->input, &ir->ir);
278 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
282 static void ir_timer(unsigned long data)
284 struct IR_i2c *ir = (struct IR_i2c*)data;
285 schedule_work(&ir->work);
288 static void ir_work(struct work_struct *work)
290 struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
291 int polling_interval = 100;
293 /* MSI TV@nywhere Plus requires more frequent polling
294 otherwise it will miss some keypresses */
295 if (ir->c.adapter->id == I2C_HW_SAA7134 && ir->c.addr == 0x30)
296 polling_interval = 50;
299 mod_timer(&ir->timer, jiffies + msecs_to_jiffies(polling_interval));
302 /* ----------------------------------------------------------------------- */
304 static int ir_attach(struct i2c_adapter *adap, int addr,
305 unsigned short flags, int kind);
306 static int ir_detach(struct i2c_client *client);
307 static int ir_probe(struct i2c_adapter *adap);
309 static struct i2c_driver driver = {
311 .name = "ir-kbd-i2c",
313 .id = I2C_DRIVERID_INFRARED,
314 .attach_adapter = ir_probe,
315 .detach_client = ir_detach,
318 static struct i2c_client client_template =
324 static int ir_attach(struct i2c_adapter *adap, int addr,
325 unsigned short flags, int kind)
327 IR_KEYTAB_TYPE *ir_codes = NULL;
331 struct input_dev *input_dev;
334 ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
335 input_dev = input_allocate_device();
336 if (!ir || !input_dev) {
341 ir->c = client_template;
342 ir->input = input_dev;
344 ir->c.adapter = adap;
347 i2c_set_clientdata(&ir->c, ir);
352 ir->get_key = get_key_pixelview;
353 ir_type = IR_TYPE_OTHER;
354 ir_codes = ir_codes_empty;
358 ir->get_key = get_key_pv951;
359 ir_type = IR_TYPE_OTHER;
360 ir_codes = ir_codes_pv951;
365 ir->get_key = get_key_haup;
366 ir_type = IR_TYPE_RC5;
367 if (hauppauge == 1) {
368 ir_codes = ir_codes_hauppauge_new;
370 ir_codes = ir_codes_rc5_tv;
375 ir->get_key = get_key_knc1;
376 ir_type = IR_TYPE_OTHER;
377 ir_codes = ir_codes_empty;
381 ir->get_key = get_key_fusionhdtv;
382 ir_type = IR_TYPE_RC5;
383 ir_codes = ir_codes_fusionhdtv_mce;
389 if (adap->id == I2C_HW_B_CX2388x) {
390 /* Handled by cx88-input */
391 name = "CX2388x remote";
392 ir_type = IR_TYPE_RC5;
393 ir->get_key = get_key_haup_xvr;
394 if (hauppauge == 1) {
395 ir_codes = ir_codes_hauppauge_new;
397 ir_codes = ir_codes_rc5_tv;
400 /* Handled by saa7134-input */
401 name = "SAA713x remote";
402 ir_type = IR_TYPE_OTHER;
406 name = "AVerMedia Cardbus remote";
407 ir->get_key = get_key_avermedia_cardbus;
408 ir_type = IR_TYPE_OTHER;
409 ir_codes = ir_codes_avermedia_cardbus;
412 /* shouldn't happen */
413 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
419 snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
420 ir->ir_codes = ir_codes;
422 /* register i2c device
423 * At device register, IR codes may be changed to be
426 err = i2c_attach_client(&ir->c);
430 /* If IR not supported or disabled, unregisters driver */
431 if (ir->get_key == NULL) {
436 /* Phys addr can only be set after attaching (for ir->c.dev) */
437 snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
438 dev_name(&ir->c.adapter->dev),
439 dev_name(&ir->c.dev));
441 /* init + register input device */
442 ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
443 input_dev->id.bustype = BUS_I2C;
444 input_dev->name = ir->c.name;
445 input_dev->phys = ir->phys;
447 err = input_register_device(ir->input);
451 printk(DEVNAME ": %s detected at %s [%s]\n",
452 ir->input->name, ir->input->phys, adap->name);
454 /* start polling via eventd */
455 INIT_WORK(&ir->work, ir_work);
456 init_timer(&ir->timer);
457 ir->timer.function = ir_timer;
458 ir->timer.data = (unsigned long)ir;
459 schedule_work(&ir->work);
464 i2c_detach_client(&ir->c);
466 input_free_device(input_dev);
471 static int ir_detach(struct i2c_client *client)
473 struct IR_i2c *ir = i2c_get_clientdata(client);
475 /* kill outstanding polls */
476 del_timer_sync(&ir->timer);
477 flush_scheduled_work();
479 /* unregister devices */
480 input_unregister_device(ir->input);
481 i2c_detach_client(&ir->c);
488 static int ir_probe(struct i2c_adapter *adap)
491 /* The external IR receiver is at i2c address 0x34 (0x35 for
492 reads). Future Hauppauge cards will have an internal
493 receiver at 0x30 (0x31 for reads). In theory, both can be
494 fitted, and Hauppauge suggest an external overrides an
497 That's why we probe 0x1a (~0x34) first. CB
500 static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
501 static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
502 static const int probe_em28XX[] = { 0x30, 0x47, -1 };
503 static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
504 static const int probe_cx23885[] = { 0x6b, -1 };
506 struct i2c_msg msg = {
517 case I2C_HW_B_CX2341X:
521 probe = probe_saa7134;
523 case I2C_HW_B_EM28XX:
524 probe = probe_em28XX;
526 case I2C_HW_B_CX2388x:
529 case I2C_HW_B_CX23885:
530 probe = probe_cx23885;
536 for (i = 0; -1 != probe[i]; i++) {
538 rc = i2c_transfer(adap, &msg, 1);
539 dprintk(1,"probe 0x%02x @ %s: %s\n",
540 probe[i], adap->name,
541 (1 == rc) ? "yes" : "no");
543 ir_attach(adap, probe[i], 0, 0);
548 /* Special case for MSI TV@nywhere Plus remote */
549 if (adap->id == I2C_HW_SAA7134) {
552 /* MSI TV@nywhere Plus controller doesn't seem to
553 respond to probes unless we read something from
554 an existing device. Weird... */
557 rc = i2c_transfer(adap, &msg, 1);
558 dprintk(1, "probe 0x%02x @ %s: %s\n",
559 msg.addr, adap->name,
560 (1 == rc) ? "yes" : "no");
562 /* Now do the probe. The controller does not respond
563 to 0-byte reads, so we use a 1-byte read instead. */
567 rc = i2c_transfer(adap, &msg, 1);
568 dprintk(1, "probe 0x%02x @ %s: %s\n",
569 msg.addr, adap->name,
570 (1 == rc) ? "yes" : "no");
572 ir_attach(adap, msg.addr, 0, 0);
575 /* Special case for AVerMedia Cardbus remote */
576 if (adap->id == I2C_HW_SAA7134) {
577 unsigned char subaddr, data;
578 struct i2c_msg msg[] = { { .addr = 0x40, .flags = 0,
579 .buf = &subaddr, .len = 1},
580 { .addr = 0x40, .flags = I2C_M_RD,
581 .buf = &data, .len = 1} };
583 rc = i2c_transfer(adap, msg, 2);
584 dprintk(1, "probe 0x%02x/0x%02x @ %s: %s\n",
585 msg[0].addr, subaddr, adap->name,
586 (2 == rc) ? "yes" : "no");
588 ir_attach(adap, msg[0].addr, 0, 0);
594 /* ----------------------------------------------------------------------- */
596 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
597 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
598 MODULE_LICENSE("GPL");
600 static int __init ir_init(void)
602 return i2c_add_driver(&driver);
605 static void __exit ir_fini(void)
607 i2c_del_driver(&driver);
610 module_init(ir_init);
611 module_exit(ir_fini);
614 * Overrides for Emacs so that we follow Linus's tabbing style.
615 * ---------------------------------------------------------------------------