datapath.c

IT projecotr reference design.

    int08 retval;
    
    if( mbSend( datapathMbxID, DPMSG_IMAGEPOSITION, 1500, (uint32)value, FALSE, (uint32)(&retval) ) != MBM_PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "mb send failed\r\n", retval );
        return FAIL;
    }
    return retval;
}

/****************************************************************************/
/* User control to set rear projection and switch execution context         */
/****************************************************************************/

int08 datapath_UserSetRearProjection( uint08 enable )
{
    int08 retval;
    
    if( mbSend( datapathMbxID, DPMSG_REARPROJECTION, 1500, (uint32)enable, FALSE, (uint32)(&retval) ) != MBM_PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "mb send failed\r\n", retval );
        return FAIL;
    }
    return retval;
}

/****************************************************************************/
/* User control to set ceiling projection and switch execution context      */
/****************************************************************************/

int08 datapath_UserSetCeilingProjection( uint08 enable )
{
    int08 retval;
    
    if( mbSend( datapathMbxID, DPMSG_CEILINGPROJECTION, 1500, (uint32)enable, FALSE, (uint32)(&retval) ) != MBM_PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "mb send failed\r\n", retval );
        return FAIL;
    }
    return retval;
}

/****************************************************************************/
/* User control to set keystone and switch execution context                */
/****************************************************************************/

int08 datapath_UserSetKeystoneAnglePitch( int16 pitch )
{
    int08 retval;
    
    if( mbSend( datapathMbxID, DPMSG_KEYSTONEPITCH, 1500, (uint32)pitch, FALSE, (uint32)(&retval) ) != MBM_PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "mb send failed\r\n", retval );
        return FAIL;
    }
    return retval;
}

/****************************************************************************/
/* User control to run splash capture and switch execution context          */
/****************************************************************************/

int08 datapath_UserScreenCapture( void )
{
    int08 retval;
    
    if( mbSend( datapathMbxID, DPMSG_SPLASHCAPTURE, -1, 0, FALSE, (uint32)(&retval) ) != MBM_PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "mb send failed\r\n", retval );
        return FAIL;
    }
    return retval;
}

/***************************************************************************/
/* User control to read and apply color defaults from flash                */
/***************************************************************************/

void datapath_UserRestoreColorDefaults( BOOL resetAll )
{
    mbSend( datapathMbxID, DPMSG_RESTORECOLORDEFAULTS, -1, (uint32)resetAll, FALSE, 0 );
}

/***************************************************************************/
/* User control to read and apply color defaults from flash                */
/***************************************************************************/

void datapath_UserRestoreDisplayDefaults( void )
{
    mbSend( datapathMbxID, DPMSG_RESTOREDISPLAYDEFAULTS, -1, 0, FALSE, 0 );
}


/****************************************************************************/
/* Returns what is currently displayed on the DMD for the OSD               */
/****************************************************************************/

DP_CONNECTOR datapath_GetActiveDisplay( void )
{
    if( blankScreenEnabled )
    {
        return BLANKSCREEN;  /* does not currently distinguish blank sfg from blank splash */
    }
    
    if( sourceDesc.sourceActive )
    {
        return sourceDesc.connector;
    }

    if( datapathState == SPLASH_AT_STARTUP )
    {
        return SPLASH;
    }
    
    if( datapathState == TPG_DISPLAYED )
    {
        return TESTPATTERN;
    }

       /* if in any other state, not displaying an external source, and not */
       /* displaying splash or tpg we are displaying SFG                    */
    return NOSOURCE;
}

/****************************************************************************/
/* Datapath task - handles external messages and services state machine     */
/****************************************************************************/

void datapath_Task( void )
{
    int08 cc;

    while( 1 )
    {
                    /* datapath_Callback() will interpret received messages */
        cc = mbRecv( datapathMbxID, datapathTaskPollPeriod, datapath_Callback );

        if( cc == MBM_NOMSG )      /* timeout -- used to poll state machine */
        {
            datapath_Callback( DPMSG_NONE, 0, 0 );
        }
        else if( cc != PASS )
        {
            dbmsg_ftrace( DBM_ALWAYS, "ccode %d receiving Datapath message\r\n", cc );
        }
    }
}

/****************************************************************************/
/* Datapath message callback                                                */
/****************************************************************************/

static void datapath_Callback( uint16 msgID, uint32 parm, uint32 parm2 )
{
    switch( msgID )
    {
    case DPMSG_INIT:
        datapath_StartDisplay();
        datapathReady = TRUE;
        break;
    
    case DPMSG_GETREADY:
        *((uint32*)parm) = datapathReady;
        break;
        
    case DPMSG_GOTOSTATE:
        datapath_StopCurrentOperation();
        datapath_GotoState( parm );
        break;
    
    case DPMSG_SETCONNECTOR:
        datapath_StopCurrentOperation();
        if( parm < LAST_CONNECTOR )
        {
            sourceDesc.connector = (DP_CONNECTOR) parm;
        }
        else if( parm == NEXT_CONNECTOR )
        {
            datapath_CycleConnector( TRUE );
        }
        source_DisplaySFG( &sourceDesc );
        dispfmt_ConfigureForSource( FALSE );
        datapath_GotoState( BEGIN_SCAN );
        break;
    
    case DPMSG_SETTPG:
        datapath_SetTestPattern( parm );
        break;
  
    case DPMSG_BLANKCOLOR:
        source_SetUserSFGColor( &sourceDesc, parm );
        break;
        
    case DPMSG_OVERSCAN:
        *((int08*)parm2) = dispfmt_SetOverscan( (uint08)parm );
        break;
        
    case DPMSG_MAGNIFY:
        *((int08*)parm2) = dispfmt_SetMagnify( (int16)parm );
        break;

    case DPMSG_PAN:
        *((int08*)parm2) = dispfmt_SetPan( (int16)parm );
        break;        

    case DPMSG_SCAN:
        *((int08*)parm2) = dispfmt_SetScan( (int16)parm );
        break;        

    case DPMSG_IMAGESIZE:
        *((int08*)parm2) = dispfmt_SetImageSize( (uint08)(parm>>16), (int16)(parm & 0xFFFF) );
        break;     

    case DPMSG_ASPECTRATIO:
        *((int08*)parm2) = dispfmt_SetAspectRatio( (uint08)parm );
        break;        

    case DPMSG_IMAGEPOSITION:
        *((int08*)parm2) = dispfmt_SetImagePosition( (int16)parm );
        break;        

    case DPMSG_REARPROJECTION:
        *((int08*)parm2) = dispfmt_SetRearProjection( (uint08)parm );
        break;        

    case DPMSG_CEILINGPROJECTION:
        *((int08*)parm2) = dispfmt_SetCeilingProjection( (uint08)parm );
        break;        

    case DPMSG_KEYSTONEPITCH:
        *((int08*)parm2) = dispfmt_SetKeystoneAnglePitch( (int16)parm );
        break;
        
    case DPMSG_SPLASHCAPTURE:
        *((int08*)parm2) = pictcont_ScreenCapture();
        break;
        
    case DPMSG_RESTORECOLORDEFAULTS:
        pictcont_RestoreColorDefaults( (BOOL)parm );
        break;
        
    case DPMSG_RESTOREDISPLAYDEFAULTS:
        dispfmt_RestoreDefaults();
        break;
  
    case DPMSG_STATE_FLUSHED:
        if( parm != flushIndex )
        {
            return;
        }
        datapath_StateMachineProc( msgID );
        break;

    case DPMSG_STATE_SYNCSDETECTED:
    case DPMSG_STATE_LOCKED:
    case DPMSG_STATE_REACQUIRE:
    case DPMSG_STATE_LOSTLOCK:
    case DPMSG_STATE_TOGGLEBLANK:
    case DPMSG_STATE_SUSPENDSCAN:
    case DPMSG_STATE_RESUMESCAN:
    case DPMSG_STATE_RESYNC:
        datapath_StateMachineProc( msgID );
        break;

    case DPMSG_NONE:                   /* timeout handling used for polling */
                               /* call the polling function for each device */
        switch( sourceDesc.connector )
        {
        case DVI:
            msgID = dvicontrol_Poll( datapathState );
            break;
            
        case VGA:
            msgID = adccontrol_Poll( datapathState );
            break;
        
        case COMPOSITE:
        case SVIDEO:
        case COMPONENT:
            msgID = deccontrol_Poll( datapathState );
            break;
        
        default:
            msgID = DPMSG_NONE;
            break;
        }
                    /* process messages returned from the polling functions */
                    /* note: DPMSG_NONE still checks each state for timeout */
        datapath_StateMachineProc( msgID );
        break;
    
    default:
        datapath_StateMachineProc( msgID );
        break;
    }
}

/****************************************************************************/
/* Datapath state machine message/polling processor                         */
/****************************************************************************/

static void datapath_StateMachineProc( uint08 msgID )
{
    switch( datapathState )
    {
    case SPLASH_AT_STARTUP:
                             /* After time has elapsed, start source search */
        if( datapath_TimeElapsedInState() >= gpConfiguration->Datapath.SplashAtStartupTimeout )
        {
            source_DisplaySFG( &sourceDesc );
            dispfmt_ConfigureForSource( FALSE );
            
            datapath_GotoState( BEGIN_SCAN );
        }
        break;
        
    case SUSPENDED:
        switch( msgID )
        {
        case DPMSG_STATE_TOGGLEBLANK:
            if( !blankScreenEnabled )
            {
                blankScreenEnabled = TRUE;
            }
            else
            {
                blankScreenEnabled = FALSE;
                      /* leave SFG/splash displayed for search -- no action */
                datapath_GotoState( BEGIN_SCAN );  /* restart source search */
            }
            break;
 
        case DPMSG_STATE_RESUMESCAN:
            if( !blankScreenEnabled )
            {
                datapath_GotoState( BEGIN_SCAN );
            }
            break;
        }
        break;
    
    case TPG_DISPLAYED:
        /* an external state change request is the only way to exit suspended state */
        switch( msgID )
        {
        case DPMSG_STATE_TOGGLEBLANK:
            if( !blankScreenEnabled )
            {
                blankScreenEnabled = TRUE;
          
                datapath_StoreSourceDesc();
                source_DisplaySFG( &sourceDesc );
                dispfmt_ConfigureForSource( FALSE );
            }
            else
            {
                              /* remove SFG/splash, display external source */
                DISP_SetChannelSource( SRC_PRIMARY, DISP_EXTERNAL_SOURCE );
                blankScreenEnabled = FALSE;
                
                    /* don't change state, just restore settings for source */
                sourceDesc.activeDisplay = DP_TESTPATTERN;
                datapath_RetrieveSourceDesc();
                dispfmt_ConfigureForSource( FALSE );
            }
            break;
        }
        
        break;

    case BEGIN_SCAN:
        switch( msgID )
        {
        case DPMSG_STATE_FLUSHED:
            datapath_GotoState( LOOK_FOR_SYNCS );
            break;