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