hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

HID: multitouch: Store per collection multitouch data 

Currently, hid-multitouch can only handle one multitouch collection at
a time. This is an issue for the Dell Canvas, as the Totem (a dial tool)
is also using a multitouch-like collection.

Factor out the multitouch collection data in their own struct.

Acked-by: Peter Hutterer <peter.hutterer@who-t.net>
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
Benjamin Tissoires 2018-07-13 16:13:45 +02:00 committed by Jiri Kosina
parent cf6d15d7b1
commit f146d1c4d7
1 changed files with 230 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

380
drivers/hid/hid-multitouch.c
View File

@ -28,14 +28,11 @@
*/
/*
* This driver is regularly tested thanks to the tool hid-test[1].
* This tool relies on hid-replay[2] and a database of hid devices[3].
* This driver is regularly tested thanks to the test suite in hid-tools[1].
* Please run these regression tests before patching this module so that
* your patch won't break existing known devices.
*
* [1] https://github.com/bentiss/hid-test
* [2] https://github.com/bentiss/hid-replay
* [3] https://github.com/bentiss/hid-devices
* [1] https://gitlab.freedesktop.org/libevdev/hid-tools
*/
#include <linux/device.h>
@ -99,6 +96,37 @@ struct mt_slot {
bool has_azimuth; /* the contact reports azimuth */
};
struct mt_application {
struct list_head list;
unsigned int application;
struct mt_slot curdata; /* placeholder of incoming data */
int cc_index; /* contact count field index in the report */
int cc_value_index; /* contact count value index in the field */
int scantime_index; /* scantime field index in the report */
int scantime_val_index; /* scantime value index in the field */
unsigned int last_slot_field; /* the last field of a slot */
bool curvalid; /* is the current contact valid? */
int left_button_state; /* left button state */
unsigned int mt_flags; /* flags to pass to input-mt */
__u8 num_received; /* how many contacts we received */
__u8 num_expected; /* expected last contact index */
__u8 buttons_count; /* number of physical buttons per touchpad */
__u8 touches_by_report; /* how many touches are present in one report:
* 1 means we should use a serial protocol
* > 1 means hybrid (multitouch) protocol
*/
__s32 dev_time; /* the scan time provided by the device */
unsigned long jiffies; /* the frame's jiffies */
int timestamp; /* the timestamp to be sent */
int prev_scantime; /* scantime reported previously */
bool have_contact_count;
};
struct mt_class {
__s32 name; /* MT_CLS */
__s32 quirks;
@ -117,40 +145,24 @@ struct mt_fields {
};
struct mt_device {
struct mt_slot curdata; /* placeholder of incoming data */
struct mt_class mtclass; /* our mt device class */
struct timer_list release_timer; /* to release sticky fingers */
struct hid_device *hdev; /* hid_device we're attached to */
struct mt_fields *fields; /* temporary placeholder for storing the
multitouch fields */
unsigned long mt_io_flags; /* mt flags (MT_IO_FLAGS_*) */
int cc_index; /* contact count field index in the report */
int cc_value_index; /* contact count value index in the field */
int scantime_index; /* scantime field index in the report */
int scantime_val_index; /* scantime value index in the field */
int prev_scantime; /* scantime reported in the previous packet */
int left_button_state; /* left button state */
unsigned last_slot_field; /* the last field of a slot */
unsigned mt_report_id; /* the report ID of the multitouch device */
__u8 inputmode_value; /* InputMode HID feature value */
__u8 num_received; /* how many contacts we received */
__u8 num_expected; /* expected last contact index */
__u8 maxcontacts;
__u8 touches_by_report; /* how many touches are present in one report:
* 1 means we should use a serial protocol
* > 1 means hybrid (multitouch) protocol */
__u8 buttons_count; /* number of physical buttons per touchpad */
bool is_buttonpad; /* is this device a button pad? */
bool serial_maybe; /* need to check for serial protocol */
bool curvalid; /* is the current contact valid? */
unsigned mt_flags; /* flags to pass to input-mt */
__s32 dev_time; /* the scan time provided by the device */
unsigned long jiffies; /* the frame's jiffies */
int timestamp; /* the timestamp to be sent */
struct list_head applications;
};
static void mt_post_parse_default_settings(struct mt_device *td);
static void mt_post_parse(struct mt_device *td);
static void mt_post_parse_default_settings(struct mt_device *td,
struct mt_application *app);
static void mt_post_parse(struct mt_device *td, struct mt_application *app);
/* classes of device behavior */
#define MT_CLS_DEFAULT 0x0001
@ -203,10 +215,10 @@ static void mt_post_parse(struct mt_device *td);
* to a valid contact that was just read.
*/
static int cypress_compute_slot(struct mt_device *td)
static int cypress_compute_slot(struct mt_application *app)
{
if (td->curdata.contactid != 0 || td->num_received == 0)
return td->curdata.contactid;
if (app->curdata.contactid != 0 || app->num_received == 0)
return app->curdata.contactid;
else
return -1;
}
@ -353,15 +365,22 @@ static ssize_t mt_set_quirks(struct device *dev,
{
struct hid_device *hdev = to_hid_device(dev);
struct mt_device *td = hid_get_drvdata(hdev);
struct mt_application *application;
unsigned long val;
bool confidence_found = false;
if (kstrtoul(buf, 0, &val))
return -EINVAL;
td->mtclass.quirks = val;
if (td->cc_index < 0)
list_for_each_entry(application, &td->applications, list) {
if (application->have_contact_count)
confidence_found = true;
}
if (!confidence_found)
td->mtclass.quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
return count;
@ -457,6 +476,55 @@ static void set_abs(struct input_dev *input, unsigned int code,
input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
}
static struct mt_application *mt_allocate_application(struct mt_device *td,
unsigned int application)
{
struct mt_application *mt_application;
mt_application = devm_kzalloc(&td->hdev->dev, sizeof(*mt_application),
GFP_KERNEL);
if (!mt_application)
return NULL;
mt_application->application = application;
if (application == HID_DG_TOUCHSCREEN)
mt_application->mt_flags |= INPUT_MT_DIRECT;
/*
* Model touchscreens providing buttons as touchpads.
*/
if (application == HID_DG_TOUCHPAD) {
mt_application->mt_flags |= INPUT_MT_POINTER;
td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
}
mt_application->cc_index = -1;
mt_application->scantime_index = -1;
list_add_tail(&mt_application->list, &td->applications);
return mt_application;
}
static struct mt_application *mt_find_application(struct mt_device *td,
unsigned int application)
{
struct mt_application *tmp, *mt_application = NULL;
list_for_each_entry(tmp, &td->applications, list) {
if (application == tmp->application) {
mt_application = tmp;
break;
}
}
if (!mt_application)
mt_application = mt_allocate_application(td, application);
return mt_application;
}
static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
struct hid_input *hi)
{
@ -470,28 +538,24 @@ static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
struct hid_field *field, struct hid_usage *usage,
unsigned long **bit, int *max)
unsigned long **bit, int *max, struct mt_application *app)
{
struct mt_device *td = hid_get_drvdata(hdev);
struct mt_class *cls = &td->mtclass;
int code;
struct hid_usage *prev_usage = NULL;
if (field->application == HID_DG_TOUCHSCREEN)
td->mt_flags |= INPUT_MT_DIRECT;
/*
* Model touchscreens providing buttons as touchpads.
*/
if (field->application == HID_DG_TOUCHPAD ||
(usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
td->mt_flags |= INPUT_MT_POINTER;
if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
app->mt_flags |= INPUT_MT_POINTER;
td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
}
/* count the buttons on touchpads */
if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
td->buttons_count++;
app->buttons_count++;
if (usage->usage_index)
prev_usage = &field->usage[usage->usage_index - 1];
@ -501,33 +565,23 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
case HID_UP_GENDESK:
switch (usage->hid) {
case HID_GD_X:
if (prev_usage && (prev_usage->hid == usage->hid)) {
hid_map_usage(hi, usage, bit, max,
EV_ABS, ABS_MT_TOOL_X);
set_abs(hi->input, ABS_MT_TOOL_X, field,
cls->sn_move);
} else {
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);
}
if (prev_usage && (prev_usage->hid == usage->hid))
code = ABS_MT_TOOL_X;
else
code = ABS_MT_POSITION_X;
hid_map_usage(hi, usage, bit, max, EV_ABS, code);
set_abs(hi->input, code, field, cls->sn_move);
mt_store_field(usage, td, hi);
return 1;
case HID_GD_Y:
if (prev_usage && (prev_usage->hid == usage->hid)) {
hid_map_usage(hi, usage, bit, max,
EV_ABS, ABS_MT_TOOL_Y);
set_abs(hi->input, ABS_MT_TOOL_Y, field,
cls->sn_move);
} else {
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);
}
if (prev_usage && (prev_usage->hid == usage->hid))
code = ABS_MT_TOOL_Y;
else
code = ABS_MT_POSITION_Y;
hid_map_usage(hi, usage, bit, max, EV_ABS, code);
set_abs(hi->input, code, field, cls->sn_move);
mt_store_field(usage, td, hi);
return 1;
}
@ -558,7 +612,7 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
return 1;
case HID_DG_CONTACTID:
mt_store_field(usage, td, hi);
td->touches_by_report++;
app->touches_by_report++;
td->mt_report_id = field->report->id;
return 1;
case HID_DG_WIDTH:
@ -602,20 +656,16 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
if (field->index >= field->report->maxfield ||
usage->usage_index >= field->report_count)
return 1;
td->scantime_index = field->index;
td->scantime_val_index = usage->usage_index;
/*
* We don't set td->last_slot_field as scan time is
* global to the report.
*/
app->scantime_index = field->index;
app->scantime_val_index = usage->usage_index;
return 1;
case HID_DG_CONTACTCOUNT:
/* Ignore if indexes are out of bounds. */
if (field->index >= field->report->maxfield ||
usage->usage_index >= field->report_count)
return 1;
td->cc_index = field->index;
td->cc_value_index = usage->usage_index;
app->cc_index = field->index;
app->cc_value_index = usage->usage_index;
return 1;
case HID_DG_AZIMUTH:
hid_map_usage(hi, usage, bit, max,
@ -666,39 +716,41 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
return 0;
}
static int mt_compute_slot(struct mt_device *td, struct input_dev *input)
static int mt_compute_slot(struct mt_device *td, struct mt_application *app,
struct input_dev *input)
{
__s32 quirks = td->mtclass.quirks;
if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
return td->curdata.contactid;
return app->curdata.contactid;
if (quirks & MT_QUIRK_CYPRESS)
return cypress_compute_slot(td);
return cypress_compute_slot(app);
if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
return td->num_received;
return app->num_received;
if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
return td->curdata.contactid - 1;
return app->curdata.contactid - 1;
return input_mt_get_slot_by_key(input, td->curdata.contactid);
return input_mt_get_slot_by_key(input, app->curdata.contactid);
}
/*
* 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, struct input_dev *input)
static void mt_complete_slot(struct mt_device *td, struct mt_application *app,
struct input_dev *input)
{
if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) &&
td->num_received >= td->num_expected)
app->num_received >= app->num_expected)
return;
if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
if (app->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
int active;
int slotnum = mt_compute_slot(td, input);
struct mt_slot *s = &td->curdata;
int slotnum = mt_compute_slot(td, app, input);
struct mt_slot *s = &app->curdata;
struct input_mt *mt = input->mt;
if (slotnum < 0 || slotnum >= td->maxcontacts)
@ -753,23 +805,25 @@ static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
}
}
td->num_received++;
app->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_sync_frame(struct mt_device *td, struct input_dev *input)
static void mt_sync_frame(struct mt_device *td, struct mt_application *app,
struct input_dev *input)
{
if (td->mtclass.quirks & MT_QUIRK_WIN8_PTP_BUTTONS)
input_event(input, EV_KEY, BTN_LEFT, td->left_button_state);
input_event(input, EV_KEY, BTN_LEFT, app->left_button_state);
input_mt_sync_frame(input);
input_event(input, EV_MSC, MSC_TIMESTAMP, td->timestamp);
input_event(input, EV_MSC, MSC_TIMESTAMP, app->timestamp);
input_sync(input);
td->num_received = 0;
td->left_button_state = 0;
app->num_received = 0;
app->left_button_state = 0;
if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
else
@ -777,14 +831,13 @@ static void mt_sync_frame(struct mt_device *td, struct input_dev *input)
clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
}
static int mt_compute_timestamp(struct mt_device *td, struct hid_field *field,
__s32 value)
static int mt_compute_timestamp(struct mt_application *app,
struct hid_field *field, __s32 value)
{
long delta = value - td->dev_time;
unsigned long jdelta = jiffies_to_usecs(jiffies - td->jiffies);
long delta = value - app->prev_scantime;
unsigned long jdelta = jiffies_to_usecs(jiffies - app->jiffies);
td->jiffies = jiffies;
td->dev_time = value;
app->jiffies = jiffies;
if (delta < 0)
delta += field->logical_maximum;
@ -796,7 +849,7 @@ static int mt_compute_timestamp(struct mt_device *td, struct hid_field *field,
/* No data received for a while, resync the timestamp. */
return 0;
else
return td->timestamp + delta;
return app->timestamp + delta;
}
static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
@ -811,7 +864,7 @@ static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
struct hid_usage *usage, __s32 value,
bool first_packet)
struct mt_application *app, bool first_packet)
{
struct mt_device *td = hid_get_drvdata(hid);
__s32 quirks = td->mtclass.quirks;
@ -821,47 +874,48 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
switch (usage->hid) {
case HID_DG_INRANGE:
if (quirks & MT_QUIRK_VALID_IS_INRANGE)
td->curvalid = value;
app->curvalid = value;
if (quirks & MT_QUIRK_HOVERING)
td->curdata.inrange_state = value;
app->curdata.inrange_state = value;
break;
case HID_DG_TIPSWITCH:
if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
td->curvalid = value;
td->curdata.touch_state = value;
app->curvalid = value;
app->curdata.touch_state = value;
break;
case HID_DG_CONFIDENCE:
if (quirks & MT_QUIRK_CONFIDENCE)
td->curdata.confidence_state = value;
app->curdata.confidence_state = value;
if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
td->curvalid = value;
app->curvalid = value;
break;
case HID_DG_CONTACTID:
td->curdata.contactid = value;
app->curdata.contactid = value;
break;
case HID_DG_TIPPRESSURE:
td->curdata.p = value;
app->curdata.p = value;
break;
case HID_GD_X:
if (usage->code == ABS_MT_TOOL_X)
td->curdata.cx = value;
app->curdata.cx = value;
else
td->curdata.x = value;
app->curdata.x = value;
break;
case HID_GD_Y:
if (usage->code == ABS_MT_TOOL_Y)
td->curdata.cy = value;
app->curdata.cy = value;
else
td->curdata.y = value;
app->curdata.y = value;
break;
case HID_DG_WIDTH:
td->curdata.w = value;
app->curdata.w = value;
break;
case HID_DG_HEIGHT:
td->curdata.h = value;
app->curdata.h = value;
break;
case HID_DG_SCANTIME:
td->timestamp = mt_compute_timestamp(td, field, value);
app->timestamp = mt_compute_timestamp(app, field,
value);
break;
case HID_DG_CONTACTCOUNT:
break;
@ -878,8 +932,8 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
*/
if (value > field->logical_maximum / 2)
value -= field->logical_maximum;
td->curdata.a = -value;
td->curdata.has_azimuth = true;
app->curdata.a = -value;
app->curdata.has_azimuth = true;
break;
case HID_DG_TOUCH:
/* do nothing */
@ -904,7 +958,7 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
*/
if ((quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
usage->type == EV_KEY && usage->code == BTN_LEFT) {
td->left_button_state |= value;
app->left_button_state |= value;
return;
}
@ -916,8 +970,9 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
if (usage->usage_index + 1 == field->report_count) {
/* we only take into account the last report. */
if (usage->hid == td->last_slot_field)
mt_complete_slot(td, field->hidinput->input);
if (usage->hid == app->last_slot_field)
mt_complete_slot(td, app,
field->hidinput->input);
}
}
@ -926,26 +981,34 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
{
struct mt_device *td = hid_get_drvdata(hid);
struct mt_application *app;
struct hid_field *field;
bool first_packet;
unsigned count;
int r, n, scantime = 0;
int r, n;
int scantime = 0;
int contact_count = -1;
/* sticky fingers release in progress, abort */
if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
return;
app = mt_find_application(td, report->application);
if (!app)
return;
/*
* Includes multi-packet support where subsequent
* packets are sent with zero contactcount.
*/
if (td->scantime_index >= 0) {
field = report->field[td->scantime_index];
scantime = field->value[td->scantime_val_index];
if (app->scantime_index >= 0) {
field = report->field[app->scantime_index];
scantime = field->value[app->scantime_val_index];
}
if (td->cc_index >= 0) {
struct hid_field *field = report->field[td->cc_index];
int value = field->value[td->cc_value_index];
if (app->cc_index >= 0) {
field = report->field[app->cc_index];
contact_count = field->value[app->cc_value_index];
/*
* For Win8 PTPs the first packet (td->num_received == 0) may
@ -955,15 +1018,16 @@ static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
* timestamp has changed.
*/
if ((td->mtclass.quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
td->num_received == 0 && td->prev_scantime != scantime)
td->num_expected = value;
app->num_received == 0 &&
app->prev_scantime != scantime)
app->num_expected = contact_count;
/* A non 0 contact count always indicates a first packet */
else if (value)
td->num_expected = value;
else if (contact_count)
app->num_expected = contact_count;
}
td->prev_scantime = scantime;
app->prev_scantime = scantime;
first_packet = td->num_received == 0;
first_packet = app->num_received == 0;
for (r = 0; r < report->maxfield; r++) {
field = report->field[r];
count = field->report_count;
@ -973,11 +1037,11 @@ static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
for (n = 0; n < count; n++)
mt_process_mt_event(hid, field, &field->usage[n],
field->value[n], first_packet);
field->value[n], app, first_packet);
}
if (td->num_received >= td->num_expected)
mt_sync_frame(td, report->field[0]->hidinput->input);
if (app->num_received >= app->num_expected)
mt_sync_frame(td, app, report->field[0]->hidinput->input);
/*
* Windows 8 specs says 2 things:
@ -1009,7 +1073,8 @@ static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
}
static int mt_touch_input_configured(struct hid_device *hdev,
struct hid_input *hi)
struct hid_input *hi,
struct mt_application *app)
{
struct mt_device *td = hid_get_drvdata(hdev);
struct mt_class *cls = &td->mtclass;
@ -1019,28 +1084,29 @@ static int mt_touch_input_configured(struct hid_device *hdev,
if (!td->maxcontacts)
td->maxcontacts = MT_DEFAULT_MAXCONTACT;
mt_post_parse(td);
mt_post_parse(td, app);
if (td->serial_maybe)
mt_post_parse_default_settings(td);
mt_post_parse_default_settings(td, app);
if (cls->is_indirect)
td->mt_flags |= INPUT_MT_POINTER;
app->mt_flags |= INPUT_MT_POINTER;
if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
td->mt_flags |= INPUT_MT_DROP_UNUSED;
app->mt_flags |= INPUT_MT_DROP_UNUSED;
/* check for clickpads */
if ((td->mt_flags & INPUT_MT_POINTER) && (td->buttons_count == 1))
if ((app->mt_flags & INPUT_MT_POINTER) &&
(app->buttons_count == 1))
td->is_buttonpad = true;
if (td->is_buttonpad)
__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
ret = input_mt_init_slots(input, td->maxcontacts, td->mt_flags);
ret = input_mt_init_slots(input, td->maxcontacts, app->mt_flags);
if (ret)
return ret;
td->mt_flags = 0;
app->mt_flags = 0;
return 0;
}
@ -1051,6 +1117,7 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
unsigned long **bit, int *max)
{
struct mt_device *td = hid_get_drvdata(hdev);
struct mt_application *application;
/*
* If mtclass.export_all_inputs is not set, only map fields from
@ -1093,6 +1160,8 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
return 1;
}
application = mt_find_application(td, field->application);
/*
* some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
* for the stylus.
@ -1109,7 +1178,8 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
if (field->application == HID_DG_TOUCHSCREEN ||
field->application == HID_DG_TOUCHPAD)
return mt_touch_input_mapping(hdev, hi, field, usage, bit, max);
return mt_touch_input_mapping(hdev, hi, field, usage, bit, max,
application);
/* let hid-core decide for the others */
return 0;
@ -1259,12 +1329,13 @@ static void mt_set_modes(struct hid_device *hdev, enum latency_mode latency,
}
}
static void mt_post_parse_default_settings(struct mt_device *td)
static void mt_post_parse_default_settings(struct mt_device *td,
struct mt_application *app)
{
__s32 quirks = td->mtclass.quirks;
/* unknown serial device needs special quirks */
if (td->touches_by_report == 1) {
if (app->touches_by_report == 1) {
quirks |= MT_QUIRK_ALWAYS_VALID;
quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
@ -1275,17 +1346,19 @@ static void mt_post_parse_default_settings(struct mt_device *td)
td->mtclass.quirks = quirks;
}
static void mt_post_parse(struct mt_device *td)
static void mt_post_parse(struct mt_device *td, struct mt_application *app)
{
struct mt_fields *f = td->fields;
struct mt_class *cls = &td->mtclass;
if (td->touches_by_report > 0) {
int field_count_per_touch = f->length / td->touches_by_report;
td->last_slot_field = f->usages[field_count_per_touch - 1];
if (app->touches_by_report > 0) {
int field_count_per_touch;
field_count_per_touch = f->length / app->touches_by_report;
app->last_slot_field = f->usages[field_count_per_touch - 1];
}
if (td->cc_index < 0)
if (app->cc_index < 0)
cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
}
@ -1295,13 +1368,17 @@ static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
char *name;
const char *suffix = NULL;
unsigned int application = 0;
struct mt_application *mt_application = NULL;
struct hid_report *report;
int ret;
list_for_each_entry(report, &hi->reports, hidinput_list) {
application = report->application;
mt_application = mt_find_application(td, application);
if (report->id == td->mt_report_id) {
ret = mt_touch_input_configured(hdev, hi);
ret = mt_touch_input_configured(hdev, hi,
mt_application);
if (ret)
return ret;
}
@ -1390,6 +1467,7 @@ static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage)
static void mt_release_contacts(struct hid_device *hid)
{
struct hid_input *hidinput;
struct mt_application *application;
struct mt_device *td = hid_get_drvdata(hid);
list_for_each_entry(hidinput, &hid->inputs, list) {
@ -1409,7 +1487,9 @@ static void mt_release_contacts(struct hid_device *hid)
}
}
td->num_received = 0;
list_for_each_entry(application, &td->applications, list) {
application->num_received = 0;
}
}
static void mt_expired_timeout(struct timer_list *t)
@ -1449,11 +1529,11 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
td->hdev = hdev;
td->mtclass = *mtclass;
td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
td->cc_index = -1;
td->scantime_index = -1;
td->mt_report_id = -1;
hid_set_drvdata(hdev, td);
INIT_LIST_HEAD(&td->applications);
td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields),
GFP_KERNEL);
if (!td->fields) {