/* 
+----------------------------------------------------------------------------- 
|  Project :  
|  Modul   :  
+----------------------------------------------------------------------------- 
|  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 is part of the entity PPP and implements all
|             functions to handles the incoming process internal signals as
|             described in the SDL-documentation (PTX-statemachine)
+----------------------------------------------------------------------------- 
*/ 

#define ENTITY_PPP

/*
 * define for ptxs debug traces
 */
/* #define PTXS_DEBUG */

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

#include "typedefs.h"   /* to get Condat data types */
#include "vsi.h"        /* to get a lot of macros */
#include "macdef.h"     /* to get a lot of macros */
#include "custom.h"     /* to get a lot of macros */
#include "gsm.h"        /* to get a lot of macros */
/*lint -efile(766,cnf_ppp.h) */
#include "cnf_ppp.h"    /* to get cnf-definitions */
/*lint -efile(766,mon_ppp.h) */
#include "mon_ppp.h"    /* to get mon-definitions */
#include "prim.h"       /* to get the definitions of used SAP and directions */
#include "dti.h"        /* to get the DTILIB definitions */
#include "ppp.h"        /* to get the global entity definitions */

#include "ppp_dti.h"    /* to get the local DTILIB definitions */
#include "ppp_frxs.h"   /* to get signal interface from frx */
#include "ppp_arbs.h"   /* to get signal interface from arb */

#include "ppp_arbf.h"   /* to get arb functions */

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

/*==== LOCAL VARS ===========================================================*/

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

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



/*
+------------------------------------------------------------------------------
| Function    : sig_arb_ptx_dead_mode_req
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_ARB_PTX_DEAD_MODE_REQ. It sets
|               the frame-reception-packet-transission direction to DEAD mode.
|               That means these two services will not receive or send any more
|               data.
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_arb_ptx_dead_mode_req ()
{
  TRACE_ISIG( "sig_arb_ptx_dead_mode_req" );

  ppp_data->ptx.ftx_buffer_state = PTX_FTX_BUFFER_FULL;
  ppp_data->ptx.ptx_buffer_state = PTX_BUFFER_FULL;

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_READY:
    case PTX_BLOCKED:
      SET_STATE( PPP_SERVICE_PTX, PTX_DEAD );
      sig_ptx_frx_stop_flow_req();
      break;

    default:
      TRACE_ERROR( "SIG_ARB_PTX_DEAD_MODE_REQ unexpected" );
      break;
  }
  
  /*
   * set FRX to dead mode
   */
  sig_ptx_frx_dead_mode_req();

} /* sig_arb_ptx_dead_mode_req() */



/*
+------------------------------------------------------------------------------
| Function    : sig_arb_ptx_ready_mode_req
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_ARB_PTX_READY_MODE_REQ. It sets
|               the frame-reception-packet-transission direction to READY mode.
|               That means these two services will receive and send data.
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_arb_ptx_ready_mode_req ()
{
  TRACE_ISIG( "sig_arb_ptx_ready_mode_req" );

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_BLOCKED:
      SET_STATE( PPP_SERVICE_PTX, PTX_READY );
      /*
       * incoming data flow had not been stopped but redirected to
       * ARB, so normally don't need to start, but it is possible that the data flow  
       * has been stopped bacause of ftx_buffer_full_ind
       */
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_READY AND
         ppp_data->ptx.ptx_buffer_state EQ PTX_BUFFER_READY        )
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(READY_MODE_REQ): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      /* 
       * data is to be sent directly to the peer, and the dtilib buffer is
       * full, so stop incoming data flow.
       */
      if(ppp_data->ptx.ptx_buffer_state EQ PTX_BUFFER_FULL)
      {
        sig_ptx_frx_stop_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("INFO(READY_MODE_REQ): UL data flow wasn't stopped, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    case PTX_DEAD:
      /*
       * incoming data is to be redirected to ARB
       */
      SET_STATE( PPP_SERVICE_PTX, PTX_READY);
      sig_ptx_frx_ready_mode_req();
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_READY AND
         ppp_data->ptx.ptx_buffer_state EQ PTX_BUFFER_READY        )
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(READY_MODE_REQ): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    default:
      TRACE_ERROR( "SIG_ARB_PTX_READY_MODE_REQ unexpected" );
      break;
  }
} /* sig_arb_ptx_ready_mode_req() */



/*
+------------------------------------------------------------------------------
| Function    : sig_arb_ptx_blocked_mode_req
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_ARB_PTX_BLOCKED_MODE_REQ. It
|               sets the frame-reception-packet-transission direction to
|               BLOCKED mode. That means PPP receives frames, but it dos not
|               send packts.
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_arb_ptx_blocked_mode_req ()
{
  TRACE_ISIG( "sig_arb_ptx_blocked_mode_req" );

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_DEAD:
      /* 
       * Start incoming data flow - data will be sent to ARB.
       */
      SET_STATE( PPP_SERVICE_PTX, PTX_BLOCKED);
      sig_ptx_frx_ready_mode_req();
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_READY)
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(BLOCKED_MODE_REQ): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    case PTX_READY:
      /*
       * Do not stop incoming data flow, just redirect it to ARB
       * Restart incoming data flow if it should be now redirected to ARB
       */
      SET_STATE( PPP_SERVICE_PTX, PTX_BLOCKED );
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_READY AND
         ppp_data->ptx.ptx_buffer_state EQ PTX_BUFFER_FULL         )
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(BLOCKED_MODE_REQ): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    default:
      TRACE_ERROR( "SIG_ARB_PTX_BLOCKED_MODE_REQ unexpected" );
      break;
  }
} /* sig_arb_ptx_blocked_mode_req() */



/*
+------------------------------------------------------------------------------
| Function    : sig_arb_ptx_transparent_mode_req
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_ARB_PTX_TRANSPARENT_MODE_REQ.
|               It sets the frame-reception-packet-transission direction to
|               TRANSPARENT mode. That means PPP receives frames and sends
|               these frame transparent to the upper layer.
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_arb_ptx_transparent_mode_req ()
{
  TRACE_ISIG( "sig_arb_ptx_transparent_mode_req" );

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_DEAD:
      /*
       * Set ptx to transparent mode and enable incoming data flow.
       * The dti connection has been newly opened so that its buffers
       * are empty and data can be received
       */
      SET_STATE( PPP_SERVICE_PTX, PTX_READY );
      sig_ptx_frx_transparent_mode_req();
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_READY AND
         ppp_data->ptx.ptx_buffer_state EQ PTX_BUFFER_READY        )
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(TRANSP_MODE_REQ): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    default:
      TRACE_ERROR( "SIG_ARB_PTX_TRANSPARENT_MODE_REQ unexpected" );
      break;
  }
} /* sig_arb_ptx_transparent_mode_req() */

/*
+------------------------------------------------------------------------------
| Function    : sig_frx_ptx_packet_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_FRX_PTX_PACKET_IND. The service
|               FRX received a complete frame and forwards the encapsulated
|               packet to PTX.
|
| Parameters  : ptype      - type of packet
|               packet_len - length of packet
|               packet     - pointer to a generic data descriptor
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_frx_ptx_packet_ind (USHORT ptype,
                                    USHORT packet_len,
                                    T_desc2* packet)
{
  TRACE_ISIG( "sig_frx_ptx_packet_ind" );

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_READY:
      switch(ptype)
      {
        case DTI_PID_CTCP:
        case DTI_PID_UTCP:
          /*
           * if Van Jacobson Header Compression is not negotiated such packets
           * will not be sent to upper layer
           */
          if(ppp_data->n_hc NEQ PPP_HC_VJ)
          {
            sig_ptx_arb_packet_ind(ptype, packet);
            if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_FULL)
            {
              sig_ptx_frx_stop_flow_req();
              #ifdef PTXS_DEBUG
              TRACE_EVENT_P2("INFO(PTX_PACKET_IND): UL data flow was stopped, %s(%d)", __FILE__, __LINE__);
              #endif /* PTXS_DEBUG */
            }
            break;
          }
          /* fall through */
        case DTI_PID_IP:
        case DTI_PID_UOS:
          /*
           * send packet to upper layer
           */
          {
            PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND);

            dti_data_ind->desc_list2.list_len = packet_len;
            dti_data_ind->desc_list2.first    = (ULONG)packet;

            /*
             *  Send the DTI data primitive
             */

            sig_any_dti_data_ind(ppp_data->ppphDTI,
                                 dti_data_ind,
                                 PPP_INSTANCE, PROT_LAYER,
                                 PROT_CHANNEL,(UBYTE)ptype);
          }
          break;

        default:
          /*
           * received packet is nether an IP packet nor
           * a PPP frame (transparent mode), so we forward it to ARB
           */
          sig_ptx_arb_packet_ind(ptype, packet);
          if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_FULL)
          {
            sig_ptx_frx_stop_flow_req();
            #ifdef PTXS_DEBUG
            TRACE_EVENT_P2("INFO(PTX_PACKET_IND): UL data flow was stopped, %s(%d)", __FILE__, __LINE__);
            #endif /* PTXS_DEBUG */
          }
          break;
      }
    break;

    case PTX_BLOCKED:
      /*
       * In BLOCKED mode we forward each packet to ARB
       */
      sig_ptx_arb_packet_ind(ptype, packet);
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_FULL)
      {
        sig_ptx_frx_stop_flow_req();
        #ifdef PTXS_DEBUG
        TRACE_EVENT_P2("INFO(PTX_PACKET_IND): UL data flow was stopped, %s(%d)", __FILE__, __LINE__);
        #endif /* PTXS_DEBUG */
      }
      break;

    default:
      TRACE_ERROR( "SIG_FRX_PTX_PACKET_IND unexpected" );
      arb_discard_packet(packet);
      break;
  }
} /* sig_frx_ptx_packet_ind() */

/*
+------------------------------------------------------------------------------
| Function    : sig_dti_ptx_tx_buffer_ready_ind
+------------------------------------------------------------------------------
| Description : Handles the signal sig_dti_ptx_tx_buffer_ready_ind
|
| Parameters  : no parameter
|
+------------------------------------------------------------------------------
*/

GLOBAL void sig_dti_ptx_tx_buffer_ready_ind ()
{
  TRACE_FUNCTION( "sig_dti_ptx_tx_buffer_ready_ind" );

  ppp_data->ptx.ptx_buffer_state = PTX_BUFFER_READY;

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_READY:
      if(ppp_data->ptx.ftx_buffer_state EQ PTX_FTX_BUFFER_READY)
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(BUFFER_READY_IND): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    case PTX_BLOCKED:
    case PTX_DEAD:
      /* wait for sig_arb_ptx_blocked/ready/transparent_mode_req */
      break;

    default:
      TRACE_ERROR( "DTI signal unexpected" );
      break;
  }
} /* sig_dti_ptx_tx_buffer_ready_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_dti_ptx_tx_buffer_full_ind
+------------------------------------------------------------------------------
| Description : This function handle the signal sig_dti_ptx_tx_buffer_full_ind
|
| Parameters  : no parameter
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_dti_ptx_tx_buffer_full_ind ()
{
  TRACE_FUNCTION ("sig_dti_ptx_tx_buffer_full_ind()");

  ppp_data->ptx.ptx_buffer_state = PTX_BUFFER_FULL;

  switch( GET_STATE( PPP_SERVICE_PTX ) )
    {
      case PTX_READY:
        sig_ptx_frx_stop_flow_req();
        break;

      case PTX_DEAD:
        break;

      case PTX_BLOCKED:
        /*
         * do not stop incoming data flow here since data is not sent
         * to the peer but to ARB, not having to be buffered in dtilib
         */
        break;

      default:
        TRACE_ERROR("Wrong state");
        break;
    }
} /* sig_dti_ptx_tx_buffer_full_ind() */


/*
+------------------------------------------------------------------------------
| Function    : sig_ftx_ptx_tx_buffer_full_ind
+------------------------------------------------------------------------------
| Description : This function handle the signal sig_ftx_ptx_tx_buffer_full_ind
|
| Parameters  : no parameter
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ftx_ptx_buffer_full_ind ()
{
  TRACE_FUNCTION ("sig_ftx_ptx_tx_buffer_full_ind()");

  ppp_data->ptx.ftx_buffer_state = PTX_FTX_BUFFER_FULL;

} /* sig_ftx_ptx_tx_buffer_full_ind() */


/*
+------------------------------------------------------------------------------
| Function    : sig_ftx_ptx_tx_buffer_ready_ind
+------------------------------------------------------------------------------
| Description : This function handle the signal sig_ftx_ptx_tx_buffer_ready_ind
|
| Parameters  : no parameter
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ftx_ptx_buffer_ready_ind ()
{
  TRACE_FUNCTION ("sig_ftx_ptx_tx_buffer_ready_ind()");

  ppp_data->ptx.ftx_buffer_state = PTX_FTX_BUFFER_READY;

  switch( GET_STATE( PPP_SERVICE_PTX ) )
  {
    case PTX_READY:
      if(ppp_data->ptx.ptx_buffer_state EQ PTX_BUFFER_READY)
      {
        sig_ptx_frx_start_flow_req();
      }
      #ifdef PTXS_DEBUG
      else
      {
        TRACE_EVENT_P2("WARNING(FTX_BUFFER_READY_IND): UL data flow wasn't started, %s(%d)", __FILE__, __LINE__);
      }
      #endif /* PTXS_DEBUG */
      break;

    case PTX_BLOCKED:
        /*
         * Start data flow also if PTX buffer is full,
         * because the data will be redirected to ARB.
         */
        sig_ptx_frx_start_flow_req();
      break;

    case PTX_DEAD:
      /* wait for sig_arb_ptx_blocked/ready/transparent_mode_req */
      break;

    default:
      TRACE_ERROR( "DTI signal unexpected" );
      break;
  }


} /* sig_ftx_ptx_tx_buffer_ready_ind() */