Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[linux-2.6] / drivers / media / video / saa7134 / saa7134-input.c
1 /*
2  *
3  * handle saa7134 IR remotes via linux kernel input layer.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  */
20
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/sched.h>
26 #include <linux/interrupt.h>
27 #include <linux/input.h>
28
29 #include "saa7134-reg.h"
30 #include "saa7134.h"
31
32 static unsigned int disable_ir = 0;
33 module_param(disable_ir, int, 0444);
34 MODULE_PARM_DESC(disable_ir,"disable infrared remote support");
35
36 static unsigned int ir_debug = 0;
37 module_param(ir_debug, int, 0644);
38 MODULE_PARM_DESC(ir_debug,"enable debug messages [IR]");
39
40 static int pinnacle_remote = 0;
41 module_param(pinnacle_remote, int, 0644);    /* Choose Pinnacle PCTV remote */
42 MODULE_PARM_DESC(pinnacle_remote, "Specify Pinnacle PCTV remote: 0=coloured, 1=grey (defaults to 0)");
43
44 #define dprintk(fmt, arg...)    if (ir_debug) \
45         printk(KERN_DEBUG "%s/ir: " fmt, dev->name , ## arg)
46 #define i2cdprintk(fmt, arg...)    if (ir_debug) \
47         printk(KERN_DEBUG "%s/ir: " fmt, ir->c.name , ## arg)
48
49 /* -------------------- GPIO generic keycode builder -------------------- */
50
51 static int build_key(struct saa7134_dev *dev)
52 {
53         struct saa7134_ir *ir = dev->remote;
54         u32 gpio, data;
55
56         /* rising SAA7134_GPIO_GPRESCAN reads the status */
57         saa_clearb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
58         saa_setb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
59
60         gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
61         if (ir->polling) {
62                 if (ir->last_gpio == gpio)
63                         return 0;
64                 ir->last_gpio = gpio;
65         }
66
67         data = ir_extract_bits(gpio, ir->mask_keycode);
68         dprintk("build_key gpio=0x%x mask=0x%x data=%d\n",
69                 gpio, ir->mask_keycode, data);
70
71         if (ir->polling) {
72                 if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
73                     (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
74                         ir_input_keydown(ir->dev, &ir->ir, data, data);
75                 } else {
76                         ir_input_nokey(ir->dev, &ir->ir);
77                 }
78         }
79         else {  /* IRQ driven mode - handle key press and release in one go */
80                 if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
81                     (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
82                         ir_input_keydown(ir->dev, &ir->ir, data, data);
83                         ir_input_nokey(ir->dev, &ir->ir);
84                 }
85         }
86
87         return 0;
88 }
89
90 /* --------------------- Chip specific I2C key builders ----------------- */
91
92 static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
93 {
94         unsigned char b;
95
96         /* poll IR chip */
97         if (1 != i2c_master_recv(&ir->c,&b,1)) {
98                 i2cdprintk("read error\n");
99                 return -EIO;
100         }
101
102         /* no button press */
103         if (b==0)
104                 return 0;
105
106         /* repeating */
107         if (b & 0x80)
108                 return 1;
109
110         *ir_key = b;
111         *ir_raw = b;
112         return 1;
113 }
114
115 void saa7134_input_irq(struct saa7134_dev *dev)
116 {
117         struct saa7134_ir *ir = dev->remote;
118
119         if (!ir->polling)
120                 build_key(dev);
121 }
122
123 static void saa7134_input_timer(unsigned long data)
124 {
125         struct saa7134_dev *dev = (struct saa7134_dev*)data;
126         struct saa7134_ir *ir = dev->remote;
127         unsigned long timeout;
128
129         build_key(dev);
130         timeout = jiffies + (ir->polling * HZ / 1000);
131         mod_timer(&ir->timer, timeout);
132 }
133
134 int saa7134_input_init1(struct saa7134_dev *dev)
135 {
136         struct saa7134_ir *ir;
137         struct input_dev *input_dev;
138         IR_KEYTAB_TYPE *ir_codes = NULL;
139         u32 mask_keycode = 0;
140         u32 mask_keydown = 0;
141         u32 mask_keyup   = 0;
142         int polling      = 0;
143         int ir_type      = IR_TYPE_OTHER;
144
145         if (dev->has_remote != SAA7134_REMOTE_GPIO)
146                 return -ENODEV;
147         if (disable_ir)
148                 return -ENODEV;
149
150         /* detect & configure */
151         switch (dev->board) {
152         case SAA7134_BOARD_FLYVIDEO2000:
153         case SAA7134_BOARD_FLYVIDEO3000:
154         case SAA7134_BOARD_FLYTVPLATINUM_FM:
155         case SAA7134_BOARD_FLYTVPLATINUM_MINI2:
156                 ir_codes     = ir_codes_flyvideo;
157                 mask_keycode = 0xEC00000;
158                 mask_keydown = 0x0040000;
159                 break;
160         case SAA7134_BOARD_CINERGY400:
161         case SAA7134_BOARD_CINERGY600:
162         case SAA7134_BOARD_CINERGY600_MK3:
163                 ir_codes     = ir_codes_cinergy;
164                 mask_keycode = 0x00003f;
165                 mask_keyup   = 0x040000;
166                 break;
167         case SAA7134_BOARD_ECS_TVP3XP:
168         case SAA7134_BOARD_ECS_TVP3XP_4CB5:
169                 ir_codes     = ir_codes_eztv;
170                 mask_keycode = 0x00017c;
171                 mask_keyup   = 0x000002;
172                 polling      = 50; // ms
173                 break;
174         case SAA7134_BOARD_KWORLD_XPERT:
175         case SAA7134_BOARD_AVACSSMARTTV:
176                 ir_codes     = ir_codes_pixelview;
177                 mask_keycode = 0x00001F;
178                 mask_keyup   = 0x000020;
179                 polling      = 50; // ms
180                 break;
181         case SAA7134_BOARD_MD2819:
182         case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
183         case SAA7134_BOARD_AVERMEDIA_305:
184         case SAA7134_BOARD_AVERMEDIA_307:
185         case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
186         case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
187         case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
188                 ir_codes     = ir_codes_avermedia;
189                 mask_keycode = 0x0007C8;
190                 mask_keydown = 0x000010;
191                 polling      = 50; // ms
192                 /* Set GPIO pin2 to high to enable the IR controller */
193                 saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
194                 saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
195                 break;
196         case SAA7134_BOARD_KWORLD_TERMINATOR:
197                 ir_codes     = ir_codes_pixelview;
198                 mask_keycode = 0x00001f;
199                 mask_keyup   = 0x000060;
200                 polling      = 50; // ms
201                 break;
202         case SAA7134_BOARD_MANLI_MTV001:
203         case SAA7134_BOARD_MANLI_MTV002:
204         case SAA7134_BOARD_BEHOLD_409FM:
205                 ir_codes     = ir_codes_manli;
206                 mask_keycode = 0x001f00;
207                 mask_keyup   = 0x004000;
208                 polling      = 50; // ms
209                 break;
210         case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS:
211                 ir_codes     = ir_codes_pctv_sedna;
212                 mask_keycode = 0x001f00;
213                 mask_keyup   = 0x004000;
214                 polling      = 50; // ms
215                 break;
216         case SAA7134_BOARD_GOTVIEW_7135:
217                 ir_codes     = ir_codes_gotview7135;
218                 mask_keycode = 0x0003EC;
219                 mask_keyup   = 0x008000;
220                 mask_keydown = 0x000010;
221                 polling      = 50; // ms
222                 break;
223         case SAA7134_BOARD_VIDEOMATE_TV_PVR:
224         case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS:
225         case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII:
226                 ir_codes     = ir_codes_videomate_tv_pvr;
227                 mask_keycode = 0x00003F;
228                 mask_keyup   = 0x400000;
229                 polling      = 50; // ms
230                 break;
231         case SAA7134_BOARD_VIDEOMATE_DVBT_300:
232         case SAA7134_BOARD_VIDEOMATE_DVBT_200:
233                 ir_codes     = ir_codes_videomate_tv_pvr;
234                 mask_keycode = 0x003F00;
235                 mask_keyup   = 0x040000;
236                 break;
237         case SAA7134_BOARD_FLYDVBT_LR301:
238         case SAA7134_BOARD_FLYDVBTDUO:
239                 ir_codes     = ir_codes_flydvb;
240                 mask_keycode = 0x0001F00;
241                 mask_keydown = 0x0040000;
242                 break;
243         }
244         if (NULL == ir_codes) {
245                 printk("%s: Oops: IR config error [card=%d]\n",
246                        dev->name, dev->board);
247                 return -ENODEV;
248         }
249
250         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
251         input_dev = input_allocate_device();
252         if (!ir || !input_dev) {
253                 kfree(ir);
254                 input_free_device(input_dev);
255                 return -ENOMEM;
256         }
257
258         ir->dev = input_dev;
259
260         /* init hardware-specific stuff */
261         ir->mask_keycode = mask_keycode;
262         ir->mask_keydown = mask_keydown;
263         ir->mask_keyup   = mask_keyup;
264         ir->polling      = polling;
265
266         /* init input device */
267         snprintf(ir->name, sizeof(ir->name), "saa7134 IR (%s)",
268                  saa7134_boards[dev->board].name);
269         snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
270                  pci_name(dev->pci));
271
272         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
273         input_dev->name = ir->name;
274         input_dev->phys = ir->phys;
275         input_dev->id.bustype = BUS_PCI;
276         input_dev->id.version = 1;
277         if (dev->pci->subsystem_vendor) {
278                 input_dev->id.vendor  = dev->pci->subsystem_vendor;
279                 input_dev->id.product = dev->pci->subsystem_device;
280         } else {
281                 input_dev->id.vendor  = dev->pci->vendor;
282                 input_dev->id.product = dev->pci->device;
283         }
284         input_dev->cdev.dev = &dev->pci->dev;
285
286         /* all done */
287         dev->remote = ir;
288         if (ir->polling) {
289                 init_timer(&ir->timer);
290                 ir->timer.function = saa7134_input_timer;
291                 ir->timer.data     = (unsigned long)dev;
292                 ir->timer.expires  = jiffies + HZ;
293                 add_timer(&ir->timer);
294         }
295
296         input_register_device(ir->dev);
297         return 0;
298 }
299
300 void saa7134_input_fini(struct saa7134_dev *dev)
301 {
302         if (NULL == dev->remote)
303                 return;
304
305         if (dev->remote->polling)
306                 del_timer_sync(&dev->remote->timer);
307         input_unregister_device(dev->remote->dev);
308         kfree(dev->remote);
309         dev->remote = NULL;
310 }
311
312 void saa7134_set_i2c_ir(struct saa7134_dev *dev, struct IR_i2c *ir)
313 {
314         if (disable_ir) {
315                 dprintk("Found supported i2c remote, but IR has been disabled\n");
316                 ir->get_key=NULL;
317                 return;
318         }
319
320         switch (dev->board) {
321         case SAA7134_BOARD_PINNACLE_PCTV_110i:
322                 snprintf(ir->c.name, sizeof(ir->c.name), "Pinnacle PCTV");
323                 if (pinnacle_remote == 0) {
324                         ir->get_key   = get_key_pinnacle_color;
325                         ir->ir_codes = ir_codes_pinnacle_color;
326                 } else {
327                         ir->get_key   = get_key_pinnacle_grey;
328                         ir->ir_codes = ir_codes_pinnacle_grey;
329                 }
330                 break;
331         case SAA7134_BOARD_UPMOST_PURPLE_TV:
332                 snprintf(ir->c.name, sizeof(ir->c.name), "Purple TV");
333                 ir->get_key   = get_key_purpletv;
334                 ir->ir_codes  = ir_codes_purpletv;
335                 break;
336         default:
337                 dprintk("Shouldn't get here: Unknown board %x for I2C IR?\n",dev->board);
338                 break;
339         }
340
341 }
342 /* ----------------------------------------------------------------------
343  * Local variables:
344  * c-basic-offset: 8
345  * End:
346  */