FreeCalypso > hg > freecalypso-citrine
diff g23m-gsm/cc/cc_act.c @ 0:75a11d740a02
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 09 Jun 2016 00:02:41 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/g23m-gsm/cc/cc_act.c Thu Jun 09 00:02:41 2016 +0000 @@ -0,0 +1,2316 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS (6147) +| Modul : CC_ACT ++----------------------------------------------------------------------------- +| 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 primitive processing functions +| of the SDL process Call Control for the call active +| phase of the component CC of the mobile station ++----------------------------------------------------------------------------- +*/ + +#ifndef CC_ACT_C +#define CC_ACT_C + +#include "config.h" +#include "fixedconf.h" +#include "condat-features.h" + +#define ENTITY_CC +/*==== INCLUDES ===================================================*/ + +#include <string.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 "cnf_cc.h" +#include "mon_cc.h" +#include "pei.h" +#include "tok.h" +#include "cc.h" +#include "cc_em.h" + +/*==== EXPORT =====================================================*/ + +/*==== PROTOTYPES =================================================*/ +LOCAL void cc_mncc_hold_retrieve_req (T_PRIM * prim); + +/*==== PRIVAT =====================================================*/ + +/*==== VARIABLES ==================================================*/ + +/*==== FUNCTIONS ==================================================*/ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_dtmf_full | ++--------------------------------------------------------------------+ + + PURPOSE : Check whether DTMF buffer is full + +*/ + +LOCAL BOOL cc_dtmf_full (const T_DTMF *p_dtmf) +{ + TRACE_FUNCTION ("cc_dtmf_full()"); + + return ((p_dtmf->read EQ p_dtmf->write + 1) OR + (p_dtmf->read EQ 0 AND p_dtmf->write EQ DTMF_BUF_SIZE - 1)); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_dtmf_empty | ++--------------------------------------------------------------------+ + + PURPOSE : Check whether DTMF buffer is empty + +*/ + +LOCAL BOOL cc_dtmf_empty (const T_DTMF *p_dtmf) +{ + TRACE_FUNCTION ("cc_dtmf_empty()"); + + return (p_dtmf->read EQ p_dtmf->write); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_dtmf_write | ++--------------------------------------------------------------------+ + + PURPOSE : Write next entry into DTMF buffer. + No checks are done (e.g. buffer full) + +*/ + +LOCAL void cc_dtmf_write (T_DTMF *p_dtmf, UBYTE val) +{ + TRACE_FUNCTION ("cc_dtmf_write()"); + + p_dtmf->buf[p_dtmf->write++] = val; + if (p_dtmf->write EQ DTMF_BUF_SIZE) + p_dtmf->write = 0; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_dtmf_write | ++--------------------------------------------------------------------+ + + PURPOSE : Read next entry from DTMF buffer. + No checks are done (e.g. buffer empty) + +*/ + +LOCAL UBYTE cc_dtmf_read (T_DTMF *p_dtmf) +{ + UBYTE val; + + TRACE_FUNCTION ("cc_dtmf_read()"); + + val = p_dtmf->buf[p_dtmf->read++]; + if (p_dtmf->read EQ DTMF_BUF_SIZE) + p_dtmf->read = 0; + return val; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_dtmf_allowed | ++--------------------------------------------------------------------+ + + PURPOSE : This functions returns TRUE if DTMF is allowed in the + current state, otherwise FALSE. + +*/ + +LOCAL BOOL cc_dtmf_allowed (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_dtmf_allowed()"); + + /* + * "The mobile station shall be capable of transmitting DTMF messages if + * and only if the mobile station has the user connection for speech + * attached and an appropriate channel is available. + * + * ".." + * + * NOTE 1: This specification means that DTMF messages can generally be + * sent in the active state of a call in speech transmission + * mode or when a traffic channel is available during setup or + * release and the progress indicator IE has been received." + * + * [TS 24.008 subclause 5.5.7] + * + * As of GSM 04.08 the progress indicator IE can be received by + * CALL PROCEEDING, PROGRESS, CONNECT, SETUP, ALERTING and DISCONNECT. + */ + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_3: /* mobile originating call proceeding */ + case M_CC_CS_4: /* call delivered */ + case M_CC_CS_8: /* connect request */ + case M_CC_CS_11: /* disconnect request */ + case M_CC_CS_12: /* disconnect indication */ + case M_CC_CS_19: /* release request */ + case CS_101: /* substate of CS_10, reestablish requested */ + case M_CC_CS_26: /* mobile originating modify */ + case CS_261: /* substate of CS_26, reestablish requested */ + if (cc_data->progress_desc[cc_data->index_ti] EQ NOT_PRESENT_8BIT) + return FALSE; /* Progress indicator IE has not been received */ + /*FALLTHROUGH*/ /*lint -fallthrough*/ + case M_CC_CS_10: /* active */ + if (cc_data->channel_type EQ NAS_CH_SDCCH) + return FALSE; /* No TCH assigned */ + + if ((cc_data->channel_mode NEQ NAS_CHM_SPEECH) AND + (cc_data->channel_mode NEQ NAS_CHM_SPEECH_V2) AND + (cc_data->channel_mode NEQ NAS_CHM_SPEECH_V3)) + return FALSE; /* Channel mode is not speech */ + + return TRUE; + + default: + return FALSE; + } +} + +/*==== VARIABLES ==================================================*/ + +/*==== FUNCTIONS ==================================================*/ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_start_dtmf_req | ++--------------------------------------------------------------------+ + + PURPOSE : Sending of DTMF tones to the infrastructure side. + +*/ + +GLOBAL void cc_mncc_start_dtmf_req (T_MNCC_START_DTMF_REQ * dtmf) +{ + GET_INSTANCE_DATA; + T_DTMF * p_dtmf; + + TRACE_FUNCTION ("cc_mncc_start_dtmf_req()"); + + + if ((cc_data->index_ti = srv_convert_ti (dtmf->ti)) + EQ NOT_PRESENT_8BIT) + { + PFREE (dtmf); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + default: + if (!cc_dtmf_allowed ()) + { + /* Tone dropped. Confirm DTMF request with negative cause */ + PALLOC (dtmf_cnf, MNCC_START_DTMF_CNF); + dtmf_cnf->ti = dtmf->ti; + dtmf_cnf->key = dtmf->key; + dtmf_cnf->cause = MNCC_CAUSE_DTMF_NOT_ALLOWED; + dtmf_cnf->dtmf_mod = dtmf->dtmf_mod; + PSENDX (MMI, dtmf_cnf); + + PFREE (dtmf); + return; + } + + p_dtmf = &cc_data->dtmf [cc_data->index_ti]; + + if ( dtmf->dtmf_mod EQ MNCC_DTMF_MOD_AUTO OR + dtmf->dtmf_mod EQ MNCC_DTMF_MOD_MAN_START ) + { + if (p_dtmf->state EQ DTMF_IDLE) + { + /* + * If sending of DTMF tones is not in + * progress send the tone. + */ + CCD_START; + { + MCAST (start_dtmf, U_START_DTMF); + + cc_build_start_dtmf (dtmf->key, start_dtmf); + for_start_dtmf (start_dtmf); + } + CCD_END; + + /* On sending a START DTMF message the MS shall start T336 */ + TIMERSTART (T336, T336_VALUE); + + p_dtmf->state = DTMF_SEND_REQUEST; + p_dtmf->mode = (dtmf->dtmf_mod EQ MNCC_DTMF_MOD_AUTO)?DTMF_AUTO:DTMF_MAN; + p_dtmf->key = dtmf->key; + } + else + { + /* + * Not DTMF_IDLE. + */ + + if (dtmf->dtmf_mod EQ MNCC_DTMF_MOD_AUTO) + { + /* + * If DTMF_MOD_AUTO, store the tone if the buffer is not full. + */ + if (!cc_dtmf_full (p_dtmf)) + cc_dtmf_write (p_dtmf, (UBYTE)SET_DTMF_MOD(dtmf->key, DTMF_AUTO)); + // PATCH HM 13.04.00 >>> + else + { + /* Tone dropped. Confirm DTMF request with negative cause */ + PALLOC (dtmf_cnf, MNCC_START_DTMF_CNF); + dtmf_cnf->ti = dtmf->ti; + dtmf_cnf->key = dtmf->key; + dtmf_cnf->cause = MNCC_CAUSE_DTMF_BUFFER_FULL; + dtmf_cnf->dtmf_mod = dtmf->dtmf_mod; + PSENDX(MMI, dtmf_cnf); + } + // PATCH HM 13.04.00 <<< + } + else + { + /* + * If DTMF_MOD_MAN_START, two conditions have to be fullfilled + * that the tone is stored and not dropped: + * + * - The buffer is not full. + * - There is enough room to store the stop which + * will follow the tone. + */ + if (!cc_dtmf_full (p_dtmf) AND + (p_dtmf->read NEQ (p_dtmf->write + 2) % DTMF_BUF_SIZE)) + { + cc_dtmf_write (p_dtmf, (UBYTE)SET_DTMF_MOD(dtmf->key, DTMF_MAN)); + } + // PATCH HM 13.04.00 >>> + else + { + /* Tone dropped. Confirm DTMF request with negative cause */ + PALLOC (dtmf_cnf, MNCC_START_DTMF_CNF); + dtmf_cnf->ti = dtmf->ti; + dtmf_cnf->key = dtmf->key; + dtmf_cnf->cause = MNCC_CAUSE_DTMF_BUFFER_FULL; + dtmf_cnf->dtmf_mod = dtmf->dtmf_mod; + PSENDX (MMI, dtmf_cnf); + } + // PATCH HM 13.04.00 <<< + } + } + } + else + { + /* + * This is DTMF_MOD_MAN_STOP + */ + if ( p_dtmf->state EQ DTMF_SEND_ACKNOWLEDGE AND + cc_dtmf_empty (p_dtmf)) + { + /* + * If sending of DTMF tones is in + * progress stop the tone. + */ + for_stop_dtmf (); + + /* On sending a STOP DTMF message the MS shall start T337 */ + TIMERSTART (T337, T337_VALUE); + + p_dtmf->state = DTMF_STOP_REQUEST; + } + else + { + /* + * If DTMF_MOD_MAN_STOP, the stop mark is stored if + * the buffer is not full. If DTMF STOP ACK is received + * and there are unexpected stops in the buffer due to + * a loss of the respective tones, the stops are dropped + * until a tone is found. + */ + if (!cc_dtmf_full(p_dtmf)) + { + cc_dtmf_write (p_dtmf, NOT_PRESENT_8BIT); + } + } + } + PFREE (dtmf) + break; + + case M_CC_CS_26: /* mobile originating modify */ + case CS_101: + case CS_261: + srv_store_prim ((T_PRIM *)D2P(dtmf)); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_reset_dtmf | ++--------------------------------------------------------------------+ + + PURPOSE : Reset DTMF machine. If used before CC leaves any state in + which DTMF is possible MMI is informed about DTMF failure + if there was still a DTMF request outstanding. + +*/ + +GLOBAL void cc_reset_dtmf (void) +{ + GET_INSTANCE_DATA; + T_DTMF * p_dtmf; + BOOL dtmf_aborted; + + TRACE_FUNCTION ("cc_reset_dtmf"); + + p_dtmf = &cc_data->dtmf[cc_data->index_ti]; + + if (cc_dtmf_allowed()) + { + /* Stop all possibly running DTMF timers */ + TIMERSTOP (TIMER_DTMF); + + /* + * A DTMF acknowledge maybe outstanding for ACI either if the + * DTMF state is DTMF_SEND_REQ or + * a tone was found in the DTMF send buffer + */ + dtmf_aborted = (p_dtmf->state EQ DTMF_SEND_REQUEST); + while (!dtmf_aborted AND !cc_dtmf_empty(p_dtmf)) + dtmf_aborted = (cc_dtmf_read (p_dtmf) NEQ NOT_PRESENT_8BIT); + + if (dtmf_aborted) + { + /* Tone dropped. Confirm DTMF request with negative cause */ + PALLOC (dtmf_cnf, MNCC_START_DTMF_CNF); + dtmf_cnf->ti = cc_data->ti; + dtmf_cnf->key = NOT_PRESENT_8BIT; + dtmf_cnf->cause = MNCC_CAUSE_DTMF_ABORTED; + dtmf_cnf->dtmf_mod = NOT_PRESENT_8BIT; + PSENDX (MMI, dtmf_cnf); + } + + } + p_dtmf->state = DTMF_IDLE; + p_dtmf->write = 0; + p_dtmf->read = 0; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_start_dtmf_ack | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming start dtmf acknowledge message. + +*/ + +GLOBAL void cc_start_dtmf_ack (T_D_START_DTMF_ACK * start_dtmf_ack) +{ + GET_INSTANCE_DATA; + T_DTMF * p_dtmf; + + TRACE_FUNCTION ("cc_start_dtmf_ack()"); + + if (cc_dtmf_allowed ()) + { + if (cc_check_error_flag ()) + { + p_dtmf = &cc_data->dtmf[cc_data->index_ti]; + + /* Stop T336 */ + TIMERSTOP (TIMER_DTMF); + + if (p_dtmf->state EQ DTMF_SEND_REQUEST) + { + PALLOC (start, MNCC_START_DTMF_CNF); + + start->ti = cc_data->ti; + start->key = start_dtmf_ack->key_facility.key; + start->cause = MNCC_CAUSE_DTMF_START_SUCCESS; + start->dtmf_mod = (p_dtmf->mode EQ DTMF_AUTO) ? + MNCC_DTMF_MOD_AUTO : MNCC_DTMF_MOD_MAN_START; + PSENDX (MMI, start); + + EM_CC_START_DTMF_ACKNOWLEDGE; + + if( p_dtmf->mode EQ DTMF_AUTO ) + { + for_stop_dtmf (); + + /* On sending a STOP DTMF message the MS shall start T337 */ + TIMERSTART (T337, T337_VALUE); + + p_dtmf->state = DTMF_STOP_REQUEST; + } + else + { + /* This is DTMF_MAN */ + if (!cc_dtmf_empty (p_dtmf)) + { + UBYTE tone; + + tone = cc_dtmf_read (p_dtmf); + if (tone EQ NOT_PRESENT_8BIT) + { + /* Should be always true */ + p_dtmf->mode = GET_DTMF_MOD(tone); + for_stop_dtmf (); + + /* On sending a STOP DTMF message the MS shall start T337 */ + TIMERSTART (T337, T337_VALUE); + + p_dtmf->state = DTMF_STOP_REQUEST; + } + while (!cc_dtmf_empty(p_dtmf) AND + p_dtmf->buf[p_dtmf->read] EQ NOT_PRESENT_8BIT) + { + /* Consume all unwanted stop marks */ + (void)cc_dtmf_read(p_dtmf); + } + } + else + p_dtmf->state = DTMF_SEND_ACKNOWLEDGE; + } +/* Implements Measure# 3 and streamline encoding */ + CCD_END; + } + else + { + +/* Implements Measure# 3 and streamline encoding */ + CCD_END; + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } +/* Implements Measure# 3 and streamline encoding */ + } /* if (cc_check_error_flag (cc_data)) */ + } /* if (cc_dtmf_allowed (cc_data)) */ + else + { + /* + * DTMF not allowed for some reason, e.g. wrong state, + * call is not a speech call, no TCH assigned etc. + */ + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_start_dtmf_rej | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming start dtmf reject message. + +*/ + +GLOBAL void cc_start_dtmf_rej (T_D_START_DTMF_REJ * start_dtmf_rej) +{ + GET_INSTANCE_DATA; + T_DTMF * p_dtmf; + + TRACE_FUNCTION ("cc_start_dtmf_rej()"); + + if (cc_dtmf_allowed ()) + { + if (cc_check_error_flag ()) + { + /* Stop T336 */ + TIMERSTOP (TIMER_DTMF); + p_dtmf = &cc_data->dtmf[cc_data->index_ti]; + if (p_dtmf->state EQ DTMF_SEND_REQUEST) + { + PALLOC (start, MNCC_START_DTMF_CNF); + + start->ti = cc_data->ti; + start->key = NOT_PRESENT_8BIT; + start->dtmf_mod = NOT_PRESENT_8BIT; + /* + * cause IE is mandatory and the check for presence has been done already + * thus there is no need to check for validity of cause IE here anymore + */ + start->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + start_dtmf_rej->cc_cause.cause); + PSENDX (MMI, start); + + p_dtmf->state = DTMF_IDLE; + p_dtmf->write = 0; + p_dtmf->read = 0; +/* Implements Measure# 3 and streamline encoding */ + CCD_END; + } + else + { +/* Implements Measure# 3 and streamline encoding */ + CCD_END; + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } +/* Implements Measure# 3 and streamline encoding */ + } + } + else + { + /* + * DTMF not allowed for some reason, e.g. wrong state, + * call is not a speech call, no TCH assigned etc. + */ + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_stop_dtmf | ++--------------------------------------------------------------------+ + + PURPOSE : Stops DTMF, back to DTMF_IDLE state. + Reasons for call: + 1.) Reception of STOP DTMF ACK message + 2.) Expiry of T336 + 3.) Expiry of T337 + +*/ + +GLOBAL void cc_stop_dtmf (void) +{ + GET_INSTANCE_DATA; + T_DTMF * p_dtmf; + + TRACE_FUNCTION ("cc_stop_dtmf()"); + + p_dtmf = &cc_data->dtmf[cc_data->index_ti]; + + while (!cc_dtmf_empty(p_dtmf)) + { + UBYTE tone; + + tone = cc_dtmf_read (p_dtmf); + if (tone NEQ NOT_PRESENT_8BIT) + { + /* + * another DTMF tone has to be sent + */ + p_dtmf->mode = GET_DTMF_MOD (tone); + p_dtmf->key = tone & 0x7f; + CCD_START; + { + MCAST (start, U_START_DTMF); + + cc_build_start_dtmf (p_dtmf->key, start); + for_start_dtmf (start); + } + CCD_END; + + /* On sending a START DTMF message the MS shall start T336 */ + TIMERSTART (T336, T336_VALUE); + + p_dtmf->state = DTMF_SEND_REQUEST; + return; + } + } + p_dtmf->state = DTMF_IDLE; + srv_use_stored_prim (); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_stop_dtmf_ack | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming stop dtmf ack message. + +*/ + +GLOBAL void cc_stop_dtmf_ack (void) +{ + GET_INSTANCE_DATA; + T_DTMF * p_dtmf; + + TRACE_FUNCTION ("cc_stop_dtmf_ack()"); + + if (cc_dtmf_allowed ()) + { + if (cc_check_error_flag ()) + { + CCD_END; + p_dtmf = &cc_data->dtmf[cc_data->index_ti]; + if (p_dtmf->state EQ DTMF_STOP_REQUEST) + { + if (p_dtmf->mode EQ DTMF_MAN) + { + PALLOC (start, MNCC_START_DTMF_CNF); + start->ti = cc_data->ti; + start->key = NOT_PRESENT_8BIT; + start->cause = MNCC_CAUSE_DTMF_STOP_SUCCESS; + start->dtmf_mod = MNCC_DTMF_MOD_MAN_STOP; + PSENDX (MMI, start); + } + /* Stop T337 */ + TIMERSTOP (TIMER_DTMF); + cc_stop_dtmf (); + } + else + { + /* + * The STOP DTMF ACK message was not expected as we did not sent + * previously a START DTMF request. + */ +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } + } + } + else + { + /* + * DTMF not allowed in the current state + */ + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_facility_req | ++--------------------------------------------------------------------+ + + PURPOSE : Sending of Facility Information by the mobile side. + +*/ + +GLOBAL void cc_mncc_facility_req (T_MNCC_FACILITY_REQ * facility) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_mncc_facility_req()"); + + if ((cc_data->index_ti = srv_convert_ti (facility->ti)) + EQ NOT_PRESENT_8BIT) + { + PFREE (facility); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_19: + PFREE (facility); + break; + + case M_CC_CS_01: + case CS_101: + case CS_261: + srv_store_prim ((T_PRIM *)D2P(facility)); + break; + + default: + CCD_START; + { + MCAST (facility_msg, U_FACILITY); + cc_build_facility (facility, facility_msg); + for_facility (facility_msg); + + EM_CC_FACILITY_TO_THE_NETWORK; + + } + CCD_END; + PFREE (facility); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_modify_req | ++--------------------------------------------------------------------+ + + PURPOSE : Start of a mobile originated in-call modification. + +*/ + +GLOBAL void cc_mncc_modify_req (T_MNCC_MODIFY_REQ * modify) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_mncc_modify_req()"); + + if ((cc_data->index_ti = srv_convert_ti (modify->ti)) + EQ NOT_PRESENT_8BIT) + { + PFREE (modify); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_10: + if (((cc_data->hold_state[cc_data->index_ti] EQ M_CC_HLD_IDLE)) AND + (cc_data->dtmf[cc_data->index_ti].state EQ DTMF_IDLE)) + { + /* + * If no other procedure is running + */ + CCD_START; + { + MCAST (modify_msg, B_MODIFY); + cc_build_modify (modify, modify_msg); + for_modify (modify_msg); + } + CCD_END; + PFREE (modify); + cc_set_state (M_CC_CS_26); + TIMERSTART (T323, T323_VALUE); + + EM_CC_MO_IN_CALL_MODIFICATION; + + } + else + srv_store_prim ((T_PRIM *)D2P(modify)); + break; + + default: + PFREE (modify); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_user_req | ++--------------------------------------------------------------------+ + + PURPOSE : Send user information or congestion control. + +*/ + +GLOBAL void cc_mncc_user_req (T_MNCC_USER_REQ * user) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_mncc_user_req()"); + + if ((cc_data->index_ti = srv_convert_ti (user->ti)) + EQ NOT_PRESENT_8BIT) + { + PFREE (user); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_10: + switch (user->congest_lev) + { + case M_CC_CL_RECEIVER_READY: + case M_CC_CL_RECEIVER_NOT_READY: + /* + * Send Congestion Control + */ + CCD_START; + { + MCAST (cong_ctrl, B_CONGEST_CTRL); + + cc_build_congestion_control (user, cong_ctrl); + for_congestion_control (cong_ctrl); + } + CCD_END; + PFREE (user); + break; + default: + /* + * Send User Information + */ + CCD_START; + { + MCAST (user_msg, B_USER_INFO); + + cc_build_user_information (user, user_msg); + for_user_information (user_msg); + } + CCD_END; + PFREE (user); + break; + } + break; + + case CS_101: + srv_store_prim ((T_PRIM *)D2P(user)); + break; + + default: + PFREE (user); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_hold_req | ++--------------------------------------------------------------------+ + + PURPOSE : Send hold message. + +*/ + +GLOBAL void cc_mncc_hold_req (T_MNCC_HOLD_REQ * hold) +{ + + TRACE_FUNCTION ("cc_mncc_hold_req()"); + +/* Implements Measure# 18 */ + cc_mncc_hold_retrieve_req ((T_PRIM *)D2P(hold)); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_retrieve_req | ++--------------------------------------------------------------------+ + + PURPOSE : Send retrieve message. + +*/ +GLOBAL void cc_mncc_retrieve_req (T_MNCC_RETRIEVE_REQ * retrieve) +{ + + TRACE_FUNCTION ("cc_mncc_retrieve_req()"); + +/* Implements Measure# 18 */ + cc_mncc_hold_retrieve_req ((T_PRIM *)D2P(retrieve)); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_call_is_active | ++--------------------------------------------------------------------+ + + PURPOSE : Return TRUE if the respective CC instance is in an active + state, otherwise return FALSE. + +*/ + +LOCAL BOOL cc_call_is_active (UBYTE index_ti) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_call_is_active()"); + + switch (cc_data->state[index_ti]) + { + case M_CC_CS_10: + case M_CC_CS_26: + case CS_101: + case CS_261: + return TRUE; + + default: + return FALSE; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_sync_req | ++--------------------------------------------------------------------+ + + PURPOSE : Processing a MNCC_SYNC_REQ primitive. To be able to + understand some details of this function, see first + GSM 03.84, GSM 04.84 and GSM 11.10 chapters 31.4.1 and 31.4.2. + +*/ + +GLOBAL void cc_mncc_sync_req (T_MNCC_SYNC_REQ * mncc_sync_req) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cc_mncc_sync_req()"); + + if ((cc_data->index_ti = srv_convert_ti (mncc_sync_req->ti)) + EQ NOT_PRESENT_8BIT) + { + PFREE (mncc_sync_req); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * Note: MPTY and HOLD only has a meaning in the following states, + * in other states these aux states have absolutely no meaning. + */ + case M_CC_CS_10: + case M_CC_CS_26: + case CS_101: + case CS_261: + switch (mncc_sync_req->synccs) + { + case MNCC_SYNCCS_MPTY_EVENT: + + TRACE_EVENT_P2 (" ti = %d, mpty_event = %d", + mncc_sync_req->ti, + mncc_sync_req->mpty_event); + + switch (mncc_sync_req->mpty_event) + { + case MNCC_MPTY_BUILD_SENT: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] EQ M_CC_MPTY_IDLE) + { + cc_data->mpty_state[i] = M_CC_MPTY_REQ; + } + } + break; + + case MNCC_MPTY_BUILD_FAIL: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] EQ M_CC_MPTY_REQ) + { + cc_data->mpty_state[i] = M_CC_MPTY_IDLE; + } + } + break; + + case MNCC_MPTY_BUILD_SUCCESS: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i)) + { + cc_data->mpty_state[i] = M_CC_MPTY_CALL; + cc_data->hold_state[i] = M_CC_HLD_IDLE; + } + } + break; + + /* -- */ + + case MNCC_MPTY_SPLIT_SENT: + if (cc_data->mpty_state[cc_data->index_ti] EQ M_CC_MPTY_CALL) + { + cc_data->mpty_state[cc_data->index_ti] = M_CC_MPTY_SPLIT; + } + break; + + case MNCC_MPTY_SPLIT_FAIL: + if (cc_data->mpty_state[cc_data->index_ti] EQ M_CC_MPTY_SPLIT) + { + cc_data->mpty_state[cc_data->index_ti] = M_CC_MPTY_CALL; + } + break; + + case MNCC_MPTY_SPLIT_SUCCESS: + cc_data->mpty_state[cc_data->index_ti] = M_CC_MPTY_IDLE; + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_IDLE; + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_CALL_HELD; + } + } + break; + + /* -- */ + + case MNCC_MPTY_HOLD_SENT: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_HOLD_REQ; + } + } + break; + + case MNCC_MPTY_HOLD_FAIL: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_IDLE; + } + } + break; + + case MNCC_MPTY_HOLD_SUCCESS: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_CALL_HELD; + } + } + break; + + /* -- */ + + case MNCC_MPTY_RETRIEVE_SENT: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_RETRIEVE_REQ; + } + } + break; + + case MNCC_MPTY_RETRIEVE_FAIL: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_CALL_HELD; + } + } + break; + + case MNCC_MPTY_RETRIEVE_SUCCESS: + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i) AND + cc_data->mpty_state[i] NEQ M_CC_MPTY_IDLE) + { + cc_data->hold_state[i] = M_CC_HLD_IDLE; + } + } + break; + + /* -- */ + + default: + TRACE_ERROR ("Illegal MPTY event"); + break; + } /* switch (mncc_sync_req->mpty_event) */ + break; + + default: + TRACE_ERROR ("Illegal SYNCCS"); + } /* switch (mncc_sync_req->synccs) */ + break; + + default: + break; /* Ignore the event */ + } /* switch (cc_data->state[cc_data->index_ti]) */ + +#ifndef NTRACE + for (i = 0; i < MAX_CC_CALLS; i++) + { + if (cc_call_is_active(i)) + { + TRACE_EVENT_P4 (" hold[%d] = %d, mpty[%d] = %d", + cc_data->stored_ti_values[i], + cc_data->hold_state[i], + cc_data->stored_ti_values[i], + cc_data->mpty_state[i]); + } + } +#endif /* #ifndef NTRACE */ + + PFREE (mncc_sync_req); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_status_res | ++--------------------------------------------------------------------+ + + PURPOSE : Processing a MNCC_STATUS_RES primitive. There is an + outstanding STATUS message which still has to be sent to + the network after having received a STATUS ENQUIRY in U10. + +*/ + +GLOBAL void cc_mncc_status_res (T_MNCC_STATUS_RES * mncc_status_res) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_mncc_status_res()"); + + if ((cc_data->index_ti = srv_convert_ti (mncc_status_res->ti)) + EQ NOT_PRESENT_8BIT) + { + PFREE (mncc_status_res); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_01: /* MM connection pending */ + case CS_101: /* No network connection, reestablishment in progress */ + case CS_261: + break; + + default: +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_STATUS_ENQUIRY); + break; + } + + PFREE (mncc_status_res); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_facility | ++--------------------------------------------------------------------+ + + PURPOSE : Processing of an incoming facility message. + +*/ + +GLOBAL void cc_facility (T_D_FACILITY * facility) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_facility()"); + + /* + * A facility message can be received in every state where CC has a + * MM connection, no need to check states here. + */ + if (cc_check_error_flag ()) + { + cc_build_facility_ind (MNCC_FAC_IN_FACILITY, TRUE, &facility->facility); + CCD_END; + } + + EM_CC_FACILITY_FROM_THE_NETWORK; + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_hold_ack | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming hold ack message. + +*/ + +GLOBAL void cc_hold_ack (void) +{ + GET_INSTANCE_DATA; + CCD_END; + + TRACE_FUNCTION ("cc_hold_ack()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_check_error_flag ()) + { + if (cc_data->hold_state[cc_data->index_ti] EQ M_CC_HLD_HOLD_REQ) + { + PALLOC (hold_cnf, MNCC_HOLD_CNF); + + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_CALL_HELD; + hold_cnf->ti = cc_data->ti; + hold_cnf->cause = MNCC_CAUSE_HOLD_SUCCESS; + PSENDX (MMI, hold_cnf); + + EM_CC_CALL_HOLD_ACKNOWLEDGE; + + } + else + { +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } + } + break; + + default: +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_hold_rej | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming hold rej message. + +*/ + +GLOBAL void cc_hold_rej (T_D_HOLD_REJ * hold_rej) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_hold_rej()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_data->hold_state[cc_data->index_ti] EQ M_CC_HLD_HOLD_REQ) + { + PALLOC (hold_cnf, MNCC_HOLD_CNF); + + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_IDLE; + hold_cnf->ti = cc_data->ti; + + /* + * It is possible for the network to send a REJ without a Cause IE. + * This causes the decoder to flag a Madatory IE error. According to + * 04.08 Sec: 8.5.3.e, the REJ should still be managed as if a correctly + * formatted REJ had been received. + */ + if (!hold_rej->cc_cause.v_cause) + { + hold_cnf->cause = MNCC_CAUSE_NO_NET_CAUSE; + } + else + { + hold_cnf->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + hold_rej->cc_cause.cause); + } + PSENDX (MMI, hold_cnf); + srv_use_stored_prim (); + + EM_CC_CALL_HOLD_REJECT; + + CCD_END; + } + else + { + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } + break; + + default: + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_retrieve_ack | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming retrieve ack message. + +*/ + +GLOBAL void cc_retrieve_ack (void) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_retrieve_ack()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_check_error_flag ()) + { + CCD_END; + if (cc_data->hold_state[cc_data->index_ti] EQ M_CC_HLD_RETRIEVE_REQ) + { + PALLOC (retrieve_cnf, MNCC_RETRIEVE_CNF); + + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_IDLE; + retrieve_cnf->ti = cc_data->ti; + retrieve_cnf->cause = MNCC_CAUSE_RETRIEVE_SUCCESS; + PSENDX (MMI, retrieve_cnf); + + EM_CC_CALL_RETRIEVE_ACKNOWLEDGE; + + } + else + { +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } + } + break; + + default: + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_retrieve_rej | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming retrieve rej message. + +*/ + +GLOBAL void cc_retrieve_rej (T_D_RETRIEVE_REJ * retrieve_rej) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_retrieve_rej()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_data->hold_state[cc_data->index_ti] EQ M_CC_HLD_RETRIEVE_REQ) + { + PALLOC (retrieve_cnf, MNCC_RETRIEVE_CNF); + + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_CALL_HELD; + retrieve_cnf->ti = cc_data->ti; + + /* + * It is possible for the network to send a REJ without a Cause IE. + * This causes the decoder to flag a Madatory IE error. According to + * 04.08 Sec: 8.5.3.e, the REJ should still be managed as if a correctly + * formatted REJ had been received. + */ + if (!retrieve_rej->cc_cause.v_cause) + { + retrieve_cnf->cause = MNCC_CAUSE_NO_NET_CAUSE; + } + else + { + retrieve_cnf->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + retrieve_rej->cc_cause.cause); + } + PSENDX (MMI, retrieve_cnf); + srv_use_stored_prim (); + + EM_CC_CALL_RETRIEVE_REJECT; + + CCD_END; + } + else + { + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + } + break; + + default: + CCD_END; +/* Implements Measure# 3 and streamline encoding */ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_congestion_control | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming congestion control message. + +*/ + +GLOBAL void cc_congestion_control (T_B_CONGEST_CTRL * cong) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_congestion_control()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_check_error_flag ()) + { + PALLOC (user, MNCC_USER_IND); + + cc_build_user_ind_from_cong (user, cong); + PSENDX (MMI, user); + CCD_END; + } + break; + + default: + CCD_END; +/* Implements Measure# 3 and streamline encoding*/ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_user_information | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming user information message. + +*/ + +GLOBAL void cc_user_information ( T_B_USER_INFO * user) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_user_information()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_check_error_flag ()) + { + PALLOC (user_ind, MNCC_USER_IND); + + cc_build_user_ind_from_user (user_ind, user); + CCD_END; + PSENDX (MMI, user_ind); + + EM_CC_USER_TO_USER_DATA_RECEIVED; + + } + break; + + default: + CCD_END; +/* Implements Measure# 4 and streamline encoding*/ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_modify | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming modify message. + +*/ + +GLOBAL void cc_modify (T_B_MODIFY * modify) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_modify()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_10: + if (cc_check_error_flag ()) + { + switch (cc_data->neg_ri) + { + case M_CC_REPEAT_CIRCULAR: + if (cc_data->active_service EQ cc_data->neg_serv1) + { + if (cc_bcs_compatible (&modify->bearer_cap, + &cc_data->neg_bc2, TRUE) EQ TRUE) + { + CCD_END; + cc_mod_complete (); + } + else + { + CCD_END; + cc_mod_reject (); + } + } + else + { + if (cc_bcs_compatible (&modify->bearer_cap, + &cc_data->neg_bc1, TRUE) EQ TRUE) + { + CCD_END; + cc_mod_complete (); + } + else + { + CCD_END; + cc_mod_reject (); + } + } + break; +#ifndef REL99 + case M_CC_REPEAT_SEQUENTIAL: + if (cc_data->active_service EQ cc_data->neg_serv1) + { + if (cc_bcs_compatible (&modify->bearer_cap, + &cc_data->neg_bc2, TRUE) EQ TRUE) + { + CCD_END; + cc_mod_complete (); + } + else + { + CCD_END; + cc_mod_reject (); + } + } + else + { + CCD_END; + cc_mod_reject (); + } + break; +#endif /* #ifndef REL99 */ + default: + CCD_END; + cc_mod_reject (); + break; + } + } + break; + + default: + CCD_END; +/* Implements Measure# 5 and streamline encoding*/ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mod_reject | ++--------------------------------------------------------------------+ + + PURPOSE : Negative end of a mobile terminated in-call modification. + +*/ + +GLOBAL void cc_mod_reject (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_mod_reject()"); + + CCD_START; + { + MCAST (modify_rej, B_MODIFY_REJ); + + + cc_build_modify_reject (modify_rej, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_BEARER_CAP_AUTHORIZ)); + for_modify_reject (modify_rej); + } + + EM_CC_MT_IN_CALL_MODIFICATION_FAILED; + + CCD_END; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mod_complete | ++--------------------------------------------------------------------+ + + PURPOSE : Positive end of a mobile terminated in-call modification. + +*/ + +GLOBAL void cc_mod_complete (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_mod_complete()"); + + CCD_START; + { + MCAST (modify_com, B_MODIFY_COMP); + PALLOC (mod_ind, MNCC_MODIFY_IND); + + + if (cc_data->active_service EQ cc_data->neg_serv1) + cc_data->active_service = cc_data->neg_serv2; + else + cc_data->active_service = cc_data->neg_serv1; + + mod_ind->ti = cc_data->ti; + mod_ind->serv = cc_data->active_service; + PSENDX (MMI, mod_ind); + + EM_CC_MT_IN_CALL_MODIFICATION_PASSED; + + cc_build_modify_complete (modify_com); + for_modify_complete (modify_com); + } + CCD_END; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_modify_complete | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming modify complete message. + +*/ + +GLOBAL void cc_modify_complete ( T_B_MODIFY_COMP * mod_com) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_modify_complete()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_26: + if (cc_check_error_flag ()) + { + if (cc_data->new_itc EQ mod_com->bearer_cap.trans_cap) + { + PALLOC (mod_cnf, MNCC_MODIFY_CNF); + + TIMERSTOP (TIMER_CC); + if (cc_data->active_service EQ cc_data->serv1) + cc_data->active_service = cc_data->serv2; + else + cc_data->active_service = cc_data->serv1; + mod_cnf->ti = cc_data->ti; + mod_cnf->cause = MNCC_CAUSE_MODIFY_SUCCESS; + /* Setting raw_cause to empty as we are not sending any cause from network*/ + mod_cnf->c_raw_cause = 0; + + EM_CC_MO_IN_CALL_MODIFICATION_PASSED; + + PSENDX (MMI, mod_cnf); + cc_set_state (M_CC_CS_10); + } + CCD_END; + } + break; + + default: + CCD_END; +/* Implements Measure# 6 and streamline encoding*/ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_modify_reject | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming modify reject message. + +*/ + +GLOBAL void cc_modify_reject (T_B_MODIFY_REJ * mod_rej) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_modify_reject()"); + + switch (cc_data->state[cc_data->index_ti]) + { + /* + * CS_0 is handled by the formatter + */ + case M_CC_CS_26: + if (cc_check_error_flag ()) + { + if (cc_data->old_itc EQ mod_rej->bearer_cap.trans_cap) + { + PALLOC (mod_cnf, MNCC_MODIFY_CNF); + + TIMERSTOP (TIMER_CC); + mod_cnf->ti = cc_data->ti; + /* + * cause IE is mandatory and the check for presence has been done + * already thus there is no need to check for validity of cause IE + * here anymore + */ + mod_cnf->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + mod_rej->cc_cause.cause); + mod_cnf->c_raw_cause = cc_build_cause (&mod_rej->cc_cause, + mod_cnf->raw_cause); + PSENDX (MMI, mod_cnf); + cc_set_state (M_CC_CS_10); + } + + EM_CC_MO_IN_CALL_MODIFICATION_FAILED; + + CCD_END; + } + break; + + default: + CCD_END; +/* Implements Measure# 7 and streamline encoding*/ + cc_send_status (M_CC_CAUSE_MESSAGE_TYPE_INCOMPAT); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_status | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming status message. + +*/ + +GLOBAL void cc_status (T_B_STATUS * status) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cc_status()"); + + /* The cause is in STATUS a mandatory IE (given intact message) */ + TRACE_EVENT_P1 ("STATUS cause: %02x", status->cc_cause.cause); + + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_0: + CCD_END; + if (status->call_state.state NEQ M_CC_CS_0) + { + CCD_START; + { + MCAST (rel_com, U_RELEASE_COMP); + + cc_build_release_complete (rel_com, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT)); + for_release_complete (rel_com); + } + CCD_END; + } + for_rel_req (); + break; + + case M_CC_CS_1: + case M_CC_CS_3: + case M_CC_CS_4: + case M_CC_CS_6: + case M_CC_CS_7: + case M_CC_CS_8: + case M_CC_CS_9: + case M_CC_CS_10: + case M_CC_CS_26: + if (cc_check_error_flag ()) + { + /* check for incompatible state */ + if (status->call_state.state NEQ cc_data->state[cc_data->index_ti]) + { + PALLOC (rel_ind, MNCC_RELEASE_IND); + + cc_reset_dtmf (); // China change HM 11.07.00 + + TIMERSTOP (TIMER_CC); + + rel_ind->ti = cc_data->ti; + + rel_ind->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT); + rel_ind->c_raw_cause = 0; + PSENDX (MMI, rel_ind); + + CCD_END; + CCD_START; + { + MCAST (rel_com, U_RELEASE_COMP); + + cc_build_release_complete (rel_com, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT)); + for_release_complete (rel_com); + } + CCD_END; + for_rel_req (); + cc_set_state (M_CC_CS_0); + } + else + /* + * compatible, perform checks/ actions of 04.08, ch. 5.5.3.2.2; + * Condat action (option!) is to initiate normal call clearing + * (with DISCONNECT) + */ + { + if ((status->cc_cause.cause >= M_CC_CAUSE_INCORRECT_MESSAGE) + AND + (status->cc_cause.cause <= M_CC_CAUSE_COND_INFO_ELEM)) + { + /* + * Block entered for + * CAUSE_INCORRECT_MESSAGE, CAUSE_INVALID_MAND_INFO, + * CAUSE_MESSAGE_TYPE_NOT_IMPLEM, CAUSE_MESSAGE_TYPE_INCOMPAT, + * CAUSE_INFO_ELEM_NOT_IMPLEM, CAUSE_COND_INFO_ELEM. (0x5f..0x64) + */ + if ((cc_data->state[cc_data->index_ti] EQ M_CC_CS_10) AND + (cc_data->hold_state[cc_data->index_ti] EQ M_CC_HLD_HOLD_REQ)) + { + /* + * Compatible state, last CC message was a hold request which is + * not supported by the network. Handled like HOLD REJECT. + */ + PALLOC (hold_cnf, MNCC_HOLD_CNF); /* T_MNCC_HOLD_CNF */ + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_IDLE; + hold_cnf->ti = cc_data->ti; + hold_cnf->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + status->cc_cause.cause); + PSENDX (MMI, hold_cnf); + CCD_END; + srv_use_stored_prim (); + } + else if (status->cc_cause.cause NEQ M_CC_CAUSE_INFO_ELEM_NOT_IMPLEM) + { + /* + * Compatible state, special condition for HOLD REQUEST not met. + * The network is also not complaining about an optional + * information element which can be simply ignored. + * Disconnect the call. + */ + PALLOC (disc_ind, MNCC_DISCONNECT_IND); + + TIMERSTOP (TIMER_CC); + + disc_ind->ti = cc_data->ti; + disc_ind->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + status->cc_cause.cause); + disc_ind->c_raw_cause = cc_build_cause (&status->cc_cause, + disc_ind->raw_cause); + disc_ind->diagnostic = NOT_PRESENT_8BIT; + disc_ind->progress_desc = MNCC_PROG_NOT_PRES; + PSENDX (MMI, disc_ind); + + CCD_END; + CCD_START; + { + MCAST (disconnect, U_DISCONNECT); + + cc_build_disconnect (disconnect, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_CALL_CLEAR), + NULL, MNCC_SS_VER_NOT_PRES); + for_disconnect (disconnect); + } + TIMERSTART (T305, T305_VALUE); + cc_set_state (M_CC_CS_11); + } + } + else + { + /* + * STATUS message but neither incompatible state nor indicating + * incorrect message / IE; check if we received a STATUS with cause + * "message not compatible with protocol state". GSM 04.08 does not + * define what to do and also does not define that this case has to + * be handled at all; + * Condat (HM) decided to "clear DTMF" if it was running to try to + * recover from the misaligned states scenario. + */ + T_DTMF *p_dtmf; + + p_dtmf = &cc_data->dtmf[cc_data->index_ti]; + if ((p_dtmf->state EQ DTMF_SEND_REQUEST) AND + (status->cc_cause.cause EQ M_CC_CAUSE_MESSAGE_INCOMPAT)) + { + /* Send negative acknowledge for DTMF send request to MMI */ + PALLOC (mncc_start_dtmf_cnf, MNCC_START_DTMF_CNF); + mncc_start_dtmf_cnf->ti = cc_data->ti; + mncc_start_dtmf_cnf->key = NOT_PRESENT_8BIT; + mncc_start_dtmf_cnf->dtmf_mod = NOT_PRESENT_8BIT; + mncc_start_dtmf_cnf->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_NET, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT); + PSENDX (MMI, mncc_start_dtmf_cnf); + } + + /* Bring screwed up network back to work */ + for_stop_dtmf (); + + /* Reset screwed up DTMF state machine */ + p_dtmf->state = DTMF_IDLE; + p_dtmf->read = 0; + p_dtmf->write = 0; + } + CCD_END; + } + } + break; + + case M_CC_CS_11: + case M_CC_CS_12: + if (cc_check_error_flag ()) + { + if (status->call_state.state NEQ cc_data->state[cc_data->index_ti]) + { + /* + * STATUS message with incompatible state + * On receipt of a STATUS message reporting an incompatible call + * control state, the receiving entity shall clear the call by + * sending a RELEASE COMPLETE message with cause # 101 "message + * not compatible with protocol state". The reported call control + * state is incompatible if the combination of call control states + * at the sender and receiver side cannot occur, do not match or cannot + * be aligned by actions of the receiver; the exact definition is + * implementation dependent. [04.08 clause 5.5.3.2.1] + */ + cc_reset_dtmf (); + + TIMERSTOP (TIMER_CC); + + /* Send MNCC_RELEASE_IND to MMI */ + { + PALLOC (rel_ind, MNCC_RELEASE_IND); /* T_MNCC_RELEASE_IND */ + rel_ind->ti = cc_data->ti; + rel_ind->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT); + rel_ind->c_raw_cause = 0; + PSENDX (MMI, rel_ind); + } + + CCD_END; + CCD_START; + { + MCAST (rel_com, U_RELEASE_COMP); /* T_U_RELEASE_COMP */ + cc_build_release_complete (rel_com, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT)); + for_release_complete (rel_com); + for_rel_req (); + cc_set_state (M_CC_CS_0); + } + } + CCD_END; + } + break; + + case M_CC_CS_19: + if (cc_check_error_flag ()) + { + if (status->call_state.state NEQ cc_data->state[cc_data->index_ti]) + { + TIMERSTOP (TIMER_CC); + + cc_reset_dtmf (); + + { + PALLOC (rel_cnf, MNCC_RELEASE_CNF); /* T_MNCC_RELEASE_CNF */ + rel_cnf->ti = cc_data->ti; + rel_cnf->cause = CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT); + /* Setting raw_cause to empty as this is a local release + * of MM connection,CC is not receiving any cause value + * from Network + */ + rel_cnf->c_raw_cause = 0; + PSENDX (MMI, rel_cnf); + } + + CCD_END; + CCD_START; + { + MCAST (rel_com, U_RELEASE_COMP); /* T_U_RELEASE_COMP */ + cc_build_release_complete (rel_com, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_INCOMPAT)); + for_release_complete (rel_com); + for_rel_req (); + cc_set_state (M_CC_CS_0); + } + } + CCD_END; + } + break; + + default: + CCD_END; + break; + } + + EM_CC_STATUS_RECEIVED; + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_status_enquiry | ++--------------------------------------------------------------------+ + + PURPOSE : Processing an incoming status enquiry message. + +*/ + +GLOBAL void cc_status_enquiry (void) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION ("cc_status_enquiry()"); + + /* + * CS_0 is handled by the formatter + */ + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_10: + /* + * Ensure synchronization of auxiliary states with ACI. + */ + if (cc_check_error_flag ()) + { + CCD_END; + { + PALLOC (mncc_status_ind, MNCC_STATUS_IND); + mncc_status_ind->ti = cc_data->ti; + PSENDX (MMI, mncc_status_ind); + } + + EM_CC_STATUS_ENQUIRY_RECEIVED; + + } + break; + + default: + /* + * No auxiliary states in non-active states. Immediate response is safe. + */ + if (cc_check_error_flag ()) + { + CCD_END; + /* EM call moved above cc_send_status should not have any impact */ + EM_CC_STATUS_ENQUIRY_RECEIVED; + +/* Implements Measure# 7 and streamline encoding*/ + cc_send_status (M_CC_CAUSE_STATUS_ENQUIRY); + } + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_unknown_message | ++--------------------------------------------------------------------+ + + PURPOSE : Processing of an incoming unknown message. + +*/ + +GLOBAL void cc_unknown_message (void) +{ + + CCD_END; + CCD_START; + { + MCAST (status, B_STATUS); + + TRACE_FUNCTION ("cc_unknown_message()"); + + cc_build_status (status, + CAUSE_MAKE(DEFBY_STD, + ORIGSIDE_MS, + MNCC_CC_ORIGINATING_ENTITY, + M_CC_CAUSE_MESSAGE_TYPE_NOT_IMPLEM)); + for_status (status); + } + CCD_END; +} + +/* Implements Measure# 18 */ +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CC_ACT | +| STATE : code ROUTINE : cc_mncc_hold_retrieve_req | ++--------------------------------------------------------------------+ + + PURPOSE : Send hold REQ/retrieve REQ. + +*/ + +LOCAL void cc_mncc_hold_retrieve_req (T_PRIM * prim) +{ + GET_INSTANCE_DATA; + UBYTE ti; + + TRACE_FUNCTION ("cc_mncc_hold_retrieve_req()"); + + if(prim->custom.opc EQ MNCC_HOLD_REQ) + { + ti = ((T_MNCC_HOLD_REQ *)P2D(prim))->ti; + } + else + { + ti = ((T_MNCC_RETRIEVE_REQ *)P2D(prim))->ti; + } + if ((cc_data->index_ti = srv_convert_ti (ti)) EQ NOT_PRESENT_8BIT) + { + PFREE (P2D(prim)); + return; + } + + switch (cc_data->state[cc_data->index_ti]) + { + case M_CC_CS_10: + if(prim->custom.opc EQ MNCC_HOLD_REQ) + { + /* We should think about storing the hold request + until DTMF idle state reached. ... + This causes some other changes, we have to add some + calls to serv_use_stored_prim() at some places after + state transition of the DTMF state machine to DTMF idle.*/ + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_HOLD_REQ; + for_hold (); + EM_CC_CALL_HOLD; + } + else + { + cc_data->hold_state[cc_data->index_ti] = M_CC_HLD_RETRIEVE_REQ; + for_retrieve (); + EM_CC_CALL_RETRIEVE; + } + PFREE (P2D(prim)); + + break; + + case CS_101: + case M_CC_CS_26: + case CS_261: + srv_store_prim (prim); + break; + + default: + PFREE (P2D(prim)); + break; + } +} + +#endif