refcmdproc.c

IT projecotr reference design.

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

static BOOL cmdApp_IntStack_rd( void )                            /* 0x0212 */
{
    extern uint32 HEAP_End;                 /* low limit of interrupt stack */
    extern uint32 Stack_Limit;             /* high limit of interrupt stack */

    uint32 *p = &HEAP_End;                            /* pointer into stack */
    uint32  fill  = *p++;                               /* stack fill value */
    uint32  sfree = 0;                         /* count of free stack bytes */
    uint32  ssize = (uint32)&Stack_Limit - (uint32)&HEAP_End; /* stack size */
    uint32  sused;                                            /* stack used */

    while( fill == *p++ ) sfree += 4;                   /* count free bytes */

    sused = ssize - sfree;                                    /* stack used */

    cmdPut4( ssize );
    cmdPut4( sused );
    cmdPut4( sfree );

    return PASS;
}

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

static BOOL cmdApp_Power_wr( void )                               /* 0x0200 */
{
    UIREP uiRep;

    uiRep.key   = KCODE_PAD_POWER;                      /* keypad power key */
    uiRep.mouse = 0;
    uiRep.mouse_x = 0;
    uiRep.mouse_y = 0;

    guiKeycode( &uiRep, TRUE );

    return TRUE;
}

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

static BOOL cmdApp_Prior_wr( void )                               /* 0x0208 */
{
    TASKINFO_STRUCT info;                            /* task info structure */
    int08           index    = cmdGet1( int08 );              /* task index */
    uint08          priority = cmdGet1( uint08 );      /* new task priority */

    if( 0 == info.taskID )                   /* if task is not instantiated */
        return TRUE;

    if( !info_getTaskInfo( index, &info ))              /* if invalid index */
        return FALSE;

    RTA_TaskSetPriority( (uint32)info.taskID, (uint32)priority );

    return TRUE;
}

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

static BOOL cmdApp_State_rd( void )                               /* 0x0207 */
{
    cmdPutK1( sysmon_state());

    return TRUE;
}

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

static BOOL cmdApp_Resrce_rd( void )                              /* 0x0203 */
{
    RTA_Resources highCount;                            /* high water marks */
    RTA_Resources currCount;                               /* current usage */

    RTA_GetResourceHighWaterMarks ( &highCount );
    RTA_GetResourceCount( &currCount );

    cmdPutK1( highCount.Tasks    );
    cmdPutK1( highCount.Evts     );
    cmdPutK1( highCount.GrpEvts  );
    cmdPutK1( highCount.Mbxs     );
    cmdPutK1( highCount.MemPools );
    cmdPutK1( highCount.Sems     );

    cmdPutK1( currCount.Tasks    );
    cmdPutK1( currCount.Evts     );
    cmdPutK1( currCount.GrpEvts  );
    cmdPutK1( currCount.Mbxs     );
    cmdPutK1( currCount.MemPools );
    cmdPutK1( currCount.Sems     );

    return TRUE;
}

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

static BOOL cmdApp_Susp_wr( void )                                /* 0x0209 */
{
    TASKINFO_STRUCT info;                            /* task info structure */
    int08           index  = cmdGet1( int08 );                /* task index */
    uint08          tState = cmdGet1( int08 );            /* new task state */

    if( !info_getTaskInfo( index, &info ))              /* if invalid index */
        return FALSE;

    if( 0 == info.taskID )                   /* if task is not instantiated */
        return TRUE;

    if( tState )
        RTA_TaskResume( info.taskID );
    else
        RTA_TaskSuspend( info.taskID );

    return TRUE;
}

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

static BOOL cmdApp_TIDInfo_rd( void )                             /* 0x020e */
{
    uint32 taskID = cmdGet4( uint32 );                           /* task ID */
    uint32 priority;                                            /* priority */
    uint32 unuStack;                                        /* unused stack */

    if( RTA_SUCCESS != RTA_TaskGetPriority( taskID, &priority ))
        return FALSE;

    if( RTA_SUCCESS != RTA_TaskGetUnusedStack( taskID, &unuStack ))
        return FALSE;

    cmdPut4( priority );
    cmdPut4( unuStack );

    return TRUE;
}

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

static BOOL cmdApp_TIDPrio_wr( void )                             /* 0x020f */
{
    uint32 taskID   = cmdGet4( uint32 );                         /* task ID */
    uint32 priority = cmdGet4( uint32 );                        /* priority */

    return RTA_SUCCESS == RTA_TaskSetPriority( taskID, priority );
}

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

static BOOL cmdApp_TIDSusp_wr( void )                             /* 0x0210 */
{
    uint32 taskID = cmdGet4( uint32 );                           /* task ID */
    uint08 tState = cmdGet1( int08 );                     /* new task state */
    int08  cc;                                           /* completion code */

    if( tState )
        cc = RTA_TaskResume( taskID );
    else
        cc = RTA_TaskSuspend( taskID );

    return RTA_SUCCESS == cc;
}

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

static BOOL cmdApp_TInfo_wr( void )                               /* 0x0201 */
{
    info_showAllTaskInfo();
    return TRUE;
}

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

static BOOL cmdApp_TStat_rd( void )                               /* 0x0206 */
{
    TASKINFO_STRUCT info;                            /* task info structure */
    int08           index = cmdGet1( int08 );                 /* task index */

    if( !info_getTaskInfo( index, &info ))              /* if invalid index */
        return FALSE;

    cmdPut4( info.taskID );
    cmdPut1( info.priority );
    cmdPut2( info.stackSize );
    cmdPut2( info.stackUnused );
    cmdPut2( info.stackUsed );

    return TRUE;
}

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

static BOOL cmdApp_Versions_rd( void )                            /* 0x0205 */
{
    struct layoutversionstruct verStruct;
    DDP_GetRevInfo revInfo;

    cmdPutK4( SW_VER_APPLICATION );

    if( !EE_GETVAR( Version, verStruct ))    /* app cfg version from EEPROM */
        return FALSE;

    cmdPut1( verStruct.Subminor );
    cmdPutK1( 0 );
    cmdPut1( verStruct.Minor );
    cmdPut1( verStruct.Major );

    cmdPutK4( API_GetVersion().API_Byte );

    revInfo.SeqAsicConfigNum = CONFIGNO_SEQ;
    revInfo.SwAsicConfigNum  = CONFIGNO_SWASIC;

    DDP_GetAsicConfigRevision( &revInfo );

    cmdPut4( revInfo.SwConfigRevision );
    cmdPut4( revInfo.SeqConfigRevision );

    return TRUE;
}

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

static BOOL cmdApp_CalADC_wr( void )             /* 0x0235 */
{
    return adccontrol_Calibrate();
}

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

int08 SEQ_EnableManualClockDrop( BOOL state );       /* undeclared function */
void  SEQ_EnableManualSequenceSelection( BOOL state );   /* undeclared func */
int08 SEQ_SetManualVector( uint08 seqVector);        /* undeclared function */

static BOOL   isCWClockDrop = FALSE;        /* no API function to read this */
static BOOL   isManSeqSel  = FALSE;               /* not available from API */
static uint08 manSeqVector = 0;                   /* not available from API */

/* ------------------------------------------------------------------------ */

static BOOL cmdCW_ClkDrop_rd( void )                              /* 0x0302 */
{
    isCWClockDrop = cmdGet1( BOOL );

    SEQ_EnableManualClockDrop( isCWClockDrop );
    cmdPut1( isCWClockDrop );

    return TRUE;
}

/* ------------------------------------------------------------------------ */

static BOOL cmdCW_ManSeq_rd( void )                               /* 0x030c */
{
    isManSeqSel  = cmdGet1( BOOL );                        /* manual enable */
    manSeqVector = cmdGet1( uint08 );                      /* vector number */

    SEQ_SetManualVector( manSeqVector );
    SEQ_EnableManualSequenceSelection( isManSeqSel );

    cmdPut1( isManSeqSel );
    cmdPut1( manSeqVector );

    return TRUE;
}

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

static BOOL cmdCW_Coast_rd( void )                                /* 0x0301 */
{
    BOOL flag = cmdGet1( BOOL );

    CW_SetCoast( flag );
    cmdPut1( flag );

    return TRUE;
}

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

static BOOL cmdCW_Debug_rd( void )                                /* 0x0303 */
{
    int08 cc = CW_SetDebugMode( cmdGet1( BOOL ));

    cmdPutK1( CW_GetDebugMode());

    return PASS == cc;
}

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

static BOOL cmdCW_ExpVSync_rd( void )                             /* 0x0306 */
{
    uint16 expVSync;

    CW_GetExpectedVsync( &expVSync );
    cmdPut2( expVSync );

    return TRUE;
}

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

static BOOL cmdCW_ExpVSync_wr( void )                             /* 0x0306 */
{
    CW_SetExpectedVsync( cmdGet2( uint16 ));

    return TRUE;
}

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

static BOOL cmdCW_GetSeqInfo_rd( void )                           /* 0x030a */
{
    CW_MODES spinFactor =  cmdGet1( CW_MODES );   /* factor being requested */
    uint08   numSeqModes;      /* number of modes for requested spin factor */
    uint08   seqMode;                              /* current sequence mode */

    if( FAIL == CW_GetAvailableSequenceModes( spinFactor, &numSeqModes ))
        return FALSE;

    seqMode = CW_GetSeqMode();

    cmdPut1( numSeqModes );
    cmdPut1( seqMode );

    return TRUE;
}

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

static BOOL cmdCW_IndexDelay_rd( void )                           /* 0x0305 */
{
    uint16 indexDelay;

    CW_GetIndexDelay( &indexDelay );
    cmdPut2( indexDelay );

    return TRUE;
}

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

static BOOL cmdCW_IndexDelay_wr( void )                           /* 0x0305 */
{
    uint16 indexDelay = cmdGet2( uint16 );

    CW_SetIndexDelay( indexDelay );
    EE_PUTVAR( UserSystem.CW_Calibration, indexDelay );

    return TRUE;
}

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

#define SEQ_CLOCKFREQ   16666667


static BOOL cmdCW_IndexParm_rd( void )                            /* 0x0307 */
{
    int32  ixp32 = CW_GetIndexPeriod();
    uint32 u32   = SEQ_CLOCKFREQ / ixp32;

    cmdPut4( ixp32 );
    cmdPut4( u32 );

    return TRUE;
}

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

static BOOL cmdCW_MultMode_rd( void )                             /* 0x0308 */
{
    cmdPutK1( CW_GetMode());

    return TRUE;
}

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

static BOOL cmdCW_MultMode_wr( void )                             /* 0x0308 */
{

    CW_SetMode( cmdGet1( CW_MODES ));

    return TRUE;
}

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

static BOOL cmdCW_OpStat_rd( void )                               /* 0x0304 */
{
    cmdPutK1( CW_GetSpinning());
    cmdPutK1( CW_IsCoastEnabled());
    cmdPut1 ( isCWClockDrop );
    cmdPutK1( CW_GetDebugMode());
    cmdPut1 ( isManSeqSel );
    cmdPut1 ( manSeqVector );

    return TRUE;
}

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

static BOOL cmdCW_SetSeqMode_wr( void )                           /* 0x0309 */
{
    CW_MODES spinFactor = cmdGet1( CW_MODES );               /* spin factor */
    uint08   seqMode    = cmdGet1( uint08 );                        /* mode */
    uint08   waveformIdx;
    int08    retval;

    retval = FAIL;
    if( gpConfiguration->Illum.UartBallastEnable && LMP_BLST_IsCommunicationEnabled() )
    {
        if( FAIL != SEQ_GetWaveformIndex( (CW_MODES)spinFactor, 
                                          seqMode,
                                          LMP_BLST_GetManufacturerID(),
                                          &waveformIdx ) )
        {                       
            if( LMP_BLST_SetWaveform( waveformIdx ) == PASS )
                retval = CW_SetCWandSeqMode((CW_MODES)spinFactor, seqMode);
        }
    }
    else
    {
        retval = CW_SetCWandSeqMode((CW_MODES)spinFactor, seqMode);
    }