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>
This commit is contained in:
Peter Ujfalusi 2015-10-14 14:43:05 +03:00 committed by Vinod Koul
parent 4ab54f696d
commit 7a73b135cd

View file

@ -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));