icall.h

Go to the documentation of this file.

/******************************************************************************

 Group: WCS, LPC, BTS
 $Target Device: DEVICES $

 ******************************************************************************
 $License: BSD3 2013 $
 ******************************************************************************
 $Release Name: PACKAGE NAME $
 $Release Date: PACKAGE RELEASE DATE $
 *****************************************************************************/

#ifndef ICALL_H
#define ICALL_H

#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

#include "hal_assert.h"

#define ICALL_SERVICE_CLASS_MASK        0xFFF8

#define ICALL_SERVICE_INSTANCE_MASK     0x0007

#define ICALL_SERVICE_CLASS_PRIMITIVE   0x0008

/* Radio stack services */

#define ICALL_SERVICE_CLASS_BLE         0x0010

#define ICALL_SERVICE_CLASS_TIMAC       0x0018

#define ICALL_SERVICE_CLASS_REMOTI_RTI  0x0020

#define ICALL_SERVICE_CLASS_REMOTI_RCN  0x0028

#define ICALL_SERVICE_CLASS_ZSTACK      0x0030

#define ICALL_SERVICE_CLASS_NPI         0x0038

#define ICALL_SERVICE_CLASS_BLE_MSG     0x0050

/* Services that are visible only for other services
 * but not for applications */

#define ICALL_SERVICE_CLASS_CRYPTO      0x0080

#define ICALL_SERVICE_CLASS_BLE_BOARD   0x0088

#define ICALL_SERVICE_CLASS_TIMAC_BOARD 0x0090

#define ICALL_SERVICE_CLASS_RADIO       0x0098

#define ICALL_SERVICE_CLASS_DUMMY       0x0100

#define ICALL_SERVICE_CLASS_DUMMY_BOARD 0x0200

#define ICALL_INVALID_ENTITY_ID            0xffu

#define ICALL_INVALID_TIMER_ID             NULL


#define ICALL_UNDEF_DEST_ID                0xffu

#define ICALL_ERRNO_SUCCESS                0

#define ICALL_ERRNO_TIMEOUT                1

#define ICALL_ERRNO_NOMSG                  2

#define ICALL_ERRNO_INVALID_SERVICE        -1

#define ICALL_ERRNO_INVALID_FUNCTION       -2

#define ICALL_ERRNO_INVALID_PARAMETER      -3

#define ICALL_ERRNO_NO_RESOURCE            -4

#define ICALL_ERRNO_UNKNOWN_THREAD         -5

#define ICALL_ERRNO_CORRUPT_MSG            -6

#define ICALL_ERRNO_OVERFLOW               -7

#define ICALL_ERRNO_UNDERFLOW              -8

#define ICALL_MSG_FORMAT_KEEP              0

#define ICALL_MSG_FORMAT_1ST_CHAR_TASK_ID  1

#define ICALL_MSG_FORMAT_3RD_CHAR_TASK_ID  2

#ifdef ICALL_LITE

#define ICALL_MSG_FORMAT_DIRECT_API_ID     3

#define ICALL_LITE_DIRECT_API_DONE_CMD_ID  0x42

#endif   /* ICALL_LITE */

#define ICALL_TIMEOUT_FOREVER              0xfffffffful

#ifndef ICALL_TIMEOUT_PREDEFINE
#define ICALL_TIMEOUT_PREDEFINE            5000
#endif   /* ICALL_TIMEOUT_PREDEFINE */

#define ICALL_SEMAPHORE_MODE_COUNTING      0

#define ICALL_SEMAPHORE_MODE_BINARY        1

/* @brief Primitive service function enumeration */


#define ICALL_PRIMITIVE_FUNC_ENROLL                       0

#define ICALL_PRIMITIVE_FUNC_REGISTER_APP                 1

#define ICALL_PRIMITIVE_FUNC_MSG_ALLOC                    2

#define ICALL_PRIMITIVE_FUNC_MSG_FREE                     3

#define ICALL_PRIMITIVE_FUNC_MALLOC                       4

#define ICALL_PRIMITIVE_FUNC_FREE                         5

#define ICALL_PRIMITIVE_FUNC_SEND_MSG                     6

#define ICALL_PRIMITIVE_FUNC_FETCH_MSG                    7

#define ICALL_PRIMITIVE_FUNC_SEND_SERV_MSG                8

#define ICALL_PRIMITIVE_FUNC_FETCH_SERV_MSG               9

#define ICALL_PRIMITIVE_FUNC_WAIT                         10

#define ICALL_PRIMITIVE_FUNC_SIGNAL                       11

#define ICALL_PRIMITIVE_FUNC_ABORT                        12

#define ICALL_PRIMITIVE_FUNC_ENABLE_INT                   13

#define ICALL_PRIMITIVE_FUNC_DISABLE_INT                  14

#define ICALL_PRIMITIVE_FUNC_ENABLE_MINT                  15

#define ICALL_PRIMITIVE_FUNC_DISABLE_MINT                 16

#define ICALL_PRIMITIVE_FUNC_REGISTER_ISR                 17

#define ICALL_PRIMITIVE_FUNC_GET_TICKS                    18

#define ICALL_PRIMITIVE_FUNC_SET_TIMER_MSECS              19

#define ICALL_PRIMITIVE_FUNC_GET_TICK_PERIOD              20

#define ICALL_PRIMITIVE_FUNC_GET_MAX_MILLISECONDS         21

#define ICALL_PRIMITIVE_FUNC_ENTITY2SERVICE               22

#define ICALL_PRIMITIVE_FUNC_PWR_UPD_ACTIVITY_COUNTER     23

#define ICALL_PRIMITIVE_FUNC_PWR_REGISTER_NOTIFY          24

#define ICALL_PRIMITIVE_FUNC_WAIT_MATCH                   25

#define ICALL_PRIMITIVE_FUNC_GET_ENTITY_ID                26

#define ICALL_PRIMITIVE_FUNC_SET_TIMER                    27

#define ICALL_PRIMITIVE_FUNC_STOP_TIMER                   28

#define ICALL_PRIMITIVE_FUNC_PWR_CONFIG_AC_ACTION         29

#define ICALL_PRIMITIVE_FUNC_PWR_REQUIRE                  30

#define ICALL_PRIMITIVE_FUNC_PWR_DISPENSE                 31

#define ICALL_PRIMITIVE_FUNC_THREAD_SERVES                32

#define ICALL_PRIMITIVE_FUNC_PWR_IS_STABLE_XOSC_HF        33

#define ICALL_PRIMITIVE_FUNC_PWR_GET_TRANSITION_STATE     34

#define ICALL_PRIMITIVE_FUNC_CREATE_TASK                  35

#define ICALL_PRIMITIVE_FUNC_CREATE_SEMAPHORE             36

#define ICALL_PRIMITIVE_FUNC_WAIT_SEMAPHORE               37

#define ICALL_PRIMITIVE_FUNC_SWITCH_XOSC_HF               38

#define ICALL_PRIMITIVE_FUNC_PWR_GET_XOSC_STARTUP_TIME    39

#define ICALL_PRIMITIVE_FUNC_REGISTER_ISR_EXT             40

#ifdef ICALL_EVENTS

#define ICALL_PRIMITIVE_FUNC_POST_SEMAPHORE               41

#define ICALL_PRIMITIVE_FUNC_CREATE_EVENT                 42

#define ICALL_PRIMITIVE_FUNC_WAIT_EVENT                   43

#define ICALL_PRIMITIVE_FUNC_POST_EVENT                   44
#endif  /* ICALL_EVENTS */

#define ICALL_MSG_FUNC_GET_LOCAL_MSG_ENTITY_ID            0

#ifdef ICALL_EVENTS

#define ICALL_MSG_EVENT_ID                                Event_Id_31

#define ICALL_WAITMATCH_EVENT_ID                          Event_Id_29
#endif

typedef int_fast16_t ICall_Errno;

typedef uint_least16_t ICall_ServiceEnum;

typedef uint_least8_t ICall_MSGFormat;

typedef uint_least16_t ICall_FuncID;

typedef void *ICall_SyncHandle;

typedef void *ICall_TaskHandle;

typedef void *ICall_Semaphore;

#ifdef ICALL_EVENTS

typedef void *ICall_Event;
#endif /* ICALL_EVENTS */

typedef uint_least8_t ICall_EntityID;

typedef void *ICall_TimerID;

typedef struct
{
  uint32_t totalSize;
  uint32_t totalFreeSize;
  uint32_t largestFreeSize;
}ICall_heapStats_t;

typedef bool (*ICall_MsgMatchFn)(ICall_ServiceEnum src, ICall_EntityID dest,
                                 const void *msg);

typedef void (*ICall_TimerCback)(void *arg);

typedef struct _icall_func_args_hdr_t
{
  ICall_ServiceEnum service;   
  ICall_FuncID func;           
} ICall_FuncArgsHdr;

typedef struct _icall_register_app_args_t
{
  ICall_FuncArgsHdr hdr; 
  ICall_EntityID    entity; 
  ICall_SyncHandle   msgSyncHdl; 
} ICall_RegisterAppArgs;

typedef struct _icall_alloc_args_t
{
  ICall_FuncArgsHdr hdr; 
  size_t size;           
  void * ptr;            
} ICall_AllocArgs;

typedef struct _icall_free_args_t
{
  ICall_FuncArgsHdr hdr;    
  void * ptr;               
} ICall_FreeArgs;

typedef struct _icall_send_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_EntityID src;       
  union
  {
    ICall_EntityID entityId;    
    ICall_ServiceEnum servId;   
  } dest;     
  ICall_MSGFormat format;       
  void *msg;                    
} ICall_SendArgs;

typedef struct _icall_fetch_msg_args_t
{
  ICall_FuncArgsHdr hdr;      
  union
  {
    ICall_ServiceEnum servId; 
    ICall_EntityID entityId;  
  } src;    
  ICall_EntityID dest;        
  void *msg;                  
} ICall_FetchMsgArgs;

typedef struct _icall_wait_args_t
{
  ICall_FuncArgsHdr hdr;         
  uint_least32_t milliseconds;   
} ICall_WaitArgs;

typedef struct _icall_signal_args_t
{
  ICall_FuncArgsHdr hdr;      
  ICall_SyncHandle syncHandle;  
} ICall_SignalArgs;

typedef struct _icall_signal_events_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_SyncHandle syncHandle;  
  uint32_t          events;   
} ICall_SignalEventsArgs;

struct _icall_enroll_service_args_t;

typedef struct _icall_entity2service_args_t
{
  ICall_FuncArgsHdr hdr;          
  ICall_EntityID entityId;        
  ICall_ServiceEnum servId;       
} ICall_EntityId2ServiceIdArgs;

typedef struct _icall_intnum_args_t
{
  ICall_FuncArgsHdr hdr;      
  int_least32_t intnum;       
} ICall_IntNumArgs;

typedef struct _icall_register_isr_args_t
{
  ICall_FuncArgsHdr hdr;      
  int_least32_t intnum;       
  void (*isrfunc)(void);      
} ICall_RegisterISRArgs;

typedef struct _icall_register_isr_args_ext_t
{
  ICall_FuncArgsHdr hdr;               
  int_least32_t     intnum;            
  void              (*isrfunc)(void);  
  int               intPriority;       
} ICall_RegisterISRArgs_Ext;

typedef struct _icall_getuint32_args_t
{
  ICall_FuncArgsHdr hdr;      
  uint_least32_t value;       
} ICall_GetUint32Args;

typedef struct _icall_getbool_args_t
{
  ICall_FuncArgsHdr hdr;
  bool value;
} ICall_GetBoolArgs;

typedef struct _icall_pwr_upd_activity_counter_args_t
{
  ICall_FuncArgsHdr hdr;      
  bool incFlag;               
  bool pwrRequired;           
} ICall_PwrUpdActivityCounterArgs;

typedef uint_fast32_t ICall_PwrBitmap_t;

typedef struct _icall_pwr_bitmap_args_t
{
  ICall_FuncArgsHdr hdr;      
  ICall_PwrBitmap_t bitmap;   
} ICall_PwrBitmapArgs;

typedef struct _icall_pwr_get_transition_state_args_t
{
  ICall_FuncArgsHdr hdr;      
  uint_fast8_t state;         
} ICall_PwrGetTransitionStateArgs;

typedef struct _icall_pwr_get_xosc_startup_time_args_t
{
  ICall_FuncArgsHdr hdr;      
  uint_least32_t timeUntilWakeupInMs;   
  uint_least32_t value;         
} ICall_PwrGetXOSCStartupTimeArgs;

typedef struct _icall_thread_serves_args_t
{
  ICall_FuncArgsHdr hdr;        
  ICall_ServiceEnum servId;     
  uint_fast8_t result;          
} ICall_ThreadServesArgs;

typedef struct _icall_create_task_args_t
{
  ICall_FuncArgsHdr hdr;      
  void (*entryfn)(size_t arg);   
  uint_least8_t priority;       
  uint_least16_t stacksize;     
  size_t arg;                   
} ICall_CreateTaskArgs;

#ifdef ICALL_RTOS_SEMAPHORE_API

typedef struct _icall_create_semaphore_args_t
{
  ICall_FuncArgsHdr hdr;      

  uint_least8_t mode;
  int initcount;      
  ICall_Semaphore sem;    
} ICall_CreateSemaphoreArgs;

typedef struct _icall_post_semaphore_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_Semaphore sem;      
} ICall_PostSemaphoreArgs;

typedef struct _icall_wait_semaphore_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_Semaphore sem;      
  uint_least32_t milliseconds;  
} ICall_WaitSemaphoreArgs;
#endif /* ICALL_RTOS_SEMAPHORE_API */

#ifdef ICALL_RTOS_EVENTS_API

typedef struct _icall_create_event_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_Event event;        
} ICall_CreateEventArgs;

typedef struct _icall_post_event_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_Event event;        
  uint32_t events;          
} ICall_PostEventArgs;

typedef struct _icall_wait_event_args_t
{
  ICall_FuncArgsHdr hdr;      
  ICall_Event event;          
  uint_least32_t milliseconds;  
} ICall_WaitEventArgs;
#endif /* ICALL_RTOS_EVENTS_API */


typedef struct _icall_msg_hdr_t
{
  void    *next;
  uint8_t  srcentity; /* Source entity across threads */
  uint8_t  dstentity; /* Destination entity across threads */
  uint8_t  format;    /* message transformation request */
  uint16_t len;
  uint8_t  dest_id;
} ICall_MsgHdr;


typedef uint_fast8_t ICall_PwrTransition;

/* @brief Forward reference */
struct _icall_pwr_notify_data_t;

typedef void (*ICall_PwrNotifyFn)(ICall_PwrTransition pwrTrans,
                                  struct _icall_pwr_notify_data_t *obj);

typedef struct _icall_pwr_notify_data_t
{
  ICall_PwrNotifyFn _private;
} ICall_PwrNotifyData;

typedef struct _icall_pwr_register_notify_args_t
{
  ICall_FuncArgsHdr hdr;      
  ICall_PwrNotifyFn fn;       
  ICall_PwrNotifyData *obj;   
} ICall_PwrRegisterNotifyArgs;

typedef struct _icall_wait_match_args_t
{
  ICall_FuncArgsHdr hdr;        
  uint_least32_t milliseconds;  
  ICall_MsgMatchFn matchFn;     
  ICall_ServiceEnum servId;     
  ICall_EntityID dest;          
  void *msg;                    
} ICall_WaitMatchArgs;

typedef struct _icall_get_entity_id_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_EntityID entity;    
} ICall_GetEntityIdArgs;

typedef ICall_Errno (*ICall_Dispatcher)(ICall_FuncArgsHdr *args);

typedef uint_least32_t ICall_CSState;

typedef ICall_CSState (*ICall_EnterCS)(void);

typedef void (*ICall_LeaveCS)(ICall_CSState key);

extern ICall_Dispatcher ICall_dispatcher;

extern ICall_EnterCS ICall_enterCriticalSection;

extern ICall_LeaveCS ICall_leaveCriticalSection;

typedef struct _icall_remote_task_arg_t
{
  ICall_Dispatcher dispatch;      
  ICall_EnterCS entercs;          
  ICall_LeaveCS leavecs;          
} ICall_RemoteTaskArg;

typedef void (*ICall_RemoteTaskEntry)(const ICall_RemoteTaskArg *arg0,
                                      void *arg1);

typedef ICall_Errno (*ICall_ServiceFunc)(ICall_FuncArgsHdr *args);

typedef struct _icall_enroll_service_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_ServiceEnum service;  
  ICall_ServiceFunc fn;       
  ICall_EntityID entity;      
  ICall_SyncHandle msgSyncHdl;  
} ICall_EnrollServiceArgs;

typedef struct _icall_set_timer_args_t
{
  ICall_FuncArgsHdr hdr;      
  uint_least32_t timeout;     
  ICall_TimerID timerid;      
  ICall_TimerCback cback;     
  void *arg;                  
} ICall_SetTimerArgs;

typedef struct _icall_stop_timer_args_t
{
  ICall_FuncArgsHdr hdr;    
  ICall_TimerID timerid;    
} ICall_StopTimerArgs;

typedef struct _icall_get_local_msg_entity_id_args_t
{
  ICall_FuncArgsHdr hdr;        
  ICall_ServiceEnum service;     
  ICall_EntityID entity;        
  uint_least8_t localId;        
} ICall_GetLocalMsgEntityIdArgs;

typedef enum
{
   ICALL_RTI_APP_CMD_EVENT       = 0xE0,    
   ICALL_RTI_STACK_CMD_EVENT     = 0xE1,    
   ICALL_RTI_APP_ASYNC_CMD_EVENT = 0xE2,    
   ICALL_RTI_APP_SYNC_CMD_EVENT  = 0xE3,    
   ICALL_RCN_APP_ASYNC_CMD_EVENT = 0xE4,    
   ICALL_RCN_APP_SYNC_CMD_EVENT  = 0xE5     
}ICall_RemotiCmdEvent_t;

#ifdef ICALL_LITE
typedef uint_least32_t icall_lite_id_t;     

typedef struct _ICall_LiteCmdStatus_
{
  uint_least8_t cmdId;        
} ICall_LiteCmdStatus;

PACKED_TYPEDEF_STRUCT
{
  uint_least32_t    *pointerStack;    
  icall_lite_id_t   directAPI;        
} icall_directAPIMsg_t;               

PACKED_TYPEDEF_STRUCT
{
  ICall_MsgHdr hdr;                 
  icall_directAPIMsg_t   msg;       
} icallLiteMsg_t;                   

#endif /* ICALL_LITE */

typedef struct
{
  ICall_RemoteTaskEntry startupEntry;
  uint_least32_t        imgTaskPriority;
  uint_least32_t        imgTaskStackSize;
  void                  *ICall_imgInitParam;
} ICall_RemoteTask_t;

extern uint_least8_t ICall_resetReason;

extern void ICall_init(void);

extern void ICall_createRemoteTasks(void);

extern void ICall_createRemoteTasksAtRuntime(ICall_RemoteTask_t *remoteTaskTable, uint8_t nb_elems);

extern ICall_TaskHandle ICall_getRemoteTaskHandle(uint8 index);

extern ICall_EntityID ICall_searchServiceEntity(ICall_ServiceEnum service);

#ifdef ICALL_LITE

uint32_t icall_directAPI( uint8_t service, icall_lite_id_t id, ... );

ICall_Errno ICall_sendServiceComplete(ICall_EntityID src,
                                      ICall_EntityID dest,
                                      ICall_MSGFormat format,
                                      void *msg);
#endif /* ICALL_LITE */

#ifdef ICALL_JT

ICall_Errno ICall_registerApp(ICall_EntityID *entity, ICall_SyncHandle *msgSyncHdl);

void *ICall_allocMsg(size_t size);

void ICall_freeMsg(void *msg);

ICall_Errno
ICall_sendServiceMsg(ICall_EntityID src,
                     ICall_ServiceEnum dest,
                     ICall_MSGFormat format, void *msg);

ICall_Errno
ICall_fetchServiceMsg(ICall_ServiceEnum *src,
                      ICall_EntityID *dest,
                      void **msg);

ICall_Errno ICall_wait(uint_fast32_t milliseconds);

ICall_Errno ICall_signal(ICall_SyncHandle msgSyncHdl);

ICall_Errno
ICall_enrollService(ICall_ServiceEnum service,
                    ICall_ServiceFunc fn,
                    ICall_EntityID *entity,
                    ICall_SyncHandle *msgSyncHdl);

void *ICall_malloc(uint_least16_t size);

void ICall_free(void *msg);

void *ICall_mallocLimited(uint_least16_t size);

void ICall_getHeapStats(ICall_heapStats_t *stats);

ICall_Errno ICall_send(ICall_EntityID src,
                              ICall_EntityID dest,
                              ICall_MSGFormat format,
                              void *msg);

ICall_Errno ICall_fetchMsg(ICall_EntityID *src,
                                         ICall_EntityID *dest,
                                         void **msg);

ICall_Errno ICall_entityId2ServiceId(ICall_EntityID entityId,
                                                   ICall_ServiceEnum *servId);


#ifdef HEAPMGR_METRICS

void ICall_getHeapMgrGetMetrics(uint32_t *pBlkMax,
                                uint32_t *pBlkCnt,
                                uint32_t *pBlkFree,
                                uint32_t *pMemAlo,
                                uint32_t *pMemMax,
                                uint32_t *pMemUB);


#endif

ICall_Errno
ICall_abort(void);

ICall_Errno
ICall_enableInt(int intnum);

ICall_Errno
ICall_disableInt(int intnum);

ICall_Errno
ICall_enableMInt(void);

ICall_Errno
ICall_disableMInt(void);

ICall_Errno
ICall_registerISR(int intnum, void (*isrfunc)(void));

ICall_Errno
ICall_registerISR_Ext(int intnum, void (*isrfunc)(void), int intPriority );

uint_fast32_t
ICall_getTicks(void);

uint_fast32_t
ICall_getTickPeriod(void);
uint_fast32_t
ICall_getMaxMSecs(void);

ICall_Errno
ICall_setTimerMSecs(uint_fast32_t msecs,
                    ICall_TimerCback cback,
                    void *arg,
                    ICall_TimerID *id);

ICall_Errno
ICall_setTimer(uint_fast32_t ticks,
               ICall_TimerCback cback,
               void *arg,
               ICall_TimerID *id);

void
ICall_stopTimer(ICall_TimerID id);
bool
ICall_pwrUpdActivityCounter(bool incFlag);

ICall_Errno
ICall_pwrConfigACAction(ICall_PwrBitmap_t bitmap);
ICall_Errno
ICall_pwrRequire(ICall_PwrBitmap_t bitmap);

ICall_Errno
ICall_pwrDispense(ICall_PwrBitmap_t bitmap);

bool
ICall_pwrIsStableXOSCHF(void);

ICall_Errno
ICall_pwrSwitchXOSCHF(void);
uint32_t
ICall_pwrGetXOSCStartupTime(uint_fast32_t timeUntilWakeupInMs);

ICall_Errno
ICall_pwrRegisterNotify(ICall_PwrNotifyFn fn, ICall_PwrNotifyData *obj);
uint_fast8_t
ICall_pwrGetTransitionState(void);

ICall_Errno
ICall_createTask(void (*entryfn)(size_t arg), uint_fast8_t priority,
                 uint_fast16_t stacksize, size_t arg);

#ifdef ICALL_RTOS_SEMAPHORE_API

ICall_Semaphore
ICall_createSemaphore(uint_fast8_t mode, int initcount);
#endif

#ifdef ICALL_RTOS_SEMAPHORE_API

ICall_Errno
ICall_postSemaphore(ICall_Semaphore sem);
#endif /* ICALL_RTOS_SEMAPHORE_API */

#ifdef ICALL_RTOS_EVENTS_API

ICall_Event
ICall_createEvent(void);
ICall_Errno
ICall_postEvent(ICall_Event event, uint32_t events);
ICall_Errno
ICall_waitEvent(ICall_Event event, uint_fast32_t milliseconds);
#endif /* ICALL_RTOS_EVENTS_API */

#ifdef ICALL_RTOS_SEMAPHORE_API

ICall_Errno
ICall_waitSemaphore(ICall_Semaphore sem, uint_fast32_t milliseconds);
#endif /* ICALL_RTOS_SEMAPHORE_API */

ICall_Errno
ICall_waitMatch(uint_least32_t milliseconds,
                ICall_MsgMatchFn matchFn,
                ICall_ServiceEnum *src,
                ICall_EntityID *dest,
                void **msg);

ICall_EntityID
ICall_getEntityId(void);
uint_fast8_t
ICall_threadServes(ICall_ServiceEnum service);

uint_fast8_t
ICall_getLocalMsgEntityId(ICall_ServiceEnum service, ICall_EntityID entity);

#else /* ICALL_JT */

static ICall_Errno ICall_registerApp(ICall_EntityID *entity,
                                            ICall_SyncHandle *msgSyncHdl)
{
  ICall_RegisterAppArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_REGISTER_APP;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *entity = args.entity;
  *msgSyncHdl = args.msgSyncHdl;
  return errno;
}

static void *ICall_allocMsg(size_t size)
{
  ICall_AllocArgs args;
  ICall_Errno errno;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_MSG_ALLOC;
  args.size = size;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno != ICALL_ERRNO_SUCCESS)
  {
    return NULL;
  }
  return args.ptr;
}

static void ICall_freeMsg(void *msg)
{
  ICall_FreeArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_MSG_FREE;
  args.ptr = msg;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_sendServiceMsg(ICall_EntityID src,
                     ICall_ServiceEnum dest,
                     ICall_MSGFormat format, void *msg)
{
  ICall_SendArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_SEND_SERV_MSG;
  args.src = src;
  args.dest.servId = dest;
  args.format = format;
  args.msg = msg;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_fetchServiceMsg(ICall_ServiceEnum *src,
                      ICall_EntityID *dest,
                      void **msg)
{
  ICall_FetchMsgArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_FETCH_SERV_MSG;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *src = args.src.servId;
  *dest = args.dest;
  *msg = args.msg;
  return errno;
}

static ICall_Errno ICall_wait(uint_fast32_t milliseconds)
{
  ICall_WaitArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_WAIT;
  args.milliseconds = milliseconds;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno ICall_signal(ICall_SyncHandle msgSyncHdl)
{
  ICall_SignalArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_SIGNAL;
  args.syncHandle = msgSyncHdl;

  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_enrollService(ICall_ServiceEnum service,
                    ICall_ServiceFunc fn,
                    ICall_EntityID *entity,
                    ICall_SyncHandle *msgSyncHdl)
{
  ICall_EnrollServiceArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_ENROLL;
  args.service = service;
  args.fn = fn;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *entity = args.entity;
  *msgSyncHdl = args.msgSyncHdl;
  return errno;
}

static void *ICall_malloc(uint_least16_t size)
{
  ICall_AllocArgs args;
  ICall_Errno errno;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_MALLOC;
  args.size = size;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno != ICALL_ERRNO_SUCCESS)
  {
    return NULL;
  }
  return args.ptr;
}

static void ICall_free(void *msg)
{
  ICall_FreeArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_FREE;
  args.ptr = msg;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno ICall_send(ICall_EntityID src,
                                     ICall_EntityID dest,
                                     ICall_MSGFormat format,
                                     void *msg)
{
  ICall_SendArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_SEND_MSG;
  args.src = src;
  args.dest.entityId = dest;
  args.format = format;
  args.msg = msg;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno ICall_fetchMsg(ICall_EntityID *src,
                                         ICall_EntityID *dest,
                                         void **msg)
{
  ICall_FetchMsgArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_FETCH_MSG;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *src = args.src.entityId;
  *dest = args.dest;
  *msg = args.msg;
  return errno;
}

static ICall_Errno ICall_entityId2ServiceId(ICall_EntityID entityId,
                                                   ICall_ServiceEnum *servId)
{
  ICall_EntityId2ServiceIdArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_ENTITY2SERVICE;
  args.entityId = entityId;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *servId = args.servId;
  return errno;
}

static ICall_Errno
ICall_abort(void)
{
  HAL_ASSERT( HAL_ASSERT_CAUSE_ICALL_ABORT );

  ICall_FuncArgsHdr args;
  args.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.func = ICALL_PRIMITIVE_FUNC_ABORT;
  return ICall_dispatcher(&args);
}

static ICall_Errno
ICall_enableInt(int intnum)
{
  ICall_IntNumArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_ENABLE_INT;
  args.intnum = intnum;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_disableInt(int intnum)
{
  ICall_IntNumArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_DISABLE_INT;
  args.intnum = intnum;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_enableMInt(void)
{
  ICall_FuncArgsHdr args;
  args.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.func = ICALL_PRIMITIVE_FUNC_ENABLE_MINT;
  return ICall_dispatcher(&args);
}

static ICall_Errno
ICall_disableMInt(void)
{
  ICall_FuncArgsHdr args;
  args.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.func = ICALL_PRIMITIVE_FUNC_DISABLE_MINT;
  return ICall_dispatcher(&args);
}

static ICall_Errno
ICall_registerISR(int intnum, void (*isrfunc)(void))
{
  ICall_RegisterISRArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_REGISTER_ISR;
  args.intnum = intnum;
  args.isrfunc = isrfunc;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_registerISR_Ext(int intnum, void (*isrfunc)(void), int intPriority )
{
  ICall_RegisterISRArgs_Ext args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func    = ICALL_PRIMITIVE_FUNC_REGISTER_ISR_EXT;
  args.intnum      = intnum;
  args.isrfunc     = isrfunc;
  args.intPriority = intPriority;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static uint_fast32_t
ICall_getTicks(void)
{
  ICall_GetUint32Args args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_GET_TICKS;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  return args.value;
}

static uint_fast32_t
ICall_getTickPeriod(void)
{
  ICall_GetUint32Args args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_GET_TICK_PERIOD;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  return args.value;
}

static uint_fast32_t
ICall_getMaxMSecs(void)
{
  ICall_GetUint32Args args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_GET_MAX_MILLISECONDS;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  return args.value;
}

static ICall_Errno
ICall_setTimerMSecs(uint_fast32_t msecs,
                    ICall_TimerCback cback,
                    void *arg,
                    ICall_TimerID *id)
{
  ICall_SetTimerArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_SET_TIMER_MSECS;
  args.timeout = msecs;
  args.cback = cback;
  args.arg = arg;
  args.timerid = *id;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *id = args.timerid;

  return errno;
}

static ICall_Errno
ICall_setTimer(uint_fast32_t ticks,
               ICall_TimerCback cback,
               void *arg,
               ICall_TimerID *id)
{
  ICall_SetTimerArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_SET_TIMER;
  args.timeout = ticks;
  args.cback = cback;
  args.arg = arg;
  args.timerid = *id;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  *id = args.timerid;

  return errno;
}

static void
ICall_stopTimer(ICall_TimerID id)
{
  ICall_StopTimerArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_STOP_TIMER;
  args.timerid = id;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static bool
ICall_pwrUpdActivityCounter(bool incFlag)
{
  ICall_PwrUpdActivityCounterArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_UPD_ACTIVITY_COUNTER;
  args.incFlag = incFlag;
  (void)ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  return (args.pwrRequired);
}

static ICall_Errno
ICall_pwrConfigACAction(ICall_PwrBitmap_t bitmap)
{
  ICall_PwrBitmapArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_CONFIG_AC_ACTION;
  args.bitmap = bitmap;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_pwrRequire(ICall_PwrBitmap_t bitmap)
{
  ICall_PwrBitmapArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_REQUIRE;
  args.bitmap = bitmap;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static ICall_Errno
ICall_pwrDispense(ICall_PwrBitmap_t bitmap)
{
  ICall_PwrBitmapArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_DISPENSE;
  args.bitmap = bitmap;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static bool
ICall_pwrIsStableXOSCHF(void)
{
  ICall_GetBoolArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_IS_STABLE_XOSC_HF;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  return args.value;
}

static ICall_Errno
ICall_pwrSwitchXOSCHF(void)
{
  ICall_FuncArgsHdr args;
  args.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.func = ICALL_PRIMITIVE_FUNC_SWITCH_XOSC_HF;
  return ICall_dispatcher(&args);
}

static uint32_t
ICall_pwrGetXOSCStartupTime(uint_fast32_t timeUntilWakeupInMs)
{
  ICall_PwrGetXOSCStartupTimeArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_GET_XOSC_STARTUP_TIME;
  args.timeUntilWakeupInMs = timeUntilWakeupInMs;
  (void) ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  return args.value;
}

static ICall_Errno
ICall_pwrRegisterNotify(ICall_PwrNotifyFn fn, ICall_PwrNotifyData *obj)
{
  ICall_PwrRegisterNotifyArgs args;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_REGISTER_NOTIFY;
  args.fn = fn;
  args.obj = obj;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

static uint_fast8_t
ICall_pwrGetTransitionState(void)
{
  ICall_PwrGetTransitionStateArgs args;
  ICall_Errno errno;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_PWR_GET_TRANSITION_STATE;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);

  if (errno == ICALL_ERRNO_SUCCESS)
  {
    return args.state;
  }
  return 0;
}

static ICall_Errno
ICall_createTask(void (*entryfn)(size_t arg), uint_fast8_t priority,
                 uint_fast16_t stacksize, size_t arg)
{
  ICall_CreateTaskArgs args;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_CREATE_TASK;
  args.entryfn = entryfn;
  args.priority = priority;
  args.stacksize = stacksize;
  args.arg = arg;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}

#ifdef ICALL_RTOS_SEMAPHORE_API

static ICall_Semaphore
ICall_createSemaphore(uint_fast8_t mode, int initcount)
{
  ICall_CreateSemaphoreArgs args;
  ICall_Errno errno;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_CREATE_SEMAPHORE;
  args.mode = mode;
  args.initcount = initcount;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno == ICALL_ERRNO_SUCCESS)
  {
    return args.sem;
  }
  return NULL;
}
#endif

#ifdef ICALL_RTOS_SEMAPHORE_API

static ICall_Errno
ICall_postSemaphore(ICall_Semaphore sem)
{
  ICall_PostSemaphoreArgs args;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_POST_SEMAPHORE;
  args.sem = sem;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}
#endif /* ICALL_RTOS_SEMAPHORE_API */

#ifdef ICALL_RTOS_EVENTS_API

static ICall_Event
ICall_createEvent(void)
{
  ICall_CreateEventArgs args;
  ICall_Errno errno;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_CREATE_EVENT;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno == ICALL_ERRNO_SUCCESS)
  {
    return args.event;
  }
  return NULL;
}

static ICall_Errno
ICall_postEvent(ICall_Event event, uint32_t events)
{
  ICall_PostEventArgs args;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_POST_EVENT;
  args.event = event;
  args.events = events;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}
static ICall_Errno
ICall_waitEvent(ICall_Event event, uint_fast32_t milliseconds)
{
  ICall_WaitEventArgs args;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_WAIT_EVENT;
  args.event = event;
  args.milliseconds = milliseconds;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}
#endif /* ICALL_RTOS_EVENTS_API */

#ifdef ICALL_RTOS_SEMAPHORE_API

static ICall_Errno
ICall_waitSemaphore(ICall_Semaphore sem, uint_fast32_t milliseconds)
{
  ICall_WaitSemaphoreArgs args;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_WAIT_SEMAPHORE;
  args.sem = sem;
  args.milliseconds = milliseconds;
  return ICall_dispatcher((ICall_FuncArgsHdr *)&args);
}
#endif /* ICALL_RTOS_SEMAPHORE_API */

static ICall_Errno
ICall_waitMatch(uint_least32_t milliseconds,
                ICall_MsgMatchFn matchFn,
                ICall_ServiceEnum *src,
                ICall_EntityID *dest,
                void **msg)
{
  ICall_WaitMatchArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_WAIT_MATCH;
  args.milliseconds = milliseconds;
  args.matchFn = matchFn;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (src != NULL)
  {
    *src = args.servId;
  }
  if (dest != NULL)
  {
    *dest = args.dest;
  }
  *msg = args.msg;
  return errno;
}

static ICall_EntityID
ICall_getEntityId(void)
{
  ICall_GetEntityIdArgs args;
  ICall_Errno errno;
  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_GET_ENTITY_ID;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno == ICALL_ERRNO_SUCCESS)
  {
    return args.entity;
  }
  return ICALL_INVALID_ENTITY_ID;
}

static uint_fast8_t
ICall_threadServes(ICall_ServiceEnum service)
{
  ICall_ThreadServesArgs args;
  ICall_Errno errno;

  args.hdr.service = ICALL_SERVICE_CLASS_PRIMITIVE;
  args.hdr.func = ICALL_PRIMITIVE_FUNC_THREAD_SERVES;
  args.servId = service;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno == ICALL_ERRNO_SUCCESS)
  {
    return args.result;
  }
  return 0;
}

static uint_fast8_t
ICall_getLocalMsgEntityId(ICall_ServiceEnum service, ICall_EntityID entity)
{
  ICall_GetLocalMsgEntityIdArgs args;
  ICall_Errno errno;
  args.hdr.service = service;
  args.hdr.func = ICALL_MSG_FUNC_GET_LOCAL_MSG_ENTITY_ID;
  args.entity = entity;
  errno = ICall_dispatcher((ICall_FuncArgsHdr *)&args);
  if (errno == ICALL_ERRNO_SUCCESS)
  {
    return args.localId;
  }
  return 0xFF;
}


#endif /* ICALL_JT */

#ifdef __cplusplus
}
#endif

#endif /* ICALL_H */