Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-15 00:21:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

HID: core: split data fetching from processing in hid_input_field()

Browse Source 
This is a preparatory patch for being able to process the usages
out of order. We split the retrieval of the data in a separate function
and also split out the processing of the usages depending if the field
is an array or a variable.

No functional changes from this patch.

Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <ping.cheng@wacom.com>
Acked-by: Peter Hutterer <peter.hutterer@who-t.net>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
Benjamin Tissoires 2022-02-03 15:32:17 +01:00 committed by Jiri Kosina
parent 74acc277b6
commit b79c1abae5
2 changed files with 80 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
drivers/hid/hid-core.c
View File

@ -1544,13 +1544,12 @@ static inline int hid_array_value_is_valid(struct hid_field *field,
}
/*
* Analyse a received field, and fetch the data from it. The field
* content is stored for next report processing (we do differential
* reporting to the layer).
* Fetch the field from the data. The field content is stored for next
* report processing (we do differential reporting to the layer).
*/
static void hid_input_field(struct hid_device *hid, struct hid_field *field,
__u8 *data, int interrupt)
static void hid_input_fetch_field(struct hid_device *hid,
struct hid_field *field,
__u8 *data)
{
unsigned n;
unsigned count = field->report_count;
@ -1561,6 +1560,7 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field,
value = field->new_value;
memset(value, 0, count * sizeof(__s32));
field->ignored = false;
for (n = 0; n < count; n++) {
@ -1572,21 +1572,56 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field,
/* Ignore report if ErrorRollOver */
if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
hid_array_value_is_valid(field, value[n]) &&
field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1) {
field->ignored = true;
return;
}
}
}
/*
* Process a received variable field.
*/
static void hid_input_var_field(struct hid_device *hid,
struct hid_field *field,
int interrupt)
{
unsigned int count = field->report_count;
__s32 *value = field->new_value;
unsigned int n;
for (n = 0; n < count; n++)
hid_process_event(hid,
field,
&field->usage[n],
value[n],
interrupt);
memcpy(field->value, value, count * sizeof(__s32));
}
/*
* Process a received array field. The field content is stored for
* next report processing (we do differential reporting to the layer).
*/
static void hid_input_array_field(struct hid_device *hid,
struct hid_field *field,
int interrupt)
{
unsigned int n;
unsigned int count = field->report_count;
__s32 min = field->logical_minimum;
__s32 *value;
value = field->new_value;
/* ErrorRollOver */
if (field->ignored)
return;
for (n = 0; n < count; n++) {
if (HID_MAIN_ITEM_VARIABLE & field->flags) {
hid_process_event(hid,
field,
&field->usage[n],
value[n],
interrupt);
continue;
}
if (hid_array_value_is_valid(field, field->value[n]) &&
search(value, field->value[n], count))
hid_process_event(hid,
@ -1607,6 +1642,31 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field,
memcpy(field->value, value, count * sizeof(__s32));
}
/*
* Analyse a received report, and fetch the data from it. The field
* content is stored for next report processing (we do differential
* reporting to the layer).
*/
static void hid_process_report(struct hid_device *hid,
struct hid_report *report,
__u8 *data,
int interrupt)
{
unsigned int a;
struct hid_field *field;
for (a = 0; a < report->maxfield; a++) {
field = report->field[a];
hid_input_fetch_field(hid, field, data);
if (field->flags & HID_MAIN_ITEM_VARIABLE)
hid_input_var_field(hid, field, interrupt);
else
hid_input_array_field(hid, field, interrupt);
}
}
/*
* Output the field into the report.
*/
@ -1768,7 +1828,6 @@ int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
struct hid_report_enum *report_enum = hid->report_enum + type;
struct hid_report *report;
struct hid_driver *hdrv;
unsigned int a;
u32 rsize, csize = size;
u8 *cdata = data;
int ret = 0;
@ -1804,8 +1863,7 @@ int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
}
if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
for (a = 0; a < report->maxfield; a++)
hid_input_field(hid, report->field[a], cdata, interrupt);
hid_process_report(hid, report, cdata, interrupt);
hdrv = hid->driver;
if (hdrv && hdrv->report)
hdrv->report(hid, report);

3
include/linux/hid.h
View File

@ -342,7 +342,7 @@ struct hid_item {
* HID device quirks.
*/
/*
/*
* Increase this if you need to configure more HID quirks at module load time
*/
#define MAX_USBHID_BOOT_QUIRKS 4
@ -483,6 +483,7 @@ struct hid_field {
__s32 physical_maximum;
__s32 unit_exponent;
unsigned unit;
bool ignored; /* this field is ignored in this event */
struct hid_report *report; /* associated report */
unsigned index; /* index into report->field[] */
/* hidinput data */