coresight: support etm tracing on remote processors

Currently the remote processors do not have access to CoreSight debug
and trace framework. Add support for configuring the required CoreSight
components to enable ETM tracing on these processors.

Change-Id: I1a2aa6567f26124124cf1c570575836e62519052
Signed-off-by: Aparna Das <adas@codeaurora.org>
This commit is contained in:
Aparna Das
2013-10-16 23:38:53 -07:00
committed by Pratik Patel
parent 0726cbe7e6
commit b84b311ffd
7 changed files with 582 additions and 4 deletions
@@ -22,10 +22,24 @@ Required properties:
"arm,coresight-cti" for coresight cti devices,
"qcom,coresight-hwevent" for coresight hardware event devices
"arm,coresight-fuse" for coresight fuse device,
- reg : physical base address and length of the register set(s) of the component
- reg-names : names corresponding to each reg property value. The reg-names that
need to be used with corresponding compatible string for a coresight device
are:
"qcom,coresight-audio-etm" for coresight audio etm trace device,
"qcom,coresight-modem-etm" for coresight modem etm trace device,
"qcom,coresight-wcn-etm" for coresight wireless etm trace device,
"qcom,coresight-rpm-etm" for coresight rpm etm trace device
- reg : physical base address and length of the register set(s) of the component.
Not required for the following compatible strings:
- "qcom,coresight-audio-etm",
- "qcom,coresight-modem-etm",
- "qcom,coresight-wcn-etm",
- "qcom,coresight-rpm-etm"
- reg-names : names corresponding to each reg property value.
Not required for the following compatible strings:
- "qcom,coresight-audio-etm",
- "qcom,coresight-modem-etm",
- "qcom,coresight-wcn-etm",
- "qcom,coresight-rpm-etm"
The reg-names that need to be used with corresponding compatible string
for a coresight device are:
- for coresight tmc-etr or tmc-etf device:
compatible : should be "arm,coresight-tmc"
reg-names : should be:
+32
View File
@@ -151,6 +151,38 @@ config CORESIGHT_ETM_PCSAVE_DEFAULT_ENABLE
If unsure, say 'N' here to avoid potential power penalty.
config CORESIGHT_AUDIO_ETM
bool "Audio processor ETM trace support"
help
Enables support for ETM trace collection on audio processor using
CoreSight framework. Enabling this will allow turning on ETM tracing
on audio processor via sysfs by configuring the required CoreSight
components.
config CORESIGHT_MODEM_ETM
bool "Modem processor ETM trace support"
help
Enables support for ETM trace collection on modem processor using
CoreSight framework. Enabling this will allow turning on ETM tracing
on modem processor via sysfs by configuring the required CoreSight
components.
config CORESIGHT_WCN_ETM
bool "Wireless subsystem processor ETM trace support"
help
Enables support for ETM trace collection on wireless subsystem
processor using CoreSight framework. Enabling this will allow
turning on ETM tracing on wireless subsystem via sysfs by configuring
the required CoreSight components.
config CORESIGHT_RPM_ETM
bool "RPM processor ETM trace support"
help
Enables support for ETM trace collection on RPM processor using
CoreSight framework. Enabling this will allow turning on ETM
tracing on RPM processor via sysfs by configuring the required
CoreSight components.
endif
config CORESIGHT_EVENT
+4
View File
@@ -13,4 +13,8 @@ obj-$(CONFIG_CORESIGHT_REPLICATOR) += coresight-replicator.o
obj-$(CONFIG_CORESIGHT_STM) += coresight-stm.o
obj-$(CONFIG_CORESIGHT_HWEVENT) += coresight-hwevent.o
obj-$(CONFIG_CORESIGHT_ETM) += coresight-etm.o coresight-etm-cp14.o
obj-$(CONFIG_CORESIGHT_AUDIO_ETM) += coresight-audio-etm.o
obj-$(CONFIG_CORESIGHT_MODEM_ETM) += coresight-modem-etm.o
obj-$(CONFIG_CORESIGHT_WCN_ETM) += coresight-wcn-etm.o
obj-$(CONFIG_CORESIGHT_RPM_ETM) += coresight-rpm-etm.o
obj-$(CONFIG_CORESIGHT_EVENT) += coresight-event.o
+132
View File
@@ -0,0 +1,132 @@
/* Copyright (c) 2013, 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
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/err.h>
#include <linux/sysfs.h>
#include <linux/of_coresight.h>
#include <linux/coresight.h>
struct audio_etm_drvdata {
struct device *dev;
struct coresight_device *csdev;
};
static int audio_etm_enable(struct coresight_device *csdev)
{
struct audio_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "Audio ETM tracing enabled\n");
return 0;
}
static void audio_etm_disable(struct coresight_device *csdev)
{
struct audio_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "Audio ETM tracing disabled\n");
}
static const struct coresight_ops_source audio_etm_source_ops = {
.enable = audio_etm_enable,
.disable = audio_etm_disable,
};
static const struct coresight_ops audio_cs_ops = {
.source_ops = &audio_etm_source_ops,
};
static int audio_etm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata;
struct audio_etm_drvdata *drvdata;
struct coresight_desc *desc;
if (pdev->dev.of_node) {
pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
pdev->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);
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
desc->type = CORESIGHT_DEV_TYPE_SOURCE;
desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_PROC;
desc->ops = &audio_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev))
return PTR_ERR(drvdata->csdev);
dev_info(dev, "Audio ETM initialized\n");
return 0;
}
static int audio_etm_remove(struct platform_device *pdev)
{
struct audio_etm_drvdata *drvdata = platform_get_drvdata(pdev);
coresight_unregister(drvdata->csdev);
return 0;
}
static struct of_device_id audio_etm_match[] = {
{.compatible = "qcom,coresight-audio-etm"},
{}
};
static struct platform_driver audio_etm_driver = {
.probe = audio_etm_probe,
.remove = audio_etm_remove,
.driver = {
.name = "coresight-audio-etm",
.owner = THIS_MODULE,
.of_match_table = audio_etm_match,
},
};
int __init audio_etm_init(void)
{
return platform_driver_register(&audio_etm_driver);
}
module_init(audio_etm_init);
void __exit audio_etm_exit(void)
{
platform_driver_unregister(&audio_etm_driver);
}
module_exit(audio_etm_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("CoreSight Audio ETM driver");
+132
View File
@@ -0,0 +1,132 @@
/* Copyright (c) 2013, 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
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/err.h>
#include <linux/sysfs.h>
#include <linux/of_coresight.h>
#include <linux/coresight.h>
struct modem_etm_drvdata {
struct device *dev;
struct coresight_device *csdev;
};
static int modem_etm_enable(struct coresight_device *csdev)
{
struct modem_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "Modem ETM tracing enabled\n");
return 0;
}
static void modem_etm_disable(struct coresight_device *csdev)
{
struct modem_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "Modem ETM tracing disabled\n");
}
static const struct coresight_ops_source modem_etm_source_ops = {
.enable = modem_etm_enable,
.disable = modem_etm_disable,
};
static const struct coresight_ops modem_cs_ops = {
.source_ops = &modem_etm_source_ops,
};
static int modem_etm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata;
struct modem_etm_drvdata *drvdata;
struct coresight_desc *desc;
if (pdev->dev.of_node) {
pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
pdev->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);
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
desc->type = CORESIGHT_DEV_TYPE_SOURCE;
desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_PROC;
desc->ops = &modem_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev))
return PTR_ERR(drvdata->csdev);
dev_info(dev, "Modem ETM initialized\n");
return 0;
}
static int modem_etm_remove(struct platform_device *pdev)
{
struct modem_etm_drvdata *drvdata = platform_get_drvdata(pdev);
coresight_unregister(drvdata->csdev);
return 0;
}
static struct of_device_id modem_etm_match[] = {
{.compatible = "qcom,coresight-modem-etm"},
{}
};
static struct platform_driver modem_etm_driver = {
.probe = modem_etm_probe,
.remove = modem_etm_remove,
.driver = {
.name = "coresight-modem-etm",
.owner = THIS_MODULE,
.of_match_table = modem_etm_match,
},
};
int __init modem_etm_init(void)
{
return platform_driver_register(&modem_etm_driver);
}
module_init(modem_etm_init);
void __exit modem_etm_exit(void)
{
platform_driver_unregister(&modem_etm_driver);
}
module_exit(modem_etm_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("CoreSight Modem ETM driver");
+132
View File
@@ -0,0 +1,132 @@
/* Copyright (c) 2013, 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
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/err.h>
#include <linux/sysfs.h>
#include <linux/of_coresight.h>
#include <linux/coresight.h>
struct rpm_etm_drvdata {
struct device *dev;
struct coresight_device *csdev;
};
static int rpm_etm_enable(struct coresight_device *csdev)
{
struct rpm_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "RPM ETM tracing enabled\n");
return 0;
}
static void rpm_etm_disable(struct coresight_device *csdev)
{
struct rpm_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "RPM ETM tracing disabled\n");
}
static const struct coresight_ops_source rpm_etm_source_ops = {
.enable = rpm_etm_enable,
.disable = rpm_etm_disable,
};
static const struct coresight_ops rpm_cs_ops = {
.source_ops = &rpm_etm_source_ops,
};
static int rpm_etm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata;
struct rpm_etm_drvdata *drvdata;
struct coresight_desc *desc;
if (pdev->dev.of_node) {
pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
pdev->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);
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
desc->type = CORESIGHT_DEV_TYPE_SOURCE;
desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_PROC;
desc->ops = &rpm_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev))
return PTR_ERR(drvdata->csdev);
dev_info(dev, "RPM ETM initialized\n");
return 0;
}
static int rpm_etm_remove(struct platform_device *pdev)
{
struct rpm_etm_drvdata *drvdata = platform_get_drvdata(pdev);
coresight_unregister(drvdata->csdev);
return 0;
}
static struct of_device_id rpm_etm_match[] = {
{.compatible = "qcom,coresight-rpm-etm"},
{}
};
static struct platform_driver rpm_etm_driver = {
.probe = rpm_etm_probe,
.remove = rpm_etm_remove,
.driver = {
.name = "coresight-rpm-etm",
.owner = THIS_MODULE,
.of_match_table = rpm_etm_match,
},
};
int __init rpm_etm_init(void)
{
return platform_driver_register(&rpm_etm_driver);
}
module_init(rpm_etm_init);
void __exit rpm_etm_exit(void)
{
platform_driver_unregister(&rpm_etm_driver);
}
module_exit(rpm_etm_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("CoreSight RPM ETM driver");
+132
View File
@@ -0,0 +1,132 @@
/* Copyright (c) 2013, 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
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/err.h>
#include <linux/sysfs.h>
#include <linux/of_coresight.h>
#include <linux/coresight.h>
struct wcn_etm_drvdata {
struct device *dev;
struct coresight_device *csdev;
};
static int wcn_etm_enable(struct coresight_device *csdev)
{
struct wcn_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "Wireless ETM tracing enabled\n");
return 0;
}
static void wcn_etm_disable(struct coresight_device *csdev)
{
struct wcn_etm_drvdata *drvdata =
dev_get_drvdata(csdev->dev.parent);
dev_info(drvdata->dev, "Wireless ETM tracing disabled\n");
}
static const struct coresight_ops_source wcn_etm_source_ops = {
.enable = wcn_etm_enable,
.disable = wcn_etm_disable,
};
static const struct coresight_ops wcn_cs_ops = {
.source_ops = &wcn_etm_source_ops,
};
static int wcn_etm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata;
struct wcn_etm_drvdata *drvdata;
struct coresight_desc *desc;
if (pdev->dev.of_node) {
pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
pdev->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);
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
desc->type = CORESIGHT_DEV_TYPE_SOURCE;
desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_PROC;
desc->ops = &wcn_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev))
return PTR_ERR(drvdata->csdev);
dev_info(dev, "Wireless ETM initialized\n");
return 0;
}
static int wcn_etm_remove(struct platform_device *pdev)
{
struct wcn_etm_drvdata *drvdata = platform_get_drvdata(pdev);
coresight_unregister(drvdata->csdev);
return 0;
}
static struct of_device_id wcn_etm_match[] = {
{.compatible = "qcom,coresight-wcn-etm"},
{}
};
static struct platform_driver wcn_etm_driver = {
.probe = wcn_etm_probe,
.remove = wcn_etm_remove,
.driver = {
.name = "coresight-wcn-etm",
.owner = THIS_MODULE,
.of_match_table = wcn_etm_match,
},
};
int __init wcn_etm_init(void)
{
return platform_driver_register(&wcn_etm_driver);
}
module_init(wcn_etm_init);
void __exit wcn_etm_exit(void)
{
platform_driver_unregister(&wcn_etm_driver);
}
module_exit(wcn_etm_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("CoreSight Wireless ETM driver");