1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // handle em28xx IR remotes via linux kernel input layer.
4 //
5 // Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 //		      Markus Rechberger <mrechberger@gmail.com>
7 //		      Mauro Carvalho Chehab <mchehab@kernel.org>
8 //		      Sascha Sommer <saschasommer@freenet.de>
9 //
10 // This program is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU General Public License as published by
12 // the Free Software Foundation; either version 2 of the License, or
13 // (at your option) any later version.
14 //
15 // This program is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 // GNU General Public License for more details.
19 
20 #include "em28xx.h"
21 
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/interrupt.h>
26 #include <linux/usb.h>
27 #include <linux/usb/input.h>
28 #include <linux/slab.h>
29 #include <linux/bitrev.h>
30 
31 #define EM28XX_SNAPSHOT_KEY				KEY_CAMERA
32 #define EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL		500 /* [ms] */
33 #define EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL		100 /* [ms] */
34 
35 static unsigned int ir_debug;
36 module_param(ir_debug, int, 0644);
37 MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
38 
39 #define MODULE_NAME "em28xx"
40 
41 #define dprintk(fmt, arg...) do {					\
42 	if (ir_debug)							\
43 		dev_printk(KERN_DEBUG, &ir->dev->intf->dev,		\
44 			   "input: %s: " fmt, __func__, ## arg);	\
45 } while (0)
46 
47 /*
48  * Polling structure used by em28xx IR's
49  */
50 
51 struct em28xx_ir_poll_result {
52 	unsigned int toggle_bit:1;
53 	unsigned int read_count:7;
54 
55 	enum rc_proto protocol;
56 	u32 scancode;
57 };
58 
59 struct em28xx_IR {
60 	struct em28xx *dev;
61 	struct rc_dev *rc;
62 	char phys[32];
63 
64 	/* poll decoder */
65 	int polling;
66 	struct delayed_work work;
67 	unsigned int full_code:1;
68 	unsigned int last_readcount;
69 	u64 rc_proto;
70 
71 	struct i2c_client *i2c_client;
72 
73 	int  (*get_key_i2c)(struct i2c_client *ir, enum rc_proto *protocol,
74 			    u32 *scancode);
75 	int  (*get_key)(struct em28xx_IR *ir, struct em28xx_ir_poll_result *r);
76 };
77 
78 /*
79  * I2C IR based get keycodes - should be used with ir-kbd-i2c
80  */
81 
82 static int em28xx_get_key_terratec(struct i2c_client *i2c_dev,
83 				   enum rc_proto *protocol, u32 *scancode)
84 {
85 	int rc;
86 	unsigned char b;
87 
88 	/* poll IR chip */
89 	rc = i2c_master_recv(i2c_dev, &b, 1);
90 	if (rc != 1) {
91 		if (rc < 0)
92 			return rc;
93 		return -EIO;
94 	}
95 
96 	/*
97 	 * it seems that 0xFE indicates that a button is still hold
98 	 * down, while 0xff indicates that no button is hold down.
99 	 */
100 
101 	if (b == 0xff)
102 		return 0;
103 
104 	if (b == 0xfe)
105 		/* keep old data */
106 		return 1;
107 
108 	*protocol = RC_PROTO_UNKNOWN;
109 	*scancode = b;
110 	return 1;
111 }
112 
113 static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev,
114 				  enum rc_proto *protocol, u32 *scancode)
115 {
116 	unsigned char buf[2];
117 	int size;
118 
119 	/* poll IR chip */
120 	size = i2c_master_recv(i2c_dev, buf, sizeof(buf));
121 
122 	if (size != 2)
123 		return -EIO;
124 
125 	/* Does eliminate repeated parity code */
126 	if (buf[1] == 0xff)
127 		return 0;
128 
129 	/*
130 	 * Rearranges bits to the right order.
131 	 * The bit order were determined experimentally by using
132 	 * The original Hauppauge Grey IR and another RC5 that uses addr=0x08
133 	 * The RC5 code has 14 bits, but we've experimentally determined
134 	 * the meaning for only 11 bits.
135 	 * So, the code translation is not complete. Yet, it is enough to
136 	 * work with the provided RC5 IR.
137 	 */
138 	*protocol = RC_PROTO_RC5;
139 	*scancode = (bitrev8(buf[1]) & 0x1f) << 8 | bitrev8(buf[0]) >> 2;
140 	return 1;
141 }
142 
143 static int em28xx_get_key_pinnacle_usb_grey(struct i2c_client *i2c_dev,
144 					    enum rc_proto *protocol,
145 					    u32 *scancode)
146 {
147 	unsigned char buf[3];
148 
149 	/* poll IR chip */
150 
151 	if (i2c_master_recv(i2c_dev, buf, 3) != 3)
152 		return -EIO;
153 
154 	if (buf[0] != 0x00)
155 		return 0;
156 
157 	*protocol = RC_PROTO_UNKNOWN;
158 	*scancode = buf[2] & 0x3f;
159 	return 1;
160 }
161 
162 static int em28xx_get_key_winfast_usbii_deluxe(struct i2c_client *i2c_dev,
163 					       enum rc_proto *protocol,
164 					       u32 *scancode)
165 {
166 	unsigned char subaddr, keydetect, key;
167 
168 	struct i2c_msg msg[] = {
169 		{
170 			.addr = i2c_dev->addr,
171 			.flags = 0,
172 			.buf = &subaddr, .len = 1
173 		}, {
174 			.addr = i2c_dev->addr,
175 			.flags = I2C_M_RD,
176 			.buf = &keydetect,
177 			.len = 1
178 		}
179 	};
180 
181 	subaddr = 0x10;
182 	if (i2c_transfer(i2c_dev->adapter, msg, 2) != 2)
183 		return -EIO;
184 	if (keydetect == 0x00)
185 		return 0;
186 
187 	subaddr = 0x00;
188 	msg[1].buf = &key;
189 	if (i2c_transfer(i2c_dev->adapter, msg, 2) != 2)
190 		return -EIO;
191 	if (key == 0x00)
192 		return 0;
193 
194 	*protocol = RC_PROTO_UNKNOWN;
195 	*scancode = key;
196 	return 1;
197 }
198 
199 /*
200  * Poll based get keycode functions
201  */
202 
203 /* This is for the em2860/em2880 */
204 static int default_polling_getkey(struct em28xx_IR *ir,
205 				  struct em28xx_ir_poll_result *poll_result)
206 {
207 	struct em28xx *dev = ir->dev;
208 	int rc;
209 	u8 msg[3] = { 0, 0, 0 };
210 
211 	/*
212 	 * Read key toggle, brand, and key code
213 	 * on registers 0x45, 0x46 and 0x47
214 	 */
215 	rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR,
216 					  msg, sizeof(msg));
217 	if (rc < 0)
218 		return rc;
219 
220 	/* Infrared toggle (Reg 0x45[7]) */
221 	poll_result->toggle_bit = (msg[0] >> 7);
222 
223 	/* Infrared read count (Reg 0x45[6:0] */
224 	poll_result->read_count = (msg[0] & 0x7f);
225 
226 	/* Remote Control Address/Data (Regs 0x46/0x47) */
227 	switch (ir->rc_proto) {
228 	case RC_PROTO_BIT_RC5:
229 		poll_result->protocol = RC_PROTO_RC5;
230 		poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]);
231 		break;
232 
233 	case RC_PROTO_BIT_NEC:
234 		poll_result->protocol = RC_PROTO_NEC;
235 		poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[2]);
236 		break;
237 
238 	default:
239 		poll_result->protocol = RC_PROTO_UNKNOWN;
240 		poll_result->scancode = msg[1] << 8 | msg[2];
241 		break;
242 	}
243 
244 	return 0;
245 }
246 
247 static int em2874_polling_getkey(struct em28xx_IR *ir,
248 				 struct em28xx_ir_poll_result *poll_result)
249 {
250 	struct em28xx *dev = ir->dev;
251 	int rc;
252 	u8 msg[5] = { 0, 0, 0, 0, 0 };
253 
254 	/*
255 	 * Read key toggle, brand, and key code
256 	 * on registers 0x51-55
257 	 */
258 	rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR,
259 					  msg, sizeof(msg));
260 	if (rc < 0)
261 		return rc;
262 
263 	/* Infrared toggle (Reg 0x51[7]) */
264 	poll_result->toggle_bit = (msg[0] >> 7);
265 
266 	/* Infrared read count (Reg 0x51[6:0] */
267 	poll_result->read_count = (msg[0] & 0x7f);
268 
269 	/*
270 	 * Remote Control Address (Reg 0x52)
271 	 * Remote Control Data (Reg 0x53-0x55)
272 	 */
273 	switch (ir->rc_proto) {
274 	case RC_PROTO_BIT_RC5:
275 		poll_result->protocol = RC_PROTO_RC5;
276 		poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]);
277 		break;
278 
279 	case RC_PROTO_BIT_NEC:
280 		poll_result->scancode = ir_nec_bytes_to_scancode(msg[1], msg[2], msg[3], msg[4],
281 								 &poll_result->protocol);
282 		break;
283 
284 	case RC_PROTO_BIT_RC6_0:
285 		poll_result->protocol = RC_PROTO_RC6_0;
286 		poll_result->scancode = RC_SCANCODE_RC6_0(msg[1], msg[2]);
287 		break;
288 
289 	default:
290 		poll_result->protocol = RC_PROTO_UNKNOWN;
291 		poll_result->scancode = (msg[1] << 24) | (msg[2] << 16) |
292 					(msg[3] << 8)  | msg[4];
293 		break;
294 	}
295 
296 	return 0;
297 }
298 
299 /*
300  * Polling code for em28xx
301  */
302 
303 static int em28xx_i2c_ir_handle_key(struct em28xx_IR *ir)
304 {
305 	static u32 scancode;
306 	enum rc_proto protocol;
307 	int rc;
308 
309 	rc = ir->get_key_i2c(ir->i2c_client, &protocol, &scancode);
310 	if (rc < 0) {
311 		dprintk("ir->get_key_i2c() failed: %d\n", rc);
312 		return rc;
313 	}
314 
315 	if (rc) {
316 		dprintk("%s: proto = 0x%04x, scancode = 0x%04x\n",
317 			__func__, protocol, scancode);
318 		rc_keydown(ir->rc, protocol, scancode, 0);
319 	}
320 	return 0;
321 }
322 
323 static void em28xx_ir_handle_key(struct em28xx_IR *ir)
324 {
325 	int result;
326 	struct em28xx_ir_poll_result poll_result;
327 
328 	/* read the registers containing the IR status */
329 	result = ir->get_key(ir, &poll_result);
330 	if (unlikely(result < 0)) {
331 		dprintk("ir->get_key() failed: %d\n", result);
332 		return;
333 	}
334 
335 	if (unlikely(poll_result.read_count != ir->last_readcount)) {
336 		dprintk("%s: toggle: %d, count: %d, key 0x%04x\n", __func__,
337 			poll_result.toggle_bit, poll_result.read_count,
338 			poll_result.scancode);
339 		if (ir->full_code)
340 			rc_keydown(ir->rc,
341 				   poll_result.protocol,
342 				   poll_result.scancode,
343 				   poll_result.toggle_bit);
344 		else
345 			rc_keydown(ir->rc,
346 				   RC_PROTO_UNKNOWN,
347 				   poll_result.scancode & 0xff,
348 				   poll_result.toggle_bit);
349 
350 		if (ir->dev->chip_id == CHIP_ID_EM2874 ||
351 		    ir->dev->chip_id == CHIP_ID_EM2884)
352 			/*
353 			 * The em2874 clears the readcount field every time the
354 			 * register is read.  The em2860/2880 datasheet says
355 			 * that it is supposed to clear the readcount, but it
356 			 * doesn't. So with the em2874, we are looking for a
357 			 * non-zero read count as opposed to a readcount
358 			 * that is incrementing
359 			 */
360 			ir->last_readcount = 0;
361 		else
362 			ir->last_readcount = poll_result.read_count;
363 	}
364 }
365 
366 static void em28xx_ir_work(struct work_struct *work)
367 {
368 	struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work);
369 
370 	if (ir->i2c_client) /* external i2c device */
371 		em28xx_i2c_ir_handle_key(ir);
372 	else /* internal device */
373 		em28xx_ir_handle_key(ir);
374 	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
375 }
376 
377 static int em28xx_ir_start(struct rc_dev *rc)
378 {
379 	struct em28xx_IR *ir = rc->priv;
380 
381 	INIT_DELAYED_WORK(&ir->work, em28xx_ir_work);
382 	schedule_delayed_work(&ir->work, 0);
383 
384 	return 0;
385 }
386 
387 static void em28xx_ir_stop(struct rc_dev *rc)
388 {
389 	struct em28xx_IR *ir = rc->priv;
390 
391 	cancel_delayed_work_sync(&ir->work);
392 }
393 
394 static int em2860_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_proto)
395 {
396 	struct em28xx_IR *ir = rc_dev->priv;
397 	struct em28xx *dev = ir->dev;
398 
399 	/* Adjust xclk based on IR table for RC5/NEC tables */
400 	if (*rc_proto & RC_PROTO_BIT_RC5) {
401 		dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
402 		ir->full_code = 1;
403 		*rc_proto = RC_PROTO_BIT_RC5;
404 	} else if (*rc_proto & RC_PROTO_BIT_NEC) {
405 		dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
406 		ir->full_code = 1;
407 		*rc_proto = RC_PROTO_BIT_NEC;
408 	} else if (*rc_proto & RC_PROTO_BIT_UNKNOWN) {
409 		*rc_proto = RC_PROTO_BIT_UNKNOWN;
410 	} else {
411 		*rc_proto = ir->rc_proto;
412 		return -EINVAL;
413 	}
414 	em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
415 			      EM28XX_XCLK_IR_RC5_MODE);
416 
417 	ir->rc_proto = *rc_proto;
418 
419 	return 0;
420 }
421 
422 static int em2874_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_proto)
423 {
424 	struct em28xx_IR *ir = rc_dev->priv;
425 	struct em28xx *dev = ir->dev;
426 	u8 ir_config = EM2874_IR_RC5;
427 
428 	/* Adjust xclk and set type based on IR table for RC5/NEC/RC6 tables */
429 	if (*rc_proto & RC_PROTO_BIT_RC5) {
430 		dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
431 		ir->full_code = 1;
432 		*rc_proto = RC_PROTO_BIT_RC5;
433 	} else if (*rc_proto & RC_PROTO_BIT_NEC) {
434 		dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
435 		ir_config = EM2874_IR_NEC | EM2874_IR_NEC_NO_PARITY;
436 		ir->full_code = 1;
437 		*rc_proto = RC_PROTO_BIT_NEC;
438 	} else if (*rc_proto & RC_PROTO_BIT_RC6_0) {
439 		dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
440 		ir_config = EM2874_IR_RC6_MODE_0;
441 		ir->full_code = 1;
442 		*rc_proto = RC_PROTO_BIT_RC6_0;
443 	} else if (*rc_proto & RC_PROTO_BIT_UNKNOWN) {
444 		*rc_proto = RC_PROTO_BIT_UNKNOWN;
445 	} else {
446 		*rc_proto = ir->rc_proto;
447 		return -EINVAL;
448 	}
449 	em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
450 	em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
451 			      EM28XX_XCLK_IR_RC5_MODE);
452 
453 	ir->rc_proto = *rc_proto;
454 
455 	return 0;
456 }
457 
458 static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_proto)
459 {
460 	struct em28xx_IR *ir = rc_dev->priv;
461 	struct em28xx *dev = ir->dev;
462 
463 	/* Setup the proper handler based on the chip */
464 	switch (dev->chip_id) {
465 	case CHIP_ID_EM2860:
466 	case CHIP_ID_EM2883:
467 		return em2860_ir_change_protocol(rc_dev, rc_proto);
468 	case CHIP_ID_EM2884:
469 	case CHIP_ID_EM2874:
470 	case CHIP_ID_EM28174:
471 	case CHIP_ID_EM28178:
472 		return em2874_ir_change_protocol(rc_dev, rc_proto);
473 	default:
474 		dev_err(&ir->dev->intf->dev,
475 			"Unrecognized em28xx chip id 0x%02x: IR not supported\n",
476 			dev->chip_id);
477 		return -EINVAL;
478 	}
479 }
480 
481 static int em28xx_probe_i2c_ir(struct em28xx *dev)
482 {
483 	int i = 0;
484 	/*
485 	 * Leadtek winfast tv USBII deluxe can find a non working IR-device
486 	 * at address 0x18, so if that address is needed for another board in
487 	 * the future, please put it after 0x1f.
488 	 */
489 	static const unsigned short addr_list[] = {
490 		 0x1f, 0x30, 0x47, I2C_CLIENT_END
491 	};
492 
493 	while (addr_list[i] != I2C_CLIENT_END) {
494 		if (i2c_probe_func_quick_read(&dev->i2c_adap[dev->def_i2c_bus],
495 					      addr_list[i]) == 1)
496 			return addr_list[i];
497 		i++;
498 	}
499 
500 	return -ENODEV;
501 }
502 
503 /*
504  * Handle buttons
505  */
506 
507 static void em28xx_query_buttons(struct work_struct *work)
508 {
509 	struct em28xx *dev =
510 		container_of(work, struct em28xx, buttons_query_work.work);
511 	u8 i, j;
512 	int regval;
513 	bool is_pressed, was_pressed;
514 	const struct em28xx_led *led;
515 
516 	/* Poll and evaluate all addresses */
517 	for (i = 0; i < dev->num_button_polling_addresses; i++) {
518 		/* Read value from register */
519 		regval = em28xx_read_reg(dev, dev->button_polling_addresses[i]);
520 		if (regval < 0)
521 			continue;
522 		/* Check states of the buttons and act */
523 		j = 0;
524 		while (dev->board.buttons[j].role >= 0 &&
525 		       dev->board.buttons[j].role < EM28XX_NUM_BUTTON_ROLES) {
526 			const struct em28xx_button *button;
527 
528 			button = &dev->board.buttons[j];
529 
530 			/* Check if button uses the current address */
531 			if (button->reg_r != dev->button_polling_addresses[i]) {
532 				j++;
533 				continue;
534 			}
535 			/* Determine if button is and was pressed last time */
536 			is_pressed = regval & button->mask;
537 			was_pressed = dev->button_polling_last_values[i]
538 				       & button->mask;
539 			if (button->inverted) {
540 				is_pressed = !is_pressed;
541 				was_pressed = !was_pressed;
542 			}
543 			/* Clear button state (if needed) */
544 			if (is_pressed && button->reg_clearing)
545 				em28xx_write_reg(dev, button->reg_clearing,
546 						 (~regval & button->mask)
547 						    | (regval & ~button->mask));
548 			/* Handle button state */
549 			if (!is_pressed || was_pressed) {
550 				j++;
551 				continue;
552 			}
553 			switch (button->role) {
554 			case EM28XX_BUTTON_SNAPSHOT:
555 				/* Emulate the keypress */
556 				input_report_key(dev->sbutton_input_dev,
557 						 EM28XX_SNAPSHOT_KEY, 1);
558 				/* Unpress the key */
559 				input_report_key(dev->sbutton_input_dev,
560 						 EM28XX_SNAPSHOT_KEY, 0);
561 				break;
562 			case EM28XX_BUTTON_ILLUMINATION:
563 				led = em28xx_find_led(dev,
564 						      EM28XX_LED_ILLUMINATION);
565 				/* Switch illumination LED on/off */
566 				if (led)
567 					em28xx_toggle_reg_bits(dev,
568 							       led->gpio_reg,
569 							       led->gpio_mask);
570 				break;
571 			default:
572 				WARN_ONCE(1, "BUG: unhandled button role.");
573 			}
574 			/* Next button */
575 			j++;
576 		}
577 		/* Save current value for comparison during the next polling */
578 		dev->button_polling_last_values[i] = regval;
579 	}
580 	/* Schedule next poll */
581 	schedule_delayed_work(&dev->buttons_query_work,
582 			      msecs_to_jiffies(dev->button_polling_interval));
583 }
584 
585 static int em28xx_register_snapshot_button(struct em28xx *dev)
586 {
587 	struct usb_device *udev = interface_to_usbdev(dev->intf);
588 	struct input_dev *input_dev;
589 	int err;
590 
591 	dev_info(&dev->intf->dev, "Registering snapshot button...\n");
592 	input_dev = input_allocate_device();
593 	if (!input_dev)
594 		return -ENOMEM;
595 
596 	usb_make_path(udev, dev->snapshot_button_path,
597 		      sizeof(dev->snapshot_button_path));
598 	strlcat(dev->snapshot_button_path, "/sbutton",
599 		sizeof(dev->snapshot_button_path));
600 
601 	input_dev->name = "em28xx snapshot button";
602 	input_dev->phys = dev->snapshot_button_path;
603 	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
604 	set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit);
605 	input_dev->keycodesize = 0;
606 	input_dev->keycodemax = 0;
607 	usb_to_input_id(udev, &input_dev->id);
608 	input_dev->dev.parent = &dev->intf->dev;
609 
610 	err = input_register_device(input_dev);
611 	if (err) {
612 		dev_err(&dev->intf->dev, "input_register_device failed\n");
613 		input_free_device(input_dev);
614 		return err;
615 	}
616 
617 	dev->sbutton_input_dev = input_dev;
618 	return 0;
619 }
620 
621 static void em28xx_init_buttons(struct em28xx *dev)
622 {
623 	u8  i = 0, j = 0;
624 	bool addr_new = false;
625 
626 	dev->button_polling_interval = EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL;
627 	while (dev->board.buttons[i].role >= 0 &&
628 	       dev->board.buttons[i].role < EM28XX_NUM_BUTTON_ROLES) {
629 		const struct em28xx_button *button = &dev->board.buttons[i];
630 
631 		/* Check if polling address is already on the list */
632 		addr_new = true;
633 		for (j = 0; j < dev->num_button_polling_addresses; j++) {
634 			if (button->reg_r == dev->button_polling_addresses[j]) {
635 				addr_new = false;
636 				break;
637 			}
638 		}
639 		/* Check if max. number of polling addresses is exceeded */
640 		if (addr_new && dev->num_button_polling_addresses
641 					   >= EM28XX_NUM_BUTTON_ADDRESSES_MAX) {
642 			WARN_ONCE(1, "BUG: maximum number of button polling addresses exceeded.");
643 			goto next_button;
644 		}
645 		/* Button role specific checks and actions */
646 		if (button->role == EM28XX_BUTTON_SNAPSHOT) {
647 			/* Register input device */
648 			if (em28xx_register_snapshot_button(dev) < 0)
649 				goto next_button;
650 		} else if (button->role == EM28XX_BUTTON_ILLUMINATION) {
651 			/* Check sanity */
652 			if (!em28xx_find_led(dev, EM28XX_LED_ILLUMINATION)) {
653 				dev_err(&dev->intf->dev,
654 					"BUG: illumination button defined, but no illumination LED.\n");
655 				goto next_button;
656 			}
657 		}
658 		/* Add read address to list of polling addresses */
659 		if (addr_new) {
660 			unsigned int index = dev->num_button_polling_addresses;
661 
662 			dev->button_polling_addresses[index] = button->reg_r;
663 			dev->num_button_polling_addresses++;
664 		}
665 		/* Reduce polling interval if necessary */
666 		if (!button->reg_clearing)
667 			dev->button_polling_interval =
668 					 EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL;
669 next_button:
670 		/* Next button */
671 		i++;
672 	}
673 
674 	/* Start polling */
675 	if (dev->num_button_polling_addresses) {
676 		memset(dev->button_polling_last_values, 0,
677 		       EM28XX_NUM_BUTTON_ADDRESSES_MAX);
678 		schedule_delayed_work(&dev->buttons_query_work,
679 				      msecs_to_jiffies(dev->button_polling_interval));
680 	}
681 }
682 
683 static void em28xx_shutdown_buttons(struct em28xx *dev)
684 {
685 	/* Cancel polling */
686 	cancel_delayed_work_sync(&dev->buttons_query_work);
687 	/* Clear polling addresses list */
688 	dev->num_button_polling_addresses = 0;
689 	/* Deregister input devices */
690 	if (dev->sbutton_input_dev) {
691 		dev_info(&dev->intf->dev, "Deregistering snapshot button\n");
692 		input_unregister_device(dev->sbutton_input_dev);
693 		dev->sbutton_input_dev = NULL;
694 	}
695 }
696 
697 static int em28xx_ir_init(struct em28xx *dev)
698 {
699 	struct usb_device *udev = interface_to_usbdev(dev->intf);
700 	struct em28xx_IR *ir;
701 	struct rc_dev *rc;
702 	int err = -ENOMEM;
703 	u64 rc_proto;
704 	u16 i2c_rc_dev_addr = 0;
705 
706 	if (dev->is_audio_only) {
707 		/* Shouldn't initialize IR for this interface */
708 		return 0;
709 	}
710 
711 	kref_get(&dev->ref);
712 	INIT_DELAYED_WORK(&dev->buttons_query_work, em28xx_query_buttons);
713 
714 	if (dev->board.buttons)
715 		em28xx_init_buttons(dev);
716 
717 	if (dev->board.has_ir_i2c) {
718 		i2c_rc_dev_addr = em28xx_probe_i2c_ir(dev);
719 		if (!i2c_rc_dev_addr) {
720 			dev->board.has_ir_i2c = 0;
721 			dev_warn(&dev->intf->dev,
722 				 "No i2c IR remote control device found.\n");
723 			err = -ENODEV;
724 			goto ref_put;
725 		}
726 	}
727 
728 	if (!dev->board.ir_codes && !dev->board.has_ir_i2c) {
729 		/* No remote control support */
730 		dev_warn(&dev->intf->dev,
731 			 "Remote control support is not available for this card.\n");
732 		return 0;
733 	}
734 
735 	dev_info(&dev->intf->dev, "Registering input extension\n");
736 
737 	ir = kzalloc(sizeof(*ir), GFP_KERNEL);
738 	if (!ir)
739 		goto ref_put;
740 	rc = rc_allocate_device(RC_DRIVER_SCANCODE);
741 	if (!rc)
742 		goto error;
743 
744 	/* record handles to ourself */
745 	ir->dev = dev;
746 	dev->ir = ir;
747 	ir->rc = rc;
748 
749 	rc->priv = ir;
750 	rc->open = em28xx_ir_start;
751 	rc->close = em28xx_ir_stop;
752 
753 	if (dev->board.has_ir_i2c) {	/* external i2c device */
754 		switch (dev->model) {
755 		case EM2800_BOARD_TERRATEC_CINERGY_200:
756 		case EM2820_BOARD_TERRATEC_CINERGY_250:
757 			rc->map_name = RC_MAP_EM_TERRATEC;
758 			ir->get_key_i2c = em28xx_get_key_terratec;
759 			break;
760 		case EM2820_BOARD_PINNACLE_USB_2:
761 			rc->map_name = RC_MAP_PINNACLE_GREY;
762 			ir->get_key_i2c = em28xx_get_key_pinnacle_usb_grey;
763 			break;
764 		case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
765 			rc->map_name = RC_MAP_HAUPPAUGE;
766 			ir->get_key_i2c = em28xx_get_key_em_haup;
767 			rc->allowed_protocols = RC_PROTO_BIT_RC5;
768 			break;
769 		case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
770 			rc->map_name = RC_MAP_WINFAST_USBII_DELUXE;
771 			ir->get_key_i2c = em28xx_get_key_winfast_usbii_deluxe;
772 			break;
773 		default:
774 			err = -ENODEV;
775 			goto error;
776 		}
777 
778 		ir->i2c_client = kzalloc(sizeof(*ir->i2c_client), GFP_KERNEL);
779 		if (!ir->i2c_client)
780 			goto error;
781 		ir->i2c_client->adapter = &ir->dev->i2c_adap[dev->def_i2c_bus];
782 		ir->i2c_client->addr = i2c_rc_dev_addr;
783 		ir->i2c_client->flags = 0;
784 		/* NOTE: all other fields of i2c_client are unused */
785 	} else {	/* internal device */
786 		switch (dev->chip_id) {
787 		case CHIP_ID_EM2860:
788 		case CHIP_ID_EM2883:
789 			rc->allowed_protocols = RC_PROTO_BIT_RC5 |
790 						RC_PROTO_BIT_NEC;
791 			ir->get_key = default_polling_getkey;
792 			break;
793 		case CHIP_ID_EM2884:
794 		case CHIP_ID_EM2874:
795 		case CHIP_ID_EM28174:
796 		case CHIP_ID_EM28178:
797 			ir->get_key = em2874_polling_getkey;
798 			rc->allowed_protocols = RC_PROTO_BIT_RC5 |
799 				RC_PROTO_BIT_NEC | RC_PROTO_BIT_NECX |
800 				RC_PROTO_BIT_NEC32 | RC_PROTO_BIT_RC6_0;
801 			break;
802 		default:
803 			err = -ENODEV;
804 			goto error;
805 		}
806 
807 		rc->change_protocol = em28xx_ir_change_protocol;
808 		rc->map_name = dev->board.ir_codes;
809 
810 		/* By default, keep protocol field untouched */
811 		rc_proto = RC_PROTO_BIT_UNKNOWN;
812 		err = em28xx_ir_change_protocol(rc, &rc_proto);
813 		if (err)
814 			goto error;
815 	}
816 
817 	/* This is how often we ask the chip for IR information */
818 	ir->polling = 100; /* ms */
819 
820 	usb_make_path(udev, ir->phys, sizeof(ir->phys));
821 	strlcat(ir->phys, "/input0", sizeof(ir->phys));
822 
823 	rc->device_name = em28xx_boards[dev->model].name;
824 	rc->input_phys = ir->phys;
825 	usb_to_input_id(udev, &rc->input_id);
826 	rc->dev.parent = &dev->intf->dev;
827 	rc->driver_name = MODULE_NAME;
828 
829 	/* all done */
830 	err = rc_register_device(rc);
831 	if (err)
832 		goto error;
833 
834 	dev_info(&dev->intf->dev, "Input extension successfully initialized\n");
835 
836 	return 0;
837 
838 error:
839 	kfree(ir->i2c_client);
840 	dev->ir = NULL;
841 	rc_free_device(rc);
842 	kfree(ir);
843 ref_put:
844 	em28xx_shutdown_buttons(dev);
845 	return err;
846 }
847 
848 static int em28xx_ir_fini(struct em28xx *dev)
849 {
850 	struct em28xx_IR *ir = dev->ir;
851 
852 	if (dev->is_audio_only) {
853 		/* Shouldn't initialize IR for this interface */
854 		return 0;
855 	}
856 
857 	dev_info(&dev->intf->dev, "Closing input extension\n");
858 
859 	em28xx_shutdown_buttons(dev);
860 
861 	/* skip detach on non attached boards */
862 	if (!ir)
863 		goto ref_put;
864 
865 	rc_unregister_device(ir->rc);
866 
867 	kfree(ir->i2c_client);
868 
869 	/* done */
870 	kfree(ir);
871 	dev->ir = NULL;
872 
873 ref_put:
874 	kref_put(&dev->ref, em28xx_free_device);
875 
876 	return 0;
877 }
878 
879 static int em28xx_ir_suspend(struct em28xx *dev)
880 {
881 	struct em28xx_IR *ir = dev->ir;
882 
883 	if (dev->is_audio_only)
884 		return 0;
885 
886 	dev_info(&dev->intf->dev, "Suspending input extension\n");
887 	if (ir)
888 		cancel_delayed_work_sync(&ir->work);
889 	cancel_delayed_work_sync(&dev->buttons_query_work);
890 	/*
891 	 * is canceling delayed work sufficient or does the rc event
892 	 * kthread needs stopping? kthread is stopped in
893 	 * ir_raw_event_unregister()
894 	 */
895 	return 0;
896 }
897 
898 static int em28xx_ir_resume(struct em28xx *dev)
899 {
900 	struct em28xx_IR *ir = dev->ir;
901 
902 	if (dev->is_audio_only)
903 		return 0;
904 
905 	dev_info(&dev->intf->dev, "Resuming input extension\n");
906 	/*
907 	 * if suspend calls ir_raw_event_unregister(), the should call
908 	 * ir_raw_event_register()
909 	 */
910 	if (ir)
911 		schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
912 	if (dev->num_button_polling_addresses)
913 		schedule_delayed_work(&dev->buttons_query_work,
914 				      msecs_to_jiffies(dev->button_polling_interval));
915 	return 0;
916 }
917 
918 static struct em28xx_ops rc_ops = {
919 	.id   = EM28XX_RC,
920 	.name = "Em28xx Input Extension",
921 	.init = em28xx_ir_init,
922 	.fini = em28xx_ir_fini,
923 	.suspend = em28xx_ir_suspend,
924 	.resume = em28xx_ir_resume,
925 };
926 
927 static int __init em28xx_rc_register(void)
928 {
929 	return em28xx_register_extension(&rc_ops);
930 }
931 
932 static void __exit em28xx_rc_unregister(void)
933 {
934 	em28xx_unregister_extension(&rc_ops);
935 }
936 
937 MODULE_LICENSE("GPL v2");
938 MODULE_AUTHOR("Mauro Carvalho Chehab");
939 MODULE_DESCRIPTION(DRIVER_DESC " - input interface");
940 MODULE_VERSION(EM28XX_VERSION);
941 
942 module_init(em28xx_rc_register);
943 module_exit(em28xx_rc_unregister);
944