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