Add stub functions for Osal_qmssAccCsEnter and Osal_qmssAccCsExit
[keystone-rtos/netapi.git] / ti / runtime / hplib / 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 #ifndef DISABLE_OSAL
44 /* CSL RL includes */
45 #include <ti/csl/csl_cache.h>
47 #include <stdlib.h>
48 #include <stdio.h>
50 #include "hplib.h"
51 #include <unistd.h>
52 #include <sys/mman.h>
53 #include <sys/types.h>
54 #include <sys/stat.h>
55 #include <sys/ioctl.h>
56 #include <fcntl.h>
57 #include <errno.h>
58 #include <string.h>
59 //#include "netapi_util.h"
60 #include "hplibmod.h"
61 #include <ti/drv/sa/sa_osal.h>
62 #include <ti/runtime/pktlib/pktlib.h>
64 typedef struct osal_shm_Tag
65 {
66     hplib_spinLock_T qmss_lock;
67     hplib_spinLock_T nwal_lock;
68     hplib_spinLock_T hplib_lock;
69     hplib_spinLock_T cppi_lock;
70     hplib_spinLock_T sa_lock;
71     hplib_spinLock_T pktlib_lock;
72     int init_done;
73 } osal_shm_T;
75 void* pBase = NULL;
76 osal_shm_T* posalShm;
78 uint32_t              Osal_qmss_MallocCounter =0;
79 uint32_t              Osal_qmss_FreeCounter =0;
80 uint32_t              Osal_cppi_MallocCounter =0;
81 uint32_t              Osal_cppi_FreeCounter =0;
83 static __thread int our_core = 0;
84 static __thread HPLIB_SPINLOCK_IF_T* p_lock_if;
86 void* Osal_saGetSCPhyAddr(void* vaddr);
88 static unsigned int cache_op_cycles=0;
89 static unsigned int n_cache_op_cycles=0;
90 void Osal_cache_op_measure_reset(void) { cache_op_cycles=0; n_cache_op_cycles=0;}
91 unsigned int Osal_cache_op_measure(unsigned long long * p_n) { *p_n = n_cache_op_cycles;  return cache_op_cycles;}
93 HPLIB_SPINLOCK_IF_T lock_if_lol =
94 {
95     hplib_mSpinLockInit,
96     hplib_mSpinLockTryLock,
97     hplib_mSpinLockIsLocked,
98     hplib_mSpinLockLock,
99     hplib_mSpinLockUnlock,
100     hplib_mRWLockInit,
101     hplib_mRWLockWriteLock,
102     hplib_mRWLockWriteUnlock,
103     hplib_mRWLockReadLock,
104     hplib_mRWLockReadUnlock
105 };
107 HPLIB_SPINLOCK_IF_T lock_if_mp =
109     hplib_mSpinLockInit,
110     hplib_mSpinLockTryLock,
111     hplib_mSpinLockIsLocked,
112     hplib_mSpinLockLockMP,
113     hplib_mSpinLockUnlockMP,
114     hplib_mRWLockInit,
115     hplib_mRWLockWriteLockMP,
116     hplib_mRWLockWriteUnlockMP,
117     hplib_mRWLockReadLockMP,
118     hplib_mRWLockReadUnlockMP
119 };
121 /* This is called 1 Time per system boot by the global master process */
122 hplib_RetValue hplib_utilOsalCreate()
124     hplib_RetValue retVal = hplib_OK;
125     pBase = hplib_shmOpen();
127     if ((retVal = hplib_shmAddEntry(pBase, sizeof(osal_shm_T), OSAL_ENTRY)) !=
128         hplib_OK)
129     {
130         hplib_Log("hplib_utilOsalCreate: hplib_shmAddEntry failed for OSAL_ENTRY\n");
131         return retVal;
132     }
133     else
134     {
135         posalShm = (osal_shm_T*)hplib_shmGetEntry(pBase, OSAL_ENTRY);
136         posalShm->init_done = 0;
137     }
139     posalShm = (osal_shm_T*)hplib_shmGetEntry(pBase, OSAL_ENTRY);
141     posalShm->qmss_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
142     posalShm->nwal_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
143     posalShm->hplib_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
144     posalShm->cppi_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
145     posalShm->sa_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
146     posalShm->pktlib_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
148     posalShm->init_done = 1;
149     return retVal;
152 /* This can be called for every other process which is NOT the global master process */
153 hplib_RetValue Osal_start(void *pShmBase)
155     if (!pBase)
156         pBase = pShmBase;
158     posalShm = (osal_shm_T*)hplib_shmGetEntry(pBase, OSAL_ENTRY);
159     if (posalShm)
160     {
161         if(posalShm->init_done)
162             return hplib_OK;
163     }
164     return hplib_FAILURE;
167 void *  Osal_qmssMtCsEnter()
169     p_lock_if->lock(&posalShm->qmss_lock);
170     return NULL;
174 void Osal_qmssMtCsExit(void *key)
176     p_lock_if->unlock(&posalShm->qmss_lock);
177     return;
180 void* Osal_qmssAccCsEnter (void)
182     return NULL;
184 void Osal_qmssAccCsExit (void *CsHandle)
186     return;
188 void Osal_nwalCsEnter(uint32_t *key)
190     p_lock_if->lock(&posalShm->nwal_lock);
193 void Osal_nwalCsExit(uint32_t key)
195     p_lock_if->unlock(&posalShm->nwal_lock);
198 void Osal_qmssLog ( String fmt, ... )
200     return;
204 void Osal_cppiCsEnter (uint32_t *key)
206     p_lock_if->lock(&posalShm->cppi_lock);
209 void Osal_cppiCsExit (uint32_t key)
211     p_lock_if->unlock(&posalShm->cppi_lock);
214 void Osal_paBeginMemAccess (Ptr addr, uint32_t size)
216     /*No implementation required for ARM*/
219 void Osal_paEndMemAccess (Ptr addr, uint32_t size)
220 {      
221     /*No implementation required for ARM*/
223 void Osal_paMtCsEnter (uint32_t *key)
225     /*No implementation required for ARM*/
227 void Osal_paMtCsExit (uint32_t key)
229     /*No implementation required for ARM*/
232 void*  Osal_qmssCsEnter ()
234     p_lock_if->lock(&posalShm->qmss_lock);
235     return NULL;
238 void Osal_qmssCsExit (void *  key)
240     p_lock_if->unlock(&posalShm->qmss_lock);
243 Ptr Osal_qmssMalloc (uint32_t num_bytes)
245     Ptr ret;
247     Osal_qmss_MallocCounter++;
248     ret = malloc (num_bytes);
249     return ret;
252 void Osal_qmssFree (Ptr ptr, uint32_t size)
254     /* Increment the free counter. */
255     Osal_qmss_FreeCounter++;    
256     free(ptr);
259 Ptr Osal_cppiMalloc (uint32_t num_bytes)
261     Ptr ret;
262     
263     Osal_cppi_MallocCounter++;
264     //num_bytes += (CACHE_L2_LINESIZE-1);
265         num_bytes += (127);
266     ret = malloc (num_bytes);
267     return ret;
270 void Osal_cppiFree (Ptr ptr, uint32_t size)
272     /* Increment the free counter. */
273     Osal_cppi_FreeCounter++;    
274     free(ptr);    
277 void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)
279     return;
282 void  Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)
284     return;
287 void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)
289     return;
292 void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)
294     return;
297 void Osal_nwalInvalidateCache (void *blockPtr, uint32_t size)
299     return;
302 void Osal_nwalWriteBackCache (void *blockPtr, uint32_t size)
304     return;
307 uint32_t Osal_nwalGetCacheLineSize (void )
309     /* By default assumes L2 cache line is enabled. If not return CACHE_L1D_LINESIZE */
310     return (CACHE_L2_LINESIZE);
313 /********************************************************************
314  * FUNCTION PURPOSE: Convert local address to global
315  ********************************************************************
316  * DESCRIPTION: Returns global address
317  ********************************************************************/
319 unsigned int Osal_nwalLocToGlobAddr(unsigned int x)
321     return x;
325 void Osal_nwalSetProcId (uint16_t core_id )
327     our_core = core_id;
332 void Osal_setHplibSpinLockIfType(hplib_spinLock_Type if_type )
334     if (if_type == hplib_spinLock_Type_MP)
335         p_lock_if = &lock_if_mp;
336     else
337         p_lock_if = &lock_if_lol;
339 uint16_t Osal_nwalGetProcId (void )
341     return our_core;
344 uint64_t Osal_nwalGetTimeStamp(void)
346     return hplib_mUtilGetTimestamp();
349 uint16_t Osal_saGetProcId (void )
351     return 0;
354 void* Osal_saGetSCPhyAddr(void* vaddr)
356     if(vaddr == NULL)
357     {
358         return NULL;
359     }
360     return (void *)(memPoolAddr[0].memStartPhy + ((uint8_t*) vaddr - memPoolAddr[0].memStart));
363 void Osal_saBeginScAccess (void* addr, uint32_t size)
365     hplib_cacheInv(addr,size);
368 void Osal_saEndScAccess   (void* addr, uint32_t size)
370     hplib_cacheWb(addr,size);
374 void Osal_saCsEnter (uint32_t *key)
376     p_lock_if->lock(&posalShm->sa_lock);
379 void Osal_saCsExit (uint32_t key)
381     p_lock_if->unlock(&posalShm->sa_lock);
385 void Osal_saMtCsEnter (uint32_t *key)
387     p_lock_if->lock(&posalShm->sa_lock);
390 void Osal_saMtCsExit (uint32_t key)
392     p_lock_if->unlock(&posalShm->sa_lock);
395 void Osal_saBeginMemAccess (void *blockPtr, uint32_t size)
397     /*  not required on ARM */
398     /*Osal_invalidateCache(blockPtr,size); */
401 void Osal_saEndMemAccess (void *blockPtr, uint32_t size)
403     /*  not required on ARM */
404     /*  Osal_writeBackCache(blockPtr,size); */
407 int   Osal_saGetSysEndianMode(void)
409 #if defined( _BIG_ENDIAN ) 
410     return((int)sa_SYS_ENDIAN_MODE_BIG);
411 #else
412     return((int)sa_SYS_ENDIAN_MODE_LITTLE);
413 #endif
416 void Osal_pktLibBeginMemAccess(void* ptr, uint32_t size)
418     //Osal_invalidateCache(ptr,size);
422 void Osal_pktLibEndMemAccess(void* ptr, uint32_t size)
424     //Osal_writeBackCache(ptr,size);
428 void Osal_pktLibBeginPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
430     /*  not required on ARM */
431     /* Osal_invalidateCache(ptrPkt,size); */
435 void Osal_pktLibEndPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
436 {    
438     /* Cache Write back for the packet. Currently being disabled as it will be done during
439      * QMSS Push operation
440      
441     Osal_writeBackCache((void *)ptrPkt,size);
442     */
446 void* Osal_pktLibEnterCriticalSection(Pktlib_HeapHandle heapHandle)
448     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
449      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
450      * Implementations here could range from a MULTI-THREAD protection if the packets in 
451      * the heap are being accessed across multiple threads or MULTI-CORE if the packets
452      * are being accessed across multiple cores and features: split and clone are used.
453      * For NWAL layer no protection required.
454      *
455      * For testing we are not doing any of this so we are simply setting it to NOOP */
456     p_lock_if->lock(&posalShm->pktlib_lock);
457     return NULL;
461 void  Osal_pktLibExitCriticalSection(Pktlib_HeapHandle heapHandle, void* csHandle)
463     /* TODO: We should use the 'heapHandle' and compare it with what we got from the
464      * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
465      * Implementations here could range from a MULTI-THREAD protection if the packets in 
466      * the heap are being accessed across multiple threads or MULTI-CORE if the packets
467      * are being accessed across multiple cores and features: split and clone are used.
468      * For NWAL layer no protection required.. 
469      *
470      * For testing we are not doing any of this so we are simply setting it to NOOP */
471     p_lock_if->unlock(&posalShm->pktlib_lock);
472     return;
475 void* Osal_pktLibPhyToVirt(void *ptr)
477     return(hplib_mVMPhyToVirt(ptr));
480 void* Osal_qmssVirtToPhy (void *ptr)
482     return hplib_mVMVirtToPhy(ptr);
485 void * Osal_qmssPhyToVirt (void *ptr)
487     return hplib_mVMPhyToVirt(ptr);
490 /******************************************************************************
491 * Function to traverse a CPPI descriptor and convert all address references
492 * from virtual to physical.
493 ******************************************************************************/
494 //#define ASSUME_ALL_DESCRIPTOR   //define this if mono and host descriptors are present, else don't
495                                   //define and just host will be assumed (more efficient)
496 void* Osal_qmssConvertDescVirtToPhy(uint32_t QID, void *descAddr)
498     return hplib_mVMConvertDescVirtToPhy(descAddr);
500 /******************************************************************************
501 * Function to traverse a CPPI descriptor and convert all address references
502 * from physical to virtual.
503 ******************************************************************************/
504 void* Osal_qmssConvertDescPhyToVirt(uint32_t QID, void *descAddr)
506     return hplib_mVMConvertDescPhyToVirt(descAddr);
508 void* Osal_stubCsEnter (void)
510     return NULL;
512 void Osal_stubCsExit (void *CsHandle)
514     return;
517 /* Internal Function used by hplib */
518 void* Osal_hplibCsEnter (void)
520     p_lock_if->lock(&posalShm->hplib_lock);
521     return NULL;
523 /* Internal Function used by hplib */
525 void Osal_hplibCsExit (void *CsHandle)
527     p_lock_if->unlock(&posalShm->hplib_lock);
528     return;
530 #endif