kernel/drivers/media/rc/ene_ir.c

   1 /*
   2  * driver for ENE KB3926 B/C/D/E/F CIR (pnp id: ENE0XXX)
   3  *
   4  * Copyright (C) 2010 Maxim Levitsky <maximlevitsky@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19  * USA
  20  *
  21  * Special thanks to:
  22  *   Sami R. <maesesami@gmail.com> for lot of help in debugging and therefore
  23  *    bringing to life support for transmission & learning mode.
  24  *
  25  *   Charlie Andrews <charliethepilot@googlemail.com> for lots of help in
  26  *   bringing up the support of new firmware buffer that is popular
  27  *   on latest notebooks
  28  *
  29  *   ENE for partial device documentation
  30  *
  31  */
  32
  33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  34
  35 #include <linux/kernel.h>
  36 #include <linux/module.h>
  37 #include <linux/pnp.h>
  38 #include <linux/io.h>
  39 #include <linux/interrupt.h>
  40 #include <linux/sched.h>
  41 #include <linux/slab.h>
  42 #include <media/rc-core.h>
  43 #include "ene_ir.h"
  44
  45 static int sample_period;
  46 static bool learning_mode_force;
  47 static int debug;
  48 static bool txsim;
  49
  50 static void ene_set_reg_addr(struct ene_device *dev, u16 reg)
  51 {
  52         outb(reg >> 8, dev->hw_io + ENE_ADDR_HI);
  53         outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO);
  54 }
  55
  56 /* read a hardware register */
  57 static u8 ene_read_reg(struct ene_device *dev, u16 reg)
  58 {
  59         u8 retval;
  60         ene_set_reg_addr(dev, reg);
  61         retval = inb(dev->hw_io + ENE_IO);
  62         dbg_regs("reg %04x == %02x", reg, retval);
  63         return retval;
  64 }
  65
  66 /* write a hardware register */
  67 static void ene_write_reg(struct ene_device *dev, u16 reg, u8 value)
  68 {
  69         dbg_regs("reg %04x <- %02x", reg, value);
  70         ene_set_reg_addr(dev, reg);
  71         outb(value, dev->hw_io + ENE_IO);
  72 }
  73
  74 /* Set bits in hardware register */
  75 static void ene_set_reg_mask(struct ene_device *dev, u16 reg, u8 mask)
  76 {
  77         dbg_regs("reg %04x |= %02x", reg, mask);
  78         ene_set_reg_addr(dev, reg);
  79         outb(inb(dev->hw_io + ENE_IO) | mask, dev->hw_io + ENE_IO);
  80 }
  81
  82 /* Clear bits in hardware register */
  83 static void ene_clear_reg_mask(struct ene_device *dev, u16 reg, u8 mask)
  84 {
  85         dbg_regs("reg %04x &= ~%02x ", reg, mask);
  86         ene_set_reg_addr(dev, reg);
  87         outb(inb(dev->hw_io + ENE_IO) & ~mask, dev->hw_io + ENE_IO);
  88 }
  89
  90 /* A helper to set/clear a bit in register according to boolean variable */
  91 static void ene_set_clear_reg_mask(struct ene_device *dev, u16 reg, u8 mask,
  92                                                                 bool set)
  93 {
  94         if (set)
  95                 ene_set_reg_mask(dev, reg, mask);
  96         else
  97                 ene_clear_reg_mask(dev, reg, mask);
  98 }
  99
 100 /* detect hardware features */
 101 static int ene_hw_detect(struct ene_device *dev)
 102 {
 103         u8 chip_major, chip_minor;
 104         u8 hw_revision, old_ver;
 105         u8 fw_reg2, fw_reg1;
 106
 107         ene_clear_reg_mask(dev, ENE_ECSTS, ENE_ECSTS_RSRVD);
 108         chip_major = ene_read_reg(dev, ENE_ECVER_MAJOR);
 109         chip_minor = ene_read_reg(dev, ENE_ECVER_MINOR);
 110         ene_set_reg_mask(dev, ENE_ECSTS, ENE_ECSTS_RSRVD);
 111
 112         hw_revision = ene_read_reg(dev, ENE_ECHV);
 113         old_ver = ene_read_reg(dev, ENE_HW_VER_OLD);
 114
 115         dev->pll_freq = (ene_read_reg(dev, ENE_PLLFRH) << 4) +
 116                 (ene_read_reg(dev, ENE_PLLFRL) >> 4);
 117
 118         if (sample_period != ENE_DEFAULT_SAMPLE_PERIOD)
 119                 dev->rx_period_adjust =
 120                         dev->pll_freq == ENE_DEFAULT_PLL_FREQ ? 2 : 4;
 121
 122         if (hw_revision == 0xFF) {
 123                 pr_warn("device seems to be disabled\n");
 124                 pr_warn("send a mail to lirc-list@lists.sourceforge.net\n");
 125                 pr_warn("please attach output of acpidump and dmidecode\n");
 126                 return -ENODEV;
 127         }
 128
 129         pr_notice("chip is 0x%02x%02x - kbver = 0x%02x, rev = 0x%02x\n",
 130                   chip_major, chip_minor, old_ver, hw_revision);
 131
 132         pr_notice("PLL freq = %d\n", dev->pll_freq);
 133
 134         if (chip_major == 0x33) {
 135                 pr_warn("chips 0x33xx aren't supported\n");
 136                 return -ENODEV;
 137         }
 138
 139         if (chip_major == 0x39 && chip_minor == 0x26 && hw_revision == 0xC0) {
 140                 dev->hw_revision = ENE_HW_C;
 141                 pr_notice("KB3926C detected\n");
 142         } else if (old_ver == 0x24 && hw_revision == 0xC0) {
 143                 dev->hw_revision = ENE_HW_B;
 144                 pr_notice("KB3926B detected\n");
 145         } else {
 146                 dev->hw_revision = ENE_HW_D;
 147                 pr_notice("KB3926D or higher detected\n");
 148         }
 149
 150         /* detect features hardware supports */
 151         if (dev->hw_revision < ENE_HW_C)
 152                 return 0;
 153
 154         fw_reg1 = ene_read_reg(dev, ENE_FW1);
 155         fw_reg2 = ene_read_reg(dev, ENE_FW2);
 156
 157         pr_notice("Firmware regs: %02x %02x\n", fw_reg1, fw_reg2);
 158
 159         dev->hw_use_gpio_0a = !!(fw_reg2 & ENE_FW2_GP0A);
 160         dev->hw_learning_and_tx_capable = !!(fw_reg2 & ENE_FW2_LEARNING);
 161         dev->hw_extra_buffer = !!(fw_reg1 & ENE_FW1_HAS_EXTRA_BUF);
 162
 163         if (dev->hw_learning_and_tx_capable)
 164                 dev->hw_fan_input = !!(fw_reg2 & ENE_FW2_FAN_INPUT);
 165
 166         pr_notice("Hardware features:\n");
 167
 168         if (dev->hw_learning_and_tx_capable) {
 169                 pr_notice("* Supports transmitting & learning mode\n");
 170                 pr_notice("   This feature is rare and therefore,\n");
 171                 pr_notice("   you are welcome to test it,\n");
 172                 pr_notice("   and/or contact the author via:\n");
 173                 pr_notice("   lirc-list@lists.sourceforge.net\n");
 174                 pr_notice("   or maximlevitsky@gmail.com\n");
 175
 176                 pr_notice("* Uses GPIO %s for IR raw input\n",
 177                           dev->hw_use_gpio_0a ? "40" : "0A");
 178
 179                 if (dev->hw_fan_input)
 180                         pr_notice("* Uses unused fan feedback input as source of demodulated IR data\n");
 181         }
 182
 183         if (!dev->hw_fan_input)
 184                 pr_notice("* Uses GPIO %s for IR demodulated input\n",
 185                           dev->hw_use_gpio_0a ? "0A" : "40");
 186
 187         if (dev->hw_extra_buffer)
 188                 pr_notice("* Uses new style input buffer\n");
 189         return 0;
 190 }
 191
 192 /* Read properities of hw sample buffer */
 193 static void ene_rx_setup_hw_buffer(struct ene_device *dev)
 194 {
 195         u16 tmp;
 196
 197         ene_rx_read_hw_pointer(dev);
 198         dev->r_pointer = dev->w_pointer;
 199
 200         if (!dev->hw_extra_buffer) {
 201                 dev->buffer_len = ENE_FW_PACKET_SIZE * 2;
 202                 return;
 203         }
 204
 205         tmp = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER);
 206         tmp |= ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER+1) << 8;
 207         dev->extra_buf1_address = tmp;
 208
 209         dev->extra_buf1_len = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 2);
 210
 211         tmp = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 3);
 212         tmp |= ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 4) << 8;
 213         dev->extra_buf2_address = tmp;
 214
 215         dev->extra_buf2_len = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 5);
 216
 217         dev->buffer_len = dev->extra_buf1_len + dev->extra_buf2_len + 8;
 218
 219         pr_notice("Hardware uses 2 extended buffers:\n");
 220         pr_notice("  0x%04x - len : %d\n",
 221                   dev->extra_buf1_address, dev->extra_buf1_len);
 222         pr_notice("  0x%04x - len : %d\n",
 223                   dev->extra_buf2_address, dev->extra_buf2_len);
 224
 225         pr_notice("Total buffer len = %d\n", dev->buffer_len);
 226
 227         if (dev->buffer_len > 64 || dev->buffer_len < 16)
 228                 goto error;
 229
 230         if (dev->extra_buf1_address > 0xFBFC ||
 231                                         dev->extra_buf1_address < 0xEC00)
 232                 goto error;
 233
 234         if (dev->extra_buf2_address > 0xFBFC ||
 235                                         dev->extra_buf2_address < 0xEC00)
 236                 goto error;
 237
 238         if (dev->r_pointer > dev->buffer_len)
 239                 goto error;
 240
 241         ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND);
 242         return;
 243 error:
 244         pr_warn("Error validating extra buffers, device probably won't work\n");
 245         dev->hw_extra_buffer = false;
 246         ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND);
 247 }
 248
 249
 250 /* Restore the pointers to extra buffers - to make module reload work*/
 251 static void ene_rx_restore_hw_buffer(struct ene_device *dev)
 252 {
 253         if (!dev->hw_extra_buffer)
 254                 return;
 255
 256         ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 0,
 257                                 dev->extra_buf1_address & 0xFF);
 258         ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 1,
 259                                 dev->extra_buf1_address >> 8);
 260         ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 2, dev->extra_buf1_len);
 261
 262         ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 3,
 263                                 dev->extra_buf2_address & 0xFF);
 264         ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 4,
 265                                 dev->extra_buf2_address >> 8);
 266         ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 5,
 267                                 dev->extra_buf2_len);
 268         ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND);
 269 }
 270
 271 /* Read hardware write pointer */
 272 static void ene_rx_read_hw_pointer(struct ene_device *dev)
 273 {
 274         if (dev->hw_extra_buffer)
 275                 dev->w_pointer = ene_read_reg(dev, ENE_FW_RX_POINTER);
 276         else
 277                 dev->w_pointer = ene_read_reg(dev, ENE_FW2)
 278                         & ENE_FW2_BUF_WPTR ? 0 : ENE_FW_PACKET_SIZE;
 279
 280         dbg_verbose("RB: HW write pointer: %02x, driver read pointer: %02x",
 281                 dev->w_pointer, dev->r_pointer);
 282 }
 283
 284 /* Gets address of next sample from HW ring buffer */
 285 static int ene_rx_get_sample_reg(struct ene_device *dev)
 286 {
 287         int r_pointer;
 288
 289         if (dev->r_pointer == dev->w_pointer) {
 290                 dbg_verbose("RB: hit end, try update w_pointer");
 291                 ene_rx_read_hw_pointer(dev);
 292         }
 293
 294         if (dev->r_pointer == dev->w_pointer) {
 295                 dbg_verbose("RB: end of data at %d", dev->r_pointer);
 296                 return 0;
 297         }
 298
 299         dbg_verbose("RB: reading at offset %d", dev->r_pointer);
 300         r_pointer = dev->r_pointer;
 301
 302         dev->r_pointer++;
 303         if (dev->r_pointer == dev->buffer_len)
 304                 dev->r_pointer = 0;
 305
 306         dbg_verbose("RB: next read will be from offset %d", dev->r_pointer);
 307
 308         if (r_pointer < 8) {
 309                 dbg_verbose("RB: read at main buffer at %d", r_pointer);
 310                 return ENE_FW_SAMPLE_BUFFER + r_pointer;
 311         }
 312
 313         r_pointer -= 8;
 314
 315         if (r_pointer < dev->extra_buf1_len) {
 316                 dbg_verbose("RB: read at 1st extra buffer at %d", r_pointer);
 317                 return dev->extra_buf1_address + r_pointer;
 318         }
 319
 320         r_pointer -= dev->extra_buf1_len;
 321
 322         if (r_pointer < dev->extra_buf2_len) {
 323                 dbg_verbose("RB: read at 2nd extra buffer at %d", r_pointer);
 324                 return dev->extra_buf2_address + r_pointer;
 325         }
 326
 327         dbg("attempt to read beyond ring buffer end");
 328         return 0;
 329 }
 330
 331 /* Sense current received carrier */
 332 static void ene_rx_sense_carrier(struct ene_device *dev)
 333 {
 334         DEFINE_IR_RAW_EVENT(ev);
 335
 336         int carrier, duty_cycle;
 337         int period = ene_read_reg(dev, ENE_CIRCAR_PRD);
 338         int hperiod = ene_read_reg(dev, ENE_CIRCAR_HPRD);
 339
 340         if (!(period & ENE_CIRCAR_PRD_VALID))
 341                 return;
 342
 343         period &= ~ENE_CIRCAR_PRD_VALID;
 344
 345         if (!period)
 346                 return;
 347
 348         dbg("RX: hardware carrier period = %02x", period);
 349         dbg("RX: hardware carrier pulse period = %02x", hperiod);
 350
 351         carrier = 2000000 / period;
 352         duty_cycle = (hperiod * 100) / period;
 353         dbg("RX: sensed carrier = %d Hz, duty cycle %d%%",
 354                                                 carrier, duty_cycle);
 355         if (dev->carrier_detect_enabled) {
 356                 ev.carrier_report = true;
 357                 ev.carrier = carrier;
 358                 ev.duty_cycle = duty_cycle;
 359                 ir_raw_event_store(dev->rdev, &ev);
 360         }
 361 }
 362
 363 /* this enables/disables the CIR RX engine */
 364 static void ene_rx_enable_cir_engine(struct ene_device *dev, bool enable)
 365 {
 366         ene_set_clear_reg_mask(dev, ENE_CIRCFG,
 367                         ENE_CIRCFG_RX_EN | ENE_CIRCFG_RX_IRQ, enable);
 368 }
 369
 370 /* this selects input for CIR engine. Ether GPIO 0A or GPIO40*/
 371 static void ene_rx_select_input(struct ene_device *dev, bool gpio_0a)
 372 {
 373         ene_set_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_GPIO0A, gpio_0a);
 374 }
 375
 376 /*
 377  * this enables alternative input via fan tachometer sensor and bypasses
 378  * the hw CIR engine
 379  */
 380 static void ene_rx_enable_fan_input(struct ene_device *dev, bool enable)
 381 {
 382         if (!dev->hw_fan_input)
 383                 return;
 384
 385         if (!enable)
 386                 ene_write_reg(dev, ENE_FAN_AS_IN1, 0);
 387         else {
 388                 ene_write_reg(dev, ENE_FAN_AS_IN1, ENE_FAN_AS_IN1_EN);
 389                 ene_write_reg(dev, ENE_FAN_AS_IN2, ENE_FAN_AS_IN2_EN);
 390         }
 391 }
 392
 393 /* setup the receiver for RX*/
 394 static void ene_rx_setup(struct ene_device *dev)
 395 {
 396         bool learning_mode = dev->learning_mode_enabled ||
 397                                         dev->carrier_detect_enabled;
 398         int sample_period_adjust = 0;
 399
 400         dbg("RX: setup receiver, learning mode = %d", learning_mode);
 401
 402
 403         /* This selects RLC input and clears CFG2 settings */
 404         ene_write_reg(dev, ENE_CIRCFG2, 0x00);
 405
 406         /* set sample period*/
 407         if (sample_period == ENE_DEFAULT_SAMPLE_PERIOD)
 408                 sample_period_adjust =
 409                         dev->pll_freq == ENE_DEFAULT_PLL_FREQ ? 1 : 2;
 410
 411         ene_write_reg(dev, ENE_CIRRLC_CFG,
 412                         (sample_period + sample_period_adjust) |
 413                                                 ENE_CIRRLC_CFG_OVERFLOW);
 414         /* revB doesn't support inputs */
 415         if (dev->hw_revision < ENE_HW_C)
 416                 goto select_timeout;
 417
 418         if (learning_mode) {
 419
 420                 WARN_ON(!dev->hw_learning_and_tx_capable);
 421
 422                 /* Enable the opposite of the normal input
 423                 That means that if GPIO40 is normally used, use GPIO0A
 424                 and vice versa.
 425                 This input will carry non demodulated
 426                 signal, and we will tell the hw to demodulate it itself */
 427                 ene_rx_select_input(dev, !dev->hw_use_gpio_0a);
 428                 dev->rx_fan_input_inuse = false;
 429
 430                 /* Enable carrier demodulation */
 431                 ene_set_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_CARR_DEMOD);
 432
 433                 /* Enable carrier detection */
 434                 ene_write_reg(dev, ENE_CIRCAR_PULS, 0x63);
 435                 ene_set_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_CARR_DETECT,
 436                         dev->carrier_detect_enabled || debug);
 437         } else {
 438                 if (dev->hw_fan_input)
 439                         dev->rx_fan_input_inuse = true;
 440                 else
 441                         ene_rx_select_input(dev, dev->hw_use_gpio_0a);
 442
 443                 /* Disable carrier detection & demodulation */
 444                 ene_clear_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_CARR_DEMOD);
 445                 ene_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_CARR_DETECT);
 446         }
 447
 448 select_timeout:
 449         if (dev->rx_fan_input_inuse) {
 450                 dev->rdev->rx_resolution = US_TO_NS(ENE_FW_SAMPLE_PERIOD_FAN);
 451
 452                 /* Fan input doesn't support timeouts, it just ends the
 453                         input with a maximum sample */
 454                 dev->rdev->min_timeout = dev->rdev->max_timeout =
 455                         US_TO_NS(ENE_FW_SMPL_BUF_FAN_MSK *
 456                                 ENE_FW_SAMPLE_PERIOD_FAN);
 457         } else {
 458                 dev->rdev->rx_resolution = US_TO_NS(sample_period);
 459
 460                 /* Theoreticly timeout is unlimited, but we cap it
 461                  * because it was seen that on one device, it
 462                  * would stop sending spaces after around 250 msec.
 463                  * Besides, this is close to 2^32 anyway and timeout is u32.
 464                  */
 465                 dev->rdev->min_timeout = US_TO_NS(127 * sample_period);
 466                 dev->rdev->max_timeout = US_TO_NS(200000);
 467         }
 468
 469         if (dev->hw_learning_and_tx_capable)
 470                 dev->rdev->tx_resolution = US_TO_NS(sample_period);
 471
 472         if (dev->rdev->timeout > dev->rdev->max_timeout)
 473                 dev->rdev->timeout = dev->rdev->max_timeout;
 474         if (dev->rdev->timeout < dev->rdev->min_timeout)
 475                 dev->rdev->timeout = dev->rdev->min_timeout;
 476 }
 477
 478 /* Enable the device for receive */
 479 static void ene_rx_enable_hw(struct ene_device *dev)
 480 {
 481         u8 reg_value;
 482
 483         /* Enable system interrupt */
 484         if (dev->hw_revision < ENE_HW_C) {
 485                 ene_write_reg(dev, ENEB_IRQ, dev->irq << 1);
 486                 ene_write_reg(dev, ENEB_IRQ_UNK1, 0x01);
 487         } else {
 488                 reg_value = ene_read_reg(dev, ENE_IRQ) & 0xF0;
 489                 reg_value |= ENE_IRQ_UNK_EN;
 490                 reg_value &= ~ENE_IRQ_STATUS;
 491                 reg_value |= (dev->irq & ENE_IRQ_MASK);
 492                 ene_write_reg(dev, ENE_IRQ, reg_value);
 493         }
 494
 495         /* Enable inputs */
 496         ene_rx_enable_fan_input(dev, dev->rx_fan_input_inuse);
 497         ene_rx_enable_cir_engine(dev, !dev->rx_fan_input_inuse);
 498
 499         /* ack any pending irqs - just in case */
 500         ene_irq_status(dev);
 501
 502         /* enable firmware bits */
 503         ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ);
 504
 505         /* enter idle mode */
 506         ir_raw_event_set_idle(dev->rdev, true);
 507 }
 508
 509 /* Enable the device for receive - wrapper to track the state*/
 510 static void ene_rx_enable(struct ene_device *dev)
 511 {
 512         ene_rx_enable_hw(dev);
 513         dev->rx_enabled = true;
 514 }
 515
 516 /* Disable the device receiver */
 517 static void ene_rx_disable_hw(struct ene_device *dev)
 518 {
 519         /* disable inputs */
 520         ene_rx_enable_cir_engine(dev, false);
 521         ene_rx_enable_fan_input(dev, false);
 522
 523         /* disable hardware IRQ and firmware flag */
 524         ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ);
 525         ir_raw_event_set_idle(dev->rdev, true);
 526 }
 527
 528 /* Disable the device receiver - wrapper to track the state */
 529 static void ene_rx_disable(struct ene_device *dev)
 530 {
 531         ene_rx_disable_hw(dev);
 532         dev->rx_enabled = false;
 533 }
 534
 535 /* This resets the receiver. Useful to stop stream of spaces at end of
 536  * transmission
 537  */
 538 static void ene_rx_reset(struct ene_device *dev)
 539 {
 540         ene_clear_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_RX_EN);
 541         ene_set_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_RX_EN);
 542 }
 543
 544 /* Set up the TX carrier frequency and duty cycle */
 545 static void ene_tx_set_carrier(struct ene_device *dev)
 546 {
 547         u8 tx_puls_width;
 548         unsigned long flags;
 549
 550         spin_lock_irqsave(&dev->hw_lock, flags);
 551
 552         ene_set_clear_reg_mask(dev, ENE_CIRCFG,
 553                 ENE_CIRCFG_TX_CARR, dev->tx_period > 0);
 554
 555         if (!dev->tx_period)
 556                 goto unlock;
 557
 558         BUG_ON(dev->tx_duty_cycle >= 100 || dev->tx_duty_cycle <= 0);
 559
 560         tx_puls_width = dev->tx_period / (100 / dev->tx_duty_cycle);
 561
 562         if (!tx_puls_width)
 563                 tx_puls_width = 1;
 564
 565         dbg("TX: pulse distance = %d * 500 ns", dev->tx_period);
 566         dbg("TX: pulse width = %d * 500 ns", tx_puls_width);
 567
 568         ene_write_reg(dev, ENE_CIRMOD_PRD, dev->tx_period | ENE_CIRMOD_PRD_POL);
 569         ene_write_reg(dev, ENE_CIRMOD_HPRD, tx_puls_width);
 570 unlock:
 571         spin_unlock_irqrestore(&dev->hw_lock, flags);
 572 }
 573
 574 /* Enable/disable transmitters */
 575 static void ene_tx_set_transmitters(struct ene_device *dev)
 576 {
 577         unsigned long flags;
 578
 579         spin_lock_irqsave(&dev->hw_lock, flags);
 580         ene_set_clear_reg_mask(dev, ENE_GPIOFS8, ENE_GPIOFS8_GPIO41,
 581                                         !!(dev->transmitter_mask & 0x01));
 582         ene_set_clear_reg_mask(dev, ENE_GPIOFS1, ENE_GPIOFS1_GPIO0D,
 583                                         !!(dev->transmitter_mask & 0x02));
 584         spin_unlock_irqrestore(&dev->hw_lock, flags);
 585 }
 586
 587 /* prepare transmission */
 588 static void ene_tx_enable(struct ene_device *dev)
 589 {
 590         u8 conf1 = ene_read_reg(dev, ENE_CIRCFG);
 591         u8 fwreg2 = ene_read_reg(dev, ENE_FW2);
 592
 593         dev->saved_conf1 = conf1;
 594
 595         /* Show information about currently connected transmitter jacks */
 596         if (fwreg2 & ENE_FW2_EMMITER1_CONN)
 597                 dbg("TX: Transmitter #1 is connected");
 598
 599         if (fwreg2 & ENE_FW2_EMMITER2_CONN)
 600                 dbg("TX: Transmitter #2 is connected");
 601
 602         if (!(fwreg2 & (ENE_FW2_EMMITER1_CONN | ENE_FW2_EMMITER2_CONN)))
 603                 pr_warn("TX: transmitter cable isn't connected!\n");
 604
 605         /* disable receive on revc */
 606         if (dev->hw_revision == ENE_HW_C)
 607                 conf1 &= ~ENE_CIRCFG_RX_EN;
 608
 609         /* Enable TX engine */
 610         conf1 |= ENE_CIRCFG_TX_EN | ENE_CIRCFG_TX_IRQ;
 611         ene_write_reg(dev, ENE_CIRCFG, conf1);
 612 }
 613
 614 /* end transmission */
 615 static void ene_tx_disable(struct ene_device *dev)
 616 {
 617         ene_write_reg(dev, ENE_CIRCFG, dev->saved_conf1);
 618         dev->tx_buffer = NULL;
 619 }
 620
 621
 622 /* TX one sample - must be called with dev->hw_lock*/
 623 static void ene_tx_sample(struct ene_device *dev)
 624 {
 625         u8 raw_tx;
 626         u32 sample;
 627         bool pulse = dev->tx_sample_pulse;
 628
 629         if (!dev->tx_buffer) {
 630                 pr_warn("TX: BUG: attempt to transmit NULL buffer\n");
 631                 return;
 632         }
 633
 634         /* Grab next TX sample */
 635         if (!dev->tx_sample) {
 636
 637                 if (dev->tx_pos == dev->tx_len) {
 638                         if (!dev->tx_done) {
 639                                 dbg("TX: no more data to send");
 640                                 dev->tx_done = true;
 641                                 goto exit;
 642                         } else {
 643                                 dbg("TX: last sample sent by hardware");
 644                                 ene_tx_disable(dev);
 645                                 complete(&dev->tx_complete);
 646                                 return;
 647                         }
 648                 }
 649
 650                 sample = dev->tx_buffer[dev->tx_pos++];
 651                 dev->tx_sample_pulse = !dev->tx_sample_pulse;
 652
 653                 dev->tx_sample = DIV_ROUND_CLOSEST(sample, sample_period);
 654
 655                 if (!dev->tx_sample)
 656                         dev->tx_sample = 1;
 657         }
 658
 659         raw_tx = min(dev->tx_sample , (unsigned int)ENE_CIRRLC_OUT_MASK);
 660         dev->tx_sample -= raw_tx;
 661
 662         dbg("TX: sample %8d (%s)", raw_tx * sample_period,
 663                                                 pulse ? "pulse" : "space");
 664         if (pulse)
 665                 raw_tx |= ENE_CIRRLC_OUT_PULSE;
 666
 667         ene_write_reg(dev,
 668                 dev->tx_reg ? ENE_CIRRLC_OUT1 : ENE_CIRRLC_OUT0, raw_tx);
 669
 670         dev->tx_reg = !dev->tx_reg;
 671 exit:
 672         /* simulate TX done interrupt */
 673         if (txsim)
 674                 mod_timer(&dev->tx_sim_timer, jiffies + HZ / 500);
 675 }
 676
 677 /* timer to simulate tx done interrupt */
 678 static void ene_tx_irqsim(unsigned long data)
 679 {
 680         struct ene_device *dev = (struct ene_device *)data;
 681         unsigned long flags;
 682
 683         spin_lock_irqsave(&dev->hw_lock, flags);
 684         ene_tx_sample(dev);
 685         spin_unlock_irqrestore(&dev->hw_lock, flags);
 686 }
 687
 688
 689 /* read irq status and ack it */
 690 static int ene_irq_status(struct ene_device *dev)
 691 {
 692         u8 irq_status;
 693         u8 fw_flags1, fw_flags2;
 694         int retval = 0;
 695
 696         fw_flags2 = ene_read_reg(dev, ENE_FW2);
 697
 698         if (dev->hw_revision < ENE_HW_C) {
 699                 irq_status = ene_read_reg(dev, ENEB_IRQ_STATUS);
 700
 701                 if (!(irq_status & ENEB_IRQ_STATUS_IR))
 702                         return 0;
 703
 704                 ene_clear_reg_mask(dev, ENEB_IRQ_STATUS, ENEB_IRQ_STATUS_IR);
 705                 return ENE_IRQ_RX;
 706         }
 707
 708         irq_status = ene_read_reg(dev, ENE_IRQ);
 709         if (!(irq_status & ENE_IRQ_STATUS))
 710                 return 0;
 711
 712         /* original driver does that twice - a workaround ? */
 713         ene_write_reg(dev, ENE_IRQ, irq_status & ~ENE_IRQ_STATUS);
 714         ene_write_reg(dev, ENE_IRQ, irq_status & ~ENE_IRQ_STATUS);
 715
 716         /* check RX interrupt */
 717         if (fw_flags2 & ENE_FW2_RXIRQ) {
 718                 retval |= ENE_IRQ_RX;
 719                 ene_write_reg(dev, ENE_FW2, fw_flags2 & ~ENE_FW2_RXIRQ);
 720         }
 721
 722         /* check TX interrupt */
 723         fw_flags1 = ene_read_reg(dev, ENE_FW1);
 724         if (fw_flags1 & ENE_FW1_TXIRQ) {
 725                 ene_write_reg(dev, ENE_FW1, fw_flags1 & ~ENE_FW1_TXIRQ);
 726                 retval |= ENE_IRQ_TX;
 727         }
 728
 729         return retval;
 730 }
 731
 732 /* interrupt handler */
 733 static irqreturn_t ene_isr(int irq, void *data)
 734 {
 735         u16 hw_value, reg;
 736         int hw_sample, irq_status;
 737         bool pulse;
 738         unsigned long flags;
 739         irqreturn_t retval = IRQ_NONE;
 740         struct ene_device *dev = (struct ene_device *)data;
 741         DEFINE_IR_RAW_EVENT(ev);
 742
 743         spin_lock_irqsave(&dev->hw_lock, flags);
 744
 745         dbg_verbose("ISR called");
 746         ene_rx_read_hw_pointer(dev);
 747         irq_status = ene_irq_status(dev);
 748
 749         if (!irq_status)
 750                 goto unlock;
 751
 752         retval = IRQ_HANDLED;
 753
 754         if (irq_status & ENE_IRQ_TX) {
 755                 dbg_verbose("TX interrupt");
 756                 if (!dev->hw_learning_and_tx_capable) {
 757                         dbg("TX interrupt on unsupported device!");
 758                         goto unlock;
 759                 }
 760                 ene_tx_sample(dev);
 761         }
 762
 763         if (!(irq_status & ENE_IRQ_RX))
 764                 goto unlock;
 765
 766         dbg_verbose("RX interrupt");
 767
 768         if (dev->hw_learning_and_tx_capable)
 769                 ene_rx_sense_carrier(dev);
 770
 771         /* On hardware that don't support extra buffer we need to trust
 772                 the interrupt and not track the read pointer */
 773         if (!dev->hw_extra_buffer)
 774                 dev->r_pointer = dev->w_pointer == 0 ? ENE_FW_PACKET_SIZE : 0;
 775
 776         while (1) {
 777
 778                 reg = ene_rx_get_sample_reg(dev);
 779
 780                 dbg_verbose("next sample to read at: %04x", reg);
 781                 if (!reg)
 782                         break;
 783
 784                 hw_value = ene_read_reg(dev, reg);
 785
 786                 if (dev->rx_fan_input_inuse) {
 787
 788                         int offset = ENE_FW_SMPL_BUF_FAN - ENE_FW_SAMPLE_BUFFER;
 789
 790                         /* read high part of the sample */
 791                         hw_value |= ene_read_reg(dev, reg + offset) << 8;
 792                         pulse = hw_value & ENE_FW_SMPL_BUF_FAN_PLS;
 793
 794                         /* clear space bit, and other unused bits */
 795                         hw_value &= ENE_FW_SMPL_BUF_FAN_MSK;
 796                         hw_sample = hw_value * ENE_FW_SAMPLE_PERIOD_FAN;
 797
 798                 } else {
 799                         pulse = !(hw_value & ENE_FW_SAMPLE_SPACE);
 800                         hw_value &= ~ENE_FW_SAMPLE_SPACE;
 801                         hw_sample = hw_value * sample_period;
 802
 803                         if (dev->rx_period_adjust) {
 804                                 hw_sample *= 100;
 805                                 hw_sample /= (100 + dev->rx_period_adjust);
 806                         }
 807                 }
 808
 809                 if (!dev->hw_extra_buffer && !hw_sample) {
 810                         dev->r_pointer = dev->w_pointer;
 811                         continue;
 812                 }
 813
 814                 dbg("RX: %d (%s)", hw_sample, pulse ? "pulse" : "space");
 815
 816                 ev.duration = US_TO_NS(hw_sample);
 817                 ev.pulse = pulse;
 818                 ir_raw_event_store_with_filter(dev->rdev, &ev);
 819         }
 820
 821         ir_raw_event_handle(dev->rdev);
 822 unlock:
 823         spin_unlock_irqrestore(&dev->hw_lock, flags);
 824         return retval;
 825 }
 826
 827 /* Initialize default settings */
 828 static void ene_setup_default_settings(struct ene_device *dev)
 829 {
 830         dev->tx_period = 32;
 831         dev->tx_duty_cycle = 50; /*%*/
 832         dev->transmitter_mask = 0x03;
 833         dev->learning_mode_enabled = learning_mode_force;
 834
 835         /* Set reasonable default timeout */
 836         dev->rdev->timeout = US_TO_NS(150000);
 837 }
 838
 839 /* Upload all hardware settings at once. Used at load and resume time */
 840 static void ene_setup_hw_settings(struct ene_device *dev)
 841 {
 842         if (dev->hw_learning_and_tx_capable) {
 843                 ene_tx_set_carrier(dev);
 844                 ene_tx_set_transmitters(dev);
 845         }
 846
 847         ene_rx_setup(dev);
 848 }
 849
 850 /* outside interface: called on first open*/
 851 static int ene_open(struct rc_dev *rdev)
 852 {
 853         struct ene_device *dev = rdev->priv;
 854         unsigned long flags;
 855
 856         spin_lock_irqsave(&dev->hw_lock, flags);
 857         ene_rx_enable(dev);
 858         spin_unlock_irqrestore(&dev->hw_lock, flags);
 859         return 0;
 860 }
 861
 862 /* outside interface: called on device close*/
 863 static void ene_close(struct rc_dev *rdev)
 864 {
 865         struct ene_device *dev = rdev->priv;
 866         unsigned long flags;
 867         spin_lock_irqsave(&dev->hw_lock, flags);
 868
 869         ene_rx_disable(dev);
 870         spin_unlock_irqrestore(&dev->hw_lock, flags);
 871 }
 872
 873 /* outside interface: set transmitter mask */
 874 static int ene_set_tx_mask(struct rc_dev *rdev, u32 tx_mask)
 875 {
 876         struct ene_device *dev = rdev->priv;
 877         dbg("TX: attempt to set transmitter mask %02x", tx_mask);
 878
 879         /* invalid txmask */
 880         if (!tx_mask || tx_mask & ~0x03) {
 881                 dbg("TX: invalid mask");
 882                 /* return count of transmitters */
 883                 return 2;
 884         }
 885
 886         dev->transmitter_mask = tx_mask;
 887         ene_tx_set_transmitters(dev);
 888         return 0;
 889 }
 890
 891 /* outside interface : set tx carrier */
 892 static int ene_set_tx_carrier(struct rc_dev *rdev, u32 carrier)
 893 {
 894         struct ene_device *dev = rdev->priv;
 895         u32 period;
 896
 897         dbg("TX: attempt to set tx carrier to %d kHz", carrier);
 898         if (carrier == 0)
 899                 return -EINVAL;
 900
 901         period = 2000000 / carrier;
 902         if (period && (period > ENE_CIRMOD_PRD_MAX ||
 903                         period < ENE_CIRMOD_PRD_MIN)) {
 904
 905                 dbg("TX: out of range %d-%d kHz carrier",
 906                         2000 / ENE_CIRMOD_PRD_MIN, 2000 / ENE_CIRMOD_PRD_MAX);
 907                 return -1;
 908         }
 909
 910         dev->tx_period = period;
 911         ene_tx_set_carrier(dev);
 912         return 0;
 913 }
 914
 915 /*outside interface : set tx duty cycle */
 916 static int ene_set_tx_duty_cycle(struct rc_dev *rdev, u32 duty_cycle)
 917 {
 918         struct ene_device *dev = rdev->priv;
 919         dbg("TX: setting duty cycle to %d%%", duty_cycle);
 920         dev->tx_duty_cycle = duty_cycle;
 921         ene_tx_set_carrier(dev);
 922         return 0;
 923 }
 924
 925 /* outside interface: enable learning mode */
 926 static int ene_set_learning_mode(struct rc_dev *rdev, int enable)
 927 {
 928         struct ene_device *dev = rdev->priv;
 929         unsigned long flags;
 930         if (enable == dev->learning_mode_enabled)
 931                 return 0;
 932
 933         spin_lock_irqsave(&dev->hw_lock, flags);
 934         dev->learning_mode_enabled = enable;
 935         ene_rx_disable(dev);
 936         ene_rx_setup(dev);
 937         ene_rx_enable(dev);
 938         spin_unlock_irqrestore(&dev->hw_lock, flags);
 939         return 0;
 940 }
 941
 942 static int ene_set_carrier_report(struct rc_dev *rdev, int enable)
 943 {
 944         struct ene_device *dev = rdev->priv;
 945         unsigned long flags;
 946
 947         if (enable == dev->carrier_detect_enabled)
 948                 return 0;
 949
 950         spin_lock_irqsave(&dev->hw_lock, flags);
 951         dev->carrier_detect_enabled = enable;
 952         ene_rx_disable(dev);
 953         ene_rx_setup(dev);
 954         ene_rx_enable(dev);
 955         spin_unlock_irqrestore(&dev->hw_lock, flags);
 956         return 0;
 957 }
 958
 959 /* outside interface: enable or disable idle mode */
 960 static void ene_set_idle(struct rc_dev *rdev, bool idle)
 961 {
 962         struct ene_device *dev = rdev->priv;
 963
 964         if (idle) {
 965                 ene_rx_reset(dev);
 966                 dbg("RX: end of data");
 967         }
 968 }
 969
 970 /* outside interface: transmit */
 971 static int ene_transmit(struct rc_dev *rdev, unsigned *buf, unsigned n)
 972 {
 973         struct ene_device *dev = rdev->priv;
 974         unsigned long flags;
 975
 976         dev->tx_buffer = buf;
 977         dev->tx_len = n;
 978         dev->tx_pos = 0;
 979         dev->tx_reg = 0;
 980         dev->tx_done = 0;
 981         dev->tx_sample = 0;
 982         dev->tx_sample_pulse = false;
 983
 984         dbg("TX: %d samples", dev->tx_len);
 985
 986         spin_lock_irqsave(&dev->hw_lock, flags);
 987
 988         ene_tx_enable(dev);
 989
 990         /* Transmit first two samples */
 991         ene_tx_sample(dev);
 992         ene_tx_sample(dev);
 993
 994         spin_unlock_irqrestore(&dev->hw_lock, flags);
 995
 996         if (wait_for_completion_timeout(&dev->tx_complete, 2 * HZ) == 0) {
 997                 dbg("TX: timeout");
 998                 spin_lock_irqsave(&dev->hw_lock, flags);
 999                 ene_tx_disable(dev);
1000                 spin_unlock_irqrestore(&dev->hw_lock, flags);
1001         } else
1002                 dbg("TX: done");
1003         return n;
1004 }
1005
1006 /* probe entry */
1007 static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
1008 {
1009         int error = -ENOMEM;
1010         struct rc_dev *rdev;
1011         struct ene_device *dev;
1012
1013         /* allocate memory */
1014         dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL);
1015         rdev = rc_allocate_device();
1016         if (!dev || !rdev)
1017                 goto exit_free_dev_rdev;
1018
1019         /* validate resources */
1020         error = -ENODEV;
1021
1022         /* init these to -1, as 0 is valid for both */
1023         dev->hw_io = -1;
1024         dev->irq = -1;
1025
1026         if (!pnp_port_valid(pnp_dev, 0) ||
1027             pnp_port_len(pnp_dev, 0) < ENE_IO_SIZE)
1028                 goto exit_free_dev_rdev;
1029
1030         if (!pnp_irq_valid(pnp_dev, 0))
1031                 goto exit_free_dev_rdev;
1032
1033         spin_lock_init(&dev->hw_lock);
1034
1035         dev->hw_io = pnp_port_start(pnp_dev, 0);
1036         dev->irq = pnp_irq(pnp_dev, 0);
1037
1038
1039         pnp_set_drvdata(pnp_dev, dev);
1040         dev->pnp_dev = pnp_dev;
1041
1042         /* don't allow too short/long sample periods */
1043         if (sample_period < 5 || sample_period > 0x7F)
1044                 sample_period = ENE_DEFAULT_SAMPLE_PERIOD;
1045
1046         /* detect hardware version and features */
1047         error = ene_hw_detect(dev);
1048         if (error)
1049                 goto exit_free_dev_rdev;
1050
1051         if (!dev->hw_learning_and_tx_capable && txsim) {
1052                 dev->hw_learning_and_tx_capable = true;
1053                 setup_timer(&dev->tx_sim_timer, ene_tx_irqsim,
1054                                                 (long unsigned int)dev);
1055                 pr_warn("Simulation of TX activated\n");
1056         }
1057
1058         if (!dev->hw_learning_and_tx_capable)
1059                 learning_mode_force = false;
1060
1061         rdev->driver_type = RC_DRIVER_IR_RAW;
1062         rdev->allowed_protocols = RC_BIT_ALL;
1063         rdev->priv = dev;
1064         rdev->open = ene_open;
1065         rdev->close = ene_close;
1066         rdev->s_idle = ene_set_idle;
1067         rdev->driver_name = ENE_DRIVER_NAME;
1068         rdev->map_name = RC_MAP_RC6_MCE;
1069         rdev->input_name = "ENE eHome Infrared Remote Receiver";
1070
1071         if (dev->hw_learning_and_tx_capable) {
1072                 rdev->s_learning_mode = ene_set_learning_mode;
1073                 init_completion(&dev->tx_complete);
1074                 rdev->tx_ir = ene_transmit;
1075                 rdev->s_tx_mask = ene_set_tx_mask;
1076                 rdev->s_tx_carrier = ene_set_tx_carrier;
1077                 rdev->s_tx_duty_cycle = ene_set_tx_duty_cycle;
1078                 rdev->s_carrier_report = ene_set_carrier_report;
1079                 rdev->input_name = "ENE eHome Infrared Remote Transceiver";
1080         }
1081
1082         dev->rdev = rdev;
1083
1084         ene_rx_setup_hw_buffer(dev);
1085         ene_setup_default_settings(dev);
1086         ene_setup_hw_settings(dev);
1087
1088         device_set_wakeup_capable(&pnp_dev->dev, true);
1089         device_set_wakeup_enable(&pnp_dev->dev, true);
1090
1091         error = rc_register_device(rdev);
1092         if (error < 0)
1093                 goto exit_free_dev_rdev;
1094
1095         /* claim the resources */
1096         error = -EBUSY;
1097         if (!request_region(dev->hw_io, ENE_IO_SIZE, ENE_DRIVER_NAME)) {
1098                 goto exit_unregister_device;
1099         }
1100
1101         if (request_irq(dev->irq, ene_isr,
1102                         IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev)) {
1103                 goto exit_release_hw_io;
1104         }
1105
1106         pr_notice("driver has been successfully loaded\n");
1107         return 0;
1108
1109 exit_release_hw_io:
1110         release_region(dev->hw_io, ENE_IO_SIZE);
1111 exit_unregister_device:
1112         rc_unregister_device(rdev);
1113         rdev = NULL;
1114 exit_free_dev_rdev:
1115         rc_free_device(rdev);
1116         kfree(dev);
1117         return error;
1118 }
1119
1120 /* main unload function */
1121 static void ene_remove(struct pnp_dev *pnp_dev)
1122 {
1123         struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1124         unsigned long flags;
1125
1126         spin_lock_irqsave(&dev->hw_lock, flags);
1127         ene_rx_disable(dev);
1128         ene_rx_restore_hw_buffer(dev);
1129         spin_unlock_irqrestore(&dev->hw_lock, flags);
1130
1131         free_irq(dev->irq, dev);
1132         release_region(dev->hw_io, ENE_IO_SIZE);
1133         rc_unregister_device(dev->rdev);
1134         kfree(dev);
1135 }
1136
1137 /* enable wake on IR (wakes on specific button on original remote) */
1138 static void ene_enable_wake(struct ene_device *dev, bool enable)
1139 {
1140         dbg("wake on IR %s", enable ? "enabled" : "disabled");
1141         ene_set_clear_reg_mask(dev, ENE_FW1, ENE_FW1_WAKE, enable);
1142 }
1143
1144 #ifdef CONFIG_PM
1145 static int ene_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1146 {
1147         struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1148         bool wake = device_may_wakeup(&dev->pnp_dev->dev);
1149
1150         if (!wake && dev->rx_enabled)
1151                 ene_rx_disable_hw(dev);
1152
1153         ene_enable_wake(dev, wake);
1154         return 0;
1155 }
1156
1157 static int ene_resume(struct pnp_dev *pnp_dev)
1158 {
1159         struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1160         ene_setup_hw_settings(dev);
1161
1162         if (dev->rx_enabled)
1163                 ene_rx_enable(dev);
1164
1165         ene_enable_wake(dev, false);
1166         return 0;
1167 }
1168 #endif
1169
1170 static void ene_shutdown(struct pnp_dev *pnp_dev)
1171 {
1172         struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1173         ene_enable_wake(dev, true);
1174 }
1175
1176 static const struct pnp_device_id ene_ids[] = {
1177         {.id = "ENE0100",},
1178         {.id = "ENE0200",},
1179         {.id = "ENE0201",},
1180         {.id = "ENE0202",},
1181         {},
1182 };
1183
1184 static struct pnp_driver ene_driver = {
1185         .name = ENE_DRIVER_NAME,
1186         .id_table = ene_ids,
1187         .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1188
1189         .probe = ene_probe,
1190         .remove = ene_remove,
1191 #ifdef CONFIG_PM
1192         .suspend = ene_suspend,
1193         .resume = ene_resume,
1194 #endif
1195         .shutdown = ene_shutdown,
1196 };
1197
1198 module_param(sample_period, int, S_IRUGO);
1199 MODULE_PARM_DESC(sample_period, "Hardware sample period (50 us default)");
1200
1201 module_param(learning_mode_force, bool, S_IRUGO);
1202 MODULE_PARM_DESC(learning_mode_force, "Enable learning mode by default");
1203
1204 module_param(debug, int, S_IRUGO | S_IWUSR);
1205 MODULE_PARM_DESC(debug, "Debug level");
1206
1207 module_param(txsim, bool, S_IRUGO);
1208 MODULE_PARM_DESC(txsim,
1209         "Simulate TX features on unsupported hardware (dangerous)");
1210
1211 MODULE_DEVICE_TABLE(pnp, ene_ids);
1212 MODULE_DESCRIPTION
1213         ("Infrared input driver for KB3926B/C/D/E/F "
1214         "(aka ENE0100/ENE0200/ENE0201/ENE0202) CIR port");
1215
1216 MODULE_AUTHOR("Maxim Levitsky");
1217 MODULE_LICENSE("GPL");
1218
1219 module_pnp_driver(ene_driver);