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, ircode;
  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          * Hauppauge remotes (black/silver) always use
  90          * specific device ids. If we do not filter the
  91          * device ids then messages destined for devices
  92          * such as TVs (id=0) will get through causing
  93          * mis-fired events.
  94          *
  95          * We also filter out invalid key presses which
  96          * produce annoying debug log entries.
  97          */
  98         ircode= (start << 12) | (toggle << 11) | (dev << 6) | code;
  99         if ((ircode & 0x1fff)==0x1fff)
 100                 /* invalid key press */
 101                 return 0;
 102
 103         if (dev!=0x1e && dev!=0x1f)
 104                 /* not a hauppauge remote */
 105                 return 0;
 106
 107         if (!range)
 108                 code += 64;
 109
 110         dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
 111                 start, range, toggle, dev, code);
 112
 113         /* return key */
 114         *ir_key = code;
 115         *ir_raw = ircode;
 116         return 1;
 117 }
 118
 119 static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 120 {
 121         return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
 122 }
 123
 124 static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 125 {
 126         return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
 127 }
 128
 129 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 130 {
 131         unsigned char b;
 132
 133         /* poll IR chip */
 134         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 135                 dprintk(1,"read error\n");
 136                 return -EIO;
 137         }
 138         *ir_key = b;
 139         *ir_raw = b;
 140         return 1;
 141 }
 142
 143 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 144 {
 145         unsigned char b;
 146
 147         /* poll IR chip */
 148         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 149                 dprintk(1,"read error\n");
 150                 return -EIO;
 151         }
 152
 153         /* ignore 0xaa */
 154         if (b==0xaa)
 155                 return 0;
 156         dprintk(2,"key %02x\n", b);
 157
 158         *ir_key = b;
 159         *ir_raw = b;
 160         return 1;
 161 }
 162
 163 static int get_key_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 164 {
 165         unsigned char buf[4];
 166
 167         /* poll IR chip */
 168         if (4 != i2c_master_recv(&ir->c,buf,4)) {
 169                 dprintk(1,"read error\n");
 170                 return -EIO;
 171         }
 172
 173         if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
 174                 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
 175                         buf[0], buf[1], buf[2], buf[3]);
 176
 177         /* no key pressed or signal from other ir remote */
 178         if(buf[0] != 0x1 ||  buf[1] != 0xfe)
 179                 return 0;
 180
 181         *ir_key = buf[2];
 182         *ir_raw = (buf[2] << 8) | buf[3];
 183
 184         return 1;
 185 }
 186
 187 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 188 {
 189         unsigned char b;
 190
 191         /* poll IR chip */
 192         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 193                 dprintk(1,"read error\n");
 194                 return -EIO;
 195         }
 196
 197         /* it seems that 0xFE indicates that a button is still hold
 198            down, while 0xff indicates that no button is hold
 199            down. 0xfe sequences are sometimes interrupted by 0xFF */
 200
 201         dprintk(2,"key %02x\n", b);
 202
 203         if (b == 0xff)
 204                 return 0;
 205
 206         if (b == 0xfe)
 207                 /* keep old data */
 208                 return 1;
 209
 210         *ir_key = b;
 211         *ir_raw = b;
 212         return 1;
 213 }
 214
 215 /* ----------------------------------------------------------------------- */
 216
 217 static void ir_key_poll(struct IR_i2c *ir)
 218 {
 219         static u32 ir_key, ir_raw;
 220         int rc;
 221
 222         dprintk(2,"ir_poll_key\n");
 223         rc = ir->get_key(ir, &ir_key, &ir_raw);
 224         if (rc < 0) {
 225                 dprintk(2,"error\n");
 226                 return;
 227         }
 228
 229         if (0 == rc) {
 230                 ir_input_nokey(ir->input, &ir->ir);
 231         } else {
 232                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 233         }
 234 }
 235
 236 static void ir_timer(unsigned long data)
 237 {
 238         struct IR_i2c *ir = (struct IR_i2c*)data;
 239         schedule_work(&ir->work);
 240 }
 241
 242 static void ir_work(struct work_struct *work)
 243 {
 244         struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
 245
 246         ir_key_poll(ir);
 247         mod_timer(&ir->timer, jiffies + msecs_to_jiffies(100));
 248 }
 249
 250 /* ----------------------------------------------------------------------- */
 251
 252 static int ir_attach(struct i2c_adapter *adap, int addr,
 253                       unsigned short flags, int kind);
 254 static int ir_detach(struct i2c_client *client);
 255 static int ir_probe(struct i2c_adapter *adap);
 256
 257 static struct i2c_driver driver = {
 258         .driver = {
 259                 .name   = "ir-kbd-i2c",
 260         },
 261         .id             = I2C_DRIVERID_INFRARED,
 262         .attach_adapter = ir_probe,
 263         .detach_client  = ir_detach,
 264 };
 265
 266 static struct i2c_client client_template =
 267 {
 268         .name = "unset",
 269         .driver = &driver
 270 };
 271
 272 static int ir_attach(struct i2c_adapter *adap, int addr,
 273                      unsigned short flags, int kind)
 274 {
 275         IR_KEYTAB_TYPE *ir_codes = NULL;
 276         char *name;
 277         int ir_type;
 278         struct IR_i2c *ir;
 279         struct input_dev *input_dev;
 280         int err;
 281
 282         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
 283         input_dev = input_allocate_device();
 284         if (!ir || !input_dev) {
 285                 err = -ENOMEM;
 286                 goto err_out_free;
 287         }
 288
 289         ir->c = client_template;
 290         ir->input = input_dev;
 291
 292         ir->c.adapter = adap;
 293         ir->c.addr    = addr;
 294
 295         i2c_set_clientdata(&ir->c, ir);
 296
 297         switch(addr) {
 298         case 0x64:
 299                 name        = "Pixelview";
 300                 ir->get_key = get_key_pixelview;
 301                 ir_type     = IR_TYPE_OTHER;
 302                 ir_codes    = ir_codes_empty;
 303                 break;
 304         case 0x4b:
 305                 name        = "PV951";
 306                 ir->get_key = get_key_pv951;
 307                 ir_type     = IR_TYPE_OTHER;
 308                 ir_codes    = ir_codes_pv951;
 309                 break;
 310         case 0x18:
 311         case 0x1a:
 312                 name        = "Hauppauge";
 313                 ir->get_key = get_key_haup;
 314                 ir_type     = IR_TYPE_RC5;
 315                 if (hauppauge == 1) {
 316                         ir_codes    = ir_codes_hauppauge_new;
 317                 } else {
 318                         ir_codes    = ir_codes_rc5_tv;
 319                 }
 320                 break;
 321         case 0x30:
 322                 name        = "KNC One";
 323                 ir->get_key = get_key_knc1;
 324                 ir_type     = IR_TYPE_OTHER;
 325                 ir_codes    = ir_codes_empty;
 326                 break;
 327         case 0x6b:
 328                 name        = "FusionHDTV";
 329                 ir->get_key = get_key_fusionhdtv;
 330                 ir_type     = IR_TYPE_RC5;
 331                 ir_codes    = ir_codes_fusionhdtv_mce;
 332                 break;
 333         case 0x7a:
 334         case 0x47:
 335         case 0x71:
 336         case 0x2d:
 337                 if (adap->id == I2C_HW_B_CX2388x) {
 338                         /* Handled by cx88-input */
 339                         name        = "CX2388x remote";
 340                         ir_type     = IR_TYPE_RC5;
 341                         ir->get_key = get_key_haup_xvr;
 342                         if (hauppauge == 1) {
 343                                 ir_codes    = ir_codes_hauppauge_new;
 344                         } else {
 345                                 ir_codes    = ir_codes_rc5_tv;
 346                         }
 347                 } else {
 348                         /* Handled by saa7134-input */
 349                         name        = "SAA713x remote";
 350                         ir_type     = IR_TYPE_OTHER;
 351                 }
 352                 break;
 353         default:
 354                 /* shouldn't happen */
 355                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
 356                 err = -ENODEV;
 357                 goto err_out_free;
 358         }
 359
 360         /* Sets name */
 361         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 362         ir->ir_codes = ir_codes;
 363
 364         /* register i2c device
 365          * At device register, IR codes may be changed to be
 366          * board dependent.
 367          */
 368         err = i2c_attach_client(&ir->c);
 369         if (err)
 370                 goto err_out_free;
 371
 372         /* If IR not supported or disabled, unregisters driver */
 373         if (ir->get_key == NULL) {
 374                 err = -ENODEV;
 375                 goto err_out_detach;
 376         }
 377
 378         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 379         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 380                  ir->c.adapter->dev.bus_id,
 381                  ir->c.dev.bus_id);
 382
 383         /* init + register input device */
 384         ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
 385         input_dev->id.bustype = BUS_I2C;
 386         input_dev->name       = ir->c.name;
 387         input_dev->phys       = ir->phys;
 388
 389         err = input_register_device(ir->input);
 390         if (err)
 391                 goto err_out_detach;
 392
 393         printk(DEVNAME ": %s detected at %s [%s]\n",
 394                ir->input->name, ir->input->phys, adap->name);
 395
 396         /* start polling via eventd */
 397         INIT_WORK(&ir->work, ir_work);
 398         init_timer(&ir->timer);
 399         ir->timer.function = ir_timer;
 400         ir->timer.data     = (unsigned long)ir;
 401         schedule_work(&ir->work);
 402
 403         return 0;
 404
 405  err_out_detach:
 406         i2c_detach_client(&ir->c);
 407  err_out_free:
 408         input_free_device(input_dev);
 409         kfree(ir);
 410         return err;
 411 }
 412
 413 static int ir_detach(struct i2c_client *client)
 414 {
 415         struct IR_i2c *ir = i2c_get_clientdata(client);
 416
 417         /* kill outstanding polls */
 418         del_timer_sync(&ir->timer);
 419         flush_scheduled_work();
 420
 421         /* unregister devices */
 422         input_unregister_device(ir->input);
 423         i2c_detach_client(&ir->c);
 424
 425         /* free memory */
 426         kfree(ir);
 427         return 0;
 428 }
 429
 430 static int ir_probe(struct i2c_adapter *adap)
 431 {
 432
 433         /* The external IR receiver is at i2c address 0x34 (0x35 for
 434            reads).  Future Hauppauge cards will have an internal
 435            receiver at 0x30 (0x31 for reads).  In theory, both can be
 436            fitted, and Hauppauge suggest an external overrides an
 437            internal.
 438
 439            That's why we probe 0x1a (~0x34) first. CB
 440         */
 441
 442         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 443         static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
 444         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 445         static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
 446         static const int probe_cx23885[] = { 0x6b, -1 };
 447         const int *probe;
 448         struct i2c_msg msg = {
 449                 .flags = I2C_M_RD,
 450                 .len = 0,
 451                 .buf = NULL,
 452         };
 453         int i, rc;
 454
 455         switch (adap->id) {
 456         case I2C_HW_B_BT848:
 457                 probe = probe_bttv;
 458                 break;
 459         case I2C_HW_B_CX2341X:
 460                 probe = probe_bttv;
 461                 break;
 462         case I2C_HW_SAA7134:
 463                 probe = probe_saa7134;
 464                 break;
 465         case I2C_HW_B_EM28XX:
 466                 probe = probe_em28XX;
 467                 break;
 468         case I2C_HW_B_CX2388x:
 469                 probe = probe_cx88;
 470                 break;
 471         case I2C_HW_B_CX23885:
 472                 probe = probe_cx23885;
 473                 break;
 474         default:
 475                 return 0;
 476         }
 477
 478         for (i = 0; -1 != probe[i]; i++) {
 479                 msg.addr = probe[i];
 480                 rc = i2c_transfer(adap, &msg, 1);
 481                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 482                         probe[i], adap->name,
 483                         (1 == rc) ? "yes" : "no");
 484                 if (1 == rc) {
 485                         ir_attach(adap, probe[i], 0, 0);
 486                         break;
 487                 }
 488         }
 489         return 0;
 490 }
 491
 492 /* ----------------------------------------------------------------------- */
 493
 494 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 495 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 496 MODULE_LICENSE("GPL");
 497
 498 static int __init ir_init(void)
 499 {
 500         return i2c_add_driver(&driver);
 501 }
 502
 503 static void __exit ir_fini(void)
 504 {
 505         i2c_del_driver(&driver);
 506 }
 507
 508 module_init(ir_init);
 509 module_exit(ir_fini);
 510
 511 /*
 512  * Overrides for Emacs so that we follow Linus's tabbing style.
 513  * ---------------------------------------------------------------------------
 514  * Local variables:
 515  * c-basic-offset: 8
 516  * End:
 517  */