From nobody Sun Feb 8 12:31:27 2026 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 BD7C531355A; Sat, 20 Dec 2025 20:47:08 +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=1766263633; cv=none; b=C3SfQsniULukYKDORoVx42NZRcPkz4NqW9dKLWdh8NprGvyNv1DJL8ENHZjNd7Zcv72hBK2d40mH7MEyBfrb3WrYLZCyDFGx+X3qEkAcyY/IpVjSQj1RSlpFOquyzqyvTsXr50JefJvOn8uCW4PTy7EkT2FvCcrcSbZ4uFgTNWc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263633; c=relaxed/simple; bh=+f95zJcvI0/rxUUgSjBFd7sMhiwQpEdJpxwQpZDWd/o=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=gOSNjy4Q99mZ0lTd9PjkbplMwIzNEs9uobWFX5i4xBcNNg34hLyR8aYUas7zm+GtoMAEaJqLbiPiIXsTPEK6tbIGMzGEVRPai2tO5aE1zYkVJH93Keg6Jk5nd/haSSMhoMzh2b/j2yiJh8XFZMSF0vQppSuWml2HjQJt1qjKBTs= 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=C4fVRCEL; 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="C4fVRCEL" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263612; x=1766868412; 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=C4fVRCEL5ZOKLWupF2BIgkFX5wTMUTHmxsZlb9ck8s5Gb9vIwzES9bDlhg06EWAX AqLqvL/rk/N6uW/D/cZ28DgKII78j2H7F6IAlC/IvCKair1x6bEyv/LUFYk39e1wl mq7KGdooS28L46tZOB1CyJ1K6NdAa1ugP+ME6TzCn7wDSTFoDWWLTv1Vuu2unDH14 Sa1ZKUiuMBCBzZb9KJBV4t+OgFKEaY3wVhIDrmwZowyNB1Ml+nfEZruagK8Odd7FH wyjX3FKkMxsD8OLGIGbXDM1lPMFQy2KcEbBFUoTGy/uvQ6idRzrI/DV7DFI89xi++ kr6U+pwwSMYm2TSyPg== 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 1N4Qwg-1vw3LO2Uxq-014Pm1; Sat, 20 Dec 2025 21:46:52 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v2 1/9] platform/wmi: Introduce marshalling support Date: Sat, 20 Dec 2025 21:46:14 +0100 Message-Id: <20251220204622.3541-2-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:dtfVEATbDr4ufAj4l+ovw8fuFdjrrxZOSJzg+usLwb7EmGF0fjO s2ZZiA18nod3nKP9G/KcthVNZO6hy5M0cNMh2NzC+KYLlKczvGiGihDtpg4Hfa1cJDymlTD lsCAJr3LS02/u+N+oTXMlM9qgPZBrpv+I95nAc81+SrxQyVbUl/gBa2myU1UYPwZwgCKVEL hHve/v/fBbqb8h1DgAv+w== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:o4vKaeffT7g=;GN/9s11aYnMHevzQgWO2Io3dcy6 MjXQRwLnx2Fv+2IP7rhjxXVFIXwlhHzvNZOuA44zjYN2a9DVNYU2jBcncPuTioS+zQGZL+q2Z Ej3gfylphEHmNDy12qQ1aAkd1PS+wlA/iZq2hKdNicVzZISd6JyCYIlSr3iOZp8H4aQBO0Ptp mvAOuMD0/92RC7MX4V5R0Q+KN+oNtHGs3fzbo/33VHO/HjI1XO+bQ2sIRxxR3aVQlW11W5mUY hDKBkbtMEIepL1Ck00rwR+qX5odJs38HZjeVwIqQWSNzp7VF/S3qfurMDnP/UyFbXIaFx4P5w e/5HjTwKOgVIpw4VlYSsmnGnSxJRWFrlz0YcwBzik9f0gALdfsb3jAgvovJSgWhijfmmoTpIP ROlZj3KgMruotwbSh16zVFBNFh0Z1fcklZAYI2kUvn+UPNvbeTQwWIYC52QxxI7kdp8uRs1Nd VBmaMlu+FPbkCdbMbncenyP0AL/NzM3znu0plTxJEDpQ/GaQvUMszb5nDpEOzuImnkI7QQvHa S842U0DhTXF0CB2jf5Jm4tPNXK8t1683nXeU/czFywl1Q+BElPR8PqI18AeNPaBt6mC5TgYF5 TAOoP++ctzwo8fUzrK984/GHC0OafXwCcpRYFBseeoyaNd5hep9zdJZduRlFyiK0v3qMCm4uc GDtUlo1R8HZZQ6gbR+RxSsi5FVSPTq6rHsWLi4pq7D9BBKgtUVjHoTo5WBQTjqWbNsfOonXbs dBahm+MWOHxlz+zMJP0jDeyneU6U/x3Mx3yRb9p7mNk0V5CsXLDbVKlCoE9p/kCTQGaIx2hsz ZwAsw29poKFp4YE027ai9lYBr8mTeszTf57aooyb50P244r31/gvWR3zctGrEmZG1tgwv7Ygz PXHB3a+dGGZ+9R7KVwL7xxVkw2U1vazdtZvEPgGLlVpnREildLiGpiQwIGJiRs0aEcB7CUsmR BrDJn+JsaGyYUs37Mppq1r3wwYQjMsdlw3tuDoH0lZfaXBdBJHNG5hTxC3L9F27uNHkliLOav LkvJSO3Afvm52tybeoRVKi3BqxD9R9w74TYc8LhcStibrzU5ikmIY8sFI55KTZB2pg99igGRL PGEOGsae01j8toNnramclQBJbX/fz3dKFlLBPLTQDM9MiKAsLDikdro/sN1PbIloaY+qFSUB6 NUlhas6cLfYnNQsyxDhbc0/t5eAUCqUrr0NCEC5uLuY1qBatkXrKgOuFdAZfPl3AZOp1+QIlS 4APa5rq+GXmMtH+bASs0iQ3VfKHwFhqOU9PSBkKvLpAdIBKWMzhS9HoXp6j38kX08PVYt6FcG yQU9D85jXcJ11XyyeFhngfniJ/vpRLCFBPUTDB9BmERgOtTYyKmFwHbOa8VFn0ghZJ9oPTzi2 TuCAkpcsea5TNB9dTwkD39VyufrU62jPO0P69hNfbig/Cell4VOou6JLDQs6jjJgrWE3nVcaF 7ukwMf+fD0Ln/AMUp5zzn3m1XaVWjlA/aulSNPG1paD9EQxgsY8RJt3VonYb2ZZXymMkD1ubV s9WumGPwwg6FPt6i5SXqp1SKvgJT72Y9I9//tc7D0yY3darkwM8HooPKsV7apHrCRJU01jQ0/ +otsDNIvJgpLr3ts0eS9JG2me028hbsDYLK28sH0B02q+WB+/qBdVCtv6mlxTive9uNz3/VV0 qtMCthpTWcWY9YjllQHoG2AVD/2RAGl1zs3igNRaSIU1fVJtC30z8EN8LfloCvanPUyZi6QmK ani7btxBmu31I3+ua1MrCWDptiYKe9sK+C8jctulM5qvzbCfmY6YrM+ROHt1+2DR8ptqpuxJ8 F7hu68cfKcWIErYiSCuRldQIIg+b4uktf/V6KjAqI/IHZ7e5yRDTgm2gINLIsZRwlZU1uCyqv NMPLhkdRkmIEmCa5NmIcj+vx635rHXDqJf3YAU/H/o5xqwDor/bWJrNjB5Cgoi+4cDbKAfiPX rEHeFDwHCSMQCakZr9BEs+wY1yxN4Ro10LnWtMZ6s4Wgj50k5AvhskM/4PjauQKpApENzWOjx 1f8Vl7WHc24G7ZHT/9nyhH2CJNC3NuVylapkiWs8cXhyP2ShmCaQSsqA3NxsmGlSV2DVXtMok wC+a0PyunWat2sGc/e2hHZzHD0kyzBNS/5d2ePLXh4pzFo1IxuvNuh+PPxuhPxFOfb9udjLy9 Srm4ZZVojdODE/t8emkCjTFun3U7ByOzSg2BTP2MrBcEPrY/sKd2Ym4MJV/OG82+hwpxPL7Yg TE9KAXV9je/aSaBLS5pohi8mxBYRHa51YAv5tv197lvQjoOOCPw58S7fC84B+y+/SxCn5so2v XVR/wFrcXNvy49GiBmhmTjeFvlpvkBLsMF+2WZGBOknpE6VStx6TOmN3WglnzhOYT+2ewYeyp R52NanKnvJGj4qZpFfuWuuU9u1hk+Is9jq0r5qgQe8RHGjjatg26NclGCPKZzf/JdeBcY51/f 5aOIEHrS5MOgRXaPwGkZdllciPMs1Rpem0Y1+CSVc1xZiKczcf8yFBxobVp2PXoWkd7UZYCTM JnNETHvc7i7czpachPbBbRC9blWoCpO6Z++MC+bzNpMYruJFwgWzyo24R+02TLOmfMuG9EN1A fForNu5jxcqCtIURDg9z9zhhdYo8JwG/ATwWf03qo9iR9469xLGPzzFHyr4hugDs+XWndQN7u 2VQE2o0XBbuAYZuViunaJAXtDrpiBDsk2iWyYncIIbGqr6XOv/OkrTvAoPzyGSW0tdOHcssAj 5WfBznjqEebwlmXYitwMq3FrYDzk8qasIZ/WePKLr6NMavB4SSVrcXj3lCyvJ0BfnBHdeH7J4 YnfeF079SHgcQhRKgBxH9dDXqysTdtNKd0a+SKTN18yOK+aurAfx+/AedGO+RD6XRtqqFnxEa OwtnZ+VWOGWJm+a5FKr0BzxcAAWLtqLcH8+3bhiK6ljAc2QfEvCfdpQK9k7BZee81itOPOICF zCsi9xJYjNlMgd+NDXrzKLRzxeJYjdkYhMMacByfSv4ARNoDrq8s1BBuhLs9pnTdGwAgQRwh/ HXamsr1EaC/VrEdMucLsvYpGXAdzh24gXoXrUvlKHSfsDw/fFHwivlIZboRpvmW94Y2gFPZhs iixb5vHdMcISlHAwHYIelnorko9faqgUQ/PU60ad0T/h2ZgAfhdoUsHNTRjYQXNI+Drkzi7uI Gb3C3SDaxEKvzx2T++Lm1kU2ZfCfJeFDT6ByPrG5FKD1zVYcipsDhn8ts2ySpjM1wXIfAHTz0 PTDK/tiXENSFABd1j+zys0wS5dAKGGKMKazTR93fqxnY1YPapOVl/j/lY3Y3TrQJhPRumZ656 s0WNA4Vxkcv5zpCVW8Mt5emPSg+xEZibc0a4b33j0fOnNptQ77IKI9JFcXaozrJhftmQo7hJ3 /wl4zVsJ2E4tirGxA4f2WW/Tq2pVgPGnKDqM2MNofb7tDWoPaS4qntyO2Q79m+vmYDERO13Ub jRDznzM31vICQBB1t4B5y46amMbbGhtzoxtIFJUMeHhYHK2UGGJsFD7zOeGMJz05Y0wzJM+A/ WWbv20qrIbV3vzRZrZ6dsd2AEOEhqOKmAFqOi9lhd5zNPIHJ6JKNJPdYZgPnVz4iPmR084kNe nADFxwHjeGHVVahpi1okZ0iAMpPeMpSkNQAMa0e2vz1i9GYxNo+3+G14oZlsdeVVewrBs5ecj xjXb5aQk3KbqKTWmbIjcjw7RFYbIQ0cJultOyvMkaNTdd1UQ+FOJ/y66zJnjWTYxQDBEaYEdn tntdflSFkSY8wNyG+cCN2L2Jzi2m8AVOtb/TxEOtvdTxxtOzKvCCmw+5go8YgtWvqXPO9NlTu F6ZR5/hU1iMqjEuiEV1W/DhNqTdTBAbqUFcnIoLdUhq15qkldieo1N5rh4chy8Yv9Sbce1CrZ 38OnzlsSdJu/14RdHLO80qx06NIxJCzuPgZKckr7ikCUt3M5Vny1k0DmVDkcASZOkaZJyV5Fg b2YhcXriz3Aelm3TUGGkSOqxdw6DdQ2opHQoplSyUsaKGrYjiOfpqgixOjPgfAa7hwVBBtFOB qXT/JEVTJW+8aYpK1iYIpvByirNJ6UWi+kPu+niNisd9UoS2f55wHwmskC6TNCl0xYKQXgBtU iC4f2Wf+aGvZaSr2V39Q/x9PNaza0zaQesn6j3oGcIBxlLWeFSwpMUJTQUDVCuqVFDRhtsrpx 0GjrL7NVG18YpojD0PguWVu7Zeh2KWtkvYxqlvrVmTBD+6G0pcsXzI/8h7QP9VIyEnOSDUPXW 1VBULhT2O2EpL+Kr0HYdYkcyyCRcentcosRzYOX9HuuOJmIOVHITpDWWyhoZPsulKQFg1trAE B8HwQyZQ9FrOecAeAVeTrBGZQrBWgARVb1sdA8j9l2cbBYf/mjzet4oSIMu8YpxyVwpJXJSwt DRtp8/BzuVb6VpKciDG9aw8TiqkCzAYbXNGGllZKg+A0T7uj+J64GB474DYRdJxRpVSFAiu3B 7dRegapmdsRlK3123GaEgVsW59KfCNsg/daoeT6wiqB/UUmKeafzSri2rLeDJjCWA0sq8ct1u bSNfeHvEVa4rUD6ZDQQIkOBNoibYtpf+HTsTVHl9bWc39nCY4kmWH1lCxdmNqfmb66GxPEBBY GMJENAVSSp119Ahdtv6b5Hma5X6cCWtYFzTwK7s8GySa/hUqkvc/YzMFMoSAv1B4hHUgrlZx0 AqACPIl3WC0kRz8QU+wXWNET6nkf5vgMB+w/wUqey5P0TZv0TFbyl9+bg8w8CQWeTYF8RyAY8 0PVXPbJ88L5IIZlxdzMKxXwTMzbt4xOiQGEjAnnC/7WyNHoFFMuM71JxtgTF1EHvmYCZ0m1wG EvKSKVsA5IkEI4+nIM0oiPDUokWo/3U3XCZdTLLoSsWYHTImCsikv5Xg5fgb/GFDeAYnnltYF fYpdRC4GPyXhXm7GN3Oo5yHzHNpHljFoZlc8Az8M+iHFylWfnIrsI5g6R4pVJXBnQ9PnatotA QFLChAbxQ/+WvkGkcz3w5icljl33zzDYaF4H7qhSHiqLNFov78bhbKJ5oY6Kq3Xvz3nc9qPHQ 3fzu3zVyx2RgpbvSEUsv3NhXjE044Db40E82OsR3WOppVk9z0WJsRVzdqNxY2DLRAK1zE2MzV 5TaengMKnCAUCrNam4yVHXS05/PPiG4Kfg8VEEHKwtfpefw/rCg380aRGt9lqnHLs6ka4mNyJ zSRCQbH1F7v9B2KxLgxXv1xUqy1jlRKLkP4fxz6rrwqQscfn3+4PL+kidhXZqK9b6SD6eDaNK W2Y3u5d9GJrFDy++ZJUW3bBgyH0XWZVW4dQeuZlj7lHlYoAo0WB1YUimr1nncxs= 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 Sun Feb 8 12:31:27 2026 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 40C95313542; Sat, 20 Dec 2025 20:47:03 +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=1766263630; cv=none; b=u/fa+W/mfU8Dll84pOycvjBBws3+b7Hj/p63dylz93PQvdeVoJ8InDLRXSkuYpM/636QJszZ6VwmWGkTVRPGwx4Fg8D337yLygcgM6xV9rHbsHNeRsJjMoR82G/tUmak0osS+JoIGZGIihaw3IyafE6W6RrAj4gkn1NX7VC65ZQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263630; c=relaxed/simple; bh=Qrm452hUDjTo+GGxWQlTtlWPQVOZ0d4S83JUqVH1EZA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=fGXHZSMoVVskKgPvrDWM6crkMPm6RPSdYCliLLgk8HKC6nPIaFc9/1sEfgVmCmUfYFmUCL3xwwpHrN6M/ZnUnb3aAvjAG7WEsaK8v91GcAj6DlP9l0wxn0vUeZhLoj/3peDuzv9rUxtaGT+x1rEzUt50Y1RuLrn2kstiOMsDh1A= 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=CkP/DIW6; 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="CkP/DIW6" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263615; x=1766868415; 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=CkP/DIW68+sY3/veraHA+YjYSTyvTw+aQbMMcPUzpPiDCoZ2AnKJ86z3/rzAlLAv yXsvDG/FhpWaIIDMKn09XqEl5vbbBQ3g/FqVIPvuTqmVdw4Q1UwxhzQSVtNfomOOJ 9bKqIni69fUpO+Caaid1IqjXGAN25JpNzyPAv0JdBWG6zMsUXQryFPzGsOU7xI+Ci /kk1l2BQo8vZuSGfudbOEyNh0mhV2TQe+8pWJ8rOMrXi7rGNBTSXAF9oIDZCOffyO T+E+MtpCo/MvVYcQQpFll2Ku+3i8TIcWzGcI69RjcihWH+hj/iyTl2WmLgDdVU85y dAvyv9bW9ccs0/VbMQ== 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 1MAwXh-1vhoHP2vUH-00H81w; Sat, 20 Dec 2025 21:46:54 +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 v2 2/9] platform/wmi: Add kunit test for the marshalling code Date: Sat, 20 Dec 2025 21:46:15 +0100 Message-Id: <20251220204622.3541-3-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:p1/WqCkdS0bdgCbrZaslj4Jks8UangUAKguqxxSp3DInL7YH5AX zCWtq57qcRWyix6nGCaH8n2RoIUo3Ku84bMBGAuAX9qolHG7LoetpgidUrwqDjYFT8MilbB lKXn5s0gGYkkNtb8lOl4Vc5VwDdiIA2zYgTvsB2bcD/IbAc7f4bTS2xs/hqU6e0SXN4Ojj0 c9eBTC3zh47PibmR2qlOQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:uu4nwwcpnUw=;6e4tF+MwhKPqJac+iRIgEUgYnIw 57z/VR5o89Py5TDFW70Yr/qRMdbvPCC19XJlfhHH3ovKjMOONvAkJUBPUH0VTks+dr+T9/nnr JTnge+NAo1nqjIVp4C99UWf9KuyyvUfeGITc1QBM6ZvJsXiWD2dHZ11E7YcEKKI1V24Xeu7cs +Rj13QlwHqEXSCVphcsBWc2NjJ9G/KiZUJCgdHFqITgTG4bT/x8xKOAZxsXOLA9YJy8cQ1l+I KLdy2sqvXZ4xGSHUQU+ner3Tjq9saT6xxlXD9pFTGMqTHFzwVBPpZ/fEE4Rj8c2G1Cn6j3yUD GXcPH6G+PuRvyjF/jk5ZxNtOc/VzVkx+xkkoJRrPDr8YQ8QSMlc2Snsr4CNm3xppaUVrj9q+i qtBoZCMfRGaovsQyNfLLRywn71lyoeh68C3O7D1br54IRniVuK55b9brYTyXOMFknmRiwDq1R gSrI2jHk4J5YOaQ/thEmgQw9j7Wa3CjKLTuNEP9BDbDrVwyAEJVlnMOS1CPRSWTHAED3t2MpH 8No+ZINn4A2waA3wBYHdqb11BTZiIQAYS1y+lW++9QyYlqzXPp7nfjbTiuNnzyTBlnJFDViMK oY/ZV6/IyQYkBr4EsJq2ZwbxNPVOZnX1EZT16W5m+7xP1L/ywTeuo27cr4ZGGoxZ63JhXB92d Y9FYAOo+D/5QnckSrGKwrTUebvyV+17nzA9UG+WAGcoZrgwW7H6UauTpj7GdR5hSavk70WcmS x16Selxg9IRR+uTRGl1aXemn+KvX14+A1BJt6pc3teLWwNYJqQb1bbl+A2LqfZ1acsMY1tBcw WUPRPL3Wb1b4MAWDjBFM5Ono3fP19LT+b/2G/CoV9vY0SfQGPLPDf5i2mz6cjNER7Z93kQTuy WZKgmD96uvb+GOqtOqcEdwm1rSSw17jwxgOl1WGVzAEbCpISSZxOiRSfE47YTH+7uc0QwxKpt 6Ge1peQQt47h3YjBpqHfBck3UiM5LvNZmspFQ8ab6JacXRN+KI8qYKtXc6tUYDSoCPziL6sAg Q77lqZJfqS7NFKyEdlOGLUGXVAGdmFTegL5jSr7uzKkCEzKld0LwYH6cXrv+m1N/bPHkBitrm z/jMjCCWWQci6tTpRb0huv7idSQdDg7gV7Xw5igJWrAB9nKl5AhFKidddjlHvhL5Pz29zOiAw 7+kMjctMkLqm4xBw81dWjbX1J/izCXrBa9mgvvFgy8wNyaxeunb7QYZOmzYFyTPEBDZYbG83i sY3L5CmszRMqStpKfxr7G7ODT1rmX5EbBX4XRyFLNUQZtnPHHFMggQM0AIXGwoIKfeQkCcUnT XrZ1gz4BIUtQ8y/AjFAjRo5Whuydl+TA160YPXoW/PFUfBCF/KKXl8osTjd9gIfTgBV0tRhUr bLRJLyZWJZ3qeEbQwUZpGfy6msSE7E8z27wvZgMXJaPk/7ZFIFK/wnkI5Iq63TiyP2HUHbbCf 9mgh8hkBFFi+0w8Hn9kpT7RWYWfY4eSLnqPGY6Yk0CKLkIbtUwbXvBF9D+D12CYfkAXd5ng40 uuPgcnR027c+1Q3H0PgrRVvUa/OmQTg2L0xuievJfxn2VB82HgayTjH49ec9xxjrvjzP/eIQ0 2hubJbAAEeVBRfljKjQQk3p2p22zfwTj4rNPzwJLz4jUEqSkSikgMj9KXEztKEhLNrWliEFyi h1JzELrJ+ThX9ATVndzOFahDwJzq92QAlTNmKZgO94kGHm47WIpufnB3GYMtbECaQNfeGous0 sORR7Ke185obSnyA7iMrf0+3plALTSnoC3n0Wo1w9lSnku0owWm3q43+CwSC1C1h64dem2HxA 2wM1CAtGwNKmHl/zmZTTItSvTrteCCY2NqsCGuppUr/79s0MICggqLFkZhsF71SW29NFsww8f xkng//H1ztFewItv+HxVgva+MjZelHD3A6TDnSW2hl/7GZpMBaLRzwjOIZa7xHjPvX5Xovk03 iI9UKX+XqjOC+Ts6U02oGl9OD1twQkOMv4F+WoTn6dufb0R07B6OmPTu/P39JagheqmoHCVXe J0VxInaL43N0tMFt1+lyD6ceKkYHTwe1rB+rjI/mH3Cwd6aT2cwfWSd2cUDEXAylgn9VaJDOb 0NSx45Buoy+b3q6HZS0/Gqy1oO8SbUdMjubqefeLKAmKaWwkKnd8cppUcbcoCCxw07pTktT2g 61/qAtrpZOWy1TAn7WYF/qGcotBx30Ky7sXlQXGMZkK/F7aWvO/I3FBYnC8x67nYmgWaAeZXe +H1Hl7019zWRuubT3FCKrtOC4AFnOmNEt+XilFZwHkInpo97NSywqCNX/zzkQANmVrh6/6o7u YnXnTHp2v85GnB/XpvjDKuJCv9zC8tsM82+f0owEnlDvd+VXreIa6O/ya/NrZNMCP/3nZyG5A FRB3ezkreuCHmy1+mxwdCVqKStkWF+KEsMYIzgvNw/kJqJj2BuVGdVYYM/FTOyDZtDffAi8CQ aQnuAhsTt3oA+gud/FEKTuYyYly9YPTbnnjuMqk+xyfB0pYSeO00/7IRmrIbunUqjvWUQqo9j 364LRT7SUgOEXpAWnGVBGzmYafwLw20Z857DYOle/H6bxi1uOljIlaQd1NkqLiHz71bwdOALK N13KqJpm1HOIcodehPLJxCqMP0b8fqW5reAeAezd/baPZv0pX+is1tB4le9n41U63NhbRwNi8 DgUxICwIlz42H8VnrC+09NP843tMEn/u5DUz0TzPoIwMeVzPvb7imv88xVAvXIbGpw6OQnzd9 FbhG/Ek8OLLVIP/5UPPpnQShWQAHT0uKLjuW1AehnkA8MVW51D0c9iX+l/WhQ90AvKkwzsCxo HEu/FXsozL6vIeX/HBgUgA7mwcw3+jIdzYoj5NYBE3f7xdDeYqgWwc2+rRmxWorRlVZT5kpTi B3OLDd/yDBwzPslQxE/YnmyGkdjIuDOQfq4dhplgvE88UvIb1vDtXhccMsxZi3bKnJKgLD1H7 5Tc0qlz2x44hZ9Isf48a3Nzso1mqNiCfCUBfK70lfwWLsYnW/AtlsN8uNeYOIXssajJ6RWgoM +sLJayO53VuRZBoQjdGXnklkkFnff8Wo91yk0O8H1Ua0TmYjvm+qGWbKueNHb5ANOJE0v3gnd aSmu2A4/Y+lIa2/UXVqWSV8tomzwgQTvfpSjf+iiA+3NjL71s/j93ZTOmz+/5H+CxufZEbh/i 0r/eBzbYlshurEWe+8/GzMT5z4T8kKmetIRYdsabkU2z3PTIqUUaFlH73u768yJwnpksb8GJK mMV2Pb8ThOz6j/TB6cHTogeVhh+lbFEodRJSqjfUFpLUrcu0MCbY/tc8Kz79o6If7A+z3PhwA QzzUHzkCud1YN1mml7ekf585TbOWkcARkr0yqs+Deq52SQXwxGYWDipjoKhqOWviu46LbfiJz fxS9liAv2vnVweIvrGECwlcjRgrfoEIjv57HijyrBBXqE335xPjT2/hbWibyo7VGZ7dfpcO35 YylWkavzZQLxx1xIGml5ba5/qBNLn6c6vYE5RBAqz8nS89ddhS3INWycazhj3xlRjxhCXFBOG MWUmu6CjnK0jfS2HOVagcoQevdHXS88AiTffdwvxO8rUnXUrHixOI5hzFkk5uJy2zttmUG/gb lxHf6mIX/KYXsv3Xc6Dw+b3SU6WCsTI8ebeLQUTRhLCx2w6jHVlMotDjXkaxCE/ZDqv9fG9mL /Wua1eTwxAFVEb54tyOdj87Rn1+OlDIECWHUqDBrJbvXbMpR/6LdxGbxBsrZB5Ti2q+ny8nKh YDAeL3F7t7AIL1cQSl47ORfu2q/LHS1dMIuGKgUsduodCeEj/RgAyjs8NW8fpPEqd7PoN3XgR 5IetF5Bm9uNSFgon9DYB7nbDrPQeNC10SXSTf5L5h3lXubswSGH3hJJUcBHucRFgBAPvpsOmD 9Gx4l4nc0vfN8OW5mlq+jnY8QoOsYBhv7d50ePqIT++TBDHD5vRXg99rrfVcQPQV9wTXfmjme 9ZbpML1Rmry8c3BlcyaqP5kl6ft9/SoD1OvGnTrpvqn0Pz293LlK47GRf4ZV6tH8aHyJJjmyr 4Y0iKJ04eulpz9XPhXBQfxo1UQNyWXiyy9DsQlJxz0oV8/rUfObjj8f42XBtCVw0jrlYPilhb lU/fIJcNt6fUbIxhq6hhOg1SamSRPIUNOLCQsMfovvdcPsdsQb4tR0C70r45O8hyoGN7rTM/n fPECTlhff4/b2BdMyd7xcVaUPcfPUlAUTNXTTaev2imP/+lL3UXd/uWe2AsNLWM7SOtGbyOAu gLMU23Z7McJqZWCPjX8TDYFpWOBzhJaajbKb+/WOtyiI/IjUx4kpSAnViBbxkrLaYE/z4sALg g/bUR8jiRTTo0l4gbYKeLfoMMK8i85NoEbgWeeNOHdxxyjvph2+V8CGCQMMlxuKv9atbL4z9q pScXkMbC9jvu7WBDfsLOSxdERIJT7tnmxjojpFqeJB2TNTDvkCs8vw17wnWb4v3cCP7qHyjx0 UK0X9qXHnNMVetZOWsFZoiFmPxcJvKHxg+RRapkck5EzKdULiRuKkRDaOCx7m/v83k1MhBsph rsAP92RPwKBUsyE41ktSrQtTn19SPvDDG/0XNAL9sPICc81hUACNKxDmkj5mIIR7yy/QDIu1t X8QeDBamjxWm2cgN1/DBWIv8EPfqQyC3KDp6XruVu/cvCnfEtpW1JdAUGtb1DPQJXjrWMo2qL YO7uuZG5l6doxInQEnbtjcX6TRkgOYIGklFDCwny6d0DsNfAGpWbYAWKbWTHG5cgl3Pir7pe+ UlKr4/+wxPhcO5oktEOwRp2KTDO6xp5TcTHHaVoJCt8lSPgKNeRT3vDbMMr+4tTupG/1LKIzU fZ9YhHXedT0VZ5rcG7K+6P4e2szwGD6UFLjvFW8pildMucbP31EjQinF/HIes3UW8hBLS7ajI 2r1wek4/TsLY+drhFyhVTgwzQsW9OAVF0/SDdlZH0SlQFI1B0RpiWEJGWBLWNiDGO6TxPsy2X Jt29zdx+/CuyReiUe+edhLLCsafCE66sMwDx7Xxv6goekLcxWk2hIkp8q7secZRrHUDwmTSKS lefE85IAt1g9jiaX9w4cAquNZXhCss2n1pIRCVlkemjuyphoSqTqQ1nWTdyxXAijRwK39G6CQ eC+ENp/XkSiM8YywCcY7tlSyl8Pc/U8Gg6aIuEjLQbgSI9POYDlvd8goOmZ6QyH/4qj+i9VO2 KRJolhAvnWrEJ97xZ+qITpPWL00lZ4tuwKzDzTYYnDlsnJnxj+2EjAUTvxnZzt4OcZPU4iQA= 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 Sun Feb 8 12:31:27 2026 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 CC3B5279794; Sat, 20 Dec 2025 20:47:01 +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=1766263624; cv=none; b=h8Y9rsboNDF0Opjk5qJpYTqxgnXdkb9oeeEVl6Nzuy144cHfNqrxssPBor0AjW5FZ3U/kytpD8zqt1NQlwqy9i8ZDKK93quo9GWSIUaHZ7TIBeA6eleqd4APrHbWl+NjWi67kXqe2u0Oayl5FltvJVdyKGUcrX1NvJJ9ZENPrl0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263624; c=relaxed/simple; bh=xLk9zIAKLFK5NSyVBhqid7P/VsmVLZ9C44myHTpz19A=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=O3FvrvzVIJNm1+JmWviBd4PNg/BipNmz2WLjKxhqQKVLueNHOX3u0JgYfyHdBtzZLaN2ZnRI9wZFzUjOHoLCkjcMkcHHmreNrLdiqkKnZspeuy294/U2f5pkU8XTLCHgKTgwFYxkV3qEaWloZKS3kDdLEbDoriiMOuAxhBApjyQ= 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=FlnG2uFh; 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="FlnG2uFh" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263616; x=1766868416; 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=FlnG2uFh4oti5fHjY5p+312KVt8pAaaaOrPGWi4P0paT4WxdtxMBhIGpH9oHP2Gk TdX9gho3TQDC+pmo0U6kGdbtHhowmvWgXh6LCx7kdvx4yFfTLJigTXZV05LuymKRY 5r7jcLRUBskLpDiICrP5OR2OLw6ccjo+FWgwE5x43ziSzateor9n7EaPTdmEXzhn0 GT7VMVV3XHB4USAxs8PccpNUW5TGVYe45l4uP98x6iZXZHnOkaXrefFRhBPNn5/2n jMfq0jjFFXR9WyA4rky+irSt+wNbvJNyw5Hzcwdn18xwfz37ZQYWraIWShgpc3ZRC NkqVaEO2asBYy7hUtA== 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 1MkYbu-1wFm4k1sFy-00p5tF; Sat, 20 Dec 2025 21:46:56 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v2 3/9] platform/wmi: Add helper functions for WMI string conversions Date: Sat, 20 Dec 2025 21:46:16 +0100 Message-Id: <20251220204622.3541-4-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:gVyIe0xa8LmSmgUynD65Fqtd19+pWMQo8QJemIrhtx73pniHxkC jSfOZD2HLrEGfsCQDnq52acXaGJ7dud8TSXkWOv8RpxzEb2TRyU1WRKJjkGnE+savEd+NNm LgPs3gpEf6Iggnd2GadlJrjhUkZ7ffSunyWWIbdYRb85HC3Skw4NmViwaWr1QncltRhZF1+ Vpt2/X7IYkg9UDw55OZjQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:cDDlheaz52c=;DH9Lp6umvjDz47cJ44PT6JpbXGh injqkk5J/JmBLUl4gL44yVFmKQjlRShV3bSEvtdcepPBRzHx5CR3hUeuu8RtrYO+9ZclClsV7 xwr7C2x2617jUeDZBSa8Px03982dtbuUiXZsaLSaxkW/n/5O3Mxb9i1/OBfjBwgzruFuUR89u 1iDkjZyVl01cwtDVJhhC9ZCrJoKLTqNYUHW4s+EgEwt6PyvRcMx6DKsNXGAdC4sba5SsEkgJ1 R73RNJUXmrh0eKAqljXAnRvtFi4ikhi0cJRzQ/tzS3tzPqO3bug37Xr6E4hTB9PWAbc78nFnz nEzoWEZLvEJ2Ick0Ia1cFBxF7y1JOoFzENCnHyPtqK2ZBY82cWyz2kTLdDE6VxKSwsl27A1OE kWD4zrQ8Y7nclwNijS+XjNchAbuzOa0t+25sxArMCHWuDRzZn0tVlpDyU+bFrg+MJlvKbxciR /pfsVRql77lQZIFwuiH2jQd+KkWz/o6S5nbUfsjm5RYVTOe7QSDp/SsaimI614ZgrhbIJv/oP 2D5cJD9AF8FkDQ33Op2vmLHC8Hpl8jzf5IIyLYeelc+AGUuUKGaelE7f/fryD/NT11tSZzN8i rkyBInptQq+6f/lF9gx8o0BWZUcBMk/7AT7irNyahy8DEmkV/dusxU1LyYTEheAXb6RZ0lVqL K7MAS1BAY+g4coCCimSQrCd+vdcNNYIJtchanu4IPZxLZqqEfzeoz1T0XUZJlKZx9Kzldk1r8 4rONp847ymiDy62ZnZx0NG4GArIDgKfYhm6OtBshjP+48EWchP130sUGO2xZ8wY5avkGHoPjU 56AvRCWkg2UhFPsAwShlSM8WHRB1Sq75Qj8cX0FhE7YnlAUNn7j9x1XWDQW94gAOzhKpLmj75 rlRIIoi69FvasHU7lIDB+IqEj+WRUsTM+R+JtpuF0dfgzffmfIhQnYhdfApxXVCMLWx2mWX4s NgeHjNB1Zc2WnFPWkCNG2pc5B5dwgCgJeIEB+Il3H8qV8YAFNcEyB+h8RSXrukaFP94BSPx+a HDqSVMD1v3I1nBVnzN2BPjX9+YI1E9dVwc8LqxPi0NeVhK3LNYfE4/uKsM+EZag/td7T+YLGa DRH99VSMql1O035rN6t0i5QbouqmiqHWmD5DYTnU0CAlLHNE/+fIZwAcZC0dcJ/pOTh6Maaeu lSa1CF1x7kxma7XWktT/Cin9J8AY1TSuo+d4hegSIDPNhuLGp2XS7UBsd1i92Pnyatr3DZstO v4fsJKTnDHJ93NIxkkVRJPbygQz6BB+VoniEMIs4ekLiOraIs7DmowdU6N+cZsNo7E4YEebkO LvHkwC226b6wrSUdvdA1GXQvQ9ZMRN7Z4AbKdXpvJJQECRsASG+gWKQY3ZICzci9FeCFp2bLL wEc6hIfT9FDnhvhplX4X9tBdG/yUX3uTyLCtseGd72ZLpYOYYb+2dys0JSCruMgBSr7ZHr2Dd QkVrpo5VKMvLPTZTPGhuDMJ+4PaunyML3fjN0MYavcNsmNrkZSDoWJLzzedztVR1kWYU+iYqR npWEd9slzmXln9A0t251lQHC6yL2sKFu4DrDJwHrHpq8KLDlSUrBlayLv24CXIMpXryaRyj1e 64MpuUZo+akVM2iGkdmr/hNDkWZkA1F9BZUnFTTI8552OSJ4RUIVUZrQxd34GDh+ZL3rl9Jc/ czqz2u6zDDYG6goIfsbezAJRBAKlv824YvGrRdtIOWfckA2YnAA5XYezULpkk0KHz8lXsSmSK ZCz3Q4rZC0aMrFlVRhj1yZfae8CsB6gBG9dE0BX8KWEDC547CqfVGU1O5rTX+yKBHYaYGtN26 iwmGm+3MYeuNQwrv4wgsATlGruBc+vWyTwlFSu0nqIBOpB7dl0B6kzCcaiksRnj7vJChXyzo1 lEJOwJjWAdUQWNKR+/09bD1xDO8j9kVraH+AR/10BUpcwgO98Fj73xOxgFVMNBrGievk/23rZ 35Be6fWrQnAwCBFaAGrpJaM6u6rkV9QDIRMERM3LTAfPrAveahsf32qPitsvB+HDLJtwmd0dE Yu85d5eB7UX3eG7C48sozo6mutss+MNNvq7f5KVY15ZhRRh/Wxr+Qwv0BRi79btHV453c68bq JIaao2taGg8Z27mfbYgvZ2ulb2aC9Ootb7WIc5AuTh9b3Gt2w9+HaMBukiOQFu/xSrpz6N3LC ZFIYzB81AiZ2jCvMkBD5h46e9QOgChU/rnrVQhxXGgCr99xsjLqtbB8PksbP0cHKjPHI1+6Wn C+LC5j2w9QBRAu19uupjzPaAeLjGvVzKBllA8ISuD3iphjHoIa3LotQJztOlVtIH27NN6/d+z cZMuXXsL8TEDRJ8u23olJr42O9tMUyxtO5Ie/HUTdzjwyXxwZyl0o0S6PzoQyeJXuazYAJbB1 2ZQkKp6HZpPKsfl9ZZaHPOswTvtSMqmVQWzTOCvZHOGed5HKTlllodHu6THcKTa+pI+s2yEoE QlgX8XfCzo0pS9u6uqsUBNVFjGCdZGERBPrSSYYRnQ4mE3r5MnBXFvuYYkfFr82r0tUeWArF7 AmwmGcHRW/FKEdjprrXvsQ9P7QDum8r/qkUXxRcWn1A26RpDLXmnQLmzYXnVTTArfpS3+key8 r9TyPdidGQVmbgGBybrWnHJ616cxgj1MtD9eemkAtDAz9WliJ4ZN0W+634ZZdE3u7EE2q4uBU 8VXoG/gd9cK0v+S1PvTy23jik7nyLwTQZMQkRreBvKE0LPwKWKlEkQPzNX3/RovvQvIXRp/Ua 1jq0JfEQsLPuvBBgrVKIiBTjVy3m86iW/PdEAb+hvbUrqah+PVGAFlGCR1AetZK50FwPeTOYE HMllar4bp0Sn6hwPWNqbHIdRf4zAQo8xmGYOHxFlXoTW5lAhpq9lDvG2ovdrQVHSgxMD6sgld lZ7YpVY/5KY8crKA3dkzkPDQaLKIODK7DSLbNj55waJNl7GpV7k6Wh7QwB/RHnn2BVvYGUtDB g87wdFHsNXs7JRsvgTuYOs4pEd9fZD5sbeTnCTfXG35WJIkQE4GL3dnBVfQtISNLGtWkkIrgG 5xcVK36BhHwAG+yJcHVzHGIiotxmc7HCjCZAprSi67MB79lmk3byth88cfnk2Fvl7R383pP8+ ihTnaH4AmSJqoLVGXUJwExMGzOz5f1FJyisTradah/uTYlMT87237FYWjRmT7lcqD1QjXQGcj TLkJhXex95BqNBWMpwvEcE56K8ugR6E29cyRmdyyFgJYSq5Xm7BrbZlJt7tLTViGDQVFXZUKU UK8TAacGKsOk+3SNn0JgqP90r9O5Y9SuHJhKCJrzozLrcZ1PJVYnBP40MGhrybXcQ/OTOMYPa k1UGJBg9ntItdaDWNoowcHJ7Tq3DVes3k/osNRI8XKVjUE2sVSxyQtUg6rv3y74kdbpPnmew7 PZeXqLeZe7iTVRyWoUdicLq7QE/k+aZY8daVyPmkMPmMgdhyN7NLHossSGW7lt8a80k2k0wnd gcYaCcm0Ug5i3HrMS4wfl+4khQpabgEdLR5orrBSuOFUPnRJ2HGXiVnsNIwEGSXhmwqmLdUox UuhsocMkuB0fKhgZ9CAZVBZT0RWW1wUAxpsiRH0ehT0ijY2+XmPFTZnEMJs3+Uw5+3UAbec23 KIcWfWFTM3un1aKuvoB9txTCRj6CxgYKr8rrdFuhtA7JMMTmTSTT2Ds8fVq5VLhq5LTUz7CRA zAeNYJ0CRhA5q/sva669avt6TwORf5jIAhFD4fjthdHmoMpib1AlZSBR/wq7kxL9ILCzxwdCe qlbQbuj4OcZE1hdCSg40QKP3aYh/9AA5YiVAB+LvLvPuM1Xb2yBaxtN8WXksWW8qYc9RWgRNr MWN5CSBF/Lxd2POG1dDREd2MQovmDkIU22He+b6wrhy9lOinlUwTXPBoZup951lfq5oGtYphs XHVodfeyHPVYQ4gvntxfDAyW+PGx3elI8yqAJ+q1tga3g20vHqWlUCWze4fMn4iljjgm0jI/w Z5Z9J8oUv4Dc5Pd4+FGGLspu0aTyyl5cQRQ581/EtPInxPCoaSKaVmJ9avsO+47mTDIt8DMA4 3xSKreBm3IhzBCmE5uC9mpSvLufsnP0z5rFCWlUQWNir3L1kSwGXIhO++biJuVWyRg7lsUV00 4aV2vYxR1XcKlm03La9tsVTSOBU711elrp4GBltbVq5kZH29FKdG4sjd05/7pG+c8i0eMRK/P ju2xnlaU/RrceShGSwCbwEEeahRATVxvCsJQQkZB13N4aEBKZfVVdaLl0332OulHED8Pw2Uh8 4sISf/j9IynOIxSPRqVBTUzS7QF+7e/Kzd80vRVA4O7RC8z20+8AEQEjCgLzVFP/SUmdSN86Z 300OLu67LBLYQX8k/2nFsfVbgo+t7WXGmFHYvfqXCPQ5477UW52tqMyO3ZOqdfHCwwze051cu ST1aB8PVXvBFqs5sgzaYAkU8aJwii+JQ7enWoQZl4vijWMA/To7D6v4b3phZzHa/xJts668F7 2yQbIcHUIyLAjaw9gdkNhwZnqyLFVD4afcKVecRUv9SR+ZkTVf8GhN9E0rlcIFkEAT4iuWOdF bi2oOkA0ani7AOjjh9C54AVeth50+EE0UiQRXkAOeLcGVuavUh7TDX0kGKf8diYYM2ey5LAMg bcNpeIj9rhEmsxCpsE+0piDP7WKTzjGW+kSBKx1w1H7RpVLf/I8TmHKKx7ZWDE/9JNAyQX7HO Pm8PPi9wSKLcTliCX84ZxBufAkj6hV7E0kAmzmrY25NVYis/ZtLXDa8jNLpEL2eKdxvLvrBvR Bxw7hbxyTX55OciSEEQz2vJDu08Imht0wk49zEqsu+/dOx+FIeAtaUbFhy+sS3XzuhwfB8RNK PsLDFw1PRuG8vur/8la00O2Xtn2ba1dpiIrWJWTCk/CFT9c6fcJyxrkgbooBhHZncdoi8Lqtf eQL8nfDLJHqfuaGYiyc2Kcs17XIqUIOtyzjKyRIUk/mY68OVAmvcVWuciRchgy0kN/2bcwvjY B+MvKJh3JtDNma3HWhvz+VODFV5Do46jgX2tZPbsPPlm1doWiMom8dnF832Is0DHniVlAIpUB qc43HhL4ke7QlLbhoETrhIaxn6tEHEoDy+e/YIcxq76wSxDyUzBfmKVcqsDz3LnIJwUgUkUka cPCw9l6ZMvR0n2xihqIYC0MB2QpnAUAZxms50kM2V+/fB6/KOACAdXULRwcBXp4FQUWqu1R6o iNiqlUkNKRgYAbSgl2el07iPBVkz9Y78rvQVOVHYSPLTzfyKL7Q== 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 Sun Feb 8 12:31:27 2026 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 CC42628750B; Sat, 20 Dec 2025 20:46:59 +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=1766263624; cv=none; b=G2Z/cLDRRfIW25Kx50x2v/LWscp641fgkMa2vcz2HtluKHZnnoySNpKS1J6nuklI+fTtV2qvKMvVMpLw6J0aD7y6offqDbLmJeB/dT99yZdhUUxplbd6whadU0aEnfpmXa4XverHXhcK0h3gRub8B6DF3+mBHskSlG3Debnice4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263624; c=relaxed/simple; bh=l2YJRNguf8wk88SUlTEgZ+7KnTWqdISh9C3Qj15haMk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=iAU7tG706d3MraUNmGdO/E6HVi36K1QjpkopQDl5f7WPKJu1MpZ5b2/CO+2Uaz1VnO18b2k0dHQGJvIWTuXCUyxBmomfnaxlXlR0T2cfCjIqvGyr4lMiajqF3ygLxbL5MWBt4/lPvGf2dqNgcHWGh505eMZT0HS914rg4dZn2es= 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=iXFYtJrL; 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="iXFYtJrL" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263618; x=1766868418; 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=iXFYtJrLzbdQYf3O6Ij3xku6ud0PXSkkTuy5z0VNDVLXnJwZrUFLxB8S68u5RIEX q24ICJmxF7OItvG5wBkpMiYzBjzhDyaOEiagOYb0P1fPZ+zD33N3SMLM560gCSq7r H30V9hKERZQBiz2Y7oV8LAzQ0ZlZY2XE/STlSXppflbTRICTEY1HCSAiFlCCLIlDp 9IULhQ7dnoYaz+LgbyxYAVbAnHanvxFyMf3kdDjVRmzddzvkJzMstjh4UwBykdJ06 SH1YkEvfsVZi95pFhmMqu1B9GQRiIy+EHPJYPbyjpD+KFaCIrD7eYb7lwbPJxu+Dp KxTMkV9c58Eb44xr3A== 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 1MTABT-1vOdG11eBj-00X0oT; Sat, 20 Dec 2025 21:46:58 +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 v2 4/9] platform/wmi: Add kunit test for the string conversion code Date: Sat, 20 Dec 2025 21:46:17 +0100 Message-Id: <20251220204622.3541-5-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:ODKHqPbc/s16Xh/mpygSIoFrIVje5XO4sUcZ/aj6x5JrDVSV/qB BdpYcForqroR5fzXAJJ7P5tS/kuqW4zUM3qcgFOhG1q+Fy6kXIKAU+2LeaP3YYDu7tHAZBk Mq4bnuqUVAl5KnC9yxqMCeqk37EIctvzMBuJxqZtLacT7hOSNMjXtqXyHa4g6R64fkqevei evIMIGCUHfU2Y0Br8vzVA== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:iYpRPKOvtS4=;EuuIOsZYmTDg2atACXlcsP7Zgva 4r8InlMGC4EPW2iUSZTNeWGeo+yg0AMJ0KA7VFr6z1CErWsFQbRqf33xAqmRFkS77shDNEDD4 HcqxYJ4lCRs+3lIaLCFXkZ6cWTl1RoYiUW6mtnG2tyDtY8cMps/BhIlt+qLi6cH9zfOy/Cbz4 //k5GFgb+TutExImYdneoV74FSsSHcZCFN6qRKSraGJR59fXtjsoG0gD7YmEb8cTlx83Mjv52 7D6OMCCyTD2rltMKv5vQwiFS/8YaZ/8QdHNdO5NDrF1Zayod4GOK117g828YIBJ2QnCUZHbqu jS7N67gAKXjTVozcFSsdwhyONVNdQPI2sxkEZjrVymFT/Lu/Z0Ne9ODnDdCHqpyanyMrGWakX 6Ppqm1E1VAyTT+VB6pEBxH9YAmJgP3L5eGD9MCUVLjDN/47ZWNZOFcsC7/ErDDwTfsaaETfV/ dIFi+h4PL24vw4kNYoQVwhbcqCuMmWw0CAiLetaAMcdGRnHk/adnKnouWzdD7SBYGd5aKjjga S188acuNX4F93/eqPFQLC5R+no36ETtEZ50MGZNcx9xaBxMorQb/o0xcTNZUxd8UiYAFw6jK4 O35L5aCsPdImRdbYjedBhVzL/m71uYZsrBUFZUJiREKOfUCTSEcIlLt+svqNSWDo9B8UijfLl UE0adFgjG05v34IKGWsYgaOGvVMsbczVfnRw8v1V8D3TtMa0pqlmwcx8qRFRMtq1CgtLji25G 42WpXdxhehqaN4m5ce9ULEZ9+z9yO/KhdwxJN71XgzB+LofPUW6Gj1NphM73umwYGmxNP5ZS7 ZJyu534n+LZCJdpGP42DXnFRKjtMFxaxGJLxRG3YoG0ehMlwiZse8OtdUBBRrCRxTBjoBLr8O Xwsz8Xt5tJQJMAedj4OCDspFDS+50eOedIWrAdRDJMi+3ks03+iwThNLlI5uRoL170XWWr316 vD9ZT1uTufw72caaOEM7TbGthCJlxs7FLN33EC/OBMsJKlsf8j/wZkC46pNySpWpDxo0V6JtR jCNLouXfKTRYFRkiirAYRj5PBA8L2dDz9/FOewSmOL5WtxnUVU11qsjoBMgOvOG5uF1BuxUlM BP7kuU+ZdLqZdktKIN/9Mo+q0yksOeSzVxW9UAJhyw3wa2SithgHZnwIzqRwbRbz8+LTBH/+L toTMOnatosU6fEHx32JjyLBacj+1SGPfu1hHcjWdn3ESgedn01qrwap/X+ljM9asnWPpzIXRi Qk0LuKI4DMR9og+wbOHTHskxgimhzBTRxN+iaW6Jo9j8CfXmySCZNE0Cu+xTiDCYXk1hWJYY8 0e5+r4y2iJ9zDPnpIiizQDgkRaYYWaGUIjdt0A66b2IEY1jHLHEhYaBEWIxKUgwY0m2Llq7M+ +pLWjDVgtn2K0tkxJADJjGV2OvmVIZ+KJQG1hV/wR8WJSuAB5jVRbVDT3wYhgewCVP8HWnU9/ ILSLtolwzn6bEMTGfWjpn4DnuU7QI7SYHhdpMCUK2Qvfb3J8AjFppZ5iWuaCpo/kb/8MCRFGS vdmVS6f0B4/EsluraZt1MRvmku2adomb3IdDcDHwenL+Ojm6k9ALArCDRUZZuSKhbHTE7y5Sw 2FY5X88siljB9jntjBFNr0I3u2drEgCVMMfYmBFHIMChUlEJzb339cw+i8fYfQY/n5pBeAL/4 Dud5h9ebnt4xw4U/mBDAgOwbg/CbKJ0WOXtgFfbmUKO7KtOaxsvj4Rc2NwbrbVzlbOtL0AjNc Xot0/lGZ//XX3u0XxQEqgjLxJ14sO65dq0Mv4S60aV3b/spO4a9fA6mpXlvG0R5NnXGHm8doQ /+rL/obZG+F/nTfDwgNjci5lgdybhx7Mj+FAVMG/8o4ha6Z2HnNjNFRjPyXqJwd9Xd8RK0uGz KHx11Nb3QCm+EnTffMhqK6HvTopOdZKfHYXoufxMouC7wlPw3f4MWcP74qGec0uwtHW1BqPM8 MxH2RDfPnBEWCCZIjx8NhB1VuGi/R6IfvfeXK/0/OwefoGI2BlUxthMdQKmBO9zUhQ1HoF3u2 qMEyvT1K+fQIPdc77G3sknSwR9LbDvDtyPZuw5nHc8C01mH4rowKdXPrYJ0R0p6+8XMFJwV+l g1T9ECcCGZLwa3apjRShX1Op5Gl8Lqp00LGtkOWZM1nViuQKDk0ozwuVdg3Xj+Dg+FIHI1c0i kZutdDEtxYAus63kRkK57cXmxEEfR/IN66OmfOMh3Y2+078RHfDymwuPC2XSS8VOgpOgKKQY1 cFN+G6+SJjOFqSJ5e7Ro+RYGMRWTP6tSaJGo9kjwuVgqEAVMsZkohcyhkqRl/gOBvqgV2VO0q +2yHDB8m3yHYGf7xFoelqYhQTyEs9BbLr8H3TCa2J5uFVb9jNV5hmaYZQrtPKKiOhufpfFghI 5lQm4rNEslykl+4iIIV5H/aQnOqXcpqLWJV+Fb/Oe/NDGNzM08cxf5r5f/HcnSEkWMCxpdE+J opx+CXWlHNPIK3ieFfuXf8DwflFgJHCKYjKJ5E+ERev/HtRRR3hrZQ3uGVRvqlUTRM7Uo1S5I iaBHfJcnBqapUkyKimoLAnNPwvqKSlTREN1Kj+Zk8CVC01PJSr6aB4KWtettkoq1w7aHmoyqA 2KeZ8N9AyhikExZ7XHpyHcVZquyPlvG/ESpIgV13y0Akaca377KujW5m3AMRxmor5LHsGaAsd 6zQC4k9xMFq3fcHVlRPi23MJ6uNtgb5eC4aVz8dRQmkZxsfbZJM0XoC5jy4zwtfRVA/+DoGf6 jRL60H/+k6eYacDu5GHDN3/dhnhUhOtQn22e8OgzQnIgz0DedPCSj/9BdAmIBo1jjmMfsxPbh dzg4SrdRZ46dWDMhOeH+qkpHJ2YA0wP71txO9wR34tDI+Tl7aps9t4AEQ/p//70AhfGvwGIHQ jdKr7srLRxQKBxGl9qGuCAhN8RvMx4uFCtkZB5o6GZKHIh8mwrvZyPvojpXyPzIZjjp0qTaeq qtKMtNa2GcSSNZnt0wbQIsIQejjOELmJrG64lMCTDV6N4nkeDsM1CzccwH7HffG5MrB9TiTnS 2p/6rj9UlkbqET5acXk5cOgK4O2UbGkvGwWwJaFLbXtjyK3y8WPD5KSI8QQduxWJxRDyJ4eji B8rU55QPor4hHX5NJbUD71hap/eQ9JZ2VK2WAO36UlQdz12TfVEX/ykr4HTLC2DD43ozMuElx LfhmA3UlJZq1tdUPOti5sV34SMwFSMlILLpDGGkHlRI4mf7+AzbfB7mAtJf1HCxDETGhaIgfh 02B0k2R+79O4zKqEXoG4XFXOVrPtzccf+Jgjk0co+xR6x3DRPLDT7Ad7NssXl9xs4tzzHJ4iX v02L3b2swjSaHHsaIji73b9uXlUsNnj2Kh5zVkcWBVRGuuWe+wOHfM7OXCH/klibcAIw0MmSz RQ7l073abDPqXRrQbVWUhCxBPW6I+og/Hd4CipEzY1dhU/uY59XG5oSk3VP1WtjpX1cYJc4oq U8DaqNakHL53hKiqh2P03w6PjmYt2FnIsv55w9zOoI6jBQ4FdfKFPqquV4W/tBHxoTq33mwyk LRRo3REsE/dllsElLyzPVetWF4NzcWZoN0cWKL/hF5wzXRDbwlQPfoFCC6RKJmXme648LSDuM hutzQgCz9KzQVoT3lVnJwDLiKkPPWbeHU0hm7QjndsPiVu2eAeHtwHwCqQ72fNpM3L6RNl8b8 p1Hbr7nTj3fOFgBO5Q63hStYiq9YxlVF1aWjOGGjAvDRckmy0+htILJc4RC7Ye5wcxYBTvjCl tK8LG53k2OueaeiHdvXqOwKwKaAHajAxexXNS/35FOP8EYGfH184Z0Qs9bfUeYIvoNqrC3ifj bIM2zmQ+eDew/saZTmHotN9TLKvxy2rg286HL+xVO4pF+iHoE/A+vo70s3oFtXXmD53et03U/ 5RdCNqgYtdoQ+16xyyIJic53fRaaa8Cn5K3tp9NevxVFmlIGkAdnZlIzzM860Bcw16h2jqpT1 aWNfAoaZvcJW1sWt+2S7Tu/fOkqSW8MsuaJlIxoFCqpiVaNBj7uD26gE0CT0lx9M3Yhtu6t3g OngjTWsvhDwB1JtGJAYUmbV7/W3zR+SUUEm2zi0J+XBsIdipTMW3Z9tmKI/TsHFqvzzM/zDtA vnegARl0eLBSuJFQbqBUEYAeIZPUITI+mOfcYZ0c8eSVD0w8MDjDN3dhXkRSoepCdL0a4bh1Y RiRE58Vx93KZeMROYcLfmIM+yG5UQ0pwJwMaS9F5TFOC5LH4DY//QgcYWZDwxMtGza3ruflO0 OGV0zbQUEUNB1EKQpk2SBqeBhw8Id7XBeQdAZDuW0DCwun+ahKDSJ8LESboZ27hYo94hxlh1A H+QkCs48/jSAB2NMlqytCDJv7zZFu2xJ4OE5ZP6RVaeZPACenGB8JWgCfmhW0LgKR7rCSmX0e VO9U71bLbry1ShTi/+ZYHpGKmsQLkAapPAp+ENB8pE3es/apmso7zTt/5H4QRlXO6ZFAcNnsw bbpjvcZnNhmkT0dFVzlNpa4wLxOZE/BOlVj5KOWbkL/jXogQ9eg7+g/2ROChG2oaQlTV596fh Qip7niINX5VbSe95AIBdOnB8nLEZ2FLAGwh29GM+82xoBeQMkMmljg+c+JDcv0LppENI2W83s ZBIaN/L02n8tC0o9VddRrwHDEbo+xQQm/wTinOorQz6ZmuUxkXn8nSJNuCejDbd3bgiisBJAv 0IwfvKEzYYbAHp2nkYmaVERr+Cx3dHyh9c79hXI2tSEara0jWa38cQQJM8rH5dC3HGqbo5iaw V2kiiztO8oCVpawFMalPjxo16MebULPiyWvpdJ6CQeEov3iX60JqyLRbbrxfIwTezXaZfbabY 03La7ZWDe+Ktey3LcCcHApJpXnBfamp/LRO482SWkC0Dm/nOh9wlLz55ODdKVSz9/KbBmJPcu oUW9u6DrO4NAZdKkuq6/Jixoz0oCB6HxTaGqlCKM+H11AeCFjvCFAIFrIzdl5gEPBK38NTqNE FjyTHVERoqd73LAOjOEW+2Ru2lbliobvwYMtXxahCZFrtiGa4CnFwLl87Fc0kZI9bppzFom6i fgkHL7k+buKE1BxIo02TrEXW4CjyEg8lVGEidUmPM+lg4anr55uKg5VadGnb1oxlHTkezuk3S hitBrwTEWbwtRZfSTk09msyCape4UYeg61GTS/Or/inqvXlcEp/VzBXUlsAFdykzqbUl+i1rz 0FUZlTdmuvgLuzM0SaDSvBDVzp+U86RDK31Wmb1t6C7v4P8zHsUWezvl+3uh76pkya19LtoQ= 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 Sun Feb 8 12:31:27 2026 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 8A6173128A3; Sat, 20 Dec 2025 20:47:02 +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=1766263624; cv=none; b=jkIT4Krepr+wtyjXwWqd7lGWpL1XBz/getgZHQlJ364LnXenxzHJ7y2ZTi/KIqenj6J2zKi5bzxQ8Ix0O+0wNdP1bncP8PsjB0R1lZp0tZNrqZvU/W6WN27up7cp/BPu8Fi9/JOnfPlRmHxiLzovR0akbURXCNPBe3kor45FFl4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263624; c=relaxed/simple; bh=xQFPf4e4pS/ERkYL/pEVTkOjn8tcKqY6C3zLhawflTg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=b2iWDf8jPXBZYGd6GGbAUhSBxsLnL/uK+imstKT4BWksRITNXmvlWevkXfJOyUF/JQJzniVD5uXd/0iTOGmgoO8xd68NHDlS/fdNWGU+hT06A+x6UjiPiYBAObOv+YrllsFKooeIFb766xFQA6BliGtUVoqZjINHGzMv2rOd0SA= 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=CPNM3+TU; 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="CPNM3+TU" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263620; x=1766868420; 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=CPNM3+TU1z2ry2lNkhOu4K/C/htCnBMWeZ/ea3nXhNeif1+Xj27ZSaiKwMjE0JO5 JFx3meZRdiXJ/xfpiufnmGASqfBzthFsMFTjNfmWdYdkuCtJQf/mOOS9iidyWd+rR OP2I1OQi41WOsM0T3bQnr2/QLw8WXUjHOhpk2CzzOhKY3lnYdwVvsz4qs483pVgf5 z93FlrErbBz/uWgXK4gt21jjpiYKG19WTbcd7bNWsUuDSptXgDT1zLpdEnLgxECGw hMUFNFDpp1cYxIb+Gv8y25KoPZyjfOYuzoX9DWmSsksRqcSr42R26hxrslaeitbOW 50G5VJhWNiC9TdDacQ== 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 1MOiHf-1vKDP91Pnb-00MJ0w; Sat, 20 Dec 2025 21:47:00 +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 v2 5/9] platform/x86: intel-wmi-sbl-fw-update: Use new buffer-based WMI API Date: Sat, 20 Dec 2025 21:46:18 +0100 Message-Id: <20251220204622.3541-6-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:6JK9w47MK5ph4TXLwub8WQ/fkQ+ijnBvxYtYxWSVOlqKJ1qqU3d I+lj1vTlGKa+mFO+6mzRiUAR1JOOLiUFEEQpfi2XhU7r8DtRwoPP3Jew0BfViFaD5mXRbZt FoRa6qwfi3qLnu43dwwX41T5pv1HKyTYjF54sc06n1RqDHADFIpj+OBZDYjnPAXSQUaSvVY VYyO0hknTNFYL3iuaQz7Q== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:nlxhYBSnoBM=;DK0MAnU4B/mmQE/LVq3HGx2fAIM vhdibjLZ2+3+zX/QhacZ/8NNWAMfQdU/JcRIO+Yr0cISCEkU7mlQk+F1nqe8vh3M5NdGLFw+G uU2YgQEVvIKShIIYpMjKfppm6375SO53rHd8IDIMg80mQNDJUxgjLgMcZuNhAqWjXH2n2FZ3U YC8BZBIolodK+AA6KOFF34Qhs4UkSQq4GsY27Kp9ZxR5yB6L5JmoAPnZuUb/n82idiIOUAiyo CkiK3fQ0uJtATqA+uoB3QbqzP8VUfx2igOd9fataxHbAn2nZtw+o+yAlvkKuYO6YYcjbl3td4 hqtv7TwQzS5hgY/IUeFcvbJ+7mz+//3UT9VzUeBEnGKKaNI99Nv1k5Bbu7B/yUnBXitgGBh90 aMTYDp1L9jMlUvLN47AKgLzPPZ/cSO1ZwG3dRP7DR4WbvLO5Whrb9JJsAvxSZOWEK+4wnlEjN 1nxj/h6EdEnPVwG6xDKujhpkbupicdo+Kti2PTp5lCggJIBoeOREHTb6KKmEOdFcFnI5x6kLb FbKXQSLvI8Sy3kmf2U0zkyq0ithizNBM7CnLOvWINt5tgoYB9pou17/4ZQwLztCsVDO3XpW4T zJdRWv7BUTVPeZ8KSWhvhBHmKCOuUWbQdow6qmfzx2iK6CREe2VLUqrH6YQYH/aSNkU8FVAK+ 7Dxk40t0wu9XQtv7ddydC3uOJ3RyhegI9VWAYglqLbp/gmeZXl7nlOqOWTn870JtJhV7z7ovR gYpq+YcUK/zlmyR35YIbhYvlvpjmqp7sVibZyD1a7CEhbaWTcs8mi4DS25ZUPHmW2+Gbu3Pmd 3UbtV3uj91KHBLHvvgvoFtDBrw9fTAe90Du2ThI0/UNKgjDjEAzeSijj/sL5nCx2hRMiGwJTo Y4TW2BIMHT15HT/WGAyVclFqSL67iWEyfaNuPi2KRVSihApEUqXYcka8X2oRMUDV4KH9/b8mV 39OSRjPrqFrTLbGcWlxBTw+HBcCNe/jPuV409M1bY8yGx0BLxMSnyS0n8Vl+1gz2xPMRd3+Ox BYiX21SqxRR5yfF2nRMCCBYTJaeoHvM6FLf/uXmVSKVjEp+IalYGpgABGpCTeSsZjshRIDTxW FMMdwSq5c5NCeixSh5Q2zum/13xOp8VPWQg6KTo4w6+Du/2oIKOUknW9B5mgEutWcTBJQiDE6 GJWFufppE6QRHxn32SpRaswwCCThe5VVu8X4K2iSqeh4W2pRisr1A9jiBboOPDcIxMUCIdRP4 /AOfQqZSKICQ9S/tBcut17S5BefsLgIStifO2AjJke514aY+Kas9tV0wfCIrCZozcfXmpNGeq dIoCPmnE0T6ccR421XYWedwB7gefVgqUCHMEND/08ZeA4B9ODEhEp6vXIQX5KEAcB4wsD88dP 8B9Kmd/7Wj0z7GiysK+NfKlxj7Id7GWylnNqazzlEGKUb/QbP8YBOBKJWosMZZ+TwasBXuWDj bzWwMC0Ame8vOx9JCKRUqaGWOjMyPn7pZiCHQavPhloGk5yBnVGwY8Pldt9PsOnX/qPFxXNYH VWe75ZgFUjtPGu8jpSzfCWt8v0CxlA5smsQlaW5aC16ef/diMWrWDGSnq7JPlkwKOLK2FUZZt dnvPlowkFdqICefgPoOffYvb/xPIkghd6QBVd0TpIp2v/9yNmz7ppDjcqfyD6ixV4opSmJVUP dehtlJELf63XuMQgiPAcRf5BRWjXkxETkUr5fIX1YhoAnXgkApTwISzd3yFQVHVQMwihxpBMI RuTc3diw4X2tdIBlbblcj71911mag+sEDqps/8FhGfrwy1oS2NbsUdhSUbFmTHF4cDmP7Ul/A /rzIxoQMczg/mBRwVRmlmAnyBF5exOhUu4cyvoxOUSHmwgI/wFVtq/K9eoKGLnt4aZpHiDTB2 rrG9twZTldKXr7IrPv+mmXHb4rh1zXiekHqb0nySn4GB5yg1y9WzObGBn7H4NallR4hlv8cdE pD7m/eF9j6CxkScX1mIT/HaPO1NC9XDS2VRoTBZUZ4ukRJHRQHh4zTkRbNrm90k2j8JCefFnr exscjaLevIXG7HZ1vEaFT6JnwMC7b4YXsSMhnxF/Gg/lS/L2VNs1RKA7l6N6vPLb+bEaSkxa0 UrkxLTPceQ7IzttBtcxSeITfbq1ma8U6MWxFiMbDE9MBGz8S+oDaXAoOrzjPytOymzL+YhyZb /AvIwuasZRfDroRUv7CK/KRp+AKjd/8SQ2WZkTebYxpQU2IizfZB0EAz2T7tBrHGbsuBtt/6e FRFZzCa61EDVdjNdDG0/WudcLVaShjr4Oh1PqRMg+vDQ8seNf3LcWjeqSI0qxOlqwQ93mgwsO dxF9B9eOuvYosNV1Cxx1rf/ZzzAgulPb1Sukv453IhZh6E5afr2hhWavH9uLG8s+7Av1axnQ/ uFAo0Zfwkw6Hk4s4a8UJOy3TZNOdeCVO/tgB/b0V6T9g34LFN6fTDdzY3cvWmYBduGwY4Xk6Y Pp38LqwblEQXrhK3IVl6RTkE/wQq90sdB8vFbZ5wCl/XzrlTuwuDTjrq33ov7vfRQRlPdFHBJ p4XmHJDLEf6d1HAMaHTQ/4SrSt95yrsdw+SlLtXAszy/Vsty9tLnvfsITQIOn90gbaw9p6oqJ rKzZmspnhlD0QifQD/HtnK1r0P6BV+XUSJP7DeQ+hIhnp38CY8Y7g17rJqw2BqPl9b5TYUTw4 8eiA1oK3cyisfOpRxVQlTpunnREavsTKzWOPnP0VgR86iPY3hUjrSbJRP2+GJy9u6zot53GS3 JQT2jDoJ8PI/yIEz42ItSRcfjFNTSxfJV2ywx8Ns4bXsbK0ktr5zsd0yCMWGqeZRmZjXb7yff 55ATe6Jll9hJ2xRw5A7gkDBZSkCkz5oe37lpI6pw72TT3MbWH+afgf2k6kQsVoD0Sh3fcNpWO rbdiduePO3EUOp7DI7hX6jlDSD9/TfI74+hneIpQjG5mEz3vBF2rsfCmu2OcMyuE91BkK1oi4 mduKLgLlmjEzm98GJBRGXqqDER9SBb+Q0Vl3j7Ni5U0tVedhELLotoJOuLyJgVTXrsXdpX66y mP/leRCZp8C847cfpy3E6kGjwzVALf/4Tr0I8QnbLHoAiYTqHdV7JLicIMoDmo7Lmp93/kyZo x4D0iAMRO2IqwJaC8h2s+kF8ceWGVULrUlAq9rSemKtv4wRSo0gykkD2qEtXqz4Dpvxd9zSNS q7ev5jWEmoIP6xPWFrAoyZiVAeIYOKrF68HDtRM49aDTNRjG9dgFqIEEId+50CB7VC+XB9E+z rNzUwhLvhQF6wQS8NrcExH13VSgjamfp1tQ66PD8XSBBA9aBwcTQXuc/0TgapwtBs+A4d1fZi 2uAHXy6v0IhtPWnvFS4aO+a2g4PZkZ0gbhI3Gf0rltIbheye7fFFpRwM5bpfPsxbRrS0BWRZJ C7lZPcG9QcowT/1ZX+flRfyz9fSdKY2r+YLO9OpFca6cpkKUv3sG/yjAMUkU2cH7LL3tTaFfd 8KB6fEco6TE7je449FX/y1Zcdd5x3mUg6TwhvdPyolskfI1XrP7amciyaisjviNY7mvRV7pZ8 tLM6WYlQUWvHcjxJVxGwmPCFnC0MpXLm3rRH2ZveNJx+IdWQaZZx1l84QfXWlgZEBIZEC+JaE f1kUTBf80iSFD697Wl4KE3ixCLmbNr4bZJiawkFAQEjrUSCI2TjJaEa1PwLjp6r4Tj7f7tAAl i8qMez1xSK2IaKu+WMu4xNBDJxVmR5z2inJfDrpceiSTvcB3IOKhMoHhkO+5m/VHPiTIKp51D ua9BWqfdtF1UUx6mAhzTaFRAF9rmaQcAMvi/BoPP1ihGwnq78PYktPwLX3GyTWhhdNd4g8Oa7 9W8QEPqownzJ+5Uo48pBL53m/RurUi5yM394TVQyWeZ1jKVWR5FilxojcwdLot8/JaseBQQJC llFprtYuos/yZmrTzjyuR+7W+i1P36O5d0emAPY9UZt0YYUlJKECeF7HyxohMEGzl+2X8u6s5 gMFdcXjAR537HT3x+/bp37lRWR/i3MCVVZ5tf2joMn42LWZANgfFUznacmNFKzzEVhf0Khqh6 +zumVykhPf3Fnrm6l6M0AC2qIEgEsE7XZnco7a6UcFvl0HwW5/E4Nemy7jvAVduAoiUTp7rC5 Fo4GOvtfZ84q7rww8MXiVV1r9G1NmVIZp/da64CXaz667DFqRsn0ak0UzG2s78bF1YLF+T+W9 niBr6rm9Pr4ujowWLpABCpOCMmgk99w60C2ADHQE7pFFyWqE0f1fN0hZVDpmhYoIHrAq5sXo6 LO3dcG6ZQ4K2+IvWWctPeNY9Ch/svnNnmtip2Y5TkzB72lquqh1B10SY2zI/QuTMlQJjwOQGJ Tyd+5gq9dAS1e8vin7Airf1KKZ3bnF3gVA7mNK+7/2OHVQ9iz6iyE2bPWhW2ImpAr5vk43k3Y wYF/7OR4oHdBJCiSZq06Z4CiVzQJJBHLSioh8cO/GDnV8phOa/LxvTi8Lmc7jjP18rVokes+l JxsQdvEMckqch0HK/Z+keHfNt/yd69UD7zOvWRVRRr0AztQLe9Uwn5ShQhcTKxPzbuoKDzPEs MT00cO5XQQkexl/6CEfroad1I55Bl7G2YaYnWc8E3MRjQMLTHjZ1mwGsZ4hIkDWSF+ludQmK2 3j3r8IQF7aZE8lIljkodlxmaKt1XDo6WRwjkWfJgc69xYuGneakYODBbRbQ4XWy3TzJ6yICJp 71X0Xq/C69fTIeCu/rTHf3+AVkWzmaakJSKjPUjYL8lE8vb+GhB0ttWX1FAmjQraGvAhT1/yH e1jJzBzNmbzCe9G9ajYvchH/Jhljt1GAv3kgYNNiExbQx2n63Tjf4a+vnprqZ747NaQyc6d3X e9jOMebvsE/YWcd+TkDiw8d0gVFdAJKkFsry34KDIGx7roZ/G42tyC7O2D+Y5TIqep249PQgP ZGf+z9TGplXPUORkk96qyqBxoz5UGHyqYuiAAogpQbNbL/kAnLLHOwUW71NAlqaaBsDjlEGpt /SccyOxGKD4qNfuHoTCn2Vp4ctsN/mJoYBggFvaTbXvVOG12QFxoNDm3MQ6CXXQowouvCRMKL tcYmXk3/DhJuojngJHv4FROYDYnSRCp0DKee8DtJahBQOmQCdOl9LqsPO6w+idgIne58Oj4mt w1tFo0lQOAFa/7kEu9dvvUblP5U3PXOP19bbleFKoPycxVInJeRXinuLanhrZq1f3y1Bz7SzE G4zoq0Wa2ukqJYr/kP00kUXRHZTe40dYdbnBvr5xyqKRB/H2b8rNHi95S4cjdGbrrckWPfk75 8qORK3uiN7kFyWTxoUjPpI49q7IkIXnOaUL3S64zBZwKWSoCp306Y9AAj9eGB78= Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to also support ACPI firmware implementations that return a ACPI buffer instead of a ACPI integer. Signed-off-by: Armin Wolf --- .../platform/x86/intel/wmi/sbl-fw-update.c | 43 ++++++++----------- 1 file changed, 18 insertions(+), 25 deletions(-) diff --git a/drivers/platform/x86/intel/wmi/sbl-fw-update.c b/drivers/platf= orm/x86/intel/wmi/sbl-fw-update.c index 75c82c08117f..3716ccaaed6a 100644 --- a/drivers/platform/x86/intel/wmi/sbl-fw-update.c +++ b/drivers/platform/x86/intel/wmi/sbl-fw-update.c @@ -14,7 +14,6 @@ * https://slimbootloader.github.io/security/firmware-update.html */ =20 -#include #include #include #include @@ -25,41 +24,35 @@ =20 static int get_fwu_request(struct device *dev, u32 *out) { - union acpi_object *obj; + struct wmi_buffer buffer; + __le32 *result; + int ret; =20 - obj =3D wmidev_block_query(to_wmi_device(dev), 0); - if (!obj) - return -ENODEV; + ret =3D wmidev_query_block(to_wmi_device(dev), 0, &buffer); + if (ret < 0) + return ret; =20 - if (obj->type !=3D ACPI_TYPE_INTEGER) { - dev_warn(dev, "wmidev_block_query returned invalid value\n"); - kfree(obj); - return -EINVAL; + if (buffer.length < sizeof(*result)) { + kfree(buffer.data); + return -ENODATA; } =20 - *out =3D obj->integer.value; - kfree(obj); + result =3D buffer.data; + *out =3D le32_to_cpu(*result); + kfree(result); =20 return 0; } =20 static int set_fwu_request(struct device *dev, u32 in) { - struct acpi_buffer input; - acpi_status status; - u32 value; - - value =3D in; - input.length =3D sizeof(u32); - input.pointer =3D &value; - - status =3D wmidev_block_set(to_wmi_device(dev), 0, &input); - if (ACPI_FAILURE(status)) { - dev_err(dev, "wmidev_block_set failed\n"); - return -ENODEV; - } + __le32 value =3D cpu_to_le32(in); + struct wmi_buffer buffer =3D { + .length =3D sizeof(value), + .data =3D &value, + }; =20 - return 0; + return wmidev_set_block(to_wmi_device(dev), 0, &buffer); } =20 static ssize_t firmware_update_request_show(struct device *dev, --=20 2.39.5 From nobody Sun Feb 8 12:31:27 2026 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 ABD1D3128B8; Sat, 20 Dec 2025 20:47:17 +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=1766263640; cv=none; b=VihU6cXHjSC/KktnB6jMQbXM7MqpP/8ooiTC6T5rs/0nH42wXg5lXOtoHZ9HNijrEG7FRqyDwQZfWq8K1OLM6KXpUccYbT8zCgo5Wo6+AeXaV3ufvxUdK03csWaN2MznTjGGfUGP/QNVOzg/RLExuQSVv7SQSa4zK55vHl7qj2o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263640; c=relaxed/simple; bh=TvDAHqOndFQ+sdZIj1OoGw4fU13kcnFTYjuqXVcz0M0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=VyLws5dG2nmC51D0DkD4UJk6G7QmsdrkgeNZVnaAJc9tmS2g6aQKmw04gZKxCVEi7JHNEYcc1W4DX87KN4goqZ4p3frtUtujKDgdZf6q2+m9uEEnvlMvZHRZFn9Ts48SUdP2seXFeAgArMDPRYxbl3B1Szr4PZq3wUN4CX5Xp+0= 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=qGcGXQq7; 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="qGcGXQq7" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263622; x=1766868422; 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=qGcGXQq7uzNZx1T9cQMptqfXRtE4VQ5txjACgMflLCCllfz6mF3HAY1DbpZiVG/O C393oVIPOK+GfGyVLLOzfHt+VdCBkFRGYgc/66iMRkO03e8T0KwCCgLSR48sn59W5 xGMsT9NeX8rIJfpTzm5t5hbrJsRc7vAMiAlQ8GvV9y3Ych0Sewdsf9OPq39OA3mhZ OBhUzZhCpnbVBRqF1yaIvplt9quF2ertbeTRbQBwKQNtWrQj8ROj0wRCs//RgTFdL YxlasWoDVZuaqbi0v5zlAGfKIvKoC5lugACrgFR+MKKSkprRLc98LDSKGSacQTGuU fNR5EBtjByraVSB64w== 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 1MTRQq-1vPSbS23Yq-00XpzC; Sat, 20 Dec 2025 21:47:02 +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 v2 6/9] platform/x86/intel/wmi: thunderbolt: Use new buffer-based WMI API Date: Sat, 20 Dec 2025 21:46:19 +0100 Message-Id: <20251220204622.3541-7-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:ZJDXW/fXC2waWjXhVuqZRXo2wkARi1M0vzhd4rXv2ddHHrIbvEP pBvWCXxA6/hmGG4Olcg6koQ6OWwbkJJVLz/yMmdV+5qmMn5czYHBH10/SD10cRFVpMqA62O hX3/cI2DVBKMiz1V0NrD128P8i19zsRrUPUGq+7AqyuglA/9WOBvp1LCAurRTlxMBlwgyK6 7DNvkOL23mQT/7C/jfbcQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:U01SrZ2wBQY=;uQ08EJ8jikp71/jUiFIIHqVmARw ph9NIdK1qbXAymuxTlGmMOeKCy/a029cK1uW9l+gta1QMA2PZ+UHroc+8UVw9NoBJlhcyFu26 N9K+/DyCGxf0qU5oIIV9P0vN0cy+uH5cnuYsFDA2FBgBEZzIoijbyKk1mn6Eq4cSSrgfqn3Yp DlAmKKL/KQeynUOHfZJ+QyJ5tzPnLpMPdvApFM3D0LOAKxhWWoMGRI6nM63Msa/62m6BecWK+ qTV24xteFWbt6C80iVDLpp3i2o2r4h/Phc45k35pL2wX486y6//H4SRb8SkpViXR7avwj4met NG3ppo6kr2t1nn2ZsFa/xuHpcZ2yoellpQft5rStl3j0JUQtxO9B0EYCjLWlGqDbzknlnbSuy dc9GCPluII8RgfzWANtc6Wq6SqTj74FfcFQSsQgML4nAMmteMuaiWUfCJeWsEuFbf/8kcseGu X9ONKnUOQNlJG5Y8o7GJHr3aO99K53pFa8cccL7YUSGwZzfvxHnn710jVn/WV6giQj1pPpana kQex0NJJlhKnsbPCAwRaV1OrOXca4mn10kRkxcnhleW7uZujLNqkRAUOUKQtNgDJyEwZU3+Ng DtUA2lbbyIQTppuJOBMDBSqMn+x3uisv0VlKOu5bB6ZWs16RvIKsvaBF7ybtPBtxz7y0znP6+ 13zvHZKanddRHarBAQQvjs9y6duvNMGiyAv7mnj/uquWgg5N/dVoZnIOJpN3SINqPzetrt++v wiHdhmL9axYXEt+lUEt9l9HmBOTeQa+VGNsMuMNgG4iVnfDWT89eyPPqx96at07bJROZhvsBx fqzMwkTk4mmwPAct8sjMIjCHB8wp/ubYnGLxUVPQbESqA2hrXoKCD2zAjWaxX1ZaixuLzeZon Z4NS+Adu3dv1EtJKz279OOL0ufeOytIARm/qSR/QOI+Fos6SS2eu8cjE89oVLSBCFINAQRPxL SiapDa+UFilzZPCxgxIPU5BeVMQckYArFf6zeAZL1AD32OLVwoqwP2XEIOIoDyp7rVOuvxunV GDBEF1HuqL4/u3cBgbD0WF4WA8vmoyJa7zpRXG3k5y+beTHDdX29A3wI9aCI8BGbclGaUagpc t/v+ykRVEcctzxFObo0VQjeJWz04vuJygtDIlLLv2aTXAjxPgea/Pf9nAmMbeGB884+IhNb7l cfX1wh0chVpxaM81XkgQIbsSSEgfABBvnJecdtbxrQ5sNHMffPmW7dY54rbnIdyzDgtXdVLGy jEswkt0leI2zsrIM6x4c1frdcbLZN0m4ue7aJUkmYybzh7qInONlRLjVX8R8t93QwxI//AQAQ vOYGsvaZXb1pPkRjIrxhhtsejTBss58E4kaRHZ2mHrOTQppEv4L/dUvt7olRn6JsBjWEL0fbA kwLEMUA3Tkuv2hUUuNHzuW2wy1t0NA9YVfByrwecBrlSr0p393MT0RmJvKZcPqltwVaYVEvTT ZxKi68q/+ad0q4bDNqRUJSFQ6GWbfqvlvi4DJ0/ABOxpSPIIIkPH8Tkb8UP6z+c2kBhgftORC BhFRpfmfj6KYAoEwTh5ju3lzjKfSkt5jd/iiSd+F8J+UQixxovhU1v2y1RlnDqZheXV+2VhHj +NuIp+Iv0Zgao6VurYIakJ+V9yJ9Zdn23OsnASMuA6bSneIBMfd6OpGlZyJl1UjtIYySTMAX9 22NUWx8F33w015OMODNKoNWtGi5I41l+VEZ0G3e6saCWAv3LrOcSR/uF9leIzuhmSZiWMy0hw BEVMZZyBUJlNX5ts76UiBddQyfwGk5G0f56Emcig7KcF69ilcP94q13wE63SDdSBy6rWaAoqr 7Oq5a+hk7tnrF14rB9ukwinVq6a2zrEPBeAgJE9Ul4GTYXIhqZH/tY+X1J9864EtNuwo+Q3Ra rsialEExQoKZkSi+NN8/mJabuReVYc59/nLQE+otYPm3rRwfg99xcYfX+Q4jJ9HCTztdYqzWP QEysf4T4cRKG3n49T9zc31IU0yaMlYvViT4f5vLz7RvYHsZV5SQr6eVdNLqbCe9HU9mkSuAx9 QpBCTUkIGGYUlBGFUdl/rCQa50D1QVOGGkZg5PmDuTVOUcr8dkojNrJ0nW7Lm3a0LTxIkyp3f +g9YyTwtte7CPr0r41WZvO5UHSshh1ei40qCY0E00d0vWMUMHmI9AQE/qUtSG/J+I3pFM/g1U oaBOgiRSh8ijtJgWkFSNcEpE3S65PGEHW6waRefr/bfh4nbGhgQlBhW8nmBN6hvtcL6esTCKp l4fQhfLOhIi7SHeZrJ8OXIA7a6dPQc8Xj4exeY3MGge5KoOIMm0MYQb3xkHLklC3bRZRpWYpt CT683u51/qOoFHvf1ycZJzBzTzdD3J+1NPm+HINno1V9BiRobhdjBKA1M/myl6tqL4txwnSr6 aK3SpQIHBCXxjypTTSVRQNnUmEcISoCB+mXoIo7eYieWR+ygCCx9177y1WE4pCIenCX7Z7bJe gqTtroYDMeo514rFOKXBPFzhdQb8rhLju1QlYIaJK9rFhzY6dvQAWX7yD4R42XMIqVJJPie3a S8IzVPaLzfbgFaMega8yEagsuQqWC6DRCIPoybluzuoSlBNJ23xGVX9iZcidSH1A5T2MbSes1 tBBjDGt2amAxGPheRhSobK1GdM0gUCyPp3hPQJ8rWOQTM2OC81rCw6cEJ60L92R0yTUnU0M2m hpKXcSB/KfxbBV254UCGNVgsjYHeet/ASYKwCCfseJ6FuP8taZnEecigTY2G9poQcrnGUaPap AXfZk0mQZVwLryy5BZWghyvTQpSv7s1nkuEdEyiHe8ZjzJCWe8dKDNOHepWipNMUBl8F/itjx 1A2LvHSav4MiqfEqkuZ1247VX/iVdf9C9wZIXJz/AticpL4kskjfaK5MbHMcd8y9Ku3jgqBkJ H7nlZ2VcYmNxnSPGKS/I4ig+Ehw1AN85porZ/pxBWFdmrV3dPQW+1/AdiS+ovLaAcXYd2eAdI EjaxBHmM7PHXqaLVfu1ck4J6+IaBygR3bqVisSyUMdeCsrzVEmvIf2wll026eaWvy8tFSyN3v ZltK4IncXMOJ+26MUeaeKK773FkdGqfOECZkjavHY00xhtQRrjaYnAghIABXjjNw7QI+j4aTC TLTkEZFftehhv0IoYFEMn56ooJN+0l3Rwe1mwvAdQUQF6KJOgSqJRPhSOuG41ykZ05uDu2WdU Ftc9ewbto8swrNc8CyyEiGR8u9+yZ9gHpDFGdeTvuUiDiPUJLSiNZ3eMLqbOMczX0aCgH04LE 4cH39n5gMBlGwHCXl8Y+ndIf+q2FDT7zNxGdZ20oX7NqYqG+pHzCcO4p29ZEss8Rg90teizeu ZM23Kx2QGG3rYFIzgELj4SvImxNrpsRDx0LQTtyvmJp68caOqecj5wWJ603H4WTmGVgNgpNZd ThoaUE8xIouP8EeXR3Xzow+HQP3chr56AJZdvglkYgKIH0ZqxN4m2SsN4ql8sVOyms8JtwjNW ohQC+UrrRrzcqSJK+YkKumFhSs9ExQcJNg7bL6ZlfcJUW8xHDIIyFu0azFCCh1nMeej8wJimg 8oTCyLbmPZK2jRhDmwE9SLchUYulPj0WArQYsSlZ1MRALSNtY0NqxdIczOJxN2u68F7WVfRSw zftYGwAnkRwYfSojOyuH5IUArsb6CMCVzteuiTwcRe47vbRW+CQ+Wf0/AD+MgDlsRGBKJ86D1 u6GEH7bdEhwsuTEf+Dws5O3YNwgUodIeLZ8Pe5HQwlgBj7hhnt7qMyCn8GJIGmcb/7zdwmfoT 7628gElGfPVVwTDIG+mtFRcZwUZsoRE0zvPkgOx1+vBYF534+UvkhmGjGL2xpKSxc9FTE322J 5WQ4ZRP+qEH67BZjk6mNzAigRYT24wbZFtYS8YYxkwd9VvM+0gWDYquEhgI8u47I4oAgBh0Oe ICb0JDy/9F+PHGbBui4gHXtoOZ2sgXhCF/OxWYLSSIN86aFyz3G1xjZNM+nkHI4vh9wziLwys ytL7vRzFgXBLAneU2d2RTn70A08MSAxAzRUNdPfpIU5AXb0Xu5wqaLS1E0diItg6u14L9q12e wp+YxsVTlOCAtcKSHK2tvLJ9jeUWMsN12t/qmuT8IyIE4pcbdfkoF3j3ileNHtln88EG55/5b UFoEvk4G6psW5rZzZd3m2e1o4el6Lplso7Fngb8xrDBguqcoR4gtEQNY6KwpsMUFWhF4IMdnF A+1pidqlQme1Ra0KziO1LgsApzuMGDdTVtL7hucOBfvF6BseDqmDRT77eBJHINsf+oLYt/HUm DK5k4QLWFVU1LqOyKJz0fCpmm+4oHdut0r4DQ7t8TZyC834etgM0IuXHkLqGgdmbgC5CIG/sN FQ/dsEeBuuyWS9oI1j4xG8WlvsgQqA4ruapQMHrY5VXtMvo2236dCmVcQkp9bO2q8XT54InNo CVLjhzmSzGlrP6CJyIli8NTGWBK3hoqfQMTuaW7rJFaSD7m6lw9e8SQuim4K1FmOuicMr91Ms EximJbHc8cVaBLEUU3GDq7E+MemuFxDoWa3s/olCKsMZKECTguIW86+IJhg3egWDzsISCRIcC 3/u9niS+tTMCqIdoG57WQLdoCjmmbkZh4lpEVz3BmdXUAPamILve8B38f4F7ZRQTRk/pMVb1r +wvVIifrWZl1eql89RhzieoRrdpDWomJ2OaxlmNr9sdNn7HhBYCcZl8cHmu9P6bircEHdnsze yb0vUX+o0W7VLhWsK6+Ns8o2NAVW3tcqflErStVIk8kYzAX8LknqiJ9t2E1ldpeP61QZTS3cV W7cwKc/989qWd6OvW3VGWhL1PYeVJURKjf9HpHeKgIgX5re/8isGzErVdoXUn6CsQ/hX7pJ2s /8QeySSJrg7lntRAZNIaB3B/4zuZ8WyetzkMOaGlulvcp8yo/bpV4cGj+e0AxnLXPUmrX+UBF 6X1OTLXCqSRAG/D6lqtZlEvH16vLRNOSykqMo3JqQpXEsffoQ3KvlWq7ohFtCnBqL6HF0jPmj ykVMN7ELGvgmJXyGVsbRKaucQG+/LCyvEl43pb5X8COXVmL2f96A86qunVxIllVlie/Kh6fxX tB2WdTRQaMVKASPIudk0gA3Q/ZXatsyWooPPeZQXo7vrxZygkyvZEl/fl1vi05I/z8SYeICip Koh2Dx2tvVX0IR3i+dIseIaYQrFwZkr0u1Hx67lSWCgECppAcROnCQ/LAoqgzN3ICmQhF5fZi NcUkctFY= Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to avoid having to deal with ACPI at all. Signed-off-by: Armin Wolf --- drivers/platform/x86/intel/wmi/thunderbolt.c | 26 +++++++++----------- 1 file changed, 11 insertions(+), 15 deletions(-) diff --git a/drivers/platform/x86/intel/wmi/thunderbolt.c b/drivers/platfor= m/x86/intel/wmi/thunderbolt.c index 08df560a2c7a..f01dd096c689 100644 --- a/drivers/platform/x86/intel/wmi/thunderbolt.c +++ b/drivers/platform/x86/intel/wmi/thunderbolt.c @@ -7,7 +7,6 @@ =20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt =20 -#include #include #include #include @@ -23,24 +22,21 @@ static ssize_t force_power_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { - struct acpi_buffer input; - acpi_status status; + struct wmi_buffer buffer; + int ret; u8 mode; =20 - input.length =3D sizeof(u8); - input.pointer =3D &mode; + buffer.length =3D sizeof(mode); + buffer.data =3D &mode; + mode =3D hex_to_bin(buf[0]); - dev_dbg(dev, "force_power: storing %#x\n", mode); - if (mode =3D=3D 0 || mode =3D=3D 1) { - status =3D wmidev_evaluate_method(to_wmi_device(dev), 0, 1, &input, NULL= ); - if (ACPI_FAILURE(status)) { - dev_dbg(dev, "force_power: failed to evaluate ACPI method\n"); - return -ENODEV; - } - } else { - dev_dbg(dev, "force_power: unsupported mode\n"); + if (mode > 1) return -EINVAL; - } + + ret =3D wmidev_invoke_method(to_wmi_device(dev), 0, 1, &buffer, NULL); + if (ret < 0) + return ret; + return count; } =20 --=20 2.39.5 From nobody Sun Feb 8 12:31:27 2026 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 3AF73313E25; Sat, 20 Dec 2025 20:47:17 +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=1766263640; cv=none; b=ghmvBOjPF6OuHFnQ7f1bSlSGV0Mc8LzR87Hqaw/qBXMASv9swAaNwR+0KiXiagbDwro1PZe+tThzRuiRf+sjPxHsLWTFjDyPhUu036Tbf9921dp8rvM1RHoaujJ3nJG33gIfFEXeeA14P5ekM3HBgWI2Ht8r4wLWHHW+3JLCgZA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263640; c=relaxed/simple; bh=TJgLzTksdV6FW6f/rYwBBRpRBJulZLasWdVu8QXIRik=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Y26uW+56wJNt5gnt7vJVYoxd1Nr3gulVPuXwEEUgXRpuOk0M5p2OmbcBsZgj0tiONQiIrNyIa+R4fPJNWx9kyQmlFHQc8z4rK8uDDsCr7NWeNjpftOG7NiPd4DuE3Y36LW0z3vMgUoOyNTDRG3M2yGAfXgtToJk1jX20p2tMEMc= 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=Tpj2xZVh; 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="Tpj2xZVh" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263625; x=1766868425; 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=Tpj2xZVh9x6W2rUNuGH9oSeyEiRXUrWHeq+c/B09XcrirIJJg6nMHnKRgnB9GDXi O75XsH3tS2zjMkwyAn7MvA6WvArPupRdsFE4oXOPWyVbnxd1odZJrOb73mB7F5Oc6 jEdvkKkqXVHoAluG0byMjwWf/78xmkGcep/T/rDAD/+DRNFl/beyjDweDALQ/yAAU IjxXXif86JHYUd8t6y07Y5bfUUVd0H7hz2z/7Tkbjn5QUbnykxHvtPi04tMGGUXoB UEelC+qcFU02dGz3cXhr/zIi3C567jw8TU+uYqqRTVG9XlYK+pin/OFNGdlch5EBG vX3TH8ldxD0MoeZ7RA== 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 1MJVHU-1vHipE36cK-00Q9En; Sat, 20 Dec 2025 21:47:04 +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 v2 7/9] platform/x86: xiaomi-wmi: Use new buffer-based WMI API Date: Sat, 20 Dec 2025 21:46:20 +0100 Message-Id: <20251220204622.3541-8-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:2QjoIkMJ1p4DZt7TOLVaOMwVT6ipP1nyPG8SxmwpPsPWFkGarih u/WFg0klKdbohsM7KgIUs/h+cqK3VOdTAR0DJD1pztm8Ixlg5gbeGa+kOBFNeESCenOVo51 AvmE9dHGCNDmvuHFb+kNS/gGr3U3UxyxsyEiles6v+YDURqA4Bncx53icgf3WlkE4ic2OWq bqU+yi3cPgm121XJIt0yQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:dj7aV+zmw20=;g5xZS7i7Y3Nulx7I+qn0RJGzopi s9+S3PTPHR3/SxpJJ17P5NIxN/mUnAv5CfygdJur8B7NfU97u1bZ1nImJeABmzrkzLhPj0+3U M8UFB5NJaAMSMNzqYM+3lR2cFkkNrLSWwWv7+CgX1LO6l2XY6mdr46qPCc+9lyEI8aOPRemhM FHakK6mOlFnNYGqgktN/sAMrNfneKm865AkATTnAPwSpFUeOe9d1cI8EUWPf1GLHtVjNS5RAT wVvBQE4UvQjbbYenv8mza0XuWXa4ZHjp6J1AmzGRBSvf/2PRwUmDud7WFgzU7yfvhjoS4ORxn PgaGc0ozp8yN+7rzsPcyB6NSsF4LUcWhDt3gk8BuJQXpT3fxEWE4u2LAVzoCTVhKNdV/ppe9y bKAIJ4AjvmtQG24RUHgd3qpm9vnjj0qMiX84Lk9GukABvlgdXmvcYhNo+UGQ2/y6hX6/Pwj5U mN+riqm+wXgJpDMCsk0c6K9m9UoRTAfJMCGPJVip3wqK7ylOjh0s7rMOJ8CM+nG4WZ9unPFw1 3r+L/ikrVqtcxyH2Y1G8ZPIRz32pTouoNUc371mzVPeDxOMZiuREttXPXk1yQwkqRjxd302YB T00ybr2LGfRyQ7c5HR0zXKzEiwyxf9kWUdKJH+0AVGSQjej1mPn9x7XO8mqmBb6n/nNo6CDKa CmdikyWy8KSoGiBeDp6M0DuFAvlWjVQBYQeXWsbUeiXy6BCUmFAbMeEWG6EJvTSNwjGmkH96P BTpVHF9jiIsrs8+mDXSBRPJS6EXXDv31bMznbFqU2j1OVJEg8RUCzmb8l/DVT98VUzH5uqbkn rartYKjkwA1rkjm5i56Rc9jZZDZt7FMOKMuGs7kHv9ciq8W9/MHNhI0mS9JCK7tKB6ujWv3UA c+kw0LUk01QO/MilH/T+SveuIiCKH4jWQJ7G3PpF3Mfgz5wBUMUwMJ3SIcwvDSGeD6obtdD7M Ijc1iMI+O6a7ItDMwBU0QOYqqbMaihtoPvzXTk/VlpWc3HXMzM228/YCK0v8lRhzSIfhq9aMY GKwpjUaNCZVJgzFt6qF4R7xb1hp/EnXXRIk4JbgE0wupXsLsVbXHvNLno98OHM+jvAda34F03 tEQ8YI8a0ISGDdNhSncIaQY7FQM+1ijt3czAsgSznqXRnqnpN9HP3GjpSo9960TDDOdZB6KBg IfYxYmuLmKPhslAr9/2jTZH47RbxNyfkD6RYu4W0pDFDTwrI7bQCAG2Sxq0YaCDR7rWNDlSxI NlrTTws6e08XRzxwCPnaJZIgObM1raC8GA7CvitkQd+oz8rdGF9K+9ciKz/3XIvm6Nv1LQ6gY lzJwEsV/H8kpoG0X68KMa3XYWo5kyF/K+ILYs1aWOvfQjxeCme1duRR7plAg93BwdNsFRpPhx zpAFhwTQvdzMQI9ey9jlumJahkG3DBiqu7K7IjEpCOlLyAY8lP2feyL6cZJyvIP+GpyXbzn+j X1pB4gxxXYFuXwthLOgm4KTErP9xd7HLbQZvuEIw2KKTmhzZ71Fv7Q1jYs0xWjdWmzXiR/pVt NGcxWOeWCcoJ+Xc5xvkstOd02LHDc9ZrtbmCWcf+6nacbc5WZ13p0ARCkUCQFjB/boe3vaKHU yhfDj8qMB+cffJeAbMwJRaN3KUHbjjBy0uxUHk1yEa2byxoZ0OWOThngbTsLxuBCfMkjfRet2 q+J3JQWpUhdOnwKke9ebaBlsuA3IpaBIFurDILiGFFz4ClmipTTmkfKK1+j51NDd+C7OTMj4v l7JhY9pPeAsoCefiXbWSvXae7+t31u46Kgw95tEwsIjQ83U9zdNUBmYrymHasXTS6KSelhhAu QOWjPpt2Qmjhjg0hh8glDA9K/j76A/Dz8NggIhPomUp3spafNVEE7I4C11E6drvgK1T7MWVO/ qO23P3XboLUMTxyun0ZWvT5r8cEcA9Jp4IBSPDjdVyLYXhJpZBhqbhwbmotoBFw2wTWTkYZed Mgo5b89omxS320QZ96Hsns53tjaMlnFttJdSlwnYJZLTyhvAN+1AD7qcd9vkfXHZNzZWnxV5j QLzLPUoLqKvFCfYaNOOrcpF6rSHAOfRjpCLoYBqgvGYYQRFqU8MkpaPNxN3tGuGekc/VFgB3y wkdCa/X4wCKJmBE4edvSXFBWEQx4HBGFD8fanWw97JP8R9NJbMCy9DY1uo0y5/OHl9mk9PCyx zvqkExg8b+inGGEmK0hb7LLlnaiQRh6zd5G1AUoQ6BJZaqR07CP96DXhmmCax5z1B5aSkGbXJ 2ege535uFvTjokWG99TQQuwNO82DpPWkZvzphA1M98lCyb7YTgi8dnvQPkNfZIGf/SYafHgt2 F+LZQxaA/XwgsxAq5SQc/4nK5Zu8wK/1Mo3dE2s355YQf/D+h7eQVCQfSxC1QQrftP/lX8hma 4lSMPf74PI3hp3/shdYgEsr8p8tres9zQmEiF3TeRmDKzExgavzX5kvRLU1eb637fuIlmNFPt ZDHx+Z7F4Sr/Ggk/IPr3b5Cr50JN7IrYBIRaQbRET3YKg+rN2kDwv6E58h/tesAIZ9S+3jJS4 6e6nqDJ5Nt7QdqRDewaLl3HiZk5hOOGZSkhmuapgyhzXic4E6R1AmEWi7+tiUa6lKoXKczOZv VCtW6Ps8Ac6fOR/G3pqbKGzlNW3jOhYmGMleDCK0hZTpZFOk4Q69fI8uo4dDgTLiputIZHLtY vcCZi485zMp7fjT1zRZQtKAaVNuzkbrolpMJC3enEMzgwYWZf0krkHF9yA+hwrwSJ+fZJ4DIS RziMdEq/rAR+FdrScFqEd1zsTgYDtr7kxPCZmihpgTWRnvmLAAwaNMH+cMCBCmJED91SeFcN+ 8d/F53lnznEIEiDq+V0Ogqby40aXOxZbQSMc6t/z3db3AEDKPcxmOVgQ8HmHTzD8nH75MHtCL xPFVRAL6nwOb3CeZ+vsaAa5U/EX32qSb+9ofsel2shUel3ISq4bNhPN09Hoy5Xq6exb0AONxd kChsPBnYpf7ttGGgrpjAGFbz/+a6KeolhC3GIAhgWI7jrVaTMLmDKjy9XjDZwMHyJB1TBWmVS yfSbaL2LgS+b1flpfW6VfEI9TQWLcRYpbJLFb9PwFNRfOSKLEGPAm2u6h4nP3i9wwlacHJRhG 9h9D5g1g1dsdC7W2aSBovI6UBCBK+1ApxAV7vaoD7q2VRk3i+UOHi1ZIns6CWrWZ4teb17vN6 yy1XEXtM+eKAb4eMgb4Luk0YoG+V3RaS7rEQripNVo1nzeIo8UJCMCZfaknz42h6lQgeusjE0 DzpUU9IpZWZX1t5nziO5rILBVXpVXfdj7ZBpl6CGATxV218kPzUwfk2g0QjnWAsHISufaWi19 gc4n+nZiIgURvRMUtn8JMb4NVQUrV0dNSfdUDArLt2tfNBOz3+b4WNKramoqd8cicqcYn7t/4 lcY8Rsf6+YCA4HmEF0FPZnrTRZHFgDbwrsJFxAchRSwvCI2Bwj4dstHRtiYmCtt2cjW6F04mJ zPagT6aFxorvJm2itiwcWUbUCkiZ/rwwhdqTLqOSZ4i6CWlmuFzCMu4i9Ca7RKUupRNgF6wgz lrEG7+VG84ilGhMkvv6fQKQRyfk5JF71bJRb8j+Dk4CB0YkqKikATLd0P1OiNBBK230m/ufVl 9FudFpMGLJFOdkDpUm+5JaQR7OvvR/0nLxWvcSB8lDvG+UKzdsuh+jhB5bTHWMzN7x9etScmc ZWlBP6gxeyNkzaHGRe8tcKOe2IvH4XZ7HdHEkPPaj6W0yaLZScGjWGYkYhoeyOkL837FdRvip E3eeIF1kz/+orxw9m8aGJdrayjUGBcPwZ0KzFBmrnzBvZmuftg3AYtN1Ft5D5Q57m+bC2Mk5J rIgfRt+e9VBgVs3B0J2Nmpbb8s6bcjUcPg0PWGwuTbFxsZhF0qcZEi9RKByj++IP1G7xc8rjC w9UQdQFo4vzWEiFBa9OeOR3kCnsToWNv9SSFq27yZs8coJrVn38KCeAmsECxCaEaccSGBc1m6 /2U0+3jDMIYjnp2tFTCfJbXGUhlqhAouzHl88OfZSPwYsN/a06o3fIW7fnPEn1qonp4cCqlBb LZbNYDxE2KYErELVfuuA9n2wGl9lMrw42IWOQ+juB4CKLU5iyy36n11Vj47OQOZht6rf+5vnO VizNqgzG36vH9BqSPjoTwK+0vy+bwD8fGcpi0738UshNjzhIlWQEIrm3stPKgwnLDudzKFEQ5 h9sJaD09bBuXA62oM+tV2sJvjlmVDzYlcHnmI70a/a6oi33sFJcugZr9oLPXG50rlLbKfU9iT 1lHOvh+E5TQ8zm6Vq5wGL9VWqTmDUce3H6tARcDdR1Hc78yLJOgqbS5D62do7upi16F/oIJKr uco1dTQ3H3ctzlwHtsue8UCxyfc2jVE903b7zL9eK8EFZS4cjFZ8racY41qtmKcQ5xKByuNhm VHR7nwWoD0+pkxrhQVlf6DTpONHfbL0pwNuk/NU99BXQj23G4lXMGhUSQpiwLqFSHbCYaAV+J n2fxY4thyqaMxgAefMt8c8ocA3OZLn4dalvXi037b8yPh3fRSZrHCCKxcLxzruqFSXx0srvtx BwAMEzlse6f2Ue/EJ8naAJ70PC7oRm3rcHKaxa0ptmOG8zx2VoUgWfAkt4E7WOKblmwAK4IrV +u67AmHz1Dszistq0lWm7B/YbGmTDE1xs6X+QDed+sseoBx6zY80De0btjNnQN2+o/8P6PUge JUOfzx7haJT76DsLBuIA5Ax60vFeJMPvhlLKFKQUlWiunn4+6emkNSp78WQEAoZxRoJWk8D99 asLZCzFKkpKqf1kH9iDMnkEhij2r5VmylbYQWyMsY45/Lt9twFDoz2isOLIm0C16MZbBDfFgJ xKwXkkf8DnYtaJHgtCppleNCoJBSG0QYFGr1mjsNWQ4JlqXpYYa7DwVOYg55BANAS/iqy2MnC 9f+gOGqi4ZfUEHGZtpDtZ5OnM8x43Jc1s9+6ideJEVwzkZmAiYyUlaw9kopAtrumFJL39QUwF hB7aI8/GXr2zFvVLR30rpRweIHVJFOiPCBKsvsz/GMGZ9O7HEBSdLVjcKZmZ0mILN9ugZLhj1 h+YQHsQICF2tGjFpIOOkE7xQ8HIKoqU85FrPVcS96geXRwWcVPQCMa2Y41cQnaTb9DWo9sZnX vDtvHqp9DX0ealYmCY8f7OQ9I3PRVIH7gXCWJjieM7UMWidDi3S3BgyiGBJPnXmOBDOp/zIch ZnyF06SvYi0ZtVgeDTD1zy2fRvtZ3Uo4r8PLMAX834qLmbfsmyg== Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to avoid having to deal with ACPI at all. Signed-off-by: Armin Wolf --- drivers/platform/x86/xiaomi-wmi.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/drivers/platform/x86/xiaomi-wmi.c b/drivers/platform/x86/xiaom= i-wmi.c index b892007b9863..badf9e42e015 100644 --- a/drivers/platform/x86/xiaomi-wmi.c +++ b/drivers/platform/x86/xiaomi-wmi.c @@ -1,7 +1,6 @@ // SPDX-License-Identifier: GPL-2.0 /* WMI driver for Xiaomi Laptops */ =20 -#include #include #include #include @@ -56,7 +55,7 @@ static int xiaomi_wmi_probe(struct wmi_device *wdev, cons= t void *context) return input_register_device(data->input_dev); } =20 -static void xiaomi_wmi_notify(struct wmi_device *wdev, union acpi_object *= dummy) +static void xiaomi_wmi_notify(struct wmi_device *wdev, const struct wmi_bu= ffer *dummy) { struct xiaomi_wmi *data =3D dev_get_drvdata(&wdev->dev); =20 @@ -85,7 +84,7 @@ static struct wmi_driver xiaomi_wmi_driver =3D { }, .id_table =3D xiaomi_wmi_id_table, .probe =3D xiaomi_wmi_probe, - .notify =3D xiaomi_wmi_notify, + .notify_new =3D xiaomi_wmi_notify, .no_singleton =3D true, }; module_wmi_driver(xiaomi_wmi_driver); --=20 2.39.5 From nobody Sun Feb 8 12:31:27 2026 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 3EA9B313543; Sat, 20 Dec 2025 20:47:12 +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=1766263635; cv=none; b=PrrgAs3zrTxMASbBpfVxEQe2j0AhJNuXVWiuXP7PzmdmCPOoClsX/PITDA2jZfCGaUgg38YqXG4uo54cOdY/OUcgv3BdG8cy9YDzLFC/GK5to5mzKnPIqDPKILnwPLLrWeBebRCp3eJnhANzvWk0kASgpgphEf9Zg5e7CWgpP6s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263635; c=relaxed/simple; bh=O8IGx/qdPLgHwXwdToL4OtW7b6tvLndNcTwk+PuIHqM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=g7BuHKi3KexV+phz+h9n+npB+Jrcj0+95ejlg8HiNrcI8nafLSbB1aidbwAFy3sUCIVTQFyux9rLi3SdKA4XBNK8fdnnEqhW6CBbNSpk65FXGMB0jSN9qAJx2ZFgdEFuq3e6iWWWzDKWRREKTFI647/njT2lCkc7FuL6fpPvat4= 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=DC05EYho; 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="DC05EYho" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263626; x=1766868426; 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=DC05EYhomHyJ87XahONEd1FU2tGpfhOTGE2RxA11zOgrM2SmcBz0iQiMKHpp5Fvb u3sYAsHLPgJ4wxnsLN229GjjzmwY6/gctOj4X2ap3NpEk184VgdN8PtRzM+GaS5Yq 1tPRLyq0UCFe1twpAI1eE+OM8/2sYUngrq9c9hMzXx3WIr+jgTM2oZofL9J+NkagN UAucwdCHKV0vRA0KGmq339O++MDt7l3aJQWOdMPyEmMAfqmSSYBiXEQXmi3whufnA 9ubPd56bQgcXOygNCbTZWmfwHFon3Jqd9sy3IuC+1hWwyqOiELgu7MXcFtWuHsbEB tZNXgtGIY3DrWvMZIg== 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 1MS3mt-1vPjBR21IR-00Rovs; Sat, 20 Dec 2025 21:47:06 +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 v2 8/9] platform/x86: wmi-bmof: Use new buffer-based WMI API Date: Sat, 20 Dec 2025 21:46:21 +0100 Message-Id: <20251220204622.3541-9-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:znMtZ12B6OcM82rj4yq3BUq34a3rcldGFpqSiFlSElBkJXBWY2S gDaVHr63OfZjsqiGcQxerALwNc4Y6cyld4B5emFSczNOHtlSBtBAS76cfqmYw12lgVPwhRq qsqStZjm9w7oZ5p23e9med3aflsvakMUFFAu18MxutCBMYhDHp9R9/+8GtGnheQE0ajCWt1 WcjXeL7U5hk7NotvV94AA== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:EScRA6vRrXQ=;hKG4vcgiRZTkWzvH1c6jZhNwQ9T lEG6hR41qWZ9uzH2QEY33h5g5lf7jmWy/SFyS5rWQYbTGArTCNY+QZWZyAlcBGqnwNrBmsIrU 1sRDkKC7a/4HwOrzZ9DoVusfj/qkggADOXjUSPczoeaVvymvs2TSqY8TQPm5MyKj60PbqFPjI NruYdyim1+N/fqN/yxY/pO658jiPdnpfFXIViIer6ICyPRGnukRQouy2WgQhjZ2E9v4vta6PW PYJz38zLvgPsCGpiMn1qdyAlZWoxtqBKtz5kGrkTVqXvyX/kvSY7eB1+IFnaJICEUSaRb6UuE sz1IZ33eeM6ZkdXvb85MN9waWCqSr2Sb31Gjz4NSRYcTvb8rpmuTyrAJmMVZBfm9o9weAZUGw VgKgjjke/iEEgMrM3TuOXvvf++L20lSzKtgV5xOEH+NxskDzl63Um+Nn96T4zdpe937rjqLmC CqEIm3XvXPvUnPx2KfuIIBkqKDe6ccAnUd/whx2rJxz8bnaoNk1KkxXbICLSw189IVExnuzN8 vEarfqCMtMOTZuEOyTYnGLS3cRc9V0Pr8rpl4XHuOsIzzatfjrnOq9jHrfxCSSndUt8GkRB/U KxEEhyR0px/onIQk9UD+B+oqQcRSZDWM0pRAEQ1igi2oWCkJsiXsWhEkCBUqj2Blvj7D7AjRb 3PnuLbb5H5ao7ZqGJRxkwCFMYnT/OkzjVo0oV7zkYFPs8NZrYG1plI3qhTazAxoMqEH9X4ka3 UpENF8jHnvxV90sDZT+Yd2sls1fKcdgOis6M6/z/4n0hbjHnSHlVL2ILDAx8E9AJvXMaTtkWh 7HjmxTQv0QFMMO80APzTlh9HqLYeovsTlWTNgFreOvqO/Ng0kcC33wB5WgZQ+LIcy+EJiEgMb /PuJ2+SoTSBBAREHbTsfBMO8DtFdLdTsMcrlr7zdPjasaavsm9pWfd19eFeeBMk6cpKyXlFJx 6rFHb5iUNiQJVOUSyh/dPuZmjiio384SRgcSvDHcH5nnDLCrZiB4hvFbMaAi9tZh7AYYpkBNA QhAhiABVC5s263ZcadbCZmKabfRATXx4f0T3uFNafcbrWdBBMVputcaAeRerfCAOG2L7BEosN AotS3nVtA9Ji9DrOnMrTzofPpB0K8yVd5i3SB8SXLYtLkRUIUSyGNMKUV2hYxWS60jABparCa 1K7dln7wWIxfjkSiK32rbHWZoB8aT2r4RhVG6xzmXnOqCyaKve5jGdUo9rRCiNNQR0DwD1RME p1aJ9/ilXa44GuzXV8g6w+mFGXnMWDTMYAsp24NUXjCosKOPuKv74rVPHKTlFW3kcGRLiscV5 eld1Tnhpv1AqOU0/d7WCoELLpinDjc1lrDa1yCfX3CMqO5OVPqh4cu0rlWnFL1OSqWWBHk0fx 2oTWxrRc0oUBhWPDTV1z7azHwqEebCgNy2A6KswouvtWlxPMgrxe9ixWKrEQ0Mv/HO0kobZ4R YpiJg1RbOpBDGHH1O9C0tzpkYayoFSRZk8kDr3J/7dztaBIO9RS4We5/1r0ApYp92yuUAl6XE 1y8j8r/yAPLIdkDLubNmsmy8AB5dl7QST9ctxgWLm4nBaz559/Vt5C29Lx08x8p/8UxvaaSWH mpFT1bIF230qcmIQIIDaGuDJQy/gBw/Qx8aajf3wwF6GbDmR7aNyBmC7+5LFSxr0p6kDGNc9B IfjYf2Tvb3EM4kdSXa02jk1dkUfoOEwT8HJUhmuAqZ4vxACay+qadvmBA1IV3YMCrwFhI/r0a 6b/jp77lCiQjM7wMpVs9ZqWc6FjDYLJVptYJ9OGHHTAWfl3EXvPq40biv1TrasrYIpOOf0/gi hhxXzw3+xRe8dlrUS/Chqu4V1MBK6gKak1chaUXa0kAVGfhm23Q5U8VRwb//m45kk0allwaqB f/5fj5mY7VPs2kYzN4DXW2AeJ3P2Ea7buxWTSJLdJsRq4TGY9PxZ6R1auaSellCuFxfQjyQ3B skjZQzXuQN5rMvJJRcmnjz5rb2H6oft+R/1aQy3KKAfX0+9UGfKjfOsLq5bpk7gYYWwsye36o 5PRAxK9nhayO+n+dKzHRzzPuaGAoahw125oQC7agep9D2PiKQ5259Hc1iffGs/nqUknfVgdKC EhjXsyfosEWMumlC0fzxuUrX/r0wMIg0uOQ07TC6O22JA7msZBDRFVIg4kLY1N2EOJjzPTB/O iwsUNzaadlcuQ+PKBaPUFoMylIN3V/bdmTJc+/2YC5/EC1Tc7rVptq6CDUGvech9VCwH3tJZR iOnSqnd3fKXSZR5qMuLp8nV9LVtM0NpvWnGMJwGWxfPRKM4c1cZnLzCix+3ShaLR258sBkUhI 6gwwyf08/sjvIIDE0rHCvtIazgBQYrOw2/fKo8OmEJ5Emi84GDBef2gLh53M4/MZTTPTXi0bA QsRi4WTZ0TWFLJzpWKUE2eJ3XCUVeeQwwoJmi7KINC8HEPsDLddNc42yABBag3AkeeILsxVib 8Whi5jutRC9zRT7VEQbWzd5Ri4WDjEX1xfCZ8Fc46a+mxWnmU1P2+5eA2vpUqoBaaKBMTOGQV Tm7wIZsyYjntouPKkDGwy+ktEn5ZPPYcOBVXqfbsKFm9IakqnWXjYcb7+6WiyvPfrOvsqdYxy sSb2Qahx+Zh2roBB9Uss2Q9CTmIG7eEaxipzYi1dEsMUa7EbPEuGvvI+7SC7Hfb/b0bl0FpMH 5KpN7R5a9qAsuHV5YbcS6Akvfko/NoR3hMJElFtjisiIL+tOMmcHxNHQLaDnMm2bXZz8qiM4G OlDVtz0D6EK/KH0pZPweF3A0IMwbin3SIF7zD1IzY/MEzO+A9tfP8L/h7JMwNoNrvvtX3Obx8 u5E826PBIXqcRFWQAaC1+2CXt94VFQAj3HVBc8+RFlX4phydEOeRT7/e0ubAyUeeiokpTnZdM FPmty2SgeQf2+ixsesaR9t2h/eurxfLZByFayj/av8DCgNqIZMvGlH14niqAhiGFuSdUXEIDU 0bSzoP5KB8+TXwEPv/uVu/biHcXmzqjNFbM+c+fvCyrdU95fymOH+5hEDCcXpOKtxBkQ7nYj5 8xBkTRXhS+h6GryGvr1qgrQDPeJnDUTOONOsClDQs/vn222NfPuKCoKyBlcHaO4/GMu9IFD/g xz7pphPjT1TMcAswT6omKpYN64bXEyUHmyZcw25AdlsoDEPuAwojJd4VlM/MJLCikQnpOkAB2 ptH8iYaAUlKj218W598P+XeZ/nrDkoplUsVmQ+sZyp1ZZnAT1qH//1M8JfLADaqCjLTyl7rNU CfXT8pgXycnKRb5UqnCH6XTItpWw4o6P+YhqPwNEVVhqL7T86i0HpaZKF14imlugrhQGkJWEe MmUSNah1DFT9sWMW3CiKB2FbtdJ6S3LX+pJyiWlahQLjpP+A+O3vcE7pXHZXNWsBGQYw2N6uj 9P65S8PkYDf2vFByXqHgcy+24j9flEkOfT1E6qpXCsUpDktf58QikNnAncJ1L1rAJN7aUMJDs RE1KhHFpG+9w2OGewNpEF2SvJitUi6nC7mnilgi9FzvHx/8MHG4a0+fNnrZdgzbG8Cxd6FU3N lRgjQ2YHyManMMgl7xNPqrpV4kS9Yxfi0KZxzwWK5uww4GG62IcTQYpDPjh3t+KaC6vYp+/Uz ONF8sDr8KPqEPi4FinDWaYajFxU1B5OGI0zIvEidgsbKPrHYeC6MtvWlHlwoWoPjv+b4965qi pWRkYv87Igtr9ryPvifSu/Q9kkRPBnd2i+mKVEAfzJJWIMnEYQ8q2HKgPZyxvfEEreDibg8tr fncprxh0qXWs7BTw/1tRC0nR+c0eqXDG4RUaK2E7HRiBuMb3S0L8Op9mnMIPFi2UVdAHiohmj KYQjDQCZf61HqkZNmu7dNNz4Q8kAo8u8T5cIJfVBd62DvnW1Ci8mKbZXWAQsn9bnF/su4yEwC uiirOAzq7pVH+PT/jXGlDs7WysrKyu1+YknISBYUG5So5ssUjqbPjv9wxYXJMC9xsRLrYefh1 /sAsPfYBOWOIb8CK49Fsf6EO52VyF9+iSnYyGASN2axYUhXypbJDHUWRshxoh1YlDTo1mMXUb IyM+hwEBPEx5A6UVIWlcJ/ECgedlTV4rOaCvZwn8SZOfK+PwzbbQzlaqFd38iX2DBQOBclyw2 a8unJYftGSJTfF0nosf2bxFBGxhEmSc628qPU3JHTEAmKbVQRJ8rzvWn+p4NQLBRp84qNhMB4 DFz8Lyb9BsU2DlKBtYdn6793xU3Q3us9Nvx3KpS+CrlM2RsSI4NDhQ6geqUbQoaBB7ZzJFwc9 bTMVZs3LdYm8db3s8+RdJ1UZTXITsK/X+S/rDb6de84fHuEfk0xWpziMsgHVpNdkINB86Forb F7R/gq81UHFxgQ3SgLTP7dfqbc5VlzsgFS0pvtChtLsn2COsXvPz/JNR9MFRaXSOq5u0AyRz3 lxZqhrf1Cjl5KEr+mxXRhlOq2bANmgbckDlhJAddjSkkRISyZn5EzO5fO8PCZpwYDlAMS++z0 8B4ejkeyt9E9cEFTmudHvlxyQft2q9GlKAhmLoagVmtuLOXqbUoOtCige8654PdTt/xHYPgOE YBhu+US+KMRvDG0GFHUe3bh+16EbP+dI8LL63pBcr6RzmZAP6oG05K18JpIHmybB2KBx5CUvL 2A9373sC/iU5Sl8SmAynDtZHdcDO/hBW2wYPzh5SpXQOukk1pXwZRd2qkwaZWb0Po5dDQqrgX DDHmxqqCbOtbVfsHGc+v0RaJa5qqDL4DjW1w1fsNyGhRMedoZJtlTNzkkbK8H5heQ5Nf7bAP8 de5kagVWz5W5M3YzMMPuWFL0nP0X37QA6b2w/tXHE7Rl2bPIlNQWuV5TjXUyRWr8R5ppuQ9zQ HL8XPj6dsGvDqsdFRNw8KZ4aUySUCkyNAg0EEvEIG/0smVhRIrF1FwzG3e7Xx9G2xUvycwnEw cGAWflGsEN8PTo3E3TZpjwwgjZqCQ3GVUCbrQ6lecu6dDtT8KYOLj/h9A2X2NdXdQCSfKYFE4 +atJbIsfGK8klPy9CqLzJOX8YxBpeeIt4Mz1Ew5Znqjx0mBMNH3fldfnaBSqBFEoUl97CGlco gENUg9zR7FtJ5tbNBy59DHrJMgiUNIxISwRG1/y2j2IlADFtXDR8XmVr/4Ln7pa7SuJCptbge QHAknIdP1YEcMrDjKgqrCF3BaiFALjkplokoCG+qISSshOvRarqyVcyMovMUzYAxMCUdhXO8G pPmPnH5HASHTP2DSsrtFQSL1jcYJrMijvp8zzjDXvFLTbESnuScqCWmRNyQeIAeAZuFBWKTKk fMhbShfBJ+fPJhDqWH7D Content-Type: text/plain; charset="utf-8" Use the new buffer-based WMI API to also support ACPI firmware implementations that do not use ACPI buffers to return the BMOF data. Signed-off-by: Armin Wolf --- drivers/platform/x86/wmi-bmof.c | 34 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/drivers/platform/x86/wmi-bmof.c b/drivers/platform/x86/wmi-bmo= f.c index 5b00370a9a22..e3a126de421b 100644 --- a/drivers/platform/x86/wmi-bmof.c +++ b/drivers/platform/x86/wmi-bmof.c @@ -8,7 +8,6 @@ =20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt =20 -#include #include #include #include @@ -24,9 +23,9 @@ static ssize_t bmof_read(struct file *filp, struct kobjec= t *kobj, const struct b char *buf, loff_t off, size_t count) { struct device *dev =3D kobj_to_dev(kobj); - union acpi_object *obj =3D dev_get_drvdata(dev); + struct wmi_buffer *buffer =3D dev_get_drvdata(dev); =20 - return memory_read_from_buffer(buf, count, &off, obj->buffer.pointer, obj= ->buffer.length); + return memory_read_from_buffer(buf, count, &off, buffer->data, buffer->le= ngth); } =20 static const BIN_ATTR_ADMIN_RO(bmof, 0); @@ -39,9 +38,9 @@ static const struct bin_attribute * const bmof_attrs[] = =3D { static size_t bmof_bin_size(struct kobject *kobj, const struct bin_attribu= te *attr, int n) { struct device *dev =3D kobj_to_dev(kobj); - union acpi_object *obj =3D dev_get_drvdata(dev); + struct wmi_buffer *buffer =3D dev_get_drvdata(dev); =20 - return obj->buffer.length; + return buffer->length; } =20 static const struct attribute_group bmof_group =3D { @@ -56,30 +55,27 @@ static const struct attribute_group *bmof_groups[] =3D { =20 static int wmi_bmof_probe(struct wmi_device *wdev, const void *context) { - union acpi_object *obj; + struct wmi_buffer *buffer; + int ret; =20 - obj =3D wmidev_block_query(wdev, 0); - if (!obj) { - dev_err(&wdev->dev, "failed to read Binary MOF\n"); - return -EIO; - } + buffer =3D devm_kzalloc(&wdev->dev, sizeof(*buffer), GFP_KERNEL); + if (!buffer) + return -ENOMEM; =20 - if (obj->type !=3D ACPI_TYPE_BUFFER) { - dev_err(&wdev->dev, "Binary MOF is not a buffer\n"); - kfree(obj); - return -EIO; - } + ret =3D wmidev_query_block(wdev, 0, buffer); + if (ret < 0) + return ret; =20 - dev_set_drvdata(&wdev->dev, obj); + dev_set_drvdata(&wdev->dev, buffer); =20 return 0; } =20 static void wmi_bmof_remove(struct wmi_device *wdev) { - union acpi_object *obj =3D dev_get_drvdata(&wdev->dev); + struct wmi_buffer *buffer =3D dev_get_drvdata(&wdev->dev); =20 - kfree(obj); + kfree(buffer->data); } =20 static const struct wmi_device_id wmi_bmof_id_table[] =3D { --=20 2.39.5 From nobody Sun Feb 8 12:31:27 2026 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 4FBAB3148A7; Sat, 20 Dec 2025 20:47:22 +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=1766263646; cv=none; b=tY/5GEiIUopCLu1UFv7hse76nIIRE4F/9d5viV1ZyDk5j5MO+IXe5KqslIVZhglaDPGh2Xyz2IXGiOQOGK3tnp1N5cTjZ+Uo7DJIVXp0qUUM+A35fV70zh2YbTAKmlojrmX0UL3PMxcp5s4Xwv6Eye02cptzMW+37oHUNDni9M8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766263646; c=relaxed/simple; bh=8MWKvLKrIhwESL6K2lYU1hcXZLjKr62HLpiR+lptuBw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=b5DYE1X2PBW+wVrDbWv3FeN7uXja150vLvsXPLbEMTRVQj9p+kWuyNJrXkHFCJi3Kzhx43a0D43TbuvQ9GEE48u5/vyaALZcFjOAeJ24QRKsDcxSehY805NsG5FKiNBlcY8jlcYEV6n5LG2wA0NTux6J9aNbNYsztemk232VdmE= 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=cH3BAs5X; 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="cH3BAs5X" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1766263632; x=1766868432; i=w_armin@gmx.de; bh=WUXnniPV7qpv2Ba8+v4zPdnBdenui6dm7evYQTvUE04=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=cH3BAs5X3wMzUsKRrbLmr5lDObkYolTZ36uOgAp56JolgWStQemDBfdbrK37RwdB XjZgIVGS9Lguwzuy5sRg7Tpn09U4FZ7TJQm7zWvPwCNuZkwNFJs5HbTkiqKTLJ1+U 86AAFoocXvwvfzdYBcU/+mT7T1U9FhmIxyijZXSN0AnndFE9G09npXFQ4U+skK/Pz 6bPFsp+ZrjLCSuSX3NEQzRRBG7fE5cIxjx3Cr0wNrzhpIXWrNhBA2SLfKrV3oyCSI n16ArqnZTcR9TJKjaIk9VfmrU9voWWeMdu2NpeffF1zzMpnJpHDDsoeIsqWrBopLP k1G4YYjq5cXmPT0dQg== 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 1MIMbU-1vjDTs2eRQ-00G4dQ; Sat, 20 Dec 2025 21:47:08 +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 v2 9/9] platform/wmi: Update driver development guide Date: Sat, 20 Dec 2025 21:46:22 +0100 Message-Id: <20251220204622.3541-10-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251220204622.3541-1-W_Armin@gmx.de> References: <20251220204622.3541-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:fB+YMWr/OGeEizknCs6WChgvzdA9egoa9XTzsCZSDg91VpSvLm0 pH7bm5Spgxy6VYaT2L+r/8GJN2ghnu3y3sY4sHgFtEiFXV7Im8OFRkstCA38I4frVgs7BEb tlQ7y1wlsAJWsI0y20ARYDhwj8HaSG5lbeYSrMoB93anfkWUZ9ifhvF8Hg4MOWpdnwuqmwT zjVbxICpdLxpR21k8v2Dw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:RUcVby3TTQw=;VdMj8Qf1ffXNsTqIHwyRcoS69d0 w678CaH3nSKDwz7rOhhVVR83yWRTYOYUiX+k4Q+c0aPK7f09hTj1XrVdkaQQhr6/MGNXSAkgI j4jG7m3CU4fNRWiCmJVzXvoCFLMrAOD1i6hk3b2QKuC/Kdvks00GbTioP8zKGsZgJW2PXt1CS A0NuJLr2L2UJDCvVgtGIFObIxdLwHuApbZjpiKqhgqd3u1jdmxf0q+7Tni2JcRbD4opjK2MST X/7O8HcZekDtRnuEK5TYlE9o0SqcxcleC7qtY2Msm1z7i8VOERLr4cIy4XDGmcSM4ZZMrDmH0 c3Vo1XtjNWUeJ858gqAj1DRqSurRqJcqbhL/qIH2uRs+o4PcUgAreTD7kFh5KPrrGpfZjU55n AE8Dy2Ge61rJLzP/i/IbHatNIQEEppcYkn5aGPewMM8xBS0AMiRp/M7i4PYXw9KvtAWowV08F n9HcdKi9gBWiSZX2oO6HWVh1B1271EQdiVktWWufD9dsGKcUvUbjdUY5IWtRl72ESJAVFJoi+ rDVc1zRuT0SEsWeSvIgQFYnXW9QadLj+HBMU0cytQnac3YWUCXwGM/Kjm8kbL06xwbVYPNe2W kFnGy7gSydSIfyqiHfVaWoh9tytsRtU9o/Y4LR9OfXDSZW1EayJiqMHyAyjx7rKE1kmtjiV1F cJUjAGC5sryHZDLAyycxHLW1JsDwxWUPLhUwYb4iySFd/hGclZ4x9ScRkSnWyqFnL2t/Slnkf tjxOLjCcQJDC3ic3q1xJfcrUZ7/KcMXYEej3b/IU90uLj/osXgWxyD/cZoW/mSDrkzpOypUbR 6v5nJYTcxVoNl9eHHuf5/OqI7vWY6o6CpRbmRKRrBqAjjxtXIRHDhT4e3+B5iT6CCZdeYhIAD btA1BXOYCANK7TLTa+PcMde19pQ5T83fIPS4W6HWsrzoofuxRCQdIADaCpPZNQciSDQtrlvxj jLO4K0BOhfPgZRrXX9Ot07GjkXiO9XsXxFMLEjTF/RuuUS9F8xuyeauS9X17kjJ2d+J6CVWDN kfiz40iU2Mj2AzkBGGHbii5J2AMvkVbYtk11iXfsynpkXKbFsmKogzNZPlIeJIUSxffhfR3ci G5jN5FWr1JlBMxNWbzbbY0n9Nh15uPf2qfZfpd+Fbk8CMpmDQn613jQRcfzC+XlLJbCM7+jii pBlmExGm3aQjUS0N+wX3Jv/yaEdY12XA1rV9bLVusntrmMi9GWeVCcr/TBc7FavsAQrOJiZgd 0iyY1Q4JtMhOnt1pgAgPxBfXF/rHpgWm02eSWsyWsbn2PPtbEA8hj+Tg783wjuBgdB3IzkdeG nHWu5cAqz5gc+/E3H1JFY32SJ88JxLIXYXzP4dFk5DIuiyWYGOEnihIpX6WnWP5asJYc8Mp69 UK/UzZH7qUxJZDRsJnCFbeAPai6cUy0hGJgAcVxSlWtbosfYOdU86DyZc6Cv36VUKeGCYQ4v/ iwSOMfXP3CTKsTPQpnU/pCBh3uIlUjOVNtV3oPl7YMtC7WRPwC3D8rwKUNJsxTZFqCrhrqfP+ s3UShkPVuQqYq5cMXphLsgk5qOmPsyEnJzuwMFRFtEUUYMFMkQ01NW/w4efR5SeIGN+QW/hwg i4eIm25esuZoChQdOH8jJVzh1dOCp2TLL9y0kSBHyzS3IkGqux/UnP3hgDunnYexvR4swmIgJ C0HJllH1B+ofXB8rgnc3tVHmDZ/L0OtAhYs+c9UxdcmB9wIye1QMPMlDo7sQf1vOZVzl/6bdX cznrY9hmfuPOxnM/LPgx83j8mZxZI8XFY+v/ag0TCXptKtCKU9ueL4dye1fnWPj1Dy4kb+Yuq D3nAOp8I47c4cLf89i1c9ysHIsR9xiFP4VN8OSs/35eBNnNGyobnazzUUVB8bzaqMFO8rO7Ns 1voCUZU+R7Ls//zYdYsOajjWWT7ctDIvKgbuT0GWZD5/ZTMeDF+89tePEf1g7s2nRH6rFtVhK iBWQNVQ3ujCEaEWy+MVGUYut8UHKrVR3rwN9cd1BTiJVU0E4tDEj+MW1qjmMAZ7cvu2n11LBk bH/X4zbfckNwdG3n2qjqFJrSmIEckkbQt72bWBmpKRArIRz2P2ybDaw7cfhmr18K6itvSsk1S R6h9ptHRtPhygkpAkXffdooRlyJO3+VdO7RbIZHaQv7m3AzpR4hCod9CdiJf0SdFrGixeHcn+ /Zk+t3lMEQEmkleqlxvabjgPQoAHy5qzSzjl6O4jzfOCY7azphFidk7pA9upkwG61lUUM6s9d WDd1DbL/UKMhJ2Tb668oxzXp6+IzopXAD8RXlxpmDmsoDWQMhB79i+6eyXxi573tDdEeL80e6 T348vtiKLYuMASBv/z4kdwWWOh08pd04CuZs0dBZgfiPxwswTPOoMLqwtKYphx3iaOLMsfL24 /ksSknfS/q2v8rXOt4gWYxuM2IUIb01Sun5HvAU3THz6jdfOWGTX+qhxgXyvewsERQGPDS0m/ WIZzCrCBtVdnkfRAxHiQlsc4666SFZDxWoedHyHD1wTRV9Uvi0zFPobh1ipF3TAYpDJfpP2mC fYfTisWXppjC25skMMLFNPzNFAZdsWf6cmhvr6CuPoYbHxDwFLWJbBqeGIr5XZDCR6KBPf2uf IrTVD1qspN/dattdyrcALtMFAm/NRneUoj/QvLinIMgDK3C//pWKkP1kK3K+Q7PcwFGUuAsRi 0NidJFeggoEwYWAGwi4uAMByGzCouJnOADbz4vGuveR3dzI1yxG6ionSqy9Xq4EVJDUnuh3uq xt7NtXNpVTcHQPpI85jITSE8VWZUU6BDHyAFLtTF9MtA/yh+Cm32dIIJLuoLPxzevGNWj3X7x uj3RvVum1g/KDrmYES1dnVhf2kaEIRwIBfp6hYelc41k3jqYtf/FC7PGbPWnO1sfNbfwpGVJF eh9nOkc/11rJJrDmhDoizt+olxFnSHCnb3G6IHVfa0EX2qsotloud8LpjaDgjol9Dvz2TJqB6 Yssk//x2raN7ZLEOcZIRAVwUTjS29OBFPw3bDZmaS2kgJ9F0On0M/2HRaHjWv5ujEuRj3TeJJ LTenHh2K7g+IOQseUSTfkW1AgWhV/3GUWAdIN3n/F+SXwF7/bMebGE7qWYKyUk3x2gH9EKDyy +F23xhDMBpcXXJefQPQ4jeXLv4N7tD0S53EGcPTtCYjn3QcSBnQCKSwG/8ScRJJnd3zxy+inp XWPYzJHkJ87WO8TecNNuBvbn24jhJkjgOJrVCY1XBYJDog55JGToIw1IoEY9gnnoDV5EfWq4K xBUDDe7KqG/jSaGflQsBzjasC3H33Smu6dAbXbVuse/QEoRRZdwXU5gN0f2XiASGFMBFHERNk LmPYVnS4PX5CQ6jkKH+/PiRJa7/5ECpoAaHbEah5ydII4oVGDjgyUUWcSwUD40rVK/ZwHWQ3R BbJaDfM16MO0pZH6CywoteZuDWLhccdE+VqONLPlCEbQQ0Ehhkt2nqEOILf33dbrbGiEoyH4i SgHERgmrHXhEr5uqYxs5j7FtGLh3ZTIfX41UDKuCdbRzibk4ZcwpnsGP3r7cljngusjMfdCLV Y85WbTspPH6Q54GYR5PxIMsvS49PNm8qlZ284CYaVXUy6uh82mtq/Xq/HDu5/vEwZxLar5Z8m aBzRSiMVT89SvTXT7FD/MtO+MKK57o5b1s8LFffUuqmBnGgV5kedYE/Dbho9lbvRSdy/bT8H4 tjKkaQKhQ1/Bvb96lOFBPklFNJCtCy+Z6I1w8ldmpYIPBvQBU1OoNbYPtHJC+/2yeEenl8wh1 fmTrexLuadkAJiIB1gtXiNfLQIEllRlfAsgQzGZiNoA68xM7SeT2jkV4OjEKI39tZAaxxuIn1 6KBGh1WSsvNoTtN4mfRU7cuCZSAfc8KHzSo/LQXEgPLsG+rENqE1OkBuMAalILhZ4XxPvBGvy 07IwrLlKR0/tdQrJ+7Ux8Jg6TzikWoFucix1UCIUhc1+sauE4U7QHyWiBfdVUu1JEaobiv+4B PWngJ2lhaS7Qk5/GCXde7utpbgFGCrXbpoWFO2nXJHsH1jO3Zj0r9590bwPJgGcKt8F0sEINX 3Rd/JHAq8pjMfxj4TrYOQsIrKTdBb2/hvNReVQhY/3h4TzLfX3YBpu6/r3ofef3g11UMjWLDe 2dJB7En6/Ax0wk5JDlDXyff36Wp+LYE8wjALqfBkXABuTfEGfojabEGUbd8iyB91WA1FvBmXt 2Tm0a5Od7VWQoOz9MIRVjnofIDH4cP3njbPkTQ2yRYriW+kKSNMWAauPzV0u/ZVRxYxVxgRfw P7wss8mM5BnqveY+XknaTn9fxf0+uEwifQAQmaPABo9CzvpA0XIXBjLpVExPKJLkAMowU+ftF hXQN5cm2FArYuIreei/H2K3iN1EokPd4kCo5a9bGjG/xh6yTPE3pe1kRVB/Jp4wW9hNEEKv+Q clPCs9/7P4AQNY6fV47V1UGI+sJqE/yHZOzLoaEJsLcFJd62h3Cvx5IChRRxZbpTTJ5IWoDsI mSkTpB3peOXzD3b9g/RELzhmAbBlWcAo0M4Mqymn6y6zVzTrp/FdXjesdiBSzNaiO8APUbw4h MJDsnKqJeXjORiC76/I/UYlFfr8a8kotfILrikWPuz7vrtAezge7kJXzcHl+ExnyqniUirzAL 5KLlaaZFiCVa3stHW1bf1lFimR+esNxQ9JCS5TbYvMTZDUk1aDUa+9QPxRS5QSdI9yFtjBGbM 1x/1mOh008cKiEh9hDFpLbLr9D1aFJI8OWvTUGBe8pIahLCP1KQgdL6Jokj9MwmnoV26Zp1SL 8m6hQhKD8XAY3gdbIUvXss1X4pLbFhEfluw82lygnkHUlOfROJ1T5Pd9VBbGZbDpNedD9D6rp i/nJvvETRpW3F/OvQ1maow8bdj1JrHlFvMoE1wdAahRe8Nh9uEos1sK+4yz7OhPdelt+IGNWc NCcTGFHoh46ZqMZvU8m5vNCS0Zebe6CgrQr1+f7J7gW73htZye3auWHpRVhvFUCT+s1GtTEdK LuWSjRpTV9pUKjzzkDOoZ640JUuNoSYPM2nlWtJvEFY55j+RNo867F5Wm4tYflkT5okHZJhEG KJaj4EaczNRIjYeh2IZmbB4dSF6/AJtMSH0AeAzEpFFniq3DxUGgEBT+Ye/VdnU0+pXPLKcVm TgmNN2Vw13kSxJc1D+TWZzmTIOj+BUrNjzxKOx9WHGGEQAGTNTm2dbnplPos5twJO6LHA2XgL BXRh5pvg= Content-Type: text/plain; charset="utf-8" New WMI drivers should use the new buffer-based WMI API instead of the deprecated ACPI-based API. Update the driver development guide to recommend the buffer-based API to driver developers and explain the purpose of struct wmi_buffer. Also update the ACPI interface documentation to describe the conversion rules for converting ACPI objects into WMI buffers. Reviewed-by: Randy Dunlap Signed-off-by: Armin Wolf --- Documentation/wmi/acpi-interface.rst | 68 +++++++++++++++++ .../wmi/driver-development-guide.rst | 76 +++++++++++++------ 2 files changed, 121 insertions(+), 23 deletions(-) diff --git a/Documentation/wmi/acpi-interface.rst b/Documentation/wmi/acpi-= interface.rst index 1ef003b033bf..4657101c528a 100644 --- a/Documentation/wmi/acpi-interface.rst +++ b/Documentation/wmi/acpi-interface.rst @@ -104,3 +104,71 @@ holding the notification ID of the event. This method = should be evaluated every time an ACPI notification is received, since some ACPI implementations use= a queue to store WMI event data items. This queue will overflow after a coup= le of WMI events are received without retrieving the associated WMI event dat= a. + +Conversion rules for ACPI data types +------------------------------------ + +Consumers of the ACPI-WMI interface use binary buffers to exchange data wi= th the WMI driver core, +with the internal structure of the buffer being only know to the consumers= . The WMI driver core is +thus responsible for converting the data inside the buffer into an appropr= iate ACPI data type for +consumption by the ACPI firmware. Additionally, any data returned by the v= arious ACPI methods needs +to be converted back into a binary buffer. + +The layout of said buffers is defined by the MOF description of the WMI me= thod or data block in +question [1]_: + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D +Data Type Layout = Alignment +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D +``string`` Starts with an unsigned 16-bit little endian integer speci= fying 2 bytes + the length of the string data in bytes, followed by the st= ring data + encoded as UTF-16LE with **optional** NULL termination and= padding. + Keep in mind that some firmware implementations might depe= nd on the + terminating NULL character to be present. Also the padding= should + always be performed with NULL characters. +``boolean`` Single byte where 0 means ``false`` and nonzero means ``tr= ue``. 1 byte +``sint8`` Signed 8-bit integer. = 1 byte +``uint8`` Unsigned 8-bit integer. = 1 byte +``sint16`` Signed 16-bit little endian integer. = 2 bytes +``uint16`` Unsigned 16-bit little endian integer. = 2 bytes +``sint32`` Signed 32-bit little endian integer. = 4 bytes +``uint32`` Unsigned 32-bit little endian integer. = 4 bytes +``sint64`` Signed 64-bit little endian integer. = 8 bytes +``uint64`` Unsigned 64-bit little endian integer. = 8 bytes +``datetime`` A fixed-length 25-character UTF-16LE string with the forma= t 2 bytes + *yyyymmddhhmmss.mmmmmmsutc* where *yyyy* is the 4-digit ye= ar, *mm* is + the 2-digit month, *dd* is the 2-digit day, *hh* is the 2-= digit hour + based on a 24-hour clock, *mm* is the 2-digit minute, *ss*= is the + 2-digit second, *mmmmmm* is the 6-digit microsecond, *s* i= s a plus or + minus character depending on whether *utc* is a positive o= r negative + offset from UTC (or a colon if the date is an interval). U= npopulated + fields should be filled with asterisks. +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D + +Arrays should be aligned based on the alignment of their base type, while = objects should be +aligned based on the largest alignment of an element inside them. + +All buffers returned by the WMI driver core are 8-byte aligned. When conve= rting ACPI data types +into such buffers the following conversion rules apply: + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D +ACPI Data Type Converted into +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D +Buffer Copied as-is. +Integer Converted into a ``uint32``. +String Converted into a ``string`` with a terminating NULL charac= ter + to match the behavior the of the Windows driver. +Package Each element inside the package is converted with alignment + of the resulting data types being respected. Nested packag= es + are not allowed. +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D + +The Windows driver does attempt to handle nested packages, but this result= s in internal data +structures (``_ACPI_METHOD_ARGUMENT_V1``) erroneously being copied into th= e resulting buffer. +ACPI firmware implementations should thus not return nested packages from = ACPI methods +associated with the ACPI-WMI interface. + +References +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +.. [1] https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/d= river-defined-wmi-data-items diff --git a/Documentation/wmi/driver-development-guide.rst b/Documentation= /wmi/driver-development-guide.rst index 5680303ae314..fbc2d9b12fe9 100644 --- a/Documentation/wmi/driver-development-guide.rst +++ b/Documentation/wmi/driver-development-guide.rst @@ -70,7 +70,7 @@ to matching WMI devices using a struct wmi_device_id tabl= e: .probe =3D foo_probe, .remove =3D foo_remove, /* optional, devres is preferred */ .shutdown =3D foo_shutdown, /* optional, called during shutdow= n */ - .notify =3D foo_notify, /* optional, for event handling */ + .notify_new =3D foo_notify, /* optional, for event handling */ .no_notify_data =3D true, /* optional, enables events contai= ning no additional data */ .no_singleton =3D true, /* required for new WMI drivers */ }; @@ -90,9 +90,9 @@ the WMI device and put it in a well-known state for the W= MI driver to pick up la or kexec. Most WMI drivers need no special shutdown handling and can thus = omit this callback. =20 Please note that new WMI drivers are required to be able to be instantiate= d multiple times, -and are forbidden from using any deprecated GUID-based WMI functions. This= means that the -WMI driver should be prepared for the scenario that multiple matching WMI = devices are present -on a given machine. +and are forbidden from using any deprecated GUID-based or ACPI-based WMI f= unctions. This means +that the WMI driver should be prepared for the scenario that multiple matc= hing WMI devices are +present on a given machine. =20 Because of this, WMI drivers should use the state container design pattern= as described in Documentation/driver-api/driver-model/design-patterns.rst. @@ -104,38 +104,37 @@ Documentation/driver-api/driver-model/design-patterns= .rst. WMI method drivers ------------------ =20 -WMI drivers can call WMI device methods using wmidev_evaluate_method(), the -structure of the ACPI buffer passed to this function is device-specific an= d usually -needs some tinkering to get right. Looking at the ACPI tables containing t= he WMI -device usually helps here. The method id and instance number passed to thi= s function -are also device-specific, looking at the decoded Binary MOF is usually eno= ugh to -find the right values. +WMI drivers can call WMI device methods using wmidev_invoke_method(). For = each WMI method +invocation the WMI driver needs to provide the instance number and the met= hod ID, as well as +a buffer with the method arguments and optionally a buffer for the results. =20 -The maximum instance number can be retrieved during runtime using wmidev_i= nstance_count(). +The layout of said buffers is device-specific and described by the Binary = MOF data associated +with a given WMI device. Said Binary MOF data also describes the method ID= of a given WMI method +with the ``WmiMethodId`` qualifier. WMI devices exposing WMI methods usual= ly expose only a single +instance (instance number 0), but in theory can expose multiple instances = as well. In such a case +the number of instances can be retrieved using wmidev_instance_count(). =20 -Take a look at drivers/platform/x86/inspur_platform_profile.c for an examp= le WMI method driver. +Take a look at drivers/platform/x86/intel/wmi/thunderbolt.c for an example= WMI method driver. =20 WMI data block drivers ---------------------- =20 -WMI drivers can query WMI device data blocks using wmidev_block_query(), t= he -structure of the returned ACPI object is again device-specific. Some WMI d= evices -also allow for setting data blocks using wmidev_block_set(). +WMI drivers can query WMI data blocks using wmidev_query_block(), the layo= ut of the returned +buffer is again device-specific and described by the Binary MOF data. Some= WMI data blocks are +also writeable and can be set using wmidev_set_block(). The number of data= block instances can +again be retrieved using wmidev_instance_count(). =20 -The maximum instance number can also be retrieved using wmidev_instance_co= unt(). - -Take a look at drivers/platform/x86/intel/wmi/sbl-fw-update.c for an examp= le -WMI data block driver. +Take a look at drivers/platform/x86/intel/wmi/sbl-fw-update.c for an examp= le WMI data block driver. =20 WMI event drivers ----------------- =20 -WMI drivers can receive WMI events via the notify() callback inside the st= ruct wmi_driver. +WMI drivers can receive WMI events via the notify_new() callback inside th= e struct wmi_driver. The WMI subsystem will then take care of setting up the WMI event accordin= gly. Please note that -the structure of the ACPI object passed to this callback is device-specifi= c, and freeing the -ACPI object is being done by the WMI subsystem, not the driver. +the layout of the buffer passed to this callback is device-specific, and f= reeing of the buffer +is done by the WMI subsystem itself, not the driver. =20 -The WMI driver core will take care that the notify() callback will only be= called after +The WMI driver core will take care that the notify_new() callback will onl= y be called after the probe() callback has been called, and that no events are being receive= d by the driver right before and after calling its remove() or shutdown() callback. =20 @@ -147,6 +146,36 @@ the ``no_notify_data`` flag inside struct wmi_driver s= hould be set to ``true``. =20 Take a look at drivers/platform/x86/xiaomi-wmi.c for an example WMI event = driver. =20 +Exchanging data with the WMI driver core +---------------------------------------- + +WMI drivers can exchange data with the WMI driver core using struct wmi_bu= ffer. The internal +structure of those buffers is device-specific and only known by the WMI dr= iver. Because of this +the WMI driver itself is responsible for parsing and validating the data r= eceived from its +WMI device. + +The structure of said buffers is described by the MOF data associated with= the WMI device in +question. When such a buffer contains multiple data items it usually makes= sense to define a +C structure and use it during parsing. Since the WMI driver core guarantee= s that all buffers +received from a WMI device are aligned on an 8-byte boundary, WMI drivers = can simply perform +a cast between the WMI buffer data and this C structure. + +This however should only be done after the size of the buffer was verified= to be large enough +to hold the whole C structure. WMI drivers should reject undersized buffer= s as they are usually +sent by the WMI device to signal an internal error. Oversized buffers howe= ver should be accepted +to emulate the behavior of the Windows WMI implementation. + +When defining a C structure for parsing WMI buffers the alignment of the d= ata items should be +respected. This is especially important for 64-bit integers as those have = different alignments +on 64-bit (8-byte alignment) and 32-bit (4-byte alignment) architectures. = It is thus a good idea +to manually specify the alignment of such data items or mark the whole str= ucture as packed when +appropriate. Integer data items in general are little-endian integers and = should be marked as +such using ``__le64`` and friends. When parsing WMI string data items the = struct wmi_string should +be used as WMI strings have a different layout than C strings. + +See Documentation/wmi/acpi-interface.rst for more information regarding th= e binary format +of WMI data items. + Handling multiple WMI devices at once ------------------------------------- =20 @@ -171,6 +200,7 @@ Things to avoid When developing WMI drivers, there are a couple of things which should be = avoided: =20 - usage of the deprecated GUID-based WMI interface which uses GUIDs instea= d of WMI device structs +- usage of the deprecated ACPI-based WMI interface which uses ACPI objects= instead of plain buffers - bypassing of the WMI subsystem when talking to WMI devices - WMI drivers which cannot be instantiated multiple times. =20 --=20 2.39.5