/*
* ======== control ========
* This is the stub-implementation for the control method
*/
static XDAS_Int32 control(ISCALE_Handle h, ISCALE_Cmd id,
ISCALE_DynamicParams *params)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_SCALE_Msg *msg;
/* get a message appropriate for this algorithm */
if ((msg = (_SCALE_Msg *)VISA_allocMsg(visa)) == NULL) {
return (SCALE_ERUNTIME);
}
/* marshall the command */
msg->visa.cmd = _SCALE_CCONTROL;
msg->cmd.control.id = id;
/* no pointers, just copy the dynamic params struct into the msg */
msg->cmd.control.params = *params;
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* nothing to unmarshall, just free the msg. */
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
/*
* ======== process ========
* This is the stub-implementation for the process method
*/
static XDAS_Int32 process(ISCALE_Handle h, XDAS_Int8 *inBuf,
XDAS_Int8 *outBuf, ISCALE_InArgs *inArgs, ISCALE_OutArgs *outArgs)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_SCALE_Msg *msg;
/* get a message appropriate for this algorithm */
if ((msg = (_SCALE_Msg *)VISA_allocMsg(visa)) == NULL) {
return (SCALE_ERUNTIME);
}
/* Specify the processing command that the skeleton should do */
msg->visa.cmd = _SCALE_CPROCESS;
/* inBuf is a pointer, so we have to convert it */
msg->cmd.process.inBuf = (XDAS_Int8 *)
Memory_getBufferPhysicalAddress(inBuf, inArgs->inBufSize, NULL);
if (msg->cmd.process.inBuf == NULL) {
retVal = SCALE_ERUNTIME;
goto exit;
}
/* Similarly with outBuf. Note that inArgs and outArgs contain no
* pointers, so we can simply copy the entire original structure.
*/
msg->cmd.process.outBuf = (XDAS_Int8 *)
Memory_getBufferPhysicalAddress(outBuf, inArgs->outBufSize, NULL);
if (msg->cmd.process.outBuf == NULL) {
retVal = SCALE_ERUNTIME;
goto exit;
}
/* inArgs has no pointers, so simply copy the struct fields into the msg */
msg->cmd.process.inArgs = *inArgs;
/* Note that outArgs is *output* and need not be provided to the skel */
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* copy out the outArgs */
*outArgs = msg->cmd.process.outArgs;
/* Note that we need not copy inArgs out of the msg. */
/*
* Note that we don't have to do any reverse address translation, as the
* originally provided buffers haven't changed.
*/
exit:
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
/*
* ======== process ========
* This is the sync stub implementation for the process method
*/
static XDAS_Int32 process(IVIDDEC2_Handle h, XDM1_BufDesc *inBufs,
XDM_BufDesc *outBufs, IVIDDEC2_InArgs *inArgs, IVIDDEC2_OutArgs *outArgs)
{
XDAS_Int32 retVal;
_VIDDEC2_Msg *msg;
VISA_Handle visa = (VISA_Handle)h;
retVal = marshallMsg(h, inBufs, outBufs, inArgs, outArgs, &msg);
if (retVal != IVIDDEC2_EOK) {
return (retVal);
}
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* Regardless of return value, unmarshall outArgs. */
retVal = unmarshallMsg(h, inBufs, outBufs, inArgs, outArgs, msg, retVal);
return (retVal);
}
/*
* ======== control ========
* This is the stub-implementation for the control method
*/
static XDAS_Int32 control(IAUDDEC_Handle h, IAUDDEC_Cmd id,
IAUDDEC_DynamicParams *params, IAUDDEC_Status *status)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_AUDDEC_Msg *msg;
IAUDDEC_Status *pMsgStatus;
Int payloadSize;
/*
* Validate arguments. Do we want to do this _every_ time, or just in
* checked builds?
*/
if ((params == NULL) || (params->size < sizeof(IAUDDEC_DynamicParams)) ||
(status == NULL) || (status->size < sizeof(IAUDDEC_Status))) {
/* invalid args, could even assert here, it's a spec violation. */
return (IAUDDEC_EFAIL);
}
/*
* Initialize extendedError to zero so we don't return something
* uninitialized in extendedError.
*/
status->extendedError = 0;
/* make sure it'll all fit! */
payloadSize = sizeof(VISA_MsgHeader) + sizeof(id) + params->size +
status->size;
if (payloadSize > VISA_getMaxMsgSize(visa)) {
/* Can't handle these large extended args. */
Log_print2(Diags_USER6,
"[+6] process> invalid arguments - too big (0x%x > 0x%x). "
"Validate .size fields", payloadSize,
VISA_getMaxMsgSize(visa));
return (IAUDDEC_EFAIL);
}
/* get a message appropriate for this algorithm */
if ((msg = (_AUDDEC_Msg *)VISA_allocMsg(visa)) == NULL) {
return (IAUDDEC_ERUNTIME);
}
/* marshall the command */
msg->visa.cmd = _AUDDEC_CCONTROL;
msg->cmd.control.id = id;
/* params has no pointers so simply memcpy "size" bytes into the msg */
memcpy(&(msg->cmd.control.params), params, params->size);
/* unmarshall status based on the "size" of params */
pMsgStatus = (IAUDDEC_Status *)((UInt)(&(msg->cmd.control.params)) +
params->size);
/*
* Initialize the .size and .data fields - the rest are filled in by
* the codec.
*/
pMsgStatus->size = status->size;
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* ensure we get CCONTROL msg (ensure async CPROCESS pipeline drained) */
Assert_isTrue(msg->visa.cmd == _AUDDEC_CCONTROL, (Assert_Id)NULL);
/* unmarshall status */
pMsgStatus = (IAUDDEC_Status *)((UInt)(&(msg->cmd.control.params)) +
params->size);
if (VISA_isChecked()) {
/* ensure codec didn't modify status->size */
Assert_isTrue(pMsgStatus->size == status->size, (Assert_Id)NULL);
}
memcpy(status, pMsgStatus, status->size);
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
/*
* ======== control ========
* This is the stub-implementation for the control method
*/
static XDAS_Int32 control(ISPHDEC_Handle h, ISPHDEC_Cmd id,
ISPHDEC_DynamicParams *params, ISPHDEC_Status *status)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_SPHDEC_Msg *msg;
ISPHDEC_Status *pMsgStatus;
Int payloadSize;
/*
* Validate arguments. Do we want to do this _every_ time, or just in
* checked builds?
*/
if ((params == NULL) || (params->size < sizeof(ISPHDEC_DynamicParams)) ||
(status == NULL) || (status->size < sizeof(ISPHDEC_Status))) {
/* invalid args, could even assert here, it's a spec violation. */
return (SPHDEC_EFAIL);
}
/* make sure it'll all fit! */
payloadSize = sizeof(VISA_MsgHeader) + sizeof(id) + params->size +
status->size;
if (payloadSize > VISA_getMaxMsgSize(visa)) {
/* Can't handle these large extended args. */
GT_2trace(CURTRACE, GT_6CLASS,
"process> invalid arguments - too big (0x%x > 0x%x). "
"Validate .size fields\n", payloadSize,
VISA_getMaxMsgSize(visa));
return (SPHDEC_EFAIL);
}
/* get a message appropriate for this algorithm */
if ((msg = (_SPHDEC_Msg *)VISA_allocMsg(visa)) == NULL) {
return (ISPHDEC_ERUNTIME);
}
/* marshall the command */
msg->visa.cmd = _SPHDEC_CCONTROL;
msg->cmd.control.id = id;
/* params has no pointers so simply memcpy "size" bytes into the msg */
memcpy(&(msg->cmd.control.params), params, params->size);
/* unmarshall status based on the "size" of params */
pMsgStatus = (ISPHDEC_Status *)((UInt)(&(msg->cmd.control.params)) +
params->size);
/* set the size field - the rest is filled in by the codec */
/* TODO:H probably want to zero out the rest of the status struct */
pMsgStatus->size = status->size;
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* ensure we get CCONTROL msg (ensure async CPROCESS pipeline drained) */
GT_assert(CURTRACE, msg->visa.cmd == _SPHDEC_CCONTROL);
/* unmarshall status */
pMsgStatus = (ISPHDEC_Status *)((UInt)(&(msg->cmd.control.params)) +
params->size);
if (VISA_isChecked()) {
/* ensure codec didn't modify status->size */
GT_assert(CURTRACE, pMsgStatus->size == status->size);
}
memcpy(status, pMsgStatus, status->size);
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
/*
* ======== control ========
* This is the stub-implementation for the control method
*/
static XDAS_Int32 control(IVIDDEC2_Handle h, IVIDDEC2_Cmd id,
IVIDDEC2_DynamicParams *params, IVIDDEC2_Status *status)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_VIDDEC2_Msg *msg;
IVIDDEC2_Status *pMsgStatus;
XDAS_Int8 *virtAddr = NULL;
Int payloadSize;
/*
* Validate arguments. Do we want to do this _every_ time, or just in
* checked builds?
*/
if ((params == NULL) || (params->size < sizeof(IVIDDEC2_DynamicParams)) ||
(status == NULL) || (status->size < sizeof(IVIDDEC2_Status))) {
/* invalid args, could even assert here, it's a spec violation. */
return (IVIDDEC2_EFAIL);
}
/*
* Initialize extendedError to zero so we don't return something
* uninitialized in extendedError.
*/
status->extendedError = 0;
/* make sure it'll all fit! */
payloadSize = sizeof(VISA_MsgHeader) + sizeof(id) + params->size +
status->size;
if (payloadSize > VISA_getMaxMsgSize(visa)) {
/* Can't handle these large extended args. */
Log_print2(Diags_USER6,
"[+6] control> invalid arguments - too big (0x%x > 0x%x). "
"Validate .size fields", payloadSize,
VISA_getMaxMsgSize(visa));
return (IVIDDEC2_EUNSUPPORTED);
}
/* get a message appropriate for this algorithm */
if ((msg = (_VIDDEC2_Msg *)VISA_allocMsg(visa)) == NULL) {
return (IVIDDEC2_EFAIL);
}
/* marshall the command */
msg->visa.cmd = _VIDDEC2_CCONTROL;
msg->cmd.control.id = id;
/* params has no pointers so simply memcpy "size" bytes into the msg */
memcpy(&(msg->cmd.control.params), params, params->size);
/* unmarshall status based on the "size" of params */
pMsgStatus = (IVIDDEC2_Status *)((UInt)(&(msg->cmd.control.params)) +
params->size);
/*
* Initialize the .size and .data fields - the rest are filled in by
* the codec.
*/
pMsgStatus->size = status->size;
if (status->data.buf != NULL) {
pMsgStatus->data.bufSize = status->data.bufSize;
/* save it for later */
virtAddr = status->data.buf;
pMsgStatus->data.buf = (XDAS_Int8 *)
Memory_getBufferPhysicalAddress(status->data.buf,
status->data.bufSize, NULL);
if (pMsgStatus->data.buf == NULL) {
retVal = IVIDDEC2_EFAIL;
goto exit;
}
}
else {
/* Place null into the msg so the skel knows it's invalid */
pMsgStatus->data.buf = NULL;
}
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* ensure we get CCONTROL msg (ensure async CPROCESS pipeline drained) */
Assert_isTrue(msg->visa.cmd == _VIDDEC2_CCONTROL, (Assert_Id)NULL);
/* unmarshall status */
pMsgStatus = (IVIDDEC2_Status *)((UInt)(&(msg->cmd.control.params)) +
params->size);
if (VISA_isChecked()) {
/* ensure codec didn't modify status->size */
Assert_isTrue(pMsgStatus->size == status->size, (Assert_Id)NULL);
/*
* TODO:L Should we also check that pMsgStatus->data.buf is the same
* after the call as before?
*/
}
memcpy(status, pMsgStatus, status->size);
/*
* And finally, restore status->data.buf to its original value. Note that
* this works even when status->data.buf was NULL because virtAddr is
* initialized to NULL.
*
* While potentially more confusing, this is just as correct as
* (and faster than!) calling Memory_getVirtualBuffer().
*/
status->data.buf = virtAddr;
/* Clear .accessMask; the local processor didn't access the buffer */
status->data.accessMask = 0;
exit:
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
/*
* ======== control ========
* This is the stub-implementation for the control method
*/
static XDAS_Int32 control(IVIDDEC2BACK_Handle h, XDM_Context *context,
IVIDDEC2_Status *status)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_VIDDEC2BACK_Msg *msg;
// IVIDDEC2_Status *pMsgStatus;
// XDAS_Int8 *virtAddr = NULL;
/*
* Validate arguments. Do we want to do this _every_ time, or just in
* checked builds?
*/
if ((context == NULL) || (status == NULL) ||
(status->size < sizeof(IVIDDEC2_Status))) {
/* invalid args, could even assert here, it's a spec violation. */
return (IVIDDEC2_EFAIL);
}
if (/* size of "stuff to marshall" > message size */
(sizeof(VISA_MsgHeader) + sizeof(*context) + status->size)
> sizeof(_VIDDEC2BACK_Msg)) {
/* Can't handle these large extended args. */
Log_print0(Diags_USER6,
"[+6] control> invalid arguments - validate .size fields");
return (IVIDDEC2_EUNSUPPORTED);
}
/* get a message appropriate for this algorithm */
if ((msg = (_VIDDEC2BACK_Msg *)VISA_allocMsg(visa)) == NULL) {
return (IVIDDEC2_EFAIL);
}
/* marshall the command */
msg->visa.cmd = _VIDDEC2BACK_CCONTROL;
/*
* Initialize the .size and .data fields - the rest are filled in by
* the codec.
*/
msg->cmd.control.status.size = status->size;
#if 0
if (status->data.buf != NULL) {
pMsgStatus->data.bufSize = status->data.bufSize;
/* save it for later */
virtAddr = status->data.buf;
pMsgStatus->data.buf = (XDAS_Int8 *)
Memory_getBufferPhysicalAddress(status->data.buf,
status->data.bufSize, NULL);
if (pMsgStatus->data.buf == NULL) {
retVal = IVIDDEC2_EFAIL;
goto exit;
}
}
else {
/* Place null into the msg so the skel knows it's invalid */
pMsgStatus->data.buf = NULL;
}
#endif
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* ensure we get CCONTROL msg (ensure async CPROCESS pipeline drained) */
Assert_isTrue(msg->visa.cmd == _VIDDEC2BACK_CCONTROL, (Assert_Id)NULL);
if (VISA_isChecked()) {
/* ensure codec didn't modify status->size */
Assert_isTrue(msg->cmd.control.status.size == status->size,
(Assert_Id)NULL);
/*
* TODO:L Should we also check that pMsgStatus->data.buf is the same
* after the call as before?
*/
}
memcpy(status, &(msg->cmd.control.status), status->size);
#if 0
/*
* And finally, restore status->data.buf to its original value. Note that
* this works even when status->data.buf was NULL because virtAddr is
* initialized to NULL.
*
* While potentially more confusing, this is just as correct as
* (and faster than!) calling Memory_getVirtualBuffer().
*/
status->data.buf = virtAddr;
/* Clear .accessMask; the local processor didn't access the buffer */
status->data.accessMask = 0;
#endif
//exit:
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
/*
* ======== control ========
* This is the stub-implementation for the control method
*/
static XDAS_Int32 control(IUNIVERSAL_Handle h, IUNIVERSAL_Cmd id,
IUNIVERSAL_DynamicParams *dynParams, IUNIVERSAL_Status *status)
{
XDAS_Int32 retVal;
VISA_Handle visa = (VISA_Handle)h;
_UNIVERSAL_Msg *msg;
IUNIVERSAL_Status *pMsgStatus;
XDAS_Int8 *virtAddr[XDM_MAX_IO_BUFFERS];
Int i;
Int numBufs;
Int payloadSize;
/*
* Validate arguments. Do we want to do this _every_ time, or just in
* checked builds?
*/
if ((dynParams == NULL) ||
(dynParams->size < sizeof(IUNIVERSAL_DynamicParams)) ||
(status == NULL) || (status->size < sizeof(IUNIVERSAL_Status))) {
/* invalid args, could even assert here, it's a spec violation. */
return (IUNIVERSAL_EFAIL);
}
/*
* Initialize extendedError to zero so we don't return something
* uninitialized in extendedError.
*/
status->extendedError = 0;
/* make sure it'll all fit! */
payloadSize = sizeof(VISA_MsgHeader) + sizeof(id) + dynParams->size +
status->size;
if (payloadSize > VISA_getMaxMsgSize(visa)) {
/* Can't handle these large extended args. */
Log_print2(Diags_USER6,
"[+6] control> invalid arguments - too big (0x%x > 0x%x). "
"Validate .size fields", payloadSize,
VISA_getMaxMsgSize(visa));
return (IUNIVERSAL_EUNSUPPORTED);
}
/* get a message appropriate for this algorithm */
if ((msg = (_UNIVERSAL_Msg *)VISA_allocMsg(visa)) == NULL) {
return (IUNIVERSAL_EFAIL);
}
/* marshall the command */
msg->visa.cmd = _UNIVERSAL_CCONTROL;
msg->cmd.control.id = id;
/* dynParams has no pointers so simply memcpy "size" bytes into the msg */
memcpy(&(msg->cmd.control.dynParams), dynParams, dynParams->size);
/* point at status based on the "size" of dynParams */
pMsgStatus =
(IUNIVERSAL_Status *)((UInt)(&(msg->cmd.control.dynParams)) +
dynParams->size);
/*
* Initialize the .size and .data fields - the rest are filled in by
* the codec.
*/
pMsgStatus->size = status->size;
/* 1) pMsgStatus->data.numBufs is a plain integer, we just copy it */
pMsgStatus->data.numBufs = status->data.numBufs;
/*
* status->data.descs[] is a sparse array of buffer descriptors. Convert
* them if non-NULL.
*/
for (i = 0, numBufs = 0;
((numBufs < status->data.numBufs) && (i < XDM_MAX_IO_BUFFERS)); i++) {
if (status->data.descs[i].buf != NULL) {
/* valid member of sparse array, convert it */
pMsgStatus->data.descs[i].bufSize = status->data.descs[i].bufSize;
/* save it for later */
virtAddr[i] = status->data.descs[i].buf;
pMsgStatus->data.descs[i].buf = (XDAS_Int8 *)
Memory_getBufferPhysicalAddress(status->data.descs[i].buf,
status->data.descs[i].bufSize, NULL);
if (pMsgStatus->data.descs[i].buf == NULL) {
retVal = IUNIVERSAL_EFAIL;
goto exit;
}
/* found, and handled, another buffer. */
numBufs++;
}
else {
/* empty member of sparse array, no conversion needed. */
pMsgStatus->data.descs[i].bufSize = 0;
pMsgStatus->data.descs[i].buf = NULL;
virtAddr[i] = NULL;
}
}
if (VISA_isChecked()) {
/* check that we found inBufs->numBufs pointers in inBufs->bufs[] */
Assert_isTrue(status->data.numBufs == numBufs, (Assert_Id)NULL);
}
/* send the message to the skeleton and wait for completion */
retVal = VISA_call(visa, (VISA_Msg *)&msg);
/* ensure we get CCONTROL msg (ensure async CPROCESS pipeline drained) */
Assert_isTrue(msg->visa.cmd == _UNIVERSAL_CCONTROL, (Assert_Id)NULL);
/* unmarshall status */
pMsgStatus =
(IUNIVERSAL_Status *)((UInt)(&(msg->cmd.control.dynParams)) +
dynParams->size);
if (VISA_isChecked()) {
/* ensure codec didn't modify status->size */
Assert_isTrue(pMsgStatus->size == status->size, (Assert_Id)NULL);
/*
* TODO:L Should we also check that pMsgStatus->data.buf is the same
* after the call as before?
*/
}
memcpy(status, pMsgStatus, status->size);
/*
* And finally, restore status->data.descs[].buf's to their original values.
*
* While potentially more confusing, this is just as correct as
* (and faster than!) calling Memory_getVirtualBuffer().
*/
for (i = 0, numBufs = 0;
(numBufs < status->data.numBufs) && (i < XDM_MAX_IO_BUFFERS); i++) {
status->data.descs[i].buf = virtAddr[i];
/* Clear .accessMask; the local processor didn't access the buffer */
status->data.descs[i].accessMask = 0;
if (virtAddr[i] != NULL) {
numBufs++;
}
}
exit:
VISA_freeMsg(visa, (VISA_Msg)msg);
return (retVal);
}
