FreeCalypso > hg > fc-tourmaline
view src/g23m-gsm/sms/sms_cp.c @ 287:3dee79757ae4
UI fw: load handheld audio mode on boot
We have now reached the point where use of audio mode config files
should be considered mandatory. In ACI usage we can tell users that
they need to perform an AT@AUL of some appropriate audio mode, but
in UI-enabled fw we really need to have the firmware load audio modes
on its own, so that correct audio config gets established when the
handset or development board runs on its own, without a connected host
computer.
Once have FC Venus with both main and headset audio channels and
headset plug insertion detection, our fw will need to automatically
load the handheld mode or the headset mode depending on the plug
insertion state. For now we load only the handheld mode, which has
been tuned for FC-HDS4 on FC Luna.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 13 Nov 2021 03:20:57 +0000 |
parents | fa8dc04885d8 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GSM-F&D (8411) | Modul : SMS_CP +----------------------------------------------------------------------------- | 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 control protocol | of the component SMS. +----------------------------------------------------------------------------- */ #ifndef SMS_CP_C #define SMS_CP_C #define ENTITY_SMS /*==== INCLUDES ===================================================*/ #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 ===================================================*/ /* Implements Measure# 4 */ /* +------------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_send_err_ind_errcs | +------------------------------------------------------------------------+ PURPOSE : This routine process the signal CP_DATA_IND_CP_ERROR for the cases CP_MM_CONNECTION_ESTABLISHED and CP_WAIT_FOR_ACK */ LOCAL void cp_send_err_ind_errcs(UBYTE errcs) { GET_INSTANCE_DATA; TRACE_FUNCTION("cp_send_err_ind_errcs()"); /* * Check if the cmms_mode is enabled or not * If enabled dont release the MM connection */ if(!CMMS_ACTIVE) { cp_send_release_req (SMS_INST.ti); SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; } else { sms_data->cmms_release_pending = TRUE; } rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_NET, SMSCP_ORIGINATING_ENTITY, errcs)); } /* Implements Measure# 3 */ /* +------------------------------------------------------------------------- -+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_send_err_ind_msg_type_unknown | +---------------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_IND_CP_UNKNOWN for the cases CP_MM_CONNECTION_ESTABLISHED and CP_WAIT_FOR_ACK */ LOCAL void cp_send_err_ind_msg_type_unknown(void) { GET_INSTANCE_DATA; TRACE_FUNCTION("cp_send_err_ind_msg_type_unknown()"); cp_build_cp_error (SMS_CP_CS_MSG_TYPE_NON_EXIST); /* * Check if the cmms_mode is enabled or not * If enabled dont release the MM connection */ if(!CMMS_ACTIVE) { cp_send_release_req (SMS_INST.ti); SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; } else { sms_data->cmms_release_pending = TRUE; } rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, SMSCP_ORIGINATING_ENTITY, SMS_CP_CS_MSG_TYPE_NON_EXIST)); } /* Implements Measure# 8 */ /* +------------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_send_err_ind_msg_not_comp | +------------------------------------------------------------------------+ PURPOSE : This routine process the signals CP_DATA_IND_CP_ACK and CP_DATA_IND_CP_DATA for the cases CP_MM_CONNECTION_ESTABLISHED and CP_WAIT_FOR_ACK */ LOCAL void cp_send_err_ind_msg_not_comp (void) { GET_INSTANCE_DATA; TRACE_FUNCTION("cp_send_err_ind_msg_not_comp()"); cp_build_cp_error (SMS_CP_CS_MSG_NOT_COMP); cp_send_release_req (SMS_INST.ti); SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, SMSCP_ORIGINATING_ENTITY, SMS_CP_CS_MSG_NOT_COMP)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_init | +--------------------------------------------------------------------+ PURPOSE : Initialize the control protocol. */ GLOBAL void cp_init (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_init()"); memset (sms_data, 0, sizeof (T_SMS_DATA)); sms_data->data[0].state[STATE_CP] = CP_IDLE; sms_data->data[1].state[STATE_CP] = CP_IDLE; /* * Initialize the timer_values with default values */ sms_data->timer_values[TC1M] = TC1M_VALUE; sms_data->timer_values[TR1M] = TR1M_VALUE; sms_data->timer_values[TR2M] = TR2M_VALUE; sms_data->timer_values[TRAM] = TRAM_VALUE; sms_data->timer_values[TLCT] = TLCT_VALUE; sms_data->timer_values[TMMS] = TMMS_VALUE; #if defined (GPRS) { int i; /* * default for MO SM: CCT preferred, * no LLC flow information known yet */ SMS_ROUTE_PREF(sms_data) = GPRS_SMS_CCT_PREF; SMS_LLC_FLOW(sms_data) = SMS_LLC_UNKNOWN; SMS_SMS_FLOW(sms_data) = SMS_FLOW_UNKNOWN; /* * initialize downlink info of each instance */ for (i = 0; i < MAX_SMS_CALLS; i++) { sms_data->data[i].downlink = SMS_DOWNLINK_NONE; sms_data->data[i].ack_type = SMS_CP_NONE; sms_data->data[i].cp_cause = NOT_PRESENT_8BIT; sms_data->data[i].cp_user_data_dl = NULL; } } #endif } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_add_pd_ti | +--------------------------------------------------------------------+ PURPOSE : Add Protocol Discriminator and Transaction Identifier to the SDU and modify its parameters accordingly. */ void cp_add_pd_ti (UBYTE ti, T_sdu *sdu) { if (sdu NEQ NULL) { sdu->o_buf -= BSIZE_TI_PD; sdu->l_buf += BSIZE_TI_PD; sdu->buf[BYTELEN_POS(sdu->o_buf)] = PD_SMS | (ti << 4); memset (sdu->buf, 0, BYTELEN(sdu->o_buf)); } } #if defined (GPRS) /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_init_ll_unitdata_req | +--------------------------------------------------------------------+ PURPOSE : Initialize a ll_unitdata_req. */ void cp_init_ll_unitdata_req (T_LL_UNITDATA_REQ * unitdata_req) { unitdata_req->sapi = LL_SAPI_7; unitdata_req->tlli = LL_TLLI_INVALID; unitdata_req->ll_qos.delay = LL_DELAY_SUB; unitdata_req->ll_qos.relclass = LL_RLC_PROT; unitdata_req->ll_qos.peak = LL_PEAK_SUB; unitdata_req->ll_qos.preced = LL_PRECED_SUB; unitdata_req->ll_qos.mean = LL_MEAN_SUB; unitdata_req->radio_prio = LL_RADIO_PRIO_1; unitdata_req->cipher = LL_CIPHER_OFF; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_send_getunitdata_req | +--------------------------------------------------------------------+ PURPOSE : Initialize ready to receive protocol. */ GLOBAL void cp_send_getunitdata_req (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_send_getunitdata_req()"); if (SMS_SMS_FLOW(sms_data) NEQ SMS_FLOW_AVAILABLE) { PALLOC (get_unitdata_req, LL_GETUNITDATA_REQ); memset (get_unitdata_req, 0, sizeof (T_LL_GETUNITDATA_REQ)); get_unitdata_req->sapi = LL_SAPI_7; get_unitdata_req->tlli = LL_TLLI_INVALID; SMS_SMS_FLOW(sms_data) = SMS_FLOW_AVAILABLE; PSENDX (LLC, get_unitdata_req); } } #endif /* GPRS */ /*---- PRIMITIVES --------------------------------------------------*/ /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_mmsms_error_ind | +--------------------------------------------------------------------+ PURPOSE : Processing the primitive MMSMS_ERROR_IND. */ GLOBAL void cp_mmsms_error_ind (T_MMSMS_ERROR_IND *error_ind) { register T_SMS_DATA *sms_data = GET_SMS_INSTANCE (error_ind->ti); TRACE_FUNCTION_P1 ("cp_mmsms_error_ind(TI=%u)", error_ind->ti); if (sms_data) { TRACE_EVENT_P1 ("MMSMS_ERROR_IND.CAUSE: 0x%4.4hX", error_ind->cause); SMS_EM_LOSS_OF_MM_CONNECTION; cp_send_release_req (error_ind->ti); switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_MM_CONNECTION_PENDING: { SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.ti = error_ind->ti; /* This is meant for SMS over GSM as preference and GPRS as fallback. */ #ifdef GPRS if(sms_data->mo_dst_pref EQ GPRS_SMS_CCT_PREF) { TRACE_FUNCTION ("GSM Failed trying with GPRS "); rl_establish_cnf(FALSE); } else #endif { SMS_INST.r_flag = FALSE; /* * RL_ERROR_IND => */ rl_error_ind (error_ind->cause); } break; } case CP_WAIT_FOR_ACK: /* * stop timer TC1M */ sms_timer_stop(TC1M); SMS_RETX(sms_data) = 0; SMS_INST.r_flag = FALSE; SMS_INST.ti = error_ind->ti; /*FALLTHROUGH*/ /*lint -fallthrough*/ case CP_MM_CONNECTION_ESTABLISHED: SMS_INST_SET_STATE (STATE_CP, CP_IDLE); rl_error_ind (error_ind->cause); break; default: SMS_INST_SET_STATE (STATE_CP, CP_IDLE); FREE_SMS_INSTANCE (error_ind->ti); break; } } PFREE (error_ind); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_mmsms_establish_cnf | +--------------------------------------------------------------------+ PURPOSE : Processing the primitive MMSMS_ESTABLISH_CNF. */ GLOBAL void cp_mmsms_establish_cnf (T_MMSMS_ESTABLISH_CNF *establish_cnf) { register T_SMS_DATA *sms_data = GET_SMS_INSTANCE (establish_cnf->ti); TRACE_FUNCTION_P1 ("cp_mmsms_establish_cnf(TI=%u)", establish_cnf->ti); SMS_EM_MM_CONNECTION_ESTABLISHED; if (sms_data) { /* * set TI */ sms_data->data[INST_MO].ti = establish_cnf->ti; /* * reset ack pending */ SMS_INST.cp_ack_pending = FALSE; switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_MM_CONNECTION_PENDING: { /* * CP state transition */ SMS_INST_SET_STATE (STATE_CP, CP_MM_CONNECTION_ESTABLISHED); /* * RL_ESTABLISH_CNF => */ rl_establish_cnf(TRUE); break; } default: TRACE_ERROR("MMSMS_ESTABLISH_CNF in wrong state received!"); break; } } PFREE (establish_cnf); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_mmsms_release_ind | +--------------------------------------------------------------------+ PURPOSE : Processing the primitive MMSMS_RELEASE_IND. */ GLOBAL void cp_mmsms_release_ind (T_MMSMS_RELEASE_IND *release_ind) { register T_SMS_DATA *sms_data = GET_SMS_INSTANCE (release_ind->ti); TRACE_FUNCTION_P1 ("cp_mmsms_release_ind(TI=%u)", release_ind->ti); if (sms_data) { TRACE_EVENT_P1 ("MMSMS_RELEASE_IND: cause=0x%4.4hX", release_ind->cause); SMS_EM_MM_CONNECTION_FAILED; switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_MM_CONNECTION_PENDING: /* ------------------------------------ */ { /* * safe TI */ SMS_INST.ti = release_ind->ti; SMS_INST_SET_STATE (STATE_CP, CP_IDLE); /* This is meant for SMS over GSM as preference and GPRS as fallback. */ #ifdef GPRS if(sms_data->mo_dst_pref EQ GPRS_SMS_CCT_PREF) { TRACE_FUNCTION ("GSM Failed trying with GPRS "); rl_establish_cnf(FALSE); } else #endif { SMS_INST.r_flag = FALSE; /* RL_ERROR_IND */ rl_error_ind (release_ind->cause); } break; } /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { /* * CP state transition CP_IDLE */ SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; /* * RL_ERROR_IND => */ rl_error_ind (release_ind->cause); break; } /* ------------------------------------ */ case CP_WAIT_FOR_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); /* * CP state transition CP_IDLE */ SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_RETX(sms_data) = 0; SMS_INST.r_flag = FALSE; /* * RL_ERROR_IND => */ rl_error_ind (release_ind->cause); break; } /* ------------------------------------ */ default: /* ------------------------------------ */ /* * CP state transition CP_IDLE */ SMS_INST_SET_STATE (STATE_CP, CP_IDLE); FREE_SMS_INSTANCE (release_ind->ti); break; } } PFREE (release_ind); } /*---- SIGNALS -----------------------------------------------------*/ /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_abort_req | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_ABORT_REQ. */ GLOBAL void cp_abort_req (void) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_abort_req(TI=%u)",SMS_INST.ti); SMS_EM_ABORT_OF_MM_CONNECTION; if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { CCD_START; /* * check whether CP ACK needs to be send */ if (SMS_INST.cp_ack_pending EQ TRUE) { cp_build_cp_ack (); } /* * generate CP_ERROR */ cp_build_cp_error (SMS_CP_CS_PROTOCOL_ERROR); /* * release connection */ SMS_INST.r_flag = FALSE; cp_send_release_req (SMS_INST.ti); CCD_END; break; } /* ------------------------------------ */ case CP_MM_CONNECTION_PENDING: /* ------------------------------------ */ { /* * release connection */ SMS_INST.r_flag = FALSE; cp_send_release_req (SMS_INST.ti); break; } /* ------------------------------------ */ case CP_WAIT_FOR_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); CCD_START; /* * check whether CP ACK needs to be send */ if (SMS_INST.cp_ack_pending EQ TRUE) { cp_build_cp_ack (); } /* * generate CP_ERROR */ cp_build_cp_error (SMS_CP_CS_PROTOCOL_ERROR); /* * release connection */ SMS_INST.r_flag = FALSE; cp_send_release_req (SMS_INST.ti); CCD_END; break; } #if defined (GPRS) /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_DATA: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_RP_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); cp_error_req_gsms (SMS_CP_CS_PROTOCOL_ERROR, FALSE); break; } #endif /* GPRS */ } #if defined (GPRS) if (SMS_CP_ACK_TYPE(sms_data) EQ SMS_CP_NONE) #endif /* GPRS */ { SMS_INST_SET_STATE (STATE_CP, CP_IDLE); } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_data_ind_cp_ack | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_IND_CP_ACK. */ GLOBAL void cp_data_ind_cp_ack (void) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_data_ind_cp_ack(TI=%u)", SMS_INST.ti); if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { /* Implements Measure# 8 */ cp_send_err_ind_msg_not_comp (); break; } /* ------------------------------------ */ case CP_WAIT_FOR_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); if (SMS_INST.r_flag) { SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; cp_send_release_req (SMS_INST.ti); FREE_SMS_INSTANCE (SMS_INST.ti); } else { SMS_INST_SET_STATE (STATE_CP, CP_MM_CONNECTION_ESTABLISHED); } break; } #if defined (GPRS) /* ------------------------------------ */ case CP_GSMS_IDLE: /* ------------------------------------ */ { if (SMS_INST.r_flag) { SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; FREE_SMS_INSTANCE (SMS_INST.ti); } else { cp_error_req_gsms (SMS_CP_CS_MSG_NOT_COMP, TRUE); } break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); if (SMS_INST.r_flag) { SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; FREE_SMS_INSTANCE (SMS_INST.ti); } else { SMS_INST_SET_STATE (STATE_CP, CP_GSMS_MO_WAIT_FOR_CP_DATA); } break; } /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_CP_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); SMS_INST_SET_STATE (STATE_CP, CP_IDLE); if (SMS_INST.r_flag) { SMS_INST.r_flag = FALSE; } FREE_SMS_INSTANCE (SMS_INST.ti); break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_DATA: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_RP_ACK: /* ------------------------------------ */ { cp_error_req_gsms (SMS_CP_CS_MSG_NOT_COMP, FALSE); rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, SMSCP_ORIGINATING_ENTITY, SMS_CP_CS_MSG_NOT_COMP)); break; } #endif /* GPRS */ } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_data_ind_cp_data | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_IND_CP_DATA. */ GLOBAL void cp_data_ind_cp_data (T_D_CP_DATA *cp_data) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_data_ind_cp_data(TI=%u)", SMS_INST.ti); if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_WAIT_FOR_ACK: /* ------------------------------------ */ { if (SMS_INST.r_flag) { /* Nothing expected anymore */ /* * stop timer TC1M */ sms_timer_stop(TC1M); /* Implements Measure# 8 */ cp_send_err_ind_msg_not_comp (); break; } else { TRACE_EVENT ("CP ACK lost"); cp_data_ind_cp_ack (); } } /*FALLTHROUGH*/ /*lint -fallthrough*/ /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { /* * remember to cp ack */ SMS_INST.cp_ack_pending = TRUE; /* * RL_DATA_IND => */ rl_data_ind (&cp_data->cp_user_data_dl); break; } #if defined (GPRS) /* ------------------------------------ */ case CP_GSMS_IDLE: /* ------------------------------------ */ { if (SMS_LLC_FLOW(sms_data) EQ SMS_LLC_AVAILABLE) { cp_build_cp_ack (); } else { SMS_CP_ACK_TYPE(sms_data) = SMS_CP_ACK; SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY_WAITING; } SMS_INST_SET_STATE (STATE_CP, CP_GSMS_MT_WAIT_FOR_RP_ACK); rl_data_ind (&cp_data->cp_user_data_dl); break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_DATA: /* ------------------------------------ */ { if (SMS_LLC_FLOW(sms_data) EQ SMS_LLC_AVAILABLE) { /* * generate CP_ACK */ cp_build_cp_ack (); /* * RL_DATA_IND => */ rl_data_ind (&cp_data->cp_user_data_dl); } else { if (SMS_CP_UDL(sms_data) EQ NULL) { MALLOC(SMS_CP_UDL(sms_data), sizeof(T_cp_user_data_dl)); } memcpy (SMS_CP_UDL(sms_data), &cp_data->cp_user_data_dl, sizeof(T_cp_user_data_dl)); SMS_CP_ACK_TYPE(sms_data) = SMS_CP_ACK; SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY_WAITING; SMS_INST_SET_STATE (STATE_CP, CP_GSMS_IDLE); SMS_INST.r_flag = TRUE; } break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_ACK: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_CP_ACK: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_RP_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); cp_error_req_gsms (SMS_CP_CS_MSG_NOT_COMP, FALSE); rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, SMSCP_ORIGINATING_ENTITY, SMS_CP_CS_MSG_NOT_COMP)); break; } #endif /* GPRS */ } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_data_ind_cp_error | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_IND_CP_ERROR. The cause value is marked as CP-ERROR */ GLOBAL void cp_data_ind_cp_error (UBYTE errcs) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_data_ind_cp_error(TI=%u)", SMS_INST.ti); TRACE_EVENT_P1 ("CP Error Cause = %d", (int)errcs); if (sms_data) { TRACE_EVENT_P1 ("CP_ERROR.CAUSE rcvd: 0x%2.2X", (int)errcs); switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { /* Implements Measure# 4 */ cp_send_err_ind_errcs(errcs); break; } /* ------------------------------------ */ case CP_WAIT_FOR_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); /* Implements Measure# 4 */ cp_send_err_ind_errcs(errcs); break; } #if defined (GPRS) /* ------------------------------------ */ case CP_GSMS_IDLE: /* ------------------------------------ */ { SMS_INST.r_flag = FALSE; SMS_INST_SET_STATE (STATE_CP, CP_IDLE); /* FREE_SMS_INSTANCE (SMS_INST.ti); */ break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_DATA: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_RP_ACK: /* ------------------------------------ */ { SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_NET, SMSCP_ORIGINATING_ENTITY, errcs)); /* FREE_SMS_INSTANCE (SMS_INST.ti); */ break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_ACK: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_CP_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_NET, SMSCP_ORIGINATING_ENTITY, errcs)); /*FREE_SMS_INSTANCE (SMS_INST.ti);*/ break; } #endif /* GPRS */ } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_data_ind_cp_unknown | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_IND_CP_UNKNOWN. */ GLOBAL void cp_data_ind_cp_unknown (void) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_data_ind_cp_unknown(TI=%u)", SMS_INST.ti); if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { /* Implements Measure# 3 */ cp_send_err_ind_msg_type_unknown(); break; } /* ------------------------------------ */ case CP_WAIT_FOR_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); /* Implements Measure# 3 */ cp_send_err_ind_msg_type_unknown(); break; } #if defined (GPRS) /* ------------------------------------ */ case CP_GSMS_IDLE: /* ------------------------------------ */ { cp_error_req_gsms (SMS_CP_CS_MSG_TYPE_NON_EXIST, TRUE); break; } /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_ACK: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_CP_ACK: /* ------------------------------------ */ { /* * stop timer TC1M */ sms_timer_stop(TC1M); } /*FALLTHROUGH*/ /*lint -fallthrough*/ /* ------------------------------------ */ case CP_GSMS_MO_WAIT_FOR_CP_DATA: /* ------------------------------------ */ case CP_GSMS_MT_WAIT_FOR_RP_ACK: /* ------------------------------------ */ { cp_error_req_gsms (SMS_CP_CS_MSG_TYPE_NON_EXIST, FALSE); rl_error_ind (CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, SMSCP_ORIGINATING_ENTITY, SMS_CP_CS_MSG_TYPE_NON_EXIST)); break; } #endif /* GPRS */ } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_establish_req | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_ESTABLISH_REQ. */ GLOBAL void cp_establish_req (UBYTE ti) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_establish_req(TI=%u)",ti); #if defined (GPRS) /* * send data on selected downlink */ if (SMS_INST.downlink EQ SMS_DOWNLINK_MMSMS) { #endif /* GPRS */ /* * GSM - establish connection */ switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_IDLE: /* ------------------------------------ */ default: /* ------------------------------------ */ { PALLOC (establish_req, MMSMS_ESTABLISH_REQ); SMS_EM_MM_CONNECTION_ESTABLISHMENT; establish_req->ti = ti; SMS_INST_SET_STATE (STATE_CP, CP_MM_CONNECTION_PENDING); PSENDX (MM, establish_req); break; } /* ------------------------------------ */ //default: /* ------------------------------------ */ // TRACE_ERROR("CP_ESTABLISH_REQ in wrong state received!"); } #if defined (GPRS) } else if (SMS_INST.downlink EQ SMS_DOWNLINK_LL_CHECK) { /* * GMMSMS_REG_STATE_REQ ==> */ PALLOC (reg_state_req, GMMSMS_REG_STATE_REQ); PSENDX (GMM, reg_state_req); /* * CP state transition */ SMS_INST_SET_STATE (STATE_CP, CP_MM_CONNECTION_PENDING); /* * set TI */ sms_data->data[INST_MO].ti = ti; } else { /* * set TI */ sms_data->data[INST_MO].ti = ti; /* * GPRS - do nothing */ rl_establish_cnf(TRUE); /* synchronous call back */ } #endif /* GPRS */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_data_req | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_REQ. */ GLOBAL void cp_data_req (T_U_CP_DATA *cp_data) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_data_req(TI=%u)",SMS_INST.ti); if (sms_data) { /* * U_CP_DATA contains a maximum of 252 Bytes */ PALLOC_SDU (data_req, MMSMS_DATA_REQ, LEN_U_CP_DATA); data_req->sdu.o_buf = ENCODE_OFFSET; cp_data->msg_type = U_CP_DATA; ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&data_req->sdu, (UBYTE *)cp_data, NOT_PRESENT_8BIT); cp_add_pd_ti (SMS_CP_REF(sms_data), &data_req->sdu); #if defined (GPRS) /* * send data on selected downlink */ if (SMS_INST.downlink EQ SMS_DOWNLINK_MMSMS) { #endif /* GPRS */ switch (SMS_INST_GET_STATE (STATE_CP)) { /* ------------------------------------ */ case CP_MM_CONNECTION_ESTABLISHED: /* ------------------------------------ */ { USHORT bsize_message = D_SDU_OFF (data_req)+ D_SDU_LEN (data_req); PALLOC_SDU (tx_data_req, MMSMS_DATA_REQ, bsize_message); /* * check whether CP ACK needs to be send */ if (SMS_INST.cp_ack_pending EQ TRUE) { cp_build_cp_ack (); } /* * reset retry counter */ SMS_RETX(sms_data) = 0; /* * save data req */ if (SMS_DATA_REQ(sms_data) NEQ NULL) PFREE (SMS_DATA_REQ(sms_data)); SMS_DATA_REQ(sms_data) = data_req; /* * CP state transition CP_WAIT_FOR_ACK */ SMS_INST_SET_STATE (STATE_CP, CP_WAIT_FOR_ACK); SMS_EM_SEND_CP_DATA; #if FALSE PCOPY (tx_data_req, data_req); #else SMS_SDU_COPY (tx_data_req, data_req, MMSMS_DATA_REQ); #endif TRACE_BINDUMP(sms_handle, TC_USER4, "U_CP_DATA", (&(tx_data_req->sdu.buf[0]) + ((tx_data_req->sdu.o_buf >> 3) -1)), ((tx_data_req->sdu.l_buf >> 3) + 1)); PSENDX (MM, tx_data_req); /* * start timer TC1M */ sms_timer_start(TC1M); break; } /* ------------------------------------ */ default: /* ------------------------------------ */ { TRACE_ERROR("CP_DATA_REQ in wrong state received!"); PFREE (data_req); break; } } #if defined (GPRS) } else cp_data_req_gsms (data_req); #endif /* GPRS */ } } #if defined (GPRS) /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_send_data_gsms | +--------------------------------------------------------------------+ PURPOSE : Send CP_DATA_REQ on LL downlink. LLC availability to be checked by the caller */ GLOBAL void cp_send_data_gsms (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_send_data_gsms()"); if (sms_data) { USHORT bsize_message = ENCODE_OFFSET + D_SDU_LEN (SMS_DATA_REQ(sms_data)); PALLOC_SDU (unitdata_req, LL_UNITDATA_REQ, bsize_message); /* * copy stored mo message sdu to unitdata sdu buffer */ SMS_SDU_COPY (unitdata_req, SMS_DATA_REQ(sms_data), LL_UNITDATA_REQ); cp_init_ll_unitdata_req (unitdata_req); TRACE_BINDUMP(sms_handle, TC_USER4, "U_CP_DATA", (&(unitdata_req->sdu.buf[0]) + ((unitdata_req->sdu.o_buf >> 3) -1)), ((unitdata_req->sdu.l_buf >> 3) + 1)); PSENDX (LLC, unitdata_req); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_data_req_gsms | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_DATA_REQ on LL downlink. */ GLOBAL void cp_data_req_gsms (T_MMSMS_DATA_REQ *data_req) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_data_req_gsms()"); if (sms_data) { /* * check if LL is still registered */ if (SMS_INST.downlink EQ SMS_DOWNLINK_LL_CHECK) { PALLOC (reg_state_req, GMMSMS_REG_STATE_REQ); memset (reg_state_req, 0, sizeof (T_GMMSMS_REG_STATE_REQ)); PSENDX (GMM, reg_state_req); SMS_INST_SET_STATE (STATE_CP, CP_GSMS_IDLE); } switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_IDLE: case CP_GSMS_IDLE: case CP_GSMS_MO_WAIT_FOR_CP_DATA: case CP_GSMS_MT_WAIT_FOR_RP_ACK: { /* * save message for later usage */ if (SMS_DATA_REQ(sms_data) NEQ NULL) { PFREE (SMS_DATA_REQ(sms_data)); } SMS_DATA_REQ(sms_data) = data_req; /* * send message if flow control allows */ if (SMS_INST.downlink EQ SMS_DOWNLINK_LL) { if (SMS_LLC_FLOW(sms_data) EQ SMS_LLC_AVAILABLE) { cp_send_data_gsms (); SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY; } else { SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY_WAITING; } if ((SMS_INST_GET_STATE (STATE_CP)) EQ CP_GSMS_MT_WAIT_FOR_RP_ACK) { SMS_INST_SET_STATE (STATE_CP, CP_GSMS_MT_WAIT_FOR_CP_ACK); } else if ((SMS_INST_GET_STATE (STATE_CP)) EQ CP_GSMS_MO_WAIT_FOR_CP_DATA) { SMS_INST_SET_STATE (STATE_CP, CP_GSMS_IDLE); } else { SMS_INST_SET_STATE (STATE_CP, CP_GSMS_MO_WAIT_FOR_CP_ACK); } SMS_RETX(sms_data) = 0; /* * start timer TC1M */ sms_timer_start(TC1M); } break; } default: { PFREE (data_req); break; } } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_error_req_gsms | +--------------------------------------------------------------------+ PURPOSE : Sending CP-ERROR over GPRS with consideration of LLC flow control. */ GLOBAL void cp_error_req_gsms (UBYTE cause, BOOL free_ti) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_error_req_gsms()"); if (sms_data) { if (SMS_LLC_FLOW(sms_data) EQ SMS_LLC_AVAILABLE) { CCD_START; cp_build_cp_error (cause); CCD_END; SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; if(free_ti) { FREE_SMS_INSTANCE (SMS_INST.ti); } sms_data->llc_flow = SMS_LLC_BUSY; } else { SMS_CP_ACK_TYPE(sms_data) = SMS_CP_ERROR; SMS_CP_CAUSE(sms_data) = cause; SMS_INST_SET_STATE (STATE_CP, CP_GSMS_IDLE); SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY_WAITING; } } } #endif /* GPRS */ /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_est_ind_cp_ack | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_EST_IND_CP_ACK. */ GLOBAL void cp_est_ind_cp_ack (void) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_est_ind_cp_ack(TI=%u)",SMS_INST.ti); if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_IDLE: { cp_build_cp_error (SMS_CP_CS_MSG_NOT_COMP); SMS_INST.r_flag = FALSE; /*FALLTHROUGH*/ /*lint -fallthrough*/ default: cp_send_release_req (SMS_INST.ti); FREE_SMS_INSTANCE (SMS_INST.ti); break; } } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_est_ind_cp_data | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_EST_IND_CP_DATA. */ GLOBAL void cp_est_ind_cp_data (T_D_CP_DATA *cp_data) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_est_ind_cp_data(TI=%u)",SMS_INST.ti); switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_IDLE: { /* * generate CP_ACK */ cp_build_cp_ack (); /* * CP state transition CP_MM_CONNECTION_ESTABLISHED */ SMS_INST_SET_STATE (STATE_CP, CP_MM_CONNECTION_ESTABLISHED); /* * r flag */ SMS_INST.r_flag = FALSE; /* * RL_DATA_IND => */ rl_data_ind (&cp_data->cp_user_data_dl); break; } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_est_ind_cp_error | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_EST_IND_CP_ERROR. */ GLOBAL void cp_est_ind_cp_error (UBYTE cp_error) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_est_ind_cp_error(TI=%u)", SMS_INST.ti); TRACE_EVENT_P1 ("CP Error Cause = %d", (int)cp_error); if (sms_data) { TRACE_EVENT_P1 ("CP_ERROR.CAUSE rcvd: 0x%2.2X", (int)cp_error); switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_IDLE: { SMS_INST.r_flag = FALSE; cp_send_release_req (SMS_INST.ti); FREE_SMS_INSTANCE (SMS_INST.ti); break; } } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_est_ind_cp_unknown | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_EST_IND_CP_UNKNOWN. */ GLOBAL void cp_est_ind_cp_unknown (void) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_est_ind_cp_unknown(TI=%u)", SMS_INST.ti); if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_IDLE: { cp_build_cp_error (SMS_CP_CS_INFO_NON_EXIST); SMS_INST.r_flag = FALSE; cp_send_release_req (SMS_INST.ti); FREE_SMS_INSTANCE (SMS_INST.ti); break; } } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_release_req | +--------------------------------------------------------------------+ PURPOSE : Processing the signal CP_RELEASE_REQ. */ GLOBAL void cp_release_req (UBYTE ti) { GET_INSTANCE_DATA; TRACE_FUNCTION_P1 ("cp_release_req(TI=%u)", ti); if (sms_data) { switch (SMS_INST_GET_STATE (STATE_CP)) { case CP_IDLE: SMS_INST.r_flag = FALSE; FREE_SMS_INSTANCE (ti); break; case CP_WAIT_FOR_ACK: SMS_INST.r_flag = TRUE; break; case CP_MM_CONNECTION_PENDING: /* * new connection establishment pending * while releasing old connection * (-> concat sms) */ /* * check whether CP ACK needs to be send */ if (SMS_INST.cp_ack_pending EQ TRUE) { cp_build_cp_ack (); } /* * release connection */ SMS_INST.r_flag = FALSE; cp_send_release_req (ti); break; case CP_MM_CONNECTION_ESTABLISHED: /* * check whether CP ACK needs to be send */ if (SMS_INST.cp_ack_pending EQ TRUE) { cp_build_cp_ack (); } /* * CP state transition CP_IDLE */ SMS_INST_SET_STATE (STATE_CP, CP_IDLE); /* * release connection */ SMS_INST.r_flag = FALSE; cp_send_release_req (ti); break; #ifdef GPRS case CP_GSMS_IDLE: SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; FREE_SMS_INSTANCE (SMS_INST.ti); break; case CP_GSMS_MO_WAIT_FOR_CP_ACK: case CP_GSMS_MT_WAIT_FOR_CP_ACK: SMS_INST.r_flag = TRUE; break; case CP_GSMS_MO_WAIT_FOR_CP_DATA: case CP_GSMS_MT_WAIT_FOR_RP_ACK: SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; FREE_SMS_INSTANCE (SMS_INST.ti); break; #endif /* #ifdef GPRS */ default: break; } } } #if defined (GPRS) /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_gmmsms_reg_state_cnf | +--------------------------------------------------------------------+ PURPOSE : Processing the signal GMMSMS_REG_STATE_CNF (GSMS only). */ GLOBAL void cp_gmmsms_reg_state_cnf (T_GMMSMS_REG_STATE_CNF *reg_state_cnf) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_gmmsms_reg_state_cnf()"); if (sms_data EQ NULL) { TRACE_ERROR("Horror: sms_data=NULL"); return; } if (SMS_INST_GET_STATE (STATE_CP) EQ CP_MM_CONNECTION_PENDING) { /* * CP state transition */ SMS_INST_SET_STATE (STATE_CP, CP_GSMS_IDLE); if (reg_state_cnf->reg_state EQ SMS_RS_REGISTERED) { TRACE_EVENT("downlink = SMS_DOWNLINK_LL"); SMS_INST.downlink = SMS_DOWNLINK_LL; cp_send_getunitdata_req (); /* * RL_ESTABLISH_CNF => */ rl_establish_cnf(TRUE); } else { /* * RL_ESTABLISH_CNF => */ rl_establish_cnf(FALSE); } } else if (SMS_INST_GET_STATE (STATE_CP) EQ CP_GSMS_IDLE) { if (reg_state_cnf->reg_state EQ SMS_RS_REGISTERED) { SMS_INST.downlink = SMS_DOWNLINK_LL; cp_send_getunitdata_req (); if (SMS_LLC_FLOW(sms_data) EQ SMS_LLC_AVAILABLE) { /* * using LL is possible, send message */ cp_send_data_gsms (); SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY; } else { SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY_WAITING; } SMS_INST_SET_STATE (STATE_CP, CP_GSMS_MO_WAIT_FOR_CP_ACK); SMS_RETX(sms_data) = 0; /* * start timer TC1M */ sms_timer_start(TC1M); } else { SMS_LLC_FLOW(sms_data) = SMS_LLC_UNKNOWN; if (sms_data->mo_dst_pref EQ GPRS_SMS_GPRS_PREF) { /* * unsing the preferred downlink LL failed, use CSD */ PALLOC (establish_req, MMSMS_ESTABLISH_REQ); TRACE_EVENT("GPRS not registered, fallback to CSD"); establish_req->ti = SMS_INST.ti; SMS_INST.downlink = SMS_DOWNLINK_MMSMS; SMS_INST_SET_STATE (STATE_CP, CP_MM_CONNECTION_PENDING); PSENDX (MM, establish_req); } else { /* * only GPRS is configured to be used, abort */ cp_send_release_req (SMS_INST.ti); SMS_INST_SET_STATE (STATE_CP, CP_IDLE); SMS_INST.r_flag = FALSE; SMS_INST.downlink = SMS_DOWNLINK_NONE; rl_error_ind (SMS_CAUSE_NO_SERVICE); /* FREE_SMS_INSTANCE (SMS_INST.ti); */ } } } PFREE (reg_state_cnf); } #endif /* GPRS */ /*---- FUNCTIONS ---------------------------------------------------*/ /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_build_cp_ack | +--------------------------------------------------------------------+ PURPOSE : Processing the function CP_BUILD_CP_ACK. (GPRS: the appropriate downlink is determined first) */ GLOBAL void cp_build_cp_ack (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_build_cp_ack()"); /* * reset cp ack pending */ SMS_INST.cp_ack_pending = FALSE; #if defined (GPRS) if (SMS_INST.downlink EQ SMS_DOWNLINK_MMSMS) #endif /* GPRS */ { PALLOC_SDU (data_req, MMSMS_DATA_REQ, ENCODE_OFFSET+BSIZE_B_CP_ACK); data_req->sdu.o_buf = ENCODE_OFFSET; data_req->sdu.l_buf = BSIZE_B_CP_ACK; data_req->sdu.buf[BYTELEN_POS(data_req->sdu.o_buf)] = B_CP_ACK; cp_add_pd_ti (SMS_CP_REF(sms_data), &data_req->sdu); SMS_EM_SEND_CP_ACKNOWLEDGE; TRACE_BINDUMP(sms_handle, TC_USER4, "B_CP_ACK", (&(data_req->sdu.buf[0]) + ((data_req->sdu.o_buf >> 3) -1)), ((data_req->sdu.l_buf >> 3) + 1)); PSENDX (MM, data_req); return; } #if defined (GPRS) if ((SMS_INST.downlink EQ SMS_DOWNLINK_LL) /*AND (sms_data->llc_flow EQ SMS_LLC_AVAILABLE)*/) { /* * build cp_ack for LL downlink */ PALLOC_SDU (unitdata_req, LL_UNITDATA_REQ, ENCODE_OFFSET+BSIZE_B_CP_ACK); unitdata_req->sdu.o_buf = ENCODE_OFFSET; unitdata_req->sdu.l_buf = BSIZE_B_CP_ACK; unitdata_req->sdu.buf[BYTELEN_POS(unitdata_req->sdu.o_buf)] = B_CP_ACK; cp_add_pd_ti (SMS_CP_REF(sms_data), &unitdata_req->sdu); cp_init_ll_unitdata_req (unitdata_req); SMS_LLC_FLOW(sms_data) = SMS_LLC_BUSY; TRACE_BINDUMP(sms_handle, TC_USER4, "B_CP_ACK", (&(unitdata_req->sdu.buf[0]) + ((unitdata_req->sdu.o_buf >> 3) -1)), ((unitdata_req->sdu.l_buf >> 3) + 1)); PSENDX (LLC, unitdata_req); } #endif /* GPRS */ } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_build_cp_error | +--------------------------------------------------------------------+ PURPOSE : Processing the function CP_BUILD_CP_ERROR. */ GLOBAL void cp_build_cp_error (UBYTE error) { GET_INSTANCE_DATA; if (sms_data) { TRACE_EVENT_P1 ("CP_ERROR.CAUSE sent: 0x%2.2X", (int)error); #if defined (GPRS) if (SMS_INST.downlink EQ SMS_DOWNLINK_MMSMS) #endif /* GPRS */ { MCAST (cp_error, B_CP_ERROR); PALLOC_MSG (data_req, MMSMS_DATA_REQ, B_CP_ERROR); TRACE_FUNCTION ("cp_build_cp_error()"); SMS_EM_SEND_CP_ERROR; /* * check whether CP ACK needs to be send */ if (SMS_INST.cp_ack_pending EQ TRUE) { cp_build_cp_ack (); } data_req->sdu.o_buf = ENCODE_OFFSET; cp_error->msg_type = B_CP_ERROR; cp_error->cp_cause = error; ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *) &data_req->sdu, (UBYTE *) _decodedMsg, NOT_PRESENT_8BIT); cp_add_pd_ti (SMS_CP_REF(sms_data), &data_req->sdu); TRACE_BINDUMP(sms_handle, TC_USER4, "B_CP_ERROR", (&(data_req->sdu.buf[0]) + ((data_req->sdu.o_buf >> 3) -1)), ((data_req->sdu.l_buf >> 3) + 1)); PSENDX (MM, data_req); return; } #if defined (GPRS) if ((SMS_INST.downlink EQ SMS_DOWNLINK_LL) /*&& (sms_data->llc_flow EQ SMS_LLC_AVAILABLE)*/) { /* * build cp_error for LL downlink */ MCAST (cp_error, B_CP_ERROR); PALLOC_MSG (unitdata_req, LL_UNITDATA_REQ, B_CP_ERROR); TRACE_FUNCTION ("cp_build_cp_error() - LL downlink"); unitdata_req->sdu.o_buf = ENCODE_OFFSET; cp_error->msg_type = B_CP_ERROR; cp_error->cp_cause = error; ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *) &unitdata_req->sdu, (UBYTE *) _decodedMsg, NOT_PRESENT_8BIT); cp_add_pd_ti (SMS_CP_REF(sms_data), &unitdata_req->sdu); cp_init_ll_unitdata_req (unitdata_req); TRACE_BINDUMP(sms_handle, TC_USER4, "B_CP_ERROR", (&(unitdata_req->sdu.buf[0]) + ((unitdata_req->sdu.o_buf >> 3) -1)), ((unitdata_req->sdu.l_buf >> 3) + 1)); PSENDX (LLC, unitdata_req); } #endif /* GPRS */ } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_CP | | STATE : code ROUTINE : cp_send_release_req | +--------------------------------------------------------------------+ PURPOSE : Send a MMSMS_RELEASE_REQ. (GPRS: only if this is not an LL downlink) */ GLOBAL void cp_send_release_req ( UBYTE ti) { GET_INSTANCE_DATA; TRACE_FUNCTION ("cp_send_release_req()"); if (sms_data) { #if defined (GPRS) if (SMS_INST.downlink EQ SMS_DOWNLINK_MMSMS) { #endif PALLOC (release_req, MMSMS_RELEASE_REQ); release_req->ti = ti; PSENDX (MM, release_req); #if defined (GPRS) } #endif } } #endif