From nobody Thu Oct 9 01:09:45 2025 Received: from mail-pf1-f176.google.com (mail-pf1-f176.google.com [209.85.210.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 263994C97; Sun, 22 Jun 2025 00:04:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550687; cv=none; b=icEQRU/23qacUAwTLNsBxU1wR20V3VedTv/SidOPq2+6dK1Sw1NdtPUGNzaEO7zzo5j6dAD1kt2VLgRD6teeA5t7LCOAmyeIGk5H8ikLsxq4JfXXbabpSgs4EXEr6jZk7lL+V1PMXRDqoBFp39XY64tkGmUALT/dZoBS64WApl4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550687; c=relaxed/simple; bh=DXyFUucMFonCOoKPXmmdpzv0Mx3fIW1WWsT7f2FzLDU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=hAUjnGwbAk1hS0Vm08s8MsCkGtaFDEDWxLKns7c8NtDollGh0Ni2/0pDljFqcf98t13oX4RdgXFMQE+Y7PVhq7/8tQCOpLDPv7fJT1bgrBKyOPHMKj7goQ157M5ThdaS7kP0ZD5xjBJPzEeu6Jlji678N/fQmFZcma8yTV+bxok= 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=MRaBLgSQ; arc=none smtp.client-ip=209.85.210.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="MRaBLgSQ" Received: by mail-pf1-f176.google.com with SMTP id d2e1a72fcca58-7426c44e014so2638195b3a.3; Sat, 21 Jun 2025 17:04:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750550685; x=1751155485; 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=DzQdUBlScYsXkw8H+z5lKEEFfhrtswPUm2kf4rvQK8I=; b=MRaBLgSQlf/f6tENcL8wQSESXdvc13zI61g6X5un4VSZG9hTNKqVQyez+dZeagjixd hcaRtYFSlC5UFPW622tA98bqlz/StRGlFPBaGs7QWFIgruTS4lvT97NcGOc6jnpvLsKd 16ddgnFXPn5W+mdaKgLzoOQkejmqT4KrRebFsad1yY7Ee6qNKotOw3xIJOBkDTyev/kh 0G/Y9FXrjSXLG7MIhMMTXZlU+uVDfto0626yFYhRsZ+7+j80nZdkWNNlZo6TR45JbOjH vVdrLNAhXM1gFmBgdz6Q+wdWIV7mUbpuAIWHtG1c8d00VHC8BsKvMEcbBCnN3cTZvEeS F6tQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750550685; x=1751155485; 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=DzQdUBlScYsXkw8H+z5lKEEFfhrtswPUm2kf4rvQK8I=; b=WLTDDQcwyUBxwCbIGzQ/4Jlo7VZDDpPh9jQXp4tPQdTvRzvTORvk6evXF5lZrFFhL3 jON6tutWjNbxtHYODqujDFwudfyMKHw8e3MCGuc0tMR9tGq3dYPo2dKUHN0GVpjdcoWO 2zOCTBaN/eN7NFT0v2xVpnpgLgWiFkqNck4L0+HmIkWupzWQHwGOsRIHZGMxkKyDtW9f ya+c6kyTjt3lUN56s6wy9muLJWwM/xx8DQxClo9J3gDmDAA+ElvMDgGrzvCJiIsDJWmK tMNxJFxo4irJ7dSdWoHxxeVR/Seze7+GqzS9+kJIsWX3A2z73F1xEGEVn1RWAf9A5mMW G4Ng== X-Forwarded-Encrypted: i=1; AJvYcCUk7QD5o+ryasyO59ODvS6OTnyl1b3oicGCiDSD4E5OcANchbUJR9ToQ9QhSwpPKIYq4n+opM5JAglAJaeDvH8Wc+QOvw==@vger.kernel.org, AJvYcCXc8o8+83+sMbYVbeTm0Kk2QlGPsyeTSnL9t2Eqcpg6tOxkExPukL4zfLIqbV/peWDjRsrmdPhYxiYSVRs=@vger.kernel.org X-Gm-Message-State: AOJu0Yw6HnD+8yv/yYK3ChV4cosilNd+ls+vh4I88O3ZKm1FGeEXRvsQ Pk8mJEPpiQmcfow5/xYEE4XG1AjKuQ12CWgn85m2A622nKUMm6zQ8+Vi2MlZuvIg X-Gm-Gg: ASbGncu8pEdK07Y4iStE4vXAWO+U6I+51sUJBdKWcY5VcydkWUwxY4+Y3jaFr8izxJN I4nvao6qKC9QLV0B3bA2BWXuiyqyQlJqT4phu6MMMLo3lBjuVHO2ATwTAMn/8TDK4+8wl4QjqSV 2dnT7h/Y5dgG4TAdKum5NtbuMT/LgDGGfP+4KwH7VoH9ZamkWu3TB4PKNCi50tdvevt9bIWiM99 f1BHjEPTw6nkafftWULNtXbasMB11FjMBD1K1ECcIIeErKIHxFpgHouBWWAgShK8Z3Zl3cONkKt BSdRX39tqU+jzMY1cJPSsZy3MCI/5iEcFWrQi/gaKvpku1zC0G7b5OdtJv8rEg== X-Google-Smtp-Source: AGHT+IGEd+F8VmPYtB07eTUhRT6mDvcuNsqwcgGnEYeMmojCiF2bIRcPwH83J1OL1PUkvUENUht6RA== X-Received: by 2002:a05:6a21:33a9:b0:1f5:80a3:b006 with SMTP id adf61e73a8af0-22026e47a3dmr11760134637.21.1750550685101; Sat, 21 Jun 2025 17:04:45 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7490a626326sm4941424b3a.75.2025.06.21.17.04.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Jun 2025 17:04:44 -0700 (PDT) From: Kurt Borja Date: Sat, 21 Jun 2025 21:04:04 -0300 Subject: [PATCH v3 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: <20250621-fw-attrs-api-v3-1-3dd55e463396@gmail.com> References: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> In-Reply-To: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> To: Hans de Goede , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello Cc: 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=7934; i=kuurtb@gmail.com; h=from:subject:message-id; bh=zizOHC0AlSPEm/Zzww0cbN6lQ5O2XQbDki5mm7XGl5A=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBnhHlOvbAhPKTnjbG5tXs15VYx1zc2Xz29xLXDQ2n1Jw Oeq6ew1HaUsDGJcDLJiiiztCYu+PYrKe+t3IPQ+zBxWJpAhDFycAjCRi+sZfrN7f7ZKs51hGsei LyjIsHlKoXXrGSEfq/qDnq+/3j+bXcbwh9dgWcov1m2ntn8qWhvvEn572fOUNnfzGxXT5to+Dsl nZgUA 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 | 162 +++++++++++++++++++= ++++ drivers/platform/x86/firmware_attributes_class.h | 44 ++++++ 2 files changed, 206 insertions(+) diff --git a/drivers/platform/x86/firmware_attributes_class.c b/drivers/pla= tform/x86/firmware_attributes_class.c index 736e96c186d9dc6d945517f090e9af903e93bbf4..27edb48636c8a91125b0a335411= ebafd9818630c 100644 --- a/drivers/platform/x86/firmware_attributes_class.c +++ b/drivers/platform/x86/firmware_attributes_class.c @@ -2,7 +2,13 @@ =20 /* Firmware attributes class helper module */ =20 +#include +#include +#include +#include #include +#include +#include #include "firmware_attributes_class.h" =20 const struct class firmware_attributes_class =3D { @@ -10,6 +16,160 @@ const struct class firmware_attributes_class =3D { }; EXPORT_SYMBOL_GPL(firmware_attributes_class); =20 +static ssize_t fwat_attrs_kobj_show(struct kobject *kobj, struct attribute= *attr, + char *buf) +{ + const struct fwat_attribute *fattr =3D to_fwat_attribute(attr); + struct fwat_device *fadev =3D to_fwat_device(kobj); + + if (!fattr->show) + return -ENOENT; + + return fattr->show(fadev->dev, fattr, buf); +} + +static ssize_t fwat_attrs_kobj_store(struct kobject *kobj, struct attribut= e *attr, + const char *buf, size_t count) +{ + const struct fwat_attribute *fattr =3D to_fwat_attribute(attr); + struct fwat_device *fadev =3D to_fwat_device(kobj); + + if (!fattr->store) + return -ENOENT; + + return fattr->store(fadev->dev, fattr, buf, count); +} + +static const struct sysfs_ops fwat_attrs_kobj_ops =3D { + .show =3D fwat_attrs_kobj_show, + .store =3D fwat_attrs_kobj_store, +}; + +static void fwat_attrs_kobj_release(struct kobject *kobj) +{ + struct fwat_device *fadev =3D to_fwat_device(kobj); + + kfree(fadev); +} + +static const struct kobj_type fwat_attrs_ktype =3D { + .sysfs_ops =3D &fwat_attrs_kobj_ops, + .release =3D fwat_attrs_kobj_release, +}; + +/** + * fwat_device_register - Create and register a firmware-attributes class + * device + * @parent: Parent device + * @name: Name of the class device + * @data: Drvdata of the class device + * @groups: Extra groups for the class device (Optional) + * + * 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 *data, + const struct attribute_group **groups) +{ + struct fwat_device *fadev; + struct device *dev; + int ret; + + if (!parent || !name) + return ERR_PTR(-EINVAL); + + fadev =3D kzalloc(sizeof(*fadev), GFP_KERNEL); + if (!fadev) + return ERR_PTR(-ENOMEM); + + dev =3D device_create(&firmware_attributes_class, parent, MKDEV(0, 0), + data, "%s", name); + if (IS_ERR(dev)) { + kfree(fadev); + return ERR_CAST(dev); + } + + ret =3D kobject_init_and_add(&fadev->attrs_kobj, &fwat_attrs_ktype, &dev-= >kobj, + "attributes"); + if (ret) + goto out_kobj_put; + + if (groups) { + ret =3D device_add_groups(dev, groups); + if (ret) + goto out_kobj_unregister; + } + + fadev->dev =3D dev; + fadev->groups =3D groups; + + kobject_uevent(&fadev->attrs_kobj, KOBJ_ADD); + + return fadev; + +out_kobj_unregister: + kobject_del(&fadev->attrs_kobj); + +out_kobj_put: + kobject_put(&fadev->attrs_kobj); + device_unregister(dev); + + return ERR_PTR(ret); +} +EXPORT_SYMBOL_GPL(fwat_device_register); + +void fwat_device_unregister(struct fwat_device *fadev) +{ + struct device *dev =3D fadev->dev; + + if (!fadev) + return; + + device_remove_groups(dev, fadev->groups); + kobject_del(&fadev->attrs_kobj); + kobject_put(&fadev->attrs_kobj); + device_unregister(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 +183,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..ad94bf91e5af30a2b8feb9abf22= 4ee6f0d17600a 100644 --- a/drivers/platform/x86/firmware_attributes_class.h +++ b/drivers/platform/x86/firmware_attributes_class.h @@ -5,8 +5,52 @@ #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 kobject attrs_kobj; + const struct attribute_group **groups; +}; + +#define to_fwat_device(_k) container_of_const(_k, struct fwat_device, attr= s_kobj) + +/** + * struct fwat_attribute - The firmware-attributes's custom attribute + * @attr: Embedded struct attribute. + * @show: Show method called by the "attributes" kobject's ktype. + * @store: Store method called by the "attributes" kobject's ktype. + */ +struct fwat_attribute { + struct attribute attr; + ssize_t (*show)(struct device *dev, const struct fwat_attribute *attr, + char *buf); + ssize_t (*store)(struct device *dev, const struct fwat_attribute *attr, + const char *buf, size_t count); +}; + +#define to_fwat_attribute(_a) container_of_const(_a, struct fwat_attribute= , attr) + +struct fwat_device * __must_check +fwat_device_register(struct device *parent, const char *name, void *data, + 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 Thu Oct 9 01:09:45 2025 Received: from mail-pf1-f171.google.com (mail-pf1-f171.google.com [209.85.210.171]) (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 D393C8F66; Sun, 22 Jun 2025 00:04:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550692; cv=none; b=EY4r86Qu0/ujQZsABvbWmEPX49CtHardfCMOeCOOEo/MKcpX+ZhW/0zITBLUH2VuZdeyAJx6HL43D5fPwLcXEN2Q0MK5g5rrZKtRaVPzcEfaF3/+wZobD5EQr65k6YAJOJVo5+NgUtM9hZgwFHotoHsbioZj0FfPw8VP/OD6tO8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550692; c=relaxed/simple; bh=EOxhodjuHtiKmkEMUox8ZZUATb824HNGZIyEw2W8pzw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=qVOA3ek5Fltk3EVtqx+K//aOKfuL9Y+X1P91icvu4eStjQ9YA603Saa969vo4GuCVA/RoQzBKCQv81sY9RVCABxHStzNPJzZbmCXuI/W8W21hajLys8ursLUDsrBqZKBLw0lTyqDNum+/JGm105xeF1rKD/63zHaW0jz9geriE0= 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=O0EYaq22; arc=none smtp.client-ip=209.85.210.171 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="O0EYaq22" Received: by mail-pf1-f171.google.com with SMTP id d2e1a72fcca58-7490cb9a892so1132777b3a.0; Sat, 21 Jun 2025 17:04:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750550689; x=1751155489; 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=psczNds0l29gY7n5y91wpugrv6OcsGiddH5j1nMGU+s=; b=O0EYaq22LjBaM5jShGs7g8hzU9fMehVmHyzsrobTHg0SSEOWhoCRWbyl25ZmXbom7S 94SRRe7t52g06IXzkqTXx7SujNxw9lYbpPPaKTAujo+I5HSnZY9zwhcvEY2N9sVg5VvQ 7X26MH8XNeq1t29Fa90ACDmmJ5rT6Q3bfyEOuIxY5rkkyD5rhKqgx8cEPb4qINR8IeQP LMI4AwQiwjWDm7skhmBBwIWGid5Duwdz20P3yONUVAVSN9Ua80Su6rz/tNdkA+ZIbcd1 SHDAuNMyD0V3oJ5IDxcEpKzqJuT2RCMA+MFlW2rvxOejgRJfoFdYlB375Bfw1iWjrPF5 Uytg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750550689; x=1751155489; 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=psczNds0l29gY7n5y91wpugrv6OcsGiddH5j1nMGU+s=; b=MHOP369SdSRaxluVjVbM6XUQhZH5ZpQP3xlPkXCW67OzZGIgG5/G2qHYnPZmCUfh3P OiJnONzbjIm3aqN9j7SAUTN0cnfeRC2mvBS3ed2TY2h3xDwsd3HhFnutd9+hk5sVf11L 2+Sj2zK9foSTT0I0wUtaiIq51criHrG4lnXdA/+h+ofxWyW4J0VppDlJXn9OEAdZ7b9Y g1QXYPZx15DCd235luaqeU1axoPKnMNjpXF/W+BKb41/EJQmstTwol2u1QcruFfylVU8 208mCB2PJcV4blTL//kQEADh61YPKpFhR+ujZc2xHllc3TgiAF0ttP1IKv/wekS07SHS dYcw== X-Forwarded-Encrypted: i=1; AJvYcCVOxXoGvzfjYIneh143sjhuCCuGFVt+HY8lrBgjWpuUfNHL7qLQELgC2m+QyIQpnTYjR8MG2VAc/kPuTQw=@vger.kernel.org, AJvYcCX5pild7ztkXAa5CHxjLbtmpvD8EN/r3Mu/KoPHPeA9ai68wCOi4bgpXfjWJ4Q3QRjiyR2d4pNCUrqxCOQS5g1yeaOetg==@vger.kernel.org X-Gm-Message-State: AOJu0Yxby4VVZvHIwerrCOE5ujh68jopZvJn57oNlCwEoEdOeaH+/BJ0 OTdkAwpuf+BZrM08WxYYnYle8FHht47v+AP13caDBPbeajWaRRK9+p9Q X-Gm-Gg: ASbGncv4Gw7nXv/5YmT/SN2m5GPX7VWgkuswL2KwhYrdhtVu8H7JBnWeCXMYMZ4tENQ WI72IaLO/qtpHiEtvJeiv6HPP9ZXoyQsBiq08N8mLEXnDj2zqE3nh1GM7pNp2D9qomPqGIyVXDF YERLxr46KSjL3MfZUr9efWNd9G5Diq+SS+jYOPRF8UQdFA4MlbZYrHgBZUSOF/LhIivhoJwHKw8 gt904Tw7BiV5uECJF2sak/uo5bqXToJdDK5b/Xlz9+iPQOACtBpP4V4RRDiL7AOs9X6wKjHqrJJ Hu4uFlnJk2GnjvLsjlj6KP8EXyA25pcZOKbRRkJJcoIjMFN9qcuVxoaW1qPCLRMXrDk7hkHn X-Google-Smtp-Source: AGHT+IFgY8b+tLodyVNMMY4yEqu97Wmh/mYwBaQshN9u0rBDFGNjph4J4RIyqywlU0B3qvY93Yyyww== X-Received: by 2002:a05:6a00:3d14:b0:740:9a4b:fb2a with SMTP id d2e1a72fcca58-7490daae7abmr10623053b3a.20.1750550689009; Sat, 21 Jun 2025 17:04:49 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7490a626326sm4941424b3a.75.2025.06.21.17.04.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Jun 2025 17:04:48 -0700 (PDT) From: Kurt Borja Date: Sat, 21 Jun 2025 21:04:05 -0300 Subject: [PATCH v3 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: <20250621-fw-attrs-api-v3-2-3dd55e463396@gmail.com> References: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> In-Reply-To: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> To: Hans de Goede , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello Cc: 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=28533; i=kuurtb@gmail.com; h=from:subject:message-id; bh=EOxhodjuHtiKmkEMUox8ZZUATb824HNGZIyEw2W8pzw=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBnhHlNdTJ6rBjCXqnA5XY337i9q23f8WHJKjclb86S1R mqv/uZ3lLIwiHExyIopsrQnLPr2KCrvrd+B0Pswc1iZQIYwcHEKwEQyhBkZ3j/Yp7P+zMRJTvND BHmckp8+DExL8fCx+7zEZfL3MxGS0owMs2zt5hpenbczTt94wvHK6G1BX9cGqW108lgnp1375OM dVgA= 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 | 453 +++++++++++++++++++= +++- drivers/platform/x86/firmware_attributes_class.h | 333 +++++++++++++++++ 2 files changed, 785 insertions(+), 1 deletion(-) diff --git a/drivers/platform/x86/firmware_attributes_class.c b/drivers/pla= tform/x86/firmware_attributes_class.c index 27edb48636c8a91125b0a335411ebafd9818630c..034f9254240b048f58c97c18062= db03f771f8139 100644 --- a/drivers/platform/x86/firmware_attributes_class.c +++ b/drivers/platform/x86/firmware_attributes_class.c @@ -9,13 +9,88 @@ #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) + +struct fwat_group { + struct attribute_group group; + struct list_head node; +}; + +struct fwat_group_config { + int type; + unsigned int total_attrs; + const char * const *attr_labels; + ssize_t (*show)(struct device *dev, const struct fwat_attribute *attr, + char *buf); + ssize_t (*store)(struct device *dev, const struct fwat_attribute *attr, + const char *buf, size_t count); +}; + +struct fwat_attribute_ext { + struct fwat_attribute fattr; + const struct fwat_group_data *data; + unsigned int type; +}; + +#define to_fwat_attribute_ext(_f) \ + container_of_const(_f, struct fwat_attribute_ext, fattr) + +#define fwat_attribute_ext_init(_name, _mode, _show, _store, _idx, _type, = _config) \ + ((struct fwat_attribute_ext){ \ + .fattr =3D __ATTR(_name, _mode, _show, _store), \ + .config =3D _config, \ + .idx =3D _idx, \ + .type =3D _type, \ + }) + 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_BOOLEAN] =3D "boolean", + [FWAT_GROUP_ENUMERATION] =3D "enumeration", + [FWAT_GROUP_INTEGER] =3D "integer", + [FWAT_GROUP_STRING] =3D "string", +}; + +static const char * const fwat_bool_labels[] =3D { + [fwat_bool_current_value] =3D "current_value", + [fwat_bool_default_value] =3D "default_value", +}; + +static const char * const fwat_enum_labels[] =3D { + [fwat_enum_current_value] =3D "current_value", + [fwat_enum_default_value] =3D "default_value", + [fwat_enum_possible_values] =3D "possible_values", +}; + +static const char * const fwat_int_labels[] =3D { + [fwat_int_current_value] =3D "current_value", + [fwat_int_default_value] =3D "default_value", + [fwat_int_min_value] =3D "min_value", + [fwat_int_max_value] =3D "max_value", + [fwat_int_scalar_increment] =3D "scalar_increment", +}; + +static const char * const fwat_str_labels[] =3D { + [fwat_str_current_value] =3D "current_value", + [fwat_str_default_value] =3D "default_value", + [fwat_str_min_length] =3D "min_length", + [fwat_str_max_length] =3D "max_length", +}; + static ssize_t fwat_attrs_kobj_show(struct kobject *kobj, struct attribute= *attr, char *buf) { @@ -57,6 +132,379 @@ static const struct kobj_type fwat_attrs_ktype =3D { .release =3D fwat_attrs_kobj_release, }; =20 +static ssize_t fwat_type_show(struct device *dev, const struct fwat_attrib= ute *attr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + + return sysfs_emit(buf, "%s\n", fwat_type_labels[ext->type]); +} + +static ssize_t +fwat_display_name_show(struct device *dev, const struct fwat_attribute *at= tr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_group_data *data =3D ext->data; + + if (!data->display_name) + return -EOPNOTSUPP; + + return sysfs_emit(buf, "%s\n", data->display_name); +} + +static ssize_t +fwat_language_code_show(struct device *dev, const struct fwat_attribute *a= ttr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_group_data *data =3D ext->data; + + if (!data->language_code) + return -EOPNOTSUPP; + + return sysfs_emit(buf, "%s\n", data->language_code); +} + +static ssize_t +boolean_group_show(struct device *dev, const struct fwat_attribute *attr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_bool_data *data =3D to_fwat_bool_data(ext->data); + bool val; + int ret; + + switch (ext->type) { + case fwat_bool_current_value: + ret =3D data->read(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 +enumeration_group_show(struct device *dev, const struct fwat_attribute *at= tr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_enum_data *data =3D to_fwat_enum_data(ext->data); + int val_idx, sz =3D 0; + int ret; + + switch (ext->type) { + case fwat_enum_current_value: + ret =3D data->read(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: + sz +=3D sysfs_emit_at(buf, sz, "%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 +integer_group_show(struct device *dev, const struct fwat_attribute *attr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_int_data *data =3D to_fwat_int_data(ext->data); + long val; + int ret; + + switch (ext->type) { + case fwat_int_current_value: + ret =3D data->read(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 +string_group_show(struct device *dev, const struct fwat_attribute *attr, + char *buf) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_str_data *data =3D to_fwat_str_data(ext->data); + const char *val; + long len; + int ret; + + switch (ext->type) { + case fwat_str_current_value: + ret =3D data->read(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 +boolean_group_store(struct device *dev, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_bool_data *data =3D to_fwat_bool_data(ext->data); + bool val; + int ret; + + ret =3D kstrtobool(buf, &val); + if (ret) + return ret; + + ret =3D data->write(dev, data->group.id, val); + if (ret) + return ret; + + return count; +} + +static ssize_t +enumeration_group_store(struct device *dev, const struct fwat_attribute *a= ttr, + const char *buf, size_t count) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_enum_data *data =3D to_fwat_enum_data(ext->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(dev, data->group.id, val_idx); + if (ret) + return ret; + + return count; +} + +static ssize_t +integer_group_store(struct device *dev, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_int_data *data =3D to_fwat_int_data(ext->data); + long val; + int ret; + + ret =3D kstrtol(buf, 0, &val); + if (ret) + return ret; + + ret =3D data->write(dev, data->group.id, val); + if (ret) + return ret; + + return count; +} + +static ssize_t +string_group_store(struct device *dev, const struct fwat_attribute *attr, + const char *buf, size_t count) +{ + const struct fwat_attribute_ext *ext =3D to_fwat_attribute_ext(attr); + const struct fwat_str_data *data =3D to_fwat_str_data(ext->data); + int ret; + + ret =3D data->write(dev, data->group.id, buf); + if (ret) + return ret; + + return count; +} + +static int fwat_add_group(struct fwat_device *fadev, const struct fwat_gro= up_data *data, + const struct fwat_group_config *config) +{ + struct fwat_attribute_ext *fattrs; + struct fwat_group *group; + struct attribute **attrs; + unsigned int bit, i =3D 0; + size_t nattrs; + int ret; + + nattrs =3D bitmap_weight(&data->fattrs, config->total_attrs); + if (data->display_name) + nattrs++; + if (data->language_code) + nattrs++; + + attrs =3D devm_kcalloc(fadev->dev, sizeof(*attrs), nattrs + 2, GFP_KERNEL= ); + if (!attrs) + return -ENOMEM; + fattrs =3D devm_kcalloc(fadev->dev, sizeof(*fattrs), nattrs + 1, GFP_KERN= EL); + if (!fattrs) + return -ENOMEM; + + fattrs[i].fattr.attr.name =3D "type"; + fattrs[i].fattr.attr.mode =3D 0444; + fattrs[i].fattr.show =3D fwat_type_show; + fattrs[i].data =3D data; + fattrs[i].type =3D config->type; + attrs[i] =3D &fattrs[i].fattr.attr; + i++; + + if (data->display_name) { + fattrs[i].fattr.attr.name =3D "display_name"; + fattrs[i].fattr.attr.mode =3D 0444; + fattrs[i].fattr.show =3D fwat_display_name_show; + fattrs[i].data =3D data; + fattrs[i].type =3D config->type; + attrs[i] =3D &fattrs[i].fattr.attr; + i++; + } + + if (data->language_code) { + fattrs[i].fattr.attr.name =3D "display_name_language_code"; + fattrs[i].fattr.attr.mode =3D 0444; + fattrs[i].fattr.show =3D fwat_language_code_show; + fattrs[i].data =3D data; + fattrs[i].type =3D config->type; + attrs[i] =3D &fattrs[i].fattr.attr; + i++; + } + + for_each_set_bit(bit, &data->fattrs, config->total_attrs) { + fattrs[i].fattr.attr.name =3D config->attr_labels[bit]; + /* current_value is always at bit 0 and uses data->mode */ + fattrs[i].fattr.attr.mode =3D bit ? 0444 : data->mode; + fattrs[i].fattr.show =3D config->show; + fattrs[i].fattr.store =3D config->store; + fattrs[i].data =3D data; + fattrs[i].type =3D bit; + attrs[i] =3D &fattrs[i].fattr.attr; + i++; + } + + group =3D devm_kzalloc(fadev->dev, sizeof(*group), GFP_KERNEL); + if (!group) + return -ENOMEM; + group->group.name =3D data->name; + group->group.attrs =3D attrs; + ret =3D sysfs_create_group(&fadev->attrs_kobj, &group->group); + if (ret) + return ret; + list_add(&group->node, &fadev->auto_groups); + + kobject_uevent(&fadev->attrs_kobj, KOBJ_CHANGE); + + return 0; +} + +static void fwat_remove_auto_groups(struct fwat_device *fadev) +{ + struct fwat_group *pos; + + list_for_each_entry(pos, &fadev->auto_groups, node) + sysfs_remove_group(&fadev->attrs_kobj, &pos->group); +} + +int fwat_create_bool_group(struct fwat_device *fadev, const struct fwat_bo= ol_data *data) +{ + struct fwat_group_config config =3D { + .type =3D FWAT_GROUP_BOOLEAN, + .total_attrs =3D fwat_bool_attrs_last, + .attr_labels =3D fwat_bool_labels, + .show =3D boolean_group_show, + .store =3D boolean_group_store, + }; + + return fwat_add_group(fadev, &data->group, &config); +} +EXPORT_SYMBOL_GPL(fwat_create_bool_group); + +int fwat_create_enum_group(struct fwat_device *fadev, const struct fwat_en= um_data *data) +{ + struct fwat_group_config config =3D { + .type =3D FWAT_GROUP_ENUMERATION, + .total_attrs =3D fwat_enum_attrs_last, + .attr_labels =3D fwat_enum_labels, + .show =3D enumeration_group_show, + .store =3D enumeration_group_store, + }; + + return fwat_add_group(fadev, &data->group, &config); +} +EXPORT_SYMBOL_GPL(fwat_create_enum_group); + +int fwat_create_int_group(struct fwat_device *fadev, const struct fwat_int= _data *data) +{ + struct fwat_group_config config =3D { + .type =3D FWAT_GROUP_INTEGER, + .total_attrs =3D fwat_int_attrs_last, + .attr_labels =3D fwat_int_labels, + .show =3D integer_group_show, + .store =3D integer_group_store, + }; + + return fwat_add_group(fadev, &data->group, &config); +} +EXPORT_SYMBOL_GPL(fwat_create_int_group); + +int fwat_create_str_group(struct fwat_device *fadev, const struct fwat_str= _data *data) +{ + struct fwat_group_config config =3D { + .type =3D FWAT_GROUP_STRING, + .total_attrs =3D fwat_str_attrs_last, + .attr_labels =3D fwat_str_labels, + .show =3D string_group_show, + .store =3D string_group_store, + }; + + return fwat_add_group(fadev, &data->group, &config); +} +EXPORT_SYMBOL_GPL(fwat_create_str_group); + /** * fwat_device_register - Create and register a firmware-attributes class * device @@ -102,6 +550,7 @@ fwat_device_register(struct device *parent, const char = *name, void *data, =20 fadev->dev =3D dev; fadev->groups =3D groups; + INIT_LIST_HEAD(&fadev->auto_groups); =20 kobject_uevent(&fadev->attrs_kobj, KOBJ_ADD); =20 @@ -120,11 +569,13 @@ EXPORT_SYMBOL_GPL(fwat_device_register); =20 void fwat_device_unregister(struct fwat_device *fadev) { - struct device *dev =3D fadev->dev; + struct device *dev; =20 if (!fadev) return; =20 + dev =3D fadev->dev; + fwat_remove_auto_groups(fadev); device_remove_groups(dev, fadev->groups); kobject_del(&fadev->attrs_kobj); kobject_put(&fadev->attrs_kobj); diff --git a/drivers/platform/x86/firmware_attributes_class.h b/drivers/pla= tform/x86/firmware_attributes_class.h index ad94bf91e5af30a2b8feb9abf224ee6f0d17600a..6b089e61cfb74c4bf1d196d374b= c6c271b14f211 100644 --- a/drivers/platform/x86/firmware_attributes_class.h +++ b/drivers/platform/x86/firmware_attributes_class.h @@ -10,6 +10,7 @@ #include #include #include +#include =20 extern const struct class firmware_attributes_class; =20 @@ -23,6 +24,7 @@ struct fwat_device { struct device *dev; struct kobject attrs_kobj; const struct attribute_group **groups; + struct list_head auto_groups; }; =20 #define to_fwat_device(_k) container_of_const(_k, struct fwat_device, attr= s_kobj) @@ -43,6 +45,337 @@ struct fwat_attribute { =20 #define to_fwat_attribute(_a) container_of_const(_a, struct fwat_attribute= , attr) =20 +enum fwat_group_type { + FWAT_GROUP_BOOLEAN, + FWAT_GROUP_ENUMERATION, + FWAT_GROUP_INTEGER, + FWAT_GROUP_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) + +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); + +/** + * struct fwat_group_data - Data struct common between group types + * @idx: Group ID defined by the user. + * @name: Name of the group. + * @display_name: Name showed in the display_name attribute. (Optional) + * @language_code: Language code showed in the display_name_language_code + * attribute. (Optional) + * @fattrs: Bitmap of selected attributes for this group type. + * @mode: Mode for the current_value attribute. All other attributes will = have + * 0444 permissions. + * + * 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; + const char *name; + const char *display_name; + const char *language_code; + unsigned long fattrs; + umode_t mode; +}; + +/** + * struct fwat_bool_data - Data struct for the boolean group type + * @default_val: Default value. + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @group: Group data. + */ +struct fwat_bool_data { + bool default_val; + int (*read)(struct device *dev, long id, bool *val); + int (*write)(struct device *dev, long id, bool val); + struct fwat_group_data group; +}; + +/** + * struct fwat_enum_data - Data struct for the enumeration group type + * @default_idx: Index of the default value in the @possible_vals array. + * @possible_vals: Array of possible value strings for this group type. + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @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 default_idx; + const char * const *possible_vals; + int (*read)(struct device *dev, long id, int *val_idx); + int (*write)(struct device *dev, long id, int val_idx); + struct fwat_group_data group; +}; + +/** + * struct fwat_int_data - Data struct for the integer group type + * @default_val: Default value. + * @min_val: Minimum value. + * @max_val: Maximum value. + * @increment: Scalar increment for this value. + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @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 { + long default_val; + long min_val; + long max_val; + long increment; + int (*read)(struct device *dev, long id, long *val); + int (*write)(struct device *dev, long id, long val); + struct fwat_group_data group; +}; + +/** + * struct fwat_str_data - Data struct for the string group type + * @default_val: Default value. + * @min_len: Minimum string length. + * @max_len: Maximum string length. + * @read: Read callback for the current_value attribute. + * @write: Write callback for the current_value attribute. + * @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 { + const char *default_val; + long min_len; + long max_len; + int (*read)(struct device *dev, long id, const char **val); + int (*write)(struct device *dev, long id, const char *val); + 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 an static + * struct fwat_bool_data instance + * @_name: Name of the group. + * @_disp_name: Name showed 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 an static + * struct fwat_enum_data instance + * @_name: Name of the group. + * @_disp_name: Name showed 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 an static + * struct fwat_int_data instance + * @_name: Name of the group. + * @_disp_name: Name showed 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 an static + * struct fwat_str_data instance + * @_name: Name of the group. + * @_disp_name: Name showed 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; + * int ret; + * ... + * 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 *data, const struct attribute_group **groups); --=20 2.50.0 From nobody Thu Oct 9 01:09:45 2025 Received: from mail-pf1-f177.google.com (mail-pf1-f177.google.com [209.85.210.177]) (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 8783C440C; Sun, 22 Jun 2025 00:04:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550695; cv=none; b=cj49lSevcA4QlTkGrAUmKMqghIOy+4110Jti4FAe0iRq2TUyt4SxLCF4SygrpxI+wDlKYXPEPedsS7q6R520zbjZbIUBtRDmxeNxX5/VrW/gKbLfGOfV+m6aE6K1UfHHHpqqyVaRvmF2VPbNMdUwTXMvGvH6RteNOkQMMeA1Ryw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550695; c=relaxed/simple; bh=Ev03nOhI3O2zIAdD5KACHNvxiZ5BFbf2hfuWHFiGuiY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=r7S+EMvyAE3yKlIWQxgKxHRY9Q4+Z6So++MKqwuBCBsee6Fk3aLoHZeLeFE/bhEDw+XTepA8u5s9BizDq04Fa16Q4602mZWDK/s75dMSene7kSKHNI0mmudBkFd7cp2+06alaXpne/x0hElEn+UlAnzUlsh0nUdT+hLG7BidplE= 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=gcf4RjI6; arc=none smtp.client-ip=209.85.210.177 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="gcf4RjI6" Received: by mail-pf1-f177.google.com with SMTP id d2e1a72fcca58-74931666cbcso237907b3a.0; Sat, 21 Jun 2025 17:04:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750550693; x=1751155493; 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=VNBPXOMqa8ce2SYEi86h/8XHU3XHNw6oTVxgDCvCUP4=; b=gcf4RjI6YdRTt+Q31aNlu0qoMxdrlKO3cPXNW445L1htWr5+BIY4cnRBX9dsZBO2J0 g1LDLzOn1G3pyV2e3vu37xrYT3Fumot8D/wDq9NtGjQweONiYW9N5+oZf//OADhafg4p zrNmld8Lzwd8Qty3WQ208eW69J31w8nGGL2eBZJw0gTAG76+7Cp8pBpp7NGCFqAN8cOy aiFjswESZWVuF4xG3LQrVQQHPvfV80IKk4Lg1kYTItFzFZO+21xI7MNpWuSCVPEzkfPR 3hUwPfQq+uOJ80mAc33Cj2umqD7XJxEmX8eBe6dRFl71KVq5nO4USYFRHtLRcVJfAZ2H XNtg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750550693; x=1751155493; 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=VNBPXOMqa8ce2SYEi86h/8XHU3XHNw6oTVxgDCvCUP4=; b=cBgtUVGxHjaSqNuXdLxi+gcvXVVNu0DkvM3/PPC2QQxQkcq8d8hRjJezaXcefe6Nk4 R3Ki8/REDDPrkWWpDiXlXYD79ZvrvmdLXAWu8rsAO5dUHbGlpfR2kDd3XR8oq10SoqFl T2pzDMMAGix4kPZmIK/UA9VGJ0qKS4fk4i80jehrzY5H4A/HJt/vwvJn9JqVs5PMt5V/ LY3QuYw3jx+lmhTmQleb+LZ5UdyJFvNcF7l84Vf26UduLYAoK2CtSC4y+1CbtI6W0q4g xkmaUv2GOCm4JTPLbWkwQroNMSn/lr/SBn1yJ+SyK47QKXoQhKKjBFLMPIC3z4YH+dEV g3cQ== X-Forwarded-Encrypted: i=1; AJvYcCWGh4gY31fNjtIDda+O4VEBbj0w0yJ12LUAKZ7b6LbmxKjbTc4pTVQIp1ybk091EdQdIdTRYwcEleqFByjQ7eP7N1KMcw==@vger.kernel.org, AJvYcCWl/nHc5Q+BH9dZUolosOGmskpXMzUstvLZtVtIEsTVF7t5kmz8tO500FBJd+v/Us1hZndSfVX0ivWgx6A=@vger.kernel.org X-Gm-Message-State: AOJu0YxGTXnGgrFN2CAUsUWe0/uOIH+hCMIgeLVEdnYfCowBLGQhuc0L p+v7SUueJel7qBbg9v5HCJh8IfkmHzpjhDOA+mlBpheEQcFdWzvazKmb X-Gm-Gg: ASbGnctFJJdjaeM+E3QNlcPr1e0wHpTGLPuCtnwDXcqpU4ujN9naZE+FGk62bMwCVxp tst1mBA7Yj6WNG9ckIubYBVpS317Mk/2Xp+rhur1PZsKxEc9AS4PRtC9T+WrxqhWYSaefGCqnNP RGPKuv/cZ+N1C3qSeYHchkDJ4f/JKbtoYf3VXI9a6R58PRkXZkCD0bQpThs87PxidmfFjbtuvKe c9ZVCy3eXoeZUZXSnZ9BA8le8zw/0FzhtYSmNRtWLgp/tbwPgSXy6Srs1aNg7LowQwabTYfKCEa DXPDiX/rJ9foiL8TireU4uwAHlMG+pHR6C92yKbkOB2+7iAWgNHFlc+tcTbpGd7Y2Z8o7cJX X-Google-Smtp-Source: AGHT+IFJOGMm2y8GVS3lSZpLGC+FD/F10k4v807BpJ8hbi7UXhavxt73T36watBtWBYbP82zIJCphg== X-Received: by 2002:a05:6a00:3e17:b0:748:ff39:a0ed with SMTP id d2e1a72fcca58-7490d6a2b0bmr10596406b3a.20.1750550692695; Sat, 21 Jun 2025 17:04:52 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7490a626326sm4941424b3a.75.2025.06.21.17.04.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Jun 2025 17:04:52 -0700 (PDT) From: Kurt Borja Date: Sat, 21 Jun 2025 21:04:06 -0300 Subject: [PATCH v3 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: <20250621-fw-attrs-api-v3-3-3dd55e463396@gmail.com> References: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> In-Reply-To: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> To: Hans de Goede , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello Cc: 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=Ev03nOhI3O2zIAdD5KACHNvxiZ5BFbf2hfuWHFiGuiY=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBnhHlNZeAMv5sYmppydnW+VEG7Mp1031ciBwcq5Kswm6 vv/+taOUhYGMS4GWTFFlvaERd8eReW99TsQeh9mDisTyBAGLk4BmEhKKyPDuYc+TWI9Di/15rOZ Mqzutktclb5np31CpM/jEw2XdgozM/xP6jCUP6lV7rN1m//azYZHXkzR3pNz5ekUV86d/wwCjx/ mBAA= 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 Suggested-by: Joshua Grisham --- 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 d00389b860e4ea0655c740c78bc3751f323b6370..3aec09987ab145508ed05b02e61= a6d94edf79484 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 034f9254240b048f58c97c18062db03f771f8139..af39ed9ad2836147c98b4bb0b89= e70e96ee34b71 100644 --- a/drivers/platform/x86/firmware_attributes_class.c +++ b/drivers/platform/x86/firmware_attributes_class.c @@ -10,7 +10,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 13237890fc92002e7e730b1c235ddf068a6737cd..2df31af8a3b4ac88710af1fae2d= 5dabbb3185f1d 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 34a47269e3d34d2eda6b71af73892656cd2bf67d..f61a6287eb0ebe9ac4c0c9445c3= b54c12b276691 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 5878a351993eb05a4c5c2c75b4915d972ce9becc..9a5a7b956a9f6a2738470e83ce9= 3f4cccf4bf3b4 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 Thu Oct 9 01:09:45 2025 Received: from mail-pf1-f172.google.com (mail-pf1-f172.google.com [209.85.210.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 0687B1805A; Sun, 22 Jun 2025 00:04:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550698; cv=none; b=hGClOfvfqvVJdEOWll4U4vNmcSobA/97CPqOq6Pa2WxhkNCf2/B0VwqHxOF8ZNKiSnABvLCFCT+AU+g3SZXtWlgY2Nd2HdVphsecKoLmKxJnOOeNDLcZfrojop+6QZn/g+DZZYmu26F+F3NnKqmFTrvsH8kF9Lrw3VeKZeReDzw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550698; c=relaxed/simple; bh=liILi0h70NtnHMaTrnZq1JtW1kl+WBBQwRBtx4jqqqU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=tv5eDfkQnznU2Z1TEABHgE7I9LZQvV7ra3TeABve6v7izGsKCfYsYdRF8KqwVdJoCixQRSYLyBjfEQ9H4JcRkKCwEL89MyJ+rE8HrbKhQxMn/h8/V3eKGfONyuCPnm90FZaD8/nEE0YDJt9CT5PLUxXcl4NIRcA9OQtv9gp6JIU= 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=mfSj/f0j; arc=none smtp.client-ip=209.85.210.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="mfSj/f0j" Received: by mail-pf1-f172.google.com with SMTP id d2e1a72fcca58-749248d06faso640728b3a.2; Sat, 21 Jun 2025 17:04:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750550696; x=1751155496; 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=K2/KSwnwApNBj2qg4eJFgFllM2G5u9JrEk978fuXLkk=; b=mfSj/f0jH2ee+cKSv62gUDjDnL39Lg4WIVjaRgnj9TwC4ogAFnvtMD1eplzliImJgN uMyZ7cidgJ/tvoBPJdT1DCx0qY/VG1Tn8EG9UW6X8KHQbJMYcCYxwwiF9X2wpm3C2mau jztU51TgOGU2qJm3UYXMt2ZapCjzdvB44mgxpazyyOZNhvHJIKdsH+SgVfFheWXe1C/S I63AlM7p6DTTTRSgMCtIApKKVDtKdVleYTFtN//R1WYt6ASmAZ5MLN0KFRwjbOO9ZRGS IOmVgBqRuEHbbp00aoCbc4XT+TQs9ofssdH/mkAs3Zxt+HTRYHs6y/o3mFMKudMF2oBH wfWQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750550696; x=1751155496; 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=K2/KSwnwApNBj2qg4eJFgFllM2G5u9JrEk978fuXLkk=; b=PmErEfzrliJ/3nYl5WG9GcVabsveFuv/C7N42QVxeB43Egaq2dJKyOHqF0SUZnln/q EDmFck+ynUw9bEf+mglvcgJ4bHckyNhbjqQ3/hxhgzTb1aMtQnL+nFTVUJ34oSk6VCX8 8VoXz0wzyImISVT5ib6YcaWk11b1wAuwIGFQwYoU2plfwHNIXWavy1IY4ljhMzTSOciY bI720MTI8BlMDiSczlbCTy5CEOCuXQWvkBEDjajQ+Kvq8I3AXKkQ/CNHL2aR7cUVqg8I aKP7U/RfumblCplLF4zvTiG4IayObNUKfo4T1FCbJj4ao6S04TK2X9tfSmGacsmDDDlO shBA== X-Forwarded-Encrypted: i=1; AJvYcCV5x7SnUrJMkN9VXJkl/VE8A5NUfrfbkQfXVnyyQqsyMSoHFTsxFe8ZKuAw95mzIBKb2vkguCIM9zJopcSH15vB57urew==@vger.kernel.org, AJvYcCXD3zEyBUxexPm0+7ymvq6m5VyK+JLRu8Zcxu1qGewB8Q+rlvrOz0kzLryIx2Sga8rxgXq1eHW2wien7CE=@vger.kernel.org X-Gm-Message-State: AOJu0YwztbXj9jBkSZiRpanEaTEzDqPL0IqzsA7qFm4B39AqPFtyY0ch vClNFZ3cohDmPs55LdWo4rsEj62nar+nYEr/0HVqgBalKiW36oAJBD9c X-Gm-Gg: ASbGncufTNwRZV4j820tH/b24AO7XjRBHu6XK0LXBt6nlyCPnSemv36z/zpjCY8P7he zq+65pkWg9l4e0S9n1G7cr5ZIvRtj2V3PcsHErUNreiwcRiEg7vUx0VgZ6tEYvcF/qTwwm0NTb2 KYM8iH7vfhv0a9szZG5etvIrW1YgiQWyORJRLUAXNSuLAZ+Fcol1dr/9iH/W0I010RRCJ0ZHs5v 90Mm15oscYK99eH8rCqVZGJDKJhtW/5YV0Wi5G3s5KM9UW8mPEpi2lrb75ibJYPr8EnbJ1APMfX sBObHqcIrtwOmyJndhg6KViu2jnLmxa1w5iXxvg6kVDRWghKPuF6p3iA+T1UnXd5sz4dZIOO X-Google-Smtp-Source: AGHT+IFtsZ9q2T86H6D8O76MCN+rXPQrc/Zj8zCoI46Ni7R7B0emU5wUSs5UuHY91MEwdstztE4NPw== X-Received: by 2002:a05:6a00:1704:b0:748:f1ba:9aff with SMTP id d2e1a72fcca58-7490d478954mr8722457b3a.5.1750550696235; Sat, 21 Jun 2025 17:04:56 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7490a626326sm4941424b3a.75.2025.06.21.17.04.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Jun 2025 17:04:55 -0700 (PDT) From: Kurt Borja Date: Sat, 21 Jun 2025 21:04:07 -0300 Subject: [PATCH v3 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: <20250621-fw-attrs-api-v3-4-3dd55e463396@gmail.com> References: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> In-Reply-To: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> To: Hans de Goede , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello Cc: 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=10903; i=kuurtb@gmail.com; h=from:subject:message-id; bh=liILi0h70NtnHMaTrnZq1JtW1kl+WBBQwRBtx4jqqqU=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBnhHlN7msoM1ife1p29p+Rp3eNHHjcqhE/L5AcyH6hvP RfPJjWjo5SFQYyLQVZMkaU9YdG3R1F5b/0OhN6HmcPKBDKEgYtTACaSn8bIMP2l8+OTFyJKrn1d Jlugd69wSe3bCzy2i55wp1vc2Vmq/JXhD5fryvmy5i2P2RM/z7sfWMPGFd4+efLh/G5rx+jLz/z NmQE= 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 | 244 ++++++++------------------= ---- 1 file changed, 61 insertions(+), 183 deletions(-) diff --git a/drivers/platform/x86/samsung-galaxybook.c b/drivers/platform/x= 86/samsung-galaxybook.c index 9a5a7b956a9f6a2738470e83ce93f4cccf4bf3b4..d1db2a3f716aafc5a314f2bdc57= f7c958a9ae346 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,193 +876,106 @@ static int galaxybook_block_recording_init(struct s= amsung_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; + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + + 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; =20 - if (!count) - return -EINVAL; - - err =3D kstrtobool(buf, &value); + err =3D usb_charging_acpi_get(galaxybook, &val); if (err) return err; =20 - guard(mutex)(&galaxybook->fw_attr_lock); + *val_idx =3D val; =20 - err =3D fw_attr->set_value(galaxybook, value); + return 0; +} + +static int usb_charging_write(struct device *dev, long id, int val_idx) +{ + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + + return usb_charging_acpi_set(galaxybook, val_idx ? true : false); +} + +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 samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); + bool val; + int err; + + err =3D block_recording_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 block_recording_write(struct device *dev, long id, int val_idx) { - struct galaxybook_fw_attr *fw_attr; - struct attribute **attrs; =20 - fw_attr =3D devm_kzalloc(&galaxybook->platform->dev, sizeof(*fw_attr), GF= P_KERNEL); - if (!fw_attr) - return -ENOMEM; + struct samsung_galaxybook *galaxybook =3D dev_get_drvdata(dev); =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 block_recording_acpi_set(galaxybook, val_idx ? true : false); } =20 -static void galaxybook_kset_unregister(void *data) -{ - struct kset *kset =3D data; - - kset_unregister(kset); -} - -static void galaxybook_fw_attrs_dev_unregister(void *data) -{ - struct device *fw_attrs_dev =3D data; - - device_unregister(fw_attrs_dev); -} +DEFINE_FWAT_ENUM_GROUP(block_recording, "Block Recording", galaxybook_poss= ible_vals, + false, 0644, FWAT_ENUM_ALL_ATTRS); =20 static int galaxybook_fw_attrs_init(struct samsung_galaxybook *galaxybook) { + struct fwat_device *fdev; bool value; int err; =20 - err =3D devm_mutex_init(&galaxybook->platform->dev, &galaxybook->fw_attr_= lock); - if (err) - return err; - - 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 +988,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 Thu Oct 9 01:09:45 2025 Received: from mail-pf1-f172.google.com (mail-pf1-f172.google.com [209.85.210.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 673DC22318; Sun, 22 Jun 2025 00:05:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550701; cv=none; b=SllUNnM+ZmpX/oN8G25KN8RP7VHgoJ8ZuWpHqxPno+uYJLzOzaUweyT3Ma9xEyol5v3MNaSIsDOL8pF9LeMb8ihvTEzbFzkeRV6+8ZUkwyOQbQZ5hD6QwhPbyjVlGMD0sCCO36ifdx/O9xkI6ATKiWbW12uwu+pLXF6JRYXQqak= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550701; c=relaxed/simple; bh=PGzNmxKPeKeIW9y3SLrZgxUtNxszaOvcO3mqQbh5IU4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Ynca7SmjtLfZayHLikelIEncPhIx5fClvkq7nq+f4YV2UiqtHGg7UN96MPgm8E7gLKelJov09mi3mt07+3G7ITm2y/mB0rxl61fneebvBIqemS9gV8qI2aLTmcHmvwuUVyJVI9fYWmi7zhFAR60DYH60FmhsjkM647VFt8ncDYo= 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=ghRbiuBF; arc=none smtp.client-ip=209.85.210.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="ghRbiuBF" Received: by mail-pf1-f172.google.com with SMTP id d2e1a72fcca58-73c17c770a7so3495686b3a.2; Sat, 21 Jun 2025 17:05:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750550700; x=1751155500; 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=ghRbiuBFo7hpSCf1fxPCuz2UUHlbx/3erm18gemvAKdzoC1700MBK+P2aFSv1Em1nI ckRloKcIyNigHsw9CCCYRWBj+LcD+d5lcl/EpaiC14RymoWoDSETYbmavem0wTRBJYvi 1PPaBpG1s43wf2NK9wxbO4kDGAwruCdtEL4g84T/8Pyc7pNss9B9GSNRgr2xKOAodW9e wh2Kp/7Na/Bsk0NUb+BKG/qnIkkKuRT7t5Y8SF7GvVwG8AH9BiI/TE4+cry6XDnZFDw8 uDZL32ebZO8rfe9I3U7T2Ac8SdbnF9wpP0XSgvQiMDrJuEeNNk7+vKYeVIy9yuMLq/LD YFNQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750550700; x=1751155500; 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=kij+O/aRdcTqdK/ChIL3ub9bl1f3zfp/BUFIqcZhXQfq0DkylWt+kSPQCkxFi9NXjy sV4bcRjhAzpdDeloVDBfCthyiXH4we1Nf6oKKZxeYa4l2nYok5+ajJIRFoY8j2EPyqeW SOq7wLUbFnfv+H/+mtJU5IJzXM28iqIAMP0nGsYdRS7hf7ctB3+Tk6i+3nQZBVVs/lo6 W4zlNxHrmtp8m5pP6yoH+n6KGJkXnszHJ2z4jSzfKPUmbY1EIO88EPsr6tynVqMSeP7w j0i57J3IjWvWIidew73xG3iv9ecTxl7odxCQ+G0lBdcGFkvc65hI0ZKVS8ewR23qsT/r NwXw== X-Forwarded-Encrypted: i=1; AJvYcCVEwh3bbG9joukQBY/m7820ciKizJcROJrgXY9jHF1KRjvsMTSLGsYZtWw+vY2ziEv4wlyquATZ4qZo8Gw=@vger.kernel.org, AJvYcCXQZjJH5974UBEoliWNkMd5Syhc2p8cSFd5904y4QEe0wfCqV17h69iM5/yPsWLqKNPhMvGXrcv7unBu0IeW2Lh+bLLVQ==@vger.kernel.org X-Gm-Message-State: AOJu0YxCBiuduxn4GLqaPHm4Lzb45GCnJPMtCfvR7Lpy9VX55g0NfeeY Zmp/SNhvufP7lGEkkIZUkESUtlmEtD65C7CYePVvuYr2Ns7PYuPY3++Q X-Gm-Gg: ASbGncsKRkLWsW1umq7SMesY2KlGfgqKlNr4TLK2676ha+iCG/IRJCDa9ZB9T8yYcP8 BnjPKm7BJAwPmo+ev7q6H2psbOoToTZ56QB1VWy+hm1dQUZLA3eXSmnQfmbwNR7dYRdCwIjB/G2 NPRRfDv1idvVyuJ9EcNEoW2f8kbTJUvv8SIciq2CGPbNXOug2z6/XbuwNhug+zDl/vJBVmedn18 JzzD9GXdyMuErJYxjK5S4d7LexAbwfxFY6g6Xm0FaUVSPsKmUufAFKc4k1fjLiIyVOyju/p52ev ZLpoMVYLH1EetmtM8EUJCtUPh6Alo4SAVEZMIbtZk9KzrAaAGDyA8jWaXLZnwQ== X-Google-Smtp-Source: AGHT+IGV4XdxopG8G2S7cgW2Oa2OOcAyNnYcBcje+Z+pJWDLQ1GmJ7zqzgwvby81KNcPcdYG5ZI2gQ== X-Received: by 2002:a05:6a00:1914:b0:747:ee09:1fd2 with SMTP id d2e1a72fcca58-7490d630890mr11356548b3a.12.1750550699762; Sat, 21 Jun 2025 17:04:59 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7490a626326sm4941424b3a.75.2025.06.21.17.04.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Jun 2025 17:04:59 -0700 (PDT) From: Kurt Borja Date: Sat, 21 Jun 2025 21:04:08 -0300 Subject: [PATCH v3 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: <20250621-fw-attrs-api-v3-5-3dd55e463396@gmail.com> References: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> In-Reply-To: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> To: Hans de Goede , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello Cc: 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+lTTG02pJDBnhHlO/rkr5sJeVR2iV31+GgmUyRT7/rGX2fp0atDDtn PGaOc/zO0pZGMS4GGTFFFnaExZ9exSV99bvQOh9mDmsTCBDGLg4BWAiGnqMDLstl5dNatIOvfl0 oXaiUdSc5v2PFbct/D990pIu+U0KtlyMDPd+z1Co8trg11FXnzXNvXWaJZeazLyZu6zyf+V+Y62 P5gAA 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 Thu Oct 9 01:09:45 2025 Received: from mail-pf1-f169.google.com (mail-pf1-f169.google.com [209.85.210.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 E75623E47B; Sun, 22 Jun 2025 00:05:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550705; cv=none; b=tOCot3MPuJPQCtXJDk1HHIEu0ox/VDi/C4xGxQ9krffo5gjPc4Y7GSCd2iSR5Jl6GjfmA9WeZBcWk3R87CUd56vc9HUIsYj97avWjMinI70apHZlUd7lS9Z5IhrJ1b+ynNc98MHlCduWG7zJuOEW/ClXH+gbZXruQlnDuRvwzKU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750550705; c=relaxed/simple; bh=hOd6+qOcYjH/w/j3ddYeY0GLTSBfqJE3weH99urGytI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=QaAL3PAsLxCXlJ0eXDvjDAVP8NUC5THydzsGj8ick5MKyUtfIaY7LTvnBC+0aA1Ym5UkVFqmVumyo/GyzjpZYeZnbUmVYDImpoo9DDV4scQo/JumNxibroOMixlI0YVbsvrifjoQorptwmHg8wjEuL6Bft4/4nYJ7/FCU1RA2EI= 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=I2ZFqhue; arc=none smtp.client-ip=209.85.210.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="I2ZFqhue" Received: by mail-pf1-f169.google.com with SMTP id d2e1a72fcca58-7406c6dd2b1so2297608b3a.0; Sat, 21 Jun 2025 17:05:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750550703; x=1751155503; 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=3DnWNuVGlcxt97iON5+GLNil5h81EohwejutmAGRqZY=; b=I2ZFqhueT4Xgcvjl7dBj6bthufsgBvDKomlAvmwX/+vOUZXSQP+KG9RnZUGOK/NRTl XCmw9+CEGItRPRw7EgA7tgdujmu6bxAYtxNsPcs+JbbIc4VmZXbw9aSR4s1oUfswrlQG 1oeLFoG+12MsE8Lk7KaVBKe9bZUd2JF4ylECNXRlzc/wSanDXqcK8HSdAOnZECgox0sq oUBfa7qZgXDMTebmQW1yN6pSPY5hGU6VeRWdPHbvOUeq5+LnYi49v97ZquDtoHO1kUiM OtjBotakVywoPLifqKaQYeIp7MhVQH8lu/93ArDqY9fHbNaqMZTz2ti0VB3wK+pxA2ee odCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750550703; x=1751155503; 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=3DnWNuVGlcxt97iON5+GLNil5h81EohwejutmAGRqZY=; b=bD2aNMGyjJsYbjk2PmxW3J4BwUypRf53npxOrOEZBFBjFaiB3BMtYk1EgNpzfJy1Lw WiYYIqRD8LTlPczOiWS3YcBHcn/aaO37ddBjIIg+YtB6VTz9Or1nVdArkG76R4CSzSAU voLNGQn+Y1mf8yrKKB0NRBgHjzKXLgnPtRuxMJLt3HgF/xgOMzqZRXc9eiHaOcwreLTq qFVO0qloexNgKzXXYD2MXwuZqqeBFqwK7wvtwhRUejlbnHMWljsEGr1UvRTQx0nVN6IH KhLFJThz87OZGNlFZzlBY2jRMO2jL2QTLBnpwcAExRRPmaQaOuWZKTCBmqkKzqzAzKH0 MKeg== X-Forwarded-Encrypted: i=1; AJvYcCUHel2rMYv6VHB2b4pNppz4dxR+6IGuhsnuagIIAQKvuhZNgvwcz1PnNkAHlzyCVLcNzubzF7bzsbQygEk=@vger.kernel.org, AJvYcCUYszI3Y7Ms8WjcFW4OVrH2RoIakEQe8xDwZBkQ6dl2LIVnmXoxela3t0R29AvxjtuoTixhSAesrgIbXJa+Bz5gnWXPcw==@vger.kernel.org X-Gm-Message-State: AOJu0YzSz+lImO9Y+cWDwirrJvBRyf32EcocoPo5IRJl2Mbwez9vMxyI wKeIX429x5tPlq9BkYq8aCyTq71FXccPzsr0YTzOO84Z/CxPvxpiMY1n X-Gm-Gg: ASbGnctdsJ+6HO1Pw0TYK1Je8lFiucEoSaXIt6aILMQovxSMTUniACAeRqVh23VN7ZB ce5fNmOBYj/AN1aB309OR0ZrRmRUmOzjh3E0gHupJo74FlWxsInbCPbAvE5dNCBGRVAJ5By0kzV DeRmVOBYwAJd2we1rtTcc7l0qv4A+pdFPkH/EWYkf6JqsPm7+9izIwYTjEyckZAmcLGtTsaf0aB wHOJ5jgFO+QUc0INo1fc6A7NTBTIOeekcy7+266X5K+JjvFeRm+YqH/LcHDQNt8zskcCekzWU0D H5vXJvoI2HhJzZM7xNODkpewcM7rZaKI3UHLRWwO6WejFw7eEcEjVC239G/iFFO4h8V34b7O X-Google-Smtp-Source: AGHT+IE1MOr1rfdCggF9CVGTBOCN0L20OHEyXsSSxw+1pr/VwW2OVdL8ypQHNSrFMAImoPVGMhfFfQ== X-Received: by 2002:a05:6a20:7fa5:b0:1f3:3547:f21b with SMTP id adf61e73a8af0-220291c220fmr11495803637.5.1750550703163; Sat, 21 Jun 2025 17:05:03 -0700 (PDT) Received: from [192.168.1.26] ([181.88.247.122]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7490a626326sm4941424b3a.75.2025.06.21.17.05.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Jun 2025 17:05:02 -0700 (PDT) From: Kurt Borja Date: Sat, 21 Jun 2025 21:04:09 -0300 Subject: [PATCH v3 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: <20250621-fw-attrs-api-v3-6-3dd55e463396@gmail.com> References: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> In-Reply-To: <20250621-fw-attrs-api-v3-0-3dd55e463396@gmail.com> To: Hans de Goede , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , =?utf-8?q?Thomas_Wei=C3=9Fschuh?= , Joshua Grisham , Mark Pearson , Armin Wolf , Mario Limonciello Cc: 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=hOd6+qOcYjH/w/j3ddYeY0GLTSBfqJE3weH99urGytI=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDBnhHlOfdW1bavOjW9LVe5fDQ+WYiXOjfeZJKbmn2e383 NMoKfqwo5SFQYyLQVZMkaU9YdG3R1F5b/0OhN6HmcPKBDKEgYtTACZiws/wh481bb99kq2dhrVu 4OZdJ96+59385WTC9YIF7TkTP563yGFkuHt+03Lv7B81uzfOe+msMsem329fz/+S3XxCN4QVpPK zGAA= 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 c14614613377df7f40565c6df50661fe3f510034..c799f603e9210e4703eeb1f0ac9= d6b9e8bd469c5 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