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