SAFE public projects git trees. - safe/jmp/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  * modified for DViCO Fusion HDTV 5 RT GOLD by
  14  *      Chaogui Zhang <czhang1974@gmail.com>
  15  * modified for MSI TV@nywhere Plus by
  16  *      Henry Wong <henry@stuffedcow.net>
  17  *      Mark Schultz <n9xmj@yahoo.com>
  18  *      Brian Rogers <brian_rogers@comcast.net>
  19  * modified for AVerMedia Cardbus by
  20  *      Oldrich Jedlicka <oldium.pro@seznam.cz>
  21  *
  22  *  This program is free software; you can redistribute it and/or modify
  23  *  it under the terms of the GNU General Public License as published by
  24  *  the Free Software Foundation; either version 2 of the License, or
  25  *  (at your option) any later version.
  26  *
  27  *  This program is distributed in the hope that it will be useful,
  28  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  *  GNU General Public License for more details.
  31  *
  32  *  You should have received a copy of the GNU General Public License
  33  *  along with this program; if not, write to the Free Software
  34  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  35  *
  36  */
  37
  38 #include <linux/module.h>
  39 #include <linux/init.h>
  40 #include <linux/kernel.h>
  41 #include <linux/string.h>
  42 #include <linux/timer.h>
  43 #include <linux/delay.h>
  44 #include <linux/errno.h>
  45 #include <linux/slab.h>
  46 #include <linux/i2c.h>
  47 #include <linux/i2c-id.h>
  48 #include <linux/workqueue.h>
  49
  50 #include <media/ir-common.h>
  51 #include <media/ir-kbd-i2c.h>
  52
  53 /* ----------------------------------------------------------------------- */
  54 /* insmod parameters                                                       */
  55
  56 static int debug;
  57 module_param(debug, int, 0644);    /* debug level (0,1,2) */
  58
  59 static int hauppauge;
  60 module_param(hauppauge, int, 0644);    /* Choose Hauppauge remote */
  61 MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
  62
  63
  64 #define DEVNAME "ir-kbd-i2c"
  65 #define dprintk(level, fmt, arg...)     if (debug >= level) \
  66         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
  67
  68 /* ----------------------------------------------------------------------- */
  69
  70 static int get_key_haup_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
  71                                int size, int offset)
  72 {
  73         unsigned char buf[6];
  74         int start, range, toggle, dev, code, ircode;
  75
  76         /* poll IR chip */
  77         if (size != i2c_master_recv(&ir->c,buf,size))
  78                 return -EIO;
  79
  80         /* split rc5 data block ... */
  81         start  = (buf[offset] >> 7) &    1;
  82         range  = (buf[offset] >> 6) &    1;
  83         toggle = (buf[offset] >> 5) &    1;
  84         dev    =  buf[offset]       & 0x1f;
  85         code   = (buf[offset+1] >> 2) & 0x3f;
  86
  87         /* rc5 has two start bits
  88          * the first bit must be one
  89          * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
  90          */
  91         if (!start)
  92                 /* no key pressed */
  93                 return 0;
  94         /*
  95          * Hauppauge remotes (black/silver) always use
  96          * specific device ids. If we do not filter the
  97          * device ids then messages destined for devices
  98          * such as TVs (id=0) will get through causing
  99          * mis-fired events.
 100          *
 101          * We also filter out invalid key presses which
 102          * produce annoying debug log entries.
 103          */
 104         ircode= (start << 12) | (toggle << 11) | (dev << 6) | code;
 105         if ((ircode & 0x1fff)==0x1fff)
 106                 /* invalid key press */
 107                 return 0;
 108
 109         if (dev!=0x1e && dev!=0x1f)
 110                 /* not a hauppauge remote */
 111                 return 0;
 112
 113         if (!range)
 114                 code += 64;
 115
 116         dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
 117                 start, range, toggle, dev, code);
 118
 119         /* return key */
 120         *ir_key = code;
 121         *ir_raw = ircode;
 122         return 1;
 123 }
 124
 125 static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 126 {
 127         return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
 128 }
 129
 130 static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 131 {
 132         return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
 133 }
 134
 135 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 136 {
 137         unsigned char b;
 138
 139         /* poll IR chip */
 140         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 141                 dprintk(1,"read error\n");
 142                 return -EIO;
 143         }
 144         *ir_key = b;
 145         *ir_raw = b;
 146         return 1;
 147 }
 148
 149 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 150 {
 151         unsigned char b;
 152
 153         /* poll IR chip */
 154         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 155                 dprintk(1,"read error\n");
 156                 return -EIO;
 157         }
 158
 159         /* ignore 0xaa */
 160         if (b==0xaa)
 161                 return 0;
 162         dprintk(2,"key %02x\n", b);
 163
 164         *ir_key = b;
 165         *ir_raw = b;
 166         return 1;
 167 }
 168
 169 static int get_key_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 170 {
 171         unsigned char buf[4];
 172
 173         /* poll IR chip */
 174         if (4 != i2c_master_recv(&ir->c,buf,4)) {
 175                 dprintk(1,"read error\n");
 176                 return -EIO;
 177         }
 178
 179         if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
 180                 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
 181                         buf[0], buf[1], buf[2], buf[3]);
 182
 183         /* no key pressed or signal from other ir remote */
 184         if(buf[0] != 0x1 ||  buf[1] != 0xfe)
 185                 return 0;
 186
 187         *ir_key = buf[2];
 188         *ir_raw = (buf[2] << 8) | buf[3];
 189
 190         return 1;
 191 }
 192
 193 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 194 {
 195         unsigned char b;
 196
 197         /* poll IR chip */
 198         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 199                 dprintk(1,"read error\n");
 200                 return -EIO;
 201         }
 202
 203         /* it seems that 0xFE indicates that a button is still hold
 204            down, while 0xff indicates that no button is hold
 205            down. 0xfe sequences are sometimes interrupted by 0xFF */
 206
 207         dprintk(2,"key %02x\n", b);
 208
 209         if (b == 0xff)
 210                 return 0;
 211
 212         if (b == 0xfe)
 213                 /* keep old data */
 214                 return 1;
 215
 216         *ir_key = b;
 217         *ir_raw = b;
 218         return 1;
 219 }
 220
 221 static int get_key_avermedia_cardbus(struct IR_i2c *ir,
 222                                      u32 *ir_key, u32 *ir_raw)
 223 {
 224         unsigned char subaddr, key, keygroup;
 225         struct i2c_msg msg[] = { { .addr = ir->c.addr, .flags = 0,
 226                                    .buf = &subaddr, .len = 1},
 227                                  { .addr = ir->c.addr, .flags = I2C_M_RD,
 228                                   .buf = &key, .len = 1} };
 229         subaddr = 0x0d;
 230         if (2 != i2c_transfer(ir->c.adapter, msg, 2)) {
 231                 dprintk(1, "read error\n");
 232                 return -EIO;
 233         }
 234
 235         if (key == 0xff)
 236                 return 0;
 237
 238         subaddr = 0x0b;
 239         msg[1].buf = &keygroup;
 240         if (2 != i2c_transfer(ir->c.adapter, msg, 2)) {
 241                 dprintk(1, "read error\n");
 242                 return -EIO;
 243         }
 244
 245         if (keygroup == 0xff)
 246                 return 0;
 247
 248         dprintk(1, "read key 0x%02x/0x%02x\n", key, keygroup);
 249         if (keygroup < 2 || keygroup > 3) {
 250                 /* Only a warning */
 251                 dprintk(1, "warning: invalid key group 0x%02x for key 0x%02x\n",
 252                                                                 keygroup, key);
 253         }
 254         key |= (keygroup & 1) << 6;
 255
 256         *ir_key = key;
 257         *ir_raw = key;
 258         return 1;
 259 }
 260
 261 /* ----------------------------------------------------------------------- */
 262
 263 static void ir_key_poll(struct IR_i2c *ir)
 264 {
 265         static u32 ir_key, ir_raw;
 266         int rc;
 267
 268         dprintk(2,"ir_poll_key\n");
 269         rc = ir->get_key(ir, &ir_key, &ir_raw);
 270         if (rc < 0) {
 271                 dprintk(2,"error\n");
 272                 return;
 273         }
 274
 275         if (0 == rc) {
 276                 ir_input_nokey(ir->input, &ir->ir);
 277         } else {
 278                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 279         }
 280 }
 281
 282 static void ir_timer(unsigned long data)
 283 {
 284         struct IR_i2c *ir = (struct IR_i2c*)data;
 285         schedule_work(&ir->work);
 286 }
 287
 288 static void ir_work(struct work_struct *work)
 289 {
 290         struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
 291         int polling_interval = 100;
 292
 293         /* MSI TV@nywhere Plus requires more frequent polling
 294            otherwise it will miss some keypresses */
 295         if (ir->c.adapter->id == I2C_HW_SAA7134 && ir->c.addr == 0x30)
 296                 polling_interval = 50;
 297
 298         ir_key_poll(ir);
 299         mod_timer(&ir->timer, jiffies + msecs_to_jiffies(polling_interval));
 300 }
 301
 302 /* ----------------------------------------------------------------------- */
 303
 304 static int ir_attach(struct i2c_adapter *adap, int addr,
 305                       unsigned short flags, int kind);
 306 static int ir_detach(struct i2c_client *client);
 307 static int ir_probe(struct i2c_adapter *adap);
 308
 309 static struct i2c_driver driver = {
 310         .driver = {
 311                 .name   = "ir-kbd-i2c",
 312         },
 313         .id             = I2C_DRIVERID_INFRARED,
 314         .attach_adapter = ir_probe,
 315         .detach_client  = ir_detach,
 316 };
 317
 318 static struct i2c_client client_template =
 319 {
 320         .name = "unset",
 321         .driver = &driver
 322 };
 323
 324 static int ir_attach(struct i2c_adapter *adap, int addr,
 325                      unsigned short flags, int kind)
 326 {
 327         IR_KEYTAB_TYPE *ir_codes = NULL;
 328         char *name;
 329         int ir_type;
 330         struct IR_i2c *ir;
 331         struct input_dev *input_dev;
 332         int err;
 333
 334         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
 335         input_dev = input_allocate_device();
 336         if (!ir || !input_dev) {
 337                 err = -ENOMEM;
 338                 goto err_out_free;
 339         }
 340
 341         ir->c = client_template;
 342         ir->input = input_dev;
 343
 344         ir->c.adapter = adap;
 345         ir->c.addr    = addr;
 346
 347         i2c_set_clientdata(&ir->c, ir);
 348
 349         switch(addr) {
 350         case 0x64:
 351                 name        = "Pixelview";
 352                 ir->get_key = get_key_pixelview;
 353                 ir_type     = IR_TYPE_OTHER;
 354                 ir_codes    = ir_codes_empty;
 355                 break;
 356         case 0x4b:
 357                 name        = "PV951";
 358                 ir->get_key = get_key_pv951;
 359                 ir_type     = IR_TYPE_OTHER;
 360                 ir_codes    = ir_codes_pv951;
 361                 break;
 362         case 0x18:
 363         case 0x1a:
 364                 name        = "Hauppauge";
 365                 ir->get_key = get_key_haup;
 366                 ir_type     = IR_TYPE_RC5;
 367                 if (hauppauge == 1) {
 368                         ir_codes    = ir_codes_hauppauge_new;
 369                 } else {
 370                         ir_codes    = ir_codes_rc5_tv;
 371                 }
 372                 break;
 373         case 0x30:
 374                 name        = "KNC One";
 375                 ir->get_key = get_key_knc1;
 376                 ir_type     = IR_TYPE_OTHER;
 377                 ir_codes    = ir_codes_empty;
 378                 break;
 379         case 0x6b:
 380                 name        = "FusionHDTV";
 381                 ir->get_key = get_key_fusionhdtv;
 382                 ir_type     = IR_TYPE_RC5;
 383                 ir_codes    = ir_codes_fusionhdtv_mce;
 384                 break;
 385         case 0x7a:
 386         case 0x47:
 387         case 0x71:
 388         case 0x2d:
 389                 if (adap->id == I2C_HW_B_CX2388x) {
 390                         /* Handled by cx88-input */
 391                         name        = "CX2388x remote";
 392                         ir_type     = IR_TYPE_RC5;
 393                         ir->get_key = get_key_haup_xvr;
 394                         if (hauppauge == 1) {
 395                                 ir_codes    = ir_codes_hauppauge_new;
 396                         } else {
 397                                 ir_codes    = ir_codes_rc5_tv;
 398                         }
 399                 } else {
 400                         /* Handled by saa7134-input */
 401                         name        = "SAA713x remote";
 402                         ir_type     = IR_TYPE_OTHER;
 403                 }
 404                 break;
 405         case 0x40:
 406                 name        = "AVerMedia Cardbus remote";
 407                 ir->get_key = get_key_avermedia_cardbus;
 408                 ir_type     = IR_TYPE_OTHER;
 409                 ir_codes    = ir_codes_avermedia_cardbus;
 410                 break;
 411         default:
 412                 /* shouldn't happen */
 413                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
 414                 err = -ENODEV;
 415                 goto err_out_free;
 416         }
 417
 418         /* Sets name */
 419         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 420         ir->ir_codes = ir_codes;
 421
 422         /* register i2c device
 423          * At device register, IR codes may be changed to be
 424          * board dependent.
 425          */
 426         err = i2c_attach_client(&ir->c);
 427         if (err)
 428                 goto err_out_free;
 429
 430         /* If IR not supported or disabled, unregisters driver */
 431         if (ir->get_key == NULL) {
 432                 err = -ENODEV;
 433                 goto err_out_detach;
 434         }
 435
 436         /* Phys addr can only be set after attaching (for ir->c.dev) */
 437         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 438                  dev_name(&ir->c.adapter->dev),
 439                  dev_name(&ir->c.dev));
 440
 441         /* init + register input device */
 442         ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
 443         input_dev->id.bustype = BUS_I2C;
 444         input_dev->name       = ir->c.name;
 445         input_dev->phys       = ir->phys;
 446
 447         err = input_register_device(ir->input);
 448         if (err)
 449                 goto err_out_detach;
 450
 451         printk(DEVNAME ": %s detected at %s [%s]\n",
 452                ir->input->name, ir->input->phys, adap->name);
 453
 454         /* start polling via eventd */
 455         INIT_WORK(&ir->work, ir_work);
 456         init_timer(&ir->timer);
 457         ir->timer.function = ir_timer;
 458         ir->timer.data     = (unsigned long)ir;
 459         schedule_work(&ir->work);
 460
 461         return 0;
 462
 463  err_out_detach:
 464         i2c_detach_client(&ir->c);
 465  err_out_free:
 466         input_free_device(input_dev);
 467         kfree(ir);
 468         return err;
 469 }
 470
 471 static int ir_detach(struct i2c_client *client)
 472 {
 473         struct IR_i2c *ir = i2c_get_clientdata(client);
 474
 475         /* kill outstanding polls */
 476         del_timer_sync(&ir->timer);
 477         flush_scheduled_work();
 478
 479         /* unregister devices */
 480         input_unregister_device(ir->input);
 481         i2c_detach_client(&ir->c);
 482
 483         /* free memory */
 484         kfree(ir);
 485         return 0;
 486 }
 487
 488 static int ir_probe(struct i2c_adapter *adap)
 489 {
 490
 491         /* The external IR receiver is at i2c address 0x34 (0x35 for
 492            reads).  Future Hauppauge cards will have an internal
 493            receiver at 0x30 (0x31 for reads).  In theory, both can be
 494            fitted, and Hauppauge suggest an external overrides an
 495            internal.
 496
 497            That's why we probe 0x1a (~0x34) first. CB
 498         */
 499
 500         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 501         static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
 502         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 503         static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
 504         static const int probe_cx23885[] = { 0x6b, -1 };
 505         const int *probe;
 506         struct i2c_msg msg = {
 507                 .flags = I2C_M_RD,
 508                 .len = 0,
 509                 .buf = NULL,
 510         };
 511         int i, rc;
 512
 513         switch (adap->id) {
 514         case I2C_HW_B_BT848:
 515                 probe = probe_bttv;
 516                 break;
 517         case I2C_HW_B_CX2341X:
 518                 probe = probe_bttv;
 519                 break;
 520         case I2C_HW_SAA7134:
 521                 probe = probe_saa7134;
 522                 break;
 523         case I2C_HW_B_EM28XX:
 524                 probe = probe_em28XX;
 525                 break;
 526         case I2C_HW_B_CX2388x:
 527                 probe = probe_cx88;
 528                 break;
 529         case I2C_HW_B_CX23885:
 530                 probe = probe_cx23885;
 531                 break;
 532         default:
 533                 return 0;
 534         }
 535
 536         for (i = 0; -1 != probe[i]; i++) {
 537                 msg.addr = probe[i];
 538                 rc = i2c_transfer(adap, &msg, 1);
 539                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 540                         probe[i], adap->name,
 541                         (1 == rc) ? "yes" : "no");
 542                 if (1 == rc) {
 543                         ir_attach(adap, probe[i], 0, 0);
 544                         return 0;
 545                 }
 546         }
 547
 548         /* Special case for MSI TV@nywhere Plus remote */
 549         if (adap->id == I2C_HW_SAA7134) {
 550                 u8 temp;
 551
 552                 /* MSI TV@nywhere Plus controller doesn't seem to
 553                    respond to probes unless we read something from
 554                    an existing device. Weird... */
 555
 556                 msg.addr = 0x50;
 557                 rc = i2c_transfer(adap, &msg, 1);
 558                         dprintk(1, "probe 0x%02x @ %s: %s\n",
 559                         msg.addr, adap->name,
 560                         (1 == rc) ? "yes" : "no");
 561
 562                 /* Now do the probe. The controller does not respond
 563                    to 0-byte reads, so we use a 1-byte read instead. */
 564                 msg.addr = 0x30;
 565                 msg.len = 1;
 566                 msg.buf = &temp;
 567                 rc = i2c_transfer(adap, &msg, 1);
 568                 dprintk(1, "probe 0x%02x @ %s: %s\n",
 569                         msg.addr, adap->name,
 570                         (1 == rc) ? "yes" : "no");
 571                 if (1 == rc)
 572                         ir_attach(adap, msg.addr, 0, 0);
 573         }
 574
 575         /* Special case for AVerMedia Cardbus remote */
 576         if (adap->id == I2C_HW_SAA7134) {
 577                 unsigned char subaddr, data;
 578                 struct i2c_msg msg[] = { { .addr = 0x40, .flags = 0,
 579                                            .buf = &subaddr, .len = 1},
 580                                          { .addr = 0x40, .flags = I2C_M_RD,
 581                                            .buf = &data, .len = 1} };
 582                 subaddr = 0x0d;
 583                 rc = i2c_transfer(adap, msg, 2);
 584                 dprintk(1, "probe 0x%02x/0x%02x @ %s: %s\n",
 585                         msg[0].addr, subaddr, adap->name,
 586                         (2 == rc) ? "yes" : "no");
 587                 if (2 == rc)
 588                         ir_attach(adap, msg[0].addr, 0, 0);
 589         }
 590
 591         return 0;
 592 }
 593
 594 /* ----------------------------------------------------------------------- */
 595
 596 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 597 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 598 MODULE_LICENSE("GPL");
 599
 600 static int __init ir_init(void)
 601 {
 602         return i2c_add_driver(&driver);
 603 }
 604
 605 static void __exit ir_fini(void)
 606 {
 607         i2c_del_driver(&driver);
 608 }
 609
 610 module_init(ir_init);
 611 module_exit(ir_fini);
 612
 613 /*
 614  * Overrides for Emacs so that we follow Linus's tabbing style.
 615  * ---------------------------------------------------------------------------
 616  * Local variables:
 617  * c-basic-offset: 8
 618  * End:
 619  */