![Benjamin Tissoires](/assets/img/avatar_default.png)
This patch sorts the defs for the MT_CLS. I choose to split generic classes and device specific ones to be able to add more generic classes in the future. It also put eGalax devices at their right place (alphabetically) in mt_devices. Signed-off-by: Benjamin Tissoires <benjamin.tissoires@enac.fr> Signed-off-by: Jiri Kosina <jkosina@suse.cz>
739 lines
20 KiB
C
739 lines
20 KiB
C
/*
|
|
* HID driver for multitouch panels
|
|
*
|
|
* Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
|
|
* Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
|
|
* Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
|
|
*
|
|
* This code is partly based on hid-egalax.c:
|
|
*
|
|
* Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
|
|
* Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
|
|
* Copyright (c) 2010 Canonical, Ltd.
|
|
*
|
|
* This code is partly based on hid-3m-pct.c:
|
|
*
|
|
* Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
|
|
* Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
|
|
* Copyright (c) 2010 Canonical, Ltd.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*/
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/hid.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/input/mt.h>
|
|
#include "usbhid/usbhid.h"
|
|
|
|
|
|
MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
|
|
MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
|
|
MODULE_DESCRIPTION("HID multitouch panels");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#include "hid-ids.h"
|
|
|
|
/* quirks to control the device */
|
|
#define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0)
|
|
#define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1)
|
|
#define MT_QUIRK_CYPRESS (1 << 2)
|
|
#define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3)
|
|
#define MT_QUIRK_VALID_IS_INRANGE (1 << 4)
|
|
#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 5)
|
|
#define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 6)
|
|
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 7)
|
|
|
|
struct mt_slot {
|
|
__s32 x, y, p, w, h;
|
|
__s32 contactid; /* the device ContactID assigned to this slot */
|
|
bool touch_state; /* is the touch valid? */
|
|
bool seen_in_this_frame;/* has this slot been updated */
|
|
};
|
|
|
|
struct mt_device {
|
|
struct mt_slot curdata; /* placeholder of incoming data */
|
|
struct mt_class *mtclass; /* our mt device class */
|
|
unsigned last_field_index; /* last field index of the report */
|
|
unsigned last_slot_field; /* the last field of a slot */
|
|
__s8 inputmode; /* InputMode HID feature, -1 if non-existent */
|
|
__u8 num_received; /* how many contacts we received */
|
|
__u8 num_expected; /* expected last contact index */
|
|
__u8 maxcontacts;
|
|
bool curvalid; /* is the current contact valid? */
|
|
struct mt_slot *slots;
|
|
};
|
|
|
|
struct mt_class {
|
|
__s32 name; /* MT_CLS */
|
|
__s32 quirks;
|
|
__s32 sn_move; /* Signal/noise ratio for move events */
|
|
__s32 sn_width; /* Signal/noise ratio for width events */
|
|
__s32 sn_height; /* Signal/noise ratio for height events */
|
|
__s32 sn_pressure; /* Signal/noise ratio for pressure events */
|
|
__u8 maxcontacts;
|
|
};
|
|
|
|
/* classes of device behavior */
|
|
#define MT_CLS_DEFAULT 0x0001
|
|
|
|
#define MT_CLS_CONFIDENCE 0x0002
|
|
#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0003
|
|
#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0004
|
|
#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0005
|
|
#define MT_CLS_DUAL_NSMU_CONTACTID 0x0006
|
|
|
|
/* vendor specific classes */
|
|
#define MT_CLS_3M 0x0101
|
|
#define MT_CLS_CYPRESS 0x0102
|
|
#define MT_CLS_EGALAX 0x0103
|
|
|
|
#define MT_DEFAULT_MAXCONTACT 10
|
|
|
|
/*
|
|
* these device-dependent functions determine what slot corresponds
|
|
* to a valid contact that was just read.
|
|
*/
|
|
|
|
static int cypress_compute_slot(struct mt_device *td)
|
|
{
|
|
if (td->curdata.contactid != 0 || td->num_received == 0)
|
|
return td->curdata.contactid;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
static int find_slot_from_contactid(struct mt_device *td)
|
|
{
|
|
int i;
|
|
for (i = 0; i < td->maxcontacts; ++i) {
|
|
if (td->slots[i].contactid == td->curdata.contactid &&
|
|
td->slots[i].touch_state)
|
|
return i;
|
|
}
|
|
for (i = 0; i < td->maxcontacts; ++i) {
|
|
if (!td->slots[i].seen_in_this_frame &&
|
|
!td->slots[i].touch_state)
|
|
return i;
|
|
}
|
|
/* should not occurs. If this happens that means
|
|
* that the device sent more touches that it says
|
|
* in the report descriptor. It is ignored then. */
|
|
return -1;
|
|
}
|
|
|
|
struct mt_class mt_classes[] = {
|
|
{ .name = MT_CLS_DEFAULT,
|
|
.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
|
|
{ .name = MT_CLS_CONFIDENCE,
|
|
.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
|
|
{ .name = MT_CLS_CONFIDENCE_MINUS_ONE,
|
|
.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
|
|
MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
|
|
{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
|
|
.quirks = MT_QUIRK_VALID_IS_INRANGE |
|
|
MT_QUIRK_SLOT_IS_CONTACTID,
|
|
.maxcontacts = 2 },
|
|
{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
|
|
.quirks = MT_QUIRK_VALID_IS_INRANGE |
|
|
MT_QUIRK_SLOT_IS_CONTACTNUMBER,
|
|
.maxcontacts = 2 },
|
|
{ .name = MT_CLS_DUAL_NSMU_CONTACTID,
|
|
.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
|
|
MT_QUIRK_SLOT_IS_CONTACTID,
|
|
.maxcontacts = 2 },
|
|
|
|
/*
|
|
* vendor specific classes
|
|
*/
|
|
{ .name = MT_CLS_3M,
|
|
.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
|
|
MT_QUIRK_SLOT_IS_CONTACTID,
|
|
.sn_move = 2048,
|
|
.sn_width = 128,
|
|
.sn_height = 128 },
|
|
{ .name = MT_CLS_CYPRESS,
|
|
.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
|
|
MT_QUIRK_CYPRESS,
|
|
.maxcontacts = 10 },
|
|
{ .name = MT_CLS_EGALAX,
|
|
.quirks = MT_QUIRK_SLOT_IS_CONTACTID |
|
|
MT_QUIRK_VALID_IS_INRANGE |
|
|
MT_QUIRK_EGALAX_XYZ_FIXUP,
|
|
.maxcontacts = 2,
|
|
.sn_move = 4096,
|
|
.sn_pressure = 32,
|
|
},
|
|
|
|
{ }
|
|
};
|
|
|
|
static void mt_feature_mapping(struct hid_device *hdev,
|
|
struct hid_field *field, struct hid_usage *usage)
|
|
{
|
|
struct mt_device *td = hid_get_drvdata(hdev);
|
|
|
|
switch (usage->hid) {
|
|
case HID_DG_INPUTMODE:
|
|
td->inputmode = field->report->id;
|
|
break;
|
|
case HID_DG_CONTACTMAX:
|
|
td->maxcontacts = field->value[0];
|
|
if (td->mtclass->maxcontacts)
|
|
/* check if the maxcontacts is given by the class */
|
|
td->maxcontacts = td->mtclass->maxcontacts;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void set_abs(struct input_dev *input, unsigned int code,
|
|
struct hid_field *field, int snratio)
|
|
{
|
|
int fmin = field->logical_minimum;
|
|
int fmax = field->logical_maximum;
|
|
int fuzz = snratio ? (fmax - fmin) / snratio : 0;
|
|
input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
|
|
}
|
|
|
|
static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
|
|
struct hid_field *field, struct hid_usage *usage,
|
|
unsigned long **bit, int *max)
|
|
{
|
|
struct mt_device *td = hid_get_drvdata(hdev);
|
|
struct mt_class *cls = td->mtclass;
|
|
__s32 quirks = cls->quirks;
|
|
|
|
switch (usage->hid & HID_USAGE_PAGE) {
|
|
|
|
case HID_UP_GENDESK:
|
|
switch (usage->hid) {
|
|
case HID_GD_X:
|
|
if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
|
|
field->logical_maximum = 32760;
|
|
hid_map_usage(hi, usage, bit, max,
|
|
EV_ABS, ABS_MT_POSITION_X);
|
|
set_abs(hi->input, ABS_MT_POSITION_X, field,
|
|
cls->sn_move);
|
|
/* touchscreen emulation */
|
|
set_abs(hi->input, ABS_X, field, cls->sn_move);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_GD_Y:
|
|
if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
|
|
field->logical_maximum = 32760;
|
|
hid_map_usage(hi, usage, bit, max,
|
|
EV_ABS, ABS_MT_POSITION_Y);
|
|
set_abs(hi->input, ABS_MT_POSITION_Y, field,
|
|
cls->sn_move);
|
|
/* touchscreen emulation */
|
|
set_abs(hi->input, ABS_Y, field, cls->sn_move);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
|
|
case HID_UP_DIGITIZER:
|
|
switch (usage->hid) {
|
|
case HID_DG_INRANGE:
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_CONFIDENCE:
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_TIPSWITCH:
|
|
hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
|
|
input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_CONTACTID:
|
|
input_mt_init_slots(hi->input, td->maxcontacts);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_WIDTH:
|
|
hid_map_usage(hi, usage, bit, max,
|
|
EV_ABS, ABS_MT_TOUCH_MAJOR);
|
|
set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
|
|
cls->sn_width);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_HEIGHT:
|
|
hid_map_usage(hi, usage, bit, max,
|
|
EV_ABS, ABS_MT_TOUCH_MINOR);
|
|
set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
|
|
cls->sn_height);
|
|
input_set_abs_params(hi->input,
|
|
ABS_MT_ORIENTATION, 0, 1, 0, 0);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_TIPPRESSURE:
|
|
if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
|
|
field->logical_minimum = 0;
|
|
hid_map_usage(hi, usage, bit, max,
|
|
EV_ABS, ABS_MT_PRESSURE);
|
|
set_abs(hi->input, ABS_MT_PRESSURE, field,
|
|
cls->sn_pressure);
|
|
/* touchscreen emulation */
|
|
set_abs(hi->input, ABS_PRESSURE, field,
|
|
cls->sn_pressure);
|
|
td->last_slot_field = usage->hid;
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_CONTACTCOUNT:
|
|
td->last_field_index = field->index;
|
|
return 1;
|
|
case HID_DG_CONTACTMAX:
|
|
/* we don't set td->last_slot_field as contactcount and
|
|
* contact max are global to the report */
|
|
td->last_field_index = field->index;
|
|
return -1;
|
|
}
|
|
/* let hid-input decide for the others */
|
|
return 0;
|
|
|
|
case 0xff000000:
|
|
/* we do not want to map these: no input-oriented meaning */
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
|
|
struct hid_field *field, struct hid_usage *usage,
|
|
unsigned long **bit, int *max)
|
|
{
|
|
if (usage->type == EV_KEY || usage->type == EV_ABS)
|
|
set_bit(usage->type, hi->input->evbit);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int mt_compute_slot(struct mt_device *td)
|
|
{
|
|
__s32 quirks = td->mtclass->quirks;
|
|
|
|
if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
|
|
return td->curdata.contactid;
|
|
|
|
if (quirks & MT_QUIRK_CYPRESS)
|
|
return cypress_compute_slot(td);
|
|
|
|
if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
|
|
return td->num_received;
|
|
|
|
if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
|
|
return td->curdata.contactid - 1;
|
|
|
|
return find_slot_from_contactid(td);
|
|
}
|
|
|
|
/*
|
|
* this function is called when a whole contact has been processed,
|
|
* so that it can assign it to a slot and store the data there
|
|
*/
|
|
static void mt_complete_slot(struct mt_device *td)
|
|
{
|
|
td->curdata.seen_in_this_frame = true;
|
|
if (td->curvalid) {
|
|
int slotnum = mt_compute_slot(td);
|
|
|
|
if (slotnum >= 0 && slotnum < td->maxcontacts)
|
|
td->slots[slotnum] = td->curdata;
|
|
}
|
|
td->num_received++;
|
|
}
|
|
|
|
|
|
/*
|
|
* this function is called when a whole packet has been received and processed,
|
|
* so that it can decide what to send to the input layer.
|
|
*/
|
|
static void mt_emit_event(struct mt_device *td, struct input_dev *input)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < td->maxcontacts; ++i) {
|
|
struct mt_slot *s = &(td->slots[i]);
|
|
if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
|
|
!s->seen_in_this_frame) {
|
|
s->touch_state = false;
|
|
}
|
|
|
|
input_mt_slot(input, i);
|
|
input_mt_report_slot_state(input, MT_TOOL_FINGER,
|
|
s->touch_state);
|
|
if (s->touch_state) {
|
|
/* this finger is on the screen */
|
|
int wide = (s->w > s->h);
|
|
/* divided by two to match visual scale of touch */
|
|
int major = max(s->w, s->h) >> 1;
|
|
int minor = min(s->w, s->h) >> 1;
|
|
|
|
input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
|
|
input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
|
|
input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
|
|
input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
|
|
input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
|
|
input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
|
|
}
|
|
s->seen_in_this_frame = false;
|
|
|
|
}
|
|
|
|
input_mt_report_pointer_emulation(input, true);
|
|
input_sync(input);
|
|
td->num_received = 0;
|
|
}
|
|
|
|
|
|
|
|
static int mt_event(struct hid_device *hid, struct hid_field *field,
|
|
struct hid_usage *usage, __s32 value)
|
|
{
|
|
struct mt_device *td = hid_get_drvdata(hid);
|
|
__s32 quirks = td->mtclass->quirks;
|
|
|
|
if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
|
|
switch (usage->hid) {
|
|
case HID_DG_INRANGE:
|
|
if (quirks & MT_QUIRK_VALID_IS_INRANGE)
|
|
td->curvalid = value;
|
|
break;
|
|
case HID_DG_TIPSWITCH:
|
|
if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
|
|
td->curvalid = value;
|
|
td->curdata.touch_state = value;
|
|
break;
|
|
case HID_DG_CONFIDENCE:
|
|
if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
|
|
td->curvalid = value;
|
|
break;
|
|
case HID_DG_CONTACTID:
|
|
td->curdata.contactid = value;
|
|
break;
|
|
case HID_DG_TIPPRESSURE:
|
|
td->curdata.p = value;
|
|
break;
|
|
case HID_GD_X:
|
|
td->curdata.x = value;
|
|
break;
|
|
case HID_GD_Y:
|
|
td->curdata.y = value;
|
|
break;
|
|
case HID_DG_WIDTH:
|
|
td->curdata.w = value;
|
|
break;
|
|
case HID_DG_HEIGHT:
|
|
td->curdata.h = value;
|
|
break;
|
|
case HID_DG_CONTACTCOUNT:
|
|
/*
|
|
* Includes multi-packet support where subsequent
|
|
* packets are sent with zero contactcount.
|
|
*/
|
|
if (value)
|
|
td->num_expected = value;
|
|
break;
|
|
|
|
default:
|
|
/* fallback to the generic hidinput handling */
|
|
return 0;
|
|
}
|
|
|
|
if (usage->hid == td->last_slot_field) {
|
|
mt_complete_slot(td);
|
|
}
|
|
|
|
if (field->index == td->last_field_index
|
|
&& td->num_received >= td->num_expected)
|
|
mt_emit_event(td, field->hidinput->input);
|
|
|
|
}
|
|
|
|
/* we have handled the hidinput part, now remains hiddev */
|
|
if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
|
|
hid->hiddev_hid_event(hid, field, usage, value);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void mt_set_input_mode(struct hid_device *hdev)
|
|
{
|
|
struct mt_device *td = hid_get_drvdata(hdev);
|
|
struct hid_report *r;
|
|
struct hid_report_enum *re;
|
|
|
|
if (td->inputmode < 0)
|
|
return;
|
|
|
|
re = &(hdev->report_enum[HID_FEATURE_REPORT]);
|
|
r = re->report_id_hash[td->inputmode];
|
|
if (r) {
|
|
r->field[0]->value[0] = 0x02;
|
|
usbhid_submit_report(hdev, r, USB_DIR_OUT);
|
|
}
|
|
}
|
|
|
|
static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
|
{
|
|
int ret, i;
|
|
struct mt_device *td;
|
|
struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
|
|
|
|
for (i = 0; mt_classes[i].name ; i++) {
|
|
if (id->driver_data == mt_classes[i].name) {
|
|
mtclass = &(mt_classes[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* This allows the driver to correctly support devices
|
|
* that emit events over several HID messages.
|
|
*/
|
|
hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
|
|
|
|
td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
|
|
if (!td) {
|
|
dev_err(&hdev->dev, "cannot allocate multitouch data\n");
|
|
return -ENOMEM;
|
|
}
|
|
td->mtclass = mtclass;
|
|
td->inputmode = -1;
|
|
hid_set_drvdata(hdev, td);
|
|
|
|
ret = hid_parse(hdev);
|
|
if (ret != 0)
|
|
goto fail;
|
|
|
|
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
|
|
if (ret)
|
|
goto fail;
|
|
|
|
if (!td->maxcontacts)
|
|
td->maxcontacts = MT_DEFAULT_MAXCONTACT;
|
|
|
|
td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
|
|
GFP_KERNEL);
|
|
if (!td->slots) {
|
|
dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
|
|
hid_hw_stop(hdev);
|
|
ret = -ENOMEM;
|
|
goto fail;
|
|
}
|
|
|
|
mt_set_input_mode(hdev);
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
kfree(td);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int mt_reset_resume(struct hid_device *hdev)
|
|
{
|
|
mt_set_input_mode(hdev);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static void mt_remove(struct hid_device *hdev)
|
|
{
|
|
struct mt_device *td = hid_get_drvdata(hdev);
|
|
hid_hw_stop(hdev);
|
|
kfree(td->slots);
|
|
kfree(td);
|
|
hid_set_drvdata(hdev, NULL);
|
|
}
|
|
|
|
static const struct hid_device_id mt_devices[] = {
|
|
|
|
/* 3M panels */
|
|
{ .driver_data = MT_CLS_3M,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_3M,
|
|
USB_DEVICE_ID_3M1968) },
|
|
{ .driver_data = MT_CLS_3M,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_3M,
|
|
USB_DEVICE_ID_3M2256) },
|
|
|
|
/* ActionStar panels */
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
|
|
USB_DEVICE_ID_ACTIONSTAR_1011) },
|
|
|
|
/* Cando panels */
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
|
|
USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
|
|
USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
|
|
USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
|
|
USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
|
|
|
|
/* CVTouch panels */
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
|
|
USB_DEVICE_ID_CVTOUCH_SCREEN) },
|
|
|
|
/* Cypress panel */
|
|
{ .driver_data = MT_CLS_CYPRESS,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
|
|
USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
|
|
|
|
/* eGalax devices (resistive) */
|
|
{ .driver_data = MT_CLS_EGALAX,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
|
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
|
|
{ .driver_data = MT_CLS_EGALAX,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
|
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
|
|
|
|
/* eGalax devices (capacitive) */
|
|
{ .driver_data = MT_CLS_EGALAX,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
|
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
|
|
{ .driver_data = MT_CLS_EGALAX,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
|
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
|
|
{ .driver_data = MT_CLS_EGALAX,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
|
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
|
|
|
|
/* Elo TouchSystems IntelliTouch Plus panel */
|
|
{ .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_ELO,
|
|
USB_DEVICE_ID_ELO_TS2515) },
|
|
|
|
/* GeneralTouch panel */
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
|
|
USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
|
|
|
|
/* GoodTouch panels */
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
|
|
USB_DEVICE_ID_GOODTOUCH_000f) },
|
|
|
|
/* Ilitek dual touch panel */
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_ILITEK,
|
|
USB_DEVICE_ID_ILITEK_MULTITOUCH) },
|
|
|
|
/* IRTOUCH panels */
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
|
|
USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
|
|
|
|
/* Lumio panels */
|
|
{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
|
|
USB_DEVICE_ID_CRYSTALTOUCH) },
|
|
|
|
/* MosArt panels */
|
|
{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
|
|
USB_DEVICE_ID_ASUS_T91MT)},
|
|
{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
|
|
USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
|
|
{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_TURBOX,
|
|
USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
|
|
|
|
/* PenMount panels */
|
|
{ .driver_data = MT_CLS_CONFIDENCE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
|
|
USB_DEVICE_ID_PENMOUNT_PCI) },
|
|
|
|
/* PixCir-based panels */
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
|
|
USB_DEVICE_ID_HANVON_MULTITOUCH) },
|
|
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
|
|
USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
|
|
|
|
/* Stantum panels */
|
|
{ .driver_data = MT_CLS_CONFIDENCE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
|
|
USB_DEVICE_ID_MTP)},
|
|
{ .driver_data = MT_CLS_CONFIDENCE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
|
|
USB_DEVICE_ID_MTP_STM)},
|
|
{ .driver_data = MT_CLS_CONFIDENCE,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
|
|
USB_DEVICE_ID_MTP_SITRONIX)},
|
|
|
|
/* Touch International panels */
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
|
|
USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
|
|
|
|
/* Unitec panels */
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
|
|
USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
|
|
{ .driver_data = MT_CLS_DEFAULT,
|
|
HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
|
|
USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
|
|
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(hid, mt_devices);
|
|
|
|
static const struct hid_usage_id mt_grabbed_usages[] = {
|
|
{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
|
|
{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
|
|
};
|
|
|
|
static struct hid_driver mt_driver = {
|
|
.name = "hid-multitouch",
|
|
.id_table = mt_devices,
|
|
.probe = mt_probe,
|
|
.remove = mt_remove,
|
|
.input_mapping = mt_input_mapping,
|
|
.input_mapped = mt_input_mapped,
|
|
.feature_mapping = mt_feature_mapping,
|
|
.usage_table = mt_grabbed_usages,
|
|
.event = mt_event,
|
|
#ifdef CONFIG_PM
|
|
.reset_resume = mt_reset_resume,
|
|
#endif
|
|
};
|
|
|
|
static int __init mt_init(void)
|
|
{
|
|
return hid_register_driver(&mt_driver);
|
|
}
|
|
|
|
static void __exit mt_exit(void)
|
|
{
|
|
hid_unregister_driver(&mt_driver);
|
|
}
|
|
|
|
module_init(mt_init);
|
|
module_exit(mt_exit);
|