History

[media] Remove staging/lirc/lirc_i2c driver

This driver duplicates the same functionality found at ir-kbd-i2c. There were a few missing key parsers that were added by the previous patches. The only thing left on lirc_i2c driver is the IR parsing for Asus TV-Box and Creative/VisionTek BreakOut-Box. Those devices use pcf8574 chip for IR. They are old video adapters with TV tuners. Their code were never merged upstream, and they are not chipped anymore. So, it is very unlikely that someone would have interests on porting them to the Linux Kernel. Due to that, let's remove lirc_i2c, as all the remaining functionality are already mapped via ir-kbd-i2c.

Mauro Carvalho Chehab committed 15 years ago

Commit 41ca2b11 parent 8a6334f3 files · +0 −544Browse files

Showing the changes to drivers/staging/lirc (3 of 3 files). Show all

Unified · Split

3 files
  1. drivers/staging/lirc/Kconfig +0 −7
  2. drivers/staging/lirc/Makefile +0 −1
  3. drivers/staging/lirc/lirc_i2c.c +0 −536
drivers/staging/lirc/Kconfig+0−7
@@ -18,13 +18,6 @@ config LIRC_BT829 · 17 unmodified lines
1818 help
1919 Driver for the IR interface on BT829-based hardware
2020
21−config LIRC_I2C
22− tristate "I2C Based IR Receivers"
23− depends on LIRC && I2C
24− help
25− Driver for I2C-based IR receivers, such as those commonly
26− found onboard Hauppauge PVR-150/250/350 video capture cards
27−
2821 config LIRC_IGORPLUGUSB
2922 tristate "Igor Cesko's USB IR Receiver"
3023 depends on LIRC && USB
drivers/staging/lirc/Makefile+0−1
@@ -4,7 +4,6 @@ · 3 unmodified lines
44 # Each configuration option enables a list of files.
55
66 obj-$(CONFIG_LIRC_BT829) += lirc_bt829.o
7−obj-$(CONFIG_LIRC_I2C) += lirc_i2c.o
87 obj-$(CONFIG_LIRC_IGORPLUGUSB) += lirc_igorplugusb.o
98 obj-$(CONFIG_LIRC_IMON) += lirc_imon.o
109 obj-$(CONFIG_LIRC_IT87) += lirc_it87.o
drivers/staging/lirc/lirc_i2c.c+0−536
@@ -1,536 +0,0 @@
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);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t