qspi.h

Go to the documentation of this file.

#ifndef DSY_QSPI
#define DSY_QSPI 
#ifndef UNIT_TEST // for unit tests, a dummy implementation
 
#include <cstdint>
#include "daisy_core.h" // Added for dsy_gpio_pin typedef
 
#define DSY_QSPI_TEXT       \
    __attribute__((section( \
        ".qspiflash_text"))) 
#define DSY_QSPI_DATA       \
    __attribute__((section( \
        ".qspiflash_data"))) 
#define DSY_QSPI_BSS        \
    __attribute__((section( \
        ".qspiflash_bss"))) 
namespace daisy
{
class QSPIHandle
{
  public:
    enum Result
    {
        OK = 0,
        ERR
    };
 
    enum Status
    {
        GOOD = 0,
        E_HAL_ERROR,
        E_SWITCHING_MODES,
        E_INVALID_MODE,
    };
 
    struct Config
    {
        enum Device
        {
            IS25LP080D,  
            IS25LP064A,  
            DEVICE_LAST, 
        };
 
        enum Mode
        {
            MEMORY_MAPPED,    
            INDIRECT_POLLING, 
            MODE_LAST,
        };
 
        //SCK,  CE# (active low)
        struct
        {
            dsy_gpio_pin io0; 
            dsy_gpio_pin io1; 
            dsy_gpio_pin io2; 
            dsy_gpio_pin io3; 
            dsy_gpio_pin clk; 
            dsy_gpio_pin ncs; 
        } pin_config;
 
        Device device;
        Mode   mode;
    };
 
    Result Init(const Config& config);
 
    const Config& GetConfig() const;
 
    // Couldn't this just be called before anything else in init? That
    // would make manually calling it unnecessary.
    Result DeInit();
 
    Result WritePage(uint32_t address, uint32_t size, uint8_t* buffer);
 
    Result Write(uint32_t address, uint32_t size, uint8_t* buffer);
 
    Result Erase(uint32_t start_addr, uint32_t end_addr);
 
    Result EraseSector(uint32_t address);
 
    Status GetStatus();
 
    void* GetData(uint32_t offset = 0);
 
    QSPIHandle() : pimpl_(nullptr) {}
    QSPIHandle(const QSPIHandle& other) = default;
    QSPIHandle& operator=(const QSPIHandle& other) = default;
 
    class Impl; 
  private:
    Impl* pimpl_;
};
 
} // namespace daisy
 
#else
 
#include <cstdint>
#include "../tests/TestIsolator.h"
 
namespace daisy
{
class QSPIHandle
{
  public:
    enum Result
    {
        OK = 0,
        ERR
    };
 
    static Result ResetAndClear()
    {
        testIsolator_.GetStateForCurrentTest()->memory_.clear();
        return Result::OK;
    }
 
 
    static Result Write(uint32_t address, uint32_t size, uint8_t* buffer)
    {
        // 256-byte aligned, normalized address value
        uint32_t adjusted_addr = (address) & (uint32_t)(~0xff);
        // Make sure memory is of approriate size
        uint32_t total_bytes = adjusted_addr + size;
        AdaptToSize(total_bytes);
        // Copy data into vector
        uint8_t* dest = testIsolator_.GetStateForCurrentTest()->memory_.data();
        std::copy(&buffer[adjusted_addr],
                  &buffer[adjusted_addr + size],
                  &dest[adjusted_addr]);
        return Result::OK;
    }
 
    static Result Erase(uint32_t start_addr, uint32_t end_addr)
    {
        uint32_t adjusted_start_addr = (start_addr) & (uint32_t)(~0xff);
        uint32_t adjusted_end_addr   = (end_addr) & (uint32_t)(~0xff);
 
        // guard addresses
        assert(adjusted_start_addr < kMaxAdjustedAddr);
        assert(adjusted_end_addr < kMaxAdjustedAddr);
 
        // Make sure vector is of appropriate size
        // size should be at least (adjusted_end_addr)
        AdaptToSize(adjusted_end_addr);
        uint8_t* buff = testIsolator_.GetStateForCurrentTest()->memory_.data();
        // Erases memory by setting all bits to 1
        std::fill(&buff[adjusted_start_addr], &buff[adjusted_end_addr], 0xff);
        return Result::OK;
    }
 
    static void* GetData(uint32_t offset = 0)
    {
        assert(offset < kMaxAdjustedAddr);
        AdaptToSize(offset + 1); 
        return (void*)(testIsolator_.GetStateForCurrentTest()->memory_.data()
                       + offset);
    }
 
    static size_t GetCurrentSize()
    {
        return testIsolator_.GetStateForCurrentTest()->memory_.size();
    }
 
  private:
    static void AdaptToSize(uint32_t required_bytes)
    {
        if(testIsolator_.GetStateForCurrentTest()->memory_.size()
           < required_bytes)
            testIsolator_.GetStateForCurrentTest()->memory_.resize(
                required_bytes, 0x00);
    }
    static constexpr uint32_t kMaxAdjustedAddr = 0x800000;
    struct QSPIState
    {
        // Emulate the byte-memory of the QSPI flash
        std::vector<uint8_t> memory_;
    };
    static TestIsolator<QSPIState> testIsolator_;
};
 
 
} // namespace daisy
 
 
#endif // ifndef UNIT_TEST
 
#endif // ifndef DSY_QSPI