drivers/media/pci/saa7134/saa7134-input.c

   1 /*
   2  *
   3  * handle saa7134 IR remotes via linux kernel input layer.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  *
  19  */
  20
  21 #include "saa7134.h"
  22 #include "saa7134-reg.h"
  23
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/delay.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/slab.h>
  29
  30 #define MODULE_NAME "saa7134"
  31
  32 static unsigned int disable_ir;
  33 module_param(disable_ir, int, 0444);
  34 MODULE_PARM_DESC(disable_ir,"disable infrared remote support");
  35
  36 static unsigned int ir_debug;
  37 module_param(ir_debug, int, 0644);
  38 MODULE_PARM_DESC(ir_debug,"enable debug messages [IR]");
  39
  40 static int pinnacle_remote;
  41 module_param(pinnacle_remote, int, 0644);    /* Choose Pinnacle PCTV remote */
  42 MODULE_PARM_DESC(pinnacle_remote, "Specify Pinnacle PCTV remote: 0=coloured, 1=grey (defaults to 0)");
  43
  44 #define input_dbg(fmt, arg...) do { \
  45         if (ir_debug) \
  46                 printk(KERN_DEBUG pr_fmt("input: " fmt), ## arg); \
  47         } while (0)
  48 #define ir_dbg(ir, fmt, arg...) do { \
  49         if (ir_debug) \
  50                 printk(KERN_DEBUG pr_fmt("ir %s: " fmt), ir->name, ## arg); \
  51         } while (0)
  52
  53 /* Helper function for raw decoding at GPIO16 or GPIO18 */
  54 static int saa7134_raw_decode_irq(struct saa7134_dev *dev);
  55
  56 /* -------------------- GPIO generic keycode builder -------------------- */
  57
  58 static int build_key(struct saa7134_dev *dev)
  59 {
  60         struct saa7134_card_ir *ir = dev->remote;
  61         u32 gpio, data;
  62
  63         /* here comes the additional handshake steps for some cards */
  64         switch (dev->board) {
  65         case SAA7134_BOARD_GOTVIEW_7135:
  66                 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x80);
  67                 saa_clearb(SAA7134_GPIO_GPSTATUS1, 0x80);
  68                 break;
  69         }
  70         /* rising SAA7134_GPIO_GPRESCAN reads the status */
  71         saa_clearb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
  72         saa_setb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
  73
  74         gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
  75         if (ir->polling) {
  76                 if (ir->last_gpio == gpio)
  77                         return 0;
  78                 ir->last_gpio = gpio;
  79         }
  80
  81         data = ir_extract_bits(gpio, ir->mask_keycode);
  82         input_dbg("build_key gpio=0x%x mask=0x%x data=%d\n",
  83                 gpio, ir->mask_keycode, data);
  84
  85         switch (dev->board) {
  86         case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
  87                 if (data == ir->mask_keycode)
  88                         rc_keyup(ir->dev);
  89                 else
  90                         rc_keydown_notimeout(ir->dev, RC_TYPE_UNKNOWN, data, 0);
  91                 return 0;
  92         }
  93
  94         if (ir->polling) {
  95                 if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
  96                     (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
  97                         rc_keydown_notimeout(ir->dev, RC_TYPE_UNKNOWN, data, 0);
  98                 } else {
  99                         rc_keyup(ir->dev);
 100                 }
 101         }
 102         else {  /* IRQ driven mode - handle key press and release in one go */
 103                 if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
 104                     (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
 105                         rc_keydown_notimeout(ir->dev, RC_TYPE_UNKNOWN, data, 0);
 106                         rc_keyup(ir->dev);
 107                 }
 108         }
 109
 110         return 0;
 111 }
 112
 113 /* --------------------- Chip specific I2C key builders ----------------- */
 114
 115 static int get_key_flydvb_trio(struct IR_i2c *ir, enum rc_type *protocol,
 116                                u32 *scancode, u8 *toggle)
 117 {
 118         int gpio;
 119         int attempt = 0;
 120         unsigned char b;
 121
 122         /* We need this to access GPI Used by the saa_readl macro. */
 123         struct saa7134_dev *dev = ir->c->adapter->algo_data;
 124
 125         if (dev == NULL) {
 126                 ir_dbg(ir, "get_key_flydvb_trio: "
 127                            "ir->c->adapter->algo_data is NULL!\n");
 128                 return -EIO;
 129         }
 130
 131         /* rising SAA7134_GPIGPRESCAN reads the status */
 132         saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 133         saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 134
 135         gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 136
 137         if (0x40000 & ~gpio)
 138                 return 0; /* No button press */
 139
 140         /* poll IR chip */
 141         /* weak up the IR chip */
 142         b = 0;
 143
 144         while (1 != i2c_master_send(ir->c, &b, 1)) {
 145                 if ((attempt++) < 10) {
 146                         /*
 147                          * wait a bit for next attempt -
 148                          * I don't know how make it better
 149                          */
 150                         msleep(10);
 151                         continue;
 152                 }
 153                 ir_dbg(ir, "send wake up byte to pic16C505 (IR chip)"
 154                            "failed %dx\n", attempt);
 155                 return -EIO;
 156         }
 157         if (1 != i2c_master_recv(ir->c, &b, 1)) {
 158                 ir_dbg(ir, "read error\n");
 159                 return -EIO;
 160         }
 161
 162         *protocol = RC_TYPE_UNKNOWN;
 163         *scancode = b;
 164         *toggle = 0;
 165         return 1;
 166 }
 167
 168 static int get_key_msi_tvanywhere_plus(struct IR_i2c *ir, enum rc_type *protocol,
 169                                        u32 *scancode, u8 *toggle)
 170 {
 171         unsigned char b;
 172         int gpio;
 173
 174         /* <dev> is needed to access GPIO. Used by the saa_readl macro. */
 175         struct saa7134_dev *dev = ir->c->adapter->algo_data;
 176         if (dev == NULL) {
 177                 ir_dbg(ir, "get_key_msi_tvanywhere_plus: "
 178                            "ir->c->adapter->algo_data is NULL!\n");
 179                 return -EIO;
 180         }
 181
 182         /* rising SAA7134_GPIO_GPRESCAN reads the status */
 183
 184         saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 185         saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 186
 187         gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 188
 189         /* GPIO&0x40 is pulsed low when a button is pressed. Don't do
 190            I2C receive if gpio&0x40 is not low. */
 191
 192         if (gpio & 0x40)
 193                 return 0;       /* No button press */
 194
 195         /* GPIO says there is a button press. Get it. */
 196
 197         if (1 != i2c_master_recv(ir->c, &b, 1)) {
 198                 ir_dbg(ir, "read error\n");
 199                 return -EIO;
 200         }
 201
 202         /* No button press */
 203
 204         if (b == 0xff)
 205                 return 0;
 206
 207         /* Button pressed */
 208
 209         input_dbg("get_key_msi_tvanywhere_plus: Key = 0x%02X\n", b);
 210         *protocol = RC_TYPE_UNKNOWN;
 211         *scancode = b;
 212         *toggle = 0;
 213         return 1;
 214 }
 215
 216 /* copied and modified from get_key_msi_tvanywhere_plus() */
 217 static int get_key_kworld_pc150u(struct IR_i2c *ir, enum rc_type *protocol,
 218                                  u32 *scancode, u8 *toggle)
 219 {
 220         unsigned char b;
 221         unsigned int gpio;
 222
 223         /* <dev> is needed to access GPIO. Used by the saa_readl macro. */
 224         struct saa7134_dev *dev = ir->c->adapter->algo_data;
 225         if (dev == NULL) {
 226                 ir_dbg(ir, "get_key_kworld_pc150u: "
 227                            "ir->c->adapter->algo_data is NULL!\n");
 228                 return -EIO;
 229         }
 230
 231         /* rising SAA7134_GPIO_GPRESCAN reads the status */
 232
 233         saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 234         saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 235
 236         gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 237
 238         /* GPIO&0x100 is pulsed low when a button is pressed. Don't do
 239            I2C receive if gpio&0x100 is not low. */
 240
 241         if (gpio & 0x100)
 242                 return 0;       /* No button press */
 243
 244         /* GPIO says there is a button press. Get it. */
 245
 246         if (1 != i2c_master_recv(ir->c, &b, 1)) {
 247                 ir_dbg(ir, "read error\n");
 248                 return -EIO;
 249         }
 250
 251         /* No button press */
 252
 253         if (b == 0xff)
 254                 return 0;
 255
 256         /* Button pressed */
 257
 258         input_dbg("get_key_kworld_pc150u: Key = 0x%02X\n", b);
 259         *protocol = RC_TYPE_UNKNOWN;
 260         *scancode = b;
 261         *toggle = 0;
 262         return 1;
 263 }
 264
 265 static int get_key_purpletv(struct IR_i2c *ir, enum rc_type *protocol,
 266                             u32 *scancode, u8 *toggle)
 267 {
 268         unsigned char b;
 269
 270         /* poll IR chip */
 271         if (1 != i2c_master_recv(ir->c, &b, 1)) {
 272                 ir_dbg(ir, "read error\n");
 273                 return -EIO;
 274         }
 275
 276         /* no button press */
 277         if (b==0)
 278                 return 0;
 279
 280         /* repeating */
 281         if (b & 0x80)
 282                 return 1;
 283
 284         *protocol = RC_TYPE_UNKNOWN;
 285         *scancode = b;
 286         *toggle = 0;
 287         return 1;
 288 }
 289
 290 static int get_key_hvr1110(struct IR_i2c *ir, enum rc_type *protocol,
 291                            u32 *scancode, u8 *toggle)
 292 {
 293         unsigned char buf[5];
 294
 295         /* poll IR chip */
 296         if (5 != i2c_master_recv(ir->c, buf, 5))
 297                 return -EIO;
 298
 299         /* Check if some key were pressed */
 300         if (!(buf[0] & 0x80))
 301                 return 0;
 302
 303         /*
 304          * buf[3] & 0x80 is always high.
 305          * buf[3] & 0x40 is a parity bit. A repeat event is marked
 306          * by preserving it into two separate readings
 307          * buf[4] bits 0 and 1, and buf[1] and buf[2] are always
 308          * zero.
 309          *
 310          * Note that the keymap which the hvr1110 uses is RC5.
 311          *
 312          * FIXME: start bits could maybe be used...?
 313          */
 314         *protocol = RC_TYPE_RC5;
 315         *scancode = RC_SCANCODE_RC5(buf[3] & 0x1f, buf[4] >> 2);
 316         *toggle = !!(buf[3] & 0x40);
 317         return 1;
 318 }
 319
 320
 321 static int get_key_beholdm6xx(struct IR_i2c *ir, enum rc_type *protocol,
 322                               u32 *scancode, u8 *toggle)
 323 {
 324         unsigned char data[12];
 325         u32 gpio;
 326
 327         struct saa7134_dev *dev = ir->c->adapter->algo_data;
 328
 329         /* rising SAA7134_GPIO_GPRESCAN reads the status */
 330         saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 331         saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 332
 333         gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 334
 335         if (0x400000 & ~gpio)
 336                 return 0; /* No button press */
 337
 338         ir->c->addr = 0x5a >> 1;
 339
 340         if (12 != i2c_master_recv(ir->c, data, 12)) {
 341                 ir_dbg(ir, "read error\n");
 342                 return -EIO;
 343         }
 344
 345         if (data[9] != (unsigned char)(~data[8]))
 346                 return 0;
 347
 348         *protocol = RC_TYPE_NEC;
 349         *scancode = RC_SCANCODE_NECX(data[11] << 8 | data[10], data[9]);
 350         *toggle = 0;
 351         return 1;
 352 }
 353
 354 /* Common (grey or coloured) pinnacle PCTV remote handling
 355  *
 356  */
 357 static int get_key_pinnacle(struct IR_i2c *ir, enum rc_type *protocol,
 358                             u32 *scancode, u8 *toggle, int parity_offset,
 359                             int marker, int code_modulo)
 360 {
 361         unsigned char b[4];
 362         unsigned int start = 0,parity = 0,code = 0;
 363
 364         /* poll IR chip */
 365         if (4 != i2c_master_recv(ir->c, b, 4)) {
 366                 ir_dbg(ir, "read error\n");
 367                 return -EIO;
 368         }
 369
 370         for (start = 0; start < ARRAY_SIZE(b); start++) {
 371                 if (b[start] == marker) {
 372                         code=b[(start+parity_offset + 1) % 4];
 373                         parity=b[(start+parity_offset) % 4];
 374                 }
 375         }
 376
 377         /* Empty Request */
 378         if (parity == 0)
 379                 return 0;
 380
 381         /* Repeating... */
 382         if (ir->old == parity)
 383                 return 0;
 384
 385         ir->old = parity;
 386
 387         /* drop special codes when a key is held down a long time for the grey controller
 388            In this case, the second bit of the code is asserted */
 389         if (marker == 0xfe && (code & 0x40))
 390                 return 0;
 391
 392         code %= code_modulo;
 393
 394         *protocol = RC_TYPE_UNKNOWN;
 395         *scancode = code;
 396         *toggle = 0;
 397
 398         ir_dbg(ir, "Pinnacle PCTV key %02x\n", code);
 399         return 1;
 400 }
 401
 402 /* The grey pinnacle PCTV remote
 403  *
 404  *  There are one issue with this remote:
 405  *   - I2c packet does not change when the same key is pressed quickly. The workaround
 406  *     is to hold down each key for about half a second, so that another code is generated
 407  *     in the i2c packet, and the function can distinguish key presses.
 408  *
 409  * Sylvain Pasche <sylvain.pasche@gmail.com>
 410  */
 411 static int get_key_pinnacle_grey(struct IR_i2c *ir, enum rc_type *protocol,
 412                                  u32 *scancode, u8 *toggle)
 413 {
 414
 415         return get_key_pinnacle(ir, protocol, scancode, toggle, 1, 0xfe, 0xff);
 416 }
 417
 418
 419 /* The new pinnacle PCTV remote (with the colored buttons)
 420  *
 421  * Ricardo Cerqueira <v4l@cerqueira.org>
 422  */
 423 static int get_key_pinnacle_color(struct IR_i2c *ir, enum rc_type *protocol,
 424                                   u32 *scancode, u8 *toggle)
 425 {
 426         /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
 427          *
 428          * this is the only value that results in 42 unique
 429          * codes < 128
 430          */
 431
 432         return get_key_pinnacle(ir, protocol, scancode, toggle, 2, 0x80, 0x88);
 433 }
 434
 435 void saa7134_input_irq(struct saa7134_dev *dev)
 436 {
 437         struct saa7134_card_ir *ir;
 438
 439         if (!dev || !dev->remote)
 440                 return;
 441
 442         ir = dev->remote;
 443         if (!ir->running)
 444                 return;
 445
 446         if (!ir->polling && !ir->raw_decode) {
 447                 build_key(dev);
 448         } else if (ir->raw_decode) {
 449                 saa7134_raw_decode_irq(dev);
 450         }
 451 }
 452
 453 static void saa7134_input_timer(unsigned long data)
 454 {
 455         struct saa7134_dev *dev = (struct saa7134_dev *)data;
 456         struct saa7134_card_ir *ir = dev->remote;
 457
 458         build_key(dev);
 459         mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling));
 460 }
 461
 462 static void ir_raw_decode_timer_end(unsigned long data)
 463 {
 464         struct saa7134_dev *dev = (struct saa7134_dev *)data;
 465
 466         ir_raw_event_handle(dev->remote->dev);
 467 }
 468
 469 static int __saa7134_ir_start(void *priv)
 470 {
 471         struct saa7134_dev *dev = priv;
 472         struct saa7134_card_ir *ir;
 473
 474         if (!dev || !dev->remote)
 475                 return -EINVAL;
 476
 477         ir  = dev->remote;
 478         if (ir->running)
 479                 return 0;
 480
 481         /* Moved here from saa7134_input_init1() because the latter
 482          * is not called on device resume */
 483         switch (dev->board) {
 484         case SAA7134_BOARD_MD2819:
 485         case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
 486         case SAA7134_BOARD_AVERMEDIA_305:
 487         case SAA7134_BOARD_AVERMEDIA_307:
 488         case SAA7134_BOARD_AVERMEDIA_505:
 489         case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
 490         case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
 491         case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
 492         case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
 493         case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
 494         case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
 495         case SAA7134_BOARD_AVERMEDIA_M102:
 496         case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
 497                 /* Without this we won't receive key up events */
 498                 saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
 499                 saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
 500                 break;
 501         case SAA7134_BOARD_AVERMEDIA_777:
 502         case SAA7134_BOARD_AVERMEDIA_A16AR:
 503                 /* Without this we won't receive key up events */
 504                 saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
 505                 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
 506                 break;
 507         case SAA7134_BOARD_AVERMEDIA_A16D:
 508                 /* Without this we won't receive key up events */
 509                 saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
 510                 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
 511                 break;
 512         case SAA7134_BOARD_GOTVIEW_7135:
 513                 saa_setb(SAA7134_GPIO_GPMODE1, 0x80);
 514                 break;
 515         }
 516
 517         ir->running = true;
 518
 519         if (ir->polling) {
 520                 setup_timer(&ir->timer, saa7134_input_timer,
 521                             (unsigned long)dev);
 522                 ir->timer.expires = jiffies + HZ;
 523                 add_timer(&ir->timer);
 524         } else if (ir->raw_decode) {
 525                 /* set timer_end for code completion */
 526                 setup_timer(&ir->timer, ir_raw_decode_timer_end,
 527                             (unsigned long)dev);
 528         }
 529
 530         return 0;
 531 }
 532
 533 static void __saa7134_ir_stop(void *priv)
 534 {
 535         struct saa7134_dev *dev = priv;
 536         struct saa7134_card_ir *ir;
 537
 538         if (!dev || !dev->remote)
 539                 return;
 540
 541         ir  = dev->remote;
 542         if (!ir->running)
 543                 return;
 544
 545         if (ir->polling || ir->raw_decode)
 546                 del_timer_sync(&ir->timer);
 547
 548         ir->running = false;
 549
 550         return;
 551 }
 552
 553 int saa7134_ir_start(struct saa7134_dev *dev)
 554 {
 555         if (dev->remote->users)
 556                 return __saa7134_ir_start(dev);
 557
 558         return 0;
 559 }
 560
 561 void saa7134_ir_stop(struct saa7134_dev *dev)
 562 {
 563         if (dev->remote->users)
 564                 __saa7134_ir_stop(dev);
 565 }
 566
 567 static int saa7134_ir_open(struct rc_dev *rc)
 568 {
 569         struct saa7134_dev *dev = rc->priv;
 570
 571         dev->remote->users++;
 572         return __saa7134_ir_start(dev);
 573 }
 574
 575 static void saa7134_ir_close(struct rc_dev *rc)
 576 {
 577         struct saa7134_dev *dev = rc->priv;
 578
 579         dev->remote->users--;
 580         if (!dev->remote->users)
 581                 __saa7134_ir_stop(dev);
 582 }
 583
 584 int saa7134_input_init1(struct saa7134_dev *dev)
 585 {
 586         struct saa7134_card_ir *ir;
 587         struct rc_dev *rc;
 588         char *ir_codes = NULL;
 589         u32 mask_keycode = 0;
 590         u32 mask_keydown = 0;
 591         u32 mask_keyup   = 0;
 592         unsigned polling = 0;
 593         bool raw_decode  = false;
 594         int err;
 595
 596         if (dev->has_remote != SAA7134_REMOTE_GPIO)
 597                 return -ENODEV;
 598         if (disable_ir)
 599                 return -ENODEV;
 600
 601         /* detect & configure */
 602         switch (dev->board) {
 603         case SAA7134_BOARD_FLYVIDEO2000:
 604         case SAA7134_BOARD_FLYVIDEO3000:
 605         case SAA7134_BOARD_FLYTVPLATINUM_FM:
 606         case SAA7134_BOARD_FLYTVPLATINUM_MINI2:
 607         case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM:
 608                 ir_codes     = RC_MAP_FLYVIDEO;
 609                 mask_keycode = 0xEC00000;
 610                 mask_keydown = 0x0040000;
 611                 break;
 612         case SAA7134_BOARD_CINERGY400:
 613         case SAA7134_BOARD_CINERGY600:
 614         case SAA7134_BOARD_CINERGY600_MK3:
 615                 ir_codes     = RC_MAP_CINERGY;
 616                 mask_keycode = 0x00003f;
 617                 mask_keyup   = 0x040000;
 618                 break;
 619         case SAA7134_BOARD_ECS_TVP3XP:
 620         case SAA7134_BOARD_ECS_TVP3XP_4CB5:
 621                 ir_codes     = RC_MAP_EZTV;
 622                 mask_keycode = 0x00017c;
 623                 mask_keyup   = 0x000002;
 624                 polling      = 50; // ms
 625                 break;
 626         case SAA7134_BOARD_KWORLD_XPERT:
 627         case SAA7134_BOARD_AVACSSMARTTV:
 628                 ir_codes     = RC_MAP_PIXELVIEW;
 629                 mask_keycode = 0x00001F;
 630                 mask_keyup   = 0x000020;
 631                 polling      = 50; // ms
 632                 break;
 633         case SAA7134_BOARD_MD2819:
 634         case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
 635         case SAA7134_BOARD_AVERMEDIA_305:
 636         case SAA7134_BOARD_AVERMEDIA_307:
 637         case SAA7134_BOARD_AVERMEDIA_505:
 638         case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
 639         case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
 640         case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
 641         case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
 642         case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
 643         case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
 644         case SAA7134_BOARD_AVERMEDIA_M102:
 645         case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
 646                 ir_codes     = RC_MAP_AVERMEDIA;
 647                 mask_keycode = 0x0007C8;
 648                 mask_keydown = 0x000010;
 649                 polling      = 50; // ms
 650                 /* GPIO stuff moved to __saa7134_ir_start() */
 651                 break;
 652         case SAA7134_BOARD_AVERMEDIA_M135A:
 653                 ir_codes     = RC_MAP_AVERMEDIA_M135A;
 654                 mask_keydown = 0x0040000;       /* Enable GPIO18 line on both edges */
 655                 mask_keyup   = 0x0040000;
 656                 mask_keycode = 0xffff;
 657                 raw_decode   = true;
 658                 break;
 659         case SAA7134_BOARD_AVERMEDIA_M733A:
 660                 ir_codes     = RC_MAP_AVERMEDIA_M733A_RM_K6;
 661                 mask_keydown = 0x0040000;
 662                 mask_keyup   = 0x0040000;
 663                 mask_keycode = 0xffff;
 664                 raw_decode   = true;
 665                 break;
 666         case SAA7134_BOARD_AVERMEDIA_777:
 667         case SAA7134_BOARD_AVERMEDIA_A16AR:
 668                 ir_codes     = RC_MAP_AVERMEDIA;
 669                 mask_keycode = 0x02F200;
 670                 mask_keydown = 0x000400;
 671                 polling      = 50; // ms
 672                 /* GPIO stuff moved to __saa7134_ir_start() */
 673                 break;
 674         case SAA7134_BOARD_AVERMEDIA_A16D:
 675                 ir_codes     = RC_MAP_AVERMEDIA_A16D;
 676                 mask_keycode = 0x02F200;
 677                 mask_keydown = 0x000400;
 678                 polling      = 50; /* ms */
 679                 /* GPIO stuff moved to __saa7134_ir_start() */
 680                 break;
 681         case SAA7134_BOARD_KWORLD_TERMINATOR:
 682                 ir_codes     = RC_MAP_PIXELVIEW;
 683                 mask_keycode = 0x00001f;
 684                 mask_keyup   = 0x000060;
 685                 polling      = 50; // ms
 686                 break;
 687         case SAA7134_BOARD_MANLI_MTV001:
 688         case SAA7134_BOARD_MANLI_MTV002:
 689                 ir_codes     = RC_MAP_MANLI;
 690                 mask_keycode = 0x001f00;
 691                 mask_keyup   = 0x004000;
 692                 polling      = 50; /* ms */
 693                 break;
 694         case SAA7134_BOARD_BEHOLD_409FM:
 695         case SAA7134_BOARD_BEHOLD_401:
 696         case SAA7134_BOARD_BEHOLD_403:
 697         case SAA7134_BOARD_BEHOLD_403FM:
 698         case SAA7134_BOARD_BEHOLD_405:
 699         case SAA7134_BOARD_BEHOLD_405FM:
 700         case SAA7134_BOARD_BEHOLD_407:
 701         case SAA7134_BOARD_BEHOLD_407FM:
 702         case SAA7134_BOARD_BEHOLD_409:
 703         case SAA7134_BOARD_BEHOLD_505FM:
 704         case SAA7134_BOARD_BEHOLD_505RDS_MK5:
 705         case SAA7134_BOARD_BEHOLD_505RDS_MK3:
 706         case SAA7134_BOARD_BEHOLD_507_9FM:
 707         case SAA7134_BOARD_BEHOLD_507RDS_MK3:
 708         case SAA7134_BOARD_BEHOLD_507RDS_MK5:
 709                 ir_codes     = RC_MAP_MANLI;
 710                 mask_keycode = 0x003f00;
 711                 mask_keyup   = 0x004000;
 712                 polling      = 50; /* ms */
 713                 break;
 714         case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM:
 715                 ir_codes     = RC_MAP_BEHOLD_COLUMBUS;
 716                 mask_keycode = 0x003f00;
 717                 mask_keyup   = 0x004000;
 718                 polling      = 50; // ms
 719                 break;
 720         case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS:
 721                 ir_codes     = RC_MAP_PCTV_SEDNA;
 722                 mask_keycode = 0x001f00;
 723                 mask_keyup   = 0x004000;
 724                 polling      = 50; // ms
 725                 break;
 726         case SAA7134_BOARD_GOTVIEW_7135:
 727                 ir_codes     = RC_MAP_GOTVIEW7135;
 728                 mask_keycode = 0x0003CC;
 729                 mask_keydown = 0x000010;
 730                 polling      = 5; /* ms */
 731                 /* GPIO stuff moved to __saa7134_ir_start() */
 732                 break;
 733         case SAA7134_BOARD_VIDEOMATE_TV_PVR:
 734         case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS:
 735         case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII:
 736                 ir_codes     = RC_MAP_VIDEOMATE_TV_PVR;
 737                 mask_keycode = 0x00003F;
 738                 mask_keyup   = 0x400000;
 739                 polling      = 50; // ms
 740                 break;
 741         case SAA7134_BOARD_PROTEUS_2309:
 742                 ir_codes     = RC_MAP_PROTEUS_2309;
 743                 mask_keycode = 0x00007F;
 744                 mask_keyup   = 0x000080;
 745                 polling      = 50; // ms
 746                 break;
 747         case SAA7134_BOARD_VIDEOMATE_DVBT_300:
 748         case SAA7134_BOARD_VIDEOMATE_DVBT_200:
 749                 ir_codes     = RC_MAP_VIDEOMATE_TV_PVR;
 750                 mask_keycode = 0x003F00;
 751                 mask_keyup   = 0x040000;
 752                 break;
 753         case SAA7134_BOARD_FLYDVBS_LR300:
 754         case SAA7134_BOARD_FLYDVBT_LR301:
 755         case SAA7134_BOARD_FLYDVBTDUO:
 756                 ir_codes     = RC_MAP_FLYDVB;
 757                 mask_keycode = 0x0001F00;
 758                 mask_keydown = 0x0040000;
 759                 break;
 760         case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
 761         case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA:
 762         case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
 763                 ir_codes     = RC_MAP_ASUS_PC39;
 764                 mask_keydown = 0x0040000;       /* Enable GPIO18 line on both edges */
 765                 mask_keyup   = 0x0040000;
 766                 mask_keycode = 0xffff;
 767                 raw_decode   = true;
 768                 break;
 769         case SAA7134_BOARD_ASUSTeK_PS3_100:
 770                 ir_codes     = RC_MAP_ASUS_PS3_100;
 771                 mask_keydown = 0x0040000;
 772                 mask_keyup   = 0x0040000;
 773                 mask_keycode = 0xffff;
 774                 raw_decode   = true;
 775                 break;
 776         case SAA7134_BOARD_ENCORE_ENLTV:
 777         case SAA7134_BOARD_ENCORE_ENLTV_FM:
 778                 ir_codes     = RC_MAP_ENCORE_ENLTV;
 779                 mask_keycode = 0x00007f;
 780                 mask_keyup   = 0x040000;
 781                 polling      = 50; // ms
 782                 break;
 783         case SAA7134_BOARD_ENCORE_ENLTV_FM53:
 784         case SAA7134_BOARD_ENCORE_ENLTV_FM3:
 785                 ir_codes     = RC_MAP_ENCORE_ENLTV_FM53;
 786                 mask_keydown = 0x0040000;       /* Enable GPIO18 line on both edges */
 787                 mask_keyup   = 0x0040000;
 788                 mask_keycode = 0xffff;
 789                 raw_decode   = true;
 790                 break;
 791         case SAA7134_BOARD_10MOONSTVMASTER3:
 792                 ir_codes     = RC_MAP_ENCORE_ENLTV;
 793                 mask_keycode = 0x5f80000;
 794                 mask_keyup   = 0x8000000;
 795                 polling      = 50; //ms
 796                 break;
 797         case SAA7134_BOARD_GENIUS_TVGO_A11MCE:
 798                 ir_codes     = RC_MAP_GENIUS_TVGO_A11MCE;
 799                 mask_keycode = 0xff;
 800                 mask_keydown = 0xf00000;
 801                 polling = 50; /* ms */
 802                 break;
 803         case SAA7134_BOARD_REAL_ANGEL_220:
 804                 ir_codes     = RC_MAP_REAL_AUDIO_220_32_KEYS;
 805                 mask_keycode = 0x3f00;
 806                 mask_keyup   = 0x4000;
 807                 polling = 50; /* ms */
 808                 break;
 809         case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
 810                 ir_codes     = RC_MAP_KWORLD_PLUS_TV_ANALOG;
 811                 mask_keycode = 0x7f;
 812                 polling = 40; /* ms */
 813                 break;
 814         case SAA7134_BOARD_VIDEOMATE_S350:
 815                 ir_codes     = RC_MAP_VIDEOMATE_S350;
 816                 mask_keycode = 0x003f00;
 817                 mask_keydown = 0x040000;
 818                 break;
 819         case SAA7134_BOARD_LEADTEK_WINFAST_DTV1000S:
 820                 ir_codes     = RC_MAP_WINFAST;
 821                 mask_keycode = 0x5f00;
 822                 mask_keyup   = 0x020000;
 823                 polling      = 50; /* ms */
 824                 break;
 825         case SAA7134_BOARD_VIDEOMATE_M1F:
 826                 ir_codes     = RC_MAP_VIDEOMATE_K100;
 827                 mask_keycode = 0x0ff00;
 828                 mask_keyup   = 0x040000;
 829                 break;
 830         case SAA7134_BOARD_HAUPPAUGE_HVR1150:
 831         case SAA7134_BOARD_HAUPPAUGE_HVR1120:
 832                 ir_codes     = RC_MAP_HAUPPAUGE;
 833                 mask_keydown = 0x0040000;       /* Enable GPIO18 line on both edges */
 834                 mask_keyup   = 0x0040000;
 835                 mask_keycode = 0xffff;
 836                 raw_decode   = true;
 837                 break;
 838         case SAA7134_BOARD_LEADTEK_WINFAST_TV2100_FM:
 839                 ir_codes     = RC_MAP_LEADTEK_Y04G0051;
 840                 mask_keydown = 0x0040000;       /* Enable GPIO18 line on both edges */
 841                 mask_keyup   = 0x0040000;
 842                 mask_keycode = 0xffff;
 843                 raw_decode   = true;
 844                 break;
 845         }
 846         if (NULL == ir_codes) {
 847                 pr_err("Oops: IR config error [card=%d]\n", dev->board);
 848                 return -ENODEV;
 849         }
 850
 851         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
 852         rc = rc_allocate_device();
 853         if (!ir || !rc) {
 854                 err = -ENOMEM;
 855                 goto err_out_free;
 856         }
 857
 858         ir->dev = rc;
 859         dev->remote = ir;
 860
 861         /* init hardware-specific stuff */
 862         ir->mask_keycode = mask_keycode;
 863         ir->mask_keydown = mask_keydown;
 864         ir->mask_keyup   = mask_keyup;
 865         ir->polling      = polling;
 866         ir->raw_decode   = raw_decode;
 867
 868         /* init input device */
 869         snprintf(ir->name, sizeof(ir->name), "saa7134 IR (%s)",
 870                  saa7134_boards[dev->board].name);
 871         snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
 872                  pci_name(dev->pci));
 873
 874         rc->priv = dev;
 875         rc->open = saa7134_ir_open;
 876         rc->close = saa7134_ir_close;
 877         if (raw_decode)
 878                 rc->driver_type = RC_DRIVER_IR_RAW;
 879
 880         rc->input_name = ir->name;
 881         rc->input_phys = ir->phys;
 882         rc->input_id.bustype = BUS_PCI;
 883         rc->input_id.version = 1;
 884         if (dev->pci->subsystem_vendor) {
 885                 rc->input_id.vendor  = dev->pci->subsystem_vendor;
 886                 rc->input_id.product = dev->pci->subsystem_device;
 887         } else {
 888                 rc->input_id.vendor  = dev->pci->vendor;
 889                 rc->input_id.product = dev->pci->device;
 890         }
 891         rc->dev.parent = &dev->pci->dev;
 892         rc->map_name = ir_codes;
 893         rc->driver_name = MODULE_NAME;
 894
 895         err = rc_register_device(rc);
 896         if (err)
 897                 goto err_out_free;
 898
 899         return 0;
 900
 901 err_out_free:
 902         rc_free_device(rc);
 903         dev->remote = NULL;
 904         kfree(ir);
 905         return err;
 906 }
 907
 908 void saa7134_input_fini(struct saa7134_dev *dev)
 909 {
 910         if (NULL == dev->remote)
 911                 return;
 912
 913         saa7134_ir_stop(dev);
 914         rc_unregister_device(dev->remote->dev);
 915         kfree(dev->remote);
 916         dev->remote = NULL;
 917 }
 918
 919 void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
 920 {
 921         struct i2c_board_info info;
 922         struct i2c_msg msg_msi = {
 923                 .addr = 0x50,
 924                 .flags = I2C_M_RD,
 925                 .len = 0,
 926                 .buf = NULL,
 927         };
 928         int rc;
 929
 930         if (disable_ir) {
 931                 input_dbg("IR has been disabled, not probing for i2c remote\n");
 932                 return;
 933         }
 934
 935         memset(&info, 0, sizeof(struct i2c_board_info));
 936         memset(&dev->init_data, 0, sizeof(dev->init_data));
 937         strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
 938
 939         switch (dev->board) {
 940         case SAA7134_BOARD_PINNACLE_PCTV_110i:
 941         case SAA7134_BOARD_PINNACLE_PCTV_310i:
 942                 dev->init_data.name = "Pinnacle PCTV";
 943                 if (pinnacle_remote == 0) {
 944                         dev->init_data.get_key = get_key_pinnacle_color;
 945                         dev->init_data.ir_codes = RC_MAP_PINNACLE_COLOR;
 946                         info.addr = 0x47;
 947                 } else {
 948                         dev->init_data.get_key = get_key_pinnacle_grey;
 949                         dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
 950                         info.addr = 0x47;
 951                 }
 952                 break;
 953         case SAA7134_BOARD_UPMOST_PURPLE_TV:
 954                 dev->init_data.name = "Purple TV";
 955                 dev->init_data.get_key = get_key_purpletv;
 956                 dev->init_data.ir_codes = RC_MAP_PURPLETV;
 957                 info.addr = 0x7a;
 958                 break;
 959         case SAA7134_BOARD_MSI_TVATANYWHERE_PLUS:
 960                 dev->init_data.name = "MSI TV@nywhere Plus";
 961                 dev->init_data.get_key = get_key_msi_tvanywhere_plus;
 962                 dev->init_data.ir_codes = RC_MAP_MSI_TVANYWHERE_PLUS;
 963                 /*
 964                  * MSI TV@nyware Plus requires more frequent polling
 965                  * otherwise it will miss some keypresses
 966                  */
 967                 dev->init_data.polling_interval = 50;
 968                 info.addr = 0x30;
 969                 /* MSI TV@nywhere Plus controller doesn't seem to
 970                    respond to probes unless we read something from
 971                    an existing device. Weird...
 972                    REVISIT: might no longer be needed */
 973                 rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
 974                 input_dbg("probe 0x%02x @ %s: %s\n",
 975                         msg_msi.addr, dev->i2c_adap.name,
 976                         (1 == rc) ? "yes" : "no");
 977                 break;
 978         case SAA7134_BOARD_KWORLD_PC150U:
 979                 /* copied and modified from MSI TV@nywhere Plus */
 980                 dev->init_data.name = "Kworld PC150-U";
 981                 dev->init_data.get_key = get_key_kworld_pc150u;
 982                 dev->init_data.ir_codes = RC_MAP_KWORLD_PC150U;
 983                 info.addr = 0x30;
 984                 /* MSI TV@nywhere Plus controller doesn't seem to
 985                    respond to probes unless we read something from
 986                    an existing device. Weird...
 987                    REVISIT: might no longer be needed */
 988                 rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
 989                 input_dbg("probe 0x%02x @ %s: %s\n",
 990                         msg_msi.addr, dev->i2c_adap.name,
 991                         (1 == rc) ? "yes" : "no");
 992                 break;
 993         case SAA7134_BOARD_HAUPPAUGE_HVR1110:
 994                 dev->init_data.name = "HVR 1110";
 995                 dev->init_data.get_key = get_key_hvr1110;
 996                 dev->init_data.ir_codes = RC_MAP_HAUPPAUGE;
 997                 info.addr = 0x71;
 998                 break;
 999         case SAA7134_BOARD_BEHOLD_607FM_MK3:
1000         case SAA7134_BOARD_BEHOLD_607FM_MK5:
1001         case SAA7134_BOARD_BEHOLD_609FM_MK3:
1002         case SAA7134_BOARD_BEHOLD_609FM_MK5:
1003         case SAA7134_BOARD_BEHOLD_607RDS_MK3:
1004         case SAA7134_BOARD_BEHOLD_607RDS_MK5:
1005         case SAA7134_BOARD_BEHOLD_609RDS_MK3:
1006         case SAA7134_BOARD_BEHOLD_609RDS_MK5:
1007         case SAA7134_BOARD_BEHOLD_M6:
1008         case SAA7134_BOARD_BEHOLD_M63:
1009         case SAA7134_BOARD_BEHOLD_M6_EXTRA:
1010         case SAA7134_BOARD_BEHOLD_H6:
1011         case SAA7134_BOARD_BEHOLD_X7:
1012         case SAA7134_BOARD_BEHOLD_H7:
1013         case SAA7134_BOARD_BEHOLD_A7:
1014                 dev->init_data.name = "BeholdTV";
1015                 dev->init_data.get_key = get_key_beholdm6xx;
1016                 dev->init_data.ir_codes = RC_MAP_BEHOLD;
1017                 dev->init_data.type = RC_BIT_NEC;
1018                 info.addr = 0x2d;
1019                 break;
1020         case SAA7134_BOARD_AVERMEDIA_CARDBUS_501:
1021         case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
1022                 info.addr = 0x40;
1023                 break;
1024         case SAA7134_BOARD_AVERMEDIA_A706:
1025                 info.addr = 0x41;
1026                 break;
1027         case SAA7134_BOARD_FLYDVB_TRIO:
1028                 dev->init_data.name = "FlyDVB Trio";
1029                 dev->init_data.get_key = get_key_flydvb_trio;
1030                 dev->init_data.ir_codes = RC_MAP_FLYDVB;
1031                 info.addr = 0x0b;
1032                 break;
1033         default:
1034                 input_dbg("No I2C IR support for board %x\n", dev->board);
1035                 return;
1036         }
1037
1038         if (dev->init_data.name)
1039                 info.platform_data = &dev->init_data;
1040         i2c_new_device(&dev->i2c_adap, &info);
1041 }
1042
1043 static int saa7134_raw_decode_irq(struct saa7134_dev *dev)
1044 {
1045         struct saa7134_card_ir *ir = dev->remote;
1046         unsigned long timeout;
1047         int space;
1048
1049         /* Generate initial event */
1050         saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
1051         saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
1052         space = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & ir->mask_keydown;
1053         ir_raw_event_store_edge(dev->remote->dev, space ? IR_SPACE : IR_PULSE);
1054
1055         /*
1056          * Wait 15 ms from the start of the first IR event before processing
1057          * the event. This time is enough for NEC protocol. May need adjustments
1058          * to work with other protocols.
1059          */
1060         smp_mb();
1061
1062         if (!timer_pending(&ir->timer)) {
1063                 timeout = jiffies + msecs_to_jiffies(15);
1064                 mod_timer(&ir->timer, timeout);
1065         }
1066
1067         return 1;
1068 }