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