forked from Minki/linux
1177 lines
30 KiB
C
1177 lines
30 KiB
C
|
/*
|
||
|
* driver for ENE KB3926 B/C/D CIR (also known as ENE0100/ENE0200/ENE0201)
|
||
|
*
|
||
|
* Copyright (C) 2010 Maxim Levitsky <maximlevitsky@gmail.com>
|
||
|
*
|
||
|
* 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 <linux/kernel.h>
|
||
|
#include <linux/module.h>
|
||
|
#include <linux/pnp.h>
|
||
|
#include <linux/io.h>
|
||
|
#include <linux/interrupt.h>
|
||
|
#include <linux/sched.h>
|
||
|
#include <linux/uaccess.h>
|
||
|
#include "lirc_ene0100.h"
|
||
|
|
||
|
|
||
|
static int sample_period = -1;
|
||
|
static int enable_idle = 1;
|
||
|
static int enable_duty_carrier;
|
||
|
static int input = 1;
|
||
|
static int debug;
|
||
|
static int txsim;
|
||
|
|
||
|
static void ene_rx_set_idle(struct ene_device *dev, int idle);
|
||
|
static int ene_irq_status(struct ene_device *dev);
|
||
|
static void ene_send_sample(struct ene_device *dev, unsigned long sample);
|
||
|
|
||
|
/* 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;
|
||
|
|
||
|
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);
|
||
|
|
||
|
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_recieve(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_recieve(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_recieve(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 recieved 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 || dev->rx_carrier_sense;
|
||
|
|
||
|
ene_dbg("RX: setup reciever, learning mode = %d", learning_mode);
|
||
|
|
||
|
ene_enable_normal_recieve(dev, 1);
|
||
|
|
||
|
/* old hardware doesn't support learning mode for sure */
|
||
|
if (dev->hw_revision <= ENE_HW_B)
|
||
|
return;
|
||
|
|
||
|
/* reciever not learning capable, still set gpio40 correctly */
|
||
|
if (!dev->hw_learning_and_tx_capable) {
|
||
|
ene_enable_gpio40_recieve(dev, !dev->hw_gpio40_learning);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/* enable learning mode */
|
||
|
if (learning_mode) {
|
||
|
ene_enable_gpio40_recieve(dev, dev->hw_gpio40_learning);
|
||
|
|
||
|
/* fan input is not used for learning */
|
||
|
if (dev->hw_fan_as_normal_input)
|
||
|
ene_enable_fan_recieve(dev, 0);
|
||
|
|
||
|
/* disable learning mode */
|
||
|
} else {
|
||
|
if (dev->hw_fan_as_normal_input) {
|
||
|
ene_enable_fan_recieve(dev, 1);
|
||
|
ene_enable_normal_recieve(dev, 0);
|
||
|
} else
|
||
|
ene_enable_gpio40_recieve(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);
|
||
|
}
|
||
|
|
||
|
/* 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);
|
||
|
|
||
|
/* enter idle mode */
|
||
|
ene_rx_set_idle(dev, 1);
|
||
|
|
||
|
/* enable firmware bits */
|
||
|
ene_hw_write_reg_mask(dev, ENE_FW1,
|
||
|
ENE_FW1_ENABLE | ENE_FW1_IRQ,
|
||
|
ENE_FW1_ENABLE | ENE_FW1_IRQ);
|
||
|
}
|
||
|
|
||
|
/* Disable the device reciever */
|
||
|
static void ene_rx_disable(struct ene_device *dev)
|
||
|
{
|
||
|
/* disable inputs */
|
||
|
ene_enable_normal_recieve(dev, 0);
|
||
|
|
||
|
if (dev->hw_fan_as_normal_input)
|
||
|
ene_enable_fan_recieve(dev, 0);
|
||
|
|
||
|
/* disable hardware IRQ and firmware flag */
|
||
|
ene_hw_write_reg_mask(dev, ENE_FW1, 0, ENE_FW1_ENABLE | ENE_FW1_IRQ);
|
||
|
|
||
|
ene_rx_set_idle(dev, 1);
|
||
|
}
|
||
|
|
||
|
/* send current sample to the user */
|
||
|
static void ene_rx_flush(struct ene_device *dev, int timeout)
|
||
|
{
|
||
|
unsigned long value;
|
||
|
|
||
|
value = dev->rx_sample_pulse ? LIRC_PULSE(dev->rx_sample) :
|
||
|
LIRC_SPACE(dev->rx_sample);
|
||
|
ene_send_sample(dev, value);
|
||
|
dev->rx_sample = 0;
|
||
|
dev->rx_sample_pulse = 0;
|
||
|
}
|
||
|
|
||
|
/* recieve new sample and process it */
|
||
|
static void ene_rx_sample(struct ene_device *dev, int sample, int is_pulse)
|
||
|
{
|
||
|
ene_dbg("RX: sample %8d (%s)", sample, is_pulse ? "pulse" : "space");
|
||
|
|
||
|
/* ignore spaces in idle mode, can get them on revC */
|
||
|
/* also ignore a space in front of first pulse */
|
||
|
if (dev->rx_idle && !is_pulse)
|
||
|
return;
|
||
|
|
||
|
/* get out of idle mode now */
|
||
|
if (dev->rx_idle)
|
||
|
ene_rx_set_idle(dev, 0);
|
||
|
|
||
|
if (!dev->rx_sample) {
|
||
|
dev->rx_sample = sample;
|
||
|
dev->rx_sample_pulse = is_pulse;
|
||
|
} else if (is_pulse == dev->rx_sample_pulse)
|
||
|
dev->rx_sample += sample;
|
||
|
else {
|
||
|
ene_rx_flush(dev, 0);
|
||
|
dev->rx_sample = sample;
|
||
|
dev->rx_sample_pulse = is_pulse;
|
||
|
}
|
||
|
|
||
|
if (is_pulse)
|
||
|
return;
|
||
|
|
||
|
/* overflow sample from fan input recieved, enable idle mode */
|
||
|
if (dev->rx_fan_input_inuse &&
|
||
|
sample == ENE_FAN_VALUE_MASK * ENE_SAMPLE_PERIOD_FAN) {
|
||
|
ene_rx_set_idle(dev, 1);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (!dev->rx_fan_input_inuse) {
|
||
|
/* Report timeout if enabled */
|
||
|
if (dev->rx_timeout && dev->rx_send_timeout_packet &&
|
||
|
!dev->rx_timeout_sent &&
|
||
|
dev->rx_sample > dev->rx_timeout) {
|
||
|
ene_dbg("RX: sending timeout sample");
|
||
|
ene_send_sample(dev, LIRC_TIMEOUT(dev->rx_sample));
|
||
|
dev->rx_timeout_sent = 1;
|
||
|
}
|
||
|
|
||
|
/* too large sample accumulated via normal input.
|
||
|
note that on revC, hardware idle mode turns on automaticly,
|
||
|
so max gap should be less that the gap after which
|
||
|
hw stops sending samples */
|
||
|
if (dev->rx_sample > ENE_MAXGAP) {
|
||
|
ene_rx_set_idle(dev, 1);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* enable or disable idle mode */
|
||
|
static void ene_rx_set_idle(struct ene_device *dev, int idle)
|
||
|
{
|
||
|
struct timeval now;
|
||
|
int disable_sampler = 0;
|
||
|
|
||
|
|
||
|
/* Also put hardware sampler in 'idle' mode on revB*/
|
||
|
/* revC and higher do that automaticly (firmware does?) */
|
||
|
if ((dev->hw_revision < ENE_HW_C) && enable_idle)
|
||
|
if (idle)
|
||
|
disable_sampler = 1;
|
||
|
|
||
|
ene_hw_write_reg_mask(dev, ENE_CIR_SAMPLE_PERIOD,
|
||
|
disable_sampler ? 0 : ENE_CIR_SAMPLE_OVERFLOW,
|
||
|
ENE_CIR_SAMPLE_OVERFLOW);
|
||
|
dev->rx_idle = idle;
|
||
|
|
||
|
/* remember when we have entered the idle mode */
|
||
|
if (idle) {
|
||
|
ene_dbg("RX: going into idle mode");
|
||
|
do_gettimeofday(&dev->rx_gap_start);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ene_dbg("RX: back from idle mode");
|
||
|
|
||
|
/* send the gap between keypresses now */
|
||
|
do_gettimeofday(&now);
|
||
|
|
||
|
if (dev->rx_sample_pulse) {
|
||
|
ene_dbg("RX: somehow we recieved a pulse before idle mode???");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/* manually calculate and recieve the gap between keypresses */
|
||
|
if (now.tv_sec - dev->rx_gap_start.tv_sec > 16)
|
||
|
dev->rx_sample = LIRC_SPACE(LIRC_VALUE_MASK);
|
||
|
else
|
||
|
dev->rx_sample +=
|
||
|
1000000ull * (now.tv_sec - dev->rx_gap_start.tv_sec)
|
||
|
+ now.tv_usec - dev->rx_gap_start.tv_usec;
|
||
|
|
||
|
if (dev->rx_sample > LIRC_SPACE(LIRC_VALUE_MASK))
|
||
|
dev->rx_sample = LIRC_SPACE(LIRC_VALUE_MASK);
|
||
|
|
||
|
ene_rx_flush(dev, 0);
|
||
|
dev->rx_timeout_sent = 0;
|
||
|
}
|
||
|
|
||
|
/* 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) {
|
||
|
|
||
|
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);
|
||
|
dev->tx_underway = 1;
|
||
|
|
||
|
}
|
||
|
|
||
|
/* end transmission */
|
||
|
static void ene_tx_complete(struct ene_device *dev)
|
||
|
{
|
||
|
ene_hw_write_reg(dev, ENE_CIR_CONF1, dev->saved_conf1);
|
||
|
dev->tx_underway = 0;
|
||
|
}
|
||
|
|
||
|
/* set transmit mask */
|
||
|
static void ene_tx_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_underway) {
|
||
|
ene_dbg("TX: attempt to transmit while hw isn't setup");
|
||
|
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;
|
||
|
|
||
|
|
||
|
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 ((debug && dev->learning_enabled) || dev->rx_carrier_sense)
|
||
|
carrier = ene_rx_sense_carrier(dev);
|
||
|
|
||
|
if (dev->rx_carrier_sense && carrier)
|
||
|
ene_send_sample(dev, LIRC_FREQUENCY(carrier));
|
||
|
|
||
|
|
||
|
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;
|
||
|
}
|
||
|
/* no more data */
|
||
|
if (!(hw_value))
|
||
|
break;
|
||
|
|
||
|
ene_rx_sample(dev, hw_sample, pulse);
|
||
|
}
|
||
|
unlock:
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
/* Initialize default settings */
|
||
|
static void ene_setup_settings(struct ene_device *dev)
|
||
|
{
|
||
|
dev->rx_send_timeout_packet = 0;
|
||
|
dev->rx_timeout = ENE_MAXGAP;
|
||
|
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);
|
||
|
|
||
|
/* Clear accumulated sample bufer */
|
||
|
dev->rx_sample = 0;
|
||
|
dev->rx_sample_pulse = 0;
|
||
|
dev->rx_pointer = -1;
|
||
|
dev->rx_carrier_sense = 0;
|
||
|
|
||
|
}
|
||
|
|
||
|
/* 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 for settings */
|
||
|
static int ene_ioctl(struct inode *node, struct file *file,
|
||
|
unsigned int cmd, unsigned long arg)
|
||
|
{
|
||
|
int lvalue = 0, retval, tmp;
|
||
|
unsigned long flags;
|
||
|
struct ene_device *dev = lirc_get_pdata(file);
|
||
|
|
||
|
|
||
|
switch (cmd) {
|
||
|
case LIRC_SET_SEND_CARRIER:
|
||
|
case LIRC_SET_SEND_DUTY_CYCLE:
|
||
|
case LIRC_SET_TRANSMITTER_MASK:
|
||
|
case LIRC_SET_MEASURE_CARRIER_MODE:
|
||
|
case LIRC_SET_REC_CARRIER:
|
||
|
/* All these aren't possible without this */
|
||
|
if (!dev->hw_learning_and_tx_capable)
|
||
|
return -ENOSYS;
|
||
|
/* Fall through */
|
||
|
case LIRC_SET_REC_TIMEOUT:
|
||
|
case LIRC_SET_REC_TIMEOUT_REPORTS:
|
||
|
retval = get_user(lvalue, (unsigned int *) arg);
|
||
|
if (retval)
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
switch (cmd) {
|
||
|
case LIRC_SET_SEND_CARRIER:
|
||
|
ene_dbg("TX: attempt to set tx carrier to %d kHz", lvalue);
|
||
|
tmp = 1000000 / lvalue; /* (1 / freq) (* # usec in 1 sec) */
|
||
|
|
||
|
if (tmp && (tmp > ENE_TX_PERIOD_MAX ||
|
||
|
tmp < 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);
|
||
|
|
||
|
tmp = 32; /* this is just a coincidence!!! */
|
||
|
}
|
||
|
ene_dbg("TX: set carrier to %d kHz", lvalue);
|
||
|
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->tx_period = tmp;
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
break;
|
||
|
case LIRC_SET_SEND_DUTY_CYCLE:
|
||
|
ene_dbg("TX: attempt to set duty cycle to %d%%", lvalue);
|
||
|
|
||
|
if ((lvalue >= 100) || (lvalue <= 0)) {
|
||
|
retval = -EINVAL;
|
||
|
break;
|
||
|
}
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->tx_duty_cycle = lvalue;
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
break;
|
||
|
case LIRC_SET_TRANSMITTER_MASK:
|
||
|
ene_dbg("TX: attempt to set transmitter mask %02x", lvalue);
|
||
|
|
||
|
/* invalid txmask */
|
||
|
if (!lvalue || lvalue & ~0x3) {
|
||
|
ene_dbg("TX: invalid mask");
|
||
|
/* this supposed to return num of transmitters */
|
||
|
retval = 2;
|
||
|
break;
|
||
|
}
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->transmitter_mask = lvalue;
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
break;
|
||
|
case LIRC_SET_REC_CARRIER:
|
||
|
tmp = (lvalue > ENE_NORMAL_RX_HI || lvalue < ENE_NORMAL_RX_LOW);
|
||
|
|
||
|
if (tmp != dev->learning_enabled) {
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->learning_enabled = tmp;
|
||
|
ene_rx_set_inputs(dev);
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
}
|
||
|
break;
|
||
|
case LIRC_SET_REC_TIMEOUT:
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->rx_timeout = lvalue;
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
ene_dbg("RX: set rx report timeout to %d", dev->rx_timeout);
|
||
|
break;
|
||
|
case LIRC_SET_REC_TIMEOUT_REPORTS:
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->rx_send_timeout_packet = lvalue;
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
ene_dbg("RX: %sable timeout reports",
|
||
|
dev->rx_send_timeout_packet ? "en" : "dis");
|
||
|
break;
|
||
|
case LIRC_SET_MEASURE_CARRIER_MODE:
|
||
|
if (dev->rx_carrier_sense == lvalue)
|
||
|
break;
|
||
|
spin_lock_irqsave(&dev->hw_lock, flags);
|
||
|
dev->rx_carrier_sense = lvalue;
|
||
|
ene_rx_set_inputs(dev);
|
||
|
spin_unlock_irqrestore(&dev->hw_lock, flags);
|
||
|
break;
|
||
|
case LIRC_GET_REC_RESOLUTION:
|
||
|
tmp = dev->rx_fan_input_inuse ?
|
||
|
ENE_SAMPLE_PERIOD_FAN : sample_period;
|
||
|
retval = put_user(tmp, (unsigned long *) arg);
|
||
|
break;
|
||
|
default:
|
||
|
retval = -ENOIOCTLCMD;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
/* outside interface: transmit */
|
||
|
static ssize_t ene_transmit(struct file *file, const char *buf,
|
||
|
size_t n, loff_t *ppos)
|
||
|
{
|
||
|
struct ene_device *dev = lirc_get_pdata(file);
|
||
|
unsigned long flags;
|
||
|
|
||
|
if (!dev)
|
||
|
return -EFAULT;
|
||
|
|
||
|
if (!dev->hw_learning_and_tx_capable)
|
||
|
return -ENODEV;
|
||
|
|
||
|
if (n % sizeof(int))
|
||
|
return -EINVAL;
|
||
|
|
||
|
if (n > ENE_TXBUF_SIZE * sizeof(int))
|
||
|
return -ENOMEM;
|
||
|
|
||
|
if (copy_from_user(dev->tx_buffer, buf, n))
|
||
|
return -EFAULT;
|
||
|
|
||
|
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_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;
|
||
|
}
|
||
|
|
||
|
/* Sends one sample to the user */
|
||
|
static void ene_send_sample(struct ene_device *dev, unsigned long sample)
|
||
|
{
|
||
|
if (!lirc_buffer_full(dev->lirc_driver->rbuf)) {
|
||
|
lirc_buffer_write(dev->lirc_driver->rbuf, (void *)&sample);
|
||
|
wake_up(&dev->lirc_driver->rbuf->wait_poll);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
static const struct file_operations ene_fops = {
|
||
|
.owner = THIS_MODULE,
|
||
|
.write = ene_transmit,
|
||
|
.ioctl = ene_ioctl,
|
||
|
};
|
||
|
|
||
|
/* main load function */
|
||
|
static int ene_probe(struct pnp_dev *pnp_dev,
|
||
|
const struct pnp_device_id *dev_id)
|
||
|
{
|
||
|
struct ene_device *dev;
|
||
|
struct lirc_driver *lirc_driver;
|
||
|
int error = -ENOMEM;
|
||
|
|
||
|
dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL);
|
||
|
|
||
|
if (!dev)
|
||
|
goto err1;
|
||
|
|
||
|
dev->pnp_dev = pnp_dev;
|
||
|
pnp_set_drvdata(pnp_dev, dev);
|
||
|
|
||
|
/* prepare lirc interface */
|
||
|
error = -ENOMEM;
|
||
|
lirc_driver = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);
|
||
|
|
||
|
if (!lirc_driver)
|
||
|
goto err2;
|
||
|
|
||
|
dev->lirc_driver = lirc_driver;
|
||
|
|
||
|
strcpy(lirc_driver->name, ENE_DRIVER_NAME);
|
||
|
lirc_driver->minor = -1;
|
||
|
lirc_driver->code_length = sizeof(int) * 8;
|
||
|
lirc_driver->features = LIRC_CAN_REC_MODE2 |
|
||
|
LIRC_CAN_GET_REC_RESOLUTION |
|
||
|
LIRC_CAN_SET_REC_TIMEOUT;
|
||
|
lirc_driver->data = dev;
|
||
|
lirc_driver->set_use_inc = ene_open;
|
||
|
lirc_driver->set_use_dec = ene_close;
|
||
|
lirc_driver->dev = &pnp_dev->dev;
|
||
|
lirc_driver->owner = THIS_MODULE;
|
||
|
lirc_driver->fops = &ene_fops;
|
||
|
lirc_driver->min_timeout = ENE_MINGAP;
|
||
|
lirc_driver->max_timeout = ENE_MAXGAP;
|
||
|
lirc_driver->rbuf = kzalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
|
||
|
|
||
|
if (!lirc_driver->rbuf)
|
||
|
goto err3;
|
||
|
|
||
|
if (lirc_buffer_init(lirc_driver->rbuf, sizeof(int), sizeof(int) * 512))
|
||
|
goto err4;
|
||
|
|
||
|
/* validate resources */
|
||
|
if (!pnp_port_valid(pnp_dev, 0) ||
|
||
|
pnp_port_len(pnp_dev, 0) < ENE_MAX_IO)
|
||
|
goto err5;
|
||
|
|
||
|
if (!pnp_irq_valid(pnp_dev, 0))
|
||
|
goto err5;
|
||
|
|
||
|
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 err5;
|
||
|
|
||
|
if (request_irq(dev->irq, ene_isr,
|
||
|
IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev))
|
||
|
goto err6;
|
||
|
|
||
|
/* detect hardware version and features */
|
||
|
error = ene_hw_detect(dev);
|
||
|
if (error)
|
||
|
goto err7;
|
||
|
|
||
|
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");
|
||
|
}
|
||
|
|
||
|
if (dev->hw_learning_and_tx_capable) {
|
||
|
lirc_driver->features |= LIRC_CAN_SEND_PULSE |
|
||
|
LIRC_CAN_SET_SEND_CARRIER |
|
||
|
LIRC_CAN_SET_TRANSMITTER_MASK;
|
||
|
|
||
|
if (enable_duty_carrier)
|
||
|
lirc_driver->features |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
|
||
|
|
||
|
if (input == 0)
|
||
|
lirc_driver->features |= LIRC_CAN_SET_REC_CARRIER;
|
||
|
|
||
|
init_completion(&dev->tx_complete);
|
||
|
}
|
||
|
|
||
|
/* 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;
|
||
|
}
|
||
|
|
||
|
device_set_wakeup_capable(&pnp_dev->dev, 1);
|
||
|
device_set_wakeup_enable(&pnp_dev->dev, 1);
|
||
|
|
||
|
error = -ENODEV;
|
||
|
if (lirc_register_driver(lirc_driver))
|
||
|
goto err7;
|
||
|
|
||
|
ene_printk(KERN_NOTICE, "driver has been succesfully loaded\n");
|
||
|
return 0;
|
||
|
|
||
|
err7:
|
||
|
free_irq(dev->irq, dev);
|
||
|
err6:
|
||
|
release_region(dev->hw_io, ENE_MAX_IO);
|
||
|
err5:
|
||
|
lirc_buffer_free(lirc_driver->rbuf);
|
||
|
err4:
|
||
|
kfree(lirc_driver->rbuf);
|
||
|
err3:
|
||
|
kfree(lirc_driver);
|
||
|
err2:
|
||
|
kfree(dev);
|
||
|
err1:
|
||
|
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);
|
||
|
lirc_unregister_driver(dev->lirc_driver->minor);
|
||
|
lirc_buffer_free(dev->lirc_driver->rbuf);
|
||
|
kfree(dev->lirc_driver);
|
||
|
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",},
|
||
|
{},
|
||
|
};
|
||
|
|
||
|
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_param(enable_duty_carrier, bool, S_IRUGO);
|
||
|
MODULE_PARM_DESC(enable_duty_carrier,
|
||
|
"Enable a code that might allow to to set TX carrier duty cycle");
|
||
|
|
||
|
MODULE_DEVICE_TABLE(pnp, ene_ids);
|
||
|
MODULE_DESCRIPTION
|
||
|
("LIRC 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);
|