Kernel

Kernel Git Source Tree

Root/drivers/hid/hid-ntrig.c

1	/*
2	* HID driver for N-Trig touchscreens
3	*
4	* Copyright (c) 2008-2010 Rafi Rubin
5	* Copyright (c) 2009-2010 Stephane Chatty
6	*
7	*/
8
9	/*
10	* This program is free software; you can redistribute it and/or modify it
11	* under the terms of the GNU General Public License as published by the Free
12	* Software Foundation; either version 2 of the License, or (at your option)
13	* any later version.
14	*/
15
16	#include <linux/device.h>
17	#include <linux/hid.h>
18	#include <linux/usb.h>
19	#include "usbhid/usbhid.h"
20	#include <linux/module.h>
21	#include <linux/slab.h>
22
23	#include "hid-ids.h"
24
25	#define NTRIG_DUPLICATE_USAGES 0x001
26
27	static unsigned int min_width;
28	module_param(min_width, uint, 0644);
29	MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
30
31	static unsigned int min_height;
32	module_param(min_height, uint, 0644);
33	MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
34
35	static unsigned int activate_slack = 1;
36	module_param(activate_slack, uint, 0644);
37	MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
38	"the start of touch input.");
39
40	static unsigned int deactivate_slack = 4;
41	module_param(deactivate_slack, uint, 0644);
42	MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
43	"deactivating touch.");
44
45	static unsigned int activation_width = 64;
46	module_param(activation_width, uint, 0644);
47	MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
48	"processing touch events.");
49
50	static unsigned int activation_height = 32;
51	module_param(activation_height, uint, 0644);
52	MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
53	"processing touch events.");
54
55	struct ntrig_data {
56	/* Incoming raw values for a single contact */
57	__u16 x, y, w, h;
58	__u16 id;
59
60	bool tipswitch;
61	bool confidence;
62	bool first_contact_touch;
63
64	bool reading_mt;
65
66	__u8 mt_footer[4];
67	__u8 mt_foot_count;
68
69	/* The current activation state. */
70	__s8 act_state;
71
72	/* Empty frames to ignore before recognizing the end of activity */
73	__s8 deactivate_slack;
74
75	/* Frames to ignore before acknowledging the start of activity */
76	__s8 activate_slack;
77
78	/* Minimum size contact to accept */
79	__u16 min_width;
80	__u16 min_height;
81
82	/* Threshold to override activation slack */
83	__u16 activation_width;
84	__u16 activation_height;
85
86	__u16 sensor_logical_width;
87	__u16 sensor_logical_height;
88	__u16 sensor_physical_width;
89	__u16 sensor_physical_height;
90	};
91
92
93	/*
94	* This function converts the 4 byte raw firmware code into
95	* a string containing 5 comma separated numbers.
96	*/
97	static int ntrig_version_string(unsigned char raw, char buf)
98	{
99	__u8 a = (raw[1] & 0x0e) >> 1;
100	__u8 b = (raw[0] & 0x3c) >> 2;
101	__u8 c = ((raw[0] & 0x03) << 3) \| ((raw[3] & 0xe0) >> 5);
102	__u8 d = ((raw[3] & 0x07) << 3) \| ((raw[2] & 0xe0) >> 5);
103	__u8 e = raw[2] & 0x07;
104
105	/*
106	* As yet unmapped bits:
107	* 0b11000000 0b11110001 0b00011000 0b00011000
108	*/
109
110	return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e);
111	}
112
113	static inline int ntrig_get_mode(struct hid_device *hdev)
114	{
115	struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT].
116	report_id_hash[0x0d];
117
118	if (!report)
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
126	static 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
143	static 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
163	hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",
164	buf, data[2], data[3], data[4], data[5]);
165	}
166
167	err_free:
168	kfree(data);
169	}
170
171	static 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
181	static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
182
183	static 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
193	static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
194
195	static 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
205	static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
206
207	static 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
217	static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
218
219	static 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
231	static 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
252	static DEVICE_ATTR(min_width, S_IWUSR \| S_IRUGO, show_min_width, set_min_width);
253
254	static 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
266	static 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
287	static DEVICE_ATTR(min_height, S_IWUSR \| S_IRUGO, show_min_height,
288	set_min_height);
289
290	static 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
300	static 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
320	static DEVICE_ATTR(activate_slack, S_IWUSR \| S_IRUGO, show_activate_slack,
321	set_activate_slack);
322
323	static 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
335	static 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
356	static DEVICE_ATTR(activation_width, S_IWUSR \| S_IRUGO, show_activation_width,
357	set_activation_width);
358
359	static 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
371	static 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
392	static DEVICE_ATTR(activation_height, S_IWUSR \| S_IRUGO,
393	show_activation_height, set_activation_height);
394
395	static 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
405	static 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
430	static DEVICE_ATTR(deactivate_slack, S_IWUSR \| S_IRUGO, show_deactivate_slack,
431	set_deactivate_slack);
432
433	static 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
447	static struct attribute_group ntrig_attribute_group = {
448	.attrs = sysfs_attrs
449	};
450
451	/*
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
457	static int ntrig_input_mapping(struct hid_device hdev, struct hid_input hi,
458	struct hid_field field, struct hid_usage usage,
459	unsigned long *bit, int max)
460	{
461	struct ntrig_data *nd = hid_get_drvdata(hdev);
462
463	/* No special mappings needed for the pen and single touch */
464	if (field->physical)
465	return 0;
466
467	switch (usage->hid & HID_USAGE_PAGE) {
468	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);
476
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	}
491	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);
498
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	}
513	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 */
520	case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */
521	case HID_DG_INPUTMODE:
522	case HID_DG_DEVICEINDEX:
523	case HID_DG_CONTACTMAX:
524	return -1;
525
526	/* width/height mapped on TouchMajor/TouchMinor/Orientation */
527	case HID_DG_WIDTH:
528	hid_map_usage(hi, usage, bit, max,
529	EV_ABS, ABS_MT_TOUCH_MAJOR);
530	return 1;
531	case HID_DG_HEIGHT:
532	hid_map_usage(hi, usage, bit, max,
533	EV_ABS, ABS_MT_TOUCH_MINOR);
534	input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
535	0, 1, 0, 0);
536	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;
543	}
544
545	return 0;
546	}
547
548	static int ntrig_input_mapped(struct hid_device hdev, struct hid_input hi,
549	struct hid_field field, struct hid_usage usage,
550	unsigned long *bit, int max)
551	{
552	/* No special mappings needed for the pen and single touch */
553	if (field->physical)
554	return 0;
555
556	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	}
562
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	*/
569	static int ntrig_event (struct hid_device hid, struct hid_field field,
570	struct hid_usage *usage, __s32 value)
571	{
572	struct ntrig_data *nd = hid_get_drvdata(hid);
573	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;
585
586	/* No special handling needed for the pen */
587	if (field->application == HID_DG_PEN)
588	return 0;
589
590	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) {
625	/*
626	* TipSwitch indicates the presence of a
627	* finger in single touch mode.
628	*/
629	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)
647	break;
648
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]) {
657	/*
658	* 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.
663	*/
664	nd->act_state = deactivate_slack - 1;
665	nd->confidence = 0;
666	break;
667	}
668
669	/*
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)
681	nd->confidence = 0;
682	} else
683	break;
684
685	if (nd->act_state > 0) {
686	/*
687	* Contact meets the activation size threshold
688	*/
689	if (nd->w >= nd->activation_width &&
690	nd->h >= nd->activation_height) {
691	if (nd->id)
692	/*
693	* first contact, activate now
694	*/
695	nd->act_state = 0;
696	else {
697	/*
698	* avoid corrupting this frame
699	* but ensure next frame will
700	* be active
701	*/
702	nd->act_state = 1;
703	break;
704	}
705	} else
706	/*
707	* Defer adjusting the activation state
708	* until the end of the frame.
709	*/
710	break;
711	}
712
713	/* Discarding this contact */
714	if (!nd->confidence)
715	break;
716
717	/* 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);
728	}
729
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;
850	}
851
852	not_claimed_input:
853
854	/* we have handled the hidinput part, now remains hiddev */
855	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
856	hid->hiddev_hid_event(hid, field, usage, value);
857
858	return 1;
859	}
860
861	static int ntrig_probe(struct hid_device hdev, const struct hid_device_id id)
862	{
863	int ret;
864	struct ntrig_data *nd;
865	struct hid_input *hidinput;
866	struct input_dev *input;
867	struct hid_report *report;
868
869	if (id->driver_data)
870	hdev->quirks \|= HID_QUIRK_MULTI_INPUT
871	\| HID_QUIRK_NO_INIT_REPORTS;
872
873	nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
874	if (!nd) {
875	hid_err(hdev, "cannot allocate N-Trig data\n");
876	return -ENOMEM;
877	}
878
879	nd->reading_mt = 0;
880	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
890	hid_set_drvdata(hdev, nd);
891
892	ret = hid_parse(hdev);
893	if (ret) {
894	hid_err(hdev, "parse failed\n");
895	goto err_free;
896	}
897
898	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
899	if (ret) {
900	hid_err(hdev, "hw start failed\n");
901	goto err_free;
902	}
903
904
905	list_for_each_entry(hidinput, &hdev->inputs, list) {
906	if (hidinput->report->maxfield < 1)
907	continue;
908
909	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:
915	/* These keys are redundant for fingers, clear them
916	* to prevent incorrect identification */
917	__clear_bit(BTN_TOOL_PEN, input->keybit);
918	__clear_bit(BTN_TOOL_FINGER, input->keybit);
919	__clear_bit(BTN_0, input->keybit);
920	__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
921	/*
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
936	/* This is needed for devices with more recent firmware versions */
937	report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
938	if (report) {
939	/* Let the device settle to ensure the wakeup message gets
940	* through */
941	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	}
951
952	ntrig_report_version(hdev);
953
954	ret = sysfs_create_group(&hdev->dev.kobj,
955	&ntrig_attribute_group);
956
957	return 0;
958	err_free:
959	kfree(nd);
960	return ret;
961	}
962
963	static void ntrig_remove(struct hid_device *hdev)
964	{
965	sysfs_remove_group(&hdev->dev.kobj,
966	&ntrig_attribute_group);
967	hid_hw_stop(hdev);
968	kfree(hid_get_drvdata(hdev));
969	}
970
971	static const struct hid_device_id ntrig_devices[] = {
972	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
973	.driver_data = NTRIG_DUPLICATE_USAGES },
974	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),
975	.driver_data = NTRIG_DUPLICATE_USAGES },
976	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),
977	.driver_data = NTRIG_DUPLICATE_USAGES },
978	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),
979	.driver_data = NTRIG_DUPLICATE_USAGES },
980	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),
981	.driver_data = NTRIG_DUPLICATE_USAGES },
982	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),
983	.driver_data = NTRIG_DUPLICATE_USAGES },
984	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),
985	.driver_data = NTRIG_DUPLICATE_USAGES },
986	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),
987	.driver_data = NTRIG_DUPLICATE_USAGES },
988	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),
989	.driver_data = NTRIG_DUPLICATE_USAGES },
990	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),
991	.driver_data = NTRIG_DUPLICATE_USAGES },
992	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),
993	.driver_data = NTRIG_DUPLICATE_USAGES },
994	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),
995	.driver_data = NTRIG_DUPLICATE_USAGES },
996	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),
997	.driver_data = NTRIG_DUPLICATE_USAGES },
998	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),
999	.driver_data = NTRIG_DUPLICATE_USAGES },
1000	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),
1001	.driver_data = NTRIG_DUPLICATE_USAGES },
1002	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),
1003	.driver_data = NTRIG_DUPLICATE_USAGES },
1004	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),
1005	.driver_data = NTRIG_DUPLICATE_USAGES },
1006	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),
1007	.driver_data = NTRIG_DUPLICATE_USAGES },
1008	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),
1009	.driver_data = NTRIG_DUPLICATE_USAGES },
1010	{ }
1011	};
1012	MODULE_DEVICE_TABLE(hid, ntrig_devices);
1013
1014	static const struct hid_usage_id ntrig_grabbed_usages[] = {
1015	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
1016	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
1017	};
1018
1019	static struct hid_driver ntrig_driver = {
1020	.name = "ntrig",
1021	.id_table = ntrig_devices,
1022	.probe = ntrig_probe,
1023	.remove = ntrig_remove,
1024	.input_mapping = ntrig_input_mapping,
1025	.input_mapped = ntrig_input_mapped,
1026	.usage_table = ntrig_grabbed_usages,
1027	.event = ntrig_event,
1028	};
1029
1030	static int __init ntrig_init(void)
1031	{
1032	return hid_register_driver(&ntrig_driver);
1033	}
1034
1035	static void __exit ntrig_exit(void)
1036	{
1037	hid_unregister_driver(&ntrig_driver);
1038	}
1039
1040	module_init(ntrig_init);
1041	module_exit(ntrig_exit);
1042	MODULE_LICENSE("GPL");
1043

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/hid/hid-ntrig.c

interactive