FreeCalypso > hg > fc-magnetite

view src/cs/riviera/rvt/rvt_task.c @ 600:8f50b202e81f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
board preprocessor conditionals: prep for more FC hw in the future This change eliminates the CONFIG_TARGET_FCDEV3B preprocessor symbol and all preprocessor conditionals throughout the code base that tested for it, replacing them with CONFIG_TARGET_FCFAM or CONFIG_TARGET_FCMODEM. These new symbols are specified as follows: CONFIG_TARGET_FCFAM is intended to cover all hardware designs created by Mother Mychaela under the FreeCalypso trademark. This family will include modem products (repackagings of the FCDEV3B, possibly with RFFE or even RF transceiver changes), and also my desired FreeCalypso handset product. CONFIG_TARGET_FCMODEM is intended to cover all FreeCalypso modem products (which will be firmware-compatible with the FCDEV3B if they use TI Rita transceiver, or will require a different fw build if we switch to one of Silabs Aero transceivers), but not the handset product. Right now this CONFIG_TARGET_FCMODEM preprocessor symbol is used to conditionalize everything dealing with MCSI. At the present moment the future of FC hardware evolution is still unknown: it is not known whether we will ever have any beyond-FCDEV3B hardware at all (contingent on uncertain funding), and if we do produce further FC hardware designs, it is not known whether they will retain the same FIC modem core (triband), if we are going to have a quadband design that still retains the classic Rita transceiver, or if we are going to switch to Silabs Aero II or some other transceiver. If we produce a quadband modem that still uses Rita, it will run exactly the same fw as the FCDEV3B thanks to the way we define TSPACT signals for the RF_FAM=12 && CONFIG_TARGET_FCFAM combination, and the current fcdev3b build target will be renamed to fcmodem. OTOH, if that putative quadband modem will be Aero-based, then it will require a different fw build target, the fcdev3b target will stay as it is, and the two targets will both define CONFIG_TARGET_FCFAM and CONFIG_TARGET_FCMODEM, but will have different RF_FAM numbers. But no matter which way we are going to evolve, it is not right to have conditionals on CONFIG_TARGET_FCDEV3B in places like ACI, and the present change clears the way for future evolution.
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 01 Apr 2019 01:05:24 +0000
parents 61f878c011b0
children
line wrap: on
line source

/**************************************************************************
*
* rvt_task.c
*
* This contains the core of the Trace task.
*
* (C) Texas Instruments, all rights reserved
*
* Version number   : 0.1
*
* History		   : 0.1 (7/5/2000) - Created
*
* Date             : 7/5/2000
*
* Author           : Guido Pagana
*
* Update           : Pascal Puel
*                  : David Lamy-Charrier (changes for Riviera 1.6)
*
***************************************************************************/


#include "nucleus.h"

#include "rv/general.h"
#include "rv/rv_general.h"
#include "rvf/rvf_api.h"
#include "rvt/rvt_gen.h"
#include "rvt/rvt_def_i.h"
#include "rvt/rvt_env.h"
#include "rvt/rvt_env_i.h"
#include "rvm/rvm_use_id_list.h"

#include "uart/serialswitch.h"

#ifndef _WINDOWS
	#include "config/swconfig.cfg"
#endif

#include <string.h>

extern NU_HISR        TI_rcv_HISR;

/* Time (in milliseconds) between two consecutive 'System Time' messages */
#ifdef PSEUDO_MODEM_USB
#define RVT_ALIVE_POLLING_TIME    (RVF_MS_TO_TICKS (10000))
#elif defined(PSEUDO_MODEM_KEEPALIVE)
#define RVT_ALIVE_POLLING_TIME    (RVF_MS_TO_TICKS (5000))
#else
#define RVT_ALIVE_POLLING_TIME    (RVF_MS_TO_TICKS (20000))
#endif

#define RVT_WAIT_FOR_HEADER       (1)
#define RVT_WAIT_FOR_DATA         (2)

#ifdef PSEUDO_MODEM_KEEPALIVE
extern void rvt_keepalive_register(void);
extern void rvt_keepalive_process(void);
#endif

/********************************************************************************/
/*                                                                              */
/*    Function Name:   rvt_task_core                                            */
/*                                                                              */
/*    Purpose:         Core of Trace task.                                      */
/*                                                                              */
/*    Input Parameters:                                                         */
/*        None.                                                                 */
/*                                                                              */
/*    Output Parameters:                                                        */
/*        None.                                                                 */
/*                                                                              */
/*    Global Parameters:                                                        */
/*        None.                                                                 */
/*                                                                              */
/*    Note:                                                                     */
/*        None.                                                                 */
/*                                                                              */
/********************************************************************************/
T_RVM_RETURN rvt_task_core (void)
{
	UINT16  event         = 0;
	UINT32  nb_bytes_sent = 0;

#ifdef PSEUDO_MODEM_KEEPALIVE
	rvt_keepalive_register();
#endif

	#ifdef FRAMING_PROTOCOL

		// Request for the level of filtering, as well as the 32-bit
		// mask related to the software entities to be monitored.
		{
			UINT8  trace_level_request[] = {RVM_INVALID_USE_ID, 0, 0, 0, 0, (RV_TRACE_LEVEL_ERROR - 1), 0, 0, 0, 0};

			// Note that the level is defined as invalid
			trace_level_request[0] = (char) rv_trace_user_id;

			// Transmit an 'empty' message
			nb_bytes_sent = 0;
			while (nb_bytes_sent < sizeof (trace_level_request))
			{
				nb_bytes_sent += SER_tr_WriteNBytes (SER_LAYER_1,
													 trace_level_request + nb_bytes_sent,
													 sizeof (trace_level_request) - nb_bytes_sent);
			}
		}

		// Start the 'Alive Polling Timer'
		#if (OP_WCP == 0)
			rvf_start_timer (RVF_TIMER_0,
							 RVT_ALIVE_POLLING_TIME,
							 TRUE);
		#endif

		for (;
			 ;
			 )
		{
			// Infinite wait on 'Trace Task' mailbox or timer events
			event = rvf_wait ((1 << RVT_TRACE_MAILBOX) | (RVF_TIMER_0_EVT_MASK),
							  0);

			// Check for some messages lost
			if (((rvt_lost_msg_cpt.bit_mask).count >= RVT_MAX_LOST_TRACE_MSG) && (p_rvt_lost_msg))
			{
				INT8    count           = 0;
				UINT8   lost_msg_length = RVT_HDR_LENGTH + RVT_LOST_MSG_LENGTH;
				UINT32  lost_msg_cpt    = rvt_lost_msg_cpt.overall_value;

				// Append with the number of messages lost
				rvt_lost_msg_cpt.overall_value = 0;
				for (count = 0;
					 count < RVT_HEX_VALUE_LENGTH;
					 count++)
				{
					p_rvt_lost_msg[lost_msg_length + count] = Num2Char[(UINT8) ((lost_msg_cpt << (count << 2)) >> 28)];	
				}
				lost_msg_length += RVT_HEX_VALUE_LENGTH;

				// Send message to the UART with byte stuffing
				nb_bytes_sent = 0;
				while (nb_bytes_sent < lost_msg_length)
				{
					nb_bytes_sent += SER_tr_WriteNBytes (SER_LAYER_1,
														 (UINT8 *) p_rvt_lost_msg + nb_bytes_sent,
														 lost_msg_length - nb_bytes_sent);
				}

			} // End of if ((rvt_lost_msg_cpt.bit_mask).count >= RVT_MAX_LOST_TRACE_MSG)

			if (event & EVENT_MASK (RVT_TRACE_MAILBOX))
			{
				T_RV_HDR  *msg = NULL;

				// Read the message from the mailbox
				if ((msg = (T_RV_HDR *) rvf_read_mbox (RVT_TRACE_MAILBOX)) != NULL)
				{
					if (msg->msg_id == RVT_TRACE_RQST_ID)
					{
						UINT8   msg_format = 0;
						UINT32  msg_length = 0;

						// Get the length
						msg_length = ((T_RVT_TRACE_RQST *) msg)->msg_length;

						// Get the format
						msg_format = ((T_RVT_TRACE_RQST *) msg)->format;

						// Copy the 'User ID'
						((UINT8 *) msg + RVT_HEADER_SIZE - 1)[0] = ((T_RVT_TRACE_RQST *) msg)->user_id;
						msg_length++;

						switch (msg_format)
						{
							case RVT_ASCII_FORMAT:
								{
									// Send message to the UART without byte stuffing
									nb_bytes_sent = 0;
									while (nb_bytes_sent < msg_length)
									{
										nb_bytes_sent += SER_tr_EncapsulateNChars (SER_LAYER_1,
																				   (char *) msg + RVT_HEADER_SIZE - 1 + nb_bytes_sent,
																				   msg_length - nb_bytes_sent);
									}
									break;
								}
							case RVT_BINARY_FORMAT:
								{
									// Send message to the UART with byte stuffing
									nb_bytes_sent = 0;
									while (nb_bytes_sent < msg_length)
									{
										nb_bytes_sent += SER_tr_WriteNBytes (SER_LAYER_1,
																			 (UINT8 *) msg + RVT_HEADER_SIZE - 1 + nb_bytes_sent,
																			 msg_length - nb_bytes_sent);
									}
									break;
								}
							default:
								{
									// Increment the number of messages lost.
									// Is the buffer corrupted?
									(rvt_lost_msg_cpt.bit_mask).count++;
									(rvt_lost_msg_cpt.bit_mask).unknown_format = 1;
									break;
								}
						}

						// Deallocate the buffer
						rvf_free_buf (msg);

					} // End of if (msg->msg_id == RVT_TRACE_RQST_ID)

					else
					{
						// Increment the number of messages lost. Is the buffer
						// corrupted?
						(rvt_lost_msg_cpt.bit_mask).count++;
						(rvt_lost_msg_cpt.bit_mask).unknown_request = 1;
					}

				} // End of if (msg != NULL)

				else
				{
					// Increment the number of messages lost. Is the buffer
					// corrupted?
					(rvt_lost_msg_cpt.bit_mask).count++;
					(rvt_lost_msg_cpt.bit_mask).message_empty = 1;
				}

			}  // End of if (event & EVENT_MASK (RVT_TRACE_MAILBOX))

			if ((event & (RVF_TIMER_0_EVT_MASK)) && (p_rvt_sys_time))			
			{
				UINT8   count           = 0;
				UINT8   sys_time_length = RVT_HDR_LENGTH + RVT_SYS_TIME_LENGTH;
				UINT32  current_time    = rvf_get_tick_count ();

				// Append with the system time
				for (count = 0;
					 count < RVT_HEX_VALUE_LENGTH;
					 count++)
				{
					p_rvt_sys_time[sys_time_length + count] = Num2Char[(UINT8) ((current_time << (count << 2)) >> 28)];	
				}
				sys_time_length += RVT_HEX_VALUE_LENGTH;

				// Send message to the UART with byte stuffing
				nb_bytes_sent = 0;
				while (nb_bytes_sent < sys_time_length)
				{
					nb_bytes_sent += SER_tr_WriteNBytes (SER_LAYER_1,
														 (UINT8 *) p_rvt_sys_time + nb_bytes_sent,
														 sys_time_length - nb_bytes_sent);
				}

			#ifdef PSEUDO_MODEM_KEEPALIVE
				rvt_keepalive_process();
			#endif

			} // End of if (event & (RVF_TIMER_0_EVT_MASK))
		}
	#else
	
		// Start the 'Alive Polling Timer'
		#if (OP_WCP == 0)
		  rvf_start_timer (RVF_TIMER_0,
						   RVT_ALIVE_POLLING_TIME,
						   TRUE);
		#endif
		
		for (;
			 ;
			 )
		{
			// Infinite wait on 'Trace Task' mailbox or timer events
			event = rvf_wait ((1 << RVT_TRACE_MAILBOX) | (RVF_TIMER_0_EVT_MASK),
							  0);

			// Check for some messages lost
			if (((rvt_lost_msg_cpt.bit_mask).count >= RVT_MAX_LOST_TRACE_MSG) && (p_rvt_lost_msg))			
			{
				INT8    count           = 0;
				UINT8   lost_msg_length = RVT_LOST_MSG_LENGTH;
				UINT32  lost_msg_cpt    = rvt_lost_msg_cpt.overall_value;

				// Append with the number of messages lost
				rvt_lost_msg_cpt.overall_value = 0;
				for (count = 0;
					 count < RVT_HEX_VALUE_LENGTH;
					 count ++)
				{
					p_rvt_lost_msg[lost_msg_length + count] = Num2Char[(UINT8) ((lost_msg_cpt << (count << 2)) >> 28)];
				}
				rvt_lost_msg_length += RVT_HEX_VALUE_LENGTH;

				// Append with the '\n' and '\r' characters for the hyper terminal
				p_rvt_lost_msg[lost_msg_length++] = '\n';
				p_rvt_lost_msg[lost_msg_length++] = '\r';

				// Send the message to the UART without byte stuffing
				nb_bytes_sent = 0;
				while (nb_bytes_sent < lost_msg_length)
				{
					nb_bytes_sent += SER_tr_WriteNChars (SER_LAYER_1,
														 (UINT8 *) p_rvt_lost_msg + nb_bytes_sent,
														 lost_msg_length - nb_bytes_sent);
				}

			} // End of if ((rvt_lost_msg_cpt.bit_mask).count >= RVT_MAX_LOST_TRACE_MSG)

			if (event & EVENT_MASK (RVT_TRACE_MAILBOX))
			{
				T_RV_HDR  *msg = NULL;

				// Read the message from the mailbox
				if ((msg = (T_RV_HDR *) rvf_read_mbox (RVT_TRACE_MAILBOX)) != NULL)
				{
					if (msg->msg_id == RVT_TRACE_RQST_ID)
					{
						UINT32  msg_length = 0;

						// Get the length
						msg_length = ((T_RVT_TRACE_RQST *) msg)->msg_length;

						// Send message to the UART without byte stuffing
						nb_bytes_sent = 0;
						while (nb_bytes_sent < msg_length)
						{
							nb_bytes_sent += SER_tr_WriteNChars (SER_LAYER_1,
																 msg + RVT_HEADER_SIZE + nb_bytes_sent,
																 msg_length - nb_bytes_sent);
						}

						// Append with the '\n' and '\r' characters for the hyper terminal
						msg_length        = 0;
						msg[msg_length++] = '\n';
						msg[msg_length++] = '\r';

						// Send message to the UART without byte stuffing
						nb_bytes_sent = 0;
						while (nb_bytes_sent < msg_length)
						{
							nb_bytes_sent += SER_tr_WriteNChars (SER_LAYER_1,
																 msg + nb_bytes_sent,
																 msg_length - nb_bytes_sent);
						}

						// Deallocate the buffer
						rvf_free_buf (msg);

					} // End of if (msg->msg_id == RVT_TRACE_RQST_ID)

					else
					{
						// Increment the number of messages lost. Is the buffer
						// corrupted?
						(rvt_lost_msg_cpt.bit_mask).count++;
						(rvt_lost_msg_cpt.bit_mask).unknown_request = 1;
					}

				} // End of if (msg != NULL)

				else
				{
					// Increment the number of messages lost. Is the buffer
					// corrupted?
					(rvt_lost_msg_cpt.bit_mask).count++;
					(rvt_lost_msg_cpt.bit_mask).message_empty = 1;
				}

			}  // End of if (event & EVENT_MASK (RVT_TRACE_MAILBOX))

			if ((event & (RVF_TIMER_0_EVT_MASK)) && (p_rvt_sys_time))
			{
				UINT8   count           = 0;
				UINT8   sys_time_length = RVT_SYS_TIME_LENGTH;
				UINT32  current_time    = rvf_get_tick_count ();

				// Append with the system time
				for (count = 0;
					 count < RVT_HEX_VALUE_LENGTH;
					 count++)
				{
					p_rvt_sys_time[sys_time_length + count] = Num2Char[(UINT8) ((current_time << (count << 2)) >> 28)];	
				}
				sys_time_length += RVT_HEX_VALUE_LENGTH;

				// Append with the '\n' and '\r' characters for the hyper terminal
				p_rvt_sys_time[sys_time_length++] = '\n';
				p_rvt_sys_time[sys_time_length++] = '\r';

				// Send message to the UART without byte stuffing
				nb_bytes_sent = 0;
				while (nb_bytes_sent < sys_time_length)
				{
					nb_bytes_sent += SER_tr_WriteNChars (SER_LAYER_1,
														 (UINT8 *) p_rvt_sys_time + nb_bytes_sent,
														 sys_time_length - nb_bytes_sent);
				}

			} // End of if (event & (RVF_TIMER_0_EVT_MASK))
		}
	#endif
}	


/********************************************************************************/
/*                                                                              */
/*    Function Name:   rvt_RX_process                                           */
/*                                                                              */
/*    Purpose:         This function is called when characters are received     */
/*                     on the serial port on receive HISR.                      */
/*                                                                              */
/*    Input Parameters:                                                         */
/*        None.                                                                 */
/*                                                                              */
/*    Output Parameters:                                                        */
/*        None.                                                                 */
/*                                                                              */
/*    Global Parameters:                                                        */
/*        None.                                                                 */
/*                                                                              */
/*    Note:                                                                     */
/*        None.                                                                 */
/*                                                                              */
/********************************************************************************/
void rvt_RX_process (void)
{
	UINT32        bytesRead;
	static UINT8  inBuffer[255];

	#ifdef FRAMING_PROTOCOL
		BOOL                      eof              = 0;
		static UINT8              rcv_state        = RVT_WAIT_FOR_HEADER;
		static UINT32             total_bytesRead  = 0;
		static RVT_CALLBACK_FUNC  rx_callback_func = NULL;

		// Get all bytes from the UART RX FIFO
		for (;
			 ;
			 )
		{
			// Read and destuff the UART RX FIFO and fill inBuffer with received
			// bytes
			bytesRead = SER_tr_ReadNBytes (SER_LAYER_1,
										   (char *) (inBuffer + total_bytesRead),
										   sizeof (inBuffer) - total_bytesRead,
										   &eof);

			// Check for the header. Hence, get the sendee
			if ((rcv_state == RVT_WAIT_FOR_HEADER) && \
				(bytesRead) && \
				!(total_bytesRead))
			{
				if ((inBuffer[0] >= RVT_RV_HEADER) &&
				    (inBuffer[0] <= RVT_KEEPALIVE_HEADER))
				{
					UINT8  idtab = 0;
				
					// Search for the ID in the table
					for (idtab = 0;
						 rvt_user_db[idtab].user_id != RVT_INVALID_HEADER;
						 idtab++)
					{
						if (rvt_user_db[idtab].user_id == inBuffer[0])
						{
							rx_callback_func = rvt_user_db[idtab].rx_callback_func;
							break;
						}
					}
					rcv_state = RVT_WAIT_FOR_DATA;
				}
			}

			// Update the total number of bytes read, regarding the current frame 
			total_bytesRead += bytesRead;

			// Call the corresponding callback function when a complete message is
			// received (eof odd)
			if (eof & 0x01)
			{
				// Invoke the callback function
				if (rx_callback_func != NULL)
				{
					rx_callback_func ((T_RVT_BUFFER) (inBuffer + 1),
									  total_bytesRead - 1);
					rx_callback_func = NULL;
				}

				// Wait for the next frame to come
				rcv_state       = RVT_WAIT_FOR_HEADER;
				total_bytesRead = 0;
			}

			// inBuffer may be full due to some synchro lost problems
			else if (total_bytesRead == sizeof (inBuffer))
			{
				// If still waiting for the header, discard received characters and
				// reset static variables for the next frame to come
				if (rcv_state == RVT_WAIT_FOR_HEADER)
				{
					total_bytesRead = 0;
					break;
				}

				// Just discard characters received as payload
				total_bytesRead = sizeof (inBuffer[0]);
			}

			// Proceed with the next concatenated frame whether more bytes left
			if (eof > 1)
			{
				continue;
			}
			break;
		}
	#else

		// Read the UART RX FIFO and fill inBuffer with received bytes
		bytesRead = SER_tr_ReadNChars (SER_LAYER_1,
									   (char *) inBuffer,
									   sizeof (inBuffer));

		// Invoke the Testmode callback function : this is the only one able,
		// for the moment, to send an external command !!  WARNING : This
		// should be the same name than the one already registered in
		// create_RVtasks.c.
		tm_receive ((T_RVT_BUFFER) inBuffer,
					bytesRead);
	#endif
}



/********************************************************************************/
/*                                                                              */
/*    Function Name:   rvt_activate_RX_HISR                                     */
/*                                                                              */
/*    Purpose:         This function is called when an RX interrupt occurs.     */
/*                                                                              */
/*    Input Parameters:                                                         */
/*        None.                                                                 */
/*                                                                              */
/*    Output Parameters:                                                        */
/*        None.                                                                 */
/*                                                                              */
/*    Global Parameters:                                                        */
/*        None.                                                                 */
/*                                                                              */
/*    Note:                                                                     */
/*        None.                                                                 */
/*                                                                              */
/********************************************************************************/
void rvt_activate_RX_HISR (void)                                    
{                                                         
	NU_Activate_HISR (&TI_rcv_HISR);
}