Add MSI Claw HID Configuration Driver
Subsystems (3)
Derek J. Clark
maintainerv11 cover Add MSI Claw HID Configuration Driver
This series adds an HID Configuration driver for the MSI Claw line of Handheld Gaming PC's. The MSI Claw HID interface provides multiple features, such as the ability to switch between xinput, dinput, and a desktop mode, RGB control, rumble intensity, and mapping of the rear "M" keys. There are additional gamepad modes that are not included in this driver as they appear to be used in assembly line testing or are incomplete in the firmware. During my testing I found them to be unstable.
The initial version of this driver was written by Denis Benato, which contained the initial reverse-engineering and implementation for the gamepad mode switching. This work was later expanded by Zhouwang Huang to include more gamepad modes and additional features. Finally, I refactored the entire driver, fixed multiple bugs, and refined the overall format to conform to kernel driver best practices and style guide.
Claude was used initially by Zhouwang Huang to quickly parse HID captures during the reverse-engineering of some of the features. Since Claude had already been used, as a test of its capabilities I had it implement the rumble intensity attribute after I had already rewritten most of the driver, which I then manually edited to fix some mistakes. I also used Claude to review the driver and these patches for any mistakes and bugs.
---
v11:
- Restore dropped changes from v10.
v10: https://lore.kernel.org/linux-input/[email protected]/
- Remove additional gamepad_registered variable left over after rename
to gp_registered.
v9: https://lore.kernel.org/linux-input/[email protected]/
- Don't use devm_* functions in cfg_setup_fn, do manual adding
and cleanup to prevent possible use after free.
- Use scoped_guard instead of guard in claw_remove.
- Rename gamepad_registered to gp_registered for brevity.
- Check for drvdata in rgb_queue_fn to avoid use after free during teardown.
- Ensure rgb_queue work is canceled during suspend.
- Limit guard usage in cfg_setup_fn to avoid holding a lock during registration and add group events.
v8: https://lore.kernel.org/linux-input/[email protected]/
- Use spinlock when accessing gamepad_registered.
- Clear state machine on all errors in claw_hw_output_report.
- Wrap all branches under single cmd_lock guard in claw_raw_event.
- Reject generic ACK in claw_raw_event if waiting_cmd is for another branch.
- Wrap all branches under single cmd_lock guard in claw_raw_event.
- Reject generic ACK in claw_raw_event if waiting_cmd is for another branch.
- Don't close hid devices that couldn't have been opened.
- Ensure led_classdev is unregistered if adding attribute group fails.
- Reorder remove actions to ensure no use-after free or rearming cleared flags.
v7: https://lore.kernel.org/linux-input/[email protected]/
- Use smp_[store_release|load_acquire] pattern for checking gamepad_registered and rgb_registered to avoid possible races during teardown.
- Reorder reinit_completion in claw_hw_output_report to avoid race
with possible incoming ACKs.
- Reorder cancel_delayed_work_sync to ensure setup can't be re-armed
after cancel.
- Reset command state machine if hw_output_report has an error.
- Add comments to (hopefully) silence sashinko-bot warnings about the
use of endpoint matching and the impossible scenario of switching to
the alternate endpoint from userspace while the driver is bound.
- Don't use spinlock_irqsave when already in irq context.
- Add profile_lock for read/write profile_pending.
- Use struct for mkey reports and rumble reports, following the
pattern established by rgb reports previously.
- Add gating to cfg_setup_fn, allowing either gamepad settings or rgb settings to populate if the other fails for any reason.
- Match on write address for rumble and mkey reports to prevent late
ACK from causing synchronization errors.
v6: https://lore.kernel.org/linux-input/[email protected]/
- Add send/ack pattern to ensure synchronous acks.
- Use spinlock_irqsave instead of mutex for read/write MODE event
data.
- add select NEW_LEDS to kconfig.
- Make all timeouts 25ms to ensure at least 2 jiffies in a 100Hz
config.
- Gate all attribute show/store functions with gamepad_registered or rgb_registered, enabling use of devm_device_add_group and ending
the need to hold a mutex during remove.
- Don't set gamepad_mode on resume, MCU preserves state.
- Ensure all count variables are checked for > 0 characters before
setting buf - 1 to \n.
- Re-arm cfg_setup in resume if it was canceled in an early suspend.
- Remove duplicated argv_free macro.
- Add spinlock_irqsave vice mutex for read/write access on attribute variables.
v5: https://lore.kernel.org/linux-input/[email protected]/
- Swap disabled & combination mkeys_function enum values.
- Fix bug introduced in v5 where claw_buttons_store would return
-EINVAL on all valid key entries.
- Ensure mode_mutex is properly init.
- Ensure claw_remove is calling hid_hw_close and not hid_hw_stop for
all paths.
- Ensure adding "DISABLED" key to valid entries is done in the correct patch.
- Re-enable sending an empty string to clear button mappings in
addition to setting DISABLED.
- Move adding the RGB device into cfg_setup to prevent led core
attributes from being written to prior to setup completing.
- Ensure frame_lock is properly init.
- Change variable names in RGB functions from frame and zone to f and
z respectively to fit all scoped_guard actions in 100 columns.
v4: https://lore.kernel.org/linux-input/[email protected]/
- Add msi_suspend/claw_suspend.
- Reorder claw_remove to cancel all work before removing sysfs.
- Add mutex lock for removing sysfs attributes.
- Add mutex lock for MODE command data read/write.
- Change dev_warn to dev_dbg in claw_profile_event.
- use __free with DEFINE_FREE macro for argv instead of manually
running argv_free, cleaining up scoped_guard goto.
- Fix frame_calc validity check to use >=.
- Use spinlock instead of mutex in raw_event and related attribute
_store function.
- Ensure delayed work is canceled in suspend & canceled before sysfs attribute removal.
v3: https://lore.kernel.org/linux-input/[email protected]/
- Add mutex for read/write if rgb frame data.
- Ensure claw_hw_output_report is properly guarded.
- Remove setting rgb_frame_count when reading rgb profiles as it always returns garbage data.
- Ensure rgb_speed is getting drvdata from a valid lookup (not hdev).
- Use scoped_guard where necessary.
- Reoder claw_probe to ensure all mutex, completion, and variable assignments are in place prior to setting drvdata.
- Ensure gamepad_mode is set to a valid enum value in claw_probe.
v2: https://lore.kernel.org/linux-input/[email protected]/
- Use mutexes to guard SYNC_TO_ROM calls and pending_profile calls.
- Rename driver to hid-msi and add generic entrypoints for probe/resume/remove that call claw specific functions in order to
future proof the driver for other MSI HID interfaces.
- Fix various bugs and formatting issues.
v1: https://lore.kernel.org/linux-input/[email protected]/
Derek J. Clark (4):
HID: hid-msi: Add MSI Claw configuration driver
HID: hid-msi: Add M-key mapping attributes
HID: hid-msi: Add RGB control interface
HID: hid-msi: Add Rumble Intensity Attributes
MAINTAINERS | 6 + drivers/hid/Kconfig | 13 + drivers/hid/Makefile | 1 + drivers/hid/hid-ids.h | 5 + drivers/hid/hid-msi.c | 1998 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 2023 insertions(+) create mode 100644 drivers/hid/hid-msi.c
Signature · 1 line
2.53.0
Derek J. Clark
maintainerPATCH v11 1/4 HID: hid-msi: Add MSI Claw configuration driver
Adds configuration HID driver for the MSI Claw series of handheld PC's. In this initial patch add the initial driver outline and attributes for changing the gamepad mode, M-key behavior, and add a WO reset function.
Sending the SWITCH_MODE and RESET commands causes a USB disconnect in the device. The completion will therefore never get hit and would trigger an -EIO. To avoid showing the user an error for every write to these attrs a bypass for the completion handling is introduced when timeout == 0.
The initial version of this patch was written by Denis Benato, which contained the initial reverse-engineering and implementation for the gamepad mode switching. This work was later expanded by Zhouwang Huang to include more gamepad modes. Finally, I refactored the drivers data in/out flow and overall format to conform to kernel driver best practices and style guides. Claude was used as an initial reviewer of this patch.
---
v9:
- Don't use devm_device_add_group in cfg_setup_fn, do manual adding and cleanup to prevent possible use after free.
- Use scoped_guard instead of guard in claw_remove.
- Rename gamepad_registered to gp_registered for brevity.
v8:
- Use spinlock when accessing gamepad_registered.
- Clear state machine on all errors in claw_hw_output_report.
- Wrap all branches under single cmd_lock guard in claw_raw_event.
- Reject generic ACK in claw_raw_event if waiting_cmd is for another branch.
- Don't close hid devices that couldn't have been opened.
v7:
- Use smp_[store_release|load_acquire] pattern for checking gamepad_registered to avoid possible races during teardown.
- Reorder reinit_completion in claw_hw_output_report to avoid race with possible incoming ACKs.
- Reorder cancel_delayed_work_sync to ensure setup can't be re-armed after cancel.
- Reset command state machine if hw_output_report has an error.
- Add comments to (hopefully) silence sashinko-bot warnings about the use of endpoint matching and the impossible scenario of switching to the alternate endpoint from userspace while the driver is bound.
- Don't use spinlock_irqsave when already in irq context.
v6:
- Add send/ack pattern to ensure synchronous acks.
- Use spinlock_irqsave instead of mutex for read/write MODE event data.
- add select NEW_LEDS to kconfig.
- Make all timeouts 25ms to ensure at least 2 jiffies in a 100Hz config.
- Gate all attribute show/store functions with gamepad_registered, enabling use of devm_device_add_group.
- Re-arm cfg_setup in resume if it was canceled in an early suspend.
- Don't set gamepad_mode on resume, MCU preserves state.
- Ensure all count variables are checked for > 0 characters before setting buf - 1 to \n.
v5:
- Swap disabled & combination mkeys_function enum values.
- Ensure mode_mutex is properly init.
- Ensure claw_remove is calling hid_hw_close and not hid_hw_stop for all paths.
v4:
- Add msi_suspend/claw_suspend.
- Reorder claw_remove to cancel all work before removing sysfs.
- Add mutex lock for removing sysfs attributes.
- Add mutex lock for MODE command data read/write.
v3:
- Ensure claw_hw_output_report is properly guarded.
- Reoder claw_probe to ensure all mutex, completion, and variable assignments are in place prior to setting drvdata.
- Ensure gamepad_mode is set to a valid enum value in claw_probe.
v2:
- Rename driver to hid-msi from hid-msi-claw.
- Rename reusable/generic functions to msi_* from claw_*, retaining claw specific functions.
- Add generic entrypoints for probe, remove, and raw event that route to claw specific functions.
--- MAINTAINERS | 6 + drivers/hid/Kconfig | 13 + drivers/hid/Makefile | 1 + drivers/hid/hid-ids.h | 5 + drivers/hid/hid-msi.c | 710 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 735 insertions(+) create mode 100644 drivers/hid/hid-msi.c
MAINTAINERS +6 -0
@@ -17965,6 +17965,12 @@ S: Odd Fixes F: Documentation/devicetree/bindings/net/ieee802154/mrf24j40.txt F: drivers/net/ieee802154/mrf24j40.c +MSI HID DRIVER +M: Derek J. Clark <[email protected]> +L: [email protected] +S: Maintained +F: drivers/hid/hid-msi.c + MSI EC DRIVER M: Nikita Kravets <[email protected]> L: [email protected]
drivers/hid/Kconfig +13 -0
@@ -492,6 +492,19 @@ config HID_GT683R Currently the following devices are know to be supported: - MSI GT683R +config HID_MSI + tristate "MSI Claw Gamepad Support" + depends on USB_HID + select NEW_LEDS + select LEDS_CLASS + select LEDS_CLASS_MULTICOLOR + help + Support for the MSI Claw RGB and controller configuration + + Say Y here to include configuration interface support for the MSI Claw Line + of Handheld Console Controllers. Say M here to compile this driver as a + module. The module will be called hid-msi. + config HID_KEYTOUCH tristate "Keytouch HID devices" help
drivers/hid/Makefile +1 -0
@@ -92,6 +92,7 @@ obj-$(CONFIG_HID_MAYFLASH) += hid-mf.o obj-$(CONFIG_HID_MEGAWORLD_FF) += hid-megaworld.o obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o +obj-$(CONFIG_HID_MSI) += hid-msi.o obj-$(CONFIG_HID_MULTITOUCH) += hid-multitouch.o obj-$(CONFIG_HID_NINTENDO) += hid-nintendo.o obj-$(CONFIG_HID_NTI) += hid-nti.o
drivers/hid/hid-ids.h +5 -0
@@ -1047,7 +1047,12 @@#define USB_DEVICE_ID_MOZA_R16_R21_2 0x0010#define USB_VENDOR_ID_MSI 0x1770 +#define USB_VENDOR_ID_MSI_2 0x0db0#define USB_DEVICE_ID_MSI_GT683R_LED_PANEL 0xff00 +#define USB_DEVICE_ID_MSI_CLAW_XINPUT 0x1901 +#define USB_DEVICE_ID_MSI_CLAW_DINPUT 0x1902 +#define USB_DEVICE_ID_MSI_CLAW_DESKTOP 0x1903 +#define USB_DEVICE_ID_MSI_CLAW_BIOS 0x1904#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400#define USB_DEVICE_ID_N_S_HARMONY 0xc359
drivers/hid/hid-msi.c new file +710 -0
710 lines not on this page · raw message
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v11 1/4] HID: hid-msi: Add MSI Claw configuration driver
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] Mixing `goto`-based error handling with scope-based cleanup (`__free`/`guard`). - [High] TOCTOU…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] Mixing goto-based error handling with scope-based cleanup (__free/guard).
- [High] TOCTOU race condition causing lost device configuration updates. --
commit 5c893bbc0296560ff4fc46c1a17db05f45daeaf6
Author: Derek J. Clark <[email protected]>
HID: hid-msi: Add MSI Claw configuration driver
This commit adds a configuration HID driver for the MSI Claw series of handheld PCs. It introduces sysfs attributes to change the gamepad mode, M-key behavior, and perform a device reset.
Quoted 4 lines
drivers/hid/hid-msi.c new file +0
-0
[ ... ]
Quoted 5 lines
drivers/hid/hid-msi.c new file +5
-0+static int claw_hw_output_report (struct hid_device *hdev,u8 index,u8 *data, +size_t len,unsigned int timeout) +{ + unsigned char *dmabuf __free(kfree) = NULL; +u8 header[] = {CLAW_OUTPUT_REPORT_ID ,0 ,0 ,0x3c , index };
[ ... ]
Quoted 2 lines
drivers/hid/hid-msi.c new file +2
-0+guard (mutex)(&drvdata->cfg_mutex); +if (timeout) {
[ ... ]
drivers/hid/hid-msi.c line 236
Quoted 3 lines
drivers/hid/hid-msi.c new file +3
-0+ ret =hid_hw_output_report (hdev, dmabuf,CLAW_PACKET_SIZE ); +if (ret <0 ) + goto err_clear_state;
[Severity: High]
Is it intended to mix goto-based error handling with scope-based cleanup in this function?
The cleanup subsystem guidelines mention that functions should either convert all resources that need cleanup to scope-based cleanup, or convert none of them. Using guard and __free alongside a goto label can create confusing ownership and lock lifetime semantics.
Could this be converted entirely to scope-based cleanup?
Quoted 4 lines
drivers/hid/hid-msi.c new file +4
-0+ + ret = ret ==CLAW_PACKET_SIZE ?0 : -EIO ; +if (ret) + goto err_clear_state;
[ ... ]
Quoted 9 lines
drivers/hid/hid-msi.c new file +9
-0+err_clear_state: +if (timeout) { +guard (spinlock_irqsave)(&drvdata->cmd_lock); + drvdata->waiting_cmd =CLAW_COMMAND_TYPE_NONE ; + drvdata->waiting_for_ack = false; + } + +return ret; +}
[ ... ]
Quoted 3 lines
drivers/hid/hid-msi.c new file +3
-0+static ssize_t gamepad_mode_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t count) +{
[ ... ]
drivers/hid/hid-msi.c line 287
Quoted 5 lines
drivers/hid/hid-msi.c new file +5
-0+ data[0 ] = ret; +scoped_guard (spinlock_irqsave, &drvdata->mode_lock) + data[1] = drvdata->mkeys_function; + + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SWITCH_MODE , data,ARRAY_SIZE (data),0 );
[Severity: High]
Does this sequence introduce a time-of-check to time-of-use race condition?
The current state of mkeys_function is read while holding mode_lock, but the lock is released before claw_hw_output_report() acquires cfg_mutex. If two threads concurrently write to gamepad_mode and mkeys_function, both could read the other's state before either acquires cfg_mutex.
This could result in the second thread sending a command that uses stale data, silently reverting the first thread's update when the device acknowledges the command.
Should the read of the current state and the device update be atomic under a single lock?
Quoted 5 lines
drivers/hid/hid-msi.c new file +5
-0+if (ret) +return ret; + +return count; +}
[ ... ]
Quoted 3 lines
drivers/hid/hid-msi.c new file +3
-0+static ssize_t mkeys_function_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t count) +{
[ ... ]
drivers/hid/hid-msi.c line 367
Quoted 5 lines
drivers/hid/hid-msi.c new file +5
-0+scoped_guard (spinlock_irqsave, &drvdata->mode_lock) + data[0] = drvdata->gamepad_mode; + data[1 ] = ret; + + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SWITCH_MODE , data,ARRAY_SIZE (data),0 );
[Severity: High]
A similar sequence happens here. Can concurrent writes to these attributes lead to lost device configuration updates due to the locks being acquired and released separately?
Quoted 5 lines
drivers/hid/hid-msi.c new file +5
-0+if (ret) +return ret; + +return count; +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Derek J. Clark
maintainerPATCH v11 2/4 HID: hid-msi: Add M-key mapping attributes
In reply to Derek J. ClarkAdds attributes that allow for remapping the M-keys with up to 5 values when in macro mode. There are 2 mappable buttons on the rear of the device, M1 on the right and M2 on the left. When mapped, the events will fire from one of three event devices: gamepad buttons will fire from the device handled by xpad, while keyboard and mouse events will fire from respectively typed evdevs provided by the input core. Names of each mapping have been kept as close to the event that will fire from the evdev as possible, with context added to the ABS_ events on the direction of the movement.
Initial reverse-engineering and implementation of this feature was done by Zhouwang Huang. I refactored the overall format to conform to kernel driver best practices and style guides. Claude was used as an initial reviewer of this patch.
---
v10:
- Remove additional gamepad_registered variable left over after rename to gp_registered.
v8:
- Wrap all branches under single cmd_lock guard in claw_raw_event.
- Reject generic ACK in claw_raw_event if waiting_cmd is for another branch.
v7:
- Use smp_[store_release|load_acquire] pattern for checking gamepad_registered to avoid possible races during teardown.
- Add profile_lock for read/write profile_pending.
- Match on write address for mkey reports to prevent late ACK from causing synchronization errors.
- Use struct for mkey reports.
v6:
- Make all timeouts 25ms to ensure at least 2 jiffies in a 100Hz config.
- Gate all attribute show/store functions with gamepad_registered.
- Remove duplicated argv_free macro.
v5:
- Ensure adding "DISABLED" key to valid entries is done in the correct patch.
- Re-enable sending an empty string to clear button mappings in addition to setting DISABLED.
v4:
- Change dev_warn to dev_dbg in claw_profile_event.
- use __free with DEFINE_FREE macro for argv instead of manually running argv_free, cleaining up scoped_guard goto.
v3:
- Use scoped_guard where necessary.
v2:
- Add mutex for SYNC_TO_ROM commands to ensure every SYNC is completed before more data is written to the MCU volatile memory.
- Add mutex for profile_pending to ensure every profile action response is serialized to the generating command.
--- drivers/hid/hid-msi.c | 448 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 446 insertions(+), 2 deletions(-)
drivers/hid/hid-msi.c +446 -2
@@ -42,6 +42,8 @@#define CLAW_DINPUT_CFG_INTF_IN 0x82#define CLAW_XINPUT_CFG_INTF_IN 0x83 +#define CLAW_KEYS_MAX 5 +enum claw_command_index {CLAW_COMMAND_TYPE_NONE =0x00 ,CLAW_COMMAND_TYPE_READ_PROFILE =0x04 ,
@@ -67,6 +69,17 @@ static const char * const claw_gamepad_mode_text[] = { [CLAW_GAMEPAD_MODE_DESKTOP] = "desktop", }; +enum claw_profile_ack_pending { +CLAW_NO_PENDING , +CLAW_M1_PENDING , +CLAW_M2_PENDING , +}; + +enum claw_key_index { +CLAW_KEY_M1 , +CLAW_KEY_M2 , +}; +enum claw_mkeys_function_index {CLAW_MKEY_FUNCTION_MACRO ,CLAW_MKEY_FUNCTION_DISABLED ,
@@ -79,6 +92,155 @@ static const char * const claw_mkeys_function_text[] = { [CLAW_MKEY_FUNCTION_COMBO] = "combination", }; +static const struct { +u8 code; +const char *name; +} claw_button_mapping_key_map[] = { +/* Gamepad buttons */ + {0x01 ,"ABS_HAT0Y_UP" }, + {0x02 ,"ABS_HAT0Y_DOWN" }, + {0x03 ,"ABS_HAT0X_LEFT" }, + {0x04 ,"ABS_HAT0X_RIGHT" }, + {0x05 ,"BTN_TL" }, + {0x06 ,"BTN_TR" }, + {0x07 ,"BTN_THUMBL" }, + {0x08 ,"BTN_THUMBR" }, + {0x09 ,"BTN_SOUTH" }, + {0x0a ,"BTN_EAST" }, + {0x0b ,"BTN_NORTH" }, + {0x0c ,"BTN_WEST" }, + {0x0d ,"BTN_MODE" }, + {0x0e ,"BTN_SELECT" }, + {0x0f ,"BTN_START" }, + {0x13 ,"BTN_TL2" }, + {0x14 ,"BTN_TR2" }, + {0x15 ,"ABS_Y_UP" }, + {0x16 ,"ABS_Y_DOWN" }, + {0x17 ,"ABS_X_LEFT" }, + {0x18 ,"ABS_X_RIGHT" }, + {0x19 ,"ABS_RY_UP" }, + {0x1a ,"ABS_RY_DOWN" }, + {0x1b ,"ABS_RX_LEFT" }, + {0x1c ,"ABS_RX_RIGHT" }, +/* Keyboard keys */ + {0x32 ,"KEY_ESC" }, + {0x33 ,"KEY_F1" }, + {0x34 ,"KEY_F2" }, + {0x35 ,"KEY_F3" }, + {0x36 ,"KEY_F4" }, + {0x37 ,"KEY_F5" }, + {0x38 ,"KEY_F6" }, + {0x39 ,"KEY_F7" }, + {0x3a ,"KEY_F8" }, + {0x3b ,"KEY_F9" }, + {0x3c ,"KEY_F10" }, + {0x3d ,"KEY_F11" }, + {0x3e ,"KEY_F12" }, + {0x3f ,"KEY_GRAVE" }, + {0x40 ,"KEY_1" }, + {0x41 ,"KEY_2" }, + {0x42 ,"KEY_3" }, + {0x43 ,"KEY_4" }, + {0x44 ,"KEY_5" }, + {0x45 ,"KEY_6" }, + {0x46 ,"KEY_7" }, + {0x47 ,"KEY_8" }, + {0x48 ,"KEY_9" }, + {0x49 ,"KEY_0" }, + {0x4a ,"KEY_MINUS" }, + {0x4b ,"KEY_EQUAL" }, + {0x4c ,"KEY_BACKSPACE" }, + {0x4d ,"KEY_TAB" }, + {0x4e ,"KEY_Q" }, + {0x4f ,"KEY_W" }, + {0x50 ,"KEY_E" }, + {0x51 ,"KEY_R" }, + {0x52 ,"KEY_T" }, + {0x53 ,"KEY_Y" }, + {0x54 ,"KEY_U" }, + {0x55 ,"KEY_I" }, + {0x56 ,"KEY_O" }, + {0x57 ,"KEY_P" }, + {0x58 ,"KEY_LEFTBRACE" }, + {0x59 ,"KEY_RIGHTBRACE" }, + {0x5a ,"KEY_BACKSLASH" }, + {0x5b ,"KEY_CAPSLOCK" }, + {0x5c ,"KEY_A" }, + {0x5d ,"KEY_S" }, + {0x5e ,"KEY_D" }, + {0x5f ,"KEY_F" }, + {0x60 ,"KEY_G" }, + {0x61 ,"KEY_H" }, + {0x62 ,"KEY_J" }, + {0x63 ,"KEY_K" }, + {0x64 ,"KEY_L" }, + {0x65 ,"KEY_SEMICOLON" }, + {0x66 ,"KEY_APOSTROPHE" }, + {0x67 ,"KEY_ENTER" }, + {0x68 ,"KEY_LEFTSHIFT" }, + {0x69 ,"KEY_Z" }, + {0x6a ,"KEY_X" }, + {0x6b ,"KEY_C" }, + {0x6c ,"KEY_V" }, + {0x6d ,"KEY_B" }, + {0x6e ,"KEY_N" }, + {0x6f ,"KEY_M" }, + {0x70 ,"KEY_COMMA" }, + {0x71 ,"KEY_DOT" }, + {0x72 ,"KEY_SLASH" }, + {0x73 ,"KEY_RIGHTSHIFT" }, + {0x74 ,"KEY_LEFTCTRL" }, + {0x75 ,"KEY_LEFTMETA" }, + {0x76 ,"KEY_LEFTALT" }, + {0x77 ,"KEY_SPACE" }, + {0x78 ,"KEY_RIGHTALT" }, + {0x79 ,"KEY_RIGHTCTRL" }, + {0x7a ,"KEY_INSERT" }, + {0x7b ,"KEY_HOME" }, + {0x7c ,"KEY_PAGEUP" }, + {0x7d ,"KEY_DELETE" }, + {0x7e ,"KEY_END" }, + {0x7f ,"KEY_PAGEDOWN" }, + {0x8a ,"KEY_KPENTER" }, + {0x8b ,"KEY_KP0" }, + {0x8c ,"KEY_KP1" }, + {0x8d ,"KEY_KP2" }, + {0x8e ,"KEY_KP3" }, + {0x8f ,"KEY_KP4" }, + {0x90 ,"KEY_KP5" }, + {0x91 ,"KEY_KP6" }, + {0x92 ,"KEY_KP7" }, + {0x93 ,"KEY_KP8" }, + {0x94 ,"KEY_KP9" }, + {0x95 ,"MD_PLAY" }, + {0x96 ,"MD_STOP" }, + {0x97 ,"MD_NEXT" }, + {0x98 ,"MD_PREV" }, + {0x99 ,"MD_VOL_UP" }, + {0x9a ,"MD_VOL_DOWN" }, + {0x9b ,"MD_VOL_MUTE" }, + {0x9c ,"KEY_F23" }, +/* Mouse events */ + {0xc8 ,"BTN_LEFT" }, + {0xc9 ,"BTN_MIDDLE" }, + {0xca ,"BTN_RIGHT" }, + {0xcb ,"BTN_SIDE" }, + {0xcc ,"BTN_EXTRA" }, + {0xcd ,"REL_WHEEL_UP" }, + {0xce ,"REL_WHEEL_DOWN" }, + {0xff ,"DISABLED" }, +}; + +static const u16 button_mapping_addr_old[] = { +0x007a ,/* M1 */ +0x011f ,/* M2 */ +}; + +static const u16 button_mapping_addr_new[] = { +0x00bb ,/* M1 */ +0x0164 ,/* M2 */ +}; +struct claw_command_report {u8 report_id;u8 padding[2 ];
@@ -87,25 +249,47 @@ struct claw_command_report {u8 data[59 ]; } __packed; +struct claw_profile_report { +u8 profile; +__be16 read_addr; +} __packed; + +struct claw_mkey_report { +struct claw_profile_report ; +u8 padding_0; +u8 padding_1; +u8 padding_2; +u8 codes[5 ]; +} __packed; +struct claw_drvdata {/* MCU General Variables */ +enum claw_profile_ack_pending profile_pending;struct completion send_cmd_complete;struct delayed_work cfg_resume;struct delayed_work cfg_setup;spinlock_t registration_lock;/* Lock for registration read/write */ +struct mutex profile_mutex;/* mutex for profile_pending calls */ +spinlock_t profile_lock;/* Lock for profile_pending read/write */ struct hid_device *hdev;struct mutex cfg_mutex;/* mutex for synchronous data */ +struct mutex rom_mutex;/* mutex for SYNC_TO_ROM calls */ bool waiting_for_ack;spinlock_t cmd_lock;/* Lock for cmd data read/write */ u8 waiting_cmd;int cmd_status; +u16 bcd_device;u8 ep;/* Gamepad Variables */ enum claw_mkeys_function_index mkeys_function;enum claw_gamepad_mode_index gamepad_mode; +u8 m1_codes[CLAW_KEYS_MAX ]; +u8 m2_codes[CLAW_KEYS_MAX ]; +const u16 *bmap_addr;spinlock_t mode_lock;/* Lock for mode data read/write */ bool gp_registered; +bool bmap_support; };static int get_endpoint_address (struct hid_device *hdev)
@@ -137,6 +321,39 @@ static int claw_gamepad_mode_event(struct claw_drvdata *drvdata,return 0 ; } +static int claw_profile_event (struct claw_drvdata *drvdata,struct claw_command_report *cmd_rep) +{ +enum claw_profile_ack_pending profile; +struct claw_mkey_report *mkeys; +u8 *codes, key; +int i; + +scoped_guard (spinlock, &drvdata->profile_lock) + profile = drvdata->profile_pending; + +switch (profile) { +case CLAW_M1_PENDING : +case CLAW_M2_PENDING : + key = (profile ==CLAW_M1_PENDING ) ?CLAW_KEY_M1 :CLAW_KEY_M2 ; + mkeys = (struct claw_mkey_report *)cmd_rep->data; +if (be16_to_cpu (mkeys->read_addr) != drvdata->bmap_addr[key]) +return -EINVAL ; + codes = (profile ==CLAW_M1_PENDING ) ? drvdata->m1_codes : drvdata->m2_codes; +for (i =0 ; i <CLAW_KEYS_MAX ; i++) + codes[i] = (mkeys->codes[i]); +break ; +default : +dev_dbg (&drvdata->hdev->dev, +"Got profile event without changes pending from command: %x\n" , + cmd_rep->cmd); +return -EINVAL ; + } +scoped_guard (spinlock, &drvdata->profile_lock) + drvdata->profile_pending = CLAW_NO_PENDING; + +return 0 ; +} +static int claw_raw_event (struct claw_drvdata *drvdata,struct hid_report *report,u8 *data,int size) {
@@ -165,9 +382,20 @@ static int claw_raw_event(struct claw_drvdata *drvdata, struct hid_report *reporcomplete (&drvdata->send_cmd_complete); } +break ; +case CLAW_COMMAND_TYPE_READ_PROFILE_ACK : + ret =claw_profile_event (drvdata, cmd_rep); +if (drvdata->waiting_for_ack && + drvdata->waiting_cmd ==CLAW_COMMAND_TYPE_READ_PROFILE ) { + drvdata->cmd_status = ret; + drvdata->waiting_for_ack = false; +complete (&drvdata->send_cmd_complete); + } +break ;case CLAW_COMMAND_TYPE_ACK : -if (drvdata->waiting_cmd ==CLAW_COMMAND_TYPE_READ_GAMEPAD_MODE ) +if (drvdata->waiting_cmd ==CLAW_COMMAND_TYPE_READ_PROFILE || + drvdata->waiting_cmd ==CLAW_COMMAND_TYPE_READ_GAMEPAD_MODE )break ;if (drvdata->waiting_for_ack) { drvdata->cmd_status =0 ;
@@ -442,6 +670,177 @@ static ssize_t reset_store(struct device *dev, struct device_attribute *attr, }static DEVICE_ATTR_WO (reset); +static int mkey_mapping_name_to_code (const char *name) +{ +int i; + +for (i =0 ; i <ARRAY_SIZE (claw_button_mapping_key_map); i++) { +if (!strcmp (name, claw_button_mapping_key_map[i].name)) +return claw_button_mapping_key_map[i].code; + } + +return -EINVAL ; +} + +static const char *mkey_mapping_code_to_name (u8 code) +{ +int i; + +if (code ==0xff ) +return NULL ; + +for (i =0 ; i <ARRAY_SIZE (claw_button_mapping_key_map); i++) { +if (claw_button_mapping_key_map[i].code == code) +return claw_button_mapping_key_map[i].name; + } + +return NULL ; +} + +static int claw_mkey_store (struct device *dev,const char *buf,u8 mkey) +{ +struct hid_device *hdev =to_hid_device (dev); +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +struct claw_mkey_report report = { {0x01 ,cpu_to_be16 (drvdata->bmap_addr[mkey])}, +0x07 ,0x04 ,0x00 , {0xff ,0xff ,0xff ,0xff ,0xff } }; + char **raw_keys __free(argv_free) = NULL; +int ret, key_count, i; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered)) +return -ENODEV ; + } + + raw_keys =argv_split (GFP_KERNEL , buf, &key_count); +if (!raw_keys) +return -ENOMEM ; + +if (key_count >CLAW_KEYS_MAX ) +return -EINVAL ; + +if (key_count ==0 ) + goto set_buttons; + +for (i =0 ; i < key_count; i++) { + ret =mkey_mapping_name_to_code (raw_keys[i]); +if (ret <0 ) +return ret; + + report.codes[i] = ret; + } + +set_buttons: + scoped_guard(mutex, &drvdata->rom_mutex) { + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; +/* MCU will not send ACK until the USB transaction completes. ACK is sent +* immediately after and will hit the stale state machine, before the next +* command re-arms the state machine. Timeout 0 ensures no deadlock waiting +* for ACK that ill never come. +*/ + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SYNC_TO_ROM ,NULL ,0 ,0 ); + } + +return ret; +} + +static int claw_mkey_show (struct device *dev,char *buf,enum claw_key_index m_key) +{ +struct hid_device *hdev =to_hid_device (dev); +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +struct claw_mkey_report report = { {0x01 ,cpu_to_be16 (drvdata->bmap_addr[m_key])},0x07 }; +int i, ret, count =0 ; +const char *name; +u8 *codes; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered)) +return -ENODEV ; + } + + codes = (m_key ==CLAW_KEY_M1 ) ? drvdata->m1_codes : drvdata->m2_codes; + +guard (mutex)(&drvdata->profile_mutex); +scoped_guard (spinlock_irqsave, &drvdata->profile_lock) + drvdata->profile_pending = (m_key == CLAW_KEY_M1) ? CLAW_M1_PENDING + :CLAW_M2_PENDING ; + + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_READ_PROFILE , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +for (i =0 ; i <CLAW_KEYS_MAX ; i++) { + name =mkey_mapping_code_to_name (codes[i]); +if (name) + count +=sysfs_emit_at (buf, count,"%s " , name); + } + +if (!count) +return sysfs_emit (buf,"(not set)\n" ); + + buf[count -1 ] ='\n' ; + +return count; +} + +static ssize_t button_m1_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t count) +{ +int ret; + + ret =claw_mkey_store (dev, buf,CLAW_KEY_M1 ); +if (ret) +return ret; + +return count; +} + +static ssize_t button_m1_show (struct device *dev,struct device_attribute *attr, +char *buf) +{ +return claw_mkey_show (dev, buf,CLAW_KEY_M1 ); +} +static DEVICE_ATTR_RW (button_m1); + +static ssize_t button_m2_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t count) +{ +int ret; + + ret =claw_mkey_store (dev, buf,CLAW_KEY_M2 ); +if (ret) +return ret; + +return count; +} + +static ssize_t button_m2_show (struct device *dev,struct device_attribute *attr, +char *buf) +{ +return claw_mkey_show (dev, buf,CLAW_KEY_M2 ); +} +static DEVICE_ATTR_RW (button_m2); + +static ssize_t button_mapping_options_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +int i, count =0 ; + +for (i =0 ; i <ARRAY_SIZE (claw_button_mapping_key_map); i++) + count +=sysfs_emit_at (buf, count,"%s " , claw_button_mapping_key_map[i].name); + +if (count) + buf[count -1 ] ='\n' ; + +return count; +} +static DEVICE_ATTR_RO (button_mapping_options); +static umode_t claw_gamepad_attr_is_visible (struct kobject *kobj,struct attribute *attr,int n) {
@@ -454,10 +853,22 @@ static umode_t claw_gamepad_attr_is_visible(struct kobject *kobj, struct attribureturn 0 ; } -return attr->mode; +/* Always show attrs available on all firmware */ +if (attr == &dev_attr_gamepad_mode.attr || + attr == &dev_attr_gamepad_mode_index.attr || + attr == &dev_attr_mkeys_function.attr || + attr == &dev_attr_mkeys_function_index.attr || + attr == &dev_attr_reset.attr) +return attr->mode; + +/* Hide button mapping attrs if it isn't supported */ +return drvdata->bmap_support ? attr->mode :0 ; }static struct attribute *claw_gamepad_attrs[] = { + &dev_attr_button_m1.attr, + &dev_attr_button_m2.attr, + &dev_attr_button_mapping_options.attr, &dev_attr_gamepad_mode.attr, &dev_attr_gamepad_mode_index.attr, &dev_attr_mkeys_function.attr,
@@ -510,8 +921,31 @@ static void cfg_resume_fn(struct work_struct *work)schedule_delayed_work (&drvdata->cfg_setup,msecs_to_jiffies (500 )); } +static void claw_features_supported (struct claw_drvdata *drvdata) +{ +u8 major = (drvdata->bcd_device >>8 ) &0xff ; +u8 minor = drvdata->bcd_device &0xff ; + +if (major ==0x01 ) { + drvdata->bmap_support = true; +if (minor >=0x66 ) + drvdata->bmap_addr = button_mapping_addr_new; +else + drvdata->bmap_addr = button_mapping_addr_old; +return ; + } + +if ((major ==0x02 && minor >=0x17 ) || major >=0x03 ) { + drvdata->bmap_support = true; + drvdata->bmap_addr = button_mapping_addr_new; +return ; + } +} +static int claw_probe (struct hid_device *hdev,u8 ep) { +struct usb_interface *intf =to_usb_interface (hdev->dev.parent); +struct usb_device *udev =interface_to_usbdev (intf);struct claw_drvdata *drvdata;int ret;
@@ -523,10 +957,20 @@ static int claw_probe(struct hid_device *hdev, u8 ep) drvdata->hdev = hdev; drvdata->ep = ep; +/* Determine feature level from firmware version */ + drvdata->bcd_device =le16_to_cpu (udev->descriptor.bcdDevice); +claw_features_supported (drvdata); + +if (!drvdata->bmap_support) +dev_dbg (&hdev->dev,"M-Key mapping is not supported. Update firmware to enable.\n" ); +mutex_init (&drvdata->cfg_mutex); +mutex_init (&drvdata->profile_mutex); +mutex_init (&drvdata->rom_mutex);spin_lock_init (&drvdata->registration_lock);spin_lock_init (&drvdata->cmd_lock);spin_lock_init (&drvdata->mode_lock); +spin_lock_init (&drvdata->profile_lock);init_completion (&drvdata->send_cmd_complete);INIT_DELAYED_WORK (&drvdata->cfg_resume, &cfg_resume_fn);INIT_DELAYED_WORK (&drvdata->cfg_setup, &cfg_setup_fn);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v11 2/4] HID: hid-msi: Add M-key mapping attributes
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] Timeout of READ_PROFILE commands leaves profile_pending dirty and falsely aborts subsequent…
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Timeout of READ_PROFILE commands leaves profile_pending dirty and falsely aborts subsequent requests due to unhandled stale ACKs.
- [High] Abandoning the ACK for CLAW_COMMAND_TYPE_SYNC_TO_ROM leaves a stale ACK in the USB input queue, falsely completing subsequent commands.
- [High] Unsafe spinlock acquisition without disabling interrupts in HID raw_event callback causes deadlocks.
--
commit ae4697cc229899bfbbf1b0ea18f1f026bc1b15e7
Author: Derek J. Clark <[email protected]>
HID: hid-msi: Add M-key mapping attributes
This commit adds attributes to allow remapping the M-keys with up to 5 values when the device is in macro mode. When mapped, these events can fire from the xpad device or the evdev interfaces provided by the input core.
Quoted 4 lines
drivers/hid/hid-msi.c +0
-0
[ ... ]
drivers/hid/hid-msi.c static int claw_gamepad_mode_event(struct claw_drvdata *drvdata, · line 331
Quoted 12 lines
drivers/hid/hid-msi.c +8
-0@@ -137,6 +321,39 @@ static int claw_gamepad_mode_event(struct claw_drvdata *drvdata,return 0 ; } +static int claw_profile_event (struct claw_drvdata *drvdata,struct claw_command_report *cmd_rep) +{ +enum claw_profile_ack_pending profile; +struct claw_mkey_report *mkeys; +u8 *codes, key; +int i; + +scoped_guard (spinlock, &drvdata->profile_lock)
^^^^^^^^
[Severity: High]
Could this cause a deadlock?
HID raw_event callbacks can be invoked from process context with IRQs enabled (e.g., when input is simulated via the uhid character device).
If an actual hardware interrupt (such as a USB URB completion) occurs on the same CPU while the lock is held in process context, the interrupt handler will invoke raw_event and attempt to reacquire profile_lock, resulting in a deadlock.
Should this use spinlock_irqsave instead?
Quoted 4 lines
drivers/hid/hid-msi.c +4
-0+ profile = drvdata->profile_pending; + +switch (profile) { +case CLAW_M1_PENDING :
[ ... ]
drivers/hid/hid-msi.c static int claw_gamepad_mode_event(struct claw_drvdata *drvdata, · line 351
Quoted 6 lines
drivers/hid/hid-msi.c +6
-0+dev_dbg (&drvdata->hdev->dev, +"Got profile event without changes pending from command: %x\n" , + cmd_rep->cmd); +return -EINVAL ; + } +scoped_guard (spinlock, &drvdata->profile_lock)
^^^^^^^^
[Severity: High]
Same question here, could this deadlock if interrupted by a hardware interrupt on the same CPU?
Quoted 4 lines
drivers/hid/hid-msi.c +4
-0+ drvdata->profile_pending =CLAW_NO_PENDING ; + +return 0 ; +}
[ ... ]
Quoted 2 lines
drivers/hid/hid-msi.c +2
-0+static int claw_mkey_store (struct device *dev,const char *buf,u8 mkey) +{
[ ... ]
drivers/hid/hid-msi.c static ssize_t reset_store(struct device *dev, struct device_attribute *attr, · line 744
Quoted 12 lines
drivers/hid/hid-msi.c +12
-0+set_buttons: + scoped_guard(mutex, &drvdata->rom_mutex) { + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; +/* MCU will not send ACK until the USB transaction completes. ACK is sent +* immediately after and will hit the stale state machine, before the next +* command re-arms the state machine. Timeout 0 ensures no deadlock waiting +* for ACK that ill never come. +*/ + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SYNC_TO_ROM ,NULL ,0 ,0 );
[Severity: High]
If the ACK for CLAW_COMMAND_TYPE_SYNC_TO_ROM is abandoned, could it leave a stale ACK in the USB input queue?
If userspace rapidly writes to the sysfs attributes (e.g., configuring button_m1 then button_m2), the second write would acquire rom_mutex, send WRITE_PROFILE_DATA, and set waiting_for_ack = true.
When the late ACK from the preceding SYNC_TO_ROM command arrives, claw_raw_event() might process it as a generic CLAW_COMMAND_TYPE_ACK and prematurely complete the wait for the new WRITE_PROFILE_DATA command.
The driver might then immediately send the next SYNC_TO_ROM while the MCU may still be processing the profile data, potentially leading to dropped configurations or MCU instability.
Quoted 4 lines
drivers/hid/hid-msi.c +4
-0+ } + +return ret; +}
[ ... ]
Quoted 3 lines
drivers/hid/hid-msi.c +3
-0+static int claw_mkey_show (struct device *dev,char *buf,enum claw_key_index m_key) +{ +struct hid_device *hdev =to_hid_device (dev);
[ ... ]
drivers/hid/hid-msi.c static ssize_t reset_store(struct device *dev, struct device_attribute *attr, · line 775
Quoted 9 lines
drivers/hid/hid-msi.c +9
-0+guard (mutex)(&drvdata->profile_mutex); +scoped_guard (spinlock_irqsave, &drvdata->profile_lock) + drvdata->profile_pending = (m_key == CLAW_KEY_M1) ? CLAW_M1_PENDING + :CLAW_M2_PENDING ; + + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_READ_PROFILE , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret;
[Severity: High]
If claw_hw_output_report() times out, could this leave profile_pending dirty?
If it returns early without resetting drvdata->profile_pending to CLAW_NO_PENDING, and another process subsequently invokes claw_mkey_show() for a different key, it would overwrite profile_pending and begin waiting for a new ACK.
If the late ACK from the initial timed-out request arrives during this window, claw_profile_event() processes it, detects an address mismatch (since it evaluates against the new profile_pending state), and returns -EINVAL.
claw_raw_event() would then blindly propagate this error to cmd_status and call complete(), falsely aborting the valid, ongoing read.
Quoted 3 lines
drivers/hid/hid-msi.c +3
-0+ +for (i =0 ; i <CLAW_KEYS_MAX ; i++) { + name =mkey_mapping_code_to_name (codes[i]);
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Derek J. Clark
maintainerPATCH v11 3/4 HID: hid-msi: Add RGB control interface
In reply to Derek J. ClarkAdds RGB control interface for MSI Claw devices. The MSI Claw uses a fairly unique RGB interface. It has 9 total zones (4 per joystick ring and 1 for the ABXY buttons), and supports up to 8 sequential frames of RGB zone data. Each frame is written to a specific area of MCU memory by the profile command, the value of which changes based on the firmware of the device. Unlike other devices (such as the Legion Go or the OneXPlayer devices), there are no hard coded effects built into the MCU. Instead, the basic effects are provided as a series of frame data. I have mirrored the effects available in Windows in this driver, while keeping the effect names consistent with the Lenovo drivers for the effects that are similar.
Initial reverse-engineering and implementation of this feature was done by Zhouwang Huang. I refactored the overall format to conform to kernel driver best practices and style guides. Claude was used as an initial reviewer of this patch.
---
v9:
- Limit guard usage in cfg_setup_fn to avoid holding a lock during registration and add group events.
- Don't use devm_ functions in cfg_setup_fn. Manually setup/teardown devices and groups to prevent use after free.
- Ensure rgb_queue work is canceled during suspend.
- Check for drvdata in rgb_queue_fn to avoid use after free during teardown.
v8:
- Ensure led_classdev is unregistered if adding attribute group fails.
- Reorder remove actions to ensure no use-after free or rearming cleared flags.
v7:
- Use smp_[store_release|load_acquire] pattern for checking rgb_registered to avoid possible races during teardown.
- Add gating to cfg_setup_fn, allowing either gamepad settings or rgb settings to populate if the other fails for any reason.
- Use spinlock when writing profile_pending.
v6:
- Make all timeouts 25ms to ensure at least 2 jiffies in a 100Hz config.
- Gate all attribute show/store functions with rgb_registered, enabling use of devm_device_add_group.
v5:
- Move adding the RGB device into cfg_setup to prevent led core attributes from being written to prior to setup completing.
- Ensure frame_lock is properly init.
- Change variable names in RGB functions from frame and zone to f and z respectively to fit all scoped_guard actions in 100 columns.
v4:
- Fix frame_calc validity check to use >=.
- USe spinlock instead of mutex in raw_event and related attribute _store function.
- Ensure delayed work is canceled in suspend & canceled before sysfs attribute removal.
v3:
- Add mutex for read/write of rgb frame data.
- Remove setting rgb_frame_count when reading rgb profiles as it always returns garbage data.
- Ensure rgb_speed is getting drvdata from a valid lookup (not hdev).
v2:
- Use pending_profile mutex
--- drivers/hid/hid-msi.c | 682 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 663 insertions(+), 19 deletions(-)
drivers/hid/hid-msi.c +663 -19
@@ -21,6 +21,7 @@#include <linux/device.h> #include <linux/hid.h> #include <linux/kobject.h> +#include <linux/led-class-multicolor.h> #include <linux/leds.h> #include <linux/module.h> #include <linux/mutex.h>
@@ -44,6 +45,10 @@#define CLAW_KEYS_MAX 5 +#define CLAW_RGB_ZONES 9 +#define CLAW_RGB_MAX_FRAMES 8 +#define CLAW_RGB_FRAME_OFFSET 0x24 +enum claw_command_index {CLAW_COMMAND_TYPE_NONE =0x00 ,CLAW_COMMAND_TYPE_READ_PROFILE =0x04 ,
@@ -73,6 +78,7 @@ enum claw_profile_ack_pending {CLAW_NO_PENDING ,CLAW_M1_PENDING ,CLAW_M2_PENDING , + CLAW_RGB_PENDING, }; enum claw_key_index {
@@ -231,6 +237,22 @@ static const struct { { 0xff, "DISABLED" }, }; +enum claw_rgb_effect_index { +CLAW_RGB_EFFECT_MONOCOLOR , +CLAW_RGB_EFFECT_BREATHE , +CLAW_RGB_EFFECT_CHROMA , +CLAW_RGB_EFFECT_RAINBOW , +CLAW_RGB_EFFECT_FROSTFIRE , +}; + +static const char *const claw_rgb_effect_text[] = { + [CLAW_RGB_EFFECT_MONOCOLOR ] ="monocolor" , + [CLAW_RGB_EFFECT_BREATHE ] ="breathe" , + [CLAW_RGB_EFFECT_CHROMA ] ="chroma" , + [CLAW_RGB_EFFECT_RAINBOW ] ="rainbow" , + [CLAW_RGB_EFFECT_FROSTFIRE ] ="frostfire" , +}; +static const u16 button_mapping_addr_old[] = {0x007a ,/* M1 */ 0x011f, /* M2 */
@@ -241,6 +263,9 @@ static const u16 button_mapping_addr_new[] = { 0x0164, /* M2 */ }; +static const u16 rgb_addr_old =0x01fa ; +static const u16 rgb_addr_new =0x024a ; +struct claw_command_report {u8 report_id;u8 padding[2 ];
@@ -262,6 +287,27 @@ struct claw_mkey_report {u8 codes[5 ]; } __packed; +struct rgb_zone { +u8 red; +u8 green; +u8 blue; +}; + +struct rgb_frame { +struct rgb_zone zone[CLAW_RGB_ZONES ]; +}; + +struct claw_rgb_report { +struct claw_profile_report ; +u8 frame_bytes; +u8 padding; +u8 frame_count; +u8 state;/* Always 0x09 */ +u8 speed; +u8 brightness; +struct rgb_frame zone_data; +} __packed; +struct claw_drvdata {/* MCU General Variables */ enum claw_profile_ack_pending profile_pending;
@@ -286,10 +332,22 @@ struct claw_drvdata {enum claw_gamepad_mode_index gamepad_mode;u8 m1_codes[CLAW_KEYS_MAX ];u8 m2_codes[CLAW_KEYS_MAX ]; -const u16 *bmap_addr;spinlock_t mode_lock;/* Lock for mode data read/write */ +const u16 *bmap_addr;bool gp_registered;bool bmap_support; + +/* RGB Variables */ +struct rgb_frame rgb_frames[CLAW_RGB_MAX_FRAMES ]; +enum claw_rgb_effect_index rgb_effect; +struct led_classdev_mc led_mc; +struct delayed_work rgb_queue; +spinlock_t frame_lock;/* lock for rgb_frames read/write */ +bool rgb_registered; +u8 rgb_frame_count; +bool rgb_enabled; +u8 rgb_speed; +u16 rgb_addr; };static int get_endpoint_address (struct hid_device *hdev)
@@ -325,8 +383,11 @@ static int claw_profile_event(struct claw_drvdata *drvdata, struct claw_command_ {enum claw_profile_ack_pending profile;struct claw_mkey_report *mkeys; -u8 *codes, key; -int i; +struct claw_rgb_report *frame; +u16 rgb_addr, read_addr; +u8 *codes, key, f_idx; +u16 frame_calc; +int i, ret =0 ;scoped_guard (spinlock, &drvdata->profile_lock) profile = drvdata->profile_pending;
@@ -342,6 +403,34 @@ static int claw_profile_event(struct claw_drvdata *drvdata, struct claw_command_for (i =0 ; i <CLAW_KEYS_MAX ; i++) codes[i] = (mkeys->codes[i]);break ; +case CLAW_RGB_PENDING : + frame = (struct claw_rgb_report *)cmd_rep->data; + rgb_addr = drvdata->rgb_addr; + read_addr =be16_to_cpu (frame->read_addr); + frame_calc = (read_addr - rgb_addr) /CLAW_RGB_FRAME_OFFSET ; +if (frame_calc >=CLAW_RGB_MAX_FRAMES ) { +dev_err (&drvdata->hdev->dev,"Got unsupported frame index: %x\n" , + frame_calc); +return -EINVAL ; + } + f_idx = frame_calc; + + scoped_guard(spinlock, &drvdata->frame_lock) { +memcpy (&drvdata->rgb_frames[f_idx], &frame->zone_data, +sizeof (struct rgb_frame )); + +/* Only use frame 0 for remaining variable assignment */ +if (f_idx !=0 ) +break ; + + drvdata->rgb_speed = frame->speed; + drvdata->led_mc.led_cdev.brightness = frame->brightness; + drvdata->led_mc.subled_info[0 ].intensity = frame->zone_data.zone[0 ].red; + drvdata->led_mc.subled_info[1 ].intensity = frame->zone_data.zone[0 ].green; + drvdata->led_mc.subled_info[2 ].intensity = frame->zone_data.zone[0 ].blue; + } + +break ;default : dev_dbg(&drvdata->hdev->dev, "Got profile event without changes pending from command: %x\n",
@@ -351,7 +440,7 @@ static int claw_profile_event(struct claw_drvdata *drvdata, struct claw_command_scoped_guard (spinlock, &drvdata->profile_lock) drvdata->profile_pending = CLAW_NO_PENDING; -return 0 ; +return ret; } static int claw_raw_event(struct claw_drvdata *drvdata, struct hid_report *report,
@@ -707,7 +796,7 @@ static int claw_mkey_store(struct device *dev, const char *buf, u8 mkey)int ret, key_count, i; scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { -/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ if (!smp_load_acquire (&drvdata->gp_registered))return -ENODEV ; }
@@ -757,7 +846,7 @@ static int claw_mkey_show(struct device *dev, char *buf, enum claw_key_index m_ku8 *codes; scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { -/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ if (!smp_load_acquire (&drvdata->gp_registered))return -ENODEV ; }
@@ -882,32 +971,553 @@ static const struct attribute_group claw_gamepad_attr_group = { .is_visible = claw_gamepad_attr_is_visible, }; +/* Read RGB config from device */ +static int claw_read_rgb_config (struct hid_device *hdev) +{ +u8 data[4 ] = {0x01 ,0x00 ,0x00 ,CLAW_RGB_FRAME_OFFSET }; +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +u16 read_addr = drvdata->rgb_addr; +size_t len =ARRAY_SIZE (data); +int ret, i; + +if (!drvdata->rgb_addr) +return -ENODEV ; + +/* Loop through all 8 pages of RGB data */ +guard (mutex)(&drvdata->profile_mutex); +for (i =0 ; i <CLAW_RGB_MAX_FRAMES ; i++) { +scoped_guard (spinlock_irqsave, &drvdata->profile_lock) + drvdata->profile_pending = CLAW_RGB_PENDING; + data[1 ] = (read_addr >>8 ) &0xff ; + data[2 ] = read_addr &0x00ff ; + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_READ_PROFILE , data, len,25 ); +if (ret) +return ret; + + read_addr +=CLAW_RGB_FRAME_OFFSET ; + } + +return 0 ; +} + +/* Send RGB configuration to device */ +static int claw_write_rgb_state (struct claw_drvdata *drvdata) +{ +struct claw_rgb_report report = { {0x01 ,0 },CLAW_RGB_FRAME_OFFSET ,0x00 , + drvdata->rgb_frame_count,0x09 , drvdata->rgb_speed, + drvdata->led_mc.led_cdev.brightness }; +u16 write_addr = drvdata->rgb_addr; +int f, ret; + +if (!drvdata->rgb_addr) +return -ENODEV ; + +if (!drvdata->rgb_frame_count) +return -EINVAL ; + +guard (mutex)(&drvdata->rom_mutex); +/* Loop through (up to) 8 pages of RGB data */ +for (f =0 ; f < drvdata->rgb_frame_count; f++) { +scoped_guard (spinlock_irqsave, &drvdata->frame_lock) + report.zone_data = drvdata->rgb_frames[f]; + +/* Set the MCU address to write the frame data to */ + report.read_addr =cpu_to_be16 (write_addr); + +/* Serialize the rgb_report and write it to MCU */ + ret =claw_hw_output_report (drvdata->hdev,CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +/* Increment the write addr by the offset for the next frame */ + write_addr +=CLAW_RGB_FRAME_OFFSET ; + } + +/* MCU will not send ACK until the USB transaction completes. ACK is sent +* immediately after and will hit the stale state machine, before the next +* command re-arms the state machine. Timeout 0 ensures no deadlock waiting +* for ACK that ill never come. +*/ + ret =claw_hw_output_report (drvdata->hdev,CLAW_COMMAND_TYPE_SYNC_TO_ROM ,NULL ,0 ,0 ); + +return ret; +} + +/* Fill all zones with the same color */ +static void claw_frame_fill_solid (struct rgb_frame *frame,struct rgb_zone zone) +{ +int z; + +for (z =0 ; z <CLAW_RGB_ZONES ; z++) + frame->zone[z] = zone; +} + +/* Apply solid effect (1 frame, no color) */ +static int claw_apply_disabled (struct claw_drvdata *drvdata) +{ +struct rgb_zone off = {0x00 ,0x00 ,0x00 }; + + scoped_guard(spinlock_irqsave, &drvdata->frame_lock) { + drvdata->rgb_frame_count =1 ; +claw_frame_fill_solid (&drvdata->rgb_frames[0 ], off); + } + +return claw_write_rgb_state (drvdata); +} + +/* Apply solid effect (1 frame, all zones same color) */ +static int claw_apply_monocolor (struct claw_drvdata *drvdata) +{ +struct mc_subled *subleds = drvdata->led_mc.subled_info; +struct rgb_zone zone = { subleds[0 ].intensity, subleds[1 ].intensity, + subleds[2 ].intensity }; + + scoped_guard(spinlock_irqsave, &drvdata->frame_lock) { + drvdata->rgb_frame_count =1 ; +claw_frame_fill_solid (&drvdata->rgb_frames[0 ], zone); + } + +return claw_write_rgb_state (drvdata); +} + +/* Apply breathe effect (2 frames: color -> off) */ +static int claw_apply_breathe (struct claw_drvdata *drvdata) +{ +struct mc_subled *subleds = drvdata->led_mc.subled_info; +struct rgb_zone zone = { subleds[0 ].intensity, subleds[1 ].intensity, + subleds[2 ].intensity }; +static const struct rgb_zone off = {0 ,0 ,0 }; + + scoped_guard(spinlock_irqsave, &drvdata->frame_lock) { + drvdata->rgb_frame_count =2 ; +claw_frame_fill_solid (&drvdata->rgb_frames[0 ], zone); +claw_frame_fill_solid (&drvdata->rgb_frames[1 ], off); + } + +return claw_write_rgb_state (drvdata); +} + +/* Apply chroma effect (6 frames: rainbow cycle, all zones sync) */ +static int claw_apply_chroma (struct claw_drvdata *drvdata) +{ +static const struct rgb_zone colors[] = { + {255 ,0 ,0 },/* red */ + {255 ,255 ,0 },/* yellow */ + {0 ,255 ,0 },/* green */ + {0 ,255 ,255 },/* cyan */ + {0 ,0 ,255 },/* blue */ + {255 ,0 ,255 },/* magenta */ + }; +u8 frame_count =ARRAY_SIZE (colors); +int f; + + scoped_guard(spinlock_irqsave, &drvdata->frame_lock) { + drvdata->rgb_frame_count = frame_count; + +for (f =0 ; f < frame_count; f++) +claw_frame_fill_solid (&drvdata->rgb_frames[f], colors[f]); + } + +return claw_write_rgb_state (drvdata); +} + +/* Apply rainbow effect (4 frames: rotating colors around joysticks) */ +static int claw_apply_rainbow (struct claw_drvdata *drvdata) +{ +static const struct rgb_zone colors[] = { + {255 ,0 ,0 },/* red */ + {0 ,255 ,0 },/* green */ + {0 ,255 ,255 },/* cyan */ + {0 ,0 ,255 },/* blue */ + }; +u8 frame_count =ARRAY_SIZE (colors); +int f, z; + + scoped_guard(spinlock_irqsave, &drvdata->frame_lock) { + drvdata->rgb_frame_count = frame_count; + +for (f =0 ; f < frame_count; f++) { +for (z =0 ; z <4 ; z++) { + drvdata->rgb_frames[f].zone[z] = colors[(z + f) %4 ]; + drvdata->rgb_frames[f].zone[z +4 ] = colors[(z + f) %4 ]; + } + drvdata->rgb_frames[f].zone[8 ] = colors[f]; + } + } + +return claw_write_rgb_state (drvdata); +} + +/* +* Apply frostfire effect (4 frames: fire vs ice rotating) +* Right joystick: fire red -> dark -> ice blue -> dark (clockwise) +* Left joystick: ice blue -> dark -> fire red -> dark (counter-clockwise) +* ABXY: fire red -> dark -> ice blue -> dark +*/ +static int claw_apply_frostfire (struct claw_drvdata *drvdata) +{ +static const struct rgb_zone colors[] = { + {255 ,0 ,0 },/* fire red */ + {0 ,0 ,0 },/* dark */ + {0 ,0 ,255 },/* ice blue */ + {0 ,0 ,0 },/* dark */ + }; +u8 frame_count =ARRAY_SIZE (colors); +int f, z; + + scoped_guard(spinlock_irqsave, &drvdata->frame_lock) { + drvdata->rgb_frame_count = frame_count; + +for (f =0 ; f < frame_count; f++) { +for (z =0 ; z <4 ; z++) { + drvdata->rgb_frames[f].zone[z] = colors[(z + f) %4 ]; + drvdata->rgb_frames[f].zone[z +4 ] = colors[(z - f +6 ) %4 ]; + } + drvdata->rgb_frames[f].zone[8 ] = colors[f]; + } + } + +return claw_write_rgb_state (drvdata); +} + +/* Apply current state to device */ +static int claw_apply_rgb_state (struct claw_drvdata *drvdata) +{ +if (!drvdata->rgb_enabled) +return claw_apply_disabled (drvdata); + +switch (drvdata->rgb_effect) { +case CLAW_RGB_EFFECT_MONOCOLOR : +return claw_apply_monocolor (drvdata); +case CLAW_RGB_EFFECT_BREATHE : +return claw_apply_breathe (drvdata); +case CLAW_RGB_EFFECT_CHROMA : +return claw_apply_chroma (drvdata); +case CLAW_RGB_EFFECT_RAINBOW : +return claw_apply_rainbow (drvdata); +case CLAW_RGB_EFFECT_FROSTFIRE : +return claw_apply_frostfire (drvdata); +default : +dev_err (drvdata->led_mc.led_cdev.dev, +"No supported rgb_effect selected\n" ); +return -EINVAL ; + } +} + +static void claw_rgb_queue_fn (struct work_struct *work) +{ + struct delayed_work *dwork = container_of(work, struct delayed_work, work); + struct claw_drvdata *drvdata = container_of(dwork, struct claw_drvdata, rgb_queue); +int ret; + +if (!drvdata) +return ; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return ; + } + + ret =claw_apply_rgb_state (drvdata); +if (ret) +dev_err (drvdata->led_mc.led_cdev.dev, +"Failed to apply RGB state: %d\n" , ret); +} + +static ssize_t effect_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{ +struct led_classdev *led_cdev =dev_get_drvdata (dev); + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); +int ret; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return -ENODEV ; + } + + ret =sysfs_match_string (claw_rgb_effect_text, buf); +if (ret <0 ) +return ret; + + drvdata->rgb_effect = ret; +mod_delayed_work (system_wq, &drvdata->rgb_queue,msecs_to_jiffies (50 )); + +return count; +} + +static ssize_t effect_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct led_classdev *led_cdev =dev_get_drvdata (dev); + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return -ENODEV ; + } + +if (drvdata->rgb_effect >=ARRAY_SIZE (claw_rgb_effect_text)) +return -EINVAL ; + +return sysfs_emit (buf,"%s\n" , claw_rgb_effect_text[drvdata->rgb_effect]); +} + +static DEVICE_ATTR_RW (effect); + +static ssize_t effect_index_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +int i, count =0 ; + +for (i =0 ; i <ARRAY_SIZE (claw_rgb_effect_text); i++) + count +=sysfs_emit_at (buf, count,"%s " , claw_rgb_effect_text[i]); + +if (count) + buf[count -1 ] ='\n' ; + +return count; +} +static DEVICE_ATTR_RO (effect_index); + +static ssize_t enabled_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{ +struct led_classdev *led_cdev =dev_get_drvdata (dev); + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); +bool val; +int ret; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return -ENODEV ; + } + + ret =kstrtobool (buf, &val); +if (ret) +return ret; + + drvdata->rgb_enabled = val; +mod_delayed_work (system_wq, &drvdata->rgb_queue,msecs_to_jiffies (50 )); + +return count; +} + +static ssize_t enabled_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct led_classdev *led_cdev =dev_get_drvdata (dev); + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return -ENODEV ; + } + +return sysfs_emit (buf,"%s\n" , drvdata->rgb_enabled ?"true" :"false" ); +} +static DEVICE_ATTR_RW (enabled); + +static ssize_t enabled_index_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"true false\n" ); +} +static DEVICE_ATTR_RO (enabled_index); + +static ssize_t speed_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t count) +{ +struct led_classdev *led_cdev =dev_get_drvdata (dev); + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); +unsigned int val, speed; +int ret; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return -ENODEV ; + } + + ret =kstrtouint (buf,10 , &val); +if (ret) +return ret; + +if (val >20 ) +return -EINVAL ; + +/* 0 is fastest, invert value for intuitive userspace speed */ + speed =20 - val; + + drvdata->rgb_speed = speed; +mod_delayed_work (system_wq, &drvdata->rgb_queue,msecs_to_jiffies (50 )); + +return count; +} + +static ssize_t speed_show (struct device *dev,struct device_attribute *attr, +char *buf) +{ +struct led_classdev *led_cdev =dev_get_drvdata (dev); + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); +u8 speed =20 - drvdata->rgb_speed; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return -ENODEV ; + } + +return sysfs_emit (buf,"%u\n" , speed); +} +static DEVICE_ATTR_RW (speed); + +static ssize_t speed_range_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"0-20\n" ); +} +static DEVICE_ATTR_RO (speed_range); + +static void claw_led_brightness_set (struct led_classdev *led_cdev, +enum led_brightness _brightness) +{ + struct led_classdev_mc *led_mc = container_of(led_cdev, struct led_classdev_mc, led_cdev); + struct claw_drvdata *drvdata = container_of(led_mc, struct claw_drvdata, led_mc); + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->rgb_registered)) +return ; + } + +mod_delayed_work (system_wq, &drvdata->rgb_queue,msecs_to_jiffies (50 )); +} + +static struct attribute *claw_rgb_attrs[] = { + &dev_attr_effect.attr, + &dev_attr_effect_index.attr, + &dev_attr_enabled.attr, + &dev_attr_enabled_index.attr, + &dev_attr_speed.attr, + &dev_attr_speed_range.attr, +NULL , +}; + +static const struct attribute_group claw_rgb_attr_group = { + .attrs = claw_rgb_attrs, +}; + +static struct mc_subled claw_rgb_subled_info[] = { + { + .color_index =LED_COLOR_ID_RED , + .channel =0x1 , + }, + { + .color_index =LED_COLOR_ID_GREEN , + .channel =0x2 , + }, + { + .color_index =LED_COLOR_ID_BLUE , + .channel =0x3 , + }, +}; +static void cfg_setup_fn (struct work_struct *work) { struct delayed_work *dwork = container_of(work, struct delayed_work, work); struct claw_drvdata *drvdata = container_of(dwork, struct claw_drvdata, cfg_setup); +bool gamepad_ready = false, rgb_ready = false, gp_registered, rgb_registered;int ret; ret =claw_hw_output_report (drvdata->hdev,CLAW_COMMAND_TYPE_READ_GAMEPAD_MODE ,NULL ,0 ,25 );if (ret) {dev_err (&drvdata->hdev->dev, -"Failed to setup device, can't read gamepad mode: %d\n" , ret); -return ; +"Failed to read gamepad mode: %d\n" , ret); + goto prep_rgb; } + gamepad_ready = true; -/* Add sysfs attributes after we get the device state */ - ret =device_add_group (&drvdata->hdev->dev, &claw_gamepad_attr_group); +prep_rgb: + ret =claw_read_rgb_config (drvdata->hdev);if (ret) {dev_err (&drvdata->hdev->dev, -"Failed to setup device, can't create gamepad attrs: %d\n" , ret); -return ; +"Failed to read RGB config: %d\n" , ret); + goto try_gamepad; } + rgb_ready = true; + +/* Add sysfs attributes after we get the device state */ +try_gamepad:scoped_guard (spinlock_irqsave, &drvdata->registration_lock) - /* Pairs with smp_load_acquire in attribute show/store functions */ -smp_store_release (&drvdata->gp_registered, true); + /* Pairs with smp_store_release from below */ + gp_registered =smp_load_acquire (&drvdata->gp_registered); + +if (!gp_registered && gamepad_ready) { + ret =device_add_group (&drvdata->hdev->dev, &claw_gamepad_attr_group); +if (ret) { +dev_err (&drvdata->hdev->dev, +"Failed to create gamepad attrs: %d\n" , ret); + goto try_rgb; + } -kobject_uevent (&drvdata->hdev->dev.kobj,KOBJ_CHANGE ); + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_load_acquire in attribute show/store functions */ +smp_store_release (&drvdata->gp_registered, true); + gp_registered = true; + } + } + +try_rgb: +/* Add and enable RGB interface once we have the device state */ +scoped_guard (spinlock_irqsave, &drvdata->registration_lock) + /* Pairs with smp_store_release from below */ + rgb_registered =smp_load_acquire (&drvdata->rgb_registered); + +if (!rgb_registered && rgb_ready) { + ret =led_classdev_multicolor_register (&drvdata->hdev->dev, + &drvdata->led_mc); +if (ret) { +dev_err (&drvdata->hdev->dev, +"Failed to create led device: %d\n" , ret); + goto update_kobjects; + } + + ret =device_add_group (drvdata->led_mc.led_cdev.dev, &claw_rgb_attr_group); +if (ret) { +dev_err (&drvdata->hdev->dev, +"Failed to create RGB attrs: %d\n" , ret); +led_classdev_multicolor_unregister (&drvdata->led_mc); + goto update_kobjects; + } + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_load_acquire in attribute show/store functions */ +smp_store_release (&drvdata->rgb_registered, true); + rgb_registered = true; + } + } + +update_kobjects: +if (gp_registered) +kobject_uevent (&drvdata->hdev->dev.kobj,KOBJ_CHANGE ); +if (rgb_registered) +kobject_uevent (&drvdata->led_mc.led_cdev.dev->kobj,KOBJ_CHANGE ); }static void cfg_resume_fn (struct work_struct *work)
@@ -916,8 +1526,10 @@ static void cfg_resume_fn(struct work_struct *work) struct claw_drvdata *drvdata = container_of(dwork, struct claw_drvdata, cfg_resume);guard (spinlock_irqsave)(&drvdata->registration_lock); -/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ -if (!smp_load_acquire (&drvdata->gp_registered)) +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered) || +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ + !smp_load_acquire (&drvdata->rgb_registered))schedule_delayed_work (&drvdata->cfg_setup,msecs_to_jiffies (500 )); }
@@ -928,18 +1540,24 @@ static void claw_features_supported(struct claw_drvdata *drvdata)if (major ==0x01 ) { drvdata->bmap_support = true; -if (minor >=0x66 ) +if (minor >=0x66 ) { drvdata->bmap_addr = button_mapping_addr_new; -else + drvdata->rgb_addr = rgb_addr_new; + }else { drvdata->bmap_addr = button_mapping_addr_old; + drvdata->rgb_addr = rgb_addr_old; + }return ; }if ((major ==0x02 && minor >=0x17 ) || major >=0x03 ) { drvdata->bmap_support = true; drvdata->bmap_addr = button_mapping_addr_new; + drvdata->rgb_addr = rgb_addr_new;return ; } + + drvdata->rgb_addr = rgb_addr_old; }static int claw_probe (struct hid_device *hdev,u8 ep)
@@ -954,6 +1572,7 @@ static int claw_probe(struct hid_device *hdev, u8 ep)return -ENOMEM ; drvdata->gamepad_mode =CLAW_GAMEPAD_MODE_XINPUT ; + drvdata->rgb_enabled = true; drvdata->hdev = hdev; drvdata->ep = ep;
@@ -964,6 +1583,17 @@ static int claw_probe(struct hid_device *hdev, u8 ep)if (!drvdata->bmap_support)dev_dbg (&hdev->dev,"M-Key mapping is not supported. Update firmware to enable.\n" ); + drvdata->led_mc.led_cdev.name ="msi_claw:rgb:joystick_rings" ; + drvdata->led_mc.led_cdev.brightness =0x50 ; + drvdata->led_mc.led_cdev.max_brightness =0x64 ; + drvdata->led_mc.led_cdev.color =LED_COLOR_ID_RGB ; + drvdata->led_mc.led_cdev.brightness_set = claw_led_brightness_set; + drvdata->led_mc.num_colors =3 ; + drvdata->led_mc.subled_info =devm_kmemdup (&hdev->dev, claw_rgb_subled_info, +sizeof (claw_rgb_subled_info),GFP_KERNEL ); +if (!drvdata->led_mc.subled_info) +return -ENOMEM ; +mutex_init (&drvdata->cfg_mutex);mutex_init (&drvdata->profile_mutex);mutex_init (&drvdata->rom_mutex);
@@ -971,9 +1601,11 @@ static int claw_probe(struct hid_device *hdev, u8 ep)spin_lock_init (&drvdata->cmd_lock);spin_lock_init (&drvdata->mode_lock);spin_lock_init (&drvdata->profile_lock); +spin_lock_init (&drvdata->frame_lock);init_completion (&drvdata->send_cmd_complete);INIT_DELAYED_WORK (&drvdata->cfg_resume, &cfg_resume_fn);INIT_DELAYED_WORK (&drvdata->cfg_setup, &cfg_setup_fn); +INIT_DELAYED_WORK (&drvdata->rgb_queue, &claw_rgb_queue_fn);/* For control interface: open the HID transport for sending commands. */ ret =hid_hw_open (hdev);
@@ -1030,6 +1662,7 @@ static void claw_remove(struct hid_device *hdev) {struct claw_drvdata *drvdata =hid_get_drvdata (hdev);bool gp_registered; +bool rgb_registered;if (!drvdata)return ;
@@ -1042,11 +1675,21 @@ static void claw_remove(struct hid_device *hdev) gp_registered =smp_load_acquire (&drvdata->gp_registered);/* Pairs with smp_load_acquire in attribute show/store functions */ smp_store_release (&drvdata->gp_registered, false); +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ + rgb_registered =smp_load_acquire (&drvdata->rgb_registered); +/* Pairs with smp_load_acquire in attribute show/store functions */ +smp_store_release (&drvdata->rgb_registered, false); }if (gp_registered)device_remove_group (&hdev->dev, &claw_gamepad_attr_group); +cancel_delayed_work_sync (&drvdata->rgb_queue); +if (rgb_registered) { +device_remove_group (drvdata->led_mc.led_cdev.dev, &claw_rgb_attr_group); +led_classdev_multicolor_unregister (&drvdata->led_mc); + } +hid_hw_close (hdev); }
@@ -1106,6 +1749,7 @@ static int claw_suspend(struct hid_device *hdev)cancel_delayed_work_sync (&drvdata->cfg_resume);cancel_delayed_work_sync (&drvdata->cfg_setup); +cancel_delayed_work_sync (&drvdata->rgb_queue);return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v11 3/4] HID: hid-msi: Add RGB control interface
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] A race condition in `claw_remove()` allows the `rgb_queue` delayed work to be re-armed after it…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] A race condition in claw_remove() allows the rgb_queue delayed work to be re-armed after it has been cancelled, leading to a Use-After-Free of the drvdata structure.
- [Medium] A hardcoded LED class device name prevents supporting multiple connected devices.
--
commit 151b50cdc17e18af52c3d79eb6a71e3b5e4583d8
Author: Derek J. Clark <[email protected]>
HID: hid-msi: Add RGB control interface
Adds RGB control interface for MSI Claw devices using a unique frame-based RGB protocol. Mirrors Windows effects using a delayed work queue to apply state to the device.
Quoted 3 lines
drivers/hid/hid-msi.c +0
-0
[ ... ]
Quoted 1 line
drivers/hid/hid-msi.c +0
-0@@ -954,6 +1572,7 @@ static int claw_probe(struct hid_device *hdev, u8 ep)
[ ... ]
drivers/hid/hid-msi.c static int claw_probe(struct hid_device *hdev, u8 ep) · line 1586
Quoted 4 lines
drivers/hid/hid-msi.c +1
-0if (!drvdata->bmap_support)dev_dbg (&hdev->dev,"M-Key mapping is not supported. Update firmware to enable.\n" ); + drvdata->led_mc.led_cdev.name ="msi_claw:rgb:joystick_rings" ;
[Severity: Medium]
Does hardcoding the LED class device name prevent multiple MSI Claw devices from being connected at the same time?
If two devices are connected, it seems the second one will fail to register its LED class device due to a sysfs name collision. Would it be safer to include a unique identifier like dev_name(&hdev->dev) in the string?
[ ... ]
Quoted 1 line
drivers/hid/hid-msi.c +0
-0@@ -1030,6 +1662,7 @@ static void claw_remove(struct hid_device *hdev)
[ ... ]
drivers/hid/hid-msi.c static void claw_remove(struct hid_device *hdev) · line 1694
Quoted 11 lines
drivers/hid/hid-msi.c +6
-0if (gp_registered)device_remove_group (&hdev->dev, &claw_gamepad_attr_group); +cancel_delayed_work_sync (&drvdata->rgb_queue); +if (rgb_registered) { +device_remove_group (drvdata->led_mc.led_cdev.dev, &claw_rgb_attr_group); +led_classdev_multicolor_unregister (&drvdata->led_mc); + } +hid_hw_close (hdev); }
[Severity: High]
Can a race condition here lead to a use-after-free of drvdata?
In sysfs store functions like effect_store(), rgb_registered is checked under the registration_lock, but mod_delayed_work() is called after dropping the lock.
If a sysfs thread is preempted right after dropping the lock, claw_remove() could set rgb_registered to false, execute cancel_delayed_work_sync(), and block on device_remove_group() waiting for the sysfs operation to finish.
Once the sysfs thread resumes, it would call mod_delayed_work(), effectively re-arming the workqueue after it was supposed to be cancelled. When claw_remove() completes, drvdata is freed, and the delayed work timer firing later would result in a use-after-free.
Would moving cancel_delayed_work_sync() after the device_remove_group() and led_classdev_multicolor_unregister() calls prevent this race?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Derek J. Clark
maintainerPATCH v11 4/4 HID: hid-msi: Add Rumble Intensity Attributes
In reply to Derek J. ClarkAdds intensity adjustment for the left and right rumble motors.
Claude was used during the reverse-engineering data gathering for this feature done by Zhouwang Huang. As the code had already been affected, I used Claude to create the initial framing for the feature, then did manual cleanup of the _show and _store functions afterwards to fix bugs and keep the coding style consistent. Claude was also used as an initial reviewer of this patch.
---
v11:
- Restore dropped changes from v10.
v7:
- Match on write address for rumble reports to prevent late ACK from causing synchronization errors.
- Use spinlock for read/write profile_pending.
- Use smp_[store_release|load_acquire] pattern for checking gamepad_registered to avoid possible races during teardown.
- Use struct for rumble reports.
v6:
- Make all timeouts 25ms to ensure at least 2 jiffies in a 100Hz config.
- Add spinlock_irqsave for read/write access on rumble_intensity variables.
- Gate all attribute show/store functions with gamepad_registered.
v5:
- Remove mkey related changes.
v2:
- Use pending_profile and sync to rom mutexes.
--- drivers/hid/hid-msi.c | 202 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 201 insertions(+), 1 deletion(-)
drivers/hid/hid-msi.c +201 -1
@@ -79,6 +79,8 @@ enum claw_profile_ack_pending {CLAW_M1_PENDING ,CLAW_M2_PENDING ,CLAW_RGB_PENDING , +CLAW_RUMBLE_LEFT_PENDING , + CLAW_RUMBLE_RIGHT_PENDING, }; enum claw_key_index {
@@ -266,6 +268,11 @@ static const u16 button_mapping_addr_new[] = {static const u16 rgb_addr_old =0x01fa ;static const u16 rgb_addr_new =0x024a ; +static const u16 rumble_addr[] = { +0x0022 ,/* left */ +0x0023 ,/* right */ +}; +struct claw_command_report {u8 report_id;u8 padding[2 ];
@@ -308,6 +315,12 @@ struct claw_rgb_report {struct rgb_frame zone_data; } __packed; +struct claw_rumble_report { +struct claw_profile_report ; +u8 padding; +u8 intensity; +} __packed; +struct claw_drvdata {/* MCU General Variables */ enum claw_profile_ack_pending profile_pending;
@@ -332,8 +345,12 @@ struct claw_drvdata {enum claw_gamepad_mode_index gamepad_mode;u8 m1_codes[CLAW_KEYS_MAX ];u8 m2_codes[CLAW_KEYS_MAX ]; -spinlock_t mode_lock;/* Lock for mode data read/write */ +u8 rumble_intensity_right; +u8 rumble_intensity_left;const u16 *bmap_addr; +spinlock_t rumble_lock;/* lock for rumble_intensity read/write */ +spinlock_t mode_lock;/* Lock for mode data read/write */ +bool rumble_support;bool gp_registered;bool bmap_support;
@@ -382,6 +399,7 @@ static int claw_gamepad_mode_event(struct claw_drvdata *drvdata,static int claw_profile_event (struct claw_drvdata *drvdata,struct claw_command_report *cmd_rep) {enum claw_profile_ack_pending profile; +struct claw_rumble_report *rumble;struct claw_mkey_report *mkeys;struct claw_rgb_report *frame;u16 rgb_addr, read_addr;
@@ -431,6 +449,20 @@ static int claw_profile_event(struct claw_drvdata *drvdata, struct claw_command_ }break ; +case CLAW_RUMBLE_LEFT_PENDING : + rumble = (struct claw_rumble_report *)cmd_rep->data; +if (be16_to_cpu (rumble->read_addr) != rumble_addr[0 ]) +return -EINVAL ; +scoped_guard (spinlock, &drvdata->rumble_lock) + drvdata->rumble_intensity_left = rumble->intensity; +break ; +case CLAW_RUMBLE_RIGHT_PENDING : + rumble = (struct claw_rumble_report *)cmd_rep->data; +if (be16_to_cpu (rumble->read_addr) != rumble_addr[1 ]) +return -EINVAL ; +scoped_guard (spinlock, &drvdata->rumble_lock) + drvdata->rumble_intensity_right = rumble->intensity; +break ;default : dev_dbg(&drvdata->hdev->dev, "Got profile event without changes pending from command: %x\n",
@@ -930,6 +962,162 @@ static ssize_t button_mapping_options_show(struct device *dev, }static DEVICE_ATTR_RO (button_mapping_options); +static ssize_t rumble_intensity_left_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{ +struct claw_rumble_report report = { {0x01 ,cpu_to_be16 (rumble_addr[0 ])},0x01 }; +struct hid_device *hdev =to_hid_device (dev); +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +u8 val; +int ret; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered)) +return -ENODEV ; + } + + ret =kstrtou8 (buf,10 , &val); +if (ret) +return ret; + +if (val >100 ) +return -EINVAL ; + + report.intensity = val; + +guard (mutex)(&drvdata->rom_mutex); + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +/* MCU will not send ACK until the USB transaction completes. ACK is sent +* immediately after and will hit the stale state machine, before the next +* command re-arms the state machine. Timeout 0 ensures no deadlock waiting +* for ACK that ill never come. +*/ + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SYNC_TO_ROM ,NULL ,0 ,0 ); +if (ret) +return ret; + +return count; +} + +static ssize_t rumble_intensity_left_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +struct claw_rumble_report report = { {0x01 ,cpu_to_be16 (rumble_addr[0 ])},0x01 }; +struct hid_device *hdev =to_hid_device (dev); +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +int ret; +u8 val; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered)) +return -ENODEV ; + } + +guard (mutex)(&drvdata->profile_mutex); +scoped_guard (spinlock_irqsave, &drvdata->profile_lock) + drvdata->profile_pending = CLAW_RUMBLE_LEFT_PENDING; + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_READ_PROFILE , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +scoped_guard (spinlock_irqsave, &drvdata->rumble_lock) + val = drvdata->rumble_intensity_left; + +return sysfs_emit (buf,"%u\n" , val); +} +static DEVICE_ATTR_RW (rumble_intensity_left); + +static ssize_t rumble_intensity_right_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{ +struct claw_rumble_report report = { {0x01 ,cpu_to_be16 (rumble_addr[1 ])},0x01 }; +struct hid_device *hdev =to_hid_device (dev); +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +u8 val; +int ret; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered)) +return -ENODEV ; + } + + ret =kstrtou8 (buf,10 , &val); +if (ret) +return ret; + +if (val >100 ) +return -EINVAL ; + + report.intensity = val; + +guard (mutex)(&drvdata->rom_mutex); + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +/* MCU will not send ACK until the USB transaction completes. ACK is sent +* immediately after and will hit the stale state machine, before the next +* command re-arms the state machine. Timeout 0 ensures no deadlock waiting +* for ACK that ill never come. +*/ + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SYNC_TO_ROM ,NULL ,0 ,0 ); +if (ret) +return ret; + +return count; +} + +static ssize_t rumble_intensity_right_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +struct claw_rumble_report report = { {0x01 ,cpu_to_be16 (rumble_addr[1 ])},0x01 }; +struct hid_device *hdev =to_hid_device (dev); +struct claw_drvdata *drvdata =hid_get_drvdata (hdev); +int ret; +u8 val; + + scoped_guard(spinlock_irqsave, &drvdata->registration_lock) { +/* Pairs with smp_store_release from cfg_setup_fn in system_wq context */ +if (!smp_load_acquire (&drvdata->gp_registered)) +return -ENODEV ; + } + +guard (mutex)(&drvdata->profile_mutex); +scoped_guard (spinlock_irqsave, &drvdata->profile_lock) + drvdata->profile_pending = CLAW_RUMBLE_RIGHT_PENDING; + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_READ_PROFILE , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +scoped_guard (spinlock_irqsave, &drvdata->rumble_lock) + val = drvdata->rumble_intensity_right; + +return sysfs_emit (buf,"%u\n" , val); +} +static DEVICE_ATTR_RW (rumble_intensity_right); + +static ssize_t rumble_intensity_range_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +return sysfs_emit (buf,"0-100\n" ); +} +static DEVICE_ATTR_RO (rumble_intensity_range); +static umode_t claw_gamepad_attr_is_visible (struct kobject *kobj,struct attribute *attr,int n) {
@@ -950,6 +1138,12 @@ static umode_t claw_gamepad_attr_is_visible(struct kobject *kobj, struct attribu attr == &dev_attr_reset.attr)return attr->mode; +/* Hide rumble attrs if not supported */ +if (attr == &dev_attr_rumble_intensity_left.attr || + attr == &dev_attr_rumble_intensity_right.attr || + attr == &dev_attr_rumble_intensity_range.attr) +return drvdata->rumble_support ? attr->mode :0 ; +/* Hide button mapping attrs if it isn't supported */ return drvdata->bmap_support ? attr->mode :0 ; }
@@ -963,6 +1157,9 @@ static struct attribute *claw_gamepad_attrs[] = { &dev_attr_mkeys_function.attr, &dev_attr_mkeys_function_index.attr, &dev_attr_reset.attr, + &dev_attr_rumble_intensity_left.attr, + &dev_attr_rumble_intensity_right.attr, + &dev_attr_rumble_intensity_range.attr, NULL, };
@@ -1542,6 +1739,7 @@ static void claw_features_supported(struct claw_drvdata *drvdata) drvdata->bmap_support = true;if (minor >=0x66 ) { drvdata->bmap_addr = button_mapping_addr_new; + drvdata->rumble_support = true; drvdata->rgb_addr = rgb_addr_new; }else { drvdata->bmap_addr = button_mapping_addr_old;
@@ -1553,6 +1751,7 @@ static void claw_features_supported(struct claw_drvdata *drvdata)if ((major ==0x02 && minor >=0x17 ) || major >=0x03 ) { drvdata->bmap_support = true; drvdata->bmap_addr = button_mapping_addr_new; + drvdata->rumble_support = true; drvdata->rgb_addr = rgb_addr_new;return ; }
@@ -1602,6 +1801,7 @@ static int claw_probe(struct hid_device *hdev, u8 ep)spin_lock_init (&drvdata->mode_lock);spin_lock_init (&drvdata->profile_lock);spin_lock_init (&drvdata->frame_lock); +spin_lock_init (&drvdata->rumble_lock);init_completion (&drvdata->send_cmd_complete);INIT_DELAYED_WORK (&drvdata->cfg_resume, &cfg_resume_fn);INIT_DELAYED_WORK (&drvdata->cfg_setup, &cfg_setup_fn);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v11 4/4] HID: hid-msi: Add Rumble Intensity Attributes
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Unwaited ACKs from SYNC_TO_ROM commands can prematurely complete the waits of subsequent unrelated commands. --
commit 11fcab6387a146514df018948771932cc7f57ed2
Author: Derek J. Clark <[email protected]>
HID: hid-msi: Add Rumble Intensity Attributes
This commit adds intensity adjustment attributes for the left and right rumble motors on MSI Claw devices.
Quoted 4 lines
drivers/hid/hid-msi.c +0
-0
[ ... ]
Quoted 1 line
drivers/hid/hid-msi.c +0
-0@@ -930,6 +962,162 @@ static ssize_t button_mapping_options_show(struct device *dev,
[ ... ]
Quoted 4 lines
drivers/hid/hid-msi.c +4
-0+static ssize_t rumble_intensity_left_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{
[ ... ]
drivers/hid/hid-msi.c static ssize_t button_mapping_options_show(struct device *dev, · line 1001
Quoted 11 lines
drivers/hid/hid-msi.c +11
-0+ ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA , + (u8 *)&report,sizeof (report),25 ); +if (ret) +return ret; + +/* MCU will not send ACK until the USB transaction completes. ACK is sent +* immediately after and will hit the stale state machine, before the next +* command re-arms the state machine. Timeout 0 ensures no deadlock waiting +* for ACK that ill never come. +*/ + ret =claw_hw_output_report (hdev,CLAW_COMMAND_TYPE_SYNC_TO_ROM ,NULL ,0 ,0 );
[Severity: High]
This is a pre-existing issue, but this patch propagates it to the new rumble attributes.
If a SYNC_TO_ROM command is sent with a timeout of 0, the driver does not wait for the hardware's ACK, but the hardware still sends a generic ACK packet for it.
If userspace rapidly writes to multiple sysfs attributes (for example, rumble_intensity_left then rumble_intensity_right), the second write will send a WRITE_PROFILE_DATA command and wait for its ACK. Can the stray ACK from the first SYNC_TO_ROM command arrive during this wait window?
Since the generic ACK doesn't indicate which command it belongs to, would this cause the driver to falsely assume the WRITE_PROFILE_DATA command has completed and prematurely wake the waiter? This could cause the driver to send the next command while the hardware is still processing the previous one, leading to dropped commands and device state desynchronization.
Quoted 5 lines
drivers/hid/hid-msi.c +5
-0+if (ret) +return ret; + +return count; +}
[ ... ]
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
Jiri Kosina
maintainerQuoted 28 lines · Derek J. Clark
This series adds an HID Configuration driver for the MSI Claw line of Handheld Gaming PC's. The MSI Claw HID interface provides multiple features, such as the ability to switch between xinput, dinput, and a desktop mode, RGB control, rumble intensity, and mapping of the rear "M" keys. There are additional gamepad modes that are not included in this driver as they appear to be used in assembly line testing or are incomplete in the firmware. During my testing I found them to be unstable.
The initial version of this driver was written by Denis Benato, which contained the initial reverse-engineering and implementation for the gamepad mode switching. This work was later expanded by Zhouwang Huang to include more gamepad modes and additional features. Finally, I refactored the entire driver, fixed multiple bugs, and refined the overall format to conform to kernel driver best practices and style guide.
Claude was used initially by Zhouwang Huang to quickly parse HID captures during the reverse-engineering of some of the features. Since Claude had already been used, as a test of its capabilities I had it implement the rumble intensity attribute after I had already rewritten most of the driver, which I then manually edited to fix some mistakes. I also used Claude to review the driver and these patches for any mistakes and bugs.
Assisted-by Claude:claude-sonnet-4-6Co-developed-by Denis Benato <[email protected]>Signed-off-by Denis Benato <[email protected]>Co-developed-by Zhouwang Huang <[email protected]>Signed-off-by Zhouwang Huang <[email protected]>Signed-off-by Derek J. Clark <[email protected]>
Quoted 3 lines
---
v11:
- Restore dropped changes from v10.
Thanks Derek.
Sashiko had quite a few insightful comments, I find especially the one with IRQ-vs-kernel context deadlock on drvdata->profile_lock valid.
Could you please go through those, and address it?
Thanks again for all the effort,
Signature · 2 lines
Jiri Kosina SUSE Labs