view src/aci2/aci/cmh_satr.c @ 662:8cd8fd15a095

SIM speed enhancement re-enabled and made configurable TI's original code supported SIM speed enhancement, but Openmoko had it disabled, and OM's disabling of speed enhancement somehow caused certain SIM cards to start working which didn't work before (OM's bug #666). Because our FC community is much smaller in year 2020 than OM's community was in their day, we are not able to find one of those #666-affected SIMs, thus the real issue they had encountered remains elusive. Thus our solution is to re-enable SIM speed enhancement and simply wait for if and when someone runs into a #666-affected SIM once again. We provide a SIM_allow_speed_enhancement global variable that allows SIM speed enhancement to be enabled or disabled per session, and an /etc/SIM_spenh file in FFS that allows it to enabled or disabled on a non-volatile basis. SIM speed enhancement is now enabled by default.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 24 May 2020 05:02:28 +0000
parents 93999a60b835
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-PS (6147)
|  Modul   :  CMH_SATR
+----------------------------------------------------------------------------- 
|  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 which are responsible
|             for the responses of the protocol stack adapter for
|             the SIM application toolkit.
+----------------------------------------------------------------------------- 
*/ 

#ifdef SIM_TOOLKIT

#ifndef CMH_SATR_C
#define CMH_SATR_C
#endif

#include "aci_all.h"
/*==== INCLUDES ===================================================*/
#include "aci_cmh.h"
#include "aci_mem.h"

#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_ss.h"
#include "psa_sat.h"
#include "psa_sim.h" /* for simShrdPrm declaration */
#include "psa_sms.h"
#include "psa_util.h"
#include "cmh.h"
#include "cmh_cc.h"
#include "cmh_sat.h"
#include "cmh_sms.h"
#include "aoc.h"

#include "phb.h"
#include "cmh_phb.h"
#include "l4_tim.h"
/*==== CONSTANTS ==================================================*/


/*==== TYPES ======================================================*/


/*==== EXPORT =====================================================*/


/*==== VARIABLES ==================================================*/


/*==== FUNCTIONS ==================================================*/

/*
+--------------------------------------------------------------------+
| PROJECT :                     MODULE  : CMH_SATR                   |
| STATE   : code                ROUTINE : cmhSAT_ModifyScaPdu        |
+--------------------------------------------------------------------+

  PURPOSE : modifies the SCA in a SUBMIT PDU

*/
LOCAL void cmhSAT_ModifyScaPdu( T_sms_sdu *sms_sdu,
                          UBYTE  *sca_buf,
                          UBYTE sca_len )
{
  UBYTE old_sca_len;
  UBYTE *rest;
  USHORT rest_len;
  UBYTE *old_sdu;
  UBYTE old_sdu_len;

  ACI_MALLOC(old_sdu, SIM_PDU_LEN);
  old_sdu_len = sms_sdu->l_buf/8;
  memcpy ( old_sdu, sms_sdu->buf, old_sdu_len );

  old_sca_len = *old_sdu+1;
  rest = old_sdu + old_sca_len;
  rest_len = old_sdu_len - old_sca_len;

  /* copy new SCA */
  memcpy(sms_sdu->buf, sca_buf, sca_len);

  /* copy the rest of the PDU */
  memcpy(sms_sdu->buf+sca_len, rest, rest_len);

  /* set the length */
  sms_sdu->l_buf = (sca_len+rest_len) * 8;

  ACI_MFREE(old_sdu);
}


/*
+--------------------------------------------------------------------+
| PROJECT :                     MODULE  : CMH_SATR                   |
| STATE   : code                ROUTINE : cmhSAT_ModifyDaPdu         |
+--------------------------------------------------------------------+

  PURPOSE : modifies the destination address in a SUBMIT PDU

*/
LOCAL void cmhSAT_ModifyDaPdu( T_sms_sdu *sms_sdu,
                         UBYTE  *da_buf,
                         UBYTE da_len )
{
  UBYTE old_sca_len;
  UBYTE old_da_len;
  UBYTE *rest;
  USHORT rest_len;
  UBYTE *old_sdu;
  UBYTE *new_sdu;
  UBYTE old_sdu_len;

  ACI_MALLOC(old_sdu, SIM_PDU_LEN);
  old_sdu_len = sms_sdu->l_buf/8;
  memcpy ( old_sdu, sms_sdu->buf, old_sdu_len );

  new_sdu = sms_sdu->buf;

  old_sca_len = *old_sdu+1;
  old_da_len  = (*(old_sdu + old_sca_len + 2)+1)/2 + 2;
  rest = old_sdu + old_sca_len + 2 + old_da_len;
  rest_len = old_sdu_len - old_sca_len - 2 - old_da_len;

  /* copy old sca, fo, mr */
  memcpy(new_sdu, old_sdu, old_sca_len+2);
  new_sdu += old_sca_len+2;

  /* copy the new DA */
  memcpy(new_sdu, da_buf, da_len);
  new_sdu += da_len;

  /* copy the rest of the PDU */
  memcpy(new_sdu, rest, rest_len);

  /* set the length */
  sms_sdu->l_buf = (old_sca_len+2+da_len+rest_len) * 8;

  ACI_MFREE(old_sdu);
}


/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_STKCmdCnf             |
+-------------------------------------------------------------------+

  PURPOSE : STK command confirmation

*/

GLOBAL SHORT cmhSAT_STKCmdCnf ( void )
{

  TRACE_FUNCTION ("cmhSAT_STKCmdCnf()");

/*
 *-------------------------------------------------------------------
 * check for command context
 *-------------------------------------------------------------------
 */
  switch( satEntStat.curCmd )
  {
    case( AT_CMD_SATE ):
     /*
      *----------------------------------------------------------------
      * process event for %SATE command
      *----------------------------------------------------------------
      */
      satEntStat.curCmd = AT_CMD_NONE;

      TRACE_EVENT_P1("SAT reponse with SIM cause: %d", satShrdPrm.stkError);
      
      switch (satShrdPrm.stkError)
      {
        case SIM_NO_ERROR:
          R_AT( RAT_SATE, satEntStat.entOwn )
            ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd );

          R_AT( RAT_OK, satEntStat.entOwn )
            ( AT_CMD_SATE );
          break;

        case SIM_CAUSE_SAT_BUSY:
          R_AT( RAT_CME, satEntStat.entOwn )
            ( AT_CMD_SATE, CME_ERR_SimSatBusy );
          break;

        case SIM_CAUSE_PUK1_BLOCKED:
          R_AT( RAT_CME, satEntStat.entOwn )
            ( AT_CMD_SATE, CME_ERR_SimFail );
          break;

        default:
          R_AT( RAT_CME, satEntStat.entOwn )
            ( AT_CMD_SATE, CME_ERR_Unknown );
          break;
      }
      break;
  }

  return 0;
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_STKCmdInd             |
+-------------------------------------------------------------------+

  PURPOSE : STK command indication

*/

GLOBAL SHORT cmhSAT_STKCmdInd ( void )
{
  SHORT idx;                 /* holds list index */

  TRACE_FUNCTION ("cmhSAT_STKCmdInd()");

/*
 *----------------------------------------------------------------
 * send unsolicited result
 *----------------------------------------------------------------
 */

  for( idx = 0; idx < CMD_SRC_MAX; idx++ )
  {
    R_AT( RAT_SATI, idx )
      ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd );
  }
  return 0;
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_Cust1StkCmdInd             |
+-------------------------------------------------------------------+

  PURPOSE : Used for Sending the Origianl STK command indication to a Cust1 MMI,
                   when performing Setup Call, Send SS, Send USSD or Send SMS
*/

GLOBAL SHORT cmhSAT_Cust1StkCmdInd ( void )
{
  SHORT idx;                 /* holds list index */

  TRACE_FUNCTION ("cmhSAT_Cust1StkCmdInd()");

  if (satShrdPrm.cust1StkCmd != (void *)0)
  {
      /*
       *----------------------------------------------------------------
       * send %SATI the MMI with the Stk Cmd
       *----------------------------------------------------------------
       */
       
        for( idx = 0; idx < CMD_SRC_MAX; idx++ )
        {
          R_AT( RAT_SATI, idx )
            ( satShrdPrm.cust1StkCmdLen >>3, satShrdPrm.cust1StkCmd);
        }

        ACI_MFREE(satShrdPrm.cust1StkCmd);

        satShrdPrm.cust1StkCmd = (void *)0;
        satShrdPrm.cust1StkCmdLen = 0;
  }

  return 0;
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_STKUsrNtfy            |
+-------------------------------------------------------------------+

  PURPOSE : STK user notification

*/

GLOBAL SHORT cmhSAT_STKUsrNtfy ( void )
{
  SHORT idx;                 /* holds list index */

  T_ACI_SATN_CNTRL_TYPE cntrl_type = SATN_CNTRL_BY_SIM_Not_Present;

  TRACE_FUNCTION ("cmhSAT_STKUsrNtfy()");

/*
 *----------------------------------------------------------------
 * determine user notification
 *----------------------------------------------------------------
 */
  switch( satShrdPrm.ntfy )
  {
    case( USR_NTF_CC_SIM ):

      if (simShrdPrm.overall_cust_mode EQ CUST_MODE_BEHAVIOUR_1)
      {
          switch (satShrdPrm.SIMCCParm.ccAct)
          {
                case CC_ACT_CAL:
                    cntrl_type = SATN_CNTRL_BY_SIM_CALL;
                    break ;

                case CC_ACT_SS:
                    cntrl_type = SATN_CNTRL_BY_SIM_SS;
                    break ;

                case CC_ACT_USSD:
                    cntrl_type = SATN_CNTRL_BY_SIM_USSD;
                    break ;

                case SMC_ACT_MO:
                    cntrl_type = SATN_CNTRL_BY_SIM_SMS;
                    break ;

                 default:
                    cntrl_type = SATN_CNTRL_BY_SIM_Not_Present;
          }
      }

      if(psa_IsVldOwnId(satShrdPrm.owner) AND
         satShrdPrm.owner NEQ NO_VLD_OWN      )
      {
        R_AT( RAT_SATN, satShrdPrm.owner )
          ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd, cntrl_type );
        break;
      }
      /* otherwise continue, no break */
      /*lint -fallthrough*/
    default:

      for( idx = 0; idx < CMD_SRC_MAX; idx++ )
      {
        if( idx NEQ satShrdPrm.run_at_id )
        {
          /* don't notify SAT itself over run at channel */
          R_AT( RAT_SATN, idx )
          ( satShrdPrm.stkCmdLen>>3, satShrdPrm.stkCmd, cntrl_type );
        }
      }
  }

  return 0;
}

LOCAL void send_error_to_user( BOOL  ownNotSAT,
                               UBYTE command,
                               UBYTE result,
                               UBYTE additional_result,
                               UBYTE *resId,
                               BOOL  satopc )
{
  T_ACI_SAT_TERM_RESP resp_data;

  psaSAT_InitTrmResp( &resp_data );

  if( ownNotSAT )
  {
    /* setup initiated by user */
    R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
      ( command, CME_ERR_NotPresent );
    /* log result */
    cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, command,
                  -1, -1, CME_ERR_NotPresent );
    return;
  }

  /* setup initiated by SAT */
  /* send SAT response */
  resp_data.add_content = additional_result;

  /* if source was open channel command */
#ifdef FF_SAT_E  
  if(satopc)
  {
    if( satShrdPrm.opchStat EQ OPCH_CCSIM_REQ )
    {
       cmhSAT_OpChnFailed( result, &resp_data );
       return;
    }
  }
#endif /* FF_SAT_E */

  if( resId NEQ NULL )
  { 
    resp_data.resCC = resId;
  }
  psaSAT_SendTrmResp( result, &resp_data );
}

/* return TRUE if key sequence accepted, FALSE otherwise */
LOCAL BOOL sim_control_send_ss( T_CLPTY_PRM *ss_clpty, 
                                UBYTE       command, 
                                BOOL        ownNotSAT, 
                                UBYTE       *resCC )
{
  T_ACI_RETURN      retVal;             /* holds return value */
  T_ACI_D_CLIR_OVRD dummy2;             /* dummy value */
  T_ACI_D_TOC       dummy1;             /* dummy value */

  /* check for busy SS condition */
  if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY )
  {
    /* NOTE: shouldn't that be:
    send_error_to_user( ownNotSAT, RSLT_CC_SIM_PRM, ADD_ME_SS_BUSY, resCC, FALSE);
    or send_error_to_user( ownNotSAT, RSLT_CC_SIM_PRM, RSLT_ME_CAP, resCC, FALSE);
    ??*/
    send_error_to_user( ownNotSAT, command, RSLT_ME_UNAB_PROC, ADD_ME_SS_BUSY, resCC, FALSE);
    return FALSE;
  }

  /* send SS control string */
  retVal = cmhCC_chkKeySeq ( satShrdPrm.SIMCCParm.owner,
                             ss_clpty,
                             &dummy1,
                             &dummy2,
                             CC_SIM_NO );
  if( retVal NEQ AT_EXCT )
  {
    /* string is not SS: terminate with error */
    send_error_to_user( ownNotSAT, command, RSLT_CC_SIM_PRM, RSLT_ME_CAP, resCC, FALSE);
    return(FALSE);
  }
  else
  {
#ifdef FF_SAT_E
    if(!ownNotSAT AND satShrdPrm.opchStat EQ OPCH_CCSIM_REQ )
    {
      return( FALSE );
    }
#endif /* FF_SAT_E */     
    return(TRUE);
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_ResCalCntrlBySIM      |
+-------------------------------------------------------------------+

  PURPOSE : Handle SIM call control result. Return TRUE if primitive
            is needed for building a terminal response.

*/
LOCAL BOOL cmhSAT_result_sim_cc_ss( SHORT cId,
                                    UBYTE *resId, 
                                    T_ccr_allw *ccr )
{
  T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
  T_ACI_SAT_TERM_RESP resp_data;
  BOOL  ownNotSAT = (satShrdPrm.SIMCCParm.owner NEQ OWN_SAT);  /* flags that the owner is not SAT */
  UBYTE cmdBuf;                         /* buffer command */

  TRACE_FUNCTION("cmhSAT_result_sim_cc_ss()");

  psaSAT_InitTrmResp( &resp_data );
  
#ifdef FF_SAT_E 
  /* check for a pending OPEN CHANNEL command */
  if (ctb->calStat EQ CS_SAT_CSD_REQ)
  {
    /* free ctb entry */
    psaCC_FreeCtbNtry (cId);

    /* respond with "error, Interaction with CC by SIM, perm problem" */
    resp_data.add_content = ADD_CC_REQ_CHNG;
    resp_data.chnStat = TRUE;

    cmhSAT_OpChnFailed( RSLT_CC_SIM_PRM, &resp_data );

    return( FALSE );
  }
#endif /* FF_SAT_E */ 

  cmdBuf = ctb->curCmd;
  psaCC_FreeCtbNtry (cId);

  cmhCC_init_cldPty( &satPndSetup.clpty );

  utl_BCD2DialStr( ccr->ss_string.ss_ctrl_string,
                   satPndSetup.clpty.num,
                   (UBYTE)MINIMUM(ccr->ss_string.c_ss_ctrl_string,
                                  MAX_DIAL_LEN-1));

  satPndSetup.clpty.ton = ccr->ss_string.noa;
  satPndSetup.clpty.npi = ccr->ss_string.npi;

  if( sim_control_send_ss( &satPndSetup.clpty, cmdBuf, ownNotSAT, resId ) )
    return( !ownNotSAT );
  return( FALSE );  /* primitive not needed anymore */
}

LOCAL void cmhSAT_result_sim_cc_address( SHORT cId, T_ccr_allw *ccr )
{
  TRACE_FUNCTION("cmhSAT_result_sim_cc_address()");

  /* adjust called address */
  cmhSAT_fillSetupPrm ( cId,
                        &ccr->addr,
                        ((ccr->v_subaddr)?&ccr->subaddr:NULL));
#ifdef FF_SAT_E  
  if( psaCC_ctb(cId)->calStat NEQ CS_SAT_CSD_REQ )
#endif /* FF_SAT_E */
  {
    /* new call table entry set default bearer capabilities */
    cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES );
  }

  /* adjust bearer capabilities */
  if( ccr->v_cap_cnf_parms )
  {
    /* CCP not supported yet */
  /*
    satShrdPrm.ntfy          = USR_NTF_SETUP_CAL;
    satShrdPrm.capParm.cId   = cId;
    satShrdPrm.capParm.cntxt = CTX_SAT_SETUP;
    satShrdPrm.capParm.CCres = *resId;

    if( psaCC_BCapDecode( BCRI_SAT, ccr->cap_cnf_parms.l_cap_cnf_parms>>3,
                          ccr->cap_cnf_parms.b_cap_cnf_parms ) < 0 )
    {
      psaSAT_SendTrmResp( RSLT_ME_CAP, 0, NULL, NULL, NULL );
      psaCC_FreeCtbNtry (cId);
      return( FALSE );
    }
    else
    {
      return( *resId EQ CCR_ALLW_WITH_MDFY );
    }
  */
  }
}

LOCAL BOOL cmhSAT_result_sim_cc_ussd( SHORT cId,
                                      UBYTE *resId, 
                                      T_ccr_allw *ccr  )
{
  T_ACI_SAT_TERM_RESP resp_data;
  BOOL                ownNotSAT = (satShrdPrm.SIMCCParm.owner NEQ OWN_SAT);  /* flags that the owner is not SAT */
  UBYTE               cmdBuf;                         /* buffer command */
  UBYTE               len = 0;
  T_ACI_RETURN        retVal;
  T_ACI_D_TOC         dummy1;
  T_ACI_D_CLIR_OVRD   dummy2;

  TRACE_FUNCTION("cmhSAT_result_sim_cc_ussd()");

  psaSAT_InitTrmResp( &resp_data );

  /* check for busy SS condition */
  if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY )
  {
    /* respond with "error, ME currently unable to process command" */
    resp_data.add_content = ADD_ME_SS_BUSY;
    resp_data.resCC       = resId;
    psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
    return( FALSE );
  }

  /* call adr to be modified with USSD string*/
  cmdBuf = psaCC_ctb(cId)->curCmd;
  psaCC_FreeCtbNtry (cId);

  if( utl_getAlphabetCb( (UBYTE) ccr->ussd_string.dcs) EQ 0 ) /* 7bit alphabet */
  {
     len=utl_cvt7To8( ccr->ussd_string.ussd_str,
                      ccr->ussd_string.c_ussd_str,
                      (UBYTE*)&satPndSetup.clpty.num, 0);
     satPndSetup.clpty.num[len]=0x00;
  }
  else
  {
     memcpy( satPndSetup.clpty.num, ccr->ussd_string.ussd_str,
             ccr->ussd_string.c_ussd_str );
     satPndSetup.clpty.num[ccr->ussd_string.c_ussd_str]=0x00;
  }

  retVal = cmhCC_chkKeySeq ( satShrdPrm.SIMCCParm.owner,
                             &satPndSetup.clpty, 
                             &dummy1, &dummy2,
                             CC_SIM_NO );

  if( retVal EQ AT_EXCT )
  {
    return( !ownNotSAT );
  }

  if( ownNotSAT )
  {
    R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
        ( cmdBuf, CME_ERR_NotPresent );

    /* log result */
    cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, cmdBuf,
                  -1, -1, CME_ERR_NotPresent );
  }
  /* setup initiated by SAT */
  else
  {
    /* send SAT response */
    resp_data.resCC = resId;
    psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data );
  }

  return( FALSE );  /* primitive not needed anymore */
}


GLOBAL BOOL cmhSAT_ResCalCntrlBySIM( UBYTE* resId, void *ccRes )
{
  UBYTE cmdBuf;                         /* buffer command */
  SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */
  SHORT actId;                          /* holds active call id */
  T_ccr_allw * ccr;                     /* points to CC result */
  BOOL  ownNotSAT;                      /* flags that the owner is not SAT */
  UBYTE idx;                            /* holds index */
  T_ACI_SAT_TERM_RESP resp_data;

#if defined SMI OR defined MFW
  T_ACI_CLOG     cmdLog;      /* holds logging info */
  CHAR           cmdlog_num_buf[MAX_CC_CALLED_NUMBER];  /* buffer where number is written for cmdLog */
  USHORT         length;                       /* length of number */
#endif

  TRACE_FUNCTION("cmhSAT_ResCalCntrlBySIM()");

  psaSAT_InitTrmResp( &resp_data );

  ccr = (T_ccr_allw*)ccRes;

  /* check if queued event download */
  if (satShrdPrm.event.c_queued)
  {
    cmhSAT_EventDwn( -1, -1, -1);
  }

  satShrdPrm.SIMCCParm.busy = FALSE;

  if (!psaCC_ctbIsValid (cId))
  {
    TRACE_ERROR ("Call table entry disappeared");
    return FALSE;
  }

  ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT;

  /*
  ** If this is a Cust1 MMI and The originator was a STK Cmd
  */
  if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND
      (ownNotSAT == FALSE))
  {
    /*
    ** Customised behaviour for the Cust1 MMI
    */
    if (*resId == CCR_NOT_ALLW)
    {
        /* Call Setup not allowed */
          send_error_to_user( ownNotSAT, psaCC_ctb(cId)->curCmd, 
                            RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, 
                            NULL, TRUE);
    }
    else
    {
        /*
        ** This was a SAT initiated call. For the Cust1 the ACI does not yet have any
        ** actions to perform, other than the CC By SIM which has been done. So :
        ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process.
        **
        ** The second action will cause the MMI to request the approriate Call Setup, SS
        ** or USSD Request and the required Call Table entry will then be re-created.
        */
        cmhSAT_Cust1StkCmdInd();
    }
  
    /* Free the Call Table Entry
    ** The SATI indication (if sent) will cause the MMI to request the approriate Call Setup, SS
    ** or USSD Request and the required Call Table entry will then be re-created.
    */
    psaCC_FreeCtbNtry (cId);

    return( FALSE );  /* primitive not needed anymore */
  }

  /* determine result id */
  switch( *resId )
  {
    case( CCR_NOT_ALLW ):
      /* call setup not allowed */
      send_error_to_user( ownNotSAT, psaCC_ctb(cId)->curCmd, 
                          RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, 
                          NULL, TRUE);

      /* memory for number has also been allocated in case of SAT setup call !! */
      psaCC_FreeCtbNtry (cId);
      return( FALSE );  /* primitive not needed anymore */

    case( CCR_ALLW_WITH_MDFY ):
      /* call setup allowed with modification */
      if( ccr->v_ss_string )
      {
        /* if setup was converted into a SS control string */
        return(cmhSAT_result_sim_cc_ss( cId, resId, ccr ));
      }
      else if( ccr->v_addr )
      {
        /* Replace call parameters for this cId with the ones provided by SIM */
        cmhSAT_result_sim_cc_address( cId, ccr );
      }
      else if (ccr->v_ussd_string)
      {
        /* if setup was converted into a USSD control string */
        return(cmhSAT_result_sim_cc_ussd( cId, resId, ccr ));
      }
      else
      {} /* do not change cId parameters */
      break;

    case( CCR_ALLW_NO_MDFY ):
      /* call setup allowed no modification */
      /* use parameters already linked to cId */
      break;
  }

  /* perform call setup initiated by user */
  if( ownNotSAT )
  {
    /* check for an active call */
    actId = psaCC_ctbFindCall( NO_VLD_OWN, CS_ACT, NO_VLD_CT );

    if( actId NEQ NO_ENTRY )
    {
      /* put active on hold if possible */
      if( psaCC_ctb(actId)->prio EQ PRIO_NORM_CALL AND
          cmhCC_getcalltype(actId) EQ VOICE_CALL )
      {
        cmhCC_HoldCall(actId, psaCC_ctb(cId)->curSrc, AT_CMD_D);
      }
      /* reject call setup: already data or emergency call on going */
      else
      {
        cmdBuf = psaCC_ctb(cId)->curCmd;
        psaCC_FreeCtbNtry (cId);

        R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
          ( cmdBuf, CME_ERR_NotPresent );

        /* log result */
        cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, cmdBuf,
                      -1, -1, CME_ERR_NotPresent );

        return( FALSE );  /* primitive not needed anymore */
      }
    }

    /* finally set up call */
    cmhCC_flagCall( cId,
                    &(cmhPrm[psaCC_ctb(cId)->calOwn].ccCmdPrm.mltyCncFlg));

    psaCC_NewCall (cId);


#if defined SMI OR defined MFW
    /* log command */
    cmdLog.atCmd                = AT_CMD_D;
    cmdLog.cmdType              = CLOG_TYPE_Set;
    cmdLog.retCode              = AT_EXCT;
    cmdLog.cId                  = cId+1;
    cmdLog.sId                  = ACI_NumParmNotPresent;
    cmdLog.cmdPrm.sD.srcId      = psaCC_ctb(cId)->curSrc;

    cmdLog.cmdPrm.sD.number     = cmdlog_num_buf;

    /* 
     * For this block wrong code is generated by target compiler 1.22e
     * Use psaCC_ctb() to simplify pointer expression.
     */
#if 0
    if(ccShrdPrm.ctb[cId]->cldPty.c_called_num < MAX_CC_CALLED_NUMBER)
    {
      length = ccShrdPrm.ctb[cId]->cldPty.c_called_num;
    }
    else
      length = MAX_CC_CALLED_NUMBER;

    utl_BCD2String( cmdLog.cmdPrm.sD.number,
                   (UBYTE *) ccShrdPrm.ctb[cId]->cldPty.called_num, 
                   length);
#else
    if(psaCC_ctb(cId)->cldPty.c_called_num < MAX_CC_CALLED_NUMBER)
    {
      length = psaCC_ctb(cId)->cldPty.c_called_num;
    }
    else
      length = MAX_CC_CALLED_NUMBER;

    utl_BCD2String (cmdLog.cmdPrm.sD.number,
                    psaCC_ctb(cId)->cldPty.called_num, 
                    length);
#endif /* else, #if 0 */

    cmdLog.cmdPrm.sD.clirOvrd   = D_CLIR_OVRD_Default; /* ??? */
    cmdLog.cmdPrm.sD.cugCtrl    = D_CUG_CTRL_NotPresent; /* ??? */
    cmdLog.cmdPrm.sD.callType   = psaCC_ctb(cId)->calType;
#ifdef SIM_TOOLKIT
    cmdLog.cmdPrm.sD.simCallCtrl= D_SIMCC_ACTIVE;
#endif  /* SIM tOOLKIT */
    rAT_PercentCLOG( &cmdLog );
#endif  /* SMI or MFW */
    return( FALSE );
  }
  /* perform call setup initiated by SAT */
  else /* Must be normal behaviour, otherwise it would have been trapped earlier in the function */
  {
  
#ifdef FF_SAT_E
   /* if source was open channel command */
   if( satShrdPrm.opchStat EQ OPCH_CCSIM_REQ )
   {
      if(*resId EQ CCR_ALLW_WITH_MDFY) 
        satShrdPrm.opchCCMdfy = TRUE;

      cmhSAT_OpChnAlert( cId );
      return( FALSE );
   }
#endif /* FF_SAT_E */

   /* alert user if command details are supported */
    if( cmhSAT_ChckCmdDet() )
    {
     /* check aoc condition */
      if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND
          (aoc_check_moc() EQ FALSE))
        /*
         * check ACM exceeds ACMmax
         * for non-emergency calls
         */
      {
        resp_data.add_content = ADD_NO_CAUSE;
        resp_data.resCC = (*resId EQ CCR_ALLW_WITH_MDFY)? resId: NULL;


        psaSAT_SendTrmResp(RSLT_ME_UNAB_PROC, &resp_data);
        psaCC_FreeCtbNtry (cId);
        return( FALSE );
      }

      for( idx = 0; idx < CMD_SRC_MAX; idx++ )
      {

#ifdef FF_SAT_E 
         T_ACI_SATA_ADD addPrm;

         addPrm.chnType = SATA_CT_VOICE;
         addPrm.chnEst  = SATA_EST_IM;

         R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur, &addPrm );
#else          
         R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur );         
#endif /* FF_SAT_E */         
      }

      satShrdPrm.ntfy = USR_NTF_SETUP_CAL;
    }
    return( FALSE );
  }
}

LOCAL BOOL sim_control_setup_call( T_ccr_allw *ccr, BOOL ownNotSAT )
{
  SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */
  UBYTE idx;                            /* holds index */
#ifdef FF_SAT_E  
  T_ACI_SATA_ADD addPrm;
#endif /* FF_SAT_E */
  cId = psaCC_ctbNewEntry();

  if( cId EQ NO_ENTRY )
  {
    send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_ME_UNAB_PROC, ADD_NO_CAUSE, NULL, FALSE);
    return( FALSE );  /* primitive not needed anymore */
  }

  /* fill in setup parameter for called address */
  cmhSAT_fillSetupPrm ( cId,
                        ((ccr->v_addr)?&ccr->addr:NULL),
                        ((ccr->v_subaddr)?&ccr->subaddr:NULL));
  /* new call table entry set default bearer capabilities */
  cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES );

  /* check aoc condition */
  if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND
      (aoc_check_moc() EQ FALSE))
    /* check ACM exceeds ACMmax for non-emergency calls */
  {
    send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_ME_UNAB_PROC, ADD_NO_CAUSE, NULL, FALSE);
    psaCC_FreeCtbNtry (cId);
    return( FALSE );
  }

  if( ccr->v_cap_cnf_parms )
  {
    /* check bearer caps, ctb not allocated */
  }

  /* declare call table entry as used and the owner and status
     of the call */
  psaCC_ctb(cId)->calOwn     = satShrdPrm.SIMCCParm.owner;
  psaCC_ctb(cId)->calStat    = CS_SAT_REQ;
  psaCC_ctb(cId)->curCmd     = AT_CMD_D;
  psaCC_ctb(cId)->curSrc     = satShrdPrm.SIMCCParm.owner;

  if( !ownNotSAT ) psaCC_ctb(cId)->SATinv = TRUE;

  /* alert user */
  if( ownNotSAT )
  {
#ifdef FF_SAT_E  
    addPrm.chnType = SATA_CT_VOICE;
    addPrm.chnEst  = SATA_EST_IM;

    R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner )
      ( cId+1, satShrdPrm.dur, &addPrm );
#else
    R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner )
      ( cId+1, satShrdPrm.dur);
#endif /* FF_SAT_E */ 

    R_AT( RAT_OK, satShrdPrm.SIMCCParm.owner )
      ( AT_CMD_D );
    /* log result */
    cmh_logRslt ( satShrdPrm.SIMCCParm.owner,
                  RAT_OK, AT_CMD_D, -1, -1, -1 );
  }
   /* setup initiated by SAT */
  else
  {
    for( idx = 0; idx < CMD_SRC_MAX; idx++ )
    {
#ifdef FF_SAT_E  
      addPrm.chnType = SATA_CT_VOICE;
      addPrm.chnEst  = SATA_EST_IM;
      R_AT( RAT_SATA, idx )
        ( cId+1, satShrdPrm.dur, &addPrm );
#else 
      R_AT( RAT_SATA, idx )
        ( cId+1, satShrdPrm.dur);
#endif /* FF_SAT_E */
    }
  }
  return( !ownNotSAT );
}


/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_ResSSCntrlBySIM       |
+-------------------------------------------------------------------+

  PURPOSE : Handle SIM SS control result. Return TRUE if primitive
            is needed for building a terminal response.

*/

GLOBAL BOOL cmhSAT_ResSSCntrlBySIM( UBYTE* resId, void *ccRes )
{
  SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */
  T_ccr_allw * ccr;                     /* points to CC result */
  BOOL  ownNotSAT;                      /* flags that the owner is not SAT */

  TRACE_FUNCTION("cmhSAT_ResSSCntrlBySIM()");
  
  ccr = (T_ccr_allw*)ccRes;

  /* check if queued event download */
  if (satShrdPrm.event.c_queued)
  {
    cmhSAT_EventDwn( -1, -1, -1);
  }

  satShrdPrm.SIMCCParm.busy = FALSE;

  ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT;

  /*
  ** If this is a Cust1 MMI and The originator was a STK Cmd
  */
  if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND
      (ownNotSAT == FALSE))
  {
      /*
      ** Customised behaviour for the Cust1 MMI
      */
      if (*resId == CCR_NOT_ALLW)
      {
          send_error_to_user( ownNotSAT,
                                             AT_CMD_D,
                                             RSLT_CC_SIM_PRM,
                                             ADD_CC_NOT_ALLWD,
                                             NULL, FALSE);
      }
      else
      {
          /*
          ** This was a SAT initiated Request. For the Cust1 the ACI does not yet have any
          ** actions to perform, other than the CC By SIM which has been done. So :
          ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process.
          **
          ** The second action will cause the MMI to request the approriate Call Setup, SS
          ** or USSD Request and the required Call Table entry will then be re-created.
          */
          cmhSAT_Cust1StkCmdInd();
      }
    
      /* Free the Call Table Entry
      ** The SATI indication (if sent) will cause the MMI to request the approriate Call Setup, SS
      ** or USSD Request and the required Call Table entry will then be re-created.
      */
      if (psaCC_ctbIsValid (cId))
      {
        psaCC_retMOCTi(psaCC_ctb(cId)->ti);
        psaCC_chngCalTypCnt(cId, -1);
        psaCC_FreeCtbNtry (cId);
      }
      return( FALSE );  /* primitive not needed anymore */
  }


/* determine result id */
  switch( *resId )
  {
    case( CCR_NOT_ALLW ): /* SS not allowed */
    {
      send_error_to_user( ownNotSAT, AT_CMD_D, RSLT_CC_SIM_PRM, ADD_CC_NOT_ALLWD, NULL, FALSE);
      if (ownNotSAT EQ FALSE)
      {
        /* clear call ID */
        if (psaCC_ctbIsValid (cId))
        {
          psaCC_retMOCTi(psaCC_ctb(cId)->ti);
          psaCC_chngCalTypCnt(cId, -1);
          psaCC_FreeCtbNtry (cId);
        }
      }
      return( FALSE );  /* primitive not needed anymore */
    }
    case( CCR_ALLW_WITH_MDFY ): /* SS allowed with modification */
    {
      if( ccr->v_addr )
      {
        /* if SS control string was converted into a call setup */
        return(sim_control_setup_call( ccr, ownNotSAT ));
      }
      else if( ccr->v_ss_string )
      {
        /* if SS control string was changed by sim control */

        /* adjust SS control string */
        cmhCC_init_cldPty( &satPndSetup.clpty ); /* erase previous ss string */

        utl_BCD2DialStr( ccr->ss_string.ss_ctrl_string,
                         satPndSetup.clpty.num,
                         (UBYTE)MINIMUM(ccr->ss_string.c_ss_ctrl_string,
                                        MAX_DIAL_LEN-1));
        satPndSetup.clpty.ton = ccr->ss_string.noa;
        satPndSetup.clpty.npi = ccr->ss_string.npi;

        sim_control_send_ss( &satPndSetup.clpty, AT_CMD_D, ownNotSAT, NULL );
        return(FALSE);
      }
      else  /* if no optionnal field, then assume no modification see 11.14 ?9.1.6 */
        sim_control_send_ss( &satPndSetup.clpty, AT_CMD_D, ownNotSAT, NULL );
        return(FALSE);
    }
    /* SS allowed no modification */
    default:
      TRACE_ERROR ("Unknown resID in cmhSAT_ResSSCntrlBySIM!");
      /*lint -fallthrough*/
    case( CCR_ALLW_NO_MDFY ):
      sim_control_send_ss( &satPndSetup.clpty, AT_CMD_D, ownNotSAT, NULL );
      return( FALSE );  /* primitive not needed anymore */
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_ResUSSDCntrlBySIM     |
+-------------------------------------------------------------------+

  PURPOSE : Handle SIM USSD control result. Return TRUE if primitive
            is needed for building a terminal response.

*/

GLOBAL BOOL cmhSAT_ResUSSDCntrlBySIM( UBYTE* resId, void *ccRes )
{
  T_ACI_RETURN retVal;                  /* holds return value */
  T_ccr_allw * ccr;                     /* points to CC result */
  UBYTE idx;                            /* holds index */
  BOOL  ownNotSAT;                      /* flags that the owner is not SAT */
  SHORT sId;
  T_ACI_SAT_TERM_RESP resp_data;
#ifdef FF_SAT_E 
  T_ACI_SATA_ADD addPrm;
#endif
  UBYTE *ussdString;
  UBYTE ussdLen;
  UBYTE src_len;



  TRACE_FUNCTION ("cmhSAT_ResUSSDCntrlBySIM()");

  psaSAT_InitTrmResp( &resp_data );

  ccr = (T_ccr_allw*)ccRes;

  /* check if queued event download */
  if (satShrdPrm.event.c_queued)
  {
    cmhSAT_EventDwn( -1, -1, -1);
  }

  satShrdPrm.SIMCCParm.busy = FALSE;

  ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT;

  /*
  ** If this is a Cust1 MMI and The originator was a STK Cmd
  */
  if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND
      (ownNotSAT == FALSE))
  {
      /*
      ** Customised behaviour for the Cust1 MMI
      */
      if (*resId == CCR_NOT_ALLW)
      {
          /* send SAT response */
          resp_data.add_content = ADD_CC_NOT_ALLWD;
          psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data );
      }
      else
      {
          /*
          ** This was a SAT initiated Request. For the Cust1 the ACI does not yet have any
          ** actions to perform, other than the CC By SIM which has been done. So :
          ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process.
          */
          cmhSAT_Cust1StkCmdInd();
      }

      return( FALSE );  /* primitive not needed anymore */
  }

/*
 *----------------------------------------------------------------
 * determine result id
 *----------------------------------------------------------------
 */
  switch( *resId )
  {
    /*
     *------------------------------------------------------------
     * SS not allowed
     *------------------------------------------------------------
     */
    case( CCR_NOT_ALLW ):

       /* setup initiated by user */
      if( ownNotSAT )
      {
        R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
          ( AT_CMD_D, CME_ERR_NotPresent );
        /* log result */
        cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D,
                      -1, -1, CME_ERR_NotPresent );
      }
       /* setup initiated by SAT */
      else
      {
        /* send SAT response */
        resp_data.add_content = ADD_CC_NOT_ALLWD;
        psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data );
      }
      return( FALSE );  /* primitive not needed anymore */

    /*
     *------------------------------------------------------------
     * USSD allowed with modification
     *------------------------------------------------------------
     */
    case( CCR_ALLW_WITH_MDFY ):

      /* if USSD control string was converted into a call setup */
      if( ccr->v_addr )
      {
        SHORT cId = psaCC_ctbNewEntry();

        if( cId EQ NO_ENTRY )
        {
          /* 
           * We got no free slot in the call table
           */
          if( ownNotSAT )
          {
            R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
              ( AT_CMD_D, CME_ERR_NotPresent );
            /* log result */
            cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D,
                          -1, -1, CME_ERR_NotPresent );
          }
           /* setup initiated by SAT */
          else
          {
            /* send SAT response */
            resp_data.add_content = ADD_NO_CAUSE;
            psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
          }
          return( FALSE );  /* primitive not needed anymore */
        }

        /*
         * We have successfully allocated a slot in the call table
         */

        /* fill in setup parameter for called address */
        cmhSAT_fillSetupPrm ( cId,
                              ((ccr->v_addr)?&ccr->addr:NULL),
                              ((ccr->v_subaddr)?&ccr->subaddr:NULL));
        /* new call table entry set default bearer capabilities */
        cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES );

       /* check aoc condition */
        if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND
            (aoc_check_moc() EQ FALSE))
          /*
           * check ACM exceeds ACMmax
           * for non-emergency calls
           */
        {
          if( ownNotSAT )
          {
            R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
              ( AT_CMD_D, CME_ERR_NotPresent );
            /* log result */
            cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D,
                          -1, -1, CME_ERR_NotPresent );
          }
           /* setup initiated by SAT */
          else
          {
            resp_data.add_content = ADD_NO_CAUSE;
            psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
          }
          psaCC_FreeCtbNtry (cId);
          return( FALSE );
        }

        if( ccr->v_cap_cnf_parms )
        {
          /* check bearer caps, ctb not allocated */
        }


        /* declare call table entry as used and the owner and status
           of the call */
        psaCC_ctb(cId)->calOwn     = satShrdPrm.SIMCCParm.owner;
        psaCC_ctb(cId)->calStat    = CS_SAT_REQ;
        psaCC_ctb(cId)->curCmd     = AT_CMD_D;
        psaCC_ctb(cId)->curSrc     = satShrdPrm.SIMCCParm.owner;

        if( !ownNotSAT )
          psaCC_ctb(cId)->SATinv = TRUE;

        /* alert user */
        if( ownNotSAT )
        {

#ifdef FF_SAT_E
          addPrm.chnType = SATA_CT_VOICE;
          addPrm.chnEst  = SATA_EST_IM;

          R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner )
            ( cId+1, satShrdPrm.dur, &addPrm );
#else
          R_AT( RAT_SATA, satShrdPrm.SIMCCParm.owner )
            ( cId+1, satShrdPrm.dur);
#endif /* FF_SAT_E */

          R_AT( RAT_OK, satShrdPrm.SIMCCParm.owner )
            ( AT_CMD_D );
          /* log result */
          cmh_logRslt ( satShrdPrm.SIMCCParm.owner,
                        RAT_OK, AT_CMD_D, -1, -1, -1 );
        }
         /* setup initiated by SAT */
        else
        {
          for( idx = 0; idx < CMD_SRC_MAX; idx++ )
          {
#ifdef FF_SAT_E
            addPrm.chnType = SATA_CT_VOICE;
            addPrm.chnEst  = SATA_EST_IM;

            R_AT( RAT_SATA, idx )
              ( cId+1, satShrdPrm.dur, &addPrm );
#else             
            R_AT( RAT_SATA, idx )
              ( cId+1, satShrdPrm.dur);
#endif 
          }
        }

        return( !ownNotSAT );
      }

      /* --- no break, continue with next case --- */
      /*lint -fallthrough*/

    /*
     *------------------------------------------------------------
     * USSD allowed no modification
     *------------------------------------------------------------
     */
    default:
      TRACE_ERROR ("unknown resID in cmhSAT_ResUSSDCntrlBySIM");
      /*lint -fallthrough*/
    case( CCR_ALLW_NO_MDFY ):

      /* check for busy SS condition */
      if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY )
      {
        /* respond with "error, ME currently unable to process command" */
        resp_data.add_content = ADD_ME_USSD_BUSY;
        psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
        return( FALSE );
      }

      /* adjust SS control string */
      if( ccr->v_ussd_string )
      {
        memcpy( &(satPndSetup.ussd_str),
                &ccr->ussd_string,
                sizeof(T_ussd_string));
      }

      /********************************************************************************/
      /*
       *-------------------------------------------------------------------
       * check if there is a USSD request pending
       *-------------------------------------------------------------------
       */
      sId = psaSS_stbFindUssdReq();

      if( sId EQ NO_ENTRY )
      {
        /* check if there is another service in progress */
        if( psaSS_stbFindActSrv( sId ) NEQ NO_ENTRY )
        {
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_ParallelUSSD );
          return( AT_FAIL );
        }

        /* get new service table entry */
        sId = psaSS_stbNewEntry();
        if( sId EQ NO_ENTRY )
        {
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
          return( AT_FAIL );
        }

        CCD_START;

        MALLOC(ussdString, MAX_USSD_STRING);

        /* set data coding scheme */
        /* patch !!!!! CLB 11/12/01      */
        if( (UBYTE)satPndSetup.ussd_str.dcs EQ 0x40 )
        {
          /* 0x40 means basically default alphabet...
          yet some asian networks dont seem to accept it (although using it
          in their own STK !!!) */
          satPndSetup.ussd_str.dcs = 0x0F;
        }
        /*********************************/
       if( utl_getAlphabetCb( (UBYTE)satPndSetup.ussd_str.dcs ) EQ 0 ) /* 7bit alphabet */
       {
         src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, satPndSetup.ussd_str.c_ussd_str); 
         ussdLen = utl_cvt8To7( satPndSetup.ussd_str.ussd_str,
                             src_len,
                             ussdString, 0 );
         /* According to spec 23.038 section 6.1.2.3 for USSD packing, for bytes end with
          * (8*n)-1 i.e where n is 1,2,3....i.e byte 7, 15, 23 ... to be padded 
          * with carriage return <CR>(0xD) 
          */
         if ((src_len+1)%8 EQ 0)
         {
           ussdString[ussdLen-1] |= (0xD << 1);
         }
       }
       else
       {
         ussdLen = satPndSetup.ussd_str.c_ussd_str;
         memcpy(ussdString, satPndSetup.ussd_str.ussd_str, MAX_USSD_STRING);
       }
       psaSS_asmProcUSSDReq( (UBYTE)satPndSetup.ussd_str.dcs /*dcs*/,
                              ussdString,
                              ussdLen);
       MFREE(ussdString);

        /* start new transaction */
        ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;

        if (ownNotSAT)   
        {
            ssShrdPrm.stb[sId].curCmd = AT_CMD_CUSD;
            ssShrdPrm.stb[sId].srvOwn = satShrdPrm.SIMCCParm.owner;
        }
        else
        {
            ssShrdPrm.stb[sId].curCmd = AT_CMD_NONE;
            ssShrdPrm.stb[sId].srvOwn = OWN_SAT;
            satShrdPrm.SentUSSDid     = sId;
        }
        psaSS_NewTrns(sId);

        if (ownNotSAT)
        {
          R_AT( RAT_OK, satShrdPrm.SIMCCParm.owner )
                  ( AT_CMD_CUSD);

          cmh_logRslt ( satShrdPrm.SIMCCParm.owner,
                        RAT_OK, AT_CMD_CUSD, -1, -1, -1 );
        }

        CCD_END;

        retVal = AT_EXCT;
      }
      else
      {
        CCD_START;

        psaSS_asmCnfUSSDReq( (UBYTE)satPndSetup.ussd_str.dcs,
                             satPndSetup.ussd_str.ussd_str,
                             satPndSetup.ussd_str.c_ussd_str );

        ssShrdPrm.stb[sId].ussdReqFlg = FALSE;

        /* continue existing transaction */
        psaSS_CntTrns(sId);

        CCD_END;

        retVal = AT_CMPL;
      }
    /**********************************************************************************/

      if( retVal EQ AT_EXCT )
        return( FALSE );  /* primitive not needed anymore */

      if( ownNotSAT )
      {
        R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
              ( AT_CMD_D, CME_ERR_NotPresent );
        /* log result */
        cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, AT_CMD_D,
                      -1, -1, CME_ERR_NotPresent );
      }
      /* setup initiated by SAT */
      else
      {
        /* send SAT response */
        resp_data.resCC = resId;
        psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data );
      }

      return( FALSE );  /* primitive not needed anymore */
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH_SATR                     |
|                            ROUTINE : cmhSAT_ResSMCntrlBySIM       |
+-------------------------------------------------------------------+

  PURPOSE : Handle SIM SM  control result. Return TRUE if primitive
            is needed for building a terminal response.

*/

GLOBAL BOOL cmhSAT_ResSMCntrlBySIM( UBYTE* resId, void *smcRes )
{
  BOOL  ownNotSAT;                      /* flags that the owner is not SAT */
  T_smcr_allw *smcr;                    /* points to SM result */
  T_ACI_CMGF_MOD mode;
  UBYTE sca_buf[MAX_SMS_ADDR_DIG/2 + 2];
  UBYTE da_buf[MAX_SMS_ADDR_DIG/2 + 2];
  UBYTE sca_len = 0;
  UBYTE da_len = 0;
  T_ACI_SAT_TERM_RESP resp_data;
  UBYTE srcId = smsShrdPrm.smsEntStat.entOwn;

  TRACE_FUNCTION ("cmhSAT_ResSMCntrlBySIM()");


  psaSAT_InitTrmResp( &resp_data );

  smcr = (T_smcr_allw*)smcRes;

  /* check if queued event download */
  if (satShrdPrm.event.c_queued)
  {
    cmhSAT_EventDwn( -1, -1, -1);
  }

  satShrdPrm.SIMCCParm.busy = FALSE;

  ownNotSAT = satShrdPrm.SIMCCParm.owner NEQ OWN_SAT;

  /*
  ** If this is a Cust1 MMI and The originator was a STK Cmd
  */
  if ((simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) AND
      (ownNotSAT == FALSE))
  {
      /*
      ** Customised behaviour for the Cust1 MMI
      */
      if (*resId == CCR_NOT_ALLW)
      {
            /* send SAT response */
            resp_data.add_content = ADD_CC_NOT_ALLWD;
            psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data );
      }
      else
      {
          /*
          ** This was a SAT initiated Request. For the Cust1 the ACI does not yet have any
          ** actions to perform, other than the CC By SIM which has been done. So :
          ** Send the Original STK Cmd to the MMI in a %SATI for the MMI to process.
          **
          ** The second action will cause the MMI to request the approriate Call Setup, SS
          ** or USSD Request and the required Call Table entry will then be re-created.
          */
          cmhSAT_Cust1StkCmdInd();
      }
    
      if ( (sat_mnsms_submit_req->rec_num EQ  SMS_RECORD_NOT_EXIST) OR
           (sat_mnsms_submit_req->modify  NEQ SMS_MODIFY_NON) )
      {
        if (smsShrdPrm.tpdu.tp_submit NEQ NULL)
        {
          ACI_MFREE(smsShrdPrm.tpdu.tp_submit);
          smsShrdPrm.tpdu.tp_submit = NULL;
        }
      }
      PFREE( sat_mnsms_submit_req );

      /*
      ** Ensure that the SMS parameters are reset, so that the SMS Entity is freed to
      ** process the command later.
      */
      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
      smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = CMD_SRC_NONE;

      return( FALSE );  /* primitive not needed anymore */
  }

  if (smsShrdPrm.smsEntStat.curCmd EQ AT_CMD_CMSS)
  {
    mode = CMGF_MOD_Txt;
  }
#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
  else if (smsShrdPrm.smsEntStat.entOwn EQ CMD_SRC_LCL)
  {
    mode = CMGF_MOD_Txt; /* since text mode (AT+CMGF=1) is never set in MMI */
  }
#endif
  else if (ownNotSAT EQ FALSE)
  {
    mode = CMGF_MOD_Pdu;
  }
  else
  {
    /*
     * request current mode
     */
    qAT_PlusCMGF(srcId, &mode);
  }

/*
 *----------------------------------------------------------------
 * determine result id
 *----------------------------------------------------------------
 */
  switch( *resId )
  {
    /*
     *------------------------------------------------------------
     * send message not allowed
     *------------------------------------------------------------
     */
    case( CCR_NOT_ALLW ):
       /* setup initiated by user */
      if( ownNotSAT )
      {
        R_AT( RAT_CME, satShrdPrm.SIMCCParm.owner )
          ( smsShrdPrm.smsEntStat.curCmd, CME_ERR_NotPresent );
        /* log result */
        cmh_logRslt ( satShrdPrm.SIMCCParm.owner, RAT_CME, smsShrdPrm.smsEntStat.curCmd,
                      -1, -1, CME_ERR_NotPresent );

        smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
        smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
      }
       /* setup initiated by SAT */
      else
      {
        /* send SAT response */
        resp_data.add_content = ADD_CC_NOT_ALLWD;
        psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data );
      }

      if ( (sat_mnsms_submit_req->rec_num EQ  SMS_RECORD_NOT_EXIST) OR
           (sat_mnsms_submit_req->modify  NEQ SMS_MODIFY_NON) )
      {
        if (smsShrdPrm.tpdu.tp_submit NEQ NULL)
        {
          ACI_MFREE(smsShrdPrm.tpdu.tp_submit);
          smsShrdPrm.tpdu.tp_submit = NULL;
        }
      }
      PFREE( sat_mnsms_submit_req );
      return( FALSE );  /* primitive not needed anymore */


    case( CCR_ALLW_WITH_MDFY ):
      if ( smcr->v_sm_addr )
      {
        /*
         * RP Service Center Address
         */

        sat_mnsms_submit_req->modify |= SMS_MODIFY_SCA;

        if (mode EQ CMGF_MOD_Pdu)
        {
          /* PDU mode */
          sca_len = CodeRPAddress( sca_buf,
                                    smcr->sm_addr.c_bcdDigit,
                                    smcr->sm_addr.noa,
                                    smcr->sm_addr.npi,
                                    smcr->sm_addr.bcdDigit );

          cmhSAT_ModifyScaPdu( &sat_mnsms_submit_req->sms_sdu,
                               sca_buf,
                               sca_len );
        }
        else
        {
          /* Text mode */
          smsShrdPrm.tpdu.sc_addr.v_ton = 1;
          smsShrdPrm.tpdu.sc_addr.ton = smcr->sm_addr.noa;
          smsShrdPrm.tpdu.sc_addr.v_npi = 1;
          smsShrdPrm.tpdu.sc_addr.npi = smcr->sm_addr.npi;
          smsShrdPrm.tpdu.sc_addr.c_num = smcr->sm_addr.c_bcdDigit;
          memcpy(smsShrdPrm.tpdu.sc_addr.num, smcr->sm_addr.bcdDigit,
                 smcr->sm_addr.c_bcdDigit);
        }
      }

      if ( smcr->v_sm_addr_2)
      {
        /*
         * TP Destination Address
         */

        sat_mnsms_submit_req->modify |= SMS_MODIFY_TPOA;

        if (mode EQ CMGF_MOD_Pdu)
        {
          /* PDU  mode */
          da_len = CodeTPAddress( da_buf,
                                   smcr->sm_addr_2.c_bcdDigit,
                                   smcr->sm_addr_2.noa,
                                   smcr->sm_addr_2.npi,
                                   smcr->sm_addr_2.bcdDigit );

          cmhSAT_ModifyDaPdu( &sat_mnsms_submit_req->sms_sdu,
                              da_buf,
                              da_len );
        }
        else
        {
          /* Text mode */
          smsShrdPrm.tpdu.tp_submit->tp_da.ton    = smcr->sm_addr_2.noa;
          smsShrdPrm.tpdu.tp_submit->tp_da.npi    = smcr->sm_addr_2.npi;
          smsShrdPrm.tpdu.tp_submit->tp_da.c_num  = smcr->sm_addr_2.c_bcdDigit;
          smsShrdPrm.tpdu.tp_submit->tp_da.digits = smcr->sm_addr_2.c_bcdDigit;
          memcpy(smsShrdPrm.tpdu.tp_submit->tp_da.num, smcr->sm_addr_2.bcdDigit,
                 smcr->sm_addr_2.c_bcdDigit);
        }
      }
      /* no break needed !!!! */
      /*lint -fallthrough*/
    case( CCR_ALLW_NO_MDFY ):
      if( sat_mnsms_submit_req )
      {
        if (mode EQ CMGF_MOD_Txt) /* Text mode */
        {
          /* code sm here */
          cmhSMS_codeMsg (&sat_mnsms_submit_req->sms_sdu,
                          SMS_VT_SUBMIT,
                          &smsShrdPrm.tpdu.sc_addr,
                          SMS_SUBMIT,
                          (UBYTE*)smsShrdPrm.tpdu.tp_submit);

          if (smsShrdPrm.tpdu.tp_submit NEQ NULL)
          {
            ACI_MFREE(smsShrdPrm.tpdu.tp_submit);
            smsShrdPrm.tpdu.tp_submit = NULL;
          }
        }

        PSENDX (SMS, sat_mnsms_submit_req);
      }
      else
        TRACE_EVENT("error provoked by SAT");
      break;

    default:
      if ( (sat_mnsms_submit_req->rec_num EQ SMS_RECORD_NOT_EXIST) OR
           (sat_mnsms_submit_req->modify NEQ SMS_MODIFY_NON) )
      {
        if (smsShrdPrm.tpdu.tp_submit NEQ NULL)
        {
          ACI_MFREE(smsShrdPrm.tpdu.tp_submit);
          smsShrdPrm.tpdu.tp_submit = NULL;
        }
      }
      TRACE_EVENT("wrong type of result received from SIM");
      PFREE( sat_mnsms_submit_req );
      return( FALSE );  /* primitive not needed anymore */
  }

return FALSE;
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : CMH                          |
|                            ROUTINE : cmhCC_SatDTMFsent            |
+-------------------------------------------------------------------+

  PURPOSE : confirmation for sent SAT DTMF
*/
GLOBAL void cmhCC_SatDTMFsent ( SHORT cId )
{
  T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
  T_ACI_SAT_TERM_RESP resp_data;
static UBYTE          dtmf_separator_count = 0;

  TRACE_FUNCTION ("cmhCC_SatDTMFsent()");

  psaSAT_InitTrmResp( &resp_data );

  /*
   * Use ctb here because TI compiler 1.22e may have a problem otherwise here.
   * See cmhCC_SndDiscRsn() for the details.
   */  
  if (GET_CAUSE_VALUE(ctb->nrmCs) NEQ NOT_PRESENT_8BIT AND
      ctb->nrmCs                  NEQ MNCC_CAUSE_DTMF_START_SUCCESS)
  {
    TRACE_EVENT_P1("network reported error when sending DTMF: %d", ctb->nrmCs);
    
    psaSAT_SendTrmResp( RSLT_NTW_UNAB_PROC, &resp_data );
    dtmf_separator_count = 0;
    return;
  }

  if(is_digit_dtmf_separator(ccShrdPrm.dtmf.dig[ccShrdPrm.dtmf.cur]))
  {
    if (dtmf_separator_count EQ 0)
    {
      dtmf_separator_count = 1;
      if(ctb->dtmfCmd NEQ AT_CMD_VTS)  /* this is only valid within a number to dial */
       {
         /* p within a number string: this is a 3 seconds pause */
          TRACE_EVENT("DTMF pause requested: 3 seconds");
#if defined (NEW_FRAME)
          TIMERSTART( TDTMF_VALUE, ACI_TDTMF );
#else
          TIMERSTART( TDTMF_VALUE, t_dtmf_handle );
#endif
          ccShrdPrm.dtmf.cur++;  /* skip the DTMF seperator */

          return;
       }
      ccShrdPrm.dtmf.cur++;  /* skip the DTMF seperator */
    }
  }
  else
  {
    dtmf_separator_count = 0;
  }

  if (ccShrdPrm.dtmf.cur < ccShrdPrm.dtmf.cnt)
  {
    cmhSAT_sendDTMF ( NULL );
  }
  else      /* whole DTMF string has been sent */
  {
    ccShrdPrm.dtmf.cId = NO_ENTRY;               /* Reset cId after sending the whole DTMF string */
    ctb->dtmfCmd = AT_CMD_NONE;
    ctb->dtmfSrc = CMD_SRC_NONE;
    psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
    dtmf_separator_count = 0;
  }
}

#endif /* #ifdef SIM_TOOLKIT */
/*==== EOF ========================================================*/