Commit b3c71626 authored by Mao Jinlong's avatar Mao Jinlong Committed by Suzuki K Poulose
Browse files

Coresight: Add coresight TPDM source driver 



Add driver to support Coresight device TPDM (Trace, Profiling and
Diagnostics Monitor). TPDM is a monitor to collect data from
different datasets. This change is to add probe/enable/disable
functions for tpdm source.

Signed-off-by: default avatarTao Zhang <quic_taozha@quicinc.com>
Signed-off-by: default avatarMao Jinlong <quic_jinlmao@quicinc.com>
Signed-off-by: default avatarSuzuki K Poulose <suzuki.poulose@arm.com>
Link: https://lore.kernel.org/r/20230120095301.30792-1-quic_jinlmao@quicinc.com
parent 5c0016d7

drivers/hwtracing/coresight/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -213,4 +213,16 @@ config ULTRASOC_SMB 


	  To compile this driver as a module, choose M here: the module will be

	  called ultrasoc-smb.



config CORESIGHT_TPDM

	tristate "CoreSight Trace, Profiling & Diagnostics Monitor driver"

	select CORESIGHT_LINKS_AND_SINKS

	help

	  This driver provides support for configuring monitor. Monitors are

	  primarily responsible for data set collection and support the

	  ability to collect any permutation of data set types.



	  To compile this driver as a module, choose M here: the module will be

	  called coresight-tpdm.



endif

drivers/hwtracing/coresight/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ obj-$(CONFIG_CORESIGHT_CPU_DEBUG) += coresight-cpu-debug.o 
obj-$(CONFIG_CORESIGHT_CATU) += coresight-catu.o

obj-$(CONFIG_CORESIGHT_CTI) += coresight-cti.o

obj-$(CONFIG_CORESIGHT_TRBE) += coresight-trbe.o

obj-$(CONFIG_CORESIGHT_TPDM) += coresight-tpdm.o

coresight-cti-y := coresight-cti-core.o	coresight-cti-platform.o \

		   coresight-cti-sysfs.o

obj-$(CONFIG_ULTRASOC_SMB) += ultrasoc-smb.o

drivers/hwtracing/coresight/coresight-core.c

+4 −1
Original line number Diff line number Diff line
@@ -1061,7 +1061,8 @@ static int coresight_validate_source(struct coresight_device *csdev, 
	}



	if (subtype != CORESIGHT_DEV_SUBTYPE_SOURCE_PROC &&

	    subtype != CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE) {

	    subtype != CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE &&

	    subtype != CORESIGHT_DEV_SUBTYPE_SOURCE_OTHERS) {

		dev_err(&csdev->dev, "wrong device subtype in %s\n", function);

		return -EINVAL;

	}
@@ -1130,6 +1131,7 @@ int coresight_enable(struct coresight_device *csdev) 
		per_cpu(tracer_path, cpu) = path;

		break;

	case CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE:

	case CORESIGHT_DEV_SUBTYPE_SOURCE_OTHERS:

		/*

		 * Use the hash of source's device name as ID

		 * and map the ID to the pointer of the path.
@@ -1179,6 +1181,7 @@ void coresight_disable(struct coresight_device *csdev) 
		per_cpu(tracer_path, cpu) = NULL;

		break;

	case CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE:

	case CORESIGHT_DEV_SUBTYPE_SOURCE_OTHERS:

		hash = hashlen_hash(hashlen_string(NULL, dev_name(&csdev->dev)));

		/* Find the path by the hash. */

		path = idr_find(&path_idr, hash);

drivers/hwtracing/coresight/coresight-tpdm.c

0 → 100644
+149 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.

 */



#include <linux/amba/bus.h>

#include <linux/bitmap.h>

#include <linux/coresight.h>

#include <linux/coresight-pmu.h>

#include <linux/device.h>

#include <linux/err.h>

#include <linux/fs.h>

#include <linux/io.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/of.h>



#include "coresight-priv.h"

#include "coresight-tpdm.h"



DEFINE_CORESIGHT_DEVLIST(tpdm_devs, "tpdm");



/* TPDM enable operations */

static int tpdm_enable(struct coresight_device *csdev,

		       struct perf_event *event, u32 mode)

{

	struct tpdm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);



	spin_lock(&drvdata->spinlock);

	if (drvdata->enable) {

		spin_unlock(&drvdata->spinlock);

		return -EBUSY;

	}



	drvdata->enable = true;

	spin_unlock(&drvdata->spinlock);



	dev_dbg(drvdata->dev, "TPDM tracing enabled\n");

	return 0;

}



/* TPDM disable operations */

static void tpdm_disable(struct coresight_device *csdev,

			 struct perf_event *event)

{

	struct tpdm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);



	spin_lock(&drvdata->spinlock);

	if (!drvdata->enable) {

		spin_unlock(&drvdata->spinlock);

		return;

	}



	drvdata->enable = false;

	spin_unlock(&drvdata->spinlock);



	dev_dbg(drvdata->dev, "TPDM tracing disabled\n");

}



static const struct coresight_ops_source tpdm_source_ops = {

	.enable		= tpdm_enable,

	.disable	= tpdm_disable,

};



static const struct coresight_ops tpdm_cs_ops = {

	.source_ops	= &tpdm_source_ops,

};



static int tpdm_probe(struct amba_device *adev, const struct amba_id *id)

{

	void __iomem *base;

	struct device *dev = &adev->dev;

	struct coresight_platform_data *pdata;

	struct tpdm_drvdata *drvdata;

	struct coresight_desc desc = { 0 };



	pdata = coresight_get_platform_data(dev);

	if (IS_ERR(pdata))

		return PTR_ERR(pdata);

	adev->dev.platform_data = pdata;



	/* driver data*/

	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);

	if (!drvdata)

		return -ENOMEM;

	drvdata->dev = &adev->dev;

	dev_set_drvdata(dev, drvdata);



	base = devm_ioremap_resource(dev, &adev->res);

	if (IS_ERR(base))

		return PTR_ERR(base);



	drvdata->base = base;



	/* Set up coresight component description */

	desc.name = coresight_alloc_device_name(&tpdm_devs, dev);

	if (!desc.name)

		return -ENOMEM;

	desc.type = CORESIGHT_DEV_TYPE_SOURCE;

	desc.subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_OTHERS;

	desc.ops = &tpdm_cs_ops;

	desc.pdata = adev->dev.platform_data;

	desc.dev = &adev->dev;

	desc.access = CSDEV_ACCESS_IOMEM(base);

	drvdata->csdev = coresight_register(&desc);

	if (IS_ERR(drvdata->csdev))

		return PTR_ERR(drvdata->csdev);



	spin_lock_init(&drvdata->spinlock);

	/* Decrease pm refcount when probe is done.*/

	pm_runtime_put(&adev->dev);



	return 0;

}



static void __exit tpdm_remove(struct amba_device *adev)

{

	struct tpdm_drvdata *drvdata = dev_get_drvdata(&adev->dev);



	coresight_unregister(drvdata->csdev);

}



/*

 * Different TPDM has different periph id.

 * The difference is 0-7 bits' value. So ignore 0-7 bits.

 */

static struct amba_id tpdm_ids[] = {

	{

		.id = 0x000f0e00,

		.mask = 0x000fff00,

	},

	{ 0, 0},

};



static struct amba_driver tpdm_driver = {

	.drv = {

		.name   = "coresight-tpdm",

		.owner	= THIS_MODULE,

		.suppress_bind_attrs = true,

	},

	.probe          = tpdm_probe,

	.id_table	= tpdm_ids,

	.remove		= tpdm_remove,

};



module_amba_driver(tpdm_driver);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Trace, Profiling & Diagnostic Monitor driver");

drivers/hwtracing/coresight/coresight-tpdm.h

0 → 100644
+26 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.

 */



#ifndef _CORESIGHT_CORESIGHT_TPDM_H

#define _CORESIGHT_CORESIGHT_TPDM_H



/**

 * struct tpdm_drvdata - specifics associated to an TPDM component

 * @base:       memory mapped base address for this component.

 * @dev:        The device entity associated to this component.

 * @csdev:      component vitals needed by the framework.

 * @spinlock:   lock for the drvdata value.

 * @enable:     enable status of the component.

 */



struct tpdm_drvdata {

	void __iomem		*base;

	struct device		*dev;

	struct coresight_device	*csdev;

	spinlock_t		spinlock;

	bool			enable;

};



#endif  /* _CORESIGHT_CORESIGHT_TPDM_H */