Branch data Line data Source code
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 mt_footer[4];
63 : : __u8 mt_foot_count;
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 : 0 : static int ntrig_version_string(unsigned char *raw, char *buf)
94 : : {
95 : 0 : __u8 a = (raw[1] & 0x0e) >> 1;
96 : 0 : __u8 b = (raw[0] & 0x3c) >> 2;
97 : 0 : __u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5);
98 : 0 : __u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5);
99 : 0 : __u8 e = raw[2] & 0x07;
100 : :
101 : : /*
102 : : * As yet unmapped bits:
103 : : * 0b11000000 0b11110001 0b00011000 0b00011000
104 : : */
105 : :
106 : 0 : return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e);
107 : : }
108 : :
109 : 0 : static inline int ntrig_get_mode(struct hid_device *hdev)
110 : : {
111 : 0 : struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT].
112 : : report_id_hash[0x0d];
113 : :
114 [ # # # # ]: 0 : if (!report || report->maxfield < 1 ||
115 [ # # ]: 0 : report->field[0]->report_count < 1)
116 : : return -EINVAL;
117 : :
118 : 0 : hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
119 [ # # ]: 0 : hid_hw_wait(hdev);
120 : 0 : return (int)report->field[0]->value[0];
121 : : }
122 : :
123 : 0 : static inline void ntrig_set_mode(struct hid_device *hdev, const int mode)
124 : : {
125 : 0 : struct hid_report *report;
126 : 0 : __u8 mode_commands[4] = { 0xe, 0xf, 0x1b, 0x10 };
127 : :
128 : 0 : if (mode < 0 || mode > 3)
129 : : return;
130 : :
131 : 0 : report = hdev->report_enum[HID_FEATURE_REPORT].
132 : : report_id_hash[mode_commands[mode]];
133 : :
134 : 0 : if (!report)
135 : : return;
136 : :
137 : 0 : hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
138 : : }
139 : :
140 : 0 : static void ntrig_report_version(struct hid_device *hdev)
141 : : {
142 : 0 : int ret;
143 : 0 : char buf[20];
144 : 0 : struct usb_device *usb_dev = hid_to_usb_dev(hdev);
145 : 0 : unsigned char *data = kmalloc(8, GFP_KERNEL);
146 : :
147 [ # # ]: 0 : if (!data)
148 : 0 : goto err_free;
149 : :
150 : 0 : ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
151 : : USB_REQ_CLEAR_FEATURE,
152 : : USB_TYPE_CLASS | USB_RECIP_INTERFACE |
153 : : USB_DIR_IN,
154 : : 0x30c, 1, data, 8,
155 : : USB_CTRL_SET_TIMEOUT);
156 : :
157 [ # # ]: 0 : if (ret == 8) {
158 : 0 : ret = ntrig_version_string(&data[2], buf);
159 : :
160 : 0 : hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",
161 : : buf, data[2], data[3], data[4], data[5]);
162 : : }
163 : :
164 : 0 : err_free:
165 : 0 : kfree(data);
166 : 0 : }
167 : :
168 : 0 : static ssize_t show_phys_width(struct device *dev,
169 : : struct device_attribute *attr,
170 : : char *buf)
171 : : {
172 : 0 : struct hid_device *hdev = to_hid_device(dev);
173 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
174 : :
175 : 0 : return sprintf(buf, "%d\n", nd->sensor_physical_width);
176 : : }
177 : :
178 : : static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
179 : :
180 : 0 : static ssize_t show_phys_height(struct device *dev,
181 : : struct device_attribute *attr,
182 : : char *buf)
183 : : {
184 : 0 : struct hid_device *hdev = to_hid_device(dev);
185 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
186 : :
187 : 0 : return sprintf(buf, "%d\n", nd->sensor_physical_height);
188 : : }
189 : :
190 : : static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
191 : :
192 : 0 : static ssize_t show_log_width(struct device *dev,
193 : : struct device_attribute *attr,
194 : : char *buf)
195 : : {
196 : 0 : struct hid_device *hdev = to_hid_device(dev);
197 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
198 : :
199 : 0 : return sprintf(buf, "%d\n", nd->sensor_logical_width);
200 : : }
201 : :
202 : : static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
203 : :
204 : 0 : static ssize_t show_log_height(struct device *dev,
205 : : struct device_attribute *attr,
206 : : char *buf)
207 : : {
208 : 0 : struct hid_device *hdev = to_hid_device(dev);
209 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
210 : :
211 : 0 : return sprintf(buf, "%d\n", nd->sensor_logical_height);
212 : : }
213 : :
214 : : static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
215 : :
216 : 0 : static ssize_t show_min_width(struct device *dev,
217 : : struct device_attribute *attr,
218 : : char *buf)
219 : : {
220 : 0 : struct hid_device *hdev = to_hid_device(dev);
221 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
222 : :
223 : 0 : return sprintf(buf, "%d\n", nd->min_width *
224 : 0 : nd->sensor_physical_width /
225 : 0 : nd->sensor_logical_width);
226 : : }
227 : :
228 : 0 : static ssize_t set_min_width(struct device *dev,
229 : : struct device_attribute *attr,
230 : : const char *buf, size_t count)
231 : : {
232 : 0 : struct hid_device *hdev = to_hid_device(dev);
233 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
234 : :
235 : 0 : unsigned long val;
236 : :
237 [ # # ]: 0 : if (kstrtoul(buf, 0, &val))
238 : : return -EINVAL;
239 : :
240 [ # # ]: 0 : if (val > nd->sensor_physical_width)
241 : : return -EINVAL;
242 : :
243 : 0 : nd->min_width = val * nd->sensor_logical_width /
244 : : nd->sensor_physical_width;
245 : :
246 : 0 : return count;
247 : : }
248 : :
249 : : static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
250 : :
251 : 0 : static ssize_t show_min_height(struct device *dev,
252 : : struct device_attribute *attr,
253 : : char *buf)
254 : : {
255 : 0 : struct hid_device *hdev = to_hid_device(dev);
256 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
257 : :
258 : 0 : return sprintf(buf, "%d\n", nd->min_height *
259 : 0 : nd->sensor_physical_height /
260 : 0 : nd->sensor_logical_height);
261 : : }
262 : :
263 : 0 : static ssize_t set_min_height(struct device *dev,
264 : : struct device_attribute *attr,
265 : : const char *buf, size_t count)
266 : : {
267 : 0 : struct hid_device *hdev = to_hid_device(dev);
268 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
269 : :
270 : 0 : unsigned long val;
271 : :
272 [ # # ]: 0 : if (kstrtoul(buf, 0, &val))
273 : : return -EINVAL;
274 : :
275 [ # # ]: 0 : if (val > nd->sensor_physical_height)
276 : : return -EINVAL;
277 : :
278 : 0 : nd->min_height = val * nd->sensor_logical_height /
279 : : nd->sensor_physical_height;
280 : :
281 : 0 : return count;
282 : : }
283 : :
284 : : static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
285 : : set_min_height);
286 : :
287 : 0 : static ssize_t show_activate_slack(struct device *dev,
288 : : struct device_attribute *attr,
289 : : char *buf)
290 : : {
291 : 0 : struct hid_device *hdev = to_hid_device(dev);
292 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
293 : :
294 : 0 : return sprintf(buf, "%d\n", nd->activate_slack);
295 : : }
296 : :
297 : 0 : static ssize_t set_activate_slack(struct device *dev,
298 : : struct device_attribute *attr,
299 : : const char *buf, size_t count)
300 : : {
301 : 0 : struct hid_device *hdev = to_hid_device(dev);
302 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
303 : :
304 : 0 : unsigned long val;
305 : :
306 [ # # ]: 0 : if (kstrtoul(buf, 0, &val))
307 : : return -EINVAL;
308 : :
309 [ # # ]: 0 : if (val > 0x7f)
310 : : return -EINVAL;
311 : :
312 : 0 : nd->activate_slack = val;
313 : :
314 : 0 : return count;
315 : : }
316 : :
317 : : static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
318 : : set_activate_slack);
319 : :
320 : 0 : static ssize_t show_activation_width(struct device *dev,
321 : : struct device_attribute *attr,
322 : : char *buf)
323 : : {
324 : 0 : struct hid_device *hdev = to_hid_device(dev);
325 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
326 : :
327 : 0 : return sprintf(buf, "%d\n", nd->activation_width *
328 : 0 : nd->sensor_physical_width /
329 : 0 : nd->sensor_logical_width);
330 : : }
331 : :
332 : 0 : static ssize_t set_activation_width(struct device *dev,
333 : : struct device_attribute *attr,
334 : : const char *buf, size_t count)
335 : : {
336 : 0 : struct hid_device *hdev = to_hid_device(dev);
337 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
338 : :
339 : 0 : unsigned long val;
340 : :
341 [ # # ]: 0 : if (kstrtoul(buf, 0, &val))
342 : : return -EINVAL;
343 : :
344 [ # # ]: 0 : if (val > nd->sensor_physical_width)
345 : : return -EINVAL;
346 : :
347 : 0 : nd->activation_width = val * nd->sensor_logical_width /
348 : : nd->sensor_physical_width;
349 : :
350 : 0 : return count;
351 : : }
352 : :
353 : : static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
354 : : set_activation_width);
355 : :
356 : 0 : static ssize_t show_activation_height(struct device *dev,
357 : : struct device_attribute *attr,
358 : : char *buf)
359 : : {
360 : 0 : struct hid_device *hdev = to_hid_device(dev);
361 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
362 : :
363 : 0 : return sprintf(buf, "%d\n", nd->activation_height *
364 : 0 : nd->sensor_physical_height /
365 : 0 : nd->sensor_logical_height);
366 : : }
367 : :
368 : 0 : static ssize_t set_activation_height(struct device *dev,
369 : : struct device_attribute *attr,
370 : : const char *buf, size_t count)
371 : : {
372 : 0 : struct hid_device *hdev = to_hid_device(dev);
373 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
374 : :
375 : 0 : unsigned long val;
376 : :
377 [ # # ]: 0 : if (kstrtoul(buf, 0, &val))
378 : : return -EINVAL;
379 : :
380 [ # # ]: 0 : if (val > nd->sensor_physical_height)
381 : : return -EINVAL;
382 : :
383 : 0 : nd->activation_height = val * nd->sensor_logical_height /
384 : : nd->sensor_physical_height;
385 : :
386 : 0 : return count;
387 : : }
388 : :
389 : : static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
390 : : show_activation_height, set_activation_height);
391 : :
392 : 0 : static ssize_t show_deactivate_slack(struct device *dev,
393 : : struct device_attribute *attr,
394 : : char *buf)
395 : : {
396 : 0 : struct hid_device *hdev = to_hid_device(dev);
397 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
398 : :
399 : 0 : return sprintf(buf, "%d\n", -nd->deactivate_slack);
400 : : }
401 : :
402 : 0 : static ssize_t set_deactivate_slack(struct device *dev,
403 : : struct device_attribute *attr,
404 : : const char *buf, size_t count)
405 : : {
406 : 0 : struct hid_device *hdev = to_hid_device(dev);
407 : 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
408 : :
409 : 0 : unsigned long val;
410 : :
411 [ # # ]: 0 : if (kstrtoul(buf, 0, &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 [ # # ]: 0 : if (val > 7)
420 : : return -EINVAL;
421 : :
422 : 0 : nd->deactivate_slack = -val;
423 : :
424 : 0 : 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 : 0 : 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 [ # # ]: 0 : struct ntrig_data *nd = hid_get_drvdata(hdev);
459 : :
460 : : /* No special mappings needed for the pen and single touch */
461 [ # # ]: 0 : if (field->physical)
462 : : return 0;
463 : :
464 [ # # # # ]: 0 : switch (usage->hid & HID_USAGE_PAGE) {
465 : 0 : case HID_UP_GENDESK:
466 [ # # # ]: 0 : switch (usage->hid) {
467 : : case HID_GD_X:
468 : 0 : hid_map_usage(hi, usage, bit, max,
469 : : EV_ABS, ABS_MT_POSITION_X);
470 : 0 : input_set_abs_params(hi->input, ABS_X,
471 : : field->logical_minimum,
472 : : field->logical_maximum, 0, 0);
473 : :
474 [ # # ]: 0 : if (!nd->sensor_logical_width) {
475 : 0 : nd->sensor_logical_width =
476 : 0 : field->logical_maximum -
477 : 0 : field->logical_minimum;
478 : 0 : nd->sensor_physical_width =
479 : 0 : field->physical_maximum -
480 : 0 : field->physical_minimum;
481 : 0 : nd->activation_width = activation_width *
482 : 0 : nd->sensor_logical_width /
483 : 0 : nd->sensor_physical_width;
484 : 0 : nd->min_width = min_width *
485 : 0 : nd->sensor_logical_width /
486 : : nd->sensor_physical_width;
487 : : }
488 : : return 1;
489 : : case HID_GD_Y:
490 : 0 : hid_map_usage(hi, usage, bit, max,
491 : : EV_ABS, ABS_MT_POSITION_Y);
492 : 0 : input_set_abs_params(hi->input, ABS_Y,
493 : : field->logical_minimum,
494 : : field->logical_maximum, 0, 0);
495 : :
496 [ # # ]: 0 : if (!nd->sensor_logical_height) {
497 : 0 : nd->sensor_logical_height =
498 : 0 : field->logical_maximum -
499 : 0 : field->logical_minimum;
500 : 0 : nd->sensor_physical_height =
501 : 0 : field->physical_maximum -
502 : 0 : field->physical_minimum;
503 : 0 : nd->activation_height = activation_height *
504 : 0 : nd->sensor_logical_height /
505 : 0 : nd->sensor_physical_height;
506 : 0 : nd->min_height = min_height *
507 : 0 : nd->sensor_logical_height /
508 : : nd->sensor_physical_height;
509 : : }
510 : : return 1;
511 : : }
512 : : return 0;
513 : :
514 : 0 : case HID_UP_DIGITIZER:
515 [ # # # # ]: 0 : 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 : 0 : hid_map_usage(hi, usage, bit, max,
526 : : EV_ABS, ABS_MT_TOUCH_MAJOR);
527 : 0 : return 1;
528 : : case HID_DG_HEIGHT:
529 : 0 : hid_map_usage(hi, usage, bit, max,
530 : : EV_ABS, ABS_MT_TOUCH_MINOR);
531 : 0 : input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
532 : : 0, 1, 0, 0);
533 : 0 : return 1;
534 : : }
535 : 0 : return 0;
536 : :
537 : : case 0xff000000:
538 : : /* we do not want to map these: no input-oriented meaning */
539 : : return -1;
540 : : }
541 : :
542 : 0 : return 0;
543 : : }
544 : :
545 : 0 : 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 [ # # ]: 0 : if (field->physical)
551 : : return 0;
552 : :
553 : 0 : if (usage->type == EV_KEY || usage->type == EV_REL
554 [ # # ]: 0 : || usage->type == EV_ABS)
555 : 0 : clear_bit(usage->code, *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 : 0 : static int ntrig_event (struct hid_device *hid, struct hid_field *field,
567 : : struct hid_usage *usage, __s32 value)
568 : : {
569 [ # # ]: 0 : struct ntrig_data *nd = hid_get_drvdata(hid);
570 : 0 : struct input_dev *input;
571 : :
572 : : /* Skip processing if not a claimed input */
573 [ # # ]: 0 : if (!(hid->claimed & HID_CLAIMED_INPUT))
574 : 0 : goto not_claimed_input;
575 : :
576 : : /* This function is being called before the structures are fully
577 : : * initialized */
578 [ # # # # ]: 0 : if(!(field->hidinput && field->hidinput->input))
579 : : return -EINVAL;
580 : :
581 : 0 : input = field->hidinput->input;
582 : :
583 : : /* No special handling needed for the pen */
584 [ # # ]: 0 : if (field->application == HID_DG_PEN)
585 : : return 0;
586 : :
587 [ # # # # : 0 : switch (usage->hid) {
# # # # #
# # ]
588 : 0 : case 0xff000001:
589 : : /* Tag indicating the start of a multitouch group */
590 : 0 : nd->reading_mt = true;
591 : 0 : nd->first_contact_touch = false;
592 : 0 : break;
593 : 0 : case HID_DG_TIPSWITCH:
594 : 0 : nd->tipswitch = value;
595 : : /* Prevent emission of touch until validated */
596 : 0 : return 1;
597 : 0 : case HID_DG_CONFIDENCE:
598 : 0 : nd->confidence = value;
599 : 0 : break;
600 : 0 : case HID_GD_X:
601 : 0 : nd->x = value;
602 : : /* Clear the contact footer */
603 : 0 : nd->mt_foot_count = 0;
604 : 0 : break;
605 : 0 : case HID_GD_Y:
606 : 0 : nd->y = value;
607 : 0 : break;
608 : 0 : case HID_DG_CONTACTID:
609 : 0 : nd->id = value;
610 : 0 : break;
611 : 0 : case HID_DG_WIDTH:
612 : 0 : nd->w = value;
613 : 0 : break;
614 : 0 : case HID_DG_HEIGHT:
615 : 0 : 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 [ # # ]: 0 : if (!nd->reading_mt) {
622 : : /*
623 : : * TipSwitch indicates the presence of a
624 : : * finger in single touch mode.
625 : : */
626 : 0 : input_report_key(input, BTN_TOUCH,
627 : 0 : nd->tipswitch);
628 : 0 : input_report_key(input, BTN_TOOL_DOUBLETAP,
629 : 0 : nd->tipswitch);
630 : 0 : input_event(input, EV_ABS, ABS_X, nd->x);
631 : 0 : input_event(input, EV_ABS, ABS_Y, nd->y);
632 : : }
633 : : break;
634 : 0 : 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 [ # # ]: 0 : if (nd->mt_foot_count >= 4)
644 : : break;
645 : :
646 : 0 : nd->mt_footer[nd->mt_foot_count++] = value;
647 : :
648 : : /* if the footer isn't complete break */
649 [ # # ]: 0 : if (nd->mt_foot_count != 4)
650 : : break;
651 : :
652 : : /* Pen activity signal. */
653 [ # # ]: 0 : 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 : 0 : nd->act_state = deactivate_slack - 1;
662 : 0 : nd->confidence = false;
663 : 0 : break;
664 : : }
665 : :
666 : : /*
667 : : * The first footer value indicates the presence of a
668 : : * finger.
669 : : */
670 [ # # ]: 0 : 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 [ # # ]: 0 : if (nd->w < nd->min_width ||
677 [ # # ]: 0 : nd->h < nd->min_height)
678 : 0 : nd->confidence = false;
679 : : } else
680 : : break;
681 : :
682 [ # # ]: 0 : if (nd->act_state > 0) {
683 : : /*
684 : : * Contact meets the activation size threshold
685 : : */
686 [ # # ]: 0 : if (nd->w >= nd->activation_width &&
687 [ # # ]: 0 : nd->h >= nd->activation_height) {
688 [ # # ]: 0 : if (nd->id)
689 : : /*
690 : : * first contact, activate now
691 : : */
692 : 0 : nd->act_state = 0;
693 : : else {
694 : : /*
695 : : * avoid corrupting this frame
696 : : * but ensure next frame will
697 : : * be active
698 : : */
699 : 0 : nd->act_state = 1;
700 : 0 : 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 [ # # ]: 0 : if (!nd->confidence)
712 : : break;
713 : :
714 : : /* emit a normal (X, Y) for the first point only */
715 [ # # ]: 0 : 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 : 0 : nd->first_contact_touch = nd->confidence;
723 : 0 : input_event(input, EV_ABS, ABS_X, nd->x);
724 : 0 : input_event(input, EV_ABS, ABS_Y, nd->y);
725 : : }
726 : :
727 : : /* Emit MT events */
728 : 0 : input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
729 : 0 : input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
730 : :
731 : : /*
732 : : * Translate from height and width to size
733 : : * and orientation.
734 : : */
735 [ # # ]: 0 : if (nd->w > nd->h) {
736 : 0 : input_event(input, EV_ABS,
737 : : ABS_MT_ORIENTATION, 1);
738 : 0 : input_event(input, EV_ABS,
739 : 0 : ABS_MT_TOUCH_MAJOR, nd->w);
740 : 0 : input_event(input, EV_ABS,
741 : 0 : ABS_MT_TOUCH_MINOR, nd->h);
742 : : } else {
743 : 0 : input_event(input, EV_ABS,
744 : : ABS_MT_ORIENTATION, 0);
745 : 0 : input_event(input, EV_ABS,
746 : 0 : ABS_MT_TOUCH_MAJOR, nd->h);
747 : 0 : input_event(input, EV_ABS,
748 : 0 : ABS_MT_TOUCH_MINOR, nd->w);
749 : : }
750 : 0 : input_mt_sync(field->hidinput->input);
751 : : break;
752 : :
753 : 0 : case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
754 [ # # ]: 0 : if (!nd->reading_mt) /* Just to be sure */
755 : : break;
756 : :
757 : 0 : 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 [ # # ]: 0 : if (nd->act_state > 0) { /* Currently inactive */
782 [ # # ]: 0 : if (value)
783 : : /*
784 : : * Consider each live contact as
785 : : * evidence of intentional activity.
786 : : */
787 [ # # ]: 0 : nd->act_state = (nd->act_state > value)
788 : 0 : ? nd->act_state - value
789 : : : 0;
790 : : else
791 : : /*
792 : : * Empty frame before we hit the
793 : : * activity threshold, reset.
794 : : */
795 : 0 : 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 [ # # ]: 0 : if (value && nd->act_state >=
805 [ # # ]: 0 : nd->deactivate_slack)
806 : : /*
807 : : * Live point: clear accumulated
808 : : * deactivation count.
809 : : */
810 : 0 : nd->act_state = 0;
811 [ # # ]: 0 : else if (nd->act_state <= nd->deactivate_slack)
812 : : /*
813 : : * We've consumed the deactivation
814 : : * slack, time to deactivate and reset.
815 : : */
816 : 0 : nd->act_state =
817 : 0 : nd->activate_slack;
818 : : else { /* Move towards deactivation */
819 : 0 : nd->act_state--;
820 : 0 : break;
821 : : }
822 : : }
823 : :
824 [ # # # # ]: 0 : 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 : 0 : input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
837 : 0 : input_report_key(input, BTN_TOUCH, 1);
838 : : } else {
839 : 0 : input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
840 : 0 : input_report_key(input, BTN_TOUCH, 0);
841 : : }
842 : : break;
843 : :
844 : : default:
845 : : /* fall-back to the generic hidinput handling */
846 : : return 0;
847 : : }
848 : :
849 : 0 : not_claimed_input:
850 : :
851 : : /* we have handled the hidinput part, now remains hiddev */
852 [ # # # # ]: 0 : if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
853 : 0 : hid->hiddev_hid_event(hid, field, usage, value);
854 : :
855 : : return 1;
856 : : }
857 : :
858 : 0 : static int ntrig_input_configured(struct hid_device *hid,
859 : : struct hid_input *hidinput)
860 : :
861 : : {
862 : 0 : struct input_dev *input = hidinput->input;
863 : :
864 [ # # ]: 0 : if (hidinput->report->maxfield < 1)
865 : : return 0;
866 : :
867 [ # # # ]: 0 : switch (hidinput->report->field[0]->application) {
868 : 0 : case HID_DG_PEN:
869 : 0 : input->name = "N-Trig Pen";
870 : 0 : break;
871 : 0 : case HID_DG_TOUCHSCREEN:
872 : : /* These keys are redundant for fingers, clear them
873 : : * to prevent incorrect identification */
874 : 0 : __clear_bit(BTN_TOOL_PEN, input->keybit);
875 : 0 : __clear_bit(BTN_TOOL_FINGER, input->keybit);
876 : 0 : __clear_bit(BTN_0, input->keybit);
877 : 0 : __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 : 0 : input->name = (hidinput->report->field[0]->physical) ?
885 [ # # ]: 0 : "N-Trig Touchscreen" :
886 : : "N-Trig MultiTouch";
887 : 0 : break;
888 : : }
889 : :
890 : : return 0;
891 : : }
892 : :
893 : 0 : static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
894 : : {
895 : 0 : int ret;
896 : 0 : struct ntrig_data *nd;
897 : 0 : struct hid_report *report;
898 : :
899 [ # # ]: 0 : if (id->driver_data)
900 : 0 : hdev->quirks |= HID_QUIRK_MULTI_INPUT
901 : : | HID_QUIRK_NO_INIT_REPORTS;
902 : :
903 : 0 : nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
904 [ # # ]: 0 : if (!nd) {
905 : 0 : hid_err(hdev, "cannot allocate N-Trig data\n");
906 : 0 : return -ENOMEM;
907 : : }
908 : :
909 : 0 : nd->reading_mt = false;
910 : 0 : nd->min_width = 0;
911 : 0 : nd->min_height = 0;
912 : 0 : nd->activate_slack = activate_slack;
913 : 0 : nd->act_state = activate_slack;
914 : 0 : nd->deactivate_slack = -deactivate_slack;
915 : 0 : nd->sensor_logical_width = 1;
916 : 0 : nd->sensor_logical_height = 1;
917 : 0 : nd->sensor_physical_width = 1;
918 : 0 : nd->sensor_physical_height = 1;
919 : :
920 : 0 : hid_set_drvdata(hdev, nd);
921 : :
922 : 0 : ret = hid_parse(hdev);
923 [ # # ]: 0 : if (ret) {
924 : 0 : hid_err(hdev, "parse failed\n");
925 : 0 : goto err_free;
926 : : }
927 : :
928 : 0 : ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
929 [ # # ]: 0 : if (ret) {
930 : 0 : hid_err(hdev, "hw start failed\n");
931 : 0 : goto err_free;
932 : : }
933 : :
934 : : /* This is needed for devices with more recent firmware versions */
935 : 0 : report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
936 [ # # ]: 0 : if (report) {
937 : : /* Let the device settle to ensure the wakeup message gets
938 : : * through */
939 [ # # ]: 0 : hid_hw_wait(hdev);
940 : 0 : hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
941 : :
942 : : /*
943 : : * Sanity check: if the current mode is invalid reset it to
944 : : * something reasonable.
945 : : */
946 [ # # ]: 0 : if (ntrig_get_mode(hdev) >= 4)
947 [ # # ]: 0 : ntrig_set_mode(hdev, 3);
948 : : }
949 : :
950 : 0 : ntrig_report_version(hdev);
951 : :
952 : 0 : ret = sysfs_create_group(&hdev->dev.kobj,
953 : : &ntrig_attribute_group);
954 [ # # ]: 0 : if (ret)
955 : 0 : hid_err(hdev, "cannot create sysfs group\n");
956 : :
957 : : return 0;
958 : 0 : err_free:
959 : 0 : kfree(nd);
960 : 0 : return ret;
961 : : }
962 : :
963 : 0 : static void ntrig_remove(struct hid_device *hdev)
964 : : {
965 : 0 : sysfs_remove_group(&hdev->dev.kobj,
966 : : &ntrig_attribute_group);
967 : 0 : hid_hw_stop(hdev);
968 : 0 : kfree(hid_get_drvdata(hdev));
969 : 0 : }
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 : 30 : module_hid_driver(ntrig_driver);
1031 : :
1032 : : MODULE_LICENSE("GPL");
|
