nvos_tegra_nonsafety.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited
 */
 
#ifndef INCLUDED_NVOS_TEGRA_NONSAFETY_H
#define INCLUDED_NVOS_TEGRA_NONSAFETY_H
 
#include <stdarg.h>
#include "nvcommon.h"
#include "nverror.h"
/* common logging APIs */
#include "nvos_s3_tegra_log.h"
#if defined(__cplusplus)
extern "C"
{
#endif
 
#if NVOS_IS_WINDOWS
typedef NvU64 NvOsPhysAddr;
#else
typedef NvU32 NvOsPhysAddr;
#endif
 
#define NVOS_KEY_MAX 128
 
#define NVOS_PATH_MAX 256
 
#define NVOS_HAS_MTIME 1
 
#define NVOS_HAS_MKDIR 1
 
#define NVOS_HAS_FTRUNCATE 1
 
#define NVOS_HAS_CONDITION 1
 
 
typedef struct NvOsFileRec *NvOsFileHandle;
 
NvError
NvOsFprintf(NvOsFileHandle stream, const char *format, ...);
 
// Doxygen requires escaping backslash characters (\) with another \ so in
// @return, ignore the first backslash if you are reading this in the header.
NvS32
NvOsSnprintf(char *str, size_t size, const char *format, ...);
 
NvError
NvOsVfprintf(NvOsFileHandle stream, const char *format, va_list ap);
 
NvS32
NvOsVsnprintf(char *str, size_t size, const char *format, va_list ap);
 
void
NvOsDebugPrintf(const char *format, ...);
 
void
NvOsLogPrintf(int prio, const char *tag, const char *format, ...);
 
void
NvOsDebugVprintf( const char *format, va_list ap );
 
NvS32
NvOsDebugNprintf( const char *format, ...);
 
void
NvOsDebugString(const char *str);
 
enum {
    NVOS_VERB_LVL_0 = 0,
    NVOS_VERB_LVL_1 = 1,
    NVOS_VERB_LVL_2 = 2,
    NVOS_VERB_LVL_3 = 3,
    NVOS_VERB_LVL_4 = 4,
};
 
int
NvOsSetVerboseLevel(NvS32 VerbLevel);
 
int
NvOsGetVerboseLevel(NvS32 *VerbLevel);
 
void
NvOsVerbosePrintf(NvS32 VerbLevel, const char *Fmt, ...);
 
NvError
NvOsShowError(NvError err, const char *file, int line);
 
#define NV_SHOW_ERRORS  NV_DEBUG
#if     NV_SHOW_ERRORS
#define NV_SHOW_ERROR(err)  NvOsShowError(err,__FILE__,__LINE__)
#else
#define NV_SHOW_ERROR(err)  (err)
#endif
 
// Doxygen requires escaping # with a backslash, so in the examples below
// ignore the backslash before the # if reading this in the header file.
#if !defined(NV_ENABLE_DEBUG_PRINTS)
#define NV_ENABLE_DEBUG_PRINTS 0
#endif
#if NV_ENABLE_DEBUG_PRINTS
#define NV_DEBUG_PRINTF(x) do { NvOsDebugPrintf x; } while (NV_FALSE)
#else
#define NV_DEBUG_PRINTF(x) do {} while (NV_FALSE)
#endif
 
 
typedef enum
{
    NvOsOs_Unknown = 0x0UL,
    NvOsOs_Windows = 0x1UL,
    NvOsOs_Linux = 0x2UL,
    NvOsOs_Qnx = 0x4UL,
    NvOsOs_Integrity = 0x5UL,
    NvOsOs_Force32 = 0x7fffffffUL,
} NvOsOs;
 
typedef enum
{
    NvOsSku_Unknown = 0x0UL,
    NvOsSku_Android = 0x1UL,
    NvOsSku_Force32 = 0x7fffffffUL,
} NvOsSku;
 
typedef struct NvOsOsInfoRec
{
    NvOsOs  OsType;
    NvOsSku Sku;
} NvOsOsInfo;
 
NvError
NvOsGetOsInformation(NvOsOsInfo *pOsInfo);
 
 
void
NvOsStrcpy(char *dest, const char *src);
 
void
NvOsStrncpy(char *dest, const char *src, size_t size);
 
typedef enum
{
    NvOsCodePage_Unknown = 0x0UL,
    NvOsCodePage_Utf8 = 0x1UL,
    NvOsCodePage_Utf16 = 0x2UL,
    NvOsCodePage_Windows1252 = 0x3UL,
    NvOsCodePage_Force32 = 0x7fffffffUL,
} NvOsCodePage;
 
size_t
NvOsStrlen(const char *s);
 
size_t
NvOsStrnlen(const char *s, size_t size);
 
 
void NvOsMemcpy(void *dest, const void *src, size_t size);
 
int
NvOsMemcmp(const void *s1, const void *s2, size_t size);
 
void
NvOsMemset(void *s, NvU8 c, size_t size);
 
 
typedef enum
{
    NvOsSeek_Set = 0,
    NvOsSeek_Cur = 1,
    NvOsSeek_End = 2,
 
    NvOsSeek_Force32 = 0x7FFFFFFF
} NvOsSeekEnum;
 
typedef enum
{
    NvOsFileType_Unknown = 0,
    NvOsFileType_File = 1,
    NvOsFileType_Directory = 2,
    NvOsFileType_Fifo = 3,
    NvOsFileType_CharacterDevice = 4,
    NvOsFileType_BlockDevice = 5,
 
    NvOsFileType_Force32 = 0x7FFFFFFF
} NvOsFileType;
 
#if NVOS_IS_LINUX
typedef struct NvOsFileRec
{
    int fd;
    NvOsFileType type;
} NvOsFile;
#endif
 
typedef struct NvOsStatTypeRec
{
    NvU64 size;
    NvOsFileType type;
    NvU64 mtime;
} NvOsStatType;
 
#define NVOS_OPEN_READ    0x1
 
#define NVOS_OPEN_WRITE   0x2
 
#define NVOS_OPEN_CREATE  0x4
 
#define NVOS_OPEN_APPEND  0x8
 
NvError
NvOsFopen(const char *path, NvU32 flags, NvOsFileHandle *file);
 
NvError NvOsFcloseEx(NvOsFileHandle stream);
 
void NvOsFclose(NvOsFileHandle stream);
 
NvError
NvOsFwrite(NvOsFileHandle stream, const void *ptr, size_t size);
 
NvError
NvOsFread(NvOsFileHandle stream, void *ptr, size_t size, size_t *bytes);
 
NvError
NvOsFgetc(NvOsFileHandle stream, NvU8 *c);
 
NvError
NvOsFseek(NvOsFileHandle file, NvS64 offset, NvOsSeekEnum whence);
 
NvError
NvOsFtell(NvOsFileHandle file, NvU64 *position);
 
NvError
NvOsStat(const char *filename, NvOsStatType *stat);
 
NvError
NvOsFstat(NvOsFileHandle file, NvOsStatType *stat);
 
NvError
NvOsFflush(NvOsFileHandle stream);
 
NvError
NvOsFsync(NvOsFileHandle stream);
 
NvError
NvOsFremove(const char *filename);
 
NvError
NvOsFtruncate(NvOsFileHandle stream, NvU64 length);
 
 
typedef struct NvOsDirRec *NvOsDirHandle;
 
NvError
NvOsOpendir(const char *path, NvOsDirHandle *dir);
 
NvError
NvOsReaddir(NvOsDirHandle dir, char *name, size_t size);
 
void NvOsClosedir(NvOsDirHandle dir);
 
NvError NvOsMkdir(char *dirname);
 
NvError
NvOsGetConfigU32(const char *name, NvU32 *value);
 
NvError
NvOsGetConfigString(const char *name, char *value, NvU32 size);
 
NvError
NvOsGetSysConfigString(const char *name, char *value, NvU32 size);
 
 
void *NvOsAlloc(size_t size);
 
void *NvOsAllocAlign(size_t align, size_t size);
 
void *NvOsRealloc(void *ptr, size_t size);
 
void NvOsFree(void *ptr);
 
typedef struct NvOsSharedMemRec *NvOsSharedMemHandle;
 
NvError
NvOsSharedMemAlloc(const char *key, size_t size,
    NvOsSharedMemHandle *descriptor);
 
NvError
NvOsSharedMemHandleFromFd(int fd, NvOsSharedMemHandle *descriptor);
 
NvError
NvOsSharedMemGetFd(NvOsSharedMemHandle descriptor, int *fd);
 
NvError
NvOsSharedMemMap(NvOsSharedMemHandle descriptor, size_t offset,
    size_t size, void **ptr);
 
void NvOsSharedMemUnmap(void *ptr, size_t size);
 
void NvOsSharedMemFree(NvOsSharedMemHandle descriptor);
 
typedef enum
{
#ifdef INCLUDED_NVOS_TEGRA_NONSAFETY_H
    NvOsMemAttribute_Reserved           = 0,
#else
    NvOsMemAttribute_Uncached           = 0,
#endif
    NvOsMemAttribute_WriteBack          = 1,
    NvOsMemAttribute_WriteCombined      = 2,
    NvOsMemAttribute_InnerWriteBack     = 3,
    NvOsMemAttribute_Secured            = 4,
    NvOsMemAttribute_DeviceMemory       = 5,
    NvOsMemAttribute_SO_DeviceMemory    = 6,
    NvOsMemAttribute_End                = 7,
 
    NvOsMemAttribute_Force32 = 0x7FFFFFFF
} NvOsMemAttribute;
 
#ifdef INCLUDED_NVOS_TEGRA_NONSAFETY_H
#if defined(__LP64__) && !defined(__DEPRECATE_NVOS_MEM_ATTR_UNCACHED__) && (!NVOS_IS_QNX)
    #if defined(__GNUC__) && (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 6)
        #pragma GCC diagnostic warning "-Wdeprecated-declarations"
        #define __DEPRECATE_NVOS_MEM_ATTR_UNCACHED__ __attribute__ ((deprecated(\
                    "Use NvOsMemAttribute_WriteCombined instead!!\n"\
                    "Use proper barrier protection when moved to writecombined\n"\
                    "VPR is treated as strongly ordered in kernel even if you use\n"\
                    "writecombined. So, no need for barrier protection for VPR allocations")))
        __DEPRECATE_NVOS_MEM_ATTR_UNCACHED__ static const NvOsMemAttribute NvOsMemAttribute_Uncached = NvOsMemAttribute_Reserved;
    #else
        static const NvOsMemAttribute NvOsMemAttribute_Uncached = NvOsMemAttribute_Reserved;
    #endif
#else
        static const NvOsMemAttribute NvOsMemAttribute_Uncached = NvOsMemAttribute_Reserved;
#endif
#endif
 
#define NVOS_MEM_NONE     0x0U
 
#define NVOS_MEM_READ     0x1U
 
#define NVOS_MEM_WRITE    0x2U
 
#define NVOS_MEM_EXECUTE  0x4U
 
#define NVOS_MEM_GLOBAL_ADDR 0x8U
 
#define NVOS_MEM_READ_WRITE (NVOS_MEM_READ | NVOS_MEM_WRITE)
 
#define NVOS_MEM_MMAP_FIXED 0x40U
 
#define NVOS_MEM_MMAP_LAZY 0x80U
 
#define NVOS_MEM_MMAP_POPULATE 0x100U
 
NvError
NvOsPhysicalMemMap(NvOsPhysAddr phys, size_t size,
    NvOsMemAttribute attrib, NvU32 flags, void **ptr);
 
void NvOsPhysicalMemUnmap(void *ptr, size_t size);
 
 
typedef enum
{
    NvOsPageFlags_Contiguous    = 0,
    NvOsPageFlags_NonContiguous = 1,
 
    NvOsMemFlags_Forceword = 0x7ffffff,
} NvOsPageFlags;
 
typedef struct NvOsPageAllocRec *NvOsPageAllocHandle;
 
NvError
NvOsPageAlloc(size_t size, NvOsMemAttribute attrib,
    NvOsPageFlags flags, NvU32 protect, NvOsPageAllocHandle *descriptor);
 
void
NvOsPageFree(NvOsPageAllocHandle descriptor);
 
NvError
NvOsPageMap(NvOsPageAllocHandle descriptor, size_t offset, size_t size,
    void **ptr);
 
void
NvOsPageUnmap(NvOsPageAllocHandle descriptor, void *ptr, size_t size);
 
NvOsPhysAddr
NvOsPageAddress(NvOsPageAllocHandle descriptor, size_t offset);
 
 
typedef struct NvOsLibraryRec *NvOsLibraryHandle;
 
NvError
NvOsLibraryLoad(const char *name, NvOsLibraryHandle *library);
 
void*
NvOsLibraryGetSymbol(NvOsLibraryHandle library, const char *symbol);
 
void NvOsLibraryUnload(NvOsLibraryHandle library);
 
NvError NvOsLibraryUnloadEx(NvOsLibraryHandle library);
 
 
typedef struct NvOsMutexRec *NvOsMutexHandle;
typedef struct NvOsIntrMutexRec *NvOsIntrMutexHandle;
typedef struct NvOsConditionRec *NvOsConditionHandle;
typedef struct NvOsSemaphoreRec *NvOsSemaphoreHandle;
typedef struct NvOsThreadRec *NvOsThreadHandle;
 
void
NvOsSleepMS(NvU32 msec);
 
void NvOsWaitUS(NvU32 usec);
 
NvError NvOsSleepUS(NvU32 usec);
NvError NvOsSleepNS(NvU32 nsec);
 
NvError NvOsBusyWaitUS(NvU32 usec);
NvError NvOsBusyWaitNS(NvU32 nsec);
 
NvError NvOsMutexCreate(NvOsMutexHandle *mutex);
 
void NvOsMutexLock(NvOsMutexHandle mutex);
 
NvError NvOsMutexLockEx(NvOsMutexHandle mutex);
 
void NvOsMutexUnlock(NvOsMutexHandle mutex);
 
NvError NvOsMutexUnlockEx(NvOsMutexHandle mutex);
 
void NvOsMutexDestroy(NvOsMutexHandle mutex);
 
NvError NvOsMutexDestroyEx(NvOsMutexHandle mutex);
 
NvError NvOsIntrMutexCreate(NvOsIntrMutexHandle *mutex);
 
void NvOsIntrMutexLock(NvOsIntrMutexHandle mutex);
 
void NvOsIntrMutexUnlock(NvOsIntrMutexHandle mutex);
 
void NvOsIntrMutexDestroy(NvOsIntrMutexHandle mutex);
 
NvError NvOsConditionCreate(NvOsConditionHandle *cond);
 
NvError NvOsConditionDestroy(NvOsConditionHandle cond);
 
NvError NvOsConditionBroadcast(NvOsConditionHandle cond);
 
NvError NvOsConditionSignal(NvOsConditionHandle cond);
 
NvError NvOsConditionWait(NvOsConditionHandle cond, NvOsMutexHandle mutex);
 
NvError NvOsConditionWaitTimeout(NvOsConditionHandle cond, NvOsMutexHandle mutex, NvU32 microsecs);
 
NvError
NvOsSemaphoreCreate(NvOsSemaphoreHandle *semaphore, NvU32 value);
 
NvError
NvOsSemaphoreClone( NvOsSemaphoreHandle orig,  NvOsSemaphoreHandle *semaphore);
 
void NvOsSemaphoreWait(NvOsSemaphoreHandle semaphore);
 
NvError NvOsSemaphoreWaitEx(NvOsSemaphoreHandle semaphore);
 
NvError
NvOsSemaphoreWaitTimeout(NvOsSemaphoreHandle semaphore, NvU32 msec);
 
void NvOsSemaphoreSignal(NvOsSemaphoreHandle semaphore);
 
NvError NvOsSemaphoreSignalEx(NvOsSemaphoreHandle semaphore);
 
void NvOsSemaphoreDestroy(NvOsSemaphoreHandle semaphore);
 
NvError NvOsSemaphoreDestroyEx(NvOsSemaphoreHandle semaphore);
 
typedef enum
{
    NvOsThreadPriorityType_Normal = 1,
    NvOsThreadPriorityType_NearInterrupt = 2,
    // NvOsThreadPriorityType_Native is ONLY valid when used with NvOsThreadCreateWithAttr
    // Using this value means that the priority of thread will be set to "nativePriority"
    NvOsThreadPriorityType_Native = 3,
 
    NvOsThreadPriorityType_Last = 4,
    NvOsThreadPriorityType_Force32 = 0x7FFFFFFF
} NvOsThreadPriorityType;
 
typedef void (*NvOsThreadFunction)(void *args);
 
NvError
NvOsThreadCreate( NvOsThreadFunction function, void *args,
    NvOsThreadHandle *thread);
 
NvError
NvOsInterruptPriorityThreadCreate( NvOsThreadFunction function, void *args,
    NvOsThreadHandle *thread);
 
const char*
NvOsThreadGetName( NvOsThreadHandle thread);
 
NvError
NvOsThreadSetName( NvOsThreadHandle thread, const char *name);
 
void NvOsThreadJoin(NvOsThreadHandle thread);
 
NvError NvOsThreadJoinEx(NvOsThreadHandle thread);
 
void NvOsThreadYield(void);
 
NvU64 NvOsGetCurrentThreadId(void);
 
void *NvOsAtomicCompareExchangePtr(void **pTarget, void *OldValue,
                                   void *NewValue);
 
NvS32 NvOsAtomicCompareExchange32(NvS32 *pTarget, NvS32 OldValue, NvS32
    NewValue);
 
NvS32 NvOsAtomicExchange32(NvS32 *pTarget, NvS32 Value);
 
NvS32 NvOsAtomicExchangeAdd32(NvS32 *pTarget, NvS32 Value);
 
#if NVOS_IS_INTEGRITY
typedef NvU64 NvOsTlsKeyHandle;
#else
typedef NvU32 NvOsTlsKeyHandle;
#endif
 
#define NVOS_INVALID_TLS_INDEX 0xFFFFFFFF
#define NVOS_TLS_CNT            4
 
NvOsTlsKeyHandle NvOsTlsAlloc(void);
 
NvOsTlsKeyHandle NvOsTlsAllocWithDestructor(void (*destructor)(void*));
 
void NvOsTlsFree(NvOsTlsKeyHandle TlsIndex);
 
void *NvOsTlsGet(NvOsTlsKeyHandle TlsIndex);
 
void NvOsTlsSet(NvOsTlsKeyHandle TlsIndex, void *Value);
 
NvError NvOsTlsAddTerminator(void (*func)(void *), void *context);
 
NvBool NvOsTlsRemoveTerminator(void (*func)(void *), void *context);
 
 
typedef struct NvOsSystemTimeRec
{
    NvU32   Seconds;
    NvU32   Milliseconds;
} NvOsSystemTime;
 
NvError
NvOsGetSystemTime(NvOsSystemTime *hNvOsSystemtime);
 
NvU32
NvOsGetTimeMS(void);
 
NvU64
NvOsGetTimeUS(void);
 
NvU64
NvOsGetTimeNS(void);
 
 
void
NvOsDataCacheWriteback(void);
 
void
NvOsDataCacheWritebackInvalidate(void);
 
void
NvOsDataCacheWritebackRange(void *start, NvU32 length);
 
void
NvOsDataCacheWritebackInvalidateRange(void *start, NvU32 length);
 
void
NvOsInstrCacheInvalidate(void);
 
void
NvOsInstrCacheInvalidateRange(void *start, NvU32 length);
 
NvBool
NvOsIsMemoryOfGivenType(NvOsMemAttribute Attrib, NvU32 Addr);
 
void
NvOsFlushWriteCombineBuffer(void);
 
typedef void (*NvOsInterruptHandler)(void *args);
 
typedef struct NvOsInterruptRec *NvOsInterruptHandle;
 
NvError
NvOsInterruptRegister(NvU32 IrqListSize,
    const NvU32 *pIrqList,
    const NvOsInterruptHandler *pIrqHandlerList,
    void *context,
    NvOsInterruptHandle *handle,
    NvBool InterruptEnable);
 
void
NvOsInterruptUnregister(NvOsInterruptHandle handle);
 
NvError
NvOsInterruptEnable(NvOsInterruptHandle handle);
 
void
NvOsInterruptDone(NvOsInterruptHandle handle);
 
void NvOsInterruptMask(NvOsInterruptHandle handle, NvBool mask);
 
struct NvOsAllocatorRec;
typedef void* (*NvOsAllocFunc)(struct NvOsAllocatorRec *, size_t size);
typedef void* (*NvOsAllocAlignFunc)(struct NvOsAllocatorRec *, size_t align, size_t size);
typedef void* (*NvOsReallocFunc)(struct NvOsAllocatorRec *, void *ptr, size_t size);
typedef void  (*NvOsFreeFunc)(struct NvOsAllocatorRec *, void *ptr);
 
typedef struct NvOsAllocatorRec {
    NvOsAllocFunc Alloc;
    NvOsAllocAlignFunc AllocAlign;
    NvOsReallocFunc Realloc;
    NvOsFreeFunc Free;
} NvOsAllocator;
 
struct NvOsAllocatorRec *NvOsGetCurrentAllocator(void);
 
 
/*
 * Debug support.
 */
#if NV_DEBUG
 
// The first parameter of the debug allocator functions is a function pointer to the
// actual allocator function.
void *NvOsAllocLeak(NvOsAllocator *, size_t size, const char *f, int l);
void *NvOsAllocAlignLeak(NvOsAllocator *, size_t align, size_t size, const char *f, int l);
void *NvOsReallocLeak(NvOsAllocator *, void *ptr, size_t size, const char *f, int l);
void NvOsFreeLeak(NvOsAllocator *, void *ptr, const char *f, int l);
 
#define NvOsAlloc(size)             NvOsAllocLeak(NvOsGetCurrentAllocator(), size, __FILE__, __LINE__)
#define NvOsAllocAlign(align, size) NvOsAllocAlignLeak(NvOsGetCurrentAllocator(), align, size, __FILE__, __LINE__)
#define NvOsRealloc(ptr, size)      NvOsReallocLeak(NvOsGetCurrentAllocator(), ptr, size, __FILE__, __LINE__)
#define NvOsFree(ptr)               NvOsFreeLeak(NvOsGetCurrentAllocator(), ptr, __FILE__, __LINE__)
 
#endif /* NVOS_DEBUG */
 
 
#if NV_DEBUG
 
void NvOsSetResourceAllocFileLine(void* userptr, const char* file, int line);
 
static NV_INLINE NvError
NvOsSharedMemAllocTraced(const char *key, size_t size,
    NvOsSharedMemHandle *descriptor, const char *f, int l )
{
    NvError status;
    status = (NvOsSharedMemAlloc)(key, size, descriptor);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*descriptor, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsSharedMemHandleFromFdTraced(int fd,
    NvOsSharedMemHandle *descriptor, const char *f, int l )
{
    NvError status;
    status = (NvOsSharedMemHandleFromFd)(fd, descriptor);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*descriptor, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsPhysicalMemMapTraced(NvOsPhysAddr phys, size_t size,
    NvOsMemAttribute attrib, NvU32 flags, void **ptr, const char *f, int l )
{
    NvError status;
    status = (NvOsPhysicalMemMap)(phys, size, attrib, flags, ptr);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*ptr, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsPageAllocTraced(size_t size, NvOsMemAttribute attrib,
    NvOsPageFlags flags, NvU32 protect, NvOsPageAllocHandle *descriptor,
    const char *f, int l )
{
    NvError status;
    status = (NvOsPageAlloc)(size, attrib, flags, protect, descriptor);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*descriptor, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsMutexCreateTraced(NvOsMutexHandle *mutex, const char *f, int l )
{
    NvError status;
    status = (NvOsMutexCreate)(mutex);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*mutex, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsIntrMutexCreateTraced(NvOsIntrMutexHandle *mutex, const char *f, int l )
{
    NvError status;
    status = (NvOsIntrMutexCreate)(mutex);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*mutex, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsSemaphoreCreateTraced( NvOsSemaphoreHandle *semaphore,  NvU32 value,
    const char *f, int l )
{
    NvError status;
    status = (NvOsSemaphoreCreate)(semaphore, value);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*semaphore, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsSemaphoreCloneTraced( NvOsSemaphoreHandle orig, NvOsSemaphoreHandle *clone,
    const char *f, int l )
{
    NvError status;
    status = (NvOsSemaphoreClone)(orig, clone);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*clone, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsThreadCreateTraced( NvOsThreadFunction function, void *args,
    NvOsThreadHandle *thread, const char *f, int l )
{
    NvError status;
    status = (NvOsThreadCreate)(function, args, thread);
    if (status == NvSuccess)
        NvOsSetResourceAllocFileLine(*thread, f, l);
    return status;
}
 
static NV_INLINE NvError
NvOsInterruptRegisterTraced(NvU32 IrqListSize, const NvU32 *pIrqList,
    const NvOsInterruptHandler *pIrqHandlerList, void *context,
    NvOsInterruptHandle *handle, NvBool InterruptEnable, const char *f, int l )
{
    NvError status;
    (void) f; /* potentially unused parameter */
    (void) l; /* potentially unused parameter */
    status = (NvOsInterruptRegister)(IrqListSize, pIrqList, pIrqHandlerList,
        context, handle, InterruptEnable);
    return status;
}
 
#define NvOsSharedMemAlloc(key, size, descriptor) \
    NvOsSharedMemAllocTraced(key, size, descriptor, __FILE__, __LINE__)
#define NvOsSharedMemHandleFromFd(fd, descriptor) \
    NvOsSharedMemHandleFromFdTraced(fd, descriptor, __FILE__, __LINE__)
#define NvOsPhysicalMemMap(phys, size, attrib, flags, ptr)   \
    NvOsPhysicalMemMapTraced(phys, size, attrib, flags, ptr, \
            __FILE__, __LINE__)
#define NvOsPageAlloc(size, attrib, flags, protect, descriptor)   \
    NvOsPageAllocTraced(size, attrib, flags, protect, descriptor, \
            __FILE__, __LINE__)
#define NvOsMutexCreate(mutex) NvOsMutexCreateTraced(mutex, __FILE__, __LINE__)
#define NvOsIntrMutexCreate(mutex) \
    NvOsIntrMutexCreateTraced(mutex, __FILE__, __LINE__)
#define NvOsSemaphoreCreate(semaphore, value)   \
    NvOsSemaphoreCreateTraced(semaphore, value, __FILE__, __LINE__)
#define NvOsSemaphoreClone(orig, semaphore)   \
    NvOsSemaphoreCloneTraced(orig, semaphore, __FILE__, __LINE__)
#define NvOsThreadCreate(func, args, thread)    \
    NvOsThreadCreateTraced(func, args, thread, __FILE__, __LINE__)
#define NvOsInterruptRegister(IrqListSize, pIrqList, pIrqHandlerList, \
        context, handle, InterruptEnable) \
    NvOsInterruptRegisterTraced(IrqListSize, pIrqList, pIrqHandlerList, \
        context, handle, InterruptEnable, __FILE__, __LINE__)
 
#endif // NVOS_DEBUG
 
// Forward declare resource tracking struct.
typedef struct NvCallstackRec     NvCallstack;
 
typedef enum
{
    NvOsCallstackType_NoStack = 1,
    NvOsCallstackType_HexStack = 2,
    NvOsCallstackType_SymbolStack = 3,
 
    NvOsCallstackType_Last = 4,
    NvOsCallstackType_Force32 = 0x7FFFFFFF
} NvOsCallstackType;
 
typedef void (*NvOsDumpCallback)(void* context, const char* line);
 
void NvOsDumpToDebugPrintf(void* context, const char* line);
 
NvCallstack* NvOsCallstackCreate      (NvOsCallstackType stackType);
void         NvOsCallstackDestroy     (NvCallstack* callstack);
NvU32        NvOsCallstackGetHeight   (NvCallstack* stack);
void         NvOsCallstackGetFrame    (char* buf, NvU32 len, NvCallstack* stack, NvU32 level);
void         NvOsCallstackDump        (NvCallstack* stack, NvU32 skip, NvOsDumpCallback callBack, void* context);
NvU32        NvOsCallstackHash        (NvCallstack* stack);
NvBool       NvOsCallstackContainsPid (NvCallstack* stack, NvU32 pid);
void         NvOsGetProcessInfo       (char* buf, NvU32 len);
 
static NV_INLINE void NvOsDebugCallstack(NvU32 skip)
{
    NvCallstack* stack = NvOsCallstackCreate(NvOsCallstackType_SymbolStack);
    if (stack)
    {
        NvOsCallstackDump(stack, skip, NvOsDumpToDebugPrintf, NULL);
        NvOsCallstackDestroy(stack);
    }
}
 
int NvOsSetFpsTarget(int target);
 
int NvOsModifyFpsTarget(int fd, int target);
 
void NvOsCancelFpsTarget(int fd);
 
 
#if NVOS_IS_HOS
 
typedef int NvOsDrvHandle;
 
NvOsDrvHandle NvOsDrvOpen(const char *pathname);
 
void NvOsDrvClose(NvOsDrvHandle);
 
NvError NvOsDrvIoctl(NvOsDrvHandle, unsigned int iocode, void *arg, size_t argsize);
 
NvError NvOsDrvIoctl2(NvOsDrvHandle, unsigned int iocode, void *arg, size_t argsize, const void *inbuf, size_t inbufsize);
 
NvError NvOsDrvIoctl3(NvOsDrvHandle, unsigned int iocode, void *arg, size_t argsize, void *outbuf, size_t outbufsize);
 
NvError NvOsDrvMapSharedMem(NvOsDrvHandle, unsigned int handle, unsigned int hMem);
 
typedef struct NvOsEventPoolRec NvOsEventPool;
typedef struct NvOsEventRec NvOsEvent;
 
NvError NvOsEventPoolCreate(NvU32 numEvents, NvOsEventPool **eventPool);
 
void NvOsEventPoolDestroy(NvOsEventPool *eventPool);
 
NvError NvOsEventPoolLink(NvOsEventPool *eventPool, NvOsEvent *event);
 
void NvOsEventPoolWait(NvOsEventPool *eventPool, NvU32 timeoutUs, NvOsEvent **event);
 
NvError NvOsSystemEventCreate(int fd, NvU32 id, NvOsEvent **event);
 
NvError NvOsTimerEventCreate(NvU32 timeoutMs, NvOsEvent **event);
 
NvError NvOsUserEventCreate(NvOsEvent **event);
 
NvError NvOsUserEventSignal(NvOsEvent *event);
 
void NvOsEventDestroy(NvOsEvent *event);
 
void NvOsEventClear(NvOsEvent *event);
 
NvError NvOsEventWait(NvOsEvent* event, NvU32 timeoutUs);
 
typedef struct NvOsThreadCreateAttrRec
{
    // If NULL, driver will allocate memory for stack
    void *threadStack;
    // If 0, driver will use OS-dependent default stack size
    size_t threadStackSize;
    // If NvOsThreadPriorityType_Native, nativePriority is used instead
    NvOsThreadPriorityType priority;
    // OS-dependent priority value of thread
    int nativePriority;
    // Preferred CPU core number to run on. -1 indicates no preference
    int idealCore;
    // Bitmask of CPU cores allowed for the thread to run on. 0 indicates core mask is not specified
    uint64_t affinityMask;
    // If NULL, thread name is not set
    const char *threadName;
} NvOsThreadCreateAttr;
 
#define NVOS_DEFINE_THREAD_CREATE_ATTR(x) \
    NvOsThreadCreateAttr x = { NULL, 0, NvOsThreadPriorityType_Normal, 0, -1, 0, NULL }
 
NvError
NvOsThreadCreateWithAttr(NvOsThreadFunction function, void *args,
    NvOsThreadHandle *thread, const NvOsThreadCreateAttr *attr);
 
typedef void (*NvOsExitHandlerFunc)(void);
typedef struct NvOsExitHandlerContextRec
{
    NvOsExitHandlerFunc Func;
    struct NvOsExitHandlerContextRec *Prev;
} NvOsExitHandlerContext;
 
typedef enum
{
    NvOsTelemetryCategory_Test,
    NvOsTelemetryCategory_VideoInfo,
} NvOsTelemetryCategory;
 
NvError NvOsTelemetrySubmitData(NvOsTelemetryCategory category, void *arg);
 
void NvOsRegisterExitHandler(NvOsExitHandlerFunc func, NvOsExitHandlerContext *ctx, NvBool toLast);
 
#define NVOS_REGISTER_EXIT_HANDLER(_func) \
    do { \
        static NvOsExitHandlerContext _ctx = {0,0}; \
        NvOsRegisterExitHandler(_func, &_ctx, false); \
    } while(0)
 
#define NVOS_REGISTER_EXIT_HANDLER_LAST(_func) \
    do { \
        static NvOsExitHandlerContext _ctx = {0,0}; \
        NvOsRegisterExitHandler(_func, &_ctx, true); \
    } while(0)
 
#endif
 
NvU32 NvOsReadReg(NvU64 Reg, NvU32 Off);
void NvOsWriteReg(NvU64 reg, NvU32 off, NvU32 val);
NvError NvOsMapRegSpace(NvU64 *VirtReg, NvU32 Base, NvU32 Size);
NvError NvOsUnMapRegSpace(NvU64 *VirtReg, NvU32 Base, NvU32 Size);
 
int NvOsDebugExternalLogInit(void);
 
#if defined(__cplusplus)
}
#endif
 
/* Additional or redefined NvOs APIs for HOS */
#if NVOS_IS_HOS
#include "../../core-hos/include/nvos_hos.h"
#endif
 
#endif // INCLUDED_NVOS_TEGRA_NONSAFETY_H