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@xxxxxxxxx> Signed-off-by: Benjamin Tissoires <benjamin.tissoires@xxxxxxxxxx> --- no changes in v4 no changes in v3 changes in v2: - changed the url of hid-tools --- drivers/hid/hid-multitouch.c | 380 ++++++++++++++++++++++++++----------------- 1 file changed, 230 insertions(+), 150 deletions(-) diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 91624a2240ca..cd207e99d26a 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -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) { -- 2.14.3 -- To unsubscribe from this list: send the line "unsubscribe linux-input" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
