l1tm_cust.c

是一个手机功能的模拟程序

      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;
      tm_return->status = E_NOSUBSYS;
      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:
    {
      tm_return->size = 32; //16*UWORD16
      memcpy(tm_return->result, &TM_ul_data[0], tm_return->size);
      break;

    }
    #if (RF==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;
      tm_return->status = E_BADINDEX;
      return;
    }
  }  // end switch

  tm_return->index  = index;
  tm_return->status = E_OK;
}

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;

      tm_return->status = E_OK;
      break;
    }
    default:
    {
      tm_return->status = E_BADINDEX;
      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:
    {
      tm_return->status = E_BADINDEX;
      tm_return->size = 0;
      return;
    }
  } // end switch

  memcpy(tm_return->result, (UWORD8 *)&value, 2);
  tm_return->size = 2;
  tm_return->status = E_OK;
}

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;

      tm_return->status = E_OK;
      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]
      {
        tm_return->status = E_INVAL;
        break;
      }

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

      tm_return->status = E_OK;
      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]))
      {
        tm_return->status = E_INVAL;
        break;
      }

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

        tm_return->status = E_OK;
      
      break;
      }
    case TX_BURST_TYPE:
      {
      if (value > 1)  // [0..1]
      {
        tm_return->status = E_INVAL;
        break;
      }
      l1_config.tmode.tx_params.burst_type = value;
      tm_return->status = E_OK;
      break;
    }
    case TX_BURST_DATA:
    {
      // range is [0..10], but we only support [0..2] and [5..13] at the moment
      if ((value > 2 && value < 5) || (value > 13))
      {
        tm_return->status = E_INVAL;
        break;
      }
      l1_config.tmode.tx_params.burst_data = value;
      tm_return->status = E_OK;
      break;
    }
    case TX_TRAINING_SEQ:
    {
      if (value > 7)  // [0..7]
      {
        tm_return->status = E_INVAL;
        break;
      }
      l1_config.tmode.tx_params.tsc = value;
      tm_return->status = E_OK;
      break;
    }
    default:
    {
      tm_return->status = E_BADINDEX;
      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;
    }
    case TX_BURST_DATA:
    {
      value = l1_config.tmode.tx_params.burst_data;
      break;
    }
    case TX_TIMING_ADVANCE:
    {
      value = l1_config.tmode.tx_params.timing_advance;
      break;
    }
    case TX_TRAINING_SEQ:
    {
      value = l1_config.tmode.tx_params.tsc;
      break;
    }
    case TX_PWR_SKIP:
    {
     value = l1_config.tmode.tx_params.txpwr_skip;
     break;
    }
    #if L1_GPRS
      case TX_GPRS_POWER0:
      case TX_GPRS_POWER1:
      case TX_GPRS_POWER2:
      case TX_GPRS_POWER3:
      case TX_GPRS_POWER4:
      case TX_GPRS_POWER5:
      case TX_GPRS_POWER6:
      case TX_GPRS_POWER7:
      {
        value = l1_config.tmode.tx_params.txpwr_gprs[index - TX_GPRS_POWER0];
        break;
      }
      case TX_GPRS_SLOTS:
      {
        value = l1_config.tmode.tx_params.timeslot_alloc;
        break;
      }
      case TX_GPRS_CODING:
      {
        value = l1_config.tmode.tx_params.coding_scheme;
        break;
      }
    #endif
    default:
    {
      tm_return->status = E_BADINDEX;
      tm_return->size = 0;
      return;
    }
  } // end switch

  memcpy(tm_return->result, (UWORD8 *)&value, 2);
  tm_return->size = 2;
  tm_return->status = E_OK;
}

void Cust_tm_tx_template_write(T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[])
{
  if (index >= sizeof(rf_band[tm_band].tx.ramp_tables)/sizeof(T_TX_RAMP))
  {
    tm_return->status = E_BADINDEX;
  }
  else if (size != sizeof(T_TX_RAMP))
  {
    // We are writing both the up and down ramps; size must be exact.
    tm_return->status = E_BADSIZE;
  }
  else
  {
    memcpy(rf_band[tm_band].tx.ramp_tables[index].ramp_up, &table[0], size/2);
    memcpy(rf_band[tm_band].tx.ramp_tables[index].ramp_down, &table[size/2], size/2);
    tm_return->status = E_OK;
    l1_config.tmode.rf_params.reload_ramps_flag = 1;
  }

  tm_return->index = index;
  tm_return->size = 0;
}

void Cust_tm_tx_template_read(T_TM_RETURN *tm_return, WORD8 index)
{
  tm_return->index = index;

  if (index >= sizeof(rf_band[tm_band].tx.ramp_tables)/sizeof(T_TX_RAMP))
  {
    tm_return->status = E_BADINDEX;
    tm_return->size = 0;
    return;
  }
   
  memcpy(&tm_return->result[0], rf_band[tm_band].tx.ramp_tables[index].ramp_up, sizeof(rf_band[tm_band].tx.ramp_tables[index].ramp_up));
  memcpy(&tm_return->result[sizeof(rf_band[tm_band].tx.ramp_tables[index].ramp_up)], rf_band[tm_band].tx.ramp_tables[index].ramp_down, sizeof(rf_band[tm_band].tx.ramp_tables[index].ramp_down));
  tm_return->size = sizeof(rf_band[tm_band].tx.ramp_tables[index]);
  tm_return->status = E_OK;
}

void Cust_tm_misc_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value)
{
  switch (index)
  {
    case GPIOSTATE0:
    case GPIODIR0:
    case GPIOSTATE1:
    case GPIODIR1:
    case GPIOSTATE0P:
    case GPIODIR0P:
    case GPIOSTATE1P:
    case GPIODIR1P:
    {
      tm_return->status = E_NOSUBSYS;
      break;
    }
    case CONVERTED_ADC0:
    case CONVERTED_ADC1:
    case CONVERTED_ADC2:
    case CONVERTED_ADC3:
    case CONVERTED_ADC4:
    case CONVERTED_ADC5:
    case CONVERTED_ADC6:
    case CONVERTED_ADC7:
    case CONVERTED_ADC8:
    {
      adc.converted[index - CONVERTED_ADC0] = value;
      tm_return->status = E_OK;
      break;
    }
    
    case RAW_ADC0:
    case RAW_ADC1:
    case RAW_ADC2:
    case RAW_ADC3:
    case RAW_ADC4:
    case RAW_ADC5:
    case RAW_ADC6:
    case RAW_ADC7:
    case RAW_ADC8:
    {
      adc.raw[index - RAW_ADC0]  = value;
      tm_return->status = E_OK;
      break;
    }
    
    case ADC0_COEFF_A:
    case ADC1_COEFF_A:
    case ADC2_COEFF_A:
    case ADC3_COEFF_A:
    case ADC4_COEFF_A:
    case ADC5_COEFF_A:
    case ADC6_COEFF_A:
    case ADC7_COEFF_A:
    case ADC8_COEFF_A:
    {
      adc_cal.a[index - ADC0_COEFF_A]  = value;
      tm_return->status = E_OK;
      break;
    }
    
    case ADC0_COEFF_B:
    case ADC1_COEFF_B:
    case ADC2_COEFF_B:
    case ADC3_COEFF_B:
    case ADC4_COEFF_B:
    case ADC5_COEFF_B:
    case ADC6_COEFF_B:
    case ADC7_COEFF_B:
    case ADC8_COEFF_B:
    {
      adc_cal.b[index - ADC0_COEFF_B]  = value;
      tm_return->status = E_OK;
      break;
    }
    case SLEEP_MODE:
    {
      power_down_config((UWORD8)value, UWIRE_CLK_CUT); //glowing,2004-6-17, import from M188
      tm_return->status = E_NOSUBSYS;
      break;
	}
    default:
    {
      tm_return->status = E_BADINDEX;
      break;
    }
  } // end switch
}

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

  switch (index)
  {
    case GPIOSTATE0:
    case GPIODIR0:
    case GPIOSTATE1:
    case GPIODIR1:
    case GPIOSTATE0P:
    case GPIODIR0P:
    case GPIOSTATE1P:
    case GPIODIR1P:
    {
      tm_return->status = E_NOSUBSYS;
      tm_return->size = 0;
      return;
    }
    case CONVERTED_ADC0:
    case CONVERTED_ADC1:
    case CONVERTED_ADC2:
    case CONVERTED_ADC3:
    case CONVERTED_ADC4:
    case CONVERTED_ADC5:
    case CONVERTED_ADC6:
    case CONVERTED_ADC7:
    case CONVERTED_ADC8:
    {
      value = adc.converted[index - CONVERTED_ADC0];
      break;
    }
    case RAW_ADC0:
    case RAW_ADC1:
    case RAW_ADC2:
    case RAW_ADC3:
    case RAW_ADC4:
    case RAW_ADC5:
    case RAW_ADC6:
    case RAW_ADC7:
    case RAW_ADC8:
    {
      value = adc.raw[index - RAW_ADC0];
      break;
    }
    case ADC0_COEFF_A:
    case ADC1_COEFF_A:
    case ADC2_COEFF_A:
    case ADC3_COEFF_A:
    case ADC4_COEFF_A:
    case ADC5_COEFF_A:
    case ADC6_COEFF_A:
    case ADC7_COEFF_A:
    case ADC8_COEFF_A:
    {
      value = adc_cal.a[index - ADC0_COEFF_A];
      break;
    }
    case ADC0_COEFF_B:
    case ADC1_COEFF_B:
    case ADC2_COEFF_B:
    case ADC3_COEFF_B:
    case ADC4_COEFF_B:
    case ADC5_COEFF_B:
    case ADC6_COEFF_B:
    case ADC7_COEFF_B:
    case ADC8_COEFF_B:
    {
      value = adc_cal.b[index - ADC0_COEFF_B];
      break;
    }
    case SLEEP_MODE:
    {
      tm_return->status = E_NOSUBSYS;
      tm_return->size = 0;
      return;
    }
    default:
    {
      tm_return->status = E_BADINDEX;
      tm_return->size = 0;
      return;
    }
  } // end switch

  memcpy(tm_return->result, (UWORD8 *)&value, 2);
  tm_return->size = 2;
  tm_return->status = E_OK;
}

void Cust_tm_misc_enable(T_TM_RETURN *tm_return, WORD16 action)
{
    UWORD8 status;
  
    // FIXME: This enum really should go into testmode header file.
    enum ME_CFG_WRITE_E {
        CFG_WRITE_MKDIRS   = 100,
        CFG_WRITE_RF_CAL   = 102,
        CFG_WRITE_RF_CFG   = 103,
        CFG_WRITE_TX_CAL   = 104,
        CFG_WRITE_TX_CFG   = 105,
        CFG_WRITE_RX_CAL   = 106,
        CFG_WRITE_RX_CFG   = 107,
        CFG_WRITE_SYS_CAL  = 108,
        CFG_WRITE_SYS_CFG  = 109
  };

  tm_return->size = 0;
  tm_return->index = action;
  tm_return->status = E_OK;

    // FIXME: This code should actually be in misc_enable()
  switch(action)
  {
    case CFG_WRITE_MKDIRS:
        ffs_mkdir("/gsm");
        ffs_mkdir("/pcm");
        ffs_mkdir("/sys");
        ffs_mkdir("/mmi");
        ffs_mkdir("/vos");
        ffs_mkdir("/var");
        ffs_mkdir("/gsm/rf");
        ffs_mkdir("/gsm/com");
        ffs_mkdir("/vos/vm");
        ffs_mkdir("/vos/vrm");
        ffs_mkdir("/vos/vrp");
        ffs_mkdir("/var/log");
        ffs_mkdir("/var/tst");
        ffs_mkdir("/gsm/rf/tx");
        ffs_mkdir("/gsm/rf/rx");
      break;
    case CFG_WRITE_RF_CAL:   config_ffs_write('f'); break;