Compal & Pirelli targets: APCOFF register setting
changed to match what the respective original firmwares set
line source
/*
+-----------------------------------------------------------------------------
| Project :
| Modul :
+-----------------------------------------------------------------------------
| 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 module defines the functions used by the command
| handler for GPRS session management ( SM ).
+-----------------------------------------------------------------------------
*/
#if defined (GPRS) && defined (DTI)
#ifndef CMH_SMF_C
#define CMH_SMF_C
#endif
#include "aci_all.h"
/*==== INCLUDES ===================================================*/
#include "gprs.h"
#include "dti.h" /* functionality of the dti library */
#include "aci_cmh.h"
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "aci_lst.h"
#include "aci.h"
#include "dti_conn_mng.h"
#include "dti_cntrl_mng.h"
#include "gaci.h"
#include "gaci_cmh.h"
#include "psa.h"
#include "psa_gmm.h"
#include "psa_sm.h"
#include "psa_gppp.h"
#include "phb.h"
#include "cmh.h"
#include "cmh_gmm.h"
#include "cmh_sm.h"
#include "cmh_gppp.h"
#include "gaci_srcc.h"
#include "psa_cc.h"
#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
#include "wap_aci.h"
#include "psa_tcpip.h"
#include "cmh_ipa.h"
#endif /* WAP || FF_GPF_TCPIP OR SAT E */
#ifdef SIM_TOOLKIT
#include "psa_sat.h"
#include "cmh_sat.h"
#endif
#include "psa_sim.h"
#include "cmh_sim.h"
#include "cmh_snd.h"
/* temp needed because of use of ATI functions here: should eventually disappear */
#include "ati_int.h"
#ifdef FF_GPF_TCPIP
#include "dcm_utils.h"
#include "dcm_state.h"
#include "dcm_env.h"
#endif
#include "dcm_f.h"
#include "psa_uart.h"
/*==== CONSTANTS ==================================================*/
/*==== TYPES ======================================================*/
typedef struct
{
T_CGEREP_EVENT event;
T_CGEREP_EVENT_REP_PARAM parm;
} T_CGERP_EVENT_BUFFER;
typedef enum
{
T_CDS_IDLE,
T_CDS_RUNNING
} T_CONTEXTS_DEACTIVATION_STATUS;
typedef struct
{
T_CONTEXTS_DEACTIVATION_STATUS state;
USHORT nsapi_set;
T_ACI_CMD_SRC srcId;
USHORT cid_set;
} T_CONTEXTS_DEACTIVATION_INFORMATION;
/*==== EXPORT =====================================================*/
/*==== VARIABLES ==================================================*/
GLOBAL SHORT nsapi_to_cid[SMH_NSAPI_MAX];
static T_CGSMS_SERVICE m_service;
static T_CGERP_EVENT_BUFFER gprs_event_buffer[GPRS_EVENT_REPORTING_BUFFER_SIZE];
static SHORT gprs_eb_current_p, gprs_eb_oldest_p;
static BOOL m_mt_te_link;
static BOOL call_waits_in_table;
static T_CONTEXTS_DEACTIVATION_INFORMATION working_cgact_actions;
/*==== FUNCTIONS ==================================================*/
/*
* functions for ATA and ATH
*/
/* GLOBAL BOOL cmhSM_sAT_H ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret ); */
/* GLOBAL BOOL cmhSM_sAT_A ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret ); */
static BOOL cmhSM_sAT_A_H_intern ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret, SHORT mode);
/*
* functions for DTI
*/
/* GLOBAL ULONG cmhSM_get_link_id_SNDCP_peer ( SHORT cid, T_SNDCP_PEER which ); */
/* GLOBAL BOOL cmhSM_context_deactivated ( USHORT nsapi_set ); */
/* GLOBAL T_ACI_RETURN cmhSNDCP_Disable( UBYTE dti_id ); */
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Init |
+--------------------------------------------------------------------+
PURPOSE : Fill variables for the own use with default values.
*/
GLOBAL void cmhSM_Init (void)
{
SHORT i = 0;
/* SM CMH global parameter */
smEntStat.curCmd = AT_CMD_NONE;
smEntStat.entOwn = OWN_NONE;
/* GPRS event reporting */
memset(gprs_event_buffer, 0, sizeof(T_CGERP_EVENT_BUFFER) * GPRS_EVENT_REPORTING_BUFFER_SIZE);
gprs_eb_current_p = 0;
gprs_eb_oldest_p = 0;
cmhSM_empty_call_table();
/* used for network requested context reactivation */
call_waits_in_table = FALSE;
working_cgact_actions.state = T_CDS_IDLE;
working_cgact_actions.nsapi_set = 0;
working_cgact_actions.srcId = CMD_SRC_NONE;
working_cgact_actions.cid_set = 0;
/*
* The following command has to be in the init and the reset function!!!
*
* Set all to zero in init. In the reset function is a contion action to
* not equeal zero.
*/
memset(pdp_context,0 , sizeof(T_GPRS_CONT_CLASS) * MAX_CID);
for (i = 0; i < MAX_CID; i++)
{
pdp_context[i].link_id_uart = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].link_id_new = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].link_id_sn = DTI_LINK_ID_NOTPRESENT;
}
m_mt_te_link = FALSE;
}
GLOBAL void cmhSM_ResetNonWorkingContexts( void )
{
SHORT i = 0, j = 0;
UBYTE srcId = srcId_cb;
UBYTE gprs_default_pco[] = {
0x80,0x80,0x21,0x10,0x01,0x01,0x00,0x10,0x81,0x06,
0x00,0x00,0x00,0x00,0x83,0x06,0x00,0x00,0x00,0x00
};
for (i = 0; i < MAX_CID; i++)
{
if ( (pdp_context[i].state EQ CS_UNDEFINED) OR (pdp_context[i].state EQ CS_DEFINED) )
{
for (j = 0; j < SMH_NSAPI_MAX; j++)
{
if ( nsapi_to_cid[j] EQ i + 1 )
{
nsapi_to_cid[j] = INVALID_CID;
}
}
memset(&pdp_context[i], 0, sizeof(T_GPRS_CONT_CLASS));
pdp_context[i].state = CS_UNDEFINED;
pdp_context[i].smreg_ti = UNDEFINED_TI;
pdp_context[i].link_id_uart = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].link_id_new = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].link_id_sn = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].user_pco.len = sizeof (gprs_default_pco);
memcpy (pdp_context[i].user_pco.pco, gprs_default_pco, sizeof (gprs_default_pco));
}
}
memset(work_cids, 0, sizeof(SHORT) * MAX_CID_PLUS_EINS);
cid_pointer = 0;
/* set default context parameter */
memset(&defaultCtx, 0, sizeof(T_GPRS_CONT_REC));
strcpy(defaultCtx.pdp_type,"IP" );
/* mode of CGAUTO*/
automatic_response_mode = 3;
m_service = CGSMS_SERVICE_CS_PREFERRED;
/* GPRS event reporting */
ati_user_output_cfg[srcId].CGEREP_mode = CGEREP_MODE_BUFFER;
ati_user_output_cfg[srcId].CGEREP_bfr = CGEREP_BFR_CLEAR;
sm_cgsms_service = CGSMS_SERVICE_CS_PREFERRED;
}
GLOBAL void cmhSM_Reset( void )
{
SHORT i = 0;
UBYTE gprs_default_pco[] = {
0x80,0x80,0x21,0x10,0x01,0x01,0x00,0x10,0x81,0x06,
0x00,0x00,0x00,0x00,0x83,0x06,0x00,0x00,0x00,0x00
};
/* SMF CMH local parameter */
memset(pdp_context, 0, sizeof(T_GPRS_CONT_CLASS) * MAX_CID);
for (i = 0; i < MAX_CID; i++)
{
pdp_context[i].state = CS_UNDEFINED;
pdp_context[i].smreg_ti = UNDEFINED_TI;
pdp_context[i].link_id_uart = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].link_id_new = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].link_id_sn = DTI_LINK_ID_NOTPRESENT;
pdp_context[i].user_pco.len = sizeof (gprs_default_pco);
memcpy (pdp_context[i].user_pco.pco, gprs_default_pco, sizeof (gprs_default_pco));
}
memset(work_cids, 0, sizeof(SHORT) * MAX_CID_PLUS_EINS);
for (i = 0; i < SMH_NSAPI_MAX; i++)
nsapi_to_cid[i] = INVALID_CID;
cid_pointer = 0;
/* set default context parameter */
memset(&defaultCtx, 0, sizeof(T_GPRS_CONT_REC));
strcpy(defaultCtx.pdp_type,"IP" );
/* mode of CGAUTO*/
automatic_response_mode = 3;
m_service = CGSMS_SERVICE_CS_PREFERRED;
/* GPRS event reporting */
ati_user_output_cfg[CMD_SRC_ATI].CGEREP_mode = CGEREP_MODE_BUFFER;
ati_user_output_cfg[CMD_SRC_ATI].CGEREP_bfr = CGEREP_BFR_CLEAR;
sm_cgsms_service = CGSMS_SERVICE_CS_PREFERRED;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_empty_call_table |
+--------------------------------------------------------------------+
PURPOSE : Fill variables for the own use with default values.
*/
GLOBAL void cmhSM_empty_call_table (void)
{
memset (gprs_call_table, 0, sizeof(T_GPRS_CALL_TABLE) *MAX_GPRS_CALL_TABLE_ENTRIES);
current_gprs_ct_index = 0;
gprs_ct_index = 0;
gprs_call_table[0].sm_ind.smreg_ti = UNDEFINED_TI;
}
/*
+-------------------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : code ROUTINE : cmhSM_getSrcIdOfRunningCGACTDeactivation |
+-------------------------------------------------------------------------------+
PURPOSE : Returns a source ID if the given cid is requested to deactivate
by +CGACT. The source ID indicates where the +CGACT was started.
*/
GLOBAL T_ACI_CMD_SRC cmhSM_getSrcIdOfRunningCGACTDeactivation(SHORT cid)
{
switch( working_cgact_actions.state )
{
case T_CDS_RUNNING:
if( (1 << (cid - 1) & working_cgact_actions.cid_set) OR
INVALID_NSAPI NEQ pdp_context[cid - 1].nsapi AND
(pdp_context[cid - 1].nsapi & working_cgact_actions.nsapi_set) )
{
return working_cgact_actions.srcId;
}
break;
case T_CDS_IDLE:
break;
}
return CMD_SRC_NONE;
}
/*
+-------------------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : code ROUTINE : cmhSM_getSrcIdOfRunningCGACTDeactivation |
+-------------------------------------------------------------------------------+
PURPOSE : Returns TRUE if +CGACT is running on the given cid -> NO_CARRIER
FASE if no CGACT was running on this cid -> CME_ERROR
*/
GLOBAL BOOL isContextDeactivationRequestedByCGACT(SHORT cid)
{
TRACE_FUNCTION("***isContextDeactivationRequestedByCGACT");
switch( working_cgact_actions.state )
{
case T_CDS_RUNNING:
if ( (1 << (cid - 1)) & working_cgact_actions.cid_set )
{
return TRUE;
}
}
return FALSE;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : code ROUTINE : cmhSM_connection_down |
+----------------------------------------------------------------------+
PURPOSE : Control the answer of context deactivations
started by an AT command.
*/
GLOBAL void cmhSM_connection_down( UBYTE dti_id )
{
SHORT cid = gaci_get_cid_over_dti_id( dti_id );
TRACE_FUNCTION("cmhSM_connection_down");
switch( working_cgact_actions.state )
{
case T_CDS_RUNNING:
TRACE_EVENT_P1("T_CDS_RUNNING, cid:%d", cid);
if ( (1 << (cid - 1)) & working_cgact_actions.cid_set )
{ /* nsapi deactivation is requested */
working_cgact_actions.cid_set &= (USHORT) ~(1U << (cid - 1));
TRACE_EVENT_P1("new set: %d",working_cgact_actions.cid_set);
if ( ! (working_cgact_actions.cid_set OR
working_cgact_actions.nsapi_set ) )
{
R_AT( RAT_OK, working_cgact_actions.srcId ) ( AT_CMD_CGACT );
working_cgact_actions.state = T_CDS_IDLE;
}
else
{
TRACE_EVENT_P2("NO OK: cid_set:%d, nsapi_set:%d",working_cgact_actions.cid_set,working_cgact_actions.nsapi_set);
}
}
else
{
TRACE_EVENT_P1("meets not the set: %d",working_cgact_actions.cid_set);
}
break;
case T_CDS_IDLE:
TRACE_EVENT("T_CDS_IDLE");
break;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_GetNewNSapi |
+--------------------------------------------------------------------+
PURPOSE : Give a free NSapi no. or invalid if all NSapi's are in use.
*/
LOCAL UBYTE cmhSM_GetNewNSapi ( void )
{
BYTE i = SMH_FIRST_FREE_NSAPIS;
TRACE_FUNCTION("cmhSM_GetNewNSapi");
while ( i <= SMH_LAST_FREE_NSAPIS AND nsapi_to_cid[i] NEQ INVALID_CID )
i++;
if ( i <= SMH_LAST_FREE_NSAPIS)
{
pdp_context[work_cids[cid_pointer] - 1].nsapi = i;
nsapi_to_cid[i] = work_cids[cid_pointer];
TRACE_EVENT_P1("new NSAPI: %d", i);
return i;
}
return INVALID_NSAPI;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_GiveNSapiFree |
+--------------------------------------------------------------------+
PURPOSE : Give a NSapi free after use.
*/
GLOBAL void cmhSM_GiveNSapiFree ( USHORT cid )
{
UBYTE *nsapi = &pdp_context[cid - 1].nsapi;
if ( *nsapi <= SMH_LAST_FREE_NSAPIS )
{
nsapi_to_cid[*nsapi] = INVALID_CID;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_contextDeactivated |
+--------------------------------------------------------------------+
PURPOSE : Detach mobile if necessary?
*/
GLOBAL void cmhSM_contextDeactivated ( void )
{
if ( ! cmhSM_isContextActive() )
{
cmhGMM_allContextsDeactivated();
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_pdp_type |
+--------------------------------------------------------------------+
PURPOSE : Give the PDP type of the current PDP context that will build.
*/
GLOBAL UBYTE cmhSM_Get_pdp_type ( void )
{
if (!strcmp(pdp_context[work_cids[cid_pointer] - 1].con.pdp_type, "IP"))
return IP_V_4;
return 0;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_pdp_address |
+--------------------------------------------------------------------+
PURPOSE : Give the PDP address of the current PDP context that will build.
*/
GLOBAL void cmhSM_Get_pdp_address ( T_pdp_address *pdp_address )
{
pdp_address->c_buff =
(UBYTE) cmhSM_pdp_address_to_ip(&pdp_context[work_cids[cid_pointer] - 1].con.pdp_addr, (UBYTE*) pdp_address->buff);
#ifdef _SIMULATION_
memset (pdp_address->buff + pdp_address->c_buff, 0, sizeof(pdp_address->buff) - pdp_address->c_buff);
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_pdp_address_to_ip |
+--------------------------------------------------------------------+
PURPOSE : Transform a PDP address to 4 BYTE IP form.
*/
GLOBAL SHORT cmhSM_pdp_address_to_ip ( T_PDP_ADDRESS *pdp_address, UBYTE *ip )
{
SHORT i = 0;
BOOL isDynamicIP = TRUE;
char *start = *pdp_address,
*end;
if ( **pdp_address )
{
for (i = 0; i < 4; i++)
{
ip[i] = (UBYTE) strtol(start, &end, 10);
start = end + 1;
/*
* dynamic ip patch
* 12.02.02 brz
*
* if it is a dynamic IP Address than the SM entity need the length set to zero
*/
if ( ip[i] )
{
isDynamicIP = FALSE;
}
}
if ( isDynamicIP EQ TRUE )
{
return 0;
}
else
{
return 4;
}
}
else
{
*ip = 0;
}
return 0;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_ip_to_pdp_address |
+--------------------------------------------------------------------+
PURPOSE : Transform a 4 BYTE IP form to the PDP address.
*/
GLOBAL void cmhSM_ip_to_pdp_address ( UBYTE *ip, T_PDP_ADDRESS pdp_address )
{
sprintf(pdp_address, "%03hd.%03hd.%03hd.%03hd", ip[0], ip[1], ip[2], ip[3] );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : convert_netaddr_to_apn |
+-------------------------------------------------------------------+
PURPOSE : converts a domain name into an APN
Technical Information:
The APN contains out of labels separated by dots.
(e.g. xxx.yyy.zzz)
This string representation must be translated to a network
representation.
The APN network representation contains out of a sequence of
a length field (not ASCII) followed by a ASCII string.
xxx.yyy.zzz => 3xxx3yyy3zzz
*/
LOCAL void convert_netaddr_to_apn ( T_smreg_apn *apn )
{
UBYTE counter = 0,
buffer = apn->buffer[0],
*pdest = apn->buffer + apn->c_buffer,
*psource = pdest - 1;
if(apn->c_buffer EQ 0)
{
return;
}
if(apn->c_buffer >= sizeof apn->buffer)
{
apn->c_buffer = 0;
TRACE_EVENT_P2 ("convert_netaddr_to_apn: array out of bounds exeption (%d >= %d)", apn->c_buffer, sizeof apn->buffer);
return;
}
/* The network representation is 1 byte longer. */
apn->c_buffer++;
/* A sentinel */
apn->buffer[0] = '.';
/* Algorithm: copy from back to front! */
while(pdest > apn->buffer )
{
counter = 0;
while(*psource NEQ '.')
{
*(pdest--) = *(psource--);
counter++;
}
*(pdest--) = counter;
psource--;
}
/* Correction according to the sentinel */
apn->buffer[1] = buffer;
apn->buffer[0] = ++counter;
/* Modify special empty APN to the need of SMREG_SAP */
if ((apn->c_buffer EQ 2) AND (apn->buffer[0] EQ 1) AND (apn->buffer[1] EQ 255))
{
apn->c_buffer = 1; /* Special SMREG_SAP indicating that there is an APN present but empty */
apn->buffer[0]= 0;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_smreg_apn |
+--------------------------------------------------------------------+
PURPOSE : Give the APN of the current PDP context that will build.
*/
GLOBAL void cmhSM_Get_smreg_apn ( T_smreg_apn *smreg_apn )
{
smreg_apn->c_buffer = strlen(pdp_context[work_cids[cid_pointer] - 1].con.apn);
strncpy((char *)smreg_apn->buffer, (const char *)pdp_context[work_cids[cid_pointer] - 1].con.apn, smreg_apn->c_buffer);
convert_netaddr_to_apn(smreg_apn);
#ifdef _SIMULATION_
memset (smreg_apn->buffer + smreg_apn->c_buffer, 0, sizeof(smreg_apn->buffer) - smreg_apn->c_buffer);
#endif
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_h_comp |
+--------------------------------------------------------------------+
PURPOSE : Give the h_comp of the current PDP context that will build.
*/
GLOBAL UBYTE cmhSM_Get_h_comp ( void )
{
return (UBYTE) pdp_context[work_cids[cid_pointer] - 1].con.h_comp;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_d_comp |
+--------------------------------------------------------------------+
PURPOSE : Give the d_comp of the current PDP context that will build.
*/
GLOBAL UBYTE cmhSM_Get_d_comp ( void )
{
return (UBYTE) pdp_context[work_cids[cid_pointer] - 1].con.d_comp;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_change_def_QOS |
+--------------------------------------------------------------------+
PURPOSE : Set the quality of service (requested) of default context.
*/
GLOBAL void cmhSM_change_def_QOS ( T_QOS *qos )
{
memcpy(&defaultCtx.qos, qos, sizeof(T_QOS));
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_change_def_QOS_min |
+--------------------------------------------------------------------+
PURPOSE : Set the quality of service (min.) of default context.
*/
GLOBAL void cmhSM_change_def_QOS_min ( T_QOS *qos )
{
memcpy(&defaultCtx.min_qos, qos, sizeof(T_QOS));
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Set_default_QOS |
+--------------------------------------------------------------------+
PURPOSE : Set the quality of service of the spezified PDP context
to default.
*/
GLOBAL void cmhSM_Set_default_QOS ( SHORT cid )
{
memcpy(&pdp_context[cid - 1].con.qos, &defaultCtx.qos, sizeof(T_QOS));
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Set_default_QOS |
+--------------------------------------------------------------------+
PURPOSE : Set the quality of service of the spezified PDP context
to default.
*/
GLOBAL void cmhSM_Set_default_QOS_min ( SHORT cid )
{
memcpy(&pdp_context[cid - 1].con.min_qos, &defaultCtx.min_qos, sizeof(T_QOS));
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_QOS |
+--------------------------------------------------------------------+
PURPOSE : Give the requested quality of service of the current
PDP context that will build.
*/
GLOBAL void cmhSM_Get_QOS ( T_smreg_qos *dest_qos )
{
T_QOS *source_qos = &pdp_context[work_cids[cid_pointer] - 1].con.qos;
dest_qos->preced = source_qos->preced;
dest_qos->delay = source_qos->delay;
dest_qos->relclass = source_qos->relclass;
dest_qos->peak = source_qos->peak;
dest_qos->mean = source_qos->mean;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_Get_QOS_min |
+--------------------------------------------------------------------+
PURPOSE : Give the minimum acceptable quality of service of the
current PDP context that will build.
*/
GLOBAL void cmhSM_Get_QOS_min ( T_smreg_min_qos *dest_qos_min )
{
T_QOS *source_qos = &pdp_context[work_cids[cid_pointer] - 1].con.min_qos;
dest_qos_min->preced = source_qos->preced;
dest_qos_min->delay = source_qos->delay;
dest_qos_min->relclass = source_qos->relclass;
dest_qos_min->peak = source_qos->peak;
dest_qos_min->mean = source_qos->mean;
}
GLOBAL USHORT cmhSM_pdp_typ_to_string ( UBYTE pdp_typ_no, char* string )
{
switch ( pdp_typ_no )
{
case 0:
strcpy (string, "X_121");
return 5;
case 33:
strcpy (string, "IP_V_4");
return 6;
case 87:
strcpy (string, "IP_V_6");
return 6;
default:
strcpy (string, "");
return 0;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_ring_gprs_par |
+--------------------------------------------------------------------+
PURPOSE : Return the information for CRING.
*/
GLOBAL char* cmhSM_ring_gprs_par ( void )
{
static char string[MAX_CRING_INFORMATION_LENGTH] = "\"";
unsigned int i = 1;
i += cmhSM_pdp_typ_to_string(gprs_call_table[current_gprs_ct_index].sm_ind.pdp_type, string + i);
string[i++] = '\"';
string[i++] = ',';
string[i++] = '\"';
memcpy (string + i, gprs_call_table[current_gprs_ct_index].sm_ind.pdp_address.buff,
gprs_call_table[current_gprs_ct_index].sm_ind.pdp_address.c_buff);
i += gprs_call_table[current_gprs_ct_index].sm_ind.pdp_address.c_buff + 1;
string[i++] = '\"';
if ( *gprs_call_table[current_gprs_ct_index].L2P )
{
string[i++] = ',';
string[i++] = '\"';
strcpy (string + i, gprs_call_table[current_gprs_ct_index].L2P);
i += strlen (gprs_call_table[current_gprs_ct_index].L2P);
string[i++] = '\"';
}
string[i] = 0;
return string;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_call_answer |
+--------------------------------------------------------------------+
PURPOSE : Return TRUE in this case, if an auto answer is needed.
*/
GLOBAL BOOL cmhSM_call_answer ( UBYTE ring_counter, T_ACI_CRING_MOD mode )
{
switch(automatic_response_mode)
{
case 0: /* GPRS off, GSM controlled by S0 */
if ( mode NEQ CRING_MOD_Gprs AND
at.S[0] AND at.S[0] <= ring_counter )
return TRUE;
break;
case 1: /* GPRS on, GSM controlled by S0 */
if ( mode EQ CRING_MOD_Gprs )
return TRUE;
if (at.S[0] AND at.S[0] <= ring_counter)
return TRUE;
break;
case 2: /* modem copatibility mode, GPRS on, GSM off */
if ( mode NEQ CRING_MOD_Gprs )
break;
/*lint -fallthrough*/
case 3: /* modem copatibility mode, GPRS on, GSM on */
if (at.S[0] AND ring_counter >= at.S[0])
return TRUE;
}
return FALSE;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_call_reject |
+--------------------------------------------------------------------+
PURPOSE : Return TRUE in this case, if an auto reject is needed.
*/
GLOBAL BOOL cmhSM_call_reject ( UBYTE ring_counter, T_ACI_CRING_MOD mode )
{
switch(automatic_response_mode)
{
case 0: /* GPRS off, GSM controlled by S0 */
return FALSE;
case 1: /* GPRS on, GSM controlled by S0 */
if (at.S99 AND mode EQ CRING_MOD_Gprs )
return TRUE;
break;
case 2: /* modem copatibility mode, GPRS on, GSM off */
case 3: /* modem copatibility mode, GPRS on, GSM on */
if ( mode NEQ CRING_MOD_Gprs )
break;
if (at.S99 AND ring_counter >= at.S99)
return TRUE;
}
return FALSE;
}
LOCAL BOOL is_GSM_call_active (void)
{
SHORT ctbIdx; /* holds call table index */
for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
{
if (ccShrdPrm.ctb[ctbIdx] NEQ NULL)
{
return (TRUE);
}
}
return (FALSE);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_sAT_H |
+--------------------------------------------------------------------+
PURPOSE : handle GPRS calls and return FALSE if a circuit switched
call need a handle.
*/
GLOBAL BOOL cmhSM_sAT_H ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret )
{
SHORT cid_array[1] = { INVALID_CID };
T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, (UBYTE)srcId, search_ati_src_id);
if ( ( at.rngPrms.isRng EQ TRUE ) AND ( at.rngPrms.mode EQ CRING_MOD_Gprs) )
{
/*
* brz patch: In the case of context reactivation over SMREG_PDP_ACTIVATE_IND with an used ti
* the GPRS ATH command doesn't do anything!
*
* Why? Because the Windows Dial-Up Networking client send every time an ATH after termination
* of the connection and with this a context reactivation was impossible.
*/
if ( gprs_call_table[current_gprs_ct_index].reactivation EQ GCTT_NORMAL )
{
return cmhSM_sAT_A_H_intern(srcId, aci_ret, 0);
}
return TRUE;
}
else
{
if (is_GSM_call_active())
{
return (FALSE);
}
/* if AT_H has been called and no RING is active, then disconnect the active
context */
#ifdef FF_GPF_TCPIP
if(is_gpf_tcpip_call())
{
T_DCM_STATUS_IND_MSG err_ind_msg;
err_ind_msg.hdr.msg_id = DCM_ERROR_IND_MSG;
err_ind_msg.result = DCM_PS_CONN_BROKEN;
dcm_send_message(err_ind_msg, DCM_SUB_NO_ACTION);
}
#endif
*aci_ret = sAT_PlusCGACT ( srcId, CGACT_STATE_DEACTIVATED, cid_array );
switch (*aci_ret)
{
case (AT_CMPL): /*operation completed*/
return FALSE; /* return false, so that GSM calls will be canceled */
case (AT_EXCT):
src_params->curAtCmd = AT_CMD_CGACT;
return TRUE;
default:
cmdCmeError(CME_ERR_Unknown); /*Command failed*/
return FALSE;
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_sAT_A |
+--------------------------------------------------------------------+
PURPOSE : handle GPRS calls and return FALSE if a circuit switched
call need a handle.
*/
GLOBAL BOOL cmhSM_sAT_A ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret )
{
BOOL b;
b = cmhSM_sAT_A_H_intern(srcId, aci_ret, 1);
if ( *aci_ret EQ AT_EXCT )
cmdErrStr = NULL;
return b;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_sAT_A_H_intern |
+--------------------------------------------------------------------+
PURPOSE : handle sAT_A and cAT_H for GPRS
*/
static BOOL cmhSM_sAT_A_H_intern ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret, SHORT mode)
{
if ( at.rngPrms.isRng EQ TRUE )
{
if ( at.rngPrms.mode EQ CRING_MOD_Gprs)
{
*aci_ret = automatic_response_mode > 1 ? /* modem copatibility mode possible */
sAT_PlusCGANS(srcId, mode, NULL, GPRS_CID_OMITTED): AT_FAIL;
}
else /* circuit switched call */
{
return FALSE;
}
}
else
{
return FALSE;
}
return TRUE;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_pdp_addr_well_formed |
+----------------------------------------------------------------------+
PURPOSE : check pdp address of well formed
*/
GLOBAL BOOL cmhSM_pdp_addr_well_formed( USHORT type, T_PDP_ADDRESS pdp_addr )
{
SHORT i = 0, state = 1;
char *start = pdp_addr, *end;
long temp;
switch ( type )
{
case PDP_T_IP: /* 255.255.255.255 */
if ( *pdp_addr )
{
while ( state AND i < 3)
{
temp = strtol(start, &end, 10);
if ( temp < 0 OR temp > 255 )
state = 0;
if ( *end NEQ '.' )
state = 0;
start = end + 1;
i++;
}
temp = strtol(start, &end, 10);
if ( temp < 0 OR temp > 255 )
state = 0;
}
if(state)
return TRUE;
break;
case PDP_T_X25:
return FALSE;
default:
break;
}
return FALSE;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_apn_well_formed |
+----------------------------------------------------------------------+
PURPOSE : check APN of well formed
*/
GLOBAL BOOL cmhSM_apn_well_formed( T_APN APN )
{
SHORT i = 0, state = 1, length = strlen (APN);
char *no_start_labels[] = {"rac","lac","sgsn"}, *start, *end, *mark;
T_APN apn;
strcpy(apn, APN);
start = apn;
/* change charcter of string to lower cases */
for (i = 0; i < length; i++)
apn[i] = tolower(apn[i]);
/* The Network Identifier shall not start with this labels */
for (i = 0; i < 3; i++)
{
if ( apn EQ strstr(apn, no_start_labels[i]) )
return FALSE;
}
/* the Wild Card APN */
if ( length EQ 1 AND *start EQ '*' )
return TRUE;
/* the APN with no name */
if ( length EQ 1 AND *start EQ /*lint -e(743)*/ '\x0ff' )
return TRUE;
/* Oporater Identifer is optional and the Network Identifer */
mark = strrchr(apn, '.');
if ( mark )
if ( strstr(mark + 1, "gprs") )
{
/* APN Operator Identifier contained (optional) */
if ( length < 18 )
return FALSE;
mark = start + length - 18; /* start of the APN Operator Identifier */
/* check APN Operator Identifier: "mncXXX.mccXXX.gprs" */
if ( mark NEQ strstr(mark, "mnc") )
return FALSE;
if ( mark + 6 NEQ strstr(mark, ".mcc") )
return FALSE;
strtol(mark + 3, &end, 10);
if ( end NEQ mark + 6 )
return FALSE;
strtol(mark + 10, &end, 10);
if ( end NEQ mark + 13 )
return FALSE;
/* check character between APN Network Identifier and the Operator Identifer */
mark--;
if ( *mark NEQ '.' )
return FALSE;
/* set stop mark */
*mark = 0;
}
else
mark = 0;
/* check APN Network Identifier */
/* shall not end in ".gprs" */
end = strrchr(apn, '.');
if ( end )
if ( strstr(end + 1, "gprs") )
return FALSE;
/* parse all labels */
while ( *start )
{
/* in first at least one Label */
while ( (*start >= 'a' AND *start <= 'z') OR (*start >= '0' AND *start <= '9') OR *start EQ '-' )
start ++;
/* next Label or nothing */
if ( *start EQ '.' )
start ++;
else
if ( *start NEQ 0)
return FALSE;
}
/* The APN Network Identifier shall have a maximum length of 63 octets. */
if ( start - apn > 63 )
return FALSE;
/* clear stop mark */
if ( mark )
*mark = '.';
return TRUE;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finished ROUTINE : cmhSM_transform_pdp_type |
+--------------------------------------------------------------------+
PURPOSE : transform pdp_type
*/
GLOBAL USHORT cmhSM_transform_pdp_type ( char *pdp_type )
{
if ( !strcmp(pdp_type, "IP") )
return PDP_T_IP;
if ( !strcmp(pdp_type, "X25") )
return PDP_T_X25;
return PDP_T_NONE;
}
GLOBAL T_CONTEXT_STATE get_state_over_cid ( SHORT cid )
{
TRACE_FUNCTION("get_state_over_cid()");
if ( (cid < 1) OR (cid > MAX_CID) )
{
TRACE_EVENT("invalid cid detected!");
return CS_INVALID_STATE;
}
return pdp_context[cid - 1].state;
}
GLOBAL void set_state_over_cid ( SHORT cid, T_CONTEXT_STATE c_state )
{
TRACE_EVENT_P3("set_state_over_cid: %d -> %d for cid %d", pdp_context[cid - 1].state, c_state, cid) ;
if (cid > 0 AND cid <= MAX_CID)
pdp_context[cid - 1].state = c_state;
}
GLOBAL T_CONTEXT_STATE get_state_working_cid ( void )
{
if ( work_cids[cid_pointer] EQ INVALID_CID )
{
TRACE_EVENT("working_cid is invalid!");
return CS_INVALID_STATE;
}
return pdp_context[work_cids[cid_pointer] - 1].state;
}
GLOBAL void set_conn_param_on_all_working_cids ( UBYTE owner, T_DTI_ENTITY_ID entity_id )
{
SHORT *pcid = &(work_cids[cid_pointer]);
TRACE_FUNCTION("set_conn_param_on_all_working_cids()");
while(INVALID_CID NEQ *pcid) {
pdp_context[*pcid - 1].owner = owner;
pdp_context[*pcid - 1].entity_id = entity_id;
pcid ++;
}
}
GLOBAL void set_conn_param_on_working_cid ( UBYTE owner, T_DTI_ENTITY_ID entity_id )
{
TRACE_FUNCTION("set_conn_param_on_working_cid()");
pdp_context[work_cids[cid_pointer] - 1].owner = owner;
pdp_context[work_cids[cid_pointer] - 1].entity_id = entity_id;
}
GLOBAL void set_state_working_cid ( T_CONTEXT_STATE c_state )
{
TRACE_FUNCTION("set_state_working_cid()");
if ( work_cids[cid_pointer] NEQ INVALID_CID )
{
pdp_context[work_cids[cid_pointer] - 1].state = c_state;
}
else
{
TRACE_EVENT("working cid is invalid!");
}
}
GLOBAL T_CONTEXT_STATE get_state_over_nsapi_set ( USHORT *nsapi_set, SHORT *cid )
{
USHORT nsapi = 0;
TRACE_FUNCTION("get_state_over_nsapi_set()");
while( nsapi < SMH_LAST_FREE_NSAPIS AND !((*nsapi_set >> nsapi) & 1) )
nsapi++;
if ( !(*nsapi_set & ( 1 << nsapi )) )
{
return CS_INVALID_STATE;
}
TRACE_EVENT_P1("NSAPI: %4d", nsapi);
*nsapi_set &= ~( 1U << nsapi );
return get_state_over_cid( *cid = nsapi_to_cid[nsapi] );
}
GLOBAL T_CONTEXT_STATE get_state_over_nsapi ( USHORT nsapi )
{
return get_state_over_cid( nsapi_to_cid[nsapi] );
}
GLOBAL USHORT cmhSM_Give_nsapi_set ( SHORT cid )
{
if ( (cid < 1) OR (cid > MAX_CID) )
return 0;
return 1 << pdp_context[cid - 1].nsapi;
}
GLOBAL T_ACI_CAL_OWN get_owner_over_cid ( SHORT cid )
{
if ( (cid < 1) OR (cid > MAX_CID) )
return CAL_OWN_NONE;
return pdp_context[cid - 1].owner;
}
GLOBAL void cmhGPPP_send_establish_request ( UBYTE peer )
{
T_PPP_ESTABLISH_REQ est_req;
memset(&est_req, 0, sizeof( T_PPP_ESTABLISH_REQ ));
est_req.mode = PPP_SERVER;
est_req.mru = PPP_MRU_DEFAULT;
est_req.ap = gpppShrdPrm.ppp_authentication_protocol;
est_req.accm = gpppShrdPrm.accm;
est_req.rt = gpppShrdPrm.restart_timer;
est_req.mc = gpppShrdPrm.max_configure;
est_req.mt = gpppShrdPrm.max_terminate;
est_req.mf = gpppShrdPrm.max_failure;
est_req.peer_direction = DTI_CHANNEL_TO_LOWER_LAYER;
est_req.prot_direction = DTI_CHANNEL_TO_HIGHER_LAYER;
est_req.peer_link_id = pdp_context[work_cids[0] - 1].link_id_uart;
est_req.prot_link_id = pdp_context[work_cids[0] - 1].link_id_new;
#ifdef _SIMULATION_
memset (est_req.peer_channel.peer_entity, 0, CHANNEL_NAME_LENGTH);
memset (est_req.protocol_channel.protocol_entity, 0, CHANNEL_NAME_LENGTH);
#endif /* _SIMULATION_ */
strcpy ( (char *) est_req.protocol_channel.protocol_entity, SNDCP_NAME);
switch (peer)
{
#ifdef BT_ADAPTER
case DTI_ENTITY_BLUETOOTH:
strcpy ( (char *) est_req.peer_channel.peer_entity, BTI_NAME);
break;
#endif
case DTI_ENTITY_UART:
strcpy ( (char *) est_req.peer_channel.peer_entity, UART_NAME);
break;
#ifdef FF_PSI
case DTI_ENTITY_PSI:
strcpy ( (char *) est_req.peer_channel.peer_entity, PSI_NAME);
break;
#endif /*FF_PSI*/
case DTI_ENTITY_AAA:
strcpy ( (char *) est_req.peer_channel.peer_entity, RIV_NAME);
break;
default:
TRACE_ERROR ("[cmhGPPP_send_establish_request()] Unexpected peer!");
return;
}
psaGPPP_Establish ( &est_req );
set_state_working_cid( CS_ESTABLISH_1 );
}
GLOBAL void cmhSM_cgerep_buffer ( void )
{
UBYTE srcId = srcId_cb;
switch (ati_user_output_cfg[srcId].CGEREP_bfr)
{
case CGEREP_BFR_CLEAR:
memset(gprs_event_buffer, 0, sizeof(T_CGERP_EVENT_BUFFER) * GPRS_EVENT_REPORTING_BUFFER_SIZE);
break;
case CGEREP_BFR_FLUSH:
if ( uart_is_mt_te_link EQ FALSE)
{
while ( gprs_eb_oldest_p NEQ gprs_eb_current_p )
{
R_AT( RAT_CGEREP, srcId )
( gprs_event_buffer[gprs_eb_oldest_p].event, gprs_event_buffer[gprs_eb_oldest_p].parm );
gprs_eb_oldest_p++;
}
}
break;
case CGEREP_BFR_OMITTED:
case CGEREP_BFR_INVALID:
default:
break;
}
}
GLOBAL void cmhSM_save_event( T_CGEREP_EVENT event, T_CGEREP_EVENT_REP_PARAM *param )
{
/* save event */
gprs_event_buffer[gprs_eb_current_p].event = event;
if (param)
memcpy (&gprs_event_buffer[gprs_eb_current_p].parm, param, sizeof(T_CGEREP_EVENT_REP_PARAM));
/* is buffer full */
if ( gprs_eb_oldest_p EQ gprs_eb_current_p )
gprs_eb_oldest_p = -1;
/* new current pointer */
gprs_eb_current_p++;
if ( gprs_eb_current_p EQ GPRS_EVENT_REPORTING_BUFFER_SIZE )
gprs_eb_current_p = 0;
/* if buffer full correct pointer to oldest event */
if ( gprs_eb_oldest_p EQ -1 )
gprs_eb_oldest_p = gprs_eb_current_p;
}
GLOBAL void cmhSM_set_sms_service ( T_CGSMS_SERVICE service )
{
{
PALLOC (mnsms_mo_serv_req, MNSMS_MO_SERV_REQ);
/* fill in primitive parameter: command request */
mnsms_mo_serv_req -> mo_sms_serv = (UBYTE) service;
PSENDX (SMS, mnsms_mo_serv_req);
}
m_service = service;
}
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_sms_service_changed |
+-------------------------------------------------------------------+
PURPOSE : indicates a network initiated PDP context modification
*/
GLOBAL void cmhSM_sms_service_changed ( UBYTE service )
{
TRACE_FUNCTION ("cmhSM_sms_service_changed()");
/*
*-------------------------------------------------------------------
* check for command context
*-------------------------------------------------------------------
*/
if ( smEntStat.curCmd EQ AT_CMD_CGSMS )
{
if ( m_service EQ service )
{
sm_cgsms_service = m_service;
R_AT( RAT_OK, smEntStat.entOwn ) ( smEntStat.curCmd );
}
else
{
R_AT( RAT_CME, smEntStat.entOwn ) ( smEntStat.curCmd, CME_ERR_Unknown );
/* log result */
cmh_logRslt ( smEntStat.entOwn, RAT_CME, smEntStat.curCmd, -1, -1, CME_ERR_Unknown );
}
smEntStat.curCmd = AT_CMD_NONE;
}
}
GLOBAL T_ACI_RETURN cmhSM_GprsAttached( SHORT state )
{
SHORT i = 1;
TRACE_FUNCTION ("cmhSM_GprsAttached()");
if ( state )
{ /* mobile is attached */
switch ( get_state_working_cid( ) )
{
case CS_ATTACHING_AFTER_DEF:
case CS_ATTACHING_AFTER_UNDEF:
cmhSM_data_link_context();
return AT_EXCT;
case CS_WAITS_FOR_ACTIVATING:
if (cmhSM_activate_context() NEQ AT_FAIL)
{
return AT_EXCT;
}
else /*GPRS is not allowed by FDN */
{
return AT_FAIL;
}
default:
return AT_FAIL;
}
}
else
{ /* attach failed */
if ( smEntStat.curCmd EQ AT_CMD_NONE AND
gpppEntStat.curCmd EQ AT_CMD_NONE )
return AT_FAIL;
/*
* it is enough to check only the working cid,
* because only one context can be in work
*/
switch ( get_state_working_cid( ) )
{
case CS_ATTACHING_AFTER_DEF:
case CS_ATTACHING_AFTER_UNDEF:
pdp_context[work_cids[cid_pointer] - 1].owner = gpppEntStat.entOwn;
gaci_RAT_caller ( RAT_NO_CARRIER, work_cids[cid_pointer], AT_CMD_CGDATA, 0 );
break;
case CS_WAITS_FOR_ACTIVATING:
pdp_context[work_cids[cid_pointer] - 1].owner = smEntStat.entOwn;
gaci_RAT_caller ( RAT_CME, work_cids[cid_pointer], AT_CMD_CGACT, CME_ERR_GPRSUnspec );
break;
default:
/*
* do nothing, because SM informs ACI over context deactivation
*/
return AT_FAIL;
}
return cmhSM_deactivateAContext( smEntStat.entOwn, work_cids[cid_pointer] );
}
}
GLOBAL T_ACI_RETURN cmhSM_activate_context(void)
{
TRACE_FUNCTION ("cmhSM_activate_context()");
if (pb_get_fdn_mode () EQ FDN_ENABLE)
{
if (pb_check_fdn (0, (const UBYTE *)"*99#") NEQ PHB_OK)
{
TRACE_EVENT("Activate Context: Entry not found in FDN, GPRS not allowed.");
ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow);
return (AT_FAIL);
}
TRACE_EVENT("Activate Context: Entry found in FDN, GPRS allowed.");
}
if( AT_CMPL EQ cmhGMM_contextActivation(smEntStat.entOwn, AT_CMD_CGACT) )
{
cmhSM_connect_working_cid();
set_state_working_cid( CS_ACTIVATING );
}
else /* AT_EXCT -> class BX class change requested (NOMIII) */
{
set_state_working_cid( CS_WAITS_FOR_ACTIVATING );
}
return (AT_EXCT);
}
#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : cmh_smf |
| STATE : initial ROUTINE : cmhSM_IP_activate_cb |
+----------------------------------------------------------------------+
PURPOSE : callback function for WAP over GPRS.
While handling the command ATD*98# in function atGD()
the function psaTCPIP_Activate() is called for WAP handling.
psaTCPIP_Activate() has this function as parameter for
call backs.
*/
void cmhSM_IP_activate_cb(T_ACI_RETURN result)
{
SHORT cid = gaci_get_cid_over_dti_id(wap_dti_id);
TRACE_FUNCTION("cmhSM_IP_activate_cb");
TRACE_EVENT_P1("wap_state: %s",wap_state_to_string(wap_state));
#ifndef FF_SAT_E
ACI_ASSERT(DTI_DTI_ID_NOTPRESENT NEQ wap_dti_id);
ACI_ASSERT(cid >= GPRS_CID_1 AND cid < GPRS_CID_INVALID);
ACI_ASSERT(result NEQ AT_FAIL);
#endif /* not FF_SAT_E */
if ( result EQ AT_FAIL )
{
/* IP activation failed. */
TRACE_EVENT("UDP/TCP/IP activation/configuration returned AT_FAIL");
if (DTI_LINK_ID_NOTPRESENT NEQ wap_dti_id)
{
dti_cntrl_close_dpath_from_dti_id (wap_dti_id);
cmhSM_disconnect_cid(cid, GC_TYPE_WAP );
}
/* reset work_cids */
set_state_over_cid(cid, CS_DEFINED);
sAT_PercentWAP(smShrdPrm.owner, 0);
smEntStat.curCmd = AT_CMD_NONE;
dti_cntrl_erase_entry(wap_dti_id);
cmdCmeError(CME_ERR_Unknown);
#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_EST_REQ ))
{
cmhSAT_OpChnUDPDeactGprs();
}
#endif /* SIM_TOOLKIT */
return;
}
switch(wap_state)
{
/* in case CO_UDP_IP and FF_GPF_TCPIP is defined this is a fall through case */
UDPIP_STATEMENT(case IPA_Activated:)
GPF_TCPIP_STATEMENT(case TCPIP_Activation:)
if(is_gpf_tcpip_call()) {
GPF_TCPIP_STATEMENT(set_conn_param_on_working_cid(
(UBYTE)smEntStat.entOwn, DTI_ENTITY_TCPIP));
}
else {
UDPIP_STATEMENT(set_conn_param_on_working_cid(
(UBYTE)smEntStat.entOwn, DTI_ENTITY_IP));
}
cmhSM_activate_context();
return;
UDPIP_STATEMENT(case UDPA_Configurated:)
GPF_TCPIP_STATEMENT(case TCPIP_Configurated:)
/* smEntStat.curCmd = AT_CMD_NONE; */
#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_EST_REQ ))
{
cmhSAT_OpChnUDPConfGprs();
}
else
#endif /* SIM_TOOLKIT */
{
R_AT ( RAT_CONNECT, smEntStat.entOwn )( AT_CMD_CGACT, -1, wapId, FALSE );
}
smEntStat.curCmd = AT_CMD_NONE;
smEntStat.entOwn = OWN_NONE;
#ifdef FF_GPF_TCPIP
if(is_gpf_tcpip_call())
{
T_DCM_STATUS_IND_MSG msg;
msg.hdr.msg_id = DCM_NEXT_CMD_READY_MSG;
dcm_send_message(msg, DCM_SUB_WAIT_CGACT_CNF);
}
#endif
break;
UDPIP_STATEMENT(case IPA_Deactivated:)
GPF_TCPIP_STATEMENT(case TCPIP_Deactivated:)
TRACE_EVENT_P1("cmhSM_IP_activate_cb, no connection, dti_id = %d", wap_dti_id);
#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_NONE ))
{
cmhSAT_OpChnUDPDeactGprs();
}
else
#endif /* SIM_TOOLKIT */
{
R_AT( RAT_NO_CARRIER, pdp_context[cid - 1].owner) ( AT_CMD_CGDATA, 0 );
}
dti_cntrl_close_dpath_from_dti_id (wap_dti_id);
cmhSM_connection_down(wap_dti_id);
cmhSM_disconnect_cid(cid, GC_TYPE_WAP );
sAT_PercentWAP(smShrdPrm.owner, 0);
if(work_cids[cid_pointer] EQ cid)
{
smEntStat.curCmd = AT_CMD_NONE;
*work_cids = 0;
cid_pointer = 0;
}
#ifdef FF_GPF_TCPIP
if(is_gpf_tcpip_call())
{
T_DCM_STATUS_IND_MSG msg;
msg.hdr.msg_id = DCM_NEXT_CMD_READY_MSG;
dcm_send_message(msg, DCM_SUB_WAIT_CGDEACT_CNF);
}
#endif
break;
default:
TRACE_EVENT("Unexpected wap state in cmhSM_IP_activate_cb()");
if(is_gpf_tcpip_call()) {
GPF_TCPIP_STATEMENT(srcc_delete_count(SRCC_TCPIP_SNDCP_LINK ));
}
else {
UDPIP_STATEMENT(srcc_delete_count(SRCC_IP_SNDCP_LINK ));
}
dti_cntrl_erase_entry(wap_dti_id);
sAT_PercentWAP(smShrdPrm.owner, 0);
smEntStat.curCmd = AT_CMD_NONE;
#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_NONE ))
{
cmhSAT_OpChnUDPDeactGprs();
}
else
#endif /* SIM_TOOLKIT */
{
cmdCmeError(CME_ERR_Unknown);
}
break;
}
return;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : cmh_smf |
| STATE : initial ROUTINE : cmhSM_IP_Enable |
+----------------------------------------------------------------------+
PURPOSE : enables IP dti connection.
*/
GLOBAL void cmhSM_IP_Enable ( T_DTI_CONN_LINK_ID link_id)
{
TRACE_FUNCTION("cmhSM_IP_Enable");
#ifdef _SIMULATION_
cmhSM_connect_context ( gaci_get_cid_over_link_id( link_id ),
DTI_ENTITY_IP, 0, 100 );
#else /* _SIMULATION_ */
cmhSM_connect_context ( gaci_get_cid_over_link_id( link_id ),
DTI_ENTITY_IP, 0, 0 );
#endif /* _SIMULATION_ */
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : cmh_smf |
| STATE : initial ROUTINE : cmhSM_IP_Disable |
+----------------------------------------------------------------------+
PURPOSE : disables IP dti connection.
*/
GLOBAL void cmhSM_IP_Disable ()
{
TRACE_FUNCTION("cmhSM_IP_Disable");
}
#endif /* WAP || FF_GPF_TCPIP || SAT E */
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_data_link_context |
+-------------------------------------------------------------------+
*/
GLOBAL void cmhSM_data_link_context(void)
{
TRACE_FUNCTION ("cmhSM_data_link_context()");
R_AT( RAT_CONNECT, pdp_context[work_cids[cid_pointer] - 1].owner )
( AT_CMD_CGDATA, 0, 0, FALSE );
/* log result */
cmh_logRslt ( pdp_context[work_cids[cid_pointer] - 1].owner,
RAT_CONNECT, AT_CMD_CGDATA, -1, -1, -1 );
cmhSM_connect_working_cid();
}
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_get_cid |
+-------------------------------------------------------------------+
*/
GLOBAL SHORT cmhSM_get_cid ( USHORT nsapi )
{
return nsapi_to_cid[nsapi];
}
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_next_work_cid |
+-------------------------------------------------------------------+
PURPOSE : start the next context activation if requested
*/
GLOBAL BOOL cmhSM_next_work_cid ( T_ACI_AT_CMD curCmd )
{
TRACE_EVENT_P1("cmhSM_next_work_cid, cid_pointer: %d", cid_pointer);
cid_pointer ++;
if ( work_cids[cid_pointer] EQ INVALID_CID )
{
smEntStat.curCmd = AT_CMD_NONE;
gpppEntStat.curCmd = AT_CMD_NONE;
cid_pointer = 0;
*work_cids = 0;
return FALSE;
}
switch ( curCmd )
{
case AT_CMD_CGDATA:
cmhSM_data_link_context();
break;
case AT_CMD_CGACT:
if(AT_FAIL EQ cmhSM_activate_context())
{
smEntStat.curCmd = AT_CMD_NONE;
gpppEntStat.curCmd = AT_CMD_NONE;
cid_pointer = 0;
*work_cids = 0;
/*R_AT (RAT_CME, smEntStat.entOwn)( AT_CMD_CGACT, CME_ERR_Unknown );*/
return FALSE;
}
break;
default:
cid_pointer = 0;
*work_cids = 0;
return FALSE;
}
return TRUE;
}
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_define_cid_list |
+-------------------------------------------------------------------+
PURPOSE : define all cid's in the list, if necessary
*/
GLOBAL SHORT cmhSM_define_cid_list( T_ACI_CMD_SRC srcId, SHORT *cids )
{
int i = 1;
TRACE_FUNCTION("cmhSM_define_cid_list");
if(INVALID_CID != *work_cids)
{
return 0;
}
if ( *cids EQ GPRS_CID_OMITTED) /* if no cid given */
{
while ( i <= MAX_CID AND get_state_over_cid( (SHORT)i ) NEQ CS_DEFINED )
i++;
if ( i > MAX_CID )
{
i = 1;
while ( i <= MAX_CID AND get_state_over_cid( (SHORT)i ) NEQ CS_UNDEFINED )
i++;
if ( i <= MAX_CID )
{
/*
* reset of context parameter if cid undefined
*/
sAT_PlusCGDCONT_exec (srcId, (SHORT)i, &defaultCtx);
set_state_over_cid((SHORT)i, CS_UNDEFINED);
}
else
return 0;
}
*cids = work_cids[0] = i;
work_cids[1] = INVALID_CID;
i = 1; /* no. of cids */
}
else /* if cid(s) is/are given */
{
SHORT j = 0;
i = 0;
/*
* checks given cid parameter
*/
while ( i < MAX_CID AND cids[i] NEQ INVALID_CID )
{
/* check cid */
if ( cids[i] < GPRS_CID_1 OR cids[i] >= GPRS_CID_INVALID )
return 0;
/* count cids */
i++;
}
if ( MAX_CID < i )
return 0;
memcpy (work_cids, cids, sizeof( *work_cids ) * (i + 1) );
/*
* reset of context parameter if cid undefined
*/
for (j = 0; work_cids[j] NEQ INVALID_CID; j++)
{
switch(get_state_over_cid(work_cids[j]))
{
case CS_UNDEFINED:
sAT_PlusCGDCONT_exec (srcId, work_cids[j], &defaultCtx);
set_state_over_cid(work_cids[j], CS_UNDEFINED);
/*lint -fallthrough*/
case CS_DEFINED:
case CS_ACTIVATED:
break;
default:
memset (work_cids, 0, sizeof( *work_cids ) * (i + 1) );
return 0;
}
}
}
return i;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_get_pdp_addr_for_CGPADDR |
+----------------------------------------------------------------------+
PURPOSE : return the PDP_address to one cid for the GPRS CGPADDR AT command
*/
GLOBAL SHORT cmhSM_get_pdp_addr_for_CGPADDR ( SHORT cid, T_PDP_ADDRESS pdp_adress )
{
T_CONTEXT_STATE c_state; /* state of context */
c_state = get_state_over_cid( cid );
if ( c_state EQ CS_UNDEFINED OR c_state EQ CS_INVALID_STATE )
{
*pdp_adress = 0;
return INVALID_CID;
}
if ( c_state EQ CS_ACTIVATED OR c_state EQ CS_DATA_LINK )
strcpy( pdp_adress, pdp_context[cid - 1].allocated_pdp_addr );
else
strcpy( pdp_adress, pdp_context[cid - 1].con.pdp_addr );
return cid;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_is_smreg_ti_used |
+----------------------------------------------------------------------+
PURPOSE : handle for used smreg_ti
*/
GLOBAL BOOL cmhSM_is_smreg_ti_used ( UBYTE smreg_ti, SHORT *cid )
{
SHORT i = 0;
while ( i < MAX_CID )
{
if ( pdp_context[i].smreg_ti EQ smreg_ti)
{
psaSM_PDP_Deactivate ( (USHORT) (1 << pdp_context[i].nsapi), SMREG_LOCAL);
psaGPPP_Terminate( PPP_LOWER_LAYER_UP );
call_waits_in_table = TRUE;
*cid = i + 1;
set_state_over_cid(*cid, CS_CONTEXT_REACTIVATION_1);
return TRUE;
}
i++;
}
return FALSE;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_context_reactivation |
+----------------------------------------------------------------------+
PURPOSE :
*/
GLOBAL void cmhSM_context_reactivation ( void )
{
T_CGEREP_EVENT_REP_PARAM event;
T_SMREG_PDP_ACTIVATE_IND *sm_ind;
SHORT i = 0;
if ( call_waits_in_table EQ TRUE )
{
call_waits_in_table = FALSE;
/*
* GPRS event reporting
*/
sm_ind = &gprs_call_table[current_gprs_ct_index].sm_ind;
cmhSM_pdp_typ_to_string(sm_ind->pdp_type, (char*) &event.act.pdp_type);
memcpy(&event.act.pdp_addr, &sm_ind->pdp_address.buff, sm_ind->pdp_address.c_buff);
event.act.cid = gprs_call_table[current_gprs_ct_index].cid;
for( i = 0 ; i < CMD_SRC_MAX; i++ )
{
R_AT( RAT_CRING, i ) ( CRING_MOD_Gprs, CRING_TYP_GPRS, CRING_TYP_NotPresent );
R_AT( RAT_CGEREP, i ) ( CGEREP_EVENT_NW_REACT, &event );
R_AT( RAT_P_CGEV, i ) ( CGEREP_EVENT_NW_REACT, &event );
}
}
else
{
cmhSM_next_call_table_entry();
}
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_stop_context_reactivation |
+----------------------------------------------------------------------+
PURPOSE :
*/
GLOBAL void cmhSM_stop_context_reactivation ( void )
{
call_waits_in_table = FALSE;
}
GLOBAL void cmhSM_next_call_table_entry( void )
{
current_gprs_ct_index++;
if ( current_gprs_ct_index >= gprs_ct_index )
{
cmhSM_empty_call_table();
}
else
{
cmhSM_context_reactivation();
}
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_init_GPRS_DTI_list |
+----------------------------------------------------------------------+
PURPOSE : Init all DTI identifier for GPRS.
*/
GLOBAL SHORT cmhSM_connect_working_cid ( void )
{
T_GPRS_CONT_CLASS *context_info = &pdp_context[work_cids[cid_pointer] - 1];
switch ( context_info->entity_id )
{
case DTI_ENTITY_PPPS:
srcc_new_count(SRCC_PPPS_SNDCP_LINK);
if (IS_SRC_BT(context_info->owner))
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_BLUETOOTH, DTI_ENTITY_PPPS, DTI_ENTITY_SNDCP};
UBYTE dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
dti_cntrl_est_dpath ( dti_id,
entity_list,
3,
SPLIT,
PPP_UART_connect_dti_cb);
}
else
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_PPPS, DTI_ENTITY_SNDCP};
dti_cntrl_est_dpath_indirect ((UBYTE)context_info->owner,
entity_list,
2,
SPLIT,
PPP_UART_connect_dti_cb,
DTI_CPBLTY_SER,
(UBYTE)work_cids[cid_pointer]);
}
m_mt_te_link = TRUE;
break;
case DTI_ENTITY_IP:
#ifdef CO_UDP_IP
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_IP, DTI_ENTITY_SNDCP};
UBYTE dti_id;
#ifdef FF_SAT_E
if ( satShrdPrm.opchStat EQ OPCH_EST_REQ )
dti_id = simShrdPrm.sat_class_e_dti_id;
else
#endif /* FF_SAT_E */
dti_id = wap_dti_id;
/* link_id should be created in atGD already, so just connect: */
if (!dti_cntrl_est_dpath( dti_id,
entity_list,
2,
APPEND,
IP_UDP_connect_dti_cb))
{
TRACE_EVENT("cmhSM_connect_working_cid: dti_cntrl_est_dpath returned FALSE");
return 0;
}
}
#endif /* CO_UDP_IP */
break;
#ifdef FF_SAT_E
case DTI_ENTITY_SIM:
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SIM, DTI_ENTITY_SNDCP};
/* create a SAT class E DTI ID if not present */
if ( simShrdPrm.sat_class_e_dti_id EQ DTI_DTI_ID_NOTPRESENT )
{
simShrdPrm.sat_class_e_dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
TRACE_EVENT_P1("sat_class_e_dti_id = %d", simShrdPrm.sat_class_e_dti_id);
}
srcc_new_count(SRCC_SIM_SNDCP_LINK);
TRACE_FUNCTION("cmhSM_connect_working_cid:GC_TYPE_SIM");
context_info->link_id_new =
dti_conn_compose_link_id (0, 0, simShrdPrm.sat_class_e_dti_id, DTI_TUPLE_NO_NOTPRESENT);
dti_cntrl_est_dpath( simShrdPrm.sat_class_e_dti_id,
entity_list,
2,
SPLIT,
SIM_SNDCP_connect_dti_cb);
break;
}
#endif /* FF_SAT_E */
case DTI_ENTITY_NULL:
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_NULL, DTI_ENTITY_SNDCP};
UBYTE dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
srcc_new_count(SRCC_NULL_SNDCP_LINK);
context_info->link_id_new = dti_conn_compose_link_id (0, 0, dti_id, DTI_TUPLE_NO_NOTPRESENT );
dti_cntrl_est_dpath( dti_id,
entity_list,
2,
SPLIT,
NULL_SNDCP_connect_dti_cb);
break;
}
#if defined (FF_GPF_TCPIP)
case DTI_ENTITY_TCPIP:
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_TCPIP, DTI_ENTITY_SNDCP};
UBYTE dti_id;
dti_id = wap_dti_id;
/* link_id should be created in atGD already, so just connect: */
if (!dti_cntrl_est_dpath( dti_id,
entity_list,
2,
SPLIT,
TCPIP_connect_dti_cb))
{
TRACE_EVENT("cmhSM_connect_working_cid: dti_cntrl_est_dpath returned FALSE");
return 0;
}
}
break;
#endif /* FF_GPF_TCPIP */
#if defined(FF_PKTIO) OR defined(FF_TCP_IP) OR defined (FF_PSI)
case DTI_ENTITY_INVALID:
{
T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SNDCP};
srcc_new_count(SRCC_PKTIO_SNDCP_LINK);
dti_cntrl_est_dpath_indirect((UBYTE)context_info->owner,
entity_list,
1, SPLIT,
PKTIO_SNDCP_connect_dti_cb,
DTI_CPBLTY_PKT,
(UBYTE)work_cids[cid_pointer]);
set_state_working_cid( CS_ACTIVATING );
break;
}
#endif /* FF_PKTIO OR FF_TCP_IP OR FF_PSI */
default:
return 0;
}
return 1;
}
GLOBAL void cmhSM_disconnect_cid ( SHORT cid, T_GPRS_CONNECT_TYPE type )
{
T_DTI_CONN_LINK_ID link_id = cmhSM_get_link_id_SNDCP_peer( cid, SNDCP_PEER_NORMAL );
TRACE_FUNCTION("cmhSM_disconnect_cid");
TRACE_EVENT_P1("link_id %d",link_id);
if ( DTI_LINK_ID_NOTPRESENT NEQ link_id)
{
switch ( type )
{
case GC_TYPE_DATA_LINK:
srcc_delete_count( SRCC_PPPS_SNDCP_LINK );
pdp_context[cid - 1].link_id_sn = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].link_id_new = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].link_id_uart = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].entity_id = DTI_ENTITY_INVALID;
m_mt_te_link = FALSE;
break;
case GC_TYPE_WAP:
if(is_gpf_tcpip_call())
{
GPF_TCPIP_STATEMENT(srcc_delete_count( SRCC_TCPIP_SNDCP_LINK ));
}
else
{
srcc_delete_count( SRCC_IP_SNDCP_LINK );
}
pdp_context[cid - 1].link_id_sn = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].link_id_new = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].link_id_uart = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].entity_id = DTI_ENTITY_INVALID;
break;
case GC_TYPE_NULL:
case GC_TYPE_EMAIL:
switch ( pdp_context[cid - 1].entity_id )
{
case DTI_ENTITY_IP:
GPF_TCPIP_STATEMENT(case DTI_ENTITY_TCPIP:)
if(is_gpf_tcpip_call())
{
GPF_TCPIP_STATEMENT(srcc_delete_count( SRCC_TCPIP_SNDCP_LINK ));
}
else
{
srcc_delete_count( SRCC_IP_SNDCP_LINK );
}
dti_cntrl_erase_entry(EXTRACT_DTI_ID(link_id));
break;
case DTI_ENTITY_NULL:
dti_cntrl_entity_disconnected( link_id, DTI_ENTITY_NULL );
srcc_delete_count( SRCC_NULL_SNDCP_LINK );
dti_cntrl_erase_entry(EXTRACT_DTI_ID(link_id));
break;
#if defined(FF_PKTIO) OR defined(FF_TCP_IP) || defined(FF_GPF_TCPIP) OR defined (FF_PSI)
case DTI_ENTITY_PKTIO:
case DTI_ENTITY_PSI:
case DTI_ENTITY_AAA:
srcc_delete_count( SRCC_PKTIO_SNDCP_LINK );
break;
#endif /* FF_PKTIO OR FF_TCP_IP || FF_GPF_TCPIP OR FF_PSI */
}
pdp_context[cid - 1].link_id_sn = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].link_id_new = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].link_id_uart = DTI_LINK_ID_NOTPRESENT;
pdp_context[cid - 1].entity_id = DTI_ENTITY_INVALID;
break;
}
}
}
GLOBAL BOOL uart_is_mt_te_link( void )
{
return m_mt_te_link;
}
GLOBAL void cmhSNDCP_Disable( T_DTI_CONN_LINK_ID link_id )
{
SHORT cid = gaci_get_cid_over_link_id( link_id );
/*
* disconnects the context if the link_id is the current link_id of this context
*
* the other case:
* the context is switching to an other peer and the old link_id is requested
* to be disconnected, NOT the context itself
*/
if (cmhSM_get_link_id_SNDCP_peer(cid, SNDCP_PEER_NORMAL) EQ link_id)
{
cmhSM_deactivateAContext(CMD_SRC_NONE, cid);
}
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_connect_context |
+----------------------------------------------------------------------+
PURPOSE : Connect an activated or deactivated PDP context with an entity.
*/
GLOBAL SHORT cmhSM_connect_context ( SHORT cid, T_DTI_ENTITY_ID peer, UBYTE ppp_hc, UBYTE msid )
{
ULONG dti_neighbor;
UBYTE dti_direction, hcomp = cmhSM_Get_h_comp() ? SMREG_COMP_BOTH_DIRECT: SMREG_COMP_NEITHER_DIRECT;
TRACE_FUNCTION("cmhSM_connect_context()");
switch ( peer )
{
case DTI_ENTITY_PPPS:
dti_neighbor = (ULONG) PPP_NAME;
dti_direction = SMREG_HOME;
break;
case DTI_ENTITY_NULL:
dti_neighbor = (ULONG) NULL_NAME;
dti_direction = SMREG_NEIGHBOR;
smShrdPrm.direc = DIREC_MO;
break;
case DTI_ENTITY_IP:
dti_neighbor = (ULONG) IP_NAME;
dti_direction = SMREG_NEIGHBOR;
smShrdPrm.direc = DIREC_MO;
#ifdef FF_WAP
if (Wap_Call)
rAT_WAP_start_gprs_login();
#endif /* FF_WAP */
break;
#ifdef FF_SAT_E
case DTI_ENTITY_SIM:
dti_neighbor = (ULONG) SIM_NAME;
dti_direction = SMREG_NEIGHBOR;
smShrdPrm.direc = DIREC_MO;
break;
#endif /* FF_SAT_E */
#if defined(FF_PKTIO) OR defined(FF_TCP_IP) OR defined(FF_PSI)
case DTI_ENTITY_PKTIO:
dti_neighbor = (ULONG) PKTIO_NAME;
dti_direction = SMREG_HOME;
smShrdPrm.direc = DIREC_MO;
break;
case DTI_ENTITY_PSI:
dti_neighbor = (ULONG) PSI_NAME;
dti_direction = SMREG_HOME;
smShrdPrm.direc = DIREC_MO;
break;
case DTI_ENTITY_AAA:
dti_neighbor = (ULONG) RIV_NAME;
dti_direction = SMREG_NEIGHBOR;
smShrdPrm.direc = DIREC_MO;
break;
#endif /* FF_PKTIO OR FF_TCP_IP OR FF_PSI */
#ifdef FF_GPF_TCPIP
case DTI_ENTITY_TCPIP:
dti_neighbor = (ULONG) TCPIP_NAME;
dti_direction = SMREG_NEIGHBOR;
smShrdPrm.direc = DIREC_MO;
break;
#endif /* FF_GPF_TCPIP */
default:
return 0;
}
pdp_context[cid - 1].entity_id = peer;
#ifdef _SIMULATION_
dti_neighbor = 0xfe1234ef;
#endif
if ( DTI_LINK_ID_NOTPRESENT EQ pdp_context[cid - 1].link_id_sn )
{ /* context is deactivated */
cmhSM_GetNewNSapi();
psaSM_ActivateReq ( cid,
(UBYTE) (hcomp? ppp_hc: 0),
msid,
hcomp,
pdp_context[cid - 1].link_id_new,
dti_neighbor,
dti_direction );
}
else
{ /* context is activated */
EXTERN void psaSN_SwitchReq ( UBYTE nsapi,
ULONG dti_linkid,
ULONG dti_neighbor,
UBYTE dti_direction );
psaSN_SwitchReq ( pdp_context[cid - 1].nsapi,
pdp_context[cid - 1].link_id_new,
dti_neighbor, dti_direction);
dti_cntrl_close_dpath_from_dti_id (EXTRACT_DTI_ID(pdp_context[cid - 1].link_id_sn));
dti_cntrl_entity_disconnected( pdp_context[cid - 1].link_id_sn, DTI_ENTITY_SNDCP );
dti_cntrl_erase_entry( EXTRACT_DTI_ID(pdp_context[cid - 1].link_id_sn) );
}
return 1;
}
GLOBAL void cp_pdp_primitive(T_SMREG_PDP_ACTIVATE_CNF * pdp_activate_cnf,
T_PPP_PDP_ACTIVATE_RES *activate_result)
{
activate_result->ppp_hc = pdp_activate_cnf->ppp_hc;
activate_result->msid = pdp_activate_cnf->msid;
/*
* copy IP address
*/
activate_result->ip = pdp_activate_cnf->pdp_address.buff[0];
activate_result->ip = activate_result->ip << 8;
activate_result->ip+= pdp_activate_cnf->pdp_address.buff[1];
activate_result->ip = activate_result->ip << 8;
activate_result->ip+= pdp_activate_cnf->pdp_address.buff[2];
activate_result->ip = activate_result->ip << 8;
activate_result->ip+= pdp_activate_cnf->pdp_address.buff[3];
activate_result->sdu.l_buf = pdp_activate_cnf->sdu.l_buf;
activate_result->sdu.o_buf = 0;
if (pdp_activate_cnf->sdu.l_buf > 0) {
memcpy(activate_result->sdu.buf,
&pdp_activate_cnf->sdu.buf[pdp_activate_cnf->sdu.o_buf >> 3],
pdp_activate_cnf->sdu.l_buf >> 3);
}
}
GLOBAL SHORT cmhSM_context_connected( USHORT nsapi )
{
T_GPRS_CONT_CLASS *context_info = &pdp_context[nsapi_to_cid[nsapi] - 1];
UBYTE ip[4];
TRACE_FUNCTION("cmhSM_context_connected");
context_info->link_id_sn = context_info->link_id_new;
context_info->link_id_new = DTI_LINK_ID_NOTPRESENT;
switch (context_info->entity_id)
{
case DTI_ENTITY_PPPS:
cmhSM_pdp_address_to_ip(&context_info->allocated_pdp_addr, ip);
psaGPPP_PDP_Activate(0, 0, ip,
context_info->network_pco.pco, context_info->network_pco.len);
set_state_working_cid( CS_ESTABLISH_3 );
break;
#ifdef FF_PKTIO
case DTI_ENTITY_PKTIO:
#endif /* FF_PKTIO */
#ifdef FF_PSI
case DTI_ENTITY_PSI:
#endif /* FF_PSI */
#ifdef FF_SAT_E
case DTI_ENTITY_SIM:
#endif /* FF_SAT_E */
#ifdef FF_TCP_IP
case DTI_ENTITY_AAA:
#endif /* FF_TCP_IP */
#if defined (FF_SAT_E) OR defined (FF_TCP_IP) OR defined (FF_PKTIO) OR defined (FF_PSI)
dti_cntrl_entity_connected( context_info->link_id_sn, DTI_ENTITY_SNDCP, DTI_OK);
set_state_working_cid( CS_ACTIVATED );
#if defined(FF_PKTIO) OR defined (FF_PSI)
cmhSM_next_work_cid(smEntStat.curCmd);
#endif /* FF_PKTIO OR FF_PSI */
break;
#endif /* #if defined (FF_SAT_E) OR defined (FF_TCP_IP) OR defined (FF_PKTIO) OR FF_PSI */
} /* switch (context_info->entity_id) */
return 1;
} /* GLOBAL SHORT cmhSM_context_connected( USHORT nsapi ) */
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_set_PCO |
+----------------------------------------------------------------------+
PURPOSE : Set a PCO in the context of the cid.
*/
GLOBAL void cmhSM_set_PCO( SHORT cid, T_PCO_TYPE pco_type, UBYTE* buf_addr, UBYTE length)
{
T_GPRS_CONT_PCO* dest;
switch ( pco_type )
{
case PCO_USER:
dest = &pdp_context[cid - 1].user_pco;
break;
case PCO_NETWORK:
dest = &pdp_context[cid - 1].network_pco;
break;
}
/*lint -e(644) */ /* all possible types defined */
memcpy(dest->pco, buf_addr, length);
dest->len = length;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_get_dti_SNDCP_pper |
+----------------------------------------------------------------------+
PURPOSE : Give back the right DTI-ID for the SNDCP - peer connection.
*/
GLOBAL ULONG cmhSM_get_link_id_SNDCP_peer( SHORT cid, T_SNDCP_PEER which )
{
switch ( which )
{
case SNDCP_PEER_NORMAL:
return pdp_context[cid - 1].link_id_new NEQ DTI_LINK_ID_NOTPRESENT ?
pdp_context[cid - 1].link_id_new: pdp_context[cid - 1].link_id_sn;
case SNDCP_PEER_SWITCHED:
return pdp_context[cid - 1].link_id_sn;
}
return DTI_LINK_ID_NOTPRESENT;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : code ROUTINE : cmhSM_context_deactivated |
+----------------------------------------------------------------------+
PURPOSE : Control the answer of context deactivations
started by an AT command.
*/
GLOBAL void cmhSM_context_deactivated( USHORT nsapi_set )
{
switch( working_cgact_actions.state )
{
case T_CDS_RUNNING:
if ( nsapi_set & working_cgact_actions.nsapi_set )
{ /* nsapi deactivation is requested */
working_cgact_actions.nsapi_set &= ~nsapi_set;
if ( ! (working_cgact_actions.cid_set OR
working_cgact_actions.nsapi_set ) )
{
R_AT( RAT_OK, working_cgact_actions.srcId ) ( AT_CMD_CGACT );
working_cgact_actions.state = T_CDS_IDLE;
}
}
break;
case T_CDS_IDLE:
break;
}
}
/*
+----------------------------------------------------------------------+
| PROJECT : GSM-PS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : deactivateAContextForCGACT |
+----------------------------------------------------------------------+
PURPOSE : deactivate a context for CGACT
RETURN VALUE : TRUE - AT_EXCT have to be returned for this context
FALSE - AT_CMPL have to be reported for this context
*/
static T_ACI_RETURN deactivateAContextForCGACT(SHORT cid)
{
T_CONTEXT_STATE ctx_state = get_state_over_cid( cid );
SRCC_LINK_NO srcc_link_no= SRCC_INVALID_LINK;
T_DTI_ENTITY_ID dti_entity_id= DTI_ENTITY_INVALID;
TRACE_FUNCTION("deactivateAContextForCGACT()");
#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
/*
* additinal behaviour for WAP
* abort ATD*98# before context activation requested
* 2003.05.06 brz
*/
if(is_gpf_tcpip_call()) {
GPF_TCPIP_STATEMENT(srcc_link_no = SRCC_TCPIP_SNDCP_LINK);
GPF_TCPIP_STATEMENT(dti_entity_id = DTI_ENTITY_TCPIP);
}
else {
srcc_link_no = SRCC_IP_SNDCP_LINK;
dti_entity_id = DTI_ENTITY_IP;
}
if( TRUE NEQ srcc_reserve_sources( srcc_link_no, 1 ) AND
DTI_LINK_ID_NOTPRESENT NEQ pdp_context[cid - 1].link_id_new AND
cid EQ work_cids[cid_pointer] OR
pdp_context[cid - 1].entity_id EQ dti_entity_id)
{
psaTCPIP_Deactivate(cmhSM_IP_activate_cb);
if(CS_UNDEFINED EQ ctx_state OR
CS_DEFINED EQ ctx_state )
{
if(is_gpf_tcpip_call()) {
GPF_TCPIP_STATEMENT(wap_state = TCPIP_Deactivation);
}
else {
wap_state = UDPA_Deactivation;
}
dti_cntrl_close_dpath_from_dti_id(
EXTRACT_DTI_ID(cmhSM_get_link_id_SNDCP_peer(cid , SNDCP_PEER_NORMAL)));
}
if( CS_ATTACHING_AFTER_UNDEF EQ ctx_state OR
CS_ATTACHING_AFTER_DEF EQ ctx_state OR
CS_WAITS_FOR_ACTIVATING EQ ctx_state )
{
srcc_delete_count(srcc_link_no);
return cmhSM_deactivateAContext(CMD_SRC_NONE, cid);
}
return AT_EXCT;
}
else
#endif /* CO_UDP_IP || FF_GPF_TCPIP */
{
if( CS_DEFINED NEQ ctx_state AND CS_UNDEFINED NEQ ctx_state )
{
if( CS_ATTACHING_AFTER_UNDEF EQ ctx_state OR
CS_ATTACHING_AFTER_DEF EQ ctx_state OR
CS_WAITS_FOR_ACTIVATING EQ ctx_state )
{
return cmhSM_deactivateAContext(CMD_SRC_NONE, cid);
}
else
{
dti_cntrl_close_dpath_from_dti_id(
EXTRACT_DTI_ID(cmhSM_get_link_id_SNDCP_peer(cid , SNDCP_PEER_NORMAL)));
return AT_EXCT;
}
}
}
return AT_CMPL;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_deactivateAContext |
+----------------------------------------------------------------------+
PURPOSE : deactivate some contexts (able for serial multiplexer mode).
*/
GLOBAL T_ACI_RETURN cmhSM_deactivateContexts( T_ACI_CMD_SRC srcId, SHORT *cids)
{
T_ACI_RETURN ret_value = AT_CMPL;
T_CONTEXT_STATE state;
USHORT nsapi_set = 0,
cid_set = 0;
SHORT i,
all_cids[MAX_CID + 1] = {1, 2, INVALID_CID};
TRACE_FUNCTION("cmhSM_deactivateContexts");
if( T_CDS_RUNNING EQ working_cgact_actions.state) {
TRACE_EVENT("cgact_ation is running: bussy returned");
return AT_FAIL; /* AT_BUSY */
}
if(INVALID_CID EQ *cids)
{
cids = all_cids;
}
for(i = 0; cids[i] NEQ INVALID_CID; i++)
{
state = pdp_context[cids[i] - 1].state;
#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
#ifndef _SIMULATION_
pdp_context[cids[i] - 1].owner = srcId;
#endif
#else
pdp_context[cids[i] - 1].owner = srcId;
#endif
if(AT_EXCT EQ deactivateAContextForCGACT( cids[i] ))
{
ret_value = AT_EXCT;
if(0 NEQ pdp_context[cids[i] - 1].nsapi)
{
nsapi_set |= (1 << pdp_context[cids[i] - 1].nsapi);
if(state EQ CS_DATA_LINK OR
state EQ CS_ACTIVATED OR
state EQ CS_CONTEXT_REACTIVATION_1)
{
cid_set = 1 << (cids[i] - 1);
}
}
else
{
cid_set = 1 << (cids[i] - 1);
}
}
}
if(cid_set OR nsapi_set) {
working_cgact_actions.state = T_CDS_RUNNING;
working_cgact_actions.nsapi_set = nsapi_set;
working_cgact_actions.cid_set = cid_set;
working_cgact_actions.srcId = srcId;
}
cmhSM_stop_context_reactivation();
return ret_value;
}
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_getCurQOS |
+----------------------------------------------------------------------+
PURPOSE : This function returns the current QOS settings.
*/
#ifdef FF_SAT_E
GLOBAL T_QOS* cmhSM_getCurQOS( SHORT cid )
{
return &pdp_context[cid - 1].qos;
}
#endif /* FF_SAT_E */
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441) MODULE : CMH_SMF |
| STATE : finnished ROUTINE : cmhSM_deactivateAContext |
+----------------------------------------------------------------------+
PURPOSE : deactivate all contexts (able for serial multiplexer mode).
*/
GLOBAL T_ACI_RETURN cmhSM_deactivateAContext( T_ACI_CMD_SRC srcId, SHORT cid )
{
TRACE_FUNCTION("cmhSM_deactivateAContext()") ;
switch( get_state_over_cid( cid ) )
{
case CS_UNDEFINED:
case CS_DEFINED:
/*
* context ís deactivated -> not action necessary
*/
break;
case CS_ATTACHING_AFTER_UNDEF:
/*
* CGDATA has started the attach procedure
* before establish data link
* CGDATA has to be stoped
*/
set_state_over_cid( cid, CS_UNDEFINED );
psaGMM_Detach( GMMREG_DT_GPRS );
gpppEntStat.curCmd = AT_CMD_NONE;
cid_pointer = 0;
*work_cids = 0;
if(CMD_SRC_NONE EQ srcId)
{
pdp_context[cid - 1].owner = gpppEntStat.entOwn;
gaci_RAT_caller ( RAT_NO_CARRIER, cid, AT_CMD_CGDATA, 0 );
}
return AT_CMPL;
case CS_ATTACHING_AFTER_DEF:
/*
* CGDATA has started the attach procedure
* before establish data link
* CGDATA has to be stoped
*/
set_state_over_cid( cid, CS_DEFINED );
psaGMM_Detach( GMMREG_DT_GPRS );
gpppEntStat.curCmd = AT_CMD_NONE;
cid_pointer = 0;
*work_cids = 0;
if(CMD_SRC_NONE EQ srcId)
{
pdp_context[cid - 1].owner = gpppEntStat.entOwn;
gaci_RAT_caller ( RAT_NO_CARRIER, cid, AT_CMD_CGDATA, 0 );
}
return AT_CMPL;
case CS_ESTABLISH_1:
/*
* context not activated, but PPP has to be terminated
*/
set_state_over_cid( cid, CS_ABORT_ESTABLISH );
dti_cntrl_entity_disconnected( pdp_context[cid - 1].link_id_new, DTI_ENTITY_SNDCP );
if (uartShrdPrm.escape_seq EQ UART_DETECT_ESC)
{
psaGPPP_Terminate( PPP_LOWER_LAYER_DOWN );
}
else
{
psaGPPP_Terminate( PPP_LOWER_LAYER_UP );
}
uartShrdPrm.escape_seq = UART_DETECT_DTR;
return AT_EXCT;
case CS_DATA_LINK:
/*lint -fallthrough*/
case CS_ESTABLISH_2:
case CS_ESTABLISH_3:
/*
* context has to be deactivated and PPP has to be terminated
*/
set_state_over_cid( cid, CS_CONTEXT_REACTIVATION_1 );
psaSM_PDP_Deactivate( (USHORT) (1 << pdp_context[cid - 1].nsapi), SMREG_NONLOCAL);
psaGPPP_Terminate( PPP_LOWER_LAYER_UP );
return AT_EXCT;
case CS_ACTIVATED:
/*
* special handling for context switching
*/
if(DTI_LINK_ID_NOTPRESENT NEQ pdp_context[cid - 1].link_id_sn AND
DTI_LINK_ID_NOTPRESENT NEQ pdp_context[cid - 1].link_id_new )
{
return AT_CMPL;
}
/*lint -fallthrough*/
case CS_ACTIVATING:
/*
* +CGACT aborted
*/
set_state_over_cid( cid, CS_DEACTIVATE_NORMAL );
psaSM_PDP_Deactivate( (USHORT) (1 << pdp_context[cid - 1].nsapi), SMREG_NONLOCAL);
return AT_EXCT;
case CS_WAITS_FOR_ACTIVATING:
/*
* reset command state it is enough
*/
set_state_working_cid( CS_DEFINED );
gpppEntStat.curCmd = AT_CMD_NONE;
smEntStat.curCmd = AT_CMD_NONE;
*work_cids = 0;
cid_pointer = 0;
return AT_CMPL;
case CS_ABORT_ESTABLISH:
case CS_DEACTIVATE_NORMAL:
case CS_BREAKDOWN_LINK_ERROR:
case CS_BREAKDOWN_LINK_NORMAL:
/*
* context is during deactivation procedure -> not action necessary
*/
return AT_EXCT;
case CS_CONTEXT_REACTIVATION_1:
case CS_CONTEXT_REACTIVATION_2:
/*
* context is during deactivation procedure
* -> not action for context deactivation or PPP termination necessary
*/
return AT_EXCT;
}
return AT_FAIL;
}
GLOBAL BOOL cmhSM_isContextActive( void )
{
int i = SMH_FIRST_FREE_NSAPIS;
while ( i <= SMH_LAST_FREE_NSAPIS AND ( nsapi_to_cid[i] EQ INVALID_CID))
i++;
if ( i > SMH_LAST_FREE_NSAPIS)
return FALSE;
return TRUE;
}
#endif /* GPRS */
/*==== EOF ========================================================*/
