blob: 9fae2ebdd7586c0cbc49830763a1d9fd232f95db [file] [log] [blame]
Rafi Rubin94011f92008-11-19 15:54:46 +01001/*
Stephane Chatty57fd6372009-05-20 15:49:35 +02002 * HID driver for N-Trig touchscreens
Rafi Rubin94011f92008-11-19 15:54:46 +01003 *
Stephane Chatty65499812010-04-06 22:22:58 +02004 * Copyright (c) 2008-2010 Rafi Rubin
5 * Copyright (c) 2009-2010 Stephane Chatty
Rafi Rubin94011f92008-11-19 15:54:46 +01006 *
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>
Stephane Chatty65499812010-04-06 22:22:58 +020018#include <linux/usb.h>
19#include "usbhid/usbhid.h"
Rafi Rubin94011f92008-11-19 15:54:46 +010020#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/slab.h>
Rafi Rubin94011f92008-11-19 15:54:46 +010022
23#include "hid-ids.h"
24
25#define NTRIG_DUPLICATE_USAGES 0x001
26
Rafi Rubin369db2a2010-05-04 14:20:15 -040027static unsigned int min_width;
Rafi Rubinab3f4982010-05-04 14:20:16 -040028module_param(min_width, uint, 0644);
29MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
30
Rafi Rubin369db2a2010-05-04 14:20:15 -040031static unsigned int min_height;
Rafi Rubinab3f4982010-05-04 14:20:16 -040032module_param(min_height, uint, 0644);
33MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
34
Rafi Rubin369db2a2010-05-04 14:20:15 -040035static unsigned int activate_slack = 1;
Rafi Rubinab3f4982010-05-04 14:20:16 -040036module_param(activate_slack, uint, 0644);
37MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
38 "the start of touch input.");
39
Rafi Rubin369db2a2010-05-04 14:20:15 -040040static unsigned int deactivate_slack = 4;
Rafi Rubinab3f4982010-05-04 14:20:16 -040041module_param(deactivate_slack, uint, 0644);
42MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
43 "deactivating touch.");
44
Rafi Rubin369db2a2010-05-04 14:20:15 -040045static unsigned int activation_width = 64;
Rafi Rubinab3f4982010-05-04 14:20:16 -040046module_param(activation_width, uint, 0644);
47MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
48 "processing touch events.");
49
Rafi Rubin369db2a2010-05-04 14:20:15 -040050static unsigned int activation_height = 32;
Rafi Rubinab3f4982010-05-04 14:20:16 -040051module_param(activation_height, uint, 0644);
52MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
53 "processing touch events.");
Rafi Rubin369db2a2010-05-04 14:20:15 -040054
Stephane Chatty57fd6372009-05-20 15:49:35 +020055struct ntrig_data {
Rafi Rubindbf2b172010-02-12 21:13:05 -050056 /* Incoming raw values for a single contact */
57 __u16 x, y, w, h;
58 __u16 id;
Rafi Rubin250d3772010-05-03 05:08:29 -040059
60 bool tipswitch;
61 bool confidence;
62 bool first_contact_touch;
Rafi Rubindbf2b172010-02-12 21:13:05 -050063
64 bool reading_mt;
Rafi Rubindbf2b172010-02-12 21:13:05 -050065
66 __u8 mt_footer[4];
67 __u8 mt_foot_count;
Rafi Rubin369db2a2010-05-04 14:20:15 -040068
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;
Stephane Chatty57fd6372009-05-20 15:49:35 +020090};
91
Rafi Rubineab32f52010-05-04 14:20:17 -040092
Rafi Rubin02778732010-09-08 11:46:14 +020093/*
94 * This function converts the 4 byte raw firmware code into
95 * a string containing 5 comma separated numbers.
96 */
97static 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
Rafi Rubin7b2a64c2011-03-09 23:33:52 -0500113static 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)
119 return -EINVAL;
120
121 usbhid_submit_report(hdev, report, USB_DIR_IN);
122 usbhid_wait_io(hdev);
123 return (int)report->field[0]->value[0];
124}
125
126static inline void ntrig_set_mode(struct hid_device *hdev, const int mode)
127{
128 struct hid_report *report;
129 __u8 mode_commands[4] = { 0xe, 0xf, 0x1b, 0x10 };
130
131 if (mode < 0 || mode > 3)
132 return;
133
134 report = hdev->report_enum[HID_FEATURE_REPORT].
135 report_id_hash[mode_commands[mode]];
136
137 if (!report)
138 return;
139
140 usbhid_submit_report(hdev, report, USB_DIR_IN);
141}
142
Rafi Rubin02778732010-09-08 11:46:14 +0200143static void ntrig_report_version(struct hid_device *hdev)
144{
145 int ret;
146 char buf[20];
147 struct usb_device *usb_dev = hid_to_usb_dev(hdev);
148 unsigned char *data = kmalloc(8, GFP_KERNEL);
149
150 if (!data)
151 goto err_free;
152
153 ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
154 USB_REQ_CLEAR_FEATURE,
155 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
156 USB_DIR_IN,
157 0x30c, 1, data, 8,
158 USB_CTRL_SET_TIMEOUT);
159
160 if (ret == 8) {
161 ret = ntrig_version_string(&data[2], buf);
162
Joe Perches4291ee32010-12-09 19:29:03 -0800163 hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",
Rafi Rubin02778732010-09-08 11:46:14 +0200164 buf, data[2], data[3], data[4], data[5]);
165 }
166
167err_free:
168 kfree(data);
169}
170
Rafi Rubineab32f52010-05-04 14:20:17 -0400171static ssize_t show_phys_width(struct device *dev,
172 struct device_attribute *attr,
173 char *buf)
174{
175 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
176 struct ntrig_data *nd = hid_get_drvdata(hdev);
177
178 return sprintf(buf, "%d\n", nd->sensor_physical_width);
179}
180
181static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
182
183static ssize_t show_phys_height(struct device *dev,
184 struct device_attribute *attr,
185 char *buf)
186{
187 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
188 struct ntrig_data *nd = hid_get_drvdata(hdev);
189
190 return sprintf(buf, "%d\n", nd->sensor_physical_height);
191}
192
193static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
194
195static ssize_t show_log_width(struct device *dev,
196 struct device_attribute *attr,
197 char *buf)
198{
199 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
200 struct ntrig_data *nd = hid_get_drvdata(hdev);
201
202 return sprintf(buf, "%d\n", nd->sensor_logical_width);
203}
204
205static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
206
207static ssize_t show_log_height(struct device *dev,
208 struct device_attribute *attr,
209 char *buf)
210{
211 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
212 struct ntrig_data *nd = hid_get_drvdata(hdev);
213
214 return sprintf(buf, "%d\n", nd->sensor_logical_height);
215}
216
217static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
218
219static ssize_t show_min_width(struct device *dev,
220 struct device_attribute *attr,
221 char *buf)
222{
223 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
224 struct ntrig_data *nd = hid_get_drvdata(hdev);
225
226 return sprintf(buf, "%d\n", nd->min_width *
227 nd->sensor_physical_width /
228 nd->sensor_logical_width);
229}
230
231static ssize_t set_min_width(struct device *dev,
232 struct device_attribute *attr,
233 const char *buf, size_t count)
234{
235 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
236 struct ntrig_data *nd = hid_get_drvdata(hdev);
237
238 unsigned long val;
239
240 if (strict_strtoul(buf, 0, &val))
241 return -EINVAL;
242
243 if (val > nd->sensor_physical_width)
244 return -EINVAL;
245
246 nd->min_width = val * nd->sensor_logical_width /
247 nd->sensor_physical_width;
248
249 return count;
250}
251
252static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
253
254static ssize_t show_min_height(struct device *dev,
255 struct device_attribute *attr,
256 char *buf)
257{
258 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
259 struct ntrig_data *nd = hid_get_drvdata(hdev);
260
261 return sprintf(buf, "%d\n", nd->min_height *
262 nd->sensor_physical_height /
263 nd->sensor_logical_height);
264}
265
266static ssize_t set_min_height(struct device *dev,
267 struct device_attribute *attr,
268 const char *buf, size_t count)
269{
270 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
271 struct ntrig_data *nd = hid_get_drvdata(hdev);
272
273 unsigned long val;
274
275 if (strict_strtoul(buf, 0, &val))
276 return -EINVAL;
277
278 if (val > nd->sensor_physical_height)
279 return -EINVAL;
280
281 nd->min_height = val * nd->sensor_logical_height /
282 nd->sensor_physical_height;
283
284 return count;
285}
286
287static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
288 set_min_height);
289
290static ssize_t show_activate_slack(struct device *dev,
291 struct device_attribute *attr,
292 char *buf)
293{
294 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
295 struct ntrig_data *nd = hid_get_drvdata(hdev);
296
297 return sprintf(buf, "%d\n", nd->activate_slack);
298}
299
300static ssize_t set_activate_slack(struct device *dev,
301 struct device_attribute *attr,
302 const char *buf, size_t count)
303{
304 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
305 struct ntrig_data *nd = hid_get_drvdata(hdev);
306
307 unsigned long val;
308
309 if (strict_strtoul(buf, 0, &val))
310 return -EINVAL;
311
312 if (val > 0x7f)
313 return -EINVAL;
314
315 nd->activate_slack = val;
316
317 return count;
318}
319
320static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
321 set_activate_slack);
322
323static ssize_t show_activation_width(struct device *dev,
324 struct device_attribute *attr,
325 char *buf)
326{
327 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
328 struct ntrig_data *nd = hid_get_drvdata(hdev);
329
330 return sprintf(buf, "%d\n", nd->activation_width *
331 nd->sensor_physical_width /
332 nd->sensor_logical_width);
333}
334
335static ssize_t set_activation_width(struct device *dev,
336 struct device_attribute *attr,
337 const char *buf, size_t count)
338{
339 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
340 struct ntrig_data *nd = hid_get_drvdata(hdev);
341
342 unsigned long val;
343
344 if (strict_strtoul(buf, 0, &val))
345 return -EINVAL;
346
347 if (val > nd->sensor_physical_width)
348 return -EINVAL;
349
350 nd->activation_width = val * nd->sensor_logical_width /
351 nd->sensor_physical_width;
352
353 return count;
354}
355
356static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
357 set_activation_width);
358
359static ssize_t show_activation_height(struct device *dev,
360 struct device_attribute *attr,
361 char *buf)
362{
363 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
364 struct ntrig_data *nd = hid_get_drvdata(hdev);
365
366 return sprintf(buf, "%d\n", nd->activation_height *
367 nd->sensor_physical_height /
368 nd->sensor_logical_height);
369}
370
371static ssize_t set_activation_height(struct device *dev,
372 struct device_attribute *attr,
373 const char *buf, size_t count)
374{
375 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
376 struct ntrig_data *nd = hid_get_drvdata(hdev);
377
378 unsigned long val;
379
380 if (strict_strtoul(buf, 0, &val))
381 return -EINVAL;
382
383 if (val > nd->sensor_physical_height)
384 return -EINVAL;
385
386 nd->activation_height = val * nd->sensor_logical_height /
387 nd->sensor_physical_height;
388
389 return count;
390}
391
392static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
393 show_activation_height, set_activation_height);
394
395static ssize_t show_deactivate_slack(struct device *dev,
396 struct device_attribute *attr,
397 char *buf)
398{
399 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
400 struct ntrig_data *nd = hid_get_drvdata(hdev);
401
402 return sprintf(buf, "%d\n", -nd->deactivate_slack);
403}
404
405static ssize_t set_deactivate_slack(struct device *dev,
406 struct device_attribute *attr,
407 const char *buf, size_t count)
408{
409 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
410 struct ntrig_data *nd = hid_get_drvdata(hdev);
411
412 unsigned long val;
413
414 if (strict_strtoul(buf, 0, &val))
415 return -EINVAL;
416
417 /*
418 * No more than 8 terminal frames have been observed so far
419 * and higher slack is highly likely to leave the single
420 * touch emulation stuck down.
421 */
422 if (val > 7)
423 return -EINVAL;
424
425 nd->deactivate_slack = -val;
426
427 return count;
428}
429
430static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
431 set_deactivate_slack);
432
433static struct attribute *sysfs_attrs[] = {
434 &dev_attr_sensor_physical_width.attr,
435 &dev_attr_sensor_physical_height.attr,
436 &dev_attr_sensor_logical_width.attr,
437 &dev_attr_sensor_logical_height.attr,
438 &dev_attr_min_height.attr,
439 &dev_attr_min_width.attr,
440 &dev_attr_activate_slack.attr,
441 &dev_attr_activation_width.attr,
442 &dev_attr_activation_height.attr,
443 &dev_attr_deactivate_slack.attr,
444 NULL
445};
446
447static struct attribute_group ntrig_attribute_group = {
448 .attrs = sysfs_attrs
449};
450
Stephane Chatty57fd6372009-05-20 15:49:35 +0200451/*
452 * this driver is aimed at two firmware versions in circulation:
453 * - dual pen/finger single touch
454 * - finger multitouch, pen not working
455 */
456
Rafi Rubin94011f92008-11-19 15:54:46 +0100457static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
Rafi Rubina52dc342010-08-26 00:54:55 -0400458 struct hid_field *field, struct hid_usage *usage,
459 unsigned long **bit, int *max)
Rafi Rubin94011f92008-11-19 15:54:46 +0100460{
Rafi Rubin369db2a2010-05-04 14:20:15 -0400461 struct ntrig_data *nd = hid_get_drvdata(hdev);
462
Rafi Rubindbf2b172010-02-12 21:13:05 -0500463 /* No special mappings needed for the pen and single touch */
464 if (field->physical)
Rafi Rubin943ed462010-02-11 22:14:05 -0500465 return 0;
466
Stephane Chatty57fd6372009-05-20 15:49:35 +0200467 switch (usage->hid & HID_USAGE_PAGE) {
Stephane Chatty57fd6372009-05-20 15:49:35 +0200468 case HID_UP_GENDESK:
469 switch (usage->hid) {
470 case HID_GD_X:
471 hid_map_usage(hi, usage, bit, max,
472 EV_ABS, ABS_MT_POSITION_X);
473 input_set_abs_params(hi->input, ABS_X,
474 field->logical_minimum,
475 field->logical_maximum, 0, 0);
Rafi Rubin369db2a2010-05-04 14:20:15 -0400476
477 if (!nd->sensor_logical_width) {
478 nd->sensor_logical_width =
479 field->logical_maximum -
480 field->logical_minimum;
481 nd->sensor_physical_width =
482 field->physical_maximum -
483 field->physical_minimum;
484 nd->activation_width = activation_width *
485 nd->sensor_logical_width /
486 nd->sensor_physical_width;
487 nd->min_width = min_width *
488 nd->sensor_logical_width /
489 nd->sensor_physical_width;
490 }
Stephane Chatty57fd6372009-05-20 15:49:35 +0200491 return 1;
492 case HID_GD_Y:
493 hid_map_usage(hi, usage, bit, max,
494 EV_ABS, ABS_MT_POSITION_Y);
495 input_set_abs_params(hi->input, ABS_Y,
496 field->logical_minimum,
497 field->logical_maximum, 0, 0);
Rafi Rubin369db2a2010-05-04 14:20:15 -0400498
499 if (!nd->sensor_logical_height) {
500 nd->sensor_logical_height =
501 field->logical_maximum -
502 field->logical_minimum;
503 nd->sensor_physical_height =
504 field->physical_maximum -
505 field->physical_minimum;
506 nd->activation_height = activation_height *
507 nd->sensor_logical_height /
508 nd->sensor_physical_height;
509 nd->min_height = min_height *
510 nd->sensor_logical_height /
511 nd->sensor_physical_height;
512 }
Stephane Chatty57fd6372009-05-20 15:49:35 +0200513 return 1;
514 }
515 return 0;
516
517 case HID_UP_DIGITIZER:
518 switch (usage->hid) {
519 /* we do not want to map these for now */
Rafi Rubindbf2b172010-02-12 21:13:05 -0500520 case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */
Stephane Chatty57fd6372009-05-20 15:49:35 +0200521 case HID_DG_INPUTMODE:
522 case HID_DG_DEVICEINDEX:
Stephane Chatty57fd6372009-05-20 15:49:35 +0200523 case HID_DG_CONTACTMAX:
524 return -1;
525
Stephane Chatty57fd6372009-05-20 15:49:35 +0200526 /* width/height mapped on TouchMajor/TouchMinor/Orientation */
527 case HID_DG_WIDTH:
528 hid_map_usage(hi, usage, bit, max,
Rafi Rubina52dc342010-08-26 00:54:55 -0400529 EV_ABS, ABS_MT_TOUCH_MAJOR);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200530 return 1;
531 case HID_DG_HEIGHT:
532 hid_map_usage(hi, usage, bit, max,
Rafi Rubina52dc342010-08-26 00:54:55 -0400533 EV_ABS, ABS_MT_TOUCH_MINOR);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200534 input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
Rafi Rubina52dc342010-08-26 00:54:55 -0400535 0, 1, 0, 0);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200536 return 1;
537 }
538 return 0;
539
540 case 0xff000000:
541 /* we do not want to map these: no input-oriented meaning */
542 return -1;
Rafi Rubin94011f92008-11-19 15:54:46 +0100543 }
Stephane Chatty57fd6372009-05-20 15:49:35 +0200544
Rafi Rubin94011f92008-11-19 15:54:46 +0100545 return 0;
546}
547
548static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
Rafi Rubina52dc342010-08-26 00:54:55 -0400549 struct hid_field *field, struct hid_usage *usage,
550 unsigned long **bit, int *max)
Rafi Rubin94011f92008-11-19 15:54:46 +0100551{
Rafi Rubindbf2b172010-02-12 21:13:05 -0500552 /* No special mappings needed for the pen and single touch */
553 if (field->physical)
Rafi Rubin943ed462010-02-11 22:14:05 -0500554 return 0;
Rafi Rubinb0549cf2010-02-11 22:14:06 -0500555
Rafi Rubin94011f92008-11-19 15:54:46 +0100556 if (usage->type == EV_KEY || usage->type == EV_REL
557 || usage->type == EV_ABS)
558 clear_bit(usage->code, *bit);
559
560 return 0;
561}
Stephane Chatty57fd6372009-05-20 15:49:35 +0200562
563/*
564 * this function is called upon all reports
565 * so that we can filter contact point information,
566 * decide whether we are in multi or single touch mode
567 * and call input_mt_sync after each point if necessary
568 */
569static int ntrig_event (struct hid_device *hid, struct hid_field *field,
Rafi Rubina52dc342010-08-26 00:54:55 -0400570 struct hid_usage *usage, __s32 value)
Stephane Chatty57fd6372009-05-20 15:49:35 +0200571{
Stephane Chatty57fd6372009-05-20 15:49:35 +0200572 struct ntrig_data *nd = hid_get_drvdata(hid);
Rafi Rubinf41a52d2011-03-08 00:24:29 -0500573 struct input_dev *input;
574
575 /* Skip processing if not a claimed input */
576 if (!(hid->claimed & HID_CLAIMED_INPUT))
577 goto not_claimed_input;
578
579 /* This function is being called before the structures are fully
580 * initialized */
581 if(!(field->hidinput && field->hidinput->input))
582 return -EINVAL;
583
584 input = field->hidinput->input;
Stephane Chatty57fd6372009-05-20 15:49:35 +0200585
Rafi Rubin943ed462010-02-11 22:14:05 -0500586 /* No special handling needed for the pen */
587 if (field->application == HID_DG_PEN)
588 return 0;
589
Rafi Rubinff404622011-03-07 21:13:28 -0500590 switch (usage->hid) {
591 case 0xff000001:
592 /* Tag indicating the start of a multitouch group */
593 nd->reading_mt = 1;
594 nd->first_contact_touch = 0;
595 break;
596 case HID_DG_TIPSWITCH:
597 nd->tipswitch = value;
598 /* Prevent emission of touch until validated */
599 return 1;
600 case HID_DG_CONFIDENCE:
601 nd->confidence = value;
602 break;
603 case HID_GD_X:
604 nd->x = value;
605 /* Clear the contact footer */
606 nd->mt_foot_count = 0;
607 break;
608 case HID_GD_Y:
609 nd->y = value;
610 break;
611 case HID_DG_CONTACTID:
612 nd->id = value;
613 break;
614 case HID_DG_WIDTH:
615 nd->w = value;
616 break;
617 case HID_DG_HEIGHT:
618 nd->h = value;
619 /*
620 * when in single touch mode, this is the last
621 * report received in a finger event. We want
622 * to emit a normal (X, Y) position
623 */
624 if (!nd->reading_mt) {
Stephane Chatty57fd6372009-05-20 15:49:35 +0200625 /*
Rafi Rubinff404622011-03-07 21:13:28 -0500626 * TipSwitch indicates the presence of a
627 * finger in single touch mode.
Stephane Chatty57fd6372009-05-20 15:49:35 +0200628 */
Rafi Rubinff404622011-03-07 21:13:28 -0500629 input_report_key(input, BTN_TOUCH,
630 nd->tipswitch);
631 input_report_key(input, BTN_TOOL_DOUBLETAP,
632 nd->tipswitch);
633 input_event(input, EV_ABS, ABS_X, nd->x);
634 input_event(input, EV_ABS, ABS_Y, nd->y);
635 }
636 break;
637 case 0xff000002:
638 /*
639 * we receive this when the device is in multitouch
640 * mode. The first of the three values tagged with
641 * this usage tells if the contact point is real
642 * or a placeholder
643 */
644
645 /* Shouldn't get more than 4 footer packets, so skip */
646 if (nd->mt_foot_count >= 4)
Stephane Chatty57fd6372009-05-20 15:49:35 +0200647 break;
Rafi Rubinff404622011-03-07 21:13:28 -0500648
649 nd->mt_footer[nd->mt_foot_count++] = value;
650
651 /* if the footer isn't complete break */
652 if (nd->mt_foot_count != 4)
653 break;
654
655 /* Pen activity signal. */
656 if (nd->mt_footer[2]) {
Stephane Chatty57fd6372009-05-20 15:49:35 +0200657 /*
Rafi Rubinff404622011-03-07 21:13:28 -0500658 * When the pen deactivates touch, we see a
659 * bogus frame with ContactCount > 0.
660 * We can
661 * save a bit of work by ensuring act_state < 0
662 * even if deactivation slack is turned off.
Stephane Chatty57fd6372009-05-20 15:49:35 +0200663 */
Rafi Rubinff404622011-03-07 21:13:28 -0500664 nd->act_state = deactivate_slack - 1;
665 nd->confidence = 0;
666 break;
667 }
Rafi Rubindbf2b172010-02-12 21:13:05 -0500668
Rafi Rubinff404622011-03-07 21:13:28 -0500669 /*
670 * The first footer value indicates the presence of a
671 * finger.
672 */
673 if (nd->mt_footer[0]) {
674 /*
675 * We do not want to process contacts under
676 * the size threshold, but do not want to
677 * ignore them for activation state
678 */
679 if (nd->w < nd->min_width ||
680 nd->h < nd->min_height)
Rafi Rubindbf2b172010-02-12 21:13:05 -0500681 nd->confidence = 0;
Rafi Rubinff404622011-03-07 21:13:28 -0500682 } else
Rafi Rubindbf2b172010-02-12 21:13:05 -0500683 break;
684
Rafi Rubinff404622011-03-07 21:13:28 -0500685 if (nd->act_state > 0) {
Rafi Rubin369db2a2010-05-04 14:20:15 -0400686 /*
Rafi Rubinff404622011-03-07 21:13:28 -0500687 * Contact meets the activation size threshold
Rafi Rubin369db2a2010-05-04 14:20:15 -0400688 */
Rafi Rubinff404622011-03-07 21:13:28 -0500689 if (nd->w >= nd->activation_width &&
690 nd->h >= nd->activation_height) {
691 if (nd->id)
Rafi Rubin369db2a2010-05-04 14:20:15 -0400692 /*
Rafi Rubinff404622011-03-07 21:13:28 -0500693 * first contact, activate now
Rafi Rubin369db2a2010-05-04 14:20:15 -0400694 */
695 nd->act_state = 0;
Rafi Rubinff404622011-03-07 21:13:28 -0500696 else {
Rafi Rubin369db2a2010-05-04 14:20:15 -0400697 /*
Rafi Rubinff404622011-03-07 21:13:28 -0500698 * avoid corrupting this frame
699 * but ensure next frame will
700 * be active
Rafi Rubin369db2a2010-05-04 14:20:15 -0400701 */
Rafi Rubinff404622011-03-07 21:13:28 -0500702 nd->act_state = 1;
Rafi Rubin369db2a2010-05-04 14:20:15 -0400703 break;
704 }
Rafi Rubinff404622011-03-07 21:13:28 -0500705 } else
Rafi Rubin369db2a2010-05-04 14:20:15 -0400706 /*
Rafi Rubinff404622011-03-07 21:13:28 -0500707 * Defer adjusting the activation state
708 * until the end of the frame.
Rafi Rubin369db2a2010-05-04 14:20:15 -0400709 */
Rafi Rubinff404622011-03-07 21:13:28 -0500710 break;
711 }
712
713 /* Discarding this contact */
714 if (!nd->confidence)
Stephane Chatty57fd6372009-05-20 15:49:35 +0200715 break;
716
Rafi Rubinff404622011-03-07 21:13:28 -0500717 /* emit a normal (X, Y) for the first point only */
718 if (nd->id == 0) {
719 /*
720 * TipSwitch is superfluous in multitouch
721 * mode. The footer events tell us
722 * if there is a finger on the screen or
723 * not.
724 */
725 nd->first_contact_touch = nd->confidence;
726 input_event(input, EV_ABS, ABS_X, nd->x);
727 input_event(input, EV_ABS, ABS_Y, nd->y);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200728 }
Rafi Rubinff404622011-03-07 21:13:28 -0500729
730 /* Emit MT events */
731 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
732 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
733
734 /*
735 * Translate from height and width to size
736 * and orientation.
737 */
738 if (nd->w > nd->h) {
739 input_event(input, EV_ABS,
740 ABS_MT_ORIENTATION, 1);
741 input_event(input, EV_ABS,
742 ABS_MT_TOUCH_MAJOR, nd->w);
743 input_event(input, EV_ABS,
744 ABS_MT_TOUCH_MINOR, nd->h);
745 } else {
746 input_event(input, EV_ABS,
747 ABS_MT_ORIENTATION, 0);
748 input_event(input, EV_ABS,
749 ABS_MT_TOUCH_MAJOR, nd->h);
750 input_event(input, EV_ABS,
751 ABS_MT_TOUCH_MINOR, nd->w);
752 }
753 input_mt_sync(field->hidinput->input);
754 break;
755
756 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
757 if (!nd->reading_mt) /* Just to be sure */
758 break;
759
760 nd->reading_mt = 0;
761
762
763 /*
764 * Activation state machine logic:
765 *
766 * Fundamental states:
767 * state > 0: Inactive
768 * state <= 0: Active
769 * state < -deactivate_slack:
770 * Pen termination of touch
771 *
772 * Specific values of interest
773 * state == activate_slack
774 * no valid input since the last reset
775 *
776 * state == 0
777 * general operational state
778 *
779 * state == -deactivate_slack
780 * read sufficient empty frames to accept
781 * the end of input and reset
782 */
783
784 if (nd->act_state > 0) { /* Currently inactive */
785 if (value)
786 /*
787 * Consider each live contact as
788 * evidence of intentional activity.
789 */
790 nd->act_state = (nd->act_state > value)
791 ? nd->act_state - value
792 : 0;
793 else
794 /*
795 * Empty frame before we hit the
796 * activity threshold, reset.
797 */
798 nd->act_state = nd->activate_slack;
799
800 /*
801 * Entered this block inactive and no
802 * coordinates sent this frame, so hold off
803 * on button state.
804 */
805 break;
806 } else { /* Currently active */
807 if (value && nd->act_state >=
808 nd->deactivate_slack)
809 /*
810 * Live point: clear accumulated
811 * deactivation count.
812 */
813 nd->act_state = 0;
814 else if (nd->act_state <= nd->deactivate_slack)
815 /*
816 * We've consumed the deactivation
817 * slack, time to deactivate and reset.
818 */
819 nd->act_state =
820 nd->activate_slack;
821 else { /* Move towards deactivation */
822 nd->act_state--;
823 break;
824 }
825 }
826
827 if (nd->first_contact_touch && nd->act_state <= 0) {
828 /*
829 * Check to see if we're ready to start
830 * emitting touch events.
831 *
832 * Note: activation slack will decrease over
833 * the course of the frame, and it will be
834 * inconsistent from the start to the end of
835 * the frame. However if the frame starts
836 * with slack, first_contact_touch will still
837 * be 0 and we will not get to this point.
838 */
839 input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
840 input_report_key(input, BTN_TOUCH, 1);
841 } else {
842 input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
843 input_report_key(input, BTN_TOUCH, 0);
844 }
845 break;
846
847 default:
848 /* fall-back to the generic hidinput handling */
849 return 0;
Stephane Chatty57fd6372009-05-20 15:49:35 +0200850 }
851
Rafi Rubinf41a52d2011-03-08 00:24:29 -0500852not_claimed_input:
853
Stephane Chatty57fd6372009-05-20 15:49:35 +0200854 /* we have handled the hidinput part, now remains hiddev */
Rafi Rubin943ed462010-02-11 22:14:05 -0500855 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
856 hid->hiddev_hid_event(hid, field, usage, value);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200857
858 return 1;
859}
860
861static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
862{
863 int ret;
864 struct ntrig_data *nd;
Rafi Rubin943ed462010-02-11 22:14:05 -0500865 struct hid_input *hidinput;
866 struct input_dev *input;
Stephane Chatty65499812010-04-06 22:22:58 +0200867 struct hid_report *report;
Rafi Rubin943ed462010-02-11 22:14:05 -0500868
869 if (id->driver_data)
Rafi Rubin6638ded2011-03-09 23:33:51 -0500870 hdev->quirks |= HID_QUIRK_MULTI_INPUT
871 | HID_QUIRK_NO_INIT_REPORTS;
Stephane Chatty57fd6372009-05-20 15:49:35 +0200872
873 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
874 if (!nd) {
Joe Perches4291ee32010-12-09 19:29:03 -0800875 hid_err(hdev, "cannot allocate N-Trig data\n");
Stephane Chatty57fd6372009-05-20 15:49:35 +0200876 return -ENOMEM;
877 }
Rafi Rubindbf2b172010-02-12 21:13:05 -0500878
879 nd->reading_mt = 0;
Rafi Rubin369db2a2010-05-04 14:20:15 -0400880 nd->min_width = 0;
881 nd->min_height = 0;
882 nd->activate_slack = activate_slack;
883 nd->act_state = activate_slack;
884 nd->deactivate_slack = -deactivate_slack;
885 nd->sensor_logical_width = 0;
886 nd->sensor_logical_height = 0;
887 nd->sensor_physical_width = 0;
888 nd->sensor_physical_height = 0;
889
Stephane Chatty57fd6372009-05-20 15:49:35 +0200890 hid_set_drvdata(hdev, nd);
891
892 ret = hid_parse(hdev);
Rafi Rubin943ed462010-02-11 22:14:05 -0500893 if (ret) {
Joe Perches4291ee32010-12-09 19:29:03 -0800894 hid_err(hdev, "parse failed\n");
Rafi Rubin943ed462010-02-11 22:14:05 -0500895 goto err_free;
896 }
Stephane Chatty57fd6372009-05-20 15:49:35 +0200897
Rafi Rubin943ed462010-02-11 22:14:05 -0500898 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
899 if (ret) {
Joe Perches4291ee32010-12-09 19:29:03 -0800900 hid_err(hdev, "hw start failed\n");
Rafi Rubin943ed462010-02-11 22:14:05 -0500901 goto err_free;
902 }
Rafi Rubin837b4752009-06-23 14:09:26 -0400903
Rafi Rubin943ed462010-02-11 22:14:05 -0500904
905 list_for_each_entry(hidinput, &hdev->inputs, list) {
Rafi Rubin28865392010-03-10 16:10:28 +0100906 if (hidinput->report->maxfield < 1)
907 continue;
908
Rafi Rubin943ed462010-02-11 22:14:05 -0500909 input = hidinput->input;
910 switch (hidinput->report->field[0]->application) {
911 case HID_DG_PEN:
912 input->name = "N-Trig Pen";
913 break;
914 case HID_DG_TOUCHSCREEN:
Rafi Rubin28865392010-03-10 16:10:28 +0100915 /* These keys are redundant for fingers, clear them
916 * to prevent incorrect identification */
Rafi Rubindbf2b172010-02-12 21:13:05 -0500917 __clear_bit(BTN_TOOL_PEN, input->keybit);
Rafi Rubin28865392010-03-10 16:10:28 +0100918 __clear_bit(BTN_TOOL_FINGER, input->keybit);
919 __clear_bit(BTN_0, input->keybit);
Rafi Rubindbf2b172010-02-12 21:13:05 -0500920 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
Rafi Rubin943ed462010-02-11 22:14:05 -0500921 /*
922 * The physical touchscreen (single touch)
923 * input has a value for physical, whereas
924 * the multitouch only has logical input
925 * fields.
926 */
927 input->name =
928 (hidinput->report->field[0]
929 ->physical) ?
930 "N-Trig Touchscreen" :
931 "N-Trig MultiTouch";
932 break;
933 }
934 }
935
Jiri Kosinac0858552010-04-07 12:10:29 +0200936 /* This is needed for devices with more recent firmware versions */
937 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
Rafi Rubin7b2a64c2011-03-09 23:33:52 -0500938 if (report) {
939 /* Let the device settle to ensure the wakeup message gets
940 * through */
941 usbhid_wait_io(hdev);
942 usbhid_submit_report(hdev, report, USB_DIR_IN);
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 }
Stephane Chatty65499812010-04-06 22:22:58 +0200951
Rafi Rubin02778732010-09-08 11:46:14 +0200952 ntrig_report_version(hdev);
953
Rafi Rubineab32f52010-05-04 14:20:17 -0400954 ret = sysfs_create_group(&hdev->dev.kobj,
955 &ntrig_attribute_group);
Stephane Chatty65499812010-04-06 22:22:58 +0200956
Rafi Rubin943ed462010-02-11 22:14:05 -0500957 return 0;
958err_free:
959 kfree(nd);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200960 return ret;
961}
962
963static void ntrig_remove(struct hid_device *hdev)
964{
Rafi Rubineab32f52010-05-04 14:20:17 -0400965 sysfs_remove_group(&hdev->dev.kobj,
Rafi Rubina52dc342010-08-26 00:54:55 -0400966 &ntrig_attribute_group);
Stephane Chatty57fd6372009-05-20 15:49:35 +0200967 hid_hw_stop(hdev);
968 kfree(hid_get_drvdata(hdev));
969}
970
Rafi Rubin94011f92008-11-19 15:54:46 +0100971static 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 },
micki6e328192010-06-19 11:37:29 +0300974 { 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 },
Rafi Rubin94011f92008-11-19 15:54:46 +01001010 { }
1011};
1012MODULE_DEVICE_TABLE(hid, ntrig_devices);
1013
Stephane Chatty57fd6372009-05-20 15:49:35 +02001014static const struct hid_usage_id ntrig_grabbed_usages[] = {
1015 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
Rafi Rubin943ed462010-02-11 22:14:05 -05001016 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
Stephane Chatty57fd6372009-05-20 15:49:35 +02001017};
1018
Rafi Rubin94011f92008-11-19 15:54:46 +01001019static struct hid_driver ntrig_driver = {
1020 .name = "ntrig",
1021 .id_table = ntrig_devices,
Stephane Chatty57fd6372009-05-20 15:49:35 +02001022 .probe = ntrig_probe,
1023 .remove = ntrig_remove,
Rafi Rubin94011f92008-11-19 15:54:46 +01001024 .input_mapping = ntrig_input_mapping,
1025 .input_mapped = ntrig_input_mapped,
Stephane Chatty57fd6372009-05-20 15:49:35 +02001026 .usage_table = ntrig_grabbed_usages,
1027 .event = ntrig_event,
Rafi Rubin94011f92008-11-19 15:54:46 +01001028};
1029
Peter Huewea24f4232009-07-02 19:08:38 +02001030static int __init ntrig_init(void)
Rafi Rubin94011f92008-11-19 15:54:46 +01001031{
1032 return hid_register_driver(&ntrig_driver);
1033}
1034
Peter Huewea24f4232009-07-02 19:08:38 +02001035static void __exit ntrig_exit(void)
Rafi Rubin94011f92008-11-19 15:54:46 +01001036{
1037 hid_unregister_driver(&ntrig_driver);
1038}
1039
1040module_init(ntrig_init);
1041module_exit(ntrig_exit);
1042MODULE_LICENSE("GPL");