2006-01-08 21:34:21 +00:00
|
|
|
/*
|
|
|
|
* ADS7846 based touchscreen and sensor driver
|
|
|
|
*
|
|
|
|
* Copyright (c) 2005 David Brownell
|
2006-04-12 03:43:55 +00:00
|
|
|
* Copyright (c) 2006 Nokia Corporation
|
|
|
|
* Various changes: Imre Deak <imre.deak@nokia.com>
|
2006-01-08 21:34:21 +00:00
|
|
|
*
|
|
|
|
* Using code from:
|
|
|
|
* - corgi_ts.c
|
|
|
|
* Copyright (C) 2004-2005 Richard Purdie
|
|
|
|
* - omap_ts.[hc], ads7846.h, ts_osk.c
|
|
|
|
* Copyright (C) 2002 MontaVista Software
|
|
|
|
* Copyright (C) 2004 Texas Instruments
|
|
|
|
* Copyright (C) 2005 Dirk Behme
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
2007-01-18 05:45:48 +00:00
|
|
|
#include <linux/hwmon.h>
|
2006-01-08 21:34:21 +00:00
|
|
|
#include <linux/init.h>
|
2007-01-18 05:45:48 +00:00
|
|
|
#include <linux/err.h>
|
2006-01-08 21:34:21 +00:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spi/spi.h>
|
|
|
|
#include <linux/spi/ads7846.h>
|
2006-03-26 09:37:33 +00:00
|
|
|
#include <asm/irq.h>
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_ARM
|
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#ifdef CONFIG_ARCH_OMAP
|
|
|
|
#include <asm/arch/gpio.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2006-05-26 01:44:20 +00:00
|
|
|
* This code has been heavily tested on a Nokia 770, and lightly
|
|
|
|
* tested on other ads7846 devices (OSK/Mistral, Lubbock).
|
2007-05-23 03:28:40 +00:00
|
|
|
* TSC2046 is just newer ads7846 silicon.
|
2007-03-01 04:51:03 +00:00
|
|
|
* Support for ads7843 tested on Atmel at91sam926x-EK.
|
|
|
|
* Support for ads7845 has only been stubbed in.
|
2006-01-08 21:34:21 +00:00
|
|
|
*
|
2006-04-12 03:43:55 +00:00
|
|
|
* IRQ handling needs a workaround because of a shortcoming in handling
|
|
|
|
* edge triggered IRQs on some platforms like the OMAP1/2. These
|
|
|
|
* platforms don't handle the ARM lazy IRQ disabling properly, thus we
|
|
|
|
* have to maintain our own SW IRQ disabled status. This should be
|
|
|
|
* removed as soon as the affected platform's IRQ handling is fixed.
|
|
|
|
*
|
2006-01-08 21:34:21 +00:00
|
|
|
* app note sbaa036 talks in more detail about accurate sampling...
|
|
|
|
* that ought to help in situations like LCDs inducing noise (which
|
|
|
|
* can also be helped by using synch signals) and more generally.
|
2006-04-12 03:43:55 +00:00
|
|
|
* This driver tries to utilize the measures described in the app
|
|
|
|
* note. The strength of filtering can be set in the board-* specific
|
|
|
|
* files.
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
|
|
|
|
2007-01-18 05:45:31 +00:00
|
|
|
#define TS_POLL_DELAY (1 * 1000000) /* ns delay before the first sample */
|
|
|
|
#define TS_POLL_PERIOD (5 * 1000000) /* ns delay between samples */
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-02-15 05:49:35 +00:00
|
|
|
/* this driver doesn't aim at the peak continuous sample rate */
|
|
|
|
#define SAMPLE_BITS (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
struct ts_event {
|
|
|
|
/* For portability, we can't read 12 bit values using SPI (which
|
|
|
|
* would make the controller deliver them as native byteorder u16
|
2006-02-15 05:49:35 +00:00
|
|
|
* with msbs zeroed). Instead, we read them as two 8-bit values,
|
2007-01-18 05:44:41 +00:00
|
|
|
* *** WHICH NEED BYTESWAPPING *** and range adjustment.
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
2007-01-18 05:44:41 +00:00
|
|
|
u16 x;
|
|
|
|
u16 y;
|
|
|
|
u16 z1, z2;
|
2007-01-18 05:45:48 +00:00
|
|
|
int ignore;
|
2006-01-08 21:34:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ads7846 {
|
2006-02-15 05:49:22 +00:00
|
|
|
struct input_dev *input;
|
2006-01-08 21:34:21 +00:00
|
|
|
char phys[32];
|
|
|
|
|
|
|
|
struct spi_device *spi;
|
2007-01-18 05:45:48 +00:00
|
|
|
|
|
|
|
#if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
|
2006-11-03 04:34:09 +00:00
|
|
|
struct attribute_group *attr_group;
|
2007-01-18 05:45:48 +00:00
|
|
|
struct class_device *hwmon;
|
|
|
|
#endif
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
u16 model;
|
|
|
|
u16 vref_delay_usecs;
|
|
|
|
u16 x_plate_ohms;
|
2006-04-26 04:13:18 +00:00
|
|
|
u16 pressure_max;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:41:49 +00:00
|
|
|
u8 read_x, read_y, read_z1, read_z2, pwrdown;
|
|
|
|
u16 dummy; /* for the pwrdown read */
|
2006-01-08 21:34:21 +00:00
|
|
|
struct ts_event tc;
|
|
|
|
|
2006-04-12 03:41:49 +00:00
|
|
|
struct spi_transfer xfer[10];
|
2006-04-12 03:42:03 +00:00
|
|
|
struct spi_message msg[5];
|
2006-04-26 04:13:18 +00:00
|
|
|
struct spi_message *last_msg;
|
2006-04-12 03:42:03 +00:00
|
|
|
int msg_idx;
|
|
|
|
int read_cnt;
|
2006-04-26 04:13:18 +00:00
|
|
|
int read_rep;
|
2006-04-12 03:42:03 +00:00
|
|
|
int last_read;
|
|
|
|
|
|
|
|
u16 debounce_max;
|
|
|
|
u16 debounce_tol;
|
2006-04-26 04:13:18 +00:00
|
|
|
u16 debounce_rep;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
spinlock_t lock;
|
2007-01-18 05:45:31 +00:00
|
|
|
struct hrtimer timer;
|
2006-01-08 21:34:21 +00:00
|
|
|
unsigned pendown:1; /* P: lock */
|
|
|
|
unsigned pending:1; /* P: lock */
|
|
|
|
// FIXME remove "irq_disabled"
|
|
|
|
unsigned irq_disabled:1; /* P: lock */
|
2006-04-12 03:43:55 +00:00
|
|
|
unsigned disabled:1;
|
2006-04-12 03:44:05 +00:00
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
int (*filter)(void *data, int data_idx, int *val);
|
|
|
|
void *filter_data;
|
|
|
|
void (*filter_cleanup)(void *data);
|
2006-04-12 03:44:05 +00:00
|
|
|
int (*get_pendown_state)(void);
|
2006-01-08 21:34:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* leave chip selected when we're done, for quicker re-select? */
|
|
|
|
#if 0
|
|
|
|
#define CS_CHANGE(xfer) ((xfer).cs_change = 1)
|
|
|
|
#else
|
|
|
|
#define CS_CHANGE(xfer) ((xfer).cs_change = 0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* The ADS7846 has touchscreen and other sensors.
|
|
|
|
* Earlier ads784x chips are somewhat compatible.
|
|
|
|
*/
|
|
|
|
#define ADS_START (1 << 7)
|
|
|
|
#define ADS_A2A1A0_d_y (1 << 4) /* differential */
|
|
|
|
#define ADS_A2A1A0_d_z1 (3 << 4) /* differential */
|
|
|
|
#define ADS_A2A1A0_d_z2 (4 << 4) /* differential */
|
|
|
|
#define ADS_A2A1A0_d_x (5 << 4) /* differential */
|
|
|
|
#define ADS_A2A1A0_temp0 (0 << 4) /* non-differential */
|
|
|
|
#define ADS_A2A1A0_vbatt (2 << 4) /* non-differential */
|
|
|
|
#define ADS_A2A1A0_vaux (6 << 4) /* non-differential */
|
|
|
|
#define ADS_A2A1A0_temp1 (7 << 4) /* non-differential */
|
|
|
|
#define ADS_8_BIT (1 << 3)
|
|
|
|
#define ADS_12_BIT (0 << 3)
|
|
|
|
#define ADS_SER (1 << 2) /* non-differential */
|
|
|
|
#define ADS_DFR (0 << 2) /* differential */
|
|
|
|
#define ADS_PD10_PDOWN (0 << 0) /* lowpower mode + penirq */
|
|
|
|
#define ADS_PD10_ADC_ON (1 << 0) /* ADC on */
|
|
|
|
#define ADS_PD10_REF_ON (2 << 0) /* vREF on + penirq */
|
|
|
|
#define ADS_PD10_ALL_ON (3 << 0) /* ADC + vREF on */
|
|
|
|
|
|
|
|
#define MAX_12BIT ((1<<12)-1)
|
|
|
|
|
|
|
|
/* leave ADC powered up (disables penirq) between differential samples */
|
2007-01-18 05:45:21 +00:00
|
|
|
#define READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \
|
|
|
|
| ADS_12_BIT | ADS_DFR | \
|
|
|
|
(adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0))
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:45:21 +00:00
|
|
|
#define READ_Y(vref) (READ_12BIT_DFR(y, 1, vref))
|
|
|
|
#define READ_Z1(vref) (READ_12BIT_DFR(z1, 1, vref))
|
|
|
|
#define READ_Z2(vref) (READ_12BIT_DFR(z2, 1, vref))
|
2006-04-12 03:41:49 +00:00
|
|
|
|
2007-01-18 05:45:21 +00:00
|
|
|
#define READ_X(vref) (READ_12BIT_DFR(x, 1, vref))
|
|
|
|
#define PWRDOWN (READ_12BIT_DFR(y, 0, 0)) /* LAST */
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
/* single-ended samples need to first power up reference voltage;
|
|
|
|
* we leave both ADC and VREF powered
|
|
|
|
*/
|
|
|
|
#define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
|
|
|
|
| ADS_12_BIT | ADS_SER)
|
|
|
|
|
2007-01-18 05:45:21 +00:00
|
|
|
#define REF_ON (READ_12BIT_DFR(x, 1, 1))
|
|
|
|
#define REF_OFF (READ_12BIT_DFR(y, 0, 0))
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Non-touchscreen sensors only use single-ended conversions.
|
2007-01-18 05:45:48 +00:00
|
|
|
* The range is GND..vREF. The ads7843 and ads7835 must use external vREF;
|
|
|
|
* ads7846 lets that pin be unconnected, to use internal vREF.
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
2007-01-18 05:45:48 +00:00
|
|
|
static unsigned vREF_mV;
|
|
|
|
module_param(vREF_mV, uint, 0);
|
|
|
|
MODULE_PARM_DESC(vREF_mV, "external vREF voltage, in milliVolts");
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
struct ser_req {
|
2006-02-15 05:49:35 +00:00
|
|
|
u8 ref_on;
|
2006-01-08 21:34:21 +00:00
|
|
|
u8 command;
|
2006-02-15 05:49:35 +00:00
|
|
|
u8 ref_off;
|
2006-01-08 21:34:21 +00:00
|
|
|
u16 scratch;
|
|
|
|
__be16 sample;
|
|
|
|
struct spi_message msg;
|
|
|
|
struct spi_transfer xfer[6];
|
|
|
|
};
|
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
static void ads7846_enable(struct ads7846 *ts);
|
|
|
|
static void ads7846_disable(struct ads7846 *ts);
|
|
|
|
|
2006-04-12 03:44:05 +00:00
|
|
|
static int device_suspended(struct device *dev)
|
|
|
|
{
|
|
|
|
struct ads7846 *ts = dev_get_drvdata(dev);
|
|
|
|
return dev->power.power_state.event != PM_EVENT_ON || ts->disabled;
|
|
|
|
}
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
static int ads7846_read12_ser(struct device *dev, unsigned command)
|
|
|
|
{
|
|
|
|
struct spi_device *spi = to_spi_device(dev);
|
|
|
|
struct ads7846 *ts = dev_get_drvdata(dev);
|
2006-12-07 04:33:17 +00:00
|
|
|
struct ser_req *req = kzalloc(sizeof *req, GFP_KERNEL);
|
2006-01-08 21:34:21 +00:00
|
|
|
int status;
|
|
|
|
int sample;
|
2007-01-18 05:45:48 +00:00
|
|
|
int use_internal;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
if (!req)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_init(&req->msg);
|
2006-01-08 21:34:28 +00:00
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
/* FIXME boards with ads7846 might use external vref instead ... */
|
|
|
|
use_internal = (ts->model == 7846);
|
|
|
|
|
|
|
|
/* maybe turn on internal vREF, and let it settle */
|
|
|
|
if (use_internal) {
|
|
|
|
req->ref_on = REF_ON;
|
|
|
|
req->xfer[0].tx_buf = &req->ref_on;
|
|
|
|
req->xfer[0].len = 1;
|
|
|
|
spi_message_add_tail(&req->xfer[0], &req->msg);
|
|
|
|
|
|
|
|
req->xfer[1].rx_buf = &req->scratch;
|
|
|
|
req->xfer[1].len = 2;
|
|
|
|
|
|
|
|
/* for 1uF, settle for 800 usec; no cap, 100 usec. */
|
|
|
|
req->xfer[1].delay_usecs = ts->vref_delay_usecs;
|
|
|
|
spi_message_add_tail(&req->xfer[1], &req->msg);
|
|
|
|
}
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
/* take sample */
|
|
|
|
req->command = (u8) command;
|
|
|
|
req->xfer[2].tx_buf = &req->command;
|
|
|
|
req->xfer[2].len = 1;
|
2007-01-18 05:45:48 +00:00
|
|
|
spi_message_add_tail(&req->xfer[2], &req->msg);
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
req->xfer[3].rx_buf = &req->sample;
|
|
|
|
req->xfer[3].len = 2;
|
2007-01-18 05:45:48 +00:00
|
|
|
spi_message_add_tail(&req->xfer[3], &req->msg);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
/* REVISIT: take a few more samples, and compare ... */
|
|
|
|
|
2007-03-01 04:51:03 +00:00
|
|
|
/* converter in low power mode & enable PENIRQ */
|
|
|
|
req->ref_off = PWRDOWN;
|
|
|
|
req->xfer[4].tx_buf = &req->ref_off;
|
|
|
|
req->xfer[4].len = 1;
|
|
|
|
spi_message_add_tail(&req->xfer[4], &req->msg);
|
|
|
|
|
|
|
|
req->xfer[5].rx_buf = &req->scratch;
|
|
|
|
req->xfer[5].len = 2;
|
|
|
|
CS_CHANGE(req->xfer[5]);
|
|
|
|
spi_message_add_tail(&req->xfer[5], &req->msg);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:44:05 +00:00
|
|
|
ts->irq_disabled = 1;
|
2006-01-08 21:34:21 +00:00
|
|
|
disable_irq(spi->irq);
|
|
|
|
status = spi_sync(spi, &req->msg);
|
2006-04-12 03:44:05 +00:00
|
|
|
ts->irq_disabled = 0;
|
2006-01-08 21:34:21 +00:00
|
|
|
enable_irq(spi->irq);
|
|
|
|
|
|
|
|
if (req->msg.status)
|
|
|
|
status = req->msg.status;
|
2006-05-26 01:44:20 +00:00
|
|
|
|
|
|
|
/* on-wire is a must-ignore bit, a BE12 value, then padding */
|
2006-01-08 21:34:21 +00:00
|
|
|
sample = be16_to_cpu(req->sample);
|
2006-05-26 01:44:20 +00:00
|
|
|
sample = sample >> 3;
|
|
|
|
sample &= 0x0fff;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-05-26 01:44:20 +00:00
|
|
|
kfree(req);
|
2006-01-08 21:34:21 +00:00
|
|
|
return status ? status : sample;
|
|
|
|
}
|
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
#if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
|
|
|
|
|
|
|
|
#define SHOW(name, var, adjust) static ssize_t \
|
2006-01-08 21:34:21 +00:00
|
|
|
name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
|
|
|
|
{ \
|
2007-01-18 05:45:48 +00:00
|
|
|
struct ads7846 *ts = dev_get_drvdata(dev); \
|
2006-01-08 21:34:21 +00:00
|
|
|
ssize_t v = ads7846_read12_ser(dev, \
|
2007-01-18 05:45:48 +00:00
|
|
|
READ_12BIT_SER(var) | ADS_PD10_ALL_ON); \
|
2006-01-08 21:34:21 +00:00
|
|
|
if (v < 0) \
|
|
|
|
return v; \
|
2007-01-18 05:45:48 +00:00
|
|
|
return sprintf(buf, "%u\n", adjust(ts, v)); \
|
2006-01-08 21:34:21 +00:00
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
|
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
|
|
|
|
/* Sysfs conventions report temperatures in millidegrees Celcius.
|
|
|
|
* ADS7846 could use the low-accuracy two-sample scheme, but can't do the high
|
|
|
|
* accuracy scheme without calibration data. For now we won't try either;
|
|
|
|
* userspace sees raw sensor values, and must scale/calibrate appropriately.
|
|
|
|
*/
|
|
|
|
static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v)
|
|
|
|
{
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
SHOW(temp0, temp0, null_adjust) /* temp1_input */
|
|
|
|
SHOW(temp1, temp1, null_adjust) /* temp2_input */
|
|
|
|
|
|
|
|
|
|
|
|
/* sysfs conventions report voltages in millivolts. We can convert voltages
|
|
|
|
* if we know vREF. userspace may need to scale vAUX to match the board's
|
|
|
|
* external resistors; we assume that vBATT only uses the internal ones.
|
|
|
|
*/
|
|
|
|
static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v)
|
|
|
|
{
|
|
|
|
unsigned retval = v;
|
|
|
|
|
|
|
|
/* external resistors may scale vAUX into 0..vREF */
|
|
|
|
retval *= vREF_mV;
|
|
|
|
retval = retval >> 12;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v)
|
|
|
|
{
|
|
|
|
unsigned retval = vaux_adjust(ts, v);
|
|
|
|
|
|
|
|
/* ads7846 has a resistor ladder to scale this signal down */
|
|
|
|
if (ts->model == 7846)
|
|
|
|
retval *= 4;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
SHOW(in0_input, vaux, vaux_adjust)
|
|
|
|
SHOW(in1_input, vbatt, vbatt_adjust)
|
|
|
|
|
|
|
|
|
|
|
|
static struct attribute *ads7846_attributes[] = {
|
|
|
|
&dev_attr_temp0.attr,
|
|
|
|
&dev_attr_temp1.attr,
|
|
|
|
&dev_attr_in0_input.attr,
|
|
|
|
&dev_attr_in1_input.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group ads7846_attr_group = {
|
|
|
|
.attrs = ads7846_attributes,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute *ads7843_attributes[] = {
|
|
|
|
&dev_attr_in0_input.attr,
|
|
|
|
&dev_attr_in1_input.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group ads7843_attr_group = {
|
|
|
|
.attrs = ads7843_attributes,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute *ads7845_attributes[] = {
|
|
|
|
&dev_attr_in0_input.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group ads7845_attr_group = {
|
|
|
|
.attrs = ads7845_attributes,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts)
|
|
|
|
{
|
|
|
|
struct class_device *hwmon;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* hwmon sensors need a reference voltage */
|
|
|
|
switch (ts->model) {
|
|
|
|
case 7846:
|
|
|
|
if (!vREF_mV) {
|
|
|
|
dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
|
|
|
|
vREF_mV = 2500;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 7845:
|
|
|
|
case 7843:
|
|
|
|
if (!vREF_mV) {
|
|
|
|
dev_warn(&spi->dev,
|
|
|
|
"external vREF for ADS%d not specified\n",
|
|
|
|
ts->model);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* different chips have different sensor groups */
|
|
|
|
switch (ts->model) {
|
|
|
|
case 7846:
|
|
|
|
ts->attr_group = &ads7846_attr_group;
|
|
|
|
break;
|
|
|
|
case 7845:
|
|
|
|
ts->attr_group = &ads7845_attr_group;
|
|
|
|
break;
|
|
|
|
case 7843:
|
|
|
|
ts->attr_group = &ads7843_attr_group;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_dbg(&spi->dev, "ADS%d not recognized\n", ts->model);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = sysfs_create_group(&spi->dev.kobj, ts->attr_group);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
hwmon = hwmon_device_register(&spi->dev);
|
|
|
|
if (IS_ERR(hwmon)) {
|
|
|
|
sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
|
|
|
|
return PTR_ERR(hwmon);
|
|
|
|
}
|
|
|
|
|
|
|
|
ts->hwmon = hwmon;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ads784x_hwmon_unregister(struct spi_device *spi,
|
|
|
|
struct ads7846 *ts)
|
|
|
|
{
|
|
|
|
if (ts->hwmon) {
|
|
|
|
sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
|
|
|
|
hwmon_device_unregister(ts->hwmon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline int ads784x_hwmon_register(struct spi_device *spi,
|
|
|
|
struct ads7846 *ts)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ads784x_hwmon_unregister(struct spi_device *spi,
|
|
|
|
struct ads7846 *ts)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:41:32 +00:00
|
|
|
static int is_pen_down(struct device *dev)
|
|
|
|
{
|
2007-01-18 05:45:48 +00:00
|
|
|
struct ads7846 *ts = dev_get_drvdata(dev);
|
2006-04-12 03:41:32 +00:00
|
|
|
|
|
|
|
return ts->pendown;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t ads7846_pen_down_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%u\n", is_pen_down(dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
|
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
static ssize_t ads7846_disable_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct ads7846 *ts = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%u\n", ts->disabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t ads7846_disable_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct ads7846 *ts = dev_get_drvdata(dev);
|
|
|
|
char *endp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
i = simple_strtoul(buf, &endp, 10);
|
|
|
|
spin_lock_irq(&ts->lock);
|
|
|
|
|
|
|
|
if (i)
|
|
|
|
ads7846_disable(ts);
|
|
|
|
else
|
|
|
|
ads7846_enable(ts);
|
|
|
|
|
|
|
|
spin_unlock_irq(&ts->lock);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);
|
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
static struct attribute *ads784x_attributes[] = {
|
2006-11-03 04:34:09 +00:00
|
|
|
&dev_attr_pen_down.attr,
|
|
|
|
&dev_attr_disable.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
static struct attribute_group ads784x_attr_group = {
|
|
|
|
.attrs = ads784x_attributes,
|
2006-11-03 04:34:09 +00:00
|
|
|
};
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PENIRQ only kicks the timer. The timer only reissues the SPI transfer,
|
|
|
|
* to retrieve touchscreen status.
|
|
|
|
*
|
|
|
|
* The SPI transfer completion callback does the real work. It reports
|
|
|
|
* touchscreen events and reactivates the timer (or IRQ) as appropriate.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void ads7846_rx(void *ads)
|
|
|
|
{
|
2006-02-15 05:49:22 +00:00
|
|
|
struct ads7846 *ts = ads;
|
|
|
|
unsigned Rt;
|
|
|
|
u16 x, y, z1, z2;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
/* ads7846_rx_val() did in-place conversion (including byteswap) from
|
|
|
|
* on-the-wire format as part of debouncing to get stable readings.
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
2007-01-18 05:44:41 +00:00
|
|
|
x = ts->tc.x;
|
|
|
|
y = ts->tc.y;
|
|
|
|
z1 = ts->tc.z1;
|
|
|
|
z2 = ts->tc.z2;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
/* range filtering */
|
|
|
|
if (x == MAX_12BIT)
|
|
|
|
x = 0;
|
|
|
|
|
2007-01-18 05:45:43 +00:00
|
|
|
if (likely(x && z1)) {
|
2006-01-08 21:34:21 +00:00
|
|
|
/* compute touch pressure resistance using equation #2 */
|
|
|
|
Rt = z2;
|
|
|
|
Rt -= z1;
|
|
|
|
Rt *= x;
|
|
|
|
Rt *= ts->x_plate_ohms;
|
|
|
|
Rt /= z1;
|
|
|
|
Rt = (Rt + 2047) >> 12;
|
|
|
|
} else
|
|
|
|
Rt = 0;
|
|
|
|
|
2007-03-01 04:51:03 +00:00
|
|
|
if (ts->model == 7843)
|
|
|
|
Rt = ts->pressure_max / 2;
|
|
|
|
|
2006-04-26 04:13:18 +00:00
|
|
|
/* Sample found inconsistent by debouncing or pressure is beyond
|
2007-01-18 05:45:31 +00:00
|
|
|
* the maximum. Don't report it to user space, repeat at least
|
|
|
|
* once more the measurement
|
|
|
|
*/
|
2006-04-26 04:13:18 +00:00
|
|
|
if (ts->tc.ignore || Rt > ts->pressure_max) {
|
2007-01-18 05:45:43 +00:00
|
|
|
#ifdef VERBOSE
|
|
|
|
pr_debug("%s: ignored %d pressure %d\n",
|
|
|
|
ts->spi->dev.bus_id, ts->tc.ignore, Rt);
|
|
|
|
#endif
|
2007-01-18 05:45:31 +00:00
|
|
|
hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
|
2007-02-16 09:27:49 +00:00
|
|
|
HRTIMER_MODE_REL);
|
2006-04-26 04:13:18 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-01-18 05:45:43 +00:00
|
|
|
/* NOTE: We can't rely on the pressure to determine the pen down
|
|
|
|
* state, even this controller has a pressure sensor. The pressure
|
|
|
|
* value can fluctuate for quite a while after lifting the pen and
|
|
|
|
* in some cases may not even settle at the expected value.
|
2006-01-08 21:34:21 +00:00
|
|
|
*
|
2007-01-18 05:45:43 +00:00
|
|
|
* The only safe way to check for the pen up condition is in the
|
|
|
|
* timer by reading the pen signal state (it's a GPIO _and_ IRQ).
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
|
|
|
if (Rt) {
|
2007-01-18 05:45:43 +00:00
|
|
|
struct input_dev *input = ts->input;
|
2006-04-26 04:12:14 +00:00
|
|
|
|
2007-01-18 05:45:43 +00:00
|
|
|
if (!ts->pendown) {
|
|
|
|
input_report_key(input, BTN_TOUCH, 1);
|
|
|
|
ts->pendown = 1;
|
|
|
|
#ifdef VERBOSE
|
|
|
|
dev_dbg(&ts->spi->dev, "DOWN\n");
|
2006-01-08 21:34:21 +00:00
|
|
|
#endif
|
2007-01-18 05:45:43 +00:00
|
|
|
}
|
|
|
|
input_report_abs(input, ABS_X, x);
|
|
|
|
input_report_abs(input, ABS_Y, y);
|
|
|
|
input_report_abs(input, ABS_PRESSURE, Rt);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:45:43 +00:00
|
|
|
input_sync(input);
|
|
|
|
#ifdef VERBOSE
|
|
|
|
dev_dbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
|
|
|
|
#endif
|
|
|
|
}
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-02-16 09:27:49 +00:00
|
|
|
hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
|
|
|
|
HRTIMER_MODE_REL);
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
static int ads7846_debounce(void *ads, int data_idx, int *val)
|
2006-04-12 03:42:03 +00:00
|
|
|
{
|
|
|
|
struct ads7846 *ts = ads;
|
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
|
|
|
|
/* Start over collecting consistent readings. */
|
|
|
|
ts->read_rep = 0;
|
2006-04-26 04:13:18 +00:00
|
|
|
/* Repeat it, if this was the first read or the read
|
|
|
|
* wasn't consistent enough. */
|
|
|
|
if (ts->read_cnt < ts->debounce_max) {
|
2007-01-18 05:44:41 +00:00
|
|
|
ts->last_read = *val;
|
2006-04-26 04:13:18 +00:00
|
|
|
ts->read_cnt++;
|
2007-01-18 05:44:41 +00:00
|
|
|
return ADS7846_FILTER_REPEAT;
|
2006-04-26 04:13:18 +00:00
|
|
|
} else {
|
|
|
|
/* Maximum number of debouncing reached and still
|
|
|
|
* not enough number of consistent readings. Abort
|
|
|
|
* the whole sample, repeat it in the next sampling
|
|
|
|
* period.
|
|
|
|
*/
|
|
|
|
ts->read_cnt = 0;
|
2007-01-18 05:44:41 +00:00
|
|
|
return ADS7846_FILTER_IGNORE;
|
2006-04-26 04:13:18 +00:00
|
|
|
}
|
2006-04-12 03:42:03 +00:00
|
|
|
} else {
|
2006-04-26 04:13:18 +00:00
|
|
|
if (++ts->read_rep > ts->debounce_rep) {
|
|
|
|
/* Got a good reading for this coordinate,
|
|
|
|
* go for the next one. */
|
|
|
|
ts->read_cnt = 0;
|
|
|
|
ts->read_rep = 0;
|
2007-01-18 05:44:41 +00:00
|
|
|
return ADS7846_FILTER_OK;
|
|
|
|
} else {
|
2006-04-26 04:13:18 +00:00
|
|
|
/* Read more values that are consistent. */
|
|
|
|
ts->read_cnt++;
|
2007-01-18 05:44:41 +00:00
|
|
|
return ADS7846_FILTER_REPEAT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ads7846_no_filter(void *ads, int data_idx, int *val)
|
|
|
|
{
|
|
|
|
return ADS7846_FILTER_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ads7846_rx_val(void *ads)
|
|
|
|
{
|
|
|
|
struct ads7846 *ts = ads;
|
|
|
|
struct spi_message *m;
|
|
|
|
struct spi_transfer *t;
|
|
|
|
u16 *rx_val;
|
|
|
|
int val;
|
|
|
|
int action;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
m = &ts->msg[ts->msg_idx];
|
|
|
|
t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
|
|
|
|
rx_val = t->rx_buf;
|
|
|
|
|
|
|
|
/* adjust: on-wire is a must-ignore bit, a BE12 value, then padding;
|
|
|
|
* built from two 8 bit values written msb-first.
|
|
|
|
*/
|
|
|
|
val = be16_to_cpu(*rx_val) >> 3;
|
|
|
|
|
|
|
|
action = ts->filter(ts->filter_data, ts->msg_idx, &val);
|
|
|
|
switch (action) {
|
|
|
|
case ADS7846_FILTER_REPEAT:
|
|
|
|
break;
|
|
|
|
case ADS7846_FILTER_IGNORE:
|
|
|
|
ts->tc.ignore = 1;
|
|
|
|
/* Last message will contain ads7846_rx() as the
|
|
|
|
* completion function.
|
|
|
|
*/
|
|
|
|
m = ts->last_msg;
|
|
|
|
break;
|
|
|
|
case ADS7846_FILTER_OK:
|
|
|
|
*rx_val = val;
|
|
|
|
ts->tc.ignore = 0;
|
|
|
|
m = &ts->msg[++ts->msg_idx];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
2006-04-12 03:42:03 +00:00
|
|
|
}
|
|
|
|
status = spi_async(ts->spi, m);
|
|
|
|
if (status)
|
|
|
|
dev_err(&ts->spi->dev, "spi_async --> %d\n",
|
|
|
|
status);
|
|
|
|
}
|
|
|
|
|
2007-02-16 09:27:49 +00:00
|
|
|
static enum hrtimer_restart ads7846_timer(struct hrtimer *handle)
|
2006-01-08 21:34:21 +00:00
|
|
|
{
|
2007-01-18 05:45:31 +00:00
|
|
|
struct ads7846 *ts = container_of(handle, struct ads7846, timer);
|
2006-01-08 21:34:21 +00:00
|
|
|
int status = 0;
|
2006-04-12 03:42:03 +00:00
|
|
|
|
2006-04-12 03:44:05 +00:00
|
|
|
spin_lock_irq(&ts->lock);
|
|
|
|
|
2007-01-18 05:45:43 +00:00
|
|
|
if (unlikely(!ts->get_pendown_state() ||
|
|
|
|
device_suspended(&ts->spi->dev))) {
|
|
|
|
if (ts->pendown) {
|
|
|
|
struct input_dev *input = ts->input;
|
|
|
|
|
|
|
|
input_report_key(input, BTN_TOUCH, 0);
|
|
|
|
input_report_abs(input, ABS_PRESSURE, 0);
|
|
|
|
input_sync(input);
|
|
|
|
|
|
|
|
ts->pendown = 0;
|
|
|
|
#ifdef VERBOSE
|
|
|
|
dev_dbg(&ts->spi->dev, "UP\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-05-26 01:44:20 +00:00
|
|
|
/* measurement cycle ended */
|
2006-04-12 03:44:05 +00:00
|
|
|
if (!device_suspended(&ts->spi->dev)) {
|
|
|
|
ts->irq_disabled = 0;
|
|
|
|
enable_irq(ts->spi->irq);
|
|
|
|
}
|
|
|
|
ts->pending = 0;
|
|
|
|
} else {
|
|
|
|
/* pen is still down, continue with the measurement */
|
|
|
|
ts->msg_idx = 0;
|
|
|
|
status = spi_async(ts->spi, &ts->msg[0]);
|
|
|
|
if (status)
|
|
|
|
dev_err(&ts->spi->dev, "spi_async --> %d\n", status);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irq(&ts->lock);
|
2007-01-18 05:45:31 +00:00
|
|
|
return HRTIMER_NORESTART;
|
2006-04-12 03:42:03 +00:00
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t ads7846_irq(int irq, void *handle)
|
2006-04-12 03:42:03 +00:00
|
|
|
{
|
|
|
|
struct ads7846 *ts = handle;
|
|
|
|
unsigned long flags;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&ts->lock, flags);
|
2006-04-12 03:44:05 +00:00
|
|
|
if (likely(ts->get_pendown_state())) {
|
2006-01-08 21:34:21 +00:00
|
|
|
if (!ts->irq_disabled) {
|
2006-05-26 01:44:20 +00:00
|
|
|
/* The ARM do_simple_IRQ() dispatcher doesn't act
|
|
|
|
* like the other dispatchers: it will report IRQs
|
|
|
|
* even after they've been disabled. We work around
|
|
|
|
* that here. (The "generic irq" framework may help...)
|
2006-04-12 03:42:03 +00:00
|
|
|
*/
|
2006-01-08 21:34:21 +00:00
|
|
|
ts->irq_disabled = 1;
|
|
|
|
disable_irq(ts->spi->irq);
|
2006-04-12 03:42:03 +00:00
|
|
|
ts->pending = 1;
|
2007-01-18 05:45:31 +00:00
|
|
|
hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_DELAY),
|
2007-02-16 09:27:49 +00:00
|
|
|
HRTIMER_MODE_REL);
|
2006-04-12 03:42:03 +00:00
|
|
|
}
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ts->lock, flags);
|
2006-04-12 03:43:55 +00:00
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
/* Must be called with ts->lock held */
|
|
|
|
static void ads7846_disable(struct ads7846 *ts)
|
2006-01-08 21:34:21 +00:00
|
|
|
{
|
2006-04-12 03:43:55 +00:00
|
|
|
if (ts->disabled)
|
|
|
|
return;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:44:05 +00:00
|
|
|
ts->disabled = 1;
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
/* are we waiting for IRQ, or polling? */
|
2006-04-12 03:44:05 +00:00
|
|
|
if (!ts->pending) {
|
|
|
|
ts->irq_disabled = 1;
|
|
|
|
disable_irq(ts->spi->irq);
|
2006-01-08 21:34:21 +00:00
|
|
|
} else {
|
2006-04-12 03:44:05 +00:00
|
|
|
/* the timer will run at least once more, and
|
|
|
|
* leave everything in a clean state, IRQ disabled
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
2006-04-12 03:44:05 +00:00
|
|
|
while (ts->pending) {
|
2006-04-12 03:43:55 +00:00
|
|
|
spin_unlock_irq(&ts->lock);
|
2006-04-12 03:42:25 +00:00
|
|
|
msleep(1);
|
2006-04-12 03:43:55 +00:00
|
|
|
spin_lock_irq(&ts->lock);
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we know the chip's in lowpower mode since we always
|
|
|
|
* leave it that way after every request
|
|
|
|
*/
|
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Must be called with ts->lock held */
|
|
|
|
static void ads7846_enable(struct ads7846 *ts)
|
|
|
|
{
|
|
|
|
if (!ts->disabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ts->disabled = 0;
|
|
|
|
ts->irq_disabled = 0;
|
|
|
|
enable_irq(ts->spi->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
|
|
|
|
{
|
|
|
|
struct ads7846 *ts = dev_get_drvdata(&spi->dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&ts->lock);
|
|
|
|
|
|
|
|
spi->dev.power.power_state = message;
|
|
|
|
ads7846_disable(ts);
|
|
|
|
|
|
|
|
spin_unlock_irq(&ts->lock);
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
return 0;
|
2006-04-12 03:43:55 +00:00
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
static int ads7846_resume(struct spi_device *spi)
|
2006-01-08 21:34:21 +00:00
|
|
|
{
|
2006-01-08 21:34:25 +00:00
|
|
|
struct ads7846 *ts = dev_get_drvdata(&spi->dev);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
spin_lock_irq(&ts->lock);
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
spi->dev.power.power_state = PMSG_ON;
|
2006-04-12 03:43:55 +00:00
|
|
|
ads7846_enable(ts);
|
|
|
|
|
|
|
|
spin_unlock_irq(&ts->lock);
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
static int __devinit ads7846_probe(struct spi_device *spi)
|
2006-01-08 21:34:21 +00:00
|
|
|
{
|
|
|
|
struct ads7846 *ts;
|
2006-02-15 05:49:22 +00:00
|
|
|
struct input_dev *input_dev;
|
2006-01-08 21:34:25 +00:00
|
|
|
struct ads7846_platform_data *pdata = spi->dev.platform_data;
|
2006-04-12 03:42:03 +00:00
|
|
|
struct spi_message *m;
|
2006-01-08 21:34:21 +00:00
|
|
|
struct spi_transfer *x;
|
2007-01-18 05:45:21 +00:00
|
|
|
int vref;
|
2006-02-15 05:49:22 +00:00
|
|
|
int err;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
if (!spi->irq) {
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_dbg(&spi->dev, "no IRQ?\n");
|
2006-01-08 21:34:21 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pdata) {
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_dbg(&spi->dev, "no platform data?\n");
|
2006-01-08 21:34:21 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* don't exceed max specified sample rate */
|
2006-02-15 05:49:35 +00:00
|
|
|
if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
|
2006-02-15 05:49:35 +00:00
|
|
|
(spi->max_speed_hz/SAMPLE_BITS)/1000);
|
2006-01-08 21:34:21 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-05-26 01:44:20 +00:00
|
|
|
/* REVISIT when the irq can be triggered active-low, or if for some
|
|
|
|
* reason the touchscreen isn't hooked up, we don't need to access
|
|
|
|
* the pendown state.
|
|
|
|
*/
|
2006-04-12 03:44:05 +00:00
|
|
|
if (pdata->get_pendown_state == NULL) {
|
|
|
|
dev_dbg(&spi->dev, "no get_pendown_state function?\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-05-26 01:44:20 +00:00
|
|
|
/* We'd set TX wordsize 8 bits and RX wordsize to 13 bits ... except
|
|
|
|
* that even if the hardware can do that, the SPI controller driver
|
|
|
|
* may not. So we stick to very-portable 8 bit words, both RX and TX.
|
2006-01-08 21:34:21 +00:00
|
|
|
*/
|
2006-05-26 01:44:20 +00:00
|
|
|
spi->bits_per_word = 8;
|
2007-01-18 05:45:38 +00:00
|
|
|
spi->mode = SPI_MODE_1;
|
|
|
|
err = spi_setup(spi);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-02-15 05:49:22 +00:00
|
|
|
ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
|
|
|
|
input_dev = input_allocate_device();
|
|
|
|
if (!ts || !input_dev) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_free_mem;
|
|
|
|
}
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_set_drvdata(&spi->dev, ts);
|
2006-02-15 05:49:22 +00:00
|
|
|
spi->dev.power.power_state = PMSG_ON;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
ts->spi = spi;
|
2006-02-15 05:49:22 +00:00
|
|
|
ts->input = input_dev;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-02-16 09:27:49 +00:00
|
|
|
hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
2006-01-08 21:34:21 +00:00
|
|
|
ts->timer.function = ads7846_timer;
|
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
spin_lock_init(&ts->lock);
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
ts->model = pdata->model ? : 7846;
|
|
|
|
ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
|
|
|
|
ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
|
2006-04-26 04:13:18 +00:00
|
|
|
ts->pressure_max = pdata->pressure_max ? : ~0;
|
2007-01-18 05:44:41 +00:00
|
|
|
|
|
|
|
if (pdata->filter != NULL) {
|
|
|
|
if (pdata->filter_init != NULL) {
|
|
|
|
err = pdata->filter_init(pdata, &ts->filter_data);
|
|
|
|
if (err < 0)
|
|
|
|
goto err_free_mem;
|
|
|
|
}
|
|
|
|
ts->filter = pdata->filter;
|
|
|
|
ts->filter_cleanup = pdata->filter_cleanup;
|
|
|
|
} else if (pdata->debounce_max) {
|
2006-04-26 04:13:18 +00:00
|
|
|
ts->debounce_max = pdata->debounce_max;
|
2007-01-18 05:44:41 +00:00
|
|
|
if (ts->debounce_max < 2)
|
|
|
|
ts->debounce_max = 2;
|
2006-04-26 04:13:18 +00:00
|
|
|
ts->debounce_tol = pdata->debounce_tol;
|
|
|
|
ts->debounce_rep = pdata->debounce_rep;
|
2007-01-18 05:44:41 +00:00
|
|
|
ts->filter = ads7846_debounce;
|
|
|
|
ts->filter_data = ts;
|
2006-04-26 04:13:18 +00:00
|
|
|
} else
|
2007-01-18 05:44:41 +00:00
|
|
|
ts->filter = ads7846_no_filter;
|
2006-04-12 03:44:05 +00:00
|
|
|
ts->get_pendown_state = pdata->get_pendown_state;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-02-15 05:49:22 +00:00
|
|
|
snprintf(ts->phys, sizeof(ts->phys), "%s/input0", spi->dev.bus_id);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-02-15 05:49:22 +00:00
|
|
|
input_dev->name = "ADS784x Touchscreen";
|
|
|
|
input_dev->phys = ts->phys;
|
2007-04-12 05:35:14 +00:00
|
|
|
input_dev->dev.parent = &spi->dev;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-02-15 05:49:22 +00:00
|
|
|
input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
|
|
|
|
input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
|
|
|
|
input_set_abs_params(input_dev, ABS_X,
|
2006-01-08 21:34:21 +00:00
|
|
|
pdata->x_min ? : 0,
|
|
|
|
pdata->x_max ? : MAX_12BIT,
|
|
|
|
0, 0);
|
2006-02-15 05:49:22 +00:00
|
|
|
input_set_abs_params(input_dev, ABS_Y,
|
2006-01-08 21:34:21 +00:00
|
|
|
pdata->y_min ? : 0,
|
|
|
|
pdata->y_max ? : MAX_12BIT,
|
|
|
|
0, 0);
|
2006-02-15 05:49:22 +00:00
|
|
|
input_set_abs_params(input_dev, ABS_PRESSURE,
|
2006-01-08 21:34:21 +00:00
|
|
|
pdata->pressure_min, pdata->pressure_max, 0, 0);
|
|
|
|
|
2007-01-18 05:45:21 +00:00
|
|
|
vref = pdata->keep_vref_on;
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
/* set up the transfers to read touchscreen state; this assumes we
|
|
|
|
* use formula #2 for pressure, not #3.
|
|
|
|
*/
|
2006-04-12 03:42:03 +00:00
|
|
|
m = &ts->msg[0];
|
2006-01-08 21:34:21 +00:00
|
|
|
x = ts->xfer;
|
|
|
|
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_init(m);
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
/* y- still on; turn on only y+ (and ADC) */
|
2007-01-18 05:45:21 +00:00
|
|
|
ts->read_y = READ_Y(vref);
|
2006-02-15 05:49:35 +00:00
|
|
|
x->tx_buf = &ts->read_y;
|
2006-01-08 21:34:21 +00:00
|
|
|
x->len = 1;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
2006-02-15 05:49:35 +00:00
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
x++;
|
|
|
|
x->rx_buf = &ts->tc.y;
|
|
|
|
x->len = 2;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
m->complete = ads7846_rx_val;
|
2006-04-12 03:42:03 +00:00
|
|
|
m->context = ts;
|
|
|
|
|
|
|
|
m++;
|
|
|
|
spi_message_init(m);
|
|
|
|
|
|
|
|
/* turn y- off, x+ on, then leave in lowpower */
|
|
|
|
x++;
|
2007-01-18 05:45:21 +00:00
|
|
|
ts->read_x = READ_X(vref);
|
2006-04-12 03:42:03 +00:00
|
|
|
x->tx_buf = &ts->read_x;
|
|
|
|
x->len = 1;
|
|
|
|
spi_message_add_tail(x, m);
|
|
|
|
|
|
|
|
x++;
|
|
|
|
x->rx_buf = &ts->tc.x;
|
|
|
|
x->len = 2;
|
|
|
|
spi_message_add_tail(x, m);
|
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
m->complete = ads7846_rx_val;
|
2006-04-12 03:42:03 +00:00
|
|
|
m->context = ts;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
/* turn y+ off, x- on; we'll use formula #2 */
|
|
|
|
if (ts->model == 7846) {
|
2006-04-12 03:42:03 +00:00
|
|
|
m++;
|
|
|
|
spi_message_init(m);
|
|
|
|
|
2006-02-15 05:49:35 +00:00
|
|
|
x++;
|
2007-01-18 05:45:21 +00:00
|
|
|
ts->read_z1 = READ_Z1(vref);
|
2006-02-15 05:49:35 +00:00
|
|
|
x->tx_buf = &ts->read_z1;
|
2006-01-08 21:34:21 +00:00
|
|
|
x->len = 1;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
2006-02-15 05:49:35 +00:00
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
x++;
|
|
|
|
x->rx_buf = &ts->tc.z1;
|
|
|
|
x->len = 2;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
m->complete = ads7846_rx_val;
|
2006-04-12 03:42:03 +00:00
|
|
|
m->context = ts;
|
|
|
|
|
|
|
|
m++;
|
|
|
|
spi_message_init(m);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-02-15 05:49:35 +00:00
|
|
|
x++;
|
2007-01-18 05:45:21 +00:00
|
|
|
ts->read_z2 = READ_Z2(vref);
|
2006-02-15 05:49:35 +00:00
|
|
|
x->tx_buf = &ts->read_z2;
|
2006-01-08 21:34:21 +00:00
|
|
|
x->len = 1;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
2006-02-15 05:49:35 +00:00
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
x++;
|
|
|
|
x->rx_buf = &ts->tc.z2;
|
|
|
|
x->len = 2;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
m->complete = ads7846_rx_val;
|
2006-04-12 03:42:03 +00:00
|
|
|
m->context = ts;
|
|
|
|
}
|
2006-04-12 03:41:49 +00:00
|
|
|
|
|
|
|
/* power down */
|
2006-04-12 03:42:03 +00:00
|
|
|
m++;
|
|
|
|
spi_message_init(m);
|
|
|
|
|
2006-04-12 03:41:49 +00:00
|
|
|
x++;
|
|
|
|
ts->pwrdown = PWRDOWN;
|
|
|
|
x->tx_buf = &ts->pwrdown;
|
|
|
|
x->len = 1;
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
2006-04-12 03:41:49 +00:00
|
|
|
|
|
|
|
x++;
|
|
|
|
x->rx_buf = &ts->dummy;
|
|
|
|
x->len = 2;
|
2006-02-15 05:49:35 +00:00
|
|
|
CS_CHANGE(*x);
|
2006-04-12 03:42:03 +00:00
|
|
|
spi_message_add_tail(x, m);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:42:03 +00:00
|
|
|
m->complete = ads7846_rx;
|
|
|
|
m->context = ts;
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-26 04:13:18 +00:00
|
|
|
ts->last_msg = m;
|
|
|
|
|
2006-07-02 02:29:38 +00:00
|
|
|
if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
|
2006-05-26 01:44:20 +00:00
|
|
|
spi->dev.driver->name, ts)) {
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
|
2006-02-15 05:49:22 +00:00
|
|
|
err = -EBUSY;
|
2007-01-18 05:44:41 +00:00
|
|
|
goto err_cleanup_filter;
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
err = ads784x_hwmon_register(spi, ts);
|
|
|
|
if (err)
|
|
|
|
goto err_free_irq;
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
/* take a first sample, leaving nPENIRQ active and vREF off; avoid
|
2006-01-08 21:34:21 +00:00
|
|
|
* the touchscreen, in case it's not connected.
|
|
|
|
*/
|
2006-01-08 21:34:25 +00:00
|
|
|
(void) ads7846_read12_ser(&spi->dev,
|
2006-01-08 21:34:21 +00:00
|
|
|
READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
|
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
|
2006-11-03 04:34:09 +00:00
|
|
|
if (err)
|
2007-01-18 05:45:48 +00:00
|
|
|
goto err_remove_hwmon;
|
2006-04-12 03:43:55 +00:00
|
|
|
|
2006-02-15 05:49:22 +00:00
|
|
|
err = input_register_device(input_dev);
|
|
|
|
if (err)
|
2006-11-03 04:34:09 +00:00
|
|
|
goto err_remove_attr_group;
|
2006-02-15 05:49:22 +00:00
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
return 0;
|
2006-02-15 05:49:22 +00:00
|
|
|
|
2006-11-03 04:34:09 +00:00
|
|
|
err_remove_attr_group:
|
2007-01-18 05:45:48 +00:00
|
|
|
sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
|
|
|
|
err_remove_hwmon:
|
|
|
|
ads784x_hwmon_unregister(spi, ts);
|
2006-11-03 04:34:09 +00:00
|
|
|
err_free_irq:
|
2006-02-15 05:49:22 +00:00
|
|
|
free_irq(spi->irq, ts);
|
2007-01-18 05:44:41 +00:00
|
|
|
err_cleanup_filter:
|
|
|
|
if (ts->filter_cleanup)
|
|
|
|
ts->filter_cleanup(ts->filter_data);
|
2006-02-15 05:49:22 +00:00
|
|
|
err_free_mem:
|
|
|
|
input_free_device(input_dev);
|
|
|
|
kfree(ts);
|
|
|
|
return err;
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
static int __devexit ads7846_remove(struct spi_device *spi)
|
2006-01-08 21:34:21 +00:00
|
|
|
{
|
2006-01-08 21:34:25 +00:00
|
|
|
struct ads7846 *ts = dev_get_drvdata(&spi->dev);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
ads784x_hwmon_unregister(spi, ts);
|
2006-04-12 03:43:55 +00:00
|
|
|
input_unregister_device(ts->input);
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
ads7846_suspend(spi, PMSG_SUSPEND);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2007-01-18 05:45:48 +00:00
|
|
|
sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
2006-04-12 03:43:55 +00:00
|
|
|
free_irq(ts->spi->irq, ts);
|
2006-04-12 03:44:05 +00:00
|
|
|
/* suspend left the IRQ disabled */
|
|
|
|
enable_irq(ts->spi->irq);
|
2006-04-12 03:43:55 +00:00
|
|
|
|
2007-01-18 05:44:41 +00:00
|
|
|
if (ts->filter_cleanup)
|
|
|
|
ts->filter_cleanup(ts->filter_data);
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
kfree(ts);
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
dev_dbg(&spi->dev, "unregistered touchscreen\n");
|
2006-01-08 21:34:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
static struct spi_driver ads7846_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "ads7846",
|
|
|
|
.bus = &spi_bus_type,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
},
|
2006-01-08 21:34:21 +00:00
|
|
|
.probe = ads7846_probe,
|
2006-01-08 21:34:25 +00:00
|
|
|
.remove = __devexit_p(ads7846_remove),
|
2006-01-08 21:34:21 +00:00
|
|
|
.suspend = ads7846_suspend,
|
|
|
|
.resume = ads7846_resume,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init ads7846_init(void)
|
|
|
|
{
|
|
|
|
/* grr, board-specific init should stay out of drivers!! */
|
|
|
|
|
|
|
|
#ifdef CONFIG_ARCH_OMAP
|
|
|
|
if (machine_is_omap_osk()) {
|
|
|
|
/* GPIO4 = PENIRQ; GPIO6 = BUSY */
|
|
|
|
omap_request_gpio(4);
|
|
|
|
omap_set_gpio_direction(4, 1);
|
|
|
|
omap_request_gpio(6);
|
|
|
|
omap_set_gpio_direction(6, 1);
|
|
|
|
}
|
|
|
|
// also TI 1510 Innovator, bitbanging through FPGA
|
|
|
|
// also Nokia 770
|
|
|
|
// also Palm Tungsten T2
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// PXA:
|
|
|
|
// also Dell Axim X50
|
|
|
|
// also HP iPaq H191x/H192x/H415x/H435x
|
2006-01-08 21:34:25 +00:00
|
|
|
// also Intel Lubbock (additional to UCB1400; as temperature sensor)
|
2006-01-08 21:34:21 +00:00
|
|
|
// also Sharp Zaurus C7xx, C8xx (corgi/sheperd/husky)
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
// Atmel at91sam9261-EK uses ads7843
|
|
|
|
|
2006-01-08 21:34:21 +00:00
|
|
|
// also various AMD Au1x00 devel boards
|
|
|
|
|
2006-01-08 21:34:25 +00:00
|
|
|
return spi_register_driver(&ads7846_driver);
|
2006-01-08 21:34:21 +00:00
|
|
|
}
|
|
|
|
module_init(ads7846_init);
|
|
|
|
|
|
|
|
static void __exit ads7846_exit(void)
|
|
|
|
{
|
2006-01-08 21:34:25 +00:00
|
|
|
spi_unregister_driver(&ads7846_driver);
|
2006-01-08 21:34:21 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_ARCH_OMAP
|
|
|
|
if (machine_is_omap_osk()) {
|
|
|
|
omap_free_gpio(4);
|
|
|
|
omap_free_gpio(6);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
module_exit(ads7846_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|