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; }