SPI.cpp

/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved.                                                         */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib.  */
/*----------------------------------------------------------------------------*/

#include "SPI.h"

#include "ChipObject/tSPI.h"
#include "DigitalInput.h"
#include "DigitalOutput.h"
#include "Synchronized.h"
#include "WPIErrors.h"

#include <math.h>
#include <usrLib.h>

SEM_ID SPI::m_semaphore = NULL;

SPI::SPI(DigitalOutput &clk, DigitalOutput &mosi, DigitalInput &miso)
{
        Init(&clk, &mosi, &miso);
}

SPI::SPI(DigitalOutput *clk, DigitalOutput *mosi, DigitalInput *miso)
{
        Init(clk, mosi, miso);
}

SPI::SPI(DigitalOutput &clk, DigitalOutput &mosi)
{
        Init(&clk, &mosi, NULL);
}

SPI::SPI(DigitalOutput *clk, DigitalOutput *mosi)
{
        Init(clk, mosi, NULL);
}

SPI::SPI(DigitalOutput &clk, DigitalInput &miso)
{
        Init(&clk, NULL, &miso);
}

SPI::SPI(DigitalOutput *clk, DigitalInput *miso)
{
        Init(clk, NULL, miso);
}

SPI::~SPI()
{
        delete m_spi;
}

void SPI::Init(DigitalOutput *clk, DigitalOutput *mosi, DigitalInput *miso)
{
        if (m_semaphore == NULL)
        {
                m_semaphore = semMCreate(SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
        }

        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_spi = tSPI::create(&localStatus);
        wpi_setError(localStatus);

        m_config.BusBitWidth = 8;
        m_config.ClockHalfPeriodDelay = 0;
        m_config.MSBfirst = 0;
        m_config.DataOnFalling = 0;
        m_config.LatchFirst = 0;
        m_config.LatchLast = 0;
        m_config.FramePolarity = 0;
        m_config.WriteOnly = miso ? 0 : 1;
        m_config.ClockPolarity = 0;

        m_channels.SCLK_Channel = clk->GetChannelForRouting();
        m_channels.SCLK_Module = clk->GetModuleForRouting();
        m_channels.SS_Channel = 0;
        m_channels.SS_Module = 0;

        if (mosi)
        {
                m_channels.MOSI_Channel = mosi->GetChannelForRouting();
                m_channels.MOSI_Module = mosi->GetModuleForRouting();
        }
        else
        {
                m_channels.MOSI_Channel = 0;
                m_channels.MOSI_Module = 0;
        }

        if (miso)
        {
                m_channels.MISO_Channel = miso->GetChannelForRouting();
                m_channels.MISO_Module = miso->GetModuleForRouting();
        }
        else
        {
                m_channels.MISO_Channel = 0;
                m_channels.MISO_Module = 0;
        }

        m_ss = NULL;
}

void SPI::SetBitsPerWord(UINT32 bits)
{
        m_config.BusBitWidth = bits;
}

UINT32 SPI::GetBitsPerWord()
{
        return m_config.BusBitWidth;
}

void SPI::SetClockRate(double hz)
{
        int delay = 0;
        // TODO: compute the appropriate values based on digital loop timing
        if (hz <= 76628.4)
        {
                double v = (1.0/hz)/1.305e-5;
                int intv = (int)v;
                if (v-intv > 0.5)
                        delay = intv;
                else
                        delay = intv-1;
        }
        if (delay > 255)
        {
                wpi_setWPIError(SPIClockRateTooLow);
                delay = 255;
        }
        m_config.ClockHalfPeriodDelay = delay;
}

void SPI::SetMSBFirst()
{
        m_config.MSBfirst = 1;
}

void SPI::SetLSBFirst()
{
        m_config.MSBfirst = 0;
}

void SPI::SetSampleDataOnFalling()
{
        m_config.DataOnFalling = 1;
}

void SPI::SetSampleDataOnRising()
{
        m_config.DataOnFalling = 0;
}

void SPI::SetSlaveSelect(DigitalOutput *ss, tFrameMode mode, bool activeLow)
{
        if (ss)
        {
                m_channels.SS_Channel = ss->GetChannelForRouting();
                m_channels.SS_Module = ss->GetModuleForRouting();
        }
        else
        {
                m_channels.SS_Channel = 0;
                m_channels.SS_Module = 0;
        }
        m_ss = ss;

        switch (mode)
        {
                case kChipSelect:
                        m_config.LatchFirst = 0;
                        m_config.LatchLast = 0;
                        break;
                case kPreLatchPulse:
                        m_config.LatchFirst = 1;
                        m_config.LatchLast = 0;
                        break;
                case kPostLatchPulse:
                        m_config.LatchFirst = 0;
                        m_config.LatchLast = 1;
                        break;
                case kPreAndPostLatchPulse:
                        m_config.LatchFirst = 1;
                        m_config.LatchLast = 1;
                        break;
        }

        m_config.FramePolarity = activeLow ? 1 : 0;
}

void SPI::SetSlaveSelect(DigitalOutput &ss, tFrameMode mode, bool activeLow)
{
        SetSlaveSelect(&ss, mode, activeLow);
}

DigitalOutput *SPI::GetSlaveSelect(tFrameMode *mode, bool *activeLow)
{
        if (mode != NULL)
        {
                *mode = (tFrameMode) (m_config.LatchFirst | (m_config.LatchLast << 1));
        }
        if (activeLow != NULL)
        {
                *activeLow = m_config.FramePolarity != 0;
        }
        return m_ss;
}

void SPI::SetClockActiveLow()
{
        m_config.ClockPolarity = 1;
}

void SPI::SetClockActiveHigh()
{
        m_config.ClockPolarity = 0;
}

void SPI::ApplyConfig()
{
        Synchronized sync(m_semaphore);

        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_spi->writeConfig(m_config, &localStatus);
        m_spi->writeChannels(m_channels, &localStatus);
        m_spi->strobeReset(&localStatus);
        wpi_setError(localStatus);
}

UINT16 SPI::GetOutputFIFOAvailable()
{
        tRioStatusCode localStatus = NiFpga_Status_Success;
        UINT16 result = m_spi->readAvailableToLoad(&localStatus);
        wpi_setError(localStatus);
        return result;
}

UINT16 SPI::GetNumReceived()
{
        tRioStatusCode localStatus = NiFpga_Status_Success;
        UINT16 result = m_spi->readReceivedElements(&localStatus);
        wpi_setError(localStatus);
        return result;
}

bool SPI::IsDone()
{
        tRioStatusCode localStatus = NiFpga_Status_Success;
        bool result = m_spi->readStatus_Idle(&localStatus);
        wpi_setError(localStatus);
        return result;
}

bool SPI::HadReceiveOverflow()
{
        tRioStatusCode localStatus = NiFpga_Status_Success;
        bool result = m_spi->readStatus_ReceivedDataOverflow(&localStatus);
        wpi_setError(localStatus);
        return result;
}

void SPI::Write(UINT32 data)
{
        if (m_channels.MOSI_Channel == 0 && m_channels.MOSI_Module == 0)
        {
                wpi_setWPIError(SPIWriteNoMOSI);
                return;
        }

        Synchronized sync(m_semaphore);

        while (GetOutputFIFOAvailable() == 0)
                taskDelay(NO_WAIT);

        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_spi->writeDataToLoad(data, &localStatus);
        m_spi->strobeLoad(&localStatus);
        wpi_setError(localStatus);
}

UINT32 SPI::Read(bool initiate)
{
        if (m_channels.MISO_Channel == 0 && m_channels.MISO_Module == 0)
        {
                wpi_setWPIError(SPIReadNoMISO);
                return 0;
        }

        tRioStatusCode localStatus = NiFpga_Status_Success;
        UINT32 data;
        {
                Synchronized sync(m_semaphore);

                if (initiate)
                {
                        m_spi->writeDataToLoad(0, &localStatus);
                        m_spi->strobeLoad(&localStatus);
                }

                // Do we have anything ready to read?
                if (GetNumReceived() == 0)
                {
                        if (!initiate && IsDone() && GetOutputFIFOAvailable() == kTransmitFIFODepth)
                        {
                                // Nothing to read: error out
                                wpi_setWPIError(SPIReadNoData);
                                return 0;
                        }

                        // Wait for the transaction to complete
                        while (GetNumReceived() == 0)
                                taskDelay(NO_WAIT);
                }

                m_spi->strobeReadReceivedData(&localStatus);
                data = m_spi->readReceivedData(&localStatus);
        }
        wpi_setError(localStatus);

        return data;
}

void SPI::Reset()
{
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_spi->strobeReset(&localStatus);
        wpi_setError(localStatus);
}

void SPI::ClearReceivedData()
{
        tRioStatusCode localStatus = NiFpga_Status_Success;
        m_spi->strobeClearReceivedData(&localStatus);
        wpi_setError(localStatus);
}