Merge branch 'master'
[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 /* ----------------------------------------------------------------------- */
48 /* insmod parameters                                                       */
49
50 static int debug;
51 module_param(debug, int, 0644);    /* debug level (0,1,2) */
52
53 static int hauppauge = 0;
54 module_param(hauppauge, int, 0644);    /* Choose Hauppauge remote */
55 MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
56
57
58 #define DEVNAME "ir-kbd-i2c"
59 #define dprintk(level, fmt, arg...)     if (debug >= level) \
60         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
61
62 /* ----------------------------------------------------------------------- */
63
64 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
65 {
66         unsigned char buf[3];
67         int start, toggle, dev, code;
68
69         /* poll IR chip */
70         if (3 != i2c_master_recv(&ir->c,buf,3))
71                 return -EIO;
72
73         /* split rc5 data block ... */
74         start  = (buf[0] >> 6) &    3;
75         toggle = (buf[0] >> 5) &    1;
76         dev    =  buf[0]       & 0x1f;
77         code   = (buf[1] >> 2) & 0x3f;
78
79         if (3 != start)
80                 /* no key pressed */
81                 return 0;
82         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
83                 start, toggle, dev, code);
84
85         /* return key */
86         *ir_key = code;
87         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
88         return 1;
89 }
90
91 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
92 {
93         unsigned char b;
94
95         /* poll IR chip */
96         if (1 != i2c_master_recv(&ir->c,&b,1)) {
97                 dprintk(1,"read error\n");
98                 return -EIO;
99         }
100         *ir_key = b;
101         *ir_raw = b;
102         return 1;
103 }
104
105 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
106 {
107         unsigned char b;
108
109         /* poll IR chip */
110         if (1 != i2c_master_recv(&ir->c,&b,1)) {
111                 dprintk(1,"read error\n");
112                 return -EIO;
113         }
114
115         /* ignore 0xaa */
116         if (b==0xaa)
117                 return 0;
118         dprintk(2,"key %02x\n", b);
119
120         *ir_key = b;
121         *ir_raw = b;
122         return 1;
123 }
124
125 static int get_key_knc1(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
135         /* it seems that 0xFE indicates that a button is still hold
136            down, while 0xff indicates that no button is hold
137            down. 0xfe sequences are sometimes interrupted by 0xFF */
138
139         dprintk(2,"key %02x\n", b);
140
141         if (b == 0xff)
142                 return 0;
143
144         if (b == 0xfe)
145                 /* keep old data */
146                 return 1;
147
148         *ir_key = b;
149         *ir_raw = b;
150         return 1;
151 }
152
153 /* The new pinnacle PCTV remote (with the colored buttons)
154  *
155  * Ricardo Cerqueira <v4l@cerqueira.org>
156  */
157
158 int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
159 {
160         unsigned char b[4];
161         unsigned int start = 0,parity = 0,code = 0;
162
163         /* poll IR chip */
164         if (4 != i2c_master_recv(&ir->c,b,4)) {
165                 dprintk(2,"read error\n");
166                 return -EIO;
167         }
168
169         for (start = 0; start<4; start++) {
170                 if (b[start] == 0x80) {
171                         code=b[(start+3)%4];
172                         parity=b[(start+2)%4];
173                 }
174         }
175
176         /* Empty Request */
177         if (parity==0)
178                 return 0;
179
180         /* Repeating... */
181         if (ir->old == parity)
182                 return 0;
183
184
185         ir->old = parity;
186
187         /* Reduce code value to fit inside IR_KEYTAB_SIZE
188          *
189          * this is the only value that results in 42 unique
190          * codes < 128
191          */
192
193         code %= 0x88;
194
195         *ir_raw = code;
196         *ir_key = code;
197
198         dprintk(1,"Pinnacle PCTV key %02x\n", code);
199
200         return 1;
201 }
202
203 EXPORT_SYMBOL_GPL(get_key_pinnacle);
204
205 /* ----------------------------------------------------------------------- */
206
207 static void ir_key_poll(struct IR_i2c *ir)
208 {
209         static u32 ir_key, ir_raw;
210         int rc;
211
212         dprintk(2,"ir_poll_key\n");
213         rc = ir->get_key(ir, &ir_key, &ir_raw);
214         if (rc < 0) {
215                 dprintk(2,"error\n");
216                 return;
217         }
218
219         if (0 == rc) {
220                 ir_input_nokey(ir->input, &ir->ir);
221         } else {
222                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
223         }
224 }
225
226 static void ir_timer(unsigned long data)
227 {
228         struct IR_i2c *ir = (struct IR_i2c*)data;
229         schedule_work(&ir->work);
230 }
231
232 static void ir_work(void *data)
233 {
234         struct IR_i2c *ir = data;
235         ir_key_poll(ir);
236         mod_timer(&ir->timer, jiffies+HZ/10);
237 }
238
239 /* ----------------------------------------------------------------------- */
240
241 static int ir_attach(struct i2c_adapter *adap, int addr,
242                       unsigned short flags, int kind);
243 static int ir_detach(struct i2c_client *client);
244 static int ir_probe(struct i2c_adapter *adap);
245
246 static struct i2c_driver driver = {
247         .driver = {
248                 .name   = "ir-kbd-i2c",
249         },
250         .id             = I2C_DRIVERID_INFRARED,
251         .attach_adapter = ir_probe,
252         .detach_client  = ir_detach,
253 };
254
255 static struct i2c_client client_template =
256 {
257         .name = "unset",
258         .driver = &driver
259 };
260
261 static int ir_attach(struct i2c_adapter *adap, int addr,
262                      unsigned short flags, int kind)
263 {
264         IR_KEYTAB_TYPE *ir_codes = NULL;
265         char *name;
266         int ir_type;
267         struct IR_i2c *ir;
268         struct input_dev *input_dev;
269
270         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
271         input_dev = input_allocate_device();
272         if (!ir || !input_dev) {
273                 input_free_device(input_dev);
274                 kfree(ir);
275                 return -ENOMEM;
276         }
277         memset(ir,0,sizeof(*ir));
278
279         ir->c = client_template;
280         ir->input = input_dev;
281
282         ir->c.adapter = adap;
283         ir->c.addr    = addr;
284
285         i2c_set_clientdata(&ir->c, ir);
286
287         switch(addr) {
288         case 0x64:
289                 name        = "Pixelview";
290                 ir->get_key = get_key_pixelview;
291                 ir_type     = IR_TYPE_OTHER;
292                 ir_codes    = ir_codes_empty;
293                 break;
294         case 0x4b:
295                 name        = "PV951";
296                 ir->get_key = get_key_pv951;
297                 ir_type     = IR_TYPE_OTHER;
298                 ir_codes    = ir_codes_pv951;
299                 break;
300         case 0x18:
301         case 0x1a:
302                 name        = "Hauppauge";
303                 ir->get_key = get_key_haup;
304                 ir_type     = IR_TYPE_RC5;
305                 if (hauppauge == 1) {
306                         ir_codes    = ir_codes_hauppauge_new;
307                 } else {
308                         ir_codes    = ir_codes_rc5_tv;
309                 }
310                 break;
311         case 0x30:
312                 name        = "KNC One";
313                 ir->get_key = get_key_knc1;
314                 ir_type     = IR_TYPE_OTHER;
315                 ir_codes    = ir_codes_empty;
316                 break;
317         case 0x7a:
318         case 0x47:
319                 /* Handled by saa7134-input */
320                 name        = "SAA713x remote";
321                 ir_type     = IR_TYPE_OTHER;
322                 break;
323         default:
324                 /* shouldn't happen */
325                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
326                 kfree(ir);
327                 return -1;
328         }
329
330         /* Sets name */
331         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
332         ir->ir_codes=ir_codes;
333
334         /* register i2c device
335          * At device register, IR codes may be changed to be
336          * board dependent.
337          */
338         i2c_attach_client(&ir->c);
339
340         /* If IR not supported or disabled, unregisters driver */
341         if (ir->get_key == NULL) {
342                 i2c_detach_client(&ir->c);
343                 kfree(ir);
344                 return -1;
345         }
346
347         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
348         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
349                  ir->c.adapter->dev.bus_id,
350                  ir->c.dev.bus_id);
351
352         /* init + register input device */
353         ir_input_init(input_dev,&ir->ir,ir_type,ir->ir_codes);
354         input_dev->id.bustype = BUS_I2C;
355         input_dev->name       = ir->c.name;
356         input_dev->phys       = ir->phys;
357
358         /* register event device */
359         input_register_device(ir->input);
360         printk(DEVNAME ": %s detected at %s [%s]\n",
361                ir->input->name,ir->input->phys,adap->name);
362
363         /* start polling via eventd */
364         INIT_WORK(&ir->work, ir_work, ir);
365         init_timer(&ir->timer);
366         ir->timer.function = ir_timer;
367         ir->timer.data     = (unsigned long)ir;
368         schedule_work(&ir->work);
369
370         return 0;
371 }
372
373 static int ir_detach(struct i2c_client *client)
374 {
375         struct IR_i2c *ir = i2c_get_clientdata(client);
376
377         /* kill outstanding polls */
378         del_timer(&ir->timer);
379         flush_scheduled_work();
380
381         /* unregister devices */
382         input_unregister_device(ir->input);
383         i2c_detach_client(&ir->c);
384
385         /* free memory */
386         kfree(ir);
387         return 0;
388 }
389
390 static int ir_probe(struct i2c_adapter *adap)
391 {
392
393         /* The external IR receiver is at i2c address 0x34 (0x35 for
394            reads).  Future Hauppauge cards will have an internal
395            receiver at 0x30 (0x31 for reads).  In theory, both can be
396            fitted, and Hauppauge suggest an external overrides an
397            internal.
398
399            That's why we probe 0x1a (~0x34) first. CB
400         */
401
402         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
403         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
404         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
405         const int *probe = NULL;
406         struct i2c_client c;
407         unsigned char buf;
408         int i,rc;
409
410         switch (adap->id) {
411         case I2C_HW_B_BT848:
412                 probe = probe_bttv;
413                 break;
414         case I2C_HW_B_CX2341X:
415                 probe = probe_bttv;
416                 break;
417         case I2C_HW_SAA7134:
418                 probe = probe_saa7134;
419                 break;
420         case I2C_HW_B_EM28XX:
421                 probe = probe_em28XX;
422                 break;
423         }
424         if (NULL == probe)
425                 return 0;
426
427         memset(&c,0,sizeof(c));
428         c.adapter = adap;
429         for (i = 0; -1 != probe[i]; i++) {
430                 c.addr = probe[i];
431                 rc = i2c_master_recv(&c,&buf,0);
432                 dprintk(1,"probe 0x%02x @ %s: %s\n",
433                         probe[i], adap->name,
434                         (0 == rc) ? "yes" : "no");
435                 if (0 == rc) {
436                         ir_attach(adap,probe[i],0,0);
437                         break;
438                 }
439         }
440         return 0;
441 }
442
443 /* ----------------------------------------------------------------------- */
444
445 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
446 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
447 MODULE_LICENSE("GPL");
448
449 static int __init ir_init(void)
450 {
451         return i2c_add_driver(&driver);
452 }
453
454 static void __exit ir_fini(void)
455 {
456         i2c_del_driver(&driver);
457 }
458
459 module_init(ir_init);
460 module_exit(ir_fini);
461
462 /*
463  * Overrides for Emacs so that we follow Linus's tabbing style.
464  * ---------------------------------------------------------------------------
465  * Local variables:
466  * c-basic-offset: 8
467  * End:
468  */