devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

S32 Design Studio PE工具配置DMA

作者：不正经 | 2024-03-21 19:27:08

赞

踩

S32 Design Studio PE工具配置DMA

工具配置

DMA位置跟设备不一样，在Referenced_components里面。

Configurations里面就默认配置就行

channels是比较重要的，一条信号传输用到一个通道。可以选择UART、ADC、CAN之类的，这里用在了SPI通讯里面。

生成代码

在 Generated_Code\dmaController1.c里面，对应刚才配置的信息。

  1. edma_state_t dmaController1_State;
  2.  
  3. edma_chn_state_t dmaController1Chn0_State;
  4.  
  5. edma_chn_state_t dmaController1Chn1_State;
  6.  
  7. edma_chn_state_t * const edmaChnStateArray[] = {
  8.     &dmaController1Chn0_State,
  9.     &dmaController1Chn1_State
  10. };
  11.  
  12. edma_channel_config_t dmaController1Chn0_Config = {//通道0配置
  13.     .channelPriority = EDMA_CHN_DEFAULT_PRIORITY,
  14.     .virtChnConfig = EDMA_CHN0_NUMBER,
  15.     .source = EDMA_REQ_LPSPI0_RX,
  16.     .callback = NULL,
  17.     .callbackParam = NULL,
  18.     .enableTrigger = false
  19. };
  20. edma_channel_config_t dmaController1Chn1_Config = {//通道1配置
  21.     .channelPriority = EDMA_CHN_DEFAULT_PRIORITY,
  22.     .virtChnConfig = EDMA_CHN1_NUMBER,
  23.     .source = EDMA_REQ_LPSPI0_TX,
  24.     .callback = NULL,
  25.     .callbackParam = NULL,
  26.     .enableTrigger = false
  27. };
  28. const edma_channel_config_t * const edmaChnConfigArray[] = {//通道数组
  29.     &dmaController1Chn0_Config,
  30.     &dmaController1Chn1_Config
  31. };
  32.  
  33. const edma_user_config_t dmaController1_InitConfig0 = {//控制器配置
  34.     .chnArbitration = EDMA_ARBITRATION_FIXED_PRIORITY,
  35.     .haltOnError = false
  36. };

接口使用

EDMA_DRV_Init

初始化接口，基本上调用这个就能把DMA用起来，里面的参数都是自动生成的。

EDMA_DRV_Init(&dmaController1_State,&dmaController1_InitConfig0,edmaChnStateArray, edmaChnConfigArray,EDMA_CONFIGURED_CHANNELS_COUNT);

函数原型

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_Init
  4.  * Description   : Initializes the eDMA module.
  5.  *
  6.  * Implements    : EDMA_DRV_Init_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_Init(edma_state_t *edmaState,
  9.                        const edma_user_config_t *userConfig,
  10.                        edma_chn_state_t * const chnStateArray[],
  11.                        const edma_channel_config_t * const chnConfigArray[],
  12.                        uint32_t chnCount)
  13. {
  14.     uint32_t index = 0U;
  15.     DMA_Type *edmaRegBase = NULL;
  16.     IRQn_Type irqNumber = NotAvail_IRQn;
  17.     status_t edmaStatus = STATUS_SUCCESS;
  18.     status_t chnInitStatus = STATUS_SUCCESS;
  19. #if defined (CUSTOM_DEVASSERT) || defined (DEV_ERROR_DETECT)
  20.     uint32_t freq = 0U;
  21.     status_t clockManagerStatus = STATUS_SUCCESS;
  22. #endif
  23.  
  24.     /* Check the state and configuration structure pointers are valid */
  25.     DEV_ASSERT((edmaState != NULL) && (userConfig != NULL));
  26.  
  27.     /* Check the module has not already been initialized */
  28.     DEV_ASSERT(s_virtEdmaState == NULL);
  29.  
  30. #if defined (CUSTOM_DEVASSERT) || defined (DEV_ERROR_DETECT)
  31.     /* Check that eDMA and DMAMUX modules are clock gated on */
  32.     for (index = 0U; index < (uint32_t)DMA_INSTANCE_COUNT; index++)
  33.     {
  34.         clockManagerStatus = CLOCK_SYS_GetFreq(s_edmaClockNames[index], &freq);
  35.         DEV_ASSERT(clockManagerStatus == STATUS_SUCCESS);
  36.     }
  37. #ifdef FEATURE_DMAMUX_AVAILABLE
  38.     for (index = 0U; index < (uint32_t)DMAMUX_INSTANCE_COUNT; index++)
  39.     {
  40.         clockManagerStatus = CLOCK_SYS_GetFreq(s_dmamuxClockNames[index], &freq);
  41.         DEV_ASSERT(clockManagerStatus == STATUS_SUCCESS);
  42.     }
  43. #endif /* FEATURE_DMAMUX_AVAILABLE */
  44. #endif /* (CUSTOM_DEVASSERT) || defined (DEV_ERROR_DETECT) */
  45.  
  46.     /* Save the runtime state structure for the driver */
  47.     s_virtEdmaState = edmaState;
  48.  
  49.     /* Clear the state structure. */
  50.     EDMA_DRV_ClearStructure((uint8_t *)s_virtEdmaState, sizeof(edma_state_t));
  51.  
  52.     /* Init all DMA instances */
  53.     for(index = 0U; index < (uint32_t)DMA_INSTANCE_COUNT; index++)
  54.     {
  55.         edmaRegBase = s_edmaBase[index];
  56.  
  57.         /* Init eDMA module on hardware level. */
  58.         EDMA_Init(edmaRegBase);
  59.  
  60. #ifdef FEATURE_DMA_HWV3
  61.         /* Set arbitration mode */
  62.         EDMA_SetChannelArbitrationMode(edmaRegBase, userConfig->chnArbitration);
  63. #else /* FEATURE_DMA_HWV3 */
  64.         /* Set arbitration mode */
  65.         EDMA_SetChannelArbitrationMode(edmaRegBase, userConfig->chnArbitration);
  66. #if (FEATURE_DMA_CHANNEL_GROUP_COUNT > 0x1U)        
  67.         EDMA_SetGroupArbitrationMode(edmaRegBase, userConfig->groupArbitration);
  68.         EDMA_SetGroupPriority(edmaRegBase, userConfig->groupPriority);
  69. #endif /* (FEATURE_DMA_CHANNEL_GROUP_COUNT > 0x1U) */
  70. #endif /* FEATURE_DMA_HWV3 */
  71.         /* Set 'Halt on error' configuration */
  72.         EDMA_SetHaltOnErrorCmd(edmaRegBase, userConfig->haltOnError);
  73.     }
  74.  
  75. #if defined FEATURE_DMA_HAS_ERROR_IRQ
  76.     /* Enable the error interrupts for eDMA module. */
  77.     for (index = 0U; index < (uint32_t)FEATURE_DMA_VIRTUAL_ERROR_INTERRUPT_LINES; index++)
  78.     {
  79.         /* Enable channel interrupt ID. */
  80.         irqNumber = s_edmaErrIrqId[index];
  81.         INT_SYS_EnableIRQ(irqNumber);
  82.     }
  83. #endif
  84.  
  85.     /* Register all edma channel interrupt handlers into vector table. */
  86.     for (index = 0U; index < (uint32_t)FEATURE_DMA_VIRTUAL_CHANNELS_INTERRUPT_LINES; index++)
  87.     {
  88.         /* Enable channel interrupt ID. */
  89.         irqNumber = s_edmaIrqId[index];
  90.         INT_SYS_EnableIRQ(irqNumber);
  91.     }
  92.     
  93. #ifdef FEATURE_DMAMUX_AVAILABLE
  94.     /* Initialize all DMAMUX instances */
  95.     for (index = 0U; index < (uint32_t)DMAMUX_INSTANCE_COUNT; index++)
  96.     {
  97.         DMAMUX_Init(s_dmaMuxBase[index]);
  98.     }
  99. #endif
  100.  
  101.     /* Initialize the channels based on configuration list */
  102.     if ((chnStateArray != NULL) && (chnConfigArray != NULL))
  103.     {
  104.         for (index = 0U; index < chnCount; index++)
  105.         {
  106.             chnInitStatus = EDMA_DRV_ChannelInit(chnStateArray[index], chnConfigArray[index]);
  107.             if (chnInitStatus != STATUS_SUCCESS)
  108.             {
  109.                 edmaStatus = chnInitStatus;
  110.             }
  111.         }
  112.     }
  113.  
  114.     return edmaStatus;
  115. }

EDMA_DRV_Deinit

逆初始化接口

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_Deinit
  4.  * Description   : Deinitialize EDMA.
  5.  *
  6.  * Implements    : EDMA_DRV_Deinit_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_Deinit(void)
  9. {
  10.     uint32_t index = 0U;
  11.     IRQn_Type irqNumber = NotAvail_IRQn;
  12.     const edma_chn_state_t *chnState = NULL;
  13.  
  14. #if defined FEATURE_DMA_HAS_ERROR_IRQ
  15.     /* Disable the error interrupts for eDMA module. */
  16.     for (index = 0U; index < (uint32_t)FEATURE_DMA_VIRTUAL_ERROR_INTERRUPT_LINES; index++)
  17.     {
  18.         /* Enable channel interrupt ID. */
  19.         irqNumber = s_edmaErrIrqId[index];
  20.         INT_SYS_DisableIRQ(irqNumber);
  21.     }
  22. #endif
  23.  
  24.     if (s_virtEdmaState != NULL)
  25.     {
  26.         /* Release all edma channel. */
  27.         for (index = 0U; index < (uint32_t)FEATURE_DMA_VIRTUAL_CHANNELS; index++)
  28.         {
  29.             /* Release all channels. */
  30.             chnState = s_virtEdmaState->virtChnState[index];
  31.             if (chnState != NULL)
  32.             {
  33.                 (void) EDMA_DRV_ReleaseChannel(chnState->virtChn);
  34.             }
  35.         }
  36.         for (index = 0U; index < (uint32_t)FEATURE_DMA_VIRTUAL_CHANNELS_INTERRUPT_LINES; index++)
  37.         {
  38.             /* Disable channel interrupts. */
  39.             irqNumber = s_edmaIrqId[index];
  40.             INT_SYS_DisableIRQ(irqNumber);
  41.         }
  42.     }
  43.  
  44.     s_virtEdmaState = NULL;
  45.  
  46.     return STATUS_SUCCESS;
  47. }

EDMA_DRV_ChannelInit

通道初始化，在初始化接口里面有调用，不用再另外调用。

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ChannelInit
  4.  * Description   : Initialize EDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_ChannelInit_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_ChannelInit(edma_chn_state_t *edmaChannelState,
  9.                               const edma_channel_config_t *edmaChannelConfig)
  10. {
  11.     /* Check the state and configuration structure pointers are valid */
  12.     DEV_ASSERT((edmaChannelState != NULL) && (edmaChannelConfig != NULL));
  13.  
  14.     /* Check if the module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.     
  17.     /* Check the channel has not already been allocated */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[edmaChannelConfig->virtChnConfig] == NULL);    
  19.     
  20.     /* Check if the channel defined by user in the channel configuration structure is valid */
  21.     DEV_ASSERT(edmaChannelConfig->virtChnConfig < FEATURE_DMA_VIRTUAL_CHANNELS);
  22.  
  23.     /* Get DMA instance from virtual channel */
  24.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(edmaChannelConfig->virtChnConfig);
  25.  
  26.     /* Get DMA channel from virtual channel */
  27.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(edmaChannelConfig->virtChnConfig);
  28.  
  29.     /* Get virtual channel value */
  30.     uint8_t virtualChannel = edmaChannelConfig->virtChnConfig;
  31.     
  32.     /* Get status */
  33.     status_t retStatus = STATUS_SUCCESS;
  34.     
  35.     /* Load corresponding DMA instance pointer */
  36.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  37.         
  38.     /* Reset the channel state structure to default value. */
  39.     EDMA_DRV_ClearStructure((uint8_t *)edmaChannelState, sizeof(edma_chn_state_t));
  40.  
  41. #ifdef FEATURE_DMAMUX_AVAILABLE     
  42.     retStatus = EDMA_DRV_SetChannelRequestAndTrigger(edmaChannelConfig->virtChnConfig, (uint8_t)edmaChannelConfig->source, edmaChannelConfig->enableTrigger);
  43. #endif    
  44.  
  45.     /* Clear the TCD registers for this channel */
  46.     EDMA_TCDClearReg(edmaRegBase, dmaChannel);
  47.  
  48. #ifdef FEATURE_DMAMUX_AVAILABLE 
  49.     if (retStatus == STATUS_SUCCESS)
  50. #endif
  51.     {
  52.         /* Set virtual channel state */
  53.         s_virtEdmaState->virtChnState[virtualChannel] = edmaChannelState;    
  54.         /* Set virtual channel value */
  55.         s_virtEdmaState->virtChnState[virtualChannel]->virtChn = virtualChannel;        
  56.         /* Set virtual channel status to normal */
  57.         s_virtEdmaState->virtChnState[virtualChannel]->status = EDMA_CHN_NORMAL;
  58.         
  59.         /* Enable error interrupt for this channel */
  60.         EDMA_SetErrorIntCmd(edmaRegBase, dmaChannel, true);        
  61. #ifdef FEATURE_DMA_HWV3
  62.         /* Put the channel in a priority group, as defined in configuration */
  63.         EDMA_SetChannelPriorityGroup(edmaRegBase, dmaChannel, edmaChannelConfig->groupPriority);
  64. #endif
  65.  
  66.         /* Set the channel priority, as defined in the configuration, only if fixed arbitration mode is selected */
  67.         if ((EDMA_GetChannelArbitrationMode(edmaRegBase) == EDMA_ARBITRATION_FIXED_PRIORITY) &&
  68.             (edmaChannelConfig->channelPriority != EDMA_CHN_DEFAULT_PRIORITY))
  69.         {
  70.             EDMA_SetChannelPriority(edmaRegBase, dmaChannel, edmaChannelConfig->channelPriority);
  71.         }
  72.         /* Install the user callback */
  73.         retStatus = EDMA_DRV_InstallCallback(edmaChannelConfig->virtChnConfig, edmaChannelConfig->callback, edmaChannelConfig->callbackParam);
  74.     }
  75.  
  76.     return retStatus;
  77. }

EDMA_DRV_InstallCallback

安装回调函数

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_InstallCallback
  4.  * Description   : Register callback function and parameter.
  5.  *
  6.  * Implements    : EDMA_DRV_InstallCallback_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_InstallCallback(uint8_t virtualChannel,
  9.                                   edma_callback_t callback,
  10.                                   void *parameter)
  11. {
  12.     /* Check the channel number is valid */
  13.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  14.  
  15.     /* Check the channel is allocated */
  16.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  17.  
  18.     s_virtEdmaState->virtChnState[virtualChannel]->callback = callback;
  19.     s_virtEdmaState->virtChnState[virtualChannel]->parameter = parameter;
  20.  
  21.     return STATUS_SUCCESS;
  22. }

EDMA_DRV_ReleaseChannel

释放通道软硬件

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ReleaseChannel
  4.  * Description   : Free eDMA channel's hardware and software resource.
  5.  *
  6.  * Implements    : EDMA_DRV_ReleaseChannel_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_ReleaseChannel(uint8_t virtualChannel)
  9. {
  10.     /* Check that virtual channel number is valid */
  11.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  12.  
  13.     /* Check the DMA module is initialized */
  14.     DEV_ASSERT(s_virtEdmaState != NULL);
  15.  
  16.     /* Get DMA instance from virtual channel */
  17.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  18.  
  19.     /* Get DMA channel from virtual channel*/
  20.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  21.  
  22.     /* Get pointer to channel state */
  23.     edma_chn_state_t *chnState = s_virtEdmaState->virtChnState[virtualChannel];
  24.  
  25.     /* Check that virtual channel is initialized */
  26.     DEV_ASSERT(chnState != NULL);
  27.  
  28.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  29.  
  30.     /* Stop edma channel. */
  31.     EDMA_SetDmaRequestCmd(edmaRegBase, dmaChannel, false);
  32.  
  33.     /* Reset the channel state structure to default value. */
  34.     EDMA_DRV_ClearStructure((uint8_t *)chnState, sizeof(edma_chn_state_t));
  35.  
  36.     s_virtEdmaState->virtChnState[virtualChannel] = NULL;
  37.  
  38.     return STATUS_SUCCESS;
  39. }

EDMA_DRV_ClearIntStatus

清除所有中断状态

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ClearIntStatus
  4.  * Description   : Clear done and interrupt retStatus.
  5.  *
  6.  *END**************************************************************************/
  7. static void EDMA_DRV_ClearIntStatus(uint8_t virtualChannel)
  8. {
  9.     /* Get DMA instance from virtual channel */
  10.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  11.  
  12.     /* Get DMA channel from virtual channel*/
  13.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  14.  
  15.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  16.     EDMA_ClearDoneStatusFlag(edmaRegBase, dmaChannel);
  17.     EDMA_ClearIntStatusFlag(edmaRegBase, dmaChannel);
  18. }

EDMA_DRV_ClearSoftwareTCD

清除软件TCD结构体

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ClearSoftwareTCD
  4.  * Description   : Clear the software tcd structure.
  5.  *
  6.  *END**************************************************************************/
  7. static void EDMA_DRV_ClearSoftwareTCD(edma_software_tcd_t *stcd)
  8. {
  9.     EDMA_DRV_ClearStructure((uint8_t *)stcd, sizeof(edma_software_tcd_t));
  10. }

EDMA_DRV_IRQHandler

默认的中断处理函数

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_IRQHandler
  4.  * Description   : EDMA IRQ handler.
  5.  *END**************************************************************************/
  6. void EDMA_DRV_IRQHandler(uint8_t virtualChannel)
  7. {
  8.     const edma_chn_state_t *chnState = s_virtEdmaState->virtChnState[virtualChannel];
  9.  
  10.     EDMA_DRV_ClearIntStatus(virtualChannel);
  11.  
  12.     if (chnState != NULL)
  13.     {
  14.         if (chnState->callback != NULL)
  15.         {
  16.             chnState->callback(chnState->parameter, chnState->status);
  17.         }
  18.     }
  19. }

EDMA_DRV_ErrorIRQHandler

错误中断处理函数

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ErrorIRQHandler
  4.  * Description   : EDMA error IRQ handler
  5.  *END**************************************************************************/
  6. void EDMA_DRV_ErrorIRQHandler(uint8_t virtualChannel)
  7. {
  8.     /* Get DMA instance from virtual channel */
  9.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  10.  
  11.     /* Get DMA channel from virtual channel*/
  12.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  13.  
  14.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  15.     EDMA_SetDmaRequestCmd(edmaRegBase, dmaChannel, false);
  16.     edma_chn_state_t *chnState = s_virtEdmaState->virtChnState[virtualChannel];
  17.     if (chnState != NULL)
  18.     {
  19.         EDMA_DRV_ClearIntStatus(virtualChannel);
  20.         EDMA_ClearErrorIntStatusFlag(edmaRegBase, dmaChannel);
  21.         chnState->status = EDMA_CHN_ERROR;
  22.         if (chnState->callback != NULL)
  23.         {
  24.             chnState->callback(chnState->parameter, chnState->status);
  25.         }
  26.     }
  27. }

EDMA_DRV_ConfigSingleBlockTransfer

配置信号块传输

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ConfigSingleBlockTransfer
  4.  * Description   : Configures a DMA single block transfer.
  5.  *
  6.  * Implements    : EDMA_DRV_ConfigSingleBlockTransfer_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_ConfigSingleBlockTransfer(uint8_t virtualChannel,
  9.                                             edma_transfer_type_t type,
  10.                                             uint32_t srcAddr,
  11.                                             uint32_t destAddr,
  12.                                             edma_transfer_size_t transferSize,
  13.                                             uint32_t dataBufferSize)
  14. {
  15.     /* Check that virtual channel number is valid */
  16.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  17.  
  18.     /* Check that eDMA module is initialized */
  19.     DEV_ASSERT(s_virtEdmaState != NULL);
  20.  
  21.     /* Check that virtual channel is initialized */
  22.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  23.  
  24. #if defined (CUSTOM_DEVASSERT) || defined (DEV_ERROR_DETECT)
  25.     /* Check if the value passed for 'transferSize' is valid */
  26.     DEV_ASSERT(EDMA_DRV_ValidTransferSize(transferSize));
  27. #endif
  28.  
  29.     /* Get DMA instance from virtual channel */
  30.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  31.  
  32.     /* Get DMA channel from virtual channel*/
  33.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  34.  
  35.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  36.     uint8_t transferOffset;
  37.     status_t retStatus = STATUS_SUCCESS;
  38.  
  39.     /* Compute the transfer offset, based on transfer size.
  40.      * The number of bytes transferred in each source read/destination write
  41.      * is obtained with the following formula:
  42.      *    source_read_size = 2^SSIZE
  43.      *    destination_write_size = 2^DSIZE
  44.      */
  45.     transferOffset = (uint8_t) (1U << ((uint8_t)transferSize));
  46.  
  47.     /* The number of bytes to be transferred (buffer size) must
  48.      * be a multiple of the source read/destination write size
  49.      */
  50.     if ((dataBufferSize % transferOffset) != 0U)
  51.     {
  52.         retStatus = STATUS_ERROR;
  53.     }
  54.  
  55.     if (retStatus == STATUS_SUCCESS)
  56.     {
  57.         /* Clear transfer control descriptor for the current channel */
  58.         EDMA_TCDClearReg(edmaRegBase, dmaChannel);  
  59.  
  60. #ifdef FEATURE_DMA_ENGINE_STALL
  61.         /* Configure the DMA Engine to stall for a number of cycles after each R/W */
  62.         EDMA_TCDSetEngineStall(edmaRegBase, dmaChannel, EDMA_ENGINE_STALL_4_CYCLES);
  63. #endif
  64.  
  65. #ifdef FEATURE_DMA_HWV3
  66.         EDMA_SetMinorLoopMappingCmd(edmaRegBase, dmaChannel, false);
  67. #else
  68.         EDMA_SetMinorLoopMappingCmd(edmaRegBase, false);
  69. #endif
  70.  
  71.         /* Configure source and destination addresses */
  72.         EDMA_TCDSetSrcAddr(edmaRegBase, dmaChannel, srcAddr);
  73.         EDMA_TCDSetDestAddr(edmaRegBase, dmaChannel, destAddr);
  74.  
  75.         /* Set transfer size (1B/2B/4B/16B/32B) */
  76.         EDMA_TCDSetAttribute(edmaRegBase, dmaChannel, EDMA_MODULO_OFF, EDMA_MODULO_OFF, transferSize, transferSize);
  77.  
  78.         /* Configure source/destination offset. */
  79.         switch (type)
  80.         {
  81.             case EDMA_TRANSFER_PERIPH2MEM:
  82.                 EDMA_TCDSetSrcOffset(edmaRegBase, dmaChannel, 0);
  83.                 EDMA_TCDSetDestOffset(edmaRegBase, dmaChannel, (int8_t) transferOffset);
  84.                 break;
  85.             case EDMA_TRANSFER_MEM2PERIPH:
  86.                 EDMA_TCDSetSrcOffset(edmaRegBase, dmaChannel, (int8_t) transferOffset);
  87.                 EDMA_TCDSetDestOffset(edmaRegBase, dmaChannel, 0);
  88.                 break;
  89.             case EDMA_TRANSFER_MEM2MEM:
  90.                 EDMA_TCDSetSrcOffset(edmaRegBase, dmaChannel, (int8_t) transferOffset);
  91.                 EDMA_TCDSetDestOffset(edmaRegBase, dmaChannel, (int8_t) transferOffset);
  92.                 break;
  93.             case EDMA_TRANSFER_PERIPH2PERIPH:
  94.                 EDMA_TCDSetSrcOffset(edmaRegBase, dmaChannel, 0);
  95.                 EDMA_TCDSetDestOffset(edmaRegBase, dmaChannel, 0);
  96.                 break;
  97.             default:
  98.                 /* This should never be reached - all the possible values have been handled. */
  99.                 break;
  100.         }
  101.  
  102.         /* Set the total number of bytes to be transfered */
  103.         EDMA_TCDSetNbytes(edmaRegBase, dmaChannel, dataBufferSize);
  104.  
  105.         /* Set major iteration count to 1 (single block mode) */
  106.         EDMA_TCDSetMajorCount(edmaRegBase, dmaChannel, 1U);
  107.  
  108.         /* Enable interrupt when the transfer completes */
  109.         EDMA_TCDSetMajorCompleteIntCmd(edmaRegBase, dmaChannel, true);
  110.         
  111.         /* Set virtual channel status to normal */
  112.         s_virtEdmaState->virtChnState[virtualChannel]->status = EDMA_CHN_NORMAL;    
  113.     }
  114.  
  115.     return retStatus;
  116. }

EDMA_DRV_ConfigMultiBlockTransfer

配置复合信号块传输

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ConfigMultiBlockTransfer
  4.  * Description   : Configures a DMA single block transfer.
  5.  *
  6.  * Implements    : EDMA_DRV_ConfigMultiBlockTransfer_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_ConfigMultiBlockTransfer(uint8_t virtualChannel,
  9.                                            edma_transfer_type_t type,
  10.                                            uint32_t srcAddr,
  11.                                            uint32_t destAddr,
  12.                                            edma_transfer_size_t transferSize,
  13.                                            uint32_t blockSize,
  14.                                            uint32_t blockCount,
  15.                                            bool disableReqOnCompletion)
  16. {
  17.     /* Check that virtual channel number is valid */
  18.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  19.  
  20.     /* Check that eDMA module is initialized */
  21.     DEV_ASSERT(s_virtEdmaState != NULL);
  22.  
  23.     /* Get DMA instance from virtual channel */
  24.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  25.  
  26.     /* Get DMA channel from virtual channel*/
  27.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  28.  
  29.     status_t retStatus = STATUS_SUCCESS;
  30.  
  31.     /* Configure the transfer for one data block */
  32.     retStatus = EDMA_DRV_ConfigSingleBlockTransfer(virtualChannel, type, srcAddr, destAddr, transferSize, blockSize);
  33.  
  34.     if (retStatus == STATUS_SUCCESS)
  35.     {
  36.         DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  37.  
  38.         /* Set the number of data blocks */
  39.         EDMA_TCDSetMajorCount(edmaRegBase, dmaChannel, blockCount);
  40.  
  41.         /* Enable/disable requests upon completion */
  42.         EDMA_TCDSetDisableDmaRequestAfterTCDDoneCmd(edmaRegBase, dmaChannel, disableReqOnCompletion);
  43.     }
  44.  
  45.     return retStatus;
  46. }

EDMA_DRV_ConfigLoopTransfer

配置轮询传输

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ConfigLoopTransfer
  4.  * Description   : Configures the DMA transfer in a loop.
  5.  *
  6.  * Implements    : EDMA_DRV_ConfigLoopTransfer_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_ConfigLoopTransfer(uint8_t virtualChannel,
  9.                                      const edma_transfer_config_t *transferConfig)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Check the transfer configuration structure is valid */
  21.     DEV_ASSERT(transferConfig != NULL);
  22.  
  23.     /* Check the minor/major loop properties are defined */
  24.     DEV_ASSERT(transferConfig->loopTransferConfig != NULL);
  25.     
  26.     /* If the modulo feature is enabled, check alignment of addresses */
  27.     DEV_ASSERT((transferConfig->srcModulo == EDMA_MODULO_OFF) ||
  28.                ((transferConfig->srcAddr % (((uint32_t)1U) << (uint32_t)transferConfig->srcModulo)) == 0U));
  29.     DEV_ASSERT((transferConfig->destModulo == EDMA_MODULO_OFF) ||
  30.                ((transferConfig->destAddr % (((uint32_t)1U) << (uint32_t)transferConfig->destModulo)) == 0U));
  31.  
  32.     /* Get DMA instance from virtual channel */
  33.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  34.  
  35. #ifdef FEATURE_DMA_HWV3
  36.     /* Get DMA channel from virtual channel*/
  37.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  38. #endif
  39.  
  40.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  41.  
  42. #ifdef FEATURE_DMA_HWV3
  43.     EDMA_SetMinorLoopMappingCmd(edmaRegBase, dmaChannel, true);
  44. #else
  45.     EDMA_SetMinorLoopMappingCmd(edmaRegBase, true);
  46. #endif
  47.     /* Write the configuration in the transfer control descriptor registers */
  48.     EDMA_DRV_PushConfigToReg(virtualChannel, transferConfig);
  49.     
  50.     /* Set virtual channel status to normal */
  51.     s_virtEdmaState->virtChnState[virtualChannel]->status = EDMA_CHN_NORMAL;
  52.  
  53.     return STATUS_SUCCESS;
  54. }

EDMA_DRV_ConfigScatterGatherTransfer

配置分散或者聚集操作

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ConfigScatterGatherTransfer
  4.  * Description   : Configure eDMA for scatter/gather operation
  5.  *
  6.  * Implements    : EDMA_DRV_ConfigScatterGatherTransfer_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_ConfigScatterGatherTransfer(uint8_t virtualChannel,
  9.                                               edma_software_tcd_t *stcd,
  10.                                               edma_transfer_size_t transferSize,
  11.                                               uint32_t bytesOnEachRequest,
  12.                                               const edma_scatter_gather_list_t *srcList,
  13.                                               const edma_scatter_gather_list_t *destList,
  14.                                               uint8_t tcdCount)
  15. {
  16.     /* Check that virtual channel number is valid */
  17.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  18.  
  19.     /* Check that eDMA module is initialized */
  20.     DEV_ASSERT(s_virtEdmaState != NULL);
  21.  
  22.     /* Check that virtual channel is initialized */
  23.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  24.  
  25.     /* Check the input arrays for scatter/gather operation are valid */
  26.     DEV_ASSERT((stcd != NULL) && (srcList != NULL) && (destList != NULL));
  27.  
  28. #if defined (CUSTOM_DEVASSERT) || defined (DEV_ERROR_DETECT)
  29.     /* Check if the value passed for 'transferSize' is valid */
  30.     DEV_ASSERT(EDMA_DRV_ValidTransferSize(transferSize));
  31. #endif
  32.  
  33.     uint8_t i = 0U;
  34.     uint16_t transferOffset = 0U;
  35.     uint32_t stcdAlignedAddr = STCD_ADDR(stcd);
  36.     edma_software_tcd_t *edmaSwTcdAddr = (edma_software_tcd_t *)stcdAlignedAddr;
  37.     edma_loop_transfer_config_t edmaLoopConfig;
  38.     edma_transfer_config_t edmaTransferConfig;
  39.     status_t retStatus = STATUS_SUCCESS;
  40.  
  41.     /* Set virtual channel status to normal */
  42.     s_virtEdmaState->virtChnState[virtualChannel]->status = EDMA_CHN_NORMAL;    
  43.     
  44.     /* Compute the transfer offset, based on transfer size.
  45.      * The number of bytes transferred in each source read/destination write
  46.      * is obtained with the following formula:
  47.      *    source_read_size = 2^SSIZE
  48.      *    destination_write_size = 2^DSIZE
  49.      */
  50.     transferOffset = (uint16_t) (1UL << ((uint16_t)transferSize));
  51.  
  52.     /* The number of bytes to be transferred on each request must
  53.      * be a multiple of the source read/destination write size
  54.      */
  55.     if ((bytesOnEachRequest % transferOffset) != 0U)
  56.     {
  57.         retStatus = STATUS_ERROR;
  58.     }
  59.  
  60.     /* Clear the configuration structures before initializing them. */
  61.     EDMA_DRV_ClearStructure((uint8_t *)(&edmaTransferConfig), sizeof(edma_transfer_config_t));
  62.     EDMA_DRV_ClearStructure((uint8_t *)(&edmaLoopConfig), sizeof(edma_loop_transfer_config_t));
  63.  
  64.     /* Configure the transfer for scatter/gather mode. */
  65.     edmaTransferConfig.srcLastAddrAdjust = 0;
  66.     edmaTransferConfig.destLastAddrAdjust = 0;
  67.     edmaTransferConfig.srcModulo = EDMA_MODULO_OFF;
  68.     edmaTransferConfig.destModulo = EDMA_MODULO_OFF;
  69.     edmaTransferConfig.srcTransferSize = transferSize;
  70.     edmaTransferConfig.destTransferSize = transferSize;
  71.     edmaTransferConfig.minorByteTransferCount = bytesOnEachRequest;
  72.     edmaTransferConfig.interruptEnable = true;
  73.     edmaTransferConfig.scatterGatherEnable = true;
  74.     edmaTransferConfig.loopTransferConfig = &edmaLoopConfig;
  75.     edmaTransferConfig.loopTransferConfig->srcOffsetEnable = false;
  76.     edmaTransferConfig.loopTransferConfig->dstOffsetEnable = false;
  77.     edmaTransferConfig.loopTransferConfig->minorLoopChnLinkEnable = false;
  78.     edmaTransferConfig.loopTransferConfig->majorLoopChnLinkEnable = false;
  79.  
  80.     /* Copy scatter/gather lists to transfer configuration*/
  81.     for (i = 0U; (i < tcdCount) && (retStatus == STATUS_SUCCESS); i++)
  82.     {
  83.         edmaTransferConfig.srcAddr = srcList[i].address;
  84.         edmaTransferConfig.destAddr = destList[i].address;
  85.         if ((srcList[i].length != destList[i].length) || (srcList[i].type != destList[i].type))
  86.         {
  87.             retStatus = STATUS_ERROR;
  88.             break;
  89.         }
  90.         edmaTransferConfig.loopTransferConfig->majorLoopIterationCount = srcList[i].length/bytesOnEachRequest;
  91.  
  92.         switch (srcList[i].type)
  93.         {
  94.             case EDMA_TRANSFER_PERIPH2MEM:
  95.                 /* Configure Source Read. */
  96.                 edmaTransferConfig.srcOffset = 0;
  97.                 /* Configure Dest Write. */
  98.                 edmaTransferConfig.destOffset = (int16_t) transferOffset;
  99.                 break;
  100.             case EDMA_TRANSFER_MEM2PERIPH:
  101.                 /* Configure Source Read. */
  102.                 edmaTransferConfig.srcOffset = (int16_t) transferOffset;
  103.                 /* Configure Dest Write. */
  104.                 edmaTransferConfig.destOffset = 0;
  105.                 break;
  106.             case EDMA_TRANSFER_MEM2MEM:
  107.                 /* Configure Source Read. */
  108.                 edmaTransferConfig.srcOffset = (int16_t) transferOffset;
  109.                 /* Configure Dest Write. */
  110.                 edmaTransferConfig.destOffset = (int16_t) transferOffset;
  111.                 break;
  112.             case EDMA_TRANSFER_PERIPH2PERIPH:
  113.                 /* Configure Source Read. */
  114.                 edmaTransferConfig.srcOffset = 0;
  115.                 /* Configure Dest Write. */
  116.                 edmaTransferConfig.destOffset = 0;
  117.                 break;
  118.             default:
  119.                 /* This should never be reached - all the possible values have been handled. */
  120.                 break;
  121.         }
  122.  
  123.         /* Configure the pointer to next software TCD structure; for the last one, this address should be 0 */
  124.         if (i == ((uint8_t)(tcdCount - 1U)))
  125.         {
  126.             edmaTransferConfig.scatterGatherNextDescAddr = 0U;
  127.         }
  128.         else
  129.         {
  130.             edma_software_tcd_t * ptNextAddr = &edmaSwTcdAddr[i];
  131.             edmaTransferConfig.scatterGatherNextDescAddr = ((uint32_t) ptNextAddr);
  132.         }
  133.  
  134.         if (i == 0U)
  135.         {
  136.             /* Push the configuration for the first descriptor to registers */
  137.             EDMA_DRV_PushConfigToReg(virtualChannel, &edmaTransferConfig);
  138.         }
  139.         else
  140.         {
  141.             /* Copy configuration to software TCD structure */
  142.             EDMA_DRV_PushConfigToSTCD(&edmaTransferConfig, &edmaSwTcdAddr[i - 1U]);
  143.         }
  144.     }
  145.  
  146.     return retStatus;
  147. }

EDMA_DRV_StartChannel

开启通道，这个在SPI里面调用到

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_StartChannel
  4.  * Description   : Starts an eDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_StartChannel_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_StartChannel(uint8_t virtualChannel)
  9. {
  10.     /* Check that virtual channel number is valid */
  11.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  12.  
  13.     /* Check that eDMA module is initialized */
  14.     DEV_ASSERT(s_virtEdmaState != NULL);
  15.  
  16.     /* Check that virtual channel is initialized */
  17.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  18.  
  19.     /* Get DMA instance from virtual channel */
  20.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  21.  
  22.     /* Get DMA channel from virtual channel*/
  23.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  24.  
  25.     /* Enable requests for current channel */
  26.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  27.     EDMA_SetDmaRequestCmd(edmaRegBase, dmaChannel, true);
  28.  
  29.     return STATUS_SUCCESS;
  30. }

EDMA_DRV_StopChannel

暂停通道

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_StopChannel
  4.  * Description   : Stops an eDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_StopChannel_Activity
  7.  *END**************************************************************************/
  8. status_t EDMA_DRV_StopChannel(uint8_t virtualChannel)
  9. {
  10.     /* Check that virtual channel number is valid */
  11.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  12.  
  13.     /* Check that eDMA module is initialized */
  14.     DEV_ASSERT(s_virtEdmaState != NULL);
  15.  
  16.     /* Check that virtual channel is initialized */
  17.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  18.  
  19.     /* Get DMA instance from virtual channel */
  20.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  21.  
  22.     /* Get DMA channel from virtual channel*/
  23.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  24.  
  25.     /* Disable requests for current channel */
  26.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  27.     EDMA_SetDmaRequestCmd(edmaRegBase, dmaChannel, false);
  28.  
  29.     return STATUS_SUCCESS;
  30. }

EDMA_DRV_SetChannelRequestAndTrigger

设置通道请求和触发

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetChannelRequestAndTrigger
  4.  * Description   : Sets DMA channel request source in DMAMUX and controls
  5.  *                 the DMA channel periodic triggering.
  6.  *
  7.  * Implements    : EDMA_DRV_SetChannelRequestAndTrigger_Activity
  8.  *END**************************************************************************/
  9. status_t EDMA_DRV_SetChannelRequestAndTrigger(uint8_t virtualChannel,
  10.                                               uint8_t request,
  11.                                               bool enableTrigger)
  12. {
  13.     /* Check the virtual channel number is valid */
  14.     DEV_ASSERT(virtualChannel < (uint32_t)FEATURE_DMA_VIRTUAL_CHANNELS);
  15.  
  16.     /* Check that eDMA module is initialized */
  17.     DEV_ASSERT(s_virtEdmaState != NULL);
  18.  
  19. #ifdef FEATURE_DMAMUX_AVAILABLE
  20.     /* Retrieve the DMAMUX instance serving this request */
  21.     uint8_t dmaMuxInstance = (uint8_t)FEATURE_DMAMUX_REQ_SRC_TO_INSTANCE(request);
  22.  
  23.     /* Get request index for the corresponding DMAMUX instance */
  24.     uint8_t dmaMuxRequest = (uint8_t)FEATURE_DMAMUX_REQ_SRC_TO_CH(request);
  25.  
  26.     /* Get DMAMUX channel for the selected request */
  27.     uint8_t dmaMuxChannel = (uint8_t)FEATURE_DMAMUX_DMA_CH_TO_CH(virtualChannel);
  28.  
  29.     /* Retrieve the appropriate DMAMUX instance */
  30.     DMAMUX_Type *dmaMuxRegBase = s_dmaMuxBase[dmaMuxInstance];
  31.  
  32.     /* Set request and trigger */
  33. 	DMAMUX_SetChannelCmd(dmaMuxRegBase, dmaMuxChannel, false);
  34.     DMAMUX_SetChannelSource(dmaMuxRegBase, dmaMuxChannel, dmaMuxRequest);
  35. #ifdef FEATURE_DMAMUX_HAS_TRIG	
  36. 	DMAMUX_SetChannelTrigger(dmaMuxRegBase, dmaMuxChannel, enableTrigger);
  37. #else
  38.     (void)enableTrigger;	
  39. #endif	
  40. 	DMAMUX_SetChannelCmd(dmaMuxRegBase, dmaMuxChannel, true);
  41.     
  42.     return STATUS_SUCCESS;
  43. #else
  44.     (void)virtualChannel;    
  45.     (void)request;
  46.     (void)enableTrigger;    
  47.     return STATUS_UNSUPPORTED;
  48. #endif
  49. }

EDMA_DRV_ClearTCD

清除TCD结构体

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ClearTCD
  4.  * Description   : Clears all registers to 0 for the hardware TCD.
  5.  *
  6.  * Implements    : EDMA_DRV_ClearTCD_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_ClearTCD(uint8_t virtualChannel)
  9. {
  10.     /* Check that virtual channel number is valid */
  11.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  12.  
  13.     /* Check that eDMA module is initialized */
  14.     DEV_ASSERT(s_virtEdmaState != NULL);
  15.  
  16.     /* Check that virtual channel is initialized */
  17.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  18.  
  19.     /* Get DMA instance from virtual channel */
  20.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  21.  
  22.     /* Get DMA channel from virtual channel*/
  23.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  24.  
  25.     /* Clear the TCD memory */
  26.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  27.     EDMA_TCDClearReg(edmaRegBase, dmaChannel);
  28. }

EDMA_DRV_SetSrcAddr

设置源地址

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetSrcAddr
  4.  * Description   : Configures the source address for the eDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_SetSrcAddr_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetSrcAddr(uint8_t virtualChannel,
  9.                          uint32_t address)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD source address */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetSrcAddr(edmaRegBase, dmaChannel, address);
  29. }

EDMA_DRV_SetSrcOffset

设置原地址偏移

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetSrcOffset
  4.  * Description   : Configures the source address signed offset for the eDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_SetSrcOffset_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetSrcOffset(uint8_t virtualChannel,
  9.                            int16_t offset)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD source offset */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetSrcOffset(edmaRegBase, dmaChannel, offset);
  29. }

EDMA_DRV_SetSrcReadChunkSize

配置源读数据块大小

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetSrcReadChunkSize
  4.  * Description   : Configures the source read data chunk size (transferred in a read sequence).
  5.  *
  6.  * Implements    : EDMA_DRV_SetSrcReadChunkSize_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetSrcReadChunkSize(uint8_t virtualChannel,
  9.                                   edma_transfer_size_t size)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD source transfer size */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetSrcTransferSize(edmaRegBase, dmaChannel, size);
  29. }

EDMA_DRV_SetSrcLastAddrAdjustment

配置源地址最后一次调整

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetSrcLastAddrAdjustment
  4.  * Description   : Configures the source address last adjustment.
  5.  *
  6.  * Implements    : EDMA_DRV_SetSrcLastAddrAdjustment_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetSrcLastAddrAdjustment(uint8_t virtualChannel,
  9.                                        int32_t adjust)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD source last adjustment */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetSrcLastAdjust(edmaRegBase, dmaChannel, adjust);
  29. }

EDMA_DRV_SetDestLastAddrAdjustment

配置目标地址最后一次调整

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetDestLastAddrAdjustment
  4.  * Description   : Configures the source address last adjustment.
  5.  *
  6.  * Implements    : EDMA_DRV_SetDestLastAddrAdjustment_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetDestLastAddrAdjustment(uint8_t virtualChannel,
  9.                                         int32_t adjust)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD source last adjustment */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetDestLastAdjust(edmaRegBase, dmaChannel, adjust);
  29. }

EDMA_DRV_SetDestAddr

设置目标地址

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetDestAddr
  4.  * Description   : Configures the destination address for the eDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_SetDestAddr_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetDestAddr(uint8_t virtualChannel,
  9.                           uint32_t address)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD destination address */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetDestAddr(edmaRegBase, dmaChannel, address);
  29. }

EDMA_DRV_SetDestOffset

设置目标地址偏移

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetDestOffset
  4.  * Description   : Configures the destination address signed offset for the eDMA channel.
  5.  *
  6.  * Implements    : EDMA_DRV_SetDestOffset_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetDestOffset(uint8_t virtualChannel,
  9.                             int16_t offset)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD destination offset */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetDestOffset(edmaRegBase, dmaChannel, offset);
  29. }

EDMA_DRV_SetDestWriteChunkSize

配置写入目标地址数据块大小

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetDestWriteChunkSize
  4.  * Description   : Configures the destination data chunk size (transferred in a write sequence).
  5.  *
  6.  * Implements    : EDMA_DRV_SetDestWriteChunkSize_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetDestWriteChunkSize(uint8_t virtualChannel,
  9.                                     edma_transfer_size_t size)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD source transfer size */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetDestTransferSize(edmaRegBase, dmaChannel, size);
  29. }

EDMA_DRV_SetMinorLoopBlockSize

配置通道的每个服务请求中传输的字节数

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetMinorLoopBlockSize
  4.  * Description   : Configures the number of bytes to be transferred in each service request of the channel.
  5.  *
  6.  * Implements    : EDMA_DRV_SetMinorLoopBlockSize_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetMinorLoopBlockSize(uint8_t virtualChannel,
  9.                                     uint32_t nbytes)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set channel TCD minor loop block size */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetNbytes(edmaRegBase, dmaChannel, nbytes);
  29. }

EDMA_DRV_SetMajorLoopIterationCount

配置主循环迭代的次数

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetMajorLoopIterationCount
  4.  * Description   : Configures the number of major loop iterations.
  5.  *
  6.  * Implements    : EDMA_DRV_SetMajorLoopIterationCount_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetMajorLoopIterationCount(uint8_t virtualChannel,
  9.                                          uint32_t majorLoopCount)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Set the major loop iteration count */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetMajorCount(edmaRegBase, dmaChannel, majorLoopCount);
  29. }

EDMA_DRV_GetRemainingMajorIterationsCount

返回剩余的主循环迭代计数

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_GetRemainingMajorIterationsCount
  4.  * Description   : Returns the remaining major loop iteration count.
  5.  *
  6.  * Implements    : EDMA_DRV_GetRemainingMajorIterationsCount_Activity
  7.  *END**************************************************************************/
  8. uint32_t EDMA_DRV_GetRemainingMajorIterationsCount(uint8_t virtualChannel)
  9. {
  10.     /* Check that virtual channel number is valid */
  11.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  12.  
  13.     /* Check that eDMA module is initialized */
  14.     DEV_ASSERT(s_virtEdmaState != NULL);
  15.  
  16.     /* Check that virtual channel is initialized */
  17.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  18.  
  19.     /* Get DMA instance from virtual channel */
  20.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  21.  
  22.     /* Get DMA channel from virtual channel*/
  23.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  24.  
  25.     /* Retrieve the number of minor loops yet to be triggered */
  26.     const DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  27.     uint32_t count = EDMA_TCDGetCurrentMajorCount(edmaRegBase, dmaChannel);
  28.  
  29.     return count;
  30. }

EDMA_DRV_SetScatterGatherLink

配置下一个TCD的内存地址

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_SetScatterGatherLink
  4.  * Description   : Configures the memory address of the next TCD, in scatter/gather mode.
  5.  *
  6.  * Implements    : EDMA_DRV_SetScatterGatherLink_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_SetScatterGatherLink(uint8_t virtualChannel,
  9.                                    uint32_t nextTCDAddr)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Configures the memory address of the next TCD */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetScatterGatherLink(edmaRegBase, dmaChannel, nextTCDAddr);
  29. }

EDMA_DRV_DisableRequestsOnTransferComplete

在TCD的主循环完成后禁用/启用DMA请求

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_DisableRequestsOnTransferComplete
  4.  * Description   : Disables/Enables the DMA request after the major loop completes for the TCD.
  5.  *
  6.  * Implements    : EDMA_DRV_DisableRequestsOnTransferComplete_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_DisableRequestsOnTransferComplete(uint8_t virtualChannel,
  9.                                                 bool disable)
  10. {
  11.     /* Check that virtual channel number is valid */
  12.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  13.  
  14.     /* Check that eDMA module is initialized */
  15.     DEV_ASSERT(s_virtEdmaState != NULL);
  16.  
  17.     /* Check that virtual channel is initialized */
  18.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  19.  
  20.     /* Get DMA instance from virtual channel */
  21.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  22.  
  23.     /* Get DMA channel from virtual channel*/
  24.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  25.  
  26.     /* Disables/Enables the DMA request upon TCD completion */
  27.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  28.     EDMA_TCDSetDisableDmaRequestAfterTCDDoneCmd(edmaRegBase, dmaChannel, disable);
  29. }

EDMA_DRV_ConfigureInterrupt

使能失能通道中断

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_ConfigureInterrupt
  4.  * Description   : Disables/Enables the channel interrupt requests.
  5.  *
  6.  * Implements    : EDMA_DRV_ConfigureInterrupt_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_ConfigureInterrupt(uint8_t virtualChannel,
  9.                                  edma_channel_interrupt_t intSrc,
  10.                                  bool enable)
  11. {
  12.     /* Check that virtual channel number is valid */
  13.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  14.  
  15.     /* Check that eDMA module is initialized */
  16.     DEV_ASSERT(s_virtEdmaState != NULL);
  17.  
  18.     /* Check that virtual channel is initialized */
  19.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  20.  
  21.     /* Get DMA instance from virtual channel */
  22.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  23.  
  24.     /* Get DMA channel from virtual channel*/
  25.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  26.  
  27.     /* Disables/Enables the channel interrupt requests. */
  28.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  29.     switch (intSrc)
  30.     {
  31.         case EDMA_CHN_ERR_INT:
  32.             /* Enable channel interrupt request when error conditions occur */
  33.             EDMA_SetErrorIntCmd(edmaRegBase, dmaChannel, enable);
  34.             break;
  35.         case EDMA_CHN_HALF_MAJOR_LOOP_INT:
  36.             /* Enable channel interrupt request when major iteration count reaches halfway point */
  37.             EDMA_TCDSetMajorHalfCompleteIntCmd(edmaRegBase, dmaChannel, enable);
  38.             break;
  39.         case EDMA_CHN_MAJOR_LOOP_INT:
  40.             /* Enable channel interrupt request when major iteration count reaches zero */
  41.             EDMA_TCDSetMajorCompleteIntCmd(edmaRegBase, dmaChannel, enable);
  42.             break;
  43.         default:
  44.             /* This branch should never be reached if driver API is used properly */
  45.             break;
  46.     }
  47. }

EDMA_DRV_CancelTransfer

取消传输

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_CancelTransfer
  4.  * Description   : Cancels the running transfer for this channel.
  5.  *
  6.  * Implements    : EDMA_DRV_CancelTransfer_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_CancelTransfer(bool error)
  9. {
  10.     /* Check that eDMA module is initialized */
  11.     DEV_ASSERT(s_virtEdmaState != NULL);
  12.  
  13.     uint32_t dmaInstance = 0U;
  14.  
  15.     for(dmaInstance = 0U; dmaInstance < (uint32_t)DMA_INSTANCE_COUNT; dmaInstance++)
  16.     {
  17.         /* Cancel the running transfer. */
  18.         DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  19.         if (error)
  20.         {
  21.             EDMA_CancelTransferWithError(edmaRegBase);
  22.         }
  23.         else
  24.         {
  25.             EDMA_CancelTransfer(edmaRegBase);
  26.         }
  27.     }
  28. }

EDMA_DRV_TriggerSwRequest

触发DMA请求

  1. /*FUNCTION**********************************************************************
  2.  *
  3.  * Function Name : EDMA_DRV_TriggerSwRequest
  4.  * Description   : Triggers a sw request for the current channel.
  5.  *
  6.  * Implements    : EDMA_DRV_TriggerSwRequest_Activity
  7.  *END**************************************************************************/
  8. void EDMA_DRV_TriggerSwRequest(uint8_t virtualChannel)
  9. {
  10.     /* Check that virtual channel number is valid */
  11.     DEV_ASSERT(virtualChannel < FEATURE_DMA_VIRTUAL_CHANNELS);
  12.  
  13.     /* Check that eDMA module is initialized */
  14.     DEV_ASSERT(s_virtEdmaState != NULL);
  15.  
  16.     /* Check that virtual channel is initialized */
  17.     DEV_ASSERT(s_virtEdmaState->virtChnState[virtualChannel] != NULL);
  18.  
  19.     /* Get DMA instance from virtual channel */
  20.     uint8_t dmaInstance = (uint8_t)FEATURE_DMA_VCH_TO_INSTANCE(virtualChannel);
  21.  
  22.     /* Get DMA channel from virtual channel*/
  23.     uint8_t dmaChannel = (uint8_t)FEATURE_DMA_VCH_TO_CH(virtualChannel);
  24.  
  25.     /* Trigger the channel transfer. */
  26.     DMA_Type *edmaRegBase = s_edmaBase[dmaInstance];
  27.     EDMA_TriggerChannelStart(edmaRegBase, dmaChannel);
  28. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/282401
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号