main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_sdcard.h"
#include "ra8_sdhi.h"
#include "ra8_time.h"
 
/* =============================================================================
 * Tunables
 * =============================================================================
 */

typedef enum : uint32_t {
  k_sdhi_card_uart_baud       = 115200U,      
  k_sdhi_card_instance        = 0U,           
  k_sdhi_card_block_bytes     = 512U,         
  k_sdhi_card_test_lba        = 64U,          
  k_sdhi_card_block_count     = 1U,           
  k_sdhi_card_prng_seed       = 0xC0FFEE11UL, 
  k_sdhi_card_prng_mul        = 1664525UL,    
  k_sdhi_card_prng_add        = 1013904223UL, 
  k_sdhi_card_prng_byte_shift = 16U,          
  k_sdhi_card_byte_mask       = 0xFFU,        
} sdhi_card_config_t;
 
/* The test block must sit above block 0 (the FAT BPB) so the round-trip never
 * clobbers the boot sector; promote the doc-only @pre to a compile-time check. */
static_assert((uint32_t)k_sdhi_card_test_lba > 0U,
              "ra8_sdhi_card_demo test LBA must be above block 0 (the FAT BPB)");
 
/* =============================================================================
 * Static message strings (ASCII-only per project policy)
 * =============================================================================
 */
 
static const uint8_t k_msg_boot[]      = "ra8_sdhi_card_demo: boot\r\n";
static const uint8_t k_msg_card_ok[]   = "ra8_sdhi_card_demo: card ready\r\n";
static const uint8_t k_msg_init_fail[] = "ra8_sdhi_card_demo: FAIL init\r\n";
static const uint8_t k_msg_pass[] = "ra8_sdhi_card_demo: native SDHI block round-trip PASS\r\n";
static const uint8_t k_msg_fail[] = "ra8_sdhi_card_demo: FAIL\r\n";

static const char* const s_tag = "ra8_sdhi_card_demo";
 
/* =============================================================================
 * UART output helpers
 * =============================================================================
 */

static void sdhi_card_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

#define SDHI_CARD_PUTS(lit) sdhi_card_print((lit), (uint32_t)sizeof(lit) - 1U)

static void sdhi_card_panic_halt(void)
{
  while (true) {
    __asm__ volatile("wfi");
  }
}
 
/* =============================================================================
 * Hardware bring-up
 * =============================================================================
 */

static void sdhi_card_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    sdhi_card_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    sdhi_card_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    sdhi_card_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_sdhi_card_uart_baud) != k_ra8_ok) {
    sdhi_card_panic_halt();
  }
  if (ra8_board_sdhi_pins_init() != k_ra8_ok) {
    sdhi_card_panic_halt();
  }
}

static void sdhi_card_init_or_halt(void)
{
  /* Request the SD 4-bit wide bus (ACMD6). Best-effort inside
   * ra8_sdcard_init: a card that declines is left at 1-bit and init
   * still succeeds, so this never turns a working card into a failure. */
  const ra8_sdcard_cfg_t cfg = {.instance  = (uint8_t)k_sdhi_card_instance,
                                .bus_width = k_ra8_sdhi_bus_width_4bit};
  if (ra8_sdcard_init(&cfg) != k_ra8_ok) {
    SDHI_CARD_PUTS(k_msg_init_fail);
    sdhi_card_panic_halt();
  }
  SDHI_CARD_PUTS(k_msg_card_ok);
}
 
/* =============================================================================
 * Payload + raw-block round-trip
 * =============================================================================
 */

static uint8_t s_payload[k_sdhi_card_block_bytes];
static uint8_t s_readback[k_sdhi_card_block_bytes];

static void sdhi_card_fill_payload(void)
{
  uint32_t state = (uint32_t)k_sdhi_card_prng_seed;
  for (uint32_t i = 0U; i < (uint32_t)k_sdhi_card_block_bytes; i++) {
    state        = (state * (uint32_t)k_sdhi_card_prng_mul) + (uint32_t)k_sdhi_card_prng_add;
    s_payload[i] = (uint8_t)((state >> k_sdhi_card_prng_byte_shift) & k_sdhi_card_byte_mask);
  }
}

[[nodiscard]] static ra8_err_t sdhi_card_check_capacity(void)
{
  uint32_t blocks = 0U;
  RA8_RETURN_ON_ERROR(ra8_sdcard_get_capacity(&blocks), s_tag, "capacity");
  if (blocks <= (uint32_t)k_sdhi_card_test_lba) {
    return k_ra8_err_out_of_range;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t sdhi_card_block_roundtrip(void)
{
  RA8_RETURN_ON_ERROR(ra8_sdcard_write_blocks((uint32_t)k_sdhi_card_test_lba,
                                              s_payload,
                                              (uint32_t)k_sdhi_card_block_count),
                      s_tag,
                      "write");
  memset(s_readback, 0, sizeof(s_readback));
  RA8_RETURN_ON_ERROR(ra8_sdcard_read_blocks((uint32_t)k_sdhi_card_test_lba,
                                             s_readback,
                                             (uint32_t)k_sdhi_card_block_count),
                      s_tag,
                      "read");
  if (memcmp(s_payload, s_readback, (size_t)k_sdhi_card_block_bytes) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t sdhi_card_roundtrip(void)
{
  RA8_RETURN_ON_ERROR(sdhi_card_check_capacity(), s_tag, "capacity check");
  RA8_RETURN_ON_ERROR(sdhi_card_block_roundtrip(), s_tag, "block roundtrip");
  return k_ra8_ok;
}
 
/* =============================================================================
 * Main
 * =============================================================================
 */

void main(void)
{
  sdhi_card_setup_or_halt();
  ra8_isr_globals_enable();
  ra8_log_init();
  SDHI_CARD_PUTS(k_msg_boot);
 
  sdhi_card_init_or_halt();
  sdhi_card_fill_payload();
 
  const ra8_err_t r = sdhi_card_roundtrip();
  if (r != k_ra8_ok) {
    SDHI_CARD_PUTS(k_msg_fail);
    sdhi_card_panic_halt();
  }
  SDHI_CARD_PUTS(k_msg_pass);
  (void)ra8_board_uart_console_flush();
 
  while (true) {
    __asm__ volatile("wfi");
  }
}