Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 045b56b0 authored by Satyajit Desai's avatar Satyajit Desai Committed by Gerrit - the friendly Code Review server
Browse files

coresight: Switch all coresight driver to amba bus framework 



Move CTIs, TPDAs, TPDMs and replicator driver to the amba
bus framework. This will help with keeping the behavior
consistent across all configurable coresight devices.

Change-Id: I1f647e1811e5d2cf7cb0bfae5f03b4e187ef8ac2
Signed-off-by: default avatarSatyajit Desai <sadesai@codeaurora.org>
parent c7b2b869

Documentation/devicetree/bindings/arm/coresight.txt

+9 −15
Original line number Diff line number Diff line
@@ -73,9 +73,6 @@ its hardware characteristcs. 
	  AMBA markee):

		- "arm,coresight-replicator"

		- "qcom,coresight-csr"

		- "arm,coresight-cti"

		- "qcom,coresight-tpda"

		- "qcom,coresight-tpdm"

		- "qcom,coresight-remote-etm"

		- "qcom,coresight-hwevent"

		- "qcom,coresight-dummy"
@@ -264,7 +261,7 @@ Example: 
	};



	tpda_mss: tpda@7043000 {

		compatible = "qcom,coresight-tpda";

		compatible = "qcom,coresight-tpda", "arm,primecell";

		reg = <0x7043000 0x1000>;

		reg-names = "tpda-base";
@@ -274,9 +271,8 @@ Example: 
		qcom,dsb-elem-size = <0 32>;

		qcom,cmb-elem-size = <0 32>;



		clocks = <&clock_gcc clk_qdss_clk>,

			 <&clock_gcc clk_qdss_a_clk>;

		clock-names = "core_clk", "core_a_clk";

		clocks = <&clock_aop clk_qdss_clk>;

		clock-names = "apb_pclk";



		ports {

			#address-cells = <1>;
@@ -345,15 +341,14 @@ Example: 
	};



	tpdm_mss: tpdm@7042000 {

		compatible = "qcom,coresight-tpdm";

		compatible = "qcom,coresight-tpdm", "arm,primecell";

		reg = <0x7042000 0x1000>;

		reg-names = "tpdm-base";



		coresight-name = "coresight-tpdm-mss";



		clocks = <&clock_gcc clk_qdss_clk>,

			 <&clock_gcc clk_qdss_a_clk>;

		clock-names = "core_clk", "core_a_clk";

		clocks = <&clock_aop qdss_clk>;

		clock-names = "apb_pclk";



		port{

			tpdm_mss_out_tpda_mss: endpoint {
@@ -364,15 +359,14 @@ Example: 


4. CTIs

	cti0: cti@6010000 {

		compatible = "arm,coresight-cti";

		compatible = "arm,coresight-cti", "arm,primecell";

		reg = <0x6010000 0x1000>;

		reg-names = "cti-base";



		coresight-name = "coresight-cti0";



		clocks = <&clock_gcc clk_qdss_clk>,

			 <&clock_gcc clk_qdss_a_clk>;

		clock-names = "core_clk", "core_a_clk";

		clocks = <&clock_aop qdss_clk>;

		clock-names = "apb_pclk";

	};



[1]. There is currently two version of STM: STM32 and STM500.  Both

drivers/hwtracing/coresight/coresight-cti.c

+39 −73
Original line number Diff line number Diff line 
/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.

/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -19,7 +19,7 @@ 
#include <linux/err.h>

#include <linux/slab.h>

#include <linux/mutex.h>

#include <linux/clk.h>

#include <linux/amba/bus.h>

#include <linux/cpu_pm.h>

#include <linux/topology.h>

#include <linux/of.h>
@@ -379,7 +379,7 @@ int coresight_cti_map_trigin(struct coresight_cti *cti, int trig, int ch) 
	 * within the mutex lock region in addition to within the spinlock.

	 */

	if (drvdata->refcnt == 0) {

		ret = clk_prepare_enable(drvdata->clk);

		ret = pm_runtime_get_sync(drvdata->dev);

		if (ret)

			goto err1;

	}
@@ -402,7 +402,7 @@ int coresight_cti_map_trigin(struct coresight_cti *cti, int trig, int ch) 
	 * adjusting its value.

	 */

	if (drvdata->refcnt == 0)

		clk_disable_unprepare(drvdata->clk);

		pm_runtime_put(drvdata->dev);

err1:

	cti_trigin_gpio_disable(drvdata);

err0:
@@ -463,7 +463,7 @@ int coresight_cti_map_trigout(struct coresight_cti *cti, int trig, int ch) 
	 * within the mutex lock region in addition to within the spinlock.

	 */

	if (drvdata->refcnt == 0) {

		ret = clk_prepare_enable(drvdata->clk);

		ret = pm_runtime_get_sync(drvdata->dev);

		if (ret)

			goto err1;

	}
@@ -485,7 +485,7 @@ int coresight_cti_map_trigout(struct coresight_cti *cti, int trig, int ch) 
	 * __cti_map_trigout so it is safe to check it against 0.

	 */

	if (drvdata->refcnt == 0)

		clk_disable_unprepare(drvdata->clk);

		pm_runtime_put(drvdata->dev);

err1:

	cti_trigout_gpio_disable(drvdata);

err0:
@@ -563,7 +563,7 @@ void coresight_cti_unmap_trigin(struct coresight_cti *cti, int trig, int ch) 
	 * within the mutex lock region in addition to within the spinlock.

	 */

	if (drvdata->refcnt == 0)

		clk_disable_unprepare(drvdata->clk);

		pm_runtime_put(drvdata->dev);



	if (drvdata->gpio_trigin->trig == trig)

		cti_trigin_gpio_disable(drvdata);
@@ -632,7 +632,7 @@ void coresight_cti_unmap_trigout(struct coresight_cti *cti, int trig, int ch) 
	 * within the mutex lock region in addition to within the spinlock.

	 */

	if (drvdata->refcnt == 0)

		clk_disable_unprepare(drvdata->clk);

		pm_runtime_put(drvdata->dev);



	if (drvdata->gpio_trigout->trig == trig)

		cti_trigout_gpio_disable(drvdata);
@@ -1388,34 +1388,29 @@ static struct notifier_block cti_cpu_pm_notifier = { 
	.notifier_call = cti_cpu_pm_callback,

};



static int cti_probe(struct platform_device *pdev)

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

{

	int ret;

	int trig;

	struct device *dev = &pdev->dev;

	struct device *dev = &adev->dev;

	struct coresight_platform_data *pdata;

	struct cti_drvdata *drvdata;

	struct resource *res;

	struct coresight_desc *desc;

	struct device_node *cpu_node;



	pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);

	pdata = of_get_coresight_platform_data(dev, adev->dev.of_node);

	if (IS_ERR(pdata))

		return PTR_ERR(pdata);

	pdev->dev.platform_data = pdata;

	adev->dev.platform_data = pdata;



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

	if (!drvdata)

		return -ENOMEM;

	/* Store the driver data pointer for use in exported functions */

	drvdata->dev = &pdev->dev;

	platform_set_drvdata(pdev, drvdata);

	drvdata->dev = &adev->dev;

	dev_set_drvdata(dev, drvdata);



	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cti-base");

	if (!res)

		return -ENODEV;



	drvdata->base = devm_ioremap(dev, res->start, resource_size(res));

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

	if (!drvdata->base)

		return -ENOMEM;
@@ -1423,21 +1418,13 @@ static int cti_probe(struct platform_device *pdev) 


	mutex_init(&drvdata->mutex);



	drvdata->clk = devm_clk_get(dev, "core_clk");

	if (IS_ERR(drvdata->clk))

		return PTR_ERR(drvdata->clk);



	ret = clk_set_rate(drvdata->clk, CORESIGHT_CLK_RATE_TRACE);

	if (ret)

		return ret;



	drvdata->gpio_trigin = devm_kzalloc(dev, sizeof(struct cti_pctrl),

					    GFP_KERNEL);

	if (!drvdata->gpio_trigin)

		return -ENOMEM;



	drvdata->gpio_trigin->trig = -1;

	ret = of_property_read_u32(pdev->dev.of_node,

	ret = of_property_read_u32(adev->dev.of_node,

				   "qcom,cti-gpio-trigin", &trig);

	if (!ret)

		drvdata->gpio_trigin->trig = trig;
@@ -1450,7 +1437,7 @@ static int cti_probe(struct platform_device *pdev) 
		return -ENOMEM;



	drvdata->gpio_trigout->trig = -1;

	ret = of_property_read_u32(pdev->dev.of_node,

	ret = of_property_read_u32(adev->dev.of_node,

				   "qcom,cti-gpio-trigout", &trig);

	if (!ret)

		drvdata->gpio_trigout->trig = trig;
@@ -1458,7 +1445,7 @@ static int cti_probe(struct platform_device *pdev) 
		return ret;



	drvdata->cpu = -1;

	cpu_node = of_parse_phandle(pdev->dev.of_node, "cpu", 0);

	cpu_node = of_parse_phandle(adev->dev.of_node, "cpu", 0);

	if (cpu_node) {

		drvdata->cpu = pdata ? pdata->cpu : -1;

		if (drvdata->cpu == -1) {
@@ -1468,7 +1455,7 @@ static int cti_probe(struct platform_device *pdev) 
	}



	if (!cti_save_disable)

		drvdata->cti_save = of_property_read_bool(pdev->dev.of_node,

		drvdata->cti_save = of_property_read_bool(adev->dev.of_node,

							  "qcom,cti-save");

	if (drvdata->cti_save) {

		drvdata->state = devm_kzalloc(dev, sizeof(struct cti_state),
@@ -1476,18 +1463,18 @@ static int cti_probe(struct platform_device *pdev) 
		if (!drvdata->state)

			return -ENOMEM;



		drvdata->cti_hwclk = of_property_read_bool(pdev->dev.of_node,

		drvdata->cti_hwclk = of_property_read_bool(adev->dev.of_node,

							   "qcom,cti-hwclk");

	}

	if (drvdata->cti_save && !drvdata->cti_hwclk) {

		ret = clk_prepare_enable(drvdata->clk);

		ret = pm_runtime_get_sync(drvdata->dev);

		if (ret)

			return ret;

	}



	mutex_lock(&cti_lock);

	drvdata->cti.name = ((struct coresight_platform_data *)

			     (pdev->dev.platform_data))->name;

			     (adev->dev.platform_data))->name;

	list_add_tail(&drvdata->cti.link, &cti_list);

	mutex_unlock(&cti_lock);
@@ -1497,8 +1484,8 @@ static int cti_probe(struct platform_device *pdev) 
		goto err;

	}

	desc->type = CORESIGHT_DEV_TYPE_NONE;

	desc->pdata = pdev->dev.platform_data;

	desc->dev = &pdev->dev;

	desc->pdata = adev->dev.platform_data;

	desc->dev = &adev->dev;

	desc->groups = cti_attr_grps;

	drvdata->csdev = coresight_register(desc);

	if (IS_ERR(drvdata->csdev)) {
@@ -1511,56 +1498,35 @@ static int cti_probe(struct platform_device *pdev) 
			cpu_pm_register_notifier(&cti_cpu_pm_notifier);

		registered++;

	}



	pm_runtime_put(&adev->dev);

	dev_dbg(dev, "CTI initialized\n");

	return 0;

err:

	if (drvdata->cti_save && !drvdata->cti_hwclk)

		clk_disable_unprepare(drvdata->clk);

		pm_runtime_put(&adev->dev);

	return ret;

}



static int cti_remove(struct platform_device *pdev)

static struct amba_id cti_ids[] = {

	{

	struct cti_drvdata *drvdata = platform_get_drvdata(pdev);



	if (drvdata->cti_save) {

		registered--;

		if (!registered)

			cpu_pm_unregister_notifier(&cti_cpu_pm_notifier);

	}

	coresight_unregister(drvdata->csdev);

	if (drvdata->cti_save && !drvdata->cti_hwclk)

		clk_disable_unprepare(drvdata->clk);

	return 0;

}



static const struct of_device_id cti_match[] = {

	{.compatible = "arm,coresight-cti"},

	{}

		.id     = 0x0003b966,

		.mask   = 0x0003ffff,

		.data	= "CTI",

	},

	{ 0, 0},

};



static struct platform_driver cti_driver = {

	.probe          = cti_probe,

	.remove         = cti_remove,

	.driver         = {

static struct amba_driver cti_driver = {

	.drv = {

		.name   = "coresight-cti",

		.owner	= THIS_MODULE,

		.of_match_table = cti_match,

		.suppress_bind_attrs = true,

	},

	.probe          = cti_probe,

	.id_table	= cti_ids,

};



static int __init cti_init(void)

{

	return platform_driver_register(&cti_driver);

}

module_init(cti_init);



static void __exit cti_exit(void)

{

	platform_driver_unregister(&cti_driver);

}

module_exit(cti_exit);

builtin_amba_driver(cti_driver);



MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("CoreSight CTI driver");

drivers/hwtracing/coresight/coresight-replicator-qcom.c

+0 −3
Original line number Diff line number Diff line
@@ -47,8 +47,6 @@ static int replicator_enable(struct coresight_device *csdev, int inport, 
{

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



	pm_runtime_get_sync(drvdata->dev);



	CS_UNLOCK(drvdata->base);



	/*
@@ -85,7 +83,6 @@ static void replicator_disable(struct coresight_device *csdev, int inport, 


	CS_LOCK(drvdata->base);



	pm_runtime_put(drvdata->dev);

	dev_info(drvdata->dev, "REPLICATOR disabled\n");

}

drivers/hwtracing/coresight/coresight-tpda.c

+25 −64
Original line number Diff line number Diff line 
/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.

/* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -14,10 +14,10 @@ 
#include <linux/module.h>

#include <linux/device.h>

#include <linux/platform_device.h>

#include <linux/amba/bus.h>

#include <linux/io.h>

#include <linux/err.h>

#include <linux/fs.h>

#include <linux/clk.h>

#include <linux/bitmap.h>

#include <linux/of.h>

#include <linux/coresight.h>
@@ -53,7 +53,6 @@ struct tpda_drvdata { 
	void __iomem		*base;

	struct device		*dev;

	struct coresight_device	*csdev;

	struct clk		*clk;

	struct mutex		lock;

	bool			enable;

	uint32_t		atid;
@@ -183,11 +182,6 @@ static void __tpda_enable(struct tpda_drvdata *drvdata, int port) 
static int tpda_enable(struct coresight_device *csdev, int inport, int outport)

{

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

	int ret;



	ret = clk_prepare_enable(drvdata->clk);

	if (ret)

		return ret;



	mutex_lock(&drvdata->lock);

	__tpda_enable(drvdata, inport);
@@ -221,8 +215,6 @@ static void tpda_disable(struct coresight_device *csdev, int inport, 
	drvdata->enable = false;

	mutex_unlock(&drvdata->lock);



	clk_disable_unprepare(drvdata->clk);



	dev_info(drvdata->dev, "TPDA inport %d disabled\n", inport);

}
@@ -653,31 +645,27 @@ static void tpda_init_default_data(struct tpda_drvdata *drvdata) 
	drvdata->freq_ts = true;

}



static int tpda_probe(struct platform_device *pdev)

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

{

	int ret;

	struct device *dev = &pdev->dev;

	struct device *dev = &adev->dev;

	struct coresight_platform_data *pdata;

	struct tpda_drvdata *drvdata;

	struct resource *res;

	struct coresight_desc *desc;



	pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);

	pdata = of_get_coresight_platform_data(dev, adev->dev.of_node);

	if (IS_ERR(pdata))

		return PTR_ERR(pdata);

	pdev->dev.platform_data = pdata;

	adev->dev.platform_data = pdata;



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

	if (!drvdata)

		return -ENOMEM;

	drvdata->dev = &pdev->dev;

	platform_set_drvdata(pdev, drvdata);



	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tpda-base");

	if (!res)

		return -ENODEV;

	drvdata->dev = &adev->dev;

	dev_set_drvdata(dev, drvdata);



	drvdata->base = devm_ioremap(dev, res->start, resource_size(res));

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

	if (!drvdata->base)

		return -ENOMEM;
@@ -687,22 +675,10 @@ static int tpda_probe(struct platform_device *pdev) 
	if (ret)

		return ret;



	drvdata->clk = devm_clk_get(dev, "core_clk");

	if (IS_ERR(drvdata->clk))

		return PTR_ERR(drvdata->clk);



	ret = clk_set_rate(drvdata->clk, CORESIGHT_CLK_RATE_TRACE);

	if (ret)

		return ret;



	ret = clk_prepare_enable(drvdata->clk);

	if (ret)

		return ret;



	if (!coresight_authstatus_enabled(drvdata->base))

		goto err;



	clk_disable_unprepare(drvdata->clk);

	pm_runtime_put(&adev->dev);



	tpda_init_default_data(drvdata);
@@ -712,8 +688,8 @@ static int tpda_probe(struct platform_device *pdev) 
	desc->type = CORESIGHT_DEV_TYPE_LINK;

	desc->subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_MERG;

	desc->ops = &tpda_cs_ops;

	desc->pdata = pdev->dev.platform_data;

	desc->dev = &pdev->dev;

	desc->pdata = adev->dev.platform_data;

	desc->dev = &adev->dev;

	desc->groups = tpda_attr_grps;

	drvdata->csdev = coresight_register(desc);

	if (IS_ERR(drvdata->csdev))
@@ -722,44 +698,29 @@ static int tpda_probe(struct platform_device *pdev) 
	dev_dbg(drvdata->dev, "TPDA initialized\n");

	return 0;

err:

	clk_disable_unprepare(drvdata->clk);

	return -EPERM;

}



static int tpda_remove(struct platform_device *pdev)

static struct amba_id tpda_ids[] = {

	{

	struct tpda_drvdata *drvdata = platform_get_drvdata(pdev);



	coresight_unregister(drvdata->csdev);

	return 0;

}



static const struct of_device_id tpda_match[] = {

	{.compatible = "qcom,coresight-tpda"},

	{}

		.id     = 0x0003b969,

		.mask   = 0x0003ffff,

		.data	= "TPDA",

	},

	{ 0, 0},

};



static struct platform_driver tpda_driver = {

	.probe          = tpda_probe,

	.remove         = tpda_remove,

	.driver         = {

static struct amba_driver tpda_driver = {

	.drv = {

		.name   = "coresight-tpda",

		.owner	= THIS_MODULE,

		.of_match_table = tpda_match,

		.suppress_bind_attrs = true,

	},

	.probe          = tpda_probe,

	.id_table	= tpda_ids,

};



static int __init tpda_init(void)

{

	return platform_driver_register(&tpda_driver);

}

module_init(tpda_init);



static void __exit tpda_exit(void)

{

	platform_driver_unregister(&tpda_driver);

}

module_exit(tpda_exit);

builtin_amba_driver(tpda_driver);



MODULE_LICENSE("GPL v2");

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

drivers/hwtracing/coresight/coresight-tpdm.c

+26 −66
Original line number Diff line number Diff line
@@ -13,11 +13,10 @@ 
#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/device.h>

#include <linux/platform_device.h>

#include <linux/amba/bus.h>

#include <linux/io.h>

#include <linux/err.h>

#include <linux/fs.h>

#include <linux/clk.h>

#include <linux/bitmap.h>

#include <linux/of.h>

#include <linux/coresight.h>
@@ -246,7 +245,6 @@ struct tpdm_drvdata { 
	void __iomem		*base;

	struct device		*dev;

	struct coresight_device	*csdev;

	struct clk		*clk;

	struct mutex		lock;

	bool			enable;

	bool			clk_enable;
@@ -648,11 +646,6 @@ static int tpdm_enable(struct coresight_device *csdev, 
		       struct perf_event *event, u32 mode)

{

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

	int ret;



	ret = clk_prepare_enable(drvdata->clk);

	if (ret)

		return ret;



	mutex_lock(&drvdata->lock);

	__tpdm_enable(drvdata);
@@ -732,8 +725,6 @@ static void tpdm_disable(struct coresight_device *csdev, 
	drvdata->enable = false;

	mutex_unlock(&drvdata->lock);



	clk_disable_unprepare(drvdata->clk);



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

}
@@ -3939,57 +3930,40 @@ static void tpdm_init_default_data(struct tpdm_drvdata *drvdata) 
		drvdata->cmb->trig_ts = true;

}



static int tpdm_probe(struct platform_device *pdev)

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

{

	int ret, i;

	uint32_t pidr, devid;

	struct device *dev = &pdev->dev;

	struct device *dev = &adev->dev;

	struct coresight_platform_data *pdata;

	struct tpdm_drvdata *drvdata;

	struct resource *res;

	struct coresight_desc *desc;

	static int traceid = TPDM_TRACE_ID_START;

	uint32_t version;



	pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);

	pdata = of_get_coresight_platform_data(dev, adev->dev.of_node);

	if (IS_ERR(pdata))

		return PTR_ERR(pdata);

	pdev->dev.platform_data = pdata;

	adev->dev.platform_data = pdata;



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

	if (!drvdata)

		return -ENOMEM;

	drvdata->dev = &pdev->dev;

	platform_set_drvdata(pdev, drvdata);



	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tpdm-base");

	if (!res)

		return -ENODEV;

	drvdata->dev = &adev->dev;

	dev_set_drvdata(dev, drvdata);



	drvdata->base = devm_ioremap(dev, res->start, resource_size(res));

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

	if (!drvdata->base)

		return -ENOMEM;



	drvdata->clk_enable = of_property_read_bool(pdev->dev.of_node,

	drvdata->clk_enable = of_property_read_bool(adev->dev.of_node,

						    "qcom,clk-enable");



	drvdata->msr_fix_req = of_property_read_bool(pdev->dev.of_node,

	drvdata->msr_fix_req = of_property_read_bool(adev->dev.of_node,

						     "qcom,msr-fix-req");



	mutex_init(&drvdata->lock);



	drvdata->clk = devm_clk_get(dev, "core_clk");

	if (IS_ERR(drvdata->clk))

		return PTR_ERR(drvdata->clk);



	ret = clk_set_rate(drvdata->clk, CORESIGHT_CLK_RATE_TRACE);

	if (ret)

		return ret;



	ret = clk_prepare_enable(drvdata->clk);

	if (ret)

		return ret;



	version = tpdm_readl(drvdata, CORESIGHT_PERIPHIDR2);

	drvdata->version = BMVAL(version, 4, 7);
@@ -4017,7 +3991,7 @@ static int tpdm_probe(struct platform_device *pdev) 
	drvdata->bc_counters_avail = BMVAL(devid, 6, 10) + 1;

	drvdata->tc_counters_avail = BMVAL(devid, 4, 5) + 1;



	clk_disable_unprepare(drvdata->clk);

	pm_runtime_put(&adev->dev);



	drvdata->traceid = traceid++;
@@ -4027,8 +4001,8 @@ static int tpdm_probe(struct platform_device *pdev) 
	desc->type = CORESIGHT_DEV_TYPE_SOURCE;

	desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_PROC;

	desc->ops = &tpdm_cs_ops;

	desc->pdata = pdev->dev.platform_data;

	desc->dev = &pdev->dev;

	desc->pdata = adev->dev.platform_data;

	desc->dev = &adev->dev;

	desc->groups = tpdm_attr_grps;

	drvdata->csdev = coresight_register(desc);

	if (IS_ERR(drvdata->csdev))
@@ -4042,40 +4016,26 @@ static int tpdm_probe(struct platform_device *pdev) 
	return 0;

}



static int tpdm_remove(struct platform_device *pdev)

static struct amba_id tpdm_ids[] = {

	{

	struct tpdm_drvdata *drvdata = platform_get_drvdata(pdev);



	coresight_unregister(drvdata->csdev);

	return 0;

}



static const struct of_device_id tpdm_match[] = {

	{.compatible = "qcom,coresight-tpdm"},

	{}

		.id     = 0x0003b968,

		.mask   = 0x0003ffff,

		.data	= "TPDM",

	},

	{ 0, 0},

};



static struct platform_driver tpdm_driver = {

	.probe          = tpdm_probe,

	.remove         = tpdm_remove,

	.driver         = {

static struct amba_driver tpdm_driver = {

	.drv = {

		.name   = "coresight-tpdm",

		.owner	= THIS_MODULE,

		.of_match_table = tpdm_match,

		.suppress_bind_attrs = true,

	},

	.probe          = tpdm_probe,

	.id_table	= tpdm_ids,

};



static int __init tpdm_init(void)

{

	return platform_driver_register(&tpdm_driver);

}

module_init(tpdm_init);



static void __exit tpdm_exit(void)

{

	platform_driver_unregister(&tpdm_driver);

}

module_exit(tpdm_exit);

builtin_amba_driver(tpdm_driver);



MODULE_LICENSE("GPL v2");

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