From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-dy1-f174.google.com (mail-dy1-f174.google.com [74.125.82.174]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 24D342C08BB for ; Sun, 10 May 2026 04:35:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.174 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1778387721; cv=none; b=H9TOgRPj052bvb5to8PcAHcRjwQCi8irmbAzBus3BDss6EV0AxLXi9pWA9jSQRTfi36hvhed/fdcAOlR41PC0dTvE5pnzOmhjJY+JN3zSYs7VzcTFnrR34oMxPWe8qr2YxUYhbbNu50lIz3VzHmKUIhoYJDkryY9DTl8W9uMtIY= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1778387721; c=relaxed/simple; bh=d3jSGPOBaWc4UIC9sfI5W44LvBygx5/+tFvoKgA9SJ4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=kFWxyjAO3xJWPQsYXwv/pUP5KO+iVNLi/ndOrhTT4j0Md1WVQsqi22x+5lDeagPEQfn0g8Lqh/92yAoh+eGRyxb42qdP8xBdDAqJPXBS0oKQ6eNVICpYm4pg1nM3RRtZhlxTgU7L8ZhT0waOOaExC9KNSFMCWsFWBZ13lr7jclI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=QKBfgit0; arc=none smtp.client-ip=74.125.82.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="QKBfgit0" Received: by mail-dy1-f174.google.com with SMTP id 5a478bee46e88-2ee1054627bso3206741eec.1 for ; Sat, 09 May 2026 21:35:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1778387718; x=1778992518; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=2FiuvqqOksN6dfl3g7NjkZEHTTgF2ns2opUTPjbkspo=; b=QKBfgit0aWZ1eg/84csc3im2vOhWF1PYGVJArKVSD/F1voMSgSRtKjAyhNiQEtr1PH oY8g6AsSc6op4sChHjgF/micMBL29MBhUt3n7834qUvV5owcYlY1uEeh6b/Sd1z+CMDD pdWDCB+cKsn/UTEOj2ytL+RMXglGfakc0WY9wQ6PcnRSn2yts0KP6Mn/1nDF1cZ57UV7 MMcehJ6A8BGj8LV7kBceodmJeE9S39UnQXTG4hp4DJ2MXAhRjapq5GhnEgPT7V5MVLFT fh7CQNJ3VLcdMTp/arHpu4OOvxaNhpkreu7Wy3luyYYFmMPj3g9UXqu6FXl7ouKeP9D1 KikA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1778387718; x=1778992518; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=2FiuvqqOksN6dfl3g7NjkZEHTTgF2ns2opUTPjbkspo=; b=pUXQwTNUEJeEfk+fzI+eiuN98I0mAzfFBDbEztBLfOXdFUrUbdCJ/S4Rr/ebOuWK6G nNVwbtYFKgZvufDZpDbDQdPn34A/yxL8CWnJ3s9VraLV5B3s+5nTK4FXU8cDHxRrnilR Z+u2JOJsM4vJHPldUNNRwDUOTQ6YeIVFwT5bUPVuzORHkP/CYkEQxR+5ccUN+oTR94mq sRFpsQFW0/9MXzedPXPWJxYdJwPANMb01IrZG1ewFcJ8tjIidHyXpGTq+JNKxsZVl3uM IuEV7zAmn1b1j5I9ViMBPpvL7lrWVhjv9K2l2FoZxHvD5yLsUYn1NgD7UsQ9/C6dltec DPmw== X-Forwarded-Encrypted: i=1; AFNElJ++HeYVmZtQO3kSH+tSB95wdrJumiXhFbytuqy6qNRw35Sj7VkeUm2v9DLHuipy2KQSn/mrhWvXblY=@vger.kernel.org X-Gm-Message-State: AOJu0Yw6DFuPqVZ+8vexUIDSYM39g8ojFWRoUL/qLOSCUd8HYVnuRPJh UQotvHKJksX5qhSnCR8UiX8V3mIjaSO5ESbvkZBf8in8DLE2eZ2zGd1j X-Gm-Gg: Acq92OElD+QjVKyu75herI2n8O+piRLq5ePUdiu/5KpDVY44dwnAYDXmC6yrAqQzJex 6gMlUeu89Hhx8qB6imxGdCb5Zzftle7vWcYsaHkmykuXbSeFeT9cKpL1zZERbncgRQyc6tCbb5a 04qehss1gKzObKlGKdJ9pq8ny4Yj+GZBU0BpGX+cc1dEhkv1NbPfjD0yWK7a0ND3AA7TpO5/mlv jMuqTXiQygiWVslJNmVgxL1T1qtw6Uw0b7J4dgoLGfVkJ4U37J/GHZbXfoIciF0OWqQuOvEFGoq zfwMq049/u2/49oDSYZGF4InNaindGymNXvN7zfw6MBVOkdapvjm4OThIX7AG6t80GoqJX5v7MY qrr9j+SWMsiRsDiJB45n9KcrtwoWiOeCkxLktz6muz1hLHSgfa+ewpnIbitYTRpyyHb0B3DM5A4 6XfaHEJtLm9QXGClIMW5Ila3xuGKIbKOEU07pIjsQeKEgNIjWuGrXCaj889ceNAF6mu1zBu2I1b EnE7T39u03BNBc= X-Received: by 2002:a05:7300:2311:b0:2c6:67b6:3acc with SMTP id 5a478bee46e88-2f6e4562378mr5992938eec.15.1778387718089; Sat, 09 May 2026 21:35:18 -0700 (PDT) Received: from lappy (108-228-232-20.lightspeed.sndgca.sbcglobal.net. [108.228.232.20]) by smtp.gmail.com with ESMTPSA id 5a478bee46e88-2f88885be8esm8667953eec.22.2026.05.09.21.35.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 09 May 2026 21:35:17 -0700 (PDT) From: "Derek J. Clark" To: Jiri Kosina , Benjamin Tissoires Cc: "Pierre-Loup A . Griffais" , Denis Benato , Zhouwang Huang , "Derek J . Clark" , linux-input@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH 3/4] HID: hid-msi-claw: Add RGB control interface Date: Sun, 10 May 2026 04:35:09 +0000 Message-ID: <20260510043510.442807-4-derekjohn.clark@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260510043510.442807-1-derekjohn.clark@gmail.com> References: <20260510043510.442807-1-derekjohn.clark@gmail.com> Precedence: bulk X-Mailing-List: linux-doc@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Adds 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. Assisted-by: Claude:claude-sonnet-4-6 Co-developed-by: Zhouwang Huang Signed-off-by: Zhouwang Huang Signed-off-by: Derek J. Clark --- drivers/hid/hid-msi-claw.c | 533 ++++++++++++++++++++++++++++++++++++- 1 file changed, 530 insertions(+), 3 deletions(-) diff --git a/drivers/hid/hid-msi-claw.c b/drivers/hid/hid-msi-claw.c index 60694d075d56..f4fe74a784c2 100644 --- a/drivers/hid/hid-msi-claw.c +++ b/drivers/hid/hid-msi-claw.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -42,6 +43,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_READ_PROFILE = 0x04, CLAW_COMMAND_TYPE_READ_PROFILE_ACK = 0x05, @@ -70,6 +75,7 @@ enum claw_profile_ack_pending { CLAW_NO_PENDING, CLAW_M1_PENDING, CLAW_M2_PENDING, + CLAW_RGB_PENDING, }; enum claw_key_index { @@ -227,6 +233,22 @@ static const struct { { 0xce, "REL_WHEEL_DOWN" }, }; +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 */ @@ -237,6 +259,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]; @@ -245,6 +270,28 @@ struct claw_command_report { u8 data[59]; } __packed; +struct rgb_zone { + u8 red; + u8 green; + u8 blue; +}; + +struct rgb_frame { + struct rgb_zone zone[9]; +}; + +struct rgb_report { + u8 profile; + __be16 read_addr; + u8 frame_bytes; + u8 padding; + u8 frame_count; + u8 state; + u8 speed; + u8 brightness; + struct rgb_frame zone_data; +} __packed; + struct claw_drvdata { /* MCU General Variables */ enum claw_profile_ack_pending profile_pending; @@ -263,6 +310,16 @@ struct claw_drvdata { u8 m2_codes[CLAW_KEYS_MAX]; const u16 *bmap_addr; 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; + u8 rgb_frame_count; + bool rgb_enabled; + u8 rgb_speed; + u16 rgb_addr; }; static int get_endpoint_address(struct hid_device *hdev) @@ -292,7 +349,10 @@ 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) { - u8 *codes; + struct rgb_report *frame; + u16 rgb_addr, read_addr; + u8 *codes, f_idx; + u16 frame_calc; int i; switch (drvdata->profile_pending) { @@ -304,6 +364,39 @@ static int claw_profile_event(struct claw_drvdata *drvdata, struct claw_command_ for (i = 0; i < CLAW_KEYS_MAX; i++) codes[i] = (cmd_rep->data[6 + i] != 0xff) ? cmd_rep->data[6 + i] : 0x00; break; + case CLAW_RGB_PENDING: + frame = (struct 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 > U8_MAX) { + dev_err(drvdata->led_mc.led_cdev.dev, "Got unsupported frame index: %x\n", + frame_calc); + return -EINVAL; + } + f_idx = frame_calc; + + if (f_idx >= CLAW_RGB_MAX_FRAMES) { + dev_err(drvdata->led_mc.led_cdev.dev, "Got illegal frame index: %x\n", + f_idx); + return -EINVAL; + } + + /* Always treat the first frame as the truth for these constants */ + if (f_idx == 0) { + drvdata->rgb_frame_count = frame->frame_count; + /* Invert device speed (20-0) to sysfs speed (0-20) */ + 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; + } + + memcpy(&drvdata->rgb_frames[f_idx], &frame->zone_data, + sizeof(struct rgb_frame)); + + break; default: dev_warn(&drvdata->hdev->dev, "Got profile event without changes pending from command:%x\n", @@ -743,6 +836,389 @@ 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 */ + for (i = 0; i < 8; i++) { + drvdata->profile_pending = CLAW_RGB_PENDING; + data[1] = (read_addr >> 8) & 0xff; + data[2] = read_addr & 0x00ff; + ret = mcu_property_out(hdev, CLAW_COMMAND_TYPE_READ_PROFILE, data, len, 8); + 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 rgb_report report = { 0x01, 0x0000, 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; + size_t len = sizeof(report); + int f, ret; + + if (!drvdata->rgb_addr) + return -ENODEV; + + /* Loop through (up to) 8 pages of RGB data */ + for (f = 0; f < drvdata->rgb_frame_count; f++) { + 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 = mcu_property_out(drvdata->hdev, CLAW_COMMAND_TYPE_WRITE_PROFILE_DATA, + (u8 *)&report, len, 8); + if (ret) + return ret; + + /* Increment the write addr by the offset for the next frame */ + write_addr += CLAW_RGB_FRAME_OFFSET; + } + + return 0; +} + +/* 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, 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 }; + + 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 }; + + 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 frame; + + drvdata->rgb_frame_count = frame_count; + + for (frame = 0; frame < frame_count; frame++) + claw_frame_fill_solid(&drvdata->rgb_frames[frame], colors[frame]); + + 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 frame, zone; + + drvdata->rgb_frame_count = frame_count; + + for (frame = 0; frame < frame_count; frame++) { + for (zone = 0; zone < 4; zone++) { + drvdata->rgb_frames[frame].zone[zone] = colors[(zone + frame) % 4]; + drvdata->rgb_frames[frame].zone[zone + 4] = colors[(zone + frame) % 4]; + } + drvdata->rgb_frames[frame].zone[8] = colors[frame]; + } + + 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 frame, zone; + + drvdata->rgb_frame_count = frame_count; + + for (frame = 0; frame < frame_count; frame++) { + for (zone = 0; zone < 4; zone++) { + drvdata->rgb_frames[frame].zone[zone] = colors[(zone + frame) % 4]; + drvdata->rgb_frames[frame].zone[zone + 4] = colors[(zone - frame + 6) % 4]; + } + drvdata->rgb_frames[frame].zone[8] = colors[frame]; + } + + return claw_write_rgb_state(drvdata); +} + +/* Apply current state to device */ +static int claw_apply_rgb_state(struct claw_drvdata *drvdata) +{ + static const struct rgb_zone off = { 0, 0, 0 }; + + if (!drvdata->rgb_enabled) { + drvdata->rgb_frame_count = 1; + claw_frame_fill_solid(&drvdata->rgb_frames[0], off); + return claw_write_rgb_state(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; + + 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; + + 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); + + 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; + + 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); + + 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; + + 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 hid_device *hdev = to_hid_device(dev); + struct claw_drvdata *drvdata = hid_get_drvdata(hdev); + u8 speed = 20 - drvdata->rgb_speed; + + 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); + + 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 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 claw_remove(struct hid_device *hdev); static void cfg_setup_fn(struct work_struct *work) @@ -758,6 +1234,13 @@ static void cfg_setup_fn(struct work_struct *work) claw_remove(drvdata->hdev); } + ret = claw_read_rgb_config(drvdata->hdev); + if (ret) { + dev_err(drvdata->led_mc.led_cdev.dev, + "Failed to setup device, can't read RGB config: %d\n", ret); + claw_remove(drvdata->hdev); + } + /* Add sysfs attributes after we get the device state */ ret = sysfs_create_group(&drvdata->hdev->dev.kobj, &claw_gamepad_attr_group); if (ret) { @@ -766,7 +1249,15 @@ static void cfg_setup_fn(struct work_struct *work) claw_remove(drvdata->hdev); } + ret = device_add_group(drvdata->led_mc.led_cdev.dev, &rgb_attr_group); + if (ret) { + dev_err(&drvdata->hdev->dev, + "Failed to setup device, can't create led attributes: %d\n", ret); + claw_remove(drvdata->hdev); + } + kobject_uevent(&drvdata->hdev->dev.kobj, KOBJ_CHANGE); + kobject_uevent(&drvdata->led_mc.led_cdev.dev->kobj, KOBJ_CHANGE); } static void cfg_resume_fn(struct work_struct *work) @@ -776,6 +1267,10 @@ static void cfg_resume_fn(struct work_struct *work) u8 data[2] = { drvdata->gamepad_mode, drvdata->mkeys_function }; int ret; + ret = claw_read_rgb_config(drvdata->hdev); + if (ret) + dev_err(drvdata->led_mc.led_cdev.dev, "Failed to read RGB config: %d\n", ret); + ret = mcu_property_out(drvdata->hdev, CLAW_COMMAND_TYPE_SWITCH_MODE, data, ARRAY_SIZE(data), 0); if (ret) @@ -789,20 +1284,25 @@ 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->bmap_support = false; + drvdata->rgb_addr = rgb_addr_old; } static int claw_probe(struct hid_device *hdev, const struct hid_device_id *id) @@ -860,12 +1360,36 @@ static int claw_probe(struct hid_device *hdev, const struct hid_device_id *id) init_completion(&drvdata->send_cmd_complete); + /* Initialize RGB LED */ + INIT_DELAYED_WORK(&drvdata->rgb_queue, &claw_rgb_queue_fn); + + 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) { + ret = -ENOMEM; + goto err_close; + } + + drvdata->rgb_enabled = true; + + ret = devm_led_classdev_multicolor_register(&hdev->dev, &drvdata->led_mc); + if (ret) + goto err_close; + INIT_DELAYED_WORK(&drvdata->cfg_resume, &cfg_resume_fn); INIT_DELAYED_WORK(&drvdata->cfg_setup, &cfg_setup_fn); schedule_delayed_work(&drvdata->cfg_setup, msecs_to_jiffies(500)); return 0; +err_close: + hid_hw_close(hdev); err_stop_hw: hid_hw_stop(hdev); err_probe: @@ -881,6 +1405,9 @@ static void claw_remove(struct hid_device *hdev) if (drvdata->endpoint == CLAW_XINPUT_CFG_INTF_IN || drvdata->endpoint == CLAW_DINPUT_CFG_INTF_IN) { + /* Block writes to brightness/multi_intensity during teardown */ + drvdata->led_mc.led_cdev.brightness_set = NULL; + cancel_delayed_work_sync(&drvdata->rgb_queue); sysfs_remove_group(&hdev->dev.kobj, &claw_gamepad_attr_group); cancel_delayed_work_sync(&drvdata->cfg_setup); cancel_delayed_work_sync(&drvdata->cfg_resume); -- 2.53.0