Commit | Line | Data |
---|---|---|
10494dce DM |
1 | /* |
2 | * Touch Screen driver for EETI's I2C connected touch screen panels | |
3 | * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de> | |
4 | * | |
5 | * See EETI's software guide for the protocol specification: | |
6 | * http://home.eeti.com.tw/web20/eg/guide.htm | |
7 | * | |
8 | * Based on migor_ts.c | |
9 | * Copyright (c) 2008 Magnus Damm | |
10 | * Copyright (c) 2007 Ujjwal Pande <ujjwal@kenati.com> | |
11 | * | |
12 | * This file is free software; you can redistribute it and/or | |
13 | * modify it under the terms of the GNU General Public | |
14 | * License as published by the Free Software Foundation; either | |
15 | * version 2 of the License, or (at your option) any later version. | |
16 | * | |
17 | * This file is distributed in the hope that it will be useful, | |
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 | * General Public License for more details. | |
21 | * | |
22 | * You should have received a copy of the GNU General Public | |
23 | * License along with this library; if not, write to the Free Software | |
24 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
25 | */ | |
26 | ||
27 | #include <linux/module.h> | |
28 | #include <linux/moduleparam.h> | |
29 | #include <linux/kernel.h> | |
30 | #include <linux/input.h> | |
31 | #include <linux/interrupt.h> | |
32 | #include <linux/i2c.h> | |
33 | #include <linux/timer.h> | |
34 | #include <linux/gpio.h> | |
25a70e38 | 35 | #include <linux/input/eeti_ts.h> |
5a0e3ad6 | 36 | #include <linux/slab.h> |
10494dce | 37 | |
90ab5ee9 | 38 | static bool flip_x; |
10494dce DM |
39 | module_param(flip_x, bool, 0644); |
40 | MODULE_PARM_DESC(flip_x, "flip x coordinate"); | |
41 | ||
90ab5ee9 | 42 | static bool flip_y; |
10494dce DM |
43 | module_param(flip_y, bool, 0644); |
44 | MODULE_PARM_DESC(flip_y, "flip y coordinate"); | |
45 | ||
46 | struct eeti_ts_priv { | |
47 | struct i2c_client *client; | |
48 | struct input_dev *input; | |
49 | struct work_struct work; | |
50 | struct mutex mutex; | |
4eef6cbf | 51 | int irq_gpio, irq, irq_active_high; |
10494dce DM |
52 | }; |
53 | ||
54 | #define EETI_TS_BITDEPTH (11) | |
55 | #define EETI_MAXVAL ((1 << (EETI_TS_BITDEPTH + 1)) - 1) | |
56 | ||
57 | #define REPORT_BIT_PRESSED (1 << 0) | |
58 | #define REPORT_BIT_AD0 (1 << 1) | |
59 | #define REPORT_BIT_AD1 (1 << 2) | |
60 | #define REPORT_BIT_HAS_PRESSURE (1 << 6) | |
61 | #define REPORT_RES_BITS(v) (((v) >> 1) + EETI_TS_BITDEPTH) | |
62 | ||
25a70e38 DM |
63 | static inline int eeti_ts_irq_active(struct eeti_ts_priv *priv) |
64 | { | |
4eef6cbf | 65 | return gpio_get_value(priv->irq_gpio) == priv->irq_active_high; |
25a70e38 DM |
66 | } |
67 | ||
10494dce DM |
68 | static void eeti_ts_read(struct work_struct *work) |
69 | { | |
70 | char buf[6]; | |
71 | unsigned int x, y, res, pressed, to = 100; | |
72 | struct eeti_ts_priv *priv = | |
73 | container_of(work, struct eeti_ts_priv, work); | |
74 | ||
75 | mutex_lock(&priv->mutex); | |
76 | ||
25a70e38 | 77 | while (eeti_ts_irq_active(priv) && --to) |
10494dce DM |
78 | i2c_master_recv(priv->client, buf, sizeof(buf)); |
79 | ||
80 | if (!to) { | |
81 | dev_err(&priv->client->dev, | |
82 | "unable to clear IRQ - line stuck?\n"); | |
83 | goto out; | |
84 | } | |
85 | ||
86 | /* drop non-report packets */ | |
87 | if (!(buf[0] & 0x80)) | |
88 | goto out; | |
89 | ||
90 | pressed = buf[0] & REPORT_BIT_PRESSED; | |
91 | res = REPORT_RES_BITS(buf[0] & (REPORT_BIT_AD0 | REPORT_BIT_AD1)); | |
92 | x = buf[2] | (buf[1] << 8); | |
93 | y = buf[4] | (buf[3] << 8); | |
94 | ||
95 | /* fix the range to 11 bits */ | |
96 | x >>= res - EETI_TS_BITDEPTH; | |
97 | y >>= res - EETI_TS_BITDEPTH; | |
98 | ||
99 | if (flip_x) | |
100 | x = EETI_MAXVAL - x; | |
101 | ||
102 | if (flip_y) | |
103 | y = EETI_MAXVAL - y; | |
104 | ||
105 | if (buf[0] & REPORT_BIT_HAS_PRESSURE) | |
106 | input_report_abs(priv->input, ABS_PRESSURE, buf[5]); | |
107 | ||
108 | input_report_abs(priv->input, ABS_X, x); | |
109 | input_report_abs(priv->input, ABS_Y, y); | |
110 | input_report_key(priv->input, BTN_TOUCH, !!pressed); | |
111 | input_sync(priv->input); | |
112 | ||
113 | out: | |
114 | mutex_unlock(&priv->mutex); | |
115 | } | |
116 | ||
117 | static irqreturn_t eeti_ts_isr(int irq, void *dev_id) | |
118 | { | |
119 | struct eeti_ts_priv *priv = dev_id; | |
120 | ||
121 | /* postpone I2C transactions as we are atomic */ | |
122 | schedule_work(&priv->work); | |
123 | ||
124 | return IRQ_HANDLED; | |
125 | } | |
126 | ||
7fbef0d1 | 127 | static void eeti_ts_start(struct eeti_ts_priv *priv) |
10494dce | 128 | { |
10494dce DM |
129 | enable_irq(priv->irq); |
130 | ||
131 | /* Read the events once to arm the IRQ */ | |
132 | eeti_ts_read(&priv->work); | |
7fbef0d1 DM |
133 | } |
134 | ||
135 | static void eeti_ts_stop(struct eeti_ts_priv *priv) | |
136 | { | |
137 | disable_irq(priv->irq); | |
138 | cancel_work_sync(&priv->work); | |
139 | } | |
140 | ||
141 | static int eeti_ts_open(struct input_dev *dev) | |
142 | { | |
143 | struct eeti_ts_priv *priv = input_get_drvdata(dev); | |
144 | ||
145 | eeti_ts_start(priv); | |
10494dce DM |
146 | |
147 | return 0; | |
148 | } | |
149 | ||
150 | static void eeti_ts_close(struct input_dev *dev) | |
151 | { | |
152 | struct eeti_ts_priv *priv = input_get_drvdata(dev); | |
153 | ||
7fbef0d1 | 154 | eeti_ts_stop(priv); |
10494dce DM |
155 | } |
156 | ||
5298cc4c | 157 | static int eeti_ts_probe(struct i2c_client *client, |
10494dce DM |
158 | const struct i2c_device_id *idp) |
159 | { | |
c838cb3d | 160 | struct eeti_ts_platform_data *pdata = dev_get_platdata(&client->dev); |
10494dce DM |
161 | struct eeti_ts_priv *priv; |
162 | struct input_dev *input; | |
25a70e38 | 163 | unsigned int irq_flags; |
10494dce DM |
164 | int err = -ENOMEM; |
165 | ||
7fbef0d1 DM |
166 | /* |
167 | * In contrast to what's described in the datasheet, there seems | |
10494dce DM |
168 | * to be no way of probing the presence of that device using I2C |
169 | * commands. So we need to blindly believe it is there, and wait | |
7fbef0d1 DM |
170 | * for interrupts to occur. |
171 | */ | |
10494dce DM |
172 | |
173 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); | |
174 | if (!priv) { | |
175 | dev_err(&client->dev, "failed to allocate driver data\n"); | |
176 | goto err0; | |
177 | } | |
178 | ||
179 | mutex_init(&priv->mutex); | |
180 | input = input_allocate_device(); | |
181 | ||
182 | if (!input) { | |
183 | dev_err(&client->dev, "Failed to allocate input device.\n"); | |
184 | goto err1; | |
185 | } | |
186 | ||
187 | input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); | |
188 | input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
189 | ||
190 | input_set_abs_params(input, ABS_X, 0, EETI_MAXVAL, 0, 0); | |
191 | input_set_abs_params(input, ABS_Y, 0, EETI_MAXVAL, 0, 0); | |
192 | input_set_abs_params(input, ABS_PRESSURE, 0, 0xff, 0, 0); | |
193 | ||
194 | input->name = client->name; | |
195 | input->id.bustype = BUS_I2C; | |
196 | input->dev.parent = &client->dev; | |
197 | input->open = eeti_ts_open; | |
198 | input->close = eeti_ts_close; | |
199 | ||
200 | priv->client = client; | |
201 | priv->input = input; | |
4eef6cbf AB |
202 | priv->irq_gpio = pdata->irq_gpio; |
203 | priv->irq = gpio_to_irq(pdata->irq_gpio); | |
10494dce | 204 | |
4eef6cbf AB |
205 | err = gpio_request_one(pdata->irq_gpio, GPIOF_IN, client->name); |
206 | if (err < 0) | |
207 | goto err1; | |
25a70e38 | 208 | |
80e3e532 | 209 | priv->irq_active_high = pdata->irq_active_high; |
25a70e38 DM |
210 | |
211 | irq_flags = priv->irq_active_high ? | |
212 | IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; | |
213 | ||
10494dce DM |
214 | INIT_WORK(&priv->work, eeti_ts_read); |
215 | i2c_set_clientdata(client, priv); | |
216 | input_set_drvdata(input, priv); | |
217 | ||
218 | err = input_register_device(input); | |
219 | if (err) | |
4eef6cbf | 220 | goto err2; |
10494dce | 221 | |
25a70e38 | 222 | err = request_irq(priv->irq, eeti_ts_isr, irq_flags, |
10494dce DM |
223 | client->name, priv); |
224 | if (err) { | |
225 | dev_err(&client->dev, "Unable to request touchscreen IRQ.\n"); | |
4eef6cbf | 226 | goto err3; |
10494dce DM |
227 | } |
228 | ||
7fbef0d1 DM |
229 | /* |
230 | * Disable the device for now. It will be enabled once the | |
231 | * input device is opened. | |
232 | */ | |
233 | eeti_ts_stop(priv); | |
10494dce DM |
234 | |
235 | device_init_wakeup(&client->dev, 0); | |
236 | return 0; | |
237 | ||
4eef6cbf | 238 | err3: |
10494dce DM |
239 | input_unregister_device(input); |
240 | input = NULL; /* so we dont try to free it below */ | |
4eef6cbf AB |
241 | err2: |
242 | gpio_free(pdata->irq_gpio); | |
10494dce DM |
243 | err1: |
244 | input_free_device(input); | |
10494dce DM |
245 | kfree(priv); |
246 | err0: | |
247 | return err; | |
248 | } | |
249 | ||
e2619cf7 | 250 | static int eeti_ts_remove(struct i2c_client *client) |
10494dce DM |
251 | { |
252 | struct eeti_ts_priv *priv = i2c_get_clientdata(client); | |
253 | ||
254 | free_irq(priv->irq, priv); | |
7fbef0d1 DM |
255 | /* |
256 | * eeti_ts_stop() leaves IRQ disabled. We need to re-enable it | |
257 | * so that device still works if we reload the driver. | |
258 | */ | |
259 | enable_irq(priv->irq); | |
260 | ||
10494dce | 261 | input_unregister_device(priv->input); |
10494dce DM |
262 | kfree(priv); |
263 | ||
264 | return 0; | |
265 | } | |
266 | ||
02b6a58b | 267 | static int __maybe_unused eeti_ts_suspend(struct device *dev) |
10494dce | 268 | { |
85012fff | 269 | struct i2c_client *client = to_i2c_client(dev); |
10494dce | 270 | struct eeti_ts_priv *priv = i2c_get_clientdata(client); |
7fbef0d1 DM |
271 | struct input_dev *input_dev = priv->input; |
272 | ||
273 | mutex_lock(&input_dev->mutex); | |
274 | ||
275 | if (input_dev->users) | |
276 | eeti_ts_stop(priv); | |
277 | ||
278 | mutex_unlock(&input_dev->mutex); | |
10494dce DM |
279 | |
280 | if (device_may_wakeup(&client->dev)) | |
281 | enable_irq_wake(priv->irq); | |
282 | ||
283 | return 0; | |
284 | } | |
285 | ||
02b6a58b | 286 | static int __maybe_unused eeti_ts_resume(struct device *dev) |
10494dce | 287 | { |
85012fff | 288 | struct i2c_client *client = to_i2c_client(dev); |
10494dce | 289 | struct eeti_ts_priv *priv = i2c_get_clientdata(client); |
7fbef0d1 | 290 | struct input_dev *input_dev = priv->input; |
10494dce DM |
291 | |
292 | if (device_may_wakeup(&client->dev)) | |
293 | disable_irq_wake(priv->irq); | |
294 | ||
7fbef0d1 DM |
295 | mutex_lock(&input_dev->mutex); |
296 | ||
297 | if (input_dev->users) | |
298 | eeti_ts_start(priv); | |
299 | ||
300 | mutex_unlock(&input_dev->mutex); | |
301 | ||
10494dce DM |
302 | return 0; |
303 | } | |
85012fff MB |
304 | |
305 | static SIMPLE_DEV_PM_OPS(eeti_ts_pm, eeti_ts_suspend, eeti_ts_resume); | |
10494dce DM |
306 | |
307 | static const struct i2c_device_id eeti_ts_id[] = { | |
308 | { "eeti_ts", 0 }, | |
309 | { } | |
310 | }; | |
311 | MODULE_DEVICE_TABLE(i2c, eeti_ts_id); | |
312 | ||
313 | static struct i2c_driver eeti_ts_driver = { | |
314 | .driver = { | |
315 | .name = "eeti_ts", | |
85012fff | 316 | .pm = &eeti_ts_pm, |
10494dce DM |
317 | }, |
318 | .probe = eeti_ts_probe, | |
1cb0aa88 | 319 | .remove = eeti_ts_remove, |
10494dce DM |
320 | .id_table = eeti_ts_id, |
321 | }; | |
322 | ||
1b92c1cf | 323 | module_i2c_driver(eeti_ts_driver); |
10494dce DM |
324 | |
325 | MODULE_DESCRIPTION("EETI Touchscreen driver"); | |
326 | MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>"); | |
327 | MODULE_LICENSE("GPL"); |