main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_sdcard.h"
 
/*
 * The host unit-test build (RA8_OFF_TARGET) does not link the
 * ThreadX vendor tree, so ``tx_api.h`` (and the ThreadX-port header
 * ``ra8_threadx.h``) are pulled in only on the cross-compile target.
 */
#ifndef RA8_OFF_TARGET
#include "ra8_threadx.h"
#include "tx_api.h"
#endif
 
/* ---------------------------------------------------------------------------
 * Tunables (typed enums per the project's no-magic-number rule).
 * --------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_sdcard_thread_stack_bytes = 4096U, 
} sdcard_stack_t;

typedef enum : uint8_t {
  k_sdcard_thread_priority = 4U, 
} sdcard_priority_t;

typedef enum : uint32_t {
  k_sdcard_console_baud = 115200U, 
} sdcard_baud_t;

typedef enum : uint16_t {
  k_sdcard_loop_ticks = 5000U, 
} sdcard_period_t;

typedef enum : uint8_t {
  k_sdcard_sdhi_instance = 0U,  
  k_sdcard_dump_bytes    = 16U, 
} sdcard_layout_t;

typedef enum : uint8_t {
  k_sdcard_hex_chars_per_byte  = 3U,    
  k_sdcard_hex_nibble_shift    = 4U,    
  k_sdcard_hex_nibble_mask     = 0x0FU, 
  k_sdcard_hex_alpha_threshold = 10U,   
} sdcard_hex_t;

typedef enum : uint16_t {
  k_sdcard_block_bytes = 512U, 
} sdcard_block_size_t;
 
/* ---------------------------------------------------------------------------
 * Vector table override and thread storage (cross-build only).
 * --------------------------------------------------------------------------- */
 
#ifndef RA8_OFF_TARGET
extern void _tx_timer_interrupt(void);

[[gnu::aligned(8)]] static uint8_t s_sdcard_stack[k_sdcard_thread_stack_bytes];

static TX_THREAD s_sdcard_thread;

static uint8_t s_sdcard_block[k_sdcard_block_bytes];

void SysTick_Handler(void);
void SysTick_Handler(void)
{
  _tx_timer_interrupt();
}
 
/* ---------------------------------------------------------------------------
 * Helpers.
 * --------------------------------------------------------------------------- */

RA8_INTERNAL static char internal_sdcard_nibble_to_hex(uint8_t nibble)
{
  const uint8_t n = (uint8_t)(nibble & (uint8_t)k_sdcard_hex_nibble_mask);
  if (n < (uint8_t)k_sdcard_hex_alpha_threshold) {
    return (char)('0' + (char)n);
  }
  return (char)('A' + (char)(n - (uint8_t)k_sdcard_hex_alpha_threshold));
}

RA8_INTERNAL static void internal_sdcard_hex_dump(const uint8_t* in, uint8_t len, char* out)
{
  for (uint8_t i = 0U; i < len; i++) {
    const uint8_t b = in[i];
    out[i * k_sdcard_hex_chars_per_byte + 0U] =
      internal_sdcard_nibble_to_hex((uint8_t)(b >> k_sdcard_hex_nibble_shift));
    out[i * k_sdcard_hex_chars_per_byte + 1U] =
      internal_sdcard_nibble_to_hex((uint8_t)(b & (uint8_t)k_sdcard_hex_nibble_mask));
    out[i * k_sdcard_hex_chars_per_byte + 2U] = ' ';
  }
}

RA8_INTERNAL static void internal_sdcard_log(const char* s)
{
  if (s == nullptr) {
    return;
  }
  size_t len = 0U;
  while (s[len] != '\0') {
    len++;
  }
  (void)ra8_board_uart_console_write((const uint8_t*)s, len);
}
 
/* ---------------------------------------------------------------------------
 * Thread body.
 * --------------------------------------------------------------------------- */

RA8_INTERNAL static void internal_sdcard_one_pass(void)
{
  const ra8_err_t err = ra8_sdcard_read_blocks(0U, s_sdcard_block, 1U);
  if (err != k_ra8_ok) {
    internal_sdcard_log("sdcard: read block 0 failed\r\n");
    return;
  }
  char dump[k_sdcard_dump_bytes * k_sdcard_hex_chars_per_byte + 1U] = {};
  internal_sdcard_hex_dump(s_sdcard_block, (uint8_t)k_sdcard_dump_bytes, dump);
  dump[k_sdcard_dump_bytes * k_sdcard_hex_chars_per_byte] = '\0';
  internal_sdcard_log("sdcard: blk0[0..15] = ");
  internal_sdcard_log(dump);
  internal_sdcard_log("\r\n");
}

RA8_INTERNAL static void internal_sdcard_thread_entry(ULONG thread_input)
{
  (void)thread_input;
 
  const ra8_sdcard_cfg_t cfg = {.instance = k_sdcard_sdhi_instance};
  if (ra8_sdcard_init(&cfg) != k_ra8_ok) {
    internal_sdcard_log("sdcard: init failed (no card / bad pinmux?)\r\n");
    while (1) {
      (void)tx_thread_sleep((ULONG)k_sdcard_loop_ticks);
    }
  }
  internal_sdcard_log("sdcard: card initialized\r\n");
 
  while (1) {
    internal_sdcard_one_pass();
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    (void)tx_thread_sleep((ULONG)k_sdcard_loop_ticks);
  }
}
 
/* ---------------------------------------------------------------------------
 * tx_application_define -- ThreadX calls this once before the first
 * scheduling decision.
 * --------------------------------------------------------------------------- */

void tx_application_define(void* first_unused_memory)
{
  static CHAR s_thread_name[] = "sdcard";
 
  (void)first_unused_memory;
 
  /* Retune SysTick to the live CPUCLK0 (raised to 1 GHz by
   * ra8_cgc_init() in main()). tx_initialize_low_level.S already
   * programmed the reload from the same compile-time 1 GHz assumption,
   * but this makes the 1 ms kernel tick correct-by-construction for
   * whatever clock the app actually brought up (issue #287). Runs after
   * _tx_initialize_low_level and before the first scheduling decision. */
  if (ra8_threadx_systick_retune() != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  const UINT err = tx_thread_create(&s_sdcard_thread,
                                    s_thread_name,
                                    internal_sdcard_thread_entry,
                                    0U,
                                    s_sdcard_stack,
                                    (ULONG)k_sdcard_thread_stack_bytes,
                                    (UINT)k_sdcard_thread_priority,
                                    (UINT)k_sdcard_thread_priority,
                                    TX_NO_TIME_SLICE,
                                    TX_AUTO_START);
  if (err != TX_SUCCESS) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
}
#endif /* !RA8_OFF_TARGET */
 
/* ---------------------------------------------------------------------------
 * main() -- driver init, then drop into the ThreadX scheduler.
 * --------------------------------------------------------------------------- */

void main(void)
{
  /* CGC bring-up FIRST. tx_initialize_low_level.S programs SysTick from
   * the post-CGC CPUCLK0 target (1 GHz); entering the kernel on the
   * boot-default MOCO (~8 MHz) instead would run the "1 ms" tick ~119x
   * too slow, so tx_thread_sleep(5000) would stretch to ~10 minutes.
   * Raise the PLL before tx_kernel_enter (and tx_application_define
   * additionally retunes SysTick from the live clock -- issue #287). */
  if (ra8_cgc_init() != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  if (ra8_board_uart_console_init((uint32_t)k_sdcard_console_baud) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
#ifndef RA8_OFF_TARGET
  if (ra8_board_sdhi_pins_init() != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  ra8_isr_globals_enable();
  tx_kernel_enter();
#endif
 
  while (1) {
    __asm__ volatile("wfi");
  }
}