diff options
Diffstat (limited to 'drivers/media/video/bt8xx/bttv-input.c')
-rw-r--r-- | drivers/media/video/bt8xx/bttv-input.c | 588 |
1 files changed, 588 insertions, 0 deletions
diff --git a/drivers/media/video/bt8xx/bttv-input.c b/drivers/media/video/bt8xx/bttv-input.c new file mode 100644 index 00000000000..677d70c0e1c --- /dev/null +++ b/drivers/media/video/bt8xx/bttv-input.c | |||
@@ -0,0 +1,588 @@ | |||
1 | /* | ||
2 | * | ||
3 | * Copyright (c) 2003 Gerd Knorr | ||
4 | * Copyright (c) 2003 Pavel Machek | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License as published by | ||
8 | * the Free Software Foundation; either version 2 of the License, or | ||
9 | * (at your option) any later version. | ||
10 | * | ||
11 | * This program is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | * GNU General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU General Public License | ||
17 | * along with this program; if not, write to the Free Software | ||
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
19 | */ | ||
20 | |||
21 | #include <linux/module.h> | ||
22 | #include <linux/init.h> | ||
23 | #include <linux/delay.h> | ||
24 | #include <linux/interrupt.h> | ||
25 | #include <linux/input.h> | ||
26 | #include <linux/slab.h> | ||
27 | |||
28 | #include "bttv.h" | ||
29 | #include "bttvp.h" | ||
30 | |||
31 | |||
32 | static int ir_debug; | ||
33 | module_param(ir_debug, int, 0644); | ||
34 | |||
35 | static int ir_rc5_remote_gap = 885; | ||
36 | module_param(ir_rc5_remote_gap, int, 0644); | ||
37 | |||
38 | #undef dprintk | ||
39 | #define dprintk(arg...) do { \ | ||
40 | if (ir_debug >= 1) \ | ||
41 | printk(arg); \ | ||
42 | } while (0) | ||
43 | |||
44 | #define DEVNAME "bttv-input" | ||
45 | |||
46 | #define MODULE_NAME "bttv" | ||
47 | |||
48 | /* ---------------------------------------------------------------------- */ | ||
49 | |||
50 | static void ir_handle_key(struct bttv *btv) | ||
51 | { | ||
52 | struct bttv_ir *ir = btv->remote; | ||
53 | u32 gpio,data; | ||
54 | |||
55 | /* read gpio value */ | ||
56 | gpio = bttv_gpio_read(&btv->c); | ||
57 | if (ir->polling) { | ||
58 | if (ir->last_gpio == gpio) | ||
59 | return; | ||
60 | ir->last_gpio = gpio; | ||
61 | } | ||
62 | |||
63 | /* extract data */ | ||
64 | data = ir_extract_bits(gpio, ir->mask_keycode); | ||
65 | dprintk(KERN_INFO DEVNAME ": irq gpio=0x%x code=%d | %s%s%s\n", | ||
66 | gpio, data, | ||
67 | ir->polling ? "poll" : "irq", | ||
68 | (gpio & ir->mask_keydown) ? " down" : "", | ||
69 | (gpio & ir->mask_keyup) ? " up" : ""); | ||
70 | |||
71 | if ((ir->mask_keydown && (gpio & ir->mask_keydown)) || | ||
72 | (ir->mask_keyup && !(gpio & ir->mask_keyup))) { | ||
73 | rc_keydown_notimeout(ir->dev, data, 0); | ||
74 | } else { | ||
75 | /* HACK: Probably, ir->mask_keydown is missing | ||
76 | for this board */ | ||
77 | if (btv->c.type == BTTV_BOARD_WINFAST2000) | ||
78 | rc_keydown_notimeout(ir->dev, data, 0); | ||
79 | |||
80 | rc_keyup(ir->dev); | ||
81 | } | ||
82 | } | ||
83 | |||
84 | static void ir_enltv_handle_key(struct bttv *btv) | ||
85 | { | ||
86 | struct bttv_ir *ir = btv->remote; | ||
87 | u32 gpio, data, keyup; | ||
88 | |||
89 | /* read gpio value */ | ||
90 | gpio = bttv_gpio_read(&btv->c); | ||
91 | |||
92 | /* extract data */ | ||
93 | data = ir_extract_bits(gpio, ir->mask_keycode); | ||
94 | |||
95 | /* Check if it is keyup */ | ||
96 | keyup = (gpio & ir->mask_keyup) ? 1 << 31 : 0; | ||
97 | |||
98 | if ((ir->last_gpio & 0x7f) != data) { | ||
99 | dprintk(KERN_INFO DEVNAME ": gpio=0x%x code=%d | %s\n", | ||
100 | gpio, data, | ||
101 | (gpio & ir->mask_keyup) ? " up" : "up/down"); | ||
102 | |||
103 | rc_keydown_notimeout(ir->dev, data, 0); | ||
104 | if (keyup) | ||
105 | rc_keyup(ir->dev); | ||
106 | } else { | ||
107 | if ((ir->last_gpio & 1 << 31) == keyup) | ||
108 | return; | ||
109 | |||
110 | dprintk(KERN_INFO DEVNAME ":(cnt) gpio=0x%x code=%d | %s\n", | ||
111 | gpio, data, | ||
112 | (gpio & ir->mask_keyup) ? " up" : "down"); | ||
113 | |||
114 | if (keyup) | ||
115 | rc_keyup(ir->dev); | ||
116 | else | ||
117 | rc_keydown_notimeout(ir->dev, data, 0); | ||
118 | } | ||
119 | |||
120 | ir->last_gpio = data | keyup; | ||
121 | } | ||
122 | |||
123 | static int bttv_rc5_irq(struct bttv *btv); | ||
124 | |||
125 | void bttv_input_irq(struct bttv *btv) | ||
126 | { | ||
127 | struct bttv_ir *ir = btv->remote; | ||
128 | |||
129 | if (ir->rc5_gpio) | ||
130 | bttv_rc5_irq(btv); | ||
131 | else if (!ir->polling) | ||
132 | ir_handle_key(btv); | ||
133 | } | ||
134 | |||
135 | static void bttv_input_timer(unsigned long data) | ||
136 | { | ||
137 | struct bttv *btv = (struct bttv*)data; | ||
138 | struct bttv_ir *ir = btv->remote; | ||
139 | |||
140 | if (btv->c.type == BTTV_BOARD_ENLTV_FM_2) | ||
141 | ir_enltv_handle_key(btv); | ||
142 | else | ||
143 | ir_handle_key(btv); | ||
144 | mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling)); | ||
145 | } | ||
146 | |||
147 | /* | ||
148 | * FIXME: Nebula digi uses the legacy way to decode RC5, instead of relying | ||
149 | * on the rc-core way. As we need to be sure that both IRQ transitions are | ||
150 | * properly triggered, Better to touch it only with this hardware for | ||
151 | * testing. | ||
152 | */ | ||
153 | |||
154 | #define RC5_START(x) (((x) >> 12) & 3) | ||
155 | #define RC5_TOGGLE(x) (((x) >> 11) & 1) | ||
156 | #define RC5_ADDR(x) (((x) >> 6) & 31) | ||
157 | #define RC5_INSTR(x) ((x) & 63) | ||
158 | |||
159 | /* decode raw bit pattern to RC5 code */ | ||
160 | static u32 bttv_rc5_decode(unsigned int code) | ||
161 | { | ||
162 | unsigned int org_code = code; | ||
163 | unsigned int pair; | ||
164 | unsigned int rc5 = 0; | ||
165 | int i; | ||
166 | |||
167 | for (i = 0; i < 14; ++i) { | ||
168 | pair = code & 0x3; | ||
169 | code >>= 2; | ||
170 | |||
171 | rc5 <<= 1; | ||
172 | switch (pair) { | ||
173 | case 0: | ||
174 | case 2: | ||
175 | break; | ||
176 | case 1: | ||
177 | rc5 |= 1; | ||
178 | break; | ||
179 | case 3: | ||
180 | dprintk(KERN_INFO DEVNAME ":rc5_decode(%x) bad code\n", | ||
181 | org_code); | ||
182 | return 0; | ||
183 | } | ||
184 | } | ||
185 | dprintk(KERN_INFO DEVNAME ":" | ||
186 | "code=%x, rc5=%x, start=%x, toggle=%x, address=%x, " | ||
187 | "instr=%x\n", rc5, org_code, RC5_START(rc5), | ||
188 | RC5_TOGGLE(rc5), RC5_ADDR(rc5), RC5_INSTR(rc5)); | ||
189 | return rc5; | ||
190 | } | ||
191 | |||
192 | static void bttv_rc5_timer_end(unsigned long data) | ||
193 | { | ||
194 | struct bttv_ir *ir = (struct bttv_ir *)data; | ||
195 | struct timeval tv; | ||
196 | u32 gap; | ||
197 | u32 rc5 = 0; | ||
198 | |||
199 | /* get time */ | ||
200 | do_gettimeofday(&tv); | ||
201 | |||
202 | /* avoid overflow with gap >1s */ | ||
203 | if (tv.tv_sec - ir->base_time.tv_sec > 1) { | ||
204 | gap = 200000; | ||
205 | } else { | ||
206 | gap = 1000000 * (tv.tv_sec - ir->base_time.tv_sec) + | ||
207 | tv.tv_usec - ir->base_time.tv_usec; | ||
208 | } | ||
209 | |||
210 | /* signal we're ready to start a new code */ | ||
211 | ir->active = false; | ||
212 | |||
213 | /* Allow some timer jitter (RC5 is ~24ms anyway so this is ok) */ | ||
214 | if (gap < 28000) { | ||
215 | dprintk(KERN_INFO DEVNAME ": spurious timer_end\n"); | ||
216 | return; | ||
217 | } | ||
218 | |||
219 | if (ir->last_bit < 20) { | ||
220 | /* ignore spurious codes (caused by light/other remotes) */ | ||
221 | dprintk(KERN_INFO DEVNAME ": short code: %x\n", ir->code); | ||
222 | } else { | ||
223 | ir->code = (ir->code << ir->shift_by) | 1; | ||
224 | rc5 = bttv_rc5_decode(ir->code); | ||
225 | |||
226 | /* two start bits? */ | ||
227 | if (RC5_START(rc5) != ir->start) { | ||
228 | printk(KERN_INFO DEVNAME ":" | ||
229 | " rc5 start bits invalid: %u\n", RC5_START(rc5)); | ||
230 | |||
231 | /* right address? */ | ||
232 | } else if (RC5_ADDR(rc5) == ir->addr) { | ||
233 | u32 toggle = RC5_TOGGLE(rc5); | ||
234 | u32 instr = RC5_INSTR(rc5); | ||
235 | |||
236 | /* Good code */ | ||
237 | rc_keydown(ir->dev, instr, toggle); | ||
238 | dprintk(KERN_INFO DEVNAME ":" | ||
239 | " instruction %x, toggle %x\n", | ||
240 | instr, toggle); | ||
241 | } | ||
242 | } | ||
243 | } | ||
244 | |||
245 | static int bttv_rc5_irq(struct bttv *btv) | ||
246 | { | ||
247 | struct bttv_ir *ir = btv->remote; | ||
248 | struct timeval tv; | ||
249 | u32 gpio; | ||
250 | u32 gap; | ||
251 | unsigned long current_jiffies; | ||
252 | |||
253 | /* read gpio port */ | ||
254 | gpio = bttv_gpio_read(&btv->c); | ||
255 | |||
256 | /* get time of bit */ | ||
257 | current_jiffies = jiffies; | ||
258 | do_gettimeofday(&tv); | ||
259 | |||
260 | /* avoid overflow with gap >1s */ | ||
261 | if (tv.tv_sec - ir->base_time.tv_sec > 1) { | ||
262 | gap = 200000; | ||
263 | } else { | ||
264 | gap = 1000000 * (tv.tv_sec - ir->base_time.tv_sec) + | ||
265 | tv.tv_usec - ir->base_time.tv_usec; | ||
266 | } | ||
267 | |||
268 | dprintk(KERN_INFO DEVNAME ": RC5 IRQ: gap %d us for %s\n", | ||
269 | gap, (gpio & 0x20) ? "mark" : "space"); | ||
270 | |||
271 | /* remote IRQ? */ | ||
272 | if (!(gpio & 0x20)) | ||
273 | return 0; | ||
274 | |||
275 | /* active code => add bit */ | ||
276 | if (ir->active) { | ||
277 | /* only if in the code (otherwise spurious IRQ or timer | ||
278 | late) */ | ||
279 | if (ir->last_bit < 28) { | ||
280 | ir->last_bit = (gap - ir_rc5_remote_gap / 2) / | ||
281 | ir_rc5_remote_gap; | ||
282 | ir->code |= 1 << ir->last_bit; | ||
283 | } | ||
284 | /* starting new code */ | ||
285 | } else { | ||
286 | ir->active = true; | ||
287 | ir->code = 0; | ||
288 | ir->base_time = tv; | ||
289 | ir->last_bit = 0; | ||
290 | |||
291 | mod_timer(&ir->timer, current_jiffies + msecs_to_jiffies(30)); | ||
292 | } | ||
293 | |||
294 | /* toggle GPIO pin 4 to reset the irq */ | ||
295 | bttv_gpio_write(&btv->c, gpio & ~(1 << 4)); | ||
296 | bttv_gpio_write(&btv->c, gpio | (1 << 4)); | ||
297 | return 1; | ||
298 | } | ||
299 | |||
300 | /* ---------------------------------------------------------------------- */ | ||
301 | |||
302 | static void bttv_ir_start(struct bttv *btv, struct bttv_ir *ir) | ||
303 | { | ||
304 | if (ir->polling) { | ||
305 | setup_timer(&ir->timer, bttv_input_timer, (unsigned long)btv); | ||
306 | ir->timer.expires = jiffies + msecs_to_jiffies(1000); | ||
307 | add_timer(&ir->timer); | ||
308 | } else if (ir->rc5_gpio) { | ||
309 | /* set timer_end for code completion */ | ||
310 | setup_timer(&ir->timer, bttv_rc5_timer_end, (unsigned long)ir); | ||
311 | ir->shift_by = 1; | ||
312 | ir->start = 3; | ||
313 | ir->addr = 0x0; | ||
314 | ir->rc5_remote_gap = ir_rc5_remote_gap; | ||
315 | } | ||
316 | } | ||
317 | |||
318 | static void bttv_ir_stop(struct bttv *btv) | ||
319 | { | ||
320 | if (btv->remote->polling) | ||
321 | del_timer_sync(&btv->remote->timer); | ||
322 | |||
323 | if (btv->remote->rc5_gpio) { | ||
324 | u32 gpio; | ||
325 | |||
326 | del_timer_sync(&btv->remote->timer); | ||
327 | |||
328 | gpio = bttv_gpio_read(&btv->c); | ||
329 | bttv_gpio_write(&btv->c, gpio & ~(1 << 4)); | ||
330 | } | ||
331 | } | ||
332 | |||
333 | /* | ||
334 | * Get_key functions used by I2C remotes | ||
335 | */ | ||
336 | |||
337 | static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) | ||
338 | { | ||
339 | unsigned char b; | ||
340 | |||
341 | /* poll IR chip */ | ||
342 | if (1 != i2c_master_recv(ir->c, &b, 1)) { | ||
343 | dprintk(KERN_INFO DEVNAME ": read error\n"); | ||
344 | return -EIO; | ||
345 | } | ||
346 | |||
347 | /* ignore 0xaa */ | ||
348 | if (b==0xaa) | ||
349 | return 0; | ||
350 | dprintk(KERN_INFO DEVNAME ": key %02x\n", b); | ||
351 | |||
352 | /* | ||
353 | * NOTE: | ||
354 | * lirc_i2c maps the pv951 code as: | ||
355 | * addr = 0x61D6 | ||
356 | * cmd = bit_reverse (b) | ||
357 | * So, it seems that this device uses NEC extended | ||
358 | * I decided to not fix the table, due to two reasons: | ||
359 | * 1) Without the actual device, this is only a guess; | ||
360 | * 2) As the addr is not reported via I2C, nor can be changed, | ||
361 | * the device is bound to the vendor-provided RC. | ||
362 | */ | ||
363 | |||
364 | *ir_key = b; | ||
365 | *ir_raw = b; | ||
366 | return 1; | ||
367 | } | ||
368 | |||
369 | /* Instantiate the I2C IR receiver device, if present */ | ||
370 | void __devinit init_bttv_i2c_ir(struct bttv *btv) | ||
371 | { | ||
372 | const unsigned short addr_list[] = { | ||
373 | 0x1a, 0x18, 0x64, 0x30, 0x71, | ||
374 | I2C_CLIENT_END | ||
375 | }; | ||
376 | struct i2c_board_info info; | ||
377 | |||
378 | if (0 != btv->i2c_rc) | ||
379 | return; | ||
380 | |||
381 | memset(&info, 0, sizeof(struct i2c_board_info)); | ||
382 | memset(&btv->init_data, 0, sizeof(btv->init_data)); | ||
383 | strlcpy(info.type, "ir_video", I2C_NAME_SIZE); | ||
384 | |||
385 | switch (btv->c.type) { | ||
386 | case BTTV_BOARD_PV951: | ||
387 | btv->init_data.name = "PV951"; | ||
388 | btv->init_data.get_key = get_key_pv951; | ||
389 | btv->init_data.ir_codes = RC_MAP_PV951; | ||
390 | info.addr = 0x4b; | ||
391 | break; | ||
392 | default: | ||
393 | /* | ||
394 | * The external IR receiver is at i2c address 0x34 (0x35 for | ||
395 | * reads). Future Hauppauge cards will have an internal | ||
396 | * receiver at 0x30 (0x31 for reads). In theory, both can be | ||
397 | * fitted, and Hauppauge suggest an external overrides an | ||
398 | * internal. | ||
399 | * That's why we probe 0x1a (~0x34) first. CB | ||
400 | */ | ||
401 | |||
402 | i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list, NULL); | ||
403 | return; | ||
404 | } | ||
405 | |||
406 | if (btv->init_data.name) | ||
407 | info.platform_data = &btv->init_data; | ||
408 | i2c_new_device(&btv->c.i2c_adap, &info); | ||
409 | |||
410 | return; | ||
411 | } | ||
412 | |||
413 | int __devexit fini_bttv_i2c(struct bttv *btv) | ||
414 | { | ||
415 | if (0 != btv->i2c_rc) | ||
416 | return 0; | ||
417 | |||
418 | return i2c_del_adapter(&btv->c.i2c_adap); | ||
419 | } | ||
420 | |||
421 | int bttv_input_init(struct bttv *btv) | ||
422 | { | ||
423 | struct bttv_ir *ir; | ||
424 | char *ir_codes = NULL; | ||
425 | struct rc_dev *rc; | ||
426 | int err = -ENOMEM; | ||
427 | |||
428 | if (!btv->has_remote) | ||
429 | return -ENODEV; | ||
430 | |||
431 | ir = kzalloc(sizeof(*ir),GFP_KERNEL); | ||
432 | rc = rc_allocate_device(); | ||
433 | if (!ir || !rc) | ||
434 | goto err_out_free; | ||
435 | |||
436 | /* detect & configure */ | ||
437 | switch (btv->c.type) { | ||
438 | case BTTV_BOARD_AVERMEDIA: | ||
439 | case BTTV_BOARD_AVPHONE98: | ||
440 | case BTTV_BOARD_AVERMEDIA98: | ||
441 | ir_codes = RC_MAP_AVERMEDIA; | ||
442 | ir->mask_keycode = 0xf88000; | ||
443 | ir->mask_keydown = 0x010000; | ||
444 | ir->polling = 50; // ms | ||
445 | break; | ||
446 | |||
447 | case BTTV_BOARD_AVDVBT_761: | ||
448 | case BTTV_BOARD_AVDVBT_771: | ||
449 | ir_codes = RC_MAP_AVERMEDIA_DVBT; | ||
450 | ir->mask_keycode = 0x0f00c0; | ||
451 | ir->mask_keydown = 0x000020; | ||
452 | ir->polling = 50; // ms | ||
453 | break; | ||
454 | |||
455 | case BTTV_BOARD_PXELVWPLTVPAK: | ||
456 | ir_codes = RC_MAP_PIXELVIEW; | ||
457 | ir->mask_keycode = 0x003e00; | ||
458 | ir->mask_keyup = 0x010000; | ||
459 | ir->polling = 50; // ms | ||
460 | break; | ||
461 | case BTTV_BOARD_PV_M4900: | ||
462 | case BTTV_BOARD_PV_BT878P_9B: | ||
463 | case BTTV_BOARD_PV_BT878P_PLUS: | ||
464 | ir_codes = RC_MAP_PIXELVIEW; | ||
465 | ir->mask_keycode = 0x001f00; | ||
466 | ir->mask_keyup = 0x008000; | ||
467 | ir->polling = 50; // ms | ||
468 | break; | ||
469 | |||
470 | case BTTV_BOARD_WINFAST2000: | ||
471 | ir_codes = RC_MAP_WINFAST; | ||
472 | ir->mask_keycode = 0x1f8; | ||
473 | break; | ||
474 | case BTTV_BOARD_MAGICTVIEW061: | ||
475 | case BTTV_BOARD_MAGICTVIEW063: | ||
476 | ir_codes = RC_MAP_WINFAST; | ||
477 | ir->mask_keycode = 0x0008e000; | ||
478 | ir->mask_keydown = 0x00200000; | ||
479 | break; | ||
480 | case BTTV_BOARD_APAC_VIEWCOMP: | ||
481 | ir_codes = RC_MAP_APAC_VIEWCOMP; | ||
482 | ir->mask_keycode = 0x001f00; | ||
483 | ir->mask_keyup = 0x008000; | ||
484 | ir->polling = 50; // ms | ||
485 | break; | ||
486 | case BTTV_BOARD_ASKEY_CPH03X: | ||
487 | case BTTV_BOARD_CONCEPTRONIC_CTVFMI2: | ||
488 | case BTTV_BOARD_CONTVFMI: | ||
489 | ir_codes = RC_MAP_PIXELVIEW; | ||
490 | ir->mask_keycode = 0x001F00; | ||
491 | ir->mask_keyup = 0x006000; | ||
492 | ir->polling = 50; // ms | ||
493 | break; | ||
494 | case BTTV_BOARD_NEBULA_DIGITV: | ||
495 | ir_codes = RC_MAP_NEBULA; | ||
496 | ir->rc5_gpio = true; | ||
497 | break; | ||
498 | case BTTV_BOARD_MACHTV_MAGICTV: | ||
499 | ir_codes = RC_MAP_APAC_VIEWCOMP; | ||
500 | ir->mask_keycode = 0x001F00; | ||
501 | ir->mask_keyup = 0x004000; | ||
502 | ir->polling = 50; /* ms */ | ||
503 | break; | ||
504 | case BTTV_BOARD_KOZUMI_KTV_01C: | ||
505 | ir_codes = RC_MAP_PCTV_SEDNA; | ||
506 | ir->mask_keycode = 0x001f00; | ||
507 | ir->mask_keyup = 0x006000; | ||
508 | ir->polling = 50; /* ms */ | ||
509 | break; | ||
510 | case BTTV_BOARD_ENLTV_FM_2: | ||
511 | ir_codes = RC_MAP_ENCORE_ENLTV2; | ||
512 | ir->mask_keycode = 0x00fd00; | ||
513 | ir->mask_keyup = 0x000080; | ||
514 | ir->polling = 1; /* ms */ | ||
515 | ir->last_gpio = ir_extract_bits(bttv_gpio_read(&btv->c), | ||
516 | ir->mask_keycode); | ||
517 | break; | ||
518 | } | ||
519 | if (NULL == ir_codes) { | ||
520 | dprintk(KERN_INFO "Ooops: IR config error [card=%d]\n", btv->c.type); | ||
521 | err = -ENODEV; | ||
522 | goto err_out_free; | ||
523 | } | ||
524 | |||
525 | if (ir->rc5_gpio) { | ||
526 | u32 gpio; | ||
527 | /* enable remote irq */ | ||
528 | bttv_gpio_inout(&btv->c, (1 << 4), 1 << 4); | ||
529 | gpio = bttv_gpio_read(&btv->c); | ||
530 | bttv_gpio_write(&btv->c, gpio & ~(1 << 4)); | ||
531 | bttv_gpio_write(&btv->c, gpio | (1 << 4)); | ||
532 | } else { | ||
533 | /* init hardware-specific stuff */ | ||
534 | bttv_gpio_inout(&btv->c, ir->mask_keycode | ir->mask_keydown, 0); | ||
535 | } | ||
536 | |||
537 | /* init input device */ | ||
538 | ir->dev = rc; | ||
539 | |||
540 | snprintf(ir->name, sizeof(ir->name), "bttv IR (card=%d)", | ||
541 | btv->c.type); | ||
542 | snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", | ||
543 | pci_name(btv->c.pci)); | ||
544 | |||
545 | rc->input_name = ir->name; | ||
546 | rc->input_phys = ir->phys; | ||
547 | rc->input_id.bustype = BUS_PCI; | ||
548 | rc->input_id.version = 1; | ||
549 | if (btv->c.pci->subsystem_vendor) { | ||
550 | rc->input_id.vendor = btv->c.pci->subsystem_vendor; | ||
551 | rc->input_id.product = btv->c.pci->subsystem_device; | ||
552 | } else { | ||
553 | rc->input_id.vendor = btv->c.pci->vendor; | ||
554 | rc->input_id.product = btv->c.pci->device; | ||
555 | } | ||
556 | rc->dev.parent = &btv->c.pci->dev; | ||
557 | rc->map_name = ir_codes; | ||
558 | rc->driver_name = MODULE_NAME; | ||
559 | |||
560 | btv->remote = ir; | ||
561 | bttv_ir_start(btv, ir); | ||
562 | |||
563 | /* all done */ | ||
564 | err = rc_register_device(rc); | ||
565 | if (err) | ||
566 | goto err_out_stop; | ||
567 | |||
568 | return 0; | ||
569 | |||
570 | err_out_stop: | ||
571 | bttv_ir_stop(btv); | ||
572 | btv->remote = NULL; | ||
573 | err_out_free: | ||
574 | rc_free_device(rc); | ||
575 | kfree(ir); | ||
576 | return err; | ||
577 | } | ||
578 | |||
579 | void bttv_input_fini(struct bttv *btv) | ||
580 | { | ||
581 | if (btv->remote == NULL) | ||
582 | return; | ||
583 | |||
584 | bttv_ir_stop(btv); | ||
585 | rc_unregister_device(btv->remote->dev); | ||
586 | kfree(btv->remote); | ||
587 | btv->remote = NULL; | ||
588 | } | ||