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