SdSpiCard.h

Go to the documentation of this file.

 
#ifndef SdSpiCard_h
#define SdSpiCard_h
#include "../SpiDriver/SdSpiDriver.h"
#include "../common/SysCall.h"
#include "SdCardInfo.h"
#include "SdCardInterface.h"
#include <stddef.h>
//==============================================================================
#if HAS_SDIO_CLASS
class SdSpiCard : public SdCardInterface
{
#elif USE_BLOCK_DEVICE_INTERFACE
class SdSpiCard : public BlockDeviceInterface
{
#else  // HAS_SDIO_CLASS
class SdSpiCard
{
#endif // HAS_SDIO_CLASS
  public:
    SdSpiCard()
    {
    }
    bool begin(SdSpiConfig spiConfig);
    void dbgClearStats();
    void dbgPrintStats();
    uint32_t sectorCount();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    // Use sectorCount(). cardSize() will be removed in the future.
    uint32_t cardSize() __attribute__((deprecated))
    {
        return sectorCount();
    }
#endif // DOXYGEN_SHOULD_SKIP_THIS
    bool erase(uint32_t firstSector, uint32_t lastSector);
    bool eraseSingleSectorEnable();
    void error(uint8_t code)
    {
        m_errorCode = code;
    }
    uint8_t errorCode() const
    {
        return m_errorCode;
    }
    uint32_t errorData() const
    {
        return m_status;
    }
    bool isBusy();
 
    bool readSector(uint32_t sector, uint8_t *dst)
    {
#if ENABLE_DEDICATED_SPI
        return readSectors(sector, dst, 1);
#else  // ENABLE_DEDICATED_SPI
        return readSingle(sector, dst);
#endif // ENABLE_DEDICATED_SPI
    }
    bool readSingle(uint32_t sector, uint8_t *dst);
    bool readSectors(uint32_t sector, uint8_t *dst, size_t ns);
    bool readCID(cid_t *cid)
    {
        return readRegister(CMD10, cid);
    }
    bool readCSD(csd_t *csd)
    {
        return readRegister(CMD9, csd);
    }
    bool readData(uint8_t *dst);
    bool readOCR(uint32_t *ocr);
    bool readStart(uint32_t sector);
    bool readStatus(uint8_t *status);
    bool readStop();
    bool syncDevice();
    uint8_t type() const
    {
        return m_type;
    }
    bool writeSector(uint32_t sector, const uint8_t *src)
    {
        if (m_sharedSpi)
        {
            return writeSingle(sector, src);
        }
        else
        {
            return writeSectors(sector, src, 1);
        }
    }
    bool writeSingle(uint32_t sector, const uint8_t *src);
    bool writeSectors(uint32_t sector, const uint8_t *src, size_t ns);
    bool writeData(const uint8_t *src);
    bool writeStart(uint32_t sector);
 
    bool writeStart(uint32_t sector, uint32_t eraseCount);
    bool writeStop();
    void spiStart();
    void spiStop();
 
  private:
    // private functions
    uint8_t cardAcmd(uint8_t cmd, uint32_t arg)
    {
        cardCommand(CMD55, 0);
        return cardCommand(cmd, arg);
    }
    uint8_t cardCommand(uint8_t cmd, uint32_t arg);
    bool isTimedOut(SdMillis_t startMS, SdMillis_t timeoutMS);
    bool readData(uint8_t *dst, size_t count);
    bool readRegister(uint8_t cmd, void *buf);
    void spiSelect()
    {
        sdCsWrite(m_csPin, false);
    }
    void type(uint8_t value)
    {
        m_type = value;
    }
    void spiUnselect()
    {
        sdCsWrite(m_csPin, true);
    }
    bool waitNotBusy(SdMillis_t timeoutMS);
    bool writeData(uint8_t token, const uint8_t *src);
 
#if SPI_DRIVER_SELECT < 2
    void spiActivate()
    {
        m_spiDriver.activate();
    }
    void spiBegin(SdSpiConfig spiConfig)
    {
        m_spiDriver.begin(spiConfig);
    }
    void spiDeactivate()
    {
        m_spiDriver.deactivate();
    }
    uint8_t spiReceive()
    {
        return m_spiDriver.receive();
    }
    uint8_t spiReceive(uint8_t *buf, size_t n)
    {
        return m_spiDriver.receive(buf, n);
    }
    void spiSend(uint8_t data)
    {
        m_spiDriver.send(data);
    }
    void spiSend(const uint8_t *buf, size_t n)
    {
        m_spiDriver.send(buf, n);
    }
    void spiSetSckSpeed(uint32_t maxSck)
    {
        m_spiDriver.setSckSpeed(maxSck);
    }
    SdSpiDriver m_spiDriver;
#else  // SPI_DRIVER_SELECT < 2
    void spiActivate()
    {
        m_spiDriverPtr->activate();
    }
    void spiBegin(SdSpiConfig spiConfig)
    {
        m_spiDriverPtr->begin(spiConfig);
    }
    void spiDeactivate()
    {
        m_spiDriverPtr->deactivate();
    }
    uint8_t spiReceive()
    {
        return m_spiDriverPtr->receive();
    }
    uint8_t spiReceive(uint8_t *buf, size_t n)
    {
        return m_spiDriverPtr->receive(buf, n);
    }
    void spiSend(uint8_t data)
    {
        m_spiDriverPtr->send(data);
    }
    void spiSend(const uint8_t *buf, size_t n)
    {
        m_spiDriverPtr->send(buf, n);
    }
    void spiSetSckSpeed(uint32_t maxSck)
    {
        m_spiDriverPtr->setSckSpeed(maxSck);
    }
    SdSpiDriver *m_spiDriverPtr;
#endif // SPI_DRIVER_SELECT < 2
#if ENABLE_DEDICATED_SPI
    static const uint8_t IDLE_STATE = 0;
    static const uint8_t READ_STATE = 1;
    static const uint8_t WRITE_STATE = 2;
    uint32_t m_curSector;
    uint8_t m_curState;
    bool m_sharedSpi = true;
#else  // ENABLE_DEDICATED_SPI
    static const bool m_sharedSpi = true;
#endif // ENABLE_DEDICATED_SPI
    SdCsPin_t m_csPin;
    uint8_t m_errorCode = SD_CARD_ERROR_INIT_NOT_CALLED;
    bool m_spiActive;
    uint8_t m_status;
    uint8_t m_type = 0;
};
#endif // SdSpiCard_h