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