SAFE public projects git trees. - safe/jmp/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 #include <media/ir-common.h>
  44 #include <media/ir-kbd-i2c.h>
  45
  46 /* Mark Phalan <phalanm@o2.ie> */
  47 static IR_KEYTAB_TYPE ir_codes_pv951[IR_KEYTAB_SIZE] = {
  48         [  0 ] = KEY_KP0,
  49         [  1 ] = KEY_KP1,
  50         [  2 ] = KEY_KP2,
  51         [  3 ] = KEY_KP3,
  52         [  4 ] = KEY_KP4,
  53         [  5 ] = KEY_KP5,
  54         [  6 ] = KEY_KP6,
  55         [  7 ] = KEY_KP7,
  56         [  8 ] = KEY_KP8,
  57         [  9 ] = KEY_KP9,
  58
  59         [ 18 ] = KEY_POWER,
  60         [ 16 ] = KEY_MUTE,
  61         [ 31 ] = KEY_VOLUMEDOWN,
  62         [ 27 ] = KEY_VOLUMEUP,
  63         [ 26 ] = KEY_CHANNELUP,
  64         [ 30 ] = KEY_CHANNELDOWN,
  65         [ 14 ] = KEY_PAGEUP,
  66         [ 29 ] = KEY_PAGEDOWN,
  67         [ 19 ] = KEY_SOUND,
  68
  69         [ 24 ] = KEY_KPPLUSMINUS,       /* CH +/- */
  70         [ 22 ] = KEY_SUBTITLE,          /* CC */
  71         [ 13 ] = KEY_TEXT,              /* TTX */
  72         [ 11 ] = KEY_TV,                /* AIR/CBL */
  73         [ 17 ] = KEY_PC,                /* PC/TV */
  74         [ 23 ] = KEY_OK,                /* CH RTN */
  75         [ 25 ] = KEY_MODE,              /* FUNC */
  76         [ 12 ] = KEY_SEARCH,            /* AUTOSCAN */
  77
  78         /* Not sure what to do with these ones! */
  79         [ 15 ] = KEY_SELECT,            /* SOURCE */
  80         [ 10 ] = KEY_KPPLUS,            /* +100 */
  81         [ 20 ] = KEY_KPEQUAL,           /* SYNC */
  82         [ 28 ] = KEY_MEDIA,             /* PC/TV */
  83 };
  84
  85 /* ----------------------------------------------------------------------- */
  86 /* insmod parameters                                                       */
  87
  88 static int debug;
  89 module_param(debug, int, 0644);    /* debug level (0,1,2) */
  90
  91 #define DEVNAME "ir-kbd-i2c"
  92 #define dprintk(level, fmt, arg...)     if (debug >= level) \
  93         printk(KERN_DEBUG DEVNAME ": " fmt , ## arg)
  94
  95 /* ----------------------------------------------------------------------- */
  96
  97 static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  98 {
  99         unsigned char buf[3];
 100         int start, toggle, dev, code;
 101
 102         /* poll IR chip */
 103         if (3 != i2c_master_recv(&ir->c,buf,3))
 104                 return -EIO;
 105
 106         /* split rc5 data block ... */
 107         start  = (buf[0] >> 6) &    3;
 108         toggle = (buf[0] >> 5) &    1;
 109         dev    =  buf[0]       & 0x1f;
 110         code   = (buf[1] >> 2) & 0x3f;
 111
 112         if (3 != start)
 113                 /* no key pressed */
 114                 return 0;
 115         dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n",
 116                 start, toggle, dev, code);
 117
 118         /* return key */
 119         *ir_key = code;
 120         *ir_raw = (start << 12) | (toggle << 11) | (dev << 6) | code;
 121         return 1;
 122 }
 123
 124 static int get_key_pixelview(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 125 {
 126         unsigned char b;
 127
 128         /* poll IR chip */
 129         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 130                 dprintk(1,"read error\n");
 131                 return -EIO;
 132         }
 133         *ir_key = b;
 134         *ir_raw = b;
 135         return 1;
 136 }
 137
 138 static int get_key_pv951(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 139 {
 140         unsigned char b;
 141
 142         /* poll IR chip */
 143         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 144                 dprintk(1,"read error\n");
 145                 return -EIO;
 146         }
 147
 148         /* ignore 0xaa */
 149         if (b==0xaa)
 150                 return 0;
 151         dprintk(2,"key %02x\n", b);
 152
 153         *ir_key = b;
 154         *ir_raw = b;
 155         return 1;
 156 }
 157
 158 static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 159 {
 160         unsigned char b;
 161
 162         /* poll IR chip */
 163         if (1 != i2c_master_recv(&ir->c,&b,1)) {
 164                 dprintk(1,"read error\n");
 165                 return -EIO;
 166         }
 167
 168         /* it seems that 0xFE indicates that a button is still hold
 169            down, while 0xff indicates that no button is hold
 170            down. 0xfe sequences are sometimes interrupted by 0xFF */
 171
 172         dprintk(2,"key %02x\n", b);
 173
 174         if (b == 0xff)
 175                 return 0;
 176
 177         if (b == 0xfe)
 178                 /* keep old data */
 179                 return 1;
 180
 181         *ir_key = b;
 182         *ir_raw = b;
 183         return 1;
 184 }
 185
 186 /* ----------------------------------------------------------------------- */
 187
 188 static void ir_key_poll(struct IR_i2c *ir)
 189 {
 190         static u32 ir_key, ir_raw;
 191         int rc;
 192
 193         dprintk(2,"ir_poll_key\n");
 194         rc = ir->get_key(ir, &ir_key, &ir_raw);
 195         if (rc < 0) {
 196                 dprintk(2,"error\n");
 197                 return;
 198         }
 199
 200         if (0 == rc) {
 201                 ir_input_nokey(ir->input, &ir->ir);
 202         } else {
 203                 ir_input_keydown(ir->input, &ir->ir, ir_key, ir_raw);
 204         }
 205 }
 206
 207 static void ir_timer(unsigned long data)
 208 {
 209         struct IR_i2c *ir = (struct IR_i2c*)data;
 210         schedule_work(&ir->work);
 211 }
 212
 213 static void ir_work(void *data)
 214 {
 215         struct IR_i2c *ir = data;
 216         ir_key_poll(ir);
 217         mod_timer(&ir->timer, jiffies+HZ/10);
 218 }
 219
 220 /* ----------------------------------------------------------------------- */
 221
 222 static int ir_attach(struct i2c_adapter *adap, int addr,
 223                       unsigned short flags, int kind);
 224 static int ir_detach(struct i2c_client *client);
 225 static int ir_probe(struct i2c_adapter *adap);
 226
 227 static struct i2c_driver driver = {
 228         .name           = "ir remote kbd driver",
 229         .id             = I2C_DRIVERID_EXP3, /* FIXME */
 230         .flags          = I2C_DF_NOTIFY,
 231         .attach_adapter = ir_probe,
 232         .detach_client  = ir_detach,
 233 };
 234
 235 static struct i2c_client client_template =
 236 {
 237         .name = "unset",
 238         .driver = &driver
 239 };
 240
 241 static int ir_attach(struct i2c_adapter *adap, int addr,
 242                      unsigned short flags, int kind)
 243 {
 244         IR_KEYTAB_TYPE *ir_codes = NULL;
 245         char *name;
 246         int ir_type;
 247         struct IR_i2c *ir;
 248         struct input_dev *input_dev;
 249
 250         ir = kzalloc(sizeof(struct IR_i2c), GFP_KERNEL);
 251         input_dev = input_allocate_device();
 252         if (!ir || !input_dev) {
 253                 kfree(ir);
 254                 input_free_device(input_dev);
 255                 return -ENOMEM;
 256         }
 257
 258         ir->c = client_template;
 259         ir->input = input_dev;
 260
 261         i2c_set_clientdata(&ir->c, ir);
 262         ir->c.adapter = adap;
 263         ir->c.addr    = addr;
 264
 265         switch(addr) {
 266         case 0x64:
 267                 name        = "Pixelview";
 268                 ir->get_key = get_key_pixelview;
 269                 ir_type     = IR_TYPE_OTHER;
 270                 ir_codes    = ir_codes_empty;
 271                 break;
 272         case 0x4b:
 273                 name        = "PV951";
 274                 ir->get_key = get_key_pv951;
 275                 ir_type     = IR_TYPE_OTHER;
 276                 ir_codes    = ir_codes_pv951;
 277                 break;
 278         case 0x18:
 279         case 0x1a:
 280                 name        = "Hauppauge";
 281                 ir->get_key = get_key_haup;
 282                 ir_type     = IR_TYPE_RC5;
 283                 ir_codes    = ir_codes_rc5_tv;
 284                 break;
 285         case 0x30:
 286                 name        = "KNC One";
 287                 ir->get_key = get_key_knc1;
 288                 ir_type     = IR_TYPE_OTHER;
 289                 ir_codes    = ir_codes_empty;
 290                 break;
 291         case 0x7a:
 292         case 0x47:
 293                 /* Handled by saa7134-input */
 294                 name        = "SAA713x remote";
 295                 ir_type     = IR_TYPE_OTHER;
 296                 break;
 297         default:
 298                 /* shouldn't happen */
 299                 printk(DEVNAME ": Huh? unknown i2c address (0x%02x)?\n",addr);
 300                 kfree(ir);
 301                 return -1;
 302         }
 303
 304         /* Sets name */
 305         snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (%s)", name);
 306         ir->ir_codes=ir_codes;
 307
 308         /* register i2c device
 309          * At device register, IR codes may be changed to be
 310          * board dependent.
 311         */
 312         i2c_attach_client(&ir->c);
 313
 314         /* If IR not supported or disabled, unregisters driver */
 315         if (ir->get_key == NULL) {
 316                 i2c_detach_client(&ir->c);
 317                 kfree(ir);
 318                 return -1;
 319         }
 320
 321         /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
 322         snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
 323                  ir->c.adapter->dev.bus_id,
 324                  ir->c.dev.bus_id);
 325
 326         /* init + register input device */
 327         ir_input_init(input_dev, &ir->ir, ir_type, ir_codes);
 328         input_dev->id.bustype   = BUS_I2C;
 329         input_dev->name         = ir->c.name;
 330         input_dev->phys         = ir->phys;
 331
 332         /* register event device */
 333         input_register_device(ir->input);
 334
 335         /* start polling via eventd */
 336         INIT_WORK(&ir->work, ir_work, ir);
 337         init_timer(&ir->timer);
 338         ir->timer.function = ir_timer;
 339         ir->timer.data     = (unsigned long)ir;
 340         schedule_work(&ir->work);
 341
 342         return 0;
 343 }
 344
 345 static int ir_detach(struct i2c_client *client)
 346 {
 347         struct IR_i2c *ir = i2c_get_clientdata(client);
 348
 349         /* kill outstanding polls */
 350         del_timer(&ir->timer);
 351         flush_scheduled_work();
 352
 353         /* unregister devices */
 354         input_unregister_device(ir->input);
 355         i2c_detach_client(&ir->c);
 356
 357         /* free memory */
 358         kfree(ir);
 359         return 0;
 360 }
 361
 362 static int ir_probe(struct i2c_adapter *adap)
 363 {
 364
 365         /* The external IR receiver is at i2c address 0x34 (0x35 for
 366            reads).  Future Hauppauge cards will have an internal
 367            receiver at 0x30 (0x31 for reads).  In theory, both can be
 368            fitted, and Hauppauge suggest an external overrides an
 369            internal.
 370
 371            That's why we probe 0x1a (~0x34) first. CB
 372         */
 373
 374         static const int probe_bttv[] = { 0x1a, 0x18, 0x4b, 0x64, 0x30, -1};
 375         static const int probe_saa7134[] = { 0x7a, 0x47, -1 };
 376         static const int probe_em28XX[] = { 0x30, 0x47, -1 };
 377         const int *probe = NULL;
 378         struct i2c_client c;
 379         unsigned char buf;
 380         int i,rc;
 381
 382         switch (adap->id) {
 383         case I2C_HW_B_BT848:
 384                 probe = probe_bttv;
 385                 break;
 386         case I2C_HW_SAA7134:
 387                 probe = probe_saa7134;
 388                 break;
 389         case I2C_HW_B_EM28XX:
 390                 probe = probe_em28XX;
 391                 break;
 392         }
 393         if (NULL == probe)
 394                 return 0;
 395
 396         memset(&c,0,sizeof(c));
 397         c.adapter = adap;
 398         for (i = 0; -1 != probe[i]; i++) {
 399                 c.addr = probe[i];
 400                 rc = i2c_master_recv(&c,&buf,0);
 401                 dprintk(1,"probe 0x%02x @ %s: %s\n",
 402                         probe[i], adap->name,
 403                         (0 == rc) ? "yes" : "no");
 404                 if (0 == rc) {
 405                         ir_attach(adap,probe[i],0,0);
 406                         break;
 407                 }
 408         }
 409         return 0;
 410 }
 411
 412 /* ----------------------------------------------------------------------- */
 413
 414 MODULE_AUTHOR("Gerd Knorr, Michal Kochanowicz, Christoph Bartelmus, Ulrich Mueller");
 415 MODULE_DESCRIPTION("input driver for i2c IR remote controls");
 416 MODULE_LICENSE("GPL");
 417
 418 static int __init ir_init(void)
 419 {
 420         return i2c_add_driver(&driver);
 421 }
 422
 423 static void __exit ir_fini(void)
 424 {
 425         i2c_del_driver(&driver);
 426 }
 427
 428 module_init(ir_init);
 429 module_exit(ir_fini);
 430
 431 /*
 432  * Overrides for Emacs so that we follow Linus's tabbing style.
 433  * ---------------------------------------------------------------------------
 434  * Local variables:
 435  * c-basic-offset: 8
 436  * End:
 437  */