servo.c

ct952 source code use for Digital Frame Photo

        _TitleKeyCopyInfoStore[bStore].dwTitleKey32Bit = _dwTitleKey[0];
        _TitleKeyCopyInfoStore[bStore].bTitleKey8Bit = (BYTE) (_dwTitleKey[1] >> 24);
        _TitleKeyCopyInfoStore[bStore].CopyInfo = cpinfo;
        return TRUE;
    }
// Added by Chern Shyh-Chain, 08-30-2001, END

    _CSS_SentTitleKey () ;
    __bSERVOErrMsg = SERVO_ERROR_NONE ;
        return TRUE ;
#endif

}


// ***********************************************************************
// Function    :   SERVO_Abort
// Description :   Abort  current servo CMD when OPEN/CLOSE/PREV/NEXT IR key was asserted
// ***********************************************************************
BYTE    SERVO_Abort( void )
{
    DWORD    flagRet;
    BYTE    bRet = 0;

    OS_LockMutex( &_mServoAbort );

    OS_ClearFlag( &servo_flag_var, ~SERVO_ABORT_FINISHED );

    OS_SetFlag( &servo_flag_var, SERVO_ABORT_CMD );
    flagRet = OS_TimedWaitFlag( &servo_flag_var, SERVO_ABORT_FINISHED,
            FLAG_WAITMODE_OR, COUNT_400_MSEC );
    OS_ClearFlag( &servo_flag_var, ~SERVO_ABORT_FINISHED );

    if( (flagRet != 0) && (aRETPacket[1] == NO_ERROR) )
    {
        bRet = 1;
    }

    OS_UnlockMutex( &_mServoAbort );

    return bRet;
}


// ***********************************************************************
// Function    :    SERVO_GetStatus
// Description :    Get the status from ude dvd-rom
// Arguments   :    bStatus : 
//                  UDE_STATUS_PLAYBACK : check play back status
//                  UDE_STATUS_TRAY : check tray status
//                  UDE_STATUS_MEDIA : check media status
//                  UDE_STATUS_QUEUE : check queue status
//                  UDE_STATUS_READ : check read status
// Return      :    TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE    SERVO_GetStatus( void )
{
    BYTE bRst;
    
    OS_LockMutex( &_mServoCmd );
    aCMDPacket [0] = SERVO_CMD_GET_STATUS;
    aCMDPacket [1] = GETSTATUS;     //UDE GetStatus command

    bRst = _IssueNewCommand( COUNT_400_MSEC );

//        _bSRVStatus = aRETPacket[2];
#if 1
    if( bRst )
    {
        _bSRVStatus = aRETPacket[2];
    }
    else
    {
        _bSRVStatus = SERVO_STATUS_COMMAND_ERROR;
    }
#endif  // 0

    OS_UnlockMutex( &_mServoCmd );

    return bRst;
}

// ***********************************************************************
//  Function    :   SERVO_CheckTrayStatus
//  Description :   Used to check if cd/dvd-rom tray is closed
//  Arguments   :   None
//  Return      :   tray status
//  Side Effect :   
// ***********************************************************************
BYTE    SERVO_CheckTrayStatus( void ) 
{   
    BYTE    bRet;

    bRet = SRC_TRAY_UNKNOWN;    // ** TCH1.05; Temp give it.
    
    if( SERVO_GetStatus() )
    {
        _bSRVStatus &= SERVO_STATUS_TRAY;
    }
    else
    {
        return SRC_TRAY_UNKNOWN;    // ** TCH1.05; Temp give it.
    }

    // ** TCH1.05; begin... Convert it for current SrcFilter Module.
    switch ( _bSRVStatus )
    {
        case SERVO_TRAY_STATUS_OPENED:
            bRet= SRC_TRAY_OPENED;
            break;

        case SERVO_TRAY_STATUS_OPENING:
            bRet= SRC_TRAY_OPENING;
            break;

        case SERVO_TRAY_STATUS_CLOSED:
            bRet= SRC_TRAY_CLOSED;
            break;

        case SERVO_TRAY_STATUS_CLOSING:
            bRet= SRC_TRAY_CLOSING;
            break;

        case SERVO_TRAY_STATUS_USER_PUSH:
            bRet= SRC_TRAY_USER_PUSH;
            break;            
    }

// ** TCH1.05;     return _bSRVStatus;
    return bRet;
    // ** TCH1.05; end...     
}

// ***********************************************************************
//  Function    :   SERVO_GetDiscStatus
//  Description :   Used to check if there's title in dvd-rom.
//                  Will check if tray is closed first.
//  Arguments   :   pStatus : Not used
//  Return      :   SERVO_HAVEDISC : Have disc in tray
//                  SERVO_NODISC : No disc in tray
//  Side Effect :   If return SERVO_NODISC, maybe due to some command fail rather than really no disc.
// ***********************************************************************
/*--CoCo1.20, reduce code size.
#ifndef CSC_MASK
BYTE SERVO_GetDiscStatus(PBYTE pStatus)
{    
    return (SERVO_WaitStable());
}

BYTE SERVO_WaitStable(void)
{   
    SERVO_GetStatus();
        
    if ((_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_PRESENT)
    {
#ifdef SUPPORT_PRINTF      
        printf ("Drive Ready !\n") ;
#endif  
        return SERVO_HAVEDISC;
    }
    //Disc is not present
    else if ((_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_NOT_PRESENT)
    {
#if defined(SUPPORT_PRINTF) ||  defined(_DEBUG_INFO)
            printf ("\n Media not present, no disc detected !\n") ;
#endif                
        return SERVO_NODISC;    
    }            
    else if ((_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_NOT_ANALYZED)
    {
#if defined(SUPPORT_PRINTF) ||  defined(_DEBUG_INFO)
            printf ("\n Media wrong !\n") ;
#endif                
        return SERVO_WRONGDISC;    
    }            
    
    //LJY1.25, Support opentray when servo fails to close tray.
#ifdef SUPPORT_OPENTRAY_WHEN_CLOSETRAY_FAILED    
    if((_bSRVStatus & SERVO_STATUS_TRAY) == SERVO_TRAY_STATUS_OPENING)
    {		
        // LLY2.37p, assign KEY_OPEN_CLOSE from F/W
        // To avoid IR and F/W key conflict issue
        //__bISRKey = KEY_OPEN_CLOSE;
        __bFWKey=KEY_OPEN_CLOSE;
        return SERVO_LOADDISC_FAILED;
    }
#endif  // #ifdef SUPPORT_OPENTRAY_WHEN_CLOSETRAY_FAILED

    return SERVO_NODISC; // Brian0.66
}
#endif  //CSC_MASK
*/

void    SERVO_InitialMutexFlag( void )
{
    OS_InitMutex( &_mServoAbort );
    OS_InitMutex( &_mServoCmd );
}


// Brian0.66
// for eCos909 only
BYTE    SERVO_GetMediaStatus( void )
{
    BYTE bMediaStatus;

    while( 1 )
    {
        bMediaStatus = SERVO_PollingMediaStatus();
        if( bMediaStatus != SRCFILTER_WAITING_STABLE )
        {
            break;
        }
    }

    return bMediaStatus;
    
}

BYTE    SERVO_ReadTOC( BYTE bTemp )
{
    BYTE bTrackNum, bLastSession;
    extern DWORD __dwSectorLastSession;
    
    // wyc0.95, need to initial __dwSectorLastSession to 0 when disc is DVD. Otherwise DVD will recognize wrong after playing multi-session disc.
    SERVO_GetDiscType( );
    if( _bSrvDiscType & DISC_TYPE_CD )
    {        
        bLastSession = _sessioninfo_TOC[0].bLastSession;
        bTrackNum = _sessioninfo_TOC[bLastSession-1].bFirstTrack;
        __dwSectorLastSession = COMUTL_MSFtoHSG( MAKE_MSF(_trk_TOC[bTrackNum-1].Min, _trk_TOC[bTrackNum-1].Sec, _trk_TOC[bTrackNum-1].Frm) );
    }

    // J500CSC_120, add for supporting DVD multi-session title
    else//if( _bSrvDiscType & DISC_TYPE_DVD )
    {
        bLastSession = _sessioninfo_TOC[0].bLastSession;                        //bLastSession save Session Noumber info
        __dwSectorLastSession = (DWORD) (_trk_TOC[bLastSession-1].Min<<16)      // LastSession start sector
                + (DWORD) (_trk_TOC[bLastSession-1].Sec<<8)
                + (DWORD) (_trk_TOC[bLastSession-1].Frm);
    }

    return TRUE;
}

BYTE    SERVO_PollingMediaStatus( void )
{
    SERVO_GetStatus( );

    if( _bSRVStatus == SERVO_STATUS_COMMAND_ERROR )
    {
        return SRCFILTER_WAITING_STABLE;
    }

    if( (_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_PRESENT )
    {
#ifdef SUPPORT_PRINTF      
        printf ("Drive Ready !\n") ;
#endif  
        return SRCFILTER_HAVEDISC;
    }
    //Disc is not present
    else if( (_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_NOT_PRESENT )
    {
#if defined(SUPPORT_PRINTF) ||  defined(_DEBUG_INFO)
        printf ("\n Media not present, no disc detected !\n") ;
#endif                
        return SRCFILTER_NODISC;    
    } 
    else if( (_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_NOT_ANALYZED )
    {
#if defined(SUPPORT_PRINTF) ||  defined(_DEBUG_INFO)
        printf ("\n Media Wrong !\n") ;
#endif                
        return SRCFILTER_WRONGDISC;    
    } 
    //else if ((_bSRVStatus & SERVO_STATUS_MEDIA) == SERVO_MEDIA_STATUS_NOT_PRESENT)
    //{
        
   return SRCFILTER_WAITING_STABLE;
   // }

}

// LLY1.50, restore API since CELL module will use SrcFilter_GetCurrentPos() --> SERVO_GetCurrentPos().
// And, add the necessary code for this function.
BYTE    SERVO_GetCurrentPos( PDWORD pdwCurrentPos )
{
    *pdwCurrentPos = __SF_SourceGBL[0].dwWriteSector;    
    return TRUE;
}


/*--CoCo1.20, reduce code size.
BYTE    SERVO_CheckDiscEnding( void )
{
    return FALSE ;
}
*/

/*--CoCo1.20, reduce code size.
#ifndef CSC_MASK
BOOL    SERVO_DumpCookedSector ( BYTE * pBuf, WORD wLength, DWORD dwOffset )
{
    return TRUE;
}

BOOL    SERVO_DumpSector ( BYTE * pBuf, WORD wLength, DWORD dwOffset )
{
    return TRUE;
}
#endif  //CSC_MASK
*/

/*--CoCo1.20, reduce code size.
BYTE    SERVO_CSS_SentDiscKey( void )
{
	return TRUE;
}
*/

/*--CoCo1.20, reduce code size.
void    SERVO_AdjustThreshold ( BYTE bType, DWORD dwLevel )
{
    return;
}
*/

//BYTE SERVO_ReadTitleKey(DWORD dwSectorNumber, BYTE bStore)
//{
//    return TRUE;
//}

//BYTE SERVO_GetTrackEnd(BYTE bTrackNum, PDWORD pLength)
//{
//    return TRUE;
//}

BYTE    SERVO_SetTitleKey( BYTE bStore )
{
    PARSER_WriteTitleKey( _TitleKeyCopyInfoStore[bStore - 1].ulunTitleKey );
    return TRUE;
}

/*--CoCo1.20, reduce code size.
BYTE    SERVO_ResetRecover( BYTE bNeedStable )
{
    return FALSE;
}
*/

// ** TCH1.05; begin...  Below section is for SrcFilter.
// ==================   For SrcFilter   ===========================
//***************************************************************************
//  Function    :   ::SERVOFilter_GetStatus (void)
//  Abstract    :   Monitor Servo Status. May issue KEY_OPEN_CLOSE if needed.
//  Arguments   :
//  Return      :   NONE
//  Side Effect :   
//  Notes       :
//***************************************************************************
BYTE    SERVOFilter_GetStatus( void )
{
    if( SERVO_GetStatus() )
    {
        if( _bSRVStatus & SERVO_SPINDLE_STATUS_SPINNING )
        {
            return SRC_SPINDLE_STATUS_SPINNING;
        }
    }
//    else
//    {        
//    }

    return SRC_STATUS_NONE;
}
// ** TCH1.05; end... 

#ifdef SUPPORT_STB

static BYTE    __bDisableServo = FALSE;
//Aron
extern cyg_handle_t alarm_hdl;
extern cyg_handle_t Thread_SERVO;
extern cyg_handle_t Thread_CMDBM;
extern BYTE SRV_ServoInitial(void);
extern void SRVSV_MotorDriveOn(BYTE btOn);

VOID SERVO_Enable(VOID)
{
    if(__bDisableServo == TRUE)
    {
        SRV_ServoInitial();
        OS_EnableAlarm(alarm_hdl);  
        OS_ResumeThread(Thread_SERVO);
        OS_ResumeThread(Thread_CMDBM);                   
        __bDisableServo = FALSE;
    } 
}


VOID SERVO_Disable(VOID)
{
    DWORD dwTimeCheckStatus;

    if (__bDisableServo == FALSE)
    {
        
        if(__bSFSourcePWDown == TRUE)
        {
            SrcFilter_StartUnit();
            __bSFSourcePWDown = FALSE;
        }        
        
        if (__btDriveOpen)
        {
            __btDriveOpen = FALSE;
            SrcFilter_CloseTray();
            OSD_OUTPUT_MACRO ( MSG_OPEN, FALSE, 3 );
            dwTimeCheckStatus = OS_GetSysTimer() ;              
            while (OS_GetSysTimer() - dwTimeCheckStatus < COUNT_5_SEC)
            {
                if ( SrcFilter_CheckTrayStatus () == SRC_TRAY_CLOSED )
                {
                    break;
                }
                else
                {
                    OS_YieldThread();
                }
            }
        }

        SrcFilter_PowerMode (SERVO_POWER_STOP) ;  

        if (SERVO_PollingMediaStatus() != SRCFILTER_NODISC)
        {
            dwTimeCheckStatus = OS_GetSysTimer() ;  
            while (OS_GetSysTimer() - dwTimeCheckStatus < COUNT_10_SEC)
            {
                if (SERVOFilter_GetStatus () != SRC_SPINDLE_STATUS_SPINNING)
                {
                    break;
                }
                else
                {
                    //printf("Waiting Servo stop!!!\n");
                    OS_YieldThread();
                }
            }
        }

        if (SERVOFilter_GetStatus () == SRC_SPINDLE_STATUS_SPINNING)
        {
            printf("Err Servo spinning!!!\n");
        }
        //else
        {
            SRV_ServoInitial();
            OS_DisableAlarm(alarm_hdl);  
            OS_SuspendThread(Thread_SERVO);
            OS_SuspendThread(Thread_CMDBM);
            SRVSV_MotorDriveOn(FALSE);
            __bDisableServo = TRUE;
        }
    }
}
#endif

BYTE    _IssueNewCommand( DWORD dwTimeOut )
{
    DWORD    flagRet;
    static volatile DWORD dwTmp;

    dwTmp = dwTimeOut;

    OS_ClearFlag( &servo_flag_var, ~SERVO_CMD_FINISHED );

    OS_SetFlag( &servo_flag_var, SERVO_NEW_CMD );
    flagRet = OS_TimedWaitFlag( &servo_flag_var, SERVO_CMD_FINISHED,
            FLAG_WAITMODE_OR,  dwTimeOut );
    OS_ClearFlag( &servo_flag_var, ~SERVO_CMD_FINISHED );

    if( (flagRet != 0) && (aRETPacket[1] == NO_ERROR) )
    {
        return 1;
    }
    else
    {
        asm volatile ("nop");
    }

    return 0;       // indicate that Time-out happened or command error
}

#else
//The following 2 functions are for parser usage.
void SRVIF_ParserUpdateSERVO(DWORD dwBuf,DWORD dwReadAddr, DWORD dwReadSector)
{

}

WORD SRVIF_ParserGetEDCInfo(DWORD dwStreamIdx ,DWORD dwDumpInBaseAddr,DWORD dwSectorIdx)
{
    return 0;
}

#endif //SUPPORT_SERVO_SOURCE //++CoCo2.37p