tx-support.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 * Copyright (C) 2021 embedded brains GmbH & Co. KG
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef _TX_SUPPORT_H
#define _TX_SUPPORT_H
 
#include <rtems.h>
#include <rtems/irq-extension.h>
#include <rtems/score/atomic.h>
#include <rtems/score/threadq.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
  PRIO_PSEUDO_ISR,
  PRIO_VERY_ULTRA_HIGH,
  PRIO_ULTRA_HIGH,
  PRIO_VERY_HIGH,
  PRIO_HIGH,
  PRIO_NORMAL,
  PRIO_LOW,
  PRIO_VERY_LOW,
  PRIO_ULTRA_LOW
} Priority;
 
#define PRIO_DEFAULT 1
 
#define PRIO_INVALID 0xfffffffe
 
#define PRIO_NEARLY_IDLE 126
 
#define PRIO_FLEXIBLE 64
 
#define INVALID_ID 0xfffffffd
 
#define OBJECT_NAME rtems_build_name( 'T', 'E', 'S', 'T' )
 
#define CreateTask( name, priority ) \
  DoCreateTask( \
    rtems_build_name( name[ 0 ], name[ 1 ], name[ 2 ], name[ 3 ] ), \
    priority \
  )
 
#define SCHEDULER_A_ID 0xf010001
 
#define SCHEDULER_B_ID 0xf010002
 
#define SCHEDULER_C_ID 0xf010003
 
#define SCHEDULER_D_ID 0xf010004
 
rtems_id DoCreateTask( rtems_name name, rtems_task_priority priority );
 
void StartTask( rtems_id id, rtems_task_entry entry, void *arg );
 
void DeleteTask( rtems_id id );
 
void SuspendTask( rtems_id id );
 
void SuspendSelf( void );
 
void ResumeTask( rtems_id id );
 
bool IsTaskSuspended( rtems_id id );
 
rtems_event_set QueryPendingEvents( void );
 
rtems_event_set PollAnyEvents( void );
 
rtems_event_set ReceiveAnyEvents( void );
 
rtems_event_set ReceiveAnyEventsTimed( rtems_interval ticks );
 
void ReceiveAllEvents( rtems_event_set events );
 
void SendEvents( rtems_id id, rtems_event_set events );
 
rtems_mode GetMode( void );
 
rtems_mode SetMode( rtems_mode set, rtems_mode mask );
 
rtems_task_priority GetPriority( rtems_id id );
 
rtems_task_priority GetPriorityByScheduler(
  rtems_id task_id,
  rtems_id scheduler_id
);
 
rtems_task_priority SetPriority( rtems_id id, rtems_task_priority priority );
 
rtems_task_priority GetSelfPriority( void );
 
rtems_task_priority SetSelfPriority( rtems_task_priority priority );
 
rtems_task_priority SetSelfPriorityNoYield( rtems_task_priority priority );
 
rtems_id GetScheduler( rtems_id id );
 
rtems_id GetSelfScheduler( void );
 
void SetScheduler(
  rtems_id            task_id,
  rtems_id            scheduler_id,
  rtems_task_priority priority
);
 
void SetSelfScheduler( rtems_id scheduler_id, rtems_task_priority priority );
 
void GetAffinity( rtems_id id, cpu_set_t *set );
 
void GetSelfAffinity( cpu_set_t *set );
 
void SetAffinity( rtems_id id, const cpu_set_t *set );
 
void SetSelfAffinity( const cpu_set_t *set );
 
void SetAffinityOne( rtems_id id, uint32_t cpu_index );
 
void SetSelfAffinityOne( uint32_t cpu_index );
 
void SetAffinityAll( rtems_id id );
 
void SetSelfAffinityAll( void );
 
void Yield( void );
 
void YieldTask( rtems_id id );
 
void AddProcessor( rtems_id scheduler_id, uint32_t cpu_index );
 
void RemoveProcessor( rtems_id scheduler_id, uint32_t cpu_index );
 
rtems_id CreateMutex( void );
 
rtems_id CreateMutexNoProtocol( void );
 
rtems_id CreateMutexFIFO( void );
 
bool IsMutexOwner( rtems_id id );
 
void DeleteMutex( rtems_id id );
 
void ObtainMutex( rtems_id id );
 
void ObtainMutexTimed( rtems_id id, rtems_interval ticks );
 
void ObtainMutexDeadlock( rtems_id id );
 
void ReleaseMutex( rtems_id id );
 
struct Thread_queue_Queue;
 
struct Thread_queue_Queue *GetMutexThreadQueue( rtems_id id );
 
void RestoreRunnerASR( void );
 
void RestoreRunnerMode( void );
 
void RestoreRunnerPriority( void );
 
void RestoreRunnerScheduler( void );
 
struct _Thread_Control;
 
struct _Thread_Control *GetThread( rtems_id id );
 
struct _Thread_Control *GetExecuting( void );
 
void KillZombies( void );
 
void WaitForExecutionStop( rtems_id task_id );
 
void WaitForIntendToBlock( rtems_id task_id );
 
void WaitForHeir( uint32_t cpu_index, rtems_id task_id );
 
void WaitForNextTask( uint32_t cpu_index, rtems_id task_id );
 
typedef enum {
  TASK_TIMER_INVALID,
  TASK_TIMER_INACTIVE,
  TASK_TIMER_TICKS,
  TASK_TIMER_REALTIME,
  TASK_TIMER_MONOTONIC
} TaskTimerState;
 
typedef struct {
  TaskTimerState state;
  uint64_t expire_ticks;
  struct timespec expire_timespec;
} TaskTimerInfo;
 
void GetTaskTimerInfo( rtems_id id, TaskTimerInfo *info );
 
void GetTaskTimerInfoByThread(
  struct _Thread_Control *thread,
  TaskTimerInfo          *info
);
 
void ClockTick( void );
 
void FinalClockTick( void );
 
void TimecounterTick( void );
 
typedef uint32_t ( *GetTimecountHandler )( void );
 
GetTimecountHandler SetGetTimecountHandler( GetTimecountHandler handler );
 
#define SOFTWARE_TIMECOUNTER_FREQUENCY 1000000
 
uint32_t GetTimecountCounter( void );
 
uint32_t SetTimecountCounter( uint32_t counter );
 
rtems_id GetTimerServerTaskId( void );
 
bool DeleteTimerServer( void );
 
typedef struct {
  struct {
    const void *begin;
    void *free_begin;
    const void *end;
  } areas[ 2 ];
  size_t count;
} MemoryContext;
 
void MemorySave( MemoryContext *ctx );
 
void MemoryRestore( const MemoryContext *ctx );
 
void MemoryAllocationFailWhen( uint32_t counter );
 
typedef struct {
  Chain_Node node;
  void ( *handler )( void * );
  void *arg;
  Atomic_Uint done;
} CallWithinISRRequest;
 
void CallWithinISR( void ( *handler )( void * ), void *arg );
 
void CallWithinISRSubmit( CallWithinISRRequest *request );
 
void CallWithinISRWait( const CallWithinISRRequest *request );
 
void CallWithinISRRaise( void );
 
void CallWithinISRClear( void );
 
rtems_vector_number CallWithinISRGetVector( void );
 
rtems_vector_number GetSoftwareInterruptVector( void );
 
typedef struct {
  Thread_queue_Operations        tq_ops;
  const Thread_queue_Operations *wrapped_ops;
  Thread_queue_Control           thread_queue;
  CallWithinISRRequest           isr_request;
} WrapThreadQueueContext;
 
void WrapThreadQueueInitialize(
  WrapThreadQueueContext *ctx,
  void                 ( *handler )( void * ),
  void                   *arg
);
 
void WrapThreadQueueExtract(
  WrapThreadQueueContext *ctx,
  struct _Thread_Control *thread
);
 
void WrapThreadQueueExtractDirect(
  WrapThreadQueueContext *ctx,
  Thread_Control         *thread
);
 
void WrapThreadQueueDestroy( WrapThreadQueueContext *ctx );
 
struct Per_CPU_Control;
 
void SetPreemptionIntervention(
  struct Per_CPU_Control *cpu,
  void                 ( *handler )( void * ),
  void                   *arg
);
 
rtems_vector_number GetValidInterruptVectorNumber(
  const rtems_interrupt_attributes *required
);
 
rtems_vector_number GetTestableInterruptVector(
  const rtems_interrupt_attributes *required
);
 
rtems_status_code RaiseSoftwareInterrupt( rtems_vector_number vector );
 
rtems_status_code ClearSoftwareInterrupt( rtems_vector_number vector );
 
bool HasInterruptVectorEntriesInstalled( rtems_vector_number vector );
 
Timer_Classes GetTimerClass( rtems_id id );
 
typedef struct {
  rtems_timer_service_routine_entry routine;
  void *user_data;
  Watchdog_Interval interval;
} Timer_Scheduling_Data;
 
void GetTimerSchedulingData(
  rtems_id id,
  Timer_Scheduling_Data *data
);
 
typedef enum {
  TIMER_INVALID,
  TIMER_INACTIVE,
  TIMER_SCHEDULED,
  TIMER_PENDING
} Timer_States;
 
Timer_States GetTimerState( rtems_id id );
 
void UnsetClock( void );
 
void FatalInitialExtension(
  rtems_fatal_source source,
  bool               always_set_to_false,
  rtems_fatal_code   code
);
 
typedef void ( *FatalHandler )(
  rtems_fatal_source source,
  rtems_fatal_code   code,
  void              *arg
);
 
void SetFatalHandler( FatalHandler fatal, void *arg );
 
void SetTaskSwitchExtension( rtems_task_switch_extension task_switch );
 
typedef struct {
  uint32_t fatal;
  uint32_t thread_begin;
  uint32_t thread_create;
  uint32_t thread_delete;
  uint32_t thread_exitted;
  uint32_t thread_restart;
  uint32_t thread_start;
  uint32_t thread_switch;
  uint32_t thread_terminate;
} ExtensionCalls;
 
void ClearExtensionCalls( ExtensionCalls *calls );
 
void CopyExtensionCalls( const ExtensionCalls *from, ExtensionCalls *to );
 
void SetIORelaxHandler( void ( *handler )( void * ), void *arg );
 
void StartDelayThreadDispatch( uint32_t cpu_index );
 
void StopDelayThreadDispatch( uint32_t cpu_index );
 
bool AreInterruptsEnabled( void );
 
bool IsWhiteSpaceOnly( const char *s );
 
bool IsEqualIgnoreWhiteSpace( const char *a, const char *b );
 
#if defined(RTEMS_SMP)
bool TicketLockIsAvailable( const SMP_ticket_lock_Control *lock );
 
void TicketLockWaitForOwned( const SMP_ticket_lock_Control *lock );
 
void TicketLockWaitForOthers(
  const SMP_ticket_lock_Control *lock,
  unsigned int                   others
);
 
typedef struct {
  const SMP_ticket_lock_Control *lock;
  unsigned int                   next_ticket;
} TicketLockState;
 
void TicketLockGetState(
  const SMP_ticket_lock_Control *lock,
  TicketLockState               *state
);
 
void TicketLockWaitForAcquires(
  const TicketLockState *state,
  unsigned int           acquire_count
);
 
void TicketLockWaitForReleases(
  const TicketLockState *state,
  unsigned int           release_count
);
 
static inline bool ISRLockIsAvailable( const ISR_lock_Control *lock )
{
  return TicketLockIsAvailable( &lock->Lock.Ticket_lock );
}
 
static inline void ISRLockWaitForOwned( const ISR_lock_Control *lock )
{
  TicketLockWaitForOwned( &lock->Lock.Ticket_lock );
}
 
static inline void ISRLockWaitForOthers(
  const ISR_lock_Control *lock,
  unsigned int            others
)
{
  TicketLockWaitForOthers( &lock->Lock.Ticket_lock, others );
}
#endif
 
void *IdleBody( uintptr_t ignored );
 
extern const rtems_task_config DefaultTaskConfig;
 
#ifdef __cplusplus
}
#endif
 
#endif /* _TX_SUPPORT_H */