1/*
2 * osApi.h
3 *
4 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 *  * Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 *  * Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in
15 *    the documentation and/or other materials provided with the
16 *    distribution.
17 *  * Neither the name Texas Instruments nor the names of its
18 *    contributors may be used to endorse or promote products derived
19 *    from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34
35/*--------------------------------------------------------------------------*/
36/* Module:      OSAPI.H*/
37/**/
38/* Purpose:     This module defines unified interface to the OS specific*/
39/*              sources and services.*/
40/**/
41/*--------------------------------------------------------------------------*/
42
43#ifndef __OS_API_H__
44#define __OS_API_H__
45
46/** \file  osApi.h
47 * \brief Operating System APIs	\n
48 * This module defines unified interface to the OS specific sources and services
49 */
50
51#include "tidef.h"
52#include "TI_IPC_Api.h"
53
54#ifdef __cplusplus
55extern "C" {
56#endif
57
58
59/** \struct TI_CONNECTION_STATUS
60 * \struct *PTI_CONNECTION_STATUS
61 * \brief Ti Connection Status
62 *
63 * \par Description
64 *
65 * \sa
66 */
67typedef struct
68{
69    TI_UINT32      Event;
70    TI_UINT8*      Data;
71} TI_CONNECTION_STATUS, *PTI_CONNECTION_STATUS;
72
73typedef struct
74{
75    TI_UINT8 	uFormat;
76    TI_UINT8 	uLevel;
77    TI_UINT8 	uParamsNum;
78    TI_UINT8 	uReserved;
79    TI_UINT16 	uFileId;
80    TI_UINT16 	uLineNum;
81} TTraceMsg;
82
83#define OS_PAGE_SIZE            4096
84#define MAX_MESSAGE_SIZE        500
85#define MICROSECOND_IN_SECONDS  1000000
86
87#define UINT16_MAX_VAL					0xffff
88#define UINT8_MAX_VAL					0xff
89
90#define TRACE_FORMAT_8_BITS_PARAMS		2
91#define TRACE_FORMAT_16_BITS_PARAMS		4
92#define TRACE_FORMAT_32_BITS_PARAMS		6
93
94#define TRACE_MSG_MAX_PARAMS			32
95#define TRACE_MSG_MIN_LENGTH			(sizeof(TTraceMsg))
96#define TRACE_MSG_MAX_LENGTH			((TRACE_MSG_MAX_PARAMS * 4) + sizeof(TTraceMsg))
97
98#define INSERT_BYTE(pBuf, dataByte)     (*((TI_UINT8  *)pBuf) = (TI_UINT8 )dataByte ); pBuf++;
99#define INSERT_2_BYTES(pBuf, dataBytes) (*((TI_UINT16 *)pBuf) = (TI_UINT16)dataBytes); pBuf+=2;
100#define INSERT_4_BYTES(pBuf, dataBytes) (*((TI_UINT32 *)pBuf) = (TI_UINT32)dataBytes); pBuf+=4;
101
102
103/****************************************************************************************
104						START OF OS API (Common to all GWSI LIB, Driver and TI Driver)
105*****************************************************************************************/
106
107
108/****************************************************************************************
109                        OS HW API NEEDED BY DRIVER
110*****************************************************************************************/
111
112/** \brief  OS Disable IRQ
113 *
114 * \param  OsContext 	- Handle to the OS object
115 * \return void
116 *
117 * \par Description
118 * This function disables the Interrupts
119 *
120 * \sa
121 */
122void os_disableIrq (TI_HANDLE OsContext);
123
124/** \brief  OS Enable IRQ
125 *
126 * \param  OsContext 	- Handle to the OS object
127 * \return void
128 *
129 * \par Description
130 * This function enables the Interrupts
131 *
132 * \sa
133 */
134void os_enableIrq (TI_HANDLE OsContext);
135
136/** \brief  OS  IRQ Serviced
137 *
138 * \param  OsContext 	- Handle to the OS object
139 * \return void
140 *
141 * \par Description
142 * This function is used in Level IRQ only. At this point the interrupt line is not asserted anymore
143 * and we can inform the OS to enable IRQ again.
144 *
145 * \sa
146 */
147void os_InterruptServiced (TI_HANDLE OsContext);
148
149/****************************************************************************************
150 *						OS Report API													*
151 ****************************************************************************************/
152
153/** \brief  OS Set Debug Mode
154 *
155 * \param  enable 	- Indicates if debug mode should be enabled or disabled ( TI_TRUE | TI_FALSE )
156 * \return void
157 *
158 * \par Description
159 * This function sets the Debug Mode flag to True or False - according to user's request
160 *
161 * \sa
162 */
163void os_setDebugMode (TI_BOOL enable);
164
165/** \brief  OS Printf
166 *
167 * \param  format 	- String to print (with formatted parametrs in string if needed) and parameters values
168 *					  if formatted parameters are used in string
169 * \return void
170 *
171 * \par Description
172 * This function prints formatted output using OS available printf method
173 *
174 * \sa
175 */
176void os_printf (const char *format ,...);
177
178/****************************************************************************************
179 *						OS Memory API													*
180 ****************************************************************************************/
181
182/** \brief  OS Memory Allocation
183 *
184 * \param  OsContext 	- Handle to the OS object
185 * \param  Size 		- Size (in bytes) to be allocated
186 * \return Pointer to the allocated memory on success	;  NULL on failure (there isn't enough memory available)
187 *
188 * \par Description
189 * This function allocates resident (nonpaged) system-space memory with calling specific OS allocation function.	\n
190 * It is assumed that this function will never be called in an interrupt context since the OS allocation function
191 * has the potential to put the caller to sleep  while waiting for memory to become available.
192 *
193 * \sa
194 */
195void *os_memoryAlloc (TI_HANDLE OsContext,TI_UINT32 Size);
196
197/** \brief  OS Memory CAllocation
198 *
199 * \param  OsContext 	- Handle to the OS object
200 * \param  Number 		- Number of element to be allocated
201 * \param  Size 		- Size (in bytes) of one element
202 * \return Pointer to the allocated memory on success	;  NULL on failure (there isn't enough memory available)
203 *
204 * \par Description
205 * This function allocates an array in memory with elements initialized to 0.
206 * Allocates resident (nonpaged) system-space memory for an array with elements initialized to 0,
207 * with specific OS allocation function.
208 * It is assumed that this function will never be called in an interrupt context since the OS allocation function
209 * has the potential to put the caller to sleep  while waiting for memory to become available.
210 *
211 * \sa
212 */
213void *os_memoryCAlloc (TI_HANDLE OsContext, TI_UINT32 Number, TI_UINT32 Size);
214
215/** \brief  OS Memory Set
216 *
217 * \param  OsContext 	- Handle to the OS object
218 * \param  pMemPtr 		- Pointer to the base address of a memory block
219 * \param  Value 		- Value to set to memory block
220 * \param  Length 		- Length (in bytes) of memory block
221 * \return void
222 *
223 * \par Description
224 * This function fills a block of memory with a given value
225 *
226 * \sa
227 */
228void os_memorySet (TI_HANDLE OsContext, void *pMemPtr, TI_INT32 Value, TI_UINT32 Length);
229
230/** \brief  OS Memory Zero
231 *
232 * \param  OsContext 	- Handle to the OS object
233 * \param  pMemPtr 		- Pointer to the base address of a memory block
234 * \param  Length 		- Length (in bytes) of memory block
235 * \return void
236 *
237 * \par Description
238 * This function fills a block of memory with zeros
239 *
240 * \sa
241 */
242void os_memoryZero (TI_HANDLE OsContext, void *pMemPtr, TI_UINT32 Length);
243
244/** \brief  OS Memory Copy
245 *
246 * \param  OsContext 	- Handle to the OS object
247 * \param  pDestination - Pointer to destination buffer
248 * \param  pSource 		- Pointer to Source buffer
249 * \param  Size 		- Size (in bytes) to copy
250 * \return void
251 *
252 * \par Description
253 * This function copies a specified number of bytes from one caller-supplied location (source buffer) to another (destination buffer)
254 *
255 * \sa
256 */
257void os_memoryCopy (TI_HANDLE OsContext, void *pDestination, void *pSource, TI_UINT32 Size);
258
259/** \brief  OS Memory Free
260 *
261 * \param  OsContext 	- Handle to the OS object
262 * \param  pMemPtr 		- Pointer to the base address of a memory block
263 * \param  Size 		- Size (in bytes) to free
264 * \return void
265 *
266 * \par Description
267 * This function releases a block of memory which was previously allocated by user
268 *
269 * \sa
270 */
271void os_memoryFree (TI_HANDLE OsContext, void *pMemPtr, TI_UINT32 Size);
272
273/** \brief  OS Memory Compare
274 *
275 * \param  OsContext 	- Handle to the OS object
276 * \param  Buf1 		- Pointer to the first buffer in comperation
277 * \param  Buf2 		- Pointer to the second buffer in comperation
278 * \param  Count 		- Count (in bytes) to compare
279 * \return A value which indicates the relationship between the two compared buffers:
280 *         value < 0:	Buf1 less than Buf2
281 *         value == 0: 	Buf1 identical to Buf2
282 *         value > 0: 	Buf1 greater than Buf2
283 *
284 * \par Description
285 * This function compares between two given buffers
286 *
287 * \sa
288 */
289TI_INT32 os_memoryCompare (TI_HANDLE OsContext, TI_UINT8* Buf1, TI_UINT8* Buf2, TI_INT32 Count);
290
291/** \brief  OS Memory Allocation for HW DMA
292 *
293 * \param  pOsContext 	- Handle to the OS object
294 * \param  Size 		- Size (in bytes) to allocate
295 * \return Pointer to the allocated memory on success	;  NULL on failure (there isn't enough memory available)
296 *
297 * \par Description
298 * This function allocates resident (nonpaged) system-space memory for HW DMA operations
299 *
300 * \sa
301 */
302void *os_memoryAlloc4HwDma (TI_HANDLE pOsContext, TI_UINT32 Size);
303
304/** \brief  OS Memory for HW DMA Free
305 *
306 * \param  pOsContext 	- Handle to the OS object
307 * \param  pMem_ptr 	- Pointer to the base virtual address of allocated memory block
308 *                        This is the address that was returned to user when he allocated the memory for HW DMA usage
309 * \param  Size 		- Size (in bytes) of the memory block to be released. This parameter must be identical to the Length
310 *						  which was given by the user when he allocated the memory block for HW DMA usage
311 * \return Pointer to the allocated memory on success	;  NULL on failure (there isn't enough memory available)
312 *
313 * \par Description
314 * This function releases a block of memory previously allocated by user for HW DMA operations
315 *
316 * \sa
317 */
318void os_memory4HwDmaFree (TI_HANDLE pOsContext, void *pMem_ptr, TI_UINT32 Size);
319
320/** \brief  OS Memory Copy from User
321 *
322 * \param  OsContext 	- Handle to the OS object
323 * \param  pDstPtr 		- Pointer to destination buffer
324 * \param  pSrcPtr 		- Pointer to Source buffer
325 * \param  Size 		- Size (in bytes) to copy
326 * \return TI_OK on success	;  TI_NOK otherwise
327 *
328 * \par Description
329 * This function copies a specified number of bytes from one caller-supplied location (Source) to another (Destination)
330 *
331 * \sa
332 */
333int os_memoryCopyFromUser (TI_HANDLE OsContext, void *pDstPtr, void *pSrcPtr, TI_UINT32 Size);
334
335/** \brief  OS Memory Copy To User
336 *
337 * \param  OsContext 	- Handle to the OS object
338 * \param  pDstPtr 		- Pointer to destination buffer
339 * \param  pSrcPtr 		- Pointer to Source buffer
340 * \param  Size 		- Size (in bytes) to copy
341 * \return TI_OK on success	;  TI_NOK otherwise
342 *
343 * \par Description
344 * This function copies a specified number of bytes from one caller-supplied location (Source) to another (Destination)
345 *
346 * \sa
347 */
348int os_memoryCopyToUser (TI_HANDLE OsContext, void *pDstPtr, void *pSrcPtr, TI_UINT32 Size);
349
350/****************************************************************************************
351 *							OS TIMER API												*
352 ****************************************************************************************/
353/** \brief  Timer Callback Function
354 *
355 * \param  Context 	- Handle to the OS object
356 * \return void
357 *
358 * \par Description
359 * This callback is passed by user to OS timer when created, and is called directly from OS timer context when expired.
360 * E.g. the user user the timer in order to operate this function after a defined time expires
361 *
362 */
363typedef void (*fTimerFunction)(TI_HANDLE Context);
364
365/** \brief  OS Timer Create
366 *
367 * \param  OsContext 	- Handle to the OS object
368 * \param  pRoutine 	- Pointer to user's Timer Callback function
369 * \param  hFuncHandle 	- Handle to user's Timer Callback function parameters
370 * \return Handle to timer object on success	;  NULL on failure
371 *
372 * \par Description
373 * This function creates and initializes an OS timer object associated with a user's Timer Callback function	\n
374 * \note   1) The user's callback is called directly from OS timer context when expired.
375 * \note   2) In some OSs, it may be needed to use an intermediate callback in the
376 * \note      osapi layer (use os_timerHandlr for that).
377 *
378 * \sa
379 */
380TI_HANDLE os_timerCreate (TI_HANDLE OsContext, fTimerFunction pRoutine, TI_HANDLE hFuncHandle);
381
382/** \brief  OS Timer Destroy
383 *
384 * \param  OsContext 	- Handle to the OS object
385 * \param  TimerHandle 	- Handle to timer object which user got when created the timer
386 * \return void
387 *
388 * \par Description
389 * This function destroys the OS timer object which was previously created by user
390 *
391 * \sa
392 */
393void os_timerDestroy (TI_HANDLE OsContext, TI_HANDLE TimerHandle);
394
395/** \brief  OS Timer Start
396 *
397 * \param  OsContext 	- Handle to the OS object
398 * \param  TimerHandle 	- Handle to timer object which user got when created the timer
399 * \param  DelayMs 		- The time in MS untill the timer is awaken
400 * \return void
401 *
402 * \par Description
403 * This function Start the OS timer object which was previously created by user
404 *
405 * \sa
406 */
407void os_timerStart (TI_HANDLE OsContext, TI_HANDLE TimerHandle, TI_UINT32 DelayMs);
408
409/** \brief  OS Timer Stop
410 *
411 * \param  OsContext 	- Handle to the OS object
412 * \param  TimerHandle 	- Handle to timer object which user got when created the timer
413 * \return void
414 *
415 * \par Description
416 * This function Stops the OS timer object which was previously created by user
417 *
418 * \sa
419 */
420void os_timerStop (TI_HANDLE OsContext, TI_HANDLE TimerHandle);
421
422/** \brief  OS Periodic Interrupt Timer Start
423 *
424 * \param  OsContext 	- Handle to the OS object
425 * \return void
426 *
427 * \par Description
428 * This function starts the periodic interrupt mechanism. This function is used when PRIODIC_INTERRUPT mode is used.
429 * This Mode is enabled when interrupts that are usually received from the FW are masked,
430 * and there is need to check- in a given time periods - if handling of any FW interrupt is needed.
431 *
432 * \sa
433 */
434#ifdef PRIODIC_INTERRUPT
435void os_periodicIntrTimerStart (TI_HANDLE OsContext);
436#endif
437
438/** \brief  OS Time Stamp Ms
439 *
440 * \param  OsContext 	- Handle to the OS object
441 * \return The number of milliseconds that have elapsed since the system was booted
442 *
443 * \par Description
444 * This function returns the number of milliseconds that have elapsed since the system was booted.
445 */
446TI_UINT32 os_timeStampMs (TI_HANDLE OsContext);
447
448/** \brief  OS Time Stamp Us
449 *
450 * \param  OsContext 	- Handle to the OS object
451 * \return The number of microseconds that have elapsed since the system was booted
452 *
453 * \par Description
454 * This function returns the number of microseconds that have elapsed since the system was booted.	\n
455 * Note that sometimes this function will be called with NULL(!!!) as argument!
456 */
457TI_UINT32 os_timeStampUs (TI_HANDLE OsContext);
458
459/** \brief  OS Stall uSec
460 *
461 * \param  OsContext 	- Handle to the OS object
462 * \param  uSec 		- The time to delay in microseconds
463 * \return void
464 *
465 * \par Description
466 * This function makes delay in microseconds
467 *
468 * \sa
469 */
470void os_StalluSec (TI_HANDLE OsContext, TI_UINT32 uSec);
471
472
473/****************************************************************************************
474 *							Protection services	API										*
475 ****************************************************************************************/
476
477/** \brief  OS Protect Create
478 *
479 * \param  OsContext 	- Handle to the OS object
480 * \return Handle of the created mutex/spin lock object on Success	; NULL on Failure (not enough memory available or problems to initializing the mutex)
481 *
482 * \par Description
483 * This function allocates a mutex/spin lock object.
484 * The mutex/spinlock object which is created by this function is used for mutual-exclusion and protection of resources which are shared between
485 * multi-Tasks/Threads
486 *
487 * \sa
488 */
489TI_HANDLE os_protectCreate (TI_HANDLE OsContext);
490
491/** \brief  OS Protect Destroy
492 *
493 * \param  OsContext 		- Handle to the OS object
494 * \param  ProtectContext 	- Handle to the mutex/spin lock object
495 * \return void
496 *
497 * \par Description
498 * This function destroys s a mutex/spin lock object which was previously created by user:
499 * it frees the mutex/spin lock and then frees the object's memory
500 *
501 * \sa
502 */
503void os_protectDestroy (TI_HANDLE OsContext, TI_HANDLE ProtectContext);
504
505/** \brief  OS Protect Lock
506 *
507 * \param  OsContext 		- Handle to the OS object
508 * \param  ProtectContext 	- Handle to the mutex/spin lock object
509 * \return void
510 *
511 * \par Description
512 * This function locks the mutex/spin lock object. E.g. the caller acquires a mutex/spin lock and gains exclusive
513 * access to the shared resources, that the mutex/spin lock protects of.
514 *
515 * \sa
516 */
517void os_protectLock (TI_HANDLE OsContext, TI_HANDLE ProtectContext);
518
519/** \brief  OS Protect Unlock
520 *
521 * \param  OsContext 		- Handle to the OS object
522 * \param  ProtectContext 	- Handle to the mutex/spin lock object
523 * \return void
524 *
525 * \par Description
526 * This function unlocks the mutex/spin lock object.
527 *
528 * \sa
529 */
530void os_protectUnlock (TI_HANDLE OsContext, TI_HANDLE ProtectContext);
531
532/* Wakelock functionality */
533int os_wake_lock (TI_HANDLE OsContext);
534int os_wake_unlock (TI_HANDLE OsContext);
535int os_wake_lock_timeout (TI_HANDLE OsContext);
536int os_wake_lock_timeout_enable (TI_HANDLE OsContext);
537
538#define os_profile(hos,fn,par)
539
540
541/****************************************************************************************
542						START OF GWSI DRIVER API
543*****************************************************************************************/
544
545/** \brief  OS Signaling Object Create
546 *
547 * \param  OsContext 		- Handle to the OS object
548 * \return Pointer to Signal Object on Success	;	NULL on Failure
549 *
550 * \par Description
551 * This function creates a new Signaling Object or opens an already exists Signaling Object.
552 * The Signaling Object created by this function is used for mutual-exclusion and protection
553 * of resources which are shared between multi-Tasks/Threads by using a signaling mechanism
554 *
555 * \sa
556 */
557void *os_SignalObjectCreate (TI_HANDLE OsContext);
558
559/** \brief  OS Signaling Object Wait
560 *
561 * \param  OsContext 	- Handle to the OS object
562 * \param  ptr 			- Pointer to Signaling Object previously created by user
563 * \return TI_OK (0) on Success	;	TI_NOK (1) on Failure
564 *
565 * \par Description
566 * This function perform waiting on Signaling Object. The coller waits until signaled or until timeout
567 *
568 * \sa
569 */
570int os_SignalObjectWait (TI_HANDLE OsContext, void *ptr);
571
572/** \brief  OS Signaling Object Set
573 *
574 * \param  OsContext 	- Handle to the OS object
575 * \param  ptr 			- Pointer to Signaling Object previously created by user
576 * \return TI_OK (0) on Success	;	TI_NOK (1) on Failure
577 *
578 * \par Description
579 * This function sets a Signaling Object to signaled state (e.g the siganeling object is released)
580 *
581 * \sa
582 */
583int os_SignalObjectSet (TI_HANDLE OsContext, void *ptr);
584
585/** \brief  OS Signaling Object Free
586 *
587 * \param  OsContext 	- Handle to the OS object
588 * \param  ptr 			- Pointer to Signaling Object previously created by user
589 * \return TI_OK (0) on Success	;	TI_NOK (1) on Failure
590 *
591 * \par Description
592 * This function frees (closes) a Signaling Object Handle
593 *
594 * \sa
595 */
596int os_SignalObjectFree (TI_HANDLE OsContext, void *ptr);
597
598/** \brief  OS Schedule Request
599 *
600 * \param  OsContext 	- Handle to the OS object
601 * \return TI_OK (0) on Success	;	TI_NOK (1) on Failure
602 *
603 * \par Description
604 * This function performs scheduling (context switch) according to user request
605 *
606 * \sa
607 */
608int os_RequestSchedule (TI_HANDLE OsContext);
609
610
611/****************************************************************************************
612						START OF TI DRIVER API
613*****************************************************************************************/
614
615/** \brief  OS Read Memory Register UINT32
616 *
617 * \param  OsContext 	- Handle to the OS object
618 * \param  Register		- Pointer to register address
619 * \param  Data			- Pointer to output read data
620 * \return void
621 *
622 * \par Description
623 * This function reads register in 32 bit length
624 *
625 * \sa
626 */
627void os_hwReadMemRegisterUINT32 (TI_HANDLE OsContext, TI_UINT32* Register, TI_UINT32* Data);
628
629/** \brief  OS Write Memory Register UINT32
630 *
631 * \param  OsContext 	- Handle to the OS object
632 * \param  Register		- Pointer to register address
633 * \param  Data			- Data to write to register
634 * \return void
635 *
636 * \par Description
637 * This function reads register in 32 bit length
638 *
639 * \sa
640 */
641void os_hwWriteMemRegisterUINT32 (TI_HANDLE OsContext, TI_UINT32* Register, TI_UINT32 Data);
642
643/** \brief  OS Receive Packet
644 *
645 * \param  OsContext 	- Handle to the OS object
646 * \param  pPacket 		- Pointer to received packet data
647 * \param  Length 		- Length of received packet
648 * \return TI_TRUE on Success	;	TI_FALSE on Failure
649 *
650 * \par Description
651 * This function transfers a packet from WLAN driver to OS
652 *
653 * \sa
654 */
655TI_BOOL os_receivePacket(TI_HANDLE OsContext, void *pRxDesc ,void *pPacket, TI_UINT16 Length);
656
657/** \brief  OS Indicate Event
658 *
659 * \param  OsContext 	- Handle to the OS object
660 * \param  pData 		- Pointer to event data
661 * \return TI_OK (0) on Success	;
662 *
663 * \par Description
664 * This function indicate the OS about different connection driver's events,
665 * The function performs the rewuired operations for the event - in the OS side
666 *
667 * \sa
668 */
669TI_INT32 os_IndicateEvent (TI_HANDLE OsContext, IPC_EV_DATA *pData);
670
671/** \brief  OS Send Trace Message to Logger
672 *
673 * \param  OsContext    - The OS handle
674 * \param  uLevel   	- Severity level of the trace message
675 * \param  uFileId  	- Source file ID of the trace message
676 * \param  uLineNum 	- Line number of the trace message
677 * \param  uParamsNum   - Number of parameters in the trace message
678 * \param  ...          - The trace message parameters
679 * \return void
680 *
681 * \par Description
682 * This function sends trace message to logger
683 *
684 * \sa
685 */
686void os_Trace (TI_HANDLE OsContext, TI_UINT32 uLevel, TI_UINT32 uFileId, TI_UINT32 uLineNum, TI_UINT32 uParamsNum, ...);
687
688/**
689 * \fn     os_SetDrvThreadPriority
690 * \brief  Called upon init to set WLAN driver thread priority.
691 *
692 * \param  OsContext              - The OS handle
693 * \param  uWlanDrvThreadPriority - The WLAN driver thread priority
694 * \return
695 */
696void os_SetDrvThreadPriority (TI_HANDLE OsContext, TI_UINT32 uWlanDrvThreadPriority);
697
698
699#ifdef __cplusplus
700}
701#endif
702
703#endif /* __OS_API_H__ */
704