stm32_lock.h

Go to the documentation of this file.

 
#ifndef __STM32_LOCK_H__
#define __STM32_LOCK_H__
 
/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include <stddef.h>
#include <cmsis_compiler.h>
 
#ifndef STM32_THREAD_SAFE_STRATEGY
    #define STM32_THREAD_SAFE_STRATEGY 2 
#endif                                   /* STM32_THREAD_SAFE_STRATEGY */
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/* Function prototypes -------------------------------------------------------*/
void Error_Handler(void);
 
/* Public macros -------------------------------------------------------------*/
#define STM32_LOCK_BLOCK() \
    do {                   \
        __disable_irq();   \
        Error_Handler();   \
        while (1);         \
    } while (0)

#define STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(x) \
    do {                                     \
        if ((x) == NULL) {                   \
            STM32_LOCK_BLOCK();              \
        }                                    \
    } while (0)

#define STM32_LOCK_BLOCK_IF_INTERRUPT_CONTEXT() \
    do {                                        \
        if (__get_IPSR()) {                     \
            STM32_LOCK_BLOCK();                 \
        }                                       \
    } while (0)

#define STM32_LOCK_UNUSED(var) (void)var

#define STM32_LOCK_ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
 
#if STM32_THREAD_SAFE_STRATEGY == 1
    /*
     * User defined thread-safe implementation.
     */
 
    /* Includes ----------------------------------------------------------------*/
    #define STM32_LOCK_API 1
    #include "stm32_lock_user.h"
    #undef STM32_LOCK_API
 
#elif STM32_THREAD_SAFE_STRATEGY == 2
    /*
     * Allow lock usage from interrupts.
     */
 
    /* Private defines ---------------------------------------------------------*/
    #define LOCKING_DATA_INIT { 0, 0 }
 
/* Private typedef ---------------------------------------------------------*/
typedef struct {
    uint8_t flag;    
    uint8_t counter; 
} LockingData_t;
 
/* Private functions -------------------------------------------------------*/

static inline void stm32_lock_init(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    lock->flag = 0;
    lock->counter = 0;
}

static inline void stm32_lock_acquire(LockingData_t *lock) {
    uint8_t flag = (uint8_t)(__get_PRIMASK() & 0x1); /* PRIMASK.PM */
    __disable_irq();
    __DSB();
    __ISB();
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    if (lock->counter == 0) {
        lock->flag = flag;
    } else if (lock->counter == UINT8_MAX) {
        STM32_LOCK_BLOCK();
    }
    lock->counter++;
}

static inline void stm32_lock_release(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    if (lock->counter == 0) {
        STM32_LOCK_BLOCK();
    }
    lock->counter--;
    if (lock->counter == 0 && lock->flag == 0) {
        __enable_irq();
    }
}
 
#elif STM32_THREAD_SAFE_STRATEGY == 3
    /*
     * Deny lock usage from interrupts.
     */
 
    /* Private defines ---------------------------------------------------------*/
    #define LOCKING_DATA_INIT 0
 
/* Private typedef ---------------------------------------------------------*/
typedef uint8_t LockingData_t; 
 
/* Private functions -------------------------------------------------------*/

static inline void stm32_lock_init(LockingData_t *lock) { STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock); }

static inline void stm32_lock_acquire(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    STM32_LOCK_BLOCK_IF_INTERRUPT_CONTEXT();
}

static inline void stm32_lock_release(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    STM32_LOCK_BLOCK_IF_INTERRUPT_CONTEXT();
}
 
#elif STM32_THREAD_SAFE_STRATEGY == 4
    /*
     * Allow lock usage from interrupts. Implemented using FreeRTOS locks.
     */
 
    /* Includes ----------------------------------------------------------------*/
    #include <FreeRTOS.h>
    #include <task.h>
 
    #if defined(__GNUC__) && !defined(__CC_ARM) && configUSE_NEWLIB_REENTRANT == 0
        #warning Please set configUSE_NEWLIB_REENTRANT to 1 in FreeRTOSConfig.h, otherwise newlib will not be thread-safe
    #endif /* defined (__GNUC__) && !defined (__CC_ARM) && configUSE_NEWLIB_REENTRANT == 0 */
 
    /* Private defines ---------------------------------------------------------*/
    #define LOCKING_DATA_INIT            { { 0, 0 }, 0 }
    #define STM32_LOCK_MAX_NESTED_LEVELS 2 
typedef struct {
    uint32_t basepri[STM32_LOCK_MAX_NESTED_LEVELS];
    uint8_t nesting_level;
} LockingData_t;
 
    /* Private macros ----------------------------------------------------------*/
    #define STM32_LOCK_ASSERT_VALID_NESTING_LEVEL(lock)                        \
        do {                                                                   \
            if (lock->nesting_level >= STM32_LOCK_ARRAY_SIZE(lock->basepri)) { \
                STM32_LOCK_BLOCK();                                            \
            }                                                                  \
        } while (0)
 
/* Private functions -------------------------------------------------------*/

static inline void stm32_lock_init(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    for (size_t i = 0; i < STM32_LOCK_ARRAY_SIZE(lock->basepri); i++) {
        lock->basepri[i] = 0;
    }
    lock->nesting_level = 0;
}

static inline void stm32_lock_acquire(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    STM32_LOCK_ASSERT_VALID_NESTING_LEVEL(lock);
    lock->basepri[lock->nesting_level++] = taskENTER_CRITICAL_FROM_ISR();
}

static inline void stm32_lock_release(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    lock->nesting_level--;
    STM32_LOCK_ASSERT_VALID_NESTING_LEVEL(lock);
    taskEXIT_CRITICAL_FROM_ISR(lock->basepri[lock->nesting_level]);
}
 
    #undef STM32_LOCK_ASSERT_VALID_NESTING_LEVEL
    #undef STM32_LOCK_MAX_NESTED_LEVELS
 
#elif STM32_THREAD_SAFE_STRATEGY == 5
    /*
     * Deny lock usage from interrupts. Implemented using FreeRTOS locks.
     */
 
    /* Includes ----------------------------------------------------------------*/
    #include <FreeRTOS.h>
    #include <task.h>
    #if defined(__GNUC__) && !defined(__CC_ARM) && configUSE_NEWLIB_REENTRANT == 0
        #warning Please set configUSE_NEWLIB_REENTRANT to 1 in FreeRTOSConfig.h, otherwise newlib will not be thread-safe
    #endif /* defined (__GNUC__) && !defined (__CC_ARM) && configUSE_NEWLIB_REENTRANT == 0 */
 
    /* Private defines ---------------------------------------------------------*/
    #define LOCKING_DATA_INIT 0
 
/* Private typedef ---------------------------------------------------------*/
typedef uint8_t LockingData_t; 
 
/* Private functions -------------------------------------------------------*/

static inline void stm32_lock_init(LockingData_t *lock) { STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock); }

static inline void stm32_lock_acquire(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    STM32_LOCK_BLOCK_IF_INTERRUPT_CONTEXT();
    vTaskSuspendAll();
}

static inline void stm32_lock_release(LockingData_t *lock) {
    STM32_LOCK_BLOCK_IF_NULL_ARGUMENT(lock);
    STM32_LOCK_BLOCK_IF_INTERRUPT_CONTEXT();
    xTaskResumeAll();
}
 
#else
    #error Invalid STM32_THREAD_SAFE_STRATEGY specified
#endif /* STM32_THREAD_SAFE_STRATEGY */
 
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
 
#endif /* __STM32_LOCK_H__ */