DrvSpi.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "DrvSpi.hpp"
#include "DrvCfg.hpp"
#include "RtosInclude.hpp"

DrvSpi* DrvSpi::sInstances[2];

DrvSpi::DrvSpi() :
        mSema(1, 1) {
}

void DrvSpi::init(DrvTypes::SPI port, DrvGpio* cs, int baudrate, bool invertPhase, bool invertPolarity) {
    IRQn_Type irqType;

    mCs = cs;

    switch (port) {
    case DrvTypes::DRV_SPI1:
        mSpi = SPI1;
        irqType = SPI1_IRQn;
        break;
    case DrvTypes::DRV_SPI2:
        irqType = SPI2_IRQn;
        mSpi = SPI2;
        break;
    default:
        return;
    }

    sInstances[port - 1] = this;

    NVIC ->IP[irqType] = RTOS_INT_PRI;
    NVIC_EnableIRQ(irqType);
    setBaudrate(baudrate);
    mSpi->CR2 = SPI_CR2_RXNEIE;
    mSpi->CR1 |= SPI_CR1_MSTR | SPI_CR1_SSI | SPI_CR1_SSM;
    if (invertPhase) {
        mSpi->CR1 |= SPI_CR1_CPHA;
    }
    if (invertPolarity) {
        mSpi->CR1 |= SPI_CR1_CPOL;
    }
    mSpi->CR1 |= SPI_CR1_SPE;
}

void DrvSpi::setBaudrate(int baudrate) {
    int clk;
    if (mSpi == SPI1 ) {
        clk = DRV_CFG_PCLK2_FREQ;
    }
    else {
        clk = DRV_CFG_PCLK1_FREQ;
    }
    int br = 0;
    while (baudrate <= clk) {
        br++;
        baudrate *= 2;
    }
    mSpi->CR1 &= ~(7 << 3);
    mSpi->CR1 |= ((br & 7) << 3);
}

void DrvSpi::select() {
    *mCs = false;
}

void DrvSpi::deselect() {
    *mCs = true;
}

uint8_t DrvSpi::readWrite(const uint8_t value) {
    mSpi->DR = value;
    mSema.take(Rtos::TICK_INFINITE);
    return mDr;
}

void DrvSpi::readWrite(const uint8_t* src, int srcLen, uint8_t* dst, int dstLen) {
    int bigger = (srcLen > dstLen) ? srcLen : dstLen;
    uint8_t value;
    for (int i = 0; i < bigger; i++) {
        if (i < srcLen) {
            value = readWrite(src[i]);
        }
        else {
            value = readWrite(0xFF);
        }
        if (i < dstLen) {
            dst[i] = value;
        }
    }
}

void DrvSpi::onInterrupt() {
    mDr = mSpi->DR;
    mSema.giveFromInt();
}

void RtosInterrupt::IRQ_SPI1() {
    DrvSpi::sInstances[0]->onInterrupt();
}

void RtosInterrupt::IRQ_SPI2() {
    DrvSpi::sInstances[1]->onInterrupt();
}