static void stm_generic_unlink(struct stm_data *stm_data,
unsigned int master, unsigned int channel)
{
struct stm_drvdata *drvdata = container_of(stm_data,
struct stm_drvdata, stm);
if (!drvdata || !drvdata->csdev)
return;
coresight_disable(drvdata->csdev);
}
void top_tmc_disable(char *pdir)
{
if (MAX_ETB_FILE_LEN < strlen(pdir) + 1) {
pr_err("ETB: file length is wrong(%d).\n", strlen(pdir));
return;
}
etb_file_path = kmalloc(MAX_ETB_FILE_LEN, GFP_KERNEL);
if (etb_file_path == NULL) {
pr_err("etb:kmalloc mem failed\n");
return;
}
strncpy(etb_file_path, pdir, strlen(pdir) + 1);
coresight_disable(virt_stmdrvdata->csdev);
kfree(etb_file_path);
etb_file_path = NULL;
}
static int stm_virt_probe(struct platform_device *pdev)
{
int ret = 0;
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata = NULL;
struct stm_drvdata *drvdata = NULL;
struct coresight_desc *desc = NULL;
if (pdev->dev.of_node) {
pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);
if (IS_ERR(pdata)) {
dev_err(&pdev->dev, "of_get_coresight_platform_data error!\n");
return PTR_ERR(pdata);
}
pdev->dev.platform_data = pdata;
}
if (!pdata) {
dev_err(&pdev->dev, "coresight pdata is NULL\n");
return -ENODEV;
}
drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
if (!drvdata) {
dev_err(&pdev->dev, "coresight kzalloc error!\n");
return -ENOMEM;
}
/* Store the driver data pointer for use in exported functions */
virt_stmdrvdata = drvdata;
drvdata->dev = &pdev->dev;
platform_set_drvdata(pdev, drvdata);
spin_lock_init(&drvdata->spinlock);
drvdata->entity = OST_ENTITY_ALL;
drvdata->status = false;
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc) {
dev_err(drvdata->dev, "coresight desc kzalloc error!\n");
return -ENOMEM;
}
desc->type = CORESIGHT_DEV_TYPE_SOURCE;
desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE;
desc->ops = &stm_virt_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->groups = stm_virt_attr_grps;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev)) {
dev_err(drvdata->dev, "coresight_register error!\n");
return PTR_ERR(drvdata->csdev);
}
drvdata->miscdev.name = ((struct coresight_platform_data *)
(pdev->dev.platform_data))->name;
drvdata->miscdev.minor = MISC_DYNAMIC_MINOR;
drvdata->miscdev.fops = &stm_virt_fops;
ret = misc_register(&drvdata->miscdev);
if (ret) {
dev_err(drvdata->dev, "coresight misc_register error!\n");
goto err;
}
dev_info(drvdata->dev, "STM virt initialized\n");
#if 0
/*
* Enable and disable STM to undo the temporary default STM enable
* done by RPM.
*/
coresight_enable(drvdata->csdev);
coresight_disable(drvdata->csdev);
#endif
boot_enable = 0;
if (boot_enable)
coresight_enable(drvdata->csdev);
return 0;
err:
coresight_unregister(drvdata->csdev);
return ret;
}
static int stm_probe(struct platform_device *pdev)
{
int ret = 0;
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata = NULL;
struct stm_drvdata *drvdata = NULL;
struct resource *res = NULL;
size_t res_size, bitmap_size;
struct coresight_desc *desc = NULL;
if (pdev->dev.of_node) {
pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node);
if (IS_ERR(pdata)) {
dev_err(drvdata->dev, "of_get_coresight_platform_data error!\n");
return PTR_ERR(pdata);
}
pdev->dev.platform_data = pdata;
}
drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
if (!drvdata) {
dev_err(drvdata->dev, "coresight kzalloc error!\n");
return -ENOMEM;
}
/* Store the driver data pointer for use in exported functions */
stmdrvdata = drvdata;
drvdata->dev = &pdev->dev;
platform_set_drvdata(pdev, drvdata);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(drvdata->dev, "coresight get resource error!\n");
return -ENODEV;
}
drvdata->base = devm_ioremap(dev, res->start, resource_size(res));
if (!drvdata->base) {
dev_err(drvdata->dev, "coresight ioremap error!\n");
return -ENOMEM;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
if (!res) {
dev_err(drvdata->dev, "coresight get resource error!\n");
return -ENODEV;
}
if (boot_nr_channel) {
res_size = min((resource_size_t)(boot_nr_channel *
BYTES_PER_CHANNEL), resource_size(res));
bitmap_size = boot_nr_channel * sizeof(long);
} else {
res_size = min((resource_size_t)(NR_STM_CHANNEL *
BYTES_PER_CHANNEL), resource_size(res));
bitmap_size = NR_STM_CHANNEL * sizeof(long);
}
drvdata->chs.base = devm_ioremap(dev, res->start, res_size);
if (!drvdata->chs.base) {
dev_err(drvdata->dev, "coresight chds ioremap error!\n");
return -ENOMEM;
}
drvdata->chs.bitmap = devm_kzalloc(dev, bitmap_size, GFP_KERNEL);
if (!drvdata->chs.bitmap) {
dev_err(drvdata->dev, "coresight chs bitmap kzalloc error!\n");
return -ENOMEM;
}
spin_lock_init(&drvdata->spinlock);
drvdata->clk_at= devm_clk_get(dev, pdata->clock_at);
if (IS_ERR(drvdata->clk_at)) {
dev_err(drvdata->dev, "coresight get clock error!\n");
ret = PTR_ERR(drvdata->clk_at);
goto err;
}
ret = clk_set_rate(drvdata->clk_at, 240000000);
if (ret) {
dev_err(drvdata->dev, "coresight set clock rate error!\n");
goto err;
}
drvdata->clk_dbg= devm_clk_get(dev, pdata->clock_dbg);
if (IS_ERR(drvdata->clk_dbg)) {
dev_err(drvdata->dev, "coresight get clock error!\n");
ret = PTR_ERR(drvdata->clk_dbg);
goto err;
}
ret = clk_set_rate(drvdata->clk_dbg, 120000000);
if (ret) {
dev_err(drvdata->dev, "coresight set clock rate error!\n");
goto err;
}
drvdata->entity = OST_ENTITY_ALL;
drvdata->status = false;
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc) {
dev_err(drvdata->dev, "coresight desc kzalloc error!\n");
return -ENOMEM;
}
desc->type = CORESIGHT_DEV_TYPE_SOURCE;
desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE;
desc->ops = &stm_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->groups = stm_attr_grps;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev)) {
dev_err(drvdata->dev, "coresight_register error!\n");
return PTR_ERR(drvdata->csdev);
}
drvdata->miscdev.name = ((struct coresight_platform_data *)
(pdev->dev.platform_data))->name;
drvdata->miscdev.minor = MISC_DYNAMIC_MINOR;
drvdata->miscdev.fops = &stm_fops;
ret = misc_register(&drvdata->miscdev);
if (ret) {
dev_err(drvdata->dev, "coresight misc_register error!\n");
goto err;
}
dev_info(drvdata->dev, "STM initialized\n");
/*
* Enable and disable STM to undo the temporary default STM enable
* done by RPM.
*/
coresight_enable(drvdata->csdev);
coresight_disable(drvdata->csdev);
if (boot_enable)
coresight_enable(drvdata->csdev);
return 0;
err:
coresight_unregister(drvdata->csdev);
return ret;
}
static int __devinit stm_probe(struct platform_device *pdev)
{
int ret;
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata;
struct stm_drvdata *drvdata;
struct resource *res;
size_t res_size, bitmap_size;
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;
/* Store the driver data pointer for use in exported functions */
stmdrvdata = drvdata;
drvdata->dev = &pdev->dev;
platform_set_drvdata(pdev, drvdata);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res)
return -ENODEV;
drvdata->base = devm_ioremap(dev, res->start, resource_size(res));
if (!drvdata->base)
return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
if (!res)
return -ENODEV;
if (boot_nr_channel) {
res_size = min((resource_size_t)(boot_nr_channel *
BYTES_PER_CHANNEL), resource_size(res));
bitmap_size = boot_nr_channel * sizeof(long);
} else {
res_size = min((resource_size_t)(NR_STM_CHANNEL *
BYTES_PER_CHANNEL), resource_size(res));
bitmap_size = NR_STM_CHANNEL * sizeof(long);
}
drvdata->chs.base = devm_ioremap(dev, res->start, res_size);
if (!drvdata->chs.base)
return -ENOMEM;
drvdata->chs.bitmap = devm_kzalloc(dev, bitmap_size, GFP_KERNEL);
if (!drvdata->chs.bitmap)
return -ENOMEM;
spin_lock_init(&drvdata->spinlock);
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;
bitmap_fill(drvdata->entities, OST_ENTITY_MAX);
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_SOFTWARE;
desc->ops = &stm_cs_ops;
desc->pdata = pdev->dev.platform_data;
desc->dev = &pdev->dev;
desc->groups = stm_attr_grps;
desc->owner = THIS_MODULE;
drvdata->csdev = coresight_register(desc);
if (IS_ERR(drvdata->csdev))
return PTR_ERR(drvdata->csdev);
drvdata->miscdev.name = ((struct coresight_platform_data *)
(pdev->dev.platform_data))->name;
drvdata->miscdev.minor = MISC_DYNAMIC_MINOR;
drvdata->miscdev.fops = &stm_fops;
ret = misc_register(&drvdata->miscdev);
if (ret)
goto err;
dev_info(drvdata->dev, "STM initialized\n");
/*
* Enable and disable STM to undo the temporary default STM enable
* done by RPM.
*/
coresight_enable(drvdata->csdev);
coresight_disable(drvdata->csdev);
if (boot_enable)
coresight_enable(drvdata->csdev);
return 0;
err:
coresight_unregister(drvdata->csdev);
return ret;
}
