/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-F&D (8411)
|  Modul   :  t30_bcsf
+----------------------------------------------------------------------------- 
|  Copyright 2002 Texas Instruments Berlin, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Berlin, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  This Modul defines the procedures and functions for
|             the component T30 of the mobile station
+----------------------------------------------------------------------------- 
*/ 

#ifndef T30_BCSF_C
#define T30_BCSF_C
#endif

#define ENTITY_T30

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

#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include "typedefs.h"
#include "pcm.h"
#include "vsi.h"
#include "macdef.h"
#include "pconst.cdg"
#include "mconst.cdg"
#include "message.h"
#include "ccdapi.h"
#include "custom.h"
#include "gsm.h"
#include "prim.h"
#include "cnf_t30.h"
#include "mon_t30.h"
#include "pei.h"
#include "tok.h"
#include "dti.h"      /* functionality of the dti library */
#include "t30.h"

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

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

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

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


LOCAL const USHORT crctab[256] =
{
  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
  0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
  0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
  0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
  0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
  0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
  0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
  0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
  0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
  0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
  0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
  0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
  0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
  0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
  0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
  0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
  0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
  0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
  0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
  0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
  0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
  0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
  0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
  0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
  0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
  0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
  0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
  0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
  0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
  0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};

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

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_build_report    |
+--------------------------------------------------------------------+

  PURPOSE : build the T30_REPORT_IND primitive out of a send/rec. frame

*/

LOCAL void bcs_build_report(UBYTE *frame, USHORT len, T_T30_REPORT_IND *t30_report_ind)
{
  if (t30_data->bitorder & FBO_REV_STATUS) /* reverse the bitorder of each byte */
  {
    memcpy(t30_report_ind->sdu.buf, frame, len);
  }
  else
  {
    USHORT i;
    for (i=0; i<len; i++)
      t30_report_ind->sdu.buf[i] = BIT_MIRROR[frame[i]];
  }

  t30_report_ind->sdu.l_buf = (len << 3);
  t30_report_ind->sdu.o_buf = 0;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_init            |
+--------------------------------------------------------------------+

  PURPOSE : initialize BCS formatter

*/

GLOBAL void bcs_init(T_T30_DATA *pt30_data)
{
  TRACE_FUNCTION ("bcs_init()");
  memset (pt30_data->bcs_frm, 0, BCS_FRM_SIZE);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_check_frames    |
+--------------------------------------------------------------------+

  PURPOSE : This function checks the final flag and the frame checking sequence.
*/

LOCAL UBYTE bcs_check_frames(UBYTE *idx_max)
{

  T_sdu *sdu = (T_sdu*)t30_data->bcs_frm;
  UBYTE idx;

  for (idx = 0; idx < *idx_max; idx++)
  {
#ifdef _SIMULATION_ /* FCS generating/checking off */
    if (t30_data->test_mode & TST_FCS)
    {
    }
    else
#endif
    {
      USHORT crctt = 0xffff; /* initialize crc */

      /* shift each bit through polynomial */
      USHORT pos;
      for (pos = t30_data->frm[idx].beg; pos <= t30_data->frm[idx].end; pos++)
      {
        SHORT tmp = (crctt >> 8) ^ sdu->buf[pos];
        crctt = ((crctt << 8) ^ crctab[tmp & 0xff]) & 0xffff;
      }
      if (crctt NEQ 0x1D0F) /* check remainder */
        return CHK_FCS_ERR;
    }
#if defined _SIMULATION_ || defined KER_DEBUG_BCS
    ker_debug ("BCS_DATA_IND", (UBYTE*)&sdu->buf[t30_data->frm[idx].beg], (USHORT)(t30_data->frm[idx].end-t30_data->frm[idx].beg));
#endif
    /* count final flags */
    if (sdu->buf[t30_data->frm[idx].beg + 1] & 0x08)
    {
      *idx_max = (UBYTE)idx + 1;
      return CHK_OK;
    }
  }
#ifdef _SIMULATION_ /* Control checking OFF */
  if (t30_data->test_mode & TST_CTRL)
    return CHK_OK;
#endif
  return CHK_FIN_ERR;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_frame_pos       |
+--------------------------------------------------------------------+

  PURPOSE : This function extracts
            the beginning, the end and the length of each frame.
*/

LOCAL UBYTE bcs_frame_pos(UBYTE *flag_vector, UBYTE *idx_max)
{
  USHORT idx = 0;
  T_sdu *sdu = (T_sdu*)t30_data->bcs_frm;

  *idx_max = 0;
  while (idx < sdu->l_buf)
  {
    /* skip flags */
    while (idx < sdu->l_buf AND flag_vector[idx])
      idx++;

    /* ready if last byte is a flag */
    if (idx EQ sdu->l_buf)
      return FRM_OK;

    /* save begin of frame */
    t30_data->frm[*idx_max].beg = idx;

    /* search flag */
    while (idx < sdu->l_buf AND !flag_vector[idx])
      idx++;

    /* error if no flag found */
    if (idx EQ sdu->l_buf)
    {
      t30_data->frm[*idx_max].beg = 0;
      return FRM_OK;  /* return FRM_ERR_NO_FLAG; ??? */
    }

    /* save end of fame and length of frame */
    t30_data->frm[*idx_max].end = idx - 1;
    t30_data->frm[*idx_max].len = idx - t30_data->frm[*idx_max].beg;

    /* error if too many frames received */
    if (++(*idx_max) EQ FRAMES_MAX)
      return FRM_ERR_TOO_MANY_FRAMES;

    /* next frame */
    idx++;
  }
  return FRM_OK;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_report_rcv      |
+--------------------------------------------------------------------+

  PURPOSE : This function reports the received HDLC frames to MMI
            if desired.
*/

LOCAL void bcs_report_rcv(UBYTE idx_max)
{
  T_sdu *sdu = (T_sdu*)t30_data->bcs_frm;
  USHORT idx;

  for (idx = 0 ; idx < idx_max ; idx++)
  {
    if (t30_data->frm[idx].len >= 2)
    {
      PALLOC_SDU (t30_report_ind, T30_REPORT_IND, REPORT_SIZE_BITS);
      bcs_build_report (&sdu->buf[t30_data->frm[idx].beg], (USHORT)(t30_data->frm[idx].len - 2), t30_report_ind);
      t30_report_ind->dir = DIR_RCV;
      PSENDX (MMI, t30_report_ind);
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_decode          |
+--------------------------------------------------------------------+

  PURPOSE : This function decodes each hdlc frame and sends the
            decoded data to the kernel.
*/

/* this function is only necessary because of an iarm compiler failure */
LOCAL void bcs_clear_flag (UBYTE *ptr)
{
  if (*ptr & 0x70)
    *ptr &= 0x7F;
}

LOCAL UBYTE bcs_decode(UBYTE idx_max)
{
  T_sdu *sdu = (T_sdu*)t30_data->bcs_frm;
  UBYTE idx;

  for (idx = 0; idx < idx_max; idx++)
  {
    USHORT begin = t30_data->frm[idx].beg + 2;

    /* set direction flag to zero for CCD decoding */
    bcs_clear_flag (sdu->buf + begin);

    /* set offset and length of current frame */
    sdu->o_buf = begin << 3;
    sdu->l_buf = ((USHORT)(t30_data->frm[idx].len - 4) << 3);

#ifdef _SIMULATION_ /* show contents of buffer */
    if (t30_data->test_mode /* & TST_BUF */)
    {
      ker_debug ("ccd_decode", &sdu->buf[begin], (USHORT)(sdu->l_buf >> 3));
    }
#endif

    if (ccd_decodeMsg(CCDENT_T30, DOWNLINK, (T_MSGBUF*)sdu, _decodedMsg, HDLC_ADDR) EQ ccdError)
    {
      TRACE_EVENT ("ERROR: ccd_decode");
      return CCD_ERR;
    }
    sig_bcs_ker_bdat_ind(); /* send signal to kernel */
  }
  return CCD_OK;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_destuff         |
+--------------------------------------------------------------------+

  PURPOSE : This function de-stuffs the received BCS data.
*/

LOCAL void bcs_destuff(UBYTE *flag_vector)
{
  T_sdu *sdu = (T_sdu*)t30_data->bcs_frm;
  SHORT bcs_tmp_len = 0;
  SHORT ones = 0;
  SHORT bits = 8;
  UBYTE flag = 0;
  UBYTE *bcs_tmp;
  SHORT i;

#ifdef _SIMULATION_ /* bit stuffing/destuffing OFF */
  if (t30_data->test_mode & TST_STUFF)
  {
    for (i = 0; i < sdu->l_buf; i++)
    {
      if (sdu->buf[i] EQ HDLC_FLAG)
        flag_vector[i] = 1;
    }
    if (flag_vector[sdu->l_buf-1] NEQ 1) // trailing HDLC_FLAG is missed
    {
      sdu->l_buf++;
      sdu->buf[sdu->l_buf-1] = HDLC_FLAG;
      flag_vector[sdu->l_buf-1] = 1;
    }
    return;
  }
#endif

  MALLOC(bcs_tmp, sdu->l_buf);
  
  for (i = 0 ; i < sdu->l_buf ; i++)
  {
    UBYTE bit_ptr = 0x80; /* points initially to MSB */

    do /* check each byte for destuffing */
    {
      if (sdu->buf[i] & bit_ptr) /* bit pointed to is 1 */
      {
        ones++;
        bcs_tmp[bcs_tmp_len] = (bcs_tmp[bcs_tmp_len] << 1) | 1;
        flag                 = (flag                 << 1) | 1;

        if (! --bits) /* counter of byte's bits*/
        {
          bcs_tmp_len++;
          bits = 8;
        }
      }
      else /* bit is 0 */
      {
        if (ones != 5)
        {
          bcs_tmp[bcs_tmp_len] <<= 1;
          flag                 <<= 1;

          if (ones EQ 6 && flag EQ HDLC_FLAG)
            flag_vector[bcs_tmp_len] = 1;

          if (! --bits) /* whole byte is scanned */
          {
            bcs_tmp_len++;
            bits = 8;
          }
        }
        ones = 0;
      }
      bit_ptr >>= 1;
    }
    while (bit_ptr);
  }
  /* copy destuffed BCS frame back to sdu */
  memcpy (sdu->buf, bcs_tmp, bcs_tmp_len);
  MFREE(bcs_tmp);

  sdu->l_buf = bcs_tmp_len; /* adjust buffer length */
  if (flag_vector[sdu->l_buf-1] NEQ 1) // trailing HDLC_FLAG is missed
  {
    sdu->l_buf++;
    sdu->buf[sdu->l_buf-1] = HDLC_FLAG;
    flag_vector[sdu->l_buf-1] = 1;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_bcs_decode      |
+--------------------------------------------------------------------+

  PURPOSE : This function gets the frame positions,
            checks the frames,
            reports the contents to MMI if desired,
            decodes the contents and sends the contents to the kernel.
*/

GLOBAL void bcs_bcs_decode(void)
{
  UBYTE *flag_vector, idx_max, ret;

  MALLOC(flag_vector, BCS_FRM_SIZE);
  memset(flag_vector, 0, BCS_FRM_SIZE);
  bcs_destuff(flag_vector);
  ret = bcs_frame_pos(flag_vector, &idx_max); /* determines "idx_max" */
  MFREE(flag_vector);

  switch (ret)
  {
  case FRM_OK:
    ret = bcs_check_frames(&idx_max);
    if (t30_data->hdlc_report)
    {
      bcs_report_rcv(idx_max);
    }
    switch (ret)
    {
    case CHK_OK:
      switch (bcs_decode(idx_max))
      {
      case CCD_OK:
        return;

      case CCD_ERR:
        sig_bcs_ker_err_ind(ERR_CCD_DEC);
        return;
      }
      break; /* dummy */

    case CHK_FCS_ERR:
      sig_bcs_ker_err_ind(ERR_FCS);
      return;

    case CHK_FIN_ERR:
      sig_bcs_ker_err_ind(ERR_FINAL);
      return;
    }
    break;

  case FRM_ERR_NO_FLAG:
    sig_bcs_ker_err_ind(ERR_FRAME_NO_FLAG);
    return;

  case FRM_ERR_TOO_MANY_FRAMES:
    sig_bcs_ker_err_ind(ERR_FRAME_TOO_MANY_FRAMES);
    return;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_report_snd      |
+--------------------------------------------------------------------+

  PURPOSE : This function reports the sent HDLC frames to MMI
            if desired.
*/

LOCAL void bcs_report_snd(void)
{
  T_sdu *BCI_stream = (T_sdu*)t30_data->BCI_stream; // Binary Coded Information

  PALLOC_SDU(t30_report_ind, T30_REPORT_IND, REPORT_SIZE_BITS);
  
  bcs_build_report(&BCI_stream->buf[0], (USHORT)((BCI_stream->l_buf >> 3) + 2), t30_report_ind);
  t30_report_ind->dir = DIR_SND;
  PSENDX (MMI, t30_report_ind);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_fcs_gen         |
+--------------------------------------------------------------------+

  PURPOSE : This function generates the frame checking sequence
            for one HDLC frame.
*/

LOCAL void bcs_fcs_gen (void)
{
  T_sdu *sdu = (T_sdu*)t30_data->BCI_stream;
  USHORT end = (sdu->l_buf >> 3) + 2;
  USHORT pos;
  UBYTE i;

#ifdef _SIMULATION_ /* FCS generating/checking OFF */
  if (t30_data->test_mode & TST_FCS)
  {
    pos = end;
    sdu->buf[pos++] = 0x12;
    sdu->buf[pos++] = 0xEF;
  }
  else
#endif
  {
    USHORT crctt = 0xffff;
    for (pos = 0; pos < end; pos++)
    {
      SHORT tmp =  (crctt >> 8) ^ sdu->buf[pos];
      crctt = ((crctt << 8) ^ crctab[tmp & 0xff]) & 0xffff;
    }
    sdu->buf[pos++] = (~(crctt & 0xffff) & 0xffff) >> 8;/*lint !e661 !e662 (Warning -- Possible access/creation of out-of-bounds pointer)*/
    sdu->buf[pos++] = (~(crctt & 0xffff) & 0xff);/*lint !e661 !e662 (Warning -- Possible access/creation of out-of-bounds pointer)*/
  }

  sdu->l_buf += 32; /* 4 bytes more */

  for (i = 0; i < HDLC_FLAGS; i++)
  {
    sdu->buf[pos++] = HDLC_FLAG;/*lint !e661 !e662 (Warning -- Possible access/creation of out-of-bounds pointer)*/
    sdu->l_buf += 8;
  }
  sdu->o_buf  = 0;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_stuff           |
+--------------------------------------------------------------------+

  PURPOSE : This function stuffs the BCS data.
*/

LOCAL void bcs_stuff (UBYTE final)
{
  T_sdu *sdu_inp  = (T_sdu*)t30_data->BCI_stream;
  T_sdu *sdu_out = &t30_data->fad_data_req->sdu;
  
  UBYTE *buf_in  = sdu_inp->buf;
  USHORT len_in  = sdu_inp->l_buf >> 3;
  UBYTE *buf_out;
  USHORT len_out = sdu_out->l_buf >> 3;
  USHORT i;

#ifdef _SIMULATION_ /* bit stuffing/destuffing OFF */
  if (t30_data->test_mode & TST_STUFF)
  {
    buf_out = &sdu_out->buf[len_out];
    memcpy (buf_out, buf_in, len_in);
    sdu_out->l_buf = (len_out + len_in) << 3;
    return;
  }
#endif

  buf_out = sdu_out->buf;

  for (i = 0; i < len_in; i++)
  {
    USHORT bit_ptr = 0x80;
    UBYTE stuff = 1;
    /*
    check HDLC_FLAGS
    */
    if (buf_in[i] EQ HDLC_FLAG)
    {
      USHORT k;
      for (k = 0; k < HDLC_FLAGS; k++)
      {
        if (i EQ len_in - k - 1)
        {
          stuff = 0;
          break;
        }
      }
    }
    do
    {
      switch (buf_in[i] & bit_ptr)
      {
      default:
        buf_out[len_out] = (buf_out[len_out] << 1) | 1;
        if (! --t30_data->stuff_bits)
        {
          len_out++;
          t30_data->stuff_bits = 8;
        }
        if (!stuff)
        {
          t30_data->stuff_ones = 0;
          break;
        }
        if (++t30_data->stuff_ones != 5)
          break;
        /*
         * otherwise fall through
         */

      case 0:
        buf_out[len_out] <<= 1;
        t30_data->stuff_ones = 0;

        if (! --t30_data->stuff_bits)
        {
          len_out++;
          t30_data->stuff_bits = 8;
        }
        break;
      }
      bit_ptr >>= 1;
    } while (bit_ptr);
  }

  if (final EQ FINAL_YES AND t30_data->stuff_bits NEQ 8)
  {
    buf_out[len_out] <<= t30_data->stuff_bits;
    len_out++;
  }

  sdu_out->l_buf = len_out << 3;

  if (final EQ FINAL_YES)
  {
    t30_data->stuff_ones = 0;
    t30_data->stuff_bits = 8;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_bcs_encode      |
+--------------------------------------------------------------------+

  PURPOSE : This function encodes the HDLC frames,
            reports the HDLC frames to MMI if desired,
            generates the frame checking sequence and stuffs the bits.
*/

GLOBAL void bcs_bcs_encode(UBYTE ctrl, UBYTE final)
{
  T_sdu *sdu = (T_sdu*)t30_data->BCI_stream;

  switch (sdu->buf[2])/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
  {
    case BCS_DIS:
      TRACE_EVENT ("Send BCS_DIS");
      break;
    case BCS_CSI:
      TRACE_EVENT ("Send BCS_CSI");
      break;
    case BCS_NSF:
      TRACE_EVENT ("Send BCS_NSF");
      break;
    case BCS_DTC:
      TRACE_EVENT ("Send BCS_DTC");
      break;
    case BCS_CIG:
      TRACE_EVENT ("Send BCS_CIG");
      break;
    case BCS_NSC:
      TRACE_EVENT ("Send BCS_NSC");
      break;
    case BCS_PWD_POLL:
      TRACE_EVENT ("Send BCS_PWD_POLL");
      break;
    case BCS_SEP:
      TRACE_EVENT ("Send BCS_SEP");
      break;

    case BCS_CFR:
      TRACE_EVENT ("Send BCS_CFR");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_CRP:
      TRACE_EVENT ("Send BCS_CRP");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_DCN:
      TRACE_EVENT ("Send BCS_DCN");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_DCS:
      TRACE_EVENT ("Send BCS_DCS");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_EOM:
      TRACE_EVENT ("Send BCS_EOM");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_EOP:
      TRACE_EVENT ("Send BCS_EOP");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_FTT:
      TRACE_EVENT ("Send BCS_FTT");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_MCF:
      TRACE_EVENT ("Send BCS_MCF");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_MPS:
      TRACE_EVENT ("Send BCS_MPS");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_NSS:
      TRACE_EVENT ("Send BCS_NSS");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_PIN:
      TRACE_EVENT ("Send BCS_PIN");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_PIP:
      TRACE_EVENT ("Send BCS_PIP");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_PRI_EOM:
      TRACE_EVENT ("Send BCS_PRI_EOM");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_PRI_EOP:
      TRACE_EVENT ("Send BCS_PRI_EOP");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_PRI_MPS:
      TRACE_EVENT ("Send BCS_PRI_MPS");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_PWD_SND:
      TRACE_EVENT ("Send BCS_PWD_SND");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_RTN:
      TRACE_EVENT ("Send BCS_RTN");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_RTP:
      TRACE_EVENT ("Send BCS_RTP");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_SUB:
      TRACE_EVENT ("Send BCS_SUB");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
    case BCS_TSI:
      TRACE_EVENT ("Send BCS_TSI");
      sdu->buf[2] |= t30_data->dir;/*lint !e415 !e416 (Warning -- access/creation of out-of-bounds pointer)*/
      break;
  }

  sdu->buf[0] = HDLC_ADDR;
  sdu->buf[1] = ctrl;/*lint !e415 (Warning -- access of out-of-bounds pointer)*/

  if (t30_data->hdlc_report)
  {
    bcs_report_snd();
  }
  bcs_fcs_gen();
  bcs_stuff(final);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)             MODULE  : T30_BCSF            |
| STATE   : code                       ROUTINE : bcs_fill_bcs_frm    |
+--------------------------------------------------------------------+

  PURPOSE : This function checks if the BCS frame buffer has enough
            space to append the received data.
            If there is enough space the data is appended.
            If not than BCS_FRM_FULL is returned.

*/

GLOBAL UBYTE bcs_fill_bcs_frm (T_FAD_DATA_IND *fad_data_ind)
{
  USHORT data_len = fad_data_ind->sdu.l_buf >> 3;
  T_sdu *sdu = (T_sdu*)t30_data->bcs_frm;

  TRACE_FUNCTION("bcs_fill_bcs_frm()");

  if (sdu->l_buf + data_len < BCS_FRM_SIZE)
  {
    memcpy (&sdu->buf[sdu->l_buf], fad_data_ind->sdu.buf, data_len);
    sdu->l_buf += data_len;
    return ((fad_data_ind->final) ? BCS_FRM_FILLED : BCS_FRM_FILLING);
  }
  else
  {
    sdu->l_buf = BCS_FRM_SIZE;
    return (BCS_FRM_FULL);
  }
}