From nobody Tue Apr 7 04:19:56 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A68CA7262B; Mon, 6 Apr 2026 06:36:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775457388; cv=none; b=jO06PefJlMb4UawpqLaTo9RPi6LGY18ifwgBVp7NIw2+HKFWEQSrCpJgaxN7CSyyWmL2mFOyy6JA4Q8mleSCUKN59oXETVpJ8ubXXIfSaUGor+g4bLLd4ktApohpJyunPh7/kmmS2MF72aVWnc8EVCQVpBTTAVyLIG1XHgV2Hrc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775457388; c=relaxed/simple; bh=8EM53iH7JwSzKxm8wQ1wZ9jdKfJec0x03boGG4KY2VU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:To:Cc; b=eLyY8q2n2Qw6NCJYMxhnDhaTX1RT7TczGnq5xAG9qbZLa7ChtSMu+1kkdtnwrvPqGLSA1rmwo5cUVIAEKVV9eTEHTcKgU00XuU6p91FcmzDKg5BJRB5ylXRVENnr4LoAaU0KwSROcWdTvUIfs1M+Kwt/PYUi4dLk0S2XNqb4EDY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=M4R2QUaY; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="M4R2QUaY" Received: by smtp.kernel.org (Postfix) with ESMTPS id 4F52BC4CEF7; Mon, 6 Apr 2026 06:36:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1775457388; bh=8EM53iH7JwSzKxm8wQ1wZ9jdKfJec0x03boGG4KY2VU=; h=From:Date:Subject:To:Cc:Reply-To:From; b=M4R2QUaYuSwgN7PVnW+eZ0a+zFzmVkferdT97CtdByeVSj2a9YpQD4xrZaB5xo3ZB 8sJGYHv0xF/cN/ieu4TgG5JyJ4nz9DbqxauhjDPCeBNWUbPZt3Tu4lQIRcV3nuS669 JfsJkkWEFaW3ni0xeeTCBjiE4rXILDCMVd2YAPlmGs9JOWg0CrQbTisKvcVK/6auHT k+SLBOTXga+yiPQYfWbCsi+K8vI1CdmyRESaXkTMIG7vDcR0+dgrtVFtcJFFaRNZGZ HmROWQ/JHpACNifAM/o42Cmelj6DVTYq01lwuvB67/ys4U4ArqHje0eFQBlS0TJkmP IsIbD7lHGLxJA== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 46506EF4EB0; Mon, 6 Apr 2026 06:36:28 +0000 (UTC) From: Aaron Kling via B4 Relay Date: Mon, 06 Apr 2026 01:36:20 -0500 Subject: [PATCH v7] memory: tegra210: Support interconnect framework Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260406-t210-actmon-p2-v7-1-91adf535cf8f@gmail.com> X-B4-Tracking: v=1; b=H4sIAAAAAAAC/13OQQrCMBCF4auUrB1JhiYBV95DXKSTaRswTU1jE UrvbpC6cfkv3sfbxMI58CIuzSYyr2EJaaphT42g0U0DQ/C1BUo0spUaCioJjkpME8wIsiOvezK ayYg6mjP34f0Fb/fafU4RypjZ/RitJNp/ZjWgQFHbeUTrjTXXIbrwOFOKh5r5+arvykHv+wepB bd9uwAAAA== X-Change-ID: 20260405-t210-actmon-p2-0bcd5fc65ec6 To: Krzysztof Kozlowski , Thierry Reding , Jonathan Hunter Cc: linux-kernel@vger.kernel.org, linux-tegra@vger.kernel.org, Aaron Kling X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1775457387; l=17174; i=webgeek1234@gmail.com; s=20250217; h=from:subject:message-id; bh=KAHKZYvJmWAZZPhruG56Hw7Kl9tDtric0WozU0X9ZV0=; b=1bTMMvWxvfK//PkZDHXepwVCAg1vRVRVuGXq91inV7Gb1c72wEXlsEQZ+F09FF1spdsQ3Vzuj 2BJONyj0mG/DJIjn8yULPvdWtG66WKeCljzOY/Iu84OylH/IbjjwxGn X-Developer-Key: i=webgeek1234@gmail.com; a=ed25519; pk=TQwd6q26txw7bkK7B8qtI/kcAohZc7bHHGSD7domdrU= X-Endpoint-Received: by B4 Relay for webgeek1234@gmail.com/20250217 with auth_id=342 X-Original-From: Aaron Kling Reply-To: webgeek1234@gmail.com From: Aaron Kling This makes mc and emc interconnect providers and allows for dynamic memory clock scaling. Signed-off-by: Aaron Kling --- Changes in v7: - Squash fixes found during previous foray through -next - Use kzalloc_obj in place of kzalloc - Link to v6: https://lore.kernel.org/r/20251027-t210-actmon-p2-v6-1-1c4bd2= 27d676@gmail.com Changes in v6: - Fix style nit - Link to v5: https://lore.kernel.org/r/20251021-t210-actmon-p2-v5-1-a07dc7= 0e948d@gmail.com Changes in v5: - Split series - Link to v4: https://lore.kernel.org/r/20250923-t210-actmon-v4-0-442d1eb63= 77c@gmail.com Changes in v4: - Various cleanups in patch 5 as requested by review - Fix a couple typos in patch 4 - Link to v3: https://lore.kernel.org/r/20250906-t210-actmon-v3-0-1403365d5= 71e@gmail.com Changes in v3: - In patch 5, don't fail mc probe if opp tables are missing - Add more mc bindings to patch 1 - Add patch to use tegra210-mc bindings in the mc driver - Re-order series to align patches within a subsystem to each other - Link to v2: https://lore.kernel.org/r/20250903-t210-actmon-v2-0-e0d534d4f= 8ea@gmail.com Changes in v2: - Assume 64-bit dram bus width in patch 4 - Add dt-bindings patch to document the new properties on the tegra210-emc node. - Link to v1: https://lore.kernel.org/r/20250828-t210-actmon-v1-0-aeb19ec1f= 244@gmail.com --- drivers/memory/tegra/Kconfig | 1 + drivers/memory/tegra/tegra210-emc-core.c | 287 +++++++++++++++++++++++++++= +++- drivers/memory/tegra/tegra210-emc.h | 24 +++ drivers/memory/tegra/tegra210.c | 81 +++++++++ 4 files changed, 390 insertions(+), 3 deletions(-) diff --git a/drivers/memory/tegra/Kconfig b/drivers/memory/tegra/Kconfig index fc5a277918267ee8240f9fb9efeb80275db4790b..2d0be29afe2b9ebf9a0630ef7fb= 6fb43ff359499 100644 --- a/drivers/memory/tegra/Kconfig +++ b/drivers/memory/tegra/Kconfig @@ -55,6 +55,7 @@ config TEGRA210_EMC tristate "NVIDIA Tegra210 External Memory Controller driver" depends on ARCH_TEGRA_210_SOC || COMPILE_TEST select TEGRA210_EMC_TABLE + select PM_OPP help This driver is for the External Memory Controller (EMC) found on Tegra210 chips. The EMC controls the external DRAM on the board. diff --git a/drivers/memory/tegra/tegra210-emc-core.c b/drivers/memory/tegr= a/tegra210-emc-core.c index e96ca4157d48182574310f8caf72687bed7cc16a..c7850df2a21d9f6b837bc1fa24a= 159fc18b0498a 100644 --- a/drivers/memory/tegra/tegra210-emc-core.c +++ b/drivers/memory/tegra/tegra210-emc-core.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -87,6 +88,13 @@ =20 #define LPDDR2_MR4_SRR GENMASK(2, 0) =20 +/* + * Tegra210 memory layout can be 1 channel at 64-bit or 2 channels at 32-b= it + * each. Either way, the total bus width will always be 64-bit. + */ +#define DRAM_DATA_BUS_WIDTH_BYTES (64 / 8) +#define DDR 2 + static const struct tegra210_emc_sequence *tegra210_emc_sequences[] =3D { &tegra210_emc_r21021, }; @@ -1569,6 +1577,79 @@ static int tegra210_emc_set_rate(struct device *dev, return 0; } =20 +static void tegra210_emc_rate_requests_init(struct tegra210_emc *emc) +{ + unsigned int i; + + for (i =3D 0; i < EMC_RATE_TYPE_MAX; i++) { + emc->requested_rate[i].min_rate =3D 0; + emc->requested_rate[i].max_rate =3D ULONG_MAX; + } +} + +static int emc_request_rate(struct tegra210_emc *emc, + unsigned long new_min_rate, + unsigned long new_max_rate, + enum emc_rate_request_type type) +{ + struct emc_rate_request *req =3D emc->requested_rate; + unsigned long min_rate =3D 0, max_rate =3D ULONG_MAX; + unsigned int i; + int err; + + /* select minimum and maximum rates among the requested rates */ + for (i =3D 0; i < EMC_RATE_TYPE_MAX; i++, req++) { + if (i =3D=3D type) { + min_rate =3D max(new_min_rate, min_rate); + max_rate =3D min(new_max_rate, max_rate); + } else { + min_rate =3D max(req->min_rate, min_rate); + max_rate =3D min(req->max_rate, max_rate); + } + } + + if (min_rate > max_rate) { + dev_err_ratelimited(emc->dev, "%s: type %u: out of range: %lu %lu\n", + __func__, type, min_rate, max_rate); + return -ERANGE; + } + + err =3D clk_set_rate(emc->clk, min_rate); + if (err) + return err; + + emc->requested_rate[type].min_rate =3D new_min_rate; + emc->requested_rate[type].max_rate =3D new_max_rate; + + return 0; +} + +static int emc_set_min_rate(struct tegra210_emc *emc, unsigned long rate, + enum emc_rate_request_type type) +{ + struct emc_rate_request *req =3D &emc->requested_rate[type]; + int ret; + + mutex_lock(&emc->rate_lock); + ret =3D emc_request_rate(emc, rate, req->max_rate, type); + mutex_unlock(&emc->rate_lock); + + return ret; +} + +static int emc_set_max_rate(struct tegra210_emc *emc, unsigned long rate, + enum emc_rate_request_type type) +{ + struct emc_rate_request *req =3D &emc->requested_rate[type]; + int ret; + + mutex_lock(&emc->rate_lock); + ret =3D emc_request_rate(emc, req->min_rate, rate, type); + mutex_unlock(&emc->rate_lock); + + return ret; +} + /* * debugfs interface * @@ -1641,7 +1722,7 @@ static int tegra210_emc_debug_min_rate_set(void *data= , u64 rate) if (!tegra210_emc_validate_rate(emc, rate)) return -EINVAL; =20 - err =3D clk_set_min_rate(emc->clk, rate); + err =3D emc_set_min_rate(emc, rate, EMC_RATE_DEBUG); if (err < 0) return err; =20 @@ -1671,7 +1752,7 @@ static int tegra210_emc_debug_max_rate_set(void *data= , u64 rate) if (!tegra210_emc_validate_rate(emc, rate)) return -EINVAL; =20 - err =3D clk_set_max_rate(emc->clk, rate); + err =3D emc_set_max_rate(emc, rate, EMC_RATE_DEBUG); if (err < 0) return err; =20 @@ -1758,6 +1839,194 @@ static void tegra210_emc_debugfs_init(struct tegra2= 10_emc *emc) &tegra210_emc_debug_temperature_fops); } =20 +static inline struct tegra210_emc * +to_tegra210_emc_provider(struct icc_provider *provider) +{ + return container_of(provider, struct tegra210_emc, icc_provider); +} + +static struct icc_node_data * +emc_of_icc_xlate_extended(const struct of_phandle_args *spec, void *data) +{ + struct icc_provider *provider =3D data; + struct icc_node_data *ndata; + struct icc_node *node; + + /* External Memory is the only possible ICC route */ + list_for_each_entry(node, &provider->nodes, node_list) { + if (node->id !=3D TEGRA_ICC_EMEM) + continue; + + ndata =3D kzalloc_obj(*ndata); + if (!ndata) + return ERR_PTR(-ENOMEM); + + /* + * SRC and DST nodes should have matching TAG in order to have + * it set by default for a requested path. + */ + ndata->tag =3D TEGRA_MC_ICC_TAG_ISO; + ndata->node =3D node; + + return ndata; + } + + return ERR_PTR(-EPROBE_DEFER); +} + +static int emc_icc_set(struct icc_node *src, struct icc_node *dst) +{ + struct tegra210_emc *emc =3D to_tegra210_emc_provider(dst->provider); + unsigned long long peak_bw =3D icc_units_to_bps(dst->peak_bw); + unsigned long long avg_bw =3D icc_units_to_bps(dst->avg_bw); + unsigned long long rate =3D max(avg_bw, peak_bw); + int err; + + /* + * Tegra210 EMC runs on a clock rate of SDRAM bus. This means that + * EMC clock rate is twice smaller than the peak data rate because + * data is sampled on both EMC clock edges. + */ + do_div(rate, DDR * DRAM_DATA_BUS_WIDTH_BYTES); + rate =3D min_t(u64, rate, U32_MAX); + + err =3D emc_set_min_rate(emc, rate, EMC_RATE_ICC); + if (err) + return err; + + return 0; +} + +static int tegra210_emc_icc_get_init_bw(struct icc_node *node, u32 *avg, u= 32 *peak) +{ + *avg =3D 0; + *peak =3D 0; + + return 0; +} + +static int tegra210_emc_interconnect_init(struct tegra210_emc *emc) +{ + const struct tegra_mc_soc *soc =3D emc->mc->soc; + struct icc_node *node; + int err; + + emc->icc_provider.dev =3D emc->dev; + emc->icc_provider.set =3D emc_icc_set; + emc->icc_provider.data =3D &emc->icc_provider; + emc->icc_provider.aggregate =3D soc->icc_ops->aggregate; + emc->icc_provider.xlate_extended =3D emc_of_icc_xlate_extended; + emc->icc_provider.get_bw =3D tegra210_emc_icc_get_init_bw; + + icc_provider_init(&emc->icc_provider); + + /* create External Memory Controller node */ + node =3D icc_node_create(TEGRA_ICC_EMC); + if (IS_ERR(node)) + return PTR_ERR(node); + + node->name =3D "External Memory Controller"; + icc_node_add(node, &emc->icc_provider); + + /* link External Memory Controller to External Memory (DRAM) */ + err =3D icc_link_create(node, TEGRA_ICC_EMEM); + if (err) + goto remove_nodes; + + /* create External Memory node */ + node =3D icc_node_create(TEGRA_ICC_EMEM); + if (IS_ERR(node)) { + err =3D PTR_ERR(node); + goto remove_nodes; + } + + node->name =3D "External Memory (DRAM)"; + icc_node_add(node, &emc->icc_provider); + + err =3D icc_provider_register(&emc->icc_provider); + if (err) + goto remove_nodes; + + return 0; + +remove_nodes: + icc_nodes_remove(&emc->icc_provider); + + return dev_err_probe(emc->dev, err, "failed to initialize ICC\n"); +} + +static int tegra210_emc_opp_table_init(struct tegra210_emc *emc) +{ + u32 hw_version =3D BIT(tegra_sku_info.soc_speedo_id); + struct dev_pm_opp *opp; + unsigned long rate; + int err, max_opps, i; + + err =3D dev_pm_opp_set_supported_hw(emc->dev, &hw_version, 1); + if (err < 0) + return dev_err_probe(emc->dev, err, "failed to set OPP supported HW\n"); + + emc->hw_opp_token =3D err; + + err =3D dev_pm_opp_of_add_table(emc->dev); + if (err) { + if (err =3D=3D -ENODEV) + dev_err_probe(emc->dev, err, + "OPP table not found, please update your device tree\n"); + else + dev_err_probe(emc->dev, err, "failed to add OPP table\n"); + + goto put_hw_table; + } + + max_opps =3D dev_pm_opp_get_opp_count(emc->dev); + if (max_opps <=3D 0) { + err =3D max_opps ?: -EINVAL; + dev_err_probe(emc->dev, err, "Failed to add OPPs\n"); + goto remove_table; + } + + if (emc->num_timings !=3D max_opps) { + err =3D -EINVAL; + dev_err_probe(emc->dev, err, "OPP table does not match emc table\n"); + goto remove_table; + } + + for (i =3D 0; i < emc->num_timings; i++) { + rate =3D emc->timings[i].rate * 1000; + opp =3D dev_pm_opp_find_freq_exact(emc->dev, rate, true); + if (IS_ERR(opp)) { + err =3D PTR_ERR(opp); + dev_err_probe(emc->dev, err, "Rate %lu not found in OPP table\n", rate); + goto remove_table; + } + + dev_pm_opp_put(opp); + } + + dev_info_once(emc->dev, "OPP HW ver. 0x%x, current clock rate %lu MHz\n", + hw_version, clk_get_rate(emc->clk) / 1000000); + + return 0; + +remove_table: + dev_pm_opp_of_remove_table(emc->dev); +put_hw_table: + dev_pm_opp_put_supported_hw(emc->hw_opp_token); + emc->hw_opp_token =3D 0; + + return err; +} + +static void tegra210_emc_opp_table_cleanup(struct tegra210_emc *emc) +{ + if (emc->hw_opp_token) { + dev_pm_opp_of_remove_table(emc->dev); + dev_pm_opp_put_supported_hw(emc->hw_opp_token); + emc->hw_opp_token =3D 0; + } +} + static void tegra210_emc_detect(struct tegra210_emc *emc) { u32 value; @@ -1966,17 +2235,27 @@ static int tegra210_emc_probe(struct platform_devic= e *pdev) =20 tegra210_emc_debugfs_init(emc); =20 + err =3D tegra210_emc_opp_table_init(emc); + if (!err) { + tegra210_emc_rate_requests_init(emc); + tegra210_emc_interconnect_init(emc); + } else if (err !=3D -ENODEV) { + goto detach; + } + cd =3D devm_thermal_of_cooling_device_register(emc->dev, np, "emc", emc, &tegra210_emc_cd_ops); if (IS_ERR(cd)) { err =3D PTR_ERR(cd); dev_err(emc->dev, "failed to register cooling device: %d\n", err); - goto detach; + goto cleanup_table; } =20 return 0; =20 +cleanup_table: + tegra210_emc_opp_table_cleanup(emc); detach: debugfs_remove_recursive(emc->debugfs.root); tegra210_clk_emc_detach(emc->clk); @@ -1990,6 +2269,7 @@ static void tegra210_emc_remove(struct platform_devic= e *pdev) { struct tegra210_emc *emc =3D platform_get_drvdata(pdev); =20 + tegra210_emc_opp_table_cleanup(emc); debugfs_remove_recursive(emc->debugfs.root); tegra210_clk_emc_detach(emc->clk); of_reserved_mem_device_release(emc->dev); @@ -2050,6 +2330,7 @@ static struct platform_driver tegra210_emc_driver =3D= { .name =3D "tegra210-emc", .of_match_table =3D tegra210_emc_of_match, .pm =3D &tegra210_emc_pm_ops, + .sync_state =3D icc_sync_state, }, .probe =3D tegra210_emc_probe, .remove =3D tegra210_emc_remove, diff --git a/drivers/memory/tegra/tegra210-emc.h b/drivers/memory/tegra/teg= ra210-emc.h index 8988bcf1529072a7bdc93b185ebe0d51d82c1763..e6f267823f9f0ee18cd60778116= dc5ca2730a5d4 100644 --- a/drivers/memory/tegra/tegra210-emc.h +++ b/drivers/memory/tegra/tegra210-emc.h @@ -8,6 +8,7 @@ =20 #include #include +#include #include #include =20 @@ -784,6 +785,17 @@ enum { #define TRIM_REGS_SIZE 138 #define BURST_REGS_SIZE 221 =20 +enum emc_rate_request_type { + EMC_RATE_DEBUG, + EMC_RATE_ICC, + EMC_RATE_TYPE_MAX, +}; + +struct emc_rate_request { + unsigned long min_rate; + unsigned long max_rate; +}; + struct tegra210_emc_per_channel_regs { u16 bank; u16 offset; @@ -932,6 +944,18 @@ struct tegra210_emc { } debugfs; =20 struct tegra210_clk_emc_provider provider; + + struct icc_provider icc_provider; + int hw_opp_token; + + /* + * There are multiple sources in the EMC driver which could request + * a min/max clock rate, these rates are contained in this array. + */ + struct emc_rate_request requested_rate[EMC_RATE_TYPE_MAX]; + + /* protect shared rate-change code path */ + struct mutex rate_lock; }; =20 struct tegra210_emc_sequence { diff --git a/drivers/memory/tegra/tegra210.c b/drivers/memory/tegra/tegra21= 0.c index f58f3ef6f68191ede7098bfa4dad546ce4de275d..bcc441e786301438279e5318373= d502e3b22eec5 100644 --- a/drivers/memory/tegra/tegra210.c +++ b/drivers/memory/tegra/tegra210.c @@ -3,6 +3,9 @@ * Copyright (C) 2015-2026 NVIDIA CORPORATION. All rights reserved. */ =20 +#include +#include + #include =20 #include "mc.h" @@ -1282,6 +1285,83 @@ static const struct tegra_mc_intmask tegra210_mc_int= masks[] =3D { }, }; =20 +static int tegra210_mc_icc_set(struct icc_node *src, struct icc_node *dst) +{ + /* TODO: program PTSA */ + return 0; +} + +static int tegra210_mc_icc_aggregate(struct icc_node *node, u32 tag, u32 a= vg_bw, + u32 peak_bw, u32 *agg_avg, u32 *agg_peak) +{ + /* + * ISO clients need to reserve extra bandwidth up-front because + * there could be high bandwidth pressure during initial filling + * of the client's FIFO buffers. Secondly, we need to take into + * account impurities of the memory subsystem. + */ + if (tag & TEGRA_MC_ICC_TAG_ISO) + peak_bw =3D tegra_mc_scale_percents(peak_bw, 400); + + *agg_avg +=3D avg_bw; + *agg_peak =3D max(*agg_peak, peak_bw); + + return 0; +} + +static struct icc_node_data * +tegra210_mc_of_icc_xlate_extended(const struct of_phandle_args *spec, void= *data) +{ + struct tegra_mc *mc =3D icc_provider_to_tegra_mc(data); + const struct tegra_mc_client *client; + unsigned int i, idx =3D spec->args[0]; + struct icc_node_data *ndata; + struct icc_node *node; + + list_for_each_entry(node, &mc->provider.nodes, node_list) { + if (node->id !=3D idx) + continue; + + ndata =3D kzalloc_obj(*ndata); + if (!ndata) + return ERR_PTR(-ENOMEM); + + client =3D &mc->soc->clients[idx]; + ndata->node =3D node; + + switch (client->swgroup) { + case TEGRA_SWGROUP_DC: + case TEGRA_SWGROUP_DCB: + case TEGRA_SWGROUP_PTC: + case TEGRA_SWGROUP_VI: + /* these clients are isochronous by default */ + ndata->tag =3D TEGRA_MC_ICC_TAG_ISO; + break; + + default: + ndata->tag =3D TEGRA_MC_ICC_TAG_DEFAULT; + break; + } + + return ndata; + } + + for (i =3D 0; i < mc->soc->num_clients; i++) { + if (mc->soc->clients[i].id =3D=3D idx) + return ERR_PTR(-EPROBE_DEFER); + } + + dev_err(mc->dev, "invalid ICC client ID %u\n", idx); + + return ERR_PTR(-EINVAL); +} + +static const struct tegra_mc_icc_ops tegra210_mc_icc_ops =3D { + .xlate_extended =3D tegra210_mc_of_icc_xlate_extended, + .aggregate =3D tegra210_mc_icc_aggregate, + .set =3D tegra210_mc_icc_set, +}; + const struct tegra_mc_soc tegra210_mc_soc =3D { .clients =3D tegra210_mc_clients, .num_clients =3D ARRAY_SIZE(tegra210_mc_clients), @@ -1294,6 +1374,7 @@ const struct tegra_mc_soc tegra210_mc_soc =3D { .reset_ops =3D &tegra_mc_reset_ops_common, .resets =3D tegra210_mc_resets, .num_resets =3D ARRAY_SIZE(tegra210_mc_resets), + .icc_ops =3D &tegra210_mc_icc_ops, .ops =3D &tegra30_mc_ops, .regs =3D &tegra20_mc_regs, .handle_irq =3D tegra30_mc_irq_handlers, --- base-commit: 2febe6e6ee6e34c7754eff3c4d81aa7b0dcb7979 change-id: 20260405-t210-actmon-p2-0bcd5fc65ec6 Best regards, --=20 Aaron Kling