refcmdproc.c

IT projecotr reference design.

/****************************************************************************/
/*             TEXAS INSTRUMENTS PROPRIETARY INFORMATION                    */
/*                                                                          */
/*  (c) Copyright, Texas Instruments Incorporated, 2006.                    */
/*      All Rights Reserved.                                                */
/*                                                                          */
/*  Property of Texas Instruments Incorporated. Restricted Rights -         */
/*  Use, duplication, or disclosure is subject to restrictions set          */
/*  forth in TI's program license agreement and associated documentation.   */
/****************************************************************************/

/****************************************************************************/
/* refCmdProc.c                                                             */
/****************************************************************************/

#include <string.h>
#include <stdlib.h>

#include "common.h"
#include "ddp2230_rtos_include.h"
#include "api_ver.h"
#include "anr.h"
#include "cw.h"
#include "ddp.h"
#include "dmd.h"
#include "urt.h"
#include "gpio.h"
#include "gpioFunction.h"
#include "seq.h"
#include "src.h"                    /* src.h must be declared before disp.h */
#include "disp.h"
#include "frame.h"
#include "img.h"
#include "lmp.h"
#include "lmp_blst.h"
#include "pmd.h"
#include "dei.h"
#include "tpg.h"
#include "sfg.h"
#include "tpm.h"
#include "tmr.h"
#include "pwm.h"
#include "i2c.h"
#include "al_alc.h"            /* at end of API list. Has many dependencies */

#include "global.h"
#include "projectorCtl.h"
#include "refCmdProc.h"
#include "refDdcProc.h"
#include "dbmessage.h"
#include "eeprom.h"
#include "edid.h"
#include "info.h"
#include "sysmon.h"
#include "keycode.h"
#include "guiApp.h"
#include "version.h"
#include "iox.h"
#include "datapath.h"
#include "dispfmt.h"
#include "gammaDL.h"
#include "adccontrol.h"



/****************************************************************************/
/* An application sets the framing region via Source controls. Following    */
/* status/control functions are provided for autolock testing.              */
/****************************************************************************/

extern int08  ALC_SetVerticalFramingRegion( SRC_CHANNEL channel, uint16 v_start, uint16 v_stop );
extern void   ALC_GetVerticalFramingRegion( SRC_CHANNEL channel, ALC_RegionStruct *region );
extern int08  ALC_SetHorizontalFramingRegion( SRC_CHANNEL channel, uint16 h_start, uint16 h_stop );
extern void   ALC_GetHorizontalFramingRegion( SRC_CHANNEL channel, ALC_RegionStruct *region );



/****************************************************************************/
/* Command handlers.                                                        */
/****************************************************************************/

static BOOL cmdAlcClock_rd( void )                                /* 0x0704 */
{
    uint16 sampleClock ;

    if( PASS != ALC_GetSampleClock( &sampleClock ))
        return FALSE;

    cmdPut2( sampleClock );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcClock_wr( void )                                /* 0x0704 */
{
    uint16 clock = cmdGet2( uint16 );

    return PASS == ALC_SetSampleClock( clock );
}

/****************************************************************************/

static BOOL cmdAlcClockLim_rd( void )                             /* 0x0705 */
{
    ALC_LimitStruct limit;

    if( PASS != ALC_GetSampleClockLimits( &limit ))
        return FALSE;

    cmdPut2( limit.LowerLimit );
    cmdPut2( limit.UpperLimit );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcConfig_rd( void )                               /* 0x0703 */
{
    ALC_AutoLockASMCfgStruct cfg;

    ALC_GetAutoLockASMCfg( &cfg );

    cmdPutK1( 0 );                                          /* 0 for Analog */
    cmdPut1( cfg.OperatingMode );
    cmdPut1( cfg.ClockDetectionMode );
    cmdPut1( cfg.WideMode );
    cmdPut1( cfg.NumPhases );
    cmdPut2( cfg.VsyncsUntilManual );
    cmdPut2( cfg.RedCalibratedGain );
    cmdPut2( cfg.GreenCalibratedGain );
    cmdPut2( cfg.BlueCalibratedGain );
    cmdPut2( cfg.RedCalibratedOffset );
    cmdPut2( cfg.GreenCalibratedOffset );
    cmdPut2( cfg.BlueCalibratedOffset );
    cmdPut2( cfg.RedChMidLevelCalibratedOffset );
    cmdPut2( cfg.BlueChMidLevelCalibratedOffset );
    cmdPut1( cfg.Group1NumSavedModes );
    cmdPut1( cfg.Group2NumSavedModes );
    cmdPut1( cfg.SMTCfg );
    cmdPut4( cfg.StateMachineDisable );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcConfig_wr( void )                               /* 0x0703 */
{
    ALC_AutoLockASMCfgStruct cfg;
    uint08 dummy = cmdGet1( uint08 );                    /* skip first byte */

    ALC_GetAutoLockASMCfg( &cfg );                                  /* read */

    cfg.OperatingMode = cmdGet1( ALC_OperatingModeEnum );
    cfg.ClockDetectionMode = cmdGet1( ALC_ClockDetectionModeEnum );
    cfg.WideMode = cmdGet1( BOOL );
    cfg.NumPhases = cmdGet1( uint08 );
    cfg.VsyncsUntilManual = cmdGet2( uint16 );
    cfg.RedCalibratedGain = cmdGet2( uint16 );
    cfg.GreenCalibratedGain = cmdGet2( uint16 );
    cfg.BlueCalibratedGain = cmdGet2( uint16 );
    cfg.RedCalibratedOffset = cmdGet2( uint16 );
    cfg.GreenCalibratedOffset = cmdGet2(uint16  );
    cfg.BlueCalibratedOffset = cmdGet2( uint16 );
    cfg.RedChMidLevelCalibratedOffset = cmdGet2( uint16 );
    cfg.BlueChMidLevelCalibratedOffset = cmdGet2( uint16 );

    dummy = cmdGet1( uint08 );                                 /* skip byte */
    dummy = cmdGet1( uint08 );                                 /* skip byte */

    cfg.SMTCfg = cmdGet1( ALC_AutolockSMTCfgEnum );

    return PASS == ALC_SetAutoLockASMCfg( &cfg );
}

/****************************************************************************/

static BOOL cmdAlcCtrl_rd( void )                                 /* 0x0701 */
{
    ALC_StatusStruct stat;

    ALC_GetStatus( &stat );
    cmdPut1( stat.AlgorithmControl );
    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcCtrl_wr( void )                                 /* 0x0701 */
{
    ALC_AlgorithmCtlEnum ctrl = cmdGet1( ALC_AlgorithmCtlEnum );

    return PASS == ALC_AutoLockAlgorithmControl( ctrl );
}

/****************************************************************************/

static BOOL cmdAlcDebug_rd( void )                                /* 0x0712 */
{
    cmdPutK1( ALC_GetEnableDebugMessages());
    return TRUE;
}

/****************************************************************************/

void _alcDebugCallback( const uint08* msg )
{
    dbmsg_trace( DBM_ALWAYS, (char*)msg );
}

/********************************/

static BOOL cmdAlcDebug_wr( void )                                /* 0x0712 */
{
    BOOL enable = cmdGet1( BOOL );

    if( enable )
    {
        ALC_InstallDebugMessageCallback( _alcDebugCallback );
        ALC_SetEnableDebugMessages( TRUE );
    }

    else
    {
        ALC_SetEnableDebugMessages( FALSE );
        ALC_InstallDebugMessageCallback  ( NULL );
    }

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcFirstPL_rd( void )                              /* 0x071B */
{
    return FALSE;
}

/****************************************************************************/

static BOOL cmdAlcGain_wr( void )                                 /* 0x070C */
{
    uint16 rgain = cmdGet2( uint16 );
    uint16 ggain = cmdGet2( uint16 );
    uint16 bgain = cmdGet2( uint16 );

    return PASS == ALC_SetGain( rgain, ggain, bgain );
}

/****************************************************************************/

static BOOL cmdAlcGain_rd( void )                                 /* 0x070C */
{
    ALC_RGB16Struct rgb;

    if( PASS != ALC_GetGain( &rgb ))
        return FALSE;

    cmdPut2( rgb.Red );
    cmdPut2( rgb.Green );
    cmdPut2( rgb.Blue );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcGainLim_rd( void )                              /* 0x070D */
{
    ALC_LimitStruct limit;

    if( PASS != ALC_GetGainLimits( &limit ))
        return FALSE;

    cmdPut2( limit.LowerLimit );
    cmdPut2( limit.UpperLimit );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcHFrame_rd( void )                               /* 0x070A */
{
    ALC_RegionStruct region;
    SRC_CHANNEL channel = cmdGet1( SRC_CHANNEL );

    ALC_GetHorizontalFramingRegion( channel, &region );

    cmdPut2( region.Start );
    cmdPut2( region.Stop );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcHFrame_wr( void )                               /* 0x070A */
{
    SRC_CHANNEL channel  = cmdGet1( SRC_CHANNEL );
    uint16      lowerLim = cmdGet2( uint16 );
    uint16      upperLim = cmdGet2( uint16 );

    return PASS == ALC_SetHorizontalFramingRegion( channel, lowerLim, upperLim );
}

/****************************************************************************/

static BOOL cmdAlcHFrameLim_rd( void )                            /* 0x070B */
{
    ALC_LimitStruct limit;

    ALC_GetHorizontalFramingRegionLimits( SRC_PRIMARY, &limit );

    cmdPut2( limit.LowerLimit );
    cmdPut2( limit.UpperLimit );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcLevelWin_wr( void )                             /* 0x0710 */
{
    uint16 left   = cmdGet2( uint16 );
    uint16 right  = cmdGet2( uint16 );
    uint16 top    = cmdGet2( uint16 );
    uint16 bottom = cmdGet2( uint16 );

    return PASS == ALC_SetLevelDetectWindow(left, right, top, bottom);
}

/****************************************************************************/

static BOOL cmdAlcOffset_rd( void )                               /* 0x070E */
{
    ALC_RGB16Struct rgb;

    if( PASS != ALC_GetOffset( &rgb ))
        return FALSE;

    cmdPut2( rgb.Red );
    cmdPut2( rgb.Green );
    cmdPut2( rgb.Blue );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcOffset_wr( void )                               /* 0x070E */
{
    uint16 red = cmdGet2( uint16 );
    uint16 grn = cmdGet2( uint16 );
    uint16 blu = cmdGet2( uint16 );

    return PASS == ALC_SetOffset( red, grn, blu );
}

/****************************************************************************/

static BOOL cmdAlcOffsetLim_rd( void )                            /* 0x070F */
{
    ALC_LimitStruct limit;

    if( PASS != ALC_GetOffsetLimits( &limit ))
        return FALSE;

    cmdPut2( limit.LowerLimit );
    cmdPut2( limit.UpperLimit );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcPhase_wr( void )                                /* 0x0706 */
{
    return PASS == ALC_SetPhase( cmdGet1( uint08 ));
}

/****************************************************************************/

static BOOL cmdAlcPhase_rd( void )                                /* 0x0706 */
{
    uint08 phase;

    if( PASS != ALC_GetPhase( &phase ))
        return FALSE;

    cmdPut1(phase );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcPhaseLim_rd( void )                             /* 0x0707 */
{
    ALC_LimitStruct limit;

    if( PASS != ALC_GetPhaseLimits( &limit ))
        return FALSE;

    cmdPut2( limit.LowerLimit );
    cmdPut2( limit.UpperLimit );

    return TRUE;
}

/****************************************************************************/

static BOOL cmdAlcRGBLevel_rd( void )                             /* 0x0711 */
{
    ALC_RGB16Struct rgb1, rgb2;

    ALC_GetRGBLevels(&rgb1, &rgb2);

    cmdPut2( rgb1.Red   );
    cmdPut2( rgb1.Green );
    cmdPut2( rgb1.Blue  );
    cmdPut2( rgb2.Red   );
    cmdPut2( rgb2.Green );
    cmdPut2( rgb2.Blue  );