From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 07FEF157487; Fri, 9 Jan 2026 21:46:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995202; cv=none; b=vFoEGmj/3MLi8XonXdMkaIN/KMjSpsqvGv8SYzojvDlVwHUEmIAqhBfxtHjMvcmiaj/23rTijEzcuaFmKpmeuQzvkvX4JpRTue/PPZc68RzraMXYGe477+8UiUXRMsEOohAKTmPUeoSTZJQbie4Z6DIr9gji+TnGkyub/dUaPUA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995202; c=relaxed/simple; bh=7lv7dl94TLAa8utM25KtA1qUFVlG4bmIVKIeE3hUllo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=TakoCQoPACVEvODMUTEi+wbrU4dup6mZbk2ifRKPcMbFVaBX8Ad/JGwW3EX7L5JJFXeMl6TX1I1QU1hxKxTjNWLLJGnaao1qiT5lqRy2FEOek/WER2xWnUCdY1s/lcygwvAXPdbuh15V2jLpc/CIAZAHu7XppJ+55WeE+HY6ln4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=N3NspNE3; arc=none smtp.client-ip=212.227.15.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="N3NspNE3" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995198; x=1768599998; i=w_armin@gmx.de; bh=PM9dWNrr5vcKN24N1IFbxWjuH139BVKsH3YStFxw+P0=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Type:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=N3NspNE3hUjG8yNtzRKp6FrCFuXuGHpRQPSE+abMHnC+lxpYJDp1+YtKat5nAuvA u4MNzFSsSMwy/ibl6vjIh23jSnfcB8xY8TBQwkUkAige8/tFdYhM/V9JtUjL0RSkE TyYOrBnDi7C10D0eAUgsrVDtwrfHcQBkyEHZctbUYhnH97kDerCfz2uB3qvT5Qj5S e/LXUyNbHhca5Jv3ssSDonabFtpqYxTzXaWSkf0qiaRgGQojx+5he5paXX8efxV0o M/ppYrztyqspl/Zr/DrAMLOc9nN+/pHZFSZQq6QvoHJ/a/1eihzzmFd2Ur5Zu3+bu unL4sxiUScNduaG5ug== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MybGh-1w3PCi3ThN-00ru4X; Fri, 09 Jan 2026 22:46:38 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 1/9] platform/wmi: Introduce marshalling support Date: Fri, 9 Jan 2026 22:46:11 +0100 Message-Id: <20260109214619.7289-2-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:ewMP6dAhh2GTYrL6FCVP3g/+G+bdUpknvfIDs2/5T2NvKfq1+rQ zWFucPf/wY3CXPSJZXKnwbpsN4wxUvNDiVIt2lRitNSb1wvnZych/0Mmet3c10JUYV2qxSt JRdFkMRy36dZejKvrb7x0dt2LTcxiH666d2MvWUemZ4NbPCvsja2MsS1Vtjat6XCw4MqSfx EFyC8PpLOgc21CuzFVlQw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:4qenYJBiK94=;tCdegUsXK2Eg180Wr5qIXM5vylm IrLJf/mX4SeS6Tz40cj6Pwg09GEPIdokyouv1kQz5Jdbwr33TqIyBFgt/8nCVDF6mLS4CJyiN e/znSuxaOwmcdbW3g76rEzID7eWr88NRS5B3IHMRjf1JTy4hu9LD4jbXdjpTUzDxaJ0ib0mM2 jXxuCIZ1I6jHaStdeCCXU3Sn6A4W1pn1PeoEnx05h2NLF62oCQOQwkXiACUvkVRD4VrDlmb33 tmT1fpxmDX0P+T+aMV0LKVwdZKbpxj2eHeCr5IYogG0HuVlP6/HJjTM8Jra6KzO+xyoPuagD9 F7I8Vu4oVWjB56WzP5NCZFNP9jp2xdTDK2PU5cDKSgUFhbLSzJpduwBfxOTHvm9ej3ixl9MHa 2T8lnEVVW/u7oFqHwQK1m9YMKt/Ehr8Fwun9YOLDkcxoeVBXGncko/skcsAQJ3Rwe2ReMRZ3J o6pAjeEcyi17KhkGXwq8p/f7aOsW+AhUWT/Qgbd72/TTtgLTSShU3ttdANEbRnHAHuIjWSMSt 3JHxhSPcEXbr2KYDPgspngsCSGMP0XsLvPyN8L4rEE+p5DAOvjWD37cQRfAJyIkhRtsBy4Pj2 D17arXqQBVeMwhdjlW2kmxBoHJJpGI387kO5TVR6etRc2thTMpDcKbT9aPO9BVxSFi33jtKM4 +J2hLhDQpbjXD95mUyC4uQ26gG0iZ3dEhRG8jym6/Cxie8FP/uD3JyyTwsdLQyOQ/xtDJUHkM 4o2p4Kx0hwLgjVIKNYT2vIei9wqEbxsv8gRilRaSpJbfy7hDSEDbiwuSdQ2+FCmb49dkyqrJR 58MPgNO7PdcGLlQGwrrivZtfTO0oNyeBQDep0TvnHiZn4tNE69jYzgJJ/0rGLS1N0iaXhUrtC Y7BBo4DKzz02mQ2+ibMRD7jsENU1lxOEZah0t9hPyQt5+iQoRe7wGOmd6UXYTWWXgfMBjjLJx XnA+WFn/VXo56eDT8DLgCpcKAooDiNDQI2Ebe3XnNz/K+855DmAtog7czku/fhpW74kuLBf5S 4uyA1PkEK1KOGqaREYjB7aeMZHolxQZg48vDIo8kyIWzA8Ih9EzwnbcFkpMQnwP+ddOAdYbvj ENXc7xgJujNERLjyBTmeDM2bLeYFffgbZonurP8vA2rYGHrCg0MX2KgGWQaiRbZYF/fur9iXu SJ/oa47Lilp7/tzu1tR8ZJgy+6ZmOVnL7Sa/qVHYSMKzBdVs85CDQ+RaRJFiTYPOtoBQHvOif wIfYXFEbRETeM1QZ5EEkH+AdSrmH/VNyWyAAuZKukRbz/QXUguRzK5wjTtTAfDPyI4DMZw6Mn Ufoieytg7FjCUk+VduOJw4aurIBbyVHWKItFQEVFex5Y/ucJTjR4vOufqIwmQCZPygkLxepxI PkrV5OrORQAQ/ThITLkRqok7AVkvo21G5/qgdiKNg998C4Wdl9t0hcxDHhS3+KIRRyrX6ZyM2 sFDA0ngc5DxN8mzZEpSAhzo5wAsaGNxmK94TFy3oWGeVe0Mo/Tii8w1bkeTfghqAKzu+Oxoa2 02c5OAjYD12UYoVn+mr4EDE/x4iyCiuz2QT5O+ZUZ6xl7DStap4ChYWtHoU1OGcl8l7DRrwp5 LOGbuUS3ofpzajLF5v/NRDNF1NVAjpLIiHNq98vN8P2aFecneddJHp2upH1EZsDxbHMPNZmfY ustRx9rG7O/rd7PS5Xel7dZQoG9B/LbBe7QgZPjaaLmdblBIYb4bqeTnIzy58rrBS5BnUYtSf tEpudTYDxRyHYCo+aqy3sD7K3kVw9LTrRpygkKPpAs80zoou6pUMuw/JyHR1jarxqpy4RGlo0 aOefEEC42t+u45B1ycgydfTWWXwHv2uO7dxW8DfogZRrCJLi/UDA1inz9ro+ZlK3nBcXYCE0H beMoJ/wlp/ZMMuF1tGVAPfaOKRXRXaLYWY9ZssIt/tTtJCP2G0nvDiSegtv8tNlQv5WakQH/7 +wz8on2W5cEuvGFKZaTYvEHePggvXWL0FI1vPNIOqLM7fVCkLHWYTPJdOZpHXaqfKAM2W5wHM CJRQ9whhsVWp+DDdpRcv3rCY6aSm06PkFaRR5o0fCB89x5YvXTZJnvYHi0fTohVhV+X6/3cr7 V6aIIRuPTOKJp5TTquHtAIAikEOF0oGNkerXBdszJjDD02GgffWdOcA3xgpHpP9R1WUQuuUzx gvkXgmoEOZP/GAAlzj+rran+9Mk+PvCyvG/9xHta7+XOGOEaNghh2x1HzdlFh/UYXIdyweoSh Ne/YaYIthxtTY27cCCHQHx+Nvf+/yYVoSrHxpUA9N1ZDVJNB3c26OYcSVIGnimbnxbuW5F4sV PduM2xMbtfci/C3VqILD1cuNN9Q9SwRK4SJHG6JNrvhhelVQecPC0bWmp+cXWeQ7ZLajOJWT9 iXsT21J25BPNDx9LFaa7lR/hemQCl9rU1fGFUuQAup9Pjo0PAiDu8gDUOuQ9x7aAaabxlpHv9 uVfT6Smz7wv9DVsYRxXonmBtqqogV1RM7isuiFuEF7chPitbOfbPEEgSmzX2u/VlqxGjpGQQg vHeqsY1Jt+31u+1xnjySfNsZFxZBe/DGV0W1dFu2yRw4OaI/RWWgXmztbiIIeu9hN6vfyMaOs jNkVhbKagTeEuqeSoiHbqe5juOSZyTifkYUyRJqRIRhz4ASbo0hECzv+HWcGF/Y8RMoGtf3uX QMF9B+0OuKib9UHAFwHEMcL7CDHfxdxSgiYwDX39kDIu8OsERmoPcED6qh7x3HrNd8+PFjMxW 6INQFMG1ApmOxHmvpcpOh1gNWwxUaNXdzqbanrbS0M7aZQaK/4PVjar3tytHi2wDebCoKJJHk DKMzaTrkrNtgfngwrigxYVHx/gvXHI0J1CrNMLG13UgZHO4Fr2WV2B+nCyqsWGOU/E5KK7n3J L+raBwSsMEzId6Hvhl77Ccwd8iY/SRgI0sLD2L6JvkCnTM12k4ci58X+03h9dwHwED5ovkPwQ RPrGczSYuqXvhgSMMB6bHBSg43HRUrrfmlPH8ts2aVegfFlEg2FfHIVs3XoPJNYFitttrPj3l KS5ochTZS83G1KBkv8QGLzvhsve45cjA1nQsByLcgjIyjgtn81mUWaz6uSt8hwLSgtsQ4pVd5 25L9ae8Dt1dduM09eFFVfNlKMqvKdgjQqdlz+BBSks1bsXxGD3IJw3qYhVQ62raBjNQ18oue5 C35VLVlM/BMa18ZOUBvxE5DUK4kspPRBqgxxvhKtNGkJ/IsjtMQFRc0kjj8nzOH2TLh664A5q FsXoFVXh5AAP7KXSVd6cBVuvHIaRMjneWTFX1h084J4+yG9BGEobYynqwuPomemjsrGpIDIxJ e2iF8FZqrIlREUtM3/wOXaAVMdlnW8ndf9yOlJY+8N8ysIbYWtZcea6sHkPaCVSYI+oAqqbr6 RRSkWoOkXiUHaMR9iejnOvKBzlmN/x1hRh9a1eLae8ilJJc4IuT3NDaPN0tjivcNMilVVZ/A0 /E4NhTcu/VKSYoyqHuQZNsmln9cW5p0HDp+30MvxEyqw21p40+9dwekEU5310LuEQyafA3jAc vjdYYEKry7kBjc5NTEZzPckXOSSAk4gHBEujfdYGxR1Z0wXcteiHp8d4m4TxWzvyjXBTmep5k nDdgHbvoszkLULtw6qEmmSl4lPifQ+T2ol0O6hRa8ysaX8WDe1qkHQmvHo4pxQwlF5bPG9JA6 P+U/Yc0dOsL7jeIqH19Kwhy5Vx0tYu3VBHcH3fylSh7wgPeWt6KIhu6rVcEpyMgauI6gq0+GV gZKTlBmIi9KbM5CFTlq0DK0v3+Di/kTABeTzV5zRlEoJAvEbU29InAlS4ZvBSZ30D7Fu69+8V 4uMWR6b01uX1y0DWy62LTgTxCoTOHpBHdYFboGZFCki7SAo/VaB/04+vq4RGEN9BSu0e50y0I pv9JXj8KEDILHu6PzJRfi3t0T3e+M/hC7qIJh4PWbR0fAcaQq+ljzMXUz7dP3ABlZiZCckcK1 5X62TNzR3EDsi89GTsQUm4/ll25CjXU9L2+T3lMdYN8Xq5SHsYSdtRWXWmFyEvxegbTT4ohTc 9M6i49NZZTlrBW3MTEveQqar++DtxtH1lQQCGwwgei4/M/DJ5LhjLu4KXshy13BRUNMbtvFtl ml/e7moj1046Zmpxa1RcWvkvdaqDQwbLJEqGhw0bf1flO4bsp6o7xLuMdF4TdSLpPv18T1grK XUTq0MAhv5jLINuYTIH+y6j1Rc9K2DQXwPjAib0RUZAutZjOW9SLogTUeuziSLJFmzCoK1Ax9 g/eaiuguh5qWpIsrf8Osm2tOAsNfgJr+CdRrNogDu8oswAFtuDkgip5utZTGrF4gbM0J1M2gG 7Eu4ZMBUf93tWBQmUyYVUxAWFA39zxXlvz+omP2PFg5Fn1JtalTPvogFzc+RaU2e8hUrLsCwb oUxD04/McBkHRadB9Nx1YedH5bpTzfmqjeOtfkuWWToDPvsgemNHavi2lqSyUf9wrFwuaCZYk Yi2wQkanLdai4X80s5y/0rjMAC+zdjpXEY1YnA7NVmDtEMawUKt556dFna7bKJXI3VxY0cj4k xoPJiXFzvqxRpHll7aV50oYajxO6lkR+nEwseG1a4lWw5lF/I5saQcRUeav/IxPUhqftVvECd ZhqyoZMY+RdZkBE+G9991gUHEaL667xgFv0K/PC5/kbrVohyHQvLPNHz/NLzJiSAJZtjwXdBV wGPEOPRXS3qeXKmES1X4TDlhk9Eud12O3ZLdw27vzY5QUvOI3c7IzcTVnmMmnP9Zt9lu320Cc wK4YNNUqRY9EmCofc2wCJw2htCEkPdlCr9NuyZWz/n0QbnKuUhi1SeK7pfTKloixUSrT0ThcG 6z0ww18fESTkRDGGy2wSjFFHIoITedl3YFep9p2w14RYJLGKXBYN2fcYACM04Xv8c94k+cHgT KplVQPkDTN4zF9oaMnSKEFEI+3TVyclO10vWM6zuTsG6irSzf1MBuamxR9q7vPjLQjcffPjZH R2cld1lt7wsZNZ6ilIwEsNWc50k2JPgCN53V40GALo9g5KnK1EEbTi1DHwIsGLhvtXBcpHP5w t2bzb9JyocBVLyrh538BLe6+hOSPSwRaJ7qZf9PauAXGuL7gpQrrokmy7Op0MjySheVV3mHyo fAxrr6lJ4Fb5qCvk6cZfc5oKzieQU8hGpeOU7qAtZoRjOZF6L+1mRCoMIlr3LGzjiQuxoLgIc vBYbLENgvQVA+D4oERQsP0mJk+Eo/GLtOUbroE/VJSdG6d7BIS0NdVvmibHqy14PHn8BLOnEu IiUJTs3QMm5FMZuJlBy5 Content-Type: text/plain; charset="utf-8" The Windows WMI-ACPI driver likely uses wmilib [1] to interact with the WMI service in userspace. Said library uses plain byte buffers for exchanging data, so the WMI-ACPI driver has to convert between those byte buffers and ACPI objects returned by the ACPI firmware. The format of the byte buffer is publicly documented [2], and after some reverse eingineering of the WMI-ACPI driver using a set of custom ACPI tables, the following conversion rules have been discovered: - ACPI integers are always converted into a uint32 - ACPI strings are converted into special WMI strings - ACPI buffers are copied as-is - ACPI packages are unpacked Extend the ACPI-WMI driver to also perform this kind of marshalling for WMI data blocks, methods and events. Doing so gives us a number of benefits: - WMI drivers are not restricted to a fixed set of supported ACPI data types anymore, see dell-wmi-aio (integer vs buffer) and hp-wmi-sensors (string vs buffer) - correct marshalling of WMI strings when data blocks are marked as requiring ACPI strings instead of ACPI buffers - development of WMI drivers without having to understand ACPI This eventually should result in better compatibility with some ACPI firmware implementations and in simpler WMI drivers. There are however some differences between the original Windows driver and the ACPI-WMI driver when it comes to ACPI object conversions: - the Windows driver copies internal _ACPI_METHOD_ARGUMENT_V1 data structures into the output buffer when encountering nested ACPI packages. This is very likely an error inside the driver itself, so we do not support nested ACPI packages. - when converting WMI strings (UTF-16LE) into ACPI strings (ASCII), the Windows driver replaces non-ascii characters (=C3=A4 -> a, & -> ?) instead of returning an error. This behavior is not documented anywhere and might lead to severe errors in some cases (like setting BIOS passwords over WMI), so we simply return an error. As the current bus-based WMI API is based on ACPI buffers, a new API is necessary. The legacy GUID-based WMI API is not extended to support marshalling, as WMI drivers using said API are expected to move to the bus-based WMI API in the future. [1] https://learn.microsoft.com/de-de/windows-hardware/drivers/ddi/wmilib/ [2] https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/ driver-defined-wmi-data-items Signed-off-by: Armin Wolf --- drivers/platform/wmi/Makefile | 2 +- drivers/platform/wmi/core.c | 160 ++++++++++++++++++- drivers/platform/wmi/internal.h | 17 ++ drivers/platform/wmi/marshalling.c | 241 +++++++++++++++++++++++++++++ include/linux/wmi.h | 40 ++++- 5 files changed, 453 insertions(+), 7 deletions(-) create mode 100644 drivers/platform/wmi/internal.h create mode 100644 drivers/platform/wmi/marshalling.c diff --git a/drivers/platform/wmi/Makefile b/drivers/platform/wmi/Makefile index 98393d7391ec..6f2bf8cc709e 100644 --- a/drivers/platform/wmi/Makefile +++ b/drivers/platform/wmi/Makefile @@ -4,5 +4,5 @@ # ACPI WMI core # =20 -wmi-y :=3D core.o +wmi-y :=3D core.o marshalling.o obj-$(CONFIG_ACPI_WMI) +=3D wmi.o diff --git a/drivers/platform/wmi/core.c b/drivers/platform/wmi/core.c index 6878c4fcb0b5..1601bf9fe135 100644 --- a/drivers/platform/wmi/core.c +++ b/drivers/platform/wmi/core.c @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -33,6 +34,8 @@ #include #include =20 +#include "internal.h" + MODULE_AUTHOR("Carlos Corbacho"); MODULE_DESCRIPTION("ACPI-WMI Mapping Driver"); MODULE_LICENSE("GPL"); @@ -302,7 +305,7 @@ acpi_status wmi_evaluate_method(const char *guid_string= , u8 instance, u32 method EXPORT_SYMBOL_GPL(wmi_evaluate_method); =20 /** - * wmidev_evaluate_method - Evaluate a WMI method + * wmidev_evaluate_method - Evaluate a WMI method (deprecated) * @wdev: A wmi bus device from a driver * @instance: Instance index * @method_id: Method ID to call @@ -360,6 +363,70 @@ acpi_status wmidev_evaluate_method(struct wmi_device *= wdev, u8 instance, u32 met } EXPORT_SYMBOL_GPL(wmidev_evaluate_method); =20 +/** + * wmidev_invoke_method - Invoke a WMI method + * @wdev: A wmi bus device from a driver + * @instance: Instance index + * @method_id: Method ID to call + * @in: Mandatory WMI buffer containing input for the method call + * @out: Optional WMI buffer to return the method results + * + * Invoke a WMI method, the caller must free the resulting data inside @ou= t. + * Said data is guaranteed to be aligned on a 8-byte boundary. + * + * Return: 0 on success or negative error code on failure. + */ +int wmidev_invoke_method(struct wmi_device *wdev, u8 instance, u32 method_= id, + const struct wmi_buffer *in, struct wmi_buffer *out) +{ + struct wmi_block *wblock =3D container_of(wdev, struct wmi_block, dev); + struct acpi_buffer aout =3D { ACPI_ALLOCATE_BUFFER, NULL }; + struct acpi_buffer ain; + union acpi_object *obj; + acpi_status status; + int ret; + + if (wblock->gblock.flags & ACPI_WMI_STRING) { + ret =3D wmi_marshal_string(in, &ain); + if (ret < 0) + return ret; + } else { + if (in->length > U32_MAX) + return -E2BIG; + + ain.length =3D in->length; + ain.pointer =3D in->data; + } + + if (out) + status =3D wmidev_evaluate_method(wdev, instance, method_id, &ain, &aout= ); + else + status =3D wmidev_evaluate_method(wdev, instance, method_id, &ain, NULL); + + if (wblock->gblock.flags & ACPI_WMI_STRING) + kfree(ain.pointer); + + if (ACPI_FAILURE(status)) + return -EIO; + + if (!out) + return 0; + + obj =3D aout.pointer; + if (!obj) { + out->length =3D 0; + out->data =3D ZERO_SIZE_PTR; + + return 0; + } + + ret =3D wmi_unmarshal_acpi_object(obj, out); + kfree(obj); + + return ret; +} +EXPORT_SYMBOL_GPL(wmidev_invoke_method); + static acpi_status __query_block(struct wmi_block *wblock, u8 instance, struct acpi_buffer *out) { @@ -432,7 +499,7 @@ acpi_status wmi_query_block(const char *guid_string, u8= instance, EXPORT_SYMBOL_GPL(wmi_query_block); =20 /** - * wmidev_block_query - Return contents of a WMI block + * wmidev_block_query - Return contents of a WMI block (deprectated) * @wdev: A wmi bus device from a driver * @instance: Instance index * @@ -452,6 +519,33 @@ union acpi_object *wmidev_block_query(struct wmi_devic= e *wdev, u8 instance) } EXPORT_SYMBOL_GPL(wmidev_block_query); =20 +/** + * wmidev_query_block - Return contents of a WMI data block + * @wdev: A wmi bus device from a driver + * @instance: Instance index + * @out: WMI buffer to fill + * + * Query a WMI data block, the caller must free the resulting data inside = @out. + * Said data is guaranteed to be aligned on a 8-byte boundary. + * + * Return: 0 on success or a negative error code on failure. + */ +int wmidev_query_block(struct wmi_device *wdev, u8 instance, struct wmi_bu= ffer *out) +{ + union acpi_object *obj; + int ret; + + obj =3D wmidev_block_query(wdev, instance); + if (!obj) + return -EIO; + + ret =3D wmi_unmarshal_acpi_object(obj, out); + kfree(obj); + + return ret; +} +EXPORT_SYMBOL_GPL(wmidev_query_block); + /** * wmi_set_block - Write to a WMI block (deprecated) * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f= 2f49ba @@ -486,7 +580,7 @@ acpi_status wmi_set_block(const char *guid_string, u8 i= nstance, const struct acp EXPORT_SYMBOL_GPL(wmi_set_block); =20 /** - * wmidev_block_set - Write to a WMI block + * wmidev_block_set - Write to a WMI block (deprecated) * @wdev: A wmi bus device from a driver * @instance: Instance index * @in: Buffer containing new values for the data block @@ -535,6 +629,46 @@ acpi_status wmidev_block_set(struct wmi_device *wdev, = u8 instance, const struct } EXPORT_SYMBOL_GPL(wmidev_block_set); =20 +/** + * wmidev_set_block - Write to a WMI data block + * @wdev: A wmi bus device from a driver + * @instance: Instance index + * @in: WMI buffer containing new values for the data block + * + * Write the content of @in into a WMI data block. + * + * Return: 0 on success or negative error code on failure. + */ +int wmidev_set_block(struct wmi_device *wdev, u8 instance, const struct wm= i_buffer *in) +{ + struct wmi_block *wblock =3D container_of(wdev, struct wmi_block, dev); + struct acpi_buffer buffer; + acpi_status status; + int ret; + + if (wblock->gblock.flags & ACPI_WMI_STRING) { + ret =3D wmi_marshal_string(in, &buffer); + if (ret < 0) + return ret; + } else { + if (in->length > U32_MAX) + return -E2BIG; + + buffer.length =3D in->length; + buffer.pointer =3D in->data; + } + + status =3D wmidev_block_set(wdev, instance, &buffer); + if (wblock->gblock.flags & ACPI_WMI_STRING) + kfree(buffer.pointer); + + if (ACPI_FAILURE(status)) + return -EIO; + + return 0; +} +EXPORT_SYMBOL_GPL(wmidev_set_block); + /** * wmi_install_notify_handler - Register handler for WMI events (deprecate= d) * @guid: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba @@ -862,7 +996,7 @@ static int wmi_dev_probe(struct device *dev) return -ENODEV; } =20 - if (wdriver->notify) { + if (wdriver->notify || wdriver->notify_new) { if (test_bit(WMI_NO_EVENT_DATA, &wblock->flags) && !wdriver->no_notify_d= ata) return -ENODEV; } @@ -1221,6 +1355,8 @@ static int wmi_get_notify_data(struct wmi_block *wblo= ck, union acpi_object **obj static void wmi_notify_driver(struct wmi_block *wblock, union acpi_object = *obj) { struct wmi_driver *driver =3D to_wmi_driver(wblock->dev.dev.driver); + struct wmi_buffer buffer; + int ret; =20 if (!obj && !driver->no_notify_data) { dev_warn(&wblock->dev.dev, "Event contains no event data\n"); @@ -1229,6 +1365,22 @@ static void wmi_notify_driver(struct wmi_block *wblo= ck, union acpi_object *obj) =20 if (driver->notify) driver->notify(&wblock->dev, obj); + + if (driver->notify_new) { + if (!obj) { + driver->notify_new(&wblock->dev, NULL); + return; + } + + ret =3D wmi_unmarshal_acpi_object(obj, &buffer); + if (ret < 0) { + dev_warn(&wblock->dev.dev, "Failed to unmarshal event data: %d\n", ret); + return; + } + + driver->notify_new(&wblock->dev, &buffer); + kfree(buffer.data); + } } =20 static int wmi_notify_device(struct device *dev, void *data) diff --git a/drivers/platform/wmi/internal.h b/drivers/platform/wmi/interna= l.h new file mode 100644 index 000000000000..9a39ffa31ad1 --- /dev/null +++ b/drivers/platform/wmi/internal.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Internal interfaces used by the WMI core. + * + * Copyright (C) 2025 Armin Wolf + */ + +#ifndef _WMI_INTERNAL_H_ +#define _WMI_INTERNAL_H_ + +union acpi_object; +struct wmi_buffer; + +int wmi_unmarshal_acpi_object(const union acpi_object *obj, struct wmi_buf= fer *buffer); +int wmi_marshal_string(const struct wmi_buffer *buffer, struct acpi_buffer= *out); + +#endif /* _WMI_INTERNAL_H_ */ diff --git a/drivers/platform/wmi/marshalling.c b/drivers/platform/wmi/mars= halling.c new file mode 100644 index 000000000000..ef9fb4ffb15f --- /dev/null +++ b/drivers/platform/wmi/marshalling.c @@ -0,0 +1,241 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * ACPI-WMI buffer marshalling. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "internal.h" + +/* + * The WMI buffer data needs to be aligned on a 8 byte boundary to properly + * support 64-bit WMI integers. + */ +static_assert(ARCH_KMALLOC_MINALIGN >=3D 8); + +static int wmi_adjust_buffer_length(size_t *length, const union acpi_objec= t *obj) +{ + size_t alignment, size; + + switch (obj->type) { + case ACPI_TYPE_INTEGER: + /* + * Integers are threated as 32 bit even if the ACPI DSDT + * declares 64 bit integer width. + */ + alignment =3D 4; + size =3D sizeof(u32); + break; + case ACPI_TYPE_STRING: + /* + * Strings begin with a single little-endian 16-bit field containing + * the string length in bytes and are encoded as UTF-16LE with a termina= ting + * nul character. + */ + if (obj->string.length + 1 > U16_MAX / 2) + return -EOVERFLOW; + + alignment =3D 2; + size =3D struct_size_t(struct wmi_string, chars, obj->string.length + 1); + break; + case ACPI_TYPE_BUFFER: + /* + * Buffers are copied as-is. + */ + alignment =3D 1; + size =3D obj->buffer.length; + break; + default: + return -EPROTO; + } + + *length =3D size_add(ALIGN(*length, alignment), size); + + return 0; +} + +static int wmi_obj_get_buffer_length(const union acpi_object *obj, size_t = *length) +{ + size_t total =3D 0; + int ret; + + if (obj->type =3D=3D ACPI_TYPE_PACKAGE) { + for (int i =3D 0; i < obj->package.count; i++) { + ret =3D wmi_adjust_buffer_length(&total, &obj->package.elements[i]); + if (ret < 0) + return ret; + } + } else { + ret =3D wmi_adjust_buffer_length(&total, obj); + if (ret < 0) + return ret; + } + + *length =3D total; + + return 0; +} + +static int wmi_obj_transform_simple(const union acpi_object *obj, u8 *buff= er, size_t *consumed) +{ + struct wmi_string *string; + size_t length; + __le32 value; + u8 *aligned; + + switch (obj->type) { + case ACPI_TYPE_INTEGER: + aligned =3D PTR_ALIGN(buffer, 4); + length =3D sizeof(value); + + value =3D cpu_to_le32(obj->integer.value); + memcpy(aligned, &value, length); + break; + case ACPI_TYPE_STRING: + aligned =3D PTR_ALIGN(buffer, 2); + string =3D (struct wmi_string *)aligned; + length =3D struct_size(string, chars, obj->string.length + 1); + + /* We do not have to worry about unaligned accesses here as the WMI + * string will already be aligned on a two-byte boundary. + */ + string->length =3D cpu_to_le16((obj->string.length + 1) * 2); + for (int i =3D 0; i < obj->string.length; i++) + string->chars[i] =3D cpu_to_le16(obj->string.pointer[i]); + + /* + * The Windows WMI-ACPI driver always emits a terminating nul character, + * so we emulate this behavior here as well. + */ + string->chars[obj->string.length] =3D '\0'; + break; + case ACPI_TYPE_BUFFER: + aligned =3D buffer; + length =3D obj->buffer.length; + + memcpy(aligned, obj->buffer.pointer, length); + break; + default: + return -EPROTO; + } + + *consumed =3D (aligned - buffer) + length; + + return 0; +} + +static int wmi_obj_transform(const union acpi_object *obj, u8 *buffer) +{ + size_t consumed; + int ret; + + if (obj->type =3D=3D ACPI_TYPE_PACKAGE) { + for (int i =3D 0; i < obj->package.count; i++) { + ret =3D wmi_obj_transform_simple(&obj->package.elements[i], buffer, + &consumed); + if (ret < 0) + return ret; + + buffer +=3D consumed; + } + } else { + ret =3D wmi_obj_transform_simple(obj, buffer, &consumed); + if (ret < 0) + return ret; + } + + return 0; +} + +int wmi_unmarshal_acpi_object(const union acpi_object *obj, struct wmi_buf= fer *buffer) +{ + ssize_t length; + u8 *data; + int ret; + + ret =3D wmi_obj_get_buffer_length(obj, &length); + if (ret < 0) + return ret; + + data =3D kzalloc(length, GFP_KERNEL); + if (!data) + return -ENOMEM; + + ret =3D wmi_obj_transform(obj, data); + if (ret < 0) { + kfree(data); + return ret; + } + + buffer->length =3D length; + buffer->data =3D data; + + return 0; +} +EXPORT_SYMBOL_IF_KUNIT(wmi_unmarshal_acpi_object); + +int wmi_marshal_string(const struct wmi_buffer *buffer, struct acpi_buffer= *out) +{ + const struct wmi_string *string; + u16 length, value; + size_t chars; + char *str; + + if (buffer->length < sizeof(*string)) + return -ENODATA; + + string =3D buffer->data; + length =3D get_unaligned_le16(&string->length); + if (buffer->length < sizeof(*string) + length) + return -ENODATA; + + /* Each character needs to be 16 bits long */ + if (length % 2) + return -EINVAL; + + chars =3D length / 2; + str =3D kmalloc(chars + 1, GFP_KERNEL); + if (!str) + return -ENOMEM; + + for (int i =3D 0; i < chars; i++) { + value =3D get_unaligned_le16(&string->chars[i]); + + /* ACPI only accepts ASCII strings */ + if (value > 0x7F) { + kfree(str); + return -EINVAL; + } + + str[i] =3D value & 0xFF; + + /* + * ACPI strings should only contain a single nul character at the end. + * Because of this we must not copy any padding from the WMI string. + */ + if (!value) { + /* ACPICA wants the length of the string without the nul character */ + out->length =3D i; + out->pointer =3D str; + return 0; + } + } + + str[chars] =3D '\0'; + + out->length =3D chars; + out->pointer =3D str; + + return 0; +} +EXPORT_SYMBOL_IF_KUNIT(wmi_marshal_string); diff --git a/include/linux/wmi.h b/include/linux/wmi.h index 665ea7dc8a92..81f24d238a2c 100644 --- a/include/linux/wmi.h +++ b/include/linux/wmi.h @@ -8,9 +8,11 @@ #ifndef _LINUX_WMI_H #define _LINUX_WMI_H =20 +#include #include #include #include +#include =20 /** * struct wmi_device - WMI device structure @@ -36,6 +38,37 @@ struct wmi_device { */ #define to_wmi_device(device) container_of_const(device, struct wmi_device= , dev) =20 +/** + * struct wmi_buffer - WMI data buffer + * @length: Buffer length in bytes + * @data: Pointer to the buffer content + * + * This structure is used to exchange data with the WMI driver core. + */ +struct wmi_buffer { + size_t length; + void *data; +}; + +/** + * struct wmi_string - WMI string representation + * @length: Size of @chars in bytes + * @chars: UTF16-LE characters with optional nul termination and padding + * + * This structure is used when exchanging string data over the WMI interfa= ce. + */ +struct wmi_string { + __le16 length; + __le16 chars[]; +} __packed; + +int wmidev_invoke_method(struct wmi_device *wdev, u8 instance, u32 method_= id, + const struct wmi_buffer *in, struct wmi_buffer *out); + +int wmidev_query_block(struct wmi_device *wdev, u8 instance, struct wmi_bu= ffer *out); + +int wmidev_set_block(struct wmi_device *wdev, u8 instance, const struct wm= i_buffer *in); + acpi_status wmidev_evaluate_method(struct wmi_device *wdev, u8 instance, u= 32 method_id, const struct acpi_buffer *in, struct acpi_buffer *out); =20 @@ -54,9 +87,11 @@ u8 wmidev_instance_count(struct wmi_device *wdev); * @probe: Callback for device binding * @remove: Callback for device unbinding * @shutdown: Callback for device shutdown - * @notify: Callback for receiving WMI events + * @notify: Callback for receiving WMI events (deprecated) + * @notify_new: Callback for receiving WMI events * - * This represents WMI drivers which handle WMI devices. + * This represents WMI drivers which handle WMI devices. The data inside t= he buffer + * passed to the @notify_new callback is guaranteed to be aligned on a 8-b= yte boundary. */ struct wmi_driver { struct device_driver driver; @@ -68,6 +103,7 @@ struct wmi_driver { void (*remove)(struct wmi_device *wdev); void (*shutdown)(struct wmi_device *wdev); void (*notify)(struct wmi_device *device, union acpi_object *data); + void (*notify_new)(struct wmi_device *device, const struct wmi_buffer *da= ta); }; =20 /** --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EC7A81A3029; Fri, 9 Jan 2026 21:46:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995204; cv=none; b=RIXVbl4BLfNK4Qu7wv9aw2Uumdgft1WOzIxiSvMJgzP+jfr1Hx9rVJ2iWc/e6GGMzjCEAFVi0qbvNWrgfcGIEQkzPgEIykcbXJ8jY0Cr0CzC94qF6DIxFJ9hPk6w5L2s8DH41YxPvwdEr9ILkv1vepUNCOweBHWd86kbIZiRMMo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995204; c=relaxed/simple; bh=ILx11DLH3slyAHbtvjBd+zKe/Z16z3WeGpR8oC4qU4g=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=jMYJnjLp9G+JVa/Zj+8EehJsHue24bZv9YYf8gMzPbH7LUFkAaUD9z13n2SsBQ9qA4TK+Rs+JnB+qc2qEfLqMYnWmAjGkq+fFYFrF5Slo+Xnzgj1zZO9STjC2au54cB2X8UvMEvH6DvvG9EWuUJvIymw8FvFs585T4DqUi2m+0U= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=QAn+AldT; arc=none smtp.client-ip=212.227.15.18 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="QAn+AldT" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995200; x=1768600000; i=w_armin@gmx.de; bh=7XKG6H6VwUerChqrJhGlkgKXRhw5nOU9QVW/ZR/2gTY=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=QAn+AldTkijNDo2s30tgJL+EhaevAHcB63f3zTLCDBPjS+sw+32FnzDgOZ2Z6xAO lAGHDNeIA8v7+4EleUqyfDQIafx8FKLwEwQK+8mfwAm5OfhYsFqKRkevHV2VJOSBX 2B15y8D63I+K4i3UyWLP9USjWNrQbAwxO6mx5VMwyOvTytCoUPUtTb4hmNqkCq3a6 1fosZJVwGycxtHE0pgxgqz3f97zHexbTLxIWrf9ouNHybuszRFhrpuGzY/MN0NKQJ 9wElTnLq5s9YW7AQV7j1YfT+DPIlOCqdt1AXsiA1emroJD5Ug+OXUWlEuwuqikz4O vaGjk+nZbpoYFVLWcA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MPog5-1vRJV646Dr-00KUQV; Fri, 09 Jan 2026 22:46:40 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 2/9] platform/wmi: Add kunit test for the marshalling code Date: Fri, 9 Jan 2026 22:46:12 +0100 Message-Id: <20260109214619.7289-3-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:N0+BRUG7XStbNViKCqsMMP1F0UVA8Jr+qCzOttHSWt3nFso9qEl NY7TNSAsQhwOqes9FZLc62xJhasTRtyYY+ESXMHGXuLBTm6HD7JaO1yshpgyXpop4E1FPuZ 2tFrLquzXIXpcGKI/cIe1A2CcZwBAXVfIRnUgU3yQzppq9aEQwRNfRUZg+rA5iHsLt+JU3a Ep0T4nqHDdJr0lE6NVPcw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:HWS0/Ml0vr0=;rGxT1Now+4aYzptaMim8yuEhk2V Vya70jg4JfnchkfTQlq+voU6B4ajOWcuu9vcNJTXo3X+OoXXSUYOFfs/+FmUvKk7GIQYSREis J3efDtRVrD9ymkprpASG2WUASAc5KMd/e+XhHSzuT5MuZeEsMSDf6OcQxjMLx6dMccZj5a38T VI3GNWVIXYDzVClqtGFfsSbUemuPi6aeJeMJUAkk/+lINs0x98b9nAgOlA3hGKUEnWp0+u2JC 521AQEaLBq/wWNwcr498MiB0p7yHmZ4vmafvuKNwDJRJ5TQRmxWgRE0H2TPOgcnqqNaY2pUfR txVWgcXDNDdorAO4gBw5m2/2UrHqvOTZWQMJlfiVjX+FipOEbMqVS3fd/t/7NLrTDfSvQd5W0 bPVtQQDU78FXybWczZddJcs8HzTDn59FhFkRIYGdddZrF56pcK5jFtLMpd0OS7mmT8/88g2rs Fd97LJuK8p7xR8ZbV3SNOIl7o7ux4GEyZqbHyCNECYZl+fn+Je0YmQ8IkKmlVKugmGdSS9cCj l+MedlW2Ol0VYBxSVvRyxrOqtJYMqwwEc+1ukkr5DmxV9zWgL7uFMXsl82NeD5HT0c2vDq8hu X92iM5skgKUFFUsXMIw2XenvpDlNv+IEWKPb+MPa6uyC5XfQzSLt8G1FvmWOkhv7uY9soUm8e +Ee+eh92ri2P70G8nmepQjZsCrqx32Fie0TGO/QcQgO+7ESWxD2WOLpwl4HTzRaa3E38hLjAr reaewJC8yrxtAH1oHUAMFQszd55sDS+PuT0cfJpfvqNdAwtwOv1VUiqU0F5+Uq2+JD1wa3Cye cy5GTfQD+ovW+6Uwl5OhjdkB+ev1F5HSrfGSNQNgRYU71OnfUJvYwK1lBp3Suw02qTB/H2C5z Ap27NhYM39B3mneDBNnNqCoJgTtOyW3gWDu4GWcIcSs3l2fJ+f61edXcWGDgbFQaCT44+wfZI JfhUYMt0+D4uaYEtn3JUACwk82UZpjlgj6opVDjrthJFVlkHXCvj4q928vbjFi9f8tFlucaIr VpDiaV7lJkHOtGQ1Fj9M9r2qIdk7iXAFJb8qZ0ECcukRtGBBr8/qDoTGAaiRTckF6ywxdosXp SE5oVfbgxDunheWk+v57gQLpSTwEdT6j/MpYyTdYqnicmgNdM/+2z1eV+l+Vw/NbP6W55oi11 +tPzEDckEy5/BhUuuSUT7wZ41K6EdYFx+77dnnSzFmaowlTfBGdKgn5OFUgOH5oNNnxRd1UVS WI/O1I5arfdZfjtvrTLDXP3d+NUvECcAQXPjCFHhoveMgtyMte9A83iYRypAicPgucH+0BT6l 7dgrhDLNkspFYhOVFm8ZNNF0fBiXPP9xzdMmpp86fKzDpAW+InebP0PZ/k8EAh9T48MHtB0AB C3b25SnMUwcxMsVRD1zBwMBUNm1F4954tZoamV7aDy3OfJ6yL+SvXNcBRr0WV2y7++qdfS8iO eD1yrR2c2o6kxV7tCSmks6JTJzmRuWEg3wMpFezNdFsR68Y5+wM6LA6bZE2/meYja6XjyEwGa NCNIDLoOgyNO/MYQgBhA5e3XR+Pk3KB507o+uUJs30IhpVNP45XvyoKqCQSyj4wHOr/dLe35a mTY3yHMm3SWaDq/7q7NyQhzO6epiIqzTszRmLPdYQCNrKSbkUN8y2exk5fCBIyOHDlvxb5HwJ qsMLuiBwyvp4E6t22qr7j+WGVvCXrN3Q99afmrRZ3kfx7FYvFP+DG0g12mDPum1QP44rIDXN2 Vm90rUyyIeIU8j1OWxJD8ChZwTLdhLf5K3Xaz/41chLWyYFhsfDezFem3scHdU48PFVeRJujb p6fIiNW7AEOuywuuzn65gYDEEgc36SYpHXzggd4nCAvQenh++thqkzpayTN497OH+zTSpJe4q ZBjmctD4NYg3W9IWdpcEvwqlZko9h3pDwmWCQwCyAWrqTE2df6uyj/sTZjSYqhkqR33czpWGY P2ucgKXKjUDGHBkgwhpRyx7IT/JcnoNUQVXi1isbpcOTplvM6SKrn9Sf9qvAhOXdK4xNN/ZF3 kG8VkQg7jfAf69xHGY889yrnLvGs8oTmBKkjqxVgJV6VkmJ835zg1gHNvOl4EdvfJ1+4T2JGR X6eb8728cGhxPrgAeEQpjX0FtUZrG4tVgpaqJuCPpogpSYd7jwAbkfUn6ijtulJuuWkHwlTD9 SZEPPIce8YPqimRxwh/rNUmyprISgdVHV5muONYIfM8hheqruFShaxJ9R96ljYnvCe2Xw6pHo 6fhTz499kv/DkSHpqDkVvZ6zq0IEPiB0BWeYP/NCOCi/y8ZDS6cXBLXcQmGQz6wyT6uSrKqRd O9LTVz0mQ0RJbFEwh/y0TpkOu7Wb3o3U1XqM35MrnG4GaiwdmF61QpYZGQx+LjpbYOiLbyhmW nYvMb5/wxpsuY0O9jucfBnpUXMl2h6GYxvwR/bkENhuSxgsiVXRcoieesC0EnVDfcpN4+3at0 d8YMtGMuvYZasFYHUSs+ZGFV85l8SQw9aaw/+6BKWfUbtY0pfaSD2lVDE+TiTOQReNwvQ02Ij g+Ebb++UomowE4ZUdB7VEmLkNci2MhnbWDgUDpCvjUuT3VLgNSIHjV5IHIAK+ddzD4nNXtLNS BPW/dpbJtDvsVfN+8EnmTVMPK8OBpdn8Op6IVMBxK4RvrdVCvprCHQzN+/qwgscogSXIeGyiN LPvB9VzMi8LFJ3c0s+a+pqOZY/rQOlBsFz/0+FPeoLr77AiCFD8CVhhcaSJuh61SQf4gj0Gnr j0yiJ5aKCdAMbrWbQ7EHhTKYfLbIGVENz3NHZ8M23IOOM02E9E5o+Uu04ezEStbvjtpxANW4r cAUx7aOFvjlNgWvhoi2Ga+DTfl9lTG9AuQd7ECrSTavtwSck3XZcDw4nNwHAAPKPN6dHLBd0P 6zcudryHBP8D3UGXO8SX66va7+oMtFvlp1IzgwUPeC/OfjlkYnvJKh9FYKntkqd1Y8qnOwycu C4kXzXzL2uU4Y7WonfQ5TqxUo7XPx7Rij3YVQWN7By+E9yNzSJlSyV1LRcCtrn+hYfZkZATIL LoJ+xFbBwvhR/4A8css7BcYYf3jYWKP9QWpytXKIYUVj1DONoqKIF5CKH2kz3VGNo739/Rqk6 YY9VLSZbxwOp4jYIdE0ZTf97FgHFnfssfDJRNPMCNOeGByZabfUvA6wFDwa7zy5TN4YIQORE7 2o7cZZqO9QUO9qUl9K48I/w5RwiBxOYj7WanxqlVRwwhQ1RcvyScpDVjxcBxOFOutMpBlP4/H 8ZCiVwx2Z6CO2GeUXkeDtUPBrvFvVddhXMjgiLi+sYfSWlQQdwUxiKwQzCwYlPstOuvzHRNtg GkQR8nb8fJEfE1k22+hjSSYrVOYyaBS1s1z4mtjQKNPA0aGuxNHTPsCyWRNysQ2zMSl4F1bTu mkFfNiBXf/dY5HPa5zYucQ2dk1X28xXHkzJ/ut9QZM7r8B+riDLywwNMxfIpqYfitw5cCEaUo rF6KYLFRiiSxQn9Yh2yCRwyNRV4/SSv2Nf2v30FhNCmkhO/mmFony5lC/RgS0z32bTilWR8kh C0nfiDX6x6J0XvFRYqBPs1r7/0Gl5uE5LVWFUDHzNuQLR8vskDmihOI1Mdgv4HLWfhzrsp/2b n5BCksnYIDdnKocJDluWjjQ4wmF1+YYQ7rnnQ+VuyxJN44ZzlcQ2RgOP8RQe3ZyIgDsW8W2fT IB8yOT7b88DnMcqudUMd8DDZZ3oNpBzZG+UhUEq6qVdVWJmbO/glOOBd92j2Fe0ypeqiGVMJy /DzEa9gNQsaVPoUlE83+9Z/0vDHr+HP0KJA/WAz+cPMKXc10cEo4PRgSDaZoelXHL1COGnBmu oUSiYqWTm5iWoVEB3UFrqiImvaWaDp0vUj8drwjTsLBXe9KKz4+eJFykNULi4QVXsMCmuE92N 8bgB0F8NfnEznt0joPcmKY0morBBZj6VWZEmDrN2MFFQHXdQJCZ9XFFj2rZesfaHiiZQVoO/k Oq8ZxLMxnRRVw17tS6x/sZaW+3c1TCOw/0elWA973Tso2oMqeccoguXun30odU9g83FXDIs9Y Jidz58ILes4qyhCdWGdwsSLFOdpvOhg9QPF2pGPpyxDLCOMOzDsGD5QRJEFrxjtQqB2hjjeMB O2xyYeDVJI5QcpORr6LnUm5B0F3NxmOOjAokKHyu3hHddlLNXzvNjFKu8ZIYP+qU65RT3P1uD Xc/9rBh97d19z3jEVDH9fEAccwBdfgHzLOqK6lXYU7+KQ1m8vQgMtuBjsSKNfGGUc0RvXhNfO EGeB7LaMuXmxHKZrg03TXxtiLrogTuuJBqDHVoYL4vPq3pG5c5p6GQlg2AxpX/racJnRSKyf/ 7P51MsQ8Qx6o8/gTJqhKNO2X1EeQYPLloKyBd91Sl0dLy0Q6fXPvxgI8IuDVS3tHxlQyISaM1 ZFt6FxWd9B6V1lLfx6FGCiyl0caPmnc2C334z/5B9bKMmUwukWpiTDuDZ81mzlKLs6Jcm/Xg8 VK1U6ilnGWIWUIgx4ZmVOvSJ3lu7Eeyns2UZATqw7YXnIL8MpQIHGU0SBHfChBYb3ZEE7Mu/+ QCvCdeEJ1QUXrr4XVfJZFwWtFrBh8o1NYsyb5I274KscEY/A6YAS7/jAYZFAB+DdNUOrg9bzH lce9l7PWVHb/f6cBytYgS5kGnCHMhTCMSjPxXz3UEIZIe5ENsl+ys5X0jbDGVBx8ToDLacmLz Cj6m2ikci5+395Yqzpqzppe7Dp5gOhs8r2+NFRsBqTlHAC/yKe7G14i3cUbNvwIaMZslMXqTN cesQ4zO9wK5hzmiaq0hCu3DhvcWHUdNh5K8EswE6G1idlXNRscD+UasQ8uugJL61eInT6UDHk lc1u4Q4fDTXhstrk4njT4KUpoOgGXM0sV8SOIQ3zRW9DDGPr330jQ2nzCjQjng8FM3k+6aLAG OvCdwgvvarUc4bu4di3B2y/hTHgEIDOmjacNbKhwlp45ptAByysGEQBJy+z+3eoCHeMj6vmQj 2L2CFYKuScZboq/7+8y/qJlJO22SpDqaLvDgV/Zpk/+LDDC5+xNETKOZwxX9pwwFodeGJDbJ4 aAnM19ERtQ3+R48mr1DKfRoi4IOXjp313q9enwbI793arLjFAxxsX+wzhHpfTTVbTp08Xv7vn djeqFXCygbOvMFwphiF2YxSO+6o8ujqkeH9DSbZBxviXtLE8l9SeCKVocltq31DXNYch1aB4H Euyz2PrX5zQZR1kJgr+z62BPsSxl3YHVJ+mwVkl4Z4gox2ETgOQ== Content-Type: text/plain; charset="utf-8" The marshalling code used by the WMI driver core is implemented as a separate component, suitable for unit tests. Implmented such a unit test using KUnit. Those unit tests verify that ACPI objects are correctly converted into WMI buffers and that WMI strings are correctly converted into ACPI strings. They also verify that invalid ACPI data (like nested packages) is rejected. Signed-off-by: Armin Wolf --- drivers/platform/wmi/Kconfig | 2 + drivers/platform/wmi/Makefile | 3 + drivers/platform/wmi/tests/Kconfig | 16 + drivers/platform/wmi/tests/Makefile | 8 + .../platform/wmi/tests/marshalling_kunit.c | 449 ++++++++++++++++++ 5 files changed, 478 insertions(+) create mode 100644 drivers/platform/wmi/tests/Kconfig create mode 100644 drivers/platform/wmi/tests/Makefile create mode 100644 drivers/platform/wmi/tests/marshalling_kunit.c diff --git a/drivers/platform/wmi/Kconfig b/drivers/platform/wmi/Kconfig index 77fcbb18746b..21fa3e440042 100644 --- a/drivers/platform/wmi/Kconfig +++ b/drivers/platform/wmi/Kconfig @@ -31,4 +31,6 @@ config ACPI_WMI_LEGACY_DEVICE_NAMES userspace applications but will cause the registration of WMI devices w= ith the same GUID to fail in some corner cases. =20 +source "drivers/platform/wmi/tests/Kconfig" + endif # ACPI_WMI diff --git a/drivers/platform/wmi/Makefile b/drivers/platform/wmi/Makefile index 6f2bf8cc709e..93f37ce519ae 100644 --- a/drivers/platform/wmi/Makefile +++ b/drivers/platform/wmi/Makefile @@ -6,3 +6,6 @@ =20 wmi-y :=3D core.o marshalling.o obj-$(CONFIG_ACPI_WMI) +=3D wmi.o + +# Unit tests +obj-y +=3D tests/ diff --git a/drivers/platform/wmi/tests/Kconfig b/drivers/platform/wmi/test= s/Kconfig new file mode 100644 index 000000000000..efcbcb51c251 --- /dev/null +++ b/drivers/platform/wmi/tests/Kconfig @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# +# ACPI WMI KUnit tests +# + +config ACPI_WMI_MARSHALLING_KUNIT_TEST + tristate "KUnit Test for ACPI-WMI marshalling" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + help + This builds unit tests for the ACPI-WMI marshalling code. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. diff --git a/drivers/platform/wmi/tests/Makefile b/drivers/platform/wmi/tes= ts/Makefile new file mode 100644 index 000000000000..252c3125353a --- /dev/null +++ b/drivers/platform/wmi/tests/Makefile @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Makefile for linux/drivers/platform/x86/wmi/tests +# ACPI WMI KUnit tests +# + +wmi_marshalling_kunit-y :=3D marshalling_kunit.o +obj-$(CONFIG_ACPI_WMI_MARSHALLING_KUNIT_TEST) +=3D wmi_marshalling_kunit.o diff --git a/drivers/platform/wmi/tests/marshalling_kunit.c b/drivers/platf= orm/wmi/tests/marshalling_kunit.c new file mode 100644 index 000000000000..1a32323663cc --- /dev/null +++ b/drivers/platform/wmi/tests/marshalling_kunit.c @@ -0,0 +1,449 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * KUnit test for the ACPI-WMI marshalling code. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include + +#include +#include + +#include "../internal.h" + +struct wmi_acpi_param { + const char *name; + const union acpi_object obj; + const struct wmi_buffer buffer; +}; + +struct wmi_string_param { + const char *name; + const char *string; + const struct wmi_buffer buffer; +}; + +struct wmi_invalid_acpi_param { + const char *name; + const union acpi_object obj; +}; + +struct wmi_invalid_string_param { + const char *name; + const struct wmi_buffer buffer; +}; + +/* 0xdeadbeef */ +static u8 expected_single_integer[] =3D { + 0xef, 0xbe, 0xad, 0xde, +}; + +/* "TEST" */ +static u8 expected_single_string[] =3D { + 0x0a, 0x00, 0x54, 0x00, 0x45, 0x00, 0x53, 0x00, 0x54, 0x00, 0x00, 0x00, +}; + +static u8 test_buffer[] =3D { + 0xab, 0xcd, +}; + +static u8 expected_single_buffer[] =3D { + 0xab, 0xcd, +}; + +static union acpi_object simple_package_elements[] =3D { + { + .buffer =3D { + .type =3D ACPI_TYPE_BUFFER, + .length =3D sizeof(test_buffer), + .pointer =3D test_buffer, + }, + }, + { + .integer =3D { + .type =3D ACPI_TYPE_INTEGER, + .value =3D 0x01020304, + }, + }, +}; + +static u8 expected_simple_package[] =3D { + 0xab, 0xcd, + 0x00, 0x00, + 0x04, 0x03, 0x02, 0x01, +}; + +static u8 test_small_buffer[] =3D { + 0xde, +}; + +static union acpi_object complex_package_elements[] =3D { + { + .integer =3D { + .type =3D ACPI_TYPE_INTEGER, + .value =3D 0xdeadbeef, + }, + }, + { + .buffer =3D { + .type =3D ACPI_TYPE_BUFFER, + .length =3D sizeof(test_small_buffer), + .pointer =3D test_small_buffer, + }, + }, + { + .string =3D { + .type =3D ACPI_TYPE_STRING, + .length =3D sizeof("TEST") - 1, + .pointer =3D "TEST", + }, + }, + { + .buffer =3D { + .type =3D ACPI_TYPE_BUFFER, + .length =3D sizeof(test_small_buffer), + .pointer =3D test_small_buffer, + }, + }, + { + .integer =3D { + .type =3D ACPI_TYPE_INTEGER, + .value =3D 0x01020304, + }, + } +}; + +static u8 expected_complex_package[] =3D { + 0xef, 0xbe, 0xad, 0xde, + 0xde, + 0x00, + 0x0a, 0x00, 0x54, 0x00, 0x45, 0x00, 0x53, 0x00, 0x54, 0x00, 0x00, 0x00, + 0xde, + 0x00, + 0x04, 0x03, 0x02, 0x01, +}; + +static const struct wmi_acpi_param wmi_acpi_params_array[] =3D { + { + .name =3D "single_integer", + .obj =3D { + .integer =3D { + .type =3D ACPI_TYPE_INTEGER, + .value =3D 0xdeadbeef, + }, + }, + .buffer =3D { + .data =3D expected_single_integer, + .length =3D sizeof(expected_single_integer), + }, + }, + { + .name =3D "single_string", + .obj =3D { + .string =3D { + .type =3D ACPI_TYPE_STRING, + .length =3D sizeof("TEST") - 1, + .pointer =3D "TEST", + }, + }, + .buffer =3D { + .data =3D expected_single_string, + .length =3D sizeof(expected_single_string), + }, + }, + { + .name =3D "single_buffer", + .obj =3D { + .buffer =3D { + .type =3D ACPI_TYPE_BUFFER, + .length =3D sizeof(test_buffer), + .pointer =3D test_buffer, + }, + }, + .buffer =3D { + .data =3D expected_single_buffer, + .length =3D sizeof(expected_single_buffer), + }, + }, + { + .name =3D "simple_package", + .obj =3D { + .package =3D { + .type =3D ACPI_TYPE_PACKAGE, + .count =3D ARRAY_SIZE(simple_package_elements), + .elements =3D simple_package_elements, + }, + }, + .buffer =3D { + .data =3D expected_simple_package, + .length =3D sizeof(expected_simple_package), + }, + }, + { + .name =3D "complex_package", + .obj =3D { + .package =3D { + .type =3D ACPI_TYPE_PACKAGE, + .count =3D ARRAY_SIZE(complex_package_elements), + .elements =3D complex_package_elements, + }, + }, + .buffer =3D { + .data =3D expected_complex_package, + .length =3D sizeof(expected_complex_package), + }, + }, +}; + +static void wmi_acpi_param_get_desc(const struct wmi_acpi_param *param, ch= ar *desc) +{ + strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE); +} + +KUNIT_ARRAY_PARAM(wmi_unmarshal_acpi_object, wmi_acpi_params_array, wmi_ac= pi_param_get_desc); + +/* "WMI\0" */ +static u8 padded_wmi_string[] =3D { + 0x0a, 0x00, + 0x57, 0x00, + 0x4D, 0x00, + 0x49, 0x00, + 0x00, 0x00, + 0x00, 0x00, +}; + +static const struct wmi_string_param wmi_string_params_array[] =3D { + { + .name =3D "test", + .string =3D "TEST", + .buffer =3D { + .length =3D sizeof(expected_single_string), + .data =3D expected_single_string, + }, + }, + { + .name =3D "padded", + .string =3D "WMI", + .buffer =3D { + .length =3D sizeof(padded_wmi_string), + .data =3D padded_wmi_string, + }, + }, +}; + +static void wmi_string_param_get_desc(const struct wmi_string_param *param= , char *desc) +{ + strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE); +} + +KUNIT_ARRAY_PARAM(wmi_marshal_string, wmi_string_params_array, wmi_string_= param_get_desc); + +static union acpi_object nested_package_elements[] =3D { + { + .package =3D { + .type =3D ACPI_TYPE_PACKAGE, + .count =3D ARRAY_SIZE(simple_package_elements), + .elements =3D simple_package_elements, + }, + } +}; + +static const struct wmi_invalid_acpi_param wmi_invalid_acpi_params_array[]= =3D { + { + .name =3D "nested_package", + .obj =3D { + .package =3D { + .type =3D ACPI_TYPE_PACKAGE, + .count =3D ARRAY_SIZE(nested_package_elements), + .elements =3D nested_package_elements, + }, + }, + }, + { + .name =3D "reference", + .obj =3D { + .reference =3D { + .type =3D ACPI_TYPE_LOCAL_REFERENCE, + .actual_type =3D ACPI_TYPE_ANY, + .handle =3D NULL, + }, + }, + }, + { + .name =3D "processor", + .obj =3D { + .processor =3D { + .type =3D ACPI_TYPE_PROCESSOR, + .proc_id =3D 0, + .pblk_address =3D 0, + .pblk_length =3D 0, + }, + }, + }, + { + .name =3D "power_resource", + .obj =3D { + .power_resource =3D { + .type =3D ACPI_TYPE_POWER, + .system_level =3D 0, + .resource_order =3D 0, + }, + }, + }, +}; + +static void wmi_invalid_acpi_param_get_desc(const struct wmi_invalid_acpi_= param *param, char *desc) +{ + strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE); +} + +KUNIT_ARRAY_PARAM(wmi_unmarshal_acpi_object_failure, wmi_invalid_acpi_para= ms_array, + wmi_invalid_acpi_param_get_desc); + +static u8 oversized_wmi_string[] =3D { + 0x04, 0x00, 0x00, 0x00, +}; + +/* + * The error is that 3 bytes can not hold UTF-16 characters + * without cutting of the last one. + */ +static u8 undersized_wmi_string[] =3D { + 0x03, 0x00, 0x00, 0x00, 0x00, +}; + +static u8 non_ascii_wmi_string[] =3D { + 0x04, 0x00, 0xC4, 0x00, 0x00, 0x00, +}; + +static const struct wmi_invalid_string_param wmi_invalid_string_params_arr= ay[] =3D { + { + .name =3D "empty_buffer", + .buffer =3D { + .length =3D 0, + .data =3D ZERO_SIZE_PTR, + }, + + }, + { + .name =3D "oversized", + .buffer =3D { + .length =3D sizeof(oversized_wmi_string), + .data =3D oversized_wmi_string, + }, + }, + { + .name =3D "undersized", + .buffer =3D { + .length =3D sizeof(undersized_wmi_string), + .data =3D undersized_wmi_string, + }, + }, + { + .name =3D "non_ascii", + .buffer =3D { + .length =3D sizeof(non_ascii_wmi_string), + .data =3D non_ascii_wmi_string, + }, + }, +}; + +static void wmi_invalid_string_param_get_desc(const struct wmi_invalid_str= ing_param *param, + char *desc) +{ + strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE); +} + +KUNIT_ARRAY_PARAM(wmi_marshal_string_failure, wmi_invalid_string_params_ar= ray, + wmi_invalid_string_param_get_desc); + +KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfree, const void *); + +static void wmi_unmarshal_acpi_object_test(struct kunit *test) +{ + const struct wmi_acpi_param *param =3D test->param_value; + struct wmi_buffer result; + int ret; + + ret =3D wmi_unmarshal_acpi_object(¶m->obj, &result); + if (ret < 0) + KUNIT_FAIL_AND_ABORT(test, "Unmarshalling of ACPI object failed\n"); + + kunit_add_action(test, kfree_wrapper, result.data); + + KUNIT_EXPECT_EQ(test, result.length, param->buffer.length); + KUNIT_EXPECT_MEMEQ(test, result.data, param->buffer.data, result.length); +} + +static void wmi_unmarshal_acpi_object_failure_test(struct kunit *test) +{ + const struct wmi_invalid_acpi_param *param =3D test->param_value; + struct wmi_buffer result; + int ret; + + ret =3D wmi_unmarshal_acpi_object(¶m->obj, &result); + if (ret < 0) + return; + + kfree(result.data); + KUNIT_FAIL(test, "Invalid ACPI object was not rejected\n"); +} + +static void wmi_marshal_string_test(struct kunit *test) +{ + const struct wmi_string_param *param =3D test->param_value; + struct acpi_buffer result; + int ret; + + ret =3D wmi_marshal_string(¶m->buffer, &result); + if (ret < 0) + KUNIT_FAIL_AND_ABORT(test, "Marshalling of WMI string failed\n"); + + kunit_add_action(test, kfree_wrapper, result.pointer); + + KUNIT_EXPECT_EQ(test, result.length, strlen(param->string)); + KUNIT_EXPECT_STREQ(test, result.pointer, param->string); +} + +static void wmi_marshal_string_failure_test(struct kunit *test) +{ + const struct wmi_invalid_string_param *param =3D test->param_value; + struct acpi_buffer result; + int ret; + + ret =3D wmi_marshal_string(¶m->buffer, &result); + if (ret < 0) + return; + + kfree(result.pointer); + KUNIT_FAIL(test, "Invalid string was not rejected\n"); +} + +static struct kunit_case wmi_marshalling_test_cases[] =3D { + KUNIT_CASE_PARAM(wmi_unmarshal_acpi_object_test, + wmi_unmarshal_acpi_object_gen_params), + KUNIT_CASE_PARAM(wmi_marshal_string_test, + wmi_marshal_string_gen_params), + KUNIT_CASE_PARAM(wmi_unmarshal_acpi_object_failure_test, + wmi_unmarshal_acpi_object_failure_gen_params), + KUNIT_CASE_PARAM(wmi_marshal_string_failure_test, + wmi_marshal_string_failure_gen_params), + {} +}; + +static struct kunit_suite wmi_marshalling_test_suite =3D { + .name =3D "wmi_marshalling", + .test_cases =3D wmi_marshalling_test_cases, +}; + +kunit_test_suite(wmi_marshalling_test_suite); + +MODULE_AUTHOR("Armin Wolf "); +MODULE_DESCRIPTION("KUnit test for the ACPI-WMI marshalling code"); +MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING"); +MODULE_LICENSE("GPL"); --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EEF3D8462; Fri, 9 Jan 2026 21:46:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995218; cv=none; b=G0pZJ3Rh4OoQLoB3zQD+hvBn8b7K0cSOo069U5HOJOMQ97wjJIlxBaa3nrb5cEM8YczJlYw6LfZ7hJ9OuhFJufCCA0dNOdvruQfnX3SXlLTZKsPp6rAXcKT3eM0zMNk845IIp0eo8F1g0ovtsrF071RxXDd+p+W9HC1NuvLVT0Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995218; c=relaxed/simple; bh=E0+UClZTKNFD+rOEMwUWuL+siCBjTPa2M63+5AWwdmU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=W8TysimwzDLx86AtfYBudaT1h+5kz5FqGAKIjMCMkEChjTpmXXb+wxL/OvnMUeuCAZo1YCY2yzCNJhO25dNCFcilw3I4b+CzYuZDU3xA3/fm77U76b6MefiW14DxyJH9MS6315QD/L4FrT9ly+w7wE4qf1A81kjEgkkjfaO9gho= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=clLyW0ON; arc=none smtp.client-ip=212.227.15.18 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="clLyW0ON" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995202; x=1768600002; i=w_armin@gmx.de; bh=nCru25MMcaxm5j3/lo9WJAhRUlsBhv2miRhQx5ANaFE=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=clLyW0ON5JLfZoSz8DAZO9vH4l+MnJM64cw5ixqX/+e1KMuR6KO9gPkwT11qZDte ZaqrAtqQbwkMIORWoZQOLXCJz0HvBlA0mG5FTveY+BpwXjlb5sAf3aDjVWisMCcP2 31ztDLMnmFcEDdAx7NY375gyxa/3+nkH+HtYN7ybq8Ihz1TUxPFGJRxGZChneQO2V H6zp0ZVEodcsuk7QwN7ro3p9nQQ/axEUxPV1Yd6FrXeIT29d+9IuFE23DxodsFGWp uLi+rAVopwfKB7nzMIPSCzYoT3oQpYWD3Pwi3fIOv/eJSWVh8Dw99IwHrtY0CRVc/ XRtpVzGzaOiXo+HTIw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1M3lY1-1vebAH0X23-007NOc; Fri, 09 Jan 2026 22:46:42 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 3/9] platform/wmi: Add helper functions for WMI string conversions Date: Fri, 9 Jan 2026 22:46:13 +0100 Message-Id: <20260109214619.7289-4-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:SMBTD9afB4XbmuosnPnWOKTZak/DGEQkzOHVVXJbvyBEwLj5hoI rwbPem1zwFbeLfDV7329pga0RUTcwhHvJJrFpOnb6VigTaTD4mFu/3VA5wLNpw0pXTctJcY Zobll99NWv4C0jzopBgX+plZKSa0hp2NCpNg9/wHCWc9LHYsZcDBXJfPhh3xQkQq1JKH7p5 mwA33ueLRIY/wiopw1EFw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:CdCV5juykc8=;LwnWEZacLiFN3AjJeEfYGjD8QM2 YD0Y6NVzkxLkmZ7Cii0lqjR6cunNhoyzQNDz8ky2+LuqWC2LaN+7SUVNVK2T5v3qMxbHYWF0+ ri68fQ6rayUSOYtuNNbuOzp6ak3HUWfp2uPc/grlDJQ4r9Y59mC/CK7Q7iV7F/S/wVff4Eep9 jkyCFUFkH9gGkICUq3wyTE0pAQRXngNqKQNjh7MYWE/237xWe317mJDXyrT20JzF8mRbNAzaA G2aK6PQqi3eTTn/XRpxE7nRzyMKENik7Ya0kfYXVBq1KLX9iwZoOj58IMSXe50ck24IsQLGxU 0Le+k9dhxEaJG8gmJ5WUNHtsLIutzUsoR+KMFgdWNq/ZwI/zoFOY+rc56mdGYxY5Ds5aK8ebS orWKHEKOOhXO0pvb+5LzWjdPTWoZR5SJZvSgR1yR6IBGhArMqMdWnH3AMu07dikG0eX4UVoZx qFwaOPUY6YK9zDTBskoy7Cg7E++NP7V6lEAVRuxn4E15weNoQ+H/1CVWZzlUIxIUZW+537gfA 0yRhCJ4Cs22hK3khwFVG2JjvII8zZdS+6ifXH7TOAY2KP3CnP9e608M+qtGanXxGjQJiVKTgL aMOeNRVmJE3ucKfyMuypsLE1fcu4BGor88coNTVf+nO2jIT96icI74DQQZfFAtUgcPnqqOrd5 HfccSpJkaOqI2ACJTUzW8Vr5IykMSKnE7g9clVcXLt3uvXd6PgzZMrfFjAFGLjVoSyU/JaL5x I3vaGxk7KnTNyhr1nE4jUSxSXn6a6DWa8aVF6OymyYud7FatByjeAc49juAtNJbXS+lhHjv5i XH5s0kfwGueAzkey+YMKVJ/LRLOatWjzud8DMFv5USCIBfGp1wHRPXqYugfM/cIO6ful2s6pi q2cxAFsFCSLYHwgGlDGVcaDJjrm2PV786UiI3Gt1w+MD2Rj2axQNNbFyaJ/3unwVy1d+gDgvE 0cMriGQkCvYW5LqTTWb2ZpEbj3Q6JoA9jDzUKm4zB9GwbZ8rm3wUwGelEOi0C5UIwr3lFSV+h S1VCQoNnzneV4CM4wOSlDJpHz0TDSuWfXnulPDaAi4q0UstGMZ354GUMKPW+ZV1vlfZR2T9aA kLAHXfix2vqj339guk/OmOsO2dzPFMPBJhmf1jy6FlS0Kw0OK4yuwDzRvfY5/fq4eEVI8qnVi X0RsmcWhPbK/VgzP5OZTINpMs72eZYh7cqw0es5FBF87a46diifnHM9yGxhvaiFTAGGWUmufC IrBs0hbWwRIErw7ykrzHVJx0yGFJtyCjzo7I1oyx6RAHz62O52Nqu5udfideG8WtFRFitVPXu 0Ye2Bovos6jfZggVbA+0pCbgnFbwTqRUqri7CDKD1stmvqoMHV2+T12mXPwHz4YQilXMUOwVQ fsGuCsb/UqzK/vK1xhjz5lyIyZDwkRkvOFg+DoyD3ghm8eUa5trkrravQzurCviEXKPd/rIQY zczcSzGdUlEeemp662w+0EcoNbmSzNHEolhkshN2ZDeGRN/HCV8NWD6LLloLTHTF7UrAFaMff HDybpISH9WRhgZinAo57mgQ9QCnndaOykGzSBfQbN8nE8XgP1/RxiuZhcRCf6VNqXErRjLqIl X5VqBXcdCArgtEFUIwrMArVm/ohotFl1DWy+klIjUEXyTW8J+jOJiLSg+2r+7NIb5D/DkiZp9 m9ASIHl5/XJPgIzSM+ZfJCAIJY4nC3cnZuZD2Tah1QgfMJ5QmwI9KsOZhbTxHa1T/407ytk3J J+C1+ia6D/OpMDkvMCaaY4W9yFC0BnW/GUyXj3OLWRpGfyjeSHLYK1CNSC43W/ugTArtFjZFF f+8Pr2fB3zTIBQYvK5Bk216S10nRm9onIlnVcT2e0fUrKb6N39heLmcjkDRIzDgpHAnLmZU1S 1zO2BXEYNnfoGQrEKjazL3Qo9hnGHUo+y4kLEYwSThuLeWgE5NXh7aX6mG4TmefT85TQT+NCL YX3ECceNYzabd85Qw9cHE52ATyYLLTzZUnmqtATSom3pflr03XHc91ioggyLt8ULVtgWilzu6 8aTdyRgpPcbNANnwO6LSNAUy5ZSzYRcCSnSa8cgFDfjxCT8LDzIs3HIXtJJbfSZ2tluA/XTPj aMLiyLpiEMS2RK5Ij7bE9weputDIf+midLFgu10rCEoX6rVp4w5yzWF8qOJr1fjH7/ihvrxgU 7bkRKJCFXveu0xbIl+FVOmkq2fnuodhU78ZbLPcpPvvAkGEa1aEpKNLZJ9h5cB4BmhAthKVtQ Ca1JawEibsMlkqUNnW1Cm3yCSHhL1JqREMVxY9I9R8lAw5n6SFM7gi8Dp6XryEuhVCG0YONH5 L1feYuqMbNXCtwW/nfaHKgzf0+Ze6hJb4FCtIWuzsMcbHBLryMqNmEffsA/uCkPdmFqeT5c+0 KPQEUYasXmughRnpts0NWjn6W49rbe7zSib72aoIea0plXxGufDO7udYiN0smpH2uyHlEllhk CFuWzFN3GeW4c7dZKhKiJoVRKw750APoK/5fXh3hjGOZH7P9VbvTHgCzTqNmV2/cS5safDFWJ 6+zy9doGoNDz8XyI4OedUnno/2PrjYJeLBQQ4WavBt+BgH7zGATKBoWs8DBVBJ77iglUizvRN kCs9jcDHAhrJGC85Livu5azu1XFQ+jsz/s1avjM7Z1FcT+izAMWY7WXmkp1KRtJeqfv9yYj5V akIuaDRk8VMjWkiGIdrK1wDwDAfYLx80/GpMayO9R9K19EvHLnCp3BKeJ6fqqqsOYVPUYUaNR 4bwRFpybdhCsXMfNJqpZP98WW5okmN94059Y7e80S9yXynoPRkLTOEFZHme1gWO7JJqgaXNbD YVga8SZUIeivVFthcjxXs4YVEAK3hNxKODL+97GI6GIYe7ZcBIpLbNUblwaxXL2XKSBVyBRbl jCYNNegiKKz9SOCfRw8GWL423fDigpfztOv5pkFpzN33G0VDIzvzFzylbnomUDciJiRjfop4i O6elH+CFwAtvL1sruW8zslX/SsRQxZtQm4L7v0vftio8gmm3hZFGYAxcYSK2OUjDjty9BKgSo aLy6o1rK5yY7vp0JZXUXji6J7/tlPXP4Ra/Ebujp4jePcDVlip7P24hQBJ2m50VKgvD4ubCYP DKc/15MNSpPi3S2D6WnvsIq2OwRhZsR1thG6NGb3k6fx7i7DjHN2PTFSVj71Gu/ZuWOKGxEHU VkAhjNlVW1acGTVywkQwvp8PC2I/IMIXnzUv7RFnM4AuT43dLYadXx6rG8mTmz7hjOfAdFNCk 1LFlQzl7QWnTIK23TBtdSHEgf9kGDQZXn3TAB9IslennW7Gp5tKG2Cdo9B9FcVWGIiPhwlTfg QhrEftBHcZ0/q0A734v4oFkcKK0+fPsBmhNIMqTnHUkXHqIE5zsI4UrfDdww64S9GF2jU697D WIqtaBs8hR29gtirY3Hd7iRiPqBoCda1xwqyWF2jMN2bhmKZ7GZ0D1tlg/XCpneqIHqRSRepa MfzZ0zVsbIGhLRTi+5Rkg2+OVy2BTpixQVIrcuf5me4OyrVbeRcGGaaJlmnCBRJeBXA6YO5M6 blIKdNGjjUgDTVuzbE9kx0TQZZB9MA24a5p+du2s8M9jbeg22rOTKJfgATz1yo22+l58OeRec 4yR4pVTkTfHQmB2h9U1RU2VzhvQ5WpkkTEYWzbNk8sujAOQDE5QwpSskjSZXhKpFKBnxu3kHe AIAwErw2ImjIpO45H4pbgpQTjiC1FmIOw+L1k15dexudsydndFea+4hs5X1+5kqrv8Q+jLEX+ 0296B2cvougnqH+YqAti1HaN2MV4Gx0euWz99lr5XGb8fHoPmt2a/0f1nwExb/BkroJoVeLCS ovfLLKO9G6ZhKAtd1t6jqhoGiKnKv7zQ6PlA6OXtz7gozXwPrIHV6uez5QAqfeGKyF6etz4q7 kau2tWow6Q0ihQQgzViUEoiflNU65HDkXyrMVlSIdHvgTlkrHDELVDG6Af7jGAhNb6ouxK0x+ ADPeL8kzIgKwRFqMBSwduyUeocnOGFTaH8nrfrtDMYValBMmWZHiswUWvgfwXNVS6ipvjmA7y 00eVN0pGujFExIBB8kiYXWoUlZWac2YXOTjozdmSuG0rn1x03AYU/SOnnB2jQ+whrpUEmwziL raeUBQYJ4nhMIQcLN76hV4KxREQw7F/O0ZUlCpAvwjn5qR0Ce97dZynt1gw3AZ+T6qbOQ+tx4 USdz/IyBwU9SeiAo6pDIFxDr0aRw5Gw6Pd45npwsKRaiU0IwWW+iCmnMGia0Bbrz3ub0adXdg 9uda1c9Lw4tHnHCxr4OgmLmEi3XxTbL09Ep3uWByGCwMXEGAPbsq1nr8PZgKgHIM867eTsdKm hge8LnJ6aYyFChRfdTtz/E0uaTDWSeOdyRCEG4VfszAYO+cuwGVW1UsOlWLmRoT/2JikxXmC5 Ms44PSmJoZw/NL9AmAcxKkjvZqVnRxIqLoKUxot9knLLvz4+S3cTPgZ5UItt1SzoHOOsaQylg cA1QrA0Fld7jnWL50k/K+Jr7b7MuHOYSD32PVd5fHun0Pwl+cyRGSTGoT5Xwt4HR9mSShOmNy /cu+/WlPsjZAp2sYf8bHjijSn0rfIwbEl7lNTp9A1d1QQWGRHhu7vL7Iy3RPOtb0KlTJgJAbU w1J7zkxR4CWdpzW2EsqBkLVjpO7qwJjLmpvn05aA4aqA4NL8M5JUXn8yrrWPEVdr//yOnmi7m JzMlMIan67kQf6FFfIukhEZqc1gZV6rdFiNC5i3bI04dzm0OXviGHzIpRvgxJM9n5rwkb/akT Ee4pnG+w2mHgUMKrnJJFm39jablZ+T+oG4Tbsh9iAjZY0/7cUCIDBVHz1rEOa5eLx9+Ew9lPX bgrPdLRUhKIMKBV2gmCB0zndAsyWVIPSij3rRrQFUn2vrgxG1xVpoMN8XzviQzFLJEqW8+1VV oEG+Nnd0+p92edgjgkeZPaKBsPNJbtGpt+HWpi29zsfUOjMMKo2pJ3j0V8shDkdAjisf9CJ1n c117bGKI3EE87fAnjozi0vHpo6nBJsx/t5R/zT/fNk+2HyOaTdyMk4KHbCAc7eJATE2LaL/Iw gHUBllidTW1P2SuoJ+M/AT4pDecwqfmkJWrZJEtxxubQD5qW7TQrGVa/wI931kmzHO6KJ+12x NTLe80bgRTI/4DRun36E11WDdIT/2fnNwzv+ldfWwUHlUdwIr4Mtwlsgmkyuhox9zsaLGWwB9 INVBnZG29MQglR7Kkq1JrdQVE73bCW0d60ilNo2T0bg8BrV33rQ== Content-Type: text/plain; charset="utf-8" WMI strings are encoded using UTF16-LE characters, forcing WMI drivers to manually convert them to/from standard UTF8 strings. Add a two helper functions for those tasks. Signed-off-by: Armin Wolf --- Documentation/driver-api/wmi.rst | 3 ++ drivers/platform/wmi/Kconfig | 1 + drivers/platform/wmi/Makefile | 2 +- drivers/platform/wmi/string.c | 92 ++++++++++++++++++++++++++++++++ include/linux/wmi.h | 5 ++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 drivers/platform/wmi/string.c diff --git a/Documentation/driver-api/wmi.rst b/Documentation/driver-api/wm= i.rst index db835b43c937..b847bcdcbb09 100644 --- a/Documentation/driver-api/wmi.rst +++ b/Documentation/driver-api/wmi.rst @@ -16,5 +16,8 @@ which will be bound to compatible WMI devices by the driv= er core. .. kernel-doc:: include/linux/wmi.h :internal: =20 +.. kernel-doc:: drivers/platform/wmi/string.c + :export: + .. kernel-doc:: drivers/platform/wmi/core.c :export: diff --git a/drivers/platform/wmi/Kconfig b/drivers/platform/wmi/Kconfig index 21fa3e440042..d62f51ff3b7f 100644 --- a/drivers/platform/wmi/Kconfig +++ b/drivers/platform/wmi/Kconfig @@ -6,6 +6,7 @@ menuconfig ACPI_WMI tristate "ACPI-WMI support" depends on ACPI && X86 + select NLS help This option enables support for the ACPI-WMI driver core. =20 diff --git a/drivers/platform/wmi/Makefile b/drivers/platform/wmi/Makefile index 93f37ce519ae..2feff94a5594 100644 --- a/drivers/platform/wmi/Makefile +++ b/drivers/platform/wmi/Makefile @@ -4,7 +4,7 @@ # ACPI WMI core # =20 -wmi-y :=3D core.o marshalling.o +wmi-y :=3D core.o marshalling.o string.o obj-$(CONFIG_ACPI_WMI) +=3D wmi.o =20 # Unit tests diff --git a/drivers/platform/wmi/string.c b/drivers/platform/wmi/string.c new file mode 100644 index 000000000000..0fc43218aa5b --- /dev/null +++ b/drivers/platform/wmi/string.c @@ -0,0 +1,92 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * WMI string utility functions. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +static_assert(sizeof(__le16) =3D=3D sizeof(wchar_t)); + +/** + * wmi_string_to_utf8s - Convert a WMI string into a UTF8 string. + * @str: WMI string representation + * @dst: Buffer to fill with UTF8 characters + * @length: Length of the destination buffer + * + * Convert as WMI string into a standard UTF8 string. The conversion will = stop + * once a NUL character is detected or when the buffer is full. Any invali= d UTF16 + * characters will be ignored. The resulting UTF8 string will always be NU= L-terminated + * when this function returns successfully. + * + * Return: Length of the resulting UTF8 string or negative errno code on f= ailure. + */ +ssize_t wmi_string_to_utf8s(const struct wmi_string *str, u8 *dst, size_t = length) +{ + /* Contains the maximum number of UTF16 code points to read */ + int inlen =3D le16_to_cpu(str->length) / 2; + int ret; + + if (length < 1) + return -EINVAL; + + /* We must leave room for the NUL character at the end of the destination= buffer */ + ret =3D utf16s_to_utf8s((__force const wchar_t *)str->chars, inlen, UTF16= _LITTLE_ENDIAN, dst, + length - 1); + if (ret < 0) + return ret; + + dst[ret] =3D '\0'; + + return ret; +} +EXPORT_SYMBOL_GPL(wmi_string_to_utf8s); + +/** + * wmi_string_from_utf8s - Convert a UTF8 string into a WMI string. + * @str: WMI string representation + * @max_chars: Maximum number of UTF16 code points to store inside the WMI= string + * @src: UTF8 string to convert + * @src_length: Length of the source string without any trailing NUL-chara= cters + * + * Convert a UTF8 string into a WMI string. The conversion will stop when = the WMI string is + * full. The resulting WMI string will always be NUL-terminated and have i= ts length field set + * to and appropriate value when this function returns successfully. + * + * Return: Number of UTF16 code points inside the WMI string or negative e= rrno code on failure. + */ +ssize_t wmi_string_from_utf8s(struct wmi_string *str, size_t max_chars, co= nst u8 *src, + size_t src_length) +{ + size_t str_length; + int ret; + + if (max_chars < 1) + return -EINVAL; + + /* We must leave room for the NUL character at the end of the WMI string = */ + ret =3D utf8s_to_utf16s(src, src_length, UTF16_LITTLE_ENDIAN, (__force wc= har_t *)str->chars, + max_chars - 1); + if (ret < 0) + return ret; + + str_length =3D (ret + 1) * sizeof(u16); + if (str_length > U16_MAX) + return -EOVERFLOW; + + str->length =3D cpu_to_le16(str_length); + str->chars[ret] =3D '\0'; + + return ret; +} +EXPORT_SYMBOL_GPL(wmi_string_from_utf8s); diff --git a/include/linux/wmi.h b/include/linux/wmi.h index 81f24d238a2c..75cb0c7cfe57 100644 --- a/include/linux/wmi.h +++ b/include/linux/wmi.h @@ -62,6 +62,11 @@ struct wmi_string { __le16 chars[]; } __packed; =20 +ssize_t wmi_string_to_utf8s(const struct wmi_string *str, u8 *dst, size_t = length); + +ssize_t wmi_string_from_utf8s(struct wmi_string *str, size_t max_chars, co= nst u8 *src, + size_t src_length); + int wmidev_invoke_method(struct wmi_device *wdev, u8 instance, u32 method_= id, const struct wmi_buffer *in, struct wmi_buffer *out); =20 --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1EA1A33E378; Fri, 9 Jan 2026 21:46:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995218; cv=none; b=c154uOwf4jRi1+siVo5/wa/3csgv599Te1xUYxWjZmMBv1FgkvWBB1ow7d81vOSevKpIf1SzsGni5vPfhMvXur1luI4QSG1xwkbgl8Hc76/TWmgLCEyjJhnqR0fDLzfjPL0/Jwaw1XNLiTUHpdFSDIOEZ4A1Aoljlzye5Tz7cgU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995218; c=relaxed/simple; bh=ky6Uv9/uEc7uB1evuRXEl6vo13vIWeN02C3RIC6h4Jg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=j2YTfu/iPXhLvVegtG/KPVXfEqGwk+IuREMjYErwQdlf2hjwyw/W6XQS3kxxd2SQsg5b/EBMYX/7zX85lR3UOR2ka59RvAyIbC/95v7iwAXGYZIti33r+WTLBfFxOwWetFcNbLoh38fZaCAgyVwtpHTqq3j6swe0HZgEbUVdAL0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=cArdKqNM; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="cArdKqNM" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995205; x=1768600005; i=w_armin@gmx.de; bh=NitAERjcXLJHRK6288iehSoLRg5EoInw/6zaVgJadU8=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Type:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=cArdKqNMjV17l9k7SZ6bmZhY4+KU9HRRRNfgi8sPe1OzHmIXY+a7ty0JXi93UXaG MHjLSnNRPKRUI0B91obrDuiSt7OY2rU9c0a9RUW/9AHi67B1L215mhZc4sxlwUadX vR32NkCUkAlz0anMt5XNElWkeCybAjB+flhDGK5oaDcduvkalkeZDheM1eBLEYV40 4e0VdOh/AHOWcSir8d3K9q9JzoF9sZkfNcmU7lXXtMm+6Sh/LdrM88Mm1xt6fXdKg xgSLrkyfflLc2w77X4MTaA7Ue6K2/9ysd80wO4ZEodBXKMMraxKq+6z1bPmjGSMD3 rXHRdTDbe/l54UT1aA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MPGW7-1vU4Mr3sEv-00KasE; Fri, 09 Jan 2026 22:46:45 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 4/9] platform/wmi: Add kunit test for the string conversion code Date: Fri, 9 Jan 2026 22:46:14 +0100 Message-Id: <20260109214619.7289-5-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:18qiiithjGkB4g8k532jBMoP1W1MLvz7U7ePJ3iIWlusNljBQ9z 8WBTneWPTMud48FvcRYR3jrotURMsoSGD5tAo3Bsq++b5ER9a9KYQJBb1lRiVu5DfkDJTlW HHsTwg2ZVJU5h/J/m+6+MMfdQRyrTvdsHeqN3LzxIAQj3PAfuMW+IW+mzkNrREySVH6yAYN 6SINvB/C0vGu5T0cmtt6A== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:QzSF2KKyJrM=;jR5HXMkKCWt/B3oLGhzgiB63Sch r4WjscFyM7tY/X87WRBT7RvuAeg9AojEiGcNu5/JKEA9KzobbS8jCSNkgOg0UBR4yzMNPVAx0 FrVDmd07Zvu8AVCFO6ClTpCG4dPvOUX/+W0jBEHhwUcSL6MuPfjIEIDxOJDHQ+BpkLMS4EK9T X8D2EzGnOhqCp8QEvMs+MXHKJzn+LCJUTQY5o8ZNaH95bwZeMet5vIPddHHcScKM7ZeUp6tN5 HvL0HpGQP2BVodRyKvhpGAaSF484A9pTAXUz1CQoEzIi9dcUFGVjOohZJN1lhrPsABlV+z2hn DtzJt+DiBtJdduodM6oCSkk23Lo+i5ChgkvPLPi5oKC/csR5Xqs8mPxZNWtk0iSzKg4IApKmY 4HH88xQjHMEtHTi3BSVrIGxCxVgxQI8YWSwM9PyYJxMWwrTXjo+s5fyO22TuuUn5p5A8byVjI hwzEZq6DSMg0LCcj6zZAGhzMDBEVVb/TEtAZJVPdDFTPdfvSNzWloVztELBFPJrAhjebjHRtn 5S5Hcd4zs+xK8Src+GzJK9gu2NuJS0DoeqQU9dqiS6Ngevn+WGvqzvsMXWoBy9qYDJeDO2VdK qGAWhqrsDfpaECzUMz6BR40Zn8QwOKIBy6jEM6xwjnyef+7S6h1vaUsW7r4wbweNX0DDPavS/ 4qlsqZMqZC3sDhUrLtKeqR+SSoqKuOSGA3Zp8G4XpAEr+hW0Sh6iIMusaMDgvh6VaHZ2SNFrJ mZO19oSlVA+hgIS2p1UJ7AU4yApJgCCLP59RK7othXz/Z4MEi35GZC36+keN97yGPkCODWU8q z5+7Ru2D5fcjCX2bDCLO4nocLxrizqsQ66NDxv4qU0qWuMyn7GVGHHq4pLysu1bgpzg+537zG qxpxNj8OZQ6GUo2p34XdD2aVfCUEVjh22ARt0mTosGuPxL2po/p5UZfdKAbLUe/CoM1O72fI9 0WsF9OukY8Rv2BcZQLe22UyIUi3N+gXsrEwyRLHMutDMfhLF+/NWetiBxcd6D9TDPHA3M7MQs JUzJadN15QqjBlfzB/zt62BKo5mW2WRPSB4brXyR5JV7V6vzHOqMy/KKrwxG0HhwifmWbRhxI vzT9a+28/T/swxp8aHZRGotg/05+2BX4Qp/QP/QldKjVGdaadAoioE5gb3OdoWD0qRdKiKaLh cWCJPx6e6lCPDSM8+/c8cEN8Rj4jPuJhiXbrfGE8xcLfM7VYkKwJEgcRry2KYjcop3ymJpT3n h5PlBA/9ixlM7zlzYN7/m65Jy4qDC+q2grHUxmnhJv5G8r8Juo0uL9Hj29Ihdw/r4mIABc53z SHP8XzxJId52neHHWfnH6Trv0NSLA5GPZfHNecwHYoWhOmJqaefpOH/SM/NLUVkum/wi4KFMS Syz06PeSbxCNEScoyk2IUieYTJeHuOhR3ailKOjHIaInwUid8I5P2PcKQgHKNJ20MC9w4cXw6 Ay2q+/0FWMQ3Fo81bOFNkMpmwCclhl/xvR8PsjBop1hnUuJGsD1i/Uqtu7DVezy4aGygYDRro chvPlN/HwMqHqtYNpzmYMFAsmGQVqmucxmNubU1fxo2l1LzgYhpBEK02fXQAq+VYnEtxwrcW2 3wtdtT+0QxRXvjjZrI/q0pQt7wXvTnMSv+gAuKgrWLIlgB1iATBH0Ps5foUGI8OOMTy1qTtIJ Gu0tfJHFZ5fcqibz2UOLga3FIBUxQ9o32fCNIWmTpyDH8Od+qLfVnmvPiYLL6XnzmHGfEBu2i YpUFe8ClZWhRcDVkDQDw/DydwdHVNbOMCCTTbWkiHRNpTuVGJ+HYewdLBz0FU0hI8GCsVMeC5 oggN1Qu+jLsIYXD7ioq6Kp2Z5u9PjBvW2UKDS6BquPrWNzBaofstr7hKg0zv2Af1qSYrctwmK 9P8KRsj9h+u0m94eh5K4Msd80yK4AdoaN/pw28HwheUYPfy2rs/CMEF6vgPCswr4g8L2KCnPY ME7WcnlMFs+M0PBxGFIS0zHjEUKj2hZNjICHUqFZNaxR4qNrlO0rKc58Zb3YylqSRUOQkPVEA 0p8qVEI/xBIkkXezJPRZ/XcT1aCa1mQWJdj2ZraIzGMBdC07jfx3O6kNWz5uKKafJuGFYJ144 X0V4fKvp+i3z8d4mKNr2lzN1h2swoKRbbgN5KX6CE5qsURPUj3FD7ULMGLCdSeMVcgaF4qxjI Hr2S2zzxtqbTzIRD03dWhn6mDTApTpiOwtKQd35JZaVhx/edxx34bTTjCwMnAydG3dDNwd+lI Ecu6ig52VkUC3vVvNSrpK1JBEi22ydeXjCguPGFy0g4uXzVkDwXkKSdpA00shyRcN/SxW4cJD ZreHqVer4mQf13GbGO1keWjMJJJbXf2NlF4XLewBNP48JNzjHJxs3qty79EH0BlVMUFlQLWWE bAmmJiNgZAvTtRkcUoxovYNj+S3eemdl5KobhhrYmdg1wTbuw26SZmsuYAa/+22mS60e++kTG U8KUKR5UOFVwtqihhdxQ+d+M/NZdOcHL7+IhlbCTyZ8pBU3sJMQPGruio344kb+WHh5K4JpcO v6w5/btPy/I4pLnbKRaAfELIgCIaydqfz4/hOn3PmDsN++rClJ1cbIXtiXJUj8l+eSriKuam8 CEVW6aiRvKyDCW4WExIXEgLAkS21hJRph9qg7nfkS0Xwr72M28oSLK2H1gdCrOyTyf+dpdZ4/ 77bjgxk5rG9lTdQ2r4FZ28Q1eKXHhrMOfV82Z59jZDLWeuKsIXOWkwuAzvkFelATe2B/0E23y pg6rsfXgu0x34DZal1xlaVxzmftFZD0yVBcqkT6rAc331oCc/10e23pXuukh/Bkiqxa/CiPDE OzQaRP6hBE+CLXvoAx+AfpXxFpeH47K3huWXZ1iq+T9EY7XaXXiqJB+NHMkzapjUaNbSorzuU Op/7gLl5amk6tWxA6IwVbCYvxEEhhl8qPMnVQDjjdteaA6B/CPBaHizGMXCvrS5OXuJm2ZcyR qAZ7BE54huw+xcAl8Cy604IDLAffCCADb8aM1xr4hObvIsFwNSvK3RVne0Mm0RSQG76D0FtYh XuMTrQRLcGfqR7z1nhSBUYcV98fi80sGbqIzFikOpwIIB/ThLGbV7mKxQoLxYf/5OCjbxRGjs +fXSS9zeBGYnIVxp+bVv2bDKdTcMrmlS84eKALlFodPTfRBzMlgRBolJ1QEgGH1qX7CNyFbit CR4R5PLfLfJbYg0hHr03PPuhMthbMjyXCYS1e10guHZa0wv0qNGhacECT4F2d2x5yxD6TjnRl gMmd75LM9c09YmAy6mH/CMhle7vnyGyOD0gJuMfnobky858UxDpa75Jt1bJ7aClKZF6gYZV// o1Yc1A7zQsrykQFE9Shn806Ya1+FEA1eSKeMziMauZx8HcX84UryGAgm+y9EbSvWFHAm0IJAQ A89GTOzEEMLPrtB3cJvXNqeqObhaVlr5W5ZjN20BZGyVG4oHazG2jkLyBoEsVs6f/j3+H2AUP JpIA/Knz98s/FhaD6BcUQ9AIYOrlsPtfjdi44rEKXjhW8Y/6nFKEoJuFajRZkoBaDVnbJ1j3+ 0Pn03VOKvMbEqEOSSzgVJEzDcxelFJpKqartso2w/U6ax/iqvOqLUHCmMLdPOfB8FWIHfHS3d B6WcaED62Qlk6lebeGm+jSvFepgjJSD8O45BNpJTvs23FkXrhvMe6Iqs9zaOTz4kCThWHgjLv 90qQvoFcJHFTAcXJxGUci+tBVqP0cuk/PUcNc+jkZxwyOOKFC2X32akFk2AakB0epkNIYS3Ac Nxf/2a3wM3fTseZovtYkloYJ63751774Z4lNlTaNvALpZhfIWxXFu2XQW0w4WriF2ajUeI70q QjrpRdgEOAOvhcfvaVShsXozJoFLHdzJrRZtg41BZM5JLwj451jUoc/AM4KXXMbjcqBheRBj5 q1hnJeBPZ8XqrzMvA0XcaN/fWj/ToynCEvCIBo7Wh2s6anYweMKtzWCnlThT83x1E11xuC09w CMl6KntBWf5lTzXLuPVEyQ6hokTKrcPff5H+7HL5ZF5Fp7cSRmkbdIRXxBpsukNdNO+iCppQN 5GYEZgssOZX0OMAXUl4QrTtISqC3m5WAh76s4cyXXG4aFOWiJuh8tD89S0pT5/NRLEfevCFds 2lXN3IRNnHwM2Adt9jdwo6wCQ2eQZgAAnm6RXH5aH5YEZkw0qUbRO6ZXQ/D5VDNTpfSWAlXTr bqUb3yXSNEzPL3dWIPIiTTD4TY69JcAv7MgbXG/JOdLHbxAFSqq+Qo4YVY4F1fJPHq7mG2WB+ u86FCFCJVy0UgD35laM1vxcUGCZ4OzJnleLiP4qQsj5Mkphi4JP4rd0PcEA4eQ0Ed5TmFv8dd uKNsLjV+y7+xdKt86C8CzA1obhBhGuDy335HIWZyF1R3v2PGLvUKrpa9ButiGcnGV85DeReyO j8P6dSI9OawvWo6wYd+k6Vi8J/i0xRleivgZq9OortF0QONB1KHcEN0kM3RA+xLGe7iCPxbO1 uAn7FpN/4prBmPc/Bz/c5yvn+XR47o5pf7XC61TXOPIvS85aawO73DfBpRw79I6niWTdyDWKu VvogYWAYfFWNURSGvYRHaTiUdHPJbRKu5B/5x+YPI85dAkb18RukTHdwDEqOo8clmy99i3liU W3xqsS0kakG8TuaygWzgacdVSGrRZZRYYp5ENsCJt1EMtpcRtW6LetZTXQd3vR/BZ/BsqUx0p oiI8e6t13rkTxnRiWJ1Hrau12i/DTxL9y/3CKd0yMsxbfqWq7KR8wJVaDTv+Cm6MOVmaU3ymG 43ZGCE7EKPHLhuQ1o5W48Y4oiwMzmB6HwiHCvH0egqBSrUhioLDxcsxfEi9o0C8VNRTklh64e NOwVP07dbDMD713KA4f3Kax/KH3G1FO2Kh+nPJ0wmnsWK4gMsw+DL7AraIacmOuJZsHcgtYf9 xQYsI+W0636a8xPesGGAU1iplzjrP/Y0YhIbq0XshRcxyVbcMYTK3L2Wzp006AukTof2WV/WR I08DRrMCo7T1/rerOhFd2fxo26FYlxr3b2dT413z5MAZ4aSBAF32IGgJDXIe6QdlljTKxoT/d LZLXxBu+u0wtK3bVV4KnFxJYko7bcBaIEFED6S+EAzS6BnLyrL+tguOXacfiIhavOGvxC2uOG /wSzGTS5w7z8Hkw5gf9SDdAxRL0Vdt8C47CWFBl3907k9EDHztuAwlqYJ4SqXd8zTFNyuG6Gq xHkbtIkfnkTw/s5Udd3E2SYpM9VKQ6GFMm1oMFgtVE5oHtAktbhJCg9JuYNurOuzprZMulToG 0jXLEEX2uvl3U3OLeRbY Content-Type: text/plain; charset="utf-8" The string conversion frunctions provided by the WMI driver core have no dependencies on the remaining WMI API, making them suitable for unit tests. Implement such a unit test using kunit. Those unit tests verify that converting between WMI strings and UTF8 strings works as expected. They also verify that edge cases are handled correctly. Signed-off-by: Armin Wolf --- drivers/platform/wmi/tests/Kconfig | 11 + drivers/platform/wmi/tests/Makefile | 3 + drivers/platform/wmi/tests/string_kunit.c | 278 ++++++++++++++++++++++ 3 files changed, 292 insertions(+) create mode 100644 drivers/platform/wmi/tests/string_kunit.c diff --git a/drivers/platform/wmi/tests/Kconfig b/drivers/platform/wmi/test= s/Kconfig index efcbcb51c251..f7f0f3c540f5 100644 --- a/drivers/platform/wmi/tests/Kconfig +++ b/drivers/platform/wmi/tests/Kconfig @@ -14,3 +14,14 @@ config ACPI_WMI_MARSHALLING_KUNIT_TEST to the KUnit documentation in Documentation/dev-tools/kunit/. =20 If unsure, say N. + +config ACPI_WMI_STRING_KUNIT_TEST + tristate "KUnit Test for ACPI-WMI string conversion" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + help + This builds unit tests for the ACPI-WMI string conversion code. + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. diff --git a/drivers/platform/wmi/tests/Makefile b/drivers/platform/wmi/tes= ts/Makefile index 252c3125353a..62c438e26259 100644 --- a/drivers/platform/wmi/tests/Makefile +++ b/drivers/platform/wmi/tests/Makefile @@ -6,3 +6,6 @@ =20 wmi_marshalling_kunit-y :=3D marshalling_kunit.o obj-$(CONFIG_ACPI_WMI_MARSHALLING_KUNIT_TEST) +=3D wmi_marshalling_kunit.o + +wmi_string_kunit-y :=3D string_kunit.o +obj-$(CONFIG_ACPI_WMI_STRING_KUNIT_TEST) +=3D wmi_string_kunit.o diff --git a/drivers/platform/wmi/tests/string_kunit.c b/drivers/platform/w= mi/tests/string_kunit.c new file mode 100644 index 000000000000..9aa3ffa85090 --- /dev/null +++ b/drivers/platform/wmi/tests/string_kunit.c @@ -0,0 +1,278 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * KUnit test for the ACPI-WMI string conversion code. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include + +#include +#include + +#include + +struct wmi_string_param { + const char *name; + const struct wmi_string *wmi_string; + /* + * Remember that using sizeof() on a struct wmi_string will + * always return a size of two bytes due to the flexible + * array member! + */ + size_t wmi_string_length; + const u8 *utf8_string; + size_t utf8_string_length; +}; + +#define TEST_WMI_STRING_LENGTH 12 + +static const struct wmi_string test_wmi_string =3D { + .length =3D cpu_to_le16(10), + .chars =3D { + cpu_to_le16(u'T'), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 test_utf8_string[] =3D "TEST"; + +#define SPECIAL_WMI_STRING_LENGTH 14 + +static const struct wmi_string special_wmi_string =3D { + .length =3D cpu_to_le16(12), + .chars =3D { + cpu_to_le16(u'=C3=84'), + cpu_to_le16(u'=C3=96'), + cpu_to_le16(u'=C3=9C'), + cpu_to_le16(u'=C3=9F'), + cpu_to_le16(u'=E2=82=AC'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 special_utf8_string[] =3D "=C3=84=C3=96=C3=9C=C3=9F=E2=82= =AC"; + +#define MULTI_POINT_WMI_STRING_LENGTH 12 + +static const struct wmi_string multi_point_wmi_string =3D { + .length =3D cpu_to_le16(10), + .chars =3D { + cpu_to_le16(u'K'), + /* =F0=9F=90=A7 */ + cpu_to_le16(0xD83D), + cpu_to_le16(0xDC27), + cpu_to_le16(u'!'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 multi_point_utf8_string[] =3D "K=F0=9F=90=A7!"; + +#define PADDED_TEST_WMI_STRING_LENGTH 14 + +static const struct wmi_string padded_test_wmi_string =3D { + .length =3D cpu_to_le16(12), + .chars =3D { + cpu_to_le16(u'T'), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'\0'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 padded_test_utf8_string[] =3D "TEST\0"; + +#define OVERSIZED_TEST_WMI_STRING_LENGTH 14 + +static const struct wmi_string oversized_test_wmi_string =3D { + .length =3D cpu_to_le16(8), + .chars =3D { + cpu_to_le16(u'T'), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'!'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 oversized_test_utf8_string[] =3D "TEST!"; + +#define INVALID_TEST_WMI_STRING_LENGTH 14 + +static const struct wmi_string invalid_test_wmi_string =3D { + .length =3D cpu_to_le16(12), + .chars =3D { + cpu_to_le16(u'T'), + /* =F0=9F=90=A7, with low surrogate missing */ + cpu_to_le16(0xD83D), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'\0'), + }, +}; + +/* We have to split the string here to end the hex escape sequence */ +static const u8 invalid_test_utf8_string[] =3D "T" "\xF0\x9F" "EST"; + +static const struct wmi_string_param wmi_string_params_array[] =3D { + { + .name =3D "ascii_string", + .wmi_string =3D &test_wmi_string, + .wmi_string_length =3D TEST_WMI_STRING_LENGTH, + .utf8_string =3D test_utf8_string, + .utf8_string_length =3D sizeof(test_utf8_string), + }, + { + .name =3D "special_string", + .wmi_string =3D &special_wmi_string, + .wmi_string_length =3D SPECIAL_WMI_STRING_LENGTH, + .utf8_string =3D special_utf8_string, + .utf8_string_length =3D sizeof(special_utf8_string), + }, + { + .name =3D "multi_point_string", + .wmi_string =3D &multi_point_wmi_string, + .wmi_string_length =3D MULTI_POINT_WMI_STRING_LENGTH, + .utf8_string =3D multi_point_utf8_string, + .utf8_string_length =3D sizeof(multi_point_utf8_string), + }, +}; + +static void wmi_string_param_get_desc(const struct wmi_string_param *param= , char *desc) +{ + strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE); +} + +KUNIT_ARRAY_PARAM(wmi_string, wmi_string_params_array, wmi_string_param_ge= t_desc); + +static void wmi_string_to_utf8s_test(struct kunit *test) +{ + const struct wmi_string_param *param =3D test->param_value; + ssize_t ret; + u8 *result; + + result =3D kunit_kzalloc(test, param->utf8_string_length, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_to_utf8s(param->wmi_string, result, param->utf8_string= _length); + + KUNIT_EXPECT_EQ(test, ret, param->utf8_string_length - 1); + KUNIT_EXPECT_MEMEQ(test, result, param->utf8_string, param->utf8_string_l= ength); +} + +static void wmi_string_from_utf8s_test(struct kunit *test) +{ + const struct wmi_string_param *param =3D test->param_value; + struct wmi_string *result; + size_t max_chars; + ssize_t ret; + + max_chars =3D (param->wmi_string_length - sizeof(*result)) / 2; + result =3D kunit_kzalloc(test, param->wmi_string_length, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_from_utf8s(result, max_chars, param->utf8_string, + param->utf8_string_length); + + KUNIT_EXPECT_EQ(test, ret, max_chars - 1); + KUNIT_EXPECT_MEMEQ(test, result, param->wmi_string, param->wmi_string_len= gth); +} + +static void wmi_string_to_utf8s_padded_test(struct kunit *test) +{ + u8 result[sizeof(padded_test_utf8_string)]; + ssize_t ret; + + ret =3D wmi_string_to_utf8s(&padded_test_wmi_string, result, sizeof(resul= t)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, test_utf8_string, sizeof(test_utf8_strin= g)); +} + +static void wmi_string_from_utf8s_padded_test(struct kunit *test) +{ + struct wmi_string *result; + size_t max_chars; + ssize_t ret; + + max_chars =3D (PADDED_TEST_WMI_STRING_LENGTH - sizeof(*result)) / 2; + result =3D kunit_kzalloc(test, PADDED_TEST_WMI_STRING_LENGTH, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_from_utf8s(result, max_chars, padded_test_utf8_string, + sizeof(padded_test_utf8_string)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, &test_wmi_string, sizeof(test_wmi_string= )); +} + +static void wmi_string_to_utf8s_oversized_test(struct kunit *test) +{ + u8 result[sizeof(oversized_test_utf8_string)]; + ssize_t ret; + + ret =3D wmi_string_to_utf8s(&oversized_test_wmi_string, result, sizeof(re= sult)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, test_utf8_string, sizeof(test_utf8_strin= g)); +} + +static void wmi_string_to_utf8s_invalid_test(struct kunit *test) +{ + u8 result[sizeof(invalid_test_utf8_string)]; + ssize_t ret; + + ret =3D wmi_string_to_utf8s(&invalid_test_wmi_string, result, sizeof(resu= lt)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, test_utf8_string, sizeof(test_utf8_strin= g)); +} + +static void wmi_string_from_utf8s_invalid_test(struct kunit *test) +{ + struct wmi_string *result; + size_t max_chars; + ssize_t ret; + + max_chars =3D (INVALID_TEST_WMI_STRING_LENGTH - sizeof(*result)) / 2; + result =3D kunit_kzalloc(test, INVALID_TEST_WMI_STRING_LENGTH, GFP_KERNEL= ); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_from_utf8s(result, max_chars, invalid_test_utf8_string, + sizeof(invalid_test_utf8_string)); + + KUNIT_EXPECT_EQ(test, ret, -EINVAL); +} + +static struct kunit_case wmi_string_test_cases[] =3D { + KUNIT_CASE_PARAM(wmi_string_to_utf8s_test, wmi_string_gen_params), + KUNIT_CASE_PARAM(wmi_string_from_utf8s_test, wmi_string_gen_params), + KUNIT_CASE(wmi_string_to_utf8s_padded_test), + KUNIT_CASE(wmi_string_from_utf8s_padded_test), + KUNIT_CASE(wmi_string_to_utf8s_oversized_test), + KUNIT_CASE(wmi_string_to_utf8s_invalid_test), + KUNIT_CASE(wmi_string_from_utf8s_invalid_test), + {} +}; + +static struct kunit_suite wmi_string_test_suite =3D { + .name =3D "wmi_string", + .test_cases =3D wmi_string_test_cases, +}; + +kunit_test_suite(wmi_string_test_suite); + +MODULE_AUTHOR("Armin Wolf "); +MODULE_DESCRIPTION("KUnit test for the ACPI-WMI string conversion code"); +MODULE_LICENSE("GPL"); --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3844E33EB0A; Fri, 9 Jan 2026 21:46:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995226; cv=none; b=UbRKuDkNmNE3Gk8huINVbCYqwLUPqI3tDT6uj9wrbzia//pE5o2d9DthrWhKufcby/RLSANzVPAjusH6QhdZHq3aPhLz+1FtYhwgDp64ns8/zJVF/safvq7KbkN7PnYbIkmtAZNUgZNg6mWu7A7/1lSIa0uMM9IpqEPPo9EFpdQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995226; c=relaxed/simple; bh=xQFPf4e4pS/ERkYL/pEVTkOjn8tcKqY6C3zLhawflTg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=gv++DF7Dw1q10d6hUu5WV+fs3UHwXtGznI65UMbY+spoxA6/tnGajyNSmCVtjkyYGd2IJ+pmvjsGWDp+NY11kJW849m/SrG8B+4l956R2vNW+oGlxEaAvFV3M7fe3XaoQp2ChHddW8ZHNM3U0i5t7P6+KPHtaE7EVJYRFf/kkvk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=WN0jQjbs; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="WN0jQjbs" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995211; x=1768600011; i=w_armin@gmx.de; bh=XYhVRH57FDe5woEGMVrFL7y5wNkLwPKSbUKNJXBd9hM=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=WN0jQjbs83hPqOOtr8IeJ3kEBWD3O9SvSn7Ssj2+ssuPoaHIFhhyVdEKoLuef2Ox YMM9RNskriWygF74Yq2wkmzi1WGYCwdG8ZT2rk4W/nqRLqZpdakduI8iYEERqAXuS 7D8ZeAaRYqur1PL8pVd4D2Y5f1/8lXH35sgWWUNXQCegOxsig0+59dj146MLZdFTr 2HJkxIcYqtY9jtb5Qc/e3UT/3vxxY1O6HWvN5hdd24blntRglUbk29hXEcJsc0lLJ AFwNcu0SiHlKBRprMIksyp9K89Sgq7bPa9p21zknxQv6OudrWKeHSBbW4EkYwkH8B y0Di6Q/RkvmZGxqiCg== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MybKp-1w3PBa0bcL-00tf47; Fri, 09 Jan 2026 22:46:47 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 5/9] platform/x86: intel-wmi-sbl-fw-update: Use new buffer-based WMI API Date: Fri, 9 Jan 2026 22:46:15 +0100 Message-Id: <20260109214619.7289-6-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:BJN/dBnHL4OnOvl3/E/zCQe2r1D5+D6Y7gatxXZIAsIqvCA3mtV 8uEawEfok6ANqG1KdgrF5uswia6iNoN3ROzEgsgDLVOmxhEkizj9ZVnZNJq/H/g08P1bs5P zDe1ob4+7f/NXGffvgro26B/bl1XQ87LO17bixSLgsUL/5OJeY0kLMrrcdQx0QiAFLh2dOd esVXP7UxvIa4x9NIN8ftg== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:yn7JqgIxPJM=;DxdAXhmyQ7msAqtZvbNLNbG1ist kxKqKFBXd3MI2w1KPB6UWtU+iRgasA1CULDPOi67JbBdnpfTKtta8VL/RLTmQSQyl+BVPY4xp aSPY0jIZ+YbdKKBzLIXvwUZoRQaaGSZids2x27bodzmbnmDNhWmv7ILGwiKd1loECfMdezWyX rMaZTB8Q80ULJspzghLEzdSk42IYwohJnLNSCGZHJz3x0WDp6rkJKBaBqhW1F6+5PMeA2EZo3 F2FepGci7xYB+AvHC7jLTNvFEENUjkGg9Yb32x4Cn6v82pf8GsM5Z76mO8zTDtsFMRu1foc7a MkiCE/c2sEd6JbnCl0qbtV0RpHw6ozJQFi72u4V52OyGIt0WpaWgmma83U0bePfZC1wCF/nf5 v83Bv8Itess+xkpWTWTQMraRbNCrx29v54eJ7bQuN2Dx6RGlpPTzeQLX7G/doO999c5lxdRWG Yt6Ay8aeZd6ATCV4KjNm4ALDlp7S3OJgsV3lnsltg0SpciuZz4jadhAF6Lat9EdJBIHpJ8tdI dpGi9rjJA96XDd78Q3paFAiIN6ni1XnEXywwp/KH3hHf400gm6ApJ3Y3uc1j/zPgp6EUc72gO Tl/l1LPjgYLEqt2Ehqb1lCYek8lLBcagGFfEQAaJEZZXQ8a3OK1+qOGkkU2rpox/vWiJTUzSX Ug4Zaa+gRHSfQ4Effa4U/yQZPb+W2Pt7Ks9HLLtFDjWwRJJFPTvLToHbG8rI0TeoU9mBeEZuR K2p7o4pjy5H4ch7hb7/9fPb0mrL1sB0zL3rYBWYCKTTwhv7OJL+UM9uQ401lns6DWc45WpWUS yuGWPY2xXOVTvnIGOqW7w1NFL/+J8iGbT0VjdPXTYl078NWm7YUc7hFJZ7nnHGF+ClTi62aaU DMI4yTzSp/bOduAVO8KCh/v9zbO14luOSq3a0XhD+mXKdlD4pxTFs030epx5J874KuTGapk01 xlCT6lP5W0sAwiqIB+EGJ84+fJPjCn6Kj84JvSkLUF/+bzeWf3kLZ1DI0DYx7Q8jEAvn3IEA0 KpL7deYWVuonahWoQE3LZnEFCX5fkVvivhOuk02ilOJlHAyctt1XGex7qnznz7elI59HBoT4i GgP/O7TRmkXpHhev1gVO2n16K7e7ww8xOsTZR4GQNM6I8HYG36C/mGYNoKJz3hl5MInh7x37f r9gixeigZAavwBsM5ojsRPQZaaFujHK7dUY3YVLpRu/IQqQzE1RvPZROgSOK9HddFTqSiZFRT ljLr6ajAoSQ8rMWSVYj7o4YfFolZwAyN73TmmVXWQ2uQDZl77Yc1rCJ/p3v39XKbltCRaoViX W6m7NgH2VFVXj04q5J7E8YBx3vFTyP0Woh/Uq4s5oai0Rb+hFHxSFmfl5PkKCmbxH3YXo8O1K JBiiYPr4T6/Z3bg3uk+P3t1mxkR8ku2H5oP6G8hNNI/jJi9/5ylI3JyBlgiTGC+DmGFrwQ0uY EwoH00aKT6yTvlYi3YIt8XlaCLoO8zEc+ZwgRZ0G5D4GT+mWNY/aNy4nwdgKB8LWh5VZdEqvc VT5bcn6+l8n0ILlxJx5RWkIPr/UMoYACrSBS+nrCh2hvoYApdVguWsspqXCErqO/AX3Cmls9r LyG+r6sDMr1ujGN9KsVIkw3BI2DNvqw+WkqKA3y2rStJ1BuZjXXA67VwNo1d5LAHvf9ejc1L/ tzgoYmFFAHTqdxYsmWkTmx14QtE4XZwe4sxkinFFjmSJIkW795Ftql800u9dcTJJHzCBcPz/l DZ4jfXE9hQ7lXK1lIJb1C43E1A5z+1EQMEuefvqWp/DgaxRzDbjARAFRjsxGT67pxxi4K93tN GL7thUJqmd5UYoTVAnQ5u0LqD+2nQ3CRgV5IogX8zWb83ffprAxdqYqFDyrztpDC/drbvvKvU ZoLIrmJsigJW4pKMf4wOZj0sJCKKeg9EaHBeV5plq1JUuPldedKLVoyRgWwgG3LMQr+1x4n18 9CsBfdhbmtlVkuZGu6BReZnsK+3OidXh9HCjsytTapY+zwsg2woLIHJ5JrgWavccMZ8vMCOw+ CxNdyFhd1LPzoRXXt08OqqveaRiMNqJid74QX1BIiMiz1oD9WWujv0VEBzAdRXFtLLYuj1yPk OxlbBv3p8zMf8A+NYfVJxUrvJUqmyyo1LSUoBGoSzgSPmelFFI8NhH6ZbGjxbYT5hNNsnz8IC zJNiAntDv2yUeXwW6qSqxxaNh7tybOp0GX44qjY1zM79O2beJZdXunnItPEuWBZnbF0PifxKf DkUO0JMK0GbFPotxypPksU1/XnIQnxuotykt2SpGcGe03VcSu8TXMxCEeQ34Nv9N3KUq1YX1V 2RZ5lCy5UXOYnrdXm8ywkuZh41NjYPLoVTSSB09LnsXo0Ai0mjE7RONKT9hEb+0dJzO4NdZ8W 2mH1+WOG2snChO2HOdjKkPFQ8CZNHno4UiENDXSpthXxwrtCwmWOquW2kyofmFRmDPEFxk7cE lm6DHAMGkUroVgpRwkifw3AXNwYA5f9U0hN+maoJn9s3Oypcmd2D0tdL472cHQICFYl+/wBG1 lRVXBb7RVdCTGHQbj85/SIdFmusNIPgFUzfgHCz+PYz9hvzHoIucCJ6Dyz3uPEyrHngA1PA7W sn/KVTYDFcS81OTNvXmFLvy/i4ZrGjBoHSLxzkUmjAzdg4HQlXj08B0xGQ+DQ6Q1EF17jU0rQ pZoUOsoWc2O8ENxvgZf+1CkTOg+RIDW9e/YclWOFfkykTSNiO9BKywVRsnTlBlj+LeYaDYL8n /vpBM7LA3AfMlixSbUZ24MxtInJG2MOg+ZjHucV7PT0k2tdz8ghq6YldFEQkFTqodOdzgDi9P fkAorZ9wDtQTxheuUhv7Tf/9rq/Of2IoizYOc0v4pAincurq36zqt5jpVMg3uMiNwGUyzOIL+ nwOTSzt/0EAZPGcgopBqSxn5Y05pH0yYJBmsxuj3/sA//yJFVSg3zEZxjqxfbxaahr9Q1HO+j JPDm4tqdsboqVIhtykcMXjYAS8DJeFt+NG5xX2ptpF32tmsZZTfekrcPLMD8FqHzBa0K2s6dB /zv4d7aLtDp7FxyLJBYqFm5MJhjjb8mdfYAGsQqjhrr8wsINBVsPjD08iwKaiXu+GTB8xrvDg 66tLFiyldFpGVMujndkLuN0iu9rSX3ULFEBNA/tVHxBBJfu3Rg3WI7oQMy+KqNA4OpIjVBHot tlT8XX3l5a3l8F98tpy/3eYyBviY6LMJo3QtttrBEZmsM1BVHEO7ktqjFuBlxeu2tQcTvO5nk PtbXYfcw7kRmkPrnkbeo0ukUNCsjBPCL4CLypjGf4/GHXuXdcdJi/MeiYgDST69po2MVybqZZ bCtpTUrzg6nHJkv5N6AY/VD5tOIWUan3gp7PruMabsFLfmL5CAhIE3lKdaGSoRy0pqH4MkLbW rCvRMEZAqxckyym5xMUrkvJhZYBNjnwomrUoEY2JavPB29PUvUJhAipiDrRPiiACFNSMGaG6L 25sTesuYVXlG+3EnhAUI9XuvdurnZgi+yyZTQsfUAI1krWQMozyqnFg1I+aepaui+n06lSnlv JTrdi/pLnmKoQLAf89+dz9dpKTj2oPW0aF2PW3tvkZppcS8KqW8SOTPBJ+XXwHHIQPEnj9q+M fTQsFLwzhk8OWOvVYo+2G0eQTdD0rAjKV+SP5SnxbhmQ1Ob1vRyLOEdFhyVmPckfoGGC2lFtO aByKbWM/ZQIxSe1SzD0g6hcUd5g6HawKAACNwZzWvSMRfjO8XqRDRnVJ21Bfq5FKqQghoU5G4 yaf5S0nw6ZrFs4VoeBALeG5q7S0qqTW82J9oBh6SaOHC+W/G/6maF9UYEmd6CogdsxUtmgUkj NKLPTQGTG2terBSWvAVx0IOLldkzmIM0+I/IlMUDuKBJGvQud94hiYguQkaF8S/hEt1Xn1sSh OHr4v5EOsudqZ3PlVwJ258FgsnsFkoEVhYUgPMeSUUZfe2SEm3PNIqrIAeQIqw+nK5ssZ1mPB VaYGdvDawgHX/grZ5IiZEZgnVY2qT9LbBuxN0BHRX50Ef0MyG7etIvTVqUXmye2Ef0xgMyl3r 5L4Md8bm2PhHXKEsUxY+Z6DcCMgeo/zB6iSquBl1FDB+qrNJoRrwhsG/ztfxPhQaO5WaZ1iRE ESkUJDTXo2J8Shmt89iAhCCnF3dK3cZ+Aqer2auMXE2N3O6E2wCxOBHebHlNLeQuy25vjOafQ iGqKfs= Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to also support ACPI firmware implementations that return a ACPI buffer instead of a ACPI integer. Signed-off-by: Armin Wolf --- .../platform/x86/intel/wmi/sbl-fw-update.c | 43 ++++++++----------- 1 file changed, 18 insertions(+), 25 deletions(-) diff --git a/drivers/platform/x86/intel/wmi/sbl-fw-update.c b/drivers/platf= orm/x86/intel/wmi/sbl-fw-update.c index 75c82c08117f..3716ccaaed6a 100644 --- a/drivers/platform/x86/intel/wmi/sbl-fw-update.c +++ b/drivers/platform/x86/intel/wmi/sbl-fw-update.c @@ -14,7 +14,6 @@ * https://slimbootloader.github.io/security/firmware-update.html */ =20 -#include #include #include #include @@ -25,41 +24,35 @@ =20 static int get_fwu_request(struct device *dev, u32 *out) { - union acpi_object *obj; + struct wmi_buffer buffer; + __le32 *result; + int ret; =20 - obj =3D wmidev_block_query(to_wmi_device(dev), 0); - if (!obj) - return -ENODEV; + ret =3D wmidev_query_block(to_wmi_device(dev), 0, &buffer); + if (ret < 0) + return ret; =20 - if (obj->type !=3D ACPI_TYPE_INTEGER) { - dev_warn(dev, "wmidev_block_query returned invalid value\n"); - kfree(obj); - return -EINVAL; + if (buffer.length < sizeof(*result)) { + kfree(buffer.data); + return -ENODATA; } =20 - *out =3D obj->integer.value; - kfree(obj); + result =3D buffer.data; + *out =3D le32_to_cpu(*result); + kfree(result); =20 return 0; } =20 static int set_fwu_request(struct device *dev, u32 in) { - struct acpi_buffer input; - acpi_status status; - u32 value; - - value =3D in; - input.length =3D sizeof(u32); - input.pointer =3D &value; - - status =3D wmidev_block_set(to_wmi_device(dev), 0, &input); - if (ACPI_FAILURE(status)) { - dev_err(dev, "wmidev_block_set failed\n"); - return -ENODEV; - } + __le32 value =3D cpu_to_le32(in); + struct wmi_buffer buffer =3D { + .length =3D sizeof(value), + .data =3D &value, + }; =20 - return 0; + return wmidev_set_block(to_wmi_device(dev), 0, &buffer); } =20 static ssize_t firmware_update_request_show(struct device *dev, --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C3CC02DC346; Fri, 9 Jan 2026 21:47:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995226; cv=none; b=fa9mPFqh/gijuaTAoadaDtyJSwnCLdzhgFrM6IrdIl0c/2NfpVltUQd8SyT5G3ylovCKTo0Ckmm+RvjcT3LZk28wDP+US4GiapiTH5JSYb9PcK3yJaPL9G5UjjXZajl+0qdx8aytc6Ap0AofALVNNcS+KhE1HWM7R5GB2fACZpY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995226; c=relaxed/simple; bh=TvDAHqOndFQ+sdZIj1OoGw4fU13kcnFTYjuqXVcz0M0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=YoeSE9dwbCC1KFSb1TvqlWces8DtjpocgjCvmg98/2MNaP8iRlLTrT9HmXV/yFDtC+XGir8OWOdkgVEZVlNrX1ZmSwSWwCO8qo/O8MXFfAaP93PB1f5cxNd0p7bOtOyjzrdoaJy1zE56Cy9d67aPCwVmUj+3tWjwQAPXxoHO8c0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=IQnEZidX; arc=none smtp.client-ip=212.227.15.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="IQnEZidX" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995209; x=1768600009; i=w_armin@gmx.de; bh=7qlUiAsQVud9Gn3ClRs8IiSZLr9lSLU4BHxB9Zp6gLM=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=IQnEZidXQr1o3nlpFG0MTiyLS9X+YF1d6EJ+mhsTYg28VI/UOBsHw3rd6SXDjKGg pSZiVGMcbZ8pXFuwfM5Z1vlywdYhKOgwgoEVxs8lZ3ll/N0QIB0R7fMt0NMkHdb7I 6evO0Vvgrf3F00Cc1sMB3Yz078ge/pJJR+zK7ROsenEMtJjffOdHOd+ABcQDiCjEe 54srdG7BJKuQYZS61tUPRsueQuCoMto0JRt5nqCTaBo9661BGLBu7KW+VewFn8XLx egQ2/rVVREETC0JSS0+ch9HSJDkSir0emwDo1roHhNev81yUodCfPTgsbH7KxxTdu 5v2ba0urJLwbIw/Y3A== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1N3bWr-1vnQt81dYJ-015BXy; Fri, 09 Jan 2026 22:46:49 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 6/9] platform/x86/intel/wmi: thunderbolt: Use new buffer-based WMI API Date: Fri, 9 Jan 2026 22:46:16 +0100 Message-Id: <20260109214619.7289-7-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:MOW2W0LBYDaCCleLS9sEk3+Kn8Z5KazgxsewoMhQ1h+DFsIayuV tjAQn4Qzyr/AejhkcqCNhJA7kcrwJ04UHoc9wgcVlYS68lSCIDRt3JWkubUgI7ZoPm2cPl3 hJ+s7FD4VQxGx8MYGZu943a5KjGMJM4xGHJiYAgnEfkM6LulzaUbfUzhVOwu5QYkeUPeez2 BHRyWrbngZBNagpOuIiBA== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:/iSSIR+59No=;TXG8DMDYclg9CB997NPgAEmEUxS Up8QwKpFEVjU9XW51Ul1IcANBs5ODZiYim8+aBd7GvySgXj3E1SdDpJw8IY2+HPjG3k0pKqEP oyB0ICvEdhA+Yu8SYTNQIswAi8UncF09MDumAmVyxUU22NX/kTpUet70zu44BFwkHZjmfSvCT WxPi2APd7+gjWC5PHc5h1vT4P20GK05EPpz2x4FufJnhJBs+kRTgt624vRvln9tF4C83TsX/s 50j3f2eb6a6ijJUGbnPv0u5br6QPxskbwEDfvWf3J2IVi3whGJUMV3TmJtjs52Zh/LWMYsD1e qANvXXQWVy+EBEOqIlFc0riEnLYceAMWVlyuQPzr7jg9wv+ttYgWL7AQmHbwD8lP2NQSpTXyq eh4XZ9sc5YPRTRNmiglA0dW0GtSaMEHIwfNNxVGtE2fnHLJjLsNYEALvEJ/C9aL0J43MMDY6h rmOi5r7N2p8b9QVONlajdkajqmazW1frcdVy6siHCvQ5TrZZeizYlyajFCqxAR4wwqKq5qaay 8jmtpb1Nb3GP2W+K3kMrnzE3vH6DSe/ZyjkMN1pfoNpfJbdfOBh7Qvgr2+2kwqGkTXFNECeek zXYtfVE+EggWrjMPhq7VAb9v8c4MsMENftLEe2v+sfcwUANT15Ghproy/bXpAz6pqcSxMVRgd 3eWrJY5N0RxyyM2ADUmX/psYnaADyJjEKibCoM4JOOIwxAi4kM7Uj9V/8cFyhK5eIccCP4/HA Cdkzs7wHBPGY6dpYfrmoRJRiWpWJ1DAsRDiLiohMeE51cdJgs4TtVq0rQe3HP2bnKc3giQPly CiMJtm8II4BbGBtmezPuBqucej6hwsNdRjmsRLetQ2DstUBzATRv2CjEHPXVnhPE6S4jafiuK mJF6eAoUp+yolkrbyBVaIYv8HNagVIDVPF6ldrnRLVRAW4KVRruOrCbQX3IgivN9HscMEOZim V2sqGLVbJmjYSFrdAu12hnEeVHoa0/fbwwZDdM2vDvI9MTAPdEHzRY49QI5AaacVL7YxioVZ6 refgNLlNrf+bHTgkGL7039R9ZOskHHhF+qQFzBPt3kc9/QQJPfiUOOMK23/yamgHRvJlnlw6f breVk/2xNvrCxFyB9OljhKIn2zVBSXhlVAZtnheS5shhVAinSeL4Hg5i0624Gof8tlCIxBZ9l zJf3sduJQsMg9cDYc9ZfHg8LmES9N+HGfu9tG5o+FqaSFuvNUUjDYBbbre/TNUv30qZstfg4/ 3aDGle4OTDSzP+xIF5bIm91a24iMYtxU0weZmdKJE9bwwPs/VAv3TNQ4Uxr7QNCIMJYFWimql GJhchjcFvR4Ajz4LrvFq41AyKLcWjDJ0SaYxFdqEVVkpy5u3Q1Drkxb6n33U18blY1CnnFw/w 8pGuidHxS/LaVv+cAQMqKjrIOZ0Gcy2W5nRdDeWPYdkJK/FKVVPQSbP048iRm+fFjPA6AMBhr OD+GWZHraF7GAIrcE9XxI6xukOSaZAdRRH8E8MwxyVHw18C77Yv3B1D+T1QmV+DhzOxhyz1pf oikA+qffP9SUWPyL7V1bf8HmDEV1f+nG5+6cTCu9iOvk9EERJcAKnI0WGpmHDRhT1+Jns8wQ0 Gn43y818S84tZkK1Yaoh9Od6E0bCYM+Kgzrvtw6t5/ki29GVj+ZQkAW26ny/gAKvTilmTgFZ8 KNRdDJhm8IGk26UqnPyRNxs/FJmoNvoLbVqUWD0Msa49xTVt4k/wIE9SWIsZQ/gUS5c6Y0AQb kv9WCOxQbB9HBGnbKGAqUq8cbXhNBBrV3bKKSJSOeIh3gIUjxVkI5/SDY2v2xQyVNTQ+LuMkR L8vizQdLReJLEQaZL0ycq+debooMC6PeoVyo+lrOXkV9sKtpHpNNqEXpgOKipDC6SadgIrYdS ZdaSc7RtvF9LSasC/epCvd8PT4RQsRl5zmfmFuIFnZrxXqsLOkHZVs+UP8NCGkMhaRTLv/xWc 0MMpNMpgD9mKevtVTKybJGFsWOCblArmWuEK5gaRtQQSFoE/EoAnkdPKVSQC0g8osVXNddE6Q DKN63Gph7VP+Wd3y0W6bQyXdbVb6022a5HJdWiq4hp6q8Q8BsroQ3XHi+S1QOrKfUJIkaeFGO RcyMqAI/whp+fMvM4r5awgPs/JgrbX6152vwEqsbYBroTerT9Uzes33wHo0thCfQ2PgguF8Tp TlhN1/u1yQDNyN7ha59HbYGQT2vGXQbLL8vAApX9X+dKa5OKOxIxvl/FFSvuo9Pzh7q4idin1 M1B1u5gw4MsdZkxu9hQgBIkqbxsRPHlqARsCisfhUGzmKKGyX0q0A5k6+mdm8QCxXYHmZyxCA CRsWTHNqwcH66bn9jQu/Bxm3bAggYV/2IrHLpNR77UpdRC1au5j/DlcEcwiT40C8hw9MX9VlA loEMce7Nl0wepb/++GyK2DcHhecTo7Z4ivSyBr4TVQO/flU7/G3r4L7YXY1aDUIarTjOWzAFJ p67zJ8BeXRCzbFPrHdhdoxXTfFP/eVaMa3TgmXNLsxYMUoUL1P0DSSumGo/Zn7oCs5gk7ABBt HDyRi/dMarbRdQrjsRU3EbTEqpmLlXdBrhWBZ+rbYOaqSTV8H+e/VjUkuHk0n7J4soxRr5x21 LN65qjsCG5LONIH9JSeHLK3fyhyeFgZFtkjKU5MFRl8Nj1YjIXnP2LM30Ir/7tlKwOMUKXD6q wPQjYkM2Om6Yt1jOUahiY0PH+41Eu5A4VMkhuwAAEOzAqmGbKKCKuoYhyZa75CEVl4XDNAEMl ZsMKQ4RKjx7IQAMCuw6YQ+BknHwM6p1uCLFtv9vOJTO8Ct3c06FeFNN3EUolIKzAycgZ+5C6Q SvV8isgSJD7ST7lgIIphvbJ6KWsKHybDPzPS5lMf1k1qMaG64Fp8rJFlgByf06Q19xp6hkywi isS/JEJQA44GHuFAguIBsTw/CAVMkUqMR4uU0R8K8kL9DWMChszybz7O3twwvKwdxzzNfrGZ3 1PazHbeM/xj3/OQ0SjImsrIBb6BYRQUSaxdURBwX1HvpkDEfn5QMYw820vjCP2Nk/10A8NJr2 LME2Wov50tgknxpZKTXaDBkfuxaJvzngOHmKIrnkXosaXi4ls2u6Qh0iT6IDaoXdJhzNnHRwa XKfJxYgM3AIVIjYRqfJH2EyhYqjvHkBrniYFJnj4sCk6VLDZ/x6LC4ixI8eUvjxr6jK/bEYs6 9nVbKFoj5FRmUlLV7vI/eqHhFwOJHbueugILm3wNbcd2ip2CCPpSc8k1LOzET/9MV2PU3UgsR xAMxJnbQq6oS+NVp890XgnESbbVHx/JTQ1jWWErDWX4X2ceRLxfPOQGqix8TPpM8ME6ioJwJj evD9r4PJcm5dD/Ki9MhFpPEezXjZHQJw5M8NJTgAroHyRatDBGg73QKtwTt/dbw9GVunW9rzw G/lciVK+PxR6LDJVQopu6WBJYu2iKgrIa2CREGXTaOFb3f0KjFP0Awd6HSNtStNdZ3wQ4GTd2 2HCyIQuCdI7PuT2sHJRiNrPedbe9NBd48F3MdNSMYufagVZsWOV45N9TtePQku/9AJB+KHzik GnulZhNwVVvRBr4wxWSB14RPN6fZ2J6DzoaqUm2jidpsg5rqC2Orndkno0zEfu4H6Qnyh7JFB GilHRlhfsqDvBPornJh0CaCLqcIfyyaBQEaQN6l3OjDR1HFOI9hx7bls2I+tJYVFgYdOL4XU+ EgI3EBCTcqJG0a+gFCvUVtmKhN7LU5RxVfMvGymQSmbZB/wMIp4+Hwfn55k+kxJj2kjTP0zMg GoitoZIINEhd2fikJ0dD5eU3fagj6Yp0WeNu+A3IXLmv34dUHneyNB/j5Xx3MZNNGaRmgbr+Q UdB5/BS3u5lJTFya0cksSZXVtH6SxPCsR4IOKXES/X90F70rX5MZKc03LimN3b0m5sYWksYHC UB73MtExRspPA6/hkiqHCgZWX0EoGmJJCW5qqvPf4i3KI4JdFwiELcQtdvSQaj4EJ6Y3Kb77q qZ3HCKD7j59IHLCExouZeKZLSEDqCswRvqVMYVy5s7sF/fcfwvi/guwKqc3hN9ycwe3SWDnKZ 3JhRszfct8bH8v5l6EJABOQ55wHSz5oXxssXoRpV9EKlJzgn0RsoIIfeXnQYeni/jwve9uqRe mEH8Qn+vvfq6NAI4TC6mC2+Nq2B5xajkdAtpMDjjzyIBNxqL+Ar6T5z/GJFmI1sXZHbbqUiEK u5/7Wj9yCXjgdIO5zyaQKR7gaInH30pSPjKSja34ezZ3eT1U1KRr1Rky8OvTdqD4gImQulqP3 LkVkuQbZJvGmCcZesLxHCjuMlx4o9+A3d2VhrZzFc1r7eCllSOsYTHqSn26jYx1OggjW3GDDo P0GKTsfa2mJAsliiaDVfFTE4jKETzKCkhgP6irjNHqnpd8m+Hc66osfRkLxqWcprZNnXA7ojx ZStyhx6oK9nClsWk7+2+C3zLI6jHj1mHq0XNF+lNG0LZ8IbOr9kcNusHHSfvVHP5kXXZ3v4qO 2/DEtMgxFf5uVogdq42vghx+LA7LIhnkNy0xhv+2wa38wFZnZ+pZh29mW0QhwpBJbKjAqs1WH YbuxYIp2XfPHGQDUPPayu2j1mqXoiuzqs9PUcWKKbRunwS4jXjDHt78+F4jV+7x+qqzwT5kCp rxn6MaEE8qE/1Bq9xC+vMeszAfPjW0U08+I8/ZTLiFgnkM4K4RHz7L3s+AGJuk2akpGEKOVFA AUQTmoab/kdnPtSNOPvDNVfPd59TgcGT9gHmXVCVbju9xPykx7SSf1QOu9Ttnux9/9Bn1TBuv 8sWXQ/cDaWBa/OqJuYqNUnPl/bJ/pozQ09UEH2G9NiDK4Xorr3s29IW5K2GgV3g2ir8vd2G+Y DPznZ5wRF+7AXwrRjlTGs6+q+XSTI1zPFW5KH+N6DKgY/fLUCQ3C4WLCLHa3o2DgMnXWtqGyB C5Xr0IBpMV/FbUBk0ctbM0PRvcepJpHc92+AykqyCSY1i2TmyQ4m2aXRW0hJ9cm/GTn7MoryX wE6eQEUyW07HDbdeZimSlsPeAnadv83dQWq4Rs4U3N62pz1VQpcWbInu5z3VwNVuTx422aUcK sAKMU+2fTYShKbiJXt3zWuT/auuvLLGhvPqsgDOWUcL7Q+Dz53OOim8h/OSuxIO/X7R6zEC+b B1C5a987JcZ8L+sNPBjUhdwKOJGOq59MJ+pkRgLgsvea9se8R5ZJsmDlurr0hnhIA44OMPTG6 zd6Pi9xYP7ZQmM+zNH9FeUHjoCDx8 Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to avoid having to deal with ACPI at all. Signed-off-by: Armin Wolf --- drivers/platform/x86/intel/wmi/thunderbolt.c | 26 +++++++++----------- 1 file changed, 11 insertions(+), 15 deletions(-) diff --git a/drivers/platform/x86/intel/wmi/thunderbolt.c b/drivers/platfor= m/x86/intel/wmi/thunderbolt.c index 08df560a2c7a..f01dd096c689 100644 --- a/drivers/platform/x86/intel/wmi/thunderbolt.c +++ b/drivers/platform/x86/intel/wmi/thunderbolt.c @@ -7,7 +7,6 @@ =20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt =20 -#include #include #include #include @@ -23,24 +22,21 @@ static ssize_t force_power_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { - struct acpi_buffer input; - acpi_status status; + struct wmi_buffer buffer; + int ret; u8 mode; =20 - input.length =3D sizeof(u8); - input.pointer =3D &mode; + buffer.length =3D sizeof(mode); + buffer.data =3D &mode; + mode =3D hex_to_bin(buf[0]); - dev_dbg(dev, "force_power: storing %#x\n", mode); - if (mode =3D=3D 0 || mode =3D=3D 1) { - status =3D wmidev_evaluate_method(to_wmi_device(dev), 0, 1, &input, NULL= ); - if (ACPI_FAILURE(status)) { - dev_dbg(dev, "force_power: failed to evaluate ACPI method\n"); - return -ENODEV; - } - } else { - dev_dbg(dev, "force_power: unsupported mode\n"); + if (mode > 1) return -EINVAL; - } + + ret =3D wmidev_invoke_method(to_wmi_device(dev), 0, 1, &buffer, NULL); + if (ret < 0) + return ret; + return count; } =20 --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A514E1A3029; Fri, 9 Jan 2026 21:47:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995226; cv=none; b=am2k0QO9ZdEBhkQ4DzsWt/+qWDPogd7QobntnrHfw3f4MuY8Y0f1IBG9PchTBlYqY4oWRbqReW/TSd8NJr6hyC5JTa+ylP4lNw93EXsVvq989ivM+i1DfA3mrwDwWbuCcmREooDn1VVQ7ov+6NjVzjFhpbez8V4RdQd/CoWfF2I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995226; c=relaxed/simple; bh=TJgLzTksdV6FW6f/rYwBBRpRBJulZLasWdVu8QXIRik=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=no7ws6GOhDVwq+JA5BLurb/jTsUrQsBNh1i5h5NRyHRz08M1mbl3JCEhD/S7JgKRJbnPc9fK4WfUzci+c+z/E6qmMUk88HZz9GL7WLOdi9nKBYKT3SPCch49Dz19D0FoT7p4JkIn7MC8sNDAruuXBD8OAveo4UjdyTCtrIeMd1c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=FVNdyhKv; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="FVNdyhKv" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995212; x=1768600012; i=w_armin@gmx.de; bh=my3Bwy9Nqnm5Ql6505L7xx+AOmSQ2MHcXjgLv2xvJRI=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=FVNdyhKvd20QVD4ubQttWzb8QZXEx7sf4QwVgIJXkpPTfGreVpS6Ma9TwB++UXq2 aamBZup0XTMRlKu/vcV1/tvaPVZuHC6RRZgMuUyvInhKCxCX/IWuVgBqFjoXmJstB RuowJBtfy/NJuKIzicpRwMjAp+UEHwrpvdJ4a47XvpnUnTTgwTIj4HTvtS0WXcWnV JP9WqFZtfgPWopAGjBMdC7HPje4yGn+IifeEMyBeBBC11Dmfq+1ddNUNpoO1WEAwi TsEtfEUzfiJgpkJqFsHDEwqjCfkNCAc2yO2a0gQ5qeWkD16h8v8MOyuQ4loCPNhZL mAtSFGSlhSnJNrE4pA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MrhQ6-1wAJ6F3AZg-00ip3O; Fri, 09 Jan 2026 22:46:52 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 7/9] platform/x86: xiaomi-wmi: Use new buffer-based WMI API Date: Fri, 9 Jan 2026 22:46:17 +0100 Message-Id: <20260109214619.7289-8-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:xJQk9S1wX/ArNO54dcNnROKXFl1/WMVM5OE8fzQoWzdwLb3Pj8U HAVEbyg6Uk9WhhZWgIO2hPF0IDWX/p0sg+Y6RkUQdSM7rYL/wlZo38GzrosuZQ07sGROx92 NPTG/19T5OR+2J2RD6+bMQq+fl/Bc9oqlt7qIaCjK086fVMftLtexeNpLcb6iuaRGzKbXhm kwlWp1p47TkiJV4XmfFVQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:TBAb6aKPTyk=;JAP+ezpn8LNWoUuYJIgnbpO/dLb vwXRxa7xGqkna7h4xWBmIZRSJ8zP9Yh9T4vFDPRvA9MpMnuNpk6XjXreroGPWNb9Ezc4QhFr2 kCTDDCYVVJn1MGW1B1YfECZXxjODX1t9V9HppsFlW+8q973uyQmc2VXp/argv2D1HXs6pVt+T GaEkBxDTYrRn2ts/5WlIVQI/EbKwwSdlISBu8qpxt6wuYRfsDZvBO6nHIFdIudE76jkLqDQg0 3cCrNkQEHyY24wMP9WmZPUTjIkqZFFTE2+vU2cBm/tgxexlD5/llweB075pr/dpmlh9JI9hCO YrT296hx7b2XIfeQu4NwrNm1O7ogdudf0J1O5E4SJ1hBxtroMcWJm3GGmQjgM24iM1F374KuI B1GZUjKJurxpD0zJaHEU5rcWJncoc9PS3tlAslI3vpsAbLc1E3/7L+CVF3PAibOZDOzZSF0BE 0WJkEpK3SDktJxRIa4ptPKRgz7pVLshULxi4Ig3EzXTQ3VyqjF8CT11VgYOFE3jICq3qkU+eo +AbuRVcYFhFZqSbHY6MA6anDeShQo8KXthTHCItZF4FUhvj4K8XasK00q+MAsd/3yXrU+4BBh 0mRmPL7gXV+lnqUOezt/OFzrjjado0r1cMC6l4ltTxwZTDBQPweySvZkkd8i83flf4V3Xtn+y pNAVeq3N77F8nmJaeVbFupywS3PB6T6fnqxAOz9cVHYGtk907vLssTu0MWWVUD4izz6Ce2N3L rbUpbdiVcx90+gGpMbXj0fouObuRC6usEnN7StrB0pBxinhE/q2Z9nNjqZtB9RxPjRvhmrU99 yE+5/QZVUiVVSpNXqitsqNtzJ0kV2efQnzXlTXuX7Xnkn74XJWw0HVY2h2Y80nJa4yVqWz1+L v/MJdLVdSKlNzm2pmwppVmemRbIVS3da0bdU9+AUE1esE/n+0I9cSVXvIpnOjwYqhLinycjZm 0xlKPmRd7y5zv9Sq8IidghzX0YkDe98NxdpmnDQfY7wwfYFyPVReEgHVNnvKzGrK+JWQTbWfK 4K5uYT0RcCkqAgRd2edGaTffAC0LRLhU3WrMCYHHz0nC+2GDYeFy1jXtnTQcyzPN/Eee+DxMs Wx8hKeZpj71b/6IiDqyqHf+y0iDCrIfpVpCwsERXyqQzNgnXoUwKYcPTH9L3zhJZWTLZPgG3G hD0/AHuQtRmO5wQilML83UxvKaRGqGJQRhLPLAhcwUA4dc4m5L6PR6iw+6Msq1FIPi4sHfxOc GcW2Mcq+MLKq5xyeKVTHVT8qRc+KLWItk+0MBQH+65gGjQOfyJWzDQzhUZzBG02w+BlUPj3gY s+qDkouJtI7jnCbacm7lkWtG8PhjGr/9aYrRYVTtGFzRV8GbYxAS/UPH2+IivY7jjcaIG5zM/ YU6zCJnByFCaUfVCD7kBmpWjPQq03cITKZuvWne0L9smHmiMr1fSIcxafaBsU/fY5f0sNtfrl GNvYL9pok6J4GR9YLnMK7JKfGCRykSeCPrxNNDjgte3F55Fpt+IL/mas3pPtqAV1D+t5EYovZ BX+ykpm6mA3EaIgliY/aqr+2LeVFFR5UUcbrgcUvC4RF0dtmNwKMMLHQH7Up+5R4ISU2M0d/H tIt958aOYWt0eg9srTNH8Qq05A9Zfuka2EYFjMyg0HJtkGx5xOjKoLZDAXu480Fwrl/f7LST0 V0VtALJAtBDrP1hQy1SzGmZxzvOkJhnN9UfPXsXLyB7o7exJOxICAY9UgkTi2se+dIq2IGDhY 7YnmwS8wjUvljjxyvmAY1LedNB46W6WWAA45yic2rZIogkH1skFywYYusSv1y6V1sTiCG1SFp wzlmfrSQ8L6dyunTGvAW1nN+74gsSBnD/7ka7BTMKZ5Dh8dar9E4TaYjUorik6LCHRh1rrRUd PSSeXalEKm4Wkp2aWNh6FkgV8f99pvEQZtpyLDkfNzlxMqmDdEAt7efudO7QAuzi0WbUTkrss rS3/kvrcQ2Zf66eM+AC3BvnXMkkMq7Uff5LMYCkWzVRFu+Qu8MN2vDJW9E+T2YJ7aUkbfFd0o 06r2M45uf6gWaNSzf528lzVnvpT1dKWwEzHuF6TM3HEdu93fcn+mRDNAgFJzHfUMuKmPR2k0i 0Avh7sD8UzGHOFg8RASOiR1ZnYIGqyyd0+EjSi408jv8j+yNBMQlfCwyb550QQwCWnlPkkHjL 8EjYQahnpAgODYz+bnnIDr3v3h80N+HorlGcvu2dbdixg4M6J4yXJ1GKiAiRhv2RLIBQ3XkCj onRkGo2ccGq76N/BkRvhfR5denntsEHjb1tT56GbE6sdH5t8/Q42Z1Lc8bRLjt6nMfSe3BcQ8 w8l9bi6rUvFCOsrD790/sMgzFI/K8E2qovqwUuSZ2t82iSwkgVxQcspf/zD1tfXWSzfNQn1Ga LGnDZBM8WFUrcgT1i0NE4qYLO6qWZfmyazAtqUamb+C2flGArXUf4sea/muqpxnFytuP2QiAw GcVA3qb6bD8M+F1RSUreCs6aljwoiCaMImltpxyluFNxVIU7BjrayA+WBU2NjPb33Fap7VsKb 7uMv3O39GDlfmRr4Lsc1zHuh6NRX/J53WWXTDTbQQFggYXXZ8El5GA3xN7Emvl2PGk1cfue9I sDFJ/rICu1mqNZgwUqSWMq6vVPR4K2SBkEYnXZJdm3rvWRC5znxyr00eKLLaHjnf4P9EvTco/ j0ZNUh/zfUEbk6s9FP3xjOVA0tWIkmCtUMyruY4Vmvx70ZfHPDJzVIX6EAaRYNNsVl433mjpR bjLPHhcVDeB9zQ5oILVYakQSHDKmOavCzZS6KRrAM806m7cQxH/93+WjftnWD02eysu8SEmXc GxFFuxxb5Aj3V8uIQGHxeRU7IbCQlEeB2z/C1fqkHq4HnhSjLdQ94ZzDwp0EzBZ3O1xDmBlIQ PtDHj04Z428/V26mDOkFor1ww2LbtkpgZ5kAUUheswSOjkTAR9S8E+Wxv8TM95MEQbV9Ody4y OuJWFX3cU4oWRQq2I35c58yU5PUUvqC01s66lcASOT9bl+isQ0IchsDVKxKXcyx07Mcn1xhLY +ckyCVXFGYH38XJh9MyGgLGN1rximxwDDNaRAa/tUQk8lmgVjN9wi0ljOxaezPs3mVTaiY/mL DrriShH+NW4JNLJwhRI/TQyyiNgraMTKm/Q3XkO012ribDye2wTSj1o9Y1F8AgzFjj95cpTwV UAhKEwF+GsdZYfuYXyV9c41ItMeQQy6TbchLrdRDhf5/AVPSAuqY+M8aYaT+EipeBJ4x6O360 AhXSQt4QgjVDn/MRdo7+QGJCYpqQK7usMvqWB/c/mDpLNSvY8DrA2niKsaO1xRpFxnl3XgjCY LvZD+vZ4j4RgPMN3NQmXbOlZlCkz2TtMENSq9XqTSHExVIULOUUlRVpTZHvNwtbgdSqD2n/QR MzwRyHXQyVHJuK8ece1Mh21QIkZrJH3sh8sjmgTHOWbJ/cqjVc2gO3BMKvc2MewzY0y2gTpVD 6I8ibio9bnL7ELP1bYOgh8LGlE+nSmHde2EG0JQ6H8AD3Z6npVttycp50/Z3zTA9qaBt25WRA 8X4SMlvgWw6jZrExB9eCZJkBCqyTT6F6+qLLCa5c4X2Pc3/eOcpdQPkvCLgFxPgfkdEs3ve8D M+psf/ahIy+PnQh1/qqn5hBJeG7T9sq+7rZ7MzIgKxo6vs9cCsGe2LXg8opbqCFyWgEgjFHcG Ba639kpb3/JlVp8MRBZnCbaxTYfRxFPbKg1HYaK/puGge/Q42YvFYMnHAgU4moYN/rkrCaV9b 9rWz2lsXUkRfdG8Ofw5LQLd8folhPuXidL7utzJ7dbo1S0hyskmO1XTjbsZ3wOcHht1az7qbA +qkyBoAU37e1oCjQoXVieSkVCe8z/NwH7tRq6d3U6sW5dvEuA1DOn8fVspcjw7djNai7atK3H e/bQXvsYLRFuPVNy39Hrx40nyUKZdD36ozVgQyo+8WOiyW4iE6inSOy09vl4Yl1jI0XVrM2Qz /Fa+mIxSc8LXxDLnxz9ar7JGbrcrGBcrzS/HE1zCb7ZgeVjQrokx1Hkke7CkpbJ1ny0z4x98t L9guFUJetL96r0JWDNpPl1A8NTteTi5+NiheVivzgx1LxJwIGyftK6p88HEaoLUK7WzjEhDba kmi51jzf+TC9uAIOtoJfZ7A7PxosUYgp1P58OYlRgCpFhjgBZMfCFD5jFWXw8sAEAkjaWlO+5 UZoCLLdTCyC794fGX3fVIwuIVI08bJMG7kzesCGsqQQ2zLpamvDyDlD+ehN2i5jeCy7h8MmaV MRWavAkgdevlFoTzCJNDg+NC2IS59c3+lRajtyxfAd/KN8se0fh3kiKDSS4VbBtXlLqs3a6ZG 3dQd79wCaWvdZsPsSI+Orek27XNAbpwPxSZ4mBqnCPfGLlk8B9slo91f45XJ0BooumK4rLrUC FLVbtOdFvtmHEfVSWsOblHZpAucAHx908g4xWbQ5FdJxfcFI7x4fdYJblcizd7FQECElYrBau dW5jGdYiI74I5dn+mmExOtTEUN4nHt0GrDD4lmJJqqzQlfgZavnLn/uPFvX49vL2EyIzEp/ex Nxr2ZzLiGDS5+MeJgP7mazr5YE3gZhlhb1IlKYuvbPo6TJfr0IV9uZdI1tlKq2sY5NMn19P3v bI9QRvqWuQtv10YX2w8kXqKXgRne2DRXuAxBxUE0XZzIwPLyb+zb4+Z35m5Zf+ZXuFZfY7wF2 JOO2VcdlefOlHvhFpkEKSEw3uiOYc2kdcXOmWnaztG12Z9bEmVdvhD8C4wAVqVsRbRqcMhO5z Lf8CyBRsxQ9arP0oTUErJOOo/dgGKbuBAux7O60n+gzk3+0d3QSddb30XLAantux3lqKtjynp GXrVdrcJQSgRVE8fMVqyy1BJ1hzrsFf9FtSBbN7V7RGLCeDnbFWr3cs9ZDDgwO1cD3JPz4eQX Bu47I6efaZJWWw4IHNjz5fQHEy7zQz24QRub5rzD3wc002Mox9RlqIKBdz9SVd+/XQfaeIRvi Qt4TgxCCMH+da6bcFU49DHCx9YuBHSHp8bgD8nczMWbAaDwvCn+uOGI0paWb4dJe5e6ylsLmZ ZGm4YqweL4kGpLliwmNpu2tLVrDin+GdJj61xzX6RnfATRYP/XaCiDG+ug2Kfy7gr9VoRVo0k pIAvA7kvbK3PebdbJFymJN5WJHEFkjpMFbNisMUyIEQUr8vZMghmDL75Dqj1tkQZCXXPwQjBc veFG3KrkEajSczbv31QLBD28YI7ww Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to avoid having to deal with ACPI at all. Signed-off-by: Armin Wolf --- drivers/platform/x86/xiaomi-wmi.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/drivers/platform/x86/xiaomi-wmi.c b/drivers/platform/x86/xiaom= i-wmi.c index b892007b9863..badf9e42e015 100644 --- a/drivers/platform/x86/xiaomi-wmi.c +++ b/drivers/platform/x86/xiaomi-wmi.c @@ -1,7 +1,6 @@ // SPDX-License-Identifier: GPL-2.0 /* WMI driver for Xiaomi Laptops */ =20 -#include #include #include #include @@ -56,7 +55,7 @@ static int xiaomi_wmi_probe(struct wmi_device *wdev, cons= t void *context) return input_register_device(data->input_dev); } =20 -static void xiaomi_wmi_notify(struct wmi_device *wdev, union acpi_object *= dummy) +static void xiaomi_wmi_notify(struct wmi_device *wdev, const struct wmi_bu= ffer *dummy) { struct xiaomi_wmi *data =3D dev_get_drvdata(&wdev->dev); =20 @@ -85,7 +84,7 @@ static struct wmi_driver xiaomi_wmi_driver =3D { }, .id_table =3D xiaomi_wmi_id_table, .probe =3D xiaomi_wmi_probe, - .notify =3D xiaomi_wmi_notify, + .notify_new =3D xiaomi_wmi_notify, .no_singleton =3D true, }; module_wmi_driver(xiaomi_wmi_driver); --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 14EC333EAE9; Fri, 9 Jan 2026 21:46:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995227; cv=none; b=o+fciSrVCfGSPPPK7OCgJ729Z39cC86o+rW1Rp0EHEg1OXSb/ui3OR9VR7dpAPaj2G4YRjQDCdmWCHTDQojb7xBO/1+ORRYFMOAYqOJv7s3Si8frCDxBlBuo2XewNhDBJropRzXGAqnyFxXz4ZOKahRoMM8yz9jQj885ws5DJpg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995227; c=relaxed/simple; bh=O8IGx/qdPLgHwXwdToL4OtW7b6tvLndNcTwk+PuIHqM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Qla/kLC8+bvk8Oph1tiu1G3t5cKSWTqPmj7hLSba0DJN2+5oWvvDwPU4JkJ2fZ3H82fHvF5+eCiVjNC/KWv93X0MKFiG8E54SaXMfud6KoRvCDvGGfgr1UziysMvg385nIjAdc02335KzgXYvt9VFCyWy5XxzkPCFWt49d9CZcw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=DBd8pv8o; arc=none smtp.client-ip=212.227.15.18 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="DBd8pv8o" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995214; x=1768600014; i=w_armin@gmx.de; bh=FjbEbbK7ftoEL6GHoK2TTMmVOSXJ0BAlCyi8mVntI9c=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=DBd8pv8oWooainOCtUhASTNX0QRvLP2JnXNdOyQgYDlsixVAa29TLUfMJGpj5ccT rLWrCUTEQwA4D4QMKPt2VI1HIyc2zG+PHzz4iJ2bLmEsAXuflPgitSVVEw7mqk8hn vYGIzHpOICpEmUJpcJQEUMbdJczQZf7kkgD6RFUktihJ6ctIH8ZiUAa+XZ+O0hkGz qsLXfec0pSic9/KMJhwjeMYpfWnBwlxZuPcZq2bbydXpPbgT8L69abahU8XUKQ6Bm leMz6zJ6PxibrJHodbs3ZjcnMSlXyCAjqeE1BJFRoWslKPdLHqzFFY4AhrcisoQA0 FwFJOhMJzs5mBstLSw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1M5fIW-1vlSvX2yDK-003l8z; Fri, 09 Jan 2026 22:46:53 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 8/9] platform/x86: wmi-bmof: Use new buffer-based WMI API Date: Fri, 9 Jan 2026 22:46:18 +0100 Message-Id: <20260109214619.7289-9-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:F0wlaMqxB0v5zxJR6uG4LHUx/yuxToxiJn2bnGZ0dx+YPM1yKHW G/ayJ1ZEh6UUebfoLoOsTf5Cv4kydQTXTv1x1la3CS8Iw/KXuIYtZ1ngMP8Pd/fBTxDU4oo RMTFeFui31upTYjB2SmpJWIUf63Og4pvaVva5i10OE3Y7cUrDGaMRpp5zE5JX/FEjfeihms JzvKI18WEYUp7vhaAidHw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:phvMPZrApMg=;CH8Ol2J8JF0rGA0HxLXQY1jNhqG N9TT55Zx2rVzLIiBj+OPaWIe+UJHPSvpIczGGweJdD2VWOkyD2nWXjKg4ydCtkz3YGRckWq3I lFcZwZJ/J3Ro+yZLta8yjdn711X0URNxLhZgp3C3DzNqcaxs2yoXi0H4mvTCIt9QyknWxeqFW uH9TFlIX4vTV+dRA30bpxX2Sqj2JwsetCh8kpS/y7olnOJxF5cPDOTkImbq8HWWnb36WcplDj eJWJr0N//iicw/TIWwlEhgvrLVtjqU0Ndi7fVi30HRFjssh2Rf4h4j6/I2AsJHI8CjXWXSlbO 4Z7SDxBb1Z/mjoQROAVm/al5Vh+kwlv5R0F9w7ahnklelnCa7meGUg0GQXPpgAMsVstbBKvLt jBPRQHiQ0GZ+S1c3sAGwQP1lAd20Ck/SvARSD75duqeGBnfk+ZZIGprzXuI4t8mFW8vLf6YxZ fOLG6GaGmwSL5vjqWojn2XxH0YqX2iKfAx2i21RzpUEKHzjD+mhjqqRjpuUQZH4ev8KksV3Qk PJ6YryPijj48+qVmjeYVLcjscUZzzMdcDS9PA2aeypSJnWJ9wQXNfd1Hl9e2lxj98iC1FSXcg YO3LTfRuciaJ5IIjV6xYVi8GDZ9fqg8WlgSPmH5WoFcQTHlsOtVb8bQ23vcKIDhXam6mGiiem SKO+BkujHeS/8QvFDzeu1lwLplqXMyZteXo8a0pdqBMLLeUiqhl3IewkQ7l3Kpe10Ge9SyELG rV+NXo2tUJYvATaYLBkheeYkf+oqrmMWuD6giOCW+uIP4XyzNCA8HlvJFAorRDhO4Z7vKYySQ GU6Pz3FqGoqU4W2KtJiIWk1HbnQjiNfljIh2w4U7oeRFr8tA+dy2QrTKysa2NjF7839l4RKpr Jy7G5KrgVX3tV5LH40cOnd8yaBDciWpV86nCtskhgi4TZzloipoyqVBEaRgEWonK80nZaVBMz t/mwiLH0Q15SfLhK1Gc/MHstj4y/5Px5OQQbTyEg4J0+x2YHhpm0BvxdPjqwU/MY8KrSbmTzh rP1GqEkdCsUqK7dG0LXTvRb5eJSup9y++500JReYwz09sqAqGpZKRs4agUqydO3PLl4Lm2LhK SCSgeVLZwIGuU1Mni4zmjV6beyEDQi8euMcLTVBQ2CaEecERuLbba0anrIhtdj+Wb3U+np1Qq B0AJ2Nff7V7rDpcBViPy8rBRaGbedLGeStMn4qiTm9nUk0n3Bq1Um5odqxkK7KqzwKO2Zy0wP t4yYT89Z7m4/HVpV1l0Rkiqk4ex83GCC94rJmLrTXM8zTjlFJpl/vFp492+xv1EFfJw3zngAW kNAfiXVGOnFsPtqszJB0plcXVdf/vhU2WeSWJgaENCaJmnRAw4oe8h8wVNJKalU64aULZSRwD 5OFzPYiwJWniWQ7/Xm+VSO7aowwayW59mKMysi2n8tixlM2+8NdDx5v6atdOaa80leAoAnonF cYIVQhqjDo4eQXDJ7Hf9XRR3u6sxk/t/mZWtMn/o4ZSncORfMPshc1hp9iAa9QBx8jTiPVRJL Qz1xWCh7Wch9KidALNIp/Nc+OHV+EbeM3aqI0ZXT0C/FH2C5ZJBv2hbBNqcG8rTqyQ5YWMPyz OJmPuz2AawvphiavDK2dKJWX6NXXP5gfSKRlhunGihFhGSNEL7rVF3M+DLKhUor2DDBjOrEBZ W1pMTCgwUGz3q9cdprjHCiZDuuGLjv0q07SILpJDaZict8GU7Phhn2iBbbbtnrWG5UiOqTlyn ZH2vOdz/HndIlL1KPsqiywxM3ww2Imq8HDncDmOfR6vvoery3BXEbZIGA42WnnYwW45AqviKf YJrCwx6e/VN9N96/V/GantPUKz5fIBNMdCf0nlpKw2OhIWy3/ycRRRfMWYtotuwK+LWOAJnCM EBPEg7cB3OCp3OMEkkD7KvKvGdiUJ23577msSSbZf/c94+iXMDewCKR6p+ML+Db3twFw87q/W NYwxI0DiMBX4oo40HdRdMtPktN7Uzyr54+RYxZ7t4eg4/fL5r2gEKHdYUcWRRQyyQ0jGou/uM 4HrRRfz+o3h2BE0QvbR4BqwxMsfz9zcPsMhp0keuFMllh1U3/aqm8JQF6gum43hRSsfidzaZP iDPh9bCNX3t8SC5goODgxP0x2z2auNAlI2fj6+ytDlUKcjvEKBqy/81YIfg+JPAMAzs5v2mWM 434/HCPFWoWjtMXY00XQy4lLde/h9/Bw/iylaMfNzouEb/3wKjoYisk7pJU7fDpsaxrgChV7/ HBc+d+ksR3U7WTRMc900Valvc5npq8RQOgBuIALzFswP1WbTYp7s4hRLnfDdlKlIMyPovkb6T wgXFEVtj+qfFtMDi5Ru48wLRR9dnsxp5DS//XWYfdlZ3JrXwzm0s1PV5LFmQ3fiWH2jvPVwLL mnGMkyyAacstH5inJk4LGUUj1xegvZPS7MbCPfhtqNKfMECXPHYDR9eZZyBTFbUFna5XuwpqC uZw2mXibTygMuifkfyA6QBSDLiircdbyOBpcDpaFboD/PkpqBVXfYbLeEL65pI8XpHJhaamFH hSDn6ASsif2h0AcBhgH/hJN2MNMKobDedgzruNoj7+X6ZC1mvaaTGOoolBxSFXsHo4A+mota7 SAE+s7D+hrHGlfaXRGCawy/utjHqTZtHXmXQDsShaSyXJizcjT01ZCDTwSkX6EqodlRzGo6zb ob8W6rv1FWXfXAKaCXijC4GDx25BQjbhfbTyENNBVdDBHjiT16mUmlCM1RE4Oq1Lo/T7QGOex X+Rjj6FPEDIqAZgWD+QBa8RV+utkvtKpE2pwFtP1RhI0pb3J/aex1PGvFIjvssh5Sj06RQDw7 RJnw2eyaUWEeFjgl7VrqJZNX+mc/LH/QBBn/4T5UzniQNP0lZ7575NEDM5dLKEr+YIvwyVrdx fL4tS705jdNbAQQJGTR0qP7qDAMSVY3/UnC7kS0CfzHEeOrqpHgf5shaxS5W3F1ZuNsDoDGli BGKw097+ikzNwCz5K64G0/LypYZn9Vu3UiUKP0OUy0kWqR/rQTN/VEDhy+5GS85Ke0CUVk1M5 9Jyp3CX2GMYnjYpYR8GTDSaqYwXPxi6TRTqPjgzJuzTHOmm7iLBv/Ed/6yTai5TE7ODhDV7Jv hvSmbiH9Pi/3toyvVdSCBMenhRtLah6W0PXISlAsM64jZRS4Y7zwSLjfrkD8612VR4r6stoh+ ATScuBEDDSaq9yywuWWEBFZTA64yh3T32w+mGsGgBePQ9kKqjGoIO9gZ4wnkDj3aSQIa+rmPw 7/Krr+pkw/MHah2xsmiohnYwIh1b9TYMTgcocBbwJsqlu8eKU1FLnTI/7ZMWu/obD7mc278gM 7ktPMioYabNmQOOPH7pENC7xA8XSq1uYVuUhsSQG9pNXVoBVa0qranD4ifiUQsnHviBNVD2OX PvFTFyn57sehSr8H4YCmc0ufcxM4tLkzoPOu9Ik0ObpydxRMFLrIsrNg1SmZ/gYAxmmdmWIYr KKRr8p1iEzQZ3Pshb2kJuKdJ8I4Z0YoqbRTqLPRjwUkXiFHeyASVO+HH8F3j9qQxKyj8PsU3X UHaFcSsuETpYNXkfqaQOTOWMPrWKQRfPz1NVtJ2Jof0MtE7wSbqtwR0Ru80ynTdawipRIHjpG M/41qZOKSHs50CcGkq8z+nCbyHNZDoOH2qxP30KemgSzpNwx697uwrxFrHUv4IST+KZ4+ebLt aCXWBvAI6WtjKFcvmzRVaGucj7qpd9Oa73+YKGnG3BYDxjxO9YTj8zD+9H9pnO3O3zQ9djNLn 1LnSt/X/pzaScgA725uJWs2pNpcyU6Zz5Ozdc35AM+xRGHuPd0Mt56Lvd+wwbumQH8XtnyzNf Fkp0RSNGmKXKDgfwHGKsFGqWddvAIVCnXmEkXqj9jnoXmp+9jeg7bDOGIjDZkgi0e27q3lpLd /TU3cUnkY8/bGTGyQAHjC+o66iswbfkzbAbc6AceSctfPQCwCV7d0DJJ3LsyuJblk/TfiiAk/ mzP18ejkzI9hIw1u1pfiMBQv2nj5zbpii8ZvjNPxUVX6xTL2L1ws1V5jC8d8vCFkN+UAoa7+t PZPoEBabFOxpPCNV9xxtOolJQSsd8Z5CQWm0TqC7w5ELKFlsEB+xuA5KWx2VrH2oM4/hAD/xp JCXPCMD0vGbyEiGJyDB160tOjKAivXAgCwfCjCSajN+H7PYerHfrF1v//LjlR4+oH9+w7AQid knq2SrLuuO6G1lL4lk2UQz4nlHUxv/YYzHSZaWQQofgwIsJqNvZ2CFWmCT7RZ3T1lHfOoCLFm jwzHvG6fELjcYQjRsrpeIYL0WJRN/ijNOGLAxjLDY4VVQWhMj7BOs4/wzRYWqLwd8LWFKOb3g UirlIGjZ41pKk9N7BeAi6KCRtVJFaIxMmKVNAaEsRIalbWUgJPDMyxfH2/mV0SfQXIzAUAwKt GJllkoHILi0l2b6s50ZNVgKXJX91syGNQQmd/S1wo4FnGUb7drhY6S7fx9MgPZCxjvcZV/M7U 4M95i3szoEw0EFdT/e6L1qaMVygcvN+0/z+QyTbikVP0GbiLgM3MexPCc2sM6zC7y36VUfqlK O2A1PLx0gbF0ztNlNuk+f0WQ6nijMBGejZlM9wPlI44SVXuZTDlEpj+WFGHeZcqeqrzt5sXeF 3yrRHJ4ys9KuoC0c8B8OEDPGE/pp8xSZtOff2U18N9/5ckK+x+lIE5NDgcU9PIT5WtXb6ct8L mnV5GQsqFf8J2+1pwN5e1VoyX23/HnRkUT0CpyWXoiicqGEKItzlQ4jubaDL6DSs3f8xyzBgw 0FhYzlE11xdXJtIy8IDD2Vjy7pezWbuba5YTOOoWj8yc8LrOLhJUMQCltQ5+yHEm6u3qafdSz fp15BSzWEvL3LwMfx+pqVAEKY/q34MJtR409cVsn5jar+ruEz1vymjBjmoVox4g9jjlO5CuXB E8t41n/w9j+k5E0DgvQkrI2UWPtkwgUO4GBHotVowXZxus/1dFfkUmMjgQVDV+pp3+8PAcgc0 ZpFDRE4/CWIiQH4ITG/fhKnYNbWi+JQTiANhvb3Ias3HV8PpqzJsP4bdgkLEn1+EJOFnToJ8G RE/eF4ORQ8ULoexTDrAbCLta9sJ5cT8nrJxBwxZ9jTbLks8Bw8VWzKaY8TJnLqY1P1qGBGG/3 W8gtpoD2gAyY4C38TQh2BCxGD2fNvmNWIENVlr0pVV9497r0NE/RJxtwrkvUDD/bGCpuqAOgs 1C7Fhh1fC9JjukCRv/QzJ7KjLdwkwwvIjmlar0MP3UTviKVwKug== Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to also support ACPI firmware implementations that do not use ACPI buffers to return the BMOF data. Signed-off-by: Armin Wolf --- drivers/platform/x86/wmi-bmof.c | 34 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/drivers/platform/x86/wmi-bmof.c b/drivers/platform/x86/wmi-bmo= f.c index 5b00370a9a22..e3a126de421b 100644 --- a/drivers/platform/x86/wmi-bmof.c +++ b/drivers/platform/x86/wmi-bmof.c @@ -8,7 +8,6 @@ =20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt =20 -#include #include #include #include @@ -24,9 +23,9 @@ static ssize_t bmof_read(struct file *filp, struct kobjec= t *kobj, const struct b char *buf, loff_t off, size_t count) { struct device *dev =3D kobj_to_dev(kobj); - union acpi_object *obj =3D dev_get_drvdata(dev); + struct wmi_buffer *buffer =3D dev_get_drvdata(dev); =20 - return memory_read_from_buffer(buf, count, &off, obj->buffer.pointer, obj= ->buffer.length); + return memory_read_from_buffer(buf, count, &off, buffer->data, buffer->le= ngth); } =20 static const BIN_ATTR_ADMIN_RO(bmof, 0); @@ -39,9 +38,9 @@ static const struct bin_attribute * const bmof_attrs[] = =3D { static size_t bmof_bin_size(struct kobject *kobj, const struct bin_attribu= te *attr, int n) { struct device *dev =3D kobj_to_dev(kobj); - union acpi_object *obj =3D dev_get_drvdata(dev); + struct wmi_buffer *buffer =3D dev_get_drvdata(dev); =20 - return obj->buffer.length; + return buffer->length; } =20 static const struct attribute_group bmof_group =3D { @@ -56,30 +55,27 @@ static const struct attribute_group *bmof_groups[] =3D { =20 static int wmi_bmof_probe(struct wmi_device *wdev, const void *context) { - union acpi_object *obj; + struct wmi_buffer *buffer; + int ret; =20 - obj =3D wmidev_block_query(wdev, 0); - if (!obj) { - dev_err(&wdev->dev, "failed to read Binary MOF\n"); - return -EIO; - } + buffer =3D devm_kzalloc(&wdev->dev, sizeof(*buffer), GFP_KERNEL); + if (!buffer) + return -ENOMEM; =20 - if (obj->type !=3D ACPI_TYPE_BUFFER) { - dev_err(&wdev->dev, "Binary MOF is not a buffer\n"); - kfree(obj); - return -EIO; - } + ret =3D wmidev_query_block(wdev, 0, buffer); + if (ret < 0) + return ret; =20 - dev_set_drvdata(&wdev->dev, obj); + dev_set_drvdata(&wdev->dev, buffer); =20 return 0; } =20 static void wmi_bmof_remove(struct wmi_device *wdev) { - union acpi_object *obj =3D dev_get_drvdata(&wdev->dev); + struct wmi_buffer *buffer =3D dev_get_drvdata(&wdev->dev); =20 - kfree(obj); + kfree(buffer->data); } =20 static const struct wmi_device_id wmi_bmof_id_table[] =3D { --=20 2.39.5 From nobody Sun Feb 8 17:03:55 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6765833EB0B; Fri, 9 Jan 2026 21:47:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995234; cv=none; b=DZLigNuu3CQQaQV2ihMjRmxDSC0ZOp8H4jjsSONYqrw8SKYSAaLmnqNp2wEVZmlF/yE1tPuSIQBeUeP800f78XFUGsjVLK9TKE1vEXyZqYZQNgvTHCzJCFRN+CLzmVtlGujxoCsSEOc9Pwlrnt71/eLfbrZVgIvbisPfwkDuAFg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767995234; c=relaxed/simple; bh=8MWKvLKrIhwESL6K2lYU1hcXZLjKr62HLpiR+lptuBw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=gsFZ5kPD9tnjBgyY6JsjWABnVRfXgcEpMZgnkqYyBR0TVeZWupAPmaXuw4rSHakGghtgigteDIzQh+arsFRSDwvpdf5E5xXLzfju32rPYCZMMsLdlycbNXJes1+EjmO0JzVobCv4k5tVXhv61XteESyj6SJCsYnrxFlikQW3m40= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de; spf=pass smtp.mailfrom=gmx.de; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b=l+KpN+Ii; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="l+KpN+Ii" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1767995216; x=1768600016; i=w_armin@gmx.de; bh=WUXnniPV7qpv2Ba8+v4zPdnBdenui6dm7evYQTvUE04=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=l+KpN+Ii8IlLP5/WTpvWBmAGsQuqdtxch7ioy6JZwaxjFw94XFXQeSXtNFEuwDwU jQthJN3IZ9YwTxJuD+XGGIHYCUC3mlOSyyubKIpwXjdAnsUC6GwgxXbe2bMs2hHB8 50SAT+N0lVlYEdQpa3k83bGgDu5TE1rtEUcVizTHZWyJBjaUr03tvC9zmhudoVz+S U9sg2Wx1gV4/rFMhGrLzA6M7iSt3DFaxd8CAKMOUejPl1ovfFHuPg8CaHPGq19jiJ XSeSbYVDF1OdPJ76YvGCyVEGQIrXg8X5mZ4tImPSxCtJIQWts7HeVnHNVUMagSqC2 0/9OFsMOiw2vxz2VJA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MhD2O-1wIap33zNa-00acFO; Fri, 09 Jan 2026 22:46:56 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v3 9/9] platform/wmi: Update driver development guide Date: Fri, 9 Jan 2026 22:46:19 +0100 Message-Id: <20260109214619.7289-10-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260109214619.7289-1-W_Armin@gmx.de> References: <20260109214619.7289-1-W_Armin@gmx.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:AdfT4ZPeZwpJTel+dKwH+rXSZSKFIbQBTUMN/PBXO+qIa4moNIh BBdXiQGPPF3UWlKpIW1HQpmr5WL30QJxijHcRUrKhihzjd2zLuB/Wd3eYkcU1pq1689qfil at+JEa6MWbcI7lN5UxYImi530AvO2Cd6rIqixoz8j+2a2K6wjO2S+AlB24BCntlcgdpRgBX SN5No4cPOU713t2crGTGg== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:q97V7ShoVhA=;l+hv2T/G3DTXJoYX7vFf8XLjtJy VumLJQdjQilq/AFKOc37VnOjTrjcS6aSE16JZPxxKMnp+7CYDrH0Wf9OuiNFqOv+kLepYCZbP 42EHOog9RaNilPqpMdiSVqAnlWBbnF54ZADcFCcTmFKel3T8Nyd3hmNLsN9DecLLj6QQP8H6T HUppP6ZtBBAf9eoeqszZ2UQCnK4gdRwEi5/STmz17+bkWit2szmrjcYC9zwfhnrNETTdXY9nH 7j4STNsa93vSu/H5JVbAMnN+m+fVtUNixUQgqC+PjfoFu19+jzj54b+qp5/hMpk0UC1NHpOiF 0tXPfxUhK3XX9kue7XYRqkicFeMnEMhSQrxCbxTqyIyrEQREs2sujvEi4Q/0B5usZjEUXoR3S rUPMUH1yzamvCbpmMbNdv5yDmX5hGwj5zCVx5U+E+oo5N1CL1N4BJ0j2PiaTxpRByIHBDc3nH B1+LT4uLL0A+6FjE8OeFjmaQZOuujlrEveWJ07OKb0B8MvRRG5uEQIBKgJuva7fmlqWRB72FF EZhKWqHyOHzDQ/m7zlVIj1fDFhdjT06FNIjMf3eDWkj/jX92pG0k2rLOukNuc8X/Q85Pin7Eo Z469CPv00iKNMYewdvdC3t+G3j9NfEhCTBpOYw50pO5UXv6nudUcIKAms/SoGtkzRvKcD66dv tgeJFHBj7uqwYsHS+6I8mv9FPhqvhJ0xwNqdT88elxRxb2+sgUnYUsoE7TvIvH25q6WIFpnbx fLUAp41pkExmV442LowWaZsEwcH57dtKxa9TYMydl9d6E83hYIWqt6Zlhi3eoI5LM5ZRUoIP7 tyGb2UVMtDBauURv3OEFKNwsEnzoSdP6bKhDeo6nbPtJx8xXbAgMwUONAc/jNKmE1Ks83v8p2 KkCk2IqDxqvwRvEfZGtXzDhO7DzL3nPT7EnBovS0zMA5cyYUZKYPknsKQ/RiIR8fyQXf/pbKc Y9N+rMo8NWerl3+mu15bwkEWVCxENWp/dJZd9Isgz75+JQ1C1R0mIDM7LtacAUCaRCPhxXSEJ EtHECmvhzIpVqNbrfCRr3Vn+qbGx3uwxj1vll6C3Wn2HWBAlZqeNgn4dKd5bse4j3zF+3mXbp r+4MFmUbvy61Ff3d4hutaMEWsri3qJa5ChkthEg9rgkCXeW4Jpxow/5iz450bk+kBPbLlTEvR N871nlXt1ku63wgv7MELBE9DtS4Z+NzbJlCIQN9n9cSjdbBSTGkbbM5J0sQwj2gNCniu7jnr6 zVuO2esoDk1Z0QA+Q1zfupLwz7tW8tmjZwHzHV3uUXNDGd5ufyqrmgkNgI1Kw+cjws3iJ4sXN DflSiI57q35rryLTqg0sE1aONc3wQtI+X/XtVfDdejjK3abrgcZ7uO6OLNS5YemBG93UFP/yJ ADugqbD55X8y459OQtxDf44dzx2l6DU2uxaYaRbzbeuhwnz4puZ/WmPRU6TMcJPaU8kWDzE+q 02RgaD7KIoXaj65aSepXbkHKKw1qrkIc8W3ACil0tNMA8OVG7nUIwP5ayMP0XsuqzAAbUnVB8 bIw4G/wN9u4KE06EEbY6x54bo8LF4JpY2apF31R3tdgQdFiG27rcKlIFIUoVye52z3N6H7/tw v9+YfXtjMhVB+ICsmWLS7nc4y8DZoBKcUJAdQ4z360++2rjPPePvwNxLgB81pGXQ8AdgHpygH KoCh4x13cIobvxVF4y7q6pNmYFuTe9769b9RqrFNUZ79CNXcdM07s4VND9/DmdYsXvyDF7mzi uwQEbudfHrJhqUb4DpV6XbbwYC+6M9puTG083JNbUO3jz3d5DI3TBjOo483PXiG7RkpzIi7WY x3YRH93t/EPrOuzl4StKxgfwiUDCeXMg7SqWK3wL1LzGSF+q9sFQTPVlxreHvG/GlJGvXFxFU ZcdrYttjOoe+pIfVs/32LU2fCZsUu9rwB6hM/FUYnNDyUksaRaEaHTUvLqdXFBbSVHlkLo6p7 SulKkl55XHFsfi5s4qz1ESsl22etthT4y3trINnpiZpkgaJxYq4btaDGHu22a9scvsxvwi9kL qkwQmCViBnJTTpDz8ZiYZpV98xiWm3a2fZa2NGyKZzM1Fvqr7gZr4ZzRVa3YOnYl/trA1mFhV tPlWPNKdqt1xLARD4EaBQ0lBiSWuZu6ngNcJ41a60huFy3HYyeUQsUdhDRrx0H0wdU30LHYw4 JA6jojagfGnUKX/hVhfOw0/de33l/sTEtEFPMDhrb/yVGOyC4gHTYXTy9FV6+TbGlawsPSmWu y3ElYurepUSna0bumoLVZ09UnBadDnNVAxODW1y15LEwPcycc8qfs73qb7SoNJspIzsVE4+A5 RnZTn4EHzKLAOTSuPLSKdJnXjofkKrvtki+b9PVOQ9BwIrpUti8tlS5YX7g1+gBtCOal41vgP kxzEFAx+sgxvM9RPUAthQ4MIHLbReaAiTugxF2MusqJxZTz/fyqnbjI+PxVsavsAUam+0PaAS swFVp0lkWJ6XS0hRFa6+KmivnPsfMEWFt5NE86wyS0rMCVN3DRxdPq4cLaulCV8aovdoKn/I6 RuG/OPQT/StjMV0AgCqtECdA4+1kKTPu81tea8CURMNffQi+yG4IeuqOH9KlRi2obZ18mOtZ2 7ylOThqRVIuYERhQxuXGxq/R0w80j04gAN9F72vj9bhS8dMzp7cJ9P1GZ4c6o9BRWUrgGiUsF Lelko7O/9Ebq83zw8CVgSH7/6dwDRFIgRPpUT3k86GoRJnER0y9jUVwHvquiuIl7SY7DI/w2r DOR/7tHPd+QoK2a966i9NA/rn8YeB8wVoGWQxgtF5WbWgUhuPPeVe0lCaZnx5PGseBB9XyRgQ /fgM6VhBv8ErfPzkj8LI0XIrY20d5h/kVl8yHRWigdYtFm5lV0OwtB3geB2iGq0VHavee/7hZ 6E8HkIOmpBI68wDP1K77aPQi8QMjiPHyNjIWrpTnU/MEjxT4eFVC12UEh9dPbXlJLEhIqQKJl dpmXLZh6BdhK8JP+nI9l2xyiBq1okFeuzST7yAMGfP2mz8xUnwm57Z8daOYAsfutZH3XBCWPU G1W/zX7YfAH4NOIlQxuWaJirWRY8XYpTVO9gwu/b8BIodbEUSLyzyqqk441+7G6wZyGOU4hnZ yxz8X0NkiLfQ49bIwxgtfhcOB80Ak177LD0On7QTEciWwEBHky3Msyhhqp+Le68v5pibMipWu rgwfeuJDUgypq07UBNDvRI4QR82jlvsE4rZmuVTlhHBi7FRr7w81gz+kHvlW9yKC9c3YkLhnP lS6CxJ20gschfOsNUkg2NAONj7yxU7E6OG67ZX+yJBAUR/lsrqQJQn/1z0S5d2jTr0nUa45Oh Evtn3k7wwwP3JcbBA03DXAFzWOr3KJ1yFLZ2WHrE5dHDNfVJEQ68SXT/QrkBYX/zoAQ6D2WWJ fwR+Dw5PR6HPl+JPJXLOE/LgKISUb0W//hx3PfeSGtyzPYAyj41ZqaMRNJ8mpvK6OCxv0V/lj PxysE1dib3fGVGXg6quXami65lKtcCfzGInnLS2c0im9oJ3Zc2rlz8sJeHDm1JviWavC6hr9W +62vFY4/IZ2dOm1rrdipNLeFicyROXQcj+iHudTf7yDeB2qDURiFdEBzc/7dl8Z9/8tCW79Kb RQ8Jwydh6bFpw6C/X6VoXpDcTYh7CAkUOOhR3UYvWv1MWRTfqqY5fVlQu9TnoJCmOZHINLrX8 ooTBSziqFbrr646pOMriFMnCsdwIE6mFWgzpjWVTFnBm+2OL+rzASLfIZoKQgiUWZKrm7UypT a3sPm22DW8N5T2/kvzgWJUkgq/bt1ePyTEpHR8SiqHtkKZAhE5aIRJp5Pe3vvom6QOiwn4Ceo PwMe4CFZ4npXNHNphgR3RO7ulK6Q2B4QGqk+ZXJ9ZkrLIyN6uxd4YCJoGo0WMw4OLPveNGGpg tPsMdTTWvQ+ZKQj38GwB0/DTcRriMbQDbVhP7PFPPYD6jkssLEL4eRJ3JPO8J/k6zPoTxSy59 CaKE7qOB1iQIHlME78wBdqfZbtVkTuiwIcJ+SX0RN7Rk9Hz96P7Lj89e2RgwMJcZTVc8rEcgg hsqA9P1KQ7mbfFF8HX4ArsgsvSBoewIPV6XnTF+mZfHT1ug5tHfQ8Kj/3AaNBthWehyK+5GWD BjvShoH8jc88BNWp7O8ZWKb11/rZMVxtaOrW8A9aCv+oxAP+MWPOpzx7klU3nzqpdV48QZgn2 kesVjjKL77Bf1GvCOhafmFD0FG8VPN4CvsWHnn25jeaIUaD+7aQLWAIyrO3za6B7yIzhoptxy ldTzb3ZOsM6gXYG3SXFVI/oMA+IVOtfZU9o8Ynadq6SVqXlDxYyuhbKKpiDHhReHV5KvJh1Fd o+ygzVMvLORIx+vhZu1+zrDsY9raeXKMl0nBykNTCahpQ7Z7TsNi07cz7378Eqnu2/eOTccrh +j7Gr2IX96RtckNV+w0Csl+guLmMzVPnZFXJMCf+iWgRifnQOwqhaPzkkS4DlOhZi1AMfVFKC 211FYhoMkq+AzcAIFEEsr8gsOikSDmx5oPwYu8czMQMnsUk84IKoL6oa258jUUfLA4eoE0nPi /+WxPcufgLh43+rtV9XxyPfcJKGVCQ3PBC3IcJpgHXfb6OhA14c/jr1NtBlturL7MD5tT5cmC RTFCGcj5f9ni38eALfaoDbJ0AoPadQmRZvgFVkIbQP+CxdWWvpXInm6MWiIRjE/PzEGoiScw+ HOKKlvvfxt7+TKvlawVXOHCiI2BM0ZtVB3VXuccPso4B5Q8HeqbJEyMtzeMVc0pt/mMOC9pJT CytWeWU63MBV7R38mLEtZIpaXC2S7wthETs6ytOLDt7+TMaGZ8UYtOqZ9hjEN82qcQeCdwfsv BRT7cuVcIWui3b8ZgrDDUJl/UsB5b3Qjek85zOOAMHyIzPSxW07Fm0TkDgPuLDdBXeA+AD+8s R+xKB3Sya7WOJ3X2D1ybN0K28iqykv6TiCTPj7ieB9GuZpi/i82w137szlyUyCTLtHtE1cTgq 6Ss9O2FN1hgcRVUgBJ+IrR3d+z0ksv+PDSDuyS4WyMlUJelqMFQpjrFV0RCgQGkXJVN4hMhcR Y3TslKrE+1LJlBDBk+75pF/k1mpkyMn2iaPCZ8PzybgebmmFD1kiegHFZObpRalKwUYLbJA1W jZ8N9aMWyIA/9RdV0bXvjUmIvTwHDfV9TVjeMkD1aO+cm/ycyUaJmwrnasjVIovZcs4KjTIj7 NX/jltNxTqy3hmmzk2wrr63iuVfnR Content-Type: text/plain; charset="utf-8" New WMI drivers should use the new buffer-based WMI API instead of the deprecated ACPI-based API. Update the driver development guide to recommend the buffer-based API to driver developers and explain the purpose of struct wmi_buffer. Also update the ACPI interface documentation to describe the conversion rules for converting ACPI objects into WMI buffers. Reviewed-by: Randy Dunlap Signed-off-by: Armin Wolf --- Documentation/wmi/acpi-interface.rst | 68 +++++++++++++++++ .../wmi/driver-development-guide.rst | 76 +++++++++++++------ 2 files changed, 121 insertions(+), 23 deletions(-) diff --git a/Documentation/wmi/acpi-interface.rst b/Documentation/wmi/acpi-= interface.rst index 1ef003b033bf..4657101c528a 100644 --- a/Documentation/wmi/acpi-interface.rst +++ b/Documentation/wmi/acpi-interface.rst @@ -104,3 +104,71 @@ holding the notification ID of the event. This method = should be evaluated every time an ACPI notification is received, since some ACPI implementations use= a queue to store WMI event data items. This queue will overflow after a coup= le of WMI events are received without retrieving the associated WMI event dat= a. + +Conversion rules for ACPI data types +------------------------------------ + +Consumers of the ACPI-WMI interface use binary buffers to exchange data wi= th the WMI driver core, +with the internal structure of the buffer being only know to the consumers= . The WMI driver core is +thus responsible for converting the data inside the buffer into an appropr= iate ACPI data type for +consumption by the ACPI firmware. Additionally, any data returned by the v= arious ACPI methods needs +to be converted back into a binary buffer. + +The layout of said buffers is defined by the MOF description of the WMI me= thod or data block in +question [1]_: + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D +Data Type Layout = Alignment +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D +``string`` Starts with an unsigned 16-bit little endian integer speci= fying 2 bytes + the length of the string data in bytes, followed by the st= ring data + encoded as UTF-16LE with **optional** NULL termination and= padding. + Keep in mind that some firmware implementations might depe= nd on the + terminating NULL character to be present. Also the padding= should + always be performed with NULL characters. +``boolean`` Single byte where 0 means ``false`` and nonzero means ``tr= ue``. 1 byte +``sint8`` Signed 8-bit integer. = 1 byte +``uint8`` Unsigned 8-bit integer. = 1 byte +``sint16`` Signed 16-bit little endian integer. = 2 bytes +``uint16`` Unsigned 16-bit little endian integer. = 2 bytes +``sint32`` Signed 32-bit little endian integer. = 4 bytes +``uint32`` Unsigned 32-bit little endian integer. = 4 bytes +``sint64`` Signed 64-bit little endian integer. = 8 bytes +``uint64`` Unsigned 64-bit little endian integer. = 8 bytes +``datetime`` A fixed-length 25-character UTF-16LE string with the forma= t 2 bytes + *yyyymmddhhmmss.mmmmmmsutc* where *yyyy* is the 4-digit ye= ar, *mm* is + the 2-digit month, *dd* is the 2-digit day, *hh* is the 2-= digit hour + based on a 24-hour clock, *mm* is the 2-digit minute, *ss*= is the + 2-digit second, *mmmmmm* is the 6-digit microsecond, *s* i= s a plus or + minus character depending on whether *utc* is a positive o= r negative + offset from UTC (or a colon if the date is an interval). U= npopulated + fields should be filled with asterisks. +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D + +Arrays should be aligned based on the alignment of their base type, while = objects should be +aligned based on the largest alignment of an element inside them. + +All buffers returned by the WMI driver core are 8-byte aligned. When conve= rting ACPI data types +into such buffers the following conversion rules apply: + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D +ACPI Data Type Converted into +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D +Buffer Copied as-is. +Integer Converted into a ``uint32``. +String Converted into a ``string`` with a terminating NULL charac= ter + to match the behavior the of the Windows driver. +Package Each element inside the package is converted with alignment + of the resulting data types being respected. Nested packag= es + are not allowed. +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D + +The Windows driver does attempt to handle nested packages, but this result= s in internal data +structures (``_ACPI_METHOD_ARGUMENT_V1``) erroneously being copied into th= e resulting buffer. +ACPI firmware implementations should thus not return nested packages from = ACPI methods +associated with the ACPI-WMI interface. + +References +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +.. [1] https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/d= river-defined-wmi-data-items diff --git a/Documentation/wmi/driver-development-guide.rst b/Documentation= /wmi/driver-development-guide.rst index 5680303ae314..fbc2d9b12fe9 100644 --- a/Documentation/wmi/driver-development-guide.rst +++ b/Documentation/wmi/driver-development-guide.rst @@ -70,7 +70,7 @@ to matching WMI devices using a struct wmi_device_id tabl= e: .probe =3D foo_probe, .remove =3D foo_remove, /* optional, devres is preferred */ .shutdown =3D foo_shutdown, /* optional, called during shutdow= n */ - .notify =3D foo_notify, /* optional, for event handling */ + .notify_new =3D foo_notify, /* optional, for event handling */ .no_notify_data =3D true, /* optional, enables events contai= ning no additional data */ .no_singleton =3D true, /* required for new WMI drivers */ }; @@ -90,9 +90,9 @@ the WMI device and put it in a well-known state for the W= MI driver to pick up la or kexec. Most WMI drivers need no special shutdown handling and can thus = omit this callback. =20 Please note that new WMI drivers are required to be able to be instantiate= d multiple times, -and are forbidden from using any deprecated GUID-based WMI functions. This= means that the -WMI driver should be prepared for the scenario that multiple matching WMI = devices are present -on a given machine. +and are forbidden from using any deprecated GUID-based or ACPI-based WMI f= unctions. This means +that the WMI driver should be prepared for the scenario that multiple matc= hing WMI devices are +present on a given machine. =20 Because of this, WMI drivers should use the state container design pattern= as described in Documentation/driver-api/driver-model/design-patterns.rst. @@ -104,38 +104,37 @@ Documentation/driver-api/driver-model/design-patterns= .rst. WMI method drivers ------------------ =20 -WMI drivers can call WMI device methods using wmidev_evaluate_method(), the -structure of the ACPI buffer passed to this function is device-specific an= d usually -needs some tinkering to get right. Looking at the ACPI tables containing t= he WMI -device usually helps here. The method id and instance number passed to thi= s function -are also device-specific, looking at the decoded Binary MOF is usually eno= ugh to -find the right values. +WMI drivers can call WMI device methods using wmidev_invoke_method(). For = each WMI method +invocation the WMI driver needs to provide the instance number and the met= hod ID, as well as +a buffer with the method arguments and optionally a buffer for the results. =20 -The maximum instance number can be retrieved during runtime using wmidev_i= nstance_count(). +The layout of said buffers is device-specific and described by the Binary = MOF data associated +with a given WMI device. Said Binary MOF data also describes the method ID= of a given WMI method +with the ``WmiMethodId`` qualifier. WMI devices exposing WMI methods usual= ly expose only a single +instance (instance number 0), but in theory can expose multiple instances = as well. In such a case +the number of instances can be retrieved using wmidev_instance_count(). =20 -Take a look at drivers/platform/x86/inspur_platform_profile.c for an examp= le WMI method driver. +Take a look at drivers/platform/x86/intel/wmi/thunderbolt.c for an example= WMI method driver. =20 WMI data block drivers ---------------------- =20 -WMI drivers can query WMI device data blocks using wmidev_block_query(), t= he -structure of the returned ACPI object is again device-specific. Some WMI d= evices -also allow for setting data blocks using wmidev_block_set(). +WMI drivers can query WMI data blocks using wmidev_query_block(), the layo= ut of the returned +buffer is again device-specific and described by the Binary MOF data. Some= WMI data blocks are +also writeable and can be set using wmidev_set_block(). The number of data= block instances can +again be retrieved using wmidev_instance_count(). =20 -The maximum instance number can also be retrieved using wmidev_instance_co= unt(). - -Take a look at drivers/platform/x86/intel/wmi/sbl-fw-update.c for an examp= le -WMI data block driver. +Take a look at drivers/platform/x86/intel/wmi/sbl-fw-update.c for an examp= le WMI data block driver. =20 WMI event drivers ----------------- =20 -WMI drivers can receive WMI events via the notify() callback inside the st= ruct wmi_driver. +WMI drivers can receive WMI events via the notify_new() callback inside th= e struct wmi_driver. The WMI subsystem will then take care of setting up the WMI event accordin= gly. Please note that -the structure of the ACPI object passed to this callback is device-specifi= c, and freeing the -ACPI object is being done by the WMI subsystem, not the driver. +the layout of the buffer passed to this callback is device-specific, and f= reeing of the buffer +is done by the WMI subsystem itself, not the driver. =20 -The WMI driver core will take care that the notify() callback will only be= called after +The WMI driver core will take care that the notify_new() callback will onl= y be called after the probe() callback has been called, and that no events are being receive= d by the driver right before and after calling its remove() or shutdown() callback. =20 @@ -147,6 +146,36 @@ the ``no_notify_data`` flag inside struct wmi_driver s= hould be set to ``true``. =20 Take a look at drivers/platform/x86/xiaomi-wmi.c for an example WMI event = driver. =20 +Exchanging data with the WMI driver core +---------------------------------------- + +WMI drivers can exchange data with the WMI driver core using struct wmi_bu= ffer. The internal +structure of those buffers is device-specific and only known by the WMI dr= iver. Because of this +the WMI driver itself is responsible for parsing and validating the data r= eceived from its +WMI device. + +The structure of said buffers is described by the MOF data associated with= the WMI device in +question. When such a buffer contains multiple data items it usually makes= sense to define a +C structure and use it during parsing. Since the WMI driver core guarantee= s that all buffers +received from a WMI device are aligned on an 8-byte boundary, WMI drivers = can simply perform +a cast between the WMI buffer data and this C structure. + +This however should only be done after the size of the buffer was verified= to be large enough +to hold the whole C structure. WMI drivers should reject undersized buffer= s as they are usually +sent by the WMI device to signal an internal error. Oversized buffers howe= ver should be accepted +to emulate the behavior of the Windows WMI implementation. + +When defining a C structure for parsing WMI buffers the alignment of the d= ata items should be +respected. This is especially important for 64-bit integers as those have = different alignments +on 64-bit (8-byte alignment) and 32-bit (4-byte alignment) architectures. = It is thus a good idea +to manually specify the alignment of such data items or mark the whole str= ucture as packed when +appropriate. Integer data items in general are little-endian integers and = should be marked as +such using ``__le64`` and friends. When parsing WMI string data items the = struct wmi_string should +be used as WMI strings have a different layout than C strings. + +See Documentation/wmi/acpi-interface.rst for more information regarding th= e binary format +of WMI data items. + Handling multiple WMI devices at once ------------------------------------- =20 @@ -171,6 +200,7 @@ Things to avoid When developing WMI drivers, there are a couple of things which should be = avoided: =20 - usage of the deprecated GUID-based WMI interface which uses GUIDs instea= d of WMI device structs +- usage of the deprecated ACPI-based WMI interface which uses ACPI objects= instead of plain buffers - bypassing of the WMI subsystem when talking to WMI devices - WMI drivers which cannot be instantiated multiple times. =20 --=20 2.39.5