qp_port.hpp

Go to the documentation of this file.

//! @file
//! @brief Sample QP/C++ port
//!
//! @details
//! This is just an example of a QF port for a generic C99 compiler.
//! Other specific QF ports will define the QF facilities differently.
 
#ifndef QP_PORT_HPP_
#define QP_PORT_HPP_
 
#include <cstdint>  // Exact-width types. C++11 Standard
 
//! @brief No-return specifier for the Q_onError() callback function.
//!
//! @details
//! If the `Q_NORETURN` macro is undefined, the default definition uses
//! the C++11 specifier `[[ noreturn ]]`.
//!
//! @note
//! The `Q_NORETURN` macro can be defined in the QP port (typically in
//! `qep_port.hpp`). If such definition is provided the default won't be used.
#define Q_NORETURN  [[ noreturn ]] void
 
// QF configuration for the data members of the QActive class ----------------
//! QP::QActive event queue type used in various QP/C++ ports.
#define QACTIVE_EQUEUE_TYPE  QEQueue
 
//! QP::QActive "OS-object" type used in various QP/C++ ports.
#define QACTIVE_OS_OBJ_TYPE  void*
 
//! QP::QActive "thread" type used in various QP/C++ ports.
#define QACTIVE_THREAD_TYPE  void const *
 
// interrupt disabling mechanism ---------------------------------------------
//! Disable interrupts
#define QF_INT_DISABLE()    intDisable()
 
//! Enable interrupts
#define QF_INT_ENABLE()     intEnable()
 
// QF critical section mechanism ---------------------------------------------
//! Define the critical section status that was present before entering
//! the critical section.
//!
//! @details
//! For critical sections that are allowed to nest, the critical section
//! status must be saved and restored at the end. This macro provides the
//! storage for saving the status.
//!
//! @note
//! This macro might be empty, in which case the critical section status
//! is not saved or restored. Such critical sections won't be able to nest.
//! Also, note that the macro should be invoked without the closing semicolon.
#define QF_CRIT_STAT       std::uint32_t crit_stat_;
 
//! Enter the critical section
//!
//! @details
//! If the critical section status is provided, the macro saves the
//! critical section status from before entering the critical section.
//! Otherwise, the macro just unconditionally enters the critical section
//! without saving the status.
#define QF_CRIT_ENTRY()        (crit_stat_ = critEntry())
 
//! Exit the critical section
//!
//! @details
//! If the critical section status is provided, the macro restores the
//! critical section status saved by QF_CRIT_ENTRY(). Otherwise, the macro
//! just unconditionally exits the critical section.
#define QF_CRIT_EXIT()        critExit(crit_stat_)
 
extern "C" {
 
void intDisable(void);
void intEnable(void);
std::uint32_t critEntry(void);
void critExit(std::uint32_t stat);
std::uint32_t QK_get_IPSR(void);
 
} // extern "C"
 
 
#ifdef QF_MEM_ISOLATE
 
    ///! Memory isolation requires the context-switch
    #define QF_ON_CONTEXT_SW   1U
 
    //! Memory System setting
    #define QF_MEM_SYS() QF_onMemSys()
 
    //! Memory Application setting
    #define QF_MEM_APP() QF_onMemApp()
 
#endif ///! def QF_MEM_ISOLATE
 
// QV-specific ---------------------------------------------------------------
//! Macro to put the CPU to sleep **safely** in the non-preemptive
//! QV kernel (to be called from QV::onIdle()).
#define QV_CPU_SLEEP()     \
do {                       \
    __disable_interrupt(); \
    QF_INT_ENABLE();       \
    __WFI();               \
    __enable_interrupt();  \
} while (false)
 
 
// QK-specific ---------------------------------------------------------------
/*! Check if the code executes in the ISR context */
#define QK_ISR_CONTEXT_() (QK_priv_.intNest != 0U)
 
//! Define the ISR entry sequence
#define QK_ISR_ENTRY()                               \
do {                                                 \
    QF_INT_DISABLE();                                \
    ++QK_priv_.intNest;                              \
    QF_QS_ISR_ENTRY(QK_priv_.intNest, QK_currPrio_); \
    QF_INT_ENABLE();                            \
} while (false)
 
/*! Define the ISR exit sequence */
#define QK_ISR_EXIT()             \
do {                              \
    QF_INT_DISABLE();             \
    --QK_priv_.intNest;           \
    if (QK_priv_.intNest == 0U) { \
        if (QK_sched_() != 0U) {  \
            QK_activate_();       \
        }                         \
    }                             \
    QF_INT_ENABLE();              \
} while (false)
 
// QXK-specific --------------------------------------------------------------
//! Check if the code executes in the ISR context
#define QXK_ISR_CONTEXT_() (QXK_get_IPSR() != 0U)
 
//! Trigger context switch (used internally in QXK only)
#define QXK_CONTEXT_SWITCH_() (trigPendSV())
 
//! Define the ISR entry sequence
#define QXK_ISR_ENTRY() ((void)0)
 
//! Define the ISR exit sequence
#define QXK_ISR_EXIT()  do {                                  \
    QF_INT_DISABLE();                                         \
    if (QXK_sched_() != 0U) {                                 \
        *Q_UINT2PTR_CAST(uint32_t, 0xE000ED04U) = (1U << 28U);\
    }                                                         \
    QF_INT_ENABLE();                                          \
    QXK_ARM_ERRATUM_838869();                                 \
} while (false)
 
// include files -------------------------------------------------------------
#include "qequeue.hpp"  // QK kernel uses the native QP event queue
#include "qmpool.hpp"   // QK kernel uses the native QP memory pool
#include "qp.hpp"       // %QP Framework
#include "qk.hpp"       // QK kernel
 
#endif // QP_PORT_HPP_