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  *
  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 /* ----------------------------------------------------------------------- */
 126 /* insmod parameters                                                       */
 127
 128 static int debug;
 129 module_param(debug, int, 0644);    /* debug level (0,1,2) */
 130
 131 #define DEVNAME "ir-kbd-i2c"
 132 #define dprintk(level, fmt, arg...)     if (debug >= level) \
 133         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
 134
 135 /* ----------------------------------------------------------------------- */
 136
 137 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 138 {
 139         unsigned char buf[3];
 140         int start, toggle, dev, code;
 141
 142         /* poll IR chip */
 143         if (3 != i2c_master_recv(&ir->c,buf,3))
 144                 return -EIO;
 145
 146         /* split rc5 data block ... */
 147         start  = (buf[0] >> 6) &    3;
 148         toggle = (buf[0] >> 5) &    1;
 149         dev    =  buf[0]       & 0x1f;
 150         code   = (buf[1] >> 2) & 0x3f;
 151
 152         if (3 != start)
 153                 /* no key pressed */
 154                 return 0;
 155         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
 156                 start, toggle, dev, code);
 157
 158         /* return key */
 159         *ir_key = code;
 160         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
 161         return 1;
 162 }
 163
 164 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 165 {
 166         unsigned char b;
 167
 168         /* poll IR chip */
 169         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 170                 dprintk(1,"read error\n");
 171                 return -EIO;
 172         }
 173         *ir_key = b;
 174         *ir_raw = b;
 175         return 1;
 176 }
 177
 178 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 179 {
 180         unsigned char b;
 181
 182         /* poll IR chip */
 183         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 184                 dprintk(1,"read error\n");
 185                 return -EIO;
 186         }
 187
 188         /* ignore 0xaa */
 189         if (b==0xaa)
 190                 return 0;
 191         dprintk(2,"key %02x\n", b);
 192
 193         *ir_key = b;
 194         *ir_raw = b;
 195         return 1;
 196 }
 197
 198 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 199 {
 200         unsigned char b;
 201
 202         /* poll IR chip */
 203         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 204                 dprintk(1,"read error\n");
 205                 return -EIO;
 206         }
 207
 208         /* it seems that 0xFE indicates that a button is still hold
 209            down, while 0xFF indicates that no button is hold
 210            down. 0xFE sequences are sometimes interrupted by 0xFF */
 211
 212         dprintk(2,"key %02x\n", b);
 213
 214         if (b == 0xFF)
 215                 return 0;
 216
 217         if (b == 0xFE)
 218                 /* keep old data */
 219                 return 1;
 220
 221         *ir_key = b;
 222         *ir_raw = b;
 223         return 1;
 224 }
 225
 226 static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 227 {
 228         unsigned char b;
 229
 230         /* poll IR chip */
 231         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 232                 dprintk(1,"read error\n");
 233                 return -EIO;
 234         }
 235
 236         /* no button press */
 237         if (b==0)
 238                 return 0;
 239
 240         /* repeating */
 241         if (b & 0x80)
 242                 return 1;
 243
 244         *ir_key = b;
 245         *ir_raw = b;
 246         return 1;
 247 }
 248 /* ----------------------------------------------------------------------- */
 249
 250 static void ir_key_poll(struct IR_i2c *ir)
 251 {
 252         static u32 ir_key, ir_raw;
 253         int rc;
 254
 255         dprintk(2,"ir_poll_key\n");
 256         rc = ir->get_key(ir, &ir_key, &ir_raw);
 257         if (rc < 0) {
 258                 dprintk(2,"error\n");
 259                 return;
 260         }
 261
 262         if (0 == rc) {
 263                 ir_input_nokey(ir->input, &ir->ir);
 264         } else {
 265                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 266         }
 267 }
 268
 269 static void ir_timer(unsigned long data)
 270 {
 271         struct IR_i2c *ir = (struct IR_i2c*)data;
 272         schedule_work(&ir->work);
 273 }
 274
 275 static void ir_work(void *data)
 276 {
 277         struct IR_i2c *ir = data;
 278         ir_key_poll(ir);
 279         mod_timer(&ir->timer, jiffies+HZ/10);
 280 }
 281
 282 /* ----------------------------------------------------------------------- */
 283
 284 static int ir_attach(struct i2c_adapter *adap, int addr,
 285                       unsigned short flags, int kind);
 286 static int ir_detach(struct i2c_client *client);
 287 static int ir_probe(struct i2c_adapter *adap);
 288
 289 static struct i2c_driver driver = {
 290         .name           = "ir remote kbd driver",
 291         .id             = I2C_DRIVERID_EXP3, /* FIXME */
 292         .flags          = I2C_DF_NOTIFY,
 293         .attach_adapter = ir_probe,
 294         .detach_client  = ir_detach,
 295 };
 296
 297 static struct i2c_client client_template =
 298 {
 299         .name = "unset",
 300         .driver = &driver
 301 };
 302
 303 static int ir_attach(struct i2c_adapter *adap, int addr,
 304                      unsigned short flags, int kind)
 305 {
 306         IR_KEYTAB_TYPE *ir_codes = NULL;
 307         char *name;
 308         int ir_type;
 309         struct IR_i2c *ir;
 310         struct input_dev *input_dev;
 311
 312         ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
 313         input_dev = input_allocate_device();
 314         if (!ir || !input_dev) {
 315                 kfree(ir);
 316                 input_free_device(input_dev);
 317                 return -ENOMEM;
 318         }
 319
 320         ir->c = client_template;
 321         ir->input = input_dev;
 322
 323         i2c_set_clientdata(&ir->c, ir);
 324         ir->c.adapter = adap;
 325         ir->c.addr    = addr;
 326
 327         switch(addr) {
 328         case 0x64:
 329                 name        = "Pixelview";
 330                 ir->get_key = get_key_pixelview;
 331                 ir_type     = IR_TYPE_OTHER;
 332                 ir_codes    = ir_codes_empty;
 333                 break;
 334         case 0x4b:
 335                 name        = "PV951";
 336                 ir->get_key = get_key_pv951;
 337                 ir_type     = IR_TYPE_OTHER;
 338                 ir_codes    = ir_codes_pv951;
 339                 break;
 340         case 0x18:
 341         case 0x1a:
 342                 name        = "Hauppauge";
 343                 ir->get_key = get_key_haup;
 344                 ir_type     = IR_TYPE_RC5;
 345                 ir_codes    = ir_codes_rc5_tv;
 346                 break;
 347         case 0x30:
 348                 name        = "KNC One";
 349                 ir->get_key = get_key_knc1;
 350                 ir_type     = IR_TYPE_OTHER;
 351                 ir_codes    = ir_codes_empty;
 352                 break;
 353         case 0x7a:
 354                 name        = "Purple TV";
 355                 ir->get_key = get_key_purpletv;
 356                 ir_type     = IR_TYPE_OTHER;
 357                 ir_codes    = ir_codes_purpletv;
 358                 break;
 359
 360         default:
 361                 /* shouldn't happen */
 362                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
 363                 kfree(ir);
 364                 return -1;
 365         }
 366
 367         /* Sets name and its physical addr */
 368         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 369         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 370                  ir->c.adapter->dev.bus_id,
 371                  ir->c.dev.bus_id);
 372         ir->ir_codes=ir_codes;
 373
 374         /* register i2c device
 375          * At device register, IR codes may be changed to be
 376          * board dependent.
 377         */
 378         i2c_attach_client(&ir->c);
 379
 380         /* init + register input device */
 381         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
 382         input_dev->id.bustype   = BUS_I2C;
 383         input_dev->name         = ir->c.name;
 384         input_dev->phys         = ir->phys;
 385
 386         /* register event device */
 387         input_register_device(ir->input);
 388
 389         /* start polling via eventd */
 390         INIT_WORK(&ir->work, ir_work, ir);
 391         init_timer(&ir->timer);
 392         ir->timer.function = ir_timer;
 393         ir->timer.data     = (unsigned long)ir;
 394         schedule_work(&ir->work);
 395
 396         return 0;
 397 }
 398
 399 static int ir_detach(struct i2c_client *client)
 400 {
 401         struct IR_i2c *ir = i2c_get_clientdata(client);
 402
 403         /* kill outstanding polls */
 404         del_timer(&ir->timer);
 405         flush_scheduled_work();
 406
 407         /* unregister devices */
 408         input_unregister_device(ir->input);
 409         i2c_detach_client(&ir->c);
 410
 411         /* free memory */
 412         kfree(ir);
 413         return 0;
 414 }
 415
 416 static int ir_probe(struct i2c_adapter *adap)
 417 {
 418
 419         /* The external IR receiver is at i2c address 0x34 (0x35 for
 420            reads).  Future Hauppauge cards will have an internal
 421            receiver at 0x30 (0x31 for reads).  In theory, both can be
 422            fitted, and Hauppauge suggest an external overrides an
 423            internal.
 424
 425            That's why we probe 0x1a (~0x34) first. CB
 426         */
 427
 428         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 429         static const int probe_saa7134[] = { 0x7a, -1 };
 430         static const int probe_em2820[] = { 0x30, 0x47, -1 };
 431         const int *probe = NULL;
 432         struct i2c_client c; unsigned char buf; int i,rc;
 433
 434         switch (adap->id) {
 435         case I2C_HW_B_BT848:
 436                 probe = probe_bttv;
 437                 break;
 438         case I2C_HW_SAA7134:
 439                 probe = probe_saa7134;
 440                 break;
 441         case I2C_HW_B_EM2820:
 442                 probe = probe_em2820;
 443                 break;
 444         }
 445         if (NULL == probe)
 446                 return 0;
 447
 448         memset(&c,0,sizeof(c));
 449         c.adapter = adap;
 450         for (i = 0; -1 != probe[i]; i++) {
 451                 c.addr = probe[i];
 452                 rc = i2c_master_recv(&c,&buf,0);
 453                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 454                         probe[i], adap->name,
 455                         (0 == rc) ? "yes" : "no");
 456                 if (0 == rc) {
 457                         ir_attach(adap,probe[i],0,0);
 458                         break;
 459                 }
 460         }
 461         return 0;
 462 }
 463
 464 /* ----------------------------------------------------------------------- */
 465
 466 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 467 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 468 MODULE_LICENSE("GPL");
 469
 470 static int __init ir_init(void)
 471 {
 472         return i2c_add_driver(&driver);
 473 }
 474
 475 static void __exit ir_fini(void)
 476 {
 477         i2c_del_driver(&driver);
 478 }
 479
 480 module_init(ir_init);
 481 module_exit(ir_fini);
 482
 483 /*
 484  * Overrides for Emacs so that we follow Linus's tabbing style.
 485  * ---------------------------------------------------------------------------
 486  * Local variables:
 487  * c-basic-offset: 8
 488  * End:
 489  */