xref: /linux/drivers/media/i2c/ir-kbd-i2c.c (revision 7ec462100ef9142344ddbf86f2c3008b97acddbe)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /*
3   *
4   * keyboard input driver for i2c IR remote controls
5   *
6   * Copyright (c) 2000-2003 Gerd Knorr <kraxel@bytesex.org>
7   * modified for PixelView (BT878P+W/FM) by
8   *      Michal Kochanowicz <mkochano@pld.org.pl>
9   *      Christoph Bartelmus <lirc@bartelmus.de>
10   * modified for KNC ONE TV Station/Anubis Typhoon TView Tuner by
11   *      Ulrich Mueller <ulrich.mueller42@web.de>
12   * modified for em2820 based USB TV tuners by
13   *      Markus Rechberger <mrechberger@gmail.com>
14   * modified for DViCO Fusion HDTV 5 RT GOLD by
15   *      Chaogui Zhang <czhang1974@gmail.com>
16   * modified for MSI TV@nywhere Plus by
17   *      Henry Wong <henry@stuffedcow.net>
18   *      Mark Schultz <n9xmj@yahoo.com>
19   *      Brian Rogers <brian_rogers@comcast.net>
20   * modified for AVerMedia Cardbus by
21   *      Oldrich Jedlicka <oldium.pro@seznam.cz>
22   * Zilog Transmitter portions/ideas were derived from GPLv2+ sources:
23   *  - drivers/char/pctv_zilogir.[ch] from Hauppauge Broadway product
24   *	Copyright 2011 Hauppauge Computer works
25   *  - drivers/staging/media/lirc/lirc_zilog.c
26   *	Copyright (c) 2000 Gerd Knorr <kraxel@goldbach.in-berlin.de>
27   *	Michal Kochanowicz <mkochano@pld.org.pl>
28   *	Christoph Bartelmus <lirc@bartelmus.de>
29   *	Ulrich Mueller <ulrich.mueller42@web.de>
30   *	Stefan Jahn <stefan@lkcc.org>
31   *	Jerome Brock <jbrock@users.sourceforge.net>
32   *	Thomas Reitmayr (treitmayr@yahoo.com)
33   *	Mark Weaver <mark@npsl.co.uk>
34   *	Jarod Wilson <jarod@redhat.com>
35   *	Copyright (C) 2011 Andy Walls <awalls@md.metrocast.net>
36   */
37  
38  #include <linux/unaligned.h>
39  #include <linux/module.h>
40  #include <linux/init.h>
41  #include <linux/kernel.h>
42  #include <linux/string.h>
43  #include <linux/timer.h>
44  #include <linux/delay.h>
45  #include <linux/errno.h>
46  #include <linux/slab.h>
47  #include <linux/i2c.h>
48  #include <linux/workqueue.h>
49  
50  #include <media/rc-core.h>
51  #include <media/i2c/ir-kbd-i2c.h>
52  
53  #define FLAG_TX		1
54  #define FLAG_HDPVR	2
55  
56  static bool enable_hdpvr;
57  module_param(enable_hdpvr, bool, 0644);
58  
get_key_haup_common(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * ptoggle,int size)59  static int get_key_haup_common(struct IR_i2c *ir, enum rc_proto *protocol,
60  			       u32 *scancode, u8 *ptoggle, int size)
61  {
62  	unsigned char buf[6];
63  	int start, range, toggle, dev, code, ircode, vendor;
64  
65  	/* poll IR chip */
66  	if (size != i2c_master_recv(ir->c, buf, size))
67  		return -EIO;
68  
69  	if (buf[0] & 0x80) {
70  		int offset = (size == 6) ? 3 : 0;
71  
72  		/* split rc5 data block ... */
73  		start  = (buf[offset] >> 7) &    1;
74  		range  = (buf[offset] >> 6) &    1;
75  		toggle = (buf[offset] >> 5) &    1;
76  		dev    =  buf[offset]       & 0x1f;
77  		code   = (buf[offset+1] >> 2) & 0x3f;
78  
79  		/* rc5 has two start bits
80  		 * the first bit must be one
81  		 * the second bit defines the command range:
82  		 * 1 = 0-63, 0 = 64 - 127
83  		 */
84  		if (!start)
85  			/* no key pressed */
86  			return 0;
87  
88  		/* filter out invalid key presses */
89  		ircode = (start << 12) | (toggle << 11) | (dev << 6) | code;
90  		if ((ircode & 0x1fff) == 0x1fff)
91  			return 0;
92  
93  		if (!range)
94  			code += 64;
95  
96  		dev_dbg(&ir->rc->dev,
97  			"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
98  			start, range, toggle, dev, code);
99  
100  		*protocol = RC_PROTO_RC5;
101  		*scancode = RC_SCANCODE_RC5(dev, code);
102  		*ptoggle = toggle;
103  
104  		return 1;
105  	} else if (size == 6 && (buf[0] & 0x40)) {
106  		code = buf[4];
107  		dev = buf[3];
108  		vendor = get_unaligned_be16(buf + 1);
109  
110  		if (vendor == 0x800f) {
111  			*ptoggle = (dev & 0x80) != 0;
112  			*protocol = RC_PROTO_RC6_MCE;
113  			dev &= 0x7f;
114  			dev_dbg(&ir->rc->dev,
115  				"ir hauppauge (rc6-mce): t%d vendor=%d dev=%d code=%d\n",
116  				*ptoggle, vendor, dev, code);
117  		} else {
118  			*ptoggle = 0;
119  			*protocol = RC_PROTO_RC6_6A_32;
120  			dev_dbg(&ir->rc->dev,
121  				"ir hauppauge (rc6-6a-32): vendor=%d dev=%d code=%d\n",
122  				vendor, dev, code);
123  		}
124  
125  		*scancode = RC_SCANCODE_RC6_6A(vendor, dev, code);
126  
127  		return 1;
128  	}
129  
130  	return 0;
131  }
132  
get_key_haup(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)133  static int get_key_haup(struct IR_i2c *ir, enum rc_proto *protocol,
134  			u32 *scancode, u8 *toggle)
135  {
136  	return get_key_haup_common(ir, protocol, scancode, toggle, 3);
137  }
138  
get_key_haup_xvr(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)139  static int get_key_haup_xvr(struct IR_i2c *ir, enum rc_proto *protocol,
140  			    u32 *scancode, u8 *toggle)
141  {
142  	int ret;
143  	unsigned char buf[1] = { 0 };
144  
145  	/*
146  	 * This is the same apparent "are you ready?" poll command observed
147  	 * watching Windows driver traffic and implemented in lirc_zilog. With
148  	 * this added, we get far saner remote behavior with z8 chips on usb
149  	 * connected devices, even with the default polling interval of 100ms.
150  	 */
151  	ret = i2c_master_send(ir->c, buf, 1);
152  	if (ret != 1)
153  		return (ret < 0) ? ret : -EINVAL;
154  
155  	return get_key_haup_common(ir, protocol, scancode, toggle, 6);
156  }
157  
get_key_pixelview(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)158  static int get_key_pixelview(struct IR_i2c *ir, enum rc_proto *protocol,
159  			     u32 *scancode, u8 *toggle)
160  {
161  	int rc;
162  	unsigned char b;
163  
164  	/* poll IR chip */
165  	rc = i2c_master_recv(ir->c, &b, 1);
166  	if (rc != 1) {
167  		dev_dbg(&ir->rc->dev, "read error\n");
168  		if (rc < 0)
169  			return rc;
170  		return -EIO;
171  	}
172  
173  	*protocol = RC_PROTO_OTHER;
174  	*scancode = b;
175  	*toggle = 0;
176  	return 1;
177  }
178  
get_key_fusionhdtv(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)179  static int get_key_fusionhdtv(struct IR_i2c *ir, enum rc_proto *protocol,
180  			      u32 *scancode, u8 *toggle)
181  {
182  	int rc;
183  	unsigned char buf[4];
184  
185  	/* poll IR chip */
186  	rc = i2c_master_recv(ir->c, buf, 4);
187  	if (rc != 4) {
188  		dev_dbg(&ir->rc->dev, "read error\n");
189  		if (rc < 0)
190  			return rc;
191  		return -EIO;
192  	}
193  
194  	if (buf[0] != 0 || buf[1] != 0 || buf[2] != 0 || buf[3] != 0)
195  		dev_dbg(&ir->rc->dev, "%s: %*ph\n", __func__, 4, buf);
196  
197  	/* no key pressed or signal from other ir remote */
198  	if(buf[0] != 0x1 ||  buf[1] != 0xfe)
199  		return 0;
200  
201  	*protocol = RC_PROTO_UNKNOWN;
202  	*scancode = buf[2];
203  	*toggle = 0;
204  	return 1;
205  }
206  
get_key_knc1(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)207  static int get_key_knc1(struct IR_i2c *ir, enum rc_proto *protocol,
208  			u32 *scancode, u8 *toggle)
209  {
210  	int rc;
211  	unsigned char b;
212  
213  	/* poll IR chip */
214  	rc = i2c_master_recv(ir->c, &b, 1);
215  	if (rc != 1) {
216  		dev_dbg(&ir->rc->dev, "read error\n");
217  		if (rc < 0)
218  			return rc;
219  		return -EIO;
220  	}
221  
222  	/* it seems that 0xFE indicates that a button is still hold
223  	   down, while 0xff indicates that no button is hold
224  	   down. 0xfe sequences are sometimes interrupted by 0xFF */
225  
226  	dev_dbg(&ir->rc->dev, "key %02x\n", b);
227  
228  	if (b == 0xff)
229  		return 0;
230  
231  	if (b == 0xfe)
232  		/* keep old data */
233  		return 1;
234  
235  	*protocol = RC_PROTO_UNKNOWN;
236  	*scancode = b;
237  	*toggle = 0;
238  	return 1;
239  }
240  
get_key_geniatech(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)241  static int get_key_geniatech(struct IR_i2c *ir, enum rc_proto *protocol,
242  			     u32 *scancode, u8 *toggle)
243  {
244  	int i, rc;
245  	unsigned char b;
246  
247  	/* poll IR chip */
248  	for (i = 0; i < 4; i++) {
249  		rc = i2c_master_recv(ir->c, &b, 1);
250  		if (rc == 1)
251  			break;
252  		msleep(20);
253  	}
254  	if (rc != 1) {
255  		dev_dbg(&ir->rc->dev, "read error\n");
256  		if (rc < 0)
257  			return rc;
258  		return -EIO;
259  	}
260  
261  	/* don't repeat the key */
262  	if (ir->old == b)
263  		return 0;
264  	ir->old = b;
265  
266  	/* decode to RC5 */
267  	b &= 0x7f;
268  	b = (b - 1) / 2;
269  
270  	dev_dbg(&ir->rc->dev, "key %02x\n", b);
271  
272  	*protocol = RC_PROTO_RC5;
273  	*scancode = b;
274  	*toggle = ir->old >> 7;
275  	return 1;
276  }
277  
get_key_avermedia_cardbus(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)278  static int get_key_avermedia_cardbus(struct IR_i2c *ir, enum rc_proto *protocol,
279  				     u32 *scancode, u8 *toggle)
280  {
281  	unsigned char subaddr, key, keygroup;
282  	struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0,
283  				   .buf = &subaddr, .len = 1},
284  				 { .addr = ir->c->addr, .flags = I2C_M_RD,
285  				  .buf = &key, .len = 1} };
286  	subaddr = 0x0d;
287  	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
288  		dev_dbg(&ir->rc->dev, "read error\n");
289  		return -EIO;
290  	}
291  
292  	if (key == 0xff)
293  		return 0;
294  
295  	subaddr = 0x0b;
296  	msg[1].buf = &keygroup;
297  	if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
298  		dev_dbg(&ir->rc->dev, "read error\n");
299  		return -EIO;
300  	}
301  
302  	if (keygroup == 0xff)
303  		return 0;
304  
305  	dev_dbg(&ir->rc->dev, "read key 0x%02x/0x%02x\n", key, keygroup);
306  	if (keygroup < 2 || keygroup > 4) {
307  		dev_warn(&ir->rc->dev, "warning: invalid key group 0x%02x for key 0x%02x\n",
308  			 keygroup, key);
309  	}
310  	key |= (keygroup & 1) << 6;
311  
312  	*protocol = RC_PROTO_UNKNOWN;
313  	*scancode = key;
314  	if (ir->c->addr == 0x41) /* AVerMedia EM78P153 */
315  		*scancode |= keygroup << 8;
316  	*toggle = 0;
317  	return 1;
318  }
319  
320  /* ----------------------------------------------------------------------- */
321  
ir_key_poll(struct IR_i2c * ir)322  static int ir_key_poll(struct IR_i2c *ir)
323  {
324  	enum rc_proto protocol;
325  	u32 scancode;
326  	u8 toggle;
327  	int rc;
328  
329  	dev_dbg(&ir->rc->dev, "%s\n", __func__);
330  	rc = ir->get_key(ir, &protocol, &scancode, &toggle);
331  	if (rc < 0) {
332  		dev_warn(&ir->rc->dev, "error %d\n", rc);
333  		return rc;
334  	}
335  
336  	if (rc) {
337  		dev_dbg(&ir->rc->dev, "%s: proto = 0x%04x, scancode = 0x%08x\n",
338  			__func__, protocol, scancode);
339  		rc_keydown(ir->rc, protocol, scancode, toggle);
340  	}
341  	return 0;
342  }
343  
ir_work(struct work_struct * work)344  static void ir_work(struct work_struct *work)
345  {
346  	int rc;
347  	struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work);
348  
349  	/*
350  	 * If the transmit code is holding the lock, skip polling for
351  	 * IR, we'll get it to it next time round
352  	 */
353  	if (mutex_trylock(&ir->lock)) {
354  		rc = ir_key_poll(ir);
355  		mutex_unlock(&ir->lock);
356  		if (rc == -ENODEV) {
357  			rc_unregister_device(ir->rc);
358  			ir->rc = NULL;
359  			return;
360  		}
361  	}
362  
363  	schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling_interval));
364  }
365  
ir_open(struct rc_dev * dev)366  static int ir_open(struct rc_dev *dev)
367  {
368  	struct IR_i2c *ir = dev->priv;
369  
370  	schedule_delayed_work(&ir->work, 0);
371  
372  	return 0;
373  }
374  
ir_close(struct rc_dev * dev)375  static void ir_close(struct rc_dev *dev)
376  {
377  	struct IR_i2c *ir = dev->priv;
378  
379  	cancel_delayed_work_sync(&ir->work);
380  }
381  
382  /* Zilog Transmit Interface */
383  #define XTAL_FREQ		18432000
384  
385  #define ZILOG_SEND		0x80
386  #define ZILOG_UIR_END		0x40
387  #define ZILOG_INIT_END		0x20
388  #define ZILOG_LIR_END		0x10
389  
390  #define ZILOG_STATUS_OK		0x80
391  #define ZILOG_STATUS_TX		0x40
392  #define ZILOG_STATUS_SET	0x20
393  
394  /*
395   * As you can see here, very few different lengths of pulse and space
396   * can be encoded. This means that the hardware does not work well with
397   * recorded IR. It's best to work with generated IR, like from ir-ctl or
398   * the in-kernel encoders.
399   */
400  struct code_block {
401  	u8	length;
402  	u16	pulse[7];	/* not aligned */
403  	u8	carrier_pulse;
404  	u8	carrier_space;
405  	u16	space[8];	/* not aligned */
406  	u8	codes[61];
407  	u8	csum[2];
408  } __packed;
409  
send_data_block(struct IR_i2c * ir,int cmd,struct code_block * code_block)410  static int send_data_block(struct IR_i2c *ir, int cmd,
411  			   struct code_block *code_block)
412  {
413  	int i, j, ret;
414  	u8 buf[5], *p;
415  
416  	p = &code_block->length;
417  	for (i = 0; p < code_block->csum; i++)
418  		code_block->csum[i & 1] ^= *p++;
419  
420  	p = &code_block->length;
421  
422  	for (i = 0; i < sizeof(*code_block);) {
423  		int tosend = sizeof(*code_block) - i;
424  
425  		if (tosend > 4)
426  			tosend = 4;
427  		buf[0] = i + 1;
428  		for (j = 0; j < tosend; ++j)
429  			buf[1 + j] = p[i + j];
430  		dev_dbg(&ir->rc->dev, "%*ph", tosend + 1, buf);
431  		ret = i2c_master_send(ir->tx_c, buf, tosend + 1);
432  		if (ret != tosend + 1) {
433  			dev_dbg(&ir->rc->dev,
434  				"i2c_master_send failed with %d\n", ret);
435  			return ret < 0 ? ret : -EIO;
436  		}
437  		i += tosend;
438  	}
439  
440  	buf[0] = 0;
441  	buf[1] = cmd;
442  	ret = i2c_master_send(ir->tx_c, buf, 2);
443  	if (ret != 2) {
444  		dev_err(&ir->rc->dev, "i2c_master_send failed with %d\n", ret);
445  		return ret < 0 ? ret : -EIO;
446  	}
447  
448  	usleep_range(2000, 5000);
449  
450  	ret = i2c_master_send(ir->tx_c, buf, 1);
451  	if (ret != 1) {
452  		dev_err(&ir->rc->dev, "i2c_master_send failed with %d\n", ret);
453  		return ret < 0 ? ret : -EIO;
454  	}
455  
456  	return 0;
457  }
458  
zilog_init(struct IR_i2c * ir)459  static int zilog_init(struct IR_i2c *ir)
460  {
461  	struct code_block code_block = { .length = sizeof(code_block) };
462  	u8 buf[4];
463  	int ret;
464  
465  	put_unaligned_be16(0x1000, &code_block.pulse[3]);
466  
467  	ret = send_data_block(ir, ZILOG_INIT_END, &code_block);
468  	if (ret)
469  		return ret;
470  
471  	ret = i2c_master_recv(ir->tx_c, buf, 4);
472  	if (ret != 4) {
473  		dev_err(&ir->c->dev, "failed to retrieve firmware version: %d\n",
474  			ret);
475  		return ret < 0 ? ret : -EIO;
476  	}
477  
478  	dev_info(&ir->c->dev, "Zilog/Hauppauge IR blaster firmware version %d.%d.%d\n",
479  		 buf[1], buf[2], buf[3]);
480  
481  	return 0;
482  }
483  
484  /*
485   * If the last slot for pulse is the same as the current slot for pulse,
486   * then use slot no 7.
487   */
copy_codes(u8 * dst,u8 * src,unsigned int count)488  static void copy_codes(u8 *dst, u8 *src, unsigned int count)
489  {
490  	u8 c, last = 0xff;
491  
492  	while (count--) {
493  		c = *src++;
494  		if ((c & 0xf0) == last) {
495  			*dst++ = 0x70 | (c & 0xf);
496  		} else {
497  			*dst++ = c;
498  			last = c & 0xf0;
499  		}
500  	}
501  }
502  
503  /*
504   * When looking for repeats, we don't care about the trailing space. This
505   * is set to the shortest possible anyway.
506   */
cmp_no_trail(u8 * a,u8 * b,unsigned int count)507  static int cmp_no_trail(u8 *a, u8 *b, unsigned int count)
508  {
509  	while (--count) {
510  		if (*a++ != *b++)
511  			return 1;
512  	}
513  
514  	return (*a & 0xf0) - (*b & 0xf0);
515  }
516  
find_slot(u16 * array,unsigned int size,u16 val)517  static int find_slot(u16 *array, unsigned int size, u16 val)
518  {
519  	int i;
520  
521  	for (i = 0; i < size; i++) {
522  		if (get_unaligned_be16(&array[i]) == val) {
523  			return i;
524  		} else if (!array[i]) {
525  			put_unaligned_be16(val, &array[i]);
526  			return i;
527  		}
528  	}
529  
530  	return -1;
531  }
532  
zilog_ir_format(struct rc_dev * rcdev,unsigned int * txbuf,unsigned int count,struct code_block * code_block)533  static int zilog_ir_format(struct rc_dev *rcdev, unsigned int *txbuf,
534  			   unsigned int count, struct code_block *code_block)
535  {
536  	struct IR_i2c *ir = rcdev->priv;
537  	int rep, i, l, p = 0, s, c = 0;
538  	bool repeating;
539  	u8 codes[174];
540  
541  	code_block->carrier_pulse = DIV_ROUND_CLOSEST(
542  			ir->duty_cycle * XTAL_FREQ / 1000, ir->carrier);
543  	code_block->carrier_space = DIV_ROUND_CLOSEST(
544  			(100 - ir->duty_cycle) * XTAL_FREQ / 1000, ir->carrier);
545  
546  	for (i = 0; i < count; i++) {
547  		if (c >= ARRAY_SIZE(codes) - 1) {
548  			dev_warn(&rcdev->dev, "IR too long, cannot transmit\n");
549  			return -EINVAL;
550  		}
551  
552  		/*
553  		 * Lengths more than 142220us cannot be encoded; also
554  		 * this checks for multiply overflow
555  		 */
556  		if (txbuf[i] > 142220)
557  			return -EINVAL;
558  
559  		l = DIV_ROUND_CLOSEST((XTAL_FREQ / 1000) * txbuf[i], 40000);
560  
561  		if (i & 1) {
562  			s = find_slot(code_block->space,
563  				      ARRAY_SIZE(code_block->space), l);
564  			if (s == -1) {
565  				dev_warn(&rcdev->dev, "Too many different lengths spaces, cannot transmit");
566  				return -EINVAL;
567  			}
568  
569  			/* We have a pulse and space */
570  			codes[c++] = (p << 4) | s;
571  		} else {
572  			p = find_slot(code_block->pulse,
573  				      ARRAY_SIZE(code_block->pulse), l);
574  			if (p == -1) {
575  				dev_warn(&rcdev->dev, "Too many different lengths pulses, cannot transmit");
576  				return -EINVAL;
577  			}
578  		}
579  	}
580  
581  	/* We have to encode the trailing pulse. Find the shortest space */
582  	s = 0;
583  	for (i = 1; i < ARRAY_SIZE(code_block->space); i++) {
584  		u16 d = get_unaligned_be16(&code_block->space[i]);
585  
586  		if (get_unaligned_be16(&code_block->space[s]) > d)
587  			s = i;
588  	}
589  
590  	codes[c++] = (p << 4) | s;
591  
592  	dev_dbg(&rcdev->dev, "generated %d codes\n", c);
593  
594  	/*
595  	 * Are the last N codes (so pulse + space) repeating 3 times?
596  	 * if so we can shorten the codes list and use code 0xc0 to repeat
597  	 * them.
598  	 */
599  	repeating = false;
600  
601  	for (rep = c / 3; rep >= 1; rep--) {
602  		if (!memcmp(&codes[c - rep * 3], &codes[c - rep * 2], rep) &&
603  		    !cmp_no_trail(&codes[c - rep], &codes[c - rep * 2], rep)) {
604  			repeating = true;
605  			break;
606  		}
607  	}
608  
609  	if (repeating) {
610  		/* first copy any leading non-repeating */
611  		int leading = c - rep * 3;
612  
613  		if (leading >= ARRAY_SIZE(code_block->codes) - 3 - rep) {
614  			dev_warn(&rcdev->dev, "IR too long, cannot transmit\n");
615  			return -EINVAL;
616  		}
617  
618  		dev_dbg(&rcdev->dev, "found trailing %d repeat\n", rep);
619  		copy_codes(code_block->codes, codes, leading);
620  		code_block->codes[leading] = 0x82;
621  		copy_codes(code_block->codes + leading + 1, codes + leading,
622  			   rep);
623  		c = leading + 1 + rep;
624  		code_block->codes[c++] = 0xc0;
625  	} else {
626  		if (c >= ARRAY_SIZE(code_block->codes) - 3) {
627  			dev_warn(&rcdev->dev, "IR too long, cannot transmit\n");
628  			return -EINVAL;
629  		}
630  
631  		dev_dbg(&rcdev->dev, "found no trailing repeat\n");
632  		code_block->codes[0] = 0x82;
633  		copy_codes(code_block->codes + 1, codes, c);
634  		c++;
635  		code_block->codes[c++] = 0xc4;
636  	}
637  
638  	while (c < ARRAY_SIZE(code_block->codes))
639  		code_block->codes[c++] = 0x83;
640  
641  	return 0;
642  }
643  
zilog_tx(struct rc_dev * rcdev,unsigned int * txbuf,unsigned int count)644  static int zilog_tx(struct rc_dev *rcdev, unsigned int *txbuf,
645  		    unsigned int count)
646  {
647  	struct IR_i2c *ir = rcdev->priv;
648  	struct code_block code_block = { .length = sizeof(code_block) };
649  	u8 buf[2];
650  	int ret, i;
651  
652  	ret = zilog_ir_format(rcdev, txbuf, count, &code_block);
653  	if (ret)
654  		return ret;
655  
656  	ret = mutex_lock_interruptible(&ir->lock);
657  	if (ret)
658  		return ret;
659  
660  	ret = send_data_block(ir, ZILOG_UIR_END, &code_block);
661  	if (ret)
662  		goto out_unlock;
663  
664  	ret = i2c_master_recv(ir->tx_c, buf, 1);
665  	if (ret != 1) {
666  		dev_err(&ir->rc->dev, "i2c_master_recv failed with %d\n", ret);
667  		goto out_unlock;
668  	}
669  
670  	dev_dbg(&ir->rc->dev, "code set status: %02x\n", buf[0]);
671  
672  	if (buf[0] != (ZILOG_STATUS_OK | ZILOG_STATUS_SET)) {
673  		dev_err(&ir->rc->dev, "unexpected IR TX response %02x\n",
674  			buf[0]);
675  		ret = -EIO;
676  		goto out_unlock;
677  	}
678  
679  	buf[0] = 0x00;
680  	buf[1] = ZILOG_SEND;
681  
682  	ret = i2c_master_send(ir->tx_c, buf, 2);
683  	if (ret != 2) {
684  		dev_err(&ir->rc->dev, "i2c_master_send failed with %d\n", ret);
685  		if (ret >= 0)
686  			ret = -EIO;
687  		goto out_unlock;
688  	}
689  
690  	dev_dbg(&ir->rc->dev, "send command sent\n");
691  
692  	/*
693  	 * This bit NAKs until the device is ready, so we retry it
694  	 * sleeping a bit each time.  This seems to be what the windows
695  	 * driver does, approximately.
696  	 * Try for up to 1s.
697  	 */
698  	for (i = 0; i < 20; ++i) {
699  		set_current_state(TASK_UNINTERRUPTIBLE);
700  		schedule_timeout(msecs_to_jiffies(50));
701  		ret = i2c_master_send(ir->tx_c, buf, 1);
702  		if (ret == 1)
703  			break;
704  		dev_dbg(&ir->rc->dev,
705  			"NAK expected: i2c_master_send failed with %d (try %d)\n",
706  			ret, i + 1);
707  	}
708  
709  	if (ret != 1) {
710  		dev_err(&ir->rc->dev,
711  			"IR TX chip never got ready: last i2c_master_send failed with %d\n",
712  			ret);
713  		if (ret >= 0)
714  			ret = -EIO;
715  		goto out_unlock;
716  	}
717  
718  	ret = i2c_master_recv(ir->tx_c, buf, 1);
719  	if (ret != 1) {
720  		dev_err(&ir->rc->dev, "i2c_master_recv failed with %d\n", ret);
721  		ret = -EIO;
722  		goto out_unlock;
723  	} else if (buf[0] != ZILOG_STATUS_OK) {
724  		dev_err(&ir->rc->dev, "unexpected IR TX response #2: %02x\n",
725  			buf[0]);
726  		ret = -EIO;
727  		goto out_unlock;
728  	}
729  	dev_dbg(&ir->rc->dev, "transmit complete\n");
730  
731  	/* Oh good, it worked */
732  	ret = count;
733  out_unlock:
734  	mutex_unlock(&ir->lock);
735  
736  	return ret;
737  }
738  
zilog_tx_carrier(struct rc_dev * dev,u32 carrier)739  static int zilog_tx_carrier(struct rc_dev *dev, u32 carrier)
740  {
741  	struct IR_i2c *ir = dev->priv;
742  
743  	if (carrier > 500000 || carrier < 20000)
744  		return -EINVAL;
745  
746  	ir->carrier = carrier;
747  
748  	return 0;
749  }
750  
zilog_tx_duty_cycle(struct rc_dev * dev,u32 duty_cycle)751  static int zilog_tx_duty_cycle(struct rc_dev *dev, u32 duty_cycle)
752  {
753  	struct IR_i2c *ir = dev->priv;
754  
755  	ir->duty_cycle = duty_cycle;
756  
757  	return 0;
758  }
759  
ir_probe(struct i2c_client * client)760  static int ir_probe(struct i2c_client *client)
761  {
762  	const struct i2c_device_id *id = i2c_client_get_device_id(client);
763  	char *ir_codes = NULL;
764  	const char *name = NULL;
765  	u64 rc_proto = RC_PROTO_BIT_UNKNOWN;
766  	struct IR_i2c *ir;
767  	struct rc_dev *rc = NULL;
768  	struct i2c_adapter *adap = client->adapter;
769  	unsigned short addr = client->addr;
770  	bool probe_tx = (id->driver_data & FLAG_TX) != 0;
771  	int err;
772  
773  	if ((id->driver_data & FLAG_HDPVR) && !enable_hdpvr) {
774  		dev_err(&client->dev, "IR for HDPVR is known to cause problems during recording, use enable_hdpvr modparam to enable\n");
775  		return -ENODEV;
776  	}
777  
778  	ir = devm_kzalloc(&client->dev, sizeof(*ir), GFP_KERNEL);
779  	if (!ir)
780  		return -ENOMEM;
781  
782  	ir->c = client;
783  	ir->polling_interval = DEFAULT_POLLING_INTERVAL;
784  	i2c_set_clientdata(client, ir);
785  
786  	switch(addr) {
787  	case 0x64:
788  		name        = "Pixelview";
789  		ir->get_key = get_key_pixelview;
790  		rc_proto    = RC_PROTO_BIT_OTHER;
791  		ir_codes    = RC_MAP_EMPTY;
792  		break;
793  	case 0x18:
794  	case 0x1f:
795  	case 0x1a:
796  		name        = "Hauppauge";
797  		ir->get_key = get_key_haup;
798  		rc_proto    = RC_PROTO_BIT_RC5;
799  		ir_codes    = RC_MAP_HAUPPAUGE;
800  		break;
801  	case 0x30:
802  		name        = "KNC One";
803  		ir->get_key = get_key_knc1;
804  		rc_proto    = RC_PROTO_BIT_OTHER;
805  		ir_codes    = RC_MAP_EMPTY;
806  		break;
807  	case 0x33:
808  		name        = "Geniatech";
809  		ir->get_key = get_key_geniatech;
810  		rc_proto    = RC_PROTO_BIT_RC5;
811  		ir_codes    = RC_MAP_TOTAL_MEDIA_IN_HAND_02;
812  		ir->old     = 0xfc;
813  		break;
814  	case 0x6b:
815  		name        = "FusionHDTV";
816  		ir->get_key = get_key_fusionhdtv;
817  		rc_proto    = RC_PROTO_BIT_UNKNOWN;
818  		ir_codes    = RC_MAP_FUSIONHDTV_MCE;
819  		break;
820  	case 0x40:
821  		name        = "AVerMedia Cardbus remote";
822  		ir->get_key = get_key_avermedia_cardbus;
823  		rc_proto    = RC_PROTO_BIT_OTHER;
824  		ir_codes    = RC_MAP_AVERMEDIA_CARDBUS;
825  		break;
826  	case 0x41:
827  		name        = "AVerMedia EM78P153";
828  		ir->get_key = get_key_avermedia_cardbus;
829  		rc_proto    = RC_PROTO_BIT_OTHER;
830  		/* RM-KV remote, seems to be same as RM-K6 */
831  		ir_codes    = RC_MAP_AVERMEDIA_M733A_RM_K6;
832  		break;
833  	case 0x71:
834  		name        = "Hauppauge/Zilog Z8";
835  		ir->get_key = get_key_haup_xvr;
836  		rc_proto    = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE |
837  							RC_PROTO_BIT_RC6_6A_32;
838  		ir_codes    = RC_MAP_HAUPPAUGE;
839  		ir->polling_interval = 125;
840  		probe_tx = true;
841  		break;
842  	}
843  
844  	/* Let the caller override settings */
845  	if (client->dev.platform_data) {
846  		const struct IR_i2c_init_data *init_data =
847  						client->dev.platform_data;
848  
849  		ir_codes = init_data->ir_codes;
850  		rc = init_data->rc_dev;
851  
852  		name = init_data->name;
853  		if (init_data->type)
854  			rc_proto = init_data->type;
855  
856  		if (init_data->polling_interval)
857  			ir->polling_interval = init_data->polling_interval;
858  
859  		switch (init_data->internal_get_key_func) {
860  		case IR_KBD_GET_KEY_CUSTOM:
861  			/* The bridge driver provided us its own function */
862  			ir->get_key = init_data->get_key;
863  			break;
864  		case IR_KBD_GET_KEY_PIXELVIEW:
865  			ir->get_key = get_key_pixelview;
866  			break;
867  		case IR_KBD_GET_KEY_HAUP:
868  			ir->get_key = get_key_haup;
869  			break;
870  		case IR_KBD_GET_KEY_KNC1:
871  			ir->get_key = get_key_knc1;
872  			break;
873  		case IR_KBD_GET_KEY_GENIATECH:
874  			ir->get_key = get_key_geniatech;
875  			break;
876  		case IR_KBD_GET_KEY_FUSIONHDTV:
877  			ir->get_key = get_key_fusionhdtv;
878  			break;
879  		case IR_KBD_GET_KEY_HAUP_XVR:
880  			ir->get_key = get_key_haup_xvr;
881  			break;
882  		case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS:
883  			ir->get_key = get_key_avermedia_cardbus;
884  			break;
885  		}
886  	}
887  
888  	if (!rc) {
889  		/*
890  		 * If platform_data doesn't specify rc_dev, initialize it
891  		 * internally
892  		 */
893  		rc = rc_allocate_device(RC_DRIVER_SCANCODE);
894  		if (!rc)
895  			return -ENOMEM;
896  	}
897  	ir->rc = rc;
898  
899  	/* Make sure we are all setup before going on */
900  	if (!name || !ir->get_key || !rc_proto || !ir_codes) {
901  		dev_warn(&client->dev, "Unsupported device at address 0x%02x\n",
902  			 addr);
903  		err = -ENODEV;
904  		goto err_out_free;
905  	}
906  
907  	ir->ir_codes = ir_codes;
908  
909  	snprintf(ir->phys, sizeof(ir->phys), "%s/%s", dev_name(&adap->dev),
910  		 dev_name(&client->dev));
911  
912  	/*
913  	 * Initialize input_dev fields
914  	 * It doesn't make sense to allow overriding them via platform_data
915  	 */
916  	rc->input_id.bustype = BUS_I2C;
917  	rc->input_phys       = ir->phys;
918  	rc->device_name	     = name;
919  	rc->dev.parent       = &client->dev;
920  	rc->priv             = ir;
921  	rc->open             = ir_open;
922  	rc->close            = ir_close;
923  
924  	/*
925  	 * Initialize the other fields of rc_dev
926  	 */
927  	rc->map_name       = ir->ir_codes;
928  	rc->allowed_protocols = rc_proto;
929  	if (!rc->driver_name)
930  		rc->driver_name = KBUILD_MODNAME;
931  
932  	mutex_init(&ir->lock);
933  
934  	INIT_DELAYED_WORK(&ir->work, ir_work);
935  
936  	if (probe_tx) {
937  		ir->tx_c = i2c_new_dummy_device(client->adapter, 0x70);
938  		if (IS_ERR(ir->tx_c)) {
939  			dev_err(&client->dev, "failed to setup tx i2c address");
940  			err = PTR_ERR(ir->tx_c);
941  			goto err_out_free;
942  		} else if (!zilog_init(ir)) {
943  			ir->carrier = 38000;
944  			ir->duty_cycle = 40;
945  			rc->tx_ir = zilog_tx;
946  			rc->s_tx_carrier = zilog_tx_carrier;
947  			rc->s_tx_duty_cycle = zilog_tx_duty_cycle;
948  		}
949  	}
950  
951  	err = rc_register_device(rc);
952  	if (err)
953  		goto err_out_free;
954  
955  	return 0;
956  
957   err_out_free:
958  	if (!IS_ERR(ir->tx_c))
959  		i2c_unregister_device(ir->tx_c);
960  
961  	/* Only frees rc if it were allocated internally */
962  	rc_free_device(rc);
963  	return err;
964  }
965  
ir_remove(struct i2c_client * client)966  static void ir_remove(struct i2c_client *client)
967  {
968  	struct IR_i2c *ir = i2c_get_clientdata(client);
969  
970  	cancel_delayed_work_sync(&ir->work);
971  
972  	i2c_unregister_device(ir->tx_c);
973  
974  	rc_unregister_device(ir->rc);
975  }
976  
977  static const struct i2c_device_id ir_kbd_id[] = {
978  	/* Generic entry for any IR receiver */
979  	{ "ir_video", 0 },
980  	/* IR device specific entries should be added here */
981  	{ "ir_z8f0811_haup", FLAG_TX },
982  	{ "ir_z8f0811_hdpvr", FLAG_TX | FLAG_HDPVR },
983  	{ }
984  };
985  MODULE_DEVICE_TABLE(i2c, ir_kbd_id);
986  
987  static struct i2c_driver ir_kbd_driver = {
988  	.driver = {
989  		.name   = "ir-kbd-i2c",
990  	},
991  	.probe          = ir_probe,
992  	.remove         = ir_remove,
993  	.id_table       = ir_kbd_id,
994  };
995  
996  module_i2c_driver(ir_kbd_driver);
997  
998  /* ----------------------------------------------------------------------- */
999  
1000  MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
1001  MODULE_DESCRIPTION("input driver for i2c IR remote controls");
1002  MODULE_LICENSE("GPL");
1003