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  * modified for DViCO Fusion HDTV 5 RT GOLD by
  14  *      Chaogui Zhang <czhang1974@gmail.com>
  15  *
  16  *  This program is free software; you can redistribute it and/or modify
  17  *  it under the terms of the GNU General Public License as published by
  18  *  the Free Software Foundation; either version 2 of the License, or
  19  *  (at your option) any later version.
  20  *
  21  *  This program is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  *  GNU General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU General Public License
  27  *  along with this program; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29  *
  30  */
  31
  32 #include <linux/module.h>
  33 #include <linux/init.h>
  34 #include <linux/kernel.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/i2c-id.h>
  42 #include <linux/workqueue.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;
  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_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 146 {
 147         unsigned char buf[4];
 148
 149         /* poll IR chip */
 150         if (4 != i2c_master_recv(&ir->c,buf,4)) {
 151                 dprintk(1,"read error\n");
 152                 return -EIO;
 153         }
 154
 155         if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
 156                 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
 157                         buf[0], buf[1], buf[2], buf[3]);
 158
 159         /* no key pressed or signal from other ir remote */
 160         if(buf[0] != 0x1 ||  buf[1] != 0xfe)
 161                 return 0;
 162
 163         *ir_key = buf[2];
 164         *ir_raw = (buf[2] << 8) | buf[3];
 165
 166         return 1;
 167 }
 168
 169 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 170 {
 171         unsigned char b;
 172
 173         /* poll IR chip */
 174         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 175                 dprintk(1,"read error\n");
 176                 return -EIO;
 177         }
 178
 179         /* it seems that 0xFE indicates that a button is still hold
 180            down, while 0xff indicates that no button is hold
 181            down. 0xfe sequences are sometimes interrupted by 0xFF */
 182
 183         dprintk(2,"key %02x\n", b);
 184
 185         if (b == 0xff)
 186                 return 0;
 187
 188         if (b == 0xfe)
 189                 /* keep old data */
 190                 return 1;
 191
 192         *ir_key = b;
 193         *ir_raw = b;
 194         return 1;
 195 }
 196
 197 /* ----------------------------------------------------------------------- */
 198
 199 static void ir_key_poll(struct IR_i2c *ir)
 200 {
 201         static u32 ir_key, ir_raw;
 202         int rc;
 203
 204         dprintk(2,"ir_poll_key\n");
 205         rc = ir->get_key(ir, &ir_key, &ir_raw);
 206         if (rc < 0) {
 207                 dprintk(2,"error\n");
 208                 return;
 209         }
 210
 211         if (0 == rc) {
 212                 ir_input_nokey(ir->input, &ir->ir);
 213         } else {
 214                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 215         }
 216 }
 217
 218 static void ir_timer(unsigned long data)
 219 {
 220         struct IR_i2c *ir = (struct IR_i2c*)data;
 221         schedule_work(&ir->work);
 222 }
 223
 224 static void ir_work(struct work_struct *work)
 225 {
 226         struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
 227
 228         ir_key_poll(ir);
 229         mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
 230 }
 231
 232 /* ----------------------------------------------------------------------- */
 233
 234 static int ir_attach(struct i2c_adapter *adap, int addr,
 235                       unsigned short flags, int kind);
 236 static int ir_detach(struct i2c_client *client);
 237 static int ir_probe(struct i2c_adapter *adap);
 238
 239 static struct i2c_driver driver = {
 240         .driver = {
 241                 .name   = "ir-kbd-i2c",
 242         },
 243         .id             = I2C_DRIVERID_INFRARED,
 244         .attach_adapter = ir_probe,
 245         .detach_client  = ir_detach,
 246 };
 247
 248 static struct i2c_client client_template =
 249 {
 250         .name = "unset",
 251         .driver = &driver
 252 };
 253
 254 static int ir_attach(struct i2c_adapter *adap, int addr,
 255                      unsigned short flags, int kind)
 256 {
 257         IR_KEYTAB_TYPE *ir_codes = NULL;
 258         char *name;
 259         int ir_type;
 260         struct IR_i2c *ir;
 261         struct input_dev *input_dev;
 262         int err;
 263
 264         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
 265         input_dev = input_allocate_device();
 266         if (!ir || !input_dev) {
 267                 err = -ENOMEM;
 268                 goto err_out_free;
 269         }
 270
 271         ir->c = client_template;
 272         ir->input = input_dev;
 273
 274         ir->c.adapter = adap;
 275         ir->c.addr    = addr;
 276
 277         i2c_set_clientdata(&ir->c, ir);
 278
 279         switch(addr) {
 280         case 0x64:
 281                 name        = "Pixelview";
 282                 ir->get_key = get_key_pixelview;
 283                 ir_type     = IR_TYPE_OTHER;
 284                 ir_codes    = ir_codes_empty;
 285                 break;
 286         case 0x4b:
 287                 name        = "PV951";
 288                 ir->get_key = get_key_pv951;
 289                 ir_type     = IR_TYPE_OTHER;
 290                 ir_codes    = ir_codes_pv951;
 291                 break;
 292         case 0x18:
 293         case 0x1a:
 294                 name        = "Hauppauge";
 295                 ir->get_key = get_key_haup;
 296                 ir_type     = IR_TYPE_RC5;
 297                 if (hauppauge == 1) {
 298                         ir_codes    = ir_codes_hauppauge_new;
 299                 } else {
 300                         ir_codes    = ir_codes_rc5_tv;
 301                 }
 302                 break;
 303         case 0x30:
 304                 name        = "KNC One";
 305                 ir->get_key = get_key_knc1;
 306                 ir_type     = IR_TYPE_OTHER;
 307                 ir_codes    = ir_codes_empty;
 308                 break;
 309         case 0x6b:
 310                 name        = "FusionHDTV";
 311                 ir->get_key = get_key_fusionhdtv;
 312                 ir_type     = IR_TYPE_RC5;
 313                 ir_codes    = ir_codes_fusionhdtv_mce;
 314                 break;
 315         case 0x7a:
 316         case 0x47:
 317         case 0x71:
 318         case 0x2d:
 319                 if (adap->id == I2C_HW_B_CX2388x) {
 320                         /* Handled by cx88-input */
 321                         name        = "CX2388x remote";
 322                         ir_type     = IR_TYPE_RC5;
 323                         ir->get_key = get_key_haup_xvr;
 324                         if (hauppauge == 1) {
 325                                 ir_codes    = ir_codes_hauppauge_new;
 326                         } else {
 327                                 ir_codes    = ir_codes_rc5_tv;
 328                         }
 329                 } else {
 330                         /* Handled by saa7134-input */
 331                         name        = "SAA713x remote";
 332                         ir_type     = IR_TYPE_OTHER;
 333                 }
 334                 break;
 335         default:
 336                 /* shouldn't happen */
 337                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
 338                 err = -ENODEV;
 339                 goto err_out_free;
 340         }
 341
 342         /* Sets name */
 343         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 344         ir->ir_codes = ir_codes;
 345
 346         /* register i2c device
 347          * At device register, IR codes may be changed to be
 348          * board dependent.
 349          */
 350         err = i2c_attach_client(&ir->c);
 351         if (err)
 352                 goto err_out_free;
 353
 354         /* If IR not supported or disabled, unregisters driver */
 355         if (ir->get_key == NULL) {
 356                 err = -ENODEV;
 357                 goto err_out_detach;
 358         }
 359
 360         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 361         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 362                  ir->c.adapter->dev.bus_id,
 363                  ir->c.dev.bus_id);
 364
 365         /* init + register input device */
 366         ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
 367         input_dev->id.bustype = BUS_I2C;
 368         input_dev->name       = ir->c.name;
 369         input_dev->phys       = ir->phys;
 370
 371         err = input_register_device(ir->input);
 372         if (err)
 373                 goto err_out_detach;
 374
 375         printk(DEVNAME ": %s detected at %s [%s]\n",
 376                ir->input->name, ir->input->phys, adap->name);
 377
 378         /* start polling via eventd */
 379         INIT_WORK(&ir->work, ir_work);
 380         init_timer(&ir->timer);
 381         ir->timer.function = ir_timer;
 382         ir->timer.data     = (unsigned long)ir;
 383         schedule_work(&ir->work);
 384
 385         return 0;
 386
 387  err_out_detach:
 388         i2c_detach_client(&ir->c);
 389  err_out_free:
 390         input_free_device(input_dev);
 391         kfree(ir);
 392         return err;
 393 }
 394
 395 static int ir_detach(struct i2c_client *client)
 396 {
 397         struct IR_i2c *ir = i2c_get_clientdata(client);
 398
 399         /* kill outstanding polls */
 400         del_timer_sync(&ir->timer);
 401         flush_scheduled_work();
 402
 403         /* unregister devices */
 404         input_unregister_device(ir->input);
 405         i2c_detach_client(&ir->c);
 406
 407         /* free memory */
 408         kfree(ir);
 409         return 0;
 410 }
 411
 412 static int ir_probe(struct i2c_adapter *adap)
 413 {
 414
 415         /* The external IR receiver is at i2c address 0x34 (0x35 for
 416            reads).  Future Hauppauge cards will have an internal
 417            receiver at 0x30 (0x31 for reads).  In theory, both can be
 418            fitted, and Hauppauge suggest an external overrides an
 419            internal.
 420
 421            That's why we probe 0x1a (~0x34) first. CB
 422         */
 423
 424         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 425         static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
 426         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 427         static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
 428         static const int probe_cx23885[] = { 0x6b, -1 };
 429         const int *probe;
 430         struct i2c_msg msg = {
 431                 .flags = I2C_M_RD,
 432                 .len = 0,
 433                 .buf = NULL,
 434         };
 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_B_CX2341X:
 442                 probe = probe_bttv;
 443                 break;
 444         case I2C_HW_SAA7134:
 445                 probe = probe_saa7134;
 446                 break;
 447         case I2C_HW_B_EM28XX:
 448                 probe = probe_em28XX;
 449                 break;
 450         case I2C_HW_B_CX2388x:
 451                 probe = probe_cx88;
 452                 break;
 453         case I2C_HW_B_CX23885:
 454                 probe = probe_cx23885;
 455                 break;
 456         default:
 457                 return 0;
 458         }
 459
 460         for (i = 0; -1 != probe[i]; i++) {
 461                 msg.addr = probe[i];
 462                 rc = i2c_transfer(adap, &msg, 1);
 463                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 464                         probe[i], adap->name,
 465                         (1 == rc) ? "yes" : "no");
 466                 if (1 == rc) {
 467                         ir_attach(adap, probe[i], 0, 0);
 468                         break;
 469                 }
 470         }
 471         return 0;
 472 }
 473
 474 /* ----------------------------------------------------------------------- */
 475
 476 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 477 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 478 MODULE_LICENSE("GPL");
 479
 480 static int __init ir_init(void)
 481 {
 482         return i2c_add_driver(&driver);
 483 }
 484
 485 static void __exit ir_fini(void)
 486 {
 487         i2c_del_driver(&driver);
 488 }
 489
 490 module_init(ir_init);
 491 module_exit(ir_fini);
 492
 493 /*
 494  * Overrides for Emacs so that we follow Linus's tabbing style.
 495  * ---------------------------------------------------------------------------
 496  * Local variables:
 497  * c-basic-offset: 8
 498  * End:
 499  */