4 files changed, 287 insertions, 63 deletions

diff --git a/drivers/hid/wacom.h b/drivers/hid/wacom.h
index 7db432809e9e..ad7318db1dfe 100644
--- a/drivers/hid/wacom.h
+++ b/drivers/hid/wacom.h
@@ -129,13 +129,6 @@ static inline void wacom_schedule_work(struct wacom_wac *wacom_wac)
         schedule_work(&wacom->work);
 }
 
-static inline void wacom_notify_battery(struct wacom_wac *wacom_wac)
-{
-        struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
-
-        power_supply_changed(&wacom->battery);
-}
-
 extern const struct hid_device_id wacom_ids[];
 
 void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len);
@@ -149,4 +142,5 @@ void wacom_wac_usage_mapping(struct hid_device *hdev,
 int wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
                 struct hid_usage *usage, __s32 value);
 void wacom_wac_report(struct hid_device *hdev, struct hid_report *report);
+void wacom_battery_work(struct work_struct *work);
 #endif
diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
index f0568a7e6de9..353fe476be26 100644
--- a/drivers/hid/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -406,6 +406,9 @@ static int wacom_query_tablet_data(struct hid_device *hdev,
                 else if (features->type == WACOM_27QHDT) {
                         return wacom_set_device_mode(hdev, 131, 3, 2);
                 }
+                else if (features->type == BAMBOO_PAD) {
+                        return wacom_set_device_mode(hdev, 2, 2, 2);
+                }
         } else if (features->device_type == BTN_TOOL_PEN) {
                 if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
                         return wacom_set_device_mode(hdev, 2, 2, 2);
@@ -524,6 +527,11 @@ static int wacom_add_shared_data(struct hid_device *hdev)
 
         wacom_wac->shared = &data->shared;
 
+        if (wacom_wac->features.device_type == BTN_TOOL_FINGER)
+                wacom_wac->shared->touch = hdev;
+        else if (wacom_wac->features.device_type == BTN_TOOL_PEN)
+                wacom_wac->shared->pen = hdev;
+
 out:
         mutex_unlock(&wacom_udev_list_lock);
         return retval;
@@ -541,14 +549,22 @@ static void wacom_release_shared_data(struct kref *kref)
         kfree(data);
 }
 
-static void wacom_remove_shared_data(struct wacom_wac *wacom)
+static void wacom_remove_shared_data(struct wacom *wacom)
 {
         struct wacom_hdev_data *data;
+        struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+
+        if (wacom_wac->shared) {
+                data = container_of(wacom_wac->shared, struct wacom_hdev_data,
+                                    shared);
+
+                if (wacom_wac->shared->touch == wacom->hdev)
+                        wacom_wac->shared->touch = NULL;
+                else if (wacom_wac->shared->pen == wacom->hdev)
+                        wacom_wac->shared->pen = NULL;
 
-        if (wacom->shared) {
-                data = container_of(wacom->shared, struct wacom_hdev_data, shared);
                 kref_put(&data->kref, wacom_release_shared_data);
-                wacom->shared = NULL;
+                wacom_wac->shared = NULL;
         }
 }
 
@@ -929,6 +945,7 @@ static void wacom_destroy_leds(struct wacom *wacom)
 }
 
 static enum power_supply_property wacom_battery_props[] = {
+        POWER_SUPPLY_PROP_PRESENT,
         POWER_SUPPLY_PROP_STATUS,
         POWER_SUPPLY_PROP_SCOPE,
         POWER_SUPPLY_PROP_CAPACITY
@@ -948,6 +965,9 @@ static int wacom_battery_get_property(struct power_supply *psy,
         int ret = 0;
 
         switch (psp) {
+                case POWER_SUPPLY_PROP_PRESENT:
+                        val->intval = wacom->wacom_wac.bat_connected;
+                        break;
                 case POWER_SUPPLY_PROP_SCOPE:
                         val->intval = POWER_SUPPLY_SCOPE_DEVICE;
                         break;
@@ -961,6 +981,8 @@ static int wacom_battery_get_property(struct power_supply *psy,
                         else if (wacom->wacom_wac.battery_capacity == 100 &&
                                     wacom->wacom_wac.ps_connected)
                                 val->intval = POWER_SUPPLY_STATUS_FULL;
+                        else if (wacom->wacom_wac.ps_connected)
+                                val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
                         else
                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
                         break;
@@ -1041,8 +1063,7 @@ static int wacom_initialize_battery(struct wacom *wacom)
 
 static void wacom_destroy_battery(struct wacom *wacom)
 {
-        if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
-             wacom->battery.dev) {
+        if (wacom->battery.dev) {
                 power_supply_unregister(&wacom->battery);
                 wacom->battery.dev = NULL;
                 power_supply_unregister(&wacom->ac);
@@ -1313,6 +1334,20 @@ fail:
         return;
 }
 
+void wacom_battery_work(struct work_struct *work)
+{
+        struct wacom *wacom = container_of(work, struct wacom, work);
+
+        if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
+             !wacom->battery.dev) {
+                wacom_initialize_battery(wacom);
+        }
+        else if (!(wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
+                 wacom->battery.dev) {
+                wacom_destroy_battery(wacom);
+        }
+}
+
 /*
  * Not all devices report physical dimensions from HID.
  * Compute the default from hardcoded logical dimension
@@ -1373,6 +1408,9 @@ static int wacom_probe(struct hid_device *hdev,
 
         hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
 
+        /* hid-core sets this quirk for the boot interface */
+        hdev->quirks &= ~HID_QUIRK_NOGET;
+
         wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
         if (!wacom)
                 return -ENOMEM;
@@ -1412,6 +1450,21 @@ static int wacom_probe(struct hid_device *hdev,
                         goto fail_allocate_inputs;
         }
 
+        /*
+         * Bamboo Pad has a generic hid handling for the Pen, and we switch it
+         * into debug mode for the touch part.
+         * We ignore the other interfaces.
+         */
+        if (features->type == BAMBOO_PAD) {
+                if (features->pktlen == WACOM_PKGLEN_PENABLED) {
+                        features->type = HID_GENERIC;
+                } else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) &&
+                           (features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) {
+                        error = -ENODEV;
+                        goto fail_shared_data;
+                }
+        }
+
         /* set the default size in case we do not get them from hid */
         wacom_set_default_phy(features);
 
@@ -1446,6 +1499,12 @@ static int wacom_probe(struct hid_device *hdev,
                 features->y_max = 4096;
         }
 
+        /*
+         * Same thing for Bamboo PAD
+         */
+        if (features->type == BAMBOO_PAD)
+                features->device_type = BTN_TOOL_FINGER;
+
         if (hdev->bus == BUS_BLUETOOTH)
                 features->quirks |= WACOM_QUIRK_BATTERY;
 
@@ -1527,7 +1586,7 @@ fail_register_inputs:
         wacom_clean_inputs(wacom);
         wacom_destroy_battery(wacom);
 fail_battery:
-        wacom_remove_shared_data(wacom_wac);
+        wacom_remove_shared_data(wacom);
 fail_shared_data:
         wacom_clean_inputs(wacom);
 fail_allocate_inputs:
@@ -1550,7 +1609,7 @@ static void wacom_remove(struct hid_device *hdev)
         if (hdev->bus == BUS_BLUETOOTH)
                 device_remove_file(&hdev->dev, &dev_attr_speed);
         wacom_destroy_battery(wacom);
-        wacom_remove_shared_data(&wacom->wacom_wac);
+        wacom_remove_shared_data(wacom);
 
         hid_set_drvdata(hdev, NULL);
         kfree(wacom);
diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
index bbe32d66e500..fa0578ecd7a1 100644
--- a/drivers/hid/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -45,6 +45,27 @@ static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
  */
 static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
 
+static void wacom_notify_battery(struct wacom_wac *wacom_wac,
+        int bat_capacity, bool bat_charging, bool bat_connected,
+        bool ps_connected)
+{
+        struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
+        bool changed = wacom_wac->battery_capacity != bat_capacity  ||
+                       wacom_wac->bat_charging     != bat_charging  ||
+                       wacom_wac->bat_connected    != bat_connected ||
+                       wacom_wac->ps_connected     != ps_connected;
+
+        if (changed) {
+                wacom_wac->battery_capacity = bat_capacity;
+                wacom_wac->bat_charging = bat_charging;
+                wacom_wac->bat_connected = bat_connected;
+                wacom_wac->ps_connected = ps_connected;
+
+                if (wacom->battery.dev)
+                        power_supply_changed(&wacom->battery);
+        }
+}
+
 static int wacom_penpartner_irq(struct wacom_wac *wacom)
 {
         unsigned char *data = wacom->data;
@@ -419,17 +440,26 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
                 rw = (data[7] >> 2 & 0x07);
                 battery_capacity = batcap_gr[rw];
                 ps_connected = rw == 7;
-                if ((wacom->battery_capacity != battery_capacity) ||
-                    (wacom->ps_connected != ps_connected)) {
-                        wacom->battery_capacity = battery_capacity;
-                        wacom->ps_connected = ps_connected;
-                        wacom_notify_battery(wacom);
-                }
+                wacom_notify_battery(wacom, battery_capacity, ps_connected,
+                                     1, ps_connected);
         }
 exit:
         return retval;
 }
 
+static void wacom_intuos_schedule_prox_event(struct wacom_wac *wacom_wac)
+{
+        struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
+        struct hid_report *r;
+        struct hid_report_enum *re;
+
+        re = &(wacom->hdev->report_enum[HID_FEATURE_REPORT]);
+        r = re->report_id_hash[WACOM_REPORT_INTUOSREAD];
+        if (r) {
+                hid_hw_request(wacom->hdev, r, HID_REQ_GET_REPORT);
+        }
+}
+
 static int wacom_intuos_inout(struct wacom_wac *wacom)
 {
         struct wacom_features *features = &wacom->features;
@@ -610,8 +640,11 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
         }
 
         /* don't report other events if we don't know the ID */
-        if (!wacom->id[idx])
+        if (!wacom->id[idx]) {
+                /* but reschedule a read of the current tool */
+                wacom_intuos_schedule_prox_event(wacom);
                 return 1;
+        }
 
         return 0;
 }
@@ -1023,15 +1056,9 @@ static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
                 bat_charging = (power_raw & 0x08) ? 1 : 0;
                 ps_connected = (power_raw & 0x10) ? 1 : 0;
                 battery_capacity = batcap_i4[power_raw & 0x07];
-                if ((wacom->battery_capacity != battery_capacity) ||
-                    (wacom->bat_charging != bat_charging) ||
-                    (wacom->ps_connected != ps_connected)) {
-                        wacom->battery_capacity = battery_capacity;
-                        wacom->bat_charging = bat_charging;
-                        wacom->ps_connected = ps_connected;
-                        wacom_notify_battery(wacom);
-                }
-
+                wacom_notify_battery(wacom, battery_capacity, bat_charging,
+                                     battery_capacity || bat_charging,
+                                     ps_connected);
                 break;
         default:
                 dev_dbg(wacom->input->dev.parent,
@@ -1104,7 +1131,7 @@ static int wacom_24hdt_irq(struct wacom_wac *wacom)
                         contact_with_no_pen_down_count++;
                 }
         }
-        input_mt_report_pointer_emulation(input, true);
+        input_mt_sync_frame(input);
 
         wacom->num_contacts_left -= contacts_to_send;
         if (wacom->num_contacts_left <= 0) {
@@ -1159,7 +1186,7 @@ static int wacom_mt_touch(struct wacom_wac *wacom)
                         contact_with_no_pen_down_count++;
                 }
         }
-        input_mt_report_pointer_emulation(input, true);
+        input_mt_sync_frame(input);
 
         wacom->num_contacts_left -= contacts_to_send;
         if (wacom->num_contacts_left <= 0) {
@@ -1191,7 +1218,7 @@ static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
                         contact_with_no_pen_down_count++;
                 }
         }
-        input_mt_report_pointer_emulation(input, true);
+        input_mt_sync_frame(input);
 
         /* keep touch state for pen event */
         wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);
@@ -1651,7 +1678,7 @@ static int wacom_bpt_touch(struct wacom_wac *wacom)
                 }
         }
 
-        input_mt_report_pointer_emulation(input, true);
+        input_mt_sync_frame(input);
 
         input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
         input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
@@ -1747,7 +1774,7 @@ static int wacom_bpt3_touch(struct wacom_wac *wacom)
                         wacom_bpt3_button_msg(wacom, data + offset);
 
         }
-        input_mt_report_pointer_emulation(input, true);
+        input_mt_sync_frame(input);
         wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);
 
         return 1;
@@ -1760,20 +1787,9 @@ static int wacom_bpt_pen(struct wacom_wac *wacom)
         unsigned char *data = wacom->data;
         int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
 
-        if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_USB)
+        if (data[0] != WACOM_REPORT_PENABLED)
             return 0;
 
-        if (data[0] == WACOM_REPORT_USB) {
-                if (features->type == INTUOSHT &&
-                    wacom->shared->touch_input &&
-                    features->touch_max) {
-                        input_report_switch(wacom->shared->touch_input,
-                                            SW_MUTE_DEVICE, data[8] & 0x40);
-                        input_sync(wacom->shared->touch_input);
-                }
-                return 0;
-        }
-
         if (wacom->shared->touch_down)
                 return 0;
 
@@ -1849,6 +1865,91 @@ static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
         return 0;
 }
 
+static void wacom_bamboo_pad_pen_event(struct wacom_wac *wacom,
+                unsigned char *data)
+{
+        unsigned char prefix;
+
+        /*
+         * We need to reroute the event from the debug interface to the
+         * pen interface.
+         * We need to add the report ID to the actual pen report, so we
+         * temporary overwrite the first byte to prevent having to kzalloc/kfree
+         * and memcpy the report.
+         */
+        prefix = data[0];
+        data[0] = WACOM_REPORT_BPAD_PEN;
+
+        /*
+         * actually reroute the event.
+         * No need to check if wacom->shared->pen is valid, hid_input_report()
+         * will check for us.
+         */
+        hid_input_report(wacom->shared->pen, HID_INPUT_REPORT, data,
+                         WACOM_PKGLEN_PENABLED, 1);
+
+        data[0] = prefix;
+}
+
+static int wacom_bamboo_pad_touch_event(struct wacom_wac *wacom,
+                unsigned char *data)
+{
+        struct input_dev *input = wacom->input;
+        unsigned char *finger_data, prefix;
+        unsigned id;
+        int x, y;
+        bool valid;
+
+        prefix = data[0];
+
+        for (id = 0; id < wacom->features.touch_max; id++) {
+                valid = !!(prefix & BIT(id)) &&
+                        !wacom->shared->stylus_in_proximity;
+
+                input_mt_slot(input, id);
+                input_mt_report_slot_state(input, MT_TOOL_FINGER, valid);
+
+                if (!valid)
+                        continue;
+
+                finger_data = data + 1 + id * 3;
+                x = finger_data[0] | ((finger_data[1] & 0x0f) << 8);
+                y = (finger_data[2] << 4) | (finger_data[1] >> 4);
+
+                input_report_abs(input, ABS_MT_POSITION_X, x);
+                input_report_abs(input, ABS_MT_POSITION_Y, y);
+        }
+
+        input_mt_sync_frame(input);
+
+        input_report_key(input, BTN_LEFT, prefix & 0x40);
+        input_report_key(input, BTN_RIGHT, prefix & 0x80);
+
+        /* keep touch state for pen event */
+        wacom->shared->touch_down = !!prefix &&
+                                    !wacom->shared->stylus_in_proximity;
+
+        return 1;
+}
+
+static int wacom_bamboo_pad_irq(struct wacom_wac *wacom, size_t len)
+{
+        unsigned char *data = wacom->data;
+
+        if (!((len == WACOM_PKGLEN_BPAD_TOUCH) ||
+              (len == WACOM_PKGLEN_BPAD_TOUCH_USB)) ||
+            (data[0] != WACOM_REPORT_BPAD_TOUCH))
+                return 0;
+
+        if (data[1] & 0x01)
+                wacom_bamboo_pad_pen_event(wacom, &data[1]);
+
+        if (data[1] & 0x02)
+                return wacom_bamboo_pad_touch_event(wacom, &data[9]);
+
+        return 0;
+}
+
 static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
 {
         unsigned char *data = wacom->data;
@@ -1859,7 +1960,7 @@ static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
 
         connected = data[1] & 0x01;
         if (connected) {
-                int pid, battery, ps_connected;
+                int pid, battery, charging;
 
                 if ((wacom->shared->type == INTUOSHT) &&
                     wacom->shared->touch_input &&
@@ -1871,30 +1972,63 @@ static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
 
                 pid = get_unaligned_be16(&data[6]);
                 battery = (data[5] & 0x3f) * 100 / 31;
-                ps_connected = !!(data[5] & 0x80);
+                charging = !!(data[5] & 0x80);
                 if (wacom->pid != pid) {
                         wacom->pid = pid;
                         wacom_schedule_work(wacom);
                 }
 
-                if (wacom->shared->type &&
-                    (battery != wacom->battery_capacity ||
-                     ps_connected != wacom->ps_connected)) {
-                        wacom->battery_capacity = battery;
-                        wacom->ps_connected = ps_connected;
-                        wacom->bat_charging = ps_connected &&
-                                                wacom->battery_capacity < 100;
-                        wacom_notify_battery(wacom);
-                }
+                if (wacom->shared->type)
+                        wacom_notify_battery(wacom, battery, charging, 1, 0);
+
         } else if (wacom->pid != 0) {
                 /* disconnected while previously connected */
                 wacom->pid = 0;
                 wacom_schedule_work(wacom);
-                wacom->battery_capacity = 0;
-                wacom->bat_charging = 0;
-                wacom->ps_connected = 0;
+                wacom_notify_battery(wacom, 0, 0, 0, 0);
+        }
+
+        return 0;
+}
+
+static int wacom_status_irq(struct wacom_wac *wacom_wac, size_t len)
+{
+        struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
+        struct wacom_features *features = &wacom_wac->features;
+        unsigned char *data = wacom_wac->data;
+
+        if (data[0] != WACOM_REPORT_USB)
+                return 0;
+
+        if (features->type == INTUOSHT &&
+            wacom_wac->shared->touch_input &&
+            features->touch_max) {
+                input_report_switch(wacom_wac->shared->touch_input,
+                                    SW_MUTE_DEVICE, data[8] & 0x40);
+                input_sync(wacom_wac->shared->touch_input);
         }
 
+        if (data[9] & 0x02) { /* wireless module is attached */
+                int battery = (data[8] & 0x3f) * 100 / 31;
+                bool charging = !!(data[8] & 0x80);
+
+                wacom_notify_battery(wacom_wac, battery, charging,
+                                     battery || charging, 1);
+
+                if (!wacom->battery.dev &&
+                    !(features->quirks & WACOM_QUIRK_BATTERY)) {
+                        features->quirks |= WACOM_QUIRK_BATTERY;
+                        INIT_WORK(&wacom->work, wacom_battery_work);
+                        wacom_schedule_work(wacom_wac);
+                }
+        }
+        else if ((features->quirks & WACOM_QUIRK_BATTERY) &&
+                 wacom->battery.dev) {
+                features->quirks &= ~WACOM_QUIRK_BATTERY;
+                INIT_WORK(&wacom->work, wacom_battery_work);
+                wacom_schedule_work(wacom_wac);
+                wacom_notify_battery(wacom_wac, 0, 0, 0, 0);
+        }
         return 0;
 }
 
@@ -1967,6 +2101,8 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
         case INTUOSPL:
                 if (len == WACOM_PKGLEN_BBTOUCH3)
                         sync = wacom_bpt3_touch(wacom_wac);
+                else if (wacom_wac->data[0] == WACOM_REPORT_USB)
+                        sync = wacom_status_irq(wacom_wac, len);
                 else
                         sync = wacom_intuos_irq(wacom_wac);
                 break;
@@ -1982,7 +2118,14 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
 
         case BAMBOO_PT:
         case INTUOSHT:
-                sync = wacom_bpt_irq(wacom_wac, len);
+                if (wacom_wac->data[0] == WACOM_REPORT_USB)
+                        sync = wacom_status_irq(wacom_wac, len);
+                else
+                        sync = wacom_bpt_irq(wacom_wac, len);
+                break;
+
+        case BAMBOO_PAD:
+                sync = wacom_bamboo_pad_irq(wacom_wac, len);
                 break;
 
         case WIRELESS:
@@ -2323,6 +2466,13 @@ int wacom_setup_pentouch_input_capabilities(struct input_dev *input_dev,
                                               0, 0);
                 }
                 break;
+        case BAMBOO_PAD:
+                __clear_bit(ABS_MISC, input_dev->absbit);
+                input_mt_init_slots(input_dev, features->touch_max,
+                                    INPUT_MT_POINTER);
+                __set_bit(BTN_LEFT, input_dev->keybit);
+                __set_bit(BTN_RIGHT, input_dev->keybit);
+                break;
         }
         return 0;
 }
@@ -2976,6 +3126,12 @@ static const struct wacom_features wacom_features_0x30C =
         { "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
+static const struct wacom_features wacom_features_0x318 =
+        { "Wacom USB Bamboo PAD", 4095, 4095, /* Touch */
+          .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
+static const struct wacom_features wacom_features_0x319 =
+        { "Wacom Wireless Bamboo PAD", 4095, 4095, /* Touch */
+          .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
 static const struct wacom_features wacom_features_0x323 =
         { "Wacom Intuos P M", 21600, 13500, 1023, 31,
           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
@@ -2992,6 +3148,10 @@ static const struct wacom_features wacom_features_HID_ANY_ID =
         HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
         .driver_data = (kernel_ulong_t)&wacom_features_##prod
 
+#define I2C_DEVICE_WACOM(prod)                                          \
+        HID_DEVICE(BUS_I2C, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
+        .driver_data = (kernel_ulong_t)&wacom_features_##prod
+
 #define USB_DEVICE_LENOVO(prod)                                 \
         HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),                     \
         .driver_data = (kernel_ulong_t)&wacom_features_##prod
@@ -3124,6 +3284,8 @@ const struct hid_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x314) },
         { USB_DEVICE_WACOM(0x315) },
         { USB_DEVICE_WACOM(0x317) },
+        { USB_DEVICE_WACOM(0x318) },
+        { USB_DEVICE_WACOM(0x319) },
         { USB_DEVICE_WACOM(0x323) },
         { USB_DEVICE_WACOM(0x32A) },
         { USB_DEVICE_WACOM(0x32B) },
@@ -3136,6 +3298,7 @@ const struct hid_device_id wacom_ids[] = {
         { USB_DEVICE_LENOVO(0x6004) },
 
         { USB_DEVICE_WACOM(HID_ANY_ID) },
+        { I2C_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 021ee1c1980a..1c7d8931f1fa 100644
--- a/drivers/hid/wacom_wac.h
+++ b/drivers/hid/wacom_wac.h
@@ -33,6 +33,8 @@
 #define WACOM_PKGLEN_MTTPC      40
 #define WACOM_PKGLEN_DTUS       68
 #define WACOM_PKGLEN_PENABLED    8
+#define WACOM_PKGLEN_BPAD_TOUCH 32
+#define WACOM_PKGLEN_BPAD_TOUCH_USB     64
 
 /* wacom data size per MT contact */
 #define WACOM_BYTES_PER_MT_PACKET       11
@@ -67,6 +69,8 @@
 #define WACOM_REPORT_24HDT              1
 #define WACOM_REPORT_WL                 128
 #define WACOM_REPORT_USB                192
+#define WACOM_REPORT_BPAD_PEN           3
+#define WACOM_REPORT_BPAD_TOUCH         16
 
 /* device quirks */
 #define WACOM_QUIRK_MULTI_INPUT         0x0001
@@ -122,6 +126,7 @@ enum {
         BAMBOO_PT,
         WACOM_24HDT,
         WACOM_27QHDT,
+        BAMBOO_PAD,
         TABLETPC,   /* add new TPC below */
         TABLETPCE,
         TABLETPC2FG,
@@ -169,6 +174,8 @@ struct wacom_shared {
         unsigned touch_max;
         int type;
         struct input_dev *touch_input;
+        struct hid_device *pen;
+        struct hid_device *touch;
 };
 
 struct hid_data {
@@ -205,6 +212,7 @@ struct wacom_wac {
         int battery_capacity;
         int num_contacts_left;
         int bat_charging;
+        int bat_connected;
         int ps_connected;
         u8 bt_features;
         u8 bt_high_speed;