2015-06-10 12:06:48 +00:00
|
|
|
/*
|
2017-06-30 07:22:17 +00:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2015-06-10 12:06:48 +00:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2015 Damien P. George
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
|
2015-10-31 17:44:20 +00:00
|
|
|
#include "py/obj.h"
|
2019-02-03 12:00:44 +00:00
|
|
|
#include "systick.h"
|
2017-07-03 07:37:22 +00:00
|
|
|
#include "dma.h"
|
2015-10-31 17:44:20 +00:00
|
|
|
#include "irq.h"
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2019-02-03 12:00:44 +00:00
|
|
|
#define DMA_IDLE_ENABLED() (dma_idle.enabled != 0)
|
|
|
|
#define DMA_SYSTICK_LOG2 (3)
|
|
|
|
#define DMA_SYSTICK_MASK ((1 << DMA_SYSTICK_LOG2) - 1)
|
|
|
|
#define DMA_IDLE_TICK_MAX (8) // 8*8 = 64 msec
|
|
|
|
#define DMA_IDLE_TICK(tick) (((tick) & ~(SYSTICK_DISPATCH_NUM_SLOTS - 1) & DMA_SYSTICK_MASK) == 0)
|
|
|
|
|
2019-04-01 04:55:04 +00:00
|
|
|
#define ENABLE_SDIO (MICROPY_HW_ENABLE_SDCARD || MICROPY_HW_ENABLE_MMCARD)
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
typedef enum {
|
|
|
|
dma_id_not_defined=-1,
|
|
|
|
dma_id_0,
|
|
|
|
dma_id_1,
|
|
|
|
dma_id_2,
|
|
|
|
dma_id_3,
|
|
|
|
dma_id_4,
|
|
|
|
dma_id_5,
|
|
|
|
dma_id_6,
|
|
|
|
dma_id_7,
|
|
|
|
dma_id_8,
|
|
|
|
dma_id_9,
|
|
|
|
dma_id_10,
|
|
|
|
dma_id_11,
|
|
|
|
dma_id_12,
|
|
|
|
dma_id_13,
|
|
|
|
dma_id_14,
|
|
|
|
dma_id_15,
|
|
|
|
} dma_id_t;
|
|
|
|
|
2019-02-03 12:00:44 +00:00
|
|
|
typedef union {
|
|
|
|
uint16_t enabled; // Used to test if both counters are == 0
|
|
|
|
uint8_t counter[2];
|
|
|
|
} dma_idle_count_t;
|
|
|
|
|
2018-05-04 05:35:43 +00:00
|
|
|
struct _dma_descr_t {
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
|
2016-03-22 10:28:35 +00:00
|
|
|
DMA_Stream_TypeDef *instance;
|
2018-05-28 08:10:53 +00:00
|
|
|
#elif defined(STM32F0) || defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
DMA_Channel_TypeDef *instance;
|
|
|
|
#else
|
|
|
|
#error "Unsupported Processor"
|
|
|
|
#endif
|
|
|
|
uint32_t sub_instance;
|
|
|
|
dma_id_t id;
|
|
|
|
const DMA_InitTypeDef *init;
|
2018-05-04 05:35:43 +00:00
|
|
|
};
|
2016-03-22 10:28:35 +00:00
|
|
|
|
|
|
|
// Default parameters to dma_init() shared by spi and i2c; Channel and Direction
|
|
|
|
// vary depending on the peripheral instance so they get passed separately
|
|
|
|
static const DMA_InitTypeDef dma_init_struct_spi_i2c = {
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Channel = 0,
|
2018-03-16 23:42:50 +00:00
|
|
|
#elif defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Request = 0,
|
|
|
|
#endif
|
|
|
|
.Direction = 0,
|
|
|
|
.PeriphInc = DMA_PINC_DISABLE,
|
|
|
|
.MemInc = DMA_MINC_ENABLE,
|
|
|
|
.PeriphDataAlignment = DMA_PDATAALIGN_BYTE,
|
|
|
|
.MemDataAlignment = DMA_MDATAALIGN_BYTE,
|
|
|
|
.Mode = DMA_NORMAL,
|
|
|
|
.Priority = DMA_PRIORITY_LOW,
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.FIFOMode = DMA_FIFOMODE_DISABLE,
|
|
|
|
.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL,
|
|
|
|
.MemBurst = DMA_MBURST_INC4,
|
|
|
|
.PeriphBurst = DMA_PBURST_INC4
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2019-04-01 04:55:04 +00:00
|
|
|
#if ENABLE_SDIO && !defined(STM32H7)
|
2016-03-22 10:28:35 +00:00
|
|
|
// Parameters to dma_init() for SDIO tx and rx.
|
|
|
|
static const DMA_InitTypeDef dma_init_struct_sdio = {
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Channel = 0,
|
2018-03-16 23:42:50 +00:00
|
|
|
#elif defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Request = 0,
|
|
|
|
#endif
|
|
|
|
.Direction = 0,
|
|
|
|
.PeriphInc = DMA_PINC_DISABLE,
|
|
|
|
.MemInc = DMA_MINC_ENABLE,
|
|
|
|
.PeriphDataAlignment = DMA_PDATAALIGN_WORD,
|
|
|
|
.MemDataAlignment = DMA_MDATAALIGN_WORD,
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Mode = DMA_PFCTRL,
|
2018-03-16 23:42:50 +00:00
|
|
|
#elif defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Mode = DMA_NORMAL,
|
|
|
|
#endif
|
|
|
|
.Priority = DMA_PRIORITY_VERY_HIGH,
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.FIFOMode = DMA_FIFOMODE_ENABLE,
|
|
|
|
.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL,
|
|
|
|
.MemBurst = DMA_MBURST_INC4,
|
|
|
|
.PeriphBurst = DMA_PBURST_INC4,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(MICROPY_HW_ENABLE_DAC) && MICROPY_HW_ENABLE_DAC
|
|
|
|
// Default parameters to dma_init() for DAC tx
|
|
|
|
static const DMA_InitTypeDef dma_init_struct_dac = {
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Channel = 0,
|
2018-03-16 23:42:50 +00:00
|
|
|
#elif defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
.Request = 0,
|
|
|
|
#endif
|
|
|
|
.Direction = 0,
|
|
|
|
.PeriphInc = DMA_PINC_DISABLE,
|
|
|
|
.MemInc = DMA_MINC_ENABLE,
|
|
|
|
.PeriphDataAlignment = DMA_PDATAALIGN_BYTE,
|
|
|
|
.MemDataAlignment = DMA_MDATAALIGN_BYTE,
|
|
|
|
.Mode = DMA_NORMAL,
|
|
|
|
.Priority = DMA_PRIORITY_HIGH,
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
.FIFOMode = DMA_FIFOMODE_DISABLE,
|
|
|
|
.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL,
|
|
|
|
.MemBurst = DMA_MBURST_SINGLE,
|
|
|
|
.PeriphBurst = DMA_PBURST_SINGLE,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2018-09-17 03:47:54 +00:00
|
|
|
#if MICROPY_HW_ENABLE_DCMI
|
|
|
|
static const DMA_InitTypeDef dma_init_struct_dcmi = {
|
|
|
|
#if defined(STM32H7)
|
|
|
|
.Request = DMA_REQUEST_DCMI,
|
|
|
|
#else
|
|
|
|
.Channel = DMA_CHANNEL_1,
|
|
|
|
#endif
|
|
|
|
.Direction = DMA_PERIPH_TO_MEMORY,
|
|
|
|
.PeriphInc = DMA_PINC_DISABLE,
|
|
|
|
.MemInc = DMA_MINC_ENABLE,
|
|
|
|
.PeriphDataAlignment = DMA_PDATAALIGN_WORD,
|
|
|
|
.MemDataAlignment = DMA_MDATAALIGN_WORD,
|
|
|
|
.Mode = DMA_NORMAL,
|
|
|
|
.Priority = DMA_PRIORITY_HIGH,
|
|
|
|
.FIFOMode = DMA_FIFOMODE_ENABLE,
|
|
|
|
.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL,
|
|
|
|
.MemBurst = DMA_MBURST_INC4,
|
|
|
|
.PeriphBurst = DMA_PBURST_SINGLE
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2018-05-28 08:10:53 +00:00
|
|
|
#if defined(STM32F0)
|
|
|
|
|
|
|
|
#define NCONTROLLERS (2)
|
|
|
|
#define NSTREAMS_PER_CONTROLLER (7)
|
|
|
|
#define NSTREAM (NCONTROLLERS * NSTREAMS_PER_CONTROLLER)
|
|
|
|
|
2018-09-16 13:16:10 +00:00
|
|
|
#define DMA_SUB_INSTANCE_AS_UINT8(dma_channel) ((dma_channel) >> ((dma_channel >> 28) * 4))
|
2018-05-28 08:10:53 +00:00
|
|
|
|
2018-08-07 00:17:08 +00:00
|
|
|
#define DMA1_ENABLE_MASK (0x007f) // Bits in dma_enable_mask corresponding to DMA1 (7 channels)
|
2018-05-28 08:10:53 +00:00
|
|
|
#define DMA2_ENABLE_MASK (0x0f80) // Bits in dma_enable_mask corresponding to DMA2 (only 5 channels)
|
|
|
|
|
|
|
|
// DMA1 streams
|
|
|
|
#if MICROPY_HW_ENABLE_DAC
|
2018-09-16 13:16:10 +00:00
|
|
|
const dma_descr_t dma_DAC_1_TX = { DMA1_Channel3, HAL_DMA1_CH3_DAC_CH1, dma_id_2, &dma_init_struct_dac };
|
|
|
|
const dma_descr_t dma_DAC_2_TX = { DMA1_Channel4, HAL_DMA1_CH4_DAC_CH2, dma_id_3, &dma_init_struct_dac };
|
2018-05-28 08:10:53 +00:00
|
|
|
#endif
|
2018-09-16 13:16:10 +00:00
|
|
|
const dma_descr_t dma_SPI_2_TX = { DMA1_Channel5, HAL_DMA1_CH5_SPI2_TX, dma_id_4, &dma_init_struct_spi_i2c};
|
|
|
|
const dma_descr_t dma_SPI_2_RX = { DMA1_Channel6, HAL_DMA1_CH6_SPI2_RX, dma_id_5, &dma_init_struct_spi_i2c};
|
|
|
|
const dma_descr_t dma_SPI_1_RX = { DMA2_Channel3, HAL_DMA2_CH3_SPI1_RX, dma_id_9, &dma_init_struct_spi_i2c};
|
|
|
|
const dma_descr_t dma_SPI_1_TX = { DMA2_Channel4, HAL_DMA2_CH4_SPI1_TX, dma_id_10, &dma_init_struct_spi_i2c};
|
2018-05-28 08:10:53 +00:00
|
|
|
|
|
|
|
static const uint8_t dma_irqn[NSTREAM] = {
|
|
|
|
DMA1_Ch1_IRQn,
|
|
|
|
DMA1_Ch2_3_DMA2_Ch1_2_IRQn,
|
|
|
|
DMA1_Ch2_3_DMA2_Ch1_2_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
|
|
|
|
DMA1_Ch2_3_DMA2_Ch1_2_IRQn,
|
|
|
|
DMA1_Ch2_3_DMA2_Ch1_2_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
DMA1_Ch4_7_DMA2_Ch3_5_IRQn,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
};
|
|
|
|
|
|
|
|
#elif defined(STM32F4) || defined(STM32F7)
|
2016-03-22 10:28:35 +00:00
|
|
|
|
2015-11-16 01:02:43 +00:00
|
|
|
#define NCONTROLLERS (2)
|
2016-03-22 10:28:35 +00:00
|
|
|
#define NSTREAMS_PER_CONTROLLER (8)
|
2015-11-16 01:02:43 +00:00
|
|
|
#define NSTREAM (NCONTROLLERS * NSTREAMS_PER_CONTROLLER)
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
#define DMA_SUB_INSTANCE_AS_UINT8(dma_channel) (((dma_channel) & DMA_SxCR_CHSEL) >> 25)
|
|
|
|
|
|
|
|
#define DMA1_ENABLE_MASK (0x00ff) // Bits in dma_enable_mask corresponding to DMA1
|
|
|
|
#define DMA2_ENABLE_MASK (0xff00) // Bits in dma_enable_mask corresponding to DMA2
|
|
|
|
|
|
|
|
// These descriptors are ordered by DMAx_Stream number, and within a stream by channel
|
|
|
|
// number. The duplicate streams are ok as long as they aren't used at the same time.
|
|
|
|
//
|
|
|
|
// Currently I2C and SPI are synchronous and they call dma_init/dma_deinit
|
|
|
|
// around each transfer.
|
|
|
|
|
|
|
|
// DMA1 streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_I2C_1_RX = { DMA1_Stream0, DMA_CHANNEL_1, dma_id_0, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_3_RX = { DMA1_Stream2, DMA_CHANNEL_0, dma_id_2, &dma_init_struct_spi_i2c };
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F7)
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_I2C_4_RX = { DMA1_Stream2, DMA_CHANNEL_2, dma_id_2, &dma_init_struct_spi_i2c };
|
2016-11-25 00:21:18 +00:00
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_I2C_3_RX = { DMA1_Stream2, DMA_CHANNEL_3, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_2_RX = { DMA1_Stream2, DMA_CHANNEL_7, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_2_RX = { DMA1_Stream3, DMA_CHANNEL_0, dma_id_3, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_2_TX = { DMA1_Stream4, DMA_CHANNEL_0, dma_id_4, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_3_TX = { DMA1_Stream4, DMA_CHANNEL_3, dma_id_4, &dma_init_struct_spi_i2c };
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32F7)
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_I2C_4_TX = { DMA1_Stream5, DMA_CHANNEL_2, dma_id_5, &dma_init_struct_spi_i2c };
|
2016-11-25 00:21:18 +00:00
|
|
|
#endif
|
2016-05-05 17:15:20 +00:00
|
|
|
#if defined(MICROPY_HW_ENABLE_DAC) && MICROPY_HW_ENABLE_DAC
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_DAC_1_TX = { DMA1_Stream5, DMA_CHANNEL_7, dma_id_5, &dma_init_struct_dac };
|
|
|
|
const dma_descr_t dma_DAC_2_TX = { DMA1_Stream6, DMA_CHANNEL_7, dma_id_6, &dma_init_struct_dac };
|
2016-05-05 17:15:20 +00:00
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_3_TX = { DMA1_Stream7, DMA_CHANNEL_0, dma_id_7, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_1_TX = { DMA1_Stream7, DMA_CHANNEL_1, dma_id_7, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_2_TX = { DMA1_Stream7, DMA_CHANNEL_7, dma_id_7, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
/* not preferred streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_3_RX = { DMA1_Stream0, DMA_CHANNEL_0, dma_id_0, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_1_TX = { DMA1_Stream6, DMA_CHANNEL_1, dma_id_6, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
// DMA2 streams
|
2019-04-01 04:55:04 +00:00
|
|
|
#if defined(STM32F7) && defined(SDMMC2) && ENABLE_SDIO
|
2018-09-11 07:20:34 +00:00
|
|
|
const dma_descr_t dma_SDMMC_2 = { DMA2_Stream0, DMA_CHANNEL_11, dma_id_8, &dma_init_struct_sdio };
|
2017-03-30 06:55:21 +00:00
|
|
|
#endif
|
2018-09-17 03:47:54 +00:00
|
|
|
#if MICROPY_HW_ENABLE_DCMI
|
|
|
|
const dma_descr_t dma_DCMI_0 = { DMA2_Stream1, DMA_CHANNEL_1, dma_id_9, &dma_init_struct_dcmi };
|
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_1_RX = { DMA2_Stream2, DMA_CHANNEL_3, dma_id_10, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_5_RX = { DMA2_Stream3, DMA_CHANNEL_2, dma_id_11, &dma_init_struct_spi_i2c };
|
2019-04-01 04:55:04 +00:00
|
|
|
#if ENABLE_SDIO
|
2018-09-11 07:20:34 +00:00
|
|
|
const dma_descr_t dma_SDIO_0 = { DMA2_Stream3, DMA_CHANNEL_4, dma_id_11, &dma_init_struct_sdio };
|
2016-03-22 10:28:35 +00:00
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_4_RX = { DMA2_Stream3, DMA_CHANNEL_5, dma_id_11, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_5_TX = { DMA2_Stream4, DMA_CHANNEL_2, dma_id_12, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_4_TX = { DMA2_Stream4, DMA_CHANNEL_5, dma_id_12, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_6_TX = { DMA2_Stream5, DMA_CHANNEL_1, dma_id_13, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_1_TX = { DMA2_Stream5, DMA_CHANNEL_3, dma_id_13, &dma_init_struct_spi_i2c };
|
2019-04-01 04:55:04 +00:00
|
|
|
//#if defined(STM32F7) && defined(SDMMC2) && ENABLE_SDIO
|
2018-09-11 07:20:34 +00:00
|
|
|
//const dma_descr_t dma_SDMMC_2 = { DMA2_Stream5, DMA_CHANNEL_11, dma_id_13, &dma_init_struct_sdio };
|
|
|
|
//#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_6_RX = { DMA2_Stream6, DMA_CHANNEL_1, dma_id_14, &dma_init_struct_spi_i2c };
|
2019-04-01 04:55:04 +00:00
|
|
|
//#if ENABLE_SDIO
|
2018-09-11 07:20:34 +00:00
|
|
|
//const dma_descr_t dma_SDIO_0 = { DMA2_Stream6, DMA_CHANNEL_4, dma_id_14, &dma_init_struct_sdio };
|
|
|
|
//#endif
|
2016-03-22 10:28:35 +00:00
|
|
|
/* not preferred streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_1_TX = { DMA2_Stream3, DMA_CHANNEL_3, dma_id_11, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_1_RX = { DMA2_Stream0, DMA_CHANNEL_3, dma_id_8, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_4_RX = { DMA2_Stream0, DMA_CHANNEL_4, dma_id_8, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_4_TX = { DMA2_Stream1, DMA_CHANNEL_4, dma_id_9, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_5_RX = { DMA2_Stream5, DMA_CHANNEL_7, dma_id_13, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_5_TX = { DMA2_Stream6, DMA_CHANNEL_7, dma_id_14, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
*/
|
|
|
|
|
2015-06-10 12:06:48 +00:00
|
|
|
static const uint8_t dma_irqn[NSTREAM] = {
|
|
|
|
DMA1_Stream0_IRQn,
|
|
|
|
DMA1_Stream1_IRQn,
|
|
|
|
DMA1_Stream2_IRQn,
|
|
|
|
DMA1_Stream3_IRQn,
|
|
|
|
DMA1_Stream4_IRQn,
|
|
|
|
DMA1_Stream5_IRQn,
|
|
|
|
DMA1_Stream6_IRQn,
|
|
|
|
DMA1_Stream7_IRQn,
|
|
|
|
DMA2_Stream0_IRQn,
|
|
|
|
DMA2_Stream1_IRQn,
|
|
|
|
DMA2_Stream2_IRQn,
|
|
|
|
DMA2_Stream3_IRQn,
|
|
|
|
DMA2_Stream4_IRQn,
|
|
|
|
DMA2_Stream5_IRQn,
|
|
|
|
DMA2_Stream6_IRQn,
|
|
|
|
DMA2_Stream7_IRQn,
|
|
|
|
};
|
|
|
|
|
2018-03-16 23:42:50 +00:00
|
|
|
#elif defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
|
|
|
|
#define NCONTROLLERS (2)
|
|
|
|
#define NSTREAMS_PER_CONTROLLER (7)
|
|
|
|
#define NSTREAM (NCONTROLLERS * NSTREAMS_PER_CONTROLLER)
|
|
|
|
|
|
|
|
#define DMA_SUB_INSTANCE_AS_UINT8(dma_request) (dma_request)
|
|
|
|
|
2018-08-07 00:17:08 +00:00
|
|
|
#define DMA1_ENABLE_MASK (0x007f) // Bits in dma_enable_mask corresponding to DMA1
|
2016-03-22 10:28:35 +00:00
|
|
|
#define DMA2_ENABLE_MASK (0x3f80) // Bits in dma_enable_mask corresponding to DMA2
|
|
|
|
|
|
|
|
// These descriptors are ordered by DMAx_Channel number, and within a channel by request
|
|
|
|
// number. The duplicate streams are ok as long as they aren't used at the same time.
|
|
|
|
|
|
|
|
// DMA1 streams
|
2018-09-11 07:18:06 +00:00
|
|
|
//const dma_descr_t dma_ADC_1_RX = { DMA1_Channel1, DMA_REQUEST_0, dma_id_0, NULL }; // unused
|
|
|
|
//const dma_descr_t dma_ADC_2_RX = { DMA1_Channel2, DMA_REQUEST_0, dma_id_1, NULL }; // unused
|
|
|
|
const dma_descr_t dma_SPI_1_RX = { DMA1_Channel2, DMA_REQUEST_1, dma_id_1, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_3_TX = { DMA1_Channel2, DMA_REQUEST_3, dma_id_1, &dma_init_struct_spi_i2c };
|
|
|
|
//const dma_descr_t dma_ADC_3_RX = { DMA1_Channel3, DMA_REQUEST_0, dma_id_2, NULL }; // unused
|
|
|
|
const dma_descr_t dma_SPI_1_TX = { DMA1_Channel3, DMA_REQUEST_1, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_3_RX = { DMA1_Channel3, DMA_REQUEST_3, dma_id_2, &dma_init_struct_spi_i2c };
|
2016-05-05 14:34:01 +00:00
|
|
|
#if MICROPY_HW_ENABLE_DAC
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_DAC_1_TX = { DMA1_Channel3, DMA_REQUEST_6, dma_id_2, &dma_init_struct_dac };
|
2016-05-05 14:34:01 +00:00
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_2_RX = { DMA1_Channel4, DMA_REQUEST_1, dma_id_3, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_2_TX = { DMA1_Channel4, DMA_REQUEST_3, dma_id_3, &dma_init_struct_spi_i2c };
|
2016-05-05 14:34:01 +00:00
|
|
|
#if MICROPY_HW_ENABLE_DAC
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_DAC_2_TX = { DMA1_Channel4, DMA_REQUEST_5, dma_id_3, &dma_init_struct_dac };
|
2016-05-05 14:34:01 +00:00
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_2_TX = { DMA1_Channel5, DMA_REQUEST_1, dma_id_4, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_2_RX = { DMA1_Channel5, DMA_REQUEST_3, dma_id_4, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_1_TX = { DMA1_Channel6, DMA_REQUEST_3, dma_id_5, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_1_RX = { DMA1_Channel7, DMA_REQUEST_3, dma_id_6, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
|
|
|
|
// DMA2 streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_3_RX = { DMA2_Channel1, DMA_REQUEST_3, dma_id_7, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_3_TX = { DMA2_Channel2, DMA_REQUEST_3, dma_id_8, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
/* not preferred streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_ADC_1_RX = { DMA2_Channel3, DMA_REQUEST_0, dma_id_9, NULL };
|
|
|
|
const dma_descr_t dma_SPI_1_RX = { DMA2_Channel3, DMA_REQUEST_4, dma_id_9, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_ADC_2_RX = { DMA2_Channel4, DMA_REQUEST_0, dma_id_10, NULL };
|
|
|
|
const dma_descr_t dma_DAC_1_TX = { DMA2_Channel4, DMA_REQUEST_3, dma_id_10, &dma_init_struct_dac };
|
|
|
|
const dma_descr_t dma_SPI_1_TX = { DMA2_Channel4, DMA_REQUEST_4, dma_id_10, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
*/
|
2019-04-01 04:55:04 +00:00
|
|
|
#if ENABLE_SDIO
|
2018-09-11 07:20:34 +00:00
|
|
|
const dma_descr_t dma_SDIO_0 = { DMA2_Channel4, DMA_REQUEST_7, dma_id_10, &dma_init_struct_sdio };
|
2016-03-22 10:28:35 +00:00
|
|
|
#endif
|
|
|
|
/* not preferred streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_ADC_3_RX = { DMA2_Channel5, DMA_REQUEST_0, dma_id_11, NULL };
|
|
|
|
const dma_descr_t dma_DAC_2_TX = { DMA2_Channel5, DMA_REQUEST_3, dma_id_11, &dma_init_struct_dac };
|
|
|
|
const dma_descr_t dma_SDIO_0_TX= { DMA2_Channel5, DMA_REQUEST_7, dma_id_11, &dma_init_struct_sdio };
|
|
|
|
const dma_descr_t dma_I2C_1_RX = { DMA2_Channel6, DMA_REQUEST_5, dma_id_12, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_1_TX = { DMA2_Channel7, DMA_REQUEST_5, dma_id_13, &dma_init_struct_spi_i2c };
|
2016-03-22 10:28:35 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static const uint8_t dma_irqn[NSTREAM] = {
|
|
|
|
DMA1_Channel1_IRQn,
|
|
|
|
DMA1_Channel2_IRQn,
|
|
|
|
DMA1_Channel3_IRQn,
|
|
|
|
DMA1_Channel4_IRQn,
|
|
|
|
DMA1_Channel5_IRQn,
|
|
|
|
DMA1_Channel6_IRQn,
|
|
|
|
DMA1_Channel7_IRQn,
|
|
|
|
DMA2_Channel1_IRQn,
|
|
|
|
DMA2_Channel2_IRQn,
|
|
|
|
DMA2_Channel3_IRQn,
|
|
|
|
DMA2_Channel4_IRQn,
|
|
|
|
DMA2_Channel5_IRQn,
|
|
|
|
DMA2_Channel6_IRQn,
|
|
|
|
DMA2_Channel7_IRQn,
|
2015-06-22 13:24:59 +00:00
|
|
|
};
|
|
|
|
|
2018-02-23 18:18:52 +00:00
|
|
|
#elif defined(STM32H7)
|
|
|
|
|
|
|
|
#define NCONTROLLERS (2)
|
|
|
|
#define NSTREAMS_PER_CONTROLLER (8)
|
|
|
|
#define NSTREAM (NCONTROLLERS * NSTREAMS_PER_CONTROLLER)
|
|
|
|
|
|
|
|
#define DMA_SUB_INSTANCE_AS_UINT8(dma_channel) (dma_channel)
|
|
|
|
|
|
|
|
#define DMA1_ENABLE_MASK (0x00ff) // Bits in dma_enable_mask corresponding to DMA1
|
|
|
|
#define DMA2_ENABLE_MASK (0xff00) // Bits in dma_enable_mask corresponding to DMA2
|
|
|
|
|
|
|
|
// These descriptors are ordered by DMAx_Stream number, and within a stream by channel
|
|
|
|
// number. The duplicate streams are ok as long as they aren't used at the same time.
|
|
|
|
//
|
|
|
|
// Currently I2C and SPI are synchronous and they call dma_init/dma_deinit
|
|
|
|
// around each transfer.
|
|
|
|
|
|
|
|
// DMA1 streams
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_I2C_1_RX = { DMA1_Stream0, DMA_REQUEST_I2C1_RX, dma_id_0, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_3_RX = { DMA1_Stream2, DMA_REQUEST_SPI3_RX, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_4_RX = { DMA1_Stream2, BDMA_REQUEST_I2C4_RX, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_3_RX = { DMA1_Stream2, DMA_REQUEST_I2C3_RX, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_2_RX = { DMA1_Stream2, DMA_REQUEST_I2C2_RX, dma_id_2, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_2_RX = { DMA1_Stream3, DMA_REQUEST_SPI2_RX, dma_id_3, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_2_TX = { DMA1_Stream4, DMA_REQUEST_SPI2_TX, dma_id_4, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_3_TX = { DMA1_Stream4, DMA_REQUEST_I2C3_TX, dma_id_4, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_4_TX = { DMA1_Stream5, BDMA_REQUEST_I2C4_TX, dma_id_5, &dma_init_struct_spi_i2c };
|
2018-02-23 18:18:52 +00:00
|
|
|
#if defined(MICROPY_HW_ENABLE_DAC) && MICROPY_HW_ENABLE_DAC
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_DAC_1_TX = { DMA1_Stream5, DMA_REQUEST_DAC1_CH1, dma_id_5, &dma_init_struct_dac };
|
|
|
|
const dma_descr_t dma_DAC_2_TX = { DMA1_Stream6, DMA_REQUEST_DAC1_CH2, dma_id_6, &dma_init_struct_dac };
|
2018-02-23 18:18:52 +00:00
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_3_TX = { DMA1_Stream7, DMA_REQUEST_SPI3_TX, dma_id_7, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_1_TX = { DMA1_Stream7, DMA_REQUEST_I2C1_TX, dma_id_7, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_I2C_2_TX = { DMA1_Stream7, DMA_REQUEST_I2C2_TX, dma_id_7, &dma_init_struct_spi_i2c };
|
2018-02-23 18:18:52 +00:00
|
|
|
|
|
|
|
// DMA2 streams
|
2018-09-17 03:47:54 +00:00
|
|
|
#if MICROPY_HW_ENABLE_DCMI
|
|
|
|
const dma_descr_t dma_DCMI_0 = { DMA2_Stream1, DMA_REQUEST_DCMI, dma_id_9, &dma_init_struct_dcmi };
|
|
|
|
#endif
|
2018-09-11 07:18:06 +00:00
|
|
|
const dma_descr_t dma_SPI_1_RX = { DMA2_Stream2, DMA_REQUEST_SPI1_RX, dma_id_10, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_5_RX = { DMA2_Stream3, DMA_REQUEST_SPI5_RX, dma_id_11, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_4_RX = { DMA2_Stream3, DMA_REQUEST_SPI4_RX, dma_id_11, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_5_TX = { DMA2_Stream4, DMA_REQUEST_SPI5_TX, dma_id_12, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_4_TX = { DMA2_Stream4, DMA_REQUEST_SPI4_TX, dma_id_12, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_6_TX = { DMA2_Stream5, BDMA_REQUEST_SPI6_TX, dma_id_13, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_1_TX = { DMA2_Stream5, DMA_REQUEST_SPI1_TX, dma_id_13, &dma_init_struct_spi_i2c };
|
|
|
|
const dma_descr_t dma_SPI_6_RX = { DMA2_Stream6, BDMA_REQUEST_SPI6_RX, dma_id_14, &dma_init_struct_spi_i2c };
|
2018-02-23 18:18:52 +00:00
|
|
|
|
|
|
|
static const uint8_t dma_irqn[NSTREAM] = {
|
|
|
|
DMA1_Stream0_IRQn,
|
|
|
|
DMA1_Stream1_IRQn,
|
|
|
|
DMA1_Stream2_IRQn,
|
|
|
|
DMA1_Stream3_IRQn,
|
|
|
|
DMA1_Stream4_IRQn,
|
|
|
|
DMA1_Stream5_IRQn,
|
|
|
|
DMA1_Stream6_IRQn,
|
|
|
|
DMA1_Stream7_IRQn,
|
|
|
|
DMA2_Stream0_IRQn,
|
|
|
|
DMA2_Stream1_IRQn,
|
|
|
|
DMA2_Stream2_IRQn,
|
|
|
|
DMA2_Stream3_IRQn,
|
|
|
|
DMA2_Stream4_IRQn,
|
|
|
|
DMA2_Stream5_IRQn,
|
|
|
|
DMA2_Stream6_IRQn,
|
|
|
|
DMA2_Stream7_IRQn,
|
|
|
|
};
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
#endif
|
|
|
|
|
2015-06-10 12:06:48 +00:00
|
|
|
static DMA_HandleTypeDef *dma_handle[NSTREAM] = {NULL};
|
2016-03-22 10:28:35 +00:00
|
|
|
static uint8_t dma_last_sub_instance[NSTREAM];
|
2015-11-16 01:02:43 +00:00
|
|
|
static volatile uint32_t dma_enable_mask = 0;
|
|
|
|
volatile dma_idle_count_t dma_idle;
|
|
|
|
|
|
|
|
#define DMA_INVALID_CHANNEL 0xff // Value stored in dma_last_channel which means invalid
|
|
|
|
|
2018-05-28 08:10:53 +00:00
|
|
|
#if defined(STM32F0)
|
|
|
|
#define DMA1_IS_CLK_ENABLED() ((RCC->AHBENR & RCC_AHBENR_DMA1EN) != 0)
|
|
|
|
#define DMA2_IS_CLK_ENABLED() ((RCC->AHBENR & RCC_AHBENR_DMA2EN) != 0)
|
|
|
|
#else
|
2015-11-16 01:02:43 +00:00
|
|
|
#define DMA1_IS_CLK_ENABLED() ((RCC->AHB1ENR & RCC_AHB1ENR_DMA1EN) != 0)
|
|
|
|
#define DMA2_IS_CLK_ENABLED() ((RCC->AHB1ENR & RCC_AHB1ENR_DMA2EN) != 0)
|
2018-05-28 08:10:53 +00:00
|
|
|
#endif
|
2015-11-16 01:02:43 +00:00
|
|
|
|
2018-09-16 13:16:10 +00:00
|
|
|
#if defined(STM32F0)
|
|
|
|
|
|
|
|
void DMA1_Ch1_IRQHandler(void) {
|
|
|
|
IRQ_ENTER(DMA1_Ch1_IRQn);
|
|
|
|
if (dma_handle[dma_id_0] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler(void) {
|
|
|
|
IRQ_ENTER(DMA1_Ch2_3_DMA2_Ch1_2_IRQn);
|
|
|
|
if (dma_handle[dma_id_1] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_1]);
|
|
|
|
}
|
|
|
|
if (dma_handle[dma_id_2] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_2]);
|
|
|
|
}
|
|
|
|
if (dma_handle[dma_id_7] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_7]);
|
|
|
|
}
|
|
|
|
if (dma_handle[dma_id_8] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_8]);
|
|
|
|
}
|
|
|
|
IRQ_EXIT(DMA1_Ch2_3_DMA2_Ch1_2_IRQn);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DMA1_Ch4_7_DMA2_Ch3_5_IRQHandler(void) {
|
|
|
|
IRQ_ENTER(DMA1_Ch4_7_DMA2_Ch3_5_IRQn);
|
|
|
|
for (unsigned int i = 0; i < 4; ++i) {
|
|
|
|
if (dma_handle[dma_id_3 + i] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_3 + i]);
|
|
|
|
}
|
|
|
|
// When i==3 this will check an invalid handle, but it will always be NULL
|
|
|
|
if (dma_handle[dma_id_9 + i] != NULL) {
|
|
|
|
HAL_DMA_IRQHandler(dma_handle[dma_id_9 + i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IRQ_EXIT(DMA1_Ch4_7_DMA2_Ch3_5_IRQn);
|
|
|
|
}
|
|
|
|
|
|
|
|
#elif defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
|
2016-03-22 10:28:35 +00:00
|
|
|
|
|
|
|
void DMA1_Stream0_IRQHandler(void) { IRQ_ENTER(DMA1_Stream0_IRQn); if (dma_handle[dma_id_0] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_0]); } IRQ_EXIT(DMA1_Stream0_IRQn); }
|
|
|
|
void DMA1_Stream1_IRQHandler(void) { IRQ_ENTER(DMA1_Stream1_IRQn); if (dma_handle[dma_id_1] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_1]); } IRQ_EXIT(DMA1_Stream1_IRQn); }
|
|
|
|
void DMA1_Stream2_IRQHandler(void) { IRQ_ENTER(DMA1_Stream2_IRQn); if (dma_handle[dma_id_2] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_2]); } IRQ_EXIT(DMA1_Stream2_IRQn); }
|
|
|
|
void DMA1_Stream3_IRQHandler(void) { IRQ_ENTER(DMA1_Stream3_IRQn); if (dma_handle[dma_id_3] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_3]); } IRQ_EXIT(DMA1_Stream3_IRQn); }
|
|
|
|
void DMA1_Stream4_IRQHandler(void) { IRQ_ENTER(DMA1_Stream4_IRQn); if (dma_handle[dma_id_4] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_4]); } IRQ_EXIT(DMA1_Stream4_IRQn); }
|
|
|
|
void DMA1_Stream5_IRQHandler(void) { IRQ_ENTER(DMA1_Stream5_IRQn); if (dma_handle[dma_id_5] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_5]); } IRQ_EXIT(DMA1_Stream5_IRQn); }
|
|
|
|
void DMA1_Stream6_IRQHandler(void) { IRQ_ENTER(DMA1_Stream6_IRQn); if (dma_handle[dma_id_6] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_6]); } IRQ_EXIT(DMA1_Stream6_IRQn); }
|
|
|
|
void DMA1_Stream7_IRQHandler(void) { IRQ_ENTER(DMA1_Stream7_IRQn); if (dma_handle[dma_id_7] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_7]); } IRQ_EXIT(DMA1_Stream7_IRQn); }
|
|
|
|
void DMA2_Stream0_IRQHandler(void) { IRQ_ENTER(DMA2_Stream0_IRQn); if (dma_handle[dma_id_8] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_8]); } IRQ_EXIT(DMA2_Stream0_IRQn); }
|
|
|
|
void DMA2_Stream1_IRQHandler(void) { IRQ_ENTER(DMA2_Stream1_IRQn); if (dma_handle[dma_id_9] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_9]); } IRQ_EXIT(DMA2_Stream1_IRQn); }
|
|
|
|
void DMA2_Stream2_IRQHandler(void) { IRQ_ENTER(DMA2_Stream2_IRQn); if (dma_handle[dma_id_10] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_10]); } IRQ_EXIT(DMA2_Stream2_IRQn); }
|
|
|
|
void DMA2_Stream3_IRQHandler(void) { IRQ_ENTER(DMA2_Stream3_IRQn); if (dma_handle[dma_id_11] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_11]); } IRQ_EXIT(DMA2_Stream3_IRQn); }
|
|
|
|
void DMA2_Stream4_IRQHandler(void) { IRQ_ENTER(DMA2_Stream4_IRQn); if (dma_handle[dma_id_12] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_12]); } IRQ_EXIT(DMA2_Stream4_IRQn); }
|
|
|
|
void DMA2_Stream5_IRQHandler(void) { IRQ_ENTER(DMA2_Stream5_IRQn); if (dma_handle[dma_id_13] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_13]); } IRQ_EXIT(DMA2_Stream5_IRQn); }
|
|
|
|
void DMA2_Stream6_IRQHandler(void) { IRQ_ENTER(DMA2_Stream6_IRQn); if (dma_handle[dma_id_14] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_14]); } IRQ_EXIT(DMA2_Stream6_IRQn); }
|
|
|
|
void DMA2_Stream7_IRQHandler(void) { IRQ_ENTER(DMA2_Stream7_IRQn); if (dma_handle[dma_id_15] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_15]); } IRQ_EXIT(DMA2_Stream7_IRQn); }
|
|
|
|
|
2018-03-16 23:42:50 +00:00
|
|
|
#elif defined(STM32L4)
|
2016-03-22 10:28:35 +00:00
|
|
|
|
|
|
|
void DMA1_Channel1_IRQHandler(void) { IRQ_ENTER(DMA1_Channel1_IRQn); if (dma_handle[dma_id_0] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_0]); } IRQ_EXIT(DMA1_Channel1_IRQn); }
|
|
|
|
void DMA1_Channel2_IRQHandler(void) { IRQ_ENTER(DMA1_Channel2_IRQn); if (dma_handle[dma_id_1] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_1]); } IRQ_EXIT(DMA1_Channel2_IRQn); }
|
|
|
|
void DMA1_Channel3_IRQHandler(void) { IRQ_ENTER(DMA1_Channel3_IRQn); if (dma_handle[dma_id_2] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_2]); } IRQ_EXIT(DMA1_Channel3_IRQn); }
|
|
|
|
void DMA1_Channel4_IRQHandler(void) { IRQ_ENTER(DMA1_Channel4_IRQn); if (dma_handle[dma_id_3] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_3]); } IRQ_EXIT(DMA1_Channel4_IRQn); }
|
|
|
|
void DMA1_Channel5_IRQHandler(void) { IRQ_ENTER(DMA1_Channel5_IRQn); if (dma_handle[dma_id_4] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_4]); } IRQ_EXIT(DMA1_Channel5_IRQn); }
|
|
|
|
void DMA1_Channel6_IRQHandler(void) { IRQ_ENTER(DMA1_Channel6_IRQn); if (dma_handle[dma_id_5] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_5]); } IRQ_EXIT(DMA1_Channel6_IRQn); }
|
|
|
|
void DMA1_Channel7_IRQHandler(void) { IRQ_ENTER(DMA1_Channel7_IRQn); if (dma_handle[dma_id_6] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_6]); } IRQ_EXIT(DMA1_Channel7_IRQn); }
|
|
|
|
void DMA2_Channel1_IRQHandler(void) { IRQ_ENTER(DMA2_Channel1_IRQn); if (dma_handle[dma_id_7] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_7]); } IRQ_EXIT(DMA2_Channel1_IRQn); }
|
|
|
|
void DMA2_Channel2_IRQHandler(void) { IRQ_ENTER(DMA2_Channel2_IRQn); if (dma_handle[dma_id_8] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_8]); } IRQ_EXIT(DMA2_Channel2_IRQn); }
|
|
|
|
void DMA2_Channel3_IRQHandler(void) { IRQ_ENTER(DMA2_Channel3_IRQn); if (dma_handle[dma_id_9] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_9]); } IRQ_EXIT(DMA2_Channel3_IRQn); }
|
|
|
|
void DMA2_Channel4_IRQHandler(void) { IRQ_ENTER(DMA2_Channel4_IRQn); if (dma_handle[dma_id_10] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_10]);} IRQ_EXIT(DMA2_Channel4_IRQn); }
|
|
|
|
void DMA2_Channel5_IRQHandler(void) { IRQ_ENTER(DMA2_Channel5_IRQn); if (dma_handle[dma_id_11] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_11]);} IRQ_EXIT(DMA2_Channel5_IRQn); }
|
|
|
|
void DMA2_Channel6_IRQHandler(void) { IRQ_ENTER(DMA2_Channel6_IRQn); if (dma_handle[dma_id_12] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_12]);} IRQ_EXIT(DMA2_Channel6_IRQn); }
|
|
|
|
void DMA2_Channel7_IRQHandler(void) { IRQ_ENTER(DMA2_Channel7_IRQn); if (dma_handle[dma_id_13] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_13]);} IRQ_EXIT(DMA2_Channel7_IRQn); }
|
|
|
|
|
|
|
|
#endif
|
2015-11-16 01:02:43 +00:00
|
|
|
|
2019-02-03 12:00:44 +00:00
|
|
|
static void dma_idle_handler(uint32_t tick);
|
|
|
|
|
2015-11-16 01:02:43 +00:00
|
|
|
// Resets the idle counter for the DMA controller associated with dma_id.
|
2016-03-22 10:28:35 +00:00
|
|
|
static void dma_tickle(dma_id_t dma_id) {
|
|
|
|
dma_idle.counter[(dma_id < NSTREAMS_PER_CONTROLLER) ? 0 : 1] = 1;
|
2019-02-03 12:00:44 +00:00
|
|
|
systick_enable_dispatch(SYSTICK_DISPATCH_DMA, dma_idle_handler);
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
static void dma_enable_clock(dma_id_t dma_id) {
|
2015-11-16 01:02:43 +00:00
|
|
|
// We don't want dma_tick_handler() to turn off the clock right after we
|
|
|
|
// enable it, so we need to mark the channel in use in an atomic fashion.
|
|
|
|
mp_uint_t irq_state = MICROPY_BEGIN_ATOMIC_SECTION();
|
|
|
|
uint32_t old_enable_mask = dma_enable_mask;
|
|
|
|
dma_enable_mask |= (1 << dma_id);
|
|
|
|
MICROPY_END_ATOMIC_SECTION(irq_state);
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
if (dma_id < NSTREAMS_PER_CONTROLLER) {
|
2015-11-16 01:02:43 +00:00
|
|
|
if (((old_enable_mask & DMA1_ENABLE_MASK) == 0) && !DMA1_IS_CLK_ENABLED()) {
|
2018-02-13 04:37:35 +00:00
|
|
|
__HAL_RCC_DMA1_CLK_ENABLE();
|
2015-11-16 01:02:43 +00:00
|
|
|
|
|
|
|
// We just turned on the clock. This means that anything stored
|
|
|
|
// in dma_last_channel (for DMA1) needs to be invalidated.
|
|
|
|
|
|
|
|
for (int channel = 0; channel < NSTREAMS_PER_CONTROLLER; channel++) {
|
2016-03-22 10:28:35 +00:00
|
|
|
dma_last_sub_instance[channel] = DMA_INVALID_CHANNEL;
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
|
|
|
}
|
2015-06-10 12:06:48 +00:00
|
|
|
} else {
|
2015-11-16 01:02:43 +00:00
|
|
|
if (((old_enable_mask & DMA2_ENABLE_MASK) == 0) && !DMA2_IS_CLK_ENABLED()) {
|
2018-02-13 04:37:35 +00:00
|
|
|
__HAL_RCC_DMA2_CLK_ENABLE();
|
2015-11-16 01:02:43 +00:00
|
|
|
|
|
|
|
// We just turned on the clock. This means that anything stored
|
|
|
|
// in dma_last_channel (for DMA1) needs to be invalidated.
|
|
|
|
|
|
|
|
for (int channel = NSTREAMS_PER_CONTROLLER; channel < NSTREAM; channel++) {
|
2016-03-22 10:28:35 +00:00
|
|
|
dma_last_sub_instance[channel] = DMA_INVALID_CHANNEL;
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
|
|
|
}
|
2015-06-10 12:06:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
static void dma_disable_clock(dma_id_t dma_id) {
|
2015-11-16 01:02:43 +00:00
|
|
|
// We just mark the clock as disabled here, but we don't actually disable it.
|
|
|
|
// We wait for the timer to expire first, which means that back-to-back
|
|
|
|
// transfers don't have to initialize as much.
|
|
|
|
dma_tickle(dma_id);
|
|
|
|
dma_enable_mask &= ~(1 << dma_id);
|
|
|
|
}
|
|
|
|
|
2018-09-11 07:18:06 +00:00
|
|
|
void dma_init_handle(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint32_t dir, void *data) {
|
2016-03-22 10:28:35 +00:00
|
|
|
// initialise parameters
|
|
|
|
dma->Instance = dma_descr->instance;
|
|
|
|
dma->Init = *dma_descr->init;
|
2018-09-11 07:18:06 +00:00
|
|
|
dma->Init.Direction = dir;
|
2018-03-16 23:42:50 +00:00
|
|
|
#if defined(STM32L4) || defined(STM32H7)
|
2016-03-22 10:28:35 +00:00
|
|
|
dma->Init.Request = dma_descr->sub_instance;
|
|
|
|
#else
|
2018-05-28 08:10:53 +00:00
|
|
|
#if !defined(STM32F0)
|
2016-03-22 10:28:35 +00:00
|
|
|
dma->Init.Channel = dma_descr->sub_instance;
|
|
|
|
#endif
|
2018-05-28 08:10:53 +00:00
|
|
|
#endif
|
2016-03-22 10:28:35 +00:00
|
|
|
// half of __HAL_LINKDMA(data, xxx, *dma)
|
|
|
|
// caller must implement other half by doing: data->xxx = dma
|
|
|
|
dma->Parent = data;
|
|
|
|
}
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2018-09-11 07:18:06 +00:00
|
|
|
void dma_init(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint32_t dir, void *data){
|
2015-11-16 01:02:43 +00:00
|
|
|
// Some drivers allocate the DMA_HandleTypeDef from the stack
|
|
|
|
// (i.e. dac, i2c, spi) and for those cases we need to clear the
|
|
|
|
// structure so we don't get random values from the stack)
|
2015-06-10 12:06:48 +00:00
|
|
|
memset(dma, 0, sizeof(*dma));
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
if (dma_descr != NULL) {
|
|
|
|
dma_id_t dma_id = dma_descr->id;
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2018-09-11 07:18:06 +00:00
|
|
|
dma_init_handle(dma, dma_descr, dir, data);
|
2016-03-22 10:28:35 +00:00
|
|
|
// set global pointer for IRQ handler
|
|
|
|
dma_handle[dma_id] = dma;
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
dma_enable_clock(dma_id);
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2018-04-13 13:14:44 +00:00
|
|
|
#if defined(STM32L4)
|
|
|
|
// Always reset and configure the L4 DMA peripheral
|
|
|
|
// (dma->State is set to HAL_DMA_STATE_RESET by memset above)
|
|
|
|
// TODO: understand how L4 DMA works so this is not needed
|
|
|
|
HAL_DMA_DeInit(dma);
|
|
|
|
HAL_DMA_Init(dma);
|
2018-05-02 04:41:02 +00:00
|
|
|
NVIC_SetPriority(IRQn_NONNEG(dma_irqn[dma_id]), IRQ_PRI_DMA);
|
2018-04-13 13:14:44 +00:00
|
|
|
#else
|
2018-09-11 07:19:55 +00:00
|
|
|
// if this stream was previously configured for this channel/request and direction then we
|
2016-03-22 10:28:35 +00:00
|
|
|
// can skip most of the initialisation
|
2018-09-11 07:19:55 +00:00
|
|
|
uint8_t sub_inst = DMA_SUB_INSTANCE_AS_UINT8(dma_descr->sub_instance) | (dir == DMA_PERIPH_TO_MEMORY) << 7;
|
2016-03-22 10:28:35 +00:00
|
|
|
if (dma_last_sub_instance[dma_id] != sub_inst) {
|
|
|
|
dma_last_sub_instance[dma_id] = sub_inst;
|
2015-11-16 01:02:43 +00:00
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
// reset and configure DMA peripheral
|
2016-11-11 06:24:18 +00:00
|
|
|
// (dma->State is set to HAL_DMA_STATE_RESET by memset above)
|
|
|
|
HAL_DMA_DeInit(dma);
|
2016-03-22 10:28:35 +00:00
|
|
|
HAL_DMA_Init(dma);
|
2018-05-02 04:41:02 +00:00
|
|
|
NVIC_SetPriority(IRQn_NONNEG(dma_irqn[dma_id]), IRQ_PRI_DMA);
|
2018-05-28 08:10:53 +00:00
|
|
|
#if defined(STM32F0)
|
|
|
|
if (dma->Instance < DMA2_Channel1) {
|
|
|
|
__HAL_DMA1_REMAP(dma_descr->sub_instance);
|
|
|
|
} else {
|
|
|
|
__HAL_DMA2_REMAP(dma_descr->sub_instance);
|
|
|
|
}
|
|
|
|
#endif
|
2016-09-07 16:40:34 +00:00
|
|
|
} else {
|
|
|
|
// only necessary initialization
|
2016-09-08 10:57:14 +00:00
|
|
|
dma->State = HAL_DMA_STATE_READY;
|
2018-09-16 13:16:10 +00:00
|
|
|
#if defined(STM32F0)
|
|
|
|
// These variables are used to access the relevant 4 bits in ISR and IFCR
|
|
|
|
if (dma_id < NSTREAMS_PER_CONTROLLER) {
|
|
|
|
dma->DmaBaseAddress = DMA1;
|
|
|
|
dma->ChannelIndex = dma_id * 4;
|
|
|
|
} else {
|
|
|
|
dma->DmaBaseAddress = DMA2;
|
|
|
|
dma->ChannelIndex = (dma_id - NSTREAMS_PER_CONTROLLER) * 4;
|
|
|
|
}
|
|
|
|
#elif defined(STM32F4) || defined(STM32F7)
|
2016-09-07 16:40:34 +00:00
|
|
|
// calculate DMA base address and bitshift to be used in IRQ handler
|
|
|
|
extern uint32_t DMA_CalcBaseAndBitshift(DMA_HandleTypeDef *hdma);
|
|
|
|
DMA_CalcBaseAndBitshift(dma);
|
2018-09-16 13:16:10 +00:00
|
|
|
#endif
|
2016-03-22 10:28:35 +00:00
|
|
|
}
|
2018-04-13 13:14:44 +00:00
|
|
|
#endif
|
2015-06-10 12:06:48 +00:00
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
HAL_NVIC_EnableIRQ(dma_irqn[dma_id]);
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
2015-06-10 12:06:48 +00:00
|
|
|
}
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
void dma_deinit(const dma_descr_t *dma_descr) {
|
|
|
|
if (dma_descr != NULL) {
|
2018-09-16 13:16:10 +00:00
|
|
|
#if !defined(STM32F0)
|
2016-03-22 10:28:35 +00:00
|
|
|
HAL_NVIC_DisableIRQ(dma_irqn[dma_descr->id]);
|
2018-09-16 13:16:10 +00:00
|
|
|
#endif
|
2016-03-22 10:28:35 +00:00
|
|
|
dma_handle[dma_descr->id] = NULL;
|
2015-11-16 01:02:43 +00:00
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
dma_disable_clock(dma_descr->id);
|
|
|
|
}
|
2015-06-10 12:06:48 +00:00
|
|
|
}
|
|
|
|
|
2016-03-22 10:28:35 +00:00
|
|
|
void dma_invalidate_channel(const dma_descr_t *dma_descr) {
|
|
|
|
if (dma_descr != NULL) {
|
|
|
|
dma_id_t dma_id = dma_descr->id;
|
2018-09-11 07:19:55 +00:00
|
|
|
// Only compare the sub-instance, not the direction bit (MSB)
|
|
|
|
if ((dma_last_sub_instance[dma_id] & 0x7f) == DMA_SUB_INSTANCE_AS_UINT8(dma_descr->sub_instance) ) {
|
2016-03-22 10:28:35 +00:00
|
|
|
dma_last_sub_instance[dma_id] = DMA_INVALID_CHANNEL;
|
|
|
|
}
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:40:59 +00:00
|
|
|
// Called from the SysTick handler
|
|
|
|
// We use LSB of tick to select which controller to process
|
2019-02-03 12:00:44 +00:00
|
|
|
static void dma_idle_handler(uint32_t tick) {
|
|
|
|
if (!DMA_IDLE_ENABLED() || !DMA_IDLE_TICK(tick)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-11-16 01:02:43 +00:00
|
|
|
static const uint32_t controller_mask[] = {
|
|
|
|
DMA1_ENABLE_MASK, DMA2_ENABLE_MASK
|
|
|
|
};
|
2015-11-24 15:40:59 +00:00
|
|
|
{
|
2019-02-03 12:00:44 +00:00
|
|
|
int controller = (tick >> DMA_SYSTICK_LOG2) & 1;
|
2015-11-16 01:02:43 +00:00
|
|
|
if (dma_idle.counter[controller] == 0) {
|
2015-11-24 15:40:59 +00:00
|
|
|
return;
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
|
|
|
if (++dma_idle.counter[controller] > DMA_IDLE_TICK_MAX) {
|
|
|
|
if ((dma_enable_mask & controller_mask[controller]) == 0) {
|
|
|
|
// Nothing is active and we've reached our idle timeout,
|
|
|
|
// Now we'll really disable the clock.
|
|
|
|
dma_idle.counter[controller] = 0;
|
|
|
|
if (controller == 0) {
|
2018-02-13 04:37:35 +00:00
|
|
|
__HAL_RCC_DMA1_CLK_DISABLE();
|
2015-11-16 01:02:43 +00:00
|
|
|
} else {
|
2018-02-13 04:37:35 +00:00
|
|
|
__HAL_RCC_DMA2_CLK_DISABLE();
|
2015-11-16 01:02:43 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Something is still active, but the counter never got
|
|
|
|
// reset, so we'll reset the counter here.
|
|
|
|
dma_idle.counter[controller] = 1;
|
|
|
|
}
|
|
|
|
}
|
2015-06-10 12:06:48 +00:00
|
|
|
}
|
|
|
|
}
|