Merge branch 'for-4.19/cougar' into for-linus

New device support for hid-cougar

12 files changed, 371 insertions, 29 deletions

diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index a49a10437c40..61e1953ff921 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -207,6 +207,16 @@ config HID_CORSAIR
         - Vengeance K90
         - Scimitar PRO RGB
 
+config HID_COUGAR
+        tristate "Cougar devices"
+        depends on HID
+        help
+        Support for Cougar devices that are not fully compliant with the
+        HID standard.
+
+        Supported devices:
+        - Cougar 500k Gaming Keyboard
+
 config HID_PRODIKEYS
         tristate "Prodikeys PC-MIDI Keyboard support"
         depends on HID && SND
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 511e1cbff768..bd7ac53b75c5 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -35,6 +35,7 @@ obj-$(CONFIG_HID_CHERRY)	+= hid-cherry.o
 obj-$(CONFIG_HID_CHICONY)       += hid-chicony.o
 obj-$(CONFIG_HID_CMEDIA)        += hid-cmedia.o
 obj-$(CONFIG_HID_CORSAIR)       += hid-corsair.o
+obj-$(CONFIG_HID_COUGAR)        += hid-cougar.o
 obj-$(CONFIG_HID_CP2112)        += hid-cp2112.o
 obj-$(CONFIG_HID_CYPRESS)       += hid-cypress.o
 obj-$(CONFIG_HID_DRAGONRISE)    += hid-dr.o
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index a460ec147aee..402ad974b31c 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -134,8 +134,11 @@ static int open_collection(struct hid_parser *parser, unsigned type)
         }
 
         if (parser->device->maxcollection == parser->device->collection_size) {
-                collection = kmalloc(sizeof(struct hid_collection) *
-                                parser->device->collection_size * 2, GFP_KERNEL);
+                collection = kmalloc(
+                                array3_size(sizeof(struct hid_collection),
+                                            parser->device->collection_size,
+                                            2),
+                                GFP_KERNEL);
                 if (collection == NULL) {
                         hid_err(parser->device, "failed to reallocate collection array\n");
                         return -ENOMEM;
@@ -1278,7 +1281,7 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field,
         __s32 max = field->logical_maximum;
         __s32 *value;
 
-        value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);
+        value = kmalloc_array(count, sizeof(__s32), GFP_ATOMIC);
         if (!value)
                 return;
 
@@ -1936,6 +1939,29 @@ static int hid_bus_match(struct device *dev, struct device_driver *drv)
         return hid_match_device(hdev, hdrv) != NULL;
 }
 
+/**
+ * hid_compare_device_paths - check if both devices share the same path
+ * @hdev_a: hid device
+ * @hdev_b: hid device
+ * @separator: char to use as separator
+ *
+ * Check if two devices share the same path up to the last occurrence of
+ * the separator char. Both paths must exist (i.e., zero-length paths
+ * don't match).
+ */
+bool hid_compare_device_paths(struct hid_device *hdev_a,
+                              struct hid_device *hdev_b, char separator)
+{
+        int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys;
+        int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys;
+
+        if (n1 != n2 || n1 <= 0 || n2 <= 0)
+                return false;
+
+        return !strncmp(hdev_a->phys, hdev_b->phys, n1);
+}
+EXPORT_SYMBOL_GPL(hid_compare_device_paths);
+
 static int hid_device_probe(struct device *dev)
 {
         struct hid_driver *hdrv = to_hid_driver(dev->driver);
diff --git a/drivers/hid/hid-cougar.c b/drivers/hid/hid-cougar.c
new file mode 100644
index 000000000000..ad2e87de7dc5
--- /dev/null
+++ b/drivers/hid/hid-cougar.c
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ *  HID driver for Cougar 500k Gaming Keyboard
+ *
+ *  Copyright (c) 2018 Daniel M. Lambea <dmlambea@gmail.com>
+ */
+
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+MODULE_AUTHOR("Daniel M. Lambea <dmlambea@gmail.com>");
+MODULE_DESCRIPTION("Cougar 500k Gaming Keyboard");
+MODULE_LICENSE("GPL");
+MODULE_INFO(key_mappings, "G1-G6 are mapped to F13-F18");
+
+static int cougar_g6_is_space = 1;
+module_param_named(g6_is_space, cougar_g6_is_space, int, 0600);
+MODULE_PARM_DESC(g6_is_space,
+        "If set, G6 programmable key sends SPACE instead of F18 (0=off, 1=on) (default=1)");
+
+
+#define COUGAR_VENDOR_USAGE     0xff00ff00
+
+#define COUGAR_FIELD_CODE       1
+#define COUGAR_FIELD_ACTION     2
+
+#define COUGAR_KEY_G1           0x83
+#define COUGAR_KEY_G2           0x84
+#define COUGAR_KEY_G3           0x85
+#define COUGAR_KEY_G4           0x86
+#define COUGAR_KEY_G5           0x87
+#define COUGAR_KEY_G6           0x78
+#define COUGAR_KEY_FN           0x0d
+#define COUGAR_KEY_MR           0x6f
+#define COUGAR_KEY_M1           0x80
+#define COUGAR_KEY_M2           0x81
+#define COUGAR_KEY_M3           0x82
+#define COUGAR_KEY_LEDS         0x67
+#define COUGAR_KEY_LOCK         0x6e
+
+
+/* Default key mappings. The special key COUGAR_KEY_G6 is defined first
+ * because it is more frequent to use the spacebar rather than any other
+ * special keys. Depending on the value of the parameter 'g6_is_space',
+ * the mapping will be updated in the probe function.
+ */
+static unsigned char cougar_mapping[][2] = {
+        { COUGAR_KEY_G6,   KEY_SPACE },
+        { COUGAR_KEY_G1,   KEY_F13 },
+        { COUGAR_KEY_G2,   KEY_F14 },
+        { COUGAR_KEY_G3,   KEY_F15 },
+        { COUGAR_KEY_G4,   KEY_F16 },
+        { COUGAR_KEY_G5,   KEY_F17 },
+        { COUGAR_KEY_LOCK, KEY_SCREENLOCK },
+/* The following keys are handled by the hardware itself, so no special
+ * treatment is required:
+        { COUGAR_KEY_FN, KEY_RESERVED },
+        { COUGAR_KEY_MR, KEY_RESERVED },
+        { COUGAR_KEY_M1, KEY_RESERVED },
+        { COUGAR_KEY_M2, KEY_RESERVED },
+        { COUGAR_KEY_M3, KEY_RESERVED },
+        { COUGAR_KEY_LEDS, KEY_RESERVED },
+*/
+        { 0, 0 },
+};
+
+struct cougar_shared {
+        struct list_head list;
+        struct kref kref;
+        bool enabled;
+        struct hid_device *dev;
+        struct input_dev *input;
+};
+
+struct cougar {
+        bool special_intf;
+        struct cougar_shared *shared;
+};
+
+static LIST_HEAD(cougar_udev_list);
+static DEFINE_MUTEX(cougar_udev_list_lock);
+
+static void cougar_fix_g6_mapping(struct hid_device *hdev)
+{
+        int i;
+
+        for (i = 0; cougar_mapping[i][0]; i++) {
+                if (cougar_mapping[i][0] == COUGAR_KEY_G6) {
+                        cougar_mapping[i][1] =
+                                cougar_g6_is_space ? KEY_SPACE : KEY_F18;
+                        hid_info(hdev, "G6 mapped to %s\n",
+                                 cougar_g6_is_space ? "space" : "F18");
+                        return;
+                }
+        }
+        hid_warn(hdev, "no mapping defined for G6/spacebar");
+}
+
+/*
+ * Constant-friendly rdesc fixup for mouse interface
+ */
+static __u8 *cougar_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                                 unsigned int *rsize)
+{
+        if (rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
+            (rdesc[115] | rdesc[116] << 8) >= HID_MAX_USAGES) {
+                hid_info(hdev,
+                        "usage count exceeds max: fixing up report descriptor\n");
+                rdesc[115] = ((HID_MAX_USAGES-1) & 0xff);
+                rdesc[116] = ((HID_MAX_USAGES-1) >> 8);
+        }
+        return rdesc;
+}
+
+static struct cougar_shared *cougar_get_shared_data(struct hid_device *hdev)
+{
+        struct cougar_shared *shared;
+
+        /* Try to find an already-probed interface from the same device */
+        list_for_each_entry(shared, &cougar_udev_list, list) {
+                if (hid_compare_device_paths(hdev, shared->dev, '/')) {
+                        kref_get(&shared->kref);
+                        return shared;
+                }
+        }
+        return NULL;
+}
+
+static void cougar_release_shared_data(struct kref *kref)
+{
+        struct cougar_shared *shared = container_of(kref,
+                                                    struct cougar_shared, kref);
+
+        mutex_lock(&cougar_udev_list_lock);
+        list_del(&shared->list);
+        mutex_unlock(&cougar_udev_list_lock);
+
+        kfree(shared);
+}
+
+static void cougar_remove_shared_data(void *resource)
+{
+        struct cougar *cougar = resource;
+
+        if (cougar->shared) {
+                kref_put(&cougar->shared->kref, cougar_release_shared_data);
+                cougar->shared = NULL;
+        }
+}
+
+/*
+ * Bind the device group's shared data to this cougar struct.
+ * If no shared data exists for this group, create and initialize it.
+ */
+static int cougar_bind_shared_data(struct hid_device *hdev, struct cougar *cougar)
+{
+        struct cougar_shared *shared;
+        int error = 0;
+
+        mutex_lock(&cougar_udev_list_lock);
+
+        shared = cougar_get_shared_data(hdev);
+        if (!shared) {
+                shared = kzalloc(sizeof(*shared), GFP_KERNEL);
+                if (!shared) {
+                        error = -ENOMEM;
+                        goto out;
+                }
+
+                kref_init(&shared->kref);
+                shared->dev = hdev;
+                list_add_tail(&shared->list, &cougar_udev_list);
+        }
+
+        cougar->shared = shared;
+
+        error = devm_add_action(&hdev->dev, cougar_remove_shared_data, cougar);
+        if (error) {
+                mutex_unlock(&cougar_udev_list_lock);
+                cougar_remove_shared_data(cougar);
+                return error;
+        }
+
+out:
+        mutex_unlock(&cougar_udev_list_lock);
+        return error;
+}
+
+static int cougar_probe(struct hid_device *hdev,
+                        const struct hid_device_id *id)
+{
+        struct cougar *cougar;
+        struct hid_input *next, *hidinput = NULL;
+        unsigned int connect_mask;
+        int error;
+
+        cougar = devm_kzalloc(&hdev->dev, sizeof(*cougar), GFP_KERNEL);
+        if (!cougar)
+                return -ENOMEM;
+        hid_set_drvdata(hdev, cougar);
+
+        error = hid_parse(hdev);
+        if (error) {
+                hid_err(hdev, "parse failed\n");
+                goto fail;
+        }
+
+        if (hdev->collection->usage == COUGAR_VENDOR_USAGE) {
+                cougar->special_intf = true;
+                connect_mask = HID_CONNECT_HIDRAW;
+        } else
+                connect_mask = HID_CONNECT_DEFAULT;
+
+        error = hid_hw_start(hdev, connect_mask);
+        if (error) {
+                hid_err(hdev, "hw start failed\n");
+                goto fail;
+        }
+
+        error = cougar_bind_shared_data(hdev, cougar);
+        if (error)
+                goto fail_stop_and_cleanup;
+
+        /* The custom vendor interface will use the hid_input registered
+         * for the keyboard interface, in order to send translated key codes
+         * to it.
+         */
+        if (hdev->collection->usage == HID_GD_KEYBOARD) {
+                cougar_fix_g6_mapping(hdev);
+                list_for_each_entry_safe(hidinput, next, &hdev->inputs, list) {
+                        if (hidinput->registered && hidinput->input != NULL) {
+                                cougar->shared->input = hidinput->input;
+                                cougar->shared->enabled = true;
+                                break;
+                        }
+                }
+        } else if (hdev->collection->usage == COUGAR_VENDOR_USAGE) {
+                error = hid_hw_open(hdev);
+                if (error)
+                        goto fail_stop_and_cleanup;
+        }
+        return 0;
+
+fail_stop_and_cleanup:
+        hid_hw_stop(hdev);
+fail:
+        hid_set_drvdata(hdev, NULL);
+        return error;
+}
+
+/*
+ * Convert events from vendor intf to input key events
+ */
+static int cougar_raw_event(struct hid_device *hdev, struct hid_report *report,
+                            u8 *data, int size)
+{
+        struct cougar *cougar;
+        unsigned char code, action;
+        int i;
+
+        cougar = hid_get_drvdata(hdev);
+        if (!cougar->special_intf || !cougar->shared ||
+            !cougar->shared->input || !cougar->shared->enabled)
+                return 0;
+
+        code = data[COUGAR_FIELD_CODE];
+        action = data[COUGAR_FIELD_ACTION];
+        for (i = 0; cougar_mapping[i][0]; i++) {
+                if (code == cougar_mapping[i][0]) {
+                        input_event(cougar->shared->input, EV_KEY,
+                                    cougar_mapping[i][1], action);
+                        input_sync(cougar->shared->input);
+                        return 0;
+                }
+        }
+        hid_warn(hdev, "unmapped special key code %x: ignoring\n", code);
+        return 0;
+}
+
+static void cougar_remove(struct hid_device *hdev)
+{
+        struct cougar *cougar = hid_get_drvdata(hdev);
+
+        if (cougar) {
+                /* Stop the vendor intf to process more events */
+                if (cougar->shared)
+                        cougar->shared->enabled = false;
+                if (cougar->special_intf)
+                        hid_hw_close(hdev);
+        }
+        hid_hw_stop(hdev);
+}
+
+static struct hid_device_id cougar_id_table[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SOLID_YEAR,
+                         USB_DEVICE_ID_COUGAR_500K_GAMING_KEYBOARD) },
+        {}
+};
+MODULE_DEVICE_TABLE(hid, cougar_id_table);
+
+static struct hid_driver cougar_driver = {
+        .name                   = "cougar",
+        .id_table               = cougar_id_table,
+        .report_fixup           = cougar_report_fixup,
+        .probe                  = cougar_probe,
+        .remove                 = cougar_remove,
+        .raw_event              = cougar_raw_event,
+};
+
+module_hid_driver(cougar_driver);
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index 4db8e140f709..b48100236df8 100644
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -457,7 +457,7 @@ static char *resolv_usage_page(unsigned page, struct seq_file *f) {
         char *buf = NULL;
 
         if (!f) {
-                buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
+                buf = kzalloc(HID_DEBUG_BUFSIZE, GFP_ATOMIC);
                 if (!buf)
                         return ERR_PTR(-ENOMEM);
         }
@@ -685,7 +685,7 @@ void hid_dump_report(struct hid_device *hid, int type, u8 *data,
         char *buf;
         unsigned int i;
 
-        buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
+        buf = kmalloc(HID_DEBUG_BUFSIZE, GFP_ATOMIC);
 
         if (!buf)
                 return;
@@ -1088,7 +1088,7 @@ static int hid_debug_events_open(struct inode *inode, struct file *file)
                 goto out;
         }
 
-        if (!(list->hid_debug_buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_KERNEL))) {
+        if (!(list->hid_debug_buf = kzalloc(HID_DEBUG_BUFSIZE, GFP_KERNEL))) {
                 err = -ENOMEM;
                 kfree(list);
                 goto out;
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index c7981ddd8776..a1ee8f643f24 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -1001,6 +1001,9 @@
 #define USB_VENDOR_ID_SINO_LITE                 0x1345
 #define USB_DEVICE_ID_SINO_LITE_CONTROLLER      0x3008
 
+#define USB_VENDOR_ID_SOLID_YEAR                        0x060b
+#define USB_DEVICE_ID_COUGAR_500K_GAMING_KEYBOARD       0x500a
+
 #define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST     0x0034
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST      0x0046
diff --git a/drivers/hid/hid-picolcd_fb.c b/drivers/hid/hid-picolcd_fb.c
index 7f965e231433..864a084b6cba 100644
--- a/drivers/hid/hid-picolcd_fb.c
+++ b/drivers/hid/hid-picolcd_fb.c
@@ -394,7 +394,8 @@ static int picolcd_set_par(struct fb_info *info)
                 return -EINVAL;
 
         o_fb   = fbdata->bitmap;
-        tmp_fb = kmalloc(PICOLCDFB_SIZE*info->var.bits_per_pixel, GFP_KERNEL);
+        tmp_fb = kmalloc_array(PICOLCDFB_SIZE, info->var.bits_per_pixel,
+                               GFP_KERNEL);
         if (!tmp_fb)
                 return -ENOMEM;
 
diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c
index 25363fc571bc..50af72baa5ca 100644
--- a/drivers/hid/hid-sensor-hub.c
+++ b/drivers/hid/hid-sensor-hub.c
@@ -624,7 +624,8 @@ static int sensor_hub_probe(struct hid_device *hdev,
                 ret = -EINVAL;
                 goto err_stop_hw;
         }
-        sd->hid_sensor_hub_client_devs = devm_kzalloc(&hdev->dev, dev_cnt *
+        sd->hid_sensor_hub_client_devs = devm_kcalloc(&hdev->dev,
+                                                      dev_cnt,
                                                       sizeof(struct mfd_cell),
                                                       GFP_KERNEL);
         if (sd->hid_sensor_hub_client_devs == NULL) {
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index b39844adea47..4a44e48e08b2 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -218,7 +218,7 @@ static ssize_t hidraw_get_report(struct file *file, char __user *buffer, size_t
                 goto out;
         }
 
-        buf = kmalloc(count * sizeof(__u8), GFP_KERNEL);
+        buf = kmalloc(count, GFP_KERNEL);
         if (!buf) {
                 ret = -ENOMEM;
                 goto out;
diff --git a/drivers/hid/intel-ish-hid/ishtp-hid-client.c b/drivers/hid/intel-ish-hid/ishtp-hid-client.c
index acc2536c8094..2d28cffc1404 100644
--- a/drivers/hid/intel-ish-hid/ishtp-hid-client.c
+++ b/drivers/hid/intel-ish-hid/ishtp-hid-client.c
@@ -121,9 +121,9 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
                         }
                         client_data->hid_dev_count = (unsigned int)*payload;
                         if (!client_data->hid_devices)
-                                client_data->hid_devices = devm_kzalloc(
+                                client_data->hid_devices = devm_kcalloc(
                                                 &client_data->cl_device->dev,
-                                                client_data->hid_dev_count *
+                                                client_data->hid_dev_count,
                                                 sizeof(struct device_info),
                                                 GFP_KERNEL);
                         if (!client_data->hid_devices) {
diff --git a/drivers/hid/usbhid/Kconfig b/drivers/hid/usbhid/Kconfig
index 0108c5991a04..e50d8fe4d36c 100644
--- a/drivers/hid/usbhid/Kconfig
+++ b/drivers/hid/usbhid/Kconfig
@@ -14,7 +14,7 @@ config USB_HID
 
           You can't use this driver and the HIDBP (Boot Protocol) keyboard
           and mouse drivers at the same time. More information is available:
-          <file:Documentation/input/input.txt>.
+          <file:Documentation/input/input.rst>.
 
           If unsure, say Y.
 
diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
index 545986cfb978..ffe59a19b3a3 100644
--- a/drivers/hid/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -703,18 +703,6 @@ struct wacom_hdev_data {
 static LIST_HEAD(wacom_udev_list);
 static DEFINE_MUTEX(wacom_udev_list_lock);
 
-static bool compare_device_paths(struct hid_device *hdev_a,
-                struct hid_device *hdev_b, char separator)
-{
-        int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys;
-        int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys;
-
-        if (n1 != n2 || n1 <= 0 || n2 <= 0)
-                return false;
-
-        return !strncmp(hdev_a->phys, hdev_b->phys, n1);
-}
-
 static bool wacom_are_sibling(struct hid_device *hdev,
                 struct hid_device *sibling)
 {
@@ -737,10 +725,10 @@ static bool wacom_are_sibling(struct hid_device *hdev,
          * the same physical parent device path.
          */
         if (hdev->vendor == sibling->vendor && hdev->product == sibling->product) {
-                if (!compare_device_paths(hdev, sibling, '/'))
+                if (!hid_compare_device_paths(hdev, sibling, '/'))
                         return false;
         } else {
-                if (!compare_device_paths(hdev, sibling, '.'))
+                if (!hid_compare_device_paths(hdev, sibling, '.'))
                         return false;
         }
 
@@ -787,7 +775,7 @@ static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
 
         /* Try to find an already-probed interface from the same device */
         list_for_each_entry(data, &wacom_udev_list, list) {
-                if (compare_device_paths(hdev, data->dev, '/')) {
+                if (hid_compare_device_paths(hdev, data->dev, '/')) {
                         kref_get(&data->kref);
                         return data;
                 }
@@ -1371,7 +1359,7 @@ static int wacom_led_groups_alloc_and_register_one(struct device *dev,
         if (!devres_open_group(dev, &wacom->led.groups[group_id], GFP_KERNEL))
                 return -ENOMEM;
 
-        leds = devm_kzalloc(dev, sizeof(struct wacom_led) * count, GFP_KERNEL);
+        leds = devm_kcalloc(dev, count, sizeof(struct wacom_led), GFP_KERNEL);
         if (!leds) {
                 error = -ENOMEM;
                 goto err;
@@ -1471,7 +1459,7 @@ static int wacom_led_groups_allocate(struct wacom *wacom, int count)
         struct wacom_group_leds *groups;
         int error;
 
-        groups = devm_kzalloc(dev, sizeof(struct wacom_group_leds) * count,
+        groups = devm_kcalloc(dev, count, sizeof(struct wacom_group_leds),
                               GFP_KERNEL);
         if (!groups)
                 return -ENOMEM;