History

V4L/DVB: staging/lirc: add lirc_i2c driver

Jarod Wilson committed 16 years ago

Commit 085ffd01 parent 9119fdd1 file · +536 −0Browse files

Showing the changes to drivers/staging/lirc/lirc_i2c.c (1 of 1 file). Show all

Unified · Split

drivers/staging/lirc/lirc_i2c.c+536−0
@@ -0,0 +1,536 @@
1+/*
2+ * lirc_i2c.c
3+ *
4+ * i2c IR driver for the onboard IR port on many TV tuner cards, including:
5+ * -Flavors of the Hauppauge PVR-150/250/350
6+ * -Hauppauge HVR-1300
7+ * -PixelView (BT878P+W/FM)
8+ * -KNC ONE TV Station/Anubis Typhoon TView Tuner
9+ * -Asus TV-Box and Creative/VisionTek BreakOut-Box
10+ * -Leadtek Winfast PVR2000
11+ *
12+ * Copyright (c) 2000 Gerd Knorr <kraxel@goldbach.in-berlin.de>
13+ * modified for PixelView (BT878P+W/FM) by
14+ * Michal Kochanowicz <mkochano@pld.org.pl>
15+ * Christoph Bartelmus <lirc@bartelmus.de>
16+ * modified for KNC ONE TV Station/Anubis Typhoon TView Tuner by
17+ * Ulrich Mueller <ulrich.mueller42@web.de>
18+ * modified for Asus TV-Box and Creative/VisionTek BreakOut-Box by
19+ * Stefan Jahn <stefan@lkcc.org>
20+ * modified for inclusion into kernel sources by
21+ * Jerome Brock <jbrock@users.sourceforge.net>
22+ * modified for Leadtek Winfast PVR2000 by
23+ * Thomas Reitmayr (treitmayr@yahoo.com)
24+ * modified for Hauppauge HVR-1300 by
25+ * Jan Frey (jfrey@gmx.de)
26+ *
27+ * parts are cut&pasted from the old lirc_haup.c driver
28+ *
29+ * This program is free software; you can redistribute it and/or modify
30+ * it under the terms of the GNU General Public License as published by
31+ * the Free Software Foundation; either version 2 of the License, or
32+ * (at your option) any later version.
33+ *
34+ * This program is distributed in the hope that it will be useful,
35+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
36+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37+ * GNU General Public License for more details.
38+ *
39+ * You should have received a copy of the GNU General Public License
40+ * along with this program; if not, write to the Free Software
41+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42+ */
43+
44+
45+#include <linux/version.h>
46+#include <linux/module.h>
47+#include <linux/kmod.h>
48+#include <linux/kernel.h>
49+#include <linux/sched.h>
50+#include <linux/string.h>
51+#include <linux/timer.h>
52+#include <linux/delay.h>
53+#include <linux/errno.h>
54+#include <linux/slab.h>
55+#include <linux/i2c.h>
56+#include <linux/i2c-algo-bit.h>
57+
58+#include <media/lirc_dev.h>
59+
60+struct IR {
61+ struct lirc_driver l;
62+ struct i2c_client c;
63+ int nextkey;
64+ unsigned char b[3];
65+ unsigned char bits;
66+ unsigned char flag;
67+};
68+
69+#define DEVICE_NAME "lirc_i2c"
70+
71+/* module parameters */
72+static int debug; /* debug output */
73+static int minor = -1; /* minor number */
74+
75+#define dprintk(fmt, args...) \
76+ do { \
77+ if (debug) \
78+ printk(KERN_DEBUG DEVICE_NAME ": " fmt, \
79+ ## args); \
80+ } while (0)
81+
82+static int reverse(int data, int bits)
83+{
84+ int i;
85+ int c;
86+
87+ for (c = 0, i = 0; i < bits; i++)
88+ c |= ((data & (1<<i)) ? 1 : 0) << (bits-1-i);
89+
90+ return c;
91+}
92+
93+static int add_to_buf_adap(void *data, struct lirc_buffer *buf)
94+{
95+ struct IR *ir = data;
96+ unsigned char keybuf[4];
97+
98+ keybuf[0] = 0x00;
99+ i2c_master_send(&ir->c, keybuf, 1);
100+ /* poll IR chip */
101+ if (i2c_master_recv(&ir->c, keybuf, sizeof(keybuf)) != sizeof(keybuf)) {
102+ dprintk("read error\n");
103+ return -EIO;
104+ }
105+
106+ dprintk("key (0x%02x%02x%02x%02x)\n",
107+ keybuf[0], keybuf[1], keybuf[2], keybuf[3]);
108+
109+ /* key pressed ? */
110+ if (keybuf[2] == 0xff)
111+ return -ENODATA;
112+
113+ /* remove repeat bit */
114+ keybuf[2] &= 0x7f;
115+ keybuf[3] |= 0x80;
116+
117+ lirc_buffer_write(buf, keybuf);
118+ return 0;
119+}
120+
121+static int add_to_buf_pcf8574(void *data, struct lirc_buffer *buf)
122+{
123+ struct IR *ir = data;
124+ int rc;
125+ unsigned char all, mask;
126+ unsigned char key;
127+
128+ /* compute all valid bits (key code + pressed/release flag) */
129+ all = ir->bits | ir->flag;
130+
131+ /* save IR writable mask bits */
132+ mask = i2c_smbus_read_byte(&ir->c) & ~all;
133+
134+ /* send bit mask */
135+ rc = i2c_smbus_write_byte(&ir->c, (0xff & all) | mask);
136+
137+ /* receive scan code */
138+ rc = i2c_smbus_read_byte(&ir->c);
139+
140+ if (rc == -1) {
141+ dprintk("%s read error\n", ir->c.name);
142+ return -EIO;
143+ }
144+
145+ /* drop duplicate polls */
146+ if (ir->b[0] == (rc & all))
147+ return -ENODATA;
148+
149+ ir->b[0] = rc & all;
150+
151+ dprintk("%s key 0x%02X %s\n", ir->c.name, rc & ir->bits,
152+ (rc & ir->flag) ? "released" : "pressed");
153+
154+ /* ignore released buttons */
155+ if (rc & ir->flag)
156+ return -ENODATA;
157+
158+ /* set valid key code */
159+ key = rc & ir->bits;
160+ lirc_buffer_write(buf, &key);
161+ return 0;
162+}
163+
164+/* common for Hauppauge IR receivers */
165+static int add_to_buf_haup_common(void *data, struct lirc_buffer *buf,
166+ unsigned char *keybuf, int size, int offset)
167+{
168+ struct IR *ir = data;
169+ __u16 code;
170+ unsigned char codes[2];
171+ int ret;
172+
173+ /* poll IR chip */
174+ ret = i2c_master_recv(&ir->c, keybuf, size);
175+ if (ret == size) {
176+ ir->b[0] = keybuf[offset];
177+ ir->b[1] = keybuf[offset+1];
178+ ir->b[2] = keybuf[offset+2];
179+ if (ir->b[0] != 0x00 && ir->b[1] != 0x00)
180+ dprintk("key (0x%02x/0x%02x)\n", ir->b[0], ir->b[1]);
181+ } else {
182+ dprintk("read error (ret=%d)\n", ret);
183+ /* keep last successful read buffer */
184+ }
185+
186+ /* key pressed ? */
187+ if ((ir->b[0] & 0x80) == 0)
188+ return -ENODATA;
189+
190+ /* look what we have */
191+ code = (((__u16)ir->b[0]&0x7f)<<6) | (ir->b[1]>>2);
192+
193+ codes[0] = (code >> 8) & 0xff;
194+ codes[1] = code & 0xff;
195+
196+ /* return it */
197+ dprintk("sending code 0x%02x%02x to lirc\n", codes[0], codes[1]);
198+ lirc_buffer_write(buf, codes);
199+ return 0;
200+}
201+
202+/* specific for the Hauppauge PVR150 IR receiver */
203+static int add_to_buf_haup_pvr150(void *data, struct lirc_buffer *buf)
204+{
205+ unsigned char keybuf[6];
206+ /* fetch 6 bytes, first relevant is at offset 3 */
207+ return add_to_buf_haup_common(data, buf, keybuf, 6, 3);
208+}
209+
210+/* used for all Hauppauge IR receivers but the PVR150 */
211+static int add_to_buf_haup(void *data, struct lirc_buffer *buf)
212+{
213+ unsigned char keybuf[3];
214+ /* fetch 3 bytes, first relevant is at offset 0 */
215+ return add_to_buf_haup_common(data, buf, keybuf, 3, 0);
216+}
217+
218+
219+static int add_to_buf_pvr2000(void *data, struct lirc_buffer *buf)
220+{
221+ struct IR *ir = data;
222+ unsigned char key;
223+ s32 flags;
224+ s32 code;
225+
226+ /* poll IR chip */
227+ flags = i2c_smbus_read_byte_data(&ir->c, 0x10);
228+ if (-1 == flags) {
229+ dprintk("read error\n");
230+ return -ENODATA;
231+ }
232+ /* key pressed ? */
233+ if (0 == (flags & 0x80))
234+ return -ENODATA;
235+
236+ /* read actual key code */
237+ code = i2c_smbus_read_byte_data(&ir->c, 0x00);
238+ if (-1 == code) {
239+ dprintk("read error\n");
240+ return -ENODATA;
241+ }
242+
243+ key = code & 0xFF;
244+
245+ dprintk("IR Key/Flags: (0x%02x/0x%02x)\n", key, flags & 0xFF);
246+
247+ /* return it */
248+ lirc_buffer_write(buf, &key);
249+ return 0;
250+}
251+
252+static int add_to_buf_pixelview(void *data, struct lirc_buffer *buf)
253+{
254+ struct IR *ir = data;
255+ unsigned char key;
256+
257+ /* poll IR chip */
258+ if (1 != i2c_master_recv(&ir->c, &key, 1)) {
259+ dprintk("read error\n");
260+ return -1;
261+ }
262+ dprintk("key %02x\n", key);
263+
264+ /* return it */
265+ lirc_buffer_write(buf, &key);
266+ return 0;
267+}
268+
269+static int add_to_buf_pv951(void *data, struct lirc_buffer *buf)
270+{
271+ struct IR *ir = data;
272+ unsigned char key;
273+ unsigned char codes[4];
274+
275+ /* poll IR chip */
276+ if (1 != i2c_master_recv(&ir->c, &key, 1)) {
277+ dprintk("read error\n");
278+ return -ENODATA;
279+ }
280+ /* ignore 0xaa */
281+ if (key == 0xaa)
282+ return -ENODATA;
283+ dprintk("key %02x\n", key);
284+
285+ codes[0] = 0x61;
286+ codes[1] = 0xD6;
287+ codes[2] = reverse(key, 8);
288+ codes[3] = (~codes[2])&0xff;
289+
290+ lirc_buffer_write(buf, codes);
291+ return 0;
292+}
293+
294+static int add_to_buf_knc1(void *data, struct lirc_buffer *buf)
295+{
296+ static unsigned char last_key = 0xFF;
297+ struct IR *ir = data;
298+ unsigned char key;
299+
300+ /* poll IR chip */
301+ if (1 != i2c_master_recv(&ir->c, &key, 1)) {
302+ dprintk("read error\n");
303+ return -ENODATA;
304+ }
305+
306+ /*
307+ * it seems that 0xFE indicates that a button is still held
308+ * down, while 0xFF indicates that no button is held
309+ * down. 0xFE sequences are sometimes interrupted by 0xFF
310+ */
311+
312+ dprintk("key %02x\n", key);
313+
314+ if (key == 0xFF)
315+ return -ENODATA;
316+
317+ if (key == 0xFE)
318+ key = last_key;
319+
320+ last_key = key;
321+ lirc_buffer_write(buf, &key);
322+
323+ return 0;
324+}
325+
326+static int set_use_inc(void *data)
327+{
328+ struct IR *ir = data;
329+
330+ dprintk("%s called\n", __func__);
331+
332+ /* lock bttv in memory while /dev/lirc is in use */
333+ i2c_use_client(&ir->c);
334+
335+ return 0;
336+}
337+
338+static void set_use_dec(void *data)
339+{
340+ struct IR *ir = data;
341+
342+ dprintk("%s called\n", __func__);
343+
344+ i2c_release_client(&ir->c);
345+}
346+
347+static struct lirc_driver lirc_template = {
348+ .name = "lirc_i2c",
349+ .set_use_inc = set_use_inc,
350+ .set_use_dec = set_use_dec,
351+ .dev = NULL,
352+ .owner = THIS_MODULE,
353+};
354+
355+static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id);
356+static int ir_remove(struct i2c_client *client);
357+static int ir_command(struct i2c_client *client, unsigned int cmd, void *arg);
358+
359+static const struct i2c_device_id ir_receiver_id[] = {
360+ /* Generic entry for any IR receiver */
361+ { "ir_video", 0 },
362+ /* IR device specific entries could be added here */
363+ { }
364+};
365+
366+static struct i2c_driver driver = {
367+ .driver = {
368+ .owner = THIS_MODULE,
369+ .name = "i2c ir driver",
370+ },
371+ .probe = ir_probe,
372+ .remove = ir_remove,
373+ .id_table = ir_receiver_id,
374+ .command = ir_command,
375+};
376+
377+static void pcf_probe(struct i2c_client *client, struct IR *ir)
378+{
379+ int ret1, ret2, ret3, ret4;
380+
381+ ret1 = i2c_smbus_write_byte(client, 0xff);
382+ ret2 = i2c_smbus_read_byte(client);
383+ ret3 = i2c_smbus_write_byte(client, 0x00);
384+ ret4 = i2c_smbus_read_byte(client);
385+
386+ /* in the Asus TV-Box: bit 1-0 */
387+ if (((ret2 & 0x03) == 0x03) && ((ret4 & 0x03) == 0x00)) {
388+ ir->bits = (unsigned char) ~0x07;
389+ ir->flag = 0x04;
390+ /* in the Creative/VisionTek BreakOut-Box: bit 7-6 */
391+ } else if (((ret2 & 0xc0) == 0xc0) && ((ret4 & 0xc0) == 0x00)) {
392+ ir->bits = (unsigned char) ~0xe0;
393+ ir->flag = 0x20;
394+ }
395+
396+ return;
397+}
398+
399+static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
400+{
401+ struct IR *ir;
402+ struct i2c_adapter *adap = client->adapter;
403+ unsigned short addr = client->addr;
404+ int retval;
405+
406+ ir = kzalloc(sizeof(struct IR), GFP_KERNEL);
407+ if (!ir)
408+ return -ENOMEM;
409+ memcpy(&ir->l, &lirc_template, sizeof(struct lirc_driver));
410+ memcpy(&ir->c, client, sizeof(struct i2c_client));
411+
412+ i2c_set_clientdata(client, ir);
413+ ir->l.data = ir;
414+ ir->l.minor = minor;
415+ ir->l.sample_rate = 10;
416+ ir->l.dev = &ir->c.dev;
417+ ir->nextkey = -1;
418+
419+ switch (addr) {
420+ case 0x64:
421+ strlcpy(ir->c.name, "Pixelview IR", I2C_NAME_SIZE);
422+ ir->l.code_length = 8;
423+ ir->l.add_to_buf = add_to_buf_pixelview;
424+ break;
425+ case 0x4b:
426+ strlcpy(ir->c.name, "PV951 IR", I2C_NAME_SIZE);
427+ ir->l.code_length = 32;
428+ ir->l.add_to_buf = add_to_buf_pv951;
429+ break;
430+ case 0x71:
431+ if (adap->id == I2C_HW_B_CX2388x)
432+ strlcpy(ir->c.name, "Hauppauge HVR1300", I2C_NAME_SIZE);
433+ else /* bt8xx or cx2341x */
434+ /*
435+ * The PVR150 IR receiver uses the same protocol as
436+ * other Hauppauge cards, but the data flow is
437+ * different, so we need to deal with it by its own.
438+ */
439+ strlcpy(ir->c.name, "Hauppauge PVR150", I2C_NAME_SIZE);
440+ ir->l.code_length = 13;
441+ ir->l.add_to_buf = add_to_buf_haup_pvr150;
442+ break;
443+ case 0x6b:
444+ strlcpy(ir->c.name, "Adaptec IR", I2C_NAME_SIZE);
445+ ir->l.code_length = 32;
446+ ir->l.add_to_buf = add_to_buf_adap;
447+ break;
448+ case 0x18:
449+ case 0x1a:
450+ if (adap->id == I2C_HW_B_CX2388x) {
451+ strlcpy(ir->c.name, "Leadtek IR", I2C_NAME_SIZE);
452+ ir->l.code_length = 8;
453+ ir->l.add_to_buf = add_to_buf_pvr2000;
454+ } else { /* bt8xx or cx2341x */
455+ strlcpy(ir->c.name, "Hauppauge IR", I2C_NAME_SIZE);
456+ ir->l.code_length = 13;
457+ ir->l.add_to_buf = add_to_buf_haup;
458+ }
459+ break;
460+ case 0x30:
461+ strlcpy(ir->c.name, "KNC ONE IR", I2C_NAME_SIZE);
462+ ir->l.code_length = 8;
463+ ir->l.add_to_buf = add_to_buf_knc1;
464+ break;
465+ case 0x21:
466+ case 0x23:
467+ pcf_probe(client, ir);
468+ strlcpy(ir->c.name, "TV-Box IR", I2C_NAME_SIZE);
469+ ir->l.code_length = 8;
470+ ir->l.add_to_buf = add_to_buf_pcf8574;
471+ break;
472+ default:
473+ /* shouldn't happen */
474+ printk("lirc_i2c: Huh? unknown i2c address (0x%02x)?\n", addr);
475+ kfree(ir);
476+ return -EINVAL;
477+ }
478+ printk(KERN_INFO "lirc_i2c: chip 0x%x found @ 0x%02x (%s)\n",
479+ adap->id, addr, ir->c.name);
480+
481+ retval = lirc_register_driver(&ir->l);
482+
483+ if (retval < 0) {
484+ printk(KERN_ERR "lirc_i2c: failed to register driver!\n");
485+ kfree(ir);
486+ return retval;
487+ }
488+
489+ ir->l.minor = retval;
490+
491+ return 0;
492+}
493+
494+static int ir_remove(struct i2c_client *client)
495+{
496+ struct IR *ir = i2c_get_clientdata(client);
497+
498+ /* unregister device */
499+ lirc_unregister_driver(ir->l.minor);
500+
501+ /* free memory */
502+ kfree(ir);
503+ return 0;
504+}
505+
506+static int ir_command(struct i2c_client *client, unsigned int cmd, void *arg)
507+{
508+ /* nothing */
509+ return 0;
510+}
511+
512+static int __init lirc_i2c_init(void)
513+{
514+ i2c_add_driver(&driver);
515+ return 0;
516+}
517+
518+static void __exit lirc_i2c_exit(void)
519+{
520+ i2c_del_driver(&driver);
521+}
522+
523+MODULE_DESCRIPTION("Infrared receiver driver for Hauppauge and "
524+ "Pixelview cards (i2c stack)");
525+MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, "
526+ "Ulrich Mueller, Stefan Jahn, Jerome Brock");
527+MODULE_LICENSE("GPL");
528+
529+module_param(minor, int, S_IRUGO);
530+MODULE_PARM_DESC(minor, "Preferred minor device number");
531+
532+module_param(debug, bool, S_IRUGO | S_IWUSR);
533+MODULE_PARM_DESC(debug, "Enable debugging messages");
534+
535+module_init(lirc_i2c_init);
536+module_exit(lirc_i2c_exit);