/*
* ======== PROCWRAP_EnumNode_Info ========
*/
u32 PROCWRAP_EnumNode_Info(union Trapped_Args *args, void *pr_ctxt)
{
DSP_STATUS status;
DSP_HNODE aNodeTab[MAX_NODES];
u32 uNumNodes;
u32 uAllocated;
GT_5trace(WCD_debugMask, GT_ENTER,
"PROCWRAP_EnumNode_Info:entered args:\n0x"
"%xhProcessor:0x%x\taNodeTab:0x%x\tuNodeTabSize:"
"%0x%x\tpuNumNodes%\n0x%x puAllocated: \n",
args->ARGS_PROC_ENUMNODE_INFO.hProcessor,
args->ARGS_PROC_ENUMNODE_INFO.aNodeTab,
args->ARGS_PROC_ENUMNODE_INFO.uNodeTabSize,
args->ARGS_PROC_ENUMNODE_INFO.puNumNodes,
args->ARGS_PROC_ENUMNODE_INFO.puAllocated);
DBC_Require(args->ARGS_PROC_ENUMNODE_INFO.uNodeTabSize <= MAX_NODES);
status = PROC_EnumNodes(args->ARGS_PROC_ENUMNODE_INFO.hProcessor,
aNodeTab,
args->ARGS_PROC_ENUMNODE_INFO.uNodeTabSize,
&uNumNodes, &uAllocated);
cp_to_usr(args->ARGS_PROC_ENUMNODE_INFO.aNodeTab, aNodeTab, status,
uNumNodes);
cp_to_usr(args->ARGS_PROC_ENUMNODE_INFO.puNumNodes, &uNumNodes,
status, 1);
cp_to_usr(args->ARGS_PROC_ENUMNODE_INFO.puAllocated, &uAllocated,
status, 1);
return status;
}
/*
* ======== VIDDECCOPY_TI_process ========
*/
XDAS_Int32 VIDDECCOPY_TI_process(IVIDDEC_Handle h, XDM_BufDesc *inBufs,
XDM_BufDesc *outBufs, IVIDDEC_InArgs *inArgs, IVIDDEC_OutArgs *outArgs)
{
XDAS_Int32 curBuf;
XDAS_Int32 minSamples;
GT_5trace(curTrace, GT_ENTER, "VIDDECCOPY_TI_process(0x%lx, 0x%lx, 0x%lx, "
"0x%lx, 0x%lx)\n", h, inBufs, outBufs, inArgs, outArgs);
/* validate arguments - this codec only supports "base" xDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
GT_2trace(curTrace, GT_ENTER, "VIDDECCOPY_TI_process, unsupported size "
"(0x%lx, 0x%lx)\n", inArgs->size, outArgs->size);
return (IVIDDEC_EFAIL);
}
/* outArgs->bytesConsumed reports the total number of bytes consumed */
outArgs->bytesConsumed = 0;
/*
* A couple constraints for this simple "copy" codec:
* - Given a different number of input and output buffers, only
* decode (i.e., copy) the lesser number of buffers.
* - Given a different size of an input and output buffers, only
* decode (i.e., copy) the lesser of the sizes.
*/
for (curBuf = 0; (curBuf < inBufs->numBufs) &&
(curBuf < outBufs->numBufs); curBuf++) {
/* there's an available in and out buffer, how many samples? */
minSamples = inBufs->bufSizes[curBuf] < outBufs->bufSizes[curBuf] ?
inBufs->bufSizes[curBuf] : outBufs->bufSizes[curBuf];
/* process the data: read input, produce output */
memcpy(outBufs->bufs[curBuf], inBufs->bufs[curBuf], minSamples);
GT_1trace( curTrace, GT_2CLASS, "VIDDECCOPY_TI_process> "
"Processed %d bytes.\n", minSamples );
outArgs->bytesConsumed += minSamples;
}
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
outArgs->decodedFrameType = 0; /* TODO */
outArgs->outputID = inArgs->inputID;
outArgs->displayBufs.numBufs = 0; /* important: indicate no displayBufs */
return (IVIDDEC_EOK);
}
/*
* ======== IMGENC1_processWait ========
*/
XDAS_Int32 IMGENC1_processWait(IMGENC1_Handle handle, XDM1_BufDesc *inBufs,
XDM1_BufDesc *outBufs, IIMGENC1_InArgs *inArgs, IIMGENC1_OutArgs *outArgs,
UInt timeout)
{
XDAS_Int32 retVal = IMGENC1_EFAIL;
IMGENC1_InArgs refInArgs;
/*
* Note, we do this because someday we may allow dynamically changing
* the global 'VISA_isChecked()' value on the fly. If we allow that,
* we need to ensure the value stays consistent in the context of this call.
*/
Bool checked = VISA_isChecked();
GT_5trace(CURTRACE, GT_ENTER, "IMGENC1_processWait> "
"Enter (handle=0x%x, inBufs=0x%x, outBufs=0x%x, inArgs=0x%x, "
"outArgs=0x%x)\n", handle, inBufs, outBufs, inArgs, outArgs);
if (handle) {
IIMGENC1_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if (alg != NULL) {
if (checked) {
/*
* Make a reference copy of inArgs so we can check that
* the codec didn't modify them during process().
*/
refInArgs = *inArgs;
}
retVal = processWait(alg, inBufs, outBufs, inArgs, outArgs,
timeout);
if (checked) {
/* ensure the codec didn't modify the read-only inArgs */
if (memcmp(&refInArgs, inArgs, sizeof(*inArgs)) != 0) {
GT_1trace(CURTRACE, GT_7CLASS,
"ERROR> codec (0x%x) modified read-only inArgs "
"struct!\n", handle);
}
}
}
}
GT_2trace(CURTRACE, GT_ENTER, "IMGENC1_processWait> "
"Exit (handle=0x%x, retVal=0x%x)\n", handle, retVal);
return retVal;
}
/*
* ======== RMM_free ========
*/
bool RMM_free(struct RMM_TargetObj *target, u32 segid, u32 addr, u32 size,
bool reserved)
{
struct RMM_OvlySect *sect;
bool retVal = true;
DBC_Require(MEM_IsValidHandle(target, RMM_TARGSIGNATURE));
DBC_Require(reserved || segid < target->numSegs);
DBC_Require(reserved || (addr >= target->segTab[segid].base &&
(addr + size) <= (target->segTab[segid].base +
target->segTab[segid].length)));
GT_5trace(RMM_debugMask, GT_ENTER,
"RMM_free(0x%lx, 0x%lx, 0x%lx, 0x%lx, "
"0x%lx)\n", target, segid, addr, size, reserved);
/*
* Free or unreserve memory.
*/
if (!reserved) {
retVal = freeBlock(target, segid, addr, size);
if (retVal)
target->segTab[segid].number--;
} else {
/* Unreserve memory */
sect = (struct RMM_OvlySect *)LST_First(target->ovlyList);
while (sect != NULL) {
if (addr == sect->addr) {
DBC_Assert(size == sect->size);
/* Remove from list */
LST_RemoveElem(target->ovlyList,
(struct LST_ELEM *)sect);
MEM_Free(sect);
break;
}
sect = (struct RMM_OvlySect *)LST_Next(target->ovlyList,
(struct LST_ELEM *)sect);
}
if (sect == NULL)
retVal = false;
}
return retVal;
}
/*
* ======== IMGENC1_processAsync ========
*/
XDAS_Int32 IMGENC1_processAsync(IMGENC1_Handle handle, XDM1_BufDesc *inBufs,
XDM1_BufDesc *outBufs, IIMGENC1_InArgs *inArgs, IIMGENC1_OutArgs *outArgs)
{
XDAS_Int32 retVal = IMGENC1_EFAIL;
/*
* Note, we do this because someday we may allow dynamically changing
* the global 'VISA_isChecked()' value on the fly. If we allow that,
* we need to ensure the value stays consistent in the context of this call.
*/
Bool checked = VISA_isChecked();
GT_5trace(CURTRACE, GT_ENTER, "IMGENC1_processAsync> "
"Enter (handle=0x%x, inBufs=0x%x, outBufs=0x%x, inArgs=0x%x, "
"outArgs=0x%x)\n", handle, inBufs, outBufs, inArgs, outArgs);
if (handle) {
IIMGENC1_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if (alg != NULL) {
if (checked) {
/*
* Validate inBufs and outBufs.
*/
XdmUtils_validateSparseBufDesc1(inBufs, "inBufs");
XdmUtils_validateSparseBufDesc1(outBufs, "outBufs");
/*
* Zero out the outArgs struct (except for .size field);
* it's write-only to the codec, so the app shouldn't pass
* values through it, nor should the codec expect to
* receive values through it.
*/
memset((void *)((XDAS_Int32)(outArgs) + sizeof(outArgs->size)),
0, (sizeof(*outArgs) - sizeof(outArgs->size)));
}
retVal = processAsync(alg, inBufs, outBufs, inArgs, outArgs);
}
}
GT_2trace(CURTRACE, GT_ENTER, "IMGENC1_processAsync> "
"Exit (handle=0x%x, retVal=0x%x)\n", handle, retVal);
return (retVal);
}
/*
* ======== VIDENC1_processAsync ========
*/
XDAS_Int32 VIDENC1_processAsync(VIDENC1_Handle handle,
IVIDEO1_BufDescIn *inBufs, XDM_BufDesc *outBufs,
IVIDENC1_InArgs *inArgs, IVIDENC1_OutArgs *outArgs)
{
XDAS_Int32 retVal = VIDENC1_EFAIL;
/*
* Note, we do this because someday we may allow dynamically changing
* the global 'VISA_isChecked()' value on the fly. If we allow that,
* we need to ensure the value stays consistent in the context of this call.
*/
Bool checked = VISA_isChecked();
GT_5trace(CURTRACE, GT_ENTER, "VIDENC1_processAsync> "
"Enter (handle=0x%x, inBufs=0x%x, outBufs=0x%x, inArgs=0x%x, "
"outArgs=0x%x)\n", handle, inBufs, outBufs, inArgs, outArgs);
if (handle) {
IVIDENC1_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if (alg != NULL) {
if (checked) {
/* validate inArgs with ranges. */
if (inArgs->inputID == 0) {
GT_2trace(CURTRACE, GT_7CLASS,
"ERROR> app provided codec (0x%x) with out of range "
"inArgs->inputID field (0x%x)\n", alg, inArgs->inputID);
}
/*
* Validate inBufs and outBufs.
*/
/* TBD XdmUtils_validateVideoBufDesc1(inBufs, "inBufs"); */
XdmUtils_validateSparseBufDesc(outBufs, "outBufs");
}
retVal = processAsync(alg, inBufs, outBufs, inArgs, outArgs);
}
}
GT_2trace(CURTRACE, GT_ENTER, "VIDENC1_processAsync> "
"Exit (handle=0x%x, retVal=0x%x)\n", handle, retVal);
return (retVal);
}
/*
* ======== STRM_Open ========
* Purpose:
* Open a stream for sending/receiving data buffers to/from a task or
* XDAIS socket node on the DSP.
*/
DSP_STATUS STRM_Open(struct NODE_OBJECT *hNode, u32 uDir, u32 uIndex,
IN struct STRM_ATTR *pAttr, OUT struct STRM_OBJECT **phStrm)
{
struct STRM_MGR *hStrmMgr;
struct WMD_DRV_INTERFACE *pIntfFxns;
u32 ulChnlId;
struct STRM_OBJECT *pStrm = NULL;
CHNL_MODE uMode;
struct CHNL_ATTRS chnlAttrs;
DSP_STATUS status = DSP_SOK;
struct CMM_OBJECT *hCmmMgr = NULL; /* Shared memory manager hndl */
#ifndef RES_CLEANUP_DISABLE
DSP_STATUS res_status = DSP_SOK;
u32 hProcess;
HANDLE pCtxt = NULL;
HANDLE hDrvObject;
HANDLE hSTRMRes;
#endif
DBC_Require(cRefs > 0);
DBC_Require(phStrm != NULL);
DBC_Require(pAttr != NULL);
GT_5trace(STRM_debugMask, GT_ENTER,
"STRM_Open: hNode: 0x%x\tuDir: 0x%x\t"
"uIndex: 0x%x\tpAttr: 0x%x\tphStrm: 0x%x\n",
hNode, uDir, uIndex, pAttr, phStrm);
*phStrm = NULL;
if (uDir != DSP_TONODE && uDir != DSP_FROMNODE) {
status = DSP_EDIRECTION;
} else {
/* Get the channel id from the node (set in NODE_Connect()) */
status = NODE_GetChannelId(hNode, uDir, uIndex, &ulChnlId);
}
if (DSP_SUCCEEDED(status))
status = NODE_GetStrmMgr(hNode, &hStrmMgr);
if (DSP_SUCCEEDED(status)) {
MEM_AllocObject(pStrm, struct STRM_OBJECT, STRM_SIGNATURE);
if (pStrm == NULL) {
status = DSP_EMEMORY;
GT_0trace(STRM_debugMask, GT_6CLASS,
"STRM_Open: MEM_AllocObject() failed!\n ");
} else {
pStrm->hStrmMgr = hStrmMgr;
pStrm->uDir = uDir;
pStrm->strmState = STREAM_IDLE;
pStrm->hUserEvent = pAttr->hUserEvent;
if (pAttr->pStreamAttrIn != NULL) {
pStrm->uTimeout = pAttr->pStreamAttrIn->
uTimeout;
pStrm->uNumBufs = pAttr->pStreamAttrIn->
uNumBufs;
pStrm->lMode = pAttr->pStreamAttrIn->lMode;
pStrm->uSegment = pAttr->pStreamAttrIn->
uSegment;
pStrm->uAlignment = pAttr->pStreamAttrIn->
uAlignment;
pStrm->uDMAChnlId = pAttr->pStreamAttrIn->
uDMAChnlId;
pStrm->uDMAPriority = pAttr->pStreamAttrIn->
uDMAPriority;
chnlAttrs.uIOReqs = pAttr->pStreamAttrIn->
uNumBufs;
} else {
pStrm->uTimeout = DEFAULTTIMEOUT;
pStrm->uNumBufs = DEFAULTNUMBUFS;
pStrm->lMode = STRMMODE_PROCCOPY;
pStrm->uSegment = 0; /* local memory */
pStrm->uAlignment = 0;
pStrm->uDMAChnlId = 0;
pStrm->uDMAPriority = 0;
chnlAttrs.uIOReqs = DEFAULTNUMBUFS;
}
chnlAttrs.hReserved1 = NULL;
/* DMA chnl flush timeout */
chnlAttrs.hReserved2 = pStrm->uTimeout;
chnlAttrs.hEvent = NULL;
if (pAttr->hUserEvent != NULL)
chnlAttrs.hEvent = pAttr->hUserEvent;
}
}
if (DSP_FAILED(status))
goto func_cont;
if ((pAttr->pVirtBase == NULL) || !(pAttr->ulVirtSize > 0))
goto func_cont;
DBC_Assert(pStrm->lMode != STRMMODE_LDMA); /* no System DMA */
/* Get the shared mem mgr for this streams dev object */
status = DEV_GetCmmMgr(hStrmMgr->hDev, &hCmmMgr);
if (DSP_FAILED(status)) {
GT_1trace(STRM_debugMask, GT_6CLASS, "STRM_Open: Failed to get "
"CMM Mgr handle: 0x%x\n", status);
} else {
/*Allocate a SM addr translator for this strm.*/
status = CMM_XlatorCreate(&pStrm->hXlator, hCmmMgr, NULL);
if (DSP_FAILED(status)) {
GT_1trace(STRM_debugMask, GT_6CLASS,
"STRM_Open: Failed to "
"create SM translator: 0x%x\n", status);
} else {
DBC_Assert(pStrm->uSegment > 0);
/* Set translators Virt Addr attributes */
status = CMM_XlatorInfo(pStrm->hXlator,
(u8 **)&pAttr->pVirtBase, pAttr->ulVirtSize,
pStrm->uSegment, true);
if (status != DSP_SOK) {
GT_0trace(STRM_debugMask, GT_6CLASS,
"STRM_Open: ERROR: "
"in setting CMM_XlatorInfo.\n");
}
}
}
func_cont:
if (DSP_SUCCEEDED(status)) {
/* Open channel */
uMode = (uDir == DSP_TONODE) ?
CHNL_MODETODSP : CHNL_MODEFROMDSP;
pIntfFxns = hStrmMgr->pIntfFxns;
status = (*pIntfFxns->pfnChnlOpen) (&(pStrm->hChnl),
hStrmMgr->hChnlMgr, uMode, ulChnlId, &chnlAttrs);
if (DSP_FAILED(status)) {
/*
* over-ride non-returnable status codes so we return
* something documented
*/
if (status != DSP_EMEMORY && status !=
DSP_EINVALIDARG && status != DSP_EFAIL) {
/*
* We got a status that's not return-able.
* Assert that we got something we were
* expecting (DSP_EHANDLE isn't acceptable,
* hStrmMgr->hChnlMgr better be valid or we
* assert here), and then return DSP_EFAIL.
*/
DBC_Assert(status == CHNL_E_OUTOFSTREAMS ||
status == CHNL_E_BADCHANID ||
status == CHNL_E_CHANBUSY ||
status == CHNL_E_NOIORPS);
status = DSP_EFAIL;
}
GT_2trace(STRM_debugMask, GT_6CLASS,
"STRM_Open: Channel open failed, "
"chnl id = %d, status = 0x%x\n", ulChnlId,
status);
}
}
if (DSP_SUCCEEDED(status))
*phStrm = pStrm;
else
(void)DeleteStrm(pStrm);
#ifndef RES_CLEANUP_DISABLE
/* Return PID instead of process handle */
hProcess = current->pid;
res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT);
if (DSP_SUCCEEDED(res_status)) {
DRV_GetProcContext(hProcess,
(struct DRV_OBJECT *)hDrvObject, &pCtxt,
hNode, 0);
if (pCtxt != NULL)
DRV_ProcInsertSTRMResElement(*phStrm, &hSTRMRes, pCtxt);
}
#endif
/* ensure we return a documented error code */
DBC_Ensure((DSP_SUCCEEDED(status) &&
MEM_IsValidHandle((*phStrm), STRM_SIGNATURE)) ||
(*phStrm == NULL && (status == DSP_EHANDLE ||
status == DSP_EDIRECTION || status == DSP_EVALUE ||
status == DSP_EFAIL)));
return status;
}
/*
* ======== SPHENC_process ========
* This method must be the same for both local and remote invocation;
* each call site in the client might be calling different implementations
* (one that marshalls & sends and one that simply calls). This API
* abstracts *all* speech encoders (both high and low complexity
* encoders are invoked using this method).
*/
XDAS_Int32 SPHENC_process(SPHENC_Handle handle, XDM_BufDesc *inBufs,
XDM_BufDesc *outBufs, ISPHENC_InArgs *inArgs, ISPHENC_OutArgs *outArgs)
{
XDAS_Int32 retVal = SPHENC_EFAIL;
SPHENC_InArgs refInArgs;
/*
* Note, we assign "VISA_isChecked()" results to a local variable
* rather than repeatedly query it throughout this fxn because
* someday we may allow dynamically changing the global
* 'VISA_isChecked()' value on the fly. If we allow that, we need
* to ensure the value stays consistent in the context of this
* call.
*/
Bool checked = VISA_isChecked();
if (checked) {
/* Ensure inArgs and outArgs are non-NULL, per the XDM spec */
if ((!(XdmUtils_validateExtendedStruct(inArgs, sizeof(*inArgs),
"inArgs"))) || (!(XdmUtils_validateExtendedStruct(outArgs,
sizeof(*outArgs), "outArgs")))) {
/* for safety, return here before dereferencing and crashing */
return (retVal);
}
}
GT_5trace(CURTRACE, GT_ENTER, "SPHENC_process> "
"Enter (handle=0x%x, inBufs=0x%x, outBufs=0x%x, inArgs=0x%x, "
"outArgs=0x%x)\n", handle, inBufs, outBufs, inArgs, outArgs);
if (handle) {
ISPHENC_Fxns *fxns =
(ISPHENC_Fxns *)VISA_getAlgFxns((VISA_Handle)handle);
ISPHENC_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if ((fxns != NULL) && (alg != NULL)) {
Log_printf(ti_sdo_ce_dvtLog, "%s", (Arg)"SPHENC:process",
(Arg)handle, (Arg)0);
if (checked) {
/*
* Zero out the outArgs struct (except for .size field);
* it's write-only to the codec, so the app shouldn't pass
* values through it, nor should the codec expect to
* receive values through it.
*/
memset((void *)((XDAS_Int32)(outArgs) + sizeof(outArgs->size)),
0, (sizeof(*outArgs) - sizeof(outArgs->size)));
/*
* Make a reference copy of inArgs so we can check that
* the codec didn't modify them during process().
*/
refInArgs = *inArgs;
}
VISA_enter((VISA_Handle)handle);
retVal = fxns->process(alg, inBufs, outBufs, inArgs, outArgs);
VISA_exit((VISA_Handle)handle);
if (checked) {
/* ensure the codec didn't modify the read-only inArgs */
if (memcmp(&refInArgs, inArgs, sizeof(*inArgs)) != 0) {
GT_1trace(CURTRACE, GT_7CLASS,
"ERROR> codec (0x%x) modified read-only inArgs "
"struct!\n", handle);
}
}
}
}
GT_2trace(CURTRACE, GT_ENTER, "SPHENC_process> "
"Exit (handle=0x%x, retVal=0x%x)\n", handle, retVal);
return (retVal);
}
/*
* ======== VIDENCCOPY_TI_process ========
*/
XDAS_Int32 VIDENCCOPY_TI_process(IVIDENC_Handle h, XDM_BufDesc *inBufs,
XDM_BufDesc *outBufs, IVIDENC_InArgs *inArgs, IVIDENC_OutArgs *outArgs)
{
XDAS_Int32 curBuf;
XDAS_UInt32 minSamples;
#ifdef USE_ACPY3
const Uint32 maxTransferChunkSize = 0xffff;
Uint32 thisTransferChunkSize = 0x0;
Uint32 remainingTransferChunkSize;
Uint32 thisTransferSrcAddr, thisTransferDstAddr;
ACPY3_Params params;
VIDENCCOPY_TI_Obj *videncObj = (VIDENCCOPY_TI_Obj *)h;
#endif
GT_5trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_process(0x%x, 0x%x, 0x%x, "
"0x%x, 0x%x)\n", h, inBufs, outBufs, inArgs, outArgs);
/* validate arguments - this codec only supports "base" xDM. */
if ((inArgs->size != sizeof(*inArgs)) ||
(outArgs->size != sizeof(*outArgs))) {
GT_2trace(curTrace, GT_ENTER,
"VIDENCCOPY_TI_process, unsupported size "
"(0x%x, 0x%x)\n", inArgs->size, outArgs->size);
return (IVIDENC_EFAIL);
}
#ifdef USE_ACPY3
/*
* Activate Channel scratch DMA channels.
*/
ACPY3_activate(videncObj->dmaHandle1D1D8B);
#endif
/* outArgs->bytesGenerated reports the total number of bytes generated */
outArgs->bytesGenerated = 0;
/*
* A couple constraints for this simple "copy" codec:
* - Video encoding presumes a single input buffer, so only one input
* buffer will be encoded, regardless of inBufs->numBufs.
* - Given a different size of an input and output buffers, only
* encode (i.e., copy) the lesser of the sizes.
*/
for (curBuf = 0; (curBuf < inBufs->numBufs) &&
(curBuf < outBufs->numBufs); curBuf++) {
/* there's an available in and out buffer, how many samples? */
minSamples = inBufs->bufSizes[curBuf] < outBufs->bufSizes[curBuf] ?
inBufs->bufSizes[curBuf] : outBufs->bufSizes[curBuf];
#ifdef USE_ACPY3
thisTransferSrcAddr = (Uint32)inBufs->bufs[curBuf];
thisTransferDstAddr = (Uint32)outBufs->bufs[curBuf];
remainingTransferChunkSize = minSamples;
while (remainingTransferChunkSize > 0) {
if (remainingTransferChunkSize > maxTransferChunkSize) {
thisTransferChunkSize = maxTransferChunkSize;
}
else {
thisTransferChunkSize = remainingTransferChunkSize;
}
/* Configure the logical channel */
params.transferType = ACPY3_1D1D;
params.srcAddr = (void *)thisTransferSrcAddr;
params.dstAddr = (void *)thisTransferDstAddr;
params.elementSize = thisTransferChunkSize;
params.numElements = 1;
params.waitId = 0;
params.numFrames = 1;
remainingTransferChunkSize -= thisTransferChunkSize;
thisTransferSrcAddr += thisTransferChunkSize;
thisTransferDstAddr += thisTransferChunkSize;
/* Configure logical dma channel */
ACPY3_configure(videncObj->dmaHandle1D1D8B, ¶ms, 0);
/* Use DMA to copy data */
ACPY3_start(videncObj->dmaHandle1D1D8B);
/* wait for transfer to finish */
ACPY3_wait(videncObj->dmaHandle1D1D8B);
}
GT_1trace(curTrace, GT_2CLASS, "VIDENCCOPY_TI_process> "
"ACPY3 Processed %d bytes.\n", minSamples);
#else
GT_3trace(curTrace, GT_2CLASS, "VIDENCCOPY_TI_process> "
"memcpy (0x%x, 0x%x, %d)\n",
outBufs->bufs[curBuf], inBufs->bufs[curBuf], minSamples);
/* process the data: read input, produce output */
memcpy(outBufs->bufs[curBuf], inBufs->bufs[curBuf], minSamples);
#endif
outArgs->bytesGenerated += minSamples;
}
/* Fill out the rest of the outArgs struct */
outArgs->extendedError = 0;
outArgs->encodedFrameType = 0; /* TODO */
outArgs->inputFrameSkip = IVIDEO_FRAME_ENCODED;
outArgs->reconBufs.numBufs = 0; /* important: indicate no reconBufs */
return (IVIDENC_EOK);
}
/*
* ======== ALG_create ========
*/
ALG_Handle ALG_create(Int scratchId, IALG_Fxns *fxns, IALG_Handle parent,
IALG_Params *params, UInt32 useCacheMem)
{
IALG_Fxns *fxnsPtr;
ALG_Handle alg;
Int numRecs;
IALG_MemRec *memTab;
Int i;
Int status;
GT_5trace(CURTRACE, GT_ENTER, "ALG_create> Enter "
"(scratchId=%d, fxns=0x%x, parentAlg=0x%x, params=0x%x, "
"useCacheMem=%d)\n",
scratchId, fxns, parent, params, useCacheMem);
if (fxns != NULL) {
/* determine size of the memTab structure */
numRecs = (fxns->algNumAlloc != NULL) ?
fxns->algNumAlloc() : IALG_DEFMEMRECS;
GT_1trace(CURTRACE, (GT_4CLASS | GT_2CLASS),
"ALG_create> algNumAlloc %d memory recs\n", numRecs);
/* allocate a memTab based on number of records alg specified */
if ((memTab = (IALG_MemRec *)malloc(numRecs * sizeof (IALG_MemRec)))) {
/* call alg's algAlloc fxn to fill in memTab[] */
numRecs = fxns->algAlloc(params, &fxnsPtr, memTab);
if (numRecs <= 0) {
GT_1trace(CURTRACE, GT_7CLASS,
"ALG_create> alg's algAlloc() returned alg-specific "
"error code (0x%x)\n", numRecs);
return (NULL);
}
GT_1trace(CURTRACE, (GT_4CLASS | GT_2CLASS),
"ALG_create> algAlloc returned numRecs=%d\n", numRecs);
for (i = 0; i < numRecs; i++) {
GT_5trace(CURTRACE, GT_4CLASS, "ALG_create> "
" Memory requested memTab[%d]: size=0x%x, align=0x%x, "
"space=0x%x, attrs=0x%x\n", i, memTab[i].size,
memTab[i].alignment, memTab[i].space,
memTab[i].attrs);
}
if (_ALG_allocMemory2(memTab, numRecs, useCacheMem)) {
/* set alg object handle, and set instance's function pointer */
alg = (IALG_Handle)memTab[0].base;
alg->fxns = fxns;
/* call alg initialize function with the memory it requested */
/* if algInit successful return the alg object's handle */
status = fxns->algInit(alg, memTab, parent, params);
if (status == IALG_EOK) {
GT_0trace(CURTRACE, GT_4CLASS,
"ALG_create> algInit returned IALG_EOK\n");
free(memTab);
GT_1trace(CURTRACE, GT_ENTER,
"ALG_create> Exit (algHandle=0x%x)\n", alg);
return (alg);
}
GT_1trace(CURTRACE, GT_7CLASS, "ALG_create> "
"algInit call failed %d\n", status);
/*
* Call algFree to free all instance memory, saved memTab recs.
*/
fxns->algFree(alg, memTab);
_ALG_freeMemory2(memTab, numRecs, useCacheMem);
}
free(memTab);
}
}
GT_0trace(CURTRACE, GT_ENTER, "ALG_create> Exit "
"(algHandle=NULL)\n");
return (NULL);
}
/*
* ======== PROCWRAP_Load ========
*/
u32 PROCWRAP_Load(union Trapped_Args *args, void *pr_ctxt)
{
s32 i, len;
DSP_STATUS status = DSP_SOK;
char *temp;
s32 count = args->ARGS_PROC_LOAD.iArgc;
u8 **argv, **envp = NULL;
DBC_Require(count > 0);
DBC_Require(count <= MAX_LOADARGS);
argv = MEM_Alloc(count * sizeof(u8 *), MEM_NONPAGED);
if (!argv) {
status = DSP_EMEMORY;
goto func_cont;
}
cp_fm_usr(argv, args->ARGS_PROC_LOAD.aArgv, status, count);
if (DSP_FAILED(status)) {
MEM_Free(argv);
argv = NULL;
goto func_cont;
}
for (i = 0; i < count; i++) {
if (argv[i]) {
/* User space pointer to argument */
temp = (char *) argv[i];
/* len is increased by 1 to accommodate NULL */
len = strlen_user((char *)temp) + 1;
/* Kernel space pointer to argument */
argv[i] = MEM_Alloc(len, MEM_NONPAGED);
if (argv[i]) {
cp_fm_usr(argv[i], temp, status, len);
if (DSP_FAILED(status)) {
MEM_Free(argv[i]);
argv[i] = NULL;
goto func_cont;
}
} else {
status = DSP_EMEMORY;
goto func_cont;
}
}
}
/* TODO: validate this */
if (args->ARGS_PROC_LOAD.aEnvp) {
/* number of elements in the envp array including NULL */
count = 0;
do {
get_user(temp, args->ARGS_PROC_LOAD.aEnvp + count);
count++;
} while (temp);
envp = MEM_Alloc(count * sizeof(u8 *), MEM_NONPAGED);
if (!envp) {
status = DSP_EMEMORY;
goto func_cont;
}
cp_fm_usr(envp, args->ARGS_PROC_LOAD.aEnvp, status, count);
if (DSP_FAILED(status)) {
MEM_Free(envp);
envp = NULL;
goto func_cont;
}
for (i = 0; envp[i]; i++) {
/* User space pointer to argument */
temp = (char *)envp[i];
/* len is increased by 1 to accommodate NULL */
len = strlen_user((char *)temp) + 1;
/* Kernel space pointer to argument */
envp[i] = MEM_Alloc(len, MEM_NONPAGED);
if (envp[i]) {
cp_fm_usr(envp[i], temp, status, len);
if (DSP_FAILED(status)) {
MEM_Free(envp[i]);
envp[i] = NULL;
goto func_cont;
}
} else {
status = DSP_EMEMORY;
goto func_cont;
}
}
}
GT_5trace(WCD_debugMask, GT_ENTER,
"PROCWRAP_Load, hProcessor: 0x%x\n\tiArgc:"
"0x%x\n\taArgv: 0x%x\n\taArgv[0]: %s\n\taEnvp: 0x%0x\n",
args->ARGS_PROC_LOAD.hProcessor,
args->ARGS_PROC_LOAD.iArgc, args->ARGS_PROC_LOAD.aArgv,
argv[0], args->ARGS_PROC_LOAD.aEnvp);
if (DSP_SUCCEEDED(status)) {
status = PROC_Load(args->ARGS_PROC_LOAD.hProcessor,
args->ARGS_PROC_LOAD.iArgc,
(CONST char **)argv, (CONST char **)envp);
}
func_cont:
if (envp) {
i = 0;
while (envp[i])
MEM_Free(envp[i++]);
MEM_Free(envp);
}
if (argv) {
count = args->ARGS_PROC_LOAD.iArgc;
for (i = 0; (i < count) && argv[i]; i++)
MEM_Free(argv[i]);
MEM_Free(argv);
}
return status;
}
