aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/input/touchscreen/Kconfig37
-rw-r--r--drivers/input/touchscreen/Makefile2
-rw-r--r--drivers/input/touchscreen/ad7879-i2c.c140
-rw-r--r--drivers/input/touchscreen/ad7879-spi.c190
-rw-r--r--drivers/input/touchscreen/ad7879.c500
-rw-r--r--drivers/input/touchscreen/ad7879.h30
6 files changed, 484 insertions, 415 deletions
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index e835f04bc0d0..ff18d896ea6d 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -55,37 +55,36 @@ config TOUCHSCREEN_AD7877
55 To compile this driver as a module, choose M here: the 55 To compile this driver as a module, choose M here: the
56 module will be called ad7877. 56 module will be called ad7877.
57 57
58config TOUCHSCREEN_AD7879_I2C 58config TOUCHSCREEN_AD7879
59 tristate "AD7879 based touchscreens: AD7879-1 I2C Interface" 59 tristate "Analog Devices AD7879-1/AD7889-1 touchscreen interface"
60 depends on I2C
61 select TOUCHSCREEN_AD7879
62 help 60 help
63 Say Y here if you have a touchscreen interface using the 61 Say Y here if you want to support a touchscreen interface using
64 AD7879-1/AD7889-1 controller, and your board-specific 62 the AD7879-1/AD7889-1 controller.
65 initialization code includes that in its table of I2C devices.
66 63
67 If unsure, say N (but it's safe to say "Y"). 64 You should select a bus connection too.
68 65
69 To compile this driver as a module, choose M here: the 66 To compile this driver as a module, choose M here: the
70 module will be called ad7879. 67 module will be called ad7879.
71 68
69config TOUCHSCREEN_AD7879_I2C
70 tristate "support I2C bus connection"
71 depends on TOUCHSCREEN_AD7879 && I2C
72 help
73 Say Y here if you have AD7879-1/AD7889-1 hooked to an I2C bus.
74
75 To compile this driver as a module, choose M here: the
76 module will be called ad7879-i2c.
77
72config TOUCHSCREEN_AD7879_SPI 78config TOUCHSCREEN_AD7879_SPI
73 tristate "AD7879 based touchscreens: AD7879 SPI Interface" 79 tristate "support SPI bus connection"
74 depends on SPI_MASTER && TOUCHSCREEN_AD7879_I2C = n 80 depends on TOUCHSCREEN_AD7879 && SPI_MASTER
75 select TOUCHSCREEN_AD7879
76 help 81 help
77 Say Y here if you have a touchscreen interface using the 82 Say Y here if you have AD7879-1/AD7889-1 hooked to a SPI bus.
78 AD7879/AD7889 controller, and your board-specific initialization
79 code includes that in its table of SPI devices.
80 83
81 If unsure, say N (but it's safe to say "Y"). 84 If unsure, say N (but it's safe to say "Y").
82 85
83 To compile this driver as a module, choose M here: the 86 To compile this driver as a module, choose M here: the
84 module will be called ad7879. 87 module will be called ad7879-spi.
85
86config TOUCHSCREEN_AD7879
87 tristate
88 default n
89 88
90config TOUCHSCREEN_BITSY 89config TOUCHSCREEN_BITSY
91 tristate "Compaq iPAQ H3600 (Bitsy) touchscreen" 90 tristate "Compaq iPAQ H3600 (Bitsy) touchscreen"
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 497964a7a214..9efdd4424757 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -9,6 +9,8 @@ wm97xx-ts-y := wm97xx-core.o
9obj-$(CONFIG_TOUCHSCREEN_88PM860X) += 88pm860x-ts.o 9obj-$(CONFIG_TOUCHSCREEN_88PM860X) += 88pm860x-ts.o
10obj-$(CONFIG_TOUCHSCREEN_AD7877) += ad7877.o 10obj-$(CONFIG_TOUCHSCREEN_AD7877) += ad7877.o
11obj-$(CONFIG_TOUCHSCREEN_AD7879) += ad7879.o 11obj-$(CONFIG_TOUCHSCREEN_AD7879) += ad7879.o
12obj-$(CONFIG_TOUCHSCREEN_AD7879_I2C) += ad7879-i2c.o
13obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI) += ad7879-spi.o
12obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o 14obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o
13obj-$(CONFIG_TOUCHSCREEN_ATMEL_TSADCC) += atmel_tsadcc.o 15obj-$(CONFIG_TOUCHSCREEN_ATMEL_TSADCC) += atmel_tsadcc.o
14obj-$(CONFIG_TOUCHSCREEN_BITSY) += h3600_ts_input.o 16obj-$(CONFIG_TOUCHSCREEN_BITSY) += h3600_ts_input.o
diff --git a/drivers/input/touchscreen/ad7879-i2c.c b/drivers/input/touchscreen/ad7879-i2c.c
new file mode 100644
index 000000000000..85dfdd27df5a
--- /dev/null
+++ b/drivers/input/touchscreen/ad7879-i2c.c
@@ -0,0 +1,140 @@
1/*
2 * AD7879-1/AD7889-1 touchscreen (I2C bus)
3 *
4 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
7 */
8
9#include <linux/input.h> /* BUS_I2C */
10#include <linux/i2c.h>
11#include <linux/module.h>
12#include <linux/types.h>
13
14#include "ad7879.h"
15
16#define AD7879_DEVID 0x79 /* AD7879-1/AD7889-1 */
17
18#ifdef CONFIG_PM
19static int ad7879_i2c_suspend(struct i2c_client *client, pm_message_t message)
20{
21 struct ad7879 *ts = i2c_get_clientdata(client);
22
23 ad7879_disable(ts);
24
25 return 0;
26}
27
28static int ad7879_i2c_resume(struct i2c_client *client)
29{
30 struct ad7879 *ts = i2c_get_clientdata(client);
31
32 ad7879_enable(ts);
33
34 return 0;
35}
36#else
37# define ad7879_i2c_suspend NULL
38# define ad7879_i2c_resume NULL
39#endif
40
41/* All registers are word-sized.
42 * AD7879 uses a high-byte first convention.
43 */
44static int ad7879_i2c_read(struct device *dev, u8 reg)
45{
46 struct i2c_client *client = to_i2c_client(dev);
47
48 return swab16(i2c_smbus_read_word_data(client, reg));
49}
50
51static int ad7879_i2c_multi_read(struct device *dev,
52 u8 first_reg, u8 count, u16 *buf)
53{
54 u8 idx;
55
56 for (idx = 0; idx < count; ++idx)
57 buf[idx] = ad7879_i2c_read(dev, first_reg + idx);
58
59 return 0;
60}
61
62static int ad7879_i2c_write(struct device *dev, u8 reg, u16 val)
63{
64 struct i2c_client *client = to_i2c_client(dev);
65
66 return i2c_smbus_write_word_data(client, reg, swab16(val));
67}
68
69static const struct ad7879_bus_ops ad7879_i2c_bus_ops = {
70 .bustype = BUS_I2C,
71 .read = ad7879_i2c_read,
72 .multi_read = ad7879_i2c_multi_read,
73 .write = ad7879_i2c_write,
74};
75
76static int __devinit ad7879_i2c_probe(struct i2c_client *client,
77 const struct i2c_device_id *id)
78{
79 struct ad7879 *ts;
80
81 if (!i2c_check_functionality(client->adapter,
82 I2C_FUNC_SMBUS_WORD_DATA)) {
83 dev_err(&client->dev, "SMBUS Word Data not Supported\n");
84 return -EIO;
85 }
86
87 ts = ad7879_probe(&client->dev, AD7879_DEVID, client->irq,
88 &ad7879_i2c_bus_ops);
89 if (IS_ERR(ts))
90 return PTR_ERR(ts);
91
92 i2c_set_clientdata(client, ts);
93
94 return 0;
95}
96
97static int __devexit ad7879_i2c_remove(struct i2c_client *client)
98{
99 struct ad7879 *ts = i2c_get_clientdata(client);
100
101 ad7879_remove(ts);
102
103 return 0;
104}
105
106static const struct i2c_device_id ad7879_id[] = {
107 { "ad7879", 0 },
108 { "ad7889", 0 },
109 { }
110};
111MODULE_DEVICE_TABLE(i2c, ad7879_id);
112
113static struct i2c_driver ad7879_i2c_driver = {
114 .driver = {
115 .name = "ad7879",
116 .owner = THIS_MODULE,
117 },
118 .probe = ad7879_i2c_probe,
119 .remove = __devexit_p(ad7879_i2c_remove),
120 .suspend = ad7879_i2c_suspend,
121 .resume = ad7879_i2c_resume,
122 .id_table = ad7879_id,
123};
124
125static int __init ad7879_i2c_init(void)
126{
127 return i2c_add_driver(&ad7879_i2c_driver);
128}
129module_init(ad7879_i2c_init);
130
131static void __exit ad7879_i2c_exit(void)
132{
133 i2c_del_driver(&ad7879_i2c_driver);
134}
135module_exit(ad7879_i2c_exit);
136
137MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
138MODULE_DESCRIPTION("AD7879(-1) touchscreen I2C bus driver");
139MODULE_LICENSE("GPL");
140MODULE_ALIAS("i2c:ad7879");
diff --git a/drivers/input/touchscreen/ad7879-spi.c b/drivers/input/touchscreen/ad7879-spi.c
new file mode 100644
index 000000000000..5d1e5a050332
--- /dev/null
+++ b/drivers/input/touchscreen/ad7879-spi.c
@@ -0,0 +1,190 @@
1/*
2 * AD7879/AD7889 touchscreen (SPI bus)
3 *
4 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
7 */
8
9#include <linux/input.h> /* BUS_SPI */
10#include <linux/spi/spi.h>
11
12#include "ad7879.h"
13
14#define AD7879_DEVID 0x7A /* AD7879/AD7889 */
15
16#define MAX_SPI_FREQ_HZ 5000000
17#define AD7879_CMD_MAGIC 0xE000
18#define AD7879_CMD_READ (1 << 10)
19#define AD7879_CMD(reg) (AD7879_CMD_MAGIC | ((reg) & 0xF))
20#define AD7879_WRITECMD(reg) (AD7879_CMD(reg))
21#define AD7879_READCMD(reg) (AD7879_CMD(reg) | AD7879_CMD_READ)
22
23#ifdef CONFIG_PM
24static int ad7879_spi_suspend(struct spi_device *spi, pm_message_t message)
25{
26 struct ad7879 *ts = spi_get_drvdata(spi);
27
28 ad7879_disable(ts);
29
30 return 0;
31}
32
33static int ad7879_spi_resume(struct spi_device *spi)
34{
35 struct ad7879 *ts = spi_get_drvdata(spi);
36
37 ad7879_enable(ts);
38
39 return 0;
40}
41#else
42# define ad7879_spi_suspend NULL
43# define ad7879_spi_resume NULL
44#endif
45
46/*
47 * ad7879_read/write are only used for initial setup and for sysfs controls.
48 * The main traffic is done in ad7879_collect().
49 */
50
51static int ad7879_spi_xfer(struct spi_device *spi,
52 u16 cmd, u8 count, u16 *tx_buf, u16 *rx_buf)
53{
54 struct spi_message msg;
55 struct spi_transfer *xfers;
56 void *spi_data;
57 u16 *command;
58 u16 *_rx_buf = _rx_buf; /* shut gcc up */
59 u8 idx;
60 int ret;
61
62 xfers = spi_data = kzalloc(sizeof(*xfers) * (count + 2), GFP_KERNEL);
63 if (!spi_data)
64 return -ENOMEM;
65
66 spi_message_init(&msg);
67
68 command = spi_data;
69 command[0] = cmd;
70 if (count == 1) {
71 /* ad7879_spi_{read,write} gave us buf on stack */
72 command[1] = *tx_buf;
73 tx_buf = &command[1];
74 _rx_buf = rx_buf;
75 rx_buf = &command[2];
76 }
77
78 ++xfers;
79 xfers[0].tx_buf = command;
80 xfers[0].len = 2;
81 spi_message_add_tail(&xfers[0], &msg);
82 ++xfers;
83
84 for (idx = 0; idx < count; ++idx) {
85 if (rx_buf)
86 xfers[idx].rx_buf = &rx_buf[idx];
87 if (tx_buf)
88 xfers[idx].tx_buf = &tx_buf[idx];
89 xfers[idx].len = 2;
90 spi_message_add_tail(&xfers[idx], &msg);
91 }
92
93 ret = spi_sync(spi, &msg);
94
95 if (count == 1)
96 _rx_buf[0] = command[2];
97
98 kfree(spi_data);
99
100 return ret;
101}
102
103static int ad7879_spi_multi_read(struct device *dev,
104 u8 first_reg, u8 count, u16 *buf)
105{
106 struct spi_device *spi = to_spi_device(dev);
107
108 return ad7879_spi_xfer(spi, AD7879_READCMD(first_reg), count, NULL, buf);
109}
110
111static int ad7879_spi_read(struct device *dev, u8 reg)
112{
113 struct spi_device *spi = to_spi_device(dev);
114 u16 ret, dummy;
115
116 return ad7879_spi_xfer(spi, AD7879_READCMD(reg), 1, &dummy, &ret) ? : ret;
117}
118
119static int ad7879_spi_write(struct device *dev, u8 reg, u16 val)
120{
121 struct spi_device *spi = to_spi_device(dev);
122 u16 dummy;
123
124 return ad7879_spi_xfer(spi, AD7879_WRITECMD(reg), 1, &val, &dummy);
125}
126
127static const struct ad7879_bus_ops ad7879_spi_bus_ops = {
128 .bustype = BUS_SPI,
129 .read = ad7879_spi_read,
130 .multi_read = ad7879_spi_multi_read,
131 .write = ad7879_spi_write,
132};
133
134static int __devinit ad7879_spi_probe(struct spi_device *spi)
135{
136 struct ad7879 *ts;
137
138 /* don't exceed max specified SPI CLK frequency */
139 if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
140 dev_err(&spi->dev, "SPI CLK %d Hz?\n", spi->max_speed_hz);
141 return -EINVAL;
142 }
143
144 ts = ad7879_probe(&spi->dev, AD7879_DEVID, spi->irq, &ad7879_spi_bus_ops);
145 if (IS_ERR(ts))
146 return PTR_ERR(ts);
147
148 spi_set_drvdata(spi, ts);
149
150 return 0;
151}
152
153static int __devexit ad7879_spi_remove(struct spi_device *spi)
154{
155 struct ad7879 *ts = spi_get_drvdata(spi);
156
157 ad7879_remove(ts);
158 spi_set_drvdata(spi, NULL);
159
160 return 0;
161}
162
163static struct spi_driver ad7879_spi_driver = {
164 .driver = {
165 .name = "ad7879",
166 .bus = &spi_bus_type,
167 .owner = THIS_MODULE,
168 },
169 .probe = ad7879_spi_probe,
170 .remove = __devexit_p(ad7879_spi_remove),
171 .suspend = ad7879_spi_suspend,
172 .resume = ad7879_spi_resume,
173};
174
175static int __init ad7879_spi_init(void)
176{
177 return spi_register_driver(&ad7879_spi_driver);
178}
179module_init(ad7879_spi_init);
180
181static void __exit ad7879_spi_exit(void)
182{
183 spi_unregister_driver(&ad7879_spi_driver);
184}
185module_exit(ad7879_spi_exit);
186
187MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
188MODULE_DESCRIPTION("AD7879(-1) touchscreen SPI bus driver");
189MODULE_LICENSE("GPL");
190MODULE_ALIAS("spi:ad7879");
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index f947457c858b..1de19691c4a3 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -1,25 +1,9 @@
1/* 1/*
2 * Copyright (C) 2008-2009 Michael Hennerich, Analog Devices Inc. 2 * AD7879/AD7889 based touchscreen and GPIO driver
3 * 3 *
4 * Description: AD7879/AD7889 based touchscreen, and GPIO driver 4 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
5 * (I2C/SPI Interface)
6 * 5 *
7 * Bugs: Enter bugs at http://blackfin.uclinux.org/ 6 * Licensed under the GPL-2 or later.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, see the file COPYING, or write
21 * to the Free Software Foundation, Inc.,
22 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 * 7 *
24 * History: 8 * History:
25 * Copyright (c) 2005 David Brownell 9 * Copyright (c) 2005 David Brownell
@@ -49,6 +33,7 @@
49#include <linux/gpio.h> 33#include <linux/gpio.h>
50 34
51#include <linux/spi/ad7879.h> 35#include <linux/spi/ad7879.h>
36#include "ad7879.h"
52 37
53#define AD7879_REG_ZEROS 0 38#define AD7879_REG_ZEROS 0
54#define AD7879_REG_CTRL1 1 39#define AD7879_REG_CTRL1 1
@@ -119,29 +104,18 @@ enum {
119#define MAX_12BIT ((1<<12)-1) 104#define MAX_12BIT ((1<<12)-1)
120#define TS_PEN_UP_TIMEOUT msecs_to_jiffies(50) 105#define TS_PEN_UP_TIMEOUT msecs_to_jiffies(50)
121 106
122#if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
123#define AD7879_DEVID 0x7A
124typedef struct spi_device bus_device;
125#elif defined(CONFIG_TOUCHSCREEN_AD7879_I2C) || defined(CONFIG_TOUCHSCREEN_AD7879_I2C_MODULE)
126#define AD7879_DEVID 0x79
127typedef struct i2c_client bus_device;
128#endif
129
130struct ad7879 { 107struct ad7879 {
131 bus_device *bus; 108 const struct ad7879_bus_ops *bops;
109
110 struct device *dev;
132 struct input_dev *input; 111 struct input_dev *input;
133 struct timer_list timer; 112 struct timer_list timer;
134#ifdef CONFIG_GPIOLIB 113#ifdef CONFIG_GPIOLIB
135 struct gpio_chip gc; 114 struct gpio_chip gc;
136#endif 115#endif
116 unsigned int irq;
137 struct mutex mutex; 117 struct mutex mutex;
138 bool disabled; /* P: mutex */ 118 bool disabled; /* P: mutex */
139
140#if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
141 struct spi_message msg;
142 struct spi_transfer xfer[AD7879_NR_SENSE + 1];
143 u16 cmd;
144#endif
145 u16 conversion_data[AD7879_NR_SENSE]; 119 u16 conversion_data[AD7879_NR_SENSE];
146 char phys[32]; 120 char phys[32];
147 u8 first_conversion_delay; 121 u8 first_conversion_delay;
@@ -156,9 +130,20 @@ struct ad7879 {
156 u16 cmd_crtl3; 130 u16 cmd_crtl3;
157}; 131};
158 132
159static int ad7879_read(bus_device *, u8); 133static int ad7879_read(struct ad7879 *ts, u8 reg)
160static int ad7879_write(bus_device *, u8, u16); 134{
161static void ad7879_collect(struct ad7879 *); 135 return ts->bops->read(ts->dev, reg);
136}
137
138static int ad7879_multi_read(struct ad7879 *ts, u8 first_reg, u8 count, u16 *buf)
139{
140 return ts->bops->multi_read(ts->dev, first_reg, count, buf);
141}
142
143static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val)
144{
145 return ts->bops->write(ts->dev, reg, val);
146}
162 147
163static void ad7879_report(struct ad7879 *ts) 148static void ad7879_report(struct ad7879 *ts)
164{ 149{
@@ -173,12 +158,14 @@ static void ad7879_report(struct ad7879 *ts)
173 158
174 /* 159 /*
175 * The samples processed here are already preprocessed by the AD7879. 160 * The samples processed here are already preprocessed by the AD7879.
176 * The preprocessing function consists of a median and an averaging filter. 161 * The preprocessing function consists of a median and an averaging
177 * The combination of these two techniques provides a robust solution, 162 * filter. The combination of these two techniques provides a robust
178 * discarding the spurious noise in the signal and keeping only the data of interest. 163 * solution, discarding the spurious noise in the signal and keeping
179 * The size of both filters is programmable. (dev.platform_data, see linux/spi/ad7879.h) 164 * only the data of interest. The size of both filters is
180 * Other user-programmable conversion controls include variable acquisition time, 165 * programmable. (dev.platform_data, see linux/spi/ad7879.h) Other
181 * and first conversion delay. Up to 16 averages can be taken per conversion. 166 * user-programmable conversion controls include variable acquisition
167 * time, and first conversion delay. Up to 16 averages can be taken
168 * per conversion.
182 */ 169 */
183 170
184 if (likely(x && z1)) { 171 if (likely(x && z1)) {
@@ -213,7 +200,7 @@ static irqreturn_t ad7879_irq(int irq, void *handle)
213{ 200{
214 struct ad7879 *ts = handle; 201 struct ad7879 *ts = handle;
215 202
216 ad7879_collect(ts); 203 ad7879_multi_read(ts, AD7879_REG_XPLUS, AD7879_NR_SENSE, ts->conversion_data);
217 ad7879_report(ts); 204 ad7879_report(ts);
218 205
219 mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT); 206 mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
@@ -223,42 +210,44 @@ static irqreturn_t ad7879_irq(int irq, void *handle)
223 210
224static void ad7879_setup(struct ad7879 *ts) 211static void ad7879_setup(struct ad7879 *ts)
225{ 212{
226 ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2); 213 ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
227 ad7879_write(ts->bus, AD7879_REG_CTRL3, ts->cmd_crtl3); 214 ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3);
228 ad7879_write(ts->bus, AD7879_REG_CTRL1, ts->cmd_crtl1); 215 ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1);
229} 216}
230 217
231static void ad7879_disable(struct ad7879 *ts) 218void ad7879_disable(struct ad7879 *ts)
232{ 219{
233 mutex_lock(&ts->mutex); 220 mutex_lock(&ts->mutex);
234 221
235 if (!ts->disabled) { 222 if (!ts->disabled) {
236 223
237 ts->disabled = true; 224 ts->disabled = true;
238 disable_irq(ts->bus->irq); 225 disable_irq(ts->irq);
239 226
240 if (del_timer_sync(&ts->timer)) 227 if (del_timer_sync(&ts->timer))
241 ad7879_ts_event_release(ts); 228 ad7879_ts_event_release(ts);
242 229
243 ad7879_write(ts->bus, AD7879_REG_CTRL2, 230 ad7879_write(ts, AD7879_REG_CTRL2,
244 AD7879_PM(AD7879_PM_SHUTDOWN)); 231 AD7879_PM(AD7879_PM_SHUTDOWN));
245 } 232 }
246 233
247 mutex_unlock(&ts->mutex); 234 mutex_unlock(&ts->mutex);
248} 235}
236EXPORT_SYMBOL(ad7879_disable);
249 237
250static void ad7879_enable(struct ad7879 *ts) 238void ad7879_enable(struct ad7879 *ts)
251{ 239{
252 mutex_lock(&ts->mutex); 240 mutex_lock(&ts->mutex);
253 241
254 if (ts->disabled) { 242 if (ts->disabled) {
255 ad7879_setup(ts); 243 ad7879_setup(ts);
256 ts->disabled = false; 244 ts->disabled = false;
257 enable_irq(ts->bus->irq); 245 enable_irq(ts->irq);
258 } 246 }
259 247
260 mutex_unlock(&ts->mutex); 248 mutex_unlock(&ts->mutex);
261} 249}
250EXPORT_SYMBOL(ad7879_enable);
262 251
263static ssize_t ad7879_disable_show(struct device *dev, 252static ssize_t ad7879_disable_show(struct device *dev,
264 struct device_attribute *attr, char *buf) 253 struct device_attribute *attr, char *buf)
@@ -308,7 +297,7 @@ static int ad7879_gpio_direction_input(struct gpio_chip *chip,
308 297
309 mutex_lock(&ts->mutex); 298 mutex_lock(&ts->mutex);
310 ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL; 299 ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
311 err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2); 300 err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
312 mutex_unlock(&ts->mutex); 301 mutex_unlock(&ts->mutex);
313 302
314 return err; 303 return err;
@@ -328,7 +317,7 @@ static int ad7879_gpio_direction_output(struct gpio_chip *chip,
328 else 317 else
329 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA; 318 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
330 319
331 err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2); 320 err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
332 mutex_unlock(&ts->mutex); 321 mutex_unlock(&ts->mutex);
333 322
334 return err; 323 return err;
@@ -340,7 +329,7 @@ static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
340 u16 val; 329 u16 val;
341 330
342 mutex_lock(&ts->mutex); 331 mutex_lock(&ts->mutex);
343 val = ad7879_read(ts->bus, AD7879_REG_CTRL2); 332 val = ad7879_read(ts, AD7879_REG_CTRL2);
344 mutex_unlock(&ts->mutex); 333 mutex_unlock(&ts->mutex);
345 334
346 return !!(val & AD7879_GPIO_DATA); 335 return !!(val & AD7879_GPIO_DATA);
@@ -357,14 +346,13 @@ static void ad7879_gpio_set_value(struct gpio_chip *chip,
357 else 346 else
358 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA; 347 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
359 348
360 ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2); 349 ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
361 mutex_unlock(&ts->mutex); 350 mutex_unlock(&ts->mutex);
362} 351}
363 352
364static int __devinit ad7879_gpio_add(struct device *dev) 353static int ad7879_gpio_add(struct ad7879 *ts,
354 const struct ad7879_platform_data *pdata)
365{ 355{
366 struct ad7879 *ts = dev_get_drvdata(dev);
367 struct ad7879_platform_data *pdata = dev->platform_data;
368 int ret = 0; 356 int ret = 0;
369 357
370 if (pdata->gpio_export) { 358 if (pdata->gpio_export) {
@@ -377,72 +365,78 @@ static int __devinit ad7879_gpio_add(struct device *dev)
377 ts->gc.ngpio = 1; 365 ts->gc.ngpio = 1;
378 ts->gc.label = "AD7879-GPIO"; 366 ts->gc.label = "AD7879-GPIO";
379 ts->gc.owner = THIS_MODULE; 367 ts->gc.owner = THIS_MODULE;
380 ts->gc.dev = dev; 368 ts->gc.dev = ts->dev;
381 369
382 ret = gpiochip_add(&ts->gc); 370 ret = gpiochip_add(&ts->gc);
383 if (ret) 371 if (ret)
384 dev_err(dev, "failed to register gpio %d\n", 372 dev_err(ts->dev, "failed to register gpio %d\n",
385 ts->gc.base); 373 ts->gc.base);
386 } 374 }
387 375
388 return ret; 376 return ret;
389} 377}
390 378
391/* 379static void ad7879_gpio_remove(struct ad7879 *ts)
392 * We mark ad7879_gpio_remove inline so there is a chance the code
393 * gets discarded when not needed. We can't do __devinit/__devexit
394 * markup since it is used in both probe and remove methods.
395 */
396static inline void ad7879_gpio_remove(struct device *dev)
397{ 380{
398 struct ad7879 *ts = dev_get_drvdata(dev); 381 const struct ad7879_platform_data *pdata = ts->dev->platform_data;
399 struct ad7879_platform_data *pdata = dev->platform_data;
400 int ret; 382 int ret;
401 383
402 if (pdata->gpio_export) { 384 if (pdata->gpio_export) {
403 ret = gpiochip_remove(&ts->gc); 385 ret = gpiochip_remove(&ts->gc);
404 if (ret) 386 if (ret)
405 dev_err(dev, "failed to remove gpio %d\n", 387 dev_err(ts->dev, "failed to remove gpio %d\n",
406 ts->gc.base); 388 ts->gc.base);
407 } 389 }
408} 390}
409#else 391#else
410static inline int ad7879_gpio_add(struct device *dev) 392static inline int ad7879_gpio_add(struct ad7879 *ts,
393 const struct ad7879_platform_data *pdata)
411{ 394{
412 return 0; 395 return 0;
413} 396}
414 397
415static inline void ad7879_gpio_remove(struct device *dev) 398static inline void ad7879_gpio_remove(struct ad7879 *ts)
416{ 399{
417} 400}
418#endif 401#endif
419 402
420static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts) 403struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
404 const struct ad7879_bus_ops *bops)
421{ 405{
406 struct ad7879_platform_data *pdata = dev->platform_data;
407 struct ad7879 *ts;
422 struct input_dev *input_dev; 408 struct input_dev *input_dev;
423 struct ad7879_platform_data *pdata = bus->dev.platform_data;
424 int err; 409 int err;
425 u16 revid; 410 u16 revid;
426 411
427 if (!bus->irq) { 412 if (!irq) {
428 dev_err(&bus->dev, "no IRQ?\n"); 413 dev_err(dev, "no IRQ?\n");
429 return -ENODEV; 414 err = -EINVAL;
415 goto err_out;
430 } 416 }
431 417
432 if (!pdata) { 418 if (!pdata) {
433 dev_err(&bus->dev, "no platform data?\n"); 419 dev_err(dev, "no platform data?\n");
434 return -ENODEV; 420 err = -EINVAL;
421 goto err_out;
435 } 422 }
436 423
424 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
437 input_dev = input_allocate_device(); 425 input_dev = input_allocate_device();
438 if (!input_dev) 426 if (!ts || !input_dev) {
439 return -ENOMEM; 427 err = -ENOMEM;
428 goto err_free_mem;
429 }
440 430
431 ts->bops = bops;
432 ts->dev = dev;
441 ts->input = input_dev; 433 ts->input = input_dev;
442 434
443 setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts); 435 setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);
444 mutex_init(&ts->mutex); 436 mutex_init(&ts->mutex);
445 437
438 ts->irq = irq;
439
446 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; 440 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
447 ts->pressure_max = pdata->pressure_max ? : ~0; 441 ts->pressure_max = pdata->pressure_max ? : ~0;
448 442
@@ -452,11 +446,12 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
452 ts->pen_down_acc_interval = pdata->pen_down_acc_interval; 446 ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
453 ts->median = pdata->median; 447 ts->median = pdata->median;
454 448
455 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&bus->dev)); 449 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
456 450
457 input_dev->name = "AD7879 Touchscreen"; 451 input_dev->name = "AD7879 Touchscreen";
458 input_dev->phys = ts->phys; 452 input_dev->phys = ts->phys;
459 input_dev->dev.parent = &bus->dev; 453 input_dev->dev.parent = dev;
454 input_dev->id.bustype = bops->bustype;
460 455
461 __set_bit(EV_ABS, input_dev->evbit); 456 __set_bit(EV_ABS, input_dev->evbit);
462 __set_bit(ABS_X, input_dev->absbit); 457 __set_bit(ABS_X, input_dev->absbit);
@@ -474,17 +469,18 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
474 input_set_abs_params(input_dev, ABS_PRESSURE, 469 input_set_abs_params(input_dev, ABS_PRESSURE,
475 pdata->pressure_min, pdata->pressure_max, 0, 0); 470 pdata->pressure_min, pdata->pressure_max, 0, 0);
476 471
477 err = ad7879_write(bus, AD7879_REG_CTRL2, AD7879_RESET); 472 err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET);
478
479 if (err < 0) { 473 if (err < 0) {
480 dev_err(&bus->dev, "Failed to write %s\n", input_dev->name); 474 dev_err(dev, "Failed to write %s\n", input_dev->name);
481 goto err_free_mem; 475 goto err_free_mem;
482 } 476 }
483 477
484 revid = ad7879_read(bus, AD7879_REG_REVID); 478 revid = ad7879_read(ts, AD7879_REG_REVID);
485 479 input_dev->id.product = (revid & 0xff);
486 if ((revid & 0xFF) != AD7879_DEVID) { 480 input_dev->id.version = revid >> 8;
487 dev_err(&bus->dev, "Failed to probe %s\n", input_dev->name); 481 if (input_dev->id.product != devid) {
482 dev_err(dev, "Failed to probe %s (%x vs %x)\n",
483 input_dev->name, devid, revid);
488 err = -ENODEV; 484 err = -ENODEV;
489 goto err_free_mem; 485 goto err_free_mem;
490 } 486 }
@@ -508,19 +504,19 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
508 504
509 ad7879_setup(ts); 505 ad7879_setup(ts);
510 506
511 err = request_threaded_irq(bus->irq, NULL, ad7879_irq, 507 err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
512 IRQF_TRIGGER_FALLING, 508 IRQF_TRIGGER_FALLING,
513 bus->dev.driver->name, ts); 509 dev_name(dev), ts);
514 if (err) { 510 if (err) {
515 dev_err(&bus->dev, "irq %d busy?\n", bus->irq); 511 dev_err(dev, "irq %d busy?\n", ts->irq);
516 goto err_free_mem; 512 goto err_free_mem;
517 } 513 }
518 514
519 err = sysfs_create_group(&bus->dev.kobj, &ad7879_attr_group); 515 err = sysfs_create_group(&dev->kobj, &ad7879_attr_group);
520 if (err) 516 if (err)
521 goto err_free_irq; 517 goto err_free_irq;
522 518
523 err = ad7879_gpio_add(&bus->dev); 519 err = ad7879_gpio_add(ts, pdata);
524 if (err) 520 if (err)
525 goto err_remove_attr; 521 goto err_remove_attr;
526 522
@@ -528,321 +524,33 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
528 if (err) 524 if (err)
529 goto err_remove_gpio; 525 goto err_remove_gpio;
530 526
531 dev_info(&bus->dev, "Rev.%d touchscreen, irq %d\n", 527 return ts;
532 revid >> 8, bus->irq);
533
534 return 0;
535 528
536err_remove_gpio: 529err_remove_gpio:
537 ad7879_gpio_remove(&bus->dev); 530 ad7879_gpio_remove(ts);
538err_remove_attr: 531err_remove_attr:
539 sysfs_remove_group(&bus->dev.kobj, &ad7879_attr_group); 532 sysfs_remove_group(&dev->kobj, &ad7879_attr_group);
540err_free_irq: 533err_free_irq:
541 free_irq(bus->irq, ts); 534 free_irq(ts->irq, ts);
542err_free_mem: 535err_free_mem:
543 input_free_device(input_dev); 536 input_free_device(input_dev);
544 537 kfree(ts);
545 return err; 538err_out:
539 return ERR_PTR(err);
546} 540}
541EXPORT_SYMBOL(ad7879_probe);
547 542
548static int __devexit ad7879_destroy(bus_device *bus, struct ad7879 *ts) 543void ad7879_remove(struct ad7879 *ts)
549{ 544{
550 ad7879_gpio_remove(&bus->dev); 545 ad7879_gpio_remove(ts);
551 ad7879_disable(ts); 546 ad7879_disable(ts);
552 sysfs_remove_group(&ts->bus->dev.kobj, &ad7879_attr_group); 547 sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group);
553 free_irq(ts->bus->irq, ts); 548 free_irq(ts->irq, ts);
554 input_unregister_device(ts->input); 549 input_unregister_device(ts->input);
555 dev_dbg(&bus->dev, "unregistered touchscreen\n");
556
557 return 0;
558}
559
560#ifdef CONFIG_PM
561static int ad7879_suspend(bus_device *bus, pm_message_t message)
562{
563 struct ad7879 *ts = dev_get_drvdata(&bus->dev);
564
565 ad7879_disable(ts);
566
567 return 0;
568}
569
570static int ad7879_resume(bus_device *bus)
571{
572 struct ad7879 *ts = dev_get_drvdata(&bus->dev);
573
574 ad7879_enable(ts);
575
576 return 0;
577}
578#else
579#define ad7879_suspend NULL
580#define ad7879_resume NULL
581#endif
582
583#if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
584#define MAX_SPI_FREQ_HZ 5000000
585#define AD7879_CMD_MAGIC 0xE000
586#define AD7879_CMD_READ (1 << 10)
587#define AD7879_WRITECMD(reg) (AD7879_CMD_MAGIC | (reg & 0xF))
588#define AD7879_READCMD(reg) (AD7879_CMD_MAGIC | AD7879_CMD_READ | (reg & 0xF))
589
590struct ser_req {
591 u16 command;
592 u16 data;
593 struct spi_message msg;
594 struct spi_transfer xfer[2];
595};
596
597/*
598 * ad7879_read/write are only used for initial setup and for sysfs controls.
599 * The main traffic is done in ad7879_collect().
600 */
601
602static int ad7879_read(struct spi_device *spi, u8 reg)
603{
604 struct ser_req *req;
605 int status, ret;
606
607 req = kzalloc(sizeof *req, GFP_KERNEL);
608 if (!req)
609 return -ENOMEM;
610
611 spi_message_init(&req->msg);
612
613 req->command = (u16) AD7879_READCMD(reg);
614 req->xfer[0].tx_buf = &req->command;
615 req->xfer[0].len = 2;
616
617 req->xfer[1].rx_buf = &req->data;
618 req->xfer[1].len = 2;
619
620 spi_message_add_tail(&req->xfer[0], &req->msg);
621 spi_message_add_tail(&req->xfer[1], &req->msg);
622
623 status = spi_sync(spi, &req->msg);
624 ret = status ? : req->data;
625
626 kfree(req);
627
628 return ret;
629}
630
631static int ad7879_write(struct spi_device *spi, u8 reg, u16 val)
632{
633 struct ser_req *req;
634 int status;
635
636 req = kzalloc(sizeof *req, GFP_KERNEL);
637 if (!req)
638 return -ENOMEM;
639
640 spi_message_init(&req->msg);
641
642 req->command = (u16) AD7879_WRITECMD(reg);
643 req->xfer[0].tx_buf = &req->command;
644 req->xfer[0].len = 2;
645
646 req->data = val;
647 req->xfer[1].tx_buf = &req->data;
648 req->xfer[1].len = 2;
649
650 spi_message_add_tail(&req->xfer[0], &req->msg);
651 spi_message_add_tail(&req->xfer[1], &req->msg);
652
653 status = spi_sync(spi, &req->msg);
654
655 kfree(req);
656
657 return status;
658}
659
660static void ad7879_collect(struct ad7879 *ts)
661{
662 int status = spi_sync(ts->bus, &ts->msg);
663
664 if (status)
665 dev_err(&ts->bus->dev, "spi_sync --> %d\n", status);
666}
667
668static void ad7879_setup_ts_def_msg(struct ad7879 *ts)
669{
670 struct spi_message *m;
671 int i;
672
673 ts->cmd = (u16) AD7879_READCMD(AD7879_REG_XPLUS);
674
675 m = &ts->msg;
676 spi_message_init(m);
677 ts->xfer[0].tx_buf = &ts->cmd;
678 ts->xfer[0].len = 2;
679
680 spi_message_add_tail(&ts->xfer[0], m);
681
682 for (i = 0; i < AD7879_NR_SENSE; i++) {
683 ts->xfer[i + 1].rx_buf = &ts->conversion_data[i];
684 ts->xfer[i + 1].len = 2;
685 spi_message_add_tail(&ts->xfer[i + 1], m);
686 }
687}
688
689static int __devinit ad7879_probe(struct spi_device *spi)
690{
691 struct ad7879 *ts;
692 int error;
693
694 /* don't exceed max specified SPI CLK frequency */
695 if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
696 dev_err(&spi->dev, "SPI CLK %d Hz?\n", spi->max_speed_hz);
697 return -EINVAL;
698 }
699
700 ts = kzalloc(sizeof(struct ad7879), GFP_KERNEL);
701 if (!ts)
702 return -ENOMEM;
703
704 dev_set_drvdata(&spi->dev, ts);
705 ts->bus = spi;
706
707 ad7879_setup_ts_def_msg(ts);
708
709 error = ad7879_construct(spi, ts);
710 if (error) {
711 dev_set_drvdata(&spi->dev, NULL);
712 kfree(ts);
713 }
714
715 return error;
716}
717
718static int __devexit ad7879_remove(struct spi_device *spi)
719{
720 struct ad7879 *ts = dev_get_drvdata(&spi->dev);
721
722 ad7879_destroy(spi, ts);
723 dev_set_drvdata(&spi->dev, NULL);
724 kfree(ts); 550 kfree(ts);
725
726 return 0;
727} 551}
728 552EXPORT_SYMBOL(ad7879_remove);
729static struct spi_driver ad7879_driver = {
730 .driver = {
731 .name = "ad7879",
732 .bus = &spi_bus_type,
733 .owner = THIS_MODULE,
734 },
735 .probe = ad7879_probe,
736 .remove = __devexit_p(ad7879_remove),
737 .suspend = ad7879_suspend,
738 .resume = ad7879_resume,
739};
740
741static int __init ad7879_init(void)
742{
743 return spi_register_driver(&ad7879_driver);
744}
745module_init(ad7879_init);
746
747static void __exit ad7879_exit(void)
748{
749 spi_unregister_driver(&ad7879_driver);
750}
751module_exit(ad7879_exit);
752
753#elif defined(CONFIG_TOUCHSCREEN_AD7879_I2C) || defined(CONFIG_TOUCHSCREEN_AD7879_I2C_MODULE)
754
755/* All registers are word-sized.
756 * AD7879 uses a high-byte first convention.
757 */
758static int ad7879_read(struct i2c_client *client, u8 reg)
759{
760 return swab16(i2c_smbus_read_word_data(client, reg));
761}
762
763static int ad7879_write(struct i2c_client *client, u8 reg, u16 val)
764{
765 return i2c_smbus_write_word_data(client, reg, swab16(val));
766}
767
768static void ad7879_collect(struct ad7879 *ts)
769{
770 int i;
771
772 for (i = 0; i < AD7879_NR_SENSE; i++)
773 ts->conversion_data[i] = ad7879_read(ts->bus,
774 AD7879_REG_XPLUS + i);
775}
776
777static int __devinit ad7879_probe(struct i2c_client *client,
778 const struct i2c_device_id *id)
779{
780 struct ad7879 *ts;
781 int error;
782
783 if (!i2c_check_functionality(client->adapter,
784 I2C_FUNC_SMBUS_WORD_DATA)) {
785 dev_err(&client->dev, "SMBUS Word Data not Supported\n");
786 return -EIO;
787 }
788
789 ts = kzalloc(sizeof(struct ad7879), GFP_KERNEL);
790 if (!ts)
791 return -ENOMEM;
792
793 i2c_set_clientdata(client, ts);
794 ts->bus = client;
795
796 error = ad7879_construct(client, ts);
797 if (error)
798 kfree(ts);
799
800 return error;
801}
802
803static int __devexit ad7879_remove(struct i2c_client *client)
804{
805 struct ad7879 *ts = dev_get_drvdata(&client->dev);
806
807 ad7879_destroy(client, ts);
808 kfree(ts);
809
810 return 0;
811}
812
813static const struct i2c_device_id ad7879_id[] = {
814 { "ad7879", 0 },
815 { "ad7889", 0 },
816 { }
817};
818MODULE_DEVICE_TABLE(i2c, ad7879_id);
819
820static struct i2c_driver ad7879_driver = {
821 .driver = {
822 .name = "ad7879",
823 .owner = THIS_MODULE,
824 },
825 .probe = ad7879_probe,
826 .remove = __devexit_p(ad7879_remove),
827 .suspend = ad7879_suspend,
828 .resume = ad7879_resume,
829 .id_table = ad7879_id,
830};
831
832static int __init ad7879_init(void)
833{
834 return i2c_add_driver(&ad7879_driver);
835}
836module_init(ad7879_init);
837
838static void __exit ad7879_exit(void)
839{
840 i2c_del_driver(&ad7879_driver);
841}
842module_exit(ad7879_exit);
843#endif
844 553
845MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 554MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
846MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver"); 555MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
847MODULE_LICENSE("GPL"); 556MODULE_LICENSE("GPL");
848MODULE_ALIAS("spi:ad7879");
diff --git a/drivers/input/touchscreen/ad7879.h b/drivers/input/touchscreen/ad7879.h
new file mode 100644
index 000000000000..169f155db3b9
--- /dev/null
+++ b/drivers/input/touchscreen/ad7879.h
@@ -0,0 +1,30 @@
1/*
2 * AD7879/AD7889 touchscreen (bus interfaces)
3 *
4 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
7 */
8
9#ifndef _AD7879_H_
10#define _AD7879_H_
11
12#include <linux/types.h>
13
14struct ad7879;
15struct device;
16
17struct ad7879_bus_ops {
18 u16 bustype;
19 int (*read)(struct device *dev, u8 reg);
20 int (*multi_read)(struct device *dev, u8 first_reg, u8 count, u16 *buf);
21 int (*write)(struct device *dev, u8 reg, u16 val);
22};
23
24void ad7879_disable(struct ad7879 *);
25void ad7879_enable(struct ad7879 *);
26struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned irq,
27 const struct ad7879_bus_ops *bops);
28void ad7879_remove(struct ad7879 *);
29
30#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-28 15:50:59 -0500