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