From nobody Sun Feb 8 00:07:31 2026 Received: from mail-pl1-f169.google.com (mail-pl1-f169.google.com [209.85.214.169]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 460B0280331; Thu, 10 Jul 2025 03:03:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116619; cv=none; b=ZRch+lsRCis3igwVg4Ew5XjId7DbxtxzZluy9hvw+alPyIpsvRPPpyGd2EKF4JIhNb1pCAfGRmO90I9Nt6cib6Fc3BRi2WEhB75nrPssN40BPPIvl8c2mAO9E9h/uJlZmK/s5EgSgnUU9FaHh14cZLCYZiYGBey/YN5fiR5TXv8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116619; c=relaxed/simple; bh=/Of205qSTw5BEk3XUtgxYmvs4j2+6Y0doOkNBCXxex0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=lD5U/+Lv8d+veUCKynlrQe60Td5+vSs+YIX7ccfI+7yHNNWqlCM2XDT09OPIIuKqYhfJ/2LEcaqP8LJykCuCFcsn4c1O9TdB8NTdaijhK3p1lmKo8yDQ8IE5HFboAnpYcnkQD/akprotyC6S5T09NmuGyHB4nR6rrRyipVDprLU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=K0jPwCn4; arc=none smtp.client-ip=209.85.214.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="K0jPwCn4" Received: by mail-pl1-f169.google.com with SMTP id d9443c01a7336-23dc5bcf49eso6844535ad.2; Wed, 09 Jul 2025 20:03:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1752116617; x=1752721417; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=VsDUV4/CFH2slluapL1u11vdrU9pFMok3uSswnLBT6U=; b=K0jPwCn4Px7jbkfGjqpMGMa/Lmx7a/rLPzlCNYGwbBSlMPfH8f8qwUmVn3501fMw8w RT/+Ku0/D0C/cEtNjGgtkFg7Ss3KUJFIyT836+hLf3s6HxjOhv3tHWZByhPsPHzPqnNv iuFA2qkuuSFEiRTkbC4NGTg2+icDPKgDLZnTop1kdsf+75FvhwPRV9/SCIIEB4UhvTlo 7PDHsje1Ndsi9NdPS+EPbOXjShWF7FR+XOuG2XHxRQJNkbel3VvFbLB2DYC4s84CjChS TOUpKI8NpXrkNXXPLmRv93O/bpeiekfB0axtfTDKYWv75Sx3sxs4lbAjvkpm1ihYbD1G Cmdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752116617; x=1752721417; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=VsDUV4/CFH2slluapL1u11vdrU9pFMok3uSswnLBT6U=; b=UuLEG/g/Hn5LZcRXggL4uY8vZAtjr4qh3m/NLNfhPvu510VJtoArd0kF8QV9uBUI3N DYRGpHvA6+3cVMndcmLwgANhiiYR7dnDzltDUuX4rPmiDAit5z81FVI4SS5gC8sR8B9L UfhDQYzTAH5l/q86uJxK4kyRDfnIYaJOwJvlKsP9ycQbLmF5WUPB7umES8vvfzBvBaRh GGNoob6/RoZ1BrzBCBa7/HCxGP6/PTJoTY4yK91QhQTO3k//EKmhI2dofu53COqMsMy7 ohhSypQfqFDFWrAzHtUqwd9eDc6DUAj/NoL2BGwmW4SiE/qvpCXhaFafz2rrozZ25rMH 9e5g== X-Forwarded-Encrypted: i=1; AJvYcCUS7BMb6sMlVWdnvOE0HrfnkSRolH5JRgv9dP/T5lClwXJg5BTIriP8kCj8l0Fo8FubHvM9XnzQKtJ6zjLFCNt3bhpChQ==@vger.kernel.org, AJvYcCXqjqtVk/IlcLJh3j/tsX9az7/wn/tdijwY09BPh/PEsKAj8SgSLPLie3BxxkyKIU8Ntv+M83SJA3iT9VQ=@vger.kernel.org X-Gm-Message-State: AOJu0YyflEa4FJ2ljPPZZ9uyzP9WtmpLrV+mdLXI1F3kyLXiWiuMkJ+N Bst0pw2kulG/7jcnPDHAlUlxDNXUo5Xy7Nkt3oDNPit5gtxwrAoonL63 X-Gm-Gg: ASbGncsy3dWlmfC3UR6Ry//4GQrRaw6o+IQLNjMArvTJWKgtioFUm1Ial0/6muKW7qD Tzvme4jWMqQxpHzbv63rnODGFGh/eeFzyoxwIqfmOzBHziaWNy76j7YHrJd4DFKnzpz+oheS2uN IBHCWqRA7F4kjUxTLQxaDFDzCo8AAKTtFJVFA91BaaQmbe2lXr2OT1tSSb22la4DXJ1Ameh/15z qhbL39TezMiTrPXC3VlKx1r4lGe0B64BOBsskCMh+C88KIu6PS6XPv2oSVRduyfS5nKYJTGne85 ge6e3dwJernwXSyDVXGmE7ElioovlM3ghvq3mZDlPuzMqvhQYnU4sNeuH23s2Q== X-Google-Smtp-Source: AGHT+IGYCAorwTlfZ1paAvwrRBTMiosysemlEeWjyBee3CI+tHla9fu+9A6yxY6ZB1wJBXT4czdSeA== X-Received: by 2002:a17:902:e807:b0:234:8c3d:2912 with SMTP id d9443c01a7336-23ddb1992famr68865135ad.11.1752116617421; Wed, 09 Jul 2025 20:03:37 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23de435b7e3sm6210445ad.224.2025.07.09.20.03.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Jul 2025 20:03:37 -0700 (PDT) From: Kurt Borja Date: Thu, 10 Jul 2025 00:03:16 -0300 Subject: [PATCH v6 1/6] platform/x86: firmware_attributes_class: Add device initialization methods Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250710-fw-attrs-api-v6-1-9959ef759771@gmail.com> References: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> In-Reply-To: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> To: =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello , Hans de Goede Cc: Alok Tiwari , Antheas Kapenekakis , "Derek J. Clark" , Prasanth Ksr , Jorge Lopez , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, Dell.Client.Kernel@dell.com, Kurt Borja X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=6404; i=kuurtb@gmail.com; h=from:subject:message-id; bh=i+PET9Gw9C+HdAtuKnNY2uOg2H8TvIGmw1iDyA/7OMU=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBn5ug0skW9YPq2X1fcTPlzwJ3tiYOfBO3J+rbkaha1xj 4qY/M53lLIwiHExyIopsrQnLPr2KCrvrd+B0Pswc1iZQIYwcHEKwER8Uhn+Jz37yNzaVLPf38zd 1fO9LUtszPljk1ljFP7XRf5s013byfA/Nrm8Y2nquTr2CwKuBR7V9744HNB0VlQykZ850V35Szo XAA== X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A From: Thomas Wei=C3=9Fschuh Currently each user of firmware_attributes_class has to manually set up kobjects, devices, etc. Provide this infrastructure out-of-the-box through the newly introduced fwat_device_register(). Reviewed-by: Mario Limonciello Signed-off-by: Thomas Wei=C3=9Fschuh Co-developed-by: Kurt Borja Signed-off-by: Kurt Borja --- drivers/platform/x86/firmware_attributes_class.c | 126 +++++++++++++++++++= ++++ drivers/platform/x86/firmware_attributes_class.h | 28 +++++ 2 files changed, 154 insertions(+) diff --git a/drivers/platform/x86/firmware_attributes_class.c b/drivers/pla= tform/x86/firmware_attributes_class.c index 736e96c186d9dc6d945517f090e9af903e93bbf4..084e66481a4a29bfd801d9e5bbb= 4067ac25b8437 100644 --- a/drivers/platform/x86/firmware_attributes_class.c +++ b/drivers/platform/x86/firmware_attributes_class.c @@ -2,7 +2,14 @@ =20 /* Firmware attributes class helper module */ =20 +#include +#include +#include +#include +#include #include +#include +#include #include "firmware_attributes_class.h" =20 const struct class firmware_attributes_class =3D { @@ -10,6 +17,123 @@ const struct class firmware_attributes_class =3D { }; EXPORT_SYMBOL_GPL(firmware_attributes_class); =20 +static void fwat_device_release(struct device *dev) +{ + struct fwat_device *fadev =3D to_fwat_device(dev); + + kfree(fadev); +} + +/** + * fwat_device_register - Create and register a firmware-attributes class + * device + * @parent: Parent device + * @name: Name of the class device + * @drvdata: Drvdata of the class device + * @groups: Extra groups for the "attributes" directory + * + * Return: pointer to the new fwat_device on success, ERR_PTR on failure + */ +struct fwat_device * +fwat_device_register(struct device *parent, const char *name, void *drvdat= a, + const struct attribute_group **groups) +{ + struct fwat_device *fadev; + int ret; + + if (!parent || !name) + return ERR_PTR(-EINVAL); + + fadev =3D kzalloc(sizeof(*fadev), GFP_KERNEL); + if (!fadev) + return ERR_PTR(-ENOMEM); + + fadev->groups =3D groups; + fadev->dev.class =3D &firmware_attributes_class; + fadev->dev.parent =3D parent; + fadev->dev.release =3D fwat_device_release; + dev_set_drvdata(&fadev->dev, drvdata); + ret =3D dev_set_name(&fadev->dev, "%s", name); + if (ret) { + kfree(fadev); + return ERR_PTR(ret); + } + ret =3D device_register(&fadev->dev); + if (ret) { + put_device(&fadev->dev); + return ERR_PTR(ret); + } + + fadev->attrs_kset =3D kset_create_and_add("attributes", NULL, &fadev->dev= .kobj); + if (!fadev->attrs_kset) { + ret =3D -ENOMEM; + goto out_device_unregister; + } + + ret =3D sysfs_create_groups(&fadev->attrs_kset->kobj, groups); + if (ret) + goto out_kset_unregister; + + return fadev; + +out_kset_unregister: + kset_unregister(fadev->attrs_kset); + +out_device_unregister: + device_unregister(&fadev->dev); + + return ERR_PTR(ret); +} +EXPORT_SYMBOL_GPL(fwat_device_register); + +void fwat_device_unregister(struct fwat_device *fadev) +{ + if (!fadev) + return; + + kset_unregister(fadev->attrs_kset); + device_unregister(&fadev->dev); +} +EXPORT_SYMBOL_GPL(fwat_device_unregister); + +static void devm_fwat_device_release(void *data) +{ + struct fwat_device *fadev =3D data; + + fwat_device_unregister(fadev); +} + +/** + * devm_fwat_device_register - Create and register a firmware-attributes c= lass + * device + * @parent: Parent device + * @name: Name of the class device + * @data: Drvdata of the class device + * @groups: Extra groups for the class device (Optional) + * + * Device managed version of fwat_device_register(). + * + * Return: pointer to the new fwat_device on success, ERR_PTR on failure + */ +struct fwat_device * +devm_fwat_device_register(struct device *parent, const char *name, void *d= ata, + const struct attribute_group **groups) +{ + struct fwat_device *fadev; + int ret; + + fadev =3D fwat_device_register(parent, name, data, groups); + if (IS_ERR(fadev)) + return fadev; + + ret =3D devm_add_action_or_reset(parent, devm_fwat_device_release, fadev); + if (ret) + return ERR_PTR(ret); + + return fadev; +} +EXPORT_SYMBOL_GPL(devm_fwat_device_register); + static __init int fw_attributes_class_init(void) { return class_register(&firmware_attributes_class); @@ -23,5 +147,7 @@ static __exit void fw_attributes_class_exit(void) module_exit(fw_attributes_class_exit); =20 MODULE_AUTHOR("Mark Pearson "); +MODULE_AUTHOR("Thomas Wei=C3=9Fschuh "); +MODULE_AUTHOR("Kurt Borja "); MODULE_DESCRIPTION("Firmware attributes class helper module"); MODULE_LICENSE("GPL"); diff --git a/drivers/platform/x86/firmware_attributes_class.h b/drivers/pla= tform/x86/firmware_attributes_class.h index d27abe54fcf9812a2f0868eec5426bbc8e7eb21c..048fd0904f767357ef856e687ec= 4cf3260016ec6 100644 --- a/drivers/platform/x86/firmware_attributes_class.h +++ b/drivers/platform/x86/firmware_attributes_class.h @@ -5,8 +5,36 @@ #ifndef FW_ATTR_CLASS_H #define FW_ATTR_CLASS_H =20 +#include +#include #include +#include +#include =20 extern const struct class firmware_attributes_class; =20 +/** + * struct fwat_device - The firmware-attributes device + * @dev: The class device. + * @attrs_kobj: The "attributes" root kobject. + * @groups: Sysfs groups attached to the @attrs_kobj. + */ +struct fwat_device { + struct device dev; + struct kset *attrs_kset; + const struct attribute_group **groups; +}; + +#define to_fwat_device(_d) container_of_const(_d, struct fwat_device, dev) + +struct fwat_device * __must_check +fwat_device_register(struct device *parent, const char *name, void *drvdat= a, + const struct attribute_group **groups); + +void fwat_device_unregister(struct fwat_device *fwadev); + +struct fwat_device * __must_check +devm_fwat_device_register(struct device *parent, const char *name, void *d= ata, + const struct attribute_group **groups); + #endif /* FW_ATTR_CLASS_H */ --=20 2.50.0 From nobody Sun Feb 8 00:07:31 2026 Received: from mail-pl1-f169.google.com (mail-pl1-f169.google.com [209.85.214.169]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AD72F28134F; Thu, 10 Jul 2025 03:03:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116625; cv=none; b=X4hxxPOGPu4BAD0mIYaA43U7QfbsjVU0tZ4ikyGvmezE4MyR0G+QjpBadVmGISeNVRl53FWGrw9T4dxssslvPce5aiS58k0otet1/65xGXi1Tmvpng2zS0akABhxeah4wKRpj3jaMvuEKdLhE/CVuSbj+am/epJxL3O4Orh3yhc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116625; c=relaxed/simple; bh=AKT2LCDF+mt9HhI7ZHod43bXodzBzmT8WJKy65Gt/cg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=LDBqpvakVvVPw2jkRTo55BHUMpajguyDQeWNYxDTtuoblwHpo5rd13+XIfuMALr6Nu8kC+NI5hqCvnbIclsI1LVbOQttaQ8nXbB2gArDhundWwd4UQqRJoG9bpiCPsHlj5FBW4WUUFO27l3sUTzkF3Re+B9zriJX5PNRkI0wgtQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=RXtcj8pA; arc=none smtp.client-ip=209.85.214.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="RXtcj8pA" Received: by mail-pl1-f169.google.com with SMTP id d9443c01a7336-23c8f179e1bso6847825ad.1; Wed, 09 Jul 2025 20:03:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1752116622; x=1752721422; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=YLNB2VQN0QIwvKWXIQ3RBnjDCQnpPMN2iAM9XzkcvG8=; b=RXtcj8pA+v38/cgpkvLhYu3aKqoUaCppHGwB5jwxGtdSaHqHLhVTiyUDrbXoVVlGkp 8yE91wvttlTHq3wcubh+GojK1OOBNV47N9zS5ZCQEkoJtiGLNGxNljUAivAPQU1juDBw zk2Pq1Om6TvFk8CR59BQbV4ZTxdpeuA+l9F7cY8UsXXf7S0M7PutDHcEDB5MG9QPXsDZ fpUYNe82wCN03hPLsz7K9dLgpOWhNtPNa2QK21pz2yKx5rjzBnDofC5bdazccSs9Nvda kufyf6480I/S/ww7pJ/7OGvtM6LyQOo765l0zSB4nbzUfuvDT3UlAD/nKh81H5ztzePK AiGw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752116622; x=1752721422; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=YLNB2VQN0QIwvKWXIQ3RBnjDCQnpPMN2iAM9XzkcvG8=; b=RE2di2LFHnCPkhDp40VTEF19N0QHboPuyHlC4YUbqaF17gnxBhz6pDIvGlK88KZHAC 4AmdLE3A5h9NdLOzRuUOqFcswzS6L6rZS/nufDnC9y3Qmqi5U4C0NV35+0Vlfw8wlj3x bRCOLzp5JFgTC2owgPPfLKT5xWa6sO3JAyyuj9RDJSgAEEZ12uPoe6b1wc3sgNj9EK/2 0B+STeNLE+7y356bTWRGisIllcJd4P2p3DWRWA8Pgsuqgj1H6ekb9SExI59wvOyOV915 98igSj4hu17+a5aQptIaq6fFVNeAuAbL6mLegI79EAnrmXqLZsRhO0bBniqegRD8h2YT x7Vg== X-Forwarded-Encrypted: i=1; AJvYcCUW3LmUXLB7k82/C4oaXovN1DIRTxNbVgcQyMBnCGZPeRHaSNIvUB8axVHCONW9N1uW3yyHkrsAw11GXos=@vger.kernel.org, AJvYcCUpdIhcvCr1T6kATP8jlNUKV2G0nwPqKcxHxJKpOtLlCSspXj1JRvQSLKMekVTsTPYpmTS8Nb3ZhuLpuJJjRc5QDZ1lAg==@vger.kernel.org X-Gm-Message-State: AOJu0YyekUzGjlSaBZwQxSOyastKIXZFMtfGgcgMFEq4FFL/zzZGkepf 94rg8xkIxkZz5e2XdFfZ5I4m/K98X9lv1FLco/z1n+aIW+N8UaxFQNmY X-Gm-Gg: ASbGncs9hKZaHELzp4rboaj27k8Yl5ggcdTqHtv+JCzJgyiw7QlqKBWQQZ/PkF9zvrn KUNeLeUdhMKQSO6CnYwIKehoSSKeQk4sPxQCV24KotfjeLzdxcQJfqwRqSJm1G81Ugf0zBjBLON vZLiveu0IuRNZFrL8yZMAOGSoTRW2n9pchsfLVxhV1en0eQHg1ZQDCVF35E5QjDx43rWIiRyHGx Za3s4awArcJWs43dDumNYW71t9cDuZaeBLIPw/BJ9NOKPleNZQdfsRXeLFXQkbyDCuhXn+QpFNT e4swlSBXy8v6Lziin48jlYdxTzDts1H/cRfoq2EeYRznO+5yXnMdUA7eOeXLcg6fx98+y76Z X-Google-Smtp-Source: AGHT+IE2LRDlUNKGSKsGJapoflmcyF0RL7B1H8D28gh0ZamXjLGu/FgFSGZnI//hIu5uiJKvG5DdDg== X-Received: by 2002:a17:903:8cd:b0:235:f4f7:a633 with SMTP id d9443c01a7336-23de4866a9fmr15730715ad.28.1752116621718; Wed, 09 Jul 2025 20:03:41 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23de435b7e3sm6210445ad.224.2025.07.09.20.03.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Jul 2025 20:03:41 -0700 (PDT) From: Kurt Borja Date: Thu, 10 Jul 2025 00:03:17 -0300 Subject: [PATCH v6 2/6] platform/x86: firmware_attributes_class: Add high level API for the attributes interface Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250710-fw-attrs-api-v6-2-9959ef759771@gmail.com> References: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> In-Reply-To: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> To: =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello , Hans de Goede Cc: Alok Tiwari , Antheas Kapenekakis , "Derek J. Clark" , Prasanth Ksr , Jorge Lopez , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, Dell.Client.Kernel@dell.com, Kurt Borja X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=30756; i=kuurtb@gmail.com; h=from:subject:message-id; bh=AKT2LCDF+mt9HhI7ZHod43bXodzBzmT8WJKy65Gt/cg=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBn5ug16S3zYryYv/OZyTWttsdGqLSpu6+WaHTa+vjKPb 9ZGrovPO0pZGMS4GGTFFFnaExZ9exSV99bvQOh9mDmsTCBDGLg4BWAi9v8Z/nCuYCh9+ubRhuUp K2of3FCVY+R7P91z7qlPXzjL36kI3Ktk+GeSHB663ve0SNzdMyrqpb3ybol2QklfH0jMzm9dplS whwsA X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A Add high level API to aid in the creation of attribute groups attached to the `attrs_kobj` (per ABI specification). This new API lets users configure each group, either statically or dynamically through a (per type) data struct and then create this group through the generic fwat_create_group() macro. Signed-off-by: Kurt Borja --- drivers/platform/x86/firmware_attributes_class.c | 539 +++++++++++++++++++= ++++ drivers/platform/x86/firmware_attributes_class.h | 329 ++++++++++++++ 2 files changed, 868 insertions(+) diff --git a/drivers/platform/x86/firmware_attributes_class.c b/drivers/pla= tform/x86/firmware_attributes_class.c index 084e66481a4a29bfd801d9e5bbb4067ac25b8437..40469586cbb4f011e3f03f6ccb8= dea643f319ab3 100644 --- a/drivers/platform/x86/firmware_attributes_class.c +++ b/drivers/platform/x86/firmware_attributes_class.c @@ -10,13 +10,65 @@ #include #include #include +#include #include "firmware_attributes_class.h" =20 +#define to_fwat_bool_data(_c) \ + container_of_const(_c, struct fwat_bool_data, group) +#define to_fwat_enum_data(_c) \ + container_of_const(_c, struct fwat_enum_data, group) +#define to_fwat_int_data(_c) \ + container_of_const(_c, struct fwat_int_data, group) +#define to_fwat_str_data(_c) \ + container_of_const(_c, struct fwat_str_data, group) + +#define __FWAT_ATTR(_name, _mode, _show, _store, _type) { \ + .attr =3D { .name =3D __stringify(_name), .mode =3D _mode }, \ + .show =3D _show, .store =3D _store, .type =3D _type, \ + } + +#define FWAT_ATTR_RO(_prefix, _name, _show, _type) \ + static struct fwat_attribute fwat_##_prefix##_##_name##_attr =3D \ + __FWAT_ATTR(_name, 0444, _show, NULL, _type) + +#define FWAT_GROUP_ATTR(_type, _mode, _name) \ + static struct fwat_attribute fwat_##_type##_##_name##_attr =3D \ + __FWAT_ATTR(_name, _mode, _type##_group_show, \ + _type##_group_store, fwat_##_type##_##_name) + +struct fwat_group { + const struct fwat_group_data *data; + struct device *dev; + struct kobject kobj; +}; + +#define kobj_to_fwat_group(_k) \ + container_of_const(_k, struct fwat_group, kobj) + +struct fwat_attribute { + struct attribute attr; + ssize_t (*show)(struct kobject *kobj, const struct fwat_attribute *attr, + char *buf); + ssize_t (*store)(struct kobject *kobj, const struct fwat_attribute *attr, + const char *buf, size_t count); + int type; +}; + +#define to_fwat_attribute(_a) \ + container_of_const(_a, struct fwat_attribute, attr) + const struct class firmware_attributes_class =3D { .name =3D "firmware-attributes", }; EXPORT_SYMBOL_GPL(firmware_attributes_class); =20 +static const char * const fwat_type_labels[] =3D { + [fwat_group_type_boolean] =3D "boolean", + [fwat_group_type_enumeration] =3D "enumeration", + [fwat_group_type_integer] =3D "integer", + [fwat_group_type_string] =3D "string", +}; + static void fwat_device_release(struct device *dev) { struct fwat_device *fadev =3D to_fwat_device(dev); @@ -24,6 +76,492 @@ static void fwat_device_release(struct device *dev) kfree(fadev); } =20 +static ssize_t +type_show(struct kobject *kobj, const struct fwat_attribute *attr, char *b= uf) +{ + return sysfs_emit(buf, "%s\n", fwat_type_labels[attr->type]); +} + +static ssize_t +display_name_show(struct kobject *kobj, const struct fwat_attribute *attr, + char *buf) +{ + struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const char *disp_name =3D group->data->display_name; + + if (!disp_name) + return -EOPNOTSUPP; + + return sysfs_emit(buf, "%s\n", disp_name); +} + +static ssize_t +display_name_language_code_show(struct kobject *kobj, const struct fwat_at= tribute *attr, + char *buf) +{ + struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const char *lang_code =3D group->data->language_code; + + if (!lang_code) + return -EOPNOTSUPP; + + return sysfs_emit(buf, "%s\n", lang_code); +} + +static ssize_t +bool_group_show(struct kobject *kobj, const struct fwat_attribute *attr, c= har *buf) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_bool_data *data =3D to_fwat_bool_data(group->data); + bool val; + int ret; + + /* show_override does not affect current_value */ + if (data->group.show_override && attr->type !=3D fwat_bool_current_value) + return data->group.show_override(group->dev, attr->type, buf); + + switch (attr->type) { + case fwat_bool_current_value: + ret =3D data->read(group->dev, data->group.id, &val); + if (ret < 0) + return ret; + break; + case fwat_bool_default_value: + val =3D data->default_val; + break; + default: + return -EOPNOTSUPP; + } + + return sysfs_emit(buf, "%s\n", str_yes_no(val)); +} + +static ssize_t +bool_group_store(struct kobject *kobj, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_bool_data *data =3D to_fwat_bool_data(group->data); + bool val; + int ret; + + ret =3D kstrtobool(buf, &val); + if (ret) + return ret; + + ret =3D data->write(group->dev, data->group.id, val); + if (ret) + return ret; + + return count; +} + +static ssize_t +enum_group_show(struct kobject *kobj, const struct fwat_attribute *attr, c= har *buf) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_enum_data *data =3D to_fwat_enum_data(group->data); + int val_idx, sz; + int ret; + + /* show_override does not affect current_value */ + if (data->group.show_override && attr->type !=3D fwat_enum_current_value) + return data->group.show_override(group->dev, attr->type, buf); + + switch (attr->type) { + case fwat_enum_current_value: + ret =3D data->read(group->dev, data->group.id, &val_idx); + if (ret < 0) + return ret; + break; + case fwat_enum_default_value: + val_idx =3D data->default_idx; + break; + case fwat_enum_possible_values: + if (!data->possible_vals || !data->possible_vals[0]) + return -EOPNOTSUPP; + + sz =3D sysfs_emit_at(buf, 0, "%s", data->possible_vals[0]); + for (unsigned int i =3D 1; data->possible_vals[i]; i++) + sz +=3D sysfs_emit_at(buf, sz, ";%s", data->possible_vals[i]); + sz +=3D sysfs_emit_at(buf, sz, "\n"); + + return sz; + default: + return -EOPNOTSUPP; + } + + return sysfs_emit(buf, "%s\n", data->possible_vals[val_idx]); +} + +static ssize_t +enum_group_store(struct kobject *kobj, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_enum_data *data =3D to_fwat_enum_data(group->data); + int val_idx; + int ret; + + val_idx =3D __sysfs_match_string(data->possible_vals, -1, buf); + if (val_idx < 0) + return val_idx; + + ret =3D data->write(group->dev, data->group.id, val_idx); + if (ret) + return ret; + + return count; +} + +static ssize_t +int_group_show(struct kobject *kobj, const struct fwat_attribute *attr, ch= ar *buf) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_int_data *data =3D to_fwat_int_data(group->data); + long val; + int ret; + + /* show_override does not affect current_value */ + if (data->group.show_override && attr->type !=3D fwat_int_current_value) + return data->group.show_override(group->dev, attr->type, buf); + + switch (attr->type) { + case fwat_int_current_value: + ret =3D data->read(group->dev, data->group.id, &val); + if (ret < 0) + return ret; + break; + case fwat_int_default_value: + val =3D data->default_val; + break; + case fwat_int_min_value: + val =3D data->min_val; + break; + case fwat_int_max_value: + val =3D data->max_val; + break; + case fwat_int_scalar_increment: + val =3D data->increment; + break; + default: + return -EOPNOTSUPP; + } + + return sysfs_emit(buf, "%ld\n", val); +} + +static ssize_t +int_group_store(struct kobject *kobj, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_int_data *data =3D to_fwat_int_data(group->data); + long val; + int ret; + + ret =3D kstrtol(buf, 0, &val); + if (ret) + return ret; + + ret =3D data->write(group->dev, data->group.id, val); + if (ret) + return ret; + + return count; +} + +static ssize_t +str_group_show(struct kobject *kobj, const struct fwat_attribute *attr, ch= ar *buf) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_str_data *data =3D to_fwat_str_data(group->data); + const char *val; + long len; + int ret; + + /* show_override does not affect current_value */ + if (data->group.show_override && attr->type !=3D fwat_str_current_value) + return data->group.show_override(group->dev, attr->type, buf); + + switch (attr->type) { + case fwat_str_current_value: + ret =3D data->read(group->dev, data->group.id, &val); + if (ret < 0) + return ret; + break; + case fwat_str_default_value: + val =3D data->default_val; + break; + case fwat_str_min_length: + len =3D data->min_len; + return sysfs_emit(buf, "%ld\n", len); + case fwat_str_max_length: + len =3D data->max_len; + return sysfs_emit(buf, "%ld\n", len); + default: + return -EOPNOTSUPP; + } + + return sysfs_emit(buf, "%s\n", val); +} + +static ssize_t +str_group_store(struct kobject *kobj, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_str_data *data =3D to_fwat_str_data(group->data); + int ret; + + ret =3D data->write(group->dev, data->group.id, buf); + if (ret) + return ret; + + return count; +} + +#define __FWAT_TYPE_NONE (-1) /* Dummy value, never evaluated. */ + +FWAT_ATTR_RO(all, display_name, display_name_show, __FWAT_TYPE_NONE); +FWAT_ATTR_RO(all, display_name_language_code, display_name_language_code_s= how, + __FWAT_TYPE_NONE); + +FWAT_ATTR_RO(bool, type, type_show, fwat_group_type_boolean); +FWAT_GROUP_ATTR(bool, 0644, current_value); +FWAT_GROUP_ATTR(bool, 0444, default_value); + +FWAT_ATTR_RO(enum, type, type_show, fwat_group_type_enumeration); +FWAT_GROUP_ATTR(enum, 0644, current_value); +FWAT_GROUP_ATTR(enum, 0444, default_value); +FWAT_GROUP_ATTR(enum, 0444, possible_values); + +FWAT_ATTR_RO(int, type, type_show, fwat_group_type_integer); +FWAT_GROUP_ATTR(int, 0644, current_value); +FWAT_GROUP_ATTR(int, 0444, default_value); +FWAT_GROUP_ATTR(int, 0444, min_value); +FWAT_GROUP_ATTR(int, 0444, max_value); +FWAT_GROUP_ATTR(int, 0444, scalar_increment); + +FWAT_ATTR_RO(str, type, type_show, fwat_group_type_string); +FWAT_GROUP_ATTR(str, 0644, current_value); +FWAT_GROUP_ATTR(str, 0444, default_value); +FWAT_GROUP_ATTR(str, 0444, min_length); +FWAT_GROUP_ATTR(str, 0444, max_length); + +static struct attribute *fwat_bool_attrs[] =3D { + &fwat_bool_type_attr.attr, + &fwat_all_display_name_attr.attr, + &fwat_all_display_name_language_code_attr.attr, + &fwat_bool_current_value_attr.attr, + &fwat_bool_default_value_attr.attr, + NULL +}; + +static struct attribute *fwat_enum_attrs[] =3D { + &fwat_enum_type_attr.attr, + &fwat_all_display_name_attr.attr, + &fwat_all_display_name_language_code_attr.attr, + &fwat_enum_current_value_attr.attr, + &fwat_enum_default_value_attr.attr, + &fwat_enum_possible_values_attr.attr, + NULL +}; + +static struct attribute *fwat_int_attrs[] =3D { + &fwat_int_type_attr.attr, + &fwat_all_display_name_attr.attr, + &fwat_all_display_name_language_code_attr.attr, + &fwat_int_current_value_attr.attr, + &fwat_int_default_value_attr.attr, + &fwat_int_min_value_attr.attr, + &fwat_int_max_value_attr.attr, + &fwat_int_scalar_increment_attr.attr, + NULL +}; + +static struct attribute *fwat_str_attrs[] =3D { + &fwat_str_type_attr.attr, + &fwat_all_display_name_attr.attr, + &fwat_all_display_name_language_code_attr.attr, + &fwat_str_current_value_attr.attr, + &fwat_str_default_value_attr.attr, + &fwat_str_min_length_attr.attr, + &fwat_str_max_length_attr.attr, + NULL +}; + +static_assert(fwat_bool_current_value =3D=3D 0); +static_assert(fwat_enum_current_value =3D=3D 0); +static_assert(fwat_int_current_value =3D=3D 0); +static_assert(fwat_str_current_value =3D=3D 0); + +static umode_t fwat_attr_visible(struct kobject *kobj, struct attribute *a= ttr, int n) +{ + const struct fwat_attribute *fwat_attr =3D to_fwat_attribute(attr); + const struct fwat_group *group =3D kobj_to_fwat_group(kobj); + const struct fwat_group_data *data =3D group->data; + + /* The `type` attribute is always first */ + if (n =3D=3D 0) + return attr->mode; + + if (attr =3D=3D &fwat_all_display_name_attr.attr) + return data->display_name ? attr->mode : 0; + + if (attr =3D=3D &fwat_all_display_name_language_code_attr.attr) + return data->language_code ? attr->mode : 0; + + if (!fwat_attr->type) + return data->mode; + + return test_bit(fwat_attr->type, &data->fattrs) ? attr->mode : 0; +} + +static const struct attribute_group fwat_bool_group =3D { + .attrs =3D fwat_bool_attrs, + .is_visible =3D fwat_attr_visible, +}; +__ATTRIBUTE_GROUPS(fwat_bool); + +static const struct attribute_group fwat_enum_group =3D { + .attrs =3D fwat_enum_attrs, + .is_visible =3D fwat_attr_visible, +}; +__ATTRIBUTE_GROUPS(fwat_enum); + +static const struct attribute_group fwat_int_group =3D { + .attrs =3D fwat_int_attrs, + .is_visible =3D fwat_attr_visible, +}; +__ATTRIBUTE_GROUPS(fwat_int); + +static const struct attribute_group fwat_str_group =3D { + .attrs =3D fwat_str_attrs, + .is_visible =3D fwat_attr_visible, +}; +__ATTRIBUTE_GROUPS(fwat_str); + +static ssize_t +fwat_attr_sysfs_show(struct kobject *kobj, struct attribute *attr, char *b= uf) +{ + const struct fwat_attribute *fwat_attr =3D to_fwat_attribute(attr); + + if (!fwat_attr->show) + return -EOPNOTSUPP; + + return fwat_attr->show(kobj, fwat_attr, buf); +} + +static ssize_t +fwat_attr_sysfs_store(struct kobject *kobj, struct attribute *attr, const = char *buf, + size_t count) +{ + const struct fwat_attribute *fwat_attr =3D to_fwat_attribute(attr); + + if (!fwat_attr->store) + return -EOPNOTSUPP; + + return fwat_attr->store(kobj, fwat_attr, buf, count); +} + +static void fwat_group_release(struct kobject *kobj) +{ + struct fwat_group *group =3D kobj_to_fwat_group(kobj); + + kfree(group); +} + +static const struct sysfs_ops fwat_attr_sysfs_ops =3D { + .show =3D fwat_attr_sysfs_show, + .store =3D fwat_attr_sysfs_store, +}; + +static const struct kobj_type fwat_boolean_ktype =3D { + .sysfs_ops =3D &fwat_attr_sysfs_ops, + .release =3D fwat_group_release, + .default_groups =3D fwat_bool_groups, +}; + +static const struct kobj_type fwat_enumeration_ktype =3D { + .sysfs_ops =3D &fwat_attr_sysfs_ops, + .release =3D fwat_group_release, + .default_groups =3D fwat_enum_groups, +}; + +static const struct kobj_type fwat_integer_ktype =3D { + .sysfs_ops =3D &fwat_attr_sysfs_ops, + .release =3D fwat_group_release, + .default_groups =3D fwat_int_groups, +}; + +static const struct kobj_type fwat_string_ktype =3D { + .sysfs_ops =3D &fwat_attr_sysfs_ops, + .release =3D fwat_group_release, + .default_groups =3D fwat_str_groups, +}; + +static int __fwat_create_group(struct fwat_device *fadev, const struct kob= j_type *ktype, + const struct fwat_group_data *data) +{ + struct fwat_group *group; + int ret; + + group =3D kzalloc(sizeof(*group), GFP_KERNEL); + if (!group) + return -ENOMEM; + + group->dev =3D &fadev->dev; + group->data =3D data; + + group->kobj.kset =3D fadev->attrs_kset; + ret =3D kobject_init_and_add(&group->kobj, ktype, NULL, "%s", data->name); + if (ret) { + kobject_put(&group->kobj); + return ret; + } + + kobject_uevent(&group->kobj, KOBJ_ADD); + + return 0; +} + +static void fwat_remove_auto_groups(struct fwat_device *fadev) +{ + struct kobject *pos, *n; + + list_for_each_entry_safe(pos, n, &fadev->attrs_kset->list, entry) + kobject_put(pos); +} + +int __fwat_create_bool_group(struct fwat_device *fadev, + const struct fwat_bool_data *data) +{ + return __fwat_create_group(fadev, &fwat_boolean_ktype, &data->group); +} +EXPORT_SYMBOL_GPL(__fwat_create_bool_group); + +int __fwat_create_enum_group(struct fwat_device *fadev, + const struct fwat_enum_data *data) +{ + return __fwat_create_group(fadev, &fwat_enumeration_ktype, &data->group); +} +EXPORT_SYMBOL_GPL(__fwat_create_enum_group); + +int __fwat_create_int_group(struct fwat_device *fadev, + const struct fwat_int_data *data) +{ + return __fwat_create_group(fadev, &fwat_integer_ktype, &data->group); +} +EXPORT_SYMBOL_GPL(__fwat_create_int_group); + +int __fwat_create_str_group(struct fwat_device *fadev, + const struct fwat_str_data *data) +{ + return __fwat_create_group(fadev, &fwat_string_ktype, &data->group); +} +EXPORT_SYMBOL_GPL(__fwat_create_str_group); + /** * fwat_device_register - Create and register a firmware-attributes class * device @@ -91,6 +629,7 @@ void fwat_device_unregister(struct fwat_device *fadev) if (!fadev) return; =20 + fwat_remove_auto_groups(fadev); kset_unregister(fadev->attrs_kset); device_unregister(&fadev->dev); } diff --git a/drivers/platform/x86/firmware_attributes_class.h b/drivers/pla= tform/x86/firmware_attributes_class.h index 048fd0904f767357ef856e687ec4cf3260016ec6..2af79d1d66fc83a9c1b8e564138= c8dfff67c9e78 100644 --- a/drivers/platform/x86/firmware_attributes_class.h +++ b/drivers/platform/x86/firmware_attributes_class.h @@ -27,6 +27,335 @@ struct fwat_device { =20 #define to_fwat_device(_d) container_of_const(_d, struct fwat_device, dev) =20 +enum fwat_group_type { + fwat_group_type_boolean, + fwat_group_type_enumeration, + fwat_group_type_integer, + fwat_group_type_string, +}; + +enum fwat_bool_attrs { + fwat_bool_current_value, + fwat_bool_default_value, + fwat_bool_attrs_last +}; + +#define FWAT_BOOL_CURRENT_VALUE BIT(fwat_bool_current_value) +#define FWAT_BOOL_DEFAULT_VALUE BIT(fwat_bool_default_value) +#define FWAT_BOOL_ALL_ATTRS GENMASK(fwat_bool_attrs_last, 0) + +enum fwat_enum_attrs { + fwat_enum_current_value, + fwat_enum_default_value, + fwat_enum_possible_values, + fwat_enum_attrs_last +}; + +#define FWAT_ENUM_CURRENT_VALUE BIT(fwat_enum_current_value) +#define FWAT_ENUM_DEFAULT_VALUE BIT(fwat_enum_default_value) +#define FWAT_ENUM_POSSIBLE_VALUES BIT(fwat_enum_possible_values) +#define FWAT_ENUM_ALL_ATTRS GENMASK(fwat_enum_attrs_last, 0) + +enum fwat_int_attrs { + fwat_int_current_value, + fwat_int_default_value, + fwat_int_min_value, + fwat_int_max_value, + fwat_int_scalar_increment, + fwat_int_attrs_last +}; + +#define FWAT_INT_CURRENT_VALUE BIT(fwat_int_current_value) +#define FWAT_INT_DEFAULT_VALUE BIT(fwat_int_default_value) +#define FWAT_INT_MIN_VALUE BIT(fwat_int_min_value) +#define FWAT_INT_MAX_VALUE BIT(fwat_int_max_value) +#define FWAT_INT_SCALAR_INCREMENT BIT(fwat_int_scalar_increment) +#define FWAT_INT_ALL_ATTRS GENMASK(fwat_int_attrs_last, 0) + +enum fwat_str_attrs { + fwat_str_current_value, + fwat_str_default_value, + fwat_str_min_length, + fwat_str_max_length, + fwat_str_attrs_last +}; + +#define FWAT_STR_CURRENT_VALUE BIT(fwat_str_current_value) +#define FWAT_STR_DEFAULT_VALUE BIT(fwat_str_default_value) +#define FWAT_STR_MIN_LENGTH BIT(fwat_str_min_length) +#define FWAT_STR_MAX_LENGTH BIT(fwat_str_max_length) +#define FWAT_STR_ALL_ATTRS GENMASK(fwat_str_attrs_last, 0) + +/** + * struct fwat_group_data - Data struct common between group types + * @id: Group ID defined by the user. + * @name: Name of the group. + * @display_name: Name shown in the display_name attribute. (Optional) + * @language_code: Language code shown in the display_name_language_code + * attribute. (Optional) + * @mode: Mode for the current_value attribute. All other attributes will = have + * 0444 permissions. + * @fattrs: Bitmap of selected attributes for this group type. + * @show_override: Custom show method for attributes in this group, except= for + * the current_value attribute, for which the a `read` callback + * will still be used. (Optional) + * + * NOTE: This struct is not meant to be defined directly. It is supposed t= o be + * embedded and defined as part of fwat_[type]_data structs. + */ +struct fwat_group_data { + long id; + umode_t mode; + const char *name; + const char *display_name; + const char *language_code; + unsigned long fattrs; + ssize_t (*show_override)(struct device *dev, int type, char *buf); +}; + +/** + * struct fwat_bool_data - Data struct for the boolean group type + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @default_val: Default value. + * @group: Group data. + */ +struct fwat_bool_data { + int (*read)(struct device *dev, long id, bool *val); + int (*write)(struct device *dev, long id, bool val); + bool default_val; + struct fwat_group_data group; +}; + +/** + * struct fwat_enum_data - Data struct for the enumeration group type + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @default_idx: Index of the default value in the @possible_vals array. + * @possible_vals: Array of possible value strings for this group type. + * @group: Group data. + * + * NOTE: The `val_idx` argument in the @write callback is guaranteed to be= a + * valid (within bounds) index. However, the user is in charge of wr= iting + * valid indexes to the `*val_idx` argument of the @read callback. + * Failing to do so may result in an OOB access. + */ +struct fwat_enum_data { + int (*read)(struct device *dev, long id, int *val_idx); + int (*write)(struct device *dev, long id, int val_idx); + int default_idx; + const char * const *possible_vals; + struct fwat_group_data group; +}; + +/** + * struct fwat_int_data - Data struct for the integer group type + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @default_val: Default value. + * @min_val: Minimum value. + * @max_val: Maximum value. + * @increment: Scalar increment for this value. + * @group: Group data. + * + * NOTE: The @min_val, @max_val, @increment constraints are merely informa= tive. + * These values are not enforced in any of the callbacks. + */ +struct fwat_int_data { + int (*read)(struct device *dev, long id, long *val); + int (*write)(struct device *dev, long id, long val); + long default_val; + long min_val; + long max_val; + long increment; + struct fwat_group_data group; +}; + +/** + * struct fwat_str_data - Data struct for the string group type + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @default_val: Default value. + * @min_len: Minimum string length. + * @max_len: Maximum string length. + * @group: Group data. + * + * NOTE: The @min_len, @max_len constraints are merely informative. These + * values are not enforced in any of the callbacks. + */ +struct fwat_str_data { + int (*read)(struct device *dev, long id, const char **buf); + int (*write)(struct device *dev, long id, const char *buf); + const char *default_val; + long min_len; + long max_len; + struct fwat_group_data group; +}; + +#define __FWAT_GROUP(_name, _disp_name, _mode, _fattrs) \ + { .name =3D __stringify(_name), .display_name =3D _disp_name, .mode =3D _= mode, .fattrs =3D _fattrs } + +/** + * DEFINE_FWAT_BOOL_GROUP - Convenience macro to quickly define a static + * struct fwat_bool_data instance + * @_name: Name of the group. + * @_disp_name: Name shown in the display_name attribute. (Optional) + * @_def_val: Default value. + * @_mode: Mode for the current_value attribute. All other attributes will= have + * 0444 permissions. + * @_fattrs: Bitmap of selected attributes for this group type. + * + * `read` and `write` callbacks are required to be already defined as + * `_name##_read` and `_name##_write` respectively. + */ +#define DEFINE_FWAT_BOOL_GROUP(_name, _disp_name, _def_val, _mode, _fattrs= ) \ + static const struct fwat_bool_data _name##_group_data =3D { \ + .read =3D _name##_read, \ + .write =3D _name##_write, \ + .default_val =3D _def_val, \ + .group =3D __FWAT_GROUP(_name, _disp_name, _mode, _fattrs), \ + } + +/** + * DEFINE_FWAT_ENUM_GROUP - Convenience macro to quickly define a static + * struct fwat_enum_data instance + * @_name: Name of the group. + * @_disp_name: Name shown in the display_name attribute. (Optional) + * @_def_idx: Index of the default value in the @_poss_vals array. + * @_poss_vals: Array of possible value strings for this group type. + * @_mode: Mode for the current_value attribute. All other attributes will= have + * 0444 permissions. + * @_fattrs: Bitmap of selected attributes for this group type. + * + * `read` and `write` callbacks are required to be already defined as + * `_name##_read` and `_name##_write` respectively. + * + * NOTE: The `val_idx` argument in the `write` callback is guaranteed to b= e a + * valid (within bounds) index. However, the user is in charge of wr= iting + * valid indexes to the `*val_idx` argument of the `read` callback. + * Failing to do so may result in an OOB access. + */ +#define DEFINE_FWAT_ENUM_GROUP(_name, _disp_name, _poss_vals, _def_idx, _m= ode, _fattrs) \ + static const struct fwat_enum_data _name##_group_data =3D { \ + .read =3D _name##_read, \ + .write =3D _name##_write, \ + .default_idx =3D _def_idx, \ + .possible_vals =3D _poss_vals, \ + .group =3D __FWAT_GROUP(_name, _disp_name, _mode, _fattrs), \ + } + +/** + * DEFINE_FWAT_INT_GROUP - Convenience macro to quickly define a static + * struct fwat_int_data instance + * @_name: Name of the group. + * @_disp_name: Name shown in the display_name attribute. (Optional) + * @_def_val: Default value. + * @_min: Minimum value. + * @_max: Maximum value. + * @_inc: Scalar increment for this value. + * @_mode: Mode for the current_value attribute. All other attributes will= have + * 0444 permissions. + * @_fattrs: Bitmap of selected attributes for this group type. + * + * `read` and `write` callbacks are required to be already defined as + * `_name##_read` and `_name##_write` respectively. + * + * NOTE: The @_min, @_max, @_inc constraints are merely informative. These + * values are not enforced in any of the callbacks. + */ +#define DEFINE_FWAT_INT_GROUP(_name, _disp_name, _def_val, _min, _max, _in= c, _mode, _fattrs) \ + static const struct fwat_int_data _name##_group_data =3D { \ + .read =3D _name##_read, \ + .write =3D _name##_write, \ + .default_val =3D _def_val, \ + .min_val =3D _min, \ + .max_val =3D _max, \ + .increment =3D _inc, \ + .group =3D __FWAT_GROUP(_name, _disp_name, _mode, _fattrs), \ + } + +/** + * DEFINE_FWAT_STR_GROUP - Convenience macro to quickly define a static + * struct fwat_str_data instance + * @_name: Name of the group. + * @_disp_name: Name shown in the display_name attribute. (Optional) + * @_def_val: Default value. + * @_min: Minimum string length. + * @_max: Maximum string length. + * @_mode: Mode for the current_value attribute. All other attributes will= have + * 0444 permissions. + * @_fattrs: Bitmap of selected attributes for this group type. + * + * `read` and `write` callbacks are required to be already defined as + * `_name##_read` and `_name##_write` respectively. + * + * NOTE: The @_min, @_max constraints are merely informative. These values= are + * not enforced in any of the callbacks. + */ +#define DEFINE_FWAT_STR_GROUP(_name, _disp_name, _def_val, _min, _max, _mo= de, _fattrs) \ + static const struct fwat_str_data _name##_group_data =3D { \ + .read =3D _name##_read, \ + .write =3D _name##_write, \ + .default_val =3D _def_val, \ + .min_len =3D _min, \ + .max_len =3D _max, \ + .group =3D __FWAT_GROUP(_name, _disp_name, _mode, _fattrs), \ + } + +int __fwat_create_bool_group(struct fwat_device *fadev, + const struct fwat_bool_data *data); +int __fwat_create_enum_group(struct fwat_device *fadev, + const struct fwat_enum_data *data); +int __fwat_create_int_group(struct fwat_device *fadev, + const struct fwat_int_data *data); +int __fwat_create_str_group(struct fwat_device *fadev, + const struct fwat_str_data *data); + +/** + * fwat_create_group - Convenience generic macro to create a group + * @_dev: fwat_device + * @_data: One of fwat_{bool,enum,int,str}_data instance + * + * This macro (and associated functions) creates a sysfs group under the + * 'attributes' directory, which is located in the class device root direc= tory. + * + * See Documentation/ABI/testing/sysfs-class-firmware-attributes for detai= ls. + * + * The @_data associated with this group may be created either statically, + * through DEFINE_FWAT_*_GROUP macros or dynamically, in which case the us= er + * would have allocate and fill the struct manually. The dynamic approach = should + * be preferred when group constraints and/or visibility is decided dynami= cally. + * + * Example: + * + * static int stat_read(...){...}; + * static int stat_write(...){...}; + * + * DEFINE_FWAT_(BOOL|ENUM|INT|STR)_GROUP(stat, ...); + * + * static int create_groups(struct fwat_device *fadev) + * { + * struct fwat_enum_data *dyn_group_data; + * + * dyn_group_data =3D kzalloc(...); + * // Fill the data + * ... + * fwat_create_group(fadev, &stat_group_data); + * fwat_create_group(fadev, &dyn_group_data); + * fwat_create_group(...); + * ... + * } + * + * Return: 0 on success, -errno on failure + */ +#define fwat_create_group(_dev, _data) \ + _Generic((_data), \ + const struct fwat_bool_data * : __fwat_create_bool_group, \ + const struct fwat_enum_data * : __fwat_create_enum_group, \ + const struct fwat_int_data * : __fwat_create_int_group, \ + const struct fwat_str_data * : __fwat_create_str_group) \ + (_dev, _data) + struct fwat_device * __must_check fwat_device_register(struct device *parent, const char *name, void *drvdat= a, const struct attribute_group **groups); --=20 2.50.0 From nobody Sun Feb 8 00:07:31 2026 Received: from mail-pl1-f170.google.com (mail-pl1-f170.google.com [209.85.214.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4D5AB28136B; Thu, 10 Jul 2025 03:03:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116627; cv=none; b=H8eOtH8kfqBdftFfqv9Oo96LVQhCmPA+rS36GOHv6nh462XAfRoQWNwwolRyganDutHHVAJumGebYjFwYuGyCXC1xAugV7dhUTabML/MmgpSe+EnaK/XRYI+gLEe4WUCaCz+48FN0gKasYVhwUPpdHfZnSISkaflbmZ5f8jD0A4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116627; c=relaxed/simple; bh=ky5/iLMIz44SuQ98wPexb2rrGVu1VL5cyqj6SKuU82A=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=PlgIu8ZrJC4PAXOfJQMythF7Vj1vE09797oZAa9nPMhZiNJFp8gJulbpSaNUB4l+s7CC1NlAxbJ+KCdOqWNRMXFjnAMi1ey7dzJTuQinPA4GUg3eFFd5CmB+NUdCtaDHaXk9XUQ9cRBHnAt01JaGNcmWd2cMUq9atPsFG+mKPQw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=EAMM2yVo; arc=none smtp.client-ip=209.85.214.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="EAMM2yVo" Received: by mail-pl1-f170.google.com with SMTP id d9443c01a7336-2350fc2591dso6214995ad.1; Wed, 09 Jul 2025 20:03:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1752116625; x=1752721425; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=oGodoOG+bYW+2GIlo1wVzxCJFs0nwimu7A6Wb3+W2mM=; b=EAMM2yVoripxU3SwORJBQrxG6XGcwJGu2pQV0NrYnECk6R5/4I2SCfHb8JUMP6u7Zc UQglbXYFZuZwNkbhHPhQovKqaDUXzIeeBFaYJ3VDw3Fb83ZxAtEFWyCZhYAICdjROCd8 QntnjgWX/q2WpOG3mp3NGkfvpo/QqMiTuEsaMU7lShrYHFwvZAcRAsGsGAaav6doVeDi 5q8Tq+VCI624MhwcWUtWgm7EyA3NbQpStncEQJm6r1wEH/nThE6vfEBrqwQVwJNfy0Iz YdCLgagCQPzytoRSBriMPzNW6UdbVHlKhMwdT4ALOJ94RynIH0tNZ4LIIo7mAM6c6xfW YQgw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752116625; x=1752721425; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=oGodoOG+bYW+2GIlo1wVzxCJFs0nwimu7A6Wb3+W2mM=; b=VJNpoA1876RNQ5kGhQcnVtaDwpxChKoOcpiCBGDpgmhQ80OiGLq/N693WTye0rjqcG TmFRqWgQn4pcaKbGRHnEaRXDyySCrDcSUpGU8evY8BiKYYBXdlLBEsU20tl0wpUkKjMR qvOLOen3mEbZXTPRj8Fn+ozxfxxDjtN9BeTnDEzgZHbX+F8XKkCv9jJELIi1Sqiyisw7 O1+lpl28y24FFdiUCAcdJZ14mogj0YNWFtSqNVTbLs584LQ0cfbJdqUfLrUJrEGPs95l 0VM3yRnbVS3Dg7X+nzII+YWs9PwaNU9lifv8qahxnouBhoNC60bNIiUvfgB4fKr9PJai 6nfg== X-Forwarded-Encrypted: i=1; AJvYcCXSHKMJlPNhWWt9cf/h6tsc3TkKwIeX6FLE6g+WUOStBWFJsMaIcoDAeq6dCMEUSCFnzvnJhm6DOj35nuk=@vger.kernel.org, AJvYcCXqVRp6rU3jImbcZGd6H8sFew7tW5QqPUdqMXzT7yovUZnIxU3/7pJ/btVYQVR1K3LOdOiL31XDryllnOinm1Z2E2ZeTA==@vger.kernel.org X-Gm-Message-State: AOJu0YwfDWVRHbFsun2SRWoiqD6vv+gtR46plR+K+j1kbCJ0Rm8miM03 bhBqCWUVoClrWwmw55f/WQZFkXs9VQxTmW5nYnCfp3Gi2qTOZhkyHe6t2mV2nACG X-Gm-Gg: ASbGnct329Rgeqtig7JOOqLsYdSfHdxQDVBpGHI03oV1IJ/WDjUdr3rYQkDJ5pIeITg 1CL1xCjxkEYZeZQjNnvFhOX41tO1D/qnjwr38Xbw7sh0x2vrvDAFf83xZvWO7vkWsuOi/bFb13/ HmdZ+D95xdg1dIRZwRM7Ve5DH6D1tDKSZJnDqQPVWe1URGPjBL9YkcDsPplHEY5q0IeEeLTQYaB ALfbBo8XDaYWSApWNa71RDoon129JLwvc65hNRI5YAdpE2FvWgtxw/G61WNClo3WA6q/FAfKNIm GPvJU81U3TTM168hladHnZkyWt7I6dd7DKfH34M6qSYGcwnM7899RoH1XbSBnA== X-Google-Smtp-Source: AGHT+IHuBcT0Gnfe/LXMeNdi6vm8Rp/f4BshHGaipdYX4SKVqcCTkcUAYpTfeQGD7AbysiYB72RvdA== X-Received: by 2002:a17:902:db0a:b0:234:11e2:f41 with SMTP id d9443c01a7336-23de2f45e12mr27161335ad.6.1752116625438; Wed, 09 Jul 2025 20:03:45 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23de435b7e3sm6210445ad.224.2025.07.09.20.03.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Jul 2025 20:03:45 -0700 (PDT) From: Kurt Borja Date: Thu, 10 Jul 2025 00:03:18 -0300 Subject: [PATCH v6 3/6] platform/x86: firmware_attributes_class: Move header to include directory Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250710-fw-attrs-api-v6-3-9959ef759771@gmail.com> References: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> In-Reply-To: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> To: =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello , Hans de Goede Cc: Alok Tiwari , Antheas Kapenekakis , "Derek J. Clark" , Prasanth Ksr , Jorge Lopez , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, Dell.Client.Kernel@dell.com, Kurt Borja X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=3771; i=kuurtb@gmail.com; h=from:subject:message-id; bh=ky5/iLMIz44SuQ98wPexb2rrGVu1VL5cyqj6SKuU82A=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBn5uo0Tcq/K3UyWfc9qleonEFHa/vzqtH9GgVFpv/oXb fdy0jjYUcrCIMbFICumyNKesOjbo6i8t34HQu/DzGFlAhnCwMUpABMxeM7wT69T9tf0De7eSapG PFMufzG/VJBr+mqvcx9nRvKDQtnTNxn+2f7WYlO0CH+2RPTr6t/+VcvYe7IfX+CbL7Jq42G3GZa ZfAA= X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A Move firmware_attributes_class.h to include/linux/ to avoid hardcoding paths inside drivers/platform/x86/. Signed-off-by: Kurt Borja --- drivers/platform/x86/dell/dell-wmi-sysman/sysman.c | 2 +- drivers/platform/x86/firmware_attributes_class.c | 2 +- drivers/platform/x86/hp/hp-bioscfg/bioscfg.c | 2 +- drivers/platform/x86/lenovo/think-lmi.c | 2 +- drivers/platform/x86/samsung-galaxybook.c | 2 +- {drivers/platform/x86 =3D> include/linux}/firmware_attributes_class.h | 0 6 files changed, 5 insertions(+), 5 deletions(-) diff --git a/drivers/platform/x86/dell/dell-wmi-sysman/sysman.c b/drivers/p= latform/x86/dell/dell-wmi-sysman/sysman.c index f5402b714657297e0ab4bb52a988fcc4c787a5fb..a93189f48dbb79aff39b4b1c254= c637dc8e8ef35 100644 --- a/drivers/platform/x86/dell/dell-wmi-sysman/sysman.c +++ b/drivers/platform/x86/dell/dell-wmi-sysman/sysman.c @@ -12,8 +12,8 @@ #include #include #include +#include #include "dell-wmi-sysman.h" -#include "../../firmware_attributes_class.h" =20 #define MAX_TYPES 4 #include diff --git a/drivers/platform/x86/firmware_attributes_class.c b/drivers/pla= tform/x86/firmware_attributes_class.c index 40469586cbb4f011e3f03f6ccb8dea643f319ab3..4652637de9bc279ef2030503efb= 18223fe64a657 100644 --- a/drivers/platform/x86/firmware_attributes_class.c +++ b/drivers/platform/x86/firmware_attributes_class.c @@ -11,7 +11,7 @@ #include #include #include -#include "firmware_attributes_class.h" +#include =20 #define to_fwat_bool_data(_c) \ container_of_const(_c, struct fwat_bool_data, group) diff --git a/drivers/platform/x86/hp/hp-bioscfg/bioscfg.c b/drivers/platfor= m/x86/hp/hp-bioscfg/bioscfg.c index 5bfa7159f5bcd57385a20fe9ac646597b320a378..c002f72b6ac083db8106e9bd044= e8a8fc1d3f310 100644 --- a/drivers/platform/x86/hp/hp-bioscfg/bioscfg.c +++ b/drivers/platform/x86/hp/hp-bioscfg/bioscfg.c @@ -12,7 +12,7 @@ #include #include #include "bioscfg.h" -#include "../../firmware_attributes_class.h" +#include #include #include =20 diff --git a/drivers/platform/x86/lenovo/think-lmi.c b/drivers/platform/x86= /lenovo/think-lmi.c index 0992b41b6221da77db2186f0ec8cda6c10a4f689..ecda54c26a6f01b77e061346ff8= d99ba657e4b56 100644 --- a/drivers/platform/x86/lenovo/think-lmi.c +++ b/drivers/platform/x86/lenovo/think-lmi.c @@ -20,7 +20,7 @@ #include #include #include -#include "../firmware_attributes_class.h" +#include #include "think-lmi.h" =20 static bool debug_support; diff --git a/drivers/platform/x86/samsung-galaxybook.c b/drivers/platform/x= 86/samsung-galaxybook.c index 3c13e13d488584300c9765132861be5c2aeca269..28046bb941c4b4947e10931690a= 290d80e909922 100644 --- a/drivers/platform/x86/samsung-galaxybook.c +++ b/drivers/platform/x86/samsung-galaxybook.c @@ -28,7 +28,7 @@ #include #include #include -#include "firmware_attributes_class.h" +#include =20 #define DRIVER_NAME "samsung-galaxybook" =20 diff --git a/drivers/platform/x86/firmware_attributes_class.h b/include/lin= ux/firmware_attributes_class.h similarity index 100% rename from drivers/platform/x86/firmware_attributes_class.h rename to include/linux/firmware_attributes_class.h --=20 2.50.0 From nobody Sun Feb 8 00:07:31 2026 Received: from mail-pg1-f176.google.com (mail-pg1-f176.google.com [209.85.215.176]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2AF52280A35; Thu, 10 Jul 2025 03:03:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116632; cv=none; b=CEdVtyV9ijMM3j123Vr6yZJEX9H5i3tBoATRpmW0WLP740nNWwO7WFcpou+D6dEejbdikxAwjYActsBPED1u6gnBIYvhXTDVx7fy0VqafslfzUIP1fFdo1OT74oGW1i77JBuDRqv8gzvCLWy1gPN0vNYT4qcfa7k8QqwqXwHg6o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116632; c=relaxed/simple; bh=+eGlPpSz/22hosbd6I5n15V9p9C3KYO8HuWq0pZwQi4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=hffdvxgks7FBp03vMDK837VO27cO7fAbhSQ5H2WCuYMEP/RKyLl4pDQ6lHKwuR1yDMgPNpZjmFT/B3M2xl19WohR4AFerRUUnDDt0Z6kkkCtxU4ZnoZJCgjUGaerL5Gg2Iw5SPIttLqsuAy/PUVoJayHmaOmI5ORxw7xBOQ9Q7k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=YvfLJv2/; arc=none smtp.client-ip=209.85.215.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="YvfLJv2/" Received: by mail-pg1-f176.google.com with SMTP id 41be03b00d2f7-b2c4331c50eso639080a12.3; Wed, 09 Jul 2025 20:03:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1752116629; x=1752721429; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=LT1B3LxqcRdENndxOMBVqMMI2dBsylEgkaBtYHfxrpY=; b=YvfLJv2/Ax+vt9Qc2C+lNYE4qDl3JEL73u4iWD6O/PlAIWfSuWW8lqDzrxqAOe8Sje NnXCBfVtUoV/J6DwDq2Iyvh8C/ERLXz4x8f+C2K/EVXWgypoH05p4vtQD8Y46wOqnRHl 3O0/+HFbyJMIALDSfgYuCmkTLESaej3g1yoA9DfJ6vFAoJv3o/L30K0v+bMAJIJAZyI4 lLn5jFFV/M4LYYX+3lhV4ZoBbNQeQfDHSgXZ+/BAgtisxE+ir5K58wMcDYGmJAN476mh Uj5fZC7Q1/gCP8XfNqvkMHkrOLVa9hJSccXNZ2Yu3wx6kvj8VGsKtnNkK3t8JCOPlGP8 e1Yg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752116629; x=1752721429; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=LT1B3LxqcRdENndxOMBVqMMI2dBsylEgkaBtYHfxrpY=; b=MB7VfGebg05LloVsbSRfjjtEWbnh5Z3UbKugQ9ULqyS85ODqWKv8g7nlXn/TePp/wl tDF3+n1f+bT1+1AgqYdcrPzcm4WyjVqUwCbFcTKEWE3+N8tdj+TXbbFWHT+0V4IH2aLC 1sNScGnLcGKzSXyGZgeJrTHd6NGqA2dBjFwxsbCe6JAnCP2sn1AvUtFSXDwyGDcT2qt6 FSetyzZ9ep3dQyya9zkdx/hmYd+YRhOhqKXFrKavn5EePMyZjSEH4dE4ctbkop6fZElR IxGdE7rHbl/q4KYzxIrBGudW1QHp/oMsXpCT+YqFTe8QvuODvHkQNXaPG9s0C/9fJCj3 hkaQ== X-Forwarded-Encrypted: i=1; AJvYcCUDtv/W2C3pClz0os45EmNPO4gjbNHqR2dleUThOjIPs19U/MIIviZS1ON2teIlQRW8yOxg3PYQDg98z4IfwjmySwviww==@vger.kernel.org, AJvYcCUS3HxWIotnkOhgl54XfhUskbji2NdQ1MR+uMWomx9d5kCCDh1DFngCDS/mIRdHtNcki6zJG3OeQbsLXfU=@vger.kernel.org X-Gm-Message-State: AOJu0YxxMsd3LQ+9pmKRdUeTNMycZJrOUNt1pIOSMtEF8vzBpRI1bxk4 1Y+4P4AAx1DjHT2ZHCHfirC2INj38hQWkOoo9raYlfaK92wUWEgA5kbX X-Gm-Gg: ASbGncsZkwF1g7K/sa4avs9hiXt6e36fejfjiUoFdhKo6Z3KKt6lWI6zd+2ChVJsZip P0ayI+ZbV/QeAMwNJHq1octtIv8UKN32KhQl4s2T03J4li21GQjXGmljFoqHB82aYz6PIcxfBLk bodpeuhKOfau8nYRhpjUlpHAVjON1GURNwAy4i8DV8xVWH59L6muyqp0zL8ypy6codknNI9rWKk WprGvvbytsOt+sLCjWWkf2W52gZhVnMcZIxe/U9qxwwcr0pX058l++8Espi7kEKME4GkiepRjZ1 Fp8Tmee4AvQEv64e4ci+efeiteyBpJtueijbtJWzUPJX2oCdUeuC8pf1cbHxSA== X-Google-Smtp-Source: AGHT+IELYEOcrgOB0gdyp0bTIBvv0CDzy59bXRt+yEf9zi7iswT+X1QH3lFi9wEqZBGVQJCNLJ4paA== X-Received: by 2002:a17:902:f70b:b0:23a:cba1:6662 with SMTP id d9443c01a7336-23ddb349bb9mr84020795ad.46.1752116629276; Wed, 09 Jul 2025 20:03:49 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23de435b7e3sm6210445ad.224.2025.07.09.20.03.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Jul 2025 20:03:48 -0700 (PDT) From: Kurt Borja Date: Thu, 10 Jul 2025 00:03:19 -0300 Subject: [PATCH v6 4/6] platform/x86: samsung-galaxybook: Transition new firmware_attributes API Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250710-fw-attrs-api-v6-4-9959ef759771@gmail.com> References: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> In-Reply-To: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> To: =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello , Hans de Goede Cc: Alok Tiwari , Antheas Kapenekakis , "Derek J. Clark" , Prasanth Ksr , Jorge Lopez , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, Dell.Client.Kernel@dell.com, Kurt Borja X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=11035; i=kuurtb@gmail.com; h=from:subject:message-id; bh=+eGlPpSz/22hosbd6I5n15V9p9C3KYO8HuWq0pZwQi4=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBn5uo2FqwPzJDwrnPJDgjSjJja42iWd5u4+OrF2m2ju1 lnVXHM7SlkYxLgYZMUUWdoTFn17FJX31u9A6H2YOaxMIEMYuDgFYCIX5zP8FZK3U5E+n+X4pDXb VN9nqkHSq8PtYoe4wjpMz9SIMKiVMfwP75oqfmzOAZVj8X3rZd4o2P7dU3e8YnudUOPTE62v1Tw YAQ== X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A Transition to new firmware_attributes API. Defining firmware_attributes groups statically through DEFINE_FWAT_ENUM_GROUP() incurs in a minor ABI change. In particular the display_name_language_code attribute is no longer created. Fortunately, this doesn't break user-space compatibility, because this attribute is not required, neither by the ABI specification nor by user-space tools. Signed-off-by: Kurt Borja --- drivers/platform/x86/samsung-galaxybook.c | 238 ++++++++------------------= ---- 1 file changed, 63 insertions(+), 175 deletions(-) diff --git a/drivers/platform/x86/samsung-galaxybook.c b/drivers/platform/x= 86/samsung-galaxybook.c index 28046bb941c4b4947e10931690a290d80e909922..0bf736c02a1870342a024507dd6= b9f6d8e7d0f82 100644 --- a/drivers/platform/x86/samsung-galaxybook.c +++ b/drivers/platform/x86/samsung-galaxybook.c @@ -36,8 +36,6 @@ struct samsung_galaxybook { struct platform_device *platform; struct acpi_device *acpi; =20 - struct device *fw_attrs_dev; - struct kset *fw_attrs_kset; /* block in case firmware attributes are updated in multiple threads */ struct mutex fw_attr_lock; =20 @@ -60,36 +58,6 @@ struct samsung_galaxybook { u8 profile_performance_modes[PLATFORM_PROFILE_LAST]; }; =20 -enum galaxybook_fw_attr_id { - GB_ATTR_POWER_ON_LID_OPEN, - GB_ATTR_USB_CHARGING, - GB_ATTR_BLOCK_RECORDING, -}; - -static const char * const galaxybook_fw_attr_name[] =3D { - [GB_ATTR_POWER_ON_LID_OPEN] =3D "power_on_lid_open", - [GB_ATTR_USB_CHARGING] =3D "usb_charging", - [GB_ATTR_BLOCK_RECORDING] =3D "block_recording", -}; - -static const char * const galaxybook_fw_attr_desc[] =3D { - [GB_ATTR_POWER_ON_LID_OPEN] =3D "Power On Lid Open", - [GB_ATTR_USB_CHARGING] =3D "USB Charging", - [GB_ATTR_BLOCK_RECORDING] =3D "Block Recording", -}; - -#define GB_ATTR_LANGUAGE_CODE "en_US.UTF-8" - -struct galaxybook_fw_attr { - struct samsung_galaxybook *galaxybook; - enum galaxybook_fw_attr_id fw_attr_id; - struct attribute_group attr_group; - struct kobj_attribute display_name; - struct kobj_attribute current_value; - int (*get_value)(struct samsung_galaxybook *galaxybook, bool *value); - int (*set_value)(struct samsung_galaxybook *galaxybook, const bool value); -}; - struct sawb { u16 safn; u16 sasb; @@ -908,150 +876,95 @@ static int galaxybook_block_recording_init(struct sa= msung_galaxybook *galaxybook =20 /* Firmware Attributes setup */ =20 -static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr= , char *buf) +static const char * const galaxybook_possible_vals[] =3D { + [false] =3D "0", [true] =3D "1", NULL +}; + +static int power_on_lid_open_read(struct device *dev, long id, int *val_id= x) { - return sysfs_emit(buf, "enumeration\n"); -} - -static struct kobj_attribute fw_attr_type =3D __ATTR_RO(type); - -static ssize_t default_value_show(struct kobject *kobj, struct kobj_attrib= ute *attr, char *buf) -{ - return sysfs_emit(buf, "0\n"); -} - -static struct kobj_attribute fw_attr_default_value =3D __ATTR_RO(default_v= alue); - -static ssize_t possible_values_show(struct kobject *kobj, struct kobj_attr= ibute *attr, char *buf) -{ - return sysfs_emit(buf, "0;1\n"); -} - -static struct kobj_attribute fw_attr_possible_values =3D __ATTR_RO(possibl= e_values); - -static ssize_t display_name_language_code_show(struct kobject *kobj, struc= t kobj_attribute *attr, - char *buf) -{ - return sysfs_emit(buf, "%s\n", GB_ATTR_LANGUAGE_CODE); -} - -static struct kobj_attribute fw_attr_display_name_language_code =3D - __ATTR_RO(display_name_language_code); - -static ssize_t display_name_show(struct kobject *kobj, struct kobj_attribu= te *attr, char *buf) -{ - struct galaxybook_fw_attr *fw_attr =3D - container_of(attr, struct galaxybook_fw_attr, display_name); - - return sysfs_emit(buf, "%s\n", galaxybook_fw_attr_desc[fw_attr->fw_attr_i= d]); -} - -static ssize_t current_value_show(struct kobject *kobj, struct kobj_attrib= ute *attr, char *buf) -{ - struct galaxybook_fw_attr *fw_attr =3D - container_of(attr, struct galaxybook_fw_attr, current_value); - bool value; + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + bool val; int err; =20 - err =3D fw_attr->get_value(fw_attr->galaxybook, &value); + err =3D power_on_lid_open_acpi_get(galaxybook, &val); if (err) return err; =20 - return sysfs_emit(buf, "%u\n", value); + *val_idx =3D val; + + return 0; } =20 -static ssize_t current_value_store(struct kobject *kobj, struct kobj_attri= bute *attr, - const char *buf, size_t count) +static int power_on_lid_open_write(struct device *dev, long id, int val_id= x) { - struct galaxybook_fw_attr *fw_attr =3D - container_of(attr, struct galaxybook_fw_attr, current_value); - struct samsung_galaxybook *galaxybook =3D fw_attr->galaxybook; - bool value; - int err; - - if (!count) - return -EINVAL; - - err =3D kstrtobool(buf, &value); - if (err) - return err; + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); =20 guard(mutex)(&galaxybook->fw_attr_lock); =20 - err =3D fw_attr->set_value(galaxybook, value); + return power_on_lid_open_acpi_set(galaxybook, val_idx ? true : false); +} + +DEFINE_FWAT_ENUM_GROUP(power_on_lid_open, "Power On Lid Open", galaxybook_= possible_vals, + false, 0644, FWAT_ENUM_ALL_ATTRS); + +static int usb_charging_read(struct device *dev, long id, int *val_idx) +{ + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + bool val; + int err; + + err =3D usb_charging_acpi_get(galaxybook, &val); if (err) return err; =20 - return count; + *val_idx =3D val; + + return 0; } =20 -#define NUM_FW_ATTR_ENUM_ATTRS 6 - -static int galaxybook_fw_attr_init(struct samsung_galaxybook *galaxybook, - const enum galaxybook_fw_attr_id fw_attr_id, - int (*get_value)(struct samsung_galaxybook *galaxybook, - bool *value), - int (*set_value)(struct samsung_galaxybook *galaxybook, - const bool value)) +static int usb_charging_write(struct device *dev, long id, int val_idx) { - struct galaxybook_fw_attr *fw_attr; - struct attribute **attrs; + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); =20 - fw_attr =3D devm_kzalloc(&galaxybook->platform->dev, sizeof(*fw_attr), GF= P_KERNEL); - if (!fw_attr) - return -ENOMEM; + guard(mutex)(&galaxybook->fw_attr_lock); =20 - attrs =3D devm_kcalloc(&galaxybook->platform->dev, NUM_FW_ATTR_ENUM_ATTRS= + 1, - sizeof(*attrs), GFP_KERNEL); - if (!attrs) - return -ENOMEM; - - attrs[0] =3D &fw_attr_type.attr; - attrs[1] =3D &fw_attr_default_value.attr; - attrs[2] =3D &fw_attr_possible_values.attr; - attrs[3] =3D &fw_attr_display_name_language_code.attr; - - sysfs_attr_init(&fw_attr->display_name.attr); - fw_attr->display_name.attr.name =3D "display_name"; - fw_attr->display_name.attr.mode =3D 0444; - fw_attr->display_name.show =3D display_name_show; - attrs[4] =3D &fw_attr->display_name.attr; - - sysfs_attr_init(&fw_attr->current_value.attr); - fw_attr->current_value.attr.name =3D "current_value"; - fw_attr->current_value.attr.mode =3D 0644; - fw_attr->current_value.show =3D current_value_show; - fw_attr->current_value.store =3D current_value_store; - attrs[5] =3D &fw_attr->current_value.attr; - - attrs[6] =3D NULL; - - fw_attr->galaxybook =3D galaxybook; - fw_attr->fw_attr_id =3D fw_attr_id; - fw_attr->attr_group.name =3D galaxybook_fw_attr_name[fw_attr_id]; - fw_attr->attr_group.attrs =3D attrs; - fw_attr->get_value =3D get_value; - fw_attr->set_value =3D set_value; - - return sysfs_create_group(&galaxybook->fw_attrs_kset->kobj, &fw_attr->att= r_group); + return usb_charging_acpi_set(galaxybook, val_idx ? true : false); } =20 -static void galaxybook_kset_unregister(void *data) +DEFINE_FWAT_ENUM_GROUP(usb_charging, "USB Charging", galaxybook_possible_v= als, + false, 0644, FWAT_ENUM_ALL_ATTRS); + +static int block_recording_read(struct device *dev, long id, int *val_idx) { - struct kset *kset =3D data; + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + bool val; + int err; =20 - kset_unregister(kset); + err =3D block_recording_acpi_get(galaxybook, &val); + if (err) + return err; + + *val_idx =3D val; + + return 0; } =20 -static void galaxybook_fw_attrs_dev_unregister(void *data) +static int block_recording_write(struct device *dev, long id, int val_idx) { - struct device *fw_attrs_dev =3D data; =20 - device_unregister(fw_attrs_dev); + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + + guard(mutex)(&galaxybook->fw_attr_lock); + + return block_recording_acpi_set(galaxybook, val_idx ? true : false); } =20 +DEFINE_FWAT_ENUM_GROUP(block_recording, "Block Recording", galaxybook_poss= ible_vals, + false, 0644, FWAT_ENUM_ALL_ATTRS); + static int galaxybook_fw_attrs_init(struct samsung_galaxybook *galaxybook) { + struct fwat_device *fdev; bool value; int err; =20 @@ -1059,42 +972,20 @@ static int galaxybook_fw_attrs_init(struct samsung_g= alaxybook *galaxybook) if (err) return err; =20 - galaxybook->fw_attrs_dev =3D device_create(&firmware_attributes_class, NU= LL, MKDEV(0, 0), - NULL, "%s", DRIVER_NAME); - if (IS_ERR(galaxybook->fw_attrs_dev)) - return PTR_ERR(galaxybook->fw_attrs_dev); - - err =3D devm_add_action_or_reset(&galaxybook->platform->dev, - galaxybook_fw_attrs_dev_unregister, - galaxybook->fw_attrs_dev); - if (err) - return err; - - galaxybook->fw_attrs_kset =3D kset_create_and_add("attributes", NULL, - &galaxybook->fw_attrs_dev->kobj); - if (!galaxybook->fw_attrs_kset) - return -ENOMEM; - err =3D devm_add_action_or_reset(&galaxybook->platform->dev, - galaxybook_kset_unregister, galaxybook->fw_attrs_kset); - if (err) - return err; + fdev =3D devm_fwat_device_register(&galaxybook->platform->dev, DRIVER_NAM= E, galaxybook, NULL); + if (IS_ERR(fdev)) + return PTR_ERR(fdev); =20 err =3D power_on_lid_open_acpi_get(galaxybook, &value); if (!err) { - err =3D galaxybook_fw_attr_init(galaxybook, - GB_ATTR_POWER_ON_LID_OPEN, - &power_on_lid_open_acpi_get, - &power_on_lid_open_acpi_set); + err =3D fwat_create_group(fdev, &power_on_lid_open_group_data); if (err) return err; } =20 err =3D usb_charging_acpi_get(galaxybook, &value); if (!err) { - err =3D galaxybook_fw_attr_init(galaxybook, - GB_ATTR_USB_CHARGING, - &usb_charging_acpi_get, - &usb_charging_acpi_set); + err =3D fwat_create_group(fdev, &usb_charging_group_data); if (err) return err; } @@ -1107,10 +998,7 @@ static int galaxybook_fw_attrs_init(struct samsung_ga= laxybook *galaxybook) =20 galaxybook->has_block_recording =3D true; =20 - return galaxybook_fw_attr_init(galaxybook, - GB_ATTR_BLOCK_RECORDING, - &block_recording_acpi_get, - &block_recording_acpi_set); + return fwat_create_group(fdev, &block_recording_group_data); } =20 /* --=20 2.50.0 From nobody Sun Feb 8 00:07:31 2026 Received: from mail-pl1-f181.google.com (mail-pl1-f181.google.com [209.85.214.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1006B283695; Thu, 10 Jul 2025 03:03:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116635; cv=none; b=TOD7vldCytBab8xD+pou+V5Isr9g96xDyGAD4IxnrBC9WDJRXXQfN77ocDij/1GiWBOXLrxmwa6bBwK6wkN08hMjoBLsy8W8pKuAQFoEY9Hlcu5edOIUY3LpIU9UyaCjUVlGKoZ8wJ7VN6hqw4oDV2n7OgUBwmiaZeiLyzvtGfo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116635; c=relaxed/simple; bh=PGzNmxKPeKeIW9y3SLrZgxUtNxszaOvcO3mqQbh5IU4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=EteYKou9hI1w4BI92xaG8YOAA0tlEn9kJQZ08Vxu0T61BfYlaeHDdjYffpIzyXXPTkQOoZD72Ss1TojE9n1Jx7DXf+E5TwwypqxJRup3SQpoNphyvK2G7luS8apZvBUCnqxXCewP9tnG9+jjJVUnonMhulomKIYKCOWfcyOJb9Q= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=GPJ5wft0; arc=none smtp.client-ip=209.85.214.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="GPJ5wft0" Received: by mail-pl1-f181.google.com with SMTP id d9443c01a7336-2353a2bc210so5678545ad.2; Wed, 09 Jul 2025 20:03:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1752116633; x=1752721433; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=SXIjFbe4Vrz2bi8rFlLHVCaoVK6EIDR/YQX7SQMy1sc=; b=GPJ5wft0REkbSF7FNu+GCQoXc4XNbCaX5gUQj7XSFxZbLY8tqhcNW/xG4gF8BjPvy2 n8lD/HL0jL76TqumMARvfDCHQgB+gpCDQ5Oo2oRD7GY5DMxZXkHZpZKZaWphXdtR3A94 MNcMQlYx9Hodk7dAj59YZbUt0lDFh/O7ticvXuzuWYO0efCdUuWfUfL1rK6lT0OLOpyG c4weeqRo17QSREKluKyslh1FBpSaA+0v3ioaPNMGosPjEazYian/abajHYUF1zgvh45v 8yq2Kl0Z3vhysoFpcp+d2OZEimhuA0UBBsKNAU2PK+5ieyOiB2KsMy443YQG056q+aL1 atmw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752116633; x=1752721433; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=SXIjFbe4Vrz2bi8rFlLHVCaoVK6EIDR/YQX7SQMy1sc=; b=VrqdsJUyxClLs23D482LhQ9kwdbXz1Ftfjfsl1hRue9l2eBRQpDnIPNsYy9WprXf8F HJ+owRGSRLeHlZxTGEx3zpEtgG8ergTj85Tzac2iXEWvwddLoAGuMG71qXCDPK8vV2sG suxEt/8PbhN6eApSlB2VEQVNhtnfQZvp37CoyMqmyEo0sVBkk9NDcUm6wd4w9kH20CZE KBfxmbvlMPyj9NbnrhT4LWAZAD5ibgrxdHVkve7sXDHGnCv57n/rv+y17rcTj+o7jCiB uu/V868BU0YdyWhC4x7cywa363fiv5TQEmVnT/DDmRH3LrQtZo69VYibJyS3EHOy8/9D xuKQ== X-Forwarded-Encrypted: i=1; AJvYcCV3yoXybAt2T72hkp6K7FkSfX8G7CEkaX4F1Y1IPRH7fVdzX0Y9tU+h2A5ky2avUGdtZhJe7sH9iTBognY=@vger.kernel.org, AJvYcCX7FeQC6sTkHAw7PdZgvmFBg0j2sntW/lExdrOqIGltNy0AhBIkiU/G9HpqpBuBmaIvol9Zuk06qKj0VaSiskODHu4Q/A==@vger.kernel.org X-Gm-Message-State: AOJu0YxcmYAAYDgru4CyIsh8Cc0EP95AcxQjQPherOiyQlyhx5HKB1tE nVKmwFUQ7YgoUDwk1qbRvAwIWR0ZYeueDiyBpgl0pZ1Sqca3IT/e2nOt X-Gm-Gg: ASbGnctCfUwS+qJSHQb6TnezmL12OiJ1DdWxlszthRHX1bYuoZnL8eEYJJMglpGhv7q 4phUwib3DHI8siAiNf1ebrW31k2ZTqX23/VLcozbOCtmhlSheZEC9qf0UEoAiGpWDKy7r0Qo9Vr DIIemB6oROF1FxSiWASnLyx/gOUJKVo9FLziSgh5qEOMUT38TRDKyuyRrdFE1Qri4Ll9CoNIU0b 1lJx5nlWd6LFuqzLfszwY6m3ek7DZ5NnAiMigu8L7qUDXcoe1KkahQ5RGBh9nvVBtEuhV0e/WYN 6vdH3j2QeLjbzvzXa+/9XmtGwV2q/QGXhHzYE1A4POp7oUqgw5RgHoRFGH5R4Q== X-Google-Smtp-Source: AGHT+IHrgD3VdqjJ19DTZubtWqeYSn6DUskkZ+P8TziZK0NPI1P9/RRwcb9bYSMrI5ZrSsAHwBf9Tg== X-Received: by 2002:a17:903:2448:b0:229:1619:ab58 with SMTP id d9443c01a7336-23de24f5a39mr37319685ad.43.1752116633351; Wed, 09 Jul 2025 20:03:53 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23de435b7e3sm6210445ad.224.2025.07.09.20.03.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Jul 2025 20:03:53 -0700 (PDT) From: Kurt Borja Date: Thu, 10 Jul 2025 00:03:20 -0300 Subject: [PATCH v6 5/6] Documentation: ABI: Update sysfs-class-firmware-attributes documentation Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250710-fw-attrs-api-v6-5-9959ef759771@gmail.com> References: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> In-Reply-To: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> To: =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello , Hans de Goede Cc: Alok Tiwari , Antheas Kapenekakis , "Derek J. Clark" , Prasanth Ksr , Jorge Lopez , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, Dell.Client.Kernel@dell.com, Kurt Borja X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=756; i=kuurtb@gmail.com; h=from:subject:message-id; bh=PGzNmxKPeKeIW9y3SLrZgxUtNxszaOvcO3mqQbh5IU4=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBn5uo1XZ0Xcf/KxTeHBPgnjfS23WUtncp1ob3potiLEV zEu5eyKjlIWBjEuBlkxRZb2hEXfHkXlvfU7EHofZg4rE8gQBi5OAZjI5V2MDFfEdTXt6vIelSUb 7tSve50nkWxzSOih3G51n2/BEXOe2DIyXLu5j9dJbovvM65O2blH0v4keD3+KMZ2JshcMLkskrm bDwA= X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A Add a simple boolean type. Signed-off-by: Kurt Borja --- Documentation/ABI/testing/sysfs-class-firmware-attributes | 1 + 1 file changed, 1 insertion(+) diff --git a/Documentation/ABI/testing/sysfs-class-firmware-attributes b/Do= cumentation/ABI/testing/sysfs-class-firmware-attributes index 2713efa509b465a39bf014180794bf487e5b42d6..64b8d5d49716e8387fee26e3e56= 910862f6a4f5c 100644 --- a/Documentation/ABI/testing/sysfs-class-firmware-attributes +++ b/Documentation/ABI/testing/sysfs-class-firmware-attributes @@ -18,6 +18,7 @@ Description: =20 The following are known types: =20 + - boolean - enumeration: a set of pre-defined valid values - integer: a range of numerical values - string --=20 2.50.0 From nobody Sun Feb 8 00:07:31 2026 Received: from mail-pl1-f172.google.com (mail-pl1-f172.google.com [209.85.214.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 02B4D283FE5; Thu, 10 Jul 2025 03:03:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116639; cv=none; b=nEsslaqZ+uBt4MfSZN675gQ2J9XDHNbkaigfoG2r8cGd8RfvXrjX2CAca9hdMhIX/HH9b28ggeMwvK4njCPsShyLhAWm1pB+yRl+PiKHdhH+IXhqrOD/3VkEoeFB6VwwkTMs5JhR6UfisEOE16kdzSnr/JwURc5wgxgMF6Zy/10= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752116639; c=relaxed/simple; bh=PFA+oHZQpzOnGYRE6dsJRrBUdbqwbvmreuJ/bqsngw8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Mh1+sOb4sAQ+iL9KrdhwrmCoeqe/6sgjBTlf1oIDyen4XiYy8O5b9Kr6whHfuCQVZW50MUwwta6fxto7ejXAlXrqirYulT8RvBXD6qJ83iqPFF+mJ4txwFvCmNqZE83lIolqijBcfTfAx0hQyp3FJ4jwU2HCuoAGneDXIW+b6gY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=AtrbzE89; arc=none smtp.client-ip=209.85.214.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="AtrbzE89" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-2366e5e4dbaso13740695ad.1; Wed, 09 Jul 2025 20:03:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1752116637; x=1752721437; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=6qzbm7XHfXh5ZmWOnzS98wjSUhwQBx3n0KIGDo+6oRk=; b=AtrbzE89bI9X8pGTniXXEMrkZz05dBN4nCdvIjUr/7WIXTvOulYE8qBA+WYeifZHdm TFOQCCpHFfLYyK8x9RYRtcWIekg4VUFzwdd03ccVqlCVY2dXsx5dk6zG77rkIZQLKTWh Y1RbZY4jCeilT+/XFMbmHx13SSpQe+MuDKqpddEv/Only0SnD2ah2NcDpq1/9oAFYs0U qW7b8K5wllrcF27oMZ2+AdgItlsKMdXYMvL7K8Yk6yOPUC4u4mINPiNyOiiou0adh2fL aZc+hObHejhawFW5CoszD5hTp20Gc51egBFHvDa5zuuBZQ2pKWPCYe0ysVmSCi0rMahI TMpQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752116637; x=1752721437; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=6qzbm7XHfXh5ZmWOnzS98wjSUhwQBx3n0KIGDo+6oRk=; b=MwTdELl6M0lItqfpYEpp5RaJN45LnH4TCKF4aOfsq24AOQBDZfgok2ec5LqGH1MExg ayV6o5lRxrz73kRtuxm/4ioq0EzqZnhJSh1/uMDAplDIarEA3lXIFXIhBe6dcf5wAg9U MCRgh/1GGRTvOP3t29C9Q3Ik0i0hcNcneAffdCrQLRRuBSXDn5GzuraNfk9IKuMaGzn9 gnHONCGpHuDRY2GGKR5weAcodPkf+MeL5nTnH/IblVDrpAPDVy71PLhoPz+czoc4D1VA okb/rz9miIe2LdRH7+bcIv9eGVl68LpY5w3HHjC0CYNIoJwjCn/HUvuBeD6RiGVqv/oS b0pA== X-Forwarded-Encrypted: i=1; AJvYcCVCzfYlryGm5+J6LazZCyJ5T6Y9iO5WvcRXplm3oX5ZtWwUmy+80wRsGjnrpav+6OHB7pYcyILN8K24qvz/HjAf8x1QOg==@vger.kernel.org, AJvYcCVYu746K0QltqHjOyXIw5QXygQlwt3wvbPlndDb3c9SN6tl0pr8hjXbT56pvBAe90S305SqmgfIF9XU7nA=@vger.kernel.org X-Gm-Message-State: AOJu0YxjsfjCZNRv02zXxNNnwxgPJ0M2PrlR5W1wk5XWUMSObqV55Sza g0b5Bh+JUv0HtsAwHfB0px0UU0oPRI40VqDE2wUnJYdjU0gfWnabIg0h X-Gm-Gg: ASbGncuA8we+DxfV7ro6uT8J4fkg+/lDlWo1PrbAcBPbjaTaOnpqkI5g/yOWgIls+Zg YMsTAtPXoVQGXXN5pefhJJtYRnqDvImJblxOUCRlmFoLwJij7Y01hQj1KhCo95inw+HKiGXxvUf OyUyB8dlTgsqrjQj877BKq5WkKvcRQRGUO458IsoJbvawWwBFVukGKmV8uEa6sZiLvvv8+H//Z3 ttwOrIBiURXAPiuIw2AcuLr3XijPas1W0CZNEuJ+uOP43shTFOjaTHv66C2i+cPnQOyWxks7nTH KCRztRLUw/X25SpP0dRyzC/EAIKnf58FgkR+xUXSZcJpJCBUvjf/Wbcox/I2cA== X-Google-Smtp-Source: AGHT+IGr0Mdzk8hxY3NE9aPkmRinUI9rqTo0avnUKCQKUGwayLo5mL4EWLpZE4YqruovjO0FOJckkg== X-Received: by 2002:a17:903:1a44:b0:234:b445:3f31 with SMTP id d9443c01a7336-23de2fe36b4mr26797485ad.17.1752116637312; Wed, 09 Jul 2025 20:03:57 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23de435b7e3sm6210445ad.224.2025.07.09.20.03.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Jul 2025 20:03:56 -0700 (PDT) From: Kurt Borja Date: Thu, 10 Jul 2025 00:03:21 -0300 Subject: [PATCH v6 6/6] MAINTAINERS: Add FIRMWARE ATTRIBUTES CLASS entry Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250710-fw-attrs-api-v6-6-9959ef759771@gmail.com> References: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> In-Reply-To: <20250710-fw-attrs-api-v6-0-9959ef759771@gmail.com> To: =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello , Hans de Goede Cc: Alok Tiwari , Antheas Kapenekakis , "Derek J. Clark" , Prasanth Ksr , Jorge Lopez , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, Dell.Client.Kernel@dell.com, Kurt Borja X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=875; i=kuurtb@gmail.com; h=from:subject:message-id; bh=PFA+oHZQpzOnGYRE6dsJRrBUdbqwbvmreuJ/bqsngw8=; b=kA0DAAoWFmBDOPSf1GYByyZiAGhvLYGgelkyhgpfp+r9OlAsJtx0nxEvOyzusZmvB4WEuYmZW 4h1BAAWCgAdFiEEh2Ci9uJabu1OwFXfFmBDOPSf1GYFAmhvLYEACgkQFmBDOPSf1GYMngEAucNy 2nlSwdi6QsA3aSz+XYaA3ovkxmgbL6g8uxs+PUIA/jIdePpxGhGO1QTNRwV3cadm57PlHMSV03C Gy81K+y0A X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A Add entry for the FIRMWARE ATTRIBUTES CLASS. Signed-off-by: Kurt Borja --- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 0a5309abba307992d4bf5b05ef8a65c839fb7606..9ef3dcadc2d6adfcdb683202668= 1691586c613ce 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9352,6 +9352,14 @@ F: include/linux/firewire.h F: include/uapi/linux/firewire*.h F: tools/firewire/ =20 +FIRMWARE ATTRIBUTES CLASS +M: Kurt Borja +L: platform-driver-x86@vger.kernel.org +S: Maintained +F: drivers/platform/x86/firmware_attributes_class.c +F: include/linux/firmware_attributes_class.h +K: (devm_)?fwat_device_(un)?register + FIRMWARE FRAMEWORK FOR ARMV8-A M: Sudeep Holla L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) --=20 2.50.0