stm32_common.cpp File Reference

Detailed Description

Low level common STM32 code.

Date

Mar 28, 2019

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file stm32_common.cpp.

Typedefs
typedef struct port_intctx	intctx_t

Functions
static void	reset_and_jump (void)
void	jump_to_bootloader ()
void	jump_to_openblt ()
BOR_Level_t	BOR_Get (void)
BOR_Result_t	BOR_Set (BOR_Level_t BORValue)
void	startWatchdog (int timeoutMs)
void	setWatchdogResetPeriod (int resetMs)
void	tryResetWatchdog ()
uint32_t	getMcuSerial ()
void	baseMCUInit ()
int	getRemainingStack (thread_t *otp)
bool	isStm32F42x ()
PUBLIC_API_WEAK void	boardPrepareForStop ()
void	boardPreparePA0ForStandby ()
PUBLIC_API_WEAK void	boardPrepareForStandby ()

Variables
static efitimems_t	watchdogResetPeriodMs = 0
static const efitimems_t	watchdogCounterResetDelay = 3000
uint32_t	__main_stack_base__

Typedef Documentation

intctx_t

typedef struct port_intctx intctx_t

Definition at line 213 of file stm32_common.cpp.

Function Documentation

baseMCUInit()

void baseMCUInit

(

)

Definition at line 195 of file stm32_common.cpp.

                   {
    // looks like this holds a random value on start? Let's set a nice clean zero
    DWT->CYCCNT = 0;
 
 
#ifndef EFI_SKIP_BOR
    BOR_Set(BOR_Level_1); // one step above default value
#else
  BOR_Set(BOR_Level_None);
#endif
 
#ifndef EFI_BOOTLOADER
    engine->outputChannels.mcuSerial = getMcuSerial();
#endif // EFI_BOOTLOADER
}

Here is the call graph for this function:

boardPrepareForStandby()

PUBLIC_API_WEAK void boardPrepareForStandby

(

)

Definition at line 280 of file stm32_common.cpp.

                                              {
    boardPreparePA0ForStandby();
}

Referenced by stm32_standby().

Here is the call graph for this function:

Here is the caller graph for this function:

boardPrepareForStop()

PUBLIC_API_WEAK void boardPrepareForStop

(

)

Definition at line 247 of file stm32_common.cpp.

                                           {
    // Default implementation - wake up on PA0 - boards should override this
    palEnableLineEvent(PAL_LINE(GPIOA, 0), PAL_EVENT_MODE_RISING_EDGE);
}

boardPreparePA0ForStandby()

void boardPreparePA0ForStandby

(

)

Standby uses special low power hardware - it always wakes on rising edge

Definition at line 256 of file stm32_common.cpp.

                                 {
#ifdef STM32F4XX
    //Enable Wakeup Pin for PA0
    PWR->CSR |= PWR_CSR_EWUP;
 
    // Clear wakeup flag - it may be set if PA0 is already
    // high when we enable it as a wake source
    PWR->CR |= PWR_CR_CWUF; //Clear Wakeup Pin flag for PA0
#endif
 
#ifdef STM32F7XX
    PWR->CSR2 |= PWR_CSR2_EWUP1; //EWUP1: Enable Wakeup pin for PA0
    PWR->CR2 |= PWR_CR2_CWUPF1; //Clear Wakeup Pin flag for PA0
#endif
 
#ifdef STM32H7XX
    // Wake on wakeup pin 0 - PA0
    PWR->WKUPEPR = PWR_WKUPEPR_WKUPEN1;
 
    // clear all possible wakeup bits
    PWR->WKUPCR = 0xFFFFFFFF;
#endif
}

Referenced by boardPrepareForStandby().

Here is the caller graph for this function:

BOR_Get()

BOR_Level_t BOR_Get

(

void

)

Definition at line 86 of file stm32_common.cpp.

                          {
    FLASH_OBProgramInitTypeDef FLASH_Handle;
 
    /* Read option bytes */
    HAL_FLASHEx_OBGetConfig(&FLASH_Handle);
 
    /* Return BOR value */
    return (BOR_Level_t) FLASH_Handle.BORLevel;
}

Referenced by BOR_Set().

Here is the call graph for this function:

Here is the caller graph for this function:

BOR_Set()

BOR_Result_t BOR_Set

(

BOR_Level_t

BORValue

)

Definition at line 96 of file stm32_common.cpp.

                                           {
    if (BOR_Get() == BORValue) {
        return BOR_Result_Ok;
    }
 
 
    FLASH_OBProgramInitTypeDef FLASH_Handle;
 
    FLASH_Handle.BORLevel = (uint32_t)BORValue;
    FLASH_Handle.OptionType = OPTIONBYTE_BOR;
 
    HAL_FLASH_OB_Unlock();
 
    HAL_FLASHEx_OBProgram(&FLASH_Handle);
 
    HAL_StatusTypeDef status = HAL_FLASH_OB_Launch();
 
    HAL_FLASH_OB_Lock();
 
    if (status != HAL_OK) {
        return BOR_Result_Error;
    }
 
    return BOR_Result_Ok;
}

Referenced by baseMCUInit().

Here is the call graph for this function:

Here is the caller graph for this function:

getMcuSerial()

uint32_t getMcuSerial

(

)

Definition at line 190 of file stm32_common.cpp.

                        {
    uint32_t *uid = ((uint32_t *)UID_BASE);
    return uid[0] + uid[1] + uid[2];
}

Referenced by baseMCUInit().

Here is the caller graph for this function:

getRemainingStack()

int getRemainingStack

(

thread_t *

otp

)

Of note is that interrupts are NOT serviced on the stack of the thread that was running when the interrupt occurred. The only thing that happens on that thread's stack is that its registers are pushed (by hardware) when an interrupt occurs, just before swapping the stack pointer out for the main stack (currently 0x400=1024 bytes), where the ISR actually runs. see also main_stack_size see also process_stack_size

see also http://www.chibios.org/dokuwiki/doku.php?id=chibios:kb:stacks

In the firmware we are using 'extern *Engine' - in the firmware Engine is a singleton

On the other hand, in order to have a meaningful unit test we are passing Engine * engine as a parameter

Definition at line 215 of file stm32_common.cpp.

                                     {
#if CH_DBG_ENABLE_STACK_CHECK
    // this would dismiss coverity warning - see http://rusefi.com/forum/viewtopic.php?f=5&t=655
    // coverity[uninit_use]
    register intctx_t *r13 asm ("r13");
    otp->activeStack = r13;
 
    int remainingStack;
    if (ch0.dbg.isr_cnt > 0) {
        // ISR context
        remainingStack = (int)(r13 - 1) - (int)&__main_stack_base__;
    } else {
        remainingStack = (int)(r13 - 1) - (int)otp->wabase;
    }
    otp->remainingStack = remainingStack;
    return remainingStack;
#else
    UNUSED(otp);
    return 99999;
#endif /* CH_DBG_ENABLE_STACK_CHECK */
}

Here is the call graph for this function:

isStm32F42x()

bool isStm32F42x

(

void

)

Definition at line 238 of file stm32_common.cpp.

                   {
    // Device identifier
    // 0x419 for STM32F42xxx and STM32F43xxx
    // 0x413 for STM32F405xx/07xx and STM32F415xx/17xx
    return ((DBGMCU->IDCODE & DBGMCU_IDCODE_DEV_ID_Msk) == 0x419);
}

jump_to_bootloader()

void jump_to_bootloader

(

)

Definition at line 63 of file stm32_common.cpp.

                          {
    // leave DFU breadcrumb which assembly startup code would check, see [rusefi][DFU] section in assembly code
 
    *((unsigned long *)0x2001FFF0) = 0xDEADBEEF; // End of RAM
 
    reset_and_jump();
}

Here is the call graph for this function:

jump_to_openblt()

void jump_to_openblt

(

)

Definition at line 72 of file stm32_common.cpp.

                       {
#if EFI_USE_OPENBLT
    /* safe to call on already inited shares area */
    SharedParamsInit();
    /* Store sing to stay in OpenBLT */
    SharedParamsWriteByIndex(0, 0x01);
 
    reset_and_jump();
#endif
}

Here is the call graph for this function:

reset_and_jump()

static void reset_and_jump ( void  )

static

Definition at line 39 of file stm32_common.cpp.

                                 {
#if !ALLOW_JUMP_WITH_IGNITION_VOLTAGE
  if (isIgnVoltage()) {
    criticalError("Not allowed with ignition power");
    return;
  }
#endif
 
    #ifdef STM32H7XX
        // H7 needs a forcible reset of the USB peripheral(s) in order for the bootloader to work properly.
        // If you don't do this, the bootloader will execute, but USB doesn't work (nobody knows why)
        // See https://community.st.com/s/question/0D53W00000vQEWsSAO/stm32h743-dfu-entry-doesnt-work-unless-boot0-held-high-at-poweron
    #ifdef STM32H723xx
        RCC->AHB1ENR &= ~(RCC_AHB1ENR_USB1OTGHSEN);
    #else
        RCC->AHB1ENR &= ~(RCC_AHB1ENR_USB1OTGHSEN | RCC_AHB1ENR_USB2OTGFSEN);
    #endif
    #endif
 
    // and now reboot
    NVIC_SystemReset();
}

Referenced by jump_to_bootloader(), and jump_to_openblt().

Here is the call graph for this function:

Here is the caller graph for this function:

setWatchdogResetPeriod()

void setWatchdogResetPeriod

(

int

resetMs

)

Definition at line 160 of file stm32_common.cpp.

                                         {
#if 0
  efiPrintf("[dev] wd %d", resetMs);
#endif
    watchdogResetPeriodMs = (efitimems_t)resetMs;
}

startWatchdog()

void startWatchdog

(

int

timeoutMs

)

Definition at line 122 of file stm32_common.cpp.

                                  {
#if HAL_USE_WDG
    // RL is a 12-bit value so we use a "2 ms" prescaler to support long timeouts (> 4.095 sec)
    static WDGConfig wdgcfg;
    wdgcfg.pr = STM32_IWDG_PR_64;   // t = (1/32768) * 64 = ~2 ms
    wdgcfg.rlr = STM32_IWDG_RL((uint32_t)((32.768f / 64.0f) * timeoutMs));
#if STM32_IWDG_IS_WINDOWED
    wdgcfg.winr = 0xfff; // don't use window
#endif
 
#ifndef __OPTIMIZE__ // gcc-specific built-in define
    // if no optimizations, then it's most likely a debug version,
    // and we need to enable a special watchdog feature to allow debugging
    efiPrintf("Enabling 'debug freeze' watchdog feature...");
#ifdef STM32H7XX
    DBGMCU->APB4FZ1 |= DBGMCU_APB4FZ1_DBG_IWDG1;
#else // F4 & F7
    DBGMCU->APB1FZ |= DBGMCU_APB1_FZ_DBG_IWDG_STOP;
#endif // STM32H7XX
#endif // __OPTIMIZE__
 
    static bool isStarted = false;
    if (!isStarted) {
        efiPrintf("Starting watchdog with timeout %d ms...", timeoutMs);
        wdgStart(&WDGD1, &wdgcfg);
        isStarted = true;
    } else {
        efiPrintf("Changing watchdog timeout to %d ms...", timeoutMs);
        // wdgStart() uses kernel lock, thus we cannot call it here from locked or ISR code
        wdg_lld_start(&WDGD1);
    }
#endif // HAL_USE_WDG
}

tryResetWatchdog()

void tryResetWatchdog

(

)

Definition at line 167 of file stm32_common.cpp.

                        {
#if HAL_USE_WDG
    static Timer lastTimeWasReset;
    static efitimems_t wdUptime = 0;
    // check if it's time to reset the watchdog
    if (lastTimeWasReset.hasElapsedMs(watchdogResetPeriodMs)) {
        // we assume tryResetWatchdog() is called from a timer callback
        wdgResetI(&WDGD1);
        lastTimeWasReset.reset();
        // with 100 ms WD
        if (wdUptime < watchdogCounterResetDelay) {
            wdUptime += watchdogResetPeriodMs;
            // we just crossed the treshold
            if (wdUptime >= watchdogCounterResetDelay) {
#if EFI_USE_OPENBLT
                SharedParamsWriteByIndex(1, 0);
#endif
            }
        }
    }
#endif // HAL_USE_WDG
}

Here is the call graph for this function:

Variable Documentation

__main_stack_base__

uint32_t __main_stack_base__

extern

Referenced by getRemainingStack().

watchdogCounterResetDelay

const efitimems_t watchdogCounterResetDelay = 3000

static

Definition at line 158 of file stm32_common.cpp.

Referenced by tryResetWatchdog().

watchdogResetPeriodMs

efitimems_t watchdogResetPeriodMs = 0

static

Definition at line 156 of file stm32_common.cpp.

Referenced by setWatchdogResetPeriod(), and tryResetWatchdog().

Go to the source code of this file.