TurboSPI_SAM3X.cpp

#include "TurboSPI.h"

#if defined(__SAM3X8E__) || defined(__SAM3X8H__)
/** Use SAM3X DMAC if nonzero */
#define USE_SAM3X_DMAC 1
/** Use extra Bus Matrix arbitration fix if nonzero */
#define USE_SAM3X_BUS_MATRIX_FIX 0
/** Time in ms for DMA receive timeout */
#define SAM3X_DMA_TIMEOUT 100
/** chip select register number */
#define SPI_CHIP_SEL 3
/** DMAC receive channel */
#define SPI_DMAC_RX_CH  1
/** DMAC transmit channel */
#define SPI_DMAC_TX_CH  0
/** DMAC Channel HW Interface Number for SPI TX. */
#define SPI_TX_IDX  1
/** DMAC Channel HW Interface Number for SPI RX. */
#define SPI_RX_IDX  2

//------------------------------------------------------------------------------
/** Disable DMA Controller. */
static void DMAC_Disable()
{
	DMAC->DMAC_EN &= (~DMAC_EN_ENABLE);
}
/** Enable DMA Controller. */
static void DMAC_Enable()
{
	DMAC->DMAC_EN = DMAC_EN_ENABLE;
}
/** Disable DMA Channel. */
static void DMAC_ChannelDisable(uint32_t ul_num)
{
	DMAC->DMAC_CHDR = DMAC_CHDR_DIS0 << ul_num;
}
/** Enable DMA Channel. */
static void DMAC_ChannelEnable(uint32_t ul_num)
{
	DMAC->DMAC_CHER = DMAC_CHER_ENA0 << ul_num;
}
/** Poll for transfer complete. */
static bool DMAC_ChannelTransferDone(uint32_t ul_num)
{
	return (DMAC->DMAC_CHSR & (DMAC_CHSR_ENA0 << ul_num)) ? false : true;
}

//------------------------------------------------------------------------------
// start RX DMA
static void SPI_DMA_Receive(uint8_t * dst, uint16_t count)
{
	DMAC_ChannelDisable(SPI_DMAC_RX_CH);
	DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_SADDR = (uint32_t)&SPI0->SPI_RDR;
	DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_DADDR = (uint32_t)dst;
	DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_DSCR = 0;
	DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CTRLA = count |
		DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_BYTE;
	DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CTRLB = DMAC_CTRLB_SRC_DSCR |
		DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_PER2MEM_DMA_FC |
		DMAC_CTRLB_SRC_INCR_FIXED | DMAC_CTRLB_DST_INCR_INCREMENTING;
	DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CFG = DMAC_CFG_SRC_PER(SPI_RX_IDX) |
		DMAC_CFG_SRC_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ASAP_CFG;
	DMAC_ChannelEnable(SPI_DMAC_RX_CH);
}
//------------------------------------------------------------------------------
// start TX DMA
static void SPI_DMA_Transfer(const uint8_t * src, uint16_t count)
{
	static uint8_t ff = 0XFF;
	uint32_t src_incr = DMAC_CTRLB_SRC_INCR_INCREMENTING;
	if (!src)
	{
		src = &ff;
		src_incr = DMAC_CTRLB_SRC_INCR_FIXED;
	}
	DMAC_ChannelDisable(SPI_DMAC_TX_CH);
	DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_SADDR = (uint32_t)src;
	DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_DADDR = (uint32_t)&SPI0->SPI_TDR;
	DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_DSCR = 0;
	DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CTRLA = count |
		DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_BYTE;

	DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CTRLB = DMAC_CTRLB_SRC_DSCR |
		DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_MEM2PER_DMA_FC |
		src_incr | DMAC_CTRLB_DST_INCR_FIXED;

	DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CFG = DMAC_CFG_DST_PER(SPI_TX_IDX) |
		DMAC_CFG_DST_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ALAP_CFG;

	DMAC_ChannelEnable(SPI_DMAC_TX_CH);
}

//------------------------------------------------------------------------------
static inline uint8_t SPI_Transfer(uint8_t b)
{
	Spi* pSpi = SPI0;

	pSpi->SPI_TDR = b;
	while ((pSpi->SPI_SR & SPI_SR_RDRF) == 0)
		;
	b = pSpi->SPI_RDR;
	return b;
}

//------------------------------------------------------------------------------
void TurboSPI::Begin()
{
	PIO_Configure(
		g_APinDescription[PIN_SPI_MOSI].pPort,
		g_APinDescription[PIN_SPI_MOSI].ulPinType,
		g_APinDescription[PIN_SPI_MOSI].ulPin,
		g_APinDescription[PIN_SPI_MOSI].ulPinConfiguration);
	PIO_Configure(
		g_APinDescription[PIN_SPI_MISO].pPort,
		g_APinDescription[PIN_SPI_MISO].ulPinType,
		g_APinDescription[PIN_SPI_MISO].ulPin,
		g_APinDescription[PIN_SPI_MISO].ulPinConfiguration);
	PIO_Configure(
		g_APinDescription[PIN_SPI_SCK].pPort,
		g_APinDescription[PIN_SPI_SCK].ulPinType,
		g_APinDescription[PIN_SPI_SCK].ulPin,
		g_APinDescription[PIN_SPI_SCK].ulPinConfiguration);
	pmc_enable_periph_clk(ID_SPI0);
#if USE_SAM3X_DMAC
	pmc_enable_periph_clk(ID_DMAC);
	DMAC_Disable();
	DMAC->DMAC_GCFG = DMAC_GCFG_ARB_CFG_FIXED;
	DMAC_Enable();
#if USE_SAM3X_BUS_MATRIX_FIX
	MATRIX->MATRIX_WPMR = 0x4d415400;
	MATRIX->MATRIX_MCFG[1] = 1;
	MATRIX->MATRIX_MCFG[2] = 1;
	MATRIX->MATRIX_SCFG[0] = 0x01000010;
	MATRIX->MATRIX_SCFG[1] = 0x01000010;
	MATRIX->MATRIX_SCFG[7] = 0x01000010;
#endif  // USE_SAM3X_BUS_MATRIX_FIX
#endif  // USE_SAM3X_DMAC

	Init(2);
}

//------------------------------------------------------------------------------
//  initialize SPI controller
void TurboSPI::Init(uint8_t sckDivisor)
{
	uint8_t scbr = sckDivisor;
	Spi* pSpi = SPI0;
	//  disable SPI
	pSpi->SPI_CR = SPI_CR_SPIDIS;
	// reset SPI
	pSpi->SPI_CR = SPI_CR_SWRST;
	// no mode fault detection, set master mode
	pSpi->SPI_MR = SPI_PCS(SPI_CHIP_SEL) | SPI_MR_MODFDIS | SPI_MR_MSTR;
	// mode 0, 8-bit,
	pSpi->SPI_CSR[SPI_CHIP_SEL] = SPI_CSR_SCBR(scbr) | SPI_CSR_NCPHA;
	// enable SPI
	pSpi->SPI_CR |= SPI_CR_SPIEN;
}

//------------------------------------------------------------------------------
/** SPI receive a byte */
uint8_t TurboSPI::Receive()
{
	return SPI_Transfer(0XFF);
}

//------------------------------------------------------------------------------
/** SPI receive multiple bytes */
uint8_t TurboSPI::Receive(uint8_t * buf, size_t n)
{
	Spi* pSpi = SPI0;
	int rtn = 0;
#if USE_SAM3X_DMAC
	// clear overrun error
	uint32_t s = pSpi->SPI_SR;

	SPI_DMA_Receive(buf, n);
	SPI_DMA_Transfer(0, n);

	uint32_t m = millis();
	while (!DMAC_ChannelTransferDone(SPI_DMAC_RX_CH))
	{
		if ((millis() - m) > SAM3X_DMA_TIMEOUT)
		{
			DMAC_ChannelDisable(SPI_DMAC_RX_CH);
			DMAC_ChannelDisable(SPI_DMAC_TX_CH);
			rtn = 2;
			break;
		}
	}
	if (pSpi->SPI_SR & SPI_SR_OVRES)
	{
		rtn |= 1;
	}
#else  // USE_SAM3X_DMAC
	for (size_t i = 0; i < n; ++i)
	{
		pSpi->SPI_TDR = 0XFF;
		while ((pSpi->SPI_SR & SPI_SR_RDRF) == 0)
			;
		buf[i] = pSpi->SPI_RDR;
	}
#endif  // USE_SAM3X_DMAC
	return rtn;
}

//------------------------------------------------------------------------------
/** SPI send a byte */
void TurboSPI::Send(uint8_t b)
{
	SPI_Transfer(b);
}

//------------------------------------------------------------------------------
void TurboSPI::Send(const uint8_t * buf, size_t n)
{
	Spi* pSpi = SPI0;
#if USE_SAM3X_DMAC
	static const size_t DMABufSize = 4095;
	while (n > DMABufSize)
	{
		SPI_DMA_Transfer(buf, DMABufSize);
		while (!DMAC_ChannelTransferDone(SPI_DMAC_TX_CH))
			;
		n -= DMABufSize;
		buf += DMABufSize;
	}
	SPI_DMA_Transfer(buf, n);
	while (!DMAC_ChannelTransferDone(SPI_DMAC_TX_CH))
		;
#else  // #if USE_SAM3X_DMAC
	while ((pSpi->SPI_SR & SPI_SR_TXEMPTY) == 0)
		;
	for (size_t i = 0; i < n; ++i)
	{
		pSpi->SPI_TDR = buf[i];
		while ((pSpi->SPI_SR & SPI_SR_TDRE) == 0)
			;
	}
#endif  // #if USE_SAM3X_DMAC
	while ((pSpi->SPI_SR & SPI_SR_TXEMPTY) == 0)
		;
	// leave RDR empty
	uint8_t b = pSpi->SPI_RDR;
}

//////////////////////////////////////////////////////////////////////////
DigitalPin::DigitalPin()
	: m_Pin(0)
	, m_Port(0)
	, m_Mask(0)
{
}

void DigitalPin::Begin(uint8_t pinID)
{
	m_Pin = pinID;
	m_Port = digitalPinToPort(m_Pin);
	m_Mask = digitalPinToBitMask(m_Pin);
}

void DigitalPin::PinMode(uint8_t dwMode)
{
	pinMode(m_Pin, dwMode);
}

void DigitalPin::High()
{
	m_Port->PIO_SODR |= m_Mask;
}

void DigitalPin::Low()
{
	m_Port->PIO_CODR |= m_Mask;
}

#endif  // defined(__SAM3X8E__) || defined(__SAM3X8H__)