1034 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * HID driver for N-Trig touchscreens4 *5 * Copyright (c) 2008-2010 Rafi Rubin6 * Copyright (c) 2009-2010 Stephane Chatty7 */8 9/*10 */11 12#include <linux/device.h>13#include <linux/hid.h>14#include <linux/usb.h>15#include "usbhid/usbhid.h"16#include <linux/module.h>17#include <linux/slab.h>18 19#include "hid-ids.h"20 21#define NTRIG_DUPLICATE_USAGES 0x00122 23static unsigned int min_width;24module_param(min_width, uint, 0644);25MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");26 27static unsigned int min_height;28module_param(min_height, uint, 0644);29MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");30 31static unsigned int activate_slack = 1;32module_param(activate_slack, uint, 0644);33MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "34 "the start of touch input.");35 36static unsigned int deactivate_slack = 4;37module_param(deactivate_slack, uint, 0644);38MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "39 "deactivating touch.");40 41static unsigned int activation_width = 64;42module_param(activation_width, uint, 0644);43MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "44 "processing touch events.");45 46static unsigned int activation_height = 32;47module_param(activation_height, uint, 0644);48MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "49 "processing touch events.");50 51struct ntrig_data {52 /* Incoming raw values for a single contact */53 __u16 x, y, w, h;54 __u16 id;55 56 bool tipswitch;57 bool confidence;58 bool first_contact_touch;59 60 bool reading_mt;61 62 __u8 mt_footer[4];63 __u8 mt_foot_count;64 65 /* The current activation state. */66 __s8 act_state;67 68 /* Empty frames to ignore before recognizing the end of activity */69 __s8 deactivate_slack;70 71 /* Frames to ignore before acknowledging the start of activity */72 __s8 activate_slack;73 74 /* Minimum size contact to accept */75 __u16 min_width;76 __u16 min_height;77 78 /* Threshold to override activation slack */79 __u16 activation_width;80 __u16 activation_height;81 82 __u16 sensor_logical_width;83 __u16 sensor_logical_height;84 __u16 sensor_physical_width;85 __u16 sensor_physical_height;86};87 88 89/*90 * This function converts the 4 byte raw firmware code into91 * a string containing 5 comma separated numbers.92 */93static int ntrig_version_string(unsigned char *raw, char *buf)94{95 __u8 a = (raw[1] & 0x0e) >> 1;96 __u8 b = (raw[0] & 0x3c) >> 2;97 __u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5);98 __u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5);99 __u8 e = raw[2] & 0x07;100 101 /*102 * As yet unmapped bits:103 * 0b11000000 0b11110001 0b00011000 0b00011000104 */105 106 return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e);107}108 109static inline int ntrig_get_mode(struct hid_device *hdev)110{111 struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT].112 report_id_hash[0x0d];113 114 if (!report || report->maxfield < 1 ||115 report->field[0]->report_count < 1)116 return -EINVAL;117 118 hid_hw_request(hdev, report, HID_REQ_GET_REPORT);119 hid_hw_wait(hdev);120 return (int)report->field[0]->value[0];121}122 123static inline void ntrig_set_mode(struct hid_device *hdev, const int mode)124{125 struct hid_report *report;126 __u8 mode_commands[4] = { 0xe, 0xf, 0x1b, 0x10 };127 128 if (mode < 0 || mode > 3)129 return;130 131 report = hdev->report_enum[HID_FEATURE_REPORT].132 report_id_hash[mode_commands[mode]];133 134 if (!report)135 return;136 137 hid_hw_request(hdev, report, HID_REQ_GET_REPORT);138}139 140static void ntrig_report_version(struct hid_device *hdev)141{142 int ret;143 char buf[20];144 struct usb_device *usb_dev = hid_to_usb_dev(hdev);145 unsigned char *data = kmalloc(8, GFP_KERNEL);146 147 if (!data)148 goto err_free;149 150 ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),151 USB_REQ_CLEAR_FEATURE,152 USB_TYPE_CLASS | USB_RECIP_INTERFACE |153 USB_DIR_IN,154 0x30c, 1, data, 8,155 USB_CTRL_SET_TIMEOUT);156 157 if (ret == 8) {158 ret = ntrig_version_string(&data[2], buf);159 160 hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",161 buf, data[2], data[3], data[4], data[5]);162 }163 164err_free:165 kfree(data);166}167 168static ssize_t show_phys_width(struct device *dev,169 struct device_attribute *attr,170 char *buf)171{172 struct hid_device *hdev = to_hid_device(dev);173 struct ntrig_data *nd = hid_get_drvdata(hdev);174 175 return sprintf(buf, "%d\n", nd->sensor_physical_width);176}177 178static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);179 180static ssize_t show_phys_height(struct device *dev,181 struct device_attribute *attr,182 char *buf)183{184 struct hid_device *hdev = to_hid_device(dev);185 struct ntrig_data *nd = hid_get_drvdata(hdev);186 187 return sprintf(buf, "%d\n", nd->sensor_physical_height);188}189 190static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);191 192static ssize_t show_log_width(struct device *dev,193 struct device_attribute *attr,194 char *buf)195{196 struct hid_device *hdev = to_hid_device(dev);197 struct ntrig_data *nd = hid_get_drvdata(hdev);198 199 return sprintf(buf, "%d\n", nd->sensor_logical_width);200}201 202static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);203 204static ssize_t show_log_height(struct device *dev,205 struct device_attribute *attr,206 char *buf)207{208 struct hid_device *hdev = to_hid_device(dev);209 struct ntrig_data *nd = hid_get_drvdata(hdev);210 211 return sprintf(buf, "%d\n", nd->sensor_logical_height);212}213 214static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);215 216static ssize_t show_min_width(struct device *dev,217 struct device_attribute *attr,218 char *buf)219{220 struct hid_device *hdev = to_hid_device(dev);221 struct ntrig_data *nd = hid_get_drvdata(hdev);222 223 return sprintf(buf, "%d\n", nd->min_width *224 nd->sensor_physical_width /225 nd->sensor_logical_width);226}227 228static ssize_t set_min_width(struct device *dev,229 struct device_attribute *attr,230 const char *buf, size_t count)231{232 struct hid_device *hdev = to_hid_device(dev);233 struct ntrig_data *nd = hid_get_drvdata(hdev);234 235 unsigned long val;236 237 if (kstrtoul(buf, 0, &val))238 return -EINVAL;239 240 if (val > nd->sensor_physical_width)241 return -EINVAL;242 243 nd->min_width = val * nd->sensor_logical_width /244 nd->sensor_physical_width;245 246 return count;247}248 249static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);250 251static ssize_t show_min_height(struct device *dev,252 struct device_attribute *attr,253 char *buf)254{255 struct hid_device *hdev = to_hid_device(dev);256 struct ntrig_data *nd = hid_get_drvdata(hdev);257 258 return sprintf(buf, "%d\n", nd->min_height *259 nd->sensor_physical_height /260 nd->sensor_logical_height);261}262 263static ssize_t set_min_height(struct device *dev,264 struct device_attribute *attr,265 const char *buf, size_t count)266{267 struct hid_device *hdev = to_hid_device(dev);268 struct ntrig_data *nd = hid_get_drvdata(hdev);269 270 unsigned long val;271 272 if (kstrtoul(buf, 0, &val))273 return -EINVAL;274 275 if (val > nd->sensor_physical_height)276 return -EINVAL;277 278 nd->min_height = val * nd->sensor_logical_height /279 nd->sensor_physical_height;280 281 return count;282}283 284static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,285 set_min_height);286 287static ssize_t show_activate_slack(struct device *dev,288 struct device_attribute *attr,289 char *buf)290{291 struct hid_device *hdev = to_hid_device(dev);292 struct ntrig_data *nd = hid_get_drvdata(hdev);293 294 return sprintf(buf, "%d\n", nd->activate_slack);295}296 297static ssize_t set_activate_slack(struct device *dev,298 struct device_attribute *attr,299 const char *buf, size_t count)300{301 struct hid_device *hdev = to_hid_device(dev);302 struct ntrig_data *nd = hid_get_drvdata(hdev);303 304 unsigned long val;305 306 if (kstrtoul(buf, 0, &val))307 return -EINVAL;308 309 if (val > 0x7f)310 return -EINVAL;311 312 nd->activate_slack = val;313 314 return count;315}316 317static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,318 set_activate_slack);319 320static ssize_t show_activation_width(struct device *dev,321 struct device_attribute *attr,322 char *buf)323{324 struct hid_device *hdev = to_hid_device(dev);325 struct ntrig_data *nd = hid_get_drvdata(hdev);326 327 return sprintf(buf, "%d\n", nd->activation_width *328 nd->sensor_physical_width /329 nd->sensor_logical_width);330}331 332static ssize_t set_activation_width(struct device *dev,333 struct device_attribute *attr,334 const char *buf, size_t count)335{336 struct hid_device *hdev = to_hid_device(dev);337 struct ntrig_data *nd = hid_get_drvdata(hdev);338 339 unsigned long val;340 341 if (kstrtoul(buf, 0, &val))342 return -EINVAL;343 344 if (val > nd->sensor_physical_width)345 return -EINVAL;346 347 nd->activation_width = val * nd->sensor_logical_width /348 nd->sensor_physical_width;349 350 return count;351}352 353static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,354 set_activation_width);355 356static ssize_t show_activation_height(struct device *dev,357 struct device_attribute *attr,358 char *buf)359{360 struct hid_device *hdev = to_hid_device(dev);361 struct ntrig_data *nd = hid_get_drvdata(hdev);362 363 return sprintf(buf, "%d\n", nd->activation_height *364 nd->sensor_physical_height /365 nd->sensor_logical_height);366}367 368static ssize_t set_activation_height(struct device *dev,369 struct device_attribute *attr,370 const char *buf, size_t count)371{372 struct hid_device *hdev = to_hid_device(dev);373 struct ntrig_data *nd = hid_get_drvdata(hdev);374 375 unsigned long val;376 377 if (kstrtoul(buf, 0, &val))378 return -EINVAL;379 380 if (val > nd->sensor_physical_height)381 return -EINVAL;382 383 nd->activation_height = val * nd->sensor_logical_height /384 nd->sensor_physical_height;385 386 return count;387}388 389static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,390 show_activation_height, set_activation_height);391 392static ssize_t show_deactivate_slack(struct device *dev,393 struct device_attribute *attr,394 char *buf)395{396 struct hid_device *hdev = to_hid_device(dev);397 struct ntrig_data *nd = hid_get_drvdata(hdev);398 399 return sprintf(buf, "%d\n", -nd->deactivate_slack);400}401 402static ssize_t set_deactivate_slack(struct device *dev,403 struct device_attribute *attr,404 const char *buf, size_t count)405{406 struct hid_device *hdev = to_hid_device(dev);407 struct ntrig_data *nd = hid_get_drvdata(hdev);408 409 unsigned long val;410 411 if (kstrtoul(buf, 0, &val))412 return -EINVAL;413 414 /*415 * No more than 8 terminal frames have been observed so far416 * and higher slack is highly likely to leave the single417 * touch emulation stuck down.418 */419 if (val > 7)420 return -EINVAL;421 422 nd->deactivate_slack = -val;423 424 return count;425}426 427static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,428 set_deactivate_slack);429 430static struct attribute *sysfs_attrs[] = {431 &dev_attr_sensor_physical_width.attr,432 &dev_attr_sensor_physical_height.attr,433 &dev_attr_sensor_logical_width.attr,434 &dev_attr_sensor_logical_height.attr,435 &dev_attr_min_height.attr,436 &dev_attr_min_width.attr,437 &dev_attr_activate_slack.attr,438 &dev_attr_activation_width.attr,439 &dev_attr_activation_height.attr,440 &dev_attr_deactivate_slack.attr,441 NULL442};443 444static const struct attribute_group ntrig_attribute_group = {445 .attrs = sysfs_attrs446};447 448/*449 * this driver is aimed at two firmware versions in circulation:450 * - dual pen/finger single touch451 * - finger multitouch, pen not working452 */453 454static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,455 struct hid_field *field, struct hid_usage *usage,456 unsigned long **bit, int *max)457{458 struct ntrig_data *nd = hid_get_drvdata(hdev);459 460 /* No special mappings needed for the pen and single touch */461 if (field->physical)462 return 0;463 464 switch (usage->hid & HID_USAGE_PAGE) {465 case HID_UP_GENDESK:466 switch (usage->hid) {467 case HID_GD_X:468 hid_map_usage(hi, usage, bit, max,469 EV_ABS, ABS_MT_POSITION_X);470 input_set_abs_params(hi->input, ABS_X,471 field->logical_minimum,472 field->logical_maximum, 0, 0);473 474 if (!nd->sensor_logical_width) {475 nd->sensor_logical_width =476 field->logical_maximum -477 field->logical_minimum;478 nd->sensor_physical_width =479 field->physical_maximum -480 field->physical_minimum;481 nd->activation_width = activation_width *482 nd->sensor_logical_width /483 nd->sensor_physical_width;484 nd->min_width = min_width *485 nd->sensor_logical_width /486 nd->sensor_physical_width;487 }488 return 1;489 case HID_GD_Y:490 hid_map_usage(hi, usage, bit, max,491 EV_ABS, ABS_MT_POSITION_Y);492 input_set_abs_params(hi->input, ABS_Y,493 field->logical_minimum,494 field->logical_maximum, 0, 0);495 496 if (!nd->sensor_logical_height) {497 nd->sensor_logical_height =498 field->logical_maximum -499 field->logical_minimum;500 nd->sensor_physical_height =501 field->physical_maximum -502 field->physical_minimum;503 nd->activation_height = activation_height *504 nd->sensor_logical_height /505 nd->sensor_physical_height;506 nd->min_height = min_height *507 nd->sensor_logical_height /508 nd->sensor_physical_height;509 }510 return 1;511 }512 return 0;513 514 case HID_UP_DIGITIZER:515 switch (usage->hid) {516 /* we do not want to map these for now */517 case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */518 case HID_DG_INPUTMODE:519 case HID_DG_DEVICEINDEX:520 case HID_DG_CONTACTMAX:521 return -1;522 523 /* width/height mapped on TouchMajor/TouchMinor/Orientation */524 case HID_DG_WIDTH:525 hid_map_usage(hi, usage, bit, max,526 EV_ABS, ABS_MT_TOUCH_MAJOR);527 return 1;528 case HID_DG_HEIGHT:529 hid_map_usage(hi, usage, bit, max,530 EV_ABS, ABS_MT_TOUCH_MINOR);531 input_set_abs_params(hi->input, ABS_MT_ORIENTATION,532 0, 1, 0, 0);533 return 1;534 }535 return 0;536 537 case 0xff000000:538 /* we do not want to map these: no input-oriented meaning */539 return -1;540 }541 542 return 0;543}544 545static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,546 struct hid_field *field, struct hid_usage *usage,547 unsigned long **bit, int *max)548{549 /* No special mappings needed for the pen and single touch */550 if (field->physical)551 return 0;552 553 if (usage->type == EV_KEY || usage->type == EV_REL554 || usage->type == EV_ABS)555 clear_bit(usage->code, *bit);556 557 return 0;558}559 560/*561 * this function is called upon all reports562 * so that we can filter contact point information,563 * decide whether we are in multi or single touch mode564 * and call input_mt_sync after each point if necessary565 */566static int ntrig_event (struct hid_device *hid, struct hid_field *field,567 struct hid_usage *usage, __s32 value)568{569 struct ntrig_data *nd = hid_get_drvdata(hid);570 struct input_dev *input;571 572 /* Skip processing if not a claimed input */573 if (!(hid->claimed & HID_CLAIMED_INPUT))574 goto not_claimed_input;575 576 /* This function is being called before the structures are fully577 * initialized */578 if(!(field->hidinput && field->hidinput->input))579 return -EINVAL;580 581 input = field->hidinput->input;582 583 /* No special handling needed for the pen */584 if (field->application == HID_DG_PEN)585 return 0;586 587 switch (usage->hid) {588 case 0xff000001:589 /* Tag indicating the start of a multitouch group */590 nd->reading_mt = true;591 nd->first_contact_touch = false;592 break;593 case HID_DG_TIPSWITCH:594 nd->tipswitch = value;595 /* Prevent emission of touch until validated */596 return 1;597 case HID_DG_CONFIDENCE:598 nd->confidence = value;599 break;600 case HID_GD_X:601 nd->x = value;602 /* Clear the contact footer */603 nd->mt_foot_count = 0;604 break;605 case HID_GD_Y:606 nd->y = value;607 break;608 case HID_DG_CONTACTID:609 nd->id = value;610 break;611 case HID_DG_WIDTH:612 nd->w = value;613 break;614 case HID_DG_HEIGHT:615 nd->h = value;616 /*617 * when in single touch mode, this is the last618 * report received in a finger event. We want619 * to emit a normal (X, Y) position620 */621 if (!nd->reading_mt) {622 /*623 * TipSwitch indicates the presence of a624 * finger in single touch mode.625 */626 input_report_key(input, BTN_TOUCH,627 nd->tipswitch);628 input_report_key(input, BTN_TOOL_DOUBLETAP,629 nd->tipswitch);630 input_event(input, EV_ABS, ABS_X, nd->x);631 input_event(input, EV_ABS, ABS_Y, nd->y);632 }633 break;634 case 0xff000002:635 /*636 * we receive this when the device is in multitouch637 * mode. The first of the three values tagged with638 * this usage tells if the contact point is real639 * or a placeholder640 */641 642 /* Shouldn't get more than 4 footer packets, so skip */643 if (nd->mt_foot_count >= 4)644 break;645 646 nd->mt_footer[nd->mt_foot_count++] = value;647 648 /* if the footer isn't complete break */649 if (nd->mt_foot_count != 4)650 break;651 652 /* Pen activity signal. */653 if (nd->mt_footer[2]) {654 /*655 * When the pen deactivates touch, we see a656 * bogus frame with ContactCount > 0.657 * We can658 * save a bit of work by ensuring act_state < 0659 * even if deactivation slack is turned off.660 */661 nd->act_state = deactivate_slack - 1;662 nd->confidence = false;663 break;664 }665 666 /*667 * The first footer value indicates the presence of a668 * finger.669 */670 if (nd->mt_footer[0]) {671 /*672 * We do not want to process contacts under673 * the size threshold, but do not want to674 * ignore them for activation state675 */676 if (nd->w < nd->min_width ||677 nd->h < nd->min_height)678 nd->confidence = false;679 } else680 break;681 682 if (nd->act_state > 0) {683 /*684 * Contact meets the activation size threshold685 */686 if (nd->w >= nd->activation_width &&687 nd->h >= nd->activation_height) {688 if (nd->id)689 /*690 * first contact, activate now691 */692 nd->act_state = 0;693 else {694 /*695 * avoid corrupting this frame696 * but ensure next frame will697 * be active698 */699 nd->act_state = 1;700 break;701 }702 } else703 /*704 * Defer adjusting the activation state705 * until the end of the frame.706 */707 break;708 }709 710 /* Discarding this contact */711 if (!nd->confidence)712 break;713 714 /* emit a normal (X, Y) for the first point only */715 if (nd->id == 0) {716 /*717 * TipSwitch is superfluous in multitouch718 * mode. The footer events tell us719 * if there is a finger on the screen or720 * not.721 */722 nd->first_contact_touch = nd->confidence;723 input_event(input, EV_ABS, ABS_X, nd->x);724 input_event(input, EV_ABS, ABS_Y, nd->y);725 }726 727 /* Emit MT events */728 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);729 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);730 731 /*732 * Translate from height and width to size733 * and orientation.734 */735 if (nd->w > nd->h) {736 input_event(input, EV_ABS,737 ABS_MT_ORIENTATION, 1);738 input_event(input, EV_ABS,739 ABS_MT_TOUCH_MAJOR, nd->w);740 input_event(input, EV_ABS,741 ABS_MT_TOUCH_MINOR, nd->h);742 } else {743 input_event(input, EV_ABS,744 ABS_MT_ORIENTATION, 0);745 input_event(input, EV_ABS,746 ABS_MT_TOUCH_MAJOR, nd->h);747 input_event(input, EV_ABS,748 ABS_MT_TOUCH_MINOR, nd->w);749 }750 input_mt_sync(field->hidinput->input);751 break;752 753 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */754 if (!nd->reading_mt) /* Just to be sure */755 break;756 757 nd->reading_mt = false;758 759 760 /*761 * Activation state machine logic:762 *763 * Fundamental states:764 * state > 0: Inactive765 * state <= 0: Active766 * state < -deactivate_slack:767 * Pen termination of touch768 *769 * Specific values of interest770 * state == activate_slack771 * no valid input since the last reset772 *773 * state == 0774 * general operational state775 *776 * state == -deactivate_slack777 * read sufficient empty frames to accept778 * the end of input and reset779 */780 781 if (nd->act_state > 0) { /* Currently inactive */782 if (value)783 /*784 * Consider each live contact as785 * evidence of intentional activity.786 */787 nd->act_state = (nd->act_state > value)788 ? nd->act_state - value789 : 0;790 else791 /*792 * Empty frame before we hit the793 * activity threshold, reset.794 */795 nd->act_state = nd->activate_slack;796 797 /*798 * Entered this block inactive and no799 * coordinates sent this frame, so hold off800 * on button state.801 */802 break;803 } else { /* Currently active */804 if (value && nd->act_state >=805 nd->deactivate_slack)806 /*807 * Live point: clear accumulated808 * deactivation count.809 */810 nd->act_state = 0;811 else if (nd->act_state <= nd->deactivate_slack)812 /*813 * We've consumed the deactivation814 * slack, time to deactivate and reset.815 */816 nd->act_state =817 nd->activate_slack;818 else { /* Move towards deactivation */819 nd->act_state--;820 break;821 }822 }823 824 if (nd->first_contact_touch && nd->act_state <= 0) {825 /*826 * Check to see if we're ready to start827 * emitting touch events.828 *829 * Note: activation slack will decrease over830 * the course of the frame, and it will be831 * inconsistent from the start to the end of832 * the frame. However if the frame starts833 * with slack, first_contact_touch will still834 * be 0 and we will not get to this point.835 */836 input_report_key(input, BTN_TOOL_DOUBLETAP, 1);837 input_report_key(input, BTN_TOUCH, 1);838 } else {839 input_report_key(input, BTN_TOOL_DOUBLETAP, 0);840 input_report_key(input, BTN_TOUCH, 0);841 }842 break;843 844 default:845 /* fall-back to the generic hidinput handling */846 return 0;847 }848 849not_claimed_input:850 851 /* we have handled the hidinput part, now remains hiddev */852 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)853 hid->hiddev_hid_event(hid, field, usage, value);854 855 return 1;856}857 858static int ntrig_input_configured(struct hid_device *hid,859 struct hid_input *hidinput)860 861{862 struct input_dev *input = hidinput->input;863 864 if (hidinput->report->maxfield < 1)865 return 0;866 867 switch (hidinput->report->field[0]->application) {868 case HID_DG_PEN:869 input->name = "N-Trig Pen";870 break;871 case HID_DG_TOUCHSCREEN:872 /* These keys are redundant for fingers, clear them873 * to prevent incorrect identification */874 __clear_bit(BTN_TOOL_PEN, input->keybit);875 __clear_bit(BTN_TOOL_FINGER, input->keybit);876 __clear_bit(BTN_0, input->keybit);877 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);878 /*879 * The physical touchscreen (single touch)880 * input has a value for physical, whereas881 * the multitouch only has logical input882 * fields.883 */884 input->name = (hidinput->report->field[0]->physical) ?885 "N-Trig Touchscreen" :886 "N-Trig MultiTouch";887 break;888 }889 890 return 0;891}892 893static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)894{895 int ret;896 struct ntrig_data *nd;897 struct hid_report *report;898 899 if (id->driver_data)900 hdev->quirks |= HID_QUIRK_MULTI_INPUT901 | HID_QUIRK_NO_INIT_REPORTS;902 903 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);904 if (!nd) {905 hid_err(hdev, "cannot allocate N-Trig data\n");906 return -ENOMEM;907 }908 909 nd->reading_mt = false;910 nd->min_width = 0;911 nd->min_height = 0;912 nd->activate_slack = activate_slack;913 nd->act_state = activate_slack;914 nd->deactivate_slack = -deactivate_slack;915 nd->sensor_logical_width = 1;916 nd->sensor_logical_height = 1;917 nd->sensor_physical_width = 1;918 nd->sensor_physical_height = 1;919 920 hid_set_drvdata(hdev, nd);921 922 ret = hid_parse(hdev);923 if (ret) {924 hid_err(hdev, "parse failed\n");925 goto err_free;926 }927 928 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);929 if (ret) {930 hid_err(hdev, "hw start failed\n");931 goto err_free;932 }933 934 /* This is needed for devices with more recent firmware versions */935 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];936 if (report) {937 /* Let the device settle to ensure the wakeup message gets938 * through */939 hid_hw_wait(hdev);940 hid_hw_request(hdev, report, HID_REQ_GET_REPORT);941 942 /*943 * Sanity check: if the current mode is invalid reset it to944 * something reasonable.945 */946 if (ntrig_get_mode(hdev) >= 4)947 ntrig_set_mode(hdev, 3);948 }949 950 ntrig_report_version(hdev);951 952 ret = sysfs_create_group(&hdev->dev.kobj,953 &ntrig_attribute_group);954 if (ret)955 hid_err(hdev, "cannot create sysfs group\n");956 957 return 0;958err_free:959 kfree(nd);960 return ret;961}962 963static void ntrig_remove(struct hid_device *hdev)964{965 sysfs_remove_group(&hdev->dev.kobj,966 &ntrig_attribute_group);967 hid_hw_stop(hdev);968 kfree(hid_get_drvdata(hdev));969}970 971static const struct hid_device_id ntrig_devices[] = {972 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),973 .driver_data = NTRIG_DUPLICATE_USAGES },974 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),975 .driver_data = NTRIG_DUPLICATE_USAGES },976 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),977 .driver_data = NTRIG_DUPLICATE_USAGES },978 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),979 .driver_data = NTRIG_DUPLICATE_USAGES },980 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),981 .driver_data = NTRIG_DUPLICATE_USAGES },982 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),983 .driver_data = NTRIG_DUPLICATE_USAGES },984 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),985 .driver_data = NTRIG_DUPLICATE_USAGES },986 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),987 .driver_data = NTRIG_DUPLICATE_USAGES },988 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),989 .driver_data = NTRIG_DUPLICATE_USAGES },990 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),991 .driver_data = NTRIG_DUPLICATE_USAGES },992 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),993 .driver_data = NTRIG_DUPLICATE_USAGES },994 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),995 .driver_data = NTRIG_DUPLICATE_USAGES },996 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),997 .driver_data = NTRIG_DUPLICATE_USAGES },998 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),999 .driver_data = NTRIG_DUPLICATE_USAGES },1000 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),1001 .driver_data = NTRIG_DUPLICATE_USAGES },1002 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),1003 .driver_data = NTRIG_DUPLICATE_USAGES },1004 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),1005 .driver_data = NTRIG_DUPLICATE_USAGES },1006 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),1007 .driver_data = NTRIG_DUPLICATE_USAGES },1008 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),1009 .driver_data = NTRIG_DUPLICATE_USAGES },1010 { }1011};1012MODULE_DEVICE_TABLE(hid, ntrig_devices);1013 1014static const struct hid_usage_id ntrig_grabbed_usages[] = {1015 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },1016 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }1017};1018 1019static struct hid_driver ntrig_driver = {1020 .name = "ntrig",1021 .id_table = ntrig_devices,1022 .probe = ntrig_probe,1023 .remove = ntrig_remove,1024 .input_mapping = ntrig_input_mapping,1025 .input_mapped = ntrig_input_mapped,1026 .input_configured = ntrig_input_configured,1027 .usage_table = ntrig_grabbed_usages,1028 .event = ntrig_event,1029};1030module_hid_driver(ntrig_driver);1031 1032MODULE_DESCRIPTION("HID driver for N-Trig touchscreens");1033MODULE_LICENSE("GPL");1034