libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/acm32f0x0-nucleo/libraries/HAL_Driver/Src/HAL_DMA.c

425 lines
16 KiB
C
Raw Blame History

/*
******************************************************************************
* @file HAL_DMA.c
* @version V1.0.0
* @date 2020
* @brief DMA HAL module driver.
* This file provides firmware functions to manage the following
* functionalities of the Direct Memory Access (DMA) peripheral:
* @ Initialization and de-initialization functions
* @ IO operation functions
******************************************************************************
*/
#include "ACM32Fxx_HAL.h"
/**************** Used in cycle mode ****************/
static DMA_LLI_InitTypeDef Cycle_Channel[DMA_CHANNEL_NUM];
/*********************************************************************************
* Function : HAL_DMA_IRQHandler
* Description : This function handles DMA interrupt request.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
__weak void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{
uint32_t lu32_Channel_Index;
/* Get DMA Channel number */
lu32_Channel_Index = ((uint32_t)(hdma->Instance) - (uint32_t)(DMA_Channel0)) / 0x20;
/* Channel has been interrupted */
if (DMA->INT_STATUS & (1 << lu32_Channel_Index))
{
/* Transfer complete interrupt */
if (DMA->INT_TC_STATUS & (1 << lu32_Channel_Index))
{
DMA->INT_TC_CLR |= (1 << lu32_Channel_Index);
if (NULL != hdma->DMA_ITC_Callback)
{
hdma->DMA_ITC_Callback();
}
}
/* Transfer error interrupt */
if (DMA->INT_ERR_STATUS & (1 << lu32_Channel_Index))
{
DMA->INT_ERR_CLR |= (1 << lu32_Channel_Index);
if (NULL != hdma->DMA_IE_Callback)
{
hdma->DMA_IE_Callback();
}
}
}
}
/*********************************************************************************
* Function : HAL_DMA_Init
* Description : DMA initial with parameters.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_Init(DMA_HandleTypeDef *hdma)
{
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
if (!IS_DMA_DATA_FLOW(hdma->Init.Data_Flow)) return HAL_ERROR;
if (!IS_DMA_REQUEST_ID(hdma->Init.Request_ID)) return HAL_ERROR;
if (!IS_DMA_SRC_WIDTH(hdma->Init.Source_Width)) return HAL_ERROR;
if (!IS_DMA_DST_WIDTH(hdma->Init.Desination_Width)) return HAL_ERROR;
#endif
/* Enable DMA Module */
System_Module_Enable(EN_DMA);
/* Enable External Interrupt */
NVIC_ClearPendingIRQ(DMA_IRQn);
NVIC_EnableIRQ(DMA_IRQn);
/* Default Little-Endian、Enable DMA */
DMA->CONFIG = DMA_CONFIG_EN;
/* Clear Channel Config */
hdma->Instance->CONFIG = 0x00000000;
if (hdma->Init.Data_Flow == DMA_DATA_FLOW_M2P)
{
hdma->Init.Request_ID <<= DMA_CHANNEL_CONFIG_DEST_PERIPH_POS;
}
else if (hdma->Init.Data_Flow == DMA_DATA_FLOW_P2M)
{
hdma->Init.Request_ID <<= DMA_CHANNEL_CONFIG_SRC_PERIPH_POS;
}
hdma->Instance->CONFIG = hdma->Init.Data_Flow | hdma->Init.Request_ID;
/* Config Channel Control */
hdma->Instance->CTRL = DMA_CHANNEL_CTRL_ITC;
/* Source or Desination address increase */
hdma->Instance->CTRL |= (hdma->Init.Desination_Inc | hdma->Init.Source_Inc);
/* Source or Desination date width */
hdma->Instance->CTRL |= (hdma->Init.Desination_Width | hdma->Init.Source_Width);
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_DeInit
* Description : DMA De-initial with parameters.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_DeInit(DMA_HandleTypeDef *hdma)
{
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
if (!IS_DMA_DATA_FLOW(hdma->Init.Data_Flow)) return HAL_ERROR;
if (!IS_DMA_REQUEST_ID(hdma->Init.Request_ID)) return HAL_ERROR;
if (!IS_DMA_SRC_WIDTH(hdma->Init.Source_Width)) return HAL_ERROR;
if (!IS_DMA_DST_WIDTH(hdma->Init.Desination_Width)) return HAL_ERROR;
#endif
/* Reset DMA Module */
System_Module_Reset(RST_DMA);
/* Disable DMA Module */
System_Module_Disable(EN_DMA);
/* Disable Interrupt */
NVIC_ClearPendingIRQ(DMA_IRQn);
NVIC_DisableIRQ(DMA_IRQn);
hdma->DMA_IE_Callback = NULL;
hdma->DMA_ITC_Callback = NULL;
memset(&hdma->Init, 0, sizeof(hdma->Init));
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_NormalMode_Start
* Description : DMA transfer start.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Input : fu32_SrcAddr: source address
* Input : fu32_DstAddr: desination address
* Input : fu32_Size: transfer size (This parameter can be a 12-bit Size)
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_NormalMode_Start(DMA_HandleTypeDef *hdma, uint32_t fu32_SrcAddr, uint32_t fu32_DstAddr, uint32_t fu32_Size)
{
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
#endif
if (fu32_Size > 0xFFF)
{
return HAL_ERROR;
}
/* Set source address and desination address */
hdma->Instance->SRC_ADDR = fu32_SrcAddr;
hdma->Instance->DEST_ADDR = fu32_DstAddr;
/* Set Transfer Size */
hdma->Instance->CTRL = (hdma->Instance->CTRL & (~0xFFF)) | fu32_Size;
/* DMA Channel Enable */
hdma->Instance->CONFIG |= DMA_CHANNEL_CONFIG_EN;
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_NormalMode_Start_IT
* Description : DMA transfer start with interrupt.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Input : fu32_SrcAddr: source address
* Input : fu32_DstAddr: desination address
* Input : fu32_Size: transfer size (This parameter can be a 12-bit Size)
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_NormalMode_Start_IT(DMA_HandleTypeDef *hdma, uint32_t fu32_SrcAddr, uint32_t fu32_DstAddr, uint32_t fu32_Size)
{
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
#endif
/* Set source address and desination address */
hdma->Instance->SRC_ADDR = fu32_SrcAddr;
hdma->Instance->DEST_ADDR = fu32_DstAddr;
/* Set Transfer Size and enable LLI interrupt */
hdma->Instance->CTRL = (hdma->Instance->CTRL & (~0xFFF)) | fu32_Size;
// hdma->Instance->CTRL &=~(1<<31);
/* DMA Channel Enable and enable transfer error interrupt and transfer complete interrupt*/
hdma->Instance->CONFIG |= DMA_CHANNEL_CONFIG_ITC | DMA_CHANNEL_CONFIG_IE | DMA_CHANNEL_CONFIG_EN;
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_CycleMode_Start
* Description : DMA Cycle transfer start.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Input : fu32_SrcAddr: source address
* Input : fu32_DstAddr: desination address
* Input : fu32_Size: transfer size (This parameter can be a 12-bit Size)
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_CycleMode_Start(DMA_HandleTypeDef *hdma, uint32_t fu32_SrcAddr, uint32_t fu32_DstAddr, uint32_t fu32_Size)
{
uint32_t lu32_Channel_Index;
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
#endif
/* Get DMA Channel number */
lu32_Channel_Index = ((uint32_t)(hdma->Instance) - (uint32_t)(DMA_Channel0)) / 0x20;
/* Set source address and desination address */
hdma->Instance->SRC_ADDR = fu32_SrcAddr;
hdma->Instance->DEST_ADDR = fu32_DstAddr;
/* Set Next Link */
hdma->Instance->LLI = (uint32_t)&Cycle_Channel[lu32_Channel_Index];
/* Set Transfer Size */
hdma->Instance->CTRL = (hdma->Instance->CTRL & (~0xFFF)) | fu32_Size;
/* The list point to oneself */
Cycle_Channel[lu32_Channel_Index].SrcAddr = fu32_SrcAddr;
Cycle_Channel[lu32_Channel_Index].DstAddr = fu32_DstAddr;
Cycle_Channel[lu32_Channel_Index].Next = &Cycle_Channel[lu32_Channel_Index];
Cycle_Channel[lu32_Channel_Index].Control = (hdma->Instance->CTRL & (~0xFFF)) | fu32_Size;
/* DMA Channel Enable */
hdma->Instance->CONFIG |= DMA_CHANNEL_CONFIG_EN;
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_CycleMode_Start_IT
* Description : DMA Cycle transfer start with interrupt.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Input : fu32_SrcAddr: source address
* Input : fu32_DstAddr: desination address
* Input : fu32_Size: transfer size (This parameter can be a 12-bit Size)
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_CycleMode_Start_IT(DMA_HandleTypeDef *hdma, uint32_t fu32_SrcAddr, uint32_t fu32_DstAddr, uint32_t fu32_Size)
{
uint32_t lu32_Channel_Index;
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
#endif
/* Get DMA Channel number */
lu32_Channel_Index = ((uint32_t)(hdma->Instance) - (uint32_t)(DMA_Channel0)) / 0x20;
/* Set source address and desination address */
hdma->Instance->SRC_ADDR = fu32_SrcAddr;
hdma->Instance->DEST_ADDR = fu32_DstAddr;
/* Set Next Link */
hdma->Instance->LLI = (uint32_t)&Cycle_Channel[lu32_Channel_Index];
/* Set Transfer Size */
hdma->Instance->CTRL = (hdma->Instance->CTRL & (~0xFFF)) | fu32_Size;
/* The list point to oneself */
Cycle_Channel[lu32_Channel_Index].SrcAddr = fu32_SrcAddr;
Cycle_Channel[lu32_Channel_Index].DstAddr = fu32_DstAddr;
Cycle_Channel[lu32_Channel_Index].Next = &Cycle_Channel[lu32_Channel_Index];
Cycle_Channel[lu32_Channel_Index].Control = (hdma->Instance->CTRL & (~0xFFF)) | fu32_Size;
/* DMA Channel Enable and enable transfer error interrupt and transfer complete interrupt*/
hdma->Instance->CONFIG |= DMA_CHANNEL_CONFIG_ITC | DMA_CHANNEL_CONFIG_IE | DMA_CHANNEL_CONFIG_EN;
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_Start
* Description : DMA transfer start.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Input : fu32_SrcAddr: source address
* Input : fu32_DstAddr: desination address
* Input : fu32_Size: transfer size (This parameter can be a 12-bit Size)
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_Start(DMA_HandleTypeDef *hdma, uint32_t fu32_SrcAddr, uint32_t fu32_DstAddr, uint32_t fu32_Size)
{
/* Check DMA Parameter */
if (!IS_DMA_MODE(hdma->Init.Mode)) return HAL_ERROR;
if (hdma->Init.Mode == DMA_NORMAL)
{
return HAL_DMA_NormalMode_Start(hdma, fu32_SrcAddr, fu32_DstAddr, fu32_Size);
}
else
{
return HAL_DMA_CycleMode_Start(hdma, fu32_SrcAddr, fu32_DstAddr, fu32_Size);
}
}
/*********************************************************************************
* Function : HAL_DMA_Start_IT
* Description : DMA transfer start with interrupt.
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Input : fu32_SrcAddr: source address
* Input : fu32_DstAddr: desination address
* Input : fu32_Size: transfer size (This parameter can be a 12-bit Size)
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t fu32_SrcAddr, uint32_t fu32_DstAddr, uint32_t fu32_Size)
{
/* Check DMA Parameter */
if (!IS_DMA_MODE(hdma->Init.Mode)) return HAL_ERROR;
if (hdma->Init.Mode == DMA_NORMAL)
{
return HAL_DMA_NormalMode_Start_IT(hdma, fu32_SrcAddr, fu32_DstAddr, fu32_Size);
}
else
{
return HAL_DMA_CycleMode_Start_IT(hdma, fu32_SrcAddr, fu32_DstAddr, fu32_Size);
}
}
/*********************************************************************************
* Function : HAL_DMA_Abort
* Description : Abort the DMA Transfer
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Output :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_Abort(DMA_HandleTypeDef *hdma)
{
uint32_t lu32_Channel_Index;
#if (USE_FULL_ASSERT == 1)
/* Check DMA Parameter */
if (!IS_DMA_ALL_INSTANCE(hdma->Instance)) return HAL_ERROR;
#endif
/* Get DMA Channel number */
lu32_Channel_Index = ((uint32_t)(hdma->Instance) - (uint32_t)(DMA_Channel0)) / 0x20;
/* DMA Channel Disable */
hdma->Instance->CONFIG &= ~(1 << 0);
/* Clear TC ERR Falg */
DMA->INT_TC_CLR |= (1 << lu32_Channel_Index);
DMA->INT_ERR_CLR |= (1 << lu32_Channel_Index);
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_DMA_GetState
* Description : Returns the DMA state..
* Input : hdma : pointer to a DMA_HandleTypeDef structure that contains
* the configuration information for DMA module
* Output :
* Author : Data : 2021
**********************************************************************************/
HAL_StatusTypeDef HAL_DMA_GetState(DMA_HandleTypeDef *hdma)
{
uint32_t lu32_Channel_Index;
HAL_StatusTypeDef States = HAL_ERROR;
/* Get DMA Channel number */
lu32_Channel_Index = ((uint32_t)(hdma->Instance) - (uint32_t)(DMA_Channel0)) / 0x20;
/* Transfer complete interrupt */
if (DMA->RAW_INT_TC_STATUS & (1 << lu32_Channel_Index))
{
DMA->INT_TC_CLR |= (1 << lu32_Channel_Index);
States = HAL_OK;
}
/* Transfer error interrupt */
if (DMA->RAW_INT_ERR_STATUS & (1 << lu32_Channel_Index))
{
DMA->INT_ERR_CLR |= (1 << lu32_Channel_Index);
States = HAL_ERROR;
}
return States;
}
View Git Blame Copy Permalink