l1tm_cust.c

MMI层OBJ不能完全编译

/************* Revision Controle System Header *************
 *                  GSM Layer 1 software
 * L1TM_CUST.C
 *
 *        Filename l1tm_cust.c
 *  Copyright 2003 (C) Texas Instruments  
 * 
 ************* Revision Controle System Header *************/

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

#if TESTMODE

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

#include "l1tm_defty.h"
#include "l1tm_cust.h"
  #include "l1audio_const.h"

#if (AUDIO_TASK == 1)
  #include "l1audio_cust.h"
  #include "l1audio_defty.h"
#endif
  #include "l1audio_stcust.h"
  
#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_msgty.h"
#include "l1_tabs.h"

#include "l1tm_msgty.h"
#include "l1tm_varex.h"

#include "abb.h"

#if (RF_FAM == 61)
  #include "tpudrv61.h"
  #include "l1_rf61.h"
  #include "apc.h"
#endif


#if (RF_FAM == 43)
  #include "tpudrv43.h"
  #include "l1_rf43.h"
#endif
#if (RF_FAM == 35)
  #include "tpudrv35.h"
  #include "l1_rf35.h"
#endif

#if (RF_FAM == 12)
  #include "tpudrv12.h"
  #include "l1_rf12.h"
#endif

#if (RF_FAM == 10)
  #include "tpudrv10.h"
  #include "l1_rf10.h"
#endif

#if (RF_FAM == 8)
  #include "tpudrv8.h"
  #include "l1_rf8.h"
#endif

#if (RF_FAM == 2)
  #include "l1_rf2.h"
#endif

#if ( L1_DRP == 1)
  #include "drp_drive.h"
#endif

#if (RF_FAM == 60)
  #include "tpudrv60.h"
  #include "l1_rf60.h"
#endif

#include "l1tm_signa.h"
#include <string.h>
#include "lcc/lcc_trace.h"
// Import band configuration from Flash module (need to replace by an access function)
//extern UWORD8       std;
extern T_L1_CONFIG  l1_config;
extern T_RF rf;
extern T_RF_BAND rf_band[GSM_BANDS];
extern UWORD16 AGC_TABLE[AGC_TABLE_SIZE];
extern T_ADC adc;
extern T_ADCCAL adc_cal;
extern UWORD16 TM_ul_data[16]; //Uplink data to be stored into ABB Uplink buffer
extern T_STD_CONFIG std_config[];
static UWORD8 tm_band = 0;

//Flexible TPU Timings
#if (L1_TPU_DEV == 1)
extern WORD16 rf_rx_tpu_timings[];
extern WORD16 rf_rx_tpu_timings[];

extern WORD16 rf_flexi_abb_delays[];
#endif

// External function prototypes
void get_cal_from_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id);
UWORD8 save_cal_in_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id);
void Cust_init_std(void);
void l1_tpu_init_light(void);

enum {
  TM_RF_ID        = 0,
  TM_ADC_ID       = 1
};

typedef signed char effs_t;
// external FFS function prototypes
effs_t ffs_mkdir(const char *pathname);
void config_ffs_write(char type);

/***********************************************************************/
/*                           TESTMODE 4.X                              */
/***********************************************************************/


/*----------------------------------------------------------*/
/* Cust_tm_init()                                           */
/*----------------------------------------------------------*/
/* Parameters :                                             */
/* Return     :                                             */
/* Functionality : Init default configuration for TM params */
/*----------------------------------------------------------*/

void Cust_tm_init(void)
{
  UWORD32 i;

  l1_config.adc_enable                             = ADC_ENABLE; // ADC readings enabled
  l1_config.agc_enable                             = AGC_ENABLE; // AGC algo enabled
  l1_config.afc_enable                             = AFC_ENABLE; // AFC algo enabled
  l1_config.tmode.rf_params.bcch_arfcn             = TM_BCCH_ARFCN;
  l1_config.tmode.rf_params.tch_arfcn              = TM_TCH_ARFCN;
  l1_config.tmode.rf_params.mon_arfcn              = TM_MON_ARFCN;
  l1_config.tmode.rf_params.channel_type           = TM_CHAN_TYPE; // TCH_F
  l1_config.tmode.rf_params.subchannel             = TM_SUB_CHAN;
  l1_config.tmode.rf_params.reload_ramps_flag      = 0;
  l1_config.tmode.rf_params.tmode_continuous       = TM_NO_CONTINUOUS;
  l1_config.tmode.rx_params.slot_num               = TM_SLOT_NUM; // Time Slot
  l1_config.tmode.rx_params.agc                    = TM_AGC_VALUE; //This may be outside the range of the RF chip used
  l1_config.tmode.rx_params.pm_enable              = TM_PM_ENABLE;
  l1_config.tmode.rx_params.lna_off                = TM_LNA_OFF;
  l1_config.tmode.rx_params.number_of_measurements = TM_NUM_MEAS;  
  l1_config.tmode.rx_params.place_of_measurement   = TM_WIN_MEAS;
  l1_config.tmode.tx_params.txpwr                  = TM_TXPWR; // Min power level for GSM900
  l1_config.tmode.tx_params.txpwr_skip             = TM_TXPWR_SKIP;
  l1_config.tmode.tx_params.timing_advance         = TM_TA;
  l1_config.tmode.tx_params.burst_type             = TM_BURST_TYPE; // default is normal up-link burst
  l1_config.tmode.tx_params.burst_data             = TM_BURST_DATA; // default is all zeros
  l1_config.tmode.tx_params.tsc                    = TM_TSC; // Training Sequence ("BCC" on BSS)
#if (CODE_VERSION != SIMULATION)
  l1_config.tmode.stats_config.num_loops           = TM_NUM_LOOPS; // 0 actually means infinite
#else
  l1_config.tmode.stats_config.num_loops           = 4; // 0 actually means infinite
#endif
  l1_config.tmode.stats_config.auto_result_loops   = TM_AUTO_RESULT_LOOPS; // 0 actually means infinite
  l1_config.tmode.stats_config.auto_reset_loops    = TM_AUTO_RESET_LOOPS; // 0 actually means infinite
  l1_config.tmode.stats_config.stat_type           = TM_STAT_TYPE;
  l1_config.tmode.stats_config.stat_bitmask        = TM_STAT_BITMASK;

#if (CODE_VERSION != SIMULATION)

 #if(RF_FAM != 61)
      // Initialize APCDEL1 register of Omega
      ABB_Write_Register_on_page(PAGE0, APCDEL1, (C_APCDEL1 - 0x0004) >> 6);
 #endif

 #if (RF_FAM == 61)
   // Changing to write the APCDEL1, APCDEL2 and APCCTRL2 via API 
   l1s_dsp_com.dsp_ndb_ptr->d_apcdel1  = l1_config.params.apcdel1;
   l1s_dsp_com.dsp_ndb_ptr->d_apcdel2  = l1_config.params.apcdel2;
   // For APCCTRL2 alone write immediately as it is different from APCDEL1 and APCDEL2
   // By Default l1_config.params.apcctrl2 (C_APCCTRL2) has automatic mode.
   l1ddsp_apc_load_apcctrl2(l1_config.params.apcctrl2);
 #endif


#endif

  l1tm.tm_msg_received   = FALSE;

  for (i=0;i<16;i++)
    TM_ul_data[i]=0;

#if L1_GPRS
  l1_config.tmode.rf_params.pdtch_arfcn          = TM_PDTCH_ARFCN;
  l1_config.tmode.rf_params.multislot_class      = TM_MULTISLOT_CLASS;
  l1_config.tmode.stats_config.stat_gprs_slots   = TM_STAT_GPRS_SLOTS;
  l1_config.tmode.rx_params.timeslot_alloc       = TM_RX_ALLOCATION;
  l1_config.tmode.rx_params.coding_scheme        = TM_RX_CODING_SCHEME;
  l1_config.tmode.tx_params.timeslot_alloc       = TM_TX_ALLOCATION;
  l1_config.tmode.tx_params.coding_scheme        = TM_TX_CODING_SCHEME;
  for (i=0; i<8; i++)
    l1_config.tmode.tx_params.txpwr_gprs[i]      = TM_TXPWR_GPRS;

  for (i=0; i<27; i++)
    l1_config.tmode.tx_params.rlc_buffer[i] = 0;
#endif

#if (L1_TPU_DEV ==1)
  l1_config.tmode.rx_params.p_rf_rx_tpu_timings = rf_rx_tpu_timings;
  l1_config.tmode.tx_params.p_rf_tx_tpu_timings = rf_tx_tpu_timings;

//Flexi ABB Delays
  l1_config.tmode.rf_params.p_rf_flexi_abb_delays= rf_flexi_abb_delays;
 #endif

}



/**********************************************************************/
/* Test mode functions used for RF calibration                        */
/**********************************************************************/

void Cust_tm_rf_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value)
{
  switch (index)
  {
  case STD_BAND_FLAG:
    {
      UWORD8 std_temp, band_temp;

      std_temp  = value & 0xff;  // tm_band = b7..0 of value
      band_temp = value >> 8;    // band    = b15..8 of value
      // get define 
      //if (sizeof(std_config)/sizeof(T_STD_CONFIG) <= std_temp)
      if (9 <= std_temp)  // std max
      {
      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_INVAL;
      #else
        tm_return->status = E_BADINDEX;
      #endif
        break;
      }
      else if ( GSM_BANDS <= band_temp)
      {
      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_INVAL;
      #else
        tm_return->status = E_BADINDEX;
      #endif
        break;
      }
      else if ( BAND_NONE == std_config[std_temp].band[band_temp])
      {
      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_INVAL;
      #else
        tm_return->status = E_BADINDEX;
      #endif
        break;
      }
      else
      {
        l1_config.std.id = std_temp;  
        tm_band = band_temp; 
        // update RAM struct with either default or ffs
        Cust_init_std();
        l1_tpu_init_light();

      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_OK;
      #else
        tm_return->status = E_OK;
      #endif

        break;
      }
    }

  case INITIAL_AFC_DAC:
    {
	#if(RF_FAM !=61)
      rf.afc.eeprom_afc = (WORD16) value << 3; // shift to put into F13.3 format
      #else
      rf.afc.eeprom_afc = (WORD16) value << 2; // shift to put into F14.2 format
    #endif

      l1_config.params.eeprom_afc = rf.afc.eeprom_afc;

      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_OK;
      #else
        tm_return->status = E_OK;
      #endif
      break;
    }

  default:
    {
      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_INVAL;
      #else
        tm_return->status = E_BADINDEX;
      #endif
      break;
    }
  } // end switch
}

void Cust_tm_rf_param_read(T_TM_RETURN *tm_return, WORD16 index)
{
  volatile UWORD16 value;

  switch (index)
  {
  case STD_BAND_FLAG:
    {
      value = ((tm_band << 8) | (l1_config.std.id) ); // return global std, tm_band (intel format)
      break;
    }
  case INITIAL_AFC_DAC:
    {
#if (RF_FAM != 61)
      value = rf.afc.eeprom_afc >> 3; // returned as F13.3
 #else
      value = rf.afc.eeprom_afc >> 2; // returned as F14.2
 #endif
	  
      break;
    }

  
  default:
    {
      tm_return->size = 0;
      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_INVAL;
      #else
        tm_return->status = E_BADINDEX;
      #endif
      return;
    }
  } // end switch

  memcpy(tm_return->result, (UWORD8 *)&value, 2);
  tm_return->size = 2;
#if (ETM_PROTOCOL == 1)
  tm_return->status = -ETM_OK;
#else
  tm_return->status = E_OK;
#endif
}

void Cust_tm_rf_table_write(T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[])
{
  UWORD8 band=0;

  tm_return->index = index;  // store index before it gets modified
  tm_return->size = 0;

  switch (index)
  {
  case RX_AGC_TABLE:
    {
      if (size != sizeof(AGC_TABLE))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        
        break;
      }

      memcpy(&AGC_TABLE[0], table, size);

      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_OK;
      #else
        tm_return->status = E_OK;
      #endif

      break;
    }
  case AFC_PARAMS:
    {

#if (VCXO_ALGO == 1)
      if (size != 24)  //  4 UWORD32 + 4 WORD16 values
#else
        if (size != 16)  // 4 UWORD32 values
#endif
        {
          #if (ETM_PROTOCOL == 1)
            tm_return->status = -ETM_NOMEM;
          #else
            tm_return->status = E_BADSIZE;
          #endif
          break;
        }

        memcpy(&rf.afc.psi_sta_inv, table, size);
        l1_config.params.psi_sta_inv    = rf.afc.psi_sta_inv;
        l1_config.params.psi_st         = rf.afc.psi_st;
        l1_config.params.psi_st_32      = rf.afc.psi_st_32;
        l1_config.params.psi_st_inv     = rf.afc.psi_st_inv;

#if (CODE_VERSION == NOT_SIMULATION)
#if (VCXO_ALGO == 1)
        l1_config.params.afc_dac_center = rf.afc.dac_center;
        l1_config.params.afc_dac_min    = rf.afc.dac_min;   
        l1_config.params.afc_dac_max    = rf.afc.dac_max;   
        l1_config.params.afc_snr_thr    = rf.afc.snr_thr;   
#endif
#endif 

      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_OK;
      #else
        tm_return->status = E_OK;
      #endif
        break;
    }
  case RX_AGC_GLOBAL_PARAMS:
    {

#if W_A_PCTM_RX_AGC_GLOBAL_PARAMS
      // For PCTM, 10 bytes must be accepted but 8 bytes only must be written 
      if (size == 10)
        size = 8;
#endif

      if (size != 8)  // 4 UWORD16 values
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&rf.rx.agc.low_agc_noise_thr, table, size);
      l1_config.params.low_agc_noise_thr  = rf.rx.agc.low_agc_noise_thr;
      l1_config.params.high_agc_sat_thr   = rf.rx.agc.high_agc_sat_thr;
      l1_config.params.low_agc            = rf.rx.agc.low_agc;
      l1_config.params.high_agc           = rf.rx.agc.high_agc;

    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case RX_IL_2_AGC_MAX:
    {
      if (size != sizeof(rf.rx.agc.il2agc_max))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&rf.rx.agc.il2agc_max[0], table, size);
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case RX_IL_2_AGC_PWR:
    {
      if (size != sizeof(rf.rx.agc.il2agc_pwr))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&rf.rx.agc.il2agc_pwr[0], table, size);
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case RX_IL_2_AGC_AV:
    {
      if (size != sizeof(rf.rx.agc.il2agc_av))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&rf.rx.agc.il2agc_av[0], table, size);
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_LEVELS:
    {
      if (size != sizeof(rf_band[tm_band].tx.levels))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&rf_band[tm_band].tx.levels[0], table, size);
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_CAL_CHAN: // generic for all bands
    {
      if (size != sizeof(rf_band[tm_band].tx.chan_cal_table))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&rf_band[tm_band].tx.chan_cal_table[0][0], table, size);
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_CAL_TEMP: // generic for all bands
    {
      if (size != sizeof(rf_band[tm_band].tx.temp))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif