forked from wirtz/BALibrary
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1025 lines
27 KiB
1025 lines
27 KiB
6 years ago
|
#ifndef DMASPI_H
|
||
|
#define DMASPI_H
|
||
|
|
||
|
#include <Arduino.h>
|
||
|
#include <util/atomic.h>
|
||
|
|
||
|
#if(!defined(__arm__) && defined(TEENSYDUINO))
|
||
|
#error This library is for teensyduino 1.21 on Teensy 3.0, 3.1 and Teensy LC only.
|
||
|
#endif
|
||
|
|
||
|
#include <SPI.h>
|
||
|
#include "DMAChannel.h"
|
||
|
#include <core_pins.h>
|
||
|
|
||
|
|
||
|
/** \brief Specifies the desired CS suppression
|
||
|
**/
|
||
|
enum TransferType
|
||
|
{
|
||
|
NORMAL, //*< The transfer will use CS at beginning and end **/
|
||
|
NO_START_CS, //*< Skip the CS activation at the start **/
|
||
|
NO_END_CS //*< SKip the CS deactivation at the end **/
|
||
|
};
|
||
|
|
||
|
/** \brief An abstract base class that provides an interface for chip select classes.
|
||
|
**/
|
||
|
class AbstractChipSelect
|
||
|
{
|
||
|
public:
|
||
|
/** \brief Called to select a chip. The implementing class can do other things as well.
|
||
|
**/
|
||
|
virtual void select(TransferType transferType = TransferType::NORMAL) = 0;
|
||
|
|
||
|
/** \brief Called to deselect a chip. The implementing class can do other things as well.
|
||
|
**/
|
||
|
virtual void deselect(TransferType transferType = TransferType::NORMAL) = 0;
|
||
|
|
||
|
/** \brief the virtual destructor needed to inherit from this class **/
|
||
|
virtual ~AbstractChipSelect() {}
|
||
|
};
|
||
|
|
||
|
|
||
|
/** \brief "do nothing" chip select class **/
|
||
|
class DummyChipSelect : public AbstractChipSelect
|
||
|
{
|
||
|
void select(TransferType transferType = TransferType::NORMAL) override {}
|
||
|
|
||
|
void deselect(TransferType transferType = TransferType::NORMAL) override {}
|
||
|
};
|
||
|
|
||
|
/** \brief "do nothing" chip select class that
|
||
|
* outputs a message through Serial when something happens
|
||
|
**/
|
||
|
class DebugChipSelect : public AbstractChipSelect
|
||
|
{
|
||
|
void select(TransferType transferType = TransferType::NORMAL) override {Serial.println("Debug CS: select()");}
|
||
|
void deselect(TransferType transferType = TransferType::NORMAL) override {Serial.println("Debug CS: deselect()");}
|
||
|
};
|
||
|
|
||
|
/** \brief An active low chip select class. This also configures the given pin.
|
||
|
* Warning: This class is hardcoded to manage a transaction on SPI (SPI0, that is).
|
||
|
* If you want to use SPI1: Use AbstractChipSelect1 (see below)
|
||
|
* If you want to use SPI2: Create AbstractChipSelect2 (adapt the implementation accordingly).
|
||
|
* Something more flexible is on the way.
|
||
|
**/
|
||
|
class ActiveLowChipSelect : public AbstractChipSelect
|
||
|
{
|
||
|
public:
|
||
|
/** Configures a chip select pin for OUTPUT mode,
|
||
|
* manages the chip selection and a corresponding SPI transaction
|
||
|
*
|
||
|
* The chip select pin is asserted \e after the SPI settings are applied
|
||
|
* and deasserted before the SPI transaction ends.
|
||
|
* \param pin the CS pin to use
|
||
|
* \param settings which SPI settings to apply when the chip is selected
|
||
|
**/
|
||
|
ActiveLowChipSelect(const unsigned int& pin, const SPISettings& settings)
|
||
|
: pin_(pin),
|
||
|
settings_(settings)
|
||
|
{
|
||
|
pinMode(pin, OUTPUT);
|
||
|
digitalWriteFast(pin, 1);
|
||
|
}
|
||
|
|
||
|
/** \brief begins an SPI transaction selects the chip (sets the pin to low) and
|
||
|
**/
|
||
|
void select(TransferType transferType = TransferType::NORMAL) override
|
||
|
{
|
||
|
SPI.beginTransaction(settings_);
|
||
|
if (transferType == TransferType::NO_START_CS) {
|
||
|
return;
|
||
|
}
|
||
|
digitalWriteFast(pin_, 0);
|
||
|
}
|
||
|
|
||
|
/** \brief deselects the chip (sets the pin to high) and ends the SPI transaction
|
||
|
**/
|
||
|
void deselect(TransferType transferType = TransferType::NORMAL) override
|
||
|
{
|
||
|
if (transferType == TransferType::NO_END_CS) {
|
||
|
} else {
|
||
|
digitalWriteFast(pin_, 1);
|
||
|
}
|
||
|
SPI.endTransaction();
|
||
|
}
|
||
|
private:
|
||
|
const unsigned int pin_;
|
||
|
const SPISettings settings_;
|
||
|
|
||
|
};
|
||
|
|
||
|
#if defined(__MK66FX1M0__)
|
||
|
class ActiveLowChipSelect1 : public AbstractChipSelect
|
||
|
{
|
||
|
public:
|
||
|
/** Equivalent to AbstractChipSelect, but for SPI1.
|
||
|
**/
|
||
|
ActiveLowChipSelect1(const unsigned int& pin, const SPISettings& settings)
|
||
|
: pin_(pin),
|
||
|
settings_(settings)
|
||
|
{
|
||
|
pinMode(pin, OUTPUT);
|
||
|
digitalWriteFast(pin, 1);
|
||
|
}
|
||
|
|
||
|
/** \brief begins an SPI transaction selects the chip (sets the pin to low) and
|
||
|
**/
|
||
|
void select(TransferType transferType = TransferType::NORMAL) override
|
||
|
{
|
||
|
SPI1.beginTransaction(settings_);
|
||
|
if (transferType == TransferType::NO_START_CS) {
|
||
|
return;
|
||
|
}
|
||
|
digitalWriteFast(pin_, 0);
|
||
|
}
|
||
|
|
||
|
/** \brief deselects the chip (sets the pin to high) and ends the SPI transaction
|
||
|
**/
|
||
|
void deselect(TransferType transferType = TransferType::NORMAL) override
|
||
|
{
|
||
|
if (transferType == TransferType::NO_END_CS) {
|
||
|
} else {
|
||
|
digitalWriteFast(pin_, 1);
|
||
|
}
|
||
|
SPI1.endTransaction();
|
||
|
}
|
||
|
private:
|
||
|
const unsigned int pin_;
|
||
|
const SPISettings settings_;
|
||
|
|
||
|
};
|
||
|
#endif
|
||
|
|
||
|
|
||
|
//#define DEBUG_DMASPI 1
|
||
|
|
||
|
#if defined(DEBUG_DMASPI)
|
||
|
#define DMASPI_PRINT(x) do {Serial.printf x ; Serial.flush();} while (0);
|
||
|
#else
|
||
|
#define DMASPI_PRINT(x) do {} while (0);
|
||
|
#endif
|
||
|
|
||
|
namespace DmaSpi
|
||
|
{
|
||
|
/** \brief describes an SPI transfer
|
||
|
*
|
||
|
* Transfers are kept in a queue (intrusive linked list) until they are processed by the DmaSpi driver.
|
||
|
*
|
||
|
**/
|
||
|
class Transfer
|
||
|
{
|
||
|
public:
|
||
|
/** \brief The Transfer's current state.
|
||
|
*
|
||
|
**/
|
||
|
enum State
|
||
|
{
|
||
|
idle, /**< The Transfer is idle, the DmaSpi has not seen it yet. **/
|
||
|
eDone, /**< The Transfer is done. **/
|
||
|
pending, /**< Queued, but not handled yet. **/
|
||
|
inProgress, /**< The DmaSpi driver is currently busy executing this Transfer. **/
|
||
|
error /**< An error occured. **/
|
||
|
};
|
||
|
|
||
|
/** \brief Creates a Transfer object.
|
||
|
* \param pSource pointer to the data source. If this is nullptr, the fill value is used instead.
|
||
|
* \param transferCount the number of SPI transfers to perform.
|
||
|
* \param pDest pointer to the data sink. If this is nullptr, data received from the slave will be discarded.
|
||
|
* \param fill if pSource is nullptr, this value is sent to the slave instead.
|
||
|
* \param cs pointer to a chip select object.
|
||
|
* If not nullptr, cs->select() is called when the Transfer is started and cs->deselect() is called when the Transfer is finished.
|
||
|
**/
|
||
|
Transfer(const uint8_t* pSource = nullptr,
|
||
|
const uint16_t& transferCount = 0,
|
||
|
volatile uint8_t* pDest = nullptr,
|
||
|
const uint8_t& fill = 0,
|
||
|
AbstractChipSelect* cs = nullptr,
|
||
|
TransferType transferType = TransferType::NORMAL
|
||
|
) : m_state(State::idle),
|
||
|
m_pSource(pSource),
|
||
|
m_transferCount(transferCount),
|
||
|
m_pDest(pDest),
|
||
|
m_fill(fill),
|
||
|
m_pNext(nullptr),
|
||
|
m_pSelect(cs),
|
||
|
m_transferType(transferType)
|
||
|
{
|
||
|
DMASPI_PRINT(("Transfer @ %p\n", this));
|
||
|
};
|
||
|
|
||
|
/** \brief Check if the Transfer is busy, i.e. may not be modified.
|
||
|
**/
|
||
|
bool busy() const {return ((m_state == State::pending) || (m_state == State::inProgress) || (m_state == State::error));}
|
||
|
|
||
|
/** \brief Check if the Transfer is done.
|
||
|
**/
|
||
|
bool done() const {return (m_state == State::eDone);}
|
||
|
|
||
|
// private:
|
||
|
volatile State m_state;
|
||
|
const uint8_t* m_pSource;
|
||
|
uint16_t m_transferCount;
|
||
|
volatile uint8_t* m_pDest;
|
||
|
uint8_t m_fill;
|
||
|
Transfer* m_pNext;
|
||
|
AbstractChipSelect* m_pSelect;
|
||
|
TransferType m_transferType;
|
||
|
};
|
||
|
} // namespace DmaSpi
|
||
|
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
class AbstractDmaSpi
|
||
|
{
|
||
|
public:
|
||
|
using Transfer = DmaSpi::Transfer;
|
||
|
|
||
|
/** \brief arduino-style initialization.
|
||
|
*
|
||
|
* During initialization, two DMA channels are allocated. If that fails, this function returns false.
|
||
|
* If the channels could be allocated, those DMA channel fields that don't change during DMA SPI operation
|
||
|
* are initialized to the values they will have at runtime.
|
||
|
*
|
||
|
* \return true if initialization was successful; false otherwise.
|
||
|
* \see end()
|
||
|
**/
|
||
|
static bool begin()
|
||
|
{
|
||
|
if(init_count_ > 0)
|
||
|
{
|
||
|
return true; // this is not particularly bad, so we can return true
|
||
|
}
|
||
|
init_count_++;
|
||
|
DMASPI_PRINT(("DmaSpi::begin() : "));
|
||
|
// create DMA channels, might fail
|
||
|
if (!createDmaChannels())
|
||
|
{
|
||
|
DMASPI_PRINT(("could not create DMA channels\n"));
|
||
|
return false;
|
||
|
}
|
||
|
state_ = eStopped;
|
||
|
// tx: known destination (SPI), no interrupt, finish silently
|
||
|
begin_setup_txChannel();
|
||
|
if (txChannel_()->error())
|
||
|
{
|
||
|
destroyDmaChannels();
|
||
|
DMASPI_PRINT(("tx channel error\n"));
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// rx: known source (SPI), interrupt on completion
|
||
|
begin_setup_rxChannel();
|
||
|
if (rxChannel_()->error())
|
||
|
{
|
||
|
destroyDmaChannels();
|
||
|
DMASPI_PRINT(("rx channel error\n"));
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
static void begin_setup_txChannel() {DMASPI_INSTANCE::begin_setup_txChannel_impl();}
|
||
|
static void begin_setup_rxChannel() {DMASPI_INSTANCE::begin_setup_rxChannel_impl();}
|
||
|
|
||
|
/** \brief Allow the DMA SPI to start handling Transfers. This must be called after begin().
|
||
|
* \see running()
|
||
|
* \see busy()
|
||
|
* \see stop()
|
||
|
* \see stopping()
|
||
|
* \see stopped()
|
||
|
**/
|
||
|
static void start()
|
||
|
{
|
||
|
DMASPI_PRINT(("DmaSpi::start() : state_ = "));
|
||
|
switch(state_)
|
||
|
{
|
||
|
case eStopped:
|
||
|
DMASPI_PRINT(("eStopped\n"));
|
||
|
state_ = eRunning;
|
||
|
beginPendingTransfer();
|
||
|
break;
|
||
|
|
||
|
case eRunning:
|
||
|
DMASPI_PRINT(("eRunning\n"));
|
||
|
break;
|
||
|
|
||
|
case eStopping:
|
||
|
DMASPI_PRINT(("eStopping\n"));
|
||
|
state_ = eRunning;
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
DMASPI_PRINT(("unknown\n"));
|
||
|
state_ = eError;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/** \brief check if the DMA SPI is in running state.
|
||
|
* \return true if the DMA SPI is in running state, false otherwise.
|
||
|
* \see start()
|
||
|
* \see busy()
|
||
|
* \see stop()
|
||
|
* \see stopping()
|
||
|
* \see stopped()
|
||
|
**/
|
||
|
static bool running() {return state_ == eRunning;}
|
||
|
|
||
|
/** \brief register a Transfer to be handled by the DMA SPI.
|
||
|
* \return false if the Transfer had an invalid transfer count (zero or greater than 32767), true otherwise.
|
||
|
* \post the Transfer state is Transfer::State::pending, or Transfer::State::error if the transfer count was invalid.
|
||
|
**/
|
||
|
static bool registerTransfer(Transfer& transfer)
|
||
|
{
|
||
|
DMASPI_PRINT(("DmaSpi::registerTransfer(%p)\n", &transfer));
|
||
|
if ((transfer.busy())
|
||
|
|| (transfer.m_transferCount == 0) // no zero length transfers allowed
|
||
|
|| (transfer.m_transferCount >= 0x8000)) // max CITER/BITER count with ELINK = 0 is 0x7FFF, so reject
|
||
|
{
|
||
|
DMASPI_PRINT((" Transfer is busy or invalid, dropped\n"));
|
||
|
transfer.m_state = Transfer::State::error;
|
||
|
return false;
|
||
|
}
|
||
|
addTransferToQueue(transfer);
|
||
|
if ((state_ == eRunning) && (!busy()))
|
||
|
{
|
||
|
DMASPI_PRINT((" starting transfer\n"));
|
||
|
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
|
||
|
{
|
||
|
beginPendingTransfer();
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
|
||
|
/** \brief Check if the DMA SPI is busy, which means that it is currently handling a Transfer.
|
||
|
\return true if a Transfer is being handled.
|
||
|
* \see start()
|
||
|
* \see running()
|
||
|
* \see stop()
|
||
|
* \see stopping()
|
||
|
* \see stopped()
|
||
|
**/
|
||
|
static bool busy()
|
||
|
{
|
||
|
return (m_pCurrentTransfer != nullptr);
|
||
|
}
|
||
|
|
||
|
/** \brief Request the DMA SPI to stop handling Transfers.
|
||
|
*
|
||
|
* The stopping driver may finish a current Transfer, but it will then not start a new, pending one.
|
||
|
* \see start()
|
||
|
* \see running()
|
||
|
* \see busy()
|
||
|
* \see stopping()
|
||
|
* \see stopped()
|
||
|
**/
|
||
|
static void stop()
|
||
|
{
|
||
|
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
|
||
|
{
|
||
|
switch(state_)
|
||
|
{
|
||
|
case eStopped:
|
||
|
break;
|
||
|
case eRunning:
|
||
|
if (busy())
|
||
|
{
|
||
|
state_ = eStopping;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// this means that the DMA SPI simply has nothing to do
|
||
|
state_ = eStopped;
|
||
|
}
|
||
|
break;
|
||
|
case eStopping:
|
||
|
break;
|
||
|
default:
|
||
|
state_ = eError;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/** \brief See if the DMA SPI is currently switching from running to stopped state
|
||
|
* \return true if the DMA SPI is switching from running to stopped state
|
||
|
* \see start()
|
||
|
* \see running()
|
||
|
* \see busy()
|
||
|
* \see stop()
|
||
|
* \see stopped()
|
||
|
**/
|
||
|
static bool stopping() { return (state_ == eStopping); }
|
||
|
|
||
|
/** \brief See if the DMA SPI is stopped
|
||
|
* \return true if the DMA SPI is in stopped state, i.e. not handling pending Transfers
|
||
|
* \see start()
|
||
|
* \see running()
|
||
|
* \see busy()
|
||
|
* \see stop()
|
||
|
* \see stopping()
|
||
|
**/
|
||
|
static bool stopped() { return (state_ == eStopped); }
|
||
|
|
||
|
/** \brief Shut down the DMA SPI
|
||
|
*
|
||
|
* Deallocates DMA channels and sets the internal state to error (this might not be an intelligent name for that)
|
||
|
* \see begin()
|
||
|
**/
|
||
|
static void end()
|
||
|
{
|
||
|
if (init_count_ == 0)
|
||
|
{
|
||
|
state_ = eError;
|
||
|
return;
|
||
|
}
|
||
|
if (init_count_ == 1)
|
||
|
{
|
||
|
init_count_--;
|
||
|
destroyDmaChannels();
|
||
|
state_ = eError;
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
init_count_--;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/** \brief get the last value that was read from a slave, but discarded because the Transfer didn't specify a sink
|
||
|
**/
|
||
|
static uint8_t devNull()
|
||
|
{
|
||
|
return m_devNull;
|
||
|
}
|
||
|
|
||
|
protected:
|
||
|
enum EState
|
||
|
{
|
||
|
eStopped,
|
||
|
eRunning,
|
||
|
eStopping,
|
||
|
eError
|
||
|
};
|
||
|
|
||
|
static void addTransferToQueue(Transfer& transfer)
|
||
|
{
|
||
|
transfer.m_state = Transfer::State::pending;
|
||
|
transfer.m_pNext = nullptr;
|
||
|
DMASPI_PRINT((" DmaSpi::addTransferToQueue() : queueing transfer\n"));
|
||
|
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
|
||
|
{
|
||
|
if (m_pNextTransfer == nullptr)
|
||
|
{
|
||
|
m_pNextTransfer = &transfer;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_pLastTransfer->m_pNext = &transfer;
|
||
|
}
|
||
|
m_pLastTransfer = &transfer;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void post_finishCurrentTransfer() {DMASPI_INSTANCE::post_finishCurrentTransfer_impl();}
|
||
|
|
||
|
static void finishCurrentTransfer()
|
||
|
{
|
||
|
if (m_pCurrentTransfer->m_pSelect != nullptr)
|
||
|
{
|
||
|
m_pCurrentTransfer->m_pSelect->deselect(m_pCurrentTransfer->m_transferType);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_Spi.endTransaction();
|
||
|
}
|
||
|
m_pCurrentTransfer->m_state = Transfer::State::eDone;
|
||
|
DMASPI_PRINT((" finishCurrentTransfer() @ %p\n", m_pCurrentTransfer));
|
||
|
m_pCurrentTransfer = nullptr;
|
||
|
post_finishCurrentTransfer();
|
||
|
}
|
||
|
|
||
|
static bool createDmaChannels()
|
||
|
{
|
||
|
if (txChannel_() == nullptr)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
if (rxChannel_() == nullptr)
|
||
|
{
|
||
|
delete txChannel_();
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
static void destroyDmaChannels()
|
||
|
{
|
||
|
if (rxChannel_() != nullptr)
|
||
|
{
|
||
|
delete rxChannel_();
|
||
|
}
|
||
|
if (txChannel_() != nullptr)
|
||
|
{
|
||
|
delete txChannel_();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static DMAChannel* rxChannel_()
|
||
|
{
|
||
|
static DMAChannel* pChannel = new DMAChannel();
|
||
|
return pChannel;
|
||
|
}
|
||
|
|
||
|
static DMAChannel* txChannel_()
|
||
|
{
|
||
|
static DMAChannel* pChannel = new DMAChannel();
|
||
|
return pChannel;
|
||
|
}
|
||
|
|
||
|
static void rxIsr_()
|
||
|
{
|
||
|
DMASPI_PRINT(("DmaSpi::rxIsr_()\n"));
|
||
|
rxChannel_()->clearInterrupt();
|
||
|
// end current transfer: deselect and mark as done
|
||
|
finishCurrentTransfer();
|
||
|
|
||
|
DMASPI_PRINT((" state = "));
|
||
|
switch(state_)
|
||
|
{
|
||
|
case eStopped: // this should not happen!
|
||
|
DMASPI_PRINT(("eStopped\n"));
|
||
|
state_ = eError;
|
||
|
break;
|
||
|
case eRunning:
|
||
|
DMASPI_PRINT(("eRunning\n"));
|
||
|
beginPendingTransfer();
|
||
|
break;
|
||
|
case eStopping:
|
||
|
DMASPI_PRINT(("eStopping\n"));
|
||
|
state_ = eStopped;
|
||
|
break;
|
||
|
case eError:
|
||
|
DMASPI_PRINT(("eError\n"));
|
||
|
break;
|
||
|
default:
|
||
|
DMASPI_PRINT(("eUnknown\n"));
|
||
|
state_ = eError;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void pre_cs() {DMASPI_INSTANCE::pre_cs_impl();}
|
||
|
static void post_cs() {DMASPI_INSTANCE::post_cs_impl();}
|
||
|
|
||
|
static void beginPendingTransfer()
|
||
|
{
|
||
|
if (m_pNextTransfer == nullptr)
|
||
|
{
|
||
|
DMASPI_PRINT(("DmaSpi::beginNextTransfer: no pending transfer\n"));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
m_pCurrentTransfer = m_pNextTransfer;
|
||
|
DMASPI_PRINT(("DmaSpi::beginNextTransfer: starting transfer @ %p\n", m_pCurrentTransfer));
|
||
|
m_pCurrentTransfer->m_state = Transfer::State::inProgress;
|
||
|
m_pNextTransfer = m_pNextTransfer->m_pNext;
|
||
|
if (m_pNextTransfer == nullptr)
|
||
|
{
|
||
|
DMASPI_PRINT((" this was the last in the queue\n"));
|
||
|
m_pLastTransfer = nullptr;
|
||
|
}
|
||
|
|
||
|
// configure Rx DMA
|
||
|
if (m_pCurrentTransfer->m_pDest != nullptr)
|
||
|
{
|
||
|
// real data sink
|
||
|
DMASPI_PRINT((" real sink\n"));
|
||
|
rxChannel_()->destinationBuffer(m_pCurrentTransfer->m_pDest,
|
||
|
m_pCurrentTransfer->m_transferCount);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// dummy data sink
|
||
|
DMASPI_PRINT((" dummy sink\n"));
|
||
|
rxChannel_()->destination(m_devNull);
|
||
|
rxChannel_()->transferCount(m_pCurrentTransfer->m_transferCount);
|
||
|
}
|
||
|
|
||
|
// configure Tx DMA
|
||
|
if (m_pCurrentTransfer->m_pSource != nullptr)
|
||
|
{
|
||
|
// real data source
|
||
|
DMASPI_PRINT((" real source\n"));
|
||
|
txChannel_()->sourceBuffer(m_pCurrentTransfer->m_pSource,
|
||
|
m_pCurrentTransfer->m_transferCount);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// dummy data source
|
||
|
DMASPI_PRINT((" dummy source\n"));
|
||
|
txChannel_()->source(m_pCurrentTransfer->m_fill);
|
||
|
txChannel_()->transferCount(m_pCurrentTransfer->m_transferCount);
|
||
|
}
|
||
|
|
||
|
pre_cs();
|
||
|
|
||
|
// Select Chip
|
||
|
if (m_pCurrentTransfer->m_pSelect != nullptr)
|
||
|
{
|
||
|
m_pCurrentTransfer->m_pSelect->select(m_pCurrentTransfer->m_transferType);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_Spi.beginTransaction(SPISettings());
|
||
|
}
|
||
|
|
||
|
post_cs();
|
||
|
}
|
||
|
|
||
|
static size_t init_count_;
|
||
|
static volatile EState state_;
|
||
|
static Transfer* volatile m_pCurrentTransfer;
|
||
|
static Transfer* volatile m_pNextTransfer;
|
||
|
static Transfer* volatile m_pLastTransfer;
|
||
|
static volatile uint8_t m_devNull;
|
||
|
//static SPICLASS& m_Spi;
|
||
|
};
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
size_t AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::init_count_ = 0;
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
volatile typename AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::EState AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::state_ = eError;
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
typename AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::Transfer* volatile AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::m_pNextTransfer = nullptr;
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
typename AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::Transfer* volatile AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::m_pCurrentTransfer = nullptr;
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
typename AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::Transfer* volatile AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::m_pLastTransfer = nullptr;
|
||
|
|
||
|
template<typename DMASPI_INSTANCE, typename SPICLASS, SPICLASS& m_Spi>
|
||
|
volatile uint8_t AbstractDmaSpi<DMASPI_INSTANCE, SPICLASS, m_Spi>::m_devNull = 0;
|
||
|
|
||
|
#if defined(KINETISK)
|
||
|
|
||
|
class DmaSpi0 : public AbstractDmaSpi<DmaSpi0, SPIClass, SPI>
|
||
|
{
|
||
|
public:
|
||
|
static void begin_setup_txChannel_impl()
|
||
|
{
|
||
|
txChannel_()->disable();
|
||
|
txChannel_()->destination((volatile uint8_t&)SPI0_PUSHR);
|
||
|
txChannel_()->disableOnCompletion();
|
||
|
txChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI0_TX);
|
||
|
}
|
||
|
|
||
|
static void begin_setup_rxChannel_impl()
|
||
|
{
|
||
|
rxChannel_()->disable();
|
||
|
rxChannel_()->source((volatile uint8_t&)SPI0_POPR);
|
||
|
rxChannel_()->disableOnCompletion();
|
||
|
rxChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI0_RX);
|
||
|
rxChannel_()->attachInterrupt(rxIsr_);
|
||
|
rxChannel_()->interruptAtCompletion();
|
||
|
}
|
||
|
|
||
|
static void pre_cs_impl()
|
||
|
{
|
||
|
SPI0_SR = 0xFF0F0000;
|
||
|
SPI0_RSER = SPI_RSER_RFDF_RE | SPI_RSER_RFDF_DIRS | SPI_RSER_TFFF_RE | SPI_RSER_TFFF_DIRS;
|
||
|
}
|
||
|
|
||
|
static void post_cs_impl()
|
||
|
{
|
||
|
rxChannel_()->enable();
|
||
|
txChannel_()->enable();
|
||
|
}
|
||
|
|
||
|
static void post_finishCurrentTransfer_impl()
|
||
|
{
|
||
|
SPI0_RSER = 0;
|
||
|
SPI0_SR = 0xFF0F0000;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
};
|
||
|
|
||
|
extern DmaSpi0 DMASPI0;
|
||
|
|
||
|
#if defined(__MK66FX1M0__)
|
||
|
|
||
|
class DmaSpi1 : public AbstractDmaSpi<DmaSpi1, SPIClass, SPI1>
|
||
|
{
|
||
|
public:
|
||
|
static void begin_setup_txChannel_impl()
|
||
|
{
|
||
|
txChannel_()->disable();
|
||
|
txChannel_()->destination((volatile uint8_t&)SPI1_PUSHR);
|
||
|
txChannel_()->disableOnCompletion();
|
||
|
txChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI1_TX);
|
||
|
}
|
||
|
|
||
|
static void begin_setup_rxChannel_impl()
|
||
|
{
|
||
|
rxChannel_()->disable();
|
||
|
rxChannel_()->source((volatile uint8_t&)SPI1_POPR);
|
||
|
rxChannel_()->disableOnCompletion();
|
||
|
rxChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI1_RX);
|
||
|
rxChannel_()->attachInterrupt(rxIsr_);
|
||
|
rxChannel_()->interruptAtCompletion();
|
||
|
}
|
||
|
|
||
|
static void pre_cs_impl()
|
||
|
{
|
||
|
SPI1_SR = 0xFF0F0000;
|
||
|
SPI1_RSER = SPI_RSER_RFDF_RE | SPI_RSER_RFDF_DIRS | SPI_RSER_TFFF_RE | SPI_RSER_TFFF_DIRS;
|
||
|
}
|
||
|
|
||
|
static void post_cs_impl()
|
||
|
{
|
||
|
rxChannel_()->enable();
|
||
|
txChannel_()->enable();
|
||
|
}
|
||
|
|
||
|
static void post_finishCurrentTransfer_impl()
|
||
|
{
|
||
|
SPI1_RSER = 0;
|
||
|
SPI1_SR = 0xFF0F0000;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
class DmaSpi2 : public AbstractDmaSpi<DmaSpi2, SPIClass, SPI2>
|
||
|
{
|
||
|
public:
|
||
|
static void begin_setup_txChannel_impl()
|
||
|
{
|
||
|
txChannel_()->disable();
|
||
|
txChannel_()->destination((volatile uint8_t&)SPI2_PUSHR);
|
||
|
txChannel_()->disableOnCompletion();
|
||
|
txChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI2_TX);
|
||
|
}
|
||
|
|
||
|
static void begin_setup_rxChannel_impl()
|
||
|
{
|
||
|
rxChannel_()->disable();
|
||
|
rxChannel_()->source((volatile uint8_t&)SPI2_POPR);
|
||
|
rxChannel_()->disableOnCompletion();
|
||
|
rxChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI2_RX);
|
||
|
rxChannel_()->attachInterrupt(rxIsr_);
|
||
|
rxChannel_()->interruptAtCompletion();
|
||
|
}
|
||
|
|
||
|
static void pre_cs_impl()
|
||
|
{
|
||
|
SPI2_SR = 0xFF0F0000;
|
||
|
SPI2_RSER = SPI_RSER_RFDF_RE | SPI_RSER_RFDF_DIRS | SPI_RSER_TFFF_RE | SPI_RSER_TFFF_DIRS;
|
||
|
}
|
||
|
|
||
|
static void post_cs_impl()
|
||
|
{
|
||
|
rxChannel_()->enable();
|
||
|
txChannel_()->enable();
|
||
|
}
|
||
|
|
||
|
static void post_finishCurrentTransfer_impl()
|
||
|
{
|
||
|
SPI2_RSER = 0;
|
||
|
SPI2_SR = 0xFF0F0000;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
};
|
||
|
*/
|
||
|
|
||
|
extern DmaSpi1 DMASPI1;
|
||
|
//extern DmaSpi2 DMASPI2;
|
||
|
#endif // defined(__MK66FX1M0__)
|
||
|
|
||
|
#elif defined(KINETISL)
|
||
|
class DmaSpi0 : public AbstractDmaSpi<DmaSpi0, SPIClass, SPI>
|
||
|
{
|
||
|
public:
|
||
|
static void begin_setup_txChannel_impl()
|
||
|
{
|
||
|
txChannel_()->disable();
|
||
|
txChannel_()->destination((volatile uint8_t&)SPI0_DL);
|
||
|
txChannel_()->disableOnCompletion();
|
||
|
txChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI0_TX);
|
||
|
}
|
||
|
|
||
|
static void begin_setup_rxChannel_impl()
|
||
|
{
|
||
|
rxChannel_()->disable();
|
||
|
rxChannel_()->source((volatile uint8_t&)SPI0_DL);
|
||
|
rxChannel_()->disableOnCompletion();
|
||
|
rxChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI0_RX);
|
||
|
rxChannel_()->attachInterrupt(rxIsr_);
|
||
|
rxChannel_()->interruptAtCompletion();
|
||
|
}
|
||
|
|
||
|
static void pre_cs_impl()
|
||
|
{
|
||
|
// disable SPI and enable SPI DMA requests
|
||
|
SPI0_C1 &= ~(SPI_C1_SPE);
|
||
|
SPI0_C2 |= SPI_C2_TXDMAE | SPI_C2_RXDMAE;
|
||
|
}
|
||
|
|
||
|
static void post_cs_impl()
|
||
|
{
|
||
|
rxChannel_()->enable();
|
||
|
txChannel_()->enable();
|
||
|
}
|
||
|
|
||
|
static void post_finishCurrentTransfer_impl()
|
||
|
{
|
||
|
SPI0_C2 = 0;
|
||
|
txChannel_()->clearComplete();
|
||
|
rxChannel_()->clearComplete();
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
};
|
||
|
|
||
|
class DmaSpi1 : public AbstractDmaSpi<DmaSpi1, SPIClass, SPI1>
|
||
|
{
|
||
|
public:
|
||
|
static void begin_setup_txChannel_impl()
|
||
|
{
|
||
|
txChannel_()->disable();
|
||
|
txChannel_()->destination((volatile uint8_t&)SPI1_DL);
|
||
|
txChannel_()->disableOnCompletion();
|
||
|
txChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI1_TX);
|
||
|
}
|
||
|
|
||
|
static void begin_setup_rxChannel_impl()
|
||
|
{
|
||
|
rxChannel_()->disable();
|
||
|
rxChannel_()->source((volatile uint8_t&)SPI1_DL);
|
||
|
rxChannel_()->disableOnCompletion();
|
||
|
rxChannel_()->triggerAtHardwareEvent(DMAMUX_SOURCE_SPI1_RX);
|
||
|
rxChannel_()->attachInterrupt(rxIsr_);
|
||
|
rxChannel_()->interruptAtCompletion();
|
||
|
}
|
||
|
|
||
|
static void pre_cs_impl()
|
||
|
{
|
||
|
// disable SPI and enable SPI DMA requests
|
||
|
SPI1_C1 &= ~(SPI_C1_SPE);
|
||
|
SPI1_C2 |= SPI_C2_TXDMAE | SPI_C2_RXDMAE;
|
||
|
}
|
||
|
|
||
|
// static void dumpCFG(const char *sz, uint32_t* p)
|
||
|
// {
|
||
|
// DMASPI_PRINT(("%s: %x %x %x %x \n", sz, p[0], p[1], p[2], p[3]));
|
||
|
// }
|
||
|
|
||
|
static void post_cs_impl()
|
||
|
{
|
||
|
DMASPI_PRINT(("post_cs S C1 C2: %x %x %x\n", SPI1_S, SPI1_C1, SPI1_C2));
|
||
|
// dumpCFG("RX", (uint32_t*)(void*)rxChannel_()->CFG);
|
||
|
// dumpCFG("TX", (uint32_t*)(void*)txChannel_()->CFG);
|
||
|
rxChannel_()->enable();
|
||
|
txChannel_()->enable();
|
||
|
}
|
||
|
|
||
|
static void post_finishCurrentTransfer_impl()
|
||
|
{
|
||
|
SPI1_C2 = 0;
|
||
|
txChannel_()->clearComplete();
|
||
|
rxChannel_()->clearComplete();
|
||
|
}
|
||
|
private:
|
||
|
};
|
||
|
|
||
|
extern DmaSpi0 DMASPI0;
|
||
|
extern DmaSpi1 DMASPI1;
|
||
|
|
||
|
#else
|
||
|
|
||
|
#error Unknown chip
|
||
|
|
||
|
#endif // KINETISK else KINETISL
|
||
|
|
||
|
class DmaSpiGeneric
|
||
|
{
|
||
|
public:
|
||
|
using Transfer = DmaSpi::Transfer;
|
||
|
|
||
|
DmaSpiGeneric() {
|
||
|
m_spiDma0 = &DMASPI0;
|
||
|
#if defined(__MK66FX1M0__)
|
||
|
m_spiDma1 = &DMASPI1;
|
||
|
#endif
|
||
|
}
|
||
|
DmaSpiGeneric(int spiId) : DmaSpiGeneric() {
|
||
|
m_spiSelect = spiId;
|
||
|
}
|
||
|
|
||
|
bool begin () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->begin();
|
||
|
default :
|
||
|
return m_spiDma0->begin();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void start () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : m_spiDma1->start(); return;
|
||
|
default :
|
||
|
m_spiDma0->start(); return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool running () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->running();
|
||
|
default :
|
||
|
return m_spiDma0->running();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool registerTransfer (Transfer& transfer) {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->registerTransfer(transfer);
|
||
|
default :
|
||
|
return m_spiDma0->registerTransfer(transfer);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
bool busy () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->busy();
|
||
|
default :
|
||
|
return m_spiDma0->busy();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void stop () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : m_spiDma1->stop(); return;
|
||
|
default :
|
||
|
m_spiDma0->stop(); return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool stopping () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->stopping();
|
||
|
default :
|
||
|
return m_spiDma0->stopping();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool stopped () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->stopped();
|
||
|
default :
|
||
|
return m_spiDma0->stopped();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void end () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : m_spiDma1->end(); return;
|
||
|
default :
|
||
|
m_spiDma0->end(); return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
uint8_t devNull () {
|
||
|
switch(m_spiSelect) {
|
||
|
case 1 : return m_spiDma1->devNull();
|
||
|
default :
|
||
|
return m_spiDma0->devNull();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
int m_spiSelect = 0;
|
||
|
DmaSpi0 *m_spiDma0 = nullptr;
|
||
|
#if defined(__MK66FX1M0__)
|
||
|
DmaSpi1 *m_spiDma1 = nullptr;
|
||
|
#else
|
||
|
// just make it Spi0 so it compiles atleast
|
||
|
DmaSpi0 *m_spiDma1 = nullptr;
|
||
|
#endif
|
||
|
|
||
|
};
|
||
|
|
||
|
|
||
|
#endif // DMASPI_H
|