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