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