diff src/g23m-gsm/sms/sms.h @ 1:fa8dc04885d8

src/g23m-*: import from Magnetite
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 16 Oct 2020 06:25:50 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gsm/sms/sms.h	Fri Oct 16 06:25:50 2020 +0000
@@ -0,0 +1,1173 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GSM-PS (8410)
+|  Modul   :  SMS
++----------------------------------------------------------------------------- 
+|  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 :  Definitions for the Protocol Stack Entity
+|             Short Message Service
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef SMS_H
+#define SMS_H
+
+#include <stdio.h>
+#ifdef TI_PS_HCOMM_CHANGE
+#include "cl_hComm_handle.h"
+#endif
+
+#ifdef TI_GSP_STR2IND_S2I_STRING
+typedef unsigned int T_S2I_STRING;
+#else
+typedef char * T_S2I_STRING;
+#define S2I_STRING(x) (x)
+#endif
+
+#ifdef TI_PS_OP_VSI_NO_CALL_ID
+#define TIMER_START(C,I,T)         vsi_t_start_nc(I,T)
+#define TIMER_PSTART(C,I,T,R)      vsi_t_pstart_nc(I,T,R)
+#define TIMER_STOP(C,I)            vsi_t_stop_nc(I)
+#define TIMER_STATUS(C,I,T)        vsi_t_status_nc(I,T)
+#define SUSPEND_SELF(C,T)          vsi_t_sleep_nc(T)
+#define SYSTEM_TIME(C,T)           vsi_t_time_nc(T)               
+#else /* TI_PS_OP_VSI_NO_CALL_ID */
+#define TIMER_START(C,I,T)         vsi_t_start(C,I,T)
+#define TIMER_PSTART(C,I,T,R)      vsi_t_pstart(C,I,T,R)
+#define TIMER_STOP(C,I)            vsi_t_stop(C,I)
+#define TIMER_STATUS(C,I,T)        vsi_t_status(C,I,T)
+#define SUSPEND_SELF(C,T)          vsi_t_sleep(C,T)
+#define SYSTEM_TIME(C,T)           vsi_t_time(C,T)               
+#endif /* TI_PS_OP_VSI_NO_CALL_ID */
+
+/*
+ * Definition whether a shared CCD buffer shall be used
+ */
+/* #undef SHARED_CCD_BUF  */
+
+#ifndef _TARGET_
+
+#define FF_CPHS   /* This flag is only required for SIMULATION defined in .xml file,
+                     to remove the redefinition warning put under comment */
+#endif /* _TARGET_ */
+
+#define FF_SMS_23430
+
+#if defined(FF_SMS_23430)
+#define FF_SMS_NW_RCG_SIM
+#endif
+
+/*==== MACROS =====================================================*/
+
+#if FALSE
+#define SMS_SDU_COPY(_d_,_s_,_t_) memcpy(_d_,_s_,\
+                     (offsetof(T_##_t_,sdu)+offsetof(T_sdu,buf)+\
+                      BYTELEN(D_SDU_OFF(_s_)+D_SDU_LEN(_s_))))
+#else
+#define SMS_SDU_COPY(_d_,_s_,_t_) memcpy(&(_d_)->sdu,&(_s_)->sdu,\
+                     offsetof(T_sdu,buf)+\
+                     BYTELEN(D_SDU_OFF(_s_)+D_SDU_LEN(_s_)))
+#endif
+
+#define GET_SMS_INSTANCE(ti)     csf_get_sms_instance(ti)
+#define GET_NEW_SMS_INSTANCE(ti) csf_get_new_sms_instance(ti)
+#define FREE_SMS_INSTANCE(ti)    csf_free_sms_instance(ti)
+#define GET_MO_INSTANCE(_sd_)    ((_sd_)->inst = INST_MO)
+#define GET_MT_INSTANCE(_sd_)    ((_sd_)->inst = INST_MT)
+
+/*
+ * The assert() macro as defined by the frame stops the task, 
+ * not only in simulation but also on the target. For the 
+ * simulation this is a desired behaviour, for the target it is not. 
+ */
+#ifndef WIN32
+#undef assert
+#define assert(x) if (!(x)) { TRACE_ERROR ("Assertion failed"); }
+#endif
+
+#define CMMS_ACTIVE ((sms_data->cmms_mode EQ CMMS_MODE_ONE) \
+                       OR (sms_data->cmms_mode EQ CMMS_MODE_TWO))
+
+/*==== CONSTANTS ==================================================*/
+
+#define DISPLAY 0
+#define IGNORE  0xFE      // return RP-ACK if handled unsuccessfully
+#define NOTHING 0xFF      // return RP-ERROR if handled unsuccessfully
+
+#define MAX_SMS_CALLS    2
+
+#define INST_MO 0
+#define INST_MT 1
+
+#define SMS_INST         sms_data->data[sms_data->inst]
+
+#define ENTITY_DATA      sms_data
+
+/*
+ * Recognition of certain networks (SIM opearators)
+ */
+
+#define NW_SIM_NONE      0       /* no special network given */
+#define NW_SIM_23430     1       /* SIM provided by operator 234-30 */
+
+/*
+ * Dynamic Configuration Numbers
+ */
+enum
+{
+   SMS_CONF_EVENT_TIMER_SET        = 1,
+   SMS_CONF_EVENT_TIMER_RESET      = 2,
+   SMS_CONF_EVENT_TIMER_SPEED_UP   = 3,
+   SMS_CONF_EVENT_TIMER_SLOW_DOWN  = 4,
+   SMS_CONF_EVENT_TIMER_SUPPRESS   = 5,
+   SMS_CONF_EVENT_PAUSE            = 6,
+   SMS_CONF_EVENT_RESUME           = 7,
+
+   SMS_CONF_EVENT_END,
+   SMS_CONF_EVENT_MAX = (SMS_CONF_EVENT_END - 1)
+};
+typedef UBYTE SMS_CONF_EVENT_ENUM_TYPE;
+
+/*
+ * Timer definitions, MAX_SMS_TIMER
+ *
+ * Description :  The constants defines the timers and the number of timers
+ *                available in the timer pool.
+ * Note        :  One CP and one RL timer per instance.
+ */
+#define TC1M             0
+#define TR1M             1
+#define TR2M             2
+#define TRAM             3
+#define TLCT             4   /* concatenation timer */
+#define TMMS             5   /* CMMS Timer */
+#define MAX_SMS_TIMER    6
+
+/*
+ * Protocoldiscriminator SMS
+ */
+#define ENCODE_OFFSET    32
+#define BSIZE_TI_PD      8
+
+/*
+ * Protocoldiscriminator SMS
+ */
+#define PD_SMS           9
+
+/*
+ * Max size of SMS-message
+ */
+#define MAX_SMS_MESSAGE_SIZE           (MAX_BITSTREAM_LEN_SMS>>3)
+
+/*
+ * Max size of TP user data
+ */
+#define MAX_CHARACTERS_TPUD            141
+
+/*
+ * Max size of sim-sms-record
+ */
+#define SIM_LENGTH_SMS_RECORD          176
+
+/*
+ * access values
+ */
+#define ACCESS_EMPTY                   0
+
+/*
+ * length of U_CP_DATA
+ */
+#define LEN_U_CP_DATA  (252*8)
+
+/*
+ * Max length of D_CP_USER_DATA
+ */
+#define MAX_LEN_CP_USER_DATA  249
+#define MIN_CP_LEN 3
+#define MIN_CP_ACK_LEN 2
+
+/*
+ * constants for GSMS: active downlink
+ */
+#if defined (GPRS)
+#define SMS_DOWNLINK_NONE              0  /* no downlink assigned yet             */
+#define SMS_DOWNLINK_MMSMS             1  /* downlink is MM using SAP MMSMS       */
+#define SMS_DOWNLINK_LL_CHECK          2  /* downlink LL is being checked         */
+#define SMS_DOWNLINK_LL                3  /* downlink is LL, registered           */
+
+/*
+ * constants for GSMS: LLC flow control
+ */
+#define SMS_LLC_UNKNOWN             0x00
+#define SMS_LLC_AVAILABLE           0x01
+#define SMS_LLC_BUSY                0x02   /* LLC is busy, no instance waiting    */
+#define SMS_LLC_BUSY_WAITING        0x03   /* LLC is busy and instance is waiting */
+
+/* constants for GSMS: SMS entity flow control status towards LLC */
+#define SMS_FLOW_UNKNOWN            0x00
+#define SMS_FLOW_AVAILABLE          0x01  /* availability of SMS signalled to LLC */
+#define SMS_FLOW_BUSY               0x02  /* SMS entity is busy */
+
+/* cp type of acknowledgement to be sent */
+#define SMS_CP_NONE                 0x00
+#define SMS_CP_ACK                  0x01
+#define SMS_CP_ERROR                0x02
+#endif /* GPRS */
+
+/*
+ * a modified version of the S/GET_STATE macros for tracing SMS_INST states
+ */
+#ifdef NTRACE
+  #define SMS_INST_SET_STATE(PROCESS,STATE)    SMS_INST.state[PROCESS] = STATE
+  #define SMS_INST_GET_STATE(PROCESS)          SMS_INST.state[PROCESS]
+#else
+  #define SMS_INST_SET_STATE(PROCESS,STATE)\
+              { vsi_o_strace (VSI_CALLER\
+                              PROCESS_NAME_SMS_INST[PROCESS],\
+                              PROCESS##_NAME [ SMS_INST.state[PROCESS] ],\
+                              PROCESS##_NAME [          STATE          ]);\
+                SMS_INST.state[PROCESS] = (STATE); }
+  #define SMS_INST_GET_STATE(PROCESS)\
+                vsi_o_strace (VSI_CALLER\
+                              PROCESS_NAME_SMS_INST[PROCESS],\
+                              PROCESS##_NAME [ SMS_INST.state[PROCESS] ],\
+                                                        NULL           ),\
+                                               SMS_INST.state[PROCESS]
+#endif /* else, #ifdef NTRACE */
+
+/*
+ * CP States
+ */
+#define CP_IDLE                        0  /* 3gpp, MO+MT */
+#define CP_MM_CONNECTION_PENDING       1  /* 3gpp, MO    */
+#define CP_WAIT_FOR_ACK                2  /* 3gpp, MO+MT */
+#define CP_MM_CONNECTION_ESTABLISHED   3  /* 3gpp, MO+MT */
+
+#if defined (GPRS)
+/*
+ * CP States for GSMS
+ */
+#define CP_GSMS_IDLE                   4  /* 3gpp */
+#define CP_GSMS_MO_WAIT_FOR_CP_ACK     5  /* 3gpp */
+#define CP_GSMS_MT_WAIT_FOR_CP_ACK     6  /* 3gpp */
+#define CP_GSMS_MO_WAIT_FOR_CP_DATA    7  /* 3gpp */
+#define CP_GSMS_MT_WAIT_FOR_RP_ACK     8  /* 3gpp */
+#endif /* GPRS */
+
+#if defined (GPRS)
+EXTERN  const char * const
+        STATE_CP_NAME[];
+#define STATE_CP_NAME_INIT             \
+       "CP_IDLE",                      \
+       "CP_MM_CONNECTION_PENDING",     \
+       "CP_WAIT_FOR_ACK",              \
+       "CP_MM_CONNECTION_ESTABLISHED", \
+       "CP_GSMS_IDLE",                 \
+       "CP_GSMS_MO_WAIT_FOR_CP_ACK",   \
+       "CP_GSMS_MT_WAIT_FOR_CP_ACK",   \
+       "CP_GSMS_MO_WAIT_FOR_CP_DATA",  \
+       "CP_GSMS_MT_WAIT_FOR_RP_ACK"
+#else
+EXTERN  const char * const
+        STATE_CP_NAME[];
+#define STATE_CP_NAME_INIT             \
+       "CP_IDLE",                      \
+       "CP_MM_CONNECTION_PENDING",     \
+       "CP_WAIT_FOR_ACK",              \
+       "CP_MM_CONNECTION_ESTABLISHED"
+#endif
+
+/*
+ * RL States
+ */
+#define RL_IDLE                        0  /* 3gpp */
+#define RL_WAIT_FOR_ACK                1  /* 3gpp */
+#define RL_WAIT_FOR_SMMA_ACK           2  /* TI */
+#define RL_WAIT_FOR_SEND_ACK           3  /* 3gpp */
+#define RL_WAIT_FOR_RETRANS_TIMER      4  /* 3gpp */
+#define RL_ESTABLISH                   5  /* TI */
+#define RL_ESTABLISHED                 6  /* TI */
+#define RL_WAIT_FOR_SEND_ERROR         7  /* TI */
+
+EXTERN  const char * const
+        STATE_RL_NAME[];
+#define STATE_RL_NAME_INIT             \
+       "RL_IDLE",                      \
+       "RL_WAIT_FOR_ACK",              \
+       "RL_WAIT_FOR_SMMA_ACK",         \
+       "RL_WAIT_FOR_SEND_ACK",         \
+       "RL_WAIT_FOR_RETRANS_TIMER",    \
+       "RL_ESTABLISH",                 \
+       "RL_ESTABLISHED",               \
+       "RL_WAIT_FOR_SEND_ERROR"
+
+/*
+ * TL States
+ */
+#define TL_IDLE                        0
+#define TL_SEND                        1
+#define TL_COMMAND                     2
+#define TL_RECEIVE                     3
+#define TL_OTHER                       4
+#define TL_ESTABLISH                   5
+#define TL_SEND_CONTD                  6
+
+EXTERN  const char * const
+        STATE_TL_NAME[];
+#define STATE_TL_NAME_INIT             \
+       "TL_IDLE",                      \
+       "TL_SEND",                      \
+       "TL_COMMAND",                   \
+       "TL_RECEIVE",                   \
+       "TL_OTHER",                     \
+       "TL_ESTABLISH",                 \
+       "TL_SEND_CONTD"                 
+
+/*
+ * SMS manages 3 (MAX_STATE_SMS_INST) states per SMS_INST: CP, RL, TL
+ */
+#define STATE_CP                       0
+#define STATE_RL                       1
+#define STATE_TL                       2
+#define MAX_STATE_SMS_INST             3
+
+EXTERN  const char * const
+        PROCESS_NAME_SMS_INST[];
+#define PROCESS_NAME_SMS_INST_INIT     \
+       "STATE_CP"   ,                  \
+       "STATE_RL"   ,                  \
+       "STATE_TL"
+
+/*
+ * A definition of the states of SMS_INST is provided in SMS_PEI.C
+ */
+#if defined(SMS_PEI_C) && ! defined(NTRACE)
+  GLOBAL const char * const          STATE_CP_NAME[] = {          STATE_CP_NAME_INIT };
+  GLOBAL const char * const          STATE_RL_NAME[] = {          STATE_RL_NAME_INIT };
+  GLOBAL const char * const          STATE_TL_NAME[] = {          STATE_TL_NAME_INIT };
+  GLOBAL const char * const  PROCESS_NAME_SMS_INST[] = {  PROCESS_NAME_SMS_INST_INIT };
+#endif
+
+/*
+ * MMI States
+ */
+#define MMI_IDLE                       0
+#define MMI_READ                       1
+#define MMI_WRITE                      2
+#define MMI_DELETE                     3
+#define MMI_FIND_FIRST                 4
+#define MMI_FIND_NEXT                  5
+#define MMI_REPLACE                    6
+#define MMI_STATE_UPDATE               7
+#define MMI_READ_STATE_UPDATE          8 
+#define MMI_RESUME                     9
+
+/* N950 Memory Optimization - Implements Measure #39*/
+EXTERN  T_S2I_STRING const
+        STATE_MMI_NAME[];
+/*
+ * NET States
+ */
+#define NET_IDLE                       0
+#define NET_WRITE                      1
+#define NET_READ                       2
+#define NET_23430_WRITE                3
+#define NET_23430_DELETE               4
+
+/* N950 Memory Optimization - Implements Measure #39*/
+EXTERN  T_S2I_STRING const
+        STATE_NET_NAME[];
+/*
+ * EST States - substates for connection establishment
+ */
+enum
+{
+        EST_IDLE                     = 0, /* no connection establishment */
+        EST_SEND                     = 1, /* conn establishment for send */
+        EST_RTX                      = 2, /* conn est for retransmission */
+        EST_CMD                      = 3, /* conn est for command        */
+        EST_SMMA                     = 4  /* conn est for smma message   */
+};
+
+/* N950 Memory Optimization - Implements Measure #39*/
+EXTERN  T_S2I_STRING const
+        STATE_EST_NAME[];
+/*
+ * SMS manages 3 (MAX_STATE) states: MMI, NET, EST
+ */
+#ifdef OPTION_MULTITHREAD
+  #define PROCESS_NAME    _ENTITY_PREFIXED(PROCESS_NAME)
+#endif
+
+#define STATE_MMI                      0
+#define STATE_NET                      1
+#define STATE_EST                      2
+#define MAX_STATE                      3
+
+/* N950 Memory Optimization - Implements Measure #39*/
+EXTERN  T_S2I_STRING const
+        PROCESS_NAME[];
+/*
+ * A definition of the states is provided in SMS_PEI.C
+ */
+#if defined(SMS_PEI_C) && ! defined(NTRACE)
+/* N950 Memory Optimization - Implements Measure #39*/
+GLOBAL T_S2I_STRING const STATE_MMI_NAME[] = 
+{
+
+  S2I_STRING("MMI_IDLE"),             
+  S2I_STRING("MMI_READ"),             
+  S2I_STRING("MMI_WRITE"),            
+  S2I_STRING("MMI_DELETE"),           
+  S2I_STRING("MMI_FIND_FIRST"),       
+  S2I_STRING("MMI_FIND_NEXT"),        
+  S2I_STRING("MMI_REPLACE"),          
+  S2I_STRING("MMI_STATE_UPDATE"),     
+  S2I_STRING("MMI_READ_STATE_UPDATE"),
+  S2I_STRING("MMI_RESUME")
+};
+#ifndef FF_SMS_23430
+GLOBAL T_S2I_STRING const STATE_NET_NAME[] = 
+{
+  S2I_STRING("NET_IDLE"), 
+  S2I_STRING("NET_WRITE"),
+  S2I_STRING("NET_READ")
+};
+#else
+GLOBAL T_S2I_STRING const STATE_NET_NAME[] = 
+{
+  S2I_STRING("NET_IDLE"),       
+  S2I_STRING("NET_WRITE"),      
+  S2I_STRING("NET_READ"),       
+  S2I_STRING("NET_23430_WRITE"),
+  S2I_STRING("NET_23430_DELETE")
+};
+#endif /* else, #ifndef FF_SMS_23430 */
+
+GLOBAL T_S2I_STRING const STATE_EST_NAME[] = 
+{
+
+  S2I_STRING("EST_IDLE"),
+  S2I_STRING("EST_SEND"),
+  S2I_STRING("EST_RTX"), 
+  S2I_STRING("EST_CMD"), 
+  S2I_STRING("EST_SMMA")
+};
+
+GLOBAL T_S2I_STRING const   PROCESS_NAME[] = 
+{
+
+  S2I_STRING("MMI"),
+  S2I_STRING("NET"),
+  S2I_STRING("EST")
+};
+#endif
+
+#define ACCESS_BY_MMI                  0x01
+#define ACCESS_BY_NET                  0x02
+#define ACCESS_BY_EST                  0x03
+
+#define SIM_SMS_FREE                   (SMS_RECORD_FREE)
+#define SIM_SMS_MT_READ                (SMS_RECORD_REC_READ)
+#define SIM_SMS_MT_TO_BE_READ          (SMS_RECORD_REC_UNREAD)
+#define SIM_SMS_MO_SENT                (SMS_RECORD_STO_SENT)
+#define SIM_SMS_MO_TO_BE_SEND          (SMS_RECORD_STO_UNSENT)
+#define SIM_SMS_PENDING                0xFF  /* new entry, not yet confirmed */
+
+#define SMS_MAX_SIM_ACCESS     2
+
+/*==== TYPES ======================================================*/
+
+/*
+ * IE Header Structure
+ */
+typedef struct
+{
+   UBYTE     iei;                   /* Information Element Identifier     */
+   UBYTE     ie_length;             /* Length of Information Element      */
+} T_SMS_PDU_IE_HDR;
+
+/*
+ * Conactenation header structure for 8 bit reference number
+ */
+typedef struct
+{
+   UBYTE     ref_nr;                /* Reference Number                   */
+   UBYTE     max_nr;                /* Maximum number of short messages
+                                       in the concatenated short message  */
+   UBYTE     seq_nr;                /* Sequence number of the current 
+                                                            short message */
+} T_SMS_PDU_CONCAT_8BIT_HDR;
+
+/*
+ * Conactenation header structure for 16 bit reference number
+ */
+typedef struct
+{
+   USHORT    ref_nr;                /* Reference Number                   */
+   UBYTE     max_nr;                /* Maximum Sequence Number            */
+   UBYTE     seq_nr;                /* Sequence Number                    */
+} T_SMS_PDU_CONCAT_16BIT_HDR;
+
+/*
+ * Conactenation header common structure
+ */
+typedef struct
+{
+   USHORT    ref_nr;                /* Reference Number                   */
+   UBYTE     max_nr;                /* Maximum Sequence Number            */
+   UBYTE     seq_nr;                /* Sequence Number                    */
+} T_SMS_CONCAT_HDR;
+
+typedef struct
+{
+  UBYTE      t_mode;
+  ULONG      t_val;
+} T_TIMER_CONFIG;
+
+
+typedef struct
+{
+  T_MMSMS_DATA_REQ *mo_msg;
+  T_sms_sdu      *sms_sdu;
+  T_SIM_READ_RECORD_CNF *sim_read;
+  UBYTE          state[MAX_STATE_SMS_INST];
+  UBYTE          tl_retx;           /* Number of retransmissions on TL level */
+#ifdef REL99
+  UBYTE          failed_msg_retx;   /* stores whether MO msg is sent thru retransmission request */ 
+  UBYTE          failed_msg_rec_num;/* stores record number of last failed msg */ 
+  UBYTE          failed_msg_mem;    /* stores memory location of last failed msg */ 
+#endif
+  UBYTE          retx;
+  UBYTE          retrans;
+  UBYTE          msg_ref;
+  UBYTE          ti;
+  UBYTE          tp_mr;
+  UBYTE          tp_mr_ret;         /* TP-MR to be returned to higher layer */
+
+  /* cp_release_req() in state XXX_CP_WAIT_FOR_ACK received,
+   * delay the release until the next CP state is entered. */
+  BOOL           r_flag;
+  /* CP_ACK pending: outstanding CP_ACK in outbound direction */
+  BOOL           cp_ack_pending;
+  UBYTE          act_mem;
+  UBYTE          act_record;
+  UBYTE          act_status;
+  UBYTE          act_rdmode;
+  UBYTE          act_condx;
+  UBYTE          act_modifier;
+  UBYTE          pid;
+  UBYTE          dcs;
+#if defined (GPRS)
+  UBYTE          downlink;          /* downlink of this instance: LLC or MMSMS */
+  UBYTE          ack_type;          /* type of message to be sent */
+  UBYTE          cp_cause;          /* cause value of CP-ERROR to be sent */
+  T_cp_user_data_dl *cp_user_data_dl;
+#endif
+  BOOL           t_running[MAX_SMS_TIMER];
+} T_SMS_INST;
+
+typedef struct
+{
+  UBYTE          *status_field;     /* status each record */
+  UBYTE          *pid_field;        /* PID flag of each record */
+  UBYTE           mem_type;         /* Type of used memory */
+  UBYTE           max_record;       /* number of available records */
+  UBYTE           any_valid;        /* at least one used record exists */
+} T_BACKUP;
+
+typedef struct
+{
+  /* SIM EF file identifier. path_info need not be stored as SMS is using 
+   * only non-conflicting files 
+   * Data-field identification
+   */
+  USHORT         datafield;
+  /* record number, used only for linear fixed EFs */
+  UBYTE          rec_num;
+  /* flag indicating whether this entry is used */
+  UBYTE          entry_used;  
+} T_SMS_SIM_ACCESS_INFO;
+
+/*
+ * CONCATENATION CONTROL
+ */
+typedef struct
+{
+  BOOL           concatenation;    /* whether concatenated submits are
+                                      currently processed                    */
+  BOOL           release_pending;  /* release outstanding                    */
+  BOOL           end;              /* end of concatenated stream             */
+  BOOL           pad;              /*                                        */
+  T_SMS_CONCAT_HDR nr;             /* current number                         */
+} T_SMS_CONCAT_CNTRL;
+
+/*
+ * PAUSE RESUME CONTROL
+ */
+typedef struct
+{
+  U8             delivery_state;  /* pause or resume, SMS_DELIVER_STATUS_xxx */
+  BOOL           mem_full_sent;   /* whether mem capacity exceeded
+                                     message was sent to HLR due to
+                                     user pause request                      */
+  U16            save_cause;      /* safed cause value while sim updating    */
+} T_SMS_PR_CNTRL;
+
+typedef struct
+{
+  T_SMS_INST     data[MAX_SMS_CALLS];
+  T_rp_data_dl  *rp_data_dl;        /* points to income RL data */
+ /*
+  * following is a hack: since we cannot pass values to timer we safe it here:
+  */
+  UBYTE          timer_ti;          /* TI for running timer */
+  UBYTE          mhc;               /* message Handling compatibility */
+  UBYTE          mt;
+  UBYTE          ds;
+  UBYTE          mem3;
+  UBYTE          inst;
+  UBYTE          ent_state;
+  UBYTE          state[MAX_STATE];
+  BOOL           mem_cap_avail;     /* as stated on SIM */
+  UBYTE          access_fifo[2];
+  UBYTE          sim_phase;         /* value of EF(Phase) */
+  UBYTE          use_mem_a;
+  UBYTE          use_mem_b;
+  T_BACKUP       me_backup;
+  T_BACKUP       sim_backup;
+  
+  /* In the ME status field a backup of the SMS status is stored, 
+   * the ME PID field is a bitarray which stores whether a given 
+   * SMS is of the replacement type or not.
+   * For asynchronous memory those fields are mandatory, for 
+   * synchronous memory the backup is optional.
+   */
+  /* UBYTE          me_status_field [MAX_RECORD_ME]; */
+  /* UBYTE          me_pid_field [(MAX_RECORD_ME+7)/8]; */
+  UBYTE          sim_status_field [MAX_RECORD_SIM];
+  UBYTE          sim_pid_field[(MAX_RECORD_SIM+7)/8];
+
+  /* SMS entity has finished reading SMS entries from the SIM. */
+  BOOL           init_done;
+
+  /* SMS entries changed by SAT, not begun reading records from the SIM. */
+  BOOL           sim_mem_update;
+
+  /* concatenation control field  */
+  T_SMS_CONCAT_CNTRL concat_cntrl;
+  /* pause resume control field   */
+  T_SMS_PR_CNTRL pr_cntrl;
+
+  UBYTE          nw_spec;
+#ifdef FF_CPHS
+  UBYTE          cphs_sim;          /* CPHS SIM recognized */
+#endif
+#ifdef SIM_TOOLKIT
+  UBYTE          download_sms;
+  T_SIM_FILE_UPDATE_IND *file_update_ind;
+  /* MMI state backup */
+  UBYTE stored_mmi_state;
+  /* Backup the read_cnf primitive */
+  T_SIM_READ_RECORD_CNF *stored_read_cnf;
+#endif /* #ifdef SIM_TOOLKIT */
+#if defined (GPRS)
+  UBYTE          mo_dst_pref;       /* preferred dest. (GPRS/CCT) for MO SM */
+  UBYTE          llc_flow;          /* LLC flow control */
+  UBYTE          sms_flow;          /* SMS entity flow control */
+#endif
+  /* To indicate that release is pending for the previous connection */
+  BOOL           cmms_release_pending;
+  UBYTE          cmms_mode;
+  T_TIME timer_values[MAX_SMS_TIMER];
+  /* Used to store information on the SIM Accesses that are currently happening. 
+   * The array is indexed by the req_id that was sent in SIM_XXX_REQ */
+  T_SMS_SIM_ACCESS_INFO    sms_sim_access_info[SMS_MAX_SIM_ACCESS];
+} T_SMS_DATA;
+
+/*==== MACROS =====================================================*/
+
+#define DATA_INST(_sd_)         ((_sd_)->data[(_sd_)->inst])
+
+#define SMS_STATE(_sd_)         (DATA_INST(_sd_).state)
+#define SMS_RETX(_sd_)          (DATA_INST(_sd_).retx)
+#define SMS_RETRANS(_sd_)       (DATA_INST(_sd_).retrans)
+#define SMS_CP_REF(_sd_)        (DATA_INST(_sd_).ti)
+#define SMS_RP_REF(_sd_)        (DATA_INST(_sd_).msg_ref)
+#define SMS_TP_REF(_sd_)        (DATA_INST(_sd_).tp_mr)
+#define SMS_TP_REF_RET(_sd_)    (DATA_INST(_sd_).tp_mr_ret)
+/* #define SMS_RP_FLAG(_sd_)       (DATA_INST(_sd_).r_flag) */ /* Not used */
+#define SMS_SEL_MEM(_sd_)       (DATA_INST(_sd_).act_mem)
+#define SMS_SEL_REC(_sd_)       (DATA_INST(_sd_).act_record)
+#define SMS_REC_STATUS(_sd_)    (DATA_INST(_sd_).act_status)
+#define SMS_READ_MODE(_sd_)     (DATA_INST(_sd_).act_rdmode)
+#define SMS_CONDX(_sd_)         (DATA_INST(_sd_).act_condx)
+#define SMS_MODIFY(_sd_)        (DATA_INST(_sd_).act_modifier)
+#define SMS_DATA_REQ(_sd_)      (DATA_INST(_sd_).mo_msg)
+#define SMS_SDU(_sd_)           (DATA_INST(_sd_).sms_sdu)
+#define SMS_SIM_READ(_sd_)      (DATA_INST(_sd_).sim_read)
+#define SMS_RP_RCVD(_sd_)       ((*_sd_).rp_data_dl)
+#define SMS_PID(_sd_)           (DATA_INST(_sd_).pid)
+#define SMS_DCS(_sd_)           (DATA_INST(_sd_).dcs)
+
+#define SMS_ENT_STATE(_sd_)     ((_sd_)->ent_state)
+#define SMS_SIM_PHASE(_sd_)     ((_sd_)->sim_phase)
+#define SMS_SIM_STATE(_sd_)     ((_sd_)->state)
+#define SMS_SIM_MEM_AVAIL(_sd_) ((_sd_)->mem_cap_avail)
+#define SMS_SIM_ACCESS(_sd_)    ((_sd_)->access_fifo)
+#define SMS_SAT_DWNLD(_sd_)     ((_sd_)->download_sms)
+#define SMS_MT_ACK_MODE(_sd_)   ((_sd_)->mhc)
+#define SMS_MT_HANDLING(_sd_)   ((_sd_)->mt)
+#define SMS_ST_REPORT(_sd_)     ((_sd_)->ds)
+#define SMS_MEM_CFG(_sd_)       ((_sd_)->mem3)
+#define SMS_USE_MEMA(_sd_)      ((_sd_)->use_mem_a)
+#define SMS_USE_MEMB(_sd_)      ((_sd_)->use_mem_b)
+#define SMS_SIM_PROP(_sd_)      ((_sd_)->sim_backup)
+#define SMS_ME_PROP(_sd_)       ((_sd_)->me_backup)
+#define SMS_NETWORK(_sd_)       ((_sd_)->nw_spec)
+
+#ifdef FF_CPHS
+#define SMS_CPHS(_sd_)          ((_sd_)->cphs_sim)
+#endif /* #ifdef FF_CPHS */
+
+#if defined (GPRS)
+#define SMS_ROUTE(_sd_)         (DATA_INST(_sd_).downlink)
+#define SMS_CP_ACK_TYPE(_sd_)   (DATA_INST(_sd_).ack_type)
+#define SMS_CP_CAUSE(_sd_)      (DATA_INST(_sd_).cp_cause)
+#define SMS_CP_UDL(_sd_)        (DATA_INST(_sd_).cp_user_data_dl)
+#define SMS_ROUTE_PREF(_sd_)    ((_sd_)->mo_dst_pref)
+#define SMS_LLC_FLOW(_sd_)      ((_sd_)->llc_flow)
+#define SMS_SMS_FLOW(_sd_)      ((_sd_)->sms_flow)
+#endif
+
+
+/*==== EXPORT =====================================================*/
+
+/*
+ * Prototypes Formatter
+ */
+EXTERN void for_init_sms             (void);
+
+/*
+ * Prototypes Transfer-Layer Primitives
+ */
+
+EXTERN void tl_init                  (void);
+EXTERN void tl_init_complete         (void);
+EXTERN void tl_mnsms_configure_req   (T_MNSMS_CONFIGURE_REQ   *configure_req);
+#ifdef GPRS
+EXTERN void tl_mnsms_mo_serv_req     (T_MNSMS_MO_SERV_REQ     *mo_serv_req);
+#endif
+#ifdef SIM_PERS_OTA
+EXTERN void tl_mnsms_OTA_message_res  (T_MNSMS_OTA_MESSAGE_RES *mnsms_OTA_message_res);
+#endif
+EXTERN void tl_mnsms_command_req     (T_MNSMS_COMMAND_REQ     *command_req);
+EXTERN void tl_mnsms_delete_req      (T_MNSMS_DELETE_REQ      *delete_req);
+EXTERN void tl_mnsms_read_req        (T_MNSMS_READ_REQ        *read_req);
+EXTERN void tl_mnsms_store_req       (T_MNSMS_STORE_REQ       *store_req);
+EXTERN void tl_mnsms_submit_req      (T_MNSMS_SUBMIT_REQ      *submit_req);
+EXTERN void tl_mnsms_pause_req       (T_MNSMS_PAUSE_REQ       *pause_req);
+EXTERN void tl_mnsms_resume_req      (T_MNSMS_RESUME_REQ      *resume_req);
+EXTERN void tl_mnsms_query_req       (T_MNSMS_QUERY_REQ       *query_req);
+EXTERN void tl_sim_sms_insert_ind    (T_SIM_SMS_INSERT_IND    *insert_ind);
+#if defined(SIM_TOOLKIT) OR defined(FF_CPHS)
+EXTERN void tl_sim_read_cnf          (T_SIM_READ_CNF          *read_cnf);
+#endif /* #if defined(SIM_TOOLKIT) OR defined(FF_CPHS) */
+#ifdef SIM_TOOLKIT
+EXTERN void tl_sim_file_update_ind   (T_SIM_FILE_UPDATE_IND   *file_update_ind);
+#endif /* #ifdef SIM_TOOLKIT */
+EXTERN void tl_sim_update_cnf        (T_SIM_UPDATE_CNF        *update_cnf);
+EXTERN void tl_sim_update_record_cnf (T_SIM_UPDATE_RECORD_CNF *update_cnf);
+EXTERN void tl_sim_read_record_cnf   (T_SIM_READ_RECORD_CNF   *read_cnf);
+EXTERN void tl_sim_remove_ind        (T_SIM_REMOVE_IND        *remove_ind);
+#if defined(SIM_TOOLKIT) AND defined(SAT_SMS_DNL_SUPPORT)
+EXTERN void tl_sim_toolkit_cnf       (T_SIM_TOOLKIT_CNF       *toolkit_cnf);
+#endif /* #if defined(SIM_TOOLKIT) AND defined(SAT_SMS_DNL_SUPPORT) */
+EXTERN void tl_mnsms_error_ind       (USHORT                  error);
+EXTERN void tl_mnsms_ack_res         (T_MNSMS_ACK_RES         *ack_res);
+EXTERN UBYTE tl_check_class_2        (UBYTE                    dcs);
+EXTERN BOOL  tl_build_envelope_sms_download (T_rp_data_dl     *rp_data_dl);
+EXTERN void tl_mnsms_read_cnf        (UBYTE                   mem_type,
+                                      UBYTE                   record,
+                                      UBYTE                   *data,
+                                      USHORT                  error);
+
+
+
+EXTERN void tl_mnsms_store_cnf       (UBYTE                   mem_type,
+                                      UBYTE                   record,
+                                      USHORT                  error);
+EXTERN void tl_mnsms_submit_cnf      (UBYTE                   mem_type,
+                                      UBYTE                   record,
+                                      UBYTE                   tp_mr,
+                                      USHORT                  cause,
+                                      T_sms_sdu               *sms_sdu);
+EXTERN void tl_mnsms_command_cnf     (UBYTE                   tp_mr,
+                                      USHORT                  cause,
+                                      T_sms_sdu               *sms_sdu);
+EXTERN void tl_mnsms_delete_cnf      (UBYTE                   mem_type,
+                                      UBYTE                   record,
+                                      UBYTE                   next_rec,
+                                      USHORT                  error);
+EXTERN void tl_mnsms_resume_cnf      (USHORT                  cause);
+EXTERN void tl_mnsms_query_cnf       (U8                      query_type,
+                                      U8                      status);
+
+/*
+ * Prototypes Transfer-Layer Signals
+ */
+EXTERN void tl_establish_cnf         (BOOL            success);
+EXTERN void tl_establish_cnf_send    (void);
+EXTERN void tl_establish_cnf_rtx     (void);
+EXTERN void tl_establish_cnf_cmd     (void);
+EXTERN void tl_data_ind              (T_rp_data_dl   *rp_data_dl);
+EXTERN void tl_report_ind            (T_rp_user_data *rp_user_data,
+                                      USHORT         cause);
+EXTERN void tl_timeout_ind           (USHORT         timer_id);
+
+
+/*
+ * Prototypes Transfer-Layer Functions
+ */
+EXTERN void tl_establish_connection  (BOOL                incr);
+EXTERN void tl_build_status_rep      (T_rp_data_dl       *rp_data_dl,
+                                      T_MNSMS_STATUS_IND *status_ind);
+EXTERN BOOL tl_modify_submit (T_SIM_PDU *sim_pdu,
+                              UBYTE     modify,
+                              T_sms_sdu *sms_sdu,
+                              UBYTE     *rec_data);
+EXTERN BOOL tl_prepare_submit (T_SIM_PDU   *sim_pdu,
+                               T_U_CP_DATA *cp_data);
+EXTERN void tl_build_deliver_rep     (T_MNSMS_ACK_RES     *ack_res,
+                                      UBYTE               msg_ref,
+                                      T_MMSMS_DATA_REQ    *data_req,
+                                      T_U_CP_DATA         *cp_data);
+EXTERN USHORT tl_convert_sim_error   (USHORT sim_error);
+EXTERN BOOL tl_convert_mo_to_mem     (T_MMSMS_DATA_REQ   *data_req,
+                                      UBYTE              *data);
+EXTERN void tl_convert_mt_to_mem     (T_rp_data_dl       *rp_data_dl,
+                                      UBYTE              *data);
+EXTERN UBYTE tl_convert_sim_to_mmi   (UBYTE        mem_type,
+                                      UBYTE        record,
+                                      UBYTE        *data,
+                                      UBYTE        length);
+EXTERN void tl_message_ind_from_sim  (UBYTE        mem_type,
+                                      UBYTE        record,
+                                      UBYTE        max_record,
+                                      UBYTE        *data);
+EXTERN void tl_message_ind_from_net  (UBYTE        mem_type,
+                                      UBYTE        record,
+                                      UBYTE        max_record,
+                                      T_rp_data_dl *rp_data_dl);
+EXTERN void tl_read_me_memory        (USHORT       index,
+                                      UBYTE        status);
+EXTERN void tl_read_sim_memory       (USHORT       index,
+                                      UBYTE        status);
+EXTERN void tl_sim_read_req          (USHORT       datafield,
+                                      UBYTE        length);
+EXTERN void tl_sim_read_record_req   (UBYTE        record);
+EXTERN void tl_sim_update_req        (UBYTE        record,
+                                      UBYTE        status,
+                                      UBYTE        *data);
+EXTERN void tl_sim_conv_update_req   (UBYTE        record,
+                                      T_rp_data_dl *rp_data_dl);
+EXTERN void tl_handle_message        (T_TP_DELIVER *sms_deliver);
+#ifdef FF_SMS_23430
+EXTERN BOOL tl_handle_23430          (T_TP_DELIVER *sms_deliver);
+#endif /* #ifdef FF_SMS_23430 */
+EXTERN void tl_build_sim_update_req  (void);
+EXTERN UBYTE tl_read_access_fifo     (void);
+EXTERN void tl_set_access_fifo       (UBYTE        access);
+EXTERN BOOL tl_sms_memo_exceeded     (BOOL         avail);
+EXTERN void tl_sms_memo_pause        (void);
+EXTERN void tl_sms_memo_resume       (void);
+EXTERN void tl_mnsms_report_ind      (UBYTE        ent_state);
+EXTERN void tl_read_sim_message      (USHORT       index);
+EXTERN void tl_find_first            (UBYTE        mem_type);
+EXTERN void tl_find_next             (UBYTE        mem_type,
+                                      UBYTE        index);
+EXTERN void tl_adjust_message_len    (UBYTE        tp_vt_mti,
+                                      BUF_tpdu     *tpdu);
+EXTERN void tl_get_pid_dcs           (UBYTE        status,
+                                      T_sms_sdu    *sms_sdu,
+                                      UBYTE        *pid,
+                                      UBYTE        *dcs);
+EXTERN BOOL tl_find_status_pid       (UBYTE        mem_type,
+                                      UBYTE        index,
+                                      UBYTE        *data,
+                                      T_BACKUP     *backup);
+EXTERN UBYTE tl_get_free_space       (UBYTE        mem_type);
+EXTERN void  tl_store_pid            (T_BACKUP     *backup,
+                                      unsigned     index,
+                                      UBYTE        pid);
+EXTERN void  tl_store_status         (T_BACKUP     *backup,
+                                      unsigned     index,
+                                      UBYTE        status);
+EXTERN UBYTE tl_get_status           (T_BACKUP     *backup,
+                                      unsigned     index);
+EXTERN int   tl_check_mt_pid         (T_BACKUP     *backup,
+                                      unsigned     index,
+                                      UBYTE        pid);
+EXTERN UBYTE tl_check_status_value   (UBYTE        status);
+EXTERN int   tl_search_record        (T_BACKUP     *backup,
+                                      USHORT       index,
+                                      UBYTE        status);
+EXTERN UBYTE tl_search_record_for_delete (T_BACKUP *backup,
+                                          UBYTE   index,
+                                          UBYTE    status);
+EXTERN BOOL  tl_check_replace_entry  (UBYTE        *new_data,
+                                      UBYTE        *old_data);
+EXTERN void  tl_replace_message      (T_TP_DELIVER *sms_deliver);
+EXTERN void  tl_sim_toolkit_confirm  (T_SIM_TOOLKIT_CNF *toolkit_cnf);
+EXTERN void  tl_cmms_start           (void);
+EXTERN void  tl_cmms_end             (void);
+EXTERN void  tl_mnsms_cmms_end_ind   (void);
+#ifdef FF_SMS_NW_RCG_SIM
+EXTERN void  tl_check_network_on_sim (UBYTE        *data);
+#endif /* #ifdef FF_SMS_NW_RCG_SIM */
+EXTERN void  tl_pause                (void);
+EXTERN void  tl_resume               (void);
+EXTERN void  tl_query_deliver_status (void);
+EXTERN BOOL  tl_concat_check         (T_sms_sdu    *sms_sdu);
+EXTERN void  tl_concat_cntrl         (T_SMS_CONCAT_HDR *concat_hdr);
+
+#ifdef REL99
+EXTERN void tl_mnsms_retrans_req     (T_MNSMS_RETRANS_REQ     *mnsms_retrans_req);
+EXTERN void tl_mnsms_retrans_cnf     (UBYTE mem_type,
+                                      UBYTE record,
+                                      UBYTE tp_mr,
+                                      USHORT cause,
+                                      T_sms_sdu *sms_sdu );
+EXTERN void tl_mnsms_send_prog_ind   ();
+#endif
+
+
+EXTERN BOOL tl_sms_reserve_req_id (UBYTE *acc_ix_ptr);
+
+/*
+ * Prototypes Relay-Layer Primitives
+ */
+
+EXTERN void rl_init                  (void);
+
+/*
+ * Prototypes Relay-Layer Signals
+ */
+EXTERN void rl_establish_req    (UBYTE              ti);
+EXTERN void rl_establish_cnf    (BOOL               success);
+EXTERN void rl_release_req      (UBYTE              ti);
+EXTERN void rl_data_ind         (T_cp_user_data_dl *cp_user_data_dl);
+EXTERN BOOL rl_data_req         (UBYTE             msg_ref,
+                                 T_U_CP_DATA       *cp_data);
+EXTERN void rl_error_ind        (USHORT            cause);
+EXTERN void rl_report_req_ack   (T_rp_user_data    *rp_user_data);
+EXTERN void rl_report_req_error (USHORT            cause,
+                                 T_rp_user_data    *rp_user_data);
+EXTERN BOOL rl_mem_avail_req    (void);
+EXTERN void rl_start_tram_req   (void);
+
+/*
+ * Prototypes Relay-Layer Functions
+ */
+
+EXTERN void rl_build_rp_error        (UBYTE        msg_ref,
+                                      USHORT       error,
+                                      T_U_CP_DATA  *cp_data,
+                                      T_rp_user_data *rp_user_data);
+EXTERN void rl_build_rp_smma         (UBYTE        msg_ref,
+                                      T_U_CP_DATA  *cp_data);
+EXTERN UBYTE rl_temp_failure         (UBYTE        cause);
+#ifdef GPRS
+
+EXTERN void rl_proceed               (void);
+
+EXTERN 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);
+#endif /* #ifdef GPRS */
+
+/*
+ * Prototypes Control-Protocol Primitives
+ */
+
+EXTERN void cp_init                  (void);
+EXTERN void cp_mmsms_error_ind       (T_MMSMS_ERROR_IND       *error_ind);
+EXTERN void cp_mmsms_establish_cnf   (T_MMSMS_ESTABLISH_CNF   *establish_cnf);
+EXTERN void cp_mmsms_release_ind     (T_MMSMS_RELEASE_IND     *release_ind);
+EXTERN void for_mmsms_establish_ind  (T_MMSMS_ESTABLISH_IND   *establish_ind);
+EXTERN void for_mmsms_data_ind       (T_MMSMS_DATA_IND        *data_ind);
+#if defined (GPRS)
+EXTERN void for_ll_unitdata_ind      (T_LL_UNITDATA_IND       *unitdata_ind);
+EXTERN void for_ll_unitready_ind     (T_LL_UNITREADY_IND      *unitready_ind);
+EXTERN void cp_gmmsms_reg_state_cnf  (T_GMMSMS_REG_STATE_CNF  *reg_state_res);
+#endif
+
+/*
+ * Prototypes Control-Protocol Signals
+ */
+EXTERN void cp_establish_req         (UBYTE         ti);
+EXTERN void cp_abort_req             (void);
+EXTERN void cp_data_ind_cp_ack       (void);
+EXTERN void cp_data_ind_cp_data      (T_D_CP_DATA  *cp_data);
+EXTERN void cp_data_ind_cp_error     (UBYTE        errcs);
+EXTERN void cp_data_ind_cp_unknown   (void);
+EXTERN void cp_data_req              (T_U_CP_DATA  *cp_data);
+EXTERN void cp_est_ind_cp_ack        (void);
+EXTERN void cp_est_ind_cp_data       (T_D_CP_DATA  *cp_data);
+EXTERN void cp_est_ind_cp_error      (UBYTE        cp_error);
+EXTERN void cp_est_ind_cp_unknown    (void);
+EXTERN void cp_release_req           (UBYTE         ti);
+#if defined (GPRS)
+EXTERN void cp_send_data_gsms        (void);
+EXTERN void cp_data_req_gsms         (T_MMSMS_DATA_REQ *rp_data);
+EXTERN void cp_error_req_gsms        (UBYTE        cause,
+                                      BOOL         free_ti);
+EXTERN void cp_send_getunitdata_req  (void);
+#endif
+
+
+/*
+ * Prototypes Control-Protocol Functions
+ */
+
+EXTERN void cp_add_pd_ti             (UBYTE            ti,
+                                      T_sdu            *sdu);
+EXTERN void cp_build_cp_ack          (void);
+EXTERN void cp_build_cp_error        (UBYTE            error);
+EXTERN void cp_send_release_req      (UBYTE            ti);
+
+#if defined (GPRS)
+EXTERN void cp_init_ll_unitdata_req (T_LL_UNITDATA_REQ *unitdata_req);
+#endif
+/*
+ * If all entities are linked into one module this definitions
+ * prefixes all this functions with the enity name
+ */
+
+/*
+ * Prototypes Timer
+ */
+EXTERN void sms_timer_start          (USHORT      id);
+EXTERN void sms_timer_stop           (USHORT      id);
+EXTERN BOOL sms_timer_check          (USHORT      id);
+/*
+ * If all entities are linked into one module this definitions
+ * prefixes all this functions with the enity name
+ */
+#ifdef OPTION_MULTITHREAD
+  #define tim_exec_timeout   _ENTITY_PREFIXED(tim_exec_timeout)
+  #define tim_start_timer    _ENTITY_PREFIXED(tim_start_timer)
+  #define tim_stop_timer     _ENTITY_PREFIXED(tim_stop_timer)
+#endif /* #ifdef OPTION_MULTITHREAD */
+EXTERN void tim_exec_timeout (USHORT index);
+EXTERN void tim_start_timer  (USHORT index, T_TIME value);
+EXTERN void tim_stop_timer   (USHORT index);
+
+EXTERN void tim_tc1m                 (void);
+EXTERN void tim_tr1m                 (void);
+EXTERN void tim_tr2m                 (void);
+EXTERN void tim_tram                 (void);
+EXTERN void tim_tlct                 (void);
+EXTERN void tim_tmms                 (void);
+
+/*
+ *  SMS primitives Engineering Mode
+ *  Bitmask for the event tracing
+ */
+
+/*
+ * Prototypes Customer Specific Functions
+ */
+
+EXTERN UBYTE       csf_get_new_mo_ti();
+EXTERN T_SMS_DATA *csf_get_sms_instance (UBYTE ti);
+EXTERN T_SMS_DATA *csf_get_new_sms_instance (UBYTE ti);
+EXTERN void        csf_free_sms_instance (UBYTE ti);
+
+#define TIMERSTART(i,v)                 tim_start_timer (i, v);
+#define TIMERSTOP(i)                    tim_stop_timer (i);
+
+/*
+ * If all entities are linked into one module this definitions
+ * prefixes the global data with the enity name
+ */
+#ifdef OPTION_MULTITHREAD
+#ifdef TI_PS_HCOMM_CHANGE
+#else
+  #define hCommMMI       _ENTITY_PREFIXED(hCommMMI)
+  #define hCommMM        _ENTITY_PREFIXED(hCommMM)
+  #define hCommSIM       _ENTITY_PREFIXED(hCommSIM)
+#endif /* TI_PS_HCOMM_CHANGE */ 
+  #ifdef GPRS
+    #define hCommLLC     _ENTITY_PREFIXED(hCommLLC)
+    #define hCommGMM     _ENTITY_PREFIXED(hCommGMM)
+  #endif /* GPRS */
+
+  #define _decodedMsg   _ENTITY_PREFIXED(_decodedMsg)
+  #define _CCDbuf       _ENTITY_PREFIXED(_CCDBuf)
+  #define data_base     _ENTITY_PREFIXED(data_base)
+#endif /* #ifdef OPTION_MULTITHREAD */
+#ifdef TI_PS_HCOMM_CHANGE
+#else
+EXTERN T_HANDLE         hCommMMI;        /* MMI Communication        */
+EXTERN T_HANDLE         hCommSIM;        /* SIM Communication        */
+EXTERN T_HANDLE         hCommMM;         /* MM  Communication        */
+#endif /* TI_PS_HCOMM_CHANGE */ 
+#ifdef GPRS
+EXTERN T_HANDLE         hCommLLC;        /* LLC Communication        */
+EXTERN T_HANDLE         hCommGMM;        /* GMM Communication        */
+#endif /* GPRS */
+EXTERN T_HANDLE         sms_handle;
+
+#ifndef SHARED_CCD_BUF
+#define CCD_START
+#define CCD_END
+EXTERN UBYTE          _decodedMsg [];
+#else
+EXTERN UBYTE *        _decodedMsg;
+EXTERN UBYTE          _CCDbuf;
+#define CCD_START if(!_CCDbuf){_decodedMsg = ccd_begin();_CCDbuf=TRUE;}
+#define CCD_END   if(_CCDbuf){ccd_end();_CCDbuf=FALSE;}
+#endif /* else, #ifndef SHARED_CCD_BUF */
+
+EXTERN T_SMS_DATA data_base;
+
+#define GET_INSTANCE(p) &data_base
+
+#define GET_INSTANCE_DATA    register T_SMS_DATA *sms_data= &data_base
+
+#if !defined(NTRACE) && !defined(NCONFIG)
+/*
+ * If all entities are linked into one module this definitions
+ * prefixes the global data with the entity name
+ */
+#ifdef OPTION_MULTITHREAD
+  #define partab        _ENTITY_PREFIXED(partab)
+#endif /* #ifdef OPTION_MULTITHREAD */
+
+EXTERN const KW_DATA    partab[];
+#endif /* #if !defined(NTRACE) && !defined(NCONFIG) */
+
+/* Implements Measure#32: Row 84, 96, 87, 89, 95, 97, 104, 109 & 113 */
+EXTERN const char * const ef_sms_id;
+
+#define SMS_INST_TC1M  ((USHORT)(TC1M*MAX_SMS_CALLS+sms_data->inst))
+#define SMS_INST_TR1M  ((USHORT)(TR1M*MAX_SMS_CALLS+sms_data->inst))
+#define SMS_INST_TR2M  ((USHORT)(TR2M*MAX_SMS_CALLS+sms_data->inst))
+#define SMS_INST_TRAM  ((USHORT)(TRAM*MAX_SMS_CALLS+sms_data->inst))
+#define SMS_INST_TLCT  ((USHORT)(TLCT*MAX_SMS_CALLS+sms_data->inst))
+
+#endif /* #ifndef SMS_H */