1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * HID driver for N-Trig touchscreens |
4 | * |
5 | * Copyright (c) 2008-2010 Rafi Rubin |
6 | * Copyright (c) 2009-2010 Stephane Chatty |
7 | */ |
8 | |
9 | /* |
10 | */ |
11 | |
12 | #include <linux/device.h> |
13 | #include <linux/hid.h> |
14 | #include <linux/usb.h> |
15 | #include "usbhid/usbhid.h" |
16 | #include <linux/module.h> |
17 | #include <linux/slab.h> |
18 | |
19 | #include "hid-ids.h" |
20 | |
21 | #define NTRIG_DUPLICATE_USAGES 0x001 |
22 | |
23 | static unsigned int min_width; |
24 | module_param(min_width, uint, 0644); |
25 | MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept." ); |
26 | |
27 | static unsigned int min_height; |
28 | module_param(min_height, uint, 0644); |
29 | MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept." ); |
30 | |
31 | static unsigned int activate_slack = 1; |
32 | module_param(activate_slack, uint, 0644); |
33 | MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at " |
34 | "the start of touch input." ); |
35 | |
36 | static unsigned int deactivate_slack = 4; |
37 | module_param(deactivate_slack, uint, 0644); |
38 | MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before " |
39 | "deactivating touch." ); |
40 | |
41 | static unsigned int activation_width = 64; |
42 | module_param(activation_width, uint, 0644); |
43 | MODULE_PARM_DESC(activation_width, "Width threshold to immediately start " |
44 | "processing touch events." ); |
45 | |
46 | static unsigned int activation_height = 32; |
47 | module_param(activation_height, uint, 0644); |
48 | MODULE_PARM_DESC(activation_height, "Height threshold to immediately start " |
49 | "processing touch events." ); |
50 | |
51 | struct ntrig_data { |
52 | /* Incoming raw values for a single contact */ |
53 | __u16 x, y, w, h; |
54 | __u16 id; |
55 | |
56 | bool tipswitch; |
57 | bool confidence; |
58 | bool first_contact_touch; |
59 | |
60 | bool reading_mt; |
61 | |
62 | __u8 [4]; |
63 | __u8 ; |
64 | |
65 | /* The current activation state. */ |
66 | __s8 act_state; |
67 | |
68 | /* Empty frames to ignore before recognizing the end of activity */ |
69 | __s8 deactivate_slack; |
70 | |
71 | /* Frames to ignore before acknowledging the start of activity */ |
72 | __s8 activate_slack; |
73 | |
74 | /* Minimum size contact to accept */ |
75 | __u16 min_width; |
76 | __u16 min_height; |
77 | |
78 | /* Threshold to override activation slack */ |
79 | __u16 activation_width; |
80 | __u16 activation_height; |
81 | |
82 | __u16 sensor_logical_width; |
83 | __u16 sensor_logical_height; |
84 | __u16 sensor_physical_width; |
85 | __u16 sensor_physical_height; |
86 | }; |
87 | |
88 | |
89 | /* |
90 | * This function converts the 4 byte raw firmware code into |
91 | * a string containing 5 comma separated numbers. |
92 | */ |
93 | static int ntrig_version_string(unsigned char *raw, char *buf) |
94 | { |
95 | __u8 a = (raw[1] & 0x0e) >> 1; |
96 | __u8 b = (raw[0] & 0x3c) >> 2; |
97 | __u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5); |
98 | __u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5); |
99 | __u8 e = raw[2] & 0x07; |
100 | |
101 | /* |
102 | * As yet unmapped bits: |
103 | * 0b11000000 0b11110001 0b00011000 0b00011000 |
104 | */ |
105 | |
106 | return sprintf(buf, fmt: "%u.%u.%u.%u.%u" , a, b, c, d, e); |
107 | } |
108 | |
109 | static inline int ntrig_get_mode(struct hid_device *hdev) |
110 | { |
111 | struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT]. |
112 | report_id_hash[0x0d]; |
113 | |
114 | if (!report || report->maxfield < 1 || |
115 | report->field[0]->report_count < 1) |
116 | return -EINVAL; |
117 | |
118 | hid_hw_request(hdev, report, reqtype: HID_REQ_GET_REPORT); |
119 | hid_hw_wait(hdev); |
120 | return (int)report->field[0]->value[0]; |
121 | } |
122 | |
123 | static inline void ntrig_set_mode(struct hid_device *hdev, const int mode) |
124 | { |
125 | struct hid_report *report; |
126 | __u8 mode_commands[4] = { 0xe, 0xf, 0x1b, 0x10 }; |
127 | |
128 | if (mode < 0 || mode > 3) |
129 | return; |
130 | |
131 | report = hdev->report_enum[HID_FEATURE_REPORT]. |
132 | report_id_hash[mode_commands[mode]]; |
133 | |
134 | if (!report) |
135 | return; |
136 | |
137 | hid_hw_request(hdev, report, reqtype: HID_REQ_GET_REPORT); |
138 | } |
139 | |
140 | static void ntrig_report_version(struct hid_device *hdev) |
141 | { |
142 | int ret; |
143 | char buf[20]; |
144 | struct usb_device *usb_dev = hid_to_usb_dev(hdev); |
145 | unsigned char *data = kmalloc(size: 8, GFP_KERNEL); |
146 | |
147 | if (!data) |
148 | goto err_free; |
149 | |
150 | ret = usb_control_msg(dev: usb_dev, usb_rcvctrlpipe(usb_dev, 0), |
151 | USB_REQ_CLEAR_FEATURE, |
152 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | |
153 | USB_DIR_IN, |
154 | value: 0x30c, index: 1, data, size: 8, |
155 | USB_CTRL_SET_TIMEOUT); |
156 | |
157 | if (ret == 8) { |
158 | ret = ntrig_version_string(raw: &data[2], buf); |
159 | |
160 | hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n" , |
161 | buf, data[2], data[3], data[4], data[5]); |
162 | } |
163 | |
164 | err_free: |
165 | kfree(objp: data); |
166 | } |
167 | |
168 | static ssize_t show_phys_width(struct device *dev, |
169 | struct device_attribute *attr, |
170 | char *buf) |
171 | { |
172 | struct hid_device *hdev = to_hid_device(dev); |
173 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
174 | |
175 | return sprintf(buf, fmt: "%d\n" , nd->sensor_physical_width); |
176 | } |
177 | |
178 | static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL); |
179 | |
180 | static ssize_t show_phys_height(struct device *dev, |
181 | struct device_attribute *attr, |
182 | char *buf) |
183 | { |
184 | struct hid_device *hdev = to_hid_device(dev); |
185 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
186 | |
187 | return sprintf(buf, fmt: "%d\n" , nd->sensor_physical_height); |
188 | } |
189 | |
190 | static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL); |
191 | |
192 | static ssize_t show_log_width(struct device *dev, |
193 | struct device_attribute *attr, |
194 | char *buf) |
195 | { |
196 | struct hid_device *hdev = to_hid_device(dev); |
197 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
198 | |
199 | return sprintf(buf, fmt: "%d\n" , nd->sensor_logical_width); |
200 | } |
201 | |
202 | static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL); |
203 | |
204 | static ssize_t show_log_height(struct device *dev, |
205 | struct device_attribute *attr, |
206 | char *buf) |
207 | { |
208 | struct hid_device *hdev = to_hid_device(dev); |
209 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
210 | |
211 | return sprintf(buf, fmt: "%d\n" , nd->sensor_logical_height); |
212 | } |
213 | |
214 | static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL); |
215 | |
216 | static ssize_t show_min_width(struct device *dev, |
217 | struct device_attribute *attr, |
218 | char *buf) |
219 | { |
220 | struct hid_device *hdev = to_hid_device(dev); |
221 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
222 | |
223 | return sprintf(buf, fmt: "%d\n" , nd->min_width * |
224 | nd->sensor_physical_width / |
225 | nd->sensor_logical_width); |
226 | } |
227 | |
228 | static ssize_t set_min_width(struct device *dev, |
229 | struct device_attribute *attr, |
230 | const char *buf, size_t count) |
231 | { |
232 | struct hid_device *hdev = to_hid_device(dev); |
233 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
234 | |
235 | unsigned long val; |
236 | |
237 | if (kstrtoul(s: buf, base: 0, res: &val)) |
238 | return -EINVAL; |
239 | |
240 | if (val > nd->sensor_physical_width) |
241 | return -EINVAL; |
242 | |
243 | nd->min_width = val * nd->sensor_logical_width / |
244 | nd->sensor_physical_width; |
245 | |
246 | return count; |
247 | } |
248 | |
249 | static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width); |
250 | |
251 | static ssize_t show_min_height(struct device *dev, |
252 | struct device_attribute *attr, |
253 | char *buf) |
254 | { |
255 | struct hid_device *hdev = to_hid_device(dev); |
256 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
257 | |
258 | return sprintf(buf, fmt: "%d\n" , nd->min_height * |
259 | nd->sensor_physical_height / |
260 | nd->sensor_logical_height); |
261 | } |
262 | |
263 | static ssize_t set_min_height(struct device *dev, |
264 | struct device_attribute *attr, |
265 | const char *buf, size_t count) |
266 | { |
267 | struct hid_device *hdev = to_hid_device(dev); |
268 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
269 | |
270 | unsigned long val; |
271 | |
272 | if (kstrtoul(s: buf, base: 0, res: &val)) |
273 | return -EINVAL; |
274 | |
275 | if (val > nd->sensor_physical_height) |
276 | return -EINVAL; |
277 | |
278 | nd->min_height = val * nd->sensor_logical_height / |
279 | nd->sensor_physical_height; |
280 | |
281 | return count; |
282 | } |
283 | |
284 | static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height, |
285 | set_min_height); |
286 | |
287 | static ssize_t show_activate_slack(struct device *dev, |
288 | struct device_attribute *attr, |
289 | char *buf) |
290 | { |
291 | struct hid_device *hdev = to_hid_device(dev); |
292 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
293 | |
294 | return sprintf(buf, fmt: "%d\n" , nd->activate_slack); |
295 | } |
296 | |
297 | static ssize_t set_activate_slack(struct device *dev, |
298 | struct device_attribute *attr, |
299 | const char *buf, size_t count) |
300 | { |
301 | struct hid_device *hdev = to_hid_device(dev); |
302 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
303 | |
304 | unsigned long val; |
305 | |
306 | if (kstrtoul(s: buf, base: 0, res: &val)) |
307 | return -EINVAL; |
308 | |
309 | if (val > 0x7f) |
310 | return -EINVAL; |
311 | |
312 | nd->activate_slack = val; |
313 | |
314 | return count; |
315 | } |
316 | |
317 | static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack, |
318 | set_activate_slack); |
319 | |
320 | static ssize_t show_activation_width(struct device *dev, |
321 | struct device_attribute *attr, |
322 | char *buf) |
323 | { |
324 | struct hid_device *hdev = to_hid_device(dev); |
325 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
326 | |
327 | return sprintf(buf, fmt: "%d\n" , nd->activation_width * |
328 | nd->sensor_physical_width / |
329 | nd->sensor_logical_width); |
330 | } |
331 | |
332 | static ssize_t set_activation_width(struct device *dev, |
333 | struct device_attribute *attr, |
334 | const char *buf, size_t count) |
335 | { |
336 | struct hid_device *hdev = to_hid_device(dev); |
337 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
338 | |
339 | unsigned long val; |
340 | |
341 | if (kstrtoul(s: buf, base: 0, res: &val)) |
342 | return -EINVAL; |
343 | |
344 | if (val > nd->sensor_physical_width) |
345 | return -EINVAL; |
346 | |
347 | nd->activation_width = val * nd->sensor_logical_width / |
348 | nd->sensor_physical_width; |
349 | |
350 | return count; |
351 | } |
352 | |
353 | static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width, |
354 | set_activation_width); |
355 | |
356 | static ssize_t show_activation_height(struct device *dev, |
357 | struct device_attribute *attr, |
358 | char *buf) |
359 | { |
360 | struct hid_device *hdev = to_hid_device(dev); |
361 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
362 | |
363 | return sprintf(buf, fmt: "%d\n" , nd->activation_height * |
364 | nd->sensor_physical_height / |
365 | nd->sensor_logical_height); |
366 | } |
367 | |
368 | static ssize_t set_activation_height(struct device *dev, |
369 | struct device_attribute *attr, |
370 | const char *buf, size_t count) |
371 | { |
372 | struct hid_device *hdev = to_hid_device(dev); |
373 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
374 | |
375 | unsigned long val; |
376 | |
377 | if (kstrtoul(s: buf, base: 0, res: &val)) |
378 | return -EINVAL; |
379 | |
380 | if (val > nd->sensor_physical_height) |
381 | return -EINVAL; |
382 | |
383 | nd->activation_height = val * nd->sensor_logical_height / |
384 | nd->sensor_physical_height; |
385 | |
386 | return count; |
387 | } |
388 | |
389 | static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO, |
390 | show_activation_height, set_activation_height); |
391 | |
392 | static ssize_t show_deactivate_slack(struct device *dev, |
393 | struct device_attribute *attr, |
394 | char *buf) |
395 | { |
396 | struct hid_device *hdev = to_hid_device(dev); |
397 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
398 | |
399 | return sprintf(buf, fmt: "%d\n" , -nd->deactivate_slack); |
400 | } |
401 | |
402 | static ssize_t set_deactivate_slack(struct device *dev, |
403 | struct device_attribute *attr, |
404 | const char *buf, size_t count) |
405 | { |
406 | struct hid_device *hdev = to_hid_device(dev); |
407 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
408 | |
409 | unsigned long val; |
410 | |
411 | if (kstrtoul(s: buf, base: 0, res: &val)) |
412 | return -EINVAL; |
413 | |
414 | /* |
415 | * No more than 8 terminal frames have been observed so far |
416 | * and higher slack is highly likely to leave the single |
417 | * touch emulation stuck down. |
418 | */ |
419 | if (val > 7) |
420 | return -EINVAL; |
421 | |
422 | nd->deactivate_slack = -val; |
423 | |
424 | return count; |
425 | } |
426 | |
427 | static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack, |
428 | set_deactivate_slack); |
429 | |
430 | static struct attribute *sysfs_attrs[] = { |
431 | &dev_attr_sensor_physical_width.attr, |
432 | &dev_attr_sensor_physical_height.attr, |
433 | &dev_attr_sensor_logical_width.attr, |
434 | &dev_attr_sensor_logical_height.attr, |
435 | &dev_attr_min_height.attr, |
436 | &dev_attr_min_width.attr, |
437 | &dev_attr_activate_slack.attr, |
438 | &dev_attr_activation_width.attr, |
439 | &dev_attr_activation_height.attr, |
440 | &dev_attr_deactivate_slack.attr, |
441 | NULL |
442 | }; |
443 | |
444 | static const struct attribute_group ntrig_attribute_group = { |
445 | .attrs = sysfs_attrs |
446 | }; |
447 | |
448 | /* |
449 | * this driver is aimed at two firmware versions in circulation: |
450 | * - dual pen/finger single touch |
451 | * - finger multitouch, pen not working |
452 | */ |
453 | |
454 | static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi, |
455 | struct hid_field *field, struct hid_usage *usage, |
456 | unsigned long **bit, int *max) |
457 | { |
458 | struct ntrig_data *nd = hid_get_drvdata(hdev); |
459 | |
460 | /* No special mappings needed for the pen and single touch */ |
461 | if (field->physical) |
462 | return 0; |
463 | |
464 | switch (usage->hid & HID_USAGE_PAGE) { |
465 | case HID_UP_GENDESK: |
466 | switch (usage->hid) { |
467 | case HID_GD_X: |
468 | hid_map_usage(hidinput: hi, usage, bit, max, |
469 | EV_ABS, ABS_MT_POSITION_X); |
470 | input_set_abs_params(dev: hi->input, ABS_X, |
471 | min: field->logical_minimum, |
472 | max: field->logical_maximum, fuzz: 0, flat: 0); |
473 | |
474 | if (!nd->sensor_logical_width) { |
475 | nd->sensor_logical_width = |
476 | field->logical_maximum - |
477 | field->logical_minimum; |
478 | nd->sensor_physical_width = |
479 | field->physical_maximum - |
480 | field->physical_minimum; |
481 | nd->activation_width = activation_width * |
482 | nd->sensor_logical_width / |
483 | nd->sensor_physical_width; |
484 | nd->min_width = min_width * |
485 | nd->sensor_logical_width / |
486 | nd->sensor_physical_width; |
487 | } |
488 | return 1; |
489 | case HID_GD_Y: |
490 | hid_map_usage(hidinput: hi, usage, bit, max, |
491 | EV_ABS, ABS_MT_POSITION_Y); |
492 | input_set_abs_params(dev: hi->input, ABS_Y, |
493 | min: field->logical_minimum, |
494 | max: field->logical_maximum, fuzz: 0, flat: 0); |
495 | |
496 | if (!nd->sensor_logical_height) { |
497 | nd->sensor_logical_height = |
498 | field->logical_maximum - |
499 | field->logical_minimum; |
500 | nd->sensor_physical_height = |
501 | field->physical_maximum - |
502 | field->physical_minimum; |
503 | nd->activation_height = activation_height * |
504 | nd->sensor_logical_height / |
505 | nd->sensor_physical_height; |
506 | nd->min_height = min_height * |
507 | nd->sensor_logical_height / |
508 | nd->sensor_physical_height; |
509 | } |
510 | return 1; |
511 | } |
512 | return 0; |
513 | |
514 | case HID_UP_DIGITIZER: |
515 | switch (usage->hid) { |
516 | /* we do not want to map these for now */ |
517 | case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */ |
518 | case HID_DG_INPUTMODE: |
519 | case HID_DG_DEVICEINDEX: |
520 | case HID_DG_CONTACTMAX: |
521 | return -1; |
522 | |
523 | /* width/height mapped on TouchMajor/TouchMinor/Orientation */ |
524 | case HID_DG_WIDTH: |
525 | hid_map_usage(hidinput: hi, usage, bit, max, |
526 | EV_ABS, ABS_MT_TOUCH_MAJOR); |
527 | return 1; |
528 | case HID_DG_HEIGHT: |
529 | hid_map_usage(hidinput: hi, usage, bit, max, |
530 | EV_ABS, ABS_MT_TOUCH_MINOR); |
531 | input_set_abs_params(dev: hi->input, ABS_MT_ORIENTATION, |
532 | min: 0, max: 1, fuzz: 0, flat: 0); |
533 | return 1; |
534 | } |
535 | return 0; |
536 | |
537 | case 0xff000000: |
538 | /* we do not want to map these: no input-oriented meaning */ |
539 | return -1; |
540 | } |
541 | |
542 | return 0; |
543 | } |
544 | |
545 | static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi, |
546 | struct hid_field *field, struct hid_usage *usage, |
547 | unsigned long **bit, int *max) |
548 | { |
549 | /* No special mappings needed for the pen and single touch */ |
550 | if (field->physical) |
551 | return 0; |
552 | |
553 | if (usage->type == EV_KEY || usage->type == EV_REL |
554 | || usage->type == EV_ABS) |
555 | clear_bit(nr: usage->code, addr: *bit); |
556 | |
557 | return 0; |
558 | } |
559 | |
560 | /* |
561 | * this function is called upon all reports |
562 | * so that we can filter contact point information, |
563 | * decide whether we are in multi or single touch mode |
564 | * and call input_mt_sync after each point if necessary |
565 | */ |
566 | static int ntrig_event (struct hid_device *hid, struct hid_field *field, |
567 | struct hid_usage *usage, __s32 value) |
568 | { |
569 | struct ntrig_data *nd = hid_get_drvdata(hdev: hid); |
570 | struct input_dev *input; |
571 | |
572 | /* Skip processing if not a claimed input */ |
573 | if (!(hid->claimed & HID_CLAIMED_INPUT)) |
574 | goto not_claimed_input; |
575 | |
576 | /* This function is being called before the structures are fully |
577 | * initialized */ |
578 | if(!(field->hidinput && field->hidinput->input)) |
579 | return -EINVAL; |
580 | |
581 | input = field->hidinput->input; |
582 | |
583 | /* No special handling needed for the pen */ |
584 | if (field->application == HID_DG_PEN) |
585 | return 0; |
586 | |
587 | switch (usage->hid) { |
588 | case 0xff000001: |
589 | /* Tag indicating the start of a multitouch group */ |
590 | nd->reading_mt = true; |
591 | nd->first_contact_touch = false; |
592 | break; |
593 | case HID_DG_TIPSWITCH: |
594 | nd->tipswitch = value; |
595 | /* Prevent emission of touch until validated */ |
596 | return 1; |
597 | case HID_DG_CONFIDENCE: |
598 | nd->confidence = value; |
599 | break; |
600 | case HID_GD_X: |
601 | nd->x = value; |
602 | /* Clear the contact footer */ |
603 | nd->mt_foot_count = 0; |
604 | break; |
605 | case HID_GD_Y: |
606 | nd->y = value; |
607 | break; |
608 | case HID_DG_CONTACTID: |
609 | nd->id = value; |
610 | break; |
611 | case HID_DG_WIDTH: |
612 | nd->w = value; |
613 | break; |
614 | case HID_DG_HEIGHT: |
615 | nd->h = value; |
616 | /* |
617 | * when in single touch mode, this is the last |
618 | * report received in a finger event. We want |
619 | * to emit a normal (X, Y) position |
620 | */ |
621 | if (!nd->reading_mt) { |
622 | /* |
623 | * TipSwitch indicates the presence of a |
624 | * finger in single touch mode. |
625 | */ |
626 | input_report_key(dev: input, BTN_TOUCH, |
627 | value: nd->tipswitch); |
628 | input_report_key(dev: input, BTN_TOOL_DOUBLETAP, |
629 | value: nd->tipswitch); |
630 | input_event(dev: input, EV_ABS, ABS_X, value: nd->x); |
631 | input_event(dev: input, EV_ABS, ABS_Y, value: nd->y); |
632 | } |
633 | break; |
634 | case 0xff000002: |
635 | /* |
636 | * we receive this when the device is in multitouch |
637 | * mode. The first of the three values tagged with |
638 | * this usage tells if the contact point is real |
639 | * or a placeholder |
640 | */ |
641 | |
642 | /* Shouldn't get more than 4 footer packets, so skip */ |
643 | if (nd->mt_foot_count >= 4) |
644 | break; |
645 | |
646 | nd->mt_footer[nd->mt_foot_count++] = value; |
647 | |
648 | /* if the footer isn't complete break */ |
649 | if (nd->mt_foot_count != 4) |
650 | break; |
651 | |
652 | /* Pen activity signal. */ |
653 | if (nd->mt_footer[2]) { |
654 | /* |
655 | * When the pen deactivates touch, we see a |
656 | * bogus frame with ContactCount > 0. |
657 | * We can |
658 | * save a bit of work by ensuring act_state < 0 |
659 | * even if deactivation slack is turned off. |
660 | */ |
661 | nd->act_state = deactivate_slack - 1; |
662 | nd->confidence = false; |
663 | break; |
664 | } |
665 | |
666 | /* |
667 | * The first footer value indicates the presence of a |
668 | * finger. |
669 | */ |
670 | if (nd->mt_footer[0]) { |
671 | /* |
672 | * We do not want to process contacts under |
673 | * the size threshold, but do not want to |
674 | * ignore them for activation state |
675 | */ |
676 | if (nd->w < nd->min_width || |
677 | nd->h < nd->min_height) |
678 | nd->confidence = false; |
679 | } else |
680 | break; |
681 | |
682 | if (nd->act_state > 0) { |
683 | /* |
684 | * Contact meets the activation size threshold |
685 | */ |
686 | if (nd->w >= nd->activation_width && |
687 | nd->h >= nd->activation_height) { |
688 | if (nd->id) |
689 | /* |
690 | * first contact, activate now |
691 | */ |
692 | nd->act_state = 0; |
693 | else { |
694 | /* |
695 | * avoid corrupting this frame |
696 | * but ensure next frame will |
697 | * be active |
698 | */ |
699 | nd->act_state = 1; |
700 | break; |
701 | } |
702 | } else |
703 | /* |
704 | * Defer adjusting the activation state |
705 | * until the end of the frame. |
706 | */ |
707 | break; |
708 | } |
709 | |
710 | /* Discarding this contact */ |
711 | if (!nd->confidence) |
712 | break; |
713 | |
714 | /* emit a normal (X, Y) for the first point only */ |
715 | if (nd->id == 0) { |
716 | /* |
717 | * TipSwitch is superfluous in multitouch |
718 | * mode. The footer events tell us |
719 | * if there is a finger on the screen or |
720 | * not. |
721 | */ |
722 | nd->first_contact_touch = nd->confidence; |
723 | input_event(dev: input, EV_ABS, ABS_X, value: nd->x); |
724 | input_event(dev: input, EV_ABS, ABS_Y, value: nd->y); |
725 | } |
726 | |
727 | /* Emit MT events */ |
728 | input_event(dev: input, EV_ABS, ABS_MT_POSITION_X, value: nd->x); |
729 | input_event(dev: input, EV_ABS, ABS_MT_POSITION_Y, value: nd->y); |
730 | |
731 | /* |
732 | * Translate from height and width to size |
733 | * and orientation. |
734 | */ |
735 | if (nd->w > nd->h) { |
736 | input_event(dev: input, EV_ABS, |
737 | ABS_MT_ORIENTATION, value: 1); |
738 | input_event(dev: input, EV_ABS, |
739 | ABS_MT_TOUCH_MAJOR, value: nd->w); |
740 | input_event(dev: input, EV_ABS, |
741 | ABS_MT_TOUCH_MINOR, value: nd->h); |
742 | } else { |
743 | input_event(dev: input, EV_ABS, |
744 | ABS_MT_ORIENTATION, value: 0); |
745 | input_event(dev: input, EV_ABS, |
746 | ABS_MT_TOUCH_MAJOR, value: nd->h); |
747 | input_event(dev: input, EV_ABS, |
748 | ABS_MT_TOUCH_MINOR, value: nd->w); |
749 | } |
750 | input_mt_sync(dev: field->hidinput->input); |
751 | break; |
752 | |
753 | case HID_DG_CONTACTCOUNT: /* End of a multitouch group */ |
754 | if (!nd->reading_mt) /* Just to be sure */ |
755 | break; |
756 | |
757 | nd->reading_mt = false; |
758 | |
759 | |
760 | /* |
761 | * Activation state machine logic: |
762 | * |
763 | * Fundamental states: |
764 | * state > 0: Inactive |
765 | * state <= 0: Active |
766 | * state < -deactivate_slack: |
767 | * Pen termination of touch |
768 | * |
769 | * Specific values of interest |
770 | * state == activate_slack |
771 | * no valid input since the last reset |
772 | * |
773 | * state == 0 |
774 | * general operational state |
775 | * |
776 | * state == -deactivate_slack |
777 | * read sufficient empty frames to accept |
778 | * the end of input and reset |
779 | */ |
780 | |
781 | if (nd->act_state > 0) { /* Currently inactive */ |
782 | if (value) |
783 | /* |
784 | * Consider each live contact as |
785 | * evidence of intentional activity. |
786 | */ |
787 | nd->act_state = (nd->act_state > value) |
788 | ? nd->act_state - value |
789 | : 0; |
790 | else |
791 | /* |
792 | * Empty frame before we hit the |
793 | * activity threshold, reset. |
794 | */ |
795 | nd->act_state = nd->activate_slack; |
796 | |
797 | /* |
798 | * Entered this block inactive and no |
799 | * coordinates sent this frame, so hold off |
800 | * on button state. |
801 | */ |
802 | break; |
803 | } else { /* Currently active */ |
804 | if (value && nd->act_state >= |
805 | nd->deactivate_slack) |
806 | /* |
807 | * Live point: clear accumulated |
808 | * deactivation count. |
809 | */ |
810 | nd->act_state = 0; |
811 | else if (nd->act_state <= nd->deactivate_slack) |
812 | /* |
813 | * We've consumed the deactivation |
814 | * slack, time to deactivate and reset. |
815 | */ |
816 | nd->act_state = |
817 | nd->activate_slack; |
818 | else { /* Move towards deactivation */ |
819 | nd->act_state--; |
820 | break; |
821 | } |
822 | } |
823 | |
824 | if (nd->first_contact_touch && nd->act_state <= 0) { |
825 | /* |
826 | * Check to see if we're ready to start |
827 | * emitting touch events. |
828 | * |
829 | * Note: activation slack will decrease over |
830 | * the course of the frame, and it will be |
831 | * inconsistent from the start to the end of |
832 | * the frame. However if the frame starts |
833 | * with slack, first_contact_touch will still |
834 | * be 0 and we will not get to this point. |
835 | */ |
836 | input_report_key(dev: input, BTN_TOOL_DOUBLETAP, value: 1); |
837 | input_report_key(dev: input, BTN_TOUCH, value: 1); |
838 | } else { |
839 | input_report_key(dev: input, BTN_TOOL_DOUBLETAP, value: 0); |
840 | input_report_key(dev: input, BTN_TOUCH, value: 0); |
841 | } |
842 | break; |
843 | |
844 | default: |
845 | /* fall-back to the generic hidinput handling */ |
846 | return 0; |
847 | } |
848 | |
849 | not_claimed_input: |
850 | |
851 | /* we have handled the hidinput part, now remains hiddev */ |
852 | if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event) |
853 | hid->hiddev_hid_event(hid, field, usage, value); |
854 | |
855 | return 1; |
856 | } |
857 | |
858 | static int ntrig_input_configured(struct hid_device *hid, |
859 | struct hid_input *hidinput) |
860 | |
861 | { |
862 | struct input_dev *input = hidinput->input; |
863 | |
864 | if (hidinput->report->maxfield < 1) |
865 | return 0; |
866 | |
867 | switch (hidinput->report->field[0]->application) { |
868 | case HID_DG_PEN: |
869 | input->name = "N-Trig Pen" ; |
870 | break; |
871 | case HID_DG_TOUCHSCREEN: |
872 | /* These keys are redundant for fingers, clear them |
873 | * to prevent incorrect identification */ |
874 | __clear_bit(BTN_TOOL_PEN, input->keybit); |
875 | __clear_bit(BTN_TOOL_FINGER, input->keybit); |
876 | __clear_bit(BTN_0, input->keybit); |
877 | __set_bit(BTN_TOOL_DOUBLETAP, input->keybit); |
878 | /* |
879 | * The physical touchscreen (single touch) |
880 | * input has a value for physical, whereas |
881 | * the multitouch only has logical input |
882 | * fields. |
883 | */ |
884 | input->name = (hidinput->report->field[0]->physical) ? |
885 | "N-Trig Touchscreen" : |
886 | "N-Trig MultiTouch" ; |
887 | break; |
888 | } |
889 | |
890 | return 0; |
891 | } |
892 | |
893 | static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id) |
894 | { |
895 | int ret; |
896 | struct ntrig_data *nd; |
897 | struct hid_report *report; |
898 | |
899 | if (id->driver_data) |
900 | hdev->quirks |= HID_QUIRK_MULTI_INPUT |
901 | | HID_QUIRK_NO_INIT_REPORTS; |
902 | |
903 | nd = kmalloc(size: sizeof(struct ntrig_data), GFP_KERNEL); |
904 | if (!nd) { |
905 | hid_err(hdev, "cannot allocate N-Trig data\n" ); |
906 | return -ENOMEM; |
907 | } |
908 | |
909 | nd->reading_mt = false; |
910 | nd->min_width = 0; |
911 | nd->min_height = 0; |
912 | nd->activate_slack = activate_slack; |
913 | nd->act_state = activate_slack; |
914 | nd->deactivate_slack = -deactivate_slack; |
915 | nd->sensor_logical_width = 1; |
916 | nd->sensor_logical_height = 1; |
917 | nd->sensor_physical_width = 1; |
918 | nd->sensor_physical_height = 1; |
919 | |
920 | hid_set_drvdata(hdev, data: nd); |
921 | |
922 | ret = hid_parse(hdev); |
923 | if (ret) { |
924 | hid_err(hdev, "parse failed\n" ); |
925 | goto err_free; |
926 | } |
927 | |
928 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF); |
929 | if (ret) { |
930 | hid_err(hdev, "hw start failed\n" ); |
931 | goto err_free; |
932 | } |
933 | |
934 | /* This is needed for devices with more recent firmware versions */ |
935 | report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a]; |
936 | if (report) { |
937 | /* Let the device settle to ensure the wakeup message gets |
938 | * through */ |
939 | hid_hw_wait(hdev); |
940 | hid_hw_request(hdev, report, reqtype: HID_REQ_GET_REPORT); |
941 | |
942 | /* |
943 | * Sanity check: if the current mode is invalid reset it to |
944 | * something reasonable. |
945 | */ |
946 | if (ntrig_get_mode(hdev) >= 4) |
947 | ntrig_set_mode(hdev, mode: 3); |
948 | } |
949 | |
950 | ntrig_report_version(hdev); |
951 | |
952 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, |
953 | grp: &ntrig_attribute_group); |
954 | if (ret) |
955 | hid_err(hdev, "cannot create sysfs group\n" ); |
956 | |
957 | return 0; |
958 | err_free: |
959 | kfree(objp: nd); |
960 | return ret; |
961 | } |
962 | |
963 | static void ntrig_remove(struct hid_device *hdev) |
964 | { |
965 | sysfs_remove_group(kobj: &hdev->dev.kobj, |
966 | grp: &ntrig_attribute_group); |
967 | hid_hw_stop(hdev); |
968 | kfree(objp: hid_get_drvdata(hdev)); |
969 | } |
970 | |
971 | static const struct hid_device_id ntrig_devices[] = { |
972 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN), |
973 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
974 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1), |
975 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
976 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2), |
977 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
978 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3), |
979 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
980 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4), |
981 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
982 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5), |
983 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
984 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6), |
985 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
986 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7), |
987 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
988 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8), |
989 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
990 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9), |
991 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
992 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10), |
993 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
994 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11), |
995 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
996 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12), |
997 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
998 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13), |
999 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
1000 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14), |
1001 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
1002 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15), |
1003 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
1004 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16), |
1005 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
1006 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17), |
1007 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
1008 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18), |
1009 | .driver_data = NTRIG_DUPLICATE_USAGES }, |
1010 | { } |
1011 | }; |
1012 | MODULE_DEVICE_TABLE(hid, ntrig_devices); |
1013 | |
1014 | static const struct hid_usage_id ntrig_grabbed_usages[] = { |
1015 | { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, |
1016 | { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 } |
1017 | }; |
1018 | |
1019 | static struct hid_driver ntrig_driver = { |
1020 | .name = "ntrig" , |
1021 | .id_table = ntrig_devices, |
1022 | .probe = ntrig_probe, |
1023 | .remove = ntrig_remove, |
1024 | .input_mapping = ntrig_input_mapping, |
1025 | .input_mapped = ntrig_input_mapped, |
1026 | .input_configured = ntrig_input_configured, |
1027 | .usage_table = ntrig_grabbed_usages, |
1028 | .event = ntrig_event, |
1029 | }; |
1030 | module_hid_driver(ntrig_driver); |
1031 | |
1032 | MODULE_LICENSE("GPL" ); |
1033 | |