. changes for ddr cache
[keystone-rtos/netapi.git] / ti / runtime / netapi / src / osal.c
1 /******************************************************************************\r
2  * FILE PURPOSE:  Functions to OSAL related routines for running NWAL, PA, QMSS,etc\r
3  ******************************************************************************\r
4  * FILE NAME:   osal.c\r
5  *\r
6  * DESCRIPTION: Functions to initialize framework resources for running NWAL\r
7  *\r
8  * REVISION HISTORY:\r
9  *\r
10  *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
11  * \r
12  *  Redistribution and use in source and binary forms, with or without \r
13  *  modification, are permitted provided that the following conditions \r
14  *  are met:\r
15  *\r
16  *    Redistributions of source code must retain the above copyright \r
17  *    notice, this list of conditions and the following disclaimer.\r
18  *\r
19  *    Redistributions in binary form must reproduce the above copyright\r
20  *    notice, this list of conditions and the following disclaimer in the \r
21  *    documentation and/or other materials provided with the   \r
22  *    distribution.\r
23  *\r
24  *    Neither the name of Texas Instruments Incorporated nor the names of\r
25  *    its contributors may be used to endorse or promote products derived\r
26  *    from this software without specific prior written permission.\r
27  *\r
28  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
29  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
30  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
31  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
32  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
33  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
34  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
35  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
36  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
37  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
38  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
39  *\r
40  */\r
41 \r
42 /* CSL RL includes */\r
43 #include <ti/csl/cslr_device.h>\r
44 #include <ti/csl/csl_pscAux.h>\r
45 #include <ti/csl/csl_semAux.h>\r
46 #include <ti/csl/csl_cacheAux.h>\r
47 #include <ti/csl/csl_xmcAux.h>\r
48 \r
49 #include <stdlib.h>\r
50 #include <stdio.h>\r
51 \r
52 #include "netapi_tune.h"\r
53 #include "netapi_vm.h"\r
54 #include "netapi_timer.h"\r
55 #include <unistd.h>\r
56 #include <sys/mman.h>\r
57 #include <sys/types.h>\r
58 #include <sys/stat.h>\r
59 #include <sys/ioctl.h>\r
60 #include <fcntl.h>\r
61 #include <errno.h>\r
62 #include <string.h>\r
63 #include "netapi_util.h"\r
64 #include "tools/module/netapimod.h"\r
65 #define System_printf   printf\r
66 \r
67 uint32_t              Osal_qmss_MallocCounter =0;\r
68 uint32_t              Osal_qmss_FreeCounter =0;\r
69 uint32_t              Osal_cppi_MallocCounter =0;\r
70 uint32_t              Osal_cppi_FreeCounter =0;\r
71 \r
72 void* Osal_saGetSCPhyAddr(void* vaddr);\r
73 \r
74 \r
75 \r
76 /* TODO: */\r
77 #define DNUM    0\r
78 \r
79 #if 0\r
80 uint32_t globalCritkey;\r
81 \r
82 /* Lock to be used for critical section */\r
83 pthread_mutex_t mutex_lock;\r
84 \r
85 void nwalTest_osalInit() \r
86 {\r
87     pthread_mutex_init(&mutex_lock, NULL);\r
88     return;\r
89 }\r
90 \r
91 void nwalTest_osalshutdown() \r
92 {\r
93     pthread_mutex_destroy(&mutex_lock);\r
94     return;\r
95 }\r
96 \r
97 static inline void nwalTest_osalEnterCS()\r
98 {\r
99 #if 0\r
100     pthread_mutex_lock(&mutex_lock);\r
101 #endif \r
102     return;\r
103 }\r
104 \r
105 static inline void nwalTest_osalLeaveCS()\r
106 {\r
107 \r
108 #if 0\r
109     pthread_mutex_unlock(&mutex_lock);\r
110 #endif\r
111     return;\r
112 }\r
113 \r
114 #endif\r
115 \r
116 /**********USE SPACE ACCESS TO KERNEL MEMORY SERVICES*************/\r
117 static int netapi_fd;\r
118 \r
119 /***init **/\r
120 int netapi_utilModInit(void)\r
121 {\r
122     netapi_fd = open("/dev/netapi", O_RDWR);\r
123 \r
124     if (netapi_fd == -1) {\r
125         return -1;\r
126     }\r
127     return netapi_fd;\r
128 }\r
129 \r
130 /***close **/\r
131 void netapi_utilModClose(void)\r
132 {\r
133     close(netapi_fd);\r
134 }\r
135 \r
136 /* return physical address of region kernel module has allocated for us */\r
137 unsigned long netapi_utilGetPhysOfBufferArea(void)\r
138 {\r
139     unsigned long physp;\r
140 \r
141     if (ioctl(netapi_fd, NETAPIMOD_IOCGETPHYS | NETAPIMOD_IOCMAGIC, &physp) == -1) {\r
142         return 0;\r
143     }\r
144     return physp;\r
145 }\r
146 \r
147 /* return the size of that region */\r
148 unsigned long netapi_utilGetSizeOfBufferArea(void)\r
149 {\r
150     unsigned long size;\r
151 \r
152     if (ioctl(netapi_fd, NETAPIMOD_IOCGETSIZE | NETAPIMOD_IOCMAGIC, &size) == -1) {\r
153         return 0;\r
154     }\r
155     return size;\r
156 }\r
157 \r
158 //*****for the actual wb, inv cache ops, call the osal_xxx version, not these directly\r
159 // (so make inline)\r
160 /** write back operation on block */\r
161 static inline int netapi_utilCacheWb(void *ptr, size_t size)\r
162 {\r
163     struct netapimod_block block;\r
164 \r
165     block.addr = (unsigned long)ptr;\r
166     block.size = size;\r
167 \r
168     if (ioctl(netapi_fd, NETAPIMOD_IOCCACHEWB | NETAPIMOD_IOCMAGIC, &block) == -1) {\r
169         return -1;\r
170     }\r
171     return 0;\r
172 }\r
173 \r
174 /** write back & invalidate **/\r
175 int netapi_utilCacheWbInv(void *ptr, size_t size)\r
176 {\r
177     struct netapimod_block block;\r
178 \r
179     block.addr = (unsigned long)ptr;\r
180     block.size = size;\r
181 \r
182     if (ioctl(netapi_fd, NETAPIMOD_IOCCACHEWBINV | NETAPIMOD_IOCMAGIC, &block) == -1) {\r
183         return -1;\r
184     }\r
185     return 0;\r
186 }\r
187 \r
188 /** just invalidate **/\r
189 static inline int netapi_utilCacheInv(void *ptr, size_t size)\r
190 {\r
191     struct netapimod_block block;\r
192 \r
193     block.addr = (unsigned long)ptr;\r
194     block.size = size;\r
195 \r
196     if (ioctl(netapi_fd, NETAPIMOD_IOCCACHEINV | NETAPIMOD_IOCMAGIC, &block) == -1) {\r
197         return -1;\r
198     }\r
199     return 0;\r
200 }\r
201 \r
202 //***mmap the block into our user space process memory map.  */\r
203 unsigned long netapi_utilGetVaOfBufferArea(void)\r
204 {\r
205     void *userp;\r
206 \r
207     /* Map the physical address to user space */\r
208     userp = mmap(0,                       // Preferred start address\r
209                  NETAPIMOD_MEMSZ,            // Length to be mapped\r
210                  PROT_WRITE | PROT_READ,  // Read and write access\r
211                  MAP_SHARED,              // Shared memory\r
212                  netapi_fd,               // File descriptor\r
213                  0);                      // The byte offset from fd\r
214 \r
215     if (userp == MAP_FAILED) {\r
216         return 0;\r
217     }\r
218     return (unsigned long)userp;\r
219 }\r
220 \r
221 \r
222 /*****************************************************************************\r
223  * FUNCTION PURPOSE: Cache Invalidation Routine\r
224  ***************************************************************************** \r
225  * DESCRIPTION: Cache Invalidation Routine\r
226  *****************************************************************************/\r
227 void Osal_invalidateCache (void *blockPtr, uint32_t size) \r
228 {\r
229 \r
230 #ifdef NETAPI_TUNE_USE_CACHE_OPS\r
231     if ((blockPtr <netapi_VM_mem_start)||( blockPtr>netapi_VM_mem_end)) return;\r
232     //netapi_utilCacheInv(blockPtr, size);\r
233     netapi_utilCacheInv(Osal_saGetSCPhyAddr(blockPtr), size);\r
234 #endif\r
235     return;\r
236 }\r
237 \r
238 /*****************************************************************************\r
239  * FUNCTION PURPOSE: Cache Writeback Routine\r
240  ***************************************************************************** \r
241  * DESCRIPTION: Cache Invalidation Routine\r
242  *****************************************************************************/\r
243 void Osal_writeBackCache (void *blockPtr, uint32_t size) \r
244 {\r
245 #ifdef NETAPI_TUNE_USE_CACHE_OPS\r
246     if ((blockPtr <netapi_VM_mem_start)||( blockPtr>netapi_VM_mem_end)) return;\r
247     //netapi_utilCacheWbInv(blockPtr, size);\r
248     netapi_utilCacheWbInv(Osal_saGetSCPhyAddr(blockPtr), size);\r
249 #endif\r
250     return;\r
251 }\r
252 \r
253 \r
254 void *  Osal_qmssMtCsEnter()\r
255 {\r
256     /* Stub Function. TBD: Would need to handle when for multi proc access \r
257      * To be handled once infrastructure is available from Kernel\r
258      */\r
259     return NULL;\r
260 }\r
261 \r
262 \r
263 void Osal_qmssMtCsExit(void *key)\r
264 {\r
265     /* Stub Function. TBD: Would need to handle when for multi proc access \r
266      * To be handled once infrastructure is available from Kernel\r
267      */\r
268     return;\r
269 }\r
270 \r
271 void Osal_nwalCsEnter(uint32_t *key)\r
272 {\r
273     /* Stub Function. TBD: Would need to handle when for multi proc access \r
274      * To be handled once infrastructure is available from Kernel\r
275      */\r
276     return;\r
277 }\r
278 \r
279 void Osal_nwalCsExit(uint32_t key)\r
280 {\r
281     /* Stub Function. TBD: Would need to handle when for multi proc access \r
282      * To be handled once infrastructure is available from Kernel\r
283      */\r
284     return;\r
285 }\r
286 \r
287 \r
288 void Osal_qmssLog ( String fmt, ... )\r
289 {\r
290 }\r
291 \r
292 \r
293 void Osal_cppiCsEnter (uint32_t *key)\r
294\r
295 \r
296     /* Stub Function. TBD: Would need to handle when for multi proc access \r
297      * To be handled once infrastructure is available from Kernel\r
298      */\r
299     return;\r
300 }\r
301 \r
302 void Osal_cppiCsExit (uint32_t key)\r
303 {\r
304 \r
305     /* Stub Function. TBD: Would need to handle when for multi proc access \r
306      * To be handled once infrastructure is available from Kernel\r
307      */\r
308     return;\r
309 }\r
310 \r
311 void Osal_cppiLog ( String fmt, ... )\r
312 {\r
313 }\r
314 \r
315 void Osal_paBeginMemAccess (Ptr addr, uint32_t size)\r
316 {\r
317     /* Stub Function. TBD: Would need to handle when for multi proc access \r
318      * To be handled once infrastructure is available from Kernel\r
319      */\r
320 \r
321 }\r
322 \r
323 void Osal_paEndMemAccess (Ptr addr, uint32_t size)\r
324 {      \r
325     /* Stub Function. TBD: Would need to handle when for multi proc access \r
326      * To be handled once infrastructure is available from Kernel\r
327      */\r
328 }\r
329 void Osal_paMtCsEnter (uint32_t *key)\r
330 {\r
331     /* Stub Function. TBD: Would need to handle when for multi proc access \r
332      * To be handled once infrastructure is available from Kernel\r
333      */\r
334 }\r
335 void Osal_paMtCsExit (uint32_t key)\r
336 {\r
337     /* Stub Function. TBD: Would need to handle when for multi proc access \r
338      * To be handled once infrastructure is available from Kernel\r
339      */\r
340 }\r
341 \r
342 \r
343 void*  Osal_qmssCsEnter ()\r
344 {\r
345     \r
346     /* Stub Function. TBD: Would need to handle when for multi proc access \r
347      * To be handled once infrastructure is available from Kernel\r
348      */\r
349     return(NULL);\r
350 }\r
351 \r
352 void Osal_qmssCsExit (void *  key)\r
353 {\r
354     /* Stub Function. TBD: Would need to handle when for multi proc access \r
355      * To be handled once infrastructure is available from Kernel\r
356      */\r
357     return;\r
358 }\r
359 \r
360 Ptr Osal_qmssMalloc (uint32_t num_bytes)\r
361 {\r
362     Ptr ret;\r
363    \r
364     Osal_qmss_MallocCounter++;\r
365     ret = malloc (num_bytes);    \r
366     if(ret==NULL)\r
367     {\r
368       System_printf("\nERROR! QMSS Malloc failed!\n");\r
369     }    \r
370     \r
371     return ret;\r
372 }\r
373 \r
374 void Osal_qmssFree (Ptr ptr, uint32_t size)\r
375 {\r
376     /* Increment the free counter. */\r
377     Osal_qmss_FreeCounter++;    \r
378     free(ptr);\r
379 }\r
380 \r
381 Ptr Osal_cppiMalloc (uint32_t num_bytes)\r
382 {\r
383     Ptr ret;\r
384     \r
385     Osal_cppi_MallocCounter++;\r
386     num_bytes += (CACHE_L2_LINESIZE-1);\r
387     ret = malloc (num_bytes);\r
388 \r
389     if(ret==NULL)\r
390     {\r
391       System_printf("\nERROR! CPPI Malloc failed!\n");\r
392     }   \r
393     \r
394     return ret;\r
395 }\r
396 \r
397 void Osal_cppiFree (Ptr ptr, uint32_t size)\r
398 {\r
399     /* Increment the free counter. */\r
400     Osal_cppi_FreeCounter++;    \r
401     free(ptr);    \r
402 }\r
403 \r
404 void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)\r
405 {\r
406     Osal_invalidateCache(blockPtr,size);\r
407     return;\r
408 }\r
409 \r
410 void  Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)\r
411 {\r
412     Osal_writeBackCache(blockPtr,size);\r
413     return;\r
414 }\r
415 \r
416 void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)\r
417 {\r
418     Osal_invalidateCache(blockPtr,size);\r
419     return;\r
420 }\r
421 \r
422 void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)\r
423 {\r
424     Osal_writeBackCache(blockPtr,size);\r
425     return;\r
426 }\r
427 \r
428 void Osal_nwalInvalidateCache (void *blockPtr, uint32_t size)\r
429 {\r
430     //Osal_invalidateCache(blockPtr,size);\r
431     return;\r
432 }\r
433 \r
434 void Osal_nwalWriteBackCache (void *blockPtr, uint32_t size)\r
435 {\r
436     //Osal_writeBackCache(blockPtr,size);\r
437     return;\r
438 }\r
439 \r
440 uint32_t Osal_nwalGetCacheLineSize (void )\r
441 {\r
442     /* By default assumes L2 cache line is enabled. If not return CACHE_L1D_LINESIZE */\r
443     return (CACHE_L2_LINESIZE);\r
444 }\r
445 \r
446 /********************************************************************\r
447  * FUNCTION PURPOSE: Convert local address to global\r
448  ********************************************************************\r
449  * DESCRIPTION: Returns global address\r
450  ********************************************************************/\r
451 \r
452 unsigned int Osal_nwalLocToGlobAddr(unsigned int x)\r
453 {\r
454     return x;\r
455 }\r
456 \r
457 uint16_t Osal_nwalGetProcId (void )\r
458 {\r
459     return DNUM;\r
460 }\r
461 uint64_t Osal_nwalGetTimeStamp(void)\r
462 {\r
463     /* Stub function to return timestamp\r
464      */\r
465     return netapi_getTimestamp();\r
466 }\r
467 \r
468 uint16_t Osal_saGetProcId (void )\r
469 {\r
470     return 0;\r
471 }\r
472 \r
473 void* Osal_saGetSCPhyAddr(void* vaddr)\r
474 {\r
475     if(vaddr == NULL)\r
476     {\r
477         return NULL;\r
478     }\r
479     return (void *)(netapi_VM_mem_start_phy + ((uint8_t*) vaddr - netapi_VM_mem_start));\r
480 \r
481 }\r
482 \r
483 void Osal_saBeginScAccess (void* addr, uint32_t size)\r
484 {\r
485    Osal_invalidateCache(addr,size);\r
486 \r
487 }\r
488 \r
489 void Osal_saEndScAccess   (void* addr, uint32_t size)\r
490 {\r
491     Osal_writeBackCache(addr,size);\r
492 \r
493 }\r
494 \r
495 \r
496 void Osal_saCsEnter (uint32_t *key)\r
497 {\r
498     /* Stub Function. TBD: Would need to handle when for multi proc access \r
499      * To be handled once infrastructure is available from Kernel\r
500      */ \r
501     //((CSL_semAcquireDirect (SA_HW_SEM)) == 0); \r
502     return;\r
503 }\r
504 \r
505 void Osal_saCsExit (uint32_t key)\r
506 {\r
507     /* Stub Function. TBD: Would need to handle when for multi proc access \r
508      * To be handled once infrastructure is available from Kernel\r
509      */ \r
510     return;\r
511 }\r
512 \r
513 \r
514 void Osal_saMtCsEnter (uint32_t *key)\r
515 {\r
516    /* Stub Function. TBD: Would need to handle when for multi proc access \r
517      * To be handled once infrastructure is available from Kernel\r
518      */ \r
519     return;\r
520 }\r
521 \r
522 void Osal_saMtCsExit (uint32_t key)\r
523 {\r
524     /* Stub Function. TBD: Would need to handle when for multi proc access \r
525      * To be handled once infrastructure is available from Kernel\r
526      */ \r
527     return;\r
528 }\r
529 \r
530 void Osal_saBeginMemAccess (void *blockPtr, uint32_t size)\r
531 {\r
532     Osal_invalidateCache(blockPtr,size);\r
533     return;\r
534 }\r
535 \r
536 void Osal_saEndMemAccess (void *blockPtr, uint32_t size)\r
537 {\r
538     Osal_writeBackCache(blockPtr,size);\r
539     return;\r
540 }\r
541 \r
542 \r
543 \r
544 void Osal_pktLibBeginMemAccess(void* ptr, uint32_t size)\r
545 {\r
546     //Osal_invalidateCache(ptr,size);\r
547 }\r
548 \r
549 \r
550 void Osal_pktLibEndMemAccess(void* ptr, uint32_t size)\r
551 {\r
552     //Osal_writeBackCache(ptr,size);\r
553 }\r
554 \r
555 \r
556 void Osal_pktLibBeginPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)\r
557 {\r
558     /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
559      * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
560      * Just for testing we are always invalidating the cache here. */\r
561 \r
562      //Osal_invalidateCache(ptrPkt,size);\r
563 }\r
564 \r
565 \r
566 void Osal_pktLibEndPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)\r
567 {\r
568     /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
569      * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
570      * Just for testing we are always writing back the cache here. */\r
571 \r
572     /* Writeback the contents of the cache. */\r
573     //Osal_writeBackCache(ptrPkt,size);\r
574 }\r
575 \r
576 \r
577 void* Osal_pktLibEnterCriticalSection(Pktlib_HeapHandle heapHandle)\r
578 {\r
579     /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
580      * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
581      * Implementations here could range from a MULTI-THREAD protection if the packets in \r
582      * the heap are being accessed across multiple threads or MULTI-CORE if the packets\r
583      * are being accessed across multiple cores and features: split and clone are used.\r
584      * For NWAL layer no protection required.\r
585      *\r
586      * For testing we are not doing any of this so we are simply setting it to NOOP */\r
587     return NULL;\r
588 }\r
589 \r
590 \r
591 void  Osal_pktLibExitCriticalSection(Pktlib_HeapHandle heapHandle, void* csHandle)\r
592 {\r
593     /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
594      * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
595      * Implementations here could range from a MULTI-THREAD protection if the packets in \r
596      * the heap are being accessed across multiple threads or MULTI-CORE if the packets\r
597      * are being accessed across multiple cores and features: split and clone are used.\r
598      * For NWAL layer no protection required.. \r
599      *\r
600      * For testing we are not doing any of this so we are simply setting it to NOOP */\r
601     return;        \r
602 }\r
603 \r
604 void* Osal_qmssVirtToPhy (void *ptr)\r
605 {\r
606     return (void *)(netapi_VM_mem_start_phy + ((uint8_t*)ptr - netapi_VM_mem_start));\r
607 }\r
608 \r
609 void* Osal_qmssPhyToVirt (void *ptr)\r
610 {\r
611     if (!ptr) return (void *) 0;\r
612     //todo, see if out of range of mem_start_phy and size!! (like mmu would do)\r
613     return (void *)(netapi_VM_mem_start + ((uint8_t*)ptr - netapi_VM_mem_start_phy));\r
614 }\r
615 \r
616 /******************************************************************************\r
617 * Function to traverse a CPPI descriptor and convert all address references\r
618 * from virtual to physical.\r
619 ******************************************************************************/\r
620 void* Osal_qmssConvertDescVirtToPhy(void *descAddr)\r
621 {\r
622     if (!descAddr) return (void *)0;\r
623 \r
624     if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)\r
625     {\r
626         Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);\r
627         Cppi_HostDesc *prevBDPtr = 0;\r
628         while (nextBDPtr)\r
629         {\r
630             void *buffPtr;\r
631             if (nextBDPtr->buffPtr)\r
632             {\r
633                 buffPtr = (void *)nextBDPtr->buffPtr;\r
634                 nextBDPtr->buffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->buffPtr));\r
635                 if (!(nextBDPtr->buffPtr)) return (void *)0;\r
636             }\r
637 \r
638             if (nextBDPtr->origBuffPtr)\r
639             {\r
640                 nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->origBuffPtr));\r
641                 if (!(nextBDPtr->origBuffPtr)) return (void *)0;\r
642             }\r
643 \r
644             prevBDPtr = nextBDPtr;\r
645             nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));\r
646             if (prevBDPtr->nextBDPtr)\r
647             {\r
648                 prevBDPtr->nextBDPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(prevBDPtr->nextBDPtr));\r
649                 if (!(prevBDPtr->nextBDPtr)) return (void *)0;\r
650             }\r
651 \r
652             Qmss_osalEndMemAccess(buffPtr, prevBDPtr->buffLen);\r
653             Qmss_osalEndMemAccess(prevBDPtr, sizeof(Cppi_HostDesc));\r
654         }\r
655         descAddr = Osal_qmssVirtToPhy(descAddr);\r
656         if (!descAddr) return (void *)0;\r
657     }\r
658     else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)\r
659     {\r
660         descAddr = Osal_qmssVirtToPhy(descAddr);\r
661         if (!descAddr) return (void *)0;\r
662     }\r
663     return descAddr;\r
664 \r
665 }\r
666 \r
667 \r
668 /******************************************************************************\r
669 * Function to traverse a CPPI descriptor and convert all address references\r
670 * from physical to virtual.\r
671 ******************************************************************************/\r
672 void* Osal_qmssConvertDescPhyToVirt(void *descAddr)\r
673 {\r
674     if (!descAddr) return (void *)0;\r
675     descAddr = Osal_qmssPhyToVirt(descAddr);\r
676 \r
677     if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)\r
678     {\r
679         Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);\r
680         while (nextBDPtr)\r
681         {\r
682             Qmss_osalBeginMemAccess(nextBDPtr, sizeof(Cppi_HostDesc));\r
683             if (nextBDPtr->buffPtr)\r
684             {\r
685                 nextBDPtr->buffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->buffPtr));\r
686                 if (!(nextBDPtr->buffPtr)) return (void *)0;\r
687             }\r
688 \r
689             if (nextBDPtr->origBuffPtr)\r
690             {\r
691                 nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->origBuffPtr));\r
692                 if (!(nextBDPtr->origBuffPtr)) return (void *)0;\r
693             }\r
694 \r
695             if (nextBDPtr->nextBDPtr)\r
696             {\r
697                 nextBDPtr->nextBDPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->nextBDPtr));\r
698                 if (!(nextBDPtr->nextBDPtr)) return (void *)0;\r
699             }\r
700 \r
701             Qmss_osalBeginMemAccess((void *)(nextBDPtr->buffPtr), nextBDPtr->buffLen);\r
702             nextBDPtr = (void *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));\r
703         }\r
704     }\r
705     else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)\r
706     {\r
707         descAddr = Osal_qmssPhyToVirt(descAddr);\r
708         if (!descAddr) return (void *)0;\r
709     }\r
710     return descAddr;\r
711 }\r
712 \r
713 void* Osal_stubCsEnter (void)\r
714 {\r
715 \r
716 \r
717 }\r
718 void Osal_stubCsExit (void *CsHandle)\r
719 {\r
720     /* Release Semaphore using handle */\r
721 \r
722 \r
723     return;\r
724 }\r
725 \r