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