From: Yeoreum Yun <yeoreum.yun@arm.com>
To: Mike Leach <mike.leach@arm.com>,
James Clark <james.clark@linaro.org>, Leo Yan <leo.yan@arm.com>,
Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
Mathieu Poirier <mathieu.poirier@linaro.org>,
coresight@lists.linaro.org,
linux-arm-kernel@lists.infradead.org,
linux-kernel@vger.kernel.org, linux-rt-devel@lists.linux.dev
Cc: Suzuki K Poulose <suzuki.poulose@arm.com>,
Alexander Shishkin <alexander.shishkin@linux.intel.com>,
Sebastian Andrzej Siewior <bigeasy@linutronix.de>,
Clark Williams <clrkwllms@kernel.org>,
Steven Rostedt <rostedt@goodmis.org>,
Yeoreum Yun <yeoreum.yun@arm.com>
Subject: [PATCH v12 11/14] coresight: etm4x: rename drvdata->config to sysfs_config
Date: Thu, 24 Sep 2026 18:33:49 +0100 [thread overview]
Message-ID: <20260924-separate_etm_cfg_v2-v12-11-a2b41d2f7c2b@arm.com> (raw)
In-Reply-To: <20260924-separate_etm_cfg_v2-v12-0-a2b41d2f7c2b@arm.com>
drvdata->config is used only by the sysfs interface.
Rename it to sysfs_config to clarify its purpose.
For readability, also rename local config variables to sysfs_config
where they refer to drvdata->sysfs_config.
Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
---
drivers/hwtracing/coresight/coresight-etm4x-core.c | 10 +-
.../hwtracing/coresight/coresight-etm4x-sysfs.c | 775 +++++++++++----------
drivers/hwtracing/coresight/coresight-etm4x.h | 4 +-
3 files changed, 395 insertions(+), 394 deletions(-)
diff --git a/drivers/hwtracing/coresight/coresight-etm4x-core.c b/drivers/hwtracing/coresight/coresight-etm4x-core.c
index 5db11309bfbb..2a4751a75382 100644
--- a/drivers/hwtracing/coresight/coresight-etm4x-core.c
+++ b/drivers/hwtracing/coresight/coresight-etm4x-core.c
@@ -960,7 +960,7 @@ static int etm4_enable_sysfs(struct coresight_device *csdev, struct coresight_pa
arg.path = path;
scoped_guard(raw_spinlock, &drvdata->spinlock) {
- drvdata->curr_config = drvdata->config;
+ drvdata->curr_config = drvdata->sysfs_config;
}
ret = smp_call_function_single(drvdata->cpu,
@@ -1153,7 +1153,7 @@ static void etm4_disable_sysfs(struct coresight_device *csdev)
{
struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
const struct etmv4_config *curr_config = &drvdata->curr_config;
int i;
@@ -1169,9 +1169,9 @@ static void etm4_disable_sysfs(struct coresight_device *csdev)
* the sysfs-session has been disabled.
*/
for (i = 0; i < caps->nr_cntr; i++)
- config->cntr_val[i] = curr_config->cntr_val[i];
+ sysfs_config->cntr_val[i] = curr_config->cntr_val[i];
- config->seq_state = curr_config->seq_state;
+ sysfs_config->seq_state = curr_config->seq_state;
coresight_set_mode(drvdata->csdev, CS_MODE_DISABLED);
@@ -2214,7 +2214,7 @@ static int etm4_add_coresight_dev(struct etm4_init_arg *init_arg)
if (!desc.name)
return -ENOMEM;
- etm4_set_default(&drvdata->config, caps);
+ etm4_set_default(&drvdata->sysfs_config, caps);
if (etm4x_always_pm_save(dev, init_arg->csa))
pm_save = true;
diff --git a/drivers/hwtracing/coresight/coresight-etm4x-sysfs.c b/drivers/hwtracing/coresight/coresight-etm4x-sysfs.c
index 8f5ea8edf5d8..9dadf2c6f1be 100644
--- a/drivers/hwtracing/coresight/coresight-etm4x-sysfs.c
+++ b/drivers/hwtracing/coresight/coresight-etm4x-sysfs.c
@@ -16,15 +16,15 @@
static int etm4_set_mode_exclude(struct etmv4_drvdata *drvdata, bool exclude)
{
u8 idx;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
/*
* TRCACATRn.TYPE bit[1:0]: type of comparison
* the trace unit performs
*/
- if (FIELD_GET(TRCACATRn_TYPE_MASK, config->addr_acc[idx]) == TRCACATRn_TYPE_ADDR) {
+ if (FIELD_GET(TRCACATRn_TYPE_MASK, sysfs_config->addr_acc[idx]) == TRCACATRn_TYPE_ADDR) {
if (idx % 2 != 0)
return -EINVAL;
@@ -33,8 +33,8 @@ static int etm4_set_mode_exclude(struct etmv4_drvdata *drvdata, bool exclude)
* relevant bit of ViewInst Include/Exclude Control register
* for corresponding address comparator pair.
*/
- if (config->addr_type[idx] != ETM_ADDR_TYPE_RANGE ||
- config->addr_type[idx + 1] != ETM_ADDR_TYPE_RANGE)
+ if (sysfs_config->addr_type[idx] != ETM_ADDR_TYPE_RANGE ||
+ sysfs_config->addr_type[idx + 1] != ETM_ADDR_TYPE_RANGE)
return -EINVAL;
if (exclude == true) {
@@ -42,15 +42,15 @@ static int etm4_set_mode_exclude(struct etmv4_drvdata *drvdata, bool exclude)
* Set exclude bit and unset the include bit
* corresponding to comparator pair
*/
- config->viiectlr |= BIT(idx / 2 + 16);
- config->viiectlr &= ~BIT(idx / 2);
+ sysfs_config->viiectlr |= BIT(idx / 2 + 16);
+ sysfs_config->viiectlr &= ~BIT(idx / 2);
} else {
/*
* Set include bit and unset exclude bit
* corresponding to comparator pair
*/
- config->viiectlr |= BIT(idx / 2);
- config->viiectlr &= ~BIT(idx / 2 + 16);
+ sysfs_config->viiectlr |= BIT(idx / 2);
+ sysfs_config->viiectlr &= ~BIT(idx / 2 + 16);
}
}
return 0;
@@ -181,102 +181,102 @@ static ssize_t reset_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
if (val)
- config->mode = 0x0;
+ sysfs_config->mode = 0x0;
/* Disable data tracing: do not trace load and store data transfers */
- config->mode &= ~(ETM_MODE_LOAD | ETM_MODE_STORE);
- config->cfg &= ~(TRCCONFIGR_INSTP0_LOAD | TRCCONFIGR_INSTP0_STORE);
+ sysfs_config->mode &= ~(ETM_MODE_LOAD | ETM_MODE_STORE);
+ sysfs_config->cfg &= ~(TRCCONFIGR_INSTP0_LOAD | TRCCONFIGR_INSTP0_STORE);
/* Disable data value and data address tracing */
- config->mode &= ~(ETM_MODE_DATA_TRACE_ADDR |
+ sysfs_config->mode &= ~(ETM_MODE_DATA_TRACE_ADDR |
ETM_MODE_DATA_TRACE_VAL);
- config->cfg &= ~(TRCCONFIGR_DA | TRCCONFIGR_DV);
+ sysfs_config->cfg &= ~(TRCCONFIGR_DA | TRCCONFIGR_DV);
/* Disable all events tracing */
- config->eventctrl0 = 0x0;
- config->eventctrl1 = 0x0;
+ sysfs_config->eventctrl0 = 0x0;
+ sysfs_config->eventctrl1 = 0x0;
/* Disable timestamp event */
- config->ts_ctrl = 0x0;
+ sysfs_config->ts_ctrl = 0x0;
/* Disable stalling */
- config->stall_ctrl = 0x0;
+ sysfs_config->stall_ctrl = 0x0;
/* Reset trace synchronization period to 2^8 = 256 bytes*/
if (!caps->syncpr)
- config->syncfreq = 0x8;
+ sysfs_config->syncfreq = 0x8;
/*
* Enable ViewInst to trace everything with start-stop logic in
* started state. ARM recommends start-stop logic is set before
* each trace run.
*/
- config->vinst_ctrl = FIELD_PREP(TRCVICTLR_EVENT_MASK, 0x01);
+ sysfs_config->vinst_ctrl = FIELD_PREP(TRCVICTLR_EVENT_MASK, 0x01);
if (caps->nr_addr_cmp > 0) {
- config->mode |= ETM_MODE_VIEWINST_STARTSTOP;
+ sysfs_config->mode |= ETM_MODE_VIEWINST_STARTSTOP;
/* SSSTATUS, bit[9] */
- config->vinst_ctrl |= TRCVICTLR_SSSTATUS;
+ sysfs_config->vinst_ctrl |= TRCVICTLR_SSSTATUS;
}
/* No address range filtering for ViewInst */
- config->viiectlr = 0x0;
+ sysfs_config->viiectlr = 0x0;
/* No start-stop filtering for ViewInst */
- config->vissctlr = 0x0;
- config->vipcssctlr = 0x0;
+ sysfs_config->vissctlr = 0x0;
+ sysfs_config->vipcssctlr = 0x0;
/* Disable seq events */
for (i = 0; i < caps->nr_seq_ctrls; i++)
- config->seq_ctrl[i] = 0x0;
- config->seq_rst = 0x0;
- config->seq_state = 0x0;
+ sysfs_config->seq_ctrl[i] = 0x0;
+ sysfs_config->seq_rst = 0x0;
+ sysfs_config->seq_state = 0x0;
/* Disable external input events */
- config->ext_inp = 0x0;
+ sysfs_config->ext_inp = 0x0;
- config->cntr_idx = 0x0;
+ sysfs_config->cntr_idx = 0x0;
for (i = 0; i < caps->nr_cntr; i++) {
- config->cntrldvr[i] = 0x0;
- config->cntr_ctrl[i] = 0x0;
- config->cntr_val[i] = 0x0;
+ sysfs_config->cntrldvr[i] = 0x0;
+ sysfs_config->cntr_ctrl[i] = 0x0;
+ sysfs_config->cntr_val[i] = 0x0;
}
- config->res_idx = 0x0;
+ sysfs_config->res_idx = 0x0;
for (i = 2; i < 2 * caps->nr_resource; i++)
- config->res_ctrl[i] = 0x0;
+ sysfs_config->res_ctrl[i] = 0x0;
- config->ss_idx = 0x0;
+ sysfs_config->ss_idx = 0x0;
for (i = 0; i < caps->nr_ss_cmp; i++) {
- config->ss_ctrl[i] = 0x0;
- config->ss_pe_cmp[i] = 0x0;
+ sysfs_config->ss_ctrl[i] = 0x0;
+ sysfs_config->ss_pe_cmp[i] = 0x0;
}
- config->addr_idx = 0x0;
+ sysfs_config->addr_idx = 0x0;
for (i = 0; i < caps->nr_addr_cmp * 2; i++) {
- config->addr_val[i] = 0x0;
- config->addr_acc[i] = 0x0;
- config->addr_type[i] = ETM_ADDR_TYPE_NONE;
+ sysfs_config->addr_val[i] = 0x0;
+ sysfs_config->addr_acc[i] = 0x0;
+ sysfs_config->addr_type[i] = ETM_ADDR_TYPE_NONE;
}
- config->ctxid_idx = 0x0;
+ sysfs_config->ctxid_idx = 0x0;
for (i = 0; i < caps->numcidc; i++)
- config->ctxid_pid[i] = 0x0;
+ sysfs_config->ctxid_pid[i] = 0x0;
- config->ctxid_mask0 = 0x0;
- config->ctxid_mask1 = 0x0;
+ sysfs_config->ctxid_mask0 = 0x0;
+ sysfs_config->ctxid_mask1 = 0x0;
- config->vmid_idx = 0x0;
+ sysfs_config->vmid_idx = 0x0;
for (i = 0; i < caps->numvmidc; i++)
- config->vmid_val[i] = 0x0;
- config->vmid_mask0 = 0x0;
- config->vmid_mask1 = 0x0;
+ sysfs_config->vmid_val[i] = 0x0;
+ sysfs_config->vmid_mask0 = 0x0;
+ sysfs_config->vmid_mask1 = 0x0;
raw_spin_unlock(&drvdata->spinlock);
@@ -295,9 +295,9 @@ static ssize_t mode_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->mode;
+ val = sysfs_config->mode;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -308,142 +308,142 @@ static ssize_t mode_store(struct device *dev,
unsigned long val, mode;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- config->mode = val & ETMv4_MODE_ALL;
+ sysfs_config->mode = val & ETMv4_MODE_ALL;
if (caps->instrp0) {
/* start by clearing instruction P0 field */
- config->cfg &= ~TRCCONFIGR_INSTP0_LOAD_STORE;
- if (config->mode & ETM_MODE_LOAD)
+ sysfs_config->cfg &= ~TRCCONFIGR_INSTP0_LOAD_STORE;
+ if (sysfs_config->mode & ETM_MODE_LOAD)
/* 0b01 Trace load instructions as P0 instructions */
- config->cfg |= TRCCONFIGR_INSTP0_LOAD;
- if (config->mode & ETM_MODE_STORE)
+ sysfs_config->cfg |= TRCCONFIGR_INSTP0_LOAD;
+ if (sysfs_config->mode & ETM_MODE_STORE)
/* 0b10 Trace store instructions as P0 instructions */
- config->cfg |= TRCCONFIGR_INSTP0_STORE;
- if (config->mode & ETM_MODE_LOAD_STORE)
+ sysfs_config->cfg |= TRCCONFIGR_INSTP0_STORE;
+ if (sysfs_config->mode & ETM_MODE_LOAD_STORE)
/*
* 0b11 Trace load and store instructions
* as P0 instructions
*/
- config->cfg |= TRCCONFIGR_INSTP0_LOAD_STORE;
+ sysfs_config->cfg |= TRCCONFIGR_INSTP0_LOAD_STORE;
}
/* bit[3], Branch broadcast mode */
- if ((config->mode & ETM_MODE_BB) && (caps->trcbb))
- config->cfg |= TRCCONFIGR_BB;
+ if ((sysfs_config->mode & ETM_MODE_BB) && (caps->trcbb))
+ sysfs_config->cfg |= TRCCONFIGR_BB;
else
- config->cfg &= ~TRCCONFIGR_BB;
+ sysfs_config->cfg &= ~TRCCONFIGR_BB;
/* bit[4], Cycle counting instruction trace bit */
- if ((config->mode & ETMv4_MODE_CYCACC) &&
+ if ((sysfs_config->mode & ETMv4_MODE_CYCACC) &&
(caps->trccci == true))
- config->cfg |= TRCCONFIGR_CCI;
+ sysfs_config->cfg |= TRCCONFIGR_CCI;
else
- config->cfg &= ~TRCCONFIGR_CCI;
+ sysfs_config->cfg &= ~TRCCONFIGR_CCI;
/* bit[6], Context ID tracing bit */
- if ((config->mode & ETMv4_MODE_CTXID) && (caps->ctxid_size))
- config->cfg |= TRCCONFIGR_CID;
+ if ((sysfs_config->mode & ETMv4_MODE_CTXID) && (caps->ctxid_size))
+ sysfs_config->cfg |= TRCCONFIGR_CID;
else
- config->cfg &= ~TRCCONFIGR_CID;
+ sysfs_config->cfg &= ~TRCCONFIGR_CID;
- if ((config->mode & ETM_MODE_VMID) && (caps->vmid_size))
- config->cfg |= TRCCONFIGR_VMID;
+ if ((sysfs_config->mode & ETM_MODE_VMID) && (caps->vmid_size))
+ sysfs_config->cfg |= TRCCONFIGR_VMID;
else
- config->cfg &= ~TRCCONFIGR_VMID;
+ sysfs_config->cfg &= ~TRCCONFIGR_VMID;
/* bits[10:8], Conditional instruction tracing bit */
- mode = ETM_MODE_COND(config->mode);
+ mode = ETM_MODE_COND(sysfs_config->mode);
if (caps->trccond) {
- config->cfg &= ~TRCCONFIGR_COND_MASK;
- config->cfg |= mode << __bf_shf(TRCCONFIGR_COND_MASK);
+ sysfs_config->cfg &= ~TRCCONFIGR_COND_MASK;
+ sysfs_config->cfg |= mode << __bf_shf(TRCCONFIGR_COND_MASK);
}
/* bit[11], Global timestamp tracing bit */
- if ((config->mode & ETMv4_MODE_TIMESTAMP) && (caps->ts_size))
- config->cfg |= TRCCONFIGR_TS;
+ if ((sysfs_config->mode & ETMv4_MODE_TIMESTAMP) && (caps->ts_size))
+ sysfs_config->cfg |= TRCCONFIGR_TS;
else
- config->cfg &= ~TRCCONFIGR_TS;
+ sysfs_config->cfg &= ~TRCCONFIGR_TS;
/* bit[12], Return stack enable bit */
- if ((config->mode & ETM_MODE_RETURNSTACK) && (caps->retstack))
- config->cfg |= TRCCONFIGR_RS;
+ if ((sysfs_config->mode & ETM_MODE_RETURNSTACK) && (caps->retstack))
+ sysfs_config->cfg |= TRCCONFIGR_RS;
else
- config->cfg &= ~TRCCONFIGR_RS;
+ sysfs_config->cfg &= ~TRCCONFIGR_RS;
/* bits[14:13], Q element enable field */
- mode = ETM_MODE_QELEM(config->mode);
+ mode = ETM_MODE_QELEM(sysfs_config->mode);
/* start by clearing QE bits */
- config->cfg &= ~(TRCCONFIGR_QE_W_COUNTS | TRCCONFIGR_QE_WO_COUNTS);
+ sysfs_config->cfg &= ~(TRCCONFIGR_QE_W_COUNTS | TRCCONFIGR_QE_WO_COUNTS);
/*
* if supported, Q elements with instruction counts are enabled.
* Always set the low bit for any requested mode. Valid combos are
* 0b00, 0b01 and 0b11.
*/
if (mode && caps->q_support)
- config->cfg |= TRCCONFIGR_QE_W_COUNTS;
+ sysfs_config->cfg |= TRCCONFIGR_QE_W_COUNTS;
/*
* if supported, Q elements with and without instruction
* counts are enabled
*/
if ((mode & BIT(1)) && (caps->q_support & BIT(1)))
- config->cfg |= TRCCONFIGR_QE_WO_COUNTS;
+ sysfs_config->cfg |= TRCCONFIGR_QE_WO_COUNTS;
/* bit[11], AMBA Trace Bus (ATB) trigger enable bit */
- if ((config->mode & ETM_MODE_ATB_TRIGGER) && (caps->atbtrig))
- config->eventctrl1 |= TRCEVENTCTL1R_ATB;
+ if ((sysfs_config->mode & ETM_MODE_ATB_TRIGGER) && (caps->atbtrig))
+ sysfs_config->eventctrl1 |= TRCEVENTCTL1R_ATB;
else
- config->eventctrl1 &= ~TRCEVENTCTL1R_ATB;
+ sysfs_config->eventctrl1 &= ~TRCEVENTCTL1R_ATB;
/* bit[12], Low-power state behavior override bit */
- if ((config->mode & ETM_MODE_LPOVERRIDE) && (caps->lpoverride))
- config->eventctrl1 |= TRCEVENTCTL1R_LPOVERRIDE;
+ if ((sysfs_config->mode & ETM_MODE_LPOVERRIDE) && (caps->lpoverride))
+ sysfs_config->eventctrl1 |= TRCEVENTCTL1R_LPOVERRIDE;
else
- config->eventctrl1 &= ~TRCEVENTCTL1R_LPOVERRIDE;
+ sysfs_config->eventctrl1 &= ~TRCEVENTCTL1R_LPOVERRIDE;
/* bit[8], Instruction stall bit */
- if ((config->mode & ETM_MODE_ISTALL_EN) && (caps->stallctl))
- config->stall_ctrl |= TRCSTALLCTLR_ISTALL;
+ if ((sysfs_config->mode & ETM_MODE_ISTALL_EN) && (caps->stallctl))
+ sysfs_config->stall_ctrl |= TRCSTALLCTLR_ISTALL;
else
- config->stall_ctrl &= ~TRCSTALLCTLR_ISTALL;
+ sysfs_config->stall_ctrl &= ~TRCSTALLCTLR_ISTALL;
/* bit[10], Prioritize instruction trace bit */
- if (config->mode & ETM_MODE_INSTPRIO)
- config->stall_ctrl |= TRCSTALLCTLR_INSTPRIORITY;
+ if (sysfs_config->mode & ETM_MODE_INSTPRIO)
+ sysfs_config->stall_ctrl |= TRCSTALLCTLR_INSTPRIORITY;
else
- config->stall_ctrl &= ~TRCSTALLCTLR_INSTPRIORITY;
+ sysfs_config->stall_ctrl &= ~TRCSTALLCTLR_INSTPRIORITY;
/* bit[13], Trace overflow prevention bit */
- if ((config->mode & ETM_MODE_NOOVERFLOW) && (caps->nooverflow))
- config->stall_ctrl |= TRCSTALLCTLR_NOOVERFLOW;
+ if ((sysfs_config->mode & ETM_MODE_NOOVERFLOW) && (caps->nooverflow))
+ sysfs_config->stall_ctrl |= TRCSTALLCTLR_NOOVERFLOW;
else
- config->stall_ctrl &= ~TRCSTALLCTLR_NOOVERFLOW;
+ sysfs_config->stall_ctrl &= ~TRCSTALLCTLR_NOOVERFLOW;
/* bit[9] Start/stop logic control bit */
- if (config->mode & ETM_MODE_VIEWINST_STARTSTOP)
- config->vinst_ctrl |= TRCVICTLR_SSSTATUS;
+ if (sysfs_config->mode & ETM_MODE_VIEWINST_STARTSTOP)
+ sysfs_config->vinst_ctrl |= TRCVICTLR_SSSTATUS;
else
- config->vinst_ctrl &= ~TRCVICTLR_SSSTATUS;
+ sysfs_config->vinst_ctrl &= ~TRCVICTLR_SSSTATUS;
/* bit[10], Whether a trace unit must trace a Reset exception */
- if (config->mode & ETM_MODE_TRACE_RESET)
- config->vinst_ctrl |= TRCVICTLR_TRCRESET;
+ if (sysfs_config->mode & ETM_MODE_TRACE_RESET)
+ sysfs_config->vinst_ctrl |= TRCVICTLR_TRCRESET;
else
- config->vinst_ctrl &= ~TRCVICTLR_TRCRESET;
+ sysfs_config->vinst_ctrl &= ~TRCVICTLR_TRCRESET;
/* bit[11], Whether a trace unit must trace a system error exception */
- if ((config->mode & ETM_MODE_TRACE_ERR) && (caps->trc_error))
- config->vinst_ctrl |= TRCVICTLR_TRCERR;
+ if ((sysfs_config->mode & ETM_MODE_TRACE_ERR) && (caps->trc_error))
+ sysfs_config->vinst_ctrl |= TRCVICTLR_TRCERR;
else
- config->vinst_ctrl &= ~TRCVICTLR_TRCERR;
+ sysfs_config->vinst_ctrl &= ~TRCVICTLR_TRCERR;
- if (config->mode & (ETM_MODE_EXCL_KERN | ETM_MODE_EXCL_USER))
- etm4_config_trace_mode(config, caps);
+ if (sysfs_config->mode & (ETM_MODE_EXCL_KERN | ETM_MODE_EXCL_USER))
+ etm4_config_trace_mode(sysfs_config, caps);
raw_spin_unlock(&drvdata->spinlock);
@@ -457,9 +457,9 @@ static ssize_t pe_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->pe_sel;
+ val = sysfs_config->pe_sel;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -470,7 +470,7 @@ static ssize_t pe_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -481,7 +481,7 @@ static ssize_t pe_store(struct device *dev,
return -EINVAL;
}
- config->pe_sel = val;
+ sysfs_config->pe_sel = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -493,9 +493,9 @@ static ssize_t event_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->eventctrl0;
+ val = sysfs_config->eventctrl0;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -506,7 +506,7 @@ static ssize_t event_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -515,19 +515,19 @@ static ssize_t event_store(struct device *dev,
switch (caps->nr_event) {
case 0x0:
/* EVENT0, bits[7:0] */
- config->eventctrl0 = val & 0xFF;
+ sysfs_config->eventctrl0 = val & 0xFF;
break;
case 0x1:
/* EVENT1, bits[15:8] */
- config->eventctrl0 = val & 0xFFFF;
+ sysfs_config->eventctrl0 = val & 0xFFFF;
break;
case 0x2:
/* EVENT2, bits[23:16] */
- config->eventctrl0 = val & 0xFFFFFF;
+ sysfs_config->eventctrl0 = val & 0xFFFFFF;
break;
case 0x3:
/* EVENT3, bits[31:24] */
- config->eventctrl0 = val;
+ sysfs_config->eventctrl0 = val;
break;
default:
break;
@@ -543,9 +543,9 @@ static ssize_t event_instren_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = FIELD_GET(TRCEVENTCTL1R_INSTEN_MASK, config->eventctrl1);
+ val = FIELD_GET(TRCEVENTCTL1R_INSTEN_MASK, sysfs_config->eventctrl1);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -556,32 +556,33 @@ static ssize_t event_instren_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
/* start by clearing all instruction event enable bits */
- config->eventctrl1 &= ~TRCEVENTCTL1R_INSTEN_MASK;
+ sysfs_config->eventctrl1 &= ~TRCEVENTCTL1R_INSTEN_MASK;
switch (caps->nr_event) {
case 0x0:
/* generate Event element for event 1 */
- config->eventctrl1 |= val & TRCEVENTCTL1R_INSTEN_1;
+ sysfs_config->eventctrl1 |= val & TRCEVENTCTL1R_INSTEN_1;
break;
case 0x1:
/* generate Event element for event 1 and 2 */
- config->eventctrl1 |= val & (TRCEVENTCTL1R_INSTEN_0 | TRCEVENTCTL1R_INSTEN_1);
+ sysfs_config->eventctrl1 |= val & (TRCEVENTCTL1R_INSTEN_0 |
+ TRCEVENTCTL1R_INSTEN_1);
break;
case 0x2:
/* generate Event element for event 1, 2 and 3 */
- config->eventctrl1 |= val & (TRCEVENTCTL1R_INSTEN_0 |
+ sysfs_config->eventctrl1 |= val & (TRCEVENTCTL1R_INSTEN_0 |
TRCEVENTCTL1R_INSTEN_1 |
TRCEVENTCTL1R_INSTEN_2);
break;
case 0x3:
/* generate Event element for all 4 events */
- config->eventctrl1 |= val & (TRCEVENTCTL1R_INSTEN_0 |
+ sysfs_config->eventctrl1 |= val & (TRCEVENTCTL1R_INSTEN_0 |
TRCEVENTCTL1R_INSTEN_1 |
TRCEVENTCTL1R_INSTEN_2 |
TRCEVENTCTL1R_INSTEN_3);
@@ -600,9 +601,9 @@ static ssize_t event_ts_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->ts_ctrl;
+ val = sysfs_config->ts_ctrl;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -613,14 +614,14 @@ static ssize_t event_ts_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
if (!caps->ts_size)
return -EINVAL;
- config->ts_ctrl = val & ETMv4_EVENT_MASK;
+ sysfs_config->ts_ctrl = val & ETMv4_EVENT_MASK;
return size;
}
static DEVICE_ATTR_RW(event_ts);
@@ -631,9 +632,9 @@ static ssize_t syncfreq_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->syncfreq;
+ val = sysfs_config->syncfreq;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -644,14 +645,14 @@ static ssize_t syncfreq_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
if (caps->syncpr)
return -EINVAL;
- config->syncfreq = val & ETMv4_SYNC_MASK;
+ sysfs_config->syncfreq = val & ETMv4_SYNC_MASK;
return size;
}
static DEVICE_ATTR_RW(syncfreq);
@@ -662,9 +663,9 @@ static ssize_t cyc_threshold_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->ccctlr;
+ val = sysfs_config->ccctlr;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -675,7 +676,7 @@ static ssize_t cyc_threshold_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -685,7 +686,7 @@ static ssize_t cyc_threshold_store(struct device *dev,
if (val < caps->ccitmin)
return -EINVAL;
- config->ccctlr = val;
+ sysfs_config->ccctlr = val;
return size;
}
static DEVICE_ATTR_RW(cyc_threshold);
@@ -696,9 +697,9 @@ static ssize_t bb_ctrl_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->bb_ctrl;
+ val = sysfs_config->bb_ctrl;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -709,7 +710,7 @@ static ssize_t bb_ctrl_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -726,7 +727,7 @@ static ssize_t bb_ctrl_store(struct device *dev,
if ((val & TRCBBCTLR_MODE) && (FIELD_GET(TRCBBCTLR_RANGE_MASK, val) == 0))
return -EINVAL;
- config->bb_ctrl = val & (TRCBBCTLR_MODE | TRCBBCTLR_RANGE_MASK);
+ sysfs_config->bb_ctrl = val & (TRCBBCTLR_MODE | TRCBBCTLR_RANGE_MASK);
return size;
}
static DEVICE_ATTR_RW(bb_ctrl);
@@ -737,9 +738,9 @@ static ssize_t event_vinst_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = FIELD_GET(TRCVICTLR_EVENT_MASK, config->vinst_ctrl);
+ val = FIELD_GET(TRCVICTLR_EVENT_MASK, sysfs_config->vinst_ctrl);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -749,15 +750,15 @@ static ssize_t event_vinst_store(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
val &= TRCVICTLR_EVENT_MASK >> __bf_shf(TRCVICTLR_EVENT_MASK);
- config->vinst_ctrl &= ~TRCVICTLR_EVENT_MASK;
- config->vinst_ctrl |= FIELD_PREP(TRCVICTLR_EVENT_MASK, val);
+ sysfs_config->vinst_ctrl &= ~TRCVICTLR_EVENT_MASK;
+ sysfs_config->vinst_ctrl |= FIELD_PREP(TRCVICTLR_EVENT_MASK, val);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -769,9 +770,9 @@ static ssize_t s_exlevel_vinst_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = FIELD_GET(TRCVICTLR_EXLEVEL_S_MASK, config->vinst_ctrl);
+ val = FIELD_GET(TRCVICTLR_EXLEVEL_S_MASK, sysfs_config->vinst_ctrl);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -782,17 +783,17 @@ static ssize_t s_exlevel_vinst_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
/* clear all EXLEVEL_S bits */
- config->vinst_ctrl &= ~TRCVICTLR_EXLEVEL_S_MASK;
+ sysfs_config->vinst_ctrl &= ~TRCVICTLR_EXLEVEL_S_MASK;
/* enable instruction tracing for corresponding exception level */
val &= caps->s_ex_level;
- config->vinst_ctrl |= val << __bf_shf(TRCVICTLR_EXLEVEL_S_MASK);
+ sysfs_config->vinst_ctrl |= val << __bf_shf(TRCVICTLR_EXLEVEL_S_MASK);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -804,10 +805,10 @@ static ssize_t ns_exlevel_vinst_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/* EXLEVEL_NS, bits[23:20] */
- val = FIELD_GET(TRCVICTLR_EXLEVEL_NS_MASK, config->vinst_ctrl);
+ val = FIELD_GET(TRCVICTLR_EXLEVEL_NS_MASK, sysfs_config->vinst_ctrl);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -818,17 +819,17 @@ static ssize_t ns_exlevel_vinst_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
/* clear EXLEVEL_NS bits */
- config->vinst_ctrl &= ~TRCVICTLR_EXLEVEL_NS_MASK;
+ sysfs_config->vinst_ctrl &= ~TRCVICTLR_EXLEVEL_NS_MASK;
/* enable instruction tracing for corresponding exception level */
val &= caps->ns_ex_level;
- config->vinst_ctrl |= val << __bf_shf(TRCVICTLR_EXLEVEL_NS_MASK);
+ sysfs_config->vinst_ctrl |= val << __bf_shf(TRCVICTLR_EXLEVEL_NS_MASK);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -840,9 +841,9 @@ static ssize_t addr_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->addr_idx;
+ val = sysfs_config->addr_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -853,7 +854,7 @@ static ssize_t addr_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -865,7 +866,7 @@ static ssize_t addr_idx_store(struct device *dev,
* dereferenced multiple times within a spinlock block elsewhere.
*/
raw_spin_lock(&drvdata->spinlock);
- config->addr_idx = val;
+ sysfs_config->addr_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -878,11 +879,11 @@ static ssize_t addr_instdatatype_show(struct device *dev,
ssize_t len;
u8 val, idx;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
- val = FIELD_GET(TRCACATRn_TYPE_MASK, config->addr_acc[idx]);
+ idx = sysfs_config->addr_idx;
+ val = FIELD_GET(TRCACATRn_TYPE_MASK, sysfs_config->addr_acc[idx]);
len = scnprintf(buf, PAGE_SIZE, "%s\n",
val == TRCACATRn_TYPE_ADDR ? "instr" :
(val == TRCACATRn_TYPE_DATA_LOAD_ADDR ? "data_load" :
@@ -899,7 +900,7 @@ static ssize_t addr_instdatatype_store(struct device *dev,
u8 idx;
char str[20] = "";
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (strlen(buf) >= 20)
return -EINVAL;
@@ -907,10 +908,10 @@ static ssize_t addr_instdatatype_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
if (!strcmp(str, "instr"))
/* TYPE, bits[1:0] */
- config->addr_acc[idx] &= ~TRCACATRn_TYPE_MASK;
+ sysfs_config->addr_acc[idx] &= ~TRCACATRn_TYPE_MASK;
raw_spin_unlock(&drvdata->spinlock);
return size;
@@ -924,16 +925,16 @@ static ssize_t addr_single_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
raw_spin_lock(&drvdata->spinlock);
- if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
+ if (!(sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- val = (unsigned long)config->addr_val[idx];
+ val = (unsigned long)sysfs_config->addr_val[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -945,21 +946,21 @@ static ssize_t addr_single_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
- if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
+ idx = sysfs_config->addr_idx;
+ if (!(sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_SINGLE)) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- config->addr_val[idx] = (u64)val;
- config->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
+ sysfs_config->addr_val[idx] = (u64)val;
+ sysfs_config->addr_type[idx] = ETM_ADDR_TYPE_SINGLE;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -972,24 +973,24 @@ static ssize_t addr_range_show(struct device *dev,
u8 idx;
unsigned long val1, val2;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
if (idx % 2 != 0) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
- config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
- (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
- config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
+ if (!((sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
+ sysfs_config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
+ (sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
+ sysfs_config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- val1 = (unsigned long)config->addr_val[idx];
- val2 = (unsigned long)config->addr_val[idx + 1];
+ val1 = (unsigned long)sysfs_config->addr_val[idx];
+ val2 = (unsigned long)sysfs_config->addr_val[idx + 1];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
}
@@ -1001,7 +1002,7 @@ static ssize_t addr_range_store(struct device *dev,
u8 idx;
unsigned long val1, val2;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
int elements, exclude;
elements = sscanf(buf, "%lx %lx %x", &val1, &val2, &exclude);
@@ -1014,31 +1015,31 @@ static ssize_t addr_range_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
if (idx % 2 != 0) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- if (!((config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
- config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
- (config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
- config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
+ if (!((sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE &&
+ sysfs_config->addr_type[idx + 1] == ETM_ADDR_TYPE_NONE) ||
+ (sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_RANGE &&
+ sysfs_config->addr_type[idx + 1] == ETM_ADDR_TYPE_RANGE))) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- config->addr_val[idx] = (u64)val1;
- config->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
- config->addr_val[idx + 1] = (u64)val2;
- config->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
+ sysfs_config->addr_val[idx] = (u64)val1;
+ sysfs_config->addr_type[idx] = ETM_ADDR_TYPE_RANGE;
+ sysfs_config->addr_val[idx + 1] = (u64)val2;
+ sysfs_config->addr_type[idx + 1] = ETM_ADDR_TYPE_RANGE;
/*
* Program include or exclude control bits for vinst or vdata
* whenever we change addr comparators to ETM_ADDR_TYPE_RANGE
* use supplied value, or default to bit set in 'mode'
*/
if (elements != 3)
- exclude = config->mode & ETM_MODE_EXCLUDE;
+ exclude = sysfs_config->mode & ETM_MODE_EXCLUDE;
etm4_set_mode_exclude(drvdata, exclude ? true : false);
raw_spin_unlock(&drvdata->spinlock);
@@ -1053,18 +1054,18 @@ static ssize_t addr_start_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
- if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
+ if (!(sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- val = (unsigned long)config->addr_val[idx];
+ val = (unsigned long)sysfs_config->addr_val[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1077,26 +1078,26 @@ static ssize_t addr_start_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
if (!caps->nr_addr_cmp) {
raw_spin_unlock(&drvdata->spinlock);
return -EINVAL;
}
- if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
+ if (!(sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_START)) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- config->addr_val[idx] = (u64)val;
- config->addr_type[idx] = ETM_ADDR_TYPE_START;
- config->vissctlr |= BIT(idx);
+ sysfs_config->addr_val[idx] = (u64)val;
+ sysfs_config->addr_type[idx] = ETM_ADDR_TYPE_START;
+ sysfs_config->vissctlr |= BIT(idx);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1109,18 +1110,18 @@ static ssize_t addr_stop_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
- if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
+ if (!(sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- val = (unsigned long)config->addr_val[idx];
+ val = (unsigned long)sysfs_config->addr_val[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1133,26 +1134,26 @@ static ssize_t addr_stop_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
if (!caps->nr_addr_cmp) {
raw_spin_unlock(&drvdata->spinlock);
return -EINVAL;
}
- if (!(config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
- config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
+ if (!(sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_NONE ||
+ sysfs_config->addr_type[idx] == ETM_ADDR_TYPE_STOP)) {
raw_spin_unlock(&drvdata->spinlock);
return -EPERM;
}
- config->addr_val[idx] = (u64)val;
- config->addr_type[idx] = ETM_ADDR_TYPE_STOP;
- config->vissctlr |= BIT(idx + 16);
+ sysfs_config->addr_val[idx] = (u64)val;
+ sysfs_config->addr_type[idx] = ETM_ADDR_TYPE_STOP;
+ sysfs_config->vissctlr |= BIT(idx + 16);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1165,12 +1166,12 @@ static ssize_t addr_ctxtype_show(struct device *dev,
ssize_t len;
u8 idx, val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
/* CONTEXTTYPE, bits[3:2] */
- val = FIELD_GET(TRCACATRn_CONTEXTTYPE_MASK, config->addr_acc[idx]);
+ val = FIELD_GET(TRCACATRn_CONTEXTTYPE_MASK, sysfs_config->addr_acc[idx]);
len = scnprintf(buf, PAGE_SIZE, "%s\n", val == ETM_CTX_NONE ? "none" :
(val == ETM_CTX_CTXID ? "ctxid" :
(val == ETM_CTX_VMID ? "vmid" : "all")));
@@ -1186,7 +1187,7 @@ static ssize_t addr_ctxtype_store(struct device *dev,
char str[10] = "";
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (strlen(buf) >= 10)
return -EINVAL;
@@ -1194,21 +1195,21 @@ static ssize_t addr_ctxtype_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
if (!strcmp(str, "none"))
/* start by clearing context type bits */
- config->addr_acc[idx] &= ~TRCACATRn_CONTEXTTYPE_MASK;
+ sysfs_config->addr_acc[idx] &= ~TRCACATRn_CONTEXTTYPE_MASK;
else if (!strcmp(str, "ctxid")) {
/* 0b01 The trace unit performs a Context ID */
if (caps->numcidc) {
- config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_CTXID;
- config->addr_acc[idx] &= ~TRCACATRn_CONTEXTTYPE_VMID;
+ sysfs_config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_CTXID;
+ sysfs_config->addr_acc[idx] &= ~TRCACATRn_CONTEXTTYPE_VMID;
}
} else if (!strcmp(str, "vmid")) {
/* 0b10 The trace unit performs a VMID */
if (caps->numvmidc) {
- config->addr_acc[idx] &= ~TRCACATRn_CONTEXTTYPE_CTXID;
- config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_VMID;
+ sysfs_config->addr_acc[idx] &= ~TRCACATRn_CONTEXTTYPE_CTXID;
+ sysfs_config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_VMID;
}
} else if (!strcmp(str, "all")) {
/*
@@ -1216,9 +1217,9 @@ static ssize_t addr_ctxtype_store(struct device *dev,
* comparison and a VMID
*/
if (caps->numcidc)
- config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_CTXID;
+ sysfs_config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_CTXID;
if (caps->numvmidc)
- config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_VMID;
+ sysfs_config->addr_acc[idx] |= TRCACATRn_CONTEXTTYPE_VMID;
}
raw_spin_unlock(&drvdata->spinlock);
return size;
@@ -1232,12 +1233,12 @@ static ssize_t addr_context_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
/* context ID comparator bits[6:4] */
- val = FIELD_GET(TRCACATRn_CONTEXT_MASK, config->addr_acc[idx]);
+ val = FIELD_GET(TRCACATRn_CONTEXT_MASK, sysfs_config->addr_acc[idx]);
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1250,7 +1251,7 @@ static ssize_t addr_context_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1261,10 +1262,10 @@ static ssize_t addr_context_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
/* clear context ID comparator bits[6:4] */
- config->addr_acc[idx] &= ~TRCACATRn_CONTEXT_MASK;
- config->addr_acc[idx] |= val << __bf_shf(TRCACATRn_CONTEXT_MASK);
+ sysfs_config->addr_acc[idx] &= ~TRCACATRn_CONTEXT_MASK;
+ sysfs_config->addr_acc[idx] |= val << __bf_shf(TRCACATRn_CONTEXT_MASK);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1277,11 +1278,11 @@ static ssize_t addr_exlevel_s_ns_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
- val = FIELD_GET(TRCACATRn_EXLEVEL_MASK, config->addr_acc[idx]);
+ idx = sysfs_config->addr_idx;
+ val = FIELD_GET(TRCACATRn_EXLEVEL_MASK, sysfs_config->addr_acc[idx]);
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1293,7 +1294,7 @@ static ssize_t addr_exlevel_s_ns_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 0, &val))
return -EINVAL;
@@ -1302,10 +1303,10 @@ static ssize_t addr_exlevel_s_ns_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
+ idx = sysfs_config->addr_idx;
/* clear Exlevel_ns & Exlevel_s bits[14:12, 11:8], bit[15] is res0 */
- config->addr_acc[idx] &= ~TRCACATRn_EXLEVEL_MASK;
- config->addr_acc[idx] |= val << __bf_shf(TRCACATRn_EXLEVEL_MASK);
+ sysfs_config->addr_acc[idx] &= ~TRCACATRn_EXLEVEL_MASK;
+ sysfs_config->addr_acc[idx] |= val << __bf_shf(TRCACATRn_EXLEVEL_MASK);
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1325,24 +1326,24 @@ static ssize_t addr_cmp_view_show(struct device *dev,
u8 idx, addr_type;
unsigned long addr_v, addr_v2, addr_ctrl;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
int size = 0;
bool exclude = false;
raw_spin_lock(&drvdata->spinlock);
- idx = config->addr_idx;
- addr_v = config->addr_val[idx];
- addr_ctrl = config->addr_acc[idx];
- addr_type = config->addr_type[idx];
+ idx = sysfs_config->addr_idx;
+ addr_v = sysfs_config->addr_val[idx];
+ addr_ctrl = sysfs_config->addr_acc[idx];
+ addr_type = sysfs_config->addr_type[idx];
if (addr_type == ETM_ADDR_TYPE_RANGE) {
if (idx & 0x1) {
idx -= 1;
addr_v2 = addr_v;
- addr_v = config->addr_val[idx];
+ addr_v = sysfs_config->addr_val[idx];
} else {
- addr_v2 = config->addr_val[idx + 1];
+ addr_v2 = sysfs_config->addr_val[idx + 1];
}
- exclude = config->viiectlr & BIT(idx / 2 + 16);
+ exclude = sysfs_config->viiectlr & BIT(idx / 2 + 16);
}
raw_spin_unlock(&drvdata->spinlock);
if (addr_type) {
@@ -1369,11 +1370,11 @@ static ssize_t vinst_pe_cmp_start_stop_show(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (!caps->nr_pe_cmp)
return -EINVAL;
- val = config->vipcssctlr;
+ val = sysfs_config->vipcssctlr;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
static ssize_t vinst_pe_cmp_start_stop_store(struct device *dev,
@@ -1383,7 +1384,7 @@ static ssize_t vinst_pe_cmp_start_stop_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1391,7 +1392,7 @@ static ssize_t vinst_pe_cmp_start_stop_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- config->vipcssctlr = val;
+ sysfs_config->vipcssctlr = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1403,9 +1404,9 @@ static ssize_t seq_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->seq_idx;
+ val = sysfs_config->seq_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1416,7 +1417,7 @@ static ssize_t seq_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (!caps->nr_seq_ctrls)
return -ENOTSUPP;
@@ -1430,7 +1431,7 @@ static ssize_t seq_idx_store(struct device *dev,
* dereferenced multiple times within a spinlock block elsewhere.
*/
raw_spin_lock(&drvdata->spinlock);
- config->seq_idx = val;
+ sysfs_config->seq_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1442,9 +1443,9 @@ static ssize_t seq_state_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->seq_state;
+ val = sysfs_config->seq_state;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1455,7 +1456,7 @@ static ssize_t seq_state_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1465,7 +1466,7 @@ static ssize_t seq_state_store(struct device *dev,
coresight_get_mode(drvdata->csdev) == CS_MODE_SYSFS)
return -EBUSY;
- config->seq_state = val;
+ sysfs_config->seq_state = val;
return size;
}
static DEVICE_ATTR_RW(seq_state);
@@ -1477,11 +1478,11 @@ static ssize_t seq_event_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->seq_idx;
- val = config->seq_ctrl[idx];
+ idx = sysfs_config->seq_idx;
+ val = sysfs_config->seq_ctrl[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1493,15 +1494,15 @@ static ssize_t seq_event_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->seq_idx;
+ idx = sysfs_config->seq_idx;
/* Seq control has two masks B[15:8] F[7:0] */
- config->seq_ctrl[idx] = val & 0xFFFF;
+ sysfs_config->seq_ctrl[idx] = val & 0xFFFF;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1513,9 +1514,9 @@ static ssize_t seq_reset_event_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->seq_rst;
+ val = sysfs_config->seq_rst;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1526,14 +1527,14 @@ static ssize_t seq_reset_event_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
if (!(caps->nrseqstate))
return -EINVAL;
- config->seq_rst = val & ETMv4_EVENT_MASK;
+ sysfs_config->seq_rst = val & ETMv4_EVENT_MASK;
return size;
}
static DEVICE_ATTR_RW(seq_reset_event);
@@ -1544,9 +1545,9 @@ static ssize_t cntr_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->cntr_idx;
+ val = sysfs_config->cntr_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1557,7 +1558,7 @@ static ssize_t cntr_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1569,7 +1570,7 @@ static ssize_t cntr_idx_store(struct device *dev,
* dereferenced multiple times within a spinlock block elsewhere.
*/
raw_spin_lock(&drvdata->spinlock);
- config->cntr_idx = val;
+ sysfs_config->cntr_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1582,11 +1583,11 @@ static ssize_t cntrldvr_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->cntr_idx;
- val = config->cntrldvr[idx];
+ idx = sysfs_config->cntr_idx;
+ val = sysfs_config->cntrldvr[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1598,7 +1599,7 @@ static ssize_t cntrldvr_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1606,8 +1607,8 @@ static ssize_t cntrldvr_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->cntr_idx;
- config->cntrldvr[idx] = val;
+ idx = sysfs_config->cntr_idx;
+ sysfs_config->cntrldvr[idx] = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1620,11 +1621,11 @@ static ssize_t cntr_val_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->cntr_idx;
- val = config->cntr_val[idx];
+ idx = sysfs_config->cntr_idx;
+ val = sysfs_config->cntr_val[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1636,7 +1637,7 @@ static ssize_t cntr_val_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1647,8 +1648,8 @@ static ssize_t cntr_val_store(struct device *dev,
return -EBUSY;
raw_spin_lock(&drvdata->spinlock);
- idx = config->cntr_idx;
- config->cntr_val[idx] = val;
+ idx = sysfs_config->cntr_idx;
+ sysfs_config->cntr_val[idx] = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1661,11 +1662,11 @@ static ssize_t cntr_ctrl_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->cntr_idx;
- val = config->cntr_ctrl[idx];
+ idx = sysfs_config->cntr_idx;
+ val = sysfs_config->cntr_ctrl[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1677,14 +1678,14 @@ static ssize_t cntr_ctrl_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->cntr_idx;
- config->cntr_ctrl[idx] = val;
+ idx = sysfs_config->cntr_idx;
+ sysfs_config->cntr_ctrl[idx] = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1696,9 +1697,9 @@ static ssize_t res_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->res_idx;
+ val = sysfs_config->res_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1709,7 +1710,7 @@ static ssize_t res_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1725,7 +1726,7 @@ static ssize_t res_idx_store(struct device *dev,
* dereferenced multiple times within a spinlock block elsewhere.
*/
raw_spin_lock(&drvdata->spinlock);
- config->res_idx = val;
+ sysfs_config->res_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1738,11 +1739,11 @@ static ssize_t res_ctrl_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- idx = config->res_idx;
- val = config->res_ctrl[idx];
+ idx = sysfs_config->res_idx;
+ val = sysfs_config->res_ctrl[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1754,18 +1755,18 @@ static ssize_t res_ctrl_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->res_idx;
+ idx = sysfs_config->res_idx;
/* For odd idx pair inversal bit is RES0 */
if (idx % 2 != 0)
/* PAIRINV, bit[21] */
val &= ~TRCRSCTLRn_PAIRINV;
- config->res_ctrl[idx] = val & (TRCRSCTLRn_PAIRINV |
+ sysfs_config->res_ctrl[idx] = val & (TRCRSCTLRn_PAIRINV |
TRCRSCTLRn_INV |
TRCRSCTLRn_GROUP_MASK |
TRCRSCTLRn_SELECT_MASK);
@@ -1779,9 +1780,9 @@ static ssize_t sshot_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->ss_idx;
+ val = sysfs_config->ss_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1792,7 +1793,7 @@ static ssize_t sshot_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1800,7 +1801,7 @@ static ssize_t sshot_idx_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- config->ss_idx = val;
+ sysfs_config->ss_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1812,10 +1813,10 @@ static ssize_t sshot_ctrl_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- val = config->ss_ctrl[config->ss_idx];
+ val = sysfs_config->ss_ctrl[sysfs_config->ss_idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1827,14 +1828,14 @@ static ssize_t sshot_ctrl_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->ss_idx;
- config->ss_ctrl[idx] = FIELD_PREP(TRCSSCCRn_SAC_ARC_RST_MASK, val);
+ idx = sysfs_config->ss_idx;
+ sysfs_config->ss_ctrl[idx] = FIELD_PREP(TRCSSCCRn_SAC_ARC_RST_MASK, val);
/* must clear bit 31 and 30 in related status register on programming */
drvdata->ss_status[idx] &= ~(TRCSSCSRn_STATUS | TRCSSCSRn_PENDING);
raw_spin_unlock(&drvdata->spinlock);
@@ -1847,10 +1848,10 @@ static ssize_t sshot_status_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- val = drvdata->ss_status[config->ss_idx];
+ val = drvdata->ss_status[sysfs_config->ss_idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1862,10 +1863,10 @@ static ssize_t sshot_pe_ctrl_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
raw_spin_lock(&drvdata->spinlock);
- val = config->ss_pe_cmp[config->ss_idx];
+ val = sysfs_config->ss_pe_cmp[sysfs_config->ss_idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1877,14 +1878,14 @@ static ssize_t sshot_pe_ctrl_store(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->ss_idx;
- config->ss_pe_cmp[idx] = FIELD_PREP(TRCSSPCICRn_PC_MASK, val);
+ idx = sysfs_config->ss_idx;
+ sysfs_config->ss_pe_cmp[idx] = FIELD_PREP(TRCSSPCICRn_PC_MASK, val);
/* must clear bit 31 and 30 in related status register on programming */
drvdata->ss_status[idx] &= ~(TRCSSCSRn_STATUS | TRCSSCSRn_PENDING);
raw_spin_unlock(&drvdata->spinlock);
@@ -1898,9 +1899,9 @@ static ssize_t ctxid_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->ctxid_idx;
+ val = sysfs_config->ctxid_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1911,7 +1912,7 @@ static ssize_t ctxid_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -1923,7 +1924,7 @@ static ssize_t ctxid_idx_store(struct device *dev,
* dereferenced multiple times within a spinlock block elsewhere.
*/
raw_spin_lock(&drvdata->spinlock);
- config->ctxid_idx = val;
+ sysfs_config->ctxid_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1936,7 +1937,7 @@ static ssize_t ctxid_pid_show(struct device *dev,
u8 idx;
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/*
* Don't use contextID tracing if coming from a PID namespace. See
@@ -1946,8 +1947,8 @@ static ssize_t ctxid_pid_show(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->ctxid_idx;
- val = (unsigned long)config->ctxid_pid[idx];
+ idx = sysfs_config->ctxid_idx;
+ val = (unsigned long)sysfs_config->ctxid_pid[idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -1960,7 +1961,7 @@ static ssize_t ctxid_pid_store(struct device *dev,
unsigned long pid;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/*
* When contextID tracing is enabled the tracers will insert the
@@ -1985,8 +1986,8 @@ static ssize_t ctxid_pid_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- idx = config->ctxid_idx;
- config->ctxid_pid[idx] = (u64)pid;
+ idx = sysfs_config->ctxid_idx;
+ sysfs_config->ctxid_pid[idx] = (u64)pid;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -1998,7 +1999,7 @@ static ssize_t ctxid_masks_show(struct device *dev,
{
unsigned long val1, val2;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/*
* Don't use contextID tracing if coming from a PID namespace. See
@@ -2008,8 +2009,8 @@ static ssize_t ctxid_masks_show(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- val1 = config->ctxid_mask0;
- val2 = config->ctxid_mask1;
+ val1 = sysfs_config->ctxid_mask0;
+ val2 = sysfs_config->ctxid_mask1;
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
}
@@ -2022,7 +2023,7 @@ static ssize_t ctxid_masks_store(struct device *dev,
unsigned long val1, val2, mask;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
int nr_inputs;
/*
@@ -2052,39 +2053,39 @@ static ssize_t ctxid_masks_store(struct device *dev,
switch (caps->numcidc) {
case 0x1:
/* COMP0, bits[7:0] */
- config->ctxid_mask0 = val1 & 0xFF;
+ sysfs_config->ctxid_mask0 = val1 & 0xFF;
break;
case 0x2:
/* COMP1, bits[15:8] */
- config->ctxid_mask0 = val1 & 0xFFFF;
+ sysfs_config->ctxid_mask0 = val1 & 0xFFFF;
break;
case 0x3:
/* COMP2, bits[23:16] */
- config->ctxid_mask0 = val1 & 0xFFFFFF;
+ sysfs_config->ctxid_mask0 = val1 & 0xFFFFFF;
break;
case 0x4:
/* COMP3, bits[31:24] */
- config->ctxid_mask0 = val1;
+ sysfs_config->ctxid_mask0 = val1;
break;
case 0x5:
/* COMP4, bits[7:0] */
- config->ctxid_mask0 = val1;
- config->ctxid_mask1 = val2 & 0xFF;
+ sysfs_config->ctxid_mask0 = val1;
+ sysfs_config->ctxid_mask1 = val2 & 0xFF;
break;
case 0x6:
/* COMP5, bits[15:8] */
- config->ctxid_mask0 = val1;
- config->ctxid_mask1 = val2 & 0xFFFF;
+ sysfs_config->ctxid_mask0 = val1;
+ sysfs_config->ctxid_mask1 = val2 & 0xFFFF;
break;
case 0x7:
/* COMP6, bits[23:16] */
- config->ctxid_mask0 = val1;
- config->ctxid_mask1 = val2 & 0xFFFFFF;
+ sysfs_config->ctxid_mask0 = val1;
+ sysfs_config->ctxid_mask1 = val2 & 0xFFFFFF;
break;
case 0x8:
/* COMP7, bits[31:24] */
- config->ctxid_mask0 = val1;
- config->ctxid_mask1 = val2;
+ sysfs_config->ctxid_mask0 = val1;
+ sysfs_config->ctxid_mask1 = val2;
break;
default:
break;
@@ -2095,7 +2096,7 @@ static ssize_t ctxid_masks_store(struct device *dev,
* For example, if bit[3] of ctxid_mask0 is 1, we must clear bits[31:24]
* of ctxid comparator0 value (corresponding to byte 0) register.
*/
- mask = config->ctxid_mask0;
+ mask = sysfs_config->ctxid_mask0;
for (i = 0; i < caps->numcidc; i++) {
/* mask value of corresponding ctxid comparator */
maskbyte = mask & ETMv4_EVENT_MASK;
@@ -2105,13 +2106,13 @@ static ssize_t ctxid_masks_store(struct device *dev,
*/
for (j = 0; j < 8; j++) {
if (maskbyte & 1)
- config->ctxid_pid[i] &= ~(0xFFUL << (j * 8));
+ sysfs_config->ctxid_pid[i] &= ~(0xFFUL << (j * 8));
maskbyte >>= 1;
}
/* Select the next ctxid comparator mask value */
if (i == 3)
/* ctxid comparators[4-7] */
- mask = config->ctxid_mask1;
+ mask = sysfs_config->ctxid_mask1;
else
mask >>= 0x8;
}
@@ -2127,9 +2128,9 @@ static ssize_t vmid_idx_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
- val = config->vmid_idx;
+ val = sysfs_config->vmid_idx;
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -2140,7 +2141,7 @@ static ssize_t vmid_idx_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
if (kstrtoul(buf, 16, &val))
return -EINVAL;
@@ -2152,7 +2153,7 @@ static ssize_t vmid_idx_store(struct device *dev,
* dereferenced multiple times within a spinlock block elsewhere.
*/
raw_spin_lock(&drvdata->spinlock);
- config->vmid_idx = val;
+ sysfs_config->vmid_idx = val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -2164,7 +2165,7 @@ static ssize_t vmid_val_show(struct device *dev,
{
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/*
* Don't use virtual contextID tracing if coming from a PID namespace.
@@ -2174,7 +2175,7 @@ static ssize_t vmid_val_show(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- val = (unsigned long)config->vmid_val[config->vmid_idx];
+ val = (unsigned long)sysfs_config->vmid_val[sysfs_config->vmid_idx];
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx\n", val);
}
@@ -2186,7 +2187,7 @@ static ssize_t vmid_val_store(struct device *dev,
unsigned long val;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/*
* Don't use virtual contextID tracing if coming from a PID namespace.
@@ -2205,7 +2206,7 @@ static ssize_t vmid_val_store(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- config->vmid_val[config->vmid_idx] = (u64)val;
+ sysfs_config->vmid_val[sysfs_config->vmid_idx] = (u64)val;
raw_spin_unlock(&drvdata->spinlock);
return size;
}
@@ -2216,7 +2217,7 @@ static ssize_t vmid_masks_show(struct device *dev,
{
unsigned long val1, val2;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
/*
* Don't use virtual contextID tracing if coming from a PID namespace.
@@ -2226,8 +2227,8 @@ static ssize_t vmid_masks_show(struct device *dev,
return -EINVAL;
raw_spin_lock(&drvdata->spinlock);
- val1 = config->vmid_mask0;
- val2 = config->vmid_mask1;
+ val1 = sysfs_config->vmid_mask0;
+ val2 = sysfs_config->vmid_mask1;
raw_spin_unlock(&drvdata->spinlock);
return scnprintf(buf, PAGE_SIZE, "%#lx %#lx\n", val1, val2);
}
@@ -2240,7 +2241,7 @@ static ssize_t vmid_masks_store(struct device *dev,
unsigned long val1, val2, mask;
struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent);
const struct etmv4_caps *caps = &drvdata->caps;
- struct etmv4_config *config = &drvdata->config;
+ struct etmv4_config *sysfs_config = &drvdata->sysfs_config;
int nr_inputs;
/*
@@ -2270,39 +2271,39 @@ static ssize_t vmid_masks_store(struct device *dev,
switch (caps->numvmidc) {
case 0x1:
/* COMP0, bits[7:0] */
- config->vmid_mask0 = val1 & 0xFF;
+ sysfs_config->vmid_mask0 = val1 & 0xFF;
break;
case 0x2:
/* COMP1, bits[15:8] */
- config->vmid_mask0 = val1 & 0xFFFF;
+ sysfs_config->vmid_mask0 = val1 & 0xFFFF;
break;
case 0x3:
/* COMP2, bits[23:16] */
- config->vmid_mask0 = val1 & 0xFFFFFF;
+ sysfs_config->vmid_mask0 = val1 & 0xFFFFFF;
break;
case 0x4:
/* COMP3, bits[31:24] */
- config->vmid_mask0 = val1;
+ sysfs_config->vmid_mask0 = val1;
break;
case 0x5:
/* COMP4, bits[7:0] */
- config->vmid_mask0 = val1;
- config->vmid_mask1 = val2 & 0xFF;
+ sysfs_config->vmid_mask0 = val1;
+ sysfs_config->vmid_mask1 = val2 & 0xFF;
break;
case 0x6:
/* COMP5, bits[15:8] */
- config->vmid_mask0 = val1;
- config->vmid_mask1 = val2 & 0xFFFF;
+ sysfs_config->vmid_mask0 = val1;
+ sysfs_config->vmid_mask1 = val2 & 0xFFFF;
break;
case 0x7:
/* COMP6, bits[23:16] */
- config->vmid_mask0 = val1;
- config->vmid_mask1 = val2 & 0xFFFFFF;
+ sysfs_config->vmid_mask0 = val1;
+ sysfs_config->vmid_mask1 = val2 & 0xFFFFFF;
break;
case 0x8:
/* COMP7, bits[31:24] */
- config->vmid_mask0 = val1;
- config->vmid_mask1 = val2;
+ sysfs_config->vmid_mask0 = val1;
+ sysfs_config->vmid_mask1 = val2;
break;
default:
break;
@@ -2314,7 +2315,7 @@ static ssize_t vmid_masks_store(struct device *dev,
* For example, if bit[3] of vmid_mask0 is 1, we must clear bits[31:24]
* of vmid comparator0 value (corresponding to byte 0) register.
*/
- mask = config->vmid_mask0;
+ mask = sysfs_config->vmid_mask0;
for (i = 0; i < caps->numvmidc; i++) {
/* mask value of corresponding vmid comparator */
maskbyte = mask & ETMv4_EVENT_MASK;
@@ -2324,13 +2325,13 @@ static ssize_t vmid_masks_store(struct device *dev,
*/
for (j = 0; j < 8; j++) {
if (maskbyte & 1)
- config->vmid_val[i] &= ~(0xFFUL << (j * 8));
+ sysfs_config->vmid_val[i] &= ~(0xFFUL << (j * 8));
maskbyte >>= 1;
}
/* Select the next vmid comparator mask value */
if (i == 3)
/* vmid comparators[4-7] */
- mask = config->vmid_mask1;
+ mask = sysfs_config->vmid_mask1;
else
mask >>= 0x8;
}
diff --git a/drivers/hwtracing/coresight/coresight-etm4x.h b/drivers/hwtracing/coresight/coresight-etm4x.h
index ae97c5c004bf..5417280cdb27 100644
--- a/drivers/hwtracing/coresight/coresight-etm4x.h
+++ b/drivers/hwtracing/coresight/coresight-etm4x.h
@@ -1070,7 +1070,7 @@ struct etmv4_save_state {
* at runtime, due to the additional setting of TRFCR_CX when
* in EL2. Otherwise, 0.
* @curr_config: structure holding current applied configuration.
- * @config: structure holding sysfs mode configuration.
+ * @sysfs_config: structure holding sysfs mode configuration.
* @save_state: State to be preserved across power loss
* @paused: Indicates if the trace unit is paused.
* @ss_status: The status of the corresponding single-shot comparator.
@@ -1092,7 +1092,7 @@ struct etmv4_drvdata {
bool paused : 1;
u64 trfcr;
struct etmv4_config curr_config;
- struct etmv4_config config;
+ struct etmv4_config sysfs_config;
struct etmv4_save_state *save_state;
u32 ss_status[ETM_MAX_SS_CMP];
DECLARE_BITMAP(arch_features, ETM4_IMPDEF_FEATURE_MAX);
--
2.43.0
next prev parent reply other threads:[~2026-09-24 17:34 UTC|newest]
Thread overview: 19+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-09-24 17:33 [PATCH v12 00/14] fix several inconsistencies with sysfs configuration in etmX Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 01/14] coresight: etm4x: read-back TRCSEQSTR at disabling and prohibit modifying seq_state while enabling Yeoreum Yun
2026-09-24 17:46 ` sashiko-bot
2026-09-24 17:33 ` [PATCH v12 02/14] coresight: etm4x: prohibit modifying cntr_val while session is enabled Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 03/14] coresight: etm3x: prohibit modifying cntr_val and reset " Yeoreum Yun
2026-09-24 17:58 ` sashiko-bot
2026-09-24 17:33 ` [PATCH v12 04/14] coresight: etm4x: fix inconsistencies with sysfs configuration Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 05/14] coresight: etm3x: " Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 06/14] coresight: etm3x: remove redundant cpu online check on etm_enable_sysfs() Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 07/14] coresight: etm4x: introduce struct etm4_caps Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 08/14] coresight: etm4x: exclude ss_status from drvdata->config Yeoreum Yun
2026-09-24 18:21 ` sashiko-bot
2026-09-24 17:33 ` [PATCH v12 09/14] coresight: etm4x: remove s_ex_level from config Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 10/14] coresight: etm4x: rename local config as curr_config referring drvdata->curr_config Yeoreum Yun
2026-09-24 17:33 ` Yeoreum Yun [this message]
2026-09-24 17:33 ` [PATCH v12 12/14] coresight: etm3x: introduce struct etm_caps Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 13/14] coresight: etm3x: rename local config as curr_config referring drvdata->curr_config Yeoreum Yun
2026-09-24 17:33 ` [PATCH v12 14/14] coresight: etm3x: rename drvdata->config to sysfs_config Yeoreum Yun
2026-09-24 18:36 ` sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260924-separate_etm_cfg_v2-v12-11-a2b41d2f7c2b@arm.com \
--to=yeoreum.yun@arm.com \
--cc=alexander.shishkin@linux.intel.com \
--cc=bigeasy@linutronix.de \
--cc=clrkwllms@kernel.org \
--cc=coresight@lists.linaro.org \
--cc=gregkh@linuxfoundation.org \
--cc=james.clark@linaro.org \
--cc=leo.yan@arm.com \
--cc=linux-arm-kernel@lists.infradead.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-rt-devel@lists.linux.dev \
--cc=mathieu.poirier@linaro.org \
--cc=mike.leach@arm.com \
--cc=rostedt@goodmis.org \
--cc=suzuki.poulose@arm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®