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