Skip to contentSkip to conversation

leds: asus-aura-scsi: Add ASUS Aura RGB LED driver for ROG NVMe enclosures

RFC Superseded Liang Haowen 3 participants 5 messages Sep 25 – Oct 15 1 message not in the archive

Subsystems (3)

v9 of 10 Superseded Latest is v10 →

lore
Share & tools
lore
#0 lore raw

v9 cover leds: asus-aura-scsi: Add ASUS Aura RGB LED driver for ROG NVMe enclosures

Hello,

v9, as its own thread, addressing Ilpo's line review of v8 and the one real sashiko item. This time the full pass over the code was done.

Changes since v8:

- The DMA staging buffer is cacheline-aligned now, so an invalidation on non-coherent architectures cannot clobber the rest of struct asus_aura (the sashiko High).

- One pass over the code for includes, per Ilpo's comment: the explicit set is array_size.h, blk-mq.h, blk_types.h, blkdev.h, build_bug.h, byteorder/generic.h, cache.h, compiler.h, compiler_attributes.h, container_of.h, dev_printk.h, err.h, jiffies.h, the led headers, module.h, slab.h, sprintf.h, spinlock.h, string.h, workqueue.h and the scsi ones; unused ones (bits.h, kernel.h) dropped.

- ENE_OPCODE and ENE_TIMEOUT are defines again, the timeout value stays 5 s (Ilpo).

- The container_of() declarations are single lines (Lee's v6 comment, Ilpo's reminder), and every loop over the LED array uses ARRAY_SIZE() (Ilpo).

- The MODE/APPLY writes pass named locals with sizeof() instead of compound literals (Ilpo).

- The driver now applies without saving. The controller flash only changes on an explicit save command, which this driver never
sends: the LED class interface is runtime state and does not promise persistence across power cycles, and a save on every update would wear the flash. This drops the flash-wear caveat from the previous versions.

Everything else is unchanged from v8: the multicolor LED interface, the SCSI device handler attachment, the protocol handling and the remaining caveats. On the interface direction:
the LED side will move onto Marco's Dynamic Lighting class (OpenGamingCollective/linux-unstable#17) once that settles; he has removed his draft SCSI driver from the series and says the SCSI part will be added by its maintainer, so the two efforts are aligned on the same split.

v9 was verified on hardware again, including a visual check of the per-LED colours: the four LEDs, sequential updates, unplug under load (zero splats, zero leaked nodes, clean rmmod).

Liang Haowen (1):
leds: asus-aura-scsi: Add ASUS Aura RGB LED driver for ROG NVMe
enclosures

Signature · 9 lines
2.55.0


Liang Haowen (1):
  leds: asus-aura-scsi: Add ASUS Aura RGB LED driver for ROG NVMe
    enclosures

-- 
2.55.0
#1 lore raw

RFC v9 1/1 leds: asus-aura-scsi: Add ASUS Aura RGB LED driver for ROG NVMe enclosures

ASUS ROG external NVMe enclosures (ROG STRIX Arion, USB 0b05:1932) are plain USB mass-storage devices with no HID interface: the Aura LEDs hang off an ENE controller driven by vendor SCSI commands on the same LUN as the disk. The enclosure has 4 independently addressable LEDs, verified on hardware.

Register a scsi_device_handler matched by INQUIRY (vendor "ROG", model "ESD-S1C"); it does not claim the sdev (sd keeps owning the disk) and exposes each LED as a multicolor LED class device, /sys/class/leds/asus-arion-0-0-0-0::led-0 through led-3. The H:C:T:L part of the sdev name keeps the names unique when more than one enclosure is connected, with its colons flattened to dashes. The color section stays empty, since multicolor LEDs enumerate their palette via multi_intensity, and the four identical zones use the function name with a "-N" ordinal, as the naming section in Documentation/leds/leds-class.rst asks for.

Protocol: a 16-byte vendor CDB (opcode 0xec, 'A' 'S' signature, BE16 register index, argument count in byte 13), modelled by struct ene_cdb. MODE 0x8021 (Static) must be written first in every sequence or the device ignores it; colours go to 0x8160 + 3 * led and 0x8100 + 3 * led (3 bytes, wire order R, B, G; both tables are written because firmware revisions pull from one or the other); APPLY 0x80a0 takes 0x01 to apply; the controller also accepts 0xaa to save the state to its flash, which this driver never sends: the LED class interface is runtime state and does not promise persistence across power cycles, and a save on every update would wear the controller flash. The colour reverts to the stored default on power cycle, like any other runtime-only LED.

The CDB cannot go through scsi_execute_cmd(): it sizes the command via scsi_command_size(opcode), which maps vendor opcode 0xec to 10 bytes, so byte 13 is dropped and the device silently ignores the write (GOOD status, no error). scsi_execute_cmd() also offers no way to override the derived length. The request is therefore built with scsi_alloc_request(), which initializes the scsi_cmnd parts a passthrough needs, with cmd_len set to the CDB size, mirroring what SG_IO does from userspace. A 5 s timeout and a single retry-less quiet submission cover the register writes.

The write payload is copied into a per-device buffer before it is mapped with blk_rq_map_kern(), so no stack memory is ever mapped for DMA (VMAP_STACK).

brightness_set only caches the colour and marks the LED pending under a spinlock; led_mc_calc_color_components() runs under that lock too, because it writes the shared subled_info array and trigger events call led_set_brightness() without the led_access lock that serializes sysfs stores. A single work item per enclosure then snapshots the pending LEDs and runs one ENE sequence for all of them. Funneling every update through one work item keeps the sequences from interleaving between concurrent LED updates and batches multi-LED updates into a single APPLY. A re-queued run with nothing pending returns before touching the device, so it cannot wear the flash with a pointless SAVE, and the lock keeps a colour write from being reordered after its pending flag on weakly ordered architectures.

This is the monolithic out-of-tree version as verified on hardware; the Kconfig/Makefile/MAINTAINERS wiring lands with the agreed split into a SCSI transport helper and a shared ASUS Aura LED interface.

---
 drivers/leds/rgb/leds-asus-aura-scsi.c | 404 +++++++++++++++++++++++++
 1 file changed, 404 insertions(+)
 create mode 100644 drivers/leds/rgb/leds-asus-aura-scsi.c
drivers/leds/rgb/leds-asus-aura-scsi.c new file +404 -0
new file mode 100644
index 0000000..2ffed53
@@ -0,0 +1,404 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * ASUS Aura RGB over SCSI for ROG external NVMe enclosures
+ * (e.g. ROG STRIX Arion, USB 0b05:1932).
+ *
+ * USB mass-storage device, no HID; the ENE LED controller is driven via
+ * vendor SCSI commands on the disk's LUN. Matched by INQUIRY (vendor
+ * "ROG", model "ESD-S1C"); the sdev is not claimed, sd keeps owning the
+ * disk. Attach manually until the SCSI side agrees on an in-tree hook:
+ * echo asus_aura > /sys/block/sdX/device/dh_state
+ *
+ * Each of the 4 LEDs is a multicolor LED class device,
+ * /sys/class/leds/asus-arion-<H-C-T-L>::led-0..led-3. A colour change
+ * writes only that LED's slots in the ENE colour tables, then applies
+ * without saving (runtime state, no flash wear); MODE must precede
+ * every sequence or the device ignores it. The register layout is
+ * described by struct ene_cdb.
+ *
+ * brightness_set (LED core fast path) only caches the colour and marks
+ * the LED pending under a spinlock; a single work item per enclosure
+ * snapshots all pending LEDs and runs one ENE sequence for them. One
+ * work item also serializes the sequences against each other: the
+ * MODE/colour/APPLY chain must never interleave between
+ * concurrent LED updates.
+ */
+
+#include <linux/array_size.h>
+#include <linux/blk-mq.h>
+#include <linux/blk_types.h>
+#include <linux/blkdev.h>
+#include <linux/build_bug.h>
+#include <linux/byteorder/generic.h>
+#include <linux/cache.h>
+#include <linux/compiler.h>
+#include <linux/compiler_attributes.h>
+#include <linux/container_of.h>
+#include <linux/dev_printk.h>
+#include <linux/err.h>
+#include <linux/jiffies.h>
+#include <linux/led-class-multicolor.h>
+#include <linux/leds.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/sprintf.h>
+#include <linux/string.h>
+#include <linux/workqueue.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_dh.h>
+
+#define ARION_INQ_VENDOR	"ROG"
+#define ARION_INQ_MODEL		"ESD-S1C"
+
+/* The colour table has 16 slots; 4 of them drive LEDs. */
+#define ARION_NUM_LEDS		4
+
+#define ENE_OPCODE		0xec
+
+/* ENE register map (BE16 on the wire). */
+#define ENE_REG_MODE		0x8021	/* 1 = Static selects the colour tables */
+#define ENE_REG_APPLY		0x80a0	/* 0x01 = apply, 0xaa = apply and save */
+#define ENE_REG_COLORS_EFFECT	0x8160	/* colour table, 3 bytes per LED */
+#define ENE_REG_COLORS_DIRECT	0x8100	/* second table some firmware uses */
+
+#define ENE_MODE_STATIC		1
+#define ENE_APPLY		0x01
+#define ENE_TIMEOUT		(5 * HZ)
+
+/* The colour tables are R, B, G on the wire; the subleds are R, G, B. */
+#define ENE_WIRE_R		0
+#define ENE_WIRE_B		1
+#define ENE_WIRE_G		2
+#define ENE_RGB_LEN		3
+
+/*
+ * Vendor CDB: opcode, 'A''S' signature, register, argument count in
+ * byte 13. scsi_execute_cmd() cannot be used for it, see the commit
+ * message.
+ */
+struct ene_cdb {
+	u8		opcode;
+	u8		sig[2];
+	__be16		reg;
+	u8		reserved[8];
+	u8		arg_count;
+	u8		pad[2];
+} __packed;
+
+static_assert(sizeof(struct ene_cdb) == 16);
+
+struct asus_aura_led {
+	struct led_classdev_mc	mc_cdev;
+	struct mc_subled	subled[ENE_RGB_LEN];
+
+	/* Cached colour, consumed by the work item. */
+	u8			rgb[ENE_RGB_LEN];
+	bool			pending;
+
+	struct asus_aura	*aura;
+};
+
+struct asus_aura {
+	struct scsi_device	*sdev;
+	struct asus_aura_led	leds[ARION_NUM_LEDS];
+
+	/* Serializes the cached colours and pending flags. */
+	spinlock_t		lock;
+	struct work_struct	work;
+
+	/*
+	 * DMA-safe staging buffer, the only memory ever mapped for DMA.
+	 * Cacheline-aligned so that invalidation on non-coherent
+	 * architectures cannot clobber the members above.
+	 */
+	u8			tx[ENE_RGB_LEN] ____cacheline_aligned;
+};
+
+static int ene_write_reg(struct asus_aura *aura, u16 reg,
+			 const u8 *tx, u8 len)
+{
+	struct scsi_device *sdev = aura->sdev;
+	struct request *rq;
+	struct scsi_cmnd *scmd;
+	struct ene_cdb cdb = {
+		.opcode		= ENE_OPCODE,
+		.sig		= { 'A', 'S' },
+		.reg		= cpu_to_be16(reg),
+		.arg_count	= len,
+	};
+	int ret;
+
+	rq = scsi_alloc_request(sdev->request_queue, REQ_OP_DRV_OUT, 0);
+	if (IS_ERR(rq))
+		return PTR_ERR(rq);
+
+	/*
+	 * Stack memory is not DMA-safe (VMAP_STACK), so the payload is
+	 * copied into the per-device buffer first.
+	 */
+	memcpy(aura->tx, tx, len);
+	ret = blk_rq_map_kern(rq, aura->tx, len, GFP_NOIO);
+	if (ret)
+		goto out;
+
+	scmd = blk_mq_rq_to_pdu(rq);
+	scmd->cmd_len = sizeof(cdb);
+	memcpy(scmd->cmnd, &cdb, sizeof(cdb));
+	scmd->allowed = 1;
+	rq->timeout = ENE_TIMEOUT;
+	rq->rq_flags |= RQF_QUIET;
+
+	blk_execute_rq(rq, true);
+
+	/* GOOD status is zero in the fields we care about. */
+	ret = scmd->result ? -EIO : 0;
+out:
+	blk_mq_free_request(rq);
+	return ret;
+}
+
+static void asus_aura_work(struct work_struct *work)
+{
+	struct asus_aura *aura = container_of(work, struct asus_aura, work);
+	u8 rgb[ARION_NUM_LEDS][ENE_RGB_LEN];
+	u8 mode = ENE_MODE_STATIC;
+	u8 apply = ENE_APPLY;
+	bool pending[ARION_NUM_LEDS];
+	bool any = false;
+	unsigned long flags;
+	int ret;
+
+	/*
+	 * Fast path without the lock: if nothing is pending, return
+	 * before touching the device. A colour arriving right after
+	 * the check re-queues this work, so nothing is lost.
+	 */
+	for (int i = 0; i < ARRAY_SIZE(aura->leds); i++) {
+		if (READ_ONCE(aura->leds[i].pending)) {
+			any = true;
+			break;
+		}
+	}
+	if (!any)
+		return;
+
+	/* Snapshot the cached colours and clear the pending flags. */
+	spin_lock_irqsave(&aura->lock, flags);
+	for (int i = 0; i < ARRAY_SIZE(aura->leds); i++) {
+		pending[i] = aura->leds[i].pending;
+		aura->leds[i].pending = false;
+		memcpy(rgb[i], aura->leds[i].rgb, ENE_RGB_LEN);
+	}
+	spin_unlock_irqrestore(&aura->lock, flags);
+
+	if (!scsi_device_online(aura->sdev))
+		return;
+
+	/* Mode first: without it the device ignores the sequence. */
+	ret = ene_write_reg(aura, ENE_REG_MODE, &mode, sizeof(mode));
+	if (ret)
+		goto err;
+
+	for (int i = 0; i < ARRAY_SIZE(aura->leds); i++) {
+		if (!pending[i])
+			continue;
+
+		/*
+		 * Both colour tables are written: firmware revisions
+		 * pull from either of them.
+		 */
+		ret = ene_write_reg(aura,
+				    ENE_REG_COLORS_EFFECT + i * ENE_RGB_LEN,
+				    rgb[i], sizeof(rgb[i]));
+		if (ret)
+			goto err;
+
+		ret = ene_write_reg(aura,
+				    ENE_REG_COLORS_DIRECT + i * ENE_RGB_LEN,
+				    rgb[i], sizeof(rgb[i]));
+		if (ret)
+			goto err;
+	}
+
+	/*
+	 * Apply without save: the LED class interface is runtime state
+	 * and does not promise persistence across power cycles, and a
+	 * save on every update would wear the controller flash.
+	 */
+	ret = ene_write_reg(aura, ENE_REG_APPLY, &apply, sizeof(apply));
+	if (ret)
+		goto err;
+
+	return;
+
+err:
+	/*
+	 * This runs detached from the LED core, which has no error
+	 * channel for brightness_set. The write is dropped and logged
+	 * ratelimited; the LED keeps the last successfully applied
+	 * colour until the next user update.
+	 */
+	dev_err_ratelimited(&aura->sdev->sdev_gendev,
+			    "asus_aura: colour update failed: %d\n", ret);
+}
+
+/* Non-blocking LED callback (LED core fast path). Cache colour, defer SCSI. */
+static void asus_aura_set(struct led_classdev *cdev,
+			  enum led_brightness brightness)
+{
+	struct led_classdev_mc *mc = lcdev_to_mccdev(cdev);
+	struct asus_aura_led *led = container_of(mc, struct asus_aura_led, mc_cdev);
+	struct asus_aura *aura = led->aura;
+	unsigned long flags;
+
+	/*
+	 * led_mc_calc_color_components() writes the shared subled_info
+	 * array. Sysfs stores are serialized by the LED core, but
+	 * trigger events call led_set_brightness() without that lock,
+	 * so compute and cache under the aura lock.
+	 */
+	spin_lock_irqsave(&aura->lock, flags);
+
+	led_mc_calc_color_components(mc, brightness);
+
+	led->rgb[ENE_WIRE_R] = led->subled[0].brightness;
+	led->rgb[ENE_WIRE_B] = led->subled[2].brightness;
+	led->rgb[ENE_WIRE_G] = led->subled[1].brightness;
+	led->pending = true;
+
+	spin_unlock_irqrestore(&aura->lock, flags);
+
+	schedule_work(&aura->work);
+}
+
+static int asus_aura_register_led(struct asus_aura *aura, int index)
+{
+	struct asus_aura_led *led = &aura->leds[index];
+	struct led_classdev *cdev = &led->mc_cdev.led_cdev;
+	char hctl[32];
+	int ret;
+
+	led->aura = aura;
+
+	led->subled[0].color_index = LED_COLOR_ID_RED;
+	led->subled[1].color_index = LED_COLOR_ID_GREEN;
+	led->subled[2].color_index = LED_COLOR_ID_BLUE;
+	led->mc_cdev.num_colors = ENE_RGB_LEN;
+	led->mc_cdev.subled_info = led->subled;
+
+	/*
+	 * The sdev's H:C:T:L keeps the names unique when more than one
+	 * enclosure is connected; with a static name the LED core would
+	 * register a second enclosure's LEDs under renamed nodes
+	 * (asus-arion::led-0_1), the wrong device identity. The colons
+	 * are flattened to dashes, the color section stays empty
+	 * (multicolor, palette via multi_intensity) and the four
+	 * identical zones take a "-N" ordinal, as
+	 * Documentation/leds/leds-class.rst asks for.
+	 */
+	strscpy(hctl, dev_name(&aura->sdev->sdev_gendev));
+	strreplace(hctl, ':', '-');
+	cdev->name = kasprintf(GFP_KERNEL, "asus-arion-%s::led-%d", hctl, index);
+	if (!cdev->name)
+		return -ENOMEM;
+
+	cdev->max_brightness = 255;
+	cdev->brightness_set = asus_aura_set;
+
+	led_mc_calc_color_components(&led->mc_cdev, cdev->brightness);
+
+	/*
+	 * NULL parent: a device reference on the sdev would block its
+	 * final release on unplug, which is what calls detach() to
+	 * unregister the LEDs. The cycle leaked nodes and the module
+	 * refcount on every hot-unplug.
+	 */
+	ret = led_classdev_multicolor_register(NULL, &led->mc_cdev);
+	if (ret)
+		kfree(cdev->name);
+	return ret;
+}
+
+/*
+ * Unregister the LEDs before cancelling the work: unregistering removes
+ * the sysfs attributes, so no new brightness_set can schedule the work
+ * afterwards. Cancelling first would leave a window where a brightness
+ * write requeues the work after cancel_work_sync() returned.
+ */
+static void asus_aura_release(struct asus_aura *aura, int num_leds)
+{
+	for (int i = 0; i < num_leds; i++) {
+		led_classdev_multicolor_unregister(&aura->leds[i].mc_cdev);
+		kfree(aura->leds[i].mc_cdev.led_cdev.name);
+	}
+
+	cancel_work_sync(&aura->work);
+	kfree(aura);
+}
+
+static int asus_aura_attach(struct scsi_device *sdev)
+{
+	struct asus_aura *aura;
+	int ret;
+
+	if (strncmp(sdev->vendor, ARION_INQ_VENDOR, strlen(ARION_INQ_VENDOR)) ||
+	    strncmp(sdev->model, ARION_INQ_MODEL, strlen(ARION_INQ_MODEL)))
+		return SCSI_DH_DEV_UNSUPP;
+
+	aura = kzalloc_obj(*aura, GFP_KERNEL);
+	if (!aura)
+		return SCSI_DH_NOMEM;
+
+	aura->sdev = sdev;
+	spin_lock_init(&aura->lock);
+	INIT_WORK(&aura->work, asus_aura_work);
+
+	for (int i = 0; i < ARRAY_SIZE(aura->leds); i++) {
+		ret = asus_aura_register_led(aura, i);
+		if (ret) {
+			asus_aura_release(aura, i);
+			return SCSI_DH_NOMEM;
+		}
+	}
+
+	sdev->handler_data = aura;
+	return SCSI_DH_OK;
+}
+
+static void asus_aura_detach(struct scsi_device *sdev)
+{
+	struct asus_aura *aura = sdev->handler_data;
+
+	if (!aura)
+		return;
+
+	asus_aura_release(aura, ARION_NUM_LEDS);
+	sdev->handler_data = NULL;
+}
+
+static struct scsi_device_handler asus_aura_dh = {
+	.name	= "asus_aura",
+	.module	= THIS_MODULE,
+	.attach	= asus_aura_attach,
+	.detach	= asus_aura_detach,
+};
+
+static int __init asus_aura_init(void)
+{
+	return scsi_register_device_handler(&asus_aura_dh);
+}
+
+static void __exit asus_aura_exit(void)
+{
+	scsi_unregister_device_handler(&asus_aura_dh);
+}
+
+module_init(asus_aura_init);
+module_exit(asus_aura_exit);
+
+MODULE_DESCRIPTION("ASUS Aura RGB over SCSI for ROG NVMe enclosures");
+MODULE_AUTHOR("Liang Haowen");
+MODULE_LICENSE("GPL");
Signature · 1 line
2.55.0
#2 lore raw
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [Low] leds: asus-aura-scsi: undefined function kzalloc_obj() causes build failure - [Low] leds…

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [Low] leds: asus-aura-scsi: undefined function kzalloc_obj() causes build failure
- [Low] leds: asus-aura-scsi: blk_rq_map_kern() missing required request_queue argument
- [Low] leds: asus-aura-scsi: strscpy() called with missing size argument --

commit 4bfc2d1ddcebc584c1ac85ff43152c8925e0316d
Author: Liang Haowen <[email protected]>

leds: asus-aura-scsi: Add ASUS Aura RGB LED driver for ROG NVMe enclosures

This commit adds a new SCSI device handler and multicolour LED class driver to support the ASUS Aura RGB LEDs present in ROG STRIX Arion external NVMe enclosures. It sets up LED instances and maps hardware updates via vendor SCSI commands over the block layer.

Quoted 4 lines
drivers/leds/rgb/leds-asus-aura-scsi.c new file +0 -0
new file mode 100644

[ ... ]

Quoted 5 lines
drivers/leds/rgb/leds-asus-aura-scsi.c new file +5 -0
+static int ene_write_reg(struct asus_aura *aura, u16 reg,
+			 const u8 *tx, u8 len)
+{
+	struct scsi_device *sdev = aura->sdev;
+	struct request *rq;

[ ... ]

drivers/leds/rgb/leds-asus-aura-scsi.c line 143

Quoted 6 lines
drivers/leds/rgb/leds-asus-aura-scsi.c new file +6 -0
+	/*
+	 * Stack memory is not DMA-safe (VMAP_STACK), so the payload is
+	 * copied into the per-device buffer first.
+	 */
+	memcpy(aura->tx, tx, len);
+	ret = blk_rq_map_kern(rq, aura->tx, len, GFP_NOIO);

[Severity: Low]
Does this code compile? The block layer API blk_rq_map_kern() requires 5 arguments, including the struct request_queue pointer as the first argument, but only 4 are provided here.

[ ... ]

Quoted 5 lines
drivers/leds/rgb/leds-asus-aura-scsi.c new file +5 -0
+static int asus_aura_register_led(struct asus_aura *aura, int index)
+{
+	struct asus_aura_led *led = &aura->leds[index];
+	struct led_classdev *cdev = &led->mc_cdev.led_cdev;
+	char hctl[32];

[ ... ]

drivers/leds/rgb/leds-asus-aura-scsi.c line 302

Quoted 11 lines
drivers/leds/rgb/leds-asus-aura-scsi.c new file +11 -0
+	/*
+	 * The sdev's H:C:T:L keeps the names unique when more than one
+	 * enclosure is connected; with a static name the LED core would
+	 * register a second enclosure's LEDs under renamed nodes
+	 * (asus-arion::led-0_1), the wrong device identity. The colons
+	 * are flattened to dashes, the color section stays empty
+	 * (multicolor, palette via multi_intensity) and the four
+	 * identical zones take a "-N" ordinal, as
+	 * Documentation/leds/leds-class.rst asks for.
+	 */
+	strscpy(hctl, dev_name(&aura->sdev->sdev_gendev));

[Severity: Low]
Can strscpy() be called with only 2 arguments here? The function requires 3 arguments (destination, source, count), and a 2-argument macro wrapper does not exist in this tree. This will result in a compilation error.

[ ... ]

drivers/leds/rgb/leds-asus-aura-scsi.c line 351

Quoted 10 lines
drivers/leds/rgb/leds-asus-aura-scsi.c new file +10 -0
+static int asus_aura_attach(struct scsi_device *sdev)
+{
+	struct asus_aura *aura;
+	int ret;
+
+	if (strncmp(sdev->vendor, ARION_INQ_VENDOR, strlen(ARION_INQ_VENDOR)) ||
+	    strncmp(sdev->model, ARION_INQ_MODEL, strlen(ARION_INQ_MODEL)))
+		return SCSI_DH_DEV_UNSUPP;
+
+	aura = kzalloc_obj(*aura, GFP_KERNEL);

[Severity: Low]
Is kzalloc_obj() an intended API here? It appears to be an undefined macro/function which results in an immediate compilation error. Should this be kzalloc() instead?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1

A message that is not in the archive (sent off-list or not yet received): [email protected]

maintainer
#4 lore raw
Quoted 72 lines · Lee Jones

--- checkpatch.pl: clean (0 issues) ---

Quoted 62 lines · Liang Haowen

ASUS ROG external NVMe enclosures (ROG STRIX Arion, USB 0b05:1932) are plain USB mass-storage devices with no HID interface: the Aura LEDs hang off an ENE controller driven by vendor SCSI commands on the same LUN as the disk. The enclosure has 4 independently addressable LEDs, verified on hardware.

Register a scsi_device_handler matched by INQUIRY (vendor "ROG", model "ESD-S1C"); it does not claim the sdev (sd keeps owning the disk) and exposes each LED as a multicolor LED class device, /sys/class/leds/asus-arion-0-0-0-0::led-0 through led-3. The H:C:T:L part of the sdev name keeps the names unique when more than one enclosure is connected, with its colons flattened to dashes. The color section stays empty, since multicolor LEDs enumerate their palette via multi_intensity, and the four identical zones use the function name with a "-N" ordinal, as the naming section in Documentation/leds/leds-class.rst asks for.

Protocol: a 16-byte vendor CDB (opcode 0xec, 'A' 'S' signature, BE16 register index, argument count in byte 13), modelled by struct ene_cdb. MODE 0x8021 (Static) must be written first in every sequence or the device ignores it; colours go to 0x8160 + 3 * led and 0x8100 + 3 * led (3 bytes, wire order R, B, G; both tables are written because firmware revisions pull from one or the other); APPLY 0x80a0 takes 0x01 to apply; the controller also accepts 0xaa to save the state to its flash, which this driver never sends: the LED class interface is runtime state and does not promise persistence across power cycles, and a save on every update would wear the controller flash. The colour reverts to the stored default on power cycle, like any other runtime-only LED.

The CDB cannot go through scsi_execute_cmd(): it sizes the command via scsi_command_size(opcode), which maps vendor opcode 0xec to 10 bytes, so byte 13 is dropped and the device silently ignores the write (GOOD status, no error). scsi_execute_cmd() also offers no way to override the derived length. The request is therefore built with scsi_alloc_request(), which initializes the scsi_cmnd parts a passthrough needs, with cmd_len set to the CDB size, mirroring what SG_IO does from userspace. A 5 s timeout and a single retry-less quiet submission cover the register writes.

The write payload is copied into a per-device buffer before it is mapped with blk_rq_map_kern(), so no stack memory is ever mapped for DMA (VMAP_STACK).

brightness_set only caches the colour and marks the LED pending under a spinlock; led_mc_calc_color_components() runs under that lock too, because it writes the shared subled_info array and trigger events call led_set_brightness() without the led_access lock that serializes sysfs stores. A single work item per enclosure then snapshots the pending LEDs and runs one ENE sequence for all of them. Funneling every update through one work item keeps the sequences from interleaving between concurrent LED updates and batches multi-LED updates into a single APPLY. A re-queued run with nothing pending returns before touching the device, so it cannot wear the flash with a pointless SAVE, and the lock keeps a colour write from being reordered after its pending flag on weakly ordered architectures.

This is the monolithic out-of-tree version as verified on hardware; the Kconfig/Makefile/MAINTAINERS wiring lands with the agreed split into a SCSI transport helper and a shared ASUS Aura LED interface.

Quoted 5 lines
---
 drivers/leds/rgb/leds-asus-aura-scsi.c | 404 +++++++++++++++++++++++++
 1 file changed, 404 insertions(+)
 create mode 100644 drivers/leds/rgb/leds-asus-aura-scsi.c
Quoted 3 lines

A driver source file without 'Kconfig' or 'Makefile' integration is dead code in the tree. Either wire it up now or hold off on submitting until the rest of the pieces are ready.

Also:

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [Low] leds: asus-aura-scsi: undefined function kzalloc_obj() causes build failure
- [Low] leds: asus-aura-scsi: blk_rq_map_kern() missing required request_queue argument
- [Low] leds: asus-aura-scsi: strscpy() called with missing size argument

Was this even tested?

Signature · 1 line
Lee Jones
#5 lore raw
Quoted 3 lines · Lee Jones

A driver source file without 'Kconfig' or 'Makefile' integration is dead code in the tree. Either wire it up now or hold off on submitting until the rest of the pieces are ready.

v10 wires it up: the drivers/leds/rgb/Kconfig and Makefile entries are in, and the series is posted as a new thread under the same subject.

Your 25 Sep note never reached me: neither it nor the copy kernel.org relayed on 14 Oct is in any folder of my mailbox. I first saw its content today, quoted in this mail. The three week gap was delivery, not silence; this is my first chance to answer it.

Quoted 6 lines

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [Low] leds: asus-aura-scsi: undefined function kzalloc_obj() causes build failure
- [Low] leds: asus-aura-scsi: blk_rq_map_kern() missing required request_queue argument
- [Low] leds: asus-aura-scsi: strscpy() called with missing size argument

Was this even tested?

Yes. The driver builds with clang (LLVM=1) against 7.2.4 with zero warnings, loads on the enclosure, and was exercised today: the four LED zones driven to independent colours and checked by eye, 60 sequential and 100 concurrent updates, the sdev deleted mid-write (zero splats, clean detach), rmmod, and a fresh attach through a host scan.

All three findings assume a tree older than v7.0:

- kzalloc_obj() has existed since v7.0 (Kees Cook's series, include/linux/slab.h).
- blk_rq_map_kern() takes four arguments on current kernels; the queue comes from the request itself, and scsi_execute_cmd() calls it the same way.
- strscpy() with two arguments is backed by __strscpy0 in include/linux/string.h, which infers sizeof(dst) and rejects non-array destinations. v10 passes the size explicitly anyway, since it costs nothing.

kzalloc_obj() has now been reported by the bot in all nine of its reviews and blk_rq_map_kern() in eight, and the answer has not changed since the first time. If sashiko could review against a current tree, or drop those two checks, the noise would stop.

Best regards,
Liang