procsdk_audio_x_xx_xx_xx/common/paf_alg_malloc.c

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