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

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