// SPDX-License-Identifier: GPL-2.0+
/*
 *  HID driver for gaming keys on Logitech gaming keyboards (such as the G15)
 *
 *  Copyright (c) 2019 Hans de Goede <hdegoede@redhat.com>
 */

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/leds.h>
#include <linux/led-class-multicolor.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/sched.h>
#include <linux/usb.h>
#include <linux/wait.h>
#include <dt-bindings/leds/common.h>

#include "hid-ids.h"

#define LG_G15_TRANSFER_BUF_SIZE        20

#define LG_G15_FEATURE_REPORT           0x02

#define LG_G510_FEATURE_M_KEYS_LEDS     0x04
#define LG_G510_FEATURE_BACKLIGHT_RGB   0x05
#define LG_G510_FEATURE_POWER_ON_RGB    0x06

#define LG_G510_INPUT_MACRO_KEYS        0x03
#define LG_G510_INPUT_KBD_BACKLIGHT     0x04

#define LG_G13_INPUT_REPORT             0x01
#define LG_G13_FEATURE_M_KEYS_LEDS      0x05
#define LG_G13_FEATURE_BACKLIGHT_RGB    0x07
#define LG_G13_BACKLIGHT_HW_ON_BIT      23

/**
 * g13_input_report.keybits[] is not 32-bit aligned, so we can't use the bitops macros.
 *
 * @ary: Pointer to array of u8s
 * @b: Bit index into ary, LSB first.  Not range checked.
 */
#define TEST_BIT(ary, b)        ((1 << ((b) & 7)) & (ary)[(b) >> 3])

enum lg_g15_model {
        LG_G13,
        LG_G15,
        LG_G15_V2,
        LG_G510,
        LG_G510_USB_AUDIO,
        LG_Z10,
};

enum lg_g15_led_type {
        LG_G15_KBD_BRIGHTNESS,
        LG_G15_LCD_BRIGHTNESS,
        LG_G15_BRIGHTNESS_MAX,
        LG_G15_MACRO_PRESET1 = 2,
        LG_G15_MACRO_PRESET2,
        LG_G15_MACRO_PRESET3,
        LG_G15_MACRO_RECORD,
        LG_G15_LED_MAX
};

struct g13_input_report {
        u8 report_id;   /* Report ID is always set to 1. */
        u8 joy_x, joy_y;
        u8 keybits[5];
};

struct lg_g15_led {
        union {
                struct led_classdev cdev;
                struct led_classdev_mc mcdev;
        };
        enum led_brightness brightness;
        enum lg_g15_led_type led;
        /* Used to store initial color intensities before subled_info is allocated */
        u8 red, green, blue;
};

struct lg_g15_data {
        /* Must be first for proper dma alignment */
        u8 transfer_buf[LG_G15_TRANSFER_BUF_SIZE];
        /* Protects the transfer_buf and led brightness */
        struct mutex mutex;
        struct work_struct work;
        struct input_dev *input;
        struct input_dev *input_js; /* Separate joystick device for G13. */
        struct hid_device *hdev;
        enum lg_g15_model model;
        struct lg_g15_led leds[LG_G15_LED_MAX];
        bool game_mode_enabled;
        bool backlight_disabled;        /* true == HW backlight toggled *OFF* */
};

/********* G13 LED functions ***********/
/*
 * G13 retains no state across power cycles, and always powers up with the backlight on,
 * color #5AFF6E, all macro key LEDs off.
 */
static int lg_g13_get_leds_state(struct lg_g15_data *g15)
{
        u8 * const tbuf = g15->transfer_buf;
        int ret, high;

        /* RGB backlight. */
        ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_BACKLIGHT_RGB,
                                 tbuf, 5,
                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
        if (ret != 5) {
                hid_err(g15->hdev, "Error getting backlight brightness: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }

        /* Normalize RGB intensities against the highest component. */
        high = max3(tbuf[1], tbuf[2], tbuf[3]);
        if (high) {
                g15->leds[LG_G15_KBD_BRIGHTNESS].red =
                        DIV_ROUND_CLOSEST(tbuf[1] * 255, high);
                g15->leds[LG_G15_KBD_BRIGHTNESS].green =
                        DIV_ROUND_CLOSEST(tbuf[2] * 255, high);
                g15->leds[LG_G15_KBD_BRIGHTNESS].blue =
                        DIV_ROUND_CLOSEST(tbuf[3] * 255, high);
                g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = high;
        } else {
                g15->leds[LG_G15_KBD_BRIGHTNESS].red        = 255;
                g15->leds[LG_G15_KBD_BRIGHTNESS].green      = 255;
                g15->leds[LG_G15_KBD_BRIGHTNESS].blue       = 255;
                g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = 0;
        }

        /* Macro LEDs. */
        ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_M_KEYS_LEDS,
                                 tbuf, 5,
                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
        if (ret != 5) {
                hid_err(g15->hdev, "Error getting macro LED brightness: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }

        for (int i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; ++i)
                g15->leds[i].brightness = !!(tbuf[1] & (1 << (i - LG_G15_MACRO_PRESET1)));

        /*
         * Bit 23 of g13_input_report.keybits[] contains the backlight's
         * current HW toggle state.  Retrieve it from the device.
         */
        ret = hid_hw_raw_request(g15->hdev, LG_G13_INPUT_REPORT,
                                 tbuf, sizeof(struct g13_input_report),
                                 HID_INPUT_REPORT, HID_REQ_GET_REPORT);
        if (ret != sizeof(struct g13_input_report)) {
                hid_err(g15->hdev, "Error getting backlight on/off state: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }
        g15->backlight_disabled =
                !TEST_BIT(((struct g13_input_report *) tbuf)->keybits,
                          LG_G13_BACKLIGHT_HW_ON_BIT);

        return 0;
}

static int lg_g13_kbd_led_write(struct lg_g15_data *g15,
                                struct lg_g15_led *g15_led,
                                enum led_brightness brightness)
{
        struct mc_subled const * const subleds = g15_led->mcdev.subled_info;
        u8 * const tbuf = g15->transfer_buf;
        int ret;

        guard(mutex)(&g15->mutex);

        led_mc_calc_color_components(&g15_led->mcdev, brightness);

        tbuf[0] = 5;
        tbuf[1] = subleds[0].brightness;
        tbuf[2] = subleds[1].brightness;
        tbuf[3] = subleds[2].brightness;
        tbuf[4] = 0;

        ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_BACKLIGHT_RGB,
                                 tbuf, 5,
                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
        if (ret != 5) {
                hid_err(g15->hdev, "Error setting backlight brightness: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }

        g15_led->brightness = brightness;
        return 0;
}

static int lg_g13_kbd_led_set(struct led_classdev *led_cdev, enum led_brightness brightness)
{
        struct led_classdev_mc *mc = lcdev_to_mccdev(led_cdev);
        struct lg_g15_led *g15_led =
                container_of(mc, struct lg_g15_led, mcdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);

        /* Ignore LED off on unregister / keyboard unplug */
        if (led_cdev->flags & LED_UNREGISTERING)
                return 0;

        return lg_g13_kbd_led_write(g15, g15_led, brightness);
}

static enum led_brightness lg_g13_kbd_led_get(struct led_classdev *led_cdev)
{
        struct led_classdev_mc const * const mc = lcdev_to_mccdev(led_cdev);
        struct lg_g15_led const *g15_led =
                container_of(mc, struct lg_g15_led, mcdev);

        return g15_led->brightness;
}

static int lg_g13_mkey_led_set(struct led_classdev *led_cdev, enum led_brightness brightness)
{
        struct lg_g15_led *g15_led =
                container_of(led_cdev, struct lg_g15_led, cdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
        int i, ret;
        u8 * const tbuf = g15->transfer_buf;
        u8 val, mask = 0;

        /* Ignore LED off on unregister / keyboard unplug */
        if (led_cdev->flags & LED_UNREGISTERING)
                return 0;

        guard(mutex)(&g15->mutex);

        for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; ++i) {
                if (i == g15_led->led)
                        val = brightness;
                else
                        val = g15->leds[i].brightness;

                if (val)
                        mask |= 1 << (i - LG_G15_MACRO_PRESET1);
        }

        tbuf[0] = 5;
        tbuf[1] = mask;
        tbuf[2] = 0;
        tbuf[3] = 0;
        tbuf[4] = 0;

        ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_M_KEYS_LEDS,
                                 tbuf, 5,
                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
        if (ret != 5) {
                hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }

        g15_led->brightness = brightness;
        return 0;
}

static enum led_brightness lg_g13_mkey_led_get(struct led_classdev *led_cdev)
{
        /*
         * G13 doesn't change macro key LEDs behind our back, so they're
         * whatever we last set them to.
         */
        struct lg_g15_led *g15_led =
                container_of(led_cdev, struct lg_g15_led, cdev);

        return g15_led->brightness;
}

/******** G15 and G15 v2 LED functions ********/

static int lg_g15_update_led_brightness(struct lg_g15_data *g15)
{
        int ret;

        ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT,
                                 g15->transfer_buf, 4,
                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
        if (ret != 4) {
                hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }

        g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = g15->transfer_buf[1];
        g15->leds[LG_G15_LCD_BRIGHTNESS].brightness = g15->transfer_buf[2];

        g15->leds[LG_G15_MACRO_PRESET1].brightness =
                !(g15->transfer_buf[3] & 0x01);
        g15->leds[LG_G15_MACRO_PRESET2].brightness =
                !(g15->transfer_buf[3] & 0x02);
        g15->leds[LG_G15_MACRO_PRESET3].brightness =
                !(g15->transfer_buf[3] & 0x04);
        g15->leds[LG_G15_MACRO_RECORD].brightness =
                !(g15->transfer_buf[3] & 0x08);

        return 0;
}

static enum led_brightness lg_g15_led_get(struct led_classdev *led_cdev)
{
        struct lg_g15_led *g15_led =
                container_of(led_cdev, struct lg_g15_led, cdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
        enum led_brightness brightness;

        mutex_lock(&g15->mutex);
        lg_g15_update_led_brightness(g15);
        brightness = g15->leds[g15_led->led].brightness;
        mutex_unlock(&g15->mutex);

        return brightness;
}

static int lg_g15_led_set(struct led_classdev *led_cdev,
                          enum led_brightness brightness)
{
        struct lg_g15_led *g15_led =
                container_of(led_cdev, struct lg_g15_led, cdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
        u8 val, mask = 0;
        int i, ret;

        /* Ignore LED off on unregister / keyboard unplug */
        if (led_cdev->flags & LED_UNREGISTERING)
                return 0;

        mutex_lock(&g15->mutex);

        g15->transfer_buf[0] = LG_G15_FEATURE_REPORT;
        g15->transfer_buf[3] = 0;

        if (g15_led->led < LG_G15_BRIGHTNESS_MAX) {
                g15->transfer_buf[1] = g15_led->led + 1;
                g15->transfer_buf[2] = brightness << (g15_led->led * 4);
        } else {
                for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) {
                        if (i == g15_led->led)
                                val = brightness;
                        else
                                val = g15->leds[i].brightness;

                        if (val)
                                mask |= 1 << (i - LG_G15_MACRO_PRESET1);
                }

                g15->transfer_buf[1] = 0x04;
                g15->transfer_buf[2] = ~mask;
        }

        ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT,
                                 g15->transfer_buf, 4,
                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
        if (ret == 4) {
                /* Success */
                g15_led->brightness = brightness;
                ret = 0;
        } else {
                hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
                ret = (ret < 0) ? ret : -EIO;
        }

        mutex_unlock(&g15->mutex);

        return ret;
}

static void lg_g15_leds_changed_work(struct work_struct *work)
{
        struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work);
        enum led_brightness old_brightness[LG_G15_BRIGHTNESS_MAX];
        enum led_brightness brightness[LG_G15_BRIGHTNESS_MAX];
        int i, ret;

        mutex_lock(&g15->mutex);
        for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++)
                old_brightness[i] = g15->leds[i].brightness;

        ret = lg_g15_update_led_brightness(g15);

        for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++)
                brightness[i] = g15->leds[i].brightness;
        mutex_unlock(&g15->mutex);

        if (ret)
                return;

        for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++) {
                if (brightness[i] == old_brightness[i])
                        continue;

                led_classdev_notify_brightness_hw_changed(&g15->leds[i].cdev,
                                                          brightness[i]);
        }
}

/******** G510 LED functions ********/

static int lg_g510_get_initial_led_brightness(struct lg_g15_data *g15, int i)
{
        int ret, high;

        ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_BACKLIGHT_RGB + i,
                                 g15->transfer_buf, 4,
                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
        if (ret != 4) {
                hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
                return (ret < 0) ? ret : -EIO;
        }

        high = max3(g15->transfer_buf[1], g15->transfer_buf[2],
                    g15->transfer_buf[3]);

        if (high) {
                g15->leds[i].red =
                        DIV_ROUND_CLOSEST(g15->transfer_buf[1] * 255, high);
                g15->leds[i].green =
                        DIV_ROUND_CLOSEST(g15->transfer_buf[2] * 255, high);
                g15->leds[i].blue =
                        DIV_ROUND_CLOSEST(g15->transfer_buf[3] * 255, high);
                g15->leds[i].brightness = high;
        } else {
                g15->leds[i].red   = 255;
                g15->leds[i].green = 255;
                g15->leds[i].blue  = 255;
                g15->leds[i].brightness = 0;
        }

        if (i)
                return 0;

        ret = hid_hw_raw_request(g15->hdev, LG_G510_INPUT_KBD_BACKLIGHT,
                                 g15->transfer_buf, 2,
                                 HID_INPUT_REPORT, HID_REQ_GET_REPORT);
        if (ret != 2) {
                /* This can happen when a KVM switch is used, so only warn. */
                hid_warn(g15->hdev, "Error getting backlight state: %d\n", ret);
                return 0;
        }

        g15->backlight_disabled = g15->transfer_buf[1] & 0x04;

        return 0;
}

/* Must be called with g15->mutex locked */
static int lg_g510_kbd_led_write(struct lg_g15_data *g15,
                                 struct lg_g15_led *g15_led,
                                 enum led_brightness brightness)
{
        struct mc_subled *subleds = g15_led->mcdev.subled_info;
        int ret;

        led_mc_calc_color_components(&g15_led->mcdev, brightness);

        g15->transfer_buf[0] = 5 + g15_led->led;
        g15->transfer_buf[1] = subleds[0].brightness;
        g15->transfer_buf[2] = subleds[1].brightness;
        g15->transfer_buf[3] = subleds[2].brightness;

        ret = hid_hw_raw_request(g15->hdev,
                                 LG_G510_FEATURE_BACKLIGHT_RGB + g15_led->led,
                                 g15->transfer_buf, 4,
                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
        if (ret == 4) {
                /* Success */
                g15_led->brightness = brightness;
                ret = 0;
        } else {
                hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
                ret = (ret < 0) ? ret : -EIO;
        }

        return ret;
}

static int lg_g510_kbd_led_set(struct led_classdev *led_cdev,
                               enum led_brightness brightness)
{
        struct led_classdev_mc *mc = lcdev_to_mccdev(led_cdev);
        struct lg_g15_led *g15_led =
                container_of(mc, struct lg_g15_led, mcdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
        int ret;

        /* Ignore LED off on unregister / keyboard unplug */
        if (led_cdev->flags & LED_UNREGISTERING)
                return 0;

        mutex_lock(&g15->mutex);
        ret = lg_g510_kbd_led_write(g15, g15_led, brightness);
        mutex_unlock(&g15->mutex);

        return ret;
}

static enum led_brightness lg_g510_kbd_led_get(struct led_classdev *led_cdev)
{
        struct led_classdev_mc *mc = lcdev_to_mccdev(led_cdev);
        struct lg_g15_led *g15_led =
                container_of(mc, struct lg_g15_led, mcdev);

        return g15_led->brightness;
}

static void lg_g510_leds_sync_work(struct work_struct *work)
{
        struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work);
        struct lg_g15_led *g15_led = &g15->leds[LG_G15_KBD_BRIGHTNESS];

        mutex_lock(&g15->mutex);
        lg_g510_kbd_led_write(g15, g15_led, g15_led->brightness);
        mutex_unlock(&g15->mutex);
}

static int lg_g510_update_mkey_led_brightness(struct lg_g15_data *g15)
{
        int ret;

        ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS,
                                 g15->transfer_buf, 2,
                                 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
        if (ret != 2) {
                hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
                ret = (ret < 0) ? ret : -EIO;
        }

        g15->leds[LG_G15_MACRO_PRESET1].brightness =
                !!(g15->transfer_buf[1] & 0x80);
        g15->leds[LG_G15_MACRO_PRESET2].brightness =
                !!(g15->transfer_buf[1] & 0x40);
        g15->leds[LG_G15_MACRO_PRESET3].brightness =
                !!(g15->transfer_buf[1] & 0x20);
        g15->leds[LG_G15_MACRO_RECORD].brightness =
                !!(g15->transfer_buf[1] & 0x10);

        return 0;
}

static enum led_brightness lg_g510_mkey_led_get(struct led_classdev *led_cdev)
{
        struct lg_g15_led *g15_led =
                container_of(led_cdev, struct lg_g15_led, cdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
        enum led_brightness brightness;

        mutex_lock(&g15->mutex);
        lg_g510_update_mkey_led_brightness(g15);
        brightness = g15->leds[g15_led->led].brightness;
        mutex_unlock(&g15->mutex);

        return brightness;
}

static int lg_g510_mkey_led_set(struct led_classdev *led_cdev,
                                enum led_brightness brightness)
{
        struct lg_g15_led *g15_led =
                container_of(led_cdev, struct lg_g15_led, cdev);
        struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
        u8 val, mask = 0;
        int i, ret;

        /* Ignore LED off on unregister / keyboard unplug */
        if (led_cdev->flags & LED_UNREGISTERING)
                return 0;

        mutex_lock(&g15->mutex);

        for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) {
                if (i == g15_led->led)
                        val = brightness;
                else
                        val = g15->leds[i].brightness;

                if (val)
                        mask |= 0x80 >> (i - LG_G15_MACRO_PRESET1);
        }

        g15->transfer_buf[0] = LG_G510_FEATURE_M_KEYS_LEDS;
        g15->transfer_buf[1] = mask;

        ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS,
                                 g15->transfer_buf, 2,
                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
        if (ret == 2) {
                /* Success */
                g15_led->brightness = brightness;
                ret = 0;
        } else {
                hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
                ret = (ret < 0) ? ret : -EIO;
        }

        mutex_unlock(&g15->mutex);

        return ret;
}

/******** Generic LED functions ********/
static int lg_g15_get_initial_led_brightness(struct lg_g15_data *g15)
{
        int ret;

        switch (g15->model) {
        case LG_G13:
                return lg_g13_get_leds_state(g15);
        case LG_G15:
        case LG_G15_V2:
                return lg_g15_update_led_brightness(g15);
        case LG_G510:
        case LG_G510_USB_AUDIO:
                ret = lg_g510_get_initial_led_brightness(g15, 0);
                if (ret)
                        return ret;

                ret = lg_g510_get_initial_led_brightness(g15, 1);
                if (ret)
                        return ret;

                return lg_g510_update_mkey_led_brightness(g15);
        case LG_Z10:
                /*
                 * Getting the LCD backlight brightness is not supported.
                 * Reading Feature(2) fails with -EPIPE and this crashes
                 * the LCD and touch keys part of the speakers.
                 */
                return 0;
        }
        return -EINVAL; /* Never reached */
}

/******** Input functions ********/

/* Table mapping keybits[] bit positions to event codes. */
/* Note: Indices are discontinuous to aid readability. */
static const u16 g13_keys_for_bits[] = {
        /* Main keypad - keys G1 - G22 */
        [0] = KEY_MACRO1,
        [1] = KEY_MACRO2,
        [2] = KEY_MACRO3,
        [3] = KEY_MACRO4,
        [4] = KEY_MACRO5,
        [5] = KEY_MACRO6,
        [6] = KEY_MACRO7,
        [7] = KEY_MACRO8,
        [8] = KEY_MACRO9,
        [9] = KEY_MACRO10,
        [10] = KEY_MACRO11,
        [11] = KEY_MACRO12,
        [12] = KEY_MACRO13,
        [13] = KEY_MACRO14,
        [14] = KEY_MACRO15,
        [15] = KEY_MACRO16,
        [16] = KEY_MACRO17,
        [17] = KEY_MACRO18,
        [18] = KEY_MACRO19,
        [19] = KEY_MACRO20,
        [20] = KEY_MACRO21,
        [21] = KEY_MACRO22,

        /* LCD menu buttons. */
        [24] = KEY_KBD_LCD_MENU5,       /* "Next page" button */
        [25] = KEY_KBD_LCD_MENU1,       /* Left-most */
        [26] = KEY_KBD_LCD_MENU2,
        [27] = KEY_KBD_LCD_MENU3,
        [28] = KEY_KBD_LCD_MENU4,       /* Right-most */

        /* Macro preset and record buttons; have red LEDs under them. */
        [29] = KEY_MACRO_PRESET1,
        [30] = KEY_MACRO_PRESET2,
        [31] = KEY_MACRO_PRESET3,
        [32] = KEY_MACRO_RECORD_START,

        /* 33-35 handled by joystick device. */

        /* Backlight toggle. */
        [37] = KEY_LIGHTS_TOGGLE,
};

#define G13_JS_KEYBITS_OFFSET   33

static const u16 g13_keys_for_bits_js[] = {
        /* Joystick buttons */
        /* These keybits are at bit indices 33, 34, and 35. */
        BTN_BASE,       /* Left side */
        BTN_BASE2,      /* Bottom side */
        BTN_THUMB,      /* Stick depress */
};

static int lg_g13_event(struct lg_g15_data *g15, u8 const *data)
{
        struct g13_input_report const * const rep = (struct g13_input_report *) data;
        int i, val;
        bool backlight_disabled;

        /*
         * Main macropad and menu keys.
         * Emit key events defined for each bit position.
         */
        for (i = 0; i < ARRAY_SIZE(g13_keys_for_bits); ++i) {
                if (g13_keys_for_bits[i]) {
                        val = TEST_BIT(rep->keybits, i);
                        input_report_key(g15->input, g13_keys_for_bits[i], val);
                }
        }
        input_sync(g15->input);

        /*
         * Joystick.
         * Emit button and deflection events.
         */
        for (i = 0; i < ARRAY_SIZE(g13_keys_for_bits_js); ++i) {
                val = TEST_BIT(rep->keybits, i + G13_JS_KEYBITS_OFFSET);
                input_report_key(g15->input_js, g13_keys_for_bits_js[i], val);
        }
        input_report_abs(g15->input_js, ABS_X, rep->joy_x);
        input_report_abs(g15->input_js, ABS_Y, rep->joy_y);
        input_sync(g15->input_js);

        /*
         * Bit 23 of keybits[] reports the current backlight on/off state.  If
         * it has changed from the last cached value, apply an update.
         */
        backlight_disabled = !TEST_BIT(rep->keybits, LG_G13_BACKLIGHT_HW_ON_BIT);
        if (backlight_disabled ^ g15->backlight_disabled) {
                led_classdev_notify_brightness_hw_changed(
                        &g15->leds[LG_G15_KBD_BRIGHTNESS].mcdev.led_cdev,
                        backlight_disabled
                        ? 0 : g15->leds[LG_G15_KBD_BRIGHTNESS].brightness);
                g15->backlight_disabled = backlight_disabled;
        }

        return 0;
}

/* On the G15 Mark I Logitech has been quite creative with which bit is what */
static void lg_g15_handle_lcd_menu_keys(struct lg_g15_data *g15, u8 *data)
{
        int i, val;

        /* Most left (round/display) button below the LCD */
        input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[8] & 0x80);
        /* 4 other buttons below the LCD */
        for (i = 0; i < 4; i++) {
                val = data[i + 2] & 0x80;
                input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val);
        }
}

static int lg_g15_event(struct lg_g15_data *g15, u8 *data)
{
        int i, val;

        /* G1 - G6 */
        for (i = 0; i < 6; i++) {
                val = data[i + 1] & (1 << i);
                input_report_key(g15->input, KEY_MACRO1 + i, val);
        }
        /* G7 - G12 */
        for (i = 0; i < 6; i++) {
                val = data[i + 2] & (1 << i);
                input_report_key(g15->input, KEY_MACRO7 + i, val);
        }
        /* G13 - G17 */
        for (i = 0; i < 5; i++) {
                val = data[i + 1] & (4 << i);
                input_report_key(g15->input, KEY_MACRO13 + i, val);
        }
        /* G18 */
        input_report_key(g15->input, KEY_MACRO18, data[8] & 0x40);

        /* M1 - M3 */
        for (i = 0; i < 3; i++) {
                val = data[i + 6] & (1 << i);
                input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val);
        }
        /* MR */
        input_report_key(g15->input, KEY_MACRO_RECORD_START, data[7] & 0x40);

        lg_g15_handle_lcd_menu_keys(g15, data);

        /* Backlight cycle button pressed? */
        if (data[1] & 0x80)
                schedule_work(&g15->work);

        input_sync(g15->input);
        return 0;
}

static int lg_g15_v2_event(struct lg_g15_data *g15, u8 *data)
{
        int i, val;

        /* G1 - G6 */
        for (i = 0; i < 6; i++) {
                val = data[1] & (1 << i);
                input_report_key(g15->input, KEY_MACRO1 + i, val);
        }

        /* M1 - M3 + MR */
        input_report_key(g15->input, KEY_MACRO_PRESET1, data[1] & 0x40);
        input_report_key(g15->input, KEY_MACRO_PRESET2, data[1] & 0x80);
        input_report_key(g15->input, KEY_MACRO_PRESET3, data[2] & 0x20);
        input_report_key(g15->input, KEY_MACRO_RECORD_START, data[2] & 0x40);

        /* Round button to the left of the LCD */
        input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[2] & 0x80);
        /* 4 buttons below the LCD */
        for (i = 0; i < 4; i++) {
                val = data[2] & (2 << i);
                input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val);
        }

        /* Backlight cycle button pressed? */
        if (data[2] & 0x01)
                schedule_work(&g15->work);

        input_sync(g15->input);
        return 0;
}

static int lg_g510_event(struct lg_g15_data *g15, u8 *data)
{
        bool game_mode_enabled;
        int i, val;

        /* G1 - G18 */
        for (i = 0; i < 18; i++) {
                val = data[i / 8 + 1] & (1 << (i % 8));
                input_report_key(g15->input, KEY_MACRO1 + i, val);
        }

        /* Game mode on/off slider */
        game_mode_enabled = data[3] & 0x04;
        if (game_mode_enabled != g15->game_mode_enabled) {
                if (game_mode_enabled)
                        hid_info(g15->hdev, "Game Mode enabled, Windows (super) key is disabled\n");
                else
                        hid_info(g15->hdev, "Game Mode disabled\n");
                g15->game_mode_enabled = game_mode_enabled;
        }

        /* M1 - M3 */
        for (i = 0; i < 3; i++) {
                val = data[3] & (0x10 << i);
                input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val);
        }
        /* MR */
        input_report_key(g15->input, KEY_MACRO_RECORD_START, data[3] & 0x80);

        /* LCD menu keys */
        for (i = 0; i < 5; i++) {
                val = data[4] & (1 << i);
                input_report_key(g15->input, KEY_KBD_LCD_MENU1 + i, val);
        }

        /* Headphone Mute */
        input_report_key(g15->input, KEY_MUTE, data[4] & 0x20);
        /* Microphone Mute */
        input_report_key(g15->input, KEY_F20, data[4] & 0x40);

        input_sync(g15->input);
        return 0;
}

static int lg_g510_leds_event(struct lg_g15_data *g15, u8 *data)
{
        struct lg_g15_led *g15_led = &g15->leds[LG_G15_KBD_BRIGHTNESS];
        bool backlight_disabled;

        backlight_disabled = data[1] & 0x04;
        if (backlight_disabled == g15->backlight_disabled)
                return 0;

        led_classdev_notify_brightness_hw_changed(
                &g15_led->mcdev.led_cdev,
                backlight_disabled ? 0 : g15_led->brightness);

        g15->backlight_disabled = backlight_disabled;

        /*
         * The G510 ignores backlight updates when the backlight is turned off
         * through the light toggle button on the keyboard, to work around this
         * we queue a workitem to sync values when the backlight is turned on.
         */
        if (!backlight_disabled)
                schedule_work(&g15->work);

        return 0;
}

static int lg_g15_raw_event(struct hid_device *hdev, struct hid_report *report,
                            u8 *data, int size)
{
        struct lg_g15_data *g15 = hid_get_drvdata(hdev);

        if (!g15)
                return 0;

        switch (g15->model) {
        case LG_G13:
                if (data[0] == 0x01 && size == sizeof(struct g13_input_report))
                        return lg_g13_event(g15, data);
                break;
        case LG_G15:
                if (data[0] == 0x02 && size == 9)
                        return lg_g15_event(g15, data);
                break;
        case LG_G15_V2:
                if (data[0] == 0x02 && size == 5)
                        return lg_g15_v2_event(g15, data);
                break;
        case LG_Z10:
                if (data[0] == 0x02 && size == 9) {
                        lg_g15_handle_lcd_menu_keys(g15, data);
                        input_sync(g15->input);
                }
                break;
        case LG_G510:
        case LG_G510_USB_AUDIO:
                if (data[0] == LG_G510_INPUT_MACRO_KEYS && size == 5)
                        return lg_g510_event(g15, data);
                if (data[0] == LG_G510_INPUT_KBD_BACKLIGHT && size == 2)
                        return lg_g510_leds_event(g15, data);
                break;
        }

        return 0;
}

static int lg_g15_input_open(struct input_dev *dev)
{
        struct hid_device *hdev = input_get_drvdata(dev);

        return hid_hw_open(hdev);
}

static void lg_g15_input_close(struct input_dev *dev)
{
        struct hid_device *hdev = input_get_drvdata(dev);

        hid_hw_close(hdev);
}

static void lg_g15_setup_led_rgb(struct lg_g15_data *g15, int index)
{
        int i;
        struct mc_subled *subled_info;
        struct lg_g15_led * const gled = &g15->leds[index];

        if (g15->model == LG_G13) {
                gled->mcdev.led_cdev.brightness_set_blocking =
                        lg_g13_kbd_led_set;
                gled->mcdev.led_cdev.brightness_get =
                        lg_g13_kbd_led_get;
                gled->mcdev.led_cdev.flags = LED_BRIGHT_HW_CHANGED;
        } else {
                gled->mcdev.led_cdev.brightness_set_blocking =
                        lg_g510_kbd_led_set;
                gled->mcdev.led_cdev.brightness_get =
                        lg_g510_kbd_led_get;
                if (index == LG_G15_KBD_BRIGHTNESS)
                        g15->leds[index].mcdev.led_cdev.flags = LED_BRIGHT_HW_CHANGED;
        }
        gled->mcdev.led_cdev.max_brightness = 255;
        gled->mcdev.num_colors = 3;

        subled_info = devm_kcalloc(&g15->hdev->dev, 3, sizeof(*subled_info), GFP_KERNEL);
        if (!subled_info)
                return;

        for (i = 0; i < 3; i++) {
                switch (i + 1) {
                case LED_COLOR_ID_RED:
                        subled_info[i].color_index = LED_COLOR_ID_RED;
                        subled_info[i].intensity = gled->red;
                        break;
                case LED_COLOR_ID_GREEN:
                        subled_info[i].color_index = LED_COLOR_ID_GREEN;
                        subled_info[i].intensity = gled->green;
                        break;
                case LED_COLOR_ID_BLUE:
                        subled_info[i].color_index = LED_COLOR_ID_BLUE;
                        subled_info[i].intensity = gled->blue;
                        break;
                }
                subled_info[i].channel = i;
        }
        gled->mcdev.subled_info = subled_info;
}

static int lg_g15_register_led(struct lg_g15_data *g15, int i, const char *name)
{
        int ret;

        g15->leds[i].led = i;
        g15->leds[i].cdev.name = name;

        switch (g15->model) {
        case LG_G13:
                if (i < LG_G15_BRIGHTNESS_MAX) {
                        /* RGB backlight. */
                        lg_g15_setup_led_rgb(g15, i);
                        ret = devm_led_classdev_multicolor_register_ext(&g15->hdev->dev,
                                                                        &g15->leds[i].mcdev,
                                                                        NULL);
                } else {
                        /* Macro keys */
                        g15->leds[i].cdev.brightness_set_blocking = lg_g13_mkey_led_set;
                        g15->leds[i].cdev.brightness_get = lg_g13_mkey_led_get;
                        g15->leds[i].cdev.max_brightness = 1;

                        ret = devm_led_classdev_register(&g15->hdev->dev,
                                                         &g15->leds[i].cdev);
                }
                break;
        case LG_G15:
        case LG_G15_V2:
                g15->leds[i].cdev.brightness_get = lg_g15_led_get;
                fallthrough;
        case LG_Z10:
                g15->leds[i].cdev.brightness_set_blocking = lg_g15_led_set;
                if (i < LG_G15_BRIGHTNESS_MAX) {
                        g15->leds[i].cdev.flags = LED_BRIGHT_HW_CHANGED;
                        g15->leds[i].cdev.max_brightness = 2;
                } else {
                        g15->leds[i].cdev.max_brightness = 1;
                }
                ret = devm_led_classdev_register(&g15->hdev->dev, &g15->leds[i].cdev);
                break;
        case LG_G510:
        case LG_G510_USB_AUDIO:
                switch (i) {
                case LG_G15_LCD_BRIGHTNESS:
                        /*
                         * The G510 does not have a separate LCD brightness,
                         * but it does have a separate power-on (reset) value.
                         */
                        g15->leds[i].cdev.name = "g15::power_on_backlight_val";
                        fallthrough;
                case LG_G15_KBD_BRIGHTNESS:
                        /* register multicolor LED */
                        lg_g15_setup_led_rgb(g15, i);
                        ret = devm_led_classdev_multicolor_register_ext(&g15->hdev->dev,
                                                                        &g15->leds[i].mcdev,
                                                                        NULL);
                        break;
                default:
                        g15->leds[i].cdev.brightness_set_blocking =
                                lg_g510_mkey_led_set;
                        g15->leds[i].cdev.brightness_get =
                                lg_g510_mkey_led_get;
                        g15->leds[i].cdev.max_brightness = 1;
                        ret = devm_led_classdev_register(&g15->hdev->dev, &g15->leds[i].cdev);
                }
                break;
        }

        return ret;
}

/* Common input device init code shared between keyboards and Z-10 speaker handling */
static void lg_g15_init_input_dev_core(struct hid_device *hdev, struct input_dev *input,
                                       char const *name)
{
        input->name = name;
        input->phys = hdev->phys;
        input->uniq = hdev->uniq;
        input->id.bustype = hdev->bus;
        input->id.vendor  = hdev->vendor;
        input->id.product = hdev->product;
        input->id.version = hdev->version;
        input->dev.parent = &hdev->dev;
        input->open = lg_g15_input_open;
        input->close = lg_g15_input_close;
}

static void lg_g15_init_input_dev(struct hid_device *hdev, struct input_dev *input,
                                  const char *name)
{
        int i;

        lg_g15_init_input_dev_core(hdev, input, name);

        /* Keys below the LCD, intended for controlling a menu on the LCD */
        for (i = 0; i < 5; i++)
                input_set_capability(input, EV_KEY, KEY_KBD_LCD_MENU1 + i);
}

static void lg_g13_init_input_dev(struct hid_device *hdev,
                                  struct input_dev *input, const char *name,
                                  struct input_dev *input_js, const char *name_js)
{
        /* Macropad. */
        lg_g15_init_input_dev_core(hdev, input, name);
        for (int i = 0; i < ARRAY_SIZE(g13_keys_for_bits); ++i) {
                if (g13_keys_for_bits[i])
                        input_set_capability(input, EV_KEY, g13_keys_for_bits[i]);
        }

        /* OBTW, we're a joystick, too... */
        lg_g15_init_input_dev_core(hdev, input_js, name_js);
        for (int i = 0; i < ARRAY_SIZE(g13_keys_for_bits_js); ++i)
                input_set_capability(input_js, EV_KEY, g13_keys_for_bits_js[i]);

        input_set_capability(input_js, EV_ABS, ABS_X);
        input_set_abs_params(input_js, ABS_X, 0, 255, 0, 0);
        input_set_capability(input_js, EV_ABS, ABS_Y);
        input_set_abs_params(input_js, ABS_Y, 0, 255, 0, 0);
}

static int lg_g15_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
        static const char * const led_names[] = {
                "g15::kbd_backlight",
                "g15::lcd_backlight",
                "g15::macro_preset1",
                "g15::macro_preset2",
                "g15::macro_preset3",
                "g15::macro_record",
        };
        u8 gkeys_settings_output_report = 0;
        u8 gkeys_settings_feature_report = 0;
        struct hid_report_enum *rep_enum;
        unsigned int connect_mask = 0;
        bool has_ff000000 = false;
        struct lg_g15_data *g15;
        struct input_dev *input, *input_js;
        struct hid_report *rep;
        int ret, i, gkeys = 0;

        hdev->quirks |= HID_QUIRK_INPUT_PER_APP;

        ret = hid_parse(hdev);
        if (ret)
                return ret;

        /*
         * Some models have multiple interfaces, we want the interface with
         * the f000.0000 application input report.
         */
        rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
        list_for_each_entry(rep, &rep_enum->report_list, list) {
                if (rep->application == 0xff000000)
                        has_ff000000 = true;
        }
        if (!has_ff000000)
                return hid_hw_start(hdev, HID_CONNECT_DEFAULT);

        g15 = devm_kzalloc(&hdev->dev, sizeof(*g15), GFP_KERNEL);
        if (!g15)
                return -ENOMEM;

        mutex_init(&g15->mutex);

        input = devm_input_allocate_device(&hdev->dev);
        if (!input)
                return -ENOMEM;

        g15->hdev = hdev;
        g15->model = id->driver_data;
        g15->input = input;
        input_set_drvdata(input, hdev);
        hid_set_drvdata(hdev, (void *)g15);

        switch (g15->model) {
        case LG_G13:
                /*
                 * The G13 has an analog thumbstick with nearby buttons.  Some
                 * libraries and applications are known to ignore devices that
                 * don't "look like" a joystick, and a device with two ABS axes
                 * and 25+ macro keys would confuse them.
                 *
                 * Create an additional input device dedicated to appear as a
                 * simplified joystick (two ABS axes, three BTN buttons).
                 */
                input_js = devm_input_allocate_device(&hdev->dev);
                if (!input_js)
                        return -ENOMEM;
                g15->input_js = input_js;
                input_set_drvdata(input_js, hdev);

                connect_mask = HID_CONNECT_HIDRAW;
                gkeys = 25;
                break;
        case LG_G15:
                INIT_WORK(&g15->work, lg_g15_leds_changed_work);
                /*
                 * The G15 and G15 v2 use a separate usb-device (on a builtin
                 * hub) which emulates a keyboard for the F1 - F12 emulation
                 * on the G-keys, which we disable, rendering the emulated kbd
                 * non-functional, so we do not let hid-input connect.
                 */
                connect_mask = HID_CONNECT_HIDRAW;
                gkeys_settings_output_report = 0x02;
                gkeys = 18;
                break;
        case LG_G15_V2:
                INIT_WORK(&g15->work, lg_g15_leds_changed_work);
                connect_mask = HID_CONNECT_HIDRAW;
                gkeys_settings_output_report = 0x02;
                gkeys = 6;
                break;
        case LG_G510:
        case LG_G510_USB_AUDIO:
                INIT_WORK(&g15->work, lg_g510_leds_sync_work);
                connect_mask = HID_CONNECT_HIDINPUT | HID_CONNECT_HIDRAW;
                gkeys_settings_feature_report = 0x01;
                gkeys = 18;
                break;
        case LG_Z10:
                connect_mask = HID_CONNECT_HIDRAW;
                break;
        }

        ret = hid_hw_start(hdev, connect_mask);
        if (ret)
                return ret;

        /* Tell the keyboard to stop sending F1-F12 + 1-6 for G1 - G18 */
        if (gkeys_settings_output_report) {
                g15->transfer_buf[0] = gkeys_settings_output_report;
                memset(g15->transfer_buf + 1, 0, gkeys);
                /*
                 * The kbd ignores our output report if we do not queue
                 * an URB on the USB input endpoint first...
                 */
                ret = hid_hw_open(hdev);
                if (ret)
                        goto error_hw_stop;
                ret = hid_hw_output_report(hdev, g15->transfer_buf, gkeys + 1);
                hid_hw_close(hdev);
        }

        if (gkeys_settings_feature_report) {
                g15->transfer_buf[0] = gkeys_settings_feature_report;
                memset(g15->transfer_buf + 1, 0, gkeys);
                ret = hid_hw_raw_request(g15->hdev,
                                gkeys_settings_feature_report,
                                g15->transfer_buf, gkeys + 1,
                                HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
        }

        if (ret < 0) {
                hid_err(hdev, "Error %d disabling keyboard emulation for the G-keys, falling back to generic hid-input driver\n",
                        ret);
                hid_set_drvdata(hdev, NULL);
                return 0;
        }

        /* Get initial brightness levels */
        ret = lg_g15_get_initial_led_brightness(g15);
        if (ret)
                goto error_hw_stop;

        if (g15->model == LG_Z10) {
                lg_g15_init_input_dev(hdev, g15->input, "Logitech Z-10 LCD Menu Keys");
                ret = input_register_device(g15->input);
                if (ret)
                        goto error_hw_stop;

                ret = lg_g15_register_led(g15, 1, "z-10::lcd_backlight");
                if (ret)
                        goto error_hw_stop;

                return 0; /* All done */
        } else if (g15->model == LG_G13) {
                static char const * const g13_led_names[] = {
                        /* Backlight is shared between LCD and keys. */
                        "g13:rgb:kbd_backlight",
                        NULL,   /* Keep in sync with led_type enum */
                        "g13:red:macro_preset_1",
                        "g13:red:macro_preset_2",
                        "g13:red:macro_preset_3",
                        "g13:red:macro_record",
                };
                lg_g13_init_input_dev(hdev,
                                      input, "Logitech G13 Gaming Keypad",
                                      input_js, "Logitech G13 Thumbstick");
                ret = input_register_device(input);
                if (ret)
                        goto error_hw_stop;
                ret = input_register_device(input_js);
                if (ret)
                        goto error_hw_stop;

                for (i = 0; i < ARRAY_SIZE(g13_led_names); ++i) {
                        if (g13_led_names[i]) {
                                ret = lg_g15_register_led(g15, i, g13_led_names[i]);
                                if (ret)
                                        goto error_hw_stop;
                        }
                }
                led_classdev_notify_brightness_hw_changed(
                        &g15->leds[LG_G15_KBD_BRIGHTNESS].mcdev.led_cdev,
                        g15->backlight_disabled
                        ? 0 : g15->leds[LG_G15_KBD_BRIGHTNESS].brightness);
                return 0;
        }

        /* Setup and register input device */
        lg_g15_init_input_dev(hdev, input, "Logitech Gaming Keyboard Gaming Keys");

        /* G-keys */
        for (i = 0; i < gkeys; i++)
                input_set_capability(input, EV_KEY, KEY_MACRO1 + i);

        /* M1 - M3 and MR keys */
        for (i = 0; i < 3; i++)
                input_set_capability(input, EV_KEY, KEY_MACRO_PRESET1 + i);
        input_set_capability(input, EV_KEY, KEY_MACRO_RECORD_START);

        /*
         * On the G510 only report headphone and mic mute keys when *not* using
         * the builtin USB audio device. When the builtin audio is used these
         * keys directly toggle mute (and the LEDs) on/off.
         */
        if (g15->model == LG_G510) {
                input_set_capability(input, EV_KEY, KEY_MUTE);
                /* Userspace expects F20 for micmute */
                input_set_capability(input, EV_KEY, KEY_F20);
        }

        ret = input_register_device(input);
        if (ret)
                goto error_hw_stop;

        /* Register LED devices */
        for (i = 0; i < LG_G15_LED_MAX; i++) {
                ret = lg_g15_register_led(g15, i, led_names[i]);
                if (ret)
                        goto error_hw_stop;
        }

        return 0;

error_hw_stop:
        hid_hw_stop(hdev);
        return ret;
}

static const struct hid_device_id lg_g15_devices[] = {
        /*
         * The G13 is a macropad-only device with an LCD, LED backlighing,
         * and joystick.
         */
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                         USB_DEVICE_ID_LOGITECH_G13),
                .driver_data = LG_G13 },
        /* The G11 is a G15 without the LCD, treat it as a G15 */
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                USB_DEVICE_ID_LOGITECH_G11),
                .driver_data = LG_G15 },
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                         USB_DEVICE_ID_LOGITECH_G15_LCD),
                .driver_data = LG_G15 },
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                         USB_DEVICE_ID_LOGITECH_G15_V2_LCD),
                .driver_data = LG_G15_V2 },
        /* G510 without a headset plugged in */
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                         USB_DEVICE_ID_LOGITECH_G510),
                .driver_data = LG_G510 },
        /* G510 with headset plugged in / with extra USB audio interface */
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                         USB_DEVICE_ID_LOGITECH_G510_USB_AUDIO),
                .driver_data = LG_G510_USB_AUDIO },
        /* Z-10 speakers */
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
                         USB_DEVICE_ID_LOGITECH_Z_10_SPK),
                .driver_data = LG_Z10 },
        { }
};
MODULE_DEVICE_TABLE(hid, lg_g15_devices);

static struct hid_driver lg_g15_driver = {
        .name                   = "lg-g15",
        .id_table               = lg_g15_devices,
        .raw_event              = lg_g15_raw_event,
        .probe                  = lg_g15_probe,
};
module_hid_driver(lg_g15_driver);

MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
MODULE_DESCRIPTION("HID driver for gaming keys on Logitech gaming keyboards");
MODULE_LICENSE("GPL");