[Linuxwacom-devel] [PATCH input-wacom 1/5] backport: HID: wacom: generic: Don't return a value for wacom_wac_event

[Jason Gerecke]

From: Ping Cheng <***@gmail.com>

It is unnecessary to return a value since nothing is expecting a
value from it.

Signed-off-by: Ping Cheng <***@wacom.com>
Reviewed-By: Jason Gerecke <***@wacom.com>
Signed-off-by: Jiri Kosina <***@suse.cz>
[***@wacom.com: Imported into input-wacom repository (354a329)]
Signed-off-by: Jason Gerecke <***@wacom.com>
[***@wacom.com: Backported from input-wacom repository (e94e9ad)]
Signed-off-by: Jason Gerecke <***@wacom.com>
---
3.17/wacom.h | 2 +-
3.17/wacom_wac.c | 62 ++++++++++++++++++++++++--------------------------------
2 files changed, 28 insertions(+), 36 deletions(-)

diff --git a/3.17/wacom.h b/3.17/wacom.h
index 1e2c898..e9e0c16 100644
--- a/3.17/wacom.h
+++ b/3.17/wacom.h
@@ -212,7 +212,7 @@ int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
struct wacom_wac *wacom_wac);
void wacom_wac_usage_mapping(struct hid_device *hdev,
struct hid_field *field, struct hid_usage *usage);
-int wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
+void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
struct hid_usage *usage, __s32 value);
void wacom_wac_report(struct hid_device *hdev, struct hid_report *report);
void wacom_battery_work(struct work_struct *work);
diff --git a/3.17/wacom_wac.c b/3.17/wacom_wac.c
index 7e20236..7560dfa 100644
--- a/3.17/wacom_wac.c
+++ b/3.17/wacom_wac.c
@@ -1590,7 +1590,7 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
}
}

-static int wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
+static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
struct hid_usage *usage, __s32 value)
{
struct wacom *wacom = hid_get_drvdata(hdev);
@@ -1606,23 +1606,21 @@ static int wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
case WACOM_HID_WD_BATTERY_LEVEL:
wacom_wac->hid_data.battery_capacity = value;
wacom_wac->hid_data.bat_connected = 1;
- return 0;
+ break;

case WACOM_HID_WD_BATTERY_CHARGING:
wacom_wac->hid_data.bat_charging = value;
wacom_wac->hid_data.ps_connected = value;
wacom_wac->hid_data.bat_connected = 1;
- return 0;
+ break;

case WACOM_HID_WD_TOUCHRINGSTATUS:
- return 0;
+ break;

default:
input_event(input, usage->type, usage->code, value);
break;
}
-
- return 0;
}

static void wacom_wac_pad_pre_report(struct hid_device *hdev,
@@ -1739,7 +1737,7 @@ static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
}
}

-static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
+static void wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
struct hid_usage *usage, __s32 value)
{
struct wacom *wacom = hid_get_drvdata(hdev);
@@ -1761,25 +1759,25 @@ static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
wacom_wac->hid_data.inrange_state = value;
if (!(features->quirks & WACOM_QUIRK_SENSE))
wacom_wac->hid_data.sense_state = value;
- return 0;
+ return;
case HID_DG_BATTERYSTRENGTH:
wacom_wac->hid_data.battery_capacity = value;
wacom_wac->hid_data.bat_connected = 1;
break;
case HID_DG_INVERT:
wacom_wac->hid_data.invert_state = value;
- return 0;
+ return;
case HID_DG_ERASER:
case HID_DG_TIPSWITCH:
wacom_wac->hid_data.tipswitch |= value;
- return 0;
+ return;
case HID_DG_TOOLSERIALNUMBER:
wacom_wac->serial[0] = (wacom_wac->serial[0] & ~0xFFFFFFFFULL);
wacom_wac->serial[0] |= value;
- return 0;
+ return;
case WACOM_HID_WD_SENSE:
wacom_wac->hid_data.sense_state = value;
- return 0;
+ return;
case WACOM_HID_WD_SERIALHI:
wacom_wac->serial[0] = (wacom_wac->serial[0] & 0xFFFFFFFF);
wacom_wac->serial[0] |= ((__u64)value) << 32;
@@ -1791,7 +1789,7 @@ static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
if (value >> 20 == 1) {
wacom_wac->id[0] |= value & 0xFFFFF;
}
- return 0;
+ return;
case WACOM_HID_WD_TOOLTYPE:
/*
* Some devices (MobileStudio Pro, and possibly later
@@ -1801,50 +1799,48 @@ static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
* up over time :(
*/
wacom_wac->id[0] |= value;
- return 0;
+ return;
case WACOM_HID_WD_OFFSETLEFT:
if (features->offset_left && value != features->offset_left)
hid_warn(hdev, "%s: overriding exising left offset "
"%d -> %d\n", __func__, value,
features->offset_left);
features->offset_left = value;
- return 0;
+ return;
case WACOM_HID_WD_OFFSETRIGHT:
if (features->offset_right && value != features->offset_right)
hid_warn(hdev, "%s: overriding exising right offset "
"%d -> %d\n", __func__, value,
features->offset_right);
features->offset_right = value;
- return 0;
+ return;
case WACOM_HID_WD_OFFSETTOP:
if (features->offset_top && value != features->offset_top)
hid_warn(hdev, "%s: overriding exising top offset "
"%d -> %d\n", __func__, value,
features->offset_top);
features->offset_top = value;
- return 0;
+ return;
case WACOM_HID_WD_OFFSETBOTTOM:
if (features->offset_bottom && value != features->offset_bottom)
hid_warn(hdev, "%s: overriding exising bottom offset "
"%d -> %d\n", __func__, value,
features->offset_bottom);
features->offset_bottom = value;
- return 0;
+ return;
}

/* send pen events only when touch is up or forced out
* or touch arbitration is off
*/
if (!usage->type || delay_pen_events(wacom_wac))
- return 0;
+ return;

/* send pen events only when the pen is in/entering/leaving proximity */
if (!wacom_wac->hid_data.inrange_state && !wacom_wac->tool[0])
- return 0;
+ return;

input_event(input, usage->type, usage->code, value);
-
- return 0;
}

static void wacom_wac_pen_pre_report(struct hid_device *hdev,
@@ -1988,7 +1984,7 @@ static void wacom_wac_finger_slot(struct wacom_wac *wacom_wac,
}
}

-static int wacom_wac_finger_event(struct hid_device *hdev,
+static void wacom_wac_finger_event(struct hid_device *hdev,
struct hid_field *field, struct hid_usage *usage, __s32 value)
{
struct wacom *wacom = hid_get_drvdata(hdev);
@@ -2021,8 +2017,6 @@ static int wacom_wac_finger_event(struct hid_device *hdev,
if (equivalent_usage == wacom_wac->hid_data.last_slot_field)
wacom_wac_finger_slot(wacom_wac, wacom_wac->touch_input);
}
-
- return 0;
}

static void wacom_wac_finger_pre_report(struct hid_device *hdev,
@@ -2108,29 +2102,27 @@ void wacom_wac_usage_mapping(struct hid_device *hdev,
features->device_type |= WACOM_DEVICETYPE_DIRECT;

if (WACOM_PAD_FIELD(field))
- return wacom_wac_pad_usage_mapping(hdev, field, usage);
+ wacom_wac_pad_usage_mapping(hdev, field, usage);
else if (WACOM_PEN_FIELD(field))
- return wacom_wac_pen_usage_mapping(hdev, field, usage);
+ wacom_wac_pen_usage_mapping(hdev, field, usage);
else if (WACOM_FINGER_FIELD(field))
- return wacom_wac_finger_usage_mapping(hdev, field, usage);
+ wacom_wac_finger_usage_mapping(hdev, field, usage);
}

-int wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
+void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
struct hid_usage *usage, __s32 value)
{
struct wacom *wacom = hid_get_drvdata(hdev);

if (wacom->wacom_wac.features.type != HID_GENERIC)
- return 0;
+ return;

if (WACOM_PAD_FIELD(field))
- return wacom_wac_pad_event(hdev, field, usage, value);
+ wacom_wac_pad_event(hdev, field, usage, value);
else if (WACOM_PEN_FIELD(field))
- return wacom_wac_pen_event(hdev, field, usage, value);
+ wacom_wac_pen_event(hdev, field, usage, value);
else if (WACOM_FINGER_FIELD(field))
- return wacom_wac_finger_event(hdev, field, usage, value);
-
- return 0;
+ wacom_wac_finger_event(hdev, field, usage, value);
}

static void wacom_report_events(struct hid_device *hdev, struct hid_report *report)

[Jason Gerecke]

From: Ping Cheng <***@gmail.com>

Make sure everything reported from pad are registered

Signed-off-by: Ping Cheng <***@wacom.com>
Reviewed-By: Jason Gerecke <***@wacom.com>
Signed-off-by: Jiri Kosina <***@suse.cz>
[***@wacom.com: Imported into input-wacom repository (f3f24e7)]
Signed-off-by: Jason Gerecke <***@wacom.com>
[***@wacom.com: Backported from input-wacom repository (52f3133)]
Signed-off-by: Jason Gerecke <***@wacom.com>
---
3.17/wacom_wac.c | 9 +++++++++
1 file changed, 9 insertions(+)

diff --git a/3.17/wacom_wac.c b/3.17/wacom_wac.c
index d0acd1d..4e042b6 100644
--- a/3.17/wacom_wac.c
+++ b/3.17/wacom_wac.c
@@ -1546,14 +1546,17 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
case WACOM_HID_WD_ACCELEROMETER_X:
__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_ACCELEROMETER_Y:
__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_ACCELEROMETER_Z:
__set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_BUTTONHOME:
case WACOM_HID_WD_BUTTONUP:
@@ -1565,18 +1568,23 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
wacom_numbered_button_to_key(features->numbered_buttons),
0);
features->numbered_buttons++;
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_TOUCHONOFF:
wacom_map_usage(input, usage, field, EV_SW, SW_MUTE_DEVICE, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_TOUCHSTRIP:
wacom_map_usage(input, usage, field, EV_ABS, ABS_RX, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_TOUCHSTRIP2:
wacom_map_usage(input, usage, field, EV_ABS, ABS_RY, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
case WACOM_HID_WD_TOUCHRING:
wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
}

@@ -1586,6 +1594,7 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
wacom_numbered_button_to_key(features->numbered_buttons),
0);
features->numbered_buttons++;
+ features->device_type |= WACOM_DEVICETYPE_PAD;
break;
}
}

[Jason Gerecke]

Commit 345857b ("HID: wacom: generic: Add support for sensor offsets") included
a change to the operation and location of the call to 'wacom_add_shared_data'
in 'wacom_parse_and_register'. The modifications included moving it higher up
so that it would occur before the call to 'wacom_retrieve_hid_descriptor'. This
was done to prevent a crash that would have occured when the report containing
tablet offsets was fed into the driver with 'wacom_hid_report_raw_event'
(specifically: the various 'wacom_wac_*_report' functions were written with the
assumption that they would only be called once tablet setup had completed;
'wacom_wac_pen_report' in particular dereferences 'shared' which wasn't yet
allocated).

Moving the call to 'wacom_add_shared_data' effectively prevented the crash but
also broke the sibiling detection code which assumes that the HID descriptor
has been read and the various device_type flags set.

To fix this situation, we restore the original 'wacom_add_shared_data'
operation and location and instead implement an alternative change that can
also prevent the crash. Specifically, we notice that the report functions
mentioned above expect to be called only for input reports. By adding a check,
we can prevent feature reports (such as the offset report) from
causing trouble.

Fixes: 345857bb49 ("HID: wacom: generic: Add support for sensor offsets")
Signed-off-by: Jason Gerecke <***@wacom.com>
Tested-by: Ping Cheng <***@wacom.com>
Reviewed-by: Benjamin Tissoires <***@redhat.com>
Signed-off-by: Jiri Kosina <***@suse.cz>
[***@wacom.com: Imported into input-wacom repository (a9ce785)]
Signed-off-by: Jason Gerecke <***@wacom.com>
[***@wacom.com: Backported from input-wacom repository (8276911)]
Signed-off-by: Jason Gerecke <***@wacom.com>
---
3.17/wacom_sys.c | 21 ++++++++++-----------
3.17/wacom_wac.c | 10 ++++++++++
2 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/3.17/wacom_sys.c b/3.17/wacom_sys.c
index 80f07ee..5c4773a 100644
--- a/3.17/wacom_sys.c
+++ b/3.17/wacom_sys.c
@@ -748,6 +748,11 @@ static int wacom_add_shared_data(struct hid_device *hdev)
return retval;
}

+ if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)
+ wacom_wac->shared->touch = hdev;
+ else if (wacom_wac->features.device_type & WACOM_DEVICETYPE_PEN)
+ wacom_wac->shared->pen = hdev;
+
out:
mutex_unlock(&wacom_udev_list_lock);
return retval;
@@ -1865,10 +1870,6 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
if (error)
goto fail_open_group;

- error = wacom_add_shared_data(hdev);
- if (error)
- goto fail_allocate_inputs;
-
/*
* Bamboo Pad has a generic hid handling for the Pen, and we switch it
* into debug mode for the touch part.
@@ -1880,7 +1881,7 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
} else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) &&
(features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) {
error = -ENODEV;
- goto fail_shared_data;
+ goto fail_allocate_inputs;
}
}

@@ -1909,10 +1910,9 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless)

wacom_update_name(wacom, wireless ? " (WL)" : "");

- if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)
- wacom_wac->shared->touch = hdev;
- else if (wacom_wac->features.device_type & WACOM_DEVICETYPE_PEN)
- wacom_wac->shared->pen = hdev;
+ error = wacom_add_shared_data(hdev);
+ if (error)
+ goto fail_shared_data;

if (!(features->device_type & WACOM_DEVICETYPE_WL_MONITOR) &&
(features->quirks & WACOM_QUIRK_BATTERY)) {
@@ -1993,9 +1993,8 @@ fail_register_inputs:
wacom_destroy_battery(wacom);
#endif
fail_battery:
-fail_parsed:
fail_shared_data:
- wacom_remove_shared_data(wacom);
+fail_parsed:
fail_allocate_inputs:
fail_open_group:
wacom_release_resources(wacom);
diff --git a/3.17/wacom_wac.c b/3.17/wacom_wac.c
index 6b00374..d864dd3 100644
--- a/3.17/wacom_wac.c
+++ b/3.17/wacom_wac.c
@@ -2195,6 +2195,16 @@ void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)

wacom_report_events(hdev, report);

+ /*
+ * Non-input reports may be sent prior to the device being
+ * completely initialized. Since only their events need
+ * to be processed, exit after 'wacom_report_events' has
+ * been called to prevent potential crashes in the report-
+ * processing functions.
+ */
+ if (report->type != HID_INPUT_REPORT)
+ return;
+
if (WACOM_PAD_FIELD(field)) {
wacom_wac_pad_battery_report(hdev, report);
if (wacom->wacom_wac.pad_input)

[Jason Gerecke]

From: Ping Cheng <***@gmail.com>

post input_sync only when there are input events posted

Signed-off-by: Ping Cheng <***@wacom.com>
Reviewed-By: Jason Gerecke <***@wacom.com>
Signed-off-by: Jiri Kosina <***@suse.cz>
[***@wacom.com: Imported into input-wacom repository (c9cfb2a)]
Signed-off-by: Jason Gerecke <***@wacom.com>
[***@wacom.com: Backported from input-wacom repository (0ce8595)]
Signed-off-by: Jason Gerecke <***@wacom.com>
---
3.17/wacom_wac.c | 76 +++++++++++++++++++++++++++++++++++++-------------------
3.17/wacom_wac.h | 1 +
2 files changed, 52 insertions(+), 25 deletions(-)

diff --git a/3.17/wacom_wac.c b/3.17/wacom_wac.c
index 4e042b6..6b00374 100644
--- a/3.17/wacom_wac.c
+++ b/3.17/wacom_wac.c
@@ -1599,18 +1599,13 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
}
}

-static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
+static void wacom_wac_pad_battery_event(struct hid_device *hdev, struct hid_field *field,
struct hid_usage *usage, __s32 value)
{
struct wacom *wacom = hid_get_drvdata(hdev);
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
- struct input_dev *input = wacom_wac->pad_input;
unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);

- if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) {
- wacom_wac->hid_data.inrange_state |= value;
- }
-
switch (equivalent_usage) {
case WACOM_HID_WD_BATTERY_LEVEL:
wacom_wac->hid_data.battery_capacity = value;
@@ -1622,11 +1617,28 @@ static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field
wacom_wac->hid_data.ps_connected = value;
wacom_wac->hid_data.bat_connected = 1;
break;
+ }
+}

+static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
+ struct hid_usage *usage, __s32 value)
+{
+ struct wacom *wacom = hid_get_drvdata(hdev);
+ struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+ struct input_dev *input = wacom_wac->pad_input;
+ struct wacom_features *features = &wacom_wac->features;
+ unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
+
+ if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) {
+ wacom_wac->hid_data.inrange_state |= value;
+ }
+
+ switch (equivalent_usage) {
case WACOM_HID_WD_TOUCHRINGSTATUS:
break;

default:
+ features->input_event_flag = true;
input_event(input, usage->type, usage->code, value);
break;
}
@@ -1641,21 +1653,12 @@ static void wacom_wac_pad_pre_report(struct hid_device *hdev,
wacom_wac->hid_data.inrange_state = 0;
}

-static void wacom_wac_pad_report(struct hid_device *hdev,
+static void wacom_wac_pad_battery_report(struct hid_device *hdev,
struct hid_report *report)
{
struct wacom *wacom = hid_get_drvdata(hdev);
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
struct wacom_features *features = &wacom_wac->features;
- struct input_dev *input = wacom_wac->pad_input;
- bool active = wacom_wac->hid_data.inrange_state != 0;
-
- /*
- * don't report prox for events like accelerometer
- * or battery status
- */
- if (wacom_equivalent_usage(report->field[0]->physical) == HID_DG_TABLETFUNCTIONKEY)
- input_event(input, EV_ABS, ABS_MISC, active ? PAD_DEVICE_ID : 0);

if (features->quirks & WACOM_QUIRK_BATTERY) {
int capacity = wacom_wac->hid_data.battery_capacity;
@@ -1666,8 +1669,27 @@ static void wacom_wac_pad_report(struct hid_device *hdev,
wacom_notify_battery(wacom_wac, capacity, charging,
connected, powered);
}
+}

- input_sync(input);
+static void wacom_wac_pad_report(struct hid_device *hdev,
+ struct hid_report *report)
+{
+ struct wacom *wacom = hid_get_drvdata(hdev);
+ struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+ struct wacom_features *features = &wacom_wac->features;
+ struct input_dev *input = wacom_wac->pad_input;
+ bool active = wacom_wac->hid_data.inrange_state != 0;
+
+ /* report prox for expresskey events */
+ if (wacom_equivalent_usage(report->field[0]->physical) == HID_DG_TABLETFUNCTIONKEY) {
+ features->input_event_flag = true;
+ input_event(input, EV_ABS, ABS_MISC, active ? PAD_DEVICE_ID : 0);
+ }
+
+ if (features->input_event_flag) {
+ features->input_event_flag = false;
+ input_sync(input);
+ }
}

static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
@@ -2126,9 +2148,11 @@ void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
if (wacom->wacom_wac.features.type != HID_GENERIC)
return;

- if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
- wacom_wac_pad_event(hdev, field, usage, value);
- else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
+ if (WACOM_PAD_FIELD(field)) {
+ wacom_wac_pad_battery_event(hdev, field, usage, value);
+ if (wacom->wacom_wac.pad_input)
+ wacom_wac_pad_event(hdev, field, usage, value);
+ } else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
wacom_wac_pen_event(hdev, field, usage, value);
else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
wacom_wac_finger_event(hdev, field, usage, value);
@@ -2171,12 +2195,14 @@ void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)

wacom_report_events(hdev, report);

- if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
- return wacom_wac_pad_report(hdev, report);
- else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
- return wacom_wac_pen_report(hdev, report);
+ if (WACOM_PAD_FIELD(field)) {
+ wacom_wac_pad_battery_report(hdev, report);
+ if (wacom->wacom_wac.pad_input)
+ wacom_wac_pad_report(hdev, report);
+ } else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
+ wacom_wac_pen_report(hdev, report);
else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
- return wacom_wac_finger_report(hdev, report);
+ wacom_wac_finger_report(hdev, report);
}

static int wacom_bpt_touch(struct wacom_wac *wacom)
diff --git a/3.17/wacom_wac.h b/3.17/wacom_wac.h
index 968eb60..e366f0a 100644
--- a/3.17/wacom_wac.h
+++ b/3.17/wacom_wac.h
@@ -248,6 +248,7 @@ struct wacom_features {
int pktlen;
bool check_for_hid_type;
int hid_type;
+ bool input_event_flag;
};

struct wacom_shared {

[Jason Gerecke]

From: Ping Cheng <***@gmail.com>

Sometime valid events may not be supported by the driver yet. Make
sure we don't process them when the code is not ready.

This fix prevents a kernel panic due to unsupported HID events.

Signed-off-by: Ping Cheng <***@wacom.com>
Reviewed-By: Jason Gerecke <***@wacom.com>
Signed-off-by: Jiri Kosina <***@suse.cz>
[***@wacom.com: Imported into input-wacom repository (6f46cf9)]
Signed-off-by: Jason Gerecke <***@wacom.com>
[***@wacom.com: Backported from input-wacom repository (b6b76bb)]
Signed-off-by: Jason Gerecke <***@wacom.com>
---
3.17/wacom_wac.c | 18 +++++++++---------
1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/3.17/wacom_wac.c b/3.17/wacom_wac.c
index 7560dfa..d0acd1d 100644
--- a/3.17/wacom_wac.c
+++ b/3.17/wacom_wac.c
@@ -2117,11 +2117,11 @@ void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
if (wacom->wacom_wac.features.type != HID_GENERIC)
return;

- if (WACOM_PAD_FIELD(field))
+ if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
wacom_wac_pad_event(hdev, field, usage, value);
- else if (WACOM_PEN_FIELD(field))
+ else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
wacom_wac_pen_event(hdev, field, usage, value);
- else if (WACOM_FINGER_FIELD(field))
+ else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
wacom_wac_finger_event(hdev, field, usage, value);
}

@@ -2153,20 +2153,20 @@ void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
if (wacom_wac->features.type != HID_GENERIC)
return;

- if (WACOM_PAD_FIELD(field))
+ if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
wacom_wac_pad_pre_report(hdev, report);
- else if (WACOM_PEN_FIELD(field))
+ else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
wacom_wac_pen_pre_report(hdev, report);
- else if (WACOM_FINGER_FIELD(field))
+ else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
wacom_wac_finger_pre_report(hdev, report);

wacom_report_events(hdev, report);

- if (WACOM_PAD_FIELD(field))
+ if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
return wacom_wac_pad_report(hdev, report);
- else if (WACOM_PEN_FIELD(field))
+ else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
return wacom_wac_pen_report(hdev, report);
- else if (WACOM_FINGER_FIELD(field))
+ else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
return wacom_wac_finger_report(hdev, report);
}