l1tm_cust.c

MMI层OBJ不能完全编译

        break;
      }

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

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

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

      memcpy(&rf_band[tm_band].rx.rx_cal_params, table, size);
      if (tm_band == 0)
      {
        l1_config.std.g_magic_band1             = rf_band[tm_band].rx.rx_cal_params.g_magic;
        l1_config.std.lna_att_band1             = rf_band[tm_band].rx.rx_cal_params.lna_att;
        l1_config.std.lna_switch_thr_low_band1  = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_low;
        l1_config.std.lna_switch_thr_high_band1 = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_high;
      }
      else if (tm_band == 1)
      {
        l1_config.std.g_magic_band2             = rf_band[tm_band].rx.rx_cal_params.g_magic;
        l1_config.std.lna_att_band2             = rf_band[tm_band].rx.rx_cal_params.lna_att;
        l1_config.std.lna_switch_thr_low_band2  = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_low;
        l1_config.std.lna_switch_thr_high_band2 = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_high;
      }
      else
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_INVAL;
        #else
          tm_return->status = E_INVAL;
        #endif
        break;
      }

    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_CAL_EXTREME:
  case RX_CAL_LEVEL:
    {
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_NOSYS;
    #else
      tm_return->status = E_NOSUBSYS;
    #endif  
      break;
    }
#if L1_GPRS
  case RLC_TX_BUFFER_CS1:
  case RLC_TX_BUFFER_CS2:
  case RLC_TX_BUFFER_CS3:
  case RLC_TX_BUFFER_CS4:
    {
      UWORD8 i, buffer_size;

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

      buffer_size = size/2 + size%2;  // bytes will be concatenated into UWORD16

      if (buffer_size > 27)  //max. number of data bytes
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      // make sure that last byte is zero in case of odd number of bytes
      table[size] = 0; 

      // init the whole buffer before downloading new data
      for (i=0; i<27; i++)
        l1_config.tmode.tx_params.rlc_buffer[i] = 0;

      for (i=0; i<buffer_size; i++)
      {
        l1_config.tmode.tx_params.rlc_buffer[i] = (table[2*i+1] << 8) | table[2*i];
      }
      l1_config.tmode.tx_params.rlc_buffer_size = buffer_size;

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

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

      if (size != 32)  // 16 UWORD16 (containing 10 data bits each)
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_NOMEM;
        #else
          tm_return->status = E_BADSIZE;
        #endif
        break;
      }

      memcpy(&TM_ul_data, table, size);

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

    #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_table_read(T_TM_RETURN *tm_return, WORD8 index)
{
  switch (index)
  {
  case RX_AGC_TABLE:
    {
      tm_return->size = sizeof(AGC_TABLE);
      memcpy(tm_return->result, &AGC_TABLE[0], tm_return->size);
      break;
    }
  case AFC_PARAMS:
    {
#if (VCXO_ALGO == 1)
      tm_return->size = 24;  // 4 UWORD32's + 4 WORD16
#else
      tm_return->size = 16;  // 4 UWORD32's
#endif
      memcpy(tm_return->result, &rf.afc.psi_sta_inv, tm_return->size);
      break;
    }
  case RX_AGC_GLOBAL_PARAMS:
    {

#if W_A_PCTM_RX_AGC_GLOBAL_PARAMS
      // 5 are both supported by ETM and PCTM
      // not clean -> final solution should be 4 words for ETM
      tm_return->size = 10;  // 5 UWORD16's
#else
      tm_return->size = 8;  // 4 UWORD16's
#endif
      memcpy(tm_return->result, &rf.rx.agc.low_agc_noise_thr, tm_return->size);
#if W_A_PCTM_RX_AGC_GLOBAL_PARAMS
      tm_return->result[8] = 0;
      tm_return->result[9] = 0;  // Clear last value because no more supported
#endif
      break;
    }
  case RX_IL_2_AGC_MAX:
    {
      tm_return->size = sizeof(rf.rx.agc.il2agc_max);
      memcpy(tm_return->result, &rf.rx.agc.il2agc_max[0], tm_return->size);
      break;
    }
  case RX_IL_2_AGC_PWR:
    {
      tm_return->size = sizeof(rf.rx.agc.il2agc_pwr);
      memcpy(tm_return->result, &rf.rx.agc.il2agc_pwr[0], tm_return->size);
      break;
    }
  case RX_IL_2_AGC_AV:
    {
      tm_return->size = sizeof(rf.rx.agc.il2agc_av);
      memcpy(tm_return->result, &rf.rx.agc.il2agc_av[0], tm_return->size);
      break;
    }
  case TX_LEVELS:
    {
      tm_return->size = sizeof(rf_band[tm_band].tx.levels);
      memcpy(tm_return->result, &rf_band[tm_band].tx.levels[0], tm_return->size);
      break;
    }
  case TX_CAL_CHAN: // generic for all bands
    {
      tm_return->size = sizeof(rf_band[tm_band].tx.chan_cal_table);
      memcpy(tm_return->result, &rf_band[tm_band].tx.chan_cal_table[0][0], tm_return->size);
      break;
    }
  case TX_CAL_TEMP:  // generic for all bands
    {
      tm_return->size = sizeof(rf_band[tm_band].tx.temp);
      memcpy(tm_return->result, &rf_band[tm_band].tx.temp[0], tm_return->size);
      break;
    }
  case RX_CAL_CHAN:  // generic for all bands
    {
      tm_return->size = sizeof(rf_band[tm_band].rx.agc_bands);
      memcpy(tm_return->result, &rf_band[tm_band].rx.agc_bands[0], tm_return->size);
      break;
    }
  case RX_CAL_TEMP:  // generic for all bands
    {
      tm_return->size = sizeof(rf_band[tm_band].rx.temp);
      memcpy(tm_return->result, &rf_band[tm_band].rx.temp[0], tm_return->size);
      break;
    }
  case RX_AGC_PARAMS:
    {
      // WARNING: sizeof(rf.rx.rx_cal_params[band]) returns 12 because of alignment
      tm_return->size = 10;  // five UWORD16's
      memcpy(tm_return->result, &rf_band[tm_band].rx.rx_cal_params, tm_return->size);
      break;
    }
  case TX_CAL_EXTREME:
  case RX_CAL_LEVEL:
    {
      tm_return->size = 0;
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_NOSYS;
    #else
      tm_return->status = E_NOSUBSYS;
    #endif  
      return;
    }
#if L1_GPRS
  case RLC_TX_BUFFER_CS1:
  case RLC_TX_BUFFER_CS2:
  case RLC_TX_BUFFER_CS3:
  case RLC_TX_BUFFER_CS4:
    {
      tm_return->size = l1_config.tmode.tx_params.rlc_buffer_size * 2; // UWORD16's
      memcpy(tm_return->result, &l1_config.tmode.tx_params.rlc_buffer[0], tm_return->size);
      break;
    }

#endif
  case TX_DATA_BUFFER:
    {
      UWORD8 i;
      for (i=0; i<16; i++)
      {
        tm_return->result[2*i]=(TM_ul_data[i] >> 6) & 0x00FF;
        tm_return->result[2*i+1]=(TM_ul_data[i] >> 14) & 0x0003;
      }

      tm_return->size = 32; //16*UWORD16
      break;

    }
    #if (RF_FAM == 35)
    case RX_PLL_TUNING_TABLE:
    {
      tm_return->size = sizeof(pll_tuning); //6*UWORD16
      memcpy(tm_return->result, &pll_tuning, tm_return->size);

      pll_tuning.enable    = 0;

      break;
    }
    #endif

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

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

void Cust_tm_rx_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value)
{
  switch (index)
  {
  case RX_FRONT_DELAY:
    {
      //delay for dual band not implemented yet
      rf.tx.prg_tx = value;
      l1_config.params.prg_tx_gsm = rf.tx.prg_tx;
      l1_config.params.prg_tx_dcs = rf.tx.prg_tx;

    #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_rx_param_read(T_TM_RETURN *tm_return, WORD16 index)
{
  volatile UWORD16 value;

  switch (index)
  {
  case RX_FRONT_DELAY:
    {
      value = rf.tx.prg_tx;
      break;
    } 
  
  default:
    {
      #if (ETM_PROTOCOL == 1)
        tm_return->status = -ETM_INVAL;
      #else
        tm_return->status = E_BADINDEX;
      #endif
      tm_return->size = 0;
      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_tx_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value, UWORD8 band)
{
  switch (index)
  {
  case TX_APC_DAC:
    {
      // generic for all bands
      rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].apc = value;

    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_RAMP_TEMPLATE:
    {
      if (value >= sizeof(rf_band[tm_band].tx.ramp_tables)/sizeof(rf_band[tm_band].tx.ramp_tables[0]))  // [0..15]
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_INVAL;
        #else
          tm_return->status = E_INVAL;
        #endif
        break;
      }

      // generic for all bands
      rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].ramp_index = value;

    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      l1_config.tmode.rf_params.reload_ramps_flag = 1;
      break;
    }
  case TX_CHAN_CAL_TABLE:
    {
      if (value >= sizeof(rf_band[tm_band].tx.chan_cal_table)/sizeof(rf_band[tm_band].tx.chan_cal_table[0]))
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_INVAL;
        #else
          tm_return->status = E_INVAL;
        #endif
        break;
      }

      // generic for all bands
      rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].chan_cal_index = value;

    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_BURST_TYPE:
    {
      if (value > 1)  // [0..1]
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_INVAL;
        #else
          tm_return->status = E_INVAL;
        #endif
        break;
      }
      l1_config.tmode.tx_params.burst_type = value;
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_BURST_DATA:
    {
      // range is [0..10], currently we support [0..13] at the moment
      if (value > 13)
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_INVAL;
        #else
          tm_return->status = E_INVAL;
        #endif
        break;
      }
      l1_config.tmode.tx_params.burst_data = value;
    #if (ETM_PROTOCOL == 1)
      tm_return->status = -ETM_OK;
    #else
      tm_return->status = E_OK;
    #endif
      break;
    }
  case TX_TRAINING_SEQ:
    {
      if (value > 7)  // [0..7]
      {
        #if (ETM_PROTOCOL == 1)
          tm_return->status = -ETM_INVAL;
        #else
          tm_return->status = E_INVAL;
        #endif
        break;
      }
      l1_config.tmode.tx_params.tsc = value;
    #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_tx_param_read(T_TM_RETURN *tm_return, WORD16 index, UWORD8 band)
{
  volatile UWORD16 value;

  switch (index)
  {
  case TX_PWR_LEVEL:
    {
      value = l1_config.tmode.tx_params.txpwr;
      break;
    }
  case TX_APC_DAC:
    {
      value = rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].apc;
      break;
    }
  case TX_RAMP_TEMPLATE:
    {
      value = rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].ramp_index;
      break;
    }
  case TX_CHAN_CAL_TABLE:
    {
      value = rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].chan_cal_index;
      break;
    }
  case TX_BURST_TYPE:
    {
      value = l1_config.tmode.tx_params.burst_type;
      break;
    }