FreeCalypso > hg > freecalypso-sw
view gsm-fw/riviera/rvt/ti_profiler/ti_profiler.c @ 266:cb833ff54d88
rvinterf: CLI2RVI_RESET_PACKET_RX command implemented
| author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
|---|---|
| date | Thu, 06 Feb 2014 01:10:13 +0000 |
| parents | afceeeb2cba1 |
| children |
line wrap: on
line source
/************************************************************************************ * ti_profiler.c : contains ti profiling module function * * * * * * Author: Philippe Martinez * * * * version: 1.0 * * * * Date: 07/16/2001 * * (C) Copyright 2001 by Texas Instruments Incorporated, All Rights Reserved * ************************************************************************************/ #include "config/debug.cfg" #if (TI_PROFILER == 1) || (TI_NUC_MONITOR == 1) /*-------------------------------------------------------*/ /* include files */ /*-------------------------------------------------------*/ #include <string.h> #include "main/sys_types.h" #include "nucleus.h" #include "qu_defs.h" #include "tc_defs.h" #include "rvf/rvf_api.h" #include "rvt/rvt_gen.h" #include "rvt/rvt_def_i.h" #include "mem.h" #include "iq.h" #include "rvt/ti_profiler/ti_profiler.h" #include "timer.h" #include "inth.h" /*-------------------------------------------------------*/ /* Global instances */ /*-------------------------------------------------------*/ // task variable instance T_RVF_MB_ID prof_mb_id; T_RVT_USER_ID prof_trace_id; T_RVF_ADDR_ID prof_addr_id; /*-------------------------------------------------------*/ /* internal prototypes */ /*-------------------------------------------------------*/ void ti_prf_init( void ); T_RV_RET ti_prf_core(void); void ti_profiler_trace_rx_callback( T_RVT_BUFFER trace_msg, UINT16 trace_msg_size ); #if (L1_TRACER == 1) extern void SendTraces(char *s); #endif #endif #if (TI_PROFILER == 1) /*-------------------------------------------------------*/ /* Global instances */ /*-------------------------------------------------------*/ // Internal state of profiling T_PROFILER_STATE profiler_state = PROFILER_STOPPED; // Buffer that contains the Profiling samples. // Structure (SYS_UWORD32 buffer): // C_OP_CODE_TDMA_BEGIN // PC Samples ...... // C_OP_CODE_TDMA_END // ...... // C_OP_CODE_TDMA_BEGIN // PC Samples ...... // C_OP_CODE_TDMA_END SYS_UWORD32 pr_buffer[PR_BUFFER_SIZE]; // pointer on pr_buffer SYS_UWORD32 pos_pr_buffer = 0; SYS_UWORD32 pr_buffer_length = PR_BUFFER_SIZE; T_PROFILER_BUFFER_STATE ti_profiler_buffer_state = LOGGING; T_PROFILER_HANDLER ti_profiler_active = NOT_ACTIVE; // hisr variable instance NU_HISR ti_profiler_cb; SYS_UWORD8 ti_profiler_hisr_stack[500]; // Event variables // NO_SLEEP_EVENT SYS_UWORD32 ti_profiler_nb_sleep_call = 0; SYS_UWORD32 ti_profiler_nb_sleep_counter_ref = 0; T_PROFILER_EVENTS ti_profiler_event_state = NO_EVENT; /*-------------------------------------------------------*/ /* internal prototypes */ /*-------------------------------------------------------*/ void ti_profiler_start( BOOL enable ); void ti_profiler_handler( SYS_UWORD32 programCounter ); void ti_profiler_freeze( void ); void ti_profiler_unfreeze( void ); void ti_profiler_tdma_action( void ); void ti_profiler_init_profiler_module( void ); void ti_profiler_hisr( void ); void l1_profiler_open( void ); void l1_profiler_close( void ); void l1_profiler_flush( void ); /*-------------------------------------------------------*/ /* external prototypes */ /*-------------------------------------------------------*/ SYS_UWORD32 l1_get_next_absolute_fn( void ); /*-------------------------------------------------------*/ /* ti_profiler_start() */ /*-------------------------------------------------------*/ /* */ /* Description: Start or Stop the timer */ /* ------------ */ /* parameters */ /* enable = 1 => Unmask + start the timer 1 */ /* Initialize buffer. */ /* enable = 0 => mask + stop the timer 1 */ /* Close Buffer. */ /*-------------------------------------------------------*/ void ti_profiler_start( BOOL enable ) { if( enable ) { TM_EnableTimer( PR_TIMER_NUM ); IQ_Unmask( IQ_TIM1 ); IQ_InitLevel( IQ_TIM1, FIQ, 0, 1 ); TM_ResetTimer( PR_TIMER_NUM, PR_TIMER_RESET_VALUE, 1, 0 ); TM_StartTimer( PR_TIMER_NUM ); } else { IQ_Mask( IQ_TIM1 ); IQ_InitLevel( IQ_TIM1, 0, 0, 1 ); TM_StopTimer( PR_TIMER_NUM ); } } // ti_profiler_start /*-------------------------------------------------------*/ /* ti_profiler_handler() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* Store the Program counter in a static buffer */ /* If buffer is full, deactivate the profiling and */ /* activate the ti_profiler_hisr(); */ /*-------------------------------------------------------*/ void ti_profiler_handler( SYS_UWORD32 programCounter ) { // Store the program Counter in log buffer pr_buffer[ pos_pr_buffer++ ] = programCounter; } // ti_profiler_handler /*-------------------------------------------------------*/ /* ti_profiler_freeze() ti_profiler_unfreeze() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* Function to suspend/resume the profiling */ /*-------------------------------------------------------*/ void ti_profiler_freeze() { TM_StopTimer( PR_TIMER_NUM ); } // ti_profiler_freeze void ti_profiler_unfreeze() { TM_StartTimer( PR_TIMER_NUM ); } // ti_profiler_unfreeze /*-------------------------------------------------------*/ /* ti_profiler_init_profiler_module() */ /*-------------------------------------------------------*/ /* */ /* Description: Initialize profiling task and hisr */ /* ------------ */ /* Note : this init will changed */ /* */ /*-------------------------------------------------------*/ void ti_profiler_init_profiler_module( void ) { // Fill the entire stack with the pattern 0xFE memset( ti_profiler_hisr_stack, 0xFE, sizeof( ti_profiler_hisr_stack ) ); // Create the HISR which is called from power interrupts NU_Create_HISR( &ti_profiler_cb, "TI PROF", ti_profiler_hisr, 2, ti_profiler_hisr_stack, sizeof( ti_profiler_hisr_stack ) ); // lowest prty } // ti_profiler_init_profiler_module /*-------------------------------------------------------*/ /* ti_profiler_hisr() High Interrupt service routine */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* This hisr stands as relay for the profiler LISR. */ /* It sends a message to the profiler task to start the */ /* buffer extraction. */ /*-------------------------------------------------------*/ void ti_profiler_hisr( void ) { T_PROFILER_MSG * msg; //send a message to the ti profiler task if( rvf_get_buf( prof_mb_id, sizeof( T_PROFILER_MSG ), ( T_RVF_BUFFER** ) &msg ) == RVF_GREEN ) { msg->msg_id = TI_PROFILER_OUTPUT_BUFFER; rvf_send_msg( prof_addr_id, msg ); } } // ti_profiler_hisr /*-------------------------------------------------------*/ /* ti_profiler_tdma_action() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* */ /* */ /*-------------------------------------------------------*/ void ti_profiler_tdma_action(void) { switch( profiler_state ) { case PROFILER_RUNNING : { SYS_UWORD8 output_buffer_condition = 0; // suspend the profiler //ti_profiler_freeze(); ti_profiler_start( FALSE ); if( ti_profiler_event_state == NO_SLEEP_EVENT ) { // Need to reach the event to output the buffer if( ti_profiler_nb_sleep_call++ >= ti_profiler_nb_sleep_counter_ref ) { output_buffer_condition = 1; ti_profiler_nb_sleep_call = 0; // ti_profiler_buffer_state = FLUSH; } // End if } else { output_buffer_condition = 1; } // End if // Check if buffer threshold reached if( pos_pr_buffer >= PR_BUFFER_THRESHOLD ) { // change the status of the buffer ti_profiler_buffer_state = LOGGING; // Insert the End of Buffer OP code pr_buffer[ pos_pr_buffer++ ] = C_OP_CODE_END_BUFFER; // Specifie used length of buffer in SYS_UWORD32 pr_buffer_length = pos_pr_buffer; if( output_buffer_condition == 1 ) { // Change profiler state to freezed profiler_state = PROFILER_FREEZED; // Activate the hisr in order to start the buffer output NU_Activate_HISR( &ti_profiler_cb ); } else { // insert TDMA begin OP Code pr_buffer[ 0 ] = C_OP_CODE_BEGIN_BUFFER; pr_buffer[ 1 ] = C_OP_CODE_TDMA_BEGIN; // Insert current fn pr_buffer[ 2 ] = l1_get_next_absolute_fn(); // initialize buffer pointer pos_pr_buffer = 3; ti_profiler_start( TRUE ); } // End if } else { // insert OP Code begining of TDMA pr_buffer[pos_pr_buffer++] = C_OP_CODE_TDMA_BEGIN; // Insert current fn pr_buffer[pos_pr_buffer++] = l1_get_next_absolute_fn(); // resume profiler //ti_profiler_unfreeze(); ti_profiler_start( TRUE ); } // End if break; } // PROFILER_RUNNING case PROFILER_TO_BE_RAN : { // insert TDMA begin OP Code pr_buffer[ 0 ] = C_OP_CODE_BEGIN_BUFFER; pr_buffer[ 1 ] = C_OP_CODE_TDMA_BEGIN; // Insert current fn pr_buffer[ 2 ] = l1_get_next_absolute_fn(); // initialize buffer pointer pos_pr_buffer = 3; // start the profiler profiler_state = PROFILER_RUNNING; // start the profiler ti_profiler_start( TRUE ); break; } // PROFILER_TO_BE_RAN case PROFILER_TO_BE_STOPPED : { // stop the profiler ti_profiler_start( FALSE ); // Insert End Buffer Op Code. pr_buffer[pos_pr_buffer++] = C_OP_CODE_END_BUFFER; profiler_state = PROFILER_STOPPED; // Activate the hisr in order to start the buffer output NU_Activate_HISR( &ti_profiler_cb ); // Returns to inactive ti_profiler_active = NOT_ACTIVE; break; } // PROFILER_TO_BE_STOPPED case PROFILER_TO_BE_UNFREEZED : { // Init profiling buffer // insert TDMA begin OP Code pr_buffer[ 0 ] = C_OP_CODE_BEGIN_BUFFER; pr_buffer[ 1 ] = C_OP_CODE_TDMA_BEGIN; // Insert current fn pr_buffer[ 2 ] = l1_get_next_absolute_fn(); // initialize buffer pointer pos_pr_buffer = 3; // Insert the TDMA Start Op Code profiler_state = PROFILER_RUNNING; // resume profiler //ti_profiler_unfreeze(); ti_profiler_start( TRUE ); break; } // PROFILER_TO_BE_UNFREEZED default : { // nothing to do break; } // default } // End switch } // ti_profiler_tdma_action /*-------------------------------------------------------*/ /* ti_profiler_open() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* Start the profiling on the next TDMA occurence */ /* */ /*-------------------------------------------------------*/ void ti_profiler_open( void ) { if( ti_profiler_active == NOT_ACTIVE ) { } // End if } // ti_profiler_open /*-------------------------------------------------------*/ /* ti_profiler_close() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* Stop the profiling on the next TDMA occurence */ /* */ /*-------------------------------------------------------*/ void ti_profiler_close( void ) { if( ti_profiler_active == NOT_ACTIVE ) { l1_profiler_close(); } // End if } // ti_profiler_close /*-------------------------------------------------------*/ /* l1_profiler_flush() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* freeze the profiling and flush the current profiling */ /* buffer. Profiling will restart after output of the */ /* buffer. */ /*-------------------------------------------------------*/ void ti_profiler_flush( void ) { if( ti_profiler_active == NOT_ACTIVE ) { l1_profiler_flush(); } // End if } // ti_profiler_flush // To be used only TI internal modules /*-------------------------------------------------------*/ /* ti_profiler_open() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* Start the profiling on the next TDMA occurence */ /* */ /*-------------------------------------------------------*/ void l1_profiler_open( void ) { if( ti_profiler_active != NOT_ACTIVE ) { // stop profiler timer ti_profiler_start( FALSE ); // go to idle profiler_state = PROFILER_STOPPED; } // Endif // insert TDMA begin OP Code pr_buffer[ 0 ] = C_OP_CODE_BEGIN_BUFFER; pr_buffer[ 1 ] = C_OP_CODE_TDMA_BEGIN; // Insert current fn pr_buffer[ 2 ] = l1_get_next_absolute_fn(); // initialize buffer pointer pos_pr_buffer = 3; // change state of profiler profiler_state = PROFILER_TO_BE_RAN; } // ti_profiler_open /*-------------------------------------------------------*/ /* ti_profiler_close() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* Stop the profiling on the next TDMA occurence */ /* */ /*-------------------------------------------------------*/ void l1_profiler_close( void ) { // stop the profiler ti_profiler_start( FALSE ); // Insert TDMA_BOUNDARY Op Code. pr_buffer[pos_pr_buffer++] = C_OP_CODE_END_BUFFER; profiler_state = PROFILER_STOPPED; // Activate the hisr in order to start the buffer output NU_Activate_HISR( &ti_profiler_cb ); } // ti_profiler_close /*-------------------------------------------------------*/ /* l1_profiler_flush() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* freeze the profiling and flush the current profiling */ /* buffer. Profiling will restart after output of the */ /* buffer. */ /*-------------------------------------------------------*/ void l1_profiler_flush( void ) { ti_profiler_buffer_state = FLUSH; } // ti_profiler_flush #endif // PROFILER #if (TI_NUC_MONITOR == 1) /*-------------------------------------------------------*/ /* Global instances */ /*-------------------------------------------------------*/ // management of monitoring buffer // Internal state of nucleus monitoring T_NUC_MONITOR_STATE ti_nuc_monitor_state = NUC_MONITOR_STOPPED; // pointers on current buffer SYS_UWORD8* ti_nuc_monitor_current_buffer = NULL; SYS_UWORD8 ti_nuc_monitor_current_position = 0; // Create static doubled bufferised LISR buffers (max 10 LISR by TDMA) SYS_UWORD8 ti_nuc_monitor_LISR_Buffer[C_NUC_LISR_BUF_PG_NB][C_NUC_MAX_LISR]; SYS_UWORD8 ti_nuc_monitor_LISR_current_page = 0; SYS_UWORD8 ti_nuc_monitor_LISR_current_pos = 0; SYS_UWORD8 ti_nuc_monitor_LISR_next_page = 0; SYS_UWORD8 ti_nuc_monitor_LISR_next_pos = 0; // Create static doubled bufferised LISR buffers (max 10 LISR by TDMA) SYS_UWORD8 ti_nuc_monitor_Thread_Buffer[C_NUC_THREAD_BUF_PG_NB][C_NUC_MAX_THREAD]; SYS_UWORD8 ti_nuc_monitor_Thread_current_page = 0; SYS_UWORD8 ti_nuc_monitor_Thread_current_pos = 0; SYS_UWORD8 ti_nuc_monitor_Thread_next_page = 0; SYS_UWORD8 ti_nuc_monitor_Thread_next_pos = 0; // hisr variable instance NU_HISR ti_nuc_monitor_cb; SYS_UWORD8 ti_nuc_monitor_hisr_stack[ 500 ]; // Array that store the ID <-> pointer of the Nucleus Components //SYS_UWORD32* ti_nuc_monitor_thread_id[ NUC_MONITOR_MAX_ID ]; SYS_UWORD32 ti_nuc_monitor_thread_id[ NUC_MONITOR_MAX_ID ]; SYS_UWORD8 ti_nuc_monitor_thread_pos = 0; //SYS_UWORD32* ti_nuc_monitor_queue_id[ NUC_MONITOR_MAX_ID ]; SYS_UWORD32 ti_nuc_monitor_queue_id[ NUC_MONITOR_MAX_ID ]; SYS_UWORD8 ti_nuc_monitor_queue_pos = 0; // LISR IRQ value SYS_UWORD8 IRQ_value; // Indicates the nucleus monitor part to switch Thread buffer page SYS_UWORD8 ti_nuc_monitor_change_thread_page = 0; // Indicates that the IDLE mode has been reached // (to be reset in LISR or Thread monitor function) SYS_UWORD8 ti_nuc_monitor_idle_reached = 0; // debug SYS_UWORD32 ti_nuc_monitor_lost_messages = 0; /*-------------------------------------------------------*/ /* internal prototypes */ /*-------------------------------------------------------*/ void ti_nuc_monitor_tdma_action( void ); void ti_nuc_monitor_init_module( void ); void ti_nuc_monitor_hisr( void ); void ti_nuc_monitor_check_ID_buffer( void ); void ti_nuc_monitor_LISR_log( void ); void ti_nuc_monitor_LISR_log_end( void ); void ti_nuc_monitor_Thread_log( void ); void ti_nuc_monitor_Queue_log( SYS_UWORD32* queue_pointer, SYS_UWORD8 status, SYS_UWORD8 Direction ); void ti_nuc_monitor_sleep( void ); T_RVT_RET ti_nuc_monitor_mem_alloc(T_RVT_USER_ID user_id, T_RVT_MSG_LG buffer_lenght, T_RVT_BUFFER * buff); /*-------------------------------------------------------*/ /* external prototypes */ /*-------------------------------------------------------*/ extern SYS_UWORD16 l1_get_actual_fn_mod42432( void ); extern SYS_UWORD32* TCD_Current_Thread; /*-------------------------------------------------------*/ /* ti_nuc_monitor_init_module() */ /*-------------------------------------------------------*/ /* */ /* Description: Initialize hisr */ /* ------------ */ /* Create hisr and initialize thread/queue structures. */ /* */ /*-------------------------------------------------------*/ void ti_nuc_monitor_init_module( void ) { SYS_UWORD8 i; // Fill the entire stack with the pattern 0xFE memset( ti_nuc_monitor_hisr_stack, 0xFE, sizeof( ti_nuc_monitor_hisr_stack ) ); // Create the HISR NU_Create_HISR( &ti_nuc_monitor_cb, "TI MON", ti_nuc_monitor_hisr, 2, ti_nuc_monitor_hisr_stack, sizeof( ti_nuc_monitor_hisr_stack ) ); // lowest prty } // ti_nuc_monitor_init_module /*-------------------------------------------------------*/ /* ti_nuc_monitor_hisr() High Interrupt service routine */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* It sends a message to the profiler task to start the */ /* buffer extraction. */ /*-------------------------------------------------------*/ void ti_nuc_monitor_hisr( void ) { SYS_UWORD8 remaining_bytes; SYS_UWORD16 fn; T_PROFILER_MSG *msg; SYS_UWORD8 i; // Allocate a buffer first time if(( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_RUN ) || ( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_STARTED )) { if((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) == RVT_OK) { ti_nuc_monitor_current_position = 0; // Insert the interrupt OP Code (0x00 0x00 0x00) if( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_RUN ) { for( i=0; i < 3; i++) { ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = 0x00; } // End for } // Endif // Reset intermediate buffer pointers ti_nuc_monitor_Thread_current_pos = 0; ti_nuc_monitor_LISR_current_pos = 0; } else { return; } // End if // Write FN OP CODE : (0x00 | xx) ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ( C_OP_CODE_FN_LOG ); // Insert the fn%42432 fn = l1_get_actual_fn_mod42432(); // insert LSB ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) (fn & 0x00ff); // insert MSB ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ((fn & 0xff00) >> 8); ti_nuc_monitor_state = NUC_MONITOR_RUNNING; return; } // End if // Copy the LISR and Thread buffer into current buffer. // - LISR array // Check the number of byte remaining in the current // log buffer vs LISR buffer. remaining_bytes = NUC_MONITOR_BUFFER_SIZE - ti_nuc_monitor_current_position; if( remaining_bytes > ti_nuc_monitor_LISR_next_pos ) { // Copy ti_nuc_monitor_LISR_next_pos bytes to Nucleus log buffer memcpy( &ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position ], &ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_next_page ][ 0 ], ti_nuc_monitor_LISR_next_pos); ti_nuc_monitor_current_position += ti_nuc_monitor_LISR_next_pos; } else { // Copy remaining_bytes bytes to Nucleus log buffer memcpy( &ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position ], &ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_next_page ][ 0 ], remaining_bytes); ti_nuc_monitor_current_position += remaining_bytes; // Send current buffer // send a message to the ti profiler task if( rvf_get_buf( prof_mb_id, sizeof( T_PROFILER_MSG ), ( T_RVF_BUFFER** ) &msg ) == RVF_GREEN ) { msg->msg_id = TI_NUC_MONITOR_OUTPUT_BUFFER; msg->p_buffer = ti_nuc_monitor_current_buffer; msg->buffer_size = ti_nuc_monitor_current_position; ti_nuc_monitor_current_position = 0; if( rvf_send_msg( prof_addr_id, msg ) != RV_OK ) { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if } else { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if // Change Nucleus log buffer if((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) != RVT_OK) { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if // Copy remaining_bytes bytes to Nucleus log buffer memcpy( &ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position ], &ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_next_page ][ remaining_bytes ], ( ti_nuc_monitor_LISR_next_pos - remaining_bytes )); ti_nuc_monitor_current_position += ( ti_nuc_monitor_LISR_next_pos - remaining_bytes ); } // End if // - Thread Array // Check the number of byte remaining in the current // log buffer vs Thread buffer. remaining_bytes = NUC_MONITOR_BUFFER_SIZE - ti_nuc_monitor_current_position; if( remaining_bytes > ti_nuc_monitor_Thread_next_pos ) { // Copy ti_nuc_monitor_Thread_next_pos bytes to Nucleus log buffer memcpy( &ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position ], &ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_next_page ][ 0 ], ti_nuc_monitor_Thread_next_pos); ti_nuc_monitor_current_position += ti_nuc_monitor_Thread_next_pos; } else { // Copy remaining_bytes bytes to Nucleus log buffer memcpy( &ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position ], &ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_next_page ][ 0 ], remaining_bytes); ti_nuc_monitor_current_position += remaining_bytes; // Send current buffer // send a message to the ti profiler task if( rvf_get_buf( prof_mb_id, sizeof( T_PROFILER_MSG ), ( T_RVF_BUFFER** ) &msg ) == RVF_GREEN ) { msg->msg_id = TI_NUC_MONITOR_OUTPUT_BUFFER; msg->p_buffer = ti_nuc_monitor_current_buffer; msg->buffer_size = ti_nuc_monitor_current_position; ti_nuc_monitor_current_position = 0; if( rvf_send_msg( prof_addr_id, msg ) != RV_OK ) { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if } else { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if // Change Nucleus log buffer if((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) != RVT_OK) { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if // Copy remaining_bytes bytes to Nucleus log buffer memcpy( &ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position ], &ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_next_page ][ remaining_bytes ], ( ti_nuc_monitor_Thread_next_pos - remaining_bytes )); ti_nuc_monitor_current_position += ( ti_nuc_monitor_Thread_next_pos - remaining_bytes ); } // End if // Exit if monitoring must be stopped if( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_STOP ) { ti_nuc_monitor_state = NUC_MONITOR_STOPPED; return; } // End if // Insert actual Frame number // Check if enough space in current buffer if( ti_nuc_monitor_current_position >= (NUC_MONITOR_BUFFER_SIZE - 3) ) { // send a message to the ti profiler task if( rvf_get_buf( prof_mb_id, sizeof( T_PROFILER_MSG ), ( T_RVF_BUFFER** ) &msg ) == RVF_GREEN ) { msg->msg_id = TI_NUC_MONITOR_OUTPUT_BUFFER; msg->p_buffer = ti_nuc_monitor_current_buffer; msg->buffer_size = ti_nuc_monitor_current_position; ti_nuc_monitor_current_position = 0; if( rvf_send_msg( prof_addr_id, msg ) != RV_OK ) { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if } else { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if // Change Nucleus log buffer if((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) != RVT_OK) { ti_nuc_monitor_state = NUC_MONITOR_TO_BE_RUN; return; } // End if } // End if // Write FN OP CODE : (0x00 | xx) ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ( C_OP_CODE_FN_LOG ); // Insert the fn%42432 fn = l1_get_actual_fn_mod42432(); // insert LSB ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) (fn & 0x00ff); // insert MSB ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ((fn & 0xff00) >> 8); } // ti_nuc_monitor_hisr /*-------------------------------------------------------*/ /* ti_nuc_monitor_check_ID_buffer() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* During the Thread/Queue ID -> names buffer */ /* transmission, change current buffer. */ /* Send the full buffer and allocate a new one. */ /*-------------------------------------------------------*/ void ti_nuc_monitor_check_ID_buffer( void ) { // Reset pointer ti_nuc_monitor_current_position = 0; // Send a message to the Riviera Tracer to Output the current buffer. if( rvt_send_trace_no_cpy( ( T_RVT_BUFFER ) ti_nuc_monitor_current_buffer, prof_trace_id, NUC_MONITOR_BUFFER_SIZE, // Length in bytes RVT_BINARY_FORMAT ) != RVT_OK ) { // code to insert a breakpoint if failed. ti_nuc_monitor_state = NUC_MONITOR_STOPPED; } // End if // Allocate one buffer. do { ti_nuc_monitor_state = NUC_MONITOR_STOPPED; if ((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) != RVT_OK) { ti_nuc_monitor_state = NUC_MONITOR_WAITING; } // End if } while (ti_nuc_monitor_state == NUC_MONITOR_WAITING); } // ti_nuc_monitor_check_ID_buffer /*-------------------------------------------------------*/ /* ti_nuc_monitor_tdma_action() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* this function activate the HISR monitor */ /*-------------------------------------------------------*/ void ti_nuc_monitor_tdma_action( void ) { if(( ti_nuc_monitor_state == NUC_MONITOR_RUNNING ) || ( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_RUN ) || ( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_STOP ) || ( ti_nuc_monitor_state == NUC_MONITOR_TO_BE_STARTED )) { // Activate the hisr in order to start the buffer fill NU_Activate_HISR( &ti_nuc_monitor_cb ); } // End if } // ti_nuc_monitor_tdma_action /*-------------------------------------------------------*/ /* ti_nuc_monitor_LISR_log() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* This function permits to include the LISR IRQ and */ /* timer value in the LISR log buffer */ /* Warning : To save cpu, no overflow check is done */ /*-------------------------------------------------------*/ void ti_nuc_monitor_LISR_log( void ) { SYS_UWORD16 timer_value; if( ti_nuc_monitor_state == NUC_MONITOR_RUNNING ) { // Exit Idle mode if reached ti_nuc_monitor_idle_reached = 0; IRQ_value = (SYS_UWORD8) ((* (volatile SYS_UWORD16 *) INTH_B_IRQ_REG) & 0x001f); // Write LISR OP CODE and IRQ : (0xC0 | IRQ) ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_current_page ] [ ti_nuc_monitor_LISR_current_pos ] = (SYS_UWORD8) (C_OP_CODE_LISR_FLAG | IRQ_value); // Write the timer value timer_value = TM_ReadTimer(2); // (* (SYS_UWORD16 *) TIMER2_READ_TIM) // insert LSB ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_current_page ] [ ti_nuc_monitor_LISR_current_pos + 1 ] = (SYS_UWORD8) (timer_value & 0x00ff); // insert MSB ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_current_page ] [ ti_nuc_monitor_LISR_current_pos + 2 ] = (SYS_UWORD8) ((timer_value & 0xff00) >> 8); ti_nuc_monitor_LISR_current_pos += 3; } // End if } // ti_nuc_monitor_LISR_log /*-------------------------------------------------------*/ /* ti_nuc_monitor_LISR_log_end() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* This function permits to include the LISR end */ /* timer value in the LISR log buffer */ /* Warning : To save cpu, no overflow check is done */ /*-------------------------------------------------------*/ void ti_nuc_monitor_LISR_log_end( void ) { SYS_UWORD16 timer_value; if( ti_nuc_monitor_state == NUC_MONITOR_RUNNING ) { // Write the timer value timer_value = TM_ReadTimer(2); // insert LSB ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_current_page ] [ ti_nuc_monitor_LISR_current_pos ] = (SYS_UWORD8) (timer_value & 0x00ff); // insert MSB ti_nuc_monitor_LISR_Buffer[ ti_nuc_monitor_LISR_current_page ] [ ti_nuc_monitor_LISR_current_pos + 1 ] = (SYS_UWORD8) ((timer_value & 0xff00) >> 8); ti_nuc_monitor_LISR_current_pos += 2; // Switch LISR & thread buffer page if IRQ4 (TDMA) if( IRQ_value == 4 ) { // copy current to next ti_nuc_monitor_LISR_next_pos = ti_nuc_monitor_LISR_current_pos; ti_nuc_monitor_LISR_next_page = ti_nuc_monitor_LISR_current_page; // instead of changing the Thread page here, set a boolean ti_nuc_monitor_change_thread_page = 1; //ti_nuc_monitor_Thread_next_pos = ti_nuc_monitor_Thread_current_pos; //ti_nuc_monitor_Thread_next_page = ti_nuc_monitor_Thread_current_page; // Reset current pointer ti_nuc_monitor_LISR_current_pos = 0; //ti_nuc_monitor_Thread_current_pos = 0; // Change page if( ti_nuc_monitor_LISR_current_page == 0 ) { ti_nuc_monitor_LISR_current_page = 1; // ti_nuc_monitor_Thread_current_page = 1; } else { ti_nuc_monitor_LISR_current_page = 0; // ti_nuc_monitor_Thread_current_page = 0; } // End if // reset IRQ_value IRQ_value = 0; // reset timer TM_ResetTimer (2, 0xFFFF, 1, 0); TM_StartTimer (2); // Doesn't work // * (volatile SYS_UWORD16 *) TIMER2_LOAD_TIM = 0xFFFF; // * (volatile SYS_UWORD16 *) TIMER2_CNTL = 0x0003; } // End if } // End if } // ti_nuc_monitor_LISR_log_end /*-------------------------------------------------------*/ /* ti_nuc_monitor_Thread_log() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* This function permits to include the Thread and */ /* timer value in the log buffer */ /*-------------------------------------------------------*/ void ti_nuc_monitor_Thread_log( void ) { SYS_UWORD16 timer_value; SYS_UWORD8 i; if( ti_nuc_monitor_state == NUC_MONITOR_RUNNING ) { // Exit Idle mode if reached ti_nuc_monitor_idle_reached = 0; // Check if page must be changed if( ti_nuc_monitor_change_thread_page == 1 ) { ti_nuc_monitor_change_thread_page = 0; // copy current to next ti_nuc_monitor_Thread_next_pos = ti_nuc_monitor_Thread_current_pos; ti_nuc_monitor_Thread_next_page = ti_nuc_monitor_Thread_current_page; // Reset current pointer ti_nuc_monitor_Thread_current_pos = 0; // Change page if( ti_nuc_monitor_Thread_current_page == 0 ) { ti_nuc_monitor_Thread_current_page = 1; } else { ti_nuc_monitor_Thread_current_page = 0; } // End if } // End if // Search the ID considering the Nucleus_Current_thread Pointer for( i = 0; i < ti_nuc_monitor_thread_pos ; i++ ) { if( ti_nuc_monitor_thread_id[ i ] == (SYS_UWORD32) TCD_Current_Thread ) { // insert the OP Code Thread | ID ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos ] = (SYS_UWORD8) (C_OP_CODE_THREAD_FLAG | i); // exit loop break; } // End if } // End for // Write the timer value timer_value = TM_ReadTimer(2); // (* (SYS_UWORD16 *) TIMER2_READ_TIM) // insert LSB ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos + 1 ] = (SYS_UWORD8) (timer_value & 0x00ff); // insert MSB ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos + 2 ] = (SYS_UWORD8) ((timer_value & 0xff00) >> 8); ti_nuc_monitor_Thread_current_pos += 3; } // End if } // ti_nuc_monitor_Thread_log /*-------------------------------------------------------*/ /* ti_nuc_monitor_Queue_log() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* This function permits to include the Queue ID and */ /* status value in the log buffer */ /* Direction = 0 => Send message */ /* Direction = 1 => Receive message */ /* status = 0 => OK */ /* status = 1 => Queue full */ /*-------------------------------------------------------*/ void ti_nuc_monitor_Queue_log( SYS_UWORD32* queue_pointer, SYS_UWORD8 status, SYS_UWORD8 Direction ) { SYS_UWORD8 status_word; SYS_UWORD8 i; if( ti_nuc_monitor_state == NUC_MONITOR_RUNNING ) { // Exit Idle mode if reached ti_nuc_monitor_idle_reached = 0; // Check if page must be changed if( ti_nuc_monitor_change_thread_page == 1 ) { ti_nuc_monitor_change_thread_page = 0; // copy current to next ti_nuc_monitor_Thread_next_pos = ti_nuc_monitor_Thread_current_pos; ti_nuc_monitor_Thread_next_page = ti_nuc_monitor_Thread_current_page; // Reset current pointer ti_nuc_monitor_Thread_current_pos = 0; // Change page if( ti_nuc_monitor_Thread_current_page == 0 ) { ti_nuc_monitor_Thread_current_page = 1; } else { ti_nuc_monitor_Thread_current_page = 0; } // End if } // End if // Search the ID considering the Nucleus_Current_thread Pointer for( i = 0; i < ti_nuc_monitor_queue_pos ; i++ ) { if( ti_nuc_monitor_queue_id[ i ] == (SYS_UWORD32) queue_pointer) { // insert the OP Code Thread | ID ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos ] = (SYS_UWORD8) (C_OP_CODE_QUEUE_FLAG | i); // exit loop break; } // End if } // End for // Write the status value and Receive/send flag status_word = (Direction << 8) | (status << 7) | i; // Direction | Status | ID ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos + 1 ] = (SYS_UWORD8) (status_word); ti_nuc_monitor_Thread_current_pos += 2; } // End if } // ti_nuc_monitor_Queue_log /*-------------------------------------------------------*/ /* ti_nuc_monitor_sleep() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* This function permits to include the sleep and */ /* timer value in the log buffer */ /*-------------------------------------------------------*/ void ti_nuc_monitor_sleep( void ) { SYS_UWORD16 timer_value; SYS_UWORD8 i; if(( ti_nuc_monitor_state == NUC_MONITOR_RUNNING ) && ( ti_nuc_monitor_idle_reached == 0 )) { ti_nuc_monitor_idle_reached = 1; // insert the OP Code Thread | ID ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos ] = (SYS_UWORD8) (0xBF); // Write the timer value timer_value = TM_ReadTimer(2); // (* (SYS_UWORD16 *) TIMER2_READ_TIM) // insert LSB ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos + 1 ] = (SYS_UWORD8) (timer_value & 0x00ff); // insert MSB ti_nuc_monitor_Thread_Buffer[ ti_nuc_monitor_Thread_current_page ] [ ti_nuc_monitor_Thread_current_pos + 2 ] = (SYS_UWORD8) ((timer_value & 0xff00) >> 8); ti_nuc_monitor_Thread_current_pos += 3; } // End if } // ti_nuc_monitor_sleep // -------------- RVT Copied function -------------------------------- // --- Modified Memory Bank ---- /********************************************************************************/ /* */ /* Function Name: ti_nuc_monitor_mem_alloc */ /* */ /* Purpose: this function creates a memory bank for the profiler task*/ /* */ /* Input Parameters: */ /* refer to t_rvt_type.h */ /* */ /* Output Parameters: */ /* refer to t_rvt_type.h */ /* */ /* Global Parameters: */ /* None. */ /* */ /* Note: */ /* None. */ /* */ /********************************************************************************/ T_RVT_RET ti_nuc_monitor_mem_alloc(T_RVT_USER_ID user_id, T_RVT_MSG_LG buffer_lenght, T_RVT_BUFFER * buff) { T_RVF_MB_STATUS return_value; return_value = rvf_get_buf (prof_mb_id, (UINT32) buffer_lenght + RVT_HEADER_SIZE, (T_RVF_BUFFER**) buff); if (return_value == RVF_RED) { *buff = NULL; return RVT_MEMORY_ERR; } else { *buff = *buff + RVT_HEADER_SIZE; return RVT_OK; } } // ti_nuc_monitor_mem_alloc // ------------------------------------------------------------------- #endif // TI_NUC_MONITOR #if (TI_PROFILER == 1) || (TI_NUC_MONITOR == 1) /*-------------------------------------------------------*/ /* ti_prf_init() */ /*-------------------------------------------------------*/ /* */ /* Description: Initialize profiling hisrs */ /* ------------ */ /* Register the profiling to rvt */ /* */ /*-------------------------------------------------------*/ void ti_prf_init( void ) { #if (TI_PROFILER == 1) ti_profiler_init_profiler_module(); #endif #if (TI_NUC_MONITOR == 1) ti_nuc_monitor_init_module(); #endif // Register to Trace task module rvt_register_id( "PROF", &prof_trace_id, ti_profiler_trace_rx_callback ); } // ti_prf_init /*-------------------------------------------------------*/ /* ti_prf_core() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* this function : */ /* - start the profiler on PC side message reception */ /* - stop the profiler on PC side message reception */ /* - cut the profiler buffer less than 256 bytes */ /* messages to rvt */ /* */ /*-------------------------------------------------------*/ T_RV_RET ti_prf_core(void) { SYS_UWORD16 i = 0; SYS_UWORD16 event; SYS_UWORD16 message_length; T_PROFILER_MSG *msg; while( INFINITE_LOOP ) { // Suspend the task on empty queue event = rvf_wait( RVF_TASK_MBOX_0_EVT_MASK, 0 ); msg = ( T_PROFILER_MSG* ) rvf_read_mbox( RVF_TASK_MBOX_0 ); // Check the msg ID code switch( msg->msg_id ) { #if (TI_PROFILER == 1) case TI_PROFILER_OUTPUT_BUFFER : // Cut the buffer in small element to be sent to // PC by the RVT. { message_length = TRACE_MESSAGE_SIZE; pos_pr_buffer = 0; // loop until end of buffer while( pos_pr_buffer < pr_buffer_length ) { // Update message length for next loop turn if ( pos_pr_buffer <= ( pr_buffer_length - TRACE_MESSAGE_SIZE ) ) { message_length = TRACE_MESSAGE_SIZE; } else { message_length = pr_buffer_length - pos_pr_buffer; } if( rvt_send_trace_cpy( ( T_RVT_BUFFER ) &pr_buffer[ pos_pr_buffer ], prof_trace_id, message_length * 4, // Length in bytes RVT_BINARY_FORMAT ) == RVT_OK ) { // Update pr_buffer pointer pos_pr_buffer += message_length; } // End if } // End while // Restart the profiling at vitam aeternam unless stop command received. if( profiler_state == PROFILER_FREEZED ) { profiler_state = PROFILER_TO_BE_UNFREEZED; } // End if break; } // TI_PROFILER_OUTPUT_BUFFER case TI_PROFILER_START_PROFILING : { #if (L1_TRACER == 1) SendTraces("TI_PROF: msg TI_PROFILER_START\n\r"); #endif ti_profiler_event_state = (T_PROFILER_EVENTS) (msg->event_number); if( ti_profiler_event_state == NO_SLEEP_EVENT ) { ti_profiler_nb_sleep_counter_ref = msg->arg1; // nb_tdma } // End if // Source of Activation ti_profiler_active = ACTIVE_BY_HOST; // change state of profiler profiler_state = PROFILER_TO_BE_RAN; break; } // TI_PROFILER_START_PROFILING case TI_PROFILER_END_PROFILING : { #if (L1_TRACER == 1) SendTraces("TI_PROF: msg TI_PROFILER_STOP\n\r"); #endif profiler_state = PROFILER_TO_BE_STOPPED; break; } // TI_PROFILER_END_PROFILING #endif #if (TI_NUC_MONITOR == 1) case TI_NUC_MONITOR_START : { SYS_UWORD8 i = 0; SYS_UWORD8 j = 0; #if (L1_TRACER == 1) SendTraces("TI_PROF: msg TI_NUC_MONITOR_START\n\r"); #endif if( ti_nuc_monitor_state == NUC_MONITOR_STOPPED ) { // Output the task and queues create info. // buffer format is following : // C_OP_CODE_NUC_MON_THREAD_IDS | (1 byte) // < Thread ID0 > | (1 byte) // < Thread name > | (8 bytes) // < Thread ID1 > | (1 byte) // < Thread name > | (8 bytes) // .............. // C_OP_CODE_NUC_MON_THREAD_IDS | (1 byte) // < Queue ID0 > | (1 byte) // < Queue name > | (8 bytes) // < Queue ID1 > | (1 byte) // < Queue name > | (8 bytes) // .............. // C_OP_CODE_NUC_MON_THREAD_IDS | (1 byte) // Allocate one buffer. while ((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) != RVT_OK); // Output the ID (thread and Queue array) ti_nuc_monitor_current_buffer[ti_nuc_monitor_current_position++] = C_OP_CODE_NUC_MON_THREAD_IDS; // Output the Thread IDs and corresponding Thread name. for( i = 0 ; i < ti_nuc_monitor_thread_pos ; i++ ) { // distinghuish Task and HISR if( (( TC_TCB * ) ( ti_nuc_monitor_thread_id[ i ]))->tc_id == TC_HISR_ID) { ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (0x80 | i); // ID } else { ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = i; // ID } // End if if( ti_nuc_monitor_current_position >= NUC_MONITOR_BUFFER_SIZE ) { ti_nuc_monitor_check_ID_buffer(); } // End if // Write task priority ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ((( TC_TCB * ) ( ti_nuc_monitor_thread_id[ i ]))->tc_priority); if( ti_nuc_monitor_current_position >= NUC_MONITOR_BUFFER_SIZE ) { ti_nuc_monitor_check_ID_buffer(); } // End if // Write name in the Log buffer. for( j = 0 ; j < NU_MAX_NAME ; j++ ) { ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ((( TC_TCB * ) ( ti_nuc_monitor_thread_id[ i ]))->tc_name[ j ]); // Thread_name if( ti_nuc_monitor_current_position >= NUC_MONITOR_BUFFER_SIZE ) { ti_nuc_monitor_check_ID_buffer(); } // End if } // End for } // End for // Output the ID (thread and Queue array) if( ti_nuc_monitor_queue_pos != 0 ) { ti_nuc_monitor_current_buffer[ti_nuc_monitor_current_position++] = C_OP_CODE_NUC_MON_THREAD_IDS; // Output the Queue IDs and corresponding Queue name. if( ti_nuc_monitor_current_position >= NUC_MONITOR_BUFFER_SIZE ) { ti_nuc_monitor_check_ID_buffer(); } // End if for( i = 0 ; i < ti_nuc_monitor_queue_pos ; i++ ) { ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = i; // ID if( ti_nuc_monitor_current_position >= NUC_MONITOR_BUFFER_SIZE ) { ti_nuc_monitor_check_ID_buffer(); } // End if // Write name in the Log buffer. for( j = 0 ; j < NU_MAX_NAME ; j++ ) { ti_nuc_monitor_current_buffer[ ti_nuc_monitor_current_position++ ] = (SYS_UWORD8) ((( QU_QCB * ) ( ti_nuc_monitor_queue_id[ i ] ))->qu_name[ j ]); // Thread_name if( ti_nuc_monitor_current_position >= NUC_MONITOR_BUFFER_SIZE ) { ti_nuc_monitor_check_ID_buffer(); } // End if } // End for } // End for } // End if // Insert end op code (same as begin op code) ti_nuc_monitor_current_buffer[ti_nuc_monitor_current_position++] = C_OP_CODE_NUC_MON_THREAD_IDS; // flush the last buffer. // Send a message to the Riviera Tracer to Output the current buffer. if( rvt_send_trace_no_cpy( ( T_RVT_BUFFER ) ti_nuc_monitor_current_buffer, prof_trace_id, ti_nuc_monitor_current_position, // Length in bytes RVT_BINARY_FORMAT ) != RVT_OK ) { // Code to insert break point. ti_nuc_monitor_state = NUC_MONITOR_STOPPED; } // End if // Configuration buffer has been logged out. /* ** Allocate a buffer for Nucleus profiling */ while ((ti_nuc_monitor_mem_alloc (prof_trace_id, NUC_MONITOR_BUFFER_SIZE, (T_RVT_BUFFER*) &ti_nuc_monitor_current_buffer)) != RVT_OK); // reset the current pointer. ti_nuc_monitor_current_position = 0; // Set the new Monitoring state. ti_nuc_monitor_state = NUC_MONITOR_TO_BE_STARTED; } // End if break; } // TI_NUC_MONITOR_START case TI_NUC_MONITOR_OUTPUT_BUFFER : { // The buffer is output only if it is full. // Send a message to the Riviera Tracer to Output the current buffer. if( rvt_send_trace_no_cpy( ( T_RVT_BUFFER ) msg->p_buffer, prof_trace_id, msg->buffer_size, // Length in bytes RVT_BINARY_FORMAT ) != RVT_OK ) { // increment lost messages variable ti_nuc_monitor_lost_messages++; } // End if break; } // TI_NUC_MONITOR_OUTPUT_BUFFER case TI_NUC_MONITOR_STOP : { #if (L1_TRACER == 1) SendTraces("TI_PROF: msg TI_NUC_MONITOR_STOP\n\r"); #endif ti_nuc_monitor_state = NUC_MONITOR_TO_BE_STOP; break; } // TI_NUC_MONITOR_STOP #endif default : { #if (L1_TRACER == 1) SendTraces("TI_PROF: msg default\n\r"); #endif break; } // default } // End switch // Free the msg alloc rvf_free_buf( msg ); } // End while ( INFINITE_LOOP ) } // ti_profiler_task /*-------------------------------------------------------*/ /* ti_profiler_trace_rx_callback() */ /*-------------------------------------------------------*/ /* */ /* Description: */ /* ------------ */ /* callback function called when the trace */ /* module receives a msg for the profiler */ /* or the nucleus monitor. */ /* */ /*-------------------------------------------------------*/ void ti_profiler_trace_rx_callback(T_RVT_BUFFER trace_msg, UINT16 trace_msg_size) { T_PROFILER_MSG * msg; // send a message to the ti profiler received from Rvt if( rvf_get_buf( prof_mb_id, sizeof( T_PROFILER_MSG ), ( T_RVF_BUFFER** ) &msg ) == RVF_GREEN ) { /* if( trace_msg[0] == 1 ) msg->msg_id = TI_PROFILER_START_PROFILING; else if ( trace_msg[0] == 0 ) msg->msg_id = TI_PROFILER_END_PROFILING; else if ( trace_msg[0] == 2 ) msg->msg_id = TI_NUC_MONITOR_START; else if ( trace_msg[0] == 3 ) msg->msg_id = TI_NUC_MONITOR_STOP; */ msg->msg_id = ((T_PROFILER_MSG_UART*) trace_msg)->msg_id; msg->event_number = ((T_PROFILER_MSG_UART*) trace_msg)->event_number; msg->arg1 = ((T_PROFILER_MSG_UART*) trace_msg)->arg1; rvf_send_msg( prof_addr_id, msg ); } } // ti_profiler_trace_rx_callback #endif // NUC_MONITOR || PROFILER