1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
  4 */
  5
  6#include <linux/amba/bus.h>
  7#include <linux/bitfield.h>
  8#include <linux/coresight.h>
  9#include <linux/device.h>
 10#include <linux/err.h>
 11#include <linux/fs.h>
 12#include <linux/io.h>
 13#include <linux/kernel.h>
 14#include <linux/module.h>
 15#include <linux/of.h>
 16#include <linux/platform_device.h>
 17
 18#include "coresight-priv.h"
 19#include "coresight-tpda.h"
 20#include "coresight-trace-id.h"
 21
 22DEFINE_CORESIGHT_DEVLIST(tpda_devs, "tpda");
 23
 24static bool coresight_device_is_tpdm(struct coresight_device *csdev)
 25{
 26	return (csdev->type == CORESIGHT_DEV_TYPE_SOURCE) &&
 27	       (csdev->subtype.source_subtype ==
 28			CORESIGHT_DEV_SUBTYPE_SOURCE_TPDM);
 29}
 30
 31/*
 32 * Read the DSB element size from the TPDM device
 33 * Returns
 34 *    The dsb element size read from the devicetree if available.
 35 *    0 - Otherwise, with a warning once.
 36 */
 37static int tpdm_read_dsb_element_size(struct coresight_device *csdev)
 38{
 39	int rc = 0;
 40	u8 size = 0;
 41
 42	rc = fwnode_property_read_u8(dev_fwnode(csdev->dev.parent),
 43			"qcom,dsb-element-size", &size);
 44	if (rc)
 45		dev_warn_once(&csdev->dev,
 46			"Failed to read TPDM DSB Element size: %d\n", rc);
 47
 48	return size;
 49}
 50
 51/*
 52 * Search and read element data size from the TPDM node in
 53 * the devicetree. Each input port of TPDA is connected to
 54 * a TPDM. Different TPDM supports different types of dataset,
 55 * and some may support more than one type of dataset.
 56 * Parameter "inport" is used to pass in the input port number
 57 * of TPDA, and it is set to -1 in the recursize call.
 58 */
 59static int tpda_get_element_size(struct coresight_device *csdev,
 60				 int inport)
 61{
 62	int dsb_size = -ENOENT;
 63	int i, size;
 64	struct coresight_device *in;
 65
 66	for (i = 0; i < csdev->pdata->nr_inconns; i++) {
 67		in = csdev->pdata->in_conns[i]->src_dev;
 68		if (!in)
 69			continue;
 70
 71		/* Ignore the paths that do not match port */
 72		if (inport > 0 &&
 73		    csdev->pdata->in_conns[i]->dest_port != inport)
 74			continue;
 75
 76		if (coresight_device_is_tpdm(in)) {
 77			size = tpdm_read_dsb_element_size(in);
 78		} else {
 79			/* Recurse down the path */
 80			size = tpda_get_element_size(in, -1);
 81		}
 82
 83		if (size < 0)
 84			return size;
 85
 86		if (dsb_size < 0) {
 87			/* Found a size, save it. */
 88			dsb_size = size;
 89		} else {
 90			/* Found duplicate TPDMs */
 91			return -EEXIST;
 92		}
 93	}
 94
 95	return dsb_size;
 96}
 97
 98/* Settings pre enabling port control register */
 99static void tpda_enable_pre_port(struct tpda_drvdata *drvdata)
100{
101	u32 val;
102
103	val = readl_relaxed(drvdata->base + TPDA_CR);
104	val &= ~TPDA_CR_ATID;
105	val |= FIELD_PREP(TPDA_CR_ATID, drvdata->atid);
106	writel_relaxed(val, drvdata->base + TPDA_CR);
107}
108
109static int tpda_enable_port(struct tpda_drvdata *drvdata, int port)
110{
111	u32 val;
112	int size;
113
114	val = readl_relaxed(drvdata->base + TPDA_Pn_CR(port));
115	/*
116	 * Configure aggregator port n DSB data set element size
117	 * Set the bit to 0 if the size is 32
118	 * Set the bit to 1 if the size is 64
119	 */
120	size = tpda_get_element_size(drvdata->csdev, port);
121	switch (size) {
122	case 32:
123		val &= ~TPDA_Pn_CR_DSBSIZE;
124		break;
125	case 64:
126		val |= TPDA_Pn_CR_DSBSIZE;
127		break;
128	case 0:
129		return -EEXIST;
130	case -EEXIST:
131		dev_warn_once(&drvdata->csdev->dev,
132			"Detected multiple TPDMs on port %d", -EEXIST);
133		return -EEXIST;
134	default:
135		return -EINVAL;
136	}
137
138	/* Enable the port */
139	val |= TPDA_Pn_CR_ENA;
140	writel_relaxed(val, drvdata->base + TPDA_Pn_CR(port));
141
142	return 0;
143}
144
145static int __tpda_enable(struct tpda_drvdata *drvdata, int port)
146{
147	int ret;
148
149	CS_UNLOCK(drvdata->base);
150
151	if (!drvdata->csdev->enable)
152		tpda_enable_pre_port(drvdata);
153
154	ret = tpda_enable_port(drvdata, port);
155	CS_LOCK(drvdata->base);
156
157	return ret;
158}
159
160static int tpda_enable(struct coresight_device *csdev,
161		       struct coresight_connection *in,
162		       struct coresight_connection *out)
163{
164	struct tpda_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
165	int ret = 0;
166
167	spin_lock(&drvdata->spinlock);
168	if (atomic_read(&in->dest_refcnt) == 0) {
169		ret = __tpda_enable(drvdata, in->dest_port);
170		if (!ret) {
171			atomic_inc(&in->dest_refcnt);
172			dev_dbg(drvdata->dev, "TPDA inport %d enabled.\n", in->dest_port);
173		}
174	}
175
176	spin_unlock(&drvdata->spinlock);
177	return ret;
178}
179
180static void __tpda_disable(struct tpda_drvdata *drvdata, int port)
181{
182	u32 val;
183
184	CS_UNLOCK(drvdata->base);
185
186	val = readl_relaxed(drvdata->base + TPDA_Pn_CR(port));
187	val &= ~TPDA_Pn_CR_ENA;
188	writel_relaxed(val, drvdata->base + TPDA_Pn_CR(port));
189
190	CS_LOCK(drvdata->base);
191}
192
193static void tpda_disable(struct coresight_device *csdev,
194			 struct coresight_connection *in,
195			 struct coresight_connection *out)
196{
197	struct tpda_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
198
199	spin_lock(&drvdata->spinlock);
200	if (atomic_dec_return(&in->dest_refcnt) == 0)
201		__tpda_disable(drvdata, in->dest_port);
202
203	spin_unlock(&drvdata->spinlock);
204
205	dev_dbg(drvdata->dev, "TPDA inport %d disabled\n", in->dest_port);
206}
207
208static const struct coresight_ops_link tpda_link_ops = {
209	.enable		= tpda_enable,
210	.disable	= tpda_disable,
211};
212
213static const struct coresight_ops tpda_cs_ops = {
214	.link_ops	= &tpda_link_ops,
215};
216
217static int tpda_init_default_data(struct tpda_drvdata *drvdata)
218{
219	int atid;
220	/*
221	 * TPDA must has a unique atid. This atid can uniquely
222	 * identify the TPDM trace source connected to the TPDA.
223	 * The TPDMs which are connected to same TPDA share the
224	 * same trace-id. When TPDA does packetization, different
225	 * port will have unique channel number for decoding.
226	 */
227	atid = coresight_trace_id_get_system_id();
228	if (atid < 0)
229		return atid;
230
231	drvdata->atid = atid;
232	return 0;
233}
234
235static int tpda_probe(struct amba_device *adev, const struct amba_id *id)
236{
237	int ret;
238	struct device *dev = &adev->dev;
239	struct coresight_platform_data *pdata;
240	struct tpda_drvdata *drvdata;
241	struct coresight_desc desc = { 0 };
242	void __iomem *base;
243
244	pdata = coresight_get_platform_data(dev);
245	if (IS_ERR(pdata))
246		return PTR_ERR(pdata);
247	adev->dev.platform_data = pdata;
248
249	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
250	if (!drvdata)
251		return -ENOMEM;
252
253	drvdata->dev = &adev->dev;
254	dev_set_drvdata(dev, drvdata);
255
256	base = devm_ioremap_resource(dev, &adev->res);
257	if (IS_ERR(base))
258		return PTR_ERR(base);
259	drvdata->base = base;
260
261	spin_lock_init(&drvdata->spinlock);
262
263	ret = tpda_init_default_data(drvdata);
264	if (ret)
265		return ret;
266
267	desc.name = coresight_alloc_device_name(&tpda_devs, dev);
268	if (!desc.name)
269		return -ENOMEM;
270	desc.type = CORESIGHT_DEV_TYPE_LINK;
271	desc.subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_MERG;
272	desc.ops = &tpda_cs_ops;
273	desc.pdata = adev->dev.platform_data;
274	desc.dev = &adev->dev;
275	desc.access = CSDEV_ACCESS_IOMEM(base);
276	drvdata->csdev = coresight_register(&desc);
277	if (IS_ERR(drvdata->csdev))
278		return PTR_ERR(drvdata->csdev);
279
280	pm_runtime_put(&adev->dev);
281
282	dev_dbg(drvdata->dev, "TPDA initialized\n");
283	return 0;
284}
285
286static void tpda_remove(struct amba_device *adev)
287{
288	struct tpda_drvdata *drvdata = dev_get_drvdata(&adev->dev);
289
290	coresight_trace_id_put_system_id(drvdata->atid);
291	coresight_unregister(drvdata->csdev);
292}
293
294/*
295 * Different TPDA has different periph id.
296 * The difference is 0-7 bits' value. So ignore 0-7 bits.
297 */
298static struct amba_id tpda_ids[] = {
299	{
300		.id     = 0x000f0f00,
301		.mask   = 0x000fff00,
302	},
303	{ 0, 0},
304};
305
306static struct amba_driver tpda_driver = {
307	.drv = {
308		.name   = "coresight-tpda",
309		.owner	= THIS_MODULE,
310		.suppress_bind_attrs = true,
311	},
312	.probe          = tpda_probe,
313	.remove		= tpda_remove,
314	.id_table	= tpda_ids,
315};
316
317module_amba_driver(tpda_driver);
318
319MODULE_LICENSE("GPL");
320MODULE_DESCRIPTION("Trace, Profiling & Diagnostic Aggregator driver");