icc-rpmh.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2020, The Linux Foundation. All rights reserved.
  4 * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
  5 */
  6
  7#include <linux/bitfield.h>
  8#include <linux/clk.h>
  9#include <linux/interconnect.h>
 10#include <linux/interconnect-provider.h>
 11#include <linux/module.h>
 12#include <linux/of.h>
 13#include <linux/of_platform.h>
 14#include <linux/slab.h>
 15
 16#include "bcm-voter.h"
 17#include "icc-common.h"
 18#include "icc-rpmh.h"
 19
 20/* QNOC QoS */
 21#define QOSGEN_MAINCTL_LO(p, qp)	(0x8 + (p->port_offsets[qp]))
 22#define QOS_SLV_URG_MSG_EN_MASK		GENMASK(3, 3)
 23#define QOS_DFLT_PRIO_MASK		GENMASK(6, 4)
 24#define QOS_DISABLE_MASK		GENMASK(24, 24)
 25
 26/**
 27 * qcom_icc_set_qos - initialize static QoS configurations
 28 * @qp: qcom icc provider to which @node belongs
 29 * @node: qcom icc node to operate on
 30 */
 31static void qcom_icc_set_qos(struct qcom_icc_provider *qp,
 32			     struct qcom_icc_node *node)
 33{
 34	const struct qcom_icc_qosbox *qos = node->qosbox;
 35	int port;
 36
 37	for (port = 0; port < qos->num_ports; port++) {
 38		regmap_update_bits(qp->regmap, QOSGEN_MAINCTL_LO(qos, port),
 39				   QOS_DISABLE_MASK,
 40				   FIELD_PREP(QOS_DISABLE_MASK, qos->prio_fwd_disable));
 41
 42		regmap_update_bits(qp->regmap, QOSGEN_MAINCTL_LO(qos, port),
 43				   QOS_DFLT_PRIO_MASK,
 44				   FIELD_PREP(QOS_DFLT_PRIO_MASK, qos->prio));
 45
 46		regmap_update_bits(qp->regmap, QOSGEN_MAINCTL_LO(qos, port),
 47				   QOS_SLV_URG_MSG_EN_MASK,
 48				   FIELD_PREP(QOS_SLV_URG_MSG_EN_MASK, qos->urg_fwd));
 49	}
 50}
 51
 52/**
 53 * qcom_icc_pre_aggregate - cleans up stale values from prior icc_set
 54 * @node: icc node to operate on
 55 */
 56void qcom_icc_pre_aggregate(struct icc_node *node)
 57{
 58	size_t i;
 59	struct qcom_icc_node *qn;
 60	struct qcom_icc_provider *qp;
 61
 62	qn = node->data;
 63	qp = to_qcom_provider(node->provider);
 64
 65	for (i = 0; i < QCOM_ICC_NUM_BUCKETS; i++) {
 66		qn->sum_avg[i] = 0;
 67		qn->max_peak[i] = 0;
 68	}
 69
 70	for (i = 0; i < qn->num_bcms; i++)
 71		qcom_icc_bcm_voter_add(qp->voter, qn->bcms[i]);
 72}
 73EXPORT_SYMBOL_GPL(qcom_icc_pre_aggregate);
 74
 75/**
 76 * qcom_icc_aggregate - aggregate bw for buckets indicated by tag
 77 * @node: node to aggregate
 78 * @tag: tag to indicate which buckets to aggregate
 79 * @avg_bw: new bw to sum aggregate
 80 * @peak_bw: new bw to max aggregate
 81 * @agg_avg: existing aggregate avg bw val
 82 * @agg_peak: existing aggregate peak bw val
 83 */
 84int qcom_icc_aggregate(struct icc_node *node, u32 tag, u32 avg_bw,
 85		       u32 peak_bw, u32 *agg_avg, u32 *agg_peak)
 86{
 87	size_t i;
 88	struct qcom_icc_node *qn;
 89
 90	qn = node->data;
 91
 92	if (!tag)
 93		tag = QCOM_ICC_TAG_ALWAYS;
 94
 95	for (i = 0; i < QCOM_ICC_NUM_BUCKETS; i++) {
 96		if (tag & BIT(i)) {
 97			qn->sum_avg[i] += avg_bw;
 98			qn->max_peak[i] = max_t(u32, qn->max_peak[i], peak_bw);
 99		}
100
101		if (node->init_avg || node->init_peak) {
102			qn->sum_avg[i] = max_t(u64, qn->sum_avg[i], node->init_avg);
103			qn->max_peak[i] = max_t(u64, qn->max_peak[i], node->init_peak);
104		}
105	}
106
107	*agg_avg += avg_bw;
108	*agg_peak = max_t(u32, *agg_peak, peak_bw);
109
110	return 0;
111}
112EXPORT_SYMBOL_GPL(qcom_icc_aggregate);
113
114/**
115 * qcom_icc_set - set the constraints based on path
116 * @src: source node for the path to set constraints on
117 * @dst: destination node for the path to set constraints on
118 *
119 * Return: 0 on success, or an error code otherwise
120 */
121int qcom_icc_set(struct icc_node *src, struct icc_node *dst)
122{
123	struct qcom_icc_provider *qp;
124	struct icc_node *node;
125
126	if (!src)
127		node = dst;
128	else
129		node = src;
130
131	qp = to_qcom_provider(node->provider);
132
133	qcom_icc_bcm_voter_commit(qp->voter);
134
135	return 0;
136}
137EXPORT_SYMBOL_GPL(qcom_icc_set);
138
139/**
140 * qcom_icc_bcm_init - populates bcm aux data and connect qnodes
141 * @bcm: bcm to be initialized
142 * @dev: associated provider device
143 *
144 * Return: 0 on success, or an error code otherwise
145 */
146int qcom_icc_bcm_init(struct qcom_icc_bcm *bcm, struct device *dev)
147{
148	struct qcom_icc_node *qn;
149	const struct bcm_db *data;
150	size_t data_count;
151	int i;
152
153	/* BCM is already initialised*/
154	if (bcm->addr)
155		return 0;
156
157	bcm->addr = cmd_db_read_addr(bcm->name);
158	if (!bcm->addr) {
159		dev_err(dev, "%s could not find RPMh address\n",
160			bcm->name);
161		return -EINVAL;
162	}
163
164	data = cmd_db_read_aux_data(bcm->name, &data_count);
165	if (IS_ERR(data)) {
166		dev_err(dev, "%s command db read error (%ld)\n",
167			bcm->name, PTR_ERR(data));
168		return PTR_ERR(data);
169	}
170	if (!data_count) {
171		dev_err(dev, "%s command db missing or partial aux data\n",
172			bcm->name);
173		return -EINVAL;
174	}
175
176	bcm->aux_data.unit = le32_to_cpu(data->unit);
177	bcm->aux_data.width = le16_to_cpu(data->width);
178	bcm->aux_data.vcd = data->vcd;
179	bcm->aux_data.reserved = data->reserved;
180	INIT_LIST_HEAD(&bcm->list);
181	INIT_LIST_HEAD(&bcm->ws_list);
182
183	if (!bcm->vote_scale)
184		bcm->vote_scale = 1000;
185
186	/* Link Qnodes to their respective BCMs */
187	for (i = 0; i < bcm->num_nodes; i++) {
188		qn = bcm->nodes[i];
189		qn->bcms[qn->num_bcms] = bcm;
190		qn->num_bcms++;
191	}
192
193	return 0;
194}
195EXPORT_SYMBOL_GPL(qcom_icc_bcm_init);
196
197/**
198 * qcom_icc_rpmh_configure_qos - configure QoS parameters
199 * @qp: qcom icc provider associated with QoS endpoint nodes
200 *
201 * Return: 0 on success, or an error code otherwise
202 */
203static int qcom_icc_rpmh_configure_qos(struct qcom_icc_provider *qp)
204{
205	struct qcom_icc_node *qnode;
206	size_t i;
207	int ret;
208
209	ret = clk_bulk_prepare_enable(qp->num_clks, qp->clks);
210	if (ret)
211		return ret;
212
213	for (i = 0; i < qp->num_nodes; i++) {
214		qnode = qp->nodes[i];
215		if (!qnode)
216			continue;
217
218		if (qnode->qosbox)
219			qcom_icc_set_qos(qp, qnode);
220	}
221
222	clk_bulk_disable_unprepare(qp->num_clks, qp->clks);
223
224	return ret;
225}
226
227int qcom_icc_rpmh_probe(struct platform_device *pdev)
228{
229	const struct qcom_icc_desc *desc;
230	struct device *dev = &pdev->dev;
231	struct icc_onecell_data *data;
232	struct icc_provider *provider;
233	struct qcom_icc_node * const *qnodes, *qn;
234	struct qcom_icc_provider *qp;
235	struct icc_node *node;
236	size_t num_nodes, i, j;
237	int ret;
238
239	desc = of_device_get_match_data(dev);
240	if (!desc)
241		return -EINVAL;
242
243	qnodes = desc->nodes;
244	num_nodes = desc->num_nodes;
245
246	qp = devm_kzalloc(dev, sizeof(*qp), GFP_KERNEL);
247	if (!qp)
248		return -ENOMEM;
249
250	data = devm_kzalloc(dev, struct_size(data, nodes, num_nodes), GFP_KERNEL);
251	if (!data)
252		return -ENOMEM;
253	data->num_nodes = num_nodes;
254
255	provider = &qp->provider;
256	provider->dev = dev;
257	provider->set = qcom_icc_set;
258	provider->pre_aggregate = qcom_icc_pre_aggregate;
259	provider->aggregate = qcom_icc_aggregate;
260	provider->xlate_extended = qcom_icc_xlate_extended;
261	provider->data = data;
262
263	icc_provider_init(provider);
264
265	qp->dev = dev;
266	qp->bcms = desc->bcms;
267	qp->nodes = desc->nodes;
268	qp->num_bcms = desc->num_bcms;
269	qp->num_nodes = desc->num_nodes;
270
271	qp->voter = of_bcm_voter_get(qp->dev, NULL);
272	if (IS_ERR(qp->voter))
273		return PTR_ERR(qp->voter);
274
275	for (i = 0; i < qp->num_bcms; i++)
276		qcom_icc_bcm_init(qp->bcms[i], dev);
277
278	for (i = 0; i < num_nodes; i++) {
279		qn = qnodes[i];
280		if (!qn)
281			continue;
282
283		if (!qn->node)
284			qn->node = icc_node_create_dyn();
285
286		node = qn->node;
287		if (IS_ERR(node)) {
288			ret = PTR_ERR(node);
289			goto err_remove_nodes;
290		}
291
292		ret = icc_node_set_name(node, provider, qn->name);
293		if (ret) {
294			icc_node_destroy(node->id);
295			goto err_remove_nodes;
296		}
297
298		node->data = qn;
299		icc_node_add(node, provider);
300
301		for (j = 0; j < qn->num_links; j++)
302			icc_link_nodes(node, &qn->link_nodes[j]->node);
303
304		data->nodes[i] = node;
305	}
306
307	if (desc->config) {
308		struct resource *res;
309		void __iomem *base;
310
311		/* Try parent's regmap first */
312		qp->regmap = dev_get_regmap(dev->parent, NULL);
313		if (!qp->regmap) {
314			base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
315			if (IS_ERR(base))
316				goto skip_qos_config;
317
318			qp->regmap = devm_regmap_init_mmio(dev, base, desc->config);
319			if (IS_ERR(qp->regmap)) {
320				dev_info(dev, "Skipping QoS, regmap failed; %ld\n",
321					 PTR_ERR(qp->regmap));
322				goto skip_qos_config;
323			}
324		}
325
326		qp->num_clks = devm_clk_bulk_get_all(qp->dev, &qp->clks);
327		if (qp->num_clks == -EPROBE_DEFER)
328			return dev_err_probe(dev, qp->num_clks, "Failed to get QoS clocks\n");
329
330		if (qp->num_clks < 0 || (!qp->num_clks && desc->qos_requires_clocks)) {
331			dev_info(dev, "Skipping QoS, failed to get clk: %d\n", qp->num_clks);
332			goto skip_qos_config;
333		}
334
335		ret = qcom_icc_rpmh_configure_qos(qp);
336		if (ret)
337			dev_info(dev, "Failed to program QoS: %d\n", ret);
338	}
339
340skip_qos_config:
341	ret = icc_provider_register(provider);
342	if (ret)
343		goto err_remove_nodes;
344
345	platform_set_drvdata(pdev, qp);
346
347	/* Populate child NoC devices if any */
348	if (of_get_child_count(dev->of_node) > 0) {
349		ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
350		if (ret)
351			goto err_deregister_provider;
352	}
353
354	return 0;
355
356err_deregister_provider:
357	icc_provider_deregister(provider);
358err_remove_nodes:
359	icc_nodes_remove(provider);
360
361	return ret;
362}
363EXPORT_SYMBOL_GPL(qcom_icc_rpmh_probe);
364
365void qcom_icc_rpmh_remove(struct platform_device *pdev)
366{
367	struct qcom_icc_provider *qp = platform_get_drvdata(pdev);
368
369	icc_provider_deregister(&qp->provider);
370	icc_nodes_remove(&qp->provider);
371}
372EXPORT_SYMBOL_GPL(qcom_icc_rpmh_remove);
373
374MODULE_DESCRIPTION("Qualcomm RPMh interconnect driver");
375MODULE_LICENSE("GPL v2");