stk_arch_common.h

Go to the documentation of this file.

/*
 * SuperTinyKernel(TM) RTOS: Lightweight High-Performance Deterministic C++ RTOS for Embedded Systems.
 *
 * Source: https://github.com/SuperTinyKernel-RTOS
 *
 * Copyright (c) 2022-2026 Neutron Code Limited <stk@neutroncode.com>. All Rights Reserved.
 * License: MIT License, see LICENSE for a full text.
 */
 
#ifndef STK_ARCH_COMMON_H_
#define STK_ARCH_COMMON_H_

 
#include "stk_common.h"
 
namespace stk {

class PlatformContext
{
public:
    explicit PlatformContext() : m_handler(nullptr), m_service(nullptr), m_stack_idle(nullptr),
        m_stack_active(nullptr), m_tick_resolution(0U)
    {}

    void InitializeBase(IPlatform::IEventHandler *handler, IKernelService *service, Stack *exit_trap,
        uint32_t resolution_us)
    {
        m_handler         = handler;
        m_service         = service;
        m_stack_idle      = exit_trap;
        m_stack_active    = nullptr;
        m_tick_resolution = resolution_us;
    }

    static inline Word InitStackMemory(IStackMemory *const memory)
    {
        STK_ASSERT(memory != nullptr);
              
        ArrayView<Word> stack(const_cast<Word *>(memory->GetStack()), memory->GetStackSize());
        STK_ASSERT(stack.GetSize() >= STACK_SIZE_MIN);
        
        // initialize stack memory to satisfy stack integrity check in Kernel::StateSwitch
        for (size_t i = 0U; i < stack.GetSize(); ++i)
        {
            stack[i] = STK_STACK_MEMORY_FILLER;
        }
        
        // get address of the last valid item and step forward by 1 Word size to point to the top
        const Word stack_top = hw::PtrToWord(memory->GetStack()) + (stack.GetSize() * sizeof(Word));
 
        // expecting STK_STACK_MEMORY_ALIGN-byte aligned memory for a stack
        STK_ASSERT((stack_top & (STK_STACK_MEMORY_ALIGN - 1U)) == 0U);
 
        return stack_top;
    }
 
    IPlatform::IEventHandler *m_handler;         
    IKernelService           *m_service;         
    Stack                    *m_stack_idle;      
    Stack                    *m_stack_active;    
    uint32_t                  m_tick_resolution; 
 
protected:
    STK_NONCOPYABLE_CLASS(PlatformContext);

    ~PlatformContext() = default;
};

#ifndef STK_ARCH_GET_CPU_ID
    #define STK_ARCH_GET_CPU_ID() (0)
#endif

#ifndef _STK_UNDER_TEST
    #define GetContext() s_StkPlatformContext[STK_ARCH_GET_CPU_ID()]
#endif

static __stk_forceinline Cycles ConvertTimeUsToClockCycles(uint32_t clock_freq, Ticks time_us)
{
    return ((static_cast<Cycles>(time_us) * clock_freq) / 1000000ULL);
}
 
} // namespace stk
 
#endif /* STK_ARCH_COMMON_H_ */