FsDriveSdSpi.cpp

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

#include "FsDriveSdSpi.hpp"
#include "LibEndian.hpp"
#include "FsCfg.hpp"

FsDriveSdSpi* FsDriveSdSpi::sInstances[1];

FsDriveSdSpi::FsDriveSdSpi(DrvSpi* spi) {
    sInstances[0] = this;
    mSpi = spi;
}

FsDriveSdSpi::~FsDriveSdSpi() {

}

bool FsDriveSdSpi::internalInit() {
    mSpi->setBaudrate(400000);
    mSpi->deselect();
    for (int i = 0; i < 10; i++) {
        mSpi->readWrite(0xFF);
    }
    if (sendCmd(CMD0_GO_IDLE_STATE, 0).value != RESP_R1_IDLE_VALUE) {
        return false;
    }
    if (sendCmd(CMD8_SEND_IF_COND, 0x1AA).value != RESP_R1_IDLE_VALUE) {
        return false;
    }
    RESP_R7 respR7;
    mSpi->readWrite(0, 0, (uint8_t*) &respR7, sizeof(respR7));
    if (respR7.voltageAccepted != 1 || respR7.checkPattern != 0xAA) {
        return false;
    }

    RtosTimer timer;
    timer.set(Rtos::convertMsToTick(1000));
    while (true) {
        if (timer.isEllapsed()) {
            return false;
        }
        if (sendCmd(CMD55_APP_CMD, 0).value <= RESP_R1_IDLE_VALUE) {
            if (sendCmd(ACMD41_SD_SEND_OP_COND, 0x40000000).value == 0) {
                break;
            }
        }
    }

    if (sendCmd(CMD9_SEND_CSD, 0).value != 0) {
        return false;
    }

    uint8_t csd[16];
    if (!readDataBlock(csd, sizeof(csd))) {
        return false;
    }
    if ((csd[0] >> 6) == 1) { // SDC ver 2
        uint32_t cs = csd[9] + ((uint32_t) csd[8] << 8) + 1;
        mSectorsCount = cs << 10;
    }
    else { // SDC ver 1
        uint32_t n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
        uint32_t cs = (csd[8] >> 6) + ((uint32_t) csd[7] << 2) + ((uint32_t) (csd[6] & 3) << 10) + 1;
        mSectorsCount = cs << (n - 9);
    }
    mSpi->setBaudrate(FS_CFG_SPI_FULL_SPEED_BAUDRATE);
    return true;
}

bool FsDriveSdSpi::init() {
    bool result = internalInit();
    mSpi->deselect();
    return result;
}

bool FsDriveSdSpi::readDataBlock(uint8_t* buffer, unsigned int size) {
    RtosTimer timer;
    timer.set(Rtos::convertMsToTick(100)+1);

    while (true) {
        if (mSpi->readWrite(0xFF) == 0xFE) {
            break;
        }
        if (timer.isEllapsed()) {
            return false;
        }
    }

    mSpi->readWrite(0, 0, buffer, size);
    uint8_t crc[2];
    mSpi->readWrite(0, 0, crc, 2); //CRC
    return true;
}

bool FsDriveSdSpi::internalReadBlocks(FsDefs::SECTOR* buffer, unsigned int blockNumber, unsigned int blockCount) {
    uint8_t* dst = (uint8_t*) buffer;

    if (blockCount == 1) {
        if (sendCmd(CMD17_READ_SINGLE_BLOCK, blockNumber).value != 0) {
            return false;
        }
        if (!readDataBlock(dst, 512)) {
            return false;
        }

    }
    else {
        if (sendCmd(CMD18_READ_MULTIPLE_BLOCK, blockNumber).value != 0) {
            return false;
        }

        while (blockCount-- > 0) {
            if (!readDataBlock(dst, 512)) {
                return false;
            }
            dst += 512;
        }
        sendCmd(CMD12_STOP_TRANSMISSION, 0);

    }
    return true;
}

bool FsDriveSdSpi::readBlocks(FsDefs::SECTOR* buffer, unsigned int blockNumber, unsigned int blockCount) {
    bool result = internalReadBlocks(buffer, blockNumber, blockCount);
    mSpi->deselect();
    return result;
}

bool FsDriveSdSpi::writeDataBlock(const uint8_t* buffer, unsigned int size, bool isMultipleBlock) {
    if (!waitReady()) {
        return false;
    }

    if (isMultipleBlock) {
        mSpi->readWrite(START_MULTIPLE_BLOCK_WRITE);
    }
    else {
        mSpi->readWrite(START_SINGLE_BLOCK_WRITE);
    }
    mSpi->readWrite(buffer, size, 0, 0);
    uint8_t tokenAndCrc[3];
    mSpi->readWrite(0, 0, tokenAndCrc, 3);
    if ((tokenAndCrc[0] & 0x1F) != 0x05) { //Check control token
        return false;
    }
    return true;
}

bool FsDriveSdSpi::internalWriteBlocks(const FsDefs::SECTOR* buffer, unsigned int blockNumber, unsigned int blockCount) {
    uint8_t* src = (uint8_t*) buffer;
    if (blockCount == 1) {
        if (sendCmd(CMD24_WRITE_BLOCK, blockNumber).value != 0) {
            return false;
        }
        if (!writeDataBlock(src, 512, false)) {
            return false;
        }

    }
    else {
        if (sendCmd(ACMD23_SET_WR_BLK_ERASE_COUNT, blockCount).value > RESP_R1_IDLE_VALUE) {
            return false;
        }
        if (sendCmd(CMD25_WRITE_MULTIPLE_BLOCK, blockNumber).value != 0) {
            return false;
        }
        while (blockCount-- > 0) {
            if (!writeDataBlock(src, 512, true)) {
                return false;
            }
            src += 512;
        }
        //Stop tranmission
        if (!waitReady()) {
            return false;
        }
        mSpi->readWrite(STOP_TRANSMISSION);
    }
    return true;
}

bool FsDriveSdSpi::writeBlocks(const FsDefs::SECTOR* buffer, unsigned int blockNumber, unsigned int blockCount) {
    bool result = internalWriteBlocks(buffer, blockNumber, blockCount);
    mSpi->deselect();
    return result;
}

FsDriveSdSpi::RESP_R1 FsDriveSdSpi::sendCmd(uint8_t cmd, uint32_t arg) {
    mSpi->deselect();

    CMD_RESP cmdResp;
    RESP_R1 resp;

    cmdResp.start = 0;
    cmdResp.cmdRsp = 1;
    cmdResp.cmdId = cmd;
    cmdResp.args[0] = (uint8_t) ((arg >> 24) & 0xFF);
    cmdResp.args[1] = (uint8_t) ((arg >> 16) & 0xFF);
    cmdResp.args[2] = (uint8_t) ((arg >> 8) & 0xFF);
    cmdResp.args[3] = (uint8_t) (arg & 0xFF);
    cmdResp.crc = 0;
    cmdResp.stop = 1;
//The SPI interface is initialized in the CRC OFF mode in default. (except for commands CMD0 and CMD8).
    if (cmd == CMD0_GO_IDLE_STATE) {
        cmdResp.crc = 0x0A;
    }
    if (cmd == CMD8_SEND_IF_COND) {
        cmdResp.crc = 0x43;
    }

    resp.value = 0xFF;
    mSpi->select();
    if (!waitReady()) {
        return resp;
    }
    mSpi->readWrite((uint8_t*) &cmdResp, sizeof(CMD_RESP), 0, 0);
    if (cmd == CMD12_STOP_TRANSMISSION) {
        mSpi->readWrite(0);
    }

    for (int i = 0; (i < 10); i++) { //Get the response (try max 10 times)
        resp.value = mSpi->readWrite(0xFF);
        if (!resp.bits.zero) {
            break;
        }
    }
    return resp; // Return with the response value
}

bool FsDriveSdSpi::waitReady() {
    RtosTimer timer;
    timer.set(Rtos::convertMsToTick(500)+1);

    while (!timer.isEllapsed()) {
        if (mSpi->readWrite(0xFF) == 0xFF) {
            return true;
        }
    }
    return false;
}