如何在vxWorks-7中跳转至u-boot启动加载器重启单板？

Hey Dennis, I get it—dealing with a faulty board where power cycling isn't reliable is a real pain. Let's walk through how to trigger a jump straight to U-Boot from VxWorks 7, so you can reboot without hitting the power button.

Step 1: Get U-Boot's Entry Point Address #

First, you need to know exactly where U-Boot lives in memory. This is usually defined in your board's U-Boot configuration:

• Check U-Boot's configs/<your-board-name>.h file for CONFIG_SYS_TEXT_BASE—that's the starting address of U-Boot's executable code.
• For example, many ARM-based boards use 0x00000000 or 0x80000000; adjust this value based on your hardware.
• You'll also need U-Boot's initial stack address, found in CONFIG_SYS_INIT_SP_ADDR in the same config file.

Step 2: Write the Kernel-Level Jump Function #

You'll need a low-level function to shut down VxWorks cleanly and jump to U-Boot. Here's an ARM-specific example (modify for x86/RISC-V if your board uses a different architecture):

#include <vxWorks.h>
#include <sysLib.h>
#include <intLib.h>
#include <taskLib.h>

/* Replace with your board's actual U-Boot entry address */
#define UBOOT_ENTRY 0x80000000
/* Replace with U-Boot's initial stack address */
#define UBOOT_INIT_SP 0x80100000

void jumpToUboot(void)
{
    // Suspend all other tasks to avoid interference during the jump
    taskSuspendAll();

    // Lock all interrupts—no unexpected interrupts mid-jump
    intLock();

    // Flush caches to ensure all pending writes are committed to memory
    sysCacheFlush(DATA_CACHE);
    sysCacheFlush(INSTRUCTION_CACHE);

    // Disable MMU, D-cache, and I-cache (critical if VxWorks uses them)
    asm volatile(
        "mrc p15, 0, r0, c1, c0, 0\n"
        "bic r0, r0, #0x1\n"      // Turn off MMU
        "bic r0, r0, #0x4\n"      // Turn off D-cache
        "bic r0, r0, #0x1000\n"   // Turn off I-cache
        "mcr p15, 0, r0, c1, c0, 0\n"
        "isb\n"
        "dsb\n"
    );

    // Set up U-Boot's initial stack pointer
    asm volatile("mov sp, %0" : : "r"(UBOOT_INIT_SP));

    // Jump to U-Boot's entry point
    void (*ubootStart)(void) = (void (*)(void))UBOOT_ENTRY;
    ubootStart();

    // We should never reach here, but loop just in case
    while(1);
}

Step 3: Compile and Deploy the Function #

1. Build the module: Use Wind River Workbench to create a kernel module project, add the code above, and compile it for your target architecture.
2. Load and run: Transfer the module to your target (via FTP/TFTP) and load it using ld <module.o> in the VxWorks shell. Then call jumpToUboot()—your board should immediately restart into U-Boot.

Key Notes for Other Architectures #

• x86: You'll need to disable paging, reset segment registers, and use a far jump to U-Boot's entry point. Reference x86 real-mode initialization code for details.
• RISC-V: Manipulate the satp register to disable the MMU instead of ARM's CP15 registers, and adjust stack setup to match RISC-V calling conventions.
• Board-Specific Cleanup: Some boards may require resetting peripherals (like SPI controllers or GPIO) before jumping—check your board's reference manual for pre-jump steps.

Test First! #

Before deploying this to your faulty board, test it on a working unit of the same hardware. This ensures the jump logic works as expected without causing additional issues.

内容的提问来源于stack exchange，提问作者Dennis Kerrisk