blob: a30254bed3119ed8483270d7f6e8cdb79624da6f [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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197/* ----------------------------------------------------------------------- */
198
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800199static void ir_key_poll(struct IR_i2c *ir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 static u32 ir_key, ir_raw;
202 int rc;
203
204 dprintk(2,"ir_poll_key\n");
205 rc = ir->get_key(ir, &ir_key, &ir_raw);
206 if (rc < 0) {
207 dprintk(2,"error\n");
208 return;
209 }
210
211 if (0 == rc) {
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500212 ir_input_nokey(ir->input, &ir->ir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 } else {
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500214 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 }
216}
217
218static void ir_timer(unsigned long data)
219{
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800220 struct IR_i2c *ir = (struct IR_i2c*)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 schedule_work(&ir->work);
222}
223
David Howellsc4028952006-11-22 14:57:56 +0000224static void ir_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
David Howellsc4028952006-11-22 14:57:56 +0000226 struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
Dmitry Torokhov8083c522007-05-21 11:51:11 -0300227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 ir_key_poll(ir);
Dmitry Torokhov8083c522007-05-21 11:51:11 -0300229 mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
231
232/* ----------------------------------------------------------------------- */
233
234static int ir_attach(struct i2c_adapter *adap, int addr,
235 unsigned short flags, int kind);
236static int ir_detach(struct i2c_client *client);
237static int ir_probe(struct i2c_adapter *adap);
238
239static struct i2c_driver driver = {
Laurent Riffard604f28e2005-11-26 20:43:39 +0100240 .driver = {
Mauro Carvalho Chehabcab462f2006-01-09 15:53:26 -0200241 .name = "ir-kbd-i2c",
Laurent Riffard604f28e2005-11-26 20:43:39 +0100242 },
Mauro Carvalho Chehabdd815402005-12-12 00:37:31 -0800243 .id = I2C_DRIVERID_INFRARED,
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800244 .attach_adapter = ir_probe,
245 .detach_client = ir_detach,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246};
247
248static struct i2c_client client_template =
249{
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800250 .name = "unset",
251 .driver = &driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252};
253
254static int ir_attach(struct i2c_adapter *adap, int addr,
255 unsigned short flags, int kind)
256{
257 IR_KEYTAB_TYPE *ir_codes = NULL;
258 char *name;
259 int ir_type;
Mauro Carvalho Chehabafd1a0c2005-12-12 00:37:27 -0800260 struct IR_i2c *ir;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500261 struct input_dev *input_dev;
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300262 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Mauro Carvalho Chehab674434c2005-12-12 00:37:28 -0800264 ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500265 input_dev = input_allocate_device();
266 if (!ir || !input_dev) {
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300267 err = -ENOMEM;
268 goto err_out_free;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500269 }
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 ir->c = client_template;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500272 ir->input = input_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 ir->c.adapter = adap;
275 ir->c.addr = addr;
276
Mauro Carvalho Chehabd21838d2006-01-09 15:25:21 -0200277 i2c_set_clientdata(&ir->c, ir);
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 switch(addr) {
280 case 0x64:
281 name = "Pixelview";
282 ir->get_key = get_key_pixelview;
283 ir_type = IR_TYPE_OTHER;
284 ir_codes = ir_codes_empty;
285 break;
286 case 0x4b:
287 name = "PV951";
288 ir->get_key = get_key_pv951;
289 ir_type = IR_TYPE_OTHER;
290 ir_codes = ir_codes_pv951;
291 break;
292 case 0x18:
293 case 0x1a:
294 name = "Hauppauge";
295 ir->get_key = get_key_haup;
296 ir_type = IR_TYPE_RC5;
J.O. Ahobf47e4e2006-01-23 09:34:06 -0200297 if (hauppauge == 1) {
Ricardo Cerqueira4c0f6312006-01-23 09:42:06 -0200298 ir_codes = ir_codes_hauppauge_new;
J.O. Ahobf47e4e2006-01-23 09:34:06 -0200299 } else {
300 ir_codes = ir_codes_rc5_tv;
301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 break;
303 case 0x30:
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800304 name = "KNC One";
305 ir->get_key = get_key_knc1;
306 ir_type = IR_TYPE_OTHER;
307 ir_codes = ir_codes_empty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 break;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300309 case 0x6b:
Michael Krufky3c443582007-08-24 01:07:12 -0300310 name = "FusionHDTV";
311 ir->get_key = get_key_fusionhdtv;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300312 ir_type = IR_TYPE_RC5;
Michael Krufky3c443582007-08-24 01:07:12 -0300313 ir_codes = ir_codes_fusionhdtv_mce;
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300314 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 case 0x7a:
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800316 case 0x47:
Thomas Genty177aaaf2006-11-29 21:57:24 -0300317 case 0x71:
Andrey J. Melnikoff (TEMHOTA)e8018c92008-01-07 05:17:39 -0300318 case 0x2d:
Jan Frey39cf1e82007-06-25 14:34:06 -0300319 if (adap->id == I2C_HW_B_CX2388x) {
320 /* Handled by cx88-input */
321 name = "CX2388x remote";
322 ir_type = IR_TYPE_RC5;
323 ir->get_key = get_key_haup_xvr;
324 if (hauppauge == 1) {
325 ir_codes = ir_codes_hauppauge_new;
326 } else {
327 ir_codes = ir_codes_rc5_tv;
328 }
329 } else {
330 /* Handled by saa7134-input */
331 name = "SAA713x remote";
332 ir_type = IR_TYPE_OTHER;
333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 break;
335 default:
336 /* shouldn't happen */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300337 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
338 err = -ENODEV;
339 goto err_out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800342 /* Sets name */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300344 ir->ir_codes = ir_codes;
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800345
346 /* register i2c device
347 * At device register, IR codes may be changed to be
348 * board dependent.
Mauro Carvalho Chehab674434c2005-12-12 00:37:28 -0800349 */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300350 err = i2c_attach_client(&ir->c);
351 if (err)
352 goto err_out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800354 /* If IR not supported or disabled, unregisters driver */
355 if (ir->get_key == NULL) {
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300356 err = -ENODEV;
357 goto err_out_detach;
Ricardo Cerqueiraac9cd972005-11-08 21:37:56 -0800358 }
359
360 /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
361 snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
362 ir->c.adapter->dev.bus_id,
363 ir->c.dev.bus_id);
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 /* init + register input device */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300366 ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
Mauro Carvalho Chehabd21838d2006-01-09 15:25:21 -0200367 input_dev->id.bustype = BUS_I2C;
368 input_dev->name = ir->c.name;
369 input_dev->phys = ir->phys;
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500370
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300371 err = input_register_device(ir->input);
372 if (err)
373 goto err_out_detach;
374
Mauro Carvalho Chehabd21838d2006-01-09 15:25:21 -0200375 printk(DEVNAME ": %s detected at %s [%s]\n",
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300376 ir->input->name, ir->input->phys, adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378 /* start polling via eventd */
David Howellsc4028952006-11-22 14:57:56 +0000379 INIT_WORK(&ir->work, ir_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 init_timer(&ir->timer);
381 ir->timer.function = ir_timer;
382 ir->timer.data = (unsigned long)ir;
383 schedule_work(&ir->work);
384
385 return 0;
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300386
387 err_out_detach:
388 i2c_detach_client(&ir->c);
389 err_out_free:
390 input_free_device(input_dev);
391 kfree(ir);
392 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
395static int ir_detach(struct i2c_client *client)
396{
Mauro Carvalho Chehab4ac97912005-11-08 21:37:43 -0800397 struct IR_i2c *ir = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 /* kill outstanding polls */
Dmitry Torokhovb07b4782006-11-20 10:23:04 -0300400 del_timer_sync(&ir->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 flush_scheduled_work();
402
403 /* unregister devices */
Dmitry Torokhovb7df3912005-09-15 02:01:53 -0500404 input_unregister_device(ir->input);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 i2c_detach_client(&ir->c);
406
407 /* free memory */
408 kfree(ir);
409 return 0;
410}
411
412static int ir_probe(struct i2c_adapter *adap)
413{
414
415 /* The external IR receiver is at i2c address 0x34 (0x35 for
416 reads). Future Hauppauge cards will have an internal
417 receiver at 0x30 (0x31 for reads). In theory, both can be
418 fitted, and Hauppauge suggest an external overrides an
419 internal.
420
421 That's why we probe 0x1a (~0x34) first. CB
422 */
423
424 static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
Andrey J. Melnikoff (TEMHOTA)e8018c92008-01-07 05:17:39 -0300425 static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
Mauro Carvalho Chehabb296fc62005-11-08 21:38:37 -0800426 static const int probe_em28XX[] = { 0x30, 0x47, -1 };
Chaogui Zhangd54d6982007-08-24 01:02:32 -0300427 static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
Michael Krufky9bc37ca2007-09-08 15:17:13 -0300428 static const int probe_cx23885[] = { 0x6b, -1 };
Jean Delvared6f34d72008-04-22 14:45:47 -0300429 const int *probe;
Jean Delvare37c45df2008-04-25 20:42:45 -0300430 struct i2c_msg msg = {
431 .flags = I2C_M_RD,
432 .len = 0,
433 .buf = NULL,
434 };
Marcin Slusarza5885852008-04-22 14:45:33 -0300435 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
437 switch (adap->id) {
Jean Delvarec7a46532005-08-11 23:41:56 +0200438 case I2C_HW_B_BT848:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 probe = probe_bttv;
440 break;
Hans Verkuil51dab142006-03-25 08:10:12 -0300441 case I2C_HW_B_CX2341X:
Hans Verkuilc097b042006-03-30 19:57:28 -0300442 probe = probe_bttv;
Hans Verkuil51dab142006-03-25 08:10:12 -0300443 break;
Jean Delvare1684a9842005-08-11 23:51:10 +0200444 case I2C_HW_SAA7134:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 probe = probe_saa7134;
446 break;
Mauro Carvalho Chehabb296fc62005-11-08 21:38:37 -0800447 case I2C_HW_B_EM28XX:
448 probe = probe_em28XX;
Markus Rechbergerc3658642005-11-08 21:37:21 -0800449 break;
Jan Frey39cf1e82007-06-25 14:34:06 -0300450 case I2C_HW_B_CX2388x:
451 probe = probe_cx88;
Trent Piepho415a1972007-10-15 20:39:25 -0300452 break;
Michael Krufky9bc37ca2007-09-08 15:17:13 -0300453 case I2C_HW_B_CX23885:
454 probe = probe_cx23885;
Jan Frey39cf1e82007-06-25 14:34:06 -0300455 break;
Jean Delvared6f34d72008-04-22 14:45:47 -0300456 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return 0;
Jean Delvared6f34d72008-04-22 14:45:47 -0300458 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800460 for (i = 0; -1 != probe[i]; i++) {
Jean Delvare37c45df2008-04-25 20:42:45 -0300461 msg.addr = probe[i];
462 rc = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 dprintk(1,"probe 0x%02x @ %s: %s\n",
464 probe[i], adap->name,
Jean Delvare37c45df2008-04-25 20:42:45 -0300465 (1 == rc) ? "yes" : "no");
466 if (1 == rc) {
Marcin Slusarza5885852008-04-22 14:45:33 -0300467 ir_attach(adap, probe[i], 0, 0);
Mauro Carvalho Chehabd5e52652005-11-08 21:37:32 -0800468 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 return 0;
472}
473
474/* ----------------------------------------------------------------------- */
475
476MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
477MODULE_DESCRIPTION("input driver for i2c IR remote controls");
478MODULE_LICENSE("GPL");
479
480static int __init ir_init(void)
481{
482 return i2c_add_driver(&driver);
483}
484
485static void __exit ir_fini(void)
486{
487 i2c_del_driver(&driver);
488}
489
490module_init(ir_init);
491module_exit(ir_fini);
492
493/*
494 * Overrides for Emacs so that we follow Linus's tabbing style.
495 * ---------------------------------------------------------------------------
496 * Local variables:
497 * c-basic-offset: 8
498 * End:
499 */