+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  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 
+
−|             procedures and functions as described in the 
+
−|             SDL-documentation (FRX-statemachine)
+
−+----------------------------------------------------------------------------- 
+
−*/ 
+
−
+
−#define ENTITY_PPP
+
−
+
−/*==== 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 */
+
−/*lint -efile(766,gsm.h) */
+
−#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_ptxs.h"   /* to get signal interface from ptx */
+
−
+
−#include "ppp_arbf.h"   /* to get arb functions */
+
−
+
−#include <string.h>     /* to get memcpy */
+
−
+
−#ifdef PPP_HDLC_TRACE
+
−#include <stdio.h>      /* to get sprintf */
+
−#endif /* PPP_HDLC_TRACE */
+
−/*==== CONST ================================================================*/
+
−
+
−/*==== LOCAL VARS ===========================================================*/
+
−
+
−/*==== PRIVATE FUNCTIONS ====================================================*/
+
−
+
−/*==== PUBLIC FUNCTIONS =====================================================*/
+
−
+
−
+
−
+
−#ifndef PPP_INT_RAM
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : frx_init
+
−+------------------------------------------------------------------------------
+
−| Description : The function frx_init() initializes Frame Receive (FRX)
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void frx_init ()
+
−{ 
+
−  TRACE_FUNCTION( "frx_init" );
+
−
+
−  ppp_data->frx.frame_complete   = FALSE;
+
−  ppp_data->frx.stored_packet    = NULL;
+
−  ppp_data->frx.received_data    = NULL;
+
−  ppp_data->frx.store_state      = FRX_ADD_ERROR;
+
−  ppp_data->frx.data_flow_state  = FRX_DATA_FLOW_DEAD;
+
−
+
−#ifdef PPP_HDLC_TRACE
+
−  ppp_data->frx.hdlc_frame     = NULL;
+
−#endif /* PPP_HDLC_TRACE */
+
−  
+
−  INIT_STATE( PPP_SERVICE_FRX , FRX_DEAD );
+
−} /* frx_init() */
+
−#endif  /* PPP_INT_RAM */
+
−
+
−
+
−#ifndef PPP_FLASH_ROM
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : frx_add_desc
+
−+------------------------------------------------------------------------------
+
−| Description : The function frx_add_desc() appends the given 
+
−|               generic data descriptor to the already received descriptors.
+
−|               The function removes transparent characters and calculates
+
−|               the fcs.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void frx_add_desc ()
+
−{
+
−  UBYTE    store_state;
+
−  UBYTE    currentbyte;
+
−  USHORT   fcs;
+
−  UBYTE    escape;
+
−  USHORT   s_offset;
+
−  USHORT   s_size;
+
−  UBYTE*   destination;
+
−  USHORT   d_offset;
+
−  USHORT   d_size;
+
−  USHORT*  fcstab;
+
−  T_desc2* source_desc;
+
−  T_desc2* temp_desc;
+
−  USHORT   packet_len;
+
−#ifdef PPP_HDLC_TRACE
+
−  T_desc2* trace_desc;
+
−  T_desc2* trace_desc2;
+
−  T_desc2* trace_desc3;
+
−  USHORT   trace_pos;
+
−  char     buf[100];
+
−  USHORT   i;
+
−#endif /* PPP_HDLC_TRACE */
+
−
+
−  TRACE_FUNCTION( "frx_add_desc" );
+
−
+
−#ifdef PPP_HDLC_TRACE
+
−  /*
+
−   * trace HDLC frame
+
−   * the goal is to trace out only erroneous PPP frames
+
−   * if a correct PPP frame is received 
+
−   * we just release the stored copy of this frame without tracing
+
−   */
+
−  /*
+
−   * set source pointer
+
−   */
+
−  trace_desc = ppp_data->frx.received_data;
+
−  trace_pos  = ppp_data->frx.proceed_data;
+
−  switch(ppp_data->frx.store_state)
+
−  {
+
−    case FRX_ADD_ERROR:
+
−      /*
+
−       * we trace out each byte til the first HDLC flag
+
−       */
+
−      /*
+
−       * release old stored HDLC frame
+
−       * this should not be necessary
+
−       */
+
−      MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−      ppp_data->frx.hdlc_frame = NULL;
+
−      /*
+
−       * trace incomming data until the first HDLC flag
+
−       */
+
−      while((trace_desc) && (trace_pos >= trace_desc->len))
+
−      {
+
−        trace_desc = (T_desc2*)trace_desc->next;
+
−        trace_pos  = 0;
+
−      }
+
−      if((trace_desc) &&
+
−         (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG))
+
−      {
+
−        TRACE_EVENT("waiting for next HDLC flag:");
+
−        i = 0;
+
−        do
+
−        {
+
−          i+= sprintf(&buf[i], "0x%02x, ", trace_desc->buffer[trace_pos]);
+
−          trace_pos++;
+
−          while((trace_desc) && (trace_pos >= trace_desc->len))
+
−          {
+
−            trace_desc = (T_desc2*)trace_desc->next;
+
−            trace_pos  = 0;
+
−          }
+
−          if(i > 80)
+
−          {
+
−            TRACE_EVENT( buf );
+
−            i = 0;
+
−          }
+
−        }
+
−        while((trace_desc) &&
+
−              (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG));
+
−        if(i > 0)
+
−        {
+
−          TRACE_EVENT( buf );
+
−          i = 0;
+
−        }
+
−      }
+
−      break;
+
−
+
−    case FRX_ADD_HDLC_BEGIN:
+
−      /*
+
−       * we store just the first HDLC flag and fall through 
+
−       * to the default case to store the complete PPP frame
+
−       */
+
−      /*
+
−       * release old stored HDLC frame
+
−       */
+
−      MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−      ppp_data->frx.hdlc_frame = NULL;
+
−
+
−      if(trace_desc)
+
−      {
+
−        /*
+
−         * allocate first descriptor to store new HDLC frame
+
−         */
+
−        MALLOC(trace_desc2,
+
−               (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE));
+
−        trace_desc2->len         = 0;
+
−        trace_desc2->next        = (ULONG)NULL;
+
−        ppp_data->frx.hdlc_frame = trace_desc2;
+
−
+
−        /*
+
−         * store first HDLC flag
+
−         */
+
−        TRACE_EVENT_P2("start flag found in desc=0x%08x: pos=%d", 
+
−                       trace_desc, 
+
−                       trace_pos);
+
−        trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos];
+
−        trace_desc2->len++;
+
−        trace_pos++;
+
−        while((trace_desc) && (trace_pos >= trace_desc->len))
+
−        {
+
−          trace_desc = (T_desc2*)trace_desc->next;
+
−          trace_pos  = 0;
+
−        }
+
−      }
+
−      /* fall through */
+
−    default:
+
−      /*
+
−       * to store the complete PPP frame
+
−       */
+
−      /*
+
−       * set destination pointer
+
−       */
+
−      trace_desc2 = ppp_data->frx.hdlc_frame;
+
−      while(trace_desc2->next NEQ (ULONG)NULL)
+
−      {
+
−        trace_desc2 = (T_desc2*)trace_desc2->next;
+
−      }
+
−
+
−      /*
+
−       * set source pointer
+
−       */
+
−      while((trace_desc) && (trace_pos >= trace_desc->len))
+
−      {
+
−        trace_desc = (T_desc2*)trace_desc->next;
+
−        trace_pos  = 0;
+
−      }
+
−
+
−      if(trace_desc)
+
−      {
+
−        /*
+
−         * store HDLC frame
+
−         */
+
−        while((trace_desc) &&
+
−              (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG))
+
−        {
+
−          if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE)
+
−          {
+
−            MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                  FRX_ADD_SMALL_PACKET_SIZE));
+
−            trace_desc3->len  = 0;
+
−            trace_desc3->next = (ULONG)NULL;
+
−            trace_desc2->next = (ULONG)trace_desc3;
+
−            trace_desc2       = trace_desc3;
+
−          }
+
−          trace_desc2->buffer[trace_desc2->len] = 
+
−            trace_desc->buffer[trace_pos];
+
−          trace_desc2->len++;
+
−          trace_pos++;
+
−          while((trace_desc) && (trace_pos >= trace_desc->len))
+
−          {
+
−            trace_desc = (T_desc2*)trace_desc->next;
+
−            trace_pos  = 0;
+
−          }
+
−        }
+
−        /*
+
−         * store last HDLC flag
+
−         */
+
−        if(trace_desc)
+
−        {
+
−          if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE)
+
−          {
+
−            MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                  FRX_ADD_SMALL_PACKET_SIZE));
+
−            trace_desc3->len  = 0;
+
−            trace_desc3->next = (ULONG)NULL;
+
−            trace_desc2->next = (ULONG)trace_desc3;
+
−            trace_desc2       = trace_desc3;
+
−          }
+
−          TRACE_EVENT_P2("stop flag found in desc=0x%08x pos=%d", 
+
−                         trace_desc, 
+
−                         trace_pos);
+
−          trace_desc2->buffer[trace_desc2->len] = 
+
−            trace_desc->buffer[trace_pos];
+
−          trace_desc2->len++;
+
−          trace_pos++;
+
−        }
+
−      }
+
−      break;
+
−  }
+
−#endif /* PPP_HDLC_TRACE */
+
−  /*
+
−   * copy all important values into local variables
+
−   */
+
−  store_state = ppp_data->frx.store_state;
+
−  fcs         = ppp_data->frx.calc_fcs;
+
−  escape      = ppp_data->frx.escape;
+
−  source_desc = ppp_data->frx.received_data;
+
−  s_offset    = ppp_data->frx.proceed_data;
+
−  fcstab      = ppp_data->fcstab;
+
−  /*
+
−   * set destination pointer
+
−   */
+
−  destination = NULL;
+
−  d_offset    = 0;
+
−  d_size      = 0;
+
−  switch(store_state)
+
−  {
+
−    case FRX_ADD_INFORMATION:
+
−    case FRX_ADD_FCS1:
+
−    case FRX_ADD_FCS2:
+
−      destination = ppp_data->frx.cur_desc->buffer;
+
−      d_offset    = ppp_data->frx.cur_desc->len;
+
−      d_size      = ppp_data->frx.cur_desc_size;
+
−      break;
+
−  } /*lint !e744 switch statement has no default */
+
−  /*
+
−   * while there is still data to analyze and 
+
−   * a complete packet is not yet received
+
−   */
+
−  while((source_desc) && (ppp_data->frx.frame_complete EQ FALSE))
+
−  {
+
−    /*
+
−     * while the current descriptor is not yet complete analyzed.
+
−     * if a complete packet is analyzed we leave the loop via break command
+
−     */
+
−    for(s_size = source_desc->len; s_offset < s_size; s_offset++)
+
−    {
+
−      /*
+
−       * set current byte
+
−       */
+
−      currentbyte = source_desc->buffer[s_offset];
+
−      /*
+
−       * detect HDLC flag
+
−       */
+
−      if(currentbyte EQ PPP_HDLC_FLAG)
+
−      {
+
−        if(store_state EQ FRX_ADD_ERROR)
+
−        {
+
−#ifdef PPP_HDLC_TRACE
+
−          /*
+
−           * store next HDLC frame
+
−           */
+
−          /*
+
−           * release old stored HDLC frame
+
−           */
+
−          MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−          ppp_data->frx.hdlc_frame = NULL;
+
−          /*
+
−           * set source pointer
+
−           */
+
−          trace_desc = source_desc;
+
−          trace_pos  = s_offset;
+
−          /*
+
−           * allocate first descriptor to store new HDLC frame
+
−           */
+
−          MALLOC(trace_desc2, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                FRX_ADD_SMALL_PACKET_SIZE));
+
−          trace_desc2->len         = 0;
+
−          trace_desc2->next        = (ULONG)NULL;
+
−          ppp_data->frx.hdlc_frame = trace_desc2;
+
−
+
−          /*
+
−           * store first HDLC flag
+
−           */
+
−          TRACE_EVENT_P2("start flag found in desc=0x%08x pos=%d", 
+
−                         trace_desc, 
+
−                         trace_pos);
+
−          trace_desc2->buffer[trace_desc2->len] = 
+
−            trace_desc->buffer[trace_pos];
+
−          trace_desc2->len++;
+
−          trace_pos++;
+
−          while((trace_desc) && (trace_pos >= trace_desc->len))
+
−          {
+
−            trace_desc = (T_desc2*)trace_desc->next;
+
−            trace_pos  = 0;
+
−          }
+
−          if(trace_desc)
+
−          {
+
−            /*
+
−             * store HDLC frame
+
−             */
+
−            while((trace_desc) &&
+
−                  (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG))
+
−            {
+
−              if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE)
+
−              {
+
−                MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                      FRX_ADD_SMALL_PACKET_SIZE));
+
−                trace_desc3->len  = 0;
+
−                trace_desc3->next = (ULONG)NULL;
+
−                trace_desc2->next = (ULONG)trace_desc3;
+
−                trace_desc2       = trace_desc3;
+
−              }
+
−              trace_desc2->buffer[trace_desc2->len] = 
+
−                trace_desc->buffer[trace_pos];
+
−              trace_desc2->len++;
+
−              trace_pos++;
+
−              while((trace_desc) && (trace_pos >= trace_desc->len))
+
−              {
+
−                trace_desc = (T_desc2*)trace_desc->next;
+
−                trace_pos  = 0;
+
−              }
+
−            }
+
−            /*
+
−             * store last HDLC flag
+
−             */
+
−            if(trace_desc)
+
−            {
+
−              if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE)
+
−              {
+
−                MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                      FRX_ADD_SMALL_PACKET_SIZE));
+
−                trace_desc3->len  = 0;
+
−                trace_desc3->next = (ULONG)NULL;
+
−                trace_desc2->next = (ULONG)trace_desc3;
+
−                trace_desc2       = trace_desc3;
+
−              }
+
−              TRACE_EVENT_P2("stop flag found in desc=0x%08x pos=%d", 
+
−                             trace_desc, 
+
−                             trace_pos);
+
−              trace_desc2->buffer[trace_desc2->len] = 
+
−                trace_desc->buffer[trace_pos];
+
−              trace_desc2->len++;
+
−              trace_pos++;
+
−            }
+
−          }
+
−#endif /* PPP_HDLC_TRACE */
+
−          store_state = FRX_ADD_HDLC_BEGIN;
+
−        }
+
−        /*
+
−         * begin of frame detected
+
−         */
+
−        if(store_state EQ FRX_ADD_HDLC_BEGIN)
+
−        {
+
−          /*
+
−           * initialize new packet
+
−           */
+
−          ppp_data->frx.stored_len   = 0;
+
−          d_offset                   = 0;
+
−          ppp_data->frx.stored_ptype = 0x0000;
+
−          fcs                        = PPP_INITFCS;
+
−          escape                     = FALSE;
+
−          store_state                = FRX_ADD_ADDRESS;
+
−        }
+
−        /*
+
−         * end of frame detected
+
−         * no error occured, frame complete
+
−         * if we are in INFORMATION state we have to keep in mind the FCS at MRU check
+
−         */
+
−        else if(((ppp_data->frx.stored_len + d_offset) >= 4) && 
+
−                (((ppp_data->frx.stored_len + d_offset) <= ppp_data->mru) ||
+
−                 (((ppp_data->frx.stored_len + d_offset) <= 
+
−                   (ppp_data->mru + 2)) && 
+
−                  (store_state EQ FRX_ADD_INFORMATION))) &&
+
−                (fcs EQ PPP_GOODFCS))
+
−        {
+
−          /* 
+
−           * determine the length of the packet
+
−           */
+
−          packet_len                  = 0;
+
−          ppp_data->frx.stored_len   += d_offset;
+
−          ppp_data->frx.cur_desc->len = d_offset;
+
−          switch(store_state)
+
−          {
+
−            case FRX_ADD_INFORMATION:
+
−              packet_len = ppp_data->frx.stored_len - 2;
+
−              break;
+
−
+
−            case FRX_ADD_FCS1:
+
−              packet_len = ppp_data->frx.stored_len - 1;
+
−              break;
+
−
+
−            case FRX_ADD_FCS2:
+
−              packet_len = ppp_data->frx.stored_len;
+
−              break;
+
−          } /*lint !e744 switch statement has no default */
+
−          if(packet_len < ppp_data->frx.stored_len)
+
−          {
+
−            /*
+
−             * remove FCS
+
−             */
+
−            ppp_data->frx.stored_len = packet_len;
+
−            temp_desc                = ppp_data->frx.stored_packet;
+
−            while(packet_len > temp_desc->len)
+
−            {
+
−              packet_len-= temp_desc->len;
+
−              temp_desc  = (T_desc2*)temp_desc->next;
+
−            }
+
−            temp_desc->len = packet_len;
+
−            /*
+
−             * free the rest of packet
+
−             */
+
−            arb_discard_packet((T_desc2*)temp_desc->next);
+
−            temp_desc->next = (ULONG)NULL;
+
−          }
+
−#ifdef PPP_HDLC_TRACE
+
−          /*
+
−           * remove stored HDLC frame because of correct reception
+
−           * the storage of the next PPP frame is done
+
−           * in the next call of frx_add_desc()
+
−           */
+
−          MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−          ppp_data->frx.hdlc_frame = NULL;
+
−#endif /* PPP_HDLC_TRACE */
+
−          /*
+
−           * esape loop
+
−           */
+
−          ppp_data->frx.frame_complete = TRUE;
+
−          store_state                  = FRX_ADD_HDLC_BEGIN;
+
−          break;
+
−        }
+
−        /*
+
−         * end of frame detected
+
−         * error occured, discard frame
+
−         */
+
−        else
+
−        {
+
−          /*
+
−           * error traces
+
−           */
+
−          if(((ppp_data->frx.stored_len + d_offset) >= 4) &&
+
−             (fcs NEQ PPP_GOODFCS))
+
−          {
+
−            TRACE_EVENT("ERROR HDLC PACKET PPP FCS FAULT");
+
−          }
+
−          else if((ppp_data->frx.stored_len + d_offset) > ppp_data->mru)
+
−          {
+
−            TRACE_EVENT_P3("ERROR PPP PACKET TO LONG stored_len=%d  d_offset=%d  mru=%d",
+
−                           ppp_data->frx.stored_len,
+
−                           d_offset,
+
−                           ppp_data->mru);
+
−          }
+
−#ifdef PPP_HDLC_TRACE
+
−          if((ppp_data->frx.stored_len + d_offset) > 0)
+
−          {
+
−            /*
+
−             * trace HDLC frame and store next frame
+
−             */
+
−            TRACE_EVENT("wrong HDLC frame:");
+
−            i           = 0;
+
−            trace_pos   = 0;
+
−            trace_desc2 = ppp_data->frx.hdlc_frame;
+
−            while(trace_desc2)
+
−            {
+
−              i+= sprintf(&buf[i], 
+
−                          "0x%02x, ", 
+
−                          trace_desc2->buffer[trace_pos]);
+
−              trace_pos++;
+
−              if(trace_desc2->len <= trace_pos)
+
−              {
+
−                trace_desc2 = (T_desc2*)trace_desc2->next;
+
−                trace_pos   = 0;
+
−              }
+
−              if(i > 80)
+
−              {
+
−                TRACE_EVENT( buf );
+
−                i = 0;
+
−              }
+
−            }
+
−            if(i > 0)
+
−            {
+
−              TRACE_EVENT( buf );
+
−              i = 0;
+
−            }
+
−          }
+
−          /*
+
−           * release stored HDLC frame
+
−           */
+
−          MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−          ppp_data->frx.hdlc_frame = NULL;
+
−          /*
+
−           * store next HDLC frame
+
−           */
+
−          /*
+
−           * set source pointer
+
−           */
+
−          trace_desc = source_desc;
+
−          trace_pos  = s_offset;
+
−          /*
+
−           * allocate first descriptor to store new HDLC frame
+
−           */
+
−          MALLOC(trace_desc2, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                FRX_ADD_SMALL_PACKET_SIZE));
+
−          trace_desc2->len         = 0;
+
−          trace_desc2->next        = (ULONG)NULL;
+
−          ppp_data->frx.hdlc_frame = trace_desc2;
+
−
+
−          /*
+
−           * store first HDLC flag
+
−           */
+
−          TRACE_EVENT_P2("start flag found in desc=0x%08x pos=%d", 
+
−                         trace_desc, 
+
−                         trace_pos);
+
−          trace_desc2->buffer[trace_desc2->len] = 
+
−            trace_desc->buffer[trace_pos];
+
−          trace_desc2->len++;
+
−          trace_pos++;
+
−          while((trace_desc) && (trace_pos >= trace_desc->len))
+
−          {
+
−            trace_desc = (T_desc2*)trace_desc->next;
+
−            trace_pos  = 0;
+
−          }
+
−          if(trace_desc)
+
−          {
+
−            /*
+
−             * store HDLC frame
+
−             */
+
−            while((trace_desc) &&
+
−                  (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG))
+
−            {
+
−              if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE)
+
−              {
+
−                MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                      FRX_ADD_SMALL_PACKET_SIZE));
+
−                trace_desc3->len  = 0;
+
−                trace_desc3->next = (ULONG)NULL;
+
−                trace_desc2->next = (ULONG)trace_desc3;
+
−                trace_desc2       = trace_desc3;
+
−              }
+
−              trace_desc2->buffer[trace_desc2->len] = 
+
−                trace_desc->buffer[trace_pos];
+
−              trace_desc2->len++;
+
−              trace_pos++;
+
−              while((trace_desc) && (trace_pos >= trace_desc->len))
+
−              {
+
−                trace_desc = (T_desc2*)trace_desc->next;
+
−                trace_pos  = 0;
+
−              }
+
−            }
+
−            /*
+
−             * store last HDLC flag
+
−             */
+
−            if(trace_desc)
+
−            {
+
−              if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE)
+
−              {
+
−                MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                      FRX_ADD_SMALL_PACKET_SIZE));
+
−                trace_desc3->len  = 0;
+
−                trace_desc3->next = (ULONG)NULL;
+
−                trace_desc2->next = (ULONG)trace_desc3;
+
−                trace_desc2       = trace_desc3;
+
−              }
+
−              TRACE_EVENT_P2("stop flag found in desc=0x%08x pos=%d", 
+
−                             trace_desc, 
+
−                             trace_pos);
+
−              trace_desc2->buffer[trace_desc2->len] = 
+
−                trace_desc->buffer[trace_pos];
+
−              trace_desc2->len++;
+
−              trace_pos++;
+
−            }
+
−          }
+
−#endif /* PPP_HDLC_TRACE */
+
−          /*
+
−           * remove receiced packet because of an error
+
−           * decrease source offset beacause the HDLC end flag 
+
−           * can also be the HDLC start flag of the next frame
+
−           */
+
−          s_offset--;
+
−          arb_discard_packet(ppp_data->frx.stored_packet);
+
−          ppp_data->frx.stored_packet = NULL;
+
−          store_state                 = FRX_ADD_HDLC_BEGIN;
+
−        }
+
−      }
+
−      /*
+
−       * detect Control Escape octet 
+
−       */
+
−      else if((currentbyte EQ PPP_HDLC_ESCAPE) && (escape EQ FALSE))
+
−      {
+
−        escape = TRUE;
+
−      }
+
−      /*
+
−       * usual octet
+
−       */
+
−      else
+
−      {
+
−        /*
+
−         * bit 5 complement for the octet followed by Control Escape
+
−         */
+
−        if(escape EQ TRUE)
+
−        {
+
−          currentbyte^= 0x20;
+
−          escape      = FALSE;
+
−        }
+
−        /*
+
−         * calculate FCS 
+
−         */
+
−#ifdef _SIMULATION_
+
−        fcs = (fcs << 8) + currentbyte; /*lint !e734 Loss of precision */
+
−#else /* _SIMULATION_ */
+
−        fcs = (fcs >> 8) ^ fcstab[(fcs ^ currentbyte) & 0xff];
+
−#endif /* _SIMULATION_ */
+
−        /*
+
−         * store the packet and determine the protocol 
+
−         */
+
−        switch(store_state)
+
−        {
+
−          case FRX_ADD_INFORMATION:
+
−            if(d_offset >= d_size)
+
−            {
+
−              if((ppp_data->frx.stored_len + d_offset) < ppp_data->mru)
+
−              {
+
−                /*
+
−                 * allocate new descriptor
+
−                 */
+
−                switch(ppp_data->frx.stored_ptype)
+
−                {
+
−                  case DTI_PID_LCP:
+
−                  case DTI_PID_PAP:
+
−                  case DTI_PID_CHAP:
+
−                  case DTI_PID_IPCP:
+
−                    /*
+
−                     * allocate a big descriptor, copy the data into the new
+
−                     * one and free the small descriptor
+
−                     */
+
−                    MALLOC (ppp_data->frx.stored_packet, 
+
−                            (USHORT)(sizeof(T_desc2) - 1 + ppp_data->mru));
+
−                    memcpy(ppp_data->frx.stored_packet->buffer, 
+
−                           destination, 
+
−                           d_offset); /*lint !e668 Possibly passing a null pointer */
+
−                    MFREE(ppp_data->frx.cur_desc);
+
−                    ppp_data->frx.cur_desc       = ppp_data->frx.stored_packet;
+
−                    ppp_data->frx.cur_desc->next = (ULONG)NULL;
+
−                    destination = ppp_data->frx.cur_desc->buffer;
+
−                    d_size      = ppp_data->mru;
+
−                    break;
+
−
+
−                  default:
+
−                    /*
+
−                     * allocate a new small descriptor
+
−                     */
+
−                    MALLOC (temp_desc, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                        FRX_ADD_SMALL_PACKET_SIZE));
+
−                    ppp_data->frx.cur_desc->next = (ULONG)temp_desc;
+
−                    ppp_data->frx.cur_desc->len  = d_offset;
+
−                    ppp_data->frx.cur_desc       = temp_desc;
+
−                    ppp_data->frx.cur_desc->next = (ULONG)NULL;
+
−                    ppp_data->frx.stored_len    += d_offset;
+
−                    destination = ppp_data->frx.cur_desc->buffer;
+
−                    d_offset    = 0;
+
−                    d_size      = FRX_ADD_SMALL_PACKET_SIZE;
+
−                    break;
+
−                }
+
−              }
+
−              else if((ppp_data->frx.stored_len + d_offset) >= 
+
−                      (ppp_data->mru + 2))
+
−              {
+
−                /*
+
−                 * remove receiced packet because it is to long
+
−                 */
+
−                arb_discard_packet(ppp_data->frx.stored_packet);
+
−                ppp_data->frx.stored_packet = NULL;
+
−                store_state = FRX_ADD_ERROR;
+
−
+
−                TRACE_EVENT("ERROR PPP: HDLC packet to long");
+
−#ifdef PPP_HDLC_TRACE
+
−                /*
+
−                 * trace HDLC frame
+
−                 */
+
−                TRACE_EVENT("wrong HDLC frame:");
+
−                i           = 0;
+
−                trace_pos   = 0;
+
−                trace_desc2 = ppp_data->frx.hdlc_frame;
+
−                while(trace_desc2)
+
−                {
+
−                  i+= sprintf(&buf[i], 
+
−                              "0x%02x, ", 
+
−                              trace_desc2->buffer[trace_pos]);
+
−                  trace_pos++;
+
−                  if(trace_desc2->len <= trace_pos)
+
−                  {
+
−                    trace_desc2 = (T_desc2*)trace_desc2->next;
+
−                    trace_pos   = 0;
+
−                  }
+
−                  if(i > 80)
+
−                  {
+
−                    TRACE_EVENT( buf );
+
−                    i = 0;
+
−                  }
+
−                }
+
−                if(i > 0)
+
−                {
+
−                  TRACE_EVENT( buf );
+
−                  i = 0;
+
−                }
+
−                /*
+
−                 * release stored HDLC frame
+
−                 */
+
−                MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−                ppp_data->frx.hdlc_frame = NULL;
+
−#endif /* PPP_HDLC_TRACE */
+
−                break;
+
−              }
+
−              else if((ppp_data->frx.stored_len + d_offset) >= 
+
−                      (ppp_data->mru + 1))
+
−              {
+
−                d_offset--;
+
−                store_state = FRX_ADD_FCS2;
+
−                break;
+
−              }
+
−              else
+
−              {
+
−                store_state = FRX_ADD_FCS1;
+
−                break;
+
−              }
+
−            }
+
−            /*
+
−             * copy data
+
−             */
+
−            destination[d_offset] = currentbyte; /*lint !e613 Possible use of null pointer */
+
−            /*
+
−             * increase destination offset
+
−             */
+
−            d_offset++;
+
−            break;
+
−
+
−          case FRX_ADD_CONTROL:
+
−            if(currentbyte EQ 0x03)
+
−              store_state = FRX_ADD_PROTOCOL1;
+
−            else
+
−            {
+
−              TRACE_EVENT("ERROR PPP: wrong HDLC control field");
+
−#ifdef PPP_HDLC_TRACE
+
−              /*
+
−               * trace HDLC frame
+
−               */
+
−              TRACE_EVENT("wrong HDLC frame:");
+
−              i           = 0;
+
−              trace_pos   = 0;
+
−              trace_desc2 = ppp_data->frx.hdlc_frame;
+
−              while(trace_desc2)
+
−              {
+
−                i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]);
+
−                trace_pos++;
+
−                if(trace_desc2->len <= trace_pos)
+
−                {
+
−                  trace_desc2 = (T_desc2*)trace_desc2->next;
+
−                  trace_pos   = 0;
+
−                }
+
−                if(i > 80)
+
−                {
+
−                  TRACE_EVENT( buf );
+
−                  i = 0;
+
−                }
+
−              }
+
−              if(i > 0)
+
−              {
+
−                TRACE_EVENT( buf );
+
−                i = 0;
+
−              }
+
−              /*
+
−               * release stored HDLC frame
+
−               */
+
−              MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−              ppp_data->frx.hdlc_frame = NULL;
+
−#endif /* PPP_HDLC_TRACE */
+
−              store_state = FRX_ADD_ERROR;
+
−            }
+
−            break;
+
−
+
−          case FRX_ADD_ADDRESS:
+
−            if(currentbyte EQ 0xff)
+
−            {
+
−              store_state = FRX_ADD_CONTROL;
+
−              break;
+
−            }
+
−            /*
+
−             * address and control field compression detected
+
−             */
+
−            /* fall through */
+
−          case FRX_ADD_PROTOCOL1:
+
−            if((currentbyte & 0x01) EQ 0)
+
−            {
+
−              ppp_data->frx.stored_ptype = currentbyte;
+
−              ppp_data->frx.stored_ptype = (ppp_data->frx.stored_ptype << 8); /*lint !e734 Loss of precision */
+
−              store_state = FRX_ADD_PROTOCOL2;
+
−              break;
+
−            }
+
−            /*
+
−             * protocol field compression detected
+
−             */
+
−            /* fall through */
+
−          case FRX_ADD_PROTOCOL2:
+
−            if(currentbyte & 0x01)
+
−            {
+
−              /*
+
−               * store protocol
+
−               */
+
−              ppp_data->frx.stored_ptype|= currentbyte;
+
−              /*
+
−               * allocate new packet
+
−               */
+
−              d_size = FRX_ADD_SMALL_PACKET_SIZE;
+
−              /*
+
−               * Allocate the necessary size for the data descriptor. 
+
−               * The size is calculated as follows:
+
−               * - take the size of a descriptor structure
+
−               * - subtract one because of the array buffer[1] to get
+
−               *   the size of descriptor control information
+
−               * - add number of octets of descriptor data
+
−               */
+
−              MALLOC (ppp_data->frx.stored_packet, 
+
−                      (USHORT)(sizeof(T_desc2) - 1 + d_size));
+
−              ppp_data->frx.cur_desc       = ppp_data->frx.stored_packet;
+
−              ppp_data->frx.cur_desc->next = (ULONG)NULL;
+
−              destination = ppp_data->frx.cur_desc->buffer;
+
−              d_offset    = 0;
+
−              store_state = FRX_ADD_INFORMATION;
+
−            }
+
−            else
+
−            {
+
−              TRACE_EVENT("ERROR PPP: wrong HDLC protocol field");
+
−#ifdef PPP_HDLC_TRACE
+
−              /*
+
−               * trace HDLC frame
+
−               */
+
−              TRACE_EVENT("wrong HDLC frame:");
+
−              i           = 0;
+
−              trace_pos   = 0;
+
−              trace_desc2 = ppp_data->frx.hdlc_frame;
+
−              while(trace_desc2)
+
−              {
+
−                i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]);
+
−                trace_pos++;
+
−                if(trace_desc2->len <= trace_pos)
+
−                {
+
−                  trace_desc2 = (T_desc2*)trace_desc2->next;
+
−                  trace_pos   = 0;
+
−                }
+
−                if(i > 80)
+
−                {
+
−                  TRACE_EVENT( buf );
+
−                  i = 0;
+
−                }
+
−              }
+
−              if(i > 0)
+
−              {
+
−                TRACE_EVENT( buf );
+
−                i = 0;
+
−              }
+
−              /*
+
−               * release stored HDLC frame
+
−               */
+
−              MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−              ppp_data->frx.hdlc_frame = NULL;
+
−#endif /* PPP_HDLC_TRACE */
+
−              store_state = FRX_ADD_ERROR;
+
−            }
+
−            break;
+
−
+
−          case FRX_ADD_FCS1:
+
−            store_state = FRX_ADD_FCS2;
+
−            break;
+
−
+
−          case FRX_ADD_FCS2:
+
−            /*
+
−             * remove receiced packet because its to long
+
−             */
+
−            arb_discard_packet(ppp_data->frx.stored_packet);
+
−            ppp_data->frx.stored_packet = NULL;
+
−            store_state = FRX_ADD_ERROR;
+
−            
+
−            TRACE_EVENT("ERROR PPP: HDLC packet to long");
+
−#ifdef PPP_HDLC_TRACE
+
−            /*
+
−             * trace HDLC frame
+
−             */
+
−            TRACE_EVENT("wrong HDLC frame:");
+
−            i           = 0;
+
−            trace_pos   = 0;
+
−            trace_desc2 = ppp_data->frx.hdlc_frame;
+
−            while(trace_desc2)
+
−            {
+
−              i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]);
+
−              trace_pos++;
+
−              if(trace_desc2->len <= trace_pos)
+
−              {
+
−                trace_desc2 = (T_desc2*)trace_desc2->next;
+
−                trace_pos   = 0;
+
−              }
+
−              if(i > 80)
+
−              {
+
−                TRACE_EVENT( buf );
+
−                i = 0;
+
−              }
+
−            }
+
−            if(i > 0)
+
−            {
+
−              TRACE_EVENT( buf );
+
−              i = 0;
+
−            }
+
−            /*
+
−             * release stored HDLC frame
+
−             */
+
−            MFREE_DESC2(ppp_data->frx.hdlc_frame);
+
−            ppp_data->frx.hdlc_frame = NULL;
+
−#endif /* PPP_HDLC_TRACE */
+
−            break;
+
−
+
−          case FRX_ADD_ERROR:
+
−            /*
+
−             * we wait for the next HDLC flag
+
−             */
+
−            break;
+
−
+
−          case FRX_ADD_HDLC_BEGIN:
+
−            TRACE_ERROR("ERROR: frx_add_desc(): in FRX_ADD_HDLC_BEGIN state without HDLC flag");
+
−            break;
+
−
+
−          default:
+
−            TRACE_ERROR("ERROR: frx_add_desc(): wrong state");
+
−            break;
+
−        }
+
−      }
+
−    }
+
−    /*
+
−     * check if current descriptor is complete analyzed
+
−     */
+
−    if(s_offset >= s_size)
+
−    {
+
−      temp_desc = (T_desc2*)source_desc->next;
+
−      MFREE(source_desc);
+
−      source_desc = temp_desc;
+
−      s_offset    = 0;
+
−    }
+
−  }
+
−  /*
+
−   * store important values in global variables
+
−   */
+
−  switch(store_state)
+
−  {
+
−    case FRX_ADD_INFORMATION:
+
−    case FRX_ADD_FCS1:
+
−    case FRX_ADD_FCS2:
+
−      ppp_data->frx.cur_desc->len = d_offset;
+
−      break;
+
−  } /*lint !e744 switch statement has no default */
+
−  ppp_data->frx.store_state   = store_state;
+
−  ppp_data->frx.calc_fcs      = fcs;
+
−  ppp_data->frx.escape        = escape;
+
−  ppp_data->frx.received_data = source_desc;
+
−  ppp_data->frx.cur_desc_size = d_size;
+
−  ppp_data->frx.proceed_data  = s_offset;
+
−} /*lint !e550 fcstab not accessed in _SIMULATION_ frx_add_desc() */
+
−#endif /* PPP_FLASH_ROM */
+
−
+
−
+
−
+
−#ifndef PPP_INT_RAM
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : frx_detect_frame
+
−+------------------------------------------------------------------------------
+
−| Description : The function frx_detect_frame() detects begin and end of 
+
−|               PPP frames.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void frx_detect_frame ()
+
−{
+
−  UBYTE*   source;
+
−  UBYTE*   destination;
+
−  T_desc2* temp_desc1;
+
−  T_desc2* temp_desc2;
+
−  
+
−  TRACE_FUNCTION( "frx_detect_frame" );
+
−
+
−  /*
+
−   * copy received data stream pointer
+
−   */
+
−  temp_desc1 = ppp_data->frx.received_data;
+
−  /*
+
−   * set destination pointer if necessary
+
−   */
+
−  if(ppp_data->frx.store_state EQ FRX_ADD_INFORMATION)
+
−  {
+
−    /*
+
−     * to avoid erroneuos code generation of target compiler,
+
−     * it is written in two lines instead of one
+
−     */
+
−    destination = ppp_data->frx.cur_desc->buffer;
+
−    destination+= ppp_data->frx.cur_desc->len;
+
−  }
+
−
+
−  /*
+
−   * while there is still data to analyze and 
+
−   * a complete frame is not yet received
+
−   */
+
−  while((temp_desc1) && (ppp_data->frx.frame_complete EQ FALSE))
+
−  {
+
−    /*
+
−     * set source pointer
+
−     */
+
−    source = &temp_desc1->buffer[ppp_data->frx.proceed_data];
+
−    /*
+
−     * We count down the length of the current descriptor.
+
−     * while the current descriptor is not yet complete analyzed and 
+
−     * a complete frame is not yet received
+
−     */
+
−    while((temp_desc1->len) && (ppp_data->frx.frame_complete EQ FALSE))
+
−    {
+
−      switch(ppp_data->frx.store_state)
+
−      {
+
−        case FRX_ADD_ERROR:
+
−          /*
+
−           * search for next HDLC flag
+
−           */
+
−          while((temp_desc1->len) &&
+
−                (*source NEQ PPP_HDLC_FLAG))
+
−          {
+
−            /*
+
−             * increase source pointer
+
−             */
+
−            source++;
+
−            temp_desc1->len--;
+
−            ppp_data->frx.proceed_data++;
+
−          }
+
−          if(temp_desc1->len EQ 0) /*lint !e661 Possible access of out-of-bounds pointer */
+
−            /*
+
−             * end of descriptor reached
+
−             * analyze next descriptor
+
−             */
+
−            break;
+
−          ppp_data->frx.store_state = FRX_ADD_HDLC_BEGIN;
+
−          /* fall through */
+
−        case FRX_ADD_HDLC_BEGIN:
+
−          /*
+
−           * create new packet (frame) to store detected frame
+
−           */
+
−          ppp_data->frx.stored_len    = 0;
+
−          ppp_data->frx.stored_ptype  = DTI_PID_UOS;
+
−          ppp_data->frx.cur_desc_size = FRX_ADD_SMALL_PACKET_SIZE;
+
−          /*
+
−           * Allocate the necessary size for the data descriptor. The size is 
+
−           * calculated as follows:
+
−           * - take the size of a descriptor structure
+
−           * - subtract one because of the array buffer[1] to get the size of
+
−           *   descriptor control information
+
−           * - add number of octets of descriptor data
+
−           */
+
−          MALLOC (ppp_data->frx.stored_packet,
+
−                  (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE));
+
−          ppp_data->frx.cur_desc       = ppp_data->frx.stored_packet;
+
−          ppp_data->frx.cur_desc->len  = 0;
+
−          ppp_data->frx.cur_desc->next = (ULONG)NULL;
+
−          destination = ppp_data->frx.cur_desc->buffer;
+
−
+
−          *destination = *source; /*lint !e613 Possible use of null pointer */
+
−          /*
+
−           * increase source pointer
+
−           */
+
−          source++; /*lint !e613 Possible use of null pointer */
+
−          temp_desc1->len--;
+
−          ppp_data->frx.proceed_data++;
+
−          /*
+
−           * increase destination pointer
+
−           */
+
−          ppp_data->frx.stored_len++;
+
−          destination++;
+
−          ppp_data->frx.cur_desc->len++;
+
−
+
−          ppp_data->frx.store_state = FRX_ADD_INFORMATION;
+
−          break;
+
−
+
−        case FRX_ADD_INFORMATION:
+
−          /*
+
−           * copy data
+
−           */
+
−          while((temp_desc1->len) &&
+
−                (ppp_data->frx.stored_len < ppp_data->mru) &&
+
−                (ppp_data->frx.cur_desc->len < ppp_data->frx.cur_desc_size) &&
+
−                (*source NEQ PPP_HDLC_FLAG))
+
−          {
+
−            /*
+
−             * copy data
+
−             */
+
−            *destination = *source; /*lint !e644 destination may not have been initialized */
+
−            /*
+
−             * increase source pointer
+
−             */
+
−            source++;
+
−            temp_desc1->len--;
+
−            ppp_data->frx.proceed_data++;
+
−            /*
+
−             * increase destination pointer
+
−             */
+
−            ppp_data->frx.stored_len++;
+
−            destination++;
+
−            ppp_data->frx.cur_desc->len++;
+
−          }
+
−          /*
+
−           * analyze why the loop is left
+
−           */
+
−          if(ppp_data->frx.stored_len < ppp_data->mru) /*lint !e661 Possible access of out-of-bounds pointer */
+
−          {
+
−            if(ppp_data->frx.cur_desc->len >= ppp_data->frx.cur_desc_size)
+
−            {
+
−              /*
+
−               * allocate a new small descriptor
+
−               */
+
−              MALLOC (temp_desc2, (USHORT)(sizeof(T_desc2) - 1 + 
+
−                                  FRX_ADD_SMALL_PACKET_SIZE));
+
−              ppp_data->frx.cur_desc->next = (ULONG)temp_desc2;
+
−              ppp_data->frx.cur_desc       = 
+
−                (T_desc2*)ppp_data->frx.cur_desc->next;
+
−              ppp_data->frx.cur_desc->len  = 0;
+
−              ppp_data->frx.cur_desc->size = 0;
+
−              ppp_data->frx.cur_desc->offset = 0;
+
−              ppp_data->frx.cur_desc->next = (ULONG)NULL;
+
−              ppp_data->frx.cur_desc_size  = FRX_ADD_SMALL_PACKET_SIZE;
+
−              destination = ppp_data->frx.cur_desc->buffer;
+
−            }
+
−            if((temp_desc1->len) &&
+
−               (*source EQ PPP_HDLC_FLAG)) /*lint !e613 Possible use of null pointer */
+
−            {
+
−              /*
+
−               * end of frame detected
+
−               */
+
−              ppp_data->frx.store_state = FRX_ADD_HDLC_BEGIN;
+
−              /*
+
−               * copy HDLC flag
+
−               */
+
−              *destination = *source; /*lint !e613 Possible use of null pointer */
+
−              /*
+
−               * increase length values
+
−               */
+
−              ppp_data->frx.stored_len++;
+
−              ppp_data->frx.cur_desc->len++;
+
−              /*
+
−               * check for correct length
+
−               */
+
−              if(ppp_data->frx.stored_len > 2)
+
−              {
+
−                /*
+
−                 * no error occured, frame complete
+
−                 */
+
−                ppp_data->frx.frame_complete = TRUE;
+
−              }
+
−              else
+
−              {
+
−                /*
+
−                 * remove receiced packet because its to short
+
−                 */
+
−                arb_discard_packet(ppp_data->frx.stored_packet);
+
−                ppp_data->frx.stored_packet = NULL;
+
−              }
+
−            }
+
−          }
+
−          else
+
−          {
+
−            /*
+
−             * remove receiced packet because its to long
+
−             */
+
−            arb_discard_packet(ppp_data->frx.stored_packet);
+
−            ppp_data->frx.stored_packet  = NULL;
+
−            ppp_data->frx.store_state    = FRX_ADD_ERROR;
+
−          }
+
−          break;
+
−      } /*lint !e744 switch statement has no default */
+
−    }
+
−    if(temp_desc1->len EQ 0)
+
−    {
+
−      temp_desc2 = (T_desc2*)temp_desc1->next;
+
−      MFREE(temp_desc1);
+
−      temp_desc1                 = temp_desc2;
+
−      ppp_data->frx.proceed_data = 0;
+
−    }
+
−  }
+
−  /*
+
−   * store received data stream pointer
+
−   */
+
−  ppp_data->frx.received_data = temp_desc1;
+
−} /* frx_detect_frame() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : frx_send_pack_ready_mode()
+
−+------------------------------------------------------------------------------
+
−| Description : send as many packets to ptx as can be extracted from received frame.
+
−|               Frx is in ready mode.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−GLOBAL void frx_send_pack_ready_mode ()
+
−{
+
−  T_desc2* temp_desc;
+
−
+
−  TRACE_FUNCTION( "frx_send_pack_ready_mode ()" );
+
−
+
−  while( ppp_data->frx.frame_complete   EQ TRUE            AND
+
−         ppp_data->frx.data_flow_state  EQ FRX_DATA_FLOW_READY)
+
−  {
+
−    /*
+
−     * to avoid any side effects
+
−     * first reset all necessary variables and then call the signal 
+
−     */
+
−    ppp_data->frx.frame_complete = FALSE;
+
−    temp_desc                    = ppp_data->frx.stored_packet;
+
−    ppp_data->frx.stored_packet  = NULL;
+
−    sig_frx_ptx_packet_ind(ppp_data->frx.stored_ptype, 
+
−                           ppp_data->frx.stored_len,
+
−                           temp_desc);
+
−    frx_add_desc();
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : frx_send_pack_transp_mode
+
−+------------------------------------------------------------------------------
+
−| Description : send as many packets to ptx as can be extracted from received frame.
+
−|               Frx is in transparent mode .
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−GLOBAL void frx_send_pack_transp_mode ()
+
−{
+
−  T_desc2* temp_desc;
+
−
+
−  TRACE_FUNCTION( "frx_send_pack_transp_mode ()" );
+
−
+
−  while( ppp_data->frx.frame_complete  EQ TRUE            AND
+
−         ppp_data->frx.data_flow_state EQ FRX_DATA_FLOW_READY)
+
−  {
+
−    /*
+
−     * to avoid any side effects
+
−     * first reset all necessary variables and then call the signal 
+
−     */
+
−    ppp_data->frx.frame_complete = FALSE;
+
−    temp_desc                    = ppp_data->frx.stored_packet;
+
−    ppp_data->frx.stored_packet  = NULL;
+
−    sig_frx_ptx_packet_ind(ppp_data->frx.stored_ptype, 
+
−                           ppp_data->frx.stored_len,
+
−                           temp_desc);
+
−    frx_detect_frame();
+
−  }
+
−
+
−}
+
−
+
−#endif  /* PPP_INT_RAM */
+
−