pasdk/common/paf_alg_malloc.c

   1
   2 /*
   3 Copyright (c) 2016, 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 // Algorithm Memory Allocation
  38 //
  39
  40 /*
  41  * File Inclusions
  42  */
  43
  44 #include <xdc/std.h>
  45 #include <xdc/cfg/global.h>
  46
  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>
  52
  53 //#include <stdlib.h>
  54 //#include <string.h>
  55
  56 #include "alg.h"
  57
  58 //#include "pafhjt.h"
  59 #include "paf_alg.h"
  60 #include "paf_alg_priv.h"
  61
  62 #include "paf_ialg.h"
  63
  64 #include "common.h"
  65 #include "paf_heapMgr.h"
  66
  67 //extern int IRAM;
  68 //extern int SDRAM;
  69 //extern int L3RAM;
  70
  71
  72 // -----------------------------------------------------------------------------
  73 // Debugging Trace Control, local to this file.
  74 //
  75
  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 */
  80
  81 #include <logp.h>
  82
  83 // allows you to set a different trace module in pa.cfg
  84 #define TR_MOD  trace
  85
  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
  89
  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
  93
  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
  99
 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
 105
 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
 111
 112 // Note:  memory spaces are defined in ialg.h from the xdais package.
 113 // 17 is external.  2 and 5 are internal.
 114
 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  */
 122
 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;
 134
 135     // Initialize error block
 136     Error_init(&eb);
 137
 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     }
 148
 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 }
 243
 244 /*
 245  * The PAF_ALG_mallocMemory function allocates the memory requested by the
 246  * memTab's.
 247  */
 248
 249 Int
 250 PAF_ALG_mallocMemory_ (
 251     IALG_MemRec common[],
 252     PAF_IALG_Config *p)
 253 {
 254     Int i;
 255     Error_Block eb;
 256
 257     // Initialize error block
 258     Error_init(&eb);
 259
 260     for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i)
 261     {
 262         if(0 == common[i].size)
 263             continue;
 264
 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         }
 279
 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     }
 287
 288     return 0;
 289 }
 290
 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  */
 297
 298 Void
 299 PAF_ALG_freeMemory(
 300     IALG_MemRec memTab[],
 301     Int n)
 302 {
 303
 304 #ifdef _TMS320C6X
 305 //#warn Cannot free memory here because segids are not known
 306 #endif
 307
 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;
 316
 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 }
 328
 329 /*
 330  * The PAF_ALG_init function initializes the memTab's to default values.
 331  */
 332
 333 Void
 334 PAF_ALG_init_ (
 335     IALG_MemRec memTab[],
 336     Int n,
 337     const IALG_MemSpace memSpace[])
 338 {
 339     Int i;
 340
 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 }
 349
 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  */
 354
 355 #ifdef _TMS320C6X
 356 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
 357 #pragma CODE_SECTION(PAF_ALG_activate,".text:_PAF_ALG_activate")
 358 #endif
 359
 360 Void
 361 PAF_ALG_activate (
 362     ALG_Handle alg)
 363 {
 364 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
 365     asm (" .clink");
 366 #endif
 367
 368     if (alg->fxns->algActivate != NULL) {
 369         alg->fxns->algActivate (alg);
 370     }
 371 }
 372
 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  */
 377
 378 #ifdef _TMS320C6X
 379 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
 380 #pragma CODE_SECTION(PAF_ALG_deactivate,".text:_PAF_ALG_deactivate")
 381 #endif
 382
 383 Void
 384 PAF_ALG_deactivate (
 385     ALG_Handle alg)
 386 {
 387 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
 388     asm (" .clink");
 389 #endif
 390
 391     if (alg->fxns->algDeactivate != NULL) {
 392         alg->fxns->algDeactivate(alg);
 393     }
 394 }
 395
 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  */
 400
 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;
 411
 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;
 415
 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;
 419
 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;
 423
 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;
 427
 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;
 431
 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.
 435
 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;
 439
 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;
 443
 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     }
 448
 449 }
 450
 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;
 461
 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;
 465
 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;
 469
 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;
 473
 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;
 477
 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;
 481
 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.
 485
 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;
 489
 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;
 493
 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 }
 499
 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  */
 504
 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
 529
 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;
 537
 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;
 545
 546     /* initialize clear flag */
 547     p->clr=clr;
 548
 549     // TRACE_GEN((&TR_MOD, "PAF_ALG_memSpace_.%d: IPAF_ALG_setup_", __LINE__));
 550 }