From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.8 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CC938C433E2 for ; Fri, 11 Sep 2020 08:45:11 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C731C2078D for ; Fri, 11 Sep 2020 08:45:10 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="kQNISfjW" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C731C2078D Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=ehmZKKMjrt0nm1wiCRJr9fIy7jC0Aohezu++acRnLxw=; b=kQNISfjW10WnRSo5buvt9dpBx tpChBaUQo9Q3og2dO0DRvLCPMRrOKQlsAue1qznN/W4xvZzBCEQuJdqNAlbzkryqkKUQN/MEPLIIY py2R3ZvSvDt7nKuljTZ3pYECaJyjzPpumm0F56Y/Auj5l9kluqHDGJllWoByzvSAWIAGdWvqIJJS3 I8dnLKw+0IqYl0UbzOW5RJV7WxNWPc2UXof9z8LQvgPW2Ph/wEaSdnrYbLVWSDbApZAZ4jANDU/ar uvIGwyMMpO6mcr3sJhIbaQLpZsoqF7ibRRWG1l6VNazcSREzR0MmjuDz9WKBxcd2t0+MbAGYD5SmL oeaMOAfrg==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kGeeJ-0001p6-No; Fri, 11 Sep 2020 08:43:15 +0000 Received: from foss.arm.com ([217.140.110.172]) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kGech-0001Ep-Dk for linux-arm-kernel@lists.infradead.org; Fri, 11 Sep 2020 08:41:51 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 5944911B3; Fri, 11 Sep 2020 01:41:34 -0700 (PDT) Received: from ewhatever.cambridge.arm.com (ewhatever.cambridge.arm.com [10.1.197.1]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 57A843F73C; Fri, 11 Sep 2020 01:41:33 -0700 (PDT) From: Suzuki K Poulose To: linux-arm-kernel@lists.infradead.org Subject: [PATCH 05/19] coresight: Use device access layer for Software lock/unlock operations Date: Fri, 11 Sep 2020 09:41:05 +0100 Message-Id: <20200911084119.1080694-6-suzuki.poulose@arm.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200911084119.1080694-1-suzuki.poulose@arm.com> References: <20200911084119.1080694-1-suzuki.poulose@arm.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200911_044135_622383_BFF72526 X-CRM114-Status: GOOD ( 19.95 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: mathieu.poirier@linaro.org, Suzuki K Poulose , coresight@lists.linaro.org, Anshuman.Khandual@arm.com, leo.yan@linaro.org, mike.leach@linaro.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Convert CS_LOCK/UNLOCK operations to use the device access layer. Cc: Mathieu Poirier Cc: Mike Leach Signed-off-by: Suzuki K Poulose --- drivers/hwtracing/coresight/coresight-catu.c | 12 +++-- .../hwtracing/coresight/coresight-cpu-debug.c | 22 +++++++-- .../hwtracing/coresight/coresight-cti-sysfs.c | 5 +- drivers/hwtracing/coresight/coresight-cti.c | 16 ++++--- drivers/hwtracing/coresight/coresight-etb10.c | 19 ++++---- .../coresight/coresight-etm3x-sysfs.c | 10 ++-- drivers/hwtracing/coresight/coresight-etm3x.c | 26 +++++++---- drivers/hwtracing/coresight/coresight-etm4x.c | 27 +++++++---- .../hwtracing/coresight/coresight-funnel.c | 15 +++--- drivers/hwtracing/coresight/coresight-priv.h | 9 ++-- .../coresight/coresight-replicator.c | 16 ++++--- drivers/hwtracing/coresight/coresight-stm.c | 46 ++++++++++++------- .../hwtracing/coresight/coresight-tmc-etf.c | 28 +++++++---- .../hwtracing/coresight/coresight-tmc-etr.c | 16 ++++--- drivers/hwtracing/coresight/coresight-tpiu.c | 9 ++-- drivers/hwtracing/coresight/coresight.c | 8 ++-- 16 files changed, 179 insertions(+), 105 deletions(-) diff --git a/drivers/hwtracing/coresight/coresight-catu.c b/drivers/hwtracing/coresight/coresight-catu.c index df2f45457e2b..9e96cda2f924 100644 --- a/drivers/hwtracing/coresight/coresight-catu.c +++ b/drivers/hwtracing/coresight/coresight-catu.c @@ -456,10 +456,12 @@ static int catu_enable(struct coresight_device *csdev, void *data) { int rc; struct catu_drvdata *catu_drvdata = csdev_to_catu_drvdata(csdev); + struct csdev_access *csa = &csdev->access; - CS_UNLOCK(catu_drvdata->base); + CS_UNLOCK(csa); rc = catu_enable_hw(catu_drvdata, data); - CS_LOCK(catu_drvdata->base); + CS_LOCK(csa); + return rc; } @@ -484,10 +486,12 @@ static int catu_disable(struct coresight_device *csdev, void *__unused) { int rc; struct catu_drvdata *catu_drvdata = csdev_to_catu_drvdata(csdev); + struct csdev_access *csa = &csdev->access; - CS_UNLOCK(catu_drvdata->base); + CS_UNLOCK(csa); rc = catu_disable_hw(catu_drvdata); - CS_LOCK(catu_drvdata->base); + CS_LOCK(csa); + return rc; } diff --git a/drivers/hwtracing/coresight/coresight-cpu-debug.c b/drivers/hwtracing/coresight/coresight-cpu-debug.c index 96544b348c27..5d5619284866 100644 --- a/drivers/hwtracing/coresight/coresight-cpu-debug.c +++ b/drivers/hwtracing/coresight/coresight-cpu-debug.c @@ -108,6 +108,20 @@ static bool debug_enable; module_param_named(enable, debug_enable, bool, 0600); MODULE_PARM_DESC(enable, "Control to enable coresight CPU debug functionality"); +static inline void coresight_debug_lock(struct debug_drvdata *drvdata) +{ + struct csdev_access dummy = CSDEV_ACCESS_IOMEM(drvdata->base); + + CS_LOCK(&dummy); +} + +static void coresight_debug_unlock(struct debug_drvdata *drvdata) +{ + struct csdev_access dummy = CSDEV_ACCESS_IOMEM(drvdata->base); + + CS_UNLOCK(&dummy); +} + static void debug_os_unlock(struct debug_drvdata *drvdata) { /* Unlocks the debug registers */ @@ -191,7 +205,7 @@ static void debug_read_regs(struct debug_drvdata *drvdata) { u32 save_edprcr; - CS_UNLOCK(drvdata->base); + coresight_debug_unlock(drvdata); /* Unlock os lock */ debug_os_unlock(drvdata); @@ -238,7 +252,7 @@ static void debug_read_regs(struct debug_drvdata *drvdata) /* Restore EDPRCR register */ writel_relaxed(save_edprcr, drvdata->base + EDPRCR); - CS_LOCK(drvdata->base); + coresight_debug_lock(drvdata); } #ifdef CONFIG_64BIT @@ -326,13 +340,13 @@ static void debug_init_arch_data(void *info) u32 mode, pcsr_offset; u32 eddevid, eddevid1; - CS_UNLOCK(drvdata->base); + coresight_debug_unlock(drvdata); /* Read device info */ eddevid = readl_relaxed(drvdata->base + EDDEVID); eddevid1 = readl_relaxed(drvdata->base + EDDEVID1); - CS_LOCK(drvdata->base); + coresight_debug_lock(drvdata); /* Parse implementation feature */ mode = eddevid & EDDEVID_PCSAMPLE_MODE; diff --git a/drivers/hwtracing/coresight/coresight-cti-sysfs.c b/drivers/hwtracing/coresight/coresight-cti-sysfs.c index 392757f3a019..2208b5191042 100644 --- a/drivers/hwtracing/coresight/coresight-cti-sysfs.c +++ b/drivers/hwtracing/coresight/coresight-cti-sysfs.c @@ -220,14 +220,15 @@ static ssize_t cti_reg32_show(struct device *dev, char *buf, u32 val = 0; struct cti_drvdata *drvdata = dev_get_drvdata(dev->parent); struct cti_config *config = &drvdata->config; + struct csdev_access *csa = &drvdata->csdev->access; spin_lock(&drvdata->spinlock); if ((reg_offset >= 0) && cti_active(config)) { - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); val = readl_relaxed(drvdata->base + reg_offset); if (pcached_val) *pcached_val = val; - CS_LOCK(drvdata->base); + CS_LOCK(csa); } else if (pcached_val) { val = *pcached_val; } diff --git a/drivers/hwtracing/coresight/coresight-cti.c b/drivers/hwtracing/coresight/coresight-cti.c index e07e15593dd8..f921a9eeba81 100644 --- a/drivers/hwtracing/coresight/coresight-cti.c +++ b/drivers/hwtracing/coresight/coresight-cti.c @@ -60,10 +60,11 @@ DEFINE_CORESIGHT_DEVLIST(cti_sys_devs, "cti_sys"); /* write set of regs to hardware - call with spinlock claimed */ void cti_write_all_hw_regs(struct cti_drvdata *drvdata) { + struct csdev_access *csa = &drvdata->csdev->access; struct cti_config *config = &drvdata->config; int i; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* disable CTI before writing registers */ writel_relaxed(0, drvdata->base + CTICONTROL); @@ -83,7 +84,7 @@ void cti_write_all_hw_regs(struct cti_drvdata *drvdata) /* re-enable CTI */ writel_relaxed(1, drvdata->base + CTICONTROL); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } /* write regs to hardware and enable */ @@ -155,6 +156,7 @@ static int cti_disable_hw(struct cti_drvdata *drvdata) struct cti_config *config = &drvdata->config; struct device *dev = &drvdata->csdev->dev; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &csdev->access; spin_lock(&drvdata->spinlock); @@ -166,14 +168,14 @@ static int cti_disable_hw(struct cti_drvdata *drvdata) if (!config->hw_enabled || !config->hw_powered) goto cti_not_disabled; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* disable CTI */ writel_relaxed(0, drvdata->base + CTICONTROL); config->hw_enabled = false; coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); spin_unlock(&drvdata->spinlock); pm_runtime_put(dev); return 0; @@ -186,9 +188,11 @@ static int cti_disable_hw(struct cti_drvdata *drvdata) void cti_write_single_reg(struct cti_drvdata *drvdata, int offset, u32 value) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); writel_relaxed(value, drvdata->base + offset); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } void cti_write_intack(struct device *dev, u32 ackval) diff --git a/drivers/hwtracing/coresight/coresight-etb10.c b/drivers/hwtracing/coresight/coresight-etb10.c index 5b0d1c1a0442..b41cd73585cc 100644 --- a/drivers/hwtracing/coresight/coresight-etb10.c +++ b/drivers/hwtracing/coresight/coresight-etb10.c @@ -106,8 +106,9 @@ static void __etb_enable_hw(struct etb_drvdata *drvdata) { int i; u32 depth; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); depth = drvdata->buffer_depth; /* reset write RAM pointer address */ @@ -127,7 +128,7 @@ static void __etb_enable_hw(struct etb_drvdata *drvdata) /* ETB trace capture enable */ writel_relaxed(ETB_CTL_CAPT_EN, drvdata->base + ETB_CTL_REG); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static int etb_enable_hw(struct etb_drvdata *drvdata) @@ -253,7 +254,7 @@ static void __etb_disable_hw(struct etb_drvdata *drvdata) struct device *dev = &drvdata->csdev->dev; struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); ffcr = readl_relaxed(drvdata->base + ETB_FFCR); /* stop formatter when a stop has completed */ @@ -276,7 +277,7 @@ static void __etb_disable_hw(struct etb_drvdata *drvdata) "timeout while waiting for Formatter to Stop\n"); } - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void etb_dump_hw(struct etb_drvdata *drvdata) @@ -288,8 +289,9 @@ static void etb_dump_hw(struct etb_drvdata *drvdata) u32 read_ptr, write_ptr; u32 frame_off, frame_endoff; struct device *dev = &drvdata->csdev->dev; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); read_ptr = readl_relaxed(drvdata->base + ETB_RAM_READ_POINTER); write_ptr = readl_relaxed(drvdata->base + ETB_RAM_WRITE_POINTER); @@ -337,7 +339,7 @@ static void etb_dump_hw(struct etb_drvdata *drvdata) writel_relaxed(read_ptr, drvdata->base + ETB_RAM_READ_POINTER); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void etb_disable_hw(struct etb_drvdata *drvdata) @@ -435,6 +437,7 @@ static unsigned long etb_update_buffer(struct coresight_device *csdev, unsigned long offset, to_read = 0, flags; struct cs_buffers *buf = sink_config; struct etb_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); + struct csdev_access *csa = &drvdata->csdev->access; if (!buf) return 0; @@ -448,7 +451,7 @@ static unsigned long etb_update_buffer(struct coresight_device *csdev, goto out; __etb_disable_hw(drvdata); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* unit is in words, not bytes */ read_ptr = readl_relaxed(drvdata->base + ETB_RAM_READ_POINTER); @@ -563,7 +566,7 @@ static unsigned long etb_update_buffer(struct coresight_device *csdev, handle->head += to_read; __etb_enable_hw(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); out: spin_unlock_irqrestore(&drvdata->spinlock, flags); diff --git a/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c b/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c index e8c7649f123e..3e379b3fcdfd 100644 --- a/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c +++ b/drivers/hwtracing/coresight/coresight-etm3x-sysfs.c @@ -47,14 +47,15 @@ static ssize_t etmsr_show(struct device *dev, { unsigned long flags, val; struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); + struct csdev_access *csa = &drvdata->csdev->access; pm_runtime_get_sync(dev->parent); spin_lock_irqsave(&drvdata->spinlock, flags); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); val = etm_readl(drvdata, ETMSR); - CS_LOCK(drvdata->base); + CS_LOCK(csa); spin_unlock_irqrestore(&drvdata->spinlock, flags); pm_runtime_put(dev->parent); @@ -939,6 +940,7 @@ static ssize_t seq_curr_state_show(struct device *dev, unsigned long val, flags; struct etm_drvdata *drvdata = dev_get_drvdata(dev->parent); struct etm_config *config = &drvdata->config; + struct csdev_access *csa = &drvdata->csdev->access; if (!local_read(&drvdata->mode)) { val = config->seq_curr_state; @@ -948,9 +950,9 @@ static ssize_t seq_curr_state_show(struct device *dev, pm_runtime_get_sync(dev->parent); spin_lock_irqsave(&drvdata->spinlock, flags); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); val = (etm_readl(drvdata, ETMSQR) & ETM_SQR_MASK); - CS_LOCK(drvdata->base); + CS_LOCK(csa); spin_unlock_irqrestore(&drvdata->spinlock, flags); pm_runtime_put(dev->parent); diff --git a/drivers/hwtracing/coresight/coresight-etm3x.c b/drivers/hwtracing/coresight/coresight-etm3x.c index a7c791f15da7..debb4dc15527 100644 --- a/drivers/hwtracing/coresight/coresight-etm3x.c +++ b/drivers/hwtracing/coresight/coresight-etm3x.c @@ -361,8 +361,9 @@ static int etm_enable_hw(struct etm_drvdata *drvdata) u32 etmcr; struct etm_config *config = &drvdata->config; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); rc = coresight_claim_device_unlocked(csdev); if (rc) @@ -424,7 +425,7 @@ static int etm_enable_hw(struct etm_drvdata *drvdata) etm_clr_prog(drvdata); done: - CS_LOCK(drvdata->base); + CS_LOCK(csa); dev_dbg(&drvdata->csdev->dev, "cpu: %d enable smp call done: %d\n", drvdata->cpu, rc); @@ -457,10 +458,12 @@ int etm_get_trace_id(struct etm_drvdata *drvdata) unsigned long flags; int trace_id = -1; struct device *etm_dev; + struct csdev_access *csa; if (!drvdata) goto out; + csa = &drvdata->csdev->access; etm_dev = drvdata->csdev->dev.parent; if (!local_read(&drvdata->mode)) return drvdata->traceid; @@ -469,9 +472,9 @@ int etm_get_trace_id(struct etm_drvdata *drvdata) spin_lock_irqsave(&drvdata->spinlock, flags); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); trace_id = (etm_readl(drvdata, ETMTRACEIDR) & ETM_TRACEID_MASK); - CS_LOCK(drvdata->base); + CS_LOCK(csa); spin_unlock_irqrestore(&drvdata->spinlock, flags); pm_runtime_put(etm_dev); @@ -570,8 +573,9 @@ static void etm_disable_hw(void *info) struct etm_drvdata *drvdata = info; struct etm_config *config = &drvdata->config; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); etm_set_prog(drvdata); /* Read back sequencer and counters for post trace analysis */ @@ -583,7 +587,7 @@ static void etm_disable_hw(void *info) etm_set_pwrdwn(drvdata); coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); dev_dbg(&drvdata->csdev->dev, "cpu: %d disable smp call done\n", drvdata->cpu); @@ -592,11 +596,12 @@ static void etm_disable_hw(void *info) static void etm_disable_perf(struct coresight_device *csdev) { struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); + struct csdev_access *csa = &drvdata->csdev->access; if (WARN_ON_ONCE(drvdata->cpu != smp_processor_id())) return; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* Setting the prog bit disables tracing immediately */ etm_set_prog(drvdata); @@ -608,7 +613,7 @@ static void etm_disable_perf(struct coresight_device *csdev) etm_set_pwrdwn(drvdata); coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void etm_disable_sysfs(struct coresight_device *csdev) @@ -739,11 +744,12 @@ static void etm_init_arch_data(void *info) u32 etmidr; u32 etmccr; struct etm_drvdata *drvdata = info; + struct csdev_access csa = CSDEV_ACCESS_IOMEM(drvdata->base); /* Make sure all registers are accessible */ etm_os_unlock(drvdata); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(&csa); /* First dummy read */ (void)etm_readl(drvdata, ETMPDSR); @@ -776,7 +782,7 @@ static void etm_init_arch_data(void *info) etm_set_pwrdwn(drvdata); etm_clr_pwrup(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(&csa); } static void etm_init_trace_id(struct etm_drvdata *drvdata) diff --git a/drivers/hwtracing/coresight/coresight-etm4x.c b/drivers/hwtracing/coresight/coresight-etm4x.c index 5b81d6f12027..40d242d14ffa 100644 --- a/drivers/hwtracing/coresight/coresight-etm4x.c +++ b/drivers/hwtracing/coresight/coresight-etm4x.c @@ -111,7 +111,7 @@ static int etm4_enable_hw(struct etmv4_drvdata *drvdata) struct device *etm_dev = &csdev->dev; struct csdev_access *csa = &csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); etm4_os_unlock(drvdata); @@ -222,7 +222,7 @@ static int etm4_enable_hw(struct etmv4_drvdata *drvdata) isb(); done: - CS_LOCK(drvdata->base); + CS_LOCK(csa); dev_dbg(etm_dev, "cpu: %d enable smp call done: %d\n", drvdata->cpu, rc); @@ -479,7 +479,7 @@ static void etm4_disable_hw(void *info) struct csdev_access *csa = &csdev->access; int i; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); if (!drvdata->skip_power_up) { /* power can be removed from the trace unit now */ @@ -521,7 +521,7 @@ static void etm4_disable_hw(void *info) coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); dev_dbg(&drvdata->csdev->dev, "cpu: %d disable smp call done\n", drvdata->cpu); @@ -626,11 +626,12 @@ static void etm4_init_arch_data(void *info) u32 etmidr5; struct etmv4_drvdata *drvdata = info; int i; + struct csdev_access csa = CSDEV_ACCESS_IOMEM(drvdata->base); /* Make sure all registers are accessible */ etm4_os_unlock(drvdata); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(&csa); /* find all capabilities of the tracing unit */ etmidr0 = readl_relaxed(drvdata->base + TRCIDR0); @@ -784,7 +785,7 @@ static void etm4_init_arch_data(void *info) drvdata->nrseqstate = BMVAL(etmidr5, 25, 27); /* NUMCNTR, bits[30:28] number of counters available for tracing */ drvdata->nr_cntr = BMVAL(etmidr5, 28, 30); - CS_LOCK(drvdata->base); + CS_LOCK(&csa); } /* Set ELx trace filter access in the TRCVICTLR register */ @@ -1165,7 +1166,7 @@ static int etm4_cpu_save(struct etmv4_drvdata *drvdata) dsb(sy); isb(); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* Lock the OS lock to disable trace and external debugger access */ etm4_os_lock(drvdata); @@ -1273,7 +1274,7 @@ static int etm4_cpu_save(struct etmv4_drvdata *drvdata) drvdata->base + TRCPDCR); out: - CS_LOCK(drvdata->base); + CS_LOCK(csa); return ret; } @@ -1281,8 +1282,14 @@ static void etm4_cpu_restore(struct etmv4_drvdata *drvdata) { int i; struct etmv4_save_state *state = drvdata->save_state; + struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa; + + if (WARN_ON(!csdev)) + return; - CS_UNLOCK(drvdata->base); + csa = &csdev->access; + CS_UNLOCK(csa); writel_relaxed(state->trcclaimset, drvdata->base + TRCCLAIMSET); @@ -1374,7 +1381,7 @@ static void etm4_cpu_restore(struct etmv4_drvdata *drvdata) /* Unlock the OS lock to re-enable trace and external debug access */ etm4_os_unlock(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static int etm4_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd, diff --git a/drivers/hwtracing/coresight/coresight-funnel.c b/drivers/hwtracing/coresight/coresight-funnel.c index b3f98ce51a68..5b74dd0d0652 100644 --- a/drivers/hwtracing/coresight/coresight-funnel.c +++ b/drivers/hwtracing/coresight/coresight-funnel.c @@ -53,8 +53,9 @@ static int dynamic_funnel_enable_hw(struct funnel_drvdata *drvdata, int port) u32 functl; int rc = 0; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); /* Claim the device only when we enable the first slave */ @@ -70,7 +71,7 @@ static int dynamic_funnel_enable_hw(struct funnel_drvdata *drvdata, int port) writel_relaxed(functl, drvdata->base + FUNNEL_FUNCTL); writel_relaxed(drvdata->priority, drvdata->base + FUNNEL_PRICTL); done: - CS_LOCK(drvdata->base); + CS_LOCK(csa); return rc; } @@ -103,8 +104,9 @@ static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata, { u32 functl; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); functl &= ~(1 << inport); @@ -114,7 +116,7 @@ static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata, if (!(functl & FUNNEL_ENSx_MASK)) coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void funnel_disable(struct coresight_device *csdev, int inport, @@ -174,10 +176,11 @@ static DEVICE_ATTR_RW(priority); static u32 get_funnel_ctrl_hw(struct funnel_drvdata *drvdata) { u32 functl; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL); - CS_LOCK(drvdata->base); + CS_LOCK(csa); return functl; } diff --git a/drivers/hwtracing/coresight/coresight-priv.h b/drivers/hwtracing/coresight/coresight-priv.h index f2dc625ea585..a87ce11a0ea6 100644 --- a/drivers/hwtracing/coresight/coresight-priv.h +++ b/drivers/hwtracing/coresight/coresight-priv.h @@ -108,19 +108,20 @@ static inline void coresight_insert_barrier_packet(void *buf) } -static inline void CS_LOCK(void __iomem *addr) +static inline void CS_LOCK(struct csdev_access *csa) { do { /* Wait for things to settle */ mb(); - writel_relaxed(0x0, addr + CORESIGHT_LAR); + csdev_access_relaxed_write32(csa, 0x0, CORESIGHT_LAR); } while (0); } -static inline void CS_UNLOCK(void __iomem *addr) +static inline void CS_UNLOCK(struct csdev_access *csa) { do { - writel_relaxed(CORESIGHT_UNLOCK, addr + CORESIGHT_LAR); + csdev_access_relaxed_write32(csa, CORESIGHT_UNLOCK, + CORESIGHT_LAR); /* Make sure everyone has seen this */ mb(); } while (0); diff --git a/drivers/hwtracing/coresight/coresight-replicator.c b/drivers/hwtracing/coresight/coresight-replicator.c index b8361bb808f1..b9b40822f3aa 100644 --- a/drivers/hwtracing/coresight/coresight-replicator.c +++ b/drivers/hwtracing/coresight/coresight-replicator.c @@ -46,12 +46,12 @@ struct replicator_drvdata { static void dynamic_replicator_reset(struct replicator_drvdata *drvdata) { struct coresight_device *csdev = drvdata->csdev; - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &csdev->access; if (WARN_ON(!csdev)) return; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); if (!coresight_claim_device_unlocked(csdev)) { writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0); @@ -59,7 +59,7 @@ static void dynamic_replicator_reset(struct replicator_drvdata *drvdata) coresight_disclaim_device_unlocked(csdev); } - CS_LOCK(drvdata->base); + CS_LOCK(csa); } /* @@ -77,8 +77,9 @@ static int dynamic_replicator_enable(struct replicator_drvdata *drvdata, int rc = 0; u32 id0val, id1val; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); id0val = readl_relaxed(drvdata->base + REPLICATOR_IDFILTER0); id1val = readl_relaxed(drvdata->base + REPLICATOR_IDFILTER1); @@ -113,7 +114,7 @@ static int dynamic_replicator_enable(struct replicator_drvdata *drvdata, writel_relaxed(id1val, drvdata->base + REPLICATOR_IDFILTER1); } - CS_LOCK(drvdata->base); + CS_LOCK(csa); return rc; } @@ -148,6 +149,7 @@ static void dynamic_replicator_disable(struct replicator_drvdata *drvdata, { u32 reg; struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &csdev->access; switch (outport) { case 0: @@ -161,7 +163,7 @@ static void dynamic_replicator_disable(struct replicator_drvdata *drvdata, return; } - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* disable the flow of ATB data through port */ writel_relaxed(0xff, drvdata->base + reg); @@ -169,7 +171,7 @@ static void dynamic_replicator_disable(struct replicator_drvdata *drvdata, if ((readl_relaxed(drvdata->base + REPLICATOR_IDFILTER0) == 0xff) && (readl_relaxed(drvdata->base + REPLICATOR_IDFILTER1) == 0xff)) coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void replicator_disable(struct coresight_device *csdev, int inport, diff --git a/drivers/hwtracing/coresight/coresight-stm.c b/drivers/hwtracing/coresight/coresight-stm.c index 9667c5c8f433..ddf90c76284c 100644 --- a/drivers/hwtracing/coresight/coresight-stm.c +++ b/drivers/hwtracing/coresight/coresight-stm.c @@ -148,7 +148,9 @@ struct stm_drvdata { static void stm_hwevent_enable_hw(struct stm_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); writel_relaxed(drvdata->stmhebsr, drvdata->base + STMHEBSR); writel_relaxed(drvdata->stmheter, drvdata->base + STMHETER); @@ -157,29 +159,33 @@ static void stm_hwevent_enable_hw(struct stm_drvdata *drvdata) 0x04, /* Error detection on event tracing */ drvdata->base + STMHEMCR); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void stm_port_enable_hw(struct stm_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); /* ATB trigger enable on direct writes to TRIG locations */ writel_relaxed(0x10, drvdata->base + STMSPTRIGCSR); writel_relaxed(drvdata->stmspscr, drvdata->base + STMSPSCR); writel_relaxed(drvdata->stmsper, drvdata->base + STMSPER); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void stm_enable_hw(struct stm_drvdata *drvdata) { + struct csdev_access *csa = &drvdata->csdev->access; + if (drvdata->stmheer) stm_hwevent_enable_hw(drvdata); stm_port_enable_hw(drvdata); - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* 4096 byte between synchronisation packets */ writel_relaxed(0xFFF, drvdata->base + STMSYNCR); @@ -188,7 +194,7 @@ static void stm_enable_hw(struct stm_drvdata *drvdata) 0x01), /* global STM enable */ drvdata->base + STMTCSR); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static int stm_enable(struct coresight_device *csdev, @@ -218,36 +224,41 @@ static int stm_enable(struct coresight_device *csdev, static void stm_hwevent_disable_hw(struct stm_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); writel_relaxed(0x0, drvdata->base + STMHEMCR); writel_relaxed(0x0, drvdata->base + STMHEER); writel_relaxed(0x0, drvdata->base + STMHETER); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void stm_port_disable_hw(struct stm_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); writel_relaxed(0x0, drvdata->base + STMSPER); writel_relaxed(0x0, drvdata->base + STMSPTRIGCSR); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void stm_disable_hw(struct stm_drvdata *drvdata) { u32 val; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); val = readl_relaxed(drvdata->base + STMTCSR); val &= ~0x1; /* clear global STM enable [0] */ writel_relaxed(val, drvdata->base + STMTCSR); - CS_LOCK(drvdata->base); + CS_LOCK(csa); stm_port_disable_hw(drvdata); if (drvdata->stmheer) @@ -538,6 +549,8 @@ static ssize_t port_select_store(struct device *dev, const char *buf, size_t size) { struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent); + struct csdev_access *csa = &drvdata->csdev->access; + unsigned long val, stmsper; int ret = 0; @@ -549,13 +562,13 @@ static ssize_t port_select_store(struct device *dev, drvdata->stmspscr = val; if (local_read(&drvdata->mode)) { - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* Process as per ARM's TRM recommendation */ stmsper = readl_relaxed(drvdata->base + STMSPER); writel_relaxed(0x0, drvdata->base + STMSPER); writel_relaxed(drvdata->stmspscr, drvdata->base + STMSPSCR); writel_relaxed(stmsper, drvdata->base + STMSPER); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } spin_unlock(&drvdata->spinlock); @@ -585,6 +598,7 @@ static ssize_t port_enable_store(struct device *dev, const char *buf, size_t size) { struct stm_drvdata *drvdata = dev_get_drvdata(dev->parent); + struct csdev_access *csa = &drvdata->csdev->access; unsigned long val; int ret = 0; @@ -596,9 +610,9 @@ static ssize_t port_enable_store(struct device *dev, drvdata->stmsper = val; if (local_read(&drvdata->mode)) { - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); writel_relaxed(drvdata->stmsper, drvdata->base + STMSPER); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } spin_unlock(&drvdata->spinlock); diff --git a/drivers/hwtracing/coresight/coresight-tmc-etf.c b/drivers/hwtracing/coresight/coresight-tmc-etf.c index 610a494efbbc..05f65bd08cb1 100644 --- a/drivers/hwtracing/coresight/coresight-tmc-etf.c +++ b/drivers/hwtracing/coresight/coresight-tmc-etf.c @@ -18,7 +18,9 @@ static int tmc_set_etf_buffer(struct coresight_device *csdev, static void __tmc_etb_enable_hw(struct tmc_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); /* Wait for TMCSReady bit to be set */ tmc_wait_for_tmcready(drvdata); @@ -32,7 +34,7 @@ static void __tmc_etb_enable_hw(struct tmc_drvdata *drvdata) writel_relaxed(drvdata->trigger_cntr, drvdata->base + TMC_TRG); tmc_enable_hw(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static int tmc_etb_enable_hw(struct tmc_drvdata *drvdata) @@ -71,7 +73,9 @@ static void tmc_etb_dump_hw(struct tmc_drvdata *drvdata) static void __tmc_etb_disable_hw(struct tmc_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); tmc_flush_and_stop(drvdata); /* @@ -82,7 +86,7 @@ static void __tmc_etb_disable_hw(struct tmc_drvdata *drvdata) tmc_etb_dump_hw(drvdata); tmc_disable_hw(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static void tmc_etb_disable_hw(struct tmc_drvdata *drvdata) @@ -93,7 +97,9 @@ static void tmc_etb_disable_hw(struct tmc_drvdata *drvdata) static void __tmc_etf_enable_hw(struct tmc_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); /* Wait for TMCSReady bit to be set */ tmc_wait_for_tmcready(drvdata); @@ -104,7 +110,7 @@ static void __tmc_etf_enable_hw(struct tmc_drvdata *drvdata) writel_relaxed(0x0, drvdata->base + TMC_BUFWM); tmc_enable_hw(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static int tmc_etf_enable_hw(struct tmc_drvdata *drvdata) @@ -121,13 +127,14 @@ static int tmc_etf_enable_hw(struct tmc_drvdata *drvdata) static void tmc_etf_disable_hw(struct tmc_drvdata *drvdata) { struct coresight_device *csdev = drvdata->csdev; + struct csdev_access *csa = &csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); tmc_flush_and_stop(drvdata); tmc_disable_hw(drvdata); coresight_disclaim_device_unlocked(csdev); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } /* @@ -452,6 +459,7 @@ static unsigned long tmc_update_etf_buffer(struct coresight_device *csdev, unsigned long offset, to_read = 0, flags; struct cs_buffers *buf = sink_config; struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); + struct csdev_access *csa = &csdev->access; if (!buf) return 0; @@ -466,7 +474,7 @@ static unsigned long tmc_update_etf_buffer(struct coresight_device *csdev, if (atomic_read(csdev->refcnt) != 1) goto out; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); tmc_flush_and_stop(drvdata); @@ -551,7 +559,7 @@ static unsigned long tmc_update_etf_buffer(struct coresight_device *csdev, if (buf->snapshot) handle->head += to_read; - CS_LOCK(drvdata->base); + CS_LOCK(csa); out: spin_unlock_irqrestore(&drvdata->spinlock, flags); diff --git a/drivers/hwtracing/coresight/coresight-tmc-etr.c b/drivers/hwtracing/coresight/coresight-tmc-etr.c index 1aae2405041d..d33b93deefcb 100644 --- a/drivers/hwtracing/coresight/coresight-tmc-etr.c +++ b/drivers/hwtracing/coresight/coresight-tmc-etr.c @@ -952,8 +952,9 @@ static void __tmc_etr_enable_hw(struct tmc_drvdata *drvdata) { u32 axictl, sts; struct etr_buf *etr_buf = drvdata->etr_buf; + struct csdev_access *csa = &drvdata->csdev->access; - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); /* Wait for TMCSReady bit to be set */ tmc_wait_for_tmcready(drvdata); @@ -995,7 +996,7 @@ static void __tmc_etr_enable_hw(struct tmc_drvdata *drvdata) writel_relaxed(drvdata->trigger_cntr, drvdata->base + TMC_TRG); tmc_enable_hw(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } static int tmc_etr_enable_hw(struct tmc_drvdata *drvdata, @@ -1094,7 +1095,9 @@ static void tmc_etr_sync_sysfs_buf(struct tmc_drvdata *drvdata) static void __tmc_etr_disable_hw(struct tmc_drvdata *drvdata) { - CS_UNLOCK(drvdata->base); + struct csdev_access *csa = &drvdata->csdev->access; + + CS_UNLOCK(csa); tmc_flush_and_stop(drvdata); /* @@ -1106,7 +1109,7 @@ static void __tmc_etr_disable_hw(struct tmc_drvdata *drvdata) tmc_disable_hw(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); } @@ -1482,6 +1485,7 @@ tmc_update_etr_buffer(struct coresight_device *csdev, struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); struct etr_perf_buffer *etr_perf = config; struct etr_buf *etr_buf = etr_perf->etr_buf; + struct csdev_access *csa = &csdev->access; spin_lock_irqsave(&drvdata->spinlock, flags); @@ -1497,12 +1501,12 @@ tmc_update_etr_buffer(struct coresight_device *csdev, goto out; } - CS_UNLOCK(drvdata->base); + CS_UNLOCK(csa); tmc_flush_and_stop(drvdata); tmc_sync_etr_buf(drvdata); - CS_LOCK(drvdata->base); + CS_LOCK(csa); spin_unlock_irqrestore(&drvdata->spinlock, flags); lost = etr_buf->full; diff --git a/drivers/hwtracing/coresight/coresight-tpiu.c b/drivers/hwtracing/coresight/coresight-tpiu.c index 7dd8300cf6be..dd38be482c21 100644 --- a/drivers/hwtracing/coresight/coresight-tpiu.c +++ b/drivers/hwtracing/coresight/coresight-tpiu.c @@ -62,11 +62,11 @@ struct tpiu_drvdata { static void tpiu_enable_hw(struct csdev_access *csa) { - CS_UNLOCK(csa->base); + CS_UNLOCK(csa); /* TODO: fill this up */ - CS_LOCK(csa->base); + CS_LOCK(csa); } static int tpiu_enable(struct coresight_device *csdev, u32 mode, void *__unused) @@ -79,7 +79,8 @@ static int tpiu_enable(struct coresight_device *csdev, u32 mode, void *__unused) static void tpiu_disable_hw(struct csdev_access *csa) { - CS_UNLOCK(csa->base); + + CS_UNLOCK(csa); /* Clear formatter and stop on flush */ csdev_access_relaxed_write32(csa, FFCR_STOP_FI, TPIU_FFCR); @@ -90,7 +91,7 @@ static void tpiu_disable_hw(struct csdev_access *csa) /* Wait for formatter to stop */ coresight_timeout(csa, TPIU_FFSR, FFSR_FT_STOPPED_BIT, 1); - CS_LOCK(csa->base); + CS_LOCK(csa); } static int tpiu_disable(struct coresight_device *csdev) diff --git a/drivers/hwtracing/coresight/coresight.c b/drivers/hwtracing/coresight/coresight.c index 7545a22769c4..64353ee0a2bc 100644 --- a/drivers/hwtracing/coresight/coresight.c +++ b/drivers/hwtracing/coresight/coresight.c @@ -192,9 +192,9 @@ int coresight_claim_device(struct coresight_device *csdev) if (WARN_ON(!csdev)) return -EINVAL; - CS_UNLOCK(csdev->access.base); + CS_UNLOCK(&csdev->access); rc = coresight_claim_device_unlocked(csdev); - CS_LOCK(csdev->access.base); + CS_LOCK(&csdev->access); return rc; } @@ -225,9 +225,9 @@ void coresight_disclaim_device(struct coresight_device *csdev) if (WARN_ON(!csdev)) return; - CS_UNLOCK(csdev->access.base); + CS_UNLOCK(&csdev->access); coresight_disclaim_device_unlocked(csdev); - CS_LOCK(csdev->access.base); + CS_LOCK(&csdev->access); } /* enable or disable an associated CTI device of the supplied CS device */ -- 2.24.1 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel