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