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 #include <media/ir-common.h>
  44 #include <media/ir-kbd-i2c.h>
  45
  46 /* Mark Phalan <phalanm@o2.ie> */
  47 static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
  48         [  0 ] = KEY_KP0,
  49         [  1 ] = KEY_KP1,
  50         [  2 ] = KEY_KP2,
  51         [  3 ] = KEY_KP3,
  52         [  4 ] = KEY_KP4,
  53         [  5 ] = KEY_KP5,
  54         [  6 ] = KEY_KP6,
  55         [  7 ] = KEY_KP7,
  56         [  8 ] = KEY_KP8,
  57         [  9 ] = KEY_KP9,
  58
  59         [ 18 ] = KEY_POWER,
  60         [ 16 ] = KEY_MUTE,
  61         [ 31 ] = KEY_VOLUMEDOWN,
  62         [ 27 ] = KEY_VOLUMEUP,
  63         [ 26 ] = KEY_CHANNELUP,
  64         [ 30 ] = KEY_CHANNELDOWN,
  65         [ 14 ] = KEY_PAGEUP,
  66         [ 29 ] = KEY_PAGEDOWN,
  67         [ 19 ] = KEY_SOUND,
  68
  69         [ 24 ] = KEY_KPPLUSMINUS,       /* CH +/- */
  70         [ 22 ] = KEY_SUBTITLE,          /* CC */
  71         [ 13 ] = KEY_TEXT,              /* TTX */
  72         [ 11 ] = KEY_TV,                /* AIR/CBL */
  73         [ 17 ] = KEY_PC,                /* PC/TV */
  74         [ 23 ] = KEY_OK,                /* CH RTN */
  75         [ 25 ] = KEY_MODE,              /* FUNC */
  76         [ 12 ] = KEY_SEARCH,            /* AUTOSCAN */
  77
  78         /* Not sure what to do with these ones! */
  79         [ 15 ] = KEY_SELECT,            /* SOURCE */
  80         [ 10 ] = KEY_KPPLUS,            /* +100 */
  81         [ 20 ] = KEY_KPEQUAL,           /* SYNC */
  82         [ 28 ] = KEY_MEDIA,             /* PC/TV */
  83 };
  84
  85 static IR_KEYTAB_TYPE ir_codes_purpletv[IR_KEYTAB_SIZE] = {
  86         [ 0x3  ] = KEY_POWER,
  87         [ 0x6f ] = KEY_MUTE,
  88         [ 0x10 ] = KEY_BACKSPACE,       /* Recall */
  89
  90         [ 0x11 ] = KEY_KP0,
  91         [ 0x4  ] = KEY_KP1,
  92         [ 0x5  ] = KEY_KP2,
  93         [ 0x6  ] = KEY_KP3,
  94         [ 0x8  ] = KEY_KP4,
  95         [ 0x9  ] = KEY_KP5,
  96         [ 0xa  ] = KEY_KP6,
  97         [ 0xc  ] = KEY_KP7,
  98         [ 0xd  ] = KEY_KP8,
  99         [ 0xe  ] = KEY_KP9,
 100         [ 0x12 ] = KEY_KPDOT,           /* 100+ */
 101
 102         [ 0x7  ] = KEY_VOLUMEUP,
 103         [ 0xb  ] = KEY_VOLUMEDOWN,
 104         [ 0x1a ] = KEY_KPPLUS,
 105         [ 0x18 ] = KEY_KPMINUS,
 106         [ 0x15 ] = KEY_UP,
 107         [ 0x1d ] = KEY_DOWN,
 108         [ 0xf  ] = KEY_CHANNELUP,
 109         [ 0x13 ] = KEY_CHANNELDOWN,
 110         [ 0x48 ] = KEY_ZOOM,
 111
 112         [ 0x1b ] = KEY_VIDEO,           /* Video source */
 113         [ 0x49 ] = KEY_LANGUAGE,        /* MTS Select */
 114         [ 0x19 ] = KEY_SEARCH,          /* Auto Scan */
 115
 116         [ 0x4b ] = KEY_RECORD,
 117         [ 0x46 ] = KEY_PLAY,
 118         [ 0x45 ] = KEY_PAUSE,           /* Pause */
 119         [ 0x44 ] = KEY_STOP,
 120         [ 0x40 ] = KEY_FORWARD,         /* Forward ? */
 121         [ 0x42 ] = KEY_REWIND,          /* Backward ? */
 122
 123 };
 124
 125 static IR_KEYTAB_TYPE ir_codes_pinnacle[IR_KEYTAB_SIZE] = {
 126         [ 0x59 ] = KEY_MUTE,
 127         [ 0x4a ] = KEY_POWER,
 128
 129         [ 0x18 ] = KEY_TEXT,
 130         [ 0x26 ] = KEY_TV,
 131         [ 0x3d ] = KEY_PRINT,
 132
 133         [ 0x48 ] = KEY_RED,
 134         [ 0x04 ] = KEY_GREEN,
 135         [ 0x11 ] = KEY_YELLOW,
 136         [ 0x00 ] = KEY_BLUE,
 137
 138         [ 0x2d ] = KEY_VOLUMEUP,
 139         [ 0x1e ] = KEY_VOLUMEDOWN,
 140
 141         [ 0x49 ] = KEY_MENU,
 142
 143         [ 0x16 ] = KEY_CHANNELUP,
 144         [ 0x17 ] = KEY_CHANNELDOWN,
 145
 146         [ 0x20 ] = KEY_UP,
 147         [ 0x21 ] = KEY_DOWN,
 148         [ 0x22 ] = KEY_LEFT,
 149         [ 0x23 ] = KEY_RIGHT,
 150         [ 0x0d ] = KEY_SELECT,
 151
 152
 153
 154         [ 0x08 ] = KEY_BACK,
 155         [ 0x07 ] = KEY_REFRESH,
 156
 157         [ 0x2f ] = KEY_ZOOM,
 158         [ 0x29 ] = KEY_RECORD,
 159
 160         [ 0x4b ] = KEY_PAUSE,
 161         [ 0x4d ] = KEY_REWIND,
 162         [ 0x2e ] = KEY_PLAY,
 163         [ 0x4e ] = KEY_FORWARD,
 164         [ 0x53 ] = KEY_PREVIOUS,
 165         [ 0x4c ] = KEY_STOP,
 166         [ 0x54 ] = KEY_NEXT,
 167
 168         [ 0x69 ] = KEY_KP0,
 169         [ 0x6a ] = KEY_KP1,
 170         [ 0x6b ] = KEY_KP2,
 171         [ 0x6c ] = KEY_KP3,
 172         [ 0x6d ] = KEY_KP4,
 173         [ 0x6e ] = KEY_KP5,
 174         [ 0x6f ] = KEY_KP6,
 175         [ 0x70 ] = KEY_KP7,
 176         [ 0x71 ] = KEY_KP8,
 177         [ 0x72 ] = KEY_KP9,
 178
 179         [ 0x74 ] = KEY_CHANNEL,
 180         [ 0x0a ] = KEY_BACKSPACE,
 181 };
 182
 183 /* ----------------------------------------------------------------------- */
 184 /* insmod parameters                                                       */
 185
 186 static int debug;
 187 module_param(debug, int, 0644);    /* debug level (0,1,2) */
 188
 189 #define DEVNAME "ir-kbd-i2c"
 190 #define dprintk(level, fmt, arg...)     if (debug >= level) \
 191         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
 192
 193 /* ----------------------------------------------------------------------- */
 194
 195 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 196 {
 197         unsigned char buf[3];
 198         int start, toggle, dev, code;
 199
 200         /* poll IR chip */
 201         if (3 != i2c_master_recv(&ir->c,buf,3))
 202                 return -EIO;
 203
 204         /* split rc5 data block ... */
 205         start  = (buf[0] >> 6) &    3;
 206         toggle = (buf[0] >> 5) &    1;
 207         dev    =  buf[0]       & 0x1f;
 208         code   = (buf[1] >> 2) & 0x3f;
 209
 210         if (3 != start)
 211                 /* no key pressed */
 212                 return 0;
 213         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
 214                 start, toggle, dev, code);
 215
 216         /* return key */
 217         *ir_key = code;
 218         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
 219         return 1;
 220 }
 221
 222 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 223 {
 224         unsigned char b;
 225
 226         /* poll IR chip */
 227         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 228                 dprintk(1,"read error\n");
 229                 return -EIO;
 230         }
 231         *ir_key = b;
 232         *ir_raw = b;
 233         return 1;
 234 }
 235
 236 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 237 {
 238         unsigned char b;
 239
 240         /* poll IR chip */
 241         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 242                 dprintk(1,"read error\n");
 243                 return -EIO;
 244         }
 245
 246         /* ignore 0xaa */
 247         if (b==0xaa)
 248                 return 0;
 249         dprintk(2,"key %02x\n", b);
 250
 251         *ir_key = b;
 252         *ir_raw = b;
 253         return 1;
 254 }
 255
 256 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 257 {
 258         unsigned char b;
 259
 260         /* poll IR chip */
 261         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 262                 dprintk(1,"read error\n");
 263                 return -EIO;
 264         }
 265
 266         /* it seems that 0xFE indicates that a button is still hold
 267            down, while 0xff indicates that no button is hold
 268            down. 0xfe sequences are sometimes interrupted by 0xFF */
 269
 270         dprintk(2,"key %02x\n", b);
 271
 272         if (b == 0xff)
 273                 return 0;
 274
 275         if (b == 0xfe)
 276                 /* keep old data */
 277                 return 1;
 278
 279         *ir_key = b;
 280         *ir_raw = b;
 281         return 1;
 282 }
 283
 284 static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 285 {
 286         unsigned char b;
 287
 288         /* poll IR chip */
 289         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 290                 dprintk(1,"read error\n");
 291                 return -EIO;
 292         }
 293
 294         /* no button press */
 295         if (b==0)
 296                 return 0;
 297
 298         /* repeating */
 299         if (b & 0x80)
 300                 return 1;
 301
 302         *ir_key = b;
 303         *ir_raw = b;
 304         return 1;
 305 }
 306
 307 /* The new pinnacle PCTV remote (with the colored buttons)
 308  *
 309  * Ricardo Cerqueira <v4l@cerqueira.org>
 310  */
 311
 312 static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 313 {
 314         unsigned char b[4];
 315         unsigned int start = 0,parity = 0,code = 0;
 316
 317         /* poll IR chip */
 318         if (4 != i2c_master_recv(&ir->c,b,4)) {
 319                 dprintk(1,"read error\n");
 320                 return -EIO;
 321         }
 322
 323         for (start = 0; start<4; start++) {
 324                 if (b[start] == 0x80) {
 325                         code=b[(start+3)%4];
 326                         parity=b[(start+2)%4];
 327                 }
 328         }
 329
 330         /* Empty Request */
 331         if (parity==0)
 332                 return 0;
 333
 334         /* Repeating... */
 335         if (ir->old == parity)
 336                 return 0;
 337
 338
 339         ir->old = parity;
 340
 341         /* Reduce code value to fit inside IR_KEYTAB_SIZE
 342          *
 343          * this is the only value that results in 42 unique
 344          * codes < 128
 345          */
 346
 347         code %= 0x88;
 348
 349         *ir_raw = code;
 350         *ir_key = code;
 351
 352         dprintk(1,"Pinnacle PCTV key %02x\n", code);
 353
 354         return 1;
 355 }
 356
 357
 358 /* ----------------------------------------------------------------------- */
 359
 360 static void ir_key_poll(struct IR_i2c *ir)
 361 {
 362         static u32 ir_key, ir_raw;
 363         int rc;
 364
 365         dprintk(2,"ir_poll_key\n");
 366         rc = ir->get_key(ir, &ir_key, &ir_raw);
 367         if (rc < 0) {
 368                 dprintk(2,"error\n");
 369                 return;
 370         }
 371
 372         if (0 == rc) {
 373                 ir_input_nokey(ir->input, &ir->ir);
 374         } else {
 375                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 376         }
 377 }
 378
 379 static void ir_timer(unsigned long data)
 380 {
 381         struct IR_i2c *ir = (struct IR_i2c*)data;
 382         schedule_work(&ir->work);
 383 }
 384
 385 static void ir_work(void *data)
 386 {
 387         struct IR_i2c *ir = data;
 388         ir_key_poll(ir);
 389         mod_timer(&ir->timer, jiffies+HZ/10);
 390 }
 391
 392 /* ----------------------------------------------------------------------- */
 393
 394 static int ir_attach(struct i2c_adapter *adap, int addr,
 395                       unsigned short flags, int kind);
 396 static int ir_detach(struct i2c_client *client);
 397 static int ir_probe(struct i2c_adapter *adap);
 398
 399 static struct i2c_driver driver = {
 400         .name           = "ir remote kbd driver",
 401         .id             = I2C_DRIVERID_EXP3, /* FIXME */
 402         .flags          = I2C_DF_NOTIFY,
 403         .attach_adapter = ir_probe,
 404         .detach_client  = ir_detach,
 405 };
 406
 407 static struct i2c_client client_template =
 408 {
 409         .name = "unset",
 410         .driver = &driver
 411 };
 412
 413 static int ir_attach(struct i2c_adapter *adap, int addr,
 414                      unsigned short flags, int kind)
 415 {
 416         IR_KEYTAB_TYPE *ir_codes = NULL;
 417         char *name;
 418         int ir_type;
 419         struct IR_i2c *ir;
 420         struct input_dev *input_dev;
 421
 422         ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
 423         input_dev = input_allocate_device();
 424         if (!ir || !input_dev) {
 425                 kfree(ir);
 426                 input_free_device(input_dev);
 427                 return -ENOMEM;
 428         }
 429
 430         ir->c = client_template;
 431         ir->input = input_dev;
 432
 433         i2c_set_clientdata(&ir->c, ir);
 434         ir->c.adapter = adap;
 435         ir->c.addr    = addr;
 436
 437         switch(addr) {
 438         case 0x64:
 439                 name        = "Pixelview";
 440                 ir->get_key = get_key_pixelview;
 441                 ir_type     = IR_TYPE_OTHER;
 442                 ir_codes    = ir_codes_empty;
 443                 break;
 444         case 0x4b:
 445                 name        = "PV951";
 446                 ir->get_key = get_key_pv951;
 447                 ir_type     = IR_TYPE_OTHER;
 448                 ir_codes    = ir_codes_pv951;
 449                 break;
 450         case 0x18:
 451         case 0x1a:
 452                 name        = "Hauppauge";
 453                 ir->get_key = get_key_haup;
 454                 ir_type     = IR_TYPE_RC5;
 455                 ir_codes    = ir_codes_rc5_tv;
 456                 break;
 457         case 0x30:
 458                 name        = "KNC One";
 459                 ir->get_key = get_key_knc1;
 460                 ir_type     = IR_TYPE_OTHER;
 461                 ir_codes    = ir_codes_empty;
 462                 break;
 463         case 0x47:
 464                 name        = "Pinnacle PCTV";
 465                 ir->get_key = get_key_pinnacle;
 466                 ir_type     = IR_TYPE_OTHER;
 467                 ir_codes    = ir_codes_pinnacle;
 468                 break;
 469         case 0x7a:
 470                 name        = "Purple TV";
 471                 ir->get_key = get_key_purpletv;
 472                 ir_type     = IR_TYPE_OTHER;
 473                 ir_codes    = ir_codes_purpletv;
 474                 break;
 475
 476         default:
 477                 /* shouldn't happen */
 478                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
 479                 kfree(ir);
 480                 return -1;
 481         }
 482
 483         /* Sets name and its physical addr */
 484         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 485         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 486                  ir->c.adapter->dev.bus_id,
 487                  ir->c.dev.bus_id);
 488         ir->ir_codes=ir_codes;
 489
 490         /* register i2c device
 491          * At device register, IR codes may be changed to be
 492          * board dependent.
 493         */
 494         i2c_attach_client(&ir->c);
 495
 496         /* init + register input device */
 497         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
 498         input_dev->id.bustype   = BUS_I2C;
 499         input_dev->name         = ir->c.name;
 500         input_dev->phys         = ir->phys;
 501
 502         /* register event device */
 503         input_register_device(ir->input);
 504
 505         /* start polling via eventd */
 506         INIT_WORK(&ir->work, ir_work, ir);
 507         init_timer(&ir->timer);
 508         ir->timer.function = ir_timer;
 509         ir->timer.data     = (unsigned long)ir;
 510         schedule_work(&ir->work);
 511
 512         return 0;
 513 }
 514
 515 static int ir_detach(struct i2c_client *client)
 516 {
 517         struct IR_i2c *ir = i2c_get_clientdata(client);
 518
 519         /* kill outstanding polls */
 520         del_timer(&ir->timer);
 521         flush_scheduled_work();
 522
 523         /* unregister devices */
 524         input_unregister_device(ir->input);
 525         i2c_detach_client(&ir->c);
 526
 527         /* free memory */
 528         kfree(ir);
 529         return 0;
 530 }
 531
 532 static int ir_probe(struct i2c_adapter *adap)
 533 {
 534
 535         /* The external IR receiver is at i2c address 0x34 (0x35 for
 536            reads).  Future Hauppauge cards will have an internal
 537            receiver at 0x30 (0x31 for reads).  In theory, both can be
 538            fitted, and Hauppauge suggest an external overrides an
 539            internal.
 540
 541            That's why we probe 0x1a (~0x34) first. CB
 542         */
 543
 544         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 545         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
 546         static const int probe_em2820[] = { 0x30, 0x47, -1 };
 547         const int *probe = NULL;
 548         struct i2c_client c;
 549         unsigned char buf;
 550         int i,rc;
 551
 552         switch (adap->id) {
 553         case I2C_HW_B_BT848:
 554                 probe = probe_bttv;
 555                 break;
 556         case I2C_HW_SAA7134:
 557                 probe = probe_saa7134;
 558                 break;
 559         case I2C_HW_B_EM2820:
 560                 probe = probe_em2820;
 561                 break;
 562         }
 563         if (NULL == probe)
 564                 return 0;
 565
 566         memset(&c,0,sizeof(c));
 567         c.adapter = adap;
 568         for (i = 0; -1 != probe[i]; i++) {
 569                 c.addr = probe[i];
 570                 rc = i2c_master_recv(&c,&buf,0);
 571                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 572                         probe[i], adap->name,
 573                         (0 == rc) ? "yes" : "no");
 574                 if (0 == rc) {
 575                         ir_attach(adap,probe[i],0,0);
 576                         break;
 577                 }
 578         }
 579         return 0;
 580 }
 581
 582 /* ----------------------------------------------------------------------- */
 583
 584 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 585 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 586 MODULE_LICENSE("GPL");
 587
 588 static int __init ir_init(void)
 589 {
 590         return i2c_add_driver(&driver);
 591 }
 592
 593 static void __exit ir_fini(void)
 594 {
 595         i2c_del_driver(&driver);
 596 }
 597
 598 module_init(ir_init);
 599 module_exit(ir_fini);
 600
 601 /*
 602  * Overrides for Emacs so that we follow Linus's tabbing style.
 603  * ---------------------------------------------------------------------------
 604  * Local variables:
 605  * c-basic-offset: 8
 606  * End:
 607  */