aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/IR/ene_ir.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/IR/ene_ir.c')
-rw-r--r--drivers/media/IR/ene_ir.c595
1 files changed, 221 insertions, 374 deletions
diff --git a/drivers/media/IR/ene_ir.c b/drivers/media/IR/ene_ir.c
index 9d11caf55b0..5447750f5e3 100644
--- a/drivers/media/IR/ene_ir.c
+++ b/drivers/media/IR/ene_ir.c
@@ -1,5 +1,5 @@
/*
- * driver for ENE KB3926 B/C/D CIR (also known as ENE0100/ENE0200/ENE0201)
+ * driver for ENE KB3926 B/C/D CIR (pnp id: ENE0XXX)
*
* Copyright (C) 2010 Maxim Levitsky <maximlevitsky@gmail.com>
*
@@ -25,20 +25,20 @@
#include <linux/io.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
-#include <linux/uaccess.h>
-#include "lirc_ene0100.h"
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <media/ir-core.h>
+#include <media/ir-common.h>
+#include "ene_ir.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)
@@ -85,6 +85,7 @@ static int ene_hw_detect(struct ene_device *dev)
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);
@@ -96,6 +97,17 @@ static int ene_hw_detect(struct ene_device *dev)
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");
@@ -160,7 +172,7 @@ static int ene_hw_detect(struct ene_device *dev)
}
/* this enables/disables IR input via gpio40*/
-static void ene_enable_gpio40_recieve(struct ene_device *dev, int enable)
+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,
@@ -168,13 +180,13 @@ static void ene_enable_gpio40_recieve(struct ene_device *dev, int enable)
}
/* this enables/disables IR via standard input */
-static void ene_enable_normal_recieve(struct ene_device *dev, int enable)
+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_recieve(struct ene_device *dev, int enable)
+static void ene_enable_fan_receive(struct ene_device *dev, int enable)
{
if (!enable)
ene_hw_write_reg(dev, ENE_FAN_AS_IN1, 0);
@@ -186,7 +198,7 @@ static void ene_enable_fan_recieve(struct ene_device *dev, int enable)
}
-/* Sense current recieved carrier */
+/* Sense current received carrier */
static int ene_rx_sense_carrier(struct ene_device *dev)
{
int period = ene_hw_read_reg(dev, ENE_RX_CARRIER);
@@ -209,37 +221,37 @@ static int ene_rx_sense_carrier(struct ene_device *dev)
/* 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;
+ int learning_mode = dev->learning_enabled;
- ene_dbg("RX: setup reciever, learning mode = %d", learning_mode);
+ ene_dbg("RX: setup receiver, learning mode = %d", learning_mode);
- ene_enable_normal_recieve(dev, 1);
+ ene_enable_normal_receive(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 */
+ /* receiver not learning capable, still set gpio40 correctly */
if (!dev->hw_learning_and_tx_capable) {
- ene_enable_gpio40_recieve(dev, !dev->hw_gpio40_learning);
+ ene_enable_gpio40_receive(dev, !dev->hw_gpio40_learning);
return;
}
/* enable learning mode */
if (learning_mode) {
- ene_enable_gpio40_recieve(dev, dev->hw_gpio40_learning);
+ 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_recieve(dev, 0);
+ ene_enable_fan_receive(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);
+ ene_enable_fan_receive(dev, 1);
+ ene_enable_normal_receive(dev, 0);
} else
- ene_enable_gpio40_recieve(dev,
+ ene_enable_gpio40_receive(dev,
!dev->hw_gpio40_learning);
}
@@ -249,6 +261,16 @@ static void ene_rx_set_inputs(struct ene_device *dev)
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 */
@@ -277,147 +299,33 @@ static void ene_rx_enable(struct ene_device *dev)
/* 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);
+
+ /* enter idle mode */
+ ir_raw_event_set_idle(dev->idev, 1);
+ ir_raw_event_reset(dev->idev);
+
}
-/* Disable the device reciever */
+/* Disable the device receiver */
static void ene_rx_disable(struct ene_device *dev)
{
/* disable inputs */
- ene_enable_normal_recieve(dev, 0);
+ ene_enable_normal_receive(dev, 0);
if (dev->hw_fan_as_normal_input)
- ene_enable_fan_recieve(dev, 0);
+ 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);
- 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;
- }
- }
+ ir_raw_event_set_idle(dev->idev, 1);
+ ir_raw_event_reset(dev->idev);
}
-/* 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)
@@ -436,6 +344,8 @@ static void ene_tx_prepare(struct ene_device *dev)
/* 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 =
@@ -459,7 +369,6 @@ static void ene_tx_prepare(struct ene_device *dev)
conf1 &= ~ENE_CIR_CONF1_TX_CARR;
ene_hw_write_reg(dev, ENE_CIR_CONF1, conf1);
- dev->tx_underway = 1;
}
@@ -467,11 +376,11 @@ static void ene_tx_prepare(struct ene_device *dev)
static void ene_tx_complete(struct ene_device *dev)
{
ene_hw_write_reg(dev, ENE_CIR_CONF1, dev->saved_conf1);
- dev->tx_underway = 0;
+ dev->tx_buffer = NULL;
}
/* set transmit mask */
-static void ene_tx_set_transmiter_mask(struct ene_device *dev)
+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;
@@ -492,8 +401,8 @@ 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");
+ if (!dev->tx_buffer) {
+ ene_dbg("TX: attempt to transmit NULL buffer");
return;
}
@@ -623,6 +532,7 @@ static irqreturn_t ene_isr(int irq, void *data)
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);
@@ -646,12 +556,13 @@ static irqreturn_t ene_isr(int irq, void *data)
goto unlock;
- if ((debug && dev->learning_enabled) || dev->rx_carrier_sense)
+ if (dev->carrier_detect_enabled || debug)
carrier = ene_rx_sense_carrier(dev);
-
- if (dev->rx_carrier_sense && carrier)
- ene_send_sample(dev, LIRC_FREQUENCY(carrier));
-
+#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,
@@ -672,13 +583,25 @@ static irqreturn_t ene_isr(int irq, void *data)
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_rx_sample(dev, hw_sample, pulse);
+ 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;
@@ -687,8 +610,6 @@ unlock:
/* 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;
@@ -698,11 +619,7 @@ static void ene_setup_settings(struct ene_device *dev)
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;
}
@@ -732,144 +649,97 @@ static void ene_close(void *data)
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)
+/* outside interface: set transmitter mask */
+static int ene_set_tx_mask(void *data, u32 tx_mask)
{
- int lvalue = 0, retval, tmp;
+ struct ene_device *dev = (struct ene_device *)data;
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;
+ 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;
}
- 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) */
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ dev->transmitter_mask = tx_mask;
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
+ return 0;
+}
- if (tmp && (tmp > ENE_TX_PERIOD_MAX ||
- tmp < ENE_TX_PERIOD_MIN)) {
+/* 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: out of range %d-%d carrier, "
- "falling back to 32 kHz",
- 1000 / ENE_TX_PERIOD_MIN,
- 1000 / ENE_TX_PERIOD_MAX);
+ ene_dbg("TX: attempt to set tx carrier to %d kHz", carrier);
- tmp = 32; /* this is just a coincidence!!! */
- }
- ene_dbg("TX: set carrier to %d kHz", lvalue);
+ if (period && (period > ENE_TX_PERIOD_MAX ||
+ period < ENE_TX_PERIOD_MIN)) {
- 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);
+ ene_dbg("TX: out of range %d-%d carrier, "
+ "falling back to 32 kHz",
+ 1000 / ENE_TX_PERIOD_MIN,
+ 1000 / ENE_TX_PERIOD_MAX);
- 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;
+ period = 32; /* this is just a coincidence!!! */
}
+ ene_dbg("TX: set carrier to %d kHz", carrier);
- return retval;
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ dev->tx_period = period;
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
+ return 0;
}
-/* outside interface: transmit */
-static ssize_t ene_transmit(struct file *file, const char *buf,
- size_t n, loff_t *ppos)
+
+/* outside interface: enable learning mode */
+static int ene_set_learning_mode(void *data, int enable)
{
- struct ene_device *dev = lirc_get_pdata(file);
+ struct ene_device *dev = (struct ene_device *)data;
unsigned long flags;
+ if (enable == dev->learning_enabled)
+ return 0;
- if (!dev)
- return -EFAULT;
+ 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;
+}
- if (!dev->hw_learning_and_tx_capable)
- return -ENODEV;
+/* 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;
+}
- if (n % sizeof(int))
- return -EINVAL;
+/* 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");
- if (n > ENE_TXBUF_SIZE * sizeof(int))
- return -ENOMEM;
+ ene_hw_write_reg_mask(dev, ENE_CIR_SAMPLE_PERIOD,
+ (enable_idle && idle) ? 0 : ENE_CIR_SAMPLE_OVERFLOW,
+ ENE_CIR_SAMPLE_OVERFLOW);
+}
- if (copy_from_user(dev->tx_buffer, buf, n))
- return -EFAULT;
+/* 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;
@@ -881,7 +751,7 @@ static ssize_t ene_transmit(struct file *file, const char *buf,
spin_lock_irqsave(&dev->hw_lock, flags);
- ene_tx_set_transmiter_mask(dev);
+ ene_tx_hw_set_transmiter_mask(dev);
ene_tx_prepare(dev);
/* Transmit first two samples */
@@ -897,80 +767,35 @@ static ssize_t ene_transmit(struct file *file, const char *buf,
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)
+/* probe entry */
+static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
{
- struct ene_device *dev;
- struct lirc_driver *lirc_driver;
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 (!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;
+ 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 err5;
+ goto error;
if (!pnp_irq_valid(pnp_dev, 0))
- goto err5;
+ goto error;
dev->hw_io = pnp_port_start(pnp_dev, 0);
dev->irq = pnp_irq(pnp_dev, 0);
@@ -979,16 +804,19 @@ static int ene_probe(struct pnp_dev *pnp_dev,
/* claim the resources */
error = -EBUSY;
if (!request_region(dev->hw_io, ENE_MAX_IO, ENE_DRIVER_NAME))
- goto err5;
+ goto error;
if (request_irq(dev->irq, ene_isr,
IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev))
- goto err6;
+ 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 err7;
+ goto error;
ene_setup_settings(dev);
@@ -1000,19 +828,21 @@ static int ene_probe(struct pnp_dev *pnp_dev,
"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;
+ 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 (enable_duty_carrier)
- lirc_driver->features |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
+ if (dev->hw_revision == ENE_HW_B)
+ ir_props->s_idle = ene_rx_set_idle;
- if (input == 0)
- lirc_driver->features |= LIRC_CAN_SET_REC_CARRIER;
- init_completion(&dev->tx_complete);
- }
+ dev->props = ir_props;
+ dev->idev = input_dev;
/* don't allow too short/long sample periods */
if (sample_period < 5 || sample_period > 0x7F)
@@ -1029,29 +859,50 @@ static int ene_probe(struct pnp_dev *pnp_dev,
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 (lirc_register_driver(lirc_driver))
- goto err7;
+ 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;
-
-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:
+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);
-err1:
return error;
}
@@ -1067,9 +918,8 @@ static void ene_remove(struct pnp_dev *pnp_dev)
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);
+ ir_input_unregister(dev->idev);
+ kfree(dev->props);
kfree(dev);
}
@@ -1113,6 +963,7 @@ static const struct pnp_device_id ene_ids[] = {
{.id = "ENE0100",},
{.id = "ENE0200",},
{.id = "ENE0201",},
+ {.id = "ENE0202",},
{},
};
@@ -1160,13 +1011,9 @@ 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 "
+ ("Infrared input driver for KB3926B/KB3926C/KB3926D "
"(aka ENE0100/ENE0200/ENE0201) CIR port");
MODULE_AUTHOR("Maxim Levitsky");