FreeCalypso > hg > fc-tourmaline

view src/g23m-fad/ppp/ppp_ftxf.c @ 303:f76436d19a7a default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
!GPRS config: fix long-standing AT+COPS chance hanging bug There has been a long-standing bug in FreeCalypso going back years: sometimes in the AT command bring-up sequence of an ACI-only MS, the AT+COPS command would produce only a power scan followed by cessation of protocol stack activity (only L1 ADC traces), instead of the expected network search sequence. This behaviour was seen in different FC firmware versions going back to Citrine, and seemed to follow some law of chance, not reliably repeatable. This bug has been tracked down and found to be specific to !GPRS configuration, stemming from our TCS2/TCS3 hybrid and reconstruction of !GPRS support that was bitrotten in TCS3.2/LoCosto version. ACI module psa_mms.c, needed only for !GPRS, was missing in the TCS3 version and had to be pulled from TCS2 - but as it turns out, there is a new field in the MMR_REG_REQ primitive that needs to be set correctly, and that psa_mms.c module is the place where this initialization needed to be added.
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 08 Jun 2023 08:23:37 +0000
parents fa8dc04885d8
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  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 (FTX-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_arbf.h"   /* to get function interface from arb */

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

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

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

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

#ifndef PPP_INT_RAM
/*
+------------------------------------------------------------------------------
| Function    : ftx_init
+------------------------------------------------------------------------------
| Description : The function ftx_init() initializes Frame Transmit (FTX)
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void ftx_init ()
{
  USHORT i;

  TRACE_FUNCTION( "ftx_init" );

  ppp_data->ftx.acfc         = PPP_ACFC_DEFAULT;
  ppp_data->ftx.pfc          = PPP_PFC_DEFAULT;

  /*
   * inititialise ACCMTAB
   */
  for(i=0;i<=255;i++)
  {
    if(i<0x20)
    {
      ppp_data->ftx.accmtab[i] = (PPP_ACCM_DEFAULT & (1UL << i)) ? 0xFF : 0x00;
    }
    else if((i EQ PPP_HDLC_FLAG) ||
            (i EQ PPP_HDLC_ESCAPE) ||
            (i EQ PPP_ASCII_DEL))
    {
      ppp_data->ftx.accmtab[i] = 0xFF;
    }
    else
    {
      ppp_data->ftx.accmtab[i] = 0x00;
    }
  }


  INIT_STATE( PPP_SERVICE_FTX , FTX_DEAD );
} /* ftx_init() */
#endif  /* PPP_INT_RAM */



#ifndef PPP_FLASH_ROM
/*
+------------------------------------------------------------------------------
| Function    : ftx_get_frame
+------------------------------------------------------------------------------
| Description : The function ftx_get_frame() puts the given packet into a HDLC
|               frame. A FCS is calculated and put at the the end of the
|               packet. After that every byte is examined and preceeded with an
|               escape character when certain condiitions are met.
|
|               This function has been optimized - FCS calculation and escaping
|               are done in the same loop.
|
| Parameters  : ptype     - packet type
|               packet    - pointer to a generic data descriptor
|               ptr_frame - returns a list of generic data descriptors
|
+------------------------------------------------------------------------------
*/
GLOBAL void ftx_get_frame (USHORT ptype, T_desc2* packet, T_desc_list2* ptr_frame)
{
  T_desc2 *temp_desc1, *temp_desc2;
  USHORT  calc_fcs;
  USHORT  i;
  UBYTE   currentByte;
  UBYTE   escape;

  TRACE_FUNCTION( "ftx_get_frame" );

  /*
   * create a new descriptor for address, control and protocol field and put
   * it in front of the linked descriptor list
   */
    /*
     * 1 octet address field
     * 1 octet control field
     * 2 octets protocol field (uncompressed)
     *----------
     * 4 octets
     */
  MALLOC (temp_desc1, (USHORT)(sizeof(T_desc2) - 1 + 4));
  temp_desc1->next = (ULONG)packet;
  packet           = temp_desc1;
  packet->len      = 0;
    /*
     * if no address and control field compression add both
     * in LCP packets we need always address and control field
     */
  if((ppp_data->ftx.acfc EQ FALSE) ||
     (ptype EQ DTI_PID_LCP))
  {
    packet->buffer[packet->len] = 0xff;
    packet->len++;
    packet->buffer[packet->len] = 0x03;
    packet->len++;
  }
    /*
     * if no protocol field compression add most significant octet
     * of the protocol field
     * in LCP packets we need always uncompressed protocol field
     */
  if((ppp_data->ftx.pfc EQ FALSE) ||
     (ptype > 0x00ff) ||
     (ptype EQ DTI_PID_LCP))
  {
    packet->buffer[packet->len] = (UBYTE)(ptype >> 8);
    packet->len++;
  }
    /*
     * add protocol field least significant octet
     */
  packet->buffer[packet->len] = (UBYTE)(ptype & 0xff);
  packet->len++;


  /*
   * create complete frame
   * use async-control-character-map and copy the packet into descriptor with
   * a size of FTX_GET_DESC_SIZE
   */
  MALLOC (temp_desc1, (USHORT)(sizeof(T_desc2) - 1 + FTX_GET_DESC_SIZE));
  temp_desc1->next = (ULONG)NULL;
  ptr_frame->first = (ULONG)temp_desc1;


  /*
   * reset ptr_frame->list_len, it will be incremented by temp_desc1->len
   * when the packet is completely processed, at the end it will contain
   * the length of the whole frame in bytes
   */
  ptr_frame->list_len   = 0;


  /*
   * insert HDLC-Flag - to mark the start of the frame
   */
  temp_desc1->len       = 1;
  temp_desc1->size      = 1;
  temp_desc1->offset    = 1;
  temp_desc1->buffer[0] = PPP_HDLC_FLAG;
  escape=FALSE;


  /*
   * init FCS
   */
  calc_fcs   = PPP_INITFCS;


  /*
   * ATTENTION: the following two while loops contain equivalent
   * code - if you edit the code make sure you edit BOTH loops
   */
  if(ptype EQ DTI_PID_LCP)
  {
    while(packet NEQ NULL)
    {
      i=0;
      while(i < packet->len)
      {
        currentByte = packet->buffer[i];

        if(escape EQ TRUE)
        {
          temp_desc1->buffer[temp_desc1->len] = currentByte ^ 0x20;

          calc_fcs=(calc_fcs >> 8) ^
            ppp_data->fcstab[(calc_fcs ^ currentByte) & 0xff];

          escape=FALSE;
          i++;
        }

        /*
         * In LCP packets we escape ALL characters below 0x20.
         * In addition to that PPP_HDLC_FLAG, PPP_HDLC_ESCAPE,
         * PPP_ASCII_DEL are escaped too. These characters are marked in
         * in the ACCM table
         */
        else if((currentByte < 0x20) || ppp_data->ftx.accmtab[currentByte])
        {
          temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_ESCAPE;
          escape = TRUE;
        }

        else
        {
          temp_desc1->buffer[temp_desc1->len] = currentByte;

          calc_fcs=(calc_fcs >> 8) ^
            ppp_data->fcstab[(calc_fcs ^ currentByte) & 0xff];

          i++;
        }

        temp_desc1->len++;

        if(temp_desc1->len >= FTX_GET_DESC_SIZE)
        {
          ptr_frame->list_len +=temp_desc1->len;

          temp_desc2=temp_desc1;
          MALLOC (temp_desc1,
            (USHORT)(sizeof(T_desc2) - 1 + FTX_GET_DESC_SIZE));

          temp_desc1->len=0;
          temp_desc1->next = (ULONG)NULL;

          temp_desc2->next=(ULONG)temp_desc1;
        }
      }

      temp_desc2=packet;
      packet=(T_desc2*)packet->next;
      MFREE(temp_desc2);
    }
    ptr_frame->list_len +=temp_desc1->len;
  }
  else
  {
    while(packet NEQ NULL)
    {
      i=0;
      while(i < packet->len)
      {
        currentByte = packet->buffer[i];

        if(escape EQ TRUE)
        {
          temp_desc1->buffer[temp_desc1->len] = currentByte ^ 0x20;

          calc_fcs=(calc_fcs >> 8) ^
            ppp_data->fcstab[(calc_fcs ^ currentByte) & 0xff];

          escape=FALSE;
          i++;
        }

        /*
         * In packets other than LCP we escape only those characters
         * below 0x20 that are marked in the ACCM table.
         * In addition to that PPP_HDLC_FLAG, PPP_HDLC_ESCAPE,
         * PPP_ASCII_DEL are escaped too. These characters are marked in
         * in the same table.
         */
        else if(ppp_data->ftx.accmtab[currentByte])
        {
          temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_ESCAPE;
          escape = TRUE;
        }

        else
        {
          temp_desc1->buffer[temp_desc1->len] = currentByte;

          calc_fcs=(calc_fcs >> 8) ^
            ppp_data->fcstab[(calc_fcs ^ currentByte) & 0xff];

          i++;
        }

        temp_desc1->len++;

        if(temp_desc1->len >= FTX_GET_DESC_SIZE)
        {
          ptr_frame->list_len +=temp_desc1->len;

          temp_desc2=temp_desc1;
          MALLOC (temp_desc1,
            (USHORT)(sizeof(T_desc2) - 1 + FTX_GET_DESC_SIZE));
          temp_desc1->len=0;
          temp_desc1->next = (ULONG)NULL;

          temp_desc2->next=(ULONG)temp_desc1;
        }
      }

      temp_desc2=packet;
      packet=(T_desc2*)packet->next;
      MFREE(temp_desc2);
    }
    ptr_frame->list_len +=temp_desc1->len;
  }

  /*
   * finish FCS calculation
   */
  calc_fcs ^= 0xffff;


  /*
   * create a new descriptor for FCS and HDLC-Flag
   * put the descriptor at the end of the descriptor list
   *
   * FCS must be escaped too, allocate two bytes more - just in case
   * 2 for FCS, 2 for PPP_HDLC_ESCAPE, 1 for PPP_HDLC_FLAG
   *
   */
  if(temp_desc1->len + 5 >= FTX_GET_DESC_SIZE)
  {
    MALLOC (temp_desc2, (USHORT)(sizeof(T_desc2) - 1 + 5));
    temp_desc2->len    = 0;
    temp_desc2->size   = 0;
    temp_desc2->offset = 0;
    temp_desc2->next   = (ULONG)NULL;

    temp_desc1->next = (ULONG)temp_desc2;
    temp_desc1 = temp_desc2;
  }

  /*
   * insert the FCS, escape when necessary
   */
#ifdef _SIMULATION_
  temp_desc1->buffer[temp_desc1->len]=(UBYTE)(PPP_GOODFCS >> 8);
  temp_desc1->buffer[temp_desc1->len+1]=(UBYTE)(PPP_GOODFCS & 0x00ff);
  temp_desc1->len      += 2;
  ptr_frame->list_len  += 2;
#else /* _SIMULATION_ */
  /*
   * least significant octet first
   */
  if(ptype EQ DTI_PID_LCP)
  {
    currentByte = (UBYTE)(calc_fcs & 0x00ff);
    if((currentByte < 0x20) || ppp_data->ftx.accmtab[currentByte])
    {
      temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_ESCAPE;
      temp_desc1->buffer[temp_desc1->len+1] = currentByte ^ 0x20;
      temp_desc1->len      += 2;
      ptr_frame->list_len  += 2;
    }
    else
    {
      temp_desc1->buffer[temp_desc1->len] = currentByte;
      temp_desc1->len++;
      ptr_frame->list_len++;
    }

    currentByte = (UBYTE)(calc_fcs >> 8);
    if((currentByte < 0x20) || ppp_data->ftx.accmtab[currentByte])
    {
      temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_ESCAPE;
      temp_desc1->buffer[temp_desc1->len+1] = currentByte ^ 0x20;
      temp_desc1->len      += 2;
      ptr_frame->list_len  += 2;
    }
    else
    {
      temp_desc1->buffer[temp_desc1->len] = currentByte;
      temp_desc1->len++;
      ptr_frame->list_len++;
    }
  }
  else
  {
    currentByte = (UBYTE)(calc_fcs & 0x00ff);
    if(ppp_data->ftx.accmtab[currentByte])
    {
      temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_ESCAPE;
      temp_desc1->buffer[temp_desc1->len+1] = currentByte ^ 0x20;
      temp_desc1->len      += 2;
      ptr_frame->list_len  += 2;
    }
    else
    {
      temp_desc1->buffer[temp_desc1->len] = currentByte;
      temp_desc1->len++;
      ptr_frame->list_len++;
    }

    currentByte = (UBYTE)(calc_fcs >> 8);
    if(ppp_data->ftx.accmtab[currentByte])
    {
      temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_ESCAPE;
      temp_desc1->buffer[temp_desc1->len+1] = currentByte ^ 0x20;
      temp_desc1->len      += 2;
      ptr_frame->list_len  += 2;
    }
    else
    {
      temp_desc1->buffer[temp_desc1->len] = currentByte;
      temp_desc1->len++;
      ptr_frame->list_len++;
    }
  }

#endif /* _SIMULATION_ */

  /*
   * insert HDLC-Flag - to mark the start of the frame
   */
  temp_desc1->buffer[temp_desc1->len] = PPP_HDLC_FLAG;
  temp_desc1->len++;
  temp_desc1->size = temp_desc1->len;
  ptr_frame->list_len++;


} /* ftx_get_frame() */
#endif  /* PPP_FLASH_ROM */



#ifndef PPP_INT_RAM
/*
+------------------------------------------------------------------------------
| Function    : ftx_check_frame
+------------------------------------------------------------------------------
| Description : The function ftx_check_frame() checks for flag at begin and end
|               of the frame and calculates length of frame.
|
| Parameters  : ptr_frame - gives just a frame and returns a frame with length
|
+------------------------------------------------------------------------------
*/
GLOBAL void ftx_check_frame (T_desc_list2* ptr_frame)
{
  T_desc2* frame;
  T_desc2* temp_desc;
  UBYTE    last_byte;

  TRACE_FUNCTION( "ftx_check_frame" );

  frame = (T_desc2*)ptr_frame->first;

  while((frame) && (frame->len EQ 0))
    frame = (T_desc2*)frame->next;

  if(frame)
  {
    /*
     * if the first character isnt the HDLC flag then
     * create a new first data descriptor containing just the HDLC flag
     */
    if(frame->buffer[0] NEQ PPP_HDLC_FLAG)
    {
      MALLOC (frame, (USHORT)(sizeof(T_desc2) - 1 + 1));
      frame->next      = ptr_frame->first;
      frame->len       = 1;
      frame->buffer[0] = PPP_HDLC_FLAG;
      ptr_frame->first = (ULONG)frame;
    }
    /*
     * search for the last character and if it isnt the HDLC flag then
     * create a new last data descriptor containing just the HDLC flag.
     * calculate length of whole data.
     */
    ptr_frame->list_len = 0;
    for(frame = (T_desc2*)ptr_frame->first;
        frame;
        frame = (T_desc2*)frame->next)
    {
      if(frame->len)
      {
        ptr_frame->list_len+= frame->len;
        last_byte           = frame->buffer[frame->len - 1];
      }
      temp_desc = frame;
    }
    if(last_byte NEQ PPP_HDLC_FLAG) /*lint !e644 last_byte may not have been initialized */
    {
      MALLOC (frame, (USHORT)(sizeof(T_desc2) - 1 + 1));
      frame->next      = (ULONG)NULL;
      frame->len       = 1;
      frame->buffer[0] = PPP_HDLC_FLAG;
      temp_desc->next  = (ULONG)frame; /*lint !e771 temp_desc conceivably not initialized */
    }
  }
  else
  {
    /*
     * free the empty frame
     */
    arb_discard_packet((T_desc2*)ptr_frame->first);
    ptr_frame->first    = (ULONG)NULL;
    ptr_frame->list_len = 0;
  }
} /* ftx_check_frame() */
#endif  /* PPP_INT_RAM */