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;
94 * This function converts the 4 byte raw firmware code into
95 * a string containing 5 comma separated numbers.
97 static int ntrig_version_string(unsigned char *raw, char *buf)
99 __u8 a = (raw[1] & 0x0e) >> 1;
100 __u8 b = (raw[0] & 0x3c) >> 2;
101 __u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5);
102 __u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5);
103 __u8 e = raw[2] & 0x07;
106 * As yet unmapped bits:
107 * 0b11000000 0b11110001 0b00011000 0b00011000
110 return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e);
113 static void ntrig_report_version(struct hid_device *hdev)
117 struct usb_device *usb_dev = hid_to_usb_dev(hdev);
118 unsigned char *data = kmalloc(8, GFP_KERNEL);
123 ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
124 USB_REQ_CLEAR_FEATURE,
125 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
128 USB_CTRL_SET_TIMEOUT);
131 ret = ntrig_version_string(&data[2], buf);
133 hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",
134 buf, data[2], data[3], data[4], data[5]);
141 static ssize_t show_phys_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->sensor_physical_width);
151 static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
153 static ssize_t show_phys_height(struct device *dev,
154 struct device_attribute *attr,
157 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
158 struct ntrig_data *nd = hid_get_drvdata(hdev);
160 return sprintf(buf, "%d\n", nd->sensor_physical_height);
163 static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
165 static ssize_t show_log_width(struct device *dev,
166 struct device_attribute *attr,
169 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
170 struct ntrig_data *nd = hid_get_drvdata(hdev);
172 return sprintf(buf, "%d\n", nd->sensor_logical_width);
175 static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
177 static ssize_t show_log_height(struct device *dev,
178 struct device_attribute *attr,
181 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
182 struct ntrig_data *nd = hid_get_drvdata(hdev);
184 return sprintf(buf, "%d\n", nd->sensor_logical_height);
187 static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
189 static ssize_t show_min_width(struct device *dev,
190 struct device_attribute *attr,
193 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
194 struct ntrig_data *nd = hid_get_drvdata(hdev);
196 return sprintf(buf, "%d\n", nd->min_width *
197 nd->sensor_physical_width /
198 nd->sensor_logical_width);
201 static ssize_t set_min_width(struct device *dev,
202 struct device_attribute *attr,
203 const char *buf, size_t count)
205 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
206 struct ntrig_data *nd = hid_get_drvdata(hdev);
210 if (strict_strtoul(buf, 0, &val))
213 if (val > nd->sensor_physical_width)
216 nd->min_width = val * nd->sensor_logical_width /
217 nd->sensor_physical_width;
222 static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
224 static ssize_t show_min_height(struct device *dev,
225 struct device_attribute *attr,
228 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
229 struct ntrig_data *nd = hid_get_drvdata(hdev);
231 return sprintf(buf, "%d\n", nd->min_height *
232 nd->sensor_physical_height /
233 nd->sensor_logical_height);
236 static ssize_t set_min_height(struct device *dev,
237 struct device_attribute *attr,
238 const char *buf, size_t count)
240 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
241 struct ntrig_data *nd = hid_get_drvdata(hdev);
245 if (strict_strtoul(buf, 0, &val))
248 if (val > nd->sensor_physical_height)
251 nd->min_height = val * nd->sensor_logical_height /
252 nd->sensor_physical_height;
257 static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
260 static ssize_t show_activate_slack(struct device *dev,
261 struct device_attribute *attr,
264 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
265 struct ntrig_data *nd = hid_get_drvdata(hdev);
267 return sprintf(buf, "%d\n", nd->activate_slack);
270 static ssize_t set_activate_slack(struct device *dev,
271 struct device_attribute *attr,
272 const char *buf, size_t count)
274 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
275 struct ntrig_data *nd = hid_get_drvdata(hdev);
279 if (strict_strtoul(buf, 0, &val))
285 nd->activate_slack = val;
290 static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
293 static ssize_t show_activation_width(struct device *dev,
294 struct device_attribute *attr,
297 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
298 struct ntrig_data *nd = hid_get_drvdata(hdev);
300 return sprintf(buf, "%d\n", nd->activation_width *
301 nd->sensor_physical_width /
302 nd->sensor_logical_width);
305 static ssize_t set_activation_width(struct device *dev,
306 struct device_attribute *attr,
307 const char *buf, size_t count)
309 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
310 struct ntrig_data *nd = hid_get_drvdata(hdev);
314 if (strict_strtoul(buf, 0, &val))
317 if (val > nd->sensor_physical_width)
320 nd->activation_width = val * nd->sensor_logical_width /
321 nd->sensor_physical_width;
326 static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
327 set_activation_width);
329 static ssize_t show_activation_height(struct device *dev,
330 struct device_attribute *attr,
333 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
334 struct ntrig_data *nd = hid_get_drvdata(hdev);
336 return sprintf(buf, "%d\n", nd->activation_height *
337 nd->sensor_physical_height /
338 nd->sensor_logical_height);
341 static ssize_t set_activation_height(struct device *dev,
342 struct device_attribute *attr,
343 const char *buf, size_t count)
345 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
346 struct ntrig_data *nd = hid_get_drvdata(hdev);
350 if (strict_strtoul(buf, 0, &val))
353 if (val > nd->sensor_physical_height)
356 nd->activation_height = val * nd->sensor_logical_height /
357 nd->sensor_physical_height;
362 static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
363 show_activation_height, set_activation_height);
365 static ssize_t show_deactivate_slack(struct device *dev,
366 struct device_attribute *attr,
369 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
370 struct ntrig_data *nd = hid_get_drvdata(hdev);
372 return sprintf(buf, "%d\n", -nd->deactivate_slack);
375 static ssize_t set_deactivate_slack(struct device *dev,
376 struct device_attribute *attr,
377 const char *buf, size_t count)
379 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
380 struct ntrig_data *nd = hid_get_drvdata(hdev);
384 if (strict_strtoul(buf, 0, &val))
388 * No more than 8 terminal frames have been observed so far
389 * and higher slack is highly likely to leave the single
390 * touch emulation stuck down.
395 nd->deactivate_slack = -val;
400 static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
401 set_deactivate_slack);
403 static struct attribute *sysfs_attrs[] = {
404 &dev_attr_sensor_physical_width.attr,
405 &dev_attr_sensor_physical_height.attr,
406 &dev_attr_sensor_logical_width.attr,
407 &dev_attr_sensor_logical_height.attr,
408 &dev_attr_min_height.attr,
409 &dev_attr_min_width.attr,
410 &dev_attr_activate_slack.attr,
411 &dev_attr_activation_width.attr,
412 &dev_attr_activation_height.attr,
413 &dev_attr_deactivate_slack.attr,
417 static struct attribute_group ntrig_attribute_group = {
422 * this driver is aimed at two firmware versions in circulation:
423 * - dual pen/finger single touch
424 * - finger multitouch, pen not working
427 static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
428 struct hid_field *field, struct hid_usage *usage,
429 unsigned long **bit, int *max)
431 struct ntrig_data *nd = hid_get_drvdata(hdev);
433 /* No special mappings needed for the pen and single touch */
437 switch (usage->hid & HID_USAGE_PAGE) {
439 switch (usage->hid) {
441 hid_map_usage(hi, usage, bit, max,
442 EV_ABS, ABS_MT_POSITION_X);
443 input_set_abs_params(hi->input, ABS_X,
444 field->logical_minimum,
445 field->logical_maximum, 0, 0);
447 if (!nd->sensor_logical_width) {
448 nd->sensor_logical_width =
449 field->logical_maximum -
450 field->logical_minimum;
451 nd->sensor_physical_width =
452 field->physical_maximum -
453 field->physical_minimum;
454 nd->activation_width = activation_width *
455 nd->sensor_logical_width /
456 nd->sensor_physical_width;
457 nd->min_width = min_width *
458 nd->sensor_logical_width /
459 nd->sensor_physical_width;
463 hid_map_usage(hi, usage, bit, max,
464 EV_ABS, ABS_MT_POSITION_Y);
465 input_set_abs_params(hi->input, ABS_Y,
466 field->logical_minimum,
467 field->logical_maximum, 0, 0);
469 if (!nd->sensor_logical_height) {
470 nd->sensor_logical_height =
471 field->logical_maximum -
472 field->logical_minimum;
473 nd->sensor_physical_height =
474 field->physical_maximum -
475 field->physical_minimum;
476 nd->activation_height = activation_height *
477 nd->sensor_logical_height /
478 nd->sensor_physical_height;
479 nd->min_height = min_height *
480 nd->sensor_logical_height /
481 nd->sensor_physical_height;
487 case HID_UP_DIGITIZER:
488 switch (usage->hid) {
489 /* we do not want to map these for now */
490 case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */
491 case HID_DG_INPUTMODE:
492 case HID_DG_DEVICEINDEX:
493 case HID_DG_CONTACTMAX:
496 /* width/height mapped on TouchMajor/TouchMinor/Orientation */
498 hid_map_usage(hi, usage, bit, max,
499 EV_ABS, ABS_MT_TOUCH_MAJOR);
502 hid_map_usage(hi, usage, bit, max,
503 EV_ABS, ABS_MT_TOUCH_MINOR);
504 input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
511 /* we do not want to map these: no input-oriented meaning */
518 static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
519 struct hid_field *field, struct hid_usage *usage,
520 unsigned long **bit, int *max)
522 /* No special mappings needed for the pen and single touch */
526 if (usage->type == EV_KEY || usage->type == EV_REL
527 || usage->type == EV_ABS)
528 clear_bit(usage->code, *bit);
534 * this function is called upon all reports
535 * so that we can filter contact point information,
536 * decide whether we are in multi or single touch mode
537 * and call input_mt_sync after each point if necessary
539 static int ntrig_event (struct hid_device *hid, struct hid_field *field,
540 struct hid_usage *usage, __s32 value)
542 struct input_dev *input = field->hidinput->input;
543 struct ntrig_data *nd = hid_get_drvdata(hid);
545 /* No special handling needed for the pen */
546 if (field->application == HID_DG_PEN)
549 if (hid->claimed & HID_CLAIMED_INPUT) {
550 switch (usage->hid) {
552 /* Tag indicating the start of a multitouch group */
554 nd->first_contact_touch = 0;
556 case HID_DG_TIPSWITCH:
557 nd->tipswitch = value;
558 /* Prevent emission of touch until validated */
560 case HID_DG_CONFIDENCE:
561 nd->confidence = value;
565 /* Clear the contact footer */
566 nd->mt_foot_count = 0;
571 case HID_DG_CONTACTID:
580 * when in single touch mode, this is the last
581 * report received in a finger event. We want
582 * to emit a normal (X, Y) position
584 if (!nd->reading_mt) {
586 * TipSwitch indicates the presence of a
587 * finger in single touch mode.
589 input_report_key(input, BTN_TOUCH,
591 input_report_key(input, BTN_TOOL_DOUBLETAP,
593 input_event(input, EV_ABS, ABS_X, nd->x);
594 input_event(input, EV_ABS, ABS_Y, nd->y);
599 * we receive this when the device is in multitouch
600 * mode. The first of the three values tagged with
601 * this usage tells if the contact point is real
605 /* Shouldn't get more than 4 footer packets, so skip */
606 if (nd->mt_foot_count >= 4)
609 nd->mt_footer[nd->mt_foot_count++] = value;
611 /* if the footer isn't complete break */
612 if (nd->mt_foot_count != 4)
615 /* Pen activity signal. */
616 if (nd->mt_footer[2]) {
618 * When the pen deactivates touch, we see a
619 * bogus frame with ContactCount > 0.
621 * save a bit of work by ensuring act_state < 0
622 * even if deactivation slack is turned off.
624 nd->act_state = deactivate_slack - 1;
630 * The first footer value indicates the presence of a
633 if (nd->mt_footer[0]) {
635 * We do not want to process contacts under
636 * the size threshold, but do not want to
637 * ignore them for activation state
639 if (nd->w < nd->min_width ||
640 nd->h < nd->min_height)
645 if (nd->act_state > 0) {
647 * Contact meets the activation size threshold
649 if (nd->w >= nd->activation_width &&
650 nd->h >= nd->activation_height) {
653 * first contact, activate now
658 * avoid corrupting this frame
659 * but ensure next frame will
667 * Defer adjusting the activation state
668 * until the end of the frame.
673 /* Discarding this contact */
677 /* emit a normal (X, Y) for the first point only */
680 * TipSwitch is superfluous in multitouch
681 * mode. The footer events tell us
682 * if there is a finger on the screen or
685 nd->first_contact_touch = nd->confidence;
686 input_event(input, EV_ABS, ABS_X, nd->x);
687 input_event(input, EV_ABS, ABS_Y, nd->y);
691 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
692 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
695 * Translate from height and width to size
699 input_event(input, EV_ABS,
700 ABS_MT_ORIENTATION, 1);
701 input_event(input, EV_ABS,
702 ABS_MT_TOUCH_MAJOR, nd->w);
703 input_event(input, EV_ABS,
704 ABS_MT_TOUCH_MINOR, nd->h);
706 input_event(input, EV_ABS,
707 ABS_MT_ORIENTATION, 0);
708 input_event(input, EV_ABS,
709 ABS_MT_TOUCH_MAJOR, nd->h);
710 input_event(input, EV_ABS,
711 ABS_MT_TOUCH_MINOR, nd->w);
713 input_mt_sync(field->hidinput->input);
716 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
717 if (!nd->reading_mt) /* Just to be sure */
724 * Activation state machine logic:
726 * Fundamental states:
727 * state > 0: Inactive
729 * state < -deactivate_slack:
730 * Pen termination of touch
732 * Specific values of interest
733 * state == activate_slack
734 * no valid input since the last reset
737 * general operational state
739 * state == -deactivate_slack
740 * read sufficient empty frames to accept
741 * the end of input and reset
744 if (nd->act_state > 0) { /* Currently inactive */
747 * Consider each live contact as
748 * evidence of intentional activity.
750 nd->act_state = (nd->act_state > value)
751 ? nd->act_state - value
755 * Empty frame before we hit the
756 * activity threshold, reset.
758 nd->act_state = nd->activate_slack;
761 * Entered this block inactive and no
762 * coordinates sent this frame, so hold off
766 } else { /* Currently active */
767 if (value && nd->act_state >=
768 nd->deactivate_slack)
770 * Live point: clear accumulated
771 * deactivation count.
774 else if (nd->act_state <= nd->deactivate_slack)
776 * We've consumed the deactivation
777 * slack, time to deactivate and reset.
781 else { /* Move towards deactivation */
787 if (nd->first_contact_touch && nd->act_state <= 0) {
789 * Check to see if we're ready to start
790 * emitting touch events.
792 * Note: activation slack will decrease over
793 * the course of the frame, and it will be
794 * inconsistent from the start to the end of
795 * the frame. However if the frame starts
796 * with slack, first_contact_touch will still
797 * be 0 and we will not get to this point.
799 input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
800 input_report_key(input, BTN_TOUCH, 1);
802 input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
803 input_report_key(input, BTN_TOUCH, 0);
808 /* fall-back to the generic hidinput handling */
813 /* we have handled the hidinput part, now remains hiddev */
814 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
815 hid->hiddev_hid_event(hid, field, usage, value);
820 static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
823 struct ntrig_data *nd;
824 struct hid_input *hidinput;
825 struct input_dev *input;
826 struct hid_report *report;
829 hdev->quirks |= HID_QUIRK_MULTI_INPUT;
831 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
833 hid_err(hdev, "cannot allocate N-Trig data\n");
840 nd->activate_slack = activate_slack;
841 nd->act_state = activate_slack;
842 nd->deactivate_slack = -deactivate_slack;
843 nd->sensor_logical_width = 0;
844 nd->sensor_logical_height = 0;
845 nd->sensor_physical_width = 0;
846 nd->sensor_physical_height = 0;
848 hid_set_drvdata(hdev, nd);
850 ret = hid_parse(hdev);
852 hid_err(hdev, "parse failed\n");
856 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
858 hid_err(hdev, "hw start failed\n");
863 list_for_each_entry(hidinput, &hdev->inputs, list) {
864 if (hidinput->report->maxfield < 1)
867 input = hidinput->input;
868 switch (hidinput->report->field[0]->application) {
870 input->name = "N-Trig Pen";
872 case HID_DG_TOUCHSCREEN:
873 /* These keys are redundant for fingers, clear them
874 * to prevent incorrect identification */
875 __clear_bit(BTN_TOOL_PEN, input->keybit);
876 __clear_bit(BTN_TOOL_FINGER, input->keybit);
877 __clear_bit(BTN_0, input->keybit);
878 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
880 * The physical touchscreen (single touch)
881 * input has a value for physical, whereas
882 * the multitouch only has logical input
886 (hidinput->report->field[0]
888 "N-Trig Touchscreen" :
894 /* This is needed for devices with more recent firmware versions */
895 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
897 usbhid_submit_report(hdev, report, USB_DIR_OUT);
899 ntrig_report_version(hdev);
901 ret = sysfs_create_group(&hdev->dev.kobj,
902 &ntrig_attribute_group);
910 static void ntrig_remove(struct hid_device *hdev)
912 sysfs_remove_group(&hdev->dev.kobj,
913 &ntrig_attribute_group);
915 kfree(hid_get_drvdata(hdev));
918 static const struct hid_device_id ntrig_devices[] = {
919 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
920 .driver_data = NTRIG_DUPLICATE_USAGES },
921 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),
922 .driver_data = NTRIG_DUPLICATE_USAGES },
923 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),
924 .driver_data = NTRIG_DUPLICATE_USAGES },
925 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),
926 .driver_data = NTRIG_DUPLICATE_USAGES },
927 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),
928 .driver_data = NTRIG_DUPLICATE_USAGES },
929 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),
930 .driver_data = NTRIG_DUPLICATE_USAGES },
931 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),
932 .driver_data = NTRIG_DUPLICATE_USAGES },
933 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),
934 .driver_data = NTRIG_DUPLICATE_USAGES },
935 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),
936 .driver_data = NTRIG_DUPLICATE_USAGES },
937 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),
938 .driver_data = NTRIG_DUPLICATE_USAGES },
939 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),
940 .driver_data = NTRIG_DUPLICATE_USAGES },
941 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),
942 .driver_data = NTRIG_DUPLICATE_USAGES },
943 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),
944 .driver_data = NTRIG_DUPLICATE_USAGES },
945 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),
946 .driver_data = NTRIG_DUPLICATE_USAGES },
947 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),
948 .driver_data = NTRIG_DUPLICATE_USAGES },
949 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),
950 .driver_data = NTRIG_DUPLICATE_USAGES },
951 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),
952 .driver_data = NTRIG_DUPLICATE_USAGES },
953 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),
954 .driver_data = NTRIG_DUPLICATE_USAGES },
955 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),
956 .driver_data = NTRIG_DUPLICATE_USAGES },
959 MODULE_DEVICE_TABLE(hid, ntrig_devices);
961 static const struct hid_usage_id ntrig_grabbed_usages[] = {
962 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
963 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
966 static struct hid_driver ntrig_driver = {
968 .id_table = ntrig_devices,
969 .probe = ntrig_probe,
970 .remove = ntrig_remove,
971 .input_mapping = ntrig_input_mapping,
972 .input_mapped = ntrig_input_mapped,
973 .usage_table = ntrig_grabbed_usages,
974 .event = ntrig_event,
977 static int __init ntrig_init(void)
979 return hid_register_driver(&ntrig_driver);
982 static void __exit ntrig_exit(void)
984 hid_unregister_driver(&ntrig_driver);
987 module_init(ntrig_init);
988 module_exit(ntrig_exit);
989 MODULE_LICENSE("GPL");