line source
/*
+-----------------------------------------------------------------------------
| Project :
| Modul : J:\g23m-aci\aci_ext\ati_ext_mech.c
+-----------------------------------------------------------------------------
| Copyright 2002 Texas Instruments Berlin, AG
| All rights reserved.
|
| This file is confidential and a trade secret of Texas
| Instruments Berlin, AG
| The receipt of or possession of this file does not convey
| any rights to reproduce or disclose its contents or to
| manufacture, use, or sell anything it may describe, in
| whole, or in part, without the specific written consent of
| Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
| Purpose : This is the implementation of the AT command extension mechanism. Customers
| can implement their own handling of extension AT comannds here.
+-----------------------------------------------------------------------------
*/
#ifndef ATI_EXT_MECH_C
#define ATI_EXT_MECH_C
#include "aci_all.h"
#include "aci_cmh.h"
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "aci_lst.h"
#include "ati_int.h"
#include "ati_ext_mech.h"
#ifdef FF_BAT
#include "aci_bat_ext.h"
#endif
/*==== CONSTANTS ==================================================*/
#define EXT_ATD "EXT: D, I"
#define EXT_ATCFUN "EXT: +CFUN, I"
#define EXT_ATCOPS_START "EXT: +COPS, I"
#define EXT_ATCOPS_STOP "EXT: +COPS, O"
#define EXT_ENTER "EXT: I"
#define EXT_LEAVE "EXT: O"
#define EXT_UNEXPCTD "EXT: E"
#define EXT_DIAL_VOICE_PASS "DVCP"
#define EXT_MAX_BUF_LEN 41
#define EXT_VOICE_DELIMITER ';'
/*==== EXTERNALS ======================================================*/
/*==== LOCALS =========================================================*/
/*==== EXPORT ======================================================*/
EXTERN UBYTE src_id_ext; /* this source runs currently an extension command */
/*==== TYPES ======================================================*/
/*
#ifndef WIN32
extern USHORT IQ_GetBuild(void);
#ifndef ALR
extern USHORT IQ_GetPoleStarVersion(void);
#endif
extern USHORT IQ_GetJtagId(void);
extern USHORT IQ_GetRevision(void);
#endif*/
/*==== VARIABLES ==================================================*/
LOCAL CHAR extDialNum[MAX_CC_ORIG_NUM_LEN];
/* number to be dialled during testing */
LOCAL T_ACI_AT_CMD currAbrtCmd = AT_CMD_NONE;
/* used for indicating abort of */
/* asynchronous command handling */
LOCAL T_ACI_AT_CMD currExtCmd_v2 = AT_CMD_NONE;
/* used for indicating asynchronous */
/* command handling */
LOCAL SHORT extCallId_v2 = ACI_NumParmNotPresent;
/* identifier of the call which was */
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8403) MODULE : TIL_CSF |
| STATE : code ROUTINE : cmh_show_version |
+--------------------------------------------------------------------+
PURPOSE : Trace Layer 1 DSP version numbers
*/
/*
#ifndef WIN32
static void jtagid_to_chipset (USHORT jtagid, CHAR *chipset)
{
switch (jtagid) {
case 0xB268:
strcpy (chipset, "Hercules");
break;
case 0xB2B5:
strcpy (chipset, "Ulysse 1Mbits rev. B");
break;
case 0xB335:
strcpy (chipset, "Ulysse 1Mbits rev. A");
break;
case 0xB334:
strcpy (chipset, "Ulysse 2Mbits");
break;
case 0xB393:
strcpy (chipset, "Ulysse G1");
break;
case 0xB396:
strcpy (chipset, "Calypso rev. B");
break;
case 0xB2AC:
// Samson and Calypso rev. A share the same JTAG ID.
#if (CHIPSET != 7)
strcpy (chipset, "Samson");
#else
strcpy (chipset, "Calypso rev. A");
#endif
break;
default:
strcpy (chipset, "Unknown");
break;
}
}
*/
/*
GLOBAL void cmh_show_version (UBYTE src_id )
{
#ifndef ALR
CHAR buf[80];
USHORT build, hw, rev;
#else
CHAR buf[160];
CHAR chipset[25];
#endif
USHORT jtag;
UCHAR size;
CHAR *output;*/
/*
* Retrieve hardware JTAG ID info
*/
/* jtag = IQ_GetJtagId();
#ifndef ALR
build = IQ_GetBuild();
hw = IQ_GetPoleStarVersion();
rev = IQ_GetRevision();
sprintf (buf, "Build %d, Silicon Revision %04X/%04X/%04X",
build, hw, jtag, rev);
#else
jtagid_to_chipset (jtag, chipset);
sprintf (buf,
"Chipset Version:\n\r\t%s\n\rS/W Versions:\n\n\r\tTI Layer1\t\t%4X\n\r\tCondat G.2-3\t\t %3X\n\r\tTI Ref. Design Release\t %3X",
chipset,
SOFTWAREVERSION,
G23VERSION,
SYSTEMVERSION);
#endif
// Format output as a list of Pascal-like strings
size = strlen(buf);
output[0] = size;
strcpy(&(output[1]), buf);
output[size+1] = (CHAR) 0xFF;
sEXT_Output (src_id, ATI_EXT_CMPL_LINE, output);
}
#endif
*/
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : aci_to_ext_return_map |
+--------------------------------------------------------------------+
PURPOSE : This function is used to map the ACI return values to the EXT return values
*/
LOCAL T_ATI_EXT_RETURN aci_to_ext_return_map (T_ACI_RETURN aci_return)
{
TRACE_FUNCTION ("aci_to_ext_return_map ()");
switch (aci_return)
{
case AT_FAIL: return ATI_EXT_FAIL;
case AT_CMPL: return ATI_EXT_CMPL;
case AT_EXCT: return ATI_EXT_EXCT;
case AT_BUSY: return ATI_EXT_BUSY;
default: return ATI_EXT_FAIL;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : aci_to_ext_return_map |
+--------------------------------------------------------------------+
PURPOSE : This function is used to map the ATI return values to the EXT return values
*/
LOCAL T_ATI_EXT_RETURN ati_to_ext_return_map (T_ATI_RSLT ati_return)
{
TRACE_FUNCTION ("ati_to_ext_return_map ()");
switch (ati_return)
{
case ATI_FAIL: return ATI_EXT_FAIL;
case ATI_CMPL: return ATI_EXT_CMPL;
case ATI_EXCT: return ATI_EXT_EXCT;
case ATI_BUSY: return ATI_EXT_BUSY;
default: return ATI_EXT_FAIL;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : ext_LeaveEXT_v2 |
+--------------------------------------------------------------------+
PURPOSE : This function is called in case the extensin mechansim
should be left finally.
*/
LOCAL void ext_LeaveEXT_v2 ( )
{
/*indicating that no extended AT command is still in progress*/
currExtCmd_v2 = AT_CMD_NONE;
/*indicate end of extended command handling to the AT interpreter*/
/* sEXT_Finit();*/
sEXT_Indication (src_id_ext, EXT_LEAVE );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_EXTS |
| STATE : code ROUTINE : ext_ContinueTest_v2 |
+--------------------------------------------------------------------+
PURPOSE : This function is called in case the AT extension
procedure should be continued.
<id>: identifies the specific procedure to be continued
*/
LOCAL void ext_ContinueTest_v2 ( CHAR* id )
{
T_ACI_RETURN rslt;
if ( strcmp ( id, EXT_DIAL_VOICE_PASS ) EQ 0 )
{
T_ACI_D_TOC callType = D_TOC_Data;
if ( extDialNum [strlen ( extDialNum ) - 1] EQ EXT_VOICE_DELIMITER )
callType = D_TOC_Voice;
extDialNum[strlen ( extDialNum ) - 1] = '\0';
rslt = sAT_Dn ( CMD_SRC_LCL,
extDialNum,
D_CLIR_OVRD_Default,
D_CUG_CTRL_NotPresent,
callType );
if ( rslt EQ AT_EXCT )
{
/*
* generate some output at the AT interface
*/
sEXT_Indication (src_id_ext, EXT_ATD);
/*
* indicating that an extended AT command is still in progress
*/
currExtCmd_v2 = AT_CMD_D;
}
else if (rslt EQ AT_CMPL)
{
sEXT_Confirm (src_id_ext);
ext_LeaveEXT_v2 ();
}
else
{
rCI_PlusCME ( AT_CMD_EXT, CME_ERR_Unknown );
ext_LeaveEXT_v2 ();
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_EXTS |
| STATE : code ROUTINE : ext_OK_v2 |
+--------------------------------------------------------------------+
PURPOSE : This function is called in case the positive
result of the asynchronous command handling is available.
<cmdId>: command identity
*/
GLOBAL void ext_OK_v2 ( T_ACI_AT_CMD cmdId )
{
T_ACI_RETURN rslt;
if ( cmdId EQ AT_CMD_CFUN AND currAbrtCmd EQ AT_CMD_NONE )
{
rslt = sAT_PlusCOPS ( CMD_SRC_LCL,
COPS_MOD_Auto,
COPS_FRMT_NotPresent,
NULL );
if ( rslt EQ AT_EXCT )
{
/*
* generate some output at the AT interface
*/
sEXT_Output (src_id_ext, ATI_EXT_CMPL_LINE, EXT_ATCOPS_START);
/*
* indicating that an extended AT command is still in progress
*/
currExtCmd_v2 = AT_CMD_COPS;
}
else
{
ext_LeaveEXT_v2 ();
sEXT_Error ( AT_CMD_EXT, CME_ERR_Unknown);
}
}
else if ( cmdId EQ AT_CMD_COPS AND currAbrtCmd EQ AT_CMD_NONE )
{
currExtCmd_v2 = AT_CMD_NONE;
/*
* generate some output at the AT interface
*/
sEXT_Indication (AT_CMD_EXT, EXT_ATCOPS_STOP );
#ifndef WIN32
ext_ContinueTest_v2 ( EXT_DIAL_VOICE_PASS );
#endif
}
else if ( cmdId EQ AT_CMD_D AND currAbrtCmd EQ AT_CMD_NONE )
{
extCallId_v2 = 1;
ext_LeaveEXT_v2 ();
sEXT_Confirm( AT_CMD_EXT );
}
else if ( currAbrtCmd NEQ AT_CMD_NONE )
{
currAbrtCmd = AT_CMD_NONE;
ext_LeaveEXT_v2 ();
sEXT_Confirm( AT_CMD_EXT );
}
else
{
/*generate some output at the AT interface*/
sEXT_Output(src_id_ext, ATI_EXT_CMPL_LINE, EXT_UNEXPCTD);
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : rEXT_Init |
+--------------------------------------------------------------------+
PURPOSE : This function is called in the ATI initialization process.
*/
GLOBAL T_ATI_EXT_RETURN rEXT_Init ()
{
#ifdef _SIMULATION_
static CHAR *cmd_list[] = {"$A", "$B", "%TA", NULL};
#else /*_SIMULATION_*/
static CHAR *cmd_list[] = {NULL};
//static CHAR *cmd_list[] = {"$A", "$B", "%TA", NULL};
#endif /*_SIMULATION_*/
TRACE_FUNCTION ("rEXT_Init ()");
if (sEXT_Init (cmd_list) EQ ATI_CMPL)
return ATI_EXT_CMPL;
else
return ATI_EXT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : rAT_EXT |
+--------------------------------------------------------------------+
PURPOSE : This function is called by ATI in case of the detection of an
unknown command.
<src_id> : source Id
<cmd> : remaining unparsed command string.
*/
GLOBAL T_ATI_EXT_RETURN rEXT_Execute (UBYTE src_id, CHAR *cmd)
{
TRACE_FUNCTION ("rEXT_Execute ()");
/*example how to process the command AT$A*/
if (*cmd EQ '$')
{
cmd++;
switch (*cmd++)
{
T_ATI_RSLT output_rslt;
case 'A': /*print out string "Hello World"*/
output_rslt = ATI_FAIL;
if (*cmd EQ '\0')
output_rslt = sEXT_Output (src_id, ATI_EXT_CMPL_LINE, "Hello World!");
if (*cmd EQ '=' AND *(cmd+1) EQ '0')
output_rslt = sEXT_Output (src_id, ATI_EXT_CMPL_LINE, "AT$A is set to off.");
if (*cmd EQ '=' AND *(cmd+1) EQ '1')
output_rslt = sEXT_Output (src_id, ATI_EXT_CMPL_LINE, "AT$A is set to on.");
if (*cmd EQ '=' AND *(cmd+1) EQ '?')
output_rslt = sEXT_Output (src_id, ATI_EXT_CMPL_LINE, "$A: 0, 1");
return (ati_to_ext_return_map (output_rslt));
case 'B': /*print out a complete string part by part*/
sEXT_Output(src_id, ATI_EXT_PART_BEGIN, "This is ");
sEXT_Output(src_id, ATI_EXT_PART_LINE, "a complete ");
sEXT_Output(src_id, ATI_EXT_PART_LAST, "line. ");
return (ATI_EXT_CMPL);
}
}
/*
* example how to process the command AT% commands
*/
if (*cmd EQ '%')
{
sEXT_Output (src_id, ATI_EXT_CMPL_LINE, EXT_ENTER);
cmd++;
switch (*cmd)
{
case 'T':
case 't':
/*Enables RTC or AUDIO tests */
cmd++;
if (!strncmp(cmd, "A", 1) || !strncmp(cmd, "a", 1))
{
sEXT_Output (src_id, ATI_EXT_CMPL_LINE, "Performing Audio Tests");
}
else
{
if (!strncmp(cmd, "R", 1) || !strncmp(cmd, "r", 1))
{
sEXT_Output (src_id, ATI_EXT_CMPL_LINE, "Performing RTC Tests");
}
else
return( AT_FAIL );
}
return( AT_CMPL );
default:
return ( AT_FAIL );
}
}
else if ( *cmd EQ 'D' )
{
T_ACI_RETURN rslt;
TRACE_EVENT ("ATD in extension mechanism.");
strncpy ( extDialNum, cmd + 1, MINIMUM ( MAX_CC_ORIG_NUM_LEN - 1, strlen (cmd) - 1 ) );
extDialNum[MINIMUM ( MAX_CC_ORIG_NUM_LEN - 1, strlen (cmd) - 1 )] = '\0';
rslt = sAT_PlusCFUN ( CMD_SRC_LCL, CFUN_FUN_Full, CFUN_RST_NotPresent );
if ( rslt EQ AT_EXCT )
{
/*generate some output at the AT interface*/
sEXT_Output (src_id, ATI_EXT_CMPL_LINE, EXT_ATCFUN);
/*indicating that an extended AT command is still in progress*/
currExtCmd_v2 = AT_CMD_CFUN;
}
if (rslt EQ AT_FAIL)
{
sEXT_Indication(src_id, EXT_LEAVE);
sEXT_Error (src_id, CME_ERR_Unknown);
return ATI_EXT_FAIL;
}
else if (rslt EQ AT_CMPL)
{
ext_LeaveEXT_v2 ();
return ATI_EXT_CMPL;
}
return ( aci_to_ext_return_map (rslt));
}
return ATI_EXT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : rEXT_Abort |
+--------------------------------------------------------------------+
PURPOSE : This function is called by the ATI in case of aborting a pending
extension command.
*/
GLOBAL T_ATI_EXT_RETURN rEXT_Abort (UBYTE src_id)
{
T_ACI_RETURN rslt = AT_CMPL;
TRACE_FUNCTION ("rEXT_Abort ()");
/* call the abort function if necessary */
if ( currExtCmd_v2 NEQ AT_CMD_NONE )
rslt = sAT_Abort (src_id, currExtCmd_v2 );
switch ( rslt )
{
case ( AT_CMPL ):
{
currExtCmd_v2 = AT_CMD_NONE;
sEXT_Indication(src_id, cmdAtError(atOk));
ext_LeaveEXT_v2();
}
break;
case ( AT_EXCT ):
{
currExtCmd_v2 = AT_CMD_ABRT;
}
break;
default:
{
/* do nothing */
}
break;
}
return aci_to_ext_return_map (rslt);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : rEXT_Signal |
+--------------------------------------------------------------------+
PURPOSE : This function is called by the ATI when an extension signal is received.
*/
GLOBAL T_ATI_EXT_RETURN rEXT_Signal (T_ACI_EXT_IND *aci_ext_ind)
{
TRACE_FUNCTION ("rEXT_Signal ()");
/*The handling of the extension signal can be done here.*/
sEXT_Output (CMD_SRC_ATI_5, ATI_EXT_CMPL_LINE, "This is an extension signal.");
return ATI_EXT_CMPL;
}
#ifdef FF_BAT
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : ATI_EXT_MECH |
| STATE : code ROUTINE : rEXT_Response_BAT |
+--------------------------------------------------------------------+
PURPOSE : This function is called by BAT Module when customer stuff
is asynchronously received.
*/
GLOBAL T_ATI_EXT_RETURN rEXT_Response_BAT (UBYTE src_id, T_BAT_cmd_response *resp)
{
}
#endif
#endif /* ATI_EXT_MECH_C */
