[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)
127 {
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 }
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 0);
211 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
212 //if(!(memTab[i].base=(void *)MEM_alloc(
213 // PAF_ALG_memSpace(&pafConfig,memTab[i].space),
214 // memTab[i].size,memTab[i].alignment)))
215 if (!(memTab[i].base = (void *)Memory_alloc(
216 (IHeap_Handle)PAF_ALG_memSpaceToHeap(&pafConfig, memTab[i].space),
217 memTab[i].size,
218 memTab[i].alignment,
219 &eb)))
220 {
221 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.",__LINE__, memTab[i].size));
222 SW_BREAKPOINT;
223 return PAF_ALGERR_PERSIST;
224 }
225 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x",
226 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(&pafConfig,memTab[i].space)));
227 }
228 }
229 else
230 {
231 memTab[i].base=NULL;
232 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
233 SW_BREAKPOINT;
234 }
235 }
236 }
237 return 0;
238 }
240 /*
241 * The PAF_ALG_mallocMemory function allocates the memory requested by the
242 * memTab's.
243 */
245 Int
246 PAF_ALG_mallocMemory_ (
247 IALG_MemRec common[],
248 PAF_IALG_Config *p)
249 {
250 Int i;
251 Error_Block eb;
253 // Initialize error block
254 Error_init(&eb);
256 for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i)
257 {
258 if(0 == common[i].size)
259 continue;
261 if(p->clr)
262 {
263 TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: calloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
264 //common[i].base = (void *)MEM_calloc( PAF_ALG_memSpace(p,common[i].space), common[i].size, common[i].alignment);
265 common[i].base = (void *)Memory_calloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p,common[i].space), common[i].size, common[i].alignment, &eb);
266 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
267 }
268 else
269 {
270 TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: alloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
271 //common[i].base = (void *)MEM_alloc(PAF_ALG_memSpace(p, common[i].space),common[i].size, common[i].alignment);
272 common[i].base = (void *)Memory_alloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p, common[i].space), common[i].size, common[i].alignment, &eb);
273 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
274 }
276 if(!(common[i].base))
277 {
278 TRACE_TERSE((&TR_MOD, "PAF_ALG_mallocMemory_.%d: (c)alloc %d bytes failed", __LINE__, common[i].size));
279 SW_BREAKPOINT;
280 return PAF_ALGERR_COMMON;
281 }
282 }
284 return 0;
285 }
287 /*
288 * The PAF_ALG_freeMemory is derived from _ALG_freeMemory function defined
289 * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
290 * It is extended to check for the Performance Audio specific "Common"
291 * memory and scratch memory.
292 */
294 Void
295 PAF_ALG_freeMemory(
296 IALG_MemRec memTab[],
297 Int n)
298 {
300 #ifdef _TMS320C6X
301 //#warn Cannot free memory here because segids are not known
302 #endif
304 // Cannot free memory here bacause there is no way to determine
305 // the segid needed by MEM_free.
306 // Not an issuue as of now, in PA, because, if alg creation fails
307 // system does not do any thing further.
308 //
309 #if 0
310 Int i;
311 Int segid;
313 for(i=0;i<n;i++){
314 if(memTab[i].base != NULL && !(memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
315 memTab[i].attrs >= PAF_IALG_COMMON_MEM1 && memTab[i].attrs <= PAF_IALG_COMMON_MEMN))
316 {
317 #warn MEM_free might be
318 segid = (memTab[i].space == IALG_SARAM)?IRAM:SDRAM;
319 MEM_free(segid,memTab[i].base,memTab[i].size);
320 }
321 }
322 #endif
323 }
325 /*
326 * The PAF_ALG_init function initializes the memTab's to default values.
327 */
329 Void
330 PAF_ALG_init_ (
331 IALG_MemRec memTab[],
332 Int n,
333 const IALG_MemSpace memSpace[])
334 {
335 Int i;
337 for (i=0; i<n; i++) {
338 memTab[i].size = 0;
339 memTab[i].alignment = 0;
340 memTab[i].base = NULL;
341 memTab[i].space = memSpace ? memSpace[i] : PAF_IALG_NONE;
342 // TRACE_GEN((&TR_MOD, "PAF_ALG_init_[%d]:space %d", i, memTab[i].space));
343 }
344 }
346 /*
347 * PAF_ALG_activate is derived from standard XDAIS ALG_activate function defined in the
348 * file alg_malloc.c version "XDAS 2.2.1 12-07-01".
349 */
351 #ifdef _TMS320C6X
352 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
353 #pragma CODE_SECTION(PAF_ALG_activate,".text:_PAF_ALG_activate")
354 #endif
356 Void
357 PAF_ALG_activate (
358 ALG_Handle alg)
359 {
360 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
361 asm (" .clink");
362 #endif
364 if (alg->fxns->algActivate != NULL) {
365 alg->fxns->algActivate (alg);
366 }
367 }
369 /*
370 * PAF_ALG_deactivate is derived from standard XDAIS ALG_deactivate function defined in the
371 * file alg_malloc.c version "XDAS 2.2.1 12-07-01".
372 */
374 #ifdef _TMS320C6X
375 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
376 #pragma CODE_SECTION(PAF_ALG_deactivate,".text:_PAF_ALG_deactivate")
377 #endif
379 Void
380 PAF_ALG_deactivate (
381 ALG_Handle alg)
382 {
383 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
384 asm (" .clink");
385 #endif
387 if (alg->fxns->algDeactivate != NULL) {
388 alg->fxns->algDeactivate(alg);
389 }
390 }
392 /*
393 * The PAF_ALG_memSpaceToHeapId function is derived from ALGRF_memSpace function
394 * defined in the TI released algrf.h file ver "ALGRF 0.02.06 11-21-01".
395 */
397 Int
398 PAF_ALG_memSpaceToHeapId_ (
399 const PAF_IALG_Config *p,
400 IALG_MemSpace space)
401 {
402 switch(space)
403 {
404 case IALG_SARAM: /* IALG_SARAM0 = IALG_SARAM : Normally used for IRAM. */
405 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
406 return p->iHeapId;
408 case IALG_EXTERNAL: // normally external SDRAM
409 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
410 return p->eHeapId;
412 case IALG_SARAM1:
413 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
414 return p->lHeapId;
416 case IALG_SARAM2:
417 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM2 (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
418 return p->lHeapIdShm;
420 case IALG_DARAM0: // Can't use this because it is zero and overridden
421 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
422 return p->iHeapId;
424 case IALG_DARAM1: // not normally used.
425 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
426 return p->iHeapId;
428 case IALG_DARAM2: // not normally used.
429 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
430 return p->iHeapId; // not normally used.
432 case IALG_ESDATA: // not normally used.
433 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapId));
434 return p->eHeapId;
436 default:
437 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
438 return p->eHeapId;
439 }
441 }
443 HeapMem_Handle
444 PAF_ALG_memSpaceToHeap_ (
445 const PAF_IALG_Config *p,
446 IALG_MemSpace space)
447 {
448 switch(space)
449 {
450 case IALG_SARAM: /* IALG_SARAM0 = IALG_SARAM : Normally used for IRAM. */
451 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
452 return p->hIHeap;
454 case IALG_EXTERNAL: // normally external SDRAM
455 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
456 return p->hEHeap;
458 case IALG_SARAM1: // Used by Dolby Digital
459 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
460 return p->hLHeap;
462 case IALG_SARAM2:
463 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
464 return p->hLHeapShm;
466 case IALG_DARAM0: // Can't use this because it is zero and overridden
467 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
468 return p->hIHeap;
470 case IALG_DARAM1: // not normally used.
471 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
472 return p->hIHeap;
474 case IALG_DARAM2: // not normally used.
475 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
476 return p->hIHeap; // not normally used.
478 case IALG_ESDATA: // not normally used.
479 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapId));
480 return p->hEHeap;
482 default:
483 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
484 return p->hEHeap;
485 }
486 }
488 /*
489 * The PAF_ALG_setup function is derived from ALGRF_setup function defined in
490 * the TI released algrf_setup.c file ver "ALGRF 0.02.06 11-21-01" .
491 */
493 #ifdef _TMS320C6X
494 #pragma CODE_SECTION(PAF_ALG_setup_,".text:_PAF_ALG_setup_")
495 #endif
496 Void
497 PAF_ALG_setup_ (
498 PAF_IALG_Config *p,
499 Int iHeapId,
500 HeapMem_Handle hIHeap,
501 Int lHeapId,
502 HeapMem_Handle hLHeap,
503 Int eHeapId,
504 HeapMem_Handle hEHeap,
505 Int lHeapIdShm,
506 HeapMem_Handle hLHeapShm,
507 Int clr
508 )
509 {
510 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
511 asm (" .clink");
512 #endif
514 /* initialize heap Ids */
515 p->iHeapId = iHeapId;
516 p->lHeapId = lHeapId;
517 p->eHeapId = eHeapId;
518 p->lHeapIdShm = lHeapIdShm;
520 /* initialize heap handles */
521 p->hIHeap = hIHeap;
522 p->hLHeap = hLHeap;
523 p->hEHeap = hEHeap;
524 p->hLHeapShm = hLHeapShm;
526 /* initialize clear flag */
527 p->clr=clr;
529 // TRACE_GEN((&TR_MOD, "PAF_ALG_memSpace_.%d: IPAF_ALG_setup_", __LINE__));
530 }