/*
+-----------------------------------------------------------------------------
|  Project :  CSD (8411)
|  Modul   :  L2r_mgtp.c
+-----------------------------------------------------------------------------
|  Copyright 2002 Texas Instruments Berlin, AG
|                 All rights reserved.
|
|                 This file is confidential and a trade secret of Texas
|                 Instruments Berlin, AG
|                 The receipt of or possession of this file does not convey
|                 any rights to reproduce or disclose its contents or to
|                 manufacture, use, or sell anything it may describe, in
|                 whole, or in part, without the specific written consent of
|                 Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
|  Purpose :  This Modul defines the functions for processing
|             of incomming primitives for the component
|             Radio Link Protocol of the base station
+-----------------------------------------------------------------------------
*/

#ifndef L2R_MGTP_C
#define L2R_MGTP_C
#endif

#define ENTITY_L2R

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

#include <string.h>
#include "typedefs.h"
#include "pconst.cdg"
#include "vsi.h"
#include "macdef.h"
#include "custom.h"
#include "gsm.h"
#include "cus_l2r.h"
#include "cnf_l2r.h"
#include "mon_l2r.h"
#include "prim.h"
#include "pei.h"
#include "tok.h"
#include "dti.h"      /* functionality of the dti library */

#include "cl_ribu.h"
#include "l2r.h"

/*==== CONST =======================================================*/

/*==== TYPES =======================================================*/

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

/*==== VAR LOCAL ===================================================*/

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

GLOBAL void mgt_l2r_connect_cnf(UBYTE nack)
{
  PALLOC (l2r_connect_cnf, L2R_CONNECT_CNF);
  l2r_connect_cnf->ack_flg = nack;
  PSENDX (CTRL, l2r_connect_cnf);
}

LOCAL void snd_rlp_connect_res(UBYTE nack)
{
  PALLOC (rlp_connect_res, RLP_CONNECT_RES);
  rlp_connect_res->ack_flg = nack;
  PSENDX (RLP, rlp_connect_res);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_l2r_activate_req
+------------------------------------------------------------------------------
|  Description : Process primitive L2R_ACTIVATE_REQ  received from the Controller
|
|  Parameters  : l2r_activate_req -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_l2r_activate_req(T_L2R_ACTIVATE_REQ *l2r_activate_req)
{
  USHORT BytesPerPrim; /* Number of bytes per primitive */
  T_L2R_DATA *l2r_data_orig;

  TRACE_FUNCTION ("mgt_l2r_activate_req()");
  PACCESS        (l2r_activate_req);

  /***************************************
   *
   *  Initialize Shared Fax/Data memory  *
   *
   ***************************************
   */

  l2r_data_mode = NONTRANSP;

  l2r_data_orig = l2r_data;

  if (l2r_data_magic_num NEQ L2R_DATA_MAGIC_NUM)
  {
    l2r_data = &l2r_data_base[0];
  }

  memset (l2r_data, 0, sizeof (T_L2R_DATA));

  mgt_init(&l2r_data->mgt);
  dn_init(&l2r_data->dn);
  up_init(&l2r_data->up);

  l2r_data_magic_num = L2R_DATA_MAGIC_NUM; /* memory is initialized */

  l2r_data = l2r_data_orig;

  switch (GET_STATE (MGT))
  {
  case MGT_ATTACHED:
    {
    PPASS (l2r_activate_req, l2r_activate_cnf, L2R_ACTIVATE_CNF);
    l2r_activate_cnf->ack_flg = L2R_NAK;
    PSENDX (CTRL, l2r_activate_cnf);
    break;
    }

  case MGT_DETACHED:
    if (mgt_checkpar(l2r_activate_req) EQ FALSE) /* invalid parameter values */
    {
      PPASS (l2r_activate_req, l2r_activate_cnf, L2R_ACTIVATE_CNF);
      l2r_activate_cnf->ack_flg = L2R_NAK;
      PSENDX (CTRL, l2r_activate_cnf);
      return;
    }

    {
    T_MGT *dmgt = &l2r_data->mgt;

    PALLOC (rlp_attach_req, RLP_ATTACH_REQ);

    rlp_attach_req->k_ms_iwf        = l2r_activate_req->k_ms_iwf;
    rlp_attach_req->k_iwf_ms        = l2r_activate_req->k_iwf_ms;
    rlp_attach_req->t1              = l2r_activate_req->t1;
    rlp_attach_req->t2              = l2r_activate_req->t2;
    rlp_attach_req->n2              = l2r_activate_req->n2;
    rlp_attach_req->pt              = l2r_activate_req->pt;
    rlp_attach_req->p1              = l2r_activate_req->p1;
    rlp_attach_req->p2              = l2r_activate_req->p2;
    rlp_attach_req->bytes_per_prim  = l2r_activate_req->bytes_per_prim;

    switch (l2r_activate_req->uil2p)
    {
    case L2R_COPnoFlCt:
      dmgt->FlowCtrlUsed = FALSE;
      break;
    case L2R_ISO6429:
      dmgt->FlowCtrlUsed = TRUE;
      break;
    }

    switch (l2r_activate_req->rate)
    {
    case L2R_FULLRATE_14400:
      rlp_attach_req->rate = RLP_FULLRATE_14400;
      dmgt->FrameSize = RLP_FRAME_SIZE_LONG;
      break;

    case L2R_FULLRATE_9600:
      rlp_attach_req->rate = RLP_FULLRATE_9600;
      dmgt->FrameSize = RLP_FRAME_SIZE_SHORT;
      break;

    case L2R_FULLRATE_4800:
      rlp_attach_req->rate = RLP_FULLRATE_4800;
      dmgt->FrameSize = RLP_FRAME_SIZE_SHORT;
      break;

    case L2R_HALFRATE_4800:
      rlp_attach_req->rate = RLP_HALFRATE_4800;
      dmgt->FrameSize = RLP_FRAME_SIZE_SHORT;
      break;
    }

    BytesPerPrim        = l2r_activate_req->bytes_per_prim;
    dmgt->FramesPerPrim = (BytesPerPrim + dmgt->FrameSize - 1) / dmgt->FrameSize;
    dmgt->RiBuSize      = ((l2r_activate_req->buffer_size + BytesPerPrim - 1) / BytesPerPrim) + 1;

    if (dmgt->RiBuSize < MIN_RIBU_SIZE)
    {
      dmgt->RiBuSize = MIN_RIBU_SIZE;
    }

    rlp_attach_req->p0 = RLP_COMP_DIR_NONE;
    PSENDX (RLP, rlp_attach_req);
    SET_STATE (CONIND, IW_IDLE);
    SET_STATE (MGT, MGT_PENDING_ATTACH);
    break;
    }
  }
  PFREE (l2r_activate_req);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_l2r_deactivate_req
+------------------------------------------------------------------------------
|  Description : Process primitive L2R_DEACTIVATE_REQ received from the Controller.
|
|  Parameters  : l2r_deactivate_req -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_l2r_deactivate_req
                  (
                    T_L2R_DEACTIVATE_REQ *l2r_deactivate_req
                  )
{
  TRACE_FUNCTION ("mgt_l2r_deactivate_req()");
  PACCESS        (l2r_deactivate_req);

  if (GET_STATE (MGT) NEQ MGT_DETACHED)
  {
    PALLOC (rlp_detach_req, RLP_DETACH_REQ);
    mgt_deinit_connection();
    PSENDX (RLP, rlp_detach_req);
    SET_STATE (MGT, MGT_PENDING_DETACH);
  }

  PFREE (l2r_deactivate_req);

  if (GET_STATE (DTI) NEQ DTI_CLOSED)
  {
    dti_close(l2r_hDTI, L2R_DTI_UP_DEF_INSTANCE, L2R_DTI_UP_INTERFACE, L2R_DTI_UP_CHANNEL, FALSE);
    SET_STATE (DTI, DTI_CLOSED);
  }
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_l2r_connect_req
+------------------------------------------------------------------------------
|  Description : Process primitive L2R_CONNECT_REQ received from the Controller.
|
|  Parameters  : l2r_connect_req -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_l2r_connect_req(T_L2R_CONNECT_REQ *l2r_connect_req)
{
  TRACE_FUNCTION ("mgt_l2r_connect_req()");
  PACCESS        (l2r_connect_req);

  if (GET_STATE (MGT) EQ MGT_ATTACHED)
  {
    PALLOC (rlp_connect_req, RLP_CONNECT_REQ);
    PSENDX (RLP, rlp_connect_req);
    SET_STATE (MGT, MGT_PENDING_CONNECT);
  }
  PFREE (l2r_connect_req);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_l2r_disc_req
+------------------------------------------------------------------------------
|  Description : Process primitive L2R_DISC_REQ received from the Controller.
|
|  Parameters  : l2r_disc_req -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_l2r_disc_req(T_L2R_DISC_REQ *l2r_disc_req)
{
  TRACE_FUNCTION ("mgt_l2r_disc_req()");
  PACCESS        (l2r_disc_req);

  switch (GET_STATE (MGT))
  {
  case MGT_DETACHED:
  case MGT_PENDING_ATTACH:
  case MGT_ATTACHED:
    break;

  default:
    {
    PALLOC (rlp_disc_req, RLP_DISC_REQ);
    PSENDX (RLP, rlp_disc_req);
    mgt_deinit_connection();
    SET_STATE (MGT, MGT_DISCONNECT_INITIATED);
    break;
    }
  }
  PFREE (l2r_disc_req);
}

LOCAL void send_l2r_dti_cnf(U8 dti_conn, U32 link_id)
{
  PALLOC (l2r_dti_cnf, L2R_DTI_CNF);
  l2r_dti_cnf->dti_conn = dti_conn;
  l2r_dti_cnf->link_id = link_id;
  PSENDX (CTRL, l2r_dti_cnf);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_l2r_dti_req
+------------------------------------------------------------------------------
|  Description : Process primitive L2R_DTI_REQ received from the Controller.
|
|  Parameters  : l2r_dti_req -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_l2r_dti_req(T_L2R_DTI_REQ *l2r_dti_req)
{
  BOOL isOK;

  TRACE_FUNCTION ("mgt_l2r_dti_req()");
  PACCESS        (l2r_dti_req);

  switch (GET_STATE (MGT))
  {
  case MGT_CONNECTED:
    switch (l2r_dti_req->dti_conn)
    {
    case L2R_CONNECT_DTI:
      l2r_data->mgt.link_id = l2r_dti_req->link_id;

      if (GET_STATE (DTI) NEQ DTI_CLOSED)
      {
        dti_close(l2r_hDTI, L2R_DTI_UP_DEF_INSTANCE, L2R_DTI_UP_INTERFACE, L2R_DTI_UP_CHANNEL, FALSE);
        SET_STATE (DTI, DTI_CLOSED);
      }
      /*
       * open new dti library communication channel
       */
      INIT_STATE (DTI, DTI_SETUP);
      sig_mgt_up_dti_conn_setup (l2r_dti_req->link_id);
      sig_mgt_dn_dti_conn_setup (l2r_dti_req->link_id);

      isOK = dti_open (
        l2r_hDTI,
        L2R_DTI_UP_DEF_INSTANCE,
        L2R_DTI_UP_INTERFACE,
        L2R_DTI_UP_CHANNEL,
        L2R_DTI_UPLINK_QUEUE_SIZE,
        l2r_dti_req->dti_direction,
        DTI_QUEUE_UNUSED,
        DTI_VERSION_10,
        (U8*)l2r_dti_req->entity_name,
        l2r_dti_req->link_id
        );

      if (isOK EQ FALSE)
      {
        send_l2r_dti_cnf(L2R_DISCONNECT_DTI, l2r_dti_req->link_id);
        SET_STATE (DTI, DTI_CLOSED);
        PFREE(l2r_dti_req);
        return;
      }
      PFREE(l2r_dti_req);
      /*
       * L2R_DTI_CNF will be sent in sig_dti_mgt_connection_opened_ind
       */
      return;

    case L2R_DISCONNECT_DTI:
      l2r_data->up.DtiConnected = FALSE;
      l2r_data->dn.DtiConnected = FALSE;
      /*
      TRACE_EVENT_P2 ("Air interface: Received:%d Sent:%d", l2r_data->dn.RcvdChar, l2r_data->up.SentChar);
      */
      if (GET_STATE (DTI) NEQ DTI_CLOSED)
      {
        dti_close(l2r_hDTI, L2R_DTI_UP_DEF_INSTANCE, L2R_DTI_UP_INTERFACE, L2R_DTI_UP_CHANNEL, FALSE);
        SET_STATE (DTI, DTI_CLOSED);
      }
      TRACE_EVENT("MGT: DTI snatched away by ACI");
      break;
    }
    send_l2r_dti_cnf(l2r_dti_req->dti_conn, l2r_dti_req->link_id);
    break;

  default:
    break;
  }
  PFREE(l2r_dti_req);
}


/*
+------------------------------------------------------------------------------
|  Function    : sig_dti_mgt_connection_opened_ind
+------------------------------------------------------------------------------
| Description : Handles the DTILIB callback call DTI_REASON_CONNECTION_OPENED
|
|               This signal means that a dti connection has been opened
|               successfully.
|               Since it is called directy from the dtilib callback function
|               it is handled like a primitive, here..
|
|  Parameters  : -
|  Return      : -
+------------------------------------------------------------------------------
*/
GLOBAL void sig_dti_mgt_connection_opened_ind()
{
  TRACE_FUNCTION ("sig_dti_mgt_connection_opened_ind()");

  if (GET_STATE (DTI) EQ DTI_SETUP)
  {
    send_l2r_dti_cnf(L2R_CONNECT_DTI, l2r_data->mgt.link_id);
    sig_mgt_up_dti_conn_open();

    l2r_data->dn.DtiConnected = TRUE;
    TRACE_EVENT("MGT: DTI received from ACI");
    SET_STATE (DTI, DTI_IDLE);
  }
}

/*
+------------------------------------------------------------------------------
|  Function    : sig_dti_mgt_connection_closed_ind
+------------------------------------------------------------------------------
| Description : Handles the DTILIB callback call DTI_REASON_CONNECTION_CLOSED
|
|               This signal means that a dti connection has been closed
|               Since it is called directy from the dtilib callback function
|               it is handled like a primitive, here..
|
|  Parameters  : -
|  Return      : -
+------------------------------------------------------------------------------
*/
GLOBAL void sig_dti_mgt_connection_closed_ind()
{
  TRACE_FUNCTION ("sig_dti_mgt_connection_closed_ind()");

  if (GET_STATE (DTI) NEQ DTI_CLOSED)
  {
    PALLOC (l2r_dti_ind, L2R_DTI_IND);

    SET_STATE (DTI, DTI_CLOSED);

    l2r_data->up.DtiConnected = FALSE;
    l2r_data->dn.DtiConnected = FALSE;

    l2r_dti_ind->link_id = l2r_data->mgt.link_id;
    TRACE_EVENT("MGT: DTI passed to ACI");
    PSENDX (CTRL, l2r_dti_ind);
  }
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_connect_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_CONNECT_IND received from RLP.
|
|  Parameters  : rlp_connect_ind -
|
|
|  Return      :
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_rlp_connect_ind(T_RLP_CONNECT_IND *rlp_connect_ind)
{
  TRACE_FUNCTION ("mgt_rlp_connect_ind()");
  PACCESS        (rlp_connect_ind);

  switch (GET_STATE (MGT))
  {
  case MGT_PENDING_ATTACH:
    SET_STATE (CONIND, IW_WAIT);
    break;

  case MGT_ATTACHED:
    snd_rlp_connect_res(RLP_ACK);
    mgt_init_connection(TRUE);
    SET_STATE (MGT, MGT_CONNECTED);
    break;

  case MGT_PENDING_CONNECT:
    snd_rlp_connect_res(RLP_ACK);
    mgt_init_connection(FALSE);
    SET_STATE (MGT, MGT_CONNECTED);
    break;
  }
  PFREE (rlp_connect_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_connect_cnf
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_CONNECT_CNF received from RLP.
|
|  Parameters  : rlp_connect_cnf -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_rlp_connect_cnf(T_RLP_CONNECT_CNF *rlp_connect_cnf)
{
  TRACE_FUNCTION ("mgt_rlp_connect_cnf()");
  PACCESS        (rlp_connect_cnf);

  if (GET_STATE (MGT) EQ MGT_PENDING_CONNECT)
  {
    switch (rlp_connect_cnf->ack_flg)
    {
    case RLP_ACK:
      mgt_init_connection(FALSE);
      SET_STATE (MGT, MGT_CONNECTED);
      break;

    case RLP_NAK:
      mgt_l2r_connect_cnf(L2R_NAK);
      SET_STATE (MGT, MGT_ATTACHED);
      break;
    }
  }
  PFREE (rlp_connect_cnf);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_disc_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_DISC_IND received from RLP.
|
|  Parameters  : rlp_disc_ind -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_rlp_disc_ind(T_RLP_DISC_IND *rlp_disc_ind)
{
  TRACE_FUNCTION ("mgt_rlp_disc_ind()");
  PACCESS        (rlp_disc_ind);

  switch (GET_STATE (MGT))
  {
  case MGT_PENDING_CONNECT:
    mgt_l2r_connect_cnf(L2R_NAK);
    SET_STATE (MGT, MGT_ATTACHED);
    break;

  case MGT_CONNECTED:
    {
    PALLOC (l2r_disc_ind, L2R_DISC_IND);
    PSENDX (CTRL, l2r_disc_ind);
    }
    mgt_deinit_connection();
    SET_STATE (MGT, MGT_ATTACHED);
    break;
  }
  PFREE (rlp_disc_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_disc_cnf
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_DISC_CNF received from RLP.
|
|  Parameters  : rlp_disc_cnf -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_rlp_disc_cnf
                  (
                    T_RLP_DISC_CNF       *rlp_disc_cnf
                  )
{
  TRACE_FUNCTION ("mgt_rlp_disc_cnf()");
  PACCESS        (rlp_disc_cnf);

  switch (GET_STATE (MGT))
  {
  case MGT_DISCONNECT_INITIATED:
    {
     /*
      * processing for state MGT_DISCONNECT_INITIATED
      */
      PALLOC (l2r_disc_cnf, L2R_DISC_CNF);
      PSENDX (CTRL, l2r_disc_cnf);
      SET_STATE (MGT, MGT_ATTACHED);
      break;
    }
  }
  PFREE (rlp_disc_cnf);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_reset_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_RESET_IND received from RLP.
|
|  Parameters  : rlp_reset_ind -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_rlp_reset_ind
                  (
                    T_RLP_RESET_IND      *rlp_reset_ind
                  )
{
  TRACE_FUNCTION ("mgt_rlp_reset_ind()");
  PACCESS        (rlp_reset_ind);

  switch (GET_STATE (MGT))
  {
  case MGT_CONNECTED:
    {
     /*
      * processing for state MGT_CONNECTED
      */
      {
        PALLOC (l2r_reset_ind, L2R_RESET_IND);
        PSENDX (CTRL, l2r_reset_ind);
      }
      sig_mgt_up_clear_req();
      sig_mgt_dn_clear_req();

      {
        PALLOC (rlp_reset_res, RLP_RESET_RES);
        PSENDX (RLP, rlp_reset_res);
      }
      sig_mgt_dn_reconn_req();
      break;
    }
  }
  PFREE (rlp_reset_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_reset_cnf
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_RESET_CNF received from RLP.
|
|  Parameters  : rlp_reset_cnf -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_rlp_reset_cnf
                  (
                    T_RLP_RESET_CNF      *rlp_reset_cnf
                  )
{
  TRACE_FUNCTION ("mgt_rlp_reset_cnf()");
  PACCESS        (rlp_reset_cnf);
  /*
   * RLP_RESET_REQ is never used.
   * Therefore RLP_RESET_CNF does not need to be handled.
   */
  PFREE (rlp_reset_cnf);
}

/*
+------------------------------------------------------------------------------
|  Function    :  mgt_rlp_ui_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_UI_IND received from RLP.
|
|  Parameters  : rlp_ui_ind -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/


GLOBAL void mgt_rlp_ui_ind(T_RLP_UI_IND *rlp_ui_ind)
{
  TRACE_FUNCTION ("mgt_rlp_ui_ind()");
  PACCESS        (rlp_ui_ind);
  /*
  * processing for all states
  * unnumbered information is ignored by L2R
  */
  PFREE (rlp_ui_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_xid_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_XID_IND received from RLP.
|
|  Parameters  : rlp_xid_ind -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_rlp_xid_ind(T_RLP_XID_IND *rlp_xid_ind)
{
  UBYTE state;
  TRACE_FUNCTION ("mgt_rlp_xid_ind()");
  PACCESS        (rlp_xid_ind);

  state = GET_STATE (MGT);
  switch (state)
  {
  case MGT_PENDING_ATTACH:
  case MGT_ATTACHED:
  case MGT_PENDING_CONNECT:
  case MGT_CONNECTED:
    {
     /*
      * processing for states MGT_PENDING_ATTACH, MGT_ATTACHED,
      * MGT_PENDING_CONNECT and MGT_CONNECTED
      */

      PALLOC (l2r_xid_ind, L2R_XID_IND);

      l2r_xid_ind->rlp_vers = rlp_xid_ind->rlp_vers;
      l2r_xid_ind->k_ms_iwf = rlp_xid_ind->k_ms_iwf;
      l2r_xid_ind->k_iwf_ms = rlp_xid_ind->k_iwf_ms;
      l2r_xid_ind->t1       = rlp_xid_ind->t1;
      l2r_xid_ind->t2       = rlp_xid_ind->t2;
      l2r_xid_ind->n2       = rlp_xid_ind->n2;
      l2r_xid_ind->pt       = rlp_xid_ind->pt;
      l2r_xid_ind->p0       = rlp_xid_ind->p0;
      l2r_xid_ind->p1       = rlp_xid_ind->p1;
      l2r_xid_ind->p2       = rlp_xid_ind->p2;

      PSENDX (CTRL, l2r_xid_ind);
      if (state EQ MGT_PENDING_ATTACH)
      {
        {
          PALLOC (l2r_activate_cnf, L2R_ACTIVATE_CNF);
          l2r_activate_cnf->ack_flg = L2R_ACK;
          PSENDX (CTRL, l2r_activate_cnf);
        }

        switch (GET_STATE (CONIND))
        {
        case IW_IDLE:
          {
            SET_STATE (MGT, MGT_ATTACHED);
            break;
          }
        case IW_WAIT:
          snd_rlp_connect_res(RLP_ACK);
          mgt_init_connection(TRUE);
          SET_STATE (MGT, MGT_CONNECTED);
          break;
        }
      }
      break;
    }
  }
  PFREE (rlp_xid_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_error_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_ERROR_IND received from RLP.
|
|  Parameters  : rlp_error_ind -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_rlp_error_ind(T_RLP_ERROR_IND *rlp_error_ind)
{
  TRACE_FUNCTION ("mgt_rlp_error_ind()");
  PACCESS        (rlp_error_ind);

  mgt_send_l2r_error_ind(rlp_error_ind->cause);
  SET_STATE (MGT, MGT_PERMANENT_ERROR);
  PFREE (rlp_error_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_statistic_ind
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_STATISTIC_IND received from RLP.
|
|  Parameters  : rlp_statistic_ind -
|
|
|  Return      :
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_rlp_statistic_ind
                  (
                    T_RLP_STATISTIC_IND *rlp_statistic_ind
                  )
{
  TRACE_FUNCTION ("mgt_rlp_statistic_ind()");
  PACCESS        (rlp_statistic_ind);
  {
  PALLOC (l2r_statistic_ind, L2R_STATISTIC_IND);
  l2r_statistic_ind->error_rate = rlp_statistic_ind->error_rate;
  PSENDX (CTRL, l2r_statistic_ind);
  }
  PFREE (rlp_statistic_ind);
}

/*
+------------------------------------------------------------------------------
|  Function    : mgt_rlp_detach_cnf
+------------------------------------------------------------------------------
|  Description : Process primitive RLP_DETACH_CNF received from RLP.
|
|  Parameters  : rlp_detach_cnf -
|
|
|  Return      : -
+------------------------------------------------------------------------------
*/

GLOBAL void mgt_rlp_detach_cnf(T_RLP_DETACH_CNF *rlp_detach_cnf)
{
  TRACE_FUNCTION ("mgt_rlp_detach_cnf()");
  PACCESS        (rlp_detach_cnf);

  switch (GET_STATE (MGT))
  {
  case MGT_PENDING_DETACH:
    {
    PPASS (rlp_detach_cnf, l2r_deactivate_cnf, L2R_DEACTIVATE_CNF);
    PSENDX (CTRL, l2r_deactivate_cnf);
    SET_STATE (MGT, MGT_DETACHED);
    l2r_data_magic_num = 0;       /* memory is no more initialized */
    break;
    }

  default:
    PFREE (rlp_detach_cnf);
    break;
  }
}