/*
+-----------------------------------------------------------------------------
|  Project :  GSM-PS
|  Modul   :  DL_STATE
+-----------------------------------------------------------------------------
|  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 state machine of the component DL
|             (replaces the old channel dependent implementation)
+-----------------------------------------------------------------------------
*/

#ifndef DL_STATE_C
#define DL_STATE_C

#define ENTITY_DL
#define NEW_REJ_ACK /* Acknowledgement by valid reject frame
                   * in accordance with 3GPP 04.06, 5.5.3.1
                   * "On receipt of a valid I frame or supervisory frame"
                   */

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

#include "typedefs.h"
#include <string.h>
#include "vsi.h"
#include "pconst.cdg"
#include "custom.h"
#include "gsm.h"
#include "mon_dl.h"
#include "prim.h"
#include "pei.h"
#include "tok.h"
#include "ccdapi.h"
#include "dl.h"
#include "dl_em.h"
#include "DL_trc.h"

/*==== TYPEDEFS ===================================================*/
typedef struct
{
  UBYTE channel;
  UBYTE sapi;
  UBYTE state;
  UBYTE T200_Stop;
  UBYTE T200_Start;
  UBYTE pf_bit_flag;
  UBYTE dl_data_ind;
  UBYTE mdl_error_ind;
  T_CCH*  pcch;
} T_CCH_INTERN;
#define T_CCH_INTERN_INIT {0,0,0,0,0,0,0}

/*==== EXPORT =====================================================*/
/*==== PRIVAT =====================================================*/
static  int frame_validation (UBYTE channel_type, UBYTE* frame);

static  int downlink_idle (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  int downlink_contention_resolution (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  int downlink_mfe (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  int downlink_timer_recovery (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  int downlink_awaiting_release (T_CCH_INTERN* pcch_i, UBYTE *frame);

static  void downlink_mfe_information (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void downlink_mfe_supervisory (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void downlink_mfe_sabm (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void downlink_mfe_dm (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void downlink_mfe_tr_unnumbered (T_CCH_INTERN* pcch_i, UBYTE *frame, UBYTE state);
static  void downlink_i_frame (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void downlink_tr_supervisory (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void downlink_tr_information (T_CCH_INTERN* pcch_i, UBYTE *frame);

static  void invoke_retransmission (T_CCH_INTERN* pcch_i, UBYTE frame_nr);
static  void enquiry_response (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void mdl_error_ind (UBYTE cause, UBYTE channel_type, UBYTE sapi);
static  void nr_error_recovery (T_CCH_INTERN* pcch_i, UBYTE *frame);
static  void concatenate (UBYTE ch_type, UBYTE sapi, UBYTE *frame);
static  void free_sending_buffer (UBYTE ch_type, UBYTE sapi);

static  void repeat_sabm (UBYTE channel, UBYTE sapi);
static  void delayed_release_ind(UBYTE channel);

static  int uplink_idle (UBYTE channel, UBYTE sapi);
static  int uplink_awaiting_establishment (UBYTE channel, UBYTE sapi, UBYTE no_signalling_mode);
static  int uplink_mfe (UBYTE channel, UBYTE sapi, UBYTE no_signalling_mode);
static  int uplink_timer_recovery (UBYTE channel, UBYTE sapi, UBYTE no_signalling_mode);

static  void T200_expiry (UBYTE channel, UBYTE sapi);

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

/*Removed the const from the definition,rework for issue 25370*/
static  UBYTE l2_empty_frame [25] = {
        0x00, 0x00, /* the first two dummy bytes only for SACCH L1 header! */
        /* here begins the normal empty frame (SDCCH, FACCH) */
        0x01, /* address field: SAPI 0 */
        0x03, /* control field: UI frame */
        0x01, /* length field: length = 0 */
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b };
#if 0
static  UBYTE l2_invalid_frame [25] = {
        0x00, 0x00, /* the first two dummy bytes only for SACCH L1 header! */
        /* here begins the normal empty frame (SDCCH, FACCH) */
        0x1D, /* address field: SAPI 7 (unallocated SAPI; no action shall be taken on such frames) */
        0x03, /* control field: UI frame */
        0x01, /* length field: length = 0 */
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
        0x2b, 0x2b, 0x2b, 0x2b, 0x2b };
static  UBYTE l2_invalid_frame_0 [25] = {
        0x00, 0x00, /* the first two dummy bytes only for SACCH L1 header! */
        /* here begins the normal empty frame (SDCCH, FACCH) */
        0x00, /* address field: SAPI 0 */
        0x00, /* control field: UI frame */
        0x00, /* length field: length = 0 */
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00 };
#endif /* 0|1 */
static  T_CCH_INTERN  cch_i;

#if defined(CHECK_PCCHI)
#define CHECK_PCCH_I()  if (check_pcch_i(pcch_i, __LINE__)()return;
#define CHECK_PCCH_Ir() if (check_pcch_i(pcch_i, __LINE__)()return -1;
#else
#define CHECK_PCCH_I()
#define CHECK_PCCH_Ir()
#endif  /* CHECK_PCCHI */

/*==== FUNCTIONS ==================================================*/
int dl_downlink (UBYTE error_flag, UBYTE channel_type, UBYTE* frame, ULONG fn)
{
  UBYTE     channel_state = STATE_INVALID;
  UBYTE     channel = NOT_PRESENT_8BIT;
  UBYTE     frame_sapi = PS_SAPI_0; /* to calm lint, will be new set for valid frames */
  static UBYTE  invalid = 0;
  int       ret = -2;
  int       cause;
  int       l2_offset;

   GET_INSTANCE_DATA;

  TRACE_EVENT_WIN_P1 ("downlink(): dcch0_ch_type:%s",
    CH_TYPE_NAME[dl_data->dcch0_ch_type]);
  TRACE_EVENT_WIN_P6 ("DL: DCCH0=%s,%s vr=%u vs=%u va=%u T200=%u",
    CH_TYPE_NAME[dl_data->cch[C_DCCH0].ch_type],
    STATE_DCCH0_NAME[dl_data->state[C_DCCH0]],
    dl_data->cch[C_DCCH0].vr, dl_data->cch[C_DCCH0].vs, dl_data->cch[C_DCCH0].va,
    dl_data->cch[C_DCCH0].T200_counter);
  TRACE_EVENT_WIN_P6 ("DL: DCCH3=%s,%s vr=%u vs=%u va=%u T200=%u",
    CH_TYPE_NAME[dl_data->cch[C_DCCH3].ch_type],
    STATE_DCCH3_NAME[dl_data->state[C_DCCH3]],
    dl_data->cch[C_DCCH3].vr, dl_data->cch[C_DCCH3].vs, dl_data->cch[C_DCCH3].va,
    dl_data->cch[C_DCCH3].T200_counter);

  if (channel_type EQ L2_CHANNEL_SACCH)
  {
    l2_offset = 2; /* with layer 1 header */
  }
  else
  {
    l2_offset = 0; /* without layer 1 header */
  }

#define RR_SHORT_PD_HANDLING
#if defined(RR_SHORT_PD_HANDLING)
  /* Handling of unacknowledged UI frames with format type Bter */
#if defined(RR_SHORT_PD_DETECT_KNOWN_MSG_ONLY) /* detection of known messages only */
  cause = 0;
  switch (frame[l2_offset])
  {
    case RR_SHORT_PD_SI10:
    case RR_SHORT_PD_MEAS_INFO:
      if (channel_type EQ L2_CHANNEL_SACCH)
        cause = 1;
      break;
    case RR_SHORT_PD_NOTI_FACCH:
      if ((channel_type EQ L2_CHANNEL_FACCH_F) OR
          (channel_type EQ L2_CHANNEL_FACCH_H))
          cause = 1;
      break;
    case RR_SHORT_PD_UPLINK_FREE:
      cause = 1;
      break;
    default:
      break;
  }
  if (cause)
  {
    drr_dl_short_unitdata_ind (channel_type, error_flag, frame,
      &frame[l2_offset],
      (channel_type EQ L2_CHANNEL_SACCH) ? DL_N201_SACCH_Bter : DL_N201_DCCH_Bter, fn);
    return 0;
  }
#else /* detection of all possible messages with short L2 header and format Bter */
  TRACE_EVENT_WIN_P4 ("detection of format Bter: %02x&%02x=%02x ?= %02x",
    frame[l2_offset], BTER_FORMAT_MASK, GET_BTER_FORMAT (&frame[l2_offset]), SHORT_L2_HEADER_TYPE_1);
  if ((GET_BTER_FORMAT (&frame[l2_offset]) EQ SHORT_L2_HEADER_TYPE_1))
  {
    drr_dl_short_unitdata_ind (channel_type, error_flag, frame,
      &frame[l2_offset],
      (UBYTE)((channel_type EQ L2_CHANNEL_SACCH) ? DL_N201_SACCH_Bter : DL_N201_DCCH_Bter), fn);
    return 0;
  }
#endif /* kind of Bter detection */
#endif /* RR_SHORT_PD_HANDLING */

  /* check frame */

  if (error_flag EQ VALID_BLOCK)
  {
    frame_sapi = GET_SAPI (frame+l2_offset);
    if ((frame_sapi NEQ PS_SAPI_0) AND (frame_sapi NEQ PS_SAPI_3))
    {
      TRACE_EVENT_WIN_P1 ("downlink() returns -1 (wrong SAPI=%u)", frame_sapi);
      return -1;
    }

    cause = frame_validation (channel_type, frame+l2_offset);
    if (cause >= 0)
    {
      TRACE_FUNCTION ("frame validation failed!");
      if (invalid EQ 0)
      {
        TRACE_ERROR ("invalid frame");
        invalid = 1; /* only one message per succession */
      }
      mdl_error_ind ((UBYTE)cause, channel_type, frame_sapi);
      return 0;/* ETSI GSM 04.06 Annex G.2 - G.4 */
    }
    else
      invalid = 0;

#if defined(DL_2TO1) || defined(_SIMULATION_)
    /* Handling of unacknowledged UI frames on SACCH with SAPI=0 (not format type Bter) */
    if ((channel_type EQ L2_CHANNEL_SACCH) AND
        (frame_sapi EQ PS_SAPI_0) AND
        (GET_FORMAT_TYPE(frame+l2_offset) EQ U_FORMAT) AND
        (GET_U_TYPE(frame+l2_offset) EQ UI_FRAME) )
    {
      drr_dl_unitdata_ind (error_flag, frame, frame+l2_offset+3,
                           (UBYTE)(GET_LENGTH_INDICATOR (frame+l2_offset)), fn);
      return 0;
    }
#endif /* DL_2TO1 || _SIMULATION_ */
  }
#if defined(DL_2TO1)
  else if (channel_type EQ L2_CHANNEL_SACCH)
  { /*
     * Indicate invalid SACCH frame for decrement of radio link timeout counter.
     * The invalid frame possible contains invalid headers, use length 0.
     */
    drr_dl_unitdata_ind (error_flag, frame, frame+l2_offset+3, 0, fn);
  }
#endif /* DL_2TO1 */

  if (error_flag NEQ VALID_BLOCK)
  {
    TRACE_EVENT_WIN ("invalid frame->stop download handling");
    return 0; /* no further handling */
  }

  memset (&cch_i, 0, sizeof (T_CCH_INTERN));
  switch (channel_type)
  {
  case L2_CHANNEL_SDCCH:
    if (frame_sapi EQ PS_SAPI_3)
    {
      channel = C_DCCH3;
      break;
    }
    /*lint -fallthrough*/
  case L2_CHANNEL_FACCH_F:
  case L2_CHANNEL_FACCH_H:
    if (frame_sapi EQ PS_SAPI_0)
      channel = C_DCCH0;
    break;
  case L2_CHANNEL_SACCH:
    if (frame_sapi EQ PS_SAPI_3)
    { /* SACCH with SAPI=3 only supported with associated TCH (FACCH) */
      if ((dl_data->cch[C_DCCH0].ch_type EQ L2_CHANNEL_FACCH_H) OR
          (dl_data->cch[C_DCCH0].ch_type EQ L2_CHANNEL_FACCH_F))
        channel = C_DCCH3;
    }
    else
    {
      TRACE_EVENT_WIN ("No handling of SACCH with SAPI=0 here!");
      /*
       * The SACCH with SAPI=0 is handled some lines before for DL_2TO1 and
       * simulation. Handling of frames other than UI frames is not supported.
       */
    }
    break;
  default:
    break;
  }/* endswitch channel_type */

  if (channel EQ NOT_PRESENT_8BIT)
  {
    TRACE_EVENT_WIN ("downlink() returns -3");
    return -3;
  }
  else
  {

#if defined(DELAYED_SABM)
    /* ignore downlinked frames before delayed SABM was sent */
    if ((channel EQ C_DCCH0) AND
        (dl_data->dcch0_sabm_flag NEQ NOT_PRESENT_8BIT))
    {
      DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, channel_type, "DL:pend.SABM->ignore");
      return 0;
    }
#endif  /* DELAYED_SABM */

    cch_i.channel = channel;
    cch_i.sapi = frame_sapi;
#if defined(_SIMULATION_)
    if (channel_type EQ L2_CHANNEL_SACCH)
    {
      TRACE_EVENT_WIN_P1 ("SACCH: set SAPI=%u set during downlink", frame_sapi);
    }
#endif /* _SIMULATION_ */

    cch_i.state = channel_state = dl_data->state[channel];
    cch_i.pcch = &dl_data->cch[channel];
    /*
     * The channel type pcch->ch_type is overwritten as input to the downlink
     * sub functions. In case of DCCH0 this is temporary only and the channel
     * type have to be re-assigned with the value of dl_data->dcch0_ch_type.
     */
    cch_i.pcch->ch_type = channel_type;
    if (cch_i.pcch->vtx NEQ EMPTY_CMD)
    { /* save bit for the case of unsolicited frames */
      cch_i.pf_bit_flag = cch_i.pcch->f_bit;
    }
    TRACE_EVENT_WIN_P4 ("downlink()  in:%s SAPI=%u st=%u vtx=%s",
      CH_TYPE_NAME[channel_type], frame_sapi, channel_state,
      VTX_NAME[cch_i.pcch->vtx]);
    TRACE_EVENT_WIN_P9 ("vr=%u vs=%u va=%u rc=%u contres=%u reje=%u ackp=%u %c=%u",
      cch_i.pcch->vr, cch_i.pcch->vs, cch_i.pcch->va, cch_i.pcch->rc,
      cch_i.pcch->contention_resolution, cch_i.pcch->reject_exception,
      cch_i.pcch->acknowledge_pending,
      cch_i.pcch->time_flag ? 'T' : 't', cch_i.pcch->T200_counter);
  }

  switch (channel_state)
  {
    case STATE_DISABLED:
    case STATE_IDLE_DL:
    ret = downlink_idle (&cch_i, frame+l2_offset);
    break;
  case STATE_CONTENTION_RESOLUTION:
    ret = downlink_contention_resolution (&cch_i, frame+l2_offset);
    break;
  case STATE_MULTIPLE_FRAME_ESTABLISHED:
    ret = downlink_mfe (&cch_i, frame+l2_offset);
    break;
    case STATE_TIMER_RECOVERY:
    ret = downlink_timer_recovery (&cch_i, frame+l2_offset);
    break;
  case STATE_AWAITING_RELEASE:
    ret = downlink_awaiting_release (&cch_i, frame+l2_offset);
    break;
  }/* endswitch channel_state */
  if (channel EQ C_DCCH0)
  { /*
     * Reconstruct the temporary overwritten pcch->ch_type with the value
     * of dl_data->dcch0_ch_type.
     */
    cch_i.pcch->ch_type = dl_data->dcch0_ch_type;
  }


  TRACE_EVENT_WIN_P5 ("%s SAPI=%u vtx=%s (%s#%u)", CH_TYPE_NAME[cch_i.pcch->ch_type], cch_i.sapi,
                                            VTX_NAME[cch_i.pcch->vtx],
                                            __FILE10__, __LINE__);
  if (ret NEQ 0)
  {
    TRACE_EVENT_WIN_P1 ("downlink() returns %d", ret);
    return ret;
  }

  /* transfer states and flags to dl_data */
  dl_data->cch[channel].f_bit_flag = dl_data->cch[channel].f_bit = cch_i.pf_bit_flag;
  if (cch_i.T200_Start)
  {
    dl_data->cch[channel].T200_counter = T200_STOPPED;
    dl_data->cch[channel].time_flag = TRUE;
  }
  else if (cch_i.T200_Stop)
  {
    dl_data->cch[channel].T200_counter = T200_STOPPED;
    dl_data->cch[channel].time_flag = FALSE;
  }

  if (cch_i.dl_data_ind)
  {
    com_data_ind(channel_type, frame_sapi, fn);
  }

  if (channel_state NEQ cch_i.state)
  {
    set_channel_state (
      (UBYTE)((frame_sapi EQ PS_SAPI_0) ? C_DCCH0 : C_DCCH3), cch_i.state);
  }

  if (cch_i.mdl_error_ind)
  {
    mdl_error_ind ( cch_i.mdl_error_ind, channel_type, frame_sapi);
  }



  TRACE_EVENT_WIN_P4 ("downlink() out:%s SAPI=%u st=%u vtx=%s",
    CH_TYPE_NAME[channel_type], cch_i.sapi, cch_i.state,
    VTX_NAME[cch_i.pcch->vtx]);
  TRACE_EVENT_WIN_P9 ("vr=%u vs=%u va=%u rc=%u contres=%u reje=%u ackp=%u %c=%u",
    cch_i.pcch->vr, cch_i.pcch->vs, cch_i.pcch->va, cch_i.pcch->rc,
    cch_i.pcch->contention_resolution, cch_i.pcch->reject_exception,
    cch_i.pcch->acknowledge_pending,
    cch_i.pcch->time_flag ? 'T' : 't', cch_i.pcch->T200_counter);
  TRACE_EVENT_WIN_P4 ("T200=%s  %s  %s  %s",
    cch_i.T200_Start ? "Start" : cch_i.T200_Stop ? "Stop" : "...",
    cch_i.pf_bit_flag ? "P/F" : "",
    cch_i.dl_data_ind ? "DATA_IND" : "", cch_i.mdl_error_ind ? "ERROR_IND" : "");
  TRACE_EVENT_WIN_P1 ("downlink() returns %d", ret);

  return ret;
}/* endfunc downlink */

LOCAL int frame_validation (UBYTE channel_type, UBYTE* frame)
{
  UBYTE frame_length;
  BOOL  frame_m_bit;
  UBYTE N201;

  if (!GET_EA (frame))
    return FRAME_NOT_IMPLEMENTED; /* ETSI GSM 04.06 Annex G.2.3 */

  if (!GET_EL (frame))
    return FRAME_NOT_IMPLEMENTED; /* ETSI GSM 04.06 Annex G.4.1 */

  frame_length = GET_LENGTH_INDICATOR (frame);
  frame_m_bit = GET_M_BIT (frame);

  /* get the maximal number of octets */
  switch (channel_type)
  {
  case L2_CHANNEL_SDCCH:
    N201 = N201_SDCCH;
    break;
  case L2_CHANNEL_SACCH:
    N201 = N201_SACCH;
    break;
  default:/* CH_TYPE_FACCH_FR, L2_CHANNEL_FACCH_H */
    N201 = N201_FACCH;
    break;
  }

  switch (GET_FORMAT_TYPE (frame))
  {
  case I_FORMAT: /* I format */
  case I1_FORMAT:
    if ((frame_length > N201) OR (frame_length EQ 0))
      return I_FRAME_WITH_INCORRECT_LENGTH; /* ETSI GSM 04.06 Annex G.4.2 */
    if ((frame_length < N201) AND (frame_m_bit EQ 1))
      return I_FRAME_WITH_INCORRECT_USE_OF_M_BIT; /* ETSI GSM 04.06 Annex G.4.2 */
    break;
  case S_FORMAT: /* S format */
    if (frame_length OR frame_m_bit)
      return S_FRAME_WITH_INCORRECT_PARAMETERS; /* ETSI GSM 04.06 Annex G.4.3 */
    if ((frame[1] & 0x0f) EQ 0x0d)
      return FRAME_NOT_IMPLEMENTED; /* ETSI GSM 04.06 Annex G.3.1 */
    break;
  case U_FORMAT: /* U format */
    switch (GET_U_TYPE (frame))
    {
    case DM_FRAME:
    case DISC_FRAME:
      if (frame_length OR frame_m_bit)
        return U_FRAME_WITH_INCORRECT_PARAMETERS; /* ETSI GSM 04.06 Annex G.4.4 */
      break;
    case UA_FRAME:
    case SABM_FRAME:
    case UI_FRAME:
      if ((frame_length > N201) OR (frame_m_bit))
        return U_FRAME_WITH_INCORRECT_PARAMETERS; /* ETSI GSM 04.06 Annex G.4.5 */
      break;
    default:
      return FRAME_NOT_IMPLEMENTED; /* ETSI GSM 04.06 Annex G.3.2 */
      /*break;*/
    }/* endswitch U frame_type */
    break;
  }/* endswitch frame_format */

  /*
   * ETSI GSM 04.06 Annex G.2.1, G.2.2 will be check in the following functions
   */

  return -1; /* frame is valid */
}/* endfunc frame_validation */

static  int downlink_idle( T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  /*
   * According to 3GPP TS 04.05, 5.4.5 Idle state:
   * While in the idle state:
   * - the receipt of a DISC command shall result in the transmission of a
   *   DM response with the F bit set to the value of the received P bit;
   * - the receipt of an I frame or supervisory frame with the P bit set to "1"
   *   shall result in the transmission of a DM response with the F bit set to
   *   "1" (as defined in subclause 5.2.2);
   * - the content of any received I frame shall be discarded;
   * - on receipt of an SABM command, the procedures defined in subclause 5.4.1
   *   shall be followed;
   * - on receipt of UI commands, the procedures defined in subclause 5.3 shall
   *   be followed;
   * - all other frame types shall be discarded.
  */
  T_CCH*  pcch;

  CHECK_PCCH_Ir();
  pcch = pcch_i->pcch;

  TRACE_FUNCTION ("downlink_idle()");

  switch (GET_FORMAT_TYPE (frame))
  {
  case S_FORMAT: /* S frame */
    if (GET_S_TYPE (frame) NEQ RR_CMD)
      break;
    /*lint -fallthrough*/
  case I_FORMAT: /* I frame */
  case I1_FORMAT:
    if (GET_P_BIT (frame))
    {
      pcch->vtx = DM_CMD;
      pcch_i->pf_bit_flag = TRUE;
    }
    break;
  case U_FORMAT: /* U frame */
    if (GET_CR (frame))
    { /* command */
      switch (GET_U_TYPE (frame))
      {
      case SABM_FRAME:
        if (!GET_LENGTH_INDICATOR (frame) AND pcch_i->sapi EQ PS_SAPI_3)
        { /*
           * Mobile Terminated Establishment, but only for SAPI=3!
           *
           * According to 3GPP TS 04.06, 5.4.1 Establishment of multiple frame
           * operation, 5.4.1.1 General, Note:
           * For SAPI 0 the data link is always established by the MS.
           */
          com_restore_queue ( pcch_i->sapi, NULL);
          pcch->vtx = UA_CMD;
          pcch_i->pf_bit_flag = GET_P_BIT (frame);
          pcch->va    = 0;
          pcch->vr    = 0;
          pcch->vs    = 0;
          pcch->rc    = 0;
        }
        break;
      case DISC_FRAME:
        pcch->vtx   = DM_CMD;
        pcch_i->pf_bit_flag = GET_P_BIT (frame);
        break;
      case UI_FRAME:
        /* drr_dl_unitdata_ind() was called in the main downlink function */
        break;
      default:
        break;
      }
    }
    break;
  default:
    break;
  }

  return 0;
}/* endfunc downlink_idle */

static  int downlink_contention_resolution(T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  GET_INSTANCE_DATA;
  UBYTE frame_type;
  UBYTE frame_format;
  UBYTE frame_cr;

  UBYTE establish_cnf = FALSE;
  UBYTE release_ind = FALSE;
  UBYTE release_ind_cs = NOT_PRESENT_8BIT;

  T_CCH*  pcch;

  CHECK_PCCH_Ir();
  pcch = pcch_i->pcch;

  TRACE_FUNCTION ("downlink_contention_resolution()");

  frame_format = GET_FORMAT_TYPE (frame);
  if (frame_format EQ U_FORMAT)
  { /* U frame */
    frame_cr = GET_CR (frame);
    frame_type = GET_U_TYPE (frame);
    if (frame_cr)
    { /* command */
      switch (frame_type)
      {
      case SABM_FRAME:
        if (pcch_i->sapi EQ PS_SAPI_3)
        { /* DCCH3 */
          /*
           * According to 3GPP TS 04.06, 5.4.6.1:
           * SAPI = 3, Collision of unnumbered commands and responses.
           * Collision situations (Identical transmitted and received commands)
           * shall be resolved in the following way:  If the transmitted and
           * received unnumbered commands (SABM or DISC) are the same, the data
           * link layer entities shall send the UA response at the earliest
           * possible opportunity. The indicated state shall be entered after
           * receiving the UA response. The data link layer entities shall each
           * notify its respective layer 3 entity by means of the appropriate
           * confirm primitive, i.e. DL-ESTABLISH-CONFIRM or DL-RELEASE-CONFIRM.
           */
          if (!GET_LENGTH_INDICATOR (frame))
          {
            com_clear_queue (PS_SAPI_3);
            /* establish_cnf = TRUE; cnf will be sent at uplink opportunity */

            pcch_i->pf_bit_flag = GET_P_BIT (frame);
            pcch->vtx = UA_CMD;
            pcch->va    = 0;
            pcch->vr    = 0;
            pcch->vs    = 0;
            pcch->rc    = 0;
            pcch_i->T200_Stop = TRUE;
          }
          else
          {
            /* no contention resolution procedure with SAPI=3! */
          }
        }
        else
        {/* DCCH0 */
          /*
           * According to 3GPP TS 04.06, 5.4.1.1 General:
           * NOTE: SAPI=0 the data link is always established by the MS!
           *
           * According to 3GPP TS 04.06, 5.4.1.4 Contention resolution
           * establishment procedure:
           * All frames other than unnumbered frame formats received for the
           * SAPI in use during the establishment procedures shall be ignored.
           * The reception of unnumbered frames other than UA is treated as
           * specified for the normal establishment case.
           * NOTE 4: In fact, there are no foreseen cases in which the network
           *         will send SABM, DISC or DM, but for sake of completeness
           *         these occurrences are specified and must be treated.
           */
          establish_cnf = TRUE;/* Treated as normal establishment case */
          pcch_i->pf_bit_flag = GET_P_BIT (frame);
          pcch->vtx = UA_CMD;
          pcch->va    = 0;
          pcch->vr    = 0;
          pcch->vs    = 0;
          pcch->rc    = 0;
          pcch_i->T200_Stop = TRUE;
        }
        break;

      case DISC_FRAME:
        {
          release_ind = TRUE;

          pcch_i->pf_bit_flag = GET_P_BIT (frame);
          pcch->vtx   = DM_CMD;
        }
        break;

      default:
        break;
      }/* endswitch command frame_type */
    }
    else
    { /* response */
      switch (frame_type)
      {
      case DM_FRAME:
        /*
         * PATCH LE 14.09.99
         * Ignore DM(F=0) frames
         */
        if (GET_P_BIT (frame))
        {
          release_ind = TRUE;
        }
        break;

      case UA_FRAME:
        if (pcch_i->sapi EQ PS_SAPI_0)
        {
          if (pcch->contention_resolution)
          {
            if (com_compare_L3_msg (dl_data->dcch0_queue.switch_buffer, frame))
            {
              establish_cnf = TRUE;
              COM_FREE_QUEUE_BUFFER(&dl_data->dcch0_queue, INDEX_SWITCH_BUFFER);
            }
            else
            {
              release_ind = TRUE;
              release_ind_cs = CAUSE_DL_INFO_FIELD_MISMATCH;
            }
          }
          else
          {
            if (!GET_LENGTH_INDICATOR (frame))
            {
              establish_cnf = TRUE;
            }
            else
            {
              release_ind = TRUE;
            }
          }
        }/* endif PS_SAPI_0 */
        else if (pcch_i->sapi EQ PS_SAPI_3)
        {
          if (!GET_LENGTH_INDICATOR (frame) OR (pcch->ch_type EQ L2_CHANNEL_SACCH))
          {
            establish_cnf = TRUE;
          }
          else
          {
            release_ind = TRUE;
          }

        }/* endif PS_SAPI_3 */

        if (establish_cnf AND (pcch_i->sapi EQ PS_SAPI_0))
        {
          dcch3_enable(pcch->ch_type);
        }

        break;/* endbreak UA_FRAME */

      default:
        break;
      }/* endswitch response frame_type */
    }/* endifelse command/response */

    if (establish_cnf)
    {
      drr_dl_establish_cnf (pcch->ch_type, pcch_i->sapi);
      pcch->va = 0;
      pcch->vr = 0;
      pcch->vs = 0;
      pcch_i->T200_Stop = TRUE;
      pcch_i->state = STATE_MULTIPLE_FRAME_ESTABLISHED;
    }
    else if (release_ind)
    {
      if (pcch_i->sapi EQ PS_SAPI_0)
      {
        if (pcch->contention_resolution)
        {
          pcch->contention_resolution = FALSE;
          COM_FREE_QUEUE_BUFFER(&dl_data->dcch0_queue, INDEX_SWITCH_BUFFER);
        }
      }

      drr_dl_release_ind (pcch->ch_type, pcch_i->sapi, release_ind_cs, FALSE);
      pcch_i->T200_Stop = TRUE;
      pcch_i->state = STATE_IDLE_DL;
    }

  }/* endif frame_format == 3 (only unnumbered frames) */

  return 0;
}/* endfunc downlink_contention_resolution */

static  int downlink_mfe(T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  TRACE_EVENT_WIN ("downlink_mfe()");

  switch (GET_FORMAT_TYPE (frame))
  {
  case I_FORMAT:/* I frame */
  case I1_FORMAT:
    downlink_mfe_information (pcch_i, frame);
    break;
  case S_FORMAT: /* S frame */
    downlink_mfe_supervisory (pcch_i, frame);
    break;
  case U_FORMAT: /* U frame */
    downlink_mfe_tr_unnumbered (pcch_i, frame,
                                STATE_MULTIPLE_FRAME_ESTABLISHED);
    break;
  default:
    TRACE_EVENT_WIN ("invalid/unknown frame");
    break;
  }

  return 0;
}/* endfunc downlink_mfe */

static  void downlink_mfe_supervisory (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  UBYTE frame_cr;
  UBYTE frame_pollbit;
  UBYTE frame_nr;
  UBYTE frame_type;
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  TRACE_EVENT_WIN ("downlink_mfe_supervisory()");

  frame_type = GET_S_TYPE (frame);

  /*
   * Ignore RNR frame without notification
   * (ETSI GSM 04.06, section 6.
   * "Special protocol operation on SAPI=0 and SAPI=3", page 53)
   */
  if (frame_type EQ RNR_FRAME)
    return;

  frame_cr = GET_CR (frame);
  frame_pollbit = GET_P_BIT (frame);
  frame_nr = GET_RECEIVE_NUMBER (frame);

  /* in accordance with CCITT Q.921 figure B.7 (sheet 5 to 7 of 10) */
  if (frame_pollbit)
  {
    if (frame_cr)
    {
      enquiry_response (pcch_i, frame);
    }
    else
    {
      mdl_error_ind (UNSOLICITED_SUPERVISORY_RESPONSE, pcch->ch_type, pcch_i->sapi);/* 3GPP TS 04.06, 5.4.2.2 */
    }
  }

  if (com_check_nr (pcch->va, pcch->vs, frame_nr))
  {
    /*
     * N(R) check is successfull
     * in accordance with CCITT Q.921 figure B.7 (sheet 6 and 7 of 10)
     */

    switch (frame_type)
    {
    case RR_FRAME:
      if (frame_nr EQ pcch->vs)
      {
        /* T200 handling under ETSI GSM 04.06 section 5.5.3.1 */
        if (((8 + frame_nr - pcch->va ) & 7) > 0 /*frame_nr > pcch->va*/)
          pcch_i->T200_Stop = TRUE;

        pcch->va = frame_nr;

        free_sending_buffer (pcch->ch_type, pcch_i->sapi);
      }
      else
      {
        if (frame_nr NEQ pcch->va)
        {
          pcch->va = frame_nr;
          pcch_i->T200_Start = TRUE;
        }
      }
      break;
    case REJ_FRAME:
      /*
       * in accordance with ETSI GSM 04.06; chapter 5.5.4.1 i)
       *
       * clear existing peer receiver busy condition (not applicable in GSM)
       */

      /* reset timer T200 */
      pcch_i->T200_Stop = TRUE;
      /*
       * If REJ command with P bit set to 1,
       * transmit an appropiate supervisory response frame with F bit set to 1
       */
      if (frame_pollbit AND frame_cr)
        enquiry_response (pcch_i, frame);
      /* transmit the corresponding I frame asap */
      invoke_retransmission (pcch_i, frame_nr);


      /*
       * set its send state variable V(S) and its acknowledge state
       * variable V(A) to the value of the N(R) contained in the REJ frame
       * control field
       */
      pcch->vs = pcch->va = frame_nr;

      /*
       * if it was an REJ response frame with the F bit set to 1, notify
       * a protocol violation to layer 3 (cause=unsolicited supervisory frame)
       *
       * fulfilled at the beginning of this function!
       */
      break;
    case RNR_FRAME:
      /*
       * Ignore frame without notification
       * (ETSI GSM 04.06, section 6.
       * "Special protocol operation on SAPI=0 and SAPI=3", page 53)
       */
      break;
    default:
      TRACE_EVENT_WIN ("invalid S frame");  /* GSM 04.06 Annex G.3.1 */
      mdl_error_ind (FRAME_NOT_IMPLEMENTED, pcch->ch_type, pcch_i->sapi);
      break;
    }

  }
  else
  {
    nr_error_recovery (pcch_i, frame);
  }
}/* endfunc downlink_mfe_supervisory */


static  void downlink_mfe_sabm (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  TRACE_EVENT_WIN ("downlink_mfe_sabm()");

  if (!GET_LENGTH_INDICATOR (frame))
  {
    T_CCH*  pcch;

    CHECK_PCCH_I();
    pcch = pcch_i->pcch;

    if (pcch_i->sapi EQ PS_SAPI_0)
    {
      /* SACCH0: only unacknowledge mode available -> ignore SABM */
      if (pcch->ch_type EQ L2_CHANNEL_SACCH)
        return;
      /*
       * SDCCH0, FACCH: can not be a normal establishment procedure
       * because for SAPI=0 the data link is always established by the MS.
       * Therefore only the V state variables and any exception states
       * will be reseted.
       */
    }
    else if (pcch_i->sapi EQ PS_SAPI_3)
    { /*
       * SDCCH3, SACCH: normal establishment procedure,
       * might be a re-establishment according to GSM 04.06, 5.4.1.2
       */
      com_clear_queue (PS_SAPI_3);
    }

    /* respond with an unnumbered acknowledgement */
    pcch->vtx = UA_CMD;
    /* with the F bit set to the same value as the P bit */
    pcch_i->pf_bit_flag = GET_P_BIT (frame);
    /* reset timer T200 */
    pcch_i->T200_Stop = TRUE;
    /* reset all state variables (internal sequence counter) */
    pcch->va = 0;
    pcch->vr = 0;
    pcch->vs = 0;
    /* reset the retransmission counter */
    pcch->rc = 0;
    /* clear all exception conditions */
    pcch->reject_exception = FALSE;
    pcch->acknowledge_pending = FALSE;
    /* enter the multiple-frame-established state */
    pcch_i->state = STATE_MULTIPLE_FRAME_ESTABLISHED;
  }
  else
  {
    /*
     * frame_length NEQ 0 is only possible in contention resolution establishment
     * initiated by mobile!
     */
     mdl_error_ind (U_FRAME_WITH_INCORRECT_PARAMETERS, pcch_i->pcch->ch_type, pcch_i->sapi);/* according to GSM 04.06, 5.4.2.1 */
  }
}/* endfunc mfe_sabm */

static  void downlink_mfe_dm (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  if (!GET_P_BIT (frame))
  { /* release after unsolicited DM response during connection */

    /* New! Called now by mdl_error_ind() from caller of this function
     * drr_dl_release_ind (dl_data, pcch->ch_type, pcch_i->sapi, NOT_PRESENT_8BIT);
     */

    if ((pcch->ch_type EQ L2_CHANNEL_SDCCH) AND (pcch_i->sapi EQ PS_SAPI_3))
    {
      pcch_i->T200_Stop = TRUE;
      com_clear_queue (PS_SAPI_3);
    }
  }
}/* endfunc mfe_dm */

static  void downlink_mfe_tr_unnumbered (T_CCH_INTERN* pcch_i,
                                         UBYTE *frame, UBYTE state)
{
  UBYTE frame_type;
  T_CCH*  pcch;

  TRACE_EVENT_WIN ("downlink_mfe_tr_unnumbered()");

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  frame_type = GET_U_TYPE (frame);
  if (GET_CR (frame))
  { /* command */
    switch (frame_type)
    {
    case SABM_FRAME:
      downlink_mfe_sabm (pcch_i, frame);
      break;
    case UI_FRAME:
      /* drr_dl_unitdata_ind() was called in the main downlink function */
      break;
    case DISC_FRAME:
      pcch->vtx = UA_CMD;
      pcch_i->T200_Stop = TRUE;
      pcch_i->state = STATE_AWAITING_RELEASE;
#if !defined(LATE_LEAVING_DEDICATED)
      com_leave_dedicated (pcch->ch_type);
#endif /* LATE_LEAVING_DEDICATED */
      if (pcch_i->sapi EQ PS_SAPI_0)
      {
        dcch3_enable(pcch->ch_type);
      }
      break;
    default:
      /* GSM 04.06 Annex G.2.2, G.3.2 */
      TRACE_EVENT_WIN_P1 ("invalid command U frame (%02x)", frame_type);
      break;
    }
  }
  else
  { /* response */
    switch (frame_type)
    {
    case DM_FRAME:
      /* fulfill the actions required by 3GPP TS 4.06 section 5.4.2.2, table 7 */
      if (!GET_P_BIT(frame))
      {
        mdl_error_ind (UNSOLICITED_DM_RESPONSE_ABNORMAL_REL, pcch->ch_type, pcch_i->sapi);
      }
      else if (state EQ STATE_MULTIPLE_FRAME_ESTABLISHED)
      {
        mdl_error_ind (UNSOLICITED_DM_RESPONSE, pcch->ch_type, pcch_i->sapi);
      }

      downlink_mfe_dm (pcch_i, frame);
      break;
    case UA_FRAME:
      mdl_error_ind (UNSOLICITED_UA_RESPONSE, pcch->ch_type, pcch_i->sapi);
      break;
    default:
      /* GSM 04.06 Annex G.2.2, G.3.2 */
      TRACE_EVENT_WIN_P1 ("invalid response U frame (%02x)", frame_type);
      break;
    }
  }
}/* endfunc downlink_mfe_unnumbered */

static  void downlink_i_frame (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  /*
   * in accordance with CCITT Q.921 figure B.7 (sheet 8 of 10)
   * in accordance with CCITT Q.921 figure B.8 (sheet 7 of 9)
   * according to GSM 04.06 (same as CCITT Q.921!)
   */

  UBYTE frame_pollbit;
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  frame_pollbit = GET_P_BIT (frame);

  if (GET_SEND_NUMBER (frame) EQ pcch->vr)
  {
    pcch->vr++;
    pcch->vr &= 7;
    pcch->reject_exception = FALSE;
    concatenate (pcch->ch_type, pcch_i->sapi, frame);
    if (!GET_M_BIT (frame))
      pcch_i->dl_data_ind = TRUE;/* send DL-DATA indication */

    if (frame_pollbit)
    {
      pcch_i->pf_bit_flag = TRUE;
      pcch->vtx = RR_RSP;
      pcch->acknowledge_pending = FALSE;
    }
    else if (pcch->acknowledge_pending EQ FALSE)
    {
#if defined(IFRAME_AS_RR)
      pcch->vtx = RR_CMD;
#else
      pcch->vtx = RR_RSP;
#endif  /* IFRAME_AS_RR */
    }
  }/* endif ns == vr */
  else
  {
    if (pcch->reject_exception)
    {
      if (frame_pollbit)
      {
        pcch_i->pf_bit_flag = TRUE;
        /*pcch->vtx = RR_RSP; */
        pcch->vtx = REJ_CMD;
        pcch->acknowledge_pending = FALSE;
      }
    }
    else
    {
      pcch->reject_exception = TRUE;
      pcch_i->pf_bit_flag = frame_pollbit;
      pcch->vtx = REJ_CMD;
      pcch->acknowledge_pending = FALSE;
    }
    if (pcch->vtx EQ REJ_CMD)
    {
      TRACE_EVENT_WIN_P1 ("->REJ_CMD pf=%u", pcch_i->pf_bit_flag);
    }
  }/* endelse ns != vr */
}/* endfunc downlink_i_frame */

static  void downlink_mfe_information ( T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  UBYTE frame_nr;
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  TRACE_EVENT_WIN ("downlink_mfe_information()");

  if (!GET_CR (frame))
  { /* GSM 04.06 Annex G.2.2 */
    TRACE_EVENT_WIN ("invalid I response (C=0)");
    return;
  }

  frame_nr = GET_RECEIVE_NUMBER (frame);

  /* in accordance with CCITT Q.921 figure B.7 (sheet 8 of 10) */
  downlink_i_frame (pcch_i, frame);

  /* in accordance with CCITT Q.921 figure B.7 (sheet 9 of 10) */
  if (com_check_nr (pcch->va, pcch->vs, frame_nr))
  { /* N(R) check is successfull */
    if (frame_nr EQ pcch->vs)
    {

      /* T200 handling under ETSI GSM 04.06 section 5.5.3.1 */
      if (((8 + frame_nr - pcch->va ) & 7) > 0 /*frame_nr > pcch->va*/)
        pcch_i->T200_Stop = TRUE;

      pcch->va = frame_nr;
      free_sending_buffer (pcch->ch_type, pcch_i->sapi);
    }
    else if (frame_nr NEQ pcch->va)
    {
      pcch->va = frame_nr;
      pcch_i->T200_Start = TRUE;
    }
  }
  else
  {
    nr_error_recovery (pcch_i, frame);
  }/* endifelse com_check_nr */
}/* endfunc downlink_mfe_information */

static  int downlink_timer_recovery(T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  TRACE_EVENT_WIN ("downlink_timer_recovery()");

  switch (GET_FORMAT_TYPE (frame))
  {
  case I_FORMAT:
  case I1_FORMAT: /* I frame */
    downlink_tr_information (pcch_i, frame);
    break;
  case S_FORMAT: /* S frame */
    downlink_tr_supervisory (pcch_i, frame);
    break;
  case U_FORMAT: /* U frame */
    downlink_mfe_tr_unnumbered (pcch_i, frame, STATE_TIMER_RECOVERY);
    break;
  default:
    TRACE_EVENT_WIN ("invalid/unknown frame");
    break;
  }

  return 0;
}/* endfunc downlink_tr */

static  void downlink_tr_supervisory (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  UBYTE frame_cr;
  UBYTE frame_pollbit;
  UBYTE frame_nr;
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  TRACE_EVENT_WIN ("downlink_tr_supervisory()");

  frame_cr = GET_CR (frame);
  frame_pollbit = GET_P_BIT (frame);
  frame_nr = GET_RECEIVE_NUMBER (frame);

  switch (GET_S_TYPE (frame))
  {
  case RR_FRAME:
    /*
     * in accordance with CCITT Q.921 figure B.8 (sheet 5 and 6 of 9) and
     * 3GPP 04.06, 5.5.3.1 "On receipt of a valid I frame or supervisory frame"
     * and 5.5.7 "Waiting acknowledgement".
     */
    if (frame_pollbit AND frame_cr)
    {
      enquiry_response (pcch_i, frame);
    }

    if (com_check_nr (pcch->va, pcch->vs, frame_nr))
    {
      /* N(R) check is successfull */

      TRACE_EVENT_WIN_P5 ("V(A)=%d =< N(R)=%d =< V(S)=%d check is successfull, pf=%u cr=%u",
        pcch->va, frame_nr, pcch->vs, frame_pollbit, frame_cr);

      pcch->va = frame_nr;

      if (frame_pollbit AND !frame_cr)
      { /*
         * 3GPP 04.06, 5.5.7:
         * The timer recovery state is only cleared if the DL receives a valid
         * supervisory frame response with the F bit set to 1.
         */
        pcch_i->T200_Stop = TRUE;
        pcch_i->state = STATE_MULTIPLE_FRAME_ESTABLISHED;
        /* acknowledgement according to GSM 04.06, 5.5.3.1*/
        free_sending_buffer (pcch->ch_type, pcch_i->sapi);
      }
      else
      {
        invoke_retransmission (pcch_i, frame_nr);
      }
    }
    else
    {
      nr_error_recovery (pcch_i, frame);
    }/* endifelse com_check_nr */
    break;

  case REJ_FRAME:
#if defined(NEW_REJ_ACK)
    /*
     * in accordance with
     * 3GPP 04.06, 5.5.3.1 "On receipt of a valid I frame or supervisory frame"
     */
    if (com_check_nr (pcch->va, pcch->vs, frame_nr))
    {
      /* N(R) check is successfull */

      TRACE_EVENT_WIN_P5 ("V(A)=%d =< N(R)=%d =< V(S)=%d check is successfull, pf=%u cr=%u",
        pcch->va, frame_nr, pcch->vs, frame_pollbit, frame_cr);

      /* acknowledgement according to GSM 04.06, 5.5.3.1*/
      free_sending_buffer (pcch->ch_type, pcch_i->sapi);

      pcch->va = frame_nr;
    }
#endif  /* NEW_REJ_ACK */

    /*
     * in accordance with GSM 04.06; chapter 5.5.4.1
     * Receipt of a valid REJ frame [ii) and iii)]
     *
     * clear existing peer receiver busy condition (not applicable in GSM)
     */

    if (frame_pollbit AND !frame_cr)
    {/* REJ response with F bit set to 1 */
      /* clear the timer recovery state */
      pcch_i->state = STATE_MULTIPLE_FRAME_ESTABLISHED;

      /* reset timer T200 */
      pcch_i->T200_Stop = TRUE;

#if defined(NEW_REJ_ACK)
      /* transmit the corresponding I frame asap */
      if (pcch->va NEQ frame_nr)
      {
        TRACE_EVENT_WIN_P2 ("REJ: V(A)=%d != N(R)=%d => invoke retransmission",
          pcch->va, frame_nr);

        invoke_retransmission (pcch_i, frame_nr);
      }
#else /* NEW_REJ_ACK */
      /* transmit the corresponding I frame asap */
      invoke_retransmission (pcch_i, frame_nr);
#endif  /* NEW_REJ_ACK */


      /*
       * set its send state variable V(S) and its acknowledge state
       * variable V(A) to the value of the N(R) contained in the REJ frame
       * control field
       */
      pcch->vs = pcch->va = frame_nr;
    }
    else
    {
      /*
       * set its its acknowledge state variable V(A) to the value
       * of the N(R) contained in the REJ frame control field
       */
      pcch->va = frame_nr;

      /*
       * if REJ command with P bit set to 1,
       * transmit an appropiate supervisory response frame with F bit set to 1
       */
      if (frame_pollbit AND frame_cr)
      {
        enquiry_response (pcch_i, frame);
      }
    }
    break;

  case RNR_FRAME:
    /*
     * ignore RNR frame without notification
     * (ETSI GSM 04.06, section 6.
     * "Special protocol operation on SAPI=0 and SAPI=3", page 53)
     */
  default:
    /* frame not implemented, */
    TRACE_EVENT_WIN ("invalid S frame");  /* GSM 04.06 Annex G.3.1 */
    return;
  }/* endswitch frame_type */


}/* endfunc downlink_tr_supervisory */

static  void downlink_tr_information ( T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  T_CCH*  pcch;
  UBYTE   frame_nr;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  TRACE_EVENT_WIN ("downlink_tr_information()");

  if (!GET_CR (frame))
  { /* GSM 04.06 Annex G.2.2 */
    TRACE_EVENT_WIN ("invalid I response (C=0)");
    return;
  }

  /* in accordance with CCITT Q.921 figure B.8 (sheet 7 of 9) */
  downlink_i_frame (pcch_i, frame);

  /*
   * in accordance with CCITT Q.921 figure B.8 (sheet 8 of 9) and
   * 3GPP 04.06, 5.5.3.1 "On receipt of a valid I frame or supervisory frame"
   * and 5.5.7 "Waiting acknowledgement".
   */
  frame_nr = GET_RECEIVE_NUMBER (frame);
  if (com_check_nr (pcch->va, pcch->vs, frame_nr))
    pcch->va = frame_nr;/* N(R) check is successfull */
  else
    nr_error_recovery (pcch_i, frame);
}/* endfunc downlink_tr_information */

static  int downlink_awaiting_release(T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  T_CCH*  pcch;

  CHECK_PCCH_Ir();
  pcch = pcch_i->pcch;

  TRACE_FUNCTION ("downlink_awaiting_release()");

  if (GET_FORMAT_TYPE (frame) EQ U_FORMAT)
  { /* U frame */
    if (GET_CR (frame))
    { /* command */
      switch (GET_U_TYPE (frame))
      {
      case SABM_FRAME:
        if (pcch_i->sapi EQ PS_SAPI_0)
        {
          pcch->vtx = DM_CMD;
          pcch_i->pf_bit_flag = GET_P_BIT (frame);
          pcch_i->T200_Stop = TRUE;
          pcch_i->state = STATE_IDLE_DL;
          drr_dl_release_cnf (pcch->ch_type, PS_SAPI_0, FALSE);
        }
        break;
      case UI_FRAME:
        /* drr_dl_unitdata_ind() was called in the main downlink function */
        break;
      case DISC_FRAME:
        pcch->vtx = UA_CMD;
        pcch_i->T200_Stop = TRUE;
#if !defined(LATE_LEAVING_DEDICATED)
        com_leave_dedicated (pcch->ch_type);
#endif  /* LATE_LEAVING_DEDICATED */
        break;
      default:
        /* GSM 04.06 Annex G.2.2, G.3.2 */
        TRACE_EVENT_WIN_P1 ("invalid command U frame (%02x)", GET_U_TYPE (frame));
        break;
      }
    }
    else
    { /* response */
      switch (GET_U_TYPE (frame))
      {
      case DM_FRAME:
        /*
         * PATCH LE 14.09.99
         * Ignore DM(F=0) frames
         */
        if (!GET_P_BIT (frame))
          break;

        /* the same as UA_FRAME */
        /*lint -fallthrough*/

      case UA_FRAME:
        pcch_i->T200_Stop = TRUE;
#if defined(LATE_LEAVING_DEDICATED)
        com_leave_dedicated (pcch->ch_type);
#endif  /* LATE_LEAVING_DEDICATED */
        pcch_i->state = STATE_IDLE_DL;
        drr_dl_release_cnf (pcch->ch_type, pcch_i->sapi, TRUE);
        break;

      default:
        TRACE_EVENT_WIN_P1 ("invalid response U frame (%02x)", GET_U_TYPE (frame));
        break;
      }
    }
  }
  return 0;
}/* endfunc downlink_awaiting_release */

static  void invoke_retransmission (T_CCH_INTERN* pcch_i, UBYTE frame_nr)
{
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  if (pcch->vs NEQ frame_nr)
  { /* decrement V(S) and recover queue for retransmission */
    TRACE_EVENT_WIN ("invoke retransmission");

    pcch->vs--;
    pcch->vs &= 7;
    com_recover_queue (pcch_i->sapi);
  }
}/* endfunc invoke_retransmission */


static  void enquiry_response (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  TRACE_EVENT_WIN ("enquiry_response()");
  /*
   * in accordance with ETSI GSM 04.06, 5.5.3.2 Receiving supervisory
   * commands with the P bit set to "1" and ETSI GSM 04.06, 5.5.4.1 iii
   */

  pcch_i->pf_bit_flag = TRUE;
  pcch->acknowledge_pending = FALSE;
  pcch->vtx = RR_RSP;
}/* endfunc enquiry_response */

#if defined(_SIMULATION_)
LOCAL const char * const _str_error_ind_cause[] =
{
  "T200_EXPIRED_N200_PLUS_1_TIMES, \"T200 expired (N200 + 1 times)\"",
  "CS_REEST_REQ, \"re-establishment request\"",
  "UNSOLICITED_UA_RESPONSE, \"unsolicited UA response\"",
  "UNSOLICITED_DM_RESPONSE, \"unsolicited DM response\"",
  "UNSOLICITED_DM_RESPONSE_ABNORMAL_REL, \"unsolicited DM response, multiple frame established state\"",
  "UNSOLICITED_SUPERVISORY_RESPONSE, \"unsolicited supervisory response\"",
  "SEQUENCE_ERROR, \"sequence error\"",
  "U_FRAME_WITH_INCORRECT_PARAMETERS, \"U frame with incorrect parameters\"",
  "S_FRAME_WITH_INCORRECT_PARAMETERS, \"S frame with incorrect parameters\"",
  "I_FRAME_WITH_INCORRECT_USE_OF_M_BIT, \"I frame with incorrect use of M bit\"",
  "I_FRAME_WITH_INCORRECT_LENGTH, \"I frame with incorrect length\"",
  "FRAME_NOT_IMPLEMENTED, \"frame not implemented\"",
};
#endif  /* _SIMULATION_ */

static  void mdl_error_ind (UBYTE cause,
                         UBYTE channel_type, UBYTE sapi)
{
  TRACE_EVENT_WIN_P2 ("mdl_error_ind(%u %s)", cause, _str_error_ind_cause[cause]);
  switch(cause)
  {
    case T200_EXPIRED_N200_PLUS_1_TIMES:
    case UNSOLICITED_DM_RESPONSE:
    case UNSOLICITED_DM_RESPONSE_ABNORMAL_REL:
    case SEQUENCE_ERROR:
      drr_error_ind (channel_type, sapi);
      break;
    default:
      break;
  }
}/* endfunc mdl_error_ind */

static  void nr_error_recovery (T_CCH_INTERN* pcch_i, UBYTE *frame)
{
  
  T_CCH*  pcch;

  CHECK_PCCH_I();
  pcch = pcch_i->pcch;

  TRACE_EVENT_WIN ("nr_error_recovery()");
  DL_OFFLINE_TRACE (TRACE_DL_EVENT, TRACE_CH_UNKNOWN, pcch->ch_type, "N(R) sequence error");

  switch (pcch->ch_type)
  {
  case L2_CHANNEL_SDCCH:
    if (pcch_i->sapi EQ PS_SAPI_3)
      break;
    /*lint -fallthrough*/
  case L2_CHANNEL_SACCH:
  case L2_CHANNEL_FACCH_F:
  case L2_CHANNEL_FACCH_H:
    if ((GET_P_BIT (frame) EQ 1) AND !GET_M_BIT (frame))
      pcch_i->dl_data_ind = TRUE; /* indicate a complete message to layer 3 */
    else
      pcch_i->dl_data_ind = FALSE;/* no indication if P bit set to "0" or message is incomplete */

    /*
     * GSM 04.06, 5.7.4 The data link shall remain in current state
     * until it´s release by layer 3 ???
     */
    pcch_i->mdl_error_ind = SEQUENCE_ERROR; /* send mdl error ind after sequence error */

    DL_EM_CHANNEL_FAILURE;

    break;
  }
  pcch->vtx = EMPTY_CMD;/* no answer after N(R) sequence error */
}/* endfunc nr_error_recovery */


static void concatenate (UBYTE ch_type, UBYTE sapi,UBYTE *frame)
{
  GET_INSTANCE_DATA;
  switch (ch_type)
  {
  case L2_CHANNEL_SDCCH:
    if (sapi EQ PS_SAPI_0)
      com_concatenate (&dl_data->dcch0_in_msg, frame);
    else if (sapi EQ PS_SAPI_3)
      com_concatenate (&dl_data->dcch3_in_msg, frame);
    break;
  case L2_CHANNEL_SACCH:
    if (sapi EQ PS_SAPI_3)
    {
      com_concatenate (&dl_data->dcch3_in_msg, frame);
    }
    break;
  case L2_CHANNEL_FACCH_F:
  case L2_CHANNEL_FACCH_H:
    if (sapi EQ PS_SAPI_0)
    {
      com_concatenate (&dl_data->dcch0_in_msg, frame);
    }
    break;
  default:
    break;
  }
}/* endfunc concatenate */

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)          MODULE  : DL_COM                  |
| STATE   : code                   ROUTINE : free_sending_buffer     |
+--------------------------------------------------------------------+

  PURPOSE : After confirmation of an I frame the sending buffer is
            released if it was the last segment. This avoids
            resending of I frames after resumption.

*/
static void free_sending_buffer ( UBYTE ch_type, UBYTE sapi)
{
  GET_INSTANCE_DATA;
  T_QUEUE *queue = NULL;

  TRACE_EVENT_WIN_P2 ("free_sending_buffer():%s SAPI=%u", CH_TYPE_NAME[ch_type], sapi);

  switch (ch_type)
  {
  case L2_CHANNEL_SDCCH:
    if (sapi EQ PS_SAPI_0)
      queue = &dl_data->dcch0_queue;
    else if (sapi EQ PS_SAPI_3)
      queue = &dl_data->dcch3_queue;
    break;
  case L2_CHANNEL_SACCH:
    if (sapi EQ PS_SAPI_3)
      queue = &dl_data->dcch3_queue;
    break;
  case L2_CHANNEL_FACCH_F:
  case L2_CHANNEL_FACCH_H:
    if (sapi EQ PS_SAPI_0)
      queue = &dl_data->dcch0_queue;
    break;
  default:
    break;
  }

  if (queue)
  {
    if (queue->switch_buffer)
    {
      TRACE_EVENT_WIN_P3 ("CNF on %s SAPI=%u %s (switch_buffer)",
        CH_TYPE_NAME[queue->switch_buffer->ch_type],
        queue->switch_buffer->sapi,
        queue->switch_buffer->cnf ? "CNF required" : "");

      com_l3trace (TRACE_UPLINK, queue->switch_buffer->ch_type, (UBYTE *)queue->switch_buffer);
      COM_FREE_QUEUE_BUFFER ( queue, INDEX_SWITCH_BUFFER);
    }
    else if (queue->sending_buffer)
    {
      TRACE_EVENT_WIN_P4 ("CNF on %s SAPI=%u %s (sending_buffer) act_length=%u",
        CH_TYPE_NAME[queue->sending_buffer->ch_type],
        queue->sending_buffer->sapi,
        queue->sending_buffer->cnf ? "CNF required" : "",
        queue->act_length);

      if (queue->act_length EQ 0)
      { /* entire message has been sent */
        com_l3trace (TRACE_UPLINK, queue->sending_buffer->ch_type, (UBYTE *)queue->sending_buffer);

        if (queue->sending_buffer->cnf)
        {
          drr_dl_data_cnf (sapi);
        }
        else
        {
          COM_FREE_QUEUE_BUFFER (queue, INDEX_SENDING_BUFFER);
        }
      }
    }
    else
    {
      TRACE_EVENT_WIN_P2 ("%s SAPI=%u: sending_buffer and switch_buffer=NULL !!!",
        CH_TYPE_NAME[ch_type], sapi);
    }
  }
}/* endfunc concatenate */

static void T200_expiry ( UBYTE channel, UBYTE sapi)
{
  GET_INSTANCE_DATA;
  UBYTE   old_state;
  UBYTE   new_state;
  T_CCH * pcch = &dl_data->cch[channel];
  UBYTE   N200_counter;

  TRACE_FUNCTION ("T200_expiry()");

  switch (pcch->ch_type)
  {
    case L2_CHANNEL_SACCH:
      N200_counter = SACCH_N200;
      break;
    case L2_CHANNEL_SDCCH:
      N200_counter = SDCCH_N200;
      break;
    case L2_CHANNEL_FACCH_F:
      N200_counter = FACCH_N200_FR;
      break;
    case L2_CHANNEL_FACCH_H:
      N200_counter = FACCH_N200_HR;
      break;
    default:
      N200_counter = NOT_PRESENT_8BIT;
      break;
  }

  new_state = old_state = dl_data->state[channel];
  switch (old_state)
  {
    case STATE_CONTENTION_RESOLUTION:
      repeat_sabm (channel, sapi);
      break;

    case STATE_MULTIPLE_FRAME_ESTABLISHED:
      pcch->rc        = 1;
      pcch->p_bit_flag= 1;
      pcch->time_flag = TRUE;
      new_state   = STATE_TIMER_RECOVERY;
      break;

    case STATE_TIMER_RECOVERY:
      if (N200_counter EQ NOT_PRESENT_8BIT)
        break; /* invalid channel */

      if (pcch->rc >= N200_counter)
      { /* release connection due to T200 expired N200 plus 1 times */

        TRACE_EVENT_WIN_P1 ("T200 expired, N200=%u", N200_counter);

        /* New! Called now by mdl_error_ind().
         * drr_dl_release_ind (dl_data, pcch->ch_type, sapi, NOT_PRESENT_8BIT);
         */
        mdl_error_ind (T200_EXPIRED_N200_PLUS_1_TIMES, pcch->ch_type, sapi);

        if (sapi EQ PS_SAPI_0)
        {
          dcch3_init_dl_data();
          pcch->T200_counter      = 0;
          pcch->time_flag             = FALSE;
          pcch->contention_resolution = FALSE;
          pcch->vtx                   = EMPTY_CMD;
          new_state         = STATE_IDLE_DL;
        }
      }
      else
      {
        pcch->rc++;
        pcch->p_bit_flag  = 1;
        pcch->time_flag   = TRUE;
      }
      break;

    case STATE_AWAITING_RELEASE:
      if (pcch->rc >= N200_ESTABLISHMENT)
      {
        TRACE_EVENT_WIN_P1 ("T200 expired, N200=%u", N200_ESTABLISHMENT);
        drr_dl_release_cnf (pcch->ch_type, sapi, TRUE);
        new_state = STATE_IDLE_DL;

      }
      else
      {
        pcch->rc++;
        pcch->vtx   = DISC_CMD;
        pcch->time_flag = TRUE;
      }
      break;

    default:
      break;
  }/* endswitch old_state */

  if (new_state NEQ old_state)
  {
    set_channel_state (channel, new_state);
  }

}/* endfunc T200_expiry */

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)       MODULE  : state                      |
| STATE   : code                ROUTINE : repeat_sabm                |
+--------------------------------------------------------------------+

  PURPOSE : Repeat if possible the SABM command.

*/

static void repeat_sabm (UBYTE channel, UBYTE sapi)
{
  GET_INSTANCE_DATA;
  T_CCH*  pcch = &dl_data->cch[channel];

  TRACE_FUNCTION ("repeat_sabm()");

  if (pcch->rc >= N200_ESTABLISHMENT)
  {
    if (sapi EQ PS_SAPI_0)
      pcch->contention_resolution = FALSE;

    DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, pcch->ch_type, ">N200_EST");
    SYST_TRACE_P ((SYST, "DL: >N200 of SABM"));
    TRACE_ERROR ("DL: >N200 of SABM");

    DL_EM_CHANNEL_ESTABLISHMENT_FAILED;

    mdl_error_ind(T200_EXPIRED_N200_PLUS_1_TIMES, pcch->ch_type, sapi);
    set_channel_state (channel, STATE_IDLE_DL);
    /* New! Called now by mdl_error_ind().
     * drr_dl_release_ind (dl_data, pcch->ch_type, sapi, NOT_PRESENT_8BIT);
     */
  }
  else
  {
    pcch->rc++;
    pcch->vtx       = SABM_CMD;
    pcch->time_flag = TRUE;
    TRACE_EVENT_P1 ("DL: T200 %u. repeat of SABM", pcch->rc);
  }
}/* endfunc repeat_sabm */

GLOBAL  void set_channel_state (UBYTE channel, UBYTE state)
{
  GET_INSTANCE_DATA;
  if (dl_data->state[channel] NEQ state)
  {
    #ifdef TRACE_STATE
      vsi_o_state_ttrace ("STATE_%s:%s -> %s", PROCESS_NAME[channel],
        channel EQ C_DCCH3 ? STATE_DCCH3_NAME[dl_data->state[channel]]:
                             STATE_DCCH0_NAME[dl_data->state[channel]],
        channel EQ C_DCCH3 ? STATE_DCCH3_NAME[state] :
                             STATE_DCCH0_NAME[state]);
    #endif /* TRACE_STATE */
    dl_data->state[channel] = state;
    DL_OFFLINE_TRACE (TRACE_CHSTATE, channel, dl_data->cch[channel].ch_type, NULL);
  }
}/* endfunc set_channel_state */

static void set_T200_counter (T_CCH* pcch, UBYTE sapi)
{
  switch (pcch->ch_type)
  {
    case L2_CHANNEL_SACCH:
      pcch->T200_counter = sapi EQ PS_SAPI_0 ?
        T200_SDCCH_SAPI_0_CNT : T200_SACCH_SAPI_3_CNT;
      break;
    default:
      TRACE_EVENT_WIN_P1 ("set_T200_counter: unknown ch_type=%u -> use SDCCH", pcch->ch_type);
      /*lint -fallthrough*/
    case L2_CHANNEL_SDCCH:
      pcch->T200_counter = sapi EQ PS_SAPI_0 ?
        T200_SDCCH_SAPI_0_CNT : T200_SDCCH_SAPI_3_CNT;
      break;
    case L2_CHANNEL_FACCH_F:
      pcch->T200_counter = T200_FACCH_SAPI_0_CNT_FR;
      break;
    case L2_CHANNEL_FACCH_H:
      pcch->T200_counter = T200_FACCH_SAPI_0_CNT_HR;
      break;
  }/* endswitch ch_type */
  pcch->time_flag = FALSE;

  TRACE_EVENT_WIN_P3 ("set_T200_counter: %s, SAPI=%u: %u",
    CH_TYPE_NAME[pcch->ch_type], sapi, pcch->T200_counter);
}/* endfunc set_T200_counter */

#if defined(DELAYED_RELEASE_IND)
static void delayed_release_ind( UBYTE channel)
{
  GET_INSTANCE_DATA;
  /* delay DL RELEASE IND to RR for FTA 25.2.3 *********** */
  if (dl_data->release_ind_ch_type NEQ NOT_PRESENT_8BIT)
  {
    if (dl_data->release_ind_delay > 0)
      dl_data->release_ind_delay--;

    if (dl_data->release_ind_delay EQ 0)
    {
      DL_OFFLINE_TRACE (TRACE_DL_EVENT, TRACE_CH_UNKNOWN,
        dl_data->release_ind_ch_type, "UL:send delayed REL IND");
      drr_dl_release_ind (dl_data->release_ind_ch_type,
        dl_data->release_ind_sapi, NOT_PRESENT_8BIT, TRUE);
    }
    else
    {
      DL_OFFLINE_TRACE (TRACE_DL_EVENT, TRACE_CH_UNKNOWN,
        dl_data->release_ind_ch_type, "UL:pend. delay REL IND");
    }

  }
}

#endif  /* DELAYED_RELEASE_IND */

T_RADIO_FRAME* dl_uplink(UBYTE channel, UBYTE sapi,
                         UBYTE no_signalling_mode, BOOL recursive)
{
  GET_INSTANCE_DATA;
  T_CCH*          pcch = &dl_data->cch[channel];
  T_RADIO_FRAME*  p_l2_frame = &dl_data->l2_frame;
  int             send = UPLINK_NULL;

  TRACE_EVENT_WIN_P3 ("uplink(): %s dcch0_ch_type:%s dedi=%u",
      CH_TYPE_NAME[pcch->ch_type], CH_TYPE_NAME[dl_data->dcch0_ch_type], dl_data->RR_dedicated);
  TRACE_EVENT_WIN_P6 ("UL: DCCH0=%s,%s vr=%u vs=%u va=%u T200=%u",
    CH_TYPE_NAME[dl_data->cch[C_DCCH0].ch_type],
    STATE_DCCH0_NAME[dl_data->state[C_DCCH0]],
    dl_data->cch[C_DCCH0].vr, dl_data->cch[C_DCCH0].vs, dl_data->cch[C_DCCH0].va,
    dl_data->cch[C_DCCH0].T200_counter);
  TRACE_EVENT_WIN_P6 ("UL: DCCH3=%s,%s vr=%u vs=%u va=%u T200=%u",
    CH_TYPE_NAME[dl_data->cch[C_DCCH3].ch_type],
    STATE_DCCH3_NAME[dl_data->state[C_DCCH3]],
    dl_data->cch[C_DCCH3].vr, dl_data->cch[C_DCCH3].vs, dl_data->cch[C_DCCH3].va,
    dl_data->cch[C_DCCH3].T200_counter);


  /* check SACCH SAPI and channel */
  if (pcch->ch_type EQ L2_CHANNEL_SACCH)
  {
    if (!dl_data->RR_dedicated)
    {
      sapi = PS_SAPI_0;
      send = UPLINK_EMPTY;
      TRACE_EVENT_WIN ("SACCH without dedicated channel: change SAPI->0, UPLINK_EMPTY");
    }
    else if (dl_data->state[C_DCCH0] EQ STATE_SUSPENDED)
    {
      sapi = PS_SAPI_0;
      send = UPLINK_REPORT;
      TRACE_EVENT_WIN ("SACCH during suspended dedicated channel: change SAPI->0, UPLINK_REPORT");
    }
    else if (sapi EQ PS_SAPI_3)
    {
      if ((dl_data->state[C_DCCH0] <= STATE_IDLE_DL)
             OR
          (dl_data->dcch0_ch_type EQ L2_CHANNEL_SDCCH)
             OR
          ((dl_data->cch[C_DCCH3].vtx EQ EMPTY_CMD) AND
           (!com_queue_awaiting_transmission (PS_SAPI_3)) AND
           (dl_data->state[C_DCCH3] NEQ STATE_AWAITING_ESTABLISHMENT)
           ) )
      {
        sapi = PS_SAPI_0;
        TRACE_EVENT_WIN ("SACCH with SAPI=3 only together with FACCH and frame is awaiting tx: change SAPI->0");
      }
      else
      {
        channel = C_DCCH3;
        pcch = &dl_data->cch[channel];
        TRACE_EVENT_WIN ("SACCH with SAPI=3 together with FACCH: change channel->C_DCCH3");
      }
    }
  }
  else if ((dl_data->RR_dedicated) AND
           (dl_data->dcch0_ch_type NEQ pcch->ch_type))
  {
    TRACE_EVENT_WIN_P2 ("dcch0_ch_type (%s) NEQ %s -> unexpected,unsolicited,invalid channel => UPLINK_EMPTY",
      CH_TYPE_NAME[dl_data->dcch0_ch_type],
      CH_TYPE_NAME[dl_data->cch[C_DCCH0].ch_type]);
    send = UPLINK_EMPTY;
  }

  /* decrease T200 counter ************************************ */
  if (channel EQ C_DCCH3)
  {
    if (dl_data->cch[C_DCCH3].T200_counter >= T200_ACTIVE)
    {
      dl_data->cch[C_DCCH3].T200_counter--;
      TRACE_EVENT_WIN_P2 ("T200(SAPI_0)=%u  T200(SAPI_3)=%u*",
        dl_data->cch[C_DCCH0].T200_counter, dl_data->cch[C_DCCH3].T200_counter);
      /*DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, pcch->ch_type, "dec T200(SAPI_3)");*/
    }
  }
  else
  {
    if (pcch->ch_type NEQ L2_CHANNEL_SACCH) /* no T200 for SACCH with SAPI=0 */
    {
      if (dl_data->cch[C_DCCH0].T200_counter >= T200_ACTIVE)
      {
        dl_data->cch[C_DCCH0].T200_counter--;
        TRACE_EVENT_WIN_P2 ("T200(SAPI_0)=%u* T200(SAPI_3)=%u",
          dl_data->cch[C_DCCH0].T200_counter, dl_data->cch[C_DCCH3].T200_counter);
        /*DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, pcch->ch_type, "dec T200(SAPI_0)");*/
      }
    }
  }

  /* check activity of DL ************************************* */
  if (dl_data->dl_active AND dl_data->state[channel] EQ STATE_MULTIPLE_FRAME_ESTABLISHED)
  {
    TRACE_EVENT_WIN_P1 ("uplink(): %s dl_active", PROCESS_NAME[channel]);
    DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, pcch->ch_type, "UL:&dl_active");

    /* signalling only */
    send = UPLINK_EMPTY;
  }/* endif dl_active */

#if defined(DELAYED_SABM)
  /* delay uplink SABM to PL for FTA 26.6.6.1 and 25.2.3 *********** */
  if ((channel EQ C_DCCH0) AND (dl_data->dcch0_sabm_flag NEQ NOT_PRESENT_8BIT))
  {
    dcch0_delay_sabm (pcch);
    if (dl_data->dcch0_sabm_flag NEQ NOT_PRESENT_8BIT)
      send = UPLINK_EMPTY; /* send dummy only */
  }
#endif  /* DELAYED_SABM */


#if defined(DELAYED_RELEASE_IND)
  delayed_release_ind (channel);
#endif  /* DELAYED_RELEASE_IND */

  if ((send EQ UPLINK_NULL) OR (send EQ UPLINK_EMPTY))
  { /* After a L3 release at the last downlink DL should send a DISC */
    TRACE_EVENT_WIN_P6 ("uplink():%s %s SAPI=%u vtx=%s %s (#%u)",
      PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi,
      VTX_NAME[pcch->vtx], SEND_NAME[send], __LINE__);
    switch (channel)
    {
      case C_DCCH0:
        send = dcch0_check_disc (send);
        break;
      case C_DCCH3:
        send = dcch3_check_disc (send);
        break;
      default:
        break;
    }
    TRACE_EVENT_WIN_P6 ("uplink():%s %s SAPI=%u vtx=%s %s (#%u)",
      PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi,
      VTX_NAME[pcch->vtx], SEND_NAME[send], __LINE__);
  }

  if (send EQ UPLINK_NULL)
  {
    TRACE_EVENT_WIN_P5 ("uplink():%s %s SAPI=%u vtx=%s %s",
      PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi,
      VTX_NAME[pcch->vtx], recursive ? "RECURSIVE" : "");

    TRACE_EVENT_WIN_P8 ("UL: DCCH%u=%s,%s vr=%u vs=%u va=%u T200=%u (#%u)",
      sapi, CH_TYPE_NAME[dl_data->cch[channel].ch_type],
      STATE_DCCH3_NAME[dl_data->state[channel]],
      dl_data->cch[channel].vr, dl_data->cch[channel].vs, dl_data->cch[channel].va,
      dl_data->cch[channel].T200_counter, __LINE__);

    /* check timer T200 expiry ****************************** */
    if ((channel EQ C_DCCH0) AND
        (dl_data->cch[C_DCCH0].T200_counter EQ T200_EXPIRED))
      T200_expiry (C_DCCH0, PS_SAPI_0);
    if ((channel EQ C_DCCH3) AND
        (dl_data->cch[C_DCCH3].T200_counter EQ T200_EXPIRED))
      T200_expiry (C_DCCH3, PS_SAPI_3);

    TRACE_EVENT_WIN_P8 ("UL: DCCH%u=%s,%s vr=%u vs=%u va=%u T200=%u (#%u)",
      sapi, CH_TYPE_NAME[dl_data->cch[channel].ch_type],
      STATE_DCCH3_NAME[dl_data->state[channel]],
      dl_data->cch[channel].vr, dl_data->cch[channel].vs, dl_data->cch[channel].va,
      dl_data->cch[channel].T200_counter, __LINE__);

    /* state machine **************************************** */
    switch (dl_data->state[channel])
    {
    case STATE_IDLE_DL:
      if (pcch->vtx EQ EMPTY_CMD AND !dl_data->RR_dedicated)
        break;
      send = uplink_idle (channel, sapi);
      break;
    case STATE_CONTENTION_RESOLUTION: /* the same as STATE_AWAITING_ESTABLISHMENT */
      send = uplink_awaiting_establishment (channel, sapi, no_signalling_mode);
      break;
    case STATE_MULTIPLE_FRAME_ESTABLISHED:
      send = uplink_mfe (channel, sapi, no_signalling_mode);
      break;
    case STATE_TIMER_RECOVERY:
      send = uplink_timer_recovery (channel, sapi, no_signalling_mode);
      break;
    case STATE_AWAITING_RELEASE:
      send = uplink_awaiting_release ( channel, sapi);
      break;
    case STATE_SUSPENDED: /* only DCCH0 */
      send = UPLINK_NULL;
      break;
    case STATE_DISABLED:   /* only SABM/UA or SACCH and SDCCH (SAPI 3) */
      if (channel EQ C_DCCH3)
      {
        if (pcch->vtx EQ UA_CMD)
        {
          send = uplink_idle (channel, sapi);
        }
        else
        {
          send = UPLINK_EMPTY;
        }
      }
      break;
    }/* endswitch channel_state */

  }/* endif send == NULL */

  TRACE_EVENT_WIN_P8 ("UL: DCCH%u=%s,%s vr=%u vs=%u va=%u T200=%u (#%u)",
    sapi, CH_TYPE_NAME[dl_data->cch[channel].ch_type],
    STATE_DCCH3_NAME[dl_data->state[channel]],
    dl_data->cch[channel].vr, dl_data->cch[channel].vs, dl_data->cch[channel].va,
    dl_data->cch[channel].T200_counter, __LINE__);

  if (pcch->ch_type EQ L2_CHANNEL_SACCH)
  { /*
     * According to 3GPP TS 04.05, 4.2.2 Priority:
     * The priority arrangement on the SACCH must ensure that if a SAPI = 3
     * frame is awaiting transmission, two SAPI = 0 frames are not sent in
     * consecutive SACCH frames. In addition, for the mobile to network
     * direction it must also be ensured that any SAPI = 3 frame is followed
     * by at least one SAPI = 0 frame.
     */

    TRACE_EVENT_WIN_P3 ("sacch_last_uplink_sapi=%u SAPI=%u send=%s",
      dl_data->sacch_last_uplink_sapi, sapi, SEND_NAME[send]);

    if ((dl_data->sacch_last_uplink_sapi EQ PS_SAPI_3) OR
        ((sapi EQ PS_SAPI_3 ) AND (send EQ UPLINK_EMPTY)))
    {/* last uplinked SACCH frame was one with SAPI=3
      * or
      * no SACCH SAPI=3 frame is awaiting transmission
      * -> uplink of a SACCH SAPI=0 frame
      */
      sapi = PS_SAPI_0;
    }

    if (send EQ UPLINK_EMPTY)
    {
      sapi = PS_SAPI_0;
    }

    if ((sapi EQ PS_SAPI_0) AND (dl_data->state[C_DCCH0] >= STATE_SUSPENDED))
    { /*
       * uplink measurement reports only if SAPI=0 is suspended,
       * on contention resolution procedure, established or awaiting release
       */
      send = UPLINK_REPORT;
      TRACE_EVENT_WIN ("uplink(): SACCH REPORT now");
    }

    TRACE_EVENT_WIN_P2 ("sacch_last_uplink_sapi:=%u->%u", dl_data->sacch_last_uplink_sapi, sapi);
    dl_data->sacch_last_uplink_sapi = sapi;
  }
  else if ((pcch->ch_type EQ L2_CHANNEL_SDCCH) AND (channel NEQ C_DCCH3))
  { /*
     * According to 3GPP TS 04.05, 4.2.2 Priority:
     * The priority between data links on SDCCH shall be as follows:
     * Highest priority : SAPI = 0, Lowest priority : SAPI = 3.
     */
    if ((sapi EQ PS_SAPI_0) AND (send <= UPLINK_EMPTY))
    { /* special case: nothing is awaiting transmission for SAPI=0 */
      if ((dl_data->cch[C_DCCH3].vtx NEQ EMPTY_CMD) OR
          com_queue_awaiting_transmission(PS_SAPI_3) OR
          (dl_data->cch[C_DCCH3].T200_counter NEQ T200_STOPPED))
      {/* something is awaiting transmission for SAPI=3 */
        if (dl_data->state[C_DCCH0] >= STATE_CONTENTION_RESOLUTION)
        { /*
           * uplink SAPI=3 only if SAPI=0 is on contention resolution procedure
           * or established or awaiting release
           */
          send = UPLINK_DCCH3;
        }
      }

    }
  }
  else
  {
    /* no special treatment of FACCH */
  }

  /* return uplink frame buffer pointer dependent on the value of send */
  TRACE_EVENT_WIN_P4 ("%s on %s SAPI=%u RR_dedicated=%u",
    SEND_NAME[send], CH_TYPE_NAME[pcch->ch_type], sapi, dl_data->RR_dedicated);

  switch (send)
  {
  case UPLINK_NORMAL:
    break;

  case UPLINK_UA:
  case UPLINK_UA_F:
    com_build_UA_response (pcch->ch_type, sapi, (UBYTE)((send EQ UPLINK_UA_F) ? 1 : 0));
    break;

  case UPLINK_IFRAME:
  case UPLINK_IFRAME_P:
    {
      UBYTE m_bit;
      UBYTE p_bit = (send EQ UPLINK_IFRAME_P) ? 1 : 0;
      T_QUEUE *queue;

      if (pcch->ch_type EQ L2_CHANNEL_SACCH)
      {
        sapi = PS_SAPI_3; /* acknowledged mode only for SAPI=3 */
        TRACE_EVENT_WIN ("SACCH with I frame: acknowledged mode only for SAPI=3");
      }

      if (sapi EQ PS_SAPI_0)
        queue = &dl_data->dcch0_queue;
      else
        queue = &dl_data->dcch3_queue;

      if (send EQ UPLINK_IFRAME)
      {
        com_read_queue (pcch->ch_type, sapi, &m_bit);
      }
      else
      {/* TIMER_RECOVERY state -> repetition of the last frame */
        pcch->vs--;
        pcch->vs &= 7;
        pcch->p_bit_flag = 0;
        m_bit = queue->m_bit; /* remember last m bit  */
        TRACE_EVENT_WIN_P2 ("TIMER_RECOVERY state: decrement vs to %u, remember m=%u", pcch->vs, m_bit);
      }


      com_build_I_command (pcch->ch_type, sapi, pcch->vs, pcch->vr,
                           p_bit, m_bit, queue);
      pcch->vs++;
      pcch->vs &= 7;
      TRACE_EVENT_WIN_P4 ("%s SAPI=%u new vs=%u (pcch=%08x)",
        CH_TYPE_NAME[pcch->ch_type], sapi, pcch->vs, pcch);
    }
    set_T200_counter (pcch, sapi);
    break;

  case UPLINK_RR:
  case UPLINK_RR_F:
    if (pcch->ch_type EQ L2_CHANNEL_SACCH)
    {/*
      * There are some tests at the start of dl_uplink() to determine the right
      * SAPI value for SACCH. But the resulting value may be wrong because of
      * the priority arrangement according to 3GPP TS 04.05, section 4.2.2.
      * In case the MS has to uplink a RR frame it is clear that
      * L2 is in acknowledged mode and this can be done only with
      * a SAPI value of 3 for SACCH.
      */
      sapi = PS_SAPI_3; /* acknowledged mode only for SAPI=3 */
      TRACE_EVENT_WIN ("SACCH with supervisory frame: acknowledged mode only for SAPI=3");
    }
    com_build_RR_response (pcch->ch_type, sapi, pcch->vr,
                          (UBYTE)((send EQ UPLINK_RR_F) ? 1 : 0));
    break;

  case UPLINK_REJ:
  case UPLINK_REJ_F:
    if (pcch->ch_type EQ L2_CHANNEL_SACCH)
    {/*
      * There are some tests at the start of dl_uplink() to determine the right
      * SAPI value for SACCH. But the resulting value may be wrong because of
      * the priority arrangement according to 3GPP TS 04.05, section 4.2.2.
      * In case the MS has to uplink a REJ frame it is clear that
      * L2 is in acknowledged mode and this can be done only with
      * a SAPI value of 3 for SACCH.
      */
      sapi = PS_SAPI_3; /* acknowledged mode only for SAPI=3 */
      TRACE_EVENT_WIN ("SACCH with supervisory frame: acknowledged mode only for SAPI=3");
    }
    com_build_REJ_response (pcch->ch_type, sapi, pcch->vr,
                           (UBYTE)((send EQ UPLINK_REJ_F) ? 1 : 0));
    break;

  case UPLINK_REPORT:
    if (dl_data->RR_dedicated)
    {/* measurement report only in RR dedicated mode */
      sacch0_send_data ();
      com_l3trace (TRACE_UACK_UP, pcch->ch_type, (UBYTE *)p_l2_frame+5);


      /* no deleting of vtx!!! */
      return p_l2_frame;
      /* break; not necessary */
    }/* endif measurement report only in RR dedicated mode */

    /* else go through to UPLINK_EMPTY */
    /*lint -fallthrough*/

  default:
    possible_reset_dcch0_ch_type();

    /* check RR message with short PD, short L2 header type 1, format Bter */
    if ((dl_data->state[C_DCCH0] >= STATE_SUSPENDED) AND
         dl_data->rr_short_pd_buffer.l_buf AND
        (dl_data->rr_short_pd_ch_type EQ pcch->ch_type))
    { /* RR message with short PD, short L2 header type 1, format Bter */
      com_build_UI_Bter (pcch->ch_type);
      return p_l2_frame;
    }

    if (((pcch->ch_type EQ L2_CHANNEL_FACCH_F) OR
         (pcch->ch_type EQ L2_CHANNEL_FACCH_H))
        AND
        ((no_signalling_mode NEQ SIG_ONLY) 
#if defined(DELAYED_SABM)
        OR
         /* suppress UI frames if delayed SABM is pending
          * (independent from signalling mode) */
          (dl_data->dcch0_sabm_flag NEQ NOT_PRESENT_8BIT) 
#endif  /* DELAYED_SABM */
#if defined(DELAYED_RELEASE_IND)
        OR
         (dl_data->release_ind_ch_type NEQ NOT_PRESENT_8BIT)
#endif  /* DELAYED_RELEASE_IND */
       ))
    {
      TRACE_EVENT_WIN ("UPLINK_NULL return");
      return NULL;
    }
    /* break; not necessary */

    {
      T_RADIO_FRAME* empty_frame;

      TRACE_EVENT_WIN ("UPLINK_EMPTY return");
      /* The use of one byte array instead of two T_RADIO_FRAME structures
       * saves 21 byte. Casting is in this case the better way then two calls
       * of memcpy.
       */
      if (pcch->ch_type EQ L2_CHANNEL_SACCH)
        empty_frame = (T_RADIO_FRAME*)(&l2_empty_frame[0]);
      else
        empty_frame = (T_RADIO_FRAME*)(&l2_empty_frame[2]);

      ATRC (empty_frame, 23);

      return empty_frame;
    }
    /* break; not necessary */

  case UPLINK_DCCH3:
    return dl_uplink (C_DCCH3, PS_SAPI_3, no_signalling_mode, TRUE);
    /* break; not necessary */
  }/* endswitch send */


  /*
   * UPLINK_NORMAL, UPLINK_IFRAME (_P), UPLINK_UA (_F),
   * UPLINK_RR (_F), UPLINK_REJ (_F)
   */
  TRACE_EVENT_WIN_P5 ("%s SAPI=%u delete vtx=%s ->EMPTY_CMD (%s#%u)",
    CH_TYPE_NAME[pcch->ch_type], sapi, VTX_NAME[pcch->vtx], __FILE10__, __LINE__);
  pcch->vtx = EMPTY_CMD;

  possible_reset_dcch0_ch_type();

  return p_l2_frame;
}/* endfunc dl_uplink */

static int uplink_idle (UBYTE channel, UBYTE sapi)
{
  GET_INSTANCE_DATA;
  T_CCH*          pcch = &dl_data->cch[channel];
  int             ret = UPLINK_NORMAL;
  int             ua_response = FALSE;

  TRACE_EVENT_WIN_P3 ("uplink_idle(): %s %s SAPI=%d",
    PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi);

  switch (channel)
  {
  case C_DCCH0:
    switch (pcch->vtx)
    {
    case UA_CMD:
      ret = pcch->f_bit ? UPLINK_UA_F : UPLINK_UA;
      break;
    case DM_CMD:
      com_build_DM_response (pcch->ch_type, sapi, pcch->f_bit);
      break;
    default:
      ret = UPLINK_EMPTY;/* no SAPI=3 frame if DCCH0 is idle */
      break;
    }
    break;

  case C_DCCH3:
    switch (pcch->vtx)
    {
    case UA_CMD:
      ua_response = TRUE;
      ret = pcch->f_bit ? UPLINK_UA_F : UPLINK_UA;
      break;
    case DM_CMD:
      com_build_DM_response (pcch->ch_type, PS_SAPI_3, 1);
      ret = UPLINK_NORMAL;
      break;
    default:
      ret = UPLINK_EMPTY;
      break;
    }
    break;
  }/* endswitch channel */

  if (ua_response AND (ret EQ UPLINK_UA_F))
  {
    drr_dl_establish_ind (pcch->ch_type, sapi,
      (UBYTE)(com_queue_awaiting_transmission (sapi) ? DL_UNSERVED : DL_ALL_DONE));
    set_channel_state (channel, STATE_MULTIPLE_FRAME_ESTABLISHED);
  }

  return ret;
}/* endfunc uplink_idle */

static int uplink_awaiting_establishment (UBYTE channel, UBYTE sapi,
                                 UBYTE no_signalling_mode)
{
  GET_INSTANCE_DATA;
  T_CCH*  pcch = &dl_data->cch[channel];
  int   ret = UPLINK_NORMAL;
  int   ua_response = FALSE;
  int   sabm_command = 0;

  TRACE_EVENT_WIN_P3 ("uplink_awaiting_establishment(): %s %s SAPI=%d",
    PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi);

  if (pcch->time_flag)
    set_T200_counter (pcch, sapi);

  switch (channel)
  {
  case C_DCCH0:
    if (pcch->vtx EQ SABM_CMD)
    {
      if (pcch->contention_resolution)
        sabm_command = 2; /* com_build_SABM with L3 */
      else
        sabm_command = 1; /* com_build_SABM without L3 */
    }
    else
    {
      ret = UPLINK_EMPTY;/* no SAPI=0 frame is waiting transmission */
    }
    break;

  case C_DCCH3:
    switch (pcch->vtx)
    {
    case SABM_CMD:
      sabm_command = 1; /* com_build_SABM without L3 */
      break;
    case UA_CMD:
      ua_response = TRUE;
      break;
    case DM_CMD:
      com_build_DM_response (pcch->ch_type, sapi, pcch->f_bit);
      break;
    default:
      ret = UPLINK_EMPTY;
      break;
    }

    break;
  }

  if (ua_response)
  {
    drr_dl_establish_cnf (pcch->ch_type, sapi);
    set_channel_state (channel, STATE_MULTIPLE_FRAME_ESTABLISHED);

    ret = pcch->f_bit ? UPLINK_UA_F : UPLINK_UA;
  }
  else if (sabm_command)
  {
    com_build_SABM(pcch->ch_type, sapi, sabm_command EQ 2);
  }

  return ret;
}/* endfunc uplink_awaiting_establishment */

static int uplink_mfe (UBYTE channel, UBYTE sapi, UBYTE no_signalling_mode)
{
  GET_INSTANCE_DATA;
  T_CCH*  pcch = &dl_data->cch[channel];
  int   ret = UPLINK_NORMAL;

  TRACE_EVENT_WIN_P6 ("uplink_mfe(): %s:%s SAPI=%d vtx=%s (vs=%u va+1=%u)",
    PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi,
    VTX_NAME[pcch->vtx], pcch->vs, (pcch->va + 1)&7 );

  if (pcch->time_flag)
    set_T200_counter (pcch, sapi);

  switch (pcch->vtx)
  {
  case RR_CMD:
    if (pcch->f_bit_flag)
    {
      ret = UPLINK_RR_F;
      pcch->f_bit_flag = 0;
    }
    else
    {
      if (!com_queue_awaiting_transmission (sapi))
        ret = UPLINK_RR;
      else
      {
        if (pcch->vs EQ ((pcch->va + 1)&7))
          ret = UPLINK_RR;
        else
          ret = UPLINK_IFRAME;
      }
    }
    break;

  case UA_CMD:
    ret = pcch->f_bit ? UPLINK_UA_F : UPLINK_UA;
    break;

  case RR_RSP:
    ret = pcch->f_bit ? UPLINK_RR_F : UPLINK_RR;
    pcch->f_bit_flag = 0;
    break;

  case REJ_CMD:
    ret = pcch->f_bit ? UPLINK_REJ_F : UPLINK_REJ;
    pcch->f_bit_flag = 0;
    break;

  default:  /* vtx = ELSE */
    switch (channel)
    {
    case C_DCCH0:
      if (com_queue_awaiting_transmission (PS_SAPI_0)
            AND
          (pcch->vs NEQ ((pcch->va + 1)&7)))
        ret = UPLINK_IFRAME;
      else
      {
        ret = UPLINK_EMPTY;/* no SAPI=0 frame is waiting transmission */
      }
      break;

    case C_DCCH3:
      if (com_queue_awaiting_transmission (PS_SAPI_3))
      {
        if (pcch->vs EQ ((pcch->va + 1)&7))
          ret = UPLINK_EMPTY;
        else
          ret = UPLINK_IFRAME;
      }
      else
      {
        ret = dcch3_check_disc (UPLINK_EMPTY);/* no SAPI=3 frame is waiting transmission */
      }
      break;
    }/* endswitch channel */
    break;
  }/* endswitch vtx */


  return ret;
}/* endfunc uplink_mfe */

static int uplink_timer_recovery (UBYTE channel, UBYTE sapi, UBYTE no_signalling_mode)
{
  GET_INSTANCE_DATA;
  T_CCH*  pcch = &dl_data->cch[channel];
  int   ret = UPLINK_NORMAL;

  TRACE_EVENT_WIN_P3 ("uplink_timer_recovery(): %s %s SAPI=%d",
    PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi);

  if (pcch->time_flag)
    set_T200_counter (pcch, sapi);

  switch (pcch->vtx)
  {
  case RR_CMD:
    if (pcch->f_bit_flag)
    {
      ret = UPLINK_RR_F;
      pcch->f_bit_flag = 0;
    }
    else
    {
      if (pcch->p_bit_flag)
        ret = UPLINK_IFRAME_P;
      else
        ret = UPLINK_RR;
    }
    break;

  case UA_CMD:
    ret = pcch->f_bit ? UPLINK_UA_F : UPLINK_UA;
    break;

  case RR_RSP:
    ret = pcch->f_bit ? UPLINK_RR_F : UPLINK_RR;
    pcch->f_bit_flag = 0;
    break;

  case REJ_CMD:
    ret = pcch->f_bit ? UPLINK_REJ_F : UPLINK_REJ;
    pcch->f_bit_flag = 0;
    break;

  default:  /* vtx = ELSE */
    TRACE_EVENT_WIN_P3 ("%s SAPI=%u vtx=%s",
      CH_TYPE_NAME[pcch->ch_type], sapi, VTX_NAME[pcch->vtx]);

    if (pcch->p_bit_flag)
      ret = UPLINK_IFRAME_P;
    else
      switch (channel)
      {
      case C_DCCH0:
        ret = UPLINK_EMPTY;/* no SAPI=0 frame is waiting transmission */
        break;

      case C_DCCH3:
        ret = dcch3_check_disc (UPLINK_EMPTY);/* no SAPI=3 frame is waiting transmission */
        break;
      }
    break;
  }

#if 0 /* decrement first short before sending the frame */
  if (ret EQ UPLINK_IFRAME_P)
  {
    pcch->vs--;
    pcch->vs &= 7;
    pcch->p_bit_flag = 0;
  }
#endif /* 0 */
  return ret;
}/* endfunc uplink_timer_recovery */

GLOBAL int uplink_awaiting_release (UBYTE channel, UBYTE sapi)
{
  GET_INSTANCE_DATA;
  T_CCH*  pcch = &dl_data->cch[channel];
  int   ret = UPLINK_NORMAL;

  TRACE_EVENT_WIN_P3 ("uplink_awaiting_release(): %s %s SAPI=%d",
    PROCESS_NAME[channel], CH_TYPE_NAME[pcch->ch_type], sapi);

  if (pcch->time_flag)
    set_T200_counter (pcch, sapi);

  switch (pcch->vtx)
  {
  case DISC_CMD:
    /* DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, pcch->ch_type, "UL:Send DISC"); */
    com_build_DISC_command (pcch->ch_type, sapi, 1);
    break;
  case UA_CMD:
    set_channel_state (channel, STATE_IDLE_DL);

#if defined(DELAYED_RELEASE_IND)
    switch (pcch->ch_type)
    {
    #if defined(DL_FACCH_RELEASE_DELAY_VALUE) && (DL_FACCH_RELEASE_DELAY_VALUE > 0)
      case L2_CHANNEL_FACCH_F:
      case L2_CHANNEL_FACCH_H:
          /* delay DL RELEASE IND to RR for testcase 25.2.3 */
          dl_data->release_ind_ch_type = pcch->ch_type;
          dl_data->release_ind_sapi = sapi;
          if (dl_data->release_ind_delay EQ 0)
          {
            dl_data->release_ind_delay = DL_FACCH_RELEASE_DELAY_VALUE;
            DL_OFFLINE_TRACE (TRACE_DL_EVENT, C_DCCH0, pcch->ch_type, "delay REL IND on FACCH");
          }
        break;
    #endif /* DL_FACCH_RELEASE_DELAY_VALUE */
    #if defined(DL_SDCCH_RELEASE_DELAY_VALUE) && (DL_SDCCH_RELEASE_DELAY_VALUE > 0)
      case L2_CHANNEL_SDCCH:
          /* delay DL RELEASE IND to RR for testcase 25.2.3 */
          dl_data->release_ind_ch_type = pcch->ch_type;
          dl_data->release_ind_sapi = sapi;
          if (dl_data->release_ind_delay EQ 0)
          {
            dl_data->release_ind_delay = DL_SDCCH_RELEASE_DELAY_VALUE;
            DL_OFFLINE_TRACE (TRACE_DL_EVENT, channel, pcch->ch_type, "delay REL IND on SDCCH");
          }
        break;
    #endif /* DL_SDCCH_RELEASE_DELAY_VALUE */
      default:
        drr_dl_release_ind (pcch->ch_type, sapi, NOT_PRESENT_8BIT, TRUE);
        break;
    }
#else  /* DELAYED_RELEASE_IND */
    drr_dl_release_ind (pcch->ch_type, sapi, NOT_PRESENT_8BIT, TRUE);
#endif  /* DELAYED_RELEASE_IND */

#if defined(LATE_LEAVING_DEDICATED)
    com_leave_dedicated (pcch->ch_type);
#endif  /* LATE_LEAVING_DEDICATED */
    ret = UPLINK_UA_F;
    break;

  default:
    switch (pcch->ch_type)
    {
      case L2_CHANNEL_SACCH:
        if (channel EQ C_DCCH0)
          ret = UPLINK_REPORT;
        break;
      default:
        if (channel EQ C_DCCH0)
        {
          pcch = &dl_data->cch[C_DCCH3];
          if (pcch->time_flag)
            set_T200_counter (pcch, PS_SAPI_3);
        }
        ret = UPLINK_EMPTY;
      break;
    }/* endswitch channel */
  }/* endswitch vtx */

  return ret;
}/* endfunc uplink_awaiting_release */

#if defined(CHECK_PCCHI)
static void check_pcch_i (T_CCH_INTERN* pcch_i, int line)
{
  char buf[23];
  int ret = 0;

  if (pcch_i EQ NULL)
    ret = -1;
  else if (pcch_i->pcch EQ NULL)
    ret = -2;

  if (ret)
  {
    sprintf (buf, "#%d pcch=NULL %d", line, -ret);
    DL_OFFLINE_TRACE (TRACE_DL_EVENT, TRACE_CH_UNKNOWN, 0,buf);
  }

  return ret;
}/* endfunc check_pcch_i */
#endif  /* CHECK_PCCHI */

#endif /* DL_C */