2 * HID driver for N-Trig touchscreens
4 * Copyright (c) 2008-2010 Rafi Rubin
5 * Copyright (c) 2009-2010 Stephane Chatty
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)
16 #include <linux/device.h>
17 #include <linux/hid.h>
18 #include <linux/usb.h>
19 #include "usbhid/usbhid.h"
20 #include <linux/module.h>
21 #include <linux/slab.h>
25 #define NTRIG_DUPLICATE_USAGES 0x001
27 static unsigned int min_width;
28 module_param(min_width, uint, 0644);
29 MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
31 static unsigned int min_height;
32 module_param(min_height, uint, 0644);
33 MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
35 static unsigned int activate_slack = 1;
36 module_param(activate_slack, uint, 0644);
37 MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
38 "the start of touch input.");
40 static unsigned int deactivate_slack = 4;
41 module_param(deactivate_slack, uint, 0644);
42 MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
43 "deactivating touch.");
45 static unsigned int activation_width = 64;
46 module_param(activation_width, uint, 0644);
47 MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
48 "processing touch events.");
50 static unsigned int activation_height = 32;
51 module_param(activation_height, uint, 0644);
52 MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
53 "processing touch events.");
56 /* Incoming raw values for a single contact */
62 bool first_contact_touch;
69 /* The current activation state. */
72 /* Empty frames to ignore before recognizing the end of activity */
73 __s8 deactivate_slack;
75 /* Frames to ignore before acknowledging the start of activity */
78 /* Minimum size contact to accept */
82 /* Threshold to override activation slack */
83 __u16 activation_width;
84 __u16 activation_height;
86 __u16 sensor_logical_width;
87 __u16 sensor_logical_height;
88 __u16 sensor_physical_width;
89 __u16 sensor_physical_height;
93 static ssize_t show_phys_width(struct device *dev,
94 struct device_attribute *attr,
97 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
98 struct ntrig_data *nd = hid_get_drvdata(hdev);
100 return sprintf(buf, "%d\n", nd->sensor_physical_width);
103 static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
105 static ssize_t show_phys_height(struct device *dev,
106 struct device_attribute *attr,
109 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
110 struct ntrig_data *nd = hid_get_drvdata(hdev);
112 return sprintf(buf, "%d\n", nd->sensor_physical_height);
115 static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
117 static ssize_t show_log_width(struct device *dev,
118 struct device_attribute *attr,
121 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
122 struct ntrig_data *nd = hid_get_drvdata(hdev);
124 return sprintf(buf, "%d\n", nd->sensor_logical_width);
127 static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
129 static ssize_t show_log_height(struct device *dev,
130 struct device_attribute *attr,
133 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
134 struct ntrig_data *nd = hid_get_drvdata(hdev);
136 return sprintf(buf, "%d\n", nd->sensor_logical_height);
139 static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
141 static ssize_t show_min_width(struct device *dev,
142 struct device_attribute *attr,
145 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
146 struct ntrig_data *nd = hid_get_drvdata(hdev);
148 return sprintf(buf, "%d\n", nd->min_width *
149 nd->sensor_physical_width /
150 nd->sensor_logical_width);
153 static ssize_t set_min_width(struct device *dev,
154 struct device_attribute *attr,
155 const char *buf, size_t count)
157 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
158 struct ntrig_data *nd = hid_get_drvdata(hdev);
162 if (strict_strtoul(buf, 0, &val))
165 if (val > nd->sensor_physical_width)
168 nd->min_width = val * nd->sensor_logical_width /
169 nd->sensor_physical_width;
174 static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
176 static ssize_t show_min_height(struct device *dev,
177 struct device_attribute *attr,
180 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
181 struct ntrig_data *nd = hid_get_drvdata(hdev);
183 return sprintf(buf, "%d\n", nd->min_height *
184 nd->sensor_physical_height /
185 nd->sensor_logical_height);
188 static ssize_t set_min_height(struct device *dev,
189 struct device_attribute *attr,
190 const char *buf, size_t count)
192 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
193 struct ntrig_data *nd = hid_get_drvdata(hdev);
197 if (strict_strtoul(buf, 0, &val))
200 if (val > nd->sensor_physical_height)
203 nd->min_height = val * nd->sensor_logical_height /
204 nd->sensor_physical_height;
209 static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
212 static ssize_t show_activate_slack(struct device *dev,
213 struct device_attribute *attr,
216 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
217 struct ntrig_data *nd = hid_get_drvdata(hdev);
219 return sprintf(buf, "%d\n", nd->activate_slack);
222 static ssize_t set_activate_slack(struct device *dev,
223 struct device_attribute *attr,
224 const char *buf, size_t count)
226 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
227 struct ntrig_data *nd = hid_get_drvdata(hdev);
231 if (strict_strtoul(buf, 0, &val))
237 nd->activate_slack = val;
242 static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
245 static ssize_t show_activation_width(struct device *dev,
246 struct device_attribute *attr,
249 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
250 struct ntrig_data *nd = hid_get_drvdata(hdev);
252 return sprintf(buf, "%d\n", nd->activation_width *
253 nd->sensor_physical_width /
254 nd->sensor_logical_width);
257 static ssize_t set_activation_width(struct device *dev,
258 struct device_attribute *attr,
259 const char *buf, size_t count)
261 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
262 struct ntrig_data *nd = hid_get_drvdata(hdev);
266 if (strict_strtoul(buf, 0, &val))
269 if (val > nd->sensor_physical_width)
272 nd->activation_width = val * nd->sensor_logical_width /
273 nd->sensor_physical_width;
278 static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
279 set_activation_width);
281 static ssize_t show_activation_height(struct device *dev,
282 struct device_attribute *attr,
285 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
286 struct ntrig_data *nd = hid_get_drvdata(hdev);
288 return sprintf(buf, "%d\n", nd->activation_height *
289 nd->sensor_physical_height /
290 nd->sensor_logical_height);
293 static ssize_t set_activation_height(struct device *dev,
294 struct device_attribute *attr,
295 const char *buf, size_t count)
297 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
298 struct ntrig_data *nd = hid_get_drvdata(hdev);
302 if (strict_strtoul(buf, 0, &val))
305 if (val > nd->sensor_physical_height)
308 nd->activation_height = val * nd->sensor_logical_height /
309 nd->sensor_physical_height;
314 static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
315 show_activation_height, set_activation_height);
317 static ssize_t show_deactivate_slack(struct device *dev,
318 struct device_attribute *attr,
321 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
322 struct ntrig_data *nd = hid_get_drvdata(hdev);
324 return sprintf(buf, "%d\n", -nd->deactivate_slack);
327 static ssize_t set_deactivate_slack(struct device *dev,
328 struct device_attribute *attr,
329 const char *buf, size_t count)
331 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
332 struct ntrig_data *nd = hid_get_drvdata(hdev);
336 if (strict_strtoul(buf, 0, &val))
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.
347 nd->deactivate_slack = -val;
352 static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
353 set_deactivate_slack);
355 static 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,
369 static struct attribute_group ntrig_attribute_group = {
374 * this driver is aimed at two firmware versions in circulation:
375 * - dual pen/finger single touch
376 * - finger multitouch, pen not working
379 static 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)
383 struct ntrig_data *nd = hid_get_drvdata(hdev);
385 /* No special mappings needed for the pen and single touch */
389 switch (usage->hid & HID_USAGE_PAGE) {
391 switch (usage->hid) {
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);
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;
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);
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;
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 */
443 case HID_DG_INPUTMODE:
444 case HID_DG_DEVICEINDEX:
445 case HID_DG_CONTACTMAX:
448 /* width/height mapped on TouchMajor/TouchMinor/Orientation */
450 hid_map_usage(hi, usage, bit, max,
451 EV_ABS, ABS_MT_TOUCH_MAJOR);
454 hid_map_usage(hi, usage, bit, max,
455 EV_ABS, ABS_MT_TOUCH_MINOR);
456 input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
463 /* we do not want to map these: no input-oriented meaning */
470 static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
471 struct hid_field *field, struct hid_usage *usage,
472 unsigned long **bit, int *max)
474 /* No special mappings needed for the pen and single touch */
478 if (usage->type == EV_KEY || usage->type == EV_REL
479 || usage->type == EV_ABS)
480 clear_bit(usage->code, *bit);
486 * this function is called upon all reports
487 * so that we can filter contact point information,
488 * decide whether we are in multi or single touch mode
489 * and call input_mt_sync after each point if necessary
491 static int ntrig_event (struct hid_device *hid, struct hid_field *field,
492 struct hid_usage *usage, __s32 value)
494 struct input_dev *input = field->hidinput->input;
495 struct ntrig_data *nd = hid_get_drvdata(hid);
497 /* No special handling needed for the pen */
498 if (field->application == HID_DG_PEN)
501 if (hid->claimed & HID_CLAIMED_INPUT) {
502 switch (usage->hid) {
504 /* Tag indicating the start of a multitouch group */
506 nd->first_contact_touch = 0;
508 case HID_DG_TIPSWITCH:
509 nd->tipswitch = value;
510 /* Prevent emission of touch until validated */
512 case HID_DG_CONFIDENCE:
513 nd->confidence = value;
517 /* Clear the contact footer */
518 nd->mt_foot_count = 0;
523 case HID_DG_CONTACTID:
532 * when in single touch mode, this is the last
533 * report received in a finger event. We want
534 * to emit a normal (X, Y) position
536 if (!nd->reading_mt) {
538 * TipSwitch indicates the presence of a
539 * finger in single touch mode.
541 input_report_key(input, BTN_TOUCH,
543 input_report_key(input, BTN_TOOL_DOUBLETAP,
545 input_event(input, EV_ABS, ABS_X, nd->x);
546 input_event(input, EV_ABS, ABS_Y, nd->y);
551 * we receive this when the device is in multitouch
552 * mode. The first of the three values tagged with
553 * this usage tells if the contact point is real
557 /* Shouldn't get more than 4 footer packets, so skip */
558 if (nd->mt_foot_count >= 4)
561 nd->mt_footer[nd->mt_foot_count++] = value;
563 /* if the footer isn't complete break */
564 if (nd->mt_foot_count != 4)
567 /* Pen activity signal. */
568 if (nd->mt_footer[2]) {
570 * When the pen deactivates touch, we see a
571 * bogus frame with ContactCount > 0.
573 * save a bit of work by ensuring act_state < 0
574 * even if deactivation slack is turned off.
576 nd->act_state = deactivate_slack - 1;
582 * The first footer value indicates the presence of a
585 if (nd->mt_footer[0]) {
587 * We do not want to process contacts under
588 * the size threshold, but do not want to
589 * ignore them for activation state
591 if (nd->w < nd->min_width ||
592 nd->h < nd->min_height)
597 if (nd->act_state > 0) {
599 * Contact meets the activation size threshold
601 if (nd->w >= nd->activation_width &&
602 nd->h >= nd->activation_height) {
605 * first contact, activate now
610 * avoid corrupting this frame
611 * but ensure next frame will
619 * Defer adjusting the activation state
620 * until the end of the frame.
625 /* Discarding this contact */
629 /* emit a normal (X, Y) for the first point only */
632 * TipSwitch is superfluous in multitouch
633 * mode. The footer events tell us
634 * if there is a finger on the screen or
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);
643 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
644 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
647 * Translate from height and width to size
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);
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);
665 input_mt_sync(field->hidinput->input);
668 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
669 if (!nd->reading_mt) /* Just to be sure */
676 * Activation state machine logic:
678 * Fundamental states:
679 * state > 0: Inactive
681 * state < -deactivate_slack:
682 * Pen termination of touch
684 * Specific values of interest
685 * state == activate_slack
686 * no valid input since the last reset
689 * general operational state
691 * state == -deactivate_slack
692 * read sufficient empty frames to accept
693 * the end of input and reset
696 if (nd->act_state > 0) { /* Currently inactive */
699 * Consider each live contact as
700 * evidence of intentional activity.
702 nd->act_state = (nd->act_state > value)
703 ? nd->act_state - value
707 * Empty frame before we hit the
708 * activity threshold, reset.
710 nd->act_state = nd->activate_slack;
713 * Entered this block inactive and no
714 * coordinates sent this frame, so hold off
718 } else { /* Currently active */
719 if (value && nd->act_state >=
720 nd->deactivate_slack)
722 * Live point: clear accumulated
723 * deactivation count.
726 else if (nd->act_state <= nd->deactivate_slack)
728 * We've consumed the deactivation
729 * slack, time to deactivate and reset.
733 else { /* Move towards deactivation */
739 if (nd->first_contact_touch && nd->act_state <= 0) {
741 * Check to see if we're ready to start
742 * emitting touch events.
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.
751 input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
752 input_report_key(input, BTN_TOUCH, 1);
754 input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
755 input_report_key(input, BTN_TOUCH, 0);
760 /* fall-back to the generic hidinput handling */
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);
772 static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
775 struct ntrig_data *nd;
776 struct hid_input *hidinput;
777 struct input_dev *input;
778 struct hid_report *report;
781 hdev->quirks |= HID_QUIRK_MULTI_INPUT;
783 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
785 dev_err(&hdev->dev, "cannot allocate N-Trig data\n");
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;
800 hid_set_drvdata(hdev, nd);
802 ret = hid_parse(hdev);
804 dev_err(&hdev->dev, "parse failed\n");
808 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
810 dev_err(&hdev->dev, "hw start failed\n");
815 list_for_each_entry(hidinput, &hdev->inputs, list) {
816 if (hidinput->report->maxfield < 1)
819 input = hidinput->input;
820 switch (hidinput->report->field[0]->application) {
822 input->name = "N-Trig Pen";
824 case HID_DG_TOUCHSCREEN:
825 /* These keys are redundant for fingers, clear them
826 * to prevent incorrect identification */
827 __clear_bit(BTN_TOOL_PEN, input->keybit);
828 __clear_bit(BTN_TOOL_FINGER, input->keybit);
829 __clear_bit(BTN_0, input->keybit);
830 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
832 * The physical touchscreen (single touch)
833 * input has a value for physical, whereas
834 * the multitouch only has logical input
838 (hidinput->report->field[0]
840 "N-Trig Touchscreen" :
846 /* This is needed for devices with more recent firmware versions */
847 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
849 usbhid_submit_report(hdev, report, USB_DIR_OUT);
851 ret = sysfs_create_group(&hdev->dev.kobj,
852 &ntrig_attribute_group);
860 static void ntrig_remove(struct hid_device *hdev)
862 sysfs_remove_group(&hdev->dev.kobj,
863 &ntrig_attribute_group);
865 kfree(hid_get_drvdata(hdev));
868 static 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 },
909 MODULE_DEVICE_TABLE(hid, ntrig_devices);
911 static 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 }
916 static struct hid_driver ntrig_driver = {
918 .id_table = ntrig_devices,
919 .probe = ntrig_probe,
920 .remove = ntrig_remove,
921 .input_mapping = ntrig_input_mapping,
922 .input_mapped = ntrig_input_mapped,
923 .usage_table = ntrig_grabbed_usages,
924 .event = ntrig_event,
927 static int __init ntrig_init(void)
929 return hid_register_driver(&ntrig_driver);
932 static void __exit ntrig_exit(void)
934 hid_unregister_driver(&ntrig_driver);
937 module_init(ntrig_init);
938 module_exit(ntrig_exit);
939 MODULE_LICENSE("GPL");