From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 89BE52D97AA; Wed, 27 May 2026 10:02:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779876172; cv=none; b=UFupldtPL3Qkbluz708s1dN1m+VbLyyjt50d79cfzsJOFITu1V/m6EiYrGd8ILXNae29xTeeIsnOmZxMAxAVdbaoyF/UwGBFACmuQLKZ5wOTlgPzQh1gYmhRalpErJ/QQgURgdQMCjlKs3FNxanSDDE6mLGGS4mrlT2FX6Pnquk= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779876172; c=relaxed/simple; bh=Jd+n+wdZfz2f3+eO03Y8bGPW81v5K+jMYKirfiqPpOo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TXW6SpmrR61wEUdeNzJshfBNZpYeGdCZrmgVDS2YXGaj+pggZbuCBfpWNBMgANIEAeHwSGL4IaCWQFyqAUmC2CmArXwjOAwIHWk9AzwycTHvr/5UdNvIx8YZBBeU3y2IcHX20PQ9UJB7Mfn0QPt84gKkEe5WGpwecMOj5XyLhwI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=kU0m3y1S; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="kU0m3y1S" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D63911F000E9; Wed, 27 May 2026 10:02:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779876171; bh=3uxivZrj2/t8sbrW9mdJoZ9CAU5lPMxafXV5wRYUamE=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=kU0m3y1S1LD1hmX0JboaPc9LoPL+4EZMEiGvoau1C360oqYGFmfxpuwS5aYYd4+vo 6+zVUzLC+Cn5BG7EmFLB7w8ztsrVz3+7nFtgYZBoaqTH8DDAc4SxIPexxi9gbOuMmY etb0KW/y7QpmVffstCEbblnb18udsQU9sjZ039DHGDkBD/ANdA/Z+gk6+v2i+R6pF7 mCV7XrcVlklIn7OKWLfXms1hFGiE57jmzqHX9hKu7gO1a3kfyVnbkH5diij8use44I 8L/QW4qllFbVQp16QbjtN/Fj1bOcMwSynUsWXPpnI5n/66kvLp6KeMt62pMLmqlR+L 4fvTfcQ0kRGrg== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Cc: "Aneesh Kumar K.V (Arm)" , Catalin Marinas , Greg KH , Jeremy Linton , Jonathan Cameron , Lorenzo Pieralisi , Mark Rutland , Sudeep Holla , Will Deacon , Steven Price , Suzuki K Poulose Subject: [PATCH v6 1/4] firmware: smccc: Add an Arm SMCCC bus Date: Wed, 27 May 2026 15:32:30 +0530 Message-ID: <20260527100233.428018-2-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260527100233.428018-1-aneesh.kumar@kernel.org> References: <20260527100233.428018-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-coco@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit SMCCC-discovered firmware services are currently represented by separate platform devices, such as smccc_trng and arm-cca-dev. Those devices do not represent independent DT/ACPI-described platform resources; they are features of the SMCCC firmware interface. Add an Arm SMCCC bus for services discovered through the SMCCC firmware interface. The bus provides SMCCC device and driver registration helpers, name-based matching, modalias generation, and a sysfs modalias attribute so SMCCC service drivers can bind to discovered firmware services and autoload as modules. Follow-up changes can then register SMCCC firmware services as arm-smccc devices instead of creating independent per-feature platform devices. Based on arm_ffa code Signed-off-by: Aneesh Kumar K.V (Arm) --- drivers/firmware/smccc/smccc.c | 158 ++++++++++++++++++++++++++++++ include/linux/arm-smccc-bus.h | 49 +++++++++ include/linux/mod_devicetable.h | 13 +++ scripts/mod/devicetable-offsets.c | 3 + scripts/mod/file2alias.c | 8 ++ 5 files changed, 231 insertions(+) create mode 100644 include/linux/arm-smccc-bus.h diff --git a/drivers/firmware/smccc/smccc.c b/drivers/firmware/smccc/smccc.c index bdee057db2fd..695c920a8087 100644 --- a/drivers/firmware/smccc/smccc.c +++ b/drivers/firmware/smccc/smccc.c @@ -10,10 +10,15 @@ #include #include #include +#include +#include +#include + #include static u32 smccc_version = ARM_SMCCC_VERSION_1_0; static enum arm_smccc_conduit smccc_conduit = SMCCC_CONDUIT_NONE; +static DEFINE_IDA(arm_smccc_bus_id); bool __ro_after_init smccc_trng_available = false; s32 __ro_after_init smccc_soc_id_version = SMCCC_RET_NOT_SUPPORTED; @@ -81,6 +86,159 @@ bool arm_smccc_hypervisor_has_uuid(const uuid_t *hyp_uuid) } EXPORT_SYMBOL_GPL(arm_smccc_hypervisor_has_uuid); +static int arm_smccc_bus_match(struct device *dev, + const struct device_driver *drv) +{ + const struct arm_smccc_device_id *id_table; + struct arm_smccc_device *smccc_dev = to_arm_smccc_device(dev); + + id_table = to_arm_smccc_driver(drv)->id_table; + if (!id_table) + return 0; + + while (id_table->name[0]) { + if (!strcmp(smccc_dev->name, id_table->name)) + return 1; + id_table++; + } + + return 0; +} + +static int arm_smccc_bus_probe(struct device *dev) +{ + struct arm_smccc_driver *smccc_drv = to_arm_smccc_driver(dev->driver); + + return smccc_drv->probe(to_arm_smccc_device(dev)); +} + +static void arm_smccc_bus_remove(struct device *dev) +{ + struct arm_smccc_driver *smcc_drv = to_arm_smccc_driver(dev->driver); + + if (smcc_drv->remove) + smcc_drv->remove(to_arm_smccc_device(dev)); +} + +static int arm_smccc_bus_uevent(const struct device *dev, + struct kobj_uevent_env *env) +{ + const struct arm_smccc_device *smccc_dev = to_arm_smccc_device(dev); + + return add_uevent_var(env, "MODALIAS=" ARM_SMCCC_MODULE_PREFIX "%s", + smccc_dev->name); +} + +static ssize_t modalias_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct arm_smccc_device *smccc_dev = to_arm_smccc_device(dev); + + return sysfs_emit(buf, ARM_SMCCC_MODULE_PREFIX "%s\n", smccc_dev->name); +} +static DEVICE_ATTR_RO(modalias); + +static struct attribute *arm_smccc_device_attrs[] = { + &dev_attr_modalias.attr, + NULL, +}; +ATTRIBUTE_GROUPS(arm_smccc_device); + +const struct bus_type arm_smccc_bus_type = { + .name = "arm_smccc", + .match = arm_smccc_bus_match, + .probe = arm_smccc_bus_probe, + .remove = arm_smccc_bus_remove, + .uevent = arm_smccc_bus_uevent, + .dev_groups = arm_smccc_device_groups, +}; +EXPORT_SYMBOL_GPL(arm_smccc_bus_type); + +int arm_smccc_driver_register(struct arm_smccc_driver *driver, + struct module *owner, const char *mod_name) +{ + if (!driver->probe) + return -EINVAL; + + driver->driver.bus = &arm_smccc_bus_type; + driver->driver.name = driver->name; + driver->driver.owner = owner; + driver->driver.mod_name = mod_name; + + return driver_register(&driver->driver); +} +EXPORT_SYMBOL_GPL(arm_smccc_driver_register); + +void arm_smccc_driver_unregister(struct arm_smccc_driver *driver) +{ + driver_unregister(&driver->driver); +} +EXPORT_SYMBOL_GPL(arm_smccc_driver_unregister); + +static void arm_smccc_release_device(struct device *dev) +{ + struct arm_smccc_device *smccc_dev = to_arm_smccc_device(dev); + + ida_free(&arm_smccc_bus_id, smccc_dev->id); + kfree(smccc_dev); +} + +struct arm_smccc_device *arm_smccc_device_register(const char *name) +{ + struct arm_smccc_device *smccc_dev; + int id, ret; + + id = ida_alloc_min(&arm_smccc_bus_id, 1, GFP_KERNEL); + if (id < 0) + return ERR_PTR(id); + + smccc_dev = kzalloc_obj(*smccc_dev); + if (!smccc_dev) { + ida_free(&arm_smccc_bus_id, id); + return ERR_PTR(-ENOMEM); + } + + smccc_dev->id = id; + if (strscpy(smccc_dev->name, name) < 0) { + kfree(smccc_dev); + ida_free(&arm_smccc_bus_id, id); + return ERR_PTR(-EINVAL); + } + smccc_dev->dev.bus = &arm_smccc_bus_type; + smccc_dev->dev.release = arm_smccc_release_device; + + ret = dev_set_name(&smccc_dev->dev, "%s-%d", smccc_dev->name, id); + if (ret) { + kfree(smccc_dev); + ida_free(&arm_smccc_bus_id, id); + return ERR_PTR(ret); + } + + ret = device_register(&smccc_dev->dev); + if (ret) { + put_device(&smccc_dev->dev); + return ERR_PTR(ret); + } + + return smccc_dev; +} +EXPORT_SYMBOL_GPL(arm_smccc_device_register); + +void arm_smccc_device_unregister(struct arm_smccc_device *smccc_dev) +{ + if (!smccc_dev) + return; + + device_unregister(&smccc_dev->dev); +} +EXPORT_SYMBOL_GPL(arm_smccc_device_unregister); + +static int __init arm_smccc_bus_init(void) +{ + return bus_register(&arm_smccc_bus_type); +} +subsys_initcall(arm_smccc_bus_init); + static int __init smccc_devices_init(void) { struct platform_device *pdev; diff --git a/include/linux/arm-smccc-bus.h b/include/linux/arm-smccc-bus.h new file mode 100644 index 000000000000..188891441e57 --- /dev/null +++ b/include/linux/arm-smccc-bus.h @@ -0,0 +1,49 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2026 Arm Limited + */ +#ifndef __LINUX_ARM_SMCCC_BUS_H +#define __LINUX_ARM_SMCCC_BUS_H + +#include +#include +#include + +struct arm_smccc_device { + int id; + char name[ARM_SMCCC_NAME_SIZE]; + struct device dev; +}; + +#define to_arm_smccc_device(d) container_of(d, struct arm_smccc_device, dev) + +struct arm_smccc_driver { + const char *name; + int (*probe)(struct arm_smccc_device *sdev); + void (*remove)(struct arm_smccc_device *sdev); + const struct arm_smccc_device_id *id_table; + + struct device_driver driver; +}; + +#define to_arm_smccc_driver(d) \ + container_of_const(d, struct arm_smccc_driver, driver) + +int arm_smccc_driver_register(struct arm_smccc_driver *driver, + struct module *owner, const char *mod_name); +void arm_smccc_driver_unregister(struct arm_smccc_driver *driver); +struct arm_smccc_device *arm_smccc_device_register(const char *name); +void arm_smccc_device_unregister(struct arm_smccc_device *smcc_dev); + +#define arm_smccc_register(driver) \ + arm_smccc_driver_register(driver, THIS_MODULE, KBUILD_MODNAME) +#define arm_smccc_unregister(driver) \ + arm_smccc_driver_unregister(driver) + +#define module_arm_smccc_driver(__arm_smccc_driver) \ + module_driver(__arm_smccc_driver, arm_smccc_register, \ + arm_smccc_unregister) + +extern const struct bus_type arm_smccc_bus_type; + +#endif /* __LINUX_ARM_SMCCC_BUS_H */ diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h index 23ff24080dfd..c9cee8c5a0b2 100644 --- a/include/linux/mod_devicetable.h +++ b/include/linux/mod_devicetable.h @@ -876,6 +876,19 @@ struct auxiliary_device_id { kernel_ulong_t driver_data; }; +#define ARM_SMCCC_NAME_SIZE 40 +#define ARM_SMCCC_MODULE_PREFIX "arm_smccc:" + +/** + * struct arm_smccc_device_id - Arm SMCCC bus device identifier + * @name: SMCCC device name + * @driver_data: driver data + */ +struct arm_smccc_device_id { + char name[ARM_SMCCC_NAME_SIZE]; + kernel_ulong_t driver_data; +}; + /* Surface System Aggregator Module */ #define SSAM_MATCH_TARGET 0x1 diff --git a/scripts/mod/devicetable-offsets.c b/scripts/mod/devicetable-offsets.c index b4178c42d08f..a485011ff137 100644 --- a/scripts/mod/devicetable-offsets.c +++ b/scripts/mod/devicetable-offsets.c @@ -254,6 +254,9 @@ int main(void) DEVID(auxiliary_device_id); DEVID_FIELD(auxiliary_device_id, name); + DEVID(arm_smccc_device_id); + DEVID_FIELD(arm_smccc_device_id, name); + DEVID(ssam_device_id); DEVID_FIELD(ssam_device_id, match_flags); DEVID_FIELD(ssam_device_id, domain); diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c index 4e99393a35f1..0ce4fb049711 100644 --- a/scripts/mod/file2alias.c +++ b/scripts/mod/file2alias.c @@ -1296,6 +1296,13 @@ static void do_auxiliary_entry(struct module *mod, void *symval) module_alias_printf(mod, false, AUXILIARY_MODULE_PREFIX "%s", *name); } +static void do_arm_smccc_entry(struct module *mod, void *symval) +{ + DEF_FIELD_ADDR(symval, arm_smccc_device_id, name); + + module_alias_printf(mod, false, ARM_SMCCC_MODULE_PREFIX "%s", *name); +} + /* * Looks like: ssam:dNcNtNiNfN * @@ -1466,6 +1473,7 @@ static const struct devtable devtable[] = { {"mhi", SIZE_mhi_device_id, do_mhi_entry}, {"mhi_ep", SIZE_mhi_device_id, do_mhi_ep_entry}, {"auxiliary", SIZE_auxiliary_device_id, do_auxiliary_entry}, + {"arm_smccc", SIZE_arm_smccc_device_id, do_arm_smccc_entry}, {"ssam", SIZE_ssam_device_id, do_ssam_entry}, {"dfl", SIZE_dfl_device_id, do_dfl_entry}, {"ishtp", SIZE_ishtp_device_id, do_ishtp_entry}, -- 2.43.0