Merge branch 'upstream'
[linux-2.6] / drivers / media / video / ir-kbd-i2c.c
1 /*
2  *
3  * keyboard input driver for i2c IR remote controls
4  *
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  *
14  *  This program is free software; you can redistribute it and/or modify
15  *  it under the terms of the GNU General Public License as published by
16  *  the Free Software Foundation; either version 2 of the License, or
17  *  (at your option) any later version.
18  *
19  *  This program is distributed in the hope that it will be useful,
20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  *  GNU General Public License for more details.
23  *
24  *  You should have received a copy of the GNU General Public License
25  *  along with this program; if not, write to the Free Software
26  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27  *
28  */
29
30 #include <linux/module.h>
31 #include <linux/moduleparam.h>
32 #include <linux/init.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/string.h>
36 #include <linux/timer.h>
37 #include <linux/delay.h>
38 #include <linux/errno.h>
39 #include <linux/slab.h>
40 #include <linux/i2c.h>
41 #include <linux/workqueue.h>
42 #include <asm/semaphore.h>
43
44 #include <media/ir-common.h>
45 #include <media/ir-kbd-i2c.h>
46
47 /* Mark Phalan <phalanm@o2.ie> */
48 static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
49         [  0 ] = KEY_KP0,
50         [  1 ] = KEY_KP1,
51         [  2 ] = KEY_KP2,
52         [  3 ] = KEY_KP3,
53         [  4 ] = KEY_KP4,
54         [  5 ] = KEY_KP5,
55         [  6 ] = KEY_KP6,
56         [  7 ] = KEY_KP7,
57         [  8 ] = KEY_KP8,
58         [  9 ] = KEY_KP9,
59
60         [ 18 ] = KEY_POWER,
61         [ 16 ] = KEY_MUTE,
62         [ 31 ] = KEY_VOLUMEDOWN,
63         [ 27 ] = KEY_VOLUMEUP,
64         [ 26 ] = KEY_CHANNELUP,
65         [ 30 ] = KEY_CHANNELDOWN,
66         [ 14 ] = KEY_PAGEUP,
67         [ 29 ] = KEY_PAGEDOWN,
68         [ 19 ] = KEY_SOUND,
69
70         [ 24 ] = KEY_KPPLUSMINUS,       /* CH +/- */
71         [ 22 ] = KEY_SUBTITLE,          /* CC */
72         [ 13 ] = KEY_TEXT,              /* TTX */
73         [ 11 ] = KEY_TV,                /* AIR/CBL */
74         [ 17 ] = KEY_PC,                /* PC/TV */
75         [ 23 ] = KEY_OK,                /* CH RTN */
76         [ 25 ] = KEY_MODE,              /* FUNC */
77         [ 12 ] = KEY_SEARCH,            /* AUTOSCAN */
78
79         /* Not sure what to do with these ones! */
80         [ 15 ] = KEY_SELECT,            /* SOURCE */
81         [ 10 ] = KEY_KPPLUS,            /* +100 */
82         [ 20 ] = KEY_KPEQUAL,           /* SYNC */
83         [ 28 ] = KEY_MEDIA,             /* PC/TV */
84 };
85
86 /* ----------------------------------------------------------------------- */
87 /* insmod parameters                                                       */
88
89 static int debug;
90 module_param(debug, int, 0644);    /* debug level (0,1,2) */
91
92 #define DEVNAME "ir-kbd-i2c"
93 #define dprintk(level, fmt, arg...)     if (debug >= level) \
94         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
95
96 /* ----------------------------------------------------------------------- */
97
98 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
99 {
100         unsigned char buf[3];
101         int start, toggle, dev, code;
102
103         /* poll IR chip */
104         if (3 != i2c_master_recv(&ir->c,buf,3))
105                 return -EIO;
106
107         /* split rc5 data block ... */
108         start  = (buf[0] >> 6) &    3;
109         toggle = (buf[0] >> 5) &    1;
110         dev    =  buf[0]       & 0x1f;
111         code   = (buf[1] >> 2) & 0x3f;
112
113         if (3 != start)
114                 /* no key pressed */
115                 return 0;
116         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
117                 start, toggle, dev, code);
118
119         /* return key */
120         *ir_key = code;
121         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
122         return 1;
123 }
124
125 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
126 {
127         unsigned char b;
128
129         /* poll IR chip */
130         if (1 != i2c_master_recv(&ir->c,&b,1)) {
131                 dprintk(1,"read error\n");
132                 return -EIO;
133         }
134         *ir_key = b;
135         *ir_raw = b;
136         return 1;
137 }
138
139 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
140 {
141         unsigned char b;
142
143         /* poll IR chip */
144         if (1 != i2c_master_recv(&ir->c,&b,1)) {
145                 dprintk(1,"read error\n");
146                 return -EIO;
147         }
148
149         /* ignore 0xaa */
150         if (b==0xaa)
151                 return 0;
152         dprintk(2,"key %02x\n", b);
153
154         *ir_key = b;
155         *ir_raw = b;
156         return 1;
157 }
158
159 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
160 {
161         unsigned char b;
162
163         /* poll IR chip */
164         if (1 != i2c_master_recv(&ir->c,&b,1)) {
165                 dprintk(1,"read error\n");
166                 return -EIO;
167         }
168
169         /* it seems that 0xFE indicates that a button is still hold
170            down, while 0xff indicates that no button is hold
171            down. 0xfe sequences are sometimes interrupted by 0xFF */
172
173         dprintk(2,"key %02x\n", b);
174
175         if (b == 0xff)
176                 return 0;
177
178         if (b == 0xfe)
179                 /* keep old data */
180                 return 1;
181
182         *ir_key = b;
183         *ir_raw = b;
184         return 1;
185 }
186
187 /* The new pinnacle PCTV remote (with the colored buttons)
188  *
189  * Ricardo Cerqueira <v4l@cerqueira.org>
190  */
191
192 int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
193 {
194         unsigned char b[4];
195         unsigned int start = 0,parity = 0,code = 0;
196
197         /* poll IR chip */
198         if (4 != i2c_master_recv(&ir->c,b,4)) {
199                 dprintk(2,"read error\n");
200                 return -EIO;
201         }
202
203         for (start = 0; start<4; start++) {
204                 if (b[start] == 0x80) {
205                         code=b[(start+3)%4];
206                         parity=b[(start+2)%4];
207                 }
208         }
209
210         /* Empty Request */
211         if (parity==0)
212                 return 0;
213
214         /* Repeating... */
215         if (ir->old == parity)
216                 return 0;
217
218
219         ir->old = parity;
220
221         /* Reduce code value to fit inside IR_KEYTAB_SIZE
222          *
223          * this is the only value that results in 42 unique
224          * codes < 128
225          */
226
227         code %= 0x88;
228
229         *ir_raw = code;
230         *ir_key = code;
231
232         dprintk(1,"Pinnacle PCTV key %02x\n", code);
233
234         return 1;
235 }
236
237 EXPORT_SYMBOL_GPL(get_key_pinnacle);
238
239 /* ----------------------------------------------------------------------- */
240
241 static void ir_key_poll(struct IR_i2c *ir)
242 {
243         static u32 ir_key, ir_raw;
244         int rc;
245
246         dprintk(2,"ir_poll_key\n");
247         rc = ir->get_key(ir, &ir_key, &ir_raw);
248         if (rc < 0) {
249                 dprintk(2,"error\n");
250                 return;
251         }
252
253         if (0 == rc) {
254                 ir_input_nokey(ir->input, &ir->ir);
255         } else {
256                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
257         }
258 }
259
260 static void ir_timer(unsigned long data)
261 {
262         struct IR_i2c *ir = (struct IR_i2c*)data;
263         schedule_work(&ir->work);
264 }
265
266 static void ir_work(void *data)
267 {
268         struct IR_i2c *ir = data;
269         ir_key_poll(ir);
270         mod_timer(&ir->timer, jiffies+HZ/10);
271 }
272
273 /* ----------------------------------------------------------------------- */
274
275 static int ir_attach(struct i2c_adapter *adap, int addr,
276                       unsigned short flags, int kind);
277 static int ir_detach(struct i2c_client *client);
278 static int ir_probe(struct i2c_adapter *adap);
279
280 static struct i2c_driver driver = {
281         .driver = {
282                 .name   = "ir-kbd-i2c",
283         },
284         .id             = I2C_DRIVERID_INFRARED,
285         .attach_adapter = ir_probe,
286         .detach_client  = ir_detach,
287 };
288
289 static struct i2c_client client_template =
290 {
291         .name = "unset",
292         .driver = &driver
293 };
294
295 static int ir_attach(struct i2c_adapter *adap, int addr,
296                      unsigned short flags, int kind)
297 {
298         IR_KEYTAB_TYPE *ir_codes = NULL;
299         char *name;
300         int ir_type;
301         struct IR_i2c *ir;
302         struct input_dev *input_dev;
303
304         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
305         input_dev = input_allocate_device();
306         if (!ir || !input_dev) {
307                 input_free_device(input_dev);
308                 kfree(ir);
309                 return -ENOMEM;
310         }
311         memset(ir,0,sizeof(*ir));
312
313         ir->c = client_template;
314         ir->input = input_dev;
315
316         ir->c.adapter = adap;
317         ir->c.addr    = addr;
318
319         i2c_set_clientdata(&ir->c, ir);
320
321         switch(addr) {
322         case 0x64:
323                 name        = "Pixelview";
324                 ir->get_key = get_key_pixelview;
325                 ir_type     = IR_TYPE_OTHER;
326                 ir_codes    = ir_codes_empty;
327                 break;
328         case 0x4b:
329                 name        = "PV951";
330                 ir->get_key = get_key_pv951;
331                 ir_type     = IR_TYPE_OTHER;
332                 ir_codes    = ir_codes_pv951;
333                 break;
334         case 0x18:
335         case 0x1a:
336                 name        = "Hauppauge";
337                 ir->get_key = get_key_haup;
338                 ir_type     = IR_TYPE_RC5;
339                 ir_codes    = ir_codes_rc5_tv;
340                 break;
341         case 0x30:
342                 name        = "KNC One";
343                 ir->get_key = get_key_knc1;
344                 ir_type     = IR_TYPE_OTHER;
345                 ir_codes    = ir_codes_empty;
346                 break;
347         case 0x7a:
348         case 0x47:
349                 /* Handled by saa7134-input */
350                 name        = "SAA713x remote";
351                 ir_type     = IR_TYPE_OTHER;
352                 break;
353         default:
354                 /* shouldn't happen */
355                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
356                 kfree(ir);
357                 return -1;
358         }
359
360         /* Sets name */
361         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
362         ir->ir_codes=ir_codes;
363
364         /* register i2c device
365          * At device register, IR codes may be changed to be
366          * board dependent.
367          */
368         i2c_attach_client(&ir->c);
369
370         /* If IR not supported or disabled, unregisters driver */
371         if (ir->get_key == NULL) {
372                 i2c_detach_client(&ir->c);
373                 kfree(ir);
374                 return -1;
375         }
376
377         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
378         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
379                  ir->c.adapter->dev.bus_id,
380                  ir->c.dev.bus_id);
381
382         /* init + register input device */
383         ir_input_init(input_dev,&ir->ir,ir_type,ir->ir_codes);
384         input_dev->id.bustype = BUS_I2C;
385         input_dev->name       = ir->c.name;
386         input_dev->phys       = ir->phys;
387
388         /* register event device */
389         input_register_device(ir->input);
390         printk(DEVNAME ": %s detected at %s [%s]\n",
391                ir->input->name,ir->input->phys,adap->name);
392
393         /* start polling via eventd */
394         INIT_WORK(&ir->work, ir_work, ir);
395         init_timer(&ir->timer);
396         ir->timer.function = ir_timer;
397         ir->timer.data     = (unsigned long)ir;
398         schedule_work(&ir->work);
399
400         return 0;
401 }
402
403 static int ir_detach(struct i2c_client *client)
404 {
405         struct IR_i2c *ir = i2c_get_clientdata(client);
406
407         /* kill outstanding polls */
408         del_timer(&ir->timer);
409         flush_scheduled_work();
410
411         /* unregister devices */
412         input_unregister_device(ir->input);
413         i2c_detach_client(&ir->c);
414
415         /* free memory */
416         kfree(ir);
417         return 0;
418 }
419
420 static int ir_probe(struct i2c_adapter *adap)
421 {
422
423         /* The external IR receiver is at i2c address 0x34 (0x35 for
424            reads).  Future Hauppauge cards will have an internal
425            receiver at 0x30 (0x31 for reads).  In theory, both can be
426            fitted, and Hauppauge suggest an external overrides an
427            internal.
428
429            That's why we probe 0x1a (~0x34) first. CB
430         */
431
432         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
433         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
434         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
435         const int *probe = NULL;
436         struct i2c_client c;
437         unsigned char buf;
438         int i,rc;
439
440         switch (adap->id) {
441         case I2C_HW_B_BT848:
442                 probe = probe_bttv;
443                 break;
444         case I2C_HW_SAA7134:
445                 probe = probe_saa7134;
446                 break;
447         case I2C_HW_B_EM28XX:
448                 probe = probe_em28XX;
449                 break;
450         }
451         if (NULL == probe)
452                 return 0;
453
454         memset(&c,0,sizeof(c));
455         c.adapter = adap;
456         for (i = 0; -1 != probe[i]; i++) {
457                 c.addr = probe[i];
458                 rc = i2c_master_recv(&c,&buf,0);
459                 dprintk(1,"probe 0x%02x @ %s: %s\n",
460                         probe[i], adap->name,
461                         (0 == rc) ? "yes" : "no");
462                 if (0 == rc) {
463                         ir_attach(adap,probe[i],0,0);
464                         break;
465                 }
466         }
467         return 0;
468 }
469
470 /* ----------------------------------------------------------------------- */
471
472 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
473 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
474 MODULE_LICENSE("GPL");
475
476 static int __init ir_init(void)
477 {
478         return i2c_add_driver(&driver);
479 }
480
481 static void __exit ir_fini(void)
482 {
483         i2c_del_driver(&driver);
484 }
485
486 module_init(ir_init);
487 module_exit(ir_fini);
488
489 /*
490  * Overrides for Emacs so that we follow Linus's tabbing style.
491  * ---------------------------------------------------------------------------
492  * Local variables:
493  * c-basic-offset: 8
494  * End:
495  */