line source
/*
+-----------------------------------------------------------------------------
| Project : GSM-PS (6147)
| Modul : PSA_SATF
+-----------------------------------------------------------------------------
| 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 for the protocol
| stack adapter for the SIM application toolkit.
+-----------------------------------------------------------------------------
*/
#ifdef SIM_TOOLKIT
#ifndef PSA_SATF_C
#define PSA_SATF_C
#endif
#include "aci_all.h"
/*==== INCLUDES ===================================================*/
#include "aci_cmh.h"
#include "aci_mem.h"
#ifdef GPRS
#include "gaci_cmh.h"
#endif
#ifdef FAX_AND_DATA
#include "aci_fd.h"
#endif /* of #ifdef FAX_AND_DATA */
#include "aci.h"
#include "psa.h"
#include "psa_cc.h"
#include "psa_sat.h"
#include "psa_util.h"
#include "cmh.h"
#include "cmh_sat.h"
#include "psa_mm.h"
#include "psa_ss.h"
#include "psa_sim.h"
#include "cmh_cc.h"
#include "ksd.h"
/*==== CONSTANTS ==================================================*/
#define ITM_WDT (14) /* item width in chars */
#define HDR_WDT (10) /* header width in chars */
/*==== TYPES ======================================================*/
/*==== EXPORT =====================================================*/
/*==== VARIABLES ==================================================*/
LOCAL UBYTE ssResPrms[MAXIMUM( sizeof(BUF_res_params_sat),
MAXIMUM(sizeof(BUF_rej_params_sat),
sizeof(BUF_err_params_sat)))];
/*==== FUNCTIONS ==================================================*/
LOCAL void psaSAT_getTonNpi(CHAR *inSeq, BOOL call_active,
UBYTE *ton, UBYTE *npi);
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_BuildEnvCC |
+-------------------------------------------------------------------+
PURPOSE : Build envelope call control command.
*/
GLOBAL void psaSAT_BuildEnvCC ( SHORT cId,
T_CLPTY_PRM *ss_cldPty,
T_sat_ussd *ussd,
T_MNCC_bcconf *ccp1,
T_MNCC_bcconf *ccp2)
{
T_CC_CALL_TBL *pCtbNtry = ccShrdPrm.ctb[cId];
UBYTE ton;
UBYTE npi;
/*
*-------------------------------------------------------------------
* build envelope call control command
*-------------------------------------------------------------------
*/
{
MCAST( env, ENV_CMD );
memset( env, 0, sizeof( T_ENV_CMD ));
env->v_cc_cmd = TRUE;
/* device identities */
env->cc_cmd.v_dev_ids = TRUE;
env->cc_cmd.dev_ids.src_dev = DEV_SRC_ME;
env->cc_cmd.dev_ids.dest_dev = DEV_DST_SIM;
if( cId NEQ NO_ENTRY )
{
/* address */
env->cc_cmd.v_addr = TRUE;
if( (pCtbNtry->SATinv & SAT_REDIAL_ECCBE) AND
(rdlPrm.rdlState) )
{
memcpy(&env->cc_cmd.addr, &satRdlCCEnv.addr, sizeof(T_addr));
}
else
{
/* address */
env->cc_cmd.addr.v_noa = TRUE;
env->cc_cmd.addr.noa = pCtbNtry->cldPty.ton;
env->cc_cmd.addr.v_npi = TRUE;
env->cc_cmd.addr.npi = pCtbNtry->cldPty.npi;
env->cc_cmd.addr.c_bcdDigit = pCtbNtry->cldPty.c_called_num;
memcpy( env->cc_cmd.addr.bcdDigit,
pCtbNtry->cldPty.called_num,
pCtbNtry->cldPty.c_called_num );
}
#ifdef SIM_TOOLKIT
if ( !rdlPrm.rdlState )
{
memcpy(&satRdlCCEnv.addr, &env->cc_cmd.addr, sizeof(T_addr));
}
#endif
/* capability configuration parameters 1*/
if( ccp1 )
{
env->cc_cmd.v_cap_cnf_parms = TRUE;
env->cc_cmd.cap_cnf_parms.l_cap_cnf_parms = ccp1->bc_len<<3;
memcpy( env->cc_cmd.cap_cnf_parms.b_cap_cnf_parms, ccp1->bc,
ccp1->bc_len );
}
/* capability configuration parameters 2*/
if( ccp2 )
{
env->cc_cmd.v_cap_cnf_parms_2 = TRUE;
env->cc_cmd.cap_cnf_parms_2.l_cap_cnf_parms_2 = ccp2->bc_len<<3;
memcpy( env->cc_cmd.cap_cnf_parms_2.b_cap_cnf_parms_2, ccp2->bc,
ccp2->bc_len );
}
/* If ccp is present in the setUpCall */
if ((satShrdPrm.capParm.cntxt EQ CTX_SAT_SETUP) AND satShrdPrm.stk_ccp.l_cap_cnf_parms )
{
env->cc_cmd.v_cap_cnf_parms = TRUE;
/* Storing the ccp if ECCBE is enabled */
if( (ccShrdPrm.ctb[cId]->SATinv & SAT_REDIAL_ECCBE) AND
(rdlPrm.rdlState) )
{
memcpy(&env->cc_cmd.cap_cnf_parms, &satRdlCCEnv.ccp, sizeof(BUF_cap_cnf_parms));
}
else
{
env->cc_cmd.cap_cnf_parms.l_cap_cnf_parms = satShrdPrm.stk_ccp.l_cap_cnf_parms;
memcpy( env->cc_cmd.cap_cnf_parms.b_cap_cnf_parms, &satShrdPrm.stk_ccp.b_cap_cnf_parms,
satShrdPrm.stk_ccp.l_cap_cnf_parms );
}
#ifdef SIM_TOOLKIT
if ( !rdlPrm.rdlState )
{
memcpy( &satRdlCCEnv.ccp, &env->cc_cmd.cap_cnf_parms, sizeof(BUF_cap_cnf_parms));
}
#endif
}
/* subaddress */
if( pCtbNtry->cldPtySub.c_subaddr )
{
env->cc_cmd.v_subaddr = TRUE;
if( (pCtbNtry->SATinv & SAT_REDIAL_ECCBE) AND
(rdlPrm.rdlState) )
{
memcpy( &env->cc_cmd.subaddr, &satRdlCCEnv.sub_addr, sizeof(T_subaddr) );
}
else
{
env->cc_cmd.subaddr.v_tos = TRUE;
env->cc_cmd.subaddr.tos = pCtbNtry->cldPtySub.tos;
env->cc_cmd.subaddr.v_oei = TRUE;
env->cc_cmd.subaddr.oei = pCtbNtry->cldPtySub.odd_even;
env->cc_cmd.subaddr.c_subadr_str = pCtbNtry->cldPtySub.c_subaddr;
memcpy( env->cc_cmd.subaddr.subadr_str, pCtbNtry->cldPtySub.subaddr,
pCtbNtry->cldPtySub.c_subaddr );
}
#ifdef SIM_TOOLKIT
if ( !rdlPrm.rdlState )
{
memcpy( &satRdlCCEnv.sub_addr, &env->cc_cmd.subaddr, sizeof(T_subaddr));
}
#endif
}
}
else if( ss_cldPty NEQ NULL )
{
/* SS string */
env->cc_cmd.v_ss_string = TRUE;
psaSAT_getTonNpi(ss_cldPty->num, FALSE, &ton, &npi);
env->cc_cmd.ss_string.v_noa = TRUE;
env->cc_cmd.ss_string.noa = ton;
env->cc_cmd.ss_string.v_npi = TRUE;
env->cc_cmd.ss_string.npi = npi;
env->cc_cmd.ss_string.c_ss_ctrl_string =
(UBYTE)utl_dialStr2BCD (ss_cldPty->num, /*ssStr,*/
env->cc_cmd.ss_string.ss_ctrl_string,
MAX_SS_STRING_LEN);
}
else if( ussd NEQ NULL )
{
/* USSD string */
env->cc_cmd.v_ussd_string = TRUE;
env->cc_cmd.ussd_string.dcs = ussd->dcs;
env->cc_cmd.ussd_string.c_ussd_str = MINIMUM (ussd->c_ussd_str, MAX_SAT_USSD_LEN);
memcpy( env->cc_cmd.ussd_string.ussd_str,
ussd->ussd_str,
env->cc_cmd.ussd_string.c_ussd_str);
}
/* location information */
/* code MCC */
env->cc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mcc[1]<<4) + mmShrdPrm.usedPLMN.mcc[0]) <<16;
env->cc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mnc[2]<<4) + mmShrdPrm.usedPLMN.mcc[2]) << 8;
/* code MNC */
env->cc_cmd.cc_smc_loc_info.mnc_mcc |= (mmShrdPrm.usedPLMN.mnc[1]<<4)+mmShrdPrm.usedPLMN.mnc[0];
/* code LAC */
env->cc_cmd.cc_smc_loc_info.lac = mmShrdPrm.lac;
/* code CID */
env->cc_cmd.cc_smc_loc_info.cid = mmShrdPrm.cid;
env->cc_cmd.v_cc_smc_loc_info = TRUE;
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : psa_sat |
| STATE : code ROUTINE : psaSAT_getTonNpi |
+--------------------------------------------------------------------+
PURPOSE : Get TON and NPI. The SS string in inSeq will be
decoded to check if it contains a phone number. If
SS String contains a number, its TON and NPI will be
returned. Otherwise TON and NPI will be set to FF as
required in GSM 11.14/GSM 11.11.
*/
LOCAL void psaSAT_getTonNpi(CHAR *inSeq, BOOL call_active,
UBYTE *ton, UBYTE *npi)
{
T_KSD_SEQGRP grp;
CHAR *rest;
T_KSD_SEQPARAM para;
CHAR seq[MAX_DIAL_LEN];
*ton = MNCC_TON_NOT_PRES;
*npi = MNCC_NPI_NOT_PRES;
strcpy(seq, inSeq);
/* decode sequence */
ksd_decode(seq, call_active, &grp, &rest, ¶);
/* analyse TON and NPI */
switch( grp )
{
case SEQGRP_CF:
if ( (para.cf.num NEQ NULL) AND (para.cf.num[0] NEQ 0) )
{
*ton = para.cf.ton;
*npi = para.cf.npi;
}
break;
case SEQGRP_DIAL:
if ( ( para.dial.number NEQ NULL ) AND
( para.dial.number[0] EQ 0 ) )
{
if ( para.dial.number[0] EQ '+' )
{
*ton = TON_International;
}
else
{
*ton = TON_Unknown;
}
*npi = NPI_IsdnTelephony;
}
break;
#ifdef SMI
case SEQGRP_SET_ABBR_DIAL:
if ( (para.abbrDial.number NEQ NULL) AND
( para.abbrDial.number[0] EQ 0 ) )
{
if ( para.abbrDial.number[0] EQ '+' )
{
*ton = TON_International;
}
else
{
*ton = TON_Unknown;
}
*npi = NPI_IsdnTelephony;
}
break;
#endif /* SMI */
default:
/* Sequence group does not contain number. TON and NPI still set to FF */
break;
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_BuildEnvCB |
+-------------------------------------------------------------------+
PURPOSE : Build envelope cell broadcast data download command.
*/
GLOBAL void psaSAT_BuildEnvCB ( UBYTE *cbMsg, SHORT cbLen )
{
/*
*-------------------------------------------------------------------
* build envelope cell broadcast data download command
*-------------------------------------------------------------------
*/
{
MCAST( env, ENV_CMD );
memset( env, 0, sizeof( T_ENV_CMD ));
env->v_cbd_cmd = TRUE;
/* device identities */
env->cbd_cmd.v_dev_ids = TRUE;
env->cbd_cmd.dev_ids.src_dev = DEV_SRC_NTW;
env->cbd_cmd.dev_ids.dest_dev = DEV_DST_SIM;
/* CB message */
env->cbd_cmd.v_cb_page = TRUE;
env->cbd_cmd.cb_page.l_cb_page = cbLen<<3;
env->cbd_cmd.cb_page.o_cb_page = 0;
memcpy( env->cbd_cmd.cb_page.b_cb_page, cbMsg, cbLen );
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_BuildEnvMoSmCntr |
+-------------------------------------------------------------------+
PURPOSE : Build envelope cell broadcast data download command.
*/
GLOBAL void psaSAT_BuildEnvMoSmCntr ( T_rp_addr sc_addr,
T_tp_da dest_addr )
{
/*
*-------------------------------------------------------------------
* build envelope
*-------------------------------------------------------------------
*/
{
MCAST( env, ENV_CMD );
memset( env, 0, sizeof( T_ENV_CMD ));
env->v_smc_cmd = TRUE;
/* device identities */
env->smc_cmd.v_dev_ids = TRUE;
env->smc_cmd.dev_ids.src_dev = DEV_DST_ME;
env->smc_cmd.dev_ids.dest_dev = DEV_DST_SIM;
/* short message address */
env->smc_cmd.v_sm_addr = TRUE;
env->smc_cmd.sm_addr.v_noa = TRUE;
env->smc_cmd.sm_addr.noa = sc_addr.ton;
env->smc_cmd.sm_addr.v_npi = TRUE;
env->smc_cmd.sm_addr.npi = sc_addr.npi;
env->smc_cmd.sm_addr.c_bcdDigit = sc_addr.c_num;
memcpy(&(env->smc_cmd.sm_addr.bcdDigit[0]),
&(sc_addr.num[0]),
sc_addr.c_num /*MAX_SMS_DIGIT_LEN*/);
/* address 2 */
env->smc_cmd.v_sm_addr_2 = TRUE;
env->smc_cmd.sm_addr_2.v_noa = TRUE;
env->smc_cmd.sm_addr_2.noa = dest_addr.ton;
env->smc_cmd.sm_addr_2.v_npi = TRUE;
env->smc_cmd.sm_addr_2.npi = dest_addr.npi;
env->smc_cmd.sm_addr_2.c_bcdDigit = dest_addr.c_num;
memcpy(&(env->smc_cmd.sm_addr_2.bcdDigit[0]),
&(dest_addr.num[0]),
dest_addr.c_num /*MAX_SMS_DIGIT_LEN*/);
/* location information */
/* code MCC */
env->smc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mcc[1]<<4) + mmShrdPrm.usedPLMN.mcc[0]) <<16;
env->smc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mnc[2]<<4) + mmShrdPrm.usedPLMN.mcc[2]) << 8;
/* code MNC */
env->smc_cmd.cc_smc_loc_info.mnc_mcc |= (mmShrdPrm.usedPLMN.mnc[1]<<4)+mmShrdPrm.usedPLMN.mnc[0];
/* code LAC */
env->smc_cmd.cc_smc_loc_info.lac = mmShrdPrm.lac;
/* code CID */
env->smc_cmd.cc_smc_loc_info.cid = mmShrdPrm.cid;
env->smc_cmd.v_cc_smc_loc_info = TRUE;
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_BuildEnvEventDwn |
+-------------------------------------------------------------------+
PURPOSE : Build envelope event download command.
*/
GLOBAL BOOL psaSAT_BuildEnvEventDwn ( UBYTE event, SHORT callId, T_CC_INITIATER actionSrc )
{
T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */
BOOL MT_flag;
UBYTE trans_id = 0xFF;
UBYTE ti_flag = 0xFF; /* lint: initialization warning */
TRACE_FUNCTION("psaSAT_BuildEnvEventDwn()");
pCtbNtry = ccShrdPrm.ctb[callId];
/*
*-------------------------------------------------------------------
* build envelope
*-------------------------------------------------------------------
*/
{
MCAST( env, ENV_CMD );
memset( env, 0, sizeof( T_ENV_CMD ));
env->v_evd_cmd = TRUE;
/* event */
env->evd_cmd.v_ev_list = TRUE;
env->evd_cmd.ev_list.c_event = 1;
env->evd_cmd.ev_list.event[0] = event;
/* device identities */
env->evd_cmd.v_dev_ids = TRUE;
env->evd_cmd.dev_ids.dest_dev = DEV_DST_SIM;
switch( actionSrc )
{
case( NEAR_END ):
env->evd_cmd.dev_ids.src_dev = DEV_SRC_ME;
break;
case( FAR_END ):
env->evd_cmd.dev_ids.src_dev = DEV_SRC_NTW;
break;
default:
env->evd_cmd.v_dev_ids = FALSE;
}
if ( event EQ EVENT_MT_CALL OR
event EQ EVENT_CALL_CONN OR
event EQ EVENT_CALL_DISC )
{
/* process ti identifier */
env->evd_cmd.v_ti_list = TRUE;
env->evd_cmd.ti_list.c_ti_oct = 1;
MT_flag = pCtbNtry -> ti & 0x08; /* TRUE if MS terminated transaction */
trans_id = ( pCtbNtry -> ti) & 0x07; /* see GSM 04.07 ?1.2.3.1.3 */
}
switch( event )
{
case( EVENT_MT_CALL ):
/* ti identifier */
/* MNCC_SETUP_IND means message sent from the side that originated the TI */
env->evd_cmd.ti_list.ti_oct[0].ti = /*lint -e(644) */ trans_id;
/* address */
if (pCtbNtry->clgPty.c_num NEQ 0)
{
env->evd_cmd.v_addr = TRUE;
env->evd_cmd.addr.v_noa = TRUE;
env->evd_cmd.addr.noa = pCtbNtry->clgPty.ton;
env->evd_cmd.addr.v_npi = TRUE;
env->evd_cmd.addr.npi = pCtbNtry->clgPty.npi;
env->evd_cmd.addr.c_bcdDigit = pCtbNtry->clgPty.c_num;
memcpy(&(env->evd_cmd.addr.bcdDigit[0]),
&(pCtbNtry->clgPty.num[0]),
pCtbNtry->clgPty.c_num);
}
/* called party subaddress */
if (pCtbNtry->clgPtySub.c_subaddr NEQ 0)
{
env->evd_cmd.v_subaddr = TRUE;
env->evd_cmd.subaddr.v_tos = TRUE;
env->evd_cmd.subaddr.tos = pCtbNtry -> clgPtySub.tos;
env->evd_cmd.subaddr.v_oei = TRUE;
env->evd_cmd.subaddr.oei = pCtbNtry -> clgPtySub.odd_even;
env->evd_cmd.subaddr.c_subadr_str = pCtbNtry->clgPtySub.c_subaddr;
memcpy(&(env->evd_cmd.subaddr.subadr_str[0]),
&(pCtbNtry->clgPtySub.subaddr[0]),
pCtbNtry->clgPtySub.c_subaddr);
}
break;
case( EVENT_CALL_CONN ):
/* ti identifier */
/* MNCC_SETUP_CNF context with MO Call
or: MNCC_SETUP_RES context with MT Call
means: message sent to the side that originates the TI */
ti_flag = 0x08;
env->evd_cmd.ti_list.ti_oct[0].ti = trans_id | ti_flag;
break;
case( EVENT_CALL_DISC ):
/* ti identifier */
/*
means: message sent to the side that originates the TI */
switch (actionSrc)
{
case( NEAR_END ):
/* MNCC_REJ_IND / MNCC_DISC_REQ / MNCC_REL_REQ */
if ( /*lint -e(644) */ MT_flag )
ti_flag = 0x08;
else
ti_flag = 0x00;
break;
case( FAR_END ):
/* MNCC_DISC_IND / MNCC_REL_IND / MNCC_REL_REQ */
if ( MT_flag )
ti_flag = 0x00;
else
ti_flag = 0x08;
break;
}
env->evd_cmd.ti_list.ti_oct[0].ti = trans_id | ti_flag;
/* Cause */
env->evd_cmd.v_cause = TRUE;
if (pCtbNtry -> numRawCauseBytes EQ 0)
{
if (GET_CAUSE_VALUE(pCtbNtry -> rejCs) NEQ NOT_PRESENT_8BIT) /* radio-link failure */
{
env->evd_cmd.cause.c_cs = 0;
}
else
{
if (GET_CAUSE_VALUE(pCtbNtry -> nrmCs) NEQ NOT_PRESENT_8BIT)
{
env->evd_cmd.cause.c_cs = 2;
/*Location is user : 0 and coding standard defined for the GSM PLMNS : 3 */
env->evd_cmd.cause.cs[0] =0xE0;
env->evd_cmd.cause.cs[1] = GET_CAUSE_VALUE(pCtbNtry -> nrmCs) |0x80 ;
}
else
{
env->evd_cmd.v_cause = FALSE;
}
}
}
else
{
env->evd_cmd.cause.c_cs = pCtbNtry -> numRawCauseBytes;
memcpy( env->evd_cmd.cause.cs,
pCtbNtry -> rawCauseBytes,
pCtbNtry -> numRawCauseBytes );
}
break;
case( EVENT_LOC_STATUS ):
env->evd_cmd.v_loc_state = TRUE;
switch( satShrdPrm.locInfo.regStatus )
{
case( NO_VLD_RS ):
env->evd_cmd.v_loc_state = FALSE;
break;
case( RS_NO_SRV ):
env->evd_cmd.loc_state = 0x02;
break;
case( RS_LMTD_SRV ):
env->evd_cmd.loc_state = 0x01;
break;
case( RS_FULL_SRV ):
env->evd_cmd.loc_state = 0x00;
/*---------------------------------------------------
only in this case would location info be included
----------------------------------------------------*/
/* location information */
/* code MCC */
env->evd_cmd.cc_smc_loc_info.mnc_mcc |=
((satShrdPrm.locInfo.currPLMN.mcc[1]<<4) + satShrdPrm.locInfo.currPLMN.mcc[0]) <<16;
env->evd_cmd.cc_smc_loc_info.mnc_mcc |=
((satShrdPrm.locInfo.currPLMN.mnc[2]<<4) + satShrdPrm.locInfo.currPLMN.mcc[2]) << 8;
/* code MNC */
env->evd_cmd.cc_smc_loc_info.mnc_mcc |=
(satShrdPrm.locInfo.currPLMN.mnc[1]<<4)+satShrdPrm.locInfo.currPLMN.mnc[0];
/* code LAC */
env->evd_cmd.cc_smc_loc_info.lac = satShrdPrm.locInfo.lac;
/* code CID */
env->evd_cmd.cc_smc_loc_info.cid = satShrdPrm.locInfo.cid;
env->evd_cmd.v_cc_smc_loc_info = TRUE;
break;
}
break;
#ifdef FF_SAT_E
case( EVENT_CHAN_STAT ):
env->evd_cmd.v_chan_stat = TRUE;
env->evd_cmd.chan_stat.chan_id = CHANNEL_ID_1;
env->evd_cmd.chan_stat.chan_stat_link = LINK_NO_ESTABL;
env->evd_cmd.chan_stat.chan_stat_inf2 = LINK_DROPPED;
break;
#endif /* FF_SAT_E */
default:
env->v_evd_cmd = FALSE;
TRACE_EVENT("wrong event id for SAT event download");
break;
}
/*
*-------------------------------------------------------------------
* check if a call control request is already in progress
*-------------------------------------------------------------------
*/
if( satShrdPrm.SIMCCParm.busy EQ TRUE )
{
/* event has to be queued */
T_SAT_QUEUE *p_queue;
if (satShrdPrm.event.c_queued >= MAX_EVENT_QUEUED - 1 )
{
TRACE_EVENT("Too many events have been queued: failed to queue this new event");
return FALSE;
}
p_queue = &satShrdPrm.event.queued[satShrdPrm.event.c_queued - 1];
p_queue->owner = (T_OWN)satShrdPrm.owner;
if (p_queue->stk_cmd NEQ NULL)
{
MFREE (p_queue->stk_cmd); /* Should not happen */
}
ACI_MALLOC (p_queue->stk_cmd, sizeof (T_stk_cmd));
if (psaSAT_STKBuildCmd (p_queue->stk_cmd) < 0)
{
ACI_MFREE (p_queue->stk_cmd);
p_queue->stk_cmd = NULL;
TRACE_ERROR ("problem encoding SAT cmd");
return FALSE;
}
satShrdPrm.event.c_queued++;
}
return TRUE;
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_SendTrmResp |
+-------------------------------------------------------------------+
PURPOSE : Send a terminal response for a previous SAT command.
*/
GLOBAL void psaSAT_InitTrmResp ( T_ACI_SAT_TERM_RESP *init_resp )
{
init_resp->addLen = 0;
init_resp->add = NULL;
init_resp->add_content = 0;
init_resp->resCC = NULL;
init_resp->text = NULL;
init_resp->at_resp = NULL;
init_resp->at_resp_count = 0;
#ifdef FF_SAT_E
init_resp->chnStat = FALSE;
init_resp->bearDesc = FALSE;
init_resp->bufSize = FALSE;
#endif /* FF_SAT_E */
memset (init_resp->dtt_buf, 0xFF, TIME_STAMP_LENGTH);
memset (init_resp->lang, 0xFF, CLAN_CODE_LEN);
}
LOCAL void sat_build_cc_action_resp(UBYTE rspId,
UBYTE addLen,
UBYTE *add,
UBYTE *resCC,
T_TERM_RESP *res)
{
UBYTE byteLen; /* holds byte length */
UBYTE *p; /* byte pointer */
if( satShrdPrm.stkCnfPrim OR resCC )
{
p = (resCC)? resCC : satShrdPrm.stkCnfPrim->stk_cmd.cmd;
if( p[1] EQ 0x81 )
{
byteLen = p[2];
p = &p[3];
}
else
{
byteLen = p[1];
p = &p[2];
}
res->v_cc_req_act = TRUE;
res->cc_req_act.l_cc_req_act = byteLen<<3;
memcpy( res->cc_req_act.b_cc_req_act, p, byteLen );
/* result 2 */
res->v_res_2 = TRUE;
res->res_2.gen = res->res.gen;
/* adjust first result according to second result (GSM 11.14 / 9.1) */
if( rspId <= 0x1F )
res->res.gen = RSLT_PERF_MDFY_SIM;
else if( rspId >= 0x20 AND rspId <= 0x2F )
res->res.gen = RSLT_CC_SIM_TMP;
else if( rspId >= 0x30 AND rspId <= 0x3F )
{
res->res.gen = RSLT_CC_SIM_PRM;
res->res.v_add = TRUE;
res->res.add.l_add = 8;
res->res.add.b_add[0] = ADD_CC_REQ_CHNG;
}
if( addLen )
{
if( res->res.gen NEQ RSLT_CC_SIM_PRM ) res->res.v_add = FALSE;
res->res_2.v_add = TRUE;
res->res_2.add.l_add = addLen<<3;
memcpy( res->res_2.add.b_add,
add,
addLen );
}
/* free the primitive */
if( satShrdPrm.stkCnfPrim )
{
PFREE( satShrdPrm.stkCnfPrim );
satShrdPrm.stkCnfPrim = NULL;
}
}
}
GLOBAL BOOL psaSAT_SendTrmResp ( UBYTE rspId,
T_ACI_SAT_TERM_RESP *data_for_term_resp)
{
TRACE_FUNCTION("psaSAT_SendTrmResp()");
/*
*-------------------------------------------------------------------
* build terminal response
*-------------------------------------------------------------------
*/
CCD_START;
{
MCAST( res, TERM_RESP );
memset( res, 0, sizeof( T_TERM_RESP ));
/* init of data_for_term_resp */
/* return network error cause GSM 11.14 / 12.12.3 (it's mandatory) */
if( ( data_for_term_resp->add_content NEQ 0 ) OR
( rspId EQ RSLT_NTW_UNAB_PROC ) )
{
data_for_term_resp->add = &(data_for_term_resp->add_content);
data_for_term_resp->addLen = 1;
}
/* device identities */
res->v_cmd_details = TRUE;
res->cmd_details.cmd_nr = satShrdPrm.cmdDet.cmdNr;
res->cmd_details.cmd_typ = satShrdPrm.cmdDet.cmdType;
res->cmd_details.cmd_qlf = satShrdPrm.cmdDet.cmdQlf;
/* device identities */
res->v_dev_ids = TRUE;
res->dev_ids.src_dev = DEV_SRC_ME;
res->dev_ids.dest_dev = DEV_DST_SIM;
/* result */
res->v_res = TRUE;
res->res.gen = (rspId EQ RSLT_PERF_SUCCESS AND cmpFlg)?
RSLT_PERF_PART_CMPR:rspId;
if( data_for_term_resp->addLen )
{
res->res.v_add = TRUE;
res->res.add.l_add = data_for_term_resp->addLen<<3;
memcpy( res->res.add.b_add, data_for_term_resp->add, data_for_term_resp->addLen );
}
/* call control requested action */
sat_build_cc_action_resp( rspId,
data_for_term_resp->addLen,
data_for_term_resp->add,
data_for_term_resp->resCC,
res );
/* USSD related terminal response */
if( data_for_term_resp->text NEQ NULL )
{
res->v_text = TRUE;
res->text.dcs = data_for_term_resp->text->dcs;
res->text.c_text_str = data_for_term_resp->text->c_text_str;
memcpy( &(res->text.text_str),
data_for_term_resp->text->text_str,
data_for_term_resp->text->c_text_str);
}
/* Run AT related terminal response */
if( data_for_term_resp->at_resp NEQ NULL )
{
res->v_at_resp = TRUE;
memcpy( res->at_resp.text_str,
data_for_term_resp->at_resp,
data_for_term_resp->at_resp_count );
res->at_resp.c_text_str = (UBYTE)data_for_term_resp->at_resp_count;
}
/*
Provide Local Information (date, time and time zone)
related terminal response
*/
if( data_for_term_resp->dtt_buf[0] NEQ 0xFF)
{
res->v_dtt = TRUE;
memcpy( res->dtt.text_str,
data_for_term_resp->dtt_buf,
TIME_STAMP_LENGTH );
res->dtt.c_text_str = (UBYTE)TIME_STAMP_LENGTH;
}
/*
Provide Local Information (Language Setting)
*/
if( data_for_term_resp->lang[0] NEQ 0xFF)
{
res->v_lang = TRUE;
memcpy( res->lang.lang_buf,
data_for_term_resp->lang,
CLAN_CODE_LEN );
res->lang.c_lang_buf = (UBYTE)CLAN_CODE_LEN;
}
#ifdef FF_SAT_E
/* add channel status to terminal response */
if( data_for_term_resp->chnStat NEQ FALSE )
{
/* restricted to only one channel for class e */
res->v_chan_stat = TRUE;
res->c_chan_stat = 1;
res->chan_stat[0].chan_id = CHANNEL_ID_1;
res->chan_stat[0].chan_stat_inf2 = NO_FURTH_INFO;
res->chan_stat[0].chan_stat_link = LINK_NO_ESTABL;
if( satShrdPrm.chnTb.chnUsdFlg )
{
switch( satShrdPrm.chnTb.lnkStat )
{
case( SIM_LINK_CNCT ):
res->chan_stat[0].chan_stat_link = LINK_ESTABL;
break;
case( SIM_LINK_DROP ):
res->chan_stat[0].chan_stat_inf2 = LINK_DROPPED;
break;
default: /* already handled by pre-setting */
break;
}
}
}
/* add bearer description to terminal response */
if( data_for_term_resp->bearDesc NEQ FALSE AND satShrdPrm.opchPrm )
{
if( satShrdPrm.opchType EQ B_CSD )
{
res->v_bear_desc = TRUE;
res->bear_desc.bear_type = BT_CSD;
res->bear_desc.v_csd_bear_prm = TRUE;
res->bear_desc.csd_bear_prm = ((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->csd_bear_prm;
}
if( satShrdPrm.opchType EQ B_GPRS )
{
res->v_bear_desc = TRUE;
res->bear_desc.bear_type = BT_GPRS;
res->bear_desc.v_gprs_bear_prm = TRUE;
res->bear_desc.gprs_bear_prm = ((T_SAT_GPRS_PRM*)satShrdPrm.opchPrm)->gprs_bear_prm;
}
}
/* add buffer size to terminal response */
if( data_for_term_resp->bufSize NEQ FALSE )
{
res->v_buffer_size = TRUE;
res->buffer_size = satShrdPrm.buffer_size;
}
#endif /* FF_SAT_E */
cmpFlg = FALSE;
}
/*
*-------------------------------------------------------------------
* send terminal response
*-------------------------------------------------------------------
*/
satShrdPrm.owner = OWN_SRC_INV;
satShrdPrm.ownSAT = FALSE;
memset( &satShrdPrm.stk_ccp, 0, sizeof(BUF_cap_cnf_parms));
#ifdef TI_PS_FF_AT_P_CMD_CUST
if (satShrdPrm.cust1StkCmd != (void *)0)
{
ACI_MFREE(satShrdPrm.cust1StkCmd); /* Free the dynamically allocated Cust1 Stk Cmd memory */
satShrdPrm.cust1StkCmd = (void *)0;
satShrdPrm.cust1StkCmdLen = 0;
}
#endif /* TI_PS_FF_AT_P_CMD_CUST */
if( psaSAT_STKResponse() < 0 ) /* STK command response */
{
TRACE_EVENT( "FATAL RETURN SAT in send term resp" );
CCD_END;
return( FALSE );
}
CCD_END;
return (TRUE);
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
| ROUTINE : psaSAT_dasmMECmd |
+-------------------------------------------------------------------+
PURPOSE : disassemble ME proactive SIM command.
*/
GLOBAL BOOL psaSAT_dasmMECmd ( BUF_cmd_prms *cmdPrm )
{
UBYTE ccdRet, err;
T_ACI_SAT_TERM_RESP resp_data;
BOOL aciOnlyEvents; /* holds information whether only ACI events are in SET UP
EVENT LIST */
BOOL sendRes; /* holds temporaly return result whether to send response
or not */
/* response message in the case of SET UP EVENT LIST, only ACI events */
static UBYTE TRSetEventOk [12] =
{
0x81, /* command details tag */
0x03, /* command details length */
0x00, /* will be updated to current cmd num */
0x05, /* command SETUP EVENT LIST */
0x00, /* not used */
0x82, /* device details tag */
0x02, /* device details length */
0x82, /* source ME */
0x81, /* destination SIM */
0x83, /* result tag */
0x01, /* result length */
0x00 /* result OK */
};
TRACE_FUNCTION("psaSAT_dasmMECmd");
psaSAT_InitTrmResp( &resp_data );
#ifdef TI_PS_FF_AT_P_CMD_CUST
if ((satShrdPrm.cmdDet.cmdType NEQ SAT_CMD_EVENT_LIST) AND /* ACI has to process the event before */
(simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_NORMAL_BEHAVIOUR)) /* and NOT Cust1 behaviour */
#else
if (satShrdPrm.cmdDet.cmdType NEQ SAT_CMD_EVENT_LIST)
#endif /* TI_PS_FF_AT_P_CMD_CUST */
cmhSAT_STKUsrNtfy();
if( cmdPrm EQ NULL ) /* no parameter */
{
memset(&satShrdPrm.stkCmdPrm, 0,
sizeof(satShrdPrm.stkCmdPrm));
}
else
{
memcpy( &satShrdPrm.stkCmdPrm, cmdPrm,
sizeof(satShrdPrm.stkCmdPrm));
ccdRet = ccd_decodeMsg (CCDENT_SAT,
DOWNLINK,
(T_MSGBUF *) &satShrdPrm.stkCmdPrm,
(UBYTE *) _decodedMsg,
satShrdPrm.cmdDet.cmdType );
/* check for CCD error */
if( ccdRet NEQ ccdOK )
{
TRACE_EVENT_P1( "CCD Decoding Error: %d", ccdRet );
err = psaSAT_ccdErrChk();
if( err NEQ 0 )
{
psaSAT_SendTrmResp( err, &resp_data );
return( FALSE );
}
}
}
/* continue processing */
switch( satShrdPrm.cmdDet.cmdType )
{
case( SAT_CMD_SETUP_CALL ):
{
MCAST( calCmd, SETUP_CALL );
return( cmhSAT_setupCall( calCmd ));
}
case( SAT_CMD_SEND_SS ):
{
MCAST( ssCmd, SEND_SS );
return( cmhSAT_sendSS( ssCmd ));
}
case( SAT_CMD_SEND_USSD ):
{
MCAST( ussdCmd, SEND_USSD );
return( cmhSAT_sendUSSD( ussdCmd ));
}
case( SAT_CMD_SEND_SMS ):
{
MCAST( smCmd, SEND_SM );
return( cmhSAT_sendSM( smCmd ));
}
case( SAT_CMD_SEND_DTMF ):
{
MCAST( dtmfCmd, SEND_DTMF );
return( cmhSAT_sendDTMF( dtmfCmd ));
}
case( SAT_CMD_EVENT_LIST ):
{
MCAST( setEvent, SETUP_EVENT );
if (cmhSAT_setupEvent_Test( setEvent, &aciOnlyEvents ))
{
/* ACI-SPR-18200: If there are no Events to be processed by MMI
ACI bypasses the MMI functionality and returns TR by itself */
/* something went wrong, temp event list is empty --> TR(30) */
if ( satShrdPrm.event.temp_list EQ 0L )
{
psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
return FALSE;
}
if ( aciOnlyEvents )
{
/* prepare response to signal OK to SATK */
TRSetEventOk[2] = satShrdPrm.cmdDet.cmdNr;
satShrdPrm.setPrm[satShrdPrm.owner].stkCmd = TRSetEventOk;
satShrdPrm.setPrm[satShrdPrm.owner].stkCmdLen = 12;
/* inform SIM about acknowledged event list */
sendRes = cmhSAT_CheckSetEventResp( );
if (sendRes)
{
if( psaSAT_STKResponse() < 0 ) /* respond to STK command */
{
TRACE_EVENT( "FATAL RETURN - TR could not be send" );
}
}
}
else /* signal MMI to process further events */
{
cmhSAT_STKCmdInd();
}
return TRUE;
}
else
{
if ( satShrdPrm.event.temp_list NEQ 0L )
{
satShrdPrm.event.temp_list = 0L; /* reinitialize temp_event_list */
psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data );
}
}
}
break;
case( SAT_CMD_RUN_AT ):
{
MCAST( calCmd, RUN_AT );
return( cmhSAT_runAt( calCmd ));
}
case( SAT_CMD_LAUNCH_BROWSER ):
{
MCAST( launchBrowserCmd, LAUNCH_BROWSER );
return( cmhSAT_launchBrowser( launchBrowserCmd ));
}
case( SAT_CMD_PROV_LOC_INFO):
{
return( cmhSAT_provLocalInfo());
}
#ifdef FF_SAT_E
case( SAT_CMD_OPEN_CHANNEL ):
{
MCAST( opchCmd, OPEN_CHANNEL );
return( cmhSAT_OpenChannelReq( opchCmd ));
}
#endif /* FF_SAT_E */
}
return( FALSE );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
| ROUTINE : psaSAT_SSResComp |
+-------------------------------------------------------------------+
PURPOSE : SS result component handling.
*/
GLOBAL void psaSAT_SSResComp ( T_res_comp* resCmp )
{
UBYTE addLen = 0;
T_ACI_SAT_TERM_RESP resp_data;
psaSAT_InitTrmResp( &resp_data );
/* Add the operation code and parameters to terminal response
(reference: section 12.12.1 "Additional information for SEND SS" of 11.14)
*/
if( resCmp -> v_sequence AND
resCmp -> sequence.v_op_code )
{
ssResPrms[0] = resCmp -> sequence.op_code;
if( resCmp -> sequence.params.l_params )
{
addLen = resCmp -> sequence.params.l_params >> 3;
memcpy( &ssResPrms[1], resCmp -> sequence.params.b_params, addLen);
}
++addLen;
}
resp_data.add = ssResPrms;
resp_data.addLen = addLen;
psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
| ROUTINE : psaSAT_SSErrComp |
+-------------------------------------------------------------------+
PURPOSE : SS error result component handling.
*/
GLOBAL void psaSAT_SSErrComp ( T_fac_inf* errCmp, BOOL is_fac_ussd )
{
UBYTE ccdRet;
UBYTE addLen = 1;
T_ACI_SAT_TERM_RESP resp_data;
MCAST( com, COMP_SAT );
TRACE_FUNCTION("psaSAT_SSErrComp()");
psaSAT_InitTrmResp( &resp_data );
*ssResPrms = ADD_NO_CAUSE;
memset( com, 0, sizeof( T_COMP_SAT ));
ccdRet = ccd_decodeMsg (CCDENT_FAC,
DOWNLINK,
(T_MSGBUF *) errCmp,
(UBYTE *) _decodedMsg,
COMP_SAT);
if( ccdRet NEQ ccdOK )
{
TRACE_EVENT_P1("CCD Decoding Error: %d",ccdRet );
}
else
{
if( com->err_comp_sat.err_desc_sat.err_params_sat.
l_err_params_sat )
{
addLen = com->err_comp_sat.err_desc_sat.err_params_sat.
l_err_params_sat >> 3;
memcpy( ssResPrms,com->err_comp_sat.err_desc_sat.err_params_sat.
b_err_params_sat, addLen );
}
}
resp_data.add = ssResPrms;
resp_data.addLen = addLen;
if( is_fac_ussd )
{
psaSAT_SendTrmResp( RSLT_USSD_ERR, &resp_data );
}
else
{
psaSAT_SendTrmResp( RSLT_SS_ERR, &resp_data );
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
| ROUTINE : psaSAT_SSRejComp |
+-------------------------------------------------------------------+
PURPOSE : SS reject component handling.
*/
GLOBAL void psaSAT_SSRejComp ( UBYTE cRejectInfo )
{
UBYTE addLen = 1;
T_ACI_SAT_TERM_RESP resp_data;
TRACE_FUNCTION("psaSAT_SSRejComp()");
psaSAT_InitTrmResp( &resp_data );
*ssResPrms = ADD_NO_CAUSE;
resp_data.add = ssResPrms;
resp_data.addLen = addLen;
psaSAT_SendTrmResp( cRejectInfo, &resp_data );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
| ROUTINE : psaSAT_ss_end_ind |
+-------------------------------------------------------------------+
PURPOSE : handles SAT responses to SAT after a SAT originated SS.
*/
GLOBAL T_ACI_RETURN psaSAT_ss_end_ind ( SHORT sId,
T_COMPONENT *com,
T_MNSS_END_IND *mnss_end_ind,
BOOL is_fac_ussd )
{
TRACE_FUNCTION("psaSAT_ss_end_ind()");
if( com->v_res_comp )
{
if( is_fac_ussd EQ FALSE ) /* not for USSD !! */
{
//TISH, patch for ASTec20762
//start
psaSS_dasmResultCmp( sId, &com->res_comp );
//end
psaSAT_SSResComp( &com->res_comp );
}
else
{
psaSS_dasmResultCmp( sId, &com->res_comp );
}
return( AT_EXCT );
}
if( com->v_err_comp )
{
ssShrdPrm.stb[sId].failType = SSF_SS_ERR;
psaSAT_SSErrComp( &mnss_end_ind -> fac_inf, is_fac_ussd );
return( AT_FAIL );
}
if( com->v_rej_comp )
{
UBYTE cRejectInfo = RSLT_NTW_UNAB_PROC;
/* check for protocol incompatibility for USSD */
if ( (is_fac_ussd) AND
(com->rej_comp.v_inv_problem) )
{
switch( com->rej_comp.inv_problem )
{
case 0x01 : /* invoke problem code #1 */
{
if (psaSS_asmUSSDProt1(sId))
{
/* facility with Protocole 1 format has been sent: wait for answer */
return( AT_CMPL );
}
cRejectInfo = RSLT_NTW_UNAB_PROC;
break;
}
case 0x02 : /* invoke problem code #2 */
{
cRejectInfo = RSLT_USSD_ERR;
break;
}
default :
{
TRACE_EVENT_P1("psaSAT_ss_end_ind(): unknown invoke problem: %x", com->rej_comp.inv_problem );
break;
}
}
ssShrdPrm.stb[sId].failType = SSF_INV_PRB;
}
/* check for protocol incompatibility for USSD */
if ((is_fac_ussd EQ FALSE) AND (com->rej_comp.v_gen_problem))
{
ssShrdPrm.stb[sId].failType = SSF_GEN_PRB;
/* for 27.22.4.11.1 Seq. 1.3 SEND SS */
if (com->rej_comp.gen_problem EQ GEN_PROB_UNRECOG_CMP)
{
cRejectInfo = RSLT_SS_ERR;
}
}
psaSAT_SSRejComp( cRejectInfo );
return( AT_FAIL );
}
return(AT_FAIL);
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
| ROUTINE : psaSAT_ccdErrChk |
+-------------------------------------------------------------------+
PURPOSE : CCD error checking. The function returns a SAT result
value unequal to 0 if the operation is must be terminated.
Otherwise the condition is only a warning and the operation
should be proceeded.
*/
GLOBAL UBYTE psaSAT_ccdErrChk ( void )
{
USHORT parLst[MAX_ERR_PAR];
UBYTE ccdErr;
UBYTE fstFlg = TRUE;
TRACE_FUNCTION("psaSAT_ccdErrChk()");
/*
*-------------------------------------------------------------------
* handling of first error
*-------------------------------------------------------------------
*/
do
{
memset (parLst,0, sizeof (parLst));
if( fstFlg )
{
ccdErr = ccd_getFirstError (CCDENT_SAT, parLst);
fstFlg = FALSE;
}
else
ccdErr = ccd_getNextError (CCDENT_SAT, parLst);
switch (ccdErr)
{
case( ERR_IE_NOT_EXPECTED ): /* unexpected element */
if( !((UBYTE)parLst[0] & 0x80) )
{
cmpFlg = TRUE;
break;
}
/* otherwise continue, no break */
/*lint -fallthrough*/
case( ERR_COMPREH_REQUIRED ): /* comprehension required */
return( RSLT_UNKN_DATA );
case( ERR_MAND_ELEM_MISS ): /* mandatory elements missing */
return( RSLT_ERR_REQ_VAL );
}
} while( ccdErr NEQ ERR_NO_MORE_ERROR );
return( 0 );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
| ROUTINE : psaSAT_DumpCmd |
+-------------------------------------------------------------------+
PURPOSE : Dump SAT command to debug output.
*/
GLOBAL void psaSAT_DumpCmd ( T_stk_cmd * cmd )
{
#define SAT_TRC_LEN 32
CHAR strBuf[2*SAT_TRC_LEN+1]; /* holds string buffer */
ULONG idx, cnt, mcnt; /* buffer index */
CHAR *pDest; /* points to destination */
TRACE_FUNCTION("psaSAT_DumpCmd()");
/*
*-------------------------------------------------------------------
* format command
*-------------------------------------------------------------------
*/
TRACE_EVENT( "SAT CMD SENT/RECEIVED:" );
mcnt = (ULONG)cmd->l_cmd >> 3;
if( !mcnt )
{
TRACE_EVENT_P1("an empty envelope. (%d)", (ULONG)cmd->l_cmd);
return;
}
for( cnt = 0; cnt < mcnt; cnt += SAT_TRC_LEN )
{
pDest = strBuf;
for( idx = 0; idx < SAT_TRC_LEN AND (idx + cnt) < mcnt; idx++ )
{
/* Implements Measure#32: Row 1277 */
pDest += sprintf( pDest, format_2X_str, (UBYTE)cmd->cmd[idx + cnt] );
}
*pDest = 0x0;
TRACE_EVENT_P1("%s", strBuf );
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
| ROUTINE : psaSAT_FURegister |
+-------------------------------------------------------------------+
PURPOSE : Register a handler for FILE UPDATE.
*/
GLOBAL BOOL psaSAT_FURegister ( T_SAT_FU_FUNC fu_func )
{
int i;
TRACE_FUNCTION("psaSAT_FURegister()");
for (i = 0; i < MAX_FU_OPS; i++)
{
if (satShrdPrm.fu_func[i] EQ fu_func)
{
TRACE_EVENT ("FU func already registered");
return TRUE;
}
if (satShrdPrm.fu_func[i] EQ NULL)
{
satShrdPrm.fu_func[i] = fu_func;
return TRUE;
}
}
return FALSE;
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
| ROUTINE : psaSAT_FUConfirm |
+-------------------------------------------------------------------+
PURPOSE : Confirm a handled FILE UPDATE. The parameter is the same
with which the handler was called and refers to the entry
of the callback table.
*/
GLOBAL void psaSAT_FUConfirm (int currFU, USHORT resFU)
{
BOOL fu_active;
BOOL aci_sent_no_primitive;
TRACE_EVENT_P2("psaSAT_FUConfirm(): currFU: %d, resFU: %d", currFU, resFU);
if (resFU EQ SIM_FU_ERROR) /*If there is one error, the rest of the procedure is to be cancelled */
{
PALLOC (fu_res, SIM_FILE_UPDATE_RES);
fu_res->source = SRC_MMI;
fu_res->fu_rsc = SIM_FU_ERROR;
if (satShrdPrm.fu_func_notif)
(void)satShrdPrm.fu_func_notif((int)fu_res->fu_rsc,satShrdPrm.fu_ind); /*Sends the final result to MMI */
PSENDX (SIM, fu_res);
return;
}
TRACE_EVENT_P1("satShrdPrm.fu_ind: %d", satShrdPrm.fu_ind);
if (satShrdPrm.fu_ind NEQ NULL AND currFU < MAX_FU_OPS)
{
if (currFU < 0)
{
if (satShrdPrm.fu_func_notif)
{ /*Sends the file update request notification to MMI */
if (!satShrdPrm.fu_func_notif(-1,satShrdPrm.fu_ind))
{
PALLOC (fu_res, SIM_FILE_UPDATE_RES); /* If rejected, send negative response to SIM */
fu_res->source = SRC_MMI;
fu_res->fu_rsc = SIM_FU_ERROR;
PSENDX (SIM, fu_res);
}
}
currFU = 0;
/*satShrdPrm.fu_rsc = SIM_FU_ERROR;*/ /* default*/
fu_active = FALSE;
}
else
{
++currFU;
if ( (resFU EQ SIM_FU_SUCC_ADD) AND (satShrdPrm.fu_rsc NEQ SIM_FU_ERROR) )
{
satShrdPrm.fu_rsc = resFU;
}
/*
switch (resFU)
{
case SIM_FU_SUCCESS:
if (satShrdPrm.fu_rsc EQ SIM_FU_SUCC_ADD)
break;
case SIM_FU_SUCC_ADD:
satShrdPrm.fu_rsc = resFU;
}
*/
fu_active = TRUE;
}
for ( ; currFU < MAX_FU_OPS; currFU++)
{
if (satShrdPrm.fu_func[currFU] EQ NULL)
continue;
/* else
fu_active = TRUE;*/
aci_sent_no_primitive = satShrdPrm.fu_func[currFU](currFU, satShrdPrm.fu_ind);
if (!aci_sent_no_primitive)
{
return; /* otherwise, result would be sent directly, and not at the end */
}
}
{
PALLOC (fu_res, SIM_FILE_UPDATE_RES);
fu_res->source = SRC_MMI;
fu_res->fu_rsc = (fu_active)? satShrdPrm.fu_rsc: SIM_FU_SUCCESS;
if (satShrdPrm.fu_func_notif)
(void)satShrdPrm.fu_func_notif((int)fu_res->fu_rsc,satShrdPrm.fu_ind); /*Sends the final result to MMI */
TRACE_EVENT("FREE satShrdPrm.fu_ind");
PFREE (satShrdPrm.fu_ind);
satShrdPrm.fu_ind = NULL;
PSENDX (SIM, fu_res);
simShrdPrm.fuRef = -1;
}
}
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
| ROUTINE : psaSAT_FUNotifyRegister |
+-------------------------------------------------------------------+
PURPOSE : Register a handler for FILE UPDATE.
*/
GLOBAL BOOL psaSAT_FUNotifyRegister ( T_SAT_FU_FUNC fu_func )
{
TRACE_FUNCTION("psaSAT_FUNotifyRegister()");
if (fu_func)
{
satShrdPrm.fu_func_notif = fu_func;
return TRUE;
}
else
return FALSE;
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
| ROUTINE : psaSAT_Init |
+-------------------------------------------------------------------+
PURPOSE : initialize the protocol stack adapter for SAT.
*/
/* MACRO: initializer for set parameter */
#define INIT_SAT_SET_PARM( dest, def )\
for( LpCnt = 0; LpCnt < OWN_SRC_MAX; LpCnt++ )\
satShrdPrm.setPrm[LpCnt].dest = def
GLOBAL void psaSAT_Init ( void )
{
TRACE_FUNCTION("psaSAT_Init()");
/*
*-------------------------------------------------------------------
* set default parms
*-------------------------------------------------------------------
*/
memset( &satShrdPrm, 0, sizeof(T_SAT_SHRD_PRM));
satShrdPrm.dur = -1;
satShrdPrm.SentUSSDid = NO_ENTRY;
satShrdPrm.fu_rsc = SIM_FU_SUCCESS;
satShrdPrm.fu_ind = NULL;
satShrdPrm.sId_pwd_requested = NO_ENTRY;
#ifdef TI_PS_FF_AT_P_CMD_CUST
satShrdPrm.cust1SimRefreshRespRqd = FALSE;
#endif /* TI_PS_FF_AT_P_CMD_CUST */
satShrdPrm.locInfo.currPLMN.v_plmn = INVLD_PLMN;
satShrdPrm.Cbch_EvtDnl = FALSE;
satShrdPrm.ownSAT = FALSE;
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_ChkEventList |
+-------------------------------------------------------------------+
PURPOSE : Check if the event is monitored and shall alert SAT.
*/
GLOBAL BOOL psaSAT_ChkEventList( UBYTE eventNr )
{
BOOL event_listed = FALSE;
TRACE_FUNCTION("psaSAT_ChkEventList()");
event_listed = (satShrdPrm.event.list >> eventNr ) & 0x01;
if( event_listed )
return( TRUE );
return( FALSE );
}
#ifdef FF_SAT_E
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_ctbFindActCall |
+-------------------------------------------------------------------+
PURPOSE : Return the call id of a call which is in an active state.
If no call could be found the function returns NO_ENTRY.
*/
GLOBAL SHORT psaSAT_ctbFindActCall( void )
{
UBYTE ctbIdx;
SHORT actId = NO_ENTRY;
TRACE_FUNCTION("psaSAT_ctbFindActCall()");
for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
{
if (ccShrdPrm.ctb[ctbIdx] NEQ NULL)
{
switch( psaCC_ctb(ctbIdx)->calStat )
{
case( CS_ACT ):
case( CS_ACT_REQ ):
case( CS_MDF_REQ ):
actId = ctbIdx;
break;
}
}
}
return( actId );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : SAT |
| ROUTINE : psaSAT_gprsFindFreeCntxt|
+-------------------------------------------------------------------+
PURPOSE : Return a free context id, if busy return NO_ENTRY.
*/
#ifdef GPRS
GLOBAL SHORT psaSAT_gprsFindFreeCntxt( void )
{
BOOL cntxtStat[MAX_CID+1];
SHORT cntxtId[MAX_CID+1];
SHORT cid = NO_ENTRY;
UBYTE idx;
TRACE_FUNCTION("psaSAT_gprsFindFreeCntxt()");
if( qAT_PlusCGACT( CMD_SRC_LCL, cntxtStat, cntxtId ) NEQ AT_CMPL )
return( NO_ENTRY );
for( idx = 0; idx < MAX_CID; idx++ )
{
if( cntxtId[idx] NEQ INVALID_CID AND cntxtStat[idx] EQ TRUE ) continue;
cid = (cntxtId[idx] EQ INVALID_CID)? idx+1:cntxtId[idx];
break;
}
return( cid );
}
#endif /* GPRS */
#endif /* FF_SAT_E */
#endif /* #ifdef SIM_TOOLKIT */
/*==== EOF ========================================================*/
