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