rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/platform/hal/hal_spi.c
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

1705 lines
41 KiB
C
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "hal_spi.h"
#include "cmsis.h"
#include "hal_cmu.h"
#include "hal_dma.h"
#include "hal_location.h"
#include "hal_trace.h"
#include "plat_addr_map.h"
#include "reg_spi.h"
#include "string.h"
// TODO:
// 1) Add transfer timeout control
#ifdef SPI_ROM_ONLY
#define SPI_ASSERT(c, ...) ASSERT_NODUMP(c)
#else
#define SPI_ASSERT(c, ...) ASSERT(c, ##__VA_ARGS__)
#endif
enum HAL_SPI_ID_T {
HAL_SPI_ID_INTERNAL,
#ifdef CHIP_HAS_SPI
HAL_SPI_ID_0,
#endif
#ifdef CHIP_HAS_SPILCD
HAL_SPI_ID_SLCD,
#endif
#ifdef CHIP_HAS_SPIPHY
HAL_SPI_ID_PHY,
#endif
#ifdef CHIP_HAS_SPIDPD
HAL_SPI_ID_DPD,
#endif
HAL_SPI_ID_QTY
};
enum HAL_SPI_CS_T {
HAL_SPI_CS_0,
#if (CHIP_SPI_VER >= 2)
HAL_SPI_CS_1,
HAL_SPI_CS_2,
#if (CHIP_SPI_VER >= 3)
HAL_SPI_CS_3,
#if (CHIP_SPI_VER >= 4)
// HAL_SPI_CS_4,
#endif
#endif
#endif
HAL_SPI_CS_QTY
};
enum HAL_SPI_XFER_TYPE_T {
HAL_SPI_XFER_TYPE_SEND,
HAL_SPI_XFER_TYPE_RECV,
HAL_SPI_XFER_TYPE_QTY
};
struct HAL_SPI_MOD_NAME_T {
enum HAL_CMU_MOD_ID_T mod;
enum HAL_CMU_MOD_ID_T apb;
};
static struct SPI_T *const spi[HAL_SPI_ID_QTY] = {
(struct SPI_T *)ISPI_BASE,
#ifdef CHIP_HAS_SPI
(struct SPI_T *)SPI_BASE,
#endif
#ifdef CHIP_HAS_SPILCD
(struct SPI_T *)SPILCD_BASE,
#endif
#ifdef CHIP_HAS_SPIPHY
(struct SPI_T *)SPIPHY_BASE,
#endif
#ifdef CHIP_HAS_SPIDPD
(struct SPI_T *)SPIDPD_BASE,
#endif
};
static const struct HAL_SPI_MOD_NAME_T spi_mod[HAL_SPI_ID_QTY] = {
{
.mod = HAL_CMU_MOD_O_SPI_ITN,
.apb = HAL_CMU_MOD_P_SPI_ITN,
},
#ifdef CHIP_HAS_SPI
{
.mod = HAL_CMU_MOD_O_SPI,
.apb = HAL_CMU_MOD_P_SPI,
},
#endif
#ifdef CHIP_HAS_SPILCD
{
.mod = HAL_CMU_MOD_O_SLCD,
.apb = HAL_CMU_MOD_P_SLCD,
},
#endif
#ifdef CHIP_HAS_SPIPHY
{
.mod = HAL_CMU_MOD_O_SPI_PHY,
.apb = HAL_CMU_MOD_P_SPI_PHY,
},
#endif
#ifdef CHIP_HAS_SPIDPD
{
.mod = HAL_CMU_MOD_O_SPI_DPD,
.apb = HAL_CMU_MOD_P_SPI_DPD,
},
#endif
};
#ifndef SPI_ROM_ONLY
#ifdef CHIP_HAS_SPI
static struct HAL_SPI_CTRL_T spi0_ctrl[HAL_SPI_CS_QTY];
#if (CHIP_SPI_VER >= 2)
static enum HAL_SPI_CS_T spi0_cs = HAL_SPI_CS_0;
#else
static const enum HAL_SPI_CS_T spi0_cs = HAL_SPI_CS_0;
#endif
#endif
#ifdef CHIP_HAS_SPILCD
static struct HAL_SPI_CTRL_T spilcd_ctrl[HAL_SPI_CS_QTY];
#if (CHIP_SPI_VER >= 2)
static enum HAL_SPI_CS_T spilcd_cs = HAL_SPI_CS_0;
#else
static const enum HAL_SPI_CS_T spilcd_cs = HAL_SPI_CS_0;
#endif
#endif
#ifdef CHIP_HAS_SPIDPD
static struct HAL_SPI_CTRL_T spidpd_ctrl;
#endif
static uint8_t BOOT_BSS_LOC spi_cs_map[HAL_SPI_ID_QTY];
STATIC_ASSERT(sizeof(spi_cs_map[0]) * 8 >= HAL_SPI_CS_QTY,
"spi_cs_map size too small");
static bool BOOT_BSS_LOC in_use[HAL_SPI_ID_QTY] = {
false,
};
static HAL_SPI_DMA_HANDLER_T BOOT_BSS_LOC spi_txdma_handler[HAL_SPI_ID_QTY];
static HAL_SPI_DMA_HANDLER_T BOOT_BSS_LOC spi_rxdma_handler[HAL_SPI_ID_QTY];
static uint8_t BOOT_BSS_LOC spi_txdma_chan[HAL_SPI_ID_QTY];
static uint8_t BOOT_BSS_LOC spi_rxdma_chan[HAL_SPI_ID_QTY];
static enum HAL_SPI_MOD_CLK_SEL_T clk_sel[HAL_SPI_ID_QTY];
static bool BOOT_BSS_LOC spi_init_done = false;
static int hal_spi_activate_cs_id(enum HAL_SPI_ID_T id, uint32_t cs);
#endif
// static const char *invalid_id = "Invalid SPI ID: %d";
static inline uint8_t get_frame_bytes(enum HAL_SPI_ID_T id) {
uint8_t bits, cnt;
bits = GET_BITFIELD(spi[id]->SSPCR0, SPI_SSPCR0_DSS) + 1;
if (bits <= 8) {
cnt = 1;
} else if (bits <= 16) {
cnt = 2;
} else {
cnt = 4;
}
return cnt;
}
static inline void copy_frame_from_bytes(uint32_t *val, const uint8_t *data,
uint8_t cnt) {
#ifdef UNALIGNED_ACCESS
if (cnt == 1) {
*val = *(const uint8_t *)data;
} else if (cnt == 2) {
*val = *(const uint16_t *)data;
} else {
*val = *(const uint32_t *)data;
}
#else
if (cnt == 1) {
*val = data[0];
} else if (cnt == 2) {
*val = data[0] | (data[1] << 8);
} else {
*val = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
}
#endif
}
static inline void copy_bytes_from_frame(uint8_t *data, uint32_t val,
uint8_t cnt) {
#ifdef UNALIGNED_ACCESS
if (cnt == 1) {
*(uint8_t *)data = (uint8_t)val;
} else if (cnt == 2) {
*(uint16_t *)data = (uint16_t)val;
} else {
*(uint32_t *)data = (uint32_t)val;
}
#else
data[0] = (uint8_t)val;
if (cnt == 1) {
return;
} else if (cnt == 2) {
data[1] = (uint8_t)(val >> 8);
} else {
data[1] = (uint8_t)(val >> 8);
data[2] = (uint8_t)(val >> 16);
data[3] = (uint8_t)(val >> 24);
}
#endif
}
int hal_spi_init_ctrl(const struct HAL_SPI_CFG_T *cfg,
struct HAL_SPI_CTRL_T *ctrl) {
uint32_t div;
uint16_t cpsdvsr, scr;
uint32_t mod_clk;
#ifdef SPI_ROM_ONLY
// Assume default crystal -- Never access global versatile data to ensure
// reentrance
mod_clk = HAL_CMU_DEFAULT_CRYSTAL_FREQ;
#else // !SPI_ROM_ONLY
mod_clk = 0;
#ifdef PERIPH_PLL_FREQ
if (PERIPH_PLL_FREQ / 2 > 2 * hal_cmu_get_crystal_freq()) {
// Init to OSC_X2
mod_clk = 2 * hal_cmu_get_crystal_freq();
if (cfg->rate * 2 > mod_clk) {
mod_clk = PERIPH_PLL_FREQ / 2;
ctrl->clk_sel = HAL_SPI_MOD_CLK_SEL_PLL;
} else {
mod_clk = 0;
}
}
#endif
if (mod_clk == 0) {
// Init to OSC
mod_clk = hal_cmu_get_crystal_freq();
if (cfg->rate * 2 > mod_clk) {
mod_clk *= 2;
ctrl->clk_sel = HAL_SPI_MOD_CLK_SEL_OSC_X2;
} else {
ctrl->clk_sel = HAL_SPI_MOD_CLK_SEL_OSC;
}
}
#endif // !SPI_ROM_ONLY
SPI_ASSERT(cfg->rate <= mod_clk / (MIN_CPSDVSR * (1 + MIN_SCR)),
"SPI rate too large: %u", cfg->rate);
SPI_ASSERT(cfg->rate >= mod_clk / (MAX_CPSDVSR * (1 + MAX_SCR)),
"SPI rate too small: %u", cfg->rate);
SPI_ASSERT(cfg->tx_bits <= MAX_DATA_BITS && cfg->tx_bits >= MIN_DATA_BITS,
"Invalid SPI TX bits: %d", cfg->tx_bits);
SPI_ASSERT(cfg->rx_bits <= MAX_DATA_BITS && cfg->rx_bits >= MIN_DATA_BITS,
"Invalid SPI RX bits: %d", cfg->rx_bits);
SPI_ASSERT(cfg->rx_frame_bits <= MAX_DATA_BITS &&
(cfg->rx_frame_bits == 0 || cfg->rx_frame_bits > cfg->rx_bits),
"Invalid SPI RX FRAME bits: %d", cfg->rx_frame_bits);
SPI_ASSERT(cfg->cs < HAL_SPI_CS_QTY, "SPI cs bad: %d", cfg->cs);
div = (mod_clk + cfg->rate - 1) / cfg->rate;
cpsdvsr = (div + MAX_SCR) / (MAX_SCR + 1);
if (cpsdvsr < 2) {
cpsdvsr = 2;
} else {
if (cpsdvsr & 0x1) {
cpsdvsr += 1;
}
if (cpsdvsr > MAX_CPSDVSR) {
cpsdvsr = MAX_CPSDVSR;
}
}
scr = (div + cpsdvsr - 1) / cpsdvsr;
if (scr > 0) {
scr -= 1;
}
if (scr > MAX_SCR) {
scr = MAX_SCR;
}
ctrl->sspcr0_tx =
SPI_SSPCR0_SCR(scr) | (cfg->clk_delay_half ? SPI_SSPCR0_SPH : 0) |
(cfg->clk_polarity ? SPI_SSPCR0_SPO : 0) |
SPI_SSPCR0_FRF(0) | // Only support Motorola SPI frame format
SPI_SSPCR0_DSS(cfg->tx_bits - 1);
ctrl->sspcr1 = (cfg->rx_sep_line ? SPI_RX_SEL_EN : 0) |
SPI_SLAVE_ID(cfg->cs) | SPI_SSPCR1_SOD |
(cfg->slave ? SPI_SSPCR1_MS : 0) | SPI_SSPCR1_SSE;
ctrl->sspcpsr = SPI_SSPCPSR_CPSDVSR(cpsdvsr);
ctrl->sspdmacr = (cfg->dma_tx ? SPI_SSPDMACR_TXDMAE : 0) |
(cfg->dma_rx ? SPI_SSPDMACR_RXDMAE : 0);
ctrl->ssprxcr_tx = 0;
if (cfg->rx_frame_bits > 0) {
ctrl->sspcr0_rx =
SET_BITFIELD(ctrl->sspcr0_tx, SPI_SSPCR0_DSS, cfg->rx_frame_bits - 1);
ctrl->ssprxcr_rx = SPI_SSPRXCR_EN | SPI_SSPRXCR_OEN_POLARITY |
SPI_SSPRXCR_RXBITS(cfg->rx_bits - 1);
} else {
ctrl->sspcr0_rx =
SET_BITFIELD(ctrl->sspcr0_tx, SPI_SSPCR0_DSS, cfg->rx_bits - 1);
ctrl->ssprxcr_rx = 0;
}
return 0;
}
static void NOINLINE POSSIBLY_UNUSED hal_spi_set_xfer_type_id(
enum HAL_SPI_ID_T id, const struct HAL_SPI_CTRL_T *ctrl,
enum HAL_SPI_XFER_TYPE_T type) {
uint32_t sspcr0;
uint32_t ssprxcr;
if (type == HAL_SPI_XFER_TYPE_SEND) {
sspcr0 = ctrl->sspcr0_tx;
ssprxcr = ctrl->ssprxcr_tx;
} else {
sspcr0 = ctrl->sspcr0_rx;
ssprxcr = ctrl->ssprxcr_rx;
}
spi[id]->SSPCR0 = sspcr0;
spi[id]->SSPRXCR = ssprxcr;
}
static void NOINLINE hal_spi_enable_id(enum HAL_SPI_ID_T id,
const struct HAL_SPI_CTRL_T *ctrl,
enum HAL_SPI_XFER_TYPE_T type) {
hal_spi_set_xfer_type_id(id, ctrl, type);
spi[id]->SSPCR1 = ctrl->sspcr1;
spi[id]->SSPCPSR = ctrl->sspcpsr;
spi[id]->SSPDMACR = ctrl->sspdmacr;
#ifdef SPI_ROM_ONLY
if (id == HAL_SPI_ID_INTERNAL) {
hal_cmu_ispi_set_freq(HAL_CMU_PERIPH_FREQ_26M);
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
hal_cmu_spi_set_freq(HAL_CMU_PERIPH_FREQ_26M);
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
hal_cmu_slcd_set_freq(HAL_CMU_PERIPH_FREQ_26M);
#endif
}
#else // !SPI_ROM_ONLY
if (clk_sel[id] != ctrl->clk_sel) {
clk_sel[id] = ctrl->clk_sel;
if (ctrl->clk_sel == HAL_SPI_MOD_CLK_SEL_PLL) {
#ifdef PERIPH_PLL_FREQ
if (0) {
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
hal_cmu_spi_set_div(2);
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
hal_cmu_slcd_set_div(2);
#endif
}
// ISPI cannot use PLL clock
#endif
} else {
enum HAL_CMU_PERIPH_FREQ_T periph_freq;
if (ctrl->clk_sel == HAL_SPI_MOD_CLK_SEL_OSC_X2) {
periph_freq = HAL_CMU_PERIPH_FREQ_52M;
} else {
periph_freq = HAL_CMU_PERIPH_FREQ_26M;
}
if (id == HAL_SPI_ID_INTERNAL) {
hal_cmu_ispi_set_freq(periph_freq);
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
hal_cmu_spi_set_freq(periph_freq);
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
hal_cmu_slcd_set_freq(periph_freq);
#endif
}
}
}
#endif // !SPI_ROM_ONLY
}
static void hal_spi_disable_id(enum HAL_SPI_ID_T id) {
spi[id]->SSPCR1 &= ~SPI_SSPCR1_SSE;
}
static void POSSIBLY_UNUSED hal_spi_get_ctrl_id(enum HAL_SPI_ID_T id,
struct HAL_SPI_CTRL_T *ctrl) {
ctrl->sspcr0_tx = spi[id]->SSPCR0;
ctrl->sspcr1 = spi[id]->SSPCR1;
ctrl->sspcpsr = spi[id]->SSPCPSR;
ctrl->sspdmacr = spi[id]->SSPDMACR;
ctrl->ssprxcr_tx = spi[id]->SSPRXCR;
}
static int NOINLINE hal_spi_open_id(enum HAL_SPI_ID_T id,
const struct HAL_SPI_CFG_T *cfg,
struct HAL_SPI_CTRL_T *ctrl) {
int ret;
struct HAL_SPI_CTRL_T ctrl_regs;
bool cfg_clk = true;
// SPI_ASSERT(id < HAL_SPI_ID_QTY, invalid_id, id);
if (ctrl == NULL) {
ctrl = &ctrl_regs;
}
ret = hal_spi_init_ctrl(cfg, ctrl);
if (ret) {
return ret;
}
#ifndef SPI_ROM_ONLY
if (!spi_init_done) {
spi_init_done = true;
for (int i = HAL_SPI_ID_INTERNAL; i < HAL_SPI_ID_QTY; i++) {
spi_txdma_chan[i] = HAL_DMA_CHAN_NONE;
spi_rxdma_chan[i] = HAL_DMA_CHAN_NONE;
}
}
if (spi_cs_map[id]) {
cfg_clk = false;
}
spi_cs_map[id] |= (1 << cfg->cs);
#endif
if (cfg_clk) {
hal_cmu_clock_enable(spi_mod[id].mod);
hal_cmu_clock_enable(spi_mod[id].apb);
hal_cmu_reset_clear(spi_mod[id].mod);
hal_cmu_reset_clear(spi_mod[id].apb);
}
hal_spi_enable_id(id, ctrl, HAL_SPI_XFER_TYPE_SEND);
return 0;
}
static int POSSIBLY_UNUSED hal_spi_close_id(enum HAL_SPI_ID_T id, uint32_t cs) {
int ret = 0;
bool cfg_clk = true;
#ifndef SPI_ROM_ONLY
if (spi_cs_map[id] & (1 << cs)) {
spi_cs_map[id] &= ~(1 << cs);
#if (CHIP_SPI_VER >= 2)
if (spi_cs_map[id]) {
cfg_clk = false;
}
#endif
} else {
ret = 1;
cfg_clk = false;
}
#endif
if (cfg_clk) {
hal_spi_disable_id(id);
hal_cmu_reset_set(spi_mod[id].apb);
hal_cmu_reset_set(spi_mod[id].mod);
hal_cmu_clock_disable(spi_mod[id].apb);
hal_cmu_clock_disable(spi_mod[id].mod);
}
return ret;
}
static void POSSIBLY_UNUSED hal_spi_set_cs_id(enum HAL_SPI_ID_T id,
uint32_t cs) {
spi[id]->SSPCR1 = SET_BITFIELD(spi[id]->SSPCR1, SPI_SLAVE_ID, cs);
}
static bool hal_spi_busy_id(enum HAL_SPI_ID_T id) {
return ((spi[id]->SSPCR1 & SPI_SSPCR1_SSE) &&
(spi[id]->SSPSR & SPI_SSPSR_BSY));
}
static void hal_spi_enable_slave_output_id(enum HAL_SPI_ID_T id) {
if (spi[id]->SSPCR1 & SPI_SSPCR1_MS) {
spi[id]->SSPCR1 &= ~SPI_SSPCR1_SOD;
}
}
static void hal_spi_disable_slave_output_id(enum HAL_SPI_ID_T id) {
if (spi[id]->SSPCR1 & SPI_SSPCR1_MS) {
spi[id]->SSPCR1 |= SPI_SSPCR1_SOD;
}
}
static int hal_spi_send_id(enum HAL_SPI_ID_T id, const void *data,
uint32_t len) {
uint8_t cnt;
uint32_t sent, value;
int ret;
// SPI_ASSERT(id < HAL_SPI_ID_QTY, invalid_id, id);
SPI_ASSERT((spi[id]->SSPDMACR & SPI_SSPDMACR_TXDMAE) == 0,
"TX-DMA configured on SPI %d", id);
cnt = get_frame_bytes(id);
if (len == 0 || (len & (cnt - 1)) != 0) {
return -1;
}
sent = 0;
hal_spi_enable_slave_output_id(id);
while (sent < len) {
if ((spi[id]->SSPCR1 & SPI_SSPCR1_SSE) == 0) {
break;
}
if (spi[id]->SSPSR & SPI_SSPSR_TNF) {
value = 0;
copy_frame_from_bytes(&value, (uint8_t *)data + sent, cnt);
spi[id]->SSPDR = value;
sent += cnt;
}
}
if (sent >= len) {
ret = 0;
} else {
ret = 1;
}
while (hal_spi_busy_id(id))
;
hal_spi_disable_slave_output_id(id);
return ret;
}
static int hal_spi_recv_id(enum HAL_SPI_ID_T id, const void *cmd, void *data,
uint32_t len) {
uint8_t cnt;
uint32_t sent, recv, value;
int ret;
// SPI_ASSERT(id < HAL_SPI_ID_QTY, invalid_id, id);
SPI_ASSERT(
(spi[id]->SSPDMACR & (SPI_SSPDMACR_TXDMAE | SPI_SSPDMACR_RXDMAE)) == 0,
"RX/TX-DMA configured on SPI %d", id);
cnt = get_frame_bytes(id);
if (len == 0 || (len & (cnt - 1)) != 0) {
return -1;
}
// Rx transaction should start from idle state
if (spi[id]->SSPSR & SPI_SSPSR_BSY) {
return -11;
}
sent = 0;
recv = 0;
// Flush the RX FIFO by reset or CPU read
while (spi[id]->SSPSR & SPI_SSPSR_RNE) {
spi[id]->SSPDR;
}
spi[id]->SSPICR = ~0UL;
hal_spi_enable_slave_output_id(id);
while (recv < len || sent < len) {
if ((spi[id]->SSPCR1 & SPI_SSPCR1_SSE) == 0) {
break;
}
if (sent < len && (spi[id]->SSPSR & SPI_SSPSR_TNF)) {
value = 0;
copy_frame_from_bytes(&value, (uint8_t *)cmd + sent, cnt);
spi[id]->SSPDR = value;
sent += cnt;
}
if (recv < len && (spi[id]->SSPSR & SPI_SSPSR_RNE)) {
value = spi[id]->SSPDR;
copy_bytes_from_frame((uint8_t *)data + recv, value, cnt);
recv += cnt;
}
}
if (recv >= len && sent >= len) {
ret = 0;
} else {
ret = 1;
}
while (hal_spi_busy_id(id))
;
hal_spi_disable_slave_output_id(id);
return ret;
}
#ifdef SPI_ROM_ONLY
//------------------------------------------------------------
// ISPI ROM functions
//------------------------------------------------------------
int hal_ispi_rom_open(const struct HAL_SPI_CFG_T *cfg) {
SPI_ASSERT(cfg->tx_bits == cfg->rx_bits && cfg->rx_frame_bits == 0,
"ISPI_ROM: Bad bits cfg");
return hal_spi_open_id(HAL_SPI_ID_INTERNAL, cfg, NULL);
}
void hal_ispi_rom_activate_cs(uint32_t cs) {
SPI_ASSERT(cs < HAL_SPI_CS_QTY, "ISPI_ROM: SPI cs bad: %d", cs);
hal_spi_set_cs_id(HAL_SPI_ID_INTERNAL, cs);
}
int hal_ispi_rom_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_INTERNAL); }
int hal_ispi_rom_send(const void *data, uint32_t len) {
int ret;
ret = hal_spi_send_id(HAL_SPI_ID_INTERNAL, data, len);
return ret;
}
int hal_ispi_rom_recv(const void *cmd, void *data, uint32_t len) {
int ret;
ret = hal_spi_recv_id(HAL_SPI_ID_INTERNAL, cmd, data, len);
return ret;
}
#ifdef CHIP_HAS_SPIPHY
//------------------------------------------------------------
// SPI PHY ROM functions
//------------------------------------------------------------
int hal_spiphy_rom_open(const struct HAL_SPI_CFG_T *cfg) {
SPI_ASSERT(cfg->tx_bits == cfg->rx_bits && cfg->rx_frame_bits == 0,
"SPIPHY_ROM: Bad bits cfg");
return hal_spi_open_id(HAL_SPI_ID_PHY, cfg, NULL);
}
int hal_spiphy_rom_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_PHY); }
int hal_spiphy_rom_send(const void *data, uint32_t len) {
int ret;
ret = hal_spi_send_id(HAL_SPI_ID_PHY, data, len);
return ret;
}
int hal_spiphy_rom_recv(const void *cmd, void *data, uint32_t len) {
int ret;
ret = hal_spi_recv_id(HAL_SPI_ID_PHY, cmd, data, len);
return ret;
}
#endif
#else // !SPI_ROM_ONLY
static int hal_spi_activate_cs_id(enum HAL_SPI_ID_T id, uint32_t cs) {
struct HAL_SPI_CTRL_T *ctrl = NULL;
SPI_ASSERT(cs < HAL_SPI_CS_QTY, "SPI cs bad: %d", cs);
SPI_ASSERT(spi_cs_map[id] & (1 << cs), "SPI cs not opened: %d", cs);
#if (CHIP_SPI_VER >= 2)
if (0) {
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
spi0_cs = cs;
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
spilcd_cs = cs;
#endif
}
#endif
if (0) {
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
ctrl = &spi0_ctrl[spi0_cs];
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
ctrl = &spilcd_ctrl[spilcd_cs];
#endif
}
if (ctrl) {
hal_spi_enable_id(id, ctrl, HAL_SPI_XFER_TYPE_SEND);
}
return 0;
}
static int POSSIBLY_UNUSED hal_spi_enable_and_send_id(
enum HAL_SPI_ID_T id, const struct HAL_SPI_CTRL_T *ctrl, const void *data,
uint32_t len) {
int ret;
struct HAL_SPI_CTRL_T saved;
// SPI_ASSERT(id < HAL_SPI_ID_QTY, invalid_id, id);
if (set_bool_flag(&in_use[id])) {
return -31;
}
hal_spi_get_ctrl_id(id, &saved);
hal_spi_enable_id(id, ctrl, HAL_SPI_XFER_TYPE_SEND);
ret = hal_spi_send_id(id, data, len);
hal_spi_enable_id(id, &saved, HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[id]);
return ret;
}
static int POSSIBLY_UNUSED hal_spi_enable_and_recv_id(
enum HAL_SPI_ID_T id, const struct HAL_SPI_CTRL_T *ctrl, const void *cmd,
void *data, uint32_t len) {
int ret;
struct HAL_SPI_CTRL_T saved;
if (set_bool_flag(&in_use[id])) {
return -31;
}
hal_spi_get_ctrl_id(id, &saved);
hal_spi_enable_id(id, ctrl, HAL_SPI_XFER_TYPE_RECV);
ret = hal_spi_recv_id(id, cmd, data, len);
hal_spi_enable_id(id, &saved, HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[id]);
return ret;
}
static void hal_spi_txdma_handler(uint8_t chan, uint32_t remains,
uint32_t error, struct HAL_DMA_DESC_T *lli) {
enum HAL_SPI_ID_T id;
uint32_t lock;
lock = int_lock();
for (id = HAL_SPI_ID_INTERNAL; id < HAL_SPI_ID_QTY; id++) {
if (spi_txdma_chan[id] == chan) {
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
break;
}
}
int_unlock(lock);
if (id >= HAL_SPI_ID_QTY) {
return;
}
hal_gpdma_free_chan(chan);
clear_bool_flag(&in_use[id]);
if (spi_txdma_handler[id]) {
spi_txdma_handler[id](error);
}
}
static int hal_spi_dma_send_id(enum HAL_SPI_ID_T id, const void *data,
uint32_t len, HAL_SPI_DMA_HANDLER_T handler) {
uint8_t cnt;
enum HAL_DMA_RET_T ret;
struct HAL_DMA_CH_CFG_T dma_cfg;
enum HAL_DMA_WDITH_T dma_width;
uint32_t lock;
enum HAL_DMA_PERIPH_T dst_periph;
// SPI_ASSERT(id < HAL_SPI_ID_QTY, invalid_id, id);
SPI_ASSERT((spi[id]->SSPDMACR & SPI_SSPDMACR_TXDMAE),
"TX-DMA not configured on SPI %d", id);
spi_txdma_handler[id] = handler;
cnt = get_frame_bytes(id);
if ((len & (cnt - 1)) != 0) {
return -1;
}
if (((uint32_t)data & (cnt - 1)) != 0) {
return -2;
}
// Tx transaction should start from idle state for SPI mode 1 and 3 (SPH=1)
if ((spi[id]->SSPCR0 & SPI_SSPCR0_SPH) && (spi[id]->SSPSR & SPI_SSPSR_BSY)) {
return -11;
}
if (id == HAL_SPI_ID_INTERNAL) {
dst_periph = HAL_GPDMA_ISPI_TX;
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
dst_periph = HAL_GPDMA_SPI_TX;
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
dst_periph = HAL_GPDMA_SPILCD_TX;
#endif
} else {
return -12;
}
lock = int_lock();
if (spi_txdma_chan[id] != HAL_DMA_CHAN_NONE) {
int_unlock(lock);
return -3;
}
spi_txdma_chan[id] = hal_gpdma_get_chan(dst_periph, HAL_DMA_HIGH_PRIO);
if (spi_txdma_chan[id] == HAL_DMA_CHAN_NONE) {
int_unlock(lock);
return -4;
}
int_unlock(lock);
if (cnt == 1) {
dma_width = HAL_DMA_WIDTH_BYTE;
} else if (cnt == 2) {
dma_width = HAL_DMA_WIDTH_HALFWORD;
} else {
dma_width = HAL_DMA_WIDTH_WORD;
}
memset(&dma_cfg, 0, sizeof(dma_cfg));
dma_cfg.ch = spi_txdma_chan[id];
dma_cfg.dst = 0; // useless
dma_cfg.dst_bsize = HAL_DMA_BSIZE_4;
dma_cfg.dst_periph = dst_periph;
dma_cfg.dst_width = dma_width;
dma_cfg.handler = handler ? hal_spi_txdma_handler : NULL;
dma_cfg.src = (uint32_t)data;
dma_cfg.src_bsize = HAL_DMA_BSIZE_16;
// dma_cfg.src_periph = HAL_GPDMA_PERIPH_QTY; // useless
dma_cfg.src_tsize = len / cnt;
dma_cfg.src_width = dma_width;
dma_cfg.try_burst = 0;
dma_cfg.type = HAL_DMA_FLOW_M2P_DMA;
hal_spi_enable_slave_output_id(id);
ret = hal_gpdma_start(&dma_cfg);
if (ret != HAL_DMA_OK) {
hal_spi_disable_slave_output_id(id);
return -5;
}
if (handler == NULL) {
while ((spi[id]->SSPCR1 & SPI_SSPCR1_SSE) &&
hal_gpdma_chan_busy(spi_txdma_chan[id]))
;
hal_gpdma_free_chan(spi_txdma_chan[id]);
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
while (hal_spi_busy_id(id))
;
hal_spi_disable_slave_output_id(id);
}
return 0;
}
void hal_spi_stop_dma_send_id(enum HAL_SPI_ID_T id) {
uint32_t lock;
uint8_t tx_chan;
lock = int_lock();
tx_chan = spi_txdma_chan[id];
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
int_unlock(lock);
if (tx_chan != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(tx_chan);
hal_gpdma_free_chan(tx_chan);
}
clear_bool_flag(&in_use[id]);
}
static void hal_spi_rxdma_handler(uint8_t chan, uint32_t remains,
uint32_t error, struct HAL_DMA_DESC_T *lli) {
enum HAL_SPI_ID_T id;
uint32_t lock;
uint8_t tx_chan = HAL_DMA_CHAN_NONE;
struct HAL_SPI_CTRL_T *ctrl = NULL;
lock = int_lock();
for (id = HAL_SPI_ID_INTERNAL; id < HAL_SPI_ID_QTY; id++) {
if (spi_rxdma_chan[id] == chan) {
tx_chan = spi_txdma_chan[id];
spi_rxdma_chan[id] = HAL_DMA_CHAN_NONE;
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
break;
}
}
int_unlock(lock);
if (id >= HAL_SPI_ID_QTY) {
return;
}
hal_gpdma_free_chan(chan);
hal_gpdma_cancel(tx_chan);
hal_gpdma_free_chan(tx_chan);
if (0) {
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
ctrl = &spi0_ctrl[spi0_cs];
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
ctrl = &spilcd_ctrl[spilcd_cs];
#endif
}
if (ctrl) {
hal_spi_set_xfer_type_id(id, ctrl, HAL_SPI_XFER_TYPE_SEND);
}
clear_bool_flag(&in_use[id]);
if (spi_rxdma_handler[id]) {
spi_rxdma_handler[id](error);
}
}
static int hal_spi_dma_recv_id(enum HAL_SPI_ID_T id, const void *cmd,
void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
uint8_t cnt;
enum HAL_DMA_RET_T ret;
struct HAL_DMA_CH_CFG_T dma_cfg;
enum HAL_DMA_WDITH_T dma_width;
uint32_t lock;
int result;
enum HAL_DMA_PERIPH_T dst_periph, src_periph;
struct HAL_SPI_CTRL_T *ctrl = NULL;
// SPI_ASSERT(id < HAL_SPI_ID_QTY, invalid_id, id);
SPI_ASSERT(
(spi[id]->SSPDMACR & (SPI_SSPDMACR_TXDMAE | SPI_SSPDMACR_RXDMAE)) ==
(SPI_SSPDMACR_TXDMAE | SPI_SSPDMACR_RXDMAE),
"RX/TX-DMA not configured on SPI %d", id);
spi_rxdma_handler[id] = handler;
result = 0;
cnt = get_frame_bytes(id);
if ((len & (cnt - 1)) != 0) {
return -1;
}
if (((uint32_t)data & (cnt - 1)) != 0) {
return -2;
}
// Rx transaction should start from idle state
if (spi[id]->SSPSR & SPI_SSPSR_BSY) {
return -11;
}
if (id == HAL_SPI_ID_INTERNAL) {
src_periph = HAL_GPDMA_ISPI_RX;
dst_periph = HAL_GPDMA_ISPI_TX;
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
src_periph = HAL_GPDMA_SPI_RX;
dst_periph = HAL_GPDMA_SPI_TX;
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
src_periph = HAL_GPDMA_SPILCD_RX;
dst_periph = HAL_GPDMA_SPILCD_TX;
#endif
} else {
return -12;
}
lock = int_lock();
if (spi_txdma_chan[id] != HAL_DMA_CHAN_NONE ||
spi_rxdma_chan[id] != HAL_DMA_CHAN_NONE) {
int_unlock(lock);
return -3;
}
spi_txdma_chan[id] = hal_gpdma_get_chan(dst_periph, HAL_DMA_HIGH_PRIO);
if (spi_txdma_chan[id] == HAL_DMA_CHAN_NONE) {
int_unlock(lock);
return -4;
}
spi_rxdma_chan[id] = hal_gpdma_get_chan(src_periph, HAL_DMA_HIGH_PRIO);
if (spi_rxdma_chan[id] == HAL_DMA_CHAN_NONE) {
hal_gpdma_free_chan(spi_txdma_chan[id]);
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
int_unlock(lock);
return -5;
}
int_unlock(lock);
if (cnt == 1) {
dma_width = HAL_DMA_WIDTH_BYTE;
} else if (cnt == 2) {
dma_width = HAL_DMA_WIDTH_HALFWORD;
} else {
dma_width = HAL_DMA_WIDTH_WORD;
}
memset(&dma_cfg, 0, sizeof(dma_cfg));
dma_cfg.ch = spi_rxdma_chan[id];
dma_cfg.dst = (uint32_t)data;
dma_cfg.dst_bsize = HAL_DMA_BSIZE_16;
// dma_cfg.dst_periph = HAL_GPDMA_PERIPH_QTY; // useless
dma_cfg.dst_width = dma_width;
dma_cfg.handler = handler ? hal_spi_rxdma_handler : NULL;
dma_cfg.src = 0; // useless
dma_cfg.src_periph = src_periph;
dma_cfg.src_bsize = HAL_DMA_BSIZE_4;
dma_cfg.src_tsize = len / cnt;
dma_cfg.src_width = dma_width;
dma_cfg.try_burst = 0;
dma_cfg.type = HAL_DMA_FLOW_P2M_DMA;
// Flush the RX FIFO by reset or DMA read (CPU read is forbidden when DMA is
// enabled)
if (spi[id]->SSPSR & SPI_SSPSR_RNE) {
// Reset SPI MODULE might cause the increment of the FIFO pointer
hal_cmu_reset_pulse(spi_mod[id].mod);
// Reset SPI APB will reset the FIFO pointer
hal_cmu_reset_pulse(spi_mod[id].apb);
if (0) {
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
ctrl = &spi0_ctrl[spi0_cs];
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
ctrl = &spilcd_ctrl[spilcd_cs];
#endif
}
if (ctrl) {
// hal_spi_set_xfer_type_id() is not enough, for all the registers have
// been reset by APB reset
hal_spi_enable_id(id, ctrl, HAL_SPI_XFER_TYPE_RECV);
}
}
spi[id]->SSPICR = ~0UL;
ret = hal_gpdma_start(&dma_cfg);
if (ret != HAL_DMA_OK) {
result = -8;
goto _exit;
}
dma_cfg.ch = spi_txdma_chan[id];
dma_cfg.dst = 0; // useless
dma_cfg.dst_bsize = HAL_DMA_BSIZE_4;
dma_cfg.dst_periph = dst_periph;
dma_cfg.dst_width = dma_width;
dma_cfg.handler = NULL;
dma_cfg.src = (uint32_t)cmd;
dma_cfg.src_bsize = HAL_DMA_BSIZE_16;
// dma_cfg.src_periph = HAL_GPDMA_PERIPH_QTY; // useless
dma_cfg.src_tsize = len / cnt;
dma_cfg.src_width = dma_width;
dma_cfg.try_burst = 0;
dma_cfg.type = HAL_DMA_FLOW_M2P_DMA;
hal_spi_enable_slave_output_id(id);
ret = hal_gpdma_start(&dma_cfg);
if (ret != HAL_DMA_OK) {
result = -9;
goto _exit;
}
if (handler == NULL) {
while ((spi[id]->SSPCR1 & SPI_SSPCR1_SSE) &&
hal_gpdma_chan_busy(spi_rxdma_chan[id]))
;
}
_exit:
if (result || handler == NULL) {
hal_gpdma_cancel(spi_txdma_chan[id]);
hal_gpdma_free_chan(spi_txdma_chan[id]);
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
while (hal_spi_busy_id(id))
;
hal_spi_disable_slave_output_id(id);
hal_gpdma_cancel(spi_rxdma_chan[id]);
hal_gpdma_free_chan(spi_rxdma_chan[id]);
spi_rxdma_chan[id] = HAL_DMA_CHAN_NONE;
if (ctrl) {
hal_spi_set_xfer_type_id(id, ctrl, HAL_SPI_XFER_TYPE_SEND);
}
}
return 0;
}
void hal_spi_stop_dma_recv_id(enum HAL_SPI_ID_T id) {
uint32_t lock;
uint8_t rx_chan, tx_chan;
struct HAL_SPI_CTRL_T *ctrl = NULL;
lock = int_lock();
rx_chan = spi_rxdma_chan[id];
spi_rxdma_chan[id] = HAL_DMA_CHAN_NONE;
tx_chan = spi_txdma_chan[id];
spi_txdma_chan[id] = HAL_DMA_CHAN_NONE;
int_unlock(lock);
if (rx_chan == HAL_DMA_CHAN_NONE && tx_chan == HAL_DMA_CHAN_NONE) {
return;
}
if (rx_chan != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(rx_chan);
hal_gpdma_free_chan(rx_chan);
}
if (tx_chan != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(tx_chan);
hal_gpdma_free_chan(tx_chan);
}
if (0) {
#ifdef CHIP_HAS_SPI
} else if (id == HAL_SPI_ID_0) {
ctrl = &spi0_ctrl[spi0_cs];
#endif
#ifdef CHIP_HAS_SPILCD
} else if (id == HAL_SPI_ID_SLCD) {
ctrl = &spilcd_ctrl[spilcd_cs];
#endif
}
if (ctrl) {
hal_spi_set_xfer_type_id(id, ctrl, HAL_SPI_XFER_TYPE_SEND);
}
clear_bool_flag(&in_use[id]);
}
//------------------------------------------------------------
// ISPI functions
//------------------------------------------------------------
int hal_ispi_open(const struct HAL_SPI_CFG_T *cfg) {
SPI_ASSERT(cfg->tx_bits == cfg->rx_bits && cfg->rx_frame_bits == 0,
"ISPI: Bad bits cfg");
return hal_spi_open_id(HAL_SPI_ID_INTERNAL, cfg, NULL);
}
int hal_ispi_close(uint32_t cs) {
return hal_spi_close_id(HAL_SPI_ID_INTERNAL, cs);
}
void hal_ispi_activate_cs(uint32_t cs) {
SPI_ASSERT(cs < HAL_SPI_CS_QTY, "ISPI: SPI cs bad: %d", cs);
hal_spi_set_cs_id(HAL_SPI_ID_INTERNAL, cs);
}
int hal_ispi_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_INTERNAL); }
int hal_ispi_send(const void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_INTERNAL])) {
return -31;
}
ret = hal_spi_send_id(HAL_SPI_ID_INTERNAL, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_INTERNAL]);
return ret;
}
int hal_ispi_recv(const void *cmd, void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_INTERNAL])) {
return -31;
}
ret = hal_spi_recv_id(HAL_SPI_ID_INTERNAL, cmd, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_INTERNAL]);
return ret;
}
int hal_ispi_dma_send(const void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_INTERNAL])) {
return -31;
}
ret = hal_spi_dma_send_id(HAL_SPI_ID_INTERNAL, data, len, handler);
if (ret || handler == NULL) {
clear_bool_flag(&in_use[HAL_SPI_ID_INTERNAL]);
}
return ret;
}
int hal_ispi_dma_recv(const void *cmd, void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_INTERNAL])) {
return -31;
}
ret = hal_spi_dma_recv_id(HAL_SPI_ID_INTERNAL, cmd, data, len, handler);
if (ret || handler == NULL) {
clear_bool_flag(&in_use[HAL_SPI_ID_INTERNAL]);
}
return ret;
}
void hal_ispi_stop_dma_send(void) {
hal_spi_stop_dma_send_id(HAL_SPI_ID_INTERNAL);
}
void hal_ispi_stop_dma_recv(void) {
hal_spi_stop_dma_recv_id(HAL_SPI_ID_INTERNAL);
}
#ifdef CHIP_HAS_SPI
//------------------------------------------------------------
// SPI peripheral functions
//------------------------------------------------------------
int hal_spi_open(const struct HAL_SPI_CFG_T *cfg) {
int ret;
uint32_t lock;
if (cfg->cs >= HAL_SPI_CS_QTY) {
return -1;
}
lock = int_lock();
ret = hal_spi_open_id(HAL_SPI_ID_0, cfg, &spi0_ctrl[cfg->cs]);
#if (CHIP_SPI_VER >= 2)
if (ret == 0) {
spi0_cs = cfg->cs;
}
#endif
int_unlock(lock);
return ret;
}
int hal_spi_close(uint32_t cs) {
int ret;
uint32_t lock;
lock = int_lock();
ret = hal_spi_close_id(HAL_SPI_ID_0, cs);
#if (CHIP_SPI_VER >= 2)
if (ret == 0 && spi0_cs == cs) {
uint32_t lowest_cs;
lowest_cs = __CLZ(__RBIT(spi_cs_map[HAL_SPI_ID_0]));
if (lowest_cs < HAL_SPI_CS_QTY) {
hal_spi_activate_cs_id(HAL_SPI_ID_0, lowest_cs);
} else {
lowest_cs = HAL_SPI_CS_0;
}
spi0_cs = lowest_cs;
}
#endif
int_unlock(lock);
return ret;
}
int hal_spi_activate_cs(uint32_t cs) {
return hal_spi_activate_cs_id(HAL_SPI_ID_0, cs);
}
int hal_spi_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_0); }
int hal_spi_send(const void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_0])) {
return -31;
}
ret = hal_spi_send_id(HAL_SPI_ID_0, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_0]);
return ret;
}
int hal_spi_recv(const void *cmd, void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_0])) {
return -31;
}
hal_spi_set_xfer_type_id(HAL_SPI_ID_0, &spi0_ctrl[spi0_cs],
HAL_SPI_XFER_TYPE_RECV);
ret = hal_spi_recv_id(HAL_SPI_ID_0, cmd, data, len);
hal_spi_set_xfer_type_id(HAL_SPI_ID_0, &spi0_ctrl[spi0_cs],
HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[HAL_SPI_ID_0]);
return ret;
}
int hal_spi_dma_send(const void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_0])) {
return -31;
}
ret = hal_spi_dma_send_id(HAL_SPI_ID_0, data, len, handler);
if (ret || handler == NULL) {
clear_bool_flag(&in_use[HAL_SPI_ID_0]);
}
return ret;
}
int hal_spi_dma_recv(const void *cmd, void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_0])) {
return -31;
}
hal_spi_set_xfer_type_id(HAL_SPI_ID_0, &spi0_ctrl[spi0_cs],
HAL_SPI_XFER_TYPE_RECV);
ret = hal_spi_dma_recv_id(HAL_SPI_ID_0, cmd, data, len, handler);
if (ret || handler == NULL) {
hal_spi_set_xfer_type_id(HAL_SPI_ID_0, &spi0_ctrl[spi0_cs],
HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[HAL_SPI_ID_0]);
}
return ret;
}
void hal_spi_stop_dma_send(void) { hal_spi_stop_dma_send_id(HAL_SPI_ID_0); }
void hal_spi_stop_dma_recv(void) { hal_spi_stop_dma_recv_id(HAL_SPI_ID_0); }
int hal_spi_enable_and_send(const struct HAL_SPI_CTRL_T *ctrl, const void *data,
uint32_t len) {
return hal_spi_enable_and_send_id(HAL_SPI_ID_0, ctrl, data, len);
}
int hal_spi_enable_and_recv(const struct HAL_SPI_CTRL_T *ctrl, const void *cmd,
void *data, uint32_t len) {
return hal_spi_enable_and_recv_id(HAL_SPI_ID_0, ctrl, cmd, data, len);
}
#endif // CHIP_HAS_SPI
#ifdef CHIP_HAS_SPILCD
//------------------------------------------------------------
// SPI LCD functions
//------------------------------------------------------------
int hal_spilcd_open(const struct HAL_SPI_CFG_T *cfg) {
int ret;
uint32_t lock;
if (cfg->cs >= HAL_SPI_CS_QTY) {
return -1;
}
lock = int_lock();
ret = hal_spi_open_id(HAL_SPI_ID_SLCD, cfg, &spilcd_ctrl[cfg->cs]);
#if (CHIP_SPI_VER >= 2)
if (ret == 0) {
spilcd_cs = cfg->cs;
}
#endif
int_unlock(lock);
return ret;
}
int hal_spilcd_close(uint32_t cs) {
int ret;
uint32_t lock;
lock = int_lock();
ret = hal_spi_close_id(HAL_SPI_ID_SLCD, cs);
#if (CHIP_SPI_VER >= 2)
if (ret == 0 && spilcd_cs == cs) {
uint32_t lowest_cs;
lowest_cs = __CLZ(__RBIT(spi_cs_map[HAL_SPI_ID_SLCD]));
if (lowest_cs < HAL_SPI_CS_QTY) {
hal_spi_activate_cs_id(HAL_SPI_ID_SLCD, lowest_cs);
} else {
lowest_cs = HAL_SPI_CS_0;
}
spilcd_cs = lowest_cs;
}
#endif
int_unlock(lock);
return ret;
}
int hal_spilcd_activate_cs(uint32_t cs) {
return hal_spi_activate_cs_id(HAL_SPI_ID_SLCD, cs);
}
int hal_spilcd_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_SLCD); }
int hal_spilcd_send(const void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_SLCD])) {
return -31;
}
ret = hal_spi_send_id(HAL_SPI_ID_SLCD, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_SLCD]);
return ret;
}
int hal_spilcd_recv(const void *cmd, void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_SLCD])) {
return -31;
}
hal_spi_set_xfer_type_id(HAL_SPI_ID_SLCD, &spilcd_ctrl[spilcd_cs],
HAL_SPI_XFER_TYPE_RECV);
ret = hal_spi_recv_id(HAL_SPI_ID_SLCD, cmd, data, len);
hal_spi_set_xfer_type_id(HAL_SPI_ID_SLCD, &spilcd_ctrl[spilcd_cs],
HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[HAL_SPI_ID_SLCD]);
return ret;
}
int hal_spilcd_dma_send(const void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_SLCD])) {
return -31;
}
ret = hal_spi_dma_send_id(HAL_SPI_ID_SLCD, data, len, handler);
if (ret || handler == NULL) {
clear_bool_flag(&in_use[HAL_SPI_ID_SLCD]);
}
return ret;
}
int hal_spilcd_dma_recv(const void *cmd, void *data, uint32_t len,
HAL_SPI_DMA_HANDLER_T handler) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_SLCD])) {
return -31;
}
hal_spi_set_xfer_type_id(HAL_SPI_ID_SLCD, &spilcd_ctrl[spilcd_cs],
HAL_SPI_XFER_TYPE_RECV);
ret = hal_spi_dma_recv_id(HAL_SPI_ID_SLCD, cmd, data, len, handler);
if (ret || handler == NULL) {
hal_spi_set_xfer_type_id(HAL_SPI_ID_SLCD, &spilcd_ctrl[spilcd_cs],
HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[HAL_SPI_ID_SLCD]);
}
return ret;
}
void hal_spilcd_stop_dma_send(void) {
hal_spi_stop_dma_send_id(HAL_SPI_ID_SLCD);
}
void hal_spilcd_stop_dma_recv(void) {
hal_spi_stop_dma_recv_id(HAL_SPI_ID_SLCD);
}
int hal_spilcd_set_data_mode(void) {
if (set_bool_flag(&in_use[HAL_SPI_ID_SLCD])) {
return -31;
}
spi[HAL_SPI_ID_SLCD]->SSPCR1 |= SPI_LCD_DC_DATA;
clear_bool_flag(&in_use[HAL_SPI_ID_SLCD]);
return 0;
}
int hal_spilcd_set_cmd_mode(void) {
if (set_bool_flag(&in_use[HAL_SPI_ID_SLCD])) {
return -31;
}
spi[HAL_SPI_ID_SLCD]->SSPCR1 &= ~SPI_LCD_DC_DATA;
clear_bool_flag(&in_use[HAL_SPI_ID_SLCD]);
return 0;
}
int hal_spilcd_enable_and_send(const struct HAL_SPI_CTRL_T *ctrl,
const void *data, uint32_t len) {
return hal_spi_enable_and_send_id(HAL_SPI_ID_SLCD, ctrl, data, len);
}
int hal_spilcd_enable_and_recv(const struct HAL_SPI_CTRL_T *ctrl,
const void *cmd, void *data, uint32_t len) {
return hal_spi_enable_and_recv_id(HAL_SPI_ID_SLCD, ctrl, cmd, data, len);
}
#endif // CHIP_HAS_SPILCD
#ifdef CHIP_HAS_SPIPHY
//------------------------------------------------------------
// SPI PHY functions
//------------------------------------------------------------
int hal_spiphy_open(const struct HAL_SPI_CFG_T *cfg) {
SPI_ASSERT(cfg->tx_bits == cfg->rx_bits && cfg->rx_frame_bits == 0,
"SPIPHY: Bad bits cfg");
return hal_spi_open_id(HAL_SPI_ID_PHY, cfg, NULL);
}
int hal_spiphy_close(uint32_t cs) {
return hal_spi_close_id(HAL_SPI_ID_PHY, cs);
}
void hal_spiphy_activate_cs(uint32_t cs) {
SPI_ASSERT(cs < HAL_SPI_CS_QTY, "SPIPHY: SPI cs bad: %d", cs);
hal_spi_set_cs_id(HAL_SPI_ID_PHY, cs);
}
int hal_spiphy_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_PHY); }
int hal_spiphy_send(const void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_PHY])) {
return -31;
}
ret = hal_spi_send_id(HAL_SPI_ID_PHY, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_PHY]);
return ret;
}
int hal_spiphy_recv(const void *cmd, void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_PHY])) {
return -31;
}
ret = hal_spi_recv_id(HAL_SPI_ID_PHY, cmd, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_PHY]);
return ret;
}
#endif // CHIP_HAS_SPIPHY
#ifdef CHIP_HAS_SPIDPD
//------------------------------------------------------------
// SPI DPD functions
//------------------------------------------------------------
int hal_spidpd_open(const struct HAL_SPI_CFG_T *cfg) {
SPI_ASSERT(cfg->rx_frame_bits == 0, "SPIDPD: Bad bits cfg");
return hal_spi_open_id(HAL_SPI_ID_DPD, cfg, &spidpd_ctrl);
}
int hal_spidpd_close(uint32_t cs) {
return hal_spi_close_id(HAL_SPI_ID_DPD, cs);
}
void hal_spidpd_activate_cs(uint32_t cs) {
SPI_ASSERT(cs < HAL_SPI_CS_QTY, "SPIDPD: SPI cs bad: %d", cs);
hal_spi_set_cs_id(HAL_SPI_ID_DPD, cs);
}
int hal_spidpd_busy(void) { return hal_spi_busy_id(HAL_SPI_ID_DPD); }
int hal_spidpd_send(const void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_DPD])) {
return -31;
}
ret = hal_spi_send_id(HAL_SPI_ID_DPD, data, len);
clear_bool_flag(&in_use[HAL_SPI_ID_DPD]);
return ret;
}
int hal_spidpd_recv(const void *cmd, void *data, uint32_t len) {
int ret;
if (set_bool_flag(&in_use[HAL_SPI_ID_DPD])) {
return -31;
}
hal_spi_set_xfer_type_id(HAL_SPI_ID_DPD, &spidpd_ctrl,
HAL_SPI_XFER_TYPE_RECV);
ret = hal_spi_recv_id(HAL_SPI_ID_DPD, cmd, data, len);
hal_spi_set_xfer_type_id(HAL_SPI_ID_DPD, &spidpd_ctrl,
HAL_SPI_XFER_TYPE_SEND);
clear_bool_flag(&in_use[HAL_SPI_ID_DPD]);
return ret;
}
#endif // CHIP_HAS_SPIDPD
#endif // !SPI_ROM_ONLY
Reference in a new issue View git blame Copy permalink