Commit | Line | Data |
---|---|---|
9ca5bf50 SV |
1 | /* |
2 | * Driver for ELAN eKTF2127 i2c touchscreen controller | |
3 | * | |
4 | * For this driver the layout of the Chipone icn8318 i2c | |
5 | * touchscreencontroller is used. | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * Author: | |
13 | * Michel Verlaan <michel.verl@gmail.com> | |
14 | * Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com> | |
15 | * | |
16 | * Original chipone_icn8318 driver: | |
17 | * Hans de Goede <hdegoede@redhat.com> | |
18 | */ | |
19 | ||
20 | #include <linux/gpio/consumer.h> | |
21 | #include <linux/interrupt.h> | |
22 | #include <linux/i2c.h> | |
23 | #include <linux/input.h> | |
24 | #include <linux/input/mt.h> | |
25 | #include <linux/input/touchscreen.h> | |
26 | #include <linux/module.h> | |
27 | #include <linux/of.h> | |
28 | #include <linux/delay.h> | |
29 | ||
30 | /* Packet header defines (first byte of data send / received) */ | |
31 | #define EKTF2127_NOISE 0x40 | |
32 | #define EKTF2127_RESPONSE 0x52 | |
33 | #define EKTF2127_REQUEST 0x53 | |
34 | #define EKTF2127_HELLO 0x55 | |
35 | #define EKTF2127_REPORT 0x5d | |
36 | #define EKTF2127_CALIB_DONE 0x66 | |
37 | ||
38 | /* Register defines (second byte of data send / received) */ | |
39 | #define EKTF2127_ENV_NOISY 0x41 | |
40 | #define EKTF2127_HEIGHT 0x60 | |
41 | #define EKTF2127_WIDTH 0x63 | |
42 | ||
43 | /* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */ | |
44 | #define EKTF2127_TOUCH_REPORT_SIZE 21 | |
45 | #define EKTF2127_MAX_TOUCHES 5 | |
46 | ||
47 | struct ektf2127_ts { | |
48 | struct i2c_client *client; | |
49 | struct input_dev *input; | |
50 | struct gpio_desc *power_gpios; | |
51 | struct touchscreen_properties prop; | |
52 | }; | |
53 | ||
249d1bb2 | 54 | static void ektf2127_parse_coordinates(const u8 *buf, unsigned int touch_count, |
9ca5bf50 SV |
55 | struct input_mt_pos *touches) |
56 | { | |
57 | int index = 0; | |
58 | int i; | |
59 | ||
60 | for (i = 0; i < touch_count; i++) { | |
61 | index = 2 + i * 3; | |
62 | ||
63 | touches[i].x = (buf[index] & 0x0f); | |
64 | touches[i].x <<= 8; | |
65 | touches[i].x |= buf[index + 2]; | |
66 | ||
67 | touches[i].y = (buf[index] & 0xf0); | |
68 | touches[i].y <<= 4; | |
69 | touches[i].y |= buf[index + 1]; | |
70 | } | |
71 | } | |
72 | ||
73 | static void ektf2127_report_event(struct ektf2127_ts *ts, const u8 *buf) | |
74 | { | |
75 | struct input_mt_pos touches[EKTF2127_MAX_TOUCHES]; | |
76 | int slots[EKTF2127_MAX_TOUCHES]; | |
77 | unsigned int touch_count, i; | |
78 | ||
79 | touch_count = buf[1] & 0x07; | |
80 | if (touch_count > EKTF2127_MAX_TOUCHES) { | |
81 | dev_err(&ts->client->dev, | |
82 | "Too many touches %d > %d\n", | |
83 | touch_count, EKTF2127_MAX_TOUCHES); | |
84 | touch_count = EKTF2127_MAX_TOUCHES; | |
85 | } | |
86 | ||
87 | ektf2127_parse_coordinates(buf, touch_count, touches); | |
88 | input_mt_assign_slots(ts->input, slots, touches, | |
89 | touch_count, 0); | |
90 | ||
91 | for (i = 0; i < touch_count; i++) { | |
92 | input_mt_slot(ts->input, slots[i]); | |
93 | input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true); | |
94 | touchscreen_report_pos(ts->input, &ts->prop, | |
95 | touches[i].x, touches[i].y, true); | |
96 | } | |
97 | ||
98 | input_mt_sync_frame(ts->input); | |
99 | input_sync(ts->input); | |
100 | } | |
101 | ||
102 | static irqreturn_t ektf2127_irq(int irq, void *dev_id) | |
103 | { | |
104 | struct ektf2127_ts *ts = dev_id; | |
105 | struct device *dev = &ts->client->dev; | |
106 | char buf[EKTF2127_TOUCH_REPORT_SIZE]; | |
107 | int ret; | |
108 | ||
109 | ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE); | |
110 | if (ret != EKTF2127_TOUCH_REPORT_SIZE) { | |
111 | dev_err(dev, "Error reading touch data: %d\n", ret); | |
112 | goto out; | |
113 | } | |
114 | ||
115 | switch (buf[0]) { | |
116 | case EKTF2127_REPORT: | |
117 | ektf2127_report_event(ts, buf); | |
118 | break; | |
119 | ||
120 | case EKTF2127_NOISE: | |
121 | if (buf[1] == EKTF2127_ENV_NOISY) | |
122 | dev_dbg(dev, "Environment is electrically noisy\n"); | |
123 | break; | |
124 | ||
125 | case EKTF2127_HELLO: | |
126 | case EKTF2127_CALIB_DONE: | |
127 | break; | |
128 | ||
129 | default: | |
130 | dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]); | |
131 | break; | |
132 | } | |
133 | ||
134 | out: | |
135 | return IRQ_HANDLED; | |
136 | } | |
137 | ||
138 | static int ektf2127_start(struct input_dev *dev) | |
139 | { | |
140 | struct ektf2127_ts *ts = input_get_drvdata(dev); | |
141 | ||
142 | enable_irq(ts->client->irq); | |
143 | gpiod_set_value_cansleep(ts->power_gpios, 1); | |
144 | ||
145 | return 0; | |
146 | } | |
147 | ||
148 | static void ektf2127_stop(struct input_dev *dev) | |
149 | { | |
150 | struct ektf2127_ts *ts = input_get_drvdata(dev); | |
151 | ||
152 | disable_irq(ts->client->irq); | |
153 | gpiod_set_value_cansleep(ts->power_gpios, 0); | |
154 | } | |
155 | ||
979987de | 156 | static int __maybe_unused ektf2127_suspend(struct device *dev) |
9ca5bf50 SV |
157 | { |
158 | struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev)); | |
159 | ||
160 | mutex_lock(&ts->input->mutex); | |
161 | if (ts->input->users) | |
162 | ektf2127_stop(ts->input); | |
163 | mutex_unlock(&ts->input->mutex); | |
164 | ||
165 | return 0; | |
166 | } | |
167 | ||
979987de | 168 | static int __maybe_unused ektf2127_resume(struct device *dev) |
9ca5bf50 SV |
169 | { |
170 | struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev)); | |
171 | ||
172 | mutex_lock(&ts->input->mutex); | |
173 | if (ts->input->users) | |
174 | ektf2127_start(ts->input); | |
175 | mutex_unlock(&ts->input->mutex); | |
176 | ||
177 | return 0; | |
178 | } | |
179 | ||
180 | static SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend, | |
181 | ektf2127_resume); | |
182 | ||
183 | static int ektf2127_query_dimension(struct i2c_client *client, bool width) | |
184 | { | |
185 | struct device *dev = &client->dev; | |
186 | const char *what = width ? "width" : "height"; | |
187 | u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT; | |
188 | u8 buf[4]; | |
189 | int ret; | |
190 | int error; | |
191 | ||
192 | /* Request dimension */ | |
193 | buf[0] = EKTF2127_REQUEST; | |
194 | buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT; | |
195 | buf[2] = 0x00; | |
196 | buf[3] = 0x00; | |
197 | ret = i2c_master_send(client, buf, sizeof(buf)); | |
198 | if (ret != sizeof(buf)) { | |
199 | error = ret < 0 ? ret : -EIO; | |
200 | dev_err(dev, "Failed to request %s: %d\n", what, error); | |
201 | return error; | |
202 | } | |
203 | ||
204 | msleep(20); | |
205 | ||
206 | /* Read response */ | |
207 | ret = i2c_master_recv(client, buf, sizeof(buf)); | |
208 | if (ret != sizeof(buf)) { | |
209 | error = ret < 0 ? ret : -EIO; | |
210 | dev_err(dev, "Failed to receive %s data: %d\n", what, error); | |
211 | return error; | |
212 | } | |
213 | ||
214 | if (buf[0] != EKTF2127_RESPONSE || buf[1] != what_code) { | |
215 | dev_err(dev, "Unexpected %s data: %#02x %#02x\n", | |
216 | what, buf[0], buf[1]); | |
217 | return -EIO; | |
218 | } | |
219 | ||
220 | return (((buf[3] & 0xf0) << 4) | buf[2]) - 1; | |
221 | } | |
222 | ||
223 | static int ektf2127_probe(struct i2c_client *client, | |
224 | const struct i2c_device_id *id) | |
225 | { | |
226 | struct device *dev = &client->dev; | |
227 | struct ektf2127_ts *ts; | |
228 | struct input_dev *input; | |
229 | u8 buf[4]; | |
230 | int max_x, max_y; | |
231 | int error; | |
232 | ||
233 | if (!client->irq) { | |
234 | dev_err(dev, "Error no irq specified\n"); | |
235 | return -EINVAL; | |
236 | } | |
237 | ||
238 | ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); | |
239 | if (!ts) | |
240 | return -ENOMEM; | |
241 | ||
242 | /* This requests the gpio *and* turns on the touchscreen controller */ | |
243 | ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH); | |
244 | if (IS_ERR(ts->power_gpios)) { | |
245 | error = PTR_ERR(ts->power_gpios); | |
246 | if (error != -EPROBE_DEFER) | |
247 | dev_err(dev, "Error getting power gpio: %d\n", error); | |
248 | return error; | |
249 | } | |
250 | ||
251 | input = devm_input_allocate_device(dev); | |
252 | if (!input) | |
253 | return -ENOMEM; | |
254 | ||
255 | input->name = client->name; | |
256 | input->id.bustype = BUS_I2C; | |
257 | input->open = ektf2127_start; | |
258 | input->close = ektf2127_stop; | |
259 | ||
260 | ts->client = client; | |
261 | ||
262 | /* Read hello (ignore result, depends on initial power state) */ | |
263 | msleep(20); | |
264 | i2c_master_recv(ts->client, buf, sizeof(buf)); | |
265 | ||
266 | /* Read resolution from chip */ | |
267 | max_x = ektf2127_query_dimension(client, true); | |
268 | if (max_x < 0) | |
269 | return max_x; | |
270 | ||
271 | max_y = ektf2127_query_dimension(client, false); | |
272 | if (max_y < 0) | |
273 | return max_y; | |
274 | ||
275 | input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0); | |
276 | input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0); | |
277 | touchscreen_parse_properties(input, true, &ts->prop); | |
278 | ||
279 | error = input_mt_init_slots(input, EKTF2127_MAX_TOUCHES, | |
280 | INPUT_MT_DIRECT | | |
281 | INPUT_MT_DROP_UNUSED | | |
282 | INPUT_MT_TRACK); | |
283 | if (error) | |
284 | return error; | |
285 | ||
286 | ts->input = input; | |
287 | input_set_drvdata(input, ts); | |
288 | ||
289 | error = devm_request_threaded_irq(dev, client->irq, | |
290 | NULL, ektf2127_irq, | |
291 | IRQF_ONESHOT, client->name, ts); | |
292 | if (error) { | |
293 | dev_err(dev, "Error requesting irq: %d\n", error); | |
294 | return error; | |
295 | } | |
296 | ||
297 | /* Stop device till opened */ | |
298 | ektf2127_stop(ts->input); | |
299 | ||
300 | error = input_register_device(input); | |
301 | if (error) | |
302 | return error; | |
303 | ||
304 | i2c_set_clientdata(client, ts); | |
305 | ||
306 | return 0; | |
307 | } | |
308 | ||
309 | #ifdef CONFIG_OF | |
310 | static const struct of_device_id ektf2127_of_match[] = { | |
311 | { .compatible = "elan,ektf2127" }, | |
312 | {} | |
313 | }; | |
314 | MODULE_DEVICE_TABLE(of, ektf2127_of_match); | |
315 | #endif | |
316 | ||
317 | static const struct i2c_device_id ektf2127_i2c_id[] = { | |
318 | { "ektf2127", 0 }, | |
319 | {} | |
320 | }; | |
321 | MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id); | |
322 | ||
323 | static struct i2c_driver ektf2127_driver = { | |
324 | .driver = { | |
325 | .name = "elan_ektf2127", | |
326 | .pm = &ektf2127_pm_ops, | |
327 | .of_match_table = of_match_ptr(ektf2127_of_match), | |
328 | }, | |
329 | .probe = ektf2127_probe, | |
330 | .id_table = ektf2127_i2c_id, | |
331 | }; | |
332 | module_i2c_driver(ektf2127_driver); | |
333 | ||
334 | MODULE_DESCRIPTION("ELAN eKTF2127 I2C Touchscreen Driver"); | |
335 | MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij"); | |
336 | MODULE_LICENSE("GPL"); |