/* * driver for ENE KB3926 B/C/D CIR (pnp id: ENE0XXX) * * Copyright (C) 2010 Maxim Levitsky * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA */ #include #include #include #include #include #include #include #include #include #include #include "ene_ir.h" static int sample_period = -1; static int enable_idle = 1; static int input = 1; static int debug; static int txsim; static int ene_irq_status(struct ene_device *dev); /* read a hardware register */ static u8 ene_hw_read_reg(struct ene_device *dev, u16 reg) { u8 retval; outb(reg >> 8, dev->hw_io + ENE_ADDR_HI); outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO); retval = inb(dev->hw_io + ENE_IO); ene_dbg_verbose("reg %04x == %02x", reg, retval); return retval; } /* write a hardware register */ static void ene_hw_write_reg(struct ene_device *dev, u16 reg, u8 value) { outb(reg >> 8, dev->hw_io + ENE_ADDR_HI); outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO); outb(value, dev->hw_io + ENE_IO); ene_dbg_verbose("reg %04x <- %02x", reg, value); } /* change specific bits in hardware register */ static void ene_hw_write_reg_mask(struct ene_device *dev, u16 reg, u8 value, u8 mask) { u8 regvalue; outb(reg >> 8, dev->hw_io + ENE_ADDR_HI); outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO); regvalue = inb(dev->hw_io + ENE_IO) & ~mask; regvalue |= (value & mask); outb(regvalue, dev->hw_io + ENE_IO); ene_dbg_verbose("reg %04x <- %02x (mask=%02x)", reg, value, mask); } /* detect hardware features */ static int ene_hw_detect(struct ene_device *dev) { u8 chip_major, chip_minor; u8 hw_revision, old_ver; u8 tmp; u8 fw_capabilities; int pll_freq; tmp = ene_hw_read_reg(dev, ENE_HW_UNK); ene_hw_write_reg(dev, ENE_HW_UNK, tmp & ~ENE_HW_UNK_CLR); chip_major = ene_hw_read_reg(dev, ENE_HW_VER_MAJOR); chip_minor = ene_hw_read_reg(dev, ENE_HW_VER_MINOR); ene_hw_write_reg(dev, ENE_HW_UNK, tmp); hw_revision = ene_hw_read_reg(dev, ENE_HW_VERSION); old_ver = ene_hw_read_reg(dev, ENE_HW_VER_OLD); pll_freq = (ene_hw_read_reg(dev, ENE_PLLFRH) << 4) + (ene_hw_read_reg(dev, ENE_PLLFRL) >> 4); if (pll_freq != 1000) dev->rx_period_adjust = 4; else dev->rx_period_adjust = 2; ene_printk(KERN_NOTICE, "PLL freq = %d\n", pll_freq); if (hw_revision == 0xFF) { ene_printk(KERN_WARNING, "device seems to be disabled\n"); ene_printk(KERN_WARNING, "send a mail to lirc-list@lists.sourceforge.net\n"); ene_printk(KERN_WARNING, "please attach output of acpidump\n"); return -ENODEV; } if (chip_major == 0x33) { ene_printk(KERN_WARNING, "chips 0x33xx aren't supported\n"); return -ENODEV; } if (chip_major == 0x39 && chip_minor == 0x26 && hw_revision == 0xC0) { dev->hw_revision = ENE_HW_C; } else if (old_ver == 0x24 && hw_revision == 0xC0) { dev->hw_revision = ENE_HW_B; ene_printk(KERN_NOTICE, "KB3926B detected\n"); } else { dev->hw_revision = ENE_HW_D; ene_printk(KERN_WARNING, "unknown ENE chip detected, assuming KB3926D\n"); ene_printk(KERN_WARNING, "driver support might be not complete"); } ene_printk(KERN_DEBUG, "chip is 0x%02x%02x - kbver = 0x%02x, rev = 0x%02x\n", chip_major, chip_minor, old_ver, hw_revision); /* detect features hardware supports */ if (dev->hw_revision < ENE_HW_C) return 0; fw_capabilities = ene_hw_read_reg(dev, ENE_FW2); ene_dbg("Firmware capabilities: %02x", fw_capabilities); dev->hw_gpio40_learning = fw_capabilities & ENE_FW2_GP40_AS_LEARN; dev->hw_learning_and_tx_capable = fw_capabilities & ENE_FW2_LEARNING; dev->hw_fan_as_normal_input = dev->hw_learning_and_tx_capable && (fw_capabilities & ENE_FW2_FAN_AS_NRML_IN); ene_printk(KERN_NOTICE, "hardware features:\n"); ene_printk(KERN_NOTICE, "learning and transmit %s, gpio40_learn %s, fan_in %s\n", dev->hw_learning_and_tx_capable ? "on" : "off", dev->hw_gpio40_learning ? "on" : "off", dev->hw_fan_as_normal_input ? "on" : "off"); if (dev->hw_learning_and_tx_capable) { ene_printk(KERN_WARNING, "Device supports transmitting, but that support is\n"); ene_printk(KERN_WARNING, "lightly tested. Please test it and mail\n"); ene_printk(KERN_WARNING, "lirc-list@lists.sourceforge.net\n"); } return 0; } /* this enables/disables IR input via gpio40*/ static void ene_enable_gpio40_receive(struct ene_device *dev, int enable) { ene_hw_write_reg_mask(dev, ENE_CIR_CONF2, enable ? 0 : ENE_CIR_CONF2_GPIO40DIS, ENE_CIR_CONF2_GPIO40DIS); } /* this enables/disables IR via standard input */ static void ene_enable_normal_receive(struct ene_device *dev, int enable) { ene_hw_write_reg(dev, ENE_CIR_CONF1, enable ? ENE_CIR_CONF1_RX_ON : 0); } /* this enables/disables IR input via unused fan tachtometer input */ static void ene_enable_fan_receive(struct ene_device *dev, int enable) { if (!enable) ene_hw_write_reg(dev, ENE_FAN_AS_IN1, 0); else { ene_hw_write_reg(dev, ENE_FAN_AS_IN1, ENE_FAN_AS_IN1_EN); ene_hw_write_reg(dev, ENE_FAN_AS_IN2, ENE_FAN_AS_IN2_EN); } dev->rx_fan_input_inuse = enable; } /* Sense current received carrier */ static int ene_rx_sense_carrier(struct ene_device *dev) { int period = ene_hw_read_reg(dev, ENE_RX_CARRIER); int carrier; ene_dbg("RX: hardware carrier period = %02x", period); if (!(period & ENE_RX_CARRIER_VALID)) return 0; period &= ~ENE_RX_CARRIER_VALID; if (!period) return 0; carrier = 2000000 / period; ene_dbg("RX: sensed carrier = %d Hz", carrier); return carrier; } /* determine which input to use*/ static void ene_rx_set_inputs(struct ene_device *dev) { int learning_mode = dev->learning_enabled; ene_dbg("RX: setup receiver, learning mode = %d", learning_mode); ene_enable_normal_receive(dev, 1); /* old hardware doesn't support learning mode for sure */ if (dev->hw_revision <= ENE_HW_B) return; /* receiver not learning capable, still set gpio40 correctly */ if (!dev->hw_learning_and_tx_capable) { ene_enable_gpio40_receive(dev, !dev->hw_gpio40_learning); return; } /* enable learning mode */ if (learning_mode) { ene_enable_gpio40_receive(dev, dev->hw_gpio40_learning); /* fan input is not used for learning */ if (dev->hw_fan_as_normal_input) ene_enable_fan_receive(dev, 0); /* disable learning mode */ } else { if (dev->hw_fan_as_normal_input) { ene_enable_fan_receive(dev, 1); ene_enable_normal_receive(dev, 0); } else ene_enable_gpio40_receive(dev, !dev->hw_gpio40_learning); } /* set few additional settings for this mode */ ene_hw_write_reg_mask(dev, ENE_CIR_CONF1, learning_mode ? ENE_CIR_CONF1_LEARN1 : 0, ENE_CIR_CONF1_LEARN1); ene_hw_write_reg_mask(dev, ENE_CIR_CONF2, learning_mode ? ENE_CIR_CONF2_LEARN2 : 0, ENE_CIR_CONF2_LEARN2); if (dev->rx_fan_input_inuse) { dev->props->rx_resolution = ENE_SAMPLE_PERIOD_FAN * 1000; dev->props->timeout = ENE_FAN_VALUE_MASK * ENE_SAMPLE_PERIOD_FAN * 1000; } else { dev->props->rx_resolution = sample_period * 1000; dev->props->timeout = ENE_MAXGAP * 1000; } } /* Enable the device for receive */ static void ene_rx_enable(struct ene_device *dev) { u8 reg_value; if (dev->hw_revision < ENE_HW_C) { ene_hw_write_reg(dev, ENEB_IRQ, dev->irq << 1); ene_hw_write_reg(dev, ENEB_IRQ_UNK1, 0x01); } else { reg_value = ene_hw_read_reg(dev, ENEC_IRQ) & 0xF0; reg_value |= ENEC_IRQ_UNK_EN; reg_value &= ~ENEC_IRQ_STATUS; reg_value |= (dev->irq & ENEC_IRQ_MASK); ene_hw_write_reg(dev, ENEC_IRQ, reg_value); ene_hw_write_reg(dev, ENE_TX_UNK1, 0x63); } ene_hw_write_reg(dev, ENE_CIR_CONF2, 0x00); ene_rx_set_inputs(dev); /* set sampling period */ ene_hw_write_reg(dev, ENE_CIR_SAMPLE_PERIOD, sample_period); /* ack any pending irqs - just in case */ ene_irq_status(dev); /* enable firmware bits */ ene_hw_write_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ, ENE_FW1_ENABLE | ENE_FW1_IRQ); /* enter idle mode */ ir_raw_event_set_idle(dev->idev, 1); ir_raw_event_reset(dev->idev); } /* Disable the device receiver */ static void ene_rx_disable(struct ene_device *dev) { /* disable inputs */ ene_enable_normal_receive(dev, 0); if (dev->hw_fan_as_normal_input) ene_enable_fan_receive(dev, 0); /* disable hardware IRQ and firmware flag */ ene_hw_write_reg_mask(dev, ENE_FW1, 0, ENE_FW1_ENABLE | ENE_FW1_IRQ); ir_raw_event_set_idle(dev->idev, 1); ir_raw_event_reset(dev->idev); } /* prepare transmission */ static void ene_tx_prepare(struct ene_device *dev) { u8 conf1; conf1 = ene_hw_read_reg(dev, ENE_CIR_CONF1); dev->saved_conf1 = conf1; if (dev->hw_revision == ENE_HW_C) conf1 &= ~ENE_CIR_CONF1_TX_CLEAR; /* Enable TX engine */ conf1 |= ENE_CIR_CONF1_TX_ON; /* Set carrier */ if (dev->tx_period) { /* NOTE: duty cycle handling is just a guess, it might not be aviable. Default values were tested */ int tx_period_in500ns = dev->tx_period * 2; int tx_pulse_width_in_500ns = tx_period_in500ns / (100 / dev->tx_duty_cycle); if (!tx_pulse_width_in_500ns) tx_pulse_width_in_500ns = 1; ene_dbg("TX: pulse distance = %d * 500 ns", tx_period_in500ns); ene_dbg("TX: pulse width = %d * 500 ns", tx_pulse_width_in_500ns); ene_hw_write_reg(dev, ENE_TX_PERIOD, ENE_TX_PERIOD_UNKBIT | tx_period_in500ns); ene_hw_write_reg(dev, ENE_TX_PERIOD_PULSE, tx_pulse_width_in_500ns); conf1 |= ENE_CIR_CONF1_TX_CARR; } else conf1 &= ~ENE_CIR_CONF1_TX_CARR; ene_hw_write_reg(dev, ENE_CIR_CONF1, conf1); } /* end transmission */ static void ene_tx_complete(struct ene_device *dev) { ene_hw_write_reg(dev, ENE_CIR_CONF1, dev->saved_conf1); dev->tx_buffer = NULL; } /* set transmit mask */ static void ene_tx_hw_set_transmiter_mask(struct ene_device *dev) { u8 txport1 = ene_hw_read_reg(dev, ENE_TX_PORT1) & ~ENE_TX_PORT1_EN; u8 txport2 = ene_hw_read_reg(dev, ENE_TX_PORT2) & ~ENE_TX_PORT2_EN; if (dev->transmitter_mask & 0x01) txport1 |= ENE_TX_PORT1_EN; if (dev->transmitter_mask & 0x02) txport2 |= ENE_TX_PORT2_EN; ene_hw_write_reg(dev, ENE_TX_PORT1, txport1); ene_hw_write_reg(dev, ENE_TX_PORT2, txport2); } /* TX one sample - must be called with dev->hw_lock*/ static void ene_tx_sample(struct ene_device *dev) { u8 raw_tx; u32 sample; if (!dev->tx_buffer) { ene_dbg("TX: attempt to transmit NULL buffer"); return; } /* Grab next TX sample */ if (!dev->tx_sample) { again: if (dev->tx_pos == dev->tx_len + 1) { if (!dev->tx_done) { ene_dbg("TX: no more data to send"); dev->tx_done = 1; goto exit; } else { ene_dbg("TX: last sample sent by hardware"); ene_tx_complete(dev); complete(&dev->tx_complete); return; } } sample = dev->tx_buffer[dev->tx_pos++]; dev->tx_sample_pulse = !dev->tx_sample_pulse; ene_dbg("TX: sample %8d (%s)", sample, dev->tx_sample_pulse ? "pulse" : "space"); dev->tx_sample = DIV_ROUND_CLOSEST(sample, ENE_TX_SMPL_PERIOD); /* guard against too short samples */ if (!dev->tx_sample) goto again; } raw_tx = min(dev->tx_sample , (unsigned int)ENE_TX_SMLP_MASK); dev->tx_sample -= raw_tx; if (dev->tx_sample_pulse) raw_tx |= ENE_TX_PULSE_MASK; ene_hw_write_reg(dev, ENE_TX_INPUT1 + dev->tx_reg, raw_tx); dev->tx_reg = !dev->tx_reg; exit: /* simulate TX done interrupt */ if (txsim) mod_timer(&dev->tx_sim_timer, jiffies + HZ / 500); } /* timer to simulate tx done interrupt */ static void ene_tx_irqsim(unsigned long data) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; spin_lock_irqsave(&dev->hw_lock, flags); ene_tx_sample(dev); spin_unlock_irqrestore(&dev->hw_lock, flags); } /* read irq status and ack it */ static int ene_irq_status(struct ene_device *dev) { u8 irq_status; u8 fw_flags1, fw_flags2; int cur_rx_pointer; int retval = 0; fw_flags2 = ene_hw_read_reg(dev, ENE_FW2); cur_rx_pointer = !!(fw_flags2 & ENE_FW2_BUF_HIGH); if (dev->hw_revision < ENE_HW_C) { irq_status = ene_hw_read_reg(dev, ENEB_IRQ_STATUS); if (!(irq_status & ENEB_IRQ_STATUS_IR)) return 0; ene_hw_write_reg(dev, ENEB_IRQ_STATUS, irq_status & ~ENEB_IRQ_STATUS_IR); dev->rx_pointer = cur_rx_pointer; return ENE_IRQ_RX; } irq_status = ene_hw_read_reg(dev, ENEC_IRQ); if (!(irq_status & ENEC_IRQ_STATUS)) return 0; /* original driver does that twice - a workaround ? */ ene_hw_write_reg(dev, ENEC_IRQ, irq_status & ~ENEC_IRQ_STATUS); ene_hw_write_reg(dev, ENEC_IRQ, irq_status & ~ENEC_IRQ_STATUS); /* clear unknown flag in F8F9 */ if (fw_flags2 & ENE_FW2_IRQ_CLR) ene_hw_write_reg(dev, ENE_FW2, fw_flags2 & ~ENE_FW2_IRQ_CLR); /* check if this is a TX interrupt */ fw_flags1 = ene_hw_read_reg(dev, ENE_FW1); if (fw_flags1 & ENE_FW1_TXIRQ) { ene_hw_write_reg(dev, ENE_FW1, fw_flags1 & ~ENE_FW1_TXIRQ); retval |= ENE_IRQ_TX; } /* Check if this is RX interrupt */ if (dev->rx_pointer != cur_rx_pointer) { retval |= ENE_IRQ_RX; dev->rx_pointer = cur_rx_pointer; } else if (!(retval & ENE_IRQ_TX)) { ene_dbg("RX: interrupt without change in RX pointer(%d)", dev->rx_pointer); retval |= ENE_IRQ_RX; } if ((retval & ENE_IRQ_RX) && (retval & ENE_IRQ_TX)) ene_dbg("both RX and TX interrupt at same time"); return retval; } /* interrupt handler */ static irqreturn_t ene_isr(int irq, void *data) { u16 hw_value; int i, hw_sample; int pulse; int irq_status; unsigned long flags; int carrier = 0; irqreturn_t retval = IRQ_NONE; struct ene_device *dev = (struct ene_device *)data; struct ir_raw_event ev; spin_lock_irqsave(&dev->hw_lock, flags); irq_status = ene_irq_status(dev); if (!irq_status) goto unlock; retval = IRQ_HANDLED; if (irq_status & ENE_IRQ_TX) { if (!dev->hw_learning_and_tx_capable) { ene_dbg("TX interrupt on unsupported device!"); goto unlock; } ene_tx_sample(dev); } if (!(irq_status & ENE_IRQ_RX)) goto unlock; if (dev->carrier_detect_enabled || debug) carrier = ene_rx_sense_carrier(dev); #if 0 /* TODO */ if (dev->carrier_detect_enabled && carrier) ir_raw_event_report_frequency(dev->idev, carrier); #endif for (i = 0; i < ENE_SAMPLES_SIZE; i++) { hw_value = ene_hw_read_reg(dev, ENE_SAMPLE_BUFFER + dev->rx_pointer * 4 + i); if (dev->rx_fan_input_inuse) { /* read high part of the sample */ hw_value |= ene_hw_read_reg(dev, ENE_SAMPLE_BUFFER_FAN + dev->rx_pointer * 4 + i) << 8; pulse = hw_value & ENE_FAN_SMPL_PULS_MSK; /* clear space bit, and other unused bits */ hw_value &= ENE_FAN_VALUE_MASK; hw_sample = hw_value * ENE_SAMPLE_PERIOD_FAN; } else { pulse = !(hw_value & ENE_SAMPLE_SPC_MASK); hw_value &= ENE_SAMPLE_VALUE_MASK; hw_sample = hw_value * sample_period; if (dev->rx_period_adjust) { hw_sample *= (100 - dev->rx_period_adjust); hw_sample /= 100; } } /* no more data */ if (!(hw_value)) break; ene_dbg("RX: %d (%s)", hw_sample, pulse ? "pulse" : "space"); ev.duration = hw_sample * 1000; ev.pulse = pulse; ir_raw_event_store_with_filter(dev->idev, &ev); } ir_raw_event_handle(dev->idev); unlock: spin_unlock_irqrestore(&dev->hw_lock, flags); return retval; } /* Initialize default settings */ static void ene_setup_settings(struct ene_device *dev) { dev->tx_period = 32; dev->tx_duty_cycle = 25; /*%*/ dev->transmitter_mask = 3; /* Force learning mode if (input == 2), otherwise let user set it with LIRC_SET_REC_CARRIER */ dev->learning_enabled = (input == 2 && dev->hw_learning_and_tx_capable); dev->rx_pointer = -1; } /* outside interface: called on first open*/ static int ene_open(void *data) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; spin_lock_irqsave(&dev->hw_lock, flags); dev->in_use = 1; ene_setup_settings(dev); ene_rx_enable(dev); spin_unlock_irqrestore(&dev->hw_lock, flags); return 0; } /* outside interface: called on device close*/ static void ene_close(void *data) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; spin_lock_irqsave(&dev->hw_lock, flags); ene_rx_disable(dev); dev->in_use = 0; spin_unlock_irqrestore(&dev->hw_lock, flags); } /* outside interface: set transmitter mask */ static int ene_set_tx_mask(void *data, u32 tx_mask) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; ene_dbg("TX: attempt to set transmitter mask %02x", tx_mask); /* invalid txmask */ if (!tx_mask || tx_mask & ~0x3) { ene_dbg("TX: invalid mask"); /* return count of transmitters */ return 2; } spin_lock_irqsave(&dev->hw_lock, flags); dev->transmitter_mask = tx_mask; spin_unlock_irqrestore(&dev->hw_lock, flags); return 0; } /* outside interface : set tx carrier */ static int ene_set_tx_carrier(void *data, u32 carrier) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; u32 period = 1000000 / carrier; /* (1 / freq) (* # usec in 1 sec) */ ene_dbg("TX: attempt to set tx carrier to %d kHz", carrier); if (period && (period > ENE_TX_PERIOD_MAX || period < ENE_TX_PERIOD_MIN)) { ene_dbg("TX: out of range %d-%d carrier, " "falling back to 32 kHz", 1000 / ENE_TX_PERIOD_MIN, 1000 / ENE_TX_PERIOD_MAX); period = 32; /* this is just a coincidence!!! */ } ene_dbg("TX: set carrier to %d kHz", carrier); spin_lock_irqsave(&dev->hw_lock, flags); dev->tx_period = period; spin_unlock_irqrestore(&dev->hw_lock, flags); return 0; } /* outside interface: enable learning mode */ static int ene_set_learning_mode(void *data, int enable) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; if (enable == dev->learning_enabled) return 0; spin_lock_irqsave(&dev->hw_lock, flags); dev->learning_enabled = enable; ene_rx_set_inputs(dev); spin_unlock_irqrestore(&dev->hw_lock, flags); return 0; } /* outside interface: set rec carrier */ static int ene_set_rec_carrier(void *data, u32 min, u32 max) { struct ene_device *dev = (struct ene_device *)data; ene_set_learning_mode(dev, max > ENE_NORMAL_RX_HI || min < ENE_NORMAL_RX_LOW); return 0; } /* outside interface: enable or disable idle mode */ static void ene_rx_set_idle(void *data, int idle) { struct ene_device *dev = (struct ene_device *)data; ene_dbg("%sabling idle mode", idle ? "en" : "dis"); ene_hw_write_reg_mask(dev, ENE_CIR_SAMPLE_PERIOD, (enable_idle && idle) ? 0 : ENE_CIR_SAMPLE_OVERFLOW, ENE_CIR_SAMPLE_OVERFLOW); } /* outside interface: transmit */ static int ene_transmit(void *data, int *buf, u32 n) { struct ene_device *dev = (struct ene_device *)data; unsigned long flags; dev->tx_buffer = buf; dev->tx_len = n / sizeof(int); dev->tx_pos = 0; dev->tx_reg = 0; dev->tx_done = 0; dev->tx_sample = 0; dev->tx_sample_pulse = 0; ene_dbg("TX: %d samples", dev->tx_len); spin_lock_irqsave(&dev->hw_lock, flags); ene_tx_hw_set_transmiter_mask(dev); ene_tx_prepare(dev); /* Transmit first two samples */ ene_tx_sample(dev); ene_tx_sample(dev); spin_unlock_irqrestore(&dev->hw_lock, flags); if (wait_for_completion_timeout(&dev->tx_complete, 2 * HZ) == 0) { ene_dbg("TX: timeout"); spin_lock_irqsave(&dev->hw_lock, flags); ene_tx_complete(dev); spin_unlock_irqrestore(&dev->hw_lock, flags); } else ene_dbg("TX: done"); return n; } /* probe entry */ static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id) { int error = -ENOMEM; struct ir_dev_props *ir_props; struct input_dev *input_dev; struct ene_device *dev; /* allocate memory */ input_dev = input_allocate_device(); ir_props = kzalloc(sizeof(struct ir_dev_props), GFP_KERNEL); dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL); if (!input_dev || !ir_props || !dev) goto error; /* validate resources */ error = -ENODEV; if (!pnp_port_valid(pnp_dev, 0) || pnp_port_len(pnp_dev, 0) < ENE_MAX_IO) goto error; if (!pnp_irq_valid(pnp_dev, 0)) goto error; dev->hw_io = pnp_port_start(pnp_dev, 0); dev->irq = pnp_irq(pnp_dev, 0); spin_lock_init(&dev->hw_lock); /* claim the resources */ error = -EBUSY; if (!request_region(dev->hw_io, ENE_MAX_IO, ENE_DRIVER_NAME)) goto error; if (request_irq(dev->irq, ene_isr, IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev)) goto error; pnp_set_drvdata(pnp_dev, dev); dev->pnp_dev = pnp_dev; /* detect hardware version and features */ error = ene_hw_detect(dev); if (error) goto error; ene_setup_settings(dev); if (!dev->hw_learning_and_tx_capable && txsim) { dev->hw_learning_and_tx_capable = 1; setup_timer(&dev->tx_sim_timer, ene_tx_irqsim, (long unsigned int)dev); ene_printk(KERN_WARNING, "Simulation of TX activated\n"); } ir_props->driver_type = RC_DRIVER_IR_RAW; ir_props->allowed_protos = IR_TYPE_ALL; ir_props->priv = dev; ir_props->open = ene_open; ir_props->close = ene_close; ir_props->min_timeout = ENE_MINGAP * 1000; ir_props->max_timeout = ENE_MAXGAP * 1000; ir_props->timeout = ENE_MAXGAP * 1000; if (dev->hw_revision == ENE_HW_B) ir_props->s_idle = ene_rx_set_idle; dev->props = ir_props; dev->idev = input_dev; /* don't allow too short/long sample periods */ if (sample_period < 5 || sample_period > 0x7F) sample_period = -1; /* choose default sample period */ if (sample_period == -1) { sample_period = 50; /* on revB, hardware idle mode eats first sample if we set too low sample period */ if (dev->hw_revision == ENE_HW_B && enable_idle) sample_period = 75; } ir_props->rx_resolution = sample_period * 1000; if (dev->hw_learning_and_tx_capable) { ir_props->s_learning_mode = ene_set_learning_mode; if (input == 0) ir_props->s_rx_carrier_range = ene_set_rec_carrier; init_completion(&dev->tx_complete); ir_props->tx_ir = ene_transmit; ir_props->s_tx_mask = ene_set_tx_mask; ir_props->s_tx_carrier = ene_set_tx_carrier; ir_props->tx_resolution = ENE_TX_SMPL_PERIOD * 1000; /* ir_props->s_carrier_report = ene_set_carrier_report; */ } device_set_wakeup_capable(&pnp_dev->dev, 1); device_set_wakeup_enable(&pnp_dev->dev, 1); if (dev->hw_learning_and_tx_capable) input_dev->name = "ENE eHome Infrared Remote Transceiver"; else input_dev->name = "ENE eHome Infrared Remote Receiver"; error = -ENODEV; if (ir_input_register(input_dev, RC_MAP_RC6_MCE, ir_props, ENE_DRIVER_NAME)) goto error; ene_printk(KERN_NOTICE, "driver has been succesfully loaded\n"); return 0; error: if (dev->irq) free_irq(dev->irq, dev); if (dev->hw_io) release_region(dev->hw_io, ENE_MAX_IO); input_free_device(input_dev); kfree(ir_props); kfree(dev); return error; } /* main unload function */ static void ene_remove(struct pnp_dev *pnp_dev) { struct ene_device *dev = pnp_get_drvdata(pnp_dev); unsigned long flags; spin_lock_irqsave(&dev->hw_lock, flags); ene_rx_disable(dev); spin_unlock_irqrestore(&dev->hw_lock, flags); free_irq(dev->irq, dev); release_region(dev->hw_io, ENE_MAX_IO); ir_input_unregister(dev->idev); kfree(dev->props); kfree(dev); } /* enable wake on IR (wakes on specific button on original remote) */ static void ene_enable_wake(struct ene_device *dev, int enable) { enable = enable && device_may_wakeup(&dev->pnp_dev->dev); ene_dbg("wake on IR %s", enable ? "enabled" : "disabled"); ene_hw_write_reg_mask(dev, ENE_FW1, enable ? ENE_FW1_WAKE : 0, ENE_FW1_WAKE); } #ifdef CONFIG_PM static int ene_suspend(struct pnp_dev *pnp_dev, pm_message_t state) { struct ene_device *dev = pnp_get_drvdata(pnp_dev); ene_enable_wake(dev, 1); return 0; } static int ene_resume(struct pnp_dev *pnp_dev) { struct ene_device *dev = pnp_get_drvdata(pnp_dev); if (dev->in_use) ene_rx_enable(dev); ene_enable_wake(dev, 0); return 0; } #endif static void ene_shutdown(struct pnp_dev *pnp_dev) { struct ene_device *dev = pnp_get_drvdata(pnp_dev); ene_enable_wake(dev, 1); } static const struct pnp_device_id ene_ids[] = { {.id = "ENE0100",}, {.id = "ENE0200",}, {.id = "ENE0201",}, {.id = "ENE0202",}, {}, }; static struct pnp_driver ene_driver = { .name = ENE_DRIVER_NAME, .id_table = ene_ids, .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, .probe = ene_probe, .remove = __devexit_p(ene_remove), #ifdef CONFIG_PM .suspend = ene_suspend, .resume = ene_resume, #endif .shutdown = ene_shutdown, }; static int __init ene_init(void) { return pnp_register_driver(&ene_driver); } static void ene_exit(void) { pnp_unregister_driver(&ene_driver); } module_param(sample_period, int, S_IRUGO); MODULE_PARM_DESC(sample_period, "Hardware sample period (50 us default)"); module_param(enable_idle, bool, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(enable_idle, "Enables turning off signal sampling after long inactivity time; " "if disabled might help detecting input signal (default: enabled)" " (KB3926B only)"); module_param(input, bool, S_IRUGO); MODULE_PARM_DESC(input, "select which input to use " "0 - auto, 1 - standard, 2 - wideband(KB3926C+)"); module_param(debug, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(debug, "Enable debug (debug=2 verbose debug output)"); module_param(txsim, bool, S_IRUGO); MODULE_PARM_DESC(txsim, "Simulate TX features on unsupported hardware (dangerous)"); MODULE_DEVICE_TABLE(pnp, ene_ids); MODULE_DESCRIPTION ("Infrared input driver for KB3926B/KB3926C/KB3926D " "(aka ENE0100/ENE0200/ENE0201) CIR port"); MODULE_AUTHOR("Maxim Levitsky"); MODULE_LICENSE("GPL"); module_init(ene_init); module_exit(ene_exit);