From nobody Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.20]) (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 665F2267F57; Sat, 22 Nov 2025 20:38:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.20 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843913; cv=none; b=J4V3zRNIwu/HcP+43bMe3Uhstcyq6vSW5GVNqeGeiz2NmzTTh5kr8ACLkBvfHjRJZQfn3V9Mez48X2+M8+S3lTR/9wf6dFAxexTR8M2876Z9ayaoAlVhMvzoYkVvI3rZADzl1c7u8OsFAAPvOh/TRayCNw4+oXzx8WnWc/pA1AU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843913; c=relaxed/simple; bh=+f95zJcvI0/rxUUgSjBFd7sMhiwQpEdJpxwQpZDWd/o=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=eKSANY8OeJ/3uG7C9URe6TketijTq5zx6q+3UXpgBX51z4ei09hWvR+Ab1pAa8urwt3HmccUhejZeO8Xivz8sP7qVwUGfDD6ewBg1onKY6PMNW6qgD5ls0cgeuTDqxogeVvHkYL0D3RWCppvDqjCo91oinisrp5tOTNqw0/K1OQ= 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=CQ+6FYdy; arc=none smtp.client-ip=212.227.17.20 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="CQ+6FYdy" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843904; x=1764448704; i=w_armin@gmx.de; bh=t+vdb8PzR+iZbH2mF3hPHdKjMwT1fhwXg+m+xenSrQE=; 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=CQ+6FYdyN1T/+jTKI4h3RpMRgMicWco1cHAgR1FgwJNwrMRJ4NK17BojPJbhfvkS Dv8yvRDMgG8vR9w9ckc4N+EtUDduxjRiIimAW3ns89PXqZaLb07pck6fLtS7+4iMp DzOQTsDt9PPWI0IQyqSD5cxTzC6t6IsM7u6L57kUOSV4q3KDmlue2AHKSW9w/oRQ7 gRuRLurWVK6mrXyMoNElC2tCEdEgMkkVBGFKIW2NsogV64fu6vXI+Ck1BlvgKSIqE cXKEz6NOwmGvv21i9KyKlCutrAMg6vSl6Q6XVAEgR2WCGRa1U0xw4hmaNeozvEP2I sEOpzBnnCxJOxsN/Cg== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx105 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MG9kC-1vLoSa09jo-00D5Ym; Sat, 22 Nov 2025 21:38:24 +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 1/9] platform/wmi: Introduce marshalling support Date: Sat, 22 Nov 2025 21:37:55 +0100 Message-Id: <20251122203803.6154-2-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:ZV/yzOTErBihA/FH8QfjOF4h/LKN+H3hRCdSMa7WZJnddy0iBzS 8/XnaQpm/2rItGGowaZMou+HrymsE+BgdES4ejdjRK/RjHjQ7Br182x4X9LksYl+Wvv9v4Q F6wuK8KVyRO9Ni8UmsWlYM2qCKa/p4Xttz14HZISQUjDSFsTVlxZg/m9DVoi737jpkYVDPF T9ItT3T0F4HnkdE3p8i4g== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:7HTpIQAuUBI=;faVPjV1ZzguozZDp0hTnaLevhvP H0J8OuGKoIEsDMxzkiZmZ+6XPmAzS18k8cY+o6G2X/5o3mKr96DzsDUtyniplK2fynLZZFJKM wsuH8g15Zx6Z1GMwFQYhPHDZScrUXI6reUiQyTCUvgZdwZ+RZNcw7j3NMHarUKnVcSfXZg3LV 7isY5EbuSVYfLGdESEYaiyBKEBRk4COjSmwWky4rMHlUe7YK/uqgkH7lg/fStCbAlkud3qqdF ZTmMHUzDwAtpPq7TB7WyM+crP4McBh4Xk6BsSNJW0n/NjhQ/2m3QZ5mLuhUHJO/5UoI7GhFes W9zBS9IBMwzqJ2eiMH3HxkE+daZKHZEKyGX2G/Og631dDDv/RZROWKugspA0b8CS32DpweEux asbCrOotYFidvLjfkKud6XXEKAf2eSigbTEqnxLFGvnjk4KPr1Pu8sW9CgiUHPueNEyo6BymF Q5UoysIxKi530wFlZski8lbmUcGrJlei8uPfwP/RDlBNCeMMEmujjpv1DG/5QDyp89gbX8c5u Tl1e90AWaFdV+ux841h1HzQvakqh7dn2O2DXRHvpgDTYUp/RynNw4267lO/1cssxyd3/jpsuq uVZa2TxVq3CN3IuOc80r6d21dLEhAQtxDVat/BFhiSPDFie4VEw5M4J4ktgSeEzrSxcXsPAWV +X07/EtkNHBd6q+4PViEWZ5dZ/vdYkHA/g4fWnT/CnnCUyYyc2rK+AZ20NXmrvG/HT7vwV3Pt z/cphgvz4XPt4pCT9FZCUD9tAcskBxd2AAdZ0jbLVwmdr+J6elxTaZVkl++wMemZCfoEXAwBC dL4OuO/9+uEPxrc5R7AeqXbSOzLuIARhpcJiJ8ot5eDz+0U/OVzAWGB4jQpHTis61j87K1Yrh gwhJ5jYNoxEQjf4dbTwhy3deKEn+MrH0erjBbS6+yDaJZeY/OsV0/9UJbT8RvzcFL6hqol2LC 6puKQs8Sy29/QTzyL/CalrUbBk03sDVCHUqcvbDsWT+GHwhhnLKJzWGY1hONCySuVinbQauue knAoA6o9RUUDxLBUMTtvbQ9NGESnwss3t3JA8SuVXkp9cWtlgFV3lSuMN5xEQYoXlzJ4/U+nd QVGPkSGBL7S6Si7CkfrWf9d7QOwvi1k0ax8ktDRlLiWae8EXsQN6DjIce0j0YjU4zrfNqY80b pHJDMEoas2ASW0OdDdcEqKEcdFQufGkBw5Y71n4qCzDc37DF+JysJ6JDVXHXFEsz+yeGRMT9f DN+qCB9tMN+orB9ml4zP57UWjtdBV8dfQxNEpeo36ORjZBexCmjhPfWAGhBeewgVQ1ek83cmw Z2W0hae4ucgiGax+aezatqMDl6XtbmVSHyx1P87i7HUcw04AzbNa3Y3ry7jNdQwZj8o2Bq1Nq Guc5/UTf1Qqkm+hWbymFwHnDj1ekN6DSUTnW6ThgYVYik+xwf/F2fWLjIUagUnTN585/lwccI tyLr2PvNw76STb/SuOZ4ZE53cEOtI7vhFOJCiAxhWRn0NlJ9zWgsVqYg90Hwg0Kxj+IkObYHS fNqyHpi3RG+RQ93Cio8x4YFduRYgr85/xHjMZaKFjaXazo7lcsg0n5VhTPUbpxNQKm6coMPrz 1YClTU94oODRYu+l9Y1QL8dBDMSvCY6UsA3pdVst85IDtNshjV05XIEmO1swJYl9mFlTSKy/J 9eYvqcDxlWRjr5HtLeVYESr1EWHlV+c3NQ/XO4/2uf7N+h9M8BhCFYx4ZAR/SDoRb21xORo+0 jJs8L9elcKOYJEE/+HgCstFt6gFj+ECMZZ8HptbDHQVRqLjA89fvkhghWBp5KSKHgkPB+ssoj QhgWOh3ngGkk7GMIxnoBbrJSIMlFZB8na8/ERHW+PQsL4mxEhZBemF0IGEyyEKLj+JDrJl88P Mme9n0M3jTdiCDQxHzWLoodNEoNmALqA8pdI2F8Zo8Er5166SzEzGzQNL9ymCKlI9zK/Hjp8O KGxDfvA9PzGBduekJewvYmT6TkYVt7qx0D1D5LpmHcqlgNcF8Jd4LkKBX4gZ+Qu9+TPelnfQ6 Y0uTyHAU/wdN9k2hrRAQJV7+t+E6x5BevlB2BZ2Iz6t66jUBa1GI0LstOaZuFrTbhzfoxQVPT EfvhK0LprrhSOSlnIx47d24C32b9D7oIzzn27mnlhT/Vt9OVsD5XvyGgID5uje/LsBCJBoqww f3ExniKcsslI8489U3fJEJYI/GEzBnXu9xqBpv2QvpLnvzHuprMDA95Ds2fmr47Io1/FsRE1k 3wIzcc5X7t6lFCY4yWoEB3EN6MtM3hxBg0UlsDOwEQJMYqIwTQ/+vMKv6MpkH6HLr2Yna9UzC ggkcImsI4eWcpDf9ntMUhXRcNFZwDRvK+U4ZEPK/W2023eKa5330po1r6mIMcPRtnhJrU0pZY iO7/Z63fwB+YlKo2ISXx3OSEwnUZ9wXnt6kS6iLqqSRxRj7WcIqkzVts7LWjSMj837Lz33VM1 wDLK82UNk+jD3YVbKmu+ibYa3S8X9YP4Cef8YkmuTfFme+REYN1Zusjwy8mwhNB/2kommO2b4 gP6zrbg58pPehN+ELne+r6koF72GhYn4y6VMIfx63l9meTmOiZK5SqpFWT8LI4XYOuX20oVi0 bC2L+9k9z7yLaeg643Avo3Nut0ilM2okj15WjUNuPeRQUNxVi1UkD5Ih6b6celZ6LWmD0hkT+ ReiO657JcONZjdtmw9v19QpHDRAIRRR6gQczwgMZube5yvc2sDaZvbtgkxpiyBJSm8Hy2BBO1 bOGqbI0nC/IMODGN32SCeGSD28uhhvA8WVjoXY1SbXqZPHQFM++iawSRwes7rmDfdk9yxSjUW +1uB9MnlAlvkXa8OXztpPdmJ4xa612BuipQ6o3dGdtWyKTqt1K+eeupTmD/uaTpL3zpsmtsV3 vuW82vFEloDVqSRNYiUfwXrP7fuDAyhOjW2RtvHCOFxb//UEiDj47cIGqJ4scsmQi1plVYOiw 0gXHBCu3u7PiFlrS8Yf3x2xRr+IoyzON9d4b7nipx64xOBnXhwlxlpTQmBpy6VLF/QYV9IzUI ZII852psOR3Zxu24PafDSvhNSJule36DuPHmAsasrIeRQScqs6V2fpisNXPh8nC6G/Zq9h1Ug uJronecLHmlL1PdZQ3u9+B/1wpmrNoibT+ZYG3mTJS3K7Ftk8n08CMDaSNINyPOB4bJL4xwzJ rUzipsK/7G0tKG66bDiFfHyVMkRDkDpPI/Ci0S+Zi3wWlJorHu89OYDM1ffK7GGEYhkV3Hkn1 LbbWXlC3ehsE3HSPbl+oKff7bpjwhes74qkS0zwJvUc2n9TX3m0z3hRk1lwuH/+C/GrYAtbi7 X2X44sN0ARsX/ScHZ+IBQj8AJAdD9wA3/9cXS+pUohGnfqKDLkhrxR3teGhEvxt1zY+2EgczJ rdqpsUKQuV6FA+eKWLsUKG550lptLHx3N3QMEh6fzyy/5cpcgAzXxbJTm+pxNN5SjgEOu0CSK y3Q59uEoY4WidviqVwGFHGPv71iCBvvXQPWSpIQo/mwWbnGDf+OxDfsMI25FwyOptikJ9vj9a 9qUAbKO+o4wo3zQ1NpFcCftpug+A1IlTfHAlcgIPlGvvmAnOPotl4LkhUEMqY2rxDS9si2aTk tH2fMKOG3XZEKzTA4Dl6WytcEyySk/gydsXbS9IfBTYx7KOaNXjtxehR0arXUCXnqn2jHg+ep AfXHnxooX61Cie44r8MnHDhAQrQ6CQj+0ygLITw2qXQSAFMeQXP+yOYaDCPOna0rqq0yDu+tp IYWvNrRlz9ABwhlPyvS8s3OT+t1oUvgpQ2c/wgJ5izj5o+hSSVkoaG6p8aPptJjMEHL9YToSt I7J3S6NfCebxkuT4PWI9jgGbY3KKXgbbZahdJN7TtA1PY+BSXFbHCaJ7c3JloBf45tVZVSExk 1fC3zvtkfgPnUZ2D7GdT377cY0YZDD5yGu209igc5KtbA/Z0F0zHj4ifF7wN3eNKlr87WqyqL eoic0HqV7M//iCUkNExAam1lhoTHGT4xKF6Tb1BsInHPtOUSES0k/ZDua0kcUq0XRArwaDl4w ate+MWzQ011bllLRXZ7yR5q44XOqXm6F8NQvdQemwYtJZIAyLn9Jw3booTHAOiX3RsJgPCOUS s66hnQikZyDJN3uNXxZUh46bX345PZMRSS3UAjKCDYDVpKjDNGoIHSTwL5gMvkSzlGbGHgBpL JbHkgSmZBHojgVxolqbAAXLms/tNBD/l2Jp+D031OWjbuouEDl7LWWe24x8UNPEOOMTIsinGJ HeoSIlznmGIpAx/sff+Px3Bf/TOelBa9W3Y2RoLzZdDfUSLAMvMdkiMSN7NpM5oSEkRsHgIIw EQx/GOnC3knKGElJowUpZSJXyoCYKtlMbwYghNQLHBZC03GsCux6mbFUwe+H4wq6/c2J8n/K4 w+isS7mXESNMlLDyfHzmL14cS74jBmj5bMZuqkh/neTrX3A8qX2Bcpz/mofzKph+CE3AWmwaz ISGacQtUXcHnrDWp2mfjU11sY5PbX8FGLXwL2JQB+JPxbi3cIJplJ2GKjgkGIMlol/f0hdWur l4Jt1brRhetKjLQfvFENqju+lqQ5poKh2YzDL/gO70ew+7jWddhXNsoKaGGYmRZpiIXt+uU/T HqPrCA0kzSJJZNRoJMkYM0DcAvDPUAwzQFhfTpPNs8YJDfArFhsNhNzKV2Cuu9Z+oYtDa0T2b Ryp+4yE4ZkDd6unEsvR1FexTuPJNYuFe9IMD2V54VIYA5dAy2h+Zf9qqTqB6MU7iaMvEMwrco wPHZWKutI+SOEWnvWuMxVygPkQBaa9q59pLfhtdKWlblGuXOS0PGu6VaITDuxv/+23jf8Zdkd VtIEcUIf+y2oblxuYBhgKswpn+bRtJykKwoVNuO0yKzoiZTPrtySW3t7UD8In8bnEQQXB9OqF kqZ3Ki0M6GhmA+SjHFtk+5Cx4fjc1lutiUcwjn/BD0pWXWaimDHhBZnU4DEu6PoYfqnr6xYm3 VOS8S7JAYgOcoxh4usU5Fkca6bhIm4hoDgccil4p3oQeIMS90ty7fDuuqsh5IJRgCEjikiRBw uhNJieOb+crZ8IqW3GWjB+Xx85v8kdSDC/TJ7XXQ/N0w0Gg8Awc7s+TsSfzARDP4k60jkadHL hnBP2nUdVxXM05Nitbyxvbl0u2b0Gt1nyFGzCxXxC7Nmvgr6kGquRDcCCvMjtYl3IoMCAAxU9 c0K2O+i8wtKKHHpevW6stVzQ23TGa6ck1MwaHs3HjWDCQHcRKg60+XjQhzFYoQTlw/F1mptU= 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. During 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 | 14 ++ drivers/platform/wmi/marshalling.c | 233 +++++++++++++++++++++++++++++ include/linux/wmi.h | 39 ++++- 5 files changed, 441 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..707d1a4711e0 --- /dev/null +++ b/drivers/platform/wmi/internal.h @@ -0,0 +1,14 @@ +/* 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_ + +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..476b87b145e3 --- /dev/null +++ b/drivers/platform/wmi/marshalling.c @@ -0,0 +1,233 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * ACPI-WMI buffer marshalling. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include + +#include + +#include "internal.h" + +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..4c2fc3c1f0de 100644 --- a/include/linux/wmi.h +++ b/include/linux/wmi.h @@ -11,6 +11,7 @@ #include #include #include +#include =20 /** * struct wmi_device - WMI device structure @@ -36,6 +37,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 +86,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 +102,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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.21]) (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 59138238C0F; Sat, 22 Nov 2025 20:38:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.21 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843911; cv=none; b=XYbpponSUgqD362BF4sSnx2IwbY59yUcT+YAEW0RMVGG/Ms7g/JVCuUD+0DOeg99VQtPrnpC7uLuT9veL52+44SXFYNTgM0rcVTzqniFelFv9fn3ecyUWMAb/+fBwR6UWivlwfb5uk0TSOYXf2mM7U9/StU//fFP5g9+0QxWa/Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843911; c=relaxed/simple; bh=Qrm452hUDjTo+GGxWQlTtlWPQVOZ0d4S83JUqVH1EZA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=FLaw02WPuGWJIw+k+YFW0Cpegu1hNOSw/mtfqXiP56SIi50L04AAU7nZB4xMd/niiae+4fy4A5nX6OEajM4YpVL6/X+chcEPlA9iGDnJSscTubulOkYk2auROvDHoHeh+dUvPgHM/OQBnj0fOPtCRWWExIREoGUqkDkwR+7udCg= 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=sStzDIW+; arc=none smtp.client-ip=212.227.17.21 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="sStzDIW+" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843906; x=1764448706; i=w_armin@gmx.de; bh=N9BmCru5mgQ6rDPFZe/LRPDn2TWbLydNIGh64PrC9Fs=; 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=sStzDIW+OsNkgUcpcgHUE4CCG+lTR3tlayLFaYprZmY84BtKteoxR5O0Es0vaETX id4lKyl3XKWw5aI/sj+no0wwD3smVERzHYpn2+ZfoVddUYsxgYnfiew2PbV3Tgb/l IE7/dDY/aTTBwgS1uisQJae2dqsAuBsYvZah1mv9VjImk9+UKPtT1h9x5eB9yeX7p EpL1e+ym/rTj37ObZCNh3W5RyBVOgD4iKcmTeV2bCkhEPtDDMaAz4vSwGkxW7H20G EL1jwfaiDiRRkZTL+m19ngJ4UxaJ6TpcN5Qlifz2GGiZTNHG58IorZJj4iwo9CdFd auemamXSzXulk+dacw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx105 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MvsEx-1wEjFV0H6F-00wOs1; Sat, 22 Nov 2025 21:38:26 +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 2/9] platform/wmi: Add kunit test for the marshalling code Date: Sat, 22 Nov 2025 21:37:56 +0100 Message-Id: <20251122203803.6154-3-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:5JXo/gwcuDraKfbhwZcah1A6/zNTIbVrBpRjHbesmFgtWCF8SAk 13rnYZHSjrPuXJAD3el5syck83UTKyZX7tU6ExFbtyHg0ShSCK6/YdAksLlfWfvXyq9aMcC dDhcQUTY0a3zr6HABnGjJKcmhlBYvK6AKKzVFKAgb3c/6fAGBvMGLwJPxsotWA7KGEiWE4s 0pv33Z1FtbuUTBRLR8JJQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:thkb54ueZeQ=;3Fr41OLkRPcl4UBLkRQ4bfKoW62 YuifYWJ8B4xXxM0OxZstZG0zblGxYQSAD91gnbCrpF+kKntR9ZUnKPiNBjWAziATZDiLOr2vU xUlgdtVoswQ9+U3PcFiXQvU35bZIC7DD1who2mAwLpto5AiIMlS6gbe+Tpgl5p4gl17wsC4oU WFO27pYCG1TfXp3RKzC7ervNPTXpDO1E8L3i4bcJzfxyF0hb+IhhRPanAxv57WWh6duDM4SH7 r8QPlX/9rI8bxiosmKnCE95fXjeQoOCFDoYuBfgXvP2Ez8Y5pNgsHQtchJ5ReC7lp60lvmfIa yVqPbdLV/kjokN6qh5vOSSDHKhdVKe58nMF5Q75vIrd/S9JCaI94fxaPtF543N3QeVwgj8oOS NjwuGI5DqULa4tyL39F2slfxybYJdVeioEzJxc2IAAuT2m6CboJjgQMM7fAQKxyObnnrakQB5 zoUgXzQjqu5OUzrbw98sA3amkArxz01S6pYDUPLplrlJdGJ/a8eDFDb1fV+eYTJT/UOViCA7W t1gOjfxEJ0XqwFHroWpBN5b99ebW3hP8HmaRwupODAtg+/CSGVTCA7tl+IztfwYlNg9xxBmZI Fbvp0ODN7PtGDQxqA2Twa8Lz2KcXCSMY7sQnMEfke3iragFu/IaT/g9FOYyMIy2jWnp4iKeyv 01Tavv/57FPG6OKWq+m5dGhBEmBnELD5kKux5GmYQrNEZUwuZyjxO1yul2CgLlSI1V7e/sNMu gI6tnppWHDVDatcG/49QGtIWGwvFIRxziinAVindPFQOqNcDOQjX98praEeUOLH4H6+oOlv2W qTiwmKvBsLrsPQ52rT8sNjGGFhsF6KR5M6xrCPNSiO6W+hDgpvVmWa2EseQW0gKz+4v18ma6U XQMs+i+zxFDLkkH2fzzbRTD6hA8yKMKG2TThrXsmEr09qekMmHenPcFCSXQKOJgF+S7L/1WeM 3C83MTpjwL2OXvCr05d54Pwqrta1iJe3OtO78UjBPKqWIUEOPkcyWj3m+tkaY54ocutsSGHJW uxOR25Huw2wvLdc21N1tDQoBP5wYKuEQyIr+8rYxxXB2OstWHDovwRizOLwH2cAxWzf1KJiCq RCUbUL0dMsX98TlsCQFGaXUOYXF1OWzwIIJZ3+BJp+aU86csGq/df5VbROGPW67PbdKGcNhO3 04IuxaGMI9PiwIhjDPnpZTZMAByFUZN7lPu0Ri1rxf8fyDHYTDiAcKEUBxNe1+fMkXlSdOuaz /5QJcyXrQLKYYZV8v+3fiGaF+LNZMzKg5ooq6pEmSS5VM7WCJx/sKI1YRXsYdniNydJVxY+eH 7Tmy5h5dQiSiFlLea/nB1y6Y8X4sVjb6m5Y7f/whd6+Q0nWZWdVKiW4k3w5Egla5pH7VcSt5J eFK+P9OROz/go/jD2TD/pfwQkf3mgspNwUpHnHbV7pg+ODCeMDhtCz05F+ZpHSTZrvPyRXO1W AltXVck+inS49IB+aBdvfNgKQp6ox0+vb0OrGh4oIzSWLQAmNNu6JOwNnv2qRXMvZKKcKPeeD rC/UQ75FzR6SSSRV7nvDPB1C10DSnNellg3Y4c3JELXqQrQoHOHQsUQGvbcSfzaVLApqw3YOt qiEguDuHEYD+ZIZmw/7SJPpa5r3mZJRpnPA6BU0Wz8N0+BKe1PR0CDdh2VqgVxeOTkptAO/9z B5Bu3/3ujCoaX1N24kZmijABdEe7r4K4J4JA17u83Cirqg9N8USOA7MaYtBl1yYsW4uMXwkF/ o8lFVAzCZbq6Btc/qidigFbFlncpzldWEi8WRIhAsSA5S7uJ0idffYnCDFbAafKMjAWWo1ANy PuBTRJAv10b9EEIIfYjCXGLDcUAO+0zo9m/6a/jMiTGufamA1IHLJoQmoJNxOYAc0K/KM3Fnf MytnT5tpJ+s3JZjAsWuB2uWKsxATJOouNT7acfJm/c+53NoqvrS8A4TGiLRoKaua+g1eaOpjs 8L1VGpguSPfWRgo2dC/pKJ46wwkZMcrYFvsXU/D6X2kZwTmS/GlOR4VOpACgt9dOcEjnbX07G ocLjlsC8Rcs4bjQ47nFCK0UrGS2ToMMQGgggC442lwO9TS1iOX++yE8rBrnPbJNOYh15l6RDn wHuXiI1l9Jq0lxPcIEjJkR1vp6cbfXRkl3V+23E/0d0xSTfN3dwQXsd77ZqCw5aTD1gVpfFFZ e39LBJdGCQ2qa+2JGVDh9YDz2J1iG7NOHWrpN7dz/e+l8si9KQT8YG0oRLF0qSptvF49G6g2/ JPDTZ54xZq5zjPnYISb7s3GgPvB2GomCPi+N2+cA01ngqp2ID4wf712si2abyiTcNuZsBbGYJ 4egmUMAWmz4eBRF9CSgWNEBPt6PbhijdqKzaI70WbdzAc3iKgg3Dec3i3J59feW+nUq2l2Mpw Coje26+nLQPLRM3yxvmj78ayK4Epw8o23KQtN9dhFnRuwfz9fw2DkB8QORaYC9ULyoI9wFmiu ZA6gF2egIjXzu9+IMRZofn5l0qdZ4ryu0mpnGitzOrFoR4dq/d4VuuzCmyJpT481BPKYGYDOI pozJhVR3WTEPzMS8HWHy5X4UCLSr91zAJhwOfTK9s+8Db6Ox5sQv1ZiIMWtQH4FbytVROgmJp eDcxjgn32Y3OGoHO94Ubsb8Zw3L+BBzCvCyKpiDKJUFWTjzquQj3GCos1rP7uX5soQEMYUH1N 96LspJZ2cN6bz4hgHBM1CTKbHY7HJHc5XYIChWuxhD9nAkhcwrPD/9bcwvdftfysuUd8zcP8D cDIjjbhNBbxy+YcjglWg031Hsijeec3s1u6iNIUaZoFttxT7IBaP6Fstqm0A1GCyye5ns/AoD hnjgQY0ce4d4qsk+x7vCcuyyqZ6zqj3CryHIe1zaIx/26YinHfEQgNrXw417xsAdGwKjz5BQh xB+UoNxmr2XyijTybPv9n0uiwP4gaqQcorNk9/1LCceBYsAs5xG//K8QKSVLBX8nsV+ljoM+A B8kUsRQUFDKsHOgmwJMt4U/PP19y4Vygw3IJbJOY8gZLM2A2t3vCqKJz2m7ySrpvePLu7pntq rTssy7VBoWMF+TPFDaVcPeV8/Ad5gSZ7yNznCmC0JUKnr7wYKsHSUo6YY/+A6ASa6RJSjwS3G oarGuyJKVc7lc9Q0T1bzEzaZocOdhma5etFSv8v7NmKb/wuctVaxiZr0TQeZN67x1SE0kUQXF S49LGgAk30j3I+8P10a8SDtzN4gmTi/9CMOMFGm3QjMTb9t5Tfh/DUuq0XivD/q/ulDxxqBee 8Mu33BZILLfLge7OrB2yi+Hdfrp+62o6PECQflrw1KWDkg7JCroZULWfdbltOF+/WuODWbuk7 SW6ntWtnWOVIzzllNzOLLSbtnYh+g93/fMeHJnH9HWqu9IszQ+bBwkVOPzV8sfyoNWYHoeq6k MMm+bNr1HRGYKHvnD/39AzvdF9fk63CEbqLGwxf7ijxrjKLur2hVBru2x1IaRrEyzzVnsRpC1 HvVRkJgfKRdlhauCcF5TIJmY2VIp01bvhmvgLaUpZzwN9bRm9/hTkSsRYcLDBmGuH/CmiOLDu p+Ip1WoPOCwhA8Vb64QOVE0jbbtYMR2X1ixFmDn6T03Q0YVnIEWy4JK6QotCpd3BWIRKyhcaB FeYgP+htDypXdrDupQKzbOkJ8yqGCauQfJ5DXiQPg7R29SMi+efWQ5QmQOhvB/SdXhZVS/BY2 Kq2nFkhdLLvR6MwTC5Vs+MXg3s+ayXnNn4+SDS6F91exJH0nVw/kV06ilW/EiyUY3fjCseh1l XZvmL5r21RdQL2PAu6Fe4q0506ZrofhA3TXm5bcvyfDH/FZHubn8sJxBHHx3QV0sSJFqq4lOD UgIyILMzZ+la+iwEvuXjZVZbqDmltTZRdaGDqMfRNRgXSLJG4mx417VW0uOI0qrlY+Q7LfPA1 tuUMM0I1zTf/wrQ7yP4x8oGIMtF7iSkrVW/t2IdCM2dTSoX42hYYSnI0l5x8Fz34Y2fUw3jUT EjUNMs9rulwkZmhOenKH/h38aJ8F00+qgWzKRnlcETs7qgubSMcmMQQm9CJvh1gSHqLkgCVsG 4fF8/JAqn0qYTYnWbdDXJctKBS2BFbKd4wONL2baRx5uQ4eC8+2TARqDwwsTzuD4W1Mgu8UNL jK0D8Au8q7aPlFFvL85ZMN3RZ4k4tTZfl50hmgrV2SPx/1pam5As6mf+WQr8QCfta3w7YupTN /yhgLecX1Y1GEVLoldF8Es/YhyM0QyxR6fS2mwnht7Cy3d2q0xqy21BUARYCQPRhbBfb7AuCO nhS+b9a5Juwx6Pnjb4QBcxZR/XSb0wDhMN1aTWxEUAhToPmVsdSCX9x7yk9r7No9UW7OANClo DF/ewUOPkAv3wfawYnodi42qYg87k7TF94gtq0Gl4Qu21QT9g9WtjAykx+0bu0FVlp4EZ+/dV Ka/ndaYlIIYjndvLw4feF7UU/ELfkcSk0jupSRKheLiGDNdB1RqXBWPzR8URIF4CT9CntdWx/ BoVTzmyeD+GItZUsajbw6AJ48vTmH3e03gvRxPEA1v6OggdY9qptG3Ofd/1OefM16mYgX/yHT +h17JiIQvI6puee7R9qMkVo0JHShUO4pZiR2bwgtkZ1pOhD1w4DvK4wpRtUqs3MfVTc565pla GdE7iPIl9lkxk3IX84ZI87YaTU8PwwTUtCPQquMRb6iEf+Wutad8v3RuZ5qvafpomgu7G+dzY xXtrjb+LpxDrWtALFH+DZ29w8llgj4JNijws1PQeH/3D/UZp4RoojhvjZjECaK+TpzlwwkX21 WPCWZAYuBAS5q5l6omCHu4DAYn2cApauixZaHTX2b9xO8h+ynrIppwnCDZrGsZaPR//syMRU5 m9AeXuKSyD4OUF59Vl76Z2soI7BU/KwHwJyjd0g3DK1NNASSFcheuooQtr+Ck55zq8I6skMIP Ke++IQIAbShCp8wWwhb5O0BUV+l7b1F0hwe92vJGeq0mYoztOBv3bcDuuJwsn+UTedmkFATfn tg518rzD37YhblSBKlvdPnI8q0MO9ZyX99uh/KVBv1wxy2+um2uiUc01fxO2p1aejCcgvMr6T /libDFx+1rpHETcn5AgUdHKhPlkUxuo8MEreDtpNglFjVqX2nZq7HlQcke/bspmfzxj1cT3Vt hYIQA18tSRfrg1x4YEiwG8ogw8rlWu9D50yN8vXuC8DLzbAih4JmBZP6EisutNWmPd6J106lI HigvjAq4= 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 | 448 ++++++++++++++++++ 5 files changed, 477 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..e339791e81e5 --- /dev/null +++ b/drivers/platform/wmi/tests/marshalling_kunit.c @@ -0,0 +1,448 @@ +// 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 "../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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.21]) (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 76CA82D6E7E; Sat, 22 Nov 2025 20:38:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.21 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843925; cv=none; b=VhAHapwvX+GGrGXbTvepW+2eB7wTobGXZePZ5VVyLXc+tLdgUj57yakva3oGVKC/C0WUyDal0HRWyrzATRW2jo8BsLhrIB58hsqePp/nfghVZgy1Fd+6eaZPFSY2tZuoFzpyYdz+wR3E+kRAvx1YHqagMkG0Ey9ccP2DfIUyTIQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843925; c=relaxed/simple; bh=xLk9zIAKLFK5NSyVBhqid7P/VsmVLZ9C44myHTpz19A=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=IKDRKVSN/kWruK5h2Xspv8ffDwnXwIqYYMGAMjo39/132q1IGt90LBHy26pg1t9qtP6PmIbPVwbD9Z1igoOCp/L0Q6FTtwb5+G2lBpK7uTFtX5O2CD7e66Hsj0358SsyBvYHlw2PxE/05K52vcqbJC2zW/BflT4sLoFpSEMQy4o= 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=RJ9TqktS; arc=none smtp.client-ip=212.227.17.21 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="RJ9TqktS" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843910; x=1764448710; i=w_armin@gmx.de; bh=tg7w8vMJVMZ5N7O9lx3o1XoJ8SREmYXTOli9mx6j6t0=; 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=RJ9TqktSNqyAWeP0lVPvDoBhMUMOEHwbgN7kgjbLEbFlRFz+goYdkSCyaqpB+yPn rDEkqrJISYSN1VZmuHUUym1kYSSfsATFVbwxPPACKGS+Qg9pw9x/f7vdf6t6Y1Or+ eqU69Uq1OMrNObaXuh1mtCQVtVCLXT6BPzugjGEaiGMORnUjwKlkmPLmkX+Q1TJiP 09WLrVQmN9Uvy9SMbeCBCeSEdtGpL5Sf52sqSRbx5XfSbboylSZ5ACFUcVm6+kVGY 6kHHof/VLl6HgXYDFUX254LVUCkit6AoMjVnpLI4ccRNHHns+cLoLp8onoD8Ng2h/ sxctTsYPAwxiERmtQw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx104 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MJmKX-1vh2aq3feD-00HggI; Sat, 22 Nov 2025 21:38:30 +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 3/9] platform/wmi: Add helper functions for WMI string conversions Date: Sat, 22 Nov 2025 21:37:57 +0100 Message-Id: <20251122203803.6154-4-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:GKK057yT1pOjQD6PTeuXWZPh1uru+eRQi7Oo3AJRMdcASYUpX6g Wdq7lj617CuUi3iANvN7INayA4Zd4w3X2Mi/s7BMIcRgDhwTYxGyYw495LxOkvWgVJnrZye vnJU5Zpr9zTec5SVISlyiudIGEuVv2VP0f165qzKAh2nhtwa1Baj3zGz89xRFt6i6lMo1h1 N2BP/ssa51KELsqy2eShQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:XOgDjSpHNpY=;uzElfC9jj9XihaGwvjGEDinBgTw go9GPvy0wLuC8LJuB0EzNCn3Rsw604ptlXalT2OczPv/olyqSmg+yNp+dVV8QLrU1ARWoqAKm CbZbQrOPiS1YmNRhMW2xcHCTjVTyBbr7iKgJomppiPcgn3CpKymgqRkYNClQbqMSH7HJ8Wz7M lS4W1VFCzPwTye6hmLowExzCZPXkJOAKXP8PhgjSPMjjKbVROq22HvaG8zMsyKqqJyYqHmlob RsKliwpaVjlcZxpTIzRbAvakURN1HcJ6ldkG+MgIaNo5xj+l3zges5NabVm0IBZSlgaFCGALi hMcvr/901ahhQ3oI49P40zG/GQhog0MWzQgOXw6UYzbQIBaGhBS8PGvMOBrCNLjb/lhG7KfEP UApRaiyV2c0aSgsX4JnUSuo8rDPb2QnNi6SBEtJBz+xeOocK2bcdeSzt6dqYisCQRhP9ZTK76 QuP70p0UenOjrAA4B9VklX9ea6P7zbCSSbUIF+su8E7MIa/luQ3S9Myfj2FvcgieNSd1a3Xbb 18tvrm5zBL9NuaoHZpWC4mL2jOkggRy65eSsTeZDiZRNthmjDG9n/DkqmD40qqd1wsUdWIZ+d p4WI0AAPoCaCWLzpy44HKhABeMUM+RgXkbh23F1tlLJaXfKCXw7fAPiAhlSjnVpzxZ9+NEFZN mGIjrjJBaPzGPG29/RWN28BpdkoRG4IYDVf6bbVBXwL0DmMP3z0RHwr+99UBZ4SMY3T3wvjX1 g/sjRrWXYfEbNtmQB4vH2DLN14nCJonLPbM6ENoMeo6rgog6lRFkUmgeHeX8KIyQRUe3YO8Zl m+M4FAcJS21TKTKtPWtGl1urxKwv1qd4RpcFA21kYMPEk97HwmkVe+qdLh+iaBYgnbctlfZ72 M7Bn3xk4ysiJEISl2zB3yW0gtHeBiCZeyLl/qRjk6rA2X/tKtW0CewM63GHWoB6rrRA19FDQy iJSjwkuHGWjciUGJdIPfVi3nmkr7znaCX+cgQZTCnoe2pzL0DDXrumyT/2iNkWIr5kFYrycJd agcM4pbjf0ZP887NEDIR3+0ixanQzULnN1u1WjXmbHB/LLSQDEPpsDqul2qGAMzQKQy8h5Vl3 yVX2s6gx/N2gVcocDmv01GYm0/ZOdAXMNQ8GGgLKk+tgOXB9vAPr8/D2efqRroK5v+WDbMUAx P+H5XksBuZjJvLfExbH0E4vLQ1z2ZbNEOsETX9+qhH/hlm7C+aoPy6ZQLuhsYUtAatxNYuFdS YuLLReliDVIVjznTGBbzOSfKR4YAsBY7DeDb8FtZPi4lLGjfeYof2J5GvxLrfUXDOb/O/doQg LZRSYVirgmvuas6x2+jbmimXvfGALiyTlWzH+jBwUH1xEoeM3tWrlCOEomWABT999jonLXZqd Leo3Xv5tD/TgIOzNUcZNwaZpmDcHpG3idXjUqforWh00HK553qUj0B1ixYnoKoOxgyA1hpiCs YmkU6e1h2fX0DHrk4SPAp8NJ3NIHSZpxAijeUOJBAdz3GahwdBOSmGHANK/gnSB9Ou2wGXW5B g5kptsCobPbXeoCaevfosY/nBLFQ4qFtPrgjGGfMAhyf7A1DQyvDTAk1kLBJGMgVWHqZK2gPP rfsB8X9nQKV28eGIJhOEf+eKDHGLKXgDZ5mzT49pfrT8llSHDSIipZy3CLGdx95sAzyLYs6vN DTAhPAUiU52TYkTm3QQdanqThZPPMDYAtM5EoMcbSwhFeHnTmGZmMsQy7fS24TaFWVJkDAaPu 7wPvmNIEfLMhudiMXOJj3xlkyuHZX/c2pz1PTHFLfu8ii29KbNoQMqQP253Dv9QafCH2p+gDd QXyZx7Eamp/aGmDesNAhteC9b1Gr4bilJfWlokF0Cwl8xPwk0V5z5dPtPTWNVoPTBABi/l9zq YqN+A6MtJbwSmdeS0ujKaI4f37bDYbWyvbBTMact/D6tnn1ofq3Zss3c96WDctdwz8m1rOwE6 G6gDIPuT69+Qwd33showfS7nuzbIUYTgod4HPcX7kDcoxm21Jwf9if52hb1/M5uQqke06zspT RjNMVCFroh8KazZ+evK1AC75bCyKoSPweV4fHK0Z1uVJ3eA5xPLFJMwGlK2FuoT7vVTeRhYo2 q4jYcE/kVR/+fwm/0L/Dd8XlPduuEPGkahPyP4nq3KvRRI+5D/9/WUgdaWMNOkCQAkmodhOYB F+8cgsQAa22zdNfXYjq6CMkb9VO9rhxqmLAWwKbvQe/3eHMlW+TOr1+YTXDp+af9h4CcYuSiK WSfAqNDfsDUw2tlrat+7D7ZRZpAOFYZsaInMKKAZE0VhiusJgSXlf76DP5f5ENJ60+xeEJqoW 1ID+LweTVZIMlKweDYkDLWw2deAAin4VKXlWVSXD4Pyu3SQOqfUpKC3Ix2HWySISSluSD0EIM WtPENpfc+F4vw1F047Gqs6AAYrBq+mSOiyypIxtXmVGXtPA+DaNCZIuYK457blBQXWPOEHKIR cSo1LH/ISnz2au/0BnVsI6Hzx+UdprhHcU22F35vkhp1nx5udtDajPRL/68kuyNXmT/yeap4S qdUEvnYmJXySLxWE9U4+UROPmImIUxWe64tMcsfsaYVaWAxIv3Yx0s/HYtyh3t/9Q1DAOpjtv vxub5rr5MZIAzm7b9ilMDVNmAKtd6LBMSguBJ+XdYKCtQR2cRCYpaQ0Ao1rhUXQPL3b6eLhpi 6K29cIbc3wlcgUnFIi2OGoauky4N50vmD8ueyL6kTB6yBp9A+EyyfMvoOo6SazD5JHs/kPzxc ZHgJLl0J1u4tWTqAQEjUbUQDhPCIcn5SLqS2yboqhI6VxNRXE0zUPN3AIOjYJX8U8Z9JGzFSV gXS1o7D7m2ZkNs++fWrTADE6n7BOmyYEzEb2pm4w54hCHcH4BFSBMf7LRXEyNBobDBhTMRPCD TkEWpm5Tv+bP5PKqzz3HKH678vOlH01S5OR2hoV/2r1NdZuio68UvKIoSAXtYwAPlYYi45DoZ 2/2w8V7Eaf5EUiHXCLF8p3wxxzB4glkirFrSvDV/e58TWwFIFZxBEmupFcAbsNtIuMWZowEeH KT3pLtb22nogZAa7lTOR3eyChU9IEN77Sft3UHJd4Pl9wM8/XpRHQetWk8Gr0jkz9kYhD+S9x nf2IdSKzpLTT1JheO0T0TG2NMPCcPyPeOpJ6XXaXdPw9LdrtSQCtgo4daTjTVwnUhRoWGn7Rs zsPKIK2IkdSR/uNF6dqQAbalm0aBiRSiy1nvJOu8/iV2IzABrjZ2iLcVYbM0wGoedcWTOW3gx xAKCPJQW5NO/ixeGTRBFVRP/Ac9sKj59JlMvewHkr3TeRCgKXX5KrhdHyKGqkS4uz+Lplajb1 AafbPE/O31+I127Z1JzzEXEv9KefTHNRf2Qp+a31Y0XO9nul2UHZ+GJQzXId9CYjPo2agoHqy GIa2pmVmeJNTx7RX/bDQlBv6da2NmM0zUU4uTZfQ7KWe7dY890nype3SB0vAsYyHzGHBNlRmI BB5sB7cQ6WcEs30ue0OVD7E8QJZI2oi8WQawM2p2LFFZRoEVxtU/mQBj/7q4bYT9bPbKb7BU6 kJj3JUYa9IbVeg+yhi3kVHL7QEX3PFxOAZRVSIGIAIejulKBHRyJo6TW3SQRtuifeq/QiMLlS z/NaZBXZegGp6nQeJcD7LpOyxii8BdRUrkN8NmLfcR/E5BNupsQncSfH51xrtROFXdXSlejkp FlxHkFWKtjXdPXvD3TiZA/CCvmShVEf4eXr2P6/vva+G8huqQyW9m8C30Ly7bYnQ0kNTfjlip o7GAU0dzNNJ/F9rru5WgOZL10utDV3t/TsVSjr39UssNN8w82Y1EK8Eo+qG8Wd8Mr5BYu/6uw CU64avmrN3+2cNU1PBPDwoZ8EXWdvxgjVvlLxxlKomTGgwTxbR88+TtbPfQ5n+nasLXmnxrPH AYV2gG1ZYPF3L49l6oUsWax72VqNhEeAWYvVIt8p3jg6UeN+E4UCWnRQd9MyiSbNVR+d8nf0T bizMpDEqJ4tcRNApRmCGYdorG6L2+D9MMr8wQJoKnfwNyT4oOaCKbVL0GbhHBAFQ6RUS/rD+0 e43Te/LZJehHnAUwmK0a8OBwjWhUtZO1HpmMwZX3DMYY+T76mQ7/pNWRZdsJWLXqqoUJr0r3X O1A6ikYqkMyI6gxJQ54c/V4YTxDfDLqDr1V8axdkRfKIzXFCLND0usYGhfZMaH0XzEHM0XTDC YnCXhh3AY7lVZPFswsgn5ZSBB3CxBfa68Ukea9LF7Ug+p4SWL96nDeKxxxGH1tUe9RTzQjDGn jbzid+GIcwt4aoO3ayUQiqQQxKBSg/ENVQ9VRF78cU6C0BJeOwBQpv0X6+mZt2Qj0bTYg+V6x iIU2u75+th7pf8w6DdlXp7UsE5pIguki+V3J+DIw7slXiCoy9nA9M0VBAsA62asc3hSdMNkLt GJsxF3QqwNuSdLtv5wZ3VMlJ+1VYg5UkFpaJ+abMTFU1w4e5KH3MJW/fS5lRGh0/TWsn7JSv3 G1Mzx29T8zZlzTS0IAYAYHrF+RVGHCBcdGjiBwp4uNFOOT8XnFsgtDKtVLHfsaJ7djZH8OfYn UvRIPrxTY6XQUu9+EPOSwoTcv4UB08bYZLYvdKdv2rrRMn2y1IYLIZHI+eTwsSAKStB7aGMcO jdjMLJzJmgAVGgNG4Vuux3/DljNW/zyRStGLouKzFiXtR5i2MY39leOXwQGWs2eLqY4ciis/V Y7XR/u4ELiteFX/uPQOkuiz8l149FQAw5qFQL/2YbG96i+gh+dx0npz04NBafAAxEMykm2xr7 XwujzQJLzM/hqIca4iNV7zTWag5HViEun+d/b7Jsxog3qHF8Njud9yeHNmJkbdctAFkk2iYSS OsDwrZpJPbV0DJuxg2BpTMWm6S7slaSV+02p/wxpkZ3/a18jmN31a0jgGcua26/OcXlv2KETs 6DOmgr6mSreHFFLHwBaAfTte85empMYduUpghwa71fdGC+1Mr4B8/07UA0jl4UMCCnmhbsRxx vXRgLDboiIE17u1fidgVpKJLNPwRMnuXyl28APp6+OEdeTSZ8Mo96YuqovbfgbDXzHb0jZjQA Scohajnvd9wy40OS2s3SjxEgRQLpIuqk90ecEPeBxdzzJ7YNEDnpJI53t6Ccz94OICP6qvw8H M4ooeeV10L5sGMULoqfjWCopdawal5j+VdU+tstExlhQQCzqysDFhuLQEqpjItgoXxCzYohWo CkQ+OHznJQs6PpgnEyJbH5IYpey1mWOltC3SZ/Icsx7SMZh4r+yVRgEAnouAC6pWtwkkdPsM= 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 4c2fc3c1f0de..fbb794951388 100644 --- a/include/linux/wmi.h +++ b/include/linux/wmi.h @@ -61,6 +61,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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.20]) (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 AE5AD2848A8; Sat, 22 Nov 2025 20:38:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.20 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843919; cv=none; b=WEz7u/mGpQF6o+7rO0Cih7drBJx+WCCEDnSDLpVu8cW1Fk2/wVS1/ZBUfFVZMisnJ+rgPrmbZ4kSCu3Qh7iL3KVLVxyIMlz0uCJ1Hon+2vmarg0zcfEC6t5fhtriLtJiCoOeFKJ0acUJ7ozZQAQkSMDOW0Fw0sui5GnIRIhfW5M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843919; c=relaxed/simple; bh=l2YJRNguf8wk88SUlTEgZ+7KnTWqdISh9C3Qj15haMk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=nEyle699Wa1xIfawqrw+MzVfxZyx1SzHe5xJ8uOlfvduSJ7USEhELtL1XShJHHy41bOrxqWm+3z/cdx9cRDfKhADx61TSQEMjzSs6ahrknTxDTGuO3ceN4duvUlFDQzHbvLKyDa7mjQqwHcLNioE5b9GmlpQtFqK7ft5j8aAr7s= 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=ntLlFLLW; arc=none smtp.client-ip=212.227.17.20 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="ntLlFLLW" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843912; x=1764448712; i=w_armin@gmx.de; bh=xdpKouYgk0YDoP2WSwdh/NcjNQm8drFIQ/Nv0Bk/AOc=; 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=ntLlFLLW8yRmitZFzZtqMjPcn8ssBYPfXInTgwgvHW5hnzgHme40lGVo+WE+phO4 +Q05eQcgwJj78uMhWtN8GkUiG7ROcBMvbVsrAP7jgIOS7jG/+sHIS03p3cBFPYYjk JnXdViYt5c9s2j0GpHmXrr91zRDLp+D5/1ScGna9vOoYM0ZlA8udb6Jh/ZTg6zI4T A0Fx5VETW3+M2hbfcLsUVdTztKkvDV1srI5LawuxBV/sRViO/TgLJeoB73xzUJWK4 /HVhVQW5LYAMU02LvVx6AtWDKxKdkFwj6zFDSpX9JJ0Iq72Y0b4cyF52Doi8Yf/We OdZf8AYnHgJN+dDaJw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx104 [212.227.17.168]) with ESMTPSA (Nemesis) id 1N33Ib-1w8huf0GuT-010xRE; Sat, 22 Nov 2025 21:38:32 +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 4/9] platform/wmi: Add kunit test for the string conversion code Date: Sat, 22 Nov 2025 21:37:58 +0100 Message-Id: <20251122203803.6154-5-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:oUkENQFfk5B43bUSyXXTZSn/ZvfCAw5nuwEn7OU8K9N2cJgo0QJ rqs4pivspi8mZI/c0V1vveR6AXNPSI7MyfvN38qZE7JYIvIj7AMyO9P+Yutl66avHvFZLQO qHx/HO3R4aJilbUl6OhpF7zSsadYYEUWHjvK6k8UXbVhbMfz4GHyYLBHk+rl5ZP7oRnpzaq og1Hg70BDhrDx274q3Itw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:/CwSvMUUw5E=;0Q6ksOMJYSMHoGwfHvsxmQpsHvJ 8f68GGMqUFevusAwb+oVDquPcisGVvnuNVihltBp1TPvgnAvnyrmv88dE6UMPECt6soo0mkjX CBiwrmGanq7KOunNYYNdlgmL6tu6RIRbDKBcMj0hJPgg99qYMJXiMij8H7l4393ehjC5AEZoY 5NVkJpdhcI8jWQiOgGKtcb3mS1ljgmdYI0KwiD31hBITF+YI6hAu5f9O/xqD2jYliu3+OoTtZ E7urw2OAcCqSNrE+VO0uDtZg7hr7JeJ9n97lFSJawtko8rC6WQaXX2A0OZU8ly5n5C9/Id4wC RPYDoE+r2JPNzlKtPzd7nx/0R+kljkLSFWtK5G1GCJhf885FA3nBgQKVf2V/DDyrnc1B4eaky 9uE4LEDJWE43nD8v1LpRw8bnmVo95fln5sEJVDs5Vk/e7ydUo40NzFcLpw7jdZDGhnOZxvfJQ g9qXCWlRoGZ+AV2CjHm7yHuVtuMCU8xsYCdVHMC3+dcmp74K/VUyHDQFuvtijB7Org9wT+iZf wiX/JzabaGesbrjFeG/2TF/X+TdpBUf3Mj4bQK4KTSr1rMwrzHaXvq9kdTTptWDncIy8+AqQ+ OORWjbdc2kF2j+lx0te/jz/qcrAqJNQC1OxAVoXw7XuPNMnILh+7qKMljkNtRoV+QZ68Vvveb SoCefqhh1isa81uQJS1wze6vUSuNSCDwKdtqJZcsZHjyEWtlhxqppC7rSCDgxYs/Tgj4mmxZp 4niI8sdH3UDzfgBxqdoVQyH86gLGHqKBYYi9NSwWt/PupT+Fhj86LC/e0NW0shjY0bZ8c4Xlp pZMBh1D0nBfH5/iHOWnQtJhRLevEYIWF8z9dZ7hettBXoWqXudmst9gP9K65iwP2Tr64RVhXX 5EzLECgZXOzbPiPgDymw0v164g6A7b0JCdUQl8vEsfYiSyezg4c0H8nQivjiMd22U96PUnVGT ubnoUe16uEPdIAYqyXlKjcSd90dGUJ71sUVP17AQbt78foE8qLokdOjI+2SwBU0Pr8+IYQHnB qgr3mxEsNWEIo9fllFthkhRdCGc/YyzqwXwcaB+84RE49BTI0f6u39CoftLIFfiqb6b6oNiE7 4qgJC/i4Psig5oNLeCHkcEX5sIBaVwRJ/uQHLnQr3Vy4lPbywYrX7nP1uxeowfYTr38XJJ+Ei 6l+8uYk9pfpCvHOh3UxC4y8ONXqVTkSdEiSSHCroRB/aFe6uivZ59WBm0aPzNpXQMnSlDBZCb /wKUr1rtg7azxd39Kky15+lDby8LsKsQz6ghEelYD+6unW3Dr0nm1CIcHjKPfOpH4cTzzx9ae dcgidLqT0DUWDI+5fLxUXy5Gj1y2axIGJ+W1FrPdsgxF6PQqtl2tx7a0p0eoWbwhNhnC9bG7s PDHgVE5nSFk+SVMoviZmCVffNoFbNNb+NdfDwy7ibZLcVx1ErG5BRzabYJuu8aujMXgXW3di0 gk3JlEYMCiXSOV7zOeV2hxbuwDkMrRneFXXQTAlnNYzswGIpr2mS8veAW6Pz7ZBo9hUnu1hpF AvapCEHQ3VV4BvaUrYB0F05mYjsBVnlU7qnmiu1IRQ+NB7y2eqFoiN7kdoo7VM5QkpEdjnv9Y r6jAf6qmTGl3H3t+IU65QSmypxNw7zXfMB7tnFNP4wrBRoIeENcB8ZA3uOhCPsrsZb5XsYCyg iVdAEpArtUXuYhhuHNT9kKAguv9PqhIyY/ewbU5pkFnji6jIC3S93JABt9TUyKt60mPxKhgq5 mOfwKtloeZeC26K5745iqHyfLmwCz4mxGKnZuojRikl7vsQh+EHqPXGIw3436R6qPCx633NXx Uj4ePm3WitdacSmfCM7/4bPnCcVCV2t2hPAapd9PwACjm4vTR6c2GHA+yvz7lxUd41j+KCL1a 2YpBkgpjmHLawhg0nAWDJqnRGnTy/tzhiQ8CIz4XL06Nsk7eCFUg1SiWCD33ujdIsSsi1GHW8 pQ4pe/VMRX/Qk8b820GXcz0Htd1mnP3SaAXh8raHoZWcJulsvRnBYmtiVhNcBucapM8XYg4tP vcnckHDCYx/IA+uPMTo1bn5MNXzr1otIpHa39ju36UPNA9yYmy1HTgVSA2/ovYS8OkurpQ47P naMon2Kz0SWnySdE3tanNoSocnV+Dc2A2iyxlw0wWBzC31M4hdv7a1faLbMic7W39Pu7kZF55 RXelE+3SnPXMb6hqT8lvTsztzfbmerSO4vyXuNmAEhgiwVqCLVLMIbwZHOgHmlsDwJtfZwJBh LpzQ342oAmIcBEvEyTx4da/0RzRPXx9CTVowhnNFuMXQ5Tr2T6X0et4giM3riZlZQptxzlW0a 3s4SnjPNPWvXo9jJugwhiHFsDhJ8gAbRvz0gAo1MSOVJZ3EMgLKPUJaFXHi/Y678rDWEMKgBB K1K3DBliF0vC9RTRqfAgQx5CGmjTIXU1Y/EDpHM39yzVsprHfd03XQQDSmoX5I/iS5pngnpar TGahRn42sLlB3BPZToQEV2+mnXFUl14llM92JY2o+RUwBt6esV8g69MIAAi1+xxlVuJ2RXzly jycYJmvihuqgoLbuYFactgck53DKcFEJWCRMkRlo4dRqr57pQziOaEiCg5ulfD5I4mcQf/WPh jPKsypxU6BIKcS/1DGJjhAIIAZJY9MCYrWCBsn7ISqIAITc/Pk5r40nlCVlyihiSK8aRWWqob eIaxp/fkkswTbx8K9JfU1Jl6WGHDSE+f/SyexsPjqMYN0d4ymojJJ0jyiyl+1M0tKr0de6IL5 NGDH06nBCnRnDNRtEFexfLNkrOyw0OWbSs7eFw+WO4QPbbO7t72TFzNUHbtKKRZpHwcfhEC0i efmK6wLA10rGoEBTnuoKlw+eWD5WjCso3vdJKEfHCyv8s/QxFiLhOxaxa0onXIbFVOSzPT8tU xL1IWBSyk7DBHaY3SprdQqrgRGKxEvdm92fdwrkdLXGwHtxxEMXSSjWSzc900Yta/J9BEj9qT VVpz1xl3p1XfFO03DYCDb6Z/LtvpCesLSkeGz70nTgK/C39li5rOzS1AwEzEjba2I4mS+REgl 7yEHT10LVfBtaha7/4Wu6zS2YGbaZ781YNoyI+dIDjH+6yJ9zmPNp2ZuCfROw8v6zLdL8wdIe r+hCZiwpUneqGj8+MbHAV9uPhZ54oD+AF0u7OKZS9ygQk4DHYOLFHt6ZpOqJvsm1jtcSLCEyq Hw7iQF2Uf1w5QksWmxDR2zlwZKCSfymX40SlbbTAZBoB/ydTnJ0d7UEj22FQm4PkkKtnMxtCp Skn2TAT9UeHv249Hldw0u/J+G3W//NS18yMT44Y+aTLTY7Q4S3Xb2vGQETXkS1ExXP1eveTbU saNQFyy7F0C1ELOCifmyhXBBqahJE5w+TY0+JvnW/lku8+A9oBRAd2M6JBfjqIsnoWP/i30O5 edW+gSc0WcBnMFmIzsg9+zXzTCQ4VowS4PtS0lV8iKEkduGHUGKvVKhhqahbHoYRyApP85B5H BfDwuFEHgy9KfGmqF8afso/f4t9MEYr6aP9Iwh7iBMxeCoNaENpVLBQVTcyiPKPyMFMQHMG9o ic3EHsd9UdszUI+F3rRWqEyyD30mV7Tw4h1FL3Dtua4+G04ffBcbPcrcocTJFjXNnDYPLx1N0 C/N0mhAoAB3vP4l826JttOmkPwGneHQ3LNSEr5elZhQGMfALfPtHyJww4aRV94+I+9syMsHK1 zPc34rSnch/5ZfJgAH/6gH6naSZSYW6SZ8DgOjgvF3Nz1cvPgOz25dcBA1okFwZk0uIUtGXNr GBvC+rm8dvkg8XncZMi/jBjOwCoJAR9+dXObCQs2LjNWx45+S7cYtgo2Tx9LiSyppHMrWDk+7 mvAmswFcMQkzQX85FQ9MyR/cqo41vWSMPqZF+vAMnOtH3r5Qi/uIrC77L8bXQyceEp12zhpGL RCzNEyHnWVrN/uyJJdYYvJITssIWQNBemi2XtL/qHeLiQdEEyVowBEcGr7KBCsvlt4l2lNbOL uvH/UJ63WEBqeBmQwvKKfuAl3c7L9iJeYi96R7J9bNnpSr6KF4CAlgiTcpqrSPOXcBBtv4nHe VHg1MCZi71bPuRvVVFkrHpQUJ6Sb/oc1TKSl8a3iaIIbfx/+rKEp8MPYGpZzhLxcBSkyKG0pj DwelDN4pQephj7DJzky4shMPKGM7UJdAMn3OP49mCfRJB6ddsV+IPu8EvM/8dweeoau//79S8 VH/4sVJ+rFrQsNlCo371uq0k1TlI2SqmY20TN75Xzcr1FHB0qEXIizpaPzhIxIpi4NmDWe7yp fPHWXiDJl0C5zzIunP+761/lRRlVpyaY+MW38X8QXwspJDh2T86w+FJGawK0mRHcra+/FnQiX 80U3/YZhi8DGeNNWz8bI9YTvehaIgvrdI/HiqtUWtkWd57fsxL8z0cxI+ezYKyvKnd1UO1zd7 2SNbZXR4tWQLvyIGL9uCqjGCAeRdhQ2uc6sRSOly6mlOmRVtXUb7Ci1HY6zGc3oKp3bQO+xcV jFyIZU5Ec8yGsjhyDzFS5nzEY1HM8pG7PGnCDaag/QNN5B1BIItaIclkT5gVgHwngqintvyVP bqD46QtmXWRMYQ9NfqkMlM0bjvCKHjPxyB65Na9+ly0IoX6Vvlu6c5dzMBUPjEepELKMbXTrB iIfOKVYYf+ALTfHeOSmtfGywMzrqS0hWl6UutRB8npHcvNc+tf4oxW+hp8Zz/gc3lAsCZWuqE vM+FkkToKejmKZQGFjA9D2kJb8EoyLD5YIn+z1ByHASCNs/cex+nNYNUj3EjtU5mKn+LNDuLF BUg43Yn99MGmjjUqO866r5iljjdyzxXIZSjqDIQZxPniN1hDEON59MEJerDGp6oPEoPWcse5T PnRcCwYghXYoL072C6kFuzuv3i38ODsnCB8ly5TJFtCvbzT2PIH4n7m4FoHHAFbM/1btRj/Tp WWNTklNvRruzRFpvoqtbg/U/6obWPtyVyioW1hhC7/a3iuCUSiZMAGkKjHQQOMLV8y4XNs/7T EuJIIw08eB6pxzYxAg7koUwtdRQuhUAbNR9pffYnlClccG35aKxO/hhxBZvcXpTnDqdlpQNc0 WQsNq5KAjFt+nDLTEJ8JkRUsz6kpZbDIuEMGl81XwH6t2wfpMf4MOxuW9N36Q3S4/Lp1g/oN9 vOxgRqfQLOkQC1Pt5AlN/MLI4eESky5JX938Bx38Yxdsuf9hbygqR+Yvi4AqqH7yF4umspdji PfGUdKrp8N9rnfbijfM3B9Jm7YsmYLAHASW/k/CvXSpEe315MBw== 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 | 277 ++++++++++++++++++++++ 3 files changed, 291 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..4544ae453365 --- /dev/null +++ b/drivers/platform/wmi/tests/string_kunit.c @@ -0,0 +1,277 @@ +// 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 + +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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.22]) (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 7469E2D6E72; Sat, 22 Nov 2025 20:38:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.22 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843925; cv=none; b=k0cuLYSnqlf9gAwYlxmHfmFQQKsR0/w4O/VMaAJhdMu4hHw4mQMzLp5wKhtkBJxsn6QmA0L1g+QgTrMvZzYprgHonOwiqimMnwZXiAD5J1wWS9CNW1o9lWW8Fo/Njekvp3IQx0Je4RrQzbr4BjH1xalJm5aVXX/h6vQxu21gWkI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843925; c=relaxed/simple; bh=xQFPf4e4pS/ERkYL/pEVTkOjn8tcKqY6C3zLhawflTg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=SQYxhhwMrRkqktyomgJsoiA0YyDgTqoveavxheeaMsU7oOkq5TqHaBSTCp2dkRBxawWTFuG5kwGsAPLDU9lnQIEz7uSVvoKa0mwzc9vM3Q8duNxDXXZjL2e4ge4WlhGP5hvoeoIkBm3unYZI6pqgEYI164TsdQve+gird46AgSo= 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=JYD0D2PT; arc=none smtp.client-ip=212.227.17.22 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="JYD0D2PT" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843914; x=1764448714; 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=JYD0D2PTaauk8jMbnuawn78StUD1Fq57rw51PmC6ZyXIhFVX1WwpI2jXiwwRZBKr v1jL5wL9iN1oZw9LBC1w3gEXeEA51BJaEM+HAaYdNHmBvtGj3qr3kMpHMjMDw1OZ9 3rjzheCwAyNfXONkE7qvEQr+shseIiwmRCAov7g3V/+MNTNVJjSbax5sqN8IxoxKz XjNxPnhIqC6n4eq/bpfdC7vPfNpe+P10HZ8ItFSvY/SNoMz8Dng/yrXreOEzzGGeO wydGYA6h7oVUITqvpY2XG0XQG7Miza8iFcBHmkJKjOWBgwg8vB8Wx3x4MRsqekRtP bUBDTdyx5PzvJe/7WQ== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx104 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MkHQX-1vpwbj1awL-00iCOk; Sat, 22 Nov 2025 21:38:34 +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 5/9] platform/x86: intel-wmi-sbl-fw-update: Use new buffer-based WMI API Date: Sat, 22 Nov 2025 21:37:59 +0100 Message-Id: <20251122203803.6154-6-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:viJsEIOzVESAmuawZjaHdX/MUEadanGIjLp7QiUFAxJlLaJpQJX LVFVThEUZs31TnOFS3U6Wpfah5UGlfppJ0wtAdD8iuBIdx+sTNbqd9PUlV5m2GGKScPeJG4 M85CyA45uRj19C9jUyxS87+uhuu0lR/lsOISaP2rRLCyfXYve8Qs3hnXG3bv2MWxjh8YJPV nICr1FOaSPg47bzIrFUqQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:DqbXuNA9+Ps=;aAZpP8Apy44sJaCtgTHQZRM8OY+ wsVG8ZT0TULfLuR9L9hmMV3Q8Bek6duMcm5oJcNRadSKT1/iQCbXDOpIVLYzfqM6QicL+xQzf 2TxXWRF1SDzE+mupxcf+3wYdOUbZOOQQi5QicvN7n2K2ZGSqMGvT1sIMBdK870AKUraEZz3X7 eI61UcVJfmZZDHn6qRQFy+7TLtrCffTU7xq0HomR3iV5PIpIj+Phgb4zE+MOrlUnPnaAGAKFk zsAWXqM0XSqa5jSjOXKf132GXU67A3z2D2HjoDEaU6Ha9QD7d0tgGPddy4gcqaUE+Ingk6CNc VDQoIRrJ7XvCxw5trtmRT2C7Dp1UGGEFWWDZkgWWgVfRC157ArgHP3DRSCGeDrvG6QIKgQYiv qdwt/sRNK7z74QqhCiyOBQGDziYBlMQsYlDNRVxS/b+73cMCvToUh7T96GgWXaTvS5lAHw6Va brmxwV+2gL1zfPu22msukSRSUoc/bitqP0wAZs1H3rdMw5yLTZIIB7vF8ZUkv4vPiPGRlIpDP QQ6Tej++fvLx9nCny/AKaJ/+dCeiPNSVM1PJmzc8HvLLosrpG+K1bXWR1SpQw33cYKVmIXFZO pV7efztGlGAtoVFslUAmFNp1eHN5c3gkh94f6HceFm6yc9veJlK9JULe/RJfAM4sk6MsizME7 yGXwdIIZOGgkQFiO5eSasLe3ZJjAwa+jvsKt5asM0eInoMevApO3iNP7oG8zPHvIGA2AC7fyp qbmtXSVt0vBNjJVXe5kOdASITSVyHwsChEujjIrDefrhQhf1X/4C3rRVLyqHSkH1i4rK23eK2 LmHdfQvmW0eEue1bmMwlnP3cY+MOlFmFXnIy/rIWoeVWJU4KP5ha8ZhulEhWSTgkU5h3+lNhl H9GytKbMthnUrvYeTxuZUttwSvwANDVPIGeGrc8shJDOqz5mSor4B3XGe4GO9OKt7IaiXg5LU eFpotInTsN5xtcrARviKIkzodUhSho36O8o3WfhcyYCnPmpBViB9mBeMdBxt4AkzuUpINx+Gy hx46akjxrIOohGNnUmlAghgEiwT24wDD5QRraw+ANAVCkwNbClmYG2i/Q63SqIEB48MW1qSXb 7nx5fmRpj4fZaNH6WErBp6si2nFIqjIHKmcC9XExJsqisxr7PGDXH0mVdGOif9dCZKFb5coMy Mpfd4Rx2/53gjXP8Tal0+P5Q7z6BnemiomOw3rvLkENq/vSqZDeZmfacupfA4iFwgfVOFA5iF 4BObS6i6uI6cTGRDHtI1X+ZpobajNvLN1p6z58USNaaWhWPxjiZzHhoOX/9UYlX8eSJm6ffXz 1SrA//R7jM/qUIOrekTNX7jOaqhXz2qv2BYKt0eWKOV3DDS02YiZ6wMTBXsmozyzR0aumgeTE va0tOy2TXwmQhs2HMW/CrAzZ72sQ3NMI0XhV6AZ25aDPFE/XUoDrHJnRgosYDUP/GzBek6N5L 9J2kxDSXFRwG9q6dGVbM/rjtbjxtK3wbZ5A643dDJgDCsGen+YhGMvTf3nZiyJqDowBKdqsOc 80Yw9hao3xexneGgJJHPQR9vMfg4Ci3czSgPbUPndVFNyRt2vvn+BmTsM+NMvaRhkJZPnjPc2 /2TK0zU+0DgQKti6ij6C4YbmplQ1+g1pJK8UL4yO2UuFIvjJ8Ur2JfLGgE4cbDQC8Ni4Hz46a wza8e50enoSbsOvdqYqDjYMesQO7VPhtUjG41E5GnuhnnQHm6HGtS5AQkig/pzS9FFhMRHySF rrc7GXwBxLiE0gGOKoTZikEdGaBMc8iV2359ujgJcEZD56/+fjLpy2g33aHyHSJJm3tQM8BAF DbmXkgA4rLz+YxdSARtr4ZWYc4Fti9RbMEWhd0FPqWqQPx9jisp0X0a6FgSivh0FgpKWiOuOU 0UoembuWKa/p0AwS3XO9OpyHSlZO6N9y1WraXiZOAGWxklnO+aM8u22nTDuvHmSMYQ0OncVdy /JxbbXZ9gCb0DBIBXKIBICPVTr6sblGmf6xUgXANe7dFLOaxWTUeyWWT9gWhH2AVNVF2y+BaW ydpyVYgFW20LYLMbk+0U14wprEyrGWY+AcY5OVOc6jkuMMiDeM1OqgdVwQsVRF6CQ4I4I7u9V 1yV4+/sC6f3e/5sUasd+PnX75Y+OGAGrDDUCU6xt6Bo9RInn8cYSvMQGir8t2x+6WlWQhgA7m YqPSnCidAuXMU8QGpLbx+nEJmx855O+wPLVht+eC2BQfiAsUf0j1tm9cOt5Sx7WHzYdnZkveF s+zVfk7pnN66h9yX02JsHaYfxWRTIAMm8o/PQ/2uoBzXht0FmFReqdjSASOqcTw4vjFGGrpYG HREWaW6cl3sZz6ky/QEboFq4vD3D+osAswEbxSYbZOlA9A+C8qXgALTsisytEO4CGHdpQIVyD XmMW3YZy6RnN4a2cot1msWv9/olrBc7ko3hjb/gup56pxUkIucWBnlV+Ad43KqHazTMFnslcI XZWjl7TIee0l8dtjftD6TdwLCwmnn3CArPiV5BBbYEjddGORgw5bL33Dq3H41EkA/w63QFKg/ mcMmAib4vwqyWSYy16Q6UUjdi5U+AdXFeaYWUXoLCYwxxOdJv3ITS/keAL4Onuym7v+MWHCeC nP+lQiRq9qFx38ncCzp4I0hJ12CsWHXl7kmSt3lij8VWzaZyxCGTXq+W4VUrYUHCTMAOgDDoh BQaFP0wIskJBImh9sNtar0mT6z/mLQtY0aLIrep3uXzrJhsUpm2oUwFv8lfo7Huxndr612UyJ M7qiRCaztinx/qX8i5+GJqMzNDdRNJDogm6KsmqOvz1BnSQWPPnSwXsmvAKg6Ka7EoF3A/psY +TrJecIcDw8yoFXhigDlTNCju6X/nZvDB/koH4UKxfnK8dVHwbvlOK76uzmRCXMfuVwFKG3qx 5/gpBgD0nyLGorpqvKY5CDhP4kkcJBd+jA5lSMIAoRnUMWR95a/B6dTufRxVzPrUHuH9i3/1j O+5a47FlJG3wYtkIbRew7h35SV/5EhmsRV5XfMqyII3XYj+emu5OnmrtITmOIESbveKt1UP+q h6KYZVfiWwU70Zwcnx29Sz+jWVfTztwmpklAwVwRymenLirC4rp0hKu6XsdjbW2T7O/n9eIDb SwFuO5LBaxDcmfK3/BBYmnQ6jfmylUS+sE7X6wIeYSSf7azdAqhnteM3oG4DFK9uzvPX3jTUd 3znu2g5yPWWNVga6jNLeU1vy6lLuK3za/Uo+9NUiXqpnX8uAqgPFw4cLmsrXJWc8rWtqXMtG5 01puYjhnYvbuxbJAA5eXS9JPo4mIozlFV1yv38F/6DjJ1Er1zIWB7FMjv2CSngmcQfcJMmqgY UCGw56sUXgy2RDXY5v4i+33JkSGJfPx6n0/fxR1mfDsN2kS06/iqKFwkdoJvJjWlemXWmWJWR Bnud+q547wAmg1ubfuJ6tjMAIeNmebvWksJCikrqzINjGJUutGiIMLOd0nbuUhZVNN9xQj3a3 aC5d+B2VSdcysoIRKXcbLqkTMAD0t/aru16avIsJnHu/rtrwsxo2sL5P1JbajwZcIqqRh2NOC z7BG6jZTMzsBrTNChrfxzNM7tGoBvTf1OKVKyZXp5tjSdl2iHkJpp4peBNQB7QEdrznN0TwQi 7QICgW+rhVmli5et+ClwFOyAJrvwmmgRxxdvUPDhCn1OggZMYibA/1MTJcIEOWpQyoC2mm+vJ eGer3OMy6EdZYS0wu5DmRjqDTLj/ri9ROayUEcBB3c7Ckkr0BXXLf/RdQBswqg2Tkj3YVEo6S 0EGwQr1dAQHYCeQ6GjgtuHQPreGg3Uc5kfivJ9gFmhiHnUwxZTVoWmfE0JcmP/boOOZORyN+H XrcBnvH81ie3xRSCf9GYPC7Y6SK+GcAv+dIt03iEZzDkC/PIDkw+zK0IQdlVo92POtF9Nt4lu rgr2buEWfUKYinZUDIjXdMmP+rMOdP6u7T0QWUu/S98bzXMqpxsWRE2hGUckuiecSBal845EZ 8JmM7QaZZKj8YEOB4o+nGhNLgR+23J2aPoiv/hKPm+mqtINKSOohXrNsZKGuG79TTYTAYkCBE yO2jCi0xSkRHR5VxoTUbSne7Dlc8LeWVseULVMm8qCMsu3vag0qeJfWGYerBR4/vdbyDEx435 BDt+XpxVb6THB4JnBmtnsCGuNVgIw4o2vjKHPWLdVdnPSRBAFj3IenNf+JmrS9zduPC4bNwh/ fsxH9Pwf5QwxjkCOLhDAklSBVS3KWc4T5ZqLw33aQgGsXUfvI28EYPlQD3xcOFEySQuUIS5zP HK7RQHbcDncJKsmfmy9Fot8j17MrPto/t7oyq4H6M0pGcwUUtsgQDGBZSgjBEEg3m2a0KHHS/ 0fJyawq+8pjw/3IGHx0N/XOE6w2YQ9wpY0wV5vMurH5uIJA6Wkl75S281K+XdJKDACN2UBmA7 DS3Sf5SP7ZztF2xBvmItXbPPe90k8idSst2leGQ8Cs4zbSk7yrnkZSx7YHPN0Ds0QtPQChb3x gm7H2fmojpdoAx38xnIFO313qnGQ5MGHOeG+sE/Yc5TIezTra23zDbd1OvZnWwnPyYh3YIfEd i3DXJFVNo9SvprvR/PKshd3XNehpxaLwzOZC7TChk4NuQIPEyFznBGZwB3dXwUVn0T1gDHka/ c9C9cZGjelUW1bpAm2F2pN8T6TBiX5dCUx6+byd8/0EXxAV12YrWwzvDtwVRpbINv2VX8YAgd 44uSCHU09qHQ/eg4n2cVKKRwDVI/A7uKWSGqjaZX/LOFSuRldKaMp9IivGBw2R9Zxo+GOTfDu yZBYhW3yV2fZ4PZdwRm6BqFE0hOFOoEYFxL2+sv7vsCUM8j268ZG+PtEyaO9eSSxknx9PcXTt Uwt8kCrNmw1JiGfBgKRRA/oJniq3cBLGD2J/212t/Dia2DaeUT7dVbcj0V7r0Mey1IWXXfg16 u8HAWx1TmkjM1vPp2wPjS5Fwg8X1tMbLwNyWo566aIz1QbazWq0KaJO28B2aW4NlprpzodOxv d01rSa3Ps7TOkkrbfJKR4B6R7Zkc9/ib1HvPLDUF+Q/jDLxODbmAZpnI+atw/dg/QgxtHFfIt 5O5mcj/9GOX2+rAY/R0F8MYPCCLkK7N6J8+TvUakPHzqCBHAD/UC5VrcM04W6qdL1C4r9mRbA BcxK3nH86RK5qJGAqGUJ3upENR6gIH2B5x0UP0qnpqapmTsy9wKQwXCbWY3ZhY5S+B05CB3Ot 3dIIWKmH18Xk+ISJUUuev64tti3+OoClPNRUTa9mCSnvsvBz/VvxHMC0KGijfoKYgjdsO0Wg7 01qoKxo4Xy/6LeICrUML2yVrKIt67h9W4GjRe6sNpnI5RbXUjv863olj8mOWgyI= 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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.22]) (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 9801A2D7392; Sat, 22 Nov 2025 20:38:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.22 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843927; cv=none; b=a1AR0CE/CS96OAAptaSX1+VObIL2+ElO6xrOG3w2V8qIDrgf10SLTGH2lhPlNaEf3kf2Cs8ujJrQoikCfLbTNHFAKH4c3wDzg0qvo/CqoaI3XdrD63Ca2GB/DKM0sQRbP7PNfmsZNZVWDZK3tJ/p48HTdH0O7mc41uF4V7rcO1M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843927; c=relaxed/simple; bh=TvDAHqOndFQ+sdZIj1OoGw4fU13kcnFTYjuqXVcz0M0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=IbWYfqw+ipUsRG1Navh1Dpa92YOgVTcMPHqW926eawKIQHp6aIoNQ4I0KCH3K6x6t1vAVgIuO4X/ic946YdiIFW+PvcZ92i9kK2w0UB5dKQEWF9est8Uj4YZp9R3L9NOKs2yafG17EpygANeemgPg0piuGjtVONJ8JxSqj7Xsi0= 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=afz2b+po; arc=none smtp.client-ip=212.227.17.22 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="afz2b+po" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843917; x=1764448717; 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=afz2b+pojAoozOVD/WYzlQw+OGs0VA4nZeDmCKeLSjJg+vCvdN96LQZjAv1uhO1T 600h/+tM+ZkLRv7OZrr+6NF7k3/K5lylEdHdfFVjeNBwXwFDyNJSTRlNYlMGVQhSS aZ/3wTHMUMB03seXvnTGrfKz8W28MR/eY3H6qBVIXARABGVZ2OkLDw8lD7jnIpREd 2jw7uS2nKezBSe76513r4mFKx/d+RU9rwlcWDgomZ9QLV+GLz1uK1sIZin19eHTcN h4U5p/rNLLYDRWqqlJ1V6e2SuCrHgexodjLFbLGZNIMzgu0ZtlUrJibn6cbb5JnOV by7VyOwq/BMoY7CTMg== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx105 [212.227.17.168]) with ESMTPSA (Nemesis) id 1M89Gt-1vR0ql3wgN-000CET; Sat, 22 Nov 2025 21:38:37 +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 6/9] platform/x86/intel/wmi: thunderbolt: Use new buffer-based WMI API Date: Sat, 22 Nov 2025 21:38:00 +0100 Message-Id: <20251122203803.6154-7-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:6Jnpu7dLbFY5hYtaahzg8PSXU7x3hjygRF86iyhXdyDfQVeqelg JE784oYUuCY8kdLAdXnqkxS9tnTOvXM1mBfpH8OlaGS5hTNQZYURtdUnSqpU+alHna5bXCe bF4PCKWMV30+jRfDVnSAxUlHAYFNx9AXzfWNYovmsAYTXz1uoN2Ay/FaDxPOguWZwZSVIOl nkvIUlXjcQQXjQJORZCxQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:fU2oyRmqm8Y=;g4sTseh6EeLrsnJsVozEWWRBVpJ QEDntGPQx140ZYcbfgiPwedBRNTHL0NzJtLcMQh3kr0gF9JkyMETj/o5SlQ2UPx8UNXhvENl6 QyNd0yh8gPUmeAZwDvgvpiuluMK5ASsFOa2QHhjNKooUnhDZqixWQoLOclzcsNqgpakmBZNnT QVfp1mu4dS7bGaE5cj+6dDXPVweWnSO/0fwqE49Miea2gUT2MwDCHJb8qxOShp54xxm42awbQ OlkiPeHNm682Uf3LTQyPvyEBqYlBaRzxPMdf2re0xd8/AXiqUl/AHSBdDVQo8+tHSYzmDkV9y Sw42kYRnYKJJkNXL/EmmMSPwA2CO7Y8rBuBu15uSxz6EY+nZ8H0/daBr2Ui6pXBZ2jfs/z/MO MwJvvMUg8qsughf/vJkjvgRRcrvFPiCuuGtGjGBZy73YTNMwDtq0iDnzA4VEMPco+eDA3yRrd K9EKYWYvfuRwS0XwvtwXzRL/C4vmzHTZS4l/LRsd8OU2PJXB/18WWD5LpRmhPYQ8Au/9t0mga n/SkQzm3zH45b4Cr6SHjw1xpyV2UVGGx8JrIV1FpV/Qv+aj/GMIiSnu7QWz0xfakEary9fVLw qCPZp4MsWyuYktzVPq8iwHUk7Gzw+fpgdqJjiAW9h6UeIWfBhWoVoryq3aINeYGFNCDdE1LSi suEFqgsDjHmYwEYjY7eawJLeEIpoPkAxVVE5NN12xKC661rLs0DlNVDdLOdRWU41q1zYNL5jA 9ZrAqhAwN17/8UDRDqyjdRP2hNYAduAHoTetf/H0H3l5IIpGLMI1WctVEq+c1r/ldJTG1HdzO 4PmTIaZSNsQgFiqN++Ej/gpYUpV+2CmSW05kFiNyyACN8NuJp0ilrASDWt3Lezrh/q6x4FnF1 kORs+OgceznjCuJVs2HANJlXR6Zz3v3DdwMP0/6zsLZx+XRnJ0ai7weXdSaGVBeIYDGSmXlIX yGH7I1rX+ysO1GbqYJYQsE2glzTkJ96SjSXPUesqkGTkfAuxH7hDHFpVHbcO2CBMqQ1uNNRaL pq2iAMv3mqZXnl88me8aGNgF4L4my0I+hJ54+EkX85pAz87fKbHeWI4liQkwfd5p1AZ2rCiJ0 EqVjlGQJr3uiFFjarS9FD4gLyaV4nsX+vPD9PSPSMox7faL1SEMEJoaZk5pw/hKIIAYKM0VmS i+XpSHwRhXM6P3kl+uGpBStnRatiOlC4lX1RJs1zH2koutUB7baCwSVMqyx6xCVNRPYPe43eM BDQ5Nst3fBgjLlqkFTqqE1orCtd78OYwYmm6J55g5U/0IpjLbWqbObmoUSRlRtKgivAjQ2lLb 0fj8E2jP6Yvui2PPc2h9Pc9WGcijwDT5vzRBbnOir5qhNwUegjTuAWCWForSfsANOvYt84bhr IzkBPO4Oe3Ytxny+V1bCAySmRgi5Bqa+oS43OKfI6Wcsm6mX3xKeLWJLXr5/oFZ3sDOWeXexZ TsYN5MA/PBO4REfooGZDgAsKjFuftLZUGm1k9sPLXWM5j251p3uQnYtE2E432zD4O9eGGgGek /eKlCcq92JPfihZNXkrfsPijHt5p6J75KbDOgd9LSltql2P7DfYlId0hWhvIcTeOnhdaDgzdG tIe7o9WiNzkF1OAPO0NJKYl1Q5sVATq4m6HjQdobTGy04kjZDbRu3Rpd7muC3lyLw7UzA05O7 29J4w+H5PVLFEr7Dd7tPwAGekEmRkjiFztcD01wH1xkZdJKrPm3cP4qLoYEWCaytLvvliq0VL hBSHDwr3PNf0dkVcfgBwFv8HAFzjMbVlcrL0t9LlP0d2UJk/ilrh+bsNIqNbUXHCyzVAcWQGH vlcZWwQesdIL/tv5zmYUtH72GGzWZjMQ08Lf+MCY0z1i7D8y2suZrJQ3mB/KABxXIrqYOA50e ZSvxnqQ0InI6LcX7yzhJtUTzSWCL1T3qXh2te73UsYkDMgAmLeMZ99CZfm5bNp8STYzsOC9Bd +mZQnmZSTg5boXEiJ2tr4COK/aHLK9r81ntK3ng7nkKchVVV4Vq87Veg6UT1SAuYQC/rRtWmZ kyIcQ8QIPPVTkhrvHprgzz/BXcA5rUxuPtlf7QwEOnRuJJ5XdZ/FJKN7IrCFSwD5wPv73RWri etl+jl27aznYdaR1GlCIAcTAPvOm3JxNaYWDm6lZXRjq8LdhS5bQwHM2PtrxaGXwOpgHtgzgw 8DwCUwXfdkK5dnlrNLrG9mxk/pCZ7hxevWexH5qaYCbF0ZQZ+4THE8n4vs3Dogu/X6/dhQQ8q dxorcgx3k3d2Dvsl67w7P+/wHH0Dc1vtKCsGtKk0KzxQwG7X/biDG3yLYVMFTdRkEURJu4jCb nsCEIELYJK3GhKAIOaaw8f+3E7jU4dmLF/lvpPfaOH4zNIn5OUqtMEGHcI8MqQKyteKu3ZWnd dggONA2HobyDYJg6pZoSOQFR31tDGOlFaBcwy6VQMyGmn3crlh1URFCo95TsBCNCNk5spHxBW WH1i/QbcfQmWAN5VFecGf8horhfLZk5DheHIM9JTFlpwLsWC/FFPHTKuebv86WvDIwz7QdRhs QuWJVVYWWRPr8LR/IyzOIvcrCjRyFASDLqDJ2OUB0TqMi4l0a8ij6/R4yJwwPkYlQ9TtdjZ9Q VrgXq+QIAjZAjPM9cbB41M6wkzKjBEnpVw8y86gO8jXREINb/pxOPyjFT8KmqWCZrlUEndxct uXvQx8R+RsQrZvTgFOoakKABv9Djk7wBRYOCxt3DyGjwEknV2j+gtq90J55bN4dHtHqI5oINo qS+WtExk9OZscq9Ow8zhRnxRhrgOWOtszAzCTkyU0cscWW04CcL6PJGeDMDSSmXlVyj0iien7 xXt7s3b7GFgn2pcTbZwzxrphx0doaPrjFlwK8FsOH1XRS6x639qRg9r5MIesYkIrZYLy76keP tguNPyIUy/Vs2kP1ijy0zAeqMsuEDUO7EBj8541ddeEQBD7PZ8D9ikRODNB7NNqc2PxFWsBhD MWLfUDp07+/B48zhOGYvVy7JMw1w6RLQH7kkJXPLa+LOlFvFyGOuw3cZBwUzeqOG0TbSRG5VK YcHe2xUhq3HluICYYWAARsZlij1nkX3gl2ANAxypUTseekVjLZ0TaDyB7JNcQarUrFvHFRfm2 HOYLBXw1jZA2+q60Q34b7ethHzgx00FjbirxX4CIqLtleulLuYl3S34Fhr77bNDUq+T/f0Ams HkaZ46QPW1Qh5dZdy3Y9qrtwECGmGgiXozanlo4Q3FZtAOWgpgOfHOjkjfffggwfbXkh+Lzw7 62t/1h+qHgHmcdL6KBQE6bwuO/W4RIX3zITLdzHZGJPM1C2dKdMgKT4VzQApzzQ7PoyFZii/k 1LFH22d3gPOj0s1n3lrAU8LrMeMbls6MOxsf1l2NgouwNV8ViDLc157/hMJggiDItDMlXhERU yjOaqFzLcRIu+yXoxQiO3ZnlQltSQTkHXnRZ9m3hN5g99jxffGJcfUXIFZjkHeUpkjKJd+d7t DaPSy5erhhoEB188LZnTxptFGhbVXa+dkiaco98g1xjnVNjm62o9nXAWmh+lWSrI0mUdg8vqt vl5cx8xrIX+3ISSJgblaX+VWr6KIexdnjd3A0If56PBWiI9exg68tsemp2Gqz8Nedn0pwHRJX KZed0QP49UdHLCt89nj4t7Vq5nu42lkUVBCeMp0giw5g+ipU02WqHJgmNoj9sZhIC6PbBeSgX fV0uN9rKtdc9AZ5jKKD/qugwM9QzIkQjoefqSkR0HRnEL1U6AeUyJNPDubz4r8zy9Wr6tu2RQ yrkEU7A61pO+4jO4UD8BYAGzhBOzmC5zFebZ7OSntUibIuRzgWyf9I2MgXkzq1C3bTvGszwAJ WJJUGtD76tugl9rzTthZfdL/xoTmiqcPBM6a+Dzp/mY1OdhMTsHs+1qnJHnlVNBBlpusqu0ET WhU5f9VcYEL4ISi8c5nTVzQJupWVW2P22y/nHF8ka6aoAoV+oO+rlrNfmhdZTwdcYtGhJsTsT DLgoezVuQ4xxo+FJauf71M7/qE6DMq5J4p+clx//wdkWAK9N7obtMKhJYnWQHMmLgoGYVNvRm ieySZOUjriSzSMZYZCkMLya4d12Id04YmKvkY7CXfZ0wNK5NclUVJQlJ1WnoNSl0iaSIAAPDP YOymlVRICXk3qXUXhKPYOFFe5tHo63qaDubJLEgBgElbtEjYG1IKdm3/U3+Cd0DVFqnHW33al 1NvOVTDW3NaAZPh9rISMftiTvSVxyjMJSocgVmXq5Rz/NIBaEM3DRDldcIpMkFGVAgO2anjCc jH/wle5qNwBCc4u7zqZpLCkWiEfSlIqViEhIQn0YPEOtxxJ2hZQVZ51LKbFJwGgaqTxPkMqBD nvj4S1DWBp8H+3REqt/kgUKEm/J5+YpiEQnxo0DcQ+hTCB1f59tYu9f81A4VgUVlH6b1SS9aq E411G0ZJzoWQMRmUxEacyDFsarr8gfdtEl99SUrDyUr1vDfF3GiMSFAOZVjVYGyhqYBv4oY10 vZShxU1KCD2nL7yqGrNQW+6xTjTum03kVKwgam0UNPq0B80tviPnUc7Kbtejil3EiAlFfYHiK amfisQWHxmvGeUGa2Tl6sBf9MsL7ZzXJ3GeALJCC+hzvXsI3LNdnWwk75FF3cU8muqnYs+pZk 39AJJMi/Dsa4MDq2nCSVVaH8Ila2i/2cq0usjyzzw0ZfnJZdmeF4EQLLFQyEWnig5ESzCMwOZ +3YTU5lGiSMdkCTRzePcI/RDLiJKC6QK3u+nAdWEzmUwvc/YIos5PROc+RaOFI3FjV+FGUH6E PmrNeOuMc4FU4JIxFQaO95A2j/s79bSKGsbETlxXAluAPOKHgUpkfPlXfZT0/HkA40wORKXMw SQan0x5aMoxWSdvTfqegEDJ4zMhqCfERf579JyTrQSU8c1or462Fa0V4eLnF3eSxQ7ROYYsH3 Uj9uqb1JKq9V2X9u26utSQY6F947nILUCcCMO7wM6wjxFLkn03i1W0MfrghoP0C6snFCCdQrA Zsbbdgm/53DhH0OxEONy9PCUHmmLALdWjw2I089WmUt4JRfhFyYiedbQHkkPXGNKJla0Kf7WS mLMDG8SMy+JHMj6uwVBu5d1SWfVxFwsANdaODyDyRqzKHwGjCHAhWMaoCgdzNh3Yrz3HFWvvL ppQwpttarLYKgqGDYf+6YzOz/8QBlty+tB40xOeLSf59DiICgHWZWAtDmx4KhXVwe/PKV5cYu DOadmKYYKYvoPS/Quv0Kl+QPmSgSV4lDlgoNMKYBYu440KFaAZw== 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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.20]) (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 04C3E2D839B; Sat, 22 Nov 2025 20:38:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.20 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843930; cv=none; b=AT9xfVoxAl+/fhEutziiH3ih2a+4Gl9ccCRoybYQpYweMxfgHV5ydd4+mm4T3I1cyqiJ1yAV+5o9MbzBUEgkm5VLMBl/2AqesKf842DV5quy+HVWmzyc6fwVc4h2RvLPFzmZD9ANrm01h37oGA9JieBGjLj/ZKBlNO4D7J57IlQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843930; c=relaxed/simple; bh=TJgLzTksdV6FW6f/rYwBBRpRBJulZLasWdVu8QXIRik=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Y64ITQHF/aHnKyG/Qb7sjeLa61/1+L4KAAoUnjGSJKmrBXaWnwcDAkWKzMTaNx2rdzGhIsra0KGgU7QCmsl0i7EFQWd+7xHKTmtGZTD0mxHsr7u+W+do9ddlGYUk1jYWjMLN+g/fK1A1DzHHzNVuqfrIMj/SZc/ohBxt/K9p+G8= 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=rcEnFNPS; arc=none smtp.client-ip=212.227.17.20 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="rcEnFNPS" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843919; x=1764448719; 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=rcEnFNPSrFSdj6JLTZFStrd5U7+6QWHbW66vZq88t8vG2MPtdJ/Ik+o+bHc49/qx +t0uqp4U4GT/R56w7da/W64JE6VSJjwJNZDwROnPmhcalS5rOobAj7Da4p+5QDFkJ fZq/jpbdI8lhqx46CuZMIlenrB0xUTfSeTnLQDNpuy2ojk3Z3O1qf43jC+hD2IQ2U 2G9Anth02CgNzaH+z0I2qfxSp7dB7CE8uHSX266uR0ZZT7zC8QR5yKITZBcI3m2mi XA+XC0ik3VHLYzLfxBnX4H/Bcb7p8+EMLS3xmz7aO1TNG+ldhmI4wxizNslcEkXoK CVhK29G4fFvnyX1gDw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx105 [212.227.17.168]) with ESMTPSA (Nemesis) id 1M2f5T-1vPuue1FSJ-007r05; Sat, 22 Nov 2025 21:38:39 +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 7/9] platform/x86: xiaomi-wmi: Use new buffer-based WMI API Date: Sat, 22 Nov 2025 21:38:01 +0100 Message-Id: <20251122203803.6154-8-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:8K5Q700yXDq2bRh1HYOjWtFzDHSrZ97AOa3pRUvLJq//ByQE3DE uzHv963AIbnCTmh+/NTKSqNrqv/qX6aMS+DqGw4esbH6hjTKctT/cYL5K5dLpqLmk6Ay6tQ tol9kgSjfAklOYf+8+uXnIomOoORfMNll50DE6e9iK+H3yMdPvTG+sm5LqKilSTReGoTHF/ sbu3S2ZWbvmH99HNZeseg== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:iuty40lL8Gk=;2LwTf9RqE5b8GbBZjXtpJekrb7/ X1FVM64uSPdT7sxtAOj5DD7pkLLMHCJMO1T8zQDCdhxoWscdDhpOJhHXMGCT1jDADeK5mcRvH 7QJZztN39HMgc4bbY0pfvOz9DILgF2OZYN6AQkfECVUjgnL3NMqmr6+M7IHLQGv/tlou7QdN0 MSPfyhbe+LMzBr9o9H1rCOzowsJngMtThOKsZ5KybW0a4xH/JH9x14UNGnT36paal/aEe5Gjs IRB9sVZHYw+4Mj7DiBnTB7dwUJq+eRdn7kXjE31lHPI+W0PvTMJz5/Jhqh6j+1Q4rP2PHaI29 zEg2Y0j3SFY/VLQ4WHIYucCr7ukscy17egnaCQdKGJ2aB5f8R4cX3ZbXvEZhDPw4v9pSdB2Gm tneGPWp6KXs/utVNX9gfR8m4b476WOdyNMpXxmqMsVX2+2UI+wrXvOyivbBfsrM5Qp92X1eoZ +fpyIGhucYX082YG3mVkN9gnh5MWncf58r8I/nXuCb3+UgFXPdqEkqigXh3V8ApaB7iwr3jEC kwer1vC6fR/X6EadHdv9kf7+dYc0fxA0SvkojD/cMc8/avGXt8zDhB6q9e0QccvPMXLCQmZGu +phwrostuQ1UtRIqiYbUdeW3x5YwhwQRiiW6XyotWMG2sy4UekMCmwk+bx3/anmJt5CV75jhN x7t+rB7rZXPQzSheuHt6AkxYxpuoOmApdY8E/NF/J/66yJHOLkHmjlXXHNL3CFMHMnxLk3LPr a2HwBX2LxQnce3yZwTocaG7eFdZLOjYC4c971unRE1FignkvQQDBISu7w9Ci2SwHpYb3CENWs hdAO5ZsbhvABgKFAVHQnSTotlNVfCvMpA51/acZRpZVeLkfPZ0VjuC65vo76bWGV704e6Kp4M awzHPzvZG/2++Qb0Wrx0nIjE/tZWKUid9Cql0HhF8T4tiRYtRCeRR0mUqsBqOYkApe2OeKElS lWSH+lYXzusrhl9pFLKjASsXdJP5tx4N7M9mV1r/r2Ge3dm4XjOKxwhgtL7SMM1ENzcJ6ISx8 gNrZQhoteTUDvlHvwFHjsU5etggDGFGj5MZtAHnqZdHo84E3Ma87MMOYUrq7+otRVyY5P4DjN kiPDtUPiDTp3SeGvjJkCm9+IsiGzP2M7ZHITOgt6ONbAzapCjPGVYOxqwwAje5i10jhuKFuV1 9o0yLYUi313B0TWPkJlPSYJQL+mTkL38zRPjRYiGJBmaWqXkuPsH4amH7sNzDCU00m9myX/Z5 eD9HdZOUw03jyDX1N7KeJv9y4KFk4254HiNRRKTzb7XgiMDmDRtmYMxv/FxRZRzKu0/nFugW+ rieBynjwD5emaNTWT6hiDYAdgbSxiAfHeHgZWLG/1npa+VL5mPvQAEgZzi2xeV0uhfONMotmX 11dITtpIGso5gd+AxxUUrmNSwUxIud2kgOMlDkD9tcBFV195kBPEB3/rm3iH+uE9PmVpYqBZF G6GRKoFNQncsNttuhOM+bEueWsqy5XtfP2VGJR1k6vaE2qBHRYw7Z7Kf7XK+6CULg9iSD1s5Q WxfOqvsIzfYVOJxDTYLqPVEZP+1lh4wWhvqygpXaRklvk8k4T1I9R1vtRdK04I6CHkSOcw9kR sTYWgqzCOQGwqC1bNAtvN1OtF7nTN2+Eq+xRDchGSlO8y0kK5SixcRzCCcJgyho7uAf5/aA4u c16JVKroYA3UlQteosUv244Vb2SDXMGxOmxvyMfabslSNvof8uTCfNO794Ly67r905QCyk3TI 71ueZIfyJJW/Un21rKL1Fj+4FoTzzyVRuOpu4NZnnfAX0H9PSvoL4XA/oRuJxdPFu6JtyaY6E H2jmnETir+Kk+CFD/v4UvU5pLCt8RFAHlfFU6qA1wA9bUZ2HrYV5BsdxaNo6DAvVjI6x8PGXv 2h3ayBrpUu1msgiccuXdSCps7qkjWMh+/1lmcreMwYRpsaSykNxLLNU4ynUhTOydE1+5A1+Dc 6R7faY06nPZXVt4DHixWINWYlGHTvo7JA4gBqal0h1veN2PochWG8cLYneqGapDTIWb+7PIxY StX2nVLS1VAGT2iraLUrDZNXofo4bB1Mg25fKW79M6S9v3D5UnkAaORW8dKTd6Svv5aAJH7PK t8wJQrLmZGoZELaiu7EdRrQ1TJGxqruTIPZOPBPV4aQ43QKAQ0/eYohRL4H8i7dlyJvRChL+F tQzs7LNCeSRf92GDpK4/bufbAY1Jd0RqiVQf7tjH7ijm54lR2vEDk3bkYWv9p5H4gRF1aVtUo EqH4GAfaPW679RB+xf8ovHoeC7Gu5XHt18KVYqbew/844F6KWNHDFEd2K5q09C+Gen9VEus6S uAnSruvnrXCAaVbfwB6Csj1Q3Es8hLrUTXhWf3ba2kf1ZDw6sA22grFVQzFLd4wZ6mbK6q3eM F9nnl9XMWftOZnH9ZyIiM4r7Mn5BqPbnB+o8N8F8dN+zVH1SHaerIwfsfwNh83y9Q3XA2H7bO LxCUfAycTDOUhhBa7gZ+BoP6Np2KNccf6WA8pCmbAkdjfcrB19UWgOD3F2AbTXRnUM/tOGQ7K gkIrrWxPv3jSqBZU9Sq+6MjJBfyti8mnrt9JsYUxlA8Px7UQeRJAbYjWOh26XRRpt1BWUHYxc kDGiTzlOB9GKtdCz0oH8EJWH4BZAPbtvtjzzQUDWxNTuUYEtJAWskusMR8iJEMXvphoGuNtZA qPMxSc3JfAQBQiNC/tmTC6SnTlKHN7mOaP5TjCzCqAYsyByooXGtGICfibuXCWpGuhSoibSSf 8R6G7gqOb+D4PtOI3Sg5bojEzHru1GkXhA+S6HZnhp/+brxvcvLeFsuegMcOBeyZv6KanQRXN YLYkPz9QO8n9A90QrJCqQOFKij7Dc5Zg7fE5RuY1OQ8n0HbLldr8EnLjx3v6QD3DPGPlKXsVT h9mxBgDtpFMCx/OGKFXwV66+SHW9AQUow6PbxqXW6JBfI1d9xez/C5xZ+hpnpTsQ6u1wHcU1A SKWWdrFe4Gn0h4AN68gdoeuB8Jf36caxZaO5R3wATGEcB90sLgpPBt6TgZTVoreQjCKu0C7To qePKXU0Cx3pz9s4RpIKiQ9ETkgedkoSf8MiUj/8IAAFcx4gKD2l47EFpxdFAEKdLK0aIgw/xX FcQQF7djcqz2U1qiOs6prclq4jqb0nyW1x8rxmEIy8VjAzzmknxhX/6IxuSJWStS9M+TXDe2B ASnNla0dvqlv3xi0aw5NbqKoD2GK3KH6vzkmt7x/NZw2eu/wdeI4EhVF9aWsKIeJ9GzXiLJRm 66rQtUmaTopTfEMIf6pMW0thlJDnedOnb/Tu4RNxhnqEQTuxwMC2gXQwD8QI6Z+JG1xIpCARb poxvLwsGDLHInofdVsWUc6L1EOWkbAxEVYGjVtuLDtdRNoz+vPwId1pr8+2HmEyI8v1XqR/9k mivEUBBYrOc83eoW1ddaUqZCyr2CcTIE5SqYLyZGenP3rBBrzz7IyPmdrsGcRNB56HGvF4tW3 7r5QMFKYUPBXCPq54A7dzqpQEe/trRaMNvArY1ApM9nFPgUCLHhvi6PAUZDOsyzQmC+hPFEIU Zdtza1nlbeWpUxDFQDtxBSd4ijIox/kdGH1v0G3lOFVlulG5Up22PCN4Z1cTsVO/29mz61Pe6 EdkUm8PF1jd0f8rHkxNYzdzU0ETn8iVGHIIzIPhf7L+OZFAiCHXMa02KtgLffIfl3dHpV/u3v DeG61cY0/OqeKBvuMqFU6NVGxmplKdkmL0eEDzo8nWxMrf1XNQO6x76Ur7c/PDb8czT3p1kZ4 6fU1s3Hk32dk6QikHcb69/sO7DGi1L0WFcuzTRTaT/+CneSwiOpi4fjaAbhuxG81E0VQvaUQS PgsFdlRKkeuvP0Exz/xJL96ZEQ6vhOY87BaPdNm2Vt8nwuufFcDuxDL4OiolZOwtdmYVFD32j Ox+Ayb9qlWFQnQS7cmmUb+Uz6p3qfH8i4jhHtlxAzwroGk83BxcWZu/tCLLA6pfPSjhXNR3E7 i7bWtUF5pJt4rq8Y6QvxJxd09naxC/hQT2OuJtOK+PphrAC/rinRbeMaPaXmev6YCJs68Nf7U DeKEsfWWnnxAlQKGMoNrtwreF/WUtlqrYExOT5q5T3yRWqmk0/rVKEl8BrwC+055HZIRuz0b9 xLmHZjK9G5PP0kUhYjIj2bkQfs+0HzdDk38Car8/gfZsFYTFDFZtx4WnCH4XTU9nxO5Zstwhc G/6cTn07Kgd5VovhbiLy/GBHw6Uxs0kZZRVPI7NcDUhjnwBRfgxUtbkW7kmFboDkbV9h4un9l QMjEzjCZvSPSmKFVgznkHKVmxm3hIDuJlNW1hoHpF9zS74zTDH+sAgWO23YvcankCrZYoggpU JlhY1fwR+qRWxdcxZOgyfp4Ztpt5YlRKthm/IMNWjgZA8DlKvSgJ4DHimJZk4jyFrxZEVgNwk Nqj/u2pnSFyiaP7zKkA07JPasA64PkXyVFjq9kjke9bPSdAGHVIicWVB8lUUIdD8MmLpPiJyr ifBYRtFq4KAIV56CmdFX/BK23nmSUe50z5XOI/QiH27sWPkpHDUMmawoHFQIynSZXf/bcJElV gULH2hebKVzF9Xf09ZoCyTDijC4cANTb8XIyThkAo4800Lc6porDdMrws9pwfRws9uKXV9/ej Yyqar2lNCgjsko09E3AuAs1KdyFdVYCChFuRLGwhG0qej2FhBnM8vHcfsbM7g4XyZH500FeYg zlpS366JZO0kr+mONCMoyB5nPgN0zW9yjqPmHjBFvfivZIUKq1R4LqbYEQi2IfYsljh8SUjYj x9Oej5bVShFDxj8d5n4ZWE2RHKDhSObncsMoVCcIS2toUYiedG9MGN17BLglM1qP8ZnIIg/pr 3fPtE7xnzyAMR8KR3fG0SGdoeJ5tW3VPvDhTBukIXZxQ7+9VPwH7xj/DM1M852YZGKw/PY/gY 9HejSrM61RhECbp6Hx3+fDpS2hMgJdM9kZHSRP68A6xG/fbu3HLTSDQJTh8iiL/fmyzr15Otq q5CGYLcdLUOSGrx5hg6L/KX+Rb069PC//0yohUndFx8Sv41fdxj6y64TwfyvS1V+x5Hea4Ox1 5lhFYU83RHNSVK6Ij1H+TS0CXyYYe6by/E9v0OZRUM6dkvneqKF6dSOVkZXtwCglDR5IEsl0L mdq3+RR7GneuiRLe/9BZ9lwB6FxoS+gRuH+E4l 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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.21]) (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 CB05B2D879B; Sat, 22 Nov 2025 20:38:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.21 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843931; cv=none; b=sM/djqk2WeKC4T8YDe15lw2w3tMb/KOS6Z8/tDh0Oa3Kl7MUQpqoCMqv9bnRAbrTjBqlGu7XWfSScEQbpH7C6IY7cbHdbr+k5Pfc3k/xCge6sa1uUoPPi1FHfFxRoGej93twdBoiuBkjD1AqM9QgRJaDKDOm7bybbDjwTMUBCbM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843931; c=relaxed/simple; bh=O8IGx/qdPLgHwXwdToL4OtW7b6tvLndNcTwk+PuIHqM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=N5Ysb7H/hvO+PrLYY7M8SLqeUJCvsFIM3Za7jZY5UuwteIklntwm4grs5HneQGEDotMOe0+pav2kPXmPmJ80rkXVJxXXncI2ZyDxAHfu9p+v2Zg4uWtK1Bjc+1lY2iZ2vnPcbCzAdtUjdmFpsusLOmwf96Od6piw/+Ne0SEAT6A= 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=q0SzeYXq; arc=none smtp.client-ip=212.227.17.21 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="q0SzeYXq" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843921; x=1764448721; 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=q0SzeYXqevDmtH+CBOvTt3FGIharULkEafMKQSbJ3H8xK9OZnKrFwAC2tYKta8nh k2xMeKxvRlOLrIXY52CvF6h1NyPPNCVLFcQg1isK1mRXmBXvaNnIxBxMNBwwiBldI lpLbb7vo1S6x8ItythW1CcoHh4Ex2QEzGj8UgfI+KCt931A40eAfl64yM7Hfu6zmV MfYqFD37Pd+B1ITAy0/N/n4V76BMMdr1B4xD/LA/dixJXTE5mpt8IDfYFeOVi4cKR isOVZeqgu5obpbahXHiAngpNKqrfIvvfj+/DDD009qzfjp0OFIxCVMWfcJJxTfFPl ORaGlIcHQDILYgx4KQ== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx105 [212.227.17.168]) with ESMTPSA (Nemesis) id 1M3DJl-1vQT9Q2jQT-008R0T; Sat, 22 Nov 2025 21:38:41 +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 8/9] platform/x86: wmi-bmof: Use new buffer-based WMI API Date: Sat, 22 Nov 2025 21:38:02 +0100 Message-Id: <20251122203803.6154-9-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:DfwgPnpZa92k7daNkgknoFDP8Q8z5BTa5oeL5rJIFb9jPNdLmlA O43QScR9GWjgrLTPX2vizYa6/VjB7UmGlXCodNCe2EekN2r09SP7zieQpcyPhGzcnVo3XKN VtFsNXvnAbWBLG0Xzix8t0dAH9gafYEGR9vhOPvw9Ntnu1VT8Ls3f8fWUhfJ603TSinxNp2 KwAfVa6NQSpw0XBH7ySMQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:qd1FpESbgPg=;JGH54gvWVyvVsDNDrhheK/Cq+ei WuUm4BDNRK4tqDq43cfIHZ3sbsce578/oa23OFSJAc4QB+5IWyB6S/vlpLB/7CVbaynzYCGpN G9iDZvQtEa1zoR5NobiFVRp+s+xwJcEmHanZVNpiqcGePSARZTATcQnebyx5ECgf70EUWsBWr SvYFI8HNWNylgsjcfQqet6j3GxbhPZt0yOWFZ3e5wcKX6e7IEUdlnjYq5P5XjFoho9ptFNrN4 SFG7yiMVll/fFG2moZT+4azcO+LKQesrIQb2cSpPazVWrWWALKLNibCcC/55YjJjnnJqeFAJc poo2hv4Vr2N5NwGGDTQ87RBfH6mIkL0Z8I+8wQQacMJfsiUt0ZhFwYHi7BbzWy8C1qJGszo/e C6bvz1NvGHXjA9VvcB3gp1g2RqrxyKvptfB42n/xq+bowNlxcCQJSfzBieL7OJv4rtg9bryDL Yeb2z8BaK4TQHzoOwUa1xVI41sKbne3lwE4YJuxltUDK/b0/06jTtqVGT0DP9CV1D/dusUgqi oVVB8FDhN/prp/L4dDYjmM7zytOvO39/okI5N3S5FWnbLDfjs2OEndl1o22zDVDl+euQ2OaPc vM97Sj6M0dOnUfTjbxH9CgwdyjQrDCYxcbiAoLdfk5p1v0nhZXRSxWACkpLQRU/1eRQewjKAu wioSVgO8AiUzdDJMFMRWzMI8Mj27xkb+tZ4aimS+1wIKPsjb7XGbSh+zVmdusJ9ZVrpv3kxyJ wv7AGRdEebxhy0xqyAFej96OtATLjWnPOD2uC03Ps93eurr0XdyPR6IzkAhwCSuFnJFDyjz+F bWYhj0hb2+ntPGFVDS2WaAc5YjvMB0dkQoONe++2DpFFQDjjsa8UpA1tT1+tgVDbmRsZ2HdNU 8vz+uucL3mAPEgou57khSF14aUVQdg+Uq8Mc2nSJgyoFAzLUoUKvJnhVqSkQHy1VCSZmh/4DO qKHzidMwNlZ7vbJKtZ3pWDCSNQFj8AAIlwpglKSA4BFOIbjfpCvj9HdqD0HUubxZxC3WTf9fW McdLmt6WVSIys+yyM0KW7OI1TLl7QoYiznjtMf5tH9uG7M2aH9NuDuIjY9qifq5qvTbM3T8od 5e+aOLA65sIzZq3eMXs44AWvDgTEO5Sv2E6g1xmtb7xa4GxPQd5bYuFHlMyUJkRa1naLpH8Qy QXW1AIUVpHtlE4ufZ+IClSvSjo43Qg4FdzwhNbQeKRULbqS74QBrG/b9y2p7Z83McXFzChjVk cx0jdJ1gtHKAzTozfoCpNXJrcPDGl2GMxzyFeRU5gbEWUYPR4hrABv6KCHlO/BYFutJeOAMzJ P8WdxdjHR0EFhoKASvJGjdWNcB9grdKWDplKn2v1b6Z0r5dC01uNCHHVxoVTPOGRY4R7O5cFx jOIdQwCentGDH/ajMfnepLfK9fNIjRo0e9dQLNG6QhlBDoZeVwbyxGOXHqSiFO+HBzy63qI+Z Y5a6WcrZcS/bJZKsSXM9AoV1g/MVJxuYsIDEPnTqRj0SDqtehpGvF12QOJWz/7zMy2yEq48oT SKJPi8c1W2g6ziQtqqQF/6xZ51dP97nl4ZtL36j5MLxHG7Y9fPukwsEmltEAj24BqQz5iFNre j9gBv4ZsLIrUFQvork0KbaeqbSMpV9TAUQShk/NESl1HfmiyyxO+3ED+jYOG4iGmM7Veg7nXh 67x42WxaIVamfRMWrnFW/SGkx7g8YNPCTrcqPsI8a4spdwkxGTgMhU7tobGJ6jdYNMgQb2RSz SzuXgV0Kc+g9+CAmxQLLfc/6uI0ttDYnNmoXlgJ0cMawOpmrEpCSoozzV7yHWRWtLCnBpWQIp 4p2xIMYKgzv8M8s3ABaiNbYmdiXp0m1SmvZWfUUgBnN45BzefO30pdmg6s2FCFvCAK6ilkpx8 MA7X76Yd3CpqHxleY2Pg78orxChbiLRoQMsxsfugJLOuHcZsbMHURWbmWaKX+CXCwWtd9ctsU wmfgM28aCS8VlZbIN5Q89tYV4HNrQHcTE6UHBe1akE3XE7siEQEZFe0C1hc7H66moi7V5szpA EDdUwClrzTZnJ0iwci5uEjEI8NQA9ElRZzb2i5RreYVY4JpP1fmNFQiW/Q0fou+dMc3ijG47p QSPkYj6MHSdMGbJLpsVN3P4Yqf2Z7sY3oi/GSvzsdCeoO6/sSelAojETYQk6NrDYOGXIsXUOK dqYs5j4W0OnvX727IGK36G2bBFTXTS+9vkQA9SjwUdP0u+Tco8Gp16pTQpZ3JsbtnjcpYr/DO GOJ66PP6XRh6hHBtpWiR8sJrleNNOPHl/C+w/0RoFNAKqPHUjdlZ2txRl94LlRwKdB00nLGBl mqGCO4w2etFhldglQJ8zJMJWbXyjSBNgqjIFWUBK/i1ypaI8iruvHgNT8LVKQErfbJBM6o0Yl XQ19HYbp88B+Ql1J+4hrTiYJc2vTi9eEu0ByahkebFyMQce0J4NHU6FtdUrnhzWchs6HVITnq hT+vFFLrVtlvKhNrbzXFs4ENhpq/SABDTdExktSiu3fuFdQcO40mu7IuxiNl1rZTW01mccKdO tfLaEdP3nmeEgWghAGGxIpzQjOF+gCZnH5LgMJWvVG2JH+br3uLAJgucJTDZLuTV8n83GQxE/ XhH1CHKm5TOL6Tp9MvKx+UhKlYr7LMW1gedKSwx87IlWnC/gwTOTBSxGHnhiPCjyVwnOhrN75 dQtHz0azQqAZ1RQSCxIxkykRkwIGeGbJ8o0gGjkDKRwX41VnOA5XwiFPBfyLeU7NuGiDrRcbd lcj+gL3W/yGAhSFfYhh1i/g/yQS2ZDvMVtbc5hnCDYhyoQ4KIyF2ysZC9FzLq0liErOZ887m9 H9KuEZtdIuhF9hv77S4RGRva0XpZ48nrMPeEHLojZW2BnqZR44wGs0AA273xLazySpLonpcXE F1YCtt6JskD9zZCWScTsjibiCflO8hZgobmmmW2RkX0LZ8SsZzx8JRG1Sh/E+LQnyW7bBA8mv nKCSOHU7gEBo1Jzn+tS3nTz5O+8To3YdidPHB2rAYnujPWJh1SR0UJoQ6YHLk4EIAx/mFhJMv XeevrLKToRJbSlNyPZK1pqYvjG0CNaYSnn9d56G8D/mgoCXfQxKOmeU3mAMhT0LQIM1u7Q1fq wVdMKeQiSt5Yd2IxS57Xnc0xbjEVFw5bGQeu8MsSfzX/ILVKq/ZPIFi09Ddyy7sOVEkcT9qL9 awUzddV5s8s9SWyyDd7mc/kKXFLt58Wq+Va/mPr2Dg9PYWB/ZObxJdBT2tJB0mSwvesAXMwyn uej1B41PE+Eo8a1880hXsOn1uue2am9O8zqmU0Y3svzC+hNqKV5RnUx4bD4od/esvyFCnBfm3 VtE9WIiPyXcEBpcGcN1rdMsjhw6b5ocBG3XHifvVWAwV4AQyC1hpiPz4j3YPYZx1X0zkcaitl P1LmUt7lDyk30NdETn75UkRITp5/mHHplH9/jwIsR7v/CBpWV7EXzLKccvQBOcsEpjG/d1cSx aKGnSYMGVW7W+NPMdUwFfVS+wOSLAkjPo8c0IPB7RAC+5MAXTwPpD6SN6Z2LUf01eunknWCAf rC75OPOmwTDyAMWjnSK7T3bmIuPKQlI2pUfxj+lNEvnHoCRjnPkrqf44KwYwJJ7wa0WVKaOV9 9fXgPn10aBy8Ak0/jIDb1/QOBv7iyHx9xorkAdlzwgD5lVJG7BMxvt4VV4ET+ZKMXELzl8cuP h0bP7UF2H8cjAKmk3QZepyDp/9nwv1eIOBIAQTzloaB+EbSP7/yTspnUm5wtKXbkp1un8e32r XdJiqfJvZVyRID4qlg39Qj/clPiXFia0i5AjqxkKf9Zw050flKN3nQGCgpfALx2oqvgaRsHcw 0GNsGLagDrBVAJr/o/7FxS0dunclAPS92A1YE1lxtK1DOklHKtIKCvzlHDDMhei7d3CwoTC74 4HKesFxNLTr4CEx1GyeDG0TSb4ETLZMdY5lwjeaLCf1NFR4lF+rv/Vya+bwmIw+JNXDIwEMT7 7xhCR5gDHgTwXK77RTSxy4YxLeOcOwclaRD9a2Lgwa77qXNS8JMGVKjMohCNVxh/Z/PHJxa8O jRm/+PLAfucR+xG7BK1UayrcR6wItXdDfpMNz7siLztiqBF4N4C12qwROLHClA3TXk5e8XyNk jKjlc5oDKnS2fjnjMRzbdeZ0tYHRDooo5gD2Uyu0zgA/oHaeWkPF5ezzMKrX9XZ/bjoKSuliV ldgGGv4wJMtJJIBlWwxazJWvHw8qFesrA/R6LuQcnsLa2nLYNDrJlfNFdd/wdZ8jRMaYb3wYp FiefDZwFfSjSY+Ws6AKxi+eomHJ0cjWirEhBYv3pqHlp3F40maOJXDJRpZJv4omrHlasTbauI fUbmq/IqVubq/X2g6kiX4YHklZmJPVowhpnfHzlrjIMcBu6Ri5YhiZdTrD+u7By6tq7Y33bad cVt2niM/FhmOw5A40EP+AWQ2vWzr2gKUNFTiNwzLkhrNPUrfpcr/qcR3QbG0FXsNLNsHJB336 kXM9+y7d5K1TRIDwuxJVA9W455BBRwhOmXFpGl/uDXg4+lkvo3LT/csMGSBX0H/vbnVBVeQhr MQRHFJUzBLwBW3GAPvqWjNF5kFnoXNHtX1UigofBr+f7vddqHRrf8SBctBgrbs2XaOmDJIiMn J4iQLSt6rPon6XvulxozP0msg4jkFa2SvoOmfHdZkSfMkuqJZIG6OnY5n+qkXsJ2d2jf2F9zN kOlKtELEo5NBgTGHH5zBZXEizqngqwlyIAVDtgn1N+/Cx6B0oyBEVok+OImBQskSBj2FVxhtR P4++hdg8MZJYom2HSihI4NSZ1S0qLdicJN7ZdlrDgTLGOc8H4Lc7eVNs1gAib6Hr67MJ10d3A qD9lJCqFzwHof4q+kCpmbAXihW+CIFnIdROGz68l7Dsr60r/W2YAXDoev0BxqeWm5XkJZuA9h oXDg5Ggt97qCa48Ep5kkWV7cbe3ZcG6seyKiej1rFDx1mUGbZmr++/EndbHJMr58kNkyyMV8f FG05GlhrxXbAvGXdMFnUYy9Bd/VZB5W32EjFEStMOLxaKoLbhZ6sNyGYDODon5jsalhBgGf0K rdcJ39RxUwX3C9H+2eCl29SKsN9ikXBlt2tedewnOFpK+8HClVg9bfpPst2Zi1C6W46tI9uQP MA7GH2Pl4eaBDeZ7ssUM8zdOMA5pgvA7/h+64n 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 Tue Dec 2 01:05:37 2025 Received: from mout.gmx.net (mout.gmx.net [212.227.17.22]) (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 C814B2D131D; Sat, 22 Nov 2025 20:38:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.22 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843931; cv=none; b=NylMSjW+2OAYXYGNQ8SxelEUg6bjCHNBrTduK+NbTCX1fjOlrxGiftqYbtoEpcbN1BW8XtCUBdmL1BlIy/MBd9gsfShTxOlkE62mPOHHI/JpgcFc9ulK+FgVav+9rI2KRqIg9BMPc1FJ6W6KD5zJR//gjzxNEgTlEysFn7mlijA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763843931; c=relaxed/simple; bh=2DfUyHkuqLKEb51ARcwC5O6fLBP/HO4ZWeKvEBZVecI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=M9VcTeVLE3zaoufNNdwV7wo4fx5p0vgARvG7gE4gWIo2Ui7fZGmUPvKcx0VM4Pzm/HUOz3kWnXLNKDOAED4CkeHIh26UX3QWrEb3fnFdUMyze1x9foq2YfkyOeTjUor3aIYiZwjLLOo4yPmsfGrYuu8HnCFA9cJMExfeGtMHt8c= 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=B49zNWP/; arc=none smtp.client-ip=212.227.17.22 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="B49zNWP/" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1763843924; x=1764448724; i=w_armin@gmx.de; bh=bfYnzxa6sTlma+qjc+GSsPlCO2sXENhnw7i5MiC+Afk=; 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=B49zNWP/3NhoRMV+mX57jkB14T9fMoGP/pvkIG1ZPKfRLclCo/v2y/SlSrhy7bFK hTI0gvaACdxsiBUGjvQAsdMucFHuc2kqlWPyy0GS2Tjk8NHvv+BAABuyyUAnAtFYy DV0/8O9db5Iw9/fNtTfYroBzJCGUfRIaKxAvvcHAVp/SOVehVU2fpkMbswfChmRG4 tTGDBHkCwM+oVdH99F3/JjNXfm15zLZmucb9KUAQKe3QnhCL5nyIrjW+tBmMYdm96 c8eVAADoZHZq8P4yd284bDjYy6yAtOYPifDMbof8sUEMWD23vEZBQfr86I+6np01j g29JpFREyI3K4pmocQ== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx105 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MZCbB-1vaT1W3MLR-00RAyT; Sat, 22 Nov 2025 21:38:44 +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 9/9] platform/wmi: Update driver development guide Date: Sat, 22 Nov 2025 21:38:03 +0100 Message-Id: <20251122203803.6154-10-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251122203803.6154-1-W_Armin@gmx.de> References: <20251122203803.6154-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:kanzDpoTBZKfua4EFt73RRUOo+OWWArqxAVf2aD/oEo4b1hiT6y x/a3wT/KTT4CSRZl0i5R1S7G0if1oMGNWIkaVIzySD9s5M1wu52exW3J7jaMsWjzEZ9AwMM qqeb7//O8vnFzg66Cz252H0cTaa292XGgAdBNHfoeNJMa6YMO+xUhwsPbi7NIqx0M4FqcvG 3a/g9UeK1dm703QGg9JNw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:R5qILLG1uc8=;K5JPWKlr+PSrVaj1fYC/v6FYog+ +d3m4gJlpNJQ4GupJIUdgMrBOVdo1rpqPriJNoFh2QmrpKdY1JCL8/WxQjJonyNyXSikFw4KC NyoWZoD6lZaMK1pJgBXAjUrzzGZX/vvDOvu+ThuOE95I/XayYIpuoQ/H604nFxn67GKtAtAmy EuTG3/UUTcuDmkAQTcpoMurcj68DD5LMnad900fMJ8IU+br5JmF7V+qUBiPbmkYDNBjuKlTJO uGNE7Jq0EE3jth6IyjrYJhJNWiZct2BUHb8mK2EE5Qn/Z3C5+qpw50vPBDK0kzjw7w+4a0Hia 3HzMqPL0TicxJX+8xX51rcPCpp0Fpvq78dXAGdxcNz1/flQ4trJsq6h8/CXjIRI5OOO9/q6Cv PlY/CETB/O6jPwMCa0Gh9G32HCKpgGi/PhxMvcP4b37krn51MkpUDRFhfLE+qY+ZaMMoly4Um 7VFyYte5UocuCvReCG7E5el+hIukldqC8WaO3qlhzzse9xJtpMlSULO4ais37PaWedMvQ4qdp M7nE9+FimB5oXdtdgJ2CilFBxtPTKij9Of4b8BowbmO7R8XdOocczxn3PD5O6SCYCT0rSbfmU I1naipz4809JI+I/nXx9hSKQpCYGnNEcEDX2MTD/9ugBq3vEWXNsVyzRrJFliBVbioyrRfMMO UZObnx+4Py0u5UUecTWXIePdFgMcJ8o87nq0EC1YlnIXTrdAHcGrFb0N3W0BkrJSMlavtYB2L 8d8pKMCpd7hwXHlQCVKxZsFT7SQ33g8vl2uPa9aDXaCyakMn+AjnYx7Ep4f6d+C5j1KEpbgRv jW+3BpDcHOqXUMEPuKGo4gNLRF4QO7m99Nyc/64tfjD94fw6DMob8sYx3IBiZPebcIQWNxBAC BACmc24WjYhgv5Bwa+7SPhaIhEO09UlPi1TBSAAsG8nkmKjRkh6UNeDTTolgeUJq38h9jJQxI 7sEMM1i7EYYQGT2GxK/EJEkqWOiOfsyGqqlERN4QHdAAA/GY7QDC+A7+hFp234k2BVUdbalGI R1E9dabyO0sm3hcmjO7vyKI7bBSNE8hExunkRGRUm1e3GGFO/yCanVtg0boTahk2V0numq+Yr IaTaTVqyJukRRhzmU9ip9vQJacUbUizyKuAVQ/rfxOO4CNI2PsMLODHpZONrp22S2EwnBa0WN gkuhyJcFYNFm9dFlz3sfoImaS3UomC6bfx0K2btVR4llmi8CqTCm69l0Aez0Mebo8pTlJZmYD Mqn8MuVvXWs7VQRgN0y+yaVe0AU9dEZAEGbkKRjFElTfqjgEJVoNklnvcEtWxzOMtndeaO0Jo GIJvKMi/URbDKwNb+IuvZsAVY1ZiEQYnkB/3beHvWOt6U6Rt6+nHaG98vwElVH0CcbJ0HIl6O Z7/RIJV1ChXqNr6vcoD9elCS2fbS31Q/mnfa4eJj/da8kPy615pBdqm99vDb+F4RpgB7VJeyM PHSiWL0yHMNbCWArUII7oxG0MbXuJ54hqgy3Dr1s2UMkm21JNq7omqc2+B+bsi+7as0ScY8Ht 3t4fPk8d2owZlDXJgI3aNxjy6hOgKuetiC4HAhOT5nCFc9NOP2C0mTzLWQC8zVvxHH1EKi+yT QJje9ijRiiQRHBSjZ6X6KIqLTh51lM5rxmo2yHWb9MQQHCXNRsdSgyTg8P8BEdbF1C0HLGcYL 8d3r9cmQMLNCD4JSb9VjsZ6VYj8YVcl4dWKFm/Gtjy2dEs4sIYQO0j1IRPx8oqVAiVCKccDWw FWASFdsHhVo7Hl2ip8YLjtwMwfFrmibTWMoPo7caWi5O5QwlxqzAriI5ilG7lLIw22eTKPfmG Xx60tYG1GtDcREld9qbHjM2zuUsBLoPonrQnRAqDqlshAOAajdgarHQLlmF179LJ3zRQAFyLw Vo11CcGxWAp1bMRB5SDQEha/QygirqYyo2byn5RhI7bJdLpFIngHhhZVAsQ9VtovK1DhUyUsN HDXf3qwAH+VJDV0N08zrbkFCKfJyrzLfq2fOPoOwUC79SsqO8c7Fwn160VptczozeWZ+RkVBU lyY9JDnLk9UFY+DtXTq477a6uDwBHAgkiL5kTtBeSui/A6R7wFKBzC4hyN8iy3KN9l9oYsgYs 3UwP/E7CgVs6onQQKDXDy9TB/jr0Eung0mFqsybaWMDFh0IcceRZK24uD/jaBl5ZjbejDUErz 2D8HuopIW6FccC30lU2XZPy1lkGmgDJVYqi9iV/Vhd74GYttW9EsqGuZifSaiHCUf9pjbx/K5 ka7reRH/M+dyiseN5VTiM9iBJTxHheAx3aKCirF/oQAmaKlV70FXVRqJBRr5tWMrPsYORl90V uGsHD8ONUr3j/YQV7bQcD7+rdEZ608IQRgjt0TYFrCThoMc3B1jtogNwgxlQcdWDi6RfoTNtP Dwa6/05Trnl0TfPH1r+xGZnKlmvk7S+kOefvLgWzHZ2HBvmNd++NpGQQSOtzNtMH4tV4TEjXl ++e4CbcPoRr4sv7eF15jeVucA+Vnp6K6ZvRDrI4OrGhICYG9t82c4GUU3b08NSVmFP9qeaCpC RLsPVByXAco3VhVSrps8U1hhTbHo2i4lFjokXOH2AVTijj2OgOZI8HWxb4Lgj2A45ro6ZoLYs MPj2McLcGAMNFs3uEgiuturUZaOvru5sc2NONi9kSB1IyNdhjbN8EFm866CzCxUsjUPse1I6f QLPVHnvh/wZJhMqzh0lpMyouFSek5rPpe+vE2dj8Onkhn8dd3Y6OG8CxRnYL2rkYq/kqRjEk8 OtfdN9b420B9ij7OHT7PHL+xXo3loZDgu2sQIgnxOnQxryp5W/pZXXjH6srt7mFj+kh88N4cs MnHf5+0xYeFajyMyScn5lc72qOw0rwKXIqfvD1K05wIMee/B9ECS9uP/iHhfH+bGbx4T1zJJ4 lqBzk+wtry6LU+5wBybu5Yzg6u3p8gA2e+cNt2iWrNukYAxfGxDrxxDI5ZDXnpIJgB7fi9oUy 1nYc3UfQ9eoGTK9X44WC8qwgi9MvNVLk+xt4yK9Off2h6wSU7tUPvbtODbz0AyqOWFmV/o5uL 0zx0L3yC6UB87MJqrBdw8TCYVdlUg3+4OuTruzzP0JeB96F2WC0c2BcVcLOkpoeWJEnFk0Ig1 eKLzZIYciMPFMuWcD3WVvXuXgUFMVdFJILTCfwGVGQLx84HFYPZOY2pejn4TaEGq6WmMRKZuc eBzfH2YGMb8EJVRyxSwRjHpe+hjam5L3mleascQQijqbMXXUnqAlsFFXsTQG3tCduNPy/6xz0 htIF2i+kIHv4ZUeZrmgbyZt5F2ny6lcXFAHWhErwKK1Zi4k+XoOe9VR6O9f99f+Vlw6yjgLEC oA2n9A7hXCXeira5ZD5BWn//Wo7x/ChpRXTDG5v1fnIaE2qqRKgN8/RpBBRrDVDxeYAdTqAKs lzIeHp2SXk6TZOgH+0svdDr4+XmHxhzMASJwQr1cgY1/7SlJy/G9tKHWk1RCtQ016b7ASVdBf xhPMJP119XE5VeqkDcl81cXgf463YHjXgxkb+64KzGuuV9aDK9JZjpGVxoZSV+pEF6AML5Q56 gAbD3onqbFxS19MhLXcdhlzv9nCpMRZskAB6wBG3zVBMYf7k902Pa4EBpaci4Z8xhyhl/wclz nEe0X0+avtP4WiVjQFOhKPaU9ZHAZyRYoFp6iQfiZmPOhzYLNhICOqlj/z/KsVTw546SmeGXX 4HTCTZgVu/1OO+9lYt8y6SBKcKFw5m8MXR8XMNwxwNraQeKuPtPKdrlmJrpxewwUYUrvJ8/BO eUbLXTLN5qHSCGNGkHHtcLr5IrUGmzDvLIViXUALJ/wpBGGRdjNjM7vJbYoIiD9XSsrb7vE9E Kf1dK4GhmBQtXa2dWIDnwAIXAK0PXW2cDl/7dcPcJbQxMucJqoYG+SaQ9yO8uzjddUAD9zAe+ yoF85M521Slug0SSewdlSEuXQSG8dQlH9APOSYREQTEkxsUeH3ntYYYUB0e4gZyXS4vhtPoHr AMOYdySFB9ZfISgpFWwZderQayEk8QskeFSj6KsMEvCCUhNIDGsWWwqA2awUc47yCpCVhTAF3 qWQDHnY8jxWk2EY80JhMOcUaeshbb3hXSKpomtyGgUzDvtkBlwjPoZwq2Jvga800ZQf12iTQt BrVcSrzDVaf67QPQbGn0gDkKIVSGywSv6leN7k1LCz51zwIyEj+n9/G98gcAABvOkCKplQdl4 BappbqpSiyQaHsKXq503HPpz0/0r/bjQ1Tf0n3Io+JqwVsTgOf8El7t2Z252548fnhUkRpAUN cCGBHUNXTMVKTwXyIO2ZB/Coff8IZUUdk+ElCz8U8U0yutM343bq0WPP/szFXKFY6I+hKXaOI 4L2o8gR/wI9hwdz5C0rwkQwJfrW86X3Rc6Z0/nlXOJdCpSg6/01oFnOAcSG2fVVGglYNDFpZL NCrND0sIFEqpCnHkMzPiivex2ex+U7jSB0HOcHY3R6sxakw/AonLBCDE0njgmvenjIdtv4axd haBfOnVDnkj9UAgRAYoT1jnzHKhR80TGDT3yJI5LDGxN6s0ifMfocaAYD/knQ/3PWs0mh1G3A nRURJ5+ZEzogXQWRKXRSqF5KHzPoRjHNzDCUKy+oW2n072eDuk9AqkgvKIyxGek3s5C14W1H9 j0Ql6xY61SXUowljUYAzUJXB2u8hY5aeCaf4koEVbnlqXJeN7PLfBzLZKnNNcsOzJGMw5Z1zg 0V9bGaGPRsuZjm9N0I6MFXnGDl93tNHag53jt05pmrevitytwdM0Du1XSG9Xcg7pzRBO+x8hf NtnUXBFuuyHWtql73c2W7gFF+bVpJaNObhWZbyLKl/mkdR8hwhqkA20pRwLD/c5fcr46562Ew ytDHL6W5zmK/M/yfI2q+QcIbrJRM/mF9Zg5RE8xFALK9dsI9A4OoObpy6wtWun36X55jD1VFp eqksKR5lQRvL9rEtIxRpaSEdWQl08CHn277numt65By8yRJ+4LaM1ZK2WUi0REHiQ9NNkjsdk TfU85TRmvl8S9r6kJoVqT/23GGEkB1a5i9R1Nag41Zp6m3ofZksffk/nU2S8Z8VzzqoyXo1D9 MJeZGIQwcdzSVVavpdWlGLxVFjGP7yayi6ugMOAe6By1DoBnvU1mAjnrgbsf/yYnS2U+yd1/T eFFPXpI8HZHs3MMUnGlrLgmjaJvWeWlElFbo+/uCaNs6guubJNyLMtzM1UwJqNhNU9Tw+rGrY 3QaAAs8L2ZTOZvMEC8ef92rK0YMVN 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. 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..6dad191ac59d 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 +consumtion by the ACPI firmware. Additionally, any data returned by the va= rious 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 a unsigned 16-bit little endian integer specif= ying 2 bytes + the length of the string data in bytes, followed by the st= ring data + encoded as UTF-16LE with **optional** nul termination and = padding. + Keep in mind that some firmware implementations might depe= nd on the + terminating nul character to be present. Also the padding = should + always be performed with nul 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 byte +``uint16`` Unsigned 16-bit little endian integer. = 2 byte +``sint32`` Signed 32-bit little endian integer. = 4 byte +``uint32`` Unsigned 32-bit little endian integer. = 4 byte +``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.mmmmmmsutf* 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 nul charact= er + 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 99ef21fc1c1e..9019661180a0 100644 --- a/Documentation/wmi/driver-development-guide.rst +++ b/Documentation/wmi/driver-development-guide.rst @@ -69,7 +69,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 */ }; @@ -89,9 +89,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 and ACPI-based WMI = functions. 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. @@ -103,38 +103,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 thereturned +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 being 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 @@ -146,6 +145,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 strcture 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 a 8-byte boundary, WMI drivers c= an 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 +send 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 @@ -170,6 +199,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