This is the initial commit.
[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_vm.h"
53 #include "netapi_timer.h"
54 #define System_printf   printf
56 uint32_t              Osal_qmss_MallocCounter =0;
57 uint32_t              Osal_qmss_FreeCounter =0;
58 uint32_t              Osal_cppi_MallocCounter =0;
59 uint32_t              Osal_cppi_FreeCounter =0;
63 /* TODO: */
64 #define DNUM    0
66 #if 0
67 uint32_t globalCritkey;
69 /* Lock to be used for critical section */
70 pthread_mutex_t mutex_lock;
72 void nwalTest_osalInit() 
73 {
74     pthread_mutex_init(&mutex_lock, NULL);
75     return;
76 }
78 void nwalTest_osalshutdown() 
79 {
80     pthread_mutex_destroy(&mutex_lock);
81     return;
82 }
84 static inline void nwalTest_osalEnterCS()
85 {
86 #if 0
87     pthread_mutex_lock(&mutex_lock);
88 #endif 
89     return;
90 }
92 static inline void nwalTest_osalLeaveCS()
93 {
95 #if 0
96     pthread_mutex_unlock(&mutex_lock);
97 #endif
98     return;
99 }
101 #endif
103 /*****************************************************************************
104  * FUNCTION PURPOSE: Cache Invalidation Routine
105  ***************************************************************************** 
106  * DESCRIPTION: Cache Invalidation Routine
107  *****************************************************************************/
108 void Osal_invalidateCache (void *blockPtr, uint32_t size) 
110     /* Stub Function. TBD: Would need to handle when cache is enabled for ARM */
111     return;
114 /*****************************************************************************
115  * FUNCTION PURPOSE: Cache Writeback Routine
116  ***************************************************************************** 
117  * DESCRIPTION: Cache Invalidation Routine
118  *****************************************************************************/
119 void Osal_writeBackCache (void *blockPtr, uint32_t size) 
121     /* Stub Function. TBD: Would need to handle when cache is enabled for ARM */
122     return;
126 void *  Osal_qmssMtCsEnter()
128     /* Stub Function. TBD: Would need to handle when for multi proc access 
129      * To be handled once infrastructure is available from Kernel
130      */
131     return NULL;
135 void Osal_qmssMtCsExit(void *key)
137     /* Stub Function. TBD: Would need to handle when for multi proc access 
138      * To be handled once infrastructure is available from Kernel
139      */
140     return;
143 void Osal_nwalCsEnter(uint32_t *key)
145     /* Stub Function. TBD: Would need to handle when for multi proc access 
146      * To be handled once infrastructure is available from Kernel
147      */
148     return;
151 void Osal_nwalCsExit(uint32_t key)
153     /* Stub Function. TBD: Would need to handle when for multi proc access 
154      * To be handled once infrastructure is available from Kernel
155      */
156     return;
160 void Osal_qmssLog ( String fmt, ... )
165 void Osal_cppiCsEnter (uint32_t *key)
166
168     /* Stub Function. TBD: Would need to handle when for multi proc access 
169      * To be handled once infrastructure is available from Kernel
170      */
171     return;
174 void Osal_cppiCsExit (uint32_t key)
177     /* Stub Function. TBD: Would need to handle when for multi proc access 
178      * To be handled once infrastructure is available from Kernel
179      */
180     return;
183 void Osal_cppiLog ( String fmt, ... )
187 void Osal_paBeginMemAccess (Ptr addr, uint32_t size)
189     /* Stub Function. TBD: Would need to handle when for multi proc access 
190      * To be handled once infrastructure is available from Kernel
191      */
195 void Osal_paEndMemAccess (Ptr addr, uint32_t size)
196 {      
197     /* Stub Function. TBD: Would need to handle when for multi proc access 
198      * To be handled once infrastructure is available from Kernel
199      */
202 void*  Osal_qmssCsEnter ()
204     
205     /* Stub Function. TBD: Would need to handle when for multi proc access 
206      * To be handled once infrastructure is available from Kernel
207      */
208     return(NULL);
211 void Osal_qmssCsExit (void *  key)
213     /* Stub Function. TBD: Would need to handle when for multi proc access 
214      * To be handled once infrastructure is available from Kernel
215      */
216     return;
219 Ptr Osal_qmssMalloc (uint32_t num_bytes)
221     Ptr ret;
222    
223     Osal_qmss_MallocCounter++;
224     ret = malloc (num_bytes);    
225     if(ret==NULL)
226     {
227       System_printf("\nERROR! QMSS Malloc failed!\n");
228     }    
229     
230     return ret;
233 void Osal_qmssFree (Ptr ptr, uint32_t size)
235     /* Increment the free counter. */
236     Osal_qmss_FreeCounter++;    
237     free(ptr);
240 Ptr Osal_cppiMalloc (uint32_t num_bytes)
242     Ptr ret;
243     
244     Osal_cppi_MallocCounter++;
245     num_bytes += (CACHE_L2_LINESIZE-1);
246     ret = malloc (num_bytes);
248     if(ret==NULL)
249     {
250       System_printf("\nERROR! CPPI Malloc failed!\n");
251     }   
252     
253     return ret;
256 void Osal_cppiFree (Ptr ptr, uint32_t size)
258     /* Increment the free counter. */
259     Osal_cppi_FreeCounter++;    
260     free(ptr);    
263 void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)
265     Osal_invalidateCache(blockPtr,size);
266     return;
269 void  Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)
271     Osal_writeBackCache(blockPtr,size);
272     return;
275 void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)
277     Osal_invalidateCache(blockPtr,size);
278     return;
281 void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)
283     Osal_writeBackCache(blockPtr,size);
284     return;
287 void Osal_nwalInvalidateCache (void *blockPtr, uint32_t size)
289     Osal_invalidateCache(blockPtr,size);
290     return;
293 void Osal_nwalWriteBackCache (void *blockPtr, uint32_t size)
295     Osal_writeBackCache(blockPtr,size);
296     return;
299 uint32_t Osal_nwalGetCacheLineSize (void )
301     /* By default assumes L2 cache line is enabled. If not return CACHE_L1D_LINESIZE */
302     return (CACHE_L2_LINESIZE);
305 /********************************************************************
306  * FUNCTION PURPOSE: Convert local address to global
307  ********************************************************************
308  * DESCRIPTION: Returns global address
309  ********************************************************************/
311 unsigned int Osal_nwalLocToGlobAddr(unsigned int x)
313     return x;
316 uint16_t Osal_nwalGetProcId (void )
318     return DNUM;
320 uint64_t Osal_nwalGetTimeStamp(void)
322     /* Stub function to return timestamp
323      */
324     return netapi_getTimestamp();
326 #ifdef NWAL_ENABLE_SA 
327 void Osal_saCsEnter (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     ((CSL_semAcquireDirect (SA_HW_SEM)) == 0); 
333     return;
336 void Osal_saCsExit (uint32_t key)
338     /* Stub Function. TBD: Would need to handle when for multi proc access 
339      * To be handled once infrastructure is available from Kernel
340      */ 
341     return;
345 void Osal_saMtCsEnter (uint32_t *key)
347    /* Stub Function. TBD: Would need to handle when for multi proc access 
348      * To be handled once infrastructure is available from Kernel
349      */ 
350     return;
353 void Osal_saMtCsExit (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      */ 
358     return;
361 void Osal_saBeginMemAccess (void *blockPtr, uint32_t size)
363     Osal_invalidateCache(blockPtr,size);
364     return;
367 void Osal_saEndMemAccess (void *blockPtr, uint32_t size)
369     Osal_writeBackCache(blockPtr,size);
370     return;
375 void Osal_saBeginScAccess (void* addr, uint32_t size)
377    Osal_invalidateCache(addr,size);  
378         
380  
381 void Osal_saEndScAccess   (void* addr, uint32_t size)
383     Osal_writeBackCache(addr,size);
384     
387 #endif
389 void Osal_pktLibBeginMemAccess(void* ptr, uint32_t size)
391     Osal_invalidateCache(ptr,size);
395 void Osal_pktLibEndMemAccess(void* ptr, uint32_t size)
397     Osal_writeBackCache(ptr,size);
401 void Osal_pktLibBeginPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
403     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
404      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
405      * Just for testing we are always invalidating the cache here. */
407      Osal_invalidateCache(ptrPkt,size);
411 void Osal_pktLibEndPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
413     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
414      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
415      * Just for testing we are always writing back the cache here. */
417     /* Writeback the contents of the cache. */
418     Osal_writeBackCache(ptrPkt,size);
422 void* Osal_pktLibEnterCriticalSection(Pktlib_HeapHandle heapHandle)
424     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
425      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
426      * Implementations here could range from a MULTI-THREAD protection if the packets in 
427      * the heap are being accessed across multiple threads or MULTI-CORE if the packets
428      * are being accessed across multiple cores and features: split and clone are used.
429      * For NWAL layer no protection required.
430      *
431      * For testing we are not doing any of this so we are simply setting it to NOOP */
432     return NULL;
436 void  Osal_pktLibExitCriticalSection(Pktlib_HeapHandle heapHandle, void* csHandle)
438     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
439      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
440      * Implementations here could range from a MULTI-THREAD protection if the packets in 
441      * the heap are being accessed across multiple threads or MULTI-CORE if the packets
442      * are being accessed across multiple cores and features: split and clone are used.
443      * For NWAL layer no protection required.. 
444      *
445      * For testing we are not doing any of this so we are simply setting it to NOOP */
446     return;        
449 void* Osal_qmssVirtToPhy (void *ptr)
451     return (void *)(netapi_VM_mem_start_phy + ((uint8_t*)ptr - netapi_VM_mem_start));
454 void* Osal_qmssPhyToVirt (void *ptr)
456     if (!ptr) return (void *) 0;
457     //todo, see if out of range of mem_start_phy and size!! (like mmu would do)
458     return (void *)(netapi_VM_mem_start + ((uint8_t*)ptr - netapi_VM_mem_start_phy));
461 /******************************************************************************
462 * Function to traverse a CPPI descriptor and convert all address references
463 * from virtual to physical.
464 ******************************************************************************/
465 void* Osal_qmssConvertDescVirtToPhy(void *descAddr)
467     if (!descAddr) return (void *)0;
469     if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)
470     {
471         Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);
472         Cppi_HostDesc *prevBDPtr = 0;
473         while (nextBDPtr)
474         {
475             void *buffPtr;
476             if (nextBDPtr->buffPtr)
477             {
478                 buffPtr = (void *)nextBDPtr->buffPtr;
479                 nextBDPtr->buffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->buffPtr));
480                 if (!(nextBDPtr->buffPtr)) return (void *)0;
481             }
483             if (nextBDPtr->origBuffPtr)
484             {
485                 nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->origBuffPtr));
486                 if (!(nextBDPtr->origBuffPtr)) return (void *)0;
487             }
489             prevBDPtr = nextBDPtr;
490             nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));
491             if (prevBDPtr->nextBDPtr)
492             {
493                 prevBDPtr->nextBDPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(prevBDPtr->nextBDPtr));
494                 if (!(prevBDPtr->nextBDPtr)) return (void *)0;
495             }
497             Qmss_osalEndMemAccess(buffPtr, prevBDPtr->buffLen);
498             Qmss_osalEndMemAccess(prevBDPtr, sizeof(Cppi_HostDesc));
499         }
500         descAddr = Osal_qmssVirtToPhy(descAddr);
501         if (!descAddr) return (void *)0;
502     }
503     else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)
504     {
505         descAddr = Osal_qmssVirtToPhy(descAddr);
506         if (!descAddr) return (void *)0;
507     }
508     return descAddr;
513 /******************************************************************************
514 * Function to traverse a CPPI descriptor and convert all address references
515 * from physical to virtual.
516 ******************************************************************************/
517 void* Osal_qmssConvertDescPhyToVirt(void *descAddr)
519     if (!descAddr) return (void *)0;
520     descAddr = Osal_qmssPhyToVirt(descAddr);
522     if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)
523     {
524         Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);
525         while (nextBDPtr)
526         {
527             Qmss_osalBeginMemAccess(nextBDPtr, sizeof(Cppi_HostDesc));
528             if (nextBDPtr->buffPtr)
529             {
530                 nextBDPtr->buffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->buffPtr));
531                 if (!(nextBDPtr->buffPtr)) return (void *)0;
532             }
534             if (nextBDPtr->origBuffPtr)
535             {
536                 nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->origBuffPtr));
537                 if (!(nextBDPtr->origBuffPtr)) return (void *)0;
538             }
540             if (nextBDPtr->nextBDPtr)
541             {
542                 nextBDPtr->nextBDPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->nextBDPtr));
543                 if (!(nextBDPtr->nextBDPtr)) return (void *)0;
544             }
546             Qmss_osalBeginMemAccess((void *)(nextBDPtr->buffPtr), nextBDPtr->buffLen);
547             nextBDPtr = (void *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));
548         }
549     }
550     else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)
551     {
552         descAddr = Osal_qmssPhyToVirt(descAddr);
553         if (!descAddr) return (void *)0;
554     }
555     return descAddr;
558 void* Osal_stubCsEnter (void)
563 void Osal_stubCsExit (void *CsHandle)
565     /* Release Semaphore using handle */
568     return;