Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid

Pull HID updates from Jiri Kosina:

 - a lot of Wacom driver updates; most notably second generation Intuos
   Pro is now supported, code from Aaron Armstrong Skomra and Jason
   Gerecke

 - Surface 3 and 4 Type Cover Pro support from Daniel Keller, Dennis
   Chen and Yuta Kobayashi

 - hid-rmi is now generic transport driver, used by synaptics-rmi4;
   Support the Lenovo Thinkpad X1 Tablet dock follows on top, from
   Andrew Duggan

 - a few misc bugfixes and improvements here and there

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (29 commits)
  HID: intel-ish-hid: constify device_type structure
  HID: wacom: Bluetooth IRQ for Intuos Pro should handle prox/range
  HID: intel-ish-hid: ipc: check FW status to distinguish ISH resume paths
  HID: multitouch: fix LG Melfas touchscreen
  HID: wacom: don't apply generic settings to old devices
  HID: wacom: generic: support LEDs
  HID: wacom: generic: support generic touch switch
  HID: wacom: generic: add vendor defined touch
  HID: wacom: generic: add support for touchring
  HID: wacom: generic: remove input_event_flag
  HID: wacom: Support 2nd-gen Intuos Pro's Bluetooth classic interface
  HID: wacom: Move WAC_CMD_* into wacom_wac.h
  HID: wacom: Enable HID_GENERIC codepath for Bluetooth devices
  HID: wacom: do not attempt to switch mode while in probe
  HID: wacom: remove warning while disconnecting devices
  HID: wacom: release the resources before leaving despite devm
  HID: whitespace cleanup
  HID: multitouch: enable Surface 3 Type Cover Pro to report multitouch data
  HID: rmi: Support the Lenovo Thinkpad X1 Tablet dock using hid-rmi
  HID: rmi: Handle all Synaptics touchpads using hid-rmi
  ...

23 files changed, 698 insertions, 961 deletions

diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 4070b7386e9d..1aeb80e52424 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -785,6 +785,11 @@ config HID_SUNPLUS
 config HID_RMI
         tristate "Synaptics RMI4 device support"
         depends on HID
+        select RMI4_CORE
+        select RMI4_F03
+        select RMI4_F11
+        select RMI4_F12
+        select RMI4_F30
         ---help---
         Support for Synaptics RMI4 touchpads.
         Say Y here if you have a Synaptics RMI4 touchpads over i2c-hid or usbhid
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index ea36b557d5ee..538ff697a4cf 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -43,7 +43,6 @@
  */
 
 #define DRIVER_DESC "HID core driver"
-#define DRIVER_LICENSE "GPL"
 
 int hid_debug = 0;
 module_param_named(debug, hid_debug, int, 0600);
@@ -724,13 +723,7 @@ static void hid_scan_collection(struct hid_parser *parser, unsigned type)
                 hid->group = HID_GROUP_SENSOR_HUB;
 
         if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
-            (hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3 ||
-             hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2 ||
-             hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP ||
-             hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4 ||
-             hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2 ||
-             hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP ||
-             hid->product == USB_DEVICE_ID_MS_POWER_COVER) &&
+            hid->product == USB_DEVICE_ID_MS_POWER_COVER &&
             hid->group == HID_GROUP_MULTITOUCH)
                 hid->group = HID_GROUP_GENERIC;
 
@@ -826,7 +819,8 @@ static int hid_scan_report(struct hid_device *hid)
                 hid->group = HID_GROUP_WACOM;
                 break;
         case USB_VENDOR_ID_SYNAPTICS:
-                if (hid->group == HID_GROUP_GENERIC)
+                if (hid->group == HID_GROUP_GENERIC ||
+                    hid->group == HID_GROUP_MULTITOUCH_WIN_8)
                         if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
                             && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
                                 /*
@@ -1887,6 +1881,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
 #if IS_ENABLED(CONFIG_HID_MAYFLASH)
         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2) },
 #endif
         { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_WN) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_FA) },
@@ -1933,6 +1930,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
 #endif
+        { HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MELFAS_MT) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
@@ -1985,12 +1983,6 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) },
@@ -2126,6 +2118,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM6533) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
         { }
 };
 
@@ -2314,7 +2307,7 @@ __ATTRIBUTE_GROUPS(hid_dev);
 
 static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
-        struct hid_device *hdev = to_hid_device(dev);   
+        struct hid_device *hdev = to_hid_device(dev);
 
         if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
                         hdev->bus, hdev->vendor, hdev->product))
@@ -2867,5 +2860,5 @@ module_exit(hid_exit);
 MODULE_AUTHOR("Andreas Gal");
 MODULE_AUTHOR("Vojtech Pavlik");
 MODULE_AUTHOR("Jiri Kosina");
-MODULE_LICENSE(DRIVER_LICENSE);
+MODULE_LICENSE("GPL");
 
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 350accfee8e8..86c95d30ac80 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -323,7 +323,8 @@
 #define USB_DEVICE_ID_DRAGONRISE_WIIU           0x1800
 #define USB_DEVICE_ID_DRAGONRISE_PS3            0x1801
 #define USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR     0x1803
-#define USB_DEVICE_ID_DRAGONRISE_GAMECUBE       0x1843
+#define USB_DEVICE_ID_DRAGONRISE_GAMECUBE1      0x1843
+#define USB_DEVICE_ID_DRAGONRISE_GAMECUBE2      0x1844
 
 #define USB_VENDOR_ID_DWAV              0x0eef
 #define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER    0x0001
@@ -630,9 +631,11 @@
 #define USB_DEVICE_ID_LENOVO_CUSBKBD    0x6047
 #define USB_DEVICE_ID_LENOVO_CBTKBD     0x6048
 #define USB_DEVICE_ID_LENOVO_TPPRODOCK  0x6067
+#define USB_DEVICE_ID_LENOVO_X1_COVER   0x6085
 
 #define USB_VENDOR_ID_LG                0x1fd2
 #define USB_DEVICE_ID_LG_MULTITOUCH     0x0064
+#define USB_DEVICE_ID_LG_MELFAS_MT      0x6007
 
 #define USB_VENDOR_ID_LOGITECH          0x046d
 #define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e
@@ -725,12 +728,6 @@
 #define USB_DEVICE_ID_MS_SURFACE_PRO_2   0x0799
 #define USB_DEVICE_ID_MS_TOUCH_COVER_2   0x07a7
 #define USB_DEVICE_ID_MS_TYPE_COVER_2    0x07a9
-#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_3    0x07dc
-#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2  0x07e2
-#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP 0x07dd
-#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_4 0x07e4
-#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2 0x07e8
-#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP 0x07e9
 #define USB_DEVICE_ID_MS_POWER_COVER     0x07da
 
 #define USB_VENDOR_ID_MOJO              0x8282
diff --git a/drivers/hid/hid-mf.c b/drivers/hid/hid-mf.c
index d9090765a6e5..03f10516131d 100644
--- a/drivers/hid/hid-mf.c
+++ b/drivers/hid/hid-mf.c
@@ -6,12 +6,14 @@
  *
  * Tested with:
  * 0079:1801 "DragonRise Inc. Mayflash PS3 Game Controller Adapter"
+ * 0079:1803 "DragonRise Inc. Mayflash Wireless Sensor DolphinBar"
+ * 0079:1843 "DragonRise Inc. Mayflash GameCube Game Controller Adapter"
+ * 0079:1844 "DragonRise Inc. Mayflash GameCube Game Controller Adapter (v04)"
  *
  * The following adapters probably work too, but need to be tested:
  * 0079:1800 "DragonRise Inc. Mayflash WIIU Game Controller Adapter"
- * 0079:1843 "DragonRise Inc. Mayflash GameCube Game Controller Adapter"
  *
- * Copyright (c) 2016 Marcel Hasler <mahasler@gmail.com>
+ * Copyright (c) 2016-2017 Marcel Hasler <mahasler@gmail.com>
  */
 
 /*
@@ -125,8 +127,8 @@ static int mf_probe(struct hid_device *hid, const struct hid_device_id *id)
 
         dev_dbg(&hid->dev, "Mayflash HID hardware probe...\n");
 
-        /* Split device into four inputs */
-        hid->quirks |= HID_QUIRK_MULTI_INPUT;
+        /* Apply quirks as needed */
+        hid->quirks |= id->driver_data;
 
         error = hid_parse(hid);
         if (error) {
@@ -151,7 +153,14 @@ static int mf_probe(struct hid_device *hid, const struct hid_device_id *id)
 }
 
 static const struct hid_device_id mf_devices[] = {
-        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3),  },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3),
+                .driver_data = HID_QUIRK_MULTI_INPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR),
+                .driver_data = HID_QUIRK_MULTI_INPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1),
+                .driver_data = HID_QUIRK_MULTI_INPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2),
+                .driver_data = 0 }, /* No quirk required */
         { }
 };
 MODULE_DEVICE_TABLE(hid, mf_devices);
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
index 74b7b84a0420..96e7d3231d2f 100644
--- a/drivers/hid/hid-microsoft.c
+++ b/drivers/hid/hid-microsoft.c
@@ -274,18 +274,6 @@ static const struct hid_device_id ms_devices[] = {
                 .driver_data = MS_NOGET },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500),
                 .driver_data = MS_DUPLICATE_USAGES },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3),
-                .driver_data = MS_HIDINPUT },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2),
-                .driver_data = MS_HIDINPUT },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP),
-                .driver_data = MS_HIDINPUT },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4),
-                .driver_data = MS_HIDINPUT },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2),
-                .driver_data = MS_HIDINPUT },
-        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP),
-                .driver_data = MS_HIDINPUT },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER),
                 .driver_data = MS_HIDINPUT },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD),
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 6dca66806844..692647485a53 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -68,6 +68,7 @@ MODULE_LICENSE("GPL");
 #define MT_QUIRK_HOVERING               (1 << 11)
 #define MT_QUIRK_CONTACT_CNT_ACCURATE   (1 << 12)
 #define MT_QUIRK_FORCE_GET_FEATURE      (1 << 13)
+#define MT_QUIRK_FIX_CONST_CONTACT_ID   (1 << 14)
 
 #define MT_INPUTMODE_TOUCHSCREEN        0x02
 #define MT_INPUTMODE_TOUCHPAD           0x03
@@ -157,6 +158,7 @@ static void mt_post_parse(struct mt_device *td);
 #define MT_CLS_FLATFROG                         0x0107
 #define MT_CLS_GENERALTOUCH_TWOFINGERS          0x0108
 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS      0x0109
+#define MT_CLS_LG                               0x010a
 #define MT_CLS_VTL                              0x0110
 
 #define MT_DEFAULT_MAXCONTACT   10
@@ -263,6 +265,12 @@ static struct mt_class mt_classes[] = {
                 .sn_move = 2048,
                 .maxcontacts = 40,
         },
+        { .name = MT_CLS_LG,
+                .quirks = MT_QUIRK_ALWAYS_VALID |
+                        MT_QUIRK_FIX_CONST_CONTACT_ID |
+                        MT_QUIRK_IGNORE_DUPLICATES |
+                        MT_QUIRK_HOVERING |
+                        MT_QUIRK_CONTACT_CNT_ACCURATE },
         { .name = MT_CLS_VTL,
                 .quirks = MT_QUIRK_ALWAYS_VALID |
                         MT_QUIRK_CONTACT_CNT_ACCURATE |
@@ -1078,6 +1086,34 @@ static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
         return 0;
 }
 
+static void mt_fix_const_field(struct hid_field *field, unsigned int usage)
+{
+        if (field->usage[0].hid != usage ||
+            !(field->flags & HID_MAIN_ITEM_CONSTANT))
+                return;
+
+        field->flags &= ~HID_MAIN_ITEM_CONSTANT;
+        field->flags |= HID_MAIN_ITEM_VARIABLE;
+}
+
+static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage)
+{
+        struct hid_report *report;
+        int i;
+
+        list_for_each_entry(report,
+                            &hdev->report_enum[HID_INPUT_REPORT].report_list,
+                            list) {
+
+                if (!report->maxfield)
+                        continue;
+
+                for (i = 0; i < report->maxfield; i++)
+                        if (report->field[i]->maxusage >= 1)
+                                mt_fix_const_field(report->field[i], usage);
+        }
+}
+
 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
         int ret, i;
@@ -1151,6 +1187,9 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
         if (ret != 0)
                 return ret;
 
+        if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID)
+                mt_fix_const_fields(hdev, HID_DG_CONTACTID);
+
         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
         if (ret)
                 return ret;
@@ -1398,6 +1437,11 @@ static const struct hid_device_id mt_devices[] = {
                 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
                         USB_DEVICE_ID_ILITEK_MULTITOUCH) },
 
+        /* LG Melfas panel */
+        { .driver_data = MT_CLS_LG,
+                HID_USB_DEVICE(USB_VENDOR_ID_LG,
+                        USB_DEVICE_ID_LG_MELFAS_MT) },
+
         /* MosArt panels */
         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
                 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
diff --git a/drivers/hid/hid-rmi.c b/drivers/hid/hid-rmi.c
index be89bcbf6a71..5b40c2614599 100644
--- a/drivers/hid/hid-rmi.c
+++ b/drivers/hid/hid-rmi.c
@@ -14,11 +14,14 @@
 #include <linux/hid.h>
 #include <linux/input.h>
 #include <linux/input/mt.h>
+#include <linux/irq.h>
+#include <linux/irqdomain.h>
 #include <linux/module.h>
 #include <linux/pm.h>
 #include <linux/slab.h>
 #include <linux/wait.h>
 #include <linux/sched.h>
+#include <linux/rmi.h>
 #include "hid-ids.h"
 
 #define RMI_MOUSE_REPORT_ID             0x01 /* Mouse emulation Report */
@@ -33,9 +36,6 @@
 #define RMI_READ_DATA_PENDING           1
 #define RMI_STARTED                     2
 
-#define RMI_SLEEP_NORMAL                0x0
-#define RMI_SLEEP_DEEP_SLEEP            0x1
-
 /* device flags */
 #define RMI_DEVICE                      BIT(0)
 #define RMI_DEVICE_HAS_PHYS_BUTTONS     BIT(1)
@@ -54,25 +54,12 @@ enum rmi_mode_type {
         RMI_MODE_NO_PACKED_ATTN_REPORTS = 2,
 };
 
-struct rmi_function {
-        unsigned page;                  /* page of the function */
-        u16 query_base_addr;            /* base address for queries */
-        u16 command_base_addr;          /* base address for commands */
-        u16 control_base_addr;          /* base address for controls */
-        u16 data_base_addr;             /* base address for datas */
-        unsigned int interrupt_base;    /* cross-function interrupt number
-                                         * (uniq in the device)*/
-        unsigned int interrupt_count;   /* number of interrupts */
-        unsigned int report_size;       /* size of a report */
-        unsigned long irq_mask;         /* mask of the interrupts
-                                         * (to be applied against ATTN IRQ) */
-};
-
 /**
  * struct rmi_data - stores information for hid communication
  *
  * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
  * @page: Keeps track of the current virtual page
+ * @xport: transport device to be registered with the RMI4 core.
  *
  * @wait: Used for waiting for read data
  *
@@ -84,26 +71,18 @@ struct rmi_function {
  *
  * @flags: flags for the current device (started, reading, etc...)
  *
- * @f11: placeholder of internal RMI function F11 description
- * @f30: placeholder of internal RMI function F30 description
- *
- * @max_fingers: maximum finger count reported by the device
- * @max_x: maximum x value reported by the device
- * @max_y: maximum y value reported by the device
- *
- * @gpio_led_count: count of GPIOs + LEDs reported by F30
- * @button_count: actual physical buttons count
- * @button_mask: button mask used to decode GPIO ATTN reports
- * @button_state_mask: pull state of the buttons
- *
- * @input: pointer to the kernel input device
- *
  * @reset_work: worker which will be called in case of a mouse report
  * @hdev: pointer to the struct hid_device
+ *
+ * @device_flags: flags which describe the device
+ *
+ * @domain: the IRQ domain allocated for this RMI4 device
+ * @rmi_irq: the irq that will be used to generate events to rmi-core
  */
 struct rmi_data {
         struct mutex page_mutex;
         int page;
+        struct rmi_transport_dev xport;
 
         wait_queue_head_t wait;
 
@@ -115,34 +94,13 @@ struct rmi_data {
 
         unsigned long flags;
 
-        struct rmi_function f01;
-        struct rmi_function f11;
-        struct rmi_function f30;
-
-        unsigned int max_fingers;
-        unsigned int max_x;
-        unsigned int max_y;
-        unsigned int x_size_mm;
-        unsigned int y_size_mm;
-        bool read_f11_ctrl_regs;
-        u8 f11_ctrl_regs[RMI_F11_CTRL_REG_COUNT];
-
-        unsigned int gpio_led_count;
-        unsigned int button_count;
-        unsigned long button_mask;
-        unsigned long button_state_mask;
-
-        struct input_dev *input;
-
         struct work_struct reset_work;
         struct hid_device *hdev;
 
         unsigned long device_flags;
-        unsigned long firmware_id;
 
-        u8 f01_ctrl0;
-        u8 interrupt_enable_mask;
-        bool restore_interrupt_mask;
+        struct irq_domain *domain;
+        int rmi_irq;
 };
 
 #define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
@@ -220,10 +178,11 @@ static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)
         return ret;
 }
 
-static int rmi_read_block(struct hid_device *hdev, u16 addr, void *buf,
-                const int len)
+static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr,
+                void *buf, size_t len)
 {
-        struct rmi_data *data = hid_get_drvdata(hdev);
+        struct rmi_data *data = container_of(xport, struct rmi_data, xport);
+        struct hid_device *hdev = data->hdev;
         int ret;
         int bytes_read;
         int bytes_needed;
@@ -292,15 +251,11 @@ exit:
         return ret;
 }
 
-static inline int rmi_read(struct hid_device *hdev, u16 addr, void *buf)
-{
-        return rmi_read_block(hdev, addr, buf, 1);
-}
-
-static int rmi_write_block(struct hid_device *hdev, u16 addr, void *buf,
-                const int len)
+static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr,
+                const void *buf, size_t len)
 {
-        struct rmi_data *data = hid_get_drvdata(hdev);
+        struct rmi_data *data = container_of(xport, struct rmi_data, xport);
+        struct hid_device *hdev = data->hdev;
         int ret;
 
         mutex_lock(&data->page_mutex);
@@ -332,62 +287,20 @@ exit:
         return ret;
 }
 
-static inline int rmi_write(struct hid_device *hdev, u16 addr, void *buf)
-{
-        return rmi_write_block(hdev, addr, buf, 1);
-}
-
-static void rmi_f11_process_touch(struct rmi_data *hdata, int slot,
-                u8 finger_state, u8 *touch_data)
-{
-        int x, y, wx, wy;
-        int wide, major, minor;
-        int z;
-
-        input_mt_slot(hdata->input, slot);
-        input_mt_report_slot_state(hdata->input, MT_TOOL_FINGER,
-                        finger_state == 0x01);
-        if (finger_state == 0x01) {
-                x = (touch_data[0] << 4) | (touch_data[2] & 0x0F);
-                y = (touch_data[1] << 4) | (touch_data[2] >> 4);
-                wx = touch_data[3] & 0x0F;
-                wy = touch_data[3] >> 4;
-                wide = (wx > wy);
-                major = max(wx, wy);
-                minor = min(wx, wy);
-                z = touch_data[4];
-
-                /* y is inverted */
-                y = hdata->max_y - y;
-
-                input_event(hdata->input, EV_ABS, ABS_MT_POSITION_X, x);
-                input_event(hdata->input, EV_ABS, ABS_MT_POSITION_Y, y);
-                input_event(hdata->input, EV_ABS, ABS_MT_ORIENTATION, wide);
-                input_event(hdata->input, EV_ABS, ABS_MT_PRESSURE, z);
-                input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
-                input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
-        }
-}
-
 static int rmi_reset_attn_mode(struct hid_device *hdev)
 {
         struct rmi_data *data = hid_get_drvdata(hdev);
+        struct rmi_device *rmi_dev = data->xport.rmi_dev;
         int ret;
 
         ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
         if (ret)
                 return ret;
 
-        if (data->restore_interrupt_mask) {
-                ret = rmi_write(hdev, data->f01.control_base_addr + 1,
-                                &data->interrupt_enable_mask);
-                if (ret) {
-                        hid_err(hdev, "can not write F01 control register\n");
-                        return ret;
-                }
-        }
+        if (test_bit(RMI_STARTED, &data->flags))
+                ret = rmi_dev->driver->reset_handler(rmi_dev);
 
-        return 0;
+        return ret;
 }
 
 static void rmi_reset_work(struct work_struct *work)
@@ -399,102 +312,22 @@ static void rmi_reset_work(struct work_struct *work)
         rmi_reset_attn_mode(hdata->hdev);
 }
 
-static inline int rmi_schedule_reset(struct hid_device *hdev)
-{
-        struct rmi_data *hdata = hid_get_drvdata(hdev);
-        return schedule_work(&hdata->reset_work);
-}
-
-static int rmi_f11_input_event(struct hid_device *hdev, u8 irq, u8 *data,
-                int size)
-{
-        struct rmi_data *hdata = hid_get_drvdata(hdev);
-        int offset;
-        int i;
-
-        if (!(irq & hdata->f11.irq_mask) || size <= 0)
-                return 0;
-
-        offset = (hdata->max_fingers >> 2) + 1;
-        for (i = 0; i < hdata->max_fingers; i++) {
-                int fs_byte_position = i >> 2;
-                int fs_bit_position = (i & 0x3) << 1;
-                int finger_state = (data[fs_byte_position] >> fs_bit_position) &
-                                        0x03;
-                int position = offset + 5 * i;
-
-                if (position + 5 > size) {
-                        /* partial report, go on with what we received */
-                        printk_once(KERN_WARNING
-                                "%s %s: Detected incomplete finger report. Finger reports may occasionally get dropped on this platform.\n",
-                                 dev_driver_string(&hdev->dev),
-                                 dev_name(&hdev->dev));
-                        hid_dbg(hdev, "Incomplete finger report\n");
-                        break;
-                }
-
-                rmi_f11_process_touch(hdata, i, finger_state, &data[position]);
-        }
-        input_mt_sync_frame(hdata->input);
-        input_sync(hdata->input);
-        return hdata->f11.report_size;
-}
-
-static int rmi_f30_input_event(struct hid_device *hdev, u8 irq, u8 *data,
-                int size)
+static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
 {
         struct rmi_data *hdata = hid_get_drvdata(hdev);
-        int i;
-        int button = 0;
-        bool value;
+        struct rmi_device *rmi_dev = hdata->xport.rmi_dev;
+        unsigned long flags;
 
-        if (!(irq & hdata->f30.irq_mask))
+        if (!(test_bit(RMI_STARTED, &hdata->flags)))
                 return 0;
 
-        if (size < (int)hdata->f30.report_size) {
-                hid_warn(hdev, "Click Button pressed, but the click data is missing\n");
-                return 0;
-        }
+        local_irq_save(flags);
 
-        for (i = 0; i < hdata->gpio_led_count; i++) {
-                if (test_bit(i, &hdata->button_mask)) {
-                        value = (data[i / 8] >> (i & 0x07)) & BIT(0);
-                        if (test_bit(i, &hdata->button_state_mask))
-                                value = !value;
-                        input_event(hdata->input, EV_KEY, BTN_LEFT + button++,
-                                        value);
-                }
-        }
-        return hdata->f30.report_size;
-}
-
-static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
-{
-        struct rmi_data *hdata = hid_get_drvdata(hdev);
-        unsigned long irq_mask = 0;
-        unsigned index = 2;
+        rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2);
 
-        if (!(test_bit(RMI_STARTED, &hdata->flags)))
-                return 0;
+        generic_handle_irq(hdata->rmi_irq);
 
-        irq_mask |= hdata->f11.irq_mask;
-        irq_mask |= hdata->f30.irq_mask;
-
-        if (data[1] & ~irq_mask)
-                hid_dbg(hdev, "unknown intr source:%02lx %s:%d\n",
-                        data[1] & ~irq_mask, __FILE__, __LINE__);
-
-        if (hdata->f11.interrupt_base < hdata->f30.interrupt_base) {
-                index += rmi_f11_input_event(hdev, data[1], &data[index],
-                                size - index);
-                index += rmi_f30_input_event(hdev, data[1], &data[index],
-                                size - index);
-        } else {
-                index += rmi_f30_input_event(hdev, data[1], &data[index],
-                                size - index);
-                index += rmi_f11_input_event(hdev, data[1], &data[index],
-                                size - index);
-        }
+        local_irq_restore(flags);
 
         return 1;
 }
@@ -568,7 +401,7 @@ static int rmi_event(struct hid_device *hdev, struct hid_field *field,
                                 return 1;
                 }
 
-                rmi_schedule_reset(hdev);
+                schedule_work(&data->reset_work);
                 return 1;
         }
 
@@ -576,637 +409,71 @@ static int rmi_event(struct hid_device *hdev, struct hid_field *field,
 }
 
 #ifdef CONFIG_PM
-static int rmi_set_sleep_mode(struct hid_device *hdev, int sleep_mode)
-{
-        struct rmi_data *data = hid_get_drvdata(hdev);
-        int ret;
-        u8 f01_ctrl0;
-
-        f01_ctrl0 = (data->f01_ctrl0 & ~0x3) | sleep_mode;
-
-        ret = rmi_write(hdev, data->f01.control_base_addr,
-                        &f01_ctrl0);
-        if (ret) {
-                hid_err(hdev, "can not write sleep mode\n");
-                return ret;
-        }
-
-        return 0;
-}
-
 static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
 {
         struct rmi_data *data = hid_get_drvdata(hdev);
-        int ret;
-        u8 buf[RMI_F11_CTRL_REG_COUNT];
-
-        if (!(data->device_flags & RMI_DEVICE))
-                return 0;
-
-        ret = rmi_read_block(hdev, data->f11.control_base_addr, buf,
-                                RMI_F11_CTRL_REG_COUNT);
-        if (ret)
-                hid_warn(hdev, "can not read F11 control registers\n");
-        else
-                memcpy(data->f11_ctrl_regs, buf, RMI_F11_CTRL_REG_COUNT);
-
-
-        if (!device_may_wakeup(hdev->dev.parent))
-                return rmi_set_sleep_mode(hdev, RMI_SLEEP_DEEP_SLEEP);
-
-        return 0;
-}
-
-static int rmi_post_reset(struct hid_device *hdev)
-{
-        struct rmi_data *data = hid_get_drvdata(hdev);
+        struct rmi_device *rmi_dev = data->xport.rmi_dev;
         int ret;
 
         if (!(data->device_flags & RMI_DEVICE))
                 return 0;
 
-        ret = rmi_reset_attn_mode(hdev);
+        ret = rmi_driver_suspend(rmi_dev, false);
         if (ret) {
-                hid_err(hdev, "can not set rmi mode\n");
+                hid_warn(hdev, "Failed to suspend device: %d\n", ret);
                 return ret;
         }
 
-        if (data->read_f11_ctrl_regs) {
-                ret = rmi_write_block(hdev, data->f11.control_base_addr,
-                                data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT);
-                if (ret)
-                        hid_warn(hdev,
-                                "can not write F11 control registers after reset\n");
-        }
-
-        if (!device_may_wakeup(hdev->dev.parent)) {
-                ret = rmi_set_sleep_mode(hdev, RMI_SLEEP_NORMAL);
-                if (ret) {
-                        hid_err(hdev, "can not write sleep mode\n");
-                        return ret;
-                }
-        }
-
-        return ret;
+        return 0;
 }
 
 static int rmi_post_resume(struct hid_device *hdev)
 {
         struct rmi_data *data = hid_get_drvdata(hdev);
+        struct rmi_device *rmi_dev = data->xport.rmi_dev;
+        int ret;
 
         if (!(data->device_flags & RMI_DEVICE))
                 return 0;
 
-        return rmi_reset_attn_mode(hdev);
-}
-#endif /* CONFIG_PM */
-
-#define RMI4_MAX_PAGE 0xff
-#define RMI4_PAGE_SIZE 0x0100
-
-#define PDT_START_SCAN_LOCATION 0x00e9
-#define PDT_END_SCAN_LOCATION   0x0005
-#define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff)
-
-struct pdt_entry {
-        u8 query_base_addr:8;
-        u8 command_base_addr:8;
-        u8 control_base_addr:8;
-        u8 data_base_addr:8;
-        u8 interrupt_source_count:3;
-        u8 bits3and4:2;
-        u8 function_version:2;
-        u8 bit7:1;
-        u8 function_number:8;
-} __attribute__((__packed__));
-
-static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count)
-{
-        return GENMASK(irq_count + irq_base - 1, irq_base);
-}
-
-static void rmi_register_function(struct rmi_data *data,
-        struct pdt_entry *pdt_entry, int page, unsigned interrupt_count)
-{
-        struct rmi_function *f = NULL;
-        u16 page_base = page << 8;
-
-        switch (pdt_entry->function_number) {
-        case 0x01:
-                f = &data->f01;
-                break;
-        case 0x11:
-                f = &data->f11;
-                break;
-        case 0x30:
-                f = &data->f30;
-                break;
-        }
-
-        if (f) {
-                f->page = page;
-                f->query_base_addr = page_base | pdt_entry->query_base_addr;
-                f->command_base_addr = page_base | pdt_entry->command_base_addr;
-                f->control_base_addr = page_base | pdt_entry->control_base_addr;
-                f->data_base_addr = page_base | pdt_entry->data_base_addr;
-                f->interrupt_base = interrupt_count;
-                f->interrupt_count = pdt_entry->interrupt_source_count;
-                f->irq_mask = rmi_gen_mask(f->interrupt_base,
-                                                f->interrupt_count);
-                data->interrupt_enable_mask |= f->irq_mask;
-        }
-}
-
-static int rmi_scan_pdt(struct hid_device *hdev)
-{
-        struct rmi_data *data = hid_get_drvdata(hdev);
-        struct pdt_entry entry;
-        int page;
-        bool page_has_function;
-        int i;
-        int retval;
-        int interrupt = 0;
-        u16 page_start, pdt_start , pdt_end;
-
-        hid_info(hdev, "Scanning PDT...\n");
-
-        for (page = 0; (page <= RMI4_MAX_PAGE); page++) {
-                page_start = RMI4_PAGE_SIZE * page;
-                pdt_start = page_start + PDT_START_SCAN_LOCATION;
-                pdt_end = page_start + PDT_END_SCAN_LOCATION;
-
-                page_has_function = false;
-                for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) {
-                        retval = rmi_read_block(hdev, i, &entry, sizeof(entry));
-                        if (retval) {
-                                hid_err(hdev,
-                                        "Read of PDT entry at %#06x failed.\n",
-                                        i);
-                                goto error_exit;
-                        }
-
-                        if (RMI4_END_OF_PDT(entry.function_number))
-                                break;
-
-                        page_has_function = true;
-
-                        hid_info(hdev, "Found F%02X on page %#04x\n",
-                                        entry.function_number, page);
-
-                        rmi_register_function(data, &entry, page, interrupt);
-                        interrupt += entry.interrupt_source_count;
-                }
-
-                if (!page_has_function)
-                        break;
-        }
-
-        hid_info(hdev, "%s: Done with PDT scan.\n", __func__);
-        retval = 0;
-
-error_exit:
-        return retval;
-}
-
-#define RMI_DEVICE_F01_BASIC_QUERY_LEN  11
-
-static int rmi_populate_f01(struct hid_device *hdev)
-{
-        struct rmi_data *data = hid_get_drvdata(hdev);
-        u8 basic_queries[RMI_DEVICE_F01_BASIC_QUERY_LEN];
-        u8 info[3];
-        int ret;
-        bool has_query42;
-        bool has_lts;
-        bool has_sensor_id;
-        bool has_ds4_queries = false;
-        bool has_build_id_query = false;
-        bool has_package_id_query = false;
-        u16 query_offset = data->f01.query_base_addr;
-        u16 prod_info_addr;
-        u8 ds4_query_len;
-
-        ret = rmi_read_block(hdev, query_offset, basic_queries,
-                                RMI_DEVICE_F01_BASIC_QUERY_LEN);
-        if (ret) {
-                hid_err(hdev, "Can not read basic queries from Function 0x1.\n");
-                return ret;
-        }
-
-        has_lts = !!(basic_queries[0] & BIT(2));
-        has_sensor_id = !!(basic_queries[1] & BIT(3));
-        has_query42 = !!(basic_queries[1] & BIT(7));
-
-        query_offset += 11;
-        prod_info_addr = query_offset + 6;
-        query_offset += 10;
-
-        if (has_lts)
-                query_offset += 20;
-
-        if (has_sensor_id)
-                query_offset++;
-
-        if (has_query42) {
-                ret = rmi_read(hdev, query_offset, info);
-                if (ret) {
-                        hid_err(hdev, "Can not read query42.\n");
-                        return ret;
-                }
-                has_ds4_queries = !!(info[0] & BIT(0));
-                query_offset++;
-        }
-
-        if (has_ds4_queries) {
-                ret = rmi_read(hdev, query_offset, &ds4_query_len);
-                if (ret) {
-                        hid_err(hdev, "Can not read DS4 Query length.\n");
-                        return ret;
-                }
-                query_offset++;
-
-                if (ds4_query_len > 0) {
-                        ret = rmi_read(hdev, query_offset, info);
-                        if (ret) {
-                                hid_err(hdev, "Can not read DS4 query.\n");
-                                return ret;
-                        }
-
-                        has_package_id_query = !!(info[0] & BIT(0));
-                        has_build_id_query = !!(info[0] & BIT(1));
-                }
-        }
-
-        if (has_package_id_query)
-                prod_info_addr++;
-
-        if (has_build_id_query) {
-                ret = rmi_read_block(hdev, prod_info_addr, info, 3);
-                if (ret) {
-                        hid_err(hdev, "Can not read product info.\n");
-                        return ret;
-                }
-
-                data->firmware_id = info[1] << 8 | info[0];
-                data->firmware_id += info[2] * 65536;
-        }
-
-        ret = rmi_read_block(hdev, data->f01.control_base_addr, info,
-                                2);
-
-        if (ret) {
-                hid_err(hdev, "can not read f01 ctrl registers\n");
-                return ret;
-        }
-
-        data->f01_ctrl0 = info[0];
-
-        if (!info[1]) {
-                /*
-                 * Do to a firmware bug in some touchpads the F01 interrupt
-                 * enable control register will be cleared on reset.
-                 * This will stop the touchpad from reporting data, so
-                 * if F01 CTRL1 is 0 then we need to explicitly enable
-                 * interrupts for the functions we want data for.
-                 */
-                data->restore_interrupt_mask = true;
-
-                ret = rmi_write(hdev, data->f01.control_base_addr + 1,
-                                &data->interrupt_enable_mask);
-                if (ret) {
-                        hid_err(hdev, "can not write to control reg 1: %d.\n",
-                                ret);
-                        return ret;
-                }
-        }
-
-        return 0;
-}
-
-static int rmi_populate_f11(struct hid_device *hdev)
-{
-        struct rmi_data *data = hid_get_drvdata(hdev);
-        u8 buf[20];
-        int ret;
-        bool has_query9;
-        bool has_query10 = false;
-        bool has_query11;
-        bool has_query12;
-        bool has_query27;
-        bool has_query28;
-        bool has_query36 = false;
-        bool has_physical_props;
-        bool has_gestures;
-        bool has_rel;
-        bool has_data40 = false;
-        bool has_dribble = false;
-        bool has_palm_detect = false;
-        unsigned x_size, y_size;
-        u16 query_offset;
-
-        if (!data->f11.query_base_addr) {
-                hid_err(hdev, "No 2D sensor found, giving up.\n");
-                return -ENODEV;
-        }
-
-        /* query 0 contains some useful information */
-        ret = rmi_read(hdev, data->f11.query_base_addr, buf);
-        if (ret) {
-                hid_err(hdev, "can not get query 0: %d.\n", ret);
-                return ret;
-        }
-        has_query9 = !!(buf[0] & BIT(3));
-        has_query11 = !!(buf[0] & BIT(4));
-        has_query12 = !!(buf[0] & BIT(5));
-        has_query27 = !!(buf[0] & BIT(6));
-        has_query28 = !!(buf[0] & BIT(7));
-
-        /* query 1 to get the max number of fingers */
-        ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf);
-        if (ret) {
-                hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret);
-                return ret;
-        }
-        data->max_fingers = (buf[0] & 0x07) + 1;
-        if (data->max_fingers > 5)
-                data->max_fingers = 10;
-
-        data->f11.report_size = data->max_fingers * 5 +
-                                DIV_ROUND_UP(data->max_fingers, 4);
-
-        if (!(buf[0] & BIT(4))) {
-                hid_err(hdev, "No absolute events, giving up.\n");
-                return -ENODEV;
-        }
-
-        has_rel = !!(buf[0] & BIT(3));
-        has_gestures = !!(buf[0] & BIT(5));
-
-        ret = rmi_read(hdev, data->f11.query_base_addr + 5, buf);
-        if (ret) {
-                hid_err(hdev, "can not get absolute data sources: %d.\n", ret);
+        ret = rmi_reset_attn_mode(hdev);
+        if (ret)
                 return ret;
-        }
-
-        has_dribble = !!(buf[0] & BIT(4));
-
-        /*
-         * At least 4 queries are guaranteed to be present in F11
-         * +1 for query 5 which is present since absolute events are
-         * reported and +1 for query 12.
-         */
-        query_offset = 6;
-
-        if (has_rel)
-                ++query_offset; /* query 6 is present */
-
-        if (has_gestures) {
-                /* query 8 to find out if query 10 exists */
-                ret = rmi_read(hdev,
-                        data->f11.query_base_addr + query_offset + 1, buf);
-                if (ret) {
-                        hid_err(hdev, "can not read gesture information: %d.\n",
-                                ret);
-                        return ret;
-                }
-                has_palm_detect = !!(buf[0] & BIT(0));
-                has_query10 = !!(buf[0] & BIT(2));
-
-                query_offset += 2; /* query 7 and 8 are present */
-        }
-
-        if (has_query9)
-                ++query_offset;
-
-        if (has_query10)
-                ++query_offset;
-
-        if (has_query11)
-                ++query_offset;
-
-        /* query 12 to know if the physical properties are reported */
-        if (has_query12) {
-                ret = rmi_read(hdev, data->f11.query_base_addr
-                                + query_offset, buf);
-                if (ret) {
-                        hid_err(hdev, "can not get query 12: %d.\n", ret);
-                        return ret;
-                }
-                has_physical_props = !!(buf[0] & BIT(5));
-
-                if (has_physical_props) {
-                        query_offset += 1;
-                        ret = rmi_read_block(hdev,
-                                        data->f11.query_base_addr
-                                                + query_offset, buf, 4);
-                        if (ret) {
-                                hid_err(hdev, "can not read query 15-18: %d.\n",
-                                        ret);
-                                return ret;
-                        }
-
-                        x_size = buf[0] | (buf[1] << 8);
-                        y_size = buf[2] | (buf[3] << 8);
-
-                        data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10);
-                        data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10);
-
-                        hid_info(hdev, "%s: size in mm: %d x %d\n",
-                                 __func__, data->x_size_mm, data->y_size_mm);
-
-                        /*
-                         * query 15 - 18 contain the size of the sensor
-                         * and query 19 - 26 contain bezel dimensions
-                         */
-                        query_offset += 12;
-                }
-        }
-
-        if (has_query27)
-                ++query_offset;
 
-        if (has_query28) {
-                ret = rmi_read(hdev, data->f11.query_base_addr
-                                + query_offset, buf);
-                if (ret) {
-                        hid_err(hdev, "can not get query 28: %d.\n", ret);
-                        return ret;
-                }
-
-                has_query36 = !!(buf[0] & BIT(6));
-        }
-
-        if (has_query36) {
-                query_offset += 2;
-                ret = rmi_read(hdev, data->f11.query_base_addr
-                                + query_offset, buf);
-                if (ret) {
-                        hid_err(hdev, "can not get query 36: %d.\n", ret);
-                        return ret;
-                }
-
-                has_data40 = !!(buf[0] & BIT(5));
-        }
-
-
-        if (has_data40)
-                data->f11.report_size += data->max_fingers * 2;
-
-        ret = rmi_read_block(hdev, data->f11.control_base_addr,
-                        data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT);
+        ret = rmi_driver_resume(rmi_dev, false);
         if (ret) {
-                hid_err(hdev, "can not read ctrl block of size 11: %d.\n", ret);
+                hid_warn(hdev, "Failed to resume device: %d\n", ret);
                 return ret;
         }
 
-        /* data->f11_ctrl_regs now contains valid register data */
-        data->read_f11_ctrl_regs = true;
-
-        data->max_x = data->f11_ctrl_regs[6] | (data->f11_ctrl_regs[7] << 8);
-        data->max_y = data->f11_ctrl_regs[8] | (data->f11_ctrl_regs[9] << 8);
-
-        if (has_dribble) {
-                data->f11_ctrl_regs[0] = data->f11_ctrl_regs[0] & ~BIT(6);
-                ret = rmi_write(hdev, data->f11.control_base_addr,
-                                data->f11_ctrl_regs);
-                if (ret) {
-                        hid_err(hdev, "can not write to control reg 0: %d.\n",
-                                ret);
-                        return ret;
-                }
-        }
-
-        if (has_palm_detect) {
-                data->f11_ctrl_regs[11] = data->f11_ctrl_regs[11] & ~BIT(0);
-                ret = rmi_write(hdev, data->f11.control_base_addr + 11,
-                                &data->f11_ctrl_regs[11]);
-                if (ret) {
-                        hid_err(hdev, "can not write to control reg 11: %d.\n",
-                                ret);
-                        return ret;
-                }
-        }
-
-        return 0;
-}
-
-static int rmi_populate_f30(struct hid_device *hdev)
-{
-        struct rmi_data *data = hid_get_drvdata(hdev);
-        u8 buf[20];
-        int ret;
-        bool has_gpio, has_led;
-        unsigned bytes_per_ctrl;
-        u8 ctrl2_addr;
-        int ctrl2_3_length;
-        int i;
-
-        /* function F30 is for physical buttons */
-        if (!data->f30.query_base_addr) {
-                hid_err(hdev, "No GPIO/LEDs found, giving up.\n");
-                return -ENODEV;
-        }
-
-        ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2);
-        if (ret) {
-                hid_err(hdev, "can not get F30 query registers: %d.\n", ret);
-                return ret;
-        }
-
-        has_gpio = !!(buf[0] & BIT(3));
-        has_led = !!(buf[0] & BIT(2));
-        data->gpio_led_count = buf[1] & 0x1f;
-
-        /* retrieve ctrl 2 & 3 registers */
-        bytes_per_ctrl = (data->gpio_led_count + 7) / 8;
-        /* Ctrl0 is present only if both has_gpio and has_led are set*/
-        ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0;
-        /* Ctrl1 is always be present */
-        ctrl2_addr += bytes_per_ctrl;
-        ctrl2_3_length = 2 * bytes_per_ctrl;
-
-        data->f30.report_size = bytes_per_ctrl;
-
-        ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr,
-                                buf, ctrl2_3_length);
-        if (ret) {
-                hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n",
-                        ctrl2_3_length, ret);
-                return ret;
-        }
-
-        for (i = 0; i < data->gpio_led_count; i++) {
-                int byte_position = i >> 3;
-                int bit_position = i & 0x07;
-                u8 dir_byte = buf[byte_position];
-                u8 data_byte = buf[byte_position + bytes_per_ctrl];
-                bool dir = (dir_byte >> bit_position) & BIT(0);
-                bool dat = (data_byte >> bit_position) & BIT(0);
-
-                if (dir == 0) {
-                        /* input mode */
-                        if (dat) {
-                                /* actual buttons have pull up resistor */
-                                data->button_count++;
-                                set_bit(i, &data->button_mask);
-                                set_bit(i, &data->button_state_mask);
-                        }
-                }
-
-        }
-
         return 0;
 }
+#endif /* CONFIG_PM */
 
-static int rmi_populate(struct hid_device *hdev)
+static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr)
 {
-        struct rmi_data *data = hid_get_drvdata(hdev);
-        int ret;
-
-        ret = rmi_scan_pdt(hdev);
-        if (ret) {
-                hid_err(hdev, "PDT scan failed with code %d.\n", ret);
-                return ret;
-        }
-
-        ret = rmi_populate_f01(hdev);
-        if (ret) {
-                hid_err(hdev, "Error while initializing F01 (%d).\n", ret);
-                return ret;
-        }
-
-        ret = rmi_populate_f11(hdev);
-        if (ret) {
-                hid_err(hdev, "Error while initializing F11 (%d).\n", ret);
-                return ret;
-        }
-
-        if (!(data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)) {
-                ret = rmi_populate_f30(hdev);
-                if (ret)
-                        hid_warn(hdev, "Error while initializing F30 (%d).\n", ret);
-        }
+        struct rmi_data *data = container_of(xport, struct rmi_data, xport);
+        struct hid_device *hdev = data->hdev;
 
-        return 0;
+        return rmi_reset_attn_mode(hdev);
 }
 
 static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
 {
         struct rmi_data *data = hid_get_drvdata(hdev);
         struct input_dev *input = hi->input;
-        int ret;
-        int res_x, res_y, i;
+        int ret = 0;
+
+        if (!(data->device_flags & RMI_DEVICE))
+                return 0;
 
-        data->input = input;
+        data->xport.input = input;
 
         hid_dbg(hdev, "Opening low level driver\n");
         ret = hid_hw_open(hdev);
         if (ret)
                 return ret;
 
-        if (!(data->device_flags & RMI_DEVICE))
-                return 0;
-
         /* Allow incoming hid reports */
         hid_device_io_start(hdev);
 
@@ -1222,40 +489,10 @@ static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
                 goto exit;
         }
 
-        ret = rmi_populate(hdev);
-        if (ret)
-                goto exit;
-
-        hid_info(hdev, "firmware id: %ld\n", data->firmware_id);
-
-        __set_bit(EV_ABS, input->evbit);
-        input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0);
-        input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0);
-
-        if (data->x_size_mm && data->y_size_mm) {
-                res_x = (data->max_x - 1) / data->x_size_mm;
-                res_y = (data->max_y - 1) / data->y_size_mm;
-
-                input_abs_set_res(input, ABS_MT_POSITION_X, res_x);
-                input_abs_set_res(input, ABS_MT_POSITION_Y, res_y);
-        }
-
-        input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
-        input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0);
-        input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0);
-        input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0);
-
-        ret = input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER);
-        if (ret < 0)
+        ret = rmi_register_transport_device(&data->xport);
+        if (ret < 0) {
+                dev_err(&hdev->dev, "failed to register transport driver\n");
                 goto exit;
-
-        if (data->button_count) {
-                __set_bit(EV_KEY, input->evbit);
-                for (i = 0; i < data->button_count; i++)
-                        __set_bit(BTN_LEFT + i, input->keybit);
-
-                if (data->button_count == 1)
-                        __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
         }
 
         set_bit(RMI_STARTED, &data->flags);
@@ -1304,6 +541,71 @@ static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
         return 0;
 }
 
+static struct rmi_device_platform_data rmi_hid_pdata = {
+        .sensor_pdata = {
+                .sensor_type = rmi_sensor_touchpad,
+                .axis_align.flip_y = true,
+                .dribble = RMI_REG_STATE_ON,
+                .palm_detect = RMI_REG_STATE_OFF,
+        },
+};
+
+static const struct rmi_transport_ops hid_rmi_ops = {
+        .write_block    = rmi_hid_write_block,
+        .read_block     = rmi_hid_read_block,
+        .reset          = rmi_hid_reset,
+};
+
+static void rmi_irq_teardown(void *data)
+{
+        struct rmi_data *hdata = data;
+        struct irq_domain *domain = hdata->domain;
+
+        if (!domain)
+                return;
+
+        irq_dispose_mapping(irq_find_mapping(domain, 0));
+
+        irq_domain_remove(domain);
+        hdata->domain = NULL;
+        hdata->rmi_irq = 0;
+}
+
+static int rmi_irq_map(struct irq_domain *h, unsigned int virq,
+                       irq_hw_number_t hw_irq_num)
+{
+        irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
+
+        return 0;
+}
+
+static const struct irq_domain_ops rmi_irq_ops = {
+        .map = rmi_irq_map,
+};
+
+static int rmi_setup_irq_domain(struct hid_device *hdev)
+{
+        struct rmi_data *hdata = hid_get_drvdata(hdev);
+        int ret;
+
+        hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1,
+                                                 &rmi_irq_ops, hdata);
+        if (!hdata->domain)
+                return -ENOMEM;
+
+        ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata);
+        if (ret)
+                return ret;
+
+        hdata->rmi_irq = irq_create_mapping(hdata->domain, 0);
+        if (hdata->rmi_irq <= 0) {
+                hid_err(hdev, "Can't allocate an IRQ\n");
+                return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO;
+        }
+
+        return 0;
+}
+
 static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
         struct rmi_data *data = NULL;
@@ -1365,8 +667,8 @@ static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
 
         data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
         if (!data->writeReport) {
-                ret = -ENOMEM;
-                return ret;
+                hid_err(hdev, "failed to allocate buffer for HID reports\n");
+                return -ENOMEM;
         }
 
         data->readReport = data->writeReport + data->output_report_size;
@@ -1375,6 +677,21 @@ static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
 
         mutex_init(&data->page_mutex);
 
+        ret = rmi_setup_irq_domain(hdev);
+        if (ret) {
+                hid_err(hdev, "failed to allocate IRQ domain\n");
+                return ret;
+        }
+
+        if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)
+                rmi_hid_pdata.f30_data.disable = true;
+
+        data->xport.dev = hdev->dev.parent;
+        data->xport.pdata = rmi_hid_pdata;
+        data->xport.pdata.irq = data->rmi_irq;
+        data->xport.proto_name = "hid";
+        data->xport.ops = &hid_rmi_ops;
+
 start:
         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
         if (ret) {
@@ -1382,17 +699,6 @@ start:
                 return ret;
         }
 
-        if ((data->device_flags & RMI_DEVICE) &&
-            !test_bit(RMI_STARTED, &data->flags))
-                /*
-                 * The device maybe in the bootloader if rmi_input_configured
-                 * failed to find F11 in the PDT. Print an error, but don't
-                 * return an error from rmi_probe so that hidraw will be
-                 * accessible from userspace. That way a userspace tool
-                 * can be used to reload working firmware on the touchpad.
-                 */
-                hid_err(hdev, "Device failed to be properly configured\n");
-
         return 0;
 }
 
@@ -1401,6 +707,8 @@ static void rmi_remove(struct hid_device *hdev)
         struct rmi_data *hdata = hid_get_drvdata(hdev);
 
         clear_bit(RMI_STARTED, &hdata->flags);
+        cancel_work_sync(&hdata->reset_work);
+        rmi_unregister_transport_device(&hdata->xport);
 
         hid_hw_stop(hdev);
 }
@@ -1408,6 +716,7 @@ static void rmi_remove(struct hid_device *hdev)
 static const struct hid_device_id rmi_id[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
                 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
         { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
         { }
 };
@@ -1425,7 +734,7 @@ static struct hid_driver rmi_driver = {
 #ifdef CONFIG_PM
         .suspend                = rmi_suspend,
         .resume                 = rmi_post_resume,
-        .reset_resume           = rmi_post_reset,
+        .reset_resume           = rmi_post_resume,
 #endif
 };
 
diff --git a/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h b/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h
index ab68afcba2a2..a5897b9c0956 100644
--- a/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h
+++ b/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h
@@ -111,6 +111,14 @@
 #define IPC_ILUP_BIT                    (1<<IPC_ILUP_OFFS)
 
 /*
+ * ISH FW status bits in ISH FW Status Register
+ */
+#define IPC_ISH_FWSTS_SHIFT             12
+#define IPC_ISH_FWSTS_MASK              GENMASK(15, 12)
+#define IPC_GET_ISH_FWSTS(status)       \
+        (((status) & IPC_ISH_FWSTS_MASK) >> IPC_ISH_FWSTS_SHIFT)
+
+/*
  * FW status bits (relevant)
  */
 #define IPC_FWSTS_ILUP          0x1
diff --git a/drivers/hid/intel-ish-hid/ipc/hw-ish.h b/drivers/hid/intel-ish-hid/ipc/hw-ish.h
index 46615a03e78f..fd34307a7a70 100644
--- a/drivers/hid/intel-ish-hid/ipc/hw-ish.h
+++ b/drivers/hid/intel-ish-hid/ipc/hw-ish.h
@@ -61,6 +61,18 @@ struct ish_hw {
         void __iomem *mem_addr;
 };
 
+/*
+ * ISH FW status type
+ */
+enum {
+        FWSTS_AFTER_RESET               = 0,
+        FWSTS_WAIT_FOR_HOST             = 4,
+        FWSTS_START_KERNEL_DMA          = 5,
+        FWSTS_FW_IS_RUNNING             = 7,
+        FWSTS_SENSOR_APP_LOADED         = 8,
+        FWSTS_SENSOR_APP_RUNNING        = 15
+};
+
 #define to_ish_hw(dev) (struct ish_hw *)((dev)->hw)
 
 irqreturn_t ish_irq_handler(int irq, void *dev_id);
diff --git a/drivers/hid/intel-ish-hid/ipc/pci-ish.c b/drivers/hid/intel-ish-hid/ipc/pci-ish.c
index 20d647d2dd2c..8df81dc84529 100644
--- a/drivers/hid/intel-ish-hid/ipc/pci-ish.c
+++ b/drivers/hid/intel-ish-hid/ipc/pci-ish.c
@@ -24,7 +24,6 @@
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
-#include <linux/miscdevice.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/intel_ish.h>
 #include "ishtp-dev.h"
@@ -47,7 +46,8 @@ MODULE_DEVICE_TABLE(pci, ish_pci_tbl);
  *
  * Callback to direct log messages to Linux trace buffers
  */
-static void ish_event_tracer(struct ishtp_device *dev, char *format, ...)
+static __printf(2, 3)
+void ish_event_tracer(struct ishtp_device *dev, const char *format, ...)
 {
         if (trace_ishtp_dump_enabled()) {
                 va_list args;
@@ -205,12 +205,15 @@ static void ish_remove(struct pci_dev *pdev)
 #ifdef CONFIG_PM
 static struct device *ish_resume_device;
 
+/* 50ms to get resume response */
+#define WAIT_FOR_RESUME_ACK_MS          50
+
 /**
  * ish_resume_handler() - Work function to complete resume
  * @work:       work struct
  *
  * The resume work function to complete resume function asynchronously.
- * There are two types of platforms, one where ISH is not powered off,
+ * There are two resume paths, one where ISH is not powered off,
  * in that case a simple resume message is enough, others we need
  * a reset sequence.
  */
@@ -218,20 +221,31 @@ static void ish_resume_handler(struct work_struct *work)
 {
         struct pci_dev *pdev = to_pci_dev(ish_resume_device);
         struct ishtp_device *dev = pci_get_drvdata(pdev);
+        uint32_t fwsts;
         int ret;
 
-        ishtp_send_resume(dev);
+        /* Get ISH FW status */
+        fwsts = IPC_GET_ISH_FWSTS(dev->ops->get_fw_status(dev));
 
-        /* 50 ms to get resume response */
-        if (dev->resume_flag)
-                ret = wait_event_interruptible_timeout(dev->resume_wait,
-                                                       !dev->resume_flag,
-                                                       msecs_to_jiffies(50));
+        /*
+         * If currently, in ISH FW, sensor app is loaded or beyond that,
+         * it means ISH isn't powered off, in this case, send a resume message.
+         */
+        if (fwsts >= FWSTS_SENSOR_APP_LOADED) {
+                ishtp_send_resume(dev);
+
+                /* Waiting to get resume response */
+                if (dev->resume_flag)
+                        ret = wait_event_interruptible_timeout(dev->resume_wait,
+                                !dev->resume_flag,
+                                msecs_to_jiffies(WAIT_FOR_RESUME_ACK_MS));
+        }
 
         /*
-         * If no resume response. This platform  is not S0ix compatible
-         * So on resume full reboot of ISH processor will happen, so
-         * need to go through init sequence again
+         * If in ISH FW, sensor app isn't loaded yet, or no resume response.
+         * That means this platform is not S0ix compatible, or something is
+         * wrong with ISH FW. So on resume, full reboot of ISH processor will
+         * happen, so need to go through init sequence again.
          */
         if (dev->resume_flag)
                 ish_init(dev);
diff --git a/drivers/hid/intel-ish-hid/ishtp-hid.c b/drivers/hid/intel-ish-hid/ishtp-hid.c
index 277983aa1d90..cd23903ddcf1 100644
--- a/drivers/hid/intel-ish-hid/ishtp-hid.c
+++ b/drivers/hid/intel-ish-hid/ishtp-hid.c
@@ -208,7 +208,7 @@ int ishtp_hid_probe(unsigned int cur_hid_dev,
         hid->version = le16_to_cpu(ISH_HID_VERSION);
         hid->vendor = le16_to_cpu(ISH_HID_VENDOR);
         hid->product = le16_to_cpu(ISH_HID_PRODUCT);
-        snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX", "hid-ishtp",
+        snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-ishtp",
                 hid->vendor, hid->product);
 
         rv = hid_add_device(hid);
diff --git a/drivers/hid/intel-ish-hid/ishtp/bus.c b/drivers/hid/intel-ish-hid/ishtp/bus.c
index f4cbc744e657..5f382fedc2ab 100644
--- a/drivers/hid/intel-ish-hid/ishtp/bus.c
+++ b/drivers/hid/intel-ish-hid/ishtp/bus.c
@@ -358,7 +358,7 @@ static void ishtp_cl_dev_release(struct device *dev)
         kfree(to_ishtp_cl_device(dev));
 }
 
-static struct device_type ishtp_cl_device_type = {
+static const struct device_type ishtp_cl_device_type = {
         .release        = ishtp_cl_dev_release,
 };
 
diff --git a/drivers/hid/intel-ish-hid/ishtp/hbm.c b/drivers/hid/intel-ish-hid/ishtp/hbm.c
index 59460b66e689..b7213608ce43 100644
--- a/drivers/hid/intel-ish-hid/ishtp/hbm.c
+++ b/drivers/hid/intel-ish-hid/ishtp/hbm.c
@@ -19,7 +19,6 @@
 #include <linux/sched.h>
 #include <linux/wait.h>
 #include <linux/spinlock.h>
-#include <linux/miscdevice.h>
 #include "ishtp-dev.h"
 #include "hbm.h"
 #include "client.h"
diff --git a/drivers/hid/intel-ish-hid/ishtp/init.c b/drivers/hid/intel-ish-hid/ishtp/init.c
index ac364418e17c..d27e03526acd 100644
--- a/drivers/hid/intel-ish-hid/ishtp/init.c
+++ b/drivers/hid/intel-ish-hid/ishtp/init.c
@@ -16,7 +16,6 @@
 #include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
-#include <linux/miscdevice.h>
 #include "ishtp-dev.h"
 #include "hbm.h"
 #include "client.h"
diff --git a/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h b/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h
index a94f9a8a96a0..6a6d927b78b0 100644
--- a/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h
+++ b/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h
@@ -238,7 +238,8 @@ struct ishtp_device {
         uint64_t ishtp_host_dma_rx_buf_phys;
 
         /* Dump to trace buffers if enabled*/
-        void (*print_log)(struct ishtp_device *dev, char *format, ...);
+        __printf(2, 3) void (*print_log)(struct ishtp_device *dev,
+                                         const char *format, ...);
 
         /* Debug stats */
         unsigned int    ipc_rx_cnt;
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 333108ef18cf..961bc6fdd2d9 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -43,7 +43,6 @@
  */
 
 #define DRIVER_DESC "USB HID core driver"
-#define DRIVER_LICENSE "GPL"
 
 /*
  * Module parameters.
@@ -1660,4 +1659,4 @@ MODULE_AUTHOR("Andreas Gal");
 MODULE_AUTHOR("Vojtech Pavlik");
 MODULE_AUTHOR("Jiri Kosina");
 MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE(DRIVER_LICENSE);
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 30a2977e2645..d6847a664446 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -85,7 +85,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_WIIU, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR, HID_QUIRK_MULTI_INPUT },
-        { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_ELAN, HID_ANY_ID, HID_QUIRK_ALWAYS_POLL },
         { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_FORMOSA, USB_DEVICE_ID_FORMOSA_IR_RECEIVER, HID_QUIRK_NO_INIT_REPORTS },
@@ -103,12 +103,6 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2, HID_QUIRK_NO_INIT_REPORTS },
         { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2, HID_QUIRK_NO_INIT_REPORTS },
         { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2, HID_QUIRK_NO_INIT_REPORTS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3, HID_QUIRK_NO_INIT_REPORTS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2, HID_QUIRK_NO_INIT_REPORTS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP, HID_QUIRK_NO_INIT_REPORTS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4, HID_QUIRK_NO_INIT_REPORTS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2, HID_QUIRK_NO_INIT_REPORTS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP, HID_QUIRK_NO_INIT_REPORTS },
         { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER, HID_QUIRK_NO_INIT_REPORTS },
         { USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL, HID_QUIRK_NO_INIT_REPORTS },
         { USB_VENDOR_ID_NEXIO, USB_DEVICE_ID_NEXIO_MULTITOUCH_PTI0750, HID_QUIRK_NO_INIT_REPORTS },
@@ -297,7 +291,7 @@ static void usbhid_remove_all_dquirks(void)
 
 }
 
-/** 
+/**
  * usbhid_quirks_init: apply USB HID quirks specified at module load time
  */
 int usbhid_quirks_init(char **quirks_param)
@@ -361,7 +355,7 @@ static const struct hid_blacklist *usbhid_exists_squirk(const u16 idVendor,
 
         if (bl_entry != NULL)
                 dbg_hid("Found squirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
-                                bl_entry->quirks, bl_entry->idVendor, 
+                                bl_entry->quirks, bl_entry->idVendor,
                                 bl_entry->idProduct);
         return bl_entry;
 }
diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c
index 9a332e683db7..7fb2d1e4f5dd 100644
--- a/drivers/hid/usbhid/usbkbd.c
+++ b/drivers/hid/usbhid/usbkbd.c
@@ -39,11 +39,10 @@
 #define DRIVER_VERSION ""
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB HID Boot Protocol keyboard driver"
-#define DRIVER_LICENSE "GPL"
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE(DRIVER_LICENSE);
+MODULE_LICENSE("GPL");
 
 static const unsigned char usb_kbd_keycode[256] = {
           0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
diff --git a/drivers/hid/usbhid/usbmouse.c b/drivers/hid/usbhid/usbmouse.c
index bf16d72dc370..dd911c5241d8 100644
--- a/drivers/hid/usbhid/usbmouse.c
+++ b/drivers/hid/usbhid/usbmouse.c
@@ -42,11 +42,10 @@
 #define DRIVER_VERSION "v1.6"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB HID Boot Protocol mouse driver"
-#define DRIVER_LICENSE "GPL"
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE(DRIVER_LICENSE);
+MODULE_LICENSE("GPL");
 
 struct usb_mouse {
         char name[128];
diff --git a/drivers/hid/wacom.h b/drivers/hid/wacom.h
index d303e413306d..38ee2125412f 100644
--- a/drivers/hid/wacom.h
+++ b/drivers/hid/wacom.h
@@ -102,7 +102,6 @@
 #define DRIVER_VERSION "v2.00"
 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
 #define DRIVER_DESC "USB Wacom tablet driver"
-#define DRIVER_LICENSE "GPL"
 
 #define USB_VENDOR_ID_WACOM     0x056a
 #define USB_VENDOR_ID_LENOVO    0x17ef
@@ -166,7 +165,9 @@ struct wacom {
         struct work_struct wireless_work;
         struct work_struct battery_work;
         struct work_struct remote_work;
+        struct delayed_work init_work;
         struct wacom_remote *remote;
+        bool generic_has_leds;
         struct wacom_leds {
                 struct wacom_group_leds *groups;
                 unsigned int count;
@@ -218,4 +219,6 @@ enum led_brightness wacom_leds_brightness_get(struct wacom_led *led);
 struct wacom_led *wacom_led_find(struct wacom *wacom, unsigned int group,
                                  unsigned int id);
 struct wacom_led *wacom_led_next(struct wacom *wacom, struct wacom_led *cur);
+int wacom_equivalent_usage(int usage);
+int wacom_initialize_leds(struct wacom *wacom);
 #endif
diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
index 8aeca038cc73..be8f7e2a026f 100644
--- a/drivers/hid/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -16,15 +16,7 @@
 #include <linux/input/mt.h>
 
 #define WAC_MSG_RETRIES         5
-
-#define WAC_CMD_WL_LED_CONTROL  0x03
-#define WAC_CMD_LED_CONTROL     0x20
-#define WAC_CMD_ICON_START      0x21
-#define WAC_CMD_ICON_XFER       0x23
-#define WAC_CMD_ICON_BT_XFER    0x26
 #define WAC_CMD_RETRIES         10
-#define WAC_CMD_DELETE_PAIRING  0x20
-#define WAC_CMD_UNPAIR_ALL      0xFF
 
 #define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP)
 #define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP)
@@ -120,11 +112,12 @@ static void wacom_feature_mapping(struct hid_device *hdev,
         struct wacom *wacom = hid_get_drvdata(hdev);
         struct wacom_features *features = &wacom->wacom_wac.features;
         struct hid_data *hid_data = &wacom->wacom_wac.hid_data;
+        unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
         u8 *data;
         int ret;
         int n;
 
-        switch (usage->hid) {
+        switch (equivalent_usage) {
         case HID_DG_CONTACTMAX:
                 /* leave touch_max as is if predefined */
                 if (!features->touch_max) {
@@ -333,8 +326,14 @@ static void wacom_post_parse_hid(struct hid_device *hdev,
         if (features->type == HID_GENERIC) {
                 /* Any last-minute generic device setup */
                 if (features->touch_max > 1) {
-                        input_mt_init_slots(wacom_wac->touch_input, wacom_wac->features.touch_max,
-                                    INPUT_MT_DIRECT);
+                        if (features->device_type & WACOM_DEVICETYPE_DIRECT)
+                                input_mt_init_slots(wacom_wac->touch_input,
+                                                    wacom_wac->features.touch_max,
+                                                    INPUT_MT_DIRECT);
+                        else
+                                input_mt_init_slots(wacom_wac->touch_input,
+                                                    wacom_wac->features.touch_max,
+                                                    INPUT_MT_POINTER);
                 }
         }
 }
@@ -497,11 +496,11 @@ static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
  * from the tablet, it is necessary to switch the tablet out of this
  * mode and into one which sends the full range of tablet data.
  */
-static int wacom_query_tablet_data(struct hid_device *hdev,
-                struct wacom_features *features)
+static int _wacom_query_tablet_data(struct wacom *wacom)
 {
-        struct wacom *wacom = hid_get_drvdata(hdev);
+        struct hid_device *hdev = wacom->hdev;
         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+        struct wacom_features *features = &wacom_wac->features;
 
         if (hdev->bus == BUS_BLUETOOTH)
                 return wacom_bt_query_tablet_data(hdev, 1, features);
@@ -757,9 +756,6 @@ static int wacom_led_control(struct wacom *wacom)
         unsigned char report_id = WAC_CMD_LED_CONTROL;
         int buf_size = 9;
 
-        if (!hid_get_drvdata(wacom->hdev))
-                return -ENODEV;
-
         if (!wacom->led.groups)
                 return -ENOTSUPP;
 
@@ -767,12 +763,21 @@ static int wacom_led_control(struct wacom *wacom)
                 report_id = WAC_CMD_WL_LED_CONTROL;
                 buf_size = 13;
         }
+        else if (wacom->wacom_wac.features.type == INTUOSP2_BT) {
+                report_id = WAC_CMD_WL_INTUOSP2;
+                buf_size = 51;
+        }
         buf = kzalloc(buf_size, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
 
-        if (wacom->wacom_wac.features.type >= INTUOS5S &&
-            wacom->wacom_wac.features.type <= INTUOSPL) {
+        if (wacom->wacom_wac.features.type == HID_GENERIC) {
+                buf[0] = WAC_CMD_LED_CONTROL_GENERIC;
+                buf[1] = wacom->led.llv;
+                buf[2] = wacom->led.groups[0].select & 0x03;
+
+        } else if ((wacom->wacom_wac.features.type >= INTUOS5S &&
+            wacom->wacom_wac.features.type <= INTUOSPL)) {
                 /*
                  * Touch Ring and crop mark LED luminance may take on
                  * one of four values:
@@ -792,6 +797,16 @@ static int wacom_led_control(struct wacom *wacom)
                 } else
                         buf[1] = led_bits;
         }
+        else if (wacom->wacom_wac.features.type == INTUOSP2_BT) {
+                buf[0] = report_id;
+                buf[4] = 100; // Power Connection LED (ORANGE)
+                buf[5] = 100; // BT Connection LED (BLUE)
+                buf[6] = 100; // Paper Mode (RED?)
+                buf[7] = 100; // Paper Mode (GREEN?)
+                buf[8] = 100; // Paper Mode (BLUE?)
+                buf[9] = wacom->led.llv;
+                buf[10] = wacom->led.groups[0].select & 0x03;
+        }
         else {
                 int led = wacom->led.groups[0].select | 0x4;
 
@@ -1032,6 +1047,17 @@ static struct attribute_group intuos5_led_attr_group = {
         .attrs = intuos5_led_attrs,
 };
 
+static struct attribute *generic_led_attrs[] = {
+        &dev_attr_status0_luminance.attr,
+        &dev_attr_status_led0_select.attr,
+        NULL
+};
+
+static struct attribute_group generic_led_attr_group = {
+        .name = "wacom_led",
+        .attrs = generic_led_attrs,
+};
+
 struct wacom_sysfs_group_devres {
         struct attribute_group *group;
         struct kobject *root;
@@ -1353,7 +1379,7 @@ static int wacom_leds_alloc_and_register(struct wacom *wacom, int group_count,
         return 0;
 }
 
-static int wacom_initialize_leds(struct wacom *wacom)
+int wacom_initialize_leds(struct wacom *wacom)
 {
         int error;
 
@@ -1362,6 +1388,23 @@ static int wacom_initialize_leds(struct wacom *wacom)
 
         /* Initialize default values */
         switch (wacom->wacom_wac.features.type) {
+        case HID_GENERIC:
+                if (!wacom->generic_has_leds)
+                        return 0;
+                wacom->led.llv = 100;
+                wacom->led.max_llv = 100;
+
+                error = wacom_leds_alloc_and_register(wacom, 1, 4, false);
+                if (error) {
+                        hid_err(wacom->hdev,
+                                "cannot create leds err: %d\n", error);
+                        return error;
+                }
+
+                error = wacom_devm_sysfs_create_group(wacom,
+                                                      &generic_led_attr_group);
+                break;
+
         case INTUOS4S:
         case INTUOS4:
         case INTUOS4WL:
@@ -1420,6 +1463,17 @@ static int wacom_initialize_leds(struct wacom *wacom)
                                                       &intuos5_led_attr_group);
                 break;
 
+        case INTUOSP2_BT:
+                wacom->led.llv = 50;
+                wacom->led.max_llv = 100;
+                error = wacom_leds_alloc_and_register(wacom, 1, 4, false);
+                if (error) {
+                        hid_err(wacom->hdev,
+                                "cannot create leds err: %d\n", error);
+                        return error;
+                }
+                return 0;
+
         case REMOTE:
                 wacom->led.llv = 255;
                 wacom->led.max_llv = 255;
@@ -1440,11 +1494,23 @@ static int wacom_initialize_leds(struct wacom *wacom)
                         "cannot create sysfs group err: %d\n", error);
                 return error;
         }
-        wacom_led_control(wacom);
 
         return 0;
 }
 
+static void wacom_init_work(struct work_struct *work)
+{
+        struct wacom *wacom = container_of(work, struct wacom, init_work.work);
+
+        _wacom_query_tablet_data(wacom);
+        wacom_led_control(wacom);
+}
+
+static void wacom_query_tablet_data(struct wacom *wacom)
+{
+        schedule_delayed_work(&wacom->init_work, msecs_to_jiffies(1000));
+}
+
 static enum power_supply_property wacom_battery_props[] = {
         POWER_SUPPLY_PROP_MODEL_NAME,
         POWER_SUPPLY_PROP_PRESENT,
@@ -2020,6 +2086,24 @@ static void wacom_release_resources(struct wacom *wacom)
         wacom->wacom_wac.pad_input = NULL;
 }
 
+static void wacom_set_shared_values(struct wacom_wac *wacom_wac)
+{
+        if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) {
+                wacom_wac->shared->type = wacom_wac->features.type;
+                wacom_wac->shared->touch_input = wacom_wac->touch_input;
+        }
+
+        if (wacom_wac->has_mute_touch_switch)
+                wacom_wac->shared->has_mute_touch_switch = true;
+
+        if (wacom_wac->shared->has_mute_touch_switch &&
+            wacom_wac->shared->touch_input) {
+                set_bit(EV_SW, wacom_wac->shared->touch_input->evbit);
+                input_set_capability(wacom_wac->shared->touch_input, EV_SW,
+                                     SW_MUTE_DEVICE);
+        }
+}
+
 static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
 {
         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
@@ -2118,7 +2202,7 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
 
         if (!wireless) {
                 /* Note that if query fails it is not a hard failure */
-                wacom_query_tablet_data(hdev, features);
+                wacom_query_tablet_data(wacom);
         }
 
         /* touch only Bamboo doesn't support pen */
@@ -2139,13 +2223,7 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless)
         if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR)
                 error = hid_hw_open(hdev);
 
-        if ((wacom_wac->features.type == INTUOSHT ||
-             wacom_wac->features.type == INTUOSHT2) &&
-            (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)) {
-                wacom_wac->shared->type = wacom_wac->features.type;
-                wacom_wac->shared->touch_input = wacom_wac->touch_input;
-        }
-
+        wacom_set_shared_values(wacom_wac);
         devres_close_group(&hdev->dev, wacom);
 
         return 0;
@@ -2450,6 +2528,7 @@ static int wacom_probe(struct hid_device *hdev,
         wacom->usbdev = dev;
         wacom->intf = intf;
         mutex_init(&wacom->lock);
+        INIT_DELAYED_WORK(&wacom->init_work, wacom_init_work);
         INIT_WORK(&wacom->wireless_work, wacom_wireless_work);
         INIT_WORK(&wacom->battery_work, wacom_battery_work);
         INIT_WORK(&wacom->remote_work, wacom_remote_work);
@@ -2491,12 +2570,17 @@ static void wacom_remove(struct hid_device *hdev)
 
         hid_hw_stop(hdev);
 
+        cancel_delayed_work_sync(&wacom->init_work);
         cancel_work_sync(&wacom->wireless_work);
         cancel_work_sync(&wacom->battery_work);
         cancel_work_sync(&wacom->remote_work);
         if (hdev->bus == BUS_BLUETOOTH)
                 device_remove_file(&hdev->dev, &dev_attr_speed);
 
+        /* make sure we don't trigger the LEDs */
+        wacom_led_groups_release(wacom);
+        wacom_release_resources(wacom);
+
         hid_set_drvdata(hdev, NULL);
 }
 
@@ -2504,12 +2588,11 @@ static void wacom_remove(struct hid_device *hdev)
 static int wacom_resume(struct hid_device *hdev)
 {
         struct wacom *wacom = hid_get_drvdata(hdev);
-        struct wacom_features *features = &wacom->wacom_wac.features;
 
         mutex_lock(&wacom->lock);
 
         /* switch to wacom mode first */
-        wacom_query_tablet_data(hdev, features);
+        _wacom_query_tablet_data(wacom);
         wacom_led_control(wacom);
 
         mutex_unlock(&wacom->lock);
@@ -2540,4 +2623,4 @@ module_hid_driver(wacom_driver);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE(DRIVER_LICENSE);
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
index 672145b0d8f5..4aa3de9f1163 100644
--- a/drivers/hid/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -43,6 +43,8 @@ static void wacom_report_numbered_buttons(struct input_dev *input_dev,
 
 static int wacom_numbered_button_to_key(int n);
 
+static void wacom_update_led(struct wacom *wacom, int button_count, int mask,
+                             int group);
 /*
  * Percent of battery capacity for Graphire.
  * 8th value means AC online and show 100% capacity.
@@ -1192,6 +1194,166 @@ static int wacom_wac_finger_count_touches(struct wacom_wac *wacom)
         return count;
 }
 
+static void wacom_intuos_pro2_bt_pen(struct wacom_wac *wacom)
+{
+        const int pen_frame_len = 14;
+        const int pen_frames = 7;
+
+        struct input_dev *pen_input = wacom->pen_input;
+        unsigned char *data = wacom->data;
+        int i;
+
+        wacom->serial[0] = get_unaligned_le64(&data[99]);
+        wacom->id[0]     = get_unaligned_le16(&data[107]);
+        if (wacom->serial[0] >> 52 == 1) {
+                /* Add back in missing bits of ID for non-USI pens */
+                wacom->id[0] |= (wacom->serial[0] >> 32) & 0xFFFFF;
+        }
+        wacom->tool[0]   = wacom_intuos_get_tool_type(wacom_intuos_id_mangle(wacom->id[0]));
+
+        for (i = 0; i < pen_frames; i++) {
+                unsigned char *frame = &data[i*pen_frame_len + 1];
+                bool valid = frame[0] & 0x80;
+                bool prox = frame[0] & 0x40;
+                bool range = frame[0] & 0x20;
+
+                if (!valid)
+                        continue;
+
+                if (range) {
+                        input_report_abs(pen_input, ABS_X, get_unaligned_le16(&frame[1]));
+                        input_report_abs(pen_input, ABS_Y, get_unaligned_le16(&frame[3]));
+                        input_report_abs(pen_input, ABS_TILT_X, frame[7]);
+                        input_report_abs(pen_input, ABS_TILT_Y, frame[8]);
+                        input_report_abs(pen_input, ABS_Z, get_unaligned_le16(&frame[9]));
+                        input_report_abs(pen_input, ABS_WHEEL, get_unaligned_le16(&frame[11]));
+                }
+                input_report_abs(pen_input, ABS_PRESSURE, get_unaligned_le16(&frame[5]));
+                input_report_abs(pen_input, ABS_DISTANCE, range ? frame[13] : wacom->features.distance_max);
+
+                input_report_key(pen_input, BTN_TOUCH, frame[0] & 0x01);
+                input_report_key(pen_input, BTN_STYLUS, frame[0] & 0x02);
+                input_report_key(pen_input, BTN_STYLUS2, frame[0] & 0x04);
+
+                input_report_key(pen_input, wacom->tool[0], prox);
+                input_event(pen_input, EV_MSC, MSC_SERIAL, wacom->serial[0]);
+                input_report_abs(pen_input, ABS_MISC,
+                                 wacom_intuos_id_mangle(wacom->id[0])); /* report tool id */
+
+                wacom->shared->stylus_in_proximity = prox;
+
+                input_sync(pen_input);
+        }
+}
+
+static void wacom_intuos_pro2_bt_touch(struct wacom_wac *wacom)
+{
+        const int finger_touch_len = 8;
+        const int finger_frames = 4;
+        const int finger_frame_len = 43;
+
+        struct input_dev *touch_input = wacom->touch_input;
+        unsigned char *data = wacom->data;
+        int num_contacts_left = 5;
+        int i, j;
+
+        for (i = 0; i < finger_frames; i++) {
+                unsigned char *frame = &data[i*finger_frame_len + 109];
+                int current_num_contacts = frame[0] & 0x7F;
+                int contacts_to_send;
+
+                if (!(frame[0] & 0x80))
+                        continue;
+
+                /*
+                 * First packet resets the counter since only the first
+                 * packet in series will have non-zero current_num_contacts.
+                 */
+                if (current_num_contacts)
+                        wacom->num_contacts_left = current_num_contacts;
+
+                contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
+
+                for (j = 0; j < contacts_to_send; j++) {
+                        unsigned char *touch = &frame[j*finger_touch_len + 1];
+                        int slot = input_mt_get_slot_by_key(touch_input, touch[0]);
+                        int x = get_unaligned_le16(&touch[2]);
+                        int y = get_unaligned_le16(&touch[4]);
+                        int w = touch[6] * input_abs_get_res(touch_input, ABS_MT_POSITION_X);
+                        int h = touch[7] * input_abs_get_res(touch_input, ABS_MT_POSITION_Y);
+
+                        if (slot < 0)
+                                continue;
+
+                        input_mt_slot(touch_input, slot);
+                        input_mt_report_slot_state(touch_input, MT_TOOL_FINGER, touch[1] & 0x01);
+                        input_report_abs(touch_input, ABS_MT_POSITION_X, x);
+                        input_report_abs(touch_input, ABS_MT_POSITION_Y, y);
+                        input_report_abs(touch_input, ABS_MT_TOUCH_MAJOR, max(w, h));
+                        input_report_abs(touch_input, ABS_MT_TOUCH_MINOR, min(w, h));
+                        input_report_abs(touch_input, ABS_MT_ORIENTATION, w > h);
+                }
+
+                input_mt_sync_frame(touch_input);
+
+                wacom->num_contacts_left -= contacts_to_send;
+                if (wacom->num_contacts_left <= 0) {
+                        wacom->num_contacts_left = 0;
+                        wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
+                }
+        }
+
+        input_report_switch(touch_input, SW_MUTE_DEVICE, !(data[281] >> 7));
+        input_sync(touch_input);
+}
+
+static void wacom_intuos_pro2_bt_pad(struct wacom_wac *wacom)
+{
+        struct input_dev *pad_input = wacom->pad_input;
+        unsigned char *data = wacom->data;
+
+        int buttons = (data[282] << 1) | ((data[281] >> 6) & 0x01);
+        int ring = data[285];
+        int prox = buttons | (ring & 0x80);
+
+        wacom_report_numbered_buttons(pad_input, 9, buttons);
+
+        input_report_abs(pad_input, ABS_WHEEL, (ring & 0x80) ? (ring & 0x7f) : 0);
+
+        input_report_key(pad_input, wacom->tool[1], prox ? 1 : 0);
+        input_report_abs(pad_input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
+        input_event(pad_input, EV_MSC, MSC_SERIAL, 0xffffffff);
+
+        input_sync(pad_input);
+}
+
+static void wacom_intuos_pro2_bt_battery(struct wacom_wac *wacom)
+{
+        unsigned char *data = wacom->data;
+
+        bool chg = data[284] & 0x80;
+        int battery_status = data[284] & 0x7F;
+
+        wacom_notify_battery(wacom, battery_status, chg, 1, chg);
+}
+
+static int wacom_intuos_pro2_bt_irq(struct wacom_wac *wacom, size_t len)
+{
+        unsigned char *data = wacom->data;
+
+        if (data[0] != 0x80) {
+                dev_dbg(wacom->pen_input->dev.parent,
+                        "%s: received unknown report #%d\n", __func__, data[0]);
+                return 0;
+        }
+
+        wacom_intuos_pro2_bt_pen(wacom);
+        wacom_intuos_pro2_bt_touch(wacom);
+        wacom_intuos_pro2_bt_pad(wacom);
+        wacom_intuos_pro2_bt_battery(wacom);
+        return 0;
+}
+
 static int wacom_24hdt_irq(struct wacom_wac *wacom)
 {
         struct input_dev *input = wacom->touch_input;
@@ -1446,7 +1608,7 @@ static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
         return 0;
 }
 
-static int wacom_equivalent_usage(int usage)
+int wacom_equivalent_usage(int usage)
 {
         if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMDIGITIZER) {
                 int subpage = (usage & 0xFF00) << 8;
@@ -1473,6 +1635,16 @@ static int wacom_equivalent_usage(int usage)
                 return subpage | subusage;
         }
 
+        if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMTOUCH) {
+                int subpage = (usage & 0xFF00) << 8;
+                int subusage = (usage & 0xFF);
+
+                if (subpage == HID_UP_UNDEFINED)
+                        subpage = WACOM_HID_SP_DIGITIZER;
+
+                return subpage | subusage;
+        }
+
         return usage;
 }
 
@@ -1552,12 +1724,14 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
                 wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0);
                 features->device_type |= WACOM_DEVICETYPE_PAD;
                 break;
+        case WACOM_HID_WD_BUTTONCENTER:
+                wacom->generic_has_leds = true;
+                /* fall through */
         case WACOM_HID_WD_BUTTONHOME:
         case WACOM_HID_WD_BUTTONUP:
         case WACOM_HID_WD_BUTTONDOWN:
         case WACOM_HID_WD_BUTTONLEFT:
         case WACOM_HID_WD_BUTTONRIGHT:
-        case WACOM_HID_WD_BUTTONCENTER:
                 wacom_map_usage(input, usage, field, EV_KEY,
                                 wacom_numbered_button_to_key(features->numbered_buttons),
                                 0);
@@ -1565,7 +1739,17 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
                 features->device_type |= WACOM_DEVICETYPE_PAD;
                 break;
         case WACOM_HID_WD_TOUCHONOFF:
-                wacom_map_usage(input, usage, field, EV_SW, SW_MUTE_DEVICE, 0);
+                /*
+                 * This usage, which is used to mute touch events, comes
+                 * from the pad packet, but is reported on the touch
+                 * interface. Because the touch interface may not have
+                 * been created yet, we cannot call wacom_map_usage(). In
+                 * order to process this usage when we receive it, we set
+                 * the usage type and code directly.
+                 */
+                wacom_wac->has_mute_touch_switch = true;
+                usage->type = EV_SW;
+                usage->code = SW_MUTE_DEVICE;
                 features->device_type |= WACOM_DEVICETYPE_PAD;
                 break;
         case WACOM_HID_WD_TOUCHSTRIP:
@@ -1580,6 +1764,10 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
                 wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
                 features->device_type |= WACOM_DEVICETYPE_PAD;
                 break;
+        case WACOM_HID_WD_TOUCHRINGSTATUS:
+                wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
+                features->device_type |= WACOM_DEVICETYPE_PAD;
+                break;
         }
 
         switch (equivalent_usage & 0xfffffff0) {
@@ -1622,17 +1810,40 @@ static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field
         struct input_dev *input = wacom_wac->pad_input;
         struct wacom_features *features = &wacom_wac->features;
         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
+        int i;
+
+        /*
+         * Avoid reporting this event and setting inrange_state if this usage
+         * hasn't been mapped.
+         */
+        if (!usage->type)
+                return;
 
         if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) {
-                wacom_wac->hid_data.inrange_state |= value;
+                if (usage->hid != WACOM_HID_WD_TOUCHRING)
+                        wacom_wac->hid_data.inrange_state |= value;
         }
 
         switch (equivalent_usage) {
         case WACOM_HID_WD_TOUCHRINGSTATUS:
+                if (!value)
+                        input_event(input, usage->type, usage->code, 0);
                 break;
 
+        case WACOM_HID_WD_TOUCHONOFF:
+                if (wacom_wac->shared->touch_input) {
+                        input_report_switch(wacom_wac->shared->touch_input,
+                                            SW_MUTE_DEVICE, !value);
+                        input_sync(wacom_wac->shared->touch_input);
+                }
+                break;
+
+        case WACOM_HID_WD_BUTTONCENTER:
+                for (i = 0; i < wacom->led.count; i++)
+                        wacom_update_led(wacom, features->numbered_buttons,
+                                         value, i);
+                 /* fall through*/
         default:
-                features->input_event_flag = true;
                 input_event(input, usage->type, usage->code, value);
                 break;
         }
@@ -1670,20 +1881,15 @@ static void wacom_wac_pad_report(struct hid_device *hdev,
 {
         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,
@@ -2058,8 +2264,10 @@ static void wacom_wac_finger_pre_report(struct hid_device *hdev,
 
                 for (j = 0; j < field->maxusage; j++) {
                         struct hid_usage *usage = &field->usage[j];
+                        unsigned int equivalent_usage =
+                                wacom_equivalent_usage(usage->hid);
 
-                        switch (usage->hid) {
+                        switch (equivalent_usage) {
                         case HID_GD_X:
                         case HID_GD_Y:
                         case HID_DG_WIDTH:
@@ -2068,7 +2276,7 @@ static void wacom_wac_finger_pre_report(struct hid_device *hdev,
                         case HID_DG_INRANGE:
                         case HID_DG_INVERT:
                         case HID_DG_TIPSWITCH:
-                                hid_data->last_slot_field = usage->hid;
+                                hid_data->last_slot_field = equivalent_usage;
                                 break;
                         case HID_DG_CONTACTCOUNT:
                                 hid_data->cc_report = report->id;
@@ -2123,8 +2331,8 @@ void wacom_wac_usage_mapping(struct hid_device *hdev,
         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
         struct wacom_features *features = &wacom_wac->features;
 
-        /* currently, only direct devices have proper hid report descriptors */
-        features->device_type |= WACOM_DEVICETYPE_DIRECT;
+        if (WACOM_DIRECT_DEVICE(field))
+                features->device_type |= WACOM_DEVICETYPE_DIRECT;
 
         if (WACOM_PAD_FIELD(field))
                 wacom_wac_pad_usage_mapping(hdev, field, usage);
@@ -2142,6 +2350,9 @@ void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
         if (wacom->wacom_wac.features.type != HID_GENERIC)
                 return;
 
+        if (value > field->logical_maximum || value < field->logical_minimum)
+                return;
+
         if (WACOM_PAD_FIELD(field)) {
                 wacom_wac_pad_battery_event(hdev, field, usage, value);
                 if (wacom->wacom_wac.pad_input)
@@ -2669,6 +2880,10 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
                         sync = wacom_intuos_irq(wacom_wac);
                 break;
 
+        case INTUOSP2_BT:
+                sync = wacom_intuos_pro2_bt_irq(wacom_wac, len);
+                break;
+
         case TABLETPC:
         case TABLETPCE:
         case TABLETPC2FG:
@@ -2779,8 +2994,6 @@ void wacom_setup_device_quirks(struct wacom *wacom)
         struct wacom_features *features = &wacom->wacom_wac.features;
 
         /* The pen and pad share the same interface on most devices */
-        if (features->numbered_buttons > 0)
-                features->device_type |= WACOM_DEVICETYPE_PAD;
         if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 ||
             features->type == DTUS ||
             (features->type >= INTUOS3S && features->type <= WACOM_MO)) {
@@ -2840,6 +3053,13 @@ void wacom_setup_device_quirks(struct wacom *wacom)
         if (features->type == REMOTE)
                 features->device_type = WACOM_DEVICETYPE_PAD;
 
+        if (features->type == INTUOSP2_BT) {
+                features->device_type |= WACOM_DEVICETYPE_PEN |
+                                         WACOM_DEVICETYPE_PAD |
+                                         WACOM_DEVICETYPE_TOUCH;
+                features->quirks |= WACOM_QUIRK_BATTERY;
+        }
+
         switch (features->type) {
         case PL:
         case DTU:
@@ -2986,6 +3206,7 @@ int wacom_setup_pen_input_capabilities(struct input_dev *input_dev,
         case INTUOSPL:
         case INTUOS5S:
         case INTUOSPS:
+        case INTUOSP2_BT:
                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
                                       features->distance_max,
                                       features->distance_fuzz, 0);
@@ -3094,6 +3315,27 @@ int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
         }
 
         switch (features->type) {
+        case INTUOSP2_BT:
+                input_dev->evbit[0] |= BIT_MASK(EV_SW);
+                __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
+
+                if (wacom_wac->shared->touch->product == 0x361) {
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+                                             0, 12440, 4, 0);
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+                                             0, 8640, 4, 0);
+                }
+                else if (wacom_wac->shared->touch->product == 0x360) {
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+                                             0, 8960, 4, 0);
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+                                             0, 5920, 4, 0);
+                }
+                input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
+                input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
+
+                /* fall through */
+
         case INTUOS5:
         case INTUOS5L:
         case INTUOSPM:
@@ -3290,6 +3532,9 @@ int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
 {
         struct wacom_features *features = &wacom_wac->features;
 
+        if ((features->type == HID_GENERIC) && features->numbered_buttons > 0)
+                features->device_type |= WACOM_DEVICETYPE_PAD;
+
         if (!(features->device_type & WACOM_DEVICETYPE_PAD))
                 return -ENODEV;
 
@@ -3391,6 +3636,7 @@ int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
         case INTUOSPL:
         case INTUOS5S:
         case INTUOSPS:
+        case INTUOSP2_BT:
                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
                 break;
 
@@ -3949,6 +4195,12 @@ static const struct wacom_features wacom_features_0x343 =
           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
+static const struct wacom_features wacom_features_0x360 =
+        { "Wacom Intuos Pro M", 44800, 29600, 8191, 63,
+          INTUOSP2_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 9, .touch_max = 10 };
+static const struct wacom_features wacom_features_0x361 =
+        { "Wacom Intuos Pro L", 62200, 43200, 8191, 63,
+          INTUOSP2_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 9, .touch_max = 10 };
 
 static const struct wacom_features wacom_features_HID_ANY_ID =
         { "Wacom HID", .type = HID_GENERIC, .oVid = HID_ANY_ID, .oPid = HID_ANY_ID };
@@ -4115,6 +4367,8 @@ const struct hid_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x33D) },
         { USB_DEVICE_WACOM(0x33E) },
         { USB_DEVICE_WACOM(0x343) },
+        { BT_DEVICE_WACOM(0x360) },
+        { BT_DEVICE_WACOM(0x361) },
         { USB_DEVICE_WACOM(0x4001) },
         { USB_DEVICE_WACOM(0x4004) },
         { USB_DEVICE_WACOM(0x5000) },
@@ -4123,6 +4377,7 @@ const struct hid_device_id wacom_ids[] = {
 
         { USB_DEVICE_WACOM(HID_ANY_ID) },
         { I2C_DEVICE_WACOM(HID_ANY_ID) },
+        { BT_DEVICE_WACOM(HID_ANY_ID) },
         { }
 };
 MODULE_DEVICE_TABLE(hid, wacom_ids);
diff --git a/drivers/hid/wacom_wac.h b/drivers/hid/wacom_wac.h
index fb0e50acb10d..857ccee16f38 100644
--- a/drivers/hid/wacom_wac.h
+++ b/drivers/hid/wacom_wac.h
@@ -12,8 +12,8 @@
 #include <linux/types.h>
 #include <linux/hid.h>
 
-/* maximum packet length for USB devices */
-#define WACOM_PKGLEN_MAX        192
+/* maximum packet length for USB/BT devices */
+#define WACOM_PKGLEN_MAX        361
 
 #define WACOM_NAME_MAX          64
 #define WACOM_MAX_REMOTES       5
@@ -72,6 +72,17 @@
 #define WACOM_REPORT_REMOTE             17
 #define WACOM_REPORT_INTUOSHT2_ID       8
 
+/* wacom command report ids */
+#define WAC_CMD_WL_LED_CONTROL          0x03
+#define WAC_CMD_LED_CONTROL             0x20
+#define WAC_CMD_ICON_START              0x21
+#define WAC_CMD_ICON_XFER               0x23
+#define WAC_CMD_ICON_BT_XFER            0x26
+#define WAC_CMD_DELETE_PAIRING          0x20
+#define WAC_CMD_LED_CONTROL_GENERIC     0x32
+#define WAC_CMD_UNPAIR_ALL              0xFF
+#define WAC_CMD_WL_INTUOSP2             0x82
+
 /* device quirks */
 #define WACOM_QUIRK_BBTOUCH_LOWRES      0x0001
 #define WACOM_QUIRK_SENSE               0x0002
@@ -91,6 +102,7 @@
 #define WACOM_HID_SP_DIGITIZER          0x000d0000
 #define WACOM_HID_SP_DIGITIZERINFO      0x00100000
 #define WACOM_HID_WD_DIGITIZER          (WACOM_HID_UP_WACOMDIGITIZER | 0x01)
+#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_SERIALHI           (WACOM_HID_UP_WACOMDIGITIZER | 0x5c)
@@ -104,6 +116,7 @@
 #define WACOM_HID_WD_ACCELEROMETER_Y    (WACOM_HID_UP_WACOMDIGITIZER | 0x0402)
 #define WACOM_HID_WD_ACCELEROMETER_Z    (WACOM_HID_UP_WACOMDIGITIZER | 0x0403)
 #define WACOM_HID_WD_BATTERY_CHARGING   (WACOM_HID_UP_WACOMDIGITIZER | 0x0404)
+#define WACOM_HID_WD_TOUCHONOFF         (WACOM_HID_UP_WACOMDIGITIZER | 0x0454)
 #define WACOM_HID_WD_BATTERY_LEVEL      (WACOM_HID_UP_WACOMDIGITIZER | 0x043b)
 #define WACOM_HID_WD_EXPRESSKEY00       (WACOM_HID_UP_WACOMDIGITIZER | 0x0910)
 #define WACOM_HID_WD_EXPRESSKEYCAP00    (WACOM_HID_UP_WACOMDIGITIZER | 0x0950)
@@ -113,7 +126,6 @@
 #define WACOM_HID_WD_BUTTONLEFT         (WACOM_HID_UP_WACOMDIGITIZER | 0x0993)
 #define WACOM_HID_WD_BUTTONRIGHT        (WACOM_HID_UP_WACOMDIGITIZER | 0x0994)
 #define WACOM_HID_WD_BUTTONCENTER       (WACOM_HID_UP_WACOMDIGITIZER | 0x0995)
-#define WACOM_HID_WD_TOUCHONOFF         (WACOM_HID_UP_WACOMDIGITIZER | 0x0996)
 #define WACOM_HID_WD_FINGERWHEEL        (WACOM_HID_UP_WACOMDIGITIZER | 0x0d03)
 #define WACOM_HID_WD_OFFSETLEFT         (WACOM_HID_UP_WACOMDIGITIZER | 0x0d30)
 #define WACOM_HID_WD_OFFSETTOP          (WACOM_HID_UP_WACOMDIGITIZER | 0x0d31)
@@ -127,6 +139,12 @@
 #define WACOM_HID_UP_G11                0xff110000
 #define WACOM_HID_G11_PEN               (WACOM_HID_UP_G11 | 0x02)
 #define WACOM_HID_G11_TOUCHSCREEN       (WACOM_HID_UP_G11 | 0x11)
+#define WACOM_HID_UP_WACOMTOUCH         0xff000000
+#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_X                  (WACOM_HID_UP_WACOMTOUCH | 0x130)
+#define WACOM_HID_WT_Y                  (WACOM_HID_UP_WACOMTOUCH | 0x131)
 
 #define WACOM_PAD_FIELD(f)      (((f)->physical == HID_DG_TABLETFUNCTIONKEY) || \
                                  ((f)->physical == WACOM_HID_WD_DIGITIZERFNKEYS) || \
@@ -144,7 +162,14 @@
                                  ((f)->physical == HID_DG_FINGER) || \
                                  ((f)->application == HID_DG_TOUCHSCREEN) || \
                                  ((f)->application == WACOM_HID_G9_TOUCHSCREEN) || \
-                                 ((f)->application == WACOM_HID_G11_TOUCHSCREEN))
+                                 ((f)->application == WACOM_HID_G11_TOUCHSCREEN) || \
+                                 ((f)->application == WACOM_HID_WT_TOUCHPAD) || \
+                                 ((f)->application == HID_DG_TOUCHPAD))
+
+#define WACOM_DIRECT_DEVICE(f)  (((f)->application == HID_DG_TOUCHSCREEN) || \
+                                 ((f)->application == WACOM_HID_WT_TOUCHSCREEN) || \
+                                 ((f)->application == HID_DG_PEN) || \
+                                 ((f)->application == WACOM_HID_WD_PEN))
 
 enum {
         PENPARTNER = 0,
@@ -170,6 +195,7 @@ enum {
         INTUOSPS,
         INTUOSPM,
         INTUOSPL,
+        INTUOSP2_BT,
         WACOM_21UX2,
         WACOM_22HD,
         DTK,
@@ -232,7 +258,6 @@ struct wacom_features {
         int pktlen;
         bool check_for_hid_type;
         int hid_type;
-        bool input_event_flag;
 };
 
 struct wacom_shared {
@@ -244,6 +269,7 @@ struct wacom_shared {
         struct input_dev *touch_input;
         struct hid_device *pen;
         struct hid_device *touch;
+        bool has_mute_touch_switch;
 };
 
 struct hid_data {
@@ -300,6 +326,7 @@ struct wacom_wac {
         int mode_report;
         int mode_value;
         struct hid_data hid_data;
+        bool has_mute_touch_switch;
 };
 
 #endif