hid-ntrig.c (44b56603c4c476b845a824cff6fe905c6268b2a1) hid-ntrig.c (6e32819e12ffbd507eced11a1871700a387d5407)
1/*
2 * HID driver for N-Trig touchscreens
3 *
4 * Copyright (c) 2008-2010 Rafi Rubin
5 * Copyright (c) 2009-2010 Stephane Chatty
6 *
7 */
8

--- 10 unchanged lines hidden (view full) ---

19#include "usbhid/usbhid.h"
20#include <linux/module.h>
21#include <linux/slab.h>
22
23#include "hid-ids.h"
24
25#define NTRIG_DUPLICATE_USAGES 0x001
26
1/*
2 * HID driver for N-Trig touchscreens
3 *
4 * Copyright (c) 2008-2010 Rafi Rubin
5 * Copyright (c) 2009-2010 Stephane Chatty
6 *
7 */
8

--- 10 unchanged lines hidden (view full) ---

19#include "usbhid/usbhid.h"
20#include <linux/module.h>
21#include <linux/slab.h>
22
23#include "hid-ids.h"
24
25#define NTRIG_DUPLICATE_USAGES 0x001
26
27static unsigned int min_width;
28module_param(min_width, uint, 0644);
29MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
30
31static unsigned int min_height;
32module_param(min_height, uint, 0644);
33MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
34
35static unsigned int activate_slack = 1;
36module_param(activate_slack, uint, 0644);
37MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
38 "the start of touch input.");
39
40static unsigned int deactivate_slack = 4;
41module_param(deactivate_slack, uint, 0644);
42MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
43 "deactivating touch.");
44
45static unsigned int activation_width = 64;
46module_param(activation_width, uint, 0644);
47MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
48 "processing touch events.");
49
50static unsigned int activation_height = 32;
51module_param(activation_height, uint, 0644);
52MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
53 "processing touch events.");
54
27struct ntrig_data {
28 /* Incoming raw values for a single contact */
29 __u16 x, y, w, h;
30 __u16 id;
31
32 bool tipswitch;
33 bool confidence;
34 bool first_contact_touch;
35
36 bool reading_mt;
37
38 __u8 mt_footer[4];
39 __u8 mt_foot_count;
55struct ntrig_data {
56 /* Incoming raw values for a single contact */
57 __u16 x, y, w, h;
58 __u16 id;
59
60 bool tipswitch;
61 bool confidence;
62 bool first_contact_touch;
63
64 bool reading_mt;
65
66 __u8 mt_footer[4];
67 __u8 mt_foot_count;
68
69 /* The current activation state. */
70 __s8 act_state;
71
72 /* Empty frames to ignore before recognizing the end of activity */
73 __s8 deactivate_slack;
74
75 /* Frames to ignore before acknowledging the start of activity */
76 __s8 activate_slack;
77
78 /* Minimum size contact to accept */
79 __u16 min_width;
80 __u16 min_height;
81
82 /* Threshold to override activation slack */
83 __u16 activation_width;
84 __u16 activation_height;
85
86 __u16 sensor_logical_width;
87 __u16 sensor_logical_height;
88 __u16 sensor_physical_width;
89 __u16 sensor_physical_height;
40};
41
90};
91
92
93static ssize_t show_phys_width(struct device *dev,
94 struct device_attribute *attr,
95 char *buf)
96{
97 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
98 struct ntrig_data *nd = hid_get_drvdata(hdev);
99
100 return sprintf(buf, "%d\n", nd->sensor_physical_width);
101}
102
103static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
104
105static ssize_t show_phys_height(struct device *dev,
106 struct device_attribute *attr,
107 char *buf)
108{
109 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
110 struct ntrig_data *nd = hid_get_drvdata(hdev);
111
112 return sprintf(buf, "%d\n", nd->sensor_physical_height);
113}
114
115static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
116
117static ssize_t show_log_width(struct device *dev,
118 struct device_attribute *attr,
119 char *buf)
120{
121 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
122 struct ntrig_data *nd = hid_get_drvdata(hdev);
123
124 return sprintf(buf, "%d\n", nd->sensor_logical_width);
125}
126
127static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
128
129static ssize_t show_log_height(struct device *dev,
130 struct device_attribute *attr,
131 char *buf)
132{
133 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
134 struct ntrig_data *nd = hid_get_drvdata(hdev);
135
136 return sprintf(buf, "%d\n", nd->sensor_logical_height);
137}
138
139static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
140
141static ssize_t show_min_width(struct device *dev,
142 struct device_attribute *attr,
143 char *buf)
144{
145 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
146 struct ntrig_data *nd = hid_get_drvdata(hdev);
147
148 return sprintf(buf, "%d\n", nd->min_width *
149 nd->sensor_physical_width /
150 nd->sensor_logical_width);
151}
152
153static ssize_t set_min_width(struct device *dev,
154 struct device_attribute *attr,
155 const char *buf, size_t count)
156{
157 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
158 struct ntrig_data *nd = hid_get_drvdata(hdev);
159
160 unsigned long val;
161
162 if (strict_strtoul(buf, 0, &val))
163 return -EINVAL;
164
165 if (val > nd->sensor_physical_width)
166 return -EINVAL;
167
168 nd->min_width = val * nd->sensor_logical_width /
169 nd->sensor_physical_width;
170
171 return count;
172}
173
174static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
175
176static ssize_t show_min_height(struct device *dev,
177 struct device_attribute *attr,
178 char *buf)
179{
180 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
181 struct ntrig_data *nd = hid_get_drvdata(hdev);
182
183 return sprintf(buf, "%d\n", nd->min_height *
184 nd->sensor_physical_height /
185 nd->sensor_logical_height);
186}
187
188static ssize_t set_min_height(struct device *dev,
189 struct device_attribute *attr,
190 const char *buf, size_t count)
191{
192 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
193 struct ntrig_data *nd = hid_get_drvdata(hdev);
194
195 unsigned long val;
196
197 if (strict_strtoul(buf, 0, &val))
198 return -EINVAL;
199
200 if (val > nd->sensor_physical_height)
201 return -EINVAL;
202
203 nd->min_height = val * nd->sensor_logical_height /
204 nd->sensor_physical_height;
205
206 return count;
207}
208
209static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
210 set_min_height);
211
212static ssize_t show_activate_slack(struct device *dev,
213 struct device_attribute *attr,
214 char *buf)
215{
216 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
217 struct ntrig_data *nd = hid_get_drvdata(hdev);
218
219 return sprintf(buf, "%d\n", nd->activate_slack);
220}
221
222static ssize_t set_activate_slack(struct device *dev,
223 struct device_attribute *attr,
224 const char *buf, size_t count)
225{
226 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
227 struct ntrig_data *nd = hid_get_drvdata(hdev);
228
229 unsigned long val;
230
231 if (strict_strtoul(buf, 0, &val))
232 return -EINVAL;
233
234 if (val > 0x7f)
235 return -EINVAL;
236
237 nd->activate_slack = val;
238
239 return count;
240}
241
242static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
243 set_activate_slack);
244
245static ssize_t show_activation_width(struct device *dev,
246 struct device_attribute *attr,
247 char *buf)
248{
249 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
250 struct ntrig_data *nd = hid_get_drvdata(hdev);
251
252 return sprintf(buf, "%d\n", nd->activation_width *
253 nd->sensor_physical_width /
254 nd->sensor_logical_width);
255}
256
257static ssize_t set_activation_width(struct device *dev,
258 struct device_attribute *attr,
259 const char *buf, size_t count)
260{
261 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
262 struct ntrig_data *nd = hid_get_drvdata(hdev);
263
264 unsigned long val;
265
266 if (strict_strtoul(buf, 0, &val))
267 return -EINVAL;
268
269 if (val > nd->sensor_physical_width)
270 return -EINVAL;
271
272 nd->activation_width = val * nd->sensor_logical_width /
273 nd->sensor_physical_width;
274
275 return count;
276}
277
278static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
279 set_activation_width);
280
281static ssize_t show_activation_height(struct device *dev,
282 struct device_attribute *attr,
283 char *buf)
284{
285 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
286 struct ntrig_data *nd = hid_get_drvdata(hdev);
287
288 return sprintf(buf, "%d\n", nd->activation_height *
289 nd->sensor_physical_height /
290 nd->sensor_logical_height);
291}
292
293static ssize_t set_activation_height(struct device *dev,
294 struct device_attribute *attr,
295 const char *buf, size_t count)
296{
297 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
298 struct ntrig_data *nd = hid_get_drvdata(hdev);
299
300 unsigned long val;
301
302 if (strict_strtoul(buf, 0, &val))
303 return -EINVAL;
304
305 if (val > nd->sensor_physical_height)
306 return -EINVAL;
307
308 nd->activation_height = val * nd->sensor_logical_height /
309 nd->sensor_physical_height;
310
311 return count;
312}
313
314static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
315 show_activation_height, set_activation_height);
316
317static ssize_t show_deactivate_slack(struct device *dev,
318 struct device_attribute *attr,
319 char *buf)
320{
321 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
322 struct ntrig_data *nd = hid_get_drvdata(hdev);
323
324 return sprintf(buf, "%d\n", -nd->deactivate_slack);
325}
326
327static ssize_t set_deactivate_slack(struct device *dev,
328 struct device_attribute *attr,
329 const char *buf, size_t count)
330{
331 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
332 struct ntrig_data *nd = hid_get_drvdata(hdev);
333
334 unsigned long val;
335
336 if (strict_strtoul(buf, 0, &val))
337 return -EINVAL;
338
339 /*
340 * No more than 8 terminal frames have been observed so far
341 * and higher slack is highly likely to leave the single
342 * touch emulation stuck down.
343 */
344 if (val > 7)
345 return -EINVAL;
346
347 nd->deactivate_slack = -val;
348
349 return count;
350}
351
352static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
353 set_deactivate_slack);
354
355static struct attribute *sysfs_attrs[] = {
356 &dev_attr_sensor_physical_width.attr,
357 &dev_attr_sensor_physical_height.attr,
358 &dev_attr_sensor_logical_width.attr,
359 &dev_attr_sensor_logical_height.attr,
360 &dev_attr_min_height.attr,
361 &dev_attr_min_width.attr,
362 &dev_attr_activate_slack.attr,
363 &dev_attr_activation_width.attr,
364 &dev_attr_activation_height.attr,
365 &dev_attr_deactivate_slack.attr,
366 NULL
367};
368
369static struct attribute_group ntrig_attribute_group = {
370 .attrs = sysfs_attrs
371};
372
42/*
43 * this driver is aimed at two firmware versions in circulation:
44 * - dual pen/finger single touch
45 * - finger multitouch, pen not working
46 */
47
48static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
49 struct hid_field *field, struct hid_usage *usage,
50 unsigned long **bit, int *max)
51{
373/*
374 * this driver is aimed at two firmware versions in circulation:
375 * - dual pen/finger single touch
376 * - finger multitouch, pen not working
377 */
378
379static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
380 struct hid_field *field, struct hid_usage *usage,
381 unsigned long **bit, int *max)
382{
383 struct ntrig_data *nd = hid_get_drvdata(hdev);
384
52 /* No special mappings needed for the pen and single touch */
53 if (field->physical)
54 return 0;
55
56 switch (usage->hid & HID_USAGE_PAGE) {
57 case HID_UP_GENDESK:
58 switch (usage->hid) {
59 case HID_GD_X:
60 hid_map_usage(hi, usage, bit, max,
61 EV_ABS, ABS_MT_POSITION_X);
62 input_set_abs_params(hi->input, ABS_X,
63 field->logical_minimum,
64 field->logical_maximum, 0, 0);
385 /* No special mappings needed for the pen and single touch */
386 if (field->physical)
387 return 0;
388
389 switch (usage->hid & HID_USAGE_PAGE) {
390 case HID_UP_GENDESK:
391 switch (usage->hid) {
392 case HID_GD_X:
393 hid_map_usage(hi, usage, bit, max,
394 EV_ABS, ABS_MT_POSITION_X);
395 input_set_abs_params(hi->input, ABS_X,
396 field->logical_minimum,
397 field->logical_maximum, 0, 0);
398
399 if (!nd->sensor_logical_width) {
400 nd->sensor_logical_width =
401 field->logical_maximum -
402 field->logical_minimum;
403 nd->sensor_physical_width =
404 field->physical_maximum -
405 field->physical_minimum;
406 nd->activation_width = activation_width *
407 nd->sensor_logical_width /
408 nd->sensor_physical_width;
409 nd->min_width = min_width *
410 nd->sensor_logical_width /
411 nd->sensor_physical_width;
412 }
65 return 1;
66 case HID_GD_Y:
67 hid_map_usage(hi, usage, bit, max,
68 EV_ABS, ABS_MT_POSITION_Y);
69 input_set_abs_params(hi->input, ABS_Y,
70 field->logical_minimum,
71 field->logical_maximum, 0, 0);
413 return 1;
414 case HID_GD_Y:
415 hid_map_usage(hi, usage, bit, max,
416 EV_ABS, ABS_MT_POSITION_Y);
417 input_set_abs_params(hi->input, ABS_Y,
418 field->logical_minimum,
419 field->logical_maximum, 0, 0);
420
421 if (!nd->sensor_logical_height) {
422 nd->sensor_logical_height =
423 field->logical_maximum -
424 field->logical_minimum;
425 nd->sensor_physical_height =
426 field->physical_maximum -
427 field->physical_minimum;
428 nd->activation_height = activation_height *
429 nd->sensor_logical_height /
430 nd->sensor_physical_height;
431 nd->min_height = min_height *
432 nd->sensor_logical_height /
433 nd->sensor_physical_height;
434 }
72 return 1;
73 }
74 return 0;
75
76 case HID_UP_DIGITIZER:
77 switch (usage->hid) {
78 /* we do not want to map these for now */
79 case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */

--- 116 unchanged lines hidden (view full) ---

196 break;
197
198 nd->mt_footer[nd->mt_foot_count++] = value;
199
200 /* if the footer isn't complete break */
201 if (nd->mt_foot_count != 4)
202 break;
203
435 return 1;
436 }
437 return 0;
438
439 case HID_UP_DIGITIZER:
440 switch (usage->hid) {
441 /* we do not want to map these for now */
442 case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */

--- 116 unchanged lines hidden (view full) ---

559 break;
560
561 nd->mt_footer[nd->mt_foot_count++] = value;
562
563 /* if the footer isn't complete break */
564 if (nd->mt_foot_count != 4)
565 break;
566
204 /* Pen activity signal, trigger end of touch. */
567 /* Pen activity signal. */
205 if (nd->mt_footer[2]) {
568 if (nd->mt_footer[2]) {
569 /*
570 * When the pen deactivates touch, we see a
571 * bogus frame with ContactCount > 0.
572 * We can
573 * save a bit of work by ensuring act_state < 0
574 * even if deactivation slack is turned off.
575 */
576 nd->act_state = deactivate_slack - 1;
206 nd->confidence = 0;
207 break;
208 }
209
577 nd->confidence = 0;
578 break;
579 }
580
210 /* If the contact was invalid */
211 if (!(nd->confidence && nd->mt_footer[0])
212 || nd->w <= 250
213 || nd->h <= 190) {
214 nd->confidence = 0;
581 /*
582 * The first footer value indicates the presence of a
583 * finger.
584 */
585 if (nd->mt_footer[0]) {
586 /*
587 * We do not want to process contacts under
588 * the size threshold, but do not want to
589 * ignore them for activation state
590 */
591 if (nd->w < nd->min_width ||
592 nd->h < nd->min_height)
593 nd->confidence = 0;
594 } else
215 break;
595 break;
596
597 if (nd->act_state > 0) {
598 /*
599 * Contact meets the activation size threshold
600 */
601 if (nd->w >= nd->activation_width &&
602 nd->h >= nd->activation_height) {
603 if (nd->id)
604 /*
605 * first contact, activate now
606 */
607 nd->act_state = 0;
608 else {
609 /*
610 * avoid corrupting this frame
611 * but ensure next frame will
612 * be active
613 */
614 nd->act_state = 1;
615 break;
616 }
617 } else
618 /*
619 * Defer adjusting the activation state
620 * until the end of the frame.
621 */
622 break;
216 }
217
623 }
624
625 /* Discarding this contact */
626 if (!nd->confidence)
627 break;
628
218 /* emit a normal (X, Y) for the first point only */
219 if (nd->id == 0) {
220 /*
221 * TipSwitch is superfluous in multitouch
222 * mode. The footer events tell us
223 * if there is a finger on the screen or
224 * not.
225 */
226 nd->first_contact_touch = nd->confidence;
227 input_event(input, EV_ABS, ABS_X, nd->x);
228 input_event(input, EV_ABS, ABS_Y, nd->y);
229 }
629 /* emit a normal (X, Y) for the first point only */
630 if (nd->id == 0) {
631 /*
632 * TipSwitch is superfluous in multitouch
633 * mode. The footer events tell us
634 * if there is a finger on the screen or
635 * not.
636 */
637 nd->first_contact_touch = nd->confidence;
638 input_event(input, EV_ABS, ABS_X, nd->x);
639 input_event(input, EV_ABS, ABS_Y, nd->y);
640 }
641
642 /* Emit MT events */
230 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
231 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
643 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
644 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
645
646 /*
647 * Translate from height and width to size
648 * and orientation.
649 */
232 if (nd->w > nd->h) {
233 input_event(input, EV_ABS,
234 ABS_MT_ORIENTATION, 1);
235 input_event(input, EV_ABS,
236 ABS_MT_TOUCH_MAJOR, nd->w);
237 input_event(input, EV_ABS,
238 ABS_MT_TOUCH_MINOR, nd->h);
239 } else {
240 input_event(input, EV_ABS,
241 ABS_MT_ORIENTATION, 0);
242 input_event(input, EV_ABS,
243 ABS_MT_TOUCH_MAJOR, nd->h);
244 input_event(input, EV_ABS,
245 ABS_MT_TOUCH_MINOR, nd->w);
246 }
247 input_mt_sync(field->hidinput->input);
248 break;
249
250 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
650 if (nd->w > nd->h) {
651 input_event(input, EV_ABS,
652 ABS_MT_ORIENTATION, 1);
653 input_event(input, EV_ABS,
654 ABS_MT_TOUCH_MAJOR, nd->w);
655 input_event(input, EV_ABS,
656 ABS_MT_TOUCH_MINOR, nd->h);
657 } else {
658 input_event(input, EV_ABS,
659 ABS_MT_ORIENTATION, 0);
660 input_event(input, EV_ABS,
661 ABS_MT_TOUCH_MAJOR, nd->h);
662 input_event(input, EV_ABS,
663 ABS_MT_TOUCH_MINOR, nd->w);
664 }
665 input_mt_sync(field->hidinput->input);
666 break;
667
668 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
251 if (!nd->reading_mt)
669 if (!nd->reading_mt) /* Just to be sure */
252 break;
253
254 nd->reading_mt = 0;
255
670 break;
671
672 nd->reading_mt = 0;
673
256 if (nd->first_contact_touch) {
674
675 /*
676 * Activation state machine logic:
677 *
678 * Fundamental states:
679 * state > 0: Inactive
680 * state <= 0: Active
681 * state < -deactivate_slack:
682 * Pen termination of touch
683 *
684 * Specific values of interest
685 * state == activate_slack
686 * no valid input since the last reset
687 *
688 * state == 0
689 * general operational state
690 *
691 * state == -deactivate_slack
692 * read sufficient empty frames to accept
693 * the end of input and reset
694 */
695
696 if (nd->act_state > 0) { /* Currently inactive */
697 if (value)
698 /*
699 * Consider each live contact as
700 * evidence of intentional activity.
701 */
702 nd->act_state = (nd->act_state > value)
703 ? nd->act_state - value
704 : 0;
705 else
706 /*
707 * Empty frame before we hit the
708 * activity threshold, reset.
709 */
710 nd->act_state = nd->activate_slack;
711
712 /*
713 * Entered this block inactive and no
714 * coordinates sent this frame, so hold off
715 * on button state.
716 */
717 break;
718 } else { /* Currently active */
719 if (value && nd->act_state >=
720 nd->deactivate_slack)
721 /*
722 * Live point: clear accumulated
723 * deactivation count.
724 */
725 nd->act_state = 0;
726 else if (nd->act_state <= nd->deactivate_slack)
727 /*
728 * We've consumed the deactivation
729 * slack, time to deactivate and reset.
730 */
731 nd->act_state =
732 nd->activate_slack;
733 else { /* Move towards deactivation */
734 nd->act_state--;
735 break;
736 }
737 }
738
739 if (nd->first_contact_touch && nd->act_state <= 0) {
740 /*
741 * Check to see if we're ready to start
742 * emitting touch events.
743 *
744 * Note: activation slack will decrease over
745 * the course of the frame, and it will be
746 * inconsistent from the start to the end of
747 * the frame. However if the frame starts
748 * with slack, first_contact_touch will still
749 * be 0 and we will not get to this point.
750 */
257 input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
258 input_report_key(input, BTN_TOUCH, 1);
259 } else {
260 input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
261 input_report_key(input, BTN_TOUCH, 0);
262 }
263 break;
264
265 default:
751 input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
752 input_report_key(input, BTN_TOUCH, 1);
753 } else {
754 input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
755 input_report_key(input, BTN_TOUCH, 0);
756 }
757 break;
758
759 default:
266 /* fallback to the generic hidinput handling */
760 /* fall-back to the generic hidinput handling */
267 return 0;
268 }
269 }
270
271 /* we have handled the hidinput part, now remains hiddev */
272 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
273 hid->hiddev_hid_event(hid, field, usage, value);
274

--- 13 unchanged lines hidden (view full) ---

288
289 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
290 if (!nd) {
291 dev_err(&hdev->dev, "cannot allocate N-Trig data\n");
292 return -ENOMEM;
293 }
294
295 nd->reading_mt = 0;
761 return 0;
762 }
763 }
764
765 /* we have handled the hidinput part, now remains hiddev */
766 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
767 hid->hiddev_hid_event(hid, field, usage, value);
768

--- 13 unchanged lines hidden (view full) ---

782
783 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
784 if (!nd) {
785 dev_err(&hdev->dev, "cannot allocate N-Trig data\n");
786 return -ENOMEM;
787 }
788
789 nd->reading_mt = 0;
790 nd->min_width = 0;
791 nd->min_height = 0;
792 nd->activate_slack = activate_slack;
793 nd->act_state = activate_slack;
794 nd->deactivate_slack = -deactivate_slack;
795 nd->sensor_logical_width = 0;
796 nd->sensor_logical_height = 0;
797 nd->sensor_physical_width = 0;
798 nd->sensor_physical_height = 0;
799
296 hid_set_drvdata(hdev, nd);
297
298 ret = hid_parse(hdev);
299 if (ret) {
300 dev_err(&hdev->dev, "parse failed\n");
301 goto err_free;
302 }
303

--- 35 unchanged lines hidden (view full) ---

339 }
340 }
341
342 /* This is needed for devices with more recent firmware versions */
343 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
344 if (report)
345 usbhid_submit_report(hdev, report, USB_DIR_OUT);
346
800 hid_set_drvdata(hdev, nd);
801
802 ret = hid_parse(hdev);
803 if (ret) {
804 dev_err(&hdev->dev, "parse failed\n");
805 goto err_free;
806 }
807

--- 35 unchanged lines hidden (view full) ---

843 }
844 }
845
846 /* This is needed for devices with more recent firmware versions */
847 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
848 if (report)
849 usbhid_submit_report(hdev, report, USB_DIR_OUT);
850
851 ret = sysfs_create_group(&hdev->dev.kobj,
852 &ntrig_attribute_group);
347
348 return 0;
349err_free:
350 kfree(nd);
351 return ret;
352}
353
354static void ntrig_remove(struct hid_device *hdev)
355{
853
854 return 0;
855err_free:
856 kfree(nd);
857 return ret;
858}
859
860static void ntrig_remove(struct hid_device *hdev)
861{
862 sysfs_remove_group(&hdev->dev.kobj,
863 &ntrig_attribute_group);
356 hid_hw_stop(hdev);
357 kfree(hid_get_drvdata(hdev));
358}
359
360static const struct hid_device_id ntrig_devices[] = {
361 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
362 .driver_data = NTRIG_DUPLICATE_USAGES },
864 hid_hw_stop(hdev);
865 kfree(hid_get_drvdata(hdev));
866}
867
868static const struct hid_device_id ntrig_devices[] = {
869 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
870 .driver_data = NTRIG_DUPLICATE_USAGES },
871 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),
872 .driver_data = NTRIG_DUPLICATE_USAGES },
873 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),
874 .driver_data = NTRIG_DUPLICATE_USAGES },
875 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),
876 .driver_data = NTRIG_DUPLICATE_USAGES },
877 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),
878 .driver_data = NTRIG_DUPLICATE_USAGES },
879 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),
880 .driver_data = NTRIG_DUPLICATE_USAGES },
881 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),
882 .driver_data = NTRIG_DUPLICATE_USAGES },
883 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),
884 .driver_data = NTRIG_DUPLICATE_USAGES },
885 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),
886 .driver_data = NTRIG_DUPLICATE_USAGES },
887 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),
888 .driver_data = NTRIG_DUPLICATE_USAGES },
889 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),
890 .driver_data = NTRIG_DUPLICATE_USAGES },
891 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),
892 .driver_data = NTRIG_DUPLICATE_USAGES },
893 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),
894 .driver_data = NTRIG_DUPLICATE_USAGES },
895 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),
896 .driver_data = NTRIG_DUPLICATE_USAGES },
897 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),
898 .driver_data = NTRIG_DUPLICATE_USAGES },
899 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),
900 .driver_data = NTRIG_DUPLICATE_USAGES },
901 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),
902 .driver_data = NTRIG_DUPLICATE_USAGES },
903 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),
904 .driver_data = NTRIG_DUPLICATE_USAGES },
905 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),
906 .driver_data = NTRIG_DUPLICATE_USAGES },
363 { }
364};
365MODULE_DEVICE_TABLE(hid, ntrig_devices);
366
367static const struct hid_usage_id ntrig_grabbed_usages[] = {
368 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
369 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
370};

--- 25 unchanged lines hidden --- 		907 { }
908};
909MODULE_DEVICE_TABLE(hid, ntrig_devices);
910
911static const struct hid_usage_id ntrig_grabbed_usages[] = {
912 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
913 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
914};

--- 25 unchanged lines hidden ---