cfs-coffee-arch.c

/***********************************************************************
 * File name: cfs-coffee-arch.c
 * EVE-specific coffee FS HAL and extensions.
 *
 * Author: DT, Jetro AS
 ***********************************************************************/
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <core/mwork.h>
#include <lib/env.h>
#include <lib/assert.h>
#include <cfs/cfs.h>
#include <cfs/cfs-coffee.h>
#include <cfs-coffee-arch.h>
#include <dev/resources.h>

/**********************************************************************
 * Macro
 **********************************************************************/
/* Disable debug spam from the module */
#ifndef NDEBUG
  #define NDEBUG
#endif

/** The macro provides debug print functionality */
#ifdef NDEBUG
  #define PRINTD(FORMAT, args...) do {} while (0)
#else
  #define PRINTD(FORMAT, args...) printf(FORMAT, ##args)
#endif

#define COFFEE_PAGE_MASK          (COFFEE_PAGE_SIZE - 1)

/**********************************************************************
 * Local types
 **********************************************************************/
struct coffee_async_format_state_t
{
  struct mwork_t work;
  uint16_t sector;
};


/**********************************************************************
 * Prototypes
 **********************************************************************/
void coffee_async_format_callback(struct mwork_t *work);

/**********************************************************************
 * Variables
 **********************************************************************/

static struct coffee_async_format_state_t coffee_async_format_state =
{
  .work = MWORK_INIT(coffee_async_format_state.work, coffee_async_format_callback),
};

/***********************************************************************
    Local constants
***********************************************************************/

static inline void negate_buffer(void *data, int32_t chunk)
{
  uint32_t addr = (uint32_t) data;
  uint32_t *p = (uint32_t *) (addr & ~0x03);
  uint32_t ms = 0xFFFFFFFF << ((addr & 0x03) << 3);
  chunk += addr & 0x03;
  uint32_t fs = 0xFFFFFFFF >> ((0x04 - (chunk & 0x03)) << 3);
  chunk >>= 2;
  uint32_t i;

  if (chunk)
  {
    p[0] ^= ms;
    p[chunk] ^= fs;
    for (i = 1; i < chunk; ++i)
      p[i] ^= 0xFFFFFFFF;
  }
  else
  {
    p[0] ^= (ms & fs);
  }
}

/***********************************************************************
 * Name: flash_read
 **********************************************************************/
void flash_read(uint32_t address, void *data, uint32_t length)
{
  char *p = data;
  uint32_t next;
  uint32_t chunk;

  while (length)
  {
    next = (address | COFFEE_PAGE_MASK) + 1;
    chunk = next - address;
    if (chunk > length)
      chunk = length;

    SpiMemoryRead(&ExtFlash, p, address, chunk);
    negate_buffer(p, chunk);

    address = next;
    length -= chunk;
    p += chunk;
  }
}

/***********************************************************************
 * Name: flash_write
 **********************************************************************/
void flash_write(uint32_t address, const void *data, uint32_t length)
{
  const char *p = data;
  uint32_t next;
  uint32_t chunk;

  assert(length == 0 || ((uint32_t) data & 0x20000000) != 0);

  while (length)
  {
    next = (address | COFFEE_PAGE_MASK) + 1;
    chunk = next - address;
    if (chunk > length)
      chunk = length;

    negate_buffer((void *) p, chunk);
    SpiMemoryWrite(&ExtFlash, address, p, chunk);
    negate_buffer((void *) p, chunk);

    address = next;
    length -= chunk;
    p += chunk;
  }
}

/***********************************************************************
 * Name: coffee_async_format
 **********************************************************************/
enum coffee_async_format_status_t coffee_async_format_status(void)
{
  if (mwork_pending(&coffee_async_format_state.work))
    return COFFEE_ASYNC_FORMAT_ONGOING;
  else
    return COFFEE_ASYNC_FORMAT_IDLE;
}

/***********************************************************************
 * Name: coffee_async_format
 **********************************************************************/
void coffee_async_format(void)
{
  unsigned size;
  void *mem = cfs_coffee_get_protected_mem(&size);

  swint_state_t swint = swint_disable();
  if (mwork_pending(&coffee_async_format_state.work))
    mwork_cancel(&coffee_async_format_state.work);
  else
    RequestExtFlash();
  memset(mem, 0, size);
  coffee_async_format_state.work.at = mwork_now();
  coffee_async_format_state.sector = 0;
  mwork_schedule(&coffee_async_format_state.work);
  swint_enable(swint);
}

/***********************************************************************
 * Name: coffee_async_format
 **********************************************************************/
void coffee_async_format_cancel(void)
{
  swint_state_t swint = swint_disable();
  if (mwork_pending(&coffee_async_format_state.work))
  {
    mwork_cancel(&coffee_async_format_state.work);
    ReleaseExtFlash();
  }
  swint_enable(swint);
}

/***********************************************************************
 * Local functions
 **********************************************************************/
void coffee_async_format_callback(struct mwork_t *work)
{
  struct coffee_async_format_state_t *state =
      container_of(work, struct coffee_async_format_state_t, work);

  if (SpiIsBusy(ExtFlash.Spi))
  {
    PRINTD("⋅");
reschedule_default:
    state->work.at += MS_TO_TICKS(30);
reschedule:
    mwork_schedule(&state->work);
    return;
  }

  if (SpiMemoryIsBusy(&ExtFlash))
  {
    PRINTD("$");
    state->work.at += MS_TO_TICKS(100);
    goto reschedule;
  }

  if (state->sector >= COFFEE_SIZE / COFFEE_SECTOR_SIZE)
  {
    ReleaseExtFlash();
    PRINTD("Ж");
    return;
  }

  PRINTD("*");
  if (!SpiMemoryEraseBlockAsync(&ExtFlash, COFFEE_START_SECTOR + state->sector))
  {
    PRINTD("¤");
    goto reschedule_default;
  }

  state->sector++;
  state->work.at += MS_TO_TICKS(300);
  mwork_schedule(&state->work);
}