kpriv/linux-hardened
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
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
1 changed files with 26 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
drivers/dma/edma.c
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));