Int32 SWOSD_close(SWOSD_Obj *pObj)
{
Int32 scratchId = g_scratchIndex;
IRES_Status status;
IRES_Fxns * resFxns = &SWOSD_TI_IRES;
if(pObj->algHndl == NULL)
return SWOSD_EFAIL;
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)pObj->algHndl, resFxns, scratchId);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)pObj->algHndl);
/*
* Free resources assigned to this algorihtm
*/
status = RMAN_freeResources((IALG_Handle)pObj->algHndl, resFxns, scratchId);
if (IRES_OK != status) {
return SWOSD_EFAIL;
}
DSKT2_freeAlg(scratchId, (IALG_Handle)pObj->algHndl);
return SWOSD_SOK;
}
Int32 SWOSD_blendWindow(SWOSD_Obj * hndl)
{
SWOSD_TI_Obj *pObj = (SWOSD_TI_Obj *)hndl->algHndl;
IRES_Fxns * resFxns = &SWOSD_TI_IRES;
memcpy(&pObj->swOsdCtrl, hndl, sizeof(pObj->swOsdCtrl));
/* Activate the Algorithm */
// DSKT2_activateAlg(g_scratchIndex, (IALG_Handle)hndl->algHndl);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)hndl->algHndl, resFxns, g_scratchIndex);
SWOSD_TI_algRun(pObj, hndl);
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)hndl->algHndl, resFxns, g_scratchIndex);
/* Deactivate algorithm */
// DSKT2_deactivateAlg(g_scratchIndex, (IALG_Handle)hndl->algHndl);
return 0;
}
/*
* ======== Algorithm_deactivate ========
*/
Void Algorithm_deactivate(Algorithm_Handle alg)
{
Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
Log_print1(Diags_ENTRY, "[+E] Algorithm_deactivate> Enter(alg=0x%x)",
(IArg)alg);
if (pObject->iresFxns) {
RMAN_deactivateAllResources(pObject->alg, pObject->iresFxns,
pObject->groupId);
}
DSKT2_deactivateAlg(pObject->groupId, pObject->alg);
Log_print0(Diags_EXIT, "[+X] Algorithm_deactivate> Exit");
}
/*
* ======== Algorithm_deactivate ========
*/
Void Algorithm_deactivate(Algorithm_Handle alg)
{
Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
Log_print1(Diags_ENTRY, "[+E] Algorithm_deactivate> Enter(alg=0x%x)",
(IArg)alg);
/*
* At this stage, Algorithm could already have released
* scratch group lock (using new APIs above). Which means they saved all
* scratch context, and some other alg now have control of scratch group,
* can't call RMAN_deactivate here.
* Need to keep track of what ALG called release lock and probably not do
* anything in deactivate for those ALG(s) ??!!
*/
/* Need to actually deactivate if _Algorithm_lockOwner[groupId] == alg
* If _Algorithm_lockOwner[groupId] == NULL, some other process may have
* lock, i.e, alg is already deactivated
* If _Algorithm_lockOwner[groupId] != NULL and != alg, some other
* thread in this process has the group lock, and this alg is
* deactive. In both of the above cases, do nothing here !!
*/
if (_Algorithm_lockOwner[pObject->groupId] == pObject->alg) {
_Algorithm_lockOwner[pObject->groupId] = NULL;
if (pObject->iresFxns) {
RMAN_deactivateAllResources(pObject->alg, pObject->iresFxns,
pObject->groupId);
}
ALG_deactivate(pObject->groupId, pObject->alg);
}
Log_print0(Diags_EXIT, "[+X] Algorithm_deactivate> Exit");
}
/*
* ======== rmanTask ========
*/
Void rmanTask(UArg arg0, UArg arg1)
{
Int taskId = (Int)arg0;
Int index = (Int)arg1; /* index into attrsTable */
IALG_Fxns * algFxns = (IALG_Fxns *)&DUMALG_TI_IDUMALG;
IRES_Fxns * resFxns = &DUMALG_TI_IRES;
IDUMALG_Handle dumHandle = NULL;
IDUMALG_Params params;
Int scratchId = attrsTable[index].scratchId;
Int yieldFlag = attrsTable[index].yieldFlag;
Int priority = attrsTable[index].priority;
Arg resourceId = (Arg)(&(attrsTable[index].id));
Int i;
IRES_Status status;
Log_print0(Diags_ENTRY, "[+E] rmanTask> Enter ");
params.size = sizeof(IDUMALG_Params);
Log_print4(Diags_USER4, "[+4] rmanTask> "
"Task #%d: ScratchId %d, Priority %d Yield %d",
(IArg)taskId, (IArg)scratchId, (IArg)priority, (IArg)yieldFlag);
params.yieldFlag = yieldFlag;
params.taskId = taskId;
for (i = 0; i < NUM_RESOURCES; i++) {
params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i);
Log_print1(Diags_USER4, "[+4] rmanTask> "
"Requesting resource %d (2 => ANY)",
(IArg)((Int)params.hdvicp[i]));
}
/*
* Create an instance of the algorithm using "algFxns"
*/
SemThread_pend(mutex, SemThread_FOREVER, NULL);
dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms);
if (dumHandle == NULL) {
Log_print0(Diags_USER7, "[+7] rmanTask> Alg creation failed");
System_abort("DSKT2_createAlg() failed, aborting...\n");
}
SemThread_post(mutex, NULL);
/* Assign resources to the algorithm */
status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] rmanTask> Assign resource failed [%d]",
(IArg)status);
System_abort("RMAN_assignResources() failed, aborting...\n");
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Use IALG interfaces to do something */
dumHandle->fxns->useHDVICP(dumHandle, taskId);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] rmanTask> Free resource failed [%d]",
(IArg)status);
System_abort("RMAN_freeResources() failed, aborting...\n");
}
/*
* Free instance of the algorithm created
*/
SemThread_pend(mutex, SemThread_FOREVER, NULL);
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
SemThread_post(mutex, NULL);
SemThread_post(done, NULL);
Log_print0(Diags_EXIT, "[+X] rmanTask> Exit ");
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(Int argc, Char * argv[])
{
IRES_Status status;
Int size = 0;
Int scratchId = 2;
IALG_Fxns * algFxns = (IALG_Fxns *)&TEMPLATE_TI_CODECIRES;
IRES_Fxns * resFxns = &TEMPLATE_TI_IRES;
IALG_Handle dumHandle = NULL;
ITEMPLATE_Status algStatus;
/*
* Create an instance of the algorithm using "algFxns"
*/
dumHandle = DSKT2_createAlg(scratchId, (IALG_Fxns *)algFxns, NULL,
(IALG_Params *)NULL);
if (dumHandle == NULL) {
printf("Alg creation failed \n");
return -1;
}
/*
* Supply initialization information for the RESMAN while registering
*/
size = sizeof(IRESMAN_Params);
configParams.allocFxn = RMAN_PARAMS.allocFxn;
configParams.freeFxn = RMAN_PARAMS.freeFxn;
configParams.size = size;
/*
* Register the NULL protocol/resource manager with the generic resource
* manager
*/
status = RMAN_register(&IRESMAN_NULLRES, (IRESMAN_Params *)&configParams);
if (IRES_EEXISTS == status) {
printf("Protocol Already Registered\n");
}
/* Create an instance of an algorithm that implements IALG and IRES_Fxns */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle,
resFxns,scratchId)) {
printf("Assign Resource Failed \n");
return (-1);
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, -1);
/* Use IALG interfaces to do something */
((ITEMPLATE_Handle)dumHandle)->fxns->process((ITEMPLATE_Handle)dumHandle,
(ITEMPLATE_InArgs *)NULL, (ITEMPLATE_OutArgs *)NULL);
((ITEMPLATE_Handle)dumHandle)->fxns->control((ITEMPLATE_Handle)dumHandle,
(ITEMPLATE_Cmd )0, (ITEMPLATE_DynamicParams *)NULL, &algStatus);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, -1);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle),
resFxns, -1)) {
printf("Free Resource Failed\n");
return (-1);
}
/* Free instance of the algorithm created */
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
/* Unregister the protocol */
if (IRES_OK != RMAN_unregister(&IRESMAN_NULLRES)) {
printf("Unregister Protocol Failed\n");
return (-1);
}
RMAN_exit();
return (0);
}
Int rmanTask(Arg scratchId, Arg resourceId, Arg priority, Arg taskId,
Arg yieldFlag)
{
Int i;
IALG_Fxns * algFxns = &DUMALG_TI_IALG;
IRES_Fxns * resFxns = &DUMALG_TI_IRES;
IDUMALG_Handle dumHandle = NULL;
IDUMALG_Params params;
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Enter \n");
params.size = sizeof(IDUMALG_Params);
GT_4trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> "
"Task #%d: ScratchId %d, Priority %d Yield %d\n",taskId, scratchId,
priority, yieldFlag);
params.yieldFlag = yieldFlag;
params.taskId = taskId;
for (i = 0; i < NUM_RESOURCES; i++) {
params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i);
GT_1trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> "
"Requesting resource %d (2 => ANY)\n",(Int)params.hdvicp[i]);
}
/*
* Create an instance of the algorithm using "algFxns"
*/
SEM_pend(mutex, SYS_FOREVER);
dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms);
if (dumHandle == NULL) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Alg creation failed\n");
return -1;
}
SEM_post(mutex);
/* Assign resources to the algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle,
resFxns, scratchId)) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Assign resource failed\n");
return -1;
}
/*
* Activate the Algorithm
*/
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/*
* Use IALG interfaces to do something
*/
dumHandle->fxns->useHDVICP(dumHandle, taskId);
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/*
* Deactivate algorithm
*/
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle),
resFxns, scratchId)) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Free resource failed\n");
return -1;
}
/*
* Free instance of the algorithm created
*/
SEM_pend(mutex, SYS_FOREVER);
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
SEM_post(mutex);
SEM_post(done);
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Exit \n");
return 0;
}
/*
* ======== smain ========
*/
Int smain(Int argc, Char * argv[])
{
ISHMALG_Handle alg;
ISHMALG_Fxns fxns = SHMALG_TI_ISHMALG;
ISHMALG_Params params = ISHMALG_PARAMS;
IRES_Fxns iresFxns = SHMALG_TI_IRES;
IRES_Status status;
Int scratchId;
Bool passed = FALSE;
Bool retVal = TRUE;
Int fillVal = 1;
if (argc > 1) {
fillVal = atoi(argv[1]);
}
params.fillVal = fillVal;
System_printf("shmbuf_test2> Started. buffer fill value: %d\n", fillVal);
/* Initialize and register resource manager */
System_printf("Calling RMAN_init()...\n");
status = RMAN_init();
if (status != IRES_OK) {
/* Test failed */
System_printf("RMAN_init() failed: %s [%d]\n", getError(status),
status);
goto done;
}
SHMBUF_PARAMS.bufsize = SHMBUFSIZE;
SHMBUF_PARAMS.isScratch = TRUE; /* Make the buffer sharable */
System_printf("Calling RMAN_register()...\n");
status = RMAN_register(&SHMBUF_MGRFXNS, (IRESMAN_Params *)&SHMBUF_PARAMS);
if (status != IRES_OK) {
/* Test failed */
System_printf("RMAN_register() failed %s [%d]\n", getError(status),
status);
goto done;
}
scratchId = 1;
System_printf("Calling DSKT2_createAlg()...\n");
alg = (ISHMALG_Handle)DSKT2_createAlg(scratchId, (IALG_Fxns *)&fxns,
NULL, (IALG_Params *)¶ms);
if (alg == NULL) {
System_printf("DSKT2_createAlg() failed\n");
goto done;
}
/* Assign resources to the algorithm */
System_printf("Calling RMAN_assignResources()...\n");
status = RMAN_assignResources((IALG_Handle)alg, &iresFxns, scratchId);
if (status != IRES_OK) {
System_printf("RMAN_assignResources() failed %s [%d]\n",
getError(status), status);
goto done;
}
System_printf("Calling DSKT2_activateAlg()...\n");
DSKT2_activateAlg(scratchId, (IALG_Handle)alg);
/* Activate All Resources */
System_printf("Calling RMAN_activateAllResources()...\n");
status = RMAN_activateAllResources((IALG_Handle)alg, &iresFxns, scratchId);
if (status != IRES_OK) {
System_printf("RMAN_activateAllResourceRMAN_unregister(&SHMBUF_MGRFXNS);s() failed %s [%d]\n",
getError(status), status);
goto done;
}
/* Use the buffer */
alg->fxns->useBufs(alg);
/* Hold onto the resource for awhile */
System_printf("Sleeping...\n");
sleep(10);
/* Check contents of the buffer */
if (!(retVal = alg->fxns->checkBufs(alg))) {
System_printf("Buffer overwritten by another alg.\n");
}
/* Deactivate All Resources */
System_printf("Calling RMAN_deactivateAllResources()...\n");
status = RMAN_deactivateAllResources((IALG_Handle)alg, &iresFxns,
scratchId);
if (status != IRES_OK) {
System_printf("RMAN_deactivateAllResources() failed %s [%d]\n",
getError(status), status);
goto done;
}
/* Deactivate algorithm */
System_printf("Calling DSKT2_deactivateAlg()...\n");
DSKT2_deactivateAlg(scratchId, (IALG_Handle)alg);
/* Free resources assigned to this algorihtm */
System_printf("Calling RMAN_freeResources()...\n");
status = RMAN_freeResources((IALG_Handle)(alg), &iresFxns, scratchId);
if (status != IRES_OK) {
System_printf("RMAN_freeResources() failed %s [%d]\n",
getError(status), status);
goto done;
}
/* Free instance of the algorithm created */
System_printf("Calling DSKT2_freeAlg()...\n");
DSKT2_freeAlg(scratchId, (IALG_Handle)alg);
System_printf("Calling RMAN_unregister()...\n");
status = RMAN_unregister(&SHMBUF_MGRFXNS);
if (status != IRES_OK) {
System_printf("RMAN_unregister() failed %s [%d]\n", getError(status),
status);
goto done;
}
System_printf("Calling RMAN_exit()...\n");
status = RMAN_exit();
if (status != IRES_OK) {
System_printf("RMAN_exit() failed %s [%d]\n", getError(status),
status);
goto done;
}
else {
if (retVal) {
passed = TRUE;
}
}
done:
RMAN_exit();
if (passed) {
System_printf("TEST PASSED\n");
}
else {
System_printf("TEST FAILED\n");
}
return (0);
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(Int argc, Char * argv[])
{
Int scratchId1 = 0;
Int scratchId2 = 0;
IALG_Status algStatus;
IALG_Fxns * algFxns = &DUMRES_TI_IALG;
IRES_Fxns * resFxns = &DUMRES_TI_IRES;
DUMRES_TI_Handle algHandle1 = NULL;
DUMRES_TI_Handle algHandle2 = NULL;
EDMA3_RM_Handle rmHandle = NULL;
EDMA3_RM_ResDesc resObj;
MEM_Stat stat;
Bool retVal;
Int i = 0;
/*
* Create 2 instances of the algorithm using "algFxns"
*/
algHandle1 = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId1,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)NULL);
if (algHandle1 == NULL) {
printf("Alg creation failed for algHandle1\n");
return -1;
}
algHandle2 = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId2,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)NULL);
if (algHandle2 == NULL) {
printf("Alg creation failed for algHandle2\n");
return -1;
}
/* Assign resources to the algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)algHandle1,
resFxns, scratchId1)) {
GT_0trace(ti_sdo_fc_rman_examples_scratchEdma3_GTMask, GT_7CLASS,
"Assign Resource Failed \n");
goto AppEnd1;
}
/*
* Activate the Algorithm
*/
DSKT2_activateAlg(scratchId1, (IALG_Handle)algHandle1);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)algHandle1, resFxns, scratchId1);
/*
* Use IALG interfaces to do something
*/
DSKT2_controlAlg((IALG_Handle)algHandle1, (IALG_Cmd)NULL, &algStatus);
/* Assign resources to the second algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)algHandle2,
resFxns, scratchId2)) {
printf("Assign Resource Failed \n");
return -1;
}
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)algHandle1, resFxns, scratchId1);
/*
* Deactivate algorithm
*/
DSKT2_deactivateAlg(scratchId1, (IALG_Handle)algHandle1);
/*
* Activate the Algorithm
*/
DSKT2_activateAlg(scratchId2, (IALG_Handle)algHandle2);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)algHandle2, resFxns, scratchId2);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(algHandle1),
resFxns, scratchId1)) {
printf("Free Resource Failed \n");
return -1;
}
/*
* Acquire the EDMA3 handle first
*/
rmHandle = EDMA3_getResourceManager(NULL, -1);
if (NULL == rmHandle) {
printf("Error obtaining SYSTEM resource Manager Handle \n");
return (-1);
}
resObj.resId = 151;
resObj.type = EDMA3_RM_RES_PARAM_SET;
if (EDMA3_RM_SOK != EDMA3_RM_allocResource(rmHandle, &resObj)) {
printf("Could not allocate this resource, as it is already owned by "
"the algorithm\n");
}
resObj.resId = 256;
if (EDMA3_RM_SOK != EDMA3_RM_allocResource(rmHandle, &resObj)) {
printf("Error, could not allocate resource %d\n"
"ERROR for 6467, OK for 6446\n", resObj.resId);
}
if (EDMA3_RM_SOK != EDMA3_releaseResourceManager(NULL, -1)) {
printf("Error releasing system resource manager handle\n");
}
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)algHandle2, resFxns, scratchId2);
/*
* Deactivate algorithm
*/
DSKT2_deactivateAlg(scratchId2, (IALG_Handle)algHandle2);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(algHandle2),
resFxns, scratchId2)) {
printf("Free Resource Failed \n");
return -1;
}
AppEnd1:
/*
* Free instance of the algorithm created
*/
DSKT2_freeAlg(scratchId1, (IALG_Handle)algHandle1);
/*
* Free instance of the algorithm created
*/
DSKT2_freeAlg(scratchId2, (IALG_Handle)algHandle2);
/*
* Unregister the protocol
*/
if (IRES_OK != RMAN_unregister(&IRESMAN_EDMA3CHAN)) {
printf("Unregister Protocol Failed \n");
return -1;
}
for (i = 0; i < MAXMEMSEGMENTS; i++) {
retVal = MEM_stat(i, &stat);
if (!retVal) {
GT_assert(ti_sdo_fc_rman_examples_scratchEdma3_GTMask,
memStat[i].size == 0);
}
else {
if (memStat[i].used != stat.used) {
GT_3trace(ti_sdo_fc_rman_examples_scratchEdma3_GTMask,
GT_7CLASS, "MEM seg [%d]: orig used = 0x%x, "
"curr used = 0x%x", i, memStat[i].used,
stat.used);
return (-1);
}
}
}
RMAN_exit();
return (0);
}
/* ARGSUSED */
Int rmanTask(Int argc, Char * argv[])
{
Int i;
IALG_Fxns * algFxns = (IALG_Fxns *)&DUMALG_TI_IDUMALG;
IRES_Fxns * resFxns = &DUMALG_TI_IRES;
IDUMALG_Handle dumHandle = NULL;
IDUMALG_Params params;
Int taskId = 1;
Int scratchId = -1;
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Enter\n");
params.size = sizeof(IDUMALG_Params);
params.yieldFlag = FALSE;
params.taskId = taskId;
/* Configure the params to indicate the HDVICP requirements of each alg */
for (i = 0; i < NUM_RESOURCES; i++) {
params.hdvicp[i] = *((IRES_HDVICP_RequestType *)&attrsTable[0].id[i]);
GT_1trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> "
"Requesting resource %d (2 => ANY)\n",(Int)params.hdvicp[i]);
}
ALG_init();
/* Create an instance of the algorithm using "algFxns" */
dumHandle = (IDUMALG_Handle)ALG_create((IALG_Fxns *)algFxns,
(IALG_Handle)NULL, (IALG_Params *)¶ms);
if (dumHandle == NULL) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Alg creation failed\n");
printf("App failed\n");
return (myIdle(argc, argv));
}
/* Assign resources to the algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle,
resFxns, scratchId)) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Assign resource failed\n");
return (myIdle(argc, argv));
}
/* Activate the Algorithm */
ALG_activate((IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Use IALG interfaces to do something */
dumHandle->fxns->useHDVICP(dumHandle, taskId);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Deactivate the algorithm */
ALG_deactivate((IALG_Handle)dumHandle);
/* Free resources assigned to this algorithm */
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle),
resFxns, scratchId)) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Free resource failed\n");
return (myIdle(argc, argv));
}
/* Free instance of the algorithm created */
ALG_delete((IALG_Handle)dumHandle);
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Exit\n");
return (myIdle(argc, argv));
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(UArg arg0, UArg arg1)
{
IRES_Status status;
Int size = 0;
Int scratchId = 2;
IALG_Status algStatus;
IALG_Fxns * algFxns = &DUMRES_TI_IALG;
IRES_Fxns * resFxns = &DUMRES_TI_IRES;
DUMRES_TI_Handle dumHandle = NULL;
status = RMAN_init();
if (IRES_OK != status) {
System_abort("RMAN initialization Failed \n");
}
/*
* Create an instance of the algorithm using "algFxns"
*/
dumHandle = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId,
(IALG_Fxns *)algFxns, NULL, (IALG_Params *)NULL);
if (dumHandle == NULL) {
System_abort("Alg creation failed \n");
}
/* Create an instance of an algorithm that implements IALG and IRES_Fxns */
status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId);
if (status != IRES_OK) {
System_printf("Assign Resource Failed [%d]\n", status);
System_abort("Aborting...\n");
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Use IALG interfaces to do something */
DSKT2_controlAlg((IALG_Handle)dumHandle, (IALG_Cmd)NULL, &algStatus);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId);
if (status != IRES_OK) {
System_printf("Free Resource Failed [%d]\n", status);
System_abort("Aborting...\n");
}
/* Free instance of the algorithm created */
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
RMAN_exit();
return (1);
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(Int argc, Char * argv[])
{
IRES_Status status;
Int scratchId = 2;
IALG_Fxns * algFxns = (IALG_Fxns *)&DUMRES_TI_IDUMRES;
IRES_Fxns * resFxns = &DUMRES_TI_IRES;
IDUMRES_Handle dumHandle = NULL;
IDUMRES_Params params;
Int sleepTime = 0;
if (argc > 1) {
sleepTime = atoi(argv[1]);
}
if (argc > 2) {
scratchId = atoi(argv[2]);
}
ALG_init();
/* Create an instance of the algorithm using "algFxns" */
//params.taskId = taskId;
params.taskId = 6;
dumHandle = (IDUMRES_Handle)ALG_create( (IALG_Fxns *)algFxns,
(IALG_Handle)NULL, (IALG_Params *)¶ms);
if (dumHandle == NULL) {
printf("Alg creation failed \n");
return (-1);
}
/* Create an instance of an algorithm that implements IALG and IRES_Fxns */
status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns,scratchId);
if (IRES_OK != status) {
printf("Assign Resource Failed \n");
result = FALSE;
}
else {
ALG_activate((IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, -1);
SLEEP(sleepTime);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, -1);
ALG_deactivate((IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns,
scratchId);
if (IRES_OK != status) {
printf("Free Resource Failed \n");
result = FALSE;
}
}
ALG_delete((IALG_Handle)dumHandle);
status = RMAN_exit();
if (status != IRES_OK) {
result = FALSE;
}
if (result) {
printf("TEST PASSED\n");
}
else {
printf("TEST FAILED.\n");
}
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(Int argc, String argv[])
{
Int scratchId1 = 0;
Int scratchId2 = 1;
/* IALG_Status algStatus;*/
IALG_Fxns * algFxns = &DUMRES_TI_IALG;
IRES_Fxns * resFxns = &DUMRES_TI_IRES;
DUMRES_TI_Handle dumHandle1 = NULL;
DUMRES_TI_Handle dumHandle2 = NULL;
EDMA3_Handle rmHandle = NULL;
EDMA3_ResDesc resObj;
Bool status = TRUE;
IDUMRES_Params params;
if (argc > 1) {
scratchId1 = atoi(argv[1]);
}
if (argc > 2) {
scratchId2 = atoi(argv[2]);
}
ALG_init();
/*
* Create an instance of the algorithm using "algFxns"
*/
params.algNum = 1;
dumHandle1 = (DUMRES_TI_Handle)ALG_create((IALG_Fxns *)algFxns,
(IALG_Handle)NULL, (IALG_Params *)¶ms);
if (dumHandle1 == NULL) {
printf("Alg1 creation failed \n");
return -1;
}
params.algNum = 2;
dumHandle2 = (DUMRES_TI_Handle)ALG_create((IALG_Fxns *)algFxns,
(IALG_Handle)NULL, (IALG_Params *)¶ms);
if (dumHandle2 == NULL) {
printf("Alg2 creation failed \n");
return -1;
}
/* Create an instance of an algorithm that implements IALG and IRES_Fxns */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle1,
resFxns,scratchId1)) {
printf("Assign Resource Failed \n");
status = FALSE;
goto AppEnd1;
}
/*
* Activate the Algorithm
*/
ALG_activate((IALG_Handle)dumHandle1);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)dumHandle1, resFxns, scratchId1);
/*
* Use IALG interfaces to do something
*/
//TODO: DSKT2_controlAlg((IALG_Handle)dumHandle, (IALG_Cmd)NULL, &algStatus);
/* Assign resources to the second algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle2,
resFxns, scratchId2)) {
printf("Assign Resource Failed \n");
return -1;
}
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)dumHandle1, resFxns, scratchId1);
/*
* Deactivate algorithm
*/
ALG_deactivate((IALG_Handle)dumHandle1);
/*
* Activate the Algorithm
*/
ALG_activate((IALG_Handle)dumHandle2);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)dumHandle2, resFxns, scratchId2);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle1),
resFxns, scratchId1)) {
printf("Free Resource Failed \n");
return -1;
}
/*
* Acquire the EDMA3 handle first
*/
rmHandle = EDMA3_getResourceManager((IALG_Handle)NULL, (Int)-1);
if (NULL == rmHandle) {
printf("Error obtaining SYSTEM resource Manager Handle \n");
return (-1);
}
resObj.resId = 65;
resObj.type = EDMA3_RES_PARAM_SET;
if (EDMA3_SOK != EDMA3_allocResource(rmHandle, &resObj)) {
printf("Note, could not allocate this resource.\n");
}
resObj.resId = 126;
if (EDMA3_SOK != EDMA3_allocResource(rmHandle, &resObj)) {
printf("Note, could not allocate resource %d\n", resObj.resId);
}
if (EDMA3_SOK != EDMA3_releaseResourceManager(NULL, -1)) {
printf("Note, releasing system resource manager handle\n");
}
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)dumHandle2, resFxns, scratchId2);
/*
* Deactivate algorithm
*/
ALG_deactivate((IALG_Handle)dumHandle2);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle2),
resFxns, scratchId2)) {
printf("Free Resource Failed \n");
return -1;
}
AppEnd1:
/*
* Free instance of the algorithm created
*/
ALG_delete((IALG_Handle)dumHandle1);
/*
* Free instance of the algorithm created
*/
ALG_delete((IALG_Handle)dumHandle2);
RMAN_exit();
if (status)
printf("Application exiting normally\n");
return (0);
}
