Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7a73b135 authored by Peter Ujfalusi's avatar Peter Ujfalusi Committed by Vinod Koul
Browse files

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: default avatarPeter Ujfalusi <peter.ujfalusi@ti.com>
Signed-off-by: default avatarVinod Koul <vinod.koul@intel.com>
parent 4ab54f69

drivers/dma/edma.c

+26 −25
Original line number Diff line number Diff line
@@ -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),

	ecc->channel_unused = devm_kcalloc(dev,

					   BITS_TO_LONGS(ecc->num_channels),

					   sizeof(unsigned long), GFP_KERNEL);

	if (!ecc->edma_unused)

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