board_periph_sd.c

Go to the documentation of this file.

 
#include "board_periph_sd.h"
 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include "board_console.h"
#include "board_periph_sd_internal.h"

typedef enum : uint32_t {
  k_sd_console_line_cap = 48U, 
  k_sd_console_rd_every = 16U, 
} sd_console_t;

static uint32_t s_sd_spi_block_reads;

typedef enum : uint8_t {
  k_sd_idx_cmd0   = 0U,  
  k_sd_idx_cmd8   = 8U,  
  k_sd_idx_cmd9   = 9U,  
  k_sd_idx_cmd12  = 12U, 
  k_sd_idx_cmd16  = 16U, 
  k_sd_idx_cmd17  = 17U, 
  k_sd_idx_cmd18  = 18U, 
  k_sd_idx_cmd24  = 24U, 
  k_sd_idx_cmd25  = 25U, 
  k_sd_idx_cmd32  = 32U, 
  k_sd_idx_cmd33  = 33U, 
  k_sd_idx_cmd38  = 38U, 
  k_sd_idx_acmd41 = 41U, 
  k_sd_idx_cmd55  = 55U, 
  k_sd_idx_cmd58  = 58U, 
} board_sd_cmd_idx_t;

board_sd_state_t g_board_sd = {.image_fd = -1};

RA8_INTERNAL static uint16_t internal_board_sd_crc16(const uint8_t* data, uint32_t len)
{
  uint16_t crc = 0U;
  for (uint32_t i = 0U; i < len; i++) {
    crc ^= (uint16_t)((uint16_t)data[i] << (uint16_t)k_sd_byte_bits);
    for (uint8_t b = 0U; b < (uint8_t)k_sd_byte_bits; b++) {
      const bool msb = (crc & (uint16_t)k_sd_crc_msb) != 0U;
      crc            = (uint16_t)(crc << 1U);
      if (msb) {
        crc = (uint16_t)(crc ^ (uint16_t)k_sd_crc_poly);
      }
    }
  }
  return crc;
}

RA8_INTERNAL static bool
internal_board_sd_fill_block(const board_sd_state_t* c, uint64_t off, uint8_t* blk)
{
  (void)memset(blk, 0, (size_t)k_sd_block);
  if (off >= c->image_len) {
    return true;
  }
  const uint64_t available = c->image_len - off;
  const size_t count = (available < (uint64_t)k_sd_block) ? (size_t)available : (size_t)k_sd_block;
  return priv_board_sd_storage_read(off, blk, count);
}

RA8_INTERNAL static void
internal_board_sd_stage_block(board_sd_state_t* c, const uint8_t* payload, uint32_t len)
{
  c->resp[0] = (uint8_t)k_sd_r1_ready;
  c->resp[1] = (uint8_t)k_sd_tok_data;
  memcpy(&c->resp[2], payload, len);
  const uint16_t crc     = internal_board_sd_crc16(&c->resp[2], len);
  c->resp[2U + len]      = (uint8_t)(crc >> (uint16_t)k_sd_byte_bits);
  c->resp[2U + len + 1U] = (uint8_t)(crc & (uint16_t)k_sd_byte_mask);
  c->resp_len            = 2U + len + 2U;
  /* Console SD tab: anti-flood -- the first block and then every Nth, so a
   * book-sized multi-block read shows activity without swamping the ring. */
  s_sd_spi_block_reads++;
  bool sd_report = (s_sd_spi_block_reads == 1U);
  if ((s_sd_spi_block_reads % (uint32_t)k_sd_console_rd_every) == 0U) {
    sd_report = true;
  }
  if (sd_report) {
    char ln[k_sd_console_line_cap];
    (void)
      snprintf(ln, sizeof(ln), "SDSPI rd %uB (#%u)", (unsigned)len, (unsigned)s_sd_spi_block_reads);
    board_console_push(k_board_console_ch_sd, ln);
  }
}

RA8_INTERNAL static void
internal_board_sd_begin_read(board_sd_state_t* c, uint8_t idx, uint32_t arg)
{
  uint8_t        blk[k_sd_block] = {};
  const uint64_t off             = (uint64_t)arg * (uint64_t)k_sd_block;
  if (!internal_board_sd_fill_block(c, off, blk)) {
    c->resp[0]  = (uint8_t)k_sd_r1_param_err;
    c->resp_len = 1U;
    c->rd_multi = false;
    return;
  }
  internal_board_sd_stage_block(c, blk, (uint32_t)k_sd_block);
  c->rd_multi = (idx == (uint8_t)k_sd_idx_cmd18);
  c->rd_off   = off + (uint64_t)k_sd_block;
}

RA8_INTERNAL static void internal_board_sd_read_stream_next(board_sd_state_t* c)
{
  uint8_t blk[k_sd_block] = {};
  if (!internal_board_sd_fill_block(c, c->rd_off, blk)) {
    c->resp[0]  = (uint8_t)k_sd_read_error;
    c->resp_len = 1U;
    c->resp_pos = 0U;
    c->rd_multi = false;
    return;
  }
  internal_board_sd_stage_block(c, blk, (uint32_t)k_sd_block);
  c->resp_pos = 1U; /* skip the R1 slot: mid-stream blocks carry none. */
  c->rd_off += (uint64_t)k_sd_block;
}

RA8_INTERNAL static void internal_board_sd_stop_read(board_sd_state_t* c, uint8_t r1)
{
  c->rd_multi = false;
  c->resp[0]  = (uint8_t)k_sd_idle; /* stuff byte (tail of the cut stream). */
  c->resp[1]  = r1;
  c->resp[2]  = (uint8_t)k_sd_busy;
  c->resp[3]  = (uint8_t)k_sd_idle;
  c->resp_len = 4U;
}

RA8_INTERNAL static void
internal_board_sd_begin_write(board_sd_state_t* c, uint8_t idx, uint32_t arg, uint8_t r1)
{
  c->resp[0]  = r1;
  c->resp_len = 1U;
  c->wr_phase = k_sd_wr_token;
  c->wr_multi = (idx == (uint8_t)k_sd_idx_cmd25);
  c->wr_off   = (uint64_t)arg * (uint64_t)k_sd_block;
  c->wr_cnt   = 0U;
  /* Console SD tab: one line per SD-over-SPI block-write command. */
  char ln[k_sd_console_line_cap];
  (void)snprintf(ln, sizeof(ln), "SDSPI wr blk=%u", (unsigned)arg);
  board_console_push(k_board_console_ch_sd, ln);
}

RA8_INTERNAL static void internal_sd_write_token(board_sd_state_t* c, uint8_t tx)
{
  if ((tx == (uint8_t)k_sd_tok_data) || (tx == (uint8_t)k_sd_tok_wmulti)) {
    c->wr_phase = k_sd_wr_data;
    c->wr_cnt   = 0U;
  } else if (c->wr_multi && (tx == (uint8_t)k_sd_tok_stop)) {
    c->wr_phase = k_sd_wr_idle;
    c->wr_multi = false;
    c->resp[0]  = (uint8_t)k_sd_busy; /* program time, then done. */
    c->resp[1]  = (uint8_t)k_sd_idle;
    c->resp_len = 2U;
    c->resp_pos = 0U;
  } else {
    /* Not a token the card acts on: ignored. */
  }
}

RA8_INTERNAL static void internal_sd_write_data(board_sd_state_t* c, uint8_t tx)
{
  if (c->wr_cnt < (uint32_t)k_sd_block) {
    c->wr_block[c->wr_cnt] = tx;
  }
  c->wr_cnt++;
  if (c->wr_cnt >= (uint32_t)k_sd_block) {
    c->wr_phase = k_sd_wr_crc;
    c->wr_cnt   = 0U;
  }
}

RA8_INTERNAL static void internal_sd_write_crc(board_sd_state_t* c)
{
  c->wr_cnt++;
  if (c->wr_cnt < (uint32_t)k_sd_crc_len) {
    return;
  }
  const bool write_ok = priv_board_sd_storage_write(c->wr_off, c->wr_block, (size_t)k_sd_block);
  c->resp[0]          = write_ok ? (uint8_t)k_sd_data_accept : (uint8_t)k_sd_data_error;
  c->resp[1]          = (uint8_t)k_sd_busy;
  c->resp[2]          = (uint8_t)k_sd_idle;
  c->resp_len         = 3U;
  c->resp_pos         = 0U;
  c->wr_cnt           = 0U;
  if (c->wr_multi) {
    c->wr_off += (uint64_t)k_sd_block; /* next block of the multi-write. */
    c->wr_phase = k_sd_wr_token;
  } else {
    c->wr_phase = k_sd_wr_idle;
  }
}

RA8_INTERNAL static uint8_t internal_board_sd_write_byte(board_sd_state_t* c, uint8_t tx)
{
  if (c->wr_phase == k_sd_wr_token) {
    internal_sd_write_token(c, tx);
  } else if (c->wr_phase == k_sd_wr_data) {
    internal_sd_write_data(c, tx);
  } else {
    internal_sd_write_crc(c);
  }
  return (uint8_t)k_sd_idle;
}

RA8_INTERNAL static void internal_board_sd_cmd_send_csd(board_sd_state_t* c)
{
  uint8_t csd[k_sd_csd_len];
  memset(csd, 0, sizeof(csd));
  csd[0]         = (uint8_t)k_sd_csd_v2;
  uint32_t csize = (uint32_t)k_sd_csd_csize; /* fallback: 8 MiB. */
  if (c->image_len >= (uint32_t)k_sd_csd_unit) {
    csize = (c->image_len / (uint32_t)k_sd_csd_unit) - 1U;
  }
  csd[k_sd_csd_csize_b7] =
    (uint8_t)((csize >> (uint32_t)k_sd_arg_sh1) & (uint32_t)k_sd_csize_b7_mask);
  csd[k_sd_csd_csize_b8] =
    (uint8_t)((csize >> (uint32_t)k_sd_byte_bits) & (uint16_t)k_sd_byte_mask);
  csd[k_sd_csd_off] = (uint8_t)(csize & (uint16_t)k_sd_byte_mask);
  internal_board_sd_stage_block(c, csd, (uint32_t)k_sd_csd_len);
}

RA8_INTERNAL static bool
internal_board_sd_dispatch_ident(board_sd_state_t* c, uint8_t idx, uint8_t r1)
{
  switch (idx) {
    case (uint8_t)k_sd_idx_cmd0:
      c->resp[0]  = (uint8_t)k_sd_r1_idle;
      c->resp_len = 1U;
      break;
    case (uint8_t)k_sd_idx_cmd8: /* R7: R1 + 0x000001AA echo. */
      c->resp[0]  = (uint8_t)k_sd_r1_idle;
      c->resp[1]  = 0U;
      c->resp[2]  = 0U;
      c->resp[3]  = 1U;
      c->resp[4]  = (uint8_t)k_sd_cmd8_echo;
      c->resp_len = (uint8_t)k_sd_r7_len;
      break;
    case (uint8_t)k_sd_idx_cmd55:
      c->app_cmd  = true;
      c->resp[0]  = (uint8_t)k_sd_r1_idle;
      c->resp_len = 1U;
      break;
    case (uint8_t)k_sd_idx_cmd58: /* R3: R1 + OCR (CCS=1 -> SDHC). */
      c->resp[0]  = r1;
      c->resp[1]  = (uint8_t)k_sd_ocr_pwrccs;
      c->resp[2]  = (uint8_t)k_sd_idle;
      c->resp[3]  = (uint8_t)k_sd_ocr_volt;
      c->resp[4]  = 0U;
      c->resp_len = (uint8_t)k_sd_r7_len;
      break;
    case (uint8_t)k_sd_idx_cmd16:
      c->resp[0]  = (uint8_t)k_sd_r1_ready;
      c->resp_len = 1U;
      break;
    default:
      return false;
  }
  return true;
}

RA8_INTERNAL static void
internal_board_sd_cmd_erase_bound(board_sd_state_t* c, uint32_t* bound, uint32_t arg, uint8_t r1)
{
  *bound      = arg;
  c->resp[0]  = r1;
  c->resp_len = 1U;
}

RA8_INTERNAL static void internal_board_sd_cmd_erase(board_sd_state_t* c, uint8_t r1)
{
  if (c->erase_end >= c->erase_start) {
    const uint64_t lo  = (uint64_t)c->erase_start * (uint64_t)k_sd_block;
    const uint64_t hi  = ((uint64_t)c->erase_end + 1U) * (uint64_t)k_sd_block;
    const uint64_t end = (hi < c->image_len) ? hi : c->image_len;
    if (lo < end) {
      if (!priv_board_sd_storage_zero(lo, end - lo)) {
        r1 = (uint8_t)k_sd_r1_param_err;
      }
    }
  }
  c->resp[0]  = r1;
  c->resp_len = 1U;
}

RA8_INTERNAL static void
internal_board_sd_dispatch_data(board_sd_state_t* c, uint8_t idx, uint32_t arg, uint8_t r1)
{
  switch (idx) {
    case (uint8_t)k_sd_idx_cmd9: /* SEND_CSD: 16-byte CSD v2.0 data block. */
      internal_board_sd_cmd_send_csd(c);
      break;
    case (uint8_t)k_sd_idx_cmd17: /* READ_SINGLE_BLOCK   (SDHC: arg = block). */
    case (uint8_t)k_sd_idx_cmd18: /* READ_MULTIPLE_BLOCK -- streams to CMD12. */
      internal_board_sd_begin_read(c, idx, arg);
      break;
    case (uint8_t)k_sd_idx_cmd12: /* STOP_TRANSMISSION: end a CMD18 stream. */
      internal_board_sd_stop_read(c, r1);
      break;
    case (uint8_t)k_sd_idx_cmd24: /* WRITE_SINGLE_BLOCK   */
    case (uint8_t)k_sd_idx_cmd25: /* WRITE_MULTIPLE_BLOCK */
      internal_board_sd_begin_write(c, idx, arg, r1);
      break;
    case (uint8_t)k_sd_idx_cmd32: /* ERASE_WR_BLK_START (SDHC: arg = block). */
      internal_board_sd_cmd_erase_bound(c, &c->erase_start, arg, r1);
      break;
    case (uint8_t)k_sd_idx_cmd33: /* ERASE_WR_BLK_END (SDHC: arg = block). */
      internal_board_sd_cmd_erase_bound(c, &c->erase_end, arg, r1);
      break;
    case (uint8_t)k_sd_idx_cmd38: /* ERASE: zero the latched [start, end] range. */
      internal_board_sd_cmd_erase(c, r1);
      break;
    default:
      c->resp[0]  = r1;
      c->resp_len = 1U;
      break;
  }
}

RA8_INTERNAL static void internal_board_sd_process_cmd(board_sd_state_t* c)
{
  const uint8_t  idx     = (uint8_t)(c->cmd[0] & (uint8_t)k_sd_idx_mask);
  const uint32_t arg     = ((uint32_t)c->cmd[1] << (uint32_t)k_sd_arg_sh0) |
                           ((uint32_t)c->cmd[2] << (uint32_t)k_sd_arg_sh1) |
                           ((uint32_t)c->cmd[3] << (uint32_t)k_sd_byte_bits) | (uint32_t)c->cmd[4];
  const bool     was_app = c->app_cmd;
  const uint8_t  r1      = c->ready ? (uint8_t)k_sd_r1_ready : (uint8_t)k_sd_r1_idle;
  c->app_cmd             = false;
  c->resp_pos            = 0U;
  c->resp_len            = 0U;
 
  if ((idx == (uint8_t)k_sd_idx_acmd41) && was_app) { /* ACMD41 -- init done. */
    c->ready    = true;
    c->resp[0]  = (uint8_t)k_sd_r1_ready;
    c->resp_len = 1U;
    return;
  }
  if (internal_board_sd_dispatch_ident(c, idx, r1)) {
    return;
  }
  internal_board_sd_dispatch_data(c, idx, arg, r1);
}
 
uint8_t board_sd_exchange(uint8_t tx)
{
  if (g_board_sd.resp_pos < g_board_sd.resp_len) {
    return g_board_sd.resp[g_board_sd.resp_pos++];
  }
  if (g_board_sd.wr_phase != k_sd_wr_idle) {
    return internal_board_sd_write_byte(&g_board_sd, tx);
  }
  if (g_board_sd.collecting) {
    g_board_sd.cmd[g_board_sd.cmd_idx] = tx;
    g_board_sd.cmd_idx++;
    if (g_board_sd.cmd_idx >= (uint32_t)k_sd_cmd_len) {
      g_board_sd.collecting = false;
      internal_board_sd_process_cmd(&g_board_sd);
    }
    return (uint8_t)k_sd_idle;
  }
  if ((tx & (uint8_t)k_sd_cmd_mask) == (uint8_t)k_sd_cmd_start) {
    g_board_sd.collecting = true;
    g_board_sd.cmd[0]     = tx;
    g_board_sd.cmd_idx    = 1U;
    return (uint8_t)k_sd_idle;
  }
  if (g_board_sd.rd_multi) {
    /* Open CMD18 stream: the host clocking idle is fetching the next block.
     * The command-start check above stays first so a CMD12 frame interrupts
     * the stream instead of being swallowed as read clocking. */
    internal_board_sd_read_stream_next(&g_board_sd);
    return g_board_sd.resp[g_board_sd.resp_pos++];
  }
  return (uint8_t)k_sd_idle;
}
 
bool board_sd_read_block(uint32_t lba, uint8_t* dst)
{
  if (!g_board_sd.attached || (g_board_sd.image_fd < 0) || (dst == nullptr)) {
    return false;
  }
  /* Same SDHC block-addressing as the CMD17 path: arg is a block index. */
  const uint64_t off = (uint64_t)lba * (uint64_t)k_sd_block;
  if (off >= g_board_sd.image_len) {
    return false; /* past the end of the card -- let the real driver error out. */
  }
  uint8_t block[k_sd_block];
  if (!internal_board_sd_fill_block(&g_board_sd, off, block)) {
    return false;
  }
  (void)memcpy(dst, block, sizeof(block));
  return true;
}
 
bool board_sd_write_block(uint32_t lba, const uint8_t* src)
{
  if (!g_board_sd.attached || (g_board_sd.image_fd < 0) || (src == nullptr)) {
    return false;
  }
  /* Same SDHC block-addressing as the CMD24 path: arg is a block index. */
  const uint64_t off = (uint64_t)lba * (uint64_t)k_sd_block;
  if (off >= g_board_sd.image_len) {
    return false; /* past the end of the card -- let the real driver error out. */
  }
  if ((off + (uint64_t)k_sd_block) > g_board_sd.image_len) {
    return false; /* a full block would run off the end of the image. */
  }
  return priv_board_sd_storage_write(off, src, (size_t)k_sd_block);
}
 
void board_sd_reset(void)
{
  g_board_sd.collecting = false;
  g_board_sd.app_cmd    = false;
  g_board_sd.ready      = false;
  g_board_sd.cmd_idx    = 0U;
  g_board_sd.resp_len   = 0U;
  g_board_sd.resp_pos   = 0U;
  g_board_sd.wr_phase   = k_sd_wr_idle;
  g_board_sd.wr_multi   = false;
  g_board_sd.wr_off     = 0U;
  g_board_sd.wr_cnt     = 0U;
  g_board_sd.rd_multi   = false;
  g_board_sd.rd_off     = 0U;
}