Add support for DDR shared heap. Note:algs use IALG_EXTERNAL_SHM, which is IALG_ESDATA.
[processor-sdk/performance-audio-sr.git] / processor_audio_sdk_1_00_00_00 / pasdk / common / paf_alg_malloc.c
2 /*
3 Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
6 * Redistribution and use in source and binary forms, with or without 
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the
16 * distribution.
17 *
18 * Neither the name of Texas Instruments Incorporated nor the names of
19 * its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 */
36 //
37 // Algorithm Memory Allocation
38 //
40 /*
41  * File Inclusions 
42  */
44 #include <xdc/std.h>
45 #include <xdc/cfg/global.h>
47 //#include <mem.h>
48 #include <xdc/runtime/Error.h>
49 #include <xdc/runtime/Memory.h>
50 #include <xdc/runtime/IHeap.h>
51 #include <ti/sysbios/heaps/HeapMem.h>
53 //#include <stdlib.h>
54 //#include <string.h>
56 #include "alg.h"
58 //#include "pafhjt.h"
59 #include "paf_alg.h"
60 #include "paf_alg_priv.h"
62 #include "common.h"
63 #include "paf_heapMgr.h"
65 //extern int IRAM;
66 //extern int SDRAM;
67 //extern int L3RAM;
70 // -----------------------------------------------------------------------------
71 // Debugging Trace Control, local to this file.
72 //
74 #define PAF_DEVICE_VERSION (PAF_DEVICE & 0xffff)
75 #if PAF_DEVICE_VERSION == 0xE000
76 #define _DEBUG // This is to enable log_printfs
77 #endif /* PAF_DEVICE_VERSION */
79 #include <logp.h>
81 // allows you to set a different trace module in pa.cfg
82 #define TR_MOD  trace
84 // Allow a developer to selectively enable tracing.
85 // For release, set mask to 1 to make it easier to catch any errors.
86 #define CURRENT_TRACE_MASK  0   // terse only
88 #define TRACE_MASK_TERSE    1   // only flag errors
89 #define TRACE_MASK_GENERAL  2   // log a half dozen lines per loop
90 #define TRACE_MASK_VERBOSE  4   // trace full operation
92 #if (CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
93  #define TRACE_TERSE(a) LOG_printf a
94 #else
95  #define TRACE_TERSE(a)
96 #endif
98 #if (CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
99  #define TRACE_GEN(a) LOG_printf a
100 #else
101  #define TRACE_GEN(a)
102 #endif
104 #if (CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
105  #define TRACE_VERBOSE(a) LOG_printf a
106 #else
107  #define TRACE_VERBOSE(a)
108 #endif
110 // Note:  memory spaces are defined in ialg.h from the xdais package.
111 // 17 is external.  2 and 5 are internal.
113 /*
114  * The PAF_ALG_allocMemory is derived from _ALG_allocMemory function defined 
115  * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
116  * It is extended to check for the Performance Audio specific "Common"
117  * memory. This function assumes that memory is already
118  * allocated for the common memory and shared scratch memory.
119  */
121 Int 
122 PAF_ALG_allocMemory_ (
123     IALG_MemRec memTab[], 
124     Int n, 
125     const IALG_MemRec common[],
126     PAF_IALG_Config *p)
128     char * commonBase[PAF_IALG_COMMON_MEMN+1];
129     Int commonCount[PAF_IALG_COMMON_MEMN+1];
130     Int i;
131     Error_Block eb;
133     // Initialize error block
134     Error_init(&eb); 
136     if(common) {
137 #ifdef _TMS320C6X
138 //#warn This pragma saves ~125 bytes! --Kurt
139 #pragma UNROLL(1)
140 #endif
141         for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i) {
142             commonBase[i]=common[i].base;
143             commonCount[i]=0;
144         }
145     }
146     
147     for(i=0;i<n;++i) {
148         if( common && 
149            (memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
150             (memTab[i].attrs >= PAF_IALG_COMMON_MEM1 &&
151             memTab[i].attrs <= PAF_IALG_COMMON_MEMN))) {
152             memTab[i].base = commonBase[memTab[i].attrs] + 
153                              (commonCount[memTab[i].attrs] ? memTab[i].alignment : 0);
154             memTab[i].base = (void *)((unsigned int )memTab[i].base & 
155                              (~(memTab[i].alignment ? memTab[i].alignment - 1 : 0)));
156             commonBase[memTab[i].attrs] = (char *)memTab[i].base + memTab[i].size;
157             commonCount[memTab[i].attrs]++;
158             TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: memTab alloc %d bytes at 0x%x.", __LINE__, memTab[i].size, memTab[i].base));
159             TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) memTab %d. i: %d", memTab[i].attrs, i));
160         }
161         else {
162             if(memTab[i].size){
163                 if(p) {
164                     if(p->clr){
165                         TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: calloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
166                         //if(!(memTab[i].base = (void *)MEM_calloc(
167                         //    PAF_ALG_memSpace(p,memTab[i].space),
168                         //    memTab[i].size,memTab[i].alignment)))
169                         if (!(memTab[i].base = (void *)Memory_calloc(
170                             (IHeap_Handle)PAF_ALG_memSpaceToHeap(p,memTab[i].space),
171                             memTab[i].size,
172                             memTab[i].alignment,
173                             &eb)))
174                         {
175                             TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: calloc %d bytes failed.", __LINE__, memTab[i].size));
176                             SW_BREAKPOINT;
177                             return PAF_ALGERR_PERSIST;
178                         }
179                         TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x, %d",
180                                        memTab[i].size, memTab[i].base, PAF_ALG_memSpace(p,memTab[i].space)));
181                     }
182                     else{
183                         TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
184                         //if(!(memTab[i].base = (void *)MEM_alloc(
185                         //    PAF_ALG_memSpace(p,memTab[i].space),
186                         //    memTab[i].size,memTab[i].alignment)))
187                         if (!(memTab[i].base = (void *)Memory_alloc(
188                             (IHeap_Handle)PAF_ALG_memSpaceToHeap(p, memTab[i].space),
189                             memTab[i].size, 
190                             memTab[i].alignment, 
191                             &eb)))
192                         {
193                             TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
194                             SW_BREAKPOINT;
195                             return PAF_ALGERR_PERSIST;
196                         }
197                         TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x, %d",
198                                        memTab[i].size, memTab[i].base, PAF_ALG_memSpace(p,memTab[i].space)));
199                     }
200                 }
201                 else {
202                     PAF_IALG_Config pafConfig;
203                     TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: Setup memory regions.", __LINE__));
204                     //PAF_ALG_setup(&pafConfig,IRAM,SDRAM,IRAM,0); // option: use L3RAM
205                     PAF_ALG_setup(&pafConfig,
206                             gPafHeapIdInt,      (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt),
207                             gPafHeapIdInt1,     (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt1),
208                             gPafHeapIdExt,      (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExt),
209                             gPafHeapIdInt1Shm,  (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt1Shm),
210                             gPafHeapIdExtShm,   (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExtShm),
211                             0);
212                     TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
213                     //if(!(memTab[i].base=(void *)MEM_alloc(
214                     //    PAF_ALG_memSpace(&pafConfig,memTab[i].space),
215                     //    memTab[i].size,memTab[i].alignment)))
216                     if (!(memTab[i].base = (void *)Memory_alloc(
217                         (IHeap_Handle)PAF_ALG_memSpaceToHeap(&pafConfig, memTab[i].space),
218                         memTab[i].size,
219                         memTab[i].alignment, 
220                         &eb)))
221                     {
222                         TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.",__LINE__, memTab[i].size));
223                         SW_BREAKPOINT;
224                         return PAF_ALGERR_PERSIST;
225                     }
226                     TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x",
227                                    memTab[i].size, memTab[i].base, PAF_ALG_memSpace(&pafConfig,memTab[i].space)));
228                 }
229             }
230             else
231             {
232                 memTab[i].base=NULL;
233                 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
234                 SW_BREAKPOINT;
235             }
236         }
237     }
238     return 0;
241 /*
242  * The PAF_ALG_mallocMemory function allocates the memory requested by the 
243  * memTab's.
244  */
246 Int
247 PAF_ALG_mallocMemory_ (
248     IALG_MemRec common[], 
249     PAF_IALG_Config *p)
251     Int i;
252     Error_Block eb;
253     
254     // Initialize error block
255     Error_init(&eb);
256     
257     for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i)
258     {
259         if(0 == common[i].size)
260             continue;
262         if(p->clr)
263         {
264             TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: calloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
265             //common[i].base = (void *)MEM_calloc( PAF_ALG_memSpace(p,common[i].space), common[i].size, common[i].alignment);
266             common[i].base = (void *)Memory_calloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p,common[i].space), common[i].size, common[i].alignment, &eb);
267             TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
268         }
269         else
270         {
271             TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: alloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
272             //common[i].base = (void *)MEM_alloc(PAF_ALG_memSpace(p, common[i].space),common[i].size, common[i].alignment);
273             common[i].base = (void *)Memory_alloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p, common[i].space), common[i].size, common[i].alignment, &eb);
274             TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
275         }
277         if(!(common[i].base))
278         {
279             TRACE_TERSE((&TR_MOD, "PAF_ALG_mallocMemory_.%d: (c)alloc %d bytes failed", __LINE__, common[i].size));
280             SW_BREAKPOINT;
281             return PAF_ALGERR_COMMON;
282         }
283     }
285     return 0;
288 /*
289  * The PAF_ALG_freeMemory is derived from _ALG_freeMemory function defined 
290  * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
291  * It is extended to check for the Performance Audio specific "Common"
292  * memory and scratch memory.
293  */
295 Void 
296 PAF_ALG_freeMemory(
297     IALG_MemRec memTab[], 
298     Int n)
301 #ifdef _TMS320C6X
302 //#warn Cannot free memory here because segids are not known
303 #endif
305     // Cannot free memory here bacause there is no way to determine
306     // the segid needed by MEM_free.
307     // Not an issuue as of now, in PA, because, if alg creation fails
308     // system does not do any thing further.
309     // 
310 #if 0
311     Int i;
312     Int segid;
314     for(i=0;i<n;i++){
315         if(memTab[i].base != NULL && !(memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
316            memTab[i].attrs >= PAF_IALG_COMMON_MEM1 && memTab[i].attrs <= PAF_IALG_COMMON_MEMN))
317         {
318 #warn MEM_free might be 
319             segid = (memTab[i].space == IALG_SARAM)?IRAM:SDRAM;
320             MEM_free(segid,memTab[i].base,memTab[i].size);
321         }
322     }
323 #endif
326 /* 
327  * The PAF_ALG_init function initializes the memTab's to default values.
328  */
330 Void 
331 PAF_ALG_init_ (
332     IALG_MemRec memTab[], 
333     Int n, 
334     const IALG_MemSpace memSpace[])
336     Int i;
338     for (i=0; i<n; i++) {
339         memTab[i].size = 0;
340         memTab[i].alignment = 0;
341         memTab[i].base = NULL;
342         memTab[i].space = memSpace ? memSpace[i] : PAF_IALG_NONE;
343         // TRACE_GEN((&TR_MOD, "PAF_ALG_init_[%d]:space %d", i, memTab[i].space));
344     }
347 /*
348  *  PAF_ALG_activate is derived from standard XDAIS ALG_activate function defined in the
349  *  file alg_malloc.c version "XDAS 2.2.1 12-07-01".
350  */
352 #ifdef _TMS320C6X
353 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
354 #pragma CODE_SECTION(PAF_ALG_activate,".text:_PAF_ALG_activate")
355 #endif
357 Void
358 PAF_ALG_activate (
359     ALG_Handle alg)
361 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
362     asm (" .clink");
363 #endif    
365     if (alg->fxns->algActivate != NULL) {
366         alg->fxns->algActivate (alg);
367     }
370 /*
371  *  PAF_ALG_deactivate is derived from standard XDAIS ALG_deactivate function defined in the
372  *  file alg_malloc.c version "XDAS 2.2.1 12-07-01".
373  */
375 #ifdef _TMS320C6X
376 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
377 #pragma CODE_SECTION(PAF_ALG_deactivate,".text:_PAF_ALG_deactivate")
378 #endif
380 Void 
381 PAF_ALG_deactivate (
382     ALG_Handle alg)
384 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
385     asm (" .clink");
386 #endif
388     if (alg->fxns->algDeactivate != NULL) {
389         alg->fxns->algDeactivate(alg);
390     }   
393 /* 
394  * The PAF_ALG_memSpaceToHeapId function is derived from ALGRF_memSpace function 
395  * defined in the TI released algrf.h file ver "ALGRF 0.02.06 11-21-01".
396  */
398 Int
399 PAF_ALG_memSpaceToHeapId_ (
400     const PAF_IALG_Config *p, 
401     IALG_MemSpace space)
403     switch(space)
404     {
405         case IALG_SARAM:    /* IALG_SARAM0 = IALG_SARAM :  Normally used for IRAM */ // FL: K2G: used for L2 on DSP
406             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
407             return p->iHeapId;
409         case IALG_EXTERNAL: // normally external SDRAM // FL: K2G: used for DDR local memory
410             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
411             return p->eHeapId;
413         case IALG_SARAM1: // FL: K2G: used for MSMC local memory
414             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
415             return p->lHeapId;
417         case IALG_SARAM2:  // FL: K2G: used for MSMC shared memory
418             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM2 (IALG_SARAM_SHM) (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
419             return p->lHeapIdShm;
421         case IALG_DARAM0:   // Can't use this because it is zero and overridden
422             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
423             return p->iHeapId;
425         case IALG_DARAM1:   // not normally used.
426             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
427             return p->iHeapId;
429         case IALG_DARAM2:   // not normally used.
430             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
431             return p->iHeapId;    // not normally used.
433         case IALG_ESDATA:   // FL: K2G: used for DDR shared memory
434             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_ESDATA (IALG_EXTERNAL_SHM) (0x%x) 0x%x", __LINE__, space, p->eHeapIdShm));
435             return p->eHeapIdShm;
437         default:
438             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
439             return p->eHeapId;
440     }
441  
444 HeapMem_Handle
445 PAF_ALG_memSpaceToHeap_ (
446     const PAF_IALG_Config *p, 
447     IALG_MemSpace space)
449     switch(space)
450     {
451         case IALG_SARAM:    /* IALG_SARAM0 = IALG_SARAM :  Normally used for IRAM. */ // FL: K2G: used for L2 on DSP
452             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
453             return p->hIHeap;
455         case IALG_EXTERNAL: // normally external SDRAM // FL: K2G: used for DDR local memory
456             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
457             return p->hEHeap;
459         case IALG_SARAM1:   // FL: K2G: used for MSMC local memory
460             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
461             return p->hLHeap;
463         case IALG_SARAM2:
464             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM2 (IALG_SARAM_SHM) (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
465             return p->hLHeapShm;
467         case IALG_DARAM0:   // Can't use this because it is zero and overridden
468             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
469             return p->hIHeap;
471         case IALG_DARAM1:   // not normally used.
472             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
473             return p->hIHeap;
475         case IALG_DARAM2:   // not normally used.
476             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
477             return p->hIHeap;    // not normally used.
479         case IALG_ESDATA:   // FL: K2G: used for DDR shared memory
480             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapIdShm));
481             return p->hEHeapShm;
483         default:
484             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
485             return p->hEHeap;
486     } 
489 /* 
490  * The PAF_ALG_setup function is derived from ALGRF_setup function defined in
491  * the TI released algrf_setup.c file ver "ALGRF 0.02.06 11-21-01" .
492  */
493     
494 #ifdef _TMS320C6X
495 #pragma CODE_SECTION(PAF_ALG_setup_,".text:_PAF_ALG_setup_")
496 #endif
497 Void
498 PAF_ALG_setup_ (
499     PAF_IALG_Config *p, 
500     Int iHeapId, 
501     HeapMem_Handle hIHeap,
502     Int lHeapId,
503     HeapMem_Handle hLHeap,
504     Int eHeapId,
505     HeapMem_Handle hEHeap,
506     Int lHeapIdShm,
507     HeapMem_Handle hLHeapShm,
508     Int eHeapIdShm,
509     HeapMem_Handle hEHeapShm,
510     Int clr
512
513 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
514     asm (" .clink");
515 #endif    
516     
517     /* initialize heap Ids */
518     p->iHeapId      = iHeapId; 
519     p->lHeapId      = lHeapId;
520     p->eHeapId      = eHeapId;
521     p->lHeapIdShm   = lHeapIdShm;
522     p->eHeapIdShm   = eHeapIdShm;
523     
524     /* initialize heap handles */
525     p->hIHeap       = hIHeap;
526     p->hLHeap       = hLHeap;
527     p->hEHeap       = hEHeap;
528     p->hLHeapShm    = hLHeapShm;
529     p->hEHeapShm    = hEHeapShm;
530     
531     /* initialize clear flag */
532     p->clr=clr;
533     
534     // TRACE_GEN((&TR_MOD, "PAF_ALG_memSpace_.%d: IPAF_ALG_setup_", __LINE__));