lkml.org 
[lkml]   [2020]   [Oct]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v3 10/26] coresight: Convert claim/disclaim operations to use access wrappers
    Date
    Convert the generic CLAIM tag management APIs to use the
    device access layer abstraction.

    Cc: Mathieu Poirier <mathieu.poirier@linaro.org>
    Cc: Mike Leach <mike.leach@linaro.org>
    Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
    ---
    drivers/hwtracing/coresight/coresight-catu.c | 6 +-
    drivers/hwtracing/coresight/coresight-core.c | 66 +++++++++++--------
    .../hwtracing/coresight/coresight-cti-core.c | 17 +++--
    drivers/hwtracing/coresight/coresight-etb10.c | 4 +-
    .../coresight/coresight-etm3x-core.c | 8 ++-
    .../coresight/coresight-etm4x-core.c | 4 +-
    .../hwtracing/coresight/coresight-funnel.c | 6 +-
    .../coresight/coresight-replicator.c | 16 +++--
    .../hwtracing/coresight/coresight-tmc-etf.c | 10 +--
    .../hwtracing/coresight/coresight-tmc-etr.c | 4 +-
    include/linux/coresight.h | 16 ++---
    11 files changed, 95 insertions(+), 62 deletions(-)

    diff --git a/drivers/hwtracing/coresight/coresight-catu.c b/drivers/hwtracing/coresight/coresight-catu.c
    index 34c74b05c542..438063523463 100644
    --- a/drivers/hwtracing/coresight/coresight-catu.c
    +++ b/drivers/hwtracing/coresight/coresight-catu.c
    @@ -412,6 +412,7 @@ static int catu_enable_hw(struct catu_drvdata *drvdata, void *data)
    u32 control, mode;
    struct etr_buf *etr_buf = data;
    struct device *dev = &drvdata->csdev->dev;
    + struct coresight_device *csdev = drvdata->csdev;

    if (catu_wait_for_ready(drvdata))
    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;
    }

    - rc = coresight_claim_device_unlocked(drvdata->base);
    + rc = coresight_claim_device_unlocked(csdev);
    if (rc)
    return rc;

    @@ -466,9 +467,10 @@ static int catu_disable_hw(struct catu_drvdata *drvdata)
    {
    int rc = 0;
    struct device *dev = &drvdata->csdev->dev;
    + struct coresight_device *csdev = drvdata->csdev;

    catu_write_control(drvdata, 0);
    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);
    if (catu_wait_for_ready(drvdata)) {
    dev_info(dev, "Timeout while waiting for READY\n");
    rc = -EAGAIN;
    diff --git a/drivers/hwtracing/coresight/coresight-core.c b/drivers/hwtracing/coresight/coresight-core.c
    index 42ba989a6b5e..4e7dd5941046 100644
    --- a/drivers/hwtracing/coresight/coresight-core.c
    +++ b/drivers/hwtracing/coresight/coresight-core.c
    @@ -145,30 +145,32 @@ static int coresight_find_link_outport(struct coresight_device *csdev,
    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();
    }

    -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();
    }

    @@ -182,27 +184,33 @@ static inline void coresight_clear_claim_tags(void __iomem *base)
    * Called with CS_UNLOCKed for the component.
    * 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;

    - coresight_set_claim_tags(base);
    - if (coresight_is_claimed_self_hosted(base))
    + coresight_set_claim_tags(csdev);
    + if (coresight_is_claimed_self_hosted(csdev))
    return 0;
    /* There was a race setting the tags, clean up and fail */
    - coresight_clear_claim_tags(base);
    + coresight_clear_claim_tags(csdev);
    return -EBUSY;
    }
    EXPORT_SYMBOL_GPL(coresight_claim_device_unlocked);

    -int coresight_claim_device(void __iomem *base)
    +int coresight_claim_device(struct coresight_device *csdev)
    {
    int rc;

    - CS_UNLOCK(base);
    - rc = coresight_claim_device_unlocked(base);
    - CS_LOCK(base);
    + if (WARN_ON(!csdev))
    + return -EINVAL;
    +
    + CS_UNLOCK(csdev->access.base);
    + rc = coresight_claim_device_unlocked(csdev);
    + CS_LOCK(csdev->access.base);

    return rc;
    }
    @@ -212,11 +220,14 @@ EXPORT_SYMBOL_GPL(coresight_claim_device);
    * coresight_disclaim_device_unlocked : Clear the claim tags for the device.
    * 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))
    - coresight_clear_claim_tags(base);
    + if (WARN_ON(!csdev))
    + return;
    +
    + if (coresight_is_claimed_self_hosted(csdev))
    + coresight_clear_claim_tags(csdev);
    else
    /*
    * 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);

    -void coresight_disclaim_device(void __iomem *base)
    +void coresight_disclaim_device(struct coresight_device *csdev)
    {
    - CS_UNLOCK(base);
    - coresight_disclaim_device_unlocked(base);
    - CS_LOCK(base);
    + if (WARN_ON(!csdev))
    + return;
    +
    + CS_UNLOCK(csdev->access.base);
    + coresight_disclaim_device_unlocked(csdev);
    + CS_LOCK(csdev->access.base);
    }
    EXPORT_SYMBOL_GPL(coresight_disclaim_device);

    diff --git a/drivers/hwtracing/coresight/coresight-cti-core.c b/drivers/hwtracing/coresight/coresight-cti-core.c
    index 3bb0de97d66e..5651d7f61a70 100644
    --- a/drivers/hwtracing/coresight/coresight-cti-core.c
    +++ b/drivers/hwtracing/coresight/coresight-cti-core.c
    @@ -102,7 +102,7 @@ static int cti_enable_hw(struct cti_drvdata *drvdata)
    goto cti_state_unchanged;

    /* claim the device */
    - rc = coresight_claim_device(drvdata->base);
    + rc = coresight_claim_device(drvdata->csdev);
    if (rc)
    goto cti_err_not_enabled;

    @@ -136,7 +136,7 @@ static void cti_cpuhp_enable_hw(struct cti_drvdata *drvdata)
    goto cti_hp_not_enabled;

    /* try to claim the device */
    - if (coresight_claim_device(drvdata->base))
    + if (coresight_claim_device(drvdata->csdev))
    goto cti_hp_not_enabled;

    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 device *dev = &drvdata->csdev->dev;
    + struct coresight_device *csdev = drvdata->csdev;

    spin_lock(&drvdata->spinlock);

    @@ -171,7 +172,7 @@ static int cti_disable_hw(struct cti_drvdata *drvdata)
    writel_relaxed(0, drvdata->base + CTICONTROL);
    config->hw_enabled = false;

    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);
    CS_LOCK(drvdata->base);
    spin_unlock(&drvdata->spinlock);
    pm_runtime_put(dev);
    @@ -655,6 +656,7 @@ static int cti_cpu_pm_notify(struct notifier_block *nb, unsigned long cmd,
    void *v)
    {
    struct cti_drvdata *drvdata;
    + struct coresight_device *csdev;
    unsigned int cpu = smp_processor_id();
    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;

    drvdata = cti_cpu_drvdata[cpu];
    + csdev = drvdata->csdev;

    if (WARN_ON_ONCE(drvdata->ctidev.cpu != cpu))
    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 */
    drvdata->config.hw_powered = false;
    if (drvdata->config.hw_enabled)
    - coresight_disclaim_device(drvdata->base);
    + coresight_disclaim_device(csdev);
    break;

    case CPU_PM_ENTER_FAILED:
    drvdata->config.hw_powered = true;
    if (drvdata->config.hw_enabled) {
    - if (coresight_claim_device(drvdata->base))
    + if (coresight_claim_device(csdev))
    drvdata->config.hw_enabled = false;
    }
    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 */
    if (atomic_read(&drvdata->config.enable_req_count)) {
    /* 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;

    drvdata->config.hw_enabled = true;
    @@ -736,7 +739,7 @@ static int cti_dying_cpu(unsigned int cpu)
    spin_lock(&drvdata->spinlock);
    drvdata->config.hw_powered = false;
    if (drvdata->config.hw_enabled)
    - coresight_disclaim_device(drvdata->base);
    + coresight_disclaim_device(drvdata->csdev);
    spin_unlock(&drvdata->spinlock);
    return 0;
    }
    diff --git a/drivers/hwtracing/coresight/coresight-etb10.c b/drivers/hwtracing/coresight/coresight-etb10.c
    index f994a22876d9..0a416883e012 100644
    --- a/drivers/hwtracing/coresight/coresight-etb10.c
    +++ b/drivers/hwtracing/coresight/coresight-etb10.c
    @@ -132,7 +132,7 @@ static void __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)
    return rc;
    @@ -344,7 +344,7 @@ static void etb_disable_hw(struct etb_drvdata *drvdata)
    {
    __etb_disable_hw(drvdata);
    etb_dump_hw(drvdata);
    - coresight_disclaim_device(drvdata->base);
    + coresight_disclaim_device(drvdata->csdev);
    }

    static int etb_disable(struct coresight_device *csdev)
    diff --git a/drivers/hwtracing/coresight/coresight-etm3x-core.c b/drivers/hwtracing/coresight/coresight-etm3x-core.c
    index 36c5b0ae1b43..70d6d809cb47 100644
    --- a/drivers/hwtracing/coresight/coresight-etm3x-core.c
    +++ b/drivers/hwtracing/coresight/coresight-etm3x-core.c
    @@ -358,10 +358,11 @@ static int etm_enable_hw(struct etm_drvdata *drvdata)
    int i, rc;
    u32 etmcr;
    struct etm_config *config = &drvdata->config;
    + struct coresight_device *csdev = drvdata->csdev;

    CS_UNLOCK(drvdata->base);

    - rc = coresight_claim_device_unlocked(drvdata->base);
    + rc = coresight_claim_device_unlocked(csdev);
    if (rc)
    goto done;

    @@ -566,6 +567,7 @@ static void etm_disable_hw(void *info)
    int i;
    struct etm_drvdata *drvdata = info;
    struct etm_config *config = &drvdata->config;
    + struct coresight_device *csdev = drvdata->csdev;

    CS_UNLOCK(drvdata->base);
    etm_set_prog(drvdata);
    @@ -577,7 +579,7 @@ static void etm_disable_hw(void *info)
    config->cntr_val[i] = etm_readl(drvdata, ETMCNTVRn(i));

    etm_set_pwrdwn(drvdata);
    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);

    CS_LOCK(drvdata->base);

    @@ -602,7 +604,7 @@ static void etm_disable_perf(struct coresight_device *csdev)
    * power down the tracer.
    */
    etm_set_pwrdwn(drvdata);
    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);

    CS_LOCK(drvdata->base);
    }
    diff --git a/drivers/hwtracing/coresight/coresight-etm4x-core.c b/drivers/hwtracing/coresight/coresight-etm4x-core.c
    index 2744aadaa5ec..4f1bcf98fefe 100644
    --- a/drivers/hwtracing/coresight/coresight-etm4x-core.c
    +++ b/drivers/hwtracing/coresight/coresight-etm4x-core.c
    @@ -115,7 +115,7 @@ static int etm4_enable_hw(struct etmv4_drvdata *drvdata)

    etm4_os_unlock(drvdata);

    - rc = coresight_claim_device_unlocked(drvdata->base);
    + rc = coresight_claim_device_unlocked(csdev);
    if (rc)
    goto done;

    @@ -523,7 +523,7 @@ static void etm4_disable_hw(void *info)
    readl_relaxed(drvdata->base + TRCCNTVRn(i));
    }

    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);

    CS_LOCK(drvdata->base);

    diff --git a/drivers/hwtracing/coresight/coresight-funnel.c b/drivers/hwtracing/coresight/coresight-funnel.c
    index f77466aea26f..2f8675c527bf 100644
    --- a/drivers/hwtracing/coresight/coresight-funnel.c
    +++ b/drivers/hwtracing/coresight/coresight-funnel.c
    @@ -52,13 +52,14 @@ static int dynamic_funnel_enable_hw(struct funnel_drvdata *drvdata, int port)
    {
    u32 functl;
    int rc = 0;
    + struct coresight_device *csdev = drvdata->csdev;

    CS_UNLOCK(drvdata->base);

    functl = readl_relaxed(drvdata->base + FUNNEL_FUNCTL);
    /* Claim the device only when we enable the first slave */
    if (!(functl & FUNNEL_ENSx_MASK)) {
    - rc = coresight_claim_device_unlocked(drvdata->base);
    + rc = coresight_claim_device_unlocked(csdev);
    if (rc)
    goto done;
    }
    @@ -101,6 +102,7 @@ static void dynamic_funnel_disable_hw(struct funnel_drvdata *drvdata,
    int inport)
    {
    u32 functl;
    + struct coresight_device *csdev = drvdata->csdev;

    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 */
    if (!(functl & FUNNEL_ENSx_MASK))
    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);

    CS_LOCK(drvdata->base);
    }
    diff --git a/drivers/hwtracing/coresight/coresight-replicator.c b/drivers/hwtracing/coresight/coresight-replicator.c
    index fcf25740116c..e35d79e74e30 100644
    --- a/drivers/hwtracing/coresight/coresight-replicator.c
    +++ b/drivers/hwtracing/coresight/coresight-replicator.c
    @@ -45,12 +45,18 @@ struct replicator_drvdata {

    static void dynamic_replicator_reset(struct replicator_drvdata *drvdata)
    {
    + struct coresight_device *csdev = drvdata->csdev;
    CS_UNLOCK(drvdata->base);

    - if (!coresight_claim_device_unlocked(drvdata->base)) {
    + if (WARN_ON(!csdev))
    + return;
    +
    + CS_UNLOCK(drvdata->base);
    +
    + if (!coresight_claim_device_unlocked(csdev)) {
    writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER0);
    writel_relaxed(0xff, drvdata->base + REPLICATOR_IDFILTER1);
    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);
    }

    CS_LOCK(drvdata->base);
    @@ -70,6 +76,7 @@ static int dynamic_replicator_enable(struct replicator_drvdata *drvdata,
    {
    int rc = 0;
    u32 id0val, id1val;
    + struct coresight_device *csdev = drvdata->csdev;

    CS_UNLOCK(drvdata->base);

    @@ -84,7 +91,7 @@ static int dynamic_replicator_enable(struct replicator_drvdata *drvdata,
    id0val = id1val = 0xff;

    if (id0val == 0xff && id1val == 0xff)
    - rc = coresight_claim_device_unlocked(drvdata->base);
    + rc = coresight_claim_device_unlocked(csdev);

    if (!rc) {
    switch (outport) {
    @@ -140,6 +147,7 @@ static void dynamic_replicator_disable(struct replicator_drvdata *drvdata,
    int inport, int outport)
    {
    u32 reg;
    + struct coresight_device *csdev = drvdata->csdev;

    switch (outport) {
    case 0:
    @@ -160,7 +168,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(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);
    CS_LOCK(drvdata->base);
    }

    diff --git a/drivers/hwtracing/coresight/coresight-tmc-etf.c b/drivers/hwtracing/coresight/coresight-tmc-etf.c
    index 44402d413ebb..3a5605eda68f 100644
    --- a/drivers/hwtracing/coresight/coresight-tmc-etf.c
    +++ b/drivers/hwtracing/coresight/coresight-tmc-etf.c
    @@ -37,7 +37,7 @@ static void __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)
    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)
    {
    __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)
    @@ -109,7 +109,7 @@ static void __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)
    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)
    {
    + struct coresight_device *csdev = drvdata->csdev;
    +
    CS_UNLOCK(drvdata->base);

    tmc_flush_and_stop(drvdata);
    tmc_disable_hw(drvdata);
    - coresight_disclaim_device_unlocked(drvdata->base);
    + coresight_disclaim_device_unlocked(csdev);
    CS_LOCK(drvdata->base);
    }

    diff --git a/drivers/hwtracing/coresight/coresight-tmc-etr.c b/drivers/hwtracing/coresight/coresight-tmc-etr.c
    index 714f9e867e5f..a8b1c49761c7 100644
    --- a/drivers/hwtracing/coresight/coresight-tmc-etr.c
    +++ b/drivers/hwtracing/coresight/coresight-tmc-etr.c
    @@ -1038,7 +1038,7 @@ static int tmc_etr_enable_hw(struct tmc_drvdata *drvdata,
    rc = tmc_etr_enable_catu(drvdata, etr_buf);
    if (rc)
    return rc;
    - rc = coresight_claim_device(drvdata->base);
    + rc = coresight_claim_device(drvdata->csdev);
    if (!rc) {
    drvdata->etr_buf = etr_buf;
    __tmc_etr_enable_hw(drvdata);
    @@ -1132,7 +1132,7 @@ void tmc_etr_disable_hw(struct tmc_drvdata *drvdata)
    __tmc_etr_disable_hw(drvdata);
    /* Disable CATU device if this ETR is connected to one */
    tmc_etr_disable_catu(drvdata);
    - coresight_disclaim_device(drvdata->base);
    + coresight_disclaim_device(drvdata->csdev);
    /* Reset the ETR buf used by hardware */
    drvdata->etr_buf = NULL;
    }
    diff --git a/include/linux/coresight.h b/include/linux/coresight.h
    index cefc8fe239e6..c2d0a2aea45f 100644
    --- a/include/linux/coresight.h
    +++ b/include/linux/coresight.h
    @@ -474,11 +474,11 @@ extern int coresight_timeout(struct csdev_access *csa,
    int position,
    int value);

    -extern int coresight_claim_device(void __iomem *base);
    -extern int coresight_claim_device_unlocked(void __iomem *base);
    +extern int coresight_claim_device(struct coresight_device *csdev);
    +extern int coresight_claim_device_unlocked(struct coresight_device *csdev);

    -extern void coresight_disclaim_device(void __iomem *base);
    -extern void coresight_disclaim_device_unlocked(void __iomem *base);
    +extern void coresight_disclaim_device(struct coresight_device *csdev);
    +extern void coresight_disclaim_device_unlocked(struct coresight_device *csdev);
    extern char *coresight_alloc_device_name(struct coresight_dev_list *devs,
    struct device *dev);

    @@ -513,18 +513,18 @@ static inline int coresight_timeout(struct csdev_access *csa,
    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;
    }

    -static inline int coresight_claim_device(void __iomem *base)
    +static inline int coresight_claim_device(struct coresight_device *csdev)
    {
    return -EINVAL;
    }

    -static inline void coresight_disclaim_device(void __iomem *base) {}
    -static inline void coresight_disclaim_device_unlocked(void __iomem *base) {}
    +static inline void coresight_disclaim_device(struct coresight_device *csdev) {}
    +static inline void coresight_disclaim_device_unlocked(struct coresight_device *csdev) {}

    static inline bool coresight_loses_context_with_cpu(struct device *dev)
    {
    --
    2.24.1
    \
     
     \ /
      Last update: 2020-10-28 23:11    [W:4.290 / U:0.612 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site