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/led-class-multicolor.h> 12 #include <linux/module.h> 13 #include <linux/random.h> 14 #include <linux/sched.h> 15 #include <linux/usb.h> 16 #include <linux/wait.h> 17 #include <dt-bindings/leds/common.h> 18 19 #include "hid-ids.h" 20 21 #define LG_G15_TRANSFER_BUF_SIZE 20 22 23 #define LG_G15_FEATURE_REPORT 0x02 24 25 #define LG_G510_FEATURE_M_KEYS_LEDS 0x04 26 #define LG_G510_FEATURE_BACKLIGHT_RGB 0x05 27 #define LG_G510_FEATURE_POWER_ON_RGB 0x06 28 29 #define LG_G510_INPUT_MACRO_KEYS 0x03 30 #define LG_G510_INPUT_KBD_BACKLIGHT 0x04 31 32 #define LG_G13_INPUT_REPORT 0x01 33 #define LG_G13_FEATURE_M_KEYS_LEDS 0x05 34 #define LG_G13_FEATURE_BACKLIGHT_RGB 0x07 35 #define LG_G13_BACKLIGHT_HW_ON_BIT 23 36 37 /** 38 * g13_input_report.keybits[] is not 32-bit aligned, so we can't use the bitops macros. 39 * 40 * @ary: Pointer to array of u8s 41 * @b: Bit index into ary, LSB first. Not range checked. 42 */ 43 #define TEST_BIT(ary, b) ((1 << ((b) & 7)) & (ary)[(b) >> 3]) 44 45 enum lg_g15_model { 46 LG_G13, 47 LG_G15, 48 LG_G15_V2, 49 LG_G510, 50 LG_G510_USB_AUDIO, 51 LG_Z10, 52 }; 53 54 enum lg_g15_led_type { 55 LG_G15_KBD_BRIGHTNESS, 56 LG_G15_LCD_BRIGHTNESS, 57 LG_G15_BRIGHTNESS_MAX, 58 LG_G15_MACRO_PRESET1 = 2, 59 LG_G15_MACRO_PRESET2, 60 LG_G15_MACRO_PRESET3, 61 LG_G15_MACRO_RECORD, 62 LG_G15_LED_MAX 63 }; 64 65 struct g13_input_report { 66 u8 report_id; /* Report ID is always set to 1. */ 67 u8 joy_x, joy_y; 68 u8 keybits[5]; 69 }; 70 71 struct lg_g15_led { 72 union { 73 struct led_classdev cdev; 74 struct led_classdev_mc mcdev; 75 }; 76 enum led_brightness brightness; 77 enum lg_g15_led_type led; 78 /* Used to store initial color intensities before subled_info is allocated */ 79 u8 red, green, blue; 80 }; 81 82 struct lg_g15_data { 83 /* Must be first for proper dma alignment */ 84 u8 transfer_buf[LG_G15_TRANSFER_BUF_SIZE]; 85 /* Protects the transfer_buf and led brightness */ 86 struct mutex mutex; 87 struct work_struct work; 88 struct input_dev *input; 89 struct input_dev *input_js; /* Separate joystick device for G13. */ 90 struct hid_device *hdev; 91 enum lg_g15_model model; 92 struct lg_g15_led leds[LG_G15_LED_MAX]; 93 bool game_mode_enabled; 94 bool backlight_disabled; /* true == HW backlight toggled *OFF* */ 95 }; 96 97 /********* G13 LED functions ***********/ 98 /* 99 * G13 retains no state across power cycles, and always powers up with the backlight on, 100 * color #5AFF6E, all macro key LEDs off. 101 */ 102 static int lg_g13_get_leds_state(struct lg_g15_data *g15) 103 { 104 u8 * const tbuf = g15->transfer_buf; 105 int ret, high; 106 107 /* RGB backlight. */ 108 ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_BACKLIGHT_RGB, 109 tbuf, 5, 110 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 111 if (ret != 5) { 112 hid_err(g15->hdev, "Error getting backlight brightness: %d\n", ret); 113 return (ret < 0) ? ret : -EIO; 114 } 115 116 /* Normalize RGB intensities against the highest component. */ 117 high = max3(tbuf[1], tbuf[2], tbuf[3]); 118 if (high) { 119 g15->leds[LG_G15_KBD_BRIGHTNESS].red = 120 DIV_ROUND_CLOSEST(tbuf[1] * 255, high); 121 g15->leds[LG_G15_KBD_BRIGHTNESS].green = 122 DIV_ROUND_CLOSEST(tbuf[2] * 255, high); 123 g15->leds[LG_G15_KBD_BRIGHTNESS].blue = 124 DIV_ROUND_CLOSEST(tbuf[3] * 255, high); 125 g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = high; 126 } else { 127 g15->leds[LG_G15_KBD_BRIGHTNESS].red = 255; 128 g15->leds[LG_G15_KBD_BRIGHTNESS].green = 255; 129 g15->leds[LG_G15_KBD_BRIGHTNESS].blue = 255; 130 g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = 0; 131 } 132 133 /* Macro LEDs. */ 134 ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_M_KEYS_LEDS, 135 tbuf, 5, 136 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 137 if (ret != 5) { 138 hid_err(g15->hdev, "Error getting macro LED brightness: %d\n", ret); 139 return (ret < 0) ? ret : -EIO; 140 } 141 142 for (int i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; ++i) 143 g15->leds[i].brightness = !!(tbuf[1] & (1 << (i - LG_G15_MACRO_PRESET1))); 144 145 /* 146 * Bit 23 of g13_input_report.keybits[] contains the backlight's 147 * current HW toggle state. Retrieve it from the device. 148 */ 149 ret = hid_hw_raw_request(g15->hdev, LG_G13_INPUT_REPORT, 150 tbuf, sizeof(struct g13_input_report), 151 HID_INPUT_REPORT, HID_REQ_GET_REPORT); 152 if (ret != sizeof(struct g13_input_report)) { 153 hid_err(g15->hdev, "Error getting backlight on/off state: %d\n", ret); 154 return (ret < 0) ? ret : -EIO; 155 } 156 g15->backlight_disabled = 157 !TEST_BIT(((struct g13_input_report *) tbuf)->keybits, 158 LG_G13_BACKLIGHT_HW_ON_BIT); 159 160 return 0; 161 } 162 163 static int lg_g13_kbd_led_write(struct lg_g15_data *g15, 164 struct lg_g15_led *g15_led, 165 enum led_brightness brightness) 166 { 167 struct mc_subled const * const subleds = g15_led->mcdev.subled_info; 168 u8 * const tbuf = g15->transfer_buf; 169 int ret; 170 171 guard(mutex)(&g15->mutex); 172 173 led_mc_calc_color_components(&g15_led->mcdev, brightness); 174 175 tbuf[0] = 5; 176 tbuf[1] = subleds[0].brightness; 177 tbuf[2] = subleds[1].brightness; 178 tbuf[3] = subleds[2].brightness; 179 tbuf[4] = 0; 180 181 ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_BACKLIGHT_RGB, 182 tbuf, 5, 183 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 184 if (ret != 5) { 185 hid_err(g15->hdev, "Error setting backlight brightness: %d\n", ret); 186 return (ret < 0) ? ret : -EIO; 187 } 188 189 g15_led->brightness = brightness; 190 return 0; 191 } 192 193 static int lg_g13_kbd_led_set(struct led_classdev *led_cdev, enum led_brightness brightness) 194 { 195 struct led_classdev_mc *mc = lcdev_to_mccdev(led_cdev); 196 struct lg_g15_led *g15_led = 197 container_of(mc, struct lg_g15_led, mcdev); 198 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 199 200 /* Ignore LED off on unregister / keyboard unplug */ 201 if (led_cdev->flags & LED_UNREGISTERING) 202 return 0; 203 204 return lg_g13_kbd_led_write(g15, g15_led, brightness); 205 } 206 207 static enum led_brightness lg_g13_kbd_led_get(struct led_classdev *led_cdev) 208 { 209 struct led_classdev_mc const * const mc = lcdev_to_mccdev(led_cdev); 210 struct lg_g15_led const *g15_led = 211 container_of(mc, struct lg_g15_led, mcdev); 212 213 return g15_led->brightness; 214 } 215 216 static int lg_g13_mkey_led_set(struct led_classdev *led_cdev, enum led_brightness brightness) 217 { 218 struct lg_g15_led *g15_led = 219 container_of(led_cdev, struct lg_g15_led, cdev); 220 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 221 int i, ret; 222 u8 * const tbuf = g15->transfer_buf; 223 u8 val, mask = 0; 224 225 /* Ignore LED off on unregister / keyboard unplug */ 226 if (led_cdev->flags & LED_UNREGISTERING) 227 return 0; 228 229 guard(mutex)(&g15->mutex); 230 231 for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; ++i) { 232 if (i == g15_led->led) 233 val = brightness; 234 else 235 val = g15->leds[i].brightness; 236 237 if (val) 238 mask |= 1 << (i - LG_G15_MACRO_PRESET1); 239 } 240 241 tbuf[0] = 5; 242 tbuf[1] = mask; 243 tbuf[2] = 0; 244 tbuf[3] = 0; 245 tbuf[4] = 0; 246 247 ret = hid_hw_raw_request(g15->hdev, LG_G13_FEATURE_M_KEYS_LEDS, 248 tbuf, 5, 249 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 250 if (ret != 5) { 251 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret); 252 return (ret < 0) ? ret : -EIO; 253 } 254 255 g15_led->brightness = brightness; 256 return 0; 257 } 258 259 static enum led_brightness lg_g13_mkey_led_get(struct led_classdev *led_cdev) 260 { 261 /* 262 * G13 doesn't change macro key LEDs behind our back, so they're 263 * whatever we last set them to. 264 */ 265 struct lg_g15_led *g15_led = 266 container_of(led_cdev, struct lg_g15_led, cdev); 267 268 return g15_led->brightness; 269 } 270 271 /******** G15 and G15 v2 LED functions ********/ 272 273 static int lg_g15_update_led_brightness(struct lg_g15_data *g15) 274 { 275 int ret; 276 277 ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT, 278 g15->transfer_buf, 4, 279 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 280 if (ret != 4) { 281 hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret); 282 return (ret < 0) ? ret : -EIO; 283 } 284 285 g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = g15->transfer_buf[1]; 286 g15->leds[LG_G15_LCD_BRIGHTNESS].brightness = g15->transfer_buf[2]; 287 288 g15->leds[LG_G15_MACRO_PRESET1].brightness = 289 !(g15->transfer_buf[3] & 0x01); 290 g15->leds[LG_G15_MACRO_PRESET2].brightness = 291 !(g15->transfer_buf[3] & 0x02); 292 g15->leds[LG_G15_MACRO_PRESET3].brightness = 293 !(g15->transfer_buf[3] & 0x04); 294 g15->leds[LG_G15_MACRO_RECORD].brightness = 295 !(g15->transfer_buf[3] & 0x08); 296 297 return 0; 298 } 299 300 static enum led_brightness lg_g15_led_get(struct led_classdev *led_cdev) 301 { 302 struct lg_g15_led *g15_led = 303 container_of(led_cdev, struct lg_g15_led, cdev); 304 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 305 enum led_brightness brightness; 306 307 mutex_lock(&g15->mutex); 308 lg_g15_update_led_brightness(g15); 309 brightness = g15->leds[g15_led->led].brightness; 310 mutex_unlock(&g15->mutex); 311 312 return brightness; 313 } 314 315 static int lg_g15_led_set(struct led_classdev *led_cdev, 316 enum led_brightness brightness) 317 { 318 struct lg_g15_led *g15_led = 319 container_of(led_cdev, struct lg_g15_led, cdev); 320 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 321 u8 val, mask = 0; 322 int i, ret; 323 324 /* Ignore LED off on unregister / keyboard unplug */ 325 if (led_cdev->flags & LED_UNREGISTERING) 326 return 0; 327 328 mutex_lock(&g15->mutex); 329 330 g15->transfer_buf[0] = LG_G15_FEATURE_REPORT; 331 g15->transfer_buf[3] = 0; 332 333 if (g15_led->led < LG_G15_BRIGHTNESS_MAX) { 334 g15->transfer_buf[1] = g15_led->led + 1; 335 g15->transfer_buf[2] = brightness << (g15_led->led * 4); 336 } else { 337 for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) { 338 if (i == g15_led->led) 339 val = brightness; 340 else 341 val = g15->leds[i].brightness; 342 343 if (val) 344 mask |= 1 << (i - LG_G15_MACRO_PRESET1); 345 } 346 347 g15->transfer_buf[1] = 0x04; 348 g15->transfer_buf[2] = ~mask; 349 } 350 351 ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT, 352 g15->transfer_buf, 4, 353 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 354 if (ret == 4) { 355 /* Success */ 356 g15_led->brightness = brightness; 357 ret = 0; 358 } else { 359 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret); 360 ret = (ret < 0) ? ret : -EIO; 361 } 362 363 mutex_unlock(&g15->mutex); 364 365 return ret; 366 } 367 368 static void lg_g15_leds_changed_work(struct work_struct *work) 369 { 370 struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work); 371 enum led_brightness old_brightness[LG_G15_BRIGHTNESS_MAX]; 372 enum led_brightness brightness[LG_G15_BRIGHTNESS_MAX]; 373 int i, ret; 374 375 mutex_lock(&g15->mutex); 376 for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++) 377 old_brightness[i] = g15->leds[i].brightness; 378 379 ret = lg_g15_update_led_brightness(g15); 380 381 for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++) 382 brightness[i] = g15->leds[i].brightness; 383 mutex_unlock(&g15->mutex); 384 385 if (ret) 386 return; 387 388 for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++) { 389 if (brightness[i] == old_brightness[i]) 390 continue; 391 392 led_classdev_notify_brightness_hw_changed(&g15->leds[i].cdev, 393 brightness[i]); 394 } 395 } 396 397 /******** G510 LED functions ********/ 398 399 static int lg_g510_get_initial_led_brightness(struct lg_g15_data *g15, int i) 400 { 401 int ret, high; 402 403 ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_BACKLIGHT_RGB + i, 404 g15->transfer_buf, 4, 405 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 406 if (ret != 4) { 407 hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret); 408 return (ret < 0) ? ret : -EIO; 409 } 410 411 high = max3(g15->transfer_buf[1], g15->transfer_buf[2], 412 g15->transfer_buf[3]); 413 414 if (high) { 415 g15->leds[i].red = 416 DIV_ROUND_CLOSEST(g15->transfer_buf[1] * 255, high); 417 g15->leds[i].green = 418 DIV_ROUND_CLOSEST(g15->transfer_buf[2] * 255, high); 419 g15->leds[i].blue = 420 DIV_ROUND_CLOSEST(g15->transfer_buf[3] * 255, high); 421 g15->leds[i].brightness = high; 422 } else { 423 g15->leds[i].red = 255; 424 g15->leds[i].green = 255; 425 g15->leds[i].blue = 255; 426 g15->leds[i].brightness = 0; 427 } 428 429 if (i) 430 return 0; 431 432 ret = hid_hw_raw_request(g15->hdev, LG_G510_INPUT_KBD_BACKLIGHT, 433 g15->transfer_buf, 2, 434 HID_INPUT_REPORT, HID_REQ_GET_REPORT); 435 if (ret != 2) { 436 /* This can happen when a KVM switch is used, so only warn. */ 437 hid_warn(g15->hdev, "Error getting backlight state: %d\n", ret); 438 return 0; 439 } 440 441 g15->backlight_disabled = g15->transfer_buf[1] & 0x04; 442 443 return 0; 444 } 445 446 /* Must be called with g15->mutex locked */ 447 static int lg_g510_kbd_led_write(struct lg_g15_data *g15, 448 struct lg_g15_led *g15_led, 449 enum led_brightness brightness) 450 { 451 struct mc_subled *subleds = g15_led->mcdev.subled_info; 452 int ret; 453 454 led_mc_calc_color_components(&g15_led->mcdev, brightness); 455 456 g15->transfer_buf[0] = 5 + g15_led->led; 457 g15->transfer_buf[1] = subleds[0].brightness; 458 g15->transfer_buf[2] = subleds[1].brightness; 459 g15->transfer_buf[3] = subleds[2].brightness; 460 461 ret = hid_hw_raw_request(g15->hdev, 462 LG_G510_FEATURE_BACKLIGHT_RGB + g15_led->led, 463 g15->transfer_buf, 4, 464 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 465 if (ret == 4) { 466 /* Success */ 467 g15_led->brightness = brightness; 468 ret = 0; 469 } else { 470 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret); 471 ret = (ret < 0) ? ret : -EIO; 472 } 473 474 return ret; 475 } 476 477 static int lg_g510_kbd_led_set(struct led_classdev *led_cdev, 478 enum led_brightness brightness) 479 { 480 struct led_classdev_mc *mc = lcdev_to_mccdev(led_cdev); 481 struct lg_g15_led *g15_led = 482 container_of(mc, struct lg_g15_led, mcdev); 483 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 484 int ret; 485 486 /* Ignore LED off on unregister / keyboard unplug */ 487 if (led_cdev->flags & LED_UNREGISTERING) 488 return 0; 489 490 mutex_lock(&g15->mutex); 491 ret = lg_g510_kbd_led_write(g15, g15_led, brightness); 492 mutex_unlock(&g15->mutex); 493 494 return ret; 495 } 496 497 static enum led_brightness lg_g510_kbd_led_get(struct led_classdev *led_cdev) 498 { 499 struct led_classdev_mc *mc = lcdev_to_mccdev(led_cdev); 500 struct lg_g15_led *g15_led = 501 container_of(mc, struct lg_g15_led, mcdev); 502 503 return g15_led->brightness; 504 } 505 506 static void lg_g510_leds_sync_work(struct work_struct *work) 507 { 508 struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work); 509 struct lg_g15_led *g15_led = &g15->leds[LG_G15_KBD_BRIGHTNESS]; 510 511 mutex_lock(&g15->mutex); 512 lg_g510_kbd_led_write(g15, g15_led, g15_led->brightness); 513 mutex_unlock(&g15->mutex); 514 } 515 516 static int lg_g510_update_mkey_led_brightness(struct lg_g15_data *g15) 517 { 518 int ret; 519 520 ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS, 521 g15->transfer_buf, 2, 522 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 523 if (ret != 2) { 524 hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret); 525 ret = (ret < 0) ? ret : -EIO; 526 } 527 528 g15->leds[LG_G15_MACRO_PRESET1].brightness = 529 !!(g15->transfer_buf[1] & 0x80); 530 g15->leds[LG_G15_MACRO_PRESET2].brightness = 531 !!(g15->transfer_buf[1] & 0x40); 532 g15->leds[LG_G15_MACRO_PRESET3].brightness = 533 !!(g15->transfer_buf[1] & 0x20); 534 g15->leds[LG_G15_MACRO_RECORD].brightness = 535 !!(g15->transfer_buf[1] & 0x10); 536 537 return 0; 538 } 539 540 static enum led_brightness lg_g510_mkey_led_get(struct led_classdev *led_cdev) 541 { 542 struct lg_g15_led *g15_led = 543 container_of(led_cdev, struct lg_g15_led, cdev); 544 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 545 enum led_brightness brightness; 546 547 mutex_lock(&g15->mutex); 548 lg_g510_update_mkey_led_brightness(g15); 549 brightness = g15->leds[g15_led->led].brightness; 550 mutex_unlock(&g15->mutex); 551 552 return brightness; 553 } 554 555 static int lg_g510_mkey_led_set(struct led_classdev *led_cdev, 556 enum led_brightness brightness) 557 { 558 struct lg_g15_led *g15_led = 559 container_of(led_cdev, struct lg_g15_led, cdev); 560 struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent); 561 u8 val, mask = 0; 562 int i, ret; 563 564 /* Ignore LED off on unregister / keyboard unplug */ 565 if (led_cdev->flags & LED_UNREGISTERING) 566 return 0; 567 568 mutex_lock(&g15->mutex); 569 570 for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) { 571 if (i == g15_led->led) 572 val = brightness; 573 else 574 val = g15->leds[i].brightness; 575 576 if (val) 577 mask |= 0x80 >> (i - LG_G15_MACRO_PRESET1); 578 } 579 580 g15->transfer_buf[0] = LG_G510_FEATURE_M_KEYS_LEDS; 581 g15->transfer_buf[1] = mask; 582 583 ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS, 584 g15->transfer_buf, 2, 585 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 586 if (ret == 2) { 587 /* Success */ 588 g15_led->brightness = brightness; 589 ret = 0; 590 } else { 591 hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret); 592 ret = (ret < 0) ? ret : -EIO; 593 } 594 595 mutex_unlock(&g15->mutex); 596 597 return ret; 598 } 599 600 /******** Generic LED functions ********/ 601 static int lg_g15_get_initial_led_brightness(struct lg_g15_data *g15) 602 { 603 int ret; 604 605 switch (g15->model) { 606 case LG_G13: 607 return lg_g13_get_leds_state(g15); 608 case LG_G15: 609 case LG_G15_V2: 610 return lg_g15_update_led_brightness(g15); 611 case LG_G510: 612 case LG_G510_USB_AUDIO: 613 ret = lg_g510_get_initial_led_brightness(g15, 0); 614 if (ret) 615 return ret; 616 617 ret = lg_g510_get_initial_led_brightness(g15, 1); 618 if (ret) 619 return ret; 620 621 return lg_g510_update_mkey_led_brightness(g15); 622 case LG_Z10: 623 /* 624 * Getting the LCD backlight brightness is not supported. 625 * Reading Feature(2) fails with -EPIPE and this crashes 626 * the LCD and touch keys part of the speakers. 627 */ 628 return 0; 629 } 630 return -EINVAL; /* Never reached */ 631 } 632 633 /******** Input functions ********/ 634 635 /* Table mapping keybits[] bit positions to event codes. */ 636 /* Note: Indices are discontinuous to aid readability. */ 637 static const u16 g13_keys_for_bits[] = { 638 /* Main keypad - keys G1 - G22 */ 639 [0] = KEY_MACRO1, 640 [1] = KEY_MACRO2, 641 [2] = KEY_MACRO3, 642 [3] = KEY_MACRO4, 643 [4] = KEY_MACRO5, 644 [5] = KEY_MACRO6, 645 [6] = KEY_MACRO7, 646 [7] = KEY_MACRO8, 647 [8] = KEY_MACRO9, 648 [9] = KEY_MACRO10, 649 [10] = KEY_MACRO11, 650 [11] = KEY_MACRO12, 651 [12] = KEY_MACRO13, 652 [13] = KEY_MACRO14, 653 [14] = KEY_MACRO15, 654 [15] = KEY_MACRO16, 655 [16] = KEY_MACRO17, 656 [17] = KEY_MACRO18, 657 [18] = KEY_MACRO19, 658 [19] = KEY_MACRO20, 659 [20] = KEY_MACRO21, 660 [21] = KEY_MACRO22, 661 662 /* LCD menu buttons. */ 663 [24] = KEY_KBD_LCD_MENU5, /* "Next page" button */ 664 [25] = KEY_KBD_LCD_MENU1, /* Left-most */ 665 [26] = KEY_KBD_LCD_MENU2, 666 [27] = KEY_KBD_LCD_MENU3, 667 [28] = KEY_KBD_LCD_MENU4, /* Right-most */ 668 669 /* Macro preset and record buttons; have red LEDs under them. */ 670 [29] = KEY_MACRO_PRESET1, 671 [30] = KEY_MACRO_PRESET2, 672 [31] = KEY_MACRO_PRESET3, 673 [32] = KEY_MACRO_RECORD_START, 674 675 /* 33-35 handled by joystick device. */ 676 677 /* Backlight toggle. */ 678 [37] = KEY_LIGHTS_TOGGLE, 679 }; 680 681 #define G13_JS_KEYBITS_OFFSET 33 682 683 static const u16 g13_keys_for_bits_js[] = { 684 /* Joystick buttons */ 685 /* These keybits are at bit indices 33, 34, and 35. */ 686 BTN_BASE, /* Left side */ 687 BTN_BASE2, /* Bottom side */ 688 BTN_THUMB, /* Stick depress */ 689 }; 690 691 static int lg_g13_event(struct lg_g15_data *g15, u8 const *data) 692 { 693 struct g13_input_report const * const rep = (struct g13_input_report *) data; 694 int i, val; 695 bool backlight_disabled; 696 697 /* 698 * Main macropad and menu keys. 699 * Emit key events defined for each bit position. 700 */ 701 for (i = 0; i < ARRAY_SIZE(g13_keys_for_bits); ++i) { 702 if (g13_keys_for_bits[i]) { 703 val = TEST_BIT(rep->keybits, i); 704 input_report_key(g15->input, g13_keys_for_bits[i], val); 705 } 706 } 707 input_sync(g15->input); 708 709 /* 710 * Joystick. 711 * Emit button and deflection events. 712 */ 713 for (i = 0; i < ARRAY_SIZE(g13_keys_for_bits_js); ++i) { 714 val = TEST_BIT(rep->keybits, i + G13_JS_KEYBITS_OFFSET); 715 input_report_key(g15->input_js, g13_keys_for_bits_js[i], val); 716 } 717 input_report_abs(g15->input_js, ABS_X, rep->joy_x); 718 input_report_abs(g15->input_js, ABS_Y, rep->joy_y); 719 input_sync(g15->input_js); 720 721 /* 722 * Bit 23 of keybits[] reports the current backlight on/off state. If 723 * it has changed from the last cached value, apply an update. 724 */ 725 backlight_disabled = !TEST_BIT(rep->keybits, LG_G13_BACKLIGHT_HW_ON_BIT); 726 if (backlight_disabled ^ g15->backlight_disabled) { 727 led_classdev_notify_brightness_hw_changed( 728 &g15->leds[LG_G15_KBD_BRIGHTNESS].mcdev.led_cdev, 729 backlight_disabled 730 ? 0 : g15->leds[LG_G15_KBD_BRIGHTNESS].brightness); 731 g15->backlight_disabled = backlight_disabled; 732 } 733 734 return 0; 735 } 736 737 /* On the G15 Mark I Logitech has been quite creative with which bit is what */ 738 static void lg_g15_handle_lcd_menu_keys(struct lg_g15_data *g15, u8 *data) 739 { 740 int i, val; 741 742 /* Most left (round/display) button below the LCD */ 743 input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[8] & 0x80); 744 /* 4 other buttons below the LCD */ 745 for (i = 0; i < 4; i++) { 746 val = data[i + 2] & 0x80; 747 input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val); 748 } 749 } 750 751 static int lg_g15_event(struct lg_g15_data *g15, u8 *data) 752 { 753 int i, val; 754 755 /* G1 - G6 */ 756 for (i = 0; i < 6; i++) { 757 val = data[i + 1] & (1 << i); 758 input_report_key(g15->input, KEY_MACRO1 + i, val); 759 } 760 /* G7 - G12 */ 761 for (i = 0; i < 6; i++) { 762 val = data[i + 2] & (1 << i); 763 input_report_key(g15->input, KEY_MACRO7 + i, val); 764 } 765 /* G13 - G17 */ 766 for (i = 0; i < 5; i++) { 767 val = data[i + 1] & (4 << i); 768 input_report_key(g15->input, KEY_MACRO13 + i, val); 769 } 770 /* G18 */ 771 input_report_key(g15->input, KEY_MACRO18, data[8] & 0x40); 772 773 /* M1 - M3 */ 774 for (i = 0; i < 3; i++) { 775 val = data[i + 6] & (1 << i); 776 input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val); 777 } 778 /* MR */ 779 input_report_key(g15->input, KEY_MACRO_RECORD_START, data[7] & 0x40); 780 781 lg_g15_handle_lcd_menu_keys(g15, data); 782 783 /* Backlight cycle button pressed? */ 784 if (data[1] & 0x80) 785 schedule_work(&g15->work); 786 787 input_sync(g15->input); 788 return 0; 789 } 790 791 static int lg_g15_v2_event(struct lg_g15_data *g15, u8 *data) 792 { 793 int i, val; 794 795 /* G1 - G6 */ 796 for (i = 0; i < 6; i++) { 797 val = data[1] & (1 << i); 798 input_report_key(g15->input, KEY_MACRO1 + i, val); 799 } 800 801 /* M1 - M3 + MR */ 802 input_report_key(g15->input, KEY_MACRO_PRESET1, data[1] & 0x40); 803 input_report_key(g15->input, KEY_MACRO_PRESET2, data[1] & 0x80); 804 input_report_key(g15->input, KEY_MACRO_PRESET3, data[2] & 0x20); 805 input_report_key(g15->input, KEY_MACRO_RECORD_START, data[2] & 0x40); 806 807 /* Round button to the left of the LCD */ 808 input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[2] & 0x80); 809 /* 4 buttons below the LCD */ 810 for (i = 0; i < 4; i++) { 811 val = data[2] & (2 << i); 812 input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val); 813 } 814 815 /* Backlight cycle button pressed? */ 816 if (data[2] & 0x01) 817 schedule_work(&g15->work); 818 819 input_sync(g15->input); 820 return 0; 821 } 822 823 static int lg_g510_event(struct lg_g15_data *g15, u8 *data) 824 { 825 bool game_mode_enabled; 826 int i, val; 827 828 /* G1 - G18 */ 829 for (i = 0; i < 18; i++) { 830 val = data[i / 8 + 1] & (1 << (i % 8)); 831 input_report_key(g15->input, KEY_MACRO1 + i, val); 832 } 833 834 /* Game mode on/off slider */ 835 game_mode_enabled = data[3] & 0x04; 836 if (game_mode_enabled != g15->game_mode_enabled) { 837 if (game_mode_enabled) 838 hid_info(g15->hdev, "Game Mode enabled, Windows (super) key is disabled\n"); 839 else 840 hid_info(g15->hdev, "Game Mode disabled\n"); 841 g15->game_mode_enabled = game_mode_enabled; 842 } 843 844 /* M1 - M3 */ 845 for (i = 0; i < 3; i++) { 846 val = data[3] & (0x10 << i); 847 input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val); 848 } 849 /* MR */ 850 input_report_key(g15->input, KEY_MACRO_RECORD_START, data[3] & 0x80); 851 852 /* LCD menu keys */ 853 for (i = 0; i < 5; i++) { 854 val = data[4] & (1 << i); 855 input_report_key(g15->input, KEY_KBD_LCD_MENU1 + i, val); 856 } 857 858 /* Headphone Mute */ 859 input_report_key(g15->input, KEY_MUTE, data[4] & 0x20); 860 /* Microphone Mute */ 861 input_report_key(g15->input, KEY_F20, data[4] & 0x40); 862 863 input_sync(g15->input); 864 return 0; 865 } 866 867 static int lg_g510_leds_event(struct lg_g15_data *g15, u8 *data) 868 { 869 struct lg_g15_led *g15_led = &g15->leds[LG_G15_KBD_BRIGHTNESS]; 870 bool backlight_disabled; 871 872 backlight_disabled = data[1] & 0x04; 873 if (backlight_disabled == g15->backlight_disabled) 874 return 0; 875 876 led_classdev_notify_brightness_hw_changed( 877 &g15_led->mcdev.led_cdev, 878 backlight_disabled ? 0 : g15_led->brightness); 879 880 g15->backlight_disabled = backlight_disabled; 881 882 /* 883 * The G510 ignores backlight updates when the backlight is turned off 884 * through the light toggle button on the keyboard, to work around this 885 * we queue a workitem to sync values when the backlight is turned on. 886 */ 887 if (!backlight_disabled) 888 schedule_work(&g15->work); 889 890 return 0; 891 } 892 893 static int lg_g15_raw_event(struct hid_device *hdev, struct hid_report *report, 894 u8 *data, int size) 895 { 896 struct lg_g15_data *g15 = hid_get_drvdata(hdev); 897 898 if (!g15) 899 return 0; 900 901 switch (g15->model) { 902 case LG_G13: 903 if (data[0] == 0x01 && size == sizeof(struct g13_input_report)) 904 return lg_g13_event(g15, data); 905 break; 906 case LG_G15: 907 if (data[0] == 0x02 && size == 9) 908 return lg_g15_event(g15, data); 909 break; 910 case LG_G15_V2: 911 if (data[0] == 0x02 && size == 5) 912 return lg_g15_v2_event(g15, data); 913 break; 914 case LG_Z10: 915 if (data[0] == 0x02 && size == 9) { 916 lg_g15_handle_lcd_menu_keys(g15, data); 917 input_sync(g15->input); 918 } 919 break; 920 case LG_G510: 921 case LG_G510_USB_AUDIO: 922 if (data[0] == LG_G510_INPUT_MACRO_KEYS && size == 5) 923 return lg_g510_event(g15, data); 924 if (data[0] == LG_G510_INPUT_KBD_BACKLIGHT && size == 2) 925 return lg_g510_leds_event(g15, data); 926 break; 927 } 928 929 return 0; 930 } 931 932 static int lg_g15_input_open(struct input_dev *dev) 933 { 934 struct hid_device *hdev = input_get_drvdata(dev); 935 936 return hid_hw_open(hdev); 937 } 938 939 static void lg_g15_input_close(struct input_dev *dev) 940 { 941 struct hid_device *hdev = input_get_drvdata(dev); 942 943 hid_hw_close(hdev); 944 } 945 946 static void lg_g15_setup_led_rgb(struct lg_g15_data *g15, int index) 947 { 948 int i; 949 struct mc_subled *subled_info; 950 struct lg_g15_led * const gled = &g15->leds[index]; 951 952 if (g15->model == LG_G13) { 953 gled->mcdev.led_cdev.brightness_set_blocking = 954 lg_g13_kbd_led_set; 955 gled->mcdev.led_cdev.brightness_get = 956 lg_g13_kbd_led_get; 957 gled->mcdev.led_cdev.flags = LED_BRIGHT_HW_CHANGED; 958 } else { 959 gled->mcdev.led_cdev.brightness_set_blocking = 960 lg_g510_kbd_led_set; 961 gled->mcdev.led_cdev.brightness_get = 962 lg_g510_kbd_led_get; 963 if (index == LG_G15_KBD_BRIGHTNESS) 964 g15->leds[index].mcdev.led_cdev.flags = LED_BRIGHT_HW_CHANGED; 965 } 966 gled->mcdev.led_cdev.max_brightness = 255; 967 gled->mcdev.num_colors = 3; 968 969 subled_info = devm_kcalloc(&g15->hdev->dev, 3, sizeof(*subled_info), GFP_KERNEL); 970 if (!subled_info) 971 return; 972 973 for (i = 0; i < 3; i++) { 974 switch (i + 1) { 975 case LED_COLOR_ID_RED: 976 subled_info[i].color_index = LED_COLOR_ID_RED; 977 subled_info[i].intensity = gled->red; 978 break; 979 case LED_COLOR_ID_GREEN: 980 subled_info[i].color_index = LED_COLOR_ID_GREEN; 981 subled_info[i].intensity = gled->green; 982 break; 983 case LED_COLOR_ID_BLUE: 984 subled_info[i].color_index = LED_COLOR_ID_BLUE; 985 subled_info[i].intensity = gled->blue; 986 break; 987 } 988 subled_info[i].channel = i; 989 } 990 gled->mcdev.subled_info = subled_info; 991 } 992 993 static int lg_g15_register_led(struct lg_g15_data *g15, int i, const char *name) 994 { 995 int ret; 996 997 g15->leds[i].led = i; 998 g15->leds[i].cdev.name = name; 999 1000 switch (g15->model) { 1001 case LG_G13: 1002 if (i < LG_G15_BRIGHTNESS_MAX) { 1003 /* RGB backlight. */ 1004 lg_g15_setup_led_rgb(g15, i); 1005 ret = devm_led_classdev_multicolor_register_ext(&g15->hdev->dev, 1006 &g15->leds[i].mcdev, 1007 NULL); 1008 } else { 1009 /* Macro keys */ 1010 g15->leds[i].cdev.brightness_set_blocking = lg_g13_mkey_led_set; 1011 g15->leds[i].cdev.brightness_get = lg_g13_mkey_led_get; 1012 g15->leds[i].cdev.max_brightness = 1; 1013 1014 ret = devm_led_classdev_register(&g15->hdev->dev, 1015 &g15->leds[i].cdev); 1016 } 1017 break; 1018 case LG_G15: 1019 case LG_G15_V2: 1020 g15->leds[i].cdev.brightness_get = lg_g15_led_get; 1021 fallthrough; 1022 case LG_Z10: 1023 g15->leds[i].cdev.brightness_set_blocking = lg_g15_led_set; 1024 if (i < LG_G15_BRIGHTNESS_MAX) { 1025 g15->leds[i].cdev.flags = LED_BRIGHT_HW_CHANGED; 1026 g15->leds[i].cdev.max_brightness = 2; 1027 } else { 1028 g15->leds[i].cdev.max_brightness = 1; 1029 } 1030 ret = devm_led_classdev_register(&g15->hdev->dev, &g15->leds[i].cdev); 1031 break; 1032 case LG_G510: 1033 case LG_G510_USB_AUDIO: 1034 switch (i) { 1035 case LG_G15_LCD_BRIGHTNESS: 1036 /* 1037 * The G510 does not have a separate LCD brightness, 1038 * but it does have a separate power-on (reset) value. 1039 */ 1040 g15->leds[i].cdev.name = "g15::power_on_backlight_val"; 1041 fallthrough; 1042 case LG_G15_KBD_BRIGHTNESS: 1043 /* register multicolor LED */ 1044 lg_g15_setup_led_rgb(g15, i); 1045 ret = devm_led_classdev_multicolor_register_ext(&g15->hdev->dev, 1046 &g15->leds[i].mcdev, 1047 NULL); 1048 break; 1049 default: 1050 g15->leds[i].cdev.brightness_set_blocking = 1051 lg_g510_mkey_led_set; 1052 g15->leds[i].cdev.brightness_get = 1053 lg_g510_mkey_led_get; 1054 g15->leds[i].cdev.max_brightness = 1; 1055 ret = devm_led_classdev_register(&g15->hdev->dev, &g15->leds[i].cdev); 1056 } 1057 break; 1058 } 1059 1060 return ret; 1061 } 1062 1063 /* Common input device init code shared between keyboards and Z-10 speaker handling */ 1064 static void lg_g15_init_input_dev_core(struct hid_device *hdev, struct input_dev *input, 1065 char const *name) 1066 { 1067 input->name = name; 1068 input->phys = hdev->phys; 1069 input->uniq = hdev->uniq; 1070 input->id.bustype = hdev->bus; 1071 input->id.vendor = hdev->vendor; 1072 input->id.product = hdev->product; 1073 input->id.version = hdev->version; 1074 input->dev.parent = &hdev->dev; 1075 input->open = lg_g15_input_open; 1076 input->close = lg_g15_input_close; 1077 } 1078 1079 static void lg_g15_init_input_dev(struct hid_device *hdev, struct input_dev *input, 1080 const char *name) 1081 { 1082 int i; 1083 1084 lg_g15_init_input_dev_core(hdev, input, name); 1085 1086 /* Keys below the LCD, intended for controlling a menu on the LCD */ 1087 for (i = 0; i < 5; i++) 1088 input_set_capability(input, EV_KEY, KEY_KBD_LCD_MENU1 + i); 1089 } 1090 1091 static void lg_g13_init_input_dev(struct hid_device *hdev, 1092 struct input_dev *input, const char *name, 1093 struct input_dev *input_js, const char *name_js) 1094 { 1095 /* Macropad. */ 1096 lg_g15_init_input_dev_core(hdev, input, name); 1097 for (int i = 0; i < ARRAY_SIZE(g13_keys_for_bits); ++i) { 1098 if (g13_keys_for_bits[i]) 1099 input_set_capability(input, EV_KEY, g13_keys_for_bits[i]); 1100 } 1101 1102 /* OBTW, we're a joystick, too... */ 1103 lg_g15_init_input_dev_core(hdev, input_js, name_js); 1104 for (int i = 0; i < ARRAY_SIZE(g13_keys_for_bits_js); ++i) 1105 input_set_capability(input_js, EV_KEY, g13_keys_for_bits_js[i]); 1106 1107 input_set_capability(input_js, EV_ABS, ABS_X); 1108 input_set_abs_params(input_js, ABS_X, 0, 255, 0, 0); 1109 input_set_capability(input_js, EV_ABS, ABS_Y); 1110 input_set_abs_params(input_js, ABS_Y, 0, 255, 0, 0); 1111 } 1112 1113 static int lg_g15_probe(struct hid_device *hdev, const struct hid_device_id *id) 1114 { 1115 static const char * const led_names[] = { 1116 "g15::kbd_backlight", 1117 "g15::lcd_backlight", 1118 "g15::macro_preset1", 1119 "g15::macro_preset2", 1120 "g15::macro_preset3", 1121 "g15::macro_record", 1122 }; 1123 u8 gkeys_settings_output_report = 0; 1124 u8 gkeys_settings_feature_report = 0; 1125 struct hid_report_enum *rep_enum; 1126 unsigned int connect_mask = 0; 1127 bool has_ff000000 = false; 1128 struct lg_g15_data *g15; 1129 struct input_dev *input, *input_js; 1130 struct hid_report *rep; 1131 int ret, i, gkeys = 0; 1132 1133 hdev->quirks |= HID_QUIRK_INPUT_PER_APP; 1134 1135 ret = hid_parse(hdev); 1136 if (ret) 1137 return ret; 1138 1139 /* 1140 * Some models have multiple interfaces, we want the interface with 1141 * the f000.0000 application input report. 1142 */ 1143 rep_enum = &hdev->report_enum[HID_INPUT_REPORT]; 1144 list_for_each_entry(rep, &rep_enum->report_list, list) { 1145 if (rep->application == 0xff000000) 1146 has_ff000000 = true; 1147 } 1148 if (!has_ff000000) 1149 return hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1150 1151 g15 = devm_kzalloc(&hdev->dev, sizeof(*g15), GFP_KERNEL); 1152 if (!g15) 1153 return -ENOMEM; 1154 1155 mutex_init(&g15->mutex); 1156 1157 input = devm_input_allocate_device(&hdev->dev); 1158 if (!input) 1159 return -ENOMEM; 1160 1161 g15->hdev = hdev; 1162 g15->model = id->driver_data; 1163 g15->input = input; 1164 input_set_drvdata(input, hdev); 1165 hid_set_drvdata(hdev, (void *)g15); 1166 1167 switch (g15->model) { 1168 case LG_G13: 1169 /* 1170 * The G13 has an analog thumbstick with nearby buttons. Some 1171 * libraries and applications are known to ignore devices that 1172 * don't "look like" a joystick, and a device with two ABS axes 1173 * and 25+ macro keys would confuse them. 1174 * 1175 * Create an additional input device dedicated to appear as a 1176 * simplified joystick (two ABS axes, three BTN buttons). 1177 */ 1178 input_js = devm_input_allocate_device(&hdev->dev); 1179 if (!input_js) 1180 return -ENOMEM; 1181 g15->input_js = input_js; 1182 input_set_drvdata(input_js, hdev); 1183 1184 connect_mask = HID_CONNECT_HIDRAW; 1185 gkeys = 25; 1186 break; 1187 case LG_G15: 1188 INIT_WORK(&g15->work, lg_g15_leds_changed_work); 1189 /* 1190 * The G15 and G15 v2 use a separate usb-device (on a builtin 1191 * hub) which emulates a keyboard for the F1 - F12 emulation 1192 * on the G-keys, which we disable, rendering the emulated kbd 1193 * non-functional, so we do not let hid-input connect. 1194 */ 1195 connect_mask = HID_CONNECT_HIDRAW; 1196 gkeys_settings_output_report = 0x02; 1197 gkeys = 18; 1198 break; 1199 case LG_G15_V2: 1200 INIT_WORK(&g15->work, lg_g15_leds_changed_work); 1201 connect_mask = HID_CONNECT_HIDRAW; 1202 gkeys_settings_output_report = 0x02; 1203 gkeys = 6; 1204 break; 1205 case LG_G510: 1206 case LG_G510_USB_AUDIO: 1207 INIT_WORK(&g15->work, lg_g510_leds_sync_work); 1208 connect_mask = HID_CONNECT_HIDINPUT | HID_CONNECT_HIDRAW; 1209 gkeys_settings_feature_report = 0x01; 1210 gkeys = 18; 1211 break; 1212 case LG_Z10: 1213 connect_mask = HID_CONNECT_HIDRAW; 1214 break; 1215 } 1216 1217 ret = hid_hw_start(hdev, connect_mask); 1218 if (ret) 1219 return ret; 1220 1221 /* Tell the keyboard to stop sending F1-F12 + 1-6 for G1 - G18 */ 1222 if (gkeys_settings_output_report) { 1223 g15->transfer_buf[0] = gkeys_settings_output_report; 1224 memset(g15->transfer_buf + 1, 0, gkeys); 1225 /* 1226 * The kbd ignores our output report if we do not queue 1227 * an URB on the USB input endpoint first... 1228 */ 1229 ret = hid_hw_open(hdev); 1230 if (ret) 1231 goto error_hw_stop; 1232 ret = hid_hw_output_report(hdev, g15->transfer_buf, gkeys + 1); 1233 hid_hw_close(hdev); 1234 } 1235 1236 if (gkeys_settings_feature_report) { 1237 g15->transfer_buf[0] = gkeys_settings_feature_report; 1238 memset(g15->transfer_buf + 1, 0, gkeys); 1239 ret = hid_hw_raw_request(g15->hdev, 1240 gkeys_settings_feature_report, 1241 g15->transfer_buf, gkeys + 1, 1242 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 1243 } 1244 1245 if (ret < 0) { 1246 hid_err(hdev, "Error %d disabling keyboard emulation for the G-keys, falling back to generic hid-input driver\n", 1247 ret); 1248 hid_set_drvdata(hdev, NULL); 1249 return 0; 1250 } 1251 1252 /* Get initial brightness levels */ 1253 ret = lg_g15_get_initial_led_brightness(g15); 1254 if (ret) 1255 goto error_hw_stop; 1256 1257 if (g15->model == LG_Z10) { 1258 lg_g15_init_input_dev(hdev, g15->input, "Logitech Z-10 LCD Menu Keys"); 1259 ret = input_register_device(g15->input); 1260 if (ret) 1261 goto error_hw_stop; 1262 1263 ret = lg_g15_register_led(g15, 1, "z-10::lcd_backlight"); 1264 if (ret) 1265 goto error_hw_stop; 1266 1267 return 0; /* All done */ 1268 } else if (g15->model == LG_G13) { 1269 static char const * const g13_led_names[] = { 1270 /* Backlight is shared between LCD and keys. */ 1271 "g13:rgb:kbd_backlight", 1272 NULL, /* Keep in sync with led_type enum */ 1273 "g13:red:macro_preset_1", 1274 "g13:red:macro_preset_2", 1275 "g13:red:macro_preset_3", 1276 "g13:red:macro_record", 1277 }; 1278 lg_g13_init_input_dev(hdev, 1279 input, "Logitech G13 Gaming Keypad", 1280 input_js, "Logitech G13 Thumbstick"); 1281 ret = input_register_device(input); 1282 if (ret) 1283 goto error_hw_stop; 1284 ret = input_register_device(input_js); 1285 if (ret) 1286 goto error_hw_stop; 1287 1288 for (i = 0; i < ARRAY_SIZE(g13_led_names); ++i) { 1289 if (g13_led_names[i]) { 1290 ret = lg_g15_register_led(g15, i, g13_led_names[i]); 1291 if (ret) 1292 goto error_hw_stop; 1293 } 1294 } 1295 led_classdev_notify_brightness_hw_changed( 1296 &g15->leds[LG_G15_KBD_BRIGHTNESS].mcdev.led_cdev, 1297 g15->backlight_disabled 1298 ? 0 : g15->leds[LG_G15_KBD_BRIGHTNESS].brightness); 1299 return 0; 1300 } 1301 1302 /* Setup and register input device */ 1303 lg_g15_init_input_dev(hdev, input, "Logitech Gaming Keyboard Gaming Keys"); 1304 1305 /* G-keys */ 1306 for (i = 0; i < gkeys; i++) 1307 input_set_capability(input, EV_KEY, KEY_MACRO1 + i); 1308 1309 /* M1 - M3 and MR keys */ 1310 for (i = 0; i < 3; i++) 1311 input_set_capability(input, EV_KEY, KEY_MACRO_PRESET1 + i); 1312 input_set_capability(input, EV_KEY, KEY_MACRO_RECORD_START); 1313 1314 /* 1315 * On the G510 only report headphone and mic mute keys when *not* using 1316 * the builtin USB audio device. When the builtin audio is used these 1317 * keys directly toggle mute (and the LEDs) on/off. 1318 */ 1319 if (g15->model == LG_G510) { 1320 input_set_capability(input, EV_KEY, KEY_MUTE); 1321 /* Userspace expects F20 for micmute */ 1322 input_set_capability(input, EV_KEY, KEY_F20); 1323 } 1324 1325 ret = input_register_device(input); 1326 if (ret) 1327 goto error_hw_stop; 1328 1329 /* Register LED devices */ 1330 for (i = 0; i < LG_G15_LED_MAX; i++) { 1331 ret = lg_g15_register_led(g15, i, led_names[i]); 1332 if (ret) 1333 goto error_hw_stop; 1334 } 1335 1336 return 0; 1337 1338 error_hw_stop: 1339 hid_hw_stop(hdev); 1340 return ret; 1341 } 1342 1343 static const struct hid_device_id lg_g15_devices[] = { 1344 /* 1345 * The G13 is a macropad-only device with an LCD, LED backlighing, 1346 * and joystick. 1347 */ 1348 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1349 USB_DEVICE_ID_LOGITECH_G13), 1350 .driver_data = LG_G13 }, 1351 /* The G11 is a G15 without the LCD, treat it as a G15 */ 1352 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1353 USB_DEVICE_ID_LOGITECH_G11), 1354 .driver_data = LG_G15 }, 1355 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1356 USB_DEVICE_ID_LOGITECH_G15_LCD), 1357 .driver_data = LG_G15 }, 1358 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1359 USB_DEVICE_ID_LOGITECH_G15_V2_LCD), 1360 .driver_data = LG_G15_V2 }, 1361 /* G510 without a headset plugged in */ 1362 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1363 USB_DEVICE_ID_LOGITECH_G510), 1364 .driver_data = LG_G510 }, 1365 /* G510 with headset plugged in / with extra USB audio interface */ 1366 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1367 USB_DEVICE_ID_LOGITECH_G510_USB_AUDIO), 1368 .driver_data = LG_G510_USB_AUDIO }, 1369 /* Z-10 speakers */ 1370 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 1371 USB_DEVICE_ID_LOGITECH_Z_10_SPK), 1372 .driver_data = LG_Z10 }, 1373 { } 1374 }; 1375 MODULE_DEVICE_TABLE(hid, lg_g15_devices); 1376 1377 static struct hid_driver lg_g15_driver = { 1378 .name = "lg-g15", 1379 .id_table = lg_g15_devices, 1380 .raw_event = lg_g15_raw_event, 1381 .probe = lg_g15_probe, 1382 }; 1383 module_hid_driver(lg_g15_driver); 1384 1385 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 1386 MODULE_DESCRIPTION("HID driver for gaming keys on Logitech gaming keyboards"); 1387 MODULE_LICENSE("GPL"); 1388