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