Update for SA LLD 1.4.1
[keystone-rtos/netapi.git] / ti / runtime / netapi / src / osal.c
1 /******************************************************************************
2  * FILE PURPOSE:  Functions to OSAL related routines for running NWAL, PA, QMSS,etc
3  ******************************************************************************
4  * FILE NAME:   osal.c
5  *
6  * DESCRIPTION: Functions to initialize framework resources for running NWAL
7  *
8  * REVISION HISTORY:
9  *
10  *  Copyright (c) Texas Instruments Incorporated 2010-2011
11  * 
12  *  Redistribution and use in source and binary forms, with or without 
13  *  modification, are permitted provided that the following conditions 
14  *  are met:
15  *
16  *    Redistributions of source code must retain the above copyright 
17  *    notice, this list of conditions and the following disclaimer.
18  *
19  *    Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the 
21  *    documentation and/or other materials provided with the   
22  *    distribution.
23  *
24  *    Neither the name of Texas Instruments Incorporated nor the names of
25  *    its contributors may be used to endorse or promote products derived
26  *    from this software without specific prior written permission.
27  *
28  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
29  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
30  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
32  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
33  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
34  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
37  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
38  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39  *
40  */
42 /* CSL RL includes */
43 #include <ti/csl/cslr_device.h>
44 #include <ti/csl/csl_pscAux.h>
45 #include <ti/csl/csl_semAux.h>
46 #include <ti/csl/csl_cacheAux.h>
47 #include <ti/csl/csl_xmcAux.h>
49 #include <stdlib.h>
50 #include <stdio.h>
52 #include "netapi_tune.h"
53 #include "netapi_vm.h"
54 #include "netapi_timer.h"
55 #include <unistd.h>
56 #include <sys/mman.h>
57 #include <sys/types.h>
58 #include <sys/stat.h>
59 #include <sys/ioctl.h>
60 #include <fcntl.h>
61 #include <errno.h>
62 #include <string.h>
63 #include "netapi_util.h"
64 #include "tools/module/netapimod.h"
65 #include <ti/drv/sa/sa_osal.h>
66 #define System_printf   printf
68 uint32_t              Osal_qmss_MallocCounter =0;
69 uint32_t              Osal_qmss_FreeCounter =0;
70 uint32_t              Osal_cppi_MallocCounter =0;
71 uint32_t              Osal_cppi_FreeCounter =0;
73 void* Osal_saGetSCPhyAddr(void* vaddr);
77 /* TODO: */
78 #define DNUM    0
80 #if 0
81 uint32_t globalCritkey;
83 /* Lock to be used for critical section */
84 pthread_mutex_t mutex_lock;
86 void nwalTest_osalInit() 
87 {
88     pthread_mutex_init(&mutex_lock, NULL);
89     return;
90 }
92 void nwalTest_osalshutdown() 
93 {
94     pthread_mutex_destroy(&mutex_lock);
95     return;
96 }
98 static inline void nwalTest_osalEnterCS()
99 {
100 #if 0
101     pthread_mutex_lock(&mutex_lock);
102 #endif 
103     return;
106 static inline void nwalTest_osalLeaveCS()
109 #if 0
110     pthread_mutex_unlock(&mutex_lock);
111 #endif
112     return;
115 #endif
119 /**********USE SPACE ACCESS TO KERNEL MEMORY SERVICES*************/
120 static int netapi_fd;
122 /***init **/
123 int netapi_utilModInit(void)
125     netapi_fd = open("/dev/netapi", O_RDWR);
127     if (netapi_fd == -1) {
128         return -1;
129     }
130     return netapi_fd;
133 /***close **/
134 void netapi_utilModClose(void)
136     close(netapi_fd);
139 /* return physical address of region kernel module has allocated for us */
140 unsigned long netapi_utilGetPhysOfBufferArea(void)
142     unsigned long physp;
144     if (ioctl(netapi_fd, NETAPIMOD_IOCGETPHYS | NETAPIMOD_IOCMAGIC, &physp) == -1) {
145         return 0;
146     }
147     return physp;
150 /* return the size of that region */
151 unsigned long netapi_utilGetSizeOfBufferArea(void)
153     unsigned long size;
155     if (ioctl(netapi_fd, NETAPIMOD_IOCGETSIZE | NETAPIMOD_IOCMAGIC, &size) == -1) {
156         return 0;
157     }
158     return size;
161 //*****for the actual wb, inv cache ops, call the osal_xxx version, not these directly
162 // (so make inline)
163 /** write back operation on block */
164 static inline int _netapi_utilCacheWb(void *ptr, size_t size)
166     struct netapimod_block block;
168     block.addr = (unsigned long)ptr;
169     block.size = size;
171     if (ioctl(netapi_fd, NETAPIMOD_IOCCACHEWB | NETAPIMOD_IOCMAGIC, &block) == -1) {
172         return -1;
173     }
174     return 0;
176 int netapi_utilCacheWb(void *ptr, size_t size) {return _netapi_utilCacheWb(ptr,size);}
178 /** write back & invalidate **/
179 static inline int _netapi_utilCacheWbInv(void *ptr, size_t size)
181     struct netapimod_block block;
183     block.addr = (unsigned long)ptr;
184     block.size = size;
186     if (ioctl(netapi_fd, NETAPIMOD_IOCCACHEWBINV | NETAPIMOD_IOCMAGIC, &block) == -1) {
187         return -1;
188     }
189     return 0;
192 int netapi_utilCacheWbInv(void *ptr, size_t size) {return _netapi_utilCacheWbInv(ptr,size);}
193 /** just invalidate **/
194 static inline int _netapi_utilCacheInv(void *ptr, size_t size)
196     struct netapimod_block block;
198     block.addr = (unsigned long)ptr;
199     block.size = size;
201     if (ioctl(netapi_fd, NETAPIMOD_IOCCACHEINV | NETAPIMOD_IOCMAGIC, &block) == -1) {
202         return -1;
203     }
204     return 0;
206 int netapi_utilCacheInv(void *ptr, size_t size) {return _netapi_utilCacheInv(ptr,size);}
208 //***mmap the block into our user space process memory map.  */
209 unsigned long netapi_utilGetVaOfBufferArea(unsigned int offset, unsigned int size)
211     void *userp;
213     /* Map the physical address to user space */
214     userp = mmap(0,                       // Preferred start address
215                  size,            // Length to be mapped
216                  PROT_WRITE | PROT_READ,  // Read and write access
217                  MAP_SHARED,              // Shared memory
218                  netapi_fd,               // File descriptor
219                  offset);                      // The byte offset from fd
221     if (userp == MAP_FAILED) {
222         return 0;
223     }
224     return (unsigned long)userp;
227 static unsigned int cache_op_cycles=0;
228 static unsigned int n_cache_op_cycles=0;
229 void Osal_cache_op_measure_reset(void) { cache_op_cycles=0; n_cache_op_cycles=0;}
230 /*****************************************************************************
231  * FUNCTION PURPOSE: Cache Invalidation Routine
232  ***************************************************************************** 
233  * DESCRIPTION: Cache Invalidation Routine
234  *****************************************************************************/
235 static inline void Osal_invalidateCache (void *blockPtr, uint32_t size) 
237 #ifdef NETAPI_TUNE_USE_CACHE_OPS
238     register unsigned int v1;
239     register unsigned int v2;
240      
241     v1= netapi_timing_stop();
242     if (((uint8_t*)blockPtr <netapi_VM_mem_start)||( (uint8_t*)blockPtr>netapi_VM_mem_end)) return;
243     _netapi_utilCacheInv(blockPtr, size);
244     v2= netapi_timing_stop();
245     cache_op_cycles += (v2-v1); 
246     n_cache_op_cycles+=1;
247 #endif
249     return;
252 /*****************************************************************************
253  * FUNCTION PURPOSE: Cache Writeback Routine
254  ***************************************************************************** 
255  * DESCRIPTION: Cache Invalidation Routine
256  *****************************************************************************/
257 /* stats */
259 unsigned int Osal_cache_op_measure(int * p_n) { *p_n = n_cache_op_cycles;  return cache_op_cycles;}
261 static inline void Osal_writeBackCache (void *blockPtr, uint32_t size) 
263 #ifdef NETAPI_TUNE_USE_CACHE_OPS
264     register unsigned int v1;
265     register unsigned int v2;
266      
267     v1= netapi_timing_stop();
268     if (((uint8_t*)blockPtr <netapi_VM_mem_start)||( (uint8_t*)blockPtr>netapi_VM_mem_end)) return;
269     _netapi_utilCacheWbInv(blockPtr, size);
270     v2= netapi_timing_stop();
271     cache_op_cycles += (v2-v1); 
272     n_cache_op_cycles+=1;
273 #endif
274     return;
278 void *  Osal_qmssMtCsEnter()
280     /* Stub Function. TBD: Would need to handle when for multi proc access 
281      * To be handled once infrastructure is available from Kernel
282      */
283     return NULL;
287 void Osal_qmssMtCsExit(void *key)
289     /* Stub Function. TBD: Would need to handle when for multi proc access 
290      * To be handled once infrastructure is available from Kernel
291      */
292     return;
295 void Osal_nwalCsEnter(uint32_t *key)
297     /* Stub Function. TBD: Would need to handle when for multi proc access 
298      * To be handled once infrastructure is available from Kernel
299      */
300     return;
303 void Osal_nwalCsExit(uint32_t key)
305     /* Stub Function. TBD: Would need to handle when for multi proc access 
306      * To be handled once infrastructure is available from Kernel
307      */
308     return;
312 void Osal_qmssLog ( String fmt, ... )
317 void Osal_cppiCsEnter (uint32_t *key)
318
320     /* Stub Function. TBD: Would need to handle when for multi proc access 
321      * To be handled once infrastructure is available from Kernel
322      */
323     return;
326 void Osal_cppiCsExit (uint32_t key)
329     /* Stub Function. TBD: Would need to handle when for multi proc access 
330      * To be handled once infrastructure is available from Kernel
331      */
332     return;
335 void Osal_cppiLog ( String fmt, ... )
339 void Osal_paBeginMemAccess (Ptr addr, uint32_t size)
341     /* Stub Function. TBD: Would need to handle when for multi proc access 
342      * To be handled once infrastructure is available from Kernel
343      */
347 void Osal_paEndMemAccess (Ptr addr, uint32_t size)
348 {      
349     /* Stub Function. TBD: Would need to handle when for multi proc access 
350      * To be handled once infrastructure is available from Kernel
351      */
353 void Osal_paMtCsEnter (uint32_t *key)
355     /* Stub Function. TBD: Would need to handle when for multi proc access 
356      * To be handled once infrastructure is available from Kernel
357      */
359 void Osal_paMtCsExit (uint32_t key)
361     /* Stub Function. TBD: Would need to handle when for multi proc access 
362      * To be handled once infrastructure is available from Kernel
363      */
367 void*  Osal_qmssCsEnter ()
369     
370     /* Stub Function. TBD: Would need to handle when for multi proc access 
371      * To be handled once infrastructure is available from Kernel
372      */
373     return(NULL);
376 void Osal_qmssCsExit (void *  key)
378     /* Stub Function. TBD: Would need to handle when for multi proc access 
379      * To be handled once infrastructure is available from Kernel
380      */
381     return;
384 Ptr Osal_qmssMalloc (uint32_t num_bytes)
386     Ptr ret;
387    
388     Osal_qmss_MallocCounter++;
389     ret = malloc (num_bytes);    
390     if(ret==NULL)
391     {
392       System_printf("\nERROR! QMSS Malloc failed!\n");
393     }    
394     
395     return ret;
398 void Osal_qmssFree (Ptr ptr, uint32_t size)
400     /* Increment the free counter. */
401     Osal_qmss_FreeCounter++;    
402     free(ptr);
405 Ptr Osal_cppiMalloc (uint32_t num_bytes)
407     Ptr ret;
408     
409     Osal_cppi_MallocCounter++;
410     num_bytes += (CACHE_L2_LINESIZE-1);
411     ret = malloc (num_bytes);
413     if(ret==NULL)
414     {
415       System_printf("\nERROR! CPPI Malloc failed!\n");
416     }   
417     
418     return ret;
421 void Osal_cppiFree (Ptr ptr, uint32_t size)
423     /* Increment the free counter. */
424     Osal_cppi_FreeCounter++;    
425     free(ptr);    
428 void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)
430     //Osal_invalidateCache(blockPtr,size);
431     return;
434 void  Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)
436     //Osal_writeBackCache(blockPtr,size);
437     return;
440 void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)
442     //Osal_invalidateCache(blockPtr,size);
443     return;
446 void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)
448     //Osal_writeBackCache(blockPtr,size);
449     return;
452 void Osal_nwalInvalidateCache (void *blockPtr, uint32_t size)
454     //Osal_invalidateCache(blockPtr,size);
455     return;
458 void Osal_nwalWriteBackCache (void *blockPtr, uint32_t size)
460     //Osal_writeBackCache(blockPtr,size);
461     return;
464 uint32_t Osal_nwalGetCacheLineSize (void )
466     /* By default assumes L2 cache line is enabled. If not return CACHE_L1D_LINESIZE */
467     return (CACHE_L2_LINESIZE);
470 /********************************************************************
471  * FUNCTION PURPOSE: Convert local address to global
472  ********************************************************************
473  * DESCRIPTION: Returns global address
474  ********************************************************************/
476 unsigned int Osal_nwalLocToGlobAddr(unsigned int x)
478     return x;
481 uint16_t Osal_nwalGetProcId (void )
483     return DNUM;
485 uint64_t Osal_nwalGetTimeStamp(void)
487     /* Stub function to return timestamp
488      */
489     return netapi_getTimestamp();
492 uint16_t Osal_saGetProcId (void )
494     return 0;
497 void* Osal_saGetSCPhyAddr(void* vaddr)
499     if(vaddr == NULL)
500     {
501         return NULL;
502     }
503     return (void *)(netapi_VM_mem_start_phy + ((uint8_t*) vaddr - netapi_VM_mem_start));
507 void Osal_saBeginScAccess (void* addr, uint32_t size)
509    Osal_invalidateCache(addr,size);
513 void Osal_saEndScAccess   (void* addr, uint32_t size)
515     Osal_writeBackCache(addr,size);
520 void Osal_saCsEnter (uint32_t *key)
522     /* Stub Function. TBD: Would need to handle when for multi proc access 
523      * To be handled once infrastructure is available from Kernel
524      */ 
525     //((CSL_semAcquireDirect (SA_HW_SEM)) == 0); 
526     return;
529 void Osal_saCsExit (uint32_t key)
531     /* Stub Function. TBD: Would need to handle when for multi proc access 
532      * To be handled once infrastructure is available from Kernel
533      */ 
534     return;
538 void Osal_saMtCsEnter (uint32_t *key)
540    /* Stub Function. TBD: Would need to handle when for multi proc access 
541      * To be handled once infrastructure is available from Kernel
542      */ 
543     return;
546 void Osal_saMtCsExit (uint32_t key)
548     /* Stub Function. TBD: Would need to handle when for multi proc access 
549      * To be handled once infrastructure is available from Kernel
550      */ 
551     return;
554 void Osal_saBeginMemAccess (void *blockPtr, uint32_t size)
556     Osal_invalidateCache(blockPtr,size);
557     return;
560 void Osal_saEndMemAccess (void *blockPtr, uint32_t size)
562     Osal_writeBackCache(blockPtr,size);
563     return;
566 int   Osal_saGetSysEndianMode(void)
568 #if defined( _BIG_ENDIAN ) 
569     return((int)sa_SYS_ENDIAN_MODE_BIG);
570 #else
571     return((int)sa_SYS_ENDIAN_MODE_LITTLE);
572 #endif
575 void Osal_pktLibBeginMemAccess(void* ptr, uint32_t size)
577     //Osal_invalidateCache(ptr,size);
581 void Osal_pktLibEndMemAccess(void* ptr, uint32_t size)
583     //Osal_writeBackCache(ptr,size);
587 void Osal_pktLibBeginPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
589     Osal_invalidateCache(ptrPkt,size);
593 void Osal_pktLibEndPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
594 {    
596     /* Cache Write back for the packet. Currently being disabled as it will be done during
597      * QMSS Push operation
598      
599     Osal_writeBackCache((void *)ptrPkt,size);
600     */
604 void* Osal_pktLibEnterCriticalSection(Pktlib_HeapHandle heapHandle)
606     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
607      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
608      * Implementations here could range from a MULTI-THREAD protection if the packets in 
609      * the heap are being accessed across multiple threads or MULTI-CORE if the packets
610      * are being accessed across multiple cores and features: split and clone are used.
611      * For NWAL layer no protection required.
612      *
613      * For testing we are not doing any of this so we are simply setting it to NOOP */
614     return NULL;
618 void  Osal_pktLibExitCriticalSection(Pktlib_HeapHandle heapHandle, void* csHandle)
620     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
621      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
622      * Implementations here could range from a MULTI-THREAD protection if the packets in 
623      * the heap are being accessed across multiple threads or MULTI-CORE if the packets
624      * are being accessed across multiple cores and features: split and clone are used.
625      * For NWAL layer no protection required.. 
626      *
627      * For testing we are not doing any of this so we are simply setting it to NOOP */
628     return;        
632 void* Osal_pktLibPhyToVirt(void *ptr)
634     return(_Osal_qmssPhyToVirt(ptr));
637 void* Osal_qmssVirtToPhy (void *ptr)
639     return _Osal_qmssVirtToPhy(ptr);
642 void * Osal_qmssPhyToVirt (void *ptr)
644     return _Osal_qmssPhyToVirt(ptr);
647 /******************************************************************************
648 * Function to traverse a CPPI descriptor and convert all address references
649 * from virtual to physical.
650 ******************************************************************************/
651 //#define ASSUME_ALL_DESCRIPTOR   //define this if mono and host descriptors are present, else don't
652                                   //define and just host will be assumed (more efficient)
653 void* Osal_qmssConvertDescVirtToPhy(void *descAddr)
655     if (!descAddr) return (void *)0;
656 #ifdef ASSUME_ALL_DESCRIPTOR 
657     if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)
658 #endif
659     {
660         Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);
661         Cppi_HostDesc *prevBDPtr = 0;
662         while (nextBDPtr)
663         {
664             void *buffPtr=NULL;
665             if (nextBDPtr->buffPtr)
666             {
667                 buffPtr = (void *)nextBDPtr->buffPtr;
668                 nextBDPtr->buffPtr = (uint32_t)_Osal_qmssVirtToPhy((void *)(nextBDPtr->buffPtr));
669                 if (!(nextBDPtr->buffPtr)) return (void *)0;
670                 Osal_writeBackCache(buffPtr, nextBDPtr->buffLen);          
671             }
673             if (nextBDPtr->origBuffPtr)
674             {
675                 nextBDPtr->origBuffPtr = (uint32_t)_Osal_qmssVirtToPhy((void *)(nextBDPtr->origBuffPtr));
676                 if (!(nextBDPtr->origBuffPtr)) return (void *)0;
677             }
679             prevBDPtr = nextBDPtr;
680             nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));
681             if (prevBDPtr->nextBDPtr)
682             {
683                 prevBDPtr->nextBDPtr = (uint32_t)_Osal_qmssVirtToPhy((void *)(prevBDPtr->nextBDPtr));
684                 if (!(prevBDPtr->nextBDPtr)) return (void *)0;
685             }
687             Osal_writeBackCache(prevBDPtr, TUNE_NETAPI_DESC_SIZE);
688         }
689         descAddr = _Osal_qmssVirtToPhy(descAddr);
690         if (!descAddr) return (void *)0;
691     }
692 #ifdef ASSUME_ALL_DESCRIPTOR 
693     else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)
694     {
695         Osal_writeBackCache(descAddr, TUNE_NETAPI_DESC_SIZE);
696         descAddr = _Osal_qmssVirtToPhy(descAddr);
697         if (!descAddr) return (void *)0;
698     }
699 #endif
700     return descAddr;
705 /******************************************************************************
706 * Function to traverse a CPPI descriptor and convert all address references
707 * from physical to virtual.
708 ******************************************************************************/
709 void* Osal_qmssConvertDescPhyToVirt(void *descAddr)
711     if (!descAddr) return (void *)0;
712     descAddr = _Osal_qmssPhyToVirt(descAddr);
714 #ifdef ASSUME_ALL_DESCRIPTOR 
715     if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)
716 #endif
717     {
718         Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);
719         while (nextBDPtr)
720         {
721             Osal_invalidateCache(nextBDPtr, TUNE_NETAPI_DESC_SIZE);
722             if (nextBDPtr->buffPtr)
723             {
724                 nextBDPtr->buffPtr = (uint32_t)_Osal_qmssPhyToVirt((void *)(nextBDPtr->buffPtr));
725                 if (!(nextBDPtr->buffPtr)) return (void *)0;
726                 Osal_invalidateCache((void *)(nextBDPtr->buffPtr), nextBDPtr->buffLen);
727             }
729             if (nextBDPtr->origBuffPtr)
730             {
731                 nextBDPtr->origBuffPtr = (uint32_t)_Osal_qmssPhyToVirt((void *)(nextBDPtr->origBuffPtr));
732                 if (!(nextBDPtr->origBuffPtr)) return (void *)0;
733             }
735             if (nextBDPtr->nextBDPtr)
736             {
737                 nextBDPtr->nextBDPtr = (uint32_t)_Osal_qmssPhyToVirt((void *)(nextBDPtr->nextBDPtr));
738                 if (!(nextBDPtr->nextBDPtr)) return (void *)0;
739             }
741             nextBDPtr = (void *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));
742         }
743     }
744 #ifdef ASSUME_ALL_DESCRIPTOR 
745     else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)
746     {
747         descAddr = _Osal_qmssPhyToVirt(descAddr);
748         if (!descAddr) return (void *)0;
749         Osal_invalidateCache(descAddr, TUNE_NETAPI_DESC_SIZE);
750     }
751 #endif
752     return descAddr;
755 void* Osal_stubCsEnter (void)
760 void Osal_stubCsExit (void *CsHandle)
762     /* Release Semaphore using handle */
765     return;