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 /* ----------------------------------------------------------------------- */
  86 /* insmod parameters                                                       */
  87
  88 static int debug;
  89 module_param(debug, int, 0644);    /* debug level (0,1,2) */
  90
  91 #define DEVNAME "ir-kbd-i2c"
  92 #define dprintk(level, fmt, arg...)     if (debug >= level) \
  93         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
  94
  95 /* ----------------------------------------------------------------------- */
  96
  97 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  98 {
  99         unsigned char buf[3];
 100         int start, toggle, dev, code;
 101
 102         /* poll IR chip */
 103         if (3 != i2c_master_recv(&ir->c,buf,3))
 104                 return -EIO;
 105
 106         /* split rc5 data block ... */
 107         start  = (buf[0] >> 6) &    3;
 108         toggle = (buf[0] >> 5) &    1;
 109         dev    =  buf[0]       & 0x1f;
 110         code   = (buf[1] >> 2) & 0x3f;
 111
 112         if (3 != start)
 113                 /* no key pressed */
 114                 return 0;
 115         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
 116                 start, toggle, dev, code);
 117
 118         /* return key */
 119         *ir_key = code;
 120         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
 121         return 1;
 122 }
 123
 124 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 125 {
 126         unsigned char b;
 127
 128         /* poll IR chip */
 129         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 130                 dprintk(1,"read error\n");
 131                 return -EIO;
 132         }
 133         *ir_key = b;
 134         *ir_raw = b;
 135         return 1;
 136 }
 137
 138 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 139 {
 140         unsigned char b;
 141
 142         /* poll IR chip */
 143         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 144                 dprintk(1,"read error\n");
 145                 return -EIO;
 146         }
 147
 148         /* ignore 0xaa */
 149         if (b==0xaa)
 150                 return 0;
 151         dprintk(2,"key %02x\n", b);
 152
 153         *ir_key = b;
 154         *ir_raw = b;
 155         return 1;
 156 }
 157
 158 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 159 {
 160         unsigned char b;
 161
 162         /* poll IR chip */
 163         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 164                 dprintk(1,"read error\n");
 165                 return -EIO;
 166         }
 167
 168         /* it seems that 0xFE indicates that a button is still hold
 169            down, while 0xff indicates that no button is hold
 170            down. 0xfe sequences are sometimes interrupted by 0xFF */
 171
 172         dprintk(2,"key %02x\n", b);
 173
 174         if (b == 0xff)
 175                 return 0;
 176
 177         if (b == 0xfe)
 178                 /* keep old data */
 179                 return 1;
 180
 181         *ir_key = b;
 182         *ir_raw = b;
 183         return 1;
 184 }
 185
 186 /* The new pinnacle PCTV remote (with the colored buttons)
 187  *
 188  * Ricardo Cerqueira <v4l@cerqueira.org>
 189  */
 190
 191 int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 192 {
 193         unsigned char b[4];
 194         unsigned int start = 0,parity = 0,code = 0;
 195
 196         /* poll IR chip */
 197         if (4 != i2c_master_recv(&ir->c,b,4)) {
 198                 dprintk(2,"read error\n");
 199                 return -EIO;
 200         }
 201
 202         for (start = 0; start<4; start++) {
 203                 if (b[start] == 0x80) {
 204                         code=b[(start+3)%4];
 205                         parity=b[(start+2)%4];
 206                 }
 207         }
 208
 209         /* Empty Request */
 210         if (parity==0)
 211                 return 0;
 212
 213         /* Repeating... */
 214         if (ir->old == parity)
 215                 return 0;
 216
 217
 218         ir->old = parity;
 219
 220         /* Reduce code value to fit inside IR_KEYTAB_SIZE
 221          *
 222          * this is the only value that results in 42 unique
 223          * codes < 128
 224          */
 225
 226         code %= 0x88;
 227
 228         *ir_raw = code;
 229         *ir_key = code;
 230
 231         dprintk(1,"Pinnacle PCTV key %02x\n", code);
 232
 233         return 1;
 234 }
 235
 236 EXPORT_SYMBOL_GPL(get_key_pinnacle);
 237
 238 /* ----------------------------------------------------------------------- */
 239
 240 static void ir_key_poll(struct IR_i2c *ir)
 241 {
 242         static u32 ir_key, ir_raw;
 243         int rc;
 244
 245         dprintk(2,"ir_poll_key\n");
 246         rc = ir->get_key(ir, &ir_key, &ir_raw);
 247         if (rc < 0) {
 248                 dprintk(2,"error\n");
 249                 return;
 250         }
 251
 252         if (0 == rc) {
 253                 ir_input_nokey(ir->input, &ir->ir);
 254         } else {
 255                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 256         }
 257 }
 258
 259 static void ir_timer(unsigned long data)
 260 {
 261         struct IR_i2c *ir = (struct IR_i2c*)data;
 262         schedule_work(&ir->work);
 263 }
 264
 265 static void ir_work(void *data)
 266 {
 267         struct IR_i2c *ir = data;
 268         ir_key_poll(ir);
 269         mod_timer(&ir->timer, jiffies+HZ/10);
 270 }
 271
 272 /* ----------------------------------------------------------------------- */
 273
 274 static int ir_attach(struct i2c_adapter *adap, int addr,
 275                       unsigned short flags, int kind);
 276 static int ir_detach(struct i2c_client *client);
 277 static int ir_probe(struct i2c_adapter *adap);
 278
 279 static struct i2c_driver driver = {
 280         .name           = "ir remote kbd driver",
 281         .id             = I2C_DRIVERID_EXP3, /* FIXME */
 282         .flags          = I2C_DF_NOTIFY,
 283         .attach_adapter = ir_probe,
 284         .detach_client  = ir_detach,
 285 };
 286
 287 static struct i2c_client client_template =
 288 {
 289         .name = "unset",
 290         .driver = &driver
 291 };
 292
 293 static int ir_attach(struct i2c_adapter *adap, int addr,
 294                      unsigned short flags, int kind)
 295 {
 296         IR_KEYTAB_TYPE *ir_codes = NULL;
 297         char *name;
 298         int ir_type;
 299         struct IR_i2c *ir;
 300         struct input_dev *input_dev;
 301
 302         ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
 303         input_dev = input_allocate_device();
 304         if (!ir || !input_dev) {
 305                 kfree(ir);
 306                 input_free_device(input_dev);
 307                 return -ENOMEM;
 308         }
 309
 310         ir->c = client_template;
 311         ir->input = input_dev;
 312
 313         i2c_set_clientdata(&ir->c, ir);
 314         ir->c.adapter = adap;
 315         ir->c.addr    = addr;
 316
 317         switch(addr) {
 318         case 0x64:
 319                 name        = "Pixelview";
 320                 ir->get_key = get_key_pixelview;
 321                 ir_type     = IR_TYPE_OTHER;
 322                 ir_codes    = ir_codes_empty;
 323                 break;
 324         case 0x4b:
 325                 name        = "PV951";
 326                 ir->get_key = get_key_pv951;
 327                 ir_type     = IR_TYPE_OTHER;
 328                 ir_codes    = ir_codes_pv951;
 329                 break;
 330         case 0x18:
 331         case 0x1a:
 332                 name        = "Hauppauge";
 333                 ir->get_key = get_key_haup;
 334                 ir_type     = IR_TYPE_RC5;
 335                 ir_codes    = ir_codes_rc5_tv;
 336                 break;
 337         case 0x30:
 338                 name        = "KNC One";
 339                 ir->get_key = get_key_knc1;
 340                 ir_type     = IR_TYPE_OTHER;
 341                 ir_codes    = ir_codes_empty;
 342                 break;
 343         case 0x7a:
 344         case 0x47:
 345                 /* Handled by saa7134-input */
 346                 name        = "SAA713x remote";
 347                 ir_type     = IR_TYPE_OTHER;
 348                 break;
 349         default:
 350                 /* shouldn't happen */
 351                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
 352                 kfree(ir);
 353                 return -1;
 354         }
 355
 356         /* Sets name */
 357         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 358         ir->ir_codes=ir_codes;
 359
 360         /* register i2c device
 361          * At device register, IR codes may be changed to be
 362          * board dependent.
 363         */
 364         i2c_attach_client(&ir->c);
 365
 366         /* If IR not supported or disabled, unregisters driver */
 367         if (ir->get_key == NULL) {
 368                 i2c_detach_client(&ir->c);
 369                 kfree(ir);
 370                 return -1;
 371         }
 372
 373         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 374         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 375                  ir->c.adapter->dev.bus_id,
 376                  ir->c.dev.bus_id);
 377
 378         /* init + register input device */
 379         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
 380         input_dev->id.bustype   = BUS_I2C;
 381         input_dev->name         = ir->c.name;
 382         input_dev->phys         = ir->phys;
 383
 384         /* register event device */
 385         input_register_device(ir->input);
 386
 387         /* start polling via eventd */
 388         INIT_WORK(&ir->work, ir_work, ir);
 389         init_timer(&ir->timer);
 390         ir->timer.function = ir_timer;
 391         ir->timer.data     = (unsigned long)ir;
 392         schedule_work(&ir->work);
 393
 394         return 0;
 395 }
 396
 397 static int ir_detach(struct i2c_client *client)
 398 {
 399         struct IR_i2c *ir = i2c_get_clientdata(client);
 400
 401         /* kill outstanding polls */
 402         del_timer(&ir->timer);
 403         flush_scheduled_work();
 404
 405         /* unregister devices */
 406         input_unregister_device(ir->input);
 407         i2c_detach_client(&ir->c);
 408
 409         /* free memory */
 410         kfree(ir);
 411         return 0;
 412 }
 413
 414 static int ir_probe(struct i2c_adapter *adap)
 415 {
 416
 417         /* The external IR receiver is at i2c address 0x34 (0x35 for
 418            reads).  Future Hauppauge cards will have an internal
 419            receiver at 0x30 (0x31 for reads).  In theory, both can be
 420            fitted, and Hauppauge suggest an external overrides an
 421            internal.
 422
 423            That's why we probe 0x1a (~0x34) first. CB
 424         */
 425
 426         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 427         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
 428         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 429         const int *probe = NULL;
 430         struct i2c_client c;
 431         unsigned char buf;
 432         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_EM28XX:
 442                 probe = probe_em28XX;
 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  */