FreeCalypso > hg > fc-tourmaline

view src/cs/layer1/p_cfile/l1p_func.c @ 78:c632896652ba

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mfw/ti1_key.c: properly initialize notified_keys array The code in this ti1_key.c layer needs to call kpd_subscribe() and kpd_define_key_notification() functions in order to register with the KPD driver. The original code passed KPD_NB_PHYSICAL_KEYS in nb_notified_keys - this constant is defined to 24 in kpd_cfg.h on all platforms of interest to us - but it only filled the first 23 slots in the notified_keys array, resulting in stack garbage being passed to KPD API functions. The fix consists of initializing the last missed array slot to KPD_KEY_RECORD, the key ID for the right side button on the D-Sample handset. On our current hw targets this "Record" button exists as the EXTRA button on our Luna keypad board and as the camera button on the Pirelli DP-L10. There is no support whatsoever for this button in current BMI+MFW, we have no plans of doing anything with Pirelli's camera button even if we do get our UI fw running on that phone, and the Mother's dream of building our own FreeCalypso handset with the same button arrangement as D-Sample (including the right side button) is currently very nebulous - but let us nonetheless handle the full set of buttons on the KPD to MFW interface, and let upper layers weed out unsupported buttons.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 25 Oct 2020 23:41:01 +0000
parents 4e78acac3d88
children
line wrap: on
line source

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

#define  L1P_FUNC_C

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

#if L1_GPRS

#if (CODE_VERSION == SIMULATION)
  #include "stddef.h"
#endif

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


#if TESTMODE
  #include "l1tm_defty.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 "cust_os.h"
#include "l1_msgty.h"
#include "l1_time.h"

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

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

#if (CODE_VERSION == SIMULATION)
  #include "l1_rf2.h"
#endif

/*-------------------------------------------------------*/
/* Prototypes of external functions used in this file.   */
/*-------------------------------------------------------*/

void  l1pddsp_meas_ctrl    (UWORD8 nbmeas, UWORD8 pm_pos);
void l1dtpu_meas           (UWORD16 radio_freq,WORD8 agc,UWORD8  lna_off,
                            UWORD16 win_id,UWORD16 tpu_synchro, UWORD8 adc_active
#if (RF_FAM == 61)
                           ,UWORD8 afc_mode
                            ,UWORD8 if_ctl
#endif
                                            );
WORD8 Cust_get_agc_from_IL (UWORD16 radio_freq, UWORD16 agc_index, UWORD8 table_id);
void  l1ps_macs_init       (void);

/*-------------------------------------------------------*/
/* initialize_l1pvar()                                   */
/*-------------------------------------------------------*/
/* Parameters  :                                         */
/* -------------                                         */
/* Return      :                                         */
/* -------------                                         */
/* Description :                                         */
/* -------------                                         */
/* This routine is used to initialize the l1pa, l1ps and */
/* l1pa_l1ps_com global structures.                      */
/*-------------------------------------------------------*/
void initialize_l1pvar(void)
{
  UWORD8 i;
  
  //++++++++++++++++++++++++++++++++++++++++++
  //  Reset "l1ps" structure.
  //++++++++++++++++++++++++++++++++++++++++++

  l1ps.last_PR_good     = 0;
  l1ps.ILmin_beacon     = 255;
#if 0	/* FreeCalypso TCS211 reconstruction */
  l1ps.read_param.assignment_id = 0xFF; /* do not return non initialized value to RLC */
#endif

  for(i = 0; i < 8; i++)
    l1ps.ILmin_others[i] = l1_config.params.il_min;

  //++++++++++++++++++++++++++++++++++++++++++
  //  Reset "l1pa" structure.
  //++++++++++++++++++++++++++++++++++++++++++

  for(i=0;i<NBR_L1PA_PROCESSES;i++)
  {
    l1pa.state[i]        = 0;
    l1pa.l1pa_en_meas[i] = 0;
  }

  //++++++++++++++++++++++++++++++++++++++++++
  //  Reset "l1pa_l1ps_com" structure.
  //++++++++++++++++++++++++++++++++++++++++++

  // Initialize PC_MEAS_CHAN flag
  l1ps.pc_meas_chan_ctrl = FALSE;

  // Initialize active list used in Neighbour Measurement Transfer Process
  l1pa_l1ps_com.cres_freq_list.alist = &(l1pa_l1ps_com.cres_freq_list.list[0]);

  // Initialize parameters used in Neighbour Measurement Transfer Process
  l1pa_l1ps_com.cres_freq_list.alist->nb_carrier = 0;
  l1pa_l1ps_com.tcr_freq_list.new_list_present = FALSE;

  l1pa_l1ps_com.transfer.semaphore = TRUE;
  l1pa_l1ps_com.transfer.aset      = &(l1pa_l1ps_com.transfer.set[0]);
  l1pa_l1ps_com.transfer.fset[0]   = &(l1pa_l1ps_com.transfer.set[1]);
  l1pa_l1ps_com.transfer.fset[1]   = &(l1pa_l1ps_com.transfer.set[2]);

  // Initialize Downlink Power Control Struture. Set CRC to BAD, bcch_level
  // and burst_level[] to INVALID.
  l1pa_l1ps_com.transfer.dl_pwr_ctrl.crc_error  = TRUE;
  l1pa_l1ps_com.transfer.dl_pwr_ctrl.bcch_level = (WORD8)0x80;//omaps00090550

  for(i = 0; i < 4; i++)
  {
    l1pa_l1ps_com.transfer.dl_pwr_ctrl.burst_level[i] = (WORD8)0x80;//omaps00090550
  }

  l1pa_l1ps_com.transfer.set[0].ul_tbf_alloc = &(l1pa_l1ps_com.transfer.ul_tbf_alloc[0]);
  l1pa_l1ps_com.transfer.set[1].ul_tbf_alloc = &(l1pa_l1ps_com.transfer.ul_tbf_alloc[1]);
  l1pa_l1ps_com.transfer.set[2].ul_tbf_alloc = &(l1pa_l1ps_com.transfer.ul_tbf_alloc[2]);
  
  for(i=0;i<3;i++)
  {
    l1pa_l1ps_com.transfer.set[i].SignalCode                   = 0;
    l1pa_l1ps_com.transfer.set[i].dl_tbf_synchro_timeslot      = 0;
    l1pa_l1ps_com.transfer.set[i].dl_tbf_synchro_timeslot      = 0;
    l1pa_l1ps_com.transfer.set[i].transfer_synchro_timeslot    = 0;
    l1pa_l1ps_com.transfer.set[i].allocated_tbf                = NO_TBF;
    l1pa_l1ps_com.transfer.set[i].assignment_command           = NO_TBF;
    l1pa_l1ps_com.transfer.set[i].multislot_class              = 0;

    l1pa_l1ps_com.transfer.set[i].packet_ta.ta                 = 255;
    l1pa_l1ps_com.transfer.set[i].packet_ta.ta_index           = 255;
    l1pa_l1ps_com.transfer.set[i].packet_ta.ta_tn              = 255;

    l1pa_l1ps_com.transfer.set[i].tsc                          = 0;

    l1pa_l1ps_com.transfer.set[i].freq_param.chan_sel.h        = 0;
    l1pa_l1ps_com.transfer.set[i].freq_param.chan_sel.
                               rf_channel.single_rf.radio_freq = 0;

    l1pa_l1ps_com.transfer.set[i].tbf_sti.present              = FALSE;

    l1pa_l1ps_com.transfer.set[i].mac_mode                     = 0;

    l1pa_l1ps_com.transfer.set[i].ul_tbf_alloc->tfi            = 255;
    l1pa_l1ps_com.transfer.set[i].dl_tbf_alloc.tfi             = 255;

    l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.p0                = 255;
    l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.bts_pwr_ctl_mode  = 0;
    l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.pr_mode           = 0;
  }

  //++++++++++++++++++++++++++++++++++++++++++
  //  Reset "l1pa_macs_com" structure.
  //++++++++++++++++++++++++++++++++++++++++++

  l1ps_macs_com.fix_alloc_exhaust_flag = FALSE;
  l1ps_macs_com.rlc_downlink_call      = FALSE;
  #if FF_L1_IT_DSP_USF
    l1ps_macs_com.usf_status           = USF_AVAILABLE;
  #endif
  #if L1_EDA
    l1ps_macs_com.fb_sb_task_enabled   = FALSE;
    l1ps_macs_com.fb_sb_task_detect    = FALSE;
  #endif

  //++++++++++++++++++++++++++++++++++++++++++
  //  Reset MAC-S static structure.
  //++++++++++++++++++++++++++++++++++++++++++
  l1ps_macs_init();

  //++++++++++++++++++++++++++++++++++++++++++
  //  Reset packet transfer mode commands.
  //++++++++++++++++++++++++++++++++++++++++++

  l1pa_l1ps_com.transfer.ptcch.ta_update_cmd                 = FALSE;
  l1pa_l1ps_com.transfer.psi_param.psi_param_update_cmd      = FALSE;
  l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd   = FALSE;
  l1pa_l1ps_com.transfer.pdch_release_param.pdch_release_cmd = FALSE;
  l1pa_l1ps_com.transfer.repeat_alloc.repeat_allocation      = FALSE;
}

/*-------------------------------------------------------*/
/* l1ps_reset_db_mcu_to_dsp()                            */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality :                                       */
/*-------------------------------------------------------*/
void l1ps_reset_db_mcu_to_dsp(T_DB_MCU_TO_DSP_GPRS *page_ptr)
{
  API i;
  API size = sizeof(T_DB_MCU_TO_DSP_GPRS) / sizeof(API);
  API *ptr = (API *)page_ptr;

  // Clear all locations.
  for(i=0; i<size; i++) *ptr++ = 0;
} 
 
/*-------------------------------------------------------*/
/* l1ps_reset_db_dsp_to_mcu()                            */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality :                                       */
/*-------------------------------------------------------*/
void l1ps_reset_db_dsp_to_mcu(T_DB_DSP_TO_MCU *page_ptr)
{
  API i;
  API size = sizeof(T_DB_DSP_TO_MCU_GPRS) / sizeof(API);
  API *ptr = (API *)page_ptr;
 
  // Clear all locations.
  for(i=0; i<size; i++) *ptr++ = 0;
  
  // Set crc result as "SB not found".
  page_ptr->a_sch[0]  =  (1<<B_SCH_CRC);   // B_SCH_CRC =1, BLUD =0
}  

/*-------------------------------------------------------*/
/* l1ps_swap_iq_dl()                                     */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality :                                       */
/*-------------------------------------------------------*/
BOOL l1ps_swap_iq_dl(UWORD16 radio_freq)
{ 
  UWORD8   swap_iq;
  BOOL     swap_flag;

#if (L1_FF_MULTIBAND == 0)
  
  if(((l1_config.std.id == DUAL) || (l1_config.std.id == DUALEXT) || (l1_config.std.id == DUAL_US)) && 
     (radio_freq >= l1_config.std.first_radio_freq_band2)) 
  {
    swap_iq = l1_config.std.swap_iq_band2;
  }
  else
  {  
    swap_iq = l1_config.std.swap_iq_band1;
  }
  
#else // L1_FF_MULTIBAND = 1 below

  UWORD16 physical_band_id;
  physical_band_id = 
    l1_multiband_radio_freq_convert_into_physical_band_id(radio_freq);
  swap_iq = rf_band[physical_band_id].swap_iq;
  
#endif // #if (L1_FF_MULTIBAND == 0) else
  

  switch(swap_iq)
  {
    case 0:  /* No swap at all. */
    case 2:  /* DL, no swap.    */
      swap_flag = FALSE;
    break;
    case 1:  /* DL I/Q swap.    */
    case 3:  /* DL I/Q swap.    */
      swap_flag = TRUE;
    break;
  }
  return(swap_flag);
}

/*-------------------------------------------------------*/
/* l1ps_swap_iq_ul()                                     */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality :                                       */
/*-------------------------------------------------------*/
BOOL l1ps_swap_iq_ul(UWORD16 radio_freq)
{ 
  UWORD8   swap_iq;
  BOOL     swap_flag;

#if (L1_FF_MULTIBAND == 0)

  if(((l1_config.std.id == DUAL) || (l1_config.std.id == DUALEXT) || (l1_config.std.id == DUAL_US)) && 
     (radio_freq >= l1_config.std.first_radio_freq_band2)) 
  {
    swap_iq = l1_config.std.swap_iq_band2;
  }
  else
  {
    swap_iq = l1_config.std.swap_iq_band1;
  }
  
#else // L1_FF_MULTIBAND = 1 below

 UWORD16 physical_band_id = 0;
  physical_band_id = 
    l1_multiband_radio_freq_convert_into_physical_band_id(radio_freq);
  swap_iq = rf_band[physical_band_id].swap_iq;
  
#endif // #if (L1_FF_MULTIBAND == 0) else
  
  switch(swap_iq)
  {
    case 0: /* No swap at all. */
    case 1: /* UL, no swap.    */
      swap_flag = FALSE;
    break;
    case 2: /* UL I/Q swap.    */
    case 3: /* UL I/Q swap.    */
      swap_flag = TRUE;
    break;
  }
  return(swap_flag);
}

/*-------------------------------------------------------*/
/* l1ps_tcr_ctrl()                                       */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality :                                       */
/*-------------------------------------------------------*/
void l1ps_tcr_ctrl(UWORD8 pm_position)
{
  UWORD16  radio_freq_ctrl;
  UWORD8   lna_off;
  WORD8    agc;
  
  UWORD8   mode = PACKET_TRANSFER;
  UWORD8 input_level;
  #if (RF_FAM == 61)
    UWORD16 dco_algo_ctl_pw = 0;
    UWORD8 if_ctl = 0;
    UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GSM;
  #endif

  radio_freq_ctrl = l1pa_l1ps_com.cres_freq_list.alist->freq_list[l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl];

  // Get AGC according to the last known IL.

  input_level = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].input_level;
  agc     = Cust_get_agc_from_IL(radio_freq_ctrl, input_level >> 1, PWR_ID);
  lna_off = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].lna_off;

   #if (RF_FAM == 61) // Locosto DCO
      #if (PWMEAS_IF_MODE_FORCE == 0)        
        cust_get_if_dco_ctl_algo(&dco_algo_ctl_pw, &if_ctl, (UWORD8) L1_IL_VALID , 
            input_level,
            l1pa_l1ps_com.p_idle_param.radio_freq, if_threshold);
      #else     
        if_ctl = IF_120KHZ_DSP;
        dco_algo_ctl_pw = DCO_IF_0KHZ;    
      #endif  
   	 

      l1ddsp_load_dco_ctl_algo_pw(dco_algo_ctl_pw);
      l1s.tcr_prog_done=1;
   #endif

  // Memorize the IL and LNA used for AGC setting.
  l1pa_l1ps_com.tcr_freq_list.used_il_lna.il  = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].input_level;
  l1pa_l1ps_com.tcr_freq_list.used_il_lna.lna = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].lna_off;

  // tpu pgm: 1 measurement only.
  l1dtpu_meas(radio_freq_ctrl,
              agc,
              lna_off,
              l1s.tpu_win,
              l1s.tpu_offset,INACTIVE
#if(RF_FAM == 61)
            ,L1_AFC_SCRIPT_MODE
            ,if_ctl
#endif
  );

  // Increment tpu window identifier.
  l1s.tpu_win += (l1_config.params.rx_synth_load_split + PWR_LOAD);

  // increment carrier counter for next measurement...
  if(++l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl >= l1pa_l1ps_com.cres_freq_list.alist->nb_carrier) 
    l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl = 0;

  // Program DSP, in order to performed 1 measure.
  // Second argument specifies PW position.
  l1pddsp_meas_ctrl(1, pm_position);

  #if (TRACE_TYPE!=0) 
    //trace_fct(CST_CTRL_TRANSFER_MEAS, radio_freq_ctrl);
  #endif

  // Update d_debug timer
  l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ;


  // Flag measurement control.
  // **************************

  // Set flag "ms_ctrl" to nb_meas_to_perform.
  // It will be used as 2 tdma delayed to trigger Read phase.
  l1pa_l1ps_com.tcr_freq_list.ms_ctrl = 1;

  // Flag DSP and TPU programmation.
  // ********************************

  // Set "CTRL_MS" flag in the controle flag register.
  l1s.tpu_ctrl_reg |= CTRL_MS;
  l1s.dsp_ctrl_reg |= CTRL_MS;

}

/*-------------------------------------------------------*/
/* l1ps_bcch_meas_ctrl()                                 */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality :                                       */
/*-------------------------------------------------------*/
void l1ps_bcch_meas_ctrl(UWORD8 ts)
{
  UWORD8   lna_off;
  WORD8    agc;

  UWORD8   mode = PACKET_TRANSFER;
  UWORD8 input_level;
  #if (RF_FAM == 61)
    UWORD16 dco_algo_ctl_pw =0;
    UWORD8 if_ctl=0;
    UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GSM;
  #endif
 

  if ((l1s.dsp_ctrl_reg & CTRL_ABORT) == 0)
  {
    #define radio_freq_ctrl l1a_l1s_com.Scell_info.radio_freq

    // Get AGC according to the last known IL.
    input_level = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].input_level;
    agc     = Cust_get_agc_from_IL(radio_freq_ctrl, input_level >> 1, PWR_ID);
    lna_off = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].lna_off;
    // Memorize the IL and LNA used for AGC setting.
    // Note: the same structure as for TCR meas is used for PC_MEAS_CHAN measurements
    l1pa_l1ps_com.tcr_freq_list.used_il_lna.il  = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].input_level;
    l1pa_l1ps_com.tcr_freq_list.used_il_lna.lna = l1a_l1s_com.last_input_level[radio_freq_ctrl - l1_config.std.radio_freq_index_offset].lna_off;


   #if (RF_FAM == 61) // Locosto DCO
      cust_get_if_dco_ctl_algo(&dco_algo_ctl_pw, &if_ctl, (UWORD8) L1_IL_VALID, 
                                             input_level,
                                             radio_freq_ctrl,if_threshold);
   
      l1ddsp_load_dco_ctl_algo_pw(dco_algo_ctl_pw);
   #endif


    // tpu pgm: 1 measurement only.
    l1dtpu_meas(radio_freq_ctrl,
                agc,
                lna_off,
                l1s.tpu_win,
                l1s.tpu_offset,INACTIVE
#if(RF_FAM == 61)
                  ,L1_AFC_SCRIPT_MODE
                  ,if_ctl
#endif
	                );

    // Increment tpu window identifier.
    l1s.tpu_win += (l1_config.params.rx_synth_load_split + PWR_LOAD);

    // Program DSP, in order to performed 1 measure.
    // Second argument specifies PW position.
    l1pddsp_meas_ctrl(1, (UWORD8)ts);

    #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5)
      //trace_fct(CST_CTRL_SCELL_TRANSFER_MEAS, radio_freq_ctrl);
    #endif

    // Update d_debug timer
    l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ;


    // Flag measurement control.
    // **************************

    l1ps.pc_meas_chan_ctrl = TRUE;

    // Flag DSP and TPU programmation.
    // ********************************

    // Set "CTRL_MS" flag in the controle flag register.
    l1s.tpu_ctrl_reg |= CTRL_MS;
    l1s.dsp_ctrl_reg |= CTRL_MS;
  }
}

/*-------------------------------------------------------*/
/* l1ps_update_read_set_parameters()                     */
/*-------------------------------------------------------*/
/* Parameters :                                          */
/* Return     :                                          */
/* Functionality : Updating of the "Read_param" structure*/
/*   usefull in case the aset structure has been updated */
/*   before the last read of the current block           */
/*-------------------------------------------------------*/
void l1ps_update_read_set_parameters(void)
{
  #define READ_PARAM l1ps.read_param
  #define ASET       l1pa_l1ps_com.transfer.aset 

  // Copy of the "aset" parameters in the "read_param" structure
#if 0	/* FreeCalypso TCS211 reconstruction */
  READ_PARAM.dl_tn         = l1a_l1s_com.dl_tn;
#endif
  READ_PARAM.new_set       = 0;
  READ_PARAM.assignment_id = ASET->assignment_id;
  READ_PARAM.allocated_tbf = ASET->allocated_tbf;
  READ_PARAM.dl_tfi        = ASET->dl_tbf_alloc.tfi;
  READ_PARAM.ul_tfi        = ASET->ul_tbf_alloc->tfi;
  READ_PARAM.dl_pwr_ctl    = ASET->dl_pwr_ctl;
  READ_PARAM.pc_meas_chan  = ASET->pc_meas_chan;

  // We need to know on which frequency band we work for LNA state processing
  if (!l1pa_l1ps_com.transfer.aset->freq_param.chan_sel.h)
  {
    // Single frequency
    READ_PARAM.radio_freq_for_lna = l1pa_l1ps_com.transfer.aset->freq_param.chan_sel.rf_channel.single_rf.radio_freq;
  }
  else
  {
    // Frequency hopping: all frequencies of the frequency list are on the same band
    // We take the first frequency of the list
    READ_PARAM.radio_freq_for_lna = l1pa_l1ps_com.transfer.aset->freq_param.freq_list.rf_chan_no.A[0];
  }
}
#endif