1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Touch Screen driver for EETI's I2C connected touch screen panels |
4 | * Copyright (c) 2009,2018 Daniel Mack <daniel@zonque.org> |
5 | * |
6 | * See EETI's software guide for the protocol specification: |
7 | * http://home.eeti.com.tw/documentation.html |
8 | * |
9 | * Based on migor_ts.c |
10 | * Copyright (c) 2008 Magnus Damm |
11 | * Copyright (c) 2007 Ujjwal Pande <ujjwal@kenati.com> |
12 | */ |
13 | |
14 | #include <linux/module.h> |
15 | #include <linux/kernel.h> |
16 | #include <linux/input.h> |
17 | #include <linux/input/touchscreen.h> |
18 | #include <linux/interrupt.h> |
19 | #include <linux/i2c.h> |
20 | #include <linux/timer.h> |
21 | #include <linux/gpio/consumer.h> |
22 | #include <linux/of.h> |
23 | #include <linux/slab.h> |
24 | #include <asm/unaligned.h> |
25 | |
26 | struct eeti_ts { |
27 | struct i2c_client *client; |
28 | struct input_dev *input; |
29 | struct gpio_desc *attn_gpio; |
30 | struct touchscreen_properties props; |
31 | struct mutex mutex; |
32 | bool running; |
33 | }; |
34 | |
35 | #define EETI_TS_BITDEPTH (11) |
36 | #define EETI_MAXVAL ((1 << (EETI_TS_BITDEPTH + 1)) - 1) |
37 | |
38 | #define REPORT_BIT_PRESSED BIT(0) |
39 | #define REPORT_BIT_AD0 BIT(1) |
40 | #define REPORT_BIT_AD1 BIT(2) |
41 | #define REPORT_BIT_HAS_PRESSURE BIT(6) |
42 | #define REPORT_RES_BITS(v) (((v) >> 1) + EETI_TS_BITDEPTH) |
43 | |
44 | static void eeti_ts_report_event(struct eeti_ts *eeti, u8 *buf) |
45 | { |
46 | unsigned int res; |
47 | u16 x, y; |
48 | |
49 | res = REPORT_RES_BITS(buf[0] & (REPORT_BIT_AD0 | REPORT_BIT_AD1)); |
50 | |
51 | x = get_unaligned_be16(p: &buf[1]); |
52 | y = get_unaligned_be16(p: &buf[3]); |
53 | |
54 | /* fix the range to 11 bits */ |
55 | x >>= res - EETI_TS_BITDEPTH; |
56 | y >>= res - EETI_TS_BITDEPTH; |
57 | |
58 | if (buf[0] & REPORT_BIT_HAS_PRESSURE) |
59 | input_report_abs(dev: eeti->input, ABS_PRESSURE, value: buf[5]); |
60 | |
61 | touchscreen_report_pos(input: eeti->input, prop: &eeti->props, x, y, multitouch: false); |
62 | input_report_key(dev: eeti->input, BTN_TOUCH, value: buf[0] & REPORT_BIT_PRESSED); |
63 | input_sync(dev: eeti->input); |
64 | } |
65 | |
66 | static int eeti_ts_read(struct eeti_ts *eeti) |
67 | { |
68 | int len, error; |
69 | char buf[6]; |
70 | |
71 | len = i2c_master_recv(client: eeti->client, buf, count: sizeof(buf)); |
72 | if (len != sizeof(buf)) { |
73 | error = len < 0 ? len : -EIO; |
74 | dev_err(&eeti->client->dev, |
75 | "failed to read touchscreen data: %d\n" , |
76 | error); |
77 | return error; |
78 | } |
79 | |
80 | /* Motion packet */ |
81 | if (buf[0] & 0x80) |
82 | eeti_ts_report_event(eeti, buf); |
83 | |
84 | return 0; |
85 | } |
86 | |
87 | static irqreturn_t eeti_ts_isr(int irq, void *dev_id) |
88 | { |
89 | struct eeti_ts *eeti = dev_id; |
90 | int error; |
91 | |
92 | mutex_lock(&eeti->mutex); |
93 | |
94 | do { |
95 | /* |
96 | * If we have attention GPIO, trust it. Otherwise we'll read |
97 | * once and exit. We assume that in this case we are using |
98 | * level triggered interrupt and it will get raised again |
99 | * if/when there is more data. |
100 | */ |
101 | if (eeti->attn_gpio && |
102 | !gpiod_get_value_cansleep(desc: eeti->attn_gpio)) { |
103 | break; |
104 | } |
105 | |
106 | error = eeti_ts_read(eeti); |
107 | if (error) |
108 | break; |
109 | |
110 | } while (eeti->running && eeti->attn_gpio); |
111 | |
112 | mutex_unlock(lock: &eeti->mutex); |
113 | return IRQ_HANDLED; |
114 | } |
115 | |
116 | static void eeti_ts_start(struct eeti_ts *eeti) |
117 | { |
118 | mutex_lock(&eeti->mutex); |
119 | |
120 | eeti->running = true; |
121 | enable_irq(irq: eeti->client->irq); |
122 | |
123 | /* |
124 | * Kick the controller in case we are using edge interrupt and |
125 | * we missed our edge while interrupt was disabled. We expect |
126 | * the attention GPIO to be wired in this case. |
127 | */ |
128 | if (eeti->attn_gpio && gpiod_get_value_cansleep(desc: eeti->attn_gpio)) |
129 | eeti_ts_read(eeti); |
130 | |
131 | mutex_unlock(lock: &eeti->mutex); |
132 | } |
133 | |
134 | static void eeti_ts_stop(struct eeti_ts *eeti) |
135 | { |
136 | /* |
137 | * Not locking here, just setting a flag and expect that the |
138 | * interrupt thread will notice the flag eventually. |
139 | */ |
140 | eeti->running = false; |
141 | wmb(); |
142 | disable_irq(irq: eeti->client->irq); |
143 | } |
144 | |
145 | static int eeti_ts_open(struct input_dev *dev) |
146 | { |
147 | struct eeti_ts *eeti = input_get_drvdata(dev); |
148 | |
149 | eeti_ts_start(eeti); |
150 | |
151 | return 0; |
152 | } |
153 | |
154 | static void eeti_ts_close(struct input_dev *dev) |
155 | { |
156 | struct eeti_ts *eeti = input_get_drvdata(dev); |
157 | |
158 | eeti_ts_stop(eeti); |
159 | } |
160 | |
161 | static int eeti_ts_probe(struct i2c_client *client) |
162 | { |
163 | struct device *dev = &client->dev; |
164 | struct eeti_ts *eeti; |
165 | struct input_dev *input; |
166 | int error; |
167 | |
168 | /* |
169 | * In contrast to what's described in the datasheet, there seems |
170 | * to be no way of probing the presence of that device using I2C |
171 | * commands. So we need to blindly believe it is there, and wait |
172 | * for interrupts to occur. |
173 | */ |
174 | |
175 | eeti = devm_kzalloc(dev, size: sizeof(*eeti), GFP_KERNEL); |
176 | if (!eeti) { |
177 | dev_err(dev, "failed to allocate driver data\n" ); |
178 | return -ENOMEM; |
179 | } |
180 | |
181 | mutex_init(&eeti->mutex); |
182 | |
183 | input = devm_input_allocate_device(dev); |
184 | if (!input) { |
185 | dev_err(dev, "Failed to allocate input device.\n" ); |
186 | return -ENOMEM; |
187 | } |
188 | |
189 | input_set_capability(dev: input, EV_KEY, BTN_TOUCH); |
190 | |
191 | input_set_abs_params(dev: input, ABS_X, min: 0, EETI_MAXVAL, fuzz: 0, flat: 0); |
192 | input_set_abs_params(dev: input, ABS_Y, min: 0, EETI_MAXVAL, fuzz: 0, flat: 0); |
193 | input_set_abs_params(dev: input, ABS_PRESSURE, min: 0, max: 0xff, fuzz: 0, flat: 0); |
194 | |
195 | touchscreen_parse_properties(input, multitouch: false, prop: &eeti->props); |
196 | |
197 | input->name = client->name; |
198 | input->id.bustype = BUS_I2C; |
199 | input->open = eeti_ts_open; |
200 | input->close = eeti_ts_close; |
201 | |
202 | eeti->client = client; |
203 | eeti->input = input; |
204 | |
205 | eeti->attn_gpio = devm_gpiod_get_optional(dev, con_id: "attn" , flags: GPIOD_IN); |
206 | if (IS_ERR(ptr: eeti->attn_gpio)) |
207 | return PTR_ERR(ptr: eeti->attn_gpio); |
208 | |
209 | i2c_set_clientdata(client, data: eeti); |
210 | input_set_drvdata(dev: input, data: eeti); |
211 | |
212 | error = devm_request_threaded_irq(dev, irq: client->irq, |
213 | NULL, thread_fn: eeti_ts_isr, |
214 | IRQF_ONESHOT, |
215 | devname: client->name, dev_id: eeti); |
216 | if (error) { |
217 | dev_err(dev, "Unable to request touchscreen IRQ: %d\n" , |
218 | error); |
219 | return error; |
220 | } |
221 | |
222 | /* |
223 | * Disable the device for now. It will be enabled once the |
224 | * input device is opened. |
225 | */ |
226 | eeti_ts_stop(eeti); |
227 | |
228 | error = input_register_device(input); |
229 | if (error) |
230 | return error; |
231 | |
232 | return 0; |
233 | } |
234 | |
235 | static int eeti_ts_suspend(struct device *dev) |
236 | { |
237 | struct i2c_client *client = to_i2c_client(dev); |
238 | struct eeti_ts *eeti = i2c_get_clientdata(client); |
239 | struct input_dev *input_dev = eeti->input; |
240 | |
241 | mutex_lock(&input_dev->mutex); |
242 | |
243 | if (input_device_enabled(dev: input_dev)) |
244 | eeti_ts_stop(eeti); |
245 | |
246 | mutex_unlock(lock: &input_dev->mutex); |
247 | |
248 | if (device_may_wakeup(dev: &client->dev)) |
249 | enable_irq_wake(irq: client->irq); |
250 | |
251 | return 0; |
252 | } |
253 | |
254 | static int eeti_ts_resume(struct device *dev) |
255 | { |
256 | struct i2c_client *client = to_i2c_client(dev); |
257 | struct eeti_ts *eeti = i2c_get_clientdata(client); |
258 | struct input_dev *input_dev = eeti->input; |
259 | |
260 | if (device_may_wakeup(dev: &client->dev)) |
261 | disable_irq_wake(irq: client->irq); |
262 | |
263 | mutex_lock(&input_dev->mutex); |
264 | |
265 | if (input_device_enabled(dev: input_dev)) |
266 | eeti_ts_start(eeti); |
267 | |
268 | mutex_unlock(lock: &input_dev->mutex); |
269 | |
270 | return 0; |
271 | } |
272 | |
273 | static DEFINE_SIMPLE_DEV_PM_OPS(eeti_ts_pm, eeti_ts_suspend, eeti_ts_resume); |
274 | |
275 | static const struct i2c_device_id eeti_ts_id[] = { |
276 | { "eeti_ts" , 0 }, |
277 | { } |
278 | }; |
279 | MODULE_DEVICE_TABLE(i2c, eeti_ts_id); |
280 | |
281 | #ifdef CONFIG_OF |
282 | static const struct of_device_id of_eeti_ts_match[] = { |
283 | { .compatible = "eeti,exc3000-i2c" , }, |
284 | { } |
285 | }; |
286 | #endif |
287 | |
288 | static struct i2c_driver eeti_ts_driver = { |
289 | .driver = { |
290 | .name = "eeti_ts" , |
291 | .pm = pm_sleep_ptr(&eeti_ts_pm), |
292 | .of_match_table = of_match_ptr(of_eeti_ts_match), |
293 | }, |
294 | .probe = eeti_ts_probe, |
295 | .id_table = eeti_ts_id, |
296 | }; |
297 | |
298 | module_i2c_driver(eeti_ts_driver); |
299 | |
300 | MODULE_DESCRIPTION("EETI Touchscreen driver" ); |
301 | MODULE_AUTHOR("Daniel Mack <daniel@zonque.org>" ); |
302 | MODULE_LICENSE("GPL" ); |
303 | |