mirror of
https://github.com/torvalds/linux.git
synced 2024-12-23 19:31:53 +00:00
ef0fd640e3
Removing boot time log for drivers that don't report useful information other than they came up properly. The same information can be found in sysFS once the system has booted and as such doesn't provide any value in the boot log. Reported-by: Mark Brown <broonie@linaro.org> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
272 lines
6.5 KiB
C
272 lines
6.5 KiB
C
/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Description: CoreSight Funnel driver
|
|
*
|
|
* 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/init.h>
|
|
#include <linux/types.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/coresight.h>
|
|
#include <linux/amba/bus.h>
|
|
#include <linux/clk.h>
|
|
|
|
#include "coresight-priv.h"
|
|
|
|
#define FUNNEL_FUNCTL 0x000
|
|
#define FUNNEL_PRICTL 0x004
|
|
|
|
#define FUNNEL_HOLDTIME_MASK 0xf00
|
|
#define FUNNEL_HOLDTIME_SHFT 0x8
|
|
#define FUNNEL_HOLDTIME (0x7 << FUNNEL_HOLDTIME_SHFT)
|
|
|
|
/**
|
|
* struct funnel_drvdata - specifics associated to a funnel component
|
|
* @base: memory mapped base address for this component.
|
|
* @dev: the device entity associated to this component.
|
|
* @atclk: optional clock for the core parts of the funnel.
|
|
* @csdev: component vitals needed by the framework.
|
|
* @priority: port selection order.
|
|
*/
|
|
struct funnel_drvdata {
|
|
void __iomem *base;
|
|
struct device *dev;
|
|
struct clk *atclk;
|
|
struct coresight_device *csdev;
|
|
unsigned long priority;
|
|
};
|
|
|
|
static void funnel_enable_hw(struct funnel_drvdata *drvdata, int port)
|
|
{
|
|
u32 functl;
|
|
|
|
CS_UNLOCK(drvdata->base);
|
|
|
|
functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL);
|
|
functl &= ~FUNNEL_HOLDTIME_MASK;
|
|
functl |= FUNNEL_HOLDTIME;
|
|
functl |= (1 << port);
|
|
writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL);
|
|
writel_relaxed(drvdata->priority, drvdata->base + FUNNEL_PRICTL);
|
|
|
|
CS_LOCK(drvdata->base);
|
|
}
|
|
|
|
static int funnel_enable(struct coresight_device *csdev, int inport,
|
|
int outport)
|
|
{
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
|
|
|
|
funnel_enable_hw(drvdata, inport);
|
|
|
|
dev_info(drvdata->dev, "FUNNEL inport %d enabled\n", inport);
|
|
return 0;
|
|
}
|
|
|
|
static void funnel_disable_hw(struct funnel_drvdata *drvdata, int inport)
|
|
{
|
|
u32 functl;
|
|
|
|
CS_UNLOCK(drvdata->base);
|
|
|
|
functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL);
|
|
functl &= ~(1 << inport);
|
|
writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL);
|
|
|
|
CS_LOCK(drvdata->base);
|
|
}
|
|
|
|
static void funnel_disable(struct coresight_device *csdev, int inport,
|
|
int outport)
|
|
{
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
|
|
|
|
funnel_disable_hw(drvdata, inport);
|
|
|
|
dev_info(drvdata->dev, "FUNNEL inport %d disabled\n", inport);
|
|
}
|
|
|
|
static const struct coresight_ops_link funnel_link_ops = {
|
|
.enable = funnel_enable,
|
|
.disable = funnel_disable,
|
|
};
|
|
|
|
static const struct coresight_ops funnel_cs_ops = {
|
|
.link_ops = &funnel_link_ops,
|
|
};
|
|
|
|
static ssize_t priority_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent);
|
|
unsigned long val = drvdata->priority;
|
|
|
|
return sprintf(buf, "%#lx\n", val);
|
|
}
|
|
|
|
static ssize_t priority_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
int ret;
|
|
unsigned long val;
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent);
|
|
|
|
ret = kstrtoul(buf, 16, &val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
drvdata->priority = val;
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR_RW(priority);
|
|
|
|
static u32 get_funnel_ctrl_hw(struct funnel_drvdata *drvdata)
|
|
{
|
|
u32 functl;
|
|
|
|
CS_UNLOCK(drvdata->base);
|
|
functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL);
|
|
CS_LOCK(drvdata->base);
|
|
|
|
return functl;
|
|
}
|
|
|
|
static ssize_t funnel_ctrl_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
u32 val;
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(dev->parent);
|
|
|
|
pm_runtime_get_sync(drvdata->dev);
|
|
|
|
val = get_funnel_ctrl_hw(drvdata);
|
|
|
|
pm_runtime_put(drvdata->dev);
|
|
|
|
return sprintf(buf, "%#x\n", val);
|
|
}
|
|
static DEVICE_ATTR_RO(funnel_ctrl);
|
|
|
|
static struct attribute *coresight_funnel_attrs[] = {
|
|
&dev_attr_funnel_ctrl.attr,
|
|
&dev_attr_priority.attr,
|
|
NULL,
|
|
};
|
|
ATTRIBUTE_GROUPS(coresight_funnel);
|
|
|
|
static int funnel_probe(struct amba_device *adev, const struct amba_id *id)
|
|
{
|
|
int ret;
|
|
void __iomem *base;
|
|
struct device *dev = &adev->dev;
|
|
struct coresight_platform_data *pdata = NULL;
|
|
struct funnel_drvdata *drvdata;
|
|
struct resource *res = &adev->res;
|
|
struct coresight_desc *desc;
|
|
struct device_node *np = adev->dev.of_node;
|
|
|
|
if (np) {
|
|
pdata = of_get_coresight_platform_data(dev, np);
|
|
if (IS_ERR(pdata))
|
|
return PTR_ERR(pdata);
|
|
adev->dev.platform_data = pdata;
|
|
}
|
|
|
|
drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
|
|
if (!drvdata)
|
|
return -ENOMEM;
|
|
|
|
drvdata->dev = &adev->dev;
|
|
drvdata->atclk = devm_clk_get(&adev->dev, "atclk"); /* optional */
|
|
if (!IS_ERR(drvdata->atclk)) {
|
|
ret = clk_prepare_enable(drvdata->atclk);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
dev_set_drvdata(dev, drvdata);
|
|
|
|
/* Validity for the resource is already checked by the AMBA core */
|
|
base = devm_ioremap_resource(dev, res);
|
|
if (IS_ERR(base))
|
|
return PTR_ERR(base);
|
|
|
|
drvdata->base = base;
|
|
pm_runtime_put(&adev->dev);
|
|
|
|
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
|
|
if (!desc)
|
|
return -ENOMEM;
|
|
|
|
desc->type = CORESIGHT_DEV_TYPE_LINK;
|
|
desc->subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_MERG;
|
|
desc->ops = &funnel_cs_ops;
|
|
desc->pdata = pdata;
|
|
desc->dev = dev;
|
|
desc->groups = coresight_funnel_groups;
|
|
drvdata->csdev = coresight_register(desc);
|
|
if (IS_ERR(drvdata->csdev))
|
|
return PTR_ERR(drvdata->csdev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int funnel_runtime_suspend(struct device *dev)
|
|
{
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(dev);
|
|
|
|
if (drvdata && !IS_ERR(drvdata->atclk))
|
|
clk_disable_unprepare(drvdata->atclk);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int funnel_runtime_resume(struct device *dev)
|
|
{
|
|
struct funnel_drvdata *drvdata = dev_get_drvdata(dev);
|
|
|
|
if (drvdata && !IS_ERR(drvdata->atclk))
|
|
clk_prepare_enable(drvdata->atclk);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static const struct dev_pm_ops funnel_dev_pm_ops = {
|
|
SET_RUNTIME_PM_OPS(funnel_runtime_suspend, funnel_runtime_resume, NULL)
|
|
};
|
|
|
|
static struct amba_id funnel_ids[] = {
|
|
{
|
|
.id = 0x0003b908,
|
|
.mask = 0x0003ffff,
|
|
},
|
|
{ 0, 0},
|
|
};
|
|
|
|
static struct amba_driver funnel_driver = {
|
|
.drv = {
|
|
.name = "coresight-funnel",
|
|
.owner = THIS_MODULE,
|
|
.pm = &funnel_dev_pm_ops,
|
|
.suppress_bind_attrs = true,
|
|
},
|
|
.probe = funnel_probe,
|
|
.id_table = funnel_ids,
|
|
};
|
|
builtin_amba_driver(funnel_driver);
|