2 * HID driver for multitouch panels
4 * Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
5 * Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
6 * Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
8 * This code is partly based on hid-egalax.c:
10 * Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
11 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
12 * Copyright (c) 2010 Canonical, Ltd.
17 * This program is free software; you can redistribute it and/or modify it
18 * under the terms of the GNU General Public License as published by the Free
19 * Software Foundation; either version 2 of the License, or (at your option)
23 #include <linux/device.h>
24 #include <linux/hid.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/usb.h>
28 #include <linux/input/mt.h>
29 #include "usbhid/usbhid.h"
32 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
33 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
34 MODULE_DESCRIPTION("HID multitouch panels");
35 MODULE_LICENSE("GPL");
39 /* quirks to control the device */
40 #define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0)
41 #define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1)
42 #define MT_QUIRK_CYPRESS (1 << 2)
43 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3)
44 #define MT_QUIRK_VALID_IS_INRANGE (1 << 4)
45 #define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 5)
46 #define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 6)
50 __s32 contactid
; /* the device ContactID assigned to this slot */
51 bool touch_state
; /* is the touch valid? */
52 bool seen_in_this_frame
;/* has this slot been updated */
56 struct mt_slot curdata
; /* placeholder of incoming data */
57 struct mt_class
*mtclass
; /* our mt device class */
58 unsigned last_field_index
; /* last field index of the report */
59 unsigned last_slot_field
; /* the last field of a slot */
60 __s8 inputmode
; /* InputMode HID feature, -1 if non-existent */
61 __u8 num_received
; /* how many contacts we received */
62 __u8 num_expected
; /* expected last contact index */
64 bool curvalid
; /* is the current contact valid? */
65 struct mt_slot
*slots
;
69 __s32 name
; /* MT_CLS */
71 __s32 sn_move
; /* Signal/noise ratio for move events */
72 __s32 sn_pressure
; /* Signal/noise ratio for pressure events */
76 /* classes of device behavior */
77 #define MT_CLS_DEFAULT 1
78 #define MT_CLS_DUAL_INRANGE_CONTACTID 2
79 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 3
80 #define MT_CLS_CYPRESS 4
81 #define MT_CLS_EGALAX 5
83 #define MT_DEFAULT_MAXCONTACT 10
86 * these device-dependent functions determine what slot corresponds
87 * to a valid contact that was just read.
90 static int cypress_compute_slot(struct mt_device
*td
)
92 if (td
->curdata
.contactid
!= 0 || td
->num_received
== 0)
93 return td
->curdata
.contactid
;
98 static int find_slot_from_contactid(struct mt_device
*td
)
101 for (i
= 0; i
< td
->maxcontacts
; ++i
) {
102 if (td
->slots
[i
].contactid
== td
->curdata
.contactid
&&
103 td
->slots
[i
].touch_state
)
106 for (i
= 0; i
< td
->maxcontacts
; ++i
) {
107 if (!td
->slots
[i
].seen_in_this_frame
&&
108 !td
->slots
[i
].touch_state
)
111 /* should not occurs. If this happens that means
112 * that the device sent more touches that it says
113 * in the report descriptor. It is ignored then. */
117 struct mt_class mt_classes
[] = {
118 { .name
= MT_CLS_DEFAULT
,
119 .quirks
= MT_QUIRK_NOT_SEEN_MEANS_UP
},
120 { .name
= MT_CLS_DUAL_INRANGE_CONTACTID
,
121 .quirks
= MT_QUIRK_VALID_IS_INRANGE
|
122 MT_QUIRK_SLOT_IS_CONTACTID
,
124 { .name
= MT_CLS_DUAL_INRANGE_CONTACTNUMBER
,
125 .quirks
= MT_QUIRK_VALID_IS_INRANGE
|
126 MT_QUIRK_SLOT_IS_CONTACTNUMBER
,
128 { .name
= MT_CLS_CYPRESS
,
129 .quirks
= MT_QUIRK_NOT_SEEN_MEANS_UP
|
133 { .name
= MT_CLS_EGALAX
,
134 .quirks
= MT_QUIRK_SLOT_IS_CONTACTID
|
135 MT_QUIRK_VALID_IS_INRANGE
|
136 MT_QUIRK_EGALAX_XYZ_FIXUP
,
144 static void mt_feature_mapping(struct hid_device
*hdev
,
145 struct hid_field
*field
, struct hid_usage
*usage
)
147 struct mt_device
*td
= hid_get_drvdata(hdev
);
149 switch (usage
->hid
) {
150 case HID_DG_INPUTMODE
:
151 td
->inputmode
= field
->report
->id
;
153 case HID_DG_CONTACTMAX
:
154 td
->maxcontacts
= field
->value
[0];
155 if (td
->mtclass
->maxcontacts
)
156 /* check if the maxcontacts is given by the class */
157 td
->maxcontacts
= td
->mtclass
->maxcontacts
;
163 static void set_abs(struct input_dev
*input
, unsigned int code
,
164 struct hid_field
*field
, int snratio
)
166 int fmin
= field
->logical_minimum
;
167 int fmax
= field
->logical_maximum
;
168 int fuzz
= snratio
? (fmax
- fmin
) / snratio
: 0;
169 input_set_abs_params(input
, code
, fmin
, fmax
, fuzz
, 0);
172 static int mt_input_mapping(struct hid_device
*hdev
, struct hid_input
*hi
,
173 struct hid_field
*field
, struct hid_usage
*usage
,
174 unsigned long **bit
, int *max
)
176 struct mt_device
*td
= hid_get_drvdata(hdev
);
177 struct mt_class
*cls
= td
->mtclass
;
178 __s32 quirks
= cls
->quirks
;
180 switch (usage
->hid
& HID_USAGE_PAGE
) {
183 switch (usage
->hid
) {
185 if (quirks
& MT_QUIRK_EGALAX_XYZ_FIXUP
)
186 field
->logical_maximum
= 32760;
187 hid_map_usage(hi
, usage
, bit
, max
,
188 EV_ABS
, ABS_MT_POSITION_X
);
189 set_abs(hi
->input
, ABS_MT_POSITION_X
, field
,
191 /* touchscreen emulation */
192 set_abs(hi
->input
, ABS_X
, field
, cls
->sn_move
);
193 td
->last_slot_field
= usage
->hid
;
196 if (quirks
& MT_QUIRK_EGALAX_XYZ_FIXUP
)
197 field
->logical_maximum
= 32760;
198 hid_map_usage(hi
, usage
, bit
, max
,
199 EV_ABS
, ABS_MT_POSITION_Y
);
200 set_abs(hi
->input
, ABS_MT_POSITION_Y
, field
,
202 /* touchscreen emulation */
203 set_abs(hi
->input
, ABS_Y
, field
, cls
->sn_move
);
204 td
->last_slot_field
= usage
->hid
;
209 case HID_UP_DIGITIZER
:
210 switch (usage
->hid
) {
212 td
->last_slot_field
= usage
->hid
;
214 case HID_DG_CONFIDENCE
:
215 td
->last_slot_field
= usage
->hid
;
217 case HID_DG_TIPSWITCH
:
218 hid_map_usage(hi
, usage
, bit
, max
, EV_KEY
, BTN_TOUCH
);
219 input_set_capability(hi
->input
, EV_KEY
, BTN_TOUCH
);
220 td
->last_slot_field
= usage
->hid
;
222 case HID_DG_CONTACTID
:
223 input_mt_init_slots(hi
->input
, td
->maxcontacts
);
224 td
->last_slot_field
= usage
->hid
;
227 hid_map_usage(hi
, usage
, bit
, max
,
228 EV_ABS
, ABS_MT_TOUCH_MAJOR
);
229 td
->last_slot_field
= usage
->hid
;
232 hid_map_usage(hi
, usage
, bit
, max
,
233 EV_ABS
, ABS_MT_TOUCH_MINOR
);
234 field
->logical_maximum
= 1;
235 field
->logical_minimum
= 0;
236 set_abs(hi
->input
, ABS_MT_ORIENTATION
, field
, 0);
237 td
->last_slot_field
= usage
->hid
;
239 case HID_DG_TIPPRESSURE
:
240 if (quirks
& MT_QUIRK_EGALAX_XYZ_FIXUP
)
241 field
->logical_minimum
= 0;
242 hid_map_usage(hi
, usage
, bit
, max
,
243 EV_ABS
, ABS_MT_PRESSURE
);
244 set_abs(hi
->input
, ABS_MT_PRESSURE
, field
,
246 /* touchscreen emulation */
247 set_abs(hi
->input
, ABS_PRESSURE
, field
,
249 td
->last_slot_field
= usage
->hid
;
251 case HID_DG_CONTACTCOUNT
:
252 td
->last_field_index
= field
->report
->maxfield
- 1;
254 case HID_DG_CONTACTMAX
:
255 /* we don't set td->last_slot_field as contactcount and
256 * contact max are global to the report */
259 /* let hid-input decide for the others */
263 /* we do not want to map these: no input-oriented meaning */
270 static int mt_input_mapped(struct hid_device
*hdev
, struct hid_input
*hi
,
271 struct hid_field
*field
, struct hid_usage
*usage
,
272 unsigned long **bit
, int *max
)
274 if (usage
->type
== EV_KEY
|| usage
->type
== EV_ABS
)
275 set_bit(usage
->type
, hi
->input
->evbit
);
280 static int mt_compute_slot(struct mt_device
*td
)
282 __s32 quirks
= td
->mtclass
->quirks
;
284 if (quirks
& MT_QUIRK_SLOT_IS_CONTACTID
)
285 return td
->curdata
.contactid
;
287 if (quirks
& MT_QUIRK_CYPRESS
)
288 return cypress_compute_slot(td
);
290 if (quirks
& MT_QUIRK_SLOT_IS_CONTACTNUMBER
)
291 return td
->num_received
;
293 return find_slot_from_contactid(td
);
297 * this function is called when a whole contact has been processed,
298 * so that it can assign it to a slot and store the data there
300 static void mt_complete_slot(struct mt_device
*td
)
302 td
->curdata
.seen_in_this_frame
= true;
304 int slotnum
= mt_compute_slot(td
);
306 if (slotnum
>= 0 && slotnum
< td
->maxcontacts
)
307 td
->slots
[slotnum
] = td
->curdata
;
314 * this function is called when a whole packet has been received and processed,
315 * so that it can decide what to send to the input layer.
317 static void mt_emit_event(struct mt_device
*td
, struct input_dev
*input
)
321 for (i
= 0; i
< td
->maxcontacts
; ++i
) {
322 struct mt_slot
*s
= &(td
->slots
[i
]);
323 if ((td
->mtclass
->quirks
& MT_QUIRK_NOT_SEEN_MEANS_UP
) &&
324 !s
->seen_in_this_frame
) {
325 s
->touch_state
= false;
328 input_mt_slot(input
, i
);
329 input_mt_report_slot_state(input
, MT_TOOL_FINGER
,
331 if (s
->touch_state
) {
332 input_event(input
, EV_ABS
, ABS_MT_POSITION_X
, s
->x
);
333 input_event(input
, EV_ABS
, ABS_MT_POSITION_Y
, s
->y
);
334 input_event(input
, EV_ABS
, ABS_MT_PRESSURE
, s
->p
);
335 input_event(input
, EV_ABS
, ABS_MT_TOUCH_MAJOR
, s
->w
);
336 input_event(input
, EV_ABS
, ABS_MT_TOUCH_MINOR
, s
->h
);
338 s
->seen_in_this_frame
= false;
342 input_mt_report_pointer_emulation(input
, true);
344 td
->num_received
= 0;
349 static int mt_event(struct hid_device
*hid
, struct hid_field
*field
,
350 struct hid_usage
*usage
, __s32 value
)
352 struct mt_device
*td
= hid_get_drvdata(hid
);
353 __s32 quirks
= td
->mtclass
->quirks
;
355 if (hid
->claimed
& HID_CLAIMED_INPUT
&& td
->slots
) {
356 switch (usage
->hid
) {
358 if (quirks
& MT_QUIRK_VALID_IS_INRANGE
)
359 td
->curvalid
= value
;
361 case HID_DG_TIPSWITCH
:
362 if (quirks
& MT_QUIRK_NOT_SEEN_MEANS_UP
)
363 td
->curvalid
= value
;
364 td
->curdata
.touch_state
= value
;
366 case HID_DG_CONFIDENCE
:
367 if (quirks
& MT_QUIRK_VALID_IS_CONFIDENCE
)
368 td
->curvalid
= value
;
370 case HID_DG_CONTACTID
:
371 td
->curdata
.contactid
= value
;
373 case HID_DG_TIPPRESSURE
:
374 td
->curdata
.p
= value
;
377 td
->curdata
.x
= value
;
380 td
->curdata
.y
= value
;
383 td
->curdata
.w
= value
;
386 td
->curdata
.h
= value
;
388 case HID_DG_CONTACTCOUNT
:
390 * Includes multi-packet support where subsequent
391 * packets are sent with zero contactcount.
394 td
->num_expected
= value
;
398 /* fallback to the generic hidinput handling */
402 if (usage
->hid
== td
->last_slot_field
) {
403 mt_complete_slot(td
);
404 if (!td
->last_field_index
)
405 mt_emit_event(td
, field
->hidinput
->input
);
408 if (field
->index
== td
->last_field_index
409 && td
->num_received
>= td
->num_expected
)
410 mt_emit_event(td
, field
->hidinput
->input
);
414 /* we have handled the hidinput part, now remains hiddev */
415 if (hid
->claimed
& HID_CLAIMED_HIDDEV
&& hid
->hiddev_hid_event
)
416 hid
->hiddev_hid_event(hid
, field
, usage
, value
);
421 static void mt_set_input_mode(struct hid_device
*hdev
)
423 struct mt_device
*td
= hid_get_drvdata(hdev
);
424 struct hid_report
*r
;
425 struct hid_report_enum
*re
;
427 if (td
->inputmode
< 0)
430 re
= &(hdev
->report_enum
[HID_FEATURE_REPORT
]);
431 r
= re
->report_id_hash
[td
->inputmode
];
433 r
->field
[0]->value
[0] = 0x02;
434 usbhid_submit_report(hdev
, r
, USB_DIR_OUT
);
438 static int mt_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
441 struct mt_device
*td
;
442 struct mt_class
*mtclass
= mt_classes
; /* MT_CLS_DEFAULT */
444 for (i
= 0; mt_classes
[i
].name
; i
++) {
445 if (id
->driver_data
== mt_classes
[i
].name
) {
446 mtclass
= &(mt_classes
[i
]);
451 /* This allows the driver to correctly support devices
452 * that emit events over several HID messages.
454 hdev
->quirks
|= HID_QUIRK_NO_INPUT_SYNC
;
456 td
= kzalloc(sizeof(struct mt_device
), GFP_KERNEL
);
458 dev_err(&hdev
->dev
, "cannot allocate multitouch data\n");
461 td
->mtclass
= mtclass
;
463 hid_set_drvdata(hdev
, td
);
465 ret
= hid_parse(hdev
);
469 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
473 if (!td
->maxcontacts
)
474 td
->maxcontacts
= MT_DEFAULT_MAXCONTACT
;
476 td
->slots
= kzalloc(td
->maxcontacts
* sizeof(struct mt_slot
),
479 dev_err(&hdev
->dev
, "cannot allocate multitouch slots\n");
485 mt_set_input_mode(hdev
);
495 static int mt_reset_resume(struct hid_device
*hdev
)
497 mt_set_input_mode(hdev
);
502 static void mt_remove(struct hid_device
*hdev
)
504 struct mt_device
*td
= hid_get_drvdata(hdev
);
508 hid_set_drvdata(hdev
, NULL
);
511 static const struct hid_device_id mt_devices
[] = {
514 { .driver_data
= MT_CLS_CYPRESS
,
515 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS
,
516 USB_DEVICE_ID_CYPRESS_TRUETOUCH
) },
518 /* GeneralTouch panel */
519 { .driver_data
= MT_CLS_DUAL_INRANGE_CONTACTNUMBER
,
520 HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH
,
521 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS
) },
524 { .driver_data
= MT_CLS_DUAL_INRANGE_CONTACTID
,
525 HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS
,
526 USB_DEVICE_ID_IRTOUCH_INFRARED_USB
) },
528 /* PixCir-based panels */
529 { .driver_data
= MT_CLS_DUAL_INRANGE_CONTACTID
,
530 HID_USB_DEVICE(USB_VENDOR_ID_HANVON
,
531 USB_DEVICE_ID_HANVON_MULTITOUCH
) },
532 { .driver_data
= MT_CLS_DUAL_INRANGE_CONTACTID
,
533 HID_USB_DEVICE(USB_VENDOR_ID_CANDO
,
534 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH
) },
536 /* Resistive eGalax devices */
537 { .driver_data
= MT_CLS_EGALAX
,
538 HID_USB_DEVICE(USB_VENDOR_ID_DWAV
,
539 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH
) },
540 { .driver_data
= MT_CLS_EGALAX
,
541 HID_USB_DEVICE(USB_VENDOR_ID_DWAV
,
542 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3
) },
544 /* Capacitive eGalax devices */
545 { .driver_data
= MT_CLS_EGALAX
,
546 HID_USB_DEVICE(USB_VENDOR_ID_DWAV
,
547 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1
) },
548 { .driver_data
= MT_CLS_EGALAX
,
549 HID_USB_DEVICE(USB_VENDOR_ID_DWAV
,
550 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2
) },
551 { .driver_data
= MT_CLS_EGALAX
,
552 HID_USB_DEVICE(USB_VENDOR_ID_DWAV
,
553 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4
) },
557 MODULE_DEVICE_TABLE(hid
, mt_devices
);
559 static const struct hid_usage_id mt_grabbed_usages
[] = {
560 { HID_ANY_ID
, HID_ANY_ID
, HID_ANY_ID
},
561 { HID_ANY_ID
- 1, HID_ANY_ID
- 1, HID_ANY_ID
- 1}
564 static struct hid_driver mt_driver
= {
565 .name
= "hid-multitouch",
566 .id_table
= mt_devices
,
569 .input_mapping
= mt_input_mapping
,
570 .input_mapped
= mt_input_mapped
,
571 .feature_mapping
= mt_feature_mapping
,
572 .usage_table
= mt_grabbed_usages
,
575 .reset_resume
= mt_reset_resume
,
579 static int __init
mt_init(void)
581 return hid_register_driver(&mt_driver
);
584 static void __exit
mt_exit(void)
586 hid_unregister_driver(&mt_driver
);
589 module_init(mt_init
);
590 module_exit(mt_exit
);