Skip to content

Commit

Permalink
Input: tsc2005 - add open/close
Browse files Browse the repository at this point in the history 
Introduce open and close methods for the input device to keep the device
powered down when it is not in use. Also rework interaction between
interrupt thread and starting/shutting off/resetting the device: instead
of taking a mutex in the intterrupt thread and elsewhere disable interrupts
before transitioning the device in a new state.

The ESD handling is also separated from the IRQ thread; we poll regularly
at a given interval and simply skip reads if we see that valid interrupt
happened not so long ago. This allows us not cancel and reschedule ESD
work from interrupt context all the time.

Tested-by: Aaro Koskinen <aaro.koskinen@nokia.com>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
  • Loading branch information
Dmitry Torokhov committed Mar 17, 2011
1 parent 71f8004 commit 0b950d3
Showing 1 changed file with 124 additions and 94 deletions.
218 changes: 124 additions & 94 deletions drivers/input/touchscreen/tsc2005.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -133,13 +133,14 @@ struct tsc2005 {
struct timer_list penup_timer;

unsigned int esd_timeout;
struct timer_list esd_timer;
struct work_struct esd_work;
struct delayed_work esd_work;
unsigned long last_valid_interrupt;

unsigned int x_plate_ohm;

bool disabled;
unsigned int disable_depth;
bool opened;
bool suspended;

bool pen_down;

Expand Down Expand Up @@ -258,11 +259,6 @@ static irqreturn_t tsc2005_irq_thread(int irq, void *_ts)
u32 z1, z2;
int error;

mutex_lock(&ts->mutex);

if (unlikely(ts->disable_depth))
goto out;

/* read the coordinates */
error = spi_sync(ts->spi, &ts->spi_read_msg);
if (unlikely(error))
Expand Down Expand Up @@ -309,21 +305,13 @@ static irqreturn_t tsc2005_irq_thread(int irq, void *_ts)
spin_lock_irqsave(&ts->lock, flags);

tsc2005_update_pen_state(ts, x, y, pressure);

/* set the penup timer */
mod_timer(&ts->penup_timer,
jiffies + msecs_to_jiffies(TSC2005_PENUP_TIME_MS));

if (ts->esd_timeout && ts->set_reset) {
/* update the watchdog timer */
mod_timer(&ts->esd_timer, round_jiffies(jiffies +
msecs_to_jiffies(ts->esd_timeout)));
}

spin_unlock_irqrestore(&ts->lock, flags);

ts->last_valid_interrupt = jiffies;
out:
mutex_unlock(&ts->mutex);
return IRQ_HANDLED;
}

Expand All @@ -350,29 +338,31 @@ static void tsc2005_stop_scan(struct tsc2005 *ts)
tsc2005_cmd(ts, TSC2005_CMD_STOP);
}

/* must be called with mutex held */
static void tsc2005_disable(struct tsc2005 *ts)
/* must be called with ts->mutex held */
static void __tsc2005_disable(struct tsc2005 *ts)
{
if (ts->disable_depth++ != 0)
return;
tsc2005_stop_scan(ts);

disable_irq(ts->spi->irq);
if (ts->esd_timeout)
del_timer_sync(&ts->esd_timer);
del_timer_sync(&ts->penup_timer);
tsc2005_stop_scan(ts);

cancel_delayed_work_sync(&ts->esd_work);

enable_irq(ts->spi->irq);
}

/* must be called with mutex held */
static void tsc2005_enable(struct tsc2005 *ts)
/* must be called with ts->mutex held */
static void __tsc2005_enable(struct tsc2005 *ts)
{
if (--ts->disable_depth != 0)
return;
tsc2005_start_scan(ts);
enable_irq(ts->spi->irq);
if (!ts->esd_timeout)
return;
mod_timer(&ts->esd_timer,
round_jiffies(jiffies + msecs_to_jiffies(ts->esd_timeout)));

if (ts->esd_timeout && ts->set_reset) {
ts->last_valid_interrupt = jiffies;
schedule_delayed_work(&ts->esd_work,
round_jiffies(jiffies +
msecs_to_jiffies(ts->esd_timeout)));
}

}

static ssize_t tsc2005_disable_show(struct device *dev,
Expand All @@ -390,23 +380,29 @@ static ssize_t tsc2005_disable_store(struct device *dev,
{
struct spi_device *spi = to_spi_device(dev);
struct tsc2005 *ts = spi_get_drvdata(spi);
unsigned long res;
int i;
unsigned long val;
int error;

if (strict_strtoul(buf, 10, &res) < 0)
return -EINVAL;
i = res ? 1 : 0;
error = strict_strtoul(buf, 10, &val);
if (error)
return error;

mutex_lock(&ts->mutex);
if (i == ts->disabled)
goto out;
ts->disabled = i;
if (i)
tsc2005_disable(ts);
else
tsc2005_enable(ts);
out:

if (!ts->suspended && ts->opened) {
if (val) {
if (!ts->disabled)
__tsc2005_disable(ts);
} else {
if (ts->disabled)
__tsc2005_enable(ts);
}
}

ts->disabled = !!val;

mutex_unlock(&ts->mutex);

return count;
}
static DEVICE_ATTR(disable, 0664, tsc2005_disable_show, tsc2005_disable_store);
Expand All @@ -428,7 +424,7 @@ static ssize_t tsc2005_selftest_show(struct device *dev,
/*
* Test TSC2005 communications via temp high register.
*/
tsc2005_disable(ts);
__tsc2005_disable(ts);

error = tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high_orig);
if (error) {
Expand Down Expand Up @@ -484,7 +480,7 @@ static ssize_t tsc2005_selftest_show(struct device *dev,
}

out:
tsc2005_enable(ts);
__tsc2005_enable(ts);
mutex_unlock(&ts->mutex);

return sprintf(buf, "%d\n", success);
Expand Down Expand Up @@ -519,44 +515,79 @@ static const struct attribute_group tsc2005_attr_group = {
.attrs = tsc2005_attrs,
};

static void tsc2005_esd_timer(unsigned long data)
{
struct tsc2005 *ts = (struct tsc2005 *)data;

schedule_work(&ts->esd_work);
}

static void tsc2005_esd_work(struct work_struct *work)
{
struct tsc2005 *ts = container_of(work, struct tsc2005, esd_work);
struct tsc2005 *ts = container_of(work, struct tsc2005, esd_work.work);
int error;
u16 r;

mutex_lock(&ts->mutex);

if (ts->disable_depth)
if (time_is_after_jiffies(ts->last_valid_interrupt +
msecs_to_jiffies(ts->esd_timeout)))
goto out;

/*
* If we cannot read our known value from configuration register 0 then
* reset the controller as if from power-up and start scanning again.
*/
/* We should be able to read register without disabling interrupts. */
error = tsc2005_read(ts, TSC2005_REG_CFR0, &r);
if (error ||
((r ^ TSC2005_CFR0_INITVALUE) & TSC2005_CFR0_RW_MASK)) {
dev_info(&ts->spi->dev, "TSC2005 not responding - resetting\n");
ts->set_reset(false);
tsc2005_update_pen_state(ts, 0, 0, 0);
usleep_range(100, 500); /* only 10us required */
ts->set_reset(true);
tsc2005_start_scan(ts);
if (!error &&
!((r ^ TSC2005_CFR0_INITVALUE) & TSC2005_CFR0_RW_MASK)) {
goto out;
}

/* re-arm the watchdog */
mod_timer(&ts->esd_timer,
round_jiffies(jiffies + msecs_to_jiffies(ts->esd_timeout)));
/*
* If we could not read our known value from configuration register 0
* then we should reset the controller as if from power-up and start
* scanning again.
*/
dev_info(&ts->spi->dev, "TSC2005 not responding - resetting\n");

disable_irq(ts->spi->irq);
del_timer_sync(&ts->penup_timer);

tsc2005_update_pen_state(ts, 0, 0, 0);

ts->set_reset(false);
usleep_range(100, 500); /* only 10us required */
ts->set_reset(true);

enable_irq(ts->spi->irq);
tsc2005_start_scan(ts);

out:
/* re-arm the watchdog */
schedule_delayed_work(&ts->esd_work,
round_jiffies(jiffies +
msecs_to_jiffies(ts->esd_timeout)));
mutex_unlock(&ts->mutex);
}

static int tsc2005_open(struct input_dev *input)
{
struct tsc2005 *ts = input_get_drvdata(input);

mutex_lock(&ts->mutex);

if (!ts->suspended && !ts->disabled)
__tsc2005_enable(ts);

ts->opened = true;

mutex_unlock(&ts->mutex);

return 0;
}

static void tsc2005_close(struct input_dev *input)
{
struct tsc2005 *ts = input_get_drvdata(input);

mutex_lock(&ts->mutex);

if (!ts->suspended && !ts->disabled)
__tsc2005_disable(ts);

ts->opened = false;

mutex_unlock(&ts->mutex);
}

Expand Down Expand Up @@ -628,8 +659,7 @@ static int __devinit tsc2005_probe(struct spi_device *spi)
spin_lock_init(&ts->lock);
setup_timer(&ts->penup_timer, tsc2005_penup_timer, (unsigned long)ts);

setup_timer(&ts->esd_timer, tsc2005_esd_timer, (unsigned long)ts);
INIT_WORK(&ts->esd_work, tsc2005_esd_work);
INIT_DELAYED_WORK(&ts->esd_work, tsc2005_esd_work);

tsc2005_setup_spi_xfer(ts);

Expand All @@ -647,6 +677,14 @@ static int __devinit tsc2005_probe(struct spi_device *spi)
input_set_abs_params(input_dev, ABS_Y, 0, max_y, fudge_y, 0);
input_set_abs_params(input_dev, ABS_PRESSURE, 0, max_p, fudge_p, 0);

input_dev->open = tsc2005_open;
input_dev->close = tsc2005_close;

input_set_drvdata(input_dev, ts);

/* Ensure the touchscreen is off */
tsc2005_stop_scan(ts);

error = request_threaded_irq(spi->irq, NULL, tsc2005_irq_thread,
IRQF_TRIGGER_RISING, "tsc2005", ts);
if (error) {
Expand All @@ -669,14 +707,6 @@ static int __devinit tsc2005_probe(struct spi_device *spi)
goto err_remove_sysfs;
}

tsc2005_start_scan(ts);

if (ts->esd_timeout && ts->set_reset) {
/* start the optional ESD watchdog */
mod_timer(&ts->esd_timer, round_jiffies(jiffies +
msecs_to_jiffies(ts->esd_timeout)));
}

set_irq_wake(spi->irq, 1);
return 0;

Expand All @@ -697,16 +727,6 @@ static int __devexit tsc2005_remove(struct spi_device *spi)

sysfs_remove_group(&ts->spi->dev.kobj, &tsc2005_attr_group);

mutex_lock(&ts->mutex);
tsc2005_disable(ts);
mutex_unlock(&ts->mutex);

if (ts->esd_timeout)
del_timer_sync(&ts->esd_timer);
del_timer_sync(&ts->penup_timer);

flush_work(&ts->esd_work);

free_irq(ts->spi->irq, ts);
input_unregister_device(ts->idev);
kfree(ts);
Expand All @@ -722,7 +742,12 @@ static int tsc2005_suspend(struct device *dev)
struct tsc2005 *ts = spi_get_drvdata(spi);

mutex_lock(&ts->mutex);
tsc2005_disable(ts);

if (!ts->suspended && !ts->disabled && ts->opened)
__tsc2005_disable(ts);

ts->suspended = true;

mutex_unlock(&ts->mutex);

return 0;
Expand All @@ -734,7 +759,12 @@ static int tsc2005_resume(struct device *dev)
struct tsc2005 *ts = spi_get_drvdata(spi);

mutex_lock(&ts->mutex);
tsc2005_enable(ts);

if (ts->suspended && !ts->disabled && ts->opened)
__tsc2005_enable(ts);

ts->suspended = false;

mutex_unlock(&ts->mutex);

return 0;
Expand Down

0 comments on commit 0b950d3

Please sign in to comment.