Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
| 3 | * keyboard input driver for i2c IR remote controls |
| 4 | * |
| 5 | * Copyright (c) 2000-2003 Gerd Knorr <kraxel@bytesex.org> |
| 6 | * modified for PixelView (BT878P+W/FM) by |
| 7 | * Michal Kochanowicz <mkochano@pld.org.pl> |
| 8 | * Christoph Bartelmus <lirc@bartelmus.de> |
| 9 | * modified for KNC ONE TV Station/Anubis Typhoon TView Tuner by |
| 10 | * Ulrich Mueller <ulrich.mueller42@web.de> |
Markus Rechberger | c365864 | 2005-11-08 21:37:21 -0800 | [diff] [blame] | 11 | * modified for em2820 based USB TV tuners by |
| 12 | * Markus Rechberger <mrechberger@gmail.com> |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 13 | * modified for DViCO Fusion HDTV 5 RT GOLD by |
| 14 | * Chaogui Zhang <czhang1974@gmail.com> |
Brian Rogers | ba340b4 | 2008-10-13 08:37:06 -0300 | [diff] [blame] | 15 | * modified for MSI TV@nywhere Plus by |
| 16 | * Henry Wong <henry@stuffedcow.net> |
| 17 | * Mark Schultz <n9xmj@yahoo.com> |
| 18 | * Brian Rogers <brian_rogers@comcast.net> |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 19 | * modified for AVerMedia Cardbus by |
| 20 | * Oldrich Jedlicka <oldium.pro@seznam.cz> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | * |
| 22 | * This program is free software; you can redistribute it and/or modify |
| 23 | * it under the terms of the GNU General Public License as published by |
| 24 | * the Free Software Foundation; either version 2 of the License, or |
| 25 | * (at your option) any later version. |
| 26 | * |
| 27 | * This program is distributed in the hope that it will be useful, |
| 28 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 29 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 30 | * GNU General Public License for more details. |
| 31 | * |
| 32 | * You should have received a copy of the GNU General Public License |
| 33 | * along with this program; if not, write to the Free Software |
| 34 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 35 | * |
| 36 | */ |
| 37 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 38 | #include <asm/unaligned.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | #include <linux/init.h> |
| 41 | #include <linux/kernel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Mauro Carvalho Chehab | 674434c | 2005-12-12 00:37:28 -0800 | [diff] [blame] | 49 | |
Mauro Carvalho Chehab | 6bda964 | 2010-11-17 13:28:38 -0300 | [diff] [blame] | 50 | #include <media/rc-core.h> |
Mauro Carvalho Chehab | b5dcee2 | 2015-11-10 12:01:44 -0200 | [diff] [blame] | 51 | #include <media/i2c/ir-kbd-i2c.h> |
Markus Rechberger | c365864 | 2005-11-08 21:37:21 -0800 | [diff] [blame] | 52 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | /* ----------------------------------------------------------------------- */ |
| 54 | /* insmod parameters */ |
| 55 | |
| 56 | static int debug; |
| 57 | module_param(debug, int, 0644); /* debug level (0,1,2) */ |
| 58 | |
J.O. Aho | bf47e4e | 2006-01-23 09:34:06 -0200 | [diff] [blame] | 59 | |
Mauro Carvalho Chehab | 727e625 | 2010-03-12 21:18:14 -0300 | [diff] [blame] | 60 | #define MODULE_NAME "ir-kbd-i2c" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | #define dprintk(level, fmt, arg...) if (debug >= level) \ |
Mauro Carvalho Chehab | 727e625 | 2010-03-12 21:18:14 -0300 | [diff] [blame] | 62 | printk(KERN_DEBUG MODULE_NAME ": " fmt , ## arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
| 64 | /* ----------------------------------------------------------------------- */ |
| 65 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 66 | static int get_key_haup_common(struct IR_i2c *ir, enum rc_type *protocol, |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 67 | u32 *scancode, u8 *ptoggle, int size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | { |
Jan Frey | 39cf1e8 | 2007-06-25 14:34:06 -0300 | [diff] [blame] | 69 | unsigned char buf[6]; |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 70 | int start, range, toggle, dev, code, ircode, vendor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
| 72 | /* poll IR chip */ |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 73 | if (size != i2c_master_recv(ir->c, buf, size)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | return -EIO; |
| 75 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 76 | if (buf[0] & 0x80) { |
| 77 | int offset = (size == 6) ? 3 : 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 79 | /* split rc5 data block ... */ |
| 80 | start = (buf[offset] >> 7) & 1; |
| 81 | range = (buf[offset] >> 6) & 1; |
| 82 | toggle = (buf[offset] >> 5) & 1; |
| 83 | dev = buf[offset] & 0x1f; |
| 84 | code = (buf[offset+1] >> 2) & 0x3f; |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 85 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 86 | /* rc5 has two start bits |
| 87 | * the first bit must be one |
| 88 | * the second bit defines the command range: |
| 89 | * 1 = 0-63, 0 = 64 - 127 |
| 90 | */ |
| 91 | if (!start) |
| 92 | /* no key pressed */ |
| 93 | return 0; |
Darron Broad | 34c0802 | 2008-09-22 00:54:59 -0300 | [diff] [blame] | 94 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 95 | /* filter out invalid key presses */ |
| 96 | ircode = (start << 12) | (toggle << 11) | (dev << 6) | code; |
| 97 | if ((ircode & 0x1fff) == 0x1fff) |
| 98 | return 0; |
David Hardeman | cc7093d | 2006-09-26 16:39:00 -0300 | [diff] [blame] | 99 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 100 | if (!range) |
| 101 | code += 64; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 103 | dprintk(1, "ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n", |
| 104 | start, range, toggle, dev, code); |
| 105 | |
| 106 | *protocol = RC_TYPE_RC5; |
| 107 | *scancode = RC_SCANCODE_RC5(dev, code); |
| 108 | *ptoggle = toggle; |
| 109 | |
| 110 | return 1; |
| 111 | } else if (size == 6 && (buf[0] & 0x40)) { |
| 112 | code = buf[4]; |
| 113 | dev = buf[3]; |
| 114 | vendor = get_unaligned_be16(buf + 1); |
| 115 | |
| 116 | if (vendor == 0x800f) { |
| 117 | *ptoggle = (dev & 0x80) != 0; |
| 118 | *protocol = RC_TYPE_RC6_MCE; |
| 119 | dev &= 0x7f; |
| 120 | dprintk(1, "ir hauppauge (rc6-mce): t%d vendor=%d dev=%d code=%d\n", |
Arnd Bergmann | 9cdbe14 | 2016-11-10 17:44:50 +0100 | [diff] [blame] | 121 | *ptoggle, vendor, dev, code); |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 122 | } else { |
| 123 | *ptoggle = 0; |
| 124 | *protocol = RC_TYPE_RC6_6A_32; |
| 125 | dprintk(1, "ir hauppauge (rc6-6a-32): vendor=%d dev=%d code=%d\n", |
| 126 | vendor, dev, code); |
| 127 | } |
| 128 | |
| 129 | *scancode = RC_SCANCODE_RC6_6A(vendor, dev, code); |
| 130 | |
| 131 | return 1; |
| 132 | } |
| 133 | |
| 134 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | } |
| 136 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 137 | static int get_key_haup(struct IR_i2c *ir, enum rc_type *protocol, |
| 138 | u32 *scancode, u8 *toggle) |
Jan Frey | 39cf1e8 | 2007-06-25 14:34:06 -0300 | [diff] [blame] | 139 | { |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 140 | return get_key_haup_common(ir, protocol, scancode, toggle, 3); |
Jan Frey | 39cf1e8 | 2007-06-25 14:34:06 -0300 | [diff] [blame] | 141 | } |
| 142 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 143 | static int get_key_haup_xvr(struct IR_i2c *ir, enum rc_type *protocol, |
| 144 | u32 *scancode, u8 *toggle) |
Jan Frey | 39cf1e8 | 2007-06-25 14:34:06 -0300 | [diff] [blame] | 145 | { |
Jarod Wilson | 8df5991 | 2011-01-20 18:31:18 -0300 | [diff] [blame] | 146 | int ret; |
| 147 | unsigned char buf[1] = { 0 }; |
| 148 | |
| 149 | /* |
| 150 | * This is the same apparent "are you ready?" poll command observed |
| 151 | * watching Windows driver traffic and implemented in lirc_zilog. With |
| 152 | * this added, we get far saner remote behavior with z8 chips on usb |
| 153 | * connected devices, even with the default polling interval of 100ms. |
| 154 | */ |
| 155 | ret = i2c_master_send(ir->c, buf, 1); |
| 156 | if (ret != 1) |
| 157 | return (ret < 0) ? ret : -EINVAL; |
| 158 | |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 159 | return get_key_haup_common(ir, protocol, scancode, toggle, 6); |
Jan Frey | 39cf1e8 | 2007-06-25 14:34:06 -0300 | [diff] [blame] | 160 | } |
| 161 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 162 | static int get_key_pixelview(struct IR_i2c *ir, enum rc_type *protocol, |
| 163 | u32 *scancode, u8 *toggle) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | { |
Mauro Carvalho Chehab | 4ac9791 | 2005-11-08 21:37:43 -0800 | [diff] [blame] | 165 | unsigned char b; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | |
| 167 | /* poll IR chip */ |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 168 | if (1 != i2c_master_recv(ir->c, &b, 1)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | dprintk(1,"read error\n"); |
| 170 | return -EIO; |
| 171 | } |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 172 | |
| 173 | *protocol = RC_TYPE_OTHER; |
| 174 | *scancode = b; |
| 175 | *toggle = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | return 1; |
| 177 | } |
| 178 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 179 | static int get_key_fusionhdtv(struct IR_i2c *ir, enum rc_type *protocol, |
| 180 | u32 *scancode, u8 *toggle) |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 181 | { |
| 182 | unsigned char buf[4]; |
| 183 | |
| 184 | /* poll IR chip */ |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 185 | if (4 != i2c_master_recv(ir->c, buf, 4)) { |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 186 | dprintk(1,"read error\n"); |
| 187 | return -EIO; |
| 188 | } |
| 189 | |
| 190 | if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0) |
Harvey Harrison | 7e28adb | 2008-04-08 23:20:00 -0300 | [diff] [blame] | 191 | dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__, |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 192 | buf[0], buf[1], buf[2], buf[3]); |
| 193 | |
| 194 | /* no key pressed or signal from other ir remote */ |
| 195 | if(buf[0] != 0x1 || buf[1] != 0xfe) |
| 196 | return 0; |
| 197 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 198 | *protocol = RC_TYPE_UNKNOWN; |
| 199 | *scancode = buf[2]; |
| 200 | *toggle = 0; |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 201 | return 1; |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 202 | } |
| 203 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 204 | static int get_key_knc1(struct IR_i2c *ir, enum rc_type *protocol, |
| 205 | u32 *scancode, u8 *toggle) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | { |
| 207 | unsigned char b; |
| 208 | |
| 209 | /* poll IR chip */ |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 210 | if (1 != i2c_master_recv(ir->c, &b, 1)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | dprintk(1,"read error\n"); |
| 212 | return -EIO; |
| 213 | } |
| 214 | |
| 215 | /* it seems that 0xFE indicates that a button is still hold |
Mauro Carvalho Chehab | 4f9c05a | 2005-11-08 21:37:36 -0800 | [diff] [blame] | 216 | down, while 0xff indicates that no button is hold |
| 217 | down. 0xfe sequences are sometimes interrupted by 0xFF */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | |
| 219 | dprintk(2,"key %02x\n", b); |
| 220 | |
Mauro Carvalho Chehab | 4f9c05a | 2005-11-08 21:37:36 -0800 | [diff] [blame] | 221 | if (b == 0xff) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | return 0; |
| 223 | |
Mauro Carvalho Chehab | 4f9c05a | 2005-11-08 21:37:36 -0800 | [diff] [blame] | 224 | if (b == 0xfe) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | /* keep old data */ |
| 226 | return 1; |
| 227 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 228 | *protocol = RC_TYPE_UNKNOWN; |
| 229 | *scancode = b; |
| 230 | *toggle = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | return 1; |
| 232 | } |
| 233 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 234 | static int get_key_avermedia_cardbus(struct IR_i2c *ir, enum rc_type *protocol, |
| 235 | u32 *scancode, u8 *toggle) |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 236 | { |
| 237 | unsigned char subaddr, key, keygroup; |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 238 | struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0, |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 239 | .buf = &subaddr, .len = 1}, |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 240 | { .addr = ir->c->addr, .flags = I2C_M_RD, |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 241 | .buf = &key, .len = 1} }; |
| 242 | subaddr = 0x0d; |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 243 | if (2 != i2c_transfer(ir->c->adapter, msg, 2)) { |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 244 | dprintk(1, "read error\n"); |
| 245 | return -EIO; |
| 246 | } |
| 247 | |
| 248 | if (key == 0xff) |
| 249 | return 0; |
| 250 | |
| 251 | subaddr = 0x0b; |
| 252 | msg[1].buf = &keygroup; |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 253 | if (2 != i2c_transfer(ir->c->adapter, msg, 2)) { |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 254 | dprintk(1, "read error\n"); |
| 255 | return -EIO; |
| 256 | } |
| 257 | |
| 258 | if (keygroup == 0xff) |
| 259 | return 0; |
| 260 | |
| 261 | dprintk(1, "read key 0x%02x/0x%02x\n", key, keygroup); |
Ondrej Zary | 34fe278 | 2013-04-06 14:28:16 -0300 | [diff] [blame] | 262 | if (keygroup < 2 || keygroup > 4) { |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 263 | /* Only a warning */ |
| 264 | dprintk(1, "warning: invalid key group 0x%02x for key 0x%02x\n", |
| 265 | keygroup, key); |
| 266 | } |
| 267 | key |= (keygroup & 1) << 6; |
| 268 | |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 269 | *protocol = RC_TYPE_UNKNOWN; |
| 270 | *scancode = key; |
| 271 | if (ir->c->addr == 0x41) /* AVerMedia EM78P153 */ |
| 272 | *scancode |= keygroup << 8; |
| 273 | *toggle = 0; |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 274 | return 1; |
| 275 | } |
| 276 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | /* ----------------------------------------------------------------------- */ |
| 278 | |
Mauro Carvalho Chehab | 90bf3aa | 2012-01-09 22:28:13 -0200 | [diff] [blame] | 279 | static int ir_key_poll(struct IR_i2c *ir) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | { |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 281 | enum rc_type protocol; |
| 282 | u32 scancode; |
| 283 | u8 toggle; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | int rc; |
| 285 | |
Mauro Carvalho Chehab | e6bcb2f | 2011-01-12 13:50:01 -0300 | [diff] [blame] | 286 | dprintk(3, "%s\n", __func__); |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 287 | rc = ir->get_key(ir, &protocol, &scancode, &toggle); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | if (rc < 0) { |
| 289 | dprintk(2,"error\n"); |
Mauro Carvalho Chehab | 90bf3aa | 2012-01-09 22:28:13 -0200 | [diff] [blame] | 290 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | } |
| 292 | |
Mauro Carvalho Chehab | e6bcb2f | 2011-01-12 13:50:01 -0300 | [diff] [blame] | 293 | if (rc) { |
David Härdeman | 120703f | 2014-04-03 20:31:30 -0300 | [diff] [blame] | 294 | dprintk(1, "%s: proto = 0x%04x, scancode = 0x%08x\n", |
| 295 | __func__, protocol, scancode); |
| 296 | rc_keydown(ir->rc, protocol, scancode, toggle); |
Mauro Carvalho Chehab | e6bcb2f | 2011-01-12 13:50:01 -0300 | [diff] [blame] | 297 | } |
Mauro Carvalho Chehab | 90bf3aa | 2012-01-09 22:28:13 -0200 | [diff] [blame] | 298 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | } |
| 300 | |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 301 | static void ir_work(struct work_struct *work) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | { |
Mauro Carvalho Chehab | 90bf3aa | 2012-01-09 22:28:13 -0200 | [diff] [blame] | 303 | int rc; |
Jean Delvare | c1089bd | 2009-03-07 07:43:43 -0300 | [diff] [blame] | 304 | struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work); |
Dmitry Torokhov | 8083c52 | 2007-05-21 11:51:11 -0300 | [diff] [blame] | 305 | |
Mauro Carvalho Chehab | 90bf3aa | 2012-01-09 22:28:13 -0200 | [diff] [blame] | 306 | rc = ir_key_poll(ir); |
| 307 | if (rc == -ENODEV) { |
| 308 | rc_unregister_device(ir->rc); |
| 309 | ir->rc = NULL; |
| 310 | return; |
| 311 | } |
| 312 | |
Mauro Carvalho Chehab | c72ba8e | 2010-09-23 01:23:10 -0300 | [diff] [blame] | 313 | schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling_interval)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 314 | } |
| 315 | |
| 316 | /* ----------------------------------------------------------------------- */ |
| 317 | |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 318 | static int ir_probe(struct i2c_client *client, const struct i2c_device_id *id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | { |
Mauro Carvalho Chehab | 02858ee | 2010-04-02 20:01:00 -0300 | [diff] [blame] | 320 | char *ir_codes = NULL; |
Jean Delvare | 9a4cc5a | 2009-05-13 16:50:11 -0300 | [diff] [blame] | 321 | const char *name = NULL; |
David Härdeman | c003ab1 | 2012-10-11 19:11:54 -0300 | [diff] [blame] | 322 | u64 rc_type = RC_BIT_UNKNOWN; |
Mauro Carvalho Chehab | afd1a0c | 2005-12-12 00:37:27 -0800 | [diff] [blame] | 323 | struct IR_i2c *ir; |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 324 | struct rc_dev *rc = NULL; |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 325 | struct i2c_adapter *adap = client->adapter; |
| 326 | unsigned short addr = client->addr; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 327 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | |
Laurent Pinchart | c02b211 | 2013-05-02 08:29:43 -0300 | [diff] [blame] | 329 | ir = devm_kzalloc(&client->dev, sizeof(*ir), GFP_KERNEL); |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 330 | if (!ir) |
| 331 | return -ENOMEM; |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 332 | |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 333 | ir->c = client; |
Mauro Carvalho Chehab | c72ba8e | 2010-09-23 01:23:10 -0300 | [diff] [blame] | 334 | ir->polling_interval = DEFAULT_POLLING_INTERVAL; |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 335 | i2c_set_clientdata(client, ir); |
Mauro Carvalho Chehab | d21838d | 2006-01-09 15:25:21 -0200 | [diff] [blame] | 336 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | switch(addr) { |
| 338 | case 0x64: |
| 339 | name = "Pixelview"; |
| 340 | ir->get_key = get_key_pixelview; |
David Härdeman | c003ab1 | 2012-10-11 19:11:54 -0300 | [diff] [blame] | 341 | rc_type = RC_BIT_OTHER; |
Mauro Carvalho Chehab | 02858ee | 2010-04-02 20:01:00 -0300 | [diff] [blame] | 342 | ir_codes = RC_MAP_EMPTY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | case 0x18: |
Magnus Alm | ca39d84 | 2009-11-13 05:48:24 -0300 | [diff] [blame] | 345 | case 0x1f: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | case 0x1a: |
| 347 | name = "Hauppauge"; |
| 348 | ir->get_key = get_key_haup; |
David Härdeman | c003ab1 | 2012-10-11 19:11:54 -0300 | [diff] [blame] | 349 | rc_type = RC_BIT_RC5; |
Mauro Carvalho Chehab | 2062410 | 2011-01-24 22:23:08 -0300 | [diff] [blame] | 350 | ir_codes = RC_MAP_HAUPPAUGE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | break; |
| 352 | case 0x30: |
Mauro Carvalho Chehab | d5e5265 | 2005-11-08 21:37:32 -0800 | [diff] [blame] | 353 | name = "KNC One"; |
| 354 | ir->get_key = get_key_knc1; |
David Härdeman | c003ab1 | 2012-10-11 19:11:54 -0300 | [diff] [blame] | 355 | rc_type = RC_BIT_OTHER; |
Mauro Carvalho Chehab | 02858ee | 2010-04-02 20:01:00 -0300 | [diff] [blame] | 356 | ir_codes = RC_MAP_EMPTY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | break; |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 358 | case 0x6b: |
Michael Krufky | 3c44358 | 2007-08-24 01:07:12 -0300 | [diff] [blame] | 359 | name = "FusionHDTV"; |
| 360 | ir->get_key = get_key_fusionhdtv; |
David Härdeman | 4dd9bb9 | 2014-04-03 20:31:25 -0300 | [diff] [blame] | 361 | rc_type = RC_BIT_UNKNOWN; |
Mauro Carvalho Chehab | 02858ee | 2010-04-02 20:01:00 -0300 | [diff] [blame] | 362 | ir_codes = RC_MAP_FUSIONHDTV_MCE; |
Chaogui Zhang | d54d698 | 2007-08-24 01:02:32 -0300 | [diff] [blame] | 363 | break; |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 364 | case 0x40: |
| 365 | name = "AVerMedia Cardbus remote"; |
| 366 | ir->get_key = get_key_avermedia_cardbus; |
David Härdeman | c003ab1 | 2012-10-11 19:11:54 -0300 | [diff] [blame] | 367 | rc_type = RC_BIT_OTHER; |
Mauro Carvalho Chehab | 02858ee | 2010-04-02 20:01:00 -0300 | [diff] [blame] | 368 | ir_codes = RC_MAP_AVERMEDIA_CARDBUS; |
Oldřich Jedlička | cb3bf50 | 2009-02-12 03:43:11 -0300 | [diff] [blame] | 369 | break; |
Ondrej Zary | 34fe278 | 2013-04-06 14:28:16 -0300 | [diff] [blame] | 370 | case 0x41: |
| 371 | name = "AVerMedia EM78P153"; |
| 372 | ir->get_key = get_key_avermedia_cardbus; |
| 373 | rc_type = RC_BIT_OTHER; |
| 374 | /* RM-KV remote, seems to be same as RM-K6 */ |
| 375 | ir_codes = RC_MAP_AVERMEDIA_M733A_RM_K6; |
| 376 | break; |
Andy Walls | c69a4af | 2011-01-16 15:45:32 -0300 | [diff] [blame] | 377 | case 0x71: |
| 378 | name = "Hauppauge/Zilog Z8"; |
| 379 | ir->get_key = get_key_haup_xvr; |
Sean Young | 00bb820 | 2016-09-19 19:21:23 -0300 | [diff] [blame] | 380 | rc_type = RC_BIT_RC5 | RC_BIT_RC6_MCE | RC_BIT_RC6_6A_32; |
Mauro Carvalho Chehab | 2062410 | 2011-01-24 22:23:08 -0300 | [diff] [blame] | 381 | ir_codes = RC_MAP_HAUPPAUGE; |
Andy Walls | c69a4af | 2011-01-16 15:45:32 -0300 | [diff] [blame] | 382 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | } |
| 384 | |
Jean Delvare | 4d7a2d6 | 2009-05-13 16:49:32 -0300 | [diff] [blame] | 385 | /* Let the caller override settings */ |
| 386 | if (client->dev.platform_data) { |
| 387 | const struct IR_i2c_init_data *init_data = |
| 388 | client->dev.platform_data; |
| 389 | |
| 390 | ir_codes = init_data->ir_codes; |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 391 | rc = init_data->rc_dev; |
| 392 | |
Jean Delvare | 4d7a2d6 | 2009-05-13 16:49:32 -0300 | [diff] [blame] | 393 | name = init_data->name; |
Andy Walls | 1b6e59e | 2009-07-28 11:44:05 -0300 | [diff] [blame] | 394 | if (init_data->type) |
Mauro Carvalho Chehab | 52b6614 | 2010-11-17 14:20:52 -0300 | [diff] [blame] | 395 | rc_type = init_data->type; |
Andy Walls | 1b6e59e | 2009-07-28 11:44:05 -0300 | [diff] [blame] | 396 | |
Mauro Carvalho Chehab | c72ba8e | 2010-09-23 01:23:10 -0300 | [diff] [blame] | 397 | if (init_data->polling_interval) |
| 398 | ir->polling_interval = init_data->polling_interval; |
| 399 | |
Andy Walls | 1b6e59e | 2009-07-28 11:44:05 -0300 | [diff] [blame] | 400 | switch (init_data->internal_get_key_func) { |
| 401 | case IR_KBD_GET_KEY_CUSTOM: |
| 402 | /* The bridge driver provided us its own function */ |
| 403 | ir->get_key = init_data->get_key; |
| 404 | break; |
| 405 | case IR_KBD_GET_KEY_PIXELVIEW: |
| 406 | ir->get_key = get_key_pixelview; |
| 407 | break; |
Andy Walls | 1b6e59e | 2009-07-28 11:44:05 -0300 | [diff] [blame] | 408 | case IR_KBD_GET_KEY_HAUP: |
| 409 | ir->get_key = get_key_haup; |
| 410 | break; |
| 411 | case IR_KBD_GET_KEY_KNC1: |
| 412 | ir->get_key = get_key_knc1; |
| 413 | break; |
| 414 | case IR_KBD_GET_KEY_FUSIONHDTV: |
| 415 | ir->get_key = get_key_fusionhdtv; |
| 416 | break; |
| 417 | case IR_KBD_GET_KEY_HAUP_XVR: |
| 418 | ir->get_key = get_key_haup_xvr; |
| 419 | break; |
| 420 | case IR_KBD_GET_KEY_AVERMEDIA_CARDBUS: |
| 421 | ir->get_key = get_key_avermedia_cardbus; |
| 422 | break; |
| 423 | } |
Jean Delvare | 4d7a2d6 | 2009-05-13 16:49:32 -0300 | [diff] [blame] | 424 | } |
| 425 | |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 426 | if (!rc) { |
| 427 | /* |
Jonathan McCrohan | 39c1cb2 | 2013-10-20 21:34:01 -0300 | [diff] [blame] | 428 | * If platform_data doesn't specify rc_dev, initialize it |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 429 | * internally |
| 430 | */ |
| 431 | rc = rc_allocate_device(); |
Laurent Pinchart | c02b211 | 2013-05-02 08:29:43 -0300 | [diff] [blame] | 432 | if (!rc) |
| 433 | return -ENOMEM; |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 434 | } |
| 435 | ir->rc = rc; |
| 436 | |
Jean Delvare | 9a4cc5a | 2009-05-13 16:50:11 -0300 | [diff] [blame] | 437 | /* Make sure we are all setup before going on */ |
Mauro Carvalho Chehab | 52b6614 | 2010-11-17 14:20:52 -0300 | [diff] [blame] | 438 | if (!name || !ir->get_key || !rc_type || !ir_codes) { |
Lukas Karas | d995a18 | 2009-11-24 12:06:52 -0300 | [diff] [blame] | 439 | dprintk(1, ": Unsupported device at address 0x%02x\n", |
Jean Delvare | 9a4cc5a | 2009-05-13 16:50:11 -0300 | [diff] [blame] | 440 | addr); |
| 441 | err = -ENODEV; |
| 442 | goto err_out_free; |
| 443 | } |
| 444 | |
Ricardo Cerqueira | ac9cd97 | 2005-11-08 21:37:56 -0800 | [diff] [blame] | 445 | /* Sets name */ |
Jean Delvare | 1df8e98 | 2009-05-13 16:48:07 -0300 | [diff] [blame] | 446 | snprintf(ir->name, sizeof(ir->name), "i2c IR (%s)", name); |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 447 | ir->ir_codes = ir_codes; |
Mauro Carvalho Chehab | d5e5265 | 2005-11-08 21:37:32 -0800 | [diff] [blame] | 448 | |
Ricardo Cerqueira | ac9cd97 | 2005-11-08 21:37:56 -0800 | [diff] [blame] | 449 | snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0", |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 450 | dev_name(&adap->dev), |
| 451 | dev_name(&client->dev)); |
Ricardo Cerqueira | ac9cd97 | 2005-11-08 21:37:56 -0800 | [diff] [blame] | 452 | |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 453 | /* |
| 454 | * Initialize input_dev fields |
| 455 | * It doesn't make sense to allow overriding them via platform_data |
| 456 | */ |
David Härdeman | d8b4b58 | 2010-10-29 16:08:23 -0300 | [diff] [blame] | 457 | rc->input_id.bustype = BUS_I2C; |
David Härdeman | d8b4b58 | 2010-10-29 16:08:23 -0300 | [diff] [blame] | 458 | rc->input_phys = ir->phys; |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 459 | rc->input_name = ir->name; |
| 460 | |
| 461 | /* |
| 462 | * Initialize the other fields of rc_dev |
| 463 | */ |
| 464 | rc->map_name = ir->ir_codes; |
David Härdeman | c5540fb | 2014-04-03 20:32:21 -0300 | [diff] [blame] | 465 | rc->allowed_protocols = rc_type; |
| 466 | rc->enabled_protocols = rc_type; |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 467 | if (!rc->driver_name) |
| 468 | rc->driver_name = MODULE_NAME; |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 469 | |
David Härdeman | d8b4b58 | 2010-10-29 16:08:23 -0300 | [diff] [blame] | 470 | err = rc_register_device(rc); |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 471 | if (err) |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 472 | goto err_out_free; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 473 | |
Mauro Carvalho Chehab | 727e625 | 2010-03-12 21:18:14 -0300 | [diff] [blame] | 474 | printk(MODULE_NAME ": %s detected at %s [%s]\n", |
David Härdeman | d8b4b58 | 2010-10-29 16:08:23 -0300 | [diff] [blame] | 475 | ir->name, ir->phys, adap->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 476 | |
| 477 | /* start polling via eventd */ |
Jean Delvare | c1089bd | 2009-03-07 07:43:43 -0300 | [diff] [blame] | 478 | INIT_DELAYED_WORK(&ir->work, ir_work); |
| 479 | schedule_delayed_work(&ir->work, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 480 | |
| 481 | return 0; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 482 | |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 483 | err_out_free: |
Mauro Carvalho Chehab | 2eb2583 | 2010-11-12 09:02:40 -0300 | [diff] [blame] | 484 | /* Only frees rc if it were allocated internally */ |
David Härdeman | d8b4b58 | 2010-10-29 16:08:23 -0300 | [diff] [blame] | 485 | rc_free_device(rc); |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 486 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 487 | } |
| 488 | |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 489 | static int ir_remove(struct i2c_client *client) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | { |
Mauro Carvalho Chehab | 4ac9791 | 2005-11-08 21:37:43 -0800 | [diff] [blame] | 491 | struct IR_i2c *ir = i2c_get_clientdata(client); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 492 | |
| 493 | /* kill outstanding polls */ |
Jean Delvare | c1089bd | 2009-03-07 07:43:43 -0300 | [diff] [blame] | 494 | cancel_delayed_work_sync(&ir->work); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 496 | /* unregister device */ |
Markus Elfring | 8f1aeed | 2014-11-20 07:13:16 -0300 | [diff] [blame] | 497 | rc_unregister_device(ir->rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 498 | |
| 499 | /* free memory */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 500 | return 0; |
| 501 | } |
| 502 | |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 503 | static const struct i2c_device_id ir_kbd_id[] = { |
| 504 | /* Generic entry for any IR receiver */ |
| 505 | { "ir_video", 0 }, |
Andy Walls | f5d887a | 2009-07-28 11:50:14 -0300 | [diff] [blame] | 506 | /* IR device specific entries should be added here */ |
| 507 | { "ir_rx_z8f0811_haup", 0 }, |
Andy Walls | a9cd591 | 2010-12-28 22:47:46 -0300 | [diff] [blame] | 508 | { "ir_rx_z8f0811_hdpvr", 0 }, |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 509 | { } |
| 510 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 511 | |
Axel Lin | c6e8d86 | 2012-02-12 06:56:32 -0300 | [diff] [blame] | 512 | static struct i2c_driver ir_kbd_driver = { |
Jean Delvare | c668f32 | 2009-05-13 16:48:50 -0300 | [diff] [blame] | 513 | .driver = { |
| 514 | .name = "ir-kbd-i2c", |
| 515 | }, |
| 516 | .probe = ir_probe, |
| 517 | .remove = ir_remove, |
| 518 | .id_table = ir_kbd_id, |
| 519 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | |
Axel Lin | c6e8d86 | 2012-02-12 06:56:32 -0300 | [diff] [blame] | 521 | module_i2c_driver(ir_kbd_driver); |
| 522 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | /* ----------------------------------------------------------------------- */ |
| 524 | |
| 525 | MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller"); |
| 526 | MODULE_DESCRIPTION("input driver for i2c IR remote controls"); |
| 527 | MODULE_LICENSE("GPL"); |