blob: 7b65f5e537f803355593a85cf73b984843d851c3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
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 Rechbergerc3658642005-11-08 21:37:21 -080011 * modified for em2820 based USB TV tuners by
12 * Markus Rechberger <mrechberger@gmail.com>
Chaogui Zhangd54d6982007-08-24 01:02:32 -030013 * modified for DViCO Fusion HDTV 5 RT GOLD by
14 * Chaogui Zhang <czhang1974@gmail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 *
30 */
31
32#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/init.h>
34#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/string.h>
36#include <linux/timer.h>
37#include <linux/delay.h>
38#include <linux/errno.h>
39#include <linux/slab.h>
40#include <linux/i2c.h>
Jan Frey39cf1e82007-06-25 14:34:06 -030041#include <linux/i2c-id.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/workqueue.h>
Mauro Carvalho Chehab674434c2005-12-12 00:37:28 -080043
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <media/ir-common.h>
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -080045#include <media/ir-kbd-i2c.h>
Markus Rechbergerc3658642005-11-08 21:37:21 -080046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047/* ----------------------------------------------------------------------- */
48/* insmod parameters */
49
50static int debug;
51module_param(debug, int, 0644); /* debug level (0,1,2) */
52
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030053static int hauppauge;
J.O. Ahobf47e4e2006-01-23 09:34:06 -020054module_param(hauppauge, int, 0644); /* Choose Hauppauge remote */
55MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
56
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#define DEVNAME "ir-kbd-i2c"
59#define dprintk(level, fmt, arg...) if (debug >= level) \
60 printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
61
62/* ----------------------------------------------------------------------- */
63
Jan Frey39cf1e82007-06-25 14:34:06 -030064static int get_key_haup_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
65 int size, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
Jan Frey39cf1e82007-06-25 14:34:06 -030067 unsigned char buf[6];
David Hardemancc7093d2006-09-26 16:39:00 -030068 int start, range, toggle, dev, code;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70 /* poll IR chip */
Jan Frey39cf1e82007-06-25 14:34:06 -030071 if (size != i2c_master_recv(&ir->c,buf,size))
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 return -EIO;
73
74 /* split rc5 data block ... */
Jan Frey39cf1e82007-06-25 14:34:06 -030075 start = (buf[offset] >> 7) & 1;
76 range = (buf[offset] >> 6) & 1;
77 toggle = (buf[offset] >> 5) & 1;
78 dev = buf[offset] & 0x1f;
79 code = (buf[offset+1] >> 2) & 0x3f;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
David Hardemancc7093d2006-09-26 16:39:00 -030081 /* rc5 has two start bits
82 * the first bit must be one
83 * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
84 */
85 if (!start)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 /* no key pressed */
87 return 0;
David Hardemancc7093d2006-09-26 16:39:00 -030088
89 if (!range)
90 code += 64;
91
92 dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
93 start, range, toggle, dev, code);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95 /* return key */
96 *ir_key = code;
97 *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
98 return 1;
99}
100
Jan Frey39cf1e82007-06-25 14:34:06 -0300101static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
102{
103 return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
104}
105
106static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
107{
108 return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
109}
110
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800111static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800113 unsigned char b;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115 /* poll IR chip */
116 if (1 != i2c_master_recv(&ir->c,&b,1)) {
117 dprintk(1,"read error\n");
118 return -EIO;
119 }
120 *ir_key = b;
121 *ir_raw = b;
122 return 1;
123}
124
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800125static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800127 unsigned char b;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129 /* poll IR chip */
130 if (1 != i2c_master_recv(&ir->c,&b,1)) {
131 dprintk(1,"read error\n");
132 return -EIO;
133 }
134
135 /* ignore 0xaa */
136 if (b==0xaa)
137 return 0;
138 dprintk(2,"key %02x\n", b);
139
140 *ir_key = b;
141 *ir_raw = b;
142 return 1;
143}
144
Michael Krufky3c443582007-08-24 01:07:12 -0300145static int get_key_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300146{
147 unsigned char buf[4];
148
149 /* poll IR chip */
150 if (4 != i2c_master_recv(&ir->c,buf,4)) {
151 dprintk(1,"read error\n");
152 return -EIO;
153 }
154
155 if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
Harvey Harrison7e28adb2008-04-08 23:20:00 -0300156 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300157 buf[0], buf[1], buf[2], buf[3]);
158
159 /* no key pressed or signal from other ir remote */
160 if(buf[0] != 0x1 || buf[1] != 0xfe)
161 return 0;
162
163 *ir_key = buf[2];
164 *ir_raw = (buf[2] << 8) | buf[3];
165
166 return 1;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300167}
168
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800169static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 unsigned char b;
172
173 /* poll IR chip */
174 if (1 != i2c_master_recv(&ir->c,&b,1)) {
175 dprintk(1,"read error\n");
176 return -EIO;
177 }
178
179 /* it seems that 0xFE indicates that a button is still hold
Mauro Carvalho Chehab4f9c05a2005-11-08 21:37:36 -0800180 down, while 0xff indicates that no button is hold
181 down. 0xfe sequences are sometimes interrupted by 0xFF */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183 dprintk(2,"key %02x\n", b);
184
Mauro Carvalho Chehab4f9c05a2005-11-08 21:37:36 -0800185 if (b == 0xff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 return 0;
187
Mauro Carvalho Chehab4f9c05a2005-11-08 21:37:36 -0800188 if (b == 0xfe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 /* keep old data */
190 return 1;
191
192 *ir_key = b;
193 *ir_raw = b;
194 return 1;
195}
196
Sylvain Pascheb93eedb2006-03-25 23:14:42 -0300197/* Common (grey or coloured) pinnacle PCTV remote handling
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800198 *
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800199 */
Sylvain Pascheb93eedb2006-03-25 23:14:42 -0300200static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
201 int parity_offset, int marker, int code_modulo)
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800202{
203 unsigned char b[4];
204 unsigned int start = 0,parity = 0,code = 0;
205
206 /* poll IR chip */
207 if (4 != i2c_master_recv(&ir->c,b,4)) {
208 dprintk(2,"read error\n");
209 return -EIO;
210 }
211
Mauro Carvalho Chehab53c4e952007-03-29 08:42:30 -0300212 for (start = 0; start < ARRAY_SIZE(b); start++) {
Sylvain Pascheb93eedb2006-03-25 23:14:42 -0300213 if (b[start] == marker) {
214 code=b[(start+parity_offset+1)%4];
215 parity=b[(start+parity_offset)%4];
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800216 }
217 }
218
219 /* Empty Request */
220 if (parity==0)
221 return 0;
222
223 /* Repeating... */
224 if (ir->old == parity)
225 return 0;
226
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800227 ir->old = parity;
228
Sylvain Pascheb93eedb2006-03-25 23:14:42 -0300229 /* drop special codes when a key is held down a long time for the grey controller
230 In this case, the second bit of the code is asserted */
231 if (marker == 0xfe && (code & 0x40))
232 return 0;
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800233
Sylvain Pascheb93eedb2006-03-25 23:14:42 -0300234 code %= code_modulo;
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800235
236 *ir_raw = code;
237 *ir_key = code;
238
239 dprintk(1,"Pinnacle PCTV key %02x\n", code);
240
241 return 1;
242}
243
Sylvain Pascheb93eedb2006-03-25 23:14:42 -0300244/* The grey pinnacle PCTV remote
245 *
246 * There are one issue with this remote:
247 * - I2c packet does not change when the same key is pressed quickly. The workaround
248 * is to hold down each key for about half a second, so that another code is generated
249 * in the i2c packet, and the function can distinguish key presses.
250 *
251 * Sylvain Pasche <sylvain.pasche@gmail.com>
252 */
253int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
254{
255
256 return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
257}
258
259EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);
260
261
262/* The new pinnacle PCTV remote (with the colored buttons)
263 *
264 * Ricardo Cerqueira <v4l@cerqueira.org>
265 */
266int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
267{
268 /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
269 *
270 * this is the only value that results in 42 unique
271 * codes < 128
272 */
273
274 return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
275}
276
277EXPORT_SYMBOL_GPL(get_key_pinnacle_color);
Ricardo Cerqueira80696952005-11-13 16:07:49 -0800278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279/* ----------------------------------------------------------------------- */
280
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800281static void ir_key_poll(struct IR_i2c *ir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282{
283 static u32 ir_key, ir_raw;
284 int rc;
285
286 dprintk(2,"ir_poll_key\n");
287 rc = ir->get_key(ir, &ir_key, &ir_raw);
288 if (rc < 0) {
289 dprintk(2,"error\n");
290 return;
291 }
292
293 if (0 == rc) {
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500294 ir_input_nokey(ir->input, &ir->ir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 } else {
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500296 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 }
298}
299
300static void ir_timer(unsigned long data)
301{
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800302 struct IR_i2c *ir = (struct IR_i2c*)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 schedule_work(&ir->work);
304}
305
David Howellsc4028952006-11-22 14:57:56 +0000306static void ir_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
David Howellsc4028952006-11-22 14:57:56 +0000308 struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
Dmitry Torokhov8083c522007-05-21 11:51:11 -0300309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 ir_key_poll(ir);
Dmitry Torokhov8083c522007-05-21 11:51:11 -0300311 mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312}
313
314/* ----------------------------------------------------------------------- */
315
316static int ir_attach(struct i2c_adapter *adap, int addr,
317 unsigned short flags, int kind);
318static int ir_detach(struct i2c_client *client);
319static int ir_probe(struct i2c_adapter *adap);
320
321static struct i2c_driver driver = {
Laurent Riffard604f28e2005-11-26 20:43:39 +0100322 .driver = {
Mauro Carvalho Chehabcab462f2006-01-09 15:53:26 -0200323 .name = "ir-kbd-i2c",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100324 },
Mauro Carvalho Chehabdd815402005-12-12 00:37:31 -0800325 .id = I2C_DRIVERID_INFRARED,
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800326 .attach_adapter = ir_probe,
327 .detach_client = ir_detach,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328};
329
330static struct i2c_client client_template =
331{
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800332 .name = "unset",
333 .driver = &driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334};
335
336static int ir_attach(struct i2c_adapter *adap, int addr,
337 unsigned short flags, int kind)
338{
339 IR_KEYTAB_TYPE *ir_codes = NULL;
340 char *name;
341 int ir_type;
Mauro Carvalho Chehabafd1a0c2005-12-12 00:37:27 -0800342 struct IR_i2c *ir;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500343 struct input_dev *input_dev;
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300344 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Mauro Carvalho Chehab674434c2005-12-12 00:37:28 -0800346 ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500347 input_dev = input_allocate_device();
348 if (!ir || !input_dev) {
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300349 err = -ENOMEM;
350 goto err_out_free;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500351 }
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 ir->c = client_template;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500354 ir->input = input_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 ir->c.adapter = adap;
357 ir->c.addr = addr;
358
Mauro Carvalho Chehabd21838d2006-01-09 15:25:21 -0200359 i2c_set_clientdata(&ir->c, ir);
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 switch(addr) {
362 case 0x64:
363 name = "Pixelview";
364 ir->get_key = get_key_pixelview;
365 ir_type = IR_TYPE_OTHER;
366 ir_codes = ir_codes_empty;
367 break;
368 case 0x4b:
369 name = "PV951";
370 ir->get_key = get_key_pv951;
371 ir_type = IR_TYPE_OTHER;
372 ir_codes = ir_codes_pv951;
373 break;
374 case 0x18:
375 case 0x1a:
376 name = "Hauppauge";
377 ir->get_key = get_key_haup;
378 ir_type = IR_TYPE_RC5;
J.O. Ahobf47e4e2006-01-23 09:34:06 -0200379 if (hauppauge == 1) {
Ricardo Cerqueira4c0f6312006-01-23 09:42:06 -0200380 ir_codes = ir_codes_hauppauge_new;
J.O. Ahobf47e4e2006-01-23 09:34:06 -0200381 } else {
382 ir_codes = ir_codes_rc5_tv;
383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 break;
385 case 0x30:
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800386 name = "KNC One";
387 ir->get_key = get_key_knc1;
388 ir_type = IR_TYPE_OTHER;
389 ir_codes = ir_codes_empty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 break;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300391 case 0x6b:
Michael Krufky3c443582007-08-24 01:07:12 -0300392 name = "FusionHDTV";
393 ir->get_key = get_key_fusionhdtv;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300394 ir_type = IR_TYPE_RC5;
Michael Krufky3c443582007-08-24 01:07:12 -0300395 ir_codes = ir_codes_fusionhdtv_mce;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300396 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 case 0x7a:
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800398 case 0x47:
Thomas Genty177aaaf2006-11-29 21:57:24 -0300399 case 0x71:
Andrey J. Melnikoff (TEMHOTA)e8018c92008-01-07 05:17:39 -0300400 case 0x2d:
Jan Frey39cf1e82007-06-25 14:34:06 -0300401 if (adap->id == I2C_HW_B_CX2388x) {
402 /* Handled by cx88-input */
403 name = "CX2388x remote";
404 ir_type = IR_TYPE_RC5;
405 ir->get_key = get_key_haup_xvr;
406 if (hauppauge == 1) {
407 ir_codes = ir_codes_hauppauge_new;
408 } else {
409 ir_codes = ir_codes_rc5_tv;
410 }
411 } else {
412 /* Handled by saa7134-input */
413 name = "SAA713x remote";
414 ir_type = IR_TYPE_OTHER;
415 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 break;
417 default:
418 /* shouldn't happen */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300419 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
420 err = -ENODEV;
421 goto err_out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800424 /* Sets name */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300426 ir->ir_codes = ir_codes;
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800427
428 /* register i2c device
429 * At device register, IR codes may be changed to be
430 * board dependent.
Mauro Carvalho Chehab674434c2005-12-12 00:37:28 -0800431 */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300432 err = i2c_attach_client(&ir->c);
433 if (err)
434 goto err_out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800436 /* If IR not supported or disabled, unregisters driver */
437 if (ir->get_key == NULL) {
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300438 err = -ENODEV;
439 goto err_out_detach;
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800440 }
441
442 /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
443 snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
444 ir->c.adapter->dev.bus_id,
445 ir->c.dev.bus_id);
446
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 /* init + register input device */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300448 ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
Mauro Carvalho Chehabd21838d2006-01-09 15:25:21 -0200449 input_dev->id.bustype = BUS_I2C;
450 input_dev->name = ir->c.name;
451 input_dev->phys = ir->phys;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500452
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300453 err = input_register_device(ir->input);
454 if (err)
455 goto err_out_detach;
456
Mauro Carvalho Chehabd21838d2006-01-09 15:25:21 -0200457 printk(DEVNAME ": %s detected at %s [%s]\n",
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300458 ir->input->name, ir->input->phys, adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 /* start polling via eventd */
David Howellsc4028952006-11-22 14:57:56 +0000461 INIT_WORK(&ir->work, ir_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 init_timer(&ir->timer);
463 ir->timer.function = ir_timer;
464 ir->timer.data = (unsigned long)ir;
465 schedule_work(&ir->work);
466
467 return 0;
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300468
469 err_out_detach:
470 i2c_detach_client(&ir->c);
471 err_out_free:
472 input_free_device(input_dev);
473 kfree(ir);
474 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475}
476
477static int ir_detach(struct i2c_client *client)
478{
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800479 struct IR_i2c *ir = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
481 /* kill outstanding polls */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300482 del_timer_sync(&ir->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 flush_scheduled_work();
484
485 /* unregister devices */
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500486 input_unregister_device(ir->input);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 i2c_detach_client(&ir->c);
488
489 /* free memory */
490 kfree(ir);
491 return 0;
492}
493
494static int ir_probe(struct i2c_adapter *adap)
495{
496
497 /* The external IR receiver is at i2c address 0x34 (0x35 for
498 reads). Future Hauppauge cards will have an internal
499 receiver at 0x30 (0x31 for reads). In theory, both can be
500 fitted, and Hauppauge suggest an external overrides an
501 internal.
502
503 That's why we probe 0x1a (~0x34) first. CB
504 */
505
506 static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
Andrey J. Melnikoff (TEMHOTA)e8018c92008-01-07 05:17:39 -0300507 static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
Mauro Carvalho Chehabb296fc62005-11-08 21:38:37 -0800508 static const int probe_em28XX[] = { 0x30, 0x47, -1 };
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300509 static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
Michael Krufky9bc37ca2007-09-08 15:17:13 -0300510 static const int probe_cx23885[] = { 0x6b, -1 };
Jean Delvared6f34d72008-04-22 14:45:47 -0300511 const int *probe;
Jean Delvare37c45df2008-04-25 20:42:45 -0300512 struct i2c_msg msg = {
513 .flags = I2C_M_RD,
514 .len = 0,
515 .buf = NULL,
516 };
Marcin Slusarza5885852008-04-22 14:45:33 -0300517 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519 switch (adap->id) {
Jean Delvarec7a46532005-08-11 23:41:56 +0200520 case I2C_HW_B_BT848:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 probe = probe_bttv;
522 break;
Hans Verkuil51dab142006-03-25 08:10:12 -0300523 case I2C_HW_B_CX2341X:
Hans Verkuilc097b042006-03-30 19:57:28 -0300524 probe = probe_bttv;
Hans Verkuil51dab142006-03-25 08:10:12 -0300525 break;
Jean Delvare1684a9842005-08-11 23:51:10 +0200526 case I2C_HW_SAA7134:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 probe = probe_saa7134;
528 break;
Mauro Carvalho Chehabb296fc62005-11-08 21:38:37 -0800529 case I2C_HW_B_EM28XX:
530 probe = probe_em28XX;
Markus Rechbergerc3658642005-11-08 21:37:21 -0800531 break;
Jan Frey39cf1e82007-06-25 14:34:06 -0300532 case I2C_HW_B_CX2388x:
533 probe = probe_cx88;
Trent Piepho415a1972007-10-15 20:39:25 -0300534 break;
Michael Krufky9bc37ca2007-09-08 15:17:13 -0300535 case I2C_HW_B_CX23885:
536 probe = probe_cx23885;
Jan Frey39cf1e82007-06-25 14:34:06 -0300537 break;
Jean Delvared6f34d72008-04-22 14:45:47 -0300538 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 return 0;
Jean Delvared6f34d72008-04-22 14:45:47 -0300540 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800542 for (i = 0; -1 != probe[i]; i++) {
Jean Delvare37c45df2008-04-25 20:42:45 -0300543 msg.addr = probe[i];
544 rc = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 dprintk(1,"probe 0x%02x @ %s: %s\n",
546 probe[i], adap->name,
Jean Delvare37c45df2008-04-25 20:42:45 -0300547 (1 == rc) ? "yes" : "no");
548 if (1 == rc) {
Marcin Slusarza5885852008-04-22 14:45:33 -0300549 ir_attach(adap, probe[i], 0, 0);
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800550 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 }
552 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 return 0;
554}
555
556/* ----------------------------------------------------------------------- */
557
558MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
559MODULE_DESCRIPTION("input driver for i2c IR remote controls");
560MODULE_LICENSE("GPL");
561
562static int __init ir_init(void)
563{
564 return i2c_add_driver(&driver);
565}
566
567static void __exit ir_fini(void)
568{
569 i2c_del_driver(&driver);
570}
571
572module_init(ir_init);
573module_exit(ir_fini);
574
575/*
576 * Overrides for Emacs so that we follow Linus's tabbing style.
577 * ---------------------------------------------------------------------------
578 * Local variables:
579 * c-basic-offset: 8
580 * End:
581 */