| /* |
| * osApi.h |
| * |
| * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. |
| * 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 Texas Instruments 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. |
| */ |
| |
| |
| /*--------------------------------------------------------------------------*/ |
| /* Module: OSAPI.H*/ |
| /**/ |
| /* Purpose: This module defines unified interface to the OS specific*/ |
| /* sources and services.*/ |
| /**/ |
| /*--------------------------------------------------------------------------*/ |
| |
| #ifndef __OS_API_H__ |
| #define __OS_API_H__ |
| |
| /** \file osApi.h |
| * \brief Operating System APIs \n |
| * This module defines unified interface to the OS specific sources and services |
| */ |
| |
| #include "tidef.h" |
| #include "TI_IPC_Api.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| |
| /** \struct TI_CONNECTION_STATUS |
| * \struct *PTI_CONNECTION_STATUS |
| * \brief Ti Connection Status |
| * |
| * \par Description |
| * |
| * \sa |
| */ |
| typedef struct |
| { |
| TI_UINT32 Event; |
| TI_UINT8* Data; |
| } TI_CONNECTION_STATUS, *PTI_CONNECTION_STATUS; |
| |
| typedef struct |
| { |
| TI_UINT8 uFormat; |
| TI_UINT8 uLevel; |
| TI_UINT8 uParamsNum; |
| TI_UINT8 uReserved; |
| TI_UINT16 uFileId; |
| TI_UINT16 uLineNum; |
| } TTraceMsg; |
| |
| #define OS_PAGE_SIZE 4096 |
| #define MAX_MESSAGE_SIZE 500 |
| #define MICROSECOND_IN_SECONDS 1000000 |
| |
| #define UINT16_MAX_VAL 0xffff |
| #define UINT8_MAX_VAL 0xff |
| |
| #define TRACE_FORMAT_8_BITS_PARAMS 2 |
| #define TRACE_FORMAT_16_BITS_PARAMS 4 |
| #define TRACE_FORMAT_32_BITS_PARAMS 6 |
| |
| #define TRACE_MSG_MAX_PARAMS 32 |
| #define TRACE_MSG_MIN_LENGTH (sizeof(TTraceMsg)) |
| #define TRACE_MSG_MAX_LENGTH ((TRACE_MSG_MAX_PARAMS * 4) + sizeof(TTraceMsg)) |
| |
| #define INSERT_BYTE(pBuf, dataByte) (*((TI_UINT8 *)pBuf) = (TI_UINT8 )dataByte ); pBuf++; |
| #define INSERT_2_BYTES(pBuf, dataBytes) (*((TI_UINT16 *)pBuf) = (TI_UINT16)dataBytes); pBuf+=2; |
| #define INSERT_4_BYTES(pBuf, dataBytes) (*((TI_UINT32 *)pBuf) = (TI_UINT32)dataBytes); pBuf+=4; |
| |
| |
| /**************************************************************************************** |
| START OF OS API (Common to all GWSI LIB, Driver and TI Driver) |
| *****************************************************************************************/ |
| |
| |
| /**************************************************************************************** |
| OS HW API NEEDED BY DRIVER |
| *****************************************************************************************/ |
| |
| /** \brief OS Disable IRQ |
| * |
| * \param OsContext - Handle to the OS object |
| * \return void |
| * |
| * \par Description |
| * This function disables the Interrupts |
| * |
| * \sa |
| */ |
| void os_disableIrq (TI_HANDLE OsContext); |
| |
| /** \brief OS Enable IRQ |
| * |
| * \param OsContext - Handle to the OS object |
| * \return void |
| * |
| * \par Description |
| * This function enables the Interrupts |
| * |
| * \sa |
| */ |
| void os_enableIrq (TI_HANDLE OsContext); |
| |
| /** \brief OS IRQ Serviced |
| * |
| * \param OsContext - Handle to the OS object |
| * \return void |
| * |
| * \par Description |
| * This function is used in Level IRQ only. At this point the interrupt line is not asserted anymore |
| * and we can inform the OS to enable IRQ again. |
| * |
| * \sa |
| */ |
| void os_InterruptServiced (TI_HANDLE OsContext); |
| |
| /**************************************************************************************** |
| * OS Report API * |
| ****************************************************************************************/ |
| |
| /** \brief OS Set Debug Mode |
| * |
| * \param enable - Indicates if debug mode should be enabled or disabled ( TI_TRUE | TI_FALSE ) |
| * \return void |
| * |
| * \par Description |
| * This function sets the Debug Mode flag to True or False - according to user's request |
| * |
| * \sa |
| */ |
| void os_setDebugMode (TI_BOOL enable); |
| |
| /** \brief OS Printf |
| * |
| * \param format - String to print (with formatted parametrs in string if needed) and parameters values |
| * if formatted parameters are used in string |
| * \return void |
| * |
| * \par Description |
| * This function prints formatted output using OS available printf method |
| * |
| * \sa |
| */ |
| void os_printf (const char *format ,...); |
| |
| /**************************************************************************************** |
| * OS Memory API * |
| ****************************************************************************************/ |
| |
| /** \brief OS Memory Allocation |
| * |
| * \param OsContext - Handle to the OS object |
| * \param Size - Size (in bytes) to be allocated |
| * \return Pointer to the allocated memory on success ; NULL on failure (there isn't enough memory available) |
| * |
| * \par Description |
| * This function allocates resident (nonpaged) system-space memory with calling specific OS allocation function. \n |
| * It is assumed that this function will never be called in an interrupt context since the OS allocation function |
| * has the potential to put the caller to sleep while waiting for memory to become available. |
| * |
| * \sa |
| */ |
| void *os_memoryAlloc (TI_HANDLE OsContext,TI_UINT32 Size); |
| |
| /** \brief OS Memory CAllocation |
| * |
| * \param OsContext - Handle to the OS object |
| * \param Number - Number of element to be allocated |
| * \param Size - Size (in bytes) of one element |
| * \return Pointer to the allocated memory on success ; NULL on failure (there isn't enough memory available) |
| * |
| * \par Description |
| * This function allocates an array in memory with elements initialized to 0. |
| * Allocates resident (nonpaged) system-space memory for an array with elements initialized to 0, |
| * with specific OS allocation function. |
| * It is assumed that this function will never be called in an interrupt context since the OS allocation function |
| * has the potential to put the caller to sleep while waiting for memory to become available. |
| * |
| * \sa |
| */ |
| void *os_memoryCAlloc (TI_HANDLE OsContext, TI_UINT32 Number, TI_UINT32 Size); |
| |
| /** \brief OS Memory Set |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pMemPtr - Pointer to the base address of a memory block |
| * \param Value - Value to set to memory block |
| * \param Length - Length (in bytes) of memory block |
| * \return void |
| * |
| * \par Description |
| * This function fills a block of memory with a given value |
| * |
| * \sa |
| */ |
| void os_memorySet (TI_HANDLE OsContext, void *pMemPtr, TI_INT32 Value, TI_UINT32 Length); |
| |
| /** \brief OS Memory Zero |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pMemPtr - Pointer to the base address of a memory block |
| * \param Length - Length (in bytes) of memory block |
| * \return void |
| * |
| * \par Description |
| * This function fills a block of memory with zeros |
| * |
| * \sa |
| */ |
| void os_memoryZero (TI_HANDLE OsContext, void *pMemPtr, TI_UINT32 Length); |
| |
| /** \brief OS Memory Copy |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pDestination - Pointer to destination buffer |
| * \param pSource - Pointer to Source buffer |
| * \param Size - Size (in bytes) to copy |
| * \return void |
| * |
| * \par Description |
| * This function copies a specified number of bytes from one caller-supplied location (source buffer) to another (destination buffer) |
| * |
| * \sa |
| */ |
| void os_memoryCopy (TI_HANDLE OsContext, void *pDestination, void *pSource, TI_UINT32 Size); |
| |
| /** \brief OS Memory Free |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pMemPtr - Pointer to the base address of a memory block |
| * \param Size - Size (in bytes) to free |
| * \return void |
| * |
| * \par Description |
| * This function releases a block of memory which was previously allocated by user |
| * |
| * \sa |
| */ |
| void os_memoryFree (TI_HANDLE OsContext, void *pMemPtr, TI_UINT32 Size); |
| |
| /** \brief OS Memory Compare |
| * |
| * \param OsContext - Handle to the OS object |
| * \param Buf1 - Pointer to the first buffer in comperation |
| * \param Buf2 - Pointer to the second buffer in comperation |
| * \param Count - Count (in bytes) to compare |
| * \return A value which indicates the relationship between the two compared buffers: |
| * value < 0: Buf1 less than Buf2 |
| * value == 0: Buf1 identical to Buf2 |
| * value > 0: Buf1 greater than Buf2 |
| * |
| * \par Description |
| * This function compares between two given buffers |
| * |
| * \sa |
| */ |
| TI_INT32 os_memoryCompare (TI_HANDLE OsContext, TI_UINT8* Buf1, TI_UINT8* Buf2, TI_INT32 Count); |
| |
| /** \brief OS Memory Allocation for HW DMA |
| * |
| * \param pOsContext - Handle to the OS object |
| * \param Size - Size (in bytes) to allocate |
| * \return Pointer to the allocated memory on success ; NULL on failure (there isn't enough memory available) |
| * |
| * \par Description |
| * This function allocates resident (nonpaged) system-space memory for HW DMA operations |
| * |
| * \sa |
| */ |
| void *os_memoryAlloc4HwDma (TI_HANDLE pOsContext, TI_UINT32 Size); |
| |
| /** \brief OS Memory for HW DMA Free |
| * |
| * \param pOsContext - Handle to the OS object |
| * \param pMem_ptr - Pointer to the base virtual address of allocated memory block |
| * This is the address that was returned to user when he allocated the memory for HW DMA usage |
| * \param Size - Size (in bytes) of the memory block to be released. This parameter must be identical to the Length |
| * which was given by the user when he allocated the memory block for HW DMA usage |
| * \return Pointer to the allocated memory on success ; NULL on failure (there isn't enough memory available) |
| * |
| * \par Description |
| * This function releases a block of memory previously allocated by user for HW DMA operations |
| * |
| * \sa |
| */ |
| void os_memory4HwDmaFree (TI_HANDLE pOsContext, void *pMem_ptr, TI_UINT32 Size); |
| |
| /** \brief OS Memory Copy from User |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pDstPtr - Pointer to destination buffer |
| * \param pSrcPtr - Pointer to Source buffer |
| * \param Size - Size (in bytes) to copy |
| * \return TI_OK on success ; TI_NOK otherwise |
| * |
| * \par Description |
| * This function copies a specified number of bytes from one caller-supplied location (Source) to another (Destination) |
| * |
| * \sa |
| */ |
| int os_memoryCopyFromUser (TI_HANDLE OsContext, void *pDstPtr, void *pSrcPtr, TI_UINT32 Size); |
| |
| /** \brief OS Memory Copy To User |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pDstPtr - Pointer to destination buffer |
| * \param pSrcPtr - Pointer to Source buffer |
| * \param Size - Size (in bytes) to copy |
| * \return TI_OK on success ; TI_NOK otherwise |
| * |
| * \par Description |
| * This function copies a specified number of bytes from one caller-supplied location (Source) to another (Destination) |
| * |
| * \sa |
| */ |
| int os_memoryCopyToUser (TI_HANDLE OsContext, void *pDstPtr, void *pSrcPtr, TI_UINT32 Size); |
| |
| /**************************************************************************************** |
| * OS TIMER API * |
| ****************************************************************************************/ |
| /** \brief Timer Callback Function |
| * |
| * \param Context - Handle to the OS object |
| * \return void |
| * |
| * \par Description |
| * This callback is passed by user to OS timer when created, and is called directly from OS timer context when expired. |
| * E.g. the user user the timer in order to operate this function after a defined time expires |
| * |
| */ |
| typedef void (*fTimerFunction)(TI_HANDLE Context); |
| |
| /** \brief OS Timer Create |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pRoutine - Pointer to user's Timer Callback function |
| * \param hFuncHandle - Handle to user's Timer Callback function parameters |
| * \return Handle to timer object on success ; NULL on failure |
| * |
| * \par Description |
| * This function creates and initializes an OS timer object associated with a user's Timer Callback function \n |
| * \note 1) The user's callback is called directly from OS timer context when expired. |
| * \note 2) In some OSs, it may be needed to use an intermediate callback in the |
| * \note osapi layer (use os_timerHandlr for that). |
| * |
| * \sa |
| */ |
| TI_HANDLE os_timerCreate (TI_HANDLE OsContext, fTimerFunction pRoutine, TI_HANDLE hFuncHandle); |
| |
| /** \brief OS Timer Destroy |
| * |
| * \param OsContext - Handle to the OS object |
| * \param TimerHandle - Handle to timer object which user got when created the timer |
| * \return void |
| * |
| * \par Description |
| * This function destroys the OS timer object which was previously created by user |
| * |
| * \sa |
| */ |
| void os_timerDestroy (TI_HANDLE OsContext, TI_HANDLE TimerHandle); |
| |
| /** \brief OS Timer Start |
| * |
| * \param OsContext - Handle to the OS object |
| * \param TimerHandle - Handle to timer object which user got when created the timer |
| * \param DelayMs - The time in MS untill the timer is awaken |
| * \return void |
| * |
| * \par Description |
| * This function Start the OS timer object which was previously created by user |
| * |
| * \sa |
| */ |
| void os_timerStart (TI_HANDLE OsContext, TI_HANDLE TimerHandle, TI_UINT32 DelayMs); |
| |
| /** \brief OS Timer Stop |
| * |
| * \param OsContext - Handle to the OS object |
| * \param TimerHandle - Handle to timer object which user got when created the timer |
| * \return void |
| * |
| * \par Description |
| * This function Stops the OS timer object which was previously created by user |
| * |
| * \sa |
| */ |
| void os_timerStop (TI_HANDLE OsContext, TI_HANDLE TimerHandle); |
| |
| /** \brief OS Periodic Interrupt Timer Start |
| * |
| * \param OsContext - Handle to the OS object |
| * \return void |
| * |
| * \par Description |
| * This function starts the periodic interrupt mechanism. This function is used when PRIODIC_INTERRUPT mode is used. |
| * This Mode is enabled when interrupts that are usually received from the FW are masked, |
| * and there is need to check- in a given time periods - if handling of any FW interrupt is needed. |
| * |
| * \sa |
| */ |
| #ifdef PRIODIC_INTERRUPT |
| void os_periodicIntrTimerStart (TI_HANDLE OsContext); |
| #endif |
| |
| /** \brief OS Time Stamp Ms |
| * |
| * \param OsContext - Handle to the OS object |
| * \return The number of milliseconds that have elapsed since the system was booted |
| * |
| * \par Description |
| * This function returns the number of milliseconds that have elapsed since the system was booted. |
| */ |
| TI_UINT32 os_timeStampMs (TI_HANDLE OsContext); |
| |
| /** \brief OS Time Stamp Us |
| * |
| * \param OsContext - Handle to the OS object |
| * \return The number of microseconds that have elapsed since the system was booted |
| * |
| * \par Description |
| * This function returns the number of microseconds that have elapsed since the system was booted. \n |
| * Note that sometimes this function will be called with NULL(!!!) as argument! |
| */ |
| TI_UINT32 os_timeStampUs (TI_HANDLE OsContext); |
| |
| /** \brief OS Stall uSec |
| * |
| * \param OsContext - Handle to the OS object |
| * \param uSec - The time to delay in microseconds |
| * \return void |
| * |
| * \par Description |
| * This function makes delay in microseconds |
| * |
| * \sa |
| */ |
| void os_StalluSec (TI_HANDLE OsContext, TI_UINT32 uSec); |
| |
| |
| /**************************************************************************************** |
| * Protection services API * |
| ****************************************************************************************/ |
| |
| /** \brief OS Protect Create |
| * |
| * \param OsContext - Handle to the OS object |
| * \return Handle of the created mutex/spin lock object on Success ; NULL on Failure (not enough memory available or problems to initializing the mutex) |
| * |
| * \par Description |
| * This function allocates a mutex/spin lock object. |
| * The mutex/spinlock object which is created by this function is used for mutual-exclusion and protection of resources which are shared between |
| * multi-Tasks/Threads |
| * |
| * \sa |
| */ |
| TI_HANDLE os_protectCreate (TI_HANDLE OsContext); |
| |
| /** \brief OS Protect Destroy |
| * |
| * \param OsContext - Handle to the OS object |
| * \param ProtectContext - Handle to the mutex/spin lock object |
| * \return void |
| * |
| * \par Description |
| * This function destroys s a mutex/spin lock object which was previously created by user: |
| * it frees the mutex/spin lock and then frees the object's memory |
| * |
| * \sa |
| */ |
| void os_protectDestroy (TI_HANDLE OsContext, TI_HANDLE ProtectContext); |
| |
| /** \brief OS Protect Lock |
| * |
| * \param OsContext - Handle to the OS object |
| * \param ProtectContext - Handle to the mutex/spin lock object |
| * \return void |
| * |
| * \par Description |
| * This function locks the mutex/spin lock object. E.g. the caller acquires a mutex/spin lock and gains exclusive |
| * access to the shared resources, that the mutex/spin lock protects of. |
| * |
| * \sa |
| */ |
| void os_protectLock (TI_HANDLE OsContext, TI_HANDLE ProtectContext); |
| |
| /** \brief OS Protect Unlock |
| * |
| * \param OsContext - Handle to the OS object |
| * \param ProtectContext - Handle to the mutex/spin lock object |
| * \return void |
| * |
| * \par Description |
| * This function unlocks the mutex/spin lock object. |
| * |
| * \sa |
| */ |
| void os_protectUnlock (TI_HANDLE OsContext, TI_HANDLE ProtectContext); |
| |
| /* Wakelock functionality */ |
| int os_wake_lock (TI_HANDLE OsContext); |
| int os_wake_unlock (TI_HANDLE OsContext); |
| int os_wake_lock_timeout (TI_HANDLE OsContext); |
| int os_wake_lock_timeout_enable (TI_HANDLE OsContext); |
| |
| #define os_profile(hos,fn,par) |
| |
| |
| /**************************************************************************************** |
| START OF GWSI DRIVER API |
| *****************************************************************************************/ |
| |
| /** \brief OS Signaling Object Create |
| * |
| * \param OsContext - Handle to the OS object |
| * \return Pointer to Signal Object on Success ; NULL on Failure |
| * |
| * \par Description |
| * This function creates a new Signaling Object or opens an already exists Signaling Object. |
| * The Signaling Object created by this function is used for mutual-exclusion and protection |
| * of resources which are shared between multi-Tasks/Threads by using a signaling mechanism |
| * |
| * \sa |
| */ |
| void *os_SignalObjectCreate (TI_HANDLE OsContext); |
| |
| /** \brief OS Signaling Object Wait |
| * |
| * \param OsContext - Handle to the OS object |
| * \param ptr - Pointer to Signaling Object previously created by user |
| * \return TI_OK (0) on Success ; TI_NOK (1) on Failure |
| * |
| * \par Description |
| * This function perform waiting on Signaling Object. The coller waits until signaled or until timeout |
| * |
| * \sa |
| */ |
| int os_SignalObjectWait (TI_HANDLE OsContext, void *ptr); |
| |
| /** \brief OS Signaling Object Set |
| * |
| * \param OsContext - Handle to the OS object |
| * \param ptr - Pointer to Signaling Object previously created by user |
| * \return TI_OK (0) on Success ; TI_NOK (1) on Failure |
| * |
| * \par Description |
| * This function sets a Signaling Object to signaled state (e.g the siganeling object is released) |
| * |
| * \sa |
| */ |
| int os_SignalObjectSet (TI_HANDLE OsContext, void *ptr); |
| |
| /** \brief OS Signaling Object Free |
| * |
| * \param OsContext - Handle to the OS object |
| * \param ptr - Pointer to Signaling Object previously created by user |
| * \return TI_OK (0) on Success ; TI_NOK (1) on Failure |
| * |
| * \par Description |
| * This function frees (closes) a Signaling Object Handle |
| * |
| * \sa |
| */ |
| int os_SignalObjectFree (TI_HANDLE OsContext, void *ptr); |
| |
| /** \brief OS Schedule Request |
| * |
| * \param OsContext - Handle to the OS object |
| * \return TI_OK (0) on Success ; TI_NOK (1) on Failure |
| * |
| * \par Description |
| * This function performs scheduling (context switch) according to user request |
| * |
| * \sa |
| */ |
| int os_RequestSchedule (TI_HANDLE OsContext); |
| |
| |
| /**************************************************************************************** |
| START OF TI DRIVER API |
| *****************************************************************************************/ |
| |
| /** \brief OS Read Memory Register UINT32 |
| * |
| * \param OsContext - Handle to the OS object |
| * \param Register - Pointer to register address |
| * \param Data - Pointer to output read data |
| * \return void |
| * |
| * \par Description |
| * This function reads register in 32 bit length |
| * |
| * \sa |
| */ |
| void os_hwReadMemRegisterUINT32 (TI_HANDLE OsContext, TI_UINT32* Register, TI_UINT32* Data); |
| |
| /** \brief OS Write Memory Register UINT32 |
| * |
| * \param OsContext - Handle to the OS object |
| * \param Register - Pointer to register address |
| * \param Data - Data to write to register |
| * \return void |
| * |
| * \par Description |
| * This function reads register in 32 bit length |
| * |
| * \sa |
| */ |
| void os_hwWriteMemRegisterUINT32 (TI_HANDLE OsContext, TI_UINT32* Register, TI_UINT32 Data); |
| |
| /** \brief OS Receive Packet |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pPacket - Pointer to received packet data |
| * \param Length - Length of received packet |
| * \return TI_TRUE on Success ; TI_FALSE on Failure |
| * |
| * \par Description |
| * This function transfers a packet from WLAN driver to OS |
| * |
| * \sa |
| */ |
| TI_BOOL os_receivePacket (TI_HANDLE OsContext, void *pPacket, TI_UINT16 Length); |
| |
| /** \brief OS Indicate Event |
| * |
| * \param OsContext - Handle to the OS object |
| * \param pData - Pointer to event data |
| * \return TI_OK (0) on Success ; |
| * |
| * \par Description |
| * This function indicate the OS about different connection driver's events, |
| * The function performs the rewuired operations for the event - in the OS side |
| * |
| * \sa |
| */ |
| TI_INT32 os_IndicateEvent (TI_HANDLE OsContext, IPC_EV_DATA *pData); |
| |
| /** \brief OS Send Trace Message to Logger |
| * |
| * \param OsContext - The OS handle |
| * \param uLevel - Severity level of the trace message |
| * \param uFileId - Source file ID of the trace message |
| * \param uLineNum - Line number of the trace message |
| * \param uParamsNum - Number of parameters in the trace message |
| * \param ... - The trace message parameters |
| * \return void |
| * |
| * \par Description |
| * This function sends trace message to logger |
| * |
| * \sa |
| */ |
| void os_Trace (TI_HANDLE OsContext, TI_UINT32 uLevel, TI_UINT32 uFileId, TI_UINT32 uLineNum, TI_UINT32 uParamsNum, ...); |
| |
| /** |
| * \fn os_SetDrvThreadPriority |
| * \brief Called upon init to set WLAN driver thread priority. |
| * |
| * \param OsContext - The OS handle |
| * \param uWlanDrvThreadPriority - The WLAN driver thread priority |
| * \return |
| */ |
| void os_SetDrvThreadPriority (TI_HANDLE OsContext, TI_UINT32 uWlanDrvThreadPriority); |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* __OS_API_H__ */ |
