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 <asm/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_avermedia_cardbus(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)241 static int get_key_avermedia_cardbus(struct IR_i2c *ir, enum rc_proto *protocol,
242 u32 *scancode, u8 *toggle)
243 {
244 unsigned char subaddr, key, keygroup;
245 struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0,
246 .buf = &subaddr, .len = 1},
247 { .addr = ir->c->addr, .flags = I2C_M_RD,
248 .buf = &key, .len = 1} };
249 subaddr = 0x0d;
250 if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
251 dev_dbg(&ir->rc->dev, "read error\n");
252 return -EIO;
253 }
254
255 if (key == 0xff)
256 return 0;
257
258 subaddr = 0x0b;
259 msg[1].buf = &keygroup;
260 if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
261 dev_dbg(&ir->rc->dev, "read error\n");
262 return -EIO;
263 }
264
265 if (keygroup == 0xff)
266 return 0;
267
268 dev_dbg(&ir->rc->dev, "read key 0x%02x/0x%02x\n", key, keygroup);
269 if (keygroup < 2 || keygroup > 4) {
270 dev_warn(&ir->rc->dev, "warning: invalid key group 0x%02x for key 0x%02x\n",
271 keygroup, key);
272 }
273 key |= (keygroup & 1) << 6;
274
275 *protocol = RC_PROTO_UNKNOWN;
276 *scancode = key;
277 if (ir->c->addr == 0x41) /* AVerMedia EM78P153 */
278 *scancode |= keygroup << 8;
279 *toggle = 0;
280 return 1;
281 }
282
283 /* ----------------------------------------------------------------------- */
284
ir_key_poll(struct IR_i2c * ir)285 static int ir_key_poll(struct IR_i2c *ir)
286 {
287 enum rc_proto protocol;
288 u32 scancode;
289 u8 toggle;
290 int rc;
291
292 dev_dbg(&ir->rc->dev, "%s\n", __func__);
293 rc = ir->get_key(ir, &protocol, &scancode, &toggle);
294 if (rc < 0) {
295 dev_warn(&ir->rc->dev, "error %d\n", rc);
296 return rc;
297 }
298
299 if (rc) {
300 dev_dbg(&ir->rc->dev, "%s: proto = 0x%04x, scancode = 0x%08x\n",
301 __func__, protocol, scancode);
302 rc_keydown(ir->rc, protocol, scancode, toggle);
303 }
304 return 0;
305 }
306
ir_work(struct work_struct * work)307 static void ir_work(struct work_struct *work)
308 {
309 int rc;
310 struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work);
311
312 /*
313 * If the transmit code is holding the lock, skip polling for
314 * IR, we'll get it to it next time round
315 */
316 if (mutex_trylock(&ir->lock)) {
317 rc = ir_key_poll(ir);
318 mutex_unlock(&ir->lock);
319 if (rc == -ENODEV) {
320 rc_unregister_device(ir->rc);
321 ir->rc = NULL;
322 return;
323 }
324 }
325
326 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling_interval));
327 }
328
ir_open(struct rc_dev * dev)329 static int ir_open(struct rc_dev *dev)
330 {
331 struct IR_i2c *ir = dev->priv;
332
333 schedule_delayed_work(&ir->work, 0);
334
335 return 0;
336 }
337
ir_close(struct rc_dev * dev)338 static void ir_close(struct rc_dev *dev)
339 {
340 struct IR_i2c *ir = dev->priv;
341
342 cancel_delayed_work_sync(&ir->work);
343 }
344
345 /* Zilog Transmit Interface */
346 #define XTAL_FREQ 18432000
347
348 #define ZILOG_SEND 0x80
349 #define ZILOG_UIR_END 0x40
350 #define ZILOG_INIT_END 0x20
351 #define ZILOG_LIR_END 0x10
352
353 #define ZILOG_STATUS_OK 0x80
354 #define ZILOG_STATUS_TX 0x40
355 #define ZILOG_STATUS_SET 0x20
356
357 /*
358 * As you can see here, very few different lengths of pulse and space
359 * can be encoded. This means that the hardware does not work well with
360 * recorded IR. It's best to work with generated IR, like from ir-ctl or
361 * the in-kernel encoders.
362 */
363 struct code_block {
364 u8 length;
365 u16 pulse[7]; /* not aligned */
366 u8 carrier_pulse;
367 u8 carrier_space;
368 u16 space[8]; /* not aligned */
369 u8 codes[61];
370 u8 csum[2];
371 } __packed;
372
send_data_block(struct IR_i2c * ir,int cmd,struct code_block * code_block)373 static int send_data_block(struct IR_i2c *ir, int cmd,
374 struct code_block *code_block)
375 {
376 int i, j, ret;
377 u8 buf[5], *p;
378
379 p = &code_block->length;
380 for (i = 0; p < code_block->csum; i++)
381 code_block->csum[i & 1] ^= *p++;
382
383 p = &code_block->length;
384
385 for (i = 0; i < sizeof(*code_block);) {
386 int tosend = sizeof(*code_block) - i;
387
388 if (tosend > 4)
389 tosend = 4;
390 buf[0] = i + 1;
391 for (j = 0; j < tosend; ++j)
392 buf[1 + j] = p[i + j];
393 dev_dbg(&ir->rc->dev, "%*ph", tosend + 1, buf);
394 ret = i2c_master_send(ir->tx_c, buf, tosend + 1);
395 if (ret != tosend + 1) {
396 dev_dbg(&ir->rc->dev,
397 "i2c_master_send failed with %d\n", ret);
398 return ret < 0 ? ret : -EIO;
399 }
400 i += tosend;
401 }
402
403 buf[0] = 0;
404 buf[1] = cmd;
405 ret = i2c_master_send(ir->tx_c, buf, 2);
406 if (ret != 2) {
407 dev_err(&ir->rc->dev, "i2c_master_send failed with %d\n", ret);
408 return ret < 0 ? ret : -EIO;
409 }
410
411 usleep_range(2000, 5000);
412
413 ret = i2c_master_send(ir->tx_c, buf, 1);
414 if (ret != 1) {
415 dev_err(&ir->rc->dev, "i2c_master_send failed with %d\n", ret);
416 return ret < 0 ? ret : -EIO;
417 }
418
419 return 0;
420 }
421
zilog_init(struct IR_i2c * ir)422 static int zilog_init(struct IR_i2c *ir)
423 {
424 struct code_block code_block = { .length = sizeof(code_block) };
425 u8 buf[4];
426 int ret;
427
428 put_unaligned_be16(0x1000, &code_block.pulse[3]);
429
430 ret = send_data_block(ir, ZILOG_INIT_END, &code_block);
431 if (ret)
432 return ret;
433
434 ret = i2c_master_recv(ir->tx_c, buf, 4);
435 if (ret != 4) {
436 dev_err(&ir->c->dev, "failed to retrieve firmware version: %d\n",
437 ret);
438 return ret < 0 ? ret : -EIO;
439 }
440
441 dev_info(&ir->c->dev, "Zilog/Hauppauge IR blaster firmware version %d.%d.%d\n",
442 buf[1], buf[2], buf[3]);
443
444 return 0;
445 }
446
447 /*
448 * If the last slot for pulse is the same as the current slot for pulse,
449 * then use slot no 7.
450 */
copy_codes(u8 * dst,u8 * src,unsigned int count)451 static void copy_codes(u8 *dst, u8 *src, unsigned int count)
452 {
453 u8 c, last = 0xff;
454
455 while (count--) {
456 c = *src++;
457 if ((c & 0xf0) == last) {
458 *dst++ = 0x70 | (c & 0xf);
459 } else {
460 *dst++ = c;
461 last = c & 0xf0;
462 }
463 }
464 }
465
466 /*
467 * When looking for repeats, we don't care about the trailing space. This
468 * is set to the shortest possible anyway.
469 */
cmp_no_trail(u8 * a,u8 * b,unsigned int count)470 static int cmp_no_trail(u8 *a, u8 *b, unsigned int count)
471 {
472 while (--count) {
473 if (*a++ != *b++)
474 return 1;
475 }
476
477 return (*a & 0xf0) - (*b & 0xf0);
478 }
479
find_slot(u16 * array,unsigned int size,u16 val)480 static int find_slot(u16 *array, unsigned int size, u16 val)
481 {
482 int i;
483
484 for (i = 0; i < size; i++) {
485 if (get_unaligned_be16(&array[i]) == val) {
486 return i;
487 } else if (!array[i]) {
488 put_unaligned_be16(val, &array[i]);
489 return i;
490 }
491 }
492
493 return -1;
494 }
495
zilog_ir_format(struct rc_dev * rcdev,unsigned int * txbuf,unsigned int count,struct code_block * code_block)496 static int zilog_ir_format(struct rc_dev *rcdev, unsigned int *txbuf,
497 unsigned int count, struct code_block *code_block)
498 {
499 struct IR_i2c *ir = rcdev->priv;
500 int rep, i, l, p = 0, s, c = 0;
501 bool repeating;
502 u8 codes[174];
503
504 code_block->carrier_pulse = DIV_ROUND_CLOSEST(
505 ir->duty_cycle * XTAL_FREQ / 1000, ir->carrier);
506 code_block->carrier_space = DIV_ROUND_CLOSEST(
507 (100 - ir->duty_cycle) * XTAL_FREQ / 1000, ir->carrier);
508
509 for (i = 0; i < count; i++) {
510 if (c >= ARRAY_SIZE(codes) - 1) {
511 dev_warn(&rcdev->dev, "IR too long, cannot transmit\n");
512 return -EINVAL;
513 }
514
515 /*
516 * Lengths more than 142220us cannot be encoded; also
517 * this checks for multiply overflow
518 */
519 if (txbuf[i] > 142220)
520 return -EINVAL;
521
522 l = DIV_ROUND_CLOSEST((XTAL_FREQ / 1000) * txbuf[i], 40000);
523
524 if (i & 1) {
525 s = find_slot(code_block->space,
526 ARRAY_SIZE(code_block->space), l);
527 if (s == -1) {
528 dev_warn(&rcdev->dev, "Too many different lengths spaces, cannot transmit");
529 return -EINVAL;
530 }
531
532 /* We have a pulse and space */
533 codes[c++] = (p << 4) | s;
534 } else {
535 p = find_slot(code_block->pulse,
536 ARRAY_SIZE(code_block->pulse), l);
537 if (p == -1) {
538 dev_warn(&rcdev->dev, "Too many different lengths pulses, cannot transmit");
539 return -EINVAL;
540 }
541 }
542 }
543
544 /* We have to encode the trailing pulse. Find the shortest space */
545 s = 0;
546 for (i = 1; i < ARRAY_SIZE(code_block->space); i++) {
547 u16 d = get_unaligned_be16(&code_block->space[i]);
548
549 if (get_unaligned_be16(&code_block->space[s]) > d)
550 s = i;
551 }
552
553 codes[c++] = (p << 4) | s;
554
555 dev_dbg(&rcdev->dev, "generated %d codes\n", c);
556
557 /*
558 * Are the last N codes (so pulse + space) repeating 3 times?
559 * if so we can shorten the codes list and use code 0xc0 to repeat
560 * them.
561 */
562 repeating = false;
563
564 for (rep = c / 3; rep >= 1; rep--) {
565 if (!memcmp(&codes[c - rep * 3], &codes[c - rep * 2], rep) &&
566 !cmp_no_trail(&codes[c - rep], &codes[c - rep * 2], rep)) {
567 repeating = true;
568 break;
569 }
570 }
571
572 if (repeating) {
573 /* first copy any leading non-repeating */
574 int leading = c - rep * 3;
575
576 if (leading >= ARRAY_SIZE(code_block->codes) - 3 - rep) {
577 dev_warn(&rcdev->dev, "IR too long, cannot transmit\n");
578 return -EINVAL;
579 }
580
581 dev_dbg(&rcdev->dev, "found trailing %d repeat\n", rep);
582 copy_codes(code_block->codes, codes, leading);
583 code_block->codes[leading] = 0x82;
584 copy_codes(code_block->codes + leading + 1, codes + leading,
585 rep);
586 c = leading + 1 + rep;
587 code_block->codes[c++] = 0xc0;
588 } else {
589 if (c >= ARRAY_SIZE(code_block->codes) - 3) {
590 dev_warn(&rcdev->dev, "IR too long, cannot transmit\n");
591 return -EINVAL;
592 }
593
594 dev_dbg(&rcdev->dev, "found no trailing repeat\n");
595 code_block->codes[0] = 0x82;
596 copy_codes(code_block->codes + 1, codes, c);
597 c++;
598 code_block->codes[c++] = 0xc4;
599 }
600
601 while (c < ARRAY_SIZE(code_block->codes))
602 code_block->codes[c++] = 0x83;
603
604 return 0;
605 }
606
zilog_tx(struct rc_dev * rcdev,unsigned int * txbuf,unsigned int count)607 static int zilog_tx(struct rc_dev *rcdev, unsigned int *txbuf,
608 unsigned int count)
609 {
610 struct IR_i2c *ir = rcdev->priv;
611 struct code_block code_block = { .length = sizeof(code_block) };
612 u8 buf[2];
613 int ret, i;
614
615 ret = zilog_ir_format(rcdev, txbuf, count, &code_block);
616 if (ret)
617 return ret;
618
619 ret = mutex_lock_interruptible(&ir->lock);
620 if (ret)
621 return ret;
622
623 ret = send_data_block(ir, ZILOG_UIR_END, &code_block);
624 if (ret)
625 goto out_unlock;
626
627 ret = i2c_master_recv(ir->tx_c, buf, 1);
628 if (ret != 1) {
629 dev_err(&ir->rc->dev, "i2c_master_recv failed with %d\n", ret);
630 goto out_unlock;
631 }
632
633 dev_dbg(&ir->rc->dev, "code set status: %02x\n", buf[0]);
634
635 if (buf[0] != (ZILOG_STATUS_OK | ZILOG_STATUS_SET)) {
636 dev_err(&ir->rc->dev, "unexpected IR TX response %02x\n",
637 buf[0]);
638 ret = -EIO;
639 goto out_unlock;
640 }
641
642 buf[0] = 0x00;
643 buf[1] = ZILOG_SEND;
644
645 ret = i2c_master_send(ir->tx_c, buf, 2);
646 if (ret != 2) {
647 dev_err(&ir->rc->dev, "i2c_master_send failed with %d\n", ret);
648 if (ret >= 0)
649 ret = -EIO;
650 goto out_unlock;
651 }
652
653 dev_dbg(&ir->rc->dev, "send command sent\n");
654
655 /*
656 * This bit NAKs until the device is ready, so we retry it
657 * sleeping a bit each time. This seems to be what the windows
658 * driver does, approximately.
659 * Try for up to 1s.
660 */
661 for (i = 0; i < 20; ++i) {
662 set_current_state(TASK_UNINTERRUPTIBLE);
663 schedule_timeout(msecs_to_jiffies(50));
664 ret = i2c_master_send(ir->tx_c, buf, 1);
665 if (ret == 1)
666 break;
667 dev_dbg(&ir->rc->dev,
668 "NAK expected: i2c_master_send failed with %d (try %d)\n",
669 ret, i + 1);
670 }
671
672 if (ret != 1) {
673 dev_err(&ir->rc->dev,
674 "IR TX chip never got ready: last i2c_master_send failed with %d\n",
675 ret);
676 if (ret >= 0)
677 ret = -EIO;
678 goto out_unlock;
679 }
680
681 ret = i2c_master_recv(ir->tx_c, buf, 1);
682 if (ret != 1) {
683 dev_err(&ir->rc->dev, "i2c_master_recv failed with %d\n", ret);
684 ret = -EIO;
685 goto out_unlock;
686 } else if (buf[0] != ZILOG_STATUS_OK) {
687 dev_err(&ir->rc->dev, "unexpected IR TX response #2: %02x\n",
688 buf[0]);
689 ret = -EIO;
690 goto out_unlock;
691 }
692 dev_dbg(&ir->rc->dev, "transmit complete\n");
693
694 /* Oh good, it worked */
695 ret = count;
696 out_unlock:
697 mutex_unlock(&ir->lock);
698
699 return ret;
700 }
701
zilog_tx_carrier(struct rc_dev * dev,u32 carrier)702 static int zilog_tx_carrier(struct rc_dev *dev, u32 carrier)
703 {
704 struct IR_i2c *ir = dev->priv;
705
706 if (carrier > 500000 || carrier < 20000)
707 return -EINVAL;
708
709 ir->carrier = carrier;
710
711 return 0;
712 }
713
zilog_tx_duty_cycle(struct rc_dev * dev,u32 duty_cycle)714 static int zilog_tx_duty_cycle(struct rc_dev *dev, u32 duty_cycle)
715 {
716 struct IR_i2c *ir = dev->priv;
717
718 ir->duty_cycle = duty_cycle;
719
720 return 0;
721 }
722
ir_probe(struct i2c_client * client,const struct i2c_device_id * id)723 static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id)
724 {
725 char *ir_codes = NULL;
726 const char *name = NULL;
727 u64 rc_proto = RC_PROTO_BIT_UNKNOWN;
728 struct IR_i2c *ir;
729 struct rc_dev *rc = NULL;
730 struct i2c_adapter *adap = client->adapter;
731 unsigned short addr = client->addr;
732 bool probe_tx = (id->driver_data & FLAG_TX) != 0;
733 int err;
734
735 if ((id->driver_data & FLAG_HDPVR) && !enable_hdpvr) {
736 dev_err(&client->dev, "IR for HDPVR is known to cause problems during recording, use enable_hdpvr modparam to enable\n");
737 return -ENODEV;
738 }
739
740 ir = devm_kzalloc(&client->dev, sizeof(*ir), GFP_KERNEL);
741 if (!ir)
742 return -ENOMEM;
743
744 ir->c = client;
745 ir->polling_interval = DEFAULT_POLLING_INTERVAL;
746 i2c_set_clientdata(client, ir);
747
748 switch(addr) {
749 case 0x64:
750 name = "Pixelview";
751 ir->get_key = get_key_pixelview;
752 rc_proto = RC_PROTO_BIT_OTHER;
753 ir_codes = RC_MAP_EMPTY;
754 break;
755 case 0x18:
756 case 0x1f:
757 case 0x1a:
758 name = "Hauppauge";
759 ir->get_key = get_key_haup;
760 rc_proto = RC_PROTO_BIT_RC5;
761 ir_codes = RC_MAP_HAUPPAUGE;
762 break;
763 case 0x30:
764 name = "KNC One";
765 ir->get_key = get_key_knc1;
766 rc_proto = RC_PROTO_BIT_OTHER;
767 ir_codes = RC_MAP_EMPTY;
768 break;
769 case 0x6b:
770 name = "FusionHDTV";
771 ir->get_key = get_key_fusionhdtv;
772 rc_proto = RC_PROTO_BIT_UNKNOWN;
773 ir_codes = RC_MAP_FUSIONHDTV_MCE;
774 break;
775 case 0x40:
776 name = "AVerMedia Cardbus remote";
777 ir->get_key = get_key_avermedia_cardbus;
778 rc_proto = RC_PROTO_BIT_OTHER;
779 ir_codes = RC_MAP_AVERMEDIA_CARDBUS;
780 break;
781 case 0x41:
782 name = "AVerMedia EM78P153";
783 ir->get_key = get_key_avermedia_cardbus;
784 rc_proto = RC_PROTO_BIT_OTHER;
785 /* RM-KV remote, seems to be same as RM-K6 */
786 ir_codes = RC_MAP_AVERMEDIA_M733A_RM_K6;
787 break;
788 case 0x71:
789 name = "Hauppauge/Zilog Z8";
790 ir->get_key = get_key_haup_xvr;
791 rc_proto = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE |
792 RC_PROTO_BIT_RC6_6A_32;
793 ir_codes = RC_MAP_HAUPPAUGE;
794 ir->polling_interval = 125;
795 probe_tx = true;
796 break;
797 }
798
799 /* Let the caller override settings */
800 if (client->dev.platform_data) {
801 const struct IR_i2c_init_data *init_data =
802 client->dev.platform_data;
803
804 ir_codes = init_data->ir_codes;
805 rc = init_data->rc_dev;
806
807 name = init_data->name;
808 if (init_data->type)
809 rc_proto = init_data->type;
810
811 if (init_data->polling_interval)
812 ir->polling_interval = init_data->polling_interval;
813
814 switch (init_data->internal_get_key_func) {
815 case IR_KBD_GET_KEY_CUSTOM:
816 /* The bridge driver provided us its own function */
817 ir->get_key = init_data->get_key;
818 break;
819 case IR_KBD_GET_KEY_PIXELVIEW:
820 ir->get_key = get_key_pixelview;
821 break;
822 case IR_KBD_GET_KEY_HAUP:
823 ir->get_key = get_key_haup;
824 break;
825 case IR_KBD_GET_KEY_KNC1:
826 ir->get_key = get_key_knc1;
827 break;
828 case IR_KBD_GET_KEY_FUSIONHDTV:
829 ir->get_key = get_key_fusionhdtv;
830 break;
831 case IR_KBD_GET_KEY_HAUP_XVR:
832 ir->get_key = get_key_haup_xvr;
833 break;
834 case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS:
835 ir->get_key = get_key_avermedia_cardbus;
836 break;
837 }
838 }
839
840 if (!rc) {
841 /*
842 * If platform_data doesn't specify rc_dev, initialize it
843 * internally
844 */
845 rc = rc_allocate_device(RC_DRIVER_SCANCODE);
846 if (!rc)
847 return -ENOMEM;
848 }
849 ir->rc = rc;
850
851 /* Make sure we are all setup before going on */
852 if (!name || !ir->get_key || !rc_proto || !ir_codes) {
853 dev_warn(&client->dev, "Unsupported device at address 0x%02x\n",
854 addr);
855 err = -ENODEV;
856 goto err_out_free;
857 }
858
859 ir->ir_codes = ir_codes;
860
861 snprintf(ir->phys, sizeof(ir->phys), "%s/%s", dev_name(&adap->dev),
862 dev_name(&client->dev));
863
864 /*
865 * Initialize input_dev fields
866 * It doesn't make sense to allow overriding them via platform_data
867 */
868 rc->input_id.bustype = BUS_I2C;
869 rc->input_phys = ir->phys;
870 rc->device_name = name;
871 rc->dev.parent = &client->dev;
872 rc->priv = ir;
873 rc->open = ir_open;
874 rc->close = ir_close;
875
876 /*
877 * Initialize the other fields of rc_dev
878 */
879 rc->map_name = ir->ir_codes;
880 rc->allowed_protocols = rc_proto;
881 if (!rc->driver_name)
882 rc->driver_name = KBUILD_MODNAME;
883
884 mutex_init(&ir->lock);
885
886 INIT_DELAYED_WORK(&ir->work, ir_work);
887
888 if (probe_tx) {
889 ir->tx_c = i2c_new_dummy_device(client->adapter, 0x70);
890 if (IS_ERR(ir->tx_c)) {
891 dev_err(&client->dev, "failed to setup tx i2c address");
892 err = PTR_ERR(ir->tx_c);
893 goto err_out_free;
894 } else if (!zilog_init(ir)) {
895 ir->carrier = 38000;
896 ir->duty_cycle = 40;
897 rc->tx_ir = zilog_tx;
898 rc->s_tx_carrier = zilog_tx_carrier;
899 rc->s_tx_duty_cycle = zilog_tx_duty_cycle;
900 }
901 }
902
903 err = rc_register_device(rc);
904 if (err)
905 goto err_out_free;
906
907 return 0;
908
909 err_out_free:
910 if (!IS_ERR(ir->tx_c))
911 i2c_unregister_device(ir->tx_c);
912
913 /* Only frees rc if it were allocated internally */
914 rc_free_device(rc);
915 return err;
916 }
917
ir_remove(struct i2c_client * client)918 static int ir_remove(struct i2c_client *client)
919 {
920 struct IR_i2c *ir = i2c_get_clientdata(client);
921
922 cancel_delayed_work_sync(&ir->work);
923
924 i2c_unregister_device(ir->tx_c);
925
926 rc_unregister_device(ir->rc);
927
928 return 0;
929 }
930
931 static const struct i2c_device_id ir_kbd_id[] = {
932 /* Generic entry for any IR receiver */
933 { "ir_video", 0 },
934 /* IR device specific entries should be added here */
935 { "ir_z8f0811_haup", FLAG_TX },
936 { "ir_z8f0811_hdpvr", FLAG_TX | FLAG_HDPVR },
937 { }
938 };
939 MODULE_DEVICE_TABLE(i2c, ir_kbd_id);
940
941 static struct i2c_driver ir_kbd_driver = {
942 .driver = {
943 .name = "ir-kbd-i2c",
944 },
945 .probe = ir_probe,
946 .remove = ir_remove,
947 .id_table = ir_kbd_id,
948 };
949
950 module_i2c_driver(ir_kbd_driver);
951
952 /* ----------------------------------------------------------------------- */
953
954 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
955 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
956 MODULE_LICENSE("GPL");
957