line source
/*
+--------------------------------------------------------------------+
/*
+-------------------------------------------------------------------+
| PROJECT: GSM-F&D (8411) $Workfile:: cst_pei.c $|
| $Author:: Be $ CONDAT GmbH $Revision:: 14 $|
| CREATED: 01.02.99 $Modtime:: 14.02.00 12:14 $|
| STATE : code |
+--------------------------------------------------------------------+
MODULE : CST_PEI
PURPOSE : This Modul defines the process body interface for the
component CST of the mobile station.
EXPORT : pei_create - Create the Protocol Stack Entity
pei_init - Initialize Protocol Stack Entity
pei_primitive - Process Primitive
pei_timeout - Process Timeout
pei_exit - Close resources and terminate
pei_run - Process Primitive
pei_config - Dynamic Configuration
pei_monitor - Monitoring of physical Parameters
*/
#ifndef CST_PEI_C
#define CST_PEI_C
#endif
#include "config/swconfig.cfg"
#include "config/chipset.cfg"
#define ENTITY_CST
/*==== INCLUDES ===================================================*/
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "typedefs.h"
#include "vsi.h"
#include "custom.h"
#include "gsm.h"
#include "prim.h"
#include "cst/cnf_cst.h"
#include "cst/cus_cst.h"
#include "cst/mon_cst.h"
#include "tok.h"
#include "p_cst.h"
#include "cst/cst.h"
#include "rx.h"
#include "audio.h"
/*==== CONSTANTS ==================================================*/
// token processing
#define ERROR -1
#define EOS 1
#define COMMA 2
#define EQUAL 3
#define IDENT 4
#define STRING 5
#define LBRACK 6
#define RBRACK 7
/*==== EXPORT =====================================================*/
extern void CST_stack_trace(void);
int cst_gsm_parameters(TOK_DCB *dcb);
extern void l1_cst_l1_parameters(char*);
extern void csf_adc_start (UBYTE tx_flag, UBYTE traffic_period, UBYTE idle_period);
extern void spi_adc_on (void);
GLOBAL T_HANDLE t_adc_timer = VSI_ERROR;
GLOBAL T_HANDLE hCommPL = VSI_ERROR; /* PL Communication */
GLOBAL T_HANDLE hCommL1 = VSI_ERROR; /* L1 Communication */
T_HANDLE cst_handle;
GLOBAL UBYTE extDisplay = 0;
EXTERN UBYTE audio_is_free;
/*==== PRIVATE ====================================================*/
LOCAL const void pei_not_supported (void *data);
#ifdef OPTION_RELATIVE
LOCAL ULONG offset;
#endif
/*==== VARIABLES ==================================================*/
LOCAL USHORT t_flag = 0;
LOCAL BOOL exit_flag = FALSE;
LOCAL BOOL first_access = TRUE;
LOCAL T_MONITOR cst_mon;
/*==== FUNCTIONS ==================================================*/
LOCAL const T_FUNC cst_table[] =
{
MAK_FUNC_0 ( csf_adc_process , CST_ADC_IND )
};
/*==== PROTOTYPES==================================================*/
#if defined (_TMS470)
static SHORT cst_tok_gettok (TOK_DCB *dcb, char ** token);
static SHORT cst_tok_value (TOK_DCB *dcb, char * value []);
static int cst_tokenizer_has_more_data(const TOK_DCB *dcb);
static SHORT cst_tok_issep (char c);
static void cst_tok_init (char * s, TOK_DCB *dcb, char *buf, int buf_len);
static SHORT cst_get_values(TOK_DCB *dcb, char *value[]);
static int cst_getbyte(TOK_DCB *dcb);
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_primitive |
+--------------------------------------------------------------------+
PURPOSE : This function processes protocol specific primitives.
*/
LOCAL SHORT pei_primitive (void * ptr)
{
T_PRIM *prim = ptr;
if (prim NEQ NULL)
{
USHORT opc = prim->custom.opc;
USHORT n;
const T_FUNC *table;
VSI_PPM_REC ((T_PRIM_HEADER*)prim, __FILE__, __LINE__);
switch (opc & OPC_MASK)
{
case CST_DL: table = cst_table; n = TAB_SIZE (cst_table); break;
default : table = NULL; n = 0; break;
}
if (table != NULL )
{
if ((opc & PRM_MASK) < n)
{
table += opc & PRM_MASK;
#ifdef PALLOC_TRANSITION
P_SDU(prim) = table->soff ? (T_sdu*) (((char*)&prim->data) + table->soff) : 0;
P_LEN(prim) = table->size + sizeof (T_PRIM_HEADER);
#endif
JUMP (table->func) (P2D(prim));
}
else
{
pei_not_supported (P2D(prim));
}
return PEI_OK;
}
#ifdef GSM_ONLY
PFREE (P2D(prim))
return PEI_ERROR;
#else
if (opc & SYS_MASK)
{
vsi_c_primitive (VSI_CALLER prim);
}
else
{
PFREE (P2D(prim))
return PEI_ERROR;
}
#endif
}
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_not_supported |
+--------------------------------------------------------------------+
PURPOSE : This function handles an unsupported primitive.
*/
LOCAL const void pei_not_supported (void *data)
{
TRACE_FUNCTION ("pei_not_supported()");
PFREE (data);
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_init |
+--------------------------------------------------------------------+
PURPOSE : This function initializes the protocol stack entity
*/
LOCAL SHORT pei_init (T_HANDLE handle)
{
cst_handle = handle;
TRACE_FUNCTION ("pei_init()");
exit_flag = FALSE;
if (hCommPL < VSI_OK)
{
if ((hCommPL = vsi_c_open (VSI_CALLER PL_NAME)) < VSI_OK)
{
return PEI_ERROR;
}
}
if (hCommL1 < VSI_OK)
{
if ((hCommL1 = vsi_c_open (VSI_CALLER L1_NAME)) < VSI_OK)
{
return PEI_ERROR;
}
}
vsi_t_start (VSI_CALLER CST_ADC_TIMER, 230); // equal to 50 TDMA frames
#if defined (_TMS470)
// Set the sleep mode authorized for the layer1 synchronous.
// Possible modes are :
// for CHIPSET = 0 : NO_SLEEP, SMALL_SLEEP, BIG_SLEEP.
// It is necessary to indicate in the prototype of power_down_config()
// function which clocks (amongst ARMIO_CLK, UWIRE_CLK, SIM_CLK and UART_CLK)
// to be stopped in case of BIG_SLEEP mode.
// With this default init, ARMIO_CLK, UWIRE_CLK, SIM_CLK and UART_CLK will be stopped
// in case of BIG_SLEEP mode, but it can be changed here.
// other CHIPSETs : NO_SLEEP, SMALL_SLEEP, BIG_SLEEP, DEEP_SLEEP, ALL_SLEEP.
// It is necessary to indicate in the prototype of power_down_config()
// function which clocks to be stopped in case of BIG_SLEEP mode,
// amongst ARMIO and UWIRE clocks.
// With this default init, UWIRE_CLK will always be stopped
// in case of BIG_SLEEP mode, but it can be changed here.
// The default configuration is ALL SLEEP. It can be changed in this init.
// WARNING !! THE SLEEP MODE SHOULD NOT BE MODIFIED ONCE THE SYSTEM INIT IS FINISHED !!
#if !defined (TI_VERSION)
#if (CHIPSET == 0)
power_down_config(NO_SLEEP, ARMIO_CLK | UWIRE_CLK | SIM_CLK | UART_CLK);
#elif ((CHIPSET == 2) || (CHIPSET == 3) || \
(CHIPSET == 5) || (CHIPSET == 6) || (CHIPSET == 7) || (CHIPSET == 8) || (CHIPSET == 10) || (CHIPSET == 11))
power_down_config(ALL_SLEEP, UWIRE_CLK_CUT);
#elif ((CHIPSET == 4) || (CHIPSET == 9))
power_down_config(NO_SLEEP, UWIRE_CLK_CUT);
#endif
#endif
#endif
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_timeout |
+--------------------------------------------------------------------+
PURPOSE : This function processes timeouts.
*/
LOCAL SHORT pei_timeout (USHORT index)
{
rx_timeout (index);
audio_timeout (index);
if (index EQ CST_ADC_TIMER)
{
// start the AD conversions in layer1 synchronous
// this function will send MMI_ADC_REQ primitive to L1A for test reason.
// The user has to implement it by himself in the MMI.
// The parameters are : tx_flag, traffic_period, idle_period.
// Please refer to the ADC specification for details.
// WCS Patch : Schedule ADC on RX and TX
#if (OP_WCP == 1)
csf_adc_start(1, 10, 1);
#else
csf_adc_start(0, 10, 1);
#endif
spi_adc_on();
}
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_exit |
+--------------------------------------------------------------------+
PURPOSE : This function closes all resources and terminates.
*/
LOCAL SHORT pei_exit (void)
{
TRACE_FUNCTION ("pei_exit()");
/*
* clean up communication
*/
vsi_c_close (VSI_CALLER hCommPL);
hCommPL = VSI_ERROR;
vsi_c_close (VSI_CALLER hCommL1);
hCommL1 = VSI_ERROR;
exit_flag = TRUE;
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_config |
+--------------------------------------------------------------------+
PURPOSE : Dynamic Configuration
*/
#if !defined (NCONFIG)
LOCAL KW_DATA kwtab[] = {
CST_CONFIG, ID_CONFIG,
CST_MUTE, ID_MUTE,
CST_GSM_PARAMETERS, ID_GSM_PARAMETERS,
CST_L1_PARAMETERS, ID_L1_PARAMETERS,
"", 0
};
GLOBAL KW_DATA partab[] = {
"", 0
};
#endif
GLOBAL SHORT pei_config (T_PEI_CONFIG inString)
{
#if !defined (NCONFIG)
char * s = inString;
SHORT valno;
USHORT keyno;
char * keyw;
char * val [10];
TOK_DCB tokenizer;
char token_buf[80];
SHORT token_type;
int error; /* terminate processing */
TRACE_FUNCTION ("pei_config()");
TRACE_FUNCTION (s);
cst_tok_init(s, &tokenizer, &token_buf[0], sizeof(token_buf));
/*
* Parse next keyword and number of variables
*/
error = 0;
while (!error && cst_tokenizer_has_more_data(&tokenizer))
{
token_type = cst_tok_gettok(&tokenizer, &keyw);
if (token_type != IDENT)
{
error = 1;
}
else
{
switch ((keyno = tok_key((KW_DATA *)kwtab, keyw)))
{
case ID_CONFIG:
valno = cst_get_values(&tokenizer, val);
if (valno EQ 3)
{
extDisplay = 1;
}
break;
case ID_MUTE:
valno = cst_get_values(&tokenizer, val); /* eat up rest of line */
/*
* FTA testcase 26.6.3.4 needs the the MS is in audio free
* environment. This config disables opening of the audio
* path.
*/
audio_is_free = FALSE;
break;
case ID_GSM_PARAMETERS:
cst_gsm_parameters(&tokenizer);
break;
case ID_L1_PARAMETERS:
/* pass parameters to L1 function for further process */
l1_cst_l1_parameters(s);
valno = cst_get_values(&tokenizer, val); /* eat up rest of line */
break;
default:
TRACE_ERROR ("[PEI_CONFIG]: Illegal Keyword");
break;
}
}
}
#endif
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CST_PEI |
| STATE : code ROUTINE : cst_pei_config |
+--------------------------------------------------------------------+
PURPOSE : Dynamic Configuration
*/
GLOBAL SHORT cst_pei_config ( char * inString, char * dummy )
{
pei_config ( inString );
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_monitor |
+--------------------------------------------------------------------+
PURPOSE : This function monitors physical parameters.
*/
LOCAL SHORT pei_monitor (void ** monitor)
{
TRACE_FUNCTION ("pei_monitor()");
cst_mon.version = VERSION_CST;
*monitor = &cst_mon;
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : pei_create |
+--------------------------------------------------------------------+
PURPOSE : This function creates the protocol stack entity.
*/
GLOBAL SHORT cst_pei_create (T_PEI_INFO **info)
{
static const T_PEI_INFO pei_info =
{
"CST",
{
pei_init,
pei_exit,
pei_primitive,
pei_timeout,
NULL, /* no signal function */
NULL, /* no run function */
pei_config,
pei_monitor,
},
1536, /* Stack Size */
10, /* Queue Entries */
55, /* Priority */
MAX_CST_TIMER, /* number of timer */
0x03 /* flags */
};
TRACE_FUNCTION ("pei_create()");
/*
* Close Resources if open
*/
if (first_access)
first_access = FALSE;
else
pei_exit ();
/*
* Export startup configuration data
*/
*info = (T_PEI_INFO *)&pei_info;
return PEI_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_tok_init |
+--------------------------------------------------------------------+
PURPOSE : Initialize token scanner.
*/
static void cst_tok_init (char * s, TOK_DCB *dcb, char *buf, int buf_len)
{
int i;
dcb->nexttok = dcb->tokbuf = buf;
// can't use strcpy since it stops at 0s
for (i=0; i<buf_len-1; i++)
{
dcb->tokbuf[i] = s[i];
}
dcb->tokbuf[buf_len-1] = '\0';
dcb->lastchar = 0;
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_get_values |
+--------------------------------------------------------------------+
*/
static SHORT cst_get_values(TOK_DCB *dcb, char *value[])
{
char * val; /* not identifier, so thrown away */
/*
* Check next token
*/
switch (cst_tok_gettok (dcb, &val))
{
/*
* No value present
*/
case COMMA:
return (0);
/*
* Value(s) follows
*/
case EQUAL:
return (cst_tok_value (dcb, value));
/*
* No value present and EOS
*/
case EOS:
dcb->nexttok = NULL;
return (0);
/*
* Syntax error
*/
default:
dcb->nexttok = NULL;
return (TOK_EOCS);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_tok_value |
+--------------------------------------------------------------------+
*/
static SHORT cst_tok_value (TOK_DCB *dcb, char * value [])
{
SHORT count;
SHORT tok;
SHORT inbrack;
char * val;
char * val2;
inbrack = 0;
/*
* Get next token
*/
tok = cst_tok_gettok (dcb, &val);
switch (tok)
{
case LBRACK:
inbrack++;
break;
case IDENT :
case STRING :
tok = cst_tok_gettok (dcb, &val2); /* val2 ignored since next tok */
if ((tok == COMMA) || (tok == EOS)) /* shouldn't be an IDENT */
{
/* just single value, return */
value[0] = val;
return (1);
}
else
{
/* error */
dcb->nexttok = NULL;
return (0);
}
case EOS :
default :
dcb->nexttok = NULL;
return (0);
}
/*
* Get first token of list
*/
tok = cst_tok_gettok (dcb, &val);
count = 0;
while (1)
{
if ((tok == IDENT) || (tok == STRING))
{
value[count++] = val;
}
else
{
dcb->nexttok = NULL;
return (0);
}
tok = cst_tok_gettok (dcb, &val);
switch (tok)
{
case COMMA:
break;
case RBRACK :
if (inbrack)
{
if (((tok = cst_tok_gettok (dcb, &val)) == COMMA) ||
(tok == EOS))
{
return (count);
}
}
/*
* Fall through
*/
default:
dcb->nexttok = NULL;
return (0);
}
tok = cst_tok_gettok (dcb, &val);
}
return (0);
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_tok_gettok |
+--------------------------------------------------------------------+
PURPOSE : Get list of values for token.
Return number of values found.
Formats: Value
(Value)
(Value, Value,...)
()
*/
static SHORT cst_tok_gettok (TOK_DCB *dcb, char ** token)
{
SHORT tok;
/* if previous token was IDENT, a '\0' was placed afterwards
* for string processing and the overwritten character was
* placed in lastchar. We now replace this character.
*/
if (dcb->lastchar)
{
*(dcb->nexttok) = dcb->lastchar;
dcb->lastchar = 0;
}
/*
* Skip leading white space
*/
while (isspace (*(dcb->nexttok)))
{
dcb->nexttok++;
}
* token = dcb->nexttok++;
switch (** token)
{
case '\0': /* End of string */
case '\n':
tok = EOS;
break;
case ',':
** token = '\0';
tok = COMMA;
break;
case '=':
** token = '\0';
tok = EQUAL;
break;
case '(':
case '<':
case '[':
** token = '\0';
tok = LBRACK;
break;
case ')':
case '>':
case ']':
** token = '\0';
tok = RBRACK;
break;
case '"':
/*
* Get first char of string
*/
* token = dcb->nexttok;
while ((*(dcb->nexttok) != '\0') && (*(dcb->nexttok) != '"'))
{
dcb->nexttok++;
}
if (*(dcb->nexttok) != '\0')
{
*(dcb->nexttok++) = '\0';
}
tok = STRING;
break;
default:
/*
* Read an identifier
*/
while ( !cst_tok_issep (*(dcb->nexttok)) )
{
dcb->nexttok++;
}
dcb->lastchar = *(dcb->nexttok);
*(dcb->nexttok) = '\0';
if (*token == dcb->nexttok)
{
/* no characters in identifier. Error in code! */
tok = ERROR;
}
else
{
tok = IDENT;
}
break;
}
return (tok);
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_tok_issep |
+--------------------------------------------------------------------+
PURPOSE : Return 1 if special character.
*/
static SHORT cst_tok_issep (char c)
{
switch (c)
{
case '\0' :
case '\n' :
case ',' :
case '=' :
case '(' :
case '<' :
case '[' :
case ')' :
case '>' :
case ']' :
case '"' : return (1);
default : return (isspace (c));
}
}
/* if string in tokenizer state has unprocessed tokens return 1 */
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_tokenizer_has_more_data |
+--------------------------------------------------------------------+
PURPOSE : Return 1 if string in tokenizer state has unprocessed tokens.
*/
static int cst_tokenizer_has_more_data(const TOK_DCB *dcb)
{
return (dcb->nexttok != NULL);
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_getbyte |
+--------------------------------------------------------------------+
*/
static int cst_getbyte(TOK_DCB *dcb)
{
if (dcb->nexttok)
{
return *(dcb->nexttok++);
}
else
{
return -1;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : XXX MODULE : CST_PEI |
| STATE : code ROUTINE : cst_gsm_parameters |
+--------------------------------------------------------------------+
*/
int cst_gsm_parameters(TOK_DCB *dcb)
{
unsigned char id;
char str[80];
int i;
// STRIP FIRST TWO DELIMITERS
{
char *tok_string;
if (cst_tok_gettok(dcb, &tok_string) != EQUAL)
{
return (0);
}
if (cst_tok_gettok(dcb, &tok_string) != LBRACK)
{
return (0);
}
}
// GET CONTROL ID
if ((id = cst_getbyte(dcb)) == -1)
{
// vsi_o_trace("CST", 0x08, "gsm_parameters() parser error: out of bytes");
return (0);
}
// STACK TRACE
else if (id == '1')
{
CST_stack_trace();
} //end else if (id == '1')
// Crash Me
else if (id == '2')
{
// No instruction before setting the reset vector
void (*reset_vector)() = (void (*)()) 0x3000000;
(*reset_vector)();
} //end else if (id == '2')
#if defined (ALR)
// Print Reg Copy
else if (id == '3')
{
extern int xdump_buffer;
int *xp = &xdump_buffer;
int magic_word;
// displays the 16 User mode 32bits registers saved on exception
// vsi_o_trace("CST", 0x08, "User mode registers [r0-r15] = ...");
for (i=0; i<4; i++)
{
sprintf(str, "%08x %08x %08x %08x", *(xp++), *(xp++),
*(xp++), *(xp++));
// vsi_o_trace("CST", 0x08, str);
}
// displays the User mode CPSR saved on exception
sprintf(str, "User mode CPSR = %08x", *(xp++));
// vsi_o_trace("CST", 0x08, str);
// displays the magic word and the index of vector taken
magic_word = *(xp++);
sprintf(str, "Magic Word + Index of Vector = %08x", magic_word);
// vsi_o_trace("CST", 0x08, str);
// displays the cause of the exception
magic_word &= 0x000F;
switch (magic_word) {
case 1:
// vsi_o_trace("CST", 0x08, "Exception: Undefined Instruction");
break;
case 2:
// vsi_o_trace("CST", 0x08, "Exception: Unexpected Software Interrupt");
break;
case 3:
// vsi_o_trace("CST", 0x08, "Exception: Abort Prefetch");
break;
case 4:
// vsi_o_trace("CST", 0x08, "Exception: Abort Data");
break;
case 5:
// vsi_o_trace("CST", 0x08, "Exception: Reserved");
break;
default:
break;
}
// displays the bottom 20 words of user mode stack saved on exception
// vsi_o_trace("CST", 0x08, "Bottom 20 words of User mode stack = ...");
for (i=0; i<5; i++)
{
sprintf(str, "%08x %08x %08x %08x", *(xp++), *(xp++),
*(xp++), *(xp++));
// vsi_o_trace("CST", 0x08, str);
}
} //end else if (id == '3')
// Clear Reg Copy
else if (id == '4')
{
extern int xdump_buffer;
int *xp = &xdump_buffer;
// Clears the 38 32bits registers saved on exception
for (i=0; i<38; i++)
{
*(xp+i) = 0;
}
// vsi_o_trace("CST", 0x08, "Registers Copy cleared ...");
} //end else if (id == '4')
#endif
#if (OP_WCP == 1)
#if (WCP_PROF == 1)
// Enable/disable MC profiler
else if (id == '5')
{
PR_EnableProfiler(0);
}
else if (id == '6')
{
PR_EnableProfiler(1);
power_down_config(0, 0x5ff); // disable sleep, which interferes with profiler
}
// Enable/disable CPU Meter
else if (id == '7')
{
PR_EnableCpuMeter(0);
}
else if (id == '8')
{
PR_EnableCpuMeter(1);
power_down_config(0, 0x5ff); // disable sleep, which interferes with CPU meter
}
#endif
#endif
// STRIP LAST DELIMITER
{
char *tok_string;
if (cst_tok_gettok(dcb, &tok_string) != RBRACK)
{
return (0);
}
}
} // end cst_gsm_parameters
/*
* Reach here if unexpected event occurs (e.g. Undefined instruction, Abort,
* out of memory); choose whether to restart or stay in datadump mode to find
* out cause of problem
*/
void exception_handler(void)
{
void (*jump_address)() = (void (*)()) ((unsigned)0x0);
(*jump_address)();
}
