static HRESULT i2cOp(uint16 target, uint8 type, uint8 *buf, uint8 length)
{
TCSemaphoreWait(i2cBufSemId);
if(tempTran.status != 0) {//busy
TCSemaphoreSignal(i2cBufSemId);
return E_I2C_TRY_AGAIN; //some error
}
addI2cTrans(&tempTran, type, target, buf, length);
TCSemaphoreSignal(i2cBufSemId);
startI2cTran();
if(TCTaskStarted())
TCSemaphoreWait(i2cCompleteSemId);
else
TCTaskWait(10);
//SYS_TRACE3(SYSDEBUG_TRACE_I2C, target, type, length);
if(i2cErrorOccur()) {
SYS_DEBUG(SYSDEBUG_TRACE_I2C, "error = %d \n", i2cErrorCounter());
return E_FAIL;
}
else {
return NO_ERROR;
}
}
static void spi_slave_complete_sb(uint32 sid, uint32 * value)
{
if (!value) return; //only read commands are blocking
if (sid == codecSSId)
TCSemaphoreSignal (codecSem);
else if (sid == cpldSSId)
TCSemaphoreSignal (cpldSem);
}
/*********************************************************
Signal to waiting threads bus reset completion
*/
HRESULT briSignalOnResetPreCompletion (void)
{
HRESULT hResult = NO_ERROR;
uint32 waitingTasks = 0;
if (!briInitialized)
{
hResult = E_BRI_NOT_INITIALIZED_FATAL;
sysLogError(hResult, __LINE__, moduleName);
return hResult;
}
// Exclusive exclusive access for briPreCompletionWaitingTasks (mutex)
hResult = TCMutexLock(briPreCompletionMutexSemID);
if (hResult != NO_ERROR) return hResult;
waitingTasks = briPreCompletionWaitingTasks;
briPreCompletionWaitingTasks = 0;
// Release exclusive access for briPreCompletionWaitingTasks (mutex)
TCMutexUnlock(briPreCompletionMutexSemID);
if (waitingTasks > 0)
{
while (waitingTasks--)
{
TCSemaphoreSignal(briPreCompletionSemID);
}
}
return hResult;
}
static HRESULT mixer8SetMaster_Tool(uint32 reg, uint32 value)
{
HRESULT hResult = NO_ERROR;
switch( reg)
{
case 0:
mixer8.Enable = value;
break;
case 1:
if(mixer8CheckValidConfiguration(value))
mixer8.CurrentConfiguration = value;
else
hResult = E_BAD_INPUT_PARAMETERS;
break;
case 2:
mixer8.MasterGain = value;
break;
case 3:
mixer8.MasterMute = value;
break;
case 4:
mixer8.MasterPan = value;
break;
}
TCSemaphoreSignal(mixer8SemID);
return hResult;
}
static HRESULT mixer8SetAux_Tool(uint32 ch_index, uint32 aux_index, uint32 reg, uint32 value)
{
HRESULT hResult = NO_ERROR;
if( (ch_index < 1) || (ch_index > 8 ) || (aux_index < 1) || (aux_index > 6 ) )
{
hResult = E_BAD_INPUT_PARAMETERS;
return hResult;
}
ch_index--;
aux_index--;
switch (reg)
{
case 0:
mixer8.ChannelParameters[ch_index].Aux[aux_index].On = value;
break;
case 1:
mixer8.ChannelParameters[ch_index].Aux[aux_index].PrePost = value;
break;
case 2:
mixer8.ChannelParameters[ch_index].Aux[aux_index].Value = value;
break;
}
TCSemaphoreSignal(mixer8SemID);
return hResult;
}
static HRESULT mixer8SetChannel_Tool(uint32 index, uint32 reg, uint32 value)
{
HRESULT hResult = NO_ERROR;
if( (index < 1) || (index > 8 ) )
{
hResult = E_BAD_INPUT_PARAMETERS;
return hResult;
}
else
index--;
switch( reg )
{
case 0:
mixer8.ChannelParameters[index].Mute = value;
break;
case 1:
mixer8.ChannelParameters[index].Solo = value;
break;
case 2:
mixer8.ChannelParameters[index].Fader = value;
break;
case 3:
mixer8.ChannelParameters[index].Pan = value;
break;
case 4:
mixer8.ChannelParameters[index].Coupled = value;
break;
}
TCSemaphoreSignal(mixer8SemID);
return hResult;
}
HRESULT avsIntSignalSemaphore(void)
{
HRESULT hResult = NO_ERROR;
#ifdef _AVSTRIG
targetSignalAVSTrigger();
#endif //_AVSTRIG
TCSemaphoreSignal(avsIntSemID);
return hResult;
}
static HRESULT mixer8SetCoef_Tool(uint32 index, uint32 value)
{
HRESULT hResult = NO_ERROR;
if( (index < 1) || (index > 64 ) )
{
hResult = E_BAD_INPUT_PARAMETERS;
return hResult;
}
mixer8.ShadowCoeffs[index-1] = value;
TCSemaphoreSignal(mixer8SemID);
return hResult;
}
static void lhlTxIntHandler(void)
{
//if we are called it can only be to signal context[1] semaphore
// ML: TODO add flags if the other context had a semaphore
// ML 140610: Busreset storm fix. Use semID to indicate whether semaphore was signaled.
// The problem would occur if a bus reset comes in after the Isr handler had returned
// TRUE but before this DSR was called. The lhlBrInOutHandler would not clean up as
// the posted flag was clear so it would think cleaning was done.
if (postedTxState.contexts[1].semID)
{
fSYS_TRACE1(SYSDEBUG_TRACE_TESTS,0);
TCSemaphoreSignal(postedTxState.contexts[1].semID);
postedTxState.contexts[1].semID = 0; //done signaling.
}
}
void i2cIntDsr(void)
{
uint32 int_stat = MPTR(IC_INTR_STAT);
uint32 int_raw_stat = MPTR(IC_RAW_INTR_STAT);
//disable interrupt
TCInterruptGlobalDisable();
//SYS_TRACE3(SYSDEBUG_TRACE_I2C, int_stat, int_raw_stat, tempTran.status);
if((int_stat & BIT4) && ((int_raw_stat & BIT8) == 0)) { // TX empty and no activity
switch(tempTran.status) {
int i;
case 2:
//we are guranteed to have enough buf
for(i = 0; i < tempTran.length; i++) {
switch (tempTran.type) {
case 0:
_i2cIntWriteCmd(0x100);
break;
case 1:
_i2cIntWriteCmd(tempTran.data[tempTran.cur_pos]);
tempTran.cur_pos++;
break;
}
}
tempTran.status++;
break;
case 3:
MPTR(IC_INTR_MASK) &= ~BIT4; //clear TX empty interrupt
if(tempTran.type == 1) {
resetTran(&tempTran);
MPTR(IC_INTR_MASK) = 0;
//SYS_TRACE0(SYSDEBUG_TRACE_I2C);
TCSemaphoreSignal(i2cCompleteSemId);
}
break;
default:
break;
}
}
if(int_stat & BIT2) { // Rx not empty
//while(MPTR(IC_STATUS) & BIT3) {//rx not
while(MPTR(IC_RXFLR) != 0) {//rx not empty
tempTran.data[tempTran.cur_pos] = MPTR(IC_DATA_CMD);
tempTran.cur_pos++;
}
if(tempTran.cur_pos >= tempTran.length) {
resetTran(&tempTran);
MPTR(IC_INTR_MASK) = 0;
//SYS_TRACE1(SYSDEBUG_TRACE_I2C, tempTran.cur_pos);
TCSemaphoreSignal(i2cCompleteSemId);
}
}
if(int_stat & BIT6) { //Tx Error
i2c_tx_err_counter++;
i2c_last_tx_error = MPTR(IC_TX_ABRT_SOURCE);
resetTran(&tempTran);
MPTR(IC_INTR_MASK) = 0;
//SYS_TRACE2(SYSDEBUG_TRACE_I2C, i2c_last_tx_error, i2c_tx_err_counter);
TCSemaphoreSignal(i2cCompleteSemId);
}
_i2cClearIntr();
TCInterruptGlobalRestore();
}
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;
}
