* Re: [PATCH] kdoc: xforms: ignore special static/inline macros
From: Randy Dunlap @ 2026-06-12 23:34 UTC (permalink / raw)
To: Jonathan Corbet, linux-doc
Cc: Shuah Khan, Mauro Carvalho Chehab, Harry Wentland, Alex Hung,
Ivan Lipski, Dan Wheeler, Alex Deucher, Christian König,
amd-gfx
In-Reply-To: <87ldcj5z9i.fsf@trenco.lwn.net>
On 6/12/26 12:34 PM, Jonathan Corbet wrote:
> Randy Dunlap <rdunlap@infradead.org> writes:
>
>> drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c contains 7 (for
>> now) functions that use STATIC_IFN_KUNIT or INLINE_IFN_KUNIT macros for
>> function qualifiers (static or not, inline or not).
>>
>> These cause parse warnings from kernel-doc:
>> Invalid C declaration: Expected identifier in nested name, got keyword:
>> struct [error at 29]
>> STATIC_IFN_KUNIT const struct drm_color_lut * __extract_blob_lut (const
>> struct drm_property_blob *blob, uint32_t *size)
>>
>> Handle these in kernel-doc to prevent multiple warnings.
>>
>> Fixes: 647d1fd04652 ("drm/amd/display: Add KUnit test for color helpers")
>> Signed-off-by: Randy Dunlap <rdunlap@infradead.org>
>> ---
>> Cc: Jonathan Corbet <corbet@lwn.net>
>> Cc: Shuah Khan <skhan@linuxfoundation.org>
>> Cc: Mauro Carvalho Chehab <mchehab@kernel.org>
>> Cc: Harry Wentland <harry.wentland@amd.com>
>> Cc: Alex Hung <alex.hung@amd.com>
>> Cc: Ivan Lipski <ivan.lipski@amd.com>
>> Cc: Dan Wheeler <daniel.wheeler@amd.com>
>> Cc: Alex Deucher <alexander.deucher@amd.com>
>> Cc: Christian König <christian.koenig@amd.com>
>> Cc: amd-gfx@lists.freedesktop.org
>>
>> tools/lib/python/kdoc/xforms_lists.py | 2 ++
>> 1 file changed, 2 insertions(+)
>>
>> --- linux-next-20260601.orig/tools/lib/python/kdoc/xforms_lists.py
>> +++ linux-next-20260601/tools/lib/python/kdoc/xforms_lists.py
>> @@ -104,6 +104,8 @@ class CTransforms:
>> (CMatch("__context_unsafe"), ""),
>> (CMatch("__attribute_const__"), ""),
>> (CMatch("__attribute__"), ""),
>> + (CMatch("STATIC_IFN_KUNIT"), ""),
>> + (CMatch("INLINE_IFN_KUNIT"), ""),
>
> So I can't get this one to apply; which tree did you patch here?
Ah. My quilt patches. There is one there that I haven't submitted.
I'll drop it and resubmit the patch.
thanks.
--
~Randy
^ permalink raw reply
* Re: [PATCH net-next 0/3] docs: net: more adjustments to docs
From: patchwork-bot+netdevbpf @ 2026-06-12 23:20 UTC (permalink / raw)
To: Jakub Kicinski
Cc: davem, netdev, edumazet, pabeni, andrew+netdev, horms, corbet,
linux-doc, bpf
In-Reply-To: <20260609201224.1191391-1-kuba@kernel.org>
Hello:
This series was applied to netdev/net-next.git (main)
by Jakub Kicinski <kuba@kernel.org>:
On Tue, 9 Jun 2026 13:12:21 -0700 you wrote:
> A few small updates to the docs. Mostly typos this time.
> This is trying to prepare docs for getting fed directly
> into AI reviews.
>
> Jakub Kicinski (3):
> docs: net: fix minor issues with XDP metadata docs
> docs: net: tls-offload: document tls_dev_del, tls_dev_resync, and
> rekey
> docs: net: fix minor issues with devlink docs
>
> [...]
Here is the summary with links:
- [net-next,1/3] docs: net: fix minor issues with XDP metadata docs
https://git.kernel.org/netdev/net-next/c/6213cf54adad
- [net-next,2/3] docs: net: tls-offload: document tls_dev_del, tls_dev_resync, and rekey
(no matching commit)
- [net-next,3/3] docs: net: fix minor issues with devlink docs
(no matching commit)
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* [PATCH v4 31/31] [RFC] tools/scmi: Add SCMI Telemetry testing tool
From: Cristian Marussi @ 2026-06-12 22:38 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a testing tool that exercises the SCMI ioctls UAPI interface: as of
now the tool simply queries the initial state of the SCMI Telemetry
subsystem, tries to enable all the existent Data Events and dumps all
the Telemetry data.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- added generation file support
Basic implementation just to exercise a few IOCTls: to be refined and
extended to support a more interactive usage.
---
tools/testing/scmi/Makefile | 25 +++
tools/testing/scmi/stlm.c | 434 ++++++++++++++++++++++++++++++++++++
2 files changed, 459 insertions(+)
create mode 100644 tools/testing/scmi/Makefile
create mode 100644 tools/testing/scmi/stlm.c
diff --git a/tools/testing/scmi/Makefile b/tools/testing/scmi/Makefile
new file mode 100644
index 000000000000..a6a101f8398b
--- /dev/null
+++ b/tools/testing/scmi/Makefile
@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+CC?=$(CROSS_COMPILE)gcc
+OBJS = stlm.o
+
+CFLAGS=-Wall -static -std=gnu11 -I ../../../include/uapi/
+ifneq ($(DEBUG), )
+ CFLAGS+=-O0 -g -ggdb
+else
+ CFLAGS+=-static
+endif
+
+all: stlm
+
+stlm: $(OBJS)
+ $(CC) $(CFLAGS) $^ -o $@
+
+%.o: %.c
+ $(CC) $(CFLAGS) -c $<
+
+clean:
+ rm -f *.o
+ rm -f stlm
+
+.PHONY: clean
diff --git a/tools/testing/scmi/stlm.c b/tools/testing/scmi/stlm.c
new file mode 100644
index 000000000000..f153b6e6a4cd
--- /dev/null
+++ b/tools/testing/scmi/stlm.c
@@ -0,0 +1,434 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+
+#include <unistd.h>
+
+#include <linux/scmi.h>
+
+#define SLEEP_MS 3000
+#define DEF_TLM_ROOT "/sys/fs/arm_telemetry/"
+
+#define IOCTL_ERR_STR(_ioctl) "IOCTL:" #_ioctl
+
+struct tlm_de {
+ struct scmi_tlm_de_info *info;
+ struct scmi_tlm_de_config cfg;
+ struct scmi_tlm_de_sample sample;
+};
+
+struct tlm_group {
+ int fd;
+ struct scmi_tlm_grp_info *info;
+ struct scmi_tlm_grp_desc *desc;
+ struct scmi_tlm_intervals *ivs;
+};
+
+struct tlm_state {
+ int dfd;
+ int fd;
+ int g_dfd;
+ const char *path;
+ struct scmi_tlm_base_info info;
+ struct scmi_tlm_config cfg;
+ struct scmi_tlm_intervals *ivs;
+ unsigned int num_des;
+ struct tlm_de *des;
+ unsigned int num_groups;
+ struct tlm_group *grps;
+};
+
+static inline void dump_state(struct tlm_state *st)
+{
+ uint32_t *uuid32 = st->info.de_impl_version;
+ uint16_t *uuid16 = (uint16_t *)&st->info.de_impl_version[1];
+
+ fprintf(stdout, "- SYSTEM TELEMETRY @instance: %s\n\n", st->path);
+ fprintf(stdout, "+ Version: 0x%08X\n", st->info.version);
+ fprintf(stdout, "+ DEs#: %d\n", st->info.num_des);
+ fprintf(stdout, "+ GRPS#: %d\n", st->info.num_groups);
+ fprintf(stdout, "+ INTRV#: %d\n", st->info.num_intervals);
+
+ fprintf(stdout, "+ UUID: ");
+ fprintf(stdout, "%X-", uuid32[0]);
+ fprintf(stdout, "%X-", uuid16[0]);
+ fprintf(stdout, "%X-", uuid16[1]);
+ fprintf(stdout, "%X", uuid16[2]);
+ fprintf(stdout, "%X\n", uuid32[3]);
+
+ fprintf(stdout, "\n+ TLM_ENABLED: %d\n", st->cfg.enable);
+ fprintf(stdout, "+ CURRENT_UPDATE_INTERVAL: %d\n",
+ st->cfg.current_update_interval);
+
+ fprintf(stdout, "+ Found #%u Global Update Intervals\n",
+ st->info.num_intervals);
+ for (int i = 0; i < st->ivs->num_intervals; i++)
+ fprintf(stdout, "\t[%d]::%u\n", i, st->ivs->update_intervals[i]);
+
+ if (st->info.num_des != st->num_des) {
+ fprintf(stdout, "\n++++++ DES NOT FULLY_ENUMERATED ++++++\n");
+ fprintf(stdout, "+++ DECLARED:%u ENUMERATED:%u +++\n",
+ st->info.num_des, st->num_des);
+ }
+
+ fprintf(stdout, "\n+ Found #%d DEs:\n", st->num_des);
+ for (int i = 0; i < st->num_des; i++)
+ fprintf(stdout, "\t0x%08X %s %s -- TS:%16llu %016llX\n",
+ st->des[i].info->id,
+ st->des[i].cfg.enable ? "ON" : "--",
+ st->des[i].cfg.t_enable ? "TS_ON" : "-----",
+ st->des[i].sample.tstamp, st->des[i].sample.val);
+ fprintf(stdout, "\n");
+
+ fprintf(stdout, "+ Found %d GRPs: ", st->num_groups);
+ for (int i = 0; i < st->num_groups; i++) {
+ fprintf(stdout, "\n\tGRP_ID:%d DES#:%d INTRVS#:%d\n",
+ st->grps[i].info->id, st->grps[i].info->num_des,
+ st->grps[i].info->num_intervals);
+
+ fprintf(stdout, "\tCOMPOSING_DES:");
+ for (int j = 0; j < st->grps[i].desc->num_des; j++)
+ fprintf(stdout, "0x%08X ",
+ st->grps[i].desc->composing_des[j]);
+ fprintf(stdout, "\n");
+ }
+}
+
+static int discover_base_info(int fd, struct scmi_tlm_base_info *info)
+{
+ int ret;
+
+ ret = ioctl(fd, SCMI_TLM_GET_INFO, info);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_INFO));
+ return ret;
+ }
+
+ return ret;
+}
+
+static struct scmi_tlm_des_list *scmi_get_des_list(int fd, int num_des)
+{
+ struct scmi_tlm_des_list *dsl;
+ size_t size = sizeof(*dsl) + num_des * sizeof(dsl->des[0]);
+ int ret;
+
+ dsl = malloc(size);
+ if (!dsl)
+ return NULL;
+
+ bzero(dsl, size);
+ dsl->num_des = num_des;
+ ret = ioctl(fd, SCMI_TLM_GET_DE_LIST, dsl);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_DE_LIST));
+ return NULL;
+ }
+
+ return dsl;
+}
+
+static struct tlm_de *enumerate_des(struct tlm_state *st)
+{
+ struct scmi_tlm_des_list *dsl;
+ struct tlm_de *des;
+
+ dsl = scmi_get_des_list(st->fd, st->info.num_des);
+ if (!dsl)
+ return NULL;
+
+ st->num_des = dsl->num_des;
+ des = malloc(sizeof(*des) * st->num_des);
+ if (!des)
+ return NULL;
+
+ bzero(des, sizeof(*des) * st->num_des);
+ for (int i = 0; i < st->num_des; i++) {
+ struct tlm_de *de = &des[i];
+ int ret;
+
+ de->info = &dsl->des[i];
+ de->cfg.id = de->info->id;
+ ret = ioctl(st->fd, SCMI_TLM_GET_DE_CFG, &de->cfg);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_DE_CFG));
+ continue;
+ }
+
+ if (!de->cfg.enable)
+ continue;
+
+ /* Collect initial sample */
+ de->sample.id = de->info->id;
+ ret = ioctl(st->fd, SCMI_TLM_GET_DE_VALUE, &de->sample);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_DE_VALUE));
+ continue;
+ }
+ }
+
+ return des;
+}
+
+static int get_current_config(int fd, struct scmi_tlm_config *cfg)
+{
+ int ret;
+
+ ret = ioctl(fd, SCMI_TLM_GET_CFG, cfg);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_CFG));
+ return ret;
+ }
+
+ return ret;
+}
+
+static struct scmi_tlm_grps_list *scmi_get_grps_list(int fd, int num_groups)
+{
+ struct scmi_tlm_grps_list *gsl;
+ size_t size = sizeof(*gsl) + num_groups * sizeof(gsl->grps[0]);
+ int ret;
+
+ gsl = malloc(size);
+ if (!gsl)
+ return NULL;
+
+ bzero(gsl, size);
+ gsl->num_grps = num_groups;
+ ret = ioctl(fd, SCMI_TLM_GET_GRP_LIST, gsl);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_GRP_LIST));
+ return NULL;
+ }
+
+ return gsl;
+}
+
+static struct scmi_tlm_intervals *enumerate_intervals(int fd, int num_intervals)
+{
+ struct scmi_tlm_intervals *ivs;
+ size_t sz;
+ int ret;
+
+ sz = sizeof(*ivs) + sizeof(*ivs->update_intervals) * num_intervals;
+ ivs = malloc(sz);
+ if (!ivs)
+ return NULL;
+
+ memset(ivs, 0, sz);
+
+ ivs->num_intervals = num_intervals;
+ ret = ioctl(fd, SCMI_TLM_GET_INTRVS, ivs);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_INTRVS));
+ free(ivs);
+ return NULL;
+ }
+
+ return ivs;
+}
+
+static struct tlm_group *enumerate_groups(struct tlm_state *st)
+{
+ struct scmi_tlm_grps_list *gsl;
+ struct tlm_group *grps;
+
+ gsl = scmi_get_grps_list(st->fd, st->info.num_groups);
+ if (!gsl)
+ return NULL;
+
+ st->g_dfd = openat(st->dfd, "groups", O_RDONLY);
+ if (st->g_dfd < 0)
+ return NULL;
+
+ st->num_groups = gsl->num_grps;
+ grps = malloc(sizeof(*grps) * st->num_groups);
+ if (!grps)
+ return NULL;
+
+ bzero(grps, sizeof(*grps) * st->num_groups);
+ for (int i = 0; i < st->num_groups; i++) {
+ struct tlm_group *grp = &grps[i];
+ char gctrl[32];
+ size_t size;
+ int ret;
+
+ snprintf(gctrl, 32, "%d/control", i);
+ grp->fd = openat(st->g_dfd, gctrl, O_RDWR);
+ if (grp->fd < 0)
+ return NULL;
+
+ grp->info = &gsl->grps[i];
+ size = sizeof(*grp->desc) + sizeof(uint32_t) * grp->info->num_des;
+ grp->desc = malloc(size);
+ if (!grp->desc)
+ return NULL;
+
+ bzero(grp->desc, size);
+ grp->desc->num_des = grp->info->num_des;
+ ret = ioctl(grp->fd, SCMI_TLM_GET_GRP_DESC, grp->desc);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_GRP_DESC));
+ continue;
+ }
+
+ grp->ivs = enumerate_intervals(grp->fd, grp->info->num_intervals);
+ }
+
+ return grps;
+}
+
+static int get_tlm_state(const char *path, struct tlm_state *st)
+{
+ int ret;
+
+ st->dfd = open(path, O_RDONLY);
+ if (st->dfd < 0) {
+ perror("open");
+ return st->dfd;
+ }
+
+ st->fd = openat(st->dfd, "control", O_RDWR);
+ if (st->fd < 0) {
+ perror("openat");
+ return st->fd;
+ }
+
+ ret = discover_base_info(st->fd, &st->info);
+ if (ret)
+ return ret;
+
+ st->ivs = enumerate_intervals(st->fd, st->info.num_intervals);
+ if (!st->ivs)
+ return -1;
+
+ ret = get_current_config(st->fd, &st->cfg);
+ if (ret)
+ return ret;
+
+ if (st->info.num_des)
+ st->des = enumerate_des(st);
+
+ if (st->info.num_groups)
+ st->grps = enumerate_groups(st);
+
+ st->path = path;
+
+ return 0;
+}
+
+#define MAX_GENERATIONS 5
+
+static void get_tlm_generation(struct tlm_state *st)
+{
+ int fd, i = 0;
+ struct pollfd pfds[1];
+
+ fd = openat(st->dfd, "generation", O_RDONLY);
+ if (fd < 0) {
+ perror("openat");
+ return ;
+ }
+
+ pfds[0].fd = fd;
+ pfds[0].events = POLLIN;
+
+ do {
+ int ret;
+
+ pfds[0].revents = 0;
+ ret = poll(pfds, 1, -1);
+ if (ret < 0 ) {
+ perror("poll generation");
+ break;;
+ }
+
+ if (!pfds[0].revents)
+ continue;
+
+ if (pfds[0].revents & POLLIN) {
+ int n;
+ char buf[32] = {};
+
+ n = read(fd, buf, 32);
+ if (n < 0) {
+ perror("read generation");
+ break;
+ }
+
+ fprintf(stdout, "Generation[%u]: %s\n", i, buf);
+ }
+ } while (i++ < MAX_GENERATIONS);
+
+ close(fd);
+}
+
+int main(int argc, char **argv)
+{
+ const char *tlm_root_instance = DEF_TLM_ROOT "tlm_0/";
+ struct scmi_tlm_data_read *bulk;
+ struct scmi_tlm_de_config de_cfg = {};
+ struct tlm_state st = {};
+ size_t bulk_sz;
+ int ret;
+
+ ret = get_tlm_state(tlm_root_instance, &st);
+ if (ret)
+ return ret;
+
+ dump_state(&st);
+
+ get_tlm_generation(&st);
+
+ bulk_sz = sizeof(*bulk) + sizeof(bulk->samples[0]) * st.info.num_des;
+ bulk = malloc(bulk_sz);
+ if (!bulk)
+ return -1;
+
+ bzero(bulk, bulk_sz);
+ bulk->num_samples = st.info.num_des;
+ ret = ioctl(st.fd, SCMI_TLM_SINGLE_SAMPLE, bulk);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_SINGLE_SAMPLE));
+ return -1;
+ }
+
+ fprintf(stdout, "\n--- Enabling ALL DEs with timestamp...\n");
+ de_cfg.enable = 1;
+ de_cfg.t_enable = 1;
+ ret = ioctl(st.fd, SCMI_TLM_SET_ALL_CFG, &de_cfg);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_SET_ALL_CFG));
+ return ret;
+ }
+
+ fprintf(stdout, "\n- Single ASYNC read -\n-------------------\n");
+ for (int i = 0; i < bulk->num_samples; i++)
+ fprintf(stdout, "0x%08X %016llu %016llX\n",
+ bulk->samples[i].id, bulk->samples[i].tstamp,
+ bulk->samples[i].val);
+
+ bzero(bulk, bulk_sz);
+ bulk->num_samples = st.info.num_des;
+ ret = ioctl(st.fd, SCMI_TLM_BULK_READ, bulk);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_BULK_READ));
+ return -1;
+ }
+
+ fprintf(stdout, "\n- BULK read -\n-------------------\n");
+ for (int i = 0; i < bulk->num_samples; i++)
+ fprintf(stdout, "0x%08X %016llu %016llX\n",
+ bulk->samples[i].id, bulk->samples[i].tstamp,
+ bulk->samples[i].val);
+
+ return 0;
+}
--
2.54.0
^ permalink raw reply related
* [PATCH v4 30/31] fs/stlmfs: Document lazy mode and related mount option
From: Cristian Marussi @ 2026-06-12 22:38 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi, Jonathan Corbet, Shuah Khan
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Document optional lazy enumeration behaviour and related mount option.
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: linux-doc@vger.kernel.org
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/filesystems/stlmfs.rst | 21 +++++++++++++++++++--
1 file changed, 19 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index b5b3cd649775..fe69d40f9249 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -74,8 +74,12 @@ Design
STLMFS is a pseudo filesystem used to expose ARM SCMI Telemetry data
discovered dynamically at run-time via SCMI.
-Inodes are all dynamically created at mount-time from a dedicated
-kmem_cache based on the gathered available SCMI Telemetry information.
+Normally all of the top level file/inodes are dynamically created at
+mount-time from a dedicated kmem_cache based on the gathered available
+SCMI Telemetry information, but it is possible to enable a lazy enumeration
+and FS population mode that delays SCMI Telemetry resources enumerations
+and related FS population till the moment a user steps into the related FS
+subdirectories: *des/* *groups/* and *components/*.
Since inodes represent the discovered Telemetry entities, which in turn are
statically defined at the platform level and immutable throughout the same
@@ -128,6 +132,19 @@ Note that all of the above options are explicitly designed NOT to support
a remount operation, so as not have surprising effects on permissions of
already discovered/created telemetry files.
+It is possible to mount it in lazy-mode by using the *lazy* mount option::
+
+ mount -t stlmfs -o lazy none /sys/fs/arm_telemetry
+
+In this latter case, the des/ groups/ and components/ directory will be
+created empty at mount-time and only filled later when 'walked in'.
+
+This allows a user to benefit from a lazy enumeration scheme of the SCMI
+Telemetry resources by delaying such, usually expensive, message exchanges
+to the last possible moment: ideally, even never, if using some of the
+other alternative binary interfaces that does not need any resource
+enumeration at all.
+
Usage
=====
--
2.54.0
^ permalink raw reply related
* [PATCH v4 29/31] firmware: arm_scmi: stlmfs: Add lazy population support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a filesystem mount option to the SCMI Telemetry filesystem so as to
delay resources enumeration and related fs subtrees population to the
last possible moment when the related fs paths are accessed.
Only basic global fs entries are populated at mount time when the lazy
mount option is used.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- add lazy support to show_options
- make FS entries world-Readable and user-Writable where applicable
- added stlmfs tag in $SUBJECT
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 521 +++++++++++++++---
1 file changed, 430 insertions(+), 91 deletions(-)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index df45fc212e13..9cb8779d2b59 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -42,12 +42,14 @@ enum {
Opt_uid,
Opt_gid,
Opt_umask,
+ Opt_lazy,
};
static const struct fs_parameter_spec stlmfs_param_spec[] = {
fsparam_uid("uid", Opt_uid),
fsparam_gid("gid", Opt_gid),
fsparam_u32oct("umask", Opt_umask),
+ fsparam_flag_no("lazy", Opt_lazy),
{}
};
@@ -56,18 +58,29 @@ struct stlmfs_fs_context {
kuid_t uid;
kgid_t gid;
umode_t umask;
+ bool lazy;
+};
+
+struct stlmfs_lazy_tracker {
+ bool des;
+ bool grps;
+ bool topo;
};
struct stlmfs_sb_info {
kuid_t uid;
kgid_t gid;
umode_t umask;
+ bool lazy;
+ unsigned int num_inst;
+ struct stlmfs_lazy_tracker populated[] __counted_by(num_inst);
};
static struct kmem_cache *stlmfs_inode_cachep;
static DEFINE_MUTEX(stlmfs_mtx);
static struct super_block *stlmfs_sb;
+static unsigned int stlmfs_instances;
static atomic_t scmi_tlm_instance_count = ATOMIC_INIT(0);
@@ -134,9 +147,11 @@ struct scmi_tlm_class {
#define TLM_IS_STATE BIT(0)
#define TLM_IS_GROUP BIT(1)
#define TLM_IS_DYNAMIC BIT(2)
+#define TLM_IS_LAZY BIT(3)
#define IS_STATE(_f) ((_f) & TLM_IS_STATE)
#define IS_GROUP(_f) ((_f) & TLM_IS_GROUP)
#define IS_DYNAMIC(_f) ((_f) & TLM_IS_DYNAMIC)
+#define IS_LAZY(_f) ((_f) & TLM_IS_LAZY)
const struct file_operations *f_op;
const struct inode_operations *i_op;
};
@@ -166,6 +181,10 @@ struct scmi_tlm_class {
* @info: SCMI instance information data reference.
* @vfs_inode: The embedded VFS inode that will be initialized and plugged
* into the live filesystem at mount time.
+ * @node: List item field.
+ * @children: A list containing all the children of this node.
+ * @num_children: Number of items stored in the @children list.
+ * @mtx: A mutex to protect the @children list.
*
* This structure is used to describe each SCMI Telemetry entity discovered
* at probe time, store its related SCMI data, and link to the proper
@@ -181,6 +200,11 @@ struct scmi_tlm_inode {
const struct scmi_telemetry_info *info;
};
struct inode vfs_inode;
+ struct list_head node;
+ struct list_head children;
+ unsigned int num_children;
+ /* Mutext to protect @children list */
+ struct mutex mtx;
};
#define to_tlm_inode(t) container_of(t, struct scmi_tlm_inode, vfs_inode)
@@ -195,8 +219,6 @@ struct scmi_tlm_inode {
* struct scmi_tlm_instance - Telemetry instance descriptor
* @id: Progressive number identifying this probed instance; it will be used
* to name the top node at the root of this instance.
- * @res_enumerated: A flag to indicate if full resources enumeration has been
- * successfully performed.
* @name: Name to be used for the top root node of the instance. (tlm_<id>)
* @node: A node to link this in the list of all instances.
* @sb: A reference to the current super_block.
@@ -211,7 +233,6 @@ struct scmi_tlm_inode {
*/
struct scmi_tlm_instance {
int id;
- bool res_enumerated;
char name[MAX_INST_NAME];
struct list_head node;
struct super_block *sb;
@@ -224,6 +245,8 @@ struct scmi_tlm_instance {
const struct scmi_telemetry_info *info;
};
+static int scmi_telemetry_groups_initialize(const struct scmi_tlm_instance *ti);
+static int scmi_telemetry_topology_view_initialize(const struct scmi_tlm_instance *ti);
static int scmi_telemetry_instance_register(struct super_block *sb,
struct scmi_tlm_instance *ti);
@@ -778,12 +801,10 @@ stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
struct dentry *parent, const struct scmi_tlm_class *cls,
const void *priv)
{
- struct scmi_tlm_inode *tlmi;
+ struct scmi_tlm_inode *tlmi, *tlmi_parent;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
struct dentry *dentry;
- struct inode *inode;
-
- if (!parent)
- parent = sb->s_root;
+ struct inode *inode, *i_parent;
/*
* Bail-out when called on a bad tree, so that there is NO need to
@@ -792,7 +813,15 @@ stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
if (IS_ERR(parent))
return parent;
- dentry = simple_start_creating(parent, cls->name);
+ i_parent = d_inode(parent);
+ if (!i_parent)
+ return ERR_PTR(-ENOENT);
+
+ if (!sbi->lazy)
+ dentry = simple_start_creating(parent, cls->name);
+ else
+ dentry = d_alloc_name(parent, cls->name);
+
if (IS_ERR(dentry))
return dentry;
@@ -815,14 +844,24 @@ stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
inode->i_private = (void *)priv;
tlmi = to_tlm_inode(inode);
-
tlmi->cls = cls;
tlmi->tsp = tsp;
tlmi->priv = priv;
+ tlmi_parent = to_tlm_inode(i_parent);
+ if (sbi->lazy && tlmi_parent->cls && IS_LAZY(tlmi_parent->cls->flags)) {
+ scoped_guard(mutex, &tlmi_parent->mtx) {
+ list_add(&tlmi->node, &tlmi_parent->children);
+ tlmi_parent->num_children++;
+ }
+ }
+
d_make_persistent(dentry, inode);
- simple_done_creating(dentry);
+ if (!sbi->lazy)
+ simple_done_creating(dentry);
+ else
+ dput(dentry);
return dentry;
}
@@ -1477,8 +1516,6 @@ static const struct scmi_tlm_class tlm_tops[] = {
DEFINE_TLM_CLASS(reset_tlmo, "reset", 0, S_IFREG | 0200, &reset_fops, NULL);
-DEFINE_TLM_CLASS(des_dir_cls, "des", 0,
- S_IFDIR | 0700, NULL, NULL);
DEFINE_TLM_CLASS(name_tlmo, "name", 0,
S_IFREG | 0444, &string_ro_fops, NULL);
DEFINE_TLM_CLASS(ena_tlmo, "enable", TLM_IS_STATE,
@@ -1550,48 +1587,72 @@ static int scmi_telemetry_de_populate(struct super_block *sb,
return 0;
}
+static struct dentry *
+scmi_telemetry_subdir_create(struct super_block *sb, struct scmi_tlm_setup *tsp,
+ const char *dname, struct dentry *parent,
+ const void *priv)
+{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ struct dentry *dentry;
+
+ struct scmi_tlm_class *tlm_cls __free(kfree) =
+ kzalloc(sizeof(*tlm_cls), GFP_KERNEL);
+ if (!tlm_cls)
+ return ERR_PTR(-ENOMEM);
+
+ tlm_cls->name = dname;
+ tlm_cls->mode = S_IFDIR | 0755;
+ tlm_cls->flags = TLM_IS_DYNAMIC;
+ if (sbi->lazy)
+ tlm_cls->flags |= TLM_IS_LAZY;
+ dentry = stlmfs_create_dentry(sb, tsp, parent, tlm_cls, priv);
+ if (IS_ERR(dentry))
+ return dentry;
+
+ retain_and_null_ptr(tlm_cls);
+
+ return dentry;
+}
+
static int
-scmi_telemetry_des_lazy_enumerate(struct scmi_tlm_instance *ti,
- const struct scmi_telemetry_res_info *rinfo)
+scmi_telemetry_des_enumerate(const struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_res_info *rinfo)
{
struct scmi_tlm_setup *tsp = ti->tsp;
struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
for (int i = 0; i < rinfo->num_des; i++) {
const struct scmi_telemetry_de *de = rinfo->des[i];
struct dentry *de_dir_dentry;
int ret;
- struct scmi_tlm_class *de_tlm_cls __free(kfree) =
- kzalloc(sizeof(*de_tlm_cls), GFP_KERNEL);
- if (!de_tlm_cls)
- return -ENOMEM;
-
- de_tlm_cls->name = kasprintf(GFP_KERNEL, "0x%08X", de->info->id);
- if (!de_tlm_cls->name)
+ const char *dname __free(kfree) =
+ kasprintf(GFP_KERNEL, "0x%08X", de->info->id);
+ if (!dname)
return -ENOMEM;
- de_tlm_cls->mode = S_IFDIR | 0700;
- de_tlm_cls->flags = TLM_IS_DYNAMIC;
- de_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->des_dentry,
- de_tlm_cls, de);
+ de_dir_dentry = scmi_telemetry_subdir_create(sb, tsp, dname,
+ ti->des_dentry, de);
+ if (IS_ERR(de_dir_dentry))
+ return PTR_ERR(de_dir_dentry);
ret = scmi_telemetry_de_populate(sb, tsp, de_dir_dentry, de,
rinfo->fully_enumerated);
if (ret)
return ret;
- retain_and_null_ptr(de_tlm_cls);
+ retain_and_null_ptr(dname);
}
- ti->res_enumerated = true;
+ sbi->populated[ti->id].des = true;
dev_info(tsp->dev, "Found %d Telemetry DE resources.\n", rinfo->num_des);
return 0;
}
-static int scmi_telemetry_des_initialize(struct scmi_tlm_instance *ti)
+static int scmi_telemetry_des_initialize(const struct scmi_tlm_instance *ti)
{
const struct scmi_telemetry_res_info *rinfo;
@@ -1599,9 +1660,196 @@ static int scmi_telemetry_des_initialize(struct scmi_tlm_instance *ti)
if (!rinfo)
return -ENODEV;
- return scmi_telemetry_des_lazy_enumerate(ti, rinfo);
+ return scmi_telemetry_des_enumerate(ti, rinfo);
+}
+
+static inline struct dentry *
+scmi_telemetry_dentry_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct dentry *d, *dentry_dir;
+
+ const char *dname __free(kfree) =
+ kmemdup_nul(dentry->d_name.name, dentry->d_name.len, GFP_KERNEL);
+ if (!dname)
+ return ERR_PTR(-ENOMEM);
+
+ dentry_dir = d_find_alias(dir);
+ if (!dentry_dir)
+ return simple_lookup(dir, dentry, flags);
+
+ d = stlmfs_lookup_by_name(dentry_dir, dname);
+ dput(dentry_dir);
+
+ return d;
+}
+
+static struct dentry *
+stlmfs_lazy_des_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(dir);
+ struct scmi_tlm_instance *ti = (struct scmi_tlm_instance *)tlmi->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ int ret;
+
+ if (sbi->populated[ti->id].des)
+ return simple_lookup(dir, dentry, flags);
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ERR_PTR(ret);
+
+ return scmi_telemetry_dentry_lookup(dir, dentry, flags);
+}
+
+static const struct inode_operations lazy_des_dir_iops = {
+ .lookup = stlmfs_lazy_des_lookup,
+};
+
+static struct dentry *
+stlmfs_lazy_grps_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(dir);
+ struct scmi_tlm_instance *ti = (struct scmi_tlm_instance *)tlmi->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ int ret;
+
+ if (sbi->populated[ti->id].grps)
+ return simple_lookup(dir, dentry, flags);
+
+ ret = scmi_telemetry_groups_initialize(ti);
+ if (ret)
+ return ERR_PTR(ret);
+
+ return scmi_telemetry_dentry_lookup(dir, dentry, flags);
+}
+
+static const struct inode_operations lazy_grps_dir_iops = {
+ .lookup = stlmfs_lazy_grps_lookup,
+};
+
+static struct dentry *
+stlmfs_lazy_compo_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(dir);
+ struct scmi_tlm_instance *ti = (struct scmi_tlm_instance *)tlmi->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ int ret;
+
+ if (sbi->populated[ti->id].topo)
+ return simple_lookup(dir, dentry, flags);
+
+ ret = scmi_telemetry_topology_view_initialize(ti);
+ if (ret)
+ return ERR_PTR(ret);
+
+ return scmi_telemetry_dentry_lookup(dir, dentry, flags);
}
+static const struct inode_operations lazy_compo_dir_iops = {
+ .lookup = stlmfs_lazy_compo_lookup,
+};
+
+static inline void
+scmi_telemetry_children_dir_emit(struct dir_context *ctx,
+ struct scmi_tlm_inode *tlmi_parent)
+{
+ struct scmi_tlm_inode *tlmi;
+
+ if (ctx->pos >= tlmi_parent->num_children)
+ return;
+
+ guard(mutex)(&tlmi_parent->mtx);
+ list_for_each_entry(tlmi, &tlmi_parent->children, node) {
+ if (!dir_emit(ctx, tlmi->cls->name, strlen(tlmi->cls->name),
+ tlmi->vfs_inode.i_ino,
+ S_ISDIR(tlmi->cls->mode) ? DT_DIR : DT_REG))
+ break;
+ ctx->pos++;
+ }
+}
+
+static int
+stlmfs_lazy_des_iterate_shared(struct file *filp, struct dir_context *ctx)
+{
+ struct scmi_tlm_inode *tlmi_des = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_instance *ti = tlmi_des->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
+ if (!sbi->populated[ti->id].des) {
+ int ret;
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
+ scmi_telemetry_children_dir_emit(ctx, tlmi_des);
+
+ return 0;
+}
+
+static const struct file_operations lazy_des_fops = {
+ .iterate_shared = stlmfs_lazy_des_iterate_shared,
+};
+
+static int
+stlmfs_lazy_grps_iterate_shared(struct file *filp, struct dir_context *ctx)
+{
+ struct scmi_tlm_inode *tlmi_des = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_instance *ti = tlmi_des->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
+ if (!sbi->populated[ti->id].grps) {
+ int ret;
+
+ ret = scmi_telemetry_groups_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
+ scmi_telemetry_children_dir_emit(ctx, tlmi_des);
+
+ return 0;
+}
+
+static const struct file_operations lazy_grps_fops = {
+ .iterate_shared = stlmfs_lazy_grps_iterate_shared,
+};
+
+static int
+stlmfs_lazy_compo_iterate_shared(struct file *filp, struct dir_context *ctx)
+{
+ struct scmi_tlm_inode *tlmi_des = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_instance *ti = tlmi_des->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
+ if (!sbi->populated[ti->id].topo) {
+ int ret;
+
+ ret = scmi_telemetry_topology_view_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
+ scmi_telemetry_children_dir_emit(ctx, tlmi_des);
+
+ return 0;
+}
+
+static const struct file_operations lazy_compo_fops = {
+ .iterate_shared = stlmfs_lazy_compo_iterate_shared,
+};
+
DEFINE_TLM_CLASS(version_tlmo, "version", 0,
S_IFREG | 0444, &sa_x32_ro_fops, NULL);
@@ -1728,8 +1976,6 @@ static const struct scmi_tlm_class tlm_grps[] = {
DEFINE_TLM_CLASS(grp_data_tlmo, "des_bulk_read", TLM_IS_GROUP,
S_IFREG | 0444, &scmi_tlm_data_fops, NULL);
-DEFINE_TLM_CLASS(groups_dir_cls, "groups", 0, S_IFDIR | 0700, NULL, NULL);
-
DEFINE_TLM_CLASS(grp_single_sample_tlmo, "des_single_sample_read", TLM_IS_GROUP,
S_IFREG | 0444, &scmi_tlm_single_sample_fops, NULL);
@@ -2146,67 +2392,85 @@ DEFINE_TLM_CLASS(ctrl_tlmo, "control", 0,
DEFINE_TLM_CLASS(grp_ctrl_tlmo, "control", TLM_IS_GROUP,
S_IFREG | 0666, &scmi_tlm_ctrl_fops, NULL);
-static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
+static int
+scmi_telemetry_grp_populate(struct super_block *sb, struct scmi_tlm_setup *tsp,
+ struct dentry *parent,
+ const struct scmi_telemetry_group *grp,
+ bool single_read_support,
+ bool per_group_config_support)
+{
+ for (const struct scmi_tlm_class *gto = tlm_grps; gto->name; gto++)
+ stlmfs_create_dentry(sb, tsp, parent, gto, grp);
+
+ stlmfs_create_dentry(sb, tsp, parent, &grp_composing_des_tlmo,
+ grp->des_str);
+
+ stlmfs_create_dentry(sb, tsp, parent, &grp_ctrl_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, parent, &grp_data_tlmo, grp);
+ if (single_read_support)
+ stlmfs_create_dentry(sb, tsp, parent, &grp_single_sample_tlmo, grp);
+
+ if (per_group_config_support) {
+ stlmfs_create_dentry(sb, tsp, parent,
+ &grp_current_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, parent,
+ &grp_available_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, parent,
+ &grp_intervals_discrete_tlmo, grp);
+ }
+
+ return 0;
+}
+
+static int
+scmi_telemetry_groups_enumerate(const struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_res_info *rinfo)
{
- const struct scmi_telemetry_res_info *rinfo;
struct scmi_tlm_setup *tsp = ti->tsp;
struct super_block *sb = ti->sb;
- struct device *dev = tsp->dev;
- struct dentry *grp_dir_dentry;
-
- if (ti->info->base.num_groups == 0)
- return 0;
-
- rinfo = scmi_telemetry_res_info_get(tsp);
- if (!rinfo)
- return -ENODEV;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
for (int i = 0; i < rinfo->num_groups; i++) {
- const struct scmi_telemetry_group *grp = &rinfo->grps[i];
-
- struct scmi_tlm_class *grp_tlm_cls __free(kfree) =
- kzalloc(sizeof(*grp_tlm_cls), GFP_KERNEL);
- if (!grp_tlm_cls)
- return -ENOMEM;
+ struct dentry *grp_dentry;
+ int ret;
- grp_tlm_cls->name = kasprintf(GFP_KERNEL, "%u", grp->info->id);
- if (!grp_tlm_cls->name)
+ const char *dname __free(kfree) =
+ kasprintf(GFP_KERNEL, "%u", rinfo->grps[i].info->id);
+ if (!dname)
return -ENOMEM;
- grp_tlm_cls->mode = S_IFDIR | 0700;
- grp_tlm_cls->flags = TLM_IS_DYNAMIC;
+ grp_dentry = scmi_telemetry_subdir_create(sb, tsp, dname,
+ ti->grps_dentry,
+ &rinfo->grps[i]);
+ if (IS_ERR(grp_dentry))
+ return PTR_ERR(grp_dentry);
- grp_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->grps_dentry,
- grp_tlm_cls, grp);
+ ret = scmi_telemetry_grp_populate(sb, tsp, grp_dentry,
+ &rinfo->grps[i],
+ ti->info->single_read_support,
+ ti->info->per_group_config_support);
+ if (ret)
+ return ret;
- for (const struct scmi_tlm_class *gto = tlm_grps; gto->name; gto++)
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry, gto, grp);
+ retain_and_null_ptr(dname);
+ }
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_composing_des_tlmo, grp->des_str);
+ sbi->populated[ti->id].grps = true;
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_ctrl_tlmo, grp);
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_data_tlmo, grp);
- if (ti->info->single_read_support)
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_single_sample_tlmo, grp);
+ dev_info(tsp->dev, "Found %d Telemetry GROUPS resources.\n", rinfo->num_groups);
- if (ti->info->per_group_config_support) {
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_current_interval_tlmo, grp);
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_available_interval_tlmo, grp);
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_intervals_discrete_tlmo, grp);
- }
+ return 0;
+}
- retain_and_null_ptr(grp_tlm_cls);
- }
+static int scmi_telemetry_groups_initialize(const struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
- dev_info(dev, "Found %d Telemetry GROUPS resources.\n",
- rinfo->num_groups);
+ rinfo = scmi_telemetry_res_info_get(ti->tsp);
+ if (!rinfo || !rinfo->fully_enumerated)
+ return -ENODEV;
- return 0;
+ return scmi_telemetry_groups_enumerate(ti, rinfo);
}
static struct scmi_tlm_instance *scmi_tlm_init(struct scmi_tlm_setup *tsp,
@@ -2263,6 +2527,7 @@ static int scmi_telemetry_probe(struct scmi_device *sdev)
mutex_lock(&stlmfs_mtx);
list_add(&ti->node, &scmi_telemetry_instances);
+ stlmfs_instances++;
sb = stlmfs_sb;
mutex_unlock(&stlmfs_mtx);
@@ -2320,6 +2585,9 @@ static struct inode *stlmfs_alloc_inode(struct super_block *sb)
return NULL;
tlmi->cls = NULL;
+ mutex_init(&tlmi->mtx);
+ INIT_LIST_HEAD(&tlmi->children);
+ tlmi->num_children = 0;
return &tlmi->vfs_inode;
}
@@ -2346,6 +2614,8 @@ static int stlmfs_show_options(struct seq_file *seq, struct dentry *root)
seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, sbi->gid));
if (sbi->umask != SCMI_TLM_DEFAULT_UMASK)
seq_printf(seq, ",umask=%04u", sbi->umask);
+ if (sbi->lazy)
+ seq_printf(seq, ",lazy");
return 0;
}
@@ -2423,6 +2693,7 @@ scmi_telemetry_topology_path_get(struct super_block *sb,
struct scmi_tlm_setup *tsp,
struct dentry *parent, const char *dname)
{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
struct dentry *dentry;
dentry = stlmfs_lookup_by_name(parent, dname);
@@ -2438,6 +2709,8 @@ scmi_telemetry_topology_path_get(struct super_block *sb,
dir_tlm_cls->mode = S_IFDIR | 0755;
dir_tlm_cls->flags = TLM_IS_DYNAMIC;
+ if (sbi->lazy)
+ dir_tlm_cls->flags |= TLM_IS_LAZY;
dentry = stlmfs_create_dentry(sb, tsp, parent,
dir_tlm_cls, NULL);
@@ -2449,7 +2722,7 @@ scmi_telemetry_topology_path_get(struct super_block *sb,
}
static int scmi_telemetry_topology_add_node(struct super_block *sb,
- struct scmi_tlm_instance *ti,
+ const struct scmi_tlm_instance *ti,
const struct scmi_telemetry_de *de)
{
struct dentry *ctype, *cinst, *cunit, *dinst;
@@ -2490,21 +2763,19 @@ static int scmi_telemetry_topology_add_node(struct super_block *sb,
return ret;
}
-DEFINE_TLM_CLASS(compo_dir_cls, "by-components", 0, S_IFDIR | 0700, NULL, NULL);
-
-static int scmi_telemetry_topology_view_add(struct scmi_tlm_instance *ti)
+static int
+scmi_telemetry_topology_view_initialize(const struct scmi_tlm_instance *ti)
{
const struct scmi_telemetry_res_info *rinfo;
struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
struct device *dev = tsp->dev;
rinfo = scmi_telemetry_res_info_get(tsp);
if (!rinfo || !rinfo->fully_enumerated)
return -ENODEV;
- ti->compo_dentry =
- stlmfs_create_dentry(ti->sb, tsp, ti->top_dentry, &compo_dir_cls, NULL);
-
for (int i = 0; i < rinfo->num_des; i++) {
int ret;
@@ -2514,13 +2785,51 @@ static int scmi_telemetry_topology_view_add(struct scmi_tlm_instance *ti)
rinfo->des[i]->info->name);
}
+ sbi->populated[ti->id].topo = true;
+
+ if (sbi->lazy && !sbi->populated[ti->id].des) {
+ int ret;
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
return 0;
}
+static struct dentry *
+scmi_telemetry_top_dentry_create(struct scmi_tlm_instance *ti, bool lazy,
+ const char *dname, struct dentry *parent,
+ const struct file_operations *lazy_fops,
+ const struct inode_operations *lazy_dir_iops,
+ void *priv)
+{
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+
+ struct scmi_tlm_class *tlm_cls __free(kfree) =
+ kzalloc(sizeof(*tlm_cls), GFP_KERNEL);
+ if (!tlm_cls)
+ return ERR_PTR(-ENOMEM);
+
+ tlm_cls->name = kasprintf(GFP_KERNEL, "%s", dname);
+ tlm_cls->mode = S_IFDIR | 0755;
+ tlm_cls->flags = TLM_IS_DYNAMIC;
+ if (lazy) {
+ tlm_cls->flags |= TLM_IS_LAZY;
+ tlm_cls->f_op = lazy_fops;
+ tlm_cls->i_op = lazy_dir_iops;
+ }
+
+ return stlmfs_create_dentry(sb, tsp, parent, no_free_ptr(tlm_cls), priv);
+}
+
static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
{
struct scmi_tlm_setup *tsp = ti->tsp;
struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
scnprintf(ti->name, MAX_INST_NAME, "tlm_%d", ti->id);
@@ -2543,10 +2852,25 @@ static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
stlmfs_create_dentry(sb, tsp, ti->top_dentry,
&single_sample_tlmo, ti->info);
stlmfs_create_dentry(sb, tsp, ti->top_dentry, &ctrl_tlmo, ti->info);
- ti->des_dentry =
- stlmfs_create_dentry(sb, tsp, ti->top_dentry, &des_dir_cls, NULL);
- ti->grps_dentry =
- stlmfs_create_dentry(sb, tsp, ti->top_dentry, &groups_dir_cls, NULL);
+
+ ti->des_dentry = scmi_telemetry_top_dentry_create(ti, sbi->lazy, "des",
+ ti->top_dentry,
+ &lazy_des_fops,
+ &lazy_des_dir_iops,
+ ti);
+
+ ti->grps_dentry = scmi_telemetry_top_dentry_create(ti, sbi->lazy, "groups",
+ ti->top_dentry,
+ &lazy_grps_fops,
+ &lazy_grps_dir_iops,
+ ti);
+
+ ti->compo_dentry = scmi_telemetry_top_dentry_create(ti, sbi->lazy,
+ "by-components",
+ ti->top_dentry,
+ &lazy_compo_fops,
+ &lazy_compo_dir_iops,
+ ti);
return 0;
}
@@ -2554,6 +2878,7 @@ static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
static int scmi_telemetry_instance_register(struct super_block *sb,
struct scmi_tlm_instance *ti)
{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
int ret;
ti->sb = sb;
@@ -2561,6 +2886,9 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
if (ret)
return ret;
+ if (sbi->lazy)
+ return 0;
+
ret = scmi_telemetry_des_initialize(ti);
if (ret)
return ret;
@@ -2572,11 +2900,12 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
ti->top_cls.name);
}
- ret = scmi_telemetry_topology_view_add(ti);
- if (ret)
+ ret = scmi_telemetry_topology_view_initialize(ti);
+ if (ret) {
dev_warn(ti->tsp->dev,
"Failed to create topology view for instance %s.\n",
ti->top_cls.name);
+ }
return 0;
}
@@ -2593,11 +2922,13 @@ static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
return 0;
struct stlmfs_sb_info *sbi __free(kfree) =
- kzalloc(sizeof(*sbi), GFP_KERNEL);
+ kzalloc(struct_size(sbi, populated, stlmfs_instances), GFP_KERNEL);
if (!sbi)
return -ENOMEM;
ctx = fc->fs_private;
+ sbi->num_inst = stlmfs_instances;
+ sbi->lazy = ctx->lazy;
sbi->uid = ctx->uid;
sbi->gid = ctx->gid;
sbi->umask = ctx->umask;
@@ -2673,6 +3004,10 @@ static int stlmfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
ctx->umask = result.uint_32 & 07777;
ctx->opts |= BIT(Opt_umask);
break;
+ case Opt_lazy:
+ ctx->lazy = result.boolean;
+ ctx->opts |= BIT(Opt_lazy);
+ break;
default:
return -ENOPARAM;
}
@@ -2692,6 +3027,8 @@ static int stlmfs_reconfigure(struct fs_context *fc)
return invalfc(fc, "gid cannot be changed on remount");
if (ctx->opts & BIT(Opt_umask))
return invalfc(fc, "umask cannot be changed on remount");
+ if (ctx->opts & BIT(Opt_lazy))
+ return invalfc(fc, "lazy cannot be changed on remount");
return 0;
}
@@ -2712,6 +3049,7 @@ static int stlmfs_init_fs_context(struct fs_context *fc)
return -ENOMEM;
/* defaults */
+ ctx->lazy = false;
ctx->uid = GLOBAL_ROOT_UID;
ctx->gid = GLOBAL_ROOT_GID;
ctx->umask = SCMI_TLM_DEFAULT_UMASK;
@@ -2740,6 +3078,7 @@ static struct file_system_type scmi_telemetry_fs = {
.name = TLM_FS_NAME,
.kill_sb = stlmfs_kill_sb,
.init_fs_context = stlmfs_init_fs_context,
+ .parameters = stlmfs_param_spec,
.fs_flags = 0,
};
--
2.54.0
^ permalink raw reply related
* [PATCH v4 28/31] [RFC] docs: stlmfs: Document ARM SCMI Telemetry FS ABI
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add full ABI dcoumentation for stlmfs under testing/
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- renamed to by-components
- updated date/versions
- changed output of des/0x<NNN>/value to -> <tstamp> <value>
(removed colon)
- added Rationale and Concurrency model
- added generation counter Description
v2 --> v3
- complete ABI entries docs
RFC since unsure if place this into stable/ or testing/
---
Documentation/ABI/testing/stlmfs | 348 +++++++++++++++++++++++++++++++
1 file changed, 348 insertions(+)
create mode 100644 Documentation/ABI/testing/stlmfs
diff --git a/Documentation/ABI/testing/stlmfs b/Documentation/ABI/testing/stlmfs
new file mode 100644
index 000000000000..826092a4baf4
--- /dev/null
+++ b/Documentation/ABI/testing/stlmfs
@@ -0,0 +1,348 @@
+What: /sys/fs/arm_telemetry/tlm_<N>/...
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Rationale: This filesystem provides access to SCMI telemetry data and
+ configuration.
+ The interface is required to support:
+ - hierarchical dynamically discovered telemetry objects
+ - bulk data read across multiple sources
+ - representation of complex structured data and their
+ relationship
+ - alternative high-frequency data access (ioctl/mmap)
+ These characteristics exceed the intended use of sysfs, which is
+ designed to represent devices properties with simple attribute
+ based configuration with one value per file: representing
+ telemetry Data Events with devices was deemed an abuse by
+ itself.
+ A dedicated filesystem is therefore used to provide a more
+ suitable abstraction for this class of functionality.
+
+Concurrency: The telemetry configuration exposed through this filesystem is
+ global to each SCMI telemetry instance, indentified by the top
+ tlm_<N> directory.
+ Concurrent access from multiple user-space processes is allowed.
+ The kernel does not enforce exclusivity or ownership of the
+ interface.
+ All configuration changes are applied immediately by issuing
+ the related SCMI commands. Writes to different attributes may
+ interleave and no atomicity across multiple files is guaranteed.
+ In case of concurrent writes to the same attribute, the last
+ writer wins.
+ Read operations may observe state that has been already modified
+ and it is stale.
+ Userspace is responsible for coordinating access if stronger
+ consistency or serialization is required and this filesystem
+ provides a generation counter to aid in the detection of sudden
+ configuration changes.
+
+What: /sys/fs/arm_telemetry/tlm_<N>/all_des_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean WO entry to enable all the discovered Data Events for
+ SCMI instance <N>.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/all_tstamp_des_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean WO entry to enable timestamps for all the discovered
+ Data Events for SCMI instance <N>. (when available)
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/available_update_intervals_ms
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a space separated list of tuples of
+ values, separated by a coma, each one representing a
+ configurable update interval for SCMI instance <N>.
+ Each tuple describes a possible update interval using the
+ format <secs>,<exp> where the final represented interval is
+ calculated as: <secs> * 10 ^ <exp>
+ An example of list of tuples that can be read from this entry:
+ 3,0 4,-1 75,-2 300,-3 1,1 5,3 222,-7
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/by-components/
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A subdirectory that exposes an alternative topological view of
+ the same set of discovered DEs that can be already found under
+ the des/ branch.
+ This topology subtree is built following this structure:
+ by-components/
+ ├── <COMPO_TYPE_STR>
+ │ ├── <COMPO_ISTANCE_ID>
+ │ │ ├── <DE_UNIT_TYPE_STR>
+ │ │ │ └── <DE_INSTANCE_ID>
+ │ │ │ └── 0x<DE_ID>[<DE_NAME>] -> ../../../../../des/0x<DE_ID>
+
+ The leaves are actual symlinks to an existing des/0x<DE_ID>
+ subdirectory, while the naming of the subdirectories composing
+ the inner nodes of the subtree are derived from the DataEvent
+ Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/control
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An RW entry that can be used to discover, configure and retrieve
+ Telemetry data using the alternative binary interface based on
+ ioctls which is documented in include/uapi/linux/scmi.h
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/current_update_intervals_ms
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An RW entry that can be used to get or set the platform update
+ interval for SCMI instance <N>.
+ On read the returned tuple represents the current update
+ interval using the format <secs>,<exp> where the final
+ represented interval is calculated as: <secs> * 10 ^ <exp>
+ On write the accepted format is the same as on read <secs>,<exp>
+ but, optionally, the second element of the tuple can be omitted
+ and in that case the assumed value for the exponent will default
+ to -3, i.e. milliseconds.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/de_implementation_version
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a string representing the 128bit UUID
+ that uniquely identifies the set of SCMI Telemetry Data Events
+ and their semantic for SCMI instance <N>.
+ This is compliant with the DE_IMPLEMENTATION_REVISION described
+ in SCMI v4.0 Telemetry 3.12.4.3.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des_bulk_read
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a multi-line string containing all the
+ the DEs enabled for SCMI instance <N>, one-per-line, formatted
+ as: <DE_ID> <TIMESTAMP> <DATA_VALUE>
+ These DEs readings represent the last value updated by the
+ platform following the configured update interval: on the
+ backend they will have been collected transparently in a number
+ of different ways: on-demand SHMTI lookup, notifications,
+ fastchannels. Data consistency is guaranteed by the underlying
+ SCMI synchronization mechanisms.
+ Any disabled or unavailable DE is simply NOT included.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des_single_sample_read
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a multi-line string containing all the
+ the DEs enabled for SCMI instance <N>, one-per-line, formmatted
+ as: <DE_ID> <TIMESTAMP> <DATA_VALUE>
+ These DEs readings are generated by triggering an explicit and
+ immediate platform update using single sample asynchronous
+ collect methods.
+ Any disabled or unavailable DE is simply NOT included.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/generation
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns an integer representing the number of
+ configuration changes applied using any entry in this interface:
+ any read, following the first one after the open, blocks until
+ the next configuration change is applied and the counter is
+ increased: this entry supports poll/select system calls to ease
+ the monitoring process.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/intervals_discrete
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean RO entry to specify if the intervals reported for
+ SCMI instance <N> in available_update_intervals_ms are a list of
+ discrete intervals or a triplet of values representing
+ <LOWEST_UPDATE_INTERVAL> <HIGHEST_UPDATE_INTERVAL> <STEP_SIZE>.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/reset
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean WO entry that can be used the full reset of the SCMI
+ Telemetry subsystem, both of the configurations and of the
+ collected data, as specified in SCMI v4.0 3.12.4.12
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/tlm_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean RW entry that can be used to get or set the general
+ enable status of the Telemetry subsystem. Temporarily disabling
+ Telemetry as a whole does NOT reset the current configuration,
+ it only stops all the configured DEs updates platform side.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/version
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry used to report the SCMI Telemetry protocol version
+ used in this implementation.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/compo_instance_id
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the component instance to which this DE
+ belongs, as described by the DataEvent Descriptor in SCMI v4.0
+ 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/compo_type
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the component type to which this DE is
+ associated, as described by the DataEvent Descriptor in SCMI v4.0
+ 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/instance_id
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the DE instance ID that identifies this DE
+ within the component instance to which it belongs, as described
+ by the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/name
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A optional RO entry to report the name associated with this DE,
+ as described by the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/persistent
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO boolean to report that the DE data values are persistent
+ across all reboot cycles, except cold reboot, as described by
+ the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/tstamp_rate
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An optional RO entry to report the clock rate in KHZ used to
+ generate the timestamps associated to this DE, as described by
+ the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/type
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the type of DataEvent as described by the
+ DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/unit
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the unit of measurements used by this DE,
+ as described by the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/unit_exp
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the power-of-10 multiplier in two's
+ complement format that is applied to the unit specified by the
+ DE unit field, as described by the DataEvent Descriptor in SCMI
+ v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/value
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry used to read the last value and timestamp collected
+ for Data Event with id 0x<NNNNNNNN> for SCMI instance <N>.
+ The output is formatted as: <TIMESTAMP> <DATA_VALUE>
+ Reading from this entry can fail with:
+ -ENODATA: the DE itself, or the whole telemetry subsystem,
+ was in a disabled state at the time of the read.
+ -EINVAL: the data value associated to this DE is NOT usable
+ since it was found to have been internally marked as
+ DATA_INVALID; this could be due to a temporary or
+ permanent error condition of the underlying hardware
+ in charge of this DE data collection.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RW boolean entry used to enable or disable Data Event
+ with id 0x<NNNNNNNN> for SCMI instance <N>.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/tstamp_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An RW boolean entry used to enable or disable timestamping for
+ Data Event with id 0x<NNNNNNNN> for SCMI instance <N>.
+ This entry is optional and present only if the DE supports
+ timestamping.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/groups/<M>/
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A subdirectory containing entries that describe configurations
+ and values related to group <M> of SCMI instance <N>.
+ Most of the contained entries share the same names with some
+ other, already defined entries, elsewhere:
+
+ groups/0/
+ ├── available_update_intervals_ms
+ ├── control
+ ├── current_update_interval_ms
+ ├── des_bulk_read
+ ├── des_single_sample_read
+ ├── enable
+ ├── intervals_discrete
+ └── tstamp_enable
+
+ These homonyms carry the same syntax and semantic as the other
+ but they are usually restricted in their definitions to the
+ specific group <M>.
+ These common entries won't be described further again here.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/groups/<M>/composing_des
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that reports the space separated list of DataEvents
+ belonging to group <M> for SCMI instance <N>
+Users: Any userspace telemetry tool
--
2.54.0
^ permalink raw reply related
* [PATCH v4 27/31] firmware: arm_scmi: stlmfs: Add generation file
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a read-only generation file to be used for monitoring configuration
changes across an instance: first read after the open returns the current
value, then it blocks till next confiuration change is detected.
Generation file supports also poll system call to monitor chamges.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- added stlmfs tag in $SUBJECT
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 89 +++++++++++++++++++
1 file changed, 89 insertions(+)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index c83d9763d479..df45fc212e13 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -19,12 +19,14 @@
#include <linux/list.h>
#include <linux/module.h>
#include <linux/overflow.h>
+#include <linux/poll.h>
#include <linux/scmi_protocol.h>
#include <linux/slab.h>
#include <linux/sprintf.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/uaccess.h>
+#include <linux/wait.h>
#include <uapi/linux/scmi.h>
@@ -1368,6 +1370,91 @@ static const struct file_operations available_interv_fops = {
.release = scmi_tlm_priv_release,
};
+struct scmi_tlm_gen_priv {
+ unsigned int last_seen;
+ struct wait_queue_head *wq;
+ struct scmi_tlm_buffer tb;
+};
+
+static int scmi_tlm_generation_open(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(ino);
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_gen_priv *gen;
+
+ gen = kzalloc_obj(*gen);
+ if (!gen)
+ return -ENOMEM;
+
+ gen->wq = tsp->ops->event_wq_get(tsp->ph);
+ if (!gen->wq) {
+ kfree(gen);
+ return -ENOMEM;
+ }
+
+ gen->last_seen = SCMI_TLM_GENERATION_INVALID;
+ filp->private_data = gen;
+
+ return nonseekable_open(ino, filp);
+}
+
+static ssize_t
+scmi_tlm_generation_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_gen_priv *gen = filp->private_data;
+ struct scmi_telemetry_info *info = (struct scmi_telemetry_info *)tlmi->priv;
+ unsigned int c;
+
+ if (*ppos == gen->tb.used)
+ gen->tb.used = *ppos = 0;
+
+ if (!gen->tb.used) {
+ int ret;
+
+ ret = wait_event_interruptible(*gen->wq,
+ (c = atomic_read(&info->generation)) !=
+ gen->last_seen);
+ if (ret)
+ return -ERESTARTSYS;
+
+ gen->last_seen = c;
+ gen->tb.used = scnprintf(gen->tb.buf, SCMI_TLM_MAX_BUF_SZ, "%u\n", c);
+ }
+
+ return simple_read_from_buffer(buf, count, ppos, gen->tb.buf, gen->tb.used);
+}
+
+static __poll_t scmi_tlm_generation_poll(struct file *filp, poll_table *wait)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_telemetry_info *info = (struct scmi_telemetry_info *)tlmi->priv;
+ struct scmi_tlm_gen_priv *gen = filp->private_data;
+
+ poll_wait(filp, gen->wq, wait);
+ if (atomic_read(&info->generation) != gen->last_seen)
+ return EPOLLIN | EPOLLRDNORM;
+
+ return 0;
+}
+
+static int scmi_tlm_generation_release(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_gen_priv *gen = filp->private_data;
+
+ kfree(gen);
+
+ return 0;
+}
+
+static const struct file_operations generation_fops = {
+ .open = scmi_tlm_generation_open,
+ .read = scmi_tlm_generation_read,
+ .poll = scmi_tlm_generation_poll,
+ .release = scmi_tlm_generation_release,
+};
+
static const struct scmi_tlm_class tlm_tops[] = {
TLM_ANON_CLASS("all_des_enable", TLM_IS_STATE,
S_IFREG | 0666, &all_des_fops, NULL),
@@ -1383,6 +1470,8 @@ static const struct scmi_tlm_class tlm_tops[] = {
S_IFREG | 0444, &de_impl_vers_fops, NULL),
TLM_ANON_CLASS("tlm_enable", 0,
S_IFREG | 0666, &tlm_enable_fops, NULL),
+ TLM_ANON_CLASS("generation", 0,
+ S_IFREG | 0444, &generation_fops, NULL),
TLM_ANON_CLASS(NULL, 0, 0, NULL, NULL),
};
--
2.54.0
^ permalink raw reply related
* [PATCH v4 26/31] fs/stlmfs: Document alternative topological view
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
The human readable interface presents an alternative view based on the
discovered topological relations between the DEs.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- renamed to by-components
v2 --> v3
- completed FS tree description
- renamed components to by_components
---
Documentation/filesystems/stlmfs.rst | 72 ++++++++++++++++++++++++++++
1 file changed, 72 insertions(+)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index 0c7b7c006709..b5b3cd649775 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -143,6 +143,7 @@ create the following directory structure::
|-- all_des_enable
|-- all_des_tstamp_enable
|-- available_update_intervals_ms
+ |-- by-components/
|-- control
|-- current_update_interval_ms
|-- de_implementation_version
@@ -233,6 +234,77 @@ values, as in::
|-- intervals_discrete
`-- tstamp_enable
+by-components/
+-----------
+
+An alternative topological view of the des/ directory based on the topology
+relationship information described in des/ ::
+
+ by-components/
+ ├── cpu
+ │ ├── 0
+ │ │ ├── celsius
+ │ │ │ └── 0
+ │ │ │ └── 0x00000001[pe_0] -> ../../../../../des/0x00000001
+ │ │ └── cycles
+ │ │ ├── 0
+ │ │ │ └── 0x00001010[] -> ../../../../../des/0x00001010
+ │ │ └── 1
+ │ │ └── 0x00002020[] -> ../../../../../des/0x00002020
+ │ ├── 1
+ │ │ └── celsius
+ │ │ └── 0
+ │ │ └── 0x00000002[pe_1] -> ../../../../../des/0x00000002
+ │ └── 2
+ │ └── celsius
+ │ └── 0
+ │ └── 0x00000003[pe_2] -> ../../../../../des/0x00000003
+ ├── interconnnect
+ │ └── 0
+ │ └── hertz
+ │ └── 0
+ │ ├── 0x0000A008[A008_de] -> ../../../../../des/0x0000A008
+ │ └── 0x0000A00B[] -> ../../../../../des/0x0000A00B
+ ├── mem_cntrl
+ │ └── 0
+ │ ├── bps
+ │ │ └── 0
+ │ │ └── 0x0000A00A[] -> ../../../../../des/0x0000A00A
+ │ ├── celsius
+ │ │ └── 0
+ │ │ └── 0x0000A007[DRAM_temp] -> ../../../../../des/0x0000A007
+ │ └── joules
+ │ └── 0
+ │ └── 0x0000A002[DRAM_energy] -> ../../../../../des/0x0000A002
+ ├── periph
+ │ ├── 0
+ │ │ └── messages
+ │ │ └── 0
+ │ │ └── 0x00000016[device_16] -> ../../../../../des/0x00000016
+ │ ├── 1
+ │ │ └── messages
+ │ │ └── 0
+ │ │ └── 0x00000017[device_17] -> ../../../../../des/0x00000017
+ │ └── 2
+ │ └── messages
+ │ └── 0
+ │ └── 0x00000018[device_18] -> ../../../../../des/0x00000018
+ └── unspec
+ └── 0
+ ├── celsius
+ │ └── 0
+ │ └── 0x0000A005[] -> ../../../../../des/0x0000A005
+ ├── counts
+ │ └── 0
+ │ └── 0x0000A00C[] -> ../../../../../des/0x0000A00C
+ ├── joules
+ │ └── 0
+ │ ├── 0x0000A000[SOC_Energy] -> ../../../../../des/0x0000A000
+ │ └── 0x0000A001[] -> ../../../../../des/0x0000A001
+ └── state
+ └── 0
+ └── 0x0000A010[] -> ../../../../../des/0x0000A010
+
Alternative Binary Interfaces - Special files
=============================================
--
2.54.0
^ permalink raw reply related
* [PATCH v4 25/31] firmware: arm_scmi: stlmfs: Add by-components view
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add an alternative filesystem view for the discovered Data Events, where
the tree of DEs is laid out following the discovered topological order
instead of the existing flat layout.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- make FS entries world-Readable and user-Writable where applicable
- renamed top dir to by-components
- use octal permissions
- added stlmfs tag in $SUBJECT
v2 --> v3
- renamed components to by_components
- fixed uninitialized variable in scmi_telemetry_de_subdir_symlink()
as reported by Elif
v1 --> v2
- Use new FS API
- Introduce new stlmfs_lookup_by_name helper
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 681 ++++++++++++++++++
1 file changed, 681 insertions(+)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index 720930f6bcd1..c83d9763d479 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -203,6 +203,7 @@ struct scmi_tlm_inode {
* @top_dentry: A reference to the top dentry for this instance.
* @des_dentry: A reference to the DES dentry for this instance.
* @grps_dentry: A reference to the groups dentry for this instance.
+ * @compo_dentry: A reference to the components dentry for this instance.
* @info: A handy reference to this instance SCMI Telemetry info data.
*
*/
@@ -217,6 +218,7 @@ struct scmi_tlm_instance {
struct dentry *top_dentry;
struct dentry *des_dentry;
struct dentry *grps_dentry;
+ struct dentry *compo_dentry;
const struct scmi_telemetry_info *info;
};
@@ -225,6 +227,526 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
static LIST_HEAD(scmi_telemetry_instances);
+#define TYPES_ARRAY_SZ 256
+
+static const char *compo_types[TYPES_ARRAY_SZ] = {
+ "unspec",
+ "cpu",
+ "cluster",
+ "gpu",
+ "npu",
+ "interconnnect",
+ "mem_cntrl",
+ "l1_cache",
+ "l2_cache",
+ "l3_cache",
+ "ll_cache",
+ "sys_cache",
+ "disp_cntrl",
+ "ipu",
+ "chiplet",
+ "package",
+ "soc",
+ "system",
+ "smcu",
+ "accel",
+ "battery",
+ "charger",
+ "pmic",
+ "board",
+ "memory",
+ "periph",
+ "periph_subc",
+ "lid",
+ "display",
+ "res_29",
+ "res_30",
+ "res_31",
+ "res_32",
+ "res_33",
+ "res_34",
+ "res_35",
+ "res_36",
+ "res_37",
+ "res_38",
+ "res_39",
+ "res_40",
+ "res_41",
+ "res_42",
+ "res_43",
+ "res_44",
+ "res_45",
+ "res_46",
+ "res_47",
+ "res_48",
+ "res_49",
+ "res_50",
+ "res_51",
+ "res_52",
+ "res_53",
+ "res_54",
+ "res_55",
+ "res_56",
+ "res_57",
+ "res_58",
+ "res_59",
+ "res_60",
+ "res_61",
+ "res_62",
+ "res_63",
+ "res_64",
+ "res_65",
+ "res_66",
+ "res_67",
+ "res_68",
+ "res_69",
+ "res_70",
+ "res_71",
+ "res_72",
+ "res_73",
+ "res_74",
+ "res_75",
+ "res_76",
+ "res_77",
+ "res_78",
+ "res_79",
+ "res_80",
+ "res_81",
+ "res_82",
+ "res_83",
+ "res_84",
+ "res_85",
+ "res_86",
+ "res_87",
+ "res_88",
+ "res_89",
+ "res_90",
+ "res_91",
+ "res_92",
+ "res_93",
+ "res_94",
+ "res_95",
+ "res_96",
+ "res_97",
+ "res_98",
+ "res_99",
+ "res_100",
+ "res_101",
+ "res_102",
+ "res_103",
+ "res_104",
+ "res_105",
+ "res_106",
+ "res_107",
+ "res_108",
+ "res_109",
+ "res_110",
+ "res_111",
+ "res_112",
+ "res_113",
+ "res_114",
+ "res_115",
+ "res_116",
+ "res_117",
+ "res_118",
+ "res_119",
+ "res_120",
+ "res_121",
+ "res_122",
+ "res_123",
+ "res_124",
+ "res_125",
+ "res_126",
+ "res_127",
+ "res_128",
+ "res_129",
+ "res_130",
+ "res_131",
+ "res_132",
+ "res_133",
+ "res_134",
+ "res_135",
+ "res_136",
+ "res_137",
+ "res_138",
+ "res_139",
+ "res_140",
+ "res_141",
+ "res_142",
+ "res_143",
+ "res_144",
+ "res_145",
+ "res_146",
+ "res_147",
+ "res_148",
+ "res_149",
+ "res_150",
+ "res_151",
+ "res_152",
+ "res_153",
+ "res_154",
+ "res_155",
+ "res_156",
+ "res_157",
+ "res_158",
+ "res_159",
+ "res_160",
+ "res_161",
+ "res_162",
+ "res_163",
+ "res_164",
+ "res_165",
+ "res_166",
+ "res_167",
+ "res_168",
+ "res_169",
+ "res_170",
+ "res_171",
+ "res_172",
+ "res_173",
+ "res_174",
+ "res_175",
+ "res_176",
+ "res_177",
+ "res_178",
+ "res_179",
+ "res_180",
+ "res_181",
+ "res_182",
+ "res_183",
+ "res_184",
+ "res_185",
+ "res_186",
+ "res_187",
+ "res_188",
+ "res_189",
+ "res_190",
+ "res_191",
+ "res_192",
+ "res_193",
+ "res_194",
+ "res_195",
+ "res_196",
+ "res_197",
+ "res_198",
+ "res_199",
+ "res_200",
+ "res_201",
+ "res_202",
+ "res_203",
+ "res_204",
+ "res_205",
+ "res_206",
+ "res_207",
+ "res_208",
+ "res_209",
+ "res_210",
+ "res_211",
+ "res_212",
+ "res_213",
+ "res_214",
+ "res_215",
+ "res_216",
+ "res_217",
+ "res_218",
+ "res_219",
+ "res_220",
+ "res_221",
+ "res_222",
+ "res_223",
+ "oem_224",
+ "oem_225",
+ "oem_226",
+ "oem_227",
+ "oem_228",
+ "oem_229",
+ "oem_230",
+ "oem_231",
+ "oem_232",
+ "oem_233",
+ "oem_234",
+ "oem_235",
+ "oem_236",
+ "oem_237",
+ "oem_238",
+ "oem_239",
+ "oem_240",
+ "oem_241",
+ "oem_242",
+ "oem_243",
+ "oem_244",
+ "oem_245",
+ "oem_246",
+ "oem_247",
+ "oem_248",
+ "oem_249",
+ "oem_250",
+ "oem_251",
+ "oem_252",
+ "oem_253",
+ "oem_254",
+ "oem_255",
+};
+
+static const char *unit_types[TYPES_ARRAY_SZ] = {
+ "none",
+ "unspec",
+ "celsius",
+ "fahrenheit",
+ "kelvin",
+ "volts",
+ "amps",
+ "watts",
+ "joules",
+ "coulombs",
+ "va",
+ "nits",
+ "lumens",
+ "lux",
+ "candelas",
+ "kpa",
+ "psi",
+ "newtons",
+ "cfm",
+ "rpm",
+ "hertz",
+ "seconds",
+ "minutes",
+ "hours",
+ "days",
+ "weeks",
+ "mils",
+ "inches",
+ "feet",
+ "cubic_inches",
+ "cubic_feet",
+ "meters",
+ "cubic_centimeters",
+ "cubic_meters",
+ "liters",
+ "fluid_ounces",
+ "radians",
+ "steradians",
+ "revolutions",
+ "cycles",
+ "gravities",
+ "ounces",
+ "pounds",
+ "foot_pounds",
+ "ounce_inches",
+ "gauss",
+ "gilberts",
+ "henries",
+ "farads",
+ "ohms",
+ "siemens",
+ "moles",
+ "becquerels",
+ "ppm",
+ "decibels",
+ "dba",
+ "dbc",
+ "grays",
+ "sieverts",
+ "color_temp_kelvin",
+ "bits",
+ "bytes",
+ "words",
+ "dwords",
+ "qwords",
+ "percentage",
+ "pascals",
+ "counts",
+ "grams",
+ "newton_meters",
+ "hits",
+ "misses",
+ "retries",
+ "overruns",
+ "underruns",
+ "collisions",
+ "packets",
+ "messages",
+ "chars",
+ "errors",
+ "corrected_err",
+ "uncorrectable_err",
+ "square_mils",
+ "square_inches",
+ "square_feet",
+ "square_centimeters",
+ "square_meters",
+ "radians_per_secs",
+ "beats_per_minute",
+ "meters_per_secs_squared",
+ "meters_per_secs",
+ "cubic_meter_per_secs",
+ "millimeters_mercury",
+ "radians_per_secs_squared",
+ "state",
+ "bps",
+ "res_96",
+ "res_97",
+ "res_98",
+ "res_99",
+ "res_100",
+ "res_101",
+ "res_102",
+ "res_103",
+ "res_104",
+ "res_105",
+ "res_106",
+ "res_107",
+ "res_108",
+ "res_109",
+ "res_110",
+ "res_111",
+ "res_112",
+ "res_113",
+ "res_114",
+ "res_115",
+ "res_116",
+ "res_117",
+ "res_118",
+ "res_119",
+ "res_120",
+ "res_121",
+ "res_122",
+ "res_123",
+ "res_124",
+ "res_125",
+ "res_126",
+ "res_127",
+ "res_128",
+ "res_129",
+ "res_130",
+ "res_131",
+ "res_132",
+ "res_133",
+ "res_134",
+ "res_135",
+ "res_136",
+ "res_137",
+ "res_138",
+ "res_139",
+ "res_140",
+ "res_141",
+ "res_142",
+ "res_143",
+ "res_144",
+ "res_145",
+ "res_146",
+ "res_147",
+ "res_148",
+ "res_149",
+ "res_150",
+ "res_151",
+ "res_152",
+ "res_153",
+ "res_154",
+ "res_155",
+ "res_156",
+ "res_157",
+ "res_158",
+ "res_159",
+ "res_160",
+ "res_161",
+ "res_162",
+ "res_163",
+ "res_164",
+ "res_165",
+ "res_166",
+ "res_167",
+ "res_168",
+ "res_169",
+ "res_170",
+ "res_171",
+ "res_172",
+ "res_173",
+ "res_174",
+ "res_175",
+ "res_176",
+ "res_177",
+ "res_178",
+ "res_179",
+ "res_180",
+ "res_181",
+ "res_182",
+ "res_183",
+ "res_184",
+ "res_185",
+ "res_186",
+ "res_187",
+ "res_188",
+ "res_189",
+ "res_190",
+ "res_191",
+ "res_192",
+ "res_193",
+ "res_194",
+ "res_195",
+ "res_196",
+ "res_197",
+ "res_198",
+ "res_199",
+ "res_200",
+ "res_201",
+ "res_202",
+ "res_203",
+ "res_204",
+ "res_205",
+ "res_206",
+ "res_207",
+ "res_208",
+ "res_209",
+ "res_210",
+ "res_211",
+ "res_212",
+ "res_213",
+ "res_214",
+ "res_215",
+ "res_216",
+ "res_217",
+ "res_218",
+ "res_219",
+ "res_220",
+ "res_221",
+ "res_222",
+ "res_223",
+ "res_224",
+ "res_225",
+ "res_226",
+ "res_227",
+ "res_228",
+ "res_229",
+ "res_230",
+ "res_231",
+ "res_232",
+ "res_233",
+ "res_234",
+ "res_235",
+ "res_236",
+ "res_237",
+ "res_238",
+ "res_239",
+ "res_240",
+ "res_241",
+ "res_242",
+ "res_243",
+ "res_244",
+ "res_245",
+ "res_246",
+ "res_247",
+ "res_248",
+ "res_249",
+ "res_250",
+ "res_251",
+ "res_252",
+ "res_253",
+ "res_254",
+ "oem_unit",
+};
+
static struct inode *stlmfs_get_inode(struct super_block *sb, umode_t mode)
{
struct inode *inode = new_inode(sb);
@@ -893,6 +1415,18 @@ DEFINE_TLM_CLASS(persistent_tlmo, "persistent", 0,
DEFINE_TLM_CLASS(value_tlmo, "value", 0,
S_IFREG | 0444, &de_read_fops, NULL);
+static inline struct dentry *
+stlmfs_lookup_by_name(struct dentry *parent, const char *dname)
+{
+ struct qstr qstr;
+
+ qstr.name = dname;
+ qstr.len = strlen(dname);
+ qstr.hash = full_name_hash(parent, qstr.name, qstr.len);
+
+ return d_lookup(parent, &qstr);
+}
+
static int scmi_telemetry_de_populate(struct super_block *sb,
struct scmi_tlm_setup *tsp,
struct dentry *parent,
@@ -1753,6 +2287,147 @@ static struct dentry *stlmfs_create_root_dentry(struct super_block *sb)
return dentry;
}
+static int scmi_telemetry_de_subdir_symlink(struct super_block *sb,
+ struct scmi_tlm_setup *tsp,
+ const struct scmi_telemetry_de *de,
+ struct dentry *parent)
+{
+ struct dentry *dentry;
+ struct inode *inode;
+
+ if (IS_ERR(parent))
+ return 0;
+
+ char *name __free(kfree) = kasprintf(GFP_KERNEL, "0x%08X[%s]",
+ de->info->id, (const char *)de->info->name);
+ if (!name)
+ return -ENOMEM;
+
+ char *link __free(kfree) =
+ kasprintf(GFP_KERNEL, "../../../../../des/0x%08X", de->info->id);
+ if (!link)
+ return -ENOMEM;
+
+ dentry = simple_start_creating(parent, name);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ inode = stlmfs_get_inode(sb, S_IFLNK | 0777);
+ if (unlikely(!inode)) {
+ dev_err(tsp->dev,
+ "out of free dentries, cannot create '%s'", name);
+ return stlmfs_failed_creating(dentry);
+ }
+
+ inode->i_op = &simple_symlink_inode_operations;
+ inode->i_link = no_free_ptr(link);
+
+ d_make_persistent(dentry, inode);
+
+ simple_done_creating(dentry);
+
+ return 0;
+}
+
+static struct dentry *
+scmi_telemetry_topology_path_get(struct super_block *sb,
+ struct scmi_tlm_setup *tsp,
+ struct dentry *parent, const char *dname)
+{
+ struct dentry *dentry;
+
+ dentry = stlmfs_lookup_by_name(parent, dname);
+ if (!dentry) {
+ struct scmi_tlm_class *dir_tlm_cls __free(kfree) =
+ kzalloc(sizeof(*dir_tlm_cls), GFP_KERNEL);
+ if (!dir_tlm_cls)
+ return NULL;
+
+ dir_tlm_cls->name = kasprintf(GFP_KERNEL, "%s", dname);
+ if (!dir_tlm_cls->name)
+ return NULL;
+
+ dir_tlm_cls->mode = S_IFDIR | 0755;
+ dir_tlm_cls->flags = TLM_IS_DYNAMIC;
+
+ dentry = stlmfs_create_dentry(sb, tsp, parent,
+ dir_tlm_cls, NULL);
+ if (!IS_ERR(dentry))
+ retain_and_null_ptr(dir_tlm_cls);
+ }
+
+ return dentry;
+}
+
+static int scmi_telemetry_topology_add_node(struct super_block *sb,
+ struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_de *de)
+{
+ struct dentry *ctype, *cinst, *cunit, *dinst;
+ struct scmi_tlm_de_info *dei = de->info;
+ char inst_str[32];
+ int ret;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/ */
+ ctype = scmi_telemetry_topology_path_get(sb, ti->tsp, ti->compo_dentry,
+ compo_types[dei->compo_type]);
+ if (!ctype)
+ return -ENOMEM;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/<N>/ */
+ snprintf(inst_str, 32, "%u", dei->compo_instance_id);
+ cinst = scmi_telemetry_topology_path_get(sb, ti->tsp, ctype, inst_str);
+ dput(ctype);
+ if (!cinst)
+ return -ENOMEM;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/<N>/<DE_UNIT_TYPE_STR>/ */
+ cunit = scmi_telemetry_topology_path_get(sb, ti->tsp, cinst,
+ unit_types[dei->unit]);
+ dput(cinst);
+ if (!cunit)
+ return -ENOMEM;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/<N>/<DE_UNIT_TYPE_STR>/<N> */
+ snprintf(inst_str, 32, "%u", dei->instance_id);
+ dinst = scmi_telemetry_topology_path_get(sb, ti->tsp, cunit, inst_str);
+ dput(cunit);
+ if (!dinst)
+ return -ENOMEM;
+
+ ret = scmi_telemetry_de_subdir_symlink(sb, ti->tsp, de, dinst);
+ dput(dinst);
+
+ return ret;
+}
+
+DEFINE_TLM_CLASS(compo_dir_cls, "by-components", 0, S_IFDIR | 0700, NULL, NULL);
+
+static int scmi_telemetry_topology_view_add(struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct device *dev = tsp->dev;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (!rinfo || !rinfo->fully_enumerated)
+ return -ENODEV;
+
+ ti->compo_dentry =
+ stlmfs_create_dentry(ti->sb, tsp, ti->top_dentry, &compo_dir_cls, NULL);
+
+ for (int i = 0; i < rinfo->num_des; i++) {
+ int ret;
+
+ ret = scmi_telemetry_topology_add_node(ti->sb, ti, rinfo->des[i]);
+ if (ret)
+ dev_err(dev, "Fail to add node %s to topology. Skip.\n",
+ rinfo->des[i]->info->name);
+ }
+
+ return 0;
+}
+
static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
{
struct scmi_tlm_setup *tsp = ti->tsp;
@@ -1808,6 +2483,12 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
ti->top_cls.name);
}
+ ret = scmi_telemetry_topology_view_add(ti);
+ if (ret)
+ dev_warn(ti->tsp->dev,
+ "Failed to create topology view for instance %s.\n",
+ ti->top_cls.name);
+
return 0;
}
--
2.54.0
^ permalink raw reply related
* [PATCH v4 24/31] fs/stlmfs: Document alternative ioctl based binary interface
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Document the additionally provided special files and their usage in the
context of the alternative binary ioctl-based interface.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/filesystems/stlmfs.rst | 24 ++++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index a15da85b9971..0c7b7c006709 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -143,6 +143,7 @@ create the following directory structure::
|-- all_des_enable
|-- all_des_tstamp_enable
|-- available_update_intervals_ms
+ |-- control
|-- current_update_interval_ms
|-- de_implementation_version
|-- des/
@@ -160,6 +161,10 @@ create the following directory structure::
|-- tlm_enable
`-- version
+.. Note::
+ The control/ special file can be used to use the alternative
+ binary interface described in include/uapi/linux/scmi.h
+
Each subdirectory is defined as follows.
des/
@@ -220,6 +225,7 @@ values, as in::
scmi_tlm_0/groups/0/
|-- available_update_intervals_ms
|-- composing_des
+ |-- control
|-- current_update_interval_ms
|-- des_bulk_read
|-- des_single_sample_read
@@ -227,3 +233,21 @@ values, as in::
|-- intervals_discrete
`-- tstamp_enable
+Alternative Binary Interfaces - Special files
+=============================================
+
+Special files are populated across the filesystem so as to implement the support
+of more performant alternative binary interfaces that can be used instead of the
+main human readable ABI.
+
+IOCTLs Interface
+----------------
+
+The ioctl-based interface is detailed in::
+
+ include/uapi/linux/scmi.h
+
+The filesystem provides special files named *control/* to be used with the
+ioctl interface mentioned above: note that the behaviour of some of the ioctls
+is dependent on which *control/* file is used to invoke them (as detailed in the
+UAPI header above).
--
2.54.0
^ permalink raw reply related
* [PATCH v4 23/31] firmware: arm_scmi: stlmfs: Add ioctls support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Extend the filesystem based interface with special 'control' files that can
be used to configure and retrieve SCMI Telemetry data in binary form using
the ioctls-based ABI described in uapi/linux/scmi.h.
This alternative ABI is meant to provide a more performant access to SCMI
Telemetry configuration and data events, without the hassle of navigating
the human readable VFS based intwerface.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- make FS entries world-Readable and user-Writable where applicable
- consider default umask when defining file perms
- update Telemetry ioctl state query caller with tracking data
- added stlmfs tag in $SUBJECT
v1 --> v2
- Use new res_get() operation which use new resource accessors
- Use new de_lookup() tlm_ops
- Using cleanup.h
- use new interval.num_intervals
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 404 ++++++++++++++++++
1 file changed, 404 insertions(+)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index f4d284335ac0..720930f6bcd1 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -26,6 +26,8 @@
#include <linux/types.h>
#include <linux/uaccess.h>
+#include <uapi/linux/scmi.h>
+
#define TLM_FS_MAGIC 0x75C01C80
#define TLM_FS_NAME "stlmfs"
#define TLM_FS_MNT "arm_telemetry"
@@ -1121,6 +1123,406 @@ DEFINE_TLM_CLASS(grp_available_interval_tlmo, "available_update_intervals_ms",
DEFINE_TLM_CLASS(grp_intervals_discrete_tlmo, "intervals_discrete",
TLM_IS_GROUP, S_IFREG | 0444, &intrv_discrete_fops, NULL);
+static long
+scmi_tlm_info_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ const struct scmi_telemetry_info *info = tlmi->priv;
+ void * __user uptr = (void * __user)arg;
+
+ if (copy_to_user(uptr, &info->base, sizeof(info->base)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_intervals_get_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg, bool is_group)
+{
+ struct scmi_tlm_intervals ivs, *tlm_ivs;
+ void * __user uptr = (void * __user)arg;
+
+ if (copy_from_user(&ivs, uptr, sizeof(ivs)))
+ return -EFAULT;
+
+ if (!is_group) {
+ const struct scmi_telemetry_info *info = tlmi->priv;
+
+ tlm_ivs = info->intervals;
+ } else {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+
+ tlm_ivs = grp->intervals;
+ }
+
+ if (ivs.num_intervals != tlm_ivs->num_intervals)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, tlm_ivs,
+ sizeof(*tlm_ivs) + sizeof(u32) * ivs.num_intervals))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_de_config_set_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg, bool all)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_de_config tcfg = {};
+ int ret;
+
+ if (copy_from_user(&tcfg, uptr, sizeof(tcfg)))
+ return -EFAULT;
+
+ if (!all)
+ return tsp->ops->state_set(tsp->ph, false, tcfg.id,
+ (bool *)&tcfg.enable,
+ (bool *)&tcfg.t_enable);
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ for (int i = 0; i < rinfo->num_des; i++) {
+ ret = tsp->ops->state_set(tsp->ph, false,
+ rinfo->des[i]->info->id,
+ (bool *)&tcfg.enable,
+ (bool *)&tcfg.t_enable);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static long
+scmi_tlm_de_config_get_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_de_config tcfg = {};
+ int ret;
+
+ if (copy_from_user(&tcfg, uptr, sizeof(tcfg)))
+ return -EFAULT;
+
+ ret = tsp->ops->state_get(tsp->ph, &tcfg.id,
+ (bool *)&tcfg.enable, (bool *)&tcfg.t_enable);
+ if (ret)
+ return ret;
+
+ if (copy_to_user(uptr, &tcfg, sizeof(tcfg)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_config_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg,
+ bool is_group)
+{
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_config cfg;
+
+ if (!is_group) {
+ const struct scmi_telemetry_info *info = tlmi->priv;
+
+ cfg.enable = !!info->enabled;
+ cfg.current_update_interval = info->active_update_interval;
+ } else {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+
+ cfg.enable = !!grp->enabled;
+ cfg.t_enable = !!grp->tstamp_enabled;
+ cfg.current_update_interval = grp->active_update_interval;
+ }
+
+ if (copy_to_user(uptr, &cfg, sizeof(cfg)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_config_set_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg,
+ bool is_group)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_config cfg = {};
+ bool grp_ignore;
+ int res_id;
+
+ if (copy_from_user(&cfg, uptr, sizeof(cfg)))
+ return -EFAULT;
+
+ if (!is_group) {
+ res_id = SCMI_TLM_GRP_INVALID;
+ grp_ignore = true;
+ } else {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+ int ret;
+
+ res_id = grp->info->id;
+ grp_ignore = false;
+ ret = tsp->ops->state_set(tsp->ph, true, res_id,
+ (bool *)&cfg.enable,
+ (bool *)&cfg.t_enable);
+ if (ret)
+ return ret;
+ }
+
+ return tsp->ops->collection_configure(tsp->ph, res_id, grp_ignore,
+ (bool *)&cfg.enable,
+ &cfg.current_update_interval,
+ NULL);
+}
+
+static long
+scmi_tlm_de_info_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ const struct scmi_telemetry_de *de;
+ struct scmi_tlm_de_info dei;
+
+ if (copy_from_user(&dei, uptr, sizeof(dei)))
+ return -EFAULT;
+
+ de = tsp->ops->de_lookup(tsp->ph, dei.id);
+ if (!de)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, de->info, sizeof(*de->info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_des_list_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_telemetry_res_info *rinfo;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_des_list dsl;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (copy_from_user(&dsl, uptr, sizeof(dsl)))
+ return -EFAULT;
+
+ if (dsl.num_des < rinfo->num_des)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, &rinfo->num_des, sizeof(rinfo->num_des)))
+ return -EFAULT;
+
+ if (copy_to_user(uptr + sizeof(rinfo->num_des), rinfo->dei_store,
+ rinfo->num_des * sizeof(*rinfo->dei_store)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_de_value_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_de_sample sample;
+ int ret;
+
+ if (copy_from_user(&sample, uptr, sizeof(sample)))
+ return -EFAULT;
+
+ ret = tsp->ops->de_data_read(tsp->ph,
+ (struct scmi_telemetry_de_sample *)&sample);
+ if (ret)
+ return ret;
+
+ if (copy_to_user(uptr, &sample, sizeof(sample)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_grp_info_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+ void * __user uptr = (void * __user)arg;
+
+ if (copy_to_user(uptr, grp->info, sizeof(*grp->info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_grp_desc_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+ unsigned int num_des = grp->info->num_des;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_grp_desc grp_desc;
+
+ if (copy_from_user(&grp_desc, uptr, sizeof(grp_desc)))
+ return -EFAULT;
+
+ if (grp_desc.num_des < num_des)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, &num_des, sizeof(num_des)))
+ return -EFAULT;
+
+ if (copy_to_user(uptr + sizeof(num_des), grp->des,
+ sizeof(*grp->des) * num_des))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_grps_list_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_telemetry_res_info *rinfo;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_grps_list gsl;
+
+ if (copy_from_user(&gsl, uptr, sizeof(gsl)))
+ return -EFAULT;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (gsl.num_grps < rinfo->num_groups)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, &rinfo->num_groups, sizeof(rinfo->num_groups)))
+ return -EFAULT;
+
+ if (copy_to_user(uptr + sizeof(rinfo->num_groups), rinfo->grps_store,
+ rinfo->num_groups * sizeof(*rinfo->grps_store)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long scmi_tlm_des_read_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg, bool single,
+ bool is_group)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_data_read bulk;
+ int ret, grp_id = SCMI_TLM_GRP_INVALID;
+
+ if (copy_from_user(&bulk, uptr, sizeof(bulk)))
+ return -EFAULT;
+
+ struct scmi_tlm_data_read *bulk_ptr __free(kfree) =
+ kzalloc(struct_size(bulk_ptr, samples, bulk.num_samples),
+ GFP_KERNEL);
+ if (!bulk_ptr)
+ return -ENOMEM;
+
+ if (is_group) {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+
+ grp_id = grp->info->id;
+ }
+
+ bulk_ptr->num_samples = bulk.num_samples;
+ if (!single)
+ ret = tsp->ops->des_bulk_read(tsp->ph, grp_id,
+ &bulk_ptr->num_samples,
+ (struct scmi_telemetry_de_sample *)bulk_ptr->samples);
+ else
+ ret = tsp->ops->des_sample_get(tsp->ph, grp_id,
+ &bulk_ptr->num_samples,
+ (struct scmi_telemetry_de_sample *)bulk_ptr->samples);
+ if (ret)
+ return ret;
+
+ if (copy_to_user(uptr, bulk_ptr, sizeof(*bulk_ptr) +
+ bulk_ptr->num_samples * sizeof(bulk_ptr->samples[0])))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long scmi_tlm_unlocked_ioctl(struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ bool is_group = IS_GROUP(tlmi->cls->flags);
+
+ switch (cmd) {
+ case SCMI_TLM_GET_INFO:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_info_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_CFG:
+ return scmi_tlm_config_get_ioctl(tlmi, arg, is_group);
+ case SCMI_TLM_SET_CFG:
+ return scmi_tlm_config_set_ioctl(tlmi, arg, is_group);
+ case SCMI_TLM_GET_INTRVS:
+ return scmi_tlm_intervals_get_ioctl(tlmi, arg, is_group);
+ case SCMI_TLM_GET_DE_CFG:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_config_get_ioctl(tlmi, arg);
+ case SCMI_TLM_SET_DE_CFG:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_config_set_ioctl(tlmi, arg, false);
+ case SCMI_TLM_GET_DE_INFO:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_info_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_DE_LIST:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_des_list_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_DE_VALUE:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_value_get_ioctl(tlmi, arg);
+ case SCMI_TLM_SET_ALL_CFG:
+ return scmi_tlm_de_config_set_ioctl(tlmi, arg, true);
+ case SCMI_TLM_GET_GRP_LIST:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_grps_list_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_GRP_INFO:
+ if (!is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_grp_info_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_GRP_DESC:
+ if (!is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_grp_desc_get_ioctl(tlmi, arg);
+ case SCMI_TLM_SINGLE_SAMPLE:
+ return scmi_tlm_des_read_ioctl(tlmi, arg, true, is_group);
+ case SCMI_TLM_BULK_READ:
+ return scmi_tlm_des_read_ioctl(tlmi, arg, false, is_group);
+ default:
+ return -ENOTTY;
+ }
+}
+
+static const struct file_operations scmi_tlm_ctrl_fops = {
+ .owner = THIS_MODULE,
+ .open = nonseekable_open,
+ .unlocked_ioctl = scmi_tlm_unlocked_ioctl,
+};
+
+DEFINE_TLM_CLASS(ctrl_tlmo, "control", 0,
+ S_IFREG | 0666, &scmi_tlm_ctrl_fops, NULL);
+DEFINE_TLM_CLASS(grp_ctrl_tlmo, "control", TLM_IS_GROUP,
+ S_IFREG | 0666, &scmi_tlm_ctrl_fops, NULL);
+
static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
{
const struct scmi_telemetry_res_info *rinfo;
@@ -1160,6 +1562,7 @@ static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
&grp_composing_des_tlmo, grp->des_str);
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_ctrl_tlmo, grp);
stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_data_tlmo, grp);
if (ti->info->single_read_support)
stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
@@ -1375,6 +1778,7 @@ static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
if (ti->info->single_read_support)
stlmfs_create_dentry(sb, tsp, ti->top_dentry,
&single_sample_tlmo, ti->info);
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &ctrl_tlmo, ti->info);
ti->des_dentry =
stlmfs_create_dentry(sb, tsp, ti->top_dentry, &des_dir_cls, NULL);
ti->grps_dentry =
--
2.54.0
^ permalink raw reply related
* [PATCH v4 22/31] fs/stlmfs: Document ARM SCMI Telemetry FS mount options
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi, Jonathan Corbet, Shuah Khan
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Detail ARM SCMI Telemetry filesystem available mount options.
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: linux-doc@vger.kernel.org
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/filesystems/stlmfs.rst | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index 123e0e68e041..a15da85b9971 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -109,6 +109,25 @@ sense to allow this FS to be mounted inside a container.
All files are created world readable and, where needed for configuration,
owner writable.
+Mount Options
+=============
+
+This FS supports the typical mount options needed to modify, at mount time, the
+ownership of the root and all of the underlying inodes:
+
+ - uid: id of the owner of the root inode and all of the files subsequently
+ created under it
+
+ - gid: id of the group of the root inode and all of the files subsequently
+ created under it
+
+ - umask: a standard umask filter to be applied to user/group/other: defaults
+ to 00222
+
+Note that all of the above options are explicitly designed NOT to support
+a remount operation, so as not have surprising effects on permissions of
+already discovered/created telemetry files.
+
Usage
=====
--
2.54.0
^ permalink raw reply related
* [PATCH v4 21/31] firmware: arm_scmi: stlmfs: Add basic mount options
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add mount options to choose different uid/gid/umask for all the created
files; reject handling changes to these options while remounting.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 146 +++++++++++++++++-
1 file changed, 143 insertions(+), 3 deletions(-)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index 567585dfb036..f4d284335ac0 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -34,6 +34,32 @@
#define MAX_AVAILABLE_INTERV_CHAR_LENGTH 25
#define MAX_BULK_LINE_CHAR_LENGTH 64
+enum {
+ Opt_uid,
+ Opt_gid,
+ Opt_umask,
+};
+
+static const struct fs_parameter_spec stlmfs_param_spec[] = {
+ fsparam_uid("uid", Opt_uid),
+ fsparam_gid("gid", Opt_gid),
+ fsparam_u32oct("umask", Opt_umask),
+ {}
+};
+
+struct stlmfs_fs_context {
+ unsigned int opts;
+ kuid_t uid;
+ kgid_t gid;
+ umode_t umask;
+};
+
+struct stlmfs_sb_info {
+ kuid_t uid;
+ kgid_t gid;
+ umode_t umask;
+};
+
static struct kmem_cache *stlmfs_inode_cachep;
static DEFINE_MUTEX(stlmfs_mtx);
@@ -202,10 +228,12 @@ static struct inode *stlmfs_get_inode(struct super_block *sb, umode_t mode)
struct inode *inode = new_inode(sb);
if (inode) {
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
inode->i_ino = get_next_ino();
- inode->i_uid = GLOBAL_ROOT_UID;
- inode->i_gid = GLOBAL_ROOT_GID;
- inode->i_mode = mode & ~SCMI_TLM_DEFAULT_UMASK;
+ inode->i_uid = sbi->uid;
+ inode->i_gid = sbi->gid;
+ inode->i_mode = mode & ~sbi->umask;
simple_inode_init_ts(inode);
}
@@ -1282,10 +1310,25 @@ static void stlmfs_free_inode(struct inode *inode)
kmem_cache_free(stlmfs_inode_cachep, tlmi);
}
+static int stlmfs_show_options(struct seq_file *seq, struct dentry *root)
+{
+ struct stlmfs_sb_info *sbi = root->d_sb->s_fs_info;
+
+ if (!uid_eq(sbi->uid, GLOBAL_ROOT_UID))
+ seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, sbi->uid));
+ if (!gid_eq(sbi->gid, GLOBAL_ROOT_GID))
+ seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, sbi->gid));
+ if (sbi->umask != SCMI_TLM_DEFAULT_UMASK)
+ seq_printf(seq, ",umask=%04u", sbi->umask);
+
+ return 0;
+}
+
static const struct super_operations tlm_sops = {
.statfs = simple_statfs,
.alloc_inode = stlmfs_alloc_inode,
.free_inode = stlmfs_free_inode,
+ .show_options = stlmfs_show_options,
};
static struct dentry *stlmfs_create_root_dentry(struct super_block *sb)
@@ -1366,10 +1409,26 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
{
+ struct stlmfs_fs_context *ctx;
struct scmi_tlm_instance *ti;
struct dentry *root_dentry;
int ret;
+ /* Bail out if already initialized */
+ if (sb->s_fs_info)
+ return 0;
+
+ struct stlmfs_sb_info *sbi __free(kfree) =
+ kzalloc(sizeof(*sbi), GFP_KERNEL);
+ if (!sbi)
+ return -ENOMEM;
+
+ ctx = fc->fs_private;
+ sbi->uid = ctx->uid;
+ sbi->gid = ctx->gid;
+ sbi->umask = ctx->umask;
+
+ sb->s_fs_info = sbi;
sb->s_magic = TLM_FS_MAGIC;
sb->s_blocksize = PAGE_SIZE;
sb->s_blocksize_bits = PAGE_SHIFT;
@@ -1379,6 +1438,7 @@ static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
if (IS_ERR(root_dentry))
return PTR_ERR(root_dentry);
+ retain_and_null_ptr(sbi);
sb->s_root = root_dentry;
mutex_lock(&stlmfs_mtx);
@@ -1396,17 +1456,93 @@ static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
return 0;
}
+static void stlmfs_free(struct fs_context *fc)
+{
+ struct stlmfs_fs_context *ctx;
+
+ ctx = fc->fs_private;
+
+ kfree(ctx);
+}
+
static int stlmfs_get_tree(struct fs_context *fc)
{
return get_tree_single(fc, stlmfs_fill_super);
}
+static int stlmfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
+{
+ struct stlmfs_fs_context *ctx;
+ struct fs_parse_result result;
+ int opt;
+
+ opt = fs_parse(fc, stlmfs_param_spec, param, &result);
+ if (opt < 0)
+ return opt;
+
+ ctx = fc->fs_private;
+
+ switch (opt) {
+ case Opt_uid:
+ if (!kuid_has_mapping(fc->user_ns, result.uid))
+ return invalfc(fc, "Invalid uid");
+ ctx->uid = result.uid;
+ ctx->opts |= BIT(Opt_uid);
+ break;
+ case Opt_gid:
+ if (!kgid_has_mapping(fc->user_ns, result.gid))
+ return invalfc(fc, "Invalid gid");
+ ctx->gid = result.gid;
+ ctx->opts |= BIT(Opt_gid);
+ break;
+ case Opt_umask:
+ ctx->umask = result.uint_32 & 07777;
+ ctx->opts |= BIT(Opt_umask);
+ break;
+ default:
+ return -ENOPARAM;
+ }
+
+ return 0;
+}
+
+static int stlmfs_reconfigure(struct fs_context *fc)
+{
+ struct stlmfs_fs_context *ctx = fc->fs_private;
+
+ sync_filesystem(fc->root->d_sb);
+
+ if (ctx->opts & BIT(Opt_uid))
+ return invalfc(fc, "uid cannot be changed on remount");
+ if (ctx->opts & BIT(Opt_gid))
+ return invalfc(fc, "gid cannot be changed on remount");
+ if (ctx->opts & BIT(Opt_umask))
+ return invalfc(fc, "umask cannot be changed on remount");
+
+ return 0;
+}
+
static const struct fs_context_operations stlmfs_fc_ops = {
.get_tree = stlmfs_get_tree,
+ .parse_param = stlmfs_parse_param,
+ .free = stlmfs_free,
+ .reconfigure = stlmfs_reconfigure,
};
static int stlmfs_init_fs_context(struct fs_context *fc)
{
+ struct stlmfs_fs_context *ctx;
+
+ ctx = kzalloc_obj(*ctx);
+ if (!ctx)
+ return -ENOMEM;
+
+ /* defaults */
+ ctx->uid = GLOBAL_ROOT_UID;
+ ctx->gid = GLOBAL_ROOT_GID;
+ ctx->umask = SCMI_TLM_DEFAULT_UMASK;
+
+ fc->fs_private = ctx;
fc->ops = &stlmfs_fc_ops;
return 0;
@@ -1414,11 +1550,15 @@ static int stlmfs_init_fs_context(struct fs_context *fc)
static void stlmfs_kill_sb(struct super_block *sb)
{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
mutex_lock(&stlmfs_mtx);
stlmfs_sb = NULL;
mutex_unlock(&stlmfs_mtx);
kill_anon_super(sb);
+
+ kfree(sbi);
}
static struct file_system_type scmi_telemetry_fs = {
--
2.54.0
^ permalink raw reply related
* [PATCH v4 20/31] fs/stlmfs: Document ARM SCMI Telemetry filesystem
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi, Jonathan Corbet, Shuah Khan
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Introduce initial ARM SCMI Telemetry filesystem documentation.
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: linux-doc@vger.kernel.org
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- refactored mount description
v2 --> v3
- changed tstamp_exp to tstamp_rate
---
Documentation/filesystems/stlmfs.rst | 210 +++++++++++++++++++++++++++
1 file changed, 210 insertions(+)
create mode 100644 Documentation/filesystems/stlmfs.rst
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
new file mode 100644
index 000000000000..123e0e68e041
--- /dev/null
+++ b/Documentation/filesystems/stlmfs.rst
@@ -0,0 +1,210 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+=============================================
+STLMFS - Arm SCMI Telemetry Pseudo Filesystem
+=============================================
+
+.. contents::
+
+Overview
+========
+
+ARM SCMI is a System and Configuration Management protocol, based on a
+client-server model, that defines a number of messages that allows a
+client/agent like Linux to discover, configure and make use of services
+provided by the server/platform firmware.
+
+SCMI v4.0 introduced support for System Telemetry, through which an agent
+can dynamically enumerate configure and collect Telemetry Data Events (DE)
+exposed by the platform.
+
+This filesystem, in turn, exposes to userspace the set of discovered DEs
+allowing for their configuration and retrieval.
+
+Rationale
+=========
+
+**Why not using SysFS/KernFS or DebugFS ?**
+
+The provided userspace interface aims to satisfy 2 main concurrent
+requirements:
+
+ - expose an FS-based human-readable interface that can be used to
+ discover, configure and access Telemetry data directly easily also from
+ the shell without any special tool
+
+ - allow also alternative machine-friendly, more-performant, binary
+ interfaces that can be used by custom tools without the overhead of
+ multiple accesses through the VFS layers and the hassle of navigating
+ vast filesystem tree structures
+
+All of the above is meant to be available on production systems, not
+simply as a tool for development or testing, so debugFS is NOT an option
+here.
+
+An initial design based on SysFS and chardev/ioctl based interfaces was
+dropped in favour of this full-fledged filesystem implementation since:
+
+- SysFS is a standard way to expose device related properties using a few
+ common helpers built on kernfs; this means, though, that unfortunately in
+ our scenario we would have to generate a dummy simple device for each
+ discovered DE.
+ This by itself seems an abuse of the SysFS framework, but even ignoring
+ this, the sheer number of potentially discoverable DEs (in the order of
+ tens of thousands easily) would have led to the creation of a sensibly
+ vast number of dummy DE devices.
+
+- SysFS usage itself has its well-known constraints and best practices,
+ like the one-file/one-value rule, that hardly cope with SCMI Telemetry
+ needs.
+
+- The need to implement more complex file operations (ioctls/mmap) in
+ order to support the alternative binary interfaces does not fit with
+ SysFS/kernFS facilities.
+
+- Given the nature of the Telemetry protocol, the hybrid approach with
+ chardev/ioctl was itself problematic: on one side being upper-limited
+ in the number of chardev potentially created by the minor numbers
+ availability, on the other side the hassle of having to maintain a
+ completely different interface on the side of a FS based one.
+
+Design
+======
+
+STLMFS is a pseudo filesystem used to expose ARM SCMI Telemetry data
+discovered dynamically at run-time via SCMI.
+
+Inodes are all dynamically created at mount-time from a dedicated
+kmem_cache based on the gathered available SCMI Telemetry information.
+
+Since inodes represent the discovered Telemetry entities, which in turn are
+statically defined at the platform level and immutable throughout the same
+session (boot), allocated inodes are freed only at unmount-time and the
+user is not allowed to delete or create any kind of file within the STLMFS
+filesystem after mount has completed.
+
+A single instance of STLMFS is created at the filesystem level, using
+get_tree_single(), given that the same SCMI backend entities will be
+involved no matter how many times you mount it.
+
+STLMFS configurations gets appplied by issuing the related SCMI commands to
+the backend SCMI platform server: for such reason any configuration applied
+by this FS interface will survive the unmount or the unload of the module, but
+not a reboot.
+
+Mountpoints
+===========
+
+A pre-defined mountpoint is available at::
+
+ /sys/fs/arm_telemetry/
+
+The filesystem can be typically mounted with::
+
+ mount -t stlmfs none /sys/fs/arm_telemetry
+
+It does NOT support namespaces (no FS_USERNS_MOUNT) since it would NOT make
+sense to allow this FS to be mounted inside a container.
+
+All files are created world readable and, where needed for configuration,
+owner writable.
+
+Usage
+=====
+
+.. Note::
+ See Documentation/ABI/testing/stlmfs for a detailed description of
+ this ABI.
+
+Once mounted the FS will proceed to create a top subdirectory for each of the
+discovered SCMI Telemetry instances named as 'tlm_<N>' under which it will
+create the following directory structure::
+
+ /sys/fs/arm_telemetry/tlm_0/
+ |-- all_des_enable
+ |-- all_des_tstamp_enable
+ |-- available_update_intervals_ms
+ |-- current_update_interval_ms
+ |-- de_implementation_version
+ |-- des/
+ | |-- ...
+ | |-- ...
+ | `-- ...
+ |-- des_bulk_read
+ |-- des_single_sample_read
+ |-- groups
+ | |-- ...
+ | |-- ...
+ | `-- ...
+ |-- intervals_discrete
+ |-- reset
+ |-- tlm_enable
+ `-- version
+
+Each subdirectory is defined as follows.
+
+des/
+----
+A subtree containing in turn one subdirectory for each discovered DE and
+named by Data Event ID in hexadecimal form as in::
+
+ |-- des
+ | |-- 0x00000000
+ | |-- 0x00000016
+ | |-- 0x00001010
+ | |-- 0x0000A000
+ | |-- 0x0000A001
+ | |-- 0x0000A002
+ | |-- 0x0000A005
+ | |-- ..........
+ | |-- ..........
+ | |-- 0x0000A007
+ | |-- 0x0000A008
+ | |-- 0x0000A00A
+ | |-- 0x0000A00B
+ | |-- 0x0000A00C
+ | `-- 0x0000A010
+
+where each dedicated DE subdirectory in turn will contain files used to
+describe some DE characteristics, configure it, or read its current data
+value as in::
+
+ tlm_0/des/0xA001/
+ |-- compo_instance_id
+ |-- compo_type
+ |-- enable
+ |-- instance_id
+ |-- name
+ |-- persistent
+ |-- tstamp_enable
+ |-- tstamp_rate
+ |-- type
+ |-- unit
+ |-- unit_exp
+ `-- value
+
+groups/
+-------
+
+An optional subtree containing in turn one subdirectory for each discovered
+Group and named by Group ID as in::
+
+ |-- groups
+ | |-- 0
+ | |-- ..
+ | `-- 1
+
+where each dedicated GROUP subdirectory in turn will contain files used to
+describe some Group characteristics, configure it, or read its current data
+values, as in::
+
+ scmi_tlm_0/groups/0/
+ |-- available_update_intervals_ms
+ |-- composing_des
+ |-- current_update_interval_ms
+ |-- des_bulk_read
+ |-- des_single_sample_read
+ |-- enable
+ |-- intervals_discrete
+ `-- tstamp_enable
+
--
2.54.0
^ permalink raw reply related
* [PATCH v4 19/31] firmware: arm_scmi: stlmfs: Add System Telemetry filesystem driver
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a new SCMI System Telemetry driver which gathers platform Telemetry
data through the new the SCMI Telemetry protocol and expose all of the
discovered Telemetry data events on a dedicated pseudo-filesystem that
can be used to interactively configure SCMI Telemetry and access its
provided data.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- make FS entries world-Readable and user-Writable where applicable
- drop inode_init_owner, use static uid/gid/umask
- use kzalloc_obj
- use octal permissions
- added stlmfs tag in $SUBJECT
- changed des/0x<NNNN>/value to -> <tstamp> <value>
- hide single_sample_read entries when NOT supported by platform
- generalize and refactor tlm_priv fops: data initialze now at open
- add a .remove function to cleanup properly also on unbind
v2 --> v3
- change from tstamp_exp to tstamp_rate entry
- use new interval.num_intervals
- addded a few more comments
v1 --> v2
- Harden System Telemetry writes, DO report errors
- New 'secs[, <exp>]' for current_interval_update_ms
- Use new mount_api based on fs_context
- Use new res_get() operation to make use of new accessors
- Move des/groups enumeration to mount time
- Support partial out-of-spec FW lacking some cmds (best effort)
- Reworked init/exit sequence
- Using dev_err_probe
- Reworked probing races handling
- Avoid disabling telemetry on module removal and drop remove() code
---
drivers/firmware/arm_scmi/Kconfig | 10 +
drivers/firmware/arm_scmi/Makefile | 1 +
.../firmware/arm_scmi/scmi_system_telemetry.c | 1493 +++++++++++++++++
3 files changed, 1504 insertions(+)
create mode 100644 drivers/firmware/arm_scmi/scmi_system_telemetry.c
diff --git a/drivers/firmware/arm_scmi/Kconfig b/drivers/firmware/arm_scmi/Kconfig
index 06d2319420a0..1fc9182224cc 100644
--- a/drivers/firmware/arm_scmi/Kconfig
+++ b/drivers/firmware/arm_scmi/Kconfig
@@ -113,4 +113,14 @@ config ARM_SCMI_POWER_CONTROL
called scmi_power_control. Note this may needed early in boot to catch
early shutdown/reboot SCMI requests.
+config ARM_SCMI_SYSTEM_TELEMETRY
+ tristate "SCMI System Telemetry driver"
+ depends on ARM_SCMI_PROTOCOL || (COMPILE_TEST && OF)
+ help
+ This enables SCMI Systemn Telemetry support that allows userspace to
+ retrieve ARM Telemetry data made available via SCMI.
+
+ This driver can also be built as a module. If so, the module will be
+ called scmi_system_telemetry.
+
endmenu
diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile
index fe55b7aa0707..20f8d55840a5 100644
--- a/drivers/firmware/arm_scmi/Makefile
+++ b/drivers/firmware/arm_scmi/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_ARM_SCMI_PROTOCOL) += scmi-core.o
obj-$(CONFIG_ARM_SCMI_PROTOCOL) += scmi-module.o
obj-$(CONFIG_ARM_SCMI_POWER_CONTROL) += scmi_power_control.o
+obj-$(CONFIG_ARM_SCMI_SYSTEM_TELEMETRY) += scmi_system_telemetry.o
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
new file mode 100644
index 000000000000..567585dfb036
--- /dev/null
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -0,0 +1,1493 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * SCMI - System Telemetry Driver
+ *
+ * Copyright (C) 2026 ARM Ltd.
+ */
+
+#include <linux/atomic.h>
+#include <linux/bitfield.h>
+#include <linux/cred.h>
+#include <linux/ctype.h>
+#include <linux/dcache.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/fs.h>
+#include <linux/fs_context.h>
+#include <linux/fs_parser.h>
+#include <linux/kstrtox.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/overflow.h>
+#include <linux/scmi_protocol.h>
+#include <linux/slab.h>
+#include <linux/sprintf.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+
+#define TLM_FS_MAGIC 0x75C01C80
+#define TLM_FS_NAME "stlmfs"
+#define TLM_FS_MNT "arm_telemetry"
+
+#define SCMI_TLM_DEFAULT_UMASK 0022U
+#define MAX_AVAILABLE_INTERV_CHAR_LENGTH 25
+#define MAX_BULK_LINE_CHAR_LENGTH 64
+
+static struct kmem_cache *stlmfs_inode_cachep;
+
+static DEFINE_MUTEX(stlmfs_mtx);
+static struct super_block *stlmfs_sb;
+
+static atomic_t scmi_tlm_instance_count = ATOMIC_INIT(0);
+
+struct scmi_tlm_setup;
+
+struct scmi_tlm_priv {
+ char *buf;
+ size_t buf_sz;
+ int buf_len;
+ int (*bulk_retrieve)(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples);
+};
+
+/**
+ * struct scmi_tlm_buffer - Output Telemetry buffer descriptor
+ * @used: Current number of used bytes in @buf
+ * @buf: Actual buffer for output data
+ *
+ * This describes an output buffer which will be made available to each r/w
+ * entry file_operations.
+ */
+struct scmi_tlm_buffer {
+ size_t used;
+#define SCMI_TLM_MAX_BUF_SZ 128
+ unsigned char buf[SCMI_TLM_MAX_BUF_SZ];
+};
+
+/**
+ * struct scmi_tlm_setup - Telemetry setup descriptor
+ * @dev: A reference to the related device
+ * @ph: A reference to the protocol handle to be used with the ops
+ * @rinfo: A reference to the resource info descriptor
+ * @ops: A reference to the protocol ops
+ */
+struct scmi_tlm_setup {
+ struct device *dev;
+ struct scmi_protocol_handle *ph;
+ const struct scmi_telemetry_res_info __private *rinfo;
+ const struct scmi_telemetry_proto_ops *ops;
+};
+
+/**
+ * struct scmi_tlm_class - Telemetry class descriptor
+ * @name: A string to be used for filesystem dentry name.
+ * @mode: Filesystem mode mask.
+ * @flags: Optional misc flags that can slighly modify provided @f_op behaviour;
+ * this way the same @scmi_tlm_class can be used to describe multiple
+ * entries in the filesystem whose @f_op behaviour is very similar.
+ * @f_op: Optional file ops attached to this object. Used to initialized inodes.
+ * @i_op: Optional inode ops attached to this object. Used to initialize inodes.
+ *
+ * This structure describes a class of telemetry entities that will be
+ * associated with filesystem inodes having the same behaviour, i.e. the same
+ * @f_op and @i_op: this way it will be possible to statically define a set of
+ * common descriptors to describe all the possible behaviours and then link it
+ * to the effective inodes that will be created to support the set of DEs
+ * effectively discovered at run-time via SCMI.
+ */
+struct scmi_tlm_class {
+ const char *name;
+ umode_t mode;
+ int flags;
+#define TLM_IS_STATE BIT(0)
+#define TLM_IS_GROUP BIT(1)
+#define TLM_IS_DYNAMIC BIT(2)
+#define IS_STATE(_f) ((_f) & TLM_IS_STATE)
+#define IS_GROUP(_f) ((_f) & TLM_IS_GROUP)
+#define IS_DYNAMIC(_f) ((_f) & TLM_IS_DYNAMIC)
+ const struct file_operations *f_op;
+ const struct inode_operations *i_op;
+};
+
+#define TLM_ANON_CLASS(_n, _f, _m, _fo, _io) \
+ { \
+ .name = _n, \
+ .flags = _f, \
+ .f_op = _fo, \
+ .i_op = _io, \
+ .mode = _m, \
+ }
+
+#define DEFINE_TLM_CLASS(_tag, _ns, _fl, _mo, _fop, _iop) \
+ static const struct scmi_tlm_class _tag = \
+ TLM_ANON_CLASS(_ns, _fl, _mo, _fop, _iop)
+
+/**
+ * struct scmi_tlm_inode - Telemetry node descriptor
+ * @tsp: A reference to a structure holding data needed to interact with
+ * the SCMI instance associated to this inode.
+ * @cls: A reference to the @scmi_tlm_class describing the behaviour of this
+ * inode.
+ * @priv: Generic private data reference.
+ * @de: SCMI DE data reference.
+ * @grp: SCMI Group data reference.
+ * @info: SCMI instance information data reference.
+ * @vfs_inode: The embedded VFS inode that will be initialized and plugged
+ * into the live filesystem at mount time.
+ *
+ * This structure is used to describe each SCMI Telemetry entity discovered
+ * at probe time, store its related SCMI data, and link to the proper
+ * telemetry class @scmi_tlm_class.
+ */
+struct scmi_tlm_inode {
+ struct scmi_tlm_setup *tsp;
+ const struct scmi_tlm_class *cls;
+ union {
+ const void *priv;
+ const struct scmi_telemetry_de *de;
+ const struct scmi_telemetry_group *grp;
+ const struct scmi_telemetry_info *info;
+ };
+ struct inode vfs_inode;
+};
+
+#define to_tlm_inode(t) container_of(t, struct scmi_tlm_inode, vfs_inode)
+
+#define MAX_INST_NAME 32
+
+#define TOP_NODES_NUM 32
+#define NODES_PER_DE_NUM 12
+#define NODES_PER_GRP_NUM 9
+
+/**
+ * struct scmi_tlm_instance - Telemetry instance descriptor
+ * @id: Progressive number identifying this probed instance; it will be used
+ * to name the top node at the root of this instance.
+ * @res_enumerated: A flag to indicate if full resources enumeration has been
+ * successfully performed.
+ * @name: Name to be used for the top root node of the instance. (tlm_<id>)
+ * @node: A node to link this in the list of all instances.
+ * @sb: A reference to the current super_block.
+ * @tsp: A reference to the SCMI instance data.
+ * @top_cls: A class to represent the top node behaviour.
+ * @top_dentry: A reference to the top dentry for this instance.
+ * @des_dentry: A reference to the DES dentry for this instance.
+ * @grps_dentry: A reference to the groups dentry for this instance.
+ * @info: A handy reference to this instance SCMI Telemetry info data.
+ *
+ */
+struct scmi_tlm_instance {
+ int id;
+ bool res_enumerated;
+ char name[MAX_INST_NAME];
+ struct list_head node;
+ struct super_block *sb;
+ struct scmi_tlm_setup *tsp;
+ struct scmi_tlm_class top_cls;
+ struct dentry *top_dentry;
+ struct dentry *des_dentry;
+ struct dentry *grps_dentry;
+ const struct scmi_telemetry_info *info;
+};
+
+static int scmi_telemetry_instance_register(struct super_block *sb,
+ struct scmi_tlm_instance *ti);
+
+static LIST_HEAD(scmi_telemetry_instances);
+
+static struct inode *stlmfs_get_inode(struct super_block *sb, umode_t mode)
+{
+ struct inode *inode = new_inode(sb);
+
+ if (inode) {
+ inode->i_ino = get_next_ino();
+ inode->i_uid = GLOBAL_ROOT_UID;
+ inode->i_gid = GLOBAL_ROOT_GID;
+ inode->i_mode = mode & ~SCMI_TLM_DEFAULT_UMASK;
+ simple_inode_init_ts(inode);
+ }
+
+ return inode;
+}
+
+static int stlmfs_failed_creating(struct dentry *dentry)
+{
+ simple_done_creating(dentry);
+
+ return -ENOMEM;
+}
+
+static struct dentry *
+stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
+ struct dentry *parent, const struct scmi_tlm_class *cls,
+ const void *priv)
+{
+ struct scmi_tlm_inode *tlmi;
+ struct dentry *dentry;
+ struct inode *inode;
+
+ if (!parent)
+ parent = sb->s_root;
+
+ /*
+ * Bail-out when called on a bad tree, so that there is NO need to
+ * check upfront for errors at call-site. (like debugfs)
+ */
+ if (IS_ERR(parent))
+ return parent;
+
+ dentry = simple_start_creating(parent, cls->name);
+ if (IS_ERR(dentry))
+ return dentry;
+
+ inode = stlmfs_get_inode(sb, cls->mode);
+ if (unlikely(!inode)) {
+ dev_err(tsp->dev,
+ "out of free dentries, cannot create '%s'",
+ cls->name);
+ return ERR_PTR(stlmfs_failed_creating(dentry));
+ }
+
+ if (S_ISDIR(cls->mode)) {
+ inode->i_op = cls->i_op ?: &simple_dir_inode_operations;
+ inode->i_fop = cls->f_op ?: &simple_dir_operations;
+ } else {
+ inode->i_op = cls->i_op ?: &simple_dir_inode_operations;
+ inode->i_fop = cls->f_op;
+ }
+
+ inode->i_private = (void *)priv;
+
+ tlmi = to_tlm_inode(inode);
+
+ tlmi->cls = cls;
+ tlmi->tsp = tsp;
+ tlmi->priv = priv;
+
+ d_make_persistent(dentry, inode);
+
+ simple_done_creating(dentry);
+
+ return dentry;
+}
+
+static inline int
+__scmi_tlm_priv_generic_open(struct inode *ino, struct file *filp,
+ int (*data_init_op)(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp),
+ int (*bulk_op)(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples))
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(ino);
+ int ret;
+
+ struct scmi_tlm_priv *tp __free(kfree) = kzalloc_obj(*tp);
+ if (!tp)
+ return -ENOMEM;
+
+ tp->bulk_retrieve = bulk_op;
+ ret = data_init_op(tlmi, tp);
+ if (ret)
+ return ret;
+
+ filp->private_data = no_free_ptr(tp);
+
+ return nonseekable_open(ino, filp);
+}
+
+static int scmi_tlm_priv_release(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_priv *tp = filp->private_data;
+
+ kfree(tp->buf);
+ kfree(tp);
+
+ return 0;
+}
+
+/**
+ * scmi_telemetry_res_info_get - Resources info getter
+ * @tsp: A reference to the telemetry instance setup
+ *
+ * On first call this helper takes care to retrieve and cache all the resources
+ * descriptor from the platform, then, on the following invocations it will
+ * always return the cached value.
+ */
+static inline const struct scmi_telemetry_res_info *
+scmi_telemetry_res_info_get(struct scmi_tlm_setup *tsp)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+
+ if (tsp->rinfo)
+ return ACCESS_PRIVATE(tsp, rinfo);
+
+ rinfo = tsp->ops->res_get(tsp->ph);
+ /* Cache the retrieved resource info value */
+ smp_store_mb(tsp->rinfo, rinfo);
+
+ return rinfo;
+}
+
+static ssize_t scmi_tlm_all_des_write(struct file *filp,
+ const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ bool enable;
+ int ret;
+
+ ret = kstrtobool_from_user(buf, count, &enable);
+ if (ret)
+ return ret;
+
+ /* When !IS_STATE imply that is a tstamp_enable operation */
+ if (IS_STATE(cls->flags) && !enable) {
+ ret = tsp->ops->all_disable(tsp->ph, false);
+ if (ret)
+ return ret;
+ } else {
+ const struct scmi_telemetry_res_info *rinfo;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (!rinfo)
+ return -ENODEV;
+
+ for (int i = 0; i < rinfo->num_des; i++) {
+ ret = tsp->ops->state_set(tsp->ph, false,
+ rinfo->des[i]->info->id,
+ IS_STATE(cls->flags) ? &enable : NULL,
+ !IS_STATE(cls->flags) ? &enable : NULL);
+ if (ret)
+ return ret;
+ }
+ }
+
+ return count;
+}
+
+static ssize_t scmi_tlm_all_des_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ bool enabled, tstamp_enabled, state;
+ char o_buf[2];
+ int ret;
+
+ ret = tsp->ops->state_get(tsp->ph, NULL, &enabled, &tstamp_enabled);
+ if (ret)
+ return ret;
+
+ state = IS_STATE(cls->flags) ? enabled : tstamp_enabled;
+ o_buf[0] = state ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static const struct file_operations all_des_fops = {
+ .open = nonseekable_open,
+ .write = scmi_tlm_all_des_write,
+ .read = scmi_tlm_all_des_read,
+};
+
+static ssize_t scmi_tlm_obj_enable_write(struct file *filp,
+ const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ bool enabled, is_group = IS_GROUP(cls->flags);
+ int ret, res_id;
+
+ ret = kstrtobool_from_user(buf, count, &enabled);
+ if (ret)
+ return ret;
+
+ res_id = !is_group ? tlmi->de->info->id : tlmi->grp->info->id;
+ ret = tsp->ops->state_set(tsp->ph, is_group, res_id,
+ IS_STATE(cls->flags) ? &enabled : NULL,
+ !IS_STATE(cls->flags) ? &enabled : NULL);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static ssize_t scmi_tlm_obj_enable_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ const bool *enabled_state, *tstamp_enabled_state;
+ char o_buf[2];
+ bool enabled;
+
+ if (!IS_GROUP(tlmi->cls->flags)) {
+ enabled_state = &tlmi->de->enabled;
+ tstamp_enabled_state = &tlmi->de->tstamp_enabled;
+ } else {
+ enabled_state = &tlmi->grp->enabled;
+ tstamp_enabled_state = &tlmi->grp->tstamp_enabled;
+ }
+
+ enabled = IS_STATE(tlmi->cls->flags) ? *enabled_state : *tstamp_enabled_state;
+ o_buf[0] = enabled ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static const struct file_operations obj_enable_fops = {
+ .open = nonseekable_open,
+ .write = scmi_tlm_obj_enable_write,
+ .read = scmi_tlm_obj_enable_read,
+};
+
+static int scmi_tlm_open(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_buffer *data;
+
+ /* Allocate some per-open buffer */
+ data = kzalloc_obj(*data);
+ if (!data)
+ return -ENOMEM;
+
+ filp->private_data = data;
+
+ return nonseekable_open(ino, filp);
+}
+
+static int scmi_tlm_release(struct inode *ino, struct file *filp)
+{
+ kfree(filp->private_data);
+
+ return 0;
+}
+
+static ssize_t
+scmi_tlm_update_interval_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_buffer *data = filp->private_data;
+ unsigned int active_update_interval;
+
+ if (!data)
+ return 0;
+
+ if (!IS_GROUP(tlmi->cls->flags))
+ active_update_interval = tlmi->info->active_update_interval;
+ else
+ active_update_interval = tlmi->grp->active_update_interval;
+
+ if (!data->used)
+ data->used =
+ scnprintf(data->buf, SCMI_TLM_MAX_BUF_SZ, "%u,%d\n",
+ SCMI_TLM_GET_UPDATE_INTERVAL_SECS(active_update_interval),
+ SCMI_TLM_GET_UPDATE_INTERVAL_EXP(active_update_interval));
+
+ return simple_read_from_buffer(buf, count, ppos, data->buf, data->used);
+}
+
+static ssize_t
+scmi_tlm_update_interval_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_buffer *data = filp->private_data;
+ bool is_group = IS_GROUP(tlmi->cls->flags);
+ unsigned int update_interval_ms = 0, secs = 0;
+ int ret, grp_id, exp = -3;
+ char *p, *token;
+
+ if (count >= SCMI_TLM_MAX_BUF_SZ)
+ return -ENOSPC;
+
+ if (copy_from_user(data->buf, buf, count))
+ return -EFAULT;
+
+ /*
+ * Accepting interval specified as:
+ *
+ * - a single value, interpreted as milliseconds
+ * - a coma separated tuple, with interleaving spaces removed,
+ * interpreted as <secs>,<exp> so that the interval is calculated as:
+ * <secs> x 10 ^ <exp>
+ */
+ p = data->buf;
+ token = strsep(&p, ",");
+ if (!token || iscntrl(token[0]))
+ return -EINVAL;
+
+ ret = kstrtouint(strim(token), 0, &secs);
+ if (ret)
+ return ret;
+
+ if (p) {
+ token = p;
+ if (!token || iscntrl(token[0]))
+ return -EINVAL;
+
+ ret = kstrtoint(strim(token), 0, &exp);
+ if (ret)
+ return ret;
+ }
+
+ update_interval_ms = SCMI_TLM_BUILD_UPDATE_INTERVAL(secs, exp);
+
+ grp_id = !is_group ? SCMI_TLM_GRP_INVALID : tlmi->grp->info->id;
+ ret = tsp->ops->collection_configure(tsp->ph, grp_id, !is_group, NULL,
+ &update_interval_ms, NULL);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static const struct file_operations current_interval_fops = {
+ .open = scmi_tlm_open,
+ .read = scmi_tlm_update_interval_read,
+ .write = scmi_tlm_update_interval_write,
+ .release = scmi_tlm_release,
+};
+
+static ssize_t scmi_tlm_de_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_buffer *data = filp->private_data;
+ int ret;
+
+ if (!data)
+ return 0;
+
+ if (!data->used) {
+ struct scmi_telemetry_de_sample sample;
+
+ sample.id = tlmi->de->info->id;
+ ret = tsp->ops->de_data_read(tsp->ph, &sample);
+ if (ret)
+ return ret;
+
+ data->used = scnprintf(data->buf, SCMI_TLM_MAX_BUF_SZ,
+ "%llu %016llX\n", sample.tstamp,
+ sample.val);
+ }
+
+ return simple_read_from_buffer(buf, count, ppos, data->buf, data->used);
+}
+
+static const struct file_operations de_read_fops = {
+ .open = scmi_tlm_open,
+ .read = scmi_tlm_de_read,
+ .release = scmi_tlm_release,
+};
+
+static ssize_t
+scmi_tlm_enable_read(struct file *filp, char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ char o_buf[2];
+
+ o_buf[0] = tlmi->info->enabled ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static ssize_t
+scmi_tlm_enable_write(struct file *filp, const char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ enum scmi_telemetry_collection mode = SCMI_TLM_ONDEMAND;
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ bool enabled;
+ int ret;
+
+ ret = kstrtobool_from_user(buf, count, &enabled);
+ if (ret)
+ return ret;
+
+ ret = tsp->ops->collection_configure(tsp->ph, SCMI_TLM_GRP_INVALID, true,
+ &enabled, NULL, &mode);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static const struct file_operations tlm_enable_fops = {
+ .open = nonseekable_open,
+ .read = scmi_tlm_enable_read,
+ .write = scmi_tlm_enable_write,
+};
+
+static ssize_t
+scmi_tlm_intrv_discrete_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ bool discrete;
+ char o_buf[2];
+
+ discrete = !IS_GROUP(tlmi->cls->flags) ?
+ tlmi->info->intervals->discrete : tlmi->grp->intervals->discrete;
+
+ o_buf[0] = discrete ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static const struct file_operations intrv_discrete_fops = {
+ .open = nonseekable_open,
+ .read = scmi_tlm_intrv_discrete_read,
+};
+
+static ssize_t
+scmi_tlm_reset_write(struct file *filp, const char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ int ret;
+
+ ret = tlmi->tsp->ops->reset(tlmi->tsp->ph);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static const struct file_operations reset_fops = {
+ .open = nonseekable_open,
+ .write = scmi_tlm_reset_write,
+};
+
+static int sa_u32_get(void *data, u64 *val)
+{
+ *val = *(u32 *)data;
+ return 0;
+}
+
+static int sa_u32_set(void *data, u64 val)
+{
+ *(u32 *)data = val;
+ return 0;
+}
+
+static int sa_u32_open(struct inode *ino, struct file *filp)
+{
+ return simple_attr_open(ino, filp, sa_u32_get, sa_u32_set, "%u\n");
+}
+
+static int sa_s32_open(struct inode *ino, struct file *filp)
+{
+ return simple_attr_open(ino, filp, sa_u32_get, sa_u32_set, "%d\n");
+}
+
+static int sa_x32_open(struct inode *ino, struct file *filp)
+{
+ return simple_attr_open(ino, filp, sa_u32_get, sa_u32_set, "0x%X\n");
+}
+
+static const struct file_operations sa_x32_ro_fops = {
+ .open = sa_x32_open,
+ .read = simple_attr_read,
+ .release = simple_attr_release,
+};
+
+static const struct file_operations sa_u32_ro_fops = {
+ .open = sa_u32_open,
+ .read = simple_attr_read,
+ .release = simple_attr_release,
+};
+
+static const struct file_operations sa_s32_ro_fops = {
+ .open = sa_s32_open,
+ .read = simple_attr_read,
+ .release = simple_attr_release,
+};
+
+static ssize_t
+scmi_de_impl_version_read(struct file *filp, char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_buffer *data = filp->private_data;
+
+ if (!data)
+ return 0;
+
+ if (!data->used)
+ data->used = scnprintf(data->buf, SCMI_TLM_MAX_BUF_SZ,
+ "%pUL\n", tlmi->info->base.de_impl_version);
+
+ return simple_read_from_buffer(buf, count, ppos, data->buf, data->used);
+}
+
+static const struct file_operations de_impl_vers_fops = {
+ .open = scmi_tlm_open,
+ .read = scmi_de_impl_version_read,
+ .release = scmi_tlm_release,
+};
+
+static ssize_t scmi_tlm_priv_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_priv *tp = filp->private_data;
+
+ return simple_read_from_buffer(buf, count, ppos, tp->buf, tp->buf_len);
+}
+
+static int scmi_tlm_priv_string_init(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp)
+{
+ const char *str = tlmi->priv;
+
+ tp->buf = kasprintf(GFP_KERNEL, "%s\n", str);
+ if (!tp->buf)
+ return -ENOMEM;
+
+ tp->buf_len = strlen(tp->buf) + 1;
+
+ return 0;
+}
+
+static int scmi_tlm_priv_string_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp,
+ scmi_tlm_priv_string_init, NULL);
+}
+
+static const struct file_operations string_ro_fops = {
+ .open = scmi_tlm_priv_string_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+static int scmi_tlm_priv_available_init(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp)
+{
+ struct scmi_tlm_intervals *intervals;
+ int len = 0;
+
+ intervals = !IS_GROUP(tlmi->cls->flags) ?
+ tlmi->info->intervals : tlmi->grp->intervals;
+ tp->buf_len = intervals->num_intervals * MAX_AVAILABLE_INTERV_CHAR_LENGTH;
+ tp->buf = kzalloc(tp->buf_len, GFP_KERNEL);
+ if (!tp->buf)
+ return -ENOMEM;
+
+ for (int i = 0; i < intervals->num_intervals; i++) {
+ u32 ivl;
+
+ ivl = intervals->update_intervals[i];
+ len += scnprintf(tp->buf + len, tp->buf_len - len,
+ "%u,%d ",
+ SCMI_TLM_GET_UPDATE_INTERVAL_SECS(ivl),
+ SCMI_TLM_GET_UPDATE_INTERVAL_EXP(ivl));
+ }
+
+ tp->buf[len - 1] = '\n';
+
+ return 0;
+}
+
+static int scmi_tlm_priv_available_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp,
+ scmi_tlm_priv_available_init, NULL);
+}
+
+static const struct file_operations available_interv_fops = {
+ .open = scmi_tlm_priv_available_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+static const struct scmi_tlm_class tlm_tops[] = {
+ TLM_ANON_CLASS("all_des_enable", TLM_IS_STATE,
+ S_IFREG | 0666, &all_des_fops, NULL),
+ TLM_ANON_CLASS("all_des_tstamp_enable", 0,
+ S_IFREG | 0666, &all_des_fops, NULL),
+ TLM_ANON_CLASS("current_update_interval_ms", 0,
+ S_IFREG | 0666, ¤t_interval_fops, NULL),
+ TLM_ANON_CLASS("intervals_discrete", 0,
+ S_IFREG | 0444, &intrv_discrete_fops, NULL),
+ TLM_ANON_CLASS("available_update_intervals_ms", 0,
+ S_IFREG | 0444, &available_interv_fops, NULL),
+ TLM_ANON_CLASS("de_implementation_version", 0,
+ S_IFREG | 0444, &de_impl_vers_fops, NULL),
+ TLM_ANON_CLASS("tlm_enable", 0,
+ S_IFREG | 0666, &tlm_enable_fops, NULL),
+ TLM_ANON_CLASS(NULL, 0, 0, NULL, NULL),
+};
+
+DEFINE_TLM_CLASS(reset_tlmo, "reset", 0, S_IFREG | 0200, &reset_fops, NULL);
+
+DEFINE_TLM_CLASS(des_dir_cls, "des", 0,
+ S_IFDIR | 0700, NULL, NULL);
+DEFINE_TLM_CLASS(name_tlmo, "name", 0,
+ S_IFREG | 0444, &string_ro_fops, NULL);
+DEFINE_TLM_CLASS(ena_tlmo, "enable", TLM_IS_STATE,
+ S_IFREG | 0666, &obj_enable_fops, NULL);
+DEFINE_TLM_CLASS(tstamp_ena_tlmo, "tstamp_enable", 0,
+ S_IFREG | 0666, &obj_enable_fops, NULL);
+DEFINE_TLM_CLASS(type_tlmo, "type", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(unit_tlmo, "unit", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(unit_exp_tlmo, "unit_exp", 0,
+ S_IFREG | 0444, &sa_s32_ro_fops, NULL);
+DEFINE_TLM_CLASS(instance_id_tlmo, "instance_id", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(compo_type_tlmo, "compo_type", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(compo_inst_id_tlmo, "compo_instance_id", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(tstamp_rate_tlmo, "tstamp_rate", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(persistent_tlmo, "persistent", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(value_tlmo, "value", 0,
+ S_IFREG | 0444, &de_read_fops, NULL);
+
+static int scmi_telemetry_de_populate(struct super_block *sb,
+ struct scmi_tlm_setup *tsp,
+ struct dentry *parent,
+ const struct scmi_telemetry_de *de,
+ bool fully_enumerated)
+{
+ struct scmi_tlm_de_info *dei = de->info;
+
+ stlmfs_create_dentry(sb, tsp, parent, &ena_tlmo, de);
+ stlmfs_create_dentry(sb, tsp, parent, &value_tlmo, de);
+ if (!fully_enumerated)
+ return 0;
+
+ if (de->name_support)
+ stlmfs_create_dentry(sb, tsp, parent, &name_tlmo, dei->name);
+
+ if (de->tstamp_support) {
+ stlmfs_create_dentry(sb, tsp, parent, &tstamp_ena_tlmo, de);
+ stlmfs_create_dentry(sb, tsp, parent, &tstamp_rate_tlmo,
+ &dei->ts_rate);
+ }
+
+ stlmfs_create_dentry(sb, tsp, parent, &type_tlmo, &dei->type);
+ stlmfs_create_dentry(sb, tsp, parent, &unit_tlmo, &dei->unit);
+ stlmfs_create_dentry(sb, tsp, parent, &unit_exp_tlmo, &dei->unit_exp);
+ stlmfs_create_dentry(sb, tsp, parent, &instance_id_tlmo, &dei->instance_id);
+ stlmfs_create_dentry(sb, tsp, parent, &compo_type_tlmo, &dei->compo_type);
+ stlmfs_create_dentry(sb, tsp, parent, &compo_inst_id_tlmo,
+ &dei->compo_instance_id);
+ stlmfs_create_dentry(sb, tsp, parent, &persistent_tlmo, &dei->persistent);
+
+ return 0;
+}
+
+static int
+scmi_telemetry_des_lazy_enumerate(struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_res_info *rinfo)
+{
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+
+ for (int i = 0; i < rinfo->num_des; i++) {
+ const struct scmi_telemetry_de *de = rinfo->des[i];
+ struct dentry *de_dir_dentry;
+ int ret;
+
+ struct scmi_tlm_class *de_tlm_cls __free(kfree) =
+ kzalloc(sizeof(*de_tlm_cls), GFP_KERNEL);
+ if (!de_tlm_cls)
+ return -ENOMEM;
+
+ de_tlm_cls->name = kasprintf(GFP_KERNEL, "0x%08X", de->info->id);
+ if (!de_tlm_cls->name)
+ return -ENOMEM;
+
+ de_tlm_cls->mode = S_IFDIR | 0700;
+ de_tlm_cls->flags = TLM_IS_DYNAMIC;
+ de_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->des_dentry,
+ de_tlm_cls, de);
+
+ ret = scmi_telemetry_de_populate(sb, tsp, de_dir_dentry, de,
+ rinfo->fully_enumerated);
+ if (ret)
+ return ret;
+
+ retain_and_null_ptr(de_tlm_cls);
+ }
+
+ ti->res_enumerated = true;
+
+ dev_info(tsp->dev, "Found %d Telemetry DE resources.\n", rinfo->num_des);
+
+ return 0;
+}
+
+static int scmi_telemetry_des_initialize(struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+
+ rinfo = scmi_telemetry_res_info_get(ti->tsp);
+ if (!rinfo)
+ return -ENODEV;
+
+ return scmi_telemetry_des_lazy_enumerate(ti, rinfo);
+}
+
+DEFINE_TLM_CLASS(version_tlmo, "version", 0,
+ S_IFREG | 0444, &sa_x32_ro_fops, NULL);
+
+static int scmi_tlm_bulk_on_demand(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ return tsp->ops->des_bulk_read(tsp->ph, res_id, num_samples, samples);
+}
+
+static int scmi_tlm_buffer_fill(struct device *dev, char *buf, size_t size,
+ int *len, int num,
+ struct scmi_telemetry_de_sample *samples)
+{
+ int idx, bytes = 0;
+
+ /* Loop till there space for the next line */
+ for (idx = 0; idx < num && size - bytes >= MAX_BULK_LINE_CHAR_LENGTH; idx++) {
+ bytes += scnprintf(buf + bytes, size - bytes,
+ "0x%08X %llu %016llX\n", samples[idx].id,
+ samples[idx].tstamp, samples[idx].val);
+ }
+
+ if (idx < num) {
+ dev_err(dev, "Bulk buffer truncated !\n");
+ return -ENOSPC;
+ }
+
+ if (len)
+ *len = bytes;
+
+ return 0;
+}
+
+static int scmi_tlm_bulk_buffer_fill(struct scmi_tlm_setup *tsp,
+ struct scmi_tlm_priv *tp,
+ int res_id, int num_samples)
+{
+ int ret;
+
+ struct scmi_telemetry_de_sample *samples __free(kfree) =
+ kcalloc(num_samples, sizeof(*samples), GFP_KERNEL);
+ if (!samples)
+ return -ENOMEM;
+
+ ret = tp->bulk_retrieve(tsp, res_id, &num_samples, samples);
+ if (ret)
+ return ret;
+
+ return scmi_tlm_buffer_fill(tsp->dev, tp->buf, tp->buf_sz, &tp->buf_len,
+ num_samples, samples);
+}
+
+static int scmi_tlm_priv_data_init(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp)
+{
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ bool is_group = IS_GROUP(cls->flags);
+ int res_id, num_samples;
+
+ num_samples = !is_group ? tlmi->info->base.num_des :
+ tlmi->grp->info->num_des;
+ res_id = is_group ? tlmi->grp->info->id : SCMI_TLM_GRP_INVALID;
+ tp->buf_sz = num_samples * MAX_BULK_LINE_CHAR_LENGTH;
+ /*
+ * Note that tp->buf is a scratch buffer, filled once, used to
+ * support multiple chunked read and freed in
+ * scmi_tlm_priv_release.
+ */
+ tp->buf = kzalloc(tp->buf_sz, GFP_KERNEL);
+ if (!tp->buf)
+ return -ENOMEM;
+
+ return scmi_tlm_bulk_buffer_fill(tlmi->tsp, tp, res_id, num_samples);
+}
+
+static int scmi_tlm_priv_data_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp, scmi_tlm_priv_data_init,
+ scmi_tlm_bulk_on_demand);
+}
+
+static const struct file_operations scmi_tlm_data_fops = {
+ .owner = THIS_MODULE,
+ .open = scmi_tlm_priv_data_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+DEFINE_TLM_CLASS(data_tlmo, "des_bulk_read", 0,
+ S_IFREG | 0444, &scmi_tlm_data_fops, NULL);
+
+static int scmi_tlm_bulk_single_read(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ return tsp->ops->des_sample_get(tsp->ph, res_id, num_samples, samples);
+}
+
+static int scmi_tlm_priv_single_read_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp, scmi_tlm_priv_data_init,
+ scmi_tlm_bulk_single_read);
+}
+
+static const struct file_operations scmi_tlm_single_sample_fops = {
+ .owner = THIS_MODULE,
+ .open = scmi_tlm_priv_single_read_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+DEFINE_TLM_CLASS(single_sample_tlmo, "des_single_sample_read", 0,
+ S_IFREG | 0444, &scmi_tlm_single_sample_fops, NULL);
+
+static const struct scmi_tlm_class tlm_grps[] = {
+ TLM_ANON_CLASS("enable", TLM_IS_STATE | TLM_IS_GROUP,
+ S_IFREG | 0666, &obj_enable_fops, NULL),
+ TLM_ANON_CLASS("tstamp_enable", TLM_IS_GROUP,
+ S_IFREG | 0666, &obj_enable_fops, NULL),
+ TLM_ANON_CLASS(NULL, 0, 0, NULL, NULL),
+};
+
+DEFINE_TLM_CLASS(grp_data_tlmo, "des_bulk_read", TLM_IS_GROUP,
+ S_IFREG | 0444, &scmi_tlm_data_fops, NULL);
+
+DEFINE_TLM_CLASS(groups_dir_cls, "groups", 0, S_IFDIR | 0700, NULL, NULL);
+
+DEFINE_TLM_CLASS(grp_single_sample_tlmo, "des_single_sample_read", TLM_IS_GROUP,
+ S_IFREG | 0444, &scmi_tlm_single_sample_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_composing_des_tlmo, "composing_des", TLM_IS_GROUP,
+ S_IFREG | 0444, &string_ro_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_current_interval_tlmo, "current_update_interval_ms",
+ TLM_IS_GROUP, S_IFREG | 0666,
+ ¤t_interval_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_available_interval_tlmo, "available_update_intervals_ms",
+ TLM_IS_GROUP, S_IFREG | 0444, &available_interv_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_intervals_discrete_tlmo, "intervals_discrete",
+ TLM_IS_GROUP, S_IFREG | 0444, &intrv_discrete_fops, NULL);
+
+static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+ struct device *dev = tsp->dev;
+ struct dentry *grp_dir_dentry;
+
+ if (ti->info->base.num_groups == 0)
+ return 0;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (!rinfo)
+ return -ENODEV;
+
+ for (int i = 0; i < rinfo->num_groups; i++) {
+ const struct scmi_telemetry_group *grp = &rinfo->grps[i];
+
+ struct scmi_tlm_class *grp_tlm_cls __free(kfree) =
+ kzalloc(sizeof(*grp_tlm_cls), GFP_KERNEL);
+ if (!grp_tlm_cls)
+ return -ENOMEM;
+
+ grp_tlm_cls->name = kasprintf(GFP_KERNEL, "%u", grp->info->id);
+ if (!grp_tlm_cls->name)
+ return -ENOMEM;
+
+ grp_tlm_cls->mode = S_IFDIR | 0700;
+ grp_tlm_cls->flags = TLM_IS_DYNAMIC;
+
+ grp_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->grps_dentry,
+ grp_tlm_cls, grp);
+
+ for (const struct scmi_tlm_class *gto = tlm_grps; gto->name; gto++)
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry, gto, grp);
+
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_composing_des_tlmo, grp->des_str);
+
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_data_tlmo, grp);
+ if (ti->info->single_read_support)
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_single_sample_tlmo, grp);
+
+ if (ti->info->per_group_config_support) {
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_current_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_available_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_intervals_discrete_tlmo, grp);
+ }
+
+ retain_and_null_ptr(grp_tlm_cls);
+ }
+
+ dev_info(dev, "Found %d Telemetry GROUPS resources.\n",
+ rinfo->num_groups);
+
+ return 0;
+}
+
+static struct scmi_tlm_instance *scmi_tlm_init(struct scmi_tlm_setup *tsp,
+ int instance_id)
+{
+ struct device *dev = tsp->dev;
+ struct scmi_tlm_instance *ti;
+
+ ti = devm_kzalloc(dev, sizeof(*ti), GFP_KERNEL);
+ if (!ti)
+ return ERR_PTR(-ENOMEM);
+
+ ti->info = tsp->ops->info_get(tsp->ph);
+ if (!ti->info)
+ return dev_err_ptr_probe(dev,
+ -EINVAL, "invalid Telemetry info !\n");
+
+ ti->id = instance_id;
+ ti->tsp = tsp;
+
+ return ti;
+}
+
+static int scmi_telemetry_probe(struct scmi_device *sdev)
+{
+ const struct scmi_handle *handle = sdev->handle;
+ struct scmi_protocol_handle *ph;
+ struct device *dev = &sdev->dev;
+ struct scmi_tlm_instance *ti;
+ struct scmi_tlm_setup *tsp;
+ struct super_block *sb;
+ const void *ops;
+
+ if (!handle)
+ return -ENODEV;
+
+ ops = handle->devm_protocol_get(sdev, sdev->protocol_id, &ph);
+ if (IS_ERR(ops))
+ return dev_err_probe(dev, PTR_ERR(ops),
+ "Cannot access protocol:0x%X\n",
+ sdev->protocol_id);
+
+ tsp = devm_kzalloc(dev, sizeof(*tsp), GFP_KERNEL);
+ if (!tsp)
+ return -ENOMEM;
+
+ tsp->dev = dev;
+ tsp->ops = ops;
+ tsp->ph = ph;
+
+ ti = scmi_tlm_init(tsp, atomic_fetch_inc(&scmi_tlm_instance_count));
+ if (IS_ERR(ti))
+ return PTR_ERR(ti);
+
+ mutex_lock(&stlmfs_mtx);
+ list_add(&ti->node, &scmi_telemetry_instances);
+ sb = stlmfs_sb;
+ mutex_unlock(&stlmfs_mtx);
+
+ /*
+ * In the rare case that the file system had already been mounted by the
+ * time this instance was probed, register explicitly, since the list
+ * has been scanned already.
+ */
+ if (sb) {
+ int ret;
+
+ ret = scmi_telemetry_instance_register(sb, ti);
+ if (ret) {
+ dev_err(dev, "Failed to register instance %u at probe.\n",
+ ti->id);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static void scmi_telemetry_remove(struct scmi_device *sdev)
+{
+ struct scmi_tlm_instance *ti, *tmp;
+
+ guard(mutex)(&stlmfs_mtx);
+ list_for_each_entry_safe(ti, tmp, &scmi_telemetry_instances, node) {
+ list_del(&ti->node);
+ stlmfs_instances--;
+ }
+
+ atomic_dec(&scmi_tlm_instance_count);
+}
+
+static const struct scmi_device_id scmi_id_table[] = {
+ { SCMI_PROTOCOL_TELEMETRY, "telemetry" },
+ { }
+};
+MODULE_DEVICE_TABLE(scmi, scmi_id_table);
+
+static struct scmi_driver scmi_telemetry_driver = {
+ .name = "scmi-telemetry-driver",
+ .probe = scmi_telemetry_probe,
+ .remove = scmi_telemetry_remove,
+ .id_table = scmi_id_table,
+};
+
+static struct inode *stlmfs_alloc_inode(struct super_block *sb)
+{
+ struct scmi_tlm_inode *tlmi;
+
+ tlmi = alloc_inode_sb(sb, stlmfs_inode_cachep, GFP_KERNEL);
+ if (!tlmi)
+ return NULL;
+
+ tlmi->cls = NULL;
+
+ return &tlmi->vfs_inode;
+}
+
+static void stlmfs_free_inode(struct inode *inode)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(inode);
+
+ if (tlmi->cls && IS_DYNAMIC(tlmi->cls->flags)) {
+ kfree(tlmi->cls->name);
+ kfree(tlmi->cls);
+ }
+
+ kmem_cache_free(stlmfs_inode_cachep, tlmi);
+}
+
+static const struct super_operations tlm_sops = {
+ .statfs = simple_statfs,
+ .alloc_inode = stlmfs_alloc_inode,
+ .free_inode = stlmfs_free_inode,
+};
+
+static struct dentry *stlmfs_create_root_dentry(struct super_block *sb)
+{
+ struct dentry *dentry;
+ struct inode *inode;
+
+ inode = stlmfs_get_inode(sb, S_IFDIR | 0755);
+ if (!inode)
+ return ERR_PTR(-ENOMEM);
+
+ inode->i_op = &simple_dir_inode_operations;
+ inode->i_fop = &simple_dir_operations;
+
+ dentry = d_make_root(inode);
+ if (!dentry)
+ return ERR_PTR(-ENOMEM);
+
+ return dentry;
+}
+
+static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
+{
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+
+ scnprintf(ti->name, MAX_INST_NAME, "tlm_%d", ti->id);
+
+ /* Allocate top instance node */
+ ti->top_cls.name = ti->name;
+ ti->top_cls.mode = S_IFDIR | 0755;
+
+ /* Create the root of this instance */
+ ti->top_dentry = stlmfs_create_dentry(sb, tsp, sb->s_root, &ti->top_cls, NULL);
+ for (const struct scmi_tlm_class *tlmo = tlm_tops; tlmo->name; tlmo++)
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, tlmo, ti->info);
+
+ if (ti->info->reset_support)
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &reset_tlmo, NULL);
+
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &version_tlmo,
+ &ti->info->base.version);
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &data_tlmo, ti->info);
+ if (ti->info->single_read_support)
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry,
+ &single_sample_tlmo, ti->info);
+ ti->des_dentry =
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &des_dir_cls, NULL);
+ ti->grps_dentry =
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &groups_dir_cls, NULL);
+
+ return 0;
+}
+
+static int scmi_telemetry_instance_register(struct super_block *sb,
+ struct scmi_tlm_instance *ti)
+{
+ int ret;
+
+ ti->sb = sb;
+ ret = scmi_tlm_root_dentries_initialize(ti);
+ if (ret)
+ return ret;
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ret;
+
+ ret = scmi_telemetry_groups_initialize(ti);
+ if (ret) {
+ dev_warn(ti->tsp->dev,
+ "Failed to initialize groups for instance %s.\n",
+ ti->top_cls.name);
+ }
+
+ return 0;
+}
+
+static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
+{
+ struct scmi_tlm_instance *ti;
+ struct dentry *root_dentry;
+ int ret;
+
+ sb->s_magic = TLM_FS_MAGIC;
+ sb->s_blocksize = PAGE_SIZE;
+ sb->s_blocksize_bits = PAGE_SHIFT;
+ sb->s_op = &tlm_sops;
+
+ root_dentry = stlmfs_create_root_dentry(sb);
+ if (IS_ERR(root_dentry))
+ return PTR_ERR(root_dentry);
+
+ sb->s_root = root_dentry;
+
+ mutex_lock(&stlmfs_mtx);
+ list_for_each_entry(ti, &scmi_telemetry_instances, node) {
+ mutex_unlock(&stlmfs_mtx);
+ ret = scmi_telemetry_instance_register(sb, ti);
+ if (ret)
+ dev_err(ti->tsp->dev,
+ "Failed to register instance %u.\n", ti->id);
+ mutex_lock(&stlmfs_mtx);
+ }
+ stlmfs_sb = sb;
+ mutex_unlock(&stlmfs_mtx);
+
+ return 0;
+}
+
+static int stlmfs_get_tree(struct fs_context *fc)
+{
+ return get_tree_single(fc, stlmfs_fill_super);
+}
+
+static const struct fs_context_operations stlmfs_fc_ops = {
+ .get_tree = stlmfs_get_tree,
+};
+
+static int stlmfs_init_fs_context(struct fs_context *fc)
+{
+ fc->ops = &stlmfs_fc_ops;
+
+ return 0;
+}
+
+static void stlmfs_kill_sb(struct super_block *sb)
+{
+ mutex_lock(&stlmfs_mtx);
+ stlmfs_sb = NULL;
+ mutex_unlock(&stlmfs_mtx);
+
+ kill_anon_super(sb);
+}
+
+static struct file_system_type scmi_telemetry_fs = {
+ .owner = THIS_MODULE,
+ .name = TLM_FS_NAME,
+ .kill_sb = stlmfs_kill_sb,
+ .init_fs_context = stlmfs_init_fs_context,
+ .fs_flags = 0,
+};
+
+static void stlmfs_init_once(void *arg)
+{
+ struct scmi_tlm_inode *tlmi = arg;
+
+ inode_init_once(&tlmi->vfs_inode);
+}
+
+static int __init scmi_telemetry_init(void)
+{
+ int ret;
+
+ ret = sysfs_create_mount_point(fs_kobj, TLM_FS_MNT);
+ if (ret && ret != -EEXIST)
+ return ret;
+
+ stlmfs_inode_cachep = kmem_cache_create("stlmfs_inode_cache",
+ sizeof(struct scmi_tlm_inode), 0,
+ SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
+ stlmfs_init_once);
+ if (!stlmfs_inode_cachep) {
+ ret = -ENOMEM;
+ goto out_mnt;
+ }
+
+ ret = register_filesystem(&scmi_telemetry_fs);
+ if (ret)
+ goto out_kmem;
+
+ ret = scmi_register(&scmi_telemetry_driver);
+ if (ret)
+ goto out_reg;
+
+ return 0;
+
+out_reg:
+ unregister_filesystem(&scmi_telemetry_fs);
+out_kmem:
+ kmem_cache_destroy(stlmfs_inode_cachep);
+out_mnt:
+ sysfs_remove_mount_point(fs_kobj, TLM_FS_MNT);
+
+ return ret;
+}
+module_init(scmi_telemetry_init);
+
+static void __exit scmi_telemetry_exit(void)
+{
+ int ret;
+
+ scmi_unregister(&scmi_telemetry_driver);
+ ret = unregister_filesystem(&scmi_telemetry_fs);
+ if (ret)
+ pr_err("Failed to unregister %s\n", TLM_FS_NAME);
+
+ sysfs_remove_mount_point(fs_kobj, TLM_FS_MNT);
+ kmem_cache_destroy(stlmfs_inode_cachep);
+}
+module_exit(scmi_telemetry_exit);
+
+MODULE_AUTHOR("Cristian Marussi <cristian.marussi@arm.com>");
+MODULE_DESCRIPTION("ARM SCMI Telemetry Driver");
+MODULE_LICENSE("GPL");
--
2.54.0
^ permalink raw reply related
* [PATCH v4 18/31] firmware: arm_scmi: Add Telemetry debugfs ABI documentation
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add description of the debugfs SCMI Telemetry protocol ABI.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/ABI/testing/debugfs-scmi | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/Documentation/ABI/testing/debugfs-scmi b/Documentation/ABI/testing/debugfs-scmi
index ee7179ab2edf..9026f75e0016 100644
--- a/Documentation/ABI/testing/debugfs-scmi
+++ b/Documentation/ABI/testing/debugfs-scmi
@@ -68,3 +68,25 @@ Description: Max number of concurrently allowed in-flight SCMI messages for
the currently configured SCMI transport for instance <n> on the
RX channels.
Users: Debugging, any userspace test suite
+
+What: /sys/kernel/debug/scmi/<n>/protocols/0x<m>/
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A subdirectory grouping debug entries related to protocol <m>
+ for instance <n>. Each protocol owns and defines the subtree
+ of entries rooted under this directory.
+Users: Debugging, any userspace test suite
+
+What: /sys/kernel/debug/scmi/<n>/protocols/0x1B/shmtis/<n>
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A set of RO files exposed by the Telemetry protocol (0x1B) in
+ order to dump the latest snapshot of each SHMTI memory area in
+ binary format: each file is named by its SHMTI id.
+ File is seekable and a seek to position zero on an open file
+ causes the SHMTI snapshot to refreshed; file timestamps are
+ updated after each snapshot.
+ This directory reports SHMTIs for instance <n>.
+Users: Debugging, any userspace test suite
--
2.54.0
^ permalink raw reply related
* [PATCH v4 17/31] firmware: arm_scmi: Add Telemetry debugfs SHMTI dump support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Expose one debugfs entry for each discovered SHMTI that can be used to
dump the related SHMTI in binary form from TBGN up to TEND markers.
No processing is done kernel side, beside using proper accessors for
device memory.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
drivers/firmware/arm_scmi/telemetry.c | 90 +++++++++++++++++++++++++++
1 file changed, 90 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index ab1be6c462f1..a43d67494d73 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -11,6 +11,8 @@
#include <linux/compiler_types.h>
#include <linux/completion.h>
#include <linux/err.h>
+#include <linux/fs.h>
+#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/limits.h>
@@ -371,6 +373,12 @@ struct telemetry_shmti {
u32 last_magic;
};
+struct scmi_telemetry_dbg_shmti {
+ struct telemetry_shmti *shmti;
+ size_t buf_sz;
+ void *buf;
+};
+
#define SHMTI_EPLG(s) \
({ \
struct telemetry_shmti *_s = (s); \
@@ -1299,6 +1307,85 @@ scmi_telemetry_enumerate_common_intervals(struct telemetry_info *ti)
ti->info.intervals);
}
+static int scmi_telemetry_dbg_shmti_open(struct inode *inode, struct file *filp)
+{
+ struct scmi_telemetry_dbg_shmti *sblob;
+ struct telemetry_shmti *shmti;
+
+ if (!inode->i_private)
+ return -ENODEV;
+
+ shmti = inode->i_private;
+ sblob = kzalloc_obj(*sblob);
+ if (!sblob)
+ return -ENOMEM;
+
+ sblob->shmti = shmti;
+ sblob->buf = kzalloc(shmti->len, GFP_KERNEL);
+ if (!sblob->buf) {
+ kfree(sblob);
+ return -ENOMEM;
+ }
+
+ filp->private_data = sblob;
+
+ return 0;
+}
+
+static ssize_t scmi_telemetry_dbg_shmti_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_telemetry_dbg_shmti *sblob = filp->private_data;
+
+ /* Dump on first read and again after each rewind to start pos */
+ if (!sblob->buf_sz || *ppos == 0) {
+ memcpy_fromio(sblob->buf, sblob->shmti->base, sblob->shmti->len);
+ sblob->buf_sz = sblob->shmti->len;
+ /* update inode timestamps */
+ simple_inode_init_ts(file_inode(filp));
+ }
+
+ return simple_read_from_buffer(buf, count, ppos, sblob->buf, sblob->buf_sz);
+}
+
+static int scmi_telemetry_dbg_shmti_release(struct inode *inode, struct file *filp)
+{
+ struct scmi_telemetry_dbg_shmti *sblob = filp->private_data;
+
+ kfree(sblob->buf);
+ kfree(sblob);
+
+ return 0;
+}
+
+static const struct file_operations scmi_telemetry_dbg_shmti_fops = {
+ .open = scmi_telemetry_dbg_shmti_open,
+ .release = scmi_telemetry_dbg_shmti_release,
+ .read = scmi_telemetry_dbg_shmti_read,
+ .llseek = generic_file_llseek,
+ .owner = THIS_MODULE,
+};
+
+static void scmi_telemetry_debugfs_initialize(struct telemetry_info *ti)
+{
+ const struct scmi_protocol_handle *ph = ti->ph;
+ struct dentry *top, *shmti_top;
+
+ top = ph->hops->debugfs_proto_dentry_get(ph);
+ shmti_top = debugfs_create_dir("shmtis", top);
+
+ for (unsigned int i = 0; i < ti->num_shmti; i++) {
+ struct dentry *d;
+ char id[16];
+
+ snprintf(id, 16, "%u", i);
+ d = debugfs_create_file(id, 0444, shmti_top, &ti->shmti[i],
+ &scmi_telemetry_dbg_shmti_fops);
+ if (!IS_ERR(d))
+ i_size_write(d->d_inode, ti->shmti[i].len);
+ }
+}
+
static int iter_shmti_update_state(struct scmi_iterator_state *st,
const void *response, void *priv)
{
@@ -3195,6 +3282,9 @@ static int scmi_telemetry_protocol_init(const struct scmi_protocol_handle *ph)
"Could NOT register Telemetry notifications\n");
}
+ if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_PROTOCOLS))
+ scmi_telemetry_debugfs_initialize(ti);
+
return ret;
}
--
2.54.0
^ permalink raw reply related
* [PATCH v4 16/31] firmware: arm_scmi: Add common per-protocol debugfs support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Allow interested SCMI protocols to register their own specific debugfs
entries under a common per-instance and per-protocol subtree rooted
at /sys/kernel/debug/scmi/<N>/protocols/<PROTO_ID>/
Expose a helper to enable protocol initialization code to get access to
such per-protocol/per-instance dentries in order to be able to install
their own dedicated debugfs entries.
Per-protocol debugfs support is configurable and default off.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
drivers/firmware/arm_scmi/Kconfig | 14 +++++++++++++
drivers/firmware/arm_scmi/common.h | 2 ++
drivers/firmware/arm_scmi/driver.c | 29 +++++++++++++++++++++++++++
drivers/firmware/arm_scmi/protocols.h | 6 ++++++
include/linux/scmi_protocol.h | 12 ++++++++++-
5 files changed, 62 insertions(+), 1 deletion(-)
diff --git a/drivers/firmware/arm_scmi/Kconfig b/drivers/firmware/arm_scmi/Kconfig
index e3fb36825978..06d2319420a0 100644
--- a/drivers/firmware/arm_scmi/Kconfig
+++ b/drivers/firmware/arm_scmi/Kconfig
@@ -69,6 +69,20 @@ config ARM_SCMI_DEBUG_COUNTERS
such useful debug counters. This can be helpful for debugging and
SCMI monitoring.
+config ARM_SCMI_DEBUG_PROTOCOLS
+ bool "Enable SCMI protocols debug"
+ select ARM_SCMI_NEED_DEBUGFS
+ depends on DEBUG_FS
+ default n
+ help
+ Enables per-protocol specific debug features, where available.
+ When provided, such per-protocol debugfs entries are grouped
+ inside a common a subtree named by the protocol number and rooted
+ under a per-instance 'protocols' directory.
+
+ Such per-protocol entries subtree structure is freely defined
+ within the related protocol code.
+
config ARM_SCMI_QUIRKS
bool "Enable SCMI Quirks framework"
depends on JUMP_LABEL || COMPILE_TEST
diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h
index a8a45bacfa3f..79fda80f049a 100644
--- a/drivers/firmware/arm_scmi/common.h
+++ b/drivers/firmware/arm_scmi/common.h
@@ -321,6 +321,7 @@ enum debug_counters {
/**
* struct scmi_debug_info - Debug common info
* @top_dentry: A reference to the top debugfs dentry
+ * @protos: A reference to the top debugfs protocols subdirectory
* @name: Name of this SCMI instance
* @type: Type of this SCMI instance
* @is_atomic: Flag to state if the transport of this instance is atomic
@@ -328,6 +329,7 @@ enum debug_counters {
*/
struct scmi_debug_info {
struct dentry *top_dentry;
+ struct dentry *protos;
const char *name;
const char *type;
bool is_atomic;
diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c
index dd9446b54858..e844f40b19d9 100644
--- a/drivers/firmware/arm_scmi/driver.c
+++ b/drivers/firmware/arm_scmi/driver.c
@@ -18,6 +18,7 @@
#include <linux/bitmap.h>
#include <linux/cleanup.h>
+#include <linux/dcache.h>
#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/export.h>
@@ -99,6 +100,8 @@ struct scmi_xfers_info {
* has completed.
* @ph: An embedded protocol handle that will be passed down to protocol
* initialization code to identify this instance.
+ * @dbg: An optional reference to this protocol top debugfs directory; it will
+ * be automatically recursively removed on protocol de-initialization.
*
* Each protocol is initialized independently once for each SCMI platform in
* which is defined by DT and implemented by the SCMI server fw.
@@ -112,6 +115,7 @@ struct scmi_protocol_instance {
unsigned int version;
unsigned int negotiated_version;
struct scmi_protocol_handle ph;
+ struct dentry *dbg;
};
#define ph_to_pi(h) container_of(h, struct scmi_protocol_instance, ph)
@@ -2054,6 +2058,25 @@ static void scmi_common_fastchannel_db_ring(struct scmi_fc_db_info *db)
SCMI_PROTO_FC_RING_DB(64);
}
+static struct dentry *
+scmi_debugfs_proto_dentry_get(const struct scmi_protocol_handle *ph)
+{
+ struct scmi_protocol_instance *pi = ph_to_pi(ph);
+ struct scmi_info *info = handle_to_scmi_info(pi->handle);
+
+ if (!IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_PROTOCOLS))
+ return ERR_PTR(-ENODEV);
+
+ if (!pi->dbg) {
+ char proto_dir[8];
+
+ snprintf(proto_dir, 8, "0x%02X", pi->proto->id);
+ pi->dbg = debugfs_create_dir(proto_dir, info->dbg->protos);
+ }
+
+ return pi->dbg;
+}
+
static const struct scmi_proto_helpers_ops helpers_ops = {
.extended_name_get = scmi_common_extended_name_get,
.get_max_msg_size = scmi_common_get_max_msg_size,
@@ -2062,6 +2085,7 @@ static const struct scmi_proto_helpers_ops helpers_ops = {
.protocol_msg_check = scmi_protocol_msg_check,
.fastchannel_init = scmi_common_fastchannel_init,
.fastchannel_db_ring = scmi_common_fastchannel_db_ring,
+ .debugfs_proto_dentry_get = scmi_debugfs_proto_dentry_get,
};
/**
@@ -2356,6 +2380,8 @@ void scmi_protocol_release(const struct scmi_handle *handle, u8 protocol_id)
if (refcount_dec_and_test(&pi->users)) {
void *gid = pi->gid;
+ debugfs_remove_recursive(pi->dbg);
+
if (pi->proto->events)
scmi_deregister_protocol_events(handle, protocol_id);
@@ -3080,6 +3106,9 @@ static struct scmi_debug_info *scmi_debugfs_common_setup(struct scmi_info *info)
if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS))
scmi_debugfs_counters_setup(dbg, trans);
+ if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_PROTOCOLS))
+ dbg->protos = debugfs_create_dir("protocols", top_dentry);
+
dbg->top_dentry = top_dentry;
if (devm_add_action_or_reset(info->dev,
diff --git a/drivers/firmware/arm_scmi/protocols.h b/drivers/firmware/arm_scmi/protocols.h
index 3250d981664b..84ffff9376c9 100644
--- a/drivers/firmware/arm_scmi/protocols.h
+++ b/drivers/firmware/arm_scmi/protocols.h
@@ -11,6 +11,7 @@
#include <linux/bitfield.h>
#include <linux/completion.h>
+#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/kernel.h>
@@ -272,6 +273,9 @@ struct scmi_fc_info {
* gathering FC descriptions from the SCMI platform server.
* @fastchannel_db_ring: A common helper to ring a FC doorbell.
* @get_max_msg_size: A common helper to get the maximum message size.
+ * @debugfs_proto_dentry_get: A common helper to get a per-protocol debugfs top
+ * directory to use as a root. It will be
+ * recursively removed on protocol de-initialization.
*/
struct scmi_proto_helpers_ops {
int (*extended_name_get)(const struct scmi_protocol_handle *ph,
@@ -292,6 +296,8 @@ struct scmi_proto_helpers_ops {
u32 *rate_limit);
void (*fastchannel_db_ring)(struct scmi_fc_db_info *db);
int (*get_max_msg_size)(const struct scmi_protocol_handle *ph);
+ struct dentry *(*debugfs_proto_dentry_get)
+ (const struct scmi_protocol_handle *ph);
};
/**
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index c7e8a740ce16..6b0ea1c05e7f 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -1076,6 +1076,12 @@ struct scmi_notify_ops {
* never sleep and act accordingly.
* An optional atomic threshold value could be returned
* where configured.
+ * @debugfs_entry_get: method to get, and possibly create, a debugfs dentry
+ * rooted under the top debugfs directory for the SCMI
+ * instance referred by handle.
+ * @debugfs_entry_put: method to put, and possibly destroy, a debugfs dentry
+ * rooted under the top debugfs directory for the SCMI
+ * instance referred by handle.
* @notify_ops: pointer to set of notifications related operations
*/
struct scmi_handle {
@@ -1090,7 +1096,11 @@ struct scmi_handle {
void (*devm_protocol_put)(struct scmi_device *sdev, u8 proto);
bool (*is_transport_atomic)(const struct scmi_handle *handle,
unsigned int *atomic_threshold);
-
+ struct dentry __must_check *
+ (*debugfs_entry_get)(const struct scmi_handle *handle,
+ const char *name);
+ void (*debugfs_entry_put)(const struct scmi_handle *handle,
+ struct dentry *dentry);
const struct scmi_notify_ops *notify_ops;
};
--
2.54.0
^ permalink raw reply related
* [PATCH v4 15/31] firmware: arm_scmi: Add Telemetry generation counter
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a per-instance generation counter to track configuration changes and
expose a telemetry operations to get a related waitqueue for monitoring.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
drivers/firmware/arm_scmi/telemetry.c | 53 +++++++++++++++++++++++++++
include/linux/scmi_protocol.h | 5 +++
2 files changed, 58 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index 842b0fa4f07d..ab1be6c462f1 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -21,6 +21,7 @@
#include <linux/sprintf.h>
#include <linux/string.h>
#include <linux/xarray.h>
+#include <linux/wait.h>
#include "protocols.h"
#include "notify.h"
@@ -30,6 +31,7 @@
/* Updated only after ALL the mandatory features for that version are merged */
#define SCMI_PROTOCOL_SUPPORTED_VERSION 0x10000
+#define SCMI_TLM_GENERATION_ONE (SCMI_TLM_GENERATION_INVALID + 1U)
#define SCMI_TLM_TDCF_MAX_RETRIES 5
enum scmi_telemetry_protocol_cmd {
@@ -464,6 +466,7 @@ struct telemetry_info {
struct list_head free_des;
struct list_head fcs_des;
struct scmi_telemetry_info info;
+ struct wait_queue_head gen_wq;
struct notifier_block telemetry_nb;
atomic_t rinfo_initializing;
struct completion rinfo_initdone;
@@ -613,6 +616,29 @@ scmi_telemetry_tde_cache_lookup(struct telemetry_de *tde,
return 0;
}
+static inline void __scmi_telemetry_generation_set(struct telemetry_info *ti,
+ unsigned int new)
+{
+ atomic_set(&ti->info.generation, new);
+
+ wake_up_all(&ti->gen_wq);
+}
+
+static inline void scmi_telemetry_generation_update(struct telemetry_info *ti)
+{
+ unsigned int next;
+
+ /* Wrap around skipping invalid generation 0 */
+ next = (atomic_read(&ti->info.generation) + 1) ?: SCMI_TLM_GENERATION_ONE;
+
+ __scmi_telemetry_generation_set(ti, next);
+}
+
+static inline void scmi_telemetry_generation_reset(struct telemetry_info *ti)
+{
+ __scmi_telemetry_generation_set(ti, SCMI_TLM_GENERATION_ONE);
+}
+
struct scmi_tlm_de_priv {
struct telemetry_info *ti;
void *next;
@@ -2084,6 +2110,8 @@ static int __scmi_telemetry_state_set(const struct scmi_protocol_handle *ph,
tstamp_enabled_state,
*tstamp);
+ /* A local change can have an impact anyway */
+ scmi_telemetry_generation_update(ti);
return 0;
}
@@ -2145,6 +2173,9 @@ static int __scmi_telemetry_state_set(const struct scmi_protocol_handle *ph,
ph->xops->xfer_put(ph, t);
+ if (!ret)
+ scmi_telemetry_generation_update(ti);
+
return ret;
}
@@ -2248,6 +2279,9 @@ static int scmi_telemetry_all_disable(const struct scmi_protocol_handle *ph,
ph->xops->xfer_put(ph, t);
+ if (!ret)
+ scmi_telemetry_generation_update(ti);
+
return ret;
}
@@ -2320,6 +2354,9 @@ scmi_telemetry_collection_configure(const struct scmi_protocol_handle *ph,
ph->xops->xfer_put(ph, t);
+ if (!ret)
+ scmi_telemetry_generation_update(ti);
+
return ret;
}
@@ -2752,6 +2789,10 @@ static int scmi_telemetry_reset(const struct scmi_protocol_handle *ph)
struct telemetry_info *ti = ph->get_priv(ph);
scmi_telemetry_local_resources_reset(ti);
+
+ /* Reset generation now that server has been reset */
+ scmi_telemetry_generation_reset(ti);
+
/* Fetch again the states from platform. */
ret = scmi_telemetry_initial_state_lookup(ti);
if (ret)
@@ -2764,6 +2805,14 @@ static int scmi_telemetry_reset(const struct scmi_protocol_handle *ph)
return ret;
}
+static struct wait_queue_head *
+scmi_telemetry_event_wq_get(const struct scmi_protocol_handle *ph)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+
+ return &ti->gen_wq;
+}
+
static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.info_get = scmi_telemetry_info_get,
.de_lookup = scmi_telemetry_de_lookup,
@@ -2776,6 +2825,7 @@ static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.des_bulk_read = scmi_telemetry_des_bulk_read,
.des_sample_get = scmi_telemetry_des_sample_get,
.reset = scmi_telemetry_reset,
+ .event_wq_get = scmi_telemetry_event_wq_get,
};
static bool
@@ -3066,6 +3116,9 @@ static int scmi_telemetry_instance_init(struct telemetry_info *ti)
xa_init(&ti->xa_des);
xa_init(&ti->xa_lines);
+ /* Generation counter init */
+ atomic_set(&ti->info.generation, SCMI_TLM_GENERATION_ONE);
+ init_waitqueue_head(&ti->gen_wq);
atomic_set(&ti->des_enabled[ENA_STATE], 0);
atomic_set(&ti->des_enabled[ENA_TSTAMP], 0);
/* Setup resources lazy initialization */
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index 568fb7bb1a76..c7e8a740ce16 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -13,6 +13,7 @@
#include <linux/device.h>
#include <linux/notifier.h>
#include <linux/types.h>
+#include <linux/wait.h>
#include <uapi/linux/limits.h>
#include <uapi/linux/scmi.h>
@@ -889,6 +890,7 @@ enum scmi_telemetry_collection {
SCMI_TLM_SINGLE_READ,
};
+#define SCMI_TLM_GENERATION_INVALID 0U
#define SCMI_TLM_GRP_INVALID 0xFFFFFFFF
struct scmi_telemetry_group {
bool enabled;
@@ -933,6 +935,7 @@ struct scmi_telemetry_info {
bool enabled;
bool notif_enabled;
enum scmi_telemetry_collection current_mode;
+ atomic_t generation;
};
struct scmi_telemetry_de_sample {
@@ -965,6 +968,7 @@ struct scmi_telemetry_de_sample {
* This causes an immediate update platform-side of all the
* enabled DEs.
* @reset: reset configuration and telemetry data.
+ * @event_wq_get: get a reference to the event waitqueue for this instance.
*/
struct scmi_telemetry_proto_ops {
const struct scmi_telemetry_info __must_check *(*info_get)
@@ -992,6 +996,7 @@ struct scmi_telemetry_proto_ops {
int grp_id, int *num_samples,
struct scmi_telemetry_de_sample *samples);
int (*reset)(const struct scmi_protocol_handle *ph);
+ struct wait_queue_head *(*event_wq_get)(const struct scmi_protocol_handle *ph);
};
/**
--
2.54.0
^ permalink raw reply related
* [PATCH v4 14/31] firmware: arm_scmi: Add support for boot-on Telemetry
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add the initialization and discovery logic needed to detect when the
platform SCMI server is configured with telemetry enabled at boot and
perform all the needed resource enumerations to keep the kernel telemetry
subsystem state aligned with the platform boot-on configurations.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- bail-out FW_BUG errors
- fix typos in comments
- track boot-on Telemetry DE states
v2 --> v3
- split from monolithic telemetry protocol patch
- swap logic in scmi_telemetry_initial_state_lookup
---
drivers/firmware/arm_scmi/telemetry.c | 204 ++++++++++++++++++++++++++
1 file changed, 204 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index 41b109a194d9..842b0fa4f07d 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -823,6 +823,196 @@ static int iter_de_descr_process_response(const struct scmi_protocol_handle *ph,
return ret;
}
+static int scmi_telemetry_config_lookup(struct telemetry_info *ti,
+ unsigned int grp_id, bool *enabled,
+ unsigned int *active_update_interval)
+{
+ const struct scmi_protocol_handle *ph = ti->ph;
+ struct scmi_msg_telemetry_config_get *msg;
+ struct scmi_msg_resp_telemetry_config_get *resp;
+ struct scmi_xfer *t;
+ int ret;
+
+ ret = ph->xops->xfer_get_init(ph, TELEMETRY_CONFIG_GET,
+ sizeof(*msg), sizeof(*resp), &t);
+ if (ret)
+ return ret;
+
+ msg = t->tx.buf;
+ msg->grp_id = grp_id;
+ msg->flags = grp_id == SCMI_TLM_GRP_INVALID ?
+ TELEMETRY_GET_SELECTOR_ORPHANS : TELEMETRY_GET_SELECTOR_GROUP;
+
+ resp = t->rx.buf;
+ ret = ph->xops->do_xfer(ph, t);
+ if (!ret) {
+ *enabled = resp->control & TELEMETRY_ENABLE;
+ *active_update_interval =
+ SCMI_TLM_GET_UPDATE_INTERVAL(resp->sampling_rate);
+ }
+
+ ph->xops->xfer_put(ph, t);
+
+ return 0;
+}
+
+static int scmi_telemetry_group_config_lookup(struct telemetry_info *ti,
+ struct scmi_telemetry_group *grp)
+{
+ return scmi_telemetry_config_lookup(ti, grp->info->id, &grp->enabled,
+ &grp->active_update_interval);
+}
+
+static void iter_enabled_list_prepare_message(void *message,
+ unsigned int desc_index,
+ const void *priv)
+{
+ struct scmi_msg_telemetry_de_enabled_list *msg = message;
+
+ msg->index = cpu_to_le32(desc_index);
+ msg->flags = 0;
+}
+
+static int iter_enabled_list_update_state(struct scmi_iterator_state *st,
+ const void *response, void *priv)
+{
+ const struct scmi_msg_resp_telemetry_de_enabled_list *r = response;
+
+ st->num_returned = le32_get_bits(r->flags, GENMASK(15, 0));
+ st->num_remaining = le32_get_bits(r->flags, GENMASK(31, 16));
+
+ if (st->rx_len < (sizeof(*r) + sizeof(r->entry[0]) * st->num_returned))
+ return -EINVAL;
+
+ /*
+ * total enabled is not declared previously anywhere so we
+ * assume it's returned+remaining on first call.
+ */
+ if (!st->max_resources)
+ st->max_resources = st->num_returned + st->num_remaining;
+
+ return 0;
+}
+
+static int
+iter_enabled_list_process_response(const struct scmi_protocol_handle *ph,
+ const void *response,
+ struct scmi_iterator_state *st, void *priv)
+{
+ const struct scmi_msg_resp_telemetry_de_enabled_list *r = response;
+ const struct scmi_enabled_de_desc *desc;
+ struct telemetry_info *ti = priv;
+ struct telemetry_de *tde;
+ u32 de_id;
+ int ret;
+
+ desc = &r->entry[st->loop_idx];
+ de_id = le32_to_cpu(desc->id);
+ if (scmi_telemetry_tde_lookup(ti, de_id)) {
+ dev_err(ph->dev,
+ "Found INVALID DE with DUPLICATED ID:0x%08X\n", de_id);
+ return -EINVAL;
+ }
+
+ tde = scmi_telemetry_tde_get(ti, de_id);
+ if (IS_ERR(tde))
+ return PTR_ERR(tde);
+
+ tde->de.info->id = de_id;
+ tde->de.enabled = true;
+ tde->de.tstamp_enabled = desc->mode == DE_ENABLED_WITH_TSTAMP;
+
+ ret = scmi_telemetry_tde_register(ti, tde);
+ if (ret) {
+ scmi_telemetry_free_tde_put(ti, tde);
+ return ret;
+ }
+
+ scmi_telemetry_de_state_update(ti, ENA_STATE, NULL, true);
+ if (tde->de.tstamp_enabled)
+ scmi_telemetry_de_state_update(ti, ENA_TSTAMP, NULL, true);
+
+ dev_dbg(ph->dev, "Registered new ENABLED DE with ID:0x%08X\n",
+ tde->de.info->id);
+
+ return 0;
+}
+
+static int scmi_telemetry_enumerate_des_enabled_list(struct telemetry_info *ti)
+{
+ struct scmi_telemetry_res_info *rinfo = ACCESS_PRIVATE(ti, rinfo);
+ const struct scmi_protocol_handle *ph = ti->ph;
+ struct scmi_iterator_ops ops = {
+ .prepare_message = iter_enabled_list_prepare_message,
+ .update_state = iter_enabled_list_update_state,
+ .process_response = iter_enabled_list_process_response,
+ };
+ void *iter;
+ int ret;
+
+ iter = ph->hops->iter_response_init(ph, &ops, 0,
+ TELEMETRY_DE_ENABLED_LIST,
+ sizeof(u32) * 2, ti);
+ if (IS_ERR(iter))
+ return PTR_ERR(iter);
+
+ ret = ph->hops->iter_response_run(iter);
+ if (ret)
+ return ret;
+
+ dev_info(ti->ph->dev, "Found %u enabled DEs.\n", rinfo->num_des);
+
+ return 0;
+}
+
+static int scmi_telemetry_initial_state_lookup(struct telemetry_info *ti)
+{
+ struct device *dev = ti->ph->dev;
+ int ret;
+
+ ret = scmi_telemetry_config_lookup(ti, SCMI_TLM_GRP_INVALID,
+ &ti->info.enabled,
+ &ti->info.active_update_interval);
+ if (ret)
+ return ret;
+
+ if (!ti->info.enabled)
+ return 0;
+
+ /*
+ * When Telemetry is found already enabled on the platform, proceed with
+ * passive discovery using DE_ENABLED_LIST and TDCF scanning: note that
+ * this CAN only discover DEs exposed via SHMTIs.
+ * FastChannel DEs need a proper DE_DESCRIPTION enumeration, while, even
+ * though incoming Notifications could be used for passive discovery too,
+ * it would carry a considerable risk of assimilating trash as DEs.
+ */
+ dev_info(dev,
+ "Telemetry found enabled with update interval %ux10^%d\n",
+ SCMI_TLM_GET_UPDATE_INTERVAL_SECS(ti->info.active_update_interval),
+ SCMI_TLM_GET_UPDATE_INTERVAL_EXP(ti->info.active_update_interval));
+ /*
+ * Query enabled DEs list: collect states. It will include DEs from any
+ * interface. Enabled groups still NOT enumerated.
+ */
+ ret = scmi_telemetry_enumerate_des_enabled_list(ti);
+ if (ret) {
+ dev_err(dev, FW_BUG "Cannot query enabled DE list. Abort.\n");
+ return ret;
+ }
+
+ /* Discover DEs on SHMTis: collect states/offsets/values */
+ for (int id = 0; id < ti->num_shmti; id++) {
+ ret = scmi_telemetry_shmti_scan(ti, id, SCAN_DISCOVERY);
+ if (ret)
+ dev_warn(dev,
+ "Failed discovery-scan of SHMTI ID:%d - ret:%d\n",
+ id, ret);
+ }
+
+ return 0;
+}
+
static int
scmi_telemetry_de_groups_init(struct device *dev, struct telemetry_info *ti)
{
@@ -887,6 +1077,9 @@ scmi_telemetry_de_groups_init(struct device *dev, struct telemetry_info *ti)
}
}
+ for (int i = 0; i < ti->info.base.num_groups; i++)
+ scmi_telemetry_group_config_lookup(ti, &rinfo->grps[i]);
+
rinfo->num_groups = ti->info.base.num_groups;
return 0;
@@ -2559,6 +2752,11 @@ static int scmi_telemetry_reset(const struct scmi_protocol_handle *ph)
struct telemetry_info *ti = ph->get_priv(ph);
scmi_telemetry_local_resources_reset(ti);
+ /* Fetch again the states from platform. */
+ ret = scmi_telemetry_initial_state_lookup(ti);
+ if (ret)
+ dev_warn(ph->dev,
+ FW_BUG "Cannot retrieve initial state after reset.\n");
}
ph->xops->xfer_put(ph, t);
@@ -2918,6 +3116,12 @@ static int scmi_telemetry_protocol_init(const struct scmi_protocol_handle *ph)
return ret;
}
+ ret = scmi_telemetry_initial_state_lookup(ti);
+ if (ret) {
+ dev_err(dev, FW_BUG "Cannot retrieve initial state. Abort.\n");
+ return ret;
+ }
+
ti->info.base.version = ph->version;
ret = ph->set_priv(ph, ti);
--
2.54.0
^ permalink raw reply related
* [PATCH v4 13/31] firmware: arm_scmi: Add Telemetry notification support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add support for notifications to Telemetry protocol and register an
internal notifier during protocol initialization: any DE value received
inside a notification payload will be cached for future user consumption.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 -> v4
- use TDE cache to save DEs received via msg payload
v2 --> v3
- changed a few dev_err into traces
- split from monolithic telemetry protocol patch
- use memcpy_from_le32
---
drivers/firmware/arm_scmi/telemetry.c | 143 +++++++++++++++++++++++---
include/linux/scmi_protocol.h | 9 ++
2 files changed, 138 insertions(+), 14 deletions(-)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index f88650916de8..41b109a194d9 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -464,12 +464,16 @@ struct telemetry_info {
struct list_head free_des;
struct list_head fcs_des;
struct scmi_telemetry_info info;
+ struct notifier_block telemetry_nb;
atomic_t rinfo_initializing;
struct completion rinfo_initdone;
struct scmi_telemetry_res_info __private *rinfo;
struct scmi_telemetry_res_info *(*res_get)(struct telemetry_info *ti);
};
+#define telemetry_nb_to_info(x) \
+ container_of(x, struct telemetry_info, telemetry_nb)
+
static struct scmi_telemetry_res_info *
__scmi_telemetry_resources_get(struct telemetry_info *ti);
@@ -1645,7 +1649,6 @@ static void scmi_telemetry_tdcf_data_parse(struct telemetry_info *ti,
/* Parse data words ... only for the sake of updating TDE cache */
scmi_telemetry_line_data_parse(tde, &sample, payld, shmti->last_magic);
-
}
static int scmi_telemetry_tdcf_line_parse(struct telemetry_info *ti,
@@ -2432,6 +2435,7 @@ scmi_telemetry_msg_payld_process(struct telemetry_info *ti,
while (next < num_dwords) {
struct payload *payld = (struct payload *)&dwords[next];
+ struct scmi_telemetry_de_sample sample = {};
struct scmi_telemetry_de *de;
struct telemetry_de *tde;
u32 de_id;
@@ -2439,29 +2443,29 @@ scmi_telemetry_msg_payld_process(struct telemetry_info *ti,
next += LINE_LENGTH_WORDS(payld);
if (DATA_INVALID(payld)) {
- dev_err(ti->ph->dev, "MSG - Received INVALID DATA line\n");
+ trace_scmi_tlm_access(PAYLD_ID(payld), "MSG_INVALID", 0, 0);
continue;
}
de_id = le32_to_cpu(payld->id);
de = xa_load(&ti->xa_des, de_id);
if (!de || !de->enabled) {
- dev_err(ti->ph->dev,
- "MSG - Received INVALID DE - ID:%u enabled:%c\n",
- de_id, de ? (de->enabled ? 'Y' : 'N') : 'X');
+ trace_scmi_tlm_access(de_id, de ? "MSG_DE_DISABLED" :
+ "MSG_DE_UNKNOWN", 0, 0);
continue;
}
- tde = to_tde(de);
- guard(mutex)(&tde->mtx);
- tde->cached_msg = true;
- tde->last_val = LINE_DATA_GET(&payld->tsl);
- /* TODO BLK_TS in notification payloads */
- tde->last_ts = HAS_LINE_EXT(payld) && LINE_TS_VALID(payld) ?
+ sample.val = LINE_DATA_GET(&payld->tsl);
+ sample.tstamp = HAS_LINE_EXT(payld) && LINE_TS_VALID(payld) ?
LINE_TSTAMP_GET(&payld->tsl) : 0;
- trace_scmi_tlm_collect(tde->last_ts, tde->de.info->id,
- tde->last_val, "MESSAGE");
+ /* Trace originally read tstamp */
+ trace_scmi_tlm_collect(sample.tstamp, de->info->id, sample.val,
+ "MESSAGE");
+
+ tde = to_tde(de);
+ tde->cached_msg = true;
+ scmi_telemetry_tde_cache_update(tde, &sample, NULL);
}
}
@@ -2576,6 +2580,98 @@ static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.reset = scmi_telemetry_reset,
};
+static bool
+scmi_telemetry_notify_supported(const struct scmi_protocol_handle *ph,
+ u8 evt_id, u32 src_id)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+
+ return ti->info.continuos_update_support;
+}
+
+static int
+scmi_telemetry_set_notify_enabled(const struct scmi_protocol_handle *ph,
+ u8 evt_id, u32 src_id, bool enable)
+{
+ return 0;
+}
+
+static void *
+scmi_telemetry_fill_custom_report(const struct scmi_protocol_handle *ph,
+ u8 evt_id, ktime_t timestamp,
+ const void *payld, size_t payld_sz,
+ void *report, u32 *src_id)
+{
+ const struct scmi_telemetry_update_notify_payld *p = payld;
+ struct scmi_telemetry_update_report *r = report;
+
+ /* At least sized as an empty notification */
+ if (payld_sz < sizeof(*p))
+ return NULL;
+
+ r->timestamp = timestamp;
+ r->agent_id = le32_to_cpu(p->agent_id);
+ r->status = le32_to_cpu(p->status);
+ r->num_dwords = le32_to_cpu(p->num_dwords);
+ /*
+ * Allocated dwords and report are sized as max_msg_size, so as
+ * to allow for the maximum payload permitted by the configured
+ * transport. Overflow is not possible since out-of-size messages
+ * are dropped at the transport layer.
+ */
+ if (r->num_dwords)
+ memcpy_from_le32(r->dwords, p->array, r->num_dwords);
+
+ *src_id = 0;
+
+ return r;
+}
+
+static const struct scmi_event tlm_events[] = {
+ {
+ .id = SCMI_EVENT_TELEMETRY_UPDATE,
+ .max_payld_sz = 0,
+ .max_report_sz = 0,
+ },
+};
+
+static const struct scmi_event_ops tlm_event_ops = {
+ .is_notify_supported = scmi_telemetry_notify_supported,
+ .set_notify_enabled = scmi_telemetry_set_notify_enabled,
+ .fill_custom_report = scmi_telemetry_fill_custom_report,
+};
+
+static const struct scmi_protocol_events tlm_protocol_events = {
+ .queue_sz = SCMI_PROTO_QUEUE_SZ,
+ .ops = &tlm_event_ops,
+ .evts = tlm_events,
+ .num_events = ARRAY_SIZE(tlm_events),
+ .num_sources = 1,
+};
+
+static int scmi_telemetry_notifier(struct notifier_block *nb,
+ unsigned long event, void *data)
+{
+ struct scmi_telemetry_update_report *er = data;
+ struct telemetry_info *ti = telemetry_nb_to_info(nb);
+
+ if (er->status) {
+ trace_scmi_tlm_access(0, "BAD_NOTIF_MSG", 0, 0);
+ return NOTIFY_DONE;
+ }
+
+ trace_scmi_tlm_access(0, "TLM_UPDATE_MSG", 0, 0);
+ /* Lookup the embedded DEs in the notification payload ... */
+ if (er->num_dwords)
+ scmi_telemetry_msg_payld_process(ti, er->num_dwords, er->dwords);
+
+ /* ...scan the SHMTI/FCs for any other DE updates. */
+ if (ti->streaming_mode)
+ scmi_telemetry_scan_update(ti);
+
+ return NOTIFY_OK;
+}
+
/**
* scmi_telemetry_resources_alloc - Resources allocation
* @ti: A reference to the telemetry info descriptor for this instance
@@ -2824,7 +2920,25 @@ static int scmi_telemetry_protocol_init(const struct scmi_protocol_handle *ph)
ti->info.base.version = ph->version;
- return ph->set_priv(ph, ti);
+ ret = ph->set_priv(ph, ti);
+ if (ret)
+ return ret;
+
+ /*
+ * Register a notifier anyway straight upon protocol initialization
+ * since there could be some DEs that are ONLY reported by notifications
+ * even though the chosen collection method was SHMTI/FCs.
+ */
+ if (ti->info.continuos_update_support) {
+ ti->telemetry_nb.notifier_call = &scmi_telemetry_notifier;
+ ret = ph->notifier_register(ph, SCMI_EVENT_TELEMETRY_UPDATE,
+ NULL, &ti->telemetry_nb);
+ if (ret)
+ dev_warn(ph->dev,
+ "Could NOT register Telemetry notifications\n");
+ }
+
+ return ret;
}
static const struct scmi_protocol scmi_telemetry = {
@@ -2832,6 +2946,7 @@ static const struct scmi_protocol scmi_telemetry = {
.owner = THIS_MODULE,
.instance_init = &scmi_telemetry_protocol_init,
.ops = &tlm_proto_ops,
+ .events = &tlm_protocol_events,
.supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION,
};
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index 06baa4ddc55f..568fb7bb1a76 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -1199,6 +1199,7 @@ enum scmi_notification_events {
SCMI_EVENT_SYSTEM_POWER_STATE_NOTIFIER = 0x0,
SCMI_EVENT_POWERCAP_CAP_CHANGED = 0x0,
SCMI_EVENT_POWERCAP_MEASUREMENTS_CHANGED = 0x1,
+ SCMI_EVENT_TELEMETRY_UPDATE = 0x0,
};
struct scmi_power_state_changed_report {
@@ -1286,4 +1287,12 @@ struct scmi_powercap_meas_changed_report {
unsigned int domain_id;
unsigned int power;
};
+
+struct scmi_telemetry_update_report {
+ ktime_t timestamp;
+ unsigned int agent_id;
+ int status;
+ unsigned int num_dwords;
+ unsigned int dwords[];
+};
#endif /* _LINUX_SCMI_PROTOCOL_H */
--
2.54.0
^ permalink raw reply related
* [PATCH v4 12/31] firmware: arm_scmi: Add support for Telemetry reset
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add support for Telemetry operations needed to request platform to
reset telemetry current configuration and data events values.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- reset tracked Telemetry DE state
v2 --> v3
- split from monolithic Telemetry patch
- use scmi_telemetry_de_unlink
---
drivers/firmware/arm_scmi/telemetry.c | 47 +++++++++++++++++++++++++++
include/linux/scmi_protocol.h | 2 ++
2 files changed, 49 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index 87c3151909be..f88650916de8 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -2516,6 +2516,52 @@ static int scmi_telemetry_des_sample_get(const struct scmi_protocol_handle *ph,
return ret;
}
+static void scmi_telemetry_local_resources_reset(struct telemetry_info *ti)
+{
+ struct scmi_telemetry_res_info *rinfo;
+
+ /* Get rinfo as it is...without triggering an enumeration */
+ rinfo = __scmi_telemetry_resources_get(ti);
+ /* Clear all local state...*/
+ for (int i = 0; i < rinfo->num_des; i++) {
+ rinfo->des[i]->enabled = false;
+ rinfo->des[i]->tstamp_enabled = false;
+
+ scmi_telemetry_de_unlink(rinfo->des[i]);
+ }
+ for (int i = 0; i < rinfo->num_groups; i++) {
+ rinfo->grps[i].enabled = false;
+ rinfo->grps[i].tstamp_enabled = false;
+ rinfo->grps[i].current_mode = SCMI_TLM_ONDEMAND;
+ rinfo->grps[i].active_update_interval = 0;
+ }
+
+ atomic_set(&ti->des_enabled[ENA_STATE], 0);
+ atomic_set(&ti->des_enabled[ENA_TSTAMP], 0);
+}
+
+static int scmi_telemetry_reset(const struct scmi_protocol_handle *ph)
+{
+ struct scmi_xfer *t;
+ int ret;
+
+ ret = ph->xops->xfer_get_init(ph, TELEMETRY_RESET, sizeof(u32), 0, &t);
+ if (ret)
+ return ret;
+
+ put_unaligned_le32(0, t->tx.buf);
+ ret = ph->xops->do_xfer(ph, t);
+ if (!ret) {
+ struct telemetry_info *ti = ph->get_priv(ph);
+
+ scmi_telemetry_local_resources_reset(ti);
+ }
+
+ ph->xops->xfer_put(ph, t);
+
+ return ret;
+}
+
static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.info_get = scmi_telemetry_info_get,
.de_lookup = scmi_telemetry_de_lookup,
@@ -2527,6 +2573,7 @@ static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.de_data_read = scmi_telemetry_de_data_read,
.des_bulk_read = scmi_telemetry_des_bulk_read,
.des_sample_get = scmi_telemetry_des_sample_get,
+ .reset = scmi_telemetry_reset,
};
/**
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index f4ba5aa618a7..06baa4ddc55f 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -964,6 +964,7 @@ struct scmi_telemetry_de_sample {
* the ones belonging to a specific group when provided.
* This causes an immediate update platform-side of all the
* enabled DEs.
+ * @reset: reset configuration and telemetry data.
*/
struct scmi_telemetry_proto_ops {
const struct scmi_telemetry_info __must_check *(*info_get)
@@ -990,6 +991,7 @@ struct scmi_telemetry_proto_ops {
int __must_check (*des_sample_get)(const struct scmi_protocol_handle *ph,
int grp_id, int *num_samples,
struct scmi_telemetry_de_sample *samples);
+ int (*reset)(const struct scmi_protocol_handle *ph);
};
/**
--
2.54.0
^ permalink raw reply related
* [PATCH v4 11/31] firmware: arm_scmi: Add Telemetry DataEvent read capabilities
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add support for Telemetry operations needed to read DataEvent values and
timestamps as single entities or all together in a single bulk buffer.
The returned values are effectiely retrieved from the platform only
when strictly needed, i.e. when no fresh recent cached value was already
available.
The DataEvent values are fetched transparently from the platform origins
using the proper synchronization and consistency primitives, directly from
the SHMTIs areas or the FastChannels memory depending on the configuration.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- fix typos in comments
- extend TDE cache helpers with cache lookup routine and use cumulative
scmi_telemetry_de_sample param
v2 --> v3
- split from monolithic Telemetry patch
- simplity using a few assignement using ternary ops
- remove useless ts param from scanning function
- use a compound literal to simplify samples init
- add a missing __must_check on telemetry_ops
- changed errno on DE read troubles:
- ENODEV/ENOENT: DE is UNKNOWN
- EINVAL: DE is marked as DATA_INVALID
- ENODATA: TLM susbsystem or the specific DE is OFF
---
drivers/firmware/arm_scmi/telemetry.c | 467 ++++++++++++++++++++++++--
include/linux/scmi_protocol.h | 23 ++
2 files changed, 461 insertions(+), 29 deletions(-)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index ddbd06e7ce54..87c3151909be 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -579,16 +579,34 @@ scmi_telemetry_tde_cache_unchanged(struct telemetry_de *tde, u32 magic)
}
static void
-scmi_telemetry_tde_cache_update(struct telemetry_de *tde, u64 val,
- u64 *tstamp, u32 *magic)
+scmi_telemetry_tde_cache_update(struct telemetry_de *tde,
+ struct scmi_telemetry_de_sample *sample,
+ u32 *magic)
{
guard(mutex)(&tde->mtx);
tde->last_magic = magic ? *magic : TDCF_BAD_END_SEQ;
- tde->last_val = val;
- tde->last_ts = tstamp && TDE_HAS_TSTAMP(tde) ? *tstamp : 0;
- if (tstamp)
- *tstamp = tde->last_ts;
+ tde->last_val = sample->val;
+ tde->last_ts = TDE_HAS_TSTAMP(tde) ? sample->tstamp : 0;
+ /* Update returned value too */
+ sample->tstamp = tde->last_ts;
+}
+
+static int
+scmi_telemetry_tde_cache_lookup(struct telemetry_de *tde,
+ struct scmi_telemetry_de_sample *sample,
+ u32 *magic)
+{
+ guard(mutex)(&tde->mtx);
+
+ if (magic && tde->last_magic != *magic)
+ return -EAGAIN;
+
+ sample->id = tde->de.info->id;
+ sample->val = tde->last_val;
+ sample->tstamp = tde->last_ts;
+
+ return 0;
}
struct scmi_tlm_de_priv {
@@ -1480,31 +1498,31 @@ scmi_telemetry_tde_allocate(struct telemetry_info *ti, u32 de_id,
}
static inline void
-scmi_telemetry_line_data_parse(struct telemetry_de *tde, u64 *val, u64 *tstamp,
+scmi_telemetry_line_data_parse(struct telemetry_de *tde,
+ struct scmi_telemetry_de_sample *sample,
struct payload __iomem *payld, u32 magic)
{
/* Data is always valid since we are NOT handling BLK TS lines here */
- *val = LINE_DATA_GET(&payld->l);
- if (tstamp) {
- if (USE_BLK_TS(payld)) {
- /* Read out the actual BLK_TS */
- *tstamp = scmi_telemetry_blkts_read(magic, tde->bts);
- } else if (LINE_TS_VALID(payld)) {
- /*
- * Note that LINE_TS_VALID implies HAS_LINE_EXT and that
- * the per DE line_ts_rate is advertised in the DE
- * descriptor.
- */
- *tstamp = LINE_TSTAMP_GET(&payld->tsl);
- } else {
- *tstamp = 0;
- }
+ sample->val = LINE_DATA_GET(&payld->l);
+ if (USE_BLK_TS(payld)) {
+ /* Read out the actual BLK_TS */
+ sample->tstamp = scmi_telemetry_blkts_read(magic, tde->bts);
+ } else if (LINE_TS_VALID(payld)) {
+ /*
+ * Note that LINE_TS_VALID implies HAS_LINE_EXT and that
+ * the per DE line_ts_rate is advertised in the DE
+ * descriptor.
+ */
+ sample->tstamp = LINE_TSTAMP_GET(&payld->tsl);
+ } else {
+ sample->tstamp = 0;
}
- trace_scmi_tlm_collect(tstamp ? *tstamp : 0, tde->de.info->id,
- *val, "SHMTI_DE_READ");
+ /* Trace originally read tstamp */
+ trace_scmi_tlm_collect(sample->tstamp, tde->de.info->id,
+ sample->val, "SHMTI_DE_READ");
- scmi_telemetry_tde_cache_update(tde, *val, tstamp, &magic);
+ scmi_telemetry_tde_cache_update(tde, sample, &magic);
}
static inline void scmi_telemetry_bts_link(struct telemetry_de *tde,
@@ -1576,9 +1594,9 @@ static void scmi_telemetry_tdcf_data_parse(struct telemetry_info *ti,
enum scan_mode mode,
void *active_bts, void *active_uuid)
{
+ struct scmi_telemetry_de_sample sample = {};
bool use_blk_ts = USE_BLK_TS(payld);
struct telemetry_de *tde;
- u64 val, tstamp = 0;
u32 de_id;
de_id = PAYLD_ID(payld);
@@ -1625,9 +1643,8 @@ static void scmi_telemetry_tdcf_data_parse(struct telemetry_info *ti,
if (active_uuid)
scmi_telemetry_uuid_link(tde, active_uuid);
- /* Parse data words */
- scmi_telemetry_line_data_parse(tde, &val, &tstamp, payld,
- shmti->last_magic);
+ /* Parse data words ... only for the sake of updating TDE cache */
+ scmi_telemetry_line_data_parse(tde, &sample, payld, shmti->last_magic);
}
@@ -2110,6 +2127,395 @@ scmi_telemetry_collection_configure(const struct scmi_protocol_handle *ph,
return ret;
}
+static inline void
+scmi_telemetry_de_data_fc_read(struct telemetry_de *tde,
+ struct scmi_telemetry_de_sample *sample)
+{
+ struct fc_tsline __iomem *fc = tde->base + tde->offset;
+
+ sample->val = LINE_DATA_GET(fc);
+ sample->tstamp = LINE_TSTAMP_GET(fc);
+
+ /* Trace originally read tstamp */
+ trace_scmi_tlm_collect(sample->tstamp, tde->de.info->id, sample->val,
+ "FC_READ");
+
+ scmi_telemetry_tde_cache_update(tde, sample, NULL);
+}
+
+static void scmi_telemetry_scan_update(struct telemetry_info *ti)
+{
+ struct telemetry_de *tde;
+
+ /* Scan all SHMTIs ... */
+ for (int id = 0; id < ti->num_shmti; id++) {
+ int ret;
+
+ ret = scmi_telemetry_shmti_scan(ti, id, SCAN_LOOKUP);
+ if (ret)
+ dev_warn(ti->ph->dev,
+ "Failed update-scan of SHMTI ID:%d - ret:%d\n",
+ id, ret);
+ }
+
+ if (!ti->info.fc_support)
+ return;
+
+ /* Need to enumerate resources to access fastchannels */
+ ti->res_get(ti);
+ list_for_each_entry(tde, &ti->fcs_des, item) {
+ struct scmi_telemetry_de_sample sample = {};
+
+ if (!tde->de.enabled)
+ continue;
+
+ /* Only for the sake of updating TDE cache */
+ scmi_telemetry_de_data_fc_read(tde, &sample);
+ }
+}
+
+/*
+ * TDCF and TS Line Management Notes
+ * ---------------------------------
+ *
+ * TDCF Payload Metadata notable bits:
+ * - Bit[3]: USE BLK Tstamp
+ * - Bit[2]: Line-Extension Field present (LineTstamp)
+ * - Bit[1]: Tstamp VALID
+ * - Bit[0]: Data INVALID
+ *
+ * CASE_1:
+ * -------
+ * + A DE is enabled with timestamp disabled, so the TS fields are
+ * NOT present
+ * -> BIT[3:0] = 0000b
+ *
+ * - 1/A LINE_TSTAMP
+ * ------------------
+ * + that DE is then 're-enabled' with TS: so it was ON, it remains
+ * ON but using DE_CONFIGURE I now enabled also TS, so the
+ * platform relocates it at the end of the SHMTI and return the
+ * new offset
+ * -> BIT[3:0] = 0110b
+ *
+ * - 1/B BLK_TSTAMP
+ * ------------------
+ * + that DE is then 're-enabled' with BLK TS: so it was ON, it
+ * remains ON but using DE_CONFIGURE, we now also enabled the TS,
+ * so the platform will:
+ * - IF a preceding BLK_TS line exist (with same clk rate)
+ * it relocates the DE at the end of the SHMTI and return the
+ * new offset (if there is enough room, if not in another SHMTI)
+ * - IF a preceding BLK_TS line DOES NOT exist (with same clk rate)
+ * it creates a new BLK_TS line at the end of the SHMTI and then
+ * relocates the DE after the new BLK_TS and return the
+ * new offset (if there is enough room, if not in another SHMTI)
+ * -> BIT[3:1] = 1010b
+ *
+ * + the hole left from the relocated DE can be reused by the platform
+ * to fit another equally sized DE. (i.e. without shuffling around any
+ * other enabled DE, since that would cause a change of the known offset)
+ * anyway it will be marked as:
+ * -> BIT[3:0] = 0101b iff it was a LINE_TSTAMP
+ * -> BIT[3:0] = 0001b iff it was a BLK_TSTAMP
+ *
+ * CASE_2:
+ * -------
+ * + A DE is enabled with LINE timestamp enabled, so the TS_Line is there
+ * -> BIT[3:0] = 0110b
+ * + that DE has its timestamp disabled: again, you can do this without
+ * disabling it fully but just disabling the TS, so now that TS_line
+ * fields are still physically there but NOT valid
+ * -> BIT[3:0] = 0100b
+ * + the hole from the timestamp remain there unused until
+ * - you enable again the TS so the hole is used again
+ * -> BIT[3:0] = 0110b
+ * OR
+ * - you disable fully the DE and then re-enable it with the TS
+ * -> potentially CASE_1 the DE is relocated on enable
+ * + same kind of dynamic applies if the DE had a BLK_TS line
+ */
+static struct payload __iomem *
+scmi_telemetry_tdcf_de_payld_get(struct telemetry_de *tde)
+{
+ struct payload __iomem *payld;
+
+ payld = tde->base + tde->offset;
+ if (DATA_INVALID(payld)) {
+ trace_scmi_tlm_access(PAYLD_ID(payld), "DE_DATA_INVALID", 0, 0);
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (IS_BLK_TS_LINE(payld)) {
+ trace_scmi_tlm_access(tde->de.info->id, "BAD_DE_META", 0, 0);
+ return ERR_PTR(-EPROTO);
+ }
+
+ if (PAYLD_ID(payld) != tde->de.info->id) {
+ trace_scmi_tlm_access(tde->de.info->id, "DE_ID_MISMATCH", 0, 0);
+ return ERR_PTR(-ENODEV);
+ }
+
+ /*
+ * A valid line using BLK_TS should have been initialized with the
+ * related BLK_TS when enabled.
+ */
+ if (WARN_ON((USE_BLK_TS(payld) && !tde->bts))) {
+ trace_scmi_tlm_access(tde->de.info->id, "BAD_USE_BLK_TS", 0, 0);
+ return ERR_PTR(-EPROTO);
+ }
+
+ return payld;
+}
+
+static int
+scmi_telemetry_tdcf_de_parse(struct telemetry_de *tde,
+ struct scmi_telemetry_de_sample *sample)
+{
+ int retries = SCMI_TLM_TDCF_MAX_RETRIES;
+ struct tdcf __iomem *tdcf = tde->base;
+ u32 startm, endm;
+
+ if (!tdcf)
+ return -ENODEV;
+
+ do {
+ struct payload __iomem *payld;
+ int err;
+
+ /* A bit of exponential backoff between retries */
+ fsleep((SCMI_TLM_TDCF_MAX_RETRIES - retries) * 1000);
+
+ startm = TDCF_START_SEQ_GET(tdcf);
+ if (IS_BAD_START_SEQ(startm)) {
+ trace_scmi_tlm_access(tde->de.info->id, "MSEQ_BADSTART",
+ startm, 0);
+ continue;
+ }
+
+ /* Return last readings if nothing changed */
+ err = scmi_telemetry_tde_cache_lookup(tde, sample, &startm);
+ if (!err)
+ return 0;
+
+ payld = scmi_telemetry_tdcf_de_payld_get(tde);
+ if (IS_ERR(payld))
+ return PTR_ERR(payld);
+
+ /* Parse data words */
+ scmi_telemetry_line_data_parse(tde, sample, payld, startm);
+
+ endm = TDCF_END_SEQ_GET(tde->eplg);
+ if (startm != endm)
+ trace_scmi_tlm_access(tde->de.info->id, "MSEQ_MISMATCH",
+ startm, endm);
+ } while (startm != endm && --retries);
+
+ if (startm != endm) {
+ trace_scmi_tlm_access(tde->de.info->id, "TDCF_DE_FAIL",
+ startm, endm);
+ return -EPROTO;
+ }
+
+ return 0;
+}
+
+static int scmi_telemetry_de_access(struct telemetry_de *tde,
+ struct scmi_telemetry_de_sample *sample)
+{
+ if (!tde->de.fc_support)
+ return scmi_telemetry_tdcf_de_parse(tde, sample);
+
+ scmi_telemetry_de_data_fc_read(tde, sample);
+
+ return 0;
+}
+
+static int scmi_telemetry_de_collect(struct telemetry_info *ti,
+ struct scmi_telemetry_de *de,
+ struct scmi_telemetry_de_sample *sample)
+{
+ struct telemetry_de *tde = to_tde(de);
+
+ if (!de->enabled)
+ return -ENODATA;
+
+ /*
+ * DE readings returns cached values when:
+ * - DE data value was retrieved via notification/delayed_response
+ */
+ if (tde->cached_msg)
+ return scmi_telemetry_tde_cache_lookup(tde, sample, NULL);
+
+ return scmi_telemetry_de_access(tde, sample);
+}
+
+static int scmi_telemetry_de_data_read(const struct scmi_protocol_handle *ph,
+ struct scmi_telemetry_de_sample *sample)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+ struct scmi_telemetry_de *de;
+
+ if (!ti->info.enabled || !sample)
+ return -ENODATA;
+
+ de = xa_load(&ti->xa_des, sample->id);
+ if (!de)
+ return -ENOENT;
+
+ return scmi_telemetry_de_collect(ti, de, sample);
+}
+
+static int
+scmi_telemetry_samples_collect(struct telemetry_info *ti, int grp_id,
+ int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ struct scmi_telemetry_res_info *rinfo;
+ int max_samples;
+
+ max_samples = *num_samples;
+ *num_samples = 0;
+
+ rinfo = ti->res_get(ti);
+ for (int i = 0; i < rinfo->num_des; i++) {
+ struct scmi_telemetry_de *de;
+
+ de = rinfo->des[i];
+ /* Skip disabled DEs and not belonging to the selected Group */
+ if (!de->enabled ||
+ (grp_id != SCMI_TLM_GRP_INVALID &&
+ (!de->grp || de->grp->info->id != grp_id)))
+ continue;
+
+ /* Must be checked here to skip disabled and non selected */
+ if (*num_samples == max_samples)
+ return -ENOSPC;
+
+ /* Note that this cannot fail when passing a NULL magic */
+ scmi_telemetry_tde_cache_lookup(to_tde(de),
+ &samples[(*num_samples)++], NULL);
+ }
+
+ return 0;
+}
+
+static int scmi_telemetry_des_bulk_read(const struct scmi_protocol_handle *ph,
+ int grp_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+
+ if (!ti->info.enabled || !num_samples || !samples)
+ return -EINVAL;
+
+ /* Trigger a full SHMTIs & FCs scan */
+ scmi_telemetry_scan_update(ti);
+
+ /* Collect all last cached values */
+ return scmi_telemetry_samples_collect(ti, grp_id, num_samples, samples);
+}
+
+static void
+scmi_telemetry_msg_payld_process(struct telemetry_info *ti,
+ unsigned int num_dwords, u32 *dwords)
+{
+ struct scmi_telemetry_res_info *rinfo;
+ u32 next = 0;
+
+ rinfo = ti->res_get(ti);
+ if (!rinfo->fully_enumerated) {
+ dev_warn_once(ti->ph->dev,
+ "Cannot process DEs in message payload. Drop.\n");
+ return;
+ }
+
+ while (next < num_dwords) {
+ struct payload *payld = (struct payload *)&dwords[next];
+ struct scmi_telemetry_de *de;
+ struct telemetry_de *tde;
+ u32 de_id;
+
+ next += LINE_LENGTH_WORDS(payld);
+
+ if (DATA_INVALID(payld)) {
+ dev_err(ti->ph->dev, "MSG - Received INVALID DATA line\n");
+ continue;
+ }
+
+ de_id = le32_to_cpu(payld->id);
+ de = xa_load(&ti->xa_des, de_id);
+ if (!de || !de->enabled) {
+ dev_err(ti->ph->dev,
+ "MSG - Received INVALID DE - ID:%u enabled:%c\n",
+ de_id, de ? (de->enabled ? 'Y' : 'N') : 'X');
+ continue;
+ }
+
+ tde = to_tde(de);
+ guard(mutex)(&tde->mtx);
+ tde->cached_msg = true;
+ tde->last_val = LINE_DATA_GET(&payld->tsl);
+ /* TODO BLK_TS in notification payloads */
+ tde->last_ts = HAS_LINE_EXT(payld) && LINE_TS_VALID(payld) ?
+ LINE_TSTAMP_GET(&payld->tsl) : 0;
+
+ trace_scmi_tlm_collect(tde->last_ts, tde->de.info->id,
+ tde->last_val, "MESSAGE");
+ }
+}
+
+static int scmi_telemetry_des_sample_get(const struct scmi_protocol_handle *ph,
+ int grp_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+ struct scmi_msg_telemetry_config_set *msg;
+ struct scmi_xfer *t;
+ bool grp_ignore;
+ int ret;
+
+ if (!ti->info.enabled || !num_samples || !samples)
+ return -EINVAL;
+
+ grp_ignore = grp_id == SCMI_TLM_GRP_INVALID ? true : false;
+ if (!grp_ignore && grp_id >= ti->info.base.num_groups)
+ return -EINVAL;
+
+ ret = ph->xops->xfer_get_init(ph, TELEMETRY_CONFIG_SET,
+ sizeof(*msg), 0, &t);
+ if (ret)
+ return ret;
+
+ msg = t->tx.buf;
+ msg->grp_id = grp_id;
+ msg->control = TELEMETRY_ENABLE;
+ msg->control |= grp_ignore ? TELEMETRY_SET_SELECTOR_ALL :
+ TELEMETRY_SET_SELECTOR_GROUP;
+ msg->control |= TELEMETRY_MODE_SINGLE;
+ msg->sampling_rate = 0;
+
+ ret = ph->xops->do_xfer_with_response(ph, t);
+ if (!ret) {
+ struct scmi_msg_resp_telemetry_reading_complete *r = t->rx.buf;
+
+ /* Update cached DEs values from payload */
+ if (r->num_dwords)
+ scmi_telemetry_msg_payld_process(ti, r->num_dwords,
+ r->dwords);
+ /* Scan and update SMHTIs and FCs */
+ scmi_telemetry_scan_update(ti);
+
+ /* Collect all last cached values */
+ ret = scmi_telemetry_samples_collect(ti, grp_id, num_samples,
+ samples);
+ }
+
+ ph->xops->xfer_put(ph, t);
+
+ return ret;
+}
+
static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.info_get = scmi_telemetry_info_get,
.de_lookup = scmi_telemetry_de_lookup,
@@ -2118,6 +2524,9 @@ static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.state_set = scmi_telemetry_state_set,
.all_disable = scmi_telemetry_all_disable,
.collection_configure = scmi_telemetry_collection_configure,
+ .de_data_read = scmi_telemetry_de_data_read,
+ .des_bulk_read = scmi_telemetry_des_bulk_read,
+ .des_sample_get = scmi_telemetry_des_sample_get,
};
/**
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index eea294737d59..f4ba5aa618a7 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -935,6 +935,12 @@ struct scmi_telemetry_info {
enum scmi_telemetry_collection current_mode;
};
+struct scmi_telemetry_de_sample {
+ u32 id;
+ u64 tstamp;
+ u64 val;
+};
+
/**
* struct scmi_telemetry_proto_ops - represents the various operations provided
* by SCMI Telemetry Protocol
@@ -949,6 +955,15 @@ struct scmi_telemetry_info {
* @collection_configure: choose a sampling rate and enable SHMTI/FC sampling
* for on demand collection via @de_data_read or async
* notificatioins for all the enabled DEs.
+ * @de_data_read: on-demand read of a single DE and related optional timestamp:
+ * the value will be retrieved at the proper SHMTI offset OR
+ * from the dedicated FC area (if supported by that DE).
+ * @des_bulk_read: on-demand read of all the currently enabled DEs, or just
+ * the ones belonging to a specific group when provided.
+ * @des_sample_get: on-demand read of all the currently enabled DEs, or just
+ * the ones belonging to a specific group when provided.
+ * This causes an immediate update platform-side of all the
+ * enabled DEs.
*/
struct scmi_telemetry_proto_ops {
const struct scmi_telemetry_info __must_check *(*info_get)
@@ -967,6 +982,14 @@ struct scmi_telemetry_proto_ops {
bool *enable,
unsigned int *update_interval_ms,
enum scmi_telemetry_collection *mode);
+ int __must_check (*de_data_read)(const struct scmi_protocol_handle *ph,
+ struct scmi_telemetry_de_sample *sample);
+ int __must_check (*des_bulk_read)(const struct scmi_protocol_handle *ph,
+ int grp_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples);
+ int __must_check (*des_sample_get)(const struct scmi_protocol_handle *ph,
+ int grp_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples);
};
/**
--
2.54.0
^ permalink raw reply related
* [PATCH v4 10/31] firmware: arm_scmi: Add Telemetry configuration operations
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add support for basic Telemetry configuration operations to selectively
enable or disable DataEvents monitoring.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- track configured Telemetry DE states
- add aggregate Telemetry state query
v2 --> v3
- split from monolithic Telemetry patch
- simplify clenaup with scmi_telemetry_de_unlink
---
drivers/firmware/arm_scmi/telemetry.c | 373 ++++++++++++++++++++++++++
include/linux/scmi_protocol.h | 17 ++
2 files changed, 390 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index 087a3b6d18e4..ddbd06e7ce54 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -473,6 +473,9 @@ struct telemetry_info {
static struct scmi_telemetry_res_info *
__scmi_telemetry_resources_get(struct telemetry_info *ti);
+static int scmi_telemetry_shmti_scan(struct telemetry_info *ti,
+ unsigned int shmti_id, enum scan_mode mode);
+
static inline void
scmi_telemetry_de_state_update(struct telemetry_info *ti, enum de_state state,
bool *current_state, bool next_state)
@@ -1741,10 +1744,380 @@ static int scmi_telemetry_shmti_scan(struct telemetry_info *ti,
return 0;
}
+static int scmi_telemetry_group_state_update(struct telemetry_info *ti,
+ struct scmi_telemetry_group *grp,
+ bool *enable, bool *tstamp)
+{
+ struct scmi_telemetry_res_info *rinfo;
+
+ rinfo = ti->res_get(ti);
+ for (int i = 0; i < grp->info->num_des; i++) {
+ struct scmi_telemetry_de *de = rinfo->des[grp->des[i]];
+
+ if (enable)
+ scmi_telemetry_de_state_update(ti, ENA_STATE,
+ &de->enabled, *enable);
+
+ if (tstamp && de->tstamp_support)
+ scmi_telemetry_de_state_update(ti, ENA_TSTAMP,
+ &de->tstamp_enabled, *tstamp);
+ }
+
+ return 0;
+}
+
+static int
+scmi_telemetry_state_set_resp_process(struct telemetry_info *ti,
+ struct scmi_telemetry_de *de,
+ void *r, bool is_group)
+{
+ struct scmi_msg_resp_telemetry_de_configure *resp = r;
+ u32 sid = le32_to_cpu(resp->shmti_id);
+
+ /* Update DE SHMTI and offset, if applicable */
+ if (IS_SHMTI_ID_VALID(sid)) {
+ if (sid >= ti->num_shmti)
+ return -EPROTO;
+
+ /*
+ * Update SHMTI/offset while skipping non-SHMTI-DEs like
+ * FCs and notif-only.
+ */
+ if (!is_group) {
+ struct telemetry_de *tde;
+ struct payload *payld;
+ u32 de_offs;
+
+ de_offs = le32_to_cpu(resp->shmti_de_offset);
+ if (de_offs >= ti->shmti[sid].len - de->info->data_sz)
+ return -EPROTO;
+
+ tde = to_tde(de);
+ tde->base = ti->shmti[sid].base;
+ tde->offset = de_offs;
+ /* A handy reference to the Epilogue updated */
+ tde->eplg = SHMTI_EPLG(&ti->shmti[sid]);
+
+ payld = tde->base + tde->offset;
+ if (USE_BLK_TS(payld) && !tde->bts) {
+ struct payload *bts_payld;
+ u32 bts_offs;
+
+ bts_offs = le32_to_cpu(resp->blk_ts_offset);
+ bts_payld = (bts_offs) ? tde->base + bts_offs : NULL;
+ tde->bts = scmi_telemetry_blkts_bind(ti->ph->dev,
+ &ti->shmti[sid],
+ payld,
+ &ti->xa_lines,
+ bts_payld);
+ if (WARN_ON(!tde->bts))
+ return -EPROTO;
+ }
+ } else {
+ int ret;
+
+ /*
+ * A full SHMTI scan is needed when enabling a
+ * group or its timestamps in order to retrieve
+ * offsets: note that when group-timestamp is
+ * enabled for composing DEs a re-scan is needed
+ * since some DEs could have been relocated due
+ * to lack of space in the TDCF.
+ */
+ ret = scmi_telemetry_shmti_scan(ti, sid, SCAN_UPDATE);
+ if (ret)
+ dev_warn(ti->ph->dev,
+ "Failed group-scan of SHMTI ID:%d - ret:%d\n",
+ sid, ret);
+ }
+ } else if (!is_group) {
+ /* Unlink the related BLK_TS/UUID lines on disable */
+ scmi_telemetry_de_unlink(de);
+ }
+
+ return 0;
+}
+
+static int __scmi_telemetry_state_set(const struct scmi_protocol_handle *ph,
+ bool is_group, bool *enable,
+ bool *enabled_state, bool *tstamp,
+ bool *tstamp_enabled_state, void *obj)
+{
+ struct scmi_msg_resp_telemetry_de_configure *resp;
+ struct scmi_msg_telemetry_de_configure *msg;
+ struct telemetry_info *ti = ph->get_priv(ph);
+ struct scmi_telemetry_de *de = !is_group ? obj : NULL;
+ struct scmi_telemetry_group *grp = is_group ? obj : NULL;
+ unsigned int obj_id = !is_group ? de->info->id : grp->info->id;
+ struct scmi_xfer *t;
+ int ret;
+
+ if (!enabled_state || !tstamp_enabled_state)
+ return -EINVAL;
+
+ /* Is anything to do at all on this DE ? */
+ if (!is_group && (!enable || *enable == *enabled_state) &&
+ (!tstamp || *tstamp == *tstamp_enabled_state))
+ return 0;
+
+ /*
+ * DE is currently disabled AND no enable state change was requested,
+ * while timestamp is being changed: update only local state...no need
+ * to send a message.
+ */
+ if (!is_group && !enable && !*enabled_state) {
+ if (de->tstamp_support)
+ scmi_telemetry_de_state_update(ti, ENA_TSTAMP,
+ tstamp_enabled_state,
+ *tstamp);
+
+ return 0;
+ }
+
+ ret = ph->xops->xfer_get_init(ph, TELEMETRY_DE_CONFIGURE,
+ sizeof(*msg), sizeof(*resp), &t);
+ if (ret)
+ return ret;
+
+ msg = t->tx.buf;
+ /* Note that BOTH DE and GROUPS have a first ID field.. */
+ msg->id = cpu_to_le32(obj_id);
+ /* Default to disable mode for one DE */
+ msg->flags = DE_DISABLE_ONE;
+ msg->flags |= FIELD_PREP(GENMASK(3, 3),
+ is_group ? EVENT_GROUP : EVENT_DE);
+
+ if ((!enable && *enabled_state) || (enable && *enable)) {
+ /* Already enabled but tstamp_enabled state changed */
+ if (tstamp) {
+ /* Here, tstamp cannot be NULL too */
+ msg->flags |= *tstamp ? DE_ENABLE_WTH_TSTAMP :
+ DE_ENABLE_NO_TSTAMP;
+ } else {
+ msg->flags |= *tstamp_enabled_state ?
+ DE_ENABLE_WTH_TSTAMP : DE_ENABLE_NO_TSTAMP;
+ }
+ }
+
+ resp = t->rx.buf;
+ ret = ph->xops->do_xfer(ph, t);
+ if (!ret) {
+ ret = scmi_telemetry_state_set_resp_process(ti, obj, resp, is_group);
+ if (!ret) {
+ /* Update cached state on success */
+ if (enable) {
+ if (!is_group)
+ scmi_telemetry_de_state_update(ti, ENA_STATE,
+ enabled_state,
+ *enable);
+ else
+ *enabled_state = *enable;
+ }
+ if (tstamp) {
+ if (!is_group) {
+ if (de->tstamp_support)
+ scmi_telemetry_de_state_update(ti, ENA_TSTAMP,
+ tstamp_enabled_state,
+ *tstamp);
+ } else {
+ *tstamp_enabled_state = *tstamp;
+ }
+ }
+
+ if (is_group)
+ scmi_telemetry_group_state_update(ti, grp, enable,
+ tstamp);
+ }
+ }
+
+ ph->xops->xfer_put(ph, t);
+
+ return ret;
+}
+
+static int scmi_telemetry_state_get(const struct scmi_protocol_handle *ph,
+ u32 *id, bool *enabled, bool *tstamp_enabled)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+ struct scmi_telemetry_de *de;
+
+ if (!enabled || !tstamp_enabled)
+ return -EINVAL;
+
+ if (!id) {
+ /* Returning the all_des_* state */
+ *enabled =
+ (atomic_read(&ti->des_enabled[ENA_STATE]) == ti->info.base.num_des);
+ *tstamp_enabled =
+ (atomic_read(&ti->des_enabled[ENA_TSTAMP]) == ti->num_des_tstamp);
+
+ return 0;
+ }
+
+ de = xa_load(&ti->xa_des, *id);
+ if (!de)
+ return -ENODEV;
+
+ *enabled = de->enabled;
+ *tstamp_enabled = de->tstamp_enabled;
+
+ return 0;
+}
+
+static int scmi_telemetry_state_set(const struct scmi_protocol_handle *ph,
+ bool is_group, u32 id, bool *enable,
+ bool *tstamp)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+ bool *enabled_state, *tstamp_enabled_state;
+ struct scmi_telemetry_res_info *rinfo;
+ void *obj;
+
+ rinfo = ti->res_get(ti);
+ if (!is_group) {
+ struct scmi_telemetry_de *de;
+
+ de = xa_load(&ti->xa_des, id);
+ if (!de)
+ return -ENODEV;
+
+ enabled_state = &de->enabled;
+ tstamp_enabled_state = &de->tstamp_enabled;
+ obj = de;
+ } else {
+ struct scmi_telemetry_group *grp;
+
+ if (id >= ti->info.base.num_groups)
+ return -EINVAL;
+
+ grp = &rinfo->grps[id];
+
+ enabled_state = &grp->enabled;
+ tstamp_enabled_state = &grp->tstamp_enabled;
+ obj = grp;
+ }
+
+ return __scmi_telemetry_state_set(ph, is_group, enable, enabled_state,
+ tstamp, tstamp_enabled_state, obj);
+}
+
+static int scmi_telemetry_all_disable(const struct scmi_protocol_handle *ph,
+ bool is_group)
+{
+ struct telemetry_info *ti = ph->get_priv(ph);
+ struct scmi_msg_telemetry_de_configure *msg;
+ struct scmi_telemetry_res_info *rinfo;
+ struct scmi_xfer *t;
+ int ret;
+
+ rinfo = ti->res_get(ti);
+ ret = ph->xops->xfer_get_init(ph, TELEMETRY_DE_CONFIGURE,
+ sizeof(*msg), 0, &t);
+ if (ret)
+ return ret;
+
+ msg = t->tx.buf;
+ msg->flags = DE_DISABLE_ALL;
+ if (is_group)
+ msg->flags |= GROUP_SELECTOR;
+ ret = ph->xops->do_xfer(ph, t);
+ if (!ret) {
+ for (int i = 0; i < ti->info.base.num_des; i++)
+ scmi_telemetry_de_state_update(ti, ENA_STATE,
+ &rinfo->des[i]->enabled,
+ false);
+
+ if (is_group) {
+ for (int i = 0; i < ti->info.base.num_groups; i++)
+ rinfo->grps[i].enabled = false;
+ }
+ }
+
+ ph->xops->xfer_put(ph, t);
+
+ return ret;
+}
+
+static int
+scmi_telemetry_collection_configure(const struct scmi_protocol_handle *ph,
+ unsigned int res_id, bool grp_ignore,
+ bool *enable,
+ unsigned int *update_interval_ms,
+ enum scmi_telemetry_collection *mode)
+{
+ enum scmi_telemetry_collection *current_mode, next_mode;
+ struct telemetry_info *ti = ph->get_priv(ph);
+ struct scmi_msg_telemetry_config_set *msg;
+ unsigned int *active_update_interval;
+ struct scmi_xfer *t;
+ bool tlm_enable;
+ u32 interval;
+ int ret;
+
+ if (mode && *mode == SCMI_TLM_NOTIFICATION &&
+ !ti->info.continuos_update_support)
+ return -EINVAL;
+
+ if (res_id != SCMI_TLM_GRP_INVALID && res_id >= ti->info.base.num_groups)
+ return -EINVAL;
+
+ if (res_id == SCMI_TLM_GRP_INVALID || grp_ignore) {
+ active_update_interval = &ti->info.active_update_interval;
+ current_mode = &ti->info.current_mode;
+ } else {
+ struct scmi_telemetry_res_info *rinfo;
+
+ rinfo = ti->res_get(ti);
+ active_update_interval =
+ &rinfo->grps[res_id].active_update_interval;
+ current_mode = &rinfo->grps[res_id].current_mode;
+ }
+
+ if (!enable && !update_interval_ms && (!mode || *mode == *current_mode))
+ return 0;
+
+ ret = ph->xops->xfer_get_init(ph, TELEMETRY_CONFIG_SET,
+ sizeof(*msg), 0, &t);
+ if (ret)
+ return ret;
+
+ if (!update_interval_ms)
+ interval = cpu_to_le32(*active_update_interval);
+ else
+ interval = *update_interval_ms;
+
+ tlm_enable = enable ? *enable : ti->info.enabled;
+ next_mode = mode ? *mode : *current_mode;
+
+ msg = t->tx.buf;
+ msg->grp_id = res_id;
+ msg->control = tlm_enable ? TELEMETRY_ENABLE : 0;
+ msg->control |= grp_ignore ? TELEMETRY_SET_SELECTOR_ALL :
+ TELEMETRY_SET_SELECTOR_GROUP;
+ msg->control |= TELEMETRY_MODE_SET(next_mode);
+ msg->sampling_rate = interval;
+ ret = ph->xops->do_xfer(ph, t);
+ if (!ret) {
+ ti->info.enabled = tlm_enable;
+ *current_mode = next_mode;
+ ti->info.notif_enabled = *current_mode == SCMI_TLM_NOTIFICATION;
+ if (update_interval_ms)
+ *active_update_interval = interval;
+ }
+
+ ph->xops->xfer_put(ph, t);
+
+ return ret;
+}
+
static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.info_get = scmi_telemetry_info_get,
.de_lookup = scmi_telemetry_de_lookup,
.res_get = scmi_telemetry_resources_get,
+ .state_get = scmi_telemetry_state_get,
+ .state_set = scmi_telemetry_state_set,
+ .all_disable = scmi_telemetry_all_disable,
+ .collection_configure = scmi_telemetry_collection_configure,
};
/**
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index fcb45bd4b44c..eea294737d59 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -942,6 +942,13 @@ struct scmi_telemetry_info {
* @info_get: get the general Telemetry information.
* @de_lookup: get a specific DE descriptor from the DE id.
* @res_get: get a reference to the Telemetry resources descriptor.
+ * @state_get: retrieve the specific DE or GROUP state, if NULL returns the
+ * cumulative state of all DEs.
+ * @state_set: enable/disable the specific DE or GROUP with or without timestamps.
+ * @all_disable: disable ALL DEs or GROUPs.
+ * @collection_configure: choose a sampling rate and enable SHMTI/FC sampling
+ * for on demand collection via @de_data_read or async
+ * notificatioins for all the enabled DEs.
*/
struct scmi_telemetry_proto_ops {
const struct scmi_telemetry_info __must_check *(*info_get)
@@ -950,6 +957,16 @@ struct scmi_telemetry_proto_ops {
(const struct scmi_protocol_handle *ph, u32 id);
const struct scmi_telemetry_res_info __must_check *(*res_get)
(const struct scmi_protocol_handle *ph);
+ int (*state_get)(const struct scmi_protocol_handle *ph,
+ u32 *id, bool *enabled, bool *tstamp_enabled);
+ int (*state_set)(const struct scmi_protocol_handle *ph,
+ bool is_group, u32 id, bool *enable, bool *tstamp);
+ int (*all_disable)(const struct scmi_protocol_handle *ph, bool group);
+ int (*collection_configure)(const struct scmi_protocol_handle *ph,
+ unsigned int res_id, bool grp_ignore,
+ bool *enable,
+ unsigned int *update_interval_ms,
+ enum scmi_telemetry_collection *mode);
};
/**
--
2.54.0
^ permalink raw reply related
* [PATCH v4 09/31] firmware: arm_scmi: Add support to parse SHMTIs areas
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add logic to scan the SHMTI areas, parsing the TDCF descriptors while
collecting DataEvent, BlockTimestamp and UUID lines.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- use kzalloc_obj
- track SHMTI-discovered Telemetry DE states
- refactor TDE cache with dedicated helpers
- force tstamp to zero when timestamp is NOT supported or disabled
v2 --> v3
- split from monolithic Telemetry patch
- avoid devres allocation for resources that are added to the xa_lines XArray
- simplify prototype of line parsing helpers to drop unneeded dev
- flip tstmap logic in scmi_telemetry_line_data_parse() to properly emit
a TLM ftrace event
- use ternary ops to simplify quite a few expressions
---
drivers/firmware/arm_scmi/telemetry.c | 629 ++++++++++++++++++++++++++
1 file changed, 629 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index a5c61ec37065..087a3b6d18e4 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -254,6 +254,23 @@ struct uuid_line {
u32 dwords[SCMI_TLM_DE_IMPL_MAX_DWORDS];
};
+#define LINE_DATA_GET(f) \
+({ \
+ typeof(f) _f = (f); \
+ \
+ (TO_CPU_64(_I(&_f->data_high), _I(&_f->data_low))); \
+})
+
+#define LINE_TSTAMP_GET(f) \
+({ \
+ typeof(f) _f = (f); \
+ \
+ (TO_CPU_64(_I(&_f->ts_high), _I(&_f->ts_low))); \
+})
+
+#define BLK_TS_STAMP(f) LINE_TSTAMP_GET(f)
+#define BLK_TS_RATE(p) PAYLD_ID(p)
+
enum tdcf_line_types {
TDCF_DATA_LINE,
TDCF_BLK_TS_LINE,
@@ -365,6 +382,7 @@ struct telemetry_line {
refcount_t users;
u32 last_magic;
struct payload __iomem *payld;
+ struct xarray *xa_lines;
/* Protect line accesses */
struct mutex mtx;
};
@@ -413,18 +431,34 @@ struct telemetry_de {
#define to_tde(d) container_of(d, struct telemetry_de, de)
+#define TDE_HAS_TSTAMP(_t) \
+ ({ \
+ bool ts; \
+ struct telemetry_de *t = _t; \
+ \
+ ts = t->de.tstamp_support && t->de.tstamp_enabled; \
+ })
+
#define DE_ENABLED_WITH_TSTAMP 2
+enum de_state {
+ ENA_STATE,
+ ENA_TSTAMP,
+ ENA_MAX
+};
+
struct telemetry_info {
bool streaming_mode;
unsigned int num_shmti;
unsigned int num_des_tstamp;
+ atomic_t des_enabled[ENA_MAX];
unsigned int default_blk_ts_rate;
const struct scmi_protocol_handle *ph;
struct telemetry_shmti *shmti;
struct telemetry_de *tdes;
struct scmi_telemetry_group *grps;
struct xarray xa_des;
+ struct xarray xa_lines;
/* Mutex to protect access to @free_des */
struct mutex free_mtx;
struct list_head free_des;
@@ -439,6 +473,21 @@ struct telemetry_info {
static struct scmi_telemetry_res_info *
__scmi_telemetry_resources_get(struct telemetry_info *ti);
+static inline void
+scmi_telemetry_de_state_update(struct telemetry_info *ti, enum de_state state,
+ bool *current_state, bool next_state)
+{
+ if (!current_state || *current_state != next_state)
+ atomic_add(next_state ? 1 : -1, &ti->des_enabled[state]);
+
+ if (current_state)
+ *current_state = next_state;
+
+ dev_dbg(ti->ph->dev, "Telemetry des_enabled[%s]:%u\n",
+ state == ENA_STATE ? "STATE" : "TSTAMP",
+ atomic_read(&ti->des_enabled[state]));
+}
+
static struct telemetry_de *
scmi_telemetry_free_tde_get(struct telemetry_info *ti)
{
@@ -518,6 +567,27 @@ static int scmi_telemetry_tde_register(struct telemetry_info *ti,
return ret;
}
+static bool
+scmi_telemetry_tde_cache_unchanged(struct telemetry_de *tde, u32 magic)
+{
+ guard(mutex)(&tde->mtx);
+
+ return tde->last_magic == magic;
+}
+
+static void
+scmi_telemetry_tde_cache_update(struct telemetry_de *tde, u64 val,
+ u64 *tstamp, u32 *magic)
+{
+ guard(mutex)(&tde->mtx);
+
+ tde->last_magic = magic ? *magic : TDCF_BAD_END_SEQ;
+ tde->last_val = val;
+ tde->last_ts = tstamp && TDE_HAS_TSTAMP(tde) ? *tstamp : 0;
+ if (tstamp)
+ *tstamp = tde->last_ts;
+}
+
struct scmi_tlm_de_priv {
struct telemetry_info *ti;
void *next;
@@ -1122,6 +1192,555 @@ scmi_telemetry_resources_get(const struct scmi_protocol_handle *ph)
return ti->res_get(ti);
}
+static u64
+scmi_telemetry_blkts_read(u32 magic, struct telemetry_block_ts *bts)
+{
+ if (WARN_ON(!bts || !refcount_read(&bts->line.users)))
+ return 0;
+
+ guard(mutex)(&bts->line.mtx);
+
+ if (bts->line.last_magic == magic)
+ return bts->last_ts;
+
+ /* Note that the bts->last_rate can change ONLY on creation */
+ bts->last_ts = BLK_TS_STAMP(&bts->line.payld->blk_tsl);
+ bts->line.last_magic = magic;
+
+ return bts->last_ts;
+}
+
+static void scmi_telemetry_blkts_update(struct telemetry_info *ti, u32 magic,
+ struct telemetry_block_ts *bts)
+{
+ guard(mutex)(&bts->line.mtx);
+
+ if (bts->line.last_magic != magic) {
+ bts->last_ts = BLK_TS_STAMP(&bts->line.payld->blk_tsl);
+ bts->last_rate = BLK_TS_RATE(bts->line.payld);
+ /* BLK_TS clock rate value can change ONLY here on creation */
+ if (!bts->last_rate)
+ bts->last_rate = ti->default_blk_ts_rate;
+ bts->line.last_magic = magic;
+ }
+}
+
+static void scmi_telemetry_line_put(struct telemetry_line *line, void *blob)
+{
+ if (refcount_dec_and_test(&line->users)) {
+ scoped_guard(mutex, &line->mtx)
+ xa_erase(line->xa_lines, (unsigned long)line->payld);
+ kfree(blob);
+ }
+}
+
+static void scmi_telemetry_blkts_unlink(struct telemetry_de *tde)
+{
+ scmi_telemetry_line_put(&tde->bts->line, tde->bts);
+ tde->bts = NULL;
+}
+
+static void scmi_telemetry_uuid_unlink(struct telemetry_de *tde)
+{
+ scmi_telemetry_line_put(&tde->uuid->line, tde->uuid);
+ tde->uuid = NULL;
+}
+
+static void scmi_telemetry_de_unlink(struct scmi_telemetry_de *de)
+{
+ struct telemetry_de *tde = to_tde(de);
+
+ /* Unlink all related lines triggering their deallocation */
+ if (tde->bts)
+ scmi_telemetry_blkts_unlink(tde);
+ if (tde->uuid)
+ scmi_telemetry_uuid_unlink(tde);
+}
+
+static struct telemetry_line *
+scmi_telemetry_line_get(struct xarray *xa_lines, struct payload *payld)
+{
+ struct telemetry_line *line;
+
+ line = xa_load(xa_lines, (unsigned long)payld);
+ if (!line)
+ return NULL;
+
+ refcount_inc(&line->users);
+
+ return line;
+}
+
+static int
+scmi_telemetry_line_init(struct telemetry_line *line, struct xarray *xa_lines,
+ struct payload __iomem *payld)
+{
+ refcount_set(&line->users, 1);
+ line->payld = payld;
+ line->xa_lines = xa_lines;
+ mutex_init(&line->mtx);
+
+ return xa_insert(xa_lines, (unsigned long)payld, line, GFP_KERNEL);
+}
+
+static struct telemetry_block_ts *
+scmi_telemetry_blkts_create(struct device *dev, struct xarray *xa_lines,
+ struct payload *payld)
+{
+ struct telemetry_block_ts *bts;
+ int ret;
+
+ bts = kzalloc_obj(*bts);
+ if (!bts)
+ return NULL;
+
+ ret = scmi_telemetry_line_init(&bts->line, xa_lines, payld);
+ if (ret) {
+ kfree(bts);
+ return NULL;
+ }
+
+ trace_scmi_tlm_collect(0, (u64)payld, 0, "SHMTI_NEW_BLKTS");
+
+ return bts;
+}
+
+static struct telemetry_block_ts *
+scmi_telemetry_blkts_get_or_create(struct device *dev, struct xarray *xa_lines,
+ struct payload *payld)
+{
+ struct telemetry_line *line;
+
+ line = scmi_telemetry_line_get(xa_lines, payld);
+ if (line)
+ return to_blkts(line);
+
+ return scmi_telemetry_blkts_create(dev, xa_lines, payld);
+}
+
+static struct telemetry_uuid *
+scmi_telemetry_uuid_create(struct device *dev, struct xarray *xa_lines,
+ struct payload *payld)
+{
+ struct telemetry_uuid *uuid;
+ int ret;
+
+ uuid = kzalloc_obj(*uuid);
+ if (!uuid)
+ return NULL;
+
+ for (int i = 0; i < SCMI_TLM_DE_IMPL_MAX_DWORDS; i++)
+ uuid->de_impl_version[i] = le32_to_cpu(payld->uuid_l.dwords[i]);
+
+ ret = scmi_telemetry_line_init(&uuid->line, xa_lines, payld);
+ if (ret) {
+ kfree(uuid);
+ return NULL;
+ }
+
+ trace_scmi_tlm_collect(0, (u64)payld, 0, "SHMTI_NEW_UUID");
+
+ return uuid;
+}
+
+static struct telemetry_uuid *
+scmi_telemetry_uuid_get_or_create(struct device *dev, struct xarray *xa_lines,
+ struct payload *payld)
+{
+ struct telemetry_line *line;
+
+ line = scmi_telemetry_line_get(xa_lines, payld);
+ if (line)
+ return to_uuid(line);
+
+ return scmi_telemetry_uuid_create(dev, xa_lines, payld);
+}
+
+static void scmi_telemetry_tdcf_uuid_parse(struct telemetry_info *ti,
+ struct payload __iomem *payld,
+ struct telemetry_shmti *shmti,
+ void **active_uuid)
+{
+ struct telemetry_uuid *uuid;
+
+ if (UUID_INVALID(payld)) {
+ trace_scmi_tlm_access(0, "UUID_INVALID", 0, 0);
+ return;
+ }
+
+ /* A UUID descriptor MUST be returned: it is found or it is created */
+ uuid = scmi_telemetry_uuid_get_or_create(ti->ph->dev, &ti->xa_lines,
+ payld);
+ if (WARN_ON(!uuid))
+ return;
+
+ *active_uuid = uuid;
+}
+
+static struct payload *
+scmi_telemetry_nearest_line_by_type(struct telemetry_shmti *shmti,
+ void *last, enum tdcf_line_types ltype)
+{
+ struct tdcf __iomem *tdcf = shmti->base;
+ void *next, *found = NULL;
+
+ /* Scan from start of TDCF payloads up to last_payld */
+ next = tdcf->payld;
+ while (next < last) {
+ if (LINE_TYPE((struct payload *)next) == ltype)
+ found = next;
+
+ next += LINE_LENGTH_WORDS((struct payload *)next);
+ }
+
+ return found;
+}
+
+static struct telemetry_block_ts *
+scmi_telemetry_blkts_bind(struct device *dev, struct telemetry_shmti *shmti,
+ struct payload *payld, struct xarray *xa_lines,
+ struct payload *bts_payld)
+{
+ /* Trigger a manual search when no BLK_TS payload offset was provided */
+ if (!bts_payld) {
+ /* Find the BLK_TS immediately preceding this DE payld */
+ bts_payld = scmi_telemetry_nearest_line_by_type(shmti, payld,
+ TDCF_BLK_TS_LINE);
+ if (!bts_payld)
+ return NULL;
+ }
+
+ return scmi_telemetry_blkts_get_or_create(dev, xa_lines, bts_payld);
+}
+
+/**
+ * scmi_telemetry_tdcf_blkts_parse - A BLK_TS line parser
+ *
+ * @ti: A reference to the telemetry_info descriptor
+ * @payld: TDCF payld line to process
+ * @shmti: SHMTI descriptor inside which the scan is happening
+ * @active_bts: Input/output reference to keep track of the last blk_ts found
+ *
+ * Process a valid TDCF BLK_TS line and, after having looked up or created a
+ * blk_ts descriptor, update the related data and return it as the currently
+ * active blk_ts, given that it is effectively the last found during this
+ * scan.
+ */
+static void scmi_telemetry_tdcf_blkts_parse(struct telemetry_info *ti,
+ struct payload __iomem *payld,
+ struct telemetry_shmti *shmti,
+ void **active_bts)
+{
+ struct telemetry_block_ts *bts;
+
+ /* Check for spec compliance */
+ if (BLK_TS_INVALID(payld)) {
+ trace_scmi_tlm_access(0, "BLK_TS_INVALID", 0, 0);
+ return;
+ }
+
+ /* A BLK_TS descriptor MUST be returned: it is found or it is created */
+ bts = scmi_telemetry_blkts_get_or_create(ti->ph->dev,
+ &ti->xa_lines, payld);
+ if (WARN_ON(!bts))
+ return;
+
+ /* Update the descriptor with the lastest TS */
+ scmi_telemetry_blkts_update(ti, shmti->last_magic, bts);
+ *active_bts = bts;
+}
+
+static inline struct telemetry_de *
+scmi_telemetry_tde_allocate(struct telemetry_info *ti, u32 de_id,
+ struct payload __iomem *payld)
+{
+ struct telemetry_de *tde;
+
+ tde = scmi_telemetry_tde_get(ti, de_id);
+ if (IS_ERR(tde))
+ return NULL;
+
+ tde->de.info->id = de_id;
+ tde->de.enabled = true;
+ tde->de.tstamp_enabled = LINE_TS_VALID(payld) || USE_BLK_TS(payld);
+
+ if (scmi_telemetry_tde_register(ti, tde)) {
+ scmi_telemetry_free_tde_put(ti, tde);
+ return NULL;
+ }
+
+ scmi_telemetry_de_state_update(ti, ENA_STATE, NULL, true);
+ if (tde->de.tstamp_enabled)
+ scmi_telemetry_de_state_update(ti, ENA_TSTAMP, NULL, true);
+
+ return tde;
+}
+
+static inline void
+scmi_telemetry_line_data_parse(struct telemetry_de *tde, u64 *val, u64 *tstamp,
+ struct payload __iomem *payld, u32 magic)
+{
+ /* Data is always valid since we are NOT handling BLK TS lines here */
+ *val = LINE_DATA_GET(&payld->l);
+ if (tstamp) {
+ if (USE_BLK_TS(payld)) {
+ /* Read out the actual BLK_TS */
+ *tstamp = scmi_telemetry_blkts_read(magic, tde->bts);
+ } else if (LINE_TS_VALID(payld)) {
+ /*
+ * Note that LINE_TS_VALID implies HAS_LINE_EXT and that
+ * the per DE line_ts_rate is advertised in the DE
+ * descriptor.
+ */
+ *tstamp = LINE_TSTAMP_GET(&payld->tsl);
+ } else {
+ *tstamp = 0;
+ }
+ }
+
+ trace_scmi_tlm_collect(tstamp ? *tstamp : 0, tde->de.info->id,
+ *val, "SHMTI_DE_READ");
+
+ scmi_telemetry_tde_cache_update(tde, *val, tstamp, &magic);
+}
+
+static inline void scmi_telemetry_bts_link(struct telemetry_de *tde,
+ struct telemetry_block_ts *bts)
+{
+ refcount_inc(&bts->line.users);
+ tde->bts = bts;
+ /* Update TS clock rate if provided by the BLK_TS */
+ if (tde->bts->last_rate)
+ tde->de.info->ts_rate = tde->bts->last_rate;
+}
+
+static inline void scmi_telemetry_uuid_link(struct telemetry_de *tde,
+ struct telemetry_uuid *uuid)
+{
+ refcount_inc(&uuid->line.users);
+ tde->uuid = uuid;
+}
+
+/**
+ * scmi_telemetry_tdcf_data_parse - TDCF DataLine parsing
+ * @ti: A reference to the telemetry info descriptor
+ * @payld: Line payload to parse
+ * @shmti: A reference to the containing SHMTI area
+ * @mode: A flag to determine the behaviour of the scan
+ * @active_bts: A pointer to keep track and report any found BLK timestamp line
+ * @active_uuid: A pointer to keep track and report any found UUID line
+ *
+ * This routine takes care to:
+ * - verify line consistency in relation to the used flags and the current
+ * context: e.g. is there an active preceding BLK_TS line if the DataLine
+ * sports a USE_BLKTS flag ?
+ * - verify the related Data Event ID exists OR create a brand new DE
+ * (depending on the @mode of operation)
+ * - links any active BLK_TS or UUID line to the current DE
+ * - read and save value/tstamp for the DE ONLY if anything has changed (by
+ * tracking the last TDCF magic) and update related magic: this allows to
+ * minimize future needs of single-DE reads
+ *
+ * Modes of operation.
+ *
+ * The scan behaviour depends on the chosen @mode:
+ * - SCAN_LOOKUP: the basic scan which aims to update value associated to
+ * existing DEs. Any discovered DataLine that could NOT be
+ * matched to an existing, previously discovered, DE is
+ * discarded. This is the normal scan behaviour.
+ * - SCAN_UPDATE: a more advanced scan which provides all the SCAN_LOOKUP
+ * features plus takes care to update the DEs location
+ * coordinates inside the SHMTI: note that the related DEs are
+ * still supposed to have been previously discovered when
+ * this scan runs. This is used to update location
+ * coordinates for DEs contained in a Group when such group
+ * is enabled.
+ * - SCAN_DISCOVERY: the most advanced scan available which provides all
+ * the SCAN_LOOKUP features plus discovery capabilities:
+ * any DataLine referring to a previously unknown DE leads
+ * to the allocation of a new DE descriptor.
+ * This mode is used on the first scan at init time, ONLY
+ * if Telemetry was found to be already enabled at boot on
+ * the platform side: this helps to maximize gathered
+ * information when dealing with out of spec firmwares.
+ * Any usage of this discovery mode other than in a boot-on
+ * enabled scenario is discouraged since it can easily
+ * lead to spurious DE discoveries.
+ */
+static void scmi_telemetry_tdcf_data_parse(struct telemetry_info *ti,
+ struct payload __iomem *payld,
+ struct telemetry_shmti *shmti,
+ enum scan_mode mode,
+ void *active_bts, void *active_uuid)
+{
+ bool use_blk_ts = USE_BLK_TS(payld);
+ struct telemetry_de *tde;
+ u64 val, tstamp = 0;
+ u32 de_id;
+
+ de_id = PAYLD_ID(payld);
+ /* Discard malformed lines...a preceding BLK_TS must exist */
+ if (use_blk_ts && !active_bts) {
+ trace_scmi_tlm_access(de_id, "BAD_USE_BLK_TS", 0, 0);
+ return;
+ }
+
+ /* Is this DE ID known ? */
+ tde = scmi_telemetry_tde_lookup(ti, de_id);
+ if (!tde) {
+ if (mode != SCAN_DISCOVERY) {
+ trace_scmi_tlm_access(de_id, "DE_INVALID", 0, 0);
+ return;
+ }
+
+ /* In SCAN_DISCOVERY mode we allocate new DEs for unknown IDs */
+ tde = scmi_telemetry_tde_allocate(ti, de_id, payld);
+ if (!tde)
+ return;
+ }
+
+ /* Update DE location refs if requested: normally done only on enable */
+ if (mode >= SCAN_UPDATE) {
+ tde->base = shmti->base;
+ tde->eplg = SHMTI_EPLG(shmti);
+ tde->offset = (void *)payld - (void *)shmti->base;
+
+ dev_dbg(ti->ph->dev,
+ "TDCF-updated DE_ID:0x%08X - shmti:%pK offset:%u\n",
+ tde->de.info->id, tde->base, tde->offset);
+ }
+
+ /* Has any value/tstamp really changed ?*/
+ if (scmi_telemetry_tde_cache_unchanged(tde, shmti->last_magic))
+ return;
+
+ /* Link the related BTS when needed, it's unlinked on disable */
+ if (use_blk_ts && !tde->bts)
+ scmi_telemetry_bts_link(tde, active_bts);
+
+ /* Link the active UUID when existent, it's unlinked on disable */
+ if (active_uuid)
+ scmi_telemetry_uuid_link(tde, active_uuid);
+
+ /* Parse data words */
+ scmi_telemetry_line_data_parse(tde, &val, &tstamp, payld,
+ shmti->last_magic);
+
+}
+
+static int scmi_telemetry_tdcf_line_parse(struct telemetry_info *ti,
+ struct payload __iomem *payld,
+ struct telemetry_shmti *shmti,
+ enum scan_mode mode,
+ void **active_bts, void **active_uuid)
+{
+ int used_qwords;
+
+ used_qwords = LINE_LENGTH_QWORDS(payld);
+ /* Invalid lines are not an error, could simply be disabled DEs */
+ if (DATA_INVALID(payld)) {
+ trace_scmi_tlm_access(PAYLD_ID(payld), "TDCF_INVALID", 0, 0);
+ return used_qwords;
+ }
+
+ switch (LINE_TYPE(payld)) {
+ case TDCF_DATA_LINE:
+ scmi_telemetry_tdcf_data_parse(ti, payld, shmti, mode,
+ *active_bts, *active_uuid);
+ break;
+ case TDCF_BLK_TS_LINE:
+ scmi_telemetry_tdcf_blkts_parse(ti, payld, shmti, active_bts);
+ break;
+ case TDCF_UUID_LINE:
+ scmi_telemetry_tdcf_uuid_parse(ti, payld, shmti, active_uuid);
+ break;
+ default:
+ trace_scmi_tlm_access(PAYLD_ID(payld), "TDCF_UNKNOWN", 0, 0);
+ break;
+ }
+
+ return used_qwords;
+}
+
+/**
+ * scmi_telemetry_shmti_scan - Full SHMTI scan
+ * @ti: A reference to the telemetry info descriptor
+ * @shmti_id: ID of the SHMTI area that has to be scanned
+ * @mode: A flag to determine the behaviour of the scan
+ *
+ * Return: 0 on Success
+ */
+static int scmi_telemetry_shmti_scan(struct telemetry_info *ti,
+ unsigned int shmti_id, enum scan_mode mode)
+{
+ struct telemetry_shmti *shmti = &ti->shmti[shmti_id];
+ struct tdcf __iomem *tdcf = shmti->base;
+ int retries = SCMI_TLM_TDCF_MAX_RETRIES;
+ u32 startm = 0, endm = TDCF_BAD_END_SEQ;
+
+ if (!tdcf)
+ return -ENODEV;
+
+ do {
+ void *active_bts = NULL, *active_uuid = NULL;
+ unsigned int qwords;
+ void __iomem *next;
+
+ /* A bit of exponential backoff between retries */
+ fsleep((SCMI_TLM_TDCF_MAX_RETRIES - retries) * 1000);
+
+ /*
+ * Note that during a full SHMTI scan the magic seq numbers are
+ * checked only at the start and at the end of the scan, NOT
+ * between each parsed line and this has these consequences:
+ * - TDCF magic numbers accesses are reduced to 2 reads
+ * - the set of values obtained from a full scan belong all
+ * to the same platform update (same magic number)
+ * - a SHMTI full scan is an all or nothing operation: when
+ * a potentially corrupted read is detected along the way
+ * (MSEQ_MISMATCH) another full scan is triggered.
+ */
+ startm = TDCF_START_SEQ_GET(tdcf);
+ if (IS_BAD_START_SEQ(startm)) {
+ trace_scmi_tlm_access(0, "MSEQ_BADSTART", startm, 0);
+ continue;
+ }
+
+ /* On a BAD_SEQ this will be updated on the next attempt */
+ shmti->last_magic = startm;
+
+ qwords = QWORDS(tdcf);
+ next = tdcf->payld;
+ while (qwords) {
+ int used_qwords;
+
+ used_qwords = scmi_telemetry_tdcf_line_parse(ti, next,
+ shmti, mode,
+ &active_bts,
+ &active_uuid);
+ if (qwords < used_qwords) {
+ trace_scmi_tlm_access(PAYLD_ID(next),
+ "BAD_QWORDS", startm, 0);
+ return -EINVAL;
+ }
+
+ next += used_qwords * 8;
+ qwords -= used_qwords;
+ }
+
+ endm = TDCF_END_SEQ_GET(SHMTI_EPLG(shmti));
+ if (startm != endm)
+ trace_scmi_tlm_access(0, "MSEQ_MISMATCH", startm, endm);
+ } while (startm != endm && --retries);
+
+ if (startm != endm) {
+ trace_scmi_tlm_access(0, "TDCF_SCAN_FAIL", startm, endm);
+ return -EPROTO;
+ }
+
+ return 0;
+}
+
static const struct scmi_telemetry_proto_ops tlm_proto_ops = {
.info_get = scmi_telemetry_info_get,
.de_lookup = scmi_telemetry_de_lookup,
@@ -1211,6 +1830,13 @@ static void scmi_telemetry_resources_free(void *arg)
struct telemetry_info *ti = arg;
struct scmi_telemetry_res_info *rinfo = ACCESS_PRIVATE(ti, rinfo);
+ /*
+ * Unlinking all the BLK_TS/UUID lines related to a DE triggers also
+ * the deallocation of such lines when the embedded refcount hits zero.
+ */
+ for (int i = 0; i < rinfo->num_des; i++)
+ scmi_telemetry_de_unlink(rinfo->des[i]);
+
kfree(ti->tdes);
kfree(rinfo->des);
kfree(rinfo->dei_store);
@@ -1316,6 +1942,9 @@ static int scmi_telemetry_instance_init(struct telemetry_info *ti)
return ret;
xa_init(&ti->xa_des);
+ xa_init(&ti->xa_lines);
+ atomic_set(&ti->des_enabled[ENA_STATE], 0);
+ atomic_set(&ti->des_enabled[ENA_TSTAMP], 0);
/* Setup resources lazy initialization */
atomic_set(&ti->rinfo_initializing, 0);
init_completion(&ti->rinfo_initdone);
--
2.54.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox