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
hid_go_version_event(struct command_report * cmd_rep)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
hid_go_feature_status_event(struct command_report * cmd_rep)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
hid_go_motor_event(struct command_report * cmd_rep)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
hid_go_fps_dpi_event(struct command_report * cmd_rep)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
hid_go_light_event(struct command_report * cmd_rep)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
hid_go_device_status_event(struct command_report * cmd_rep)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
hid_go_os_mode_cfg_event(struct command_report * cmd_rep)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
hid_go_set_event_return(struct command_report * cmd_rep)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
get_endpoint_address(struct hid_device * hdev)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
hid_go_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)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
mcu_property_out(struct hid_device * hdev,u8 id,u8 command,u8 index,enum dev_type device,u8 * data,size_t len)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
version_show(struct device * dev,struct device_attribute * attr,char * buf,enum version_data_index index,enum dev_type device_type)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
feature_status_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count,enum feature_status_index index,enum dev_type device_type)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
feature_status_show(struct device * dev,struct device_attribute * attr,char * buf,enum feature_status_index index,enum dev_type device_type)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
feature_status_options(struct device * dev,struct device_attribute * attr,char * buf,enum feature_status_index index)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
motor_config_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count,enum motor_cfg_index index,enum dev_type device_type)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
motor_config_show(struct device * dev,struct device_attribute * attr,char * buf,enum motor_cfg_index index,enum dev_type device_type)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
motor_config_options(struct device * dev,struct device_attribute * attr,char * buf,enum motor_cfg_index index)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
fps_mode_dpi_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
fps_mode_dpi_show(struct device * dev,struct device_attribute * attr,char * buf)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
fps_mode_dpi_index_show(struct device * dev,struct device_attribute * attr,char * buf)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
device_status_show(struct device * dev,struct device_attribute * attr,char * buf,enum device_status_index index,enum dev_type device_type,enum cal_device_type cal_type)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
calibrate_config_store(struct device * dev,struct device_attribute * attr,const char * buf,u8 cmd,u8 sub_cmd,size_t count,enum dev_type device_type)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
calibrate_config_options(struct device * dev,struct device_attribute * attr,char * buf)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
os_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
os_mode_show(struct device * dev,struct device_attribute * attr,char * buf)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
os_mode_index_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_cfg_call(struct hid_device * hdev,enum mcu_command_index cmd,enum rgb_config_index index,u8 * val,size_t size)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
rgb_attr_show(void)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
rgb_effect_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
rgb_effect_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_effect_index_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_speed_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
rgb_speed_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_speed_range_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
rgb_mode_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_mode_index_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_profile_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
rgb_profile_show(struct device * dev,struct device_attribute * attr,char * buf)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
rgb_profile_range_show(struct device * dev,struct device_attribute * attr,char * buf)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
hid_go_brightness_set(struct led_classdev * led_cdev,enum led_brightness brightness)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
cfg_setup(struct work_struct * work)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
hid_go_cfg_probe(struct hid_device * hdev,const struct hid_device_id * _id)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
hid_go_cfg_remove(struct hid_device * hdev)2406 static void hid_go_cfg_remove(struct hid_device *hdev)
2407 {
2408 guard(mutex)(&drvdata.cfg_mutex);
2409 sysfs_remove_groups(&hdev->dev.kobj, top_level_attr_groups);
2410 hid_hw_close(hdev);
2411 hid_hw_stop(hdev);
2412 hid_set_drvdata(hdev, NULL);
2413 }
2414
hid_go_probe(struct hid_device * hdev,const struct hid_device_id * id)2415 static int hid_go_probe(struct hid_device *hdev, const struct hid_device_id *id)
2416 {
2417 int ret, ep;
2418
2419 if (!hid_is_usb(hdev))
2420 return -EINVAL;
2421
2422 hdev->quirks |= HID_QUIRK_INPUT_PER_APP | HID_QUIRK_MULTI_INPUT;
2423
2424 ret = hid_parse(hdev);
2425 if (ret) {
2426 hid_err(hdev, "Parse failed\n");
2427 return ret;
2428 }
2429
2430 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2431 if (ret) {
2432 hid_err(hdev, "Failed to start HID device\n");
2433 return ret;
2434 }
2435
2436 ret = hid_hw_open(hdev);
2437 if (ret) {
2438 hid_err(hdev, "Failed to open HID device\n");
2439 hid_hw_stop(hdev);
2440 return ret;
2441 }
2442
2443 ep = get_endpoint_address(hdev);
2444 if (ep != GO_GP_INTF_IN) {
2445 dev_dbg(&hdev->dev, "Started interface %x as generic HID device\n", ep);
2446 return 0;
2447 }
2448
2449 ret = hid_go_cfg_probe(hdev, id);
2450 if (ret)
2451 dev_err_probe(&hdev->dev, ret, "Failed to start configuration interface\n");
2452
2453 dev_dbg(&hdev->dev, "Started Legion Go HID Device: %x\n", ep);
2454
2455 return ret;
2456 }
2457
hid_go_remove(struct hid_device * hdev)2458 static void hid_go_remove(struct hid_device *hdev)
2459 {
2460 int ep = get_endpoint_address(hdev);
2461
2462 if (ep <= 0)
2463 return;
2464
2465 switch (ep) {
2466 case GO_GP_INTF_IN:
2467 hid_go_cfg_remove(hdev);
2468 break;
2469 default:
2470 hid_hw_close(hdev);
2471 hid_hw_stop(hdev);
2472 break;
2473 }
2474 }
2475
2476 static const struct hid_device_id hid_go_devices[] = {
2477 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO,
2478 USB_DEVICE_ID_LENOVO_LEGION_GO2_XINPUT) },
2479 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO,
2480 USB_DEVICE_ID_LENOVO_LEGION_GO2_DINPUT) },
2481 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO,
2482 USB_DEVICE_ID_LENOVO_LEGION_GO2_DUAL_DINPUT) },
2483 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO,
2484 USB_DEVICE_ID_LENOVO_LEGION_GO2_FPS) },
2485 {}
2486 };
2487 MODULE_DEVICE_TABLE(hid, hid_go_devices);
2488
2489 static struct hid_driver hid_lenovo_go = {
2490 .name = "hid-lenovo-go",
2491 .id_table = hid_go_devices,
2492 .probe = hid_go_probe,
2493 .remove = hid_go_remove,
2494 .raw_event = hid_go_raw_event,
2495 };
2496 module_hid_driver(hid_lenovo_go);
2497
2498 MODULE_AUTHOR("Derek J. Clark");
2499 MODULE_DESCRIPTION("HID Driver for Lenovo Legion Go Series Gamepads.");
2500 MODULE_LICENSE("GPL");
2501