/*----------------------------------------------------------------------------- function: void TOOL_sleep(U8 timeToWait) description: waits for given time input: U8 timeToWait output: nothing return: nothing -----------------------------------------------------------------------------*/ void TOOL_sleep(U32 timeToWait) { U32 t1, t2; t1 = GD_TIMER_ReadTimerStamp(); do { t2 = GD_TIMER_ReadTimerStamp(); if (t2<t1) /* in case of timer overflow */ { t1 = GD_TIMER_ReadTimerStamp(); t2 = GD_TIMER_ReadTimerStamp(); } } while ((t2-t1) < (U32)timeToWait); }
AVL63X1_ErrorCode AVL63X1_IBSP_Delay( AVL_uint32 uiDelay_ms ) { AVL_uint32 t1, t2; t1 = GD_TIMER_ReadTimerStamp(); do { t2 = GD_TIMER_ReadTimerStamp(); if (t2<t1) /* in case of timer overflow */ { t1 = GD_TIMER_ReadTimerStamp(); t2 = GD_TIMER_ReadTimerStamp(); } } while ((t2-t1) < uiDelay_ms); return(AVL63X1_EC_OK); }
/************************************************** * Fe_User_SleepTime * This function currently justs wastes the time in a loop. * It is recommended that the user implements it in such a * way that the processor uses the time for other functions, * For example in an RTOS-environment the control can be given * back to the scheduler to allow other tasks to execute within * that time. * The function is used in all files of the QST_Api only as a * minimum wait time: That means implementations that "wait" longer * than specified by ulTime are allowed. But please keep in mind * that this may increase the locking time and reduce your zapping speed. * * Inputs: * ulTime: the min. time to sleep in ms. * * Returns: * GD_OK or GD_ERR_BAD_PARAMETER ***************************************************/ GERR FE_SleepTime(U32 ulTime) { U32 t1, t2; t1 = GD_TIMER_ReadTimerStamp(); do { t2 = GD_TIMER_ReadTimerStamp(); if( t2 < t1 ) /* in case of timer overflow */ { t1 = GD_TIMER_ReadTimerStamp(); t2 = GD_TIMER_ReadTimerStamp(); } } while( ( t2 - t1 ) < (U32)ulTime ); return GD_OK; }
/*! ******************************************************************************* ** ** \brief delay in milliseconds. ** ** \param msecs to be delay in milliseconds ** ** ******************************************************************************/ GERR GD_TIMER_Delay(U32 msecs) { U32 start_time = 0; U32 end_time = 0; int time_difference = 0; start_time = GD_TIMER_ReadTimerStamp(); do { end_time = GD_TIMER_ReadTimerStamp(); time_difference = (U32)(end_time - start_time); /* check overflow */ if(start_time > end_time) { time_difference = ((time_difference < 0L) ? -time_difference : time_difference); /* C-LIB code for labs() */ } }while(time_difference < msecs); return GD_OK; }
/************************************************** * MB86667_User_Sleep * This function currently justs wastes the time in a loop. * It is recommended that the user implements it in such a * way that the processor uses the time for other functions, * For example in an RTOS-environment the control can be given * back to the scheduler to allow other tasks to execute within * that time. * The function is used in all files of the MB86667_Api only as a * minimum wait time: That means implementations that "wait" longer * than specified by ulTime are allowed. But please keep in mind * that this may increase the locking time and reduce your zapping speed. * * Inputs: * ulTime: the min. time to sleep in ms. * * Returns: * GD_OK or GD_ERR_BAD_PARAMETER, defined in MB86667_API.h ***************************************************/ GERR MB86667_User_Sleep(U32 ulTime) { /* enter your code here to realise a "wait" function */ #ifdef USE_WITHIN_GOKESDK U32 t1, t2; t1 = GD_TIMER_ReadTimerStamp(); do { t2 = GD_TIMER_ReadTimerStamp(); if (t2<t1) /* in case of timer overflow */ { t1 = GD_TIMER_ReadTimerStamp(); t2 = GD_TIMER_ReadTimerStamp(); } } while ((t2-t1) < (U32)ulTime); #else Sleep(ulTime); #endif return GD_OK; }
/*! ******************************************************************************** ** ** \brief Send a T=0 data block to the smartcard ** ** This function sends a T=0 data block by sending the data given in the ** sendBuffer and reading the status bytes SW1 and SW2 into the receive buffer. ** ** Depending on the finishCallback parameter this function either blocks ** (if NULL) or returns immediatly (if non-NULL). ** ** \note The finishCallback function must be handled with care as it is ** called in interrupt context!!! ** ** \param handle a handle specifying which ICC instance to be accessed ** \param sendBufferP a pointer to a buffer containg the data to be send ** \param sendSize the number of bytes in the send buffer to be transfered ** \param receiveBufferP a pointer to the receive buffer where to store the response ** \param receiveSize the max. size of the receive buffer, at least 2 bytes ** holding the status word bytes SW1 and SW2 ** \param receivedBytesP a pointer to a variable where to store the real number ** of received bytes ** \param finishCallback a function pointer to be called if transfer has finished ** passing NULL here forces function to block until transfer ** has finished ** ** \return ** - GD_ERR_INVALID_HANDLE in case of error if the given handle is invalid ** - GD_OK if successfull ** - GD_ERR_ICC_OVERFLOW if read buffer overflow occoured ** - GD_ERR_ICC_TIMEOUT if a timeout was detected during read ** - GD_ERR_ICC_NO_ANSWER if the card did not response at all ** - GD_ERR_ICC_SLOT_EMPTY if there is no card in the slot ** - GD_ERR_UNKNOWN for any other unknown error condition ** ******************************************************************************** */ GERR GD_ICC_T0SendData( GD_HANDLE handle, U8* sendBufferP, U32 sendSize, U8* receiveBufferP, U32 receiveSize, U32* receivedBytesP, GD_ICC_FINISH_T finishCallback ) { U8 slot_state; volatile GD_ICC_STATE_MACHINE_S* icc_sm; U32 oldtime; #ifdef GD_ICC_DEBUG #undef __FUNCTION__ #define __FUNCTION__ "GD_ICC_T0SendData" GD_ICC_Printf( "[%s] enter\n", __FUNCTION__ ); #endif if( ICC_CheckHandle( handle ) != GTRUE ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_INVALID_HANDLE)\n", __FUNCTION__ ); #endif return( GD_ERR_INVALID_HANDLE ); } GD_ICC_GetSlotStatus( handle, &slot_state ); if( slot_state == GD_ICC_NO_CARD ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_SLOT_EMPTY)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_SLOT_EMPTY ); } icc_sm = (volatile GD_ICC_STATE_MACHINE_S*)(void*)handle; oldtime = GD_TIMER_ReadTimerStamp(); while( icc_sm->status == GD_ERR_ICC_RUNNING ) { if((GD_TIMER_ReadTimerStamp()-oldtime)>ICC_MAX_WAIT_TIME) { icc_sm->status=GD_OK; return(GD_ERR_ICC_TIMEOUT); } } //icc_sm = (volatile GD_ICC_STATE_MACHINE_S*)(void*)handle; icc_sm->status = GD_ERR_ICC_RUNNING; icc_sm->nextState = ICC_STATE_T0_TRANSMIT_START; icc_sm->readBuffer = receiveBufferP; icc_sm->readSize = receiveSize; icc_sm->readBytes = 0; icc_sm->readBytesP = receivedBytesP; icc_sm->writeBuffer = sendBufferP; icc_sm->writeBytes = sendSize; icc_sm->writePos = 0; icc_sm->checkPos = 0; icc_sm->finishCallback = finishCallback; icc_sm->irqRxCallback = ICC_StateMachine; icc_sm->irqTxCallback = ICC_StateMachine; //if( icc_sm->CWT == 0 ) icc_sm->CWT = 12; //if( icc_sm->BWT == 0 ) icc_sm->BWT = 12; ICC_EnableRxIrq( icc_sm->fhIndex, 0 ); ICC_EnableTxIrq( icc_sm->fhIndex, 0 ); ICC_DebugTransfer( GFALSE ); ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); if( finishCallback != NULL ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif return( GD_OK ); } oldtime = GD_TIMER_ReadTimerStamp(); while( icc_sm->status == GD_ERR_ICC_RUNNING ) { if((GD_TIMER_ReadTimerStamp()-oldtime)>ICC_MAX_WAIT_TIME) { icc_sm->status=GD_OK; return(GD_ERR_ICC_TIMEOUT); } } ICC_DebugTransfer( GTRUE ); #ifdef GD_ICC_ATR_DEBUG ICC_DebugHandle( icc_sm ); #endif *receivedBytesP = icc_sm->readBytes; GD_ICC_GetSlotStatus( handle, &slot_state ); if( slot_state == GD_ICC_NO_CARD ) { return( GD_ERR_ICC_SLOT_EMPTY ); } if( icc_sm->status == GD_OK ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif return( GD_OK ); } if( icc_sm->status == GD_ERR_ICC_TIMEOUT ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_TIMEOUT)\n", __FUNCTION__ ); #endif return( GD_OK ); } if( icc_sm->status == GD_ERR_ICC_NO_ANSWER ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_NO_ANSWER)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_NO_ANSWER ); } #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_UNKNOWN)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_UNKNOWN ); }
/*! ******************************************************************************** ** ** \brief Perform a cold reset ** ** This function does a cold-reset and waits for the ATR from the card. ** ** Depending on the finishCallback parameter this function either blocks ** (if NULL) or returns immediatly (if non-NULL). ** ** \note The finishCallback function must be handled with care as it is ** called in interrupt context!!! ** ** \param handle a handle specifying which ICC instance to be accessed ** \param paramsP a #GD_ICC_COLD_RESET_PARAMS_S containing cold reset ** parameters ** \param finishCallback a function pointer to be called if transfer has ** finished, passing NULL here forces function to block ** until reset has finished ** ** \return ** - GD_ERR_INVALID_HANDLE in case of error if the given handle is invalid ** - GD_OK if successfull ** - GD_ERR_ICC_OVERFLOW if read buffer overflow occoured ** - GD_ERR_ICC_TIMEOUT if a timeout was detected during read ** - GD_ERR_ICC_NO_ANSWER if the card did not response at all ** - GD_ERR_ICC_SLOT_EMPTY if there is no card in the slot ** - GD_ERR_UNKNOWN for any other unknown error condition ** ******************************************************************************** */ GERR GD_ICC_ColdReset( GD_HANDLE handle, GD_ICC_COLD_RESET_PARAMS_S* paramsP, GD_ICC_FINISH_T finishCallback ) { U8 slot_state; volatile GD_ICC_STATE_MACHINE_S* icc_sm; U32 oldtime; #ifdef GD_ICC_DEBUG #undef __FUNCTION__ #define __FUNCTION__ "GD_ICC_ColdReset" GD_ICC_Printf( "[%s] enter\n", __FUNCTION__ ); #endif if( ICC_CheckHandle( handle ) != GTRUE ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_INVALID_HANDLE)\n", __FUNCTION__ ); #endif return( GD_ERR_INVALID_HANDLE ); } icc_sm = (volatile GD_ICC_STATE_MACHINE_S*)(void*)handle; GD_ICC_GetSlotStatus( handle, &slot_state ); if( slot_state == GD_ICC_NO_CARD ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_SLOT_EMPTY)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_SLOT_EMPTY ); } oldtime = GD_TIMER_ReadTimerStamp(); while( icc_sm->status == GD_ERR_ICC_RUNNING ) { if((GD_TIMER_ReadTimerStamp()-oldtime)>ICC_MAX_WAIT_TIME) { icc_sm->status=GD_OK; return(GD_ERR_ICC_TIMEOUT); } } GH_ICC_set_GlobalControl_RESND( icc_state_machine->fhIndex, 0 ); if( ( paramsP->cardClock / 1000 ) < 1000 ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_BAD_PARAMETER)\n", __FUNCTION__ ); #endif return( GD_ERR_BAD_PARAMETER ); } if( ( paramsP->convention != GD_ICC_INVERSE_CONVENTION ) && ( paramsP->convention != GD_ICC_DIRECT_CONVENTION ) ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_BAD_PARAMETER)\n", __FUNCTION__ ); #endif return( GD_ERR_BAD_PARAMETER ); } if( ( paramsP->parity != GD_ICC_ODD_PARITY ) && ( paramsP->parity != GD_ICC_EVEN_PARITY ) && ( paramsP->parity != GD_ICC_NO_PARITY ) ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_BAD_PARAMETER)\n", __FUNCTION__ ); #endif return( GD_ERR_BAD_PARAMETER ); } if( ( paramsP->parityErrResend != GD_ICC_PAR_ERR_RESEND_EN ) && ( paramsP->parityErrResend != GD_ICC_PAR_ERR_RESEND_DIS ) ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_BAD_PARAMETER)\n", __FUNCTION__ ); #endif return( GD_ERR_BAD_PARAMETER ); } if( ( paramsP->dataBits != GD_ICC_8BIT_DATA ) && ( paramsP->dataBits != GD_ICC_9BIT_DATA ) ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_BAD_PARAMETER)\n", __FUNCTION__ ); #endif return( GD_ERR_BAD_PARAMETER ); } if( paramsP->dataBits == GD_ICC_8BIT_DATA) { if( paramsP->parity == GD_ICC_NO_PARITY ) { GH_ICC_set_GlobalControl_MODE_8N1( icc_state_machine->fhIndex, 1 ); GH_ICC_set_GlobalControl_FRM0( icc_state_machine->fhIndex, 1 ); } if( paramsP->parity == GD_ICC_ODD_PARITY ) { GH_ICC_set_GlobalControl_MODE_8N1( icc_state_machine->fhIndex, 0 ); GH_ICC_set_GlobalControl_PARITY( icc_state_machine->fhIndex, 1 ); GH_ICC_set_GlobalControl_FRM0( icc_state_machine->fhIndex, 0 ); } else if( paramsP->parity == GD_ICC_EVEN_PARITY ) { GH_ICC_set_GlobalControl_MODE_8N1( icc_state_machine->fhIndex, 0 ); GH_ICC_set_GlobalControl_PARITY( icc_state_machine->fhIndex, 0 ); GH_ICC_set_GlobalControl_FRM0( icc_state_machine->fhIndex, 0 ); } } if( paramsP->dataBits == GD_ICC_9BIT_DATA) { GH_ICC_set_GlobalControl_FRM0( icc_state_machine->fhIndex, 1 ); } if( paramsP->parityErrResend == GD_ICC_PAR_ERR_RESEND_EN ) { GH_ICC_set_GlobalControl_RESND( icc_state_machine->fhIndex, 1 ); } icc_sm->status = GD_ERR_ICC_RUNNING; icc_sm->nextState = ICC_STATE_COLD_RESET_START; icc_sm->cardClock = paramsP->cardClock / 1000; icc_sm->baudRate = paramsP->baudRate; icc_sm->convention = paramsP->convention; icc_sm->parity = paramsP->parity; icc_sm->parityErrResend = paramsP->parityErrResend; icc_sm->dataBits = paramsP->dataBits; icc_sm->atrBytes = 0; icc_sm->readBuffer = icc_sm->atrBuffer; icc_sm->readSize = icc_sm->atrSize; icc_sm->readBytes = 0; icc_sm->writeBuffer = 0; icc_sm->writeBytes = 0; icc_sm->writePos = 0; icc_sm->checkPos = 0; icc_sm->finishCallback = finishCallback; icc_sm->atrParity = 0; icc_sm->irqRxCallback = ICC_StateMachine; ICC_DebugTransfer( GFALSE ); ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); /* if( finishCallback != NULL ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif return( GD_OK ); }*/ oldtime = GD_TIMER_ReadTimerStamp(); while( icc_sm->status == GD_ERR_ICC_RUNNING ) { if((GD_TIMER_ReadTimerStamp()-oldtime)>ICC_MAX_WAIT_TIME) { icc_sm->status=GD_OK; return(GD_ERR_ICC_TIMEOUT); } } if( ICC_CheckATRData( icc_sm ) ) { GH_ICC_set_GlobalControl_MASKRXFUL( icc_sm->fhIndex, 0 ); icc_sm->status = GD_OK; icc_sm->nextState = ICC_STATE_COLD_RESET_FINISH; ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); } else { if( icc_sm->readBytes == 0 ) icc_sm->status = GD_ERR_ICC_NO_ANSWER; else icc_sm->status = GD_ERR_ICC_TIMEOUT; icc_sm->nextState = ICC_STATE_COLD_RESET_FINISH; ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); } ICC_DebugTransfer( GTRUE ); #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif //GD_ICC_SetBaudRate( (GD_HANDLE)(void*)icc_sm, icc_sm->baudRate ); GD_ICC_GetSlotStatus( handle, &slot_state ); if( slot_state == GD_ICC_NO_CARD ) { return( GD_ERR_ICC_SLOT_EMPTY ); } if( icc_sm->status == GD_OK ) { if( icc_sm->readBytes > icc_sm->atrSize ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_OVERFLOW)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_OVERFLOW ); } #ifdef GD_ICC_ATR_DEBUG ICC_DebugHandle( icc_sm ); #endif #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif if( paramsP->parityErrResend == GD_ICC_PAR_ERR_RESEND_EN ) { GH_ICC_set_GlobalControl_RESND( icc_state_machine->fhIndex, 1 ); } return( GD_OK ); } if( icc_sm->status == GD_ERR_ICC_TIMEOUT ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_TIMEOUT)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_TIMEOUT ); } if( icc_sm->status == GD_ERR_ICC_OVERFLOW ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_OVERFLOW)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_OVERFLOW ); } if( icc_sm->status == GD_ERR_ICC_NO_ANSWER ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_NO_ANSWER)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_NO_ANSWER ); } if( icc_sm->status == GD_ERR_ICC_SLOT_EMPTY ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_SLOT_EMPTY)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_SLOT_EMPTY ); } #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_UNKNOWN)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_UNKNOWN ); }
/*! ******************************************************************************** ** ** \brief Perform a warm reset ** ** This function does a warm-reset and waits until the card is ready again. ** ** Depending on the finishCallback parameter this function either blocks ** (if NULL) or returns immediatly (if non-NULL). ** ** \note The finishCallback function must be handled with care as it is ** called in interrupt context!!! ** ** \param handle a handle specifying which ICC instance to be accessed ** \param paramsP a #GD_ICC_WARM_RESET_PARAMS_S containing warm reset ** parameters ** \param finishCallback a function pointer to be called if transfer has ** finished, passing NULL here forces function to block ** until reset has finished ** ** \return ** - GD_ERR_INVALID_HANDLE in case of error if the given handle is invalid ** - GD_OK if successfull ** - GD_ERR_ICC_OVERFLOW if read buffer overflow occoured ** - GD_ERR_ICC_TIMEOUT if a timeout was detected during read ** - GD_ERR_ICC_NO_ANSWER if the card did not response at all ** - GD_ERR_ICC_SLOT_EMPTY if there is no card in the slot ** - GD_ERR_UNKNOWN for any other unknown error condition ** ******************************************************************************** */ GERR GD_ICC_WarmReset( GD_HANDLE handle, GD_ICC_WARM_RESET_PARAMS_S* paramsP, GD_ICC_FINISH_T finishCallback ) { volatile GD_ICC_STATE_MACHINE_S* icc_sm; U8 slot_state; U32 oldtime; #ifdef GD_ICC_DEBUG #undef __FUNCTION__ #define __FUNCTION__ "GD_ICC_WarmReset" GD_ICC_Printf( "[%s] enter\n", __FUNCTION__ ); #endif if( ICC_CheckHandle( handle ) != GTRUE ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_INVALID_HANDLE)\n", __FUNCTION__ ); #endif return( GD_ERR_INVALID_HANDLE ); } GD_ICC_GetSlotStatus( handle, &slot_state ); if( slot_state == GD_ICC_NO_CARD ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_SLOT_EMPTY)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_SLOT_EMPTY ); } icc_sm = (volatile GD_ICC_STATE_MACHINE_S*)(void*)handle; oldtime = GD_TIMER_ReadTimerStamp(); while( icc_sm->status == GD_ERR_ICC_RUNNING ) { if((GD_TIMER_ReadTimerStamp()-oldtime)>ICC_MAX_WAIT_TIME) { icc_sm->status=GD_OK; return(GD_ERR_ICC_TIMEOUT); } } //icc_sm = (volatile GD_ICC_STATE_MACHINE_S*)(void*)handle; icc_sm->cardClock = paramsP->cardClock / 1000; icc_sm->baudRate = paramsP->baudRate; icc_sm->status = GD_ERR_ICC_RUNNING; icc_sm->nextState = ICC_STATE_WARM_RESET_START; icc_sm->atrBytes = 0; icc_sm->readBuffer = icc_sm->atrBuffer; icc_sm->readSize = icc_sm->atrSize; icc_sm->readBytes = 0; icc_sm->writeBuffer = 0; icc_sm->writeBytes = 0; icc_sm->writePos = 0; icc_sm->checkPos = 0; icc_sm->finishCallback = finishCallback; icc_sm->atrParity = 0; icc_sm->irqRxCallback = ICC_StateMachine; ICC_DebugTransfer( GFALSE ); ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); /* if( finishCallback != NULL ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif return( GD_OK ); } */ oldtime = GD_TIMER_ReadTimerStamp(); while( icc_sm->status == GD_ERR_ICC_RUNNING ) { if((GD_TIMER_ReadTimerStamp()-oldtime)>ICC_MAX_WAIT_TIME) { icc_sm->status=GD_OK; return(GD_ERR_ICC_TIMEOUT); } } if( ICC_CheckATRData( icc_sm ) ) { GH_ICC_set_GlobalControl_MASKRXFUL( icc_sm->fhIndex, 0 ); icc_sm->status = GD_OK; icc_sm->nextState = ICC_STATE_COLD_RESET_FINISH; ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); } else { if( icc_sm->readBytes == 0 ) icc_sm->status = GD_ERR_ICC_NO_ANSWER; else icc_sm->status = GD_ERR_ICC_TIMEOUT; icc_sm->nextState = ICC_STATE_COLD_RESET_FINISH; ICC_StartIdleTimer( icc_sm, 1, GFALSE, ICC_StateMachine ); } ICC_DebugTransfer( GTRUE ); //GD_ICC_SetBaudRate( (GD_HANDLE)(void*)icc_sm, icc_sm->baudRate ); GD_ICC_GetSlotStatus( handle, &slot_state ); if( slot_state == GD_ICC_NO_CARD ) { return( GD_ERR_ICC_SLOT_EMPTY ); } if( icc_sm->status == GD_OK ) { if( icc_sm->readBytes > icc_sm->atrSize ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_OVERFLOW)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_OVERFLOW ); } #ifdef GD_ICC_ATR_DEBUG ICC_DebugHandle( icc_sm ); #endif #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (OK)\n", __FUNCTION__ ); #endif return( GD_OK ); } if( icc_sm->status == GD_ERR_ICC_TIMEOUT ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_TIMEOUT)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_TIMEOUT ); } if( icc_sm->status == GD_ERR_ICC_OVERFLOW ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_OVERFLOW)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_OVERFLOW ); } if( icc_sm->status == GD_ERR_ICC_NO_ANSWER ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_NO_ANSWER)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_NO_ANSWER ); } if( icc_sm->status == GD_ERR_ICC_SLOT_EMPTY ) { #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_SLOT_EMPTY)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_SLOT_EMPTY ); } #ifdef GD_ICC_DEBUG GD_ICC_Printf( "[%s] leave (GD_ERR_ICC_UNKNOWN)\n", __FUNCTION__ ); #endif return( GD_ERR_ICC_UNKNOWN ); }
GERR GND_I2C_Read(GD_HANDLE *handleP, U8 msSlaveAddr, U8* writeDataP,U32 wrDataLen, U8* readDataP, U32 rdDataLen) { GBOOL wrFlag = GFALSE; GD_I2C_SPEED_E speed; U32 stTime, endTime, timeOut; S32 diff; speed = (GD_I2C_SPEED_E)LOWBYTE(*handleP); if( State == GD_ERR_I2C_BUSY ) return GD_ERR_I2C_BUSY; if ((speed != GD_I2C_100KBPS && speed != GD_I2C_400KBPS ) || wrDataLen > MAX_DATA_LENGTH || rdDataLen > MAX_DATA_LENGTH || readDataP == NULL || rdDataLen == 0 ) return GD_ERR_BAD_PARAMETER; if (speed == GD_I2C_100KBPS) timeOut = (rdDataLen<<4)/100 + I2C_MIN_TIMEOUT; else timeOut = (rdDataLen<<4)/400 + I2C_MIN_TIMEOUT; /* check the OCCUP */ /* GH_I2C_get_StatusReg1(); if ( GH_I2C_getm_StatusReg1_OCCUP() != GFALSE ) return GD_ERR_I2C_BUS_OCCUP; */ stTime = GNH_EXT_GetRegister(REG_I2C_STATUSREG1); if ((stTime&BIT2) == BIT2) return GD_ERR_I2C_BUS_OCCUP; /* set pointer buffer for ISR */ WriteBufferP = writeDataP; ReadBufferP = readDataP; //GD_INT_SetInterruptMask( I2CHandle, GD_INT_DISABLED); GD_INT_SetInterruptMask( GD_INT_IIC_IRQ, GD_INT_DISABLED); /* check if speed for channel already set */ if (speed == GD_I2C_400KBPS) //GH_I2C_set_ControlReg1_I2C_SPEED(1); //GNH_EXT_SetRegister(REG_I2C_CONTROLREG1,CtrlReg1Shadow|BIT0); CtrlReg1Shadow |= BIT0; else //GH_I2C_set_ControlReg1_I2C_SPEED(0); //GNH_EXT_SetRegister(REG_I2C_CONTROLREG1,CtrlReg1Shadow&(~BIT0)); CtrlReg1Shadow &= ~BIT0; GNH_EXT_SetRegister(REG_I2C_CONTROLREG1,CtrlReg1Shadow); /* reset Generic mode*/ /* GH_I2C_set_ControlReg0(CtrlReg0Shadow); GH_I2C_set_ControlReg0_RESET(1); GH_I2C_set_ControlReg0_RESET(0); */ GNH_EXT_SetRegister(REG_I2C_CONTROLREG0,CtrlReg0Shadow|BIT3); GNH_EXT_SetRegister(REG_I2C_CONTROLREG0,CtrlReg0Shadow); if( wrDataLen > 0) { wrFlag = GTRUE; /* enable IRQ mask */ //GH_I2C_set_IRQMask1_AM_END(1); //GH_I2C_set_IRQMask1_AM_ERR(1); //GH_I2C_set_IRQMask1_AM_MRX_REQ(1); //GH_I2C_set_IRQMask1_AM_MTX_REQ(1); GNH_EXT_SetRegister(REG_I2C_IRQMASK1,BIT6|BIT5|BIT4|BIT3); //GH_I2C_set_IRQMask0(0L); GNH_EXT_SetRegister(REG_I2C_IRQMASK0,0); //GH_I2C_set_ControlReg1_MS_SLA_ADD(msSlaveAddr>>1); GNH_EXT_SetRegister(REG_I2C_CONTROLREG1,CtrlReg1Shadow|(((msSlaveAddr>>1)&0x7F)<<8)); /* set length in transmit register */ //GH_I2C_set_ControlReg2(wrDataLen+1); GNH_EXT_SetRegister(REG_I2C_CONTROLREG2,wrDataLen+1); /* set length in receive register */ //GH_I2C_set_ControlReg3(MIN_DATA_LENGTH); GNH_EXT_SetRegister(REG_I2C_CONTROLREG3,MIN_DATA_LENGTH); State = GD_ERR_I2C_BUSY; /* reset Auto mode and DMA mode */ //GH_I2C_set_GoReg(0L); GNH_EXT_SetRegister(REG_I2C_GOREG,0); //GH_I2C_set_GoReg_AM_RESET(1); GNH_EXT_SetRegister(REG_I2C_GOREG,BIT1); /* start data request */ //GH_I2C_set_GoReg(0L); GNH_EXT_SetRegister(REG_I2C_GOREG,0); //GH_I2C_set_GoReg_AM_START(1); GNH_EXT_SetRegister(REG_I2C_GOREG,BIT2); //GD_INT_SetInterruptMask( I2CHandle, GD_INT_ENABLED); GD_INT_SetInterruptMask( GD_INT_IIC_IRQ, GD_INT_ENABLED); stTime = GD_TIMER_ReadTimerStamp(); do { endTime= GD_TIMER_ReadTimerStamp(); diff = endTime - stTime; if(stTime > endTime) /* check overflow */ diff = ((diff < 0L) ? -diff : diff); /* C-LIB code for labs() */ }while(State == GD_ERR_I2C_BUSY && (diff < timeOut) ); if (State == GD_ERR_I2C_BUSY) State = GD_ERR_TIMEOUT; if (State != GD_OK) return State; //GD_INT_SetInterruptMask( I2CHandle, GD_INT_DISABLED); GD_INT_SetInterruptMask( GD_INT_IIC_IRQ, GD_INT_DISABLED); }
/************************************************** * * * Inputs: * ucFlag : * TIM_SYN_TIM * This flag causes the routine to wait for a transition of the system tick. * If you use TIM_RES_TIM and TIM_GET_TIM and the routine was not * synchronised before then you have to add one tick time * to your timeout in order to guarantee at least the timeout length. * ucIndex is ignored if only this flag is set. * TIM_RES_TIM Resets the timer counter with Index ucIndex. * The reset is done immediately without synchronisation to the system * timer. If your timer tick is long (like the 40ms in our example) then it is * recommended to call User_Timers with TIM_SYN_TIM before. * This gives the maximum accuracy but requires in worst case 40 ms for * synchronisation. * TIM_GET_TIM requests the elapsed time of Index ucIndex since its last reset * ucIndex: Timer index (currently from 0 to MAX_INDEX) * ulDiffTime: holds the elapsed time of a request in ms. * The precision is depending on the system clock. * Here we have a resolution of 40 resp. 33 ms * This gives in total a max time of more than 1000 hours. * * Returns: * GD_OK or GD_ERR_BAD_PARAMETER, defined in MB86667_API.h ***************************************************/ GERR MB86667_User_Timers(U8 ucFlag, U8 ucIndex, U32 *pulDiffTime) { U32 ulTempTime; *pulDiffTime = 0; if (ucFlag > TIM_GET_TIM) return(GD_ERR_BAD_PARAMETER); if (ucIndex > MB86667_MAX_USER_TIMERS) return(GD_ERR_BAD_PARAMETER); /* sync */ if ((ucFlag & TIM_SYN_TIM) == TIM_SYN_TIM) { /* wait here until timer changes */ #ifdef USE_WITHIN_GOKESDK ulTempTime = GD_TIMER_ReadTimerStamp(); while (GD_TIMER_ReadTimerStamp() == ulTempTime); /* wait */ #else { LARGE_INTEGER ft_start,ft; GetSystemTimeAsFileTime((FILETIME *)&ft_start); ft_start.QuadPart /= 10000; do { GetSystemTimeAsFileTime((FILETIME *)&ft); ft.QuadPart /= 10000; } while (ft.QuadPart==ft_start.QuadPart); } #endif } /* reset */ if ((ucFlag & TIM_RES_TIM) == TIM_RES_TIM) { /* set start time to current time */ #ifdef USE_WITHIN_GOKESDK StartTimes[ucIndex] = GD_TIMER_ReadTimerStamp(); #else { LARGE_INTEGER ft; GetSystemTimeAsFileTime((FILETIME *)&ft); ft.QuadPart /= 10000; StartTimes[ucIndex] = (U32) ft.QuadPart; } #endif *pulDiffTime = 0; } /* get */ if ((ucFlag & TIM_GET_TIM) == TIM_GET_TIM) { /* return current time */ #ifdef USE_WITHIN_GOKESDK ulTempTime = GD_TIMER_ReadTimerStamp(); #else { LARGE_INTEGER ft; GetSystemTimeAsFileTime((FILETIME *)&ft); ft.QuadPart /= 10000; ulTempTime = (U32) ft.QuadPart; } #endif if (ulTempTime >= StartTimes[ucIndex]) { *pulDiffTime = (U32)(ulTempTime - StartTimes[ucIndex]); } else { /* in case of timer overflow reset start time */ #ifdef USE_WITHIN_GOKESDK StartTimes[ucIndex] = GD_TIMER_ReadTimerStamp(); #else { LARGE_INTEGER ft; GetSystemTimeAsFileTime((FILETIME *)&ft); ft.QuadPart /= 10000; StartTimes[ucIndex] = (U32) ft.QuadPart; } #endif *pulDiffTime = 0; } } /* Mp_VoIntTimeClock increments every 1/25 sec (1/30 for NTSC) */ /* Other systems may have better reference and need to correct the pulDiffTime in a different way */ *pulDiffTime *= TIM_RESOLUTION; /* with this multiplication we get an overflow if time is longer than 1000 hours => shouldn't be a problem */ return GD_OK; }
/*! ******************************************************************************* ** ** \brief Feeds data into VBV buffer. ** ** \c GD_VID_OpenMemory() has to be called before. ** ** \param dataP Pointer to video data. ** \param size Number of 32 bit words to copy. ** ** \return Number of copied bytes. ** ** \sa GD_VID_OpenMemory() <br> ** GD_VID_FlushData() <br> ** GD_VID_CloseMemory() <br> ** ******************************************************************************/ U32 GD_VID_FeedData(U32 *dataP, U32 size) { #if defined(GK6105S) U16 i,k; U32 tt; U32 *p; U32 count; U32 indx = 0; U8 tsd; S16 pid; U32 time = 0; U32 vbvBufferSize = 0; U32 TsPacket = 0; U32 leftByte = 0; U8 MuxCfg = 0,writestep=0; #else volatile U32* adt; U32 i; U8 tsd; #endif #if defined(GD_VID_GKFEEDDATA_DEBUG) U32 time_old = GD_TIMER_ReadTimerStamp(); GM_Printf("GD_VID_FeedData started on %d\n", time_old); #endif /* copy the Iframe header to IFrameHeader, it is used in GD_VID_FlushData*/ IFrameHeader[0] = dataP[0]; IFrameHeader[1] = dataP[1]; if(VideoFromMemFlag == GFALSE) return 0; #if defined(GK6105S) TsPacket = (size*4)/184; leftByte = (size*4)%184; if(leftByte != 0) { TsPacket++; } /*add more ts packets to vbv*/ TsPacket = TsPacket*4; // to be customized here pid = 0x123; #ifdef AV_SEPRATE_FLAG tsd = GD_TSD_GetHardwareControlledBuffer(GD_TSD_VIDEO_PES); #else tsd = GD_TSD_GetHardwareControlledBuffer(); #endif vbvBufferSize = GH_BM_get_BufferSize(tsd, GD_TSD_VIDEO_PES); GH_TSD_set_SyncDistance(0xFF); GH_TSD_set_SyncDistance(187); //GH_TSD_set_InputMode_TS1_AM_SYNC(1); GH_VD_set_VideoControl_DEC( 0); /* reset VD */ GH_BM_set_BufferReadPointer(tsd, GD_TSD_VIDEO_PES,GH_BM_get_BufferWritePointer(tsd,GD_TSD_VIDEO_PES)); //GH_BM_set_BufferWritePointer(tsd, GD_TSD_VIDEO_PES, vbvBufferSize-184); //GH_BM_set_BufferReadPointer(tsd, GD_TSD_VIDEO_PES, vbvBufferSize-184); GD_TSD_SetChannelPid(GD_TSD_VIDEO_PES, tsd, pid); if(tsd == GD_TSD_1) { MuxCfg = GH_TSD_getm_MuxConfig_TSD1_MUX_CFG(); GH_TSD_set_InputMode_TS1_AM_SYNC(1); GH_TSD_set_MuxConfig_TSD1_MUX_CFG(3); } else if(tsd == GD_TSD_2) { MuxCfg = GH_TSD_getm_MuxConfig_TSD2_MUX_CFG(); GH_TSD_set_InputMode_TS2_AM_SYNC(1); GH_TSD_set_MuxConfig_TSD2_MUX_CFG(3); } // #if defined (GK6106) // else if(tsd == GD_TSD_3) // { // MuxCfg = GH_TSD_getm_MuxConfig_TSD2_MUX_CFG(); // GH_TSD34_set_InputMode_TS1_AM_SYNC(1); // GH_TSD34_set_MuxConfig_TSD3_MUX_CFG(3); // } // else if(tsd == GD_TSD_4) // { // MuxCfg = GH_TSD_getm_MuxConfig_TSD2_MUX_CFG(); // GH_TSD34_set_InputMode_TS2_AM_SYNC(1); // GH_TSD34_set_MuxConfig_TSD4_MUX_CFG(3); // } // #endif GD_TSD_ControlChannel(GD_TSD_VIDEO_PES, tsd, GD_TSD_ENABLE); for(indx = 0; indx<1; indx++) { count = 0; p = (U32 *)dataP; for (k = 0; k < TsPacket;k++) { tt = 20000; while((GH_TSD_get_PacketControl(tsd) != 0) && ((--tt) > 0) ); if(tt == 0) return 0; tt = 20000; while((GH_TSD_get_PacketStatus(tsd) != 0) && ((--tt) > 0) ); if(tt == 0) return 0; /* write the first ts packet at the end of the vbv buffer. */ if(writestep == 0) { GH_TSD_set_Packet0(tsd, 0, (0x47<<24) | (k & 0xF)|(pid<<8)|(0x1<<4)|(0x0<<6)); for(i=1;i<47;i++) { GH_TSD_set_Packet0(tsd, i,*p++); count++; if (count%size==0 ) { p = (U32 *)dataP; } } GH_TSD_set_PacketControl(tsd, 4); } if(writestep == 1) { GH_TSD_set_Packet1(tsd, 0, (0x47<<24) | (k & 0xF)|(pid<<8)|(0x1<<4)|(0x0<<6)); for(i=1;i<47;i++) { GH_TSD_set_Packet1(tsd, i,*p++); count++; if (count%size==0 ) { p = (U32 *)dataP; } } GH_TSD_set_PacketControl(tsd, 0x50); } if(writestep == 2) { GH_TSD_set_Packet2(tsd, 0, (0x47<<24) | (k & 0xF)|(pid<<8)|(0x1<<4)|(0x0<<6)); for(i=1;i<47;i++) { GH_TSD_set_Packet2(tsd, i,*p++); count++; if (count%size==0 ) { p = (U32 *)dataP; } } GH_TSD_set_PacketControl(tsd, 0x600); } if(writestep == 3) { GH_TSD_set_Packet3(tsd, 0, (0x47<<24) | (k & 0xF)|(pid<<8)|(0x1<<4)|(0x0<<6)); for(i=1;i<47;i++) { GH_TSD_set_Packet3(tsd, i,*p++); count++; if (count%size==0 ) { p = (U32 *)dataP; } } GH_TSD_set_PacketControl(tsd, 0x7000); } writestep++; if(writestep > 3) { writestep = 0; } } } GD_TSD_ControlChannel(GD_TSD_VIDEO_PES, tsd, GD_TSD_DISABLE); if(tsd == GD_TSD_1) { GH_TSD_set_MuxConfig_TSD1_MUX_CFG(MuxCfg); } else if(tsd == GD_TSD_2) { GH_TSD_set_MuxConfig_TSD2_MUX_CFG(MuxCfg); } // #if defined (GK6106) // else if(tsd == GD_TSD_3) // { // GH_TSD34_set_MuxConfig_TSD3_MUX_CFG(MuxCfg); // } // else if(tsd == GD_TSD_4) // { // GH_TSD34_set_MuxConfig_TSD4_MUX_CFG(MuxCfg); // } // #endif NumStillDataBytes = count<<2; #if defined(GD_VID_GKFEEDDATA_DEBUG) time_old = GD_TIMER_ReadTimerStamp(); GM_Printf("GD_VID_FeedData end on %d\n", time_old); #endif #else /* reset buffer pointer and stop decoder */ GH_VD_set_VideoControl_DEC( 0); /* reset VD */ #ifdef AV_SEPRATE_FLAG tsd = GD_TSD_GetHardwareControlledBuffer(GD_TSD_VIDEO_PES); #else tsd = GD_TSD_GetHardwareControlledBuffer(); #endif GH_BM_set_BufferReadPointer( tsd, GD_TSD_VIDEO_PES, 0); GH_BM_set_BufferWritePointer(tsd, GD_TSD_VIDEO_PES, 0); /* copy data into VBV buffer */ adt = GD_VID_GetBuffer(); for (i=0; i < size; i++) adt[i]=dataP[i]; /* A still image is only shown after a new image is going to be decoded. */ /* Therefore we add a few bytes from the same image at the end. */ for (i=0; i < 64; i++) adt[i+size]=adt[i]; NumStillDataBytes = (size+64)<<2; #endif return(NumStillDataBytes); }