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