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  * modified for MSI TV@nywhere Plus by
  16  *      Henry Wong <henry@stuffedcow.net>
  17  *      Mark Schultz <n9xmj@yahoo.com>
  18  *      Brian Rogers <brian_rogers@comcast.net>
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  33  *
  34  */
  35
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38 #include <linux/kernel.h>
  39 #include <linux/string.h>
  40 #include <linux/timer.h>
  41 #include <linux/delay.h>
  42 #include <linux/errno.h>
  43 #include <linux/slab.h>
  44 #include <linux/i2c.h>
  45 #include <linux/i2c-id.h>
  46 #include <linux/workqueue.h>
  47
  48 #include <media/ir-common.h>
  49 #include <media/ir-kbd-i2c.h>
  50
  51 /* ----------------------------------------------------------------------- */
  52 /* insmod parameters                                                       */
  53
  54 static int debug;
  55 module_param(debug, int, 0644);    /* debug level (0,1,2) */
  56
  57 static int hauppauge;
  58 module_param(hauppauge, int, 0644);    /* Choose Hauppauge remote */
  59 MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults to 0)");
  60
  61
  62 #define DEVNAME "ir-kbd-i2c"
  63 #define dprintk(level, fmt, arg...)     if (debug >= level) \
  64         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
  65
  66 /* ----------------------------------------------------------------------- */
  67
  68 static int get_key_haup_common(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
  69                                int size, int offset)
  70 {
  71         unsigned char buf[6];
  72         int start, range, toggle, dev, code, ircode;
  73
  74         /* poll IR chip */
  75         if (size != i2c_master_recv(&ir->c,buf,size))
  76                 return -EIO;
  77
  78         /* split rc5 data block ... */
  79         start  = (buf[offset] >> 7) &    1;
  80         range  = (buf[offset] >> 6) &    1;
  81         toggle = (buf[offset] >> 5) &    1;
  82         dev    =  buf[offset]       & 0x1f;
  83         code   = (buf[offset+1] >> 2) & 0x3f;
  84
  85         /* rc5 has two start bits
  86          * the first bit must be one
  87          * the second bit defines the command range (1 = 0-63, 0 = 64 - 127)
  88          */
  89         if (!start)
  90                 /* no key pressed */
  91                 return 0;
  92         /*
  93          * Hauppauge remotes (black/silver) always use
  94          * specific device ids. If we do not filter the
  95          * device ids then messages destined for devices
  96          * such as TVs (id=0) will get through causing
  97          * mis-fired events.
  98          *
  99          * We also filter out invalid key presses which
 100          * produce annoying debug log entries.
 101          */
 102         ircode= (start << 12) | (toggle << 11) | (dev << 6) | code;
 103         if ((ircode & 0x1fff)==0x1fff)
 104                 /* invalid key press */
 105                 return 0;
 106
 107         if (dev!=0x1e && dev!=0x1f)
 108                 /* not a hauppauge remote */
 109                 return 0;
 110
 111         if (!range)
 112                 code += 64;
 113
 114         dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n",
 115                 start, range, toggle, dev, code);
 116
 117         /* return key */
 118         *ir_key = code;
 119         *ir_raw = ircode;
 120         return 1;
 121 }
 122
 123 static inline int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 124 {
 125         return get_key_haup_common (ir, ir_key, ir_raw, 3, 0);
 126 }
 127
 128 static inline int get_key_haup_xvr(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 129 {
 130         return get_key_haup_common (ir, ir_key, ir_raw, 6, 3);
 131 }
 132
 133 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 134 {
 135         unsigned char b;
 136
 137         /* poll IR chip */
 138         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 139                 dprintk(1,"read error\n");
 140                 return -EIO;
 141         }
 142         *ir_key = b;
 143         *ir_raw = b;
 144         return 1;
 145 }
 146
 147 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 148 {
 149         unsigned char b;
 150
 151         /* poll IR chip */
 152         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 153                 dprintk(1,"read error\n");
 154                 return -EIO;
 155         }
 156
 157         /* ignore 0xaa */
 158         if (b==0xaa)
 159                 return 0;
 160         dprintk(2,"key %02x\n", b);
 161
 162         *ir_key = b;
 163         *ir_raw = b;
 164         return 1;
 165 }
 166
 167 static int get_key_fusionhdtv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 168 {
 169         unsigned char buf[4];
 170
 171         /* poll IR chip */
 172         if (4 != i2c_master_recv(&ir->c,buf,4)) {
 173                 dprintk(1,"read error\n");
 174                 return -EIO;
 175         }
 176
 177         if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
 178                 dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
 179                         buf[0], buf[1], buf[2], buf[3]);
 180
 181         /* no key pressed or signal from other ir remote */
 182         if(buf[0] != 0x1 ||  buf[1] != 0xfe)
 183                 return 0;
 184
 185         *ir_key = buf[2];
 186         *ir_raw = (buf[2] << 8) | buf[3];
 187
 188         return 1;
 189 }
 190
 191 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 192 {
 193         unsigned char b;
 194
 195         /* poll IR chip */
 196         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 197                 dprintk(1,"read error\n");
 198                 return -EIO;
 199         }
 200
 201         /* it seems that 0xFE indicates that a button is still hold
 202            down, while 0xff indicates that no button is hold
 203            down. 0xfe sequences are sometimes interrupted by 0xFF */
 204
 205         dprintk(2,"key %02x\n", b);
 206
 207         if (b == 0xff)
 208                 return 0;
 209
 210         if (b == 0xfe)
 211                 /* keep old data */
 212                 return 1;
 213
 214         *ir_key = b;
 215         *ir_raw = b;
 216         return 1;
 217 }
 218
 219 /* ----------------------------------------------------------------------- */
 220
 221 static void ir_key_poll(struct IR_i2c *ir)
 222 {
 223         static u32 ir_key, ir_raw;
 224         int rc;
 225
 226         dprintk(2,"ir_poll_key\n");
 227         rc = ir->get_key(ir, &ir_key, &ir_raw);
 228         if (rc < 0) {
 229                 dprintk(2,"error\n");
 230                 return;
 231         }
 232
 233         if (0 == rc) {
 234                 ir_input_nokey(ir->input, &ir->ir);
 235         } else {
 236                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 237         }
 238 }
 239
 240 static void ir_timer(unsigned long data)
 241 {
 242         struct IR_i2c *ir = (struct IR_i2c*)data;
 243         schedule_work(&ir->work);
 244 }
 245
 246 static void ir_work(struct work_struct *work)
 247 {
 248         struct IR_i2c *ir = container_of(work, struct IR_i2c, work);
 249         int polling_interval = 100;
 250
 251         /* MSI TV@nywhere Plus requires more frequent polling
 252            otherwise it will miss some keypresses */
 253         if (ir->c.adapter->id == I2C_HW_SAA7134 && ir->c.addr == 0x30)
 254                 polling_interval = 50;
 255
 256         ir_key_poll(ir);
 257         mod_timer(&ir->timer, jiffies + msecs_to_jiffies(polling_interval));
 258 }
 259
 260 /* ----------------------------------------------------------------------- */
 261
 262 static int ir_attach(struct i2c_adapter *adap, int addr,
 263                       unsigned short flags, int kind);
 264 static int ir_detach(struct i2c_client *client);
 265 static int ir_probe(struct i2c_adapter *adap);
 266
 267 static struct i2c_driver driver = {
 268         .driver = {
 269                 .name   = "ir-kbd-i2c",
 270         },
 271         .id             = I2C_DRIVERID_INFRARED,
 272         .attach_adapter = ir_probe,
 273         .detach_client  = ir_detach,
 274 };
 275
 276 static struct i2c_client client_template =
 277 {
 278         .name = "unset",
 279         .driver = &driver
 280 };
 281
 282 static int ir_attach(struct i2c_adapter *adap, int addr,
 283                      unsigned short flags, int kind)
 284 {
 285         IR_KEYTAB_TYPE *ir_codes = NULL;
 286         char *name;
 287         int ir_type;
 288         struct IR_i2c *ir;
 289         struct input_dev *input_dev;
 290         int err;
 291
 292         ir = kzalloc(sizeof(struct IR_i2c),GFP_KERNEL);
 293         input_dev = input_allocate_device();
 294         if (!ir || !input_dev) {
 295                 err = -ENOMEM;
 296                 goto err_out_free;
 297         }
 298
 299         ir->c = client_template;
 300         ir->input = input_dev;
 301
 302         ir->c.adapter = adap;
 303         ir->c.addr    = addr;
 304
 305         i2c_set_clientdata(&ir->c, ir);
 306
 307         switch(addr) {
 308         case 0x64:
 309                 name        = "Pixelview";
 310                 ir->get_key = get_key_pixelview;
 311                 ir_type     = IR_TYPE_OTHER;
 312                 ir_codes    = ir_codes_empty;
 313                 break;
 314         case 0x4b:
 315                 name        = "PV951";
 316                 ir->get_key = get_key_pv951;
 317                 ir_type     = IR_TYPE_OTHER;
 318                 ir_codes    = ir_codes_pv951;
 319                 break;
 320         case 0x18:
 321         case 0x1a:
 322                 name        = "Hauppauge";
 323                 ir->get_key = get_key_haup;
 324                 ir_type     = IR_TYPE_RC5;
 325                 if (hauppauge == 1) {
 326                         ir_codes    = ir_codes_hauppauge_new;
 327                 } else {
 328                         ir_codes    = ir_codes_rc5_tv;
 329                 }
 330                 break;
 331         case 0x30:
 332                 name        = "KNC One";
 333                 ir->get_key = get_key_knc1;
 334                 ir_type     = IR_TYPE_OTHER;
 335                 ir_codes    = ir_codes_empty;
 336                 break;
 337         case 0x6b:
 338                 name        = "FusionHDTV";
 339                 ir->get_key = get_key_fusionhdtv;
 340                 ir_type     = IR_TYPE_RC5;
 341                 ir_codes    = ir_codes_fusionhdtv_mce;
 342                 break;
 343         case 0x7a:
 344         case 0x47:
 345         case 0x71:
 346         case 0x2d:
 347                 if (adap->id == I2C_HW_B_CX2388x) {
 348                         /* Handled by cx88-input */
 349                         name        = "CX2388x remote";
 350                         ir_type     = IR_TYPE_RC5;
 351                         ir->get_key = get_key_haup_xvr;
 352                         if (hauppauge == 1) {
 353                                 ir_codes    = ir_codes_hauppauge_new;
 354                         } else {
 355                                 ir_codes    = ir_codes_rc5_tv;
 356                         }
 357                 } else {
 358                         /* Handled by saa7134-input */
 359                         name        = "SAA713x remote";
 360                         ir_type     = IR_TYPE_OTHER;
 361                 }
 362                 break;
 363         default:
 364                 /* shouldn't happen */
 365                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n", addr);
 366                 err = -ENODEV;
 367                 goto err_out_free;
 368         }
 369
 370         /* Sets name */
 371         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 372         ir->ir_codes = ir_codes;
 373
 374         /* register i2c device
 375          * At device register, IR codes may be changed to be
 376          * board dependent.
 377          */
 378         err = i2c_attach_client(&ir->c);
 379         if (err)
 380                 goto err_out_free;
 381
 382         /* If IR not supported or disabled, unregisters driver */
 383         if (ir->get_key == NULL) {
 384                 err = -ENODEV;
 385                 goto err_out_detach;
 386         }
 387
 388         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 389         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 390                  ir->c.adapter->dev.bus_id,
 391                  ir->c.dev.bus_id);
 392
 393         /* init + register input device */
 394         ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
 395         input_dev->id.bustype = BUS_I2C;
 396         input_dev->name       = ir->c.name;
 397         input_dev->phys       = ir->phys;
 398
 399         err = input_register_device(ir->input);
 400         if (err)
 401                 goto err_out_detach;
 402
 403         printk(DEVNAME ": %s detected at %s [%s]\n",
 404                ir->input->name, ir->input->phys, adap->name);
 405
 406         /* start polling via eventd */
 407         INIT_WORK(&ir->work, ir_work);
 408         init_timer(&ir->timer);
 409         ir->timer.function = ir_timer;
 410         ir->timer.data     = (unsigned long)ir;
 411         schedule_work(&ir->work);
 412
 413         return 0;
 414
 415  err_out_detach:
 416         i2c_detach_client(&ir->c);
 417  err_out_free:
 418         input_free_device(input_dev);
 419         kfree(ir);
 420         return err;
 421 }
 422
 423 static int ir_detach(struct i2c_client *client)
 424 {
 425         struct IR_i2c *ir = i2c_get_clientdata(client);
 426
 427         /* kill outstanding polls */
 428         del_timer_sync(&ir->timer);
 429         flush_scheduled_work();
 430
 431         /* unregister devices */
 432         input_unregister_device(ir->input);
 433         i2c_detach_client(&ir->c);
 434
 435         /* free memory */
 436         kfree(ir);
 437         return 0;
 438 }
 439
 440 static int ir_probe(struct i2c_adapter *adap)
 441 {
 442
 443         /* The external IR receiver is at i2c address 0x34 (0x35 for
 444            reads).  Future Hauppauge cards will have an internal
 445            receiver at 0x30 (0x31 for reads).  In theory, both can be
 446            fitted, and Hauppauge suggest an external overrides an
 447            internal.
 448
 449            That's why we probe 0x1a (~0x34) first. CB
 450         */
 451
 452         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 453         static const int probe_saa7134[] = { 0x7a, 0x47, 0x71, 0x2d, -1 };
 454         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 455         static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
 456         static const int probe_cx23885[] = { 0x6b, -1 };
 457         const int *probe;
 458         struct i2c_msg msg = {
 459                 .flags = I2C_M_RD,
 460                 .len = 0,
 461                 .buf = NULL,
 462         };
 463         int i, rc;
 464
 465         switch (adap->id) {
 466         case I2C_HW_B_BT848:
 467                 probe = probe_bttv;
 468                 break;
 469         case I2C_HW_B_CX2341X:
 470                 probe = probe_bttv;
 471                 break;
 472         case I2C_HW_SAA7134:
 473                 probe = probe_saa7134;
 474                 break;
 475         case I2C_HW_B_EM28XX:
 476                 probe = probe_em28XX;
 477                 break;
 478         case I2C_HW_B_CX2388x:
 479                 probe = probe_cx88;
 480                 break;
 481         case I2C_HW_B_CX23885:
 482                 probe = probe_cx23885;
 483                 break;
 484         default:
 485                 return 0;
 486         }
 487
 488         for (i = 0; -1 != probe[i]; i++) {
 489                 msg.addr = probe[i];
 490                 rc = i2c_transfer(adap, &msg, 1);
 491                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 492                         probe[i], adap->name,
 493                         (1 == rc) ? "yes" : "no");
 494                 if (1 == rc) {
 495                         ir_attach(adap, probe[i], 0, 0);
 496                         return 0;
 497                 }
 498         }
 499
 500         /* Special case for MSI TV@nywhere Plus remote */
 501         if (adap->id == I2C_HW_SAA7134) {
 502                 u8 temp;
 503
 504                 /* MSI TV@nywhere Plus controller doesn't seem to
 505                    respond to probes unless we read something from
 506                    an existing device. Weird... */
 507
 508                 msg.addr = 0x50;
 509                 rc = i2c_transfer(adap, &msg, 1);
 510                         dprintk(1, "probe 0x%02x @ %s: %s\n",
 511                         msg.addr, adap->name,
 512                         (1 == rc) ? "yes" : "no");
 513
 514                 /* Now do the probe. The controller does not respond
 515                    to 0-byte reads, so we use a 1-byte read instead. */
 516                 msg.addr = 0x30;
 517                 msg.len = 1;
 518                 msg.buf = &temp;
 519                 rc = i2c_transfer(adap, &msg, 1);
 520                 dprintk(1, "probe 0x%02x @ %s: %s\n",
 521                         msg.addr, adap->name,
 522                         (1 == rc) ? "yes" : "no");
 523                 if (1 == rc)
 524                         ir_attach(adap, msg.addr, 0, 0);
 525         }
 526
 527         return 0;
 528 }
 529
 530 /* ----------------------------------------------------------------------- */
 531
 532 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 533 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 534 MODULE_LICENSE("GPL");
 535
 536 static int __init ir_init(void)
 537 {
 538         return i2c_add_driver(&driver);
 539 }
 540
 541 static void __exit ir_fini(void)
 542 {
 543         i2c_del_driver(&driver);
 544 }
 545
 546 module_init(ir_init);
 547 module_exit(ir_fini);
 548
 549 /*
 550  * Overrides for Emacs so that we follow Linus's tabbing style.
 551  * ---------------------------------------------------------------------------
 552  * Local variables:
 553  * c-basic-offset: 8
 554  * End:
 555  */