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