Flash Driver Architecture

/* Flash driver functions MUST execute from RAM, not flash */
/* Reason: while programming flash, the flash controller is BUSY */
/* CPU cannot fetch instructions from flash while it is being written/erased */
/* Attempting to do so causes: bus error / hard fault / data corruption */

/* GCC/Aurix: place function in RAM section */
__attribute__((section(".ramcode")))
Std_ReturnType FlsDrv_SectorErase(uint32_t sector_addr)
{
    /* All operations here execute from RAM */

    /* Disable instruction cache (if applicable) before touching flash */
    /* Aurix: PFlash cache must be invalidated after write */
    Cache_Disable();

    /* Send erase command sequence to flash controller */
    FLASH_CTRL->CMD = FLASH_CMD_ERASE_SECTOR;
    FLASH_CTRL->ADDR = sector_addr;
    FLASH_CTRL->CMD = FLASH_CMD_CONFIRM;

    /* Poll status register until complete (also runs from RAM) */
    while (FLASH_CTRL->STATUS & FLASH_STATUS_BUSY) {
        Wdg_Trigger();   /* service watchdog during long erase */
    }

    /* Re-enable cache after flash operation complete */
    Cache_InvalidateAndEnable();

    return (FLASH_CTRL->STATUS & FLASH_STATUS_ERROR) ? E_NOT_OK : E_OK;
}

/* Linker script: .ramcode section is copied from flash to RAM at startup */
/* Startup code: memcpy(RAMCODE_START, RAMCODE_LMA, RAMCODE_SIZE); */

/* Aurix alternative: execute from PSPR (CPU-local scratchpad RAM) */
/* PSPR is separate from PFlash bus; no bus conflict during erase/write */

/* AUTOSAR Fls (Flash) driver API: standard interface for bootloader */
#include "Fls.h"
#include "MemIf.h"

/* Synchronous wrapper: erase + poll until done */
Std_ReturnType Flash_EraseSector(uint32_t address, uint32_t length)
{
    if (Fls_Erase(address, length) != E_OK) {
        return E_NOT_OK;
    }

    /* Poll until erase complete */
    MemIf_StatusType status;
    uint32_t timeout_ms = 30000u;   /* 30s max erase time */
    uint32_t elapsed    = 0u;

    do {
        Fls_MainFunction();   /* AUTOSAR: drives state machine */
        status = Fls_GetStatus();
        Timer_DelayMs(1u);
        elapsed++;
        Wdg_Trigger();
        if (elapsed >= timeout_ms) { return E_NOT_OK; }
    } while (status == MEMIF_BUSY);

    return (status == MEMIF_IDLE) ? E_OK : E_NOT_OK;
}

/* Asynchronous write + poll (AUTOSAR pattern) */
Std_ReturnType Flash_WriteData(uint32_t address,
                                const uint8_t *data,
                                uint32_t length)
{
    if (Fls_Write(address, data, length) != E_OK) { return E_NOT_OK; }

    MemIf_StatusType status;
    do {
        Fls_MainFunction();
        status = Fls_GetStatus();
        Wdg_Trigger();
    } while (status == MEMIF_BUSY);

    return (status == MEMIF_IDLE) ? E_OK : E_NOT_OK;
}