Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Elo serial touchscreen driver | |
3 | * | |
4 | * Copyright (c) 2004 Vojtech Pavlik | |
5 | */ | |
6 | ||
7 | /* | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License version 2 as published by | |
10 | * the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | /* | |
14 | * This driver can handle serial Elo touchscreens using either the Elo standard | |
15 | * 'E271-2210' 10-byte protocol, Elo legacy 'E281A-4002' 6-byte protocol, Elo | |
16 | * legacy 'E271-140' 4-byte protocol and Elo legacy 'E261-280' 3-byte protocol. | |
17 | */ | |
18 | ||
19 | #include <linux/errno.h> | |
20 | #include <linux/kernel.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/slab.h> | |
23 | #include <linux/input.h> | |
24 | #include <linux/serio.h> | |
fae3006e | 25 | #include <linux/ctype.h> |
1da177e4 LT |
26 | |
27 | #define DRIVER_DESC "Elo serial touchscreen driver" | |
28 | ||
29 | MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>"); | |
30 | MODULE_DESCRIPTION(DRIVER_DESC); | |
31 | MODULE_LICENSE("GPL"); | |
32 | ||
33 | /* | |
34 | * Definitions & global arrays. | |
35 | */ | |
36 | ||
1ce316ef SJ |
37 | #define ELO_MAX_LENGTH 10 |
38 | ||
fae3006e SJ |
39 | #define ELO10_PACKET_LEN 8 |
40 | #define ELO10_TOUCH 0x03 | |
41 | #define ELO10_PRESSURE 0x80 | |
42 | ||
1ce316ef SJ |
43 | #define ELO10_LEAD_BYTE 'U' |
44 | ||
fae3006e SJ |
45 | #define ELO10_ID_CMD 'i' |
46 | ||
1ce316ef | 47 | #define ELO10_TOUCH_PACKET 'T' |
fae3006e SJ |
48 | #define ELO10_ACK_PACKET 'A' |
49 | #define ELI10_ID_PACKET 'I' | |
1da177e4 | 50 | |
1da177e4 LT |
51 | /* |
52 | * Per-touchscreen data. | |
53 | */ | |
54 | ||
55 | struct elo { | |
eca1ed19 | 56 | struct input_dev *dev; |
1da177e4 | 57 | struct serio *serio; |
fae3006e SJ |
58 | struct mutex cmd_mutex; |
59 | struct completion cmd_done; | |
1da177e4 LT |
60 | int id; |
61 | int idx; | |
fae3006e | 62 | unsigned char expected_packet; |
1da177e4 LT |
63 | unsigned char csum; |
64 | unsigned char data[ELO_MAX_LENGTH]; | |
fae3006e | 65 | unsigned char response[ELO10_PACKET_LEN]; |
1da177e4 LT |
66 | char phys[32]; |
67 | }; | |
68 | ||
7d12e780 | 69 | static void elo_process_data_10(struct elo *elo, unsigned char data) |
1da177e4 | 70 | { |
eca1ed19 | 71 | struct input_dev *dev = elo->dev; |
1da177e4 | 72 | |
1ce316ef | 73 | elo->data[elo->idx] = data; |
1da177e4 | 74 | |
8cab9ba1 DT |
75 | switch (elo->idx++) { |
76 | case 0: | |
77 | elo->csum = 0xaa; | |
78 | if (data != ELO10_LEAD_BYTE) { | |
79 | dev_dbg(&elo->serio->dev, | |
80 | "unsynchronized data: 0x%02x\n", data); | |
1da177e4 | 81 | elo->idx = 0; |
8cab9ba1 DT |
82 | } |
83 | break; | |
84 | ||
85 | case 9: | |
86 | elo->idx = 0; | |
87 | if (data != elo->csum) { | |
88 | dev_dbg(&elo->serio->dev, | |
89 | "bad checksum: 0x%02x, expected 0x%02x\n", | |
90 | data, elo->csum); | |
91 | break; | |
92 | } | |
93 | if (elo->data[1] != elo->expected_packet) { | |
94 | if (elo->data[1] != ELO10_TOUCH_PACKET) | |
95 | dev_dbg(&elo->serio->dev, | |
96 | "unexpected packet: 0x%02x\n", | |
97 | elo->data[1]); | |
1da177e4 | 98 | break; |
8cab9ba1 DT |
99 | } |
100 | if (likely(elo->data[1] == ELO10_TOUCH_PACKET)) { | |
101 | input_report_abs(dev, ABS_X, (elo->data[4] << 8) | elo->data[3]); | |
102 | input_report_abs(dev, ABS_Y, (elo->data[6] << 8) | elo->data[5]); | |
103 | if (elo->data[2] & ELO10_PRESSURE) | |
104 | input_report_abs(dev, ABS_PRESSURE, | |
105 | (elo->data[8] << 8) | elo->data[7]); | |
106 | input_report_key(dev, BTN_TOUCH, elo->data[2] & ELO10_TOUCH); | |
107 | input_sync(dev); | |
108 | } else if (elo->data[1] == ELO10_ACK_PACKET) { | |
109 | if (elo->data[2] == '0') | |
110 | elo->expected_packet = ELO10_TOUCH_PACKET; | |
111 | complete(&elo->cmd_done); | |
112 | } else { | |
113 | memcpy(elo->response, &elo->data[1], ELO10_PACKET_LEN); | |
114 | elo->expected_packet = ELO10_ACK_PACKET; | |
115 | } | |
116 | break; | |
1da177e4 | 117 | } |
1ce316ef | 118 | elo->csum += data; |
1da177e4 LT |
119 | } |
120 | ||
7d12e780 | 121 | static void elo_process_data_6(struct elo *elo, unsigned char data) |
1da177e4 | 122 | { |
eca1ed19 | 123 | struct input_dev *dev = elo->dev; |
1da177e4 LT |
124 | |
125 | elo->data[elo->idx] = data; | |
126 | ||
127 | switch (elo->idx++) { | |
128 | ||
8cab9ba1 DT |
129 | case 0: |
130 | if ((data & 0xc0) != 0xc0) | |
131 | elo->idx = 0; | |
132 | break; | |
1da177e4 | 133 | |
8cab9ba1 DT |
134 | case 1: |
135 | if ((data & 0xc0) != 0x80) | |
136 | elo->idx = 0; | |
137 | break; | |
1da177e4 | 138 | |
8cab9ba1 DT |
139 | case 2: |
140 | if ((data & 0xc0) != 0x40) | |
141 | elo->idx = 0; | |
142 | break; | |
1da177e4 | 143 | |
8cab9ba1 DT |
144 | case 3: |
145 | if (data & 0xc0) { | |
146 | elo->idx = 0; | |
1da177e4 | 147 | break; |
8cab9ba1 | 148 | } |
1da177e4 | 149 | |
8cab9ba1 DT |
150 | input_report_abs(dev, ABS_X, ((elo->data[0] & 0x3f) << 6) | (elo->data[1] & 0x3f)); |
151 | input_report_abs(dev, ABS_Y, ((elo->data[2] & 0x3f) << 6) | (elo->data[3] & 0x3f)); | |
1da177e4 | 152 | |
8cab9ba1 DT |
153 | if (elo->id == 2) { |
154 | input_report_key(dev, BTN_TOUCH, 1); | |
1da177e4 LT |
155 | input_sync(dev); |
156 | elo->idx = 0; | |
8cab9ba1 DT |
157 | } |
158 | ||
159 | break; | |
160 | ||
161 | case 4: | |
162 | if (data) { | |
163 | input_sync(dev); | |
164 | elo->idx = 0; | |
165 | } | |
166 | break; | |
167 | ||
168 | case 5: | |
169 | if ((data & 0xf0) == 0) { | |
170 | input_report_abs(dev, ABS_PRESSURE, elo->data[5]); | |
171 | input_report_key(dev, BTN_TOUCH, !!elo->data[5]); | |
172 | } | |
173 | input_sync(dev); | |
174 | elo->idx = 0; | |
175 | break; | |
1da177e4 LT |
176 | } |
177 | } | |
178 | ||
7d12e780 | 179 | static void elo_process_data_3(struct elo *elo, unsigned char data) |
1da177e4 | 180 | { |
eca1ed19 | 181 | struct input_dev *dev = elo->dev; |
1da177e4 LT |
182 | |
183 | elo->data[elo->idx] = data; | |
184 | ||
185 | switch (elo->idx++) { | |
186 | ||
8cab9ba1 DT |
187 | case 0: |
188 | if ((data & 0x7f) != 0x01) | |
1da177e4 | 189 | elo->idx = 0; |
8cab9ba1 DT |
190 | break; |
191 | case 2: | |
192 | input_report_key(dev, BTN_TOUCH, !(elo->data[1] & 0x80)); | |
193 | input_report_abs(dev, ABS_X, elo->data[1]); | |
194 | input_report_abs(dev, ABS_Y, elo->data[2]); | |
195 | input_sync(dev); | |
196 | elo->idx = 0; | |
197 | break; | |
1da177e4 LT |
198 | } |
199 | } | |
200 | ||
201 | static irqreturn_t elo_interrupt(struct serio *serio, | |
7d12e780 | 202 | unsigned char data, unsigned int flags) |
1da177e4 | 203 | { |
1ce316ef | 204 | struct elo *elo = serio_get_drvdata(serio); |
1da177e4 | 205 | |
8cab9ba1 DT |
206 | switch (elo->id) { |
207 | case 0: | |
208 | elo_process_data_10(elo, data); | |
209 | break; | |
210 | ||
211 | case 1: | |
212 | case 2: | |
213 | elo_process_data_6(elo, data); | |
214 | break; | |
215 | ||
216 | case 3: | |
217 | elo_process_data_3(elo, data); | |
218 | break; | |
1da177e4 LT |
219 | } |
220 | ||
221 | return IRQ_HANDLED; | |
222 | } | |
223 | ||
fae3006e SJ |
224 | static int elo_command_10(struct elo *elo, unsigned char *packet) |
225 | { | |
226 | int rc = -1; | |
227 | int i; | |
228 | unsigned char csum = 0xaa + ELO10_LEAD_BYTE; | |
229 | ||
230 | mutex_lock(&elo->cmd_mutex); | |
231 | ||
232 | serio_pause_rx(elo->serio); | |
233 | elo->expected_packet = toupper(packet[0]); | |
234 | init_completion(&elo->cmd_done); | |
235 | serio_continue_rx(elo->serio); | |
236 | ||
237 | if (serio_write(elo->serio, ELO10_LEAD_BYTE)) | |
238 | goto out; | |
239 | ||
240 | for (i = 0; i < ELO10_PACKET_LEN; i++) { | |
241 | csum += packet[i]; | |
242 | if (serio_write(elo->serio, packet[i])) | |
243 | goto out; | |
244 | } | |
245 | ||
246 | if (serio_write(elo->serio, csum)) | |
247 | goto out; | |
248 | ||
249 | wait_for_completion_timeout(&elo->cmd_done, HZ); | |
250 | ||
251 | if (elo->expected_packet == ELO10_TOUCH_PACKET) { | |
252 | /* We are back in reporting mode, the command was ACKed */ | |
253 | memcpy(packet, elo->response, ELO10_PACKET_LEN); | |
254 | rc = 0; | |
255 | } | |
256 | ||
257 | out: | |
258 | mutex_unlock(&elo->cmd_mutex); | |
259 | return rc; | |
260 | } | |
261 | ||
262 | static int elo_setup_10(struct elo *elo) | |
263 | { | |
264 | static const char *elo_types[] = { "Accu", "Dura", "Intelli", "Carroll" }; | |
265 | struct input_dev *dev = elo->dev; | |
266 | unsigned char packet[ELO10_PACKET_LEN] = { ELO10_ID_CMD }; | |
267 | ||
268 | if (elo_command_10(elo, packet)) | |
269 | return -1; | |
270 | ||
271 | dev->id.version = (packet[5] << 8) | packet[4]; | |
272 | ||
273 | input_set_abs_params(dev, ABS_X, 96, 4000, 0, 0); | |
274 | input_set_abs_params(dev, ABS_Y, 96, 4000, 0, 0); | |
275 | if (packet[3] & ELO10_PRESSURE) | |
276 | input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0); | |
277 | ||
8cab9ba1 DT |
278 | dev_info(&elo->serio->dev, |
279 | "%sTouch touchscreen, fw: %02x.%02x, features: 0x%02x, controller: 0x%02x\n", | |
280 | elo_types[(packet[1] -'0') & 0x03], | |
281 | packet[5], packet[4], packet[3], packet[7]); | |
fae3006e SJ |
282 | |
283 | return 0; | |
284 | } | |
285 | ||
1da177e4 LT |
286 | /* |
287 | * elo_disconnect() is the opposite of elo_connect() | |
288 | */ | |
289 | ||
290 | static void elo_disconnect(struct serio *serio) | |
291 | { | |
6b50d8b8 | 292 | struct elo *elo = serio_get_drvdata(serio); |
1da177e4 | 293 | |
6b50d8b8 | 294 | input_get_device(elo->dev); |
eca1ed19 | 295 | input_unregister_device(elo->dev); |
1da177e4 LT |
296 | serio_close(serio); |
297 | serio_set_drvdata(serio, NULL); | |
6b50d8b8 | 298 | input_put_device(elo->dev); |
1da177e4 LT |
299 | kfree(elo); |
300 | } | |
301 | ||
302 | /* | |
303 | * elo_connect() is the routine that is called when someone adds a | |
304 | * new serio device that supports Gunze protocol and registers it as | |
305 | * an input device. | |
306 | */ | |
307 | ||
308 | static int elo_connect(struct serio *serio, struct serio_driver *drv) | |
309 | { | |
310 | struct elo *elo; | |
eca1ed19 | 311 | struct input_dev *input_dev; |
1da177e4 LT |
312 | int err; |
313 | ||
eca1ed19 DT |
314 | elo = kzalloc(sizeof(struct elo), GFP_KERNEL); |
315 | input_dev = input_allocate_device(); | |
316 | if (!elo || !input_dev) { | |
317 | err = -ENOMEM; | |
6b50d8b8 | 318 | goto fail1; |
eca1ed19 | 319 | } |
1da177e4 | 320 | |
eca1ed19 DT |
321 | elo->serio = serio; |
322 | elo->id = serio->id.id; | |
323 | elo->dev = input_dev; | |
fae3006e SJ |
324 | elo->expected_packet = ELO10_TOUCH_PACKET; |
325 | mutex_init(&elo->cmd_mutex); | |
326 | init_completion(&elo->cmd_done); | |
eca1ed19 | 327 | snprintf(elo->phys, sizeof(elo->phys), "%s/input0", serio->phys); |
1da177e4 | 328 | |
eca1ed19 DT |
329 | input_dev->name = "Elo Serial TouchScreen"; |
330 | input_dev->phys = elo->phys; | |
331 | input_dev->id.bustype = BUS_RS232; | |
332 | input_dev->id.vendor = SERIO_ELO; | |
333 | input_dev->id.product = elo->id; | |
334 | input_dev->id.version = 0x0100; | |
a5394fb0 | 335 | input_dev->dev.parent = &serio->dev; |
1da177e4 | 336 | |
7b19ada2 JS |
337 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
338 | input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
1da177e4 | 339 | |
fae3006e SJ |
340 | serio_set_drvdata(serio, elo); |
341 | err = serio_open(serio, drv); | |
342 | if (err) | |
343 | goto fail2; | |
344 | ||
1da177e4 LT |
345 | switch (elo->id) { |
346 | ||
8cab9ba1 DT |
347 | case 0: /* 10-byte protocol */ |
348 | if (elo_setup_10(elo)) | |
349 | goto fail3; | |
fae3006e | 350 | |
8cab9ba1 | 351 | break; |
de1b963a | 352 | |
8cab9ba1 DT |
353 | case 1: /* 6-byte protocol */ |
354 | input_set_abs_params(input_dev, ABS_PRESSURE, 0, 15, 0, 0); | |
1da177e4 | 355 | |
8cab9ba1 DT |
356 | case 2: /* 4-byte protocol */ |
357 | input_set_abs_params(input_dev, ABS_X, 96, 4000, 0, 0); | |
358 | input_set_abs_params(input_dev, ABS_Y, 96, 4000, 0, 0); | |
359 | break; | |
1da177e4 | 360 | |
8cab9ba1 DT |
361 | case 3: /* 3-byte protocol */ |
362 | input_set_abs_params(input_dev, ABS_X, 0, 255, 0, 0); | |
363 | input_set_abs_params(input_dev, ABS_Y, 0, 255, 0, 0); | |
364 | break; | |
1da177e4 LT |
365 | } |
366 | ||
6b50d8b8 DT |
367 | err = input_register_device(elo->dev); |
368 | if (err) | |
369 | goto fail3; | |
1da177e4 LT |
370 | |
371 | return 0; | |
eca1ed19 | 372 | |
6b50d8b8 DT |
373 | fail3: serio_close(serio); |
374 | fail2: serio_set_drvdata(serio, NULL); | |
375 | fail1: input_free_device(input_dev); | |
eca1ed19 DT |
376 | kfree(elo); |
377 | return err; | |
1da177e4 LT |
378 | } |
379 | ||
380 | /* | |
381 | * The serio driver structure. | |
382 | */ | |
383 | ||
4f8d5241 | 384 | static const struct serio_device_id elo_serio_ids[] = { |
1da177e4 LT |
385 | { |
386 | .type = SERIO_RS232, | |
387 | .proto = SERIO_ELO, | |
388 | .id = SERIO_ANY, | |
389 | .extra = SERIO_ANY, | |
390 | }, | |
391 | { 0 } | |
392 | }; | |
393 | ||
394 | MODULE_DEVICE_TABLE(serio, elo_serio_ids); | |
395 | ||
396 | static struct serio_driver elo_drv = { | |
397 | .driver = { | |
398 | .name = "elo", | |
399 | }, | |
400 | .description = DRIVER_DESC, | |
401 | .id_table = elo_serio_ids, | |
402 | .interrupt = elo_interrupt, | |
403 | .connect = elo_connect, | |
404 | .disconnect = elo_disconnect, | |
405 | }; | |
406 | ||
65ac9f7a | 407 | module_serio_driver(elo_drv); |