eeprom.c

#include <stddef.h>
#include <contiki.h>
#include <core/work.h>
#include <core/event-monitor.h>
#include <dev/eeprom.h>
#include <dev/arch-eeprom.h>
#include <stdbool.h>
#include <string.h>
#include <alloca.h>
#include <lib/assert.h>
#include <dev/resources.h>
#include <dev/spi-memory.h>
#include <dev/eve-module.h>

/*** Typedef's and defines. ***/

#define EEPROM_BUFFER_SIZE(e)       (((e)->PageSize < 64) ? 64 : ((e)->PageSize))

#define EEPROM_BIT_PRESENT          (1 << 0)
#define EEPROM_BIT_USED             (1 << 1)
#define EEPROM_BIT_VALID            (1 << 2)
#define EEPROM_BITS(bits)           ((uint8_t) ~(bits))

/* XXX: Product-specific */
extern const struct spi_memory_t ExtFlash;

/** EEPROM bank id  */
enum {
  BANK_1,                           /**< First bank                                         */
  BANK_2,                           /**< Second bank                                        */
  BANK__COUNT                       /**< Amount of banks                                    */
};

/** EEPROM bank descriptor */
struct eeprom_bank_t {
  uint16_t read;                    /**< Read index, the first valid element in the bank    */
  uint16_t write;                   /**< Write index, the first free entry in the bank      */
};

/*** Function prototypes ***/
static uint32_t eeprom_sector(const struct eeprom_t *e, uint8_t bank);
static uint32_t eeprom_page(const struct eeprom_t *e, uint8_t bank, uint16_t page);
static uint32_t eeprom_addr(const struct eeprom_t *e, uint8_t bank, uint16_t page, uint32_t offset);
static void eeprom_bank_init(const struct eeprom_t *e, uint8_t *buffer, uint8_t bank);
static bool eeprom_bank_open(const struct eeprom_t *e, uint8_t *buffer, unsigned bank, struct eeprom_bank_t *cache);
static void eeprom_read_impl(eeprom_addr_t addr, unsigned char *buf, int size, const struct eeprom_t *e);
static void eeprom_write_impl(eeprom_addr_t addr, const unsigned char *buf, int size, const struct eeprom_t *e);
static void eeprom_init_impl(const struct eeprom_t *e);

static bool eeprom_ext_power(bool On);
static void eeprom_ext_erase(uint32_t SectorIndex);
static void eeprom_ext_write(uint32_t DstAddress, const void *SrcBuffer, uint32_t ByteCount);
static void eeprom_ext_read(void *DstBuffer, uint32_t SrcAddress, uint32_t ByteCount);

static bool eeprom_int_power(bool On);
static void eeprom_int_erase(uint32_t SectorIndex);
static void eeprom_int_write(uint32_t DstAddress, const void *SrcBuffer, uint32_t ByteCount);
static void eeprom_int_read(void *DstBuffer, uint32_t SrcAddress, uint32_t ByteCount);

/*** Variables ***/
const struct eeprom_vtbl_t EepromInExternalFlash =
{
  .Power = eeprom_ext_power,
  .Erase = eeprom_ext_erase,
  .Write = eeprom_ext_write,
  .Read = eeprom_ext_read,
};

const struct eeprom_vtbl_t EepromInInternalFlash =
{
  .Power = eeprom_int_power,
  .Erase = eeprom_int_erase,
  .Write = eeprom_int_write,
  .Read = eeprom_int_read,
};

/*** Static functions ***/

/** Returns flash sector address by bank id */
static uint32_t eeprom_sector(const struct eeprom_t *e, uint8_t bank)
{
  return e->StartSector + bank;
}

/** Returns flash page address by bank id and page index*/
static uint32_t eeprom_page(const struct eeprom_t *e, uint8_t bank, uint16_t page)
{
  return eeprom_sector(e, bank) * e->PagesPerSector + page;
}

/** Returns flash address by bank id, page index and offset within the page */
static uint32_t eeprom_addr(const struct eeprom_t *e, uint8_t bank, uint16_t page, uint32_t offset)
{
  return eeprom_page(e, bank, page) * e->PageSize + offset;
}

/** Initializes a EEPROM bank on flash */
static void eeprom_bank_init(const struct eeprom_t *e, uint8_t *buffer, uint8_t bank)
{
  const struct eeprom_vtbl_t *v = e->Vtbl;
  uint16_t pos, chunk;

  assert(v != NULL);

  /* Erase the sector */
  v->Erase(eeprom_sector(e, bank));

  for (pos = 0; pos < e->PagesPerSector; pos += chunk) {
    chunk = e->PagesPerSector - pos;
    if (chunk > EEPROM_BUFFER_SIZE(e))
      chunk = EEPROM_BUFFER_SIZE(e);

    /* Write the header. Do not set VALID bit for the first time */
    memset(&buffer[0], EEPROM_BITS(EEPROM_BIT_PRESENT), chunk);
    if (pos == 0)
      buffer[0] = EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED);

    v->Write(eeprom_addr(e, bank, 0, pos), buffer, chunk);
  }

  /* And now, when write is finished we can mark the header as VALID */
  buffer[0] = EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED | EEPROM_BIT_VALID);
  v->Write(eeprom_addr(e, bank, 0, 0), buffer, 1);
}

/** Reads bank header and fills bank descriptor with read and write indexes */
static bool eeprom_bank_open(const struct eeprom_t *e, uint8_t *buffer, unsigned bank, struct eeprom_bank_t *cache)
{
  const struct eeprom_vtbl_t *v = e->Vtbl;
  uint16_t pos, chunk;
  uint16_t idx = (e->PagesPerSector + e->PageSize - 1) / e->PageSize;

  assert (v != NULL);

  cache->read = cache->write = 0;

  for (pos = 0; pos < e->PagesPerSector; pos += chunk) {
    chunk = e->PagesPerSector - pos;
    if (chunk > EEPROM_BUFFER_SIZE(e))
      chunk = EEPROM_BUFFER_SIZE(e);

    v->Read(buffer, eeprom_addr(e, bank, 0, pos), chunk);

    /* Sanity check */
    if (pos == 0
        && buffer[0] != EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED | EEPROM_BIT_VALID))
      return false;

    /* Iterate through the header */
    while (idx < pos + chunk) {
      /* If VALID bit is set, update read index */
      if (buffer[idx - pos] == EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED | EEPROM_BIT_VALID)) {
        cache->read = idx;
      /* Else if not used, update write index */
      } else if (buffer[idx - pos] == EEPROM_BITS(EEPROM_BIT_PRESENT)) {
        if (cache->write == 0)
          cache->write = idx;
      /* Else check for valid value in the header */
      } else if (buffer[idx - pos] != EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED)) {
        return false;
      }
      idx += e->PagesPerEeprom;
    }
  }

  /* Done */
  return true;
}

/** Reads data from the eeprom */
static void eeprom_read_impl(eeprom_addr_t addr, unsigned char *buf, int size, const struct eeprom_t *e)
{
  const struct eeprom_vtbl_t *v = e->Vtbl;
  struct eeprom_state_t *s = e->State;
  const eeprom_addr_t eeprom_size = e->PageSize * e->PagesPerEeprom;

  assert(v != NULL);

  SWINT_AUTO_LOCK();

  /* Sanity check */
  if (addr > eeprom_size || (addr + size) > eeprom_size || size <= 0)
    return;

  /* If no valid data exist, fill buffer with 0xFF */
  if (!s->opened || s->read_page == 0 || !v->Power(true)) {
    memset(buf, 0xFF, size);
  /* Else read the page from flash */
  } else {
    v->Read(buf, eeprom_addr(e, s->read_bank, s->read_page, addr), size);
    /* Release flash resource */
    v->Power(false);
  }
}

/** Writes buffer content to the eeprom */
static void eeprom_write_impl(eeprom_addr_t addr, const unsigned char *buf, int size, const struct eeprom_t *e)
{
  const struct eeprom_vtbl_t *v = e->Vtbl;
  struct eeprom_state_t *s = e->State;
  const eeprom_addr_t eeprom_size = e->PageSize * e->PagesPerEeprom;
  uint8_t *buffer = alloca(EEPROM_BUFFER_SIZE(e));
  unsigned page;

  assert(v != NULL);

  SWINT_AUTO_LOCK();

  /* Sanity check */
  if (addr > eeprom_size || (addr + size) > eeprom_size || size <= 0)
  {
    assert(0);
    return;
  }

  /* Sanity check */
  if (!s->opened)
  {
    assert(0);
    return;
  }

  /* Open flash */
  if (!v->Power(true))
  {
    assert(0);
    return;
  }

  /* When the bank is full, wrap to the next one */
  if (s->write_page + e->PagesPerEeprom > e->PagesPerSector) {
    s->write_page = (e->PagesPerSector + e->PageSize - 1) / e->PageSize;
    s->write_bank ^= BANK_1 ^ BANK_2;
  }

  /* First write USED bit to mark the page as dirty */
  assert(EEPROM_BUFFER_SIZE(e) >= e->PagesPerEeprom);
  memset(buffer, EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED), e->PagesPerEeprom);
  v->Write(eeprom_addr(e, s->write_bank, 0, s->write_page), buffer, e->PagesPerEeprom);

  for (page = 0; page < e->PagesPerEeprom; ++page) {
    /* Read and update content of the EEPROM page */
    eeprom_read_impl(page * e->PageSize, buffer, e->PageSize, e);

    if (addr < (page + 1) * e->PageSize && size > 0) {
      unsigned offset = addr & (e->PageSize - 1);
      unsigned chunk = e->PageSize - offset;
      if (chunk > size)
        chunk = size;

      memcpy(&buffer[offset], buf, chunk);
      addr += chunk;
      buf += chunk;
      size -= chunk;
    }

    /* Write the page back to the flash */
    v->Write(eeprom_addr(e, s->write_bank, s->write_page, page * e->PageSize), buffer, e->PageSize);
  }

  /* Now write the VALID bit indicating that content is synced */
  memset(buffer, EEPROM_BITS(EEPROM_BIT_PRESENT | EEPROM_BIT_USED | EEPROM_BIT_VALID), e->PagesPerEeprom);
  v->Write(eeprom_addr(e, s->write_bank, 0, s->write_page), buffer, e->PagesPerEeprom);

  /* Now we have a valid copy on flash, so erase former read bank */
  if (s->write_bank != s->read_bank)
    eeprom_bank_init(e, buffer, s->read_bank);

  /* Update indexes */
  s->read_bank = s->write_bank;
  s->read_page = s->write_page;
  s->write_page += e->PagesPerEeprom;

  /* Release flash */
  v->Power(false);
}

/** Inializes the eeprom */
static void eeprom_init_impl(const struct eeprom_t *e)
{
  const struct eeprom_vtbl_t *v = e->Vtbl;
  struct eeprom_state_t *s = e->State;
  const uint16_t header_size = (e->PagesPerSector + e->PageSize - 1) / e->PageSize;
  uint8_t *buffer = alloca(EEPROM_BUFFER_SIZE(e));
  struct eeprom_bank_t bank[BANK__COUNT];
  struct eeprom_bank_t idx;
  int i;

  assert(v != NULL);

  SWINT_AUTO_LOCK();

  assert(e->PagesPerEeprom + 1 <= e->PagesPerSector);

  s->opened = false;

  /* Request flash resource */
  if (!v->Power(true))
    return;

  /* Open both banks */
  for (i = 0; i < BANK__COUNT; ++i) {
    if (!eeprom_bank_open(e, buffer, i, &bank[i])) {
      eeprom_bank_init(e, buffer, i);
      eeprom_bank_open(e, buffer, i, &bank[i]);
    }
  }

retry:
  /* Find current read bank */
  if (bank[BANK_1].read == 0 && bank[BANK_2].read == 0)
    idx.read = BANK_1;
  else if (bank[BANK_1].read == 0)
    idx.read = BANK_2;
  else if (bank[BANK_2].read == 0)
    idx.read = BANK_1;
  else if (bank[BANK_1].read < bank[BANK_2].read)
    idx.read = BANK_1;
  else
    idx.read = BANK_2;

  /* Find current write bank */
  if (bank[BANK_1].write == 0 && bank[BANK_2].write == 0) {
    eeprom_bank_init(e, buffer, BANK_1);
    eeprom_bank_open(e, buffer, BANK_1, &bank[BANK_1]);
    eeprom_bank_init(e, buffer, BANK_2);
    eeprom_bank_open(e, buffer, BANK_2, &bank[BANK_2]);
    goto retry;
  } else if (bank[BANK_2].write == 0)
    idx.write = BANK_1;
  else if (bank[BANK_1].write == 0)
    idx.write = BANK_2;
  else if (bank[BANK_2].write == header_size)
    idx.write = BANK_1;
  else if (bank[BANK_1].write == header_size)
    idx.write = BANK_2;
  else if (bank[BANK_1].write > bank[BANK_2].write)
    idx.write = BANK_2;
  else
    idx.write = BANK_1;

  /* Initialize possibly dirty other bank */
  if (idx.read == idx.write) {
    uint8_t other = idx.read ^ (BANK_1 ^ BANK_2);

    if (bank[other].write != header_size || bank[other].read != 0) {
      eeprom_bank_init(e, buffer, other);
      eeprom_bank_open(e, buffer, other, &bank[other]);
      goto retry;
    }
  }

  /* Save state */
  s->read_bank = idx.read;
  s->read_page = bank[idx.read].read;
  s->write_bank = idx.write;
  s->write_page = bank[idx.write].write;

  s->opened = true;

  /* Release flash resource */
  v->Power(false);
}

/*** External flash vtbl impl ***/

static bool eeprom_ext_power(bool On)
{
  if (On)
  {
    return (RequestExtFlash() == 0);
  }
  else
  {
    ReleaseExtFlash();
    return true;
  }
}

static void eeprom_ext_erase(uint32_t SectorIndex)
{
  SpiMemoryEraseSector(&ExtFlash, SectorIndex);
}

static void eeprom_ext_write(uint32_t DstAddress, const void *SrcBuffer, uint32_t ByteCount)
{
  SpiMemoryWrite(&ExtFlash, DstAddress, SrcBuffer, ByteCount);
}

static void eeprom_ext_read(void *DstBuffer, uint32_t SrcAddress, uint32_t ByteCount)
{
  SpiMemoryRead(&ExtFlash, DstBuffer, SrcAddress, ByteCount);
}

/*** Internal flash vtbl impl ***/

static bool eeprom_int_power(bool On)
{
  return true;
}

static void eeprom_int_erase(uint32_t SectorIndex)
{
  DECLARE_FLASH_OP_MONITOR(Monitor);
  sd_flash_page_erase(SectorIndex);
  FLASH_OP_WAIT(Monitor);
}

static void eeprom_int_write(uint32_t DstAddress, const void *SrcBuffer, uint32_t ByteCount)
{
  if (DstAddress & 3)
  {
    uint8_t Data[4] = {0xFF, 0xFF, 0xFF, 0xFF};
    unsigned Chunk = 4 - (DstAddress & 3);

    if (Chunk > ByteCount)
      Chunk = ByteCount;

    memcpy(&Data[DstAddress & 3], SrcBuffer, Chunk);

    DECLARE_FLASH_OP_MONITOR(Monitor);
    sd_flash_write((void *) (DstAddress & 3), (const uint32_t *) &Data, 1);
    FLASH_OP_WAIT(Monitor);

    SrcBuffer = (uint8_t *) SrcBuffer + Chunk;
    DstAddress += Chunk;
    ByteCount -= Chunk;
  }

  if (ByteCount >= 4)
  {
    DECLARE_FLASH_OP_MONITOR(Monitor);
    sd_flash_write((void *) DstAddress, (const uint32_t *) SrcBuffer, ByteCount / 4);
    FLASH_OP_WAIT(Monitor);

    SrcBuffer = (uint8_t *) SrcBuffer + (ByteCount & ~3);
    DstAddress += (ByteCount & ~3);
    ByteCount &= 3;
  }

  if (ByteCount > 0)
  {
    uint8_t Data[4] = {0xFF, 0xFF, 0xFF, 0xFF};

    memcpy(&Data[0], SrcBuffer, ByteCount);

    DECLARE_FLASH_OP_MONITOR(Monitor);
    sd_flash_write((void *) DstAddress, (const uint32_t *) &Data, 1);
    FLASH_OP_WAIT(Monitor);
  }
}

static void eeprom_int_read(void *DstBuffer, uint32_t SrcAddress, uint32_t ByteCount)
{
  memcpy(DstBuffer, (void *) SrcAddress, ByteCount);
}

/*** Module API ***/

void eeprom_write(eeprom_addr_t addr, unsigned char *buf, int size)
{
  int i;
  for (i = 0; i < EepromTableSize; ++i) {
    if (EepromTable[i].BeginAddr <= addr && EepromTable[i].EndAddr >= addr + size) {
      eeprom_write_impl(addr - EepromTable[i].BeginAddr, buf, size, &EepromTable[i]);
      break;
    }
  }
}

void eeprom_read(eeprom_addr_t addr, unsigned char *buf, int size)
{
  int i;
  for (i = 0; i < EepromTableSize; ++i) {
    if (EepromTable[i].BeginAddr <= addr && EepromTable[i].EndAddr >= addr + size) {
      eeprom_read_impl(addr - EepromTable[i].BeginAddr, buf, size, &EepromTable[i]);
      break;
    }
  }
}

void eeprom_init(void)
{
  int i;
  for (i = 0; i < EepromTableSize; ++i) {
    eeprom_init_impl(&EepromTable[i]);
  }
}