dmaengine: edma: Rename bitfields for slot and channel usage tracking

The names chosen for the bitfields were quite confusing and given no real
information on what they are used for...

edma_inuse -> slot_inuse: tracks the slot usage/availability
edma_unused -> channel_unused: tracks the channel usage/availability

Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com>
Signed-off-by: Vinod Koul <vinod.koul@intel.com>

diff --git a/drivers/dma/edma.c b/drivers/dma/edma.c
index 4b2ccc9de0adbb2702fb94e115903bb6e34e9ed6..8d9169b7f20813374ba19058663c7367935b8e6d 100644 (file)
--- a/drivers/dma/edma.c
+++ b/drivers/dma/edma.c
@@ -227,16 +227,16 @@ struct edma_cc {
        enum dma_event_q                default_queue;
 
        bool                            unused_chan_list_done;
-       /* The edma_inuse bit for each PaRAM slot is clear unless the
+       /* The slot_inuse bit for each PaRAM slot is clear unless the
         * channel is in use ... by ARM or DSP, for QDMA, or whatever.
         */
-       unsigned long *edma_inuse;
+       unsigned long *slot_inuse;
 
-       /* The edma_unused bit for each channel is clear unless
+       /* The channel_unused bit for each channel is clear unless
         * it is not being used on this platform. It uses a bit
         * of SOC-specific initialization code.
         */
-       unsigned long *edma_unused;
+       unsigned long *channel_unused;
 
        struct dma_device               dma_slave;
        struct edma_chan                *slave_chans;
@@ -452,7 +452,7 @@ static int prepare_unused_channel_list(struct device *dev, void *data)
                                continue;
 
                        clear_bit(EDMA_CHAN_SLOT(dma_spec.args[0]),
-                                 ecc->edma_unused);
+                                 ecc->channel_unused);
                        of_node_put(dma_spec.np);
                }
                return 0;
@@ -469,7 +469,7 @@ static int prepare_unused_channel_list(struct device *dev, void *data)
                dma_req = (int)res->start;
                if (dma_req >= dma_req_min && dma_req < dma_req_max)
                        clear_bit(EDMA_CHAN_SLOT(pdev->resource[i].start),
-                                 ecc->edma_unused);
+                                 ecc->channel_unused);
        }
 
        return 0;
@@ -533,17 +533,17 @@ static int edma_alloc_slot(struct edma_cc *ecc, int slot)
        if (slot < 0) {
                slot = ecc->num_channels;
                for (;;) {
-                       slot = find_next_zero_bit(ecc->edma_inuse,
+                       slot = find_next_zero_bit(ecc->slot_inuse,
                                                  ecc->num_slots,
                                                  slot);
                        if (slot == ecc->num_slots)
                                return -ENOMEM;
-                       if (!test_and_set_bit(slot, ecc->edma_inuse))
+                       if (!test_and_set_bit(slot, ecc->slot_inuse))
                                break;
                }
        } else if (slot < ecc->num_channels || slot >= ecc->num_slots) {
                return -EINVAL;
-       } else if (test_and_set_bit(slot, ecc->edma_inuse)) {
+       } else if (test_and_set_bit(slot, ecc->slot_inuse)) {
                return -EBUSY;
        }
 
@@ -559,7 +559,7 @@ static void edma_free_slot(struct edma_cc *ecc, unsigned slot)
                return;
 
        edma_write_slot(ecc, slot, &dummy_paramset);
-       clear_bit(slot, ecc->edma_inuse);
+       clear_bit(slot, ecc->slot_inuse);
 }
 
 /**
@@ -631,7 +631,7 @@ static int edma_start(struct edma_cc *ecc, unsigned channel)
                unsigned int mask = BIT(channel & 0x1f);
 
                /* EDMA channels without event association */
-               if (test_bit(channel, ecc->edma_unused)) {
+               if (test_bit(channel, ecc->channel_unused)) {
                        dev_dbg(ecc->dev, "ESR%d %08x\n", j,
                                edma_shadow0_read_array(ecc, SH_ESR, j));
                        edma_shadow0_write_array(ecc, SH_ESR, j, mask);
@@ -835,11 +835,11 @@ static int edma_alloc_channel(struct edma_cc *ecc, int channel,
        if (channel < 0) {
                channel = 0;
                for (;;) {
-                       channel = find_next_bit(ecc->edma_unused,
+                       channel = find_next_bit(ecc->channel_unused,
                                                ecc->num_channels, channel);
                        if (channel == ecc->num_channels)
                                break;
-                       if (!test_and_set_bit(channel, ecc->edma_inuse)) {
+                       if (!test_and_set_bit(channel, ecc->slot_inuse)) {
                                done = 1;
                                break;
                        }
@@ -849,7 +849,7 @@ static int edma_alloc_channel(struct edma_cc *ecc, int channel,
                        return -ENOMEM;
        } else if (channel >= ecc->num_channels) {
                return -EINVAL;
-       } else if (test_and_set_bit(channel, ecc->edma_inuse)) {
+       } else if (test_and_set_bit(channel, ecc->slot_inuse)) {
                return -EBUSY;
        }
 
@@ -895,7 +895,7 @@ static void edma_free_channel(struct edma_cc *ecc, unsigned channel)
        /* REVISIT should probably take out of shadow region 0 */
 
        edma_write_slot(ecc, channel, &dummy_paramset);
-       clear_bit(channel, ecc->edma_inuse);
+       clear_bit(channel, ecc->slot_inuse);
 }
 
 /* Move channel to a specific event queue */
@@ -2137,14 +2137,15 @@ static int edma_probe(struct platform_device *pdev)
        if (!ecc->slave_chans)
                return -ENOMEM;
 
-       ecc->edma_unused = devm_kcalloc(dev, BITS_TO_LONGS(ecc->num_channels),
-                                       sizeof(unsigned long), GFP_KERNEL);
-       if (!ecc->edma_unused)
+       ecc->channel_unused = devm_kcalloc(dev,
+                                          BITS_TO_LONGS(ecc->num_channels),
+                                          sizeof(unsigned long), GFP_KERNEL);
+       if (!ecc->channel_unused)
                return -ENOMEM;
 
-       ecc->edma_inuse = devm_kcalloc(dev, BITS_TO_LONGS(ecc->num_slots),
+       ecc->slot_inuse = devm_kcalloc(dev, BITS_TO_LONGS(ecc->num_slots),
                                       sizeof(unsigned long), GFP_KERNEL);
-       if (!ecc->edma_inuse)
+       if (!ecc->slot_inuse)
                return -ENOMEM;
 
        ecc->default_queue = info->default_queue;
@@ -2153,7 +2154,7 @@ static int edma_probe(struct platform_device *pdev)
                edma_write_slot(ecc, i, &dummy_paramset);
 
        /* Mark all channels as unused */
-       memset(ecc->edma_unused, 0xff, sizeof(ecc->edma_unused));
+       memset(ecc->channel_unused, 0xff, sizeof(ecc->channel_unused));
 
        if (info->rsv) {
                /* Clear the reserved channels in unused list */
@@ -2162,7 +2163,7 @@ static int edma_probe(struct platform_device *pdev)
                        for (i = 0; rsv_chans[i][0] != -1; i++) {
                                off = rsv_chans[i][0];
                                ln = rsv_chans[i][1];
-                               clear_bits(off, ln, ecc->edma_unused);
+                               clear_bits(off, ln, ecc->channel_unused);
                        }
                }
 
@@ -2172,7 +2173,7 @@ static int edma_probe(struct platform_device *pdev)
                        for (i = 0; rsv_slots[i][0] != -1; i++) {
                                off = rsv_slots[i][0];
                                ln = rsv_slots[i][1];
-                               set_bits(off, ln, ecc->edma_inuse);
+                               set_bits(off, ln, ecc->slot_inuse);
                        }
                }
        }
@@ -2182,7 +2183,7 @@ static int edma_probe(struct platform_device *pdev)
        if (xbar_chans) {
                for (i = 0; xbar_chans[i][1] != -1; i++) {
                        off = xbar_chans[i][1];
-                       clear_bits(off, 1, ecc->edma_unused);
+                       clear_bits(off, 1, ecc->channel_unused);
                }
        }
 
@@ -2301,7 +2302,7 @@ static int edma_pm_resume(struct device *dev)
                edma_direct_dmach_to_param_mapping(ecc);
 
        for (i = 0; i < ecc->num_channels; i++) {
-               if (test_bit(i, ecc->edma_inuse)) {
+               if (test_bit(i, ecc->slot_inuse)) {
                        /* ensure access through shadow region 0 */
                        edma_or_array2(ecc, EDMA_DRAE, 0, i >> 5,
                                       BIT(i & 0x1f));