DisparityOmp.cfg

/*
 * image_processing_evm6678l_master.cfg
 *
 * Memory Map and Program initializations for the Image Processing Application
 *
 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ 
 *  
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions 
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the   
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
*/

/*
 *   @file  image_processing_openmp_evmc6678l.cfg
 *
 *   @brief   
 *      Memory Map and Program initializations for the Image Processing Application.
 *
 */
 
/*******************************************************************************************
*  Specify all needed RTSC Moudles and configure them.                                     *
********************************************************************************************/

var Memory    = xdc.useModule('xdc.runtime.Memory');
var Log       = xdc.useModule('xdc.runtime.Log');
var Error     = xdc.useModule('xdc.runtime.Error');
var Diags     = xdc.useModule('xdc.runtime.Diags');
var Timestamp = xdc.useModule('xdc.runtime.Timestamp');
var Startup   = xdc.useModule('xdc.runtime.Startup');
var System    = xdc.useModule('xdc.runtime.System');
//var SysStd    = xdc.useModule('xdc.runtime.SysStd');
var Main      = xdc.useModule("xdc.runtime.Main");

//System.SupportProxy = SysStd;

var SysMin = xdc.useModule("xdc.runtime.SysMin");
System.SupportProxy = SysMin;
SysMin.bufSize = 0x8000;


/* Load and configure SYSBIOS packages */
var BIOS      = xdc.useModule('ti.sysbios.BIOS');
var Task      = xdc.useModule('ti.sysbios.knl.Task');
var Clock     = xdc.useModule('ti.sysbios.knl.Clock');
var Mailbox   = xdc.useModule('ti.sysbios.knl.Mailbox'); 
var Hwi       = xdc.useModule('ti.sysbios.hal.Hwi');
var Ecm       = xdc.useModule('ti.sysbios.family.c64p.EventCombiner');
var BiosCache = xdc.useModule('ti.sysbios.hal.Cache');
var HeapBuf   = xdc.useModule('ti.sysbios.heaps.HeapBuf');
var HeapMem   = xdc.useModule('ti.sysbios.heaps.HeapMem');
var Exc       = xdc.useModule('ti.sysbios.family.c64p.Exception');
var Cache     = xdc.useModule('ti.sysbios.family.c66.Cache');

BIOS.taskEnabled = true;
Task.common$.namedInstance = true;

/*
 * Enable Event Groups here and registering of ISR for specific GEM INTC is done
 * using EventCombiner_dispatchPlug() and Hwi_eventMap() APIs
 */

Ecm.eventGroupHwiNum[0] = 7;
Ecm.eventGroupHwiNum[1] = 8;
Ecm.eventGroupHwiNum[2] = 9;
Ecm.eventGroupHwiNum[3] = 10;

/* Create a Heap. */
var heapMemParams = new HeapMem.Params();
heapMemParams.size = 0x8000000;
heapMemParams.sectionName = "ddr_heap";
Program.global.ddr_heap = HeapMem.create(heapMemParams);

/* Load and configure NDK */
var Global = xdc.useModule('ti.ndk.config.Global');

/* 
** This allows the heart beat (poll function) to be created but does not generate the stack threads 
**
** Look in the cdoc (help files) to see what CfgAddEntry items can be configured. We tell it NOT
** to create any stack threads (services) as we configure those ourselves in our Main Task
** thread.
*/  
Global.enableCodeGeneration = false;

/* Load the PDK packages */
var Csl  = xdc.useModule('ti.csl.Settings');
var Pa   = xdc.useModule('ti.drv.pa.Settings');
var Cppi = xdc.loadPackage('ti.drv.cppi');     
var Qmss = xdc.loadPackage('ti.drv.qmss');

/* Load the Platform/NDK Transport packages */
var PlatformLib  = xdc.loadPackage('ti.platform.evmc6678l');
var NdkTransport = xdc.loadPackage('ti.transport.ndk');

/* Use more efficient Notify driver */
var Notify        = xdc.module('ti.sdo.ipc.Notify');
Notify.SetupProxy = xdc.module('ti.sdo.ipc.family.c647x.NotifyCircSetup');

/* Use more efficient MessageQ transport */
var MessageQ = xdc.module('ti.sdo.ipc.MessageQ');
MessageQ.SetupTransportProxy = 
        xdc.useModule('ti.sdo.ipc.transports.TransportShmNotifySetup');

Startup.firstFxns.$add('&lld_init');


var SharedRegion = xdc.useModule('ti.sdo.ipc.SharedRegion');

 

/* Load OpenMP module */
var OpenMP = xdc.useModule('ti.omp.utils.OpenMP');
OpenMP.stackSize = 0x4000;
OpenMP.setNumProcessors(8);
OpenMP.qmssInit = false;
OpenMP.ipcHeapSize = 0x30000;
OpenMP.qmssMemRegion = -1;
OpenMP.qmssStartIndex = 0;
OpenMP.qmssDestQueueNum = -1;
OpenMP.stackRegionId = -1;
OpenMP.internalOsal = true;
OpenMP.cppiHwSem = 3;
OpenMP.qmssHwSem = 4;
OpenMP.mpaxIndex = 3;
OpenMP.enableMemoryConsistency = false;

// Configure HeapOMP

// HeapOMP created in ti/omp/common.cfg.xs

var HeapOMP = xdc.useModule('ti.omp.utils.HeapOMP');
HeapOMP.sharedRegionId = 2;
HeapOMP.localHeapSize  = 0x20000;
HeapOMP.sharedHeapSize = 0x1000000;
//HeapOMP.localHeapSize  = 0x10000;
//HeapOMP.sharedHeapSize = 0x0100000;


// Specify the Shared Region

SharedRegion.setEntryMeta( HeapOMP.sharedRegionId,
                           {   base: 0x90000000,
                               len:  HeapOMP.sharedHeapSize,
                               ownerProcId: 0,
                               cacheLineSize: 0,
                               cacheEnable: false,
                               createHeap: true,
                               isValid: true,
                               name: "sr2-ddr3",
                           }
);

//

// Setup HeapOMP

//

// Initialize HeapMem parameters
var HeapOMP      = xdc.useModule('ti.omp.utils.HeapOMP');
var HeapMem      = xdc.useModule('ti.sysbios.heaps.HeapMem');
var heapMemParams = new HeapMem.Params();
heapMemParams.size = HeapOMP.localHeapSize;

// Create a HeapOMP instance
var heapOmpParams = new HeapOMP.Params();
heapOmpParams.localHeap = HeapMem.create(heapMemParams)
heapOmpParams.sRegionId = HeapOMP.sharedRegionId;

// Setup defaultHeapInstance to a HeapOMP instance

var Memory       = xdc.useModule('xdc.runtime.Memory');
if (Memory.defaultHeapInstance)
    Program.$logWarning("Memory.defaultHeapInstance already set!", this);

Memory.defaultHeapInstance = HeapOMP.create(heapOmpParams)

Task.defaultStackSize = 0x4000;
//BIOS.heapSize = 0x50000;

Program.sectMap[".cio"]              = {loadSegment: "L2SRAM", loadAlign:8};
Program.sectMap[".args"]             = {loadSegment: "L2SRAM", loadAlign:8};
Program.sectMap[".cppi"]             = {loadSegment: "MSMCSRAM", loadAlign:16};
Program.sectMap[".qmss"]             = {loadSegment: "MSMCSRAM", loadAlign:16};
Program.sectMap[".nimu_eth_ll2"]     = {loadSegment: "MSMCSRAM", loadAlign:16};
Program.sectMap[".far:NDK_PACKETMEM"]= {loadSegment: "MSMCSRAM", loadAlign: 128};
Program.sectMap[".far:NDK_OBJMEM"]   = {loadSegment: "L2SRAM", loadAlign: 16};
Program.sectMap[".resmgr_memregion"] = {loadSegment: "MSMCSRAM", loadAlign:128};
Program.sectMap[".resmgr_handles"]   = {loadSegment: "MSMCSRAM", loadAlign:16};
Program.sectMap[".resmgr_pa"]        = {loadSegment: "MSMCSRAM", loadAlign:8};

Program.sectMap["ddr_heap"]          = "DDR3";
Program.sectMap[".plt"]              = "MSMCSRAM";
Program.sectMap["platform_lib"]      = "MSMCSRAM";
Program.sectMap[".text"]             = "MSMCSRAM";
Program.sectMap[".far:NDK_MMBUFFER1"]= "MSMCSRAM";

Program.sectMap["ddr"] = new Program.SectionSpec();
Program.sectMap["ddr"].loadSegment = "DDR3_NOCACHE";
Program.sectMap[".threadprivate"] = new Program.SectionSpec();
Program.sectMap[".threadprivate"].loadSegment = "L2SRAM";

Program.sectMap[".leftImg"] = {loadSegment : "MSMCSRAM", loadAlign:8};
Program.sectMap[".rightImg"] = {loadSegment : "MSMCSRAM", loadAlign:8};
Program.sectMap[".outImg"] = {loadSegment : "MSMCSRAM", loadAlign:8};

Program.sectMap[".leftImg1"] = {loadSegment : "MSMCSRAM", loadAlign:8};
Program.sectMap[".rightImg1"] = {loadSegment : "MSMCSRAM", loadAlign:8};
Program.sectMap[".outImg1"] = {loadSegment : "MSMCSRAM", loadAlign:8};


var Cache        = xdc.useModule('ti.sysbios.family.c66.Cache');
//Cache.setMarMeta(0x80000000, 0x20000000, Cache.PC );
//Cache.setMarMeta(0x80000000, 0x20000000, Cache.PC|Cache.PFX );

// Do not cache DDR - Shared region 2 in OpenMP.xs is marked as non-cacheable
// These 2 settings need to be in sync!
Cache.setMarMeta(0x90000000, 0x10000000, 0);
//Cache.setMarMeta(0x0c000000, 0x0100000, 0);

/* Add init function */
Startup.lastFxns.$add('&EVM_init');

/*BIOS.libType = BIOS.LibType_Debug;*/

/*Hassan's additions*/
var Semaphore	= xdc.useModule ('ti.sysbios.knl.Semaphore');
var buf0sem = new Semaphore.Params();
buf0sem.mode = Semaphore.Mode_BINARY;
Program.global.buf0Sem = Semaphore.create(1, buf0sem);


var buf1sem = new Semaphore.Params();
buf1sem.mode = Semaphore.Mode_BINARY;
Program.global.buf1Sem = Semaphore.create(1, buf1sem);