[PATCH] I2C: Kill i2c_algorithm.id (6/7)
[linux-2.6.git] / drivers / media / video / ir-kbd-i2c.c
1 /*
2  * $Id: ir-kbd-i2c.c,v 1.11 2005/07/07 16:42:11 mchehab 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         [ 0x49 ] = KEY_LANGUAGE,        /* MTS Select */
114         [ 0x19 ] = KEY_SEARCH,          /* Auto Scan */
115
116         [ 0x4b ] = KEY_RECORD,
117         [ 0x46 ] = KEY_PLAY,
118         [ 0x45 ] = KEY_PAUSE,           /* Pause */
119         [ 0x44 ] = KEY_STOP,
120         [ 0x40 ] = KEY_FORWARD,         /* Forward ? */
121         [ 0x42 ] = KEY_REWIND,          /* Backward ? */
122
123 };
124
125 struct IR;
126 struct IR {
127         struct i2c_client      c;
128         struct input_dev       input;
129         struct ir_input_state  ir;
130
131         struct work_struct     work;
132         struct timer_list      timer;
133         char                   phys[32];
134         int                    (*get_key)(struct IR*, u32*, u32*);
135 };
136
137 /* ----------------------------------------------------------------------- */
138 /* insmod parameters                                                       */
139
140 static int debug;
141 module_param(debug, int, 0644);    /* debug level (0,1,2) */
142
143 #define DEVNAME "ir-kbd-i2c"
144 #define dprintk(level, fmt, arg...)     if (debug >= level) \
145         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
146
147 /* ----------------------------------------------------------------------- */
148
149 static int get_key_haup(struct IR *ir, u32 *ir_key, u32 *ir_raw)
150 {
151         unsigned char buf[3];
152         int start, toggle, dev, code;
153
154         /* poll IR chip */
155         if (3 != i2c_master_recv(&ir->c,buf,3))
156                 return -EIO;
157
158         /* split rc5 data block ... */
159         start  = (buf[0] >> 6) &    3;
160         toggle = (buf[0] >> 5) &    1;
161         dev    =  buf[0]       & 0x1f;
162         code   = (buf[1] >> 2) & 0x3f;
163
164         if (3 != start)
165                 /* no key pressed */
166                 return 0;
167         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
168                 start, toggle, dev, code);
169
170         /* return key */
171         *ir_key = code;
172         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
173         return 1;
174 }
175
176 static int get_key_pixelview(struct IR *ir, u32 *ir_key, u32 *ir_raw)
177 {
178         unsigned char b;
179
180         /* poll IR chip */
181         if (1 != i2c_master_recv(&ir->c,&b,1)) {
182                 dprintk(1,"read error\n");
183                 return -EIO;
184         }
185         *ir_key = b;
186         *ir_raw = b;
187         return 1;
188 }
189
190 static int get_key_pv951(struct IR *ir, u32 *ir_key, u32 *ir_raw)
191 {
192         unsigned char b;
193
194         /* poll IR chip */
195         if (1 != i2c_master_recv(&ir->c,&b,1)) {
196                 dprintk(1,"read error\n");
197                 return -EIO;
198         }
199
200         /* ignore 0xaa */
201         if (b==0xaa)
202                 return 0;
203         dprintk(2,"key %02x\n", b);
204
205         *ir_key = b;
206         *ir_raw = b;
207         return 1;
208 }
209
210 static int get_key_knc1(struct IR *ir, u32 *ir_key, u32 *ir_raw)
211 {
212         unsigned char b;
213
214         /* poll IR chip */
215         if (1 != i2c_master_recv(&ir->c,&b,1)) {
216                 dprintk(1,"read error\n");
217                 return -EIO;
218         }
219
220         /* it seems that 0xFE indicates that a button is still hold
221            down, while 0xFF indicates that no button is hold
222            down. 0xFE sequences are sometimes interrupted by 0xFF */
223
224         dprintk(2,"key %02x\n", b);
225
226         if (b == 0xFF)
227                 return 0;
228
229         if (b == 0xFE)
230                 /* keep old data */
231                 return 1;
232
233         *ir_key = b;
234         *ir_raw = b;
235         return 1;
236 }
237
238 static int get_key_purpletv(struct IR *ir, u32 *ir_key, u32 *ir_raw)
239 {
240         unsigned char b;
241
242         /* poll IR chip */
243         if (1 != i2c_master_recv(&ir->c,&b,1)) {
244                 dprintk(1,"read error\n");
245                 return -EIO;
246         }
247
248         /* no button press */
249         if (b==0)
250                 return 0;
251
252         /* repeating */
253         if (b & 0x80)
254                 return 1;
255
256         *ir_key = b;
257         *ir_raw = b;
258         return 1;
259 }
260 /* ----------------------------------------------------------------------- */
261
262 static void ir_key_poll(struct IR *ir)
263 {
264         static u32 ir_key, ir_raw;
265         int rc;
266
267         dprintk(2,"ir_poll_key\n");
268         rc = ir->get_key(ir, &ir_key, &ir_raw);
269         if (rc < 0) {
270                 dprintk(2,"error\n");
271                 return;
272         }
273
274         if (0 == rc) {
275                 ir_input_nokey(&ir->input,&ir->ir);
276         } else {
277                 ir_input_keydown(&ir->input,&ir->ir, ir_key, ir_raw);
278         }
279 }
280
281 static void ir_timer(unsigned long data)
282 {
283         struct IR *ir = (struct IR*)data;
284         schedule_work(&ir->work);
285 }
286
287 static void ir_work(void *data)
288 {
289         struct IR *ir = data;
290         ir_key_poll(ir);
291         mod_timer(&ir->timer, jiffies+HZ/10);
292 }
293
294 /* ----------------------------------------------------------------------- */
295
296 static int ir_attach(struct i2c_adapter *adap, int addr,
297                       unsigned short flags, int kind);
298 static int ir_detach(struct i2c_client *client);
299 static int ir_probe(struct i2c_adapter *adap);
300
301 static struct i2c_driver driver = {
302         .name           = "ir remote kbd driver",
303         .id             = I2C_DRIVERID_EXP3, /* FIXME */
304         .flags          = I2C_DF_NOTIFY,
305         .attach_adapter = ir_probe,
306         .detach_client  = ir_detach,
307 };
308
309 static struct i2c_client client_template =
310 {
311         I2C_DEVNAME("unset"),
312         .driver = &driver
313 };
314
315 static int ir_attach(struct i2c_adapter *adap, int addr,
316                      unsigned short flags, int kind)
317 {
318         IR_KEYTAB_TYPE *ir_codes = NULL;
319         char *name;
320         int ir_type;
321         struct IR *ir;
322
323         if (NULL == (ir = kmalloc(sizeof(struct IR),GFP_KERNEL)))
324                 return -ENOMEM;
325         memset(ir,0,sizeof(*ir));
326         ir->c = client_template;
327
328         i2c_set_clientdata(&ir->c, ir);
329         ir->c.adapter = adap;
330         ir->c.addr    = addr;
331
332         switch(addr) {
333         case 0x64:
334                 name        = "Pixelview";
335                 ir->get_key = get_key_pixelview;
336                 ir_type     = IR_TYPE_OTHER;
337                 ir_codes    = ir_codes_empty;
338                 break;
339         case 0x4b:
340                 name        = "PV951";
341                 ir->get_key = get_key_pv951;
342                 ir_type     = IR_TYPE_OTHER;
343                 ir_codes    = ir_codes_pv951;
344                 break;
345         case 0x18:
346         case 0x1a:
347                 name        = "Hauppauge";
348                 ir->get_key = get_key_haup;
349                 ir_type     = IR_TYPE_RC5;
350                 ir_codes    = ir_codes_rc5_tv;
351                 break;
352         case 0x30:
353                 name        = "KNC One";
354                 ir->get_key = get_key_knc1;
355                 ir_type     = IR_TYPE_OTHER;
356                 ir_codes    = ir_codes_empty;
357                 break;
358         case 0x7a:
359                 name        = "Purple TV";
360                 ir->get_key = get_key_purpletv;
361                 ir_type     = IR_TYPE_OTHER;
362                 ir_codes    = ir_codes_purpletv;
363                 break;
364         default:
365                 /* shouldn't happen */
366                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
367                 kfree(ir);
368                 return -1;
369         }
370
371         /* register i2c device */
372         i2c_attach_client(&ir->c);
373         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
374         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
375                  ir->c.adapter->dev.bus_id,
376                  ir->c.dev.bus_id);
377
378         /* init + register input device */
379         ir_input_init(&ir->input,&ir->ir,ir_type,ir_codes);
380         ir->input.id.bustype = BUS_I2C;
381         ir->input.name       = ir->c.name;
382         ir->input.phys       = ir->phys;
383         input_register_device(&ir->input);
384         printk(DEVNAME ": %s detected at %s [%s]\n",
385                ir->input.name,ir->input.phys,adap->name);
386
387         /* start polling via eventd */
388         INIT_WORK(&ir->work, ir_work, ir);
389         init_timer(&ir->timer);
390         ir->timer.function = ir_timer;
391         ir->timer.data     = (unsigned long)ir;
392         schedule_work(&ir->work);
393
394         return 0;
395 }
396
397 static int ir_detach(struct i2c_client *client)
398 {
399         struct IR *ir = i2c_get_clientdata(client);
400
401         /* kill outstanding polls */
402         del_timer(&ir->timer);
403         flush_scheduled_work();
404
405         /* unregister devices */
406         input_unregister_device(&ir->input);
407         i2c_detach_client(&ir->c);
408
409         /* free memory */
410         kfree(ir);
411         return 0;
412 }
413
414 static int ir_probe(struct i2c_adapter *adap)
415 {
416
417         /* The external IR receiver is at i2c address 0x34 (0x35 for
418            reads).  Future Hauppauge cards will have an internal
419            receiver at 0x30 (0x31 for reads).  In theory, both can be
420            fitted, and Hauppauge suggest an external overrides an
421            internal.
422
423            That's why we probe 0x1a (~0x34) first. CB
424         */
425
426         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
427         static const int probe_saa7134[] = { 0x7a, -1 };
428         const int *probe = NULL;
429         struct i2c_client c; char buf; int i,rc;
430
431         switch (adap->id) {
432         case I2C_HW_B_BT848:
433                 probe = probe_bttv;
434                 break;
435         case I2C_HW_SAA7134:
436                 probe = probe_saa7134;
437                 break;
438         }
439         if (NULL == probe)
440                 return 0;
441
442         memset(&c,0,sizeof(c));
443         c.adapter = adap;
444         for (i = 0; -1 != probe[i]; i++) {
445                 c.addr = probe[i];
446                 rc = i2c_master_recv(&c,&buf,1);
447                 dprintk(1,"probe 0x%02x @ %s: %s\n",
448                         probe[i], adap->name,
449                         (1 == rc) ? "yes" : "no");
450                 if (1 == rc) {
451                         ir_attach(adap,probe[i],0,0);
452                         break;
453                 }
454         }
455         return 0;
456 }
457
458 /* ----------------------------------------------------------------------- */
459
460 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
461 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
462 MODULE_LICENSE("GPL");
463
464 static int __init ir_init(void)
465 {
466         return i2c_add_driver(&driver);
467 }
468
469 static void __exit ir_fini(void)
470 {
471         i2c_del_driver(&driver);
472 }
473
474 module_init(ir_init);
475 module_exit(ir_fini);
476
477 /*
478  * Overrides for Emacs so that we follow Linus's tabbing style.
479  * ---------------------------------------------------------------------------
480  * Local variables:
481  * c-basic-offset: 8
482  * End:
483  */