Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

V4L/DVB: IR: Port ene driver to new IR subsystem and enable it

Browse source 
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Maxim Levitsky 2010-07-31 11:59:26 -03:00 committed by Mauro Carvalho Chehab
parent 9ea53b74df
commit 931e39a139
5 changed files with 275 additions and 412 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
MAINTAINERS
View file

@ -2203,6 +2203,12 @@ F: drivers/misc/cb710/
F: drivers/mmc/host/cb710-mmc.*
F: include/linux/cb710.h
ENE KB2426 (ENE0100/ENE020XX) INFRARED RECEIVER
M: Maxim Levitsky <maximlevitsky@gmail.com>
S: Maintained
F: drivers/media/IR/ene_ir.c
F: drivers/media/IR/ene_ir.h
EPSON 1355 FRAMEBUFFER DRIVER
M: Christopher Hoover <ch@murgatroid.com>
M: Christopher Hoover <ch@hpl.hp.com>

14
drivers/media/IR/Kconfig
View file

@ -106,6 +106,20 @@ config IR_MCEUSB
To compile this driver as a module, choose M here: the
module will be called mceusb.
config IR_ENE
tristate "ENE eHome Receiver/Transciever (pnp id: ENE0100/ENE02xxx)"
depends on PNP
depends on IR_CORE
---help---
Say Y here to enable support for integrated infrared receiver
/transciever made by ENE.
You can see if you have it by looking at lspnp output.
Output should include ENE0100 ENE0200 or something similiar.
To compile this driver as a module, choose M here: the
module will be called ene_ir.
config IR_STREAMZAP
tristate "Streamzap PC Remote IR Receiver"
depends on USB_ARCH_HAS_HCD

1
drivers/media/IR/Makefile
View file

@ -16,4 +16,5 @@ obj-$(CONFIG_IR_LIRC_CODEC) += ir-lirc-codec.o
# stand-alone IR receivers/transmitters
obj-$(CONFIG_IR_IMON) += imon.o
obj-$(CONFIG_IR_MCEUSB) += mceusb.o
obj-$(CONFIG_IR_ENE) += ene_ir.o
obj-$(CONFIG_IR_STREAMZAP) += streamzap.o

617
drivers/media/IR/ene_ir.c
View file

@ -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);
ir_raw_event_set_idle(dev->idev, 1);
ir_raw_event_reset(dev->idev);
}
/* 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)
@ -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 @@ static irqreturn_t ene_isr(int irq, void *data)
/* 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);
ene_dbg("TX: attempt to set transmitter mask %02x", tx_mask);
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;
/* 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) */
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;
spin_lock_irqsave(&dev->hw_lock, flags);
dev->transmitter_mask = tx_mask;
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 : set tx carrier */
static int ene_set_tx_carrier(void *data, u32 carrier)
{
struct ene_device *dev = lirc_get_pdata(file);
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;
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_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)
/* probe entry */
static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
{
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;
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;
error:
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->hw_io)
release_region(dev->hw_io, ENE_MAX_IO);
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:
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");

49
drivers/media/IR/ene_ir.h
View file

@ -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 (also known as ENE0XXX)
*
* Copyright (C) 2010 Maxim Levitsky <maximlevitsky@gmail.com>
*
@ -19,8 +19,7 @@
* USA
*/
#include <linux/spinlock.h>
#include <media/lirc.h>
#include <media/lirc_dev.h>
/* hardware address */
#define ENE_STATUS 0 /* hardware status - unused */
@ -88,7 +87,7 @@
#define ENE_CIR_CONF1 0xFEC0
#define ENE_CIR_CONF1_TX_CLEAR 0x01 /* clear that on revC */
/* while transmitting */
#define ENE_CIR_CONF1_RX_ON 0x07 /* normal reciever enabled */
#define ENE_CIR_CONF1_RX_ON 0x07 /* normal receiver enabled */
#define ENE_CIR_CONF1_LEARN1 0x08 /* enabled on learning mode */
#define ENE_CIR_CONF1_TX_ON 0x30 /* enabled on transmit */
#define ENE_CIR_CONF1_TX_CARR 0x80 /* send TX carrier or not */
@ -112,7 +111,7 @@
/* Unknown TX setting - TX sample period ??? */
#define ENE_TX_UNK1 0xFECB /* set to 0x63 */
/* Current recieved carrier period */
/* Current received carrier period */
#define ENE_RX_CARRIER 0xFECC /* RX period (500 ns) */
#define ENE_RX_CARRIER_VALID 0x80 /* Register content valid */
@ -124,6 +123,9 @@
/* Hardware versions */
#define ENE_HW_VERSION 0xFF00 /* hardware revision */
#define ENE_PLLFRH 0xFF16
#define ENE_PLLFRL 0xFF17
#define ENE_HW_UNK 0xFF1D
#define ENE_HW_UNK_CLR 0x04
#define ENE_HW_VER_MAJOR 0xFF1E /* chip version */
@ -162,8 +164,7 @@
/******************************************************************************/
#define ENE_DRIVER_NAME "enecir"
#define ENE_TXBUF_SIZE (500 * sizeof(int)) /* 500 samples (arbitary) */
#define ENE_DRIVER_NAME "ene_ir"
#define ENE_IRQ_RX 1
#define ENE_IRQ_TX 2
@ -188,7 +189,8 @@
struct ene_device {
struct pnp_dev *pnp_dev;
struct lirc_driver *lirc_driver;
struct input_dev *idev;
struct ir_dev_props *props;
int in_use;
/* hw IO settings */
@ -198,43 +200,36 @@ struct ene_device {
/* HW features */
int hw_revision; /* hardware revision */
int hw_learning_and_tx_capable; /* learning capable */
int hw_gpio40_learning; /* gpio40 is learning */
int hw_fan_as_normal_input; /* fan input is used as */
bool hw_learning_and_tx_capable; /* learning capable */
bool hw_gpio40_learning; /* gpio40 is learning */
bool hw_fan_as_normal_input; /* fan input is used as */
/* regular input */
/* HW state*/
int rx_pointer; /* hw pointer to rx buffer */
int rx_fan_input_inuse; /* is fan input in use for rx*/
bool rx_fan_input_inuse; /* is fan input in use for rx*/
int tx_reg; /* current reg used for TX */
u8 saved_conf1; /* saved FEC0 reg */
int learning_enabled; /* learning input enabled */
/* RX sample handling */
int rx_sample; /* current recieved sample */
int rx_sample_pulse; /* recieved sample is pulse */
int rx_idle; /* idle mode for RX activated */
struct timeval rx_gap_start; /* time of start of idle */
int rx_timeout; /* time in ms of RX timeout */
int rx_send_timeout_packet; /* do we send RX timeout */
int rx_timeout_sent; /* we sent the timeout packet */
int rx_carrier_sense; /* sense carrier */
/* TX sample handling */
unsigned int tx_sample; /* current sample for TX */
int tx_sample_pulse; /* current sample is pulse */
bool tx_sample_pulse; /* current sample is pulse */
/* TX buffer */
int tx_buffer[ENE_TXBUF_SIZE]; /* input samples buffer*/
int *tx_buffer; /* input samples buffer*/
int tx_pos; /* position in that bufer */
int tx_len; /* current len of tx buffer */
int tx_underway; /* TX is under way*/
int tx_done; /* done transmitting */
/* one more sample pending*/
struct completion tx_complete; /* TX completion */
struct timer_list tx_sim_timer;
/*TX settings */
/* TX settings */
int tx_period;
int tx_duty_cycle;
int transmitter_mask;
/* RX settings */
bool learning_enabled; /* learning input enabled */
bool carrier_detect_enabled; /* carrier detect enabled */
int rx_period_adjust;
};