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; } }
HRESULT briWaitTimeSinceResetPreCompletion(uint32 msec) { HRESULT hResult = NO_ERROR; uint32 elapsedTime = 0; uint32 waitTime = 0; DO_FOREVER { // wait until msec has elapsed since the bus reset completion, or since another reset completion occurs hResult = briElapsedTimeSinceResetPreCompletion(&elapsedTime); if (hResult != NO_ERROR) { if (hResult == E_BRI_NEW_BUS_RESET) { BOOL bResetDetected; briWaitOnResetPreCompletion (&bResetDetected); continue; // in a bus reset process } break; } if (elapsedTime < msec) { waitTime = msec - elapsedTime; TCTaskWait(waitTime); continue; // check if another reset completion has occured in between } break; } return hResult; }
HRESULT i2cWriteBuf(uint16 target, uint8 *buf, uint8 length) { HRESULT hResult; while((hResult = i2cOp(target, 1, buf, length)) == E_I2C_TRY_AGAIN) TCTaskWait(1); return hResult; }
// This thread drives the GUI statemachine static void myAppThread(void *dummy) { updateUI (); DO_FOREVER { TCTaskWait(30); uiFSMdo(); } }
// This function is called by the system when it needs to perform a // soft reset. If you need to reset any specific hardware do it here void targetBoardPrepareReset(void) { //this function will assure that the board is ready for reset targetSetMinConfigROM(); lhlSetIRMEnabled(FALSE); lhlBriForceBusReset(); TCTaskWait(1200); //enough for computer to determine the device has gone with new LLC fix. }
HRESULT StartBoot(void) { // S/W Reset Power manager targetBoardPrepareReset(); *((volatile uint32 *) PWRMGRBASE) = 0xF; TCTaskWait(500); // Reset 0.5 sec. return E_FAIL; }
void avsIntPollHandlers(void) { #if 1 //LM??? if (TCInterruptPollAVS0()) { avsIntEventHandler0(); } if (TCInterruptPollAVS1()) { avsIntEventHandler1(); } if (TCInterruptPollAVS2()) { avsIntEventHandler2(); } TCTaskWait(10); #else TCTaskWait(10000); #endif }
void avrDrdHandlerThread(void *dummy) { // HRESULT hResult = NO_ERROR; UNUSED_ARG(dummy); DO_FOREVER { TCTaskWait(10000); } }
// This thread handles the MIDI indicate LED's // It also makes sure that the codec gets initialized. static void myMidiIndicateThread(void *dummy) { //make sure update codec get's called if we already have lock DAL_STATUS dalStatus; dalGetCurrentStatus (eDAL_INTERFACE_1, &dalStatus); updateCodec(&dalStatus); DO_FOREVER { TCTaskWait(200); //every 200ms uint8 act = uart1_activity (); amDisplayLed (AM_LED_MIDI_IN,act&UART_RX_ACTIVITY); amDisplayLed (AM_LED_MIDI_OUT,act&UART_TX_ACTIVITY); } }
// updateCodec is called whenever DAL tells us that things have changed. // The function checks if any important stuff changed such as the rateMode // or the locked state. // We also handle some appliction specific LED stuff here. static void updateCodec(DAL_STATUS * pStatus) { uint16 w; if (((pStatus->state == eDAL_STATE_LOCKED) && !isLocked) || ((pStatus->state == eDAL_STATE_LOCKED) && (pStatus->lockedRateMode != lastLockedMode))) { //So either we became locked, or we slid into a new rate mode, in all cases //the codec/ADC/DAC should be told. if (firstInit) { //we got clocks, bring the device out of RESET amCtrlSetBit(LED_CODEC_NRST); TCTaskWait(10); //needs a little time?? firstInit=FALSE; } //Call the codec function for the selected mode targetWriteCodecSPIWord (0xa100); //reset switch (pStatus->lockedRateMode) { default: case eDAL_RATE_MODE_LOW: w=0xa264; break; case eDAL_RATE_MODE_MID: w=0xa265; break; case eDAL_RATE_MODE_HIGH: w=0xa266; break; } targetWriteCodecSPIWord (w); targetWriteCodecSPIWord (0xa600 | DAC_GAIN); targetWriteCodecSPIWord (0xa700 | DAC_GAIN); targetWriteCodecSPIWord (0xa103); //un-reset isLocked = true; lastLockedMode = pStatus->lockedRateMode; } else if ((pStatus->state != eDAL_STATE_LOCKED) && isLocked) { //we just lost lock //Call the codec function for the selected mode targetWriteCodecSPIWord (0xa100); //reset AKM codec, this will also mute isLocked = false; } }
void myAppThread(void *dummy) { uint32 prevTime = TCTimeGet(); DO_FOREVER { TCTaskWait(100); //just wake up every 100ms and do the following if ((TCTimeGet() - prevTime) > 1000) { } #ifdef _AXM20 AXM20Update(); #endif //_AXM20 } }
HRESULT lmHandleListElementWait(LM_CONTEXT* list, BOOL bIndexed, uint32 index, LM_HANDLE_INDEX_ELEMENT_CB callback, void **data, uint32 *arg1, uint32 *arg2) { HRESULT hResult = NO_ERROR; uint32 count = 0; DO_FOREVER { hResult = lmHandleListElement(list, bIndexed, index, callback, data, arg1, arg2); if (hResult != E_LM_ELEMENT_LOCKED) break; count++; if (count == 50) { TCTaskWait(1); count = 0; } } return hResult; }
/********************************************************* gray interrupt handler thread */ void grayIntThread(void *dummy) { UNUSED_ARG(dummy); DO_FOREVER { if (TCInterruptPollGray()) { #ifdef _GRAYINT_DEFERRED // put gray event to gray event handler threads messageQueue grayEventHandlerDeferredPolling(); #else //_GRAYINT_DEFERRED // call gray event handler directly grayEventHandlerDirectPolling(); #endif //_GRAYINT_DEFERRED } TCTaskWait(50); } }
// This function is called by the system when it needs to perform a // soft reset. As we are using CS6 which becomes A21 during boot we would // actually chip select the CPLD when trying to boot from the Flash and that // would make the system crash. // To avoid this we disable the CPLD parallel mode before resetting. void targetBoardPrepareReset(void) { //this function will assure that the board is ready for reset if (cpldSupported) { //we do not want the CPLD to respond to parallel requests at this point spiOpBlock(cpldSSId, CPLD_SPI_WR_CMD(CPLD_CTRL_REG, CPLD_CTRL_CODEC_EN | CPLD_CTRL_SPI1_EN | CPLD_CTRL_SPI2_EN | CPLD_CTRL_USER_EN), NULL); //disable the CS6 *((volatile uint32 *) MEM_SMSKR6) = 0x00000020;//SRAM, off, set 0 } targetSetMinConfigROM(); lhlSetIRMEnabled(FALSE); lhlBriForceBusReset(); TCTaskWait(1200); //enough for computer to determine the device has gone with new LLC fix. }
HRESULT briWaitTimeSinceResetIndication(uint32 msec) { HRESULT hResult = NO_ERROR; uint32 elapsedTime = 0; uint32 waitTime = 0; DO_FOREVER { // wait until msec has elapsed since the bus reset indication, or since another reset indication occurs hResult = briElapsedTimeSinceResetIndication(&elapsedTime); if (hResult != NO_ERROR) break; if (elapsedTime < msec) { waitTime = msec - elapsedTime; TCTaskWait(waitTime); continue; // check if another reset indication has occured in between } break; } return hResult; }
void fis_flash_erase_cb(void) { TCTaskWait(10); }
/***************************************************************************** nciReadNodeGeneralROMFormat ******************************************************************************/ HRESULT nciReadNodeGeneralROMFormat (uint32 nodeNum, uint32 busId, BIB_DATA *pCurBib) { HRESULT hResult = NO_ERROR; int32 quadNum = 0; // current bus info quadlet index OFFSET_1394 destOffset; uint32 i; uint32 maxRetry = 3; //LM??? QUADLET busInfoBlock[BIB_QUAD_ITEMS]; destOffset.High = 0xffff; for (quadNum = 0; (quadNum < BIB_QUAD_ITEMS) && (hResult == NO_ERROR); quadNum++) { #ifdef _SYSDEBUG if (sysDebugIsEnabled(SYSDEBUG_TRACE_BUSRESET)) { sysDebugPrintf("read quad %d for node %d\n\r", quadNum+1, nodeNum); } #endif //_SYSDEBUG destOffset.Low = BUS_INFO_BLOCK_ADDR + (quadNum * 4); for (i = 0; i < maxRetry; i++) { hResult = lhlReadNodeTimeout((uint32) (nodeNum | busId), destOffset, 4, &busInfoBlock[quadNum], LHL_QUEUE_PRIORITY, LHL_TX_REQ_SHORT_TIMEOUT_MSECS); if (hResult == NO_ERROR) { break; } #if 1 //LM??? if (lhlBriNewBusResetDetected(FALSE)) { return E_BRI_NEW_BUS_RESET; } #endif #ifdef _SYSDEBUG if (sysDebugIsEnabled(SYSDEBUG_TRACE_BUSRESET)) { sysDebugPrintf("failed read quad %d for node %d\n\r", quadNum+1, nodeNum); } #endif //_SYSDEBUG #if 1 //LM??? TCTaskWait(10); #endif } } if (hResult == NO_ERROR) { for (quadNum = 0; quadNum < BIB_QUAD_ITEMS; quadNum++) { pCurBib->busInfoBlock[quadNum] = busInfoBlock[quadNum]; } #ifdef _SIMULATE pCurBib->busInfoBlock[BIB_WWUIDLO_QUAD] += nodeNum; #endif //_SIMULATE } return hResult; }
HRESULT nciUpdateBusInfoBlocks (uint32 numNodes, BIB_DATA *bibs, BOOL bClear) { HRESULT hResult = NO_ERROR; uint32 nodeNum = 0; // current node, index into bifs UQUAD romHeader; // 1st quadlet in rom BIB_DATA *pCurBib; // I.E. bib[nodeNum] uint16 busId = 0; OFFSET_1394 destOffset; uint32 i; // bk: uint32 maxRetry = 5; //LM??? 3,..,5? // retries are blocking fcp outgoing traffic, reducing them to 1 is a temporary fix. // AV/C should be reworked to use nodeID-based API's then defer bib reads to the // application level. A bib should only be read whenever a handle is required for // a specific node uint32 maxRetry = 1; BOOL bRetry = FALSE; #ifdef _SYSDEBUG if (sysDebugIsEnabled(SYSDEBUG_TRACE_BUSRESET)) { sysDebugPrintf("Getting bibs for %d nodes\n\r", numNodes); } #endif //_SYSDEBUG hResult = briGetBusID(&busId); if (hResult != NO_ERROR) return hResult; if (bClear) for (nodeNum = 0; nodeNum < numNodes; ++nodeNum) { // all devices may be accessed by (bus_id | node_id). Insert this // here in case the node does not implement general ROM format or // does not respond to bus info block reads. pCurBib = &bibs[nodeNum]; memset(pCurBib, 0, sizeof(BIB_DATA)); pCurBib->bibDataRetry = TRUE; //LM??? retry reading bibData pCurBib->busInfoBlock[BIB_WWUIDLO_QUAD] = (busId | nodeNum); } destOffset.High = 0xffff; for (i = 0; i < maxRetry; i++) { bRetry = FALSE; for (nodeNum = 0; nodeNum < numNodes; ++nodeNum) { pCurBib = &bibs[nodeNum]; if (pCurBib->bibDataRetry == TRUE) { // bail if this bus reset was interrupted if (briNewBusReset() == TRUE) { hResult = E_BRI_NEW_BUS_RESET; sysLogError(hResult, __LINE__, moduleName); //LM??? return hResult; // new bus reset detected elsewhere } #if 1 if (nciIsNodeLinkActive (nodeNum) == TRUE) #endif { // read the first quadlet in config rom for the length byte. // If length = 1, the ROM format is minimal and there is no bus info block. // If length > 1 (general ROM format), read the 4 quadlets of the bus info block. (see 1394-1995, Section 8.2.3.5) #ifdef _SYSDEBUG if (sysDebugIsEnabled(SYSDEBUG_TRACE_BUSRESET)) { sysDebugPrintf("read ROM base for node %d\n\r", nodeNum); } #endif //_SYSDEBUG destOffset.Low = CONFIG_ROM_BASE_ADDR; hResult = lhlReadNodeTimeout(nodeNum | busId, destOffset, 4, (QUADLET*)&romHeader, LHL_QUEUE_PRIORITY, LHL_TX_REQ_SHORT_TIMEOUT_MSECS); if (hResult != NO_ERROR) { #ifdef _SYSDEBUG if (sysDebugIsEnabled(SYSDEBUG_TRACE_BUSRESET)) { sysDebugPrintf("failed read ROM base for node %d\n\r", nodeNum); } #endif //_SYSDEBUG // retry but be aware that non-compliant devices will have errors // - this is normal - just skip those devices bRetry = TRUE; } else if (romHeader.b.msb == 0) // examine length { hResult = E_NCI_ZERO_INFO_LENGTH; // 0 is not a valid value sysLogError(hResult, __LINE__, moduleName); pCurBib->bibDataRetry = FALSE; } else if (romHeader.b.msb == 1) { // minimal format pCurBib->bibDataRetry = FALSE; } else // length > 1, general rom format { hResult = nciReadNodeGeneralROMFormat (nodeNum, busId, pCurBib); if (hResult == NO_ERROR) { pCurBib->bibDataRetry = FALSE; bRetry = TRUE; } } } #if 1 else { pCurBib->bibDataRetry = FALSE; } #endif } } if (bRetry == FALSE) { break; } TCTaskWait((i*2+1)*(i*2+1)*10); } #ifdef _SYSDEBUG if (sysDebugIsEnabled(SYSDEBUG_TRACE_BUSRESET)) { sysDebugPrintf("nodeinfos done\n\r"); } #endif //_SYSDEBUG return hResult; }
void fis_flash_program_cb(void) { TCTaskWait(10); }