board_periph_sdhi.c

Go to the documentation of this file.

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

typedef enum : uint32_t {
  k_sdhi_console_line_cap = 48U, 
} sdhi_console_t;

typedef enum : uint64_t {
  k_sdhi_base          = 0x40252000UL, 
  k_sdhi_span          = 0x200UL,      
  k_sdhi_off_sd_cmd    = 0x000UL,      
  k_sdhi_off_sd_arg    = 0x008UL,      
  k_sdhi_off_sd_stop   = 0x010UL,      
  k_sdhi_off_sd_seccnt = 0x014UL,      
  k_sdhi_off_sd_rsp10  = 0x018UL,      
  k_sdhi_off_sd_rsp32  = 0x020UL,      
  k_sdhi_off_sd_rsp54  = 0x028UL,      
  k_sdhi_off_sd_rsp76  = 0x030UL,      
  k_sdhi_off_sd_info1  = 0x038UL,      
  k_sdhi_off_sd_info2  = 0x03CUL,      
  k_sdhi_off_sd_option = 0x050UL,      
  k_sdhi_off_sd_buf0   = 0x060UL,      
  k_sdhi_off_soft_rst  = 0x1C0UL,      
} sdhi_reg_map_t;

typedef enum : uint32_t {
  k_sdhi_info1_rspend = 0x00000001U, 
  k_sdhi_info2_bre    = 0x00000100U, 
  k_sdhi_info2_bwe    = 0x00000200U, 
} sdhi_status_t;

typedef enum : uint32_t {
  k_sdhi_option_width_bit  = 0x00008000U, 
  k_sdhi_option_width8_bit = 0x00002000U, 
  k_sdhi_lanes_1bit        = 1U,          
  k_sdhi_lanes_4bit        = 4U,          
  k_sdhi_lanes_8bit        = 8U,          
} sdhi_option_bits_t;

typedef enum : uint32_t {
  k_sdhi_cmd0_go_idle   = 0U,  
  k_sdhi_cmd2_send_cid  = 2U,  
  k_sdhi_cmd3_send_rca  = 3U,  
  k_sdhi_cmd7_select    = 7U,  
  k_sdhi_cmd8_if_cond   = 8U,  
  k_sdhi_cmd9_send_csd  = 9U,  
  k_sdhi_cmd12_stop     = 12U, 
  k_sdhi_cmd16_blocklen = 16U, 
  k_sdhi_cmd17_read1    = 17U, 
  k_sdhi_cmd18_readm    = 18U, 
  k_sdhi_cmd24_write1   = 24U, 
  k_sdhi_cmd25_writem   = 25U, 
  k_sdhi_acmd41_op_cond = 41U, 
  k_sdhi_cmd55_app_cmd  = 55U, 
} sdhi_cmd_idx_t;

typedef enum : uint32_t {
  k_sdhi_cmd_index_mask = 0x0000003FU, 
  k_sdhi_r1_app_cmd     = 0x00000020U, 
  k_sdhi_r1_ready       = 0x00000900U, 
  k_sdhi_r7_if_cond     = 0x000001AAU, 
  k_sdhi_ocr_ready      = 0xC0FF8000U, 
  k_sdhi_cid_word       = 0x52413844U, 
  k_sdhi_rca_value      = 0x00010000U, 
  k_sdhi_csd_v2_struct  = 0x40000000U, 
  k_sdhi_csize_lo_mask  = 0x0000003FU, 
  k_sdhi_csize_mid_mask = 0x0000FFFFU, 
} sdhi_resp_const_t;

typedef enum : uint32_t {
  k_sdhi_words         = 128U,  
  k_sdhi_block_bytes   = 512U,  
  k_sdhi_words_per_blk = 128U,  
  k_sdhi_byte_bits     = 8U,    
  k_sdhi_byte_mask     = 0xFFU, 
  k_sdhi_csize_unit    = 1024U, 
  k_sdhi_csize_shift   = 16U,   
} sdhi_geom_t;

typedef enum : uint32_t {
  k_sdhi_block_order = 96U, 
} sdhi_order_t;

typedef enum : uint8_t {
  k_sdhi_xfer_none  = 0U, 
  k_sdhi_xfer_read  = 1U, 
  k_sdhi_xfer_write = 2U, 
} sdhi_xfer_t;

typedef struct {
  uint32_t regs[k_sdhi_words];        
  uint32_t rsp[4];                    
  uint8_t  stage[k_sdhi_block_bytes]; 
  uint32_t word_idx;                  
  uint32_t lba;                       
  uint32_t blocks_left;               
  uint8_t  app_cmd;                   
  uint8_t  xfer;                      
  uint32_t reads;                     
  uint32_t writes;                    
} sdhi_state_t;
 
static sdhi_state_t s_sdhi;

RA8_INTERNAL static uint32_t internal_sdhi_word(uint64_t off)
{
  return (uint32_t)(off / 4U);
}

RA8_INTERNAL static void internal_sdhi_publish_response(void)
{
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_rsp10)] = s_sdhi.rsp[0];
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_rsp32)] = s_sdhi.rsp[1];
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_rsp54)] = s_sdhi.rsp[2];
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_rsp76)] = s_sdhi.rsp[3];
}

RA8_INTERNAL static void internal_sdhi_make_csd(void)
{
  uint64_t bytes = 0U;
  board_sd_info(nullptr, &bytes, nullptr, nullptr);
  uint32_t cap_blocks = (uint32_t)(bytes / (uint64_t)k_sdhi_block_bytes);
  if (cap_blocks < (uint32_t)k_sdhi_csize_unit) {
    cap_blocks = (uint32_t)k_sdhi_csize_unit; /* floor: keep c_size non-negative. */
  }
  const uint32_t c_size = (cap_blocks / (uint32_t)k_sdhi_csize_unit) - 1U;
  s_sdhi.rsp[3]         = (uint32_t)k_sdhi_csd_v2_struct;
  s_sdhi.rsp[2]         = (c_size >> (uint32_t)k_sdhi_csize_shift) & (uint32_t)k_sdhi_csize_lo_mask;
  s_sdhi.rsp[1] = (c_size & (uint32_t)k_sdhi_csize_mid_mask) << (uint32_t)k_sdhi_csize_shift;
  s_sdhi.rsp[0] = 0U;
}

RA8_INTERNAL static void internal_sdhi_load_block(void)
{
  (void)memset(s_sdhi.stage, 0, sizeof(s_sdhi.stage));
  (void)board_sd_read_block(s_sdhi.lba, s_sdhi.stage);
  s_sdhi.word_idx = 0U;
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info2)] |= (uint32_t)k_sdhi_info2_bre;
}

RA8_INTERNAL static void internal_sdhi_begin_read(bool multi)
{
  s_sdhi.xfer        = (uint8_t)k_sdhi_xfer_read;
  s_sdhi.blocks_left = multi ? s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_seccnt)] : 1U;
  if (s_sdhi.blocks_left == 0U) {
    s_sdhi.blocks_left = 1U;
  }
  /* Console SD tab: one line per block-read command (CMD17/CMD18). */
  char ln[k_sdhi_console_line_cap];
  (void)snprintf(ln,
                 sizeof(ln),
                 "SDHI rd lba=%u x%u",
                 (unsigned)s_sdhi.lba,
                 (unsigned)s_sdhi.blocks_left);
  board_console_push(k_board_console_ch_sd, ln);
  internal_sdhi_load_block();
}

RA8_INTERNAL static void internal_sdhi_begin_write(bool multi)
{
  s_sdhi.xfer        = (uint8_t)k_sdhi_xfer_write;
  s_sdhi.blocks_left = multi ? s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_seccnt)] : 1U;
  if (s_sdhi.blocks_left == 0U) {
    s_sdhi.blocks_left = 1U;
  }
  (void)memset(s_sdhi.stage, 0, sizeof(s_sdhi.stage));
  s_sdhi.word_idx = 0U;
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info2)] |= (uint32_t)k_sdhi_info2_bwe;
  /* Console SD tab: one line per block-write command (CMD24/CMD25). */
  char ln[k_sdhi_console_line_cap];
  (void)snprintf(ln,
                 sizeof(ln),
                 "SDHI wr lba=%u x%u",
                 (unsigned)s_sdhi.lba,
                 (unsigned)s_sdhi.blocks_left);
  board_console_push(k_board_console_ch_sd, ln);
}

RA8_INTERNAL static void internal_sdhi_exec_ident(uint32_t idx, uint32_t arg)
{
  (void)arg;
  if ((idx == (uint32_t)k_sdhi_acmd41_op_cond) && (s_sdhi.app_cmd != 0U)) {
    s_sdhi.rsp[0] = (uint32_t)k_sdhi_ocr_ready;
    return;
  }
  switch (idx) {
    case (uint32_t)k_sdhi_cmd8_if_cond:
      s_sdhi.rsp[0] = (uint32_t)k_sdhi_r7_if_cond;
      break;
    case (uint32_t)k_sdhi_cmd55_app_cmd:
      s_sdhi.app_cmd = 1U;
      /* Echo APP_CMD so the ACMD6 SET_BUS_WIDTH that may follow is
       * honoured by the driver's 4-bit negotiation check. */
      s_sdhi.rsp[0] = (uint32_t)k_sdhi_r1_ready | (uint32_t)k_sdhi_r1_app_cmd;
      break;
    case (uint32_t)k_sdhi_cmd2_send_cid:
      s_sdhi.rsp[0] = (uint32_t)k_sdhi_cid_word;
      s_sdhi.rsp[1] = (uint32_t)k_sdhi_cid_word;
      s_sdhi.rsp[2] = (uint32_t)k_sdhi_cid_word;
      s_sdhi.rsp[3] = (uint32_t)k_sdhi_cid_word;
      break;
    case (uint32_t)k_sdhi_cmd3_send_rca:
      s_sdhi.rsp[0] = (uint32_t)k_sdhi_rca_value;
      break;
    case (uint32_t)k_sdhi_cmd9_send_csd:
      internal_sdhi_make_csd();
      break;
    default:
      s_sdhi.rsp[0] = (uint32_t)k_sdhi_r1_ready;
      break;
  }
}

RA8_INTERNAL static void internal_sdhi_exec_command(uint32_t cmd)
{
  const uint32_t idx = cmd & (uint32_t)k_sdhi_cmd_index_mask;
  const uint32_t arg = s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_arg)];
 
  s_sdhi.rsp[0] = (uint32_t)k_sdhi_r1_ready;
  s_sdhi.rsp[1] = 0U;
  s_sdhi.rsp[2] = 0U;
  s_sdhi.rsp[3] = 0U;
 
  switch (idx) {
    case (uint32_t)k_sdhi_cmd17_read1:
      s_sdhi.lba = arg;
      internal_sdhi_begin_read(false);
      break;
    case (uint32_t)k_sdhi_cmd18_readm:
      s_sdhi.lba = arg;
      internal_sdhi_begin_read(true);
      break;
    case (uint32_t)k_sdhi_cmd24_write1:
      s_sdhi.lba = arg;
      internal_sdhi_begin_write(false);
      break;
    case (uint32_t)k_sdhi_cmd25_writem:
      s_sdhi.lba = arg;
      internal_sdhi_begin_write(true);
      break;
    case (uint32_t)k_sdhi_cmd12_stop:
      s_sdhi.xfer = (uint8_t)k_sdhi_xfer_none;
      break;
    default:
      internal_sdhi_exec_ident(idx, arg);
      break;
  }
  /* CMD55 sets app_cmd; every other command clears the one-shot prefix. */
  if (idx != (uint32_t)k_sdhi_cmd55_app_cmd) {
    s_sdhi.app_cmd = 0U;
  }
  internal_sdhi_publish_response();
  s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info1)] |= (uint32_t)k_sdhi_info1_rspend;
}

RA8_INTERNAL static uint32_t internal_sdhi_buf_read(void)
{
  if (s_sdhi.xfer != (uint8_t)k_sdhi_xfer_read) {
    return 0U;
  }
  const uint32_t b    = s_sdhi.word_idx * 4U;
  const uint32_t word = (uint32_t)s_sdhi.stage[b] |
                        ((uint32_t)s_sdhi.stage[b + 1U] << (uint32_t)k_sdhi_byte_bits) |
                        ((uint32_t)s_sdhi.stage[b + 2U] << (2U * (uint32_t)k_sdhi_byte_bits)) |
                        ((uint32_t)s_sdhi.stage[b + 3U] << (3U * (uint32_t)k_sdhi_byte_bits));
  s_sdhi.word_idx++;
  if (s_sdhi.word_idx < (uint32_t)k_sdhi_words_per_blk) {
    return word;
  }
  /* Block drained: advance a multi-block read, else end the phase. */
  s_sdhi.reads++;
  if (s_sdhi.blocks_left > 0U) {
    s_sdhi.blocks_left--;
  }
  if (s_sdhi.blocks_left > 0U) {
    s_sdhi.lba++;
    internal_sdhi_load_block();
  } else {
    s_sdhi.xfer = (uint8_t)k_sdhi_xfer_none;
    s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info2)] &= ~(uint32_t)k_sdhi_info2_bre;
  }
  return word;
}

RA8_INTERNAL static void internal_sdhi_buf_write(uint32_t word)
{
  if (s_sdhi.xfer != (uint8_t)k_sdhi_xfer_write) {
    return;
  }
  const uint32_t b = s_sdhi.word_idx * 4U;
  s_sdhi.stage[b]  = (uint8_t)(word & (uint32_t)k_sdhi_byte_mask);
  s_sdhi.stage[b + 1U] =
    (uint8_t)((word >> (uint32_t)k_sdhi_byte_bits) & (uint32_t)k_sdhi_byte_mask);
  s_sdhi.stage[b + 2U] =
    (uint8_t)((word >> (2U * (uint32_t)k_sdhi_byte_bits)) & (uint32_t)k_sdhi_byte_mask);
  s_sdhi.stage[b + 3U] =
    (uint8_t)((word >> (3U * (uint32_t)k_sdhi_byte_bits)) & (uint32_t)k_sdhi_byte_mask);
  s_sdhi.word_idx++;
  if (s_sdhi.word_idx < (uint32_t)k_sdhi_words_per_blk) {
    return;
  }
  /* Block filled: commit it, advance a multi-block write, else end the phase. */
  (void)board_sd_write_block(s_sdhi.lba, s_sdhi.stage);
  s_sdhi.writes++;
  s_sdhi.word_idx = 0U;
  if (s_sdhi.blocks_left > 0U) {
    s_sdhi.blocks_left--;
  }
  if (s_sdhi.blocks_left > 0U) {
    s_sdhi.lba++;
  } else {
    s_sdhi.xfer = (uint8_t)k_sdhi_xfer_none;
    s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info2)] &= ~(uint32_t)k_sdhi_info2_bwe;
  }
}

RA8_INTERNAL static uint64_t internal_sdhi_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_sdhi_base;
  if (off == (uint64_t)k_sdhi_off_sd_buf0) {
    return (uint64_t)internal_sdhi_buf_read();
  }
  if (internal_sdhi_word(off) >= (uint32_t)k_sdhi_words) {
    return 0U;
  }
  return (uint64_t)s_sdhi.regs[internal_sdhi_word(off)];
}

RA8_INTERNAL static void
internal_sdhi_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_sdhi_base;
  if (off == (uint64_t)k_sdhi_off_sd_buf0) {
    internal_sdhi_buf_write((uint32_t)value);
    return;
  }
  if (off == (uint64_t)k_sdhi_off_soft_rst) {
    /* The driver writes 0 then 1; clear the FIFO/command engine either way. */
    s_sdhi.xfer                                          = (uint8_t)k_sdhi_xfer_none;
    s_sdhi.word_idx                                      = 0U;
    s_sdhi.blocks_left                                   = 0U;
    s_sdhi.app_cmd                                       = 0U;
    s_sdhi.regs[internal_sdhi_word(off)]                 = (uint32_t)value;
    s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info1)] = 0U;
    s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_info2)] = 0U;
    return;
  }
  if (internal_sdhi_word(off) < (uint32_t)k_sdhi_words) {
    s_sdhi.regs[internal_sdhi_word(off)] = (uint32_t)value;
  }
  if (off == (uint64_t)k_sdhi_off_sd_cmd) {
    internal_sdhi_exec_command((uint32_t)value);
  }
}

RA8_INTERNAL static void internal_sdhi_reset(void)
{
  (void)memset(&s_sdhi, 0, sizeof(s_sdhi));
}

RA8_INTERNAL static uint32_t internal_sdhi_bus_lanes(void)
{
  const uint32_t opt = s_sdhi.regs[internal_sdhi_word(k_sdhi_off_sd_option)];
  if ((opt & (uint32_t)k_sdhi_option_width_bit) != 0U) {
    return (uint32_t)k_sdhi_lanes_1bit;
  }
  if ((opt & (uint32_t)k_sdhi_option_width8_bit) != 0U) {
    return (uint32_t)k_sdhi_lanes_8bit;
  }
  return (uint32_t)k_sdhi_lanes_4bit;
}

RA8_INTERNAL static void internal_sdhi_report(void)
{
  if ((s_sdhi.reads == 0U) && (s_sdhi.writes == 0U)) {
    return;
  }
  (void)priv_emu_io_errf("  SDHI card     : %u block reads  %u block writes  %u-bit bus\n",
                         s_sdhi.reads,
                         s_sdhi.writes,
                         (unsigned)internal_sdhi_bus_lanes());
}

static const board_periph_block_t s_k_sdhi_block = {
  .base   = (uint32_t)k_sdhi_base,
  .span   = (uint32_t)k_sdhi_span,
  .order  = (uint32_t)k_sdhi_block_order,
  .read   = internal_sdhi_read,
  .write  = internal_sdhi_write,
  .tick   = nullptr,
  .reset  = internal_sdhi_reset,
  .report = internal_sdhi_report,
  .name   = "SDHI",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_sdhi_block_register(void)
{
  board_periph_register_block(&s_k_sdhi_block);
}