ich777/linux_media
1
0
Fork 0
mirror of https://github.com/tbsdtv/linux_media.git synced 2025-07-23 12:43:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

coresight: Convert claim/disclaim operations to use access wrappers

Browse Source 
Convert the generic CLAIM tag management APIs to use the
device access layer abstraction.

Link: https://lore.kernel.org/r/20210110224850.1880240-7-suzuki.poulose@arm.com
Cc: Mike Leach <mike.leach@linaro.org>
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Link: https://lore.kernel.org/r/20210201181351.1475223-9-mathieu.poirier@linaro.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Suzuki K Poulose
2021-02-01 11:13:28 -07:00
committed by Greg Kroah-Hartman
parent 020052825e
commit 8ce0029658
11 changed files with 91 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/hwtracing/coresight/coresight-catu.c
View File

@@ -412,6 +412,7 @@ static int catu_enable_hw(struct catu_drvdata *drvdata, void *data)
u32 control, mode; u32 control, mode;
struct etr_buf *etr_buf = data; struct etr_buf *etr_buf = data;
struct device *dev = &drvdata->csdev->dev; struct device *dev = &drvdata->csdev->dev;
struct coresight_device *csdev = drvdata->csdev;
if (catu_wait_for_ready(drvdata)) if (catu_wait_for_ready(drvdata))
dev_warn(dev, "Timeout while waiting for READY\n"); dev_warn(dev, "Timeout while waiting for READY\n");
@@ -422,7 +423,7 @@ static int catu_enable_hw(struct catu_drvdata *drvdata, void *data)
return -EBUSY; return -EBUSY;
} }
rc = coresight_claim_device_unlocked(drvdata->base); rc = coresight_claim_device_unlocked(csdev);
if (rc) if (rc)
return rc; return rc;
@@ -466,9 +467,10 @@ static int catu_disable_hw(struct catu_drvdata *drvdata)
{ {
int rc = 0; int rc = 0;
struct device *dev = &drvdata->csdev->dev; struct device *dev = &drvdata->csdev->dev;
struct coresight_device *csdev = drvdata->csdev;
catu_write_control(drvdata, 0); catu_write_control(drvdata, 0);
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
if (catu_wait_for_ready(drvdata)) { if (catu_wait_for_ready(drvdata)) {
dev_info(dev, "Timeout while waiting for READY\n"); dev_info(dev, "Timeout while waiting for READY\n");
rc = -EAGAIN; rc = -EAGAIN;

66
drivers/hwtracing/coresight/coresight-core.c
View File

@@ -145,30 +145,32 @@ static int coresight_find_link_outport(struct coresight_device *csdev,
return -ENODEV; return -ENODEV;
} }
static inline u32 coresight_read_claim_tags(void __iomem *base) static inline u32 coresight_read_claim_tags(struct coresight_device *csdev)
{ {
return readl_relaxed(base + CORESIGHT_CLAIMCLR); return csdev_access_relaxed_read32(&csdev->access, CORESIGHT_CLAIMCLR);
} }
static inline bool coresight_is_claimed_self_hosted(void __iomem *base) static inline bool coresight_is_claimed_self_hosted(struct coresight_device *csdev)
{ {
return coresight_read_claim_tags(base) == CORESIGHT_CLAIM_SELF_HOSTED; return coresight_read_claim_tags(csdev) == CORESIGHT_CLAIM_SELF_HOSTED;
} }
static inline bool coresight_is_claimed_any(void __iomem *base) static inline bool coresight_is_claimed_any(struct coresight_device *csdev)
{ {
return coresight_read_claim_tags(base) != 0; return coresight_read_claim_tags(csdev) != 0;
} }
static inline void coresight_set_claim_tags(void __iomem *base) static inline void coresight_set_claim_tags(struct coresight_device *csdev)
{ {
writel_relaxed(CORESIGHT_CLAIM_SELF_HOSTED, base + CORESIGHT_CLAIMSET); csdev_access_relaxed_write32(&csdev->access, CORESIGHT_CLAIM_SELF_HOSTED,
CORESIGHT_CLAIMSET);
isb(); isb();
} }
static inline void coresight_clear_claim_tags(void __iomem *base) static inline void coresight_clear_claim_tags(struct coresight_device *csdev)
{ {
writel_relaxed(CORESIGHT_CLAIM_SELF_HOSTED, base + CORESIGHT_CLAIMCLR); csdev_access_relaxed_write32(&csdev->access, CORESIGHT_CLAIM_SELF_HOSTED,
CORESIGHT_CLAIMCLR);
isb(); isb();
} }
@@ -182,27 +184,33 @@ static inline void coresight_clear_claim_tags(void __iomem *base)
* Called with CS_UNLOCKed for the component. * Called with CS_UNLOCKed for the component.
* Returns : 0 on success * Returns : 0 on success
*/ */
int coresight_claim_device_unlocked(void __iomem *base) int coresight_claim_device_unlocked(struct coresight_device *csdev)
{ {
if (coresight_is_claimed_any(base)) if (WARN_ON(!csdev))
return -EINVAL;
if (coresight_is_claimed_any(csdev))
return -EBUSY; return -EBUSY;
coresight_set_claim_tags(base); coresight_set_claim_tags(csdev);
if (coresight_is_claimed_self_hosted(base)) if (coresight_is_claimed_self_hosted(csdev))
return 0; return 0;
/* There was a race setting the tags, clean up and fail */ /* There was a race setting the tags, clean up and fail */
coresight_clear_claim_tags(base); coresight_clear_claim_tags(csdev);
return -EBUSY; return -EBUSY;
} }
EXPORT_SYMBOL_GPL(coresight_claim_device_unlocked); EXPORT_SYMBOL_GPL(coresight_claim_device_unlocked);
int coresight_claim_device(void __iomem *base) int coresight_claim_device(struct coresight_device *csdev)
{ {
int rc; int rc;
CS_UNLOCK(base); if (WARN_ON(!csdev))
rc = coresight_claim_device_unlocked(base); return -EINVAL;
CS_LOCK(base);
CS_UNLOCK(csdev->access.base);
rc = coresight_claim_device_unlocked(csdev);
CS_LOCK(csdev->access.base);
return rc; return rc;
} }
@@ -212,11 +220,14 @@ EXPORT_SYMBOL_GPL(coresight_claim_device);
* coresight_disclaim_device_unlocked : Clear the claim tags for the device. * coresight_disclaim_device_unlocked : Clear the claim tags for the device.
* Called with CS_UNLOCKed for the component. * Called with CS_UNLOCKed for the component.
*/ */
void coresight_disclaim_device_unlocked(void __iomem *base) void coresight_disclaim_device_unlocked(struct coresight_device *csdev)
{ {
if (coresight_is_claimed_self_hosted(base)) if (WARN_ON(!csdev))
coresight_clear_claim_tags(base); return;
if (coresight_is_claimed_self_hosted(csdev))
coresight_clear_claim_tags(csdev);
else else
/* /*
* The external agent may have not honoured our claim * The external agent may have not honoured our claim
@@ -227,11 +238,14 @@ void coresight_disclaim_device_unlocked(void __iomem *base)
} }
EXPORT_SYMBOL_GPL(coresight_disclaim_device_unlocked); EXPORT_SYMBOL_GPL(coresight_disclaim_device_unlocked);
void coresight_disclaim_device(void __iomem *base) void coresight_disclaim_device(struct coresight_device *csdev)
{ {
CS_UNLOCK(base); if (WARN_ON(!csdev))
coresight_disclaim_device_unlocked(base); return;
CS_LOCK(base);
CS_UNLOCK(csdev->access.base);
coresight_disclaim_device_unlocked(csdev);
CS_LOCK(csdev->access.base);
} }
EXPORT_SYMBOL_GPL(coresight_disclaim_device); EXPORT_SYMBOL_GPL(coresight_disclaim_device);

17
drivers/hwtracing/coresight/coresight-cti-core.c
View File

@@ -102,7 +102,7 @@ static int cti_enable_hw(struct cti_drvdata *drvdata)
goto cti_state_unchanged; goto cti_state_unchanged;
/* claim the device */ /* claim the device */
rc = coresight_claim_device(drvdata->base); rc = coresight_claim_device(drvdata->csdev);
if (rc) if (rc)
goto cti_err_not_enabled; goto cti_err_not_enabled;
@@ -136,7 +136,7 @@ static void cti_cpuhp_enable_hw(struct cti_drvdata *drvdata)
goto cti_hp_not_enabled; goto cti_hp_not_enabled;
/* try to claim the device */ /* try to claim the device */
if (coresight_claim_device(drvdata->base)) if (coresight_claim_device(drvdata->csdev))
goto cti_hp_not_enabled; goto cti_hp_not_enabled;
cti_write_all_hw_regs(drvdata); cti_write_all_hw_regs(drvdata);
@@ -154,6 +154,7 @@ static int cti_disable_hw(struct cti_drvdata *drvdata)
{ {
struct cti_config *config = &drvdata->config; struct cti_config *config = &drvdata->config;
struct device *dev = &drvdata->csdev->dev; struct device *dev = &drvdata->csdev->dev;
struct coresight_device *csdev = drvdata->csdev;
spin_lock(&drvdata->spinlock); spin_lock(&drvdata->spinlock);
@@ -171,7 +172,7 @@ static int cti_disable_hw(struct cti_drvdata *drvdata)
writel_relaxed(0, drvdata->base + CTICONTROL); writel_relaxed(0, drvdata->base + CTICONTROL);
config->hw_enabled = false; config->hw_enabled = false;
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
spin_unlock(&drvdata->spinlock); spin_unlock(&drvdata->spinlock);
pm_runtime_put(dev); pm_runtime_put(dev);
@@ -655,6 +656,7 @@ static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
void *v) void *v)
{ {
struct cti_drvdata *drvdata; struct cti_drvdata *drvdata;
struct coresight_device *csdev;
unsigned int cpu = smp_processor_id(); unsigned int cpu = smp_processor_id();
int notify_res = NOTIFY_OK; int notify_res = NOTIFY_OK;
@@ -662,6 +664,7 @@ static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
return NOTIFY_OK; return NOTIFY_OK;
drvdata = cti_cpu_drvdata[cpu]; drvdata = cti_cpu_drvdata[cpu];
csdev = drvdata->csdev;
if (WARN_ON_ONCE(drvdata->ctidev.cpu != cpu)) if (WARN_ON_ONCE(drvdata->ctidev.cpu != cpu))
return NOTIFY_BAD; return NOTIFY_BAD;
@@ -673,13 +676,13 @@ static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
/* CTI regs all static - we have a copy & nothing to save */ /* CTI regs all static - we have a copy & nothing to save */
drvdata->config.hw_powered = false; drvdata->config.hw_powered = false;
if (drvdata->config.hw_enabled) if (drvdata->config.hw_enabled)
coresight_disclaim_device(drvdata->base); coresight_disclaim_device(csdev);
break; break;
case CPU_PM_ENTER_FAILED: case CPU_PM_ENTER_FAILED:
drvdata->config.hw_powered = true; drvdata->config.hw_powered = true;
if (drvdata->config.hw_enabled) { if (drvdata->config.hw_enabled) {
if (coresight_claim_device(drvdata->base)) if (coresight_claim_device(csdev))
drvdata->config.hw_enabled = false; drvdata->config.hw_enabled = false;
} }
break; break;
@@ -692,7 +695,7 @@ static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
/* check enable reference count to enable HW */ /* check enable reference count to enable HW */
if (atomic_read(&drvdata->config.enable_req_count)) { if (atomic_read(&drvdata->config.enable_req_count)) {
/* check we can claim the device as we re-power */ /* check we can claim the device as we re-power */
if (coresight_claim_device(drvdata->base)) if (coresight_claim_device(csdev))
goto cti_notify_exit; goto cti_notify_exit;
drvdata->config.hw_enabled = true; drvdata->config.hw_enabled = true;
@@ -736,7 +739,7 @@ static int cti_dying_cpu(unsigned int cpu)
spin_lock(&drvdata->spinlock); spin_lock(&drvdata->spinlock);
drvdata->config.hw_powered = false; drvdata->config.hw_powered = false;
if (drvdata->config.hw_enabled) if (drvdata->config.hw_enabled)
coresight_disclaim_device(drvdata->base); coresight_disclaim_device(drvdata->csdev);
spin_unlock(&drvdata->spinlock); spin_unlock(&drvdata->spinlock);
return 0; return 0;
} }

4
drivers/hwtracing/coresight/coresight-etb10.c
View File

@@ -132,7 +132,7 @@ static void __etb_enable_hw(struct etb_drvdata *drvdata)
static int etb_enable_hw(struct etb_drvdata *drvdata) static int etb_enable_hw(struct etb_drvdata *drvdata)
{ {
int rc = coresight_claim_device(drvdata->base); int rc = coresight_claim_device(drvdata->csdev);
if (rc) if (rc)
return rc; return rc;
@@ -345,7 +345,7 @@ static void etb_disable_hw(struct etb_drvdata *drvdata)
{ {
__etb_disable_hw(drvdata); __etb_disable_hw(drvdata);
etb_dump_hw(drvdata); etb_dump_hw(drvdata);
coresight_disclaim_device(drvdata->base); coresight_disclaim_device(drvdata->csdev);
} }
static int etb_disable(struct coresight_device *csdev) static int etb_disable(struct coresight_device *csdev)

8
drivers/hwtracing/coresight/coresight-etm3x-core.c
View File

@@ -358,10 +358,11 @@ static int etm_enable_hw(struct etm_drvdata *drvdata)
int i, rc; int i, rc;
u32 etmcr; u32 etmcr;
struct etm_config *config = &drvdata->config; struct etm_config *config = &drvdata->config;
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
rc = coresight_claim_device_unlocked(drvdata->base); rc = coresight_claim_device_unlocked(csdev);
if (rc) if (rc)
goto done; goto done;
@@ -566,6 +567,7 @@ static void etm_disable_hw(void *info)
int i; int i;
struct etm_drvdata *drvdata = info; struct etm_drvdata *drvdata = info;
struct etm_config *config = &drvdata->config; struct etm_config *config = &drvdata->config;
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
etm_set_prog(drvdata); etm_set_prog(drvdata);
@@ -577,7 +579,7 @@ static void etm_disable_hw(void *info)
config->cntr_val[i] = etm_readl(drvdata, ETMCNTVRn(i)); config->cntr_val[i] = etm_readl(drvdata, ETMCNTVRn(i));
etm_set_pwrdwn(drvdata); etm_set_pwrdwn(drvdata);
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
@@ -602,7 +604,7 @@ static void etm_disable_perf(struct coresight_device *csdev)
* power down the tracer. * power down the tracer.
*/ */
etm_set_pwrdwn(drvdata); etm_set_pwrdwn(drvdata);
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
} }

4
drivers/hwtracing/coresight/coresight-etm4x-core.c
View File

@@ -226,7 +226,7 @@ static int etm4_enable_hw(struct etmv4_drvdata *drvdata)
etm4_os_unlock(drvdata); etm4_os_unlock(drvdata);
rc = coresight_claim_device_unlocked(drvdata->base); rc = coresight_claim_device_unlocked(csdev);
if (rc) if (rc)
goto done; goto done;
@@ -635,7 +635,7 @@ static void etm4_disable_hw(void *info)
readl_relaxed(drvdata->base + TRCCNTVRn(i)); readl_relaxed(drvdata->base + TRCCNTVRn(i));
} }
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);

6
drivers/hwtracing/coresight/coresight-funnel.c
View File

@@ -52,13 +52,14 @@ static int dynamic_funnel_enable_hw(struct funnel_drvdata *drvdata, int port)
{ {
u32 functl; u32 functl;
int rc = 0; int rc = 0;
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL);
/* Claim the device only when we enable the first slave */ /* Claim the device only when we enable the first slave */
if (!(functl & FUNNEL_ENSx_MASK)) { if (!(functl & FUNNEL_ENSx_MASK)) {
rc = coresight_claim_device_unlocked(drvdata->base); rc = coresight_claim_device_unlocked(csdev);
if (rc) if (rc)
goto done; goto done;
} }
@@ -101,6 +102,7 @@ static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata,
int inport) int inport)
{ {
u32 functl; u32 functl;
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
@@ -110,7 +112,7 @@ static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata,
/* Disclaim the device if none of the slaves are now active */ /* Disclaim the device if none of the slaves are now active */
if (!(functl & FUNNEL_ENSx_MASK)) if (!(functl & FUNNEL_ENSx_MASK))
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
} }

12
drivers/hwtracing/coresight/coresight-replicator.c
View File

@@ -45,12 +45,14 @@ struct replicator_drvdata {
static void dynamic_replicator_reset(struct replicator_drvdata *drvdata) static void dynamic_replicator_reset(struct replicator_drvdata *drvdata)
{ {
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
if (!coresight_claim_device_unlocked(drvdata->base)) { if (!coresight_claim_device_unlocked(csdev)) {
writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0); writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0);
writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER1); writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER1);
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
} }
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
@@ -70,6 +72,7 @@ static int dynamic_replicator_enable(struct replicator_drvdata *drvdata,
{ {
int rc = 0; int rc = 0;
u32 id0val, id1val; u32 id0val, id1val;
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
@@ -84,7 +87,7 @@ static int dynamic_replicator_enable(struct replicator_drvdata *drvdata,
id0val = id1val = 0xff; id0val = id1val = 0xff;
if (id0val == 0xff && id1val == 0xff) if (id0val == 0xff && id1val == 0xff)
rc = coresight_claim_device_unlocked(drvdata->base); rc = coresight_claim_device_unlocked(csdev);
if (!rc) { if (!rc) {
switch (outport) { switch (outport) {
@@ -140,6 +143,7 @@ static void dynamic_replicator_disable(struct replicator_drvdata *drvdata,
int inport, int outport) int inport, int outport)
{ {
u32 reg; u32 reg;
struct coresight_device *csdev = drvdata->csdev;
switch (outport) { switch (outport) {
case 0: case 0:
@@ -160,7 +164,7 @@ static void dynamic_replicator_disable(struct replicator_drvdata *drvdata,
if ((readl_relaxed(drvdata->base + REPLICATOR_IDFILTER0) == 0xff) && if ((readl_relaxed(drvdata->base + REPLICATOR_IDFILTER0) == 0xff) &&
(readl_relaxed(drvdata->base + REPLICATOR_IDFILTER1) == 0xff)) (readl_relaxed(drvdata->base + REPLICATOR_IDFILTER1) == 0xff))
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
} }

10
drivers/hwtracing/coresight/coresight-tmc-etf.c
View File

@@ -37,7 +37,7 @@ static void __tmc_etb_enable_hw(struct tmc_drvdata *drvdata)
static int tmc_etb_enable_hw(struct tmc_drvdata *drvdata) static int tmc_etb_enable_hw(struct tmc_drvdata *drvdata)
{ {
int rc = coresight_claim_device(drvdata->base); int rc = coresight_claim_device(drvdata->csdev);
if (rc) if (rc)
return rc; return rc;
@@ -88,7 +88,7 @@ static void __tmc_etb_disable_hw(struct tmc_drvdata *drvdata)
static void tmc_etb_disable_hw(struct tmc_drvdata *drvdata) static void tmc_etb_disable_hw(struct tmc_drvdata *drvdata)
{ {
__tmc_etb_disable_hw(drvdata); __tmc_etb_disable_hw(drvdata);
coresight_disclaim_device(drvdata->base); coresight_disclaim_device(drvdata->csdev);
} }
static void __tmc_etf_enable_hw(struct tmc_drvdata *drvdata) static void __tmc_etf_enable_hw(struct tmc_drvdata *drvdata)
@@ -109,7 +109,7 @@ static void __tmc_etf_enable_hw(struct tmc_drvdata *drvdata)
static int tmc_etf_enable_hw(struct tmc_drvdata *drvdata) static int tmc_etf_enable_hw(struct tmc_drvdata *drvdata)
{ {
int rc = coresight_claim_device(drvdata->base); int rc = coresight_claim_device(drvdata->csdev);
if (rc) if (rc)
return rc; return rc;
@@ -120,11 +120,13 @@ static int tmc_etf_enable_hw(struct tmc_drvdata *drvdata)
static void tmc_etf_disable_hw(struct tmc_drvdata *drvdata) static void tmc_etf_disable_hw(struct tmc_drvdata *drvdata)
{ {
struct coresight_device *csdev = drvdata->csdev;
CS_UNLOCK(drvdata->base); CS_UNLOCK(drvdata->base);
tmc_flush_and_stop(drvdata); tmc_flush_and_stop(drvdata);
tmc_disable_hw(drvdata); tmc_disable_hw(drvdata);
coresight_disclaim_device_unlocked(drvdata->base); coresight_disclaim_device_unlocked(csdev);
CS_LOCK(drvdata->base); CS_LOCK(drvdata->base);
} }

4
drivers/hwtracing/coresight/coresight-tmc-etr.c
View File

@@ -1040,7 +1040,7 @@ static int tmc_etr_enable_hw(struct tmc_drvdata *drvdata,
rc = tmc_etr_enable_catu(drvdata, etr_buf); rc = tmc_etr_enable_catu(drvdata, etr_buf);
if (rc) if (rc)
return rc; return rc;
rc = coresight_claim_device(drvdata->base); rc = coresight_claim_device(drvdata->csdev);
if (!rc) { if (!rc) {
drvdata->etr_buf = etr_buf; drvdata->etr_buf = etr_buf;
__tmc_etr_enable_hw(drvdata); __tmc_etr_enable_hw(drvdata);
@@ -1134,7 +1134,7 @@ void tmc_etr_disable_hw(struct tmc_drvdata *drvdata)
__tmc_etr_disable_hw(drvdata); __tmc_etr_disable_hw(drvdata);
/* Disable CATU device if this ETR is connected to one */ /* Disable CATU device if this ETR is connected to one */
tmc_etr_disable_catu(drvdata); tmc_etr_disable_catu(drvdata);
coresight_disclaim_device(drvdata->base); coresight_disclaim_device(drvdata->csdev);
/* Reset the ETR buf used by hardware */ /* Reset the ETR buf used by hardware */
drvdata->etr_buf = NULL; drvdata->etr_buf = NULL;
} }

16
include/linux/coresight.h
View File

@@ -463,11 +463,11 @@ extern void coresight_disable(struct coresight_device *csdev);
extern int coresight_timeout(struct csdev_access *csa, u32 offset, extern int coresight_timeout(struct csdev_access *csa, u32 offset,
int position, int value); int position, int value);
extern int coresight_claim_device(void __iomem *base); extern int coresight_claim_device(struct coresight_device *csdev);
extern int coresight_claim_device_unlocked(void __iomem *base); extern int coresight_claim_device_unlocked(struct coresight_device *csdev);
extern void coresight_disclaim_device(void __iomem *base); extern void coresight_disclaim_device(struct coresight_device *csdev);
extern void coresight_disclaim_device_unlocked(void __iomem *base); extern void coresight_disclaim_device_unlocked(struct coresight_device *csdev);
extern char *coresight_alloc_device_name(struct coresight_dev_list *devs, extern char *coresight_alloc_device_name(struct coresight_dev_list *devs,
struct device *dev); struct device *dev);
@@ -498,18 +498,18 @@ static inline int coresight_timeout(struct csdev_access *csa, u32 offset,
return 1; return 1;
} }
static inline int coresight_claim_device_unlocked(void __iomem *base) static inline int coresight_claim_device_unlocked(struct coresight_device *csdev)
{ {
return -EINVAL; return -EINVAL;
} }
static inline int coresight_claim_device(void __iomem *base) static inline int coresight_claim_device(struct coresight_device *csdev)
{ {
return -EINVAL; return -EINVAL;
} }
static inline void coresight_disclaim_device(void __iomem *base) {} static inline void coresight_disclaim_device(struct coresight_device *csdev) {}
static inline void coresight_disclaim_device_unlocked(void __iomem *base) {} static inline void coresight_disclaim_device_unlocked(struct coresight_device *csdev) {}
static inline bool coresight_loses_context_with_cpu(struct device *dev) static inline bool coresight_loses_context_with_cpu(struct device *dev)
{ {