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 "paf_ialg.h"
64 #include "common.h"
65 #include "paf_heapMgr.h"
67 //extern int IRAM;
68 //extern int SDRAM;
69 //extern int L3RAM;
72 // -----------------------------------------------------------------------------
73 // Debugging Trace Control, local to this file.
74 //
76 #define PAF_DEVICE_VERSION (PAF_DEVICE & 0xffff)
77 #if PAF_DEVICE_VERSION == 0xE000
78 #define _DEBUG // This is to enable log_printfs
79 #endif /* PAF_DEVICE_VERSION */
81 #include <logp.h>
83 // allows you to set a different trace module in pa.cfg
84 #define TR_MOD trace
86 // Allow a developer to selectively enable tracing.
87 // For release, set mask to 1 to make it easier to catch any errors.
88 #define CURRENT_TRACE_MASK 0 // terse only
90 #define TRACE_MASK_TERSE 1 // only flag errors
91 #define TRACE_MASK_GENERAL 2 // log a half dozen lines per loop
92 #define TRACE_MASK_VERBOSE 4 // trace full operation
94 #if (CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
95 #define TRACE_TERSE(a) LOG_printf a
96 #else
97 #define TRACE_TERSE(a)
98 #endif
100 #if (CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
101 #define TRACE_GEN(a) LOG_printf a
102 #else
103 #define TRACE_GEN(a)
104 #endif
106 #if (CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
107 #define TRACE_VERBOSE(a) LOG_printf a
108 #else
109 #define TRACE_VERBOSE(a)
110 #endif
112 // Note: memory spaces are defined in ialg.h from the xdais package.
113 // 17 is external. 2 and 5 are internal.
115 /*
116 * The PAF_ALG_allocMemory is derived from _ALG_allocMemory function defined
117 * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
118 * It is extended to check for the Performance Audio specific "Common"
119 * memory. This function assumes that memory is already
120 * allocated for the common memory and shared scratch memory.
121 */
123 Int
124 PAF_ALG_allocMemory_ (
125 IALG_MemRec memTab[],
126 Int n,
127 const IALG_MemRec common[],
128 PAF_IALG_Config *p)
129 {
130 char * commonBase[PAF_IALG_COMMON_MEMN+1];
131 Int commonCount[PAF_IALG_COMMON_MEMN+1];
132 Int i;
133 Error_Block eb;
135 // Initialize error block
136 Error_init(&eb);
138 if(common) {
139 #ifdef _TMS320C6X
140 //#warn This pragma saves ~125 bytes! --Kurt
141 #pragma UNROLL(1)
142 #endif
143 for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i) {
144 commonBase[i]=common[i].base;
145 commonCount[i]=0;
146 }
147 }
149 for(i=0;i<n;++i) {
150 if( common &&
151 (memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
152 (memTab[i].attrs >= PAF_IALG_COMMON_MEM1 &&
153 memTab[i].attrs <= PAF_IALG_COMMON_MEMN))) {
154 memTab[i].base = commonBase[memTab[i].attrs] +
155 (commonCount[memTab[i].attrs] ? memTab[i].alignment : 0);
156 memTab[i].base = (void *)((unsigned int )memTab[i].base &
157 (~(memTab[i].alignment ? memTab[i].alignment - 1 : 0)));
158 commonBase[memTab[i].attrs] = (char *)memTab[i].base + memTab[i].size;
159 commonCount[memTab[i].attrs]++;
160 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: memTab alloc %d bytes at 0x%x.", __LINE__, memTab[i].size, memTab[i].base));
161 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) memTab %d. i: %d", memTab[i].attrs, i));
162 }
163 else {
164 if(memTab[i].size){
165 if(p) {
166 if(p->clr){
167 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: calloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
168 //if(!(memTab[i].base = (void *)MEM_calloc(
169 // PAF_ALG_memSpace(p,memTab[i].space),
170 // memTab[i].size,memTab[i].alignment)))
171 if (!(memTab[i].base = (void *)Memory_calloc(
172 (IHeap_Handle)PAF_ALG_memSpaceToHeap(p,memTab[i].space),
173 memTab[i].size,
174 memTab[i].alignment,
175 &eb)))
176 {
177 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: calloc %d bytes failed.", __LINE__, memTab[i].size));
178 SW_BREAKPOINT;
179 return PAF_ALGERR_PERSIST;
180 }
181 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x, %d",
182 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(p,memTab[i].space)));
183 }
184 else{
185 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
186 //if(!(memTab[i].base = (void *)MEM_alloc(
187 // PAF_ALG_memSpace(p,memTab[i].space),
188 // memTab[i].size,memTab[i].alignment)))
189 if (!(memTab[i].base = (void *)Memory_alloc(
190 (IHeap_Handle)PAF_ALG_memSpaceToHeap(p, memTab[i].space),
191 memTab[i].size,
192 memTab[i].alignment,
193 &eb)))
194 {
195 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
196 SW_BREAKPOINT;
197 return PAF_ALGERR_PERSIST;
198 }
199 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x, %d",
200 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(p,memTab[i].space)));
201 }
202 }
203 else {
204 PAF_IALG_Config pafConfig;
205 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: Setup memory regions.", __LINE__));
206 //PAF_ALG_setup(&pafConfig,IRAM,SDRAM,IRAM,0); // option: use L3RAM
207 PAF_ALG_setup(&pafConfig,
208 gPafHeapIdInt, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt),
209 gPafHeapIdInt1, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt1),
210 gPafHeapIdExt, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExt),
211 gPafHeapIdInt1Shm, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt1Shm),
212 gPafHeapIdExtShm, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExtShm),
213 gPafHeapIdExtNonCachedShm, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExtNonCachedShm),
214 0);
215 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
216 //if(!(memTab[i].base=(void *)MEM_alloc(
217 // PAF_ALG_memSpace(&pafConfig,memTab[i].space),
218 // memTab[i].size,memTab[i].alignment)))
219 if (!(memTab[i].base = (void *)Memory_alloc(
220 (IHeap_Handle)PAF_ALG_memSpaceToHeap(&pafConfig, memTab[i].space),
221 memTab[i].size,
222 memTab[i].alignment,
223 &eb)))
224 {
225 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.",__LINE__, memTab[i].size));
226 SW_BREAKPOINT;
227 return PAF_ALGERR_PERSIST;
228 }
229 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x",
230 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(&pafConfig,memTab[i].space)));
231 }
232 }
233 else
234 {
235 memTab[i].base=NULL;
236 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
237 SW_BREAKPOINT;
238 }
239 }
240 }
241 return 0;
242 }
244 /*
245 * The PAF_ALG_mallocMemory function allocates the memory requested by the
246 * memTab's.
247 */
249 Int
250 PAF_ALG_mallocMemory_ (
251 IALG_MemRec common[],
252 PAF_IALG_Config *p)
253 {
254 Int i;
255 Error_Block eb;
257 // Initialize error block
258 Error_init(&eb);
260 for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i)
261 {
262 if(0 == common[i].size)
263 continue;
265 if(p->clr)
266 {
267 TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: calloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
268 //common[i].base = (void *)MEM_calloc( PAF_ALG_memSpace(p,common[i].space), common[i].size, common[i].alignment);
269 common[i].base = (void *)Memory_calloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p,common[i].space), common[i].size, common[i].alignment, &eb);
270 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
271 }
272 else
273 {
274 TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: alloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
275 //common[i].base = (void *)MEM_alloc(PAF_ALG_memSpace(p, common[i].space),common[i].size, common[i].alignment);
276 common[i].base = (void *)Memory_alloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p, common[i].space), common[i].size, common[i].alignment, &eb);
277 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
278 }
280 if(!(common[i].base))
281 {
282 TRACE_TERSE((&TR_MOD, "PAF_ALG_mallocMemory_.%d: (c)alloc %d bytes failed", __LINE__, common[i].size));
283 SW_BREAKPOINT;
284 return PAF_ALGERR_COMMON;
285 }
286 }
288 return 0;
289 }
291 /*
292 * The PAF_ALG_freeMemory is derived from _ALG_freeMemory function defined
293 * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
294 * It is extended to check for the Performance Audio specific "Common"
295 * memory and scratch memory.
296 */
298 Void
299 PAF_ALG_freeMemory(
300 IALG_MemRec memTab[],
301 Int n)
302 {
304 #ifdef _TMS320C6X
305 //#warn Cannot free memory here because segids are not known
306 #endif
308 // Cannot free memory here bacause there is no way to determine
309 // the segid needed by MEM_free.
310 // Not an issuue as of now, in PA, because, if alg creation fails
311 // system does not do any thing further.
312 //
313 #if 0
314 Int i;
315 Int segid;
317 for(i=0;i<n;i++){
318 if(memTab[i].base != NULL && !(memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
319 memTab[i].attrs >= PAF_IALG_COMMON_MEM1 && memTab[i].attrs <= PAF_IALG_COMMON_MEMN))
320 {
321 #warn MEM_free might be
322 segid = (memTab[i].space == IALG_SARAM)?IRAM:SDRAM;
323 MEM_free(segid,memTab[i].base,memTab[i].size);
324 }
325 }
326 #endif
327 }
329 /*
330 * The PAF_ALG_init function initializes the memTab's to default values.
331 */
333 Void
334 PAF_ALG_init_ (
335 IALG_MemRec memTab[],
336 Int n,
337 const IALG_MemSpace memSpace[])
338 {
339 Int i;
341 for (i=0; i<n; i++) {
342 memTab[i].size = 0;
343 memTab[i].alignment = 0;
344 memTab[i].base = NULL;
345 memTab[i].space = memSpace ? memSpace[i] : PAF_IALG_NONE;
346 // TRACE_GEN((&TR_MOD, "PAF_ALG_init_[%d]:space %d", i, memTab[i].space));
347 }
348 }
350 /*
351 * PAF_ALG_activate is derived from standard XDAIS ALG_activate function defined in the
352 * file alg_malloc.c version "XDAS 2.2.1 12-07-01".
353 */
355 #ifdef _TMS320C6X
356 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
357 #pragma CODE_SECTION(PAF_ALG_activate,".text:_PAF_ALG_activate")
358 #endif
360 Void
361 PAF_ALG_activate (
362 ALG_Handle alg)
363 {
364 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
365 asm (" .clink");
366 #endif
368 if (alg->fxns->algActivate != NULL) {
369 alg->fxns->algActivate (alg);
370 }
371 }
373 /*
374 * PAF_ALG_deactivate is derived from standard XDAIS ALG_deactivate function defined in the
375 * file alg_malloc.c version "XDAS 2.2.1 12-07-01".
376 */
378 #ifdef _TMS320C6X
379 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
380 #pragma CODE_SECTION(PAF_ALG_deactivate,".text:_PAF_ALG_deactivate")
381 #endif
383 Void
384 PAF_ALG_deactivate (
385 ALG_Handle alg)
386 {
387 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
388 asm (" .clink");
389 #endif
391 if (alg->fxns->algDeactivate != NULL) {
392 alg->fxns->algDeactivate(alg);
393 }
394 }
396 /*
397 * The PAF_ALG_memSpaceToHeapId function is derived from ALGRF_memSpace function
398 * defined in the TI released algrf.h file ver "ALGRF 0.02.06 11-21-01".
399 */
401 Int
402 PAF_ALG_memSpaceToHeapId_ (
403 const PAF_IALG_Config *p,
404 IALG_MemSpace space)
405 {
406 switch(space)
407 {
408 case IALG_SARAM: /* IALG_SARAM0 = IALG_SARAM : Normally used for IRAM */ // FL: K2G: used for L2 on DSP
409 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
410 return p->iHeapId;
412 case IALG_EXTERNAL: // normally external SDRAM // FL: K2G: used for DDR local memory
413 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
414 return p->eHeapId;
416 case IALG_SARAM1: // FL: K2G: used for MSMC local memory
417 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
418 return p->lHeapId;
420 case IALG_SARAM2: // FL: K2G: used for MSMC shared memory
421 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM2 (IALG_SARAM_SHM) (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
422 return p->lHeapIdShm;
424 case IALG_DARAM0: // Can't use this because it is zero and overridden
425 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
426 return p->iHeapId;
428 case IALG_DARAM1: // not normally used.
429 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
430 return p->iHeapId;
432 case IALG_DARAM2: // not normally used.
433 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
434 return p->iHeapId; // not normally used.
436 case IALG_ESDATA: // FL: K2G: used for DDR shared memory
437 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_ESDATA (IALG_EXTERNAL_SHM) (0x%x) 0x%x", __LINE__, space, p->eHeapIdShm));
438 return p->eHeapIdShm;
440 case IALG_ENCSDATA: // K2G: used for DDR shared non-cacheable memory
441 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_ENCSDATA (PAF_HEAP_ID_EXT_NON_CACHED_SHM) (0x%x) 0x%x", __LINE__, space, p->eHeapIdNCShm));
442 return p->eHeapIdNCShm;
444 default:
445 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
446 return p->eHeapId;
447 }
449 }
451 HeapMem_Handle
452 PAF_ALG_memSpaceToHeap_ (
453 const PAF_IALG_Config *p,
454 IALG_MemSpace space)
455 {
456 switch(space)
457 {
458 case IALG_SARAM: /* IALG_SARAM0 = IALG_SARAM : Normally used for IRAM. */ // FL: K2G: used for L2 on DSP
459 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
460 return p->hIHeap;
462 case IALG_EXTERNAL: // normally external SDRAM // FL: K2G: used for DDR local memory
463 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
464 return p->hEHeap;
466 case IALG_SARAM1: // FL: K2G: used for MSMC local memory
467 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
468 return p->hLHeap;
470 case IALG_SARAM2:
471 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM2 (IALG_SARAM_SHM) (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
472 return p->hLHeapShm;
474 case IALG_DARAM0: // Can't use this because it is zero and overridden
475 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
476 return p->hIHeap;
478 case IALG_DARAM1: // not normally used.
479 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
480 return p->hIHeap;
482 case IALG_DARAM2: // not normally used.
483 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
484 return p->hIHeap; // not normally used.
486 case IALG_ESDATA: // FL: K2G: used for DDR shared memory
487 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapIdShm));
488 return p->hEHeapShm;
490 case IALG_ENCSDATA: // K2G: used for DDR shared non-cacheable memory
491 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_ENCSDATA (0x%x) 0x%x", __LINE__, space, p->eHeapIdNCShm));
492 return p->hEHeapNCShm;
494 default:
495 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
496 return p->hEHeap;
497 }
498 }
500 /*
501 * The PAF_ALG_setup function is derived from ALGRF_setup function defined in
502 * the TI released algrf_setup.c file ver "ALGRF 0.02.06 11-21-01" .
503 */
505 #ifdef _TMS320C6X
506 #pragma CODE_SECTION(PAF_ALG_setup_,".text:_PAF_ALG_setup_")
507 #endif
508 Void
509 PAF_ALG_setup_ (
510 PAF_IALG_Config *p,
511 Int iHeapId,
512 HeapMem_Handle hIHeap,
513 Int lHeapId,
514 HeapMem_Handle hLHeap,
515 Int eHeapId,
516 HeapMem_Handle hEHeap,
517 Int lHeapIdShm,
518 HeapMem_Handle hLHeapShm,
519 Int eHeapIdShm,
520 HeapMem_Handle hEHeapShm,
521 Int eHeapIdNCShm,
522 HeapMem_Handle hEHeapNCShm,
523 Int clr
524 )
525 {
526 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
527 asm (" .clink");
528 #endif
530 /* initialize heap Ids */
531 p->iHeapId = iHeapId;
532 p->lHeapId = lHeapId;
533 p->eHeapId = eHeapId;
534 p->lHeapIdShm = lHeapIdShm;
535 p->eHeapIdShm = eHeapIdShm;
536 p->eHeapIdNCShm = eHeapIdNCShm;
538 /* initialize heap handles */
539 p->hIHeap = hIHeap;
540 p->hLHeap = hLHeap;
541 p->hEHeap = hEHeap;
542 p->hLHeapShm = hLHeapShm;
543 p->hEHeapShm = hEHeapShm;
544 p->hEHeapNCShm = hEHeapNCShm;
546 /* initialize clear flag */
547 p->clr=clr;
549 // TRACE_GEN((&TR_MOD, "PAF_ALG_memSpace_.%d: IPAF_ALG_setup_", __LINE__));
550 }