osal.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  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.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 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 ti_OSAL__include
#define ti_OSAL__include

#ifdef __cplusplus
extern "C" {
#endif

#include <ti/osal/TaskP.h>
#include <ti/osal/HwiP.h>
#include <ti/osal/MuxIntcP.h>
#include <ti/osal/SemaphoreP.h>
#include <ti/osal/CacheP.h>
#include <ti/osal/TimerP.h>
#include <ti/osal/RegisterIntr.h>
#include <ti/osal/QueueP.h>
#include <ti/osal/CycleprofilerP.h>
#include <ti/osal/MailboxP.h>
#include <ti/osal/MutexP.h>
#include <ti/osal/ClockP.h>
#include <ti/osal/DebugP.h>
#include <ti/osal/HeapP.h>
#include <ti/osal/MemoryP.h>
#include <ti/osal/EventP.h>
#ifdef _TMS320C6X
#include <ti/osal/EventCombinerP.h>
#endif

/*********************************************************************
 * @def osal_OK
 * OSAL operation successful
 *********************************************************************/
#define osal_OK        (0)

/*********************************************************************
 * @def osal_FAILURE
 * OSAL operation failed
 *********************************************************************/
#define osal_FAILURE  (-(int32_t)(1))

/*********************************************************************
 * @def osal_UNSUPPORTED
 * OSAL operation is not supported
 *********************************************************************/
#define osal_UNSUPPORTED       (-(int32_t)(2))

/*********************************************************************
 * @def osal_NOMEM
 * OSAL operation is not successful due to internal osal static memory
 * is full. Application would need to create additional memory blocks
 * during startup by calling @ref Osal_setHwAttrs API to set the additional
 * memory blocks for semaphoreP and hwiP
 *********************************************************************/
#define osal_NOMEM             (-(int32_t)(3))
/* @} */

/*********************************************************************
 * @def osal_WAIT_FOREVER
 * OSAL timeout wait forever
 *********************************************************************/
#define osal_WAIT_FOREVER (~((uint32_t)0U))

/*********************************************************************
 * @def osal_NO_WAIT
 * OSAL timeout no wait
 *********************************************************************/
#define osal_NO_WAIT       ((uint32_t)0U)

/*********************************************************************
 * @def OSAL_NONOS_SEMAPHOREP_SIZE_BYTES
 * Semaphorep handle size for non-os use case
 * Application can use this size to provide a secondary extended
 * memory block for semaphore creation when all the memory  (internal to osal)
 * are utilized
 *
 *********************************************************************/
#define  OSAL_NONOS_SEMAPHOREP_SIZE_BYTES ((uint32_t) 48U)

/*********************************************************************
 * @def OSAL_NONOS_HWI_SIZE_BYTES
 * HwiP handle size for non-os use case
 * Application can use this size to provide a secondary extended
 * memory block for hwip creation when all the memory  (internal to osal)
 * are utilized
 *********************************************************************/
#define  OSAL_NONOS_HWIP_SIZE_BYTES ((uint32_t) 48U)

/*********************************************************************
 * @def OSAL_FREERTOS_HWIP_C7X_SIZE_BYTES
 * HwiP handle size for freertos-os c7x use case
 * Application can use this size to provide a secondary extended
 * memory block for hwip creation when all the memory  (internal to osal)
 * are utilized
 *********************************************************************/
#define  OSAL_FREERTOS_HWIP_C7X_SIZE_BYTES ((uint32_t) 56U)

/*********************************************************************
 * @def OSAL_SAFERTOS_HWIP_C7X_SIZE_BYTES
 * HwiP handle size for safertos-os c7x use case
 * Application can use this size to provide a secondary extended
 * memory block for hwip creation when all the memory  (internal to osal)
 * are utilized
 *********************************************************************/
#define  OSAL_SAFERTOS_HWIP_C7X_SIZE_BYTES ((uint32_t) 56U)

/*********************************************************************
 * @def OSAL_FREERTOS_SEMAPHOREP_SIZE_BYTES
 * Semaphorep handle size for non-os use case
 * Application can use this size to provide a secondary extended
 * memory block for semaphore creation when all the memory  (internal to osal)
 * are utilized
 *
 *********************************************************************/
#if defined (BUILD_C7X)
#define  OSAL_FREERTOS_SEMAPHOREP_SIZE_BYTES ((uint32_t) 176U)
#else
#define  OSAL_FREERTOS_SEMAPHOREP_SIZE_BYTES ((uint32_t) 96U)
#endif

/*********************************************************************
 * @def OSAL_FREERTOS_TASKP_SIZE_BYTES
 * TaskP handle size for non-os use case
 * Application can use this size to provide a secondary extended
 * memory block for semaphore creation when all the memory  (internal to osal)
 * are utilized
 *
 *********************************************************************/
#define  OSAL_FREERTOS_TASKP_SIZE_BYTES ((uint32_t) 128U)

/*********************************************************************
 * @def OSAL_SAFERTOS_SEMAPHOREP_SIZE_BYTES
 * Semaphorep handle size for non-os use case
 * Application can use this size to provide a secondary extended
 * memory block for semaphore creation when all the memory  (internal to osal)
 * are utilized
 *
 *********************************************************************/
#if defined (BUILD_C7X)
#define  OSAL_SAFERTOS_SEMAPHOREP_SIZE_BYTES ((uint32_t) 304U)
#else
#define  OSAL_SAFERTOS_SEMAPHOREP_SIZE_BYTES ((uint32_t) 248U)
#endif

/*********************************************************************
 * @def OSAL_SAFERTOS_TASKP_SIZE_BYTES
 * TaskP handle size for non-os use case
 * Application can use this size to provide a secondary extended
 * memory block for semaphore creation when all the memory  (internal to osal)
 * are utilized
 *
 *********************************************************************/
#if defined (BUILD_C7X)
#define  OSAL_SAFERTOS_TASKP_SIZE_BYTES ((uint32_t) 320U)
#else
#define  OSAL_SAFERTOS_TASKP_SIZE_BYTES ((uint32_t) 248U)
#endif

typedef struct Osal_StaticMemoryStatus
{
    uint32_t peakSemObjs;       
    uint32_t numMaxSemObjs;     
    uint32_t numFreeSemObjs;    
    uint32_t peakTimerObjs;     
    uint32_t numMaxTimerObjs;   
    uint32_t numFreeTimerObjs;  
    uint32_t peakHwiObjs;       
    uint32_t numMaxHwiObjs;     
    uint32_t numFreeHwiObjs;    
} Osal_StaticMemStatus;

typedef enum Osal_ThreadType_e {
    Osal_ThreadType_Hwi,   
    Osal_ThreadType_Swi,   
    Osal_ThreadType_Task,  
    Osal_ThreadType_Main,  
    Osal_ThreadType_Abort, 
} Osal_ThreadType;

/* Internal function for assert */
extern void Osal_DebugP_assert(int32_t expression, const char *file, int32_t line);
/* in real code use TI's version of OSAL_Assert (which is also fatal for OSAL_Assert(1)*/
#define OSAL_Assert(expression) (Osal_DebugP_assert((int32_t)((expression)?1:0),\
                                                  __FILE__, __LINE__))

extern Osal_ThreadType Osal_getThreadType(void);

extern int32_t Osal_delay(uint32_t nTicks);

typedef enum {
  OSAL_HWACCESS_UNRESTRICTED, 
  OSAL_HWACCESS_RESTRICTED    
} Osal_HwAccessType;

typedef struct Osal_memRange_s {
  uintptr_t    base;          
  uint32_t     size;          
} Osal_memRange;

typedef struct Osal_HwAttrs_s
{
    uint32_t  cpuFreqKHz;
    uint32_t  extClkKHz;
#if defined(gnu_targets_arm_A15F)

    uint32_t a15TargetProcMask;
#endif
#ifdef _TMS320C6X

    uint32_t ECM_intNum[4];
#endif

    Osal_HwAccessType hwAccessType;
   uintptr_t     osalDelayTimerBaseAddr;
   Osal_memRange  extSemaphorePBlock;
   Osal_memRange  extHwiPBlock;
} Osal_HwAttrs;

#define  OSAL_HWATTR_SET_EXT_CLK    (0x00000001U)

#define  OSAL_HWATTR_SET_ECM_INT      (0x00000002U)

#define OSAL_HWATTR_SET_HWACCESS_TYPE (0x00000004U)

#define OSAL_HWATTR_SET_OSALDELAY_TIMER_BASE (0x00000008U)

#define OSAL_HWATTR_SET_SEMP_EXT_BASE   (0x00000010U)

#define OSAL_HWATTR_SET_HWIP_EXT_BASE   (0x00000020U)

#define OSAL_HWATTR_SET_CPU_FREQ        (0x00000040U)

#define OSAL_HWATTR_SET_TARG_PROC_LIST  (0x00000080)
/* @} */


extern int32_t Osal_setHwAttrs(uint32_t ctrlBitMap, const Osal_HwAttrs *hwAttrs);

extern int32_t Osal_getHwAttrs(Osal_HwAttrs *hwAttrs);

extern int32_t Osal_getStaticMemStatus(Osal_StaticMemStatus *pMemStat);

extern uint32_t Osal_getCoreId(void);

int32_t Osal_isInPrivilegeMode(void);

extern Osal_HwAttrs  gOsal_HwAttrs;

#define OSAL_COMPILE_TIME_SIZE_CHECK(x,y)                              \
   do {                                                                 \
       struct {                                                 \
         uint8_t NegativeSizeIfPostulateFalse[(y) + 1U - (x)];         \
       } PostulateCheck;                                              \
   }                                                                   \
   while ((bool)false)

extern void OS_init(void);

extern void OS_start(void);

extern void OS_stop(void);

#ifdef __cplusplus
}
#endif

#endif /* ti_OSAL__include */
/* @} */