drivers/media/usb/em28xx/em28xx-input.c

   1 /*
   2   handle em28xx IR remotes via linux kernel input layer.
   3
   4    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
   5                       Markus Rechberger <mrechberger@gmail.com>
   6                       Mauro Carvalho Chehab <mchehab@infradead.org>
   7                       Sascha Sommer <saschasommer@freenet.de>
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19   You should have received a copy of the GNU General Public License
  20   along with this program; if not, write to the Free Software
  21   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 #include "em28xx.h"
  25
  26 #include <linux/module.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/usb.h>
  31 #include <linux/slab.h>
  32 #include <linux/bitrev.h>
  33
  34 #define EM28XX_SNAPSHOT_KEY                             KEY_CAMERA
  35 #define EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL         500 /* [ms] */
  36 #define EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL          100 /* [ms] */
  37
  38 static unsigned int ir_debug;
  39 module_param(ir_debug, int, 0644);
  40 MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
  41
  42 #define MODULE_NAME "em28xx"
  43
  44 #define dprintk( fmt, arg...) do {                                      \
  45         if (ir_debug)                                                   \
  46                 dev_printk(KERN_DEBUG, &ir->dev->intf->dev,             \
  47                            "input: %s: " fmt, __func__, ## arg);        \
  48 } while (0)
  49
  50 /**********************************************************
  51  Polling structure used by em28xx IR's
  52  **********************************************************/
  53
  54 struct em28xx_ir_poll_result {
  55         unsigned int toggle_bit:1;
  56         unsigned int read_count:7;
  57
  58         enum rc_type protocol;
  59         u32 scancode;
  60 };
  61
  62 struct em28xx_IR {
  63         struct em28xx *dev;
  64         struct rc_dev *rc;
  65         char name[32];
  66         char phys[32];
  67
  68         /* poll decoder */
  69         int polling;
  70         struct delayed_work work;
  71         unsigned int full_code:1;
  72         unsigned int last_readcount;
  73         u64 rc_type;
  74
  75         struct i2c_client *i2c_client;
  76
  77         int  (*get_key_i2c)(struct i2c_client *ir, enum rc_type *protocol, u32 *scancode);
  78         int  (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
  79 };
  80
  81 /**********************************************************
  82  I2C IR based get keycodes - should be used with ir-kbd-i2c
  83  **********************************************************/
  84
  85 static int em28xx_get_key_terratec(struct i2c_client *i2c_dev,
  86                                    enum rc_type *protocol, u32 *scancode)
  87 {
  88         unsigned char b;
  89
  90         /* poll IR chip */
  91         if (1 != i2c_master_recv(i2c_dev, &b, 1))
  92                 return -EIO;
  93
  94         /* it seems that 0xFE indicates that a button is still hold
  95            down, while 0xff indicates that no button is hold down. */
  96
  97         if (b == 0xff)
  98                 return 0;
  99
 100         if (b == 0xfe)
 101                 /* keep old data */
 102                 return 1;
 103
 104         *protocol = RC_TYPE_UNKNOWN;
 105         *scancode = b;
 106         return 1;
 107 }
 108
 109 static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev,
 110                                   enum rc_type *protocol, u32 *scancode)
 111 {
 112         unsigned char buf[2];
 113         int size;
 114
 115         /* poll IR chip */
 116         size = i2c_master_recv(i2c_dev, buf, sizeof(buf));
 117
 118         if (size != 2)
 119                 return -EIO;
 120
 121         /* Does eliminate repeated parity code */
 122         if (buf[1] == 0xff)
 123                 return 0;
 124
 125         /*
 126          * Rearranges bits to the right order.
 127          * The bit order were determined experimentally by using
 128          * The original Hauppauge Grey IR and another RC5 that uses addr=0x08
 129          * The RC5 code has 14 bits, but we've experimentally determined
 130          * the meaning for only 11 bits.
 131          * So, the code translation is not complete. Yet, it is enough to
 132          * work with the provided RC5 IR.
 133          */
 134         *protocol = RC_TYPE_RC5;
 135         *scancode = (bitrev8(buf[1]) & 0x1f) << 8 | bitrev8(buf[0]) >> 2;
 136         return 1;
 137 }
 138
 139 static int em28xx_get_key_pinnacle_usb_grey(struct i2c_client *i2c_dev,
 140                                             enum rc_type *protocol, u32 *scancode)
 141 {
 142         unsigned char buf[3];
 143
 144         /* poll IR chip */
 145
 146         if (3 != i2c_master_recv(i2c_dev, buf, 3))
 147                 return -EIO;
 148
 149         if (buf[0] != 0x00)
 150                 return 0;
 151
 152         *protocol = RC_TYPE_UNKNOWN;
 153         *scancode = buf[2] & 0x3f;
 154         return 1;
 155 }
 156
 157 static int em28xx_get_key_winfast_usbii_deluxe(struct i2c_client *i2c_dev,
 158                                                enum rc_type *protocol, u32 *scancode)
 159 {
 160         unsigned char subaddr, keydetect, key;
 161
 162         struct i2c_msg msg[] = { { .addr = i2c_dev->addr, .flags = 0, .buf = &subaddr, .len = 1},
 163                                  { .addr = i2c_dev->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} };
 164
 165         subaddr = 0x10;
 166         if (2 != i2c_transfer(i2c_dev->adapter, msg, 2))
 167                 return -EIO;
 168         if (keydetect == 0x00)
 169                 return 0;
 170
 171         subaddr = 0x00;
 172         msg[1].buf = &key;
 173         if (2 != i2c_transfer(i2c_dev->adapter, msg, 2))
 174                 return -EIO;
 175         if (key == 0x00)
 176                 return 0;
 177
 178         *protocol = RC_TYPE_UNKNOWN;
 179         *scancode = key;
 180         return 1;
 181 }
 182
 183 /**********************************************************
 184  Poll based get keycode functions
 185  **********************************************************/
 186
 187 /* This is for the em2860/em2880 */
 188 static int default_polling_getkey(struct em28xx_IR *ir,
 189                                   struct em28xx_ir_poll_result *poll_result)
 190 {
 191         struct em28xx *dev = ir->dev;
 192         int rc;
 193         u8 msg[3] = { 0, 0, 0 };
 194
 195         /* Read key toggle, brand, and key code
 196            on registers 0x45, 0x46 and 0x47
 197          */
 198         rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR,
 199                                           msg, sizeof(msg));
 200         if (rc < 0)
 201                 return rc;
 202
 203         /* Infrared toggle (Reg 0x45[7]) */
 204         poll_result->toggle_bit = (msg[0] >> 7);
 205
 206         /* Infrared read count (Reg 0x45[6:0] */
 207         poll_result->read_count = (msg[0] & 0x7f);
 208
 209         /* Remote Control Address/Data (Regs 0x46/0x47) */
 210         switch (ir->rc_type) {
 211         case RC_BIT_RC5:
 212                 poll_result->protocol = RC_TYPE_RC5;
 213                 poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]);
 214                 break;
 215
 216         case RC_BIT_NEC:
 217                 poll_result->protocol = RC_TYPE_NEC;
 218                 poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[2]);
 219                 break;
 220
 221         default:
 222                 poll_result->protocol = RC_TYPE_UNKNOWN;
 223                 poll_result->scancode = msg[1] << 8 | msg[2];
 224                 break;
 225         }
 226
 227         return 0;
 228 }
 229
 230 static int em2874_polling_getkey(struct em28xx_IR *ir,
 231                                  struct em28xx_ir_poll_result *poll_result)
 232 {
 233         struct em28xx *dev = ir->dev;
 234         int rc;
 235         u8 msg[5] = { 0, 0, 0, 0, 0 };
 236
 237         /* Read key toggle, brand, and key code
 238            on registers 0x51-55
 239          */
 240         rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR,
 241                                           msg, sizeof(msg));
 242         if (rc < 0)
 243                 return rc;
 244
 245         /* Infrared toggle (Reg 0x51[7]) */
 246         poll_result->toggle_bit = (msg[0] >> 7);
 247
 248         /* Infrared read count (Reg 0x51[6:0] */
 249         poll_result->read_count = (msg[0] & 0x7f);
 250
 251         /*
 252          * Remote Control Address (Reg 0x52)
 253          * Remote Control Data (Reg 0x53-0x55)
 254          */
 255         switch (ir->rc_type) {
 256         case RC_BIT_RC5:
 257                 poll_result->protocol = RC_TYPE_RC5;
 258                 poll_result->scancode = RC_SCANCODE_RC5(msg[1], msg[2]);
 259                 break;
 260
 261         case RC_BIT_NEC:
 262                 poll_result->scancode = msg[1] << 8 | msg[2];
 263                 if ((msg[3] ^ msg[4]) != 0xff) {        /* 32 bits NEC */
 264                         poll_result->protocol = RC_TYPE_NEC32;
 265                         poll_result->scancode = RC_SCANCODE_NEC32((msg[1] << 24) |
 266                                                                   (msg[2] << 16) |
 267                                                                   (msg[3] << 8)  |
 268                                                                   (msg[4]));
 269                 } else if ((msg[1] ^ msg[2]) != 0xff) { /* 24 bits NEC */
 270                         poll_result->protocol = RC_TYPE_NECX;
 271                         poll_result->scancode = RC_SCANCODE_NECX(msg[1] << 8 |
 272                                                                  msg[2], msg[3]);
 273                 } else {                                /* Normal NEC */
 274                         poll_result->protocol = RC_TYPE_NEC;
 275                         poll_result->scancode = RC_SCANCODE_NEC(msg[1], msg[3]);
 276                 }
 277                 break;
 278
 279         case RC_BIT_RC6_0:
 280                 poll_result->protocol = RC_TYPE_RC6_0;
 281                 poll_result->scancode = RC_SCANCODE_RC6_0(msg[1], msg[2]);
 282                 break;
 283
 284         default:
 285                 poll_result->protocol = RC_TYPE_UNKNOWN;
 286                 poll_result->scancode = (msg[1] << 24) | (msg[2] << 16) |
 287                                         (msg[3] << 8)  | msg[4];
 288                 break;
 289         }
 290
 291         return 0;
 292 }
 293
 294 /**********************************************************
 295  Polling code for em28xx
 296  **********************************************************/
 297
 298 static int em28xx_i2c_ir_handle_key(struct em28xx_IR *ir)
 299 {
 300         static u32 scancode;
 301         enum rc_type protocol;
 302         int rc;
 303
 304         rc = ir->get_key_i2c(ir->i2c_client, &protocol, &scancode);
 305         if (rc < 0) {
 306                 dprintk("ir->get_key_i2c() failed: %d\n", rc);
 307                 return rc;
 308         }
 309
 310         if (rc) {
 311                 dprintk("%s: proto = 0x%04x, scancode = 0x%04x\n",
 312                         __func__, protocol, scancode);
 313                 rc_keydown(ir->rc, protocol, scancode, 0);
 314         }
 315         return 0;
 316 }
 317
 318 static void em28xx_ir_handle_key(struct em28xx_IR *ir)
 319 {
 320         int result;
 321         struct em28xx_ir_poll_result poll_result;
 322
 323         /* read the registers containing the IR status */
 324         result = ir->get_key(ir, &poll_result);
 325         if (unlikely(result < 0)) {
 326                 dprintk("ir->get_key() failed: %d\n", result);
 327                 return;
 328         }
 329
 330         if (unlikely(poll_result.read_count != ir->last_readcount)) {
 331                 dprintk("%s: toggle: %d, count: %d, key 0x%04x\n", __func__,
 332                         poll_result.toggle_bit, poll_result.read_count,
 333                         poll_result.scancode);
 334                 if (ir->full_code)
 335                         rc_keydown(ir->rc,
 336                                    poll_result.protocol,
 337                                    poll_result.scancode,
 338                                    poll_result.toggle_bit);
 339                 else
 340                         rc_keydown(ir->rc,
 341                                    RC_TYPE_UNKNOWN,
 342                                    poll_result.scancode & 0xff,
 343                                    poll_result.toggle_bit);
 344
 345                 if (ir->dev->chip_id == CHIP_ID_EM2874 ||
 346                     ir->dev->chip_id == CHIP_ID_EM2884)
 347                         /* The em2874 clears the readcount field every time the
 348                            register is read.  The em2860/2880 datasheet says that it
 349                            is supposed to clear the readcount, but it doesn't.  So with
 350                            the em2874, we are looking for a non-zero read count as
 351                            opposed to a readcount that is incrementing */
 352                         ir->last_readcount = 0;
 353                 else
 354                         ir->last_readcount = poll_result.read_count;
 355         }
 356 }
 357
 358 static void em28xx_ir_work(struct work_struct *work)
 359 {
 360         struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work);
 361
 362         if (ir->i2c_client) /* external i2c device */
 363                 em28xx_i2c_ir_handle_key(ir);
 364         else /* internal device */
 365                 em28xx_ir_handle_key(ir);
 366         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 367 }
 368
 369 static int em28xx_ir_start(struct rc_dev *rc)
 370 {
 371         struct em28xx_IR *ir = rc->priv;
 372
 373         INIT_DELAYED_WORK(&ir->work, em28xx_ir_work);
 374         schedule_delayed_work(&ir->work, 0);
 375
 376         return 0;
 377 }
 378
 379 static void em28xx_ir_stop(struct rc_dev *rc)
 380 {
 381         struct em28xx_IR *ir = rc->priv;
 382
 383         cancel_delayed_work_sync(&ir->work);
 384 }
 385
 386 static int em2860_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
 387 {
 388         struct em28xx_IR *ir = rc_dev->priv;
 389         struct em28xx *dev = ir->dev;
 390
 391         /* Adjust xclk based on IR table for RC5/NEC tables */
 392         if (*rc_type & RC_BIT_RC5) {
 393                 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
 394                 ir->full_code = 1;
 395                 *rc_type = RC_BIT_RC5;
 396         } else if (*rc_type & RC_BIT_NEC) {
 397                 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
 398                 ir->full_code = 1;
 399                 *rc_type = RC_BIT_NEC;
 400         } else if (*rc_type & RC_BIT_UNKNOWN) {
 401                 *rc_type = RC_BIT_UNKNOWN;
 402         } else {
 403                 *rc_type = ir->rc_type;
 404                 return -EINVAL;
 405         }
 406         em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
 407                               EM28XX_XCLK_IR_RC5_MODE);
 408
 409         ir->rc_type = *rc_type;
 410
 411         return 0;
 412 }
 413
 414 static int em2874_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
 415 {
 416         struct em28xx_IR *ir = rc_dev->priv;
 417         struct em28xx *dev = ir->dev;
 418         u8 ir_config = EM2874_IR_RC5;
 419
 420         /* Adjust xclk and set type based on IR table for RC5/NEC/RC6 tables */
 421         if (*rc_type & RC_BIT_RC5) {
 422                 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
 423                 ir->full_code = 1;
 424                 *rc_type = RC_BIT_RC5;
 425         } else if (*rc_type & RC_BIT_NEC) {
 426                 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
 427                 ir_config = EM2874_IR_NEC | EM2874_IR_NEC_NO_PARITY;
 428                 ir->full_code = 1;
 429                 *rc_type = RC_BIT_NEC;
 430         } else if (*rc_type & RC_BIT_RC6_0) {
 431                 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
 432                 ir_config = EM2874_IR_RC6_MODE_0;
 433                 ir->full_code = 1;
 434                 *rc_type = RC_BIT_RC6_0;
 435         } else if (*rc_type & RC_BIT_UNKNOWN) {
 436                 *rc_type = RC_BIT_UNKNOWN;
 437         } else {
 438                 *rc_type = ir->rc_type;
 439                 return -EINVAL;
 440         }
 441         em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
 442         em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
 443                               EM28XX_XCLK_IR_RC5_MODE);
 444
 445         ir->rc_type = *rc_type;
 446
 447         return 0;
 448 }
 449 static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
 450 {
 451         struct em28xx_IR *ir = rc_dev->priv;
 452         struct em28xx *dev = ir->dev;
 453
 454         /* Setup the proper handler based on the chip */
 455         switch (dev->chip_id) {
 456         case CHIP_ID_EM2860:
 457         case CHIP_ID_EM2883:
 458                 return em2860_ir_change_protocol(rc_dev, rc_type);
 459         case CHIP_ID_EM2884:
 460         case CHIP_ID_EM2874:
 461         case CHIP_ID_EM28174:
 462         case CHIP_ID_EM28178:
 463                 return em2874_ir_change_protocol(rc_dev, rc_type);
 464         default:
 465                 dev_err(&ir->dev->intf->dev,
 466                         "Unrecognized em28xx chip id 0x%02x: IR not supported\n",
 467                         dev->chip_id);
 468                 return -EINVAL;
 469         }
 470 }
 471
 472 static int em28xx_probe_i2c_ir(struct em28xx *dev)
 473 {
 474         int i = 0;
 475         /* Leadtek winfast tv USBII deluxe can find a non working IR-device */
 476         /* at address 0x18, so if that address is needed for another board in */
 477         /* the future, please put it after 0x1f. */
 478         const unsigned short addr_list[] = {
 479                  0x1f, 0x30, 0x47, I2C_CLIENT_END
 480         };
 481
 482         while (addr_list[i] != I2C_CLIENT_END) {
 483                 if (i2c_probe_func_quick_read(&dev->i2c_adap[dev->def_i2c_bus], addr_list[i]) == 1)
 484                         return addr_list[i];
 485                 i++;
 486         }
 487
 488         return -ENODEV;
 489 }
 490
 491 /**********************************************************
 492  Handle buttons
 493  **********************************************************/
 494
 495 static void em28xx_query_buttons(struct work_struct *work)
 496 {
 497         struct em28xx *dev =
 498                 container_of(work, struct em28xx, buttons_query_work.work);
 499         u8 i, j;
 500         int regval;
 501         bool is_pressed, was_pressed;
 502         const struct em28xx_led *led;
 503
 504         /* Poll and evaluate all addresses */
 505         for (i = 0; i < dev->num_button_polling_addresses; i++) {
 506                 /* Read value from register */
 507                 regval = em28xx_read_reg(dev, dev->button_polling_addresses[i]);
 508                 if (regval < 0)
 509                         continue;
 510                 /* Check states of the buttons and act */
 511                 j = 0;
 512                 while (dev->board.buttons[j].role >= 0 &&
 513                        dev->board.buttons[j].role < EM28XX_NUM_BUTTON_ROLES) {
 514                         struct em28xx_button *button = &dev->board.buttons[j];
 515                         /* Check if button uses the current address */
 516                         if (button->reg_r != dev->button_polling_addresses[i]) {
 517                                 j++;
 518                                 continue;
 519                         }
 520                         /* Determine if button is and was pressed last time */
 521                         is_pressed = regval & button->mask;
 522                         was_pressed = dev->button_polling_last_values[i]
 523                                        & button->mask;
 524                         if (button->inverted) {
 525                                 is_pressed = !is_pressed;
 526                                 was_pressed = !was_pressed;
 527                         }
 528                         /* Clear button state (if needed) */
 529                         if (is_pressed && button->reg_clearing)
 530                                 em28xx_write_reg(dev, button->reg_clearing,
 531                                                  (~regval & button->mask)
 532                                                     | (regval & ~button->mask));
 533                         /* Handle button state */
 534                         if (!is_pressed || was_pressed) {
 535                                 j++;
 536                                 continue;
 537                         }
 538                         switch (button->role) {
 539                         case EM28XX_BUTTON_SNAPSHOT:
 540                                 /* Emulate the keypress */
 541                                 input_report_key(dev->sbutton_input_dev,
 542                                                  EM28XX_SNAPSHOT_KEY, 1);
 543                                 /* Unpress the key */
 544                                 input_report_key(dev->sbutton_input_dev,
 545                                                  EM28XX_SNAPSHOT_KEY, 0);
 546                                 break;
 547                         case EM28XX_BUTTON_ILLUMINATION:
 548                                 led = em28xx_find_led(dev,
 549                                                       EM28XX_LED_ILLUMINATION);
 550                                 /* Switch illumination LED on/off */
 551                                 if (led)
 552                                         em28xx_toggle_reg_bits(dev,
 553                                                                led->gpio_reg,
 554                                                                led->gpio_mask);
 555                                 break;
 556                         default:
 557                                 WARN_ONCE(1, "BUG: unhandled button role.");
 558                         }
 559                         /* Next button */
 560                         j++;
 561                 }
 562                 /* Save current value for comparison during the next polling */
 563                 dev->button_polling_last_values[i] = regval;
 564         }
 565         /* Schedule next poll */
 566         schedule_delayed_work(&dev->buttons_query_work,
 567                               msecs_to_jiffies(dev->button_polling_interval));
 568 }
 569
 570 static int em28xx_register_snapshot_button(struct em28xx *dev)
 571 {
 572         struct usb_device *udev = interface_to_usbdev(dev->intf);
 573         struct input_dev *input_dev;
 574         int err;
 575
 576         dev_info(&dev->intf->dev, "Registering snapshot button...\n");
 577         input_dev = input_allocate_device();
 578         if (!input_dev)
 579                 return -ENOMEM;
 580
 581         usb_make_path(udev, dev->snapshot_button_path,
 582                       sizeof(dev->snapshot_button_path));
 583         strlcat(dev->snapshot_button_path, "/sbutton",
 584                 sizeof(dev->snapshot_button_path));
 585
 586         input_dev->name = "em28xx snapshot button";
 587         input_dev->phys = dev->snapshot_button_path;
 588         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 589         set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit);
 590         input_dev->keycodesize = 0;
 591         input_dev->keycodemax = 0;
 592         input_dev->id.bustype = BUS_USB;
 593         input_dev->id.vendor = le16_to_cpu(udev->descriptor.idVendor);
 594         input_dev->id.product = le16_to_cpu(udev->descriptor.idProduct);
 595         input_dev->id.version = 1;
 596         input_dev->dev.parent = &dev->intf->dev;
 597
 598         err = input_register_device(input_dev);
 599         if (err) {
 600                 dev_err(&dev->intf->dev, "input_register_device failed\n");
 601                 input_free_device(input_dev);
 602                 return err;
 603         }
 604
 605         dev->sbutton_input_dev = input_dev;
 606         return 0;
 607 }
 608
 609 static void em28xx_init_buttons(struct em28xx *dev)
 610 {
 611         u8  i = 0, j = 0;
 612         bool addr_new = false;
 613
 614         dev->button_polling_interval = EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL;
 615         while (dev->board.buttons[i].role >= 0 &&
 616                dev->board.buttons[i].role < EM28XX_NUM_BUTTON_ROLES) {
 617                 struct em28xx_button *button = &dev->board.buttons[i];
 618                 /* Check if polling address is already on the list */
 619                 addr_new = true;
 620                 for (j = 0; j < dev->num_button_polling_addresses; j++) {
 621                         if (button->reg_r == dev->button_polling_addresses[j]) {
 622                                 addr_new = false;
 623                                 break;
 624                         }
 625                 }
 626                 /* Check if max. number of polling addresses is exceeded */
 627                 if (addr_new && dev->num_button_polling_addresses
 628                                            >= EM28XX_NUM_BUTTON_ADDRESSES_MAX) {
 629                         WARN_ONCE(1, "BUG: maximum number of button polling addresses exceeded.");
 630                         goto next_button;
 631                 }
 632                 /* Button role specific checks and actions */
 633                 if (button->role == EM28XX_BUTTON_SNAPSHOT) {
 634                         /* Register input device */
 635                         if (em28xx_register_snapshot_button(dev) < 0)
 636                                 goto next_button;
 637                 } else if (button->role == EM28XX_BUTTON_ILLUMINATION) {
 638                         /* Check sanity */
 639                         if (!em28xx_find_led(dev, EM28XX_LED_ILLUMINATION)) {
 640                                 dev_err(&dev->intf->dev,
 641                                         "BUG: illumination button defined, but no illumination LED.\n");
 642                                 goto next_button;
 643                         }
 644                 }
 645                 /* Add read address to list of polling addresses */
 646                 if (addr_new) {
 647                         unsigned int index = dev->num_button_polling_addresses;
 648                         dev->button_polling_addresses[index] = button->reg_r;
 649                         dev->num_button_polling_addresses++;
 650                 }
 651                 /* Reduce polling interval if necessary */
 652                 if (!button->reg_clearing)
 653                         dev->button_polling_interval =
 654                                          EM28XX_BUTTONS_VOLATILE_QUERY_INTERVAL;
 655 next_button:
 656                 /* Next button */
 657                 i++;
 658         }
 659
 660         /* Start polling */
 661         if (dev->num_button_polling_addresses) {
 662                 memset(dev->button_polling_last_values, 0,
 663                        EM28XX_NUM_BUTTON_ADDRESSES_MAX);
 664                 schedule_delayed_work(&dev->buttons_query_work,
 665                                       msecs_to_jiffies(dev->button_polling_interval));
 666         }
 667 }
 668
 669 static void em28xx_shutdown_buttons(struct em28xx *dev)
 670 {
 671         /* Cancel polling */
 672         cancel_delayed_work_sync(&dev->buttons_query_work);
 673         /* Clear polling addresses list */
 674         dev->num_button_polling_addresses = 0;
 675         /* Deregister input devices */
 676         if (dev->sbutton_input_dev != NULL) {
 677                 dev_info(&dev->intf->dev, "Deregistering snapshot button\n");
 678                 input_unregister_device(dev->sbutton_input_dev);
 679                 dev->sbutton_input_dev = NULL;
 680         }
 681 }
 682
 683 static int em28xx_ir_init(struct em28xx *dev)
 684 {
 685         struct usb_device *udev = interface_to_usbdev(dev->intf);
 686         struct em28xx_IR *ir;
 687         struct rc_dev *rc;
 688         int err = -ENOMEM;
 689         u64 rc_type;
 690         u16 i2c_rc_dev_addr = 0;
 691
 692         if (dev->is_audio_only) {
 693                 /* Shouldn't initialize IR for this interface */
 694                 return 0;
 695         }
 696
 697         kref_get(&dev->ref);
 698         INIT_DELAYED_WORK(&dev->buttons_query_work, em28xx_query_buttons);
 699
 700         if (dev->board.buttons)
 701                 em28xx_init_buttons(dev);
 702
 703         if (dev->board.has_ir_i2c) {
 704                 i2c_rc_dev_addr = em28xx_probe_i2c_ir(dev);
 705                 if (!i2c_rc_dev_addr) {
 706                         dev->board.has_ir_i2c = 0;
 707                         dev_warn(&dev->intf->dev,
 708                                  "No i2c IR remote control device found.\n");
 709                         return -ENODEV;
 710                 }
 711         }
 712
 713         if (dev->board.ir_codes == NULL && !dev->board.has_ir_i2c) {
 714                 /* No remote control support */
 715                 dev_warn(&dev->intf->dev,
 716                          "Remote control support is not available for this card.\n");
 717                 return 0;
 718         }
 719
 720         dev_info(&dev->intf->dev, "Registering input extension\n");
 721
 722         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
 723         if (!ir)
 724                 return -ENOMEM;
 725         rc = rc_allocate_device(RC_DRIVER_SCANCODE);
 726         if (!rc)
 727                 goto error;
 728
 729         /* record handles to ourself */
 730         ir->dev = dev;
 731         dev->ir = ir;
 732         ir->rc = rc;
 733
 734         rc->priv = ir;
 735         rc->open = em28xx_ir_start;
 736         rc->close = em28xx_ir_stop;
 737
 738         if (dev->board.has_ir_i2c) {    /* external i2c device */
 739                 switch (dev->model) {
 740                 case EM2800_BOARD_TERRATEC_CINERGY_200:
 741                 case EM2820_BOARD_TERRATEC_CINERGY_250:
 742                         rc->map_name = RC_MAP_EM_TERRATEC;
 743                         ir->get_key_i2c = em28xx_get_key_terratec;
 744                         break;
 745                 case EM2820_BOARD_PINNACLE_USB_2:
 746                         rc->map_name = RC_MAP_PINNACLE_GREY;
 747                         ir->get_key_i2c = em28xx_get_key_pinnacle_usb_grey;
 748                         break;
 749                 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
 750                         rc->map_name = RC_MAP_HAUPPAUGE;
 751                         ir->get_key_i2c = em28xx_get_key_em_haup;
 752                         rc->allowed_protocols = RC_BIT_RC5;
 753                         break;
 754                 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
 755                         rc->map_name = RC_MAP_WINFAST_USBII_DELUXE;
 756                         ir->get_key_i2c = em28xx_get_key_winfast_usbii_deluxe;
 757                         break;
 758                 default:
 759                         err = -ENODEV;
 760                         goto error;
 761                 }
 762
 763                 ir->i2c_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 764                 if (!ir->i2c_client)
 765                         goto error;
 766                 ir->i2c_client->adapter = &ir->dev->i2c_adap[dev->def_i2c_bus];
 767                 ir->i2c_client->addr = i2c_rc_dev_addr;
 768                 ir->i2c_client->flags = 0;
 769                 /* NOTE: all other fields of i2c_client are unused */
 770         } else {        /* internal device */
 771                 switch (dev->chip_id) {
 772                 case CHIP_ID_EM2860:
 773                 case CHIP_ID_EM2883:
 774                         rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC;
 775                         ir->get_key = default_polling_getkey;
 776                         break;
 777                 case CHIP_ID_EM2884:
 778                 case CHIP_ID_EM2874:
 779                 case CHIP_ID_EM28174:
 780                 case CHIP_ID_EM28178:
 781                         ir->get_key = em2874_polling_getkey;
 782                         rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC |
 783                                 RC_BIT_NECX | RC_BIT_NEC32 | RC_BIT_RC6_0;
 784                         break;
 785                 default:
 786                         err = -ENODEV;
 787                         goto error;
 788                 }
 789
 790                 rc->change_protocol = em28xx_ir_change_protocol;
 791                 rc->map_name = dev->board.ir_codes;
 792
 793                 /* By default, keep protocol field untouched */
 794                 rc_type = RC_BIT_UNKNOWN;
 795                 err = em28xx_ir_change_protocol(rc, &rc_type);
 796                 if (err)
 797                         goto error;
 798         }
 799
 800         /* This is how often we ask the chip for IR information */
 801         ir->polling = 100; /* ms */
 802
 803         /* init input device */
 804         snprintf(ir->name, sizeof(ir->name), "%s IR",
 805                  dev_name(&dev->intf->dev));
 806
 807         usb_make_path(udev, ir->phys, sizeof(ir->phys));
 808         strlcat(ir->phys, "/input0", sizeof(ir->phys));
 809
 810         rc->input_name = ir->name;
 811         rc->input_phys = ir->phys;
 812         rc->input_id.bustype = BUS_USB;
 813         rc->input_id.version = 1;
 814         rc->input_id.vendor = le16_to_cpu(udev->descriptor.idVendor);
 815         rc->input_id.product = le16_to_cpu(udev->descriptor.idProduct);
 816         rc->dev.parent = &dev->intf->dev;
 817         rc->driver_name = MODULE_NAME;
 818
 819         /* all done */
 820         err = rc_register_device(rc);
 821         if (err)
 822                 goto error;
 823
 824         dev_info(&dev->intf->dev, "Input extension successfully initalized\n");
 825
 826         return 0;
 827
 828 error:
 829         kfree(ir->i2c_client);
 830         dev->ir = NULL;
 831         rc_free_device(rc);
 832         kfree(ir);
 833         return err;
 834 }
 835
 836 static int em28xx_ir_fini(struct em28xx *dev)
 837 {
 838         struct em28xx_IR *ir = dev->ir;
 839
 840         if (dev->is_audio_only) {
 841                 /* Shouldn't initialize IR for this interface */
 842                 return 0;
 843         }
 844
 845         dev_info(&dev->intf->dev, "Closing input extension\n");
 846
 847         em28xx_shutdown_buttons(dev);
 848
 849         /* skip detach on non attached boards */
 850         if (!ir)
 851                 goto ref_put;
 852
 853         rc_unregister_device(ir->rc);
 854
 855         kfree(ir->i2c_client);
 856
 857         /* done */
 858         kfree(ir);
 859         dev->ir = NULL;
 860
 861 ref_put:
 862         kref_put(&dev->ref, em28xx_free_device);
 863
 864         return 0;
 865 }
 866
 867 static int em28xx_ir_suspend(struct em28xx *dev)
 868 {
 869         struct em28xx_IR *ir = dev->ir;
 870
 871         if (dev->is_audio_only)
 872                 return 0;
 873
 874         dev_info(&dev->intf->dev, "Suspending input extension\n");
 875         if (ir)
 876                 cancel_delayed_work_sync(&ir->work);
 877         cancel_delayed_work_sync(&dev->buttons_query_work);
 878         /* is canceling delayed work sufficient or does the rc event
 879            kthread needs stopping? kthread is stopped in
 880            ir_raw_event_unregister() */
 881         return 0;
 882 }
 883
 884 static int em28xx_ir_resume(struct em28xx *dev)
 885 {
 886         struct em28xx_IR *ir = dev->ir;
 887
 888         if (dev->is_audio_only)
 889                 return 0;
 890
 891         dev_info(&dev->intf->dev, "Resuming input extension\n");
 892         /* if suspend calls ir_raw_event_unregister(), the should call
 893            ir_raw_event_register() */
 894         if (ir)
 895                 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 896         if (dev->num_button_polling_addresses)
 897                 schedule_delayed_work(&dev->buttons_query_work,
 898                                       msecs_to_jiffies(dev->button_polling_interval));
 899         return 0;
 900 }
 901
 902 static struct em28xx_ops rc_ops = {
 903         .id   = EM28XX_RC,
 904         .name = "Em28xx Input Extension",
 905         .init = em28xx_ir_init,
 906         .fini = em28xx_ir_fini,
 907         .suspend = em28xx_ir_suspend,
 908         .resume = em28xx_ir_resume,
 909 };
 910
 911 static int __init em28xx_rc_register(void)
 912 {
 913         return em28xx_register_extension(&rc_ops);
 914 }
 915
 916 static void __exit em28xx_rc_unregister(void)
 917 {
 918         em28xx_unregister_extension(&rc_ops);
 919 }
 920
 921 MODULE_LICENSE("GPL");
 922 MODULE_AUTHOR("Mauro Carvalho Chehab");
 923 MODULE_DESCRIPTION(DRIVER_DESC " - input interface");
 924 MODULE_VERSION(EM28XX_VERSION);
 925
 926 module_init(em28xx_rc_register);
 927 module_exit(em28xx_rc_unregister);