Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/hid/hid-ntrig.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us