/************* Revision Control System Header *************
 *                  GSM Layer 1 software
 * MACS.C
 *
 *        Filename macs.c
 *  Copyright 2003 (C) Texas Instruments
 *
 ************* Revision Control System Header *************/


//---Configuration flags---------------------------------------------------

#define TFI_FILTERING   1   // TFI FILTERING activated if set to 1
//-------------------------------------------------------------------------


#include <stdlib.h>
#include <stdio.h>

#include "l1_macro.h"
#include "l1_confg.h"

#if L1_GPRS

#include "l1_types.h"
#include "l1_const.h"

#if TESTMODE
  #include "l1tm_defty.h"
  #include "l1tm_varex.h"
#endif
#if (AUDIO_TASK == 1)
  #include "l1audio_const.h"
  #include "l1audio_cust.h"
  #include "l1audio_defty.h"
#endif
#if (L1_GTT == 1)
  #include "l1gtt_const.h"
  #include "l1gtt_defty.h"
#endif
#if (L1_MP3 == 1)
  #include "l1mp3_defty.h"
#endif
#if (L1_MIDI == 1)
  #include "l1midi_defty.h"
#endif
#include "l1_defty.h"
#include "l1_varex.h"
#include "l1_signa.h"

#include "l1p_cons.h"
#include "l1p_msgt.h"
#include "l1p_deft.h"
#include "l1p_vare.h"
#include "l1p_sign.h"

#include "macs_def.h"
#include "macs_cst.h"
#include "macs_var.h"

#if FF_TBF
  #include "l1_trace.h"
  #if (CODE_VERSION == SIMULATION)
    #include "sim_cons.h"
    #include "sim_def.h"
    #include "sim_var.h"
  #endif
#endif
/**********************************************************/
/* MACS-S Prototypes                                      */
/**********************************************************/

void l1ps_macs_meas            (void);                // Measurement gap processing
void l1ps_macs_header_decoding (UWORD8 rx_no,
                                UWORD8 *tfi_result,
                                UWORD8 *pr);          // MAC header decoding
void l1ps_macs_read            (UWORD8 pr_table[8]);  // MAC-S control tasks processing
void l1ps_macs_ctrl            (void);                // MAC-S read tasks processing
void l1ps_macs_init            (void);                // MAC-S initialization

#if FF_TBF
void l1ps_macs_rlc_uplink_info (void);
#endif

/**********************************************************/
/* EXTERNAL Prototypes                                    */
/**********************************************************/

void l1pddsp_transfer_mslot_ctrl(UWORD8  burst_nb,
                                 UWORD8  dl_bitmap,
                                 UWORD8  ul_bitmap,
                                 UWORD8  *usf_table,
                                 UWORD8  mac_mode,
                                 UWORD8  *ul_buffer_index,
                                 UWORD8  tsc,
                                 UWORD16 radio_freq,
                                 UWORD8  synchro_timeslot,
                               #if FF_L1_IT_DSP_USF
                                 UWORD8  dsp_usf_interrupt
                               #else
                                 UWORD8  usf_vote_enable
                               #endif
                               );

/* RLC interface for uplink RLC/MAC blocks */
/*-----------------------------------------*/

void rlc_uplink(
                 UWORD8   assignment_id,
                 UWORD8   tx_data_no,            // Number of timeslot that can be used
                                                 //   for uplink data block transfer
                 UWORD32  fn,                    // Next frame number
                 UWORD8   timing_advance_value,  // Timing advance (255 if unknown)
                 API      *ul_poll_response,     // Pointer on a_pu_gprs (NDB): poll response blocks
                 API      *ul_data,              // Pointer on a_du_gprs (NDB): uplink data blocks
                 BOOL     allocation_exhausted   // Set to 1 if fixed allocation exhausted
               );

#if TESTMODE
void l1tm_rlc_uplink(UWORD8 tx, API *ul_data);
#endif

/* RLC interface for downlink RLC/MAC blocks */
/*-------------------------------------------*/
#if FF_TBF

void rlc_downlink_data(
                        UWORD8   assignment_id,
                        UWORD32  fn,             // Actual frame number
                        API      *dl             // Pointer on a_dd_gprs (NDB): downlink blocks
                      );
void rlc_uplink_info(
                     UWORD8   assignment_id,
                     UWORD32  fn,
                     UWORD8   rlc_blocks_sent,    // Number of uplink blocks that was transmitted
                                                  // during the last block period
                     UWORD8   last_poll_response  // Status of the poll responses of
                    );                            // the last block period

UWORD8 rlc_downlink_copy_buffer(UWORD8 isr);


#else

void rlc_downlink(
                   UWORD8   assignment_id,
                   UWORD32  fn,                  // Actual frame number
                   API      *dl,                 // Pointer on a_dd_gprs (NDB): downlink blocks
                   UWORD8   rlc_blocks_sent,     // Number of uplink blocks that was transmitted
                                                 //   during the last block period
                   UWORD8   last_poll_response   // Status of the poll responses of
                                                 //   the last block period
                 );

#endif

#if (TRACE_TYPE==1) || (TRACE_TYPE==4)
  #include "l1_trace.h"
#endif


#if FF_TBF
  #include <stddef.h>

  #if (CODE_VERSION == SIMULATION)
    API* const A_DD_XGPRS[1][4] =
    {
      {&buf.ndb_gprs.a_dd_gprs[0][0], &buf.ndb_gprs.a_dd_gprs[1][0], &buf.ndb_gprs.a_dd_gprs[2][0], &buf.ndb_gprs.a_dd_gprs[3][0]},
    };

    API* const A_DU_XGPRS[1][4] =
    {
      {&buf.ndb_gprs.a_du_gprs[0][0], &buf.ndb_gprs.a_du_gprs[1][0], &buf.ndb_gprs.a_du_gprs[2][0], &buf.ndb_gprs.a_du_gprs[3][0]}
    };

  #else
    API* const A_DD_XGPRS[1][4] =
    {
      {
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS, a_dd_gprs[0][0])),
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS, a_dd_gprs[1][0])),
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS, a_dd_gprs[2][0])),
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS, a_dd_gprs[3][0]))
      }
    };

    API* const  A_DU_XGPRS[1][4] =
    {
      {
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS,a_du_gprs[0][0])),
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS,a_du_gprs[1][0])),
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS,a_du_gprs[2][0])),
        (API*)(NDB_ADR_GPRS + offsetof(T_NDB_MCU_DSP_GPRS,a_du_gprs[3][0]))
      }
    };
  #endif

#endif
/*-----------------------------------------------------------*/
/* l1ps_macs_init()                                          */
/*-----------------------------------------------------------*/
/* Parameters:                                               */
/*                                                           */
/* Return:                                                   */
/*                                                           */
/* Description: This function initializes MAC-S variables    */
/*              and must be called before the first call     */
/*              of MAC-S                                     */
/*-----------------------------------------------------------*/
void l1ps_macs_init(void)
{
  UWORD8 i;

  #if FF_TBF
    macs.dl_buffer_index            = INVALID;
    for (i=0;i<NBR_SHARED_BUFFER_RLC;i++)
      macs.rlc_dbl_buffer[i].d_rlcmac_rx_no_gprs = 0xff;
  #endif
  /* General TBF parameters processed by MAC-S */
  /*********************************************/

  macs.sti_block_id           = 0;

  /* Ressources allocated by MAC-S             */
  /*********************************************/

  macs.rx_allocation          = 0;
  macs.tx_allocation          = 0;
  macs.tx_prach_allocation    = 0;
  macs.tx_data                = 0;
  macs.pwr_allocation         = 0xff;
  macs.last_rx_alloc          = 0;

  #if FF_L1_IT_DSP_USF
    macs.dsp_usf_interrupt    = 0;
  #endif

  macs.rx_blk_period          = NO_DL_BLK;
  macs.rlc_blocks_sent        = 0;
  macs.rx_no                  = 0;
  macs.last_poll_response     = 0;

  macs.usf_good               = 0;
  macs.usf_vote_enable        = 0;
  macs.tra_gap                = 8;
  macs.fix_alloc_exhaust      = FALSE;
  macs.next_usf_mon_block[0]  = macs.next_usf_mon_block[1] = 0;

  for (i = 0; i < TS_NUMBER; i ++)
  {
    macs.ul_buffer_index[i] = INVALID;
  }
  #if L1_EDA
    for (i = 0; i < 4; i++)
    {
      macs.monitored_ts[i] = INVALID;
    }
    macs.rx_monitored      = 0;
    macs.last_rx_monitored = 0;
    macs.lowest_poll_ts    = INVALID;
  #endif

  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
    // Reset PDTCH trace structure
    for(i=0; i<8; i++)
    {
      trace_info.pdtch_trace.dl_status[i] = 0;
      trace_info.pdtch_trace.ul_status[i] = 0;
      trace_info.pdtch_trace.blk_status   = 0;
    }
  #endif

} /* End of l1ps_macs_init */

/*-----------------------------------------------------------*/
/* l1ps_macs_ctrl()                                          */
/*-----------------------------------------------------------*/
/* Parameters:global l1ps_macs_com           changed         */
/*            global l1s                     unchanged       */
/*            global l1a_l1s_com             unchanged       */
/*            global l1ps_dsp_com            changed         */
/*                                                           */
/* Return:                                                   */
/*                                                           */
/* Description: MAC_S manages the timeslot allocation for    */
/*              downlink and uplink transfer and assign a    */
/*              measurement gap according to the MS class,   */
/*              the frame number when it's called and the    */
/*              allocation information given by Layer 1.     */
/*              It also program the corresponding tasks on   */
/*              the DSP and asks the RLC layer for uplink    */
/*              blocks                                       */
/*-----------------------------------------------------------*/
void l1ps_macs_ctrl(void)
{
  #define NDB_PTR  l1ps_dsp_com.pdsp_ndb_ptr
  #define SET_PTR  l1pa_l1ps_com.transfer.aset

  #if MACS_STATUS
    // No error
    l1ps_macs_com.macs_status.nb = 0;
  #endif

  /***********************************************************/
  /* USF values updating in dynamic mode (first frames of    */
  /* block periods)                                          */
  /***********************************************************/

  if  ((SET_PTR->allocated_tbf == UL_TBF) || (SET_PTR->allocated_tbf == BOTH_TBF))
  {
  #if L1_EDA
    if ((SET_PTR->mac_mode == DYN_ALLOC) || (SET_PTR->mac_mode == EXT_DYN_ALLOC))
  #else
    if (SET_PTR->mac_mode == DYN_ALLOC)
  #endif
    {
      // Test if the USF must be read in the current frame
      // Concern the first frames of each block period (useful when
      // some USF values weren't valid the frame before)
      //                                                            FN 13
      //    0   1   2   3    4   5   6   7    8   9   10  11   12
      // ----------------------------------------------------------
      // ||       B0      ||       B1      ||       B2      || I ||
      // ||   |   |   |   ||   | X |   |   ||   | X |   |   ||   ||
      // ----------------------------------------------------------
      //                                                            X:USF Reading

    #if FF_L1_IT_DSP_USF
      if (l1ps_macs_com.usf_status == USF_IT_DSP)
    #else
      if (   (l1s.next_time.fn_mod13 == 5)
          || (l1s.next_time.fn_mod13 == 9))
    #endif
      {
        // USF values are read
        // Uplink timeslots whose USF was INVALID the frame before are de-allocated
        // if their USF value is now BAD

        UWORD8 tn;

        // Reading of the d_usf_updated_gprs value
        API    usf_updated = NDB_PTR->d_usf_updated_gprs;

        #if !L1_EDA
        // For each timeslot that can be allocated in uplink...
        for (tn = macs.first_monitored_ts; tn <= macs.last_monitored_ts; tn ++)
        {
          // If USF vote was enabled on this timeslot
          if(macs.usf_vote_enable & (MASK_SLOT0 >> tn))
          {
            // Clear the USF vote flag
            macs.usf_vote_enable &= ~(MASK_SLOT0 >> tn);

            // Read USF value
            if (((usf_updated >> ((MAX_TS_NB - tn) * 2)) & MASK_2SLOTS) == USF_GOOD)
            {
              // This timeslot is valid and good
              macs.usf_good |= (UWORD8) (MASK_SLOT0 >> (tn + 3));
              macs.next_usf_mon_block[tn - macs.first_monitored_ts] = l1s.next_time.block_id + USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity];
            }
            else
            {
              // This timeslot is bad or invalid
              // If the slot was allocated for data
              if (macs.tx_data & (MASK_SLOT0 >> (tn + RXTX_DELAY)))
              {
                // rlc_blocks_sent decremented
                macs.rlc_blocks_sent --;

              #if FF_L1_IT_DSP_USF
                    // If next timeslot is also a data block:
                    // Shift data block to next TX opportunity. For MS class 12
                    // with dynamic allocation, 2 TX data max and they are
                    // contiguous (optimization).
                    if (macs.tx_data & (MASK_SLOT0 >> (tn + 1 + RXTX_DELAY)))
                    {
                      macs.ul_buffer_index[tn + 1 + RXTX_DELAY] = macs.ul_buffer_index[tn + RXTX_DELAY];

                    }

                    // Cancel burst
                    macs.ul_buffer_index[tn + RXTX_DELAY] = INVALID;

              #endif // FF_L1_IT_DSP_USF

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
                  if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
                    trace_info.pdtch_trace.ul_status[tn + RXTX_DELAY] = 0;
                #endif

                #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
                  RTTL1_FILL_MACS_STATUS(TX_CANCELLED_USF, tn)
                #endif
              }
            }
          } // End if "USF vote enabled on this timeslot"
        } // End for

        /* Uplink resources de-allocated by the DSP are de-allocated by MAC-S */
        macs.tx_allocation &= (UWORD8)  (macs.usf_good | ~macs.tx_data);
        macs.tx_data       &= (UWORD8)  (macs.usf_good | ~macs.tx_data);
        #else //#if !L1_EDA
          UWORD8  i = 0;

          //for all timeslots that need to be monitored
          while ((macs.monitored_ts[i] != INVALID) && (i <= 3))
          {
            // If USF vote was enabled on this timeslot
            if(macs.usf_vote_enable & (MASK_SLOT0 >> macs.monitored_ts[i]))
            {
              // Clear the USF vote flag
              macs.usf_vote_enable &= ~(MASK_SLOT0 >> macs.monitored_ts[i]);

              // Read USF value
              if ((((usf_updated >> ((MAX_TS_NB - macs.monitored_ts[i]) * 2)) & MASK_2SLOTS) == USF_GOOD)
                  && (macs.last_rx_monitored & (MASK_SLOT0 >> macs.monitored_ts[i])))
              {
                if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
                {
                  //RX timeslots to monitor have to be updated upon USF status receipt (only first ts with
                  //good USF has to be considered)
                  if ((macs.monitored_ts[i] <= macs.lowest_poll_ts) ||
                      ((MASK_SLOT0 >> macs.monitored_ts[i]) & macs.rx_allocation))
                    macs.rx_monitored |= (UWORD8) (MASK_SLOT0 >> macs.monitored_ts[i]);

                  // Clear the USF vote flag
                  macs.usf_vote_enable = 0;

                  //if the USF value is GOOD all remaining timelots that needed to be monitored
                  //have to be considered as having GOOD USFs
                  while ((macs.monitored_ts[i] != INVALID) && (i <= 3))
                  {
                    // Update good USFs bitmap
                    macs.usf_good |= (UWORD8) (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));
                    i++;
                  }
                  macs.next_usf_mon_block[0] = l1s.next_time.block_id + USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity];
                  break;
                }
                else
                {
                  // This timeslot is valid and good
                  macs.usf_good |= (UWORD8) (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));
                  macs.next_usf_mon_block[macs.monitored_ts[i] - macs.first_monitored_ts] = l1s.next_time.block_id + USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity];
                }
              }
              else //USF is BAD or INVALID
              {
                //The TDMA before USF status was not known so USF was supposed to be GOOD but
                // now it turns out to be BAD or INVALID so block is deallocated.
                if (macs.tx_data & (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY)))
                {
                  UWORD8 j;

                  // rlc_blocks_sent decremented
                  macs.rlc_blocks_sent --;

                  tn = macs.monitored_ts[i];

                  #if FF_L1_IT_DSP_USF
                    //For all monitored ts (beginning with last one), if the timeslot is a data block then
                    //data block is shifted to next monitored ts.
                    j=3;
                    while (macs.monitored_ts[j] != tn)
                    {
                      if ((macs.monitored_ts[j] != INVALID) &&
                          (macs.tx_data & (MASK_SLOT0 >> (macs.monitored_ts[j] + RXTX_DELAY))))
                      {
                        macs.ul_buffer_index[macs.monitored_ts[j] + RXTX_DELAY] = macs.ul_buffer_index[macs.monitored_ts[j-1] + RXTX_DELAY];
                        #if L1_EGPRS
                          macs.tx_modulation &= ~(MASK_SLOT0 >> (macs.monitored_ts[j] + RXTX_DELAY));
                          macs.tx_modulation |= ((macs.tx_modulation &
                                                (MASK_SLOT0 >> (macs.monitored_ts[j-1] + RXTX_DELAY)))
                                               >> (macs.monitored_ts[j]-macs.monitored_ts[j-1]));
                        #endif // L1_EGPRS
                      }
                      j--;
                    }

                    // Cancel burst
                    macs.ul_buffer_index[tn + RXTX_DELAY] = INVALID;
                    #if L1_EGPRS
                      macs.tx_modulation &= ~(MASK_SLOT0 >> (tn + RXTX_DELAY));
                    #endif // L1_EGPRS
                  #endif // FF_L1_IT_DSP_USF
                }//if (macs.tx_data & (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY)))
                if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
                {
                  //USF for current timeslot is BAD so it has to be monitored for next USF
                  //period
                  if ((macs.monitored_ts[i] <= macs.lowest_poll_ts) ||
                      ((MASK_SLOT0 >> macs.monitored_ts[i]) & macs.rx_allocation))
                    macs.rx_monitored |= (UWORD8) (MASK_SLOT0 >> macs.monitored_ts[i]);
                }
              }
            }//if(macs.usf_vote_enable & (MASK_SLOT0 >> macs.monitored_ts[i]))
            i++;
          }//while ((macs.monitored_ts[i] != INVALID) && (i <= 3))

          if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
          {
            // Downlink monitoring is updated depending on USF status
            macs.rx_allocation |= macs.rx_monitored;
          }

          // Uplink resources de-allocated by the DSP are de-allocated by MAC-S
          macs.tx_allocation &= (UWORD8)  (macs.usf_good | ~macs.tx_data);
          macs.tx_data       &= (UWORD8)  (macs.usf_good | ~macs.tx_data);
        #endif //#if !L1_EDA

        // Measurement gap processing
        l1ps_macs_meas();

      } // End if FN13 = 4 OR 8
    } // End if dynamic allocation mode
  } // End if uplink TBF


  #if FF_L1_IT_DSP_USF
    if (l1ps_macs_com.usf_status != USF_IT_DSP)
    {
  #endif

  /************************************************************/
  /*****  RESSOURCE ALLOCATION FOR THE NEXT BLOCK PERIOD  *****/
  /************************************************************/

  // If the next frame is the first of a block period
  //                                                           FN 13
  //    0   1   2   3    4   5   6   7    8   9   10  11   12
  // ----------------------------------------------------------
  // ||       B0      ||       B1      ||       B2      || I ||
  // || X |   |   |   || X |   |   |   || X |   |   |   ||   ||
  // ----------------------------------------------------------

  if (   (l1s.next_time.fn_mod13 == 4)
      || (l1s.next_time.fn_mod13 == 8)
      || (l1s.next_time.fn_mod13 == 0))
  {
    UWORD8   tx                  = 0;      // MS class Tx parameter checked
    UWORD8   rx                  = 0;      // MS class Rx parameter checked
    UWORD8   tx_no;                        // Number of allocated uplink timeslots
    UWORD8   highest_ul_ts;                // Highest numbered allocated uplink resource
    UWORD8   lowest_ul_ts;                 // Lowest numbered allocated uplink resource
    UWORD8   highest_dl_ts;                // Highest numbered allocated uplink resource
    UWORD8   lowest_dl_ts;                 // Lowest numbered allocated uplink resource
    UWORD8   tra_before_frame;             // Number of free Tx slots at the end of the
                                           // previous frame


    /***********************************************************/
    /* New allocated ressources                                */
    /***********************************************************/

    /*---------------------------------------------------------*/
    /* New assignment or synchronization change                */
    /*---------------------------------------------------------*/

    if (   (l1ps_macs_com.new_set != FALSE)
        || (l1a_l1s_com.dl_tn != macs.old_synchro_ts))
    {
      UWORD8  tn;
      UWORD8  fn_mod13;
      UWORD32 fn_div13;

      /* Fixed allocation mode initialization */
      /*--------------------------------------*/

      if (SET_PTR->mac_mode == FIX_ALLOC_NO_HALF)
      {
        if (((SET_PTR->assignment_command == UL_TBF) || (SET_PTR->assignment_command == BOTH_TBF)) &&
            (l1ps_macs_com.new_set))
        {
          // Starting time block ID processing
          fn_div13 = (UWORD32) (SET_PTR->tbf_sti.absolute_fn / 13);             // FN / 13
          fn_mod13 = (UWORD8) (SET_PTR->tbf_sti.absolute_fn - (fn_div13 * 13)); // FN mod 13
          macs.sti_block_id = (UWORD32) (  (3 * (UWORD32) fn_div13)             // Block ID
                                       + (fn_mod13 / 4));

          // Starting time not aligned on a block period
          if ((fn_mod13 != 0) && (fn_mod13 != 4) && (fn_mod13 != 8) && (fn_mod13 != 12))
            macs.sti_block_id ++;

          // Reset the fixed allocation bitmap exhaustion flag only in case of a new assignment
          macs.fix_alloc_exhaust      = FALSE;
        }

      } // End of fixed mode initialization
      else

        #if L1_EDA
          /*  Extended Dynamic/Dynamic allocation mode initialization  */
          /*------------------------------------------*/

          if ((SET_PTR->mac_mode == DYN_ALLOC) || (SET_PTR->mac_mode == EXT_DYN_ALLOC))
        #else
      /*  Dynamic allocation mode initialization  */
      /*------------------------------------------*/

      if (SET_PTR->mac_mode == DYN_ALLOC)
        #endif
      {
        if ((SET_PTR->assignment_command == UL_TBF) || (SET_PTR->assignment_command == BOTH_TBF) ||
            (l1a_l1s_com.dl_tn != macs.old_synchro_ts))
        {
          // USF value aren't kept
          macs.usf_good           = 0;
          macs.usf_vote_enable    = 0;         // No USF vote
          macs.rx_blk_period      = NO_DL_BLK;

          if (l1ps_macs_com.new_set)
          // USF monitoring block set to current block to immediately enable
          // the USF monitoring in case of new UL TBF
            macs.next_usf_mon_block[0] = macs.next_usf_mon_block[1] = l1s.next_time.block_id;

          // First and last allocated Tx number updating
          macs.first_monitored_ts = INVALID;
          macs.last_monitored_ts  = INVALID;

          tn = 0;
          // Search of the lowest timeslot allocated in uplink
          while (   !(SET_PTR->ul_tbf_alloc->timeslot_alloc & (MASK_SLOT0 >> tn))
                 && (tn < TS_NUMBER))
            tn ++;

          if (tn != TS_NUMBER)
          {
            macs.first_monitored_ts = tn - l1a_l1s_com.dl_tn;
            tn = MAX_TS_NB;

            // Search of the highest timeslot allocated in uplink
            while (!(SET_PTR->ul_tbf_alloc->timeslot_alloc & (MASK_SLOT0 >> tn)))
              tn --;
            macs.last_monitored_ts = tn - l1a_l1s_com.dl_tn;
                #if L1_EDA
                  //Extended Dynamic or Dynamic Allocation has been set
                  {
                    UWORD8  i=0;
                    macs.rx_monitored   = 0;
                    //Search among the timeslots allocated in uplink, the timeslots that are really
                    //allocated (macs.first_monitored_ts and macs.last_monitored_ts are for sure
                    //allocated but the allocation can have holes inbetween)
                    for (i = 0; i < 4; i++)
                    {
                      macs.monitored_ts[i] = INVALID;
                    }
                    i = 0;
                    for (tn = macs.first_monitored_ts; tn <= macs.last_monitored_ts; tn++)
                    {
                      //Find the ts that are allocated and need therefore to be monitored
                      if (((SET_PTR->ul_tbf_alloc->timeslot_alloc & (MASK_SLOT0 >> (tn + l1a_l1s_com.dl_tn))) && (SET_PTR->mac_mode == EXT_DYN_ALLOC))
                         || (SET_PTR->mac_mode == DYN_ALLOC))
                      {
                        macs.monitored_ts[i]= tn;
                        i++;
                      }
                    }
                  }
                #endif //#if L1_EDA
              }
            }
            #if L1_EDA
              if((SET_PTR->mac_mode == EXT_DYN_ALLOC))
                l1ps_macs_com.fb_sb_task_detect = TRUE;
              else
                l1ps_macs_com.fb_sb_task_detect = FALSE;
            #endif
      } // End of dynamic mode initialization

      /* Reset of new_set */
      /*------------------*/

      l1ps_macs_com.new_set = FALSE;

    } // End of new allocation

    /*---------------------------------------------------------*/
    /* Resource initialization                                 */
    /*---------------------------------------------------------*/

    macs.pwr_allocation      = 0;  // Power measurements
    macs.rx_allocation       = 0;  // Rx allocation
    macs.tx_allocation       = 0;  // Tx allocation
    macs.tx_data             = 0;  // Tx data allocation
    macs.tx_prach_allocation = 0;  // Tx PRACH allocation
    #if FF_L1_IT_DSP_USF
     macs.dsp_usf_interrupt = 0;  // DSP interrupt for USF decoding needed
    #endif

    /***********************************************************/
    /* Downlink TBF processing                                 */
    /***********************************************************/

    if ((SET_PTR->allocated_tbf == DL_TBF) || (SET_PTR->allocated_tbf == BOTH_TBF))
    {
      /* Downlink resources are allocated */
      macs.rx_allocation = (UWORD8) (   SET_PTR->dl_tbf_alloc.timeslot_alloc
                                     << l1a_l1s_com.dl_tn);
    } /* End if downlink TBF processing  */

    /***********************************************************/
    /* Uplink TBF processing                                   */
    /***********************************************************/

    if ((SET_PTR->allocated_tbf == UL_TBF) || (SET_PTR->allocated_tbf == BOTH_TBF))
    {

      /*---------------------------------------------------------*/
      /* Dynamic allocation mode                                 */
      /*---------------------------------------------------------*/

        #if L1_EDA
          if ((SET_PTR->mac_mode == DYN_ALLOC) || (SET_PTR->mac_mode == EXT_DYN_ALLOC))
        #else
          if (SET_PTR->mac_mode == DYN_ALLOC)
        #endif
      {
        UWORD8 i;
        UWORD8 tn;
        API    usf_updated;

            #if !L1_EDA
        /* Downlink resource monitoring */
        /*------------------------------*/

        macs.rx_allocation |= (UWORD8)  (   SET_PTR->ul_tbf_alloc->timeslot_alloc
                                        << l1a_l1s_com.dl_tn);

        /* USF values reading */
        /*--------------------*/

        // An uplink timeslot is allocated by MAC-S if it's allocated by the network and
        //    - USF is updated and good
        // OR - USF isn't updated

        // Reading of the d_usf_updated_gprs value
        usf_updated = NDB_PTR->d_usf_updated_gprs;

        // For each timeslot that can be allocated in uplink...
        for (tn = macs.first_monitored_ts; tn <= macs.last_monitored_ts; tn ++)
        {
          UWORD8 tn_usf;
          WORD32 delta;

          // Remaining blocks before a new USF reading
          delta = (WORD8) (macs.next_usf_mon_block[tn - macs.first_monitored_ts] - l1s.next_time.block_id);

          // MAX_FN modulo
          if (delta <= 0) delta += MAX_BLOCK_ID;

          if (delta >= USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity])
          {
            // USF no more usable
            // Clear USF in good USFs bitmap
            macs.usf_good &= (UWORD8) ~(MASK_SLOT0 >> (tn + 3));

            // Clear USF vote
            macs.usf_vote_enable &= (UWORD8) ~(MASK_SLOT0 >> tn);

            // If downlink blocks were entirely received during the last block period
            if (macs.rx_blk_period == l1s.next_time.block_id)
            {
              // Read USF
              tn_usf = (UWORD8) ((usf_updated >> ((MAX_TS_NB - tn) << 1)) & MASK_2SLOTS);

              if (tn_usf == USF_GOOD)
              {
                // Update good USFs bitmap
                macs.usf_good |= (UWORD8) (MASK_SLOT0 >> (tn + 3));
                macs.next_usf_mon_block[tn - macs.first_monitored_ts] = l1s.next_time.block_id + USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity];
              }
              else
              if ((tn_usf == USF_INVALID) && (l1s.next_time.fn_mod13 != 0))
              {
                // Unknown USF:
                //    - TPU is programmed to tranmit a block on timeslot tn
                //    - DSP will set the TX PWR to 0 for this timeslot is USF is bad
                //      (USF vote mechanism)

                macs.tx_allocation   |= (MASK_SLOT0 >> (tn + 3));
                macs.usf_vote_enable |= (MASK_SLOT0 >> tn);
              }
            } // End if "downlink block entirely received"
          } // End if "USF no more usable"
        } // End for

            #else  //#if !L1_EDA
              {
                UWORD8 tn_usf;
                WORD32 delta;
                UWORD8 i=0;

                if (SET_PTR->mac_mode == DYN_ALLOC)
                {
                  /* Downlink resource monitoring */
                  /*------------------------------*/

                  macs.rx_allocation |= (UWORD8)  (   SET_PTR->ul_tbf_alloc->timeslot_alloc
                                                << l1a_l1s_com.dl_tn);

                  macs.last_rx_monitored = macs.rx_allocation;
                }
                else
                {
                  // Remaining blocks before a new USF reading
                  delta = (WORD8) (macs.next_usf_mon_block[0] - l1s.next_time.block_id);

                  // MAX_FN modulo
                  if (delta <= 0) delta += MAX_BLOCK_ID;

                  //Save last rx_monitored timeslots
                  macs.last_rx_monitored = macs.rx_monitored;

                  //for all timeslots to monitor (timeslots allocated in UL)
                  for (tn = macs.first_monitored_ts; tn <= macs.last_monitored_ts; tn++)
                  {
                    //All possible timeslots to monitor have to be monitored
                    // (USF validity period exhausted)
                    if (macs.monitored_ts[i] != INVALID)
                      macs.rx_monitored |= (MASK_SLOT0 >> macs.monitored_ts[i]);
                    i++;
                  }

                  //USF validity period is exhausted
                  if (delta >= USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity])
                  {
                    //USF need to be evaluated for next block period
                    macs.usf_good = 0;
                  }
                  else
                  {
                    //Set monitored ts again if poll occured on one ts during a block granularity period = 4
                    //note: macs.usf_good is always different from 0
                    i=0;
                    while (!(macs.usf_good & (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY))))
                      i++;
                    macs.rx_monitored &= (UWORD8) ~(MASK_ALL_SLOTS >> macs.monitored_ts[i+1]);
                  }
                }

                // Reading of the d_usf_updated_gprs value
                usf_updated = NDB_PTR->d_usf_updated_gprs;

                i=0;
                //for all possible timeslots to monitor
                while ((macs.monitored_ts[i] != INVALID) && (i <= 3))
                {
                  if (SET_PTR->mac_mode == DYN_ALLOC)
                  {
                    // Remaining blocks before a new USF reading
                    delta = (WORD8) (macs.next_usf_mon_block[macs.monitored_ts[i] - macs.first_monitored_ts] - l1s.next_time.block_id);

                    // MAX_FN modulo
                    if (delta <= 0) delta += MAX_BLOCK_ID;
                  }

                  //USF validity period is exhausted
                  if (delta >= USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity])
                  {
                    if (SET_PTR->mac_mode == DYN_ALLOC)
                    {
                      // USF no more usable
                      // Clear USF in good USFs bitmap
                      macs.usf_good &= (UWORD8) ~(MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));

                      // Clear USF vote
                      macs.usf_vote_enable &= (UWORD8) ~(MASK_SLOT0 >> macs.monitored_ts[i]);
                    }

                    if ((macs.rx_blk_period == l1s.next_time.block_id) && (macs.last_rx_monitored & (MASK_SLOT0 >> macs.monitored_ts[i])))
                    {

                      #if L1_EGPRS
                        // EGPRS switched radio loopback sub mode on: dynamic allocation
                        // but USF are always deemed to be good
                        if (l1ps_macs_com.loop_param.sub_mode == TRUE)
                          tn_usf = USF_GOOD;
                        else
                      #endif
                          // Read USF
                         tn_usf = (UWORD8) ((usf_updated >> ((MAX_TS_NB - macs.monitored_ts[i]) << 1)) & MASK_2SLOTS);

                      if (tn_usf == USF_GOOD)
                      {
                        if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
                        {
                          //Deallocate monitored ts
                          macs.rx_monitored &= (UWORD8) ~(MASK_ALL_SLOTS >> macs.monitored_ts[i+1]);

                          //As USF is good for current monitored ts, all subsequent monitored ts have
                          //to be deallocated and the associated USF set to USF_GOOD
                          while ((macs.monitored_ts[i] != INVALID) && (i <= 3))
                          {
                            //Update good USFs bitmap
                            macs.usf_good |= (UWORD8) (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));
                            i++;
                          }
                          macs.next_usf_mon_block[0] = l1s.next_time.block_id + USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity];
                          break;
                        }
                        else
                        {
                          // Update good USFs bitmap
                          macs.usf_good |= (UWORD8) (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));
                          macs.next_usf_mon_block[macs.monitored_ts[i] - macs.first_monitored_ts] = l1s.next_time.block_id + USF_BLOCK_GRANULARITY[SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_granularity];
                        }
                      }
                      else
                      if ((tn_usf == USF_INVALID) && (l1s.next_time.fn_mod13 != 0))
                      {
                        if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
                        {
                          //Deallocate monitored ts
                          macs.rx_monitored &= (UWORD8) ~(MASK_ALL_SLOTS >> macs.monitored_ts[i+1]);

                          //As USF is invalid (status of USF not yet known) for current monitored ts, the USF is
                          //supposed to be good and therefore Tx is allocated and all subsequent monitored ts
                          //have to be deallocated. Vote mechanism is also enabled for these latter timeslots.
                          while ((macs.monitored_ts[i] != INVALID) && (i <= 3))
                          {
                            macs.tx_allocation |= (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));
                            macs.usf_vote_enable |= (MASK_SLOT0 >> macs.monitored_ts[i]);
                            i++;
                          }
                          break;
                        }
                        else
                        {
                          // Unknown USF:
                          //    - TPU is programmed to tranmit a block on timeslot tn
                          //    - DSP will set the TX PWR to 0 for this timeslot is USF is bad
                          //      (USF vote mechanism)

                          macs.tx_allocation   |= (MASK_SLOT0 >> (macs.monitored_ts[i] + RXTX_DELAY));
                          macs.usf_vote_enable |= (MASK_SLOT0 >> macs.monitored_ts[i]);
                        }
                      }
                    }//if ((macs.rx_blk_period == l1s.next_time.block_id) && (macs.last_rx_monitored & (MASK_SLOT0 >> macs.monitored_ts[i])))
                  }
                  i++;
                }//while ((tn != INVALID) && (i <= 3))
              }//if (SET_PTR->mac_mode == EXT_DYN_ALLOC)

              /* Downlink resource monitoring */
              /*------------------------------*/
              macs.rx_allocation |= macs.rx_monitored;
            #endif //#if !L1_EDA
        /* Uplink resources allocation according to USF values */
        /*-----------------------------------------------------*/

        i = l1a_l1s_com.dl_tn - RXTX_DELAY;
        if (i < TS_NUMBER)
        {
          macs.tx_allocation |= (UWORD8) (  macs.usf_good
                                          & (SET_PTR->ul_tbf_alloc->timeslot_alloc << i));
        }
        else
        {
          macs.tx_allocation |= (UWORD8) (  macs.usf_good
                                          & (SET_PTR->ul_tbf_alloc->timeslot_alloc >> (-i)));
        }

            #if L1_EDA
              //if FB/SB activity detected in comming idle frame, some TX burst have to be deallocated
              //to allow opening of FB/SB window (no TX activity should be scheduled in slots 6 and 7)
              if (l1ps_macs_com.fb_sb_task_enabled && l1ps_macs_com.fb_sb_task_detect)
              {
                macs.tx_allocation &= ~(MASK_SLOT0 >> 6);
              }
            #endif

       #if FF_L1_IT_DSP_USF
              // UL or BOTH TBF with dynamic allocation in use. DSP has to generate
              // an interrupt for USF validity for the block to be received if it
              // is either RBN (radio block number) % 3 = 0 or 1.

              if (   (l1s.next_time.fn_mod13 == 0)
                  || (l1s.next_time.fn_mod13 == 4))

                macs.dsp_usf_interrupt = 1;
       #endif

      } /* end if dynamic allocation mode */

      /*---------------------------------------------------------*/
      /* Fixed allocation mode                                   */
      /*---------------------------------------------------------*/

      if (SET_PTR->mac_mode == FIX_ALLOC_NO_HALF)
      {
        UWORD8   i;
        UWORD32  blk_id = l1s.next_time.block_id;

        /* Allocation bitmap isn't exhausted */
        /*-----------------------------------*/

        if(macs.fix_alloc_exhaust == FALSE)
        {

          // Allocation exhaustion detection
          //---------------------------------

          //
          // 0  current_fn  End of allocation                      STI  FN_MAX
          // |-----|---------|--------------------------------------|----||
          // |.....|.........|                                      |....||
          // |-----|---------|--------------------------------------|----||
          //
          // In this case, the Starting time is elapsed but current_fn < STI
          // ---> We must have (current block_ID - STI_block_ID) > 0
          //
          if (blk_id < macs.sti_block_id)
          {
            blk_id += MAX_BLOCK_ID;  // MAX_BLOCK_ID is the block ID obtained when fn = FN_MAX

          } // End of FN MAX modulo management

          #if TESTMODE
            // Never let exhaust the UL allocation in test mode packet transfer operation
            if (l1_config.TestMode)
              blk_id = macs.sti_block_id;
          #endif

          /* Allocation bitmap isn't exhausted */
          if (blk_id < (macs.sti_block_id + SET_PTR->ul_tbf_alloc->fixed_alloc.bitmap_length))
          {

            // Uplink allocation
            //------------------

            // Resources are allocated according to the allocation bitmap or ts_override
            macs.tx_allocation = (UWORD8)
                       (  SET_PTR->ul_tbf_alloc->timeslot_alloc
                        & (  SET_PTR->ul_tbf_alloc->fixed_alloc.bitmap[blk_id - macs.sti_block_id]
                           | SET_PTR->ts_override));
            // Delay
            i = l1a_l1s_com.dl_tn - RXTX_DELAY;
            if (i > MAX_TS_NB)
              macs.tx_allocation >>= (-i);
            else
              macs.tx_allocation <<= i;

            // Monitoring
            //-----------

            if ((l1s.next_time.fn_mod13 == 0) || (macs.rx_blk_period != l1s.next_time.block_id))
            {
              // Last frame was an idle frame or was used for another task --> considered as a free frame
              tra_before_frame = 8;
            }
            else
            {
              tra_before_frame = macs.tra_gap;  // Tra gap of last TDMA frame is saved
            }

            // DOWNLINK CONTROL TIMESLOT ALLOCATION

            if (  SET_PTR->ul_tbf_alloc->timeslot_alloc
                & (MASK_SLOT0 >> SET_PTR->ul_tbf_alloc->fixed_alloc.ctrl_timeslot))
            {
              // Tra and Ttb met --> allocates the downlink control timeslot
              macs.rx_allocation |= (UWORD8)
                               (MASK_SLOT0 >> (  SET_PTR->ul_tbf_alloc->fixed_alloc.ctrl_timeslot
                                               - l1a_l1s_com.dl_tn));
            }

            // UPLINK PDCH MONITORING
            else
            {
              // The control timeslot has been released

              // Allocates uplink TBF timeslots for monitoring
              macs.rx_allocation |= (UWORD8) (   SET_PTR->ul_tbf_alloc->timeslot_alloc
                                              << l1a_l1s_com.dl_tn);
            }

            // If Ttb or Tra not respected, the problem comes from uplink TBF
            // monitored timeslots
            // If Ttb not respected, downlink resources are removed
            for(i = 0; i <= MS_CLASS[SET_PTR->multislot_class].ttb; i++)
              macs.rx_allocation &=  (~((UWORD8)(macs.tx_allocation << i)));

            // Tra respect according to the current allocation
            for(i = 0; i <= MS_CLASS[SET_PTR->multislot_class].tra; i++)
              macs.rx_allocation &= (~((UWORD8)(macs.tx_allocation << (8-i))));

            // Tra respect according to the last allocation
            if (tra_before_frame < MS_CLASS[SET_PTR->multislot_class].tra)
            {
              macs.rx_allocation &= MASK_ALL_SLOTS >> (MS_CLASS[SET_PTR->multislot_class].tra - tra_before_frame);
            }

            #if MACS_STATUS
              if (macs.rx_allocation == 0)
              {
                l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = NO_RX_MONITORED;
                l1ps_macs_com.macs_status.nb ++;
              }
            #endif

            // Last block of the allocation bitmap... next block will use new settings
            // for timeslot monitoring
            if ((blk_id + 1) == (macs.sti_block_id + SET_PTR->ul_tbf_alloc->fixed_alloc.bitmap_length))
            {
              macs.fix_alloc_exhaust               = TRUE;
              // Informs L1S
              l1ps_macs_com.fix_alloc_exhaust_flag = TRUE;
            }


          } // End if "allocation bitmap isn't exhausted"
          else

          // Allocation bitmap has exhausted
          {
            macs.fix_alloc_exhaust               = TRUE;
            // Informs L1S
            l1ps_macs_com.fix_alloc_exhaust_flag = TRUE;

            // Allocates uplink TBF timeslots for monitoring
            macs.rx_allocation |= (UWORD8) (   SET_PTR->ul_tbf_alloc->timeslot_alloc
                                            << l1a_l1s_com.dl_tn);

          }

        } // End if "allocation bitmap not exhausted"

        /* Allocation bitmap is exhausted */
        /*--------------------------------*/
        else
        {
          // Allocates uplink TBF timeslots for monitoring
          macs.rx_allocation |= (UWORD8) (   SET_PTR->ul_tbf_alloc->timeslot_alloc
                                          << l1a_l1s_com.dl_tn);

        } // End if fixed allocation exhausted

      } // End of fixed allocation processing

    } // End of uplink TBF processing

    /***********************************************************/
    /* Allocation parameters checking and updating             */
    /***********************************************************/
    {
      UWORD8 ts;
      BOOL   rx_ts;
      BOOL   tx_ts;

 #if MACS_STATUS
      UWORD8 time   = INVALID;  /* Timeslot counter */
 #endif

      tx_no         = 0;
      highest_ul_ts = INVALID;
      lowest_ul_ts  = INVALID;
      highest_dl_ts = INVALID;
      lowest_dl_ts  = INVALID;

      /*---------------------------------------------------------*/
      /* Trb, Ttb parameters verification and Rx, Tx number, Sum */
      /* and highest_ul_ts parameters processing                 */
      /*---------------------------------------------------------*/

      /* We verifies all allocated uplink and downlink timeslots */
      for (ts = 0; ts < TS_NUMBER; ts ++)
      {
        rx_ts = (UWORD8) (macs.rx_allocation & (MASK_SLOT0 >> ts));
        tx_ts = (UWORD8) (macs.tx_allocation & (MASK_SLOT0 >> ts));

      #if MACS_STATUS

        /* If Rx(ts) = 0 and Tx(ts) = 0 */
        /*------------------------------*/

        if ((!rx_ts) && (!tx_ts))
        {
          /* time is incremented */
          /* If time was invalid, it becomes active */
          if (time < TS_NUMBER)
            time ++;
          if ((time == RX_SLOT)||(time == TX_SLOT))
            time = 1;
        } /* End if Rx = 0 and Tx = 0 */

        /* If Rx(ts) = 1 and Tx(ts) = 1 */
        /*------------------------------*/

        if ((rx_ts) && (tx_ts))
        {
          /* error (only type 1 mobiles are supported) */
          l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = MS_CLASS_TIME_ERROR;
          l1ps_macs_com.macs_status.nb ++;
        } /* End if Rx = 1 and Tx = 1 */
      #endif

        /* If Rx(ts) = 1 */
        /*---------------*/

        if (rx_ts)
        {
          highest_dl_ts = ts;
        #if MACS_STATUS
          /* If time is valid (invalid=0xFF) and time<Trb --> error */
          if ((time < MS_CLASS[SET_PTR->multislot_class].trb) || (time == TX_SLOT))
          {
            l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = MS_CLASS_TIME_ERROR;
            l1ps_macs_com.macs_status.nb ++;
          }
          time = RX_SLOT;
        #endif
          /* First Rx updating */
          if (lowest_dl_ts == INVALID)
            lowest_dl_ts = ts;

        } /* End if Rx = 1 */

        /* If Tx(ts) = 1 */
        /*---------------*/

        if (tx_ts)
        {
          /* Number of Tx is incremented and highest_ul_ts is updated */
          tx_no ++;
          highest_ul_ts = ts;
        #if MACS_STATUS
          /* If time is valid (invalid=0xFF) and time<Ttb --> error */
          if (   (time < MS_CLASS[SET_PTR->multislot_class].ttb)
              || (time == RX_SLOT))
          {
            l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = MS_CLASS_TIME_ERROR;
            l1ps_macs_com.macs_status.nb ++;
          }
          time = TX_SLOT;
        #endif
          /* First Tx updating */
          if (lowest_ul_ts == INVALID)
            lowest_ul_ts = ts;

          #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
            if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
              trace_info.pdtch_trace.ul_status[ts] |= 0x4;
          #endif
        } /* End if Tx = 1 */

      } /* End for */

      /* Rx and Tx MS class parameters are updated */
      if (lowest_dl_ts != INVALID)
        rx = (UWORD8) (highest_dl_ts - lowest_dl_ts + 1);

      if (lowest_ul_ts != INVALID)
        tx = (UWORD8) (highest_ul_ts - lowest_ul_ts + 1);

    #if MACS_STATUS
      // If the Trb parameter isn't respected at the end of
      // the TDMA frame --> MS Class isn't suported
      // Note: we considered that the first slot of the next TDMA is always a RX
      if (time < MS_CLASS[SET_PTR->multislot_class].trb)
      {
        l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = MS_CLASS_TIME_ERROR;
        l1ps_macs_com.macs_status.nb ++;
      }

      /*---------------------------------------------------------*/
      /* Sum, Rx and Tx parameters verification                  */
      /*---------------------------------------------------------*/

      if (  ((rx + tx) > MS_CLASS[SET_PTR->multislot_class].sum)
          ||(rx > MS_CLASS[SET_PTR->multislot_class].rx)
          ||(tx > MS_CLASS[SET_PTR->multislot_class].tx))
      {
        l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = MS_CLASS_SUM_ERROR;
        l1ps_macs_com.macs_status.nb ++;
      }

      // If all downlink timeslots are before the first uplink timeslot or after
      // the last uplink timeslot, Rx and Tx parameters are met
      if (   (   (highest_dl_ts > lowest_ul_ts)
              || (lowest_dl_ts > lowest_ul_ts))
          && (   (highest_dl_ts < highest_ul_ts)
              || (lowest_dl_ts < highest_ul_ts)))
      {
        l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = MS_CLASS_SUM_ERROR;
        l1ps_macs_com.macs_status.nb ++;
      }

    #endif

    } /* End of allocation parameters checking and updating */


    /***********************************************************/
    /* Uplink RLC/MAC blocks management (RLC - DSP interfaces) */
    /* PACCH/U placement (Poll response processing)            */
    /***********************************************************/

    {
      BOOL   poll;              // TRUE if the poll response is processed
      UWORD8 highest_ul_data;   // Highest uplink timeslot assigned for data transfer
      UWORD8 tx_allocation_s;   // Used for saving of macs.tx_allocation
      UWORD8 rx_allocation_s;   // Used for saving of macs.rx_allocation
      UWORD8 tx_data_s;         // Used for saving of macs.tx_data
      UWORD8 highest_ul_ts_s;   // Used for saving of highest_ul_ts
      UWORD8 lowest_ul_ts_s;    // Used for saving of lowest_ul_ts
      UWORD8 poll_resp_ts;      // Timeslot on which the MS must transmit a poll response
      UWORD8 ts;
      UWORD8 i;
          #if L1_EDA
            UWORD8 rx_monitored_s; // Used for saving of rx_monitored
          #endif

      /*---------------------------------------------------------*/
      /* Uplink buffer indexes initialization                    */
      /*---------------------------------------------------------*/

      macs.ul_buffer_index[0] = macs.ul_buffer_index[1] = macs.ul_buffer_index[2] =
        macs.ul_buffer_index[3] = macs.ul_buffer_index[4] = macs.ul_buffer_index[5] =
        macs.ul_buffer_index[6] = macs.ul_buffer_index[7] = INVALID;

      // Reset all uplink blocks CS-TYPE in order to disable the validity of blocks not sent
      for(i=0; i<4; i++)
      {
        NDB_PTR->a_du_gprs[i][0] = CS_NONE_TYPE;
        NDB_PTR->a_pu_gprs[i][0] = CS_NONE_TYPE;
      }

      /*---------------------------------------------------------*/
      /* Uplink RLC/MAC blocks request to RLC (RLC_UPLINK)       */
      /*---------------------------------------------------------*/

      /* All allocated uplink resources are used for data */
      macs.tx_data = macs.tx_allocation;
      highest_ul_data = highest_ul_ts;

      /* RLC UPLINK CALL */
      /*-----------------*/

      #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
        if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_UL_NO_TA)
          if ((SET_PTR->packet_ta.ta == 255) && (macs.tx_allocation != 0))
            Trace_uplink_no_TA();
      #endif

      #if TESTMODE
        if (l1_config.TestMode)
        {
          l1tm_rlc_uplink (tx_no, (API*) NDB_PTR->a_du_gprs);
        }
        else
      #endif
      {
        rlc_uplink(SET_PTR->assignment_id,         // Assignment ID
                   tx_no,                          // Number of timeslot that can be used
                                                   //   for uplink data block transfer
                   l1s.next_time.fn,               // Next frame number
                   SET_PTR->packet_ta.ta,          // Timing advance value
                   (API*) NDB_PTR->a_pu_gprs,      // Pointer on poll response struct
                   (API*) NDB_PTR->a_du_gprs,      // Pointer on uplink block struct
                   macs.fix_alloc_exhaust          // Set to 1 if fixed allocation exhausted
        );
      }

          #if FF_TBF
            #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
              if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_RLC_PARAM)
              {
                UWORD32 cs_type = 0;
                //Get the cs_type from the UL buffer API header
                //The cs_type format: byte0 (LSByte) -indicates the CS type of TS0
                //byte1- CS type of TS1
                //byt2 - CS type of TS2
                //byte3(MSBye) - CS type of TS3
                for (i=0;i<tx_no;i++)
                {
                                        cs_type |= ((((UWORD8) NDB_PTR->a_du_gprs[i][0]) & CS_GPRS_MASK) << (8*i));

                }
                Trace_rlc_ul_param(SET_PTR->assignment_id,         // Assignment ID
                                   l1s.next_time.fn,               // Next frame number
                                   tx_no,                          // Number of UL timeslot that can be used
                                   SET_PTR->packet_ta.ta,          // Timing advance value
                                   macs.fix_alloc_exhaust,
                                   cs_type );
              }
            #endif
          #else
      #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
        if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_RLC_PARAM)
        {
          Trace_rlc_ul_param(SET_PTR->assignment_id,         // Assignment ID
                             tx_no,                          // Number of timeslot that can be used
                                                             //   for uplink data block transfer
                             l1s.next_time.fn,               // Next frame number
                             SET_PTR->packet_ta.ta,          // Timing advance value
                             (UWORD32) NDB_PTR->a_pu_gprs,      // Pointer on poll response struct
                             (UWORD32) NDB_PTR->a_du_gprs,      // Pointer on uplink block struct
                             macs.fix_alloc_exhaust);
        }
      #endif
          #endif

      i = 0;

      /*---------------------------------------------------------*/
      /* Poll responses processing                               */
      /*---------------------------------------------------------*/
          #if L1_EDA
            macs.lowest_poll_ts = INVALID;
          #endif

      /* While a poll response is requested */
      while (  (   ((((UWORD8) NDB_PTR->a_pu_gprs[i][0]) & 0xF) == CS1_TYPE_POLL)
                || ((((UWORD8) NDB_PTR->a_pu_gprs[i][0]) & 0xF) == CS_PAB8_TYPE)
                || ((((UWORD8) NDB_PTR->a_pu_gprs[i][0]) & 0xF) == CS_PAB11_TYPE))
             && (i < 4))
      {
        poll = TRUE;

        // The number of the timeslot on which the poll response is requested is converted to
        // become relative to L1 synchronization
        poll_resp_ts =   (UWORD8) NDB_PTR->a_pu_gprs[i][1]
                      -  l1a_l1s_com.dl_tn
                      +  RXTX_DELAY;

        // All timeslots on which a poll is requested are set in last_poll_response.
        // last_poll_response will be updated in FN13 = 2, 6 and 10, when the 4th control
        // task will be processed for the current block period --> we'll be sure the poll
        // responses are entirely transmitted (no BCCH monitoring)
        macs.last_poll_response |= (UWORD8) (MASK_SLOT0 >> poll_resp_ts);

        // Allocations are saved: it's useful to restore uplink slots that were removed
        // for mapping a poll response that is finally not processed
        tx_allocation_s = macs.tx_allocation;
        rx_allocation_s = macs.rx_allocation;
        tx_data_s       = macs.tx_data;
        lowest_ul_ts_s  = lowest_ul_ts;
        highest_ul_ts_s = highest_ul_ts;
            #if L1_EDA
              rx_monitored_s  = macs.rx_monitored;
            #endif
          #if L1_EDA
            //In the case of concurrent TBFs in extended dynamic mode, poll response can be canceled
            //if response is not done on concurrent timeslots
            if (((SET_PTR->allocated_tbf == BOTH_TBF) && (SET_PTR->mac_mode == EXT_DYN_ALLOC)) &&
                (!((SET_PTR->dl_tbf_alloc.timeslot_alloc) & (SET_PTR->ul_tbf_alloc->timeslot_alloc)
                & (MASK_SLOT0 >> NDB_PTR->a_pu_gprs[i][1]))))
            {
              // Poll response not done
              poll = FALSE;
            }
            else
          #endif
        /* If the requested timeslot is allocated for data transfer */
        /*----------------------------------------------------------*/

        if (macs.tx_data & (MASK_SLOT0 >> poll_resp_ts))
        {
          /* The slot is removed in tx_data */
          /* No allocation modification */
          macs.tx_data &= (UWORD8) (~(MASK_SLOT0 >> poll_resp_ts));

          #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            RTTL1_FILL_MACS_STATUS(TX_CANCELLED_POLL, poll_resp_ts)
          #endif

        } /* End if slot allocated for data */

        /* If the poll response is requested on an invalid timeslot    */
        /* i.e:                                                        */
        /*    - Timeslot > 7 or < 0                                    */
        /*    - Timeslot that avoid the RX on the first timeslot       */
        /*      according to Ttb                                       */
        /*-------------------------------------------------------------*/

        else
        if ((poll_resp_ts > 7) || (poll_resp_ts <= MS_CLASS[SET_PTR->multislot_class].ttb))
        {
          // Poll response not done
          poll = FALSE;
        }

        /* If the Tra parameter isn't respected */
        /*--------------------------------------*/

          #if L1_EDA
            //Tra does not always apply with EDA.
            else
            if ((  (MASK_SLOT0 >> poll_resp_ts)
                & (   macs.rx_allocation
                   >> (TS_NUMBER - MS_CLASS[SET_PTR->multislot_class].tra)) && (SET_PTR->mac_mode != EXT_DYN_ALLOC))
                || ((poll_resp_ts == 6) && (l1ps_macs_com.fb_sb_task_enabled)))
          #else
        else
        if (  (MASK_SLOT0 >> poll_resp_ts)
            & (   macs.rx_allocation
               >> (TS_NUMBER - MS_CLASS[SET_PTR->multislot_class].tra)))

          #endif
        {
          // Poll response not done
          poll = FALSE;
        }

        /* Ttb and Tra respected                                         */
        /* Poll on a slot not already allocated for uplink data transfer */
        /*---------------------------------------------------------------*/

        else
        {
          /* If Ttb parameter isn't respected  */
          /*-----------------------------------*/

          // If one or several downlink timeslots are allocated between:
          //    - Ttb timeslots before the timeslot to use for poll response
          //    - AND the last slot of the frame (optimization)
          //          --> Ttb parameter isn't respected if the poll response is transmitted
          //              so the RX resources are removed

          macs.rx_allocation &= ~((UWORD8) (  macs.rx_allocation
                                            & (   MASK_ALL_SLOTS
                                               >> (  poll_resp_ts
                                                   - MS_CLASS[SET_PTR->multislot_class].ttb))));

              #if L1_EDA
                if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
                {
                  UWORD8 only_monitored_ts;

                  only_monitored_ts = ~((UWORD8)(SET_PTR->dl_tbf_alloc.timeslot_alloc << l1a_l1s_com.dl_tn)) & macs.rx_monitored;
                  macs.rx_allocation &= ~(only_monitored_ts & (MASK_ALL_SLOTS >> (poll_resp_ts + 1 - RXTX_DELAY)));
                  macs.rx_monitored &= macs.rx_allocation;
                }
              #endif
          /* The requested slot is allocated */
          macs.tx_allocation |= (UWORD8)  (MASK_SLOT0 >> poll_resp_ts);

          /* Lowest, highest numbered uplink timeslot and Tx parameter are updated */

          if (poll_resp_ts < lowest_ul_ts)
            lowest_ul_ts = poll_resp_ts;

          if ((poll_resp_ts > highest_ul_ts) || (highest_ul_ts == INVALID))
            highest_ul_ts = poll_resp_ts;

          tx = (UWORD8) (highest_ul_ts - lowest_ul_ts + 1);

          /* Tx and Sum parameters checking */
          /*--------------------------------*/

          /* While Tx or Sum parameter isn't respected and the poll response hasn't */
          /* already been removed */
          while (   (   (tx > MS_CLASS[SET_PTR->multislot_class].tx)
                     || ((rx + tx) > MS_CLASS[SET_PTR->multislot_class].sum))
                 && (poll == TRUE))
          {
            /* If no uplink timeslot is used for data */
            if (macs.tx_data == 0)
            {
              /* The poll response isn't processed */
              poll = FALSE;
            }
            else
            {
              /* Highest uplink PDTCH is removed */
              macs.tx_allocation &= (UWORD8) (~(MASK_SLOT0 >> highest_ul_data));
              macs.tx_data       &= (UWORD8) (~(MASK_SLOT0 >> highest_ul_data));

              #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
                RTTL1_FILL_MACS_STATUS(TX_CANCELLED_POLL, highest_ul_data)
              #endif

              /* Lowest, highest numbered uplink timeslot and Tx parameter are updated */

              lowest_ul_ts    = INVALID;
              highest_ul_ts   = INVALID;
              highest_ul_data = INVALID;

              for (ts = 0; ts < TS_NUMBER; ts ++)
              {
                if (macs.tx_allocation & (MASK_SLOT0 >> ts))
                {
                  if (lowest_ul_ts == INVALID)
                    lowest_ul_ts = ts;
                  highest_ul_ts = ts;
                  if (macs.tx_data & (MASK_SLOT0 >> ts))
                    highest_ul_data = ts;
                }
              }

              tx = (UWORD8) (highest_ul_ts - lowest_ul_ts + 1);

            }
          } /* End while Tx or Sum parameter not met */
        } /* End of case "poll on a timeslot not already allocated for uplink data transfer"
                         " Tra and Ttb respected " */

        /* If the poll response is done */
        /*------------------------------*/
        if (poll == TRUE)
        {
          // Note: Power measurement always found because Tra met

          UWORD8   cs_type;
          UWORD16  prach_info;
              #if L1_EDA
                UWORD8 only_monitored_ts;
              #endif

          cs_type    = (UWORD8)  ((NDB_PTR->a_pu_gprs[i][0]) & 0xF);
          prach_info = (UWORD16) l1ps_dsp_com.pdsp_ndb_ptr->a_pu_gprs[i][2];

          if(cs_type == CS_PAB8_TYPE)
          {
            l1ps_dsp_com.pdsp_ndb_ptr->a_pu_gprs[i][2] = ((API)(l1a_l1s_com.Scell_info.bsic << 2)) |
                                                         ((API)(prach_info) << 8);
            l1ps_dsp_com.pdsp_ndb_ptr->a_pu_gprs[i][3] = 0;

            // macs.tx_prach_allocation is updated
            macs.tx_prach_allocation |= (UWORD8) (MASK_SLOT0 >> poll_resp_ts);
          }
          else
          if(cs_type == CS_PAB11_TYPE)
          {
            l1ps_dsp_com.pdsp_ndb_ptr->a_pu_gprs[i][2] = ((API)(prach_info) << 5);
            l1ps_dsp_com.pdsp_ndb_ptr->a_pu_gprs[i][3] = ((API)(l1a_l1s_com.Scell_info.bsic << 10));

            // macs.tx_prach_allocation is updated
            macs.tx_prach_allocation |= (UWORD8) (MASK_SLOT0 >> poll_resp_ts);
          }

              #if L1_EDA
                only_monitored_ts = ~((UWORD8)(SET_PTR->dl_tbf_alloc.timeslot_alloc << l1a_l1s_com.dl_tn)) & (SET_PTR->ul_tbf_alloc->timeslot_alloc<< l1a_l1s_com.dl_tn);
                //lowest_poll_ts variable is used to remove only monitored ts above a ts
                //used for a poll.
                if (SET_PTR->mac_mode == EXT_DYN_ALLOC)
                {
                  if ((poll_resp_ts - RXTX_DELAY) < macs.lowest_poll_ts)
                    macs.lowest_poll_ts = (poll_resp_ts - RXTX_DELAY);
                }
              #endif
          #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            RTTL1_FILL_UL_PDTCH(cs_type, tx_allocation_s & (0x80 >> poll_resp_ts), poll_resp_ts + l1a_l1s_com.dl_tn)
          #endif

          // a_ul_buffer_gprs updating
          macs.ul_buffer_index[poll_resp_ts] = i + 8;

          #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
            if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
            {
              trace_info.pdtch_trace.ul_status[poll_resp_ts] |= cs_type << 4;
              trace_info.pdtch_trace.ul_status[poll_resp_ts] |= 1;
            }
          #endif
        } // End if the poll response is processed

        /* If the poll response isn't processed */
        /*--------------------------------------*/
        else
        {
          // All allocation parameters that may have been modified to map
          // this poll response are restored
          macs.tx_allocation = tx_allocation_s;
          macs.rx_allocation = rx_allocation_s;
          macs.tx_data       = tx_data_s;
          highest_ul_ts      = highest_ul_ts_s;
          lowest_ul_ts       = lowest_ul_ts_s;

        #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
          if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
            trace_info.pdtch_trace.blk_status |= 0x01;
        #endif

        #if MACS_STATUS
          l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb]= POLL_ERROR_MS_CLASS;
          l1ps_macs_com.macs_status.nb ++;
        #endif

        #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
          RTTL1_FILL_MACS_STATUS(POLL_REJECT, poll_resp_ts)
        #endif
        } // End if the poll response isn't processed
            //The trace for poll response
            #if FF_TBF
              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
                if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_POLL_PARAM)
                {
                   Trace_rlc_poll_param ( poll, //Indicate whether L1 is going to transmit poll resp or not: 0-no, 1-yes
                                                     l1s.next_time.fn, //next frm on whih poll resp will be sent
                                                     poll_resp_ts, //Timseslot for poll response
                                                     macs.tx_allocation,
                                                     (UWORD32)macs.tx_data,
                                                     macs.rx_allocation,
                                                     (UWORD32)macs.last_poll_response,
                                                     ((NDB_PTR->a_pu_gprs[i][0]) & CS_GPRS_MASK));

                }
              #endif
            #endif
        i ++;

      } /* End while a poll response is requested and can be mapped */

      /*---------------------------------------------------------*/
      /* Uplink RLC/MAC data blocks processing                   */
      /*---------------------------------------------------------*/

      i                          = 0;
      ts                         = 0;
      macs.rlc_blocks_sent       = 0;

      // tx_data_s represents here the remaining timeslots that must be associated
      // with a RLC/MAC data block
      tx_data_s                  = macs.tx_data;

      /* While a timeslot is available to transmit an uplink RLC/MAC data block */
      while (tx_data_s != 0)
      {
        /* If slot is allocated for data transfer */
        if (macs.tx_data & (MASK_SLOT0 >> ts))
        {
          UWORD8 cs_type = (((UWORD8) NDB_PTR->a_du_gprs[i][0]) & 0xF);

          /* If no RLC/MAC block is sent by RLC */
          /*------------------------------------*/

          if (cs_type == CS_NONE_TYPE)
          {
            // All uplink timeslots used for data and situated after this timeslot
            // (inluding this timeslot) are removed
            macs.tx_allocation &= (UWORD8) (~(  macs.tx_data  & (MASK_ALL_SLOTS >> ts)));
            macs.tx_data &= (UWORD8) (~(MASK_ALL_SLOTS >> ts));
            tx_data_s = 0;

            #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              RTTL1_FILL_MACS_STATUS(TX_ALLOWED_NO_BLK, ts)
                  #if FF_TBF
                    //Update the ul_status fileds for cond PDTCH trace
                    //Since this blcok doesn't have any valid CS scheme, cs_type=0 and payload=11
                    if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
                    {
                      //Bits7,6,5,4 (cs_type)of ul_status should all be zeros
                      trace_info.pdtch_trace.ul_status[ts] &= 0x0f;
                      //Make the payload as NA
                      trace_info.pdtch_trace.ul_status[ts] |= 0x03;
                    }
                  #endif
            #endif
          }

          /* Else: uplink RLC/MAC data block transfer processing */
          /*-----------------------------------------------------*/
          else
          {
            #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
              if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
              {
                trace_info.pdtch_trace.ul_status[ts] |= ((UWORD8) cs_type) << 4;
                trace_info.pdtch_trace.ul_status[ts] |= 2;
              }
            #endif

            /* A data block is assigned to timeslot ts */
            tx_data_s &= (UWORD8) (~(MASK_SLOT0 >> ts));
            /* rlc_blocks_sent value processed */
            macs.rlc_blocks_sent ++;
            /* Uplink buffer index stored in ul_buffer_index */
            macs.ul_buffer_index[ts] = i;

            /* Next data block */
            i ++;
          }

        } /* End if slot allocated for data transfer */

        /* Next timeslot */
        ts ++;
      } /* End while */

    } /* End of poll responses / uplink blocks processing */

    /***********************************************************/
    /* Measurement gap allocation                              */
    /***********************************************************/

    l1ps_macs_meas();

  #if MACS_STATUS
    if (macs.pwr_allocation == 0)
    {
      l1ps_macs_com.macs_status.id[l1ps_macs_com.macs_status.nb] = NO_MEAS_MAPPED;
      l1ps_macs_com.macs_status.nb ++;
    }
  #endif

    // Initialize the reception block period
    macs.rx_blk_period   = NO_DL_BLK;

  } /* End if next frame is the first of a block period */

  /***********************************************************/
  /* RLC_DOWNLINK call enabling for uplink PDCH status       */
  /***********************************************************/

  //                                                           FN 13
  //    0   1   2   3    4   5   6   7    8   9   10  11   12
  // ----------------------------------------------------------
  // ||       B0      ||       B1      ||       B2      || I ||
  // ||   |   |   |   || X |   |   |   || X |   |   |   || X ||
  // ----------------------------------------------------------

  if (   (l1s.actual_time.fn_mod13 == 4)
      || (l1s.actual_time.fn_mod13 == 8)
      || (l1s.actual_time.fn_mod13 == 12))
  {
        #if (FF_TBF)
          l1ps_macs_rlc_uplink_info();
        #else
    l1ps_macs_com.rlc_downlink_call = TRUE;
        #endif

    // RTT: trace UL PDTCH blocks
    #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
      if (SELECTED_BITMAP(RTTL1_ENABLE_UL_PDTCH))
      {
        UWORD8 i,j = 0;

        for(i=2; i < 8; i++)
        {
          if (macs.tx_data & (0x80 >> i))
          {
            RTTL1_FILL_UL_PDTCH((((UWORD8) NDB_PTR->a_du_gprs[j][0]) & 0xF), 1, i)
            j++;
          }
        }
      }
    #endif
  }

  #if FF_L1_IT_DSP_USF
    } // if (l1ps_macs_com.usf_status != USF_IT_DSP)
  #endif // FF_L1_IT_DSP_USF


  /***********************************************************/
  /* MAC-S control result for LAYER 1                        */
  /***********************************************************/

  /* We update allocation structures in Layer 1 - MAC-S interface */
  l1ps_macs_com.rx_allocation       = macs.rx_allocation;
  l1ps_macs_com.tx_nb_allocation    = macs.tx_allocation & (~macs.tx_prach_allocation);
  l1ps_macs_com.tx_prach_allocation = macs.tx_prach_allocation;
  l1ps_macs_com.pwr_allocation      = macs.pwr_allocation;


  #if FF_L1_IT_DSP_USF
    // When dynamic allocation is in use for uplink TBF, notifies L1S about
    // USF uncertainty for FN%13=3 and 7
    if (l1ps_macs_com.usf_status != USF_IT_DSP)
    {
      if (macs.usf_vote_enable)
        l1ps_macs_com.usf_status = USF_AWAITED;
      else
        l1ps_macs_com.usf_status = USF_AVAILABLE;
    }
  #endif // FF_L1_IT_DSP_USF

  /***********************************************************/
  /* DSP programming                                         */
  /***********************************************************/

  // Write uplink blocks - timeslots correspondance in a_ul_buffer_gprs
  // MAC mode in d_sched_mode_gprs and the USF table in a_usf_gprs (Each frame)

  #if FF_L1_IT_DSP_USF
    if (l1ps_macs_com.usf_status != USF_AWAITED)
  #endif // FF_L1_IT_DSP_USF

  l1pddsp_transfer_mslot_ctrl
      (l1s.next_time.fn_mod13_mod4,                   // Burst number (0 to 3)
       macs.rx_allocation,                            // DL Bitmap
       macs.tx_allocation,                            // UL Bitmap
       SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_table, // USF table
       SET_PTR->mac_mode,                             // MAC mode
       macs.ul_buffer_index,                          // UL buffer index
       SET_PTR->tsc,                                  // Training sequence code
       l1a_l1s_com.dedic_set.radio_freq,              // Radio Freq. used for I/Q swap.
       l1a_l1s_com.dl_tn,                             // DL Transfer Sync. TN.
         #if FF_L1_IT_DSP_USF
           macs.dsp_usf_interrupt                         // USF interrupt activation
         #else
           macs.usf_vote_enable                           // USF vote activation
         #endif
       );


  /*****************************************************************/
  /* TBF parameters saving and updating                            */
  /* last_rx_allocation, TFI, rlc_blocks_sent and last_poll_error  */
  /*****************************************************************/

  //                                                           FN 13
  //    0   1   2   3    4   5   6   7    8   9   10  11   12
  // ----------------------------------------------------------
  // ||       B0      ||       B1      ||       B2      || I ||
  // ||   |   |   | X ||   |   |   | X ||   |   |   | X ||   ||
  // ----------------------------------------------------------

  if (   (l1s.next_time.fn_mod13 == 3)
      || (l1s.next_time.fn_mod13 == 7)
      || (l1s.next_time.fn_mod13 == 11))
  {
    // Downlink blocks to report to RLC
    macs.last_rx_alloc  = macs.rx_allocation;
    macs.rx_blk_period  = l1s.next_time.block_id + 1;
    if (macs.rx_blk_period > MAX_BLOCK_ID)
      macs.rx_blk_period -= (UWORD32) (MAX_BLOCK_ID + 1);

    // Synchronization memorization for synchro. change detection
    macs.old_synchro_ts = l1a_l1s_com.dl_tn;

    macs.tx_allocation       = 0;
    macs.tx_prach_allocation = 0;
  } /* End if FN13 = 2, 6 OR 10 */

} /* END OF L1PS_MACS_CTRL() */

/*-----------------------------------------------------------*/
/* l1ps_macs_read()                                          */
/*-----------------------------------------------------------*/
/* Parameters: global l1ps_macs_com           unchanged      */
/*             global l1s                     unchanged      */
/*             global l1a_l1s_com             unchanged      */
/*             global l1ps_dsp_com            changed        */
/*                                                           */
/* Return:                                                   */
/*                                                           */
/* Description: l1ps_macs_read checks the last received      */
/*              downlink blocks. It checks if the TFI field  */
/*              is present and good in the block header and  */
/*              write in the NDB the number of received      */
/*              received blocks and on which timeslot was    */
/*              received each data block and how much block. */
/*              Then the RLC layer is called (rlc_downlink)  */
/*-----------------------------------------------------------*/
void l1ps_macs_read(UWORD8 pr_table[8])
{
  #define NDB_PTR  l1ps_dsp_com.pdsp_ndb_ptr

  /***********************************************************/
  /* Downlink RLC/MAC block management                       */
  /***********************************************************/

  // If we are in the first frame after a block period */
  //                                                           FN 13
  //    0   1   2   3    4   5   6   7    8   9   10  11   12
  // ----------------------------------------------------------
  // ||       B0      ||       B1      ||       B2      || I ||
  // ||   |   |   |   || X |   |   |   || X |   |   |   || X ||
  // ----------------------------------------------------------
  //                                         X: Received downlink RLC/MAC block management
  if (  (l1s.actual_time.fn_mod13 == 4)
      ||(l1s.actual_time.fn_mod13 == 8)
      ||(l1s.actual_time.fn_mod13 == 12))
  {
    UWORD8            ts;            // Timeslot pointer
    BOOL              tfi_result;    // Set to 1 if the TFI field is present and good
    #if FF_TBF
      UWORD8         cs_type;
      BOOL           crc_error = 0;
    #endif

    /* For each radio block allocated for downlink transfer in the last block period */
    for (ts = 0; ts < TS_NUMBER; ts ++)
    {
      if (macs.last_rx_alloc & (MASK_SLOT0 >> ts))
      {
        l1ps_macs_header_decoding(macs.rx_no, &tfi_result, &(pr_table[ts]));

        #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
          if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
          {
            trace_info.pdtch_trace.dl_status[macs.rx_no] |= tfi_result << 4;
            #if FF_TBF
                  crc_error = NDB_PTR->a_dd_gprs[macs.rx_no][0] & (1<<B_CRC_BLOCK_ERROR);
                  //In the case of GPRS b_cs_type is 4bit info.
                  cs_type = NDB_PTR->a_dd_gprs[macs.rx_no][0] & CS_GPRS_MASK;
              #if L1_EGPRS
                }
              #endif
              //If the blcok received is in CRC error, update the bit0 of dl_status as 1
              if (crc_error == (1<<B_CRC_BLOCK_ERROR))
              {
                trace_info.pdtch_trace.dl_status[macs.rx_no] |= 0x01;
              }
              else
              {
                // No CRC error. Good Block
                //dl_cs_type used only for BINARY TRACE. We put the following limitation so that
                //in the case of EGPRS with MCS we don't enter here.
                if ((cs_type > CS1_TYPE_DATA) && (cs_type <= CS4_TYPE))
                {
                  trace_info.pdtch_trace.dl_cs_type |= ((cs_type - 3) & 3) << (macs.rx_no * 2);
                }
              }
            #else
            if (l1ps_dsp_com.pdsp_ndb_ptr->a_dd_gprs[macs.rx_no][0] & 0x0100) // CRC error
              trace_info.pdtch_trace.dl_status[macs.rx_no] = 1;
            else
            {
              // CS type
              UWORD8 cs_type = NDB_PTR->a_dd_gprs[macs.rx_no][0] & 0xf;

              if (cs_type != CS1_TYPE_DATA)
                trace_info.pdtch_trace.dl_cs_type |= ((cs_type - 3) & 3) << macs.rx_no;
            }
            #endif
          }
        #endif

        // TFI filtering result stored in the downlink block buffer header
        NDB_PTR->a_dd_gprs[macs.rx_no][0] &= (API) (TFI_BIT_MASK);
        NDB_PTR->a_dd_gprs[macs.rx_no][0] |= (API) (tfi_result << TFI_BIT_SHIFT);

        /*---------------------------------------------------------*/
        /* Timeslot and Rx_no values updating                      */
        /*---------------------------------------------------------*/

        // Timeslot number (relative to the network) on which the block was received is
        // stored in the downlink block buffer header

        NDB_PTR->a_dd_gprs[macs.rx_no][1] = ts + l1a_l1s_com.dl_tn;

        #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
          RTTL1_FILL_DL_PDTCH((UWORD8) (NDB_PTR->a_dd_gprs[macs.rx_no][4]),    \
                              tfi_result,                                      \
                              NDB_PTR->a_dd_gprs[macs.rx_no][0] & 0x0100 >> 8, \
                              NDB_PTR->a_dd_gprs[macs.rx_no][0] & 0x000f,      \
                              ts + l1a_l1s_com.dl_tn)
        #endif

        macs.rx_no ++;

      } /* End if timeslot was allocated in downlink for the last block period */
    } /* Next timeslot (FOR statement) */

    #if FF_TBF
      //The "rlc_downlink_bufferize_param" structure is used to memorize parameters
      //over a block period in order to cope with spreading issue.
      //
      // C|W R    |
      //  |C W R  |
      //  |  C W R|       TBF 1
      //  |    C W|R <------------
      //----------------------
      //  |      C|W R <--------------
      //  |       |C W R
      //  |       |  C W R       TBF 2
      //  |       |    C W R
      //                   ^
      //                   |
      //                   worst case where the rlc_downlink() function can be called
      //                   when spreading occurs

      //the case above depicts a new TBF assignment without change of the synchronization:
      //as the call to the rlc_downlink() function (that needs among other the assignment id parameter)
      //can be delayed due to spreading, the assignment id of TBF 1 should be memorized
      //until the call of the rlc_downlink() function that handles the last block of TBF 1

      l1ps_macs_com.rlc_downlink_bufferize_param.allocated_tbf = l1ps.read_param.allocated_tbf;
      l1ps_macs_com.rlc_downlink_bufferize_param.assignment_id = l1ps.read_param.assignment_id;
      #if L1_EGPRS
        l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode      = l1ps.read_param.tbf_mode;
      #endif

      // New buffer to be allocated
      macs.dl_buffer_index = INVALID;
      // Initialize spreading counter
      macs.tdma_delay = 0;

      // rlc_uplink_info() invokation in case of block skipped due to resynchro
      // See L1_MCU-CHG-17924
      if (l1s.task_status[PDTCH].current_status != RE_ENTERED)
        l1ps_macs_rlc_uplink_info();
    #endif
    /***********************************************************/
    /* RLC_DOWNLINK call enabling for downlink PDCH status     */
    /***********************************************************/
    l1ps_macs_com.rlc_downlink_call = TRUE;

    #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
    #if L1_BINARY_TRACE == 0
      if (trace_info.current_config->l1_dyn_trace & (1<<L1_DYN_TRACE_DL_PDTCH_CRC))
      {
        BOOL    crc_error=0;
        UWORD8  i;

        for(i=0;i<macs.rx_no;i++)
          crc_error |= ((NDB_PTR->a_dd_gprs[i][0] & 0x0100) >> (1+i));

        Trace_Packet_Transfer(crc_error); // Previous RX blocks CRC_ERROR summary
      }
    #endif
    #endif

  } /* End if first frame after a block period */

} /* END OF L1PS_MACS_READ */

/*-----------------------------------------------------------*/
/* l1ps_macs_meas()                                          */
/*-----------------------------------------------------------*/
/* Parameters: global l1ps_macs_com           unchanged      */
/*             global l1a_l1s_com             unchanged      */
/*             static macs.rx_allocation      unchanged      */
/*             static macs.tx_allocation      unchanged      */
/*             static macs.pwr_allocation     changed        */
/* Return:                                                   */
/*                                                           */
/* Description: This function processes the power measurement*/
/*              gap according to the MS class and timeslots  */
/*              allocated in macs.tx_allocation and          */
/*              macs.rx_allocation fields.                   */
/*-----------------------------------------------------------*/
void l1ps_macs_meas()
{
  #define SET_PTR l1pa_l1ps_com.transfer.aset

  WORD8  ts                = 7;       // Timeslot pointer
  UWORD8 gap               = 0;       // Gap size counter
  UWORD8 meas              = 0;       // Temporary gap processing
  UWORD8 bitmap_rx, bitmap_tx;

  macs.pwr_allocation = 0;
  bitmap_rx = macs.rx_allocation;
  bitmap_tx = macs.tx_allocation;

  // Searching of the last allocated timeslot
  // Note: Layer 1 always synchronize on a RX event, so the Tra gap will always
  //       be found after the last allocated timeslot of a frame

  while (   (ts >= 0)
         && ((bitmap_rx & 0x01) == 0)
         && ((bitmap_tx & 0x01) == 0))
  {
    // Memorization of the timeslot
    meas |= (UWORD8) (MASK_SLOT0 >> ts);
    // Gap is incremented
    gap ++;

    bitmap_rx >>= 1;
    bitmap_tx >>= 1;
    ts --;
  }

  // Last allocated timeslot: ts
  // Power gap size: gap

  // Save the "tra gap" at the end of the frame
  macs.tra_gap = gap;

  // If Tra respected before the first Rx of the frame after
  // Here we consider that L1 is ALWAYS synchronized on a RX timeslot
  if (gap >= MS_CLASS[SET_PTR->multislot_class].tra)
  {
    // The gap is allocated
    macs.pwr_allocation |= meas;
  }
  else
  // If the first slot of the next frame is free and permit to respect the Tra parameter
  // in fixed mode
  // Notes:
  // - if Tra not respected and the current slot 0 isn't allocated --> the slot 0 of
  //   the next frame will not be allocated (only possible in Fixed mode)
  // - in all cases, only one timeslot need to be removed
  if (   (gap + 1 >= MS_CLASS[SET_PTR->multislot_class].tra)
      && (!(macs.rx_allocation & MASK_SLOT0)))
  {
    // The gap is allocated
    macs.pwr_allocation |= meas;
  }

#if L1_EDA
  //if in extended dynamic allocation and if no power measurement is set in Tra gap (Tra not fulfilled)
  //then power measurement is set in Tta gap if MS class supports it.
  if ((SET_PTR->mac_mode == EXT_DYN_ALLOC) && (!macs.pwr_allocation))
  {
    UWORD8  i = MAX_TS_NB;

    //compute tta
    while (!(macs.rx_allocation & (MASK_SLOT0 >> i)))
     i--;

    i++;
    gap = 0;
    meas = 0;
    while (!(macs.tx_allocation & (MASK_SLOT0 >> i)))
    {
     gap++;
     meas |= (UWORD8) (MASK_SLOT0 >> i);
     i++;
    }

    if (gap <= MS_CLASS[SET_PTR->multislot_class].tta)
      macs.pwr_allocation |= meas;
  }
#endif //#if L1_EDA
} /* End of l1ps_macs_meas */

/*-----------------------------------------------------------*/
/* l1ps_macs_header_decoding()                               */
/*-----------------------------------------------------------*/
/* Parameters:                                               */
/*                                                           */
/* Return:                                                   */
/*                                                           */
/* Description: This function process the TFI filtering and  */
/*              decode the PR value in the MAC header of the */
/*              block stored in buffer rx_no.                */
/*-----------------------------------------------------------*/
void l1ps_macs_header_decoding(UWORD8 rx_no, UWORD8 *tfi_result, UWORD8 *pr)
{
  UWORD8            payload;       // Payload type value in the RLC/MAC header
  UWORD8            tfi;           // TFI value
  UWORD16           mac_header[2]; // Downlink block MAC header

  *pr = 0;

  // DSP Driver
  // Downlink block MAC header reading

  mac_header[0] = NDB_PTR->a_dd_gprs[rx_no][4];
  mac_header[1] = NDB_PTR->a_dd_gprs[rx_no][5];

  *tfi_result = TFI_NOT_FILTERED;

#if TFI_FILTERING

  /*---------------------------------------------------------*/
  /* TFI Filtering                                           */
  /*---------------------------------------------------------*/

  *tfi_result = TFI_BAD;

  /* Payload reading in the block header */
  /*-------------------------------------*/

  payload = (UWORD8) (((mac_header[0]) >> PAYLOAD_SHIFT) & PAYLOAD_MASK);

  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
    if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
    {
      trace_info.pdtch_trace.dl_status[rx_no] |= payload << 6;
      // RRBP + S/P trace
      trace_info.pdtch_trace.dl_status[rx_no] |= (mac_header[0] & (0x38)) >> 2;
    }
  #endif

  /* If the payload time isn't "RESERVED" */
  if (payload != RESERVED)
  {
    /* Data block case, processed if a downlink TBF is assigned */
    /*----------------------------------------------------------*/

    if (payload == DATA_BLOCK)
    {
      *pr = (UWORD8) ((mac_header[0] >> DATA_PR_SHIFT) & PR_MASK);

      if ((l1ps.read_param.allocated_tbf == DL_TBF) || (l1ps.read_param.allocated_tbf == BOTH_TBF))
      {
        // TFI value reading
        tfi = (UWORD8) ((mac_header[0] & DATA_TFI_MASK) >> DATA_TFI_SHIFT);

        // Downlink TFI control
        if (tfi == l1ps.read_param.dl_tfi)
        {
          *tfi_result    = TFI_GOOD;
        }
      } // End if "downlink TBF enabled"

    } /* End of data block case */

    /* Control block case */
    /*--------------------*/

    else
    {
      /* Optionnal field is no present */
      if (payload == CTRL_NO_OPTIONAL)
        *tfi_result = TFI_NOT_PRESENT;

      /* Optionnal field is present */
      if (payload == CTRL_OPTIONAL)
      {
        *pr = (UWORD8) ((mac_header[1] >> CTRL_PR_SHIFT) & PR_MASK);

        /* AC = 1 : TFI is present */
        if (mac_header[0] & AC_MASK)
        {
          // TFI value reading
          tfi = (UWORD8) ((mac_header[1] & CTRL_TFI_MASK) >> CTRL_TFI_SHIFT);

          /* If direction is downlink TBF (D = 1) and a downlink TBF is in progress */
          if ( mac_header[1] & MASK_D)
          {
            if (   (l1ps.read_param.allocated_tbf == DL_TBF)
                || (l1ps.read_param.allocated_tbf == BOTH_TBF))
            {
              // Downlink TFI value is checked
              if (tfi == l1ps.read_param.dl_tfi)
              {
                *tfi_result = TFI_GOOD;
              }
            }
          } /* End if direction is downlink */

          /* If direction is uplink TBF (D = 0) and an uplink TBF is in progress */
          else if (   (l1ps.read_param.allocated_tbf == UL_TBF)
                   || (l1ps.read_param.allocated_tbf == BOTH_TBF))
          {
            // Uplink TFI value is checked
            if (tfi == l1ps.read_param.ul_tfi)
            {
              *tfi_result = TFI_GOOD;
            }

          } /* End if direction is uplink */

        } /* End if AC = 1 */

        /* AC = 0 : TFI is no present */
        else
          *tfi_result = TFI_NOT_PRESENT;

      } // End if control block with optionnal field

    } // End of control block case

  } // End if PAYLOAD != "RESERVED"

#endif

  /*---------------------------------------------------------*/
  /* pr_table updating                                       */
  /*---------------------------------------------------------*/

  if(l1ps.read_param.dl_pwr_ctl.p0 == 255)
    *pr = 0; // PR unused in "No power control" mode
  else
    *pr = PR_CONVERSION[l1ps.read_param.dl_pwr_ctl.bts_pwr_ctl_mode][*pr];

  // If TFI isn't good
  if (*tfi_result != TFI_GOOD)
  {
    // Set bit 7 to 1
    *pr |= 0x80;
  }

}

/*-----------------------------------------------------------*/
/* l1ps_macs_rlc_downlink_call()                             */
/*-----------------------------------------------------------*/
/* Parameters:                                               */
/*                                                           */
/* Return:                                                   */
/*                                                           */
/* Description: This function is called at the end of L1S    */
/*              execution if RLC_DOWNLINK must be called.    */
/*                                                           */
/*-----------------------------------------------------------*/
void l1ps_macs_rlc_downlink_call(void)
{
  UWORD8 i;
  #if FF_TBF
    UWORD32         fn;
    BOOL            rlc_dl_call = FALSE;
    API*            rlc_buffer;
    API*            dummy_rlc_buffer = NULL;

    //correct reporting of FN to L3 should be TDMA 4, 8 or 12 of MF13
    fn=l1s.actual_time.fn-l1s.actual_time.fn_mod13_mod4;

    //when fn is in first block of the MF13 (which value is not a correct value
    //to report to upper layer) then fn should be decremented so that fn%13 = 12
    if(l1s.actual_time.fn_mod13 <= 3)
      fn--;

    //to cope with border case
//    if (fn < 0)  //OMAPS00090550
//      fn += MAX_FN - 1; //OMAPS00090550

    // Retrieve decoded blocks from API. All payload decoded check.
    if (!rlc_downlink_copy_buffer(FALSE))
    {
      // Flag RLC call
      rlc_dl_call = TRUE;

      // RLC buffer exhaustion check
      if ((macs.dl_buffer_index == INVALID) || (l1a_l1s_com.recovery_flag))
      {
        if (macs.tdma_delay >= 3)
        {
          // No block reported ever by DSP
      //    #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
      //      l1_trace_egprs(NO_BLOCKS_PASSED_TO_L3);
       //   #endif

          #if (TRACE_TYPE==5)
            trace_fct_simu("MACS ERROR: No RLC blocks passed to L3 on current frame", 0);
            sprintf(errormsg,"MACS ERROR: No RLC blocks passed to L3 on current frame");
            log_sim_error(ERR);
          #endif
        }
        else
        {
          // No RLC buffer available

          #if (TRACE_TYPE==5)
            trace_fct_simu("MACS ERROR: No free buffer to copy RLC blocks on current frame", 0);
            //sprintf(errormsg,"MACS ERROR: No free buffer to copy RLC blocks on current frame");
            //log_sim_error(ERR);
          #endif
        }

        // Dummy buffer to be reported
        rlc_buffer = (API*) dummy_rlc_buffer;
      }
      // RLC buffer has been succesfully allocated
      else
      {
        // RLC buffer to be reported
        rlc_buffer = (API*) &(macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs);

        #if (TRACE_TYPE == 1)||(TRACE_TYPE == 4)
          #if L1_BINARY_TRACE == 0
            if (trace_info.current_config->l1_dyn_trace & (1<<L1_DYN_TRACE_DL_PDTCH_CRC))
            {
              BOOL    crc_error=0;
              UWORD8  i;
              #if L1_EGPRS
                if (l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode == TBF_MODE_EGPRS)
                {
                  for(i=0;i<macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs;i++)
                    crc_error |= ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & (1 << B_CRC_BLOCK_ERROR)) >> (1+i));
                }
                else
              #endif
                {
                  for(i=0;i<macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs;i++)
                    crc_error |= ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_gprs[i][0] & (1 << B_CRC_BLOCK_ERROR)) >> (1+i));
                }
              Trace_Packet_Transfer(crc_error); // Previous RX blocks CRC_ERROR summary
            }
          #endif
        #endif
        #if L1_EGPRS
          // IR testing specific trace
          #if (TRACE_TYPE == 1)||(TRACE_TYPE == 4)
            if ((trace_info.current_config->l1_dyn_trace & (1<<L1_DYN_TRACE_IR))
                && (l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode == TBF_MODE_EGPRS))
            {
              UWORD8 j ;
              // Clear ir trace variables
              trace_info.ir_trace.crc    = 0;
              trace_info.ir_trace.mcs    = 0;
		          trace_info.ir_trace.status_ir_tfi = 0;
              trace_info.ir_trace.puncturing = 0;

              for(j=0;j<MS_CLASS[MAX_CLASS].rx;j++)
              {
                trace_info.ir_trace.bsn[j] = 0;
                trace_info.ir_trace.cv_bep_egprs[j]= 0;
		            trace_info.ir_trace.mean_bep_egprs[j] = 0;
              }

              // Retrieve IR info from every PDCH
              for(i=0;i<macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs;i++)
              {
                UWORD16 crc;
                UWORD16 bsn1, bsn2;
                UWORD8  mcs;
                UWORD8  cps;
                UWORD8  k;

                // retrieve coding scheme
                mcs = (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & CS_EGPRS_MASK);

                j = k = 0 ;

                // retrieve BSN
                switch (mcs)
                {
                  case CS1_TYPE_POLL:
                  case CS1_TYPE_DATA:
                  case CS2_TYPE:
                  case CS3_TYPE:
                  case CS4_TYPE:
                    // GPRS data block
                    if ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & (1 << B_CRC_BLOCK_ERROR)) || (mcs == CS1_TYPE_POLL))
                      bsn1 = 0xffff;
                    else
                      bsn1 = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 1] >> 1) & 0x7f);
                    bsn2 = 0;

                    crc = (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & ((1 << B_CRC_HEADER_ERROR) + (1 << B_CRC_PAYLOAD1_ERROR) + (1 << B_CRC_BLOCK_ERROR)));
                    crc = (crc >> B_CRC_HEADER_ERROR);
                    break;

                  case MCS1_TYPE:
                  case MCS2_TYPE:
                  case MCS3_TYPE:
                  case MCS4_TYPE:
                    // rlc mac header type 3
                    cps = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 1]) >> 9) & 0x0F ;
                    j = 255 ; // cps is set
                  case MCS5_TYPE:
                  case MCS6_TYPE:
                      // rlc mac header type 2
                    if (j != 255)
                    {
                      cps = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 1]) >> 9) & 0x07 ;
                    }
                    do
                    {
                      if (cps == CPS_value1_6[k][mcs-MCS1_TYPE])
                      { // set puncturing scheme for payload 1 and 2: 0x01 PS1 0x10 PS2 0x11 PS3 related to time slot i
                        trace_info.ir_trace.puncturing |= (((k+1) << 2) << (4*(3-i))) ;
                        break ;
                      }
                      k++;
                    } while (k < 3) ;

                    // EGPRS data block, Header Type 2 and 3
                    if (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & (1 << B_CRC_HEADER_ERROR))
                      bsn1 = 0xffff;
                    else
                    {
                      bsn1 = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 0] >> 14) & 0x03);
                      bsn1 |= ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 1] & 0x1ff) << 2);
                    }
                    bsn2 = 0;

                    crc = (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & ((1 << B_CRC_HEADER_ERROR) + (1 << B_CRC_PAYLOAD1_ERROR) + (1 << B_CRC_BLOCK_ERROR)));
                    crc = (crc >> B_CRC_HEADER_ERROR);
                    break;

                  case MCS7_TYPE:
                  case MCS8_TYPE:
                  case MCS9_TYPE:
                    // rlc mac header type 1
                    cps = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 2]) >> 3) & 0x1F ;
                    do
                    {
                      if (cps == CPS_value7_9[j][k][mcs-MCS7_TYPE])
                      {  // set puncturing scheme for payload 1 and 2: 0x01 PS1 0x10 PS2 0x11 PS3 related to time slot i
                        trace_info.ir_trace.puncturing |= ((((j+1) << 2) | (k+1)) << (4*(3-i))) ;
                        break ;
                      }
                      k++;
                      if (k == 3)
                      {
                        k = 0;
                        j++ ;
                      }
                    } while (j < 3) ;

                    // EGPRS data block, Header Type 1
                    if (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & (1 << B_CRC_HEADER_ERROR))
                    {
                      bsn1 = 0xffff;
                      bsn2 = 0xffff;
                    }
                    else
                    {
                      bsn1 =  ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 0] >> 14) & 0x03);
                      bsn1 |= ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 1] & 0x1ff) << 2);

                      bsn2 =  ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 1] >> 9) & 0x7f);
                      bsn2 |= ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][SIZE_DSP_HEADER_EGPRS + 2] & 0x07) << 7);
                      bsn2 += bsn1;
                      if (bsn2 >= 2048)
                        bsn2 -= 2048;
                    }

                    crc = (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & ((1 << B_CRC_HEADER_ERROR) + (1 << B_CRC_PAYLOAD1_ERROR) + (1 << B_CRC_PAYLOAD2_ERROR) + (1 << B_CRC_BLOCK_ERROR)));
                    crc = (crc >> B_CRC_HEADER_ERROR);
                    break;

                  default:
                    bsn1 = 0xffff;
                    bsn2 = 0xffff;
                    crc = ((1 << B_CRC_HEADER_ERROR) + (1 << B_CRC_PAYLOAD1_ERROR) + (1 << B_CRC_PAYLOAD2_ERROR) + (1 << B_CRC_BLOCK_ERROR));
                    crc = (crc >> B_CRC_HEADER_ERROR);
                    break;
                }

                // Update IR info from current PDCH
                trace_info.ir_trace.crc    |= (crc << ((3-i)*8));
                trace_info.ir_trace.bsn[i] =  ((bsn1 << 16) | bsn2);
                trace_info.ir_trace.mcs    |= ((mcs << ((3-i)*8)));

                /* we take only the msb of cv_bep and mean_bep */
                trace_info.ir_trace.cv_bep_egprs[i] = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][2]) >> 8) ;
                trace_info.ir_trace.mean_bep_egprs[i] = (macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][3]) ;
                if (((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & TFI_BIT_MASK) >> TFI_BIT_SHIFT) == TFI_BAD)
                  trace_info.ir_trace.status_ir_tfi |= (0x1 << (3-i)) ; /* set tfi flag to 1 if block is not for MS */
              }

              trace_info.ir_trace.fn = l1s.actual_time.fn ;
              trace_info.ir_trace.status_ir_tfi |= ((macs.rlc_dbl_buffer[macs.dl_buffer_index].dl_status & (1 << IR_OUT_OF_MEMORY))<<(7-IR_OUT_OF_MEMORY)) ;

             // Output trace
              Trace_IR (&trace_info.ir_trace) ;
            }
          #endif //(TRACE_TYPE == 1)||(TRACE_TYPE == 4)
        #endif //L1_EGPRS
        #if TESTMODE
          if (l1_config.TestMode)
          {
            BOOL    crc_error_bler; //Local var used for accumulating BLER
            UWORD8  i;

            l1tm.tmode_stats.bler_total_blocks++;
            #if L1_EGPRS
              if (l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode == TBF_MODE_EGPRS)
              {
                for(i=0;i<macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs;i++)
                {
                  //bler_total_blocks gives the total number of blocks for computing BLER
                  //The block error is assigned to crc_error_bler.
                  //If the block is in error bler_crc is incremented.
                  crc_error_bler = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & (1 << B_CRC_BLOCK_ERROR)) >> B_CRC_BLOCK_ERROR);
                  if (crc_error_bler == TRUE)
                    l1tm.tmode_stats.bler_crc[i]++;
                }
              }
              else
            #endif
              {
                for(i=0;i<macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs;i++)
                {
                  //bler_total_blocks gives the total number of blocks for computing BLER
                  //The block error is assigned to crc_error_bler.
                  //If the block is in error bler_crc is incremented.
                  crc_error_bler = ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_gprs[i][0] & (1 << B_CRC_BLOCK_ERROR)) >> B_CRC_BLOCK_ERROR);
                  if (crc_error_bler == TRUE)
                    l1tm.tmode_stats.bler_crc[i]++;
                }
              }
          }
        #endif
      }
    }
    // Payload still awaited
    else // (!rlc_downlink_copy_buffer(FALSE)
    {
      // Check spreading limit not exceeded
      if ((macs.tdma_delay >= 3) || (l1a_l1s_com.recovery_flag))
      {
        // Free RLC buffer
        macs.rlc_dbl_buffer[macs.dl_buffer_index].d_rlcmac_rx_no_gprs = RLC_BLOCK_ACK;

        // Flag RLC call
        rlc_dl_call = TRUE;

        // Dummy buffer to be reported
        rlc_buffer = (API*) dummy_rlc_buffer;

        // No block reported ever by DSP

        #if (TRACE_TYPE==5)
          trace_fct_simu("MACS ERROR: No RLC blocks passed to L3 on current frame", 0);
          sprintf(errormsg,"MACS ERROR: No RLC blocks passed to L3 on current frame");
          log_sim_error(ERR);
        #endif
      }
      else
        // Increment spreading counter
        macs.tdma_delay++;
    } // (!rlc_downlink_copy_buffer(FALSE)

    // Function RLC_DOWNLINK_DATA() to be invoked
    if (rlc_dl_call)
    {

      rlc_downlink_data( l1ps_macs_com.rlc_downlink_bufferize_param.assignment_id, // Assignment ID
                         fn,                                                       // Frame number
                         rlc_buffer                                                // Pointer on the DL structure
                       );

      // Add the RLC_D traces in the case of EGPRS also

      #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
        if ((trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_RLC_PARAM)
           && (rlc_buffer != NULL))
        {
          UWORD8 i;
          UWORD16 dl_blk_status[4] = {0,0,0,0};
          for (i=0;i<macs.rx_no;i++)
          {
            #if (L1_EGPRS)
              if (l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode == TBF_MODE_EGPRS)
              {
                dl_blk_status[i] = A_DD_XGPRS[TBF_MODE_EGPRS][i][0];
              }
              else
              {
            #endif
                dl_blk_status[i] = (((UWORD8) NDB_PTR->a_dd_gprs[i][0]) & 0x070F);
            #if (L1_EGPRS)
              }
            #endif
          }
          Trace_rlc_dl_param(l1ps_macs_com.rlc_downlink_bufferize_param.assignment_id,
                       l1s.actual_time.fn,
                       macs.rx_no,
                       macs.rlc_blocks_sent,
                       macs.last_poll_response,
                       (dl_blk_status[1]<<16) |dl_blk_status[0], //dl_blk_status for TS1 and TS0
                       (dl_blk_status[3]<<16) |dl_blk_status[2]);//dl_blk_status for TS3 and TS2
        }
      #endif
      macs.rx_no                      = 0;
      l1ps_macs_com.rlc_downlink_call = FALSE;
    }

  #else

  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
    if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
    {
      // If some RX have been received or some TX have been programmed
      if ((macs.last_rx_alloc != 0) || (macs.tx_allocation != 0))
      {
        // Send trace
        Trace_condensed_pdtch(macs.last_rx_alloc, macs.tx_allocation);
      }

      // Reset PDTCH trace structure
      for(i=0; i<8; i++)
      {
        trace_info.pdtch_trace.dl_status[i] = 0;
        trace_info.pdtch_trace.ul_status[i] = 0;
      }
      trace_info.pdtch_trace.dl_cs_type   = 0;
      trace_info.pdtch_trace.blk_status   = 0;
    }
  #endif


  // Last_poll_error processing
  //---------------------------

  // All slots allocated for poll response transmission (allocated in tx_allocation
  // but not in tx_data) are set to 0 (no error) in last_poll_response
  macs.last_poll_response &= (UWORD8) (~(macs.tx_allocation) | macs.tx_data);

  /* last_poll_response correspondance with network timeslot numbers */
  i = macs.old_synchro_ts - RXTX_DELAY;

  if (i > MAX_TS_NB)
  {
    macs.last_poll_response <<= (-i);
  }
  else
  {
    macs.last_poll_response >>= i;
  }

  // Store number of RX within NDB for RLC
  //--------------------------------------

  NDB_PTR->d_rlcmac_rx_no_gprs = macs.rx_no;

  #if L1_RECOVERY
    // blocks get a CRC error in case of COM error
    if (l1a_l1s_com.recovery_flag == TRUE)
    {
     // force bad CRC for 4 RX slots
      NDB_PTR->a_dd_gprs[0][0] |= 0x0100;
      NDB_PTR->a_dd_gprs[1][0] |= 0x0100;
      NDB_PTR->a_dd_gprs[2][0] |= 0x0100;
      NDB_PTR->a_dd_gprs[3][0] |= 0x0100;
    }
  #endif
  /******************/

  // Call RLC_DOWNLINK
  //------------------

  rlc_downlink( l1ps.read_param.assignment_id,            // Assignment ID
                l1s.actual_time.fn,                       // Frame number
                (API*) &(NDB_PTR->d_rlcmac_rx_no_gprs),   // Pointer on the DL structure
                 macs.rlc_blocks_sent,                    // ID of the last transmitted uplink
                                                          //   data block
                 macs.last_poll_response                  // Status of the poll responses of
              );                                          //   the last block period

  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
    if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_RLC_PARAM)
    {
      Trace_rlc_dl_param(l1ps.read_param.assignment_id,
                         l1s.actual_time.fn,
                         (UWORD32) &(NDB_PTR->d_rlcmac_rx_no_gprs),
                         (UWORD8)  NDB_PTR->d_rlcmac_rx_no_gprs,
                         macs.rlc_blocks_sent,
                         macs.last_poll_response);
    }
  #endif

      /* FreeCalypso TCS211 reconstruction */
      #if 0 //TESTMODE
          if (l1_config.TestMode)
          {
            BOOL    crc_error_bler; //Local var used for accumulating BLER
            UWORD8  i;

            l1tm.tmode_stats.bler_total_blocks++;

            for(i=0; i < macs.rx_no; i++)
             {
                //bler_total_blocks gives the total number of blocks for computing BLER
                //The block error is assigned to crc_error_bler.
                //If the block is in error bler_crc is incremented.
               crc_error_bler = ( (NDB_PTR->a_dd_gprs[i][0] & (1 << B_CRC_BLOCK_ERROR)) >> B_CRC_BLOCK_ERROR);
               if (crc_error_bler == TRUE)
                 l1tm.tmode_stats.bler_crc[i]++;
              }
          }
        #endif

  // Clear parameters
  //-----------------

  /* All downlink blocks were processed */
  macs.last_rx_alloc              = 0;
  macs.rx_no                      = 0;
  macs.rlc_blocks_sent            = 0;
  macs.last_poll_response         = 0;

  l1ps_macs_com.rlc_downlink_call = FALSE;

  // Reset CS type.
  //---------------
  #if (DSP == 33)  || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)
    NDB_PTR->a_dd_gprs[0][0] = NDB_PTR->a_dd_gprs[1][0] = NDB_PTR->a_dd_gprs[2][0] =
    NDB_PTR->a_dd_gprs[3][0] = NDB_PTR->a_dd_gprs[4][0] = NDB_PTR->a_dd_gprs[5][0] =
    NDB_PTR->a_dd_gprs[6][0] = NDB_PTR->a_dd_gprs[7][0] = CS_NONE_TYPE;
  #else
    NDB_PTR->a_dd_gprs[0][0] = NDB_PTR->a_dd_gprs[1][0] = NDB_PTR->a_dd_gprs[2][0] =
    NDB_PTR->a_dd_gprs[3][0] = CS_NONE_TYPE;
  #endif
#endif
}//void l1ps_macs_rlc_downlink_call(void)
#if FF_TBF
/*-----------------------------------------------------------*/
/* l1ps_macs_rlc_uplink_info()                             */
/*-----------------------------------------------------------*/
/* Parameters:                                               */
/*                                                           */
/* Return:                                                   */
/*                                                           */
/* Description: This function is called in the               */
/*              l1ps_macs_ctrl() function on TDMA 4, 8 or 12 */
/*              of MF13                                      */
/*                                                           */
/*-----------------------------------------------------------*/
void l1ps_macs_rlc_uplink_info(void)
{
  UWORD8 i;

  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4))
    if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH)
    {
      // If some RX have been received or some TX have been programmed
      if ((macs.last_rx_alloc != 0) || (macs.tx_allocation != 0))
      {
        // Send trace
        Trace_condensed_pdtch(macs.last_rx_alloc, macs.tx_allocation);
      }

      // Reset PDTCH trace structure
      for(i=0; i<8; i++)
      {
        trace_info.pdtch_trace.dl_status[i] = 0;
        trace_info.pdtch_trace.ul_status[i] = 0;
      }
      trace_info.pdtch_trace.dl_cs_type   = 0;
      trace_info.pdtch_trace.blk_status   = 0;
    }
  #endif

  // Last_poll_error processing
  //---------------------------

  /* All slots allocated for poll response transmission (allocated in tx_allocation
     but not in tx_data) are set to 0 (no error) in last_poll_response */
  macs.last_poll_response &= (UWORD8) (~(macs.tx_allocation) | macs.tx_data);

  /* last_poll_response correspondance with network timeslot numbers */
  i = macs.old_synchro_ts - RXTX_DELAY;

  if (i > MAX_TS_NB)
  {
    macs.last_poll_response <<= (-i);
  }
  else
  {
    macs.last_poll_response >>= i;
  }

  #if L1_EGPRS
    //sub_mode is ON
    if (l1ps_macs_com.loop_param.sub_mode == TRUE)
    {
      macs.rlc_blocks_sent    = 0;
      macs.last_poll_response = 0;
    }
  #endif

  rlc_uplink_info(l1ps.read_param.assignment_id,
                  l1s.actual_time.fn,
                  macs.rlc_blocks_sent,
                  macs.last_poll_response);

  //While the initialization of these variables is performed in the
  //l1ps_macs_rlc_downlink_call() for GPRS, for EGPRS the initialization
  //is done here below. Note that it is still performed on frame index 0
  //of MF13 in the l1s_end_manager() function whether in EGPRS or GPRS mode.
  //The variable below is set in the l1ps_macs_ctrl() function on frame index 2 of MF13
  //and stores the rx allocation. This allocation is used later in the l1ps_macs_read()
  //function to pass the blocks that were received in the previous block period.
  macs.last_rx_alloc              = 0;
  macs.rlc_blocks_sent            = 0;
  macs.last_poll_response         = 0;
}

/*-----------------------------------------------------------*/
/* rlc_downlink_copy_buffer()                                */
/*-----------------------------------------------------------*/
/* Parameters:  isr: flag that indicates whether the call    */
/*                   of this function is performed at the    */
/*                   beginning of the hisr() function        */
/*                   (hisr = TRUE) or not.                   */
/*                                                           */
/* Return:      missing_payload: flag that indicates if still*/
/*                               payloads are missing after  */
/*                               the copy                    */
/*                                                           */
/* Description: This function is called in the hisr()        */
/*              function with hisr = TRUE and in the         */
/*              l1ps_macs_rlc_downlink_call() function       */
/*              with hisr = FALSE                            */
/*-----------------------------------------------------------*/
  UWORD8 rlc_downlink_copy_buffer(UWORD8 isr)
  {
    BOOL missing_payload   = FALSE;
    BOOL allocation_needed = FALSE;

    UWORD32 i,j;

    // Downlink blocks expected
    if (l1ps_macs_com.rlc_downlink_call)
    {
      // Not in TDMA3 unless we are in ISR so we may have blocks to copy
      if ( ((macs.tdma_delay < 3) && (!isr)) // No logical XOR in C
           || ((macs.tdma_delay >= 3) && (isr))
         )

      {
        // Test buffer allocation requirement if not already allocated
        if (macs.dl_buffer_index == INVALID)
        {
            allocation_needed = TRUE;
        }

        // Look for an available buffer and initialize it
        if (allocation_needed)
        {
          for (i = 0; i < NBR_SHARED_BUFFER_RLC; i++)
          {
            //as soon as one free block is found
            if (macs.rlc_dbl_buffer[i].d_rlcmac_rx_no_gprs == RLC_BLOCK_ACK)
            {
              // Store buffer index
              macs.dl_buffer_index = i;
              // Store number of blocks in buffer passed to RLC
              macs.rlc_dbl_buffer[i].d_rlcmac_rx_no_gprs = macs.rx_no;
              break;
            }
          }
        }

        // Copy available blocks if buffer allocated
        if (macs.dl_buffer_index != INVALID)
        {
          // GPRS mode, no spreading
        #if L1_EGPRS
          if (l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode == TBF_MODE_GPRS)
        #endif
          {
            // Copy whole bunch of blocks (4 downlink, worst case)
            for (i=0;i<NBR_BUFFER_GPRS;i++)
            {
              memcpy((char*) &macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_gprs[i][0],
                     (char*) A_DD_XGPRS[TBF_MODE_GPRS][i],
                     SIZE_GPRS_DL_BUFF * sizeof(API));
            }
          }
          // EGPRS mode
        #if L1_EGPRS
          else
          {
            // Parse every expected block
            for (i = 0; i < macs.rx_no; i++)
            {
              // If not already copied
              if ((macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0] & CS_EGPRS_MASK) == CS_NONE_TYPE)
              {
                // New block available in API
                if (A_DD_XGPRS[TBF_MODE_EGPRS][i][0] & (1 << B_BLK_READY))
                {
                  // Copy block from API to SRAM
                  memcpy((char*) &macs.rlc_dbl_buffer[macs.dl_buffer_index].buffer.a_dd_egprs[i][0],
                         (char*) A_DD_XGPRS[TBF_MODE_EGPRS][i],
                         SIZE_EGPRS_DL_BUFF * sizeof(API));

                  // Acknowledge DSP
                  A_DD_XGPRS[TBF_MODE_EGPRS][i][0] &= ~(1 << B_BLK_READY);
                }
                else
                  missing_payload = TRUE;
              }
            }
          } // TBF mode
        #endif

          // Store "missing payload" flag used for TDMA3 limit case.
          macs.dl_missing_payload = missing_payload;

        } // Buffer is allocated
        else
        {
          // No buffer allocated yet
          if (allocation_needed)
            // RLC Buffer exhaustion - abort
            missing_payload = FALSE;
          else
           // No buffer allocated yet as no block present
           missing_payload = TRUE;

          // Still some buffer expected
          macs.dl_missing_payload = TRUE;
        }
      } // Not in ISR TDMA 0,1,2, or ISR from TDMA 3
      else if ((macs.tdma_delay >= 3) && (!isr))
      {
        // End of L1S in TDMA3, we need to report the status from ISR call.
        missing_payload = macs.dl_missing_payload;
      }

      // IR status reporting (relevant for EGPRS only)
      //----------------------------------------------

      // RLC buffer allocated, all blocks received
      if ((macs.dl_buffer_index != INVALID) && (!missing_payload))
      {
      #if L1_EGPRS
        if ( (l1ps_macs_com.rlc_downlink_bufferize_param.tbf_mode == TBF_MODE_EGPRS)
             && (l1ps_dsp_com.edsp_ndb_ptr->d_modem_status_egprs & (1 << B_IR_OUT_OF_MEM)) )
        {
          // EGPRS TBF mode, IR out of memory status flag is set
          macs.rlc_dbl_buffer[macs.dl_buffer_index].dl_status |= (1 << IR_OUT_OF_MEMORY);
        }
        else
      #endif
        {
          // GPRS TBF mode or EGPRS but IR out of memory not detected
          macs.rlc_dbl_buffer[macs.dl_buffer_index].dl_status &= (~(1 << IR_OUT_OF_MEMORY));
        }
      }
    } // if (l1ps_macs_com.rlc_downlink_call)

    // Return blocks receipt completion status
    return missing_payload;
}

#endif //FF_TBF

#if TESTMODE
  //===========================================================================
  // Function called instead of l1ps_macs_ctrl if CMU200 loop mode is selected
  //===========================================================================

  void l1ps_tmode_macs_ctrl(void)
  {
    #define NDB_PTR  l1ps_dsp_com.pdsp_ndb_ptr
    #define SET_PTR  l1pa_l1ps_com.transfer.aset

    NDB_PTR->a_du_gprs[0][0]     = l1_config.tmode.tx_params.coding_scheme;

    /* Enable loop */
    NDB_PTR->d_sched_mode_gprs |= (1<<6);

    // Force single slot allocation for CMU loop: 1RX, 1TX
    macs.rx_allocation = 0x80;
    macs.tx_allocation = 0x10;
    macs.tx_prach_allocation = 0;
    macs.pwr_allocation = 0;

    macs.ul_buffer_index[0] = 0xFF;                          // UL buffer index
    macs.ul_buffer_index[1] = 0xFF;
    macs.ul_buffer_index[2] = 0xFF;
    macs.ul_buffer_index[3] = 0;
    macs.ul_buffer_index[4] = 0xFF;
    macs.ul_buffer_index[5] = 0xFF;
    macs.ul_buffer_index[6] = 0xFF;
    macs.ul_buffer_index[7] = 0xFF;

    /* Disable USF management in the DSP */
    macs.usf_vote_enable = 0;

    /***********************************************************/
    /* MAC-S control result for LAYER 1                        */
    /***********************************************************/

    /* We update allocation structures in Layer 1 - MAC-S interface */
    l1ps_macs_com.rx_allocation       = macs.rx_allocation;
    l1ps_macs_com.tx_nb_allocation    = macs.tx_allocation & (~macs.tx_prach_allocation);
    l1ps_macs_com.tx_prach_allocation = macs.tx_prach_allocation;
    l1ps_macs_com.pwr_allocation      = macs.pwr_allocation;

    /***********************************************************/
    /* DSP programming                                         */
    /***********************************************************/

    // Write uplink blocks - timeslots correspondance in a_ul_buffer_gprs
    // MAC mode in d_sched_mode_gprs and the USF table in a_usf_gprs (Each frame)

    l1pddsp_transfer_mslot_ctrl
        (l1s.next_time.fn_mod13_mod4,                   // Burst number (0 to 3)
         macs.rx_allocation,                            // DL Bitmap
         macs.tx_allocation,                            // UL Bitmap
         SET_PTR->ul_tbf_alloc->dynamic_alloc.usf_table, // USF table
         SET_PTR->mac_mode,                             // MAC mode
         macs.ul_buffer_index,                          // UL buffer index
         SET_PTR->tsc,                                  // Training sequence code
         l1a_l1s_com.dedic_set.radio_freq,              // Radio Freq. used for I/Q swap.
         l1a_l1s_com.dl_tn,                             // DL Transfer Sync. TN.
       #if FF_L1_IT_DSP_USF
         macs.dsp_usf_interrupt                         // USF interrupt activation
       #else
         macs.usf_vote_enable                           // USF vote activation
       #endif
     );

   //NDB_PTR->a_ctrl_ched_gprs[0] = CS1_TYPE_DATA;
   NDB_PTR->a_ctrl_ched_gprs[0] = NDB_PTR->a_du_gprs[0][0];

  }
#endif
#endif // L1_GPRS