Merge branch 'next' into for-linus

Merge first round of changes for 3.13 merge window.

3 files changed, 165 insertions, 53 deletions

diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index e53416a4d7f3..867e7c33ac55 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -524,9 +524,6 @@ static int wacom_set_device_mode(struct usb_interface *intf, int report_id, int
 
                 error = wacom_set_report(intf, WAC_HID_FEATURE_REPORT,
                                          report_id, rep_data, length, 1);
-                if (error >= 0)
-                        error = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
-                                                 report_id, rep_data, length, 1);
         } while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);
 
         kfree(rep_data);
@@ -548,7 +545,7 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
                         /* MT Tablet PC touch */
                         return wacom_set_device_mode(intf, 3, 4, 4);
                 }
-                else if (features->type == WACOM_24HDT) {
+                else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
                         return wacom_set_device_mode(intf, 18, 3, 2);
                 }
         } else if (features->device_type == BTN_TOOL_PEN) {
@@ -719,7 +716,7 @@ static int wacom_led_control(struct wacom *wacom)
                 return -ENOMEM;
 
         if (wacom->wacom_wac.features.type >= INTUOS5S &&
-            wacom->wacom_wac.features.type <= INTUOS5L) {
+            wacom->wacom_wac.features.type <= INTUOSPL) {
                 /*
                  * Touch Ring and crop mark LED luminance may take on
                  * one of four values:
@@ -981,14 +978,20 @@ static int wacom_initialize_leds(struct wacom *wacom)
         case INTUOS5S:
         case INTUOS5:
         case INTUOS5L:
-                wacom->led.select[0] = 0;
-                wacom->led.select[1] = 0;
-                wacom->led.llv = 32;
-                wacom->led.hlv = 0;
-                wacom->led.img_lum = 0;
-
-                error = sysfs_create_group(&wacom->intf->dev.kobj,
-                                           &intuos5_led_attr_group);
+        case INTUOSPS:
+        case INTUOSPM:
+        case INTUOSPL:
+                if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN) {
+                        wacom->led.select[0] = 0;
+                        wacom->led.select[1] = 0;
+                        wacom->led.llv = 32;
+                        wacom->led.hlv = 0;
+                        wacom->led.img_lum = 0;
+
+                        error = sysfs_create_group(&wacom->intf->dev.kobj,
+                                                  &intuos5_led_attr_group);
+                } else
+                        return 0;
                 break;
 
         default:
@@ -1024,8 +1027,12 @@ static void wacom_destroy_leds(struct wacom *wacom)
         case INTUOS5S:
         case INTUOS5:
         case INTUOS5L:
-                sysfs_remove_group(&wacom->intf->dev.kobj,
-                                   &intuos5_led_attr_group);
+        case INTUOSPS:
+        case INTUOSPM:
+        case INTUOSPL:
+                if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
+                        sysfs_remove_group(&wacom->intf->dev.kobj,
+                                           &intuos5_led_attr_group);
                 break;
         }
 }
@@ -1185,34 +1192,47 @@ static void wacom_wireless_work(struct work_struct *work)
                 wacom_wac1->features =
                         *((struct wacom_features *)id->driver_info);
                 wacom_wac1->features.device_type = BTN_TOOL_PEN;
+                snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
+                         wacom_wac1->features.name);
                 error = wacom_register_input(wacom1);
                 if (error)
-                        goto fail1;
+                        goto fail;
 
                 /* Touch interface */
-                wacom_wac2->features =
-                        *((struct wacom_features *)id->driver_info);
-                wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
-                wacom_wac2->features.device_type = BTN_TOOL_FINGER;
-                wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
-                error = wacom_register_input(wacom2);
-                if (error)
-                        goto fail2;
+                if (wacom_wac1->features.touch_max) {
+                        wacom_wac2->features =
+                                *((struct wacom_features *)id->driver_info);
+                        wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
+                        wacom_wac2->features.device_type = BTN_TOOL_FINGER;
+                        wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
+                        if (wacom_wac2->features.touch_max)
+                                snprintf(wacom_wac2->name, WACOM_NAME_MAX,
+                                         "%s (WL) Finger",wacom_wac2->features.name);
+                        else
+                                snprintf(wacom_wac2->name, WACOM_NAME_MAX,
+                                         "%s (WL) Pad",wacom_wac2->features.name);
+                        error = wacom_register_input(wacom2);
+                        if (error)
+                                goto fail;
+                }
 
                 error = wacom_initialize_battery(wacom);
                 if (error)
-                        goto fail3;
+                        goto fail;
         }
 
         return;
 
-fail3:
-        input_unregister_device(wacom_wac2->input);
-        wacom_wac2->input = NULL;
-fail2:
-        input_unregister_device(wacom_wac1->input);
-        wacom_wac1->input = NULL;
-fail1:
+fail:
+        if (wacom_wac2->input) {
+                input_unregister_device(wacom_wac2->input);
+                wacom_wac2->input = NULL;
+        }
+
+        if (wacom_wac1->input) {
+                input_unregister_device(wacom_wac1->input);
+                wacom_wac1->input = NULL;
+        }
         return;
 }
 
@@ -1302,7 +1322,7 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
          * HID descriptor. If this is the touch interface (wMaxPacketSize
          * of WACOM_PKGLEN_BBTOUCH3), override the table values.
          */
-        if (features->type >= INTUOS5S && features->type <= INTUOS5L) {
+        if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
                 if (endpoint->wMaxPacketSize == WACOM_PKGLEN_BBTOUCH3) {
                         features->device_type = BTN_TOOL_FINGER;
                         features->pktlen = WACOM_PKGLEN_BBTOUCH3;
@@ -1329,10 +1349,12 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
                 struct usb_device *other_dev;
 
                 /* Append the device type to the name */
-                strlcat(wacom_wac->name,
-                        features->device_type == BTN_TOOL_PEN ?
-                                " Pen" : " Finger",
-                        sizeof(wacom_wac->name));
+                if (features->device_type != BTN_TOOL_FINGER)
+                        strlcat(wacom_wac->name, " Pen", WACOM_NAME_MAX);
+                else if (features->touch_max)
+                        strlcat(wacom_wac->name, " Finger", WACOM_NAME_MAX);
+                else
+                        strlcat(wacom_wac->name, " Pad", WACOM_NAME_MAX);
 
                 other_dev = wacom_get_sibling(dev, features->oVid, features->oPid);
                 if (other_dev == NULL || wacom_get_usbdev_data(other_dev) == NULL)
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index c59b797eeafa..782c2535f1d8 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -427,6 +427,13 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
                         (features->type == WACOM_21UX2))
                 return 1;
 
+        /* Range Report */
+        if ((data[1] & 0xfe) == 0x20) {
+                input_report_key(input, BTN_TOUCH, 0);
+                input_report_abs(input, ABS_PRESSURE, 0);
+                input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
+        }
+
         /* Exit report */
         if ((data[1] & 0xfe) == 0x80) {
                 if (features->quirks == WACOM_QUIRK_MULTI_INPUT)
@@ -477,7 +484,7 @@ static void wacom_intuos_general(struct wacom_wac *wacom)
         /* general pen packet */
         if ((data[1] & 0xb8) == 0xa0) {
                 t = (data[6] << 2) | ((data[7] >> 6) & 3);
-                if (features->type >= INTUOS4S && features->type <= WACOM_24HD) {
+                if (features->type >= INTUOS4S && features->type <= CINTIQ_HYBRID) {
                         t = (t << 1) | (data[1] & 1);
                 }
                 input_report_abs(input, ABS_PRESSURE, t);
@@ -621,14 +628,30 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
                         } else {
                                 input_report_abs(input, ABS_MISC, 0);
                         }
-                } else if (features->type >= INTUOS5S && features->type <= INTUOS5L) {
+                } else if (features->type == CINTIQ_HYBRID) {
+                        /*
+                         * Do not send hardware buttons under Android. They
+                         * are already sent to the system through GPIO (and
+                         * have different meaning).
+                         */
+                        input_report_key(input, BTN_1, (data[4] & 0x01));
+                        input_report_key(input, BTN_2, (data[4] & 0x02));
+                        input_report_key(input, BTN_3, (data[4] & 0x04));
+                        input_report_key(input, BTN_4, (data[4] & 0x08));
+
+                        input_report_key(input, BTN_5, (data[4] & 0x10));  /* Right  */
+                        input_report_key(input, BTN_6, (data[4] & 0x20));  /* Up     */
+                        input_report_key(input, BTN_7, (data[4] & 0x40));  /* Left   */
+                        input_report_key(input, BTN_8, (data[4] & 0x80));  /* Down   */
+                        input_report_key(input, BTN_0, (data[3] & 0x01));  /* Center */
+                } else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
                         int i;
 
                         /* Touch ring mode switch has no capacitive sensor */
                         input_report_key(input, BTN_0, (data[3] & 0x01));
 
                         /*
-                         * ExpressKeys on Intuos5 have a capacitive sensor in
+                         * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
                          * addition to the mechanical switch. Switch data is
                          * stored in data[4], capacitive data in data[5].
                          */
@@ -716,7 +739,9 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
              features->type == INTUOS4 ||
              features->type == INTUOS4S ||
              features->type == INTUOS5 ||
-             features->type == INTUOS5S)) {
+             features->type == INTUOS5S ||
+             features->type == INTUOSPM ||
+             features->type == INTUOSPS)) {
 
                 return 0;
         }
@@ -769,8 +794,7 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
 
                 } else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
                         /* I4 mouse */
-                        if ((features->type >= INTUOS4S && features->type <= INTUOS4L) ||
-                            (features->type >= INTUOS5S && features->type <= INTUOS5L)) {
+                        if (features->type >= INTUOS4S && features->type <= INTUOSPL) {
                                 input_report_key(input, BTN_LEFT,   data[6] & 0x01);
                                 input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
                                 input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
@@ -797,7 +821,8 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
                                 }
                         }
                 } else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
-                                features->type == INTUOS4L || features->type == INTUOS5L) &&
+                                features->type == INTUOS4L || features->type == INTUOS5L ||
+                                features->type == INTUOSPL) &&
                            wacom->tool[idx] == BTN_TOOL_LENS) {
                         /* Lens cursor packets */
                         input_report_key(input, BTN_LEFT,   data[8] & 0x01);
@@ -1107,6 +1132,7 @@ static int wacom_bpt_touch(struct wacom_wac *wacom)
 
 static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
 {
+        struct wacom_features *features = &wacom->features;
         struct input_dev *input = wacom->input;
         bool touch = data[1] & 0x80;
         int slot = input_mt_get_slot_by_key(input, data[0]);
@@ -1122,14 +1148,23 @@ static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
         if (touch) {
                 int x = (data[2] << 4) | (data[4] >> 4);
                 int y = (data[3] << 4) | (data[4] & 0x0f);
-                int a = data[5];
+                int width, height;
 
-                // "a" is a scaled-down area which we assume is roughly
-                // circular and which can be described as: a=(pi*r^2)/C.
-                int x_res  = input_abs_get_res(input, ABS_X);
-                int y_res  = input_abs_get_res(input, ABS_Y);
-                int width  = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
-                int height = width * y_res / x_res;
+                if (features->type >= INTUOSPS && features->type <= INTUOSPL) {
+                        width  = data[5];
+                        height = data[6];
+                } else {
+                        /*
+                         * "a" is a scaled-down area which we assume is
+                         * roughly circular and which can be described as:
+                         * a=(pi*r^2)/C.
+                         */
+                        int a = data[5];
+                        int x_res  = input_abs_get_res(input, ABS_X);
+                        int y_res  = input_abs_get_res(input, ABS_Y);
+                        width  = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
+                        height = width * y_res / x_res;
+                }
 
                 input_report_abs(input, ABS_MT_POSITION_X, x);
                 input_report_abs(input, ABS_MT_POSITION_Y, y);
@@ -1327,6 +1362,7 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
         case WACOM_22HD:
         case WACOM_24HD:
         case DTK:
+        case CINTIQ_HYBRID:
                 sync = wacom_intuos_irq(wacom_wac);
                 break;
 
@@ -1337,6 +1373,9 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
         case INTUOS5S:
         case INTUOS5:
         case INTUOS5L:
+        case INTUOSPS:
+        case INTUOSPM:
+        case INTUOSPL:
                 if (len == WACOM_PKGLEN_BBTOUCH3)
                         sync = wacom_bpt3_touch(wacom_wac);
                 else
@@ -1420,7 +1459,7 @@ void wacom_setup_device_quirks(struct wacom_features *features)
 
         /* these device have multiple inputs */
         if (features->type >= WIRELESS ||
-            (features->type >= INTUOS5S && features->type <= INTUOS5L) ||
+            (features->type >= INTUOS5S && features->type <= INTUOSPL) ||
             (features->oVid && features->oPid))
                 features->quirks |= WACOM_QUIRK_MULTI_INPUT;
 
@@ -1627,6 +1666,8 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
 
         case INTUOS5:
         case INTUOS5L:
+        case INTUOSPM:
+        case INTUOSPL:
                 if (features->device_type == BTN_TOOL_PEN) {
                         __set_bit(BTN_7, input_dev->keybit);
                         __set_bit(BTN_8, input_dev->keybit);
@@ -1634,6 +1675,7 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
                 /* fall through */
 
         case INTUOS5S:
+        case INTUOSPS:
                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
 
                 if (features->device_type == BTN_TOOL_PEN) {
@@ -1765,6 +1807,24 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
                                               0, 0);
                 }
                 break;
+
+        case CINTIQ_HYBRID:
+                __set_bit(BTN_1, input_dev->keybit);
+                __set_bit(BTN_2, input_dev->keybit);
+                __set_bit(BTN_3, input_dev->keybit);
+                __set_bit(BTN_4, input_dev->keybit);
+
+                __set_bit(BTN_5, input_dev->keybit);
+                __set_bit(BTN_6, input_dev->keybit);
+                __set_bit(BTN_7, input_dev->keybit);
+                __set_bit(BTN_8, input_dev->keybit);
+                __set_bit(BTN_0, input_dev->keybit);
+
+                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
+                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
+
+                wacom_setup_cintiq(wacom_wac);
+                break;
         }
         return 0;
 }
@@ -1952,6 +2012,18 @@ static const struct wacom_features wacom_features_0x29 =
 static const struct wacom_features wacom_features_0x2A =
         { "Wacom Intuos5 M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
           63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
+static const struct wacom_features wacom_features_0x314 =
+        { "Wacom Intuos Pro S", WACOM_PKGLEN_INTUOS,  31496, 19685, 2047,
+          63, INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
+          .touch_max = 16 };
+static const struct wacom_features wacom_features_0x315 =
+        { "Wacom Intuos Pro M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
+          63, INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
+          .touch_max = 16 };
+static const struct wacom_features wacom_features_0x317 =
+        { "Wacom Intuos Pro L", WACOM_PKGLEN_INTUOS,  65024, 40640, 2047,
+          63, INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
+          .touch_max = 16 };
 static const struct wacom_features wacom_features_0xF4 =
         { "Wacom Cintiq 24HD",       WACOM_PKGLEN_INTUOS,   104480, 65600, 2047,
           63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
@@ -2131,6 +2203,13 @@ static const struct wacom_features wacom_features_0x301 =
 static const struct wacom_features wacom_features_0x6004 =
         { "ISD-V4",               WACOM_PKGLEN_GRAPHIRE,  12800,  8000,  255,
           0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0x0307 =
+        { "Wacom ISDv5 307", WACOM_PKGLEN_INTUOS,  59552,  33848, 2047,
+          63, CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
+          .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
+static const struct wacom_features wacom_features_0x0309 =
+        { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
+          .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10 };
 
 #define USB_DEVICE_WACOM(prod)                                  \
         USB_DEVICE(USB_VENDOR_ID_WACOM, prod),                  \
@@ -2259,12 +2338,17 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x300) },
         { USB_DEVICE_WACOM(0x301) },
         { USB_DEVICE_WACOM(0x304) },
+        { USB_DEVICE_DETAILED(0x314, USB_CLASS_HID, 0, 0) },
+        { USB_DEVICE_DETAILED(0x315, USB_CLASS_HID, 0, 0) },
+        { USB_DEVICE_DETAILED(0x317, USB_CLASS_HID, 0, 0) },
         { USB_DEVICE_WACOM(0x4001) },
         { USB_DEVICE_WACOM(0x47) },
         { USB_DEVICE_WACOM(0xF4) },
         { USB_DEVICE_WACOM(0xF8) },
         { USB_DEVICE_DETAILED(0xF6, USB_CLASS_HID, 0, 0) },
         { USB_DEVICE_WACOM(0xFA) },
+        { USB_DEVICE_WACOM(0x0307) },
+        { USB_DEVICE_DETAILED(0x0309, USB_CLASS_HID, 0, 0) },
         { USB_DEVICE_LENOVO(0x6004) },
         { }
 };
diff --git a/drivers/input/tablet/wacom_wac.h b/drivers/input/tablet/wacom_wac.h
index dfc9e08e7f70..fd23a3790605 100644
--- a/drivers/input/tablet/wacom_wac.h
+++ b/drivers/input/tablet/wacom_wac.h
@@ -14,6 +14,8 @@
 /* maximum packet length for USB devices */
 #define WACOM_PKGLEN_MAX        64
 
+#define WACOM_NAME_MAX          64
+
 /* packet length for individual models */
 #define WACOM_PKGLEN_PENPRTN     7
 #define WACOM_PKGLEN_GRAPHIRE    8
@@ -76,10 +78,14 @@ enum {
         INTUOS5S,
         INTUOS5,
         INTUOS5L,
+        INTUOSPS,
+        INTUOSPM,
+        INTUOSPL,
         WACOM_21UX2,
         WACOM_22HD,
         DTK,
         WACOM_24HD,
+        CINTIQ_HYBRID,
         CINTIQ,
         WACOM_BEE,
         WACOM_13HD,
@@ -126,7 +132,7 @@ struct wacom_shared {
 };
 
 struct wacom_wac {
-        char name[64];
+        char name[WACOM_NAME_MAX];
         unsigned char *data;
         int tool[2];
         int id[2];