DrvI2cMaster.cpp

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

#include "DrvI2cMaster.hpp"
#include "RtosInclude.hpp"

DrvI2cMaster* DrvI2cMaster::sInstances[2];

DrvI2cMaster::DrvI2cMaster() :
        mSema(1, 0) {
}

void DrvI2cMaster::init(DrvTypes::I2C port) {
    IRQn_Type irqTypeEv;
    IRQn_Type irqTypeEr;

    switch (port) {
        case DrvTypes::DRV_I2C1:
            sInstances[0] = this;
            mI2c = I2C1;
            irqTypeEv = I2C1_EV_IRQn;
            irqTypeEr = I2C1_ER_IRQn;
            break;
        case DrvTypes::DRV_I2C2:
            sInstances[1] = this;
            mI2c = I2C2;
            irqTypeEv = I2C2_EV_IRQn;
            irqTypeEr = I2C2_ER_IRQn;
            break;
        default:
            return;
    }
    mI2c->CR1 = 0;
    mI2c->TIMINGR = 0x00902025;

    NVIC ->IP[irqTypeEv] = RTOS_INT_PRI;
    NVIC ->IP[irqTypeEr] = RTOS_INT_PRI;
    NVIC_EnableIRQ(irqTypeEv);
    NVIC_EnableIRQ(irqTypeEr);
}

void DrvI2cMaster::setSlaveAddr(uint16_t slaveAddr) {
    mSlaveAddr = slaveAddr;
}

bool DrvI2cMaster::readWrite(const uint8_t* src, int srcLen, uint8_t* dst, int dstLen) {
    mSrc = src;
    mSrcLen = srcLen;
    mDst = dst;
    mDstLen = dstLen;
    mResult = false;
    mI2c->CR1 = I2C_CR1_TCIE | I2C_CR1_ERRIE | I2C_CR1_TXIE | I2C_CR1_RXIE | I2C_CR1_NACKIE | I2C_CR1_PE;
    if (srcLen > 0) {
        mI2c->CR2 = I2C_CR2_START | ((srcLen << 16) & I2C_CR2_NBYTES) | (mSlaveAddr & I2C_CR2_SADD);
    }
    else if (dstLen > 0) {
        mI2c->CR2 = I2C_CR2_START | I2C_CR2_RD_WRN | ((dstLen << 16) & I2C_CR2_NBYTES) | (mSlaveAddr & I2C_CR2_SADD);
    }
    else {
        mI2c->CR1 = 0;
        return true;
    }
    if (!mSema.take(Rtos::convertMsToTick(1000))) {
        mI2c->CR1 = 0;
        return false;
    }
    mI2c->CR1 = 0;
    return mResult;
}

void DrvI2cMaster::onEvent() {
    uint16_t status = mI2c->ISR;

    if (status & I2C_ISR_TXE) { // Transmit data register empty
        Rtos::nop();
    }
    if (status & I2C_ISR_TXIS) { // Transmit interrupt status
        mI2c->TXDR = *mSrc++;
        mSrcLen--;
    }
    if (status & I2C_ISR_RXNE) { // Receive data register not empty
        if (mDstLen > 0) {
            *mDst++ = mI2c->RXDR;
            mDstLen--;
        }
    }
    if (status & I2C_ISR_ADDR) { // Address matched (slave mode)
        Rtos::nop();
    }
    if (status & I2C_ISR_NACKF) { // NACK received flag
        Rtos::nop();
    }
    if (status & I2C_ISR_STOPF) { // STOP detection flag
        Rtos::nop();
    }
    if (status & I2C_ISR_TC) { // Transfer complete (master mode)
        if (mDstLen > 0) {
            mI2c->CR2 = I2C_CR2_START | I2C_CR2_RD_WRN | ((mDstLen << 16) & I2C_CR2_NBYTES) | (mSlaveAddr & I2C_CR2_SADD);
        }
        else {
            mI2c->CR2 = I2C_CR2_STOP;
            mResult = true;
            mSema.giveFromInt();
        }
    }
    if (status & I2C_ISR_TCR) { // Transfer complete reload
        Rtos::nop();
    }
    if (status & I2C_ISR_BUSY) { // Bus busy
        Rtos::nop();
    }
    if (status & I2C_ISR_DIR) { // Transfer direction (slave mode)
        Rtos::nop();
    }
    if (status & I2C_ISR_ADDCODE) { // Address match code (slave mode)
        Rtos::nop();
    }

}

void DrvI2cMaster::onError() {
    mI2c->CR1 = 0;
    mSema.giveFromInt();
    uint16_t status = mI2c->ISR;
    if (status & I2C_ISR_BERR) { // Bus error
        Rtos::nop();
    }
    if (status & I2C_ISR_ARLO) { // Arbitration lost
        Rtos::nop();
    }
    if (status & I2C_ISR_OVR) { // Overrun/Underrun
        Rtos::nop();
    }
    if (status & I2C_ISR_TIMEOUT) { // Timeout or Tlow detection flag
        Rtos::nop();
    }
    if (status & I2C_ISR_PECERR) { // PEC error in reception
        Rtos::nop();
    }
    if (status & I2C_ISR_ALERT) { // SMBus alert
        Rtos::nop();
    }
}

void RtosInterrupt::IRQ_I2C1_EV() {
    DrvI2cMaster::sInstances[0]->onEvent();
}

void RtosInterrupt::IRQ_I2C1_ER() {
    DrvI2cMaster::sInstances[0]->onError();
}

void RtosInterrupt::IRQ_I2C2_EV() {
    DrvI2cMaster::sInstances[1]->onEvent();
}

void RtosInterrupt::IRQ_I2C2_ER() {
    DrvI2cMaster::sInstances[1]->onError();
}