git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/ir-kbd-i2c.c

   1 /*
   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>
  11  * modified for em2820 based USB TV tuners by
  12  *      Markus Rechberger <mrechberger@gmail.com>
  13  *
  14  *  This program is free software; you can redistribute it and/or modify
  15  *  it under the terms of the GNU General Public License as published by
  16  *  the Free Software Foundation; either version 2 of the License, or
  17  *  (at your option) any later version.
  18  *
  19  *  This program is distributed in the hope that it will be useful,
  20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program; if not, write to the Free Software
  26  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27  *
  28  */
  29
  30 #include <linux/module.h>
  31 #include <linux/moduleparam.h>
  32 #include <linux/init.h>
  33 #include <linux/kernel.h>
  34 #include <linux/sched.h>
  35 #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>
  41 #include <linux/workqueue.h>
  42 #include <asm/semaphore.h>
  43
  44 #include <media/ir-common.h>
  45 #include <media/ir-kbd-i2c.h>
  46
  47 /* ----------------------------------------------------------------------- */
  48 /* insmod parameters                                                       */
  49
  50 static int debug;
  51 module_param(debug, int, 0644);    /* debug level (0,1,2) */
  52
  53 static int hauppauge = 0;
  54 module_param(hauppauge, int, 0644);    /* Choose Hauppauge remote */
  55 MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
  56
  57
  58 #define DEVNAME "ir-kbd-i2c"
  59 #define dprintk(level, fmt, arg...)     if (debug >= level) \
  60         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
  61
  62 /* ----------------------------------------------------------------------- */
  63
  64 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  65 {
  66         unsigned char buf[3];
  67         int start, toggle, dev, code;
  68
  69         /* poll IR chip */
  70         if (3 != i2c_master_recv(&ir->c,buf,3))
  71                 return -EIO;
  72
  73         /* split rc5 data block ... */
  74         start  = (buf[0] >> 6) &    3;
  75         toggle = (buf[0] >> 5) &    1;
  76         dev    =  buf[0]       & 0x1f;
  77         code   = (buf[1] >> 2) & 0x3f;
  78
  79         if (3 != start)
  80                 /* no key pressed */
  81                 return 0;
  82         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
  83                 start, toggle, dev, code);
  84
  85         /* return key */
  86         *ir_key = code;
  87         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
  88         return 1;
  89 }
  90
  91 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  92 {
  93         unsigned char b;
  94
  95         /* poll IR chip */
  96         if (1 != i2c_master_recv(&ir->c,&b,1)) {
  97                 dprintk(1,"read error\n");
  98                 return -EIO;
  99         }
 100         *ir_key = b;
 101         *ir_raw = b;
 102         return 1;
 103 }
 104
 105 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 106 {
 107         unsigned char b;
 108
 109         /* poll IR chip */
 110         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 111                 dprintk(1,"read error\n");
 112                 return -EIO;
 113         }
 114
 115         /* ignore 0xaa */
 116         if (b==0xaa)
 117                 return 0;
 118         dprintk(2,"key %02x\n", b);
 119
 120         *ir_key = b;
 121         *ir_raw = b;
 122         return 1;
 123 }
 124
 125 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 126 {
 127         unsigned char b;
 128
 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         /* it seems that 0xFE indicates that a button is still hold
 136            down, while 0xff indicates that no button is hold
 137            down. 0xfe sequences are sometimes interrupted by 0xFF */
 138
 139         dprintk(2,"key %02x\n", b);
 140
 141         if (b == 0xff)
 142                 return 0;
 143
 144         if (b == 0xfe)
 145                 /* keep old data */
 146                 return 1;
 147
 148         *ir_key = b;
 149         *ir_raw = b;
 150         return 1;
 151 }
 152
 153 /* Common (grey or coloured) pinnacle PCTV remote handling
 154  *
 155  */
 156 static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
 157                             int parity_offset, int marker, int code_modulo)
 158 {
 159         unsigned char b[4];
 160         unsigned int start = 0,parity = 0,code = 0;
 161
 162         /* poll IR chip */
 163         if (4 != i2c_master_recv(&ir->c,b,4)) {
 164                 dprintk(2,"read error\n");
 165                 return -EIO;
 166         }
 167
 168         for (start = 0; start<4; start++) {
 169                 if (b[start] == marker) {
 170                         code=b[(start+parity_offset+1)%4];
 171                         parity=b[(start+parity_offset)%4];
 172                 }
 173         }
 174
 175         /* Empty Request */
 176         if (parity==0)
 177                 return 0;
 178
 179         /* Repeating... */
 180         if (ir->old == parity)
 181                 return 0;
 182
 183         ir->old = parity;
 184
 185         /* drop special codes when a key is held down a long time for the grey controller
 186            In this case, the second bit of the code is asserted */
 187         if (marker == 0xfe && (code & 0x40))
 188                 return 0;
 189
 190         code %= code_modulo;
 191
 192         *ir_raw = code;
 193         *ir_key = code;
 194
 195         dprintk(1,"Pinnacle PCTV key %02x\n", code);
 196
 197         return 1;
 198 }
 199
 200 /* The grey pinnacle PCTV remote
 201  *
 202  *  There are one issue with this remote:
 203  *   - I2c packet does not change when the same key is pressed quickly. The workaround
 204  *     is to hold down each key for about half a second, so that another code is generated
 205  *     in the i2c packet, and the function can distinguish key presses.
 206  *
 207  * Sylvain Pasche <sylvain.pasche@gmail.com>
 208  */
 209 int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 210 {
 211
 212         return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
 213 }
 214
 215 EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);
 216
 217
 218 /* The new pinnacle PCTV remote (with the colored buttons)
 219  *
 220  * Ricardo Cerqueira <v4l@cerqueira.org>
 221  */
 222 int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 223 {
 224         /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
 225          *
 226          * this is the only value that results in 42 unique
 227          * codes < 128
 228          */
 229
 230         return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
 231 }
 232
 233 EXPORT_SYMBOL_GPL(get_key_pinnacle_color);
 234
 235 /* ----------------------------------------------------------------------- */
 236
 237 static void ir_key_poll(struct IR_i2c *ir)
 238 {
 239         static u32 ir_key, ir_raw;
 240         int rc;
 241
 242         dprintk(2,"ir_poll_key\n");
 243         rc = ir->get_key(ir, &ir_key, &ir_raw);
 244         if (rc < 0) {
 245                 dprintk(2,"error\n");
 246                 return;
 247         }
 248
 249         if (0 == rc) {
 250                 ir_input_nokey(ir->input, &ir->ir);
 251         } else {
 252                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 253         }
 254 }
 255
 256 static void ir_timer(unsigned long data)
 257 {
 258         struct IR_i2c *ir = (struct IR_i2c*)data;
 259         schedule_work(&ir->work);
 260 }
 261
 262 static void ir_work(void *data)
 263 {
 264         struct IR_i2c *ir = data;
 265         ir_key_poll(ir);
 266         mod_timer(&ir->timer, jiffies+HZ/10);
 267 }
 268
 269 /* ----------------------------------------------------------------------- */
 270
 271 static int ir_attach(struct i2c_adapter *adap, int addr,
 272                       unsigned short flags, int kind);
 273 static int ir_detach(struct i2c_client *client);
 274 static int ir_probe(struct i2c_adapter *adap);
 275
 276 static struct i2c_driver driver = {
 277         .driver = {
 278                 .name   = "ir-kbd-i2c",
 279         },
 280         .id             = I2C_DRIVERID_INFRARED,
 281         .attach_adapter = ir_probe,
 282         .detach_client  = ir_detach,
 283 };
 284
 285 static struct i2c_client client_template =
 286 {
 287         .name = "unset",
 288         .driver = &driver
 289 };
 290
 291 static int ir_attach(struct i2c_adapter *adap, int addr,
 292                      unsigned short flags, int kind)
 293 {
 294         IR_KEYTAB_TYPE *ir_codes = NULL;
 295         char *name;
 296         int ir_type;
 297         struct IR_i2c *ir;
 298         struct input_dev *input_dev;
 299
 300         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
 301         input_dev = input_allocate_device();
 302         if (!ir || !input_dev) {
 303                 input_free_device(input_dev);
 304                 kfree(ir);
 305                 return -ENOMEM;
 306         }
 307         memset(ir,0,sizeof(*ir));
 308
 309         ir->c = client_template;
 310         ir->input = input_dev;
 311
 312         ir->c.adapter = adap;
 313         ir->c.addr    = addr;
 314
 315         i2c_set_clientdata(&ir->c, ir);
 316
 317         switch(addr) {
 318         case 0x64:
 319                 name        = "Pixelview";
 320                 ir->get_key = get_key_pixelview;
 321                 ir_type     = IR_TYPE_OTHER;
 322                 ir_codes    = ir_codes_empty;
 323                 break;
 324         case 0x4b:
 325                 name        = "PV951";
 326                 ir->get_key = get_key_pv951;
 327                 ir_type     = IR_TYPE_OTHER;
 328                 ir_codes    = ir_codes_pv951;
 329                 break;
 330         case 0x18:
 331         case 0x1a:
 332                 name        = "Hauppauge";
 333                 ir->get_key = get_key_haup;
 334                 ir_type     = IR_TYPE_RC5;
 335                 if (hauppauge == 1) {
 336                         ir_codes    = ir_codes_hauppauge_new;
 337                 } else {
 338                         ir_codes    = ir_codes_rc5_tv;
 339                 }
 340                 break;
 341         case 0x30:
 342                 name        = "KNC One";
 343                 ir->get_key = get_key_knc1;
 344                 ir_type     = IR_TYPE_OTHER;
 345                 ir_codes    = ir_codes_empty;
 346                 break;
 347         case 0x7a:
 348         case 0x47:
 349                 /* Handled by saa7134-input */
 350                 name        = "SAA713x remote";
 351                 ir_type     = IR_TYPE_OTHER;
 352                 break;
 353         default:
 354                 /* shouldn't happen */
 355                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
 356                 kfree(ir);
 357                 return -1;
 358         }
 359
 360         /* Sets name */
 361         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 362         ir->ir_codes=ir_codes;
 363
 364         /* register i2c device
 365          * At device register, IR codes may be changed to be
 366          * board dependent.
 367          */
 368         i2c_attach_client(&ir->c);
 369
 370         /* If IR not supported or disabled, unregisters driver */
 371         if (ir->get_key == NULL) {
 372                 i2c_detach_client(&ir->c);
 373                 kfree(ir);
 374                 return -1;
 375         }
 376
 377         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 378         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 379                  ir->c.adapter->dev.bus_id,
 380                  ir->c.dev.bus_id);
 381
 382         /* init + register input device */
 383         ir_input_init(input_dev,&ir->ir,ir_type,ir->ir_codes);
 384         input_dev->id.bustype = BUS_I2C;
 385         input_dev->name       = ir->c.name;
 386         input_dev->phys       = ir->phys;
 387
 388         /* register event device */
 389         input_register_device(ir->input);
 390         printk(DEVNAME ": %s detected at %s [%s]\n",
 391                ir->input->name,ir->input->phys,adap->name);
 392
 393         /* start polling via eventd */
 394         INIT_WORK(&ir->work, ir_work, ir);
 395         init_timer(&ir->timer);
 396         ir->timer.function = ir_timer;
 397         ir->timer.data     = (unsigned long)ir;
 398         schedule_work(&ir->work);
 399
 400         return 0;
 401 }
 402
 403 static int ir_detach(struct i2c_client *client)
 404 {
 405         struct IR_i2c *ir = i2c_get_clientdata(client);
 406
 407         /* kill outstanding polls */
 408         del_timer(&ir->timer);
 409         flush_scheduled_work();
 410
 411         /* unregister devices */
 412         input_unregister_device(ir->input);
 413         i2c_detach_client(&ir->c);
 414
 415         /* free memory */
 416         kfree(ir);
 417         return 0;
 418 }
 419
 420 static int ir_probe(struct i2c_adapter *adap)
 421 {
 422
 423         /* The external IR receiver is at i2c address 0x34 (0x35 for
 424            reads).  Future Hauppauge cards will have an internal
 425            receiver at 0x30 (0x31 for reads).  In theory, both can be
 426            fitted, and Hauppauge suggest an external overrides an
 427            internal.
 428
 429            That's why we probe 0x1a (~0x34) first. CB
 430         */
 431
 432         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 433         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
 434         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 435         const int *probe = NULL;
 436         struct i2c_client c;
 437         unsigned char buf;
 438         int i,rc;
 439
 440         switch (adap->id) {
 441         case I2C_HW_B_BT848:
 442                 probe = probe_bttv;
 443                 break;
 444         case I2C_HW_B_CX2341X:
 445                 probe = probe_bttv;
 446                 break;
 447         case I2C_HW_SAA7134:
 448                 probe = probe_saa7134;
 449                 break;
 450         case I2C_HW_B_EM28XX:
 451                 probe = probe_em28XX;
 452                 break;
 453         }
 454         if (NULL == probe)
 455                 return 0;
 456
 457         memset(&c,0,sizeof(c));
 458         c.adapter = adap;
 459         for (i = 0; -1 != probe[i]; i++) {
 460                 c.addr = probe[i];
 461                 rc = i2c_master_recv(&c,&buf,0);
 462                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 463                         probe[i], adap->name,
 464                         (0 == rc) ? "yes" : "no");
 465                 if (0 == rc) {
 466                         ir_attach(adap,probe[i],0,0);
 467                         break;
 468                 }
 469         }
 470         return 0;
 471 }
 472
 473 /* ----------------------------------------------------------------------- */
 474
 475 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 476 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 477 MODULE_LICENSE("GPL");
 478
 479 static int __init ir_init(void)
 480 {
 481         return i2c_add_driver(&driver);
 482 }
 483
 484 static void __exit ir_fini(void)
 485 {
 486         i2c_del_driver(&driver);
 487 }
 488
 489 module_init(ir_init);
 490 module_exit(ir_fini);
 491
 492 /*
 493  * Overrides for Emacs so that we follow Linus's tabbing style.
 494  * ---------------------------------------------------------------------------
 495  * Local variables:
 496  * c-basic-offset: 8
 497  * End:
 498  */