view src/aci2/aci/psa_satp.c @ 701:35e7f9d0379f

targets: add TARGET_HAS_BUZZER to c11x, c139 and dsample This new target config preprocessor symbol was introduced in Tourmaline in connection with the new approach to playing buzzer melodies via PWT, properly omitting the responsible code on targets where BU output controls the vibrator instead. That code is not present in Magnetite and we have no plans to backport it here, but target header files should be kept consistent between the two trees, especially given that we plan to support FC Venus target in Magnetite.
author Mychaela Falconia <falcon@freecalypso.org>
date Sat, 26 Mar 2022 19:51:34 +0000
parents 93999a60b835
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-PS (6147)
|  Modul   :  PSA_SATP
+----------------------------------------------------------------------------- 
|  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 processing functions for the
|             primitives send to the protocol stack adapter by the
|             SIM application toolkit.
+----------------------------------------------------------------------------- 
*/ 

#ifdef SIM_TOOLKIT

#ifndef PSA_SATP_C
#define PSA_SATP_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_sim.h" /* for simShrdPrm declaration */
#include "psa_sat.h"
#include "psa_sms.h"
#include "cmh.h"
#include "cmh_sat.h"

/*==== CONSTANTS ==================================================*/


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


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


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

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

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : PSA_SATP                |
|                                 ROUTINE : psa_sim_toolkit_ind     |
+-------------------------------------------------------------------+

  PURPOSE : processes the SIM_TOOLKIT_IND primitive send by SIM.
            this is an indication that a STK command was received.

*/

GLOBAL const void psa_sim_toolkit_ind
                         ( T_SIM_TOOLKIT_IND *sim_toolkit_ind )
{
  T_ACI_SAT_TERM_RESP resp_data;

  TRACE_FUNCTION ("psa_sim_toolkit_ind()");

/*
 *-------------------------------------------------------------------
 * update shared parameter
 *-------------------------------------------------------------------
 */

  satShrdPrm.stkCmdLen = sim_toolkit_ind -> stk_cmd.l_cmd;
  satShrdPrm.stkCmd    = sim_toolkit_ind -> stk_cmd.cmd;

  psaSAT_DumpCmd ( &sim_toolkit_ind -> stk_cmd );

/*
 *-------------------------------------------------------------------
 * decode SIM toolkit command
 *-------------------------------------------------------------------
 */
  CCD_START;
  {
    UBYTE ccdRet;

    MCAST( cmd, STK_CMD );
    memset( cmd, 0, sizeof( T_STK_CMD ));

    ccdRet = ccd_decodeMsg (CCDENT_SAT,
                            DOWNLINK,
                            (T_MSGBUF *) &sim_toolkit_ind -> stk_cmd,
                            (UBYTE    *) _decodedMsg,
                            STK_CMD);

    if( ccdRet NEQ ccdOK OR !cmd->v_pas_cmd)
    {
      cmhSAT_STKCmdInd();
    }
    else if( cmd->pas_cmd.v_cmd_details AND cmd->pas_cmd.v_dev_ids )
    {
      /* store command details */
      satShrdPrm.cmdDet.cmdNr   = cmd->pas_cmd.cmd_details.cmd_nr;
      satShrdPrm.cmdDet.cmdType = cmd->pas_cmd.cmd_details.cmd_typ;
      satShrdPrm.cmdDet.cmdQlf  = cmd->pas_cmd.cmd_details.cmd_qlf;

      if (simShrdPrm.overall_cust_mode == (UBYTE)CUST_MODE_BEHAVIOUR_1)
      {
          /*
          ** Customised behaviour for the Cust1 MMI
          */
          switch (cmd->pas_cmd.cmd_details.cmd_typ)
          {
              case SAT_CMD_SETUP_CALL:
              case SAT_CMD_SEND_SMS:
              case SAT_CMD_SEND_SS:
              case SAT_CMD_SEND_USSD:
                  if (satShrdPrm.cust1StkCmd != (void *)0)
                  {
                       /*
                       ** The previous command has not been deleted.
                       */
                       ACI_MFREE(satShrdPrm.cust1StkCmd);

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

                  /*
                  ** Allocate memory to store the command
                  */
                  ACI_MALLOC(satShrdPrm.cust1StkCmd, MAX_STK_CMD);
                  if (satShrdPrm.cust1StkCmd == (void *)0)
                  {
                      /*
                      ** Memory allocation has failed, return ME Unable to Process Cmd
                      */
                      TRACE_EVENT("Memory Allocation Failure");
                      psaSAT_InitTrmResp( &resp_data );
                      psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
                      break;
                  }

                  /*
                  ** Save the received data before proceeding
                  */
                  memset(satShrdPrm.cust1StkCmd, 0, MAX_STK_CMD);
                  /*
                  ** stkCmdLen is the BIT length of the received data, so shift right 3 (divide by 8)
                  ** in order to get the BYTE length
                  */
                  memcpy(satShrdPrm.cust1StkCmd, satShrdPrm.stkCmd, satShrdPrm.stkCmdLen >> 3);
                  satShrdPrm.cust1StkCmdLen = satShrdPrm.stkCmdLen;

                  /*
                  ** Continue the processing as for normal behaviour,
                  ** special processing will be applied later
                  **
                  ** No Break!
                  */

              case SAT_CMD_EVENT_LIST:
                  /*
                  ** This command is processed normally
                  */
                  if( !cmd->pas_cmd.v_cmd_prms OR !cmd->pas_cmd.cmd_prms.l_cmd_prms )
                  {
                      TRACE_EVENT("no parameters in envelope");
                      psaSAT_dasmMECmd( NULL );
                  }
                  else
                      psaSAT_dasmMECmd( &cmd->pas_cmd.cmd_prms );
                  break;

              case SAT_CMD_REFRESH:
                  /*
                  ** This command is to be forwarded to the MMI, for the user to be given the
                  ** chance to accept or reject the Refresh action. The user response will be
                  ** contained in a SATR Response indication, and we must be prepared to
                  ** process that indication in a different manner.
                  */
                  satShrdPrm.cust1SimRefreshRespRqd = TRUE;

                  /*
                  ** Forward the command to the MMI
                  */
                  cmhSAT_STKCmdInd();
                  break;

              default:
                  /*
                  ** If the command is handled by the MMI pass it up in a %SATI indication
                  */
                  if (cmhSAT_IsStkCmdForMmi(cmd->pas_cmd.cmd_details.cmd_typ,
                                                                   cmd->pas_cmd.cmd_details.cmd_qlf) == FALSE)
                  {
                      /*
                      ** Otherwise Determine whether the command is handled in the Modem Part
                      */
                      switch (cmd->pas_cmd.cmd_details.cmd_typ)
                      {
                          case( SAT_CMD_SEND_DTMF ):
                          case( SAT_CMD_RUN_AT ):
                          case( SAT_CMD_LAUNCH_BROWSER ):
                          case (SAT_CMD_PROV_LOC_INFO):
#ifdef FF_SAT_E           
                          case( SAT_CMD_OPEN_CHANNEL ):
#endif /* FF_SAT_E */          
                              if( !cmd->pas_cmd.v_cmd_prms OR !cmd->pas_cmd.cmd_prms.l_cmd_prms )
                              {
                                  TRACE_EVENT("no parameters in envelope");
                                  psaSAT_dasmMECmd( NULL );
                              }
                              else
                                  psaSAT_dasmMECmd( &cmd->pas_cmd.cmd_prms );
                              break;
#ifdef FF_SAT_E 
                          /* special handling for CLOSE CHANNEL, no further decoding required.
                          all that is needed can be found in device identities */
                          case( SAT_CMD_CLOSE_CHANNEL ):
                              cmhSAT_CloseChannel();
                              break;
      
                          /* special handling for SEND DATA, no further decoding required.
                          all that is needed can be found in command details */
                          case( SAT_CMD_SEND_DATA ):
                              cmhSAT_SendData();
                              break;
      
                          /* special handling for GET CHANNEL STATUS, no further decoding required */
                          case( SAT_CMD_GET_CHANNEL_STATUS ):
                              cmhSAT_GetChannelStatus();
                              break;
      
                          /* special handling for RECEIVE DATA, no further decoding required */
                          case( SAT_CMD_RECEIVE_DATA ):
                              cmhSAT_STKUsrNtfy();
                              break;
#endif /* FF_SAT_E */ 

                          /*
                          ** If the command is not handled by the Modem Part, return a "Beyond ME
                          ** Capabilities" response to the SIM Entity.
                          */
                          default:
                              TRACE_EVENT("Unable to handle command");
                              psaSAT_InitTrmResp( &resp_data );
                              psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data );
                      }
                  }
          }
      }
      else
      {
          /* if command is addressed to ACI */
          switch( cmd->pas_cmd.cmd_details.cmd_typ )
          {
            case( SAT_CMD_SETUP_CALL ):
            case( SAT_CMD_SEND_SS ):
            case( SAT_CMD_SEND_SMS ):
            case( SAT_CMD_SEND_USSD ):
            case( SAT_CMD_SEND_DTMF ):
            case( SAT_CMD_EVENT_LIST ):
            case( SAT_CMD_RUN_AT ):
            case( SAT_CMD_LAUNCH_BROWSER ):
            case (SAT_CMD_PROV_LOC_INFO):
#ifdef FF_SAT_E           
            case( SAT_CMD_OPEN_CHANNEL ):
#endif /* FF_SAT_E */          
        if( !cmd->pas_cmd.v_cmd_prms OR !cmd->pas_cmd.cmd_prms.l_cmd_prms )
              {
                TRACE_EVENT("no parameters in envelope");
                psaSAT_dasmMECmd( NULL );
              }
              else
                psaSAT_dasmMECmd( &cmd->pas_cmd.cmd_prms );
              break;
#ifdef FF_SAT_E 
            /* special handling for CLOSE CHANNEL, no further decoding required.
               all that is needed can be found in device identities */
            case( SAT_CMD_CLOSE_CHANNEL ):
              
              cmhSAT_CloseChannel();
              break;

            /* special handling for SEND DATA, no further decoding required.
               all that is needed can be found in command details */
            case( SAT_CMD_SEND_DATA ):
              
              cmhSAT_SendData();
              break;

            /* special handling for GET CHANNEL STATUS, no further decoding required */
            case( SAT_CMD_GET_CHANNEL_STATUS ):
              
              cmhSAT_GetChannelStatus();
              break;

            /* special handling for RECEIVE DATA, no further decoding required */
            case( SAT_CMD_RECEIVE_DATA ):
              
              cmhSAT_STKUsrNtfy();
              break;
#endif /* FF_SAT_E */ 
            /* otherwise pass command to user */
            default:
              cmhSAT_STKCmdInd();
          }
      }
    }
    else
    {
      /* respond with "error, required values are missing" */
      TRACE_EVENT("parameters are missing");
      psaSAT_InitTrmResp( &resp_data );
      psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data );
    }
  }
  CCD_END;

/*
 *-------------------------------------------------------------------
 * free the primitive buffer
 *-------------------------------------------------------------------
 */
  PFREE (sim_toolkit_ind);

}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : PSA_SATP                |
|                                 ROUTINE : psa_sim_toolkit_cnf     |
+-------------------------------------------------------------------+

  PURPOSE : processes the SIM_TOOLKIT_CNF primitive send by SIM.
            this is a confirmation to a previous STK command.

*/

GLOBAL const void psa_sim_toolkit_cnf( T_SIM_TOOLKIT_CNF *sim_toolkit_cnf )
{
  void   *p             = NULL;
  BOOL   SIM_error      = FALSE;
  BOOL   not_allw       = FALSE;
  BOOL   allw           = FALSE;
  void   *p_allw        = NULL;
  UBYTE  *p_v_allw      = NULL;
  void   *p_not_allw    = NULL;
  UBYTE  *p_v_not_allw  = NULL;
  void   *p_allw_mdfy   = NULL;
  UBYTE  *p_v_allw_mdfy = NULL;
  SHORT  StructSize     = 0;
  UBYTE  DynEnv         = '\0';

  TRACE_FUNCTION ("psa_sim_toolkit_cnf()");
/*
 *-------------------------------------------------------------------
 * update shared parameter
 *-------------------------------------------------------------------
 */
  satShrdPrm.stkCmdLen = sim_toolkit_cnf -> stk_cmd.l_cmd;
  satShrdPrm.stkCmd    = sim_toolkit_cnf -> stk_cmd.cmd;
  satShrdPrm.stkError  = sim_toolkit_cnf -> cause;

  psaSAT_DumpCmd ( &sim_toolkit_cnf -> stk_cmd );

/*
 *-------------------------------------------------------------------
 * if request was invoked by MMI pass reply to MMI
 *-------------------------------------------------------------------
 */
  if( sim_toolkit_cnf -> req_id EQ SRQ_MMI )
  {
    cmhSAT_STKCmdCnf();
  }

/*
 *-------------------------------------------------------------------
 * if request was invoked by ACI decode envelope command result
 *-------------------------------------------------------------------
 */
  else if( sim_toolkit_cnf -> req_id EQ SRQ_ACI )
  {
    if( sim_toolkit_cnf -> stk_cmd.l_cmd EQ 0 OR
        sim_toolkit_cnf -> cause EQ SIM_CAUSE_SAT_BUSY)
    {
      SIM_error = TRUE;

      switch ( sim_toolkit_cnf -> cause )
      {
      case SIM_CAUSE_OTHER_ERROR:
      case SIM_CAUSE_SAT_BUSY:
      case SIM_CAUSE_CARD_REMOVED:
      case SIM_CAUSE_PIN1_EXPECT:
      case SIM_CAUSE_PIN1_BLOCKED:
      case SIM_CAUSE_PUK1_EXPECT:
      case SIM_CAUSE_PUK1_BLOCKED:
      case SIM_CAUSE_PIN2_EXPECT:
      case SIM_CAUSE_PIN2_BLOCKED:
      case SIM_CAUSE_PUK2_EXPECT:
      case SIM_CAUSE_PUK2_BLOCKED:
         /* in case of certain errors, assume not allowed */
        not_allw = TRUE;
        sim_toolkit_cnf -> stk_cmd.cmd[0] = CCR_NOT_ALLW;
        break;

      default:
         /* in case of a positive result without further info,
                     assume allowed not modified */
        allw = TRUE;
        sim_toolkit_cnf -> stk_cmd.cmd[0] = CCR_ALLW_NO_MDFY;
        break;
      }
      sim_toolkit_cnf -> stk_cmd.cmd[1] = 0; /* no extra TLVs */
      satShrdPrm.stkCmdLen = 2<<3;  /* 2 bytes result */
    }

    else
    {
      SIM_error = FALSE;
    }


    {
      CCD_START;
      {
        UBYTE ccdRet;
        MCAST( env, ENV_RES );
        MCAST( smc_env, ENV_RES_SMC );

        switch( satShrdPrm.SIMCCParm.ccAct )
        {
          case( CC_ACT_CAL ):
          case( CC_ACT_SS ):
          case( CC_ACT_USSD ):
            memset( env, 0, sizeof( T_ENV_RES ));
            p_v_not_allw  = &env->v_ccr_not_allw;
            p_v_allw      = &env->v_ccr_allw;
            p_v_allw_mdfy = &env->v_ccr_allw_mdfy;
            p_not_allw    = &env->ccr_not_allw;
            p_allw        = &env->ccr_allw;
            p_allw_mdfy   = &env->ccr_allw_mdfy;
            DynEnv        = ENV_RES;
            break;
          case( SMC_ACT_MO ):
            memset( smc_env, 0, sizeof( T_ENV_RES_SMC ));
            p_v_not_allw  = &smc_env->v_smcr_not_allw;
            p_v_allw      = &smc_env->v_smcr_allw;
            p_v_allw_mdfy = &smc_env->v_smcr_allw_mdfy;
            p_not_allw    = &smc_env->smcr_not_allw;
            p_allw        = &smc_env->smcr_allw;
            p_allw_mdfy   = &smc_env->smcr_allw_mdfy;
            DynEnv        = ENV_RES_SMC;
            break;
        }

        if (SIM_error)
        {
          *p_v_not_allw = not_allw;
          *p_v_allw     = allw;
        }
         /* otherwise decode message */
        else
        {
          ccdRet = ccd_decodeMsg (CCDENT_SAT,
                                  DOWNLINK,
                                  (T_MSGBUF *) &sim_toolkit_cnf -> stk_cmd,
                                  (UBYTE    *) _decodedMsg,
                                  DynEnv );

          if( ccdRet NEQ ccdOK )
          {
            /* in case of a result failure, pretend allowed not modified */
            if( psaSAT_ccdErrChk() NEQ 0 AND
                (!(*p_v_allw) AND !(*p_v_not_allw) AND !(*p_v_allw_mdfy)))
            {
              memset( env, 0, StructSize );
              *p_v_allw = TRUE;
              sim_toolkit_cnf -> stk_cmd.cmd[0] = CCR_ALLW_NO_MDFY;
              sim_toolkit_cnf -> stk_cmd.cmd[1] = 0;
              satShrdPrm.stkCmdLen = 2<<3;  /* 2 bytes result */
            }
          }
        }

        /* process result */

        if     ( *p_v_allw      ) p = p_allw;
        else if( *p_v_not_allw  ) p = p_not_allw;
        else if( *p_v_allw_mdfy ) p = p_allw_mdfy;


        satShrdPrm.ntfy = USR_NTF_CC_SIM;
        cmhSAT_STKUsrNtfy();

        switch( satShrdPrm.SIMCCParm.ccAct )
        {
          case( CC_ACT_CAL ):

            if( cmhSAT_ResCalCntrlBySIM( sim_toolkit_cnf -> stk_cmd.cmd, p ))
            {
              /* keep primitive for terminal response */
              satShrdPrm.stkCnfPrim = sim_toolkit_cnf;
              CCD_END;
              return;
            }
            break;

          case( CC_ACT_SS ):

            if( cmhSAT_ResSSCntrlBySIM( sim_toolkit_cnf -> stk_cmd.cmd, p ))
            {
              /* keep primitive for terminal response */
              satShrdPrm.stkCnfPrim = sim_toolkit_cnf;
              CCD_END;
              return;
            }
            break;

          case( CC_ACT_USSD ):

            if( cmhSAT_ResUSSDCntrlBySIM( sim_toolkit_cnf -> stk_cmd.cmd, p ))
            {
              /* keep primitive for terminal response */
              /*satShrdPrm.stkCnfPrim = sim_toolkit_cnf;*/
              CCD_END;
              return;
            }
            break;

          case( SMC_ACT_MO ):
            if( cmhSAT_ResSMCntrlBySIM( sim_toolkit_cnf -> stk_cmd.cmd, p ))
            {
              /* keep primitive for terminal response */
              /*satShrdPrm.stkCnfPrim = sim_toolkit_cnf;*/
              CCD_END;
              return;
            }
            break;

          default:
            TRACE_EVENT("UNEXP CC ACTION IN SAT PARMS");
            break;
         }
      }

      satShrdPrm.SIMCCParm.ccAct = NO_CC_ACT;
      CCD_END;
    }
  }

/*
 *-------------------------------------------------------------------
 * free the primitive buffer
 *-------------------------------------------------------------------
 */
  PFREE (sim_toolkit_cnf);

}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : PSA_SATP                |
|                                 ROUTINE : psa_sim_file_update_ind |
+-------------------------------------------------------------------+

  PURPOSE : processes the FILE_UPDATE_IND primitive send by SIM.
            It provides a list of updated EFs.

*/

GLOBAL const void psa_sim_file_update_ind
                      ( T_SIM_FILE_UPDATE_IND *sim_file_update_ind )
{
  SHORT i;
  BOOL send_confirm_now=TRUE;

  TRACE_FUNCTION ("psa_sim_file_update_ind()");

/*
 *-------------------------------------------------------------------
 * store the primitive and start processing
 *-------------------------------------------------------------------
 */
  satShrdPrm.fu_ind = sim_file_update_ind;

  /*
  *   Broadcast %SIMEF unsolicited event to all interested parties.
  */
  for(i=CMD_SRC_LCL;i<CMD_SRC_MAX;i++)
  {
    /*
    *   For a source in BAT mode, this event is permanently
    *   enabled. However, it is useful to make it configurable
    *   in ATI/BAT mode in order to ensure that by default
    *   psaSAT_FUConfirm() is called, maintaining compatibility
    *   with existing tests.
    */
#if defined(FF_BAT) && !defined(FF_ATI_BAT)
    if ((simShrdPrm.SIMEFMode[i] EQ SIMEF_MODE_ON)
      OR (aci_cmd_src_mode_get(i) EQ CMD_MODE_BAT))
#else
    if (simShrdPrm.SIMEFMode[i] EQ SIMEF_MODE_ON)
#endif
    {
      /*
      *   As we have reported the EF update, it is not now the
      *   responsibility of this function to send the response
      *   immediately.
      */
      send_confirm_now=FALSE;

      R_AT(RAT_P_SIMEF,i)(
        (SHORT *)sim_file_update_ind->file_id,
        (UBYTE)sim_file_update_ind->val_nr);
    }
  }
 
  /*
  *   If we didn't report the EF update to anyone we must send
  *   the response now.
  */
  if (send_confirm_now NEQ FALSE)
    psaSAT_FUConfirm (-1, NOT_PRESENT_16BIT);
}

#endif /* #ifdef SIM_TOOLKIT */

/*==== EOF =========================================================*/