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