at25040.hpp

Go to the documentation of this file.

#pragma once
#include "at25040_registers.hpp"
#include "at25040_spi_interface.hpp"
#if __has_include("at25040_version.h")
#include "at25040_version.h"
#else
#define HF_AT25040_VERSION_STRING "1.0.0"
#endif
 
#include <cstddef>
#include <cstdint>
 
namespace at25040 {
 
enum class Status : uint8_t {
  Ok = 0,
  Timeout = 1,
  Absent = 2,
  Busy = 3,
  Arg = 4,
};
 
enum class BlockProtect : uint8_t {
  None = 0,         
  UpperQuarter = 1, 
  UpperHalf = 2,    
  All = 3,          
};
 
template <typename Spi>
class Device {
public:
  explicit Device(Spi& spi) noexcept : spi_(spi) {}
 
  Device(const Device&) = delete;
  Device& operator=(const Device&) = delete;
 
  static constexpr uint16_t kReadChunkBytes = 16;
 
  static constexpr uint32_t kWriteCycleTimeoutMs = 10;
 
  static constexpr uint32_t kPollIntervalUs = 100;
 
  static constexpr uint32_t kPollsPerMsWithoutDelay = 1112;
 
  [[nodiscard]] uint8_t LastRdsr() const noexcept {
    return last_rdsr_;
  }
 
  Status ReadStatus(uint8_t& sr) noexcept {
    uint8_t tx[2] = {kCmdRdsr, 0x00};
    uint8_t rx[2] = {0xFF, 0xFF};
    if (!spi_.transfer(tx, rx, 2, kTimeoutMs)) {
      last_rdsr_ = 0xFF;
      return Status::Timeout;
    }
    sr = rx[1];
    last_rdsr_ = sr;
    return Status::Ok;
  }
 
  Status Probe() noexcept {
    uint8_t a = 0xFF;
    uint8_t b = 0xFF;
    if (ReadStatus(a) != Status::Ok) {
      return Status::Absent;
    }
    if (ReadStatus(b) != Status::Ok) {
      return Status::Absent;
    }
    last_rdsr_ = a;
    if (a != b || a == 0xFFu || a == kCmdRdsr) {
      return Status::Absent;
    }
    if ((a & kSrWip) != 0u) {
      return Status::Busy;
    }
    return Status::Ok;
  }
 
  Status Read(uint16_t addr, uint8_t* dst, uint16_t len) noexcept {
    if (dst == nullptr || len == 0u || addr >= kCapacityBytes ||
        len > static_cast<uint16_t>(kCapacityBytes - addr)) {
      return Status::Arg;
    }
    const Status ready = CheckReady();
    if (ready != Status::Ok) {
      return ready;
    }
    while (len > 0u) {
      const uint16_t n = len < kReadChunkBytes ? len : kReadChunkBytes;
      uint8_t tx[2 + kReadChunkBytes] = {};
      uint8_t rx[2 + kReadChunkBytes] = {};
      tx[0] = Opcode(kCmdRead, addr);
      tx[1] = static_cast<uint8_t>(addr & 0xFFu);
      if (!spi_.transfer(tx, rx, static_cast<std::size_t>(2u + n), kTimeoutMs)) {
        return Status::Timeout;
      }
      for (uint16_t i = 0; i < n; ++i) {
        dst[i] = rx[2u + i];
      }
      addr = static_cast<uint16_t>(addr + n);
      dst += n;
      len = static_cast<uint16_t>(len - n);
    }
    return Status::Ok;
  }
 
  Status WaitReady(uint32_t timeout_ms = kWriteCycleTimeoutMs) noexcept {
    constexpr bool kHasDelay = detail::HasDelayUs<Spi>::value;
    const uint32_t polls = kHasDelay ? (timeout_ms * 1000u) / kPollIntervalUs + 1u
                                     : timeout_ms * kPollsPerMsWithoutDelay + 1u;
    for (uint32_t i = 0; i < polls; ++i) {
      uint8_t sr = 0xFF;
      if (ReadStatus(sr) != Status::Ok) {
        return Status::Timeout;
      }
      if ((sr & kSrWip) == 0u) {
        return Status::Ok;
      }
      if constexpr (kHasDelay) {
        if (i + 1u < polls) {
          spi_.delay_us(kPollIntervalUs);
        }
      }
    }
    return Status::Timeout;
  }
 
  Status WriteEnable() noexcept {
    const Status ready = CheckReady();
    return ready != Status::Ok ? ready : SendInstruction(kCmdWren);
  }
 
  Status WriteDisable() noexcept {
    const Status ready = CheckReady();
    return ready != Status::Ok ? ready : SendInstruction(kCmdWrdi);
  }
 
  Status SetBlockProtection(BlockProtect level) noexcept {
    const auto bits = static_cast<uint8_t>(level);
    if (bits > 3u) {
      return Status::Arg;
    }
    const Status ready = CheckReady();
    if (ready != Status::Ok) {
      return ready;
    }
    if (SendInstruction(kCmdWren) != Status::Ok) {
      return Status::Timeout;
    }
    const uint8_t tx[2] = {kCmdWrsr, static_cast<uint8_t>(bits << 2)};
    uint8_t rx[2] = {0xFF, 0xFF};
    if (!spi_.transfer(tx, rx, 2, kTimeoutMs)) {
      return Status::Timeout;
    }
    return WaitReady();
  }
 
  Status GetBlockProtection(BlockProtect& level) noexcept {
    uint8_t sr = 0xFF;
    if (ReadStatus(sr) != Status::Ok) {
      return Status::Timeout;
    }
    if ((sr & kSrWip) != 0u) {
      return Status::Busy;
    }
    level = static_cast<BlockProtect>((sr & (kSrBp1 | kSrBp0)) >> 2);
    return Status::Ok;
  }
 
  Status WritePage(uint16_t addr, const uint8_t* src, uint16_t len) noexcept {
    if (src == nullptr || len == 0u || len > kPageSizeBytes) {
      return Status::Arg;
    }
    const uint16_t page_off = static_cast<uint16_t>(addr % kPageSizeBytes);
    if ((page_off + len) > kPageSizeBytes) {
      return Status::Arg;
    }
    if ((static_cast<uint32_t>(addr) + len) > kCapacityBytes) {
      return Status::Arg;
    }
    const Status ready = CheckReady();
    if (ready != Status::Ok) {
      return ready;
    }
    if (SendInstruction(kCmdWren) != Status::Ok) {
      return Status::Timeout;
    }
    uint8_t tx[2 + kPageSizeBytes] = {};
    uint8_t rx[2 + kPageSizeBytes] = {};
    tx[0] = Opcode(kCmdWrite, addr);
    tx[1] = static_cast<uint8_t>(addr & 0xFFu);
    for (uint16_t i = 0; i < len; ++i) {
      tx[2u + i] = src[i];
    }
    if (!spi_.transfer(tx, rx, static_cast<std::size_t>(2u + len), kTimeoutMs)) {
      return Status::Timeout;
    }
    return WaitReady();
  }
 
  Status Write(uint16_t addr, const uint8_t* src, uint16_t len) noexcept {
    if (src == nullptr || len == 0u || addr >= kCapacityBytes ||
        len > static_cast<uint16_t>(kCapacityBytes - addr)) {
      return Status::Arg;
    }
    while (len > 0u) {
      const uint16_t room = static_cast<uint16_t>(kPageSizeBytes - (addr % kPageSizeBytes));
      const uint16_t n = len < room ? len : room;
      const Status st = WritePage(addr, src, n);
      if (st != Status::Ok) {
        return st;
      }
      addr = static_cast<uint16_t>(addr + n);
      src += n;
      len = static_cast<uint16_t>(len - n);
    }
    return Status::Ok;
  }
 
private:
  static constexpr uint32_t kTimeoutMs = 20;
 
  static constexpr uint8_t Opcode(uint8_t cmd, uint16_t addr) noexcept {
    return ((addr & 0x100u) != 0u) ? static_cast<uint8_t>(cmd | kAddrA8Mask) : cmd;
  }
 
  Status CheckReady() noexcept {
    uint8_t sr = 0xFF;
    if (ReadStatus(sr) != Status::Ok) {
      return Status::Timeout;
    }
    return (sr & kSrWip) != 0u ? Status::Busy : Status::Ok;
  }
 
  Status SendInstruction(uint8_t cmd) noexcept {
    uint8_t rx = 0xFF;
    return spi_.transfer(&cmd, &rx, 1, kTimeoutMs) ? Status::Ok : Status::Timeout;
  }
 
  Spi& spi_;
  uint8_t last_rdsr_{0xFF};
};
 
inline const char* GetAt25040DriverVersion() noexcept {
  return HF_AT25040_VERSION_STRING;
}
 
} // namespace at25040