ste_dma40: Rename a jump label in __d40_execute_command_phy()

[cascardo/linux.git] / drivers / dma / ste_dma40.c

diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 4b89a35..82314b7 100644 (file)
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -1083,7 +1083,7 @@ static int __d40_execute_command_phy(struct d40_chan *d40c,
                        D40_CHAN_POS(d40c->phy_chan->num);
 
                if (status == D40_DMA_SUSPENDED || status == D40_DMA_STOP)
-                       goto done;
+                       goto unlock;
        }
 
        wmask = 0xffffffff & ~(D40_CHAN_POS_MASK(d40c->phy_chan->num));
@@ -1119,7 +1119,7 @@ static int __d40_execute_command_phy(struct d40_chan *d40c,
                }
 
        }
-done:
+ unlock:
        spin_unlock_irqrestore(&d40c->base->execmd_lock, flags);
        return ret;
 }
@@ -1607,7 +1607,7 @@ static void dma_tasklet(unsigned long data)
                /* Check if we have reached here for cyclic job */
                d40d = d40_first_active_get(d40c);
                if (d40d == NULL || !d40d->cyclic)
-                       goto err;
+                       goto check_pending_tx;
        }
 
        if (!d40d->cyclic)
@@ -1650,8 +1650,7 @@ static void dma_tasklet(unsigned long data)
                callback(callback_param);
 
        return;
-
-err:
+ check_pending_tx:
        /* Rescue manouver if receiving double interrupts */
        if (d40c->pending_tx > 0)
                d40c->pending_tx--;
@@ -1780,42 +1779,40 @@ static bool d40_alloc_mask_set(struct d40_phy_res *phy,
                    phy->allocated_dst == D40_ALLOC_FREE) {
                        phy->allocated_dst = D40_ALLOC_PHY;
                        phy->allocated_src = D40_ALLOC_PHY;
-                       goto found;
+                       goto found_unlock;
                } else
-                       goto not_found;
+                       goto not_found_unlock;
        }
 
        /* Logical channel */
        if (is_src) {
                if (phy->allocated_src == D40_ALLOC_PHY)
-                       goto not_found;
+                       goto not_found_unlock;
 
                if (phy->allocated_src == D40_ALLOC_FREE)
                        phy->allocated_src = D40_ALLOC_LOG_FREE;
 
                if (!(phy->allocated_src & BIT(log_event_line))) {
                        phy->allocated_src |= BIT(log_event_line);
-                       goto found;
+                       goto found_unlock;
                } else
-                       goto not_found;
+                       goto not_found_unlock;
        } else {
                if (phy->allocated_dst == D40_ALLOC_PHY)
-                       goto not_found;
+                       goto not_found_unlock;
 
                if (phy->allocated_dst == D40_ALLOC_FREE)
                        phy->allocated_dst = D40_ALLOC_LOG_FREE;
 
                if (!(phy->allocated_dst & BIT(log_event_line))) {
                        phy->allocated_dst |= BIT(log_event_line);
-                       goto found;
-               } else
-                       goto not_found;
+                       goto found_unlock;
+               }
        }
-
-not_found:
+ not_found_unlock:
        spin_unlock_irqrestore(&phy->lock, flags);
        return false;
-found:
+ found_unlock:
        spin_unlock_irqrestore(&phy->lock, flags);
        return true;
 }
@@ -1831,7 +1828,7 @@ static bool d40_alloc_mask_free(struct d40_phy_res *phy, bool is_src,
                phy->allocated_dst = D40_ALLOC_FREE;
                phy->allocated_src = D40_ALLOC_FREE;
                is_free = true;
-               goto out;
+               goto unlock;
        }
 
        /* Logical channel */
@@ -1847,8 +1844,7 @@ static bool d40_alloc_mask_free(struct d40_phy_res *phy, bool is_src,
 
        is_free = ((phy->allocated_src | phy->allocated_dst) ==
                   D40_ALLOC_FREE);
-
-out:
+ unlock:
        spin_unlock_irqrestore(&phy->lock, flags);
 
        return is_free;
@@ -2047,7 +2043,7 @@ static int d40_free_dma(struct d40_chan *d40c)
        res = d40_channel_execute_command(d40c, D40_DMA_STOP);
        if (res) {
                chan_err(d40c, "stop failed\n");
-               goto out;
+               goto mark_last_busy;
        }
 
        d40_alloc_mask_free(phy, is_src, chan_is_logical(d40c) ? event : 0);
@@ -2065,8 +2061,7 @@ static int d40_free_dma(struct d40_chan *d40c)
        d40c->busy = false;
        d40c->phy_chan = NULL;
        d40c->configured = false;
-out:
-
+ mark_last_busy:
        pm_runtime_mark_last_busy(d40c->base->dev);
        pm_runtime_put_autosuspend(d40c->base->dev);
        return res;
@@ -2094,8 +2089,7 @@ static bool d40_is_paused(struct d40_chan *d40c)
                        D40_CHAN_POS(d40c->phy_chan->num);
                if (status == D40_DMA_SUSPENDED || status == D40_DMA_STOP)
                        is_paused = true;
-
-               goto _exit;
+               goto unlock;
        }
 
        if (d40c->dma_cfg.dir == DMA_MEM_TO_DEV ||
@@ -2105,7 +2099,7 @@ static bool d40_is_paused(struct d40_chan *d40c)
                status = readl(chanbase + D40_CHAN_REG_SSLNK);
        } else {
                chan_err(d40c, "Unknown direction\n");
-               goto _exit;
+               goto unlock;
        }
 
        status = (status & D40_EVENTLINE_MASK(event)) >>
@@ -2113,7 +2107,7 @@ static bool d40_is_paused(struct d40_chan *d40c)
 
        if (status != D40_DMA_RUN)
                is_paused = true;
-_exit:
+ unlock:
        spin_unlock_irqrestore(&d40c->lock, flags);
        return is_paused;
 
@@ -2198,7 +2192,7 @@ static struct d40_desc *
 d40_prep_desc(struct d40_chan *chan, struct scatterlist *sg,
              unsigned int sg_len, unsigned long dma_flags)
 {
-       struct stedma40_chan_cfg *cfg = &chan->dma_cfg;
+       struct stedma40_chan_cfg *cfg;
        struct d40_desc *desc;
        int ret;
 
@@ -2206,17 +2200,18 @@ d40_prep_desc(struct d40_chan *chan, struct scatterlist *sg,
        if (!desc)
                return NULL;
 
+       cfg = &chan->dma_cfg;
        desc->lli_len = d40_sg_2_dmalen(sg, sg_len, cfg->src_info.data_width,
                                        cfg->dst_info.data_width);
        if (desc->lli_len < 0) {
                chan_err(chan, "Unaligned size\n");
-               goto err;
+               goto free_desc;
        }
 
        ret = d40_pool_lli_alloc(chan, desc, desc->lli_len);
        if (ret < 0) {
                chan_err(chan, "Could not allocate lli\n");
-               goto err;
+               goto free_desc;
        }
 
        desc->lli_current = 0;
@@ -2226,8 +2221,7 @@ d40_prep_desc(struct d40_chan *chan, struct scatterlist *sg,
        dma_async_tx_descriptor_init(&desc->txd, &chan->chan);
 
        return desc;
-
-err:
+ free_desc:
        d40_desc_free(chan, desc);
        return NULL;
 }
@@ -2238,8 +2232,8 @@ d40_prep_sg(struct dma_chan *dchan, struct scatterlist *sg_src,
            enum dma_transfer_direction direction, unsigned long dma_flags)
 {
        struct d40_chan *chan = container_of(dchan, struct d40_chan, chan);
-       dma_addr_t src_dev_addr = 0;
-       dma_addr_t dst_dev_addr = 0;
+       dma_addr_t src_dev_addr;
+       dma_addr_t dst_dev_addr;
        struct d40_desc *desc;
        unsigned long flags;
        int ret;
@@ -2253,11 +2247,13 @@ d40_prep_sg(struct dma_chan *dchan, struct scatterlist *sg_src,
 
        desc = d40_prep_desc(chan, sg_src, sg_len, dma_flags);
        if (desc == NULL)
-               goto err;
+               goto unlock;
 
        if (sg_next(&sg_src[sg_len - 1]) == sg_src)
                desc->cyclic = true;
 
+       src_dev_addr = 0;
+       dst_dev_addr = 0;
        if (direction == DMA_DEV_TO_MEM)
                src_dev_addr = chan->runtime_addr;
        else if (direction == DMA_MEM_TO_DEV)
@@ -2273,7 +2269,7 @@ d40_prep_sg(struct dma_chan *dchan, struct scatterlist *sg_src,
        if (ret) {
                chan_err(chan, "Failed to prepare %s sg job: %d\n",
                         chan_is_logical(chan) ? "log" : "phy", ret);
-               goto err;
+               goto free_desc;
        }
 
        /*
@@ -2285,10 +2281,9 @@ d40_prep_sg(struct dma_chan *dchan, struct scatterlist *sg_src,
        spin_unlock_irqrestore(&chan->lock, flags);
 
        return &desc->txd;
-
-err:
-       if (desc)
-               d40_desc_free(chan, desc);
+ free_desc:
+       d40_desc_free(chan, desc);
+ unlock:
        spin_unlock_irqrestore(&chan->lock, flags);
        return NULL;
 }
@@ -2426,7 +2421,7 @@ static int d40_alloc_chan_resources(struct dma_chan *chan)
                err = d40_config_memcpy(d40c);
                if (err) {
                        chan_err(d40c, "Failed to configure memcpy channel\n");
-                       goto fail;
+                       goto mark_last_busy;
                }
        }
 
@@ -2434,7 +2429,7 @@ static int d40_alloc_chan_resources(struct dma_chan *chan)
        if (err) {
                chan_err(d40c, "Failed to allocate channel\n");
                d40c->configured = false;
-               goto fail;
+               goto mark_last_busy;
        }
 
        pm_runtime_get_sync(d40c->base->dev);
@@ -2468,7 +2463,7 @@ static int d40_alloc_chan_resources(struct dma_chan *chan)
         */
        if (is_free_phy)
                d40_config_write(d40c);
-fail:
+ mark_last_busy:
        pm_runtime_mark_last_busy(d40c->base->dev);
        pm_runtime_put_autosuspend(d40c->base->dev);
        spin_unlock_irqrestore(&d40c->lock, flags);