From nobody Sun Feb 8 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E88776FC5; Fri, 16 Jan 2026 20:41:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596099; cv=none; b=JB7iGX8mrFyiJLUKajAe+rmtlzxWBh6L22XxivB3bm8ii/KWSn3OM8F1dho0eETJvZf4zpvTLoZfhwVdcjeyVfTkwkFcRf9G1YL+1we/yEnuX27qslqb7IggbkRkt3JtqTb97ZAF5C0jGR1Rig9Wq4ujA/ox5iP0XRQs7+NIo78= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596099; c=relaxed/simple; bh=qT+2sjf30wZ5UC8+y4lY3vfWzM/sOEocts0u7zir5z0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=gYnrwvL/zsAIZlZL/EHqL9SXzwSHc5QMj892T/fHm2bBpWFWDwFdAqfMjwb09GfKT9JwWAw8byuP0q1V/dKmUaSFZwYpHIlK30iu4Im3inlaK6yR8FGxTo10Yl+plVLyXlC3RyLnV1K3qmhNnI9uFxGpwWOEE9mqxrMnvtJ2YDQ= 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=aBk9e5Nb; arc=none smtp.client-ip=212.227.15.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="aBk9e5Nb" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596092; x=1769200892; i=w_armin@gmx.de; bh=ukB6cf3vC4mjh9KvbRYIgdauBC3uUHGtcJJ++dTUbtc=; 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=aBk9e5NbYd0xPfcu67Yf64Fv/KSAdGmeD6EBRv+nJ08RcQ0SMdiLDfSgRBpn887m T3GLMJqhazyq28ScAN+wQuzTZmmHlYF8BjQ7QPCgy+pOcKyUiYMa8wdRkFqipm0pW erefZnVTvNky/ChbG8/GAcQCfZn3XJag6ZrvJkWbpFS9zyhOIe6LDmKkOYWe6cEkB eOW3x6LcZrX0q2w2WO/FuEPRgT1uf7rMlSsjxmTujZTyqHVC6ZaDyNgN2MV/f2rk3 VNzx00WBh4hzNILUxt70UGB4U+0at8kjpw/N9kjjmckEVcSLQFjuEROq6Yz2MCZjg XLbdsR3lEbCh0/YrxA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MJE2D-1vMqm03O8J-00NxWr; Fri, 16 Jan 2026 21:41:31 +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 v4 1/9] platform/wmi: Introduce marshalling support Date: Fri, 16 Jan 2026 21:41:08 +0100 Message-Id: <20260116204116.4030-2-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:FfK+MWLddMEUYl5FtxzYU1kjoS1yN5c5FwGJr0wO4bjM6tVpZ6D JIkHOeVoKgPib+MXpkag215Arnx/jIwc7sr4abHvhJm/r/92Mhq3n0wuj14qgTI+DNWVC7V Nu0z2ycvlZHQ3T0kO5PWxjpnyoA69BkiF3QHgdF5BYPRr860DhiIU/LDbwoU1mkYajpo8Ma JmLgwE/NFW8lc2FBVkZaA== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:5IEmMkENxIc=;g5rIqPuExY99mTT2dMkxzdBh3bx jZ+mj/t8XhPI9wCdLnZj0MkQmN9J7zpInYecDAj3wmM6ntBzqSyuMgIcD4zJR78sqrhxWYaeU gFDpm0pzjBQLgJ3hVs6/pBYKLrikXdDNcs1FFxAsEkvRmXsZlFZ3TAVRm48Bq6eoF15wc4f6k vk9/MCkOMxJ2YOwzyaaaUOrKhGYB6IvkcN0bibaU1KLQHbFCFiglv4XyQRKJZWe4ET8m5tS0C iEDBEhpGlf7Cx7D20cXRZKhHrvoK4RwG5RjrRs8l9TzubMrATvqTGejjx8zS0o0710vU0wgbY YUX0foiiKI15N73pZZuwNhFfDZZRjT9Yf5uPebzwQ0/AyHbsKGNQiaRV7L6r3QiWnlY6hhWEo IpRJW+/wVxQ8lKm+CViNznx6tv+sSQyDQxEsCCKFa3JVTMeBX4chwGcLrIXKHwGCGw31kRxyV JmMPkRypuW6iWg8D8FbS7EruPtgvpCou9R38SfgirjrHuSvcqHtlbbRLEla+yjEk/+9HRrlLs sIoqQLzPUd4Mp8hW/ygPu1afx6rN7mx66ao6bBqPr7WCL8ZhQo1/dJnBHzovnhzYuRIWZOqH9 evifqosBi4m/8tmOZzrVq8YgQU9i8+Mwxt8iJeG4CsdKcYnkFwEbcGpWhS+PYkwjdg6Ylcsmr XtEqnMgYREZTR3ld3bep9GNwdho4Ve73xysaWuzgBuJrKz0DRKlZBoTghvyLtYRDExW41GMHd oJykspzoyPCHRxyiUC4DOO/FswdgWxt2PpgRjUCMNaFlE7iqom0R/vDwcePWYgVpMNVmAZ1v1 cDlvRwp+VbjC2z/LN4EAuxhGoeLKF3aDbxh/YkqW6vpcCjFucr/Dxmx0W1Tq+I6+jwtH5HYin MuIJPa0wrKScKICrYJrCm/4ib8H48vNgS2XV68B42qCNTqvrWoNjCzlXnZWyEN5tVstIYYmpG cpr7fNPEKb9TaH70fyH6fgbOs+CUkT4Ji66PlO2wAgt57HrrThXqUQirwi4AYrfFeueX8x0O6 lQUD3YFRDGBEonLgKEE1J4TlivI7Emw18eJuOy/M8vw0+bMiNeqPbgRwIEn60dxCYXuodEjwy Av2c8RZ7bMD/ADjvbQJ/nCwFSPALsRhUAt4jPjQl3dQU4UzqMpqvb+mbnX8IbJnPF1H0ey/Zx O5wtL7AbGYVkCvQf3ohxC1Hk9BlKWJWNKfQlkLW6N5XKuVGB569t+Y4UFDNqVVj34ne75ZXJP ys0+GraiuISvniDIWer1UZcVKsaCH+sDEoLDZK+/tI7MUQsq2cHQRNFk5h/RKZCS5Yd/AcEXI gEvHRnjDK6xTW8bXrbcEQQpVT5os9CFD9R5mXW/emcol0nuHTIOvDjn64xFwKkGpONpNZaSQp YAwfkgY1R6QeSqSEftdzSXTAPBHmGNUjEpKZq+vDFeu+eVUXi7KV9CQbrvYMtR9adbkGvs41Y Vtw7qfNbbcUzZoItuUKYGzzlBIEHxbNRD6L1rbrJD4QA7gf4nBBIxnjO377CFViEArImXBhY9 jWmFpTWSBeI+0JO+Ft+YMP/2sVVr906oAUmx7Bdnzux9hwaXgCP8C64pDDZ0HOqVcOJS5xitD bEXRd9bH2my0mktilDoZQbhIj5n/7J5lmawg7mL1/3uhFEyPSHVkpZzyOJXDGFlR+3oqFB41W NWSsWYRhpebI9cOcse/ueS+5wcyvgmSoJUn5wvUGV1UP2Ru1W0asuujZjpYfLOC5wiWP0h/+y 00o61kvaY0NP4SMU+stz7uLi2aOSNnIpeWKYEUtRRzUGF7gs2Hh0U5RSgavfUA9SeSLw2N45b xe5o+3cmhpw3UAYrMiFrnQVN0y9vPZmQ0Wx5gnjEMpho+bfjc+OsL3Yc+rpkmJfp1SQP/0Dc3 S2C5fEx9EtJjzv5MpG9eOEZyBhuz5nKWbkKMivqm/NL4O/QQAtuUKR3u/AvuSI8vIyNAqVVNn ua/M8QPcKbw1SMSpdt94T5qYvIJrcJje3bBXK7t8I4l496xIQnPg7+vgKktsraMJsYyg5CjTJ zNg3l0McKSuiMA7zt1X4vtXcxTjYkVS88hEqRx4eyObFrw08ECjYjXCRALmVYhmTE19SjDJD3 NcPkMerwL07Fwf1NrMdO6d/TU/jASCUIB9AtD/RutwV77KEI4AGYTq4rYICZEIQAziP8Lh2dD sbeGjHXRnK6eueWj2udhnyJ1uu6gvJlhu0rZXZOSSofLl5Mc9RHb2pYRKkY8eDdnY6WXWeqKh ZcKo4gWwTOVDjcie6q0dtAXcNc93xjWZNUvUpV9B3kPo6rYR3Jyi/ew4LG64LoFpJ3LD/NC/2 Cur8eXuETEC2gPrkU3UGaNBLwwl2tzN+UjmAZ9VvRhGxVkjAlpabpA4mAPj5NVK3QSLrgzLUi i9VEwhxRb5dqf2hr9WwuljtmATA09FtwjqSI2ZTK+piMcRM7m/y1FHcLbWJarQcxtjEqBEHVk Dd804hh4La7WlLl6pI34RZ3sZu6JPd6tD5N4UTYGnVTUVAb2iy7L+zgnS/3+1aa2f6c/L2H11 xZTF1VGnC+IE/4+ILRaFhaoCarsWBoe+ciEcEAQHkwy1XZPW1KSs9lOXjA/n8me/nv+ywfZpa /6UdDjOdXjOW19oxnBN31hxqIFJ2A9+DPFe+j1vE60a/d7aTmTejG03hj+wbODvcFZi49wjEV aFzxBriFjVRBQipXbReVXwb33co9INLc+332Go5/j6PXkUIGSP4G5JW3x62SBu8V0cs1VuEb0 Zr3G+WRByXEVLDiTporVqYCuuORF6ZBfPnYXzrGtAs8og6+pSY7aKtz+0n/Ndbcfo8kSxW+wu dB7tc72FI1/SEEjUHXwvPgVGT4WAHBuK1AZoiADw9Q1FG9UZk6QGsvVXjVflAxZSH8QKpFpI/ lU9+mD6TldYaK20KIdtATo2shAE1e/IcxabyfEqV8Q/ruHES7xemxr/WfT58EPwCbjlN/TZ76 UxFwa5k1ROCFN0pNJGeOewkZOR69HFikjHEQLWn0+cMsJesUdlv6o2cPaHdg/5mfFKEhDVWgC 7pjbmd362b6++XW3xAMEsQrwFLVGWBdA7UZmRA0KjfzPb4ZTxgROu29WCq+3bYPyhnfbuCTOI U4+MHfV1PlEC5MKYFb6rdUXJx8f1nr0m/2QuU9Z2+wKQZA0cu8Om5ETbYvCKCApSiGwx7jkJ/ OHaCAGi6/vqCSV2ERfJidfWWBAtayF4+bu1w6i9Mv/d9SitArwcSnSiciFEWTeoSgkXT68bfU 7cM1/pZVo3+yvCHrmA0POB1XJyOXo1q0EuS84UKjPD4wiNjAc+e4DBdEqAUzSJnvXES9TeG6R lCiT0WRJDteZ4exf7XIPDmaEnJmfObAQIXrZGdjFvEZjRTUL0GVaK9qqiENYNRaT+U1zbNjyq W9NNUUFilAxI/RTGHxAl9H4RUVsiQ4REWqvo+XK54uEJJX+LoYIIpkBrMF/ko0/7ufSHgE9Cl EKM5QUjKLjRNkRnW3qarGrjOMv6IKUeYS+OL0QPZuJIRm45BpuHoDnN/YrGVc3rmO7k21KKl/ mrsZh48NIN6vGFUun38X4xy9eRhFm8dN5iK61559k/AB61bO9YriVG9E0sAU5SmIA18BQBPsU i3rULMSnFf7usOLCYwcQpDa75E/fpvpEj9+zh0210VQfvViHpUtCyXWhQS4WTc9XKqrHdz8ks v8NWL2OWuymtuNbBPfi7Aycv0DKpyOGGGKcCqnho8k//0ytb8abnGr7ugV9PknV+wQIWg5LJt dXDnAYUWbiGmm/E6e1ifaMOmvk/faV8se54j6/9NG75bxwy4E5Qkcah/IBxiuPC69jw9SYSXY 4LNyPJu7Xc63W/WUGND4wEaVbNn8ZNA1aV4LYlSHo4xCN+o4a/a1bT+Y545EXwg1krT8DFxqM pobFZIj5abbESD+f1bqRjvC4HyScE3i4CMcsBbhho7COzYhT/kuL6wEvodPa21876m1SlYVQO Pz6NTRzKcJJMOtEM/q/6OuZnxsyiGAGzJr3iIJJw5bMAF00jlabafPAjf1rXwyOeTjOQj0ULG P+ClbyF+orCUkpClS1t5WzxQvAtLFsPckhEudbqjGBf2y4zGXZAxGFHnZvXKeHHIsHgnzuogC qDgMoOr83hkalM+9i9oHY9UqJn9BJjwbjujD1E/DRfEJYdfxvuSI32CuEMP6anuKQM1Bzl5/h xNa7LASt3/6gkiVlutAVCm3mCJQe4mQ/3nCyf4KxQ1C+kAYnZXw2aZ/tdP5BgFG2AqWxAKN+R RTVwjENBFcMNr3JN564rJSwiYU6/0h/wBSN/t7SdHygBfYMgoUjZkpsuDFc4Bb2k2RtvTzCYZ IKWEIJB8N7P9FdMyAR7CzsDLggbV44koqoNQFq7YSK+Vc8PBYAOBFL6tz3yp07GCRUPkGwgBG TyzzsfTqJ2H7OeGCnCJiEJG+j548oV/utYQEEkMiKK6MQBwM8Wlo7NN9IFoT0Vhm3Xl98MvKk fIQPTYXGqz7+yTgUKXg4IOyJOjMLrsRp8ImwC+8v76hAX7Ywx+qAqOkXcfj5c20+py0Lro1ig civZ2BG+S2Ie2QjnF/OroJKKTCKDsqcmpgTht75Dg+Pr65akum3cB0VEgcsHqKBg+ApyyVnTL GvmxOxEhRfOSGLcuyrfeWXbZnFPyD66uZ9z+b+/d7PSwM7xwkSNvzdZoSUSmEM7jx6Pa0DJQ1 cERhM+eVb4VRMnvumsWB1OgeNlxXwug8fA/sm75g4xsNxu3/q+7dDbfx44fnL9gh69GeQq0Dl LJOlGvxrKuGcjUNbeAPiFMrpPNDQkAi199JWbkCLRkvYS3m9lGdXU+pEht17zhoV2eAgMVVth oC1NyOssbIi7NnXdfIuc7MPsuVxOvugg+Kb32lHMuXWMZaBbcpgYHGiT4/PquuL8SsSL4Dk6j nWiqDoNIHNqqTEz7AsSuHF9wsrmlS5wMfM2yyZI6rmY9cNh3JrdbzmlFO0B4ZXgtgWSK5OEsB 5abA48T4CBN9rSksEuiW9vk4IQy24LW3erTyhLaDwpkRumm+m8dSKgQyHR43iue8VSGGtdMqE sO/ljyfeSoVfwNRQEO2KULZOJSqsxJX64/Y2mzK5KvKoZs/yxX/4x7EpHlDHQKKX+yum9Q/Aq CyPnA7+JOV6NlTvR9ioeGSt3T7j6oU+dcnjs1aAl8xebEOk5huIJRKVLokR2AxDefqSCK479a apmSO3cfDJJNveIpyG/KQL2QyMVAaKXUJz3AzmUDImgyTnyR+3xcZhHC7ASjcv3zmxdE6dpOi HrwVIGRNEh4vPVZsO43rJJJ3LDJGxl6X+ykszkT2ti4Hxf34d8Jl8ERwNIJ4b3w= Content-Type: text/plain; charset="utf-8" The Windows WMI-ACPI driver likely uses wmilib [1] to interact with the WMI service in userspace. Said library uses plain byte buffers for exchanging data, so the WMI-ACPI driver has to convert between those byte buffers and ACPI objects returned by the ACPI firmware. The format of the byte buffer is publicly documented [2], and after some reverse eingineering of the WMI-ACPI driver using a set of custom ACPI tables, the following conversion rules have been discovered: - ACPI integers are always converted into a uint32 - ACPI strings are converted into special WMI strings - ACPI buffers are copied as-is - ACPI packages are unpacked Extend the ACPI-WMI driver to also perform this kind of marshalling for WMI data blocks, methods and events. Doing so gives us a number of benefits: - WMI drivers are not restricted to a fixed set of supported ACPI data types anymore, see dell-wmi-aio (integer vs buffer) and hp-wmi-sensors (string vs buffer) - correct marshalling of WMI strings when data blocks are marked as requiring ACPI strings instead of ACPI buffers - development of WMI drivers without having to understand ACPI This eventually should result in better compatibility with some ACPI firmware implementations and in simpler WMI drivers. There are however some differences between the original Windows driver and the ACPI-WMI driver when it comes to ACPI object conversions: - the Windows driver copies internal _ACPI_METHOD_ARGUMENT_V1 data structures into the output buffer when encountering nested ACPI packages. This is very likely an error inside the driver itself, so we do not support nested ACPI packages. - when converting WMI strings (UTF-16LE) into ACPI strings (ASCII), the Windows driver replaces non-ascii characters (=C3=A4 -> a, & -> ?) instead of returning an error. This behavior is not documented anywhere and might lead to severe errors in some cases (like setting BIOS passwords over WMI), so we simply return an error. As the current bus-based WMI API is based on ACPI buffers, a new API is necessary. The legacy GUID-based WMI API is not extended to support marshalling, as WMI drivers using said API are expected to move to the bus-based WMI API in the future. [1] https://learn.microsoft.com/de-de/windows-hardware/drivers/ddi/wmilib/ [2] https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/ driver-defined-wmi-data-items Signed-off-by: Armin Wolf --- drivers/platform/wmi/Makefile | 2 +- drivers/platform/wmi/core.c | 160 ++++++++++++++++++- drivers/platform/wmi/internal.h | 17 ++ drivers/platform/wmi/marshalling.c | 247 +++++++++++++++++++++++++++++ include/linux/wmi.h | 40 ++++- 5 files changed, 459 insertions(+), 7 deletions(-) create mode 100644 drivers/platform/wmi/internal.h create mode 100644 drivers/platform/wmi/marshalling.c diff --git a/drivers/platform/wmi/Makefile b/drivers/platform/wmi/Makefile index 98393d7391ec..6f2bf8cc709e 100644 --- a/drivers/platform/wmi/Makefile +++ b/drivers/platform/wmi/Makefile @@ -4,5 +4,5 @@ # ACPI WMI core # =20 -wmi-y :=3D core.o +wmi-y :=3D core.o marshalling.o obj-$(CONFIG_ACPI_WMI) +=3D wmi.o diff --git a/drivers/platform/wmi/core.c b/drivers/platform/wmi/core.c index 6878c4fcb0b5..1601bf9fe135 100644 --- a/drivers/platform/wmi/core.c +++ b/drivers/platform/wmi/core.c @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -33,6 +34,8 @@ #include #include =20 +#include "internal.h" + MODULE_AUTHOR("Carlos Corbacho"); MODULE_DESCRIPTION("ACPI-WMI Mapping Driver"); MODULE_LICENSE("GPL"); @@ -302,7 +305,7 @@ acpi_status wmi_evaluate_method(const char *guid_string= , u8 instance, u32 method EXPORT_SYMBOL_GPL(wmi_evaluate_method); =20 /** - * wmidev_evaluate_method - Evaluate a WMI method + * wmidev_evaluate_method - Evaluate a WMI method (deprecated) * @wdev: A wmi bus device from a driver * @instance: Instance index * @method_id: Method ID to call @@ -360,6 +363,70 @@ acpi_status wmidev_evaluate_method(struct wmi_device *= wdev, u8 instance, u32 met } EXPORT_SYMBOL_GPL(wmidev_evaluate_method); =20 +/** + * wmidev_invoke_method - Invoke a WMI method + * @wdev: A wmi bus device from a driver + * @instance: Instance index + * @method_id: Method ID to call + * @in: Mandatory WMI buffer containing input for the method call + * @out: Optional WMI buffer to return the method results + * + * Invoke a WMI method, the caller must free the resulting data inside @ou= t. + * Said data is guaranteed to be aligned on a 8-byte boundary. + * + * Return: 0 on success or negative error code on failure. + */ +int wmidev_invoke_method(struct wmi_device *wdev, u8 instance, u32 method_= id, + const struct wmi_buffer *in, struct wmi_buffer *out) +{ + struct wmi_block *wblock =3D container_of(wdev, struct wmi_block, dev); + struct acpi_buffer aout =3D { ACPI_ALLOCATE_BUFFER, NULL }; + struct acpi_buffer ain; + union acpi_object *obj; + acpi_status status; + int ret; + + if (wblock->gblock.flags & ACPI_WMI_STRING) { + ret =3D wmi_marshal_string(in, &ain); + if (ret < 0) + return ret; + } else { + if (in->length > U32_MAX) + return -E2BIG; + + ain.length =3D in->length; + ain.pointer =3D in->data; + } + + if (out) + status =3D wmidev_evaluate_method(wdev, instance, method_id, &ain, &aout= ); + else + status =3D wmidev_evaluate_method(wdev, instance, method_id, &ain, NULL); + + if (wblock->gblock.flags & ACPI_WMI_STRING) + kfree(ain.pointer); + + if (ACPI_FAILURE(status)) + return -EIO; + + if (!out) + return 0; + + obj =3D aout.pointer; + if (!obj) { + out->length =3D 0; + out->data =3D ZERO_SIZE_PTR; + + return 0; + } + + ret =3D wmi_unmarshal_acpi_object(obj, out); + kfree(obj); + + return ret; +} +EXPORT_SYMBOL_GPL(wmidev_invoke_method); + static acpi_status __query_block(struct wmi_block *wblock, u8 instance, struct acpi_buffer *out) { @@ -432,7 +499,7 @@ acpi_status wmi_query_block(const char *guid_string, u8= instance, EXPORT_SYMBOL_GPL(wmi_query_block); =20 /** - * wmidev_block_query - Return contents of a WMI block + * wmidev_block_query - Return contents of a WMI block (deprectated) * @wdev: A wmi bus device from a driver * @instance: Instance index * @@ -452,6 +519,33 @@ union acpi_object *wmidev_block_query(struct wmi_devic= e *wdev, u8 instance) } EXPORT_SYMBOL_GPL(wmidev_block_query); =20 +/** + * wmidev_query_block - Return contents of a WMI data block + * @wdev: A wmi bus device from a driver + * @instance: Instance index + * @out: WMI buffer to fill + * + * Query a WMI data block, the caller must free the resulting data inside = @out. + * Said data is guaranteed to be aligned on a 8-byte boundary. + * + * Return: 0 on success or a negative error code on failure. + */ +int wmidev_query_block(struct wmi_device *wdev, u8 instance, struct wmi_bu= ffer *out) +{ + union acpi_object *obj; + int ret; + + obj =3D wmidev_block_query(wdev, instance); + if (!obj) + return -EIO; + + ret =3D wmi_unmarshal_acpi_object(obj, out); + kfree(obj); + + return ret; +} +EXPORT_SYMBOL_GPL(wmidev_query_block); + /** * wmi_set_block - Write to a WMI block (deprecated) * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f= 2f49ba @@ -486,7 +580,7 @@ acpi_status wmi_set_block(const char *guid_string, u8 i= nstance, const struct acp EXPORT_SYMBOL_GPL(wmi_set_block); =20 /** - * wmidev_block_set - Write to a WMI block + * wmidev_block_set - Write to a WMI block (deprecated) * @wdev: A wmi bus device from a driver * @instance: Instance index * @in: Buffer containing new values for the data block @@ -535,6 +629,46 @@ acpi_status wmidev_block_set(struct wmi_device *wdev, = u8 instance, const struct } EXPORT_SYMBOL_GPL(wmidev_block_set); =20 +/** + * wmidev_set_block - Write to a WMI data block + * @wdev: A wmi bus device from a driver + * @instance: Instance index + * @in: WMI buffer containing new values for the data block + * + * Write the content of @in into a WMI data block. + * + * Return: 0 on success or negative error code on failure. + */ +int wmidev_set_block(struct wmi_device *wdev, u8 instance, const struct wm= i_buffer *in) +{ + struct wmi_block *wblock =3D container_of(wdev, struct wmi_block, dev); + struct acpi_buffer buffer; + acpi_status status; + int ret; + + if (wblock->gblock.flags & ACPI_WMI_STRING) { + ret =3D wmi_marshal_string(in, &buffer); + if (ret < 0) + return ret; + } else { + if (in->length > U32_MAX) + return -E2BIG; + + buffer.length =3D in->length; + buffer.pointer =3D in->data; + } + + status =3D wmidev_block_set(wdev, instance, &buffer); + if (wblock->gblock.flags & ACPI_WMI_STRING) + kfree(buffer.pointer); + + if (ACPI_FAILURE(status)) + return -EIO; + + return 0; +} +EXPORT_SYMBOL_GPL(wmidev_set_block); + /** * wmi_install_notify_handler - Register handler for WMI events (deprecate= d) * @guid: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba @@ -862,7 +996,7 @@ static int wmi_dev_probe(struct device *dev) return -ENODEV; } =20 - if (wdriver->notify) { + if (wdriver->notify || wdriver->notify_new) { if (test_bit(WMI_NO_EVENT_DATA, &wblock->flags) && !wdriver->no_notify_d= ata) return -ENODEV; } @@ -1221,6 +1355,8 @@ static int wmi_get_notify_data(struct wmi_block *wblo= ck, union acpi_object **obj static void wmi_notify_driver(struct wmi_block *wblock, union acpi_object = *obj) { struct wmi_driver *driver =3D to_wmi_driver(wblock->dev.dev.driver); + struct wmi_buffer buffer; + int ret; =20 if (!obj && !driver->no_notify_data) { dev_warn(&wblock->dev.dev, "Event contains no event data\n"); @@ -1229,6 +1365,22 @@ static void wmi_notify_driver(struct wmi_block *wblo= ck, union acpi_object *obj) =20 if (driver->notify) driver->notify(&wblock->dev, obj); + + if (driver->notify_new) { + if (!obj) { + driver->notify_new(&wblock->dev, NULL); + return; + } + + ret =3D wmi_unmarshal_acpi_object(obj, &buffer); + if (ret < 0) { + dev_warn(&wblock->dev.dev, "Failed to unmarshal event data: %d\n", ret); + return; + } + + driver->notify_new(&wblock->dev, &buffer); + kfree(buffer.data); + } } =20 static int wmi_notify_device(struct device *dev, void *data) diff --git a/drivers/platform/wmi/internal.h b/drivers/platform/wmi/interna= l.h new file mode 100644 index 000000000000..9a39ffa31ad1 --- /dev/null +++ b/drivers/platform/wmi/internal.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Internal interfaces used by the WMI core. + * + * Copyright (C) 2025 Armin Wolf + */ + +#ifndef _WMI_INTERNAL_H_ +#define _WMI_INTERNAL_H_ + +union acpi_object; +struct wmi_buffer; + +int wmi_unmarshal_acpi_object(const union acpi_object *obj, struct wmi_buf= fer *buffer); +int wmi_marshal_string(const struct wmi_buffer *buffer, struct acpi_buffer= *out); + +#endif /* _WMI_INTERNAL_H_ */ diff --git a/drivers/platform/wmi/marshalling.c b/drivers/platform/wmi/mars= halling.c new file mode 100644 index 000000000000..63a92c4ebab5 --- /dev/null +++ b/drivers/platform/wmi/marshalling.c @@ -0,0 +1,247 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * ACPI-WMI buffer marshalling. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "internal.h" + +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) +{ + size_t length, alloc_length; + u8 *data; + int ret; + + ret =3D wmi_obj_get_buffer_length(obj, &length); + if (ret < 0) + return ret; + + if (ARCH_KMALLOC_MINALIGN < 8) { + /* + * kmalloc() guarantees that the alignment of the resulting memory alloc= ation is at + * least the largest power-of-two divisor of the allocation size. The WM= I buffer + * data needs to be aligned on a 8 byte boundary to properly support 64-= bit WMI + * integers, so we have to round the allocation size to the next multipl= e of 8. + */ + alloc_length =3D round_up(length, 8); + } else { + alloc_length =3D length; + } + + data =3D kzalloc(alloc_length, GFP_KERNEL); + if (!data) + return -ENOMEM; + + ret =3D wmi_obj_transform(obj, data); + if (ret < 0) { + kfree(data); + return ret; + } + + buffer->length =3D length; + buffer->data =3D data; + + return 0; +} +EXPORT_SYMBOL_IF_KUNIT(wmi_unmarshal_acpi_object); + +int wmi_marshal_string(const struct wmi_buffer *buffer, struct acpi_buffer= *out) +{ + const struct wmi_string *string; + u16 length, value; + size_t chars; + char *str; + + if (buffer->length < sizeof(*string)) + return -ENODATA; + + string =3D buffer->data; + length =3D get_unaligned_le16(&string->length); + if (buffer->length < sizeof(*string) + length) + return -ENODATA; + + /* Each character needs to be 16 bits long */ + if (length % 2) + return -EINVAL; + + chars =3D length / 2; + str =3D kmalloc(chars + 1, GFP_KERNEL); + if (!str) + return -ENOMEM; + + for (int i =3D 0; i < chars; i++) { + value =3D get_unaligned_le16(&string->chars[i]); + + /* ACPI only accepts ASCII strings */ + if (value > 0x7F) { + kfree(str); + return -EINVAL; + } + + str[i] =3D value & 0xFF; + + /* + * ACPI strings should only contain a single nul character at the end. + * Because of this we must not copy any padding from the WMI string. + */ + if (!value) { + /* ACPICA wants the length of the string without the nul character */ + out->length =3D i; + out->pointer =3D str; + return 0; + } + } + + str[chars] =3D '\0'; + + out->length =3D chars; + out->pointer =3D str; + + return 0; +} +EXPORT_SYMBOL_IF_KUNIT(wmi_marshal_string); diff --git a/include/linux/wmi.h b/include/linux/wmi.h index 665ea7dc8a92..81f24d238a2c 100644 --- a/include/linux/wmi.h +++ b/include/linux/wmi.h @@ -8,9 +8,11 @@ #ifndef _LINUX_WMI_H #define _LINUX_WMI_H =20 +#include #include #include #include +#include =20 /** * struct wmi_device - WMI device structure @@ -36,6 +38,37 @@ struct wmi_device { */ #define to_wmi_device(device) container_of_const(device, struct wmi_device= , dev) =20 +/** + * struct wmi_buffer - WMI data buffer + * @length: Buffer length in bytes + * @data: Pointer to the buffer content + * + * This structure is used to exchange data with the WMI driver core. + */ +struct wmi_buffer { + size_t length; + void *data; +}; + +/** + * struct wmi_string - WMI string representation + * @length: Size of @chars in bytes + * @chars: UTF16-LE characters with optional nul termination and padding + * + * This structure is used when exchanging string data over the WMI interfa= ce. + */ +struct wmi_string { + __le16 length; + __le16 chars[]; +} __packed; + +int wmidev_invoke_method(struct wmi_device *wdev, u8 instance, u32 method_= id, + const struct wmi_buffer *in, struct wmi_buffer *out); + +int wmidev_query_block(struct wmi_device *wdev, u8 instance, struct wmi_bu= ffer *out); + +int wmidev_set_block(struct wmi_device *wdev, u8 instance, const struct wm= i_buffer *in); + acpi_status wmidev_evaluate_method(struct wmi_device *wdev, u8 instance, u= 32 method_id, const struct acpi_buffer *in, struct acpi_buffer *out); =20 @@ -54,9 +87,11 @@ u8 wmidev_instance_count(struct wmi_device *wdev); * @probe: Callback for device binding * @remove: Callback for device unbinding * @shutdown: Callback for device shutdown - * @notify: Callback for receiving WMI events + * @notify: Callback for receiving WMI events (deprecated) + * @notify_new: Callback for receiving WMI events * - * This represents WMI drivers which handle WMI devices. + * This represents WMI drivers which handle WMI devices. The data inside t= he buffer + * passed to the @notify_new callback is guaranteed to be aligned on a 8-b= yte boundary. */ struct wmi_driver { struct device_driver driver; @@ -68,6 +103,7 @@ struct wmi_driver { void (*remove)(struct wmi_device *wdev); void (*shutdown)(struct wmi_device *wdev); void (*notify)(struct wmi_device *device, union acpi_object *data); + void (*notify_new)(struct wmi_device *device, const struct wmi_buffer *da= ta); }; =20 /** --=20 2.39.5 From nobody Sun Feb 8 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B5C972EFD8C; Fri, 16 Jan 2026 20:41:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596108; cv=none; b=g8S9IJJDZWHOw7f7wPNQmcAWhw2DNSBDm5lIB/oqecC2fRTZGI6wDxA9+UVwg6+UPpaEljAvNTyBvIoo9L8XFo7cKLe8qxkI50M94g0fL78roCLJmcCmBS7APlhDgF9CATAtEjE7fbBr0jm/xmN95rjn/nIv3o60rNiw14zOUvE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596108; c=relaxed/simple; bh=rWFjzn6ChiNUZ+H6bv/SNmNEoNsBlOwztJtvRjqImhU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=HA4LqtV0hf6RFdCfTDA6YnqgCTr8Sln4B4LB4+XsMSDCGW0mFo4qRow8bKN0MuQ5PbxEUeFVrlKnBkxgVHT2Gu1zsS+Wp4zCdMpijgg7iffl4g8o72hjT7Ku0h1jXtOEk0apX1M+RKBWxdz0sTY2cZOkNAD//P/8QOJIQkZ0gqo= 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=dnkgBriG; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="dnkgBriG" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596095; x=1769200895; i=w_armin@gmx.de; bh=2sCOQ2tqK7flcAoAeZW1LxP5AlXh8g4weJFvuNUa5QI=; 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=dnkgBriGSkfstjOWv74QU6Zb8ABMqnQLfIpcdcRTNr4Bdz69zkmlgvzrX8NEOaLu a94MayAyhaN3Z9zURDmcCP2PPrMqehX17SBkO5HvgF7SQuPU525Bk2XwZtbxXoAPN 7zqah7Tasiu2gzV3I9ordeur6SlySbVb7H55MjFPvPAODPFBjngyuutt4rNYp2O87 tHGKPSEApiMMm2sdB1HxOloDF9YetubsbPMhcosq3FFkfqiC5xkycG6l8BPea+bIg 1b5x9aLK/gs6p2J7N99J4Wetjj+B587hLxDiKbf8E9+y0TtHYbQXlzZmBNW38gqV1 UmG2U2KkNhL0/p+LjQ== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1N0G1d-1w3ci13Fe3-00uFQg; Fri, 16 Jan 2026 21:41:35 +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 v4 2/9] platform/wmi: Add kunit test for the marshalling code Date: Fri, 16 Jan 2026 21:41:09 +0100 Message-Id: <20260116204116.4030-3-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:0VS5ftU/baipwonB+L57ri82pYLoBcOs+sJyUUrAxnVnjHaJHp0 PEKKPN1slRuKj/zj/gVtTSi0AY7gAdR27oLF5JoLxcnL9TKSpn7kdvrF02WnyYhkjM+Ht8d XvSAOFUHqnOP9+Fbpy72/skgpxS2EQmr/E5iiutw9zvzFg9EhUvx5V8V+FdqgM44By4QJh+ cZmgQg8DHXpSzsN9MtCOQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:JnaRMgkeqr8=;VIPk4cqijxIogf4K8Um4UuVqC8X 6HhsDykipZ/vd6y7UoD2jwfyoyNcxfPGboX/2CMGWdx8MRYVr5Je0K2qfRpJFpjdRjoWPzRZ2 pclbQqaXXe2gGLSTgu7jLaIPXeNI/Xt67h68SSvBcC4/cgM0Rz7yX3/csvc3LpYAuA8sCv9Dq N7x/gNTf2UjAQfkWLMx3UXFpZB6XviTAHC9uu1lulaDl4trcLDSV8XFdmuD6Wrl4dgaZQSmlr 1MrsTnrRKIce8EFDQsfvqLvA32BssBeI3hZLO4z0/p3jQ7cfjMC/Z7JQpV1iCIOFjSPWZoqbl 0bj/65hI4dU2SLq4XTYt7RF5HnUAn8EziTVfvy9PDlRm9geodTKabR/KVNQNwVsrM9gdgZLxR MO4CO4VdkT+eCCspPeRSku1Q6WpJWlJN+/VZy6mF2gVsVCQZdCVj16Thd3osP2jnTvsebkVvx 6bP/4tIq1dNUZ7F4uL8Zav3MBB1Hy5CnRgCmkqbsggiYPAj+iujGWKeruQ3zuojbl6TYS+LIc sULS6Z4TTaJW9Du+2WqnybH7A05zvqhWX2qrkzmnR1bDLuQKPDoKNryxXQosBRW+N+QMOOKOW rfR2W6uoe4bBVOWBvLj2Ws4uoNnFbQ6MeV0X17v4R4AKedCYpm40VrpVPAAu2ZI8UXigVugY8 EVqA4Hc6EOSer2J7w0WORH8HRToy/5oHPpFyH/AoCD2LI7v63kHsvxXYpzBP63b5HLxdqA3Vz MOLDXuzdRViBkGS+uH8QDUVOBYTJ+1fkeF6nZ4MidCUzEJs8XnMLZgzC9c6yJxRuZGsCbT5tc dHuxSqGsnuf6HkDu9TDhLEZkBQef+Vs3HPDFube9J2NS8THvquID1quJC5QqcUZufUgxJgayq N3+b582qSFT3H8pxwmwafjrKkVP/vsQzGjZmqwxqjf21V/ULnfB24QlSLwOF8+sVr6s+CkIMb JS5C6LRsdi+xwVT5OYjJkstGN2susZ2p45ZrWWQ/7XbTRM26okeFv2zL9EHb5fr2OuaUBRY43 ZH7KTjy2Jak+DpLfRuQ5StLob32ExF4xmCpPuBgvIHbSXxRP+DN40I1PEY5wh3FMR7WY5KRjs 8PsGzL0wfeDMojGcFLgxB9wv2WoFFLgh1Th/b8NHE8vszAVH/GEGkBPaCOYNNG7n/8yYHTbc0 plbi0ZdN0k34hm5uszh9PyaM4Hkk7j48ZbzIydwb6NYx9JdmhzOjTOK3fiIXoU+BJazelC5SB RftXqVG+73yrMVKfNR5vCFWVzAwUb+pQ6hq54ROBTon8eEGhoV1S4DdCz4lakpk0KqkFLItSN eHKIXU0v3rcMKRPYaqz0c/TSwNsg4lhS2gODLO6HHPvsMgIVeKIhxosDpgo9PfqAAb6r/uR13 upxayMZpi8RcnRPQPi0R2BS4ea7yR07HVI9RUadmjzPTgxl7CKcbvCzlCY63L4YKWPfMeiTXg 3NTgNQvG/jEE8J+Y+Bq4lKY9QR1KBgCHUFsuLj8O1fswvGyGG+DfINzWE/35XR3XV4f0dPaly kBBuNIQrDAu6ls+pL3Nxk2BqaxmsPYjfSIozJ6qv3ZVD1YOd9zVAwk3oXPlHmO09jk2QAtpk3 DP9GFqi46o9lO2iQcDD30+Mxp7Fnfra16ho3DDh3FlTnSlMESBvXWBuO/0IjMOCNMgTxm1Ddp QiYPllD/74doR+gqjQk7WiXmkn3CCrXR8iavPxjhVICjwtI6nMhEevvcGeCkbfuUi9lHvi9zc EXNv41hwO3GcPKjkoBXR614yonHrfr1AzP/10+ArI0q3Gu4blARm5EVcoE6oewrDmUEqxfvvh dyID8Gl9St9NlgDtCYWG66VJk3DJpMfdQf2sbPKZ+rahud2Gfrs+bDmHFX92IB5C7WRSKarOK YmAzOX8gOiybMLQZCnHYainTDBnUjZHxMwtZz5D2aGfMBtoV+Ck+OxD8R4L9eMVA9wIrzuy36 3YXCFhUMDs8HiW6xz/j8voA20Xcwj+DaI50UGriV9KSRL9WwnXZJT6UlXa3QS7J8dK0PLePBZ J9L6zUKHR4VpaeUuajCBhzSWWfevnvS1YWcr/kkH9nVSiLli6mT55t3ks83aWrbqy9rU10qgY arS6fPgnVyTPkEf3xmcGhyZKEKY74Yk79CvuVuGXUkc0NNx4Be9nDOeU3Y4ZbyyQ9wnF3RCH6 LlxcLuJpFZ7DvOpP37HEZgXhGgvcAphYUCO4e4P/sS+ru8zj7eJ14EHab20PGLhO60xtDx5YT LoKGCsrJdDrVc4ZUFWxYQwcweZJLMPfIOOSLmdTHcbFjTEwqS2yToYNTN2m2sF8dktiC16yf5 /FuqPsi5BzRXReKg9mpDNuVf00Y47TSNGjnq8cMZk5sVFRgRyNkWMeIKZMdDykSi1FEFlQFEb loqMhXnOc9yFv5cwzLh/cphc6MJUHf+ttBXeTGHRgTGKfhEsOxqcdv1V9XC8GdWV9ZSqAqqW/ m5CzuxmpaqvtYUhTiWcPHA5KcKu2RE4VP/nTrZGX4YBbuJjaBTgkdhml/rCSW1jiabocFte86 KzLAYX1JknHUE38BSRENzPYBOBVKE4LVRjYvMU7CqQArlvYyUHtJfFFr6+vyfkppJsuJ65qMv 7SM6a0OlZj4JZ8F/cdSdjQTlB9oOqPpuaViUBzCBdLX5jMZ0/KccWQpaxwV7zZDyCUy7JPb8c x4zvzyu53+DmChuc1PkYkx0qZC9jgP7e2EZvZLDief96MA3241AChky75VLbQ4hrMtq2lkvaw iJoW7rj0yDMTf5eUJUUTlzHn40rteiUCzHk0g+jqNTIzsXNzBMrPO3mNt3LNbDYmBAE5bGK2I Otue46wGNTd5H5WJ2iApmScPfDDjuEqC6ZN1JQB1dNVcLGuXsFKhutQpXbYML/JaSyLtfO1jD 2qxu1RnHLA+wdv1qs5KeP4OaKm3ZNSgpXiJxYD58t+npS8yQC5Vg9Gzwc2xprgZ0Bma9QLPOl c+oLO7edtGHzHAmRIU5X/UNDsTcD5HZGq7auxpuOVWenapHdrP/u77wtyLlEDW3Mk62x05E1R kpZmw90e1p8S161jYx8elVrchmqyTCOc4ZaJRNMNseOIQ6DJPSXL/pFy4pM8aXaQZVY4y2e8J Ay+g2dtWi8TA3sDgMaKfbSv5BfkFKQWgPg09/4eNqH241Gsuyhmo3jC5GCrxA08gLn8anGJR/ 9vGUqCXUp/fK8tahCP5Fk4HzSzpkHnUsi1sy34G23mUP2dZZ7tCVQrQf1OMi8jL1BN9wI0FdF cFfjCw6tCTGXKszgP1ba5b6ZbOJ0/fVLD7ILD1dUNyi5xjkS45fy+IiCuTferajmqnLDcXCog 4nryNJx3AY7OWNpYBG+4JYnjUbLpyuCpBoyXRD4edK+Qz5sr9DfY555Au+V8Y8uKdPIOgdriB X67PuGRQVpcFbiilhOl6i6v0cE6gKQ44saPgoKoIOPWsP9ZMAvW/JZ62B7HDCfIYJxk8f76dt cbLGo4CfFA2ACIq4dS7q06+oTfu/HjPHFXIlnyp2rFLlp6Yd9cfJ1HnrKjNzkoM+DhF4UmTnE scTZDAoHtJQqt8inI9bfn5MI+vQz+DA7ELK/aqZj0nad3FvW3641erSTQVN2VcX/aBkb8BFeq O4qSIC172dnmd9hJwE02cDg6f5iG9SWTTlyZ+ONpTJNuAnlYu9+MHkAJnqf3wAKoX8aD+aX54 G5eHvu3M6RuGx8U7BoS2INXvEHAk1cFv9GxdQqG8PFGOPUrqVSOrGIHr9JEFW6ueKVCQ+Rm5H Q4YsLUqVGHDm4EmS7GouLy+UbkR8NmS0812vui1NGabzggi5GfHlkPqvujfAqTE/2MKOh1Lof BenF7fa/cU6Igkg2kYDbUoLbkzXdYNr8cujd11+qVuf/RHvrvku9BdfS6QveUpdh/YxEbvDx1 c81TEMs0hcD4o2Buja/5S3itwO8CAmSAM9oqbaTwnQ4xWoO5g2gIPp7yK6eMccz2X1vs6Vo1d YvCMBt3Se6JeMOnbZ0avxOVIfiidGt0/xx7iQhOliAmq5psPk95oC9haYslMhoAj2m/obGw9a s7XyOkdmODP9cT7yEyWjd07moS780GUlpL28FkaxGglBlp2F+lRMqyLjbaNf3EvbQ0p50T3in qDOlMvk7dOsPf1ClceUPes8BlDMMnFk1gUDoLpSPMeEoCz8Duqi4rYGwHZyDN0yvMkZR5IFEw 9l7q2Uk5JMUYUks+Jh6AZLJbzrQUCHDiPTdSLgGafOYEdqoUfaCGISGclwXCc/AGcKGZHgZRa l1XxRF7SfINgJ/dfUQIDDREjddzrErYfe8P8SY2/nhKCxNHHhDb/rTH8GAwuup2WFwqGF/a5d +FRyTlie1NDWds3WBPCa1PT8WKUSV0fRnd8odFfwTv8EKhb20YJ5suQkB1AlPlCtU+9Zv8vnf bpowC20prUpaBrJJELLliII+cmR8uz3nfuRi3WGjq8jYQ29d9x4YAYy00ihwba6Oof3aLt9K+ VIzgDz0NautJi5VEZxXi19Fo4NqeHGktwEfFLnMuMCzUCzvEOPTOZj51eGVt/qqpXJKUt4ijV e2R/xrdkzgkAdw+HRGDSZKyOew5XIMY/NXWlSFsejroTssktU2JPqE0UtENEKKp8G7dfQVW+Z 4l4td49dVDFyMc3fGl+TV86qaR4wqbVKcWHkblIjE+U76iBkNu8YjQGSI1apaTQyyLyrbXmQ5 pmHwNIUcXwQ+r36WO/aKhPA0U1DDi3E3LHVTlqynFkQ7Boy9SzyQCIMwBt5fAJAqIBUyqtEbz aDjQMKSwOV8P9ARtgR5g6DgUfbT7eq+74fKiDOnA0EdnaOhhscAQoJA47k/VJ55gwKbjCXySE ffihrgMTrwV63cdqSk6A+6la4cLRrGuIDz09VT0eTbAUXmlLfCpbYQcnAPJvwdKN27jE/yaB0 cTvqE8hXpAsHj4s3W4QynS5uvF1KZJqZogfgLgA24DWq6dy2Q1igMUQW8RHhYpjT/WkNHH5dv t8I7SP5l+++RwNNKLhzVILuhiCISfRLnMyJRw3nZBqTdAG71nW8hw0zaYyDZ/E3z8aAQvxWEe R/2eqjt5ffAJ1/MY0OvCErG9jzESUSQbmBBzz7GZPiK3s1kf0nXg9MC6qh7G9TMxaM8jxHkQJ 6t3vMTpoFBvVjjkwMo/gk97ug/i/6uLeaSOJT18oKzi+4YQKhUh0z+7iHVQtJhc5p4lTN9mf3 KZwotPWjTmIIF9K5ZoOJWFjF7U4IqP8JS3RUDLyGU5dLew3+fY/bK4NDdXQPA+ta3yoCGgLON 7Q7NfRJ13UkmW1/orZLw 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 | 452 ++++++++++++++++++ 5 files changed, 481 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..0c7cd8774aa3 --- /dev/null +++ b/drivers/platform/wmi/tests/marshalling_kunit.c @@ -0,0 +1,452 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * KUnit test for the ACPI-WMI marshalling code. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#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_TRUE(test, IS_ALIGNED((uintptr_t)result.data, 8)); + 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 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A6B5D2F0C49; Fri, 16 Jan 2026 20:41:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596108; cv=none; b=txUt0SwF0byTStjsCJeENqjmnMjMifuYAspojGvqMMbYNGxUN1Yi+pMBi6cLdkZIdzE+rTt2jJZfPear1i7ZLBkT+iTWP1mMdm8OD18KDY26fnFkIuIOWHd0h/8jgNQLkGlYsrYfhopbN6V4AGdTQwStJWlntJNScRmdB4bmFTM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596108; c=relaxed/simple; bh=E0+UClZTKNFD+rOEMwUWuL+siCBjTPa2M63+5AWwdmU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Dvpm1WZVd/cqy4Wy8sNUVPuJuK/PQztTLDv6wFZXpfJnctoEN80xcWYSZ6u2QRkBjSbNmGNWb26opxVh2RCtmPz9drylq2y7Z4qrqLjuc2QTyyUTecamkNY1n51qZXR8gW575zf1WvbFW2dn7yut8ECB7RPfee7lTNop0UTlITE= 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=QyFMTYqg; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="QyFMTYqg" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596097; x=1769200897; i=w_armin@gmx.de; bh=nCru25MMcaxm5j3/lo9WJAhRUlsBhv2miRhQx5ANaFE=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=QyFMTYqge/Z07YztXVlCf2ePQjxFqKq3wTrgf8EH1whpKsjdeJrUxgmB5b0uXw1I a3oIxfU8y+CsZRtkEZuN+IW0LwMBZnL18/szRTsiYnA/Jg+ofme0njRXTDgSuZrSa l/WplsViqAkkeIzoO/LSt8PrQ8506URxKYysIRaU6ZPG0+Oll/l+wN6HJ9YxE6Q93 HTOxrOM6RcfC0E5Dg8hvxopZ3QjEduW2WxowOi7Mt9w6UJUSWsbs0BoTHj7/+ZpyI MZChbTk8vR1UeyDLYMG78a54XFxsBG3YWLk9dr/+ROcQJMvVozmNqgDXfgRFm6npL p8oGNCNxN15fPsOo7w== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1Mof9P-1w9ZlJ3sfB-00ineU; Fri, 16 Jan 2026 21:41:37 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v4 3/9] platform/wmi: Add helper functions for WMI string conversions Date: Fri, 16 Jan 2026 21:41:10 +0100 Message-Id: <20260116204116.4030-4-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:VQ198Jnj3FKgd1JkX9wF+DErYtI2KX9LeAiHXXWoQPaXnMJVw6q Rk0wDAw+OGPMdugCw61/rhRk65HSvfGwJIYha8Q4iJxovY637VYeYf+yQFAqHEGTLe6yYLe /gBFoeWTQPQlAzLLXpIqHbGcG716hB0G6eQtIsl/ZYbUbtYP6gzS6wP+9DaTgRzm5RG3J+0 fLNtzW8Z+e5lfIlvkKrrQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:hjV09Xlug9E=;DMdfLvY+KlSJWTZNjcUwUxZYsnn j/KcTVXSS1zZy5CCHJtfuCCQkFW768Uz7gqGcX8I69Y/ALkNdNqFfCVhWiWfM7lbD/ItLx2OH iFVQQ+YkmNAiVuQ1es9mLBSFoYZl192XedQhWR/2JnpMvUpehsnDkLq0meWw3vX+kDYkF8fBr X70HXiAxRoa98S4Vlx7D3siwEpZlETTKP3lCj9I0pDX17SXQp1JrZZOmCp7JNAA9d0UJX8Ofa H9B04fGJxVkw2n9gKI8D2Z8c44Rxu8+e4OBc/hd+JbIczJOTE7ZQqklqt6e1l5PTo6ZFVePD/ Z5oDdWKzON1dmVFl/lSPiyv5zUWBrba/uYcgj7p5TRyxv4SDRYsin2K+RpPGTqeICE5CqEU1/ DtKTYf2cExanuuTjILzWL8eR8QuJV8DqRRizB6lsjyOyFCzdayw0ncSaZzVDMfr0al2eC+VDx 69bgSbj0HLAd+687aBU3+gpsKl6731NtTK56Pn0ePgaM2KYXnDDQO1nV1ixqnYph5DlrY16jS CbXrUy4RieM7vKslqg4VOEegtJ97imq0TLlitpkRVkPpLXpyzuq3LNvZE8TZg76/dW10C3fve EkUJQcEL8yuleL9AFefESxmFHIObLYnc7Wo6+1RrRTOE6cye8wpsObrem3u/5bzFAhUyYrDpY phr4b/3LtGlHvJwANmFKt10kjeY6w4pPzc5DmQUd41A4y6IC74EaI3j5qJnBsZZFGkY2IIDF/ MQui+WN7FOyJTQqZzAAg3O4IhicH/HVB6QJpYcR+Mgb4TgQdBnJdz5pA7paPKhbX89hIrokcJ c5o5MHuKIJDYhIGl6KwD7T5NzQBnEeN5jnnp6xRgOdHEzPE2AvqjY34OISkllsI9u3QRs+cCN spI6u/CqS9mETaJkGtkCgXGCiFLmChR9IiEpXm+wYji76vedPf6HhiGYBsb68YhzQdFWkHP3p Ce3UWBGEW8RnjH9d8ZtAeW+kgu1Ocqr22CAn2TEyQIhwVh9A7HgzTJsJfqrsjzl5KJvC/KEVX Nwe9cZn4wacFtqNWck3Cyb/Ll7J30GWZQTo9IRdhzPfMxeLw42PsIxY6JMD5AMS83AanjLaz5 0/fijj9LTUbQymgDaO4p9YE/OrUa/CHFYO9d6kZgAYGsolreN7lAiKwkXZQP11X05Oea0xOMa ++F68OyivYbGEjyKHG4jllWnUr8uNvtcy55sIe8boXrobCuVsw7X1RquRzY4mzMUBdjcb+V3j D3M8a2O0IiKUiIlUK31x5+Veqxn5iFgRVrgdfXwzM7tei6qsi9Ez6Hm1/iT9Rglx6l8f9PP8Z RAhc7Cf65UeeuTYX8LnRbR2YT3XrwMzlqmAH0ZgolOPTa2xjpGx+2fYs1Q57grDIXVWva5kDD 1A2+2b+r/pQOIN/OQbX4KIuFoTPYaSct4RhzCQsy04y0V8dKzNEDMvOaUVV7SNpvfo0tViLta K7ngGQ7R1rPC7dvsAdBj5WvFhAudD9JAg2zB3gIGdg8TH0jXQrWKd8rQhyriHP8uY9s3CUDhf iqzTERoS0LUvTU+mxmZkHmHpmCCcwx6qzlgVMPBXRVsjP51twG6CpZwv2AJcabUB3RnyTic81 mlnC291YNdB6hD3LmEVtb4VumTanLQrzkbeICigOKt8wK9OEvGg0dpWSlHjXYSyyDFU2gAKWI wxfL+9aVJSaXr2QP1h1TKoMhEoOhToHb3QohNk1FVZvXoPnQkuO+vJX/1ec9fmyRmNdM6AZ+z lmG8hrD2jDj+dqxqBUUrWG624kgD9PKlO59T73ausd6TBdw+EmdD0cLKiR4eASdkva1VGoyWS FB0X8apBrvEFsZpHB04fwDr1Ysm7Bmd+hCkQrWK1YqXzpuUxRsf0rKVhU8+AiG3STr4grfjjf wRNswrPJVKbP9sd4Qqa1DtyaTzjNlwTEhdrhS7EVLZHLpSeMAd5xMgokY6iDxOY7VYmn5YyEa SY/W4WM8nYSZGNhWGJKFUEmQttVlls5yJ9KA1rGwO1Ami8mE9W1BCeKqkwnLtUMGRB/wVrWlK j3c6tNc09JvukzOle4Sv2Wvoazd7pSz6E/TkHBL2Iyx1R5qSjtsTG0CHebmsyR+HovN83R26j 4dmgYQ2SMLmhBSkG1Ck2tCbHGtBTWvyWPSkgWm1vt470Y5q7PpzHArcgsZmUs+4hMU6w8HCO6 wnWvrnq1TOcBaFligkl9Mmz44tkloGrwVyw53nNiBU+LBmQ1e64TJ/vShNEvrp9bx8XSRbYOU RIVrB1BZLjx1QyJgDXd+O5FNQCtcnABNnmSPzFLHwrW6+dZaLT2uxkY925vp+vuwETXxn97t3 iYlpgscjeRz2/uHKvFShbgZi8HaCDLscsywde9KWdGRnS50OdboM+Ws8XElQmrQjid3KTRS12 /eInv4Qoj4rkixBkhoErXgBG0EJ7i1xgOmdRN5rp0e2e+o/XcU1dSQ6wpbjmQe7oT+Oni9Twv cQ9c5ePvLisAg4SVdRz7q4IGw2YpKQ4LGrWxUQOyX+fZIbX8vSKs8qpHpvj0KQvu++oQW8K0a x0CZY6UjawaQ5mEYKypQUgqIv5iRtH5FPyMblA6IGDo8geGLNHYsCfmwdUbJkflmPTYOxA37H TiOFVbaK3FQQXWSqX32Ib350epYmDZ3wV9ebUwEBmqmtd+yXj7qXY69vTnuFYqwicOX+3M9QZ d1mYyznpe8gTf4JKMVYd1AA885pW8bZdbri75GkByLVg09mY2UGc3TS6g2Iw/vCpB5rAnjzSA Ny7PtGu1EDAfYBNkhnDZ+XLTmP7O+R989sAPV/QaTP1vUUDbSRE0HfFH8Wnwu0f2z+mbpV1By yxsySWVW8QtX76PuAbmYP4u5E8olHTJRSlPn45+Kjq7bycrRac18O7kMr8XdaIU5xQ4w0EgLb 2RKJ1LsVtjtSxFkIXyab2yd7WIs8+pZVb8asJDpicgYWUiEHYvOLrvDRBQw/ANM53VSX95p3V zCtFS1cByXVLDG7Tu03YVtG/UgnxkP22+gGLh7sWQq9x17WcE0jf0H1mY8odsr6ndeKiwOXxr I4CqOMiDW3YpRrS7LVPbFVCq89PseX/PIZv+xPFPTHKTXzLOMhDYUqz6c20VrmOjPrBmWMy5T y9+dlm2ZUhqIB/BMUkr9luVj31/pRDTc6Q9kSbiJly00xKbRZxpGn5uI3amGTajaSO1kyzTfk f5pKkJD0FW8msebKmkF0aMZPqZ1L0p7Xexor1D9LIpLxfAgwagJcRY7zRhF1AAJgIJlE/dxC6 9z3SfTrq/JUggk4ZVraKhYjx5MIvINpZrx8XiaM1axN0FoFfgqKtzQAr/QqmM1SLxasV7P9vb BssiIBwpcBNBXtKR15DccYkkBwt+XO453ISD5RTcCYjVHpOApTvxczOim+20lLWsX721Vkzkg TFRfCQWaCUKl1GRY7TG81Yacw6d7SVGEjgPjO/KfsesSJ0O+oP9A1g8OGXU/ASot7wofLqXdH xhPLISXmVHvYkdTh0aLbnYE6NmWzIxILdQWn5Pke+nI07R9r/3ZcEKGh6Dz1RUzGY+4AvqfMl RzENT46aFiOtJY/Y1uVS4HPX/qykUsf22aX4Zqkpu1dPwiCw2YDCuRv+ABIwf3LeiKS8hnyEY RhF3v9ToSEIJGMc16WXu+L9/hr+mOLs/sQfnluPjH8YnNwW2u/gBxzvELnz0DQGUIyf4cQH+k mu5QJs6bj9ztLZrRVpgMs8JE0OcfnO5457xUWxzVYn1qvhr6VEflGiAsoxjUj+fJXFV9+CbVz lmryrcv7iMpKSoS8ccvyhkqej7RDletthjeevLJgNAOI7LJch8+F4+R6hRUEAvH9MoCvgNATk 8fScJZAJ3v1KMKo+8er8XwK0LApYAekjB7h2dRhzB38VStrw8wFbHxd+WJMRQIpiC7rluqUsl oyaKThKL+QSOk4+ymI8OlbZdF/d+k/+dxpQIMGPEJ3bC57CA4arDujlPMAlN7Wm/ALwQXOTDD 4c3Ymf9Hf2MJ5JVN8FK8us/9qI/JR+0jKnlvDtZIbXfGw9VyuOomAj8k9Ud8wU5oyBANdVaHr DzAy93wD3kprb87/cqyqToXFLDpeI0xHPcv7gyW1y0yOj1B0fSLGErn7iyNFT0G5N9MPRRZPn 78qK/GJ/n217jknAS6FYmCVpohHSI6qYANjOpOGr2SEMwsxzW5nhkUKB4fqBQUP+1J8kJWKQ+ F/sLAfs+RUIU8QK0PFRIWvLf5UI5IxqmHwUaLgutlZbe2J7D+K/apj5loHiWRmZYwhF/RQTD4 Eg5IkNxdIS7QA2pIzU27Ff17Ko+BbZf5nAQTp3UG4/5pU2uXE5vsgDRFBM5zaQmTjxeCk0IzP C6i9FcS0jQkDhMYnIsTacDJ7w+/DquYhii/iJF39dNRW+iufiqBva6vdOaPFeW43aeZL5pxfZ 0yxWRFTjGs9IqeRFrYO4EfNztdWN6B7rkK8I/SuDhvQaVMRT4OD+x52pD2y2Yb7VQHRKnLMFs Y45J1kRODCQ95RZ2rCdk9VttaA6xqziX9zD8oePWo+pbsOVriR04fAP38dP71JTWFIZn1Jh8H sZTaORPvW7Cx4BldsZH5D9nUUfehXF35DZ9p8DMn5Pf3Nr/oXC2FN47vbxTA9Cskd+uSxcLYX mybbhXu7fDx/ApunYUu6F9qOdYD35asNEYM/JLk/YdVuxQC2Ijky4STyVwSvsSLVOfNlXH7Hx g0Ln3WEtd4LwCk95QXNRRjKJQ8/SFGbf+ca0BR34PBTJ8WZZy9SFbYBaHZ0CiiegXN12F1jtV 7iBbrbT3yk+8oaZ/KtiW4775lIPVEEf2QKl5JfoJQek76hkMS7BotJ7sdq/sz9t8PBi9TzXIZ K5KI28z2uFdOMBVike8F5mABea3gdRVDjnmYBpdNOHNHgElZA9euO9x2NNL0eZ3R0fExCKg7O VNEYqT7qhtNterbtbj28ODAu5lbk/LoiGYL8p1dNLRzgpSMhicFZQaecFOuvUymIOtDG8Dqaa bXQcM1hzLOvs67XEPaUfy3ndR4sCCRnPA8OR5qaYCfMo+jQsghPPIdIySUX27cCynq17xZltn /WXIVUYItAs9WeJZocV14I9FF+948yQlyk21P2Ci8CjcZwJnpEYYsMascqk2CackWxN9pLDJY ziaVpF0d+/8oF6jOGgbMnalemqnVltwL6xwTva8mfZKbaZ7zZ95agfRCZcSMOKjyQcT5n4z9J JdxXS6REUxVSfhwrnGTvr7c3X6Rz8isM0ue8u75smzXjed2b6ewxuxUUAVDV3APYbJpF0GUVB eUGcKB0/Qz2qKzGIFZhb Content-Type: text/plain; charset="utf-8" WMI strings are encoded using UTF16-LE characters, forcing WMI drivers to manually convert them to/from standard UTF8 strings. Add a two helper functions for those tasks. Signed-off-by: Armin Wolf --- Documentation/driver-api/wmi.rst | 3 ++ drivers/platform/wmi/Kconfig | 1 + drivers/platform/wmi/Makefile | 2 +- drivers/platform/wmi/string.c | 92 ++++++++++++++++++++++++++++++++ include/linux/wmi.h | 5 ++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 drivers/platform/wmi/string.c diff --git a/Documentation/driver-api/wmi.rst b/Documentation/driver-api/wm= i.rst index db835b43c937..b847bcdcbb09 100644 --- a/Documentation/driver-api/wmi.rst +++ b/Documentation/driver-api/wmi.rst @@ -16,5 +16,8 @@ which will be bound to compatible WMI devices by the driv= er core. .. kernel-doc:: include/linux/wmi.h :internal: =20 +.. kernel-doc:: drivers/platform/wmi/string.c + :export: + .. kernel-doc:: drivers/platform/wmi/core.c :export: diff --git a/drivers/platform/wmi/Kconfig b/drivers/platform/wmi/Kconfig index 21fa3e440042..d62f51ff3b7f 100644 --- a/drivers/platform/wmi/Kconfig +++ b/drivers/platform/wmi/Kconfig @@ -6,6 +6,7 @@ menuconfig ACPI_WMI tristate "ACPI-WMI support" depends on ACPI && X86 + select NLS help This option enables support for the ACPI-WMI driver core. =20 diff --git a/drivers/platform/wmi/Makefile b/drivers/platform/wmi/Makefile index 93f37ce519ae..2feff94a5594 100644 --- a/drivers/platform/wmi/Makefile +++ b/drivers/platform/wmi/Makefile @@ -4,7 +4,7 @@ # ACPI WMI core # =20 -wmi-y :=3D core.o marshalling.o +wmi-y :=3D core.o marshalling.o string.o obj-$(CONFIG_ACPI_WMI) +=3D wmi.o =20 # Unit tests diff --git a/drivers/platform/wmi/string.c b/drivers/platform/wmi/string.c new file mode 100644 index 000000000000..0fc43218aa5b --- /dev/null +++ b/drivers/platform/wmi/string.c @@ -0,0 +1,92 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * WMI string utility functions. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +static_assert(sizeof(__le16) =3D=3D sizeof(wchar_t)); + +/** + * wmi_string_to_utf8s - Convert a WMI string into a UTF8 string. + * @str: WMI string representation + * @dst: Buffer to fill with UTF8 characters + * @length: Length of the destination buffer + * + * Convert as WMI string into a standard UTF8 string. The conversion will = stop + * once a NUL character is detected or when the buffer is full. Any invali= d UTF16 + * characters will be ignored. The resulting UTF8 string will always be NU= L-terminated + * when this function returns successfully. + * + * Return: Length of the resulting UTF8 string or negative errno code on f= ailure. + */ +ssize_t wmi_string_to_utf8s(const struct wmi_string *str, u8 *dst, size_t = length) +{ + /* Contains the maximum number of UTF16 code points to read */ + int inlen =3D le16_to_cpu(str->length) / 2; + int ret; + + if (length < 1) + return -EINVAL; + + /* We must leave room for the NUL character at the end of the destination= buffer */ + ret =3D utf16s_to_utf8s((__force const wchar_t *)str->chars, inlen, UTF16= _LITTLE_ENDIAN, dst, + length - 1); + if (ret < 0) + return ret; + + dst[ret] =3D '\0'; + + return ret; +} +EXPORT_SYMBOL_GPL(wmi_string_to_utf8s); + +/** + * wmi_string_from_utf8s - Convert a UTF8 string into a WMI string. + * @str: WMI string representation + * @max_chars: Maximum number of UTF16 code points to store inside the WMI= string + * @src: UTF8 string to convert + * @src_length: Length of the source string without any trailing NUL-chara= cters + * + * Convert a UTF8 string into a WMI string. The conversion will stop when = the WMI string is + * full. The resulting WMI string will always be NUL-terminated and have i= ts length field set + * to and appropriate value when this function returns successfully. + * + * Return: Number of UTF16 code points inside the WMI string or negative e= rrno code on failure. + */ +ssize_t wmi_string_from_utf8s(struct wmi_string *str, size_t max_chars, co= nst u8 *src, + size_t src_length) +{ + size_t str_length; + int ret; + + if (max_chars < 1) + return -EINVAL; + + /* We must leave room for the NUL character at the end of the WMI string = */ + ret =3D utf8s_to_utf16s(src, src_length, UTF16_LITTLE_ENDIAN, (__force wc= har_t *)str->chars, + max_chars - 1); + if (ret < 0) + return ret; + + str_length =3D (ret + 1) * sizeof(u16); + if (str_length > U16_MAX) + return -EOVERFLOW; + + str->length =3D cpu_to_le16(str_length); + str->chars[ret] =3D '\0'; + + return ret; +} +EXPORT_SYMBOL_GPL(wmi_string_from_utf8s); diff --git a/include/linux/wmi.h b/include/linux/wmi.h index 81f24d238a2c..75cb0c7cfe57 100644 --- a/include/linux/wmi.h +++ b/include/linux/wmi.h @@ -62,6 +62,11 @@ struct wmi_string { __le16 chars[]; } __packed; =20 +ssize_t wmi_string_to_utf8s(const struct wmi_string *str, u8 *dst, size_t = length); + +ssize_t wmi_string_from_utf8s(struct wmi_string *str, size_t max_chars, co= nst u8 *src, + size_t src_length); + int wmidev_invoke_method(struct wmi_device *wdev, u8 instance, u32 method_= id, const struct wmi_buffer *in, struct wmi_buffer *out); =20 --=20 2.39.5 From nobody Sun Feb 8 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2E7262FD69D; Fri, 16 Jan 2026 20:41:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596116; cv=none; b=hlXR56XkO/Z+M5AIrhfX9or8MEo8NidxSDO3rCtVZped8l6au4Q0jGq1D3Kwsn9Y5z2HReezKhgw8HT/9U6vrvmYMXeODbTVd57GE8jDXjKEdP/lgwQnhw+ZKTZEWSACTpUP/ctgllxJcx0zqr9wdZbLwJmaSbBr5JPvZntE1UQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596116; c=relaxed/simple; bh=ky6Uv9/uEc7uB1evuRXEl6vo13vIWeN02C3RIC6h4Jg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=ojuR2SV4R2bPTItDVpO+bMd+cYQ0mNSqyqmuMgrY8dGIcsifVnJ2qYulLuXC3cSZGla0KJRNbOmPXBiL0q8yxjK9EMNuRBzgVkKKzM1au1ZfpA8EutQRQC6czSnz1tzjinutFjURRS0W07VREK6C45fDCU84UeiNk1CzkSZW68w= 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=O7XxjA/G; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="O7XxjA/G" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596099; x=1769200899; i=w_armin@gmx.de; bh=NitAERjcXLJHRK6288iehSoLRg5EoInw/6zaVgJadU8=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-Id:In-Reply-To: References:MIME-Version:Content-Type:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=O7XxjA/Gr//Nn2yZz3x0AHeJAmNwhySmT5WMXzz5BF7nIihGc1NBGZ/dT8dY4Era QNXWNVpMs+VSeBS1zZ2FcpCNRgtwz9zB6hmc8D3YpJn3SR9BhE4hG4E2I1dewpguI Va/acxmXOPsFfyCNu6YsisjvIZ8jtx8fEiMG/7DZJYO6d+jJcI8f6dzS38XekJzka Teu/GHbVimSslvIwOJHQVkkByTsaY/EI/IqsXQ0moM1gaYgxNbRbo2OurBkqXHAKN W50xDD7zX8cnJOEUfuO15naRVWhY8ZSJmpQp63PrPFFGH90WzOVMOsvwk6DzvAPpt OHv2V53/U0V54JzSsA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1M9Wuk-1vmMx51BOW-004Cyl; Fri, 16 Jan 2026 21:41:39 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v4 4/9] platform/wmi: Add kunit test for the string conversion code Date: Fri, 16 Jan 2026 21:41:11 +0100 Message-Id: <20260116204116.4030-5-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:HfmAtz1JIlFISwwccmPzkh9Ef5biaNxo9mwrrvr34TE7717mkFZ ODtKyme2eyJXF7owmySchV9SkVgT9UzFp5WvIOvqK1mRNuJLCvJcTkF3Aqf7w4aye7D0iGp KBEJ1HbWDWtSmOnQkMPdZOTngQbzFTd3K2apq9DUydu98OPcR7SRTDbFicc7K1LU3qfhA6R rvLKrgtQIYEKsoZ461wvQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:/poB6mX+ROw=;qpmyJ0aa4Bz6q+dObNn5IqIWO+Y HHChdRtb+snVY21kJYCISZbmLn97y4hkc6vl5kvMqay3GIyFMTC/XF9FYRLtqaJADibBNF3Wa tgyrhjjPknJzY3OVowqgda+eqsMyVNU+vUV6IV30YCbQM+cjVsZOa0vIzv9YtLAcWlpJoHGwC eGmtWwt0bt92MTud8H6HDawacJHZLrTqwE3fKgxeI6DgydCt3AkLEyXuSOMm964giC+I3KHIR 0ohU+bwvXCxK3kq6GFirh/vNVH7T9/kNRitK2arbE9wkVyF8GsHhKChGKcuh2UxCPzaWnqOwp C67eEgFWROsCqo+Xm9jPz1FlVQDbyVVf2hZ0OUa2BnWWpEL8lmsl1DbSWo1OCgXrR1Nt46tjQ Y2ZNCLa/ECEmSX3Q62fJdOMwVHOapky1MZH3wx2BvXqga+MHAIjTcr47Us4LczCJCXOjYuyGU L2vS9HQODBSvjxbOumDrbx5BEOc3HKvN8NF98QfT8jFROuBGq7h7HiYSoEieC4gUY59jSh9+r +V+7eEiedhpBks7AdsMHGoAe2zgEjiIr6ZqR2WlWvb2fbovw5v9KGDlakX3130P+0wDvcda2s tTF62Q2yxYledFNxNv1Pd4ihohJDr49mpIfIu34z2Z11C77dSerFNhdO4VIpp2bXYXNzu0WiL bQS3Kvq0znNFhaMphERzv+7feUrqAZHHjx8rMZPq0Nnpj3NCcaQpoBSB+ArqbnQiybLNTtHJ0 rGvlLIR75xM73VRg4FArmwHBidyTLHu5XxmIW+N43+LTaMZQQTV5W3RFwC5uChen7erWWHF9J s1gBZq0iInIkxUCKH+uImwSqR2vHzJv26Nmi5PmwHXVJzu/MPQiaFgPcj8sbUPkOl7AWoJoCL /GK23J7xH2rHVX+001wfoyzWwR3M2NlzeTsa8OrT6gxsKebJsu031l3TqeQforw6iNvQMy23v hCzILK9P3Qwz6Ku7bZuEUr4DejxDsLB+p6tagDUr3NnkJqbk7G3AtlCMDsbJqyT2hlesFHeLA tkGS1Mk6o/qquQ9bqoia7u4LBvVhmIdkFUJuMxpur1lqPS3bOBiGJADAZGK7KOk08FmzcZz9T L+CECoMUtCxEvEbqKj4T+/Vg9KmfEmAv3fRpJXfH2ezzTT3E0PFAHnT07iaNS5f+Z9FkDzlD6 Q0qY/vppobIhwdyEmDJRE7FjhkLOgrfgTkQCY3nCbTcXeQZP5A6Zwnv0sBmNogDD8PuP3ZgZ3 O+sKMEk1Rv+yCtGQy+pMCaJESwnhxevJxctwk6sqypvD7e/NVQcW+CXiMx5tJXDlwoVUdEMdX sZz2DKhvz/2auUhz8ZQG+ECUONt7f3o585d44zgvQseWXAgPwtWSwaOeI7DBYCSNctHmMz6hB NnH9POZdBurI8ZiRPf7JsDalAHm8mrQFqCgi7kxSuyQ/yEEzrP/y5Bzr9n4lWaTwxs99QGhQ5 cgqcaiOp+RnPMnsR5uxvejUYoTFKdxAruJoObs/Vfx1h+cdJika8EE4mEKUvSgjqEYqtD4/N/ JBjfkohKlVXI7zQMnd9w3HE4JHFj8FtXwdlJgFrXO/GVD2bSAHANiHCTWpaLRwNj7qmZPutOC 0o6J+XXgp17snSupOW7BMOmdtI3Mkia8Pj95Vj1cC5dDCcjAwQ9MpFPyQxavg5DQSIwrH6LQa eq41fenm9De2kuGXX9d9q6dBYK/Kn/9EiK7YCI+yaqQj4SDs723vkoXNyxnyyszoBwTYx0T/e b/QSZu7fQTSp5gME8r9BQFcgXn9ptnG1v+OF/80cGr+T3z1u+hoQ+ldGWifTrrbyTbNEMay7f f3LHUC9esky1+v5CFbQ9q8baSHgkVNeIOn7yKe635NEuFy+Ag4UBMrEX7nPEd0w3JWgBzkrDS wKONeymbpkCOJF04r9aUwXPRN2Gn/XdJ3TAimss3zza6WXr30qT4Hlc81ppYmj2dDNK63wCAN 8BYNZ4EZLBPVSAbipIg5GW8cfagyOb39ZF7XoZeWAYH+SNepPvJwx7uJu4Dvg4Gd0K5ivRAKC XyNhkKaCUotqcYJj9qHkWsqWUsQREa7z91FuVJsXBVrBO1r1OaNC5DivDrLF+Sf4khEknMHgh IKdblVDDZ8HLWKFEwEp4Wm+hTN+C7dyh3Reti01hxBslGzRrlTQ5p8YMDAegw0V5jT14Ma4Pw EMlMdhOq0O3PXE5+orYKR7YIQjLFsx006Vg34cah8x/oOjmBORmb8hi1+qECbysKj3+Mzaq6r uH1d4uuyHAWlkgMqkg7VHekjM3J9DTgArfhD240TBA1ZiHQ5tGrw3rf8WmvWkTZvKUezLCVA7 ckTKJnn4wrppL2xGZg0sexZaax8qKgJgufLvmZkzrlAJU38P0J37HPIxeOXuPQUMswnC3yOUi Tf0kBdz/OqQjBfUJevwRgpVRvuI/Z8NCAFjMJDCKU02uEwQ2Iyy8zj1AoEsHp9HE+5DIogpF6 UUgaTKFLn85m9080geIDtY9/3cLrxiBtdT27wyhf/evFccuGNjqKuVvJBX8NJJaKHpxFmW2Gi IJpoU5O320oLFWW3FZbCDhg/4DjF6w4y+TWE8eZBqNZkcp+9oAx9Tkw8kyF7WtspeflkVj+Ay zrhxGJ11KzAra8mElWgRedN2nE5QeHU65PeDOl2ijrAoRG5zQlo5rcGUod/YoQnpp+nnIWdep 2QL35R5mR5/zc1jKe7rYelgaf6DxNugU6MQVbRkMEOoED4G5vuGZVPymWyLdi/UzZozCKFqma 57izV3k85VQ/hLWXuV0pp1BiiG7RFXbEEaaA0tKX8KaXY+MP+5IeaWnj+kl15PwBMsq6acGw/ +G9sB11f6FjlJGYvMyW+SG7pLrlYuWXjnhawXslt8aGtR0ln+CvOQla+rdn2y3x12zJWESyvc cOs7o9Oaa6cxWPUK4ugoRlL7pmquCXwy32XilYFRwfTOAJO05OoW3lbeRC3ETigLvoydjHyX3 bG0XhXURKTcTGVK5herVQKpUQdhnyMPFGDrJ7Nzs7e6DIvzWyD0l5Ah3nU7qz8LDBrte3uYM7 qPYtBwg0nKxihrKwsbQ7LSzQTcvU6FVGr6Va/IF0XbENfXxvDv7+d3HDcrDW3cSLbIW9px7uQ +uGwxKCdruIiUOHTuRX6J68SlghCS6YYFy15LF4BCzys+0VjkARab1+29nPDAkzQsqNrHHDsn 0y+In8iw5xxBfOWqNSnRe9EWyX7gkcfSMzVencgiGTyam4IgiBzKEvqth6BQuhDjpGFV6R636 xUHkYTOJs1/YLIas0EVR3G7hTxKLOSyKwLVSEa32J8dNGMq2pFaIgMudoVDlq75/HD4L8Tk2l Nt8mv+iTfGCcMArdF66ECtDP8pF+6eZng1zUr4iQ19St+ZKY8SXwOYkoumghfU+mnh/JPXUuJ k5UwNqwkuBJ/epj9XumW06HqOxxG8tN3/qCcBcpzfajpqeB/KttGZ4euc6H25iJw0fOiK85sC f2JZtrDzgACjh+CpgCAac6cHhLjZYyHkFlmYwh39gNWJhqgxfUuR9G8C35/VBg3r724rUku08 XbzmwFZ4eBISFYnjLdgQO1pbdp6KfGFO7jT0C8ZRWit4eiAFbe0rHMg/yfwseqIn5IUD/16Cv ZRRMhPTUp6DwzLynaiYg/7dwjObhrdXPkTDrNYmHdmTkFgHQgfTN6emY+PfPT+JYyOKhruiel UWCZNyR6spaM1KU8th9S2Hp3Eu70VHtpwTPe/j5FoVk67BLlVkJO89bJbYVF/T6Gz1s62sQac cmIsJnSND9dzFhBPdQP7+mxUd1TcoWF29+qg9cPskMN5Q59X/IOAfxUqecS3Z71FDoI+ldJZo IZKjyW3hjok+RLzVfuuteAhv/uO3JkLqCaCrLwd8/HKyLP1IivB+k9Cw8HyMY5YpGbULP12CZ J9wqJVX2pXXJUSGY/or/akLgDSrGbarclzYFGmyHIvdJpNbZKJiGEzwAemu+xoW6W8D1sa2mC qQ1z06JDUaf/QiGNCVlbLZ2ukeu8g7hgGvUy1cx2ohApEG3ayS8+hpXjF531xmx/PFaTrl5dD pPac7OKdZLLs20pcZh2bKGI/vaAQ5ByKmCLDVWV/+RzkfacNkiBGrbsmzWECbmwwitlckTkSK wvXvdoPZedcFQ/+GkP9rdTqvytSaXb1WpYjjbru/8XPXMUi5pSGm7cC4leVdn+rdaJhib9cmF C0NTEE7y14qy5fLIdH+Brjcx7Z5iqEa1sxVAXIEw8jRNVTcqHNrezKMAXtlWZJLsysEnqcbvA POxZ/LMUHTyuTq8WWv464NTuQUOQCI25nzcbNaB7nhTiAhnbGoFtghhmD3qZ5CB31NzCyrTY3 ZbK4zA3pjT2oRY4xDkpZoGA02itWtFa2h1Oka0WWyydwQYpp7EwuvrNtOgyoR6MY528BHYxz4 v8R5x44v6tGux0PLbhwjfhbLA9Gtlcs6nCpkxIqYX+pM45vRqe3+sUUHrHVonuJDsTs/dye9j qsvIgb+w2u/XpjqCtk/VtxQJF97vnoU7sItlAjQBLKG6yMg1QYop8k4DgVG8s9euKxxiwqytv 3Hq3GXtgAHa8AddF0SAgTli6HOVuIQHsVjve3KQ7UX05Oc4KR0slkWTGzaqSErNovAnYXNGAg XOnYSvGVTVvItbSUhFAhHH7TVXQSLPiDY5GmIQ2VXYuTBx0eLBeqPbRhgcQLp7J+tOz/6rARi MKjH4JjWn1Y/90AUq2/zPaMCVgycSF5nzA3+svwEO7vhNiwDno7COIoFEULunHIuxuVFrM9ZZ C/iMS+PBF17/ooCr+rq8YkcF/50QMc4xiGcVGwhSV8SVVr8Zs0w3VPkKGjrsdFpYwij3Mf9Qu 7Egl2z+jUliPJ8VG57lS/9zVJQFkhuNiZ3HClXAwuIp7okZzRW+i5P9AUvj5cMVTAYYbcNRei 3Ea40t4ApVcuCRVuiGFK4vNAqsrWHaMyH3IRxu5v6TI+FLPD3Xjr5mzac28ePrCBcFwQ/G5Ry ydTwb1TN0XEoUdEYIPW8RvtR2xE5zlPW/DEa7/oir6zea3kKDJUNeDdpcOQkqVERmXuZ1y4rz hRccrK0cyR6eGeEQv9OI8IMBFdjFqbLG/PNoP+1uwjKyTDUcmkrfVmftOLUmMFUCS/NgAsJT/ RgWfXqjNLtGAmst+YtltZNTUlWPN0BE2vAD9Y4BtbpN6vcHwNyy7DkuR9aOAsMhgC8Ixwb6wj ShTKi3yGB6s/JVRKjTEE6jF3E/UlJAmGoEWOUconSyX0N56OqdnvgaryBi2vV8/srsTQFoRg= Content-Type: text/plain; charset="utf-8" The string conversion frunctions provided by the WMI driver core have no dependencies on the remaining WMI API, making them suitable for unit tests. Implement such a unit test using kunit. Those unit tests verify that converting between WMI strings and UTF8 strings works as expected. They also verify that edge cases are handled correctly. Signed-off-by: Armin Wolf --- drivers/platform/wmi/tests/Kconfig | 11 + drivers/platform/wmi/tests/Makefile | 3 + drivers/platform/wmi/tests/string_kunit.c | 278 ++++++++++++++++++++++ 3 files changed, 292 insertions(+) create mode 100644 drivers/platform/wmi/tests/string_kunit.c diff --git a/drivers/platform/wmi/tests/Kconfig b/drivers/platform/wmi/test= s/Kconfig index efcbcb51c251..f7f0f3c540f5 100644 --- a/drivers/platform/wmi/tests/Kconfig +++ b/drivers/platform/wmi/tests/Kconfig @@ -14,3 +14,14 @@ config ACPI_WMI_MARSHALLING_KUNIT_TEST to the KUnit documentation in Documentation/dev-tools/kunit/. =20 If unsure, say N. + +config ACPI_WMI_STRING_KUNIT_TEST + tristate "KUnit Test for ACPI-WMI string conversion" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + help + This builds unit tests for the ACPI-WMI string conversion code. + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. diff --git a/drivers/platform/wmi/tests/Makefile b/drivers/platform/wmi/tes= ts/Makefile index 252c3125353a..62c438e26259 100644 --- a/drivers/platform/wmi/tests/Makefile +++ b/drivers/platform/wmi/tests/Makefile @@ -6,3 +6,6 @@ =20 wmi_marshalling_kunit-y :=3D marshalling_kunit.o obj-$(CONFIG_ACPI_WMI_MARSHALLING_KUNIT_TEST) +=3D wmi_marshalling_kunit.o + +wmi_string_kunit-y :=3D string_kunit.o +obj-$(CONFIG_ACPI_WMI_STRING_KUNIT_TEST) +=3D wmi_string_kunit.o diff --git a/drivers/platform/wmi/tests/string_kunit.c b/drivers/platform/w= mi/tests/string_kunit.c new file mode 100644 index 000000000000..9aa3ffa85090 --- /dev/null +++ b/drivers/platform/wmi/tests/string_kunit.c @@ -0,0 +1,278 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * KUnit test for the ACPI-WMI string conversion code. + * + * Copyright (C) 2025 Armin Wolf + */ + +#include +#include +#include +#include + +#include +#include + +#include + +struct wmi_string_param { + const char *name; + const struct wmi_string *wmi_string; + /* + * Remember that using sizeof() on a struct wmi_string will + * always return a size of two bytes due to the flexible + * array member! + */ + size_t wmi_string_length; + const u8 *utf8_string; + size_t utf8_string_length; +}; + +#define TEST_WMI_STRING_LENGTH 12 + +static const struct wmi_string test_wmi_string =3D { + .length =3D cpu_to_le16(10), + .chars =3D { + cpu_to_le16(u'T'), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 test_utf8_string[] =3D "TEST"; + +#define SPECIAL_WMI_STRING_LENGTH 14 + +static const struct wmi_string special_wmi_string =3D { + .length =3D cpu_to_le16(12), + .chars =3D { + cpu_to_le16(u'=C3=84'), + cpu_to_le16(u'=C3=96'), + cpu_to_le16(u'=C3=9C'), + cpu_to_le16(u'=C3=9F'), + cpu_to_le16(u'=E2=82=AC'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 special_utf8_string[] =3D "=C3=84=C3=96=C3=9C=C3=9F=E2=82= =AC"; + +#define MULTI_POINT_WMI_STRING_LENGTH 12 + +static const struct wmi_string multi_point_wmi_string =3D { + .length =3D cpu_to_le16(10), + .chars =3D { + cpu_to_le16(u'K'), + /* =F0=9F=90=A7 */ + cpu_to_le16(0xD83D), + cpu_to_le16(0xDC27), + cpu_to_le16(u'!'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 multi_point_utf8_string[] =3D "K=F0=9F=90=A7!"; + +#define PADDED_TEST_WMI_STRING_LENGTH 14 + +static const struct wmi_string padded_test_wmi_string =3D { + .length =3D cpu_to_le16(12), + .chars =3D { + cpu_to_le16(u'T'), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'\0'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 padded_test_utf8_string[] =3D "TEST\0"; + +#define OVERSIZED_TEST_WMI_STRING_LENGTH 14 + +static const struct wmi_string oversized_test_wmi_string =3D { + .length =3D cpu_to_le16(8), + .chars =3D { + cpu_to_le16(u'T'), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'!'), + cpu_to_le16(u'\0'), + }, +}; + +static const u8 oversized_test_utf8_string[] =3D "TEST!"; + +#define INVALID_TEST_WMI_STRING_LENGTH 14 + +static const struct wmi_string invalid_test_wmi_string =3D { + .length =3D cpu_to_le16(12), + .chars =3D { + cpu_to_le16(u'T'), + /* =F0=9F=90=A7, with low surrogate missing */ + cpu_to_le16(0xD83D), + cpu_to_le16(u'E'), + cpu_to_le16(u'S'), + cpu_to_le16(u'T'), + cpu_to_le16(u'\0'), + }, +}; + +/* We have to split the string here to end the hex escape sequence */ +static const u8 invalid_test_utf8_string[] =3D "T" "\xF0\x9F" "EST"; + +static const struct wmi_string_param wmi_string_params_array[] =3D { + { + .name =3D "ascii_string", + .wmi_string =3D &test_wmi_string, + .wmi_string_length =3D TEST_WMI_STRING_LENGTH, + .utf8_string =3D test_utf8_string, + .utf8_string_length =3D sizeof(test_utf8_string), + }, + { + .name =3D "special_string", + .wmi_string =3D &special_wmi_string, + .wmi_string_length =3D SPECIAL_WMI_STRING_LENGTH, + .utf8_string =3D special_utf8_string, + .utf8_string_length =3D sizeof(special_utf8_string), + }, + { + .name =3D "multi_point_string", + .wmi_string =3D &multi_point_wmi_string, + .wmi_string_length =3D MULTI_POINT_WMI_STRING_LENGTH, + .utf8_string =3D multi_point_utf8_string, + .utf8_string_length =3D sizeof(multi_point_utf8_string), + }, +}; + +static void wmi_string_param_get_desc(const struct wmi_string_param *param= , char *desc) +{ + strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE); +} + +KUNIT_ARRAY_PARAM(wmi_string, wmi_string_params_array, wmi_string_param_ge= t_desc); + +static void wmi_string_to_utf8s_test(struct kunit *test) +{ + const struct wmi_string_param *param =3D test->param_value; + ssize_t ret; + u8 *result; + + result =3D kunit_kzalloc(test, param->utf8_string_length, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_to_utf8s(param->wmi_string, result, param->utf8_string= _length); + + KUNIT_EXPECT_EQ(test, ret, param->utf8_string_length - 1); + KUNIT_EXPECT_MEMEQ(test, result, param->utf8_string, param->utf8_string_l= ength); +} + +static void wmi_string_from_utf8s_test(struct kunit *test) +{ + const struct wmi_string_param *param =3D test->param_value; + struct wmi_string *result; + size_t max_chars; + ssize_t ret; + + max_chars =3D (param->wmi_string_length - sizeof(*result)) / 2; + result =3D kunit_kzalloc(test, param->wmi_string_length, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_from_utf8s(result, max_chars, param->utf8_string, + param->utf8_string_length); + + KUNIT_EXPECT_EQ(test, ret, max_chars - 1); + KUNIT_EXPECT_MEMEQ(test, result, param->wmi_string, param->wmi_string_len= gth); +} + +static void wmi_string_to_utf8s_padded_test(struct kunit *test) +{ + u8 result[sizeof(padded_test_utf8_string)]; + ssize_t ret; + + ret =3D wmi_string_to_utf8s(&padded_test_wmi_string, result, sizeof(resul= t)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, test_utf8_string, sizeof(test_utf8_strin= g)); +} + +static void wmi_string_from_utf8s_padded_test(struct kunit *test) +{ + struct wmi_string *result; + size_t max_chars; + ssize_t ret; + + max_chars =3D (PADDED_TEST_WMI_STRING_LENGTH - sizeof(*result)) / 2; + result =3D kunit_kzalloc(test, PADDED_TEST_WMI_STRING_LENGTH, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_from_utf8s(result, max_chars, padded_test_utf8_string, + sizeof(padded_test_utf8_string)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, &test_wmi_string, sizeof(test_wmi_string= )); +} + +static void wmi_string_to_utf8s_oversized_test(struct kunit *test) +{ + u8 result[sizeof(oversized_test_utf8_string)]; + ssize_t ret; + + ret =3D wmi_string_to_utf8s(&oversized_test_wmi_string, result, sizeof(re= sult)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, test_utf8_string, sizeof(test_utf8_strin= g)); +} + +static void wmi_string_to_utf8s_invalid_test(struct kunit *test) +{ + u8 result[sizeof(invalid_test_utf8_string)]; + ssize_t ret; + + ret =3D wmi_string_to_utf8s(&invalid_test_wmi_string, result, sizeof(resu= lt)); + + KUNIT_EXPECT_EQ(test, ret, sizeof(test_utf8_string) - 1); + KUNIT_EXPECT_MEMEQ(test, result, test_utf8_string, sizeof(test_utf8_strin= g)); +} + +static void wmi_string_from_utf8s_invalid_test(struct kunit *test) +{ + struct wmi_string *result; + size_t max_chars; + ssize_t ret; + + max_chars =3D (INVALID_TEST_WMI_STRING_LENGTH - sizeof(*result)) / 2; + result =3D kunit_kzalloc(test, INVALID_TEST_WMI_STRING_LENGTH, GFP_KERNEL= ); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result); + + ret =3D wmi_string_from_utf8s(result, max_chars, invalid_test_utf8_string, + sizeof(invalid_test_utf8_string)); + + KUNIT_EXPECT_EQ(test, ret, -EINVAL); +} + +static struct kunit_case wmi_string_test_cases[] =3D { + KUNIT_CASE_PARAM(wmi_string_to_utf8s_test, wmi_string_gen_params), + KUNIT_CASE_PARAM(wmi_string_from_utf8s_test, wmi_string_gen_params), + KUNIT_CASE(wmi_string_to_utf8s_padded_test), + KUNIT_CASE(wmi_string_from_utf8s_padded_test), + KUNIT_CASE(wmi_string_to_utf8s_oversized_test), + KUNIT_CASE(wmi_string_to_utf8s_invalid_test), + KUNIT_CASE(wmi_string_from_utf8s_invalid_test), + {} +}; + +static struct kunit_suite wmi_string_test_suite =3D { + .name =3D "wmi_string", + .test_cases =3D wmi_string_test_cases, +}; + +kunit_test_suite(wmi_string_test_suite); + +MODULE_AUTHOR("Armin Wolf "); +MODULE_DESCRIPTION("KUnit test for the ACPI-WMI string conversion code"); +MODULE_LICENSE("GPL"); --=20 2.39.5 From nobody Sun Feb 8 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5BCA13A35B2; Fri, 16 Jan 2026 20:41:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596115; cv=none; b=hZZNHdhzgImH/20KGQJh/Mc5QXSiWgwDkVOc0Dg/ERV/OyxfbF39PG7dqzKOeCb8Or8nYVm6Qq1Blx0FgMr54Js6Blc8FvaE82gim2ipi/tlA3e0uOpVhtduRzjkncvNF9mvu1iGwKDQpBGiMXLYxzasr3FOXaFMqRWtwroOjvM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596115; c=relaxed/simple; bh=xQFPf4e4pS/ERkYL/pEVTkOjn8tcKqY6C3zLhawflTg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Zx0K27obBYjph7YRRCG06TfeV66uFgRJOKY75RLOyW+WujkIC92IFHSn1cJ9VKbplrf1JKqgoQhgTQvTRk/7Pf9396RVwf0zZt83wBhIoyRsSKDHZbocM2g2wj8a+9VBItZGhUDBRU1LUEsQwm55pxc+E7fjZuZKK9zNjRqKP5U= 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=T5D3Nqks; arc=none smtp.client-ip=212.227.15.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="T5D3Nqks" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596102; x=1769200902; 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=T5D3NqkslLWgmpaFJsRvyIQ+daocIUwV+FCEyyVXd+ldugR0boRMPodyA+AC12r4 jCGgb9Qrr4YxYhwNA45iIxZzhYc60GQpqBmnJAW6DDIlSKU19lV+B7+TFdyH80vFW n9QFmcGOe96WxNSYjf5CcGcYPR6TdfR3qLUplVE8Uz44dplAQ22TFYvw3ETr+5rWQ 61LUC/FE8WQRcgAe44KJoFkORPExbDnuj0iZ04Sbw2mxhoEDt/vqETgF41vrufggU Bv/A12/+cisW2zCm0WSFQch8WNqudKy+mDVFujOhb7gtjx9Xu7MhuYzri2m90nE+V xDkomGRJahHNQZlMeg== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MXGrE-1vJGKB2Eow-00RoUc; Fri, 16 Jan 2026 21:41:41 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v4 5/9] platform/x86: intel-wmi-sbl-fw-update: Use new buffer-based WMI API Date: Fri, 16 Jan 2026 21:41:12 +0100 Message-Id: <20260116204116.4030-6-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:izR2mGXqcirua9qvMvy3zoCgFLQDx5UFkKVZBE9SwrpIkzp4ofO j00RESisRTg3w9P7fwpmOBo682sVsfR71oN/FIBCZDcTLiWjOFztXdTEb4ZFolFrFXnGVWz 0vMXCQxvcpxKQ5JoqpahTM4GNKc6qr7wZ6ouVPwlIrq2Obr0R1hHcNuMquxF3cvmQQQie6V WV6TfnK9htX0TRorUXffw== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:I2dbwOX1ARM=;IZvKfBvzgYRB1FF5OSsFuNPrSzb 4JjDZoYmPJI07+O8rN1G9rvZU0A1h44nEf9JwlmrhDYz0d2wR8PoiraiDkQZ2wNwz4h0UgUwP qCc2M+0TV1kdOxV12Sa0nrZKbX47i+J93MdVAV/mnFffQrE/NUQDY98qdL4xnifID4RfFzPiT adlcE5wv8orCIjN0qbYRqWRzNwXArl0cNkOgQ6SYDuyusZ8RLJ8tMjLF/viEKLn4AwYU7rEa8 7Jj4r6tKikMVj0yKQkjkJf2XvJehptapEhwEgYxpZcIeG+3vsUAW0GSdTXzSRF+KaJ2y4RuVe YrKWgus/9YmHnm2Gv6QPREcv9v/U/UYO65tTE08wPrHQ0WTBUx1GBQmCKSmVRFJ5qt4isYtAn X98ssp/l4qjZBHZkxmEVB064iN+th3Tj+pKPVXpi8abJ00QhtJdhqhHzVDMAncZQoludnQe3H ZE+wYQ9VP9LGflUsVjxdunJZezKaBYXNLq70+p1rRUEExe7vUU4BCiJjLlnsx0f3t9i0mh1iL dUuEp98cyfbZ1tyLEw/wepBo2++hHls4gD5X1PrgrJPH5pF7CDqwTDW4TjB6YJl5DMxZSL8UR Tm8CkaSqoqlM1l1fDLba6bBzKjlXZVn+8c7UmumVus6mr0i5jby0bBlotjgwduHDl3N8DVIr6 +b6DUN/P6k7oh8Rq37OSDEp4D9OZzr4AZglSI/DFhCuqX79BldPh9OWDPnUvsx8QKvjd+8zj2 xy1NIlECWOC3XC+FQ5DbZP4z2sYZokw8w5Xjj3KCwoVpgbtmGaSIEJph1iUTAoK+epk9PzFlm sChFektSOpwmOe+y5osrXPh/gGnm6cBt/exsFHU0Dm/Up8LE+1hPOquW35CnA/BPSMA45EUba EaFufOhuAFFaoX25/1XnqcbBFPBCd3Hy/G24D8nQJ2w2UNeelv+dM51oFQYASXBxnVfS4RzXl f+9aqlJ2VwD1BPOxSZV6L0ldn3h0eKXcLkDFtyI7z1xJ0/v/nbPDQXsirTug9bnQdG4y7hLHv ZQjBfDsrYpCyCLQirt/16Nism/aDm+0geBlt4RcMQoecq1TbPNAK82+Y+nBgW3kT2EwD181on zKKfNRVcPE6wNhitjXpJtdmTZZOWvdPS9sM9mTw1gJheG9cFZF7i/Ga9v5+m8oTh2v/MoZ56m coqyG/jfnmIjvBynszzPNO0cS9qRaAgtkRk95cKihBhciAblZy6tjL1nqNuyXNnxaIIjA4l+g j2u0rlxfkYsVkBG6SoHXt8fyOIEW8rpNt496TTNI/mF2Vxu0W+Vbsa8vyAWfN9cJHbtSma2ia 469HeK6LQoIAcgRpuudD4Xf8GwDGVTQwHL7OTnRBknV1e6PYzITDbkda8hzYSZTvsgqZb6Thl zCY8Xpgim21IAseceCIju3dL8Q/3X6l12YXL+NFfK/ViTVzfieH78M3aaXYvmkTsCmd6trIdC kcSDwCE/U3V08RChVG2Uc27L46SUE5FvglS2XZ1q0sHRZyKwN4Y7DlWxSwvaSMUsgAet9+p7z vkbjhnWY7sgEUhkVtD1cNH+ZJtiylVpO3YzGpmTphz6km7tQsiD7IDXyUyA7SBu0HSQjlimuC ySN/t2yTgx5AOIhC31hwPdVQRfqTvpSN1hPuCaIZv5Uu/n+gIdDk9HYRM/QQx3JpffgTEwdfK VDiOtOetLBUYzE2P9rI3yUYUqfOTvBFMVFEVriUVO7Gbwa3frB16lCdV/WQS3aZW82Xk3bQeD jpxdpUo+n79RTFmNj4tYkiP+2hv5EwabjmFK6wje0QHSxWoH/A8tV3O0XZsjfXxqCDHv+S71D 7eiXtccZQlFPTGofjjLs7mcRdaVULP48Au7uTZXfR8+JzBdHne+/umbzvvVLWswGeTQiKjeXo CRxAExKG6PZ/aLwOQxnsRyuaSeeFrGKWp0pwbrIVEtjrHT4WRS4hfpI+an4r9ymA578GvlOwJ A+xMaWd/dY+0WbqHLIlHPE/GsPmlD79oUyxdKgKvoCE9SYLBVIubSQjygojB2kxktrlYRONZL liEWTdPZD+ybX20k4NqyumWnvJBhmAYTa9GPaqd9D1q5el2sJvycP93kxDTKYXnZZpVjIusrI C1hCUJvoMnHED7CLdE6GTaM1gRnhgM8AC4Q/USAWhZGaAPdFe5YHlshFrvP3cFZAXzq8JWph+ pgy9ChtfCcI/M00MM6rNJCCZSqzZEoPTusiHHQC6sGXvJgJRrLRHNzCnH3ZY2K9/jhObnqS9u OCYSqe2fGiMUHAbsJ0sQ6UyVTctjBBRyVdf0EbyULYMAuA9KjWJwhDOWZZMTjS43Hb3SsG83n DU+A8Gft9VbfWWuJmI3rjX5dyaAvbFIrXU01a8+gXx1h0UTLnF7w1lAsfxSFFl4LDqcWZlvqL gUir92rZjjvcR0hT/3wWt2MqvjlfAqMGd2AREDnrtJHWPKpfF8HeevoUAB+ASFjwM6mDoY0lX 6mR004dWtBxJqMjUfCLxAV+3n7LBndJqySHS+gRsibv5NKOU8TgjFn2TwVyMZ/b/OhZCPHsri 5S6yib7aUsCIDM10/LytoQT29hlQbQ/BYlEICkGeHXxg4IG/MnwvnoX1vV4c6OVaNqAMR4Mr9 f5pjk6+wgwG93n3mdkxbFCrwrJY6uT7H9nbIMS84AzwO8d8UHxOuJeBhTeIz1sVHDdRDqksun SZg5CUPjAAxMNxtjL876eltzep2onJ4gBy+DpPh5y+Lib9kWW7BYIw6tHU+o6D6LyAtApKver LFLLMa5Bv5sLR/QRJJmVmqeBmWOUZD/B9ZN+ueGGKYFxKOC7Wr+ih1GW4mfiNaWWdkVCb4ttH OzeaDN8PA1cqtUbACm7EWzy5H6N6+dy/2hhiFGJ+CCx0cy7AV0xjRf2hoXWNtwfnBaovx9PMv RqLAprCdPVjdrKP4kzr2BiVpEeFf0w8WInhIUJYClt5DBlP002ZkmSCczUQctbBGzRFZNYMcz KMwO/Lna9vRDarQueeOa4scyYT2zxfDDcdy2lWVUYZneXou1hVk/4crevdB2amAw2uznmn+8o 7OZ/JoIdlHShE4El6fLyRYREhi7bAdmEQGXePd+hNVJuLqPIMQDyMs0b/LtA6ZB4SUVZJaw3r JgAVncyd2BzQDzSRpbqSuxvKvBhDYTuc7pFT+al/X/ixskSr1f2s33VHFKnbQPCU2o1uWtFaA I0n+2lPchvuk9qxtlbAUAJnGyjGh40e3OCP0Jll1zglZOw2HX4HxeHRC1HBC20kfGwP7vt+6d 0odVUqvnTcUSfc98zWrT/U3dWqKQO+XBgLIJo2zuP5yh2no7Gk+6Qp3XDflGakS6NEd7SRkXF 2YExx6NBheFm3jVhg7iUMW5F4WdZHEA+RtVz5GPAgDBubPXWWQADuxeb7k2lWir2ky6rc9YRH v30c01pnOJ9bv8gfxeJxB2KVnyeWDzxdGW6aiNOwCOxFghQTGIuQBUtVMBskrJi9OQqSIEbAg 7kykBBYoRevjrJ4V2Bl7O2xf6o7QWssMi6UIvIsRryqRZIWWhex/xgFIlj1CkTLlJ3cUfjAyO FGwrT0s39aFgX08nHEylnAgRqAVGoKqc+6a4nxK7jSjOC73uB3YN7dSUAEK+AQ535gfL23jKD gY9aHIFa0ayNvFdNL2RHtvXg5XpDpY4kXCvOZnxM4QdXZVx7vYe1Dniw+xLD2Jt9dus9puZwk ERH+fFWOi066gLY8+nVWzxseeFY2DLMT2XLijp1V5ryLS07H6VRASHnb1HIMPrxoWgH7zIHfA ai9tY+Ps5+Ecx1ou2J3Q3VA8YhngQrmsQ4P2Tpw/Uj3bWZ1GXqcpdYpnd0Vok/pyb8p9qeC+i 5WXe0c9iYONG5rqlgGiHhxcBE/M+xPgDmxhiYoa1L041zo4sRqXWeoVcN6YYNfbc0nJ85gdbq ye/Ut1YHdKUqAmWGXmo/VkKNuO+IhDc66tQVO0dcQ46iadsGTFroRfdm6eBV9nPR0/+4nLun0 XtJFkQgDle+bDuqJIcdTLfdft6C58PJlouQwiG84OWt8u1cGLBAE73O1lg95LnRwNLg1UhTat VOF+tXSy85PDOLe7J43UWZoTBgOnBTALwDBMPMkvW1z3TrFxcZxC9xEVaMtxX7RN2RmZZr8cL wDusLPgVh3/fhoet79PQyBu4kOkOjYDSHx+W0Ua4L4MhLriJBcAZXA4514+jZYjY9Hl+UrqLV fI9vjJX/pk0UiD2EbNDworiF3fGRRDng0dkbakUU9WfpLHOg6KYuapr0qXl/BbyZeigr9hbj4 wRr+/pe9GwdUhw0LDC/Io72kj2VANhQheS4+XUFCrTZdBKzJ4yyui6oF9YIEQLOMNUPO3m0yg Z0bLVsgHuVO+JbJ48DIdRAtd9T+LVKPfRLlYM0fNm90elJzWpdQzURucq23S2JB6r4L73BrkG ClkBGJpC8W+rPNQSpfqOT1guVHmA4dFD83gBywf5joDBkA48Z9am6xi5Sc32JXs/eBD7gSz+m PwUsWeYZ+IN0ClJnPeR3H3t3O4fgvMrB5chGJs3pKHgzDuxxUIE6yjuDXLaMA/WpcNq4ejQPV 8XGf0c9TJQyGLUcX0RJ6druzQw8AMTq/lcWkOJQMrfoQhgJm1zF26zxCRBlPibbn4/T1caQjF xvGpE7Jo8qs2xJf4kuD+u3fjCs+OQOac6phUh0M5ZeYQ11q2R5VFmTMoNUHJtRT1mBNJFDRwF HA+2vXQaxAOweHRosutx5SfIiU53PuOhkksNHnPkuJAzRTkikH8lQqv22KMV2HFryL0yYyY24 2EHzuY9wTbNiGuw+amfNGoUcNMMYMav32xvSHIpZxE1eBwyMIaJiikV98lQqkjbI9fH6yll3v sD4zzkwbozlQs/gVFseSX8oS/ZD+f7ydOGZTvrT0hmkVzXwCz0cV38S3/OrtBUaEtbJga+YsK 17OWhVxf0OWbgDm+fzzAg4SGeHc7RbmewpzOuOAneU/SoQi+WtUkA1XLMJ/9CV49sn88NWzWi KXwCKB2hHOYITOB7UDDJslhQEzyaCQYXPMUME/XCYrxj0Y78I6uR2TpMRP9rrR0r/AGrF5mus 7/G+MhFohPTARMhYAFPYQzQRTykoZ49TjMv2MvvHT3Rh4305DvepclzovPd/PXx8IVO8G47yT OZrYcgl5F6MDuSlWk/VII5CwWpDY6+g8hB/Dg+U7XnQY+q0dJ82VDni8KUk+zteOr/ALY6ZPj Wo2kWmWSBhkU5Oyc825nJ3GYZtBqk/lXO6Jc4GPrutUI+X9tbxlOtySZIEqyiMc92v5gcBqcq qYyLe9+gpuYzrx3eCNZIigShFnQ/DpDIU6ouKNdHtl3XWsVyHzIkDSBDQ0tdeZAWxRvUbq3+S kNWTTljiCbn 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 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D3E632FC881; Fri, 16 Jan 2026 20:41:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596114; cv=none; b=rBCAD7P/EAhbMt668QDnxXTg2oE324QLSy6UrBBf+QmLC0muk6K5/o9VF4hRLQgA/w3b0BWWr/zCerbgX8vwWIcVcWi1ETm34tRKRuxJj1jv8toq9TxqV6cjcN/i03K3kJORAXq4ZIa8xSA7hR1iYaoghRJtEklYBRAgYY2gQT0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596114; c=relaxed/simple; bh=TvDAHqOndFQ+sdZIj1OoGw4fU13kcnFTYjuqXVcz0M0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=jRaosjN7/YB33JHeSCJgwjIugsCsW9U+lRVth1YG9D1k6CzVkPejOSFuZKfKg/f3v7RRvTQ5bNO9MkbnyQY2pjbWDVuRTkU/KYLqLq+wGxwg2T5cn0lad5/i3pHsBQCJqAxa3a4biKri/kSCkrKfhdDCbRU9rovppONXcMCtmgw= 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=LyJ5V0z1; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="LyJ5V0z1" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596104; x=1769200904; 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=LyJ5V0z1FGDg2xka99ThcudA7RvXhWDz11YRhUyj2vukFDwuc+YuYrEJOG+4hI19 hemvz5OFsFsUSq7oWSB0aMB4H7WpHaJC1N1epdbU2pfw+1b7jZCzZAoT7iDbUEnf/ AZhnofk3zfBe/2/EVLypOFhNkdGZYt+ePBT24NqkvCVEZV37x64cCeAFrcl6ZZKfY +h2ZHYndwGei8L67LYlvz5o2CQEEsKsQd5tlDzw6ETUgq3SbdiZ/eUTxI3+jWkMcl 3SuGuBkJh6QcIpAEOCM6G3+NAS5QzrVzUtlpg3UE7Ot3jmQDG3eTZZw4ON4ZlJPKP e/fHbag9gqiWEe4+cw== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MqaxO-1wBUVL3IdE-00lGx6; Fri, 16 Jan 2026 21:41:43 +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 v4 6/9] platform/x86/intel/wmi: thunderbolt: Use new buffer-based WMI API Date: Fri, 16 Jan 2026 21:41:13 +0100 Message-Id: <20260116204116.4030-7-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:uQFPOVKwRyNOxlO4oqMXTWageCh915brrJ7rY6h0RvXv/bMTCGi rH9r82WLUieIbBDJW3btYbvKgc5+to0mg7MFiRNMWpagE22xTOXldwMAIku31c8VmFWkKCY r/z4M+WDJfcv7sJCEn3KMVeDPE4DeHPwxllG7yoUF9uMqNrpqNAHwe2+fBNp5Qj0JOEQ8a4 v63944JlnM21qLZ3fiNDg== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:UUv+IsplAHU=;1Xh+HGa1XewMrM4gAKPpX8heJW6 XDLF0pt5mNPKhuTUR9wDaOW85KgDog82tGuwe/ug7z13iJSBAw7e7miRsSgDq92e5dyjJFI6D CfXg/v1CaZn/VKYwJPF4rT4i7SUiR5gQ5Qy2+M8ZvN1bA+w0FZ4lpoLX4RmKkI7R0FIeGSzkm BCW3z49ziEWqqMRNqx2PoFYZwQfhHtjt114PKm1n0BG+kQdSW97+00RgJ95u1TyNOYlIPQSNb 37w9fH+3qPau2DHsAOXR2Jpn6Zk84swgvp8q7CsF52Y0alB4AjCPsyF2Lv3fbDAJZcrIezN3Y MnuCXcxWrmcPkSY4kdZC9/qQsmqU0GrVk5GVMfOxtV+HqFaDda+mv0+C7Qi9919C9xDdTXnvF A1MGdw0a0UPWhVONVeKUyL3cJV7/ABMb27IBiqh/GYyqKKImF8m1YZg3rfvuk1eg+/oaAOUu8 wst8PsRO1udzBtCFxpdz68weYzqIuUWnE9PMHDziX7SRmrKkQoA7HiNNBrz+VOIGOnGRsJq9M suvWf257mWnZH8myuQDCjy+Hzrj9cjTwqQvNMnSzuRykcY8ZaeUtfc6/DAcc/j3/JQOFnpEAx uY+Bae1b4VHNF7FhMfgbBrsf1cZ0+ZNl8x+gyoLmu6iCIrfyBwKU1J8dGkjZ4H7mXkLPo6OcO aGfiJCD28PjQDPM/1/klG0yZzStdTqx977Ot3D4iSyKDoI2QCfFr1GGDpxUKGo1q5qQMkEVJl SiKhZ5eLPTSbxUwU6PeI0Jmd1d9njhElDGSpO5R12UZRTmP3nO303b3c9KsT/hITw3r1tNAk/ iXNGgX0pR/+77kUxzGhlBXrYSYUDe1g+4ya7sAJX+gLqK3ZYjT1gsZxOIyJPBAwU1jdVA4BCk FdjEJ+Mk0jgZvRBgFjOcBoQpAKbyhgnme8Kk8C+f/6vExJ/2FVBr47JQ9PsRzawEWlTDtDNKJ pXB8iWXyGg2Yi44rDwhFRJQtPX1Tm8KlEvL7C41DEzyM33vvWnDMS2q9E7Q6c7ZGR2CE9iHRs RNqDUoJTyMQnU2sUWVS+/zTDRCeihXhxVDN3/bHMJQkVjV/omd+0Mtjj22mg3xw+Jwv8fjYom e4eq9BjZHKNnYPEIRcLRRXYV+Wrfie1V+SWgFgDYeEjOVdQC+TctcQM1egvox+zQgFMhGpN5M oR8+0278i9rNAJ9eQAPcPbhnVpF69G8lf+H2tN64zNal+4RJbye/ruAXluPEb+rwg0kAdvwbb pIgOaduQPwYgygAT6k+o64FmUGg1B48xa2lLltDQ//4hzB9oIyNfmKRPB5kBn2h+GBpYHZOcS 8jJf5jLv7E+9Tu9hEiNzRCRY3lVQWuU0ZMkrUSWlAfejMCo7q0/pYZYjL4by9W6x4diHPJlKl H8/dNHPPEUULDMYFcZ9RdMjZRuz6+Q+whwrQ8XvjN6OIHng9JkzOMfcCCUAugvNokb/oAGjZ6 NC1/l7C9Hdpwu47EubbweqZSJvD+NxKb1NJVbtA3h55TdXKXO4rj6iYLqZuRe1WEPXiyUyFQf IXcuHB/aBv/cM6zAoQK+E5PlKekaHXa70kAeJGN5Ix4d3x9DoC5QjEJgbEIONK5rbxKWrNeJz HDXL/Sgz59atrpHG+9kNvFn9HOMnPtG1fKZM8PN0iM/UoVwW8aB0WDlrAXZ3+2MLqLOqqPv1C 1NdyR4gGMTX0vuzLRH6y5muUyJm1pMSCXJQIUWIwMI+NQJfnXYPQo528MerKXv0DKw5MD6M0b Van6gZbt7Shf9S3Ohgwogf85YsCJ1WfDLnb/zZQvL3yJx3pn6USFrIZWRvUqois+hEkNhnIKG vTAHoSbmKydpdQRPXjCj/rzAFwEvf8iO0564ZS/ka92u+LEcH+MNBWaCdp/2zg+ILHHSsiaVn I2JheiaEFnKVPNlnlApeU5QvK4P7J45g1PR1r5P8ec+GFwCw5/UXo99K8hEqzzXK+57g1Kyfp gn3BJS6UxWIqGg4ISrlqpTFXTqCTYukUJXekqzZcP+KVp/MTlTjeVXLqbKT1SBgRteK31NsE8 lCKoj5loXYkIx3WmMlyKViQBwKnUpoFtU+s7dBiKtou2LyxNq2i/8fSsGTKcu5D/toRTHnKPK 0meTWsvjen96YPM7OUFYlF7rynAZ6yUiyhDKXxMPa8c6RsdA++eFqHUbr4hlNsc2NFm/K3/KZ PNhG+PMuu9dLCB2sd/vemwuz0CbCvU5/wIXOLn6CrhLvPTTZ8BWn+iII8kCdii+1jYVxIwqsg j7iVDXFBptLLqsQKPYpooRHrp/WaUTL61RQXXkBO8kbPjSgC3WRcog2fgjDW40nzG0t241d6Z EqdIFl7V3GwCNVdWz2owZ+aktLQ+dC/lVwl/yN2pL0YAJnQjkRcUCh7gGr6ZGS4EipnjdDVM3 52R8wzgyyco7CXrIUgeno2X5l3S7WX99zuUegU0x5ZMNp+7/82aYI1NLp0sOyUVYevPHqYLSV okt1eeU0EXfi5PAsd7ovFwpZ+3WtwDeCmM4jwHVOdWLAG5AnYo4Rg7HpvCXIocVa+Ze54ck1s sdyIXqnQhIXxKrdb+qP25j6E5HfbLYym0tbI/oxwd3YCU7RW5Ci+yvH0YAhkyp/g8YoE6zRgk F/wIuy5QnhoS4ilxarX4p1rvSUI1UavPFA/MKmGqjdKk2T4xuzk9wbeRRIlLAik3BGH8WbYV8 DchuGk7Q6Yc29Ti5mdiTnJk9Svj3vCkJI1F1pbVtw0lv6Xn8zz6QJnEX9X9tds3hsGhb+zn6u McA+npGtQzDsYTow6Zlqs12RUUegyqSJIMeBBudOu5c6WukaX33KPOssovrsbfiYJhhBFNtCa 27LQTngdiy2fo39bFGNhm522jSgpnNYo69PsOdAXtxoTbHlzxeOlBCc9215J5Jv64af0XJk4n zgC3gBU1fk8JX+ZKmqZVGgezS7lhxklcARUmNvX0IzFJwV9VXtJMKK3HN5zTaSa7yUVo66L6w lOdtqVsyQ8v/E26D0NG079Bo+wvT7etzl41PquVkqziL16n8uWOa/Dz3Q8fCfPikdUYtR6BFu yAQIFabFjiCPYiLgrK0Z5ftY6icn7xO2m+JP/QANMPl50+rtFtCIntSOMGB8MT2I7rhjfisxd SIBInKQ39KADl46rmQ1mBDFwnX/MDPOskpJRRI2ZW0DHReFo70rjJy06XbttI+U/WHeVVdJsB YZ9zk+pbXHqOVJ2gSax1XPLMLtdr8Kvpd3SI+uTIYVqf6ACyWyWbIvDm4u23PtBAcrCwUjlck GtWJ2LxiS4oMd3qteI4MBFptgf99LlyJO4X1Pa3CiCLuGlQNtIK5vP3bYftxpfaf5dFflIJpB LAE9hKTg96sSf3gaHSq8EEgmTcGYvCUj5rrU+MlA8Sg/4/zQImgwqQRkalSMvbXuDyqfF3hP7 qJZL4PGoOlxreWbGJNr6krnqAEn4QXcuAcfKlFVopgS0rcuI16R02l/HIkC1Sn3aoszWl0fyU W02OsvZRCqQzbgbNDUN8CZpRbVcEqC9rLmDy3tvtV8rxRgEIVgOMFSdpnKY+/9ttfzJd5o6R6 31zqYEbxeL7Nx5V4fkbyiBf3yKzWsr7zTXyDXej0rG1Y6YTpe4XcnJg9TpRQRXyhuuBPz7ndp +JEufVs5CGYohxdPILfDNRHKN6J4qEYo2/BxpE48o5B+LvrEDAg9vYyLnWApk8Wqs8q3/PMUd bCWWRTeFzSgQd2sHXBjwK2wwKbKJFCihX/cCt+LiWSF8pntfN7gsm+Wb9zeHZaiRj6neWQXLL JykiiUA0ULX8UnHpHuxB7sjXFKoVwRFhW1O5M0JPg3XyO1Ic0IG/qCXm3kms4M3vA+0s4WP1s ClTEH9NahtvQ3zu1lAeOY+piH+sR/RW7+p7+iGVc49XdXh/z1HJusbG7jwefq6uWQx1Gk2iJw DvxzKEgM9cn/lGowoQzIvWOFROgZuS85i+w0asJ+1bc0x1cPN4bkVb2Afsdu/dxIBuW6mLN/m 3gTA64oMhLZC6dSME5NFWx2CKxv/jPUaLmeGNYSbJEsWeGncXzt585gJy5uK2NFAfUKBYmam3 NojKeQtFgI//qZfiDeDqaAvn4QMV/sbBNAv+Jxt2RnPtci7VWF9qSYxsPj8XV+88tLhoJCVLT vZRMsO+/6cBnZC2xJIVZvHLo3YZ2T4fXXFC0SLpvZc2TP7MgTEPzXU4DRWS023gCUN0iKaVe/ nQBuCRWqEq65EWoVsuJ9tRt3hvlLI9vYJYziKwPmtC0xlQq/TFmzqUFt9QqPZh3E3tIgGF0oi nujJa5S0iXQBW6XhOGBAfSyrKfGAag7QjAuA+znERg/F/AcyL/7CN/CdZjfxubFOqJKpJq/bO PA/mRtsxm+eEPadQZyS8urCeUtgVl8ukyrGxUfgkj2U042OqkNQoiNKdyFoBVpYubDGQp7N8K 3CZrdEyq933IIpd6cbWs7+XT273hoy3RFh7wQETCMWl8RE7f2AVy9jEWBQhMHyQ3SutLJDYcs lhqw+95NrtkZkDzFtex875ViNXoik3p5CM3UbDBF7JFPLiv96cUsliOGUe76SoJo7ILhUF9WY GohdID2q/BPDsb3xXZCLVmfB8o6XyAbGQ4+ws+gFq4SyJYZiqgisb551T3V05CvoAaYvIJxbY GDKc6LZ1fVGsxS9Tskp460nnqPQF0KXv1NvpabCRI1A9+6f6oPAte+xD6IsFG10zmK0vV8uaX FFJsR6vu0OsehMZskrcc6vxfmyY4V1uKgTiR/CN6QlzfC3LtWSHd0Rto1Rx7cRpczz8ogvyqC wpoS/BsOKQ7lEjQ4ndhopD0N65OcqnozQaFvLQhIwgzSc3T6e2UtXhrfyU9uMkV8KepodPnQA K6HnqledGTmSmTckFmrPuFSijk7I4z8Ng8g6qJDJSkTSHo+QVTI36JrztOxh6J2Eeg9729Krp OoPIVToSxd+CqxcBQTBvL6mRcj1YFV09TMHYWqxsM00jc0ZZagXHQ/hwLUbffB1V19JSGUfKb OxQDT1nCFvHqwEaNZrs6Mt4BWh/kyMtssDbC6vJsLM4Qs9Vj0TTFZYumBkTLWJ59h2uCsJe2B p5KshS6YyrLqS2ZW11pOIgq64g3ITrx3ASmuYvQ0G0bv1bTqTnXpYS7877ZAE9q+lQno94PgE bzpCB/QE/oxyZren6+HkwXnpi/iDdaJVu1kNPJDhrYOsVrELCaUPTxxIN6IcYyTyjrO0hDMce 835K1yBgReToNSzjwazqKMmKj+pgQ 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 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 639B73A63E7; Fri, 16 Jan 2026 20:42:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596122; cv=none; b=XhDmytUlHsEtIA2xQv4c4Nsm7mut44v1Nvh4fIr2F4q8M8+LpibA4M6hljd7VBNE1EVgbJOiNe/fNvzIBP5jHC3AXQf3L2Ax38auXj+l2Xu4EAjral7QWLyDHa5o4ee09z3PaREyCJNOPUKQvo2uj8C3zauZrdTfdfKNuHD8WkA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596122; c=relaxed/simple; bh=TJgLzTksdV6FW6f/rYwBBRpRBJulZLasWdVu8QXIRik=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=l0N0hkBS/OfCFVKATl6anaw6kcENBX9CTGb/vvdO+G4+jWmOx6nk7DsT3eTvwKWi+2FK/mRNpAp9051nTuOf23Qce27rq0MEu0TZwFN613xrnLmykXDuPezcEX+naHnGV45PdS2csKa8fko40FOSuViGGAzXUtuOGC5A93d4ymg= 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=aboy+SSf; arc=none smtp.client-ip=212.227.15.18 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="aboy+SSf" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596106; x=1769200906; 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=aboy+SSfG5LkHjV6K9+Z8HGKSiKhb8xkw62RI2fdNIfUpFesNtLM9/mFbbM+82Uj Qft8OtpOH0a1LH22tiAWTdmBTVoWrbj3oisyhW8Stw0AaJk2o53cWBlhCg6ZRjkgs mp6CIcLc5bNZsa9df8L6i7HHaS87tnDQc8FcqIluQxYbxhxwg6RT6PpPyjKw0Z10T WGg38WFAZjnyS55NcA+tmnIwra3glD5kSVmsw2fRUt5Z0+v1+2lQkBOERNh/n1I8S tmdF3OiwE0VRmugCNAUkSNiO6Klb/lOL+y4f5H1QYKWJ1xcayVoyC3oWl5F+wLF+b MlTkAbHsliF08q0kOA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx005 [212.227.17.190]) with ESMTPSA (Nemesis) id 1M9Wys-1vmMxB3eZI-002Ksm; Fri, 16 Jan 2026 21:41:46 +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 v4 7/9] platform/x86: xiaomi-wmi: Use new buffer-based WMI API Date: Fri, 16 Jan 2026 21:41:14 +0100 Message-Id: <20260116204116.4030-8-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:nKMeIxKX/Y2HAk5aXLgGHNLe9fcRooHkvrCxOWPBujlzQHgrfXR DygKgKbgjMyBruLQAmhBAzdo9NEPPVqaQJ0ub790VOVY0Vm3bBdoAyd7uqRzwnAcg+/mPH8 t//wEvql/7rCWUEz5+FQfRorv7X4H8ZHqH7NjtGmCBGT9npdHWttc+ZcFrYRucg4GT1EcAx yC6ASXxb0kifwmVCalQDA== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:o5VL95Aq4+I=;iHQGzyelPeKASV9P0rJWfjAluZj uEqx6zmdMl9Q4cKrf/pqzqP/84tUbo0mcL4v0BuYj5WwSop0KDCUCWIfgMC7me4R6daGkU2TY RMNef/Crj9IGHpnNZ4edOqxelcIJ6ig0S5V+gKt06cokPQijQfHj8/ZQLSly9va4hdYZxWM56 a4YzaumAqfvobUQ1GTiNdaOdoOgogVPJIJNKSSLLTyh3Iylyi5y/GjYDwdCqCQ3Ys6+CU/Fnb ZeKGFIIyIGD2AKYChHXJ28nnEg3fABHcx7gm7kESBa1z+py3X5FFyhGYE+/+wCjthEFiyMZEs EnYsz6KoP93aeTYDHqGv0AfJw5sJ7vhUh0YX8pKGvWOA9XiJAjMp6TGsVl2FpCj/GC0E4Rz55 n/P9P+W9cGEc4uKz8O4kylc54qZa8ixFOZwH+r334GE7a7sOdyCZyPvqBEkZjBYK/WHxxrFJF lQI1FQPJdR3R8+Rsng9R4MR9aPkjG0JdUAqAvNxgW/csa0H2m8Mz4Fcs7jHMZKG8K7Z3/1fTc hDm86/Ez912dAuBX5kXtRVbVFEKDnXG0lOBxpwgd+aEyYWPuHwh5yeZewgLKx9U+vQz7VlItq q7CAYBbo+3CyMo9o+LaiAg9x9on8Ukf5Q0Zrbi/4FypOa7o/TzBr61kmbrXV1qXwfd/SvdJTi 4M8VW0i9XzbwoABSdRidRBigSSOD/C4yd+lbcSeeRtcDz6kmHO9Js+AAc1wwM7I3Lu9vtMxMp WU9dwKcdWq2pg/1uXRaP25UAeoy4up6gf+LNqQdsEym/ioLY/TiMuZKW/DXfH7thqHvXsQDSs /6DAb68fkMd7T4e63OdQWlSy1Lyx1A0snqPVf+UDlfaYV/78z6VBsKymMDRmDChXyfJ1eQxEC xCeFzZ9y8tNIEc2X62ug11itbE5ZlogA74nnJEIV5FePldcFwvPIZQ6goQS4uLU/o6XAlbGcc b7IAvjh64M65U+9KsgmglpUKghGtmEkRG24jC9xHJDMC9J0SEZWPW1J16BYWmoQE21vnBu8I2 jHtQ+f3kiS0E8gNmm7iAFSyd7ITCsYl9HIV9ieEiNNSo7YbADziF2om1piEbjM2g0ZIyHyUSW QViFc8dIpV5rRaH10RHxvYUytma4aEp8x5RpBC/IpMxQfhXMNssfwHOd4SBm2XS8ligh/eoNa RasQ6tai1jdLUu+Wxl9hJ5gxh3IXbIkrIYLU5fwnGcB2w9td5Hp6fe1fBSLypfadc2M7Kfy9f odXqrj4XLnHLXaXVdEkxlmuXnZigePO5pO4IHmbGhVdkckrZkOznXpaWBm+r8d8zuTsHyKkBw P9h3AMpc1gtDXQhhLAQH6XZgWSDZLcHM0HwBaK9FWhc1f6yIw/X+SrmFxZwKqk7NMnWFOuwG/ J4FQuK4+GubGzwECp+mKtKPBe2AMKiaptjUvCQ3MpDZXxSmvpbucyhkKqcUj3tEdt/txLwd9f qddWxY+30hZBhJHEKtY/D9RjNL/Y2NasA77r+r8gxJ7OCMcB3vZIV/qe/zvisHAn8dmJC/S+l QKtJNpCirengO+Q4fXTFR8/Yc0DPWI9Z56ec9b2ocb3CsLwj8NgSYIRBuvCKFEOrn+pxfTrp6 nmgKwVuqV2zd6MmGlUnc+fgShXFx4wOJAkDCITFx0kcQkGJoxBV/mAuKYeyysQAXIBEgvlrC3 brCilnfVzW4AdXRMMBHWqcPv23u1fV6NvkUwiEbaNAtlCNu6GIPIe624HVPokjFpClN4IYlhc pXEU0D1tmyX9MVjlLCI8k9AIc8x0zSiroBI7mX6XGhw6WVv+726tFpPOwfV9wM9pFspxudl6t ekg3r6hlInZduTGL2k1imt2DT2rMHk4GlLWyLnXXeQJeWVsytvL/86/ZmX2lH7Jd9K++kaFJ5 WSKx/V2IpyjDJ4ntLWNliIM4wXLVugwuWFM2qVxdCV3b1dWvPCz0nf7znj2h0U6cyrgEMRFbL n9FzhwA+P2yQpwK1AU1qc31lZUw4MXIBsK4vLDAEy26hllgg0NS/nIiDx7m4OJwMQ++EUdIDu Ue2uzKjQNurd7vtHdG9IA64hY+/9ojXRs6fH5qcsKPgh3Q52MtGXyezHVra8Hs3+Ekrl4/QRo SkmNY6eugS7TM1QzxvVG65NiHBOFfeyiPBM4VN5/oyYw/gFmriEOATBhtb1pLI8Uhs7+IeFpX uuymV/B23pHMjiEpbgnVKTOpHNXUcrS4OhEhOiIC0dBuX3t/J2cFC29Ts9h1KdPdnsL3yhYtp znGKVL5aRf05c3kWGGD7fsYB6hsksONOvuAh1wCRj+g9T/Z+7627A+wXcKrxE1kDZtI0L4z4p tHRad4Tz8OPxzXVAJ4Fadep3IgBFTBf41MX1pTaj8mTmnZTmk3espyCoUxktMc8SFO6dGLytA zobnW80ZEohraDH2eKgvCf6Man6h4ck0+zo2l/PfgPL7d8fpOv/FpX7ZZZwGxgkHh7rpdB/0b 3DB3myISNgCdzv0CbFoDZ9iCdV8sFIpxFI2gNQlCCzIpxnLSQkkiO+jIF3YkXcUoInlQuf4Xe zLmMXYvq+JKLLVcQ3ZOec0SUfw6akcCOMC/22Bn23fmtgL2iNtBKcactYR2UeEDegHmQnSE2M 39sCidEtctCLJiCWldKSgFTE/Ex0DrAwqPKF2eAST928PFxxRrIC0XvsK9wAu1um7PMwlrUtZ FB38P65oNzPUF4kmbPIQwM885jKsS1QAu2ZzvvTEejbzqywPcT6ylMM7Pftn7YnXD5pa6Dw3u vRue0eyY7fxVcD5Xim7qO8lf8kWueZWitgotx3V1+dkbhuDzTRDbd6q/84aIpmzI6OG4uRE49 mzEKn2iZe0r5pXTS/D5NSqur4zegOZkDgtvUEJ44WtIHtufhd42nimtdinxrPTEizFDQSEuB7 VfbhYqNiIRN5ko+52jGC9cKzq+azsyLvjqf0bVo8ET7b3CAcYtUK206tyL8D+u2fCJfaMD5js r2ke3qkbicIVs6zHtZnmTGbCQaYY6LkP8xz39L/5F9a8PIHYA+W4DIbbWxAFraD1SFhNSIyTx unZW7XxNgqI1ulDBHmIokH/TOTd6lSfam2ZjpbkcFv3D4sSqyVnaWGDFhZTU1BRaAZPuaT2jj tvM2MZU6kCqfp4wsGlmrPVx+uf7yz8OoGJhjfzyDgu1/Fl1t/2aDJWxF4WP30GhG2Asz2z7lS rqZyxeVpQZXlL7kbLIbD8u12rWAd8OpVIbt2a0Dob4ghyo8/nYP2MsZ8ILOf9ZtJtKQpqidrm X1yhRBNqkXxoPcTAIznQCrBK+j0CmuzAb2rKSxBvosWHwxuKqdLNyLvVYHms4SnhYBkGVdpac KUMJUg/69Xp5sK34zCLqEqeuZ8Fie7Q+diMhCaJ0IuSOwAuis5+qwmFhBcXh11ODTcPgGlBy1 rdekY00yUkKjAikIGs1pkNH5X+9y6PgD7yHFe3QhOMTNB2kW98Tqo66gYgigBGyO/XE1nyh5h QrUToGV1ZEBeYfuvcDFnpoyPCoktFT/EQIzVF9vU5HRodNOtAwxbtvCZ5EHiVev7/KJnwD6Mp lya+W3pBH1N2r8BzFqQxVR1Z7deNyDfBTuolRxEtXvVMDRaCVFWyh2L2Uk1WzqkoeZjqJA3f3 djvGHfPdJZb2efvhylkNiPKGztCsZnYTFze8jPxy2fyViId5IffO+yhtNSsvlzw2yoNGsyK9R KKNTwd8yYSOt2bK1dsc1lMNUi9qb8sYvBAnzOzVlJ/ITq1m2HZuGvqrUGgHDYIvF1i8ZbwsFH 5pPxl2enXfYKEiN9sYy9i2uQPgLv8DbD3v6PtDrEHY2EfFL5NJcLzgDRGUeUZCj5CWMbQz6ge ps3rGUoXDYdl/6qg3CpzdwGXo7XE6WM8BIC1Ok2EfJfaDdNUu7gRqpcHDvfS6DZBYATM4s1hn uN0hGe3re1As361L9Te0gwR75R/++m3V71S2L1s7DgxNsXyT9z/ss2ih1rvJKEwyg8IqQFFYy KOdYpEGiFWRFp28CZLWJx3vFhESFcWOOall7ihyz2xWleRR1Oq+Yke7TT5/raEIDcFbXJTSbu ealIfiUYhdXGmdD3nhIgT0QgntSIrztF7jgMTM9rLQaLBb7LvLCcednqP3zQJHXE/Yphf9xDx V/jjzCkPLWKhYcFSxrotTKyhB0QwOt3xM0x21L67hNT9RtuBWHpg0Q6xni0p/9sVP6R3UefdT 3agaX5IbnkBWf8tHNO7zBdng+otlAIOm1PDyjj+c4zfROpSdvGOluEzlsJYEi3Xb0E5hL9aQS qNx6+i2w8gCPSMjTROlc3lLufi8N4iLns5hv2YMz6kNmRhWzqvW33uOqkx8wq/xTcqfyLP5bB lmricmKty0kdVJNNC5dE7qFk2+/THDKav4rW+MSXP6WysqihqH1LyTLrFqkEleX+Rk7OcWZua rSskZXFHhiij7hWkMLjxmAkc30DjiUdSVtA/PmoY2XzqhN8QCMJdjZTas47Lzeywqg7BOgyer DqPznwkbFI13rvmnQNIyoxX2V5Z6gbvBFttVHiu+U9PQyEqJm2+1WENaxvStQYlViShu5dtLV rjm+N+qaAg8qz6RBn7/3vsFqxTMjm4kKKCVYer92aY53jKWrcw7KdJi8vFCWyRHef1JHNBg4U nJGZhIeNgWmYG2fa3FJA0tZvMUcZ8JKwFh9qnIUIzknktd6LQCXa/BlrWyOBXrXG6Xt/2nb3F YCWC+I153sKBLG5xIxIu1Y1z2BArug7qiwD9fm2s8pq9BwFZbwrn1d5/0j0H2I8d5AR74MVmS uDtil2FQpaYgpiNQpUZ98F9qDb4C4MXFOoprPmv0eWywcZHtFmT2FKY47nfSQqHScKHdEw3Kg 6Y+JqwgdOH5GsMj6w+WJLm+/eh536q035k2ZD3G8bzN7c1EwwvVqD7IOEoCjyjeX6i/0ngKvj AO1ChAcTZYYKHg+GMQAbHyLxCdkMgashURNXzDyqcN/MTnZESsZ3BVlF0yftnKDbHPFpL79rc 5B0kOopgBM+6jLqFtjtpFdm3m6Lh1nL+WJp5QIKhPXmlNLMo32RWrRHvhsivQ92sL5wcH4NSP QAKbwWpgtR8U45oB1HdbKBzMrDdHVzHkvqDPmCRlIB0gkAq3BKyfGTfznlJmTtFfs8E7PLyUz kyMZ6ORa2qImXVTYH080EeHvCNLaltPwKlafEFqcNVuHIqiecaAkJAyXLFafB2kAx1r3ThHhN Kz1X93Mf6JTvleKpPkIjizgAB92gqvzzpryiTX5tlHJ5WISiugA== 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 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.15]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 518193A35AC; Fri, 16 Jan 2026 20:41:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.15 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596115; cv=none; b=qaooaycJjTfWh5qbv9CenjqR6BXyss5jNitaRjc5yJy5H2dwM7LHZ09zClhQqg3dTLynioXZX/WFMRqe8gOn7bh3y9gn4vHfRwEoyQTYtjN5OSpxoyFbK61ug2+LimMdx6wuZzkJXCGnodp651bExjfhk/00o8tPC2RdToFF5bM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596115; c=relaxed/simple; bh=O8IGx/qdPLgHwXwdToL4OtW7b6tvLndNcTwk+PuIHqM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=kkNcPHcCns5UlObjD4i2ZXydTlBeegvn8wOHbN1cfGV+rRJEVAJkKQnrpKivuyPD1gV80DeEp8ei0RjL4JAyV0yV/BFm2lg451HDN9RMP7X0080RjT0KnLBgg97HnHEvBionly/wwtktxj7GAvtql+OkC3ngJqHnNYfO8/lzCIQ= 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=qMNYGbuJ; arc=none smtp.client-ip=212.227.15.15 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="qMNYGbuJ" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596108; x=1769200908; 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=qMNYGbuJKZcCOFMBhAZmJskOHxdFF2k2+2og+JMWCrNUEUaXNOvsVIi30l2nsQ9n 30aYALk9dkVv2n/hriF964QAlX+zs/gSRPX0aKvHK4sdTR3875w0qrQBvKlXrQLU1 lHBM9Ncl7I7q5yGTCF9hMcnO2OTvmGNwxiM0WahHg4+UNlp6U6ns2Krx2+r/1oR17 jirpeASi8gcVFTSuh/ExFtEJMkwMi9USMNwC52VAvOUgMKFelmVNd8w1RIrXJdurW Es5IkjFdXJwMd6IbmZzy7zyLmNMSxR3HYWV0rkQzULQITu1I4XKppmNZO3nBy0JYZ lvyZ/YFgnO1NQqCirQ== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MVvPD-1vHrg648Yf-00YhTF; Fri, 16 Jan 2026 21:41:48 +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 v4 8/9] platform/x86: wmi-bmof: Use new buffer-based WMI API Date: Fri, 16 Jan 2026 21:41:15 +0100 Message-Id: <20260116204116.4030-9-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:wDT5M9zW2s72uiFqNxerTY4qs7rg0tmmR0yH/N5lCuwIHOgQNtg QHwSXevaVQuSsChh0/TgRcQHUAfYxnMVew5WPzJ7AS0BMNY5Z/s073akdPeyaiDmhzqSttF pa/EQwqpVAAMkwFXBhZIi+t4SQ0a0ErqaTHE07nlKZ0lUmPoTy3v4ZLmiCrQoxwjsJwZL1q oVbJY7SAYrZklZMQ8Oe6Q== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:nq2h6dG3Nj0=;buk70z8iIocuxsxtJuE91ZpuXpR Y2bhGmdrcjpSU5HpYH1Jca7mFIyvu4xjVxP/sWL7n4lrcmBx6YEj6kqzOTnyprxugZCuttkrP weCBORIrB5KEoxnXefUt63wPTQtYosQb/UNPBulSdrauuJh4/D2c75yEYAMjRuGDM/0sp4BIE X3EnFc/+Oulk36f+IRRs8kC1TvfEhhbXAFL3IWo4aTvkjODuBNehBC22u90i5/a6p9aHglSup WW3vyxK60qpApKhMteObrwN8M08H+/bS6C4e1ilTt4ylOA4n1EKreSdojUdeB0yIqAL2t0cvA NNIdOxVv0vI9EbNhH4I5JbB8gQPOHrC1dsc1Z5zWCgyDJetcAao2wwBlPcCajKY//qmHvOhaR W2FFceqlUbAHGMrwOHZQJezmp49Osh2FjptFUVJhS7cHDS96d0S83aVL75wTlsjD4lZUEoIrQ 4wDSGz4YDG44GVjZZv7XMl3Nebx1p6eCfvAcKczvR3ZKztL6IzDcGqQ53hgWz2wxUt3svIS7l VFl20ryItLm3np+/PXYbcTX7YMvKe3ggLvG2h9O41DNtGkSSnfSHHBkai9T/egFWlPd4rqjtY 6NteccG05N27ZI+7kQF4gntmkODbX6WbGh0rNT0ncP+keenj86j17ka7kGjf3CF/e+zkGDTm/ eU1At3MSFWpmU3NvUNT6C9y7bpaD5ZaHKY4EFU6ik4uT1Qb01nYGJcqi8sBeGYzWDSbg9yyLk j/fHPjzVhnsye9Sp9VdjRa9fOWClMgSbNegduPquvYSfJTN+pYhKv0t4uyBfHeNqmYCkvmhQM x17clvZjwqdZqPpgolMK+4LxL2gKSmnQbmRW82/0+dOZWDU/qFDbW5ychNjbiOyDawPrzZvoA 4P8SWy6AO5KJAd9SkM17zV2nfiXwZSgqlQsSOVfCyTPc71hH/82yQen5s+uhBm0AqLrWBYzKa Wb7x5wrsBNFfgmNRb7qLVGiqPfStTN1CkwNk6kqWIyt+l3Tpb7ZynBSqcdmDO/B1u72wzr8A+ k2SOYnkyeE/VYj3Wm7ehBFRb3jm3JVWv/MeKySveI1Kdy3UBdFACIN6o5JviyDG/U/ePpoKCw V3DR+WO1DpZwwjy1ZALh521dUQZSuTbPXlM5QKyAG3lQxxQfoK44krZQ7EmPTGAE9ahiAk3D7 Cc2wQyBGNRjXSwp4hdQp63NKCxOJYjfVXnMaysZbeLEkvO1KP2POKsOngNRmn/21ZCM91EyOu aYTZj+MpSHD0VWmvHErcwb81TbHJyKDreiGuSQi+GMJUsYtmDeQygr2dc+nL/AyG/AaAmB6pD lcd8wjdGcXvdaGotewJlhrtHX+Whspl0mTTQEZp/z0Tqa+fZ+1tkxPbcDWtbpxUzUkaxStcDF IjN929mrO3xqcIyoWWf7TzKRqSPiq90i1p04dJHa94xt2pi+sPyjAs+cGl4tR9I5Okf8pTTxO hyocWsV0umRoGBCshucIIy18b1N41/2o/tqlG0rYRbSimWjb7G6mHTSbupr68qw3U0eIu/3Sa qiXSEW9xrxpnscwEipYkWOezUZywTJA0QZ6v6ja/fj+dzcUHIwOkMYCbs0FtonB0wHRzhzYgd //zNSO0r4YUR+CaRAISqq4jRF/aF3giz2LmNzAsX5DkvhRW2/sZ5dMb2FEEaNRqek2bLblRWi 8VZVc37dn6PgKFJ2Y5OO1NL9qMuoOPS+SJB7GU47X8/gyZj4Yu+M/9LTQXJXlbxpUmHV0xYIY 2zsJzEA6b/aE0XAmNpOW1Y7ZJAkpRxHBTTcn7uCE1JYFHvD6ikXrYYVJn+1hNimQdp4ayVBJB JFiZ0NKWBoGtSqRHcnQpsPc7jYH491WxnUJgPNCHq1lyxi1U9jo/cokdE8+vuu0uKekXRtNCC f4toRL3n7cl/Gly2io7q3GhAUNLePAlBAVl9tEo2VIwoS/Ss5VU5xngoyN6htSVt/EZnswkMh /7adv/f4FYun7uVgeIdc7H+z0sw5w8ZKT9FeaXLL2ybx6hAZJA+4IoZqc66q0wRZSmcyoaWho syriTDLTHICE7REwQte3wtcEFDK3OgOVoWQd+FRPAFPnaVFhfodrpghHsuLdCH9PwIMnIWCd7 RQJAUoV11MfnbvyzQW/qRy0E9o+wFdPVqsSwg8HwDHVk9Ve+0khzY0t7fL/l0iWsbVbbISXdn RLAm9s5TtiqF/+wKB6A6pTgPaiwpAx8bR36pD28MFp2Xgp67cOvuUPx7iB/VF63r38ignWqHq 9QZASk8ITPHYDJQ/C6k3606bUFsx7Xu+hWWgsSRMDLiQRKiwBrs2/AtJGZmZx/7+qrhh0C8h6 S5EygMNO1I1aQ24oFRLDy/cacnjygUmqhtUC6Itm4C2LBI0V4h+UHZ73UfLz37zovJvRDU1CR c8v2YogberqFLmWGrq4frrfbvEHqoQKPnKhgrGj+CgTf8MWZo7oMlKvlQ+D8ja9XHTNRfv0XD gj+hwG4kK5HtsF7xoX25AJLaovtaGWeeinU3VBaIxoaLvjcAuDDkCYArXaY4UC5z/qlV3ampM NBWkTOTWuO0pIaAID68wUNVV37D/6jnkRf2joUBjGWpbv1pSPTb+2foEd6xDn5FzIXJ2o8fSq m4PEE60jF41A/8UmU2mqzVlSOjnnOTvZfIbz1MW4IWLF5wJNP6B9+Sef8iLRew5C4fD84+v1n vQpYXdBDu1Ztw+2IbFw1JQEO7V0s6daihJ4mcHQ/jV7FWmtwCU+/C7mc0P8XHlgZ5Xq7f2xtZ pYvWDsFPhNqBtaKu9rsDhj6FdIY8juZ4ViaYWLW0bj4rdIDu7Hpbxgb9RcY/ensYusPx/EPCu lOiy9LaUEfzx5pKx/R72R/zDIKxY1ZhlPQbPa9OP2rK4wpz1DfAxgem21GKsK5d44wMv/o4jp a9ollQ4Bk5+3ikA8PwY6WXCRMVZAe0QESoVn1SvrjjYMeOvWThprCJnxJtcJo981P5UOOaHWO 0WtDijkDO9ApCoXJ13JX7QXdgaXgBcQudBxVTrxIOT4bpoRUVQ80Fy9bbrrtjK5VD3x+TcShF qVy/GD30nnL9wNlIk4JDdYo3/WpzwHhg0bbWrTPupverzMwwlQZHOVsj1yOaOeebuAcsgphqY tSLxJcv52RfWwN3+mkq66NH0e1n4exkRxI4g9rOv0PPD4f7cSOjmUOlr6aZyXfjyaWzKG8xZI Blg9KLWMtPhypVuof30H0qvmvH80ojvBbutpxlWm0sH2mEt4Hp0TRZjCso2whSpgooaDxJAIU H1/FWjEX1wXLorxqJL1FeN6shSXIlBvoajdMrw9wEuNwoAitrZPv8Yf2oCO7JrX4SbA7vT1jp 2ypChZZK+OFfYi8VlNcR8rJqCsOwLVJiGuP6d6pwdTR6Uhx40woiwPj9g/DtC305gUAL9xU2l iMdHTjd+kB8rECWccls+BhP19Twj+loGGx7ipe0HTMGAoCL2qx0bMlywb+I2i6WL/WQAp9yLP rbHZ4Tzwa8cQba9BroKrV6lgnRUhZNO6vu0KBbSH4+18Dg4EoftGciZl1GbD2fb1GRwY6WN8e 2XjFAEXADcm8BiOfPRSTkDcsLl7EW6wy4HQIdUNim7p4gLJ/8NT4VOFSVkHmBLfLSCi23vq8S 4C92ZNbIPuTGGQqkWXbyzirc7adMEqWJltFLC3Pkrxf4giJ1nS81B38AC5lNF3Pges8RV5mLW X4ulS4zy0PQoj4iSBHpJmy+a36IlbbwCRn94RGlVzirXJpOXotsL3UbsQ0GrF6KFuVH78ajjK zD58d6BC8g3SaUvFyj6bhW3u5IHTvXK0Ixuj8KwQpbUC8dLtCiuL5D11U0J0y8U5LAk06WPDi lNm47o2oJVt4BOarx3p/ZMl+lvSey/flPNxoKqD3pYeGnkIohfJ4AcZJxWgWrMgOzyvav4Xn8 w6mikXwtCXAKn++SaC/uRXZIwcdux7WLejWvtSW1NGaoegDGrO8+eQ8Px8lmruXWBJq8n46NB 8MYcySTPQTm/eXxJzp/N+cE2x30999il+D3dFC2e/IZjVP95A05ZT2WV/ajYz95BPJga7xY+5 88Mf55m75s/rDA8/J3DhF43PrwzhwbEgyvLlb4BSafc+fPrRD15rsMr6toAsb9S+NURk6FKzr gLzjI8y1R0KEfOA8MQqpMQZO9DGI0La1opfC7lw182WtOXzwn+xv22huCZoM7XU+P1jgyt4+W Dufl8DCSB4eUsy+jZdGRULwd2X30EaneZXeznOqrfB1bjagyfskFhxthM7xdFJL8GEg+MB1cq SXA8RRO3Fs9uEWpiOhyFdI2p3nPnwj3p6fqfh7PpPyV6iIoN6bvjpXxsy80n58qgQFxGiEpPi sJgBDNEPJBQdt/Cac6y5K2umF/lw6dus8UPFgE7d/XBF5tcA1nHte/FdroeMvlklCz4kJaGb9 oGYp66xMP6L1HO6IxC3JsWqWrX6+z8eYSl7wPXPQt8K6MKr3vvdrISd4F1B9hqcXmB153MHGt H8nTHJw9+oiTKLeNIXjIU85qxHuWAGerF9WEPM/RnFY0iM6L+sU62ppX0wqlUwvba65r8Ce7B MijwD8Hm2RPjFtu1xlqjwX1pn8o25Z6vu5JvbIvG3hcq5q7ewz/1ARA58nAMeEDO9KrLg39Zw Y8NvSB4WHIlL5J0mS829yQCj6CDtMea0prYvYcdCtaW+HF70ci6WE15WNfk5R5Jg+5Ong+0XM LbH0AV9PGjv6fTmeNfGSmUi0MzLZoDjmC5eTvj98ePyL0VeoKXGQ8ah26a6VzPAaiERy89xVb PXOF+0dH+sg0+vwSvHAj4HRCi9mSyq2ecWobhj/tgAdw0KZhhUewoduiMIqqOFroLetwr3ZAS qjouHSb7y31vk9GSg71vZ/iqoZnPzfRcOveBech0dbTcDRLYeAf7RmGFHM8hgtv35N39jFsA+ UdtOEisKAsCnFS/tOSvBIXpz5k2/TOsg0SC9gV6jXVc+inde3hnYH3RrSZpAaqSezrJJSqaEV n8fr2C1d2ZcTLE+HWCQ8wFy1tWwkpdP5/zk52sP3EepgKN1l7bBgcO8wGt+idjwo0j4/nuzO2 4DsosK7TIpvpTASWrRIEbrAOmDmv8h8G4oJP7dwSTPGdVTSs7ljl4LGAv9qT9yvaZLvjwtw4j 1ZwYDx6eMZ0A+ygtl4eku2ZHIjqseA0izqwT5ez4PKug2a6YdDbInkQYETUWISKyMU5ZKFANG 8p+y085hOc7fzDcNIsK2ue+6Du8x/6W2ksq6jTvgk+ot40UeCOhVkwH7vngftEoWE1RfeBWsf P0qwy7muEvjIdIj9dqNR 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 16:53:28 2026 Received: from mout.gmx.net (mout.gmx.net [212.227.15.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 317C43A641D; Fri, 16 Jan 2026 20:42:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.15.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596123; cv=none; b=lJiSJrO3ZzUzafM5R/++tgJrCTI/7+CWLOoygPD6MSLKoRPTAMYJi7v8fTJ8WO4ivdA1xsZCN86iDPCBXa5GEOpdrisuveenIDa/EE66rsIWWrEWvaFOqKwSgiQ4Y8orZszsk0o/jVHX8svihpvn1DOWNpOTGvzQ13/rhsVC7Nk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768596123; c=relaxed/simple; bh=8MWKvLKrIhwESL6K2lYU1hcXZLjKr62HLpiR+lptuBw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=UlzTOKhONzs0jdaHlqxcnDpckXtmiDFlELicPPjRwUL1XeaJpax1ewVu7aR/zzE084WvZtdxZtiJWGlZymfU31yFByKXL5CI2VFYnbCh4qFt2tuWv/rWbFZRVC+cBkgPHnYw/cXOrtS/NdPdeW0MUnSvgde4WPo75SN0fuJru7I= 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=aBu9qxsn; arc=none smtp.client-ip=212.227.15.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.de header.i=w_armin@gmx.de header.b="aBu9qxsn" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.de; s=s31663417; t=1768596110; x=1769200910; 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=aBu9qxsn5IjTtC7ya2WiLu/ryhPF7HdDfT62p74mDOONtcrBoyKPSIpyTDi5XHP3 UpYugPx+1p5gDFNO+uCqaCMbVV3MidX8jCccnrU95w9PX21RRKr+GGwcvD8g6m7Yd ixdawc1WD1/xmxS9wa6W+kPtcMv31ybEr3hticaDhLtP15BjUFBeEVYo9Nq1E3rvU Q5F7Q/KljYR2kTpU9m1jlAjYFJy18H10hZqNxncr8LiyFmC6SKq0EJQjHoK6U8z6+ vz+p3nuAMoMaEswwGHNdvVRg7BpoOw9C9qB+5vSWhXnv16HykpoC2ZzsuxVcGotkG i4aXSj0feV3db4jbhA== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from mx-amd-b650.fritz.box ([93.202.247.91]) by mail.gmx.net (mrgmx004 [212.227.17.190]) with ESMTPSA (Nemesis) id 1MNKhs-1vQzY732pG-00HtBN; Fri, 16 Jan 2026 21:41:49 +0100 From: Armin Wolf To: hansg@kernel.org, ilpo.jarvinen@linux.intel.com Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux@weissschuh.net, Dell.Client.Kernel@dell.com, corbet@lwn.net, linux-doc@vger.kernel.org Subject: [PATCH v4 9/9] platform/wmi: Update driver development guide Date: Fri, 16 Jan 2026 21:41:16 +0100 Message-Id: <20260116204116.4030-10-W_Armin@gmx.de> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20260116204116.4030-1-W_Armin@gmx.de> References: <20260116204116.4030-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:5wjcP1X1FAk2mc+M4yaDfBywVkchNoBYmgPtLLjTsMTeCSbzRbu cTWwBgNzWcyjDbfHi8XxnMror0zpjOIbGzZlJD0hLGRWZp9IC1wB/8jGkd+AuTUmwRIAwBJ 8skanJv8dDTC2F+GI0lhVan5TZVJy9p8H5ME4NWo+/9UPNZF9i32TMzEG5qxffx9xM/D91U Xa0VP+kYtZ8Iq7KggNjxQ== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:s1kxFnWhS5E=;MKg8QmCLqtvaeMuFZam3LkjFjw8 pjeXDOSPB+dCN+DwJdoBmMOL4Ta9fWNLU8yuV5LLjslnwpHBiFLePLB9RjCjQ+cpReNaUtTjq qtg11foaJnBVJNN//4ynP3FdLc4LF02lbEMq1pUhUVwa2diCAMjFabKLfCeAiFwVOpKPzquVM +MZsOZ0Gv2AKVZQ0k4WZocYESnO73RfaeXP4zf3pnquyKUZh3+tM8QUb/fqMHDhrSAsIenbq4 3Lydv0f7i0yu7r5TrMc/gHChvUdZ1ondSKDX6urIyMgXmOaLZ4GsMqQR433WUqCmJRKYNk7/r 1Zbm6chGvWHbK5lZbir5uhFofYDf7LVjxaXXxh5K0oKa3vU+1ob4VIKY+Z+BU0/KZOZOTwjRd cZeTscUfiriNrzcEODw4girF+V7QxgeqIdITSpX3YDNa9El0CNkaM0bTWYPO5vK9Ezhqli2CB yhHtlh0wIxsb9qNokc2pOKN967/OWk9gMpYqAxzNyWYyINSdPQLQXJmQwj9s/ghluj3K64z3n fP2azR5ueUmvJTlKdjBXXRdrTKUYKWXzjIh3QYztwJK+V2Iy1Z5CJarQ4vevNQ+j8Mm9IBJp6 oV/0EJzc0ljm2Rh+HtBiRtL4dyQTM3QNjkJ8KLEBZWMmeOXWWGqPw6tv5pde6gjXUAGB+gHtX mq8HgOUiyACSCr1XPnkyCKSms9ulTJv8D3UoLT7PRKUfl7jIKqqSb8sr9VFiRvRVxC8eQ19p8 ufyk18RNqNelb5G3uuMpsEUjH9TNSC7osURUpu5yhXDZunO3JE9d10g23Qti72YFVhDsxylsF jx+qUwQU6BHtUKJdlQ+ck8tev9b8mcwfkVgFSdc/PJRpf4/dUjx7rQ0jk+JdytpupIAOctqr9 k6nuPR5pdDJtiltpkY6hRIydpy2mWu58vJ+90RdUZKbnQcbDryl4tgf2r49vzrDZFo2bR6GhX 6sKsjipQ6e7/NSoq/j8PcjtEIDZRpqz02n0fvj8dzxg6GElbqTOIDopQ8q0dT7u8X8AjfU2wz v1IsX3rmdszBuEq57UIdJeuwnj0IQOYlyfh9QuDSy/Kas2QVCRAPrKp+PryL5PzAkAkZkwUMv qCxH6kcLXRFQ5faNtsMHcSJ6j5TMU6xBK52rPY+nRNbqYM+z/UlhKQzN5T6pY1U92sqBtfEO9 0HJdpL8kHMO1pydmCmNQjpzGT5+idcRdW1tlV5CfpnMRX1FInTEL3dKsHzN3PDrxECSWHWTGK l+x9Yec78GMkHbznig68bl6z0iR37+xmQcIQIoKbZJ6+BkIhls7wwc3OiAi8twlJi9JlnmOWE gC9mrRgkUgjSPveCC/xuSZ7DYXJA62GESyzCOAW7HE2H5vXt0R3BAz/WhcbidXSq7Whr18Oki FnjmTB0w3ot2PRurIQ63dH7gtwyrP8Er6Q+OChcEmbcmRfAYIW2Klp2HjOJvQhzWz5d77SMaP 7BnKeWshmfNw+Zho88OOde7mVltYiqP/drUWzAdYgwcERWk+VKJT4Eswm/QwW1rHmygNY0FJA 1Q41xaqsYBtYYNXq8JSrztqteUkP6jQziK5OWD+2WKcN3xouG8zuGIUpyjIDJo5mO3rXNAm2O KMaR7d+T0S0aaEHc2bvV5r9CfD3xeCTxDYWkxcld49DdlP9SV67qkLcVWu29c2xcFRCjZ4O+m Atm8/A2aN050wW9/AjXyH5bRswlWKoZdeEt7zgJZRC8BwMdNZLXaljx2DETagj2P+gS+CFS+Q 84AmkzX5zHHOwmwAUxFGvJlEDWYImxHVX4UeAynqPKrAkqs0DV4jbbeK+wCyQUhZ/5SCs9kUa y/TT+84MtK7rYaj4vFoJ+GOkPwX2TG7bKZvrsZAxrgRYG6OugYDxXR/H5j6j0ikH3Z4oWhcyh DfN2q0imTrL45iRTctikK90daMDhRZYzCmzwDCELqMqZNea5bMfVuoFt4DB/kj/ikVGgg5PUh hlTWYEA7mm4fp2VbI1R9lvIm1qkp+Xuf0AmFn6D3tSphhvRosVRAWfFHxKJuPsgWrbaVUbUbi ybAwwigy9SMYAN+A7SleIxKnGOeHtddBnl365PYBHUiz0p4cUzEOGpNSHTtdFe/LNTSeBcRXk Prm7r1yAOkulbj5P2ky9Nsjl997EVlf7ZjkjzwE2yP33vbWRhI76kW+9fPcucJPr0sH4nAsnX fchudtwFmjMRdghx/UU27Qk52gBq0pBY8wsX7npJBFBOpaKzmkh4kNYWzL2noM4rH0F9Y+Iwd G4gQaZ7b1758l0HPHL5pSwULo+iYfRwbrk7sbLKHZcoRoUf0RaYNoJJdGkq/9kDgCM6zr7ltE rvtNA9jLUfMYOcxP9ch+lcSL6oXPh+CkSRtlvcedd2GdfZOH4UMIZYAGyzxGcGy/Cr3byy38s F1TMba6AtsYGCxokaArQGSNe4B5rQYuHenXX24wjYmpIgtYxrHD3Z+NwppnXmaEkKtZUfkDE4 WDLPgL9vJW4xBXmT1Y68KUJVdbWmAj4rd0AUKtYub8BFS/vTXYqQ5xSMgVh/b8IuF5zF4dOIx jcF7zNGIJDgSCbeQdxsWjF0firSpa81XPkrEVwqEY0VsYSS+IM0K3ksR0fl35P2fbS1V5xjBC P2z83RRspe//rTPMv3WOe/ktO7fENdj5U71sCQkVtGx6TIljBUnYqX90sFoMmsP/mqMiJkopn 7vPV7ji2DBr0jG616kegXfD9DWapWeN3Gie3YqLGNfbAeSYtLawz6CoNMa16FOMZzOp82u7bm pLyWSsK3N2q0nqKpR80ZWu8zI/wCxxFK0TI6tEwu/8s/wMooi9d27hyon3jtM76fK8Qldr2Cr gd9YuC3HKNoYdos2uGRctgClH180Ae7pms8zZfBHlfoRogFFjqbfAjZh5iZIRlqO5vhWQISuS xsT+wpkeG4STBzdVNcP96HBFYW89oa6vn1zLyB+OUl95VF3rUjk8VRubNgVPs9pQC9E8VQ25H ACTUCiPcXppe4XpyKdCtel7WFFABnVDx9uejZ7Js8gAu89smQOWwOhIdk3E4DNqOvK1A+K+xy q5IAeLhjKUVUEwMVMq/0F3FiBthPprRxHxQ/MzNiGTRG/SoMXk6aA6fLr6BO3orx13VIbf/B1 qKhAjk4Yayx55D7zXvglWYjAA3hsaQwI+bNK5OyhZfsp1PWemcUD5neSXXn9BtCUFJTRQwWaV HC6c+be+UySMTZ6yceOHmNL2mIlX8fzHIuZvf9DZuohk4rEkaCfdXofkQYBFdKsRSqsxZCRs/ rLN1TRGxhN/blyHffhBh/4J1IyzNf4S2JGVF/dISEsq49FHIfFmUMI+H0zvskhMCpdVVRbpLw rwpF3YF0BMh/lOIB8XsRiyrHEooSdWgkFx9F1XR6JSPUQsviD8BaLuJjvpm8jVwKWD9ienoAn iellsxsiEv+CsmrVwXjflxoyzkkL9mbYsDBWriSfoitw3jQ1AJojVYBDk8zDJCAt9Ke77D+tm wuNNO1MnZe0s0pcwwVg4r198FKqPcpSCh1jkrvUhJe/USZuN4QlJufptvfs7JmyYFldqy2SJ1 +Uuwz54NsiGoSvyd8VtsaaT0fRZxM1z6CoMjzaIPmouxEVx51ZZSckryAOnchtY6HIk2yVuKV ef0OqT8XlAqJofHh5AP9tLa6nMoVuzLLCwDIyYYFQm3FCMObLxnWSfHrWbuZaFeZ8cpcKgkoC 0X2we2rGbFZQEuEI4HL3FQbjMEsHfcP0ZKxLI9Yf4igAq0qEpb+GsQcPGyXfuTcDA2L7qwNwq yG9/vBxkBpHhbC79ZUICYTVB8rUiPXIc65XTZcRn+5/pmyiKu15FJNov9SQFs++4TH97xDP1K BHqrdEtF2h/tcmQsnDi9Tb5IRIA3xiGRFMHWQzNPpbLjoUwhzBecP0r/dLIqI2TLBVjxwdu8D tsAnhyPE+sIHuqGDQZDgGgDjxMUl06KrdOEAM0Xot0H/olWzuofqIdeFQNhHr1GwfmmPoELHY uzmn4xRy87GIkCEWBeO9+LgxMAT0kBHKavvoAQOZkGkdprVHh/dl9zXAOsbEBC8FzxWWEEDGL uVgEtQr3UGW3sQIksdEnc+zeGLi0xmOrJ8rCoDrxvwVri0rxoHaCfAo+dJ0/qz9zzWtStIgl0 YAI4eXJ3M7j9YD2VpyZBkZ85W3R+xSUULxHYgMRfhqw4vdz5lZ+GBiKoo/VARMlxjArr6JrRn wVwJ7uctzeraeasBCRMI9zdKlnebfXI1CCH05/fF4xXfJ3hjX0vbrk1FWwKrHm/QXpEqr+Z30 K8pf8S0zVZ020n26XqncNikYOVsVLI4YebifrlamLkSJKXSRCFrbWHN+O12JmeAHvn0sDu3WV W7vBaMI9+ObY1NAVRYvcdQ54pFw01ldlPqq+dQLQO5FCMNcl7i39cVTqv4ar6FP4KTI1lDSUe +0R34CJ+olQINLBuyVQYPK1015HpOMHJZeQYJf4176FPhUQa0XPp8Ed2KFpnGTStK2iLwExG+ 1fehFBJ4Hpj2gTHDA5cxXe8nG46I7/41kPwX4QgNXpAxazOjY98Aftq+AvNdvyalmPJXHAzQS j0AYvFUxtvDoeBzTJlVaW3c0K1gGcJf2Przu4HjgwncLuoUMDQd+dhAP7MAZ2zPRa6niBsFC7 docWrufYcAk5bIoG0zoJeOp/hd0n1bivtEe/kTg+/D2BR88jTeftSZJLK9I4mBAQvImPb537q 1n8QSosxGojg1k7joWvd4wjE2mxEv54hrScJMFt7iNOxXuYBtpUYJuL2mDwgr6E0WDtH8eeFs iTK8OMQ0oiMXugbjgyB2EYAGV3c4RtLwOlf/1G9+qoS/aunRIKo1iNfKYRO7D+bx1wNOluLDt EVENP9+PhfYOtbLo94mBM1zeg24GqcOazYd2rfQQa1aEIJxLAW70w2an4VZQ4pviVWRHkXlJ+ ZwuZ3nyHMKvPj4cBUHzsVvFcDq3m2GOoybdZ6NaPCKN6FM/6Av8rG2tD01rOBv1HvquzSUQez IUnuoMX34GpGCVQU7QRB5q0Dw+K4AldPVF360z2x/xm8TC8c0fOCQRdEpdTvGDLOZTQxheHJi zXgTUeVXoPJ/fAWSIrWISEY8mKBQxWYu7Z5Is1Cz/1cdJSrlC2qLdhJGLYa3iJmnLOgKKKci3 fGBRMgs2DncsJLaOLqTbvqy93Lh3Up2ylxG1TgF22/lmiYwE/55sbTj0a4lTLDyoHYfnCB0/C 5g+mG5pBQXoameUQndewzoNb5OdiF 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