SdCardSpiBased.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_DEVICES_MEMORY_SDCARDSPIBASED_HPP_
#define INCLUDE_DISTORTOS_DEVICES_MEMORY_SDCARDSPIBASED_HPP_

#include "distortos/devices/memory/BlockDevice.hpp"

#include "distortos/Mutex.hpp"

namespace distortos
{

namespace devices
{

class OutputPin;
class SpiMaster;

class SdCardSpiBased : public BlockDevice
{
public:

    constexpr static size_t blockSize {512};

    constexpr SdCardSpiBased(SpiMaster& spiMaster, OutputPin& slaveSelectPin,
            const uint32_t clockFrequency = 25000000) :
                    mutex_{Mutex::Type::recursive, Mutex::Protocol::priorityInheritance},
                    blocksCount_{},
                    auSize_{},
                    clockFrequency_{clockFrequency},
                    slaveSelectPin_{slaveSelectPin},
                    spiMaster_{spiMaster},
                    eraseTimeoutMs_{},
                    readTimeoutMs_{},
                    writeTimeoutMs_{},
                    blockAddressing_{},
                    openCount_{}
    {

    }

    ~SdCardSpiBased() override;

    int close() override;

    int erase(uint64_t address, uint64_t size) override;

    size_t getBlockSize() const override;

    uint64_t getSize() const override;

    void lock() override;

    int open() override;

    int read(uint64_t address, void* buffer, size_t size) override;

    int synchronize() override;

    void unlock() override;

    int write(uint64_t address, const void* buffer, size_t size) override;

private:

    void deinitialize();

    int initialize();

    Mutex mutex_;

    size_t blocksCount_;

    uint32_t auSize_;

    uint32_t clockFrequency_;

    OutputPin& slaveSelectPin_;

    SpiMaster& spiMaster_;

    uint16_t eraseTimeoutMs_;

    uint16_t readTimeoutMs_;

    uint16_t writeTimeoutMs_;

    bool blockAddressing_;

    uint8_t openCount_;
};

}   // namespace devices

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_DEVICES_MEMORY_SDCARDSPIBASED_HPP_