drivers/hid/hid-lg-g15.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  HID driver for gaming keys on Logitech gaming keyboards (such as the G15)
   4  *
   5  *  Copyright (c) 2019 Hans de Goede <hdegoede@redhat.com>
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/hid.h>
  10 #include <linux/leds.h>
  11 #include <linux/module.h>
  12 #include <linux/random.h>
  13 #include <linux/sched.h>
  14 #include <linux/usb.h>
  15 #include <linux/wait.h>
  16
  17 #include "hid-ids.h"
  18
  19 #define LG_G15_TRANSFER_BUF_SIZE        20
  20
  21 #define LG_G15_FEATURE_REPORT           0x02
  22
  23 #define LG_G510_FEATURE_M_KEYS_LEDS     0x04
  24 #define LG_G510_FEATURE_BACKLIGHT_RGB   0x05
  25 #define LG_G510_FEATURE_POWER_ON_RGB    0x06
  26
  27 enum lg_g15_model {
  28         LG_G15,
  29         LG_G15_V2,
  30         LG_G510,
  31         LG_G510_USB_AUDIO,
  32         LG_Z10,
  33 };
  34
  35 enum lg_g15_led_type {
  36         LG_G15_KBD_BRIGHTNESS,
  37         LG_G15_LCD_BRIGHTNESS,
  38         LG_G15_BRIGHTNESS_MAX,
  39         LG_G15_MACRO_PRESET1 = 2,
  40         LG_G15_MACRO_PRESET2,
  41         LG_G15_MACRO_PRESET3,
  42         LG_G15_MACRO_RECORD,
  43         LG_G15_LED_MAX
  44 };
  45
  46 struct lg_g15_led {
  47         struct led_classdev cdev;
  48         enum led_brightness brightness;
  49         enum lg_g15_led_type led;
  50         u8 red, green, blue;
  51 };
  52
  53 struct lg_g15_data {
  54         /* Must be first for proper dma alignment */
  55         u8 transfer_buf[LG_G15_TRANSFER_BUF_SIZE];
  56         /* Protects the transfer_buf and led brightness */
  57         struct mutex mutex;
  58         struct work_struct work;
  59         struct input_dev *input;
  60         struct hid_device *hdev;
  61         enum lg_g15_model model;
  62         struct lg_g15_led leds[LG_G15_LED_MAX];
  63         bool game_mode_enabled;
  64 };
  65
  66 /******** G15 and G15 v2 LED functions ********/
  67
  68 static int lg_g15_update_led_brightness(struct lg_g15_data *g15)
  69 {
  70         int ret;
  71
  72         ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT,
  73                                  g15->transfer_buf, 4,
  74                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
  75         if (ret != 4) {
  76                 hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
  77                 return (ret < 0) ? ret : -EIO;
  78         }
  79
  80         g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = g15->transfer_buf[1];
  81         g15->leds[LG_G15_LCD_BRIGHTNESS].brightness = g15->transfer_buf[2];
  82
  83         g15->leds[LG_G15_MACRO_PRESET1].brightness =
  84                 !(g15->transfer_buf[3] & 0x01);
  85         g15->leds[LG_G15_MACRO_PRESET2].brightness =
  86                 !(g15->transfer_buf[3] & 0x02);
  87         g15->leds[LG_G15_MACRO_PRESET3].brightness =
  88                 !(g15->transfer_buf[3] & 0x04);
  89         g15->leds[LG_G15_MACRO_RECORD].brightness =
  90                 !(g15->transfer_buf[3] & 0x08);
  91
  92         return 0;
  93 }
  94
  95 static enum led_brightness lg_g15_led_get(struct led_classdev *led_cdev)
  96 {
  97         struct lg_g15_led *g15_led =
  98                 container_of(led_cdev, struct lg_g15_led, cdev);
  99         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 100         enum led_brightness brightness;
 101
 102         mutex_lock(&g15->mutex);
 103         lg_g15_update_led_brightness(g15);
 104         brightness = g15->leds[g15_led->led].brightness;
 105         mutex_unlock(&g15->mutex);
 106
 107         return brightness;
 108 }
 109
 110 static int lg_g15_led_set(struct led_classdev *led_cdev,
 111                           enum led_brightness brightness)
 112 {
 113         struct lg_g15_led *g15_led =
 114                 container_of(led_cdev, struct lg_g15_led, cdev);
 115         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 116         u8 val, mask = 0;
 117         int i, ret;
 118
 119         /* Ignore LED off on unregister / keyboard unplug */
 120         if (led_cdev->flags & LED_UNREGISTERING)
 121                 return 0;
 122
 123         mutex_lock(&g15->mutex);
 124
 125         g15->transfer_buf[0] = LG_G15_FEATURE_REPORT;
 126         g15->transfer_buf[3] = 0;
 127
 128         if (g15_led->led < LG_G15_BRIGHTNESS_MAX) {
 129                 g15->transfer_buf[1] = g15_led->led + 1;
 130                 g15->transfer_buf[2] = brightness << (g15_led->led * 4);
 131         } else {
 132                 for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) {
 133                         if (i == g15_led->led)
 134                                 val = brightness;
 135                         else
 136                                 val = g15->leds[i].brightness;
 137
 138                         if (val)
 139                                 mask |= 1 << (i - LG_G15_MACRO_PRESET1);
 140                 }
 141
 142                 g15->transfer_buf[1] = 0x04;
 143                 g15->transfer_buf[2] = ~mask;
 144         }
 145
 146         ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT,
 147                                  g15->transfer_buf, 4,
 148                                  HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 149         if (ret == 4) {
 150                 /* Success */
 151                 g15_led->brightness = brightness;
 152                 ret = 0;
 153         } else {
 154                 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
 155                 ret = (ret < 0) ? ret : -EIO;
 156         }
 157
 158         mutex_unlock(&g15->mutex);
 159
 160         return ret;
 161 }
 162
 163 static void lg_g15_leds_changed_work(struct work_struct *work)
 164 {
 165         struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work);
 166         enum led_brightness old_brightness[LG_G15_BRIGHTNESS_MAX];
 167         enum led_brightness brightness[LG_G15_BRIGHTNESS_MAX];
 168         int i, ret;
 169
 170         mutex_lock(&g15->mutex);
 171         for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++)
 172                 old_brightness[i] = g15->leds[i].brightness;
 173
 174         ret = lg_g15_update_led_brightness(g15);
 175
 176         for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++)
 177                 brightness[i] = g15->leds[i].brightness;
 178         mutex_unlock(&g15->mutex);
 179
 180         if (ret)
 181                 return;
 182
 183         for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++) {
 184                 if (brightness[i] == old_brightness[i])
 185                         continue;
 186
 187                 led_classdev_notify_brightness_hw_changed(&g15->leds[i].cdev,
 188                                                           brightness[i]);
 189         }
 190 }
 191
 192 /******** G510 LED functions ********/
 193
 194 static int lg_g510_get_initial_led_brightness(struct lg_g15_data *g15, int i)
 195 {
 196         int ret, high;
 197
 198         ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_BACKLIGHT_RGB + i,
 199                                  g15->transfer_buf, 4,
 200                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
 201         if (ret != 4) {
 202                 hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
 203                 return (ret < 0) ? ret : -EIO;
 204         }
 205
 206         high = max3(g15->transfer_buf[1], g15->transfer_buf[2],
 207                     g15->transfer_buf[3]);
 208
 209         if (high) {
 210                 g15->leds[i].red =
 211                         DIV_ROUND_CLOSEST(g15->transfer_buf[1] * 255, high);
 212                 g15->leds[i].green =
 213                         DIV_ROUND_CLOSEST(g15->transfer_buf[2] * 255, high);
 214                 g15->leds[i].blue =
 215                         DIV_ROUND_CLOSEST(g15->transfer_buf[3] * 255, high);
 216                 g15->leds[i].brightness = high;
 217         } else {
 218                 g15->leds[i].red   = 255;
 219                 g15->leds[i].green = 255;
 220                 g15->leds[i].blue  = 255;
 221                 g15->leds[i].brightness = 0;
 222         }
 223
 224         return 0;
 225 }
 226
 227 /* Must be called with g15->mutex locked */
 228 static int lg_g510_kbd_led_write(struct lg_g15_data *g15,
 229                                  struct lg_g15_led *g15_led,
 230                                  enum led_brightness brightness)
 231 {
 232         int ret;
 233
 234         g15->transfer_buf[0] = 5 + g15_led->led;
 235         g15->transfer_buf[1] =
 236                 DIV_ROUND_CLOSEST(g15_led->red * brightness, 255);
 237         g15->transfer_buf[2] =
 238                 DIV_ROUND_CLOSEST(g15_led->green * brightness, 255);
 239         g15->transfer_buf[3] =
 240                 DIV_ROUND_CLOSEST(g15_led->blue * brightness, 255);
 241
 242         ret = hid_hw_raw_request(g15->hdev,
 243                                  LG_G510_FEATURE_BACKLIGHT_RGB + g15_led->led,
 244                                  g15->transfer_buf, 4,
 245                                  HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 246         if (ret == 4) {
 247                 /* Success */
 248                 g15_led->brightness = brightness;
 249                 ret = 0;
 250         } else {
 251                 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
 252                 ret = (ret < 0) ? ret : -EIO;
 253         }
 254
 255         return ret;
 256 }
 257
 258 static int lg_g510_kbd_led_set(struct led_classdev *led_cdev,
 259                                enum led_brightness brightness)
 260 {
 261         struct lg_g15_led *g15_led =
 262                 container_of(led_cdev, struct lg_g15_led, cdev);
 263         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 264         int ret;
 265
 266         /* Ignore LED off on unregister / keyboard unplug */
 267         if (led_cdev->flags & LED_UNREGISTERING)
 268                 return 0;
 269
 270         mutex_lock(&g15->mutex);
 271         ret = lg_g510_kbd_led_write(g15, g15_led, brightness);
 272         mutex_unlock(&g15->mutex);
 273
 274         return ret;
 275 }
 276
 277 static enum led_brightness lg_g510_kbd_led_get(struct led_classdev *led_cdev)
 278 {
 279         struct lg_g15_led *g15_led =
 280                 container_of(led_cdev, struct lg_g15_led, cdev);
 281
 282         return g15_led->brightness;
 283 }
 284
 285 static ssize_t color_store(struct device *dev, struct device_attribute *attr,
 286                            const char *buf, size_t count)
 287 {
 288         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 289         struct lg_g15_led *g15_led =
 290                 container_of(led_cdev, struct lg_g15_led, cdev);
 291         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 292         unsigned long value;
 293         int ret;
 294
 295         if (count < 7 || (count == 8 && buf[7] != '\n') || count > 8)
 296                 return -EINVAL;
 297
 298         if (buf[0] != '#')
 299                 return -EINVAL;
 300
 301         ret = kstrtoul(buf + 1, 16, &value);
 302         if (ret)
 303                 return ret;
 304
 305         mutex_lock(&g15->mutex);
 306         g15_led->red   = (value & 0xff0000) >> 16;
 307         g15_led->green = (value & 0x00ff00) >> 8;
 308         g15_led->blue  = (value & 0x0000ff);
 309         ret = lg_g510_kbd_led_write(g15, g15_led, g15_led->brightness);
 310         mutex_unlock(&g15->mutex);
 311
 312         return (ret < 0) ? ret : count;
 313 }
 314
 315 static ssize_t color_show(struct device *dev, struct device_attribute *attr,
 316                           char *buf)
 317 {
 318         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 319         struct lg_g15_led *g15_led =
 320                 container_of(led_cdev, struct lg_g15_led, cdev);
 321         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 322         ssize_t ret;
 323
 324         mutex_lock(&g15->mutex);
 325         ret = sprintf(buf, "#%02x%02x%02x\n",
 326                       g15_led->red, g15_led->green, g15_led->blue);
 327         mutex_unlock(&g15->mutex);
 328
 329         return ret;
 330 }
 331
 332 static DEVICE_ATTR_RW(color);
 333
 334 static struct attribute *lg_g510_kbd_led_attrs[] = {
 335         &dev_attr_color.attr,
 336         NULL,
 337 };
 338
 339 static const struct attribute_group lg_g510_kbd_led_group = {
 340         .attrs = lg_g510_kbd_led_attrs,
 341 };
 342
 343 static const struct attribute_group *lg_g510_kbd_led_groups[] = {
 344         &lg_g510_kbd_led_group,
 345         NULL,
 346 };
 347
 348 static void lg_g510_leds_sync_work(struct work_struct *work)
 349 {
 350         struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work);
 351
 352         mutex_lock(&g15->mutex);
 353         lg_g510_kbd_led_write(g15, &g15->leds[LG_G15_KBD_BRIGHTNESS],
 354                               g15->leds[LG_G15_KBD_BRIGHTNESS].brightness);
 355         mutex_unlock(&g15->mutex);
 356 }
 357
 358 static int lg_g510_update_mkey_led_brightness(struct lg_g15_data *g15)
 359 {
 360         int ret;
 361
 362         ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS,
 363                                  g15->transfer_buf, 2,
 364                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
 365         if (ret != 2) {
 366                 hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
 367                 ret = (ret < 0) ? ret : -EIO;
 368         }
 369
 370         g15->leds[LG_G15_MACRO_PRESET1].brightness =
 371                 !!(g15->transfer_buf[1] & 0x80);
 372         g15->leds[LG_G15_MACRO_PRESET2].brightness =
 373                 !!(g15->transfer_buf[1] & 0x40);
 374         g15->leds[LG_G15_MACRO_PRESET3].brightness =
 375                 !!(g15->transfer_buf[1] & 0x20);
 376         g15->leds[LG_G15_MACRO_RECORD].brightness =
 377                 !!(g15->transfer_buf[1] & 0x10);
 378
 379         return 0;
 380 }
 381
 382 static enum led_brightness lg_g510_mkey_led_get(struct led_classdev *led_cdev)
 383 {
 384         struct lg_g15_led *g15_led =
 385                 container_of(led_cdev, struct lg_g15_led, cdev);
 386         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 387         enum led_brightness brightness;
 388
 389         mutex_lock(&g15->mutex);
 390         lg_g510_update_mkey_led_brightness(g15);
 391         brightness = g15->leds[g15_led->led].brightness;
 392         mutex_unlock(&g15->mutex);
 393
 394         return brightness;
 395 }
 396
 397 static int lg_g510_mkey_led_set(struct led_classdev *led_cdev,
 398                                 enum led_brightness brightness)
 399 {
 400         struct lg_g15_led *g15_led =
 401                 container_of(led_cdev, struct lg_g15_led, cdev);
 402         struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
 403         u8 val, mask = 0;
 404         int i, ret;
 405
 406         /* Ignore LED off on unregister / keyboard unplug */
 407         if (led_cdev->flags & LED_UNREGISTERING)
 408                 return 0;
 409
 410         mutex_lock(&g15->mutex);
 411
 412         for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) {
 413                 if (i == g15_led->led)
 414                         val = brightness;
 415                 else
 416                         val = g15->leds[i].brightness;
 417
 418                 if (val)
 419                         mask |= 0x80 >> (i - LG_G15_MACRO_PRESET1);
 420         }
 421
 422         g15->transfer_buf[0] = LG_G510_FEATURE_M_KEYS_LEDS;
 423         g15->transfer_buf[1] = mask;
 424
 425         ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS,
 426                                  g15->transfer_buf, 2,
 427                                  HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 428         if (ret == 2) {
 429                 /* Success */
 430                 g15_led->brightness = brightness;
 431                 ret = 0;
 432         } else {
 433                 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
 434                 ret = (ret < 0) ? ret : -EIO;
 435         }
 436
 437         mutex_unlock(&g15->mutex);
 438
 439         return ret;
 440 }
 441
 442 /******** Generic LED functions ********/
 443 static int lg_g15_get_initial_led_brightness(struct lg_g15_data *g15)
 444 {
 445         int ret;
 446
 447         switch (g15->model) {
 448         case LG_G15:
 449         case LG_G15_V2:
 450                 return lg_g15_update_led_brightness(g15);
 451         case LG_G510:
 452         case LG_G510_USB_AUDIO:
 453                 ret = lg_g510_get_initial_led_brightness(g15, 0);
 454                 if (ret)
 455                         return ret;
 456
 457                 ret = lg_g510_get_initial_led_brightness(g15, 1);
 458                 if (ret)
 459                         return ret;
 460
 461                 return lg_g510_update_mkey_led_brightness(g15);
 462         case LG_Z10:
 463                 /*
 464                  * Getting the LCD backlight brightness is not supported.
 465                  * Reading Feature(2) fails with -EPIPE and this crashes
 466                  * the LCD and touch keys part of the speakers.
 467                  */
 468                 return 0;
 469         }
 470         return -EINVAL; /* Never reached */
 471 }
 472
 473 /******** Input functions ********/
 474
 475 /* On the G15 Mark I Logitech has been quite creative with which bit is what */
 476 static void lg_g15_handle_lcd_menu_keys(struct lg_g15_data *g15, u8 *data)
 477 {
 478         int i, val;
 479
 480         /* Most left (round/display) button below the LCD */
 481         input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[8] & 0x80);
 482         /* 4 other buttons below the LCD */
 483         for (i = 0; i < 4; i++) {
 484                 val = data[i + 2] & 0x80;
 485                 input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val);
 486         }
 487 }
 488
 489 static int lg_g15_event(struct lg_g15_data *g15, u8 *data)
 490 {
 491         int i, val;
 492
 493         /* G1 - G6 */
 494         for (i = 0; i < 6; i++) {
 495                 val = data[i + 1] & (1 << i);
 496                 input_report_key(g15->input, KEY_MACRO1 + i, val);
 497         }
 498         /* G7 - G12 */
 499         for (i = 0; i < 6; i++) {
 500                 val = data[i + 2] & (1 << i);
 501                 input_report_key(g15->input, KEY_MACRO7 + i, val);
 502         }
 503         /* G13 - G17 */
 504         for (i = 0; i < 5; i++) {
 505                 val = data[i + 1] & (4 << i);
 506                 input_report_key(g15->input, KEY_MACRO13 + i, val);
 507         }
 508         /* G18 */
 509         input_report_key(g15->input, KEY_MACRO18, data[8] & 0x40);
 510
 511         /* M1 - M3 */
 512         for (i = 0; i < 3; i++) {
 513                 val = data[i + 6] & (1 << i);
 514                 input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val);
 515         }
 516         /* MR */
 517         input_report_key(g15->input, KEY_MACRO_RECORD_START, data[7] & 0x40);
 518
 519         lg_g15_handle_lcd_menu_keys(g15, data);
 520
 521         /* Backlight cycle button pressed? */
 522         if (data[1] & 0x80)
 523                 schedule_work(&g15->work);
 524
 525         input_sync(g15->input);
 526         return 0;
 527 }
 528
 529 static int lg_g15_v2_event(struct lg_g15_data *g15, u8 *data)
 530 {
 531         int i, val;
 532
 533         /* G1 - G6 */
 534         for (i = 0; i < 6; i++) {
 535                 val = data[1] & (1 << i);
 536                 input_report_key(g15->input, KEY_MACRO1 + i, val);
 537         }
 538
 539         /* M1 - M3 + MR */
 540         input_report_key(g15->input, KEY_MACRO_PRESET1, data[1] & 0x40);
 541         input_report_key(g15->input, KEY_MACRO_PRESET2, data[1] & 0x80);
 542         input_report_key(g15->input, KEY_MACRO_PRESET3, data[2] & 0x20);
 543         input_report_key(g15->input, KEY_MACRO_RECORD_START, data[2] & 0x40);
 544
 545         /* Round button to the left of the LCD */
 546         input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[2] & 0x80);
 547         /* 4 buttons below the LCD */
 548         for (i = 0; i < 4; i++) {
 549                 val = data[2] & (2 << i);
 550                 input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val);
 551         }
 552
 553         /* Backlight cycle button pressed? */
 554         if (data[2] & 0x01)
 555                 schedule_work(&g15->work);
 556
 557         input_sync(g15->input);
 558         return 0;
 559 }
 560
 561 static int lg_g510_event(struct lg_g15_data *g15, u8 *data)
 562 {
 563         bool game_mode_enabled;
 564         int i, val;
 565
 566         /* G1 - G18 */
 567         for (i = 0; i < 18; i++) {
 568                 val = data[i / 8 + 1] & (1 << (i % 8));
 569                 input_report_key(g15->input, KEY_MACRO1 + i, val);
 570         }
 571
 572         /* Game mode on/off slider */
 573         game_mode_enabled = data[3] & 0x04;
 574         if (game_mode_enabled != g15->game_mode_enabled) {
 575                 if (game_mode_enabled)
 576                         hid_info(g15->hdev, "Game Mode enabled, Windows (super) key is disabled\n");
 577                 else
 578                         hid_info(g15->hdev, "Game Mode disabled\n");
 579                 g15->game_mode_enabled = game_mode_enabled;
 580         }
 581
 582         /* M1 - M3 */
 583         for (i = 0; i < 3; i++) {
 584                 val = data[3] & (0x10 << i);
 585                 input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val);
 586         }
 587         /* MR */
 588         input_report_key(g15->input, KEY_MACRO_RECORD_START, data[3] & 0x80);
 589
 590         /* LCD menu keys */
 591         for (i = 0; i < 5; i++) {
 592                 val = data[4] & (1 << i);
 593                 input_report_key(g15->input, KEY_KBD_LCD_MENU1 + i, val);
 594         }
 595
 596         /* Headphone Mute */
 597         input_report_key(g15->input, KEY_MUTE, data[4] & 0x20);
 598         /* Microphone Mute */
 599         input_report_key(g15->input, KEY_F20, data[4] & 0x40);
 600
 601         input_sync(g15->input);
 602         return 0;
 603 }
 604
 605 static int lg_g510_leds_event(struct lg_g15_data *g15, u8 *data)
 606 {
 607         bool backlight_disabled;
 608
 609         /*
 610          * The G510 ignores backlight updates when the backlight is turned off
 611          * through the light toggle button on the keyboard, to work around this
 612          * we queue a workitem to sync values when the backlight is turned on.
 613          */
 614         backlight_disabled = data[1] & 0x04;
 615         if (!backlight_disabled)
 616                 schedule_work(&g15->work);
 617
 618         return 0;
 619 }
 620
 621 static int lg_g15_raw_event(struct hid_device *hdev, struct hid_report *report,
 622                             u8 *data, int size)
 623 {
 624         struct lg_g15_data *g15 = hid_get_drvdata(hdev);
 625
 626         if (!g15)
 627                 return 0;
 628
 629         switch (g15->model) {
 630         case LG_G15:
 631                 if (data[0] == 0x02 && size == 9)
 632                         return lg_g15_event(g15, data);
 633                 break;
 634         case LG_G15_V2:
 635                 if (data[0] == 0x02 && size == 5)
 636                         return lg_g15_v2_event(g15, data);
 637                 break;
 638         case LG_Z10:
 639                 if (data[0] == 0x02 && size == 9) {
 640                         lg_g15_handle_lcd_menu_keys(g15, data);
 641                         input_sync(g15->input);
 642                 }
 643                 break;
 644         case LG_G510:
 645         case LG_G510_USB_AUDIO:
 646                 if (data[0] == 0x03 && size == 5)
 647                         return lg_g510_event(g15, data);
 648                 if (data[0] == 0x04 && size == 2)
 649                         return lg_g510_leds_event(g15, data);
 650                 break;
 651         }
 652
 653         return 0;
 654 }
 655
 656 static int lg_g15_input_open(struct input_dev *dev)
 657 {
 658         struct hid_device *hdev = input_get_drvdata(dev);
 659
 660         return hid_hw_open(hdev);
 661 }
 662
 663 static void lg_g15_input_close(struct input_dev *dev)
 664 {
 665         struct hid_device *hdev = input_get_drvdata(dev);
 666
 667         hid_hw_close(hdev);
 668 }
 669
 670 static int lg_g15_register_led(struct lg_g15_data *g15, int i, const char *name)
 671 {
 672         g15->leds[i].led = i;
 673         g15->leds[i].cdev.name = name;
 674
 675         switch (g15->model) {
 676         case LG_G15:
 677         case LG_G15_V2:
 678                 g15->leds[i].cdev.brightness_get = lg_g15_led_get;
 679                 fallthrough;
 680         case LG_Z10:
 681                 g15->leds[i].cdev.brightness_set_blocking = lg_g15_led_set;
 682                 if (i < LG_G15_BRIGHTNESS_MAX) {
 683                         g15->leds[i].cdev.flags = LED_BRIGHT_HW_CHANGED;
 684                         g15->leds[i].cdev.max_brightness = 2;
 685                 } else {
 686                         g15->leds[i].cdev.max_brightness = 1;
 687                 }
 688                 break;
 689         case LG_G510:
 690         case LG_G510_USB_AUDIO:
 691                 switch (i) {
 692                 case LG_G15_LCD_BRIGHTNESS:
 693                         /*
 694                          * The G510 does not have a separate LCD brightness,
 695                          * but it does have a separate power-on (reset) value.
 696                          */
 697                         g15->leds[i].cdev.name = "g15::power_on_backlight_val";
 698                         fallthrough;
 699                 case LG_G15_KBD_BRIGHTNESS:
 700                         g15->leds[i].cdev.brightness_set_blocking =
 701                                 lg_g510_kbd_led_set;
 702                         g15->leds[i].cdev.brightness_get =
 703                                 lg_g510_kbd_led_get;
 704                         g15->leds[i].cdev.max_brightness = 255;
 705                         g15->leds[i].cdev.groups = lg_g510_kbd_led_groups;
 706                         break;
 707                 default:
 708                         g15->leds[i].cdev.brightness_set_blocking =
 709                                 lg_g510_mkey_led_set;
 710                         g15->leds[i].cdev.brightness_get =
 711                                 lg_g510_mkey_led_get;
 712                         g15->leds[i].cdev.max_brightness = 1;
 713                 }
 714                 break;
 715         }
 716
 717         return devm_led_classdev_register(&g15->hdev->dev, &g15->leds[i].cdev);
 718 }
 719
 720 /* Common input device init code shared between keyboards and Z-10 speaker handling */
 721 static void lg_g15_init_input_dev(struct hid_device *hdev, struct input_dev *input,
 722                                   const char *name)
 723 {
 724         int i;
 725
 726         input->name = name;
 727         input->phys = hdev->phys;
 728         input->uniq = hdev->uniq;
 729         input->id.bustype = hdev->bus;
 730         input->id.vendor  = hdev->vendor;
 731         input->id.product = hdev->product;
 732         input->id.version = hdev->version;
 733         input->dev.parent = &hdev->dev;
 734         input->open = lg_g15_input_open;
 735         input->close = lg_g15_input_close;
 736
 737         /* Keys below the LCD, intended for controlling a menu on the LCD */
 738         for (i = 0; i < 5; i++)
 739                 input_set_capability(input, EV_KEY, KEY_KBD_LCD_MENU1 + i);
 740 }
 741
 742 static int lg_g15_probe(struct hid_device *hdev, const struct hid_device_id *id)
 743 {
 744         static const char * const led_names[] = {
 745                 "g15::kbd_backlight",
 746                 "g15::lcd_backlight",
 747                 "g15::macro_preset1",
 748                 "g15::macro_preset2",
 749                 "g15::macro_preset3",
 750                 "g15::macro_record",
 751         };
 752         u8 gkeys_settings_output_report = 0;
 753         u8 gkeys_settings_feature_report = 0;
 754         struct hid_report_enum *rep_enum;
 755         unsigned int connect_mask = 0;
 756         bool has_ff000000 = false;
 757         struct lg_g15_data *g15;
 758         struct input_dev *input;
 759         struct hid_report *rep;
 760         int ret, i, gkeys = 0;
 761
 762         hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
 763
 764         ret = hid_parse(hdev);
 765         if (ret)
 766                 return ret;
 767
 768         /*
 769          * Some models have multiple interfaces, we want the interface with
 770          * the f000.0000 application input report.
 771          */
 772         rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
 773         list_for_each_entry(rep, &rep_enum->report_list, list) {
 774                 if (rep->application == 0xff000000)
 775                         has_ff000000 = true;
 776         }
 777         if (!has_ff000000)
 778                 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 779
 780         g15 = devm_kzalloc(&hdev->dev, sizeof(*g15), GFP_KERNEL);
 781         if (!g15)
 782                 return -ENOMEM;
 783
 784         mutex_init(&g15->mutex);
 785
 786         input = devm_input_allocate_device(&hdev->dev);
 787         if (!input)
 788                 return -ENOMEM;
 789
 790         g15->hdev = hdev;
 791         g15->model = id->driver_data;
 792         g15->input = input;
 793         input_set_drvdata(input, hdev);
 794         hid_set_drvdata(hdev, (void *)g15);
 795
 796         switch (g15->model) {
 797         case LG_G15:
 798                 INIT_WORK(&g15->work, lg_g15_leds_changed_work);
 799                 /*
 800                  * The G15 and G15 v2 use a separate usb-device (on a builtin
 801                  * hub) which emulates a keyboard for the F1 - F12 emulation
 802                  * on the G-keys, which we disable, rendering the emulated kbd
 803                  * non-functional, so we do not let hid-input connect.
 804                  */
 805                 connect_mask = HID_CONNECT_HIDRAW;
 806                 gkeys_settings_output_report = 0x02;
 807                 gkeys = 18;
 808                 break;
 809         case LG_G15_V2:
 810                 INIT_WORK(&g15->work, lg_g15_leds_changed_work);
 811                 connect_mask = HID_CONNECT_HIDRAW;
 812                 gkeys_settings_output_report = 0x02;
 813                 gkeys = 6;
 814                 break;
 815         case LG_G510:
 816         case LG_G510_USB_AUDIO:
 817                 INIT_WORK(&g15->work, lg_g510_leds_sync_work);
 818                 connect_mask = HID_CONNECT_HIDINPUT | HID_CONNECT_HIDRAW;
 819                 gkeys_settings_feature_report = 0x01;
 820                 gkeys = 18;
 821                 break;
 822         case LG_Z10:
 823                 connect_mask = HID_CONNECT_HIDRAW;
 824                 break;
 825         }
 826
 827         ret = hid_hw_start(hdev, connect_mask);
 828         if (ret)
 829                 return ret;
 830
 831         /* Tell the keyboard to stop sending F1-F12 + 1-6 for G1 - G18 */
 832         if (gkeys_settings_output_report) {
 833                 g15->transfer_buf[0] = gkeys_settings_output_report;
 834                 memset(g15->transfer_buf + 1, 0, gkeys);
 835                 /*
 836                  * The kbd ignores our output report if we do not queue
 837                  * an URB on the USB input endpoint first...
 838                  */
 839                 ret = hid_hw_open(hdev);
 840                 if (ret)
 841                         goto error_hw_stop;
 842                 ret = hid_hw_output_report(hdev, g15->transfer_buf, gkeys + 1);
 843                 hid_hw_close(hdev);
 844         }
 845
 846         if (gkeys_settings_feature_report) {
 847                 g15->transfer_buf[0] = gkeys_settings_feature_report;
 848                 memset(g15->transfer_buf + 1, 0, gkeys);
 849                 ret = hid_hw_raw_request(g15->hdev,
 850                                 gkeys_settings_feature_report,
 851                                 g15->transfer_buf, gkeys + 1,
 852                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 853         }
 854
 855         if (ret < 0) {
 856                 hid_err(hdev, "Error %d disabling keyboard emulation for the G-keys, falling back to generic hid-input driver\n",
 857                         ret);
 858                 hid_set_drvdata(hdev, NULL);
 859                 return 0;
 860         }
 861
 862         /* Get initial brightness levels */
 863         ret = lg_g15_get_initial_led_brightness(g15);
 864         if (ret)
 865                 goto error_hw_stop;
 866
 867         if (g15->model == LG_Z10) {
 868                 lg_g15_init_input_dev(hdev, g15->input, "Logitech Z-10 LCD Menu Keys");
 869                 ret = input_register_device(g15->input);
 870                 if (ret)
 871                         goto error_hw_stop;
 872
 873                 ret = lg_g15_register_led(g15, 1, "z-10::lcd_backlight");
 874                 if (ret)
 875                         goto error_hw_stop;
 876
 877                 return 0; /* All done */
 878         }
 879
 880         /* Setup and register input device */
 881         lg_g15_init_input_dev(hdev, input, "Logitech Gaming Keyboard Gaming Keys");
 882
 883         /* G-keys */
 884         for (i = 0; i < gkeys; i++)
 885                 input_set_capability(input, EV_KEY, KEY_MACRO1 + i);
 886
 887         /* M1 - M3 and MR keys */
 888         for (i = 0; i < 3; i++)
 889                 input_set_capability(input, EV_KEY, KEY_MACRO_PRESET1 + i);
 890         input_set_capability(input, EV_KEY, KEY_MACRO_RECORD_START);
 891
 892         /*
 893          * On the G510 only report headphone and mic mute keys when *not* using
 894          * the builtin USB audio device. When the builtin audio is used these
 895          * keys directly toggle mute (and the LEDs) on/off.
 896          */
 897         if (g15->model == LG_G510) {
 898                 input_set_capability(input, EV_KEY, KEY_MUTE);
 899                 /* Userspace expects F20 for micmute */
 900                 input_set_capability(input, EV_KEY, KEY_F20);
 901         }
 902
 903         ret = input_register_device(input);
 904         if (ret)
 905                 goto error_hw_stop;
 906
 907         /* Register LED devices */
 908         for (i = 0; i < LG_G15_LED_MAX; i++) {
 909                 ret = lg_g15_register_led(g15, i, led_names[i]);
 910                 if (ret)
 911                         goto error_hw_stop;
 912         }
 913
 914         return 0;
 915
 916 error_hw_stop:
 917         hid_hw_stop(hdev);
 918         return ret;
 919 }
 920
 921 static const struct hid_device_id lg_g15_devices[] = {
 922         /* The G11 is a G15 without the LCD, treat it as a G15 */
 923         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 924                 USB_DEVICE_ID_LOGITECH_G11),
 925                 .driver_data = LG_G15 },
 926         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 927                          USB_DEVICE_ID_LOGITECH_G15_LCD),
 928                 .driver_data = LG_G15 },
 929         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 930                          USB_DEVICE_ID_LOGITECH_G15_V2_LCD),
 931                 .driver_data = LG_G15_V2 },
 932         /* G510 without a headset plugged in */
 933         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 934                          USB_DEVICE_ID_LOGITECH_G510),
 935                 .driver_data = LG_G510 },
 936         /* G510 with headset plugged in / with extra USB audio interface */
 937         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 938                          USB_DEVICE_ID_LOGITECH_G510_USB_AUDIO),
 939                 .driver_data = LG_G510_USB_AUDIO },
 940         /* Z-10 speakers */
 941         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 942                          USB_DEVICE_ID_LOGITECH_Z_10_SPK),
 943                 .driver_data = LG_Z10 },
 944         { }
 945 };
 946 MODULE_DEVICE_TABLE(hid, lg_g15_devices);
 947
 948 static struct hid_driver lg_g15_driver = {
 949         .name                   = "lg-g15",
 950         .id_table               = lg_g15_devices,
 951         .raw_event              = lg_g15_raw_event,
 952         .probe                  = lg_g15_probe,
 953 };
 954 module_hid_driver(lg_g15_driver);
 955
 956 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 957 MODULE_LICENSE("GPL");