V4L/DVB (4629): Saa7134: add card support for Proteus Pro 2309
[linux-2.6.git] / 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_PROTEUS_2309:
232                 ir_codes     = ir_codes_proteus_2309;
233                 mask_keycode = 0x00007F;
234                 mask_keyup   = 0x000080;
235                 polling      = 50; // ms
236                 break;
237         case SAA7134_BOARD_VIDEOMATE_DVBT_300:
238         case SAA7134_BOARD_VIDEOMATE_DVBT_200:
239                 ir_codes     = ir_codes_videomate_tv_pvr;
240                 mask_keycode = 0x003F00;
241                 mask_keyup   = 0x040000;
242                 break;
243         case SAA7134_BOARD_FLYDVBT_LR301:
244         case SAA7134_BOARD_FLYDVBTDUO:
245                 ir_codes     = ir_codes_flydvb;
246                 mask_keycode = 0x0001F00;
247                 mask_keydown = 0x0040000;
248                 break;
249         }
250         if (NULL == ir_codes) {
251                 printk("%s: Oops: IR config error [card=%d]\n",
252                        dev->name, dev->board);
253                 return -ENODEV;
254         }
255
256         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
257         input_dev = input_allocate_device();
258         if (!ir || !input_dev) {
259                 kfree(ir);
260                 input_free_device(input_dev);
261                 return -ENOMEM;
262         }
263
264         ir->dev = input_dev;
265
266         /* init hardware-specific stuff */
267         ir->mask_keycode = mask_keycode;
268         ir->mask_keydown = mask_keydown;
269         ir->mask_keyup   = mask_keyup;
270         ir->polling      = polling;
271
272         /* init input device */
273         snprintf(ir->name, sizeof(ir->name), "saa7134 IR (%s)",
274                  saa7134_boards[dev->board].name);
275         snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
276                  pci_name(dev->pci));
277
278         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
279         input_dev->name = ir->name;
280         input_dev->phys = ir->phys;
281         input_dev->id.bustype = BUS_PCI;
282         input_dev->id.version = 1;
283         if (dev->pci->subsystem_vendor) {
284                 input_dev->id.vendor  = dev->pci->subsystem_vendor;
285                 input_dev->id.product = dev->pci->subsystem_device;
286         } else {
287                 input_dev->id.vendor  = dev->pci->vendor;
288                 input_dev->id.product = dev->pci->device;
289         }
290         input_dev->cdev.dev = &dev->pci->dev;
291
292         /* all done */
293         dev->remote = ir;
294         if (ir->polling) {
295                 init_timer(&ir->timer);
296                 ir->timer.function = saa7134_input_timer;
297                 ir->timer.data     = (unsigned long)dev;
298                 ir->timer.expires  = jiffies + HZ;
299                 add_timer(&ir->timer);
300         }
301
302         input_register_device(ir->dev);
303         return 0;
304 }
305
306 void saa7134_input_fini(struct saa7134_dev *dev)
307 {
308         if (NULL == dev->remote)
309                 return;
310
311         if (dev->remote->polling)
312                 del_timer_sync(&dev->remote->timer);
313         input_unregister_device(dev->remote->dev);
314         kfree(dev->remote);
315         dev->remote = NULL;
316 }
317
318 void saa7134_set_i2c_ir(struct saa7134_dev *dev, struct IR_i2c *ir)
319 {
320         if (disable_ir) {
321                 dprintk("Found supported i2c remote, but IR has been disabled\n");
322                 ir->get_key=NULL;
323                 return;
324         }
325
326         switch (dev->board) {
327         case SAA7134_BOARD_PINNACLE_PCTV_110i:
328                 snprintf(ir->c.name, sizeof(ir->c.name), "Pinnacle PCTV");
329                 if (pinnacle_remote == 0) {
330                         ir->get_key   = get_key_pinnacle_color;
331                         ir->ir_codes = ir_codes_pinnacle_color;
332                 } else {
333                         ir->get_key   = get_key_pinnacle_grey;
334                         ir->ir_codes = ir_codes_pinnacle_grey;
335                 }
336                 break;
337         case SAA7134_BOARD_UPMOST_PURPLE_TV:
338                 snprintf(ir->c.name, sizeof(ir->c.name), "Purple TV");
339                 ir->get_key   = get_key_purpletv;
340                 ir->ir_codes  = ir_codes_purpletv;
341                 break;
342         default:
343                 dprintk("Shouldn't get here: Unknown board %x for I2C IR?\n",dev->board);
344                 break;
345         }
346
347 }
348 /* ----------------------------------------------------------------------
349  * Local variables:
350  * c-basic-offset: 8
351  * End:
352  */