HRESULT cliCBResponseClearReg(PB * incomingPacket, PB_PACKETTYPE packetType, RCODE_1394 *errorResponse)
// Clear the CLI response area if this address is written. Also
// resets the CLI output pointer to tbe beginning of the output buffer
// FYI: Seems the HAL driver insists on sending 4 byte Write BLOCK commands
// instead of Write Quadlet commands, so I decided to handle that case here too.
{
HRESULT hResult = E_FAIL;
*errorResponse = RSP_TYPE_ERROR;
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "Response Clear Register\n\r");
if ((packetType == PB_TYPE_WRITE_REQUEST_QUADLET) || (packetType == PB_TYPE_WRITE_REQUEST)) {
// This is a strobe address. We do something if it is written.
// We dont care about what is written
cliCBStatus = 0;
cliCBRespCount = 0;
#ifdef _CLICB_SYSLOGERROR
cliCBSysLogErrorStrLen = 0;
#endif //_CLICB_SYSLOGERROR
hResult = lalReplyWriteResponse(incomingPacket, RSP_COMPLETE, TRUE);
*errorResponse = RSP_COMPLETE;
}
return hResult;
}
HRESULT cliCBCallArea(PB * incomingPacket, PB_PACKETTYPE packetType, RCODE_1394 *errorResponse)
// Called when a CLI remote call arrives at the CLI_CALL_AREA for the new CLI interface
// Only block writes are allowed to this register
{
HRESULT hResult = NO_ERROR;
uint32 payloadSize = 0;
uint32* pPayload = NULL;
char cliCommandStr[kTempBufferSize] = {0};
*errorResponse = RSP_TYPE_ERROR;
hResult = pbGetPayloadSize(incomingPacket,&payloadSize);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetPayload(incomingPacket, (void **) &pPayload);
if (hResult != NO_ERROR) return hResult;
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "CLI command call: ");
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "packetType: %i, ", packetType);
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "payloadSize: %i", payloadSize);
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "\n\r");
if ((packetType == PB_TYPE_WRITE_REQUEST) && payloadSize > 4)
{
// Get the command and execute it
if (payloadSize <= kTempBufferSize)
{
memcpy(cliCommandStr, pPayload, payloadSize);
formatSwapStrBytes(cliCommandStr, payloadSize);
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "CLI command call: ");
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, cliCommandStr);
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "\n\r");
#ifdef _CLICB_DEFERRED_TASK
if (cliCBDeferred == TRUE)
{
CLICB_CMD* cmd = NULL;
hResult = lalReplyWriteResponse(incomingPacket, RSP_COMPLETE, TRUE);
*errorResponse = RSP_COMPLETE;
SYS_DEBUG(SYSDEBUG_TRACE_CLICB, "CLI command call: deferring to cli CB task \n\r");
hResult = cliCBAllocateDeferredCmd(&cmd, cliCommandStr);
if (hResult != NO_ERROR) return hResult;
// thread cli CB deferred task message queue
hResult = TCMsgQueueSend(cliCBDeferredQueueID, (void *) &cmd, TC_NO_WAIT);
if (hResult != NO_ERROR)
{
sysLogError(hResult, __LINE__, moduleName);
}
}
else
#endif //_CLICB_DEFERRED_TASK
{
cliCBResult = cliCBHandleCommand(cliCommandStr);
if (cliCBResult == NO_ERROR)
{
hResult = lalReplyWriteResponse(incomingPacket, RSP_COMPLETE, TRUE);
*errorResponse = RSP_COMPLETE;
}
else
{
*errorResponse = RSP_DATA_ERROR;
}
}
}
else
{
*errorResponse = RSP_DATA_ERROR;
}
}
else
{
if (payloadSize < 4) {
// <4 = DATA ERROR, =4 = TYPE ERROR, >4 <max = ok, >max = DATA ERROR
*errorResponse = RSP_DATA_ERROR;
}
}
return hResult;
}
static HRESULT mixer8firewireCoreCallback(PB *packetBlock)
{
HRESULT hResult = NO_ERROR;
PB_HEADER *pHeader = NULL;
PB_PACKETTYPE packetType = PB_TYPE_UNDEF;
PB_LOCKTYPE lockType;
OFFSET_1394 OffSetDest;
uint32 payloadSize = 0;
uint32 RegionOffSet = 0;
QUADLET *pPayload = NULL;
hResult = pbGetPacketHeader (packetBlock, &pHeader);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetPacketType(packetBlock,&packetType);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetDestinationOffset(packetBlock, &OffSetDest);
if (hResult != NO_ERROR) return hResult;
RegionOffSet = OffSetDest.Low - MIXER8_BASE_START;
hResult = pbGetDataLen(packetBlock,&payloadSize);
if(hResult != NO_ERROR)
return hResult;
if (packetType == PB_TYPE_WRITE_REQUEST_QUADLET)
{
hResult = pbGetPayload(packetBlock, (void **)&pPayload);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetDataLen(packetBlock,&payloadSize);
if (hResult != NO_ERROR) return hResult;
payloadSize = 4;
if(mixer8firewireCheckForWrite(RegionOffSet))
{
if (RegionOffSet == (MIXER8_OFFSET(CurrentConfiguration)))
{
if(mixer8CheckValidConfiguration((uint32)*pPayload))
{
memcpy((uint32*) ((int)&mixer8 + (int)RegionOffSet), pPayload, payloadSize);
hResult = lalReplyWriteResponse(packetBlock, RSP_COMPLETE, TRUE);
TCSemaphoreSignal(mixer8SemID);
}
else
{
hResult = lalReplyWriteResponse(packetBlock, RSP_DATA_ERROR, TRUE);
}
}
else
{
memcpy((uint32*) ((int)&mixer8 + (int)RegionOffSet), pPayload, payloadSize);
hResult = lalReplyWriteResponse(packetBlock, RSP_COMPLETE, TRUE);
TCSemaphoreSignal(mixer8SemID);
}
}
else
{
hResult = lalReplyWriteResponse(packetBlock, RSP_ADDRESS_ERROR, TRUE);
}
}
if (packetType == PB_TYPE_WRITE_REQUEST)
{
hResult = pbGetPayload(packetBlock, (void **) &pPayload);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetDataLen(packetBlock,&payloadSize);
if (hResult != NO_ERROR) return hResult;
if(mixer8firewireCheckForBulkWrite(RegionOffSet,payloadSize))
{
memcpy((uint32*) ((int)&mixer8 + (int)RegionOffSet), pPayload, payloadSize);
hResult = lalReplyWriteResponse(packetBlock, RSP_COMPLETE, TRUE);
TCSemaphoreSignal(mixer8SemID);
}
else
{
hResult = lalReplyWriteResponse(packetBlock, RSP_ADDRESS_ERROR, TRUE);
}
}
if (packetType == PB_TYPE_READ_REQUEST)
{
hResult = pbGetDataLen(packetBlock,&payloadSize);
if (hResult != NO_ERROR) return hResult;
hResult = lalReplyReadResponse(packetBlock, RSP_COMPLETE, (uint16) payloadSize,
(uint32*) ((int)&mixer8 + (int)RegionOffSet), TRUE);
}
if (packetType == PB_TYPE_READ_REQUEST_QUADLET)
{
payloadSize = 4;
hResult = lalReplyReadResponse(packetBlock, RSP_COMPLETE, (uint16) payloadSize,
(uint32*) ((int)&mixer8 + (int)RegionOffSet), TRUE);
}
if (packetType == PB_TYPE_LOCK_REQUEST)
{
hResult = pbGetLockType(packetBlock, &lockType);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetDataLen(packetBlock,&payloadSize);
if (hResult != NO_ERROR) return hResult;
hResult = pbGetPayload(packetBlock, (void **) &pPayload);
if (hResult != NO_ERROR) return hResult;
hResult = lalReplyLockResponse(packetBlock, RSP_COMPLETE, (uint16)payloadSize, pPayload, TRUE);
}
return hResult;
}
