1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * HID driver for Lenovo Legion Go series gamepads. 4 * 5 * Copyright (c) 2026 Derek J. Clark <derekjohn.clark@gmail.com> 6 * Copyright (c) 2026 Valve Corporation 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/array_size.h> 12 #include <linux/cleanup.h> 13 #include <linux/completion.h> 14 #include <linux/delay.h> 15 #include <linux/dev_printk.h> 16 #include <linux/device.h> 17 #include <linux/device/devres.h> 18 #include <linux/hid.h> 19 #include <linux/jiffies.h> 20 #include <linux/kstrtox.h> 21 #include <linux/led-class-multicolor.h> 22 #include <linux/mutex.h> 23 #include <linux/printk.h> 24 #include <linux/sysfs.h> 25 #include <linux/types.h> 26 #include <linux/unaligned.h> 27 #include <linux/usb.h> 28 #include <linux/workqueue.h> 29 #include <linux/workqueue_types.h> 30 31 #include "hid-ids.h" 32 33 #define GO_GP_INTF_IN 0x83 34 #define GO_OUTPUT_REPORT_ID 0x05 35 #define GO_GP_RESET_SUCCESS 0x01 36 #define GO_PACKET_SIZE 64 37 38 static struct hid_go_cfg { 39 struct delayed_work go_cfg_setup; 40 struct completion send_cmd_complete; 41 struct led_classdev *led_cdev; 42 struct hid_device *hdev; 43 struct mutex cfg_mutex; /*ensure single synchronous output report*/ 44 u8 fps_mode; 45 u8 gp_left_auto_sleep_time; 46 u8 gp_left_gyro_cal_status; 47 u8 gp_left_joy_cal_status; 48 u8 gp_left_notify_en; 49 u8 gp_left_rumble_mode; 50 u8 gp_left_trigg_cal_status; 51 u32 gp_left_version_firmware; 52 u8 gp_left_version_gen; 53 u32 gp_left_version_hardware; 54 u32 gp_left_version_product; 55 u32 gp_left_version_protocol; 56 u8 gp_mode; 57 u8 gp_right_auto_sleep_time; 58 u8 gp_right_gyro_cal_status; 59 u8 gp_right_joy_cal_status; 60 u8 gp_right_notify_en; 61 u8 gp_right_rumble_mode; 62 u8 gp_right_trigg_cal_status; 63 u32 gp_right_version_firmware; 64 u8 gp_right_version_gen; 65 u32 gp_right_version_hardware; 66 u32 gp_right_version_product; 67 u32 gp_right_version_protocol; 68 u8 gp_rumble_intensity; 69 u8 imu_left_bypass_en; 70 u8 imu_left_sensor_en; 71 u8 imu_right_bypass_en; 72 u8 imu_right_sensor_en; 73 u32 mcu_version_firmware; 74 u8 mcu_version_gen; 75 u32 mcu_version_hardware; 76 u32 mcu_version_product; 77 u32 mcu_version_protocol; 78 u32 mouse_dpi; 79 u8 os_mode; 80 u8 rgb_effect; 81 u8 rgb_en; 82 u8 rgb_mode; 83 u8 rgb_profile; 84 u8 rgb_speed; 85 u8 tp_en; 86 u8 tp_vibration_en; 87 u8 tp_vibration_intensity; 88 u32 tx_dongle_version_firmware; 89 u8 tx_dongle_version_gen; 90 u32 tx_dongle_version_hardware; 91 u32 tx_dongle_version_product; 92 u32 tx_dongle_version_protocol; 93 } drvdata; 94 95 struct go_cfg_attr { 96 u8 index; 97 }; 98 99 struct command_report { 100 u8 report_id; 101 u8 id; 102 u8 cmd; 103 u8 sub_cmd; 104 u8 device_type; 105 u8 data[59]; 106 } __packed; 107 108 enum command_id { 109 MCU_CONFIG_DATA = 0x00, 110 OS_MODE_DATA = 0x06, 111 GAMEPAD_DATA = 0x3c, 112 }; 113 114 enum mcu_command_index { 115 GET_VERSION_DATA = 0x02, 116 GET_FEATURE_STATUS, 117 SET_FEATURE_STATUS, 118 GET_MOTOR_CFG, 119 SET_MOTOR_CFG, 120 GET_DPI_CFG, 121 SET_DPI_CFG, 122 SET_TRIGGER_CFG = 0x0a, 123 SET_JOYSTICK_CFG = 0x0c, 124 SET_GYRO_CFG = 0x0e, 125 GET_RGB_CFG, 126 SET_RGB_CFG, 127 GET_DEVICE_STATUS = 0xa0, 128 129 }; 130 131 enum dev_type { 132 UNSPECIFIED, 133 USB_MCU, 134 TX_DONGLE, 135 LEFT_CONTROLLER, 136 RIGHT_CONTROLLER, 137 }; 138 139 enum enabled_status_index { 140 FEATURE_UNKNOWN, 141 FEATURE_ENABLED, 142 FEATURE_DISABLED, 143 }; 144 145 static const char *const enabled_status_text[] = { 146 [FEATURE_UNKNOWN] = "unknown", 147 [FEATURE_ENABLED] = "true", 148 [FEATURE_DISABLED] = "false", 149 }; 150 151 enum version_data_index { 152 PRODUCT_VERSION = 0x02, 153 PROTOCOL_VERSION, 154 FIRMWARE_VERSION, 155 HARDWARE_VERSION, 156 HARDWARE_GENERATION, 157 }; 158 159 enum feature_status_index { 160 FEATURE_RESET_GAMEPAD = 0x02, 161 FEATURE_IMU_BYPASS, 162 FEATURE_IMU_ENABLE = 0x05, 163 FEATURE_TOUCHPAD_ENABLE = 0x07, 164 FEATURE_LIGHT_ENABLE, 165 FEATURE_AUTO_SLEEP_TIME, 166 FEATURE_FPS_SWITCH_STATUS = 0x0b, 167 FEATURE_GAMEPAD_MODE = 0x0e, 168 }; 169 170 #define FEATURE_OS_MODE 0x69 171 172 enum fps_switch_status_index { 173 FPS_STATUS_UNKNOWN, 174 GAMEPAD, 175 FPS, 176 }; 177 178 static const char *const fps_switch_text[] = { 179 [FPS_STATUS_UNKNOWN] = "unknown", 180 [GAMEPAD] = "gamepad", 181 [FPS] = "fps", 182 }; 183 184 enum gamepad_mode_index { 185 GAMEPAD_MODE_UNKNOWN, 186 XINPUT, 187 DINPUT, 188 }; 189 190 static const char *const gamepad_mode_text[] = { 191 [GAMEPAD_MODE_UNKNOWN] = "unknown", 192 [XINPUT] = "xinput", 193 [DINPUT] = "dinput", 194 }; 195 196 enum motor_cfg_index { 197 MOTOR_CFG_ALL = 0x01, 198 MOTOR_INTENSITY, 199 VIBRATION_NOTIFY_ENABLE, 200 RUMBLE_MODE, 201 TP_VIBRATION_ENABLE, 202 TP_VIBRATION_INTENSITY, 203 }; 204 205 enum intensity_index { 206 INTENSITY_UNKNOWN, 207 INTENSITY_OFF, 208 INTENSITY_LOW, 209 INTENSITY_MEDIUM, 210 INTENSITY_HIGH, 211 }; 212 213 static const char *const intensity_text[] = { 214 [INTENSITY_UNKNOWN] = "unknown", 215 [INTENSITY_OFF] = "off", 216 [INTENSITY_LOW] = "low", 217 [INTENSITY_MEDIUM] = "medium", 218 [INTENSITY_HIGH] = "high", 219 }; 220 221 enum rumble_mode_index { 222 RUMBLE_MODE_UNKNOWN, 223 RUMBLE_MODE_FPS, 224 RUMBLE_MODE_RACE, 225 RUMBLE_MODE_AVERAGE, 226 RUMBLE_MODE_SPG, 227 RUMBLE_MODE_RPG, 228 }; 229 230 static const char *const rumble_mode_text[] = { 231 [RUMBLE_MODE_UNKNOWN] = "unknown", 232 [RUMBLE_MODE_FPS] = "fps", 233 [RUMBLE_MODE_RACE] = "racing", 234 [RUMBLE_MODE_AVERAGE] = "standard", 235 [RUMBLE_MODE_SPG] = "spg", 236 [RUMBLE_MODE_RPG] = "rpg", 237 }; 238 239 #define FPS_MODE_DPI 0x02 240 #define TRIGGER_CALIBRATE 0x04 241 #define JOYSTICK_CALIBRATE 0x04 242 #define GYRO_CALIBRATE 0x06 243 244 enum cal_device_type { 245 CALDEV_GYROSCOPE = 0x01, 246 CALDEV_JOYSTICK, 247 CALDEV_TRIGGER, 248 CALDEV_JOY_TRIGGER, 249 }; 250 251 enum cal_enable { 252 CAL_UNKNOWN, 253 CAL_START, 254 CAL_STOP, 255 }; 256 257 static const char *const cal_enabled_text[] = { 258 [CAL_UNKNOWN] = "unknown", 259 [CAL_START] = "start", 260 [CAL_STOP] = "stop", 261 }; 262 263 enum cal_status_index { 264 CAL_STAT_UNKNOWN, 265 CAL_STAT_SUCCESS, 266 CAL_STAT_FAILURE, 267 }; 268 269 static const char *const cal_status_text[] = { 270 [CAL_STAT_UNKNOWN] = "unknown", 271 [CAL_STAT_SUCCESS] = "success", 272 [CAL_STAT_FAILURE] = "failure", 273 }; 274 275 enum rgb_config_index { 276 LIGHT_CFG_ALL = 0x01, 277 LIGHT_MODE_SEL, 278 LIGHT_PROFILE_SEL, 279 USR_LIGHT_PROFILE_1, 280 USR_LIGHT_PROFILE_2, 281 USR_LIGHT_PROFILE_3, 282 }; 283 284 enum rgb_mode_index { 285 RGB_MODE_UNKNOWN, 286 RGB_MODE_DYNAMIC, 287 RGB_MODE_CUSTOM, 288 }; 289 290 static const char *const rgb_mode_text[] = { 291 [RGB_MODE_UNKNOWN] = "unknown", 292 [RGB_MODE_DYNAMIC] = "dynamic", 293 [RGB_MODE_CUSTOM] = "custom", 294 }; 295 296 enum rgb_effect_index { 297 RGB_EFFECT_MONO, 298 RGB_EFFECT_BREATHE, 299 RGB_EFFECT_CHROMA, 300 RGB_EFFECT_RAINBOW, 301 }; 302 303 static const char *const rgb_effect_text[] = { 304 [RGB_EFFECT_MONO] = "monocolor", 305 [RGB_EFFECT_BREATHE] = "breathe", 306 [RGB_EFFECT_CHROMA] = "chroma", 307 [RGB_EFFECT_RAINBOW] = "rainbow", 308 }; 309 310 enum device_status_index { 311 GET_CAL_STATUS = 0x02, 312 GET_UPGRADE_STATUS, 313 GET_MACRO_REC_STATUS, 314 GET_HOTKEY_TRIGG_STATUS, 315 }; 316 317 enum os_mode_cfg_index { 318 SET_OS_MODE = 0x09, 319 GET_OS_MODE, 320 }; 321 322 enum os_mode_type_index { 323 OS_UNKNOWN, 324 WINDOWS, 325 LINUX, 326 }; 327 328 static const char *const os_mode_text[] = { 329 [OS_UNKNOWN] = "unknown", 330 [WINDOWS] = "windows", 331 [LINUX] = "linux", 332 }; 333 334 static int hid_go_version_event(struct command_report *cmd_rep) 335 { 336 switch (cmd_rep->sub_cmd) { 337 case PRODUCT_VERSION: 338 switch (cmd_rep->device_type) { 339 case USB_MCU: 340 drvdata.mcu_version_product = 341 get_unaligned_be32(cmd_rep->data); 342 return 0; 343 case TX_DONGLE: 344 drvdata.tx_dongle_version_product = 345 get_unaligned_be32(cmd_rep->data); 346 return 0; 347 case LEFT_CONTROLLER: 348 drvdata.gp_left_version_product = 349 get_unaligned_be32(cmd_rep->data); 350 return 0; 351 case RIGHT_CONTROLLER: 352 drvdata.gp_right_version_product = 353 get_unaligned_be32(cmd_rep->data); 354 return 0; 355 default: 356 return -EINVAL; 357 } 358 case PROTOCOL_VERSION: 359 switch (cmd_rep->device_type) { 360 case USB_MCU: 361 drvdata.mcu_version_protocol = 362 get_unaligned_be32(cmd_rep->data); 363 return 0; 364 case TX_DONGLE: 365 drvdata.tx_dongle_version_protocol = 366 get_unaligned_be32(cmd_rep->data); 367 return 0; 368 case LEFT_CONTROLLER: 369 drvdata.gp_left_version_protocol = 370 get_unaligned_be32(cmd_rep->data); 371 return 0; 372 case RIGHT_CONTROLLER: 373 drvdata.gp_right_version_protocol = 374 get_unaligned_be32(cmd_rep->data); 375 return 0; 376 default: 377 return -EINVAL; 378 } 379 case FIRMWARE_VERSION: 380 switch (cmd_rep->device_type) { 381 case USB_MCU: 382 drvdata.mcu_version_firmware = 383 get_unaligned_be32(cmd_rep->data); 384 return 0; 385 case TX_DONGLE: 386 drvdata.tx_dongle_version_firmware = 387 get_unaligned_be32(cmd_rep->data); 388 return 0; 389 case LEFT_CONTROLLER: 390 drvdata.gp_left_version_firmware = 391 get_unaligned_be32(cmd_rep->data); 392 return 0; 393 case RIGHT_CONTROLLER: 394 drvdata.gp_right_version_firmware = 395 get_unaligned_be32(cmd_rep->data); 396 return 0; 397 default: 398 return -EINVAL; 399 } 400 case HARDWARE_VERSION: 401 switch (cmd_rep->device_type) { 402 case USB_MCU: 403 drvdata.mcu_version_hardware = 404 get_unaligned_be32(cmd_rep->data); 405 return 0; 406 case TX_DONGLE: 407 drvdata.tx_dongle_version_hardware = 408 get_unaligned_be32(cmd_rep->data); 409 return 0; 410 case LEFT_CONTROLLER: 411 drvdata.gp_left_version_hardware = 412 get_unaligned_be32(cmd_rep->data); 413 return 0; 414 case RIGHT_CONTROLLER: 415 drvdata.gp_right_version_hardware = 416 get_unaligned_be32(cmd_rep->data); 417 return 0; 418 default: 419 return -EINVAL; 420 } 421 case HARDWARE_GENERATION: 422 switch (cmd_rep->device_type) { 423 case USB_MCU: 424 drvdata.mcu_version_gen = cmd_rep->data[0]; 425 return 0; 426 case TX_DONGLE: 427 drvdata.tx_dongle_version_gen = cmd_rep->data[0]; 428 return 0; 429 case LEFT_CONTROLLER: 430 drvdata.gp_left_version_gen = cmd_rep->data[0]; 431 return 0; 432 case RIGHT_CONTROLLER: 433 drvdata.gp_right_version_gen = cmd_rep->data[0]; 434 return 0; 435 default: 436 return -EINVAL; 437 } 438 default: 439 return -EINVAL; 440 } 441 } 442 443 static int hid_go_feature_status_event(struct command_report *cmd_rep) 444 { 445 switch (cmd_rep->sub_cmd) { 446 case FEATURE_RESET_GAMEPAD: 447 return 0; 448 case FEATURE_IMU_ENABLE: 449 switch (cmd_rep->device_type) { 450 case LEFT_CONTROLLER: 451 drvdata.imu_left_sensor_en = cmd_rep->data[0]; 452 return 0; 453 case RIGHT_CONTROLLER: 454 drvdata.imu_right_sensor_en = cmd_rep->data[0]; 455 return 0; 456 default: 457 return -EINVAL; 458 } 459 case FEATURE_IMU_BYPASS: 460 switch (cmd_rep->device_type) { 461 case LEFT_CONTROLLER: 462 drvdata.imu_left_bypass_en = cmd_rep->data[0]; 463 return 0; 464 case RIGHT_CONTROLLER: 465 drvdata.imu_right_bypass_en = cmd_rep->data[0]; 466 return 0; 467 default: 468 return -EINVAL; 469 } 470 break; 471 case FEATURE_LIGHT_ENABLE: 472 drvdata.rgb_en = cmd_rep->data[0]; 473 return 0; 474 case FEATURE_AUTO_SLEEP_TIME: 475 switch (cmd_rep->device_type) { 476 case LEFT_CONTROLLER: 477 drvdata.gp_left_auto_sleep_time = cmd_rep->data[0]; 478 return 0; 479 case RIGHT_CONTROLLER: 480 drvdata.gp_right_auto_sleep_time = cmd_rep->data[0]; 481 return 0; 482 default: 483 return -EINVAL; 484 } 485 break; 486 case FEATURE_TOUCHPAD_ENABLE: 487 drvdata.tp_en = cmd_rep->data[0]; 488 return 0; 489 case FEATURE_GAMEPAD_MODE: 490 drvdata.gp_mode = cmd_rep->data[0]; 491 return 0; 492 case FEATURE_FPS_SWITCH_STATUS: 493 drvdata.fps_mode = cmd_rep->data[0]; 494 return 0; 495 default: 496 return -EINVAL; 497 } 498 } 499 500 static int hid_go_motor_event(struct command_report *cmd_rep) 501 { 502 switch (cmd_rep->sub_cmd) { 503 case MOTOR_CFG_ALL: 504 return -EINVAL; 505 case MOTOR_INTENSITY: 506 drvdata.gp_rumble_intensity = cmd_rep->data[0]; 507 return 0; 508 case VIBRATION_NOTIFY_ENABLE: 509 switch (cmd_rep->device_type) { 510 case LEFT_CONTROLLER: 511 drvdata.gp_left_notify_en = cmd_rep->data[0]; 512 return 0; 513 case RIGHT_CONTROLLER: 514 drvdata.gp_right_notify_en = cmd_rep->data[0]; 515 return 0; 516 default: 517 return -EINVAL; 518 } 519 break; 520 case RUMBLE_MODE: 521 switch (cmd_rep->device_type) { 522 case LEFT_CONTROLLER: 523 drvdata.gp_left_rumble_mode = cmd_rep->data[0]; 524 return 0; 525 case RIGHT_CONTROLLER: 526 drvdata.gp_right_rumble_mode = cmd_rep->data[0]; 527 return 0; 528 default: 529 return -EINVAL; 530 } 531 case TP_VIBRATION_ENABLE: 532 drvdata.tp_vibration_en = cmd_rep->data[0]; 533 return 0; 534 case TP_VIBRATION_INTENSITY: 535 drvdata.tp_vibration_intensity = cmd_rep->data[0]; 536 return 0; 537 } 538 return -EINVAL; 539 } 540 541 static int hid_go_fps_dpi_event(struct command_report *cmd_rep) 542 { 543 if (cmd_rep->sub_cmd != FPS_MODE_DPI) 544 return -EINVAL; 545 546 drvdata.mouse_dpi = get_unaligned_le32(cmd_rep->data); 547 548 return 0; 549 } 550 551 static int hid_go_light_event(struct command_report *cmd_rep) 552 { 553 struct led_classdev_mc *mc_cdev; 554 555 switch (cmd_rep->sub_cmd) { 556 case LIGHT_MODE_SEL: 557 drvdata.rgb_mode = cmd_rep->data[0]; 558 return 0; 559 case LIGHT_PROFILE_SEL: 560 drvdata.rgb_profile = cmd_rep->data[0]; 561 return 0; 562 case USR_LIGHT_PROFILE_1: 563 case USR_LIGHT_PROFILE_2: 564 case USR_LIGHT_PROFILE_3: 565 mc_cdev = lcdev_to_mccdev(drvdata.led_cdev); 566 drvdata.rgb_effect = cmd_rep->data[0]; 567 mc_cdev->subled_info[0].intensity = cmd_rep->data[1]; 568 mc_cdev->subled_info[1].intensity = cmd_rep->data[2]; 569 mc_cdev->subled_info[2].intensity = cmd_rep->data[3]; 570 drvdata.led_cdev->brightness = cmd_rep->data[4]; 571 drvdata.rgb_speed = 100 - cmd_rep->data[5]; 572 return 0; 573 default: 574 return -EINVAL; 575 } 576 } 577 578 static int hid_go_device_status_event(struct command_report *cmd_rep) 579 { 580 switch (cmd_rep->device_type) { 581 case LEFT_CONTROLLER: 582 switch (cmd_rep->data[0]) { 583 case CALDEV_GYROSCOPE: 584 drvdata.gp_left_gyro_cal_status = cmd_rep->data[1]; 585 return 0; 586 case CALDEV_JOYSTICK: 587 drvdata.gp_left_joy_cal_status = cmd_rep->data[1]; 588 return 0; 589 case CALDEV_TRIGGER: 590 drvdata.gp_left_trigg_cal_status = cmd_rep->data[1]; 591 return 0; 592 default: 593 return -EINVAL; 594 } 595 break; 596 case RIGHT_CONTROLLER: 597 switch (cmd_rep->data[0]) { 598 case CALDEV_GYROSCOPE: 599 drvdata.gp_right_gyro_cal_status = cmd_rep->data[1]; 600 return 0; 601 case CALDEV_JOYSTICK: 602 drvdata.gp_right_joy_cal_status = cmd_rep->data[1]; 603 return 0; 604 case CALDEV_TRIGGER: 605 drvdata.gp_right_trigg_cal_status = cmd_rep->data[1]; 606 return 0; 607 default: 608 return -EINVAL; 609 } 610 break; 611 default: 612 return -EINVAL; 613 } 614 } 615 616 static int hid_go_os_mode_cfg_event(struct command_report *cmd_rep) 617 { 618 switch (cmd_rep->sub_cmd) { 619 case SET_OS_MODE: 620 if (cmd_rep->data[0] != 1) 621 return -EIO; 622 return 0; 623 case GET_OS_MODE: 624 drvdata.os_mode = cmd_rep->data[0]; 625 return 0; 626 default: 627 return -EINVAL; 628 } 629 } 630 631 static int hid_go_set_event_return(struct command_report *cmd_rep) 632 { 633 if (cmd_rep->data[0] != 0) 634 return -EIO; 635 636 return 0; 637 } 638 639 static int get_endpoint_address(struct hid_device *hdev) 640 { 641 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 642 struct usb_host_endpoint *ep; 643 644 ep = intf->cur_altsetting->endpoint; 645 if (!ep) 646 return -ENODEV; 647 648 return ep->desc.bEndpointAddress; 649 } 650 651 static int hid_go_raw_event(struct hid_device *hdev, struct hid_report *report, 652 u8 *data, int size) 653 { 654 struct command_report *cmd_rep; 655 int ep, ret; 656 657 if (size != GO_PACKET_SIZE) 658 goto passthrough; 659 660 ep = get_endpoint_address(hdev); 661 if (ep != GO_GP_INTF_IN) 662 goto passthrough; 663 664 cmd_rep = (struct command_report *)data; 665 666 switch (cmd_rep->id) { 667 case MCU_CONFIG_DATA: 668 switch (cmd_rep->cmd) { 669 case GET_VERSION_DATA: 670 ret = hid_go_version_event(cmd_rep); 671 break; 672 case GET_FEATURE_STATUS: 673 ret = hid_go_feature_status_event(cmd_rep); 674 break; 675 case GET_MOTOR_CFG: 676 ret = hid_go_motor_event(cmd_rep); 677 break; 678 case GET_DPI_CFG: 679 ret = hid_go_fps_dpi_event(cmd_rep); 680 break; 681 case GET_RGB_CFG: 682 ret = hid_go_light_event(cmd_rep); 683 break; 684 case GET_DEVICE_STATUS: 685 ret = hid_go_device_status_event(cmd_rep); 686 break; 687 case SET_FEATURE_STATUS: 688 case SET_MOTOR_CFG: 689 case SET_DPI_CFG: 690 case SET_RGB_CFG: 691 case SET_TRIGGER_CFG: 692 case SET_JOYSTICK_CFG: 693 case SET_GYRO_CFG: 694 ret = hid_go_set_event_return(cmd_rep); 695 break; 696 default: 697 ret = -EINVAL; 698 break; 699 } 700 break; 701 case OS_MODE_DATA: 702 ret = hid_go_os_mode_cfg_event(cmd_rep); 703 break; 704 default: 705 goto passthrough; 706 } 707 dev_dbg(&hdev->dev, "Rx data as raw input report: [%*ph]\n", 708 GO_PACKET_SIZE, data); 709 710 complete(&drvdata.send_cmd_complete); 711 return ret; 712 713 passthrough: 714 /* Forward other HID reports so they generate events */ 715 hid_input_report(hdev, HID_INPUT_REPORT, data, size, 1); 716 return 0; 717 } 718 719 static int mcu_property_out(struct hid_device *hdev, u8 id, u8 command, 720 u8 index, enum dev_type device, u8 *data, size_t len) 721 { 722 unsigned char *dmabuf __free(kfree) = NULL; 723 u8 header[] = { GO_OUTPUT_REPORT_ID, id, command, index, device }; 724 size_t header_size = ARRAY_SIZE(header); 725 int timeout = 50; 726 int ret; 727 728 if (header_size + len > GO_PACKET_SIZE) 729 return -EINVAL; 730 731 guard(mutex)(&drvdata.cfg_mutex); 732 /* We can't use a devm_alloc reusable buffer without side effects during suspend */ 733 dmabuf = kzalloc(GO_PACKET_SIZE, GFP_KERNEL); 734 if (!dmabuf) 735 return -ENOMEM; 736 737 memcpy(dmabuf, header, header_size); 738 memcpy(dmabuf + header_size, data, len); 739 740 dev_dbg(&hdev->dev, "Send data as raw output report: [%*ph]\n", 741 GO_PACKET_SIZE, dmabuf); 742 743 ret = hid_hw_output_report(hdev, dmabuf, GO_PACKET_SIZE); 744 if (ret < 0) 745 return ret; 746 747 ret = ret == GO_PACKET_SIZE ? 0 : -EINVAL; 748 if (ret) 749 return ret; 750 751 ret = wait_for_completion_interruptible_timeout(&drvdata.send_cmd_complete, 752 msecs_to_jiffies(timeout)); 753 754 if (ret == 0) /* timeout occurred */ 755 ret = -EBUSY; 756 757 reinit_completion(&drvdata.send_cmd_complete); 758 return 0; 759 } 760 761 static ssize_t version_show(struct device *dev, struct device_attribute *attr, 762 char *buf, enum version_data_index index, 763 enum dev_type device_type) 764 { 765 ssize_t count = 0; 766 int ret; 767 768 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 769 index, device_type, NULL, 0); 770 if (ret) 771 return ret; 772 773 switch (index) { 774 case PRODUCT_VERSION: 775 switch (device_type) { 776 case USB_MCU: 777 count = sysfs_emit(buf, "%x\n", 778 drvdata.mcu_version_product); 779 break; 780 case TX_DONGLE: 781 count = sysfs_emit(buf, "%x\n", 782 drvdata.tx_dongle_version_product); 783 break; 784 case LEFT_CONTROLLER: 785 count = sysfs_emit(buf, "%x\n", 786 drvdata.gp_left_version_product); 787 break; 788 case RIGHT_CONTROLLER: 789 count = sysfs_emit(buf, "%x\n", 790 drvdata.gp_right_version_product); 791 break; 792 default: 793 return -EINVAL; 794 } 795 break; 796 case PROTOCOL_VERSION: 797 switch (device_type) { 798 case USB_MCU: 799 count = sysfs_emit(buf, "%x\n", 800 drvdata.mcu_version_protocol); 801 break; 802 case TX_DONGLE: 803 count = sysfs_emit(buf, "%x\n", 804 drvdata.tx_dongle_version_protocol); 805 break; 806 case LEFT_CONTROLLER: 807 count = sysfs_emit(buf, "%x\n", 808 drvdata.gp_left_version_protocol); 809 break; 810 case RIGHT_CONTROLLER: 811 count = sysfs_emit(buf, "%x\n", 812 drvdata.gp_right_version_protocol); 813 break; 814 default: 815 return -EINVAL; 816 } 817 break; 818 case FIRMWARE_VERSION: 819 switch (device_type) { 820 case USB_MCU: 821 count = sysfs_emit(buf, "%x\n", 822 drvdata.mcu_version_firmware); 823 break; 824 case TX_DONGLE: 825 count = sysfs_emit(buf, "%x\n", 826 drvdata.tx_dongle_version_firmware); 827 break; 828 case LEFT_CONTROLLER: 829 count = sysfs_emit(buf, "%x\n", 830 drvdata.gp_left_version_firmware); 831 break; 832 case RIGHT_CONTROLLER: 833 count = sysfs_emit(buf, "%x\n", 834 drvdata.gp_right_version_firmware); 835 break; 836 default: 837 return -EINVAL; 838 } 839 break; 840 case HARDWARE_VERSION: 841 switch (device_type) { 842 case USB_MCU: 843 count = sysfs_emit(buf, "%x\n", 844 drvdata.mcu_version_hardware); 845 break; 846 case TX_DONGLE: 847 count = sysfs_emit(buf, "%x\n", 848 drvdata.tx_dongle_version_hardware); 849 break; 850 case LEFT_CONTROLLER: 851 count = sysfs_emit(buf, "%x\n", 852 drvdata.gp_left_version_hardware); 853 break; 854 case RIGHT_CONTROLLER: 855 count = sysfs_emit(buf, "%x\n", 856 drvdata.gp_right_version_hardware); 857 break; 858 default: 859 return -EINVAL; 860 } 861 break; 862 case HARDWARE_GENERATION: 863 switch (device_type) { 864 case USB_MCU: 865 count = sysfs_emit(buf, "%x\n", 866 drvdata.mcu_version_gen); 867 break; 868 case TX_DONGLE: 869 count = sysfs_emit(buf, "%x\n", 870 drvdata.tx_dongle_version_gen); 871 break; 872 case LEFT_CONTROLLER: 873 count = sysfs_emit(buf, "%x\n", 874 drvdata.gp_left_version_gen); 875 break; 876 case RIGHT_CONTROLLER: 877 count = sysfs_emit(buf, "%x\n", 878 drvdata.gp_right_version_gen); 879 break; 880 default: 881 return -EINVAL; 882 } 883 break; 884 } 885 886 return count; 887 } 888 889 static ssize_t feature_status_store(struct device *dev, 890 struct device_attribute *attr, 891 const char *buf, size_t count, 892 enum feature_status_index index, 893 enum dev_type device_type) 894 { 895 size_t size = 1; 896 u8 val = 0; 897 int ret; 898 899 switch (index) { 900 case FEATURE_IMU_ENABLE: 901 case FEATURE_IMU_BYPASS: 902 case FEATURE_LIGHT_ENABLE: 903 case FEATURE_TOUCHPAD_ENABLE: 904 ret = sysfs_match_string(enabled_status_text, buf); 905 val = ret; 906 break; 907 case FEATURE_AUTO_SLEEP_TIME: 908 ret = kstrtou8(buf, 10, &val); 909 break; 910 case FEATURE_RESET_GAMEPAD: 911 ret = kstrtou8(buf, 10, &val); 912 if (val != GO_GP_RESET_SUCCESS) 913 return -EINVAL; 914 break; 915 case FEATURE_FPS_SWITCH_STATUS: 916 ret = sysfs_match_string(fps_switch_text, buf); 917 val = ret; 918 break; 919 case FEATURE_GAMEPAD_MODE: 920 ret = sysfs_match_string(gamepad_mode_text, buf); 921 val = ret; 922 break; 923 default: 924 return -EINVAL; 925 } 926 927 if (ret < 0) 928 return ret; 929 930 if (!val) 931 size = 0; 932 933 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, 934 SET_FEATURE_STATUS, index, device_type, &val, 935 size); 936 if (ret < 0) 937 return ret; 938 939 return count; 940 } 941 942 static ssize_t feature_status_show(struct device *dev, 943 struct device_attribute *attr, char *buf, 944 enum feature_status_index index, 945 enum dev_type device_type) 946 { 947 ssize_t count = 0; 948 int ret; 949 u8 i; 950 951 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, 952 GET_FEATURE_STATUS, index, device_type, NULL, 0); 953 if (ret) 954 return ret; 955 956 switch (index) { 957 case FEATURE_IMU_ENABLE: 958 switch (device_type) { 959 case LEFT_CONTROLLER: 960 i = drvdata.imu_left_sensor_en; 961 break; 962 case RIGHT_CONTROLLER: 963 i = drvdata.imu_right_sensor_en; 964 break; 965 default: 966 return -EINVAL; 967 } 968 if (i >= ARRAY_SIZE(enabled_status_text)) 969 return -EINVAL; 970 971 count = sysfs_emit(buf, "%s\n", enabled_status_text[i]); 972 break; 973 case FEATURE_IMU_BYPASS: 974 switch (device_type) { 975 case LEFT_CONTROLLER: 976 i = drvdata.imu_left_bypass_en; 977 break; 978 case RIGHT_CONTROLLER: 979 i = drvdata.imu_right_bypass_en; 980 break; 981 default: 982 return -EINVAL; 983 } 984 if (i >= ARRAY_SIZE(enabled_status_text)) 985 return -EINVAL; 986 987 count = sysfs_emit(buf, "%s\n", enabled_status_text[i]); 988 break; 989 case FEATURE_LIGHT_ENABLE: 990 i = drvdata.rgb_en; 991 if (i >= ARRAY_SIZE(enabled_status_text)) 992 return -EINVAL; 993 994 count = sysfs_emit(buf, "%s\n", enabled_status_text[i]); 995 break; 996 case FEATURE_TOUCHPAD_ENABLE: 997 i = drvdata.tp_en; 998 if (i >= ARRAY_SIZE(enabled_status_text)) 999 return -EINVAL; 1000 1001 count = sysfs_emit(buf, "%s\n", enabled_status_text[i]); 1002 break; 1003 case FEATURE_AUTO_SLEEP_TIME: 1004 switch (device_type) { 1005 case LEFT_CONTROLLER: 1006 i = drvdata.gp_left_auto_sleep_time; 1007 break; 1008 case RIGHT_CONTROLLER: 1009 i = drvdata.gp_right_auto_sleep_time; 1010 break; 1011 default: 1012 return -EINVAL; 1013 } 1014 count = sysfs_emit(buf, "%u\n", i); 1015 break; 1016 case FEATURE_FPS_SWITCH_STATUS: 1017 i = drvdata.fps_mode; 1018 if (i >= ARRAY_SIZE(fps_switch_text)) 1019 return -EINVAL; 1020 1021 count = sysfs_emit(buf, "%s\n", fps_switch_text[i]); 1022 break; 1023 case FEATURE_GAMEPAD_MODE: 1024 i = drvdata.gp_mode; 1025 if (i >= ARRAY_SIZE(gamepad_mode_text)) 1026 return -EINVAL; 1027 1028 count = sysfs_emit(buf, "%s\n", gamepad_mode_text[i]); 1029 break; 1030 default: 1031 return -EINVAL; 1032 } 1033 1034 return count; 1035 } 1036 1037 static ssize_t feature_status_options(struct device *dev, 1038 struct device_attribute *attr, char *buf, 1039 enum feature_status_index index) 1040 { 1041 ssize_t count = 0; 1042 unsigned int i; 1043 1044 switch (index) { 1045 case FEATURE_IMU_ENABLE: 1046 case FEATURE_IMU_BYPASS: 1047 case FEATURE_LIGHT_ENABLE: 1048 case FEATURE_TOUCHPAD_ENABLE: 1049 for (i = 1; i < ARRAY_SIZE(enabled_status_text); i++) { 1050 count += sysfs_emit_at(buf, count, "%s ", 1051 enabled_status_text[i]); 1052 } 1053 break; 1054 case FEATURE_AUTO_SLEEP_TIME: 1055 return sysfs_emit(buf, "0-255\n"); 1056 case FEATURE_FPS_SWITCH_STATUS: 1057 for (i = 1; i < ARRAY_SIZE(fps_switch_text); i++) { 1058 count += sysfs_emit_at(buf, count, "%s ", 1059 fps_switch_text[i]); 1060 } 1061 break; 1062 case FEATURE_GAMEPAD_MODE: 1063 for (i = 1; i < ARRAY_SIZE(gamepad_mode_text); i++) { 1064 count += sysfs_emit_at(buf, count, "%s ", 1065 gamepad_mode_text[i]); 1066 } 1067 break; 1068 default: 1069 return -EINVAL; 1070 } 1071 1072 if (count) 1073 buf[count - 1] = '\n'; 1074 1075 return count; 1076 } 1077 1078 static ssize_t motor_config_store(struct device *dev, 1079 struct device_attribute *attr, 1080 const char *buf, size_t count, 1081 enum motor_cfg_index index, 1082 enum dev_type device_type) 1083 { 1084 size_t size = 1; 1085 u8 val = 0; 1086 int ret; 1087 1088 switch (index) { 1089 case MOTOR_CFG_ALL: 1090 return -EINVAL; 1091 case MOTOR_INTENSITY: 1092 ret = sysfs_match_string(intensity_text, buf); 1093 val = ret; 1094 break; 1095 case VIBRATION_NOTIFY_ENABLE: 1096 ret = sysfs_match_string(enabled_status_text, buf); 1097 val = ret; 1098 break; 1099 case RUMBLE_MODE: 1100 ret = sysfs_match_string(rumble_mode_text, buf); 1101 val = ret; 1102 break; 1103 case TP_VIBRATION_ENABLE: 1104 ret = sysfs_match_string(enabled_status_text, buf); 1105 val = ret; 1106 break; 1107 case TP_VIBRATION_INTENSITY: 1108 ret = sysfs_match_string(intensity_text, buf); 1109 val = ret; 1110 break; 1111 } 1112 1113 if (ret < 0) 1114 return ret; 1115 1116 if (!val) 1117 size = 0; 1118 1119 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, SET_MOTOR_CFG, 1120 index, device_type, &val, size); 1121 if (ret < 0) 1122 return ret; 1123 1124 return count; 1125 } 1126 1127 static ssize_t motor_config_show(struct device *dev, 1128 struct device_attribute *attr, char *buf, 1129 enum motor_cfg_index index, 1130 enum dev_type device_type) 1131 { 1132 ssize_t count = 0; 1133 int ret; 1134 u8 i; 1135 1136 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_MOTOR_CFG, 1137 index, device_type, NULL, 0); 1138 if (ret) 1139 return ret; 1140 1141 switch (index) { 1142 case MOTOR_CFG_ALL: 1143 return -EINVAL; 1144 case MOTOR_INTENSITY: 1145 i = drvdata.gp_rumble_intensity; 1146 if (i >= ARRAY_SIZE(intensity_text)) 1147 return -EINVAL; 1148 1149 count = sysfs_emit(buf, "%s\n", intensity_text[i]); 1150 break; 1151 case VIBRATION_NOTIFY_ENABLE: 1152 switch (device_type) { 1153 case LEFT_CONTROLLER: 1154 i = drvdata.gp_left_notify_en; 1155 break; 1156 case RIGHT_CONTROLLER: 1157 i = drvdata.gp_right_notify_en; 1158 break; 1159 default: 1160 return -EINVAL; 1161 } 1162 if (i >= ARRAY_SIZE(enabled_status_text)) 1163 return -EINVAL; 1164 1165 count = sysfs_emit(buf, "%s\n", enabled_status_text[i]); 1166 break; 1167 case RUMBLE_MODE: 1168 switch (device_type) { 1169 case LEFT_CONTROLLER: 1170 i = drvdata.gp_left_rumble_mode; 1171 break; 1172 case RIGHT_CONTROLLER: 1173 i = drvdata.gp_right_rumble_mode; 1174 break; 1175 default: 1176 return -EINVAL; 1177 } 1178 if (i >= ARRAY_SIZE(rumble_mode_text)) 1179 return -EINVAL; 1180 1181 count = sysfs_emit(buf, "%s\n", rumble_mode_text[i]); 1182 break; 1183 case TP_VIBRATION_ENABLE: 1184 i = drvdata.tp_vibration_en; 1185 if (i >= ARRAY_SIZE(enabled_status_text)) 1186 return -EINVAL; 1187 1188 count = sysfs_emit(buf, "%s\n", enabled_status_text[i]); 1189 break; 1190 case TP_VIBRATION_INTENSITY: 1191 i = drvdata.tp_vibration_intensity; 1192 if (i >= ARRAY_SIZE(intensity_text)) 1193 return -EINVAL; 1194 1195 count = sysfs_emit(buf, "%s\n", intensity_text[i]); 1196 break; 1197 } 1198 1199 return count; 1200 } 1201 1202 static ssize_t motor_config_options(struct device *dev, 1203 struct device_attribute *attr, char *buf, 1204 enum motor_cfg_index index) 1205 { 1206 ssize_t count = 0; 1207 unsigned int i; 1208 1209 switch (index) { 1210 case MOTOR_CFG_ALL: 1211 break; 1212 case RUMBLE_MODE: 1213 for (i = 1; i < ARRAY_SIZE(rumble_mode_text); i++) { 1214 count += sysfs_emit_at(buf, count, "%s ", 1215 rumble_mode_text[i]); 1216 } 1217 break; 1218 case MOTOR_INTENSITY: 1219 case TP_VIBRATION_INTENSITY: 1220 for (i = 1; i < ARRAY_SIZE(intensity_text); i++) { 1221 count += sysfs_emit_at(buf, count, "%s ", 1222 intensity_text[i]); 1223 } 1224 break; 1225 case VIBRATION_NOTIFY_ENABLE: 1226 case TP_VIBRATION_ENABLE: 1227 for (i = 1; i < ARRAY_SIZE(enabled_status_text); i++) { 1228 count += sysfs_emit_at(buf, count, "%s ", 1229 enabled_status_text[i]); 1230 } 1231 break; 1232 } 1233 1234 if (count) 1235 buf[count - 1] = '\n'; 1236 1237 return count; 1238 } 1239 1240 static ssize_t fps_mode_dpi_store(struct device *dev, 1241 struct device_attribute *attr, 1242 const char *buf, size_t count) 1243 1244 { 1245 size_t size = 4; 1246 u32 value; 1247 u8 val[4]; 1248 int ret; 1249 1250 ret = kstrtou32(buf, 10, &value); 1251 if (ret) 1252 return ret; 1253 1254 if (value != 500 && value != 800 && value != 1200 && value != 1800) 1255 return -EINVAL; 1256 1257 put_unaligned_le32(value, val); 1258 1259 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, SET_DPI_CFG, 1260 FPS_MODE_DPI, UNSPECIFIED, val, size); 1261 if (ret < 0) 1262 return ret; 1263 1264 return count; 1265 } 1266 1267 static ssize_t fps_mode_dpi_show(struct device *dev, 1268 struct device_attribute *attr, char *buf) 1269 { 1270 int ret; 1271 1272 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_DPI_CFG, 1273 FPS_MODE_DPI, UNSPECIFIED, NULL, 0); 1274 if (ret < 0) 1275 return ret; 1276 1277 return sysfs_emit(buf, "%u\n", drvdata.mouse_dpi); 1278 } 1279 1280 static ssize_t fps_mode_dpi_index_show(struct device *dev, 1281 struct device_attribute *attr, char *buf) 1282 { 1283 return sysfs_emit(buf, "500 800 1200 1800\n"); 1284 } 1285 1286 static ssize_t device_status_show(struct device *dev, 1287 struct device_attribute *attr, char *buf, 1288 enum device_status_index index, 1289 enum dev_type device_type, 1290 enum cal_device_type cal_type) 1291 { 1292 u8 i; 1293 1294 switch (index) { 1295 case GET_CAL_STATUS: 1296 switch (device_type) { 1297 case LEFT_CONTROLLER: 1298 switch (cal_type) { 1299 case CALDEV_GYROSCOPE: 1300 i = drvdata.gp_left_gyro_cal_status; 1301 break; 1302 case CALDEV_JOYSTICK: 1303 i = drvdata.gp_left_joy_cal_status; 1304 break; 1305 case CALDEV_TRIGGER: 1306 i = drvdata.gp_left_trigg_cal_status; 1307 break; 1308 default: 1309 return -EINVAL; 1310 } 1311 break; 1312 case RIGHT_CONTROLLER: 1313 switch (cal_type) { 1314 case CALDEV_GYROSCOPE: 1315 i = drvdata.gp_right_gyro_cal_status; 1316 break; 1317 case CALDEV_JOYSTICK: 1318 i = drvdata.gp_right_joy_cal_status; 1319 break; 1320 case CALDEV_TRIGGER: 1321 i = drvdata.gp_right_trigg_cal_status; 1322 break; 1323 default: 1324 return -EINVAL; 1325 } 1326 break; 1327 default: 1328 return -EINVAL; 1329 } 1330 break; 1331 default: 1332 return -EINVAL; 1333 } 1334 1335 if (i >= ARRAY_SIZE(cal_status_text)) 1336 return -EINVAL; 1337 1338 return sysfs_emit(buf, "%s\n", cal_status_text[i]); 1339 } 1340 1341 static ssize_t calibrate_config_store(struct device *dev, 1342 struct device_attribute *attr, 1343 const char *buf, u8 cmd, u8 sub_cmd, 1344 size_t count, enum dev_type device_type) 1345 { 1346 size_t size = 1; 1347 u8 val = 0; 1348 int ret; 1349 1350 ret = sysfs_match_string(cal_enabled_text, buf); 1351 if (ret < 0) 1352 return ret; 1353 1354 val = ret; 1355 if (!val) 1356 size = 0; 1357 1358 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, cmd, sub_cmd, 1359 device_type, &val, size); 1360 if (ret < 0) 1361 return ret; 1362 1363 return count; 1364 } 1365 1366 static ssize_t calibrate_config_options(struct device *dev, 1367 struct device_attribute *attr, 1368 char *buf) 1369 { 1370 ssize_t count = 0; 1371 unsigned int i; 1372 1373 for (i = 1; i < ARRAY_SIZE(cal_enabled_text); i++) 1374 count += sysfs_emit_at(buf, count, "%s ", cal_enabled_text[i]); 1375 1376 buf[count - 1] = '\n'; 1377 1378 return count; 1379 } 1380 1381 static ssize_t os_mode_store(struct device *dev, struct device_attribute *attr, 1382 const char *buf, size_t count) 1383 { 1384 size_t size = 1; 1385 int ret; 1386 u8 val; 1387 1388 ret = sysfs_match_string(os_mode_text, buf); 1389 if (ret <= 0) 1390 return ret; 1391 1392 val = ret; 1393 ret = mcu_property_out(drvdata.hdev, OS_MODE_DATA, FEATURE_OS_MODE, 1394 SET_OS_MODE, USB_MCU, &val, size); 1395 if (ret < 0) 1396 return ret; 1397 1398 drvdata.os_mode = val; 1399 1400 return count; 1401 } 1402 1403 static ssize_t os_mode_show(struct device *dev, struct device_attribute *attr, 1404 char *buf) 1405 { 1406 ssize_t count = 0; 1407 int ret; 1408 u8 i; 1409 1410 ret = mcu_property_out(drvdata.hdev, OS_MODE_DATA, FEATURE_OS_MODE, 1411 GET_OS_MODE, USB_MCU, NULL, 0); 1412 if (ret) 1413 return ret; 1414 1415 i = drvdata.os_mode; 1416 if (i >= ARRAY_SIZE(os_mode_text)) 1417 return -EINVAL; 1418 1419 count = sysfs_emit(buf, "%s\n", os_mode_text[i]); 1420 1421 return count; 1422 } 1423 1424 static ssize_t os_mode_index_show(struct device *dev, 1425 struct device_attribute *attr, char *buf) 1426 { 1427 ssize_t count = 0; 1428 unsigned int i; 1429 1430 for (i = 1; i < ARRAY_SIZE(os_mode_text); i++) 1431 count += sysfs_emit_at(buf, count, "%s ", os_mode_text[i]); 1432 1433 if (count) 1434 buf[count - 1] = '\n'; 1435 1436 return count; 1437 } 1438 1439 static int rgb_cfg_call(struct hid_device *hdev, enum mcu_command_index cmd, 1440 enum rgb_config_index index, u8 *val, size_t size) 1441 { 1442 if (cmd != SET_RGB_CFG && cmd != GET_RGB_CFG) 1443 return -EINVAL; 1444 1445 if (index < LIGHT_CFG_ALL || index > USR_LIGHT_PROFILE_3) 1446 return -EINVAL; 1447 1448 return mcu_property_out(hdev, MCU_CONFIG_DATA, cmd, index, UNSPECIFIED, 1449 val, size); 1450 } 1451 1452 static int rgb_attr_show(void) 1453 { 1454 enum rgb_config_index index; 1455 1456 index = drvdata.rgb_profile + 3; 1457 1458 return rgb_cfg_call(drvdata.hdev, GET_RGB_CFG, index, NULL, 0); 1459 } 1460 1461 static ssize_t rgb_effect_store(struct device *dev, 1462 struct device_attribute *attr, const char *buf, 1463 size_t count) 1464 { 1465 struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(drvdata.led_cdev); 1466 enum rgb_config_index index; 1467 u8 effect; 1468 int ret; 1469 1470 ret = sysfs_match_string(rgb_effect_text, buf); 1471 if (ret < 0) 1472 return ret; 1473 1474 effect = ret; 1475 index = drvdata.rgb_profile + 3; 1476 u8 rgb_profile[6] = { effect, 1477 mc_cdev->subled_info[0].intensity, 1478 mc_cdev->subled_info[1].intensity, 1479 mc_cdev->subled_info[2].intensity, 1480 drvdata.led_cdev->brightness, 1481 drvdata.rgb_speed }; 1482 1483 ret = rgb_cfg_call(drvdata.hdev, SET_RGB_CFG, index, rgb_profile, 6); 1484 if (ret) 1485 return ret; 1486 1487 drvdata.rgb_effect = effect; 1488 return count; 1489 } 1490 1491 static ssize_t rgb_effect_show(struct device *dev, 1492 struct device_attribute *attr, char *buf) 1493 { 1494 int ret; 1495 1496 ret = rgb_attr_show(); 1497 if (ret) 1498 return ret; 1499 1500 if (drvdata.rgb_effect >= ARRAY_SIZE(rgb_effect_text)) 1501 return -EINVAL; 1502 1503 return sysfs_emit(buf, "%s\n", rgb_effect_text[drvdata.rgb_effect]); 1504 } 1505 1506 static ssize_t rgb_effect_index_show(struct device *dev, 1507 struct device_attribute *attr, char *buf) 1508 { 1509 ssize_t count = 0; 1510 unsigned int i; 1511 1512 for (i = 0; i < ARRAY_SIZE(rgb_effect_text); i++) 1513 count += sysfs_emit_at(buf, count, "%s ", rgb_effect_text[i]); 1514 1515 if (count) 1516 buf[count - 1] = '\n'; 1517 1518 return count; 1519 } 1520 1521 static ssize_t rgb_speed_store(struct device *dev, 1522 struct device_attribute *attr, const char *buf, 1523 size_t count) 1524 { 1525 struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(drvdata.led_cdev); 1526 enum rgb_config_index index; 1527 int val = 0; 1528 int ret; 1529 1530 ret = kstrtoint(buf, 10, &val); 1531 if (ret) 1532 return ret; 1533 1534 if (val < 0 || val > 100) 1535 return -EINVAL; 1536 1537 /* This is a delay setting, invert logic for consistency with other drivers */ 1538 val = 100 - val; 1539 1540 index = drvdata.rgb_profile + 3; 1541 u8 rgb_profile[6] = { drvdata.rgb_effect, 1542 mc_cdev->subled_info[0].intensity, 1543 mc_cdev->subled_info[1].intensity, 1544 mc_cdev->subled_info[2].intensity, 1545 drvdata.led_cdev->brightness, 1546 val }; 1547 1548 ret = rgb_cfg_call(drvdata.hdev, SET_RGB_CFG, index, rgb_profile, 6); 1549 if (ret) 1550 return ret; 1551 1552 drvdata.rgb_speed = val; 1553 1554 return count; 1555 } 1556 1557 static ssize_t rgb_speed_show(struct device *dev, struct device_attribute *attr, 1558 char *buf) 1559 { 1560 int ret, val; 1561 1562 ret = rgb_attr_show(); 1563 if (ret) 1564 return ret; 1565 1566 if (drvdata.rgb_speed > 100) 1567 return -EINVAL; 1568 1569 val = drvdata.rgb_speed; 1570 1571 return sysfs_emit(buf, "%hhu\n", val); 1572 } 1573 1574 static ssize_t rgb_speed_range_show(struct device *dev, 1575 struct device_attribute *attr, char *buf) 1576 { 1577 return sysfs_emit(buf, "0-100\n"); 1578 } 1579 1580 static ssize_t rgb_mode_store(struct device *dev, struct device_attribute *attr, 1581 const char *buf, size_t count) 1582 { 1583 int ret; 1584 u8 val; 1585 1586 ret = sysfs_match_string(rgb_mode_text, buf); 1587 if (ret <= 0) 1588 return ret; 1589 1590 val = ret; 1591 1592 ret = rgb_cfg_call(drvdata.hdev, SET_RGB_CFG, LIGHT_MODE_SEL, &val, 1); 1593 if (ret) 1594 return ret; 1595 1596 drvdata.rgb_mode = val; 1597 1598 return count; 1599 } 1600 1601 static ssize_t rgb_mode_show(struct device *dev, struct device_attribute *attr, 1602 char *buf) 1603 { 1604 int ret; 1605 1606 ret = rgb_cfg_call(drvdata.hdev, GET_RGB_CFG, LIGHT_MODE_SEL, NULL, 0); 1607 if (ret) 1608 return ret; 1609 1610 if (drvdata.rgb_mode >= ARRAY_SIZE(rgb_mode_text)) 1611 return -EINVAL; 1612 1613 return sysfs_emit(buf, "%s\n", rgb_mode_text[drvdata.rgb_mode]); 1614 } 1615 1616 static ssize_t rgb_mode_index_show(struct device *dev, 1617 struct device_attribute *attr, char *buf) 1618 { 1619 ssize_t count = 0; 1620 unsigned int i; 1621 1622 for (i = 1; i < ARRAY_SIZE(rgb_mode_text); i++) 1623 count += sysfs_emit_at(buf, count, "%s ", rgb_mode_text[i]); 1624 1625 if (count) 1626 buf[count - 1] = '\n'; 1627 1628 return count; 1629 } 1630 1631 static ssize_t rgb_profile_store(struct device *dev, 1632 struct device_attribute *attr, const char *buf, 1633 size_t count) 1634 { 1635 size_t size = 1; 1636 int ret; 1637 u8 val; 1638 1639 ret = kstrtou8(buf, 10, &val); 1640 if (ret < 0) 1641 return ret; 1642 1643 if (val < 1 || val > 3) 1644 return -EINVAL; 1645 1646 ret = rgb_cfg_call(drvdata.hdev, SET_RGB_CFG, LIGHT_PROFILE_SEL, &val, size); 1647 if (ret) 1648 return ret; 1649 1650 drvdata.rgb_profile = val; 1651 1652 return count; 1653 } 1654 1655 static ssize_t rgb_profile_show(struct device *dev, 1656 struct device_attribute *attr, char *buf) 1657 { 1658 int ret; 1659 1660 ret = rgb_cfg_call(drvdata.hdev, GET_RGB_CFG, LIGHT_PROFILE_SEL, NULL, 0); 1661 if (ret) 1662 return ret; 1663 1664 if (drvdata.rgb_profile < 1 || drvdata.rgb_profile > 3) 1665 return -EINVAL; 1666 1667 return sysfs_emit(buf, "%hhu\n", drvdata.rgb_profile); 1668 } 1669 1670 static ssize_t rgb_profile_range_show(struct device *dev, 1671 struct device_attribute *attr, char *buf) 1672 { 1673 return sysfs_emit(buf, "1-3\n"); 1674 } 1675 1676 static void hid_go_brightness_set(struct led_classdev *led_cdev, 1677 enum led_brightness brightness) 1678 { 1679 struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(drvdata.led_cdev); 1680 enum rgb_config_index index; 1681 int ret; 1682 1683 if (brightness > led_cdev->max_brightness) { 1684 dev_err(led_cdev->dev, "Invalid argument\n"); 1685 return; 1686 } 1687 1688 index = drvdata.rgb_profile + 3; 1689 u8 rgb_profile[6] = { drvdata.rgb_effect, 1690 mc_cdev->subled_info[0].intensity, 1691 mc_cdev->subled_info[1].intensity, 1692 mc_cdev->subled_info[2].intensity, 1693 brightness, 1694 drvdata.rgb_speed }; 1695 1696 ret = rgb_cfg_call(drvdata.hdev, SET_RGB_CFG, index, rgb_profile, 6); 1697 switch (ret) { 1698 case 0: 1699 led_cdev->brightness = brightness; 1700 break; 1701 case -ENODEV: /* during switch to IAP -ENODEV is expected */ 1702 case -ENOSYS: /* during rmmod -ENOSYS is expected */ 1703 dev_dbg(led_cdev->dev, "Failed to write RGB profile: %i\n", ret); 1704 break; 1705 default: 1706 dev_err(led_cdev->dev, "Failed to write RGB profile: %i\n", ret); 1707 } 1708 } 1709 1710 #define LEGO_DEVICE_ATTR_RW(_name, _attrname, _dtype, _rtype, _group) \ 1711 static ssize_t _name##_store(struct device *dev, \ 1712 struct device_attribute *attr, \ 1713 const char *buf, size_t count) \ 1714 { \ 1715 return _group##_store(dev, attr, buf, count, _name.index, \ 1716 _dtype); \ 1717 } \ 1718 static ssize_t _name##_show(struct device *dev, \ 1719 struct device_attribute *attr, char *buf) \ 1720 { \ 1721 return _group##_show(dev, attr, buf, _name.index, _dtype); \ 1722 } \ 1723 static ssize_t _name##_##_rtype##_show( \ 1724 struct device *dev, struct device_attribute *attr, char *buf) \ 1725 { \ 1726 return _group##_options(dev, attr, buf, _name.index); \ 1727 } \ 1728 static DEVICE_ATTR_RW_NAMED(_name, _attrname) 1729 1730 #define LEGO_DEVICE_ATTR_WO(_name, _attrname, _dtype, _group) \ 1731 static ssize_t _name##_store(struct device *dev, \ 1732 struct device_attribute *attr, \ 1733 const char *buf, size_t count) \ 1734 { \ 1735 return _group##_store(dev, attr, buf, count, _name.index, \ 1736 _dtype); \ 1737 } \ 1738 static DEVICE_ATTR_WO_NAMED(_name, _attrname) 1739 1740 #define LEGO_DEVICE_ATTR_RO(_name, _attrname, _dtype, _group) \ 1741 static ssize_t _name##_show(struct device *dev, \ 1742 struct device_attribute *attr, char *buf) \ 1743 { \ 1744 return _group##_show(dev, attr, buf, _name.index, _dtype); \ 1745 } \ 1746 static DEVICE_ATTR_RO_NAMED(_name, _attrname) 1747 1748 #define LEGO_CAL_DEVICE_ATTR(_name, _attrname, _scmd, _dtype, _rtype) \ 1749 static ssize_t _name##_store(struct device *dev, \ 1750 struct device_attribute *attr, \ 1751 const char *buf, size_t count) \ 1752 { \ 1753 return calibrate_config_store(dev, attr, buf, _name.index, \ 1754 _scmd, count, _dtype); \ 1755 } \ 1756 static ssize_t _name##_##_rtype##_show( \ 1757 struct device *dev, struct device_attribute *attr, char *buf) \ 1758 { \ 1759 return calibrate_config_options(dev, attr, buf); \ 1760 } \ 1761 static DEVICE_ATTR_WO_NAMED(_name, _attrname) 1762 1763 #define LEGO_DEVICE_STATUS_ATTR(_name, _attrname, _scmd, _dtype) \ 1764 static ssize_t _name##_show(struct device *dev, \ 1765 struct device_attribute *attr, char *buf) \ 1766 { \ 1767 return device_status_show(dev, attr, buf, _name.index, _scmd, \ 1768 _dtype); \ 1769 } \ 1770 static DEVICE_ATTR_RO_NAMED(_name, _attrname) 1771 1772 /* Gamepad - MCU */ 1773 static struct go_cfg_attr version_product_mcu = { PRODUCT_VERSION }; 1774 LEGO_DEVICE_ATTR_RO(version_product_mcu, "product_version", USB_MCU, version); 1775 1776 static struct go_cfg_attr version_protocol_mcu = { PROTOCOL_VERSION }; 1777 LEGO_DEVICE_ATTR_RO(version_protocol_mcu, "protocol_version", USB_MCU, version); 1778 1779 static struct go_cfg_attr version_firmware_mcu = { FIRMWARE_VERSION }; 1780 LEGO_DEVICE_ATTR_RO(version_firmware_mcu, "firmware_version", USB_MCU, version); 1781 1782 static struct go_cfg_attr version_hardware_mcu = { HARDWARE_VERSION }; 1783 LEGO_DEVICE_ATTR_RO(version_hardware_mcu, "hardware_version", USB_MCU, version); 1784 1785 static struct go_cfg_attr version_gen_mcu = { HARDWARE_GENERATION }; 1786 LEGO_DEVICE_ATTR_RO(version_gen_mcu, "hardware_generation", USB_MCU, version); 1787 1788 static struct go_cfg_attr fps_switch_status = { FEATURE_FPS_SWITCH_STATUS }; 1789 LEGO_DEVICE_ATTR_RO(fps_switch_status, "fps_switch_status", UNSPECIFIED, 1790 feature_status); 1791 1792 static struct go_cfg_attr gamepad_mode = { FEATURE_GAMEPAD_MODE }; 1793 LEGO_DEVICE_ATTR_RW(gamepad_mode, "mode", UNSPECIFIED, index, feature_status); 1794 static DEVICE_ATTR_RO_NAMED(gamepad_mode_index, "mode_index"); 1795 1796 static struct go_cfg_attr reset_mcu = { FEATURE_RESET_GAMEPAD }; 1797 LEGO_DEVICE_ATTR_WO(reset_mcu, "reset_mcu", USB_MCU, feature_status); 1798 1799 static struct go_cfg_attr gamepad_rumble_intensity = { MOTOR_INTENSITY }; 1800 LEGO_DEVICE_ATTR_RW(gamepad_rumble_intensity, "rumble_intensity", UNSPECIFIED, 1801 index, motor_config); 1802 static DEVICE_ATTR_RO_NAMED(gamepad_rumble_intensity_index, 1803 "rumble_intensity_index"); 1804 1805 static DEVICE_ATTR_RW(fps_mode_dpi); 1806 static DEVICE_ATTR_RO(fps_mode_dpi_index); 1807 1808 static DEVICE_ATTR_RW(os_mode); 1809 static DEVICE_ATTR_RO(os_mode_index); 1810 1811 static struct attribute *mcu_attrs[] = { 1812 &dev_attr_fps_mode_dpi.attr, 1813 &dev_attr_fps_mode_dpi_index.attr, 1814 &dev_attr_fps_switch_status.attr, 1815 &dev_attr_gamepad_mode.attr, 1816 &dev_attr_gamepad_mode_index.attr, 1817 &dev_attr_gamepad_rumble_intensity.attr, 1818 &dev_attr_gamepad_rumble_intensity_index.attr, 1819 &dev_attr_os_mode.attr, 1820 &dev_attr_os_mode_index.attr, 1821 &dev_attr_reset_mcu.attr, 1822 &dev_attr_version_firmware_mcu.attr, 1823 &dev_attr_version_gen_mcu.attr, 1824 &dev_attr_version_hardware_mcu.attr, 1825 &dev_attr_version_product_mcu.attr, 1826 &dev_attr_version_protocol_mcu.attr, 1827 NULL, 1828 }; 1829 1830 static const struct attribute_group mcu_attr_group = { 1831 .attrs = mcu_attrs, 1832 }; 1833 1834 /* Gamepad - TX Dongle */ 1835 static struct go_cfg_attr version_product_tx_dongle = { PRODUCT_VERSION }; 1836 LEGO_DEVICE_ATTR_RO(version_product_tx_dongle, "product_version", TX_DONGLE, version); 1837 1838 static struct go_cfg_attr version_protocol_tx_dongle = { PROTOCOL_VERSION }; 1839 LEGO_DEVICE_ATTR_RO(version_protocol_tx_dongle, "protocol_version", TX_DONGLE, version); 1840 1841 static struct go_cfg_attr version_firmware_tx_dongle = { FIRMWARE_VERSION }; 1842 LEGO_DEVICE_ATTR_RO(version_firmware_tx_dongle, "firmware_version", TX_DONGLE, version); 1843 1844 static struct go_cfg_attr version_hardware_tx_dongle = { HARDWARE_VERSION }; 1845 LEGO_DEVICE_ATTR_RO(version_hardware_tx_dongle, "hardware_version", TX_DONGLE, version); 1846 1847 static struct go_cfg_attr version_gen_tx_dongle = { HARDWARE_GENERATION }; 1848 LEGO_DEVICE_ATTR_RO(version_gen_tx_dongle, "hardware_generation", TX_DONGLE, version); 1849 1850 static struct go_cfg_attr reset_tx_dongle = { FEATURE_RESET_GAMEPAD }; 1851 LEGO_DEVICE_ATTR_RO(reset_tx_dongle, "reset", TX_DONGLE, feature_status); 1852 1853 static struct attribute *tx_dongle_attrs[] = { 1854 &dev_attr_reset_tx_dongle.attr, 1855 &dev_attr_version_hardware_tx_dongle.attr, 1856 &dev_attr_version_firmware_tx_dongle.attr, 1857 &dev_attr_version_gen_tx_dongle.attr, 1858 &dev_attr_version_product_tx_dongle.attr, 1859 &dev_attr_version_protocol_tx_dongle.attr, 1860 NULL, 1861 }; 1862 1863 static const struct attribute_group tx_dongle_attr_group = { 1864 .name = "tx_dongle", 1865 .attrs = tx_dongle_attrs, 1866 }; 1867 1868 /* Gamepad - Left */ 1869 static struct go_cfg_attr version_product_left = { PRODUCT_VERSION }; 1870 LEGO_DEVICE_ATTR_RO(version_product_left, "product_version", LEFT_CONTROLLER, version); 1871 1872 static struct go_cfg_attr version_protocol_left = { PROTOCOL_VERSION }; 1873 LEGO_DEVICE_ATTR_RO(version_protocol_left, "protocol_version", LEFT_CONTROLLER, version); 1874 1875 static struct go_cfg_attr version_firmware_left = { FIRMWARE_VERSION }; 1876 LEGO_DEVICE_ATTR_RO(version_firmware_left, "firmware_version", LEFT_CONTROLLER, version); 1877 1878 static struct go_cfg_attr version_hardware_left = { HARDWARE_VERSION }; 1879 LEGO_DEVICE_ATTR_RO(version_hardware_left, "hardware_version", LEFT_CONTROLLER, version); 1880 1881 static struct go_cfg_attr version_gen_left = { HARDWARE_GENERATION }; 1882 LEGO_DEVICE_ATTR_RO(version_gen_left, "hardware_generation", LEFT_CONTROLLER, version); 1883 1884 static struct go_cfg_attr auto_sleep_time_left = { FEATURE_AUTO_SLEEP_TIME }; 1885 LEGO_DEVICE_ATTR_RW(auto_sleep_time_left, "auto_sleep_time", LEFT_CONTROLLER, 1886 range, feature_status); 1887 static DEVICE_ATTR_RO_NAMED(auto_sleep_time_left_range, 1888 "auto_sleep_time_range"); 1889 1890 static struct go_cfg_attr imu_bypass_left = { FEATURE_IMU_BYPASS }; 1891 LEGO_DEVICE_ATTR_RW(imu_bypass_left, "imu_bypass_enabled", LEFT_CONTROLLER, 1892 index, feature_status); 1893 static DEVICE_ATTR_RO_NAMED(imu_bypass_left_index, "imu_bypass_enabled_index"); 1894 1895 static struct go_cfg_attr imu_enabled_left = { FEATURE_IMU_ENABLE }; 1896 LEGO_DEVICE_ATTR_RW(imu_enabled_left, "imu_enabled", LEFT_CONTROLLER, index, 1897 feature_status); 1898 static DEVICE_ATTR_RO_NAMED(imu_enabled_left_index, "imu_enabled_index"); 1899 1900 static struct go_cfg_attr reset_left = { FEATURE_RESET_GAMEPAD }; 1901 LEGO_DEVICE_ATTR_WO(reset_left, "reset", LEFT_CONTROLLER, feature_status); 1902 1903 static struct go_cfg_attr rumble_mode_left = { RUMBLE_MODE }; 1904 LEGO_DEVICE_ATTR_RW(rumble_mode_left, "rumble_mode", LEFT_CONTROLLER, index, 1905 motor_config); 1906 static DEVICE_ATTR_RO_NAMED(rumble_mode_left_index, "rumble_mode_index"); 1907 1908 static struct go_cfg_attr rumble_notification_left = { VIBRATION_NOTIFY_ENABLE }; 1909 LEGO_DEVICE_ATTR_RW(rumble_notification_left, "rumble_notification", 1910 LEFT_CONTROLLER, index, motor_config); 1911 static DEVICE_ATTR_RO_NAMED(rumble_notification_left_index, 1912 "rumble_notification_index"); 1913 1914 static struct go_cfg_attr cal_trigg_left = { TRIGGER_CALIBRATE }; 1915 LEGO_CAL_DEVICE_ATTR(cal_trigg_left, "calibrate_trigger", SET_TRIGGER_CFG, 1916 LEFT_CONTROLLER, index); 1917 static DEVICE_ATTR_RO_NAMED(cal_trigg_left_index, "calibrate_trigger_index"); 1918 1919 static struct go_cfg_attr cal_joy_left = { JOYSTICK_CALIBRATE }; 1920 LEGO_CAL_DEVICE_ATTR(cal_joy_left, "calibrate_joystick", SET_JOYSTICK_CFG, 1921 LEFT_CONTROLLER, index); 1922 static DEVICE_ATTR_RO_NAMED(cal_joy_left_index, "calibrate_joystick_index"); 1923 1924 static struct go_cfg_attr cal_gyro_left = { GYRO_CALIBRATE }; 1925 LEGO_CAL_DEVICE_ATTR(cal_gyro_left, "calibrate_gyro", SET_GYRO_CFG, 1926 LEFT_CONTROLLER, index); 1927 static DEVICE_ATTR_RO_NAMED(cal_gyro_left_index, "calibrate_gyro_index"); 1928 1929 static struct go_cfg_attr cal_trigg_left_status = { GET_CAL_STATUS }; 1930 LEGO_DEVICE_STATUS_ATTR(cal_trigg_left_status, "calibrate_trigger_status", 1931 LEFT_CONTROLLER, CALDEV_TRIGGER); 1932 1933 static struct go_cfg_attr cal_joy_left_status = { GET_CAL_STATUS }; 1934 LEGO_DEVICE_STATUS_ATTR(cal_joy_left_status, "calibrate_joystick_status", 1935 LEFT_CONTROLLER, CALDEV_JOYSTICK); 1936 1937 static struct go_cfg_attr cal_gyro_left_status = { GET_CAL_STATUS }; 1938 LEGO_DEVICE_STATUS_ATTR(cal_gyro_left_status, "calibrate_gyro_status", 1939 LEFT_CONTROLLER, CALDEV_GYROSCOPE); 1940 1941 static struct attribute *left_gamepad_attrs[] = { 1942 &dev_attr_auto_sleep_time_left.attr, 1943 &dev_attr_auto_sleep_time_left_range.attr, 1944 &dev_attr_cal_gyro_left.attr, 1945 &dev_attr_cal_gyro_left_index.attr, 1946 &dev_attr_cal_gyro_left_status.attr, 1947 &dev_attr_cal_joy_left.attr, 1948 &dev_attr_cal_joy_left_index.attr, 1949 &dev_attr_cal_joy_left_status.attr, 1950 &dev_attr_cal_trigg_left.attr, 1951 &dev_attr_cal_trigg_left_index.attr, 1952 &dev_attr_cal_trigg_left_status.attr, 1953 &dev_attr_imu_bypass_left.attr, 1954 &dev_attr_imu_bypass_left_index.attr, 1955 &dev_attr_imu_enabled_left.attr, 1956 &dev_attr_imu_enabled_left_index.attr, 1957 &dev_attr_reset_left.attr, 1958 &dev_attr_rumble_mode_left.attr, 1959 &dev_attr_rumble_mode_left_index.attr, 1960 &dev_attr_rumble_notification_left.attr, 1961 &dev_attr_rumble_notification_left_index.attr, 1962 &dev_attr_version_hardware_left.attr, 1963 &dev_attr_version_firmware_left.attr, 1964 &dev_attr_version_gen_left.attr, 1965 &dev_attr_version_product_left.attr, 1966 &dev_attr_version_protocol_left.attr, 1967 NULL, 1968 }; 1969 1970 static const struct attribute_group left_gamepad_attr_group = { 1971 .name = "left_handle", 1972 .attrs = left_gamepad_attrs, 1973 }; 1974 1975 /* Gamepad - Right */ 1976 static struct go_cfg_attr version_product_right = { PRODUCT_VERSION }; 1977 LEGO_DEVICE_ATTR_RO(version_product_right, "product_version", RIGHT_CONTROLLER, version); 1978 1979 static struct go_cfg_attr version_protocol_right = { PROTOCOL_VERSION }; 1980 LEGO_DEVICE_ATTR_RO(version_protocol_right, "protocol_version", RIGHT_CONTROLLER, version); 1981 1982 static struct go_cfg_attr version_firmware_right = { FIRMWARE_VERSION }; 1983 LEGO_DEVICE_ATTR_RO(version_firmware_right, "firmware_version", RIGHT_CONTROLLER, version); 1984 1985 static struct go_cfg_attr version_hardware_right = { HARDWARE_VERSION }; 1986 LEGO_DEVICE_ATTR_RO(version_hardware_right, "hardware_version", RIGHT_CONTROLLER, version); 1987 1988 static struct go_cfg_attr version_gen_right = { HARDWARE_GENERATION }; 1989 LEGO_DEVICE_ATTR_RO(version_gen_right, "hardware_generation", RIGHT_CONTROLLER, version); 1990 1991 static struct go_cfg_attr auto_sleep_time_right = { FEATURE_AUTO_SLEEP_TIME }; 1992 LEGO_DEVICE_ATTR_RW(auto_sleep_time_right, "auto_sleep_time", RIGHT_CONTROLLER, 1993 range, feature_status); 1994 static DEVICE_ATTR_RO_NAMED(auto_sleep_time_right_range, 1995 "auto_sleep_time_range"); 1996 1997 static struct go_cfg_attr imu_bypass_right = { FEATURE_IMU_BYPASS }; 1998 LEGO_DEVICE_ATTR_RW(imu_bypass_right, "imu_bypass_enabled", RIGHT_CONTROLLER, 1999 index, feature_status); 2000 static DEVICE_ATTR_RO_NAMED(imu_bypass_right_index, "imu_bypass_enabled_index"); 2001 2002 static struct go_cfg_attr imu_enabled_right = { FEATURE_IMU_BYPASS }; 2003 LEGO_DEVICE_ATTR_RW(imu_enabled_right, "imu_enabled", RIGHT_CONTROLLER, index, 2004 feature_status); 2005 static DEVICE_ATTR_RO_NAMED(imu_enabled_right_index, "imu_enabled_index"); 2006 2007 static struct go_cfg_attr reset_right = { FEATURE_RESET_GAMEPAD }; 2008 LEGO_DEVICE_ATTR_WO(reset_right, "reset", LEFT_CONTROLLER, feature_status); 2009 2010 static struct go_cfg_attr rumble_mode_right = { RUMBLE_MODE }; 2011 LEGO_DEVICE_ATTR_RW(rumble_mode_right, "rumble_mode", RIGHT_CONTROLLER, index, 2012 motor_config); 2013 static DEVICE_ATTR_RO_NAMED(rumble_mode_right_index, "rumble_mode_index"); 2014 2015 static struct go_cfg_attr rumble_notification_right = { VIBRATION_NOTIFY_ENABLE }; 2016 LEGO_DEVICE_ATTR_RW(rumble_notification_right, "rumble_notification", 2017 RIGHT_CONTROLLER, index, motor_config); 2018 static DEVICE_ATTR_RO_NAMED(rumble_notification_right_index, 2019 "rumble_notification_index"); 2020 2021 static struct go_cfg_attr cal_trigg_right = { TRIGGER_CALIBRATE }; 2022 LEGO_CAL_DEVICE_ATTR(cal_trigg_right, "calibrate_trigger", SET_TRIGGER_CFG, 2023 RIGHT_CONTROLLER, index); 2024 static DEVICE_ATTR_RO_NAMED(cal_trigg_right_index, "calibrate_trigger_index"); 2025 2026 static struct go_cfg_attr cal_joy_right = { JOYSTICK_CALIBRATE }; 2027 LEGO_CAL_DEVICE_ATTR(cal_joy_right, "calibrate_joystick", SET_JOYSTICK_CFG, 2028 RIGHT_CONTROLLER, index); 2029 static DEVICE_ATTR_RO_NAMED(cal_joy_right_index, "calibrate_joystick_index"); 2030 2031 static struct go_cfg_attr cal_gyro_right = { GYRO_CALIBRATE }; 2032 LEGO_CAL_DEVICE_ATTR(cal_gyro_right, "calibrate_gyro", SET_GYRO_CFG, 2033 RIGHT_CONTROLLER, index); 2034 static DEVICE_ATTR_RO_NAMED(cal_gyro_right_index, "calibrate_gyro_index"); 2035 2036 static struct go_cfg_attr cal_trigg_right_status = { GET_CAL_STATUS }; 2037 LEGO_DEVICE_STATUS_ATTR(cal_trigg_right_status, "calibrate_trigger_status", 2038 RIGHT_CONTROLLER, CALDEV_TRIGGER); 2039 2040 static struct go_cfg_attr cal_joy_right_status = { GET_CAL_STATUS }; 2041 LEGO_DEVICE_STATUS_ATTR(cal_joy_right_status, "calibrate_joystick_status", 2042 RIGHT_CONTROLLER, CALDEV_JOYSTICK); 2043 2044 static struct go_cfg_attr cal_gyro_right_status = { GET_CAL_STATUS }; 2045 LEGO_DEVICE_STATUS_ATTR(cal_gyro_right_status, "calibrate_gyro_status", 2046 RIGHT_CONTROLLER, CALDEV_GYROSCOPE); 2047 2048 static struct attribute *right_gamepad_attrs[] = { 2049 &dev_attr_auto_sleep_time_right.attr, 2050 &dev_attr_auto_sleep_time_right_range.attr, 2051 &dev_attr_cal_gyro_right.attr, 2052 &dev_attr_cal_gyro_right_index.attr, 2053 &dev_attr_cal_gyro_right_status.attr, 2054 &dev_attr_cal_joy_right.attr, 2055 &dev_attr_cal_joy_right_index.attr, 2056 &dev_attr_cal_joy_right_status.attr, 2057 &dev_attr_cal_trigg_right.attr, 2058 &dev_attr_cal_trigg_right_index.attr, 2059 &dev_attr_cal_trigg_right_status.attr, 2060 &dev_attr_imu_bypass_right.attr, 2061 &dev_attr_imu_bypass_right_index.attr, 2062 &dev_attr_imu_enabled_right.attr, 2063 &dev_attr_imu_enabled_right_index.attr, 2064 &dev_attr_reset_right.attr, 2065 &dev_attr_rumble_mode_right.attr, 2066 &dev_attr_rumble_mode_right_index.attr, 2067 &dev_attr_rumble_notification_right.attr, 2068 &dev_attr_rumble_notification_right_index.attr, 2069 &dev_attr_version_hardware_right.attr, 2070 &dev_attr_version_firmware_right.attr, 2071 &dev_attr_version_gen_right.attr, 2072 &dev_attr_version_product_right.attr, 2073 &dev_attr_version_protocol_right.attr, 2074 NULL, 2075 }; 2076 2077 static const struct attribute_group right_gamepad_attr_group = { 2078 .name = "right_handle", 2079 .attrs = right_gamepad_attrs, 2080 }; 2081 2082 /* Touchpad */ 2083 static struct go_cfg_attr touchpad_enabled = { FEATURE_TOUCHPAD_ENABLE }; 2084 LEGO_DEVICE_ATTR_RW(touchpad_enabled, "enabled", UNSPECIFIED, index, 2085 feature_status); 2086 static DEVICE_ATTR_RO_NAMED(touchpad_enabled_index, "enabled_index"); 2087 2088 static struct go_cfg_attr touchpad_vibration_enabled = { TP_VIBRATION_ENABLE }; 2089 LEGO_DEVICE_ATTR_RW(touchpad_vibration_enabled, "vibration_enabled", UNSPECIFIED, 2090 index, motor_config); 2091 static DEVICE_ATTR_RO_NAMED(touchpad_vibration_enabled_index, 2092 "vibration_enabled_index"); 2093 2094 static struct go_cfg_attr touchpad_vibration_intensity = { TP_VIBRATION_INTENSITY }; 2095 LEGO_DEVICE_ATTR_RW(touchpad_vibration_intensity, "vibration_intensity", 2096 UNSPECIFIED, index, motor_config); 2097 static DEVICE_ATTR_RO_NAMED(touchpad_vibration_intensity_index, 2098 "vibration_intensity_index"); 2099 2100 static struct attribute *touchpad_attrs[] = { 2101 &dev_attr_touchpad_enabled.attr, 2102 &dev_attr_touchpad_enabled_index.attr, 2103 &dev_attr_touchpad_vibration_enabled.attr, 2104 &dev_attr_touchpad_vibration_enabled_index.attr, 2105 &dev_attr_touchpad_vibration_intensity.attr, 2106 &dev_attr_touchpad_vibration_intensity_index.attr, 2107 NULL, 2108 }; 2109 2110 static const struct attribute_group touchpad_attr_group = { 2111 .name = "touchpad", 2112 .attrs = touchpad_attrs, 2113 }; 2114 2115 static const struct attribute_group *top_level_attr_groups[] = { 2116 &mcu_attr_group, &tx_dongle_attr_group, 2117 &left_gamepad_attr_group, &right_gamepad_attr_group, 2118 &touchpad_attr_group, NULL, 2119 }; 2120 2121 /* RGB */ 2122 static struct go_cfg_attr rgb_enabled = { FEATURE_LIGHT_ENABLE }; 2123 2124 LEGO_DEVICE_ATTR_RW(rgb_enabled, "enabled", UNSPECIFIED, index, feature_status); 2125 static DEVICE_ATTR_RO_NAMED(rgb_effect_index, "effect_index"); 2126 static DEVICE_ATTR_RO_NAMED(rgb_enabled_index, "enabled_index"); 2127 static DEVICE_ATTR_RO_NAMED(rgb_mode_index, "mode_index"); 2128 static DEVICE_ATTR_RO_NAMED(rgb_profile_range, "profile_range"); 2129 static DEVICE_ATTR_RO_NAMED(rgb_speed_range, "speed_range"); 2130 static DEVICE_ATTR_RW_NAMED(rgb_effect, "effect"); 2131 static DEVICE_ATTR_RW_NAMED(rgb_mode, "mode"); 2132 static DEVICE_ATTR_RW_NAMED(rgb_profile, "profile"); 2133 static DEVICE_ATTR_RW_NAMED(rgb_speed, "speed"); 2134 2135 static struct attribute *go_rgb_attrs[] = { 2136 &dev_attr_rgb_effect.attr, 2137 &dev_attr_rgb_effect_index.attr, 2138 &dev_attr_rgb_enabled.attr, 2139 &dev_attr_rgb_enabled_index.attr, 2140 &dev_attr_rgb_mode.attr, 2141 &dev_attr_rgb_mode_index.attr, 2142 &dev_attr_rgb_profile.attr, 2143 &dev_attr_rgb_profile_range.attr, 2144 &dev_attr_rgb_speed.attr, 2145 &dev_attr_rgb_speed_range.attr, 2146 NULL, 2147 }; 2148 2149 static struct attribute_group rgb_attr_group = { 2150 .attrs = go_rgb_attrs, 2151 }; 2152 2153 static struct mc_subled go_rgb_subled_info[] = { 2154 { 2155 .color_index = LED_COLOR_ID_RED, 2156 .brightness = 0x50, 2157 .intensity = 0x24, 2158 .channel = 0x1, 2159 }, 2160 { 2161 .color_index = LED_COLOR_ID_GREEN, 2162 .brightness = 0x50, 2163 .intensity = 0x22, 2164 .channel = 0x2, 2165 }, 2166 { 2167 .color_index = LED_COLOR_ID_BLUE, 2168 .brightness = 0x50, 2169 .intensity = 0x99, 2170 .channel = 0x3, 2171 }, 2172 }; 2173 2174 static struct led_classdev_mc go_cdev_rgb = { 2175 .led_cdev = { 2176 .name = "go:rgb:joystick_rings", 2177 .color = LED_COLOR_ID_RGB, 2178 .brightness = 0x50, 2179 .max_brightness = 0x64, 2180 .brightness_set = hid_go_brightness_set, 2181 }, 2182 .num_colors = ARRAY_SIZE(go_rgb_subled_info), 2183 .subled_info = go_rgb_subled_info, 2184 }; 2185 2186 static void cfg_setup(struct work_struct *work) 2187 { 2188 int ret; 2189 2190 /* MCU Version Attrs */ 2191 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2192 PRODUCT_VERSION, USB_MCU, NULL, 0); 2193 if (ret < 0) { 2194 dev_err(&drvdata.hdev->dev, 2195 "Failed to retrieve USB_MCU Product Version: %i\n", ret); 2196 return; 2197 } 2198 2199 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2200 PROTOCOL_VERSION, USB_MCU, NULL, 0); 2201 if (ret < 0) { 2202 dev_err(&drvdata.hdev->dev, 2203 "Failed to retrieve USB_MCU Protocol Version: %i\n", ret); 2204 return; 2205 } 2206 2207 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2208 FIRMWARE_VERSION, USB_MCU, NULL, 0); 2209 if (ret < 0) { 2210 dev_err(&drvdata.hdev->dev, 2211 "Failed to retrieve USB_MCU Firmware Version: %i\n", ret); 2212 return; 2213 } 2214 2215 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2216 HARDWARE_VERSION, USB_MCU, NULL, 0); 2217 if (ret < 0) { 2218 dev_err(&drvdata.hdev->dev, 2219 "Failed to retrieve USB_MCU Hardware Version: %i\n", ret); 2220 return; 2221 } 2222 2223 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2224 HARDWARE_GENERATION, USB_MCU, NULL, 0); 2225 if (ret < 0) { 2226 dev_err(&drvdata.hdev->dev, 2227 "Failed to retrieve USB_MCU Hardware Generation: %i\n", ret); 2228 return; 2229 } 2230 2231 /* TX Dongle Version Attrs */ 2232 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2233 PRODUCT_VERSION, TX_DONGLE, NULL, 0); 2234 if (ret < 0) { 2235 dev_err(&drvdata.hdev->dev, 2236 "Failed to retrieve TX_DONGLE Product Version: %i\n", ret); 2237 return; 2238 } 2239 2240 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2241 PROTOCOL_VERSION, TX_DONGLE, NULL, 0); 2242 if (ret < 0) { 2243 dev_err(&drvdata.hdev->dev, 2244 "Failed to retrieve TX_DONGLE Protocol Version: %i\n", ret); 2245 return; 2246 } 2247 2248 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2249 FIRMWARE_VERSION, TX_DONGLE, NULL, 0); 2250 if (ret < 0) { 2251 dev_err(&drvdata.hdev->dev, 2252 "Failed to retrieve TX_DONGLE Firmware Version: %i\n", ret); 2253 return; 2254 } 2255 2256 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2257 HARDWARE_VERSION, TX_DONGLE, NULL, 0); 2258 if (ret < 0) { 2259 dev_err(&drvdata.hdev->dev, 2260 "Failed to retrieve TX_DONGLE Hardware Version: %i\n", ret); 2261 return; 2262 } 2263 2264 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2265 HARDWARE_GENERATION, TX_DONGLE, NULL, 0); 2266 if (ret < 0) { 2267 dev_err(&drvdata.hdev->dev, 2268 "Failed to retrieve TX_DONGLE Hardware Generation: %i\n", ret); 2269 return; 2270 } 2271 2272 /* Left Handle Version Attrs */ 2273 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2274 PRODUCT_VERSION, LEFT_CONTROLLER, NULL, 0); 2275 if (ret < 0) { 2276 dev_err(&drvdata.hdev->dev, 2277 "Failed to retrieve LEFT_CONTROLLER Product Version: %i\n", ret); 2278 return; 2279 } 2280 2281 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2282 PROTOCOL_VERSION, LEFT_CONTROLLER, NULL, 0); 2283 if (ret < 0) { 2284 dev_err(&drvdata.hdev->dev, 2285 "Failed to retrieve LEFT_CONTROLLER Protocol Version: %i\n", ret); 2286 return; 2287 } 2288 2289 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2290 FIRMWARE_VERSION, LEFT_CONTROLLER, NULL, 0); 2291 if (ret < 0) { 2292 dev_err(&drvdata.hdev->dev, 2293 "Failed to retrieve LEFT_CONTROLLER Firmware Version: %i\n", ret); 2294 return; 2295 } 2296 2297 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2298 HARDWARE_VERSION, LEFT_CONTROLLER, NULL, 0); 2299 if (ret < 0) { 2300 dev_err(&drvdata.hdev->dev, 2301 "Failed to retrieve LEFT_CONTROLLER Hardware Version: %i\n", ret); 2302 return; 2303 } 2304 2305 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2306 HARDWARE_GENERATION, LEFT_CONTROLLER, NULL, 0); 2307 if (ret < 0) { 2308 dev_err(&drvdata.hdev->dev, 2309 "Failed to retrieve LEFT_CONTROLLER Hardware Generation: %i\n", ret); 2310 return; 2311 } 2312 2313 /* Right Handle Version Attrs */ 2314 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2315 PRODUCT_VERSION, RIGHT_CONTROLLER, NULL, 0); 2316 if (ret < 0) { 2317 dev_err(&drvdata.hdev->dev, 2318 "Failed to retrieve RIGHT_CONTROLLER Product Version: %i\n", ret); 2319 return; 2320 } 2321 2322 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2323 PROTOCOL_VERSION, RIGHT_CONTROLLER, NULL, 0); 2324 if (ret < 0) { 2325 dev_err(&drvdata.hdev->dev, 2326 "Failed to retrieve RIGHT_CONTROLLER Protocol Version: %i\n", ret); 2327 return; 2328 } 2329 2330 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2331 FIRMWARE_VERSION, RIGHT_CONTROLLER, NULL, 0); 2332 if (ret < 0) { 2333 dev_err(&drvdata.hdev->dev, 2334 "Failed to retrieve RIGHT_CONTROLLER Firmware Version: %i\n", ret); 2335 return; 2336 } 2337 2338 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2339 HARDWARE_VERSION, RIGHT_CONTROLLER, NULL, 0); 2340 if (ret < 0) { 2341 dev_err(&drvdata.hdev->dev, 2342 "Failed to retrieve RIGHT_CONTROLLER Hardware Version: %i\n", ret); 2343 return; 2344 } 2345 2346 ret = mcu_property_out(drvdata.hdev, MCU_CONFIG_DATA, GET_VERSION_DATA, 2347 HARDWARE_GENERATION, RIGHT_CONTROLLER, NULL, 0); 2348 if (ret < 0) { 2349 dev_err(&drvdata.hdev->dev, 2350 "Failed to retrieve RIGHT_CONTROLLER Hardware Generation: %i\n", ret); 2351 return; 2352 } 2353 } 2354 2355 static int hid_go_cfg_probe(struct hid_device *hdev, 2356 const struct hid_device_id *_id) 2357 { 2358 unsigned char *buf; 2359 int ret; 2360 2361 buf = devm_kzalloc(&hdev->dev, GO_PACKET_SIZE, GFP_KERNEL); 2362 if (!buf) 2363 return -ENOMEM; 2364 2365 hid_set_drvdata(hdev, &drvdata); 2366 drvdata.hdev = hdev; 2367 mutex_init(&drvdata.cfg_mutex); 2368 2369 ret = sysfs_create_groups(&hdev->dev.kobj, top_level_attr_groups); 2370 if (ret) { 2371 dev_err_probe(&hdev->dev, ret, 2372 "Failed to create gamepad configuration attributes\n"); 2373 return ret; 2374 } 2375 2376 ret = devm_led_classdev_multicolor_register(&hdev->dev, &go_cdev_rgb); 2377 if (ret) { 2378 dev_err_probe(&hdev->dev, ret, "Failed to create RGB device\n"); 2379 return ret; 2380 } 2381 2382 ret = devm_device_add_group(go_cdev_rgb.led_cdev.dev, &rgb_attr_group); 2383 if (ret) { 2384 dev_err_probe(&hdev->dev, ret, 2385 "Failed to create RGB configuration attributes\n"); 2386 return ret; 2387 } 2388 2389 drvdata.led_cdev = &go_cdev_rgb.led_cdev; 2390 2391 init_completion(&drvdata.send_cmd_complete); 2392 2393 /* Executing calls prior to returning from probe will lock the MCU. Schedule 2394 * initial data call after probe has completed and MCU can accept calls. 2395 */ 2396 INIT_DELAYED_WORK(&drvdata.go_cfg_setup, &cfg_setup); 2397 ret = schedule_delayed_work(&drvdata.go_cfg_setup, msecs_to_jiffies(2)); 2398 if (!ret) { 2399 dev_err(&hdev->dev, 2400 "Failed to schedule startup delayed work\n"); 2401 return -ENODEV; 2402 } 2403 return 0; 2404 } 2405 2406 static void hid_go_cfg_remove(struct hid_device *hdev) 2407 { 2408 /* 2409 * cfg_setup is scheduled from hid_go_cfg_probe() with a 2 ms delay 2410 * and dereferences drvdata.hdev. Drain it here before tearing 2411 * down so the workqueue cannot run after hid_destroy_device()'s 2412 * put_device() has released the underlying hdev and dereference 2413 * a stale drvdata.hdev pointer. 2414 */ 2415 cancel_delayed_work_sync(&drvdata.go_cfg_setup); 2416 2417 guard(mutex)(&drvdata.cfg_mutex); 2418 sysfs_remove_groups(&hdev->dev.kobj, top_level_attr_groups); 2419 hid_hw_close(hdev); 2420 hid_hw_stop(hdev); 2421 hid_set_drvdata(hdev, NULL); 2422 } 2423 2424 static int hid_go_probe(struct hid_device *hdev, const struct hid_device_id *id) 2425 { 2426 int ret, ep; 2427 2428 if (!hid_is_usb(hdev)) 2429 return -EINVAL; 2430 2431 hdev->quirks |= HID_QUIRK_INPUT_PER_APP | HID_QUIRK_MULTI_INPUT; 2432 2433 ret = hid_parse(hdev); 2434 if (ret) { 2435 hid_err(hdev, "Parse failed\n"); 2436 return ret; 2437 } 2438 2439 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 2440 if (ret) { 2441 hid_err(hdev, "Failed to start HID device\n"); 2442 return ret; 2443 } 2444 2445 ret = hid_hw_open(hdev); 2446 if (ret) { 2447 hid_err(hdev, "Failed to open HID device\n"); 2448 hid_hw_stop(hdev); 2449 return ret; 2450 } 2451 2452 ep = get_endpoint_address(hdev); 2453 if (ep != GO_GP_INTF_IN) { 2454 dev_dbg(&hdev->dev, "Started interface %x as generic HID device\n", ep); 2455 return 0; 2456 } 2457 2458 ret = hid_go_cfg_probe(hdev, id); 2459 if (ret) 2460 dev_err_probe(&hdev->dev, ret, "Failed to start configuration interface\n"); 2461 2462 dev_dbg(&hdev->dev, "Started Legion Go HID Device: %x\n", ep); 2463 2464 return ret; 2465 } 2466 2467 static void hid_go_remove(struct hid_device *hdev) 2468 { 2469 int ep = get_endpoint_address(hdev); 2470 2471 if (ep <= 0) 2472 return; 2473 2474 switch (ep) { 2475 case GO_GP_INTF_IN: 2476 hid_go_cfg_remove(hdev); 2477 break; 2478 default: 2479 hid_hw_close(hdev); 2480 hid_hw_stop(hdev); 2481 break; 2482 } 2483 } 2484 2485 static const struct hid_device_id hid_go_devices[] = { 2486 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, 2487 USB_DEVICE_ID_LENOVO_LEGION_GO2_XINPUT) }, 2488 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, 2489 USB_DEVICE_ID_LENOVO_LEGION_GO2_DINPUT) }, 2490 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, 2491 USB_DEVICE_ID_LENOVO_LEGION_GO2_DUAL_DINPUT) }, 2492 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, 2493 USB_DEVICE_ID_LENOVO_LEGION_GO2_FPS) }, 2494 {} 2495 }; 2496 MODULE_DEVICE_TABLE(hid, hid_go_devices); 2497 2498 static struct hid_driver hid_lenovo_go = { 2499 .name = "hid-lenovo-go", 2500 .id_table = hid_go_devices, 2501 .probe = hid_go_probe, 2502 .remove = hid_go_remove, 2503 .raw_event = hid_go_raw_event, 2504 }; 2505 module_hid_driver(hid_lenovo_go); 2506 2507 MODULE_AUTHOR("Derek J. Clark"); 2508 MODULE_DESCRIPTION("HID Driver for Lenovo Legion Go Series Gamepads."); 2509 MODULE_LICENSE("GPL"); 2510