1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Penmount serial touchscreen driver |
4 | * |
5 | * Copyright (c) 2006 Rick Koch <n1gp@hotmail.com> |
6 | * Copyright (c) 2011 John Sung <penmount.touch@gmail.com> |
7 | * |
8 | * Based on ELO driver (drivers/input/touchscreen/elo.c) |
9 | * Copyright (c) 2004 Vojtech Pavlik |
10 | */ |
11 | |
12 | |
13 | #include <linux/errno.h> |
14 | #include <linux/kernel.h> |
15 | #include <linux/module.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/input.h> |
18 | #include <linux/input/mt.h> |
19 | #include <linux/serio.h> |
20 | |
21 | #define DRIVER_DESC "PenMount serial touchscreen driver" |
22 | |
23 | MODULE_AUTHOR("Rick Koch <n1gp@hotmail.com>" ); |
24 | MODULE_AUTHOR("John Sung <penmount.touch@gmail.com>" ); |
25 | MODULE_DESCRIPTION(DRIVER_DESC); |
26 | MODULE_LICENSE("GPL" ); |
27 | |
28 | /* |
29 | * Definitions & global arrays. |
30 | */ |
31 | |
32 | #define PM_MAX_LENGTH 6 |
33 | #define PM_MAX_MTSLOT 16 |
34 | #define PM_3000_MTSLOT 2 |
35 | #define PM_6250_MTSLOT 12 |
36 | |
37 | /* |
38 | * Multi-touch slot |
39 | */ |
40 | |
41 | struct mt_slot { |
42 | unsigned short x, y; |
43 | bool active; /* is the touch valid? */ |
44 | }; |
45 | |
46 | /* |
47 | * Per-touchscreen data. |
48 | */ |
49 | |
50 | struct pm { |
51 | struct input_dev *dev; |
52 | struct serio *serio; |
53 | int idx; |
54 | unsigned char data[PM_MAX_LENGTH]; |
55 | char phys[32]; |
56 | unsigned char packetsize; |
57 | unsigned char maxcontacts; |
58 | struct mt_slot slots[PM_MAX_MTSLOT]; |
59 | void (*parse_packet)(struct pm *); |
60 | }; |
61 | |
62 | /* |
63 | * pm_mtevent() sends mt events and also emulates pointer movement |
64 | */ |
65 | |
66 | static void pm_mtevent(struct pm *pm, struct input_dev *input) |
67 | { |
68 | int i; |
69 | |
70 | for (i = 0; i < pm->maxcontacts; ++i) { |
71 | input_mt_slot(dev: input, slot: i); |
72 | input_mt_report_slot_state(dev: input, MT_TOOL_FINGER, |
73 | active: pm->slots[i].active); |
74 | if (pm->slots[i].active) { |
75 | input_event(dev: input, EV_ABS, ABS_MT_POSITION_X, value: pm->slots[i].x); |
76 | input_event(dev: input, EV_ABS, ABS_MT_POSITION_Y, value: pm->slots[i].y); |
77 | } |
78 | } |
79 | |
80 | input_mt_report_pointer_emulation(dev: input, use_count: true); |
81 | input_sync(dev: input); |
82 | } |
83 | |
84 | /* |
85 | * pm_checkpacket() checks if data packet is valid |
86 | */ |
87 | |
88 | static bool pm_checkpacket(unsigned char *packet) |
89 | { |
90 | int total = 0; |
91 | int i; |
92 | |
93 | for (i = 0; i < 5; i++) |
94 | total += packet[i]; |
95 | |
96 | return packet[5] == (unsigned char)~(total & 0xff); |
97 | } |
98 | |
99 | static void pm_parse_9000(struct pm *pm) |
100 | { |
101 | struct input_dev *dev = pm->dev; |
102 | |
103 | if ((pm->data[0] & 0x80) && pm->packetsize == ++pm->idx) { |
104 | input_report_abs(dev, ABS_X, value: pm->data[1] * 128 + pm->data[2]); |
105 | input_report_abs(dev, ABS_Y, value: pm->data[3] * 128 + pm->data[4]); |
106 | input_report_key(dev, BTN_TOUCH, value: !!(pm->data[0] & 0x40)); |
107 | input_sync(dev); |
108 | pm->idx = 0; |
109 | } |
110 | } |
111 | |
112 | static void pm_parse_6000(struct pm *pm) |
113 | { |
114 | struct input_dev *dev = pm->dev; |
115 | |
116 | if ((pm->data[0] & 0xbf) == 0x30 && pm->packetsize == ++pm->idx) { |
117 | if (pm_checkpacket(packet: pm->data)) { |
118 | input_report_abs(dev, ABS_X, |
119 | value: pm->data[2] * 256 + pm->data[1]); |
120 | input_report_abs(dev, ABS_Y, |
121 | value: pm->data[4] * 256 + pm->data[3]); |
122 | input_report_key(dev, BTN_TOUCH, value: pm->data[0] & 0x40); |
123 | input_sync(dev); |
124 | } |
125 | pm->idx = 0; |
126 | } |
127 | } |
128 | |
129 | static void pm_parse_3000(struct pm *pm) |
130 | { |
131 | struct input_dev *dev = pm->dev; |
132 | |
133 | if ((pm->data[0] & 0xce) == 0x40 && pm->packetsize == ++pm->idx) { |
134 | if (pm_checkpacket(packet: pm->data)) { |
135 | int slotnum = pm->data[0] & 0x0f; |
136 | pm->slots[slotnum].active = pm->data[0] & 0x30; |
137 | pm->slots[slotnum].x = pm->data[2] * 256 + pm->data[1]; |
138 | pm->slots[slotnum].y = pm->data[4] * 256 + pm->data[3]; |
139 | pm_mtevent(pm, input: dev); |
140 | } |
141 | pm->idx = 0; |
142 | } |
143 | } |
144 | |
145 | static void pm_parse_6250(struct pm *pm) |
146 | { |
147 | struct input_dev *dev = pm->dev; |
148 | |
149 | if ((pm->data[0] & 0xb0) == 0x30 && pm->packetsize == ++pm->idx) { |
150 | if (pm_checkpacket(packet: pm->data)) { |
151 | int slotnum = pm->data[0] & 0x0f; |
152 | pm->slots[slotnum].active = pm->data[0] & 0x40; |
153 | pm->slots[slotnum].x = pm->data[2] * 256 + pm->data[1]; |
154 | pm->slots[slotnum].y = pm->data[4] * 256 + pm->data[3]; |
155 | pm_mtevent(pm, input: dev); |
156 | } |
157 | pm->idx = 0; |
158 | } |
159 | } |
160 | |
161 | static irqreturn_t pm_interrupt(struct serio *serio, |
162 | unsigned char data, unsigned int flags) |
163 | { |
164 | struct pm *pm = serio_get_drvdata(serio); |
165 | |
166 | pm->data[pm->idx] = data; |
167 | |
168 | pm->parse_packet(pm); |
169 | |
170 | return IRQ_HANDLED; |
171 | } |
172 | |
173 | /* |
174 | * pm_disconnect() is the opposite of pm_connect() |
175 | */ |
176 | |
177 | static void pm_disconnect(struct serio *serio) |
178 | { |
179 | struct pm *pm = serio_get_drvdata(serio); |
180 | |
181 | serio_close(serio); |
182 | |
183 | input_unregister_device(pm->dev); |
184 | kfree(objp: pm); |
185 | |
186 | serio_set_drvdata(serio, NULL); |
187 | } |
188 | |
189 | /* |
190 | * pm_connect() is the routine that is called when someone adds a |
191 | * new serio device that supports PenMount protocol and registers it as |
192 | * an input device. |
193 | */ |
194 | |
195 | static int pm_connect(struct serio *serio, struct serio_driver *drv) |
196 | { |
197 | struct pm *pm; |
198 | struct input_dev *input_dev; |
199 | int max_x, max_y; |
200 | int err; |
201 | |
202 | pm = kzalloc(size: sizeof(struct pm), GFP_KERNEL); |
203 | input_dev = input_allocate_device(); |
204 | if (!pm || !input_dev) { |
205 | err = -ENOMEM; |
206 | goto fail1; |
207 | } |
208 | |
209 | pm->serio = serio; |
210 | pm->dev = input_dev; |
211 | snprintf(buf: pm->phys, size: sizeof(pm->phys), fmt: "%s/input0" , serio->phys); |
212 | pm->maxcontacts = 1; |
213 | |
214 | input_dev->name = "PenMount Serial TouchScreen" ; |
215 | input_dev->phys = pm->phys; |
216 | input_dev->id.bustype = BUS_RS232; |
217 | input_dev->id.vendor = SERIO_PENMOUNT; |
218 | input_dev->id.product = 0; |
219 | input_dev->id.version = 0x0100; |
220 | input_dev->dev.parent = &serio->dev; |
221 | |
222 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
223 | input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); |
224 | |
225 | switch (serio->id.id) { |
226 | default: |
227 | case 0: |
228 | pm->packetsize = 5; |
229 | pm->parse_packet = pm_parse_9000; |
230 | input_dev->id.product = 0x9000; |
231 | max_x = max_y = 0x3ff; |
232 | break; |
233 | |
234 | case 1: |
235 | pm->packetsize = 6; |
236 | pm->parse_packet = pm_parse_6000; |
237 | input_dev->id.product = 0x6000; |
238 | max_x = max_y = 0x3ff; |
239 | break; |
240 | |
241 | case 2: |
242 | pm->packetsize = 6; |
243 | pm->parse_packet = pm_parse_3000; |
244 | input_dev->id.product = 0x3000; |
245 | max_x = max_y = 0x7ff; |
246 | pm->maxcontacts = PM_3000_MTSLOT; |
247 | break; |
248 | |
249 | case 3: |
250 | pm->packetsize = 6; |
251 | pm->parse_packet = pm_parse_6250; |
252 | input_dev->id.product = 0x6250; |
253 | max_x = max_y = 0x3ff; |
254 | pm->maxcontacts = PM_6250_MTSLOT; |
255 | break; |
256 | } |
257 | |
258 | input_set_abs_params(dev: pm->dev, ABS_X, min: 0, max: max_x, fuzz: 0, flat: 0); |
259 | input_set_abs_params(dev: pm->dev, ABS_Y, min: 0, max: max_y, fuzz: 0, flat: 0); |
260 | |
261 | if (pm->maxcontacts > 1) { |
262 | input_mt_init_slots(dev: pm->dev, num_slots: pm->maxcontacts, flags: 0); |
263 | input_set_abs_params(dev: pm->dev, |
264 | ABS_MT_POSITION_X, min: 0, max: max_x, fuzz: 0, flat: 0); |
265 | input_set_abs_params(dev: pm->dev, |
266 | ABS_MT_POSITION_Y, min: 0, max: max_y, fuzz: 0, flat: 0); |
267 | } |
268 | |
269 | serio_set_drvdata(serio, data: pm); |
270 | |
271 | err = serio_open(serio, drv); |
272 | if (err) |
273 | goto fail2; |
274 | |
275 | err = input_register_device(pm->dev); |
276 | if (err) |
277 | goto fail3; |
278 | |
279 | return 0; |
280 | |
281 | fail3: serio_close(serio); |
282 | fail2: serio_set_drvdata(serio, NULL); |
283 | fail1: input_free_device(dev: input_dev); |
284 | kfree(objp: pm); |
285 | return err; |
286 | } |
287 | |
288 | /* |
289 | * The serio driver structure. |
290 | */ |
291 | |
292 | static const struct serio_device_id pm_serio_ids[] = { |
293 | { |
294 | .type = SERIO_RS232, |
295 | .proto = SERIO_PENMOUNT, |
296 | .id = SERIO_ANY, |
297 | .extra = SERIO_ANY, |
298 | }, |
299 | { 0 } |
300 | }; |
301 | |
302 | MODULE_DEVICE_TABLE(serio, pm_serio_ids); |
303 | |
304 | static struct serio_driver pm_drv = { |
305 | .driver = { |
306 | .name = "serio-penmount" , |
307 | }, |
308 | .description = DRIVER_DESC, |
309 | .id_table = pm_serio_ids, |
310 | .interrupt = pm_interrupt, |
311 | .connect = pm_connect, |
312 | .disconnect = pm_disconnect, |
313 | }; |
314 | |
315 | module_serio_driver(pm_drv); |
316 | |