view src/g23m-gsm/sms/sms_rl.c @ 110:056d0a19ed5b

mmiGprs.h: bogotab fixes
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 09 Nov 2020 01:12:23 +0000
parents fa8dc04885d8
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-F&D (8411)
|  Modul   :  SMS_RL
+----------------------------------------------------------------------------- 
|  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 Modul defines the functions for the relay layer
|             of the component SMS.
+----------------------------------------------------------------------------- 
*/   

#ifndef SMS_RL_C
#define SMS_RL_C

#define ENTITY_SMS

/*==== INCLUDES ===================================================*/

#define SAP_RR    /* get RR causes until all causes are in one document */
#define SAP_MMCM  /* same reason */

#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include "typedefs.h"
#include "pcm.h"
#include "vsi.h"
#include "custom.h"
#include "gsm.h"
#include "message.h"
#include "ccdapi.h"
#include "prim.h"
#include "cus_sms.h"
#include "cnf_sms.h"
#include "mon_sms.h"
#include "pei.h"
#include "tok.h"
#include "sms.h"
#include "sms_em.h"

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

/*==== PRIVAT ======================================================*/

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

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

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_init                    |
+--------------------------------------------------------------------+

  PURPOSE : Initialize the relay layer.

*/

GLOBAL void rl_init (void)
{
  GET_INSTANCE_DATA;    

  TRACE_FUNCTION ("rl_init()");

  sms_data->data[0].state[STATE_RL] = RL_IDLE;
  sms_data->data[1].state[STATE_RL] = RL_IDLE;
}

/*---- SIGNALS -----------------------------------------------------*/

#ifdef GPRS
GLOBAL void rl_proceed (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_proceed()");

  if (SMS_INST_GET_STATE (STATE_RL) EQ RL_WAIT_FOR_SEND_ERROR)
  {
    SMS_INST_SET_STATE (STATE_RL, RL_IDLE);

    tl_report_ind (NULL, CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS,
                   SMSRP_ORIGINATING_ENTITY, SMS_RP_CS_PROTOCOL_ERROR));
  }
}
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_data_ind                |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_DATA_IND.

*/

GLOBAL void rl_data_ind (T_cp_user_data_dl *cp_user_data_dl)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_data_ind()");

  if (sms_data)
  {
    if (cp_user_data_dl->rp_mti EQ RP_ERROR_DL)
      TRACE_EVENT_P1 ("RP_ERROR.CAUSE rcvd: 0x%2.2X",
                      (int)cp_user_data_dl->rp_error.rp_cause.rp_cause_value);

    switch (SMS_INST_GET_STATE (STATE_RL))
    {
   /* ------------------------------------- */
      case RL_ESTABLISHED:
   /* ------------------------------------- */
      case RL_IDLE:
   /* ------------------------------------- */
      {
        SMS_RP_REF(sms_data) = cp_user_data_dl->reference;
        if (cp_user_data_dl->rp_mti EQ RP_DATA_DL)
        {
         /*
          * RL state transition RL_WAIT_FOR_SEND_ACK
          */
          SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_SEND_ACK);
         /*
          * start timer TR2M
          */
          sms_timer_start(TR2M);

          SMS_EM_RECEIVE_RP_DATA;
         /*
          * TL_DATA_IND =>
          */
          tl_data_ind (&cp_user_data_dl->rp_data_dl);
        }
        else
        {
          MCAST (cp_data, U_CP_DATA);
          /*
           * If Message Id is unknwon then send RP-ERROR with cause #97
           */
          if(cp_user_data_dl->rp_mti > 0x06)
          {
            rl_build_rp_error (cp_user_data_dl->reference,
                               SMS_RP_CS_MSG_NON_EXIST,
                               cp_data, NULL);
          }
          else
          {
            rl_build_rp_error (cp_user_data_dl->reference,
                               SMS_RP_CS_MSG_NOT_COMP,
                               cp_data, NULL);
          }

          SMS_EM_SEND_RP_ERROR;

          cp_data_req (cp_data);
         /*
          * CP_RELEASE_REQ =>
          */
          TRACE_EVENT("CP_RELEASE_REQ_1");
      
          cp_release_req (SMS_INST.ti);
         /*
          * free instance
          */
          FREE_SMS_INSTANCE (SMS_INST.ti);
        }
        break;
      }

   /* ------------------------------------- */
      case RL_WAIT_FOR_ACK:
   /* ------------------------------------- */

        TRACE_FUNCTION ("rl_data_ind(): RP_WAIT_FOR_ACK");

        switch (cp_user_data_dl->rp_mti)
        {
          case RP_ACK_DL:
            TRACE_FUNCTION ("rl_data_ind(): RP_ACK_DL");
           /*
            * stop timer TR1M
            */
            sms_timer_stop(TR1M);
           /*
            * RL state transition RL_IDLE
            */
            SMS_INST_SET_STATE (STATE_RL, RL_IDLE);

            /* 
             * if CMMS mode is 1 or 2 then only make cmm_release_pending TRUE
             */
            if(CMMS_ACTIVE)
            {
               sms_data->cmms_release_pending = TRUE;
            }

           /*
            * TL_REPORT_IND =>
            */
            tl_report_ind (((cp_user_data_dl->rp_ack.v_rp_user_data)?
                            &cp_user_data_dl->rp_ack.rp_user_data:
                            NULL), SMS_NO_ERROR);           

            /* Since the transmission is successful, the data stored for 
               retransmission can be freed */
            if (SMS_DATA_REQ(sms_data) NEQ NULL)
            {
              PFREE (SMS_DATA_REQ(sms_data));
              SMS_DATA_REQ(sms_data) = NULL;
            }

            SMS_EM_RECEIVE_RP_AKNOWLEDGE;

            break;

          case RP_ERROR_DL:
            /* When an RP-error with appropriate case value is 
            * is received, Retransmission of SMS is started
            */
          {
#ifdef REL99
            BOOL retrans_flag = FALSE;
#endif
            TRACE_FUNCTION ("rl_data_ind(): RP_ERROR_DL");
           /*
            * stop timer TR1M
            */
            sms_timer_stop(TR1M);
           /* 
            * if CMMS mode is 1 or 2 then only make cmm_release_pending TRUE
            */
            if(CMMS_ACTIVE)
            {
               sms_data->cmms_release_pending = TRUE;
            }
#ifdef REL99
            /*
             * This is done for Retransmission for the causes
             * listed in the table 8.4/3gPP TS 24.011(Part 1)
             */
             if (SMS_INST.tl_retx < TL_MAX_RETANS)
            {             
              /* Check whether the cause value satisfies the one for retransmission 
               *  listed in the table 8.4/3gPP TS 24.011(Part 1)
               */  
              switch(cp_user_data_dl->rp_error.rp_cause.rp_cause_value)
              {
                case SMS_RP_CS_UNASSIGNED_NUMBER:         
                case SMS_RP_CS_OPERATOR_DET_BARRED:       
                case SMS_RP_CS_CALL_BARRED:      
                case SMS_RP_CS_SM_TRANSFER_REJECTED:
                case SMS_RP_CS_MEM_CAP_EXCEEDED:
                case SMS_RP_CS_UNIDENT_SUBSCRIBER:
                case SMS_RP_CS_FACILITY_REJECTED:
                case SMS_RP_CS_UNKNOWN_SUBSCRIBER:
                case SMS_RP_CS_NET_OUT_OF_ORDER:
                case SMS_RP_CS_NO_RESOURCES:
                case SMS_RP_CS_FAC_NOT_SUBSCRIBED:
                case SMS_RP_CS_FAC_NOT_IMPL:
                case SMS_RP_CS_INV_SM_TR_REF_VAL:
                case SMS_RP_CS_SEM_INC_MSG:
                case SMS_RP_CS_INV_MAND_INFO:
                case SMS_RP_CS_MSG_NON_EXIST:
                case SMS_RP_CS_INFO_NON_EXIST:
                case SMS_RP_CS_PROTOCOL_ERROR:
                case SMS_RP_CS_INTERWORKING:
                  retrans_flag = FALSE;
                  break;
                /* All values other than the ones above are treated as temporary
                  failures. This includes SMS_RP_CS_DEST_OUT_OF_ORDER, 
                  SMS_RP_CS_TEMP_FAILURE, SMS_RP_CS_CONGESTION, 
                  SMS_RP_CS_MSG_NOT_COMP and others non-standard values
                  are taken as temporary error */
                default:
                  retrans_flag = TRUE;
                  break;
              }
            }
            if(retrans_flag EQ TRUE)
            {
              TRACE_EVENT ("Retransmission cause received");
              cp_release_req(SMS_INST.ti);
              TIMERSTART (SMS_INST_TR1M, 20000);
              TRACE_EVENT ("Delay expiry TR1M, retransmit");
            }
            else
#endif
            {
              /*
               * RL state transition RL_IDLE
               */
              SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
              tl_report_ind (((cp_user_data_dl->rp_error.v_rp_user_data)?
                            &cp_user_data_dl->rp_error.rp_user_data: NULL),
                           CAUSE_MAKE(DEFBY_STD, ORIGSIDE_NET, SMSRP_ORIGINATING_ENTITY,
                           cp_user_data_dl->rp_error.rp_cause.rp_cause_value));
               SMS_EM_RECEIVE_RP_ERROR;
             }
          }
          break;


          default:
            TRACE_FUNCTION ("rl_data_ind(): default");

           /*
            * stop timer TR1M
            */
            sms_timer_stop(TR1M);

            {
              MCAST (cp_data_ul, U_CP_DATA);
              /*
               * If Message Id is unknwon then send RP-ERROR with cause #97
               */
              if(cp_user_data_dl->rp_mti > 0x06)
              {
                rl_build_rp_error (cp_user_data_dl->reference,
                                   SMS_RP_CS_MSG_NON_EXIST,
                                   cp_data_ul, NULL);
              }
              else
              {
                rl_build_rp_error (cp_user_data_dl->reference,
                                   SMS_RP_CS_PROTOCOL_ERROR,
                                   cp_data_ul, NULL);
              }

              cp_data_req (cp_data_ul);
            }
#ifdef GPRS   /* interworking from flow control */
            if (SMS_LLC_FLOW(sms_data) NEQ SMS_LLC_BUSY_WAITING)
#endif
            {
              SMS_INST_SET_STATE (STATE_RL, RL_IDLE);

              /* 
               * if CMMS mode is 1 or 2 and current link used is GSM then only
               * make cmm_release_pending TRUE
               */
#ifdef GPRS
              if(CMMS_ACTIVE AND (SMS_INST.downlink EQ SMS_DOWNLINK_MMSMS))
              {
                 sms_data->cmms_release_pending = TRUE;
              }
#endif
              /*
              * TL_REPORT_IND =>
              */
             /*
              * If Message Id is unknwon then send TL REPORT IND with cause #97
              */
              if(cp_user_data_dl->rp_mti > 0x06)
              {
                tl_report_ind (NULL, CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS,
                               SMSRP_ORIGINATING_ENTITY, SMS_RP_CS_MSG_NON_EXIST));
              }
              else
              {
                tl_report_ind (NULL, CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS,
                               SMSRP_ORIGINATING_ENTITY, SMS_RP_CS_PROTOCOL_ERROR));
              }
             
            }
#ifdef GPRS
            else
            {
              SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_SEND_ERROR);
            }
#endif

            SMS_EM_RECEIVE_UNKNOWN_2;

            break;
        }

        break;

      case RL_WAIT_FOR_SEND_ACK:
        TRACE_FUNCTION ("rl_data_ind(): RP_WAIT_FOR_SEND_ACK");
        {
          MCAST (cp_data_ul, U_CP_DATA);
         /*
          * If Message Id is unknwon then send RP-ERROR with cause #97
          */
          if(cp_user_data_dl->rp_mti > 0x06)
          {
            rl_build_rp_error (cp_user_data_dl->reference,
                               SMS_RP_CS_MSG_NON_EXIST,
                               cp_data_ul, NULL);
          }
          else
          {
            rl_build_rp_error (cp_user_data_dl->reference,
                               SMS_RP_CS_PROTOCOL_ERROR,
                               cp_data_ul, NULL);
          }
          cp_data_req (cp_data_ul);

        }
        break;

   /* ------------------------------------- */
      case RL_WAIT_FOR_SMMA_ACK:
   /* ------------------------------------- */

        TRACE_FUNCTION ("rl_data_ind(): RP_WAIT_FOR_SMMA_ACK");

        switch (cp_user_data_dl->rp_mti)
        {
          case RP_ACK_DL:
            TRACE_FUNCTION ("rl_data_ind(): RP_ACK_DL");
           /*
            * stop timer TR1M
            */
            sms_timer_stop(TR1M);

            SMS_INST.retrans  = FALSE;
           /*
            * RL state transition RL_IDLE
            */
            SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
           /*
            * TL_REPORT_IND =>
            */
            tl_report_ind (NULL, SMS_NO_ERROR);
            break;

          case RP_ERROR_DL:
            TRACE_FUNCTION ("rl_data_ind(): RP_ERROR_DL");

            if (rl_temp_failure (cp_user_data_dl->rp_error.
                                 rp_cause.rp_cause_value))
            {
              if (SMS_INST.retrans)
              {
               /*
                * RL state transition RL_IDLE
                */
                SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
                SMS_INST.retrans = FALSE;

               /*
                * TL_REPORT_IND =>
                */
                tl_report_ind (NULL,
                               CAUSE_MAKE(DEFBY_STD, ORIGSIDE_NET, SMSRP_ORIGINATING_ENTITY,
                               cp_user_data_dl->rp_error.rp_cause.rp_cause_value));
                sms_timer_stop(TR1M);

                tl_sms_memo_exceeded (TRUE);
               /*
                * stop timer TR1M
                */
              }
              else
              {
                SMS_INST.retrans  = TRUE;
               /*
                * RL state transition RL_WAIT_FOR_RETRANS_TIMER
                */
                SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_RETRANS_TIMER);
               /*
                * stop timer TR1M
                */
                sms_timer_stop(TR1M);
               /*
                * start timer TRAM
                */
                sms_timer_start(TRAM);
               /*
                * CP_RELEASE_REQ =>
                */
                TRACE_EVENT("CP_RELEASE_REQ_11");
                cp_release_req (SMS_INST.ti);
        
              }
            }
            else
            {
             /*
              * stop timer TR1M
              */

              sms_timer_stop(TR1M);
              SMS_INST.retrans  = FALSE;
             /*
              * RL state transition RL_IDLE
              */
              SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
             /*
              * TL_REPORT_IND =>
              */
          
              tl_report_ind (NULL,
                             CAUSE_MAKE(DEFBY_STD, ORIGSIDE_NET, SMSRP_ORIGINATING_ENTITY,
                             cp_user_data_dl->rp_error.rp_cause.rp_cause_value));

              tl_sms_memo_exceeded (TRUE);
                  
            }
            break;

          default:
            TRACE_FUNCTION ("rl_data_ind(): default");
           /*
            * stop timer TR1M
            */
            sms_timer_stop(TR1M);

            SMS_INST.retrans  = FALSE;
           /*
            * RL state transition RL_IDLE
            */
            SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
           /*
            * If Message Id is unknwon then send RP-ERROR with cause #97
            */
            if(cp_user_data_dl->rp_mti > 0x06)
            {
              MCAST (cp_data, U_CP_DATA);
              rl_build_rp_error (cp_user_data_dl->reference,
                                 SMS_RP_CS_MSG_NON_EXIST,
                                 cp_data, NULL);
              SMS_EM_SEND_RP_ERROR;
              cp_data_req (cp_data);
              tl_report_ind (NULL, CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS,
                             SMSRP_ORIGINATING_ENTITY, SMS_RP_CS_MSG_NON_EXIST));
            }
            break;
        }
        break;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_establish_req           |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_ESTABLISH_REQ.

*/

GLOBAL void rl_establish_req (UBYTE ti)
{
  GET_INSTANCE_DATA;
    TRACE_FUNCTION_P1 ("rl_establish_req(TI=%u)", ti);
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
      case RL_IDLE:
       /*
        * RL state transition RL_ESTABLISH
        */
        SMS_INST_SET_STATE (STATE_RL, RL_ESTABLISH);
       /*
        * CP_ESTABLISH_REQ =>
        */
        cp_establish_req(ti);
       /*
        * start timer TR1M
        */
        sms_data->timer_ti = ti;
        sms_timer_start(TR1M);
        break;
      default:
        TRACE_ERROR("RL_ESTABLISH_REQ in wrong state received!");
   }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_establish_cnf           |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_ESTABLISH_CNF.

*/

GLOBAL void rl_establish_cnf (BOOL         success)
{
   GET_INSTANCE_DATA;
    TRACE_FUNCTION ("rl_establish_cnf()");
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
      case RL_ESTABLISH:
       /*
        * stop timer TR1M
        */
        sms_timer_stop(TR1M);
        if (success EQ TRUE)
        {
          /*
           * RL state transition RL_ESTABLISHED
           */
           SMS_INST_SET_STATE (STATE_RL, RL_ESTABLISHED);
        }
        else
        {
          /*
           * RL state transition RL_IDLE
           */
           SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
        }
       /*
        * TL_ESTABLISH_CNF =>
        */
        tl_establish_cnf(success);
        break;
      default:
        TRACE_ERROR("RL_ESTABLISH_CNF in wrong state received!");
   }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_release_req             |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_RELEASE_REQ.

*/

GLOBAL void rl_release_req ( UBYTE  ti)
{
    TRACE_FUNCTION_P1 ("rl_release_req(TI=%u)", ti);
   /*
    * CP_RELEASE_REQ =>
    */
    TRACE_EVENT("CP_RELEASE_REQ_13");
    cp_release_req(ti);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_data_req                |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_DATA_REQ.

*/
GLOBAL BOOL rl_data_req (UBYTE       msg_ref,
                         T_U_CP_DATA *cp_data)
{
  GET_INSTANCE_DATA;    
  TRACE_FUNCTION ("rl_data_req()");

  if (sms_data)
  {
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
      case RL_ESTABLISHED:
      {
        SMS_INST.msg_ref  = msg_ref;
       /*
        * RL state transtion RL_WAIT_FOR_ACK
        */
        SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_ACK);

        SMS_EM_SEND_RP_DATA;

        cp_data->cp_user_data_ul.rp_mti = RP_DATA_UL;
        cp_data->cp_user_data_ul.reference = msg_ref;
       /*
        * CP_DATA_REQ =>
        */
        cp_data_req (cp_data);
       /*
        * start timer TR1M
        */
        sms_timer_start(TR1M);

        return TRUE;
      }
      default:
        TRACE_ERROR("RL_DATA_REQ in wrong state received!");
        break;
    }
  }
  return FALSE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_error_ind               |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_ERROR_IND.

*/

GLOBAL void rl_error_ind (USHORT     cause)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_error_ind()");

  if (sms_data)
  {
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
   /* --------------------------------- */
      case RL_ESTABLISH:
   /* --------------------------------- */

        if ( SMS_INST.tl_retx < TL_MAX_RETANS )
        {
          switch ( cause )
          {
            case MMCM_MMCS_MESSAGE_INCOMPAT:
            case RRCS_NORM:
              /* 
               * start timer TR1M with value
               */
              TIMERSTART ( SMS_INST_TR1M, 20000 );
              TRACE_EVENT ( "Delay expiry TR1M, retransmit" );
              return;

            default: /* No retransmission */
              break;
          }
        }

       /*
        * stop timer TR1M
        */
        sms_timer_stop(TR1M);
       /*FALLTHROUGH*/ /*lint -fallthrough*/
   /* --------------------------------- */
      case RL_ESTABLISHED:
   /* --------------------------------- */
       /*
        * RL state transition RL_IDLE
        */
        SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
       /*
        * free instance
        */
        FREE_SMS_INSTANCE (SMS_INST.ti);
       /*
        * TL_REPORT_IND
        */
        tl_report_ind (NULL, cause);
        break;

   /* --------------------------------- */
      case RL_WAIT_FOR_ACK:
   /* --------------------------------- */
        TRACE_FUNCTION ("rl_error_ind(): RL_WAIT_FOR_ACK");
        /* 
         * The following code is to implement a subset of 
         * 3GPP 23.040 Release 1999 subclause 9.2.3.6.
         * For certain errors the SMS SUBMIT / SMS COMMAND is repeated
         * after timeout of TR1M.
         */
        TRACE_EVENT_P2 ("TL retrans #%d, error_cs %04x",
                        SMS_INST.tl_retx,
                        cause);

        if (SMS_INST.tl_retx < TL_MAX_RETANS)
        {
          switch (cause)
          {
            case SMS_CAUSE_NET_TIMEOUT:
             /* 11.10 test case 34.2.2 step 68 */
             /*
              * start timer TR1M with value
              */
              TIMERSTART (SMS_INST_TR1M, 20000);
              TRACE_EVENT ("Delay expiry TR1M, retransmit");
              return;

            case RRCS_NORM:
            case MMCM_MMCS_MESSAGE_INCOMPAT: /* Make cingular happy, #19189 */
              TRACE_EVENT ("Retransmission after TR1M");
              return;

            default: /* No retransmission */
              break;
          }
        }
       /*
        * stop timer TR1M
        */
        sms_timer_stop(TR1M);
       /*
        * RL state transition RL_IDLE
        */
        SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
       /*
        * free instance
        */
        FREE_SMS_INSTANCE (SMS_INST.ti);
       /*
        * TL_REPORT_IND =>
        */
        tl_report_ind (NULL, cause);
        break;

   /* --------------------------------- */
      case RL_WAIT_FOR_SEND_ACK:
   /* --------------------------------- */

        TRACE_FUNCTION ("rl_error_ind(): RL_WAIT_FOR_SEND_ACK");
       /*
        * free instance
        */
        FREE_SMS_INSTANCE (SMS_INST.ti);
       /*
        * stop timer TR2M
        */
        sms_timer_stop(TR2M);
       /*
        * RL state transition RL_IDLE
        */
        SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
       /*
        * TL_REPORT_IND =>
        */
        tl_report_ind (NULL, cause);
        break;

   /* --------------------------------- */
        case RL_WAIT_FOR_SMMA_ACK:
   /* --------------------------------- */

        TRACE_FUNCTION ("rl_error_ind(): RL_WAIT_FOR_SMMA_ACK");
        
        // FREE_SMS_INSTANCE (SMS_INST.ti);

        if (SMS_INST.retrans)
        {
         /*
          * RL state transition RL_IDLE
          */
          SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
          SMS_INST.retrans = FALSE;
         /*
          * TL_REPORT_IND =>
          */
          tl_report_ind (NULL, SMS_CAUSE_NET_TIMEOUT);
         /*
          * stop timer TR1M
          */
          sms_timer_stop(TR1M);
          tl_sms_memo_exceeded (TRUE);

        }
        else
        {
          SMS_INST.retrans  = TRUE;
         /*
          * RL state transition RL_WAIT_FOR_RETRANS_TIMER
          */
          SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_RETRANS_TIMER);
         /*
          * stop timer TR1M
          */
          sms_timer_stop(TR1M);
         /*
          * start timer TRAM
          */
          sms_timer_start(TRAM);
         /*
          * CP_RELEASE_REQ =>
          */
          TRACE_EVENT("CP_RELEASE_REQ_15");
          cp_release_req (SMS_INST.ti);

         /*
          * free instance
          */
          FREE_SMS_INSTANCE (SMS_INST.ti);
        }

        break;
    

      default:
        
        if(CMMS_ACTIVE)
        {
           tl_cmms_end();
        }
       /*
        * free instance
        */
        FREE_SMS_INSTANCE (SMS_INST.ti);
       /*
        * RL state transition RL_IDLE
        */
        
        SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
        break;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_mem_avail_req           |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_MEM_AVAIL_REQ.

*/

GLOBAL BOOL rl_mem_avail_req (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_mem_avail_req()");

  if (sms_data)
  {
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
      case RL_ESTABLISHED:
      {
        CCD_START;
        {
          MCAST (cp_data, U_CP_DATA);
         /*
          * RL state transition RL_WAIT_FOR_SMMA_ACK
          */
          SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_SMMA_ACK);
          SMS_RP_REF(sms_data) = SMS_INST.tp_mr;

          rl_build_rp_smma (SMS_RP_REF(sms_data), cp_data);

          CCD_END;
         /*
          * CP_DATA_REQ =>
          */
          cp_data_req (cp_data);
        }
       /*
        * start timer TR1M
        */
        sms_timer_start(TR1M);    
        return TRUE;

      default:
        TRACE_ERROR("RL_MEM_AVAIL_REQ in wrong state received!");
        break;
      }
    }
  }
  return FALSE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_start_tram_req          |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_START_TRAM_REQ.

*/

GLOBAL void rl_start_tram_req (void)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_start_tram_req()");
          
  SMS_INST.retrans  = TRUE;
 /*
  * RL state transition RL_WAIT_FOR_RETRANS_TIMER
  */
  SMS_INST_SET_STATE (STATE_RL, RL_WAIT_FOR_RETRANS_TIMER);
 /*
  * start timer TRAM
  */
  sms_timer_start(TRAM);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_build_rp_ack            |
+--------------------------------------------------------------------+

  PURPOSE : Processing the function RL_BUILD_RP_ACK.

*/

LOCAL void rl_build_rp_ack (UBYTE          msg_ref,
                            T_U_CP_DATA    *cp_data,
                            T_rp_user_data *rp_user_data)
{
  TRACE_FUNCTION ("rl_build_rp_ack()");

  memset (&cp_data->cp_user_data_ul.rp_ack, 0, sizeof (T_rp_ack));

  cp_data->msg_type                  = U_CP_DATA;
  cp_data->cp_user_data_ul.rp_mti    = RP_ACK_UL;
  cp_data->cp_user_data_ul.reference = msg_ref;

  cp_data->cp_user_data_ul.v_rp_data_ul  = FALSE;
  cp_data->cp_user_data_ul.v_rp_error    = FALSE;
  cp_data->cp_user_data_ul.v_rp_ack      = TRUE;

  if (rp_user_data NEQ NULL AND rp_user_data->v_tpdu)
  {
    memcpy (&cp_data->cp_user_data_ul.rp_ack.rp_user_data,
            rp_user_data, sizeof (T_rp_user_data));
    cp_data->cp_user_data_ul.rp_ack.v_rp_user_data = TRUE;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_report_req_ack          |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_REPORT_REQ_ACK.

*/

GLOBAL void rl_report_req_ack (T_rp_user_data *rp_user_data)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_report_req_ack()");

  if (sms_data)
  {
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
      case RL_WAIT_FOR_SEND_ACK:
      {
        MCAST (cp_data, U_CP_DATA);
       /*
        * stop timer TR2M
        */
        sms_timer_stop(TR2M);

        rl_build_rp_ack (SMS_RP_REF(sms_data), cp_data, rp_user_data);
       /*
        * RL state transition RL_IDLE
        */
        SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
       /*
        * CP_DATA / RP_ACK ==>
        */
        cp_data_req (cp_data);
       /*
        * CP_RELEASE_REQ =>
        */
        TRACE_EVENT("CP_RELEASE_REQ_16");
        cp_release_req (SMS_INST.ti);
        break;
      }
      default:
        break;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_build_rp_error          |
+--------------------------------------------------------------------+

  PURPOSE : Processing the function RL_BUILD_RP_ERROR.

*/

GLOBAL void rl_build_rp_error (UBYTE          msg_ref,
                               USHORT         error,
                               T_U_CP_DATA    *cp_data,
                               T_rp_user_data *rp_user_data)
{
  TRACE_FUNCTION ("rl_build_rp_error()");
  TRACE_EVENT_P1 ("RP_ERROR.CAUSE sent: 0x%2.2X", (int)error);

  memset (&cp_data->cp_user_data_ul.rp_error, 0, sizeof (T_rp_error));

  cp_data->msg_type                  = U_CP_DATA;
  cp_data->cp_user_data_ul.rp_mti    = RP_ERROR_UL;
  cp_data->cp_user_data_ul.reference = msg_ref;

  cp_data->cp_user_data_ul.v_rp_data_ul  = FALSE;
  cp_data->cp_user_data_ul.v_rp_ack      = FALSE;
  cp_data->cp_user_data_ul.v_rp_error    = TRUE;

  cp_data->cp_user_data_ul.rp_error.
           rp_cause.v_rp_cause_value = TRUE;
  if (error < 128)              /* GSM 04.11 cause */
  {
    cp_data->cp_user_data_ul.rp_error.
             rp_cause.rp_cause_value = (UBYTE)error;
  }
  else
  {
    cp_data->cp_user_data_ul.rp_error.
             rp_cause.rp_cause_value = SMS_RP_CS_PROTOCOL_ERROR;
    cp_data->cp_user_data_ul.rp_error.
             v_rp_user_data = TRUE;
  }
  if (rp_user_data NEQ NULL AND rp_user_data->v_tpdu)
  {
    memcpy (&cp_data->cp_user_data_ul.rp_error.rp_user_data,
            rp_user_data, sizeof (T_rp_user_data));
    cp_data->cp_user_data_ul.rp_error.v_rp_user_data = TRUE;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_report_req_error        |
+--------------------------------------------------------------------+

  PURPOSE : Processing the signal RL_REPORT_REQ_ERROR.

*/

GLOBAL void rl_report_req_error (USHORT         cause,
                                 T_rp_user_data *rp_user_data)
{
  GET_INSTANCE_DATA;
  TRACE_FUNCTION ("rl_report_req_error()");

  if (sms_data)
  {
    switch (SMS_INST_GET_STATE (STATE_RL))
    {
      case RL_WAIT_FOR_SEND_ACK:
      {
        MCAST (cp_data, U_CP_DATA);
       /*
        * stop timer TR2M
        */
        sms_timer_stop(TR2M);

        rl_build_rp_error (SMS_RP_REF(sms_data), cause,
                           cp_data, rp_user_data);
       /*
        * RL state transition RL_IDLE
        */
        SMS_INST_SET_STATE (STATE_RL, RL_IDLE);
       /*
        * CP_DATA / RP_ERROR ==>
        */
        cp_data_req (cp_data);
        break;
      }
      default:
        break;
    }
  }
}

#if defined (GPRS)
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_build_rp_error_gprs     |
+--------------------------------------------------------------------+

  PURPOSE : Processing the function RL_BUILD_RP_ERROR for GSMS.

*/

GLOBAL void rl_build_rp_error_gprs (UBYTE              ti,
                                    T_LL_UNITDATA_REQ  *data_req,
                                    USHORT             error,
                                    UBYTE              msg_ref,
                                    T_U_CP_DATA        *cp_data,
                                    T_stk_cmd          *stk_cmd)
{
  TRACE_FUNCTION ("rl_build_rp_error_gprs()");
  TRACE_EVENT_P1 ("RP_ERROR.CAUSE sent: 0x%4.2X", (int)error);

  data_req->sdu.o_buf = ENCODE_OFFSET;

  cp_data->msg_type                  = U_CP_DATA;
  cp_data->cp_user_data_ul.rp_mti    = RP_ERROR_UL;
  cp_data->cp_user_data_ul.reference = msg_ref;

  cp_data->cp_user_data_ul.v_rp_data_ul  = FALSE;
  cp_data->cp_user_data_ul.v_rp_error    = TRUE;

  memset (&cp_data->cp_user_data_ul.rp_error.rp_cause, 0,
          sizeof (T_rp_cause));

  cp_data->cp_user_data_ul.rp_error.
           rp_cause.v_rp_cause_value = TRUE;
  if (error < 128)              /* GSM 04.11 cause */
  {
    cp_data->cp_user_data_ul.rp_error.
             rp_cause.rp_cause_value = (UBYTE)error;
    cp_data->cp_user_data_ul.rp_error.
             v_rp_user_data = FALSE;
  }
  else
  {
    cp_data->cp_user_data_ul.rp_error.
             rp_cause.rp_cause_value = SMS_RP_CS_PROTOCOL_ERROR;
    cp_data->cp_user_data_ul.rp_error.
             v_rp_user_data = TRUE;
    memset (&cp_data->cp_user_data_ul.rp_error.rp_user_data,
            0, sizeof (T_rp_user_data));
    if (error >= 256)           /* no GSM 03.40 cause */
      error = SMS_FCS_UNSPECIFIED;
    cp_data->cp_user_data_ul.rp_error.rp_user_data.
             v_tpdu = TRUE;
  /*
    cp_data->cp_user_data_ul.rp_error.rp_user_data.
             sms_deliver_rep_err.tp_fcs = (UBYTE)error;
   */
  }

  ccd_codeMsg (CCDENT_SMS,
               UPLINK,
               (T_MSGBUF *) &data_req->sdu,
               (UBYTE *) cp_data,
               NOT_PRESENT_8BIT);
  /*lint -e415 -e416 Likely creation/access of out-of-bounds pointer */
  data_req->sdu.buf[3] = (ti << 4) + PD_SMS;
  data_req->sdu.o_buf  = ENCODE_OFFSET - BSIZE_TI_PD;
  data_req->sdu.l_buf += BSIZE_TI_PD;

  if (stk_cmd NEQ NULL)
  {
    /*
     * response from a SIM Toolkit command
     */
    if (stk_cmd->l_cmd NEQ 0)
    {
      /*
       * response TPDU available
       */
      /* change length of rp-error */
      data_req->sdu.buf[5] += ((stk_cmd->l_cmd >> 3) + 2);
      /* add IEI for rp user data */
      data_req->sdu.buf[10] = 0x41;
      /* add length for rp user data */
      data_req->sdu.buf [11] = stk_cmd->l_cmd >> 3;
      /* add TPDU */
      memcpy (&data_req->sdu.buf [12],
              &stk_cmd->cmd[stk_cmd->o_cmd>>3],
              stk_cmd->l_cmd>>3);
      /* modify length of CP Data */
      data_req->sdu.l_buf += (stk_cmd->l_cmd + 16);
    }
  }
  /*lint +e415 +e416 Likely creation/access of out-of-bounds pointer */
}
#endif /* GPRS */

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_build_rp_smma           |
+--------------------------------------------------------------------+

  PURPOSE : Processing the function RL_BUILD_RP_SMMA.

*/

GLOBAL void rl_build_rp_smma (UBYTE       msg_ref,
                              T_U_CP_DATA *cp_data)
{
  TRACE_FUNCTION ("rl_build_rp_smma()");

  cp_data->cp_user_data_ul.rp_mti    = RP_SMMA_UL;
  cp_data->cp_user_data_ul.reference = msg_ref;

  cp_data->cp_user_data_ul.v_rp_data_ul = FALSE;
  cp_data->cp_user_data_ul.v_rp_error = FALSE;
  cp_data->cp_user_data_ul.v_rp_ack = FALSE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (8410)       MODULE  : SMS_RL                     |
| STATE   : code                ROUTINE : rl_temp_failure            |
+--------------------------------------------------------------------+

  PURPOSE : Processing the function RL_TEMP_FAILURE.
            This is valid for memory available notification attempt.
            [04.11 Table 8.4 part 3]
*/

GLOBAL UBYTE rl_temp_failure (UBYTE cause)
{
  TRACE_FUNCTION ("rl_temp_failure()");

  switch (cause)
  {
    case SMS_RP_CS_UNKNOWN_SUBSCRIBER:
    case SMS_RP_CS_FAC_NOT_IMPL:
    case SMS_RP_CS_SEM_INC_MSG:
    case SMS_RP_CS_INV_MAND_INFO:
    case SMS_RP_CS_MSG_NON_EXIST:
    case SMS_RP_CS_MSG_NOT_COMP:
    case SMS_RP_CS_INFO_NON_EXIST:
    case SMS_RP_CS_PROTOCOL_ERROR:
    case SMS_RP_CS_INTERWORKING:
      return FALSE; /* Non-temporary */

    default:
      return TRUE;  /* Temporary */
  }
}

#endif /* #ifndef SMS_RL_C */