Merge branch 'for-4.16/wacom' into for-linus

Pull Wacom device driver updates. These don't have to go on top of the
hid_have_special_driver[] revamp, as the whole group is assumed to
have a special driver based on VID.

3 files changed, 178 insertions, 29 deletions

diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
index ee71ad9b6cc1..409543160af7 100644
--- a/drivers/hid/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -56,6 +56,107 @@ static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
         return retval;
 }
 
+static void wacom_wac_queue_insert(struct hid_device *hdev,
+                                   struct kfifo_rec_ptr_2 *fifo,
+                                   u8 *raw_data, int size)
+{
+        bool warned = false;
+
+        while (kfifo_avail(fifo) < size) {
+                if (!warned)
+                        hid_warn(hdev, "%s: kfifo has filled, starting to drop events\n", __func__);
+                warned = true;
+
+                kfifo_skip(fifo);
+        }
+
+        kfifo_in(fifo, raw_data, size);
+}
+
+static void wacom_wac_queue_flush(struct hid_device *hdev,
+                                  struct kfifo_rec_ptr_2 *fifo)
+{
+        while (!kfifo_is_empty(fifo)) {
+                u8 buf[WACOM_PKGLEN_MAX];
+                int size;
+                int err;
+
+                size = kfifo_out(fifo, buf, sizeof(buf));
+                err = hid_report_raw_event(hdev, HID_INPUT_REPORT, buf, size, false);
+                if (err) {
+                        hid_warn(hdev, "%s: unable to flush event due to error %d\n",
+                                 __func__, err);
+                }
+        }
+}
+
+static int wacom_wac_pen_serial_enforce(struct hid_device *hdev,
+                struct hid_report *report, u8 *raw_data, int size)
+{
+        struct wacom *wacom = hid_get_drvdata(hdev);
+        struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+        struct wacom_features *features = &wacom_wac->features;
+        bool flush = false;
+        bool insert = false;
+        int i, j;
+
+        if (wacom_wac->serial[0] || !(features->quirks & WACOM_QUIRK_TOOLSERIAL))
+                return 0;
+
+        /* Queue events which have invalid tool type or serial number */
+        for (i = 0; i < report->maxfield; i++) {
+                for (j = 0; j < report->field[i]->maxusage; j++) {
+                        struct hid_field *field = report->field[i];
+                        struct hid_usage *usage = &field->usage[j];
+                        unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
+                        unsigned int offset;
+                        unsigned int size;
+                        unsigned int value;
+
+                        if (equivalent_usage != HID_DG_INRANGE &&
+                            equivalent_usage != HID_DG_TOOLSERIALNUMBER &&
+                            equivalent_usage != WACOM_HID_WD_SERIALHI &&
+                            equivalent_usage != WACOM_HID_WD_TOOLTYPE)
+                                continue;
+
+                        offset = field->report_offset;
+                        size = field->report_size;
+                        value = hid_field_extract(hdev, raw_data+1, offset + j * size, size);
+
+                        /* If we go out of range, we need to flush the queue ASAP */
+                        if (equivalent_usage == HID_DG_INRANGE)
+                                value = !value;
+
+                        if (value) {
+                                flush = true;
+                                switch (equivalent_usage) {
+                                case HID_DG_TOOLSERIALNUMBER:
+                                        wacom_wac->serial[0] = value;
+                                        break;
+
+                                case WACOM_HID_WD_SERIALHI:
+                                        wacom_wac->serial[0] |= ((__u64)value) << 32;
+                                        break;
+
+                                case WACOM_HID_WD_TOOLTYPE:
+                                        wacom_wac->id[0] = value;
+                                        break;
+                                }
+                        }
+                        else {
+                                insert = true;
+                        }
+                }
+        }
+
+        if (flush)
+                wacom_wac_queue_flush(hdev, &wacom_wac->pen_fifo);
+        else if (insert)
+                wacom_wac_queue_insert(hdev, &wacom_wac->pen_fifo, raw_data, size);
+
+        return insert && !flush;
+}
+
 static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
                 u8 *raw_data, int size)
 {
@@ -64,6 +165,9 @@ static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
         if (size > WACOM_PKGLEN_MAX)
                 return 1;
 
+        if (wacom_wac_pen_serial_enforce(hdev, report, raw_data, size))
+                return -1;
+
         memcpy(wacom->wacom_wac.data, raw_data, size);
 
         wacom_wac_irq(&wacom->wacom_wac, size);
@@ -2347,23 +2451,23 @@ static void wacom_remote_destroy_one(struct wacom *wacom, unsigned int index)
         int i;
         unsigned long flags;
 
-        spin_lock_irqsave(&remote->remote_lock, flags);
-        remote->remotes[index].registered = false;
-        spin_unlock_irqrestore(&remote->remote_lock, flags);
+        for (i = 0; i < WACOM_MAX_REMOTES; i++) {
+                if (remote->remotes[i].serial == serial) {
 
-        if (remote->remotes[index].battery.battery)
-                devres_release_group(&wacom->hdev->dev,
-                                     &remote->remotes[index].battery.bat_desc);
+                        spin_lock_irqsave(&remote->remote_lock, flags);
+                        remote->remotes[i].registered = false;
+                        spin_unlock_irqrestore(&remote->remote_lock, flags);
 
-        if (remote->remotes[index].group.name)
-                devres_release_group(&wacom->hdev->dev,
-                                     &remote->remotes[index]);
+                        if (remote->remotes[i].battery.battery)
+                                devres_release_group(&wacom->hdev->dev,
+                                                     &remote->remotes[i].battery.bat_desc);
+
+                        if (remote->remotes[i].group.name)
+                                devres_release_group(&wacom->hdev->dev,
+                                                     &remote->remotes[i]);
 
-        for (i = 0; i < WACOM_MAX_REMOTES; i++) {
-                if (remote->remotes[i].serial == serial) {
                         remote->remotes[i].serial = 0;
                         remote->remotes[i].group.name = NULL;
-                        remote->remotes[i].registered = false;
                         remote->remotes[i].battery.battery = NULL;
                         wacom->led.groups[i].select = WACOM_STATUS_UNKNOWN;
                 }
@@ -2580,6 +2684,10 @@ static int wacom_probe(struct hid_device *hdev,
                 goto fail;
         }
 
+        error = kfifo_alloc(&wacom_wac->pen_fifo, WACOM_PKGLEN_MAX, GFP_KERNEL);
+        if (error)
+                goto fail;
+
         wacom_wac->hid_data.inputmode = -1;
         wacom_wac->mode_report = -1;
 
@@ -2643,6 +2751,8 @@ static void wacom_remove(struct hid_device *hdev)
         if (wacom->wacom_wac.features.type != REMOTE)
                 wacom_release_resources(wacom);
 
+        kfifo_free(&wacom_wac->pen_fifo);
+
         hid_set_drvdata(hdev, NULL);
 }
 
diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
index 16af6886e828..90c38a0523e9 100644
--- a/drivers/hid/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -1924,7 +1924,6 @@ static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field
         struct wacom_features *features = &wacom_wac->features;
         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
         int i;
-        bool is_touch_on = value;
         bool do_report = false;
 
         /*
@@ -1969,16 +1968,17 @@ static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field
                 break;
 
         case WACOM_HID_WD_MUTE_DEVICE:
-                if (wacom_wac->shared->touch_input && value) {
-                        wacom_wac->shared->is_touch_on = !wacom_wac->shared->is_touch_on;
-                        is_touch_on = wacom_wac->shared->is_touch_on;
-                }
-
-                /* fall through*/
         case WACOM_HID_WD_TOUCHONOFF:
                 if (wacom_wac->shared->touch_input) {
+                        bool *is_touch_on = &wacom_wac->shared->is_touch_on;
+
+                        if (equivalent_usage == WACOM_HID_WD_MUTE_DEVICE && value)
+                                *is_touch_on = !(*is_touch_on);
+                        else if (equivalent_usage == WACOM_HID_WD_TOUCHONOFF)
+                                *is_touch_on = value;
+
                         input_report_switch(wacom_wac->shared->touch_input,
-                                            SW_MUTE_DEVICE, !is_touch_on);
+                                            SW_MUTE_DEVICE, !(*is_touch_on));
                         input_sync(wacom_wac->shared->touch_input);
                 }
                 break;
@@ -2085,7 +2085,29 @@ static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
                 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS2, 0);
                 break;
         case HID_DG_TOOLSERIALNUMBER:
+                features->quirks |= WACOM_QUIRK_TOOLSERIAL;
                 wacom_map_usage(input, usage, field, EV_MSC, MSC_SERIAL, 0);
+
+                /* Adjust AES usages to match modern convention */
+                if (usage->hid == WACOM_HID_WT_SERIALNUMBER && field->report_size == 16) {
+                        if (field->index + 2 < field->report->maxfield) {
+                                struct hid_field *a = field->report->field[field->index + 1];
+                                struct hid_field *b = field->report->field[field->index + 2];
+
+                                if (a->maxusage > 0 && a->usage[0].hid == HID_DG_TOOLSERIALNUMBER && a->report_size == 32 &&
+                                    b->maxusage > 0 && b->usage[0].hid == 0xFF000000 && b->report_size == 8) {
+                                        features->quirks |= WACOM_QUIRK_AESPEN;
+                                        usage->hid = WACOM_HID_WD_TOOLTYPE;
+                                        field->logical_minimum = S16_MIN;
+                                        field->logical_maximum = S16_MAX;
+                                        a->logical_minimum = S32_MIN;
+                                        a->logical_maximum = S32_MAX;
+                                        b->usage[0].hid = WACOM_HID_WD_SERIALHI;
+                                        b->logical_minimum = 0;
+                                        b->logical_maximum = U8_MAX;
+                                }
+                        }
+                }
                 break;
         case WACOM_HID_WD_SENSE:
                 features->quirks |= WACOM_QUIRK_SENSE;
@@ -2093,15 +2115,18 @@ static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
                 break;
         case WACOM_HID_WD_SERIALHI:
                 wacom_map_usage(input, usage, field, EV_ABS, ABS_MISC, 0);
-                set_bit(EV_KEY, input->evbit);
-                input_set_capability(input, EV_KEY, BTN_TOOL_PEN);
-                input_set_capability(input, EV_KEY, BTN_TOOL_RUBBER);
-                input_set_capability(input, EV_KEY, BTN_TOOL_BRUSH);
-                input_set_capability(input, EV_KEY, BTN_TOOL_PENCIL);
-                input_set_capability(input, EV_KEY, BTN_TOOL_AIRBRUSH);
-                if (!(features->device_type & WACOM_DEVICETYPE_DIRECT)) {
-                        input_set_capability(input, EV_KEY, BTN_TOOL_MOUSE);
-                        input_set_capability(input, EV_KEY, BTN_TOOL_LENS);
+
+                if (!(features->quirks & WACOM_QUIRK_AESPEN)) {
+                        set_bit(EV_KEY, input->evbit);
+                        input_set_capability(input, EV_KEY, BTN_TOOL_PEN);
+                        input_set_capability(input, EV_KEY, BTN_TOOL_RUBBER);
+                        input_set_capability(input, EV_KEY, BTN_TOOL_BRUSH);
+                        input_set_capability(input, EV_KEY, BTN_TOOL_PENCIL);
+                        input_set_capability(input, EV_KEY, BTN_TOOL_AIRBRUSH);
+                        if (!(features->device_type & WACOM_DEVICETYPE_DIRECT)) {
+                                input_set_capability(input, EV_KEY, BTN_TOOL_MOUSE);
+                                input_set_capability(input, EV_KEY, BTN_TOOL_LENS);
+                        }
                 }
                 break;
         case WACOM_HID_WD_FINGERWHEEL:
@@ -4390,6 +4415,12 @@ static const struct wacom_features wacom_features_0x360 =
 static const struct wacom_features wacom_features_0x361 =
         { "Wacom Intuos Pro L", 62200, 43200, 8191, 63,
           INTUOSP2_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 10 };
+static const struct wacom_features wacom_features_0x37A =
+        { "Wacom One by Wacom S", 15200, 9500, 2047, 63,
+          BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0x37B =
+        { "Wacom One by Wacom M", 21600, 13500, 2047, 63,
+          BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 
 static const struct wacom_features wacom_features_HID_ANY_ID =
         { "Wacom HID", .type = HID_GENERIC, .oVid = HID_ANY_ID, .oPid = HID_ANY_ID };
@@ -4558,6 +4589,8 @@ const struct hid_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x343) },
         { BT_DEVICE_WACOM(0x360) },
         { BT_DEVICE_WACOM(0x361) },
+        { USB_DEVICE_WACOM(0x37A) },
+        { USB_DEVICE_WACOM(0x37B) },
         { USB_DEVICE_WACOM(0x4001) },
         { USB_DEVICE_WACOM(0x4004) },
         { USB_DEVICE_WACOM(0x5000) },
diff --git a/drivers/hid/wacom_wac.h b/drivers/hid/wacom_wac.h
index 64d8f014602e..15d9c14fbdf7 100644
--- a/drivers/hid/wacom_wac.h
+++ b/drivers/hid/wacom_wac.h
@@ -11,6 +11,7 @@
 
 #include <linux/types.h>
 #include <linux/hid.h>
+#include <linux/kfifo.h>
 
 /* maximum packet length for USB/BT devices */
 #define WACOM_PKGLEN_MAX        361
@@ -86,7 +87,9 @@
 /* device quirks */
 #define WACOM_QUIRK_BBTOUCH_LOWRES      0x0001
 #define WACOM_QUIRK_SENSE               0x0002
+#define WACOM_QUIRK_AESPEN              0x0004
 #define WACOM_QUIRK_BATTERY             0x0008
+#define WACOM_QUIRK_TOOLSERIAL          0x0010
 
 /* device types */
 #define WACOM_DEVICETYPE_NONE           0x0000
@@ -107,6 +110,7 @@
 #define WACOM_HID_WD_PEN                (WACOM_HID_UP_WACOMDIGITIZER | 0x02)
 #define WACOM_HID_WD_SENSE              (WACOM_HID_UP_WACOMDIGITIZER | 0x36)
 #define WACOM_HID_WD_DIGITIZERFNKEYS    (WACOM_HID_UP_WACOMDIGITIZER | 0x39)
+#define WACOM_HID_WD_SERIALNUMBER       (WACOM_HID_UP_WACOMDIGITIZER | 0x5b)
 #define WACOM_HID_WD_SERIALHI           (WACOM_HID_UP_WACOMDIGITIZER | 0x5c)
 #define WACOM_HID_WD_TOOLTYPE           (WACOM_HID_UP_WACOMDIGITIZER | 0x77)
 #define WACOM_HID_WD_DISTANCE           (WACOM_HID_UP_WACOMDIGITIZER | 0x0132)
@@ -150,6 +154,7 @@
 #define WACOM_HID_WT_TOUCHSCREEN        (WACOM_HID_UP_WACOMTOUCH | 0x04)
 #define WACOM_HID_WT_TOUCHPAD           (WACOM_HID_UP_WACOMTOUCH | 0x05)
 #define WACOM_HID_WT_CONTACTMAX         (WACOM_HID_UP_WACOMTOUCH | 0x55)
+#define WACOM_HID_WT_SERIALNUMBER       (WACOM_HID_UP_WACOMTOUCH | 0x5b)
 #define WACOM_HID_WT_X                  (WACOM_HID_UP_WACOMTOUCH | 0x130)
 #define WACOM_HID_WT_Y                  (WACOM_HID_UP_WACOMTOUCH | 0x131)
 
@@ -336,6 +341,7 @@ struct wacom_wac {
         struct input_dev *pen_input;
         struct input_dev *touch_input;
         struct input_dev *pad_input;
+        struct kfifo_rec_ptr_2 pen_fifo;
         int pid;
         int num_contacts_left;
         u8 bt_features;