Int FirmwareLoad_startup (UInt16 procId, String filePath) { Int status = 0; ProcMgr_Handle handle = NULL; ProcMgr_AttachParams attachParams; ProcMgr_StartParams startParams; //String args [NUM_ARGS]; UInt32 fileId; status = ProcMgr_open (&handle, procId); if (status >= 0) { ProcMgr_getAttachParams (NULL, &attachParams); /* Default params will be used if NULL is passed. */ status = ProcMgr_attach (handle, &attachParams); if (status < 0) printf ("ProcMgr_attach failed [0x%x]\n", status); else printf ("Attached to slave procId %d.\n", procId); if(status >= 0) { /* Send filePath as the args to the slave to demonstrate how args * are used. */ //args [0] = filePath; status = ProcMgr_load (handle, filePath, 0, NULL, NULL, &fileId); if (status < 0) printf ("Error in ProcMgr_load [0x%x]\n", status); else printf ("Loaded file %s on slave procId %d.\n", filePath, procId); } if (status >= 0) { ProcMgr_getStartParams (handle, &startParams); status = ProcMgr_start (handle, &startParams); if (status < 0) printf ("ProcMgr_start failed [0x%x]\n", status); else printf ("Started slave procId %d.\n", procId); } status = ProcMgr_close (&handle); } if(status>=0) status = FirmwareLoad_ipcStart(procId); return status; }
/* * ======== ipcSetup ======== */ Int ipcSetup (Int testCase) { Int status = 0; Char * procName; UInt16 procId; ProcMgr_AttachParams attachParams; ProcMgr_State state; #if !defined(SYSLINK_USE_DAEMON) UInt32 entryPoint = 0; ProcMgr_StartParams startParams; Char uProcId; HeapBufMP_Params heapbufmpParams; #if defined(SYSLINK_USE_LOADER) Char * imageName; UInt32 fileId; #endif #endif Ipc_Config config; Int i; UInt32 srCount; SharedRegion_Entry srEntry; Osal_printf ("ipcSetup: Setup IPC componnets \n"); switch(testCase) { case 0: Osal_printf ("ipcSetup: Local RCM test\n"); remoteServerName = RCMSERVER_NAME; procName = MPU_PROC_NAME; break; case 1: Osal_printf ("ipcSetup: RCM test with RCM client and server on " "Sys M3\n\n"); remoteServerName = SYSM3_SERVER_NAME; procName = SYSM3_PROC_NAME; break; case 2: Osal_printf ("ipcSetup: RCM test with RCM client and server on " "App M3\n\n"); remoteServerName = APPM3_SERVER_NAME; procName = APPM3_PROC_NAME; break; case 3: Osal_printf ("ipcSetup: RCM test with RCM client and server on " "Tesla\n\n"); remoteServerName = DSP_SERVER_NAME; procName = DSP_PROC_NAME; break; default: Osal_printf ("ipcSetup: Please pass valid arg " "(0-local, 1-Sys M3, 2-App M3, 3-Tesla) \n"); goto exit; break; } Ipc_getConfig (&config); status = Ipc_setup (&config); if (status < 0) { Osal_printf ("ipcSetup: Error in Ipc_setup [0x%x]\n", status); goto exit; } Osal_printf("Ipc_setup status [0x%x]\n", status); procId = ((testCase == 3) ? MultiProc_getId (DSP_PROC_NAME) : \ MultiProc_getId (SYSM3_PROC_NAME)); remoteIdClient = MultiProc_getId (procName); /* Open a handle to the ProcMgr instance. */ status = ProcMgr_open (&procMgrHandleClient, procId); if (status < 0) { Osal_printf ("ipcSetup: Error in ProcMgr_open [0x%x]\n", status); goto exit; } if (status >= 0) { Osal_printf ("ipcSetup: ProcMgr_open Status [0x%x]\n", status); ProcMgr_getAttachParams (NULL, &attachParams); /* Default params will be used if NULL is passed. */ status = ProcMgr_attach (procMgrHandleClient, &attachParams); if (status < 0) { Osal_printf ("ipcSetup: ProcMgr_attach failed [0x%x]\n", status); } else { Osal_printf ("ipcSetup: ProcMgr_attach status: [0x%x]\n", status); state = ProcMgr_getState (procMgrHandleClient); Osal_printf ("ipcSetup: After attach: ProcMgr_getState\n" " state [0x%x]\n", state); } } if ((status >= 0) && (testCase == 2)) { status = ProcMgr_open (&procMgrHandleClient1, remoteIdClient); if (status < 0) { Osal_printf ("ipcSetup: Error in ProcMgr_open [0x%x]\n", status); goto exit; } if (status >= 0) { Osal_printf ("ipcSetup: ProcMgr_open Status [0x%x]\n", status); ProcMgr_getAttachParams (NULL, &attachParams); /* Default params will be used if NULL is passed. */ status = ProcMgr_attach (procMgrHandleClient1, &attachParams); if (status < 0) { Osal_printf ("ipcSetup: ProcMgr_attach failed [0x%x]\n", status); } else { Osal_printf ("ipcSetup: ProcMgr_attach status: [0x%x]\n", status); state = ProcMgr_getState (procMgrHandleClient1); Osal_printf ("ipcSetup: After attach: ProcMgr_getState\n" " state [0x%x]\n", state); } } } #if !defined(SYSLINK_USE_DAEMON) /* Daemon sets this up */ #if defined(SYSLINK_USE_LOADER) if (testCase == 1) imageName = RCM_MPUCLIENT_SYSM3ONLY_IMAGE; else if (testCase == 2) imageName = RCM_MPUCLIENT_SYSM3_IMAGE; else if (testCase == 3) imageName = RCM_MPUCLIENT_DSP_IMAGE; if (testCase != 0) { status = ProcMgr_load (procMgrHandleClient, imageName, 2, &imageName, &entryPoint, &fileId, procId); if (status < 0) { Osal_printf ("ipcSetup: Error in ProcMgr_load %s image [0x%x]\n", procName, status); goto exit; } Osal_printf ("ipcSetup: ProcMgr_load %s image Status [0x%x]\n", procName, status); } #endif /* defined(SYSLINK_USE_LOADER) */ if (testCase != 0) { startParams.proc_id = procId; status = ProcMgr_start (procMgrHandleClient, entryPoint, &startParams); if (status < 0) { Osal_printf ("ipcSetup: Error in ProcMgr_start %s [0x%x]\n", procName, status); goto exit; } Osal_printf ("ipcSetup: ProcMgr_start %s Status [0x%x]\n", procName, status); } if (testCase == 2) { #if defined(SYSLINK_USE_LOADER) imageName = RCM_MPUCLIENT_APPM3_IMAGE; uProcId = MultiProc_getId (APPM3_PROC_NAME); status = ProcMgr_load (procMgrHandleClient1, imageName, 2, &imageName, &entryPoint, &fileId, uProcId); if (status < 0) { Osal_printf ("ipcSetup: Error in ProcMgr_load AppM3 image: " "[0x%x]\n", status); goto exit; } Osal_printf ("ipcSetup: AppM3: ProcMgr_load Status [0x%x]\n", status); #endif /* defined(SYSLINK_USE_LOADER) */ startParams.proc_id = MultiProc_getId (APPM3_PROC_NAME); status = ProcMgr_start (procMgrHandleClient1, entryPoint, &startParams); if (status < 0) { Osal_printf ("ipcSetup: Error in ProcMgr_start AppM3 [0x%x]\n", status); goto exit; } Osal_printf ("ipcSetup: ProcMgr_start AppM3 Status [0x%x]\n", status); } #endif /* defined(SYSLINK_USE_DAEMON) */ srCount = SharedRegion_getNumRegions(); Osal_printf ("SharedRegion_getNumRegions = %d\n", srCount); for (i = 0; i < srCount; i++) { status = SharedRegion_getEntry (i, &srEntry); Osal_printf ("SharedRegion_entry #%d: base = 0x%x len = 0x%x " "ownerProcId = %d isValid = %d cacheEnable = %d " "cacheLineSize = 0x%x createHeap = %d name = %s\n", i, srEntry.base, srEntry.len, srEntry.ownerProcId, (Int)srEntry.isValid, (Int)srEntry.cacheEnable, srEntry.cacheLineSize, (Int)srEntry.createHeap, srEntry.name); } #if !defined(SYSLINK_USE_DAEMON) /* Daemon sets this up */ /* Create Heap and register it with MessageQ */ if (status >= 0) { HeapBufMP_Params_init (&heapbufmpParams); heapbufmpParams.sharedAddr = NULL; heapbufmpParams.align = 128; heapbufmpParams.numBlocks = 4; heapbufmpParams.blockSize = MSGSIZE; heapSize = HeapBufMP_sharedMemReq (&heapbufmpParams); Osal_printf ("ipcSetup: heapSize = 0x%x\n", heapSize); srHeap = SharedRegion_getHeap (RCM_HEAP_SR); if (srHeap == NULL) { status = MEMORYOS_E_FAIL; Osal_printf ("ipcSetup: SharedRegion_getHeap failed for srHeap:" " [0x%x]\n", srHeap); } else { Osal_printf ("ipcSetup: Before Memory_alloc = 0x%x\n", srHeap); heapBufPtr = Memory_alloc (srHeap, heapSize, 0); if (heapBufPtr == NULL) { status = MEMORYOS_E_MEMORY; Osal_printf ("ipcSetup: Memory_alloc failed for ptr: [0x%x]\n", heapBufPtr); } else { heapbufmpParams.name = RCM_MSGQ_HEAPNAME; heapbufmpParams.sharedAddr = heapBufPtr; Osal_printf ("ipcSetup: Before HeapBufMP_Create: [0x%x]\n", heapBufPtr); heapHandle = HeapBufMP_create (&heapbufmpParams); if (heapHandle == NULL) { status = HeapBufMP_E_FAIL; Osal_printf ("ipcSetup: HeapBufMP_create failed for Handle:" "[0x%x]\n", heapHandle); } else { /* Register this heap with MessageQ */ status = MessageQ_registerHeap (heapHandle, RCM_MSGQ_HEAPID); if (status < 0) { Osal_printf ("ipcSetup: MessageQ_registerHeap " "failed!\n"); } } } } } #endif /* defined(SYSLINK_USE_DAEMON) */ exit: Osal_printf ("ipcSetup: Leaving ipcSetup()\n"); return status; }
/* * ======== procCreate ======== */ static Bool procCreate(Processor_Handle proc) { Int status = 0; Bool retVal; ProcMgr_AttachParams attachParams; ProcMgr_StartParams startParams; ProcMgr_State state; ProcMgr_AddrInfo CMEMAddrInfo; HeapBufMP_Params heapP; CMEM_BlockAttrs cmemBlockAttrs; Int blockNum; Int nCMEMBlocks; Bool createAndRegisterHeap; Int16 heapId; UInt16 regionId; UInt32 numMsgs; UInt32 msgSize; Char heapName[32]; Log_print1(Diags_ENTRY, "[+E] Processor_create_d> Enter(proc=0x%x)", (IArg)proc); /* Create and initialize the PROC object */ Log_print1(Diags_USER2, "[+2] Processor_create_d> " "Retrieving CPU ID for '%s'...", (IArg)(proc->attrs.cpuId)); proc->cpuId = Processor_getCoreId(proc->attrs.cpuId); if (proc->cpuId < 0) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "Processor_getCoreId() failed: %d", proc->cpuId); goto fail; } /* Open DSP ProcMgr */ Log_print2(Diags_USER2, "[+2] Processor_create_d> " "Opening %s ProcMgr for cpuId %d...", (IArg)proc->attrs.cpuId, proc->cpuId); status = ProcMgr_open(&proc->procMgrH, proc->cpuId); if (status < 0) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "ProcMgr_open() failed: %d", (IArg)status); goto fail; } /* Attach the DSP */ Log_print1(Diags_USER2, "[+2] Processor_create_d> " "Attaching to %s...", (IArg)proc->attrs.cpuId); if (proc->useExtLoader == FALSE) { /* We load the slave */ ProcMgr_getAttachParams(NULL, &attachParams); status = ProcMgr_attach(proc->procMgrH, &attachParams); if (status < 0) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "ProcMgr_attach() failed: %d", (IArg)status); goto fail; } /* Map slave memory */ if (!mapByFile(proc->procMgrH, proc->memMapName, proc->cpuId, TRUE)) { Log_print0(Diags_USER6, "Processor_create_d> mapByFile() failed!"); } /* Load the executable on the DSP */ Log_print3(Diags_USER2, "[+2] Processor_create_d> " "Loading %s on %s (%d args)...", (IArg)(proc->imageName), (IArg)(proc->attrs.cpuId), (IArg)(proc->attrs.argc)); status = ProcMgr_load(proc->procMgrH, proc->imageName, proc->attrs.argc, proc->attrs.argv, NULL, &proc->fileId); if (status < 0) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "ProcMgr_load() failed: %d", status); goto fail; } /* temporary: to be done by SysLink in the future */ Log_print0(Diags_USER1, "[+2] Processor_create_d> " "calling Ipc_control(LOADCALLBACK)..."); status = Ipc_control(proc->cpuId, Ipc_CONTROLCMD_LOADCALLBACK, NULL); Log_print1(Diags_USER1, "[+2] Processor_create_d> " "Ipc_control(LOADCALLBACK) status: %d", (IArg)status); /* Start execution on DSP */ Log_print1(Diags_USER2, "[+2] Processor_create_d> Starting %s ...", (IArg)proc->attrs.cpuId); ProcMgr_getStartParams(proc->procMgrH, &startParams); status = ProcMgr_start(proc->procMgrH, &startParams); if (status < 0) { Log_print1(Diags_USER7, "Processor_create_d> " "ProcMgr_start() failed: %d", status); goto fail; } } // if (proc->useExtLoader == FALSE) else { /* Check the state of the processor to make sure it's really running */ state = ProcMgr_getState(proc->procMgrH); if (state != ProcMgr_State_Running) { Log_print1(Diags_USER7, "Processor_create_d> Invalid processor " "state [%d].", state); goto fail; } Log_print0(Diags_USER1, "[+2] Processor_create_d> " "calling Ipc_control(LOADCALLBACK)..."); status = Ipc_control(proc->cpuId, Ipc_CONTROLCMD_LOADCALLBACK, NULL); proc->loadCallBackStatus = status; Log_print1(Diags_USER1, "[+2] Processor_create_d> " "Ipc_control(LOADCALLBACK) status: %d", (IArg)status); if (status < 0) { Log_print1(Diags_USER7, "Processor_create_d> " "Ipc_control(LOADCALLBACK) failed: %d", status); goto fail; } } status = Ipc_control(proc->cpuId, Ipc_CONTROLCMD_STARTCALLBACK, NULL); proc->startCallBackStatus = status; Log_print1(Diags_USER1, "[+2] Processor_create_d> " "Ipc_control(STARTCALLBACK) status: %d", (IArg)status); if (status < 0) { Log_print1(Diags_USER7, "Processor_create_d> " "Ipc_control(STARTCALLBACK) failed: %d", status); goto fail; } /* get user-specified heapId */ heapId = perCoreHeapId(proc->cpuId); createAndRegisterHeap = FALSE; if (heapId == Processor_INVALID) { /* runtime validation of user configuration */ if (perCoreUserCreatedHeapFlag(proc->cpuId) == TRUE || perCoreNumMsgs(proc->cpuId) != Processor_INVALID || perCoreMsgSize(proc->cpuId) != Processor_INVALID || perCoreSharedRegionId(proc->cpuId) != Processor_INVALID) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "Invalid heap configuration for core %d: " "attempting to set other Processor_CommDesc " "elements while Processor_CommDesc.heapId is " "undefined", proc->cpuId); goto fail; } /* will return default heapId since user didn't specify */ heapId = Processor_getHeapId(proc->cpuId); if (defaultHeapRefCount++ == 0) { createAndRegisterHeap = TRUE; /* tell code below to record heapH in defaultHeapH */ defaultHeapH = (HeapBufMP_Handle)-1; } } else { if (perCoreUserCreatedHeapFlag(proc->cpuId) == FALSE) { createAndRegisterHeap = TRUE; } } if (createAndRegisterHeap) { /* create a heap for message queue usage */ /* get either user-config'ed or module default */ numMsgs = Processor_getNumMsgs(proc->cpuId); msgSize = Processor_getMsgSize(proc->cpuId); regionId = Processor_getSharedRegionId(proc->cpuId); HeapBufMP_Params_init(&heapP); heapP.numBlocks = numMsgs; heapP.blockSize = msgSize; heapP.sharedAddr = NULL; heapP.regionId = regionId; if (defaultHeapH == (HeapBufMP_Handle)-1) { sprintf(heapName, "CE-default"); } else { sprintf(heapName, "CE<->Svr%d", proc->cpuId); } heapP.name = heapName; Log_print2(Diags_USER1, "[+2] Processor_create_d> " "calling HeapBufMP_create(): nblocks %d, blocksize 0x%x", heapP.numBlocks, heapP.blockSize); proc->heapH = HeapBufMP_create(&heapP); if (proc->heapH == NULL) { Log_print0(Diags_USER7, "[+7] Processor_create_d> " "HeapBufMP_create failed"); goto fail; } if (defaultHeapH == (HeapBufMP_Handle)-1) { /* we've just created the module default heap singleton */ defaultHeapH = proc->heapH; } /* register this heap with MessageQ */ Log_print2(Diags_USER1, "[+2] Processor_create_d> " "MessageQ_registerHeap(heapH: 0x%x, heapId: %d)", (IArg)(proc->heapH), (IArg)heapId); if (MessageQ_registerHeap((Ptr)(proc->heapH), heapId) != MessageQ_S_SUCCESS) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "MessageQ_registerHeap() failed for heapId %d", heapId); goto fail; } } else { /* * createAndRegisterHeap == FASLE * If using the default heap, need to set proc->heapH for use by * procDelete(). */ if (heapId == Processor_defaultHeapId) { proc->heapH = defaultHeapH; } } proc->heapId = heapId; blockNum = 0; nCMEMBlocks = 0; status = CMEM_getNumBlocks(&nCMEMBlocks); if (status != 0) { Log_print1(Diags_USER2, "[+2] Processor_create_d> " "CMEM_getNumBlocks() failed, not registering: %d", status); } while (blockNum < nCMEMBlocks) { status = CMEM_getBlockAttrs(blockNum, &cmemBlockAttrs); if (status != 0) { Log_print2(Diags_USER7, "[+7] Processor_create_d> " "CMEM_getBlockAttrs(%d) failed: %d", blockNum, status); goto fail; } CMEMAddrInfo.addr[ProcMgr_AddrType_MasterPhys] = cmemBlockAttrs.phys_base; CMEMAddrInfo.addr[ProcMgr_AddrType_SlaveVirt] = cmemBlockAttrs.phys_base; CMEMAddrInfo.size = cmemBlockAttrs.size; CMEMAddrInfo.isCached = FALSE; Log_print3(Diags_USER1, "[+1] Processor_create_d> CMEM block " "#%d found, doing ProcMgr_map(0x%x, 0x%x)...", blockNum, (IArg)cmemBlockAttrs.phys_base, (IArg)cmemBlockAttrs.size); status = ProcMgr_map(proc->procMgrH, ProcMgr_SLAVEVIRT, &CMEMAddrInfo, ProcMgr_AddrType_MasterPhys); if (status < 0) { Log_print1(Diags_USER7, "[+7] Processor_create_d> " "ProcMgr_map() failed: %d", status); goto fail; } if (CMEMAddrInfo.addr[ProcMgr_AddrType_SlaveVirt] != cmemBlockAttrs.phys_base) { Log_print2(Diags_USER1, "[+2] Processor_create_d> " "mapped CMEM slave virtual address 0x%x doesn't " "match expected value 0x%x", CMEMAddrInfo.addr[ProcMgr_AddrType_SlaveVirt], cmemBlockAttrs.phys_base); } blockNum++; } if (Global_getenv("CE_DSPDEBUG") != NULL) { printf("Codec Engine system message (b/c CE_DSPDEBUG=1) : %s image " "loaded and started, press Enter to continue: ", proc->attrs.cpuId); getchar(); } retVal = TRUE; goto procCreate_return; /* TODO:[4] should try those asyncErrorHandlers that link supports? * (MSGQ_SetErrorHandler) */ fail: Log_print3(Diags_USER7, "[+7] Processor_create_d> " "Loading and starting %s server '%s' FAILED, status=[0x%x]", (IArg)proc->attrs.cpuId, (IArg)proc->imageName, status); procDelete(proc); retVal = FALSE; procCreate_return: Log_print1(Diags_USER2, "[+2] Processor_create_d> return (%d)", (IArg)retVal); return (retVal); }
/* * ======== ipcSetup ======== */ static Int ipcSetup (Char * sysM3ImageName, Char * appM3ImageName) { Ipc_Config config; ProcMgr_StopParams stopParams; ProcMgr_StartParams startParams; UInt32 entryPoint = 0; UInt16 procId; Int status = 0; ProcMgr_AttachParams attachParams; ProcMgr_State state; HeapBufMP_Params heapbufmpParams; Int i; UInt32 srCount; SharedRegion_Entry srEntry; if(appM3ImageName != NULL) appM3Client = TRUE; else appM3Client = FALSE; Ipc_getConfig (&config); status = Ipc_setup (&config); if (status < 0) { Osal_printf ("Error in Ipc_setup [0x%x]\n", status); goto exit; } /* Get MultiProc IDs by name. */ remoteIdSysM3 = MultiProc_getId (SYSM3_PROC_NAME); Osal_printf ("MultiProc_getId remoteId: [0x%x]\n", remoteIdSysM3); remoteIdAppM3 = MultiProc_getId (APPM3_PROC_NAME); Osal_printf ("MultiProc_getId remoteId: [0x%x]\n", remoteIdAppM3); procId = remoteIdSysM3; Osal_printf ("MultiProc_getId procId: [0x%x]\n", procId); /* Temporary fix to account for a timing issue during recovery. */ usleep(FAULT_RECOVERY_DELAY); printf("RCM procId= %d\n", procId); /* Open a handle to the ProcMgr instance. */ status = ProcMgr_open (&procMgrHandleSysM3, procId); if (status < 0) { Osal_printf ("Error in ProcMgr_open [0x%x]\n", status); goto exit_ipc_destroy; } else { Osal_printf ("ProcMgr_open Status [0x%x]\n", status); ProcMgr_getAttachParams (NULL, &attachParams); /* Default params will be used if NULL is passed. */ status = ProcMgr_attach (procMgrHandleSysM3, &attachParams); if (status < 0) { Osal_printf ("ProcMgr_attach failed [0x%x]\n", status); } else { Osal_printf ("ProcMgr_attach status: [0x%x]\n", status); state = ProcMgr_getState (procMgrHandleSysM3); Osal_printf ("After attach: ProcMgr_getState\n" " state [0x%x]\n", status); } } if (status >= 0 && appM3Client) { procId = remoteIdAppM3; Osal_printf ("MultiProc_getId procId: [0x%x]\n", procId); /* Open a handle to the ProcMgr instance. */ status = ProcMgr_open (&procMgrHandleAppM3, procId); if (status < 0) { Osal_printf ("Error in ProcMgr_open [0x%x]\n", status); goto exit_ipc_destroy; } else { Osal_printf ("ProcMgr_open Status [0x%x]\n", status); ProcMgr_getAttachParams (NULL, &attachParams); /* Default params will be used if NULL is passed. */ status = ProcMgr_attach (procMgrHandleAppM3, &attachParams); if (status < 0) { Osal_printf ("ProcMgr_attach failed [0x%x]\n", status); } else { Osal_printf ("ProcMgr_attach status: [0x%x]\n", status); state = ProcMgr_getState (procMgrHandleAppM3); Osal_printf ("After attach: ProcMgr_getState\n" " state [0x%x]\n", status); } } } #if defined(SYSLINK_USE_LOADER) Osal_printf ("SysM3 Load: loading the SysM3 image %s\n", sysM3ImageName); status = ProcMgr_load (procMgrHandleSysM3, sysM3ImageName, 2, &sysM3ImageName, &entryPoint, &fileIdSysM3, remoteIdSysM3); if(status < 0) { Osal_printf ("Error in ProcMgr_load, status [0x%x]\n", status); goto exit_procmgr_close_sysm3; } #endif startParams.proc_id = remoteIdSysM3; Osal_printf ("Starting ProcMgr for procID = %d\n", startParams.proc_id); status = ProcMgr_start(procMgrHandleSysM3, entryPoint, &startParams); if(status < 0) { Osal_printf ("Error in ProcMgr_start, status [0x%x]\n", status); goto exit_procmgr_close_sysm3; } if(appM3Client) { #if defined(SYSLINK_USE_LOADER) Osal_printf ("AppM3 Load: loading the AppM3 image %s\n", appM3ImageName); status = ProcMgr_load (procMgrHandleAppM3, appM3ImageName, 2, &appM3ImageName, &entryPoint, &fileIdAppM3, remoteIdAppM3); if(status < 0) { Osal_printf ("Error in ProcMgr_load, status [0x%x]\n", status); goto exit_procmgr_stop_sysm3; } #endif startParams.proc_id = remoteIdAppM3; Osal_printf ("Starting ProcMgr for procID = %d\n", startParams.proc_id); status = ProcMgr_start(procMgrHandleAppM3, entryPoint, &startParams); if(status < 0) { Osal_printf ("Error in ProcMgr_start, status [0x%x]\n", status); goto exit_procmgr_stop_sysm3; } } Osal_printf ("SysM3: Creating Ducati DMM pool of size 0x%x\n", DUCATI_DMM_POOL_0_SIZE); status = ProcMgr_createDMMPool (DUCATI_DMM_POOL_0_ID, DUCATI_DMM_POOL_0_START, DUCATI_DMM_POOL_0_SIZE, remoteIdSysM3); if(status < 0) { Osal_printf ("Error in ProcMgr_createDMMPool, status [0x%x]\n", status); goto exit_procmgr_stop_sysm3; } srCount = SharedRegion_getNumRegions(); Osal_printf ("SharedRegion_getNumRegions = %d\n", srCount); for (i = 0; i < srCount; i++) { status = SharedRegion_getEntry (i, &srEntry); Osal_printf ("SharedRegion_entry #%d: base = 0x%x len = 0x%x " "ownerProcId = %d isValid = %d cacheEnable = %d " "cacheLineSize = 0x%x createHeap = %d name = %s\n", i, srEntry.base, srEntry.len, srEntry.ownerProcId, (Int)srEntry.isValid, (Int)srEntry.cacheEnable, srEntry.cacheLineSize, (Int)srEntry.createHeap, srEntry.name); } /* Create the heap to be used by RCM and register it with MessageQ */ /* TODO: Do this dynamically by reading from the IPC config from the * baseimage using Ipc_readConfig() */ if (status >= 0) { HeapBufMP_Params_init (&heapbufmpParams); heapbufmpParams.sharedAddr = NULL; heapbufmpParams.align = RCM_MSGQ_TILER_HEAP_ALIGN; heapbufmpParams.numBlocks = RCM_MSGQ_TILER_HEAP_BLOCKS; heapbufmpParams.blockSize = RCM_MSGQ_TILER_MSGSIZE; heapSize = HeapBufMP_sharedMemReq (&heapbufmpParams); Osal_printf ("heapSize = 0x%x\n", heapSize); srHeap = SharedRegion_getHeap (RCM_MSGQ_HEAP_SR); if (srHeap == NULL) { status = MEMORYOS_E_FAIL; Osal_printf ("SharedRegion_getHeap failed for srHeap:" " [0x%x]\n", srHeap); goto exit_procmgr_stop_sysm3; } else { Osal_printf ("Before Memory_alloc = 0x%x\n", srHeap); heapBufPtr = Memory_alloc (srHeap, heapSize, 0); if (heapBufPtr == NULL) { status = MEMORYOS_E_MEMORY; Osal_printf ("Memory_alloc failed for ptr: [0x%x]\n", heapBufPtr); goto exit_procmgr_stop_sysm3; } else { heapbufmpParams.name = RCM_MSGQ_TILER_HEAPNAME; heapbufmpParams.sharedAddr = heapBufPtr; Osal_printf ("Before HeapBufMP_Create: [0x%x]\n", heapBufPtr); heapHandle = HeapBufMP_create (&heapbufmpParams); if (heapHandle == NULL) { status = HeapBufMP_E_FAIL; Osal_printf ("HeapBufMP_create failed for Handle:" "[0x%x]\n", heapHandle); goto exit_procmgr_stop_sysm3; } else { /* Register this heap with MessageQ */ status = MessageQ_registerHeap (heapHandle, RCM_MSGQ_TILER_HEAPID); if (status < 0) { Osal_printf ("MessageQ_registerHeap failed!\n"); goto exit_procmgr_stop_sysm3; } } } } } if (status >= 0) { HeapBufMP_Params_init (&heapbufmpParams); heapbufmpParams.sharedAddr = NULL; heapbufmpParams.align = RCM_MSGQ_DOMX_HEAP_ALIGN; heapbufmpParams.numBlocks = RCM_MSGQ_DOMX_HEAP_BLOCKS; heapbufmpParams.blockSize = RCM_MSGQ_DOMX_MSGSIZE; heapSize1 = HeapBufMP_sharedMemReq (&heapbufmpParams); Osal_printf ("heapSize1 = 0x%x\n", heapSize1); heapBufPtr1 = Memory_alloc (srHeap, heapSize1, 0); if (heapBufPtr1 == NULL) { status = MEMORYOS_E_MEMORY; Osal_printf ("Memory_alloc failed for ptr: [0x%x]\n", heapBufPtr1); goto exit_procmgr_stop_sysm3; } else { heapbufmpParams.name = RCM_MSGQ_DOMX_HEAPNAME; heapbufmpParams.sharedAddr = heapBufPtr1; Osal_printf ("Before HeapBufMP_Create: [0x%x]\n", heapBufPtr1); heapHandle1 = HeapBufMP_create (&heapbufmpParams); if (heapHandle1 == NULL) { status = HeapBufMP_E_FAIL; Osal_printf ("HeapBufMP_create failed for Handle:" "[0x%x]\n", heapHandle1); goto exit_procmgr_stop_sysm3; } else { /* Register this heap with MessageQ */ status = MessageQ_registerHeap (heapHandle1, RCM_MSGQ_DOMX_HEAPID); if (status < 0) { Osal_printf ("MessageQ_registerHeap failed!\n"); goto exit_procmgr_stop_sysm3; } } } } Osal_printf ("=== SysLink-IPC setup completed successfully!===\n"); return 0; exit_procmgr_stop_sysm3: stopParams.proc_id = remoteIdSysM3; status = ProcMgr_stop (procMgrHandleSysM3, &stopParams); if (status < 0) { Osal_printf ("Error in ProcMgr_stop(%d): status = 0x%x\n", stopParams.proc_id, status); } exit_procmgr_close_sysm3: status = ProcMgr_close (&procMgrHandleSysM3); if (status < 0) { Osal_printf ("Error in ProcMgr_close: status = 0x%x\n", status); } exit_ipc_destroy: status = Ipc_destroy (); if (status < 0) { Osal_printf ("Error in Ipc_destroy: status = 0x%x\n", status); } exit: return (-1); }
/*! * @brief Function to execute the startup for ProcMgrApp sample application */ Int ProcMgrApp_startup (UInt16 procId) { Int status = 0; ProcMgr_Handle handle = NULL; ProcMgr_AttachParams attachParams; ProcMgr_State state; UInt32 resetVector = 0x00800000; PRINTF ("Entered ProcMgrApp_startup\n"); status = ProcMgr_open (&handle, procId); if (status >= 0) { ProcMgr_getAttachParams (NULL, &attachParams); /* Default params will be used if NULL is passed. */ attachParams.bootMode = ProcMgr_BootMode_NoBoot; /* set the boot mode */ status = ProcMgr_attach (handle, &attachParams); if (status < 0) { PRINTF ("ProcMgr_attach failed [0x%x]\n", status); } else { PRINTF ("ProcMgr_attach status: [0x%x]\n", status); state = ProcMgr_getState (handle); PRINTF ("After attach: ProcMgr_getState\n" " state [0x%x]\n", state); /* Call Ipc_control for ProcMgr_BootMode_NoLoad_Pwr, ProcMgr_BootMode_NoLoad_NoPwr and ProcMgr_BootMode_NoBoot modes */ status = Ipc_control (procId, Ipc_CONTROLCMD_LOADCALLBACK, (Ptr)&resetVector); if (status < 0) { PRINTF ("Error in Ipc_control " "Ipc_CONTROLCMD_LOADCALLBACK [0x%x]\n", status); } else { state = ProcMgr_getState (handle); PRINTF ("After Ipc_loadcallback: ProcMgr_getState\n" " state [0x%x]\n", state); } } if (status >= 0) { status = Ipc_control (procId, Ipc_CONTROLCMD_STARTCALLBACK, NULL); if (status < 0) { PRINTF ("Error in Ipc_control " "Ipc_CONTROLCMD_STARTCALLBACK[0x%x]\n", status); } else { state = ProcMgr_getState (handle); PRINTF ("After Ipc_startcallback: ProcMgr_getState\n" " state [0x%x]\n", state); } } status = ProcMgr_close (&handle); PRINTF ("ProcMgr_close status: [0x%x]\n", status); } PRINTF ("Leaving ProcMgrApp_startup\n"); return 0; }