drivers: mcux_edma: refactor configure func more

Split this function up even more

Signed-off-by: Declan Snyder <declan.snyder@nxp.com>

Author: decsny

drivers/dma/dma_mcux_edma.c

@@ -280,15 +280,16 @@ static void dma_mcux_edma_multi_channels_irq_handler(const struct device *dev, u
 
 #if defined(FSL_FEATURE_SOC_DMAMUX_COUNT) && FSL_FEATURE_SOC_DMAMUX_COUNT
 static void edma_configure_dmamux(const struct device *dev, uint32_t channel,
-				   struct dma_config *config, edma_transfer_type_t transfer_type)
+				   struct dma_config *config)
 {
+	uint8_t dmamux_channel = DEV_DMAMUX_CHANNEL(dev, channel);
+	uint8_t dmamux_idx = DEV_DMAMUX_IDX(dev, channel);
 	uint32_t slot = config->dma_slot;
-	uint8_t dmamux_idx, dmamux_channel;
-
-	dmamux_idx = DEV_DMAMUX_IDX(dev, channel);
-	dmamux_channel = DEV_DMAMUX_CHANNEL(dev, channel);
 
 #if DT_INST_PROP(0, nxp_a_on)
+	struct call_back *data = DEV_CHANNEL_DATA(dev, channel);
+	edma_transfer_type_t transfer_type = data->transfer_settings.transfer_type;
+
 	if (config->source_handshake || config->dest_handshake ||
 	    transfer_type == kEDMA_MemoryToMemory) {
 		/*software trigger make the channel always on*/
@@ -317,6 +318,22 @@ static void edma_log_dmamux(const struct device *dev, uint32_t channel)
 #define edma_log_dmamux(...)
 #endif /* FSL_FEATURE_SOC_DMA_MUX_COUNT */
 
+static inline void dma_mcux_edma_configure_muxes(const struct device *dev, uint32_t channel,
+						 struct dma_config *config)
+{
+	edma_configure_dmamux(dev, channel, config);
+
+#if defined(FSL_FEATURE_EDMA_HAS_CHANNEL_MUX) && FSL_FEATURE_EDMA_HAS_CHANNEL_MUX
+	uint32_t slot = config->dma_slot;
+	uint32_t hw_channel = dma_mcux_edma_add_channel_gap(dev, channel);
+
+	/* First release any peripheral previously associated with this channel */
+	EDMA_SetChannelMux(DEV_BASE(dev), hw_channel, 0);
+	EDMA_SetChannelMux(DEV_BASE(dev), hw_channel, slot);
+#endif
+}
+
+
 static int dma_mcux_edma_configure_sg_loop(const struct device *dev,
 					   uint32_t channel,
 					   struct dma_config *config,
@@ -471,24 +488,52 @@ static int dma_mcux_edma_configure_basic(const struct device *dev,
 	return ret;
 }
 
-/* Configure a channel */
-static int dma_mcux_edma_configure(const struct device *dev, uint32_t channel,
-				   struct dma_config *config)
+static void dma_mcux_edma_configure_hardware(const struct device *dev, uint32_t channel,
+					     struct dma_config *config)
+{
+	struct call_back *data = DEV_CHANNEL_DATA(dev, channel);
+	edma_transfer_type_t transfer_type = data->transfer_settings.transfer_type;
+	struct dma_block_config *block_config = config->head_block;
+	bool sg_mode = block_config->source_gather_en || block_config->dest_scatter_en;
+	uint32_t hw_channel = dma_mcux_edma_add_channel_gap(dev, channel);
+
+	dma_mcux_edma_configure_muxes(dev, channel, config);
+
+	if (sg_mode && config->cyclic) {
+		dma_mcux_edma_configure_sg_loop(dev, channel, config, transfer_type);
+	} else if (sg_mode) {
+		dma_mcux_edma_configure_sg_dynamic(dev, channel, config, transfer_type);
+	} else {
+		dma_mcux_edma_configure_basic(dev, channel, config, transfer_type);
+	}
+
+	if (config->dest_chaining_en) {
+		LOG_DBG("link major channel %d", config->linked_channel);
+		EDMA_SetChannelLink(DEV_BASE(dev), channel, kEDMA_MajorLink,
+				    config->linked_channel);
+	}
+	if (config->source_chaining_en) {
+		LOG_DBG("link minor channel %d", config->linked_channel);
+		EDMA_SetChannelLink(DEV_BASE(dev), channel, kEDMA_MinorLink,
+				    config->linked_channel);
+	}
+
+	EDMA_EnableChannelInterrupts(DEV_BASE(dev), hw_channel, kEDMA_ErrorInterruptEnable);
+}
+
+static inline int dma_mcux_edma_validate_cfg(const struct device *dev,
+					     uint32_t channel,
+					     struct dma_config *config)
 {
 	/* Check for invalid parameters before dereferencing them. */
 	if (NULL == dev || NULL == config) {
 		return -EINVAL;
 	}
 
-	uint32_t hw_channel = dma_mcux_edma_add_channel_gap(dev, channel);
-	edma_handle_t *p_handle = DEV_EDMA_HANDLE(dev, channel);
 	struct call_back *data = DEV_CHANNEL_DATA(dev, channel);
 	struct dma_block_config *block_config = config->head_block;
-	bool sg_mode = block_config->source_gather_en || block_config->dest_scatter_en;
 	uint32_t slot = config->dma_slot;
-	edma_transfer_type_t transfer_type;
-	unsigned int key;
-	int ret = 0;
+	edma_transfer_type_t *type = &data->transfer_settings.transfer_type;
 
 	if (slot >= DEV_CFG(dev)->dma_requests) {
 		LOG_ERR("source number is out of scope %d", slot);
@@ -499,27 +544,10 @@ static int dma_mcux_edma_configure(const struct device *dev, uint32_t channel,
 		LOG_ERR("out of DMA channel %d", channel);
 		return -EINVAL;
 	}
+	LOG_DBG("channel is %d", channel);
 
 	data->transfer_settings.valid = false;
 
-	switch (config->channel_direction) {
-	case MEMORY_TO_MEMORY:
-		transfer_type = kEDMA_MemoryToMemory;
-		break;
-	case MEMORY_TO_PERIPHERAL:
-		transfer_type = kEDMA_MemoryToPeripheral;
-		break;
-	case PERIPHERAL_TO_MEMORY:
-		transfer_type = kEDMA_PeripheralToMemory;
-		break;
-	case PERIPHERAL_TO_PERIPHERAL:
-		transfer_type = kEDMA_PeripheralToPeripheral;
-		break;
-	default:
-		LOG_ERR("not support transfer direction");
-		return -EINVAL;
-	}
-
 	if (!data_size_valid(config->source_data_size)) {
 		LOG_ERR("Source unit size error, %d", config->source_data_size);
 		return -EINVAL;
@@ -537,60 +565,88 @@ static int dma_mcux_edma_configure(const struct device *dev, uint32_t channel,
 		}
 	}
 
-	data->transfer_settings.source_data_size = config->source_data_size;
-	data->transfer_settings.dest_data_size = config->dest_data_size;
-	data->transfer_settings.source_burst_length = config->source_burst_length;
-	data->transfer_settings.dest_burst_length = config->dest_burst_length;
-	data->transfer_settings.direction = config->channel_direction;
-	data->transfer_settings.transfer_type = transfer_type;
-	data->transfer_settings.valid = true;
-	data->transfer_settings.cyclic = config->cyclic;
+	switch (config->channel_direction) {
+	case MEMORY_TO_MEMORY:
+		*type = kEDMA_MemoryToMemory;
+		break;
+	case MEMORY_TO_PERIPHERAL:
+		*type = kEDMA_MemoryToPeripheral;
+		break;
+	case PERIPHERAL_TO_MEMORY:
+		*type = kEDMA_PeripheralToMemory;
+		break;
+	case PERIPHERAL_TO_PERIPHERAL:
+		*type = kEDMA_PeripheralToPeripheral;
+		break;
+	default:
+		LOG_ERR("not support transfer direction");
+		return -EINVAL;
+	}
 
-	/* Lock and page in the channel configuration */
-	key = irq_lock();
+	return 0;
+}
+
+/* fills out transfer settings struct based on api config */
+static inline void dma_mcux_edma_set_xfer_settings(const struct device *dev, uint32_t channel,
+						   struct dma_config *config)
+{
+	struct call_back *data = DEV_CHANNEL_DATA(dev, channel);
+	struct dma_mcux_channel_transfer_edma_settings *xfer_settings = &data->transfer_settings;
+
+	xfer_settings->source_burst_length = config->source_burst_length;
+	xfer_settings->dest_burst_length = config->dest_burst_length;
+	xfer_settings->source_data_size = config->source_data_size;
+	xfer_settings->dest_data_size = config->dest_data_size;
+	xfer_settings->direction = config->channel_direction;
+	xfer_settings->valid = true;
+	xfer_settings->cyclic = config->cyclic;
+}
 
-	edma_configure_dmamux(dev, channel, config, transfer_type);
+/* stops, resets, and creates new MCUX SDK handle for a channel */
+static inline void dma_mcux_edma_reset_channel(const struct device *dev, uint32_t channel)
+{
+	struct call_back *data = DEV_CHANNEL_DATA(dev, channel);
+	edma_handle_t *p_handle = DEV_EDMA_HANDLE(dev, channel);
+	uint32_t hw_channel = dma_mcux_edma_add_channel_gap(dev, channel);
 
 	if (data->busy) {
 		EDMA_AbortTransfer(p_handle);
 	}
+
 	EDMA_ResetChannel(DEV_BASE(dev), hw_channel);
 	EDMA_CreateHandle(p_handle, DEV_BASE(dev), hw_channel);
 	EDMA_SetCallback(p_handle, nxp_edma_callback, (void *)data);
+}
 
-#if defined(FSL_FEATURE_EDMA_HAS_CHANNEL_MUX) && FSL_FEATURE_EDMA_HAS_CHANNEL_MUX
-	/* First release any peripheral previously associated with this channel */
-	EDMA_SetChannelMux(DEV_BASE(dev), hw_channel, 0);
-	EDMA_SetChannelMux(DEV_BASE(dev), hw_channel, slot);
-#endif
 
-	LOG_DBG("channel is %d", channel);
-	EDMA_EnableChannelInterrupts(DEV_BASE(dev), hw_channel, kEDMA_ErrorInterruptEnable);
+/* Configure a channel */
+static int dma_mcux_edma_configure(const struct device *dev, uint32_t channel,
+				   struct dma_config *config)
+{
+	unsigned int key;
+	int ret = 0;
+
+	ret = dma_mcux_edma_validate_cfg(dev, channel, config);
+	if (ret) {
+		return ret;
+	}
+
+	dma_mcux_edma_set_xfer_settings(dev, channel, config);
+
+	/* Lock and page in the channel configuration */
+	key = irq_lock();
+
+	dma_mcux_edma_reset_channel(dev, channel);
 
 	/* Initialize all TCD pool as 0*/
 	for (int i = 0; i < CONFIG_DMA_TCD_QUEUE_SIZE; i++) {
 		memset(&DEV_CFG(dev)->tcdpool[channel][i], 0,
 		       sizeof(DEV_CFG(dev)->tcdpool[channel][i]));
 	}
 
-	if (sg_mode && config->cyclic) {
-		dma_mcux_edma_configure_sg_loop(dev, channel, config, transfer_type);
-	} else if (sg_mode) {
-		dma_mcux_edma_configure_sg_dynamic(dev, channel, config, transfer_type);
-	} else {
-		dma_mcux_edma_configure_basic(dev, channel, config, transfer_type);
-	}
+	dma_mcux_edma_configure_hardware(dev, channel, config);
 
-	if (config->dest_chaining_en) {
-		LOG_DBG("link major channel %d", config->linked_channel);
-		EDMA_SetChannelLink(DEV_BASE(dev), channel, kEDMA_MajorLink,
-				    config->linked_channel);
-	}
-	if (config->source_chaining_en) {
-		LOG_DBG("link minor channel %d", config->linked_channel);
-		EDMA_SetChannelLink(DEV_BASE(dev), channel, kEDMA_MinorLink,
-				    config->linked_channel);
-	}
+	struct call_back *data = DEV_CHANNEL_DATA(dev, channel);
 
 	data->busy = false;
 	if (config->dma_callback) {
@@ -602,7 +658,7 @@ static int dma_mcux_edma_configure(const struct device *dev, uint32_t channel,
 
 	irq_unlock(key);
 
-	return ret;
+	return 0;
 }
 
 static int dma_mcux_edma_start(const struct device *dev, uint32_t channel)