Cleanups

Author: dgarske

arch.mk

@@ -87,6 +87,8 @@ ifeq ($(ARCH),AARCH64)
     CFLAGS+=-DWOLFBOOT_DUALBOOT
     # Support detection and skip of U-Boot legacy header
     CFLAGS+=-DWOLFBOOT_UBOOT_LEGACY
+    # PLM owns RVBAR on Versal in JTAG boot; skip RVBAR writes
+    CFLAGS+=-DSKIP_RVBAR=1
   endif
 
   ifeq ($(TARGET),nxp_ls1028a)

docs/Targets.md

@@ -2308,7 +2308,7 @@ Typical boot timing with ECC384/SHA384 signing:
 
 ### SD Card Boot
 
-wolfBoot supports booting from SD card on the VMK180 using the Cadence SDHCI controller. This enables A/B partition-based firmware updates from GPT partitions on the SD card.
+wolfBoot supports booting from SD card on the VMK180 using the Arasan SDHCI controller. This enables A/B partition-based firmware updates from MBR partitions on the SD card.
 
 #### SD Card Partition Layout
 
@@ -2334,8 +2334,8 @@ make
 Key differences from QSPI configuration:
 - `DISK_SDCARD=1` - Enable SD card support via SDHCI driver
 - `EXT_FLASH=0` - Disable QSPI flash
-- `BOOT_PART_A=2` - Primary firmware on partition 2
-- `BOOT_PART_B=3` - Update firmware on partition 3
+- `BOOT_PART_A=1` - Primary firmware on partition 2 (OFP_A, 0-based index 1)
+- `BOOT_PART_B=2` - Update firmware on partition 3 (OFP_B, 0-based index 2)
 
 #### Building and Provisioning
 
@@ -2348,7 +2348,7 @@ Key differences from QSPI configuration:
 This creates:
 - `wolfboot.elf` - wolfBoot bootloader
 - `BOOT.BIN` - Complete boot image for partition 1
-- `sdcard.img` - GPT-partitioned SD card image with signed test apps
+- `sdcard.img` - MBR-partitioned SD card image with signed test apps
 - `test-app/image_v1_signed.bin` - Signed primary firmware
 - `test-app/image_v2_signed.bin` - Signed update firmware
 
@@ -2375,7 +2375,7 @@ sudo umount /mnt
 3. **Verify partitions:**
 
 ```sh
-sudo sgdisk -p /dev/sdX
+sudo fdisk -l /dev/sdX
 ```
 
 #### Boot Mode Selection
@@ -2392,7 +2392,6 @@ wolfBoot Secure Boot - AMD Versal
 Current EL: 2
 SDHCI: SDCard mode
 ...
-Boot partition: A (2)
 Firmware Valid
 Booting at 0x10000000
 ```

hal/versal.c

@@ -1151,36 +1151,17 @@ static void qspi_init(void)
  * ============================================================================
  */
 
-/* Very early debug: write single char directly to UART (no init needed)
- * Use this to confirm wolfBoot is running before any initialization */
-static void uart_write_char_direct(char c)
-{
-    volatile uint32_t *uart_fr = (volatile uint32_t*)(DEBUG_UART_BASE + 0x18);
-    volatile uint32_t *uart_dr = (volatile uint32_t*)(DEBUG_UART_BASE + 0x00);
-    /* Wait for TX FIFO not full */
-    while ((*uart_fr) & (1 << 5))
-        ;
-    *uart_dr = c;
-}
-
-static void uart_write_str_direct(const char *s)
-{
-    while (*s) {
-        if (*s == '\n')
-            uart_write_char_direct('\r');
-        uart_write_char_direct(*s++);
-    }
-}
-
 void hal_init(void)
 {
     uart_init();
 
 #if defined(DEBUG_UART) && defined(__WOLFBOOT)
-    uart_write_str_direct(
+    wolfBoot_printf(
         "\n========================================\n"
         "wolfBoot Secure Boot - AMD Versal\n"
+#ifndef WOLFBOOT_REPRODUCIBLE_BUILD
         "Build: " __DATE__ " " __TIME__ "\n"
+#endif
         "========================================\n");
     wolfBoot_printf("Current EL: %d\n", current_el());
 #endif
@@ -1697,4 +1678,3 @@ void sdhci_platform_set_bus_mode(int is_emmc)
 
 
 #endif /* TARGET_versal */
-

src/boot_aarch64.c

@@ -200,104 +200,44 @@ void RAMFUNCTION arch_reboot(void)
 #endif
 
 /* ============================================================================
- * Exception Handlers for EL2 (DEBUG_HARDFAULT support)
+ * Exception Handlers for EL2 (optional DEBUG_HARDFAULT)
  * ============================================================================
- * These handlers print diagnostic information when exceptions occur.
- * ESR_EL2 - Exception Syndrome Register (cause of exception)
- * ELR_EL2 - Exception Link Register (address that caused exception)
- * FAR_EL2 - Fault Address Register (for data/instruction aborts)
  */
 
-#if defined(DEBUG_UART) && defined(EL2_HYPERVISOR)
+#if defined(DEBUG_HARDFAULT) && defined(DEBUG_UART) && defined(EL2_HYPERVISOR)
 
-/* Read EL2 exception registers */
-static inline uint64_t read_esr_el2(void) {
-    uint64_t val;
-    __asm__ volatile("mrs %0, ESR_EL2" : "=r"(val));
-    return val;
-}
-
-static inline uint64_t read_elr_el2(void) {
-    uint64_t val;
-    __asm__ volatile("mrs %0, ELR_EL2" : "=r"(val));
-    return val;
-}
+#define READ_SYSREG(_out, _reg) __asm__ volatile("mrs %0, " #_reg : "=r"(_out))
 
-static inline uint64_t read_far_el2(void) {
-    uint64_t val;
-    __asm__ volatile("mrs %0, FAR_EL2" : "=r"(val));
-    return val;
-}
-
-/* Decode ESR exception class */
-static const char* decode_ec(uint32_t ec) {
-    switch (ec) {
-        case 0x00: return "Unknown";
-        case 0x01: return "WFI/WFE trapped";
-        case 0x07: return "SVE/SIMD/FP trapped";
-        case 0x0E: return "Illegal execution state";
-        case 0x15: return "SVC in AArch64";
-        case 0x16: return "HVC in AArch64";
-        case 0x17: return "SMC in AArch64";
-        case 0x20: return "Inst abort (lower EL)";
-        case 0x21: return "Inst abort (same EL)";
-        case 0x22: return "PC alignment fault";
-        case 0x24: return "Data abort (lower EL)";
-        case 0x25: return "Data abort (same EL)";
-        case 0x26: return "SP alignment fault";
-        case 0x2C: return "FP exception";
-        case 0x2F: return "SError";
-        case 0x30: return "Breakpoint (lower EL)";
-        case 0x31: return "Breakpoint (same EL)";
-        case 0x32: return "Software step (lower EL)";
-        case 0x33: return "Software step (same EL)";
-        case 0x34: return "Watchpoint (lower EL)";
-        case 0x35: return "Watchpoint (same EL)";
-        case 0x3C: return "BRK instruction";
-        default:   return "Other";
-    }
-}
+static void print_exception_info(const char *type)
+{
+    uint64_t esr, elr, far;
 
-static void print_exception_info(const char *type) {
-    uint64_t esr = read_esr_el2();
-    uint64_t elr = read_elr_el2();
-    uint64_t far = read_far_el2();
-    uint32_t ec = (esr >> 26) & 0x3F;
-    uint32_t iss = esr & 0x1FFFFFF;
+    READ_SYSREG(esr, ESR_EL2);
+    READ_SYSREG(elr, ELR_EL2);
+    READ_SYSREG(far, FAR_EL2);
 
     wolfBoot_printf("\n\n*** %s EXCEPTION ***\n", type);
     wolfBoot_printf("ESR_EL2: 0x%08x%08x\n", (uint32_t)(esr >> 32), (uint32_t)esr);
-    wolfBoot_printf("  EC (Exception Class): 0x%x - %s\n", ec, decode_ec(ec));
-    wolfBoot_printf("  ISS (Syndrome): 0x%x\n", iss);
-    wolfBoot_printf("ELR_EL2 (fault addr): 0x%08x%08x\n", (uint32_t)(elr >> 32), (uint32_t)elr);
-    wolfBoot_printf("FAR_EL2 (access addr): 0x%08x%08x\n", (uint32_t)(far >> 32), (uint32_t)far);
+    wolfBoot_printf("ELR_EL2: 0x%08x%08x\n", (uint32_t)(elr >> 32), (uint32_t)elr);
+    wolfBoot_printf("FAR_EL2: 0x%08x%08x\n", (uint32_t)(far >> 32), (uint32_t)far);
     wolfBoot_printf("*** SYSTEM HALTED ***\n");
 }
 
-void SynchronousInterrupt(void) {
-    print_exception_info("SYNCHRONOUS");
-    while(1) { __asm__ volatile("wfi"); }
-}
-
-void IRQInterrupt(void) {
-    print_exception_info("IRQ");
-    while(1) { __asm__ volatile("wfi"); }
-}
-
-void FIQInterrupt(void) {
-    print_exception_info("FIQ");
-    while(1) { __asm__ volatile("wfi"); }
+static void hardfault_halt(const char *type)
+{
+    print_exception_info(type);
+    while (1) { __asm__ volatile("wfi"); }
 }
 
-void SErrorInterrupt(void) {
-    print_exception_info("SERROR");
-    while(1) { __asm__ volatile("wfi"); }
-}
+void SynchronousInterrupt(void) { hardfault_halt("SYNCHRONOUS"); }
+void IRQInterrupt(void) { hardfault_halt("IRQ"); }
+void FIQInterrupt(void) { hardfault_halt("FIQ"); }
+void SErrorInterrupt(void) { hardfault_halt("SERROR"); }
 
 #else
 /* Simple stubs when debug not enabled */
-void SynchronousInterrupt(void) { while(1); }
-void IRQInterrupt(void) { while(1); }
-void FIQInterrupt(void) { while(1); }
-void SErrorInterrupt(void) { while(1); }
-#endif /* DEBUG_UART && EL2_HYPERVISOR */
+void SynchronousInterrupt(void) { while (1) { __asm__ volatile("wfi"); } }
+void IRQInterrupt(void) { while (1) { __asm__ volatile("wfi"); } }
+void FIQInterrupt(void) { while (1) { __asm__ volatile("wfi"); } }
+void SErrorInterrupt(void) { while (1) { __asm__ volatile("wfi"); } }
+#endif /* DEBUG_HARDFAULT && DEBUG_UART && EL2_HYPERVISOR */

src/boot_aarch64_start.S

@@ -467,6 +467,7 @@ InitEL1:
 
 /* Assembly startup error handler */
 error:
+    wfi
     b      error
 
 

test-app/app_versal.c

@@ -52,7 +52,7 @@ void main(void)
     wolfBoot_printf("BOOT: Version: %d (0x%08x)\n", boot_version, boot_version);
     wolfBoot_printf("UPDATE: Version: %d (0x%08x)\n", update_version, update_version);
 #else
-    wolfBoot_printf("Boot mode: Disk-based (GPT partitions)\n");
+    wolfBoot_printf("Boot mode: Disk-based (GPT/MBR partitions)\n");
 #endif
 
     wolfBoot_printf("Application running successfully!\n");