/*
+-----------------------------------------------------------------------------
|  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 UART and implements all
|             procedures and functions as described in the
|             SDL-documentation (RX-statemachine)
+-----------------------------------------------------------------------------
*/

#ifndef UART_RXF_C
#define UART_RXF_C
#endif /* !UART_RXF_C */

#define ENTITY_UART

#ifndef FF_MULTI_PORT
/*==== INCLUDES =============================================================*/

#ifdef WIN32
#include "nucleus.h"
#endif /* WIN32 */
#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"
#include "gsm.h"        /* to get a lot of macros */
#include "cnf_uart.h"   /* to get cnf-definitions */
#include "mon_uart.h"   /* to get mon-definitions */
#include "prim.h"       /* to get the definitions of used SAP and directions */
#ifdef DTILIB
#include "dti.h"        /* to get dti lib */
#endif /* DTILIB */
#include "pei.h"        /* to get PEI interface */
#ifdef _TARGET_
#include "uart/serialswitch.h"
#include "uart/traceswitch.h"
#else /* _TARGET_ */
#include "serial_dat.h" /* to get definitions of serial driver */
#endif /* _TARGET_ */
#include "uart.h"       /* to get the global entity definitions */

#ifdef _SIMULATION_
#include <stdio.h>      /* to get sprintf */
#endif /* _SIMULATION_ */
#include <string.h>    /* JK, delete warnings: to get memcpy */

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

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

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

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



/*
+------------------------------------------------------------------------------
| Function    : rx_proc_input
+------------------------------------------------------------------------------
| Description : The function rx_proc_input() is the actual callback function
|               to read data from the receive buffer.
|
| Parameters  : uart_device - database for the affected UART device
|
+------------------------------------------------------------------------------
*/
LOCAL void rx_proc_input (T_UART_DATA* uart_device)
{
  USHORT  i, len;
  T_DLC   *dlc;               /* used Data Link Connection */
  UBYTE   *source;            /* Data source pointer */
  UBYTE   *destination;       /* Data destination pointer */
  UBYTE   temp_field;         /* multi purpose value */
  BOOL    channels_complete;  /* indicator of complete reception */
  SHORT   error_code;         /* error code returned from a function */

  TRACE_FUNCTION( "rx_proc_input" );

  /*
   * read data only if we have read permission
   */
  if(uart_device->rx.read_permission)
  {
    if(uart_device->rx.dlc_instance EQ UART_EMPTY_INSTANCE)
      dlc = &uart_device->dlc_table[UART_CONTROL_INSTANCE];
    else
      dlc = &uart_device->dlc_table[uart_device->rx.dlc_instance];
    destination = &dlc->receive_data->buffer[dlc->receive_pos];
#ifdef _SIMULATION_
{
  char buf[80];
  sprintf(buf,"uart_device->rx.dlc_instance: %d", uart_device->rx.dlc_instance);
  TRACE_EVENT(buf);
}
#endif /* _SIMULATION_ */
    if(uart_device->rx.dlc_instance EQ UART_EMPTY_INSTANCE)
    {
      /*
       * Raw data
       */
      /*
       * Is a data descriptor allocated and
       * is the channel ready to receive
       */
      if((dlc->receive_process EQ UART_RX_PROCESS_READY) &&
         (dlc->receive_data))
      {
        for (i=0; i < uart_device->rx.nsource; i++)
        {
          /*
           * are there still data in the ring buffer segment and
           * are there still space in the data descriptor
           */
          if ((uart_device->rx.size[i] > 0) &&
              (dlc->receive_size > dlc->receive_pos))
          {
            len = dlc->receive_size - dlc->receive_pos;
            if (len > uart_device->rx.size[i])
              len = uart_device->rx.size[i];

            memcpy(&dlc->receive_data->buffer[dlc->receive_pos],
                   uart_device->rx.source[i],
                   len);

            uart_device->rx.size[i] -= len;
            dlc->receive_pos        += len;
            dlc->receive_data->len   = dlc->receive_pos;
          }
        }
        dlc->receive_process = UART_RX_PROCESS_COMPLETE;
      }
    }
    else
    {
      channels_complete = FALSE;
      /*
       * for each fragment
       */
      for (i=0; i < uart_device->rx.nsource; i++)
      {
        /*
         * while there is still data in buffer and
         * not yet all channels are processed
         */
        source = uart_device->rx.source[i];
        while((uart_device->rx.size[i] > 0) && (channels_complete NEQ TRUE))
        {
          /*
           * detect HDLC flag
           */
          if(*source EQ UART_HDLC_FLAG)
          {
            switch(uart_device->rx.analyze_state)
            {
              case UART_RX_ERROR:
                /*
                 * begin of frame detected
                 */
                uart_device->rx.analyze_state = UART_RX_BEGIN;
                /* fall through */
              case UART_RX_BEGIN:
                /*
                 * initialize new packet
                 */
                uart_device->rx.stored_len    = 0;
                uart_device->rx.address_field = 0;
                uart_device->rx.fcs           = UART_INITFCS;
                uart_device->rx.escape        = FALSE;
                uart_device->rx.analyze_state = UART_RX_ADDRESS;
                break;

              default:
                /*
                 * detect HDLC flag
                 */
                if(uart_device->rx.stored_len > 0)
                {
                  /*
                   * determine whether FCS already calculated
                   */
                  if(uart_device->rx.analyze_state NEQ UART_RX_FCS)
                  {
                    /*
                     * UART_RX_INFORMATION_...
                     */
                    destination--;
#ifdef _SIMULATION_
                    uart_device->rx.fcs = *destination;
#else /* _SIMULATION_ */
                    uart_device->rx.fcs = uart_device->
                                        fcstab[uart_device->rx.fcs ^ *destination];
#endif /* _SIMULATION_ */
                    /*
                     * remove FCS from data stream
                     */
                    dlc->receive_pos--;
                    uart_data->rx.stored_len--;
                  }
                  if(uart_device->rx.fcs EQ UART_GOODFCS)
                  {
                    /*
                     * no error occured, frame complete
                     */
                    dlc->receive_data->len        = dlc->receive_pos;
                    dlc->receive_process          = UART_RX_PROCESS_COMPLETE;
                    uart_device->rx.analyze_state = UART_RX_END;
                    break;
                  }
                }
                /*
                 * remove receiced frame because of an error
                 */
                switch(uart_device->rx.analyze_state)
                {
                  case UART_RX_INFORMATION:
                  case UART_RX_FCS:
                    if(uart_data->rx.dlc_instance EQ UART_CONTROL_INSTANCE)
                      dlc->receive_pos-= 2;
                    dlc->receive_pos    -= uart_data->rx.stored_len;
                    dlc->receive_process = UART_RX_PROCESS_READY;
                    break;
                  default:
                    /*
                     * Other states are not handeled here
                     */
                    break;
                }
                uart_device->rx.analyze_state = UART_RX_END;
                break;
            }
          }
          else if((*source EQ UART_HDLC_ESCAPE) &&
                  (uart_device->rx.escape NEQ TRUE))
          {
            /*
             * detect Control Escape octet
             */
            uart_device->rx.escape = TRUE;
          }
          else
          {
            /*
             * bit 5 complement for the octet followed by Control Escape
             */
            if(uart_device->rx.escape EQ TRUE)
            {
              *source             ^= 0x20;
              uart_device->rx.escape = FALSE;
            }
            /*
             * store the packet and determine the protocol
             */
            switch(uart_device->rx.analyze_state)
            {
              case UART_RX_ERROR:
                /*
                 * wait for next HDLC flag
                 */
                break;

              case UART_RX_ADDRESS:
                if((*source & UART_EA) EQ UART_EA)
                {
                  /*
                   * FCS calculation
                   */
#ifdef _SIMULATION_
                  uart_device->rx.fcs = *source;
#else /* _SIMULATION_ */
                  uart_device->rx.fcs = uart_device->
                                      fcstab[uart_device->rx.fcs ^ *source];
#endif /* _SIMULATION_ */
                  /*
                   * store Address field
                   */
                  uart_device->rx.address_field = *source;
                  uart_device->rx.analyze_state = UART_RX_CONTROL;
                }
                else
                {
                  /*
                   * invalid frame detected
                   */
                  uart_device->rx.analyze_state = UART_RX_ERROR;
                }
                break;

              case UART_RX_CONTROL:
                switch(*source)
                {
                  case UART_UIH_DATA_FRAME:
                    /*
                     * Data frame detected
                     */
                    temp_field = uart_device->rx.address_field >> UART_DLCI_POS;
                    /*
                     * if it is an existing channel, but not control channel
                     */
                    if((temp_field NEQ UART_DLCI_CONTROL) &&
                       (uart_device->dlc_instance[temp_field] NEQ
                          UART_EMPTY_INSTANCE))
                    {
                      uart_device->rx.dlc_instance =
                        uart_device->dlc_instance[temp_field];
                      dlc = &uart_device->dlc_table[uart_device->rx.dlc_instance];
#ifdef _SIMULATION_
                      TRACE_EVENT_P2("Addressfield found DLCI: 0x%02X \
                                     (dlc_instance 0x%02X)",
                                     temp_field, uart_device->rx.dlc_instance);
#endif /* _SIMULATION_ */
                      if(dlc->receive_process EQ UART_RX_PROCESS_READY)
                      {
                        /*
                         * reception Data channel found
                         * FCS calculation
                         */
#ifdef _SIMULATION_
                        uart_device->rx.fcs = *source;
#else /* _SIMULATION_ */
                        uart_device->rx.fcs = uart_device->
                                            fcstab[uart_device->
                                            rx.fcs ^ *source];
#endif /* _SIMULATION_ */
                        destination = &dlc->receive_data->
                                       buffer[dlc->receive_pos];
                        uart_device->rx.analyze_state = UART_RX_INFORMATION;
                        break;
                      }
                      else if(dlc->receive_process EQ UART_RX_PROCESS_COMPLETE)
                      {
                        channels_complete = TRUE;
                        break;
                      }
                    }
                    /* fall through */
                  case UART_SABM_FRAME:
                  case UART_UA_FRAME:
                  case UART_DM_DATA_FRAME:
                  case UART_DM_CONTROL_FRAME:
                  case UART_DISC_FRAME:
                  case UART_UIH_CONTROL_FRAME:
                    /*
                     * Control frame detected
                     */
                    dlc = &uart_device->dlc_table[UART_CONTROL_INSTANCE];
                    uart_device->rx.dlc_instance = UART_CONTROL_INSTANCE;
                    if(dlc->receive_process EQ UART_RX_PROCESS_READY)
                    {
                      /*
                       * reception Control channel found
                       * FCS calculation
                       */
#ifdef _SIMULATION_
                      uart_device->rx.fcs = *source;
#else /* _SIMULATION_ */
                      uart_device->rx.fcs = uart_device->
                                          fcstab[uart_device->
                                          rx.fcs ^ *source];
#endif /* _SIMULATION_ */
                      destination = &dlc->receive_data->
                                     buffer[dlc->receive_pos];
                      uart_device->rx.analyze_state = UART_RX_INFORMATION;
                      /*
                       * store Address and Control field
                       */
                      *destination = uart_device->rx.address_field;
                      destination++;
                      dlc->receive_pos++;
                      *destination = *source;
                      destination++;
                      dlc->receive_pos++;
                    }
                    else if(dlc->receive_process EQ UART_RX_PROCESS_COMPLETE)
                    {
                      channels_complete = TRUE;
                    }
                    else
                      /*
                       * discard frame, because it is unexpected
                       */
                      uart_device->rx.analyze_state = UART_RX_ERROR;
                    break;
                  default:
                    /*
                     * invalid frame detected
                     */
                    uart_device->rx.analyze_state = UART_RX_ERROR;
                    break;
                }
                break;

              case UART_RX_INFORMATION:
                if(uart_device->rx.stored_len < uart_device->n1)
                {
                  *destination = *source;
                  /*
                   * increase destination pointer
                   */
                  destination++;
                  uart_device->rx.stored_len++;
                  dlc->receive_pos++;
                }
                else
                {
                  /*
                   * FCS calculation
                   */
#ifdef _SIMULATION_
                  uart_device->rx.fcs = *source;
#else /* _SIMULATION_ */
                  uart_device->rx.fcs = uart_device->
                                      fcstab[uart_device->rx.fcs ^ *source];
#endif /* _SIMULATION_ */
                  uart_device->rx.analyze_state = UART_RX_FCS;
                }
                break;

              case UART_RX_FCS:
                /*
                 * remove receiced packet because its to long
                 */
                if(uart_data->rx.dlc_instance EQ UART_CONTROL_INSTANCE)
                  dlc->receive_pos-= 2;
                dlc->receive_pos             -= uart_data->rx.stored_len;
                dlc->receive_process          = UART_RX_PROCESS_READY;
                uart_device->rx.analyze_state = UART_RX_ERROR;
                break;

              default:
                /*
                 * wrong analyze state
                 */
                uart_device->rx.analyze_state = UART_RX_ERROR;
                break;
            }
          }
          if(uart_device->rx.analyze_state EQ UART_RX_END)
            uart_device->rx.analyze_state = UART_RX_BEGIN;
          /*
           * don't move source pointer
           * if each possible channel was processed
           * In this case analyze_state should be UART_RX_CONTROL.
           * The Control field must be analyzed again in next call of
           * this function.
           */
          else if(channels_complete NEQ TRUE)
          {
            /*
             * increase source pointer
             */
            source++;
            uart_device->rx.size[i]--;
          }
        }
      }
    }
  }

  PSIGNAL(hCommUART, UART_DRIVER_RECEIVED_IND, uart_device);

  *uart_device->rx.reInstall = rm_noInstall;

  /*
   * update pointer in UART driver
   */
  if((error_code = UF_InpAvail (uart_device->device)) < 0 )
  {
    TRACE_ERROR_P2("UF Driver: DataPointerUpdate failed, [%d], uart_rxf.c(%d)",
                                                         error_code, __LINE__);
  }
} /* rx_proc_input() */



/*
+------------------------------------------------------------------------------
| Function    : rx_init
+------------------------------------------------------------------------------
| Description : The function rx_init() initializes the RX service
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void rx_init ()
{
#ifndef _SIMULATION_
#ifdef WIN32
#ifndef _TARGET_
  char    buf[80];
#endif /* !_TARGET_ */
  STATUS  sts;
#endif /* WIN32 */
#endif /* !_SIMULATION_ */

  TRACE_FUNCTION( "rx_init" );

#ifndef _SIMULATION_
#ifdef WIN32
  sts = NU_Create_HISR (&uart_data->rx.rx_HISR,
                        "RX_HISR",
                        rx_proc_input,
                        2,
                        uart_data->HISR_stack,
                        HISR_STACK_SIZE);
#ifndef _TARGET_
  sprintf (buf, "NU_Create_HISR(RX) = %d", sts);
  TRACE_EVENT (buf);
#endif /* _TARGET_ */
#endif /* WIN32 */
#endif /* !_SIMULATION_ */

  uart_data->rx.read_permission = FALSE;
  uart_data->rx.prev_lines      = 0;
  uart_data->rx.dlc_instance    = UART_EMPTY_INSTANCE;
  uart_data->rx.escape          = FALSE;
  uart_data->rx.analyze_state   = UART_RX_ERROR;
  uart_data->rx.receive_state   = UART_RX_NOT_RECEIVING;
  uart_data->rx.fcs             = UART_INITFCS;
  uart_data->rx.address_field   = 0;
  uart_data->rx.stored_len      = 0;

  INIT_STATE( UART_SERVICE_RX , RX_DEAD );
} /* rx_init() */



/*
+------------------------------------------------------------------------------
| Function    : rx_readOutFunc_0
+------------------------------------------------------------------------------
| Description : The function rx_readOutFunc_0() is the official callback
|               function to read data from the receive buffer of UART device 0.
|               It just copies the parameters and calls then the actual
|               function.
|
| Parameters  : cldFromIrq - called from interrupt
|               reInstall  - reinstallation mode
|               nsource    - number of source pointers
|               source     - array of source pointers
|               size       - array of sizes for every source pointer
|               state      - state of V.24 lines
|
+------------------------------------------------------------------------------
*/
GLOBAL void rx_readOutFunc_0 (BOOL           cldFromIrq,
                              T_reInstMode  *reInstall,
                              UBYTE          nsource,
                              UBYTE         *source[],
                              USHORT        *size,
                              ULONG          state)
{
#ifndef _SIMULATION_
#ifndef _TARGET_
  char buf[40];
#endif /* !_TARGET_ */
#endif /* !_SIMULATION_ */
  T_UART_DATA* uart_device;

  TRACE_FUNCTION( "rx_readOutFunc_0" );

  /*
   * select UART device 0
   */
  uart_device = &(uart_data_base[0]);

  /*
   * store parameters
   */
  uart_device->rx.cldFromIrq = cldFromIrq;
  uart_device->rx.nsource    = nsource;
  uart_device->rx.source[0]  = source[0];
  uart_device->rx.source[1]  = source[1];
  uart_device->rx.size       = size;
  uart_device->rx.lines      = state;
  uart_device->rx.reInstall  = reInstall;

#ifndef _SIMULATION_
#ifdef WIN32
  if (cldFromIrq)
  {
    STATUS sts;
    /*
     * interrupt context of the UART driver -> activate the HISR
     */
    sts = NU_Activate_HISR (&uart_device->rx.rx_HISR);
#ifndef _TARGET_
    sprintf (buf, "NU_Activate_HISR(RX) = %d", sts);
    TRACE_EVENT (buf);
#endif /* !_TARGET_ */
  }
  else
#endif /* WIN32 */
#endif /* !_SIMULATION_ */
  {
#ifdef _SIMULATION_
    UBYTE*  trace_source[2];
    USHORT  trace_size[2];
    USHORT  i;
    USHORT  pos;
    char    buf[90];

    trace_source[0] = source[0];
    trace_source[1] = source[1];

    trace_size[0] = size[0];
    trace_size[1] = size[1];

    /*
     * trace input
     */
    if((nsource) &&
       (uart_device->rx.read_permission))
    {

      TRACE_EVENT("==== INRAW");
      i   = 0;
      pos = 0;
      while(pos < trace_size[0])
      {
        i+= sprintf(&buf[i], "0x%02x, ", trace_source[0][pos]);
        pos++;
        if(i > 80)
        {
          TRACE_EVENT( buf );
          i = 0;
        }
        else if(pos >= trace_size[0])
        {
          TRACE_EVENT( buf );
        }
      }
      if(nsource > 1)
      {
        i   = 0;
        pos = 0;
        while(pos < trace_size[1])
        {
          i+= sprintf(&buf[i], "0x%02x, ", trace_source[1][pos]);
          pos++;
          if(i > 80)
          {
            TRACE_EVENT( buf );
            i = 0;
          }
          else if(pos >= trace_size[1])
          {
            TRACE_EVENT( buf );
          }
        }
      }
    }
#endif /* _SIMULATION_ */

    /*
     * normal callback from UF_ReadData
     */
    rx_proc_input(uart_device);
  }

} /* rx_readOutFunc_0() */



#ifdef FF_TWO_UART_PORTS
/*
+------------------------------------------------------------------------------
| Function    : rx_readOutFunc_1
+------------------------------------------------------------------------------
| Description : The function rx_readOutFunc_1() is the official callback
|               function to read data from the receive buffer of UART device 1.
|               It just copies the parameters and calls then the actual
|               function.
|
| Parameters  : cldFromIrq - called from interrupt
|               reInstall  - reinstallation mode
|               nsource    - number of source pointers
|               source     - array of source pointers
|               size       - array of sizes for every source pointer
|               state      - state of V.24 lines
|
+------------------------------------------------------------------------------
*/
GLOBAL void rx_readOutFunc_1 (BOOL           cldFromIrq,
                              T_reInstMode  *reInstall,
                              UBYTE          nsource,
                              UBYTE         *source[],
                              USHORT        *size,
                              ULONG          state)
{
#ifndef _SIMULATION_
#ifndef _TARGET_
  char buf[40];
#endif /* !_TARGET_ */
#endif /* !_SIMULATION_ */
  T_UART_DATA* uart_device;

  TRACE_FUNCTION( "rx_readOutFunc_1" );

  /*
   * select UART device 1
   */
  uart_device = &(uart_data_base[1]);

  /*
   * store parameters
   */
  uart_device->rx.cldFromIrq = cldFromIrq;
  uart_device->rx.nsource    = nsource;
  uart_device->rx.source[0]  = source[0];
  uart_device->rx.source[1]  = source[1];
  uart_device->rx.size       = size;
  uart_device->rx.lines      = state;
  uart_device->rx.reInstall  = reInstall;

#ifndef _SIMULATION_
#ifdef WIN32
  if (cldFromIrq)
  {
    STATUS sts;
    /*
     * interrupt context of the UART driver -> activate the HISR
     */
    sts = NU_Activate_HISR (&uart_device->rx.rx_HISR);
#ifndef _TARGET_
    sprintf (buf, "NU_Activate_HISR(RX) = %d", sts);
    TRACE_EVENT (buf);
#endif /* !_TARGET_ */
  }
  else
#endif /* WIN32 */
#endif /* !_SIMULATION_ */
  {
#ifdef _SIMULATION_
    UBYTE*  trace_source[2];
    USHORT  trace_size[2];
    USHORT  i;
    USHORT  pos;
    char    buf[90];

    trace_source[0] = source[0];
    trace_source[1] = source[1];

    trace_size[0] = size[0];
    trace_size[1] = size[1];

    /*
     * trace input
     */
    if((nsource) &&
       (uart_device->rx.read_permission))
    {

      TRACE_EVENT("==== INRAW");
      i   = 0;
      pos = 0;
      while(pos < trace_size[0])
      {
        i+= sprintf(&buf[i], "0x%02x, ", trace_source[0][pos]);
        pos++;
        if(i > 80)
        {
          TRACE_EVENT( buf );
          i = 0;
        }
        else if(pos >= trace_size[0])
        {
          TRACE_EVENT( buf );
        }
      }
      if(nsource > 1)
      {
        i   = 0;
        pos = 0;
        while(pos < trace_size[1])
        {
          i+= sprintf(&buf[i], "0x%02x, ", trace_source[1][pos]);
          pos++;
          if(i > 80)
          {
            TRACE_EVENT( buf );
            i = 0;
          }
          else if(pos >= trace_size[1])
          {
            TRACE_EVENT( buf );
          }
        }
      }
    }
#endif /* _SIMULATION_ */

    /*
     * normal callback from UF_ReadData
     */
    rx_proc_input(uart_device);
  }

} /* rx_readOutFunc_1() */
#endif /* FF_TWO_UART_PORTS */
#endif /* !FF_MULTI_PORT */