MC23LCXXX.h

Go to the documentation of this file.

#ifndef MC23LCXXX_H
#define MC23LCXXX_H

#include "SPI.h"
#include "Storage.h"

template<uint16_t KBYTE, BOARD::pin_t SS_PIN, uint32_t FREQ = 16000000L>
class MC23LCXXX : public Storage,
  protected SPI::Device<0, MSBFIRST, FREQ, SS_PIN>
{
public:
  static const uint32_t MAX_FREQ = 16000000L;

  MC23LCXXX(SPI& spi) :
    Storage(KBYTE * 1024UL),
    SPI::Device<0, MSBFIRST, FREQ, SS_PIN>(spi)
  {}

  virtual int read(void* dst, uint32_t src, size_t count)
  {
    uint8_t* sp = (uint8_t*) &src;
    header_t header;
    size_t size;
    header.cmd = READ;
    if (KBYTE > 64) {
      header.addr[0] = sp[2];
      header.addr[1] = sp[1];
      header.addr[2] = sp[0];
      size = sizeof(header);
    }
    else {
      header.addr[0] = sp[1];
      header.addr[1] = sp[0];
      size = sizeof(header) - 1;
    }
    acquire();
    write(&header, size);
    read(dst, count);
    release();
    return (count);
  }

  virtual int write(uint32_t dst, const void* src, size_t count)
  {
    uint8_t* dp = (uint8_t*) &dst;
    header_t header;
    size_t size;
    header.cmd = WRITE;
    if (KBYTE > 64) {
      header.addr[0] = dp[2];
      header.addr[1] = dp[1];
      header.addr[2] = dp[0];
      size = sizeof(header);
    }
    else {
      header.addr[0] = dp[1];
      header.addr[1] = dp[0];
      size = sizeof(header) - 1;
    }
    acquire();
    write(&header, size);
    write(src, count);
    release();
    return (count);
  }

protected:
  struct header_t {
    uint8_t cmd;                
    uint8_t addr[3];            
  } __attribute__((packed));

  enum {
    READ = 0x03,                
    WRITE = 0x02,               
    RDMR = 0x05,                
    WRMR = 0x01                 
  };

  using SPI::Device<0,MSBFIRST,FREQ,SS_PIN>::acquire;
  using SPI::Device<0,MSBFIRST,FREQ,SS_PIN>::transfer;
  using SPI::Device<0,MSBFIRST,FREQ,SS_PIN>::read;
  using SPI::Device<0,MSBFIRST,FREQ,SS_PIN>::write;
  using SPI::Device<0,MSBFIRST,FREQ,SS_PIN>::release;
};

template<BOARD::pin_t SS_PIN, uint32_t FREQ = 16000000L>
class MC23LC512 : public MC23LCXXX<64, SS_PIN, FREQ> {
public:
  MC23LC512(SPI& spi) : MC23LCXXX<64, SS_PIN, FREQ>(spi) {}
};

template<BOARD::pin_t SS_PIN, uint32_t FREQ = 16000000L>
class MC23LC1024 : public MC23LCXXX<128, SS_PIN, FREQ>
{
public:
  MC23LC1024(SPI& spi) : MC23LCXXX<128, SS_PIN, FREQ>(spi) {}
};

#endif