{"id":2222422,"url":"http://patchwork.ozlabs.org/api/1.1/patches/2222422/?format=json","web_url":"http://patchwork.ozlabs.org/project/linux-pci/patch/20260411-rust_leds-v13-3-1208a2821deb@posteo.de/","project":{"id":28,"url":"http://patchwork.ozlabs.org/api/1.1/projects/28/?format=json","name":"Linux PCI development","link_name":"linux-pci","list_id":"linux-pci.vger.kernel.org","list_email":"linux-pci@vger.kernel.org","web_url":null,"scm_url":null,"webscm_url":null},"msgid":"<20260411-rust_leds-v13-3-1208a2821deb@posteo.de>","date":"2026-04-11T15:07:24","name":"[RESEND,v13,3/3] rust: leds: add multicolor classdev abstractions","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"b3a6de1d3aa7ceb2847f515b3fd909c524a4bf21","submitter":{"id":91819,"url":"http://patchwork.ozlabs.org/api/1.1/people/91819/?format=json","name":"Markus Probst","email":"markus.probst@posteo.de"},"delegate":null,"mbox":"http://patchwork.ozlabs.org/project/linux-pci/patch/20260411-rust_leds-v13-3-1208a2821deb@posteo.de/mbox/","series":[{"id":499561,"url":"http://patchwork.ozlabs.org/api/1.1/series/499561/?format=json","web_url":"http://patchwork.ozlabs.org/project/linux-pci/list/?series=499561","date":"2026-04-11T15:07:19","name":"rust: leds: add led classdev abstractions","version":13,"mbox":"http://patchwork.ozlabs.org/series/499561/mbox/"}],"comments":"http://patchwork.ozlabs.org/api/patches/2222422/comments/","check":"pending","checks":"http://patchwork.ozlabs.org/api/patches/2222422/checks/","tags":{},"headers":{"Return-Path":"\n ","X-Original-To":["incoming@patchwork.ozlabs.org","linux-pci@vger.kernel.org"],"Delivered-To":"patchwork-incoming@legolas.ozlabs.org","Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (2048-bit key;\n secure) header.d=posteo.de header.i=@posteo.de header.a=rsa-sha256\n header.s=2017 header.b=PWufRU3e;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org\n (client-ip=104.64.211.4; helo=sin.lore.kernel.org;\n envelope-from=linux-pci+bounces-52399-incoming=patchwork.ozlabs.org@vger.kernel.org;\n receiver=patchwork.ozlabs.org)","smtp.subspace.kernel.org;\n\tdkim=pass (2048-bit key) header.d=posteo.de header.i=@posteo.de\n header.b=\"PWufRU3e\"","smtp.subspace.kernel.org;\n arc=none smtp.client-ip=185.67.36.66","smtp.subspace.kernel.org;\n dmarc=pass (p=none dis=none) header.from=posteo.de","smtp.subspace.kernel.org;\n spf=pass smtp.mailfrom=posteo.de"],"Received":["from sin.lore.kernel.org (sin.lore.kernel.org [104.64.211.4])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4ftH9b1rrvz1y2d\n\tfor ; Sun, 12 Apr 2026 01:08:19 +1000 (AEST)","from smtp.subspace.kernel.org (conduit.subspace.kernel.org\n [100.90.174.1])\n\tby sin.lore.kernel.org (Postfix) with ESMTP id A1EDC3017A0D\n\tfor ; Sat, 11 Apr 2026 15:08:00 +0000 (UTC)","from localhost.localdomain (localhost.localdomain [127.0.0.1])\n\tby smtp.subspace.kernel.org (Postfix) with ESMTP id 065BE3921EC;\n\tSat, 11 Apr 2026 15:07:40 +0000 (UTC)","from mout02.posteo.de (mout02.posteo.de [185.67.36.66])\n\t(using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))\n\t(No client certificate requested)\n\tby smtp.subspace.kernel.org (Postfix) with ESMTPS id 455BF38D01E\n\tfor ; Sat, 11 Apr 2026 15:07:35 +0000 (UTC)","from submission (posteo.de [185.67.36.169])\n\tby mout02.posteo.de (Postfix) with ESMTPS id 3331824010A\n\tfor ; Sat, 11 Apr 2026 17:07:25 +0200 (CEST)","from customer (localhost [127.0.0.1])\n\tby submission (posteo.de) with ESMTPSA id 4ftH8V5Twcz9rxD;\n\tSat, 11 Apr 2026 17:07:22 +0200 (CEST)"],"ARC-Seal":"i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116;\n\tt=1775920059; cv=none;\n b=K77f1QMRZl1/DqlyqQCU9/2WrKFIEnMiVcRjnmA/emyMX2MvbH3sj/aHntA8oC9L9tY+7zs+dwAE46kt369RY5PXdqZsk0xY0RO6Rkvzaq0f60naHXRLaflajYVlxQaEWBVYh2f3bQFoGNTvnnzoYzn7dbq1i0CaGGVYeCkw9ZM=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=subspace.kernel.org;\n\ts=arc-20240116; t=1775920059; c=relaxed/simple;\n\tbh=Vd4ztAIIe3dZLs6GaRmT/tNaiOnzNJCI9BZUDIR6Eu4=;\n\th=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References:\n\t In-Reply-To:To:Cc;\n b=fuEVr4AeF7W1l1Pe8su++kgg65cmPYC8fbIlPDTDN0MhuFzp80swZHQJxXckdHA5kBvekjAlKfLOE7q2cmXbhr1PeiWi3XUYiRtrXmEp9HaNI0yWar6H/3lcGB7A4BSM6KkfePWG7W336xRPd2UoQihJT9YzpfjTTyoGYIeugfc=","ARC-Authentication-Results":"i=1; smtp.subspace.kernel.org;\n dmarc=pass (p=none dis=none) header.from=posteo.de;\n spf=pass smtp.mailfrom=posteo.de;\n dkim=pass (2048-bit key) header.d=posteo.de header.i=@posteo.de\n header.b=PWufRU3e; arc=none smtp.client-ip=185.67.36.66","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed; d=posteo.de; s=2017;\n\tt=1775920045; bh=joSMi7pDlFO/HtroYqlGztfxeKGo9pyV8e9cWGgHrlI=;\n\th=From:Date:Subject:MIME-Version:Content-Type:\n\t Content-Transfer-Encoding:Message-Id:To:Cc:Autocrypt:OpenPGP:From;\n\tb=PWufRU3e0wQ0d90SMOTqII7lQj2XYdMtpAmd3njPzYj8vyv2Wo6u3fePOV8BzQuXs\n\t FDotrlWcXr67/pyKKnt2m+V1N0l2i79LTH9KS9A8pYK6+VlcrRQGwijRIy62rJ9T42\n\t a8mtgiO0cuW/jzKcETTH92WgeR04ZSZMi3Sg2Dx4YXxpg9NRNqkv7So0t0Hg3mnebM\n\t v41FkAcu/nynET22rUX/dHQDhdMPjRd+fD4m6gCc9sikotew9+5CjafIvJCKPS/Z4d\n\t EQ1v794mjBCCCSlR/I4O9kVlxnM9WznneiDISRvy+1vsy7Cqqc7nZPa+bT6pnAKRbF\n\t +dtcqDlOKF/+w==","From":"Markus Probst ","Date":"Sat, 11 Apr 2026 15:07:24 +0000","Subject":"[PATCH RESEND v13 3/3] rust: leds: add multicolor classdev\n abstractions","Precedence":"bulk","X-Mailing-List":"linux-pci@vger.kernel.org","List-Id":"","List-Subscribe":"","List-Unsubscribe":"","MIME-Version":"1.0","Content-Type":"text/plain; charset=\"utf-8\"","Content-Transfer-Encoding":"7bit","Message-Id":"<20260411-rust_leds-v13-3-1208a2821deb@posteo.de>","References":"<20260411-rust_leds-v13-0-1208a2821deb@posteo.de>","In-Reply-To":"<20260411-rust_leds-v13-0-1208a2821deb@posteo.de>","To":"Lee Jones , Pavel Machek ,\n Greg Kroah-Hartman ,\n Dave Ertman , Ira Weiny ,\n Leon Romanovsky , Miguel Ojeda ,\n Alex Gaynor , Gary Guo ,\n\t=?utf-8?q?Bj=C3=B6rn_Roy_Baron?= ,\n Benno Lossin , Andreas Hindborg ,\n Alice Ryhl , Trevor Gross ,\n Danilo Krummrich , \"Rafael J. Wysocki\" ,\n Bjorn Helgaas ,\n =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= ,\n Boqun Feng , Boqun Feng ","Cc":"rust-for-linux@vger.kernel.org, linux-leds@vger.kernel.org,\n linux-kernel@vger.kernel.org, linux-pci@vger.kernel.org,\n Markus Probst ","X-Developer-Signature":"v=1; a=openpgp-sha256; l=20776;\n i=markus.probst@posteo.de; h=from:subject:message-id;\n bh=Vd4ztAIIe3dZLs6GaRmT/tNaiOnzNJCI9BZUDIR6Eu4=;\n b=owEBiQJ2/ZANAwAIATR2H/jnrUPSAcsmYgBp2mOlBOCDvtEibqx7cBnMFQNxPCHYRr2yJDNMH\n L0Y22KCf0aJAk8EAAEIADkWIQSCdBjE9KxY53IwxHM0dh/4561D0gUCadpjpRsUgAAAAAAEAA5t\n YW51MiwyLjUrMS4xMiwyLDIACgkQNHYf+OetQ9LMrA//b8M4NbOsx/u93HPIZTWvpN+xfZp3Vfo\n GhdUnSiD+b385PYKYvO3/sB43Ndz2Ow/CeWmh1kd08ZO+EkB7KzRM/8TqVRISnbFC/KIpd4V+Td\n 6yBG/Y/aSKjSpPg3EZETRo7uxRIx4rXoFw9WaGNH9HdAulfsrJKFJ9Aeb1xrTCMKSdXwB4MADM9\n fDsrZaAMpyK66wGmv7b3MPmPWWppMvwt16AS+IWF4sBhiawo/aVfl4TSNOSilT9hZLarBZo3w5k\n /U3QvTuDZlzAIW4oe6NdkNYTWq4IC6rFJ78EExrtQh4hrS/NQ40IOrwbA1wUyRiH73Si7UKThsW\n LPJm0TsV5ENWVm/npsY2fehgfrdUIDUDkQlV2dApkBSNUxTsofoF7Shg7mYbyxRw8byb358Zzx3\n 8nUn+MgvVg602evxbDPRPjWAVUxsfpBmaTDZGZfSV0W10QIfKvymeUnzO8tS0EbpIlG2slXXLGd\n S46DeZPyzJ1TC/uTPqoHSYoedskEhrcW8NQyWKwi/efRcjnILFKG2iRm6jt9sN/e7NroAWFgR97\n d+KEGRjtxGqRz4ielNfltAmyOOpmBwkxN0cjRmwjGxveyY5mf7I8f55N0nKzLBTIN0eyoMRD5p5\n Yu3eXWJIzo4s2L8jbQ7ZuRNZwiHFRbJdU5p7tkyDEJtGvO8ZzPAo=","X-Developer-Key":"i=markus.probst@posteo.de; a=openpgp;\n fpr=827418C4F4AC58E77230C47334761FF8E7AD43D2","Autocrypt":"addr=markus.probst@posteo.de; prefer-encrypt=mutual;\n keydata=xsFNBGiDvXgBEADAXUceKafpl46S35UmDh2wRvvx+UfZbcTjeQOlSwKP7YVJ4JOZrVs93qReNLkO\n WguIqPBxR9blQ4nyYrqSCV+MMw/3ifyXIm6Pw2YRUDg+WTEOjTixRCoWDgUj1nOsvJ9tVAm76Ww+\n /pAnepVRafMID0rqEfD9oGv1YrfpeFJhyE2zUw3SyyNLIKWD6QeLRhKQRbSnsXhGLFBXCqt9k5JA\n RhgQof9zvztcCVlT5KVvuyfC4H+HzeGmu9201BVyihJwKdcKPq+n/aY5FUVxNTgtI9f8wIbmfAja\n oT1pjXSp+dszakA98fhONM98pOq723o/1ZGMZukyXFfsDGtA3BB79HoopHKujLGWAGskzClwTjRQ\n xBqxh/U/lL1pc+0xPWikTNCmtziCOvv0KA0arDOMQlyFvImzX6oGVgE4ksKQYbMZ3Ikw6L1Rv1J+\n FvN0aNwOKgL2ztBRYscUGcQvA0Zo1fGCAn/BLEJvQYShWKeKqjyncVGoXFsz2AcuFKe1pwETSsN6\n OZncjy32e4ktgs07cWBfx0v62b8md36jau+B6RVnnodaA8++oXl3FRwiEW8XfXWIjy4umIv93tb8\n 8ekYsfOfWkTSewZYXGoqe4RtK80ulMHb/dh2FZQIFyRdN4HOmB4FYO5sEYFr9YjHLmDkrUgNodJC\n XCeMe4BO4iaxUQARAQABzRdtYXJrdXMucHJvYnN0QHBvc3Rlby5kZcLBkQQTAQgAOxYhBIJ0GMT0\n rFjncjDEczR2H/jnrUPSBQJog714AhsDBQsJCAcCAiICBhUKCQgLAgQWAgMBAh4HAheAAAoJEDR2\n H/jnrUPSgdkQAISaTk2D345ehXEkn5z2yUEjaVjHIE7ziqRaOgn/QanCgeTUinIv6L6QXUFvvIfH\n 1OLPwQ1hfvEg9NnNLyFezWSy6jvoVBTIPqicD/r3FkithnQ1IDkdSjrarPMxJkvuh3l7XZHo49GV\n HQ8i5zh5w4YISrcEtE99lJisvni2Jqx7we5tey9voQFDyM8jxlSWv3pmoUTCtBkX/eKHJXosgsuS\n B4TGDCVPOjla/emI5c9MhMG7O4WEEmoSdPbmraPw66YZD6uLyhV4DPHbiDWRzXWnClHSyjB9rky9\n lausFxogvu4l9H+KDsXIadNDWdLdu1/enS/wDd9zh5S78rY2jeXaG4mnf4seEKamZ7KQ6FIHrcyP\n ezdDzssPQcTQcGRMQzCn6wP3tlGk7rsfmyHMlFqdRoNNv+ZER/OkmZFPW655zRfbMi0vtrqK2Awm\n 9ggobb1oktfd9PPNXMUY+DNVlgR2G7jLnenSoQausLUm0pHoNE8TWFv851Y6SOYnvn488sP1Tki5\n F3rKwclawQFHUXTCQw+QSh9ay8xgnNZfH+u9NY7w3gPoeKBOAFcBc2BtzcgekeWS8qgEmm2/oNFV\n G0ivPQbRx8FjRKbuF7g3YhgNZZ0ac8FneuUtJ2PkSIFTZhaAiC0utvxk0ndmWFiW4acEkMZGrLaM\n L2zWNjrqwsD2zsFNBGiDvXgBEADCXQy1n7wjRxG12DOVADawjghKcG+5LtEf31WftHKLFbp/HArj\n BhkT6mj+CCI1ClqY+FYU5CK/s0ScMfLxRGLZ0Ktzawb78vOgBVFT3yB1yWBTewsAXdqNqRooaUNo\n 8cG/NNJLjhccH/7PO/FWX5qftOVUJ/AIsAhKQJ18Tc8Ik73v427EDxuKb9mTAnYQFA3Ev3hAiVbO\n 6Rv39amVOfJ8sqwiSUGidj2Fctg2aB5JbeMln0KCUbTD1LhEFepeKypfofAXQbGwaCjAhmkWy/q3\n IT1mUrPxOngbxdRoOx1tGUC0HCMUW1sFaJgQPMmDcR0JGPOpgsKnitsSnN7ShcCr1buel7vLnUMD\n +TAZ5opdoF6HjAvAnBQaijtK6minkrM0seNXnCg0KkV8xhMNa6zCs1rq4GgjNLJue2EmuyHooHA4\n 7JMoLVHcxVeuNTp6K2+XRx0Pk4e2Lj8IVy9yEYyrywEOC5XRW37KJjsiOAsumi1rkvM7QREWgUDe\n Xs0+RpxI3QrrANh71fLMRo7LKRF3Gvw13NVCCC9ea20P4PwhgWKStkwO2NO+YJsAoS1QycMi/vKu\n 0EHhknYXamaSV50oZzHKmX56vEeJHTcngrM8R1SwJCYopCx9gkz90bTVYlitJa5hloWTYeMD7FNj\n Y6jfVSzgM/K4gMgUNDW/PPGeMwARAQABwsF2BBgBCAAgFiEEgnQYxPSsWOdyMMRzNHYf+OetQ9IF\n AmiDvXgCGwwACgkQNHYf+OetQ9LHDBAAhk+ab8+WrbS/b1/gYW3q1KDiXU719nCtfkUVXKidW5Ec\n Idlr5HGt8ilLoxSWT2Zi368iHCXS0WenGgPwlv8ifvB7TOZiiTDZROZkXjEBmU4nYjJ7GymawpWv\n oQwjMsPuq6ysbzWtOZ7eILx7cI0FjQeJ/Q2baRJub0uAZNwBOxCkAS6lpk5Fntd2u8CWmDQo4SYp\n xeuQ+pwkp0yEP30RhN2BO2DXiBEGSZSYh+ioGbCHQPIV3iVj0h6lcCPOqopZqyeCfigeacBI0nvN\n jHWz/spzF3+4OS+3RJvoHtAQmProxyGib8iVsTxgZO3UUi4TSODeEt0i0kHSPY4sCciOyXfAyYoD\n DFqhRjOEwBBxhr+scU4C1T2AflozvDwq3VSONjrKJUkhd8+WsdXxMdPFgBQuiKKwUy11mz6KQfcR\n wmDehF3UaUoxa+YIhWPbKmycxuX/D8SvnqavzAeAL1OcRbEI/HsoroVlEFbBRNBZLJUlnTPs8ZcU\n 4+8rq5YX1GUrJL3jf6SAfSgO7UdkEET3PdcKFYtS+ruV1Cp5V0q4kCfI5jk25iiz8grM2wOzVSsc\n l1mEkhiEPH87HP0whhb544iioSnumd3HJKL7dzhRegsMizatupp8D65A2JziW0WKopa1iw9fti3A\n aBeNN4ijKZchBXHPgVx+YtWRHfcm4l8=","OpenPGP":"url=https://posteo.de/keys/markus.probst@posteo.de.asc;\n preference=encrypt"},"content":"Implement the abstractions needed for multicolor led class devices,\nincluding:\n\n* `led::MultiColor` - the led mode implementation\n\n* `MultiColorSubLed` - a safe wrapper arround `mc_subled`\n\n* `led::MultiColorDevice` - a safe wrapper around `led_classdev_mc`\n\n* `led::DeviceBuilder::build_multicolor` - a function to register a new\n multicolor led class device\n\nSigned-off-by: Markus Probst \n---\n rust/bindings/bindings_helper.h | 1 +\n rust/kernel/led.rs | 30 +++-\n rust/kernel/led/multicolor.rs | 387 ++++++++++++++++++++++++++++++++++++++++\n 3 files changed, 417 insertions(+), 1 deletion(-)","diff":"diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h\nindex 083cc44aa952..3171e3e6351c 100644\n--- a/rust/bindings/bindings_helper.h\n+++ b/rust/bindings/bindings_helper.h\n@@ -63,6 +63,7 @@\n #include \n #include \n #include \n+#include \n #include \n #include \n #include \ndiff --git a/rust/kernel/led.rs b/rust/kernel/led.rs\nindex 5035563d68a3..a862d88cab29 100644\n--- a/rust/kernel/led.rs\n+++ b/rust/kernel/led.rs\n@@ -33,8 +33,12 @@\n }, //\n };\n \n+#[cfg(CONFIG_LEDS_CLASS_MULTICOLOR)]\n+mod multicolor;\n mod normal;\n \n+#[cfg(CONFIG_LEDS_CLASS_MULTICOLOR)]\n+pub use multicolor::{MultiColor, MultiColorDevice, MultiColorSubLed};\n pub use normal::{Device, Normal};\n \n /// The name of the led is determined by the driver.\n@@ -279,7 +283,24 @@ pub enum Color {\n Violet = bindings::LED_COLOR_ID_VIOLET,\n Yellow = bindings::LED_COLOR_ID_YELLOW,\n Ir = bindings::LED_COLOR_ID_IR,\n+ #[cfg_attr(\n+ CONFIG_LEDS_CLASS_MULTICOLOR,\n+ doc = \"Use this color for a [`MultiColor`] led.\"\n+ )]\n+ #[cfg_attr(\n+ not(CONFIG_LEDS_CLASS_MULTICOLOR),\n+ doc = \"Use this color for a `MultiColor` led.\"\n+ )]\n+ /// If the led supports RGB, use [`Color::Rgb`] instead.\n Multi = bindings::LED_COLOR_ID_MULTI,\n+ #[cfg_attr(\n+ CONFIG_LEDS_CLASS_MULTICOLOR,\n+ doc = \"Use this color for a [`MultiColor`] led with rgb support.\"\n+ )]\n+ #[cfg_attr(\n+ not(CONFIG_LEDS_CLASS_MULTICOLOR),\n+ doc = \"Use this color for a `MultiColor` led with rgb support.\"\n+ )]\n Rgb = bindings::LED_COLOR_ID_RGB,\n Purple = bindings::LED_COLOR_ID_PURPLE,\n Orange = bindings::LED_COLOR_ID_ORANGE,\n@@ -319,7 +340,14 @@ fn try_from(value: u32) -> core::result::Result {\n ///\n /// Each led mode has its own led class device type with different capabilities.\n ///\n-/// See [`Normal`].\n+#[cfg_attr(\n+ CONFIG_LEDS_CLASS_MULTICOLOR,\n+ doc = \"See [`Normal`] and [`MultiColor`].\"\n+)]\n+#[cfg_attr(\n+ not(CONFIG_LEDS_CLASS_MULTICOLOR),\n+ doc = \"See [`Normal`] and `MultiColor`.\"\n+)]\n pub trait Mode: private::Sealed {\n /// The class device for the led mode.\n type Device>;\ndiff --git a/rust/kernel/led/multicolor.rs b/rust/kernel/led/multicolor.rs\nnew file mode 100644\nindex 000000000000..726fdaf068cb\n--- /dev/null\n+++ b/rust/kernel/led/multicolor.rs\n@@ -0,0 +1,387 @@\n+// SPDX-License-Identifier: GPL-2.0\n+\n+//! Led mode for the `struct led_classdev_mc`.\n+//!\n+//! C header: [`include/linux/led-class-multicolor.h`](srctree/include/linux/led-class-multicolor.h)\n+\n+use crate::alloc::KVec;\n+\n+use super::*;\n+\n+/// The led mode for the `struct led_classdev_mc`. Leds with this mode can have multiple colors.\n+pub enum MultiColor {}\n+impl Mode for MultiColor {\n+ type Device> = MultiColorDevice;\n+}\n+impl private::Sealed for MultiColor {}\n+\n+/// The multicolor sub led info representation.\n+///\n+/// This structure represents the Rust abstraction for a C `struct mc_subled`.\n+#[repr(C)]\n+#[derive(Copy, Clone, Debug)]\n+#[non_exhaustive]\n+pub struct MultiColorSubLed {\n+ /// the color of the sub led\n+ pub color: Color,\n+ /// the brightness of the sub led.\n+ ///\n+ /// The value will be automatically calculated.\n+ /// See `MultiColor::pre_brightness_set`.\n+ pub brightness: u32,\n+ /// the intensity of the sub led.\n+ pub intensity: u32,\n+ /// arbitrary data for the driver to store.\n+ pub channel: u32,\n+}\n+\n+// We directly pass a reference to the `subled_info` field in `led_classdev_mc` to the driver via\n+// `Device::subleds()`.\n+// We need safeguards to ensure `MultiColorSubLed` and `mc_subled` stay identical.\n+const _: () = {\n+ use core::mem::offset_of;\n+\n+ const fn assert_same_type(_: &T, _: &T) {}\n+\n+ let rust_zeroed = MultiColorSubLed {\n+ color: Color::White,\n+ brightness: 0,\n+ intensity: 0,\n+ channel: 0,\n+ };\n+ let c_zeroed = bindings::mc_subled {\n+ color_index: 0,\n+ brightness: 0,\n+ intensity: 0,\n+ channel: 0,\n+ };\n+\n+ assert!(offset_of!(MultiColorSubLed, color) == offset_of!(bindings::mc_subled, color_index));\n+ assert_same_type(&0u32, &c_zeroed.color_index);\n+\n+ assert!(\n+ offset_of!(MultiColorSubLed, brightness) == offset_of!(bindings::mc_subled, brightness)\n+ );\n+ assert_same_type(&rust_zeroed.brightness, &c_zeroed.brightness);\n+\n+ assert!(offset_of!(MultiColorSubLed, intensity) == offset_of!(bindings::mc_subled, intensity));\n+ assert_same_type(&rust_zeroed.intensity, &c_zeroed.intensity);\n+\n+ assert!(offset_of!(MultiColorSubLed, channel) == offset_of!(bindings::mc_subled, channel));\n+ assert_same_type(&rust_zeroed.channel, &c_zeroed.channel);\n+\n+ assert!(size_of::() == size_of::());\n+};\n+\n+impl MultiColorSubLed {\n+ /// Create a new multicolor sub led info.\n+ pub const fn new(color: Color) -> Self {\n+ Self {\n+ color,\n+ brightness: 0,\n+ intensity: 0,\n+ channel: 0,\n+ }\n+ }\n+\n+ /// Set arbitrary data for the driver.\n+ pub const fn channel(mut self, channel: u32) -> Self {\n+ self.channel = channel;\n+ self\n+ }\n+\n+ /// Set the initial intensity of the subled.\n+ pub const fn initial_intensity(mut self, intensity: u32) -> Self {\n+ self.intensity = intensity;\n+ self\n+ }\n+}\n+\n+/// The multicolor led class device representation.\n+///\n+/// This structure represents the Rust abstraction for a multicolor led class device.\n+#[pin_data(PinnedDrop)]\n+pub struct MultiColorDevice> {\n+ #[pin]\n+ ops: T,\n+ #[pin]\n+ classdev: Opaque,\n+}\n+\n+impl<'a, S: DeviceBuilderState> DeviceBuilder<'a, S> {\n+ /// Registers a new [`MulticolorDevice`].\n+ pub fn build_multicolor>(\n+ self,\n+ parent: &'a T::Bus,\n+ ops: impl PinInit + 'a,\n+ subleds: &'a [MultiColorSubLed],\n+ ) -> impl PinInit>, Error> + 'a {\n+ Devres::new(\n+ parent.as_ref(),\n+ try_pin_init!(MultiColorDevice {\n+ ops <- ops,\n+ classdev <- Opaque::try_ffi_init(|ptr: *mut bindings::led_classdev_mc| {\n+ let mut used = 0;\n+ if subleds.iter().any(|subled| {\n+ let bit = 1 << (subled.color as u32);\n+ if (used & bit) != 0 {\n+ true\n+ } else {\n+ used |= bit;\n+ false\n+ }\n+ }) {\n+ dev_err!(parent.as_ref(), \"duplicate color in multicolor led\\n\");\n+ return Err(EINVAL);\n+ }\n+ let mut subleds_vec = KVec::new();\n+ subleds_vec.extend_from_slice(subleds, GFP_KERNEL)?;\n+ let (subled_info, num_colors, capacity) = subleds_vec.into_raw_parts();\n+ debug_assert_eq!(num_colors, capacity);\n+\n+ // SAFETY: `try_ffi_init` guarantees that `ptr` is valid for write.\n+ // `led_classdev_mc` gets fully initialized in-place by\n+ // `led_classdev_multicolor_register_ext` including `mutex` and `list_head`.\n+ unsafe {\n+ ptr.write(bindings::led_classdev_mc {\n+ led_cdev: bindings::led_classdev {\n+ brightness_set: (!T::BLOCKING)\n+ .then_some(Adapter::::brightness_set_callback),\n+ brightness_set_blocking: T::BLOCKING\n+ .then_some(Adapter::::brightness_set_blocking_callback),\n+ brightness_get: T::HAS_BRIGHTNESS_GET\n+ .then_some(Adapter::::brightness_get_callback),\n+ blink_set: T::HAS_BLINK_SET\n+ .then_some(Adapter::::blink_set_callback),\n+ max_brightness: T::MAX_BRIGHTNESS,\n+ brightness: self.initial_brightness,\n+ default_trigger: self\n+ .default_trigger\n+ .map_or(core::ptr::null(), CStrExt::as_char_ptr),\n+ color: self.color as u32,\n+ name: self.name.map_or(core::ptr::null(), CStrExt::as_char_ptr),\n+ ..bindings::led_classdev::default()\n+ },\n+ num_colors: u32::try_from(num_colors)?,\n+ // CAST: The safeguards in the const block ensure that\n+ // `MultiColorSubLed` has an identical layout to `mc_subled`.\n+ subled_info: subled_info.cast::(),\n+ })\n+ };\n+\n+ let mut init_data = bindings::led_init_data {\n+ fwnode: self\n+ .fwnode\n+ .as_ref()\n+ .map_or(core::ptr::null_mut(), |fwnode| fwnode.as_raw()),\n+ default_label: core::ptr::null(),\n+ devicename: self\n+ .devicename\n+ .map_or(core::ptr::null(), CStrExt::as_char_ptr),\n+ devname_mandatory: self.devname_mandatory,\n+ };\n+\n+ // SAFETY:\n+ // - `parent.as_ref().as_raw()` is guaranteed to be a pointer to a valid\n+ // `device`.\n+ // - `ptr` is guaranteed to be a pointer to an initialized `led_classdev_mc`.\n+ to_result(unsafe {\n+ bindings::led_classdev_multicolor_register_ext(\n+ parent.as_ref().as_raw(),\n+ ptr,\n+ if self.name.is_none() {\n+ &raw mut init_data\n+ } else {\n+ core::ptr::null_mut()\n+ },\n+ )\n+ })\n+ .inspect_err(|_err| {\n+ // SAFETY: `subled_info` is guaranteed to be a valid array pointer to\n+ // `mc_subled` with the length and capacity of `num_colors`.\n+ drop(unsafe { KVec::from_raw_parts(subled_info, num_colors, num_colors) });\n+ })?;\n+\n+ core::mem::forget(self.fwnode); // keep the reference count incremented\n+\n+ Ok::<_, Error>(())\n+ }),\n+ }),\n+ )\n+ }\n+}\n+\n+impl> MultiColorDevice {\n+ /// # Safety\n+ /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a\n+ /// `led::MultiColorDevice`.\n+ unsafe fn from_raw<'a>(led_cdev: *mut bindings::led_classdev) -> &'a Self {\n+ // SAFETY: The function's contract guarantees that `led_cdev` points to a `led_classdev`\n+ // field embedded within a valid `led::MultiColorDevice`. `container_of!` can therefore\n+ // safely calculate the address of the containing struct.\n+ let led_mc_cdev = unsafe { container_of!(led_cdev, bindings::led_classdev_mc, led_cdev) };\n+\n+ // SAFETY: It is guaranteed that `led_mc_cdev` points to a `led_classdev_mc`\n+ // field embedded within a valid `led::MultiColorDevice`. `container_of!` can therefore\n+ // safely calculate the address of the containing struct.\n+ unsafe { &*container_of!(Opaque::cast_from(led_mc_cdev), Self, classdev) }\n+ }\n+\n+ fn parent(&self) -> &device::Device {\n+ // SAFETY: `self.classdev.get()` is guaranteed to be a valid pointer to `led_classdev_mc`.\n+ unsafe { device::Device::from_raw((*(*self.classdev.get()).led_cdev.dev).parent) }\n+ }\n+\n+ /// Returns the subleds passed to [`Device::new_multicolor`].\n+ pub fn subleds(&self) -> &[MultiColorSubLed] {\n+ // SAFETY: The existence of `self` guarantees that `self.classdev.get()` is a pointer to a\n+ // valid `led_classdev_mc`.\n+ let raw = unsafe { &*self.classdev.get() };\n+ // SAFETY: `raw.subled_info` is a valid pointer to `mc_subled[num_colors]`.\n+ // CAST: The safeguards in the const block ensure that `MultiColorSubLed` has an identical\n+ // layout to `mc_subled`.\n+ unsafe {\n+ core::slice::from_raw_parts(\n+ raw.subled_info.cast::(),\n+ raw.num_colors as usize,\n+ )\n+ }\n+ }\n+}\n+\n+// SAFETY: A `led::MultiColorDevice` can be unregistered from any thread.\n+unsafe impl + Send> Send for MultiColorDevice {}\n+\n+// SAFETY: `led::MultiColorDevice` can be shared among threads because all methods of `led::Device`\n+// are thread safe.\n+unsafe impl + Sync> Sync for MultiColorDevice {}\n+\n+struct Adapter> {\n+ _p: PhantomData,\n+}\n+\n+impl> Adapter {\n+ /// # Safety\n+ /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a\n+ /// `led::MultiColorDevice`.\n+ /// This function is called on setting the brightness of a led.\n+ unsafe extern \"C\" fn brightness_set_callback(\n+ led_cdev: *mut bindings::led_classdev,\n+ brightness: u32,\n+ ) {\n+ // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a\n+ // `led_classdev` embedded within a `led::MultiColorDevice`.\n+ let classdev = unsafe { MultiColorDevice::::from_raw(led_cdev) };\n+ // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.\n+ let parent = unsafe { T::Bus::from_device(classdev.parent()) };\n+\n+ // SAFETY: `classdev.classdev.get()` is guaranteed to be a pointer to a valid\n+ // `led_classdev_mc`.\n+ unsafe { bindings::led_mc_calc_color_components(classdev.classdev.get(), brightness) };\n+\n+ let _ = classdev.ops.brightness_set(parent, classdev, brightness);\n+ }\n+\n+ /// # Safety\n+ /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a\n+ /// `led::MultiColorDevice`.\n+ /// This function is called on setting the brightness of a led immediately.\n+ unsafe extern \"C\" fn brightness_set_blocking_callback(\n+ led_cdev: *mut bindings::led_classdev,\n+ brightness: u32,\n+ ) -> i32 {\n+ from_result(|| {\n+ // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a\n+ // `led_classdev` embedded within a `led::MultiColorDevice`.\n+ let classdev = unsafe { MultiColorDevice::::from_raw(led_cdev) };\n+ // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.\n+ let parent = unsafe { T::Bus::from_device(classdev.parent()) };\n+\n+ // SAFETY: `classdev.classdev.get()` is guaranteed to be a pointer to a valid\n+ // `led_classdev_mc`.\n+ unsafe { bindings::led_mc_calc_color_components(classdev.classdev.get(), brightness) };\n+\n+ classdev.ops.brightness_set(parent, classdev, brightness)?;\n+ Ok(0)\n+ })\n+ }\n+\n+ /// # Safety\n+ /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a\n+ /// `led::MultiColorDevice`.\n+ /// This function is called on getting the brightness of a led.\n+ unsafe extern \"C\" fn brightness_get_callback(led_cdev: *mut bindings::led_classdev) -> u32 {\n+ // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a\n+ // `led_classdev` embedded within a `led::MultiColorDevice`.\n+ let classdev = unsafe { MultiColorDevice::::from_raw(led_cdev) };\n+ // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.\n+ let parent = unsafe { T::Bus::from_device(classdev.parent()) };\n+\n+ classdev.ops.brightness_get(parent, classdev)\n+ }\n+\n+ /// # Safety\n+ /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a\n+ /// `led::MultiColorDevice`.\n+ /// `delay_on` and `delay_off` must be valid pointers to `usize` and have\n+ /// exclusive access for the period of this function.\n+ /// This function is called on enabling hardware accelerated blinking.\n+ unsafe extern \"C\" fn blink_set_callback(\n+ led_cdev: *mut bindings::led_classdev,\n+ delay_on: *mut usize,\n+ delay_off: *mut usize,\n+ ) -> i32 {\n+ from_result(|| {\n+ // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a\n+ // `led_classdev` embedded within a `led::MultiColorDevice`.\n+ let classdev = unsafe { MultiColorDevice::::from_raw(led_cdev) };\n+ // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.\n+ let parent = unsafe { T::Bus::from_device(classdev.parent()) };\n+\n+ classdev.ops.blink_set(\n+ parent,\n+ classdev,\n+ // SAFETY: The function's contract guarantees that `delay_on` points to a `usize`\n+ // and is exclusive for the period of this function.\n+ unsafe { &mut *delay_on },\n+ // SAFETY: The function's contract guarantees that `delay_off` points to a `usize`\n+ // and is exclusive for the period of this function.\n+ unsafe { &mut *delay_off },\n+ )?;\n+ Ok(0)\n+ })\n+ }\n+}\n+\n+#[pinned_drop]\n+impl> PinnedDrop for MultiColorDevice {\n+ fn drop(self: Pin<&mut Self>) {\n+ let raw = self.classdev.get();\n+ // SAFETY: The existence of `self` guarantees that `self.classdev.get()` is a pointer to a\n+ // valid `led_classdev_mc`.\n+ let dev: &device::Device = unsafe { device::Device::from_raw((*raw).led_cdev.dev) };\n+\n+ let _fwnode = dev\n+ .fwnode()\n+ // SAFETY: the reference count of `fwnode` has previously been\n+ // incremented in `led::Device::new`.\n+ .map(|fwnode| unsafe { ARef::from_raw(NonNull::from(fwnode)) });\n+\n+ // SAFETY: The existence of `self` guarantees that `self.classdev` has previously been\n+ // successfully registered with `led_classdev_multicolor_register_ext`.\n+ unsafe { bindings::led_classdev_multicolor_unregister(raw) };\n+\n+ // SAFETY: `raw` is guaranteed to be a valid pointer to `led_classdev_mc`.\n+ let led_cdev = unsafe { &*raw };\n+\n+ // SAFETY: `subled_info` is guaranteed to be a valid array pointer to `mc_subled` with the\n+ // length and capacity of `led_cdev.num_colors`. See `led::MulticolorDevice::new`.\n+ drop(unsafe {\n+ KVec::from_raw_parts(\n+ led_cdev.subled_info,\n+ led_cdev.num_colors as usize,\n+ led_cdev.num_colors as usize,\n+ )\n+ });\n+ }\n+}\n","prefixes":["RESEND","v13","3/3"]}