cs: rename driver state data to drvdata and dynamically allocate it
In preparation for using the CoreSight core layer code, rename driver
state data to drvdata. Dynamically allocate drvdata to support more
than one device instance and hence more than one drvdata instance.
Change-Id: I6f98f3194ff012c34ff6851e60e4429febfb15bd
Signed-off-by: Pratik Patel <pratikp@codeaurora.org>
diff --git a/drivers/cs/cs-etb.c b/drivers/cs/cs-etb.c
index c4cf19e..4076c00 100644
--- a/drivers/cs/cs-etb.c
+++ b/drivers/cs/cs-etb.c
@@ -29,8 +29,8 @@
#include "cs-priv.h"
-#define etb_writel(etb, val, off) __raw_writel((val), etb.base + off)
-#define etb_readl(etb, off) __raw_readl(etb.base + off)
+#define etb_writel(drvdata, val, off) __raw_writel((val), drvdata->base + off)
+#define etb_readl(drvdata, off) __raw_readl(drvdata->base + off)
#define ETB_RAM_DEPTH_REG (0x004)
#define ETB_STATUS_REG (0x00C)
@@ -58,15 +58,15 @@
#define ETB_LOCK() \
do { \
mb(); \
- etb_writel(etb, 0x0, CS_LAR); \
+ etb_writel(drvdata, 0x0, CS_LAR); \
} while (0)
#define ETB_UNLOCK() \
do { \
- etb_writel(etb, CS_UNLOCK_MAGIC, CS_LAR); \
+ etb_writel(drvdata, CS_UNLOCK_MAGIC, CS_LAR); \
mb(); \
} while (0)
-struct etb_ctx {
+struct etb_drvdata {
uint8_t *buf;
void __iomem *base;
bool enabled;
@@ -79,7 +79,7 @@
uint32_t trigger_cntr;
};
-static struct etb_ctx etb;
+static struct etb_drvdata *drvdata;
static void __etb_enable(void)
{
@@ -87,16 +87,16 @@
ETB_UNLOCK();
- etb_writel(etb, 0x0, ETB_RAM_WRITE_POINTER);
+ etb_writel(drvdata, 0x0, ETB_RAM_WRITE_POINTER);
for (i = 0; i < ETB_SIZE_WORDS; i++)
- etb_writel(etb, 0x0, ETB_RWD_REG);
+ etb_writel(drvdata, 0x0, ETB_RWD_REG);
- etb_writel(etb, 0x0, ETB_RAM_WRITE_POINTER);
- etb_writel(etb, 0x0, ETB_RAM_READ_POINTER);
+ etb_writel(drvdata, 0x0, ETB_RAM_WRITE_POINTER);
+ etb_writel(drvdata, 0x0, ETB_RAM_READ_POINTER);
- etb_writel(etb, etb.trigger_cntr, ETB_TRG);
- etb_writel(etb, BIT(13) | BIT(0), ETB_FFCR);
- etb_writel(etb, BIT(0), ETB_CTL_REG);
+ etb_writel(drvdata, drvdata->trigger_cntr, ETB_TRG);
+ etb_writel(drvdata, BIT(13) | BIT(0), ETB_FFCR);
+ etb_writel(drvdata, BIT(0), ETB_CTL_REG);
ETB_LOCK();
}
@@ -106,15 +106,15 @@
int ret;
unsigned long flags;
- ret = clk_prepare_enable(etb.clk);
+ ret = clk_prepare_enable(drvdata->clk);
if (ret)
return ret;
- spin_lock_irqsave(&etb.spinlock, flags);
+ spin_lock_irqsave(&drvdata->spinlock, flags);
__etb_enable();
- etb.enabled = true;
- dev_info(etb.dev, "ETB enabled\n");
- spin_unlock_irqrestore(&etb.spinlock, flags);
+ drvdata->enabled = true;
+ dev_info(drvdata->dev, "ETB enabled\n");
+ spin_unlock_irqrestore(&drvdata->spinlock, flags);
return 0;
}
@@ -126,23 +126,23 @@
ETB_UNLOCK();
- ffcr = etb_readl(etb, ETB_FFCR);
+ ffcr = etb_readl(drvdata, ETB_FFCR);
ffcr |= (BIT(12) | BIT(6));
- etb_writel(etb, ffcr, ETB_FFCR);
+ etb_writel(drvdata, ffcr, ETB_FFCR);
- for (count = TIMEOUT_US; BVAL(etb_readl(etb, ETB_FFCR), 6) != 0
+ for (count = TIMEOUT_US; BVAL(etb_readl(drvdata, ETB_FFCR), 6) != 0
&& count > 0; count--)
udelay(1);
- WARN(count == 0, "timeout while flushing ETB, ETB_FFCR: %#x\n",
- etb_readl(etb, ETB_FFCR));
+ WARN(count == 0, "timeout while flushing DRVDATA, ETB_FFCR: %#x\n",
+ etb_readl(drvdata, ETB_FFCR));
- etb_writel(etb, 0x0, ETB_CTL_REG);
+ etb_writel(drvdata, 0x0, ETB_CTL_REG);
- for (count = TIMEOUT_US; BVAL(etb_readl(etb, ETB_FFSR), 1) != 1
+ for (count = TIMEOUT_US; BVAL(etb_readl(drvdata, ETB_FFSR), 1) != 1
&& count > 0; count--)
udelay(1);
- WARN(count == 0, "timeout while disabling ETB, ETB_FFSR: %#x\n",
- etb_readl(etb, ETB_FFSR));
+ WARN(count == 0, "timeout while disabling DRVDATA, ETB_FFSR: %#x\n",
+ etb_readl(drvdata, ETB_FFSR));
ETB_LOCK();
}
@@ -151,13 +151,13 @@
{
unsigned long flags;
- spin_lock_irqsave(&etb.spinlock, flags);
+ spin_lock_irqsave(&drvdata->spinlock, flags);
__etb_disable();
- etb.enabled = false;
- dev_info(etb.dev, "ETB disabled\n");
- spin_unlock_irqrestore(&etb.spinlock, flags);
+ drvdata->enabled = false;
+ dev_info(drvdata->dev, "ETB disabled\n");
+ spin_unlock_irqrestore(&drvdata->spinlock, flags);
- clk_disable_unprepare(etb.clk);
+ clk_disable_unprepare(drvdata->clk);
}
static void __etb_dump(void)
@@ -172,27 +172,27 @@
ETB_UNLOCK();
- read_ptr = etb_readl(etb, ETB_RAM_READ_POINTER);
- write_ptr = etb_readl(etb, ETB_RAM_WRITE_POINTER);
+ read_ptr = etb_readl(drvdata, ETB_RAM_READ_POINTER);
+ write_ptr = etb_readl(drvdata, ETB_RAM_WRITE_POINTER);
frame_off = write_ptr % FRAME_SIZE_WORDS;
frame_endoff = FRAME_SIZE_WORDS - frame_off;
if (frame_off) {
- dev_err(etb.dev, "write_ptr: %lu not aligned to formatter "
+ dev_err(drvdata->dev, "write_ptr: %lu not aligned to formatter "
"frame size\n", (unsigned long)write_ptr);
- dev_err(etb.dev, "frameoff: %lu, frame_endoff: %lu\n",
+ dev_err(drvdata->dev, "frameoff: %lu, frame_endoff: %lu\n",
(unsigned long)frame_off, (unsigned long)frame_endoff);
write_ptr += frame_endoff;
}
- if ((etb_readl(etb, ETB_STATUS_REG) & BIT(0)) == 0)
- etb_writel(etb, 0x0, ETB_RAM_READ_POINTER);
+ if ((etb_readl(drvdata, ETB_STATUS_REG) & BIT(0)) == 0)
+ etb_writel(drvdata, 0x0, ETB_RAM_READ_POINTER);
else
- etb_writel(etb, write_ptr, ETB_RAM_READ_POINTER);
+ etb_writel(drvdata, write_ptr, ETB_RAM_READ_POINTER);
- buf_ptr = etb.buf;
+ buf_ptr = drvdata->buf;
for (i = 0; i < ETB_SIZE_WORDS; i++) {
- read_data = etb_readl(etb, ETB_RAM_READ_DATA_REG);
+ read_data = etb_readl(drvdata, ETB_RAM_READ_DATA_REG);
*buf_ptr++ = read_data >> 0;
*buf_ptr++ = read_data >> 8;
*buf_ptr++ = read_data >> 16;
@@ -209,7 +209,7 @@
}
}
- etb_writel(etb, read_ptr, ETB_RAM_READ_POINTER);
+ etb_writel(drvdata, read_ptr, ETB_RAM_READ_POINTER);
ETB_LOCK();
}
@@ -218,45 +218,45 @@
{
unsigned long flags;
- spin_lock_irqsave(&etb.spinlock, flags);
- if (etb.enabled) {
+ spin_lock_irqsave(&drvdata->spinlock, flags);
+ if (drvdata->enabled) {
__etb_disable();
__etb_dump();
__etb_enable();
- dev_info(etb.dev, "ETB dumped\n");
+ dev_info(drvdata->dev, "ETB dumped\n");
}
- spin_unlock_irqrestore(&etb.spinlock, flags);
+ spin_unlock_irqrestore(&drvdata->spinlock, flags);
}
static int etb_open(struct inode *inode, struct file *file)
{
- if (atomic_cmpxchg(&etb.in_use, 0, 1))
+ if (atomic_cmpxchg(&drvdata->in_use, 0, 1))
return -EBUSY;
- dev_dbg(etb.dev, "%s: successfully opened\n", __func__);
+ dev_dbg(drvdata->dev, "%s: successfully opened\n", __func__);
return 0;
}
static ssize_t etb_read(struct file *file, char __user *data,
size_t len, loff_t *ppos)
{
- if (etb.reading == false) {
+ if (drvdata->reading == false) {
etb_dump();
- etb.reading = true;
+ drvdata->reading = true;
}
if (*ppos + len > ETB_SIZE_WORDS * BYTES_PER_WORD)
len = ETB_SIZE_WORDS * BYTES_PER_WORD - *ppos;
- if (copy_to_user(data, etb.buf + *ppos, len)) {
- dev_dbg(etb.dev, "%s: copy_to_user failed\n", __func__);
+ if (copy_to_user(data, drvdata->buf + *ppos, len)) {
+ dev_dbg(drvdata->dev, "%s: copy_to_user failed\n", __func__);
return -EFAULT;
}
*ppos += len;
- dev_dbg(etb.dev, "%s: %d bytes copied, %d bytes left\n",
+ dev_dbg(drvdata->dev, "%s: %d bytes copied, %d bytes left\n",
__func__, len, (int) (ETB_SIZE_WORDS * BYTES_PER_WORD - *ppos));
return len;
@@ -264,11 +264,11 @@
static int etb_release(struct inode *inode, struct file *file)
{
- etb.reading = false;
+ drvdata->reading = false;
- atomic_set(&etb.in_use, 0);
+ atomic_set(&drvdata->in_use, 0);
- dev_dbg(etb.dev, "%s: released\n", __func__);
+ dev_dbg(drvdata->dev, "%s: released\n", __func__);
return 0;
}
@@ -289,7 +289,7 @@
static ssize_t etb_show_trigger_cntr(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etb.trigger_cntr;
+ unsigned long val = drvdata->trigger_cntr;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -302,7 +302,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etb.trigger_cntr = val;
+ drvdata->trigger_cntr = val;
return size;
}
static DEVICE_ATTR(trigger_cntr, S_IRUGO | S_IWUSR, etb_show_trigger_cntr,
@@ -312,31 +312,31 @@
{
int ret;
- etb.kobj = kobject_create_and_add("etb", qdss_get_modulekobj());
- if (!etb.kobj) {
- dev_err(etb.dev, "failed to create ETB sysfs kobject\n");
+ drvdata->kobj = kobject_create_and_add("etb", qdss_get_modulekobj());
+ if (!drvdata->kobj) {
+ dev_err(drvdata->dev, "failed to create ETB sysfs kobject\n");
ret = -ENOMEM;
goto err_create;
}
- ret = sysfs_create_file(etb.kobj, &dev_attr_trigger_cntr.attr);
+ ret = sysfs_create_file(drvdata->kobj, &dev_attr_trigger_cntr.attr);
if (ret) {
- dev_err(etb.dev, "failed to create ETB sysfs trigger_cntr"
+ dev_err(drvdata->dev, "failed to create ETB sysfs trigger_cntr"
" attribute\n");
goto err_file;
}
return 0;
err_file:
- kobject_put(etb.kobj);
+ kobject_put(drvdata->kobj);
err_create:
return ret;
}
static void __devexit etb_sysfs_exit(void)
{
- sysfs_remove_file(etb.kobj, &dev_attr_trigger_cntr.attr);
- kobject_put(etb.kobj);
+ sysfs_remove_file(drvdata->kobj, &dev_attr_trigger_cntr.attr);
+ kobject_put(drvdata->kobj);
}
static int __devinit etb_probe(struct platform_device *pdev)
@@ -344,29 +344,35 @@
int ret;
struct resource *res;
+ drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+ if (!drvdata) {
+ ret = -ENOMEM;
+ goto err_kzalloc_drvdata;
+ }
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
ret = -EINVAL;
goto err_res;
}
- etb.base = ioremap_nocache(res->start, resource_size(res));
- if (!etb.base) {
+ drvdata->base = ioremap_nocache(res->start, resource_size(res));
+ if (!drvdata->base) {
ret = -EINVAL;
goto err_ioremap;
}
- etb.dev = &pdev->dev;
+ drvdata->dev = &pdev->dev;
- spin_lock_init(&etb.spinlock);
+ spin_lock_init(&drvdata->spinlock);
- etb.clk = clk_get(etb.dev, "core_clk");
- if (IS_ERR(etb.clk)) {
- ret = PTR_ERR(etb.clk);
+ drvdata->clk = clk_get(drvdata->dev, "core_clk");
+ if (IS_ERR(drvdata->clk)) {
+ ret = PTR_ERR(drvdata->clk);
goto err_clk_get;
}
- ret = clk_set_rate(etb.clk, CS_CLK_RATE_TRACE);
+ ret = clk_set_rate(drvdata->clk, CS_CLK_RATE_TRACE);
if (ret)
goto err_clk_rate;
@@ -374,39 +380,42 @@
if (ret)
goto err_misc;
- etb.buf = kzalloc(ETB_SIZE_WORDS * BYTES_PER_WORD, GFP_KERNEL);
- if (!etb.buf) {
+ drvdata->buf = kzalloc(ETB_SIZE_WORDS * BYTES_PER_WORD, GFP_KERNEL);
+ if (!drvdata->buf) {
ret = -ENOMEM;
goto err_alloc;
}
etb_sysfs_init();
- dev_info(etb.dev, "ETB initialized\n");
+ dev_info(drvdata->dev, "ETB initialized\n");
return 0;
err_alloc:
misc_deregister(&etb_misc);
err_misc:
err_clk_rate:
- clk_put(etb.clk);
+ clk_put(drvdata->clk);
err_clk_get:
- iounmap(etb.base);
+ iounmap(drvdata->base);
err_ioremap:
err_res:
- dev_err(etb.dev, "ETB init failed\n");
+ kfree(drvdata);
+err_kzalloc_drvdata:
+ dev_err(drvdata->dev, "ETB init failed\n");
return ret;
}
static int __devexit etb_remove(struct platform_device *pdev)
{
- if (etb.enabled)
+ if (drvdata->enabled)
etb_disable();
etb_sysfs_exit();
- kfree(etb.buf);
+ kfree(drvdata->buf);
misc_deregister(&etb_misc);
- clk_put(etb.clk);
- iounmap(etb.base);
+ clk_put(drvdata->clk);
+ iounmap(drvdata->base);
+ kfree(drvdata);
return 0;
}
diff --git a/drivers/cs/cs-etm.c b/drivers/cs/cs-etm.c
index 4e409cb..4d02884 100644
--- a/drivers/cs/cs-etm.c
+++ b/drivers/cs/cs-etm.c
@@ -33,10 +33,10 @@
#include "cs-priv.h"
-#define etm_writel(etm, cpu, val, off) \
- __raw_writel((val), etm.base + (SZ_4K * cpu) + off)
-#define etm_readl(etm, cpu, off) \
- __raw_readl(etm.base + (SZ_4K * cpu) + off)
+#define etm_writel(drvdata, cpu, val, off) \
+ __raw_writel((val), drvdata->base + (SZ_4K * cpu) + off)
+#define etm_readl(drvdata, cpu, off) \
+ __raw_readl(drvdata->base + (SZ_4K * cpu) + off)
/*
* Device registers:
@@ -130,11 +130,11 @@
#define ETM_LOCK(cpu) \
do { \
mb(); \
- etm_writel(etm, cpu, 0x0, CS_LAR); \
+ etm_writel(drvdata, cpu, 0x0, CS_LAR); \
} while (0)
#define ETM_UNLOCK(cpu) \
do { \
- etm_writel(etm, cpu, CS_UNLOCK_MAGIC, CS_LAR); \
+ etm_writel(drvdata, cpu, CS_UNLOCK_MAGIC, CS_LAR); \
mb(); \
} while (0)
@@ -153,7 +153,7 @@
etm_boot_enable, etm_boot_enable, int, S_IRUGO
);
-struct etm_ctx {
+struct etm_drvdata {
void __iomem *base;
bool enabled;
struct wake_lock wake_lock;
@@ -200,24 +200,7 @@
uint32_t timestamp_event;
};
-static struct etm_ctx etm = {
- .trigger_event = 0x406F,
- .enable_event = 0x6F,
- .enable_ctrl1 = 0x1,
- .fifofull_level = 0x28,
- .addr_val = {(uint32_t) _stext, (uint32_t) _etext},
- .addr_type = {ETM_ADDR_TYPE_RANGE, ETM_ADDR_TYPE_RANGE},
- .cntr_event = {[0 ... (ETM_MAX_CNTR - 1)] = 0x406F},
- .cntr_rld_event = {[0 ... (ETM_MAX_CNTR - 1)] = 0x406F},
- .seq_12_event = 0x406F,
- .seq_21_event = 0x406F,
- .seq_23_event = 0x406F,
- .seq_31_event = 0x406F,
- .seq_32_event = 0x406F,
- .seq_13_event = 0x406F,
- .sync_freq = 0x80,
- .timestamp_event = 0x406F,
-};
+static struct etm_drvdata *drvdata;
/* ETM clock is derived from the processor clock and gets enabled on a
@@ -239,18 +222,18 @@
{
uint32_t etmcr;
- etmcr = etm_readl(etm, cpu, ETMCR);
+ etmcr = etm_readl(drvdata, cpu, ETMCR);
etmcr |= BIT(0);
- etm_writel(etm, cpu, etmcr, ETMCR);
+ etm_writel(drvdata, cpu, etmcr, ETMCR);
}
static void etm_clr_pwrdwn(int cpu)
{
uint32_t etmcr;
- etmcr = etm_readl(etm, cpu, ETMCR);
+ etmcr = etm_readl(drvdata, cpu, ETMCR);
etmcr &= ~BIT(0);
- etm_writel(etm, cpu, etmcr, ETMCR);
+ etm_writel(drvdata, cpu, etmcr, ETMCR);
}
static void etm_set_prog(int cpu)
@@ -258,15 +241,15 @@
uint32_t etmcr;
int count;
- etmcr = etm_readl(etm, cpu, ETMCR);
+ etmcr = etm_readl(drvdata, cpu, ETMCR);
etmcr |= BIT(10);
- etm_writel(etm, cpu, etmcr, ETMCR);
+ etm_writel(drvdata, cpu, etmcr, ETMCR);
- for (count = TIMEOUT_US; BVAL(etm_readl(etm, cpu, ETMSR), 1) != 1
+ for (count = TIMEOUT_US; BVAL(etm_readl(drvdata, cpu, ETMSR), 1) != 1
&& count > 0; count--)
udelay(1);
WARN(count == 0, "timeout while setting prog bit, ETMSR: %#x\n",
- etm_readl(etm, cpu, ETMSR));
+ etm_readl(drvdata, cpu, ETMSR));
}
static void etm_clr_prog(int cpu)
@@ -274,15 +257,15 @@
uint32_t etmcr;
int count;
- etmcr = etm_readl(etm, cpu, ETMCR);
+ etmcr = etm_readl(drvdata, cpu, ETMCR);
etmcr &= ~BIT(10);
- etm_writel(etm, cpu, etmcr, ETMCR);
+ etm_writel(drvdata, cpu, etmcr, ETMCR);
- for (count = TIMEOUT_US; BVAL(etm_readl(etm, cpu, ETMSR), 1) != 0
+ for (count = TIMEOUT_US; BVAL(etm_readl(drvdata, cpu, ETMSR), 1) != 0
&& count > 0; count--)
udelay(1);
WARN(count == 0, "timeout while clearing prog bit, ETMSR: %#x\n",
- etm_readl(etm, cpu, ETMSR));
+ etm_readl(drvdata, cpu, ETMSR));
}
static void __etm_enable(int cpu)
@@ -294,40 +277,42 @@
etm_clr_pwrdwn(cpu);
etm_set_prog(cpu);
- etm_writel(etm, cpu, etm.ctrl | BIT(10), ETMCR);
- etm_writel(etm, cpu, etm.trigger_event, ETMTRIGGER);
- etm_writel(etm, cpu, etm.startstop_ctrl, ETMTSSCR);
- etm_writel(etm, cpu, etm.enable_event, ETMTEEVR);
- etm_writel(etm, cpu, etm.enable_ctrl1, ETMTECR1);
- etm_writel(etm, cpu, etm.fifofull_level, ETMFFLR);
- for (i = 0; i < etm.nr_addr_cmp; i++) {
- etm_writel(etm, cpu, etm.addr_val[i], ETMACVRn(i));
- etm_writel(etm, cpu, etm.addr_acctype[i], ETMACTRn(i));
+ etm_writel(drvdata, cpu, drvdata->ctrl | BIT(10), ETMCR);
+ etm_writel(drvdata, cpu, drvdata->trigger_event, ETMTRIGGER);
+ etm_writel(drvdata, cpu, drvdata->startstop_ctrl, ETMTSSCR);
+ etm_writel(drvdata, cpu, drvdata->enable_event, ETMTEEVR);
+ etm_writel(drvdata, cpu, drvdata->enable_ctrl1, ETMTECR1);
+ etm_writel(drvdata, cpu, drvdata->fifofull_level, ETMFFLR);
+ for (i = 0; i < drvdata->nr_addr_cmp; i++) {
+ etm_writel(drvdata, cpu, drvdata->addr_val[i], ETMACVRn(i));
+ etm_writel(drvdata, cpu, drvdata->addr_acctype[i], ETMACTRn(i));
}
- for (i = 0; i < etm.nr_cntr; i++) {
- etm_writel(etm, cpu, etm.cntr_rld_val[i], ETMCNTRLDVRn(i));
- etm_writel(etm, cpu, etm.cntr_event[i], ETMCNTENRn(i));
- etm_writel(etm, cpu, etm.cntr_rld_event[i], ETMCNTRLDEVRn(i));
- etm_writel(etm, cpu, etm.cntr_val[i], ETMCNTVRn(i));
+ for (i = 0; i < drvdata->nr_cntr; i++) {
+ etm_writel(drvdata, cpu, drvdata->cntr_rld_val[i],
+ ETMCNTRLDVRn(i));
+ etm_writel(drvdata, cpu, drvdata->cntr_event[i], ETMCNTENRn(i));
+ etm_writel(drvdata, cpu, drvdata->cntr_rld_event[i],
+ ETMCNTRLDEVRn(i));
+ etm_writel(drvdata, cpu, drvdata->cntr_val[i], ETMCNTVRn(i));
}
- etm_writel(etm, cpu, etm.seq_12_event, ETMSQ12EVR);
- etm_writel(etm, cpu, etm.seq_21_event, ETMSQ21EVR);
- etm_writel(etm, cpu, etm.seq_23_event, ETMSQ23EVR);
- etm_writel(etm, cpu, etm.seq_31_event, ETMSQ31EVR);
- etm_writel(etm, cpu, etm.seq_32_event, ETMSQ32EVR);
- etm_writel(etm, cpu, etm.seq_13_event, ETMSQ13EVR);
- etm_writel(etm, cpu, etm.seq_curr_state, ETMSQR);
- for (i = 0; i < etm.nr_ext_out; i++)
- etm_writel(etm, cpu, 0x0000406F, ETMEXTOUTEVRn(i));
- for (i = 0; i < etm.nr_ctxid_cmp; i++)
- etm_writel(etm, cpu, etm.ctxid_val[i], ETMCIDCVRn(i));
- etm_writel(etm, cpu, etm.ctxid_mask, ETMCIDCMR);
- etm_writel(etm, cpu, etm.sync_freq, ETMSYNCFR);
- etm_writel(etm, cpu, 0x00000000, ETMEXTINSELR);
- etm_writel(etm, cpu, etm.timestamp_event, ETMTSEVR);
- etm_writel(etm, cpu, 0x00000000, ETMAUXCR);
- etm_writel(etm, cpu, cpu+1, ETMTRACEIDR);
- etm_writel(etm, cpu, 0x00000000, ETMVMIDCVR);
+ etm_writel(drvdata, cpu, drvdata->seq_12_event, ETMSQ12EVR);
+ etm_writel(drvdata, cpu, drvdata->seq_21_event, ETMSQ21EVR);
+ etm_writel(drvdata, cpu, drvdata->seq_23_event, ETMSQ23EVR);
+ etm_writel(drvdata, cpu, drvdata->seq_31_event, ETMSQ31EVR);
+ etm_writel(drvdata, cpu, drvdata->seq_32_event, ETMSQ32EVR);
+ etm_writel(drvdata, cpu, drvdata->seq_13_event, ETMSQ13EVR);
+ etm_writel(drvdata, cpu, drvdata->seq_curr_state, ETMSQR);
+ for (i = 0; i < drvdata->nr_ext_out; i++)
+ etm_writel(drvdata, cpu, 0x0000406F, ETMEXTOUTEVRn(i));
+ for (i = 0; i < drvdata->nr_ctxid_cmp; i++)
+ etm_writel(drvdata, cpu, drvdata->ctxid_val[i], ETMCIDCVRn(i));
+ etm_writel(drvdata, cpu, drvdata->ctxid_mask, ETMCIDCMR);
+ etm_writel(drvdata, cpu, drvdata->sync_freq, ETMSYNCFR);
+ etm_writel(drvdata, cpu, 0x00000000, ETMEXTINSELR);
+ etm_writel(drvdata, cpu, drvdata->timestamp_event, ETMTSEVR);
+ etm_writel(drvdata, cpu, 0x00000000, ETMAUXCR);
+ etm_writel(drvdata, cpu, cpu+1, ETMTRACEIDR);
+ etm_writel(drvdata, cpu, 0x00000000, ETMVMIDCVR);
etm_clr_prog(cpu);
ETM_LOCK(cpu);
@@ -337,13 +322,13 @@
{
int ret, cpu;
- if (etm.enabled) {
- dev_err(etm.dev, "ETM tracing already enabled\n");
+ if (drvdata->enabled) {
+ dev_err(drvdata->dev, "ETM tracing already enabled\n");
ret = -EPERM;
goto err;
}
- wake_lock(&etm.wake_lock);
+ wake_lock(&drvdata->wake_lock);
/* 1. causes all online cpus to come out of idle PC
* 2. prevents idle PC until save restore flag is enabled atomically
*
@@ -351,32 +336,32 @@
* operation and to ensure cores where trace is expected to be turned
* on are already hotplugged on
*/
- pm_qos_update_request(&etm.qos_req, 0);
+ pm_qos_update_request(&drvdata->qos_req, 0);
- ret = clk_prepare_enable(etm.clk);
+ ret = clk_prepare_enable(drvdata->clk);
if (ret)
goto err_clk;
- ret = qdss_enable(etm.src);
+ ret = qdss_enable(drvdata->src);
if (ret)
goto err_qdss;
for_each_online_cpu(cpu)
__etm_enable(cpu);
- etm.enabled = true;
+ drvdata->enabled = true;
- pm_qos_update_request(&etm.qos_req, PM_QOS_DEFAULT_VALUE);
- wake_unlock(&etm.wake_lock);
+ pm_qos_update_request(&drvdata->qos_req, PM_QOS_DEFAULT_VALUE);
+ wake_unlock(&drvdata->wake_lock);
- dev_info(etm.dev, "ETM tracing enabled\n");
+ dev_info(drvdata->dev, "ETM tracing enabled\n");
return 0;
err_qdss:
- clk_disable_unprepare(etm.clk);
+ clk_disable_unprepare(drvdata->clk);
err_clk:
- pm_qos_update_request(&etm.qos_req, PM_QOS_DEFAULT_VALUE);
- wake_unlock(&etm.wake_lock);
+ pm_qos_update_request(&drvdata->qos_req, PM_QOS_DEFAULT_VALUE);
+ wake_unlock(&drvdata->wake_lock);
err:
return ret;
}
@@ -387,7 +372,7 @@
etm_set_prog(cpu);
/* program trace enable to low by using always false event */
- etm_writel(etm, cpu, 0x6F | BIT(14), ETMTEEVR);
+ etm_writel(drvdata, cpu, 0x6F | BIT(14), ETMTEEVR);
/* Vote for ETM power/clock disable */
etm_set_pwrdwn(cpu);
@@ -398,13 +383,13 @@
{
int ret, cpu;
- if (!etm.enabled) {
- dev_err(etm.dev, "ETM tracing already disabled\n");
+ if (!drvdata->enabled) {
+ dev_err(drvdata->dev, "ETM tracing already disabled\n");
ret = -EPERM;
goto err;
}
- wake_lock(&etm.wake_lock);
+ wake_lock(&drvdata->wake_lock);
/* 1. causes all online cpus to come out of idle PC
* 2. prevents idle PC until save restore flag is disabled atomically
*
@@ -412,21 +397,21 @@
* operation and to ensure cores where trace is expected to be turned
* off are already hotplugged on
*/
- pm_qos_update_request(&etm.qos_req, 0);
+ pm_qos_update_request(&drvdata->qos_req, 0);
for_each_online_cpu(cpu)
__etm_disable(cpu);
- etm.enabled = false;
+ drvdata->enabled = false;
- qdss_disable(etm.src);
+ qdss_disable(drvdata->src);
- clk_disable_unprepare(etm.clk);
+ clk_disable_unprepare(drvdata->clk);
- pm_qos_update_request(&etm.qos_req, PM_QOS_DEFAULT_VALUE);
- wake_unlock(&etm.wake_lock);
+ pm_qos_update_request(&drvdata->qos_req, PM_QOS_DEFAULT_VALUE);
+ wake_unlock(&drvdata->wake_lock);
- dev_info(etm.dev, "ETM tracing disabled\n");
+ dev_info(drvdata->dev, "ETM tracing disabled\n");
return 0;
err:
return ret;
@@ -444,7 +429,7 @@
static ssize_t etm_show_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.enabled;
+ unsigned long val = drvdata->enabled;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -458,12 +443,12 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
if (val)
ret = etm_enable();
else
ret = etm_disable();
- mutex_unlock(&etm.mutex);
+ mutex_unlock(&drvdata->mutex);
if (ret)
return ret;
@@ -475,7 +460,7 @@
static ssize_t etm_show_nr_addr_cmp(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.nr_addr_cmp;
+ unsigned long val = drvdata->nr_addr_cmp;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
static DEVICE_ATTR(nr_addr_cmp, S_IRUGO, etm_show_nr_addr_cmp, NULL);
@@ -483,7 +468,7 @@
static ssize_t etm_show_nr_cntr(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.nr_cntr;
+ unsigned long val = drvdata->nr_cntr;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
static DEVICE_ATTR(nr_cntr, S_IRUGO, etm_show_nr_cntr, NULL);
@@ -491,7 +476,7 @@
static ssize_t etm_show_nr_ctxid_cmp(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.nr_ctxid_cmp;
+ unsigned long val = drvdata->nr_ctxid_cmp;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
static DEVICE_ATTR(nr_ctxid_cmp, S_IRUGO, etm_show_nr_ctxid_cmp, NULL);
@@ -499,7 +484,7 @@
static ssize_t etm_show_reset(struct device *dev, struct device_attribute *attr,
char *buf)
{
- unsigned long val = etm.reset;
+ unsigned long val = drvdata->reset;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -514,47 +499,47 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
if (val) {
- etm.mode = ETM_MODE_EXCLUDE;
- etm.ctrl = 0x0;
+ drvdata->mode = ETM_MODE_EXCLUDE;
+ drvdata->ctrl = 0x0;
if (cpu_is_krait_v1()) {
- etm.mode |= ETM_MODE_CYCACC;
- etm.ctrl |= BIT(12);
+ drvdata->mode |= ETM_MODE_CYCACC;
+ drvdata->ctrl |= BIT(12);
}
- etm.trigger_event = 0x406F;
- etm.startstop_ctrl = 0x0;
- etm.enable_event = 0x6F;
- etm.enable_ctrl1 = 0x1000000;
- etm.fifofull_level = 0x28;
- etm.addr_idx = 0x0;
- for (i = 0; i < etm.nr_addr_cmp; i++) {
- etm.addr_val[i] = 0x0;
- etm.addr_acctype[i] = 0x0;
- etm.addr_type[i] = ETM_ADDR_TYPE_NONE;
+ drvdata->trigger_event = 0x406F;
+ drvdata->startstop_ctrl = 0x0;
+ drvdata->enable_event = 0x6F;
+ drvdata->enable_ctrl1 = 0x1000000;
+ drvdata->fifofull_level = 0x28;
+ drvdata->addr_idx = 0x0;
+ for (i = 0; i < drvdata->nr_addr_cmp; i++) {
+ drvdata->addr_val[i] = 0x0;
+ drvdata->addr_acctype[i] = 0x0;
+ drvdata->addr_type[i] = ETM_ADDR_TYPE_NONE;
}
- etm.cntr_idx = 0x0;
- for (i = 0; i < etm.nr_cntr; i++) {
- etm.cntr_rld_val[i] = 0x0;
- etm.cntr_event[i] = 0x406F;
- etm.cntr_rld_event[i] = 0x406F;
- etm.cntr_val[i] = 0x0;
+ drvdata->cntr_idx = 0x0;
+ for (i = 0; i < drvdata->nr_cntr; i++) {
+ drvdata->cntr_rld_val[i] = 0x0;
+ drvdata->cntr_event[i] = 0x406F;
+ drvdata->cntr_rld_event[i] = 0x406F;
+ drvdata->cntr_val[i] = 0x0;
}
- etm.seq_12_event = 0x406F;
- etm.seq_21_event = 0x406F;
- etm.seq_23_event = 0x406F;
- etm.seq_31_event = 0x406F;
- etm.seq_32_event = 0x406F;
- etm.seq_13_event = 0x406F;
- etm.seq_curr_state = 0x0;
- etm.ctxid_idx = 0x0;
- for (i = 0; i < etm.nr_ctxid_cmp; i++)
- etm.ctxid_val[i] = 0x0;
- etm.ctxid_mask = 0x0;
- etm.sync_freq = 0x80;
- etm.timestamp_event = 0x406F;
+ drvdata->seq_12_event = 0x406F;
+ drvdata->seq_21_event = 0x406F;
+ drvdata->seq_23_event = 0x406F;
+ drvdata->seq_31_event = 0x406F;
+ drvdata->seq_32_event = 0x406F;
+ drvdata->seq_13_event = 0x406F;
+ drvdata->seq_curr_state = 0x0;
+ drvdata->ctxid_idx = 0x0;
+ for (i = 0; i < drvdata->nr_ctxid_cmp; i++)
+ drvdata->ctxid_val[i] = 0x0;
+ drvdata->ctxid_mask = 0x0;
+ drvdata->sync_freq = 0x80;
+ drvdata->timestamp_event = 0x406F;
}
- mutex_unlock(&etm.mutex);
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(reset, S_IRUGO | S_IWUSR, etm_show_reset, etm_store_reset);
@@ -562,7 +547,7 @@
static ssize_t etm_show_mode(struct device *dev, struct device_attribute *attr,
char *buf)
{
- unsigned long val = etm.mode;
+ unsigned long val = drvdata->mode;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -574,33 +559,33 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.mode = val & ETM_MODE_ALL;
+ mutex_lock(&drvdata->mutex);
+ drvdata->mode = val & ETM_MODE_ALL;
- if (etm.mode & ETM_MODE_EXCLUDE)
- etm.enable_ctrl1 |= BIT(24);
+ if (drvdata->mode & ETM_MODE_EXCLUDE)
+ drvdata->enable_ctrl1 |= BIT(24);
else
- etm.enable_ctrl1 &= ~BIT(24);
+ drvdata->enable_ctrl1 &= ~BIT(24);
- if (etm.mode & ETM_MODE_CYCACC)
- etm.ctrl |= BIT(12);
+ if (drvdata->mode & ETM_MODE_CYCACC)
+ drvdata->ctrl |= BIT(12);
else
- etm.ctrl &= ~BIT(12);
+ drvdata->ctrl &= ~BIT(12);
- if (etm.mode & ETM_MODE_STALL)
- etm.ctrl |= BIT(7);
+ if (drvdata->mode & ETM_MODE_STALL)
+ drvdata->ctrl |= BIT(7);
else
- etm.ctrl &= ~BIT(7);
+ drvdata->ctrl &= ~BIT(7);
- if (etm.mode & ETM_MODE_TIMESTAMP)
- etm.ctrl |= BIT(28);
+ if (drvdata->mode & ETM_MODE_TIMESTAMP)
+ drvdata->ctrl |= BIT(28);
else
- etm.ctrl &= ~BIT(28);
- if (etm.mode & ETM_MODE_CTXID)
- etm.ctrl |= (BIT(14) | BIT(15));
+ drvdata->ctrl &= ~BIT(28);
+ if (drvdata->mode & ETM_MODE_CTXID)
+ drvdata->ctrl |= (BIT(14) | BIT(15));
else
- etm.ctrl &= ~(BIT(14) | BIT(15));
- mutex_unlock(&etm.mutex);
+ drvdata->ctrl &= ~(BIT(14) | BIT(15));
+ mutex_unlock(&drvdata->mutex);
return size;
}
@@ -609,7 +594,7 @@
static ssize_t etm_show_trigger_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.trigger_event;
+ unsigned long val = drvdata->trigger_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -622,7 +607,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.trigger_event = val & ETM_EVENT_MASK;
+ drvdata->trigger_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(trigger_event, S_IRUGO | S_IWUSR, etm_show_trigger_event,
@@ -631,7 +616,7 @@
static ssize_t etm_show_enable_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.enable_event;
+ unsigned long val = drvdata->enable_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -644,7 +629,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.enable_event = val & ETM_EVENT_MASK;
+ drvdata->enable_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(enable_event, S_IRUGO | S_IWUSR, etm_show_enable_event,
@@ -653,7 +638,7 @@
static ssize_t etm_show_fifofull_level(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.fifofull_level;
+ unsigned long val = drvdata->fifofull_level;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -666,7 +651,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.fifofull_level = val;
+ drvdata->fifofull_level = val;
return size;
}
static DEVICE_ATTR(fifofull_level, S_IRUGO | S_IWUSR, etm_show_fifofull_level,
@@ -675,7 +660,7 @@
static ssize_t etm_show_addr_idx(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.addr_idx;
+ unsigned long val = drvdata->addr_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -687,15 +672,15 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- if (val >= etm.nr_addr_cmp)
+ if (val >= drvdata->nr_addr_cmp)
return -EINVAL;
/* Use mutex to ensure index doesn't change while it gets dereferenced
* multiple times within a mutex block elsewhere.
*/
- mutex_lock(&etm.mutex);
- etm.addr_idx = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->addr_idx = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(addr_idx, S_IRUGO | S_IWUSR, etm_show_addr_idx,
@@ -707,16 +692,16 @@
unsigned long val;
uint8_t idx;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
- if (!(etm.addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- etm.addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
+ if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- val = etm.addr_val[idx];
- mutex_unlock(&etm.mutex);
+ val = drvdata->addr_val[idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -730,17 +715,17 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
- if (!(etm.addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- etm.addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
+ if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ drvdata->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- etm.addr_val[idx] = val;
- etm.addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
- mutex_unlock(&etm.mutex);
+ drvdata->addr_val[idx] = val;
+ drvdata->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(addr_single, S_IRUGO | S_IWUSR, etm_show_addr_single,
@@ -752,23 +737,23 @@
unsigned long val1, val2;
uint8_t idx;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
if (idx % 2 != 0) {
- mutex_unlock(&etm.mutex);
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- if (!((etm.addr_type[idx] == ETM_ADDR_TYPE_NONE &&
- etm.addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
- (etm.addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
- etm.addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
- mutex_unlock(&etm.mutex);
+ if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
+ drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
+ (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
+ drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- val1 = etm.addr_val[idx];
- val2 = etm.addr_val[idx + 1];
- mutex_unlock(&etm.mutex);
+ val1 = drvdata->addr_val[idx];
+ val2 = drvdata->addr_val[idx + 1];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
}
@@ -785,26 +770,26 @@
if (val1 > val2)
return -EINVAL;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
if (idx % 2 != 0) {
- mutex_unlock(&etm.mutex);
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- if (!((etm.addr_type[idx] == ETM_ADDR_TYPE_NONE &&
- etm.addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
- (etm.addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
- etm.addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
- mutex_unlock(&etm.mutex);
+ if (!((drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
+ drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
+ (drvdata->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
+ drvdata->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- etm.addr_val[idx] = val1;
- etm.addr_type[idx] = ETM_ADDR_TYPE_RANGE;
- etm.addr_val[idx + 1] = val2;
- etm.addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
- etm.enable_ctrl1 |= (1 << (idx/2));
- mutex_unlock(&etm.mutex);
+ drvdata->addr_val[idx] = val1;
+ drvdata->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
+ drvdata->addr_val[idx + 1] = val2;
+ drvdata->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
+ drvdata->enable_ctrl1 |= (1 << (idx/2));
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(addr_range, S_IRUGO | S_IWUSR, etm_show_addr_range,
@@ -816,16 +801,16 @@
unsigned long val;
uint8_t idx;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
- if (!(etm.addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- etm.addr_type[idx] == ETM_ADDR_TYPE_START)) {
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
+ if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- val = etm.addr_val[idx];
- mutex_unlock(&etm.mutex);
+ val = drvdata->addr_val[idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -839,19 +824,19 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
- if (!(etm.addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- etm.addr_type[idx] == ETM_ADDR_TYPE_START)) {
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
+ if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ drvdata->addr_type[idx] == ETM_ADDR_TYPE_START)) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- etm.addr_val[idx] = val;
- etm.addr_type[idx] = ETM_ADDR_TYPE_START;
- etm.startstop_ctrl |= (1 << idx);
- etm.enable_ctrl1 |= BIT(25);
- mutex_unlock(&etm.mutex);
+ drvdata->addr_val[idx] = val;
+ drvdata->addr_type[idx] = ETM_ADDR_TYPE_START;
+ drvdata->startstop_ctrl |= (1 << idx);
+ drvdata->enable_ctrl1 |= BIT(25);
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(addr_start, S_IRUGO | S_IWUSR, etm_show_addr_start,
@@ -863,16 +848,16 @@
unsigned long val;
uint8_t idx;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
- if (!(etm.addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- etm.addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
+ if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- val = etm.addr_val[idx];
- mutex_unlock(&etm.mutex);
+ val = drvdata->addr_val[idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -886,19 +871,19 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- idx = etm.addr_idx;
- if (!(etm.addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- etm.addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ idx = drvdata->addr_idx;
+ if (!(drvdata->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ drvdata->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
+ mutex_unlock(&drvdata->mutex);
return -EPERM;
}
- etm.addr_val[idx] = val;
- etm.addr_type[idx] = ETM_ADDR_TYPE_STOP;
- etm.startstop_ctrl |= (1 << (idx + 16));
- etm.enable_ctrl1 |= BIT(25);
- mutex_unlock(&etm.mutex);
+ drvdata->addr_val[idx] = val;
+ drvdata->addr_type[idx] = ETM_ADDR_TYPE_STOP;
+ drvdata->startstop_ctrl |= (1 << (idx + 16));
+ drvdata->enable_ctrl1 |= BIT(25);
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(addr_stop, S_IRUGO | S_IWUSR, etm_show_addr_stop,
@@ -909,9 +894,9 @@
{
unsigned long val;
- mutex_lock(&etm.mutex);
- val = etm.addr_acctype[etm.addr_idx];
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ val = drvdata->addr_acctype[drvdata->addr_idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -924,9 +909,9 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.addr_acctype[etm.addr_idx] = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->addr_acctype[drvdata->addr_idx] = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(addr_acctype, S_IRUGO | S_IWUSR, etm_show_addr_acctype,
@@ -935,7 +920,7 @@
static ssize_t etm_show_cntr_idx(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.addr_idx;
+ unsigned long val = drvdata->addr_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -947,15 +932,15 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- if (val >= etm.nr_cntr)
+ if (val >= drvdata->nr_cntr)
return -EINVAL;
/* Use mutex to ensure index doesn't change while it gets dereferenced
* multiple times within a mutex block elsewhere.
*/
- mutex_lock(&etm.mutex);
- etm.cntr_idx = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->cntr_idx = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(cntr_idx, S_IRUGO | S_IWUSR, etm_show_cntr_idx,
@@ -965,9 +950,9 @@
struct device_attribute *attr, char *buf)
{
unsigned long val;
- mutex_lock(&etm.mutex);
- val = etm.cntr_rld_val[etm.cntr_idx];
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ val = drvdata->cntr_rld_val[drvdata->cntr_idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -980,9 +965,9 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.cntr_rld_val[etm.cntr_idx] = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->cntr_rld_val[drvdata->cntr_idx] = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(cntr_rld_val, S_IRUGO | S_IWUSR, etm_show_cntr_rld_val,
@@ -993,9 +978,9 @@
{
unsigned long val;
- mutex_lock(&etm.mutex);
- val = etm.cntr_event[etm.cntr_idx];
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ val = drvdata->cntr_event[drvdata->cntr_idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1008,9 +993,9 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.cntr_event[etm.cntr_idx] = val & ETM_EVENT_MASK;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->cntr_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(cntr_event, S_IRUGO | S_IWUSR, etm_show_cntr_event,
@@ -1021,9 +1006,9 @@
{
unsigned long val;
- mutex_lock(&etm.mutex);
- val = etm.cntr_rld_event[etm.cntr_idx];
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ val = drvdata->cntr_rld_event[drvdata->cntr_idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1036,9 +1021,9 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.cntr_rld_event[etm.cntr_idx] = val & ETM_EVENT_MASK;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->cntr_rld_event[drvdata->cntr_idx] = val & ETM_EVENT_MASK;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(cntr_rld_event, S_IRUGO | S_IWUSR, etm_show_cntr_rld_event,
@@ -1049,9 +1034,9 @@
{
unsigned long val;
- mutex_lock(&etm.mutex);
- val = etm.cntr_val[etm.cntr_idx];
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ val = drvdata->cntr_val[drvdata->cntr_idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1064,9 +1049,9 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.cntr_val[etm.cntr_idx] = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->cntr_val[drvdata->cntr_idx] = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(cntr_val, S_IRUGO | S_IWUSR, etm_show_cntr_val,
@@ -1075,7 +1060,7 @@
static ssize_t etm_show_seq_12_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_12_event;
+ unsigned long val = drvdata->seq_12_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1088,7 +1073,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.seq_12_event = val & ETM_EVENT_MASK;
+ drvdata->seq_12_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(seq_12_event, S_IRUGO | S_IWUSR, etm_show_seq_12_event,
@@ -1097,7 +1082,7 @@
static ssize_t etm_show_seq_21_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_21_event;
+ unsigned long val = drvdata->seq_21_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1110,7 +1095,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.seq_21_event = val & ETM_EVENT_MASK;
+ drvdata->seq_21_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(seq_21_event, S_IRUGO | S_IWUSR, etm_show_seq_21_event,
@@ -1119,7 +1104,7 @@
static ssize_t etm_show_seq_23_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_23_event;
+ unsigned long val = drvdata->seq_23_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1132,7 +1117,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.seq_23_event = val & ETM_EVENT_MASK;
+ drvdata->seq_23_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(seq_23_event, S_IRUGO | S_IWUSR, etm_show_seq_23_event,
@@ -1141,7 +1126,7 @@
static ssize_t etm_show_seq_31_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_31_event;
+ unsigned long val = drvdata->seq_31_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1154,7 +1139,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.seq_31_event = val & ETM_EVENT_MASK;
+ drvdata->seq_31_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(seq_31_event, S_IRUGO | S_IWUSR, etm_show_seq_31_event,
@@ -1163,7 +1148,7 @@
static ssize_t etm_show_seq_32_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_32_event;
+ unsigned long val = drvdata->seq_32_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1176,7 +1161,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.seq_32_event = val & ETM_EVENT_MASK;
+ drvdata->seq_32_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(seq_32_event, S_IRUGO | S_IWUSR, etm_show_seq_32_event,
@@ -1185,7 +1170,7 @@
static ssize_t etm_show_seq_13_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_13_event;
+ unsigned long val = drvdata->seq_13_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1198,7 +1183,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.seq_13_event = val & ETM_EVENT_MASK;
+ drvdata->seq_13_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(seq_13_event, S_IRUGO | S_IWUSR, etm_show_seq_13_event,
@@ -1207,7 +1192,7 @@
static ssize_t etm_show_seq_curr_state(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.seq_curr_state;
+ unsigned long val = drvdata->seq_curr_state;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1222,7 +1207,7 @@
if (val > ETM_SEQ_STATE_MAX_VAL)
return -EINVAL;
- etm.seq_curr_state = val;
+ drvdata->seq_curr_state = val;
return size;
}
static DEVICE_ATTR(seq_curr_state, S_IRUGO | S_IWUSR, etm_show_seq_curr_state,
@@ -1231,7 +1216,7 @@
static ssize_t etm_show_ctxid_idx(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.ctxid_idx;
+ unsigned long val = drvdata->ctxid_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1243,15 +1228,15 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- if (val >= etm.nr_ctxid_cmp)
+ if (val >= drvdata->nr_ctxid_cmp)
return -EINVAL;
/* Use mutex to ensure index doesn't change while it gets dereferenced
* multiple times within a mutex block elsewhere.
*/
- mutex_lock(&etm.mutex);
- etm.ctxid_idx = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->ctxid_idx = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(ctxid_idx, S_IRUGO | S_IWUSR, etm_show_ctxid_idx,
@@ -1262,9 +1247,9 @@
{
unsigned long val;
- mutex_lock(&etm.mutex);
- val = etm.ctxid_val[etm.ctxid_idx];
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ val = drvdata->ctxid_val[drvdata->ctxid_idx];
+ mutex_unlock(&drvdata->mutex);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1277,9 +1262,9 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- mutex_lock(&etm.mutex);
- etm.ctxid_val[etm.ctxid_idx] = val;
- mutex_unlock(&etm.mutex);
+ mutex_lock(&drvdata->mutex);
+ drvdata->ctxid_val[drvdata->ctxid_idx] = val;
+ mutex_unlock(&drvdata->mutex);
return size;
}
static DEVICE_ATTR(ctxid_val, S_IRUGO | S_IWUSR, etm_show_ctxid_val,
@@ -1288,7 +1273,7 @@
static ssize_t etm_show_ctxid_mask(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.ctxid_mask;
+ unsigned long val = drvdata->ctxid_mask;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1301,7 +1286,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.ctxid_mask = val;
+ drvdata->ctxid_mask = val;
return size;
}
static DEVICE_ATTR(ctxid_mask, S_IRUGO | S_IWUSR, etm_show_ctxid_mask,
@@ -1310,7 +1295,7 @@
static ssize_t etm_show_sync_freq(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = etm.sync_freq;
+ unsigned long val = drvdata->sync_freq;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1323,7 +1308,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.sync_freq = val & ETM_SYNC_MASK;
+ drvdata->sync_freq = val & ETM_SYNC_MASK;
return size;
}
static DEVICE_ATTR(sync_freq, S_IRUGO | S_IWUSR, etm_show_sync_freq,
@@ -1333,7 +1318,7 @@
struct device_attribute *attr,
char *buf)
{
- unsigned long val = etm.timestamp_event;
+ unsigned long val = drvdata->timestamp_event;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1346,7 +1331,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- etm.timestamp_event = val & ETM_EVENT_MASK;
+ drvdata->timestamp_event = val & ETM_EVENT_MASK;
return size;
}
static DEVICE_ATTR(timestamp_event, S_IRUGO | S_IWUSR, etm_show_timestamp_event,
@@ -1395,35 +1380,35 @@
{
int ret;
- etm.kobj = kobject_create_and_add("etm", qdss_get_modulekobj());
- if (!etm.kobj) {
- dev_err(etm.dev, "failed to create ETM sysfs kobject\n");
+ drvdata->kobj = kobject_create_and_add("etm", qdss_get_modulekobj());
+ if (!drvdata->kobj) {
+ dev_err(drvdata->dev, "failed to create ETM sysfs kobject\n");
ret = -ENOMEM;
goto err_create;
}
- ret = sysfs_create_file(etm.kobj, &dev_attr_enabled.attr);
+ ret = sysfs_create_file(drvdata->kobj, &dev_attr_enabled.attr);
if (ret) {
- dev_err(etm.dev, "failed to create ETM sysfs enabled"
+ dev_err(drvdata->dev, "failed to create ETM sysfs enabled"
" attribute\n");
goto err_file;
}
- if (sysfs_create_group(etm.kobj, &etm_attr_grp))
- dev_err(etm.dev, "failed to create ETM sysfs group\n");
+ if (sysfs_create_group(drvdata->kobj, &etm_attr_grp))
+ dev_err(drvdata->dev, "failed to create ETM sysfs group\n");
return 0;
err_file:
- kobject_put(etm.kobj);
+ kobject_put(drvdata->kobj);
err_create:
return ret;
}
static void __devexit etm_sysfs_exit(void)
{
- sysfs_remove_group(etm.kobj, &etm_attr_grp);
- sysfs_remove_file(etm.kobj, &dev_attr_enabled.attr);
- kobject_put(etm.kobj);
+ sysfs_remove_group(drvdata->kobj, &etm_attr_grp);
+ sysfs_remove_file(drvdata->kobj, &dev_attr_enabled.attr);
+ kobject_put(drvdata->kobj);
}
static bool __devinit etm_arch_supported(uint8_t arch)
@@ -1437,9 +1422,9 @@
return true;
}
-static int __devinit etm_arch_init(void)
+static int __devinit etm_init_arch_data(void)
{
- int ret, i;
+ int ret;
/* use cpu 0 for setup */
int cpu = 0;
uint32_t etmidr;
@@ -1457,33 +1442,19 @@
etm_set_prog(cpu);
/* find all capabilities */
- etmidr = etm_readl(etm, cpu, ETMIDR);
- etm.arch = BMVAL(etmidr, 4, 11);
- if (etm_arch_supported(etm.arch) == false) {
+ etmidr = etm_readl(drvdata, cpu, ETMIDR);
+ drvdata->arch = BMVAL(etmidr, 4, 11);
+ if (etm_arch_supported(drvdata->arch) == false) {
ret = -EINVAL;
goto err;
}
- etmccr = etm_readl(etm, cpu, ETMCCR);
- etm.nr_addr_cmp = BMVAL(etmccr, 0, 3) * 2;
- etm.nr_cntr = BMVAL(etmccr, 13, 15);
- etm.nr_ext_inp = BMVAL(etmccr, 17, 19);
- etm.nr_ext_out = BMVAL(etmccr, 20, 22);
- etm.nr_ctxid_cmp = BMVAL(etmccr, 24, 25);
-
- if (cpu_is_krait_v1()) {
- /* Krait pass1 doesn't support include filtering and non-cycle
- * accurate tracing
- */
- etm.mode = (ETM_MODE_EXCLUDE | ETM_MODE_CYCACC);
- etm.ctrl = 0x1000;
- etm.enable_ctrl1 = 0x1000000;
- for (i = 0; i < etm.nr_addr_cmp; i++) {
- etm.addr_val[i] = 0x0;
- etm.addr_acctype[i] = 0x0;
- etm.addr_type[i] = ETM_ADDR_TYPE_NONE;
- }
- }
+ etmccr = etm_readl(drvdata, cpu, ETMCCR);
+ drvdata->nr_addr_cmp = BMVAL(etmccr, 0, 3) * 2;
+ drvdata->nr_cntr = BMVAL(etmccr, 13, 15);
+ drvdata->nr_ext_inp = BMVAL(etmccr, 17, 19);
+ drvdata->nr_ext_out = BMVAL(etmccr, 20, 22);
+ drvdata->nr_ctxid_cmp = BMVAL(etmccr, 24, 25);
/* Vote for ETM power/clock disable */
etm_set_pwrdwn(cpu);
@@ -1494,62 +1465,113 @@
return ret;
}
+static void __devinit etm_init_default_data(void)
+{
+ int i;
+
+ drvdata->trigger_event = 0x406F;
+ drvdata->enable_event = 0x6F;
+ drvdata->enable_ctrl1 = 0x1;
+ drvdata->fifofull_level = 0x28;
+ if (drvdata->nr_addr_cmp >= 2) {
+ drvdata->addr_val[0] = (uint32_t) _stext;
+ drvdata->addr_val[1] = (uint32_t) _etext;
+ drvdata->addr_type[0] = ETM_ADDR_TYPE_RANGE;
+ drvdata->addr_type[1] = ETM_ADDR_TYPE_RANGE;
+ }
+ for (i = 0; i < drvdata->nr_cntr; i++) {
+ drvdata->cntr_event[i] = 0x406F;
+ drvdata->cntr_rld_event[i] = 0x406F;
+ }
+ drvdata->seq_12_event = 0x406F;
+ drvdata->seq_21_event = 0x406F;
+ drvdata->seq_23_event = 0x406F;
+ drvdata->seq_31_event = 0x406F;
+ drvdata->seq_32_event = 0x406F;
+ drvdata->seq_13_event = 0x406F;
+ drvdata->sync_freq = 0x80;
+ drvdata->timestamp_event = 0x406F;
+
+ /* Overrides for Krait pass1 */
+ if (cpu_is_krait_v1()) {
+ /* Krait pass1 doesn't support include filtering and non-cycle
+ * accurate tracing
+ */
+ drvdata->mode = (ETM_MODE_EXCLUDE | ETM_MODE_CYCACC);
+ drvdata->ctrl = 0x1000;
+ drvdata->enable_ctrl1 = 0x1000000;
+ for (i = 0; i < drvdata->nr_addr_cmp; i++) {
+ drvdata->addr_val[i] = 0x0;
+ drvdata->addr_acctype[i] = 0x0;
+ drvdata->addr_type[i] = ETM_ADDR_TYPE_NONE;
+ }
+ }
+}
+
static int __devinit etm_probe(struct platform_device *pdev)
{
int ret;
struct resource *res;
+ drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+ if (!drvdata) {
+ ret = -ENOMEM;
+ goto err_kzalloc_drvdata;
+ }
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
ret = -EINVAL;
goto err_res;
}
- etm.base = ioremap_nocache(res->start, resource_size(res));
- if (!etm.base) {
+ drvdata->base = ioremap_nocache(res->start, resource_size(res));
+ if (!drvdata->base) {
ret = -EINVAL;
goto err_ioremap;
}
- etm.dev = &pdev->dev;
+ drvdata->dev = &pdev->dev;
- mutex_init(&etm.mutex);
- wake_lock_init(&etm.wake_lock, WAKE_LOCK_SUSPEND, "msm_etm");
- pm_qos_add_request(&etm.qos_req, PM_QOS_CPU_DMA_LATENCY,
- PM_QOS_DEFAULT_VALUE);
- etm.src = qdss_get("msm_etm");
- if (IS_ERR(etm.src)) {
- ret = PTR_ERR(etm.src);
+ mutex_init(&drvdata->mutex);
+ wake_lock_init(&drvdata->wake_lock, WAKE_LOCK_SUSPEND, "msm_etm");
+ pm_qos_add_request(&drvdata->qos_req, PM_QOS_CPU_DMA_LATENCY,
+ PM_QOS_DEFAULT_VALUE);
+ drvdata->src = qdss_get("msm_etm");
+ if (IS_ERR(drvdata->src)) {
+ ret = PTR_ERR(drvdata->src);
goto err_qdssget;
}
- etm.clk = clk_get(etm.dev, "core_clk");
- if (IS_ERR(etm.clk)) {
- ret = PTR_ERR(etm.clk);
+ drvdata->clk = clk_get(drvdata->dev, "core_clk");
+ if (IS_ERR(drvdata->clk)) {
+ ret = PTR_ERR(drvdata->clk);
goto err_clk_get;
}
- ret = clk_set_rate(etm.clk, CS_CLK_RATE_TRACE);
+ ret = clk_set_rate(drvdata->clk, CS_CLK_RATE_TRACE);
if (ret)
goto err_clk_rate;
- ret = clk_prepare_enable(etm.clk);
+ ret = clk_prepare_enable(drvdata->clk);
if (ret)
goto err_clk_enable;
- ret = etm_arch_init();
+ ret = etm_init_arch_data();
if (ret)
goto err_arch;
+ etm_init_default_data();
+
ret = etm_sysfs_init();
if (ret)
goto err_sysfs;
- etm.enabled = false;
+ drvdata->enabled = false;
- clk_disable_unprepare(etm.clk);
+ clk_disable_unprepare(drvdata->clk);
- dev_info(etm.dev, "ETM initialized\n");
+ dev_info(drvdata->dev, "ETM initialized\n");
if (etm_boot_enable)
etm_enable();
@@ -1558,34 +1580,37 @@
err_sysfs:
err_arch:
- clk_disable_unprepare(etm.clk);
+ clk_disable_unprepare(drvdata->clk);
err_clk_enable:
err_clk_rate:
- clk_put(etm.clk);
+ clk_put(drvdata->clk);
err_clk_get:
- qdss_put(etm.src);
+ qdss_put(drvdata->src);
err_qdssget:
- pm_qos_remove_request(&etm.qos_req);
- wake_lock_destroy(&etm.wake_lock);
- mutex_destroy(&etm.mutex);
- iounmap(etm.base);
+ pm_qos_remove_request(&drvdata->qos_req);
+ wake_lock_destroy(&drvdata->wake_lock);
+ mutex_destroy(&drvdata->mutex);
+ iounmap(drvdata->base);
err_ioremap:
err_res:
- dev_err(etm.dev, "ETM init failed\n");
+ kfree(drvdata);
+err_kzalloc_drvdata:
+ dev_err(drvdata->dev, "ETM init failed\n");
return ret;
}
static int __devexit etm_remove(struct platform_device *pdev)
{
- if (etm.enabled)
+ if (drvdata->enabled)
etm_disable();
etm_sysfs_exit();
- clk_put(etm.clk);
- qdss_put(etm.src);
- pm_qos_remove_request(&etm.qos_req);
- wake_lock_destroy(&etm.wake_lock);
- mutex_destroy(&etm.mutex);
- iounmap(etm.base);
+ clk_put(drvdata->clk);
+ qdss_put(drvdata->src);
+ pm_qos_remove_request(&drvdata->qos_req);
+ wake_lock_destroy(&drvdata->wake_lock);
+ mutex_destroy(&drvdata->mutex);
+ iounmap(drvdata->base);
+ kfree(drvdata);
return 0;
}
diff --git a/drivers/cs/cs-funnel.c b/drivers/cs/cs-funnel.c
index 414023d..2317e90 100644
--- a/drivers/cs/cs-funnel.c
+++ b/drivers/cs/cs-funnel.c
@@ -18,15 +18,16 @@
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/err.h>
+#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/cs.h>
#include "cs-priv.h"
-#define funnel_writel(funnel, id, val, off) \
- __raw_writel((val), funnel.base + (SZ_4K * id) + off)
-#define funnel_readl(funnel, id, off) \
- __raw_readl(funnel.base + (SZ_4K * id) + off)
+#define funnel_writel(drvdata, id, val, off) \
+ __raw_writel((val), drvdata->base + (SZ_4K * id) + off)
+#define funnel_readl(drvdata, id, off) \
+ __raw_readl(drvdata->base + (SZ_4K * id) + off)
#define FUNNEL_FUNCTL (0x000)
#define FUNNEL_PRICTL (0x004)
@@ -39,11 +40,11 @@
#define FUNNEL_LOCK(id) \
do { \
mb(); \
- funnel_writel(funnel, id, 0x0, CS_LAR); \
+ funnel_writel(drvdata, id, 0x0, CS_LAR); \
} while (0)
#define FUNNEL_UNLOCK(id) \
do { \
- funnel_writel(funnel, id, CS_UNLOCK_MAGIC, CS_LAR); \
+ funnel_writel(drvdata, id, CS_UNLOCK_MAGIC, CS_LAR); \
mb(); \
} while (0)
@@ -51,7 +52,7 @@
#define FUNNEL_HOLDTIME_SHFT (0x8)
#define FUNNEL_HOLDTIME (0x7 << FUNNEL_HOLDTIME_SHFT)
-struct funnel_ctx {
+struct funnel_drvdata {
void __iomem *base;
bool enabled;
struct mutex mutex;
@@ -61,7 +62,7 @@
uint32_t priority;
};
-static struct funnel_ctx funnel;
+static struct funnel_drvdata *drvdata;
static void __funnel_enable(uint8_t id, uint32_t port_mask)
{
@@ -69,12 +70,12 @@
FUNNEL_UNLOCK(id);
- functl = funnel_readl(funnel, id, FUNNEL_FUNCTL);
+ functl = funnel_readl(drvdata, id, FUNNEL_FUNCTL);
functl &= ~FUNNEL_HOLDTIME_MASK;
functl |= FUNNEL_HOLDTIME;
functl |= port_mask;
- funnel_writel(funnel, id, functl, FUNNEL_FUNCTL);
- funnel_writel(funnel, id, funnel.priority, FUNNEL_PRICTL);
+ funnel_writel(drvdata, id, functl, FUNNEL_FUNCTL);
+ funnel_writel(drvdata, id, drvdata->priority, FUNNEL_PRICTL);
FUNNEL_LOCK(id);
}
@@ -83,16 +84,16 @@
{
int ret;
- ret = clk_prepare_enable(funnel.clk);
+ ret = clk_prepare_enable(drvdata->clk);
if (ret)
return ret;
- mutex_lock(&funnel.mutex);
+ mutex_lock(&drvdata->mutex);
__funnel_enable(id, port_mask);
- funnel.enabled = true;
- dev_info(funnel.dev, "FUNNEL port mask 0x%lx enabled\n",
+ drvdata->enabled = true;
+ dev_info(drvdata->dev, "FUNNEL port mask 0x%lx enabled\n",
(unsigned long) port_mask);
- mutex_unlock(&funnel.mutex);
+ mutex_unlock(&drvdata->mutex);
return 0;
}
@@ -103,29 +104,29 @@
FUNNEL_UNLOCK(id);
- functl = funnel_readl(funnel, id, FUNNEL_FUNCTL);
+ functl = funnel_readl(drvdata, id, FUNNEL_FUNCTL);
functl &= ~port_mask;
- funnel_writel(funnel, id, functl, FUNNEL_FUNCTL);
+ funnel_writel(drvdata, id, functl, FUNNEL_FUNCTL);
FUNNEL_LOCK(id);
}
void funnel_disable(uint8_t id, uint32_t port_mask)
{
- mutex_lock(&funnel.mutex);
+ mutex_lock(&drvdata->mutex);
__funnel_disable(id, port_mask);
- funnel.enabled = false;
- dev_info(funnel.dev, "FUNNEL port mask 0x%lx disabled\n",
+ drvdata->enabled = false;
+ dev_info(drvdata->dev, "FUNNEL port mask 0x%lx disabled\n",
(unsigned long) port_mask);
- mutex_unlock(&funnel.mutex);
+ mutex_unlock(&drvdata->mutex);
- clk_disable_unprepare(funnel.clk);
+ clk_disable_unprepare(drvdata->clk);
}
static ssize_t funnel_show_priority(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = funnel.priority;
+ unsigned long val = drvdata->priority;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -138,7 +139,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- funnel.priority = val;
+ drvdata->priority = val;
return size;
}
static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, funnel_show_priority,
@@ -148,31 +149,31 @@
{
int ret;
- funnel.kobj = kobject_create_and_add("funnel", qdss_get_modulekobj());
- if (!funnel.kobj) {
- dev_err(funnel.dev, "failed to create FUNNEL sysfs kobject\n");
+ drvdata->kobj = kobject_create_and_add("funnel", qdss_get_modulekobj());
+ if (!drvdata->kobj) {
+ dev_err(drvdata->dev, "failed to create FUNNEL sysfs kobject\n");
ret = -ENOMEM;
goto err_create;
}
- ret = sysfs_create_file(funnel.kobj, &dev_attr_priority.attr);
+ ret = sysfs_create_file(drvdata->kobj, &dev_attr_priority.attr);
if (ret) {
- dev_err(funnel.dev, "failed to create FUNNEL sysfs priority"
+ dev_err(drvdata->dev, "failed to create FUNNEL sysfs priority"
" attribute\n");
goto err_file;
}
return 0;
err_file:
- kobject_put(funnel.kobj);
+ kobject_put(drvdata->kobj);
err_create:
return ret;
}
static void __devexit funnel_sysfs_exit(void)
{
- sysfs_remove_file(funnel.kobj, &dev_attr_priority.attr);
- kobject_put(funnel.kobj);
+ sysfs_remove_file(drvdata->kobj, &dev_attr_priority.attr);
+ kobject_put(drvdata->kobj);
}
static int __devinit funnel_probe(struct platform_device *pdev)
@@ -180,56 +181,65 @@
int ret;
struct resource *res;
+ drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+ if (!drvdata) {
+ ret = -ENOMEM;
+ goto err_kzalloc_drvdata;
+ }
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
ret = -EINVAL;
goto err_res;
}
- funnel.base = ioremap_nocache(res->start, resource_size(res));
- if (!funnel.base) {
+ drvdata->base = ioremap_nocache(res->start, resource_size(res));
+ if (!drvdata->base) {
ret = -EINVAL;
goto err_ioremap;
}
- funnel.dev = &pdev->dev;
+ drvdata->dev = &pdev->dev;
- mutex_init(&funnel.mutex);
+ mutex_init(&drvdata->mutex);
- funnel.clk = clk_get(funnel.dev, "core_clk");
- if (IS_ERR(funnel.clk)) {
- ret = PTR_ERR(funnel.clk);
+ drvdata->clk = clk_get(drvdata->dev, "core_clk");
+ if (IS_ERR(drvdata->clk)) {
+ ret = PTR_ERR(drvdata->clk);
goto err_clk_get;
}
- ret = clk_set_rate(funnel.clk, CS_CLK_RATE_TRACE);
+ ret = clk_set_rate(drvdata->clk, CS_CLK_RATE_TRACE);
if (ret)
goto err_clk_rate;
funnel_sysfs_init();
- dev_info(funnel.dev, "FUNNEL initialized\n");
+ dev_info(drvdata->dev, "FUNNEL initialized\n");
return 0;
err_clk_rate:
- clk_put(funnel.clk);
+ clk_put(drvdata->clk);
err_clk_get:
- mutex_destroy(&funnel.mutex);
- iounmap(funnel.base);
+ mutex_destroy(&drvdata->mutex);
+ iounmap(drvdata->base);
err_ioremap:
err_res:
- dev_err(funnel.dev, "FUNNEL init failed\n");
+ kfree(drvdata);
+err_kzalloc_drvdata:
+ dev_err(drvdata->dev, "FUNNEL init failed\n");
return ret;
}
static int __devexit funnel_remove(struct platform_device *pdev)
{
- if (funnel.enabled)
+ if (drvdata->enabled)
funnel_disable(0x0, 0xFF);
funnel_sysfs_exit();
- clk_put(funnel.clk);
- mutex_destroy(&funnel.mutex);
- iounmap(funnel.base);
+ clk_put(drvdata->clk);
+ mutex_destroy(&drvdata->mutex);
+ iounmap(drvdata->base);
+ kfree(drvdata);
return 0;
}
diff --git a/drivers/cs/cs-stm.c b/drivers/cs/cs-stm.c
index 8f4b6f8..4444d12 100644
--- a/drivers/cs/cs-stm.c
+++ b/drivers/cs/cs-stm.c
@@ -29,10 +29,10 @@
#include "cs-priv.h"
-#define stm_writel(stm, val, off) \
- __raw_writel((val), stm.base + off)
-#define stm_readl(stm, val, off) \
- __raw_readl(stm.base + off)
+#define stm_writel(drvdata, val, off) \
+ __raw_writel((val), drvdata->base + off)
+#define stm_readl(drvdata, val, off) \
+ __raw_readl(drvdata->base + off)
#define NR_STM_CHANNEL (32)
#define BYTES_PER_CHANNEL (256)
@@ -53,17 +53,17 @@
#define OST_VERSION (0x1)
#define stm_channel_addr(ch) \
- (stm.chs.base + (ch * BYTES_PER_CHANNEL))
+ (drvdata->chs.base + (ch * BYTES_PER_CHANNEL))
#define stm_channel_off(type, opts) (type & ~opts)
#define STM_LOCK() \
do { \
mb(); \
- stm_writel(stm, 0x0, CS_LAR); \
+ stm_writel(drvdata, 0x0, CS_LAR); \
} while (0)
#define STM_UNLOCK() \
do { \
- stm_writel(stm, CS_UNLOCK_MAGIC, CS_LAR); \
+ stm_writel(drvdata, CS_UNLOCK_MAGIC, CS_LAR); \
mb(); \
} while (0)
@@ -93,7 +93,7 @@
unsigned long *bitmap;
};
-struct stm_ctx {
+struct stm_drvdata {
void __iomem *base;
bool enabled;
struct qdss_source *src;
@@ -104,19 +104,16 @@
struct channel_space chs;
};
-static struct stm_ctx stm = {
- .entity = OST_ENTITY_ALL,
-};
-
+static struct stm_drvdata *drvdata;
static void __stm_enable(void)
{
STM_UNLOCK();
- stm_writel(stm, 0x80, STMSYNCR);
- stm_writel(stm, 0xFFFFFFFF, STMSPTER);
- stm_writel(stm, 0xFFFFFFFF, STMSPER);
- stm_writel(stm, 0x30003, STMTCSR);
+ stm_writel(drvdata, 0x80, STMSYNCR);
+ stm_writel(drvdata, 0xFFFFFFFF, STMSPTER);
+ stm_writel(drvdata, 0xFFFFFFFF, STMSPER);
+ stm_writel(drvdata, 0x30003, STMTCSR);
STM_LOCK();
}
@@ -125,29 +122,29 @@
{
int ret;
- if (stm.enabled) {
- dev_err(stm.dev, "STM tracing already enabled\n");
+ if (drvdata->enabled) {
+ dev_err(drvdata->dev, "STM tracing already enabled\n");
ret = -EINVAL;
goto err;
}
- ret = clk_prepare_enable(stm.clk);
+ ret = clk_prepare_enable(drvdata->clk);
if (ret)
goto err_clk;
- ret = qdss_enable(stm.src);
+ ret = qdss_enable(drvdata->src);
if (ret)
goto err_qdss;
__stm_enable();
- stm.enabled = true;
+ drvdata->enabled = true;
- dev_info(stm.dev, "STM tracing enabled\n");
+ dev_info(drvdata->dev, "STM tracing enabled\n");
return 0;
err_qdss:
- clk_disable_unprepare(stm.clk);
+ clk_disable_unprepare(drvdata->clk);
err_clk:
err:
return ret;
@@ -157,9 +154,9 @@
{
STM_UNLOCK();
- stm_writel(stm, 0x30000, STMTCSR);
- stm_writel(stm, 0x0, STMSPER);
- stm_writel(stm, 0x0, STMSPTER);
+ stm_writel(drvdata, 0x30000, STMTCSR);
+ stm_writel(drvdata, 0x0, STMSPER);
+ stm_writel(drvdata, 0x0, STMSPTER);
STM_LOCK();
}
@@ -168,21 +165,21 @@
{
int ret;
- if (!stm.enabled) {
- dev_err(stm.dev, "STM tracing already disabled\n");
+ if (!drvdata->enabled) {
+ dev_err(drvdata->dev, "STM tracing already disabled\n");
ret = -EINVAL;
goto err;
}
__stm_disable();
- stm.enabled = false;
+ drvdata->enabled = false;
- qdss_disable(stm.src);
+ qdss_disable(drvdata->src);
- clk_disable_unprepare(stm.clk);
+ clk_disable_unprepare(drvdata->clk);
- dev_info(stm.dev, "STM tracing disabled\n");
+ dev_info(drvdata->dev, "STM tracing disabled\n");
return 0;
err:
@@ -194,15 +191,17 @@
uint32_t ch;
do {
- ch = find_next_zero_bit(stm.chs.bitmap, NR_STM_CHANNEL, off);
- } while ((ch < NR_STM_CHANNEL) && test_and_set_bit(ch, stm.chs.bitmap));
+ ch = find_next_zero_bit(drvdata->chs.bitmap,
+ NR_STM_CHANNEL, off);
+ } while ((ch < NR_STM_CHANNEL) &&
+ test_and_set_bit(ch, drvdata->chs.bitmap));
return ch;
}
static void stm_channel_free(uint32_t ch)
{
- clear_bit(ch, stm.chs.bitmap);
+ clear_bit(ch, drvdata->chs.bitmap);
}
static int stm_send(void *addr, const void *data, uint32_t size)
@@ -346,7 +345,7 @@
const void *data, uint32_t size)
{
/* we don't support sizes more than 24bits (0 to 23) */
- if (!(stm.enabled && (stm.entity & entity_id) &&
+ if (!(drvdata->enabled && (drvdata->entity & entity_id) &&
(size < 0x1000000)))
return 0;
@@ -359,10 +358,10 @@
{
char *buf;
- if (!stm.enabled)
+ if (!drvdata->enabled)
return -EINVAL;
- if (!(stm.entity & OST_ENTITY_DEV_NODE))
+ if (!(drvdata->entity & OST_ENTITY_DEV_NODE))
return size;
if (size > STM_TRACE_BUF_SIZE)
@@ -374,7 +373,7 @@
if (copy_from_user(buf, data, size)) {
kfree(buf);
- dev_dbg(stm.dev, "%s: copy_from_user failed\n", __func__);
+ dev_dbg(drvdata->dev, "%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
@@ -400,7 +399,7 @@
static ssize_t stm_show_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = stm.enabled;
+ unsigned long val = drvdata->enabled;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -429,7 +428,7 @@
static ssize_t stm_show_entity(struct device *dev,
struct device_attribute *attr, char *buf)
{
- unsigned long val = stm.entity;
+ unsigned long val = drvdata->entity;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -442,7 +441,7 @@
if (sscanf(buf, "%lx", &val) != 1)
return -EINVAL;
- stm.entity = val;
+ drvdata->entity = val;
return size;
}
static DEVICE_ATTR(entity, S_IRUGO | S_IWUSR, stm_show_entity,
@@ -452,34 +451,34 @@
{
int ret;
- stm.kobj = kobject_create_and_add("stm", qdss_get_modulekobj());
- if (!stm.kobj) {
- dev_err(stm.dev, "failed to create STM sysfs kobject\n");
+ drvdata->kobj = kobject_create_and_add("stm", qdss_get_modulekobj());
+ if (!drvdata->kobj) {
+ dev_err(drvdata->dev, "failed to create STM sysfs kobject\n");
ret = -ENOMEM;
goto err_create;
}
- ret = sysfs_create_file(stm.kobj, &dev_attr_enabled.attr);
+ ret = sysfs_create_file(drvdata->kobj, &dev_attr_enabled.attr);
if (ret) {
- dev_err(stm.dev, "failed to create STM sysfs enabled attr\n");
+ dev_err(drvdata->dev, "failed to create STM sysfs enabled attr\n");
goto err_file;
}
- if (sysfs_create_file(stm.kobj, &dev_attr_entity.attr))
- dev_err(stm.dev, "failed to create STM sysfs entity attr\n");
+ if (sysfs_create_file(drvdata->kobj, &dev_attr_entity.attr))
+ dev_err(drvdata->dev, "failed to create STM sysfs entity attr\n");
return 0;
err_file:
- kobject_put(stm.kobj);
+ kobject_put(drvdata->kobj);
err_create:
return ret;
}
static void __devexit stm_sysfs_exit(void)
{
- sysfs_remove_file(stm.kobj, &dev_attr_entity.attr);
- sysfs_remove_file(stm.kobj, &dev_attr_enabled.attr);
- kobject_put(stm.kobj);
+ sysfs_remove_file(drvdata->kobj, &dev_attr_entity.attr);
+ sysfs_remove_file(drvdata->kobj, &dev_attr_enabled.attr);
+ kobject_put(drvdata->kobj);
}
static int __devinit stm_probe(struct platform_device *pdev)
@@ -488,14 +487,20 @@
struct resource *res;
size_t res_size, bitmap_size;
+ drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+ if (!drvdata) {
+ ret = -ENOMEM;
+ goto err_kzalloc_drvdata;
+ }
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
ret = -EINVAL;
goto err_res0;
}
- stm.base = ioremap_nocache(res->start, resource_size(res));
- if (!stm.base) {
+ drvdata->base = ioremap_nocache(res->start, resource_size(res));
+ if (!drvdata->base) {
ret = -EINVAL;
goto err_ioremap0;
}
@@ -516,40 +521,42 @@
bitmap_size = NR_STM_CHANNEL * sizeof(long);
}
- stm.chs.bitmap = kzalloc(bitmap_size, GFP_KERNEL);
- if (!stm.chs.bitmap) {
+ drvdata->chs.bitmap = kzalloc(bitmap_size, GFP_KERNEL);
+ if (!drvdata->chs.bitmap) {
ret = -ENOMEM;
goto err_bitmap;
}
- stm.chs.base = ioremap_nocache(res->start, res_size);
- if (!stm.chs.base) {
+ drvdata->chs.base = ioremap_nocache(res->start, res_size);
+ if (!drvdata->chs.base) {
ret = -EINVAL;
goto err_ioremap1;
}
- stm.dev = &pdev->dev;
+ drvdata->dev = &pdev->dev;
ret = misc_register(&stm_misc);
if (ret)
goto err_misc;
- stm.src = qdss_get("msm_stm");
- if (IS_ERR(stm.src)) {
- ret = PTR_ERR(stm.src);
+ drvdata->src = qdss_get("msm_stm");
+ if (IS_ERR(drvdata->src)) {
+ ret = PTR_ERR(drvdata->src);
goto err_qdssget;
}
- stm.clk = clk_get(stm.dev, "core_clk");
- if (IS_ERR(stm.clk)) {
- ret = PTR_ERR(stm.clk);
+ drvdata->clk = clk_get(drvdata->dev, "core_clk");
+ if (IS_ERR(drvdata->clk)) {
+ ret = PTR_ERR(drvdata->clk);
goto err_clk_get;
}
- ret = clk_set_rate(stm.clk, CS_CLK_RATE_TRACE);
+ ret = clk_set_rate(drvdata->clk, CS_CLK_RATE_TRACE);
if (ret)
goto err_clk_rate;
+ drvdata->entity = OST_ENTITY_ALL;
+
ret = stm_sysfs_init();
if (ret)
goto err_sysfs;
@@ -557,40 +564,44 @@
if (stm_boot_enable)
stm_enable();
- dev_info(stm.dev, "STM initialized\n");
+ dev_info(drvdata->dev, "STM initialized\n");
return 0;
err_sysfs:
err_clk_rate:
- clk_put(stm.clk);
+ clk_put(drvdata->clk);
err_clk_get:
- qdss_put(stm.src);
+ qdss_put(drvdata->src);
err_qdssget:
misc_deregister(&stm_misc);
err_misc:
- iounmap(stm.chs.base);
+ iounmap(drvdata->chs.base);
err_ioremap1:
- kfree(stm.chs.bitmap);
+ kfree(drvdata->chs.bitmap);
err_bitmap:
err_res1:
- iounmap(stm.base);
+ iounmap(drvdata->base);
err_ioremap0:
err_res0:
- dev_err(stm.dev, "STM init failed\n");
+ kfree(drvdata);
+err_kzalloc_drvdata:
+
+ dev_err(drvdata->dev, "STM init failed\n");
return ret;
}
static int __devexit stm_remove(struct platform_device *pdev)
{
- if (stm.enabled)
+ if (drvdata->enabled)
stm_disable();
stm_sysfs_exit();
- clk_put(stm.clk);
- qdss_put(stm.src);
+ clk_put(drvdata->clk);
+ qdss_put(drvdata->src);
misc_deregister(&stm_misc);
- iounmap(stm.chs.base);
- kfree(stm.chs.bitmap);
- iounmap(stm.base);
+ iounmap(drvdata->chs.base);
+ kfree(drvdata->chs.bitmap);
+ iounmap(drvdata->base);
+ kfree(drvdata);
return 0;
}
diff --git a/drivers/cs/cs-tpiu.c b/drivers/cs/cs-tpiu.c
index 8191d2c..a8d69a7 100644
--- a/drivers/cs/cs-tpiu.c
+++ b/drivers/cs/cs-tpiu.c
@@ -17,13 +17,14 @@
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/err.h>
+#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/cs.h>
#include "cs-priv.h"
-#define tpiu_writel(tpiu, val, off) __raw_writel((val), tpiu.base + off)
-#define tpiu_readl(tpiu, off) __raw_readl(tpiu.base + off)
+#define tpiu_writel(drvdata, val, off) __raw_writel((val), drvdata->base + off)
+#define tpiu_readl(drvdata, off) __raw_readl(drvdata->base + off)
#define TPIU_SUPP_PORTSZ (0x000)
#define TPIU_CURR_PORTSZ (0x004)
@@ -49,29 +50,29 @@
#define TPIU_LOCK() \
do { \
mb(); \
- tpiu_writel(tpiu, 0x0, CS_LAR); \
+ tpiu_writel(drvdata, 0x0, CS_LAR); \
} while (0)
#define TPIU_UNLOCK() \
do { \
- tpiu_writel(tpiu, CS_UNLOCK_MAGIC, CS_LAR); \
+ tpiu_writel(drvdata, CS_UNLOCK_MAGIC, CS_LAR); \
mb(); \
} while (0)
-struct tpiu_ctx {
+struct tpiu_drvdata {
void __iomem *base;
bool enabled;
struct device *dev;
struct clk *clk;
};
-static struct tpiu_ctx tpiu;
+static struct tpiu_drvdata *drvdata;
static void __tpiu_disable(void)
{
TPIU_UNLOCK();
- tpiu_writel(tpiu, 0x3000, TPIU_FFCR);
- tpiu_writel(tpiu, 0x3040, TPIU_FFCR);
+ tpiu_writel(drvdata, 0x3000, TPIU_FFCR);
+ tpiu_writel(drvdata, 0x3040, TPIU_FFCR);
TPIU_LOCK();
}
@@ -79,8 +80,8 @@
void tpiu_disable(void)
{
__tpiu_disable();
- tpiu.enabled = false;
- dev_info(tpiu.dev, "TPIU disabled\n");
+ drvdata->enabled = false;
+ dev_info(drvdata->dev, "TPIU disabled\n");
}
static int __devinit tpiu_probe(struct platform_device *pdev)
@@ -88,49 +89,58 @@
int ret;
struct resource *res;
+ drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+ if (!drvdata) {
+ ret = -ENOMEM;
+ goto err_kzalloc_drvdata;
+ }
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
ret = -EINVAL;
goto err_res;
}
- tpiu.base = ioremap_nocache(res->start, resource_size(res));
- if (!tpiu.base) {
+ drvdata->base = ioremap_nocache(res->start, resource_size(res));
+ if (!drvdata->base) {
ret = -EINVAL;
goto err_ioremap;
}
- tpiu.dev = &pdev->dev;
+ drvdata->dev = &pdev->dev;
- tpiu.clk = clk_get(tpiu.dev, "core_clk");
- if (IS_ERR(tpiu.clk)) {
- ret = PTR_ERR(tpiu.clk);
+ drvdata->clk = clk_get(drvdata->dev, "core_clk");
+ if (IS_ERR(drvdata->clk)) {
+ ret = PTR_ERR(drvdata->clk);
goto err_clk_get;
}
- ret = clk_set_rate(tpiu.clk, CS_CLK_RATE_TRACE);
+ ret = clk_set_rate(drvdata->clk, CS_CLK_RATE_TRACE);
if (ret)
goto err_clk_rate;
- dev_info(tpiu.dev, "TPIU initialized\n");
+ dev_info(drvdata->dev, "TPIU initialized\n");
return 0;
err_clk_rate:
- clk_put(tpiu.clk);
+ clk_put(drvdata->clk);
err_clk_get:
- iounmap(tpiu.base);
+ iounmap(drvdata->base);
err_ioremap:
err_res:
- dev_err(tpiu.dev, "TPIU init failed\n");
+ kfree(drvdata);
+err_kzalloc_drvdata:
+ dev_err(drvdata->dev, "TPIU init failed\n");
return ret;
}
static int __devexit tpiu_remove(struct platform_device *pdev)
{
- if (tpiu.enabled)
+ if (drvdata->enabled)
tpiu_disable();
- clk_put(tpiu.clk);
- iounmap(tpiu.base);
+ clk_put(drvdata->clk);
+ iounmap(drvdata->base);
+ kfree(drvdata);
return 0;
}