path: root/src/occ/pss/test/apsstest.c

/******************************************************************************
// @file apsstest.c
// @brief OCC APSS TEST
*/
/******************************************************************************
 *
 *       @page ChangeLogs Change Logs
 *       @section apsstest.c APSSTEST.C
 *       @verbatim
 *
 *   Flag    Def/Fea    Userid    Date        Description
 *   ------- ---------- --------  ----------  ----------------------------------
 *
 *   @rc003             rickylie  02/03/2012  Verify & Clean Up OCC Headers & Comments
 *
 *  @endverbatim
 *
 *///*************************************************************************/

//*************************************************************************
// Includes
//*************************************************************************
#include "ssx.h"
#include "ssx_io.h"
#include "simics_stdio.h"
//#include <trac_interface.h>
#include <thread.h>
#include <threadSch.h>
#include <errl.h>
#include <apss.h>

//*************************************************************************
// Externs
//*************************************************************************
//@pb000a - added
//extern void __ssx_boot;

//*************************************************************************
// Image Header
//*************************************************************************
//@pb000a - added
//@dw000c - call with Applet ID arg (in case it gets uncommented & reused).
//IMAGE_HEADER (G_mainAppImageHdr,__ssx_boot,MAIN_APP_ID,OCC_APLT_TEST);

//*************************************************************************
// Macros
//*************************************************************************

//*************************************************************************
// Defines/Enums
//*************************************************************************
/// Period in which to run #timer_routine
#define TIMER_INTERVAL (SsxInterval) SSX_MICROSECONDS(5000) 
//@pb000d - deleted TPMD_code_header as not used
SsxSemaphore prcd_sem;

//*************************************************************************
// Structures
//*************************************************************************

//*************************************************************************
// Globals
//*************************************************************************
int g_j = 0;
int g_k = 0;

SimicsStdio simics_stdout;
SimicsStdio simics_stderr;

uint8_t noncritical_stack[NONCRITICAL_STACK_SIZE];
uint8_t critical_stack[CRITICAL_STACK_SIZE];

SsxTimer G_test_timer;

//*************************************************************************
// Function Prototypes
//*************************************************************************
extern void timer_routine(void *private);
extern void rtloop_ocb_init(void);

//*************************************************************************
// Functions
//*************************************************************************

// Function Specification
//
// Name:  pgp_validation_ssx_main_hook
//
// Description:
//
// Flow:              FN=None
//
// End Function Specification
void pgp_validation_ssx_main_hook(void)
{

}

// Function Specification
//
// Name:  Cmd_Hndl_thread_routine
//
// Description:
//
// Flow:              FN=Cmd_Hndl_thread_routine
//
// End Function Specification
//TODO placeholder
void Cmd_Hndl_thread_routine(void *arg)
{
     do
    {
        int x=0;
        for(x=0; x < 1000; x++)
        {

        }
        //printf("Thread A running");
    }while(1);

}

// Function Specification
//
// Name:  App_thread_routine
//
// Description:
//
// Flow:              FN=None
//
// End Function Specification
void App_thread_routine(void *arg)
{
    int z=0;
     do
    {
        int x=0;
        for(x=0; x < 10000; x++)
        {
            z++;
        }
        //printf("Thread A running");
    }while(1);

}

// Function Specification
//
// Name:  Thermal_Monitor_thread_routine
//
// Description:
//
// Flow:              FN=None
//
// End Function Specification
void Thermal_Monitor_thread_routine(void *arg)
{
       int z=0;
     do
    {
        int x=0;
        for(x=0; x < 10000; x++)
        {
            z++;
        }
        //printf("Thread A running");
    }while(1);
 
}

// Function Specification
//
// Name:  Hlth_Monitor_thread_routine
//
// Description:
//
// Flow:              FN=None
//
// End Function Specification
void Hlth_Monitor_thread_routine(void *arg)
{
       int z=0;
     do
    {
        int x=0;
        for(x=0; x < 10000; x++)
        {
            z++;
        }
        //printf("Thread A running");
    }while(1);

}

// Function Specification
//
// Name:  FFDC_thread_routine
//
// Description:
//
// Flow:              FN=None
//
// End Function Specification
void FFDC_thread_routine(void *arg)
{
       int z=0;
     do
    {
        int x=0;
        for(x=0; x < 10000; x++)
        {
            z++;
        }
        //printf("Thread A running");
    }while(1);

}

/** PRCD Thread
 *
 * This thread loops as the highest priority thread, where it currently 
 * just 
 * 
 */
// Function Specification
//
// Name:  prcd_thread_routine
//
// Description:
//
// Flow:              FN=None
//
// End Function Specification
void prcd_thread_routine(void *private)
{
  while(1)
  {
    // Just sit here until this semaphore is posted, which will never happen.  
    ssx_semaphore_pend(&prcd_sem, SSX_WAIT_FOREVER);

    // Only trace the first XX times that this function loops
    if(g_j < 20)
    {
      g_k = 0;
      g_j++;
      
    }
  }
}


// Function Specification
//
// Name:  apss_test_pwr_meas
//
// Description: Request the full power measurement data in a single function call for TESTING ONLY
//
// Flow:              FN=None
//
// End Function Specification
extern PoreEntryPoint pore_test; // Sleep for specified amount of time...
void apss_test_pwr_meas(void)
{
  task_apss_start_pwr_meas();

  // Schedule GPE program to delay to ensure the data is available... (BLOCKING)
  // bad: 48, good: 56
  PoreFlex test_request;
  DEBUG_PRINTF(("apss_test_pwr_meas: delay...\n"));
  pore_flex_create(&test_request,
                   &pore_gpe0_queue,
                   (void*)pore_test,         // entry_point
                   (uint32_t)56,             // entry_point argument
                   NULL,                     // callback,
                   NULL,                     // callback arg
                   ASYNC_REQUEST_BLOCKING);  // options
  pore_flex_schedule(&test_request);
  DEBUG_PRINTF(("apss_test_pwr_meas: delay complete\n"));

  task_apss_continue_pwr_meas();

  task_apss_complete_pwr_meas();

} // end apss_test_pwr_meas()




/** Main Thread
 *
 * This thread currently just loops as the lowest priority thread, handling
 * the lowest priority tasks.
 * 
 */
// Function Specification
//
// Name: main_thread_routine
//
// Description: 
//
// Flow:              FN=None
// 
// End Function Specification
void main_thread_routine(void *private)
{
  // Start the critical 250uS timer
  ssx_timer_schedule(&timer, 1, TIMER_INTERVAL);

  // Initialize APSS // @cc000a
  errlHndl_t l_errl = apss_initialize();
  if (l_errl)
  {
    // init failed, attempt one more time before giving up
    printf("ERROR: apss_initialize failed! (retrying)\n");
    setErrlSevToInfo(l_errl);
    commitErrl(&l_errl);

    l_errl = apss_initialize();
    if (l_errl)
    {
      printf("ERROR: apss_initialize failed again! (OCC will be reset)");
      commitErrl(&l_errl);

      // $TODO - Request Reset
    }
  }

  // Attempt to retrieve 3 sets of measurements
  printf("Attempting to gather power measurements\n");
  apss_test_pwr_meas();
  apss_test_pwr_meas();
  apss_test_pwr_meas();

  while(1)
  {
    // Only trace the first XX times that this function loops
    if(g_k < 3)
    {
      g_k++;

      // TRACE: Main Thread
    }


    // Sleep for 1000 before we run the loop again
    ssx_sleep_absolute(1000);
  }
}

// Function Specification
//
// Name: dump_thread_info
//
// Description: 
//
// Flow:              FN=None
// 
// End Function Specification
void dump_thread_info(void *arg)
{
    
    printf("dumping thread info--------------------------\n");
    int l_rc = 0;
    SsxThreadState l_state = 0;
    SsxThreadPriority l_pri = 0;
    int l_runnable=0;
    int x=0;
    for(x=0; x < THREADS_TO_SCHEDULE; x++)
    {
        l_rc = ssx_thread_info_get(G_scheduledThreads[x],
                                    &l_state,
                                    &l_pri,
                                    &l_runnable);

        printf("Thread %p: State %x priority %x runnable %x rc %x Global index %x\n",G_scheduledThreads[x],
                                                           l_state,
                                                            l_pri,
                                                            l_runnable,
                                                            l_rc,
                                                            G_threadSchedulerIndex);        

    }

}

/** Entry point for OCC execution
 *
 * main() currently initalizes our trace buffer along with creating threads
 * and timers for execution.  Note that once main runs ssx_start_threads, we
 * never return as the SSX kernel takes over.
 * 
 */
// Function Specification
//
// Name: main
//
// Description: 
//
// Flow:              FN=None
// 
// End Function Specification
int main(int argc, char **argv)
{
    //locals
    errlHndl_t  l_errl = NULL;

    // Initialize Trace Buffers immediately, so they can be used 
    // from this point on.
    //TRAC_init_buffers();

    // Initialize stdout so we can do printf from within simics env
    simics_stdout_create(&simics_stdout);
    simics_stderr_create(&simics_stderr);
    stdout = (FILE *)(&simics_stdout);
    stderr = (FILE *)(&simics_stderr);

    //@pb000a - added
    printf("Inside apsstest main\n");

    // Initialize SSX Stacks (note that this also reinitializes the time base to 0)
    ssx_initialize((SsxAddress)noncritical_stack, NONCRITICAL_STACK_SIZE,
		   (SsxAddress)critical_stack, CRITICAL_STACK_SIZE,
		   0);

    // Create Timers
    //ssx_timer_create(&timer, timer_routine, 0);

    // Create Global Semaphores
    ssx_semaphore_create(&prcd_sem, 0, 13);

    // Create Threads
    ssx_thread_create(&main_thread, 
		      main_thread_routine, 
		      (void *)0,
		      (SsxAddress)main_thread_stack,
		      THREAD_STACK_SIZE,
		      1);

    // Create Threads
    ssx_thread_create(&prcd_thread, 
		      prcd_thread_routine, 
		      (void *)0,
		      (SsxAddress)prcd_thread_stack,
		      THREAD_STACK_SIZE,
		      0);

    // Make Threads runnable
    ssx_thread_resume(&main_thread);
    ssx_thread_resume(&prcd_thread);

    //Initialize the thread scheduler
    l_errl = initThreadScheduler();

    if( l_errl )
    {
        // Trace and commit error

        // TODO add trace

        // commit log 
        // NOTE: log should be deleted by reader mechanism
        commitErrl( &l_errl ); 
    }

    // Initialize Realtime Loop Timer Interrupt
    //rtloop_ocb_init();

    //kick off timer
    ssx_timer_create(&G_test_timer, dump_thread_info, 0);
    ssx_timer_schedule(&G_test_timer, 1, 500000000);


    // Enter SSX Kernel
    ssx_start_threads();

    return 0;
}