632 lines
32 KiB
C
632 lines
32 KiB
C
/**
|
||
******************************************************************************
|
||
* @file plib035_dma.h
|
||
*
|
||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||
* DMA, а также сопутствующие макроопределения и перечисления
|
||
*
|
||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||
*
|
||
******************************************************************************
|
||
* @attention
|
||
*
|
||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||
*
|
||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||
******************************************************************************
|
||
*/
|
||
|
||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||
#ifndef __PLIB035_DMA_H
|
||
#define __PLIB035_DMA_H
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
/* Includes ------------------------------------------------------------------*/
|
||
#include "plib035.h"
|
||
|
||
/** @addtogroup Peripheral
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup DMA
|
||
* @brief Драйвер для работы с DMA
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup DMA_Exported_Defines Константы
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup DMA_ChannelMux_Define Мультиплексируемые каналы
|
||
* @{
|
||
*/
|
||
|
||
#define DMA_ChannelMux_8 SIU_DMAMUX_SRCSEL8_Msk /*!< Выбор мультиплексора канала DMA 8 */
|
||
#define DMA_ChannelMux_9 SIU_DMAMUX_SRCSEL9_Msk /*!< Выбор мультиплексора канала DMA 9 */
|
||
#define DMA_ChannelMux_10 SIU_DMAMUX_SRCSEL10_Msk /*!< Выбор мультиплексора канала DMA 10 */
|
||
#define DMA_ChannelMux_11 SIU_DMAMUX_SRCSEL11_Msk /*!< Выбор мультиплексора канала DMA 11 */
|
||
#define DMA_ChannelMux_12 SIU_DMAMUX_SRCSEL12_Msk /*!< Выбор мультиплексора канала DMA 12 */
|
||
#define DMA_ChannelMux_13 SIU_DMAMUX_SRCSEL13_Msk /*!< Выбор мультиплексора канала DMA 13 */
|
||
#define DMA_ChannelMux_14 SIU_DMAMUX_SRCSEL14_Msk /*!< Выбор мультиплексора канала DMA 14 */
|
||
#define DMA_ChannelMux_15 SIU_DMAMUX_SRCSEL15_Msk /*!< Выбор мультиплексора канала DMA 15 */
|
||
#define DMA_ChannelMux_All (DMA_ChannelMux_8 | \
|
||
DMA_ChannelMux_9 | \
|
||
DMA_ChannelMux_10 | \
|
||
DMA_ChannelMux_11 | \
|
||
DMA_ChannelMux_12 | \
|
||
DMA_ChannelMux_13 | \
|
||
DMA_ChannelMux_14 | \
|
||
DMA_ChannelMux_15) /*!< Выбор всех мультиплексоров каналов DMA */
|
||
|
||
#define IS_DMA_CHANNEL_MUX_NUM(VALUE) (((VALUE) != 0) && (((VALUE) & (~DMA_ChannelMux_All)) == 0))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_ChannelMux_Sel_Define Выбор источников мультиплексируемых каналов
|
||
* @{
|
||
*/
|
||
|
||
#define DMA_ChannelMux_8_QEP (SIU_DMAMUX_SRCSEL8_QEP << SIU_DMAMUX_SRCSEL8_Pos) /*!< Выбор QEP в качестве источника запросов канала DMA 8 */
|
||
#define DMA_ChannelMux_8_GPIOA (SIU_DMAMUX_SRCSEL8_GPIOA << SIU_DMAMUX_SRCSEL8_Pos) /*!< Выбор GPIOA в качестве источника запросов канала DMA 8 */
|
||
#define DMA_ChannelMux_9_TMR0 (SIU_DMAMUX_SRCSEL9_TMR0 << SIU_DMAMUX_SRCSEL9_Pos) /*!< Выбор TMR0 в качестве источника запросов канала DMA 9 */
|
||
#define DMA_ChannelMux_9_GPIOB (SIU_DMAMUX_SRCSEL9_GPIOB << SIU_DMAMUX_SRCSEL9_Pos) /*!< Выбор GPIOB в качестве источника запросов канала DMA 9 */
|
||
#define DMA_ChannelMux_10_TMR1 (SIU_DMAMUX_SRCSEL10_TMR1 << SIU_DMAMUX_SRCSEL10_Pos) /*!< Выбор TMR1 в качестве источника запросов канала DMA 10 */
|
||
#define DMA_ChannelMux_10_PWM2B (SIU_DMAMUX_SRCSEL10_PWM0B << SIU_DMAMUX_SRCSEL10_Pos) /*!< Выбор PWM2 B в качестве источника запросов канала DMA 10 */
|
||
#define DMA_ChannelMux_11_TMR2 (SIU_DMAMUX_SRCSEL11_TMR2 << SIU_DMAMUX_SRCSEL11_Pos) /*!< Выбор TMR2 в качестве источника запросов канала DMA 11 */
|
||
#define DMA_ChannelMux_11_PWM1B (SIU_DMAMUX_SRCSEL11_PWM1B << SIU_DMAMUX_SRCSEL11_Pos) /*!< Выбор PWM1 B в качестве источника запросов канала DMA 11 */
|
||
#define DMA_ChannelMux_12_TMR3 (SIU_DMAMUX_SRCSEL12_TMR3 << SIU_DMAMUX_SRCSEL12_Pos) /*!< Выбор TMR3 в качестве источника запросов канала DMA 12 */
|
||
#define DMA_ChannelMux_12_PWM0B (SIU_DMAMUX_SRCSEL12_PWM2B << SIU_DMAMUX_SRCSEL12_Pos) /*!< Выбор PWM0 B в качестве источника запросов канала DMA 12 */
|
||
#define DMA_ChannelMux_13_PWM0A (SIU_DMAMUX_SRCSEL13_PWM0A << SIU_DMAMUX_SRCSEL13_Pos) /*!< Выбор PWM0 A в качестве источника запросов канала DMA 13 */
|
||
#define DMA_ChannelMux_14_PWM1A (SIU_DMAMUX_SRCSEL14_PWM1A << SIU_DMAMUX_SRCSEL14_Pos) /*!< Выбор PWM1 A в качестве источника запросов канала DMA 14 */
|
||
#define DMA_ChannelMux_15_PWM2A (SIU_DMAMUX_SRCSEL15_PWM2A << SIU_DMAMUX_SRCSEL15_Pos) /*!< Выбор PWM2 A в качестве источника запросов канала DMA 15 */
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Channel_Define Маски каналов DMA
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup DMA_Channel_Num_Define Маски каналов по номеру
|
||
* @{
|
||
*/
|
||
|
||
#define DMA_Channel_0 0x00000001UL /*!< Канал DMA 0 */
|
||
#define DMA_Channel_1 0x00000002UL /*!< Канал DMA 1 */
|
||
#define DMA_Channel_2 0x00000004UL /*!< Канал DMA 2 */
|
||
#define DMA_Channel_3 0x00000008UL /*!< Канал DMA 3 */
|
||
#define DMA_Channel_4 0x00000010UL /*!< Канал DMA 4 */
|
||
#define DMA_Channel_5 0x00000020UL /*!< Канал DMA 5 */
|
||
#define DMA_Channel_6 0x00000040UL /*!< Канал DMA 6 */
|
||
#define DMA_Channel_7 0x00000080UL /*!< Канал DMA 7 */
|
||
#define DMA_Channel_8 0x00000100UL /*!< Канал DMA 8 */
|
||
#define DMA_Channel_9 0x00000200UL /*!< Канал DMA 9 */
|
||
#define DMA_Channel_10 0x00000400UL /*!< Канал DMA 10 */
|
||
#define DMA_Channel_11 0x00000800UL /*!< Канал DMA 11 */
|
||
#define DMA_Channel_12 0x00001000UL /*!< Канал DMA 12 */
|
||
#define DMA_Channel_13 0x00002000UL /*!< Канал DMA 13 */
|
||
#define DMA_Channel_14 0x00004000UL /*!< Канал DMA 14 */
|
||
#define DMA_Channel_15 0x00008000UL /*!< Канал DMA 15 */
|
||
#define DMA_Channel_16 0x00010000UL /*!< Канал DMA 16 */
|
||
#define DMA_Channel_All 0x0000FFFFUL /*!< Все каналы DMA */
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Channel_Periph_Define Маски каналов по имени
|
||
* @{
|
||
*/
|
||
|
||
#define DMA_Channel_UART0_TX DMA_Channel_0 /*!< Канал DMA по передаче от UART0 */
|
||
#define DMA_Channel_UART1_TX DMA_Channel_1 /*!< Канал DMA по передаче от UART1 */
|
||
#define DMA_Channel_UART0_RX DMA_Channel_2 /*!< Канал DMA по приему от UART0 */
|
||
#define DMA_Channel_UART1_RX DMA_Channel_3 /*!< Канал DMA по приему от UART1 */
|
||
#define DMA_Channel_ADC_SEQ0 DMA_Channel_4 /*!< Канал DMA секвенсора 0 АЦП */
|
||
#define DMA_Channel_ADC_SEQ1 DMA_Channel_5 /*!< Канал DMA секвенсора 1 АЦП */
|
||
#define DMA_Channel_SPI_TX DMA_Channel_6 /*!< Канал DMA по передаче от SPI */
|
||
#define DMA_Channel_SPI_RX DMA_Channel_7 /*!< Канал DMA по приему от SPI */
|
||
#define DMA_Channel_PWM0_A DMA_Channel_13 /*!< Канал PWM0 A */
|
||
#define DMA_Channel_PWM1_A DMA_Channel_14 /*!< Канал PWM1 A */
|
||
#define DMA_Channel_PWM2_A DMA_Channel_15 /*!< Канал PWM2 A */
|
||
#define DMA_Channel_PWM2_B DMA_Channel_12 /*!< Канал PWM2 B */
|
||
#define DMA_Channel_PWM1_B DMA_Channel_11 /*!< Канал PWM1 B */
|
||
#define DMA_Channel_PWM0_B DMA_Channel_10 /*!< Канал PWM0 B */
|
||
#define DMA_Channel_TMR0 DMA_Channel_9 /*!< Канал TMR0 */
|
||
#define DMA_Channel_TMR1 DMA_Channel_10 /*!< Канал TMR1 */
|
||
#define DMA_Channel_TMR2 DMA_Channel_11 /*!< Канал TMR2 */
|
||
#define DMA_Channel_TMR3 DMA_Channel_12 /*!< Канал TMR3 */
|
||
#define DMA_Channel_QEP DMA_Channel_8 /*!< Канал QEP */
|
||
#define DMA_Channel_GPIOA DMA_Channel_8 /*!< Канал GPIOA */
|
||
#define DMA_Channel_GPIOB DMA_Channel_9 /*!< Канал GPIOB */
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
#define IS_DMA_CHANNEL(VALUE) (((VALUE) != 0) && (((VALUE)&0xFFFF0000) == 0))
|
||
|
||
#define IS_GET_DMA_CHANNEL(VALUE) (((VALUE) == (DMA_Channel_0)) || \
|
||
((VALUE) == (DMA_Channel_1)) || \
|
||
((VALUE) == (DMA_Channel_2)) || \
|
||
((VALUE) == (DMA_Channel_3)) || \
|
||
((VALUE) == (DMA_Channel_4)) || \
|
||
((VALUE) == (DMA_Channel_5)) || \
|
||
((VALUE) == (DMA_Channel_6)) || \
|
||
((VALUE) == (DMA_Channel_7)) || \
|
||
((VALUE) == (DMA_Channel_8)) || \
|
||
((VALUE) == (DMA_Channel_9)) || \
|
||
((VALUE) == (DMA_Channel_10)) || \
|
||
((VALUE) == (DMA_Channel_11)) || \
|
||
((VALUE) == (DMA_Channel_12)) || \
|
||
((VALUE) == (DMA_Channel_13)) || \
|
||
((VALUE) == (DMA_Channel_14)) || \
|
||
((VALUE) == (DMA_Channel_15)))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Exported_Types Типы
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Выбор режима работы DMA
|
||
*/
|
||
|
||
typedef enum {
|
||
DMA_Mode_Disable = DMA_CHANNEL_CFG_CYCLE_CTRL_Stop, /*!< Неактивное состояние */
|
||
DMA_Mode_Basic = DMA_CHANNEL_CFG_CYCLE_CTRL_Basic, /*!< Основной режим передачи */
|
||
DMA_Mode_AutoReq = DMA_CHANNEL_CFG_CYCLE_CTRL_AutoReq, /*!< Режим передачи с авто-запросом */
|
||
DMA_Mode_PingPong = DMA_CHANNEL_CFG_CYCLE_CTRL_PingPong, /*!< Режим передачи "пинг-понг" */
|
||
DMA_Mode_PrmMemScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_MemScatGathPrim, /*!< Работа с памятью в режиме "разборка-сборка" с использованием первичной управляющей структуры */
|
||
DMA_Mode_AltMemScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_MemScatGathAlt, /*!< Работа с памятью в режиме "разборка-сборка" с использованием альтернативной управляющей структуры */
|
||
DMA_Mode_PrmPeriphScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_PeriphScatGathPrim, /*!< Работа с периферией в режиме "разборка-сборка" с использованием первичной управляющей структуры */
|
||
DMA_Mode_AltPeriphScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_PeriphScatGathAlt /*!< Работа с периферией в режиме "разборка-сборка" с использованием альтернативной управляющей структуры */
|
||
} DMA_Mode_TypeDef;
|
||
#define IS_DMA_MODE(VALUE) (((VALUE) == DMA_Mode_Disable) || \
|
||
((VALUE) == DMA_Mode_Basic) || \
|
||
((VALUE) == DMA_Mode_AutoReq) || \
|
||
((VALUE) == DMA_Mode_PingPong) || \
|
||
((VALUE) == DMA_Mode_PrmMemScatGath) || \
|
||
((VALUE) == DMA_Mode_AltMemScatGath) || \
|
||
((VALUE) == DMA_Mode_PrmPeriphScatGath) || \
|
||
((VALUE) == DMA_Mode_AltPeriphScatGath))
|
||
|
||
/**
|
||
* @brief Выбор количества передач до выполнения переарбитрации
|
||
*/
|
||
typedef enum {
|
||
DMA_ArbitrationRate_1, /*!< Переарбитрация каждую передачу DMA */
|
||
DMA_ArbitrationRate_2, /*!< Переарбитрация каждые 2 передачи DMA */
|
||
DMA_ArbitrationRate_4, /*!< Переарбитрация каждые 4 передачи DMA */
|
||
DMA_ArbitrationRate_8, /*!< Переарбитрация каждые 8 передач DMA */
|
||
DMA_ArbitrationRate_16, /*!< Переарбитрация каждые 16 передач DMA */
|
||
DMA_ArbitrationRate_32, /*!< Переарбитрация каждые 32 передачи DMA */
|
||
DMA_ArbitrationRate_64, /*!< Переарбитрация каждые 64 передачи DMA */
|
||
DMA_ArbitrationRate_128, /*!< Переарбитрация каждые 128 передач DMA */
|
||
DMA_ArbitrationRate_256, /*!< Переарбитрация каждые 256 передач DMA */
|
||
DMA_ArbitrationRate_512, /*!< Переарбитрация каждые 512 передач DMA */
|
||
DMA_ArbitrationRate_1024 /*!< Переарбитрация каждые 1024 передачи DMA */
|
||
} DMA_ArbitrationRate_TypeDef;
|
||
#define IS_DMA_ARBITRATION_RATE(VALUE) (((VALUE) == DMA_ArbitrationRate_1) || \
|
||
((VALUE) == DMA_ArbitrationRate_2) || \
|
||
((VALUE) == DMA_ArbitrationRate_4) || \
|
||
((VALUE) == DMA_ArbitrationRate_8) || \
|
||
((VALUE) == DMA_ArbitrationRate_16) || \
|
||
((VALUE) == DMA_ArbitrationRate_32) || \
|
||
((VALUE) == DMA_ArbitrationRate_64) || \
|
||
((VALUE) == DMA_ArbitrationRate_128) || \
|
||
((VALUE) == DMA_ArbitrationRate_256) || \
|
||
((VALUE) == DMA_ArbitrationRate_512) || \
|
||
((VALUE) == DMA_ArbitrationRate_1024))
|
||
|
||
/**
|
||
* @brief Разрядность данных источника или приемника
|
||
*/
|
||
typedef enum {
|
||
DMA_DataSize_8 = DMA_CHANNEL_CFG_SRC_SIZE_Byte, /*!< Разрядность данных 8 бит */
|
||
DMA_DataSize_16 = DMA_CHANNEL_CFG_SRC_SIZE_Halfword, /*!< Разрядность данных 16 бит */
|
||
DMA_DataSize_32 = DMA_CHANNEL_CFG_SRC_SIZE_Word /*!< Разрядность данных 32 бит */
|
||
} DMA_DataSize_TypeDef;
|
||
#define IS_DMA_DATA_SIZE(VALUE) (((VALUE) == DMA_DataSize_8) || \
|
||
((VALUE) == DMA_DataSize_16) || \
|
||
((VALUE) == DMA_DataSize_32))
|
||
|
||
/**
|
||
* @brief Шаг инкремента адреса источника при чтении или приемника при записи
|
||
*/
|
||
typedef enum {
|
||
DMA_DataInc_8 = DMA_CHANNEL_CFG_SRC_INC_Byte, /*!< Инкремент данных 8 бит */
|
||
DMA_DataInc_16 = DMA_CHANNEL_CFG_SRC_INC_Halfword, /*!< Инкремент данных 16 бит */
|
||
DMA_DataInc_32 = DMA_CHANNEL_CFG_SRC_INC_Word, /*!< Инкремент данных 32 бит */
|
||
DMA_DataInc_Disable = DMA_CHANNEL_CFG_SRC_INC_None /*!< Инкремент отсутствует */
|
||
} DMA_DataInc_TypeDef;
|
||
#define IS_DMA_DATA_INC(VALUE) (((VALUE) == DMA_DataInc_8) || \
|
||
((VALUE) == DMA_DataInc_16) || \
|
||
((VALUE) == DMA_DataInc_32) || \
|
||
((VALUE) == DMA_DataInc_Disable))
|
||
|
||
/**
|
||
* @brief Возможные состояния конечного автомата управления контроллером DMA
|
||
*/
|
||
typedef enum {
|
||
DMA_State_Free = DMA_STATUS_STATE_Free, /*!< В покое */
|
||
DMA_State_ReadConfigData = DMA_STATUS_STATE_ReadConfigData, /*!< Чтение управляющих данных канала */
|
||
DMA_State_ReadSrcDataEndPtr = DMA_STATUS_STATE_ReadSrcDataEndPtr, /*!< Чтение указателя конца данных источника */
|
||
DMA_State_ReadDstDataEndPtr = DMA_STATUS_STATE_ReadDstDataEndPtr, /*!< Чтение указателя конца данных приемника */
|
||
DMA_State_ReadSrcData = DMA_STATUS_STATE_ReadSrcData, /*!< Чтение данных источника */
|
||
DMA_State_WriteDstData = DMA_STATUS_STATE_WrireDstData, /*!< Запись данных в приемник */
|
||
DMA_State_WaitReq = DMA_STATUS_STATE_WaitReq, /*!< Ожидание запроса на выполнение прямого доступа */
|
||
DMA_State_WriteConfigData = DMA_STATUS_STATE_WriteConfigData, /*!< Запись управляющих данных канала */
|
||
DMA_State_Pause = DMA_STATUS_STATE_Pause, /*!< Приостановлен */
|
||
DMA_State_Done = DMA_STATUS_STATE_Done, /*!< Выполнен */
|
||
DMA_State_PeriphScatGath = DMA_STATUS_STATE_PeriphScatGath /*!< Работа с периферией в режиме "разборка-сборка" */
|
||
} DMA_State_TypeDef;
|
||
#define IS_DMA_STATE(VALUE) (((VALUE) == DMA_State_Free) || \
|
||
((VALUE) == DMA_State_ReadConfigData) || \
|
||
((VALUE) == DMA_State_ReadSrcDataEndPtr) || \
|
||
((VALUE) == DMA_State_ReadDstDataEndPtr) || \
|
||
((VALUE) == DMA_State_ReadSrcData) || \
|
||
((VALUE) == DMA_State_WriteDstData) || \
|
||
((VALUE) == DMA_State_WaitReq) || \
|
||
((VALUE) == DMA_State_Pause) || \
|
||
((VALUE) == DMA_State_Done) || \
|
||
((VALUE) == DMA_State_PeriphScatGath))
|
||
|
||
/**
|
||
* @brief Защита шины при чтении из источника или записи в приемник через DMA
|
||
*/
|
||
typedef struct
|
||
{
|
||
FunctionalState Priveleged; /*!< Управление привелегированным доступом */
|
||
FunctionalState Bufferable; /*!< Управление буфферизацией доступа */
|
||
FunctionalState Cacheable; /*!< Управление кэшированием доступа */
|
||
} DMA_Protect_TypeDef;
|
||
|
||
/**
|
||
* @brief Структура инициализации канала DMA
|
||
*/
|
||
typedef struct
|
||
{
|
||
void* SrcDataEndPtr; /*!< Указатель конца данных источника */
|
||
void* DstDataEndPtr; /*!< Указатель конца данных приемника */
|
||
DMA_Mode_TypeDef Mode; /*!< Выбор режима работы DMA. */
|
||
FunctionalState NextUseburst; /*!< Контроль установки соответсвующего каналу бита в регистре NT_DMA->CHNL_USEBURST_SET */
|
||
uint32_t TransfersTotal; /*!< Общее количество передач DMA.
|
||
Параметр может принимать любое значение из диапазона 1-1024 */
|
||
DMA_ArbitrationRate_TypeDef ArbitrationRate; /*!< Выбор количества передач до выполнения переарбитрации */
|
||
DMA_Protect_TypeDef SrcProtect; /*!< Защита шины при чтении из источника через DMA */
|
||
DMA_Protect_TypeDef DstProtect; /*!< Защита шины при записи в приемник через DMA */
|
||
DMA_DataSize_TypeDef SrcDataSize; /*!< Разрядность данных источника */
|
||
DMA_DataSize_TypeDef DstDataSize; /*!< Разрядность данных приемника */
|
||
DMA_DataInc_TypeDef SrcDataInc; /*!< Шаг инкремента адреса источника при чтении */
|
||
DMA_DataInc_TypeDef DstDataInc; /*!< Шаг инкремента адреса приемника при записи */
|
||
} DMA_ChannelInit_TypeDef;
|
||
#define IS_DMA_TRANSFERS_TOTAL(VALUE) (((VALUE) <= 1024) && ((VALUE) >= 1))
|
||
|
||
/**
|
||
* @brief Структура инициализации контроллера DMA
|
||
*/
|
||
typedef struct
|
||
{
|
||
uint32_t Channel; /*!< Определяет каналы, которые будут настроены.
|
||
Параметр может принимать значение любой комбинации масок DMA_Channel_x из @ref DMA_Channel_Define. */
|
||
DMA_Protect_TypeDef CtrlProtect; /*!< Управление защитой шины при обращении DMA к управляющим данным */
|
||
FunctionalState UseBurst; /*!< Установка пакетного обмена каналов DMA */
|
||
FunctionalState ReqMask; /*!< Маскирование (игнорирование) запросов от периферии на обслуживание каналов DMA */
|
||
FunctionalState AltCtrl; /*!< Установка альтернативной управляющей структуры каналов DMA */
|
||
FunctionalState HighPriority; /*!< Установка высокого приоритета каналов DMA */
|
||
FunctionalState ChannelEnable; /*!< Разрешение работы каналов DMA */
|
||
} DMA_Init_TypeDef;
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Exported_Functions Функции
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Настройка запросов периферии для мультиплексируемых каналов 8-15
|
||
* @param MuxNum Номера каналов. Любое сочетание значений DMA_ChannelMux_N (@ref DMA_ChannelMux_Define)
|
||
* @param MuxSel Выбор источников. Любое сочетание значений из DMA_ChannelMux_N_x (@ref DMA_ChannelMux_Sel_Define)
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_ChannelMuxConfig(uint32_t MuxNum, uint32_t MuxSel)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL_MUX_NUM(MuxNum));
|
||
|
||
MODIFY_REG(SIU->DMAMUX, MuxNum, MuxSel);
|
||
}
|
||
|
||
/** @defgroup DMA_Exported_Functions_Init_Channel Инициализация каналов DMA
|
||
* @{
|
||
*/
|
||
|
||
void DMA_ChannelDeInit(DMA_Channel_TypeDef* ChannelStruct);
|
||
void DMA_ChannelInit(DMA_Channel_TypeDef* ChannelStruct, DMA_ChannelInit_TypeDef* ChannelInitStruct);
|
||
void DMA_ChannelStructInit(DMA_ChannelInit_TypeDef* ChannelInitStruct);
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Exported_Functions_Init Инициализация контроллера DMA
|
||
* @{
|
||
*/
|
||
|
||
void DMA_DeInit(void);
|
||
void DMA_Init(DMA_Init_TypeDef* InitStruct);
|
||
void DMA_StructInit(DMA_Init_TypeDef* InitStruct);
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Exported_Functions_Config Конфигурация контроллера DMA
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Установка базового адреса управляющих каналов
|
||
* @param BasePtr Значение базового адреса
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_BasePtrConfig(uint32_t BasePtr)
|
||
{
|
||
WRITE_REG(DMA->BASEPTR, BasePtr);
|
||
}
|
||
|
||
/**
|
||
* @brief Управление защитой шины при обращении контроллера DMA к управляющим данным
|
||
* @param CtrlProtect Структура, содержащая конфигурацию защиты
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_ProtectConfig(DMA_Protect_TypeDef* CtrlProtect)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(CtrlProtect->Bufferable));
|
||
assert_param(IS_FUNCTIONAL_STATE(CtrlProtect->Cacheable));
|
||
assert_param(IS_FUNCTIONAL_STATE(CtrlProtect->Priveleged));
|
||
|
||
MODIFY_REG(DMA->CFG, DMA_CFG_CHPROT_Msk, ((CtrlProtect->Priveleged << (DMA_CFG_CHPROT_Pos + 0)) |
|
||
(CtrlProtect->Bufferable << (DMA_CFG_CHPROT_Pos + 1)) |
|
||
(CtrlProtect->Cacheable << (DMA_CFG_CHPROT_Pos + 2))));
|
||
}
|
||
|
||
/**
|
||
* @brief Разрешения работы контроллера DMA
|
||
* @attention Прежде чем включать DMA, необходимо проинициализоровать каналы
|
||
* с помощью @ref DMA_ChannelInit и сконфигурировать контроллер DMA через функцию
|
||
* инициализации @ref DMA_Init или вручную - @ref DMA_Exported_Functions_Config.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_MasterEnableCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(DMA->CFG_bit.MASTEREN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Программный запрос на осуществление передач DMA по выбранным каналам
|
||
* @param Channel Выбор канала.
|
||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_SwRequestCmd(uint32_t Channel)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL(Channel));
|
||
|
||
WRITE_REG(DMA->SWREQ, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Установка пакетного обмена каналов DMA
|
||
* @param Channel Выбор канала.
|
||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_UseBurstCmd(uint32_t Channel, FunctionalState State)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL(Channel));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
if (State == ENABLE)
|
||
WRITE_REG(DMA->USEBURSTSET, Channel);
|
||
else
|
||
WRITE_REG(DMA->USEBURSTCLR, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Маскирование каналов DMA
|
||
* @attention По маскированным каналам игнорируются запросы на передачи
|
||
* @param Channel Выбор канала
|
||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_ReqMaskCmd(uint32_t Channel, FunctionalState State)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL(Channel));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
if (State == ENABLE)
|
||
WRITE_REG(DMA->REQMASKSET, Channel);
|
||
else
|
||
WRITE_REG(DMA->REQMASKCLR, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Активация каналов DMA
|
||
* @param Channel Выбор канала
|
||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_ChannelEnableCmd(uint32_t Channel, FunctionalState State)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL(Channel));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
if (State == ENABLE)
|
||
WRITE_REG(DMA->ENSET, Channel);
|
||
else
|
||
WRITE_REG(DMA->ENCLR, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Установка альтернативной управляющей структуры каналов DMA
|
||
* @param Channel Выбор канала.
|
||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_AltCtrlCmd(uint32_t Channel, FunctionalState State)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL(Channel));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
if (State == ENABLE)
|
||
WRITE_REG(DMA->PRIALTSET, Channel);
|
||
else
|
||
WRITE_REG(DMA->PRIALTCLR, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Установка высокого приоритета каналов DMA
|
||
* @param Channel Выбор канала.
|
||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_HighPriorityCmd(uint32_t Channel, FunctionalState State)
|
||
{
|
||
assert_param(IS_DMA_CHANNEL(Channel));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
if (State == ENABLE)
|
||
WRITE_REG(DMA->PRIORITYSET, Channel);
|
||
else
|
||
WRITE_REG(DMA->PRIORITYCLR, Channel);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup DMA_Exported_Functions_Status Статусная информация
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Доступ к текущему конечного автомата контроллера DMA
|
||
* @retval State Текущее состояние конечного автомата
|
||
*/
|
||
__STATIC_INLINE DMA_State_TypeDef DMA_StateStatus(void)
|
||
{
|
||
return (DMA_State_TypeDef)READ_REG(DMA->STATUS_bit.STATE);
|
||
}
|
||
|
||
/**
|
||
* @brief Состояние контроллера DMA
|
||
* @retval State Текущее состояние контроллера DMA
|
||
*/
|
||
__STATIC_INLINE FunctionalState DMA_MasterEnableStatus(void)
|
||
{
|
||
return (FunctionalState)READ_BIT(DMA->STATUS, DMA_STATUS_MASTEREN_Msk);
|
||
}
|
||
|
||
/**
|
||
* @brief Состояние канала DMA
|
||
* @param Channel Выбор канала
|
||
* @retval State Текущее состояние контроллера DMA
|
||
*/
|
||
__STATIC_INLINE FunctionalState DMA_ChannelEnableStatus(uint32_t Channel)
|
||
{
|
||
assert_param(IS_GET_DMA_CHANNEL(Channel));
|
||
|
||
return (FunctionalState)READ_BIT(DMA->ENSET, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Показывает поддерживает ли канал одиночные SREQ запросы
|
||
* @param Channel Выбор канала
|
||
* @retval State Одно из значений @ref FunctionalState:
|
||
* - ENABLE - поддерживаются SREQ (как и блочные BREQ);
|
||
* - DISABLE - поддерживаются только блочные запросы BREQ.
|
||
*/
|
||
__STATIC_INLINE FunctionalState DMA_WaitOnReqStatus(uint32_t Channel)
|
||
{
|
||
assert_param(IS_GET_DMA_CHANNEL(Channel));
|
||
|
||
return (FunctionalState)READ_BIT(DMA->WAITONREQ, Channel);
|
||
}
|
||
|
||
/**
|
||
* @brief Показывает наличие ошибки на шине
|
||
* @retval Status Одно из значений @ref OperationStatus:
|
||
* - OK - ошибок не было;
|
||
* - ERROR - произошла ошибка.
|
||
*/
|
||
__STATIC_INLINE OperationStatus DMA_ErrorStatus(void)
|
||
{
|
||
return (OperationStatus)READ_BIT(DMA->ERRCLR, DMA_ERRCLR_VAL_Msk);
|
||
}
|
||
|
||
/**
|
||
* @brief Сброс флага ошибки на шине
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void DMA_ClearErrorStatus(void)
|
||
{
|
||
WRITE_REG(DMA->ERRCLR, DMA_ERRCLR_VAL_Msk);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif /* __PLIB035_DMA_H */
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|