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
  44 #include <media/ir-common.h>
  45 #include <media/ir-kbd-i2c.h>
  46
  47 /* Mark Phalan <phalanm@o2.ie> */
  48 static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
  49         [  0 ] = KEY_KP0,
  50         [  1 ] = KEY_KP1,
  51         [  2 ] = KEY_KP2,
  52         [  3 ] = KEY_KP3,
  53         [  4 ] = KEY_KP4,
  54         [  5 ] = KEY_KP5,
  55         [  6 ] = KEY_KP6,
  56         [  7 ] = KEY_KP7,
  57         [  8 ] = KEY_KP8,
  58         [  9 ] = KEY_KP9,
  59
  60         [ 18 ] = KEY_POWER,
  61         [ 16 ] = KEY_MUTE,
  62         [ 31 ] = KEY_VOLUMEDOWN,
  63         [ 27 ] = KEY_VOLUMEUP,
  64         [ 26 ] = KEY_CHANNELUP,
  65         [ 30 ] = KEY_CHANNELDOWN,
  66         [ 14 ] = KEY_PAGEUP,
  67         [ 29 ] = KEY_PAGEDOWN,
  68         [ 19 ] = KEY_SOUND,
  69
  70         [ 24 ] = KEY_KPPLUSMINUS,       /* CH +/- */
  71         [ 22 ] = KEY_SUBTITLE,          /* CC */
  72         [ 13 ] = KEY_TEXT,              /* TTX */
  73         [ 11 ] = KEY_TV,                /* AIR/CBL */
  74         [ 17 ] = KEY_PC,                /* PC/TV */
  75         [ 23 ] = KEY_OK,                /* CH RTN */
  76         [ 25 ] = KEY_MODE,              /* FUNC */
  77         [ 12 ] = KEY_SEARCH,            /* AUTOSCAN */
  78
  79         /* Not sure what to do with these ones! */
  80         [ 15 ] = KEY_SELECT,            /* SOURCE */
  81         [ 10 ] = KEY_KPPLUS,            /* +100 */
  82         [ 20 ] = KEY_KPEQUAL,           /* SYNC */
  83         [ 28 ] = KEY_MEDIA,             /* PC/TV */
  84 };
  85
  86 /* ----------------------------------------------------------------------- */
  87 /* insmod parameters                                                       */
  88
  89 static int debug;
  90 module_param(debug, int, 0644);    /* debug level (0,1,2) */
  91
  92 #define DEVNAME "ir-kbd-i2c"
  93 #define dprintk(level, fmt, arg...)     if (debug >= level) \
  94         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
  95
  96 /* ----------------------------------------------------------------------- */
  97
  98 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  99 {
 100         unsigned char buf[3];
 101         int start, toggle, dev, code;
 102
 103         /* poll IR chip */
 104         if (3 != i2c_master_recv(&ir->c,buf,3))
 105                 return -EIO;
 106
 107         /* split rc5 data block ... */
 108         start  = (buf[0] >> 6) &    3;
 109         toggle = (buf[0] >> 5) &    1;
 110         dev    =  buf[0]       & 0x1f;
 111         code   = (buf[1] >> 2) & 0x3f;
 112
 113         if (3 != start)
 114                 /* no key pressed */
 115                 return 0;
 116         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
 117                 start, toggle, dev, code);
 118
 119         /* return key */
 120         *ir_key = code;
 121         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
 122         return 1;
 123 }
 124
 125 static int get_key_pixelview(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         *ir_key = b;
 135         *ir_raw = b;
 136         return 1;
 137 }
 138
 139 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 140 {
 141         unsigned char b;
 142
 143         /* poll IR chip */
 144         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 145                 dprintk(1,"read error\n");
 146                 return -EIO;
 147         }
 148
 149         /* ignore 0xaa */
 150         if (b==0xaa)
 151                 return 0;
 152         dprintk(2,"key %02x\n", b);
 153
 154         *ir_key = b;
 155         *ir_raw = b;
 156         return 1;
 157 }
 158
 159 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 160 {
 161         unsigned char b;
 162
 163         /* poll IR chip */
 164         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 165                 dprintk(1,"read error\n");
 166                 return -EIO;
 167         }
 168
 169         /* it seems that 0xFE indicates that a button is still hold
 170            down, while 0xff indicates that no button is hold
 171            down. 0xfe sequences are sometimes interrupted by 0xFF */
 172
 173         dprintk(2,"key %02x\n", b);
 174
 175         if (b == 0xff)
 176                 return 0;
 177
 178         if (b == 0xfe)
 179                 /* keep old data */
 180                 return 1;
 181
 182         *ir_key = b;
 183         *ir_raw = b;
 184         return 1;
 185 }
 186
 187 /* The new pinnacle PCTV remote (with the colored buttons)
 188  *
 189  * Ricardo Cerqueira <v4l@cerqueira.org>
 190  */
 191
 192 int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 193 {
 194         unsigned char b[4];
 195         unsigned int start = 0,parity = 0,code = 0;
 196
 197         /* poll IR chip */
 198         if (4 != i2c_master_recv(&ir->c,b,4)) {
 199                 dprintk(2,"read error\n");
 200                 return -EIO;
 201         }
 202
 203         for (start = 0; start<4; start++) {
 204                 if (b[start] == 0x80) {
 205                         code=b[(start+3)%4];
 206                         parity=b[(start+2)%4];
 207                 }
 208         }
 209
 210         /* Empty Request */
 211         if (parity==0)
 212                 return 0;
 213
 214         /* Repeating... */
 215         if (ir->old == parity)
 216                 return 0;
 217
 218
 219         ir->old = parity;
 220
 221         /* Reduce code value to fit inside IR_KEYTAB_SIZE
 222          *
 223          * this is the only value that results in 42 unique
 224          * codes < 128
 225          */
 226
 227         code %= 0x88;
 228
 229         *ir_raw = code;
 230         *ir_key = code;
 231
 232         dprintk(1,"Pinnacle PCTV key %02x\n", code);
 233
 234         return 1;
 235 }
 236
 237 EXPORT_SYMBOL_GPL(get_key_pinnacle);
 238
 239 /* ----------------------------------------------------------------------- */
 240
 241 static void ir_key_poll(struct IR_i2c *ir)
 242 {
 243         static u32 ir_key, ir_raw;
 244         int rc;
 245
 246         dprintk(2,"ir_poll_key\n");
 247         rc = ir->get_key(ir, &ir_key, &ir_raw);
 248         if (rc < 0) {
 249                 dprintk(2,"error\n");
 250                 return;
 251         }
 252
 253         if (0 == rc) {
 254                 ir_input_nokey(ir->input, &ir->ir);
 255         } else {
 256                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 257         }
 258 }
 259
 260 static void ir_timer(unsigned long data)
 261 {
 262         struct IR_i2c *ir = (struct IR_i2c*)data;
 263         schedule_work(&ir->work);
 264 }
 265
 266 static void ir_work(void *data)
 267 {
 268         struct IR_i2c *ir = data;
 269         ir_key_poll(ir);
 270         mod_timer(&ir->timer, jiffies+HZ/10);
 271 }
 272
 273 /* ----------------------------------------------------------------------- */
 274
 275 static int ir_attach(struct i2c_adapter *adap, int addr,
 276                       unsigned short flags, int kind);
 277 static int ir_detach(struct i2c_client *client);
 278 static int ir_probe(struct i2c_adapter *adap);
 279
 280 static struct i2c_driver driver = {
 281         .driver = {
 282                 .owner  = THIS_MODULE,
 283                 .name   = "ir remote kbd driver",
 284         },
 285         .id             = I2C_DRIVERID_INFRARED,
 286         .attach_adapter = ir_probe,
 287         .detach_client  = ir_detach,
 288 };
 289
 290 static struct i2c_client client_template =
 291 {
 292         .name = "unset",
 293         .driver = &driver
 294 };
 295
 296 static int ir_attach(struct i2c_adapter *adap, int addr,
 297                      unsigned short flags, int kind)
 298 {
 299         IR_KEYTAB_TYPE *ir_codes = NULL;
 300         char *name;
 301         int ir_type;
 302         struct IR_i2c *ir;
 303         struct input_dev *input_dev;
 304
 305         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
 306         input_dev = input_allocate_device();
 307         if (!ir || !input_dev) {
 308                 kfree(ir);
 309                 input_free_device(input_dev);
 310                 return -ENOMEM;
 311         }
 312
 313         ir->c = client_template;
 314         ir->input = input_dev;
 315
 316         i2c_set_clientdata(&ir->c, ir);
 317         ir->c.adapter = adap;
 318         ir->c.addr    = addr;
 319
 320         switch(addr) {
 321         case 0x64:
 322                 name        = "Pixelview";
 323                 ir->get_key = get_key_pixelview;
 324                 ir_type     = IR_TYPE_OTHER;
 325                 ir_codes    = ir_codes_empty;
 326                 break;
 327         case 0x4b:
 328                 name        = "PV951";
 329                 ir->get_key = get_key_pv951;
 330                 ir_type     = IR_TYPE_OTHER;
 331                 ir_codes    = ir_codes_pv951;
 332                 break;
 333         case 0x18:
 334         case 0x1a:
 335                 name        = "Hauppauge";
 336                 ir->get_key = get_key_haup;
 337                 ir_type     = IR_TYPE_RC5;
 338                 ir_codes    = ir_codes_rc5_tv;
 339                 break;
 340         case 0x30:
 341                 name        = "KNC One";
 342                 ir->get_key = get_key_knc1;
 343                 ir_type     = IR_TYPE_OTHER;
 344                 ir_codes    = ir_codes_empty;
 345                 break;
 346         case 0x7a:
 347         case 0x47:
 348                 /* Handled by saa7134-input */
 349                 name        = "SAA713x remote";
 350                 ir_type     = IR_TYPE_OTHER;
 351                 break;
 352         default:
 353                 /* shouldn't happen */
 354                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
 355                 kfree(ir);
 356                 return -1;
 357         }
 358
 359         /* Sets name */
 360         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 361         ir->ir_codes=ir_codes;
 362
 363         /* register i2c device
 364          * At device register, IR codes may be changed to be
 365          * board dependent.
 366          */
 367         i2c_attach_client(&ir->c);
 368
 369         /* If IR not supported or disabled, unregisters driver */
 370         if (ir->get_key == NULL) {
 371                 i2c_detach_client(&ir->c);
 372                 kfree(ir);
 373                 return -1;
 374         }
 375
 376         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 377         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 378                  ir->c.adapter->dev.bus_id,
 379                  ir->c.dev.bus_id);
 380
 381         /* init + register input device */
 382         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
 383         input_dev->id.bustype   = BUS_I2C;
 384         input_dev->name         = ir->c.name;
 385         input_dev->phys         = ir->phys;
 386
 387         /* register event device */
 388         input_register_device(ir->input);
 389
 390         /* start polling via eventd */
 391         INIT_WORK(&ir->work, ir_work, ir);
 392         init_timer(&ir->timer);
 393         ir->timer.function = ir_timer;
 394         ir->timer.data     = (unsigned long)ir;
 395         schedule_work(&ir->work);
 396
 397         return 0;
 398 }
 399
 400 static int ir_detach(struct i2c_client *client)
 401 {
 402         struct IR_i2c *ir = i2c_get_clientdata(client);
 403
 404         /* kill outstanding polls */
 405         del_timer(&ir->timer);
 406         flush_scheduled_work();
 407
 408         /* unregister devices */
 409         input_unregister_device(ir->input);
 410         i2c_detach_client(&ir->c);
 411
 412         /* free memory */
 413         kfree(ir);
 414         return 0;
 415 }
 416
 417 static int ir_probe(struct i2c_adapter *adap)
 418 {
 419
 420         /* The external IR receiver is at i2c address 0x34 (0x35 for
 421            reads).  Future Hauppauge cards will have an internal
 422            receiver at 0x30 (0x31 for reads).  In theory, both can be
 423            fitted, and Hauppauge suggest an external overrides an
 424            internal.
 425
 426            That's why we probe 0x1a (~0x34) first. CB
 427         */
 428
 429         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 430         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
 431         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 432         const int *probe = NULL;
 433         struct i2c_client c;
 434         unsigned char buf;
 435         int i,rc;
 436
 437         switch (adap->id) {
 438         case I2C_HW_B_BT848:
 439                 probe = probe_bttv;
 440                 break;
 441         case I2C_HW_SAA7134:
 442                 probe = probe_saa7134;
 443                 break;
 444         case I2C_HW_B_EM28XX:
 445                 probe = probe_em28XX;
 446                 break;
 447         }
 448         if (NULL == probe)
 449                 return 0;
 450
 451         memset(&c,0,sizeof(c));
 452         c.adapter = adap;
 453         for (i = 0; -1 != probe[i]; i++) {
 454                 c.addr = probe[i];
 455                 rc = i2c_master_recv(&c,&buf,0);
 456                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 457                         probe[i], adap->name,
 458                         (0 == rc) ? "yes" : "no");
 459                 if (0 == rc) {
 460                         ir_attach(adap,probe[i],0,0);
 461                         break;
 462                 }
 463         }
 464         return 0;
 465 }
 466
 467 /* ----------------------------------------------------------------------- */
 468
 469 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 470 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 471 MODULE_LICENSE("GPL");
 472
 473 static int __init ir_init(void)
 474 {
 475         return i2c_add_driver(&driver);
 476 }
 477
 478 static void __exit ir_fini(void)
 479 {
 480         i2c_del_driver(&driver);
 481 }
 482
 483 module_init(ir_init);
 484 module_exit(ir_fini);
 485
 486 /*
 487  * Overrides for Emacs so that we follow Linus's tabbing style.
 488  * ---------------------------------------------------------------------------
 489  * Local variables:
 490  * c-basic-offset: 8
 491  * End:
 492  */