STM32F411RE Bootloader

static void jump_to_app(void) {
    // Read the first word of the app — its initial stack pointer
    uint32_t sp = flash_read_word(APP_START_ADDR);  // 0x0800C000

    // Sanity check: must be a legal SRAM address (0x20xxxxxx)
    // If no app is flashed, flash reads 0xFFFFFFFF → reject
    if ((sp & 0x2FF00000UL) != 0x20000000UL) {
        uart_send_str("No valid app — staying in bootloader\r\n");
        return;
    }

    uart_send_str("Jumping to app...\r\n");

    // Redirect the CPU's interrupt vector table to the app
    // Without this, app interrupts would call bootloader handlers
    SCB_VTOR = APP_START_ADDR;

    // Read app's reset handler (second word of its vector table)
    const VectorTable *v = (const VectorTable *)APP_START_ADDR;
    FuncPtr app_reset = v->reset_handler;

    // Must use assembly — C cannot set MSP without corrupting its own stack
    __asm volatile(
        "MSR MSP, %0  \n"   // load app's initial stack pointer
        "BX  %1       \n"   // branch to app's Reset_Handler (no return)
        : : "r"(sp), "r"(app_reset) :
    );
}

FlashStatus flash_unlock(void) {
    if (!(FLASH_CR & FLASH_CR_LOCK))
        return FLASH_OK;  // already unlocked
    // Two magic keys must be written in sequence — hardware protection
    FLASH_KEYR = 0x45670123UL;
    FLASH_KEYR = 0xCDEF89ABUL;
    return (FLASH_CR & FLASH_CR_LOCK) ? FLASH_ERROR : FLASH_OK;
}

FlashStatus flash_erase_sector(uint8_t sector) {
    FlashStatus s = wait_for_not_busy();
    if (s != FLASH_OK) return s;

    // Flash bits can only go 1→0 by writing.
    // To reset back to 1 you must erase an entire sector (→ all 0xFF)
    FLASH_CR &= ~(0xFUL << FLASH_CR_SNB_Pos);
    FLASH_CR |= FLASH_CR_SER | ((uint32_t)sector << FLASH_CR_SNB_Pos) | PSIZE_WORD;
    FLASH_CR |= FLASH_CR_STRT;   // start erase
    return wait_for_not_busy();
}

FlashStatus flash_write_word(uint32_t addr, uint32_t data) {
    FlashStatus s = wait_for_not_busy();
    if (s != FLASH_OK) return s;

    FLASH_CR |= FLASH_CR_PG | PSIZE_WORD;  // enable programming
    *(volatile uint32_t *)addr = data;      // write 4 bytes
    s = wait_for_not_busy();
    FLASH_CR &= ~FLASH_CR_PG;

    // Verify immediately — confirm the write actually stuck
    if (*(volatile uint32_t *)addr != data)
        return FLASH_ERROR;
    return s;
}

void uart_init(uint32_t baud) {
    systick_init();  // 1 kHz tick for receive timeouts

    // Enable peripheral clocks (GPIOA + USART2)
    RCC_AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    RCC_APB1ENR |= RCC_APB1ENR_USART2EN;

    // PA2, PA3 → Alternate Function 7 (USART2)
    GPIOA_MODER &= ~((3UL << 4) | (3UL << 6));
    GPIOA_MODER |=  ((2UL << 4) | (2UL << 6));   // AF mode
    GPIOA_AFRL  |=  ((7UL << 8) | (7UL << 12));  // AF7 = USART2

    // Baud rate: BRR = F_CLK / baud (16 MHz HSI, no PLL)
    USART2_BRR = 16000000UL / baud;

    USART2_CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
}

// Receive with timeout — never blocks forever
bool uart_recv_timeout(uint8_t *out, uint32_t timeout_ms) {
    uint32_t start = systick_ms;
    // Poll RXNE (Receive Not Empty) bit in status register
    while (!(USART2_SR & USART_SR_RXNE)) {
        if ((systick_ms - start) >= timeout_ms)
            return false;  // timed out — host disconnected?
    }
    *out = (uint8_t)USART2_DR;
    return true;
}