FreeCalypso > hg > freecalypso-citrine

comparison L1/cust0/l1_cust.c @ 19:12f6c51be7b3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
l1_cust.c: TCS211 reconstruction changes applied
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 10 Jun 2016 07:53:54 +0000
parents 75a11d740a02
children
comparison
equal deleted inserted replaced
18:a872b92dcd3c 19:12f6c51be7b3
271 /*-------------------------------------------------------*/ 271 /*-------------------------------------------------------*/
272 272
273 UWORD8 Cust_recover_Os(void) 273 UWORD8 Cust_recover_Os(void)
274 { 274 {
275 #if (CODE_VERSION != SIMULATION) 275 #if (CODE_VERSION != SIMULATION)
276 if (l1_config.pwr_mngt == PWR_MNGT)
277 {
278 UWORD32 current_system_clock; 276 UWORD32 current_system_clock;
279 277
280 /***************************************************/ 278 /***************************************************/
281 // Fix System clock and Nucleus Timers if any.... */ 279 // Fix System clock and Nucleus Timers if any.... */
282 /***************************************************/ 280 /***************************************************/
298 //............. 296 //.............
299 //............. 297 //.............
300 //.............. 298 //..............
301 return(TRUE); 299 return(TRUE);
302 300
303 } 301 #endif
304 #endif
305 return(TRUE); //omaps00090550
306 } 302 }
307 303
308 304
309 305
310 /*-------------------------------------------------------*/ 306 /*-------------------------------------------------------*/
327 /* ------- */ 323 /* ------- */
328 /* DO_NOT_SLEEP, FRAME_STOP or CLOCK_STOP */ 324 /* DO_NOT_SLEEP, FRAME_STOP or CLOCK_STOP */
329 /*-------------------------------------------------------*/ 325 /*-------------------------------------------------------*/
330 UWORD8 Cust_check_system(void) 326 UWORD8 Cust_check_system(void)
331 { 327 {
328 extern UWORD8 why_big_sleep;
332 329
333 #if (CODE_VERSION != SIMULATION) 330 #if (CODE_VERSION != SIMULATION)
334 if (l1_config.pwr_mngt == PWR_MNGT) 331 /* FreeCalypso change: this LT_Status() function is defunct */
332 #if 0
333 // Forbid deep sleep if the light is on
334 if(LT_Status())
335 { 335 {
336 336 //cut ARMIO and UWIRE clocks in big sleep
337 #if (L2_L3_SIMUL == 0) 337 l1s.pw_mgr.modules_status = ARMIO_CLK_CUT | UWIRE_CLK_CUT ;
338 // Forbid deep sleep if the light is on 338 why_big_sleep = BIG_SLEEP_DUE_TO_LIGHT_ON;
339 /* FreeCalypso change: this LT_Status() function is defunct */ 339 return(FRAME_STOP); // BIG sleep
340 #if 0 340 }
341 if(LT_Status()) 341 #endif
342
343 // Forbid deep sleep if the SIM and UARTs not ready
344 #if CONFIG_INCLUDE_SIM
345 if(SIM_SleepStatus())
346 #endif
347 {
348 if(SER_UartSleepStatus())
342 { 349 {
343 //cut ARMIO and UWIRE clocks in big sleep 350 return(CLOCK_STOP); // DEEP sleep
344 l1s.pw_mgr.modules_status = ARMIO_CLK_CUT | UWIRE_CLK_CUT ;
345 l1s.pw_mgr.why_big_sleep = BIG_SLEEP_DUE_TO_LIGHT_ON;
346 return(FRAME_STOP); // BIG sleep
347 } 351 }
348 #endif 352 else why_big_sleep = BIG_SLEEP_DUE_TO_UART;
349
350 #if (OP_L1_STANDALONE == 0)
351 // Forbid deep sleep if the camera is working
352 /* FreeCalypso change: no camera */
353 #if 0
354 if(!cama_sleep_status())
355 {
356 l1s.pw_mgr.why_big_sleep = BIG_SLEEP_DUE_TO_CAMERA;
357 return(FRAME_STOP); // BIG sleep
358 }
359 #endif
360
361 // Forbid deep sleep if the SIM and UARTs not ready
362 // FC note: this call to SIM_SleepStatus() *is* present in the Leonardo object
363 #if CONFIG_INCLUDE_SIM //(REQUIRED_FOR_ESAMPLE_LOCOSTO)
364 // Forbid deep sleep if the SIM and UARTs not ready
365 if(SIM_SleepStatus())
366 #endif
367 {
368 #endif
369 #endif
370 if(SER_UartSleepStatus())
371 {
372 return(CLOCK_STOP); // DEEP sleep
373 }
374 else l1s.pw_mgr.why_big_sleep = BIG_SLEEP_DUE_TO_UART;
375 #if (L2_L3_SIMUL == 0)
376 #if (OP_L1_STANDALONE == 0)
377 }
378 // Forbid deep sleep if the SIM and UARTs not ready
379 #if CONFIG_INCLUDE_SIM //(REQUIRED_FOR_ESAMPLE_LOCOSTO)
380 else l1s.pw_mgr.why_big_sleep = BIG_SLEEP_DUE_TO_SIM;
381 #endif
382 #endif
383 #endif
384 // cut ARMIO and UWIRE clocks in big sleep
385 l1s.pw_mgr.modules_status = ARMIO_CLK_CUT | UWIRE_CLK_CUT ;
386 return(FRAME_STOP); // BIG sleep
387 } 353 }
354 #if CONFIG_INCLUDE_SIM
355 else why_big_sleep = BIG_SLEEP_DUE_TO_SIM;
356 #endif
357
358 // cut ARMIO and UWIRE clocks in big sleep
359 l1s.pw_mgr.modules_status = ARMIO_CLK_CUT | UWIRE_CLK_CUT ;
360 return(FRAME_STOP); // BIG sleep
388 #else // Simulation part 361 #else // Simulation part
389 return(CLOCK_STOP); // DEEP sleep 362 return(CLOCK_STOP); // DEEP sleep
390 #endif 363 #endif
391 return(CLOCK_STOP); // omaps00090550
392 } 364 }
393 #endif /* !RUN_FLASH */ 365 #endif /* !RUN_FLASH */
394 366
395 #ifndef RUN_INT_RAM 367 #ifndef RUN_INT_RAM
396 /*-------------------------------------------------------*/ 368 /*-------------------------------------------------------*/
519 const T_CONFIG_FILE *f1 = config_files_band; 491 const T_CONFIG_FILE *f1 = config_files_band;
520 UWORD8 i; 492 UWORD8 i;
521 WORD32 offset; 493 WORD32 offset;
522 char name[64]; 494 char name[64];
523 char *p; 495 char *p;
524 #if (L1_FF_MULTIBAND == 0)
525 UWORD8 std = l1_config.std.id; 496 UWORD8 std = l1_config.std.id;
526 #endif
527 497
528 #if FFS_WORKAROUND == 1 498 #if FFS_WORKAROUND == 1
529 struct stat_s stat; 499 struct stat_s stat;
530 UWORD16 time; 500 UWORD16 time;
531 #endif 501 #endif
532 #if (L1_FF_MULTIBAND == 0)
533 for (i=0; i< GSM_BANDS; i++) 502 for (i=0; i< GSM_BANDS; i++)
534 { 503 {
535 if(std_config[std].band[i] !=0 ) 504 if(std_config[std].band[i] !=0 )
536 { 505 {
537 #else
538 for (i = 0; i < RF_NB_SUPPORTED_BANDS; i++)
539 {
540 #endif /*if (L1_FF_MULTIBAND == 0) */
541 f1 = &config_files_band[0]; 506 f1 = &config_files_band[0];
542 while (f1->name != NULL) 507 while (f1->name != NULL)
543 { 508 {
544 offset = (WORD32) f1->addr - (WORD32) &rf_band[0]; //offset in bytes 509 offset = (WORD32) f1->addr - (WORD32) &rf_band[0]; //offset in bytes
545 p = ((char *) &rf_band[i]) + offset; 510 p = ((char *) &rf_band[i]) + offset;
546 if (type == '*' || type == f1->name[0]) 511 if (type == '*' || type == f1->name[0])
547 { 512 {
548 strcpy(name, &f1->name[1]); 513 strcpy(name, &f1->name[1]);
549 strcat(name, "."); 514 strcat(name, ".");
550 #if (L1_FF_MULTIBAND == 0)
551 strcat(name, band_config[std_config[std].band[i]].name); 515 strcat(name, band_config[std_config[std].band[i]].name);
552 #else
553 strcat(name, multiband_rf[i].name);
554 #endif /*if (L1_FF_MULTIBAND == 0)*/
555 516
556 if (read == 1) 517 if (read == 1)
557 cal_fread(name, p, f1->size); 518 cal_fread(name, p, f1->size);
558 else //write == 0 519 else //write == 0
559 { 520 {
573 } 534 }
574 } 535 }
575 f1++; 536 f1++;
576 } 537 }
577 } 538 }
578 #if (L1_FF_MULTIBAND == 0) 539 }
579 }
580 #endif
581 } 540 }
582 541
583 542
584 /*-------------------------------------------------------*/ 543 /*-------------------------------------------------------*/
585 /* Cust_init_std() */ 544 /* Cust_init_std() */
587 /* Parameters : */ 546 /* Parameters : */
588 /* Return : */ 547 /* Return : */
589 /* Functionality : Init Standard variable configuration */ 548 /* Functionality : Init Standard variable configuration */
590 /*-------------------------------------------------------*/ 549 /*-------------------------------------------------------*/
591 void Cust_init_std(void) 550 void Cust_init_std(void)
592 #if (L1_FF_MULTIBAND == 0)
593 { 551 {
594 UWORD8 std = l1_config.std.id; 552 UWORD8 std = l1_config.std.id;
595 UWORD8 band1, band2; 553 UWORD8 band1, band2;
596 T_RF_BAND *pt1, *pt2; 554 T_RF_BAND *pt1, *pt2;
597 555
649 l1_config.std.radio_band_support = rf.radio_band_support; 607 l1_config.std.radio_band_support = rf.radio_band_support;
650 608
651 //TBD: DRP Calib: Currently the Calib Data are only used for the routines, TBD add to l1_config. from saved Calibration 609 //TBD: DRP Calib: Currently the Calib Data are only used for the routines, TBD add to l1_config. from saved Calibration
652 // on a need basis ? 610 // on a need basis ?
653 } 611 }
654 #else
655 {
656 UWORD8 i;
657
658 for (i = 0; i < RF_NB_SUPPORTED_BANDS; i++)
659 {
660 switch(multiband_rf[i].gsm_band_identifier)
661 {
662 case RF_GSM900:
663 rf_band[i]=rf_900;
664 break;
665 case RF_GSM850:
666 rf_band[i]=rf_850;
667 break;
668 case RF_DCS1800:
669 rf_band[i]=rf_1800;
670 break;
671 case RF_PCS1900:
672 rf_band[i]=rf_1900;
673 break;
674 default:
675 break;
676 }
677 }
678 config_ffs_read('*');
679 }
680 #endif // if (L1_FF_MULTIBAND == 0)
681 612
682 613
683 /*-------------------------------------------------------*/ 614 /*-------------------------------------------------------*/
684 /* Cust_init_params() */ 615 /* Cust_init_params() */
685 /*-------------------------------------------------------*/ 616 /*-------------------------------------------------------*/
769 l1_config.params.il_min = IL_MIN; 700 l1_config.params.il_min = IL_MIN;
770 701
771 l1_config.params.fixed_txpwr = FIXED_TXPWR; 702 l1_config.params.fixed_txpwr = FIXED_TXPWR;
772 l1_config.params.eeprom_afc = rf.afc.eeprom_afc; 703 l1_config.params.eeprom_afc = rf.afc.eeprom_afc;
773 l1_config.params.setup_afc_and_rf = SETUP_AFC_AND_RF; 704 l1_config.params.setup_afc_and_rf = SETUP_AFC_AND_RF;
774 l1_config.params.rf_wakeup_tpu_scenario_duration = l1_config.params.setup_afc_and_rf + 1; //directly dependent of l1dmacro_RF_wakeup implementation
775 705
776 l1_config.params.psi_sta_inv = rf.afc.psi_sta_inv; 706 l1_config.params.psi_sta_inv = rf.afc.psi_sta_inv;
777 l1_config.params.psi_st = rf.afc.psi_st; 707 l1_config.params.psi_st = rf.afc.psi_st;
778 l1_config.params.psi_st_32 = rf.afc.psi_st_32; 708 l1_config.params.psi_st_32 = rf.afc.psi_st_32;
779 l1_config.params.psi_st_inv = rf.afc.psi_st_inv; 709 l1_config.params.psi_st_inv = rf.afc.psi_st_inv;
785 #else 715 #else
786 #if (VCXO_ALGO == 1) 716 #if (VCXO_ALGO == 1)
787 l1_config.params.afc_dac_center = rf.afc.dac_center; // VCXO - assuming DAC linearity 717 l1_config.params.afc_dac_center = rf.afc.dac_center; // VCXO - assuming DAC linearity
788 l1_config.params.afc_dac_min = rf.afc.dac_min; // VCXO - assuming DAC linearity 718 l1_config.params.afc_dac_min = rf.afc.dac_min; // VCXO - assuming DAC linearity
789 l1_config.params.afc_dac_max = rf.afc.dac_max; // VCXO - assuming DAC linearity 719 l1_config.params.afc_dac_max = rf.afc.dac_max; // VCXO - assuming DAC linearity
790 #if (NEW_SNR_THRESHOLD == 0)
791 l1_config.params.afc_snr_thr = rf.afc.snr_thr; // VCXO - SNR threshold 720 l1_config.params.afc_snr_thr = rf.afc.snr_thr; // VCXO - SNR threshold
792 #else
793 l1_config.params.afc_snr_thr = L1_TOA_SNR_THRESHOLD;
794 #endif /* NEW_SNR_THRESHOLD */
795 l1_config.params.afc_algo = ALGO_AFC_LQG_PREDICTOR; // VCXO|VCTCXO - Choosing AFC algorithm 721 l1_config.params.afc_algo = ALGO_AFC_LQG_PREDICTOR; // VCXO|VCTCXO - Choosing AFC algorithm
796 l1_config.params.afc_win_avg_size_M = C_WIN_AVG_SIZE_M; // VCXO - Average psi values with this value 722 l1_config.params.afc_win_avg_size_M = C_WIN_AVG_SIZE_M; // VCXO - Average psi values with this value
797 l1_config.params.rgap_algo = ALGO_AFC_RXGAP; // VCXO - Choosing Reception Gap algorithm 723 l1_config.params.rgap_algo = ALGO_AFC_RXGAP; // VCXO - Choosing Reception Gap algorithm
798 l1_config.params.rgap_bad_snr_count_B = C_RGAP_BAD_SNR_COUNT_B; // VCXO - Prediction SNR count 724 l1_config.params.rgap_bad_snr_count_B = C_RGAP_BAD_SNR_COUNT_B; // VCXO - Prediction SNR count
799 #endif 725 #endif
898 /*-------------------------------------------------------*/ 824 /*-------------------------------------------------------*/
899 /* Parameters : */ 825 /* Parameters : */
900 /* Return : */ 826 /* Return : */
901 /* Functionality : returns agc value */ 827 /* Functionality : returns agc value */
902 /*-------------------------------------------------------*/ 828 /*-------------------------------------------------------*/
903 WORD8 Cust_get_agc_from_IL(UWORD16 radio_freq, UWORD16 agc_index, UWORD8 table_id,UWORD8 lna_off_val) 829 WORD8 Cust_get_agc_from_IL(UWORD16 radio_freq, UWORD16 agc_index, UWORD8 table_id)
904 { 830 {
905 831 WORD8 agc_value;
906 UWORD16 agc_index_temp; 832
907
908 // radio_freq currently not used 833 // radio_freq currently not used
909 // this parameter is passed in order to allow band dependent tables for specific RFs 834 // this parameter is passed in order to allow band dependent tables for specific RFs
910 // (e.g. dual band RF with separate AGC H/W blocks for GSM and DCS) 835 // (e.g. dual band RF with separate AGC H/W blocks for GSM and DCS)
911 836
912 agc_index_temp = (agc_index<<1) + (lna_off_val * l1ctl_get_lna_att(radio_freq));
913 agc_index= agc_index_temp>>1;
914 if (agc_index > 120) 837 if (agc_index > 120)
915 agc_index = 120; // Clip agc_index 838 agc_index = 120; // Clip agc_index
916 839
917 switch (table_id) 840 switch (table_id)
918 { 841 {
919 case MAX_ID: return(rf.rx.agc.il2agc_max[agc_index]); 842 case MAX_ID:
920 case AV_ID: return(rf.rx.agc.il2agc_av[agc_index]); 843 agc_value = rf.rx.agc.il2agc_max[agc_index];
921 case PWR_ID: return(rf.rx.agc.il2agc_pwr[agc_index]); 844 break;
845 case AV_ID:
846 agc_value = rf.rx.agc.il2agc_av[agc_index];
847 break;
848 case PWR_ID:
849 agc_value = rf.rx.agc.il2agc_pwr[agc_index];
850 break;
922 } 851 }
923 return (0);//omaps00090550 852
853 return agc_value;
924 } 854 }
925 855
926 /*-------------------------------------------------------*/ 856 /*-------------------------------------------------------*/
927 /* Cust_get_agc_band */ 857 /* Cust_get_agc_band */
928 /*-------------------------------------------------------*/ 858 /*-------------------------------------------------------*/
936 UWORD16 Cust_get_agc_band(UWORD16 arfcn, UWORD8 gsm_band) 866 UWORD16 Cust_get_agc_band(UWORD16 arfcn, UWORD8 gsm_band)
937 #else 867 #else
938 UWORD16 inline Cust_get_agc_band(UWORD16 arfcn, UWORD8 gsm_band) 868 UWORD16 inline Cust_get_agc_band(UWORD16 arfcn, UWORD8 gsm_band)
939 #endif 869 #endif
940 { 870 {
941 // WORD32 i =0 ; //omaps00090550 871 WORD32 i ;
942 UWORD8 band_number; 872
943 873 for (i=0;i<RF_RX_CAL_CHAN_SIZE;i++)
944 for (band_number=0;band_number<RF_RX_CAL_CHAN_SIZE;band_number++)
945 { 874 {
946 if (arfcn <= rf_band[gsm_band].rx.agc_bands[band_number].upper_bound) 875 if (arfcn <= rf_band[gsm_band].rx.agc_bands[i].upper_bound)
947 return(band_number); 876 return(i);
948 } 877 }
949 // Should never happen! 878 // Should never happen!
950 return(0); 879 return(0);
951 } 880 }
952 881
953 #if (L1_FF_MULTIBAND == 0)
954 /*-------------------------------------------------------*/ 882 /*-------------------------------------------------------*/
955 /* Cust_is_band_high */ 883 /* Cust_is_band_high */
956 /*-------------------------------------------------------*/ 884 /*-------------------------------------------------------*/
957 /* Parameters : arfcn */ 885 /* Parameters : arfcn */
958 /* Return : 0 if low band */ 886 /* Return : 0 if low band */
969 max_carrier = band_config[std_config[std].band[0]].max_carrier; 897 max_carrier = band_config[std_config[std].band[0]].max_carrier;
970 898
971 return(((radio_freq >= l1_config.std.first_radio_freq) && 899 return(((radio_freq >= l1_config.std.first_radio_freq) &&
972 (radio_freq < (l1_config.std.first_radio_freq + max_carrier))) ? MULTI_BAND1 : MULTI_BAND2); 900 (radio_freq < (l1_config.std.first_radio_freq + max_carrier))) ? MULTI_BAND1 : MULTI_BAND2);
973 } 901 }
974 #endif
975 902
976 /*-------------------------------------------------------*/ 903 /*-------------------------------------------------------*/
977 /* l1ctl_encode_delta2() */ 904 /* l1ctl_encode_delta2() */
978 /*-------------------------------------------------------*/ 905 /*-------------------------------------------------------*/
979 /* Parameters : */ 906 /* Parameters : */
983 WORD8 l1ctl_encode_delta2(UWORD16 radio_freq) 910 WORD8 l1ctl_encode_delta2(UWORD16 radio_freq)
984 { 911 {
985 WORD8 delta2_freq; 912 WORD8 delta2_freq;
986 UWORD16 i; 913 UWORD16 i;
987 UWORD16 arfcn; 914 UWORD16 arfcn;
988 #if (L1_FF_MULTIBAND == 0)
989 UWORD8 band; 915 UWORD8 band;
990 916
991 band = Cust_is_band_high(radio_freq); 917 band = Cust_is_band_high(radio_freq);
992 arfcn = Convert_l1_radio_freq(radio_freq); 918 arfcn = Convert_l1_radio_freq(radio_freq);
993 #else
994 WORD8 band;
995 // Corrected for input being rf_freq and not l1_freq
996 arfcn = rf_convert_l1freq_to_arfcn_rfband(rf_convert_rffreq_to_l1freq(radio_freq), &band);
997 #endif
998 919
999 i = Cust_get_agc_band(arfcn,band); // 920 i = Cust_get_agc_band(arfcn,band); //
1000 delta2_freq = rf_band[band].rx.agc_bands[i].agc_calib; 921 delta2_freq = rf_band[band].rx.agc_bands[i].agc_calib;
1001 922
1002 //temperature compensation 923 //temperature compensation
1010 } 931 }
1011 932
1012 return(delta2_freq); 933 return(delta2_freq);
1013 } 934 }
1014 935
1015 #if (L1_FF_MULTIBAND == 0)
1016 #else
1017 /*-------------------------------------------------------*/
1018 /* l1ctl_get_g_magic() */
1019 /*-------------------------------------------------------*/
1020 /* Parameters : */
1021 /* Return : */
1022 /* Functionality : */
1023 /*-------------------------------------------------------*/
1024 UWORD16 l1ctl_get_g_magic(UWORD16 radio_freq)
1025 {
1026 // Corrected for input being rf_freq and not l1_freq
1027 return (rf_band[rf_subband2band[rf_convert_rffreq_to_l1subband(radio_freq)]].rx.rx_cal_params.g_magic);
1028 }
1029
1030
1031 /*-------------------------------------------------------*/
1032 /* l1ctl_get_lna_att() */
1033 /*-------------------------------------------------------*/
1034 /* Parameters : */
1035 /* Return : */
1036 /* Functionality : */
1037 /*-------------------------------------------------------*/
1038 UWORD16 l1ctl_get_lna_att(UWORD16 radio_freq)
1039 {
1040 // The function is provided with rf_freq as input so
1041 // convert rf_freq to l1_subband then convert l1_subband to rf_band and index into rf_band
1042 return( rf_band[rf_subband2band[rf_convert_rffreq_to_l1subband(radio_freq)]].rx.rx_cal_params.lna_att);
1043 // return (rf_band[rf_convert_l1freq_to_rf_band_idx(radio_freq)].rx.rx_cal_params.lna_att);
1044 }
1045 /*-------------------------------------------------------*/
1046 /* l1ctl_encode_delta1() */
1047 /*-------------------------------------------------------*/
1048 /* Parameters : */
1049 /* Return : */
1050 /* Functionality : */
1051 /*-------------------------------------------------------*/
1052 WORD8 l1ctl_encode_delta1(UWORD16 radio_freq)
1053 {
1054 return 0;
1055 }
1056 /*-------------------------------------------------------*/
1057 /* l1ctl_encode_lna() */
1058 /*-------------------------------------------------------*/
1059 /* Parameters : */
1060 /* Return : */
1061 /* Functionality : */
1062 /*-------------------------------------------------------*/
1063 void l1ctl_encode_lna( UWORD8 input_level,
1064 UWORD8 *lna_state,
1065 UWORD16 radio_freq)
1066 {
1067
1068 /*** LNA Hysteresis is implemented as following :
1069
1070 |
1071 On|---<>----+-------+
1072 | | |
1073 LNA | | |
1074 | ^ v
1075 | | |
1076 | | |
1077 Off| +-------+----<>-----
1078 +--------------------------------
1079 50 40 30 20 input_level /-dBm
1080 THR_HIGH THR_LOW ***/
1081 WORD8 band;
1082 // Corrected for input to be rf_freq and not l1_freq
1083 band = rf_subband2band[rf_convert_rffreq_to_l1subband(radio_freq)];
1084 if ( input_level > rf_band[band].rx.rx_cal_params.lna_switch_thr_high) // < -44dBm ?
1085 {
1086 *lna_state = LNA_ON; // lna_off = FALSE
1087 }
1088 else if ( input_level < rf_band[band].rx.rx_cal_params.lna_switch_thr_low) // > -40dBm ?
1089 {
1090 *lna_state = LNA_OFF; // lna off = TRUE
1091 }
1092 }
1093
1094 UWORD8 l1ctl_get_iqswap(UWORD16 rf_freq)
1095 {
1096 return(rf_band[rf_subband2band[rf_convert_rffreq_to_l1subband(rf_freq)]].swap_iq);
1097 }
1098
1099 #endif //if L1_FF_MULTIBAND == 0)
1100
1101 /************************************/ 936 /************************************/
1102 /* TX Management */ 937 /* TX Management */
1103 /************************************/ 938 /************************************/
1104 /*-------------------------------------------------------*/ 939 /*-------------------------------------------------------*/
1105 /* Cust_get_ramp_tab */ 940 /* Cust_get_ramp_tab */
1116 */ 951 */
1117 /*-------------------------------------------------------*/ 952 /*-------------------------------------------------------*/
1118 953
1119 void Cust_get_ramp_tab(API *a_ramp, UWORD8 txpwr_ramp_up, UWORD8 txpwr_ramp_down, UWORD16 radio_freq) 954 void Cust_get_ramp_tab(API *a_ramp, UWORD8 txpwr_ramp_up, UWORD8 txpwr_ramp_down, UWORD16 radio_freq)
1120 { 955 {
1121 UWORD16 index_up, index_down,j, arfcn; 956 UWORD16 index_up, index_down, j;
1122 #if (L1_FF_MULTIBAND == 0)
1123 UWORD8 band; 957 UWORD8 band;
1124 958
1125 band = Cust_is_band_high(radio_freq); 959 band = Cust_is_band_high(radio_freq);
1126 arfcn = Convert_l1_radio_freq(radio_freq);
1127 #else
1128 WORD8 band;
1129 // Corrected for input being rf_freq and not l1_freq
1130 arfcn = rf_convert_l1freq_to_arfcn_rfband(rf_convert_rffreq_to_l1freq(radio_freq), &band);
1131 #endif //if( L1_FF_MULTIBAND == 0)
1132 960
1133 index_up = rf_band[band].tx.levels[txpwr_ramp_up].ramp_index; 961 index_up = rf_band[band].tx.levels[txpwr_ramp_up].ramp_index;
1134 index_down = rf_band[band].tx.levels[txpwr_ramp_down].ramp_index; 962 index_down = rf_band[band].tx.levels[txpwr_ramp_down].ramp_index;
1135 963
1136 #if ((ANALOG == 1) || (ANALOG == 2) || (ANALOG == 3)) 964 #if ((ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3))
1137 for (j=0; j<16; j++) 965 for (j=0; j<16; j++)
1138 { 966 {
1139 a_ramp[j]=((rf_band[band].tx.ramp_tables[index_down].ramp_down[j])<<11) | 967 a_ramp[j]=((rf_band[band].tx.ramp_tables[index_down].ramp_down[j])<<11) |
1140 ((rf_band[band].tx.ramp_tables[index_up].ramp_up[j]) << 6) | 968 ((rf_band[band].tx.ramp_tables[index_up].ramp_up[j]) << 6) |
1141 0x14; 969 0x14;
1142 } 970 }
1143 #endif 971 #endif
1144
1145 #if (RF_FAM == 61)
1146 // 20 Coeff each 8 (RampDown) + 8 (RampUp)
1147 for (j=0; j<20; j++)
1148 {
1149 a_ramp[j]=( (255 - (rf_band[band].tx.ramp_tables[index_down].ramp_down[j]) ) <<8) |
1150 ((rf_band[band].tx.ramp_tables[index_up].ramp_up[j])) ;
1151 }
1152 #endif
1153 } 972 }
1154 973
1155 /*-------------------------------------------------------*/ 974 /*-------------------------------------------------------*/
1156 /* get_pwr_data */ 975 /* get_pwr_data */
1157 /*-------------------------------------------------------*/ 976 /*-------------------------------------------------------*/
1158 /* Parameters : */ 977 /* Parameters : */
1159 /* Return : */ 978 /* Return : */
1160 /* Functionality : */ 979 /* Functionality : */
1161 /*-------------------------------------------------------*/ 980 /*-------------------------------------------------------*/
1162 981
1163 #if ((ANALOG == 1) || (ANALOG == 2) || (ANALOG == 3) || (RF_FAM == 61)) 982 #if ((ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3))
1164 UWORD16 Cust_get_pwr_data(UWORD8 txpwr, UWORD16 radio_freq 983 UWORD16 Cust_get_pwr_data(UWORD8 txpwr, UWORD16 radio_freq)
1165 #if (REL99 && FF_PRF) 984 {
1166 , UWORD8 number_uplink_timeslot
1167 #endif
1168 )
1169 {
1170 985
1171 UWORD16 i,j; 986 UWORD16 i,j;
1172 UWORD16 arfcn; 987 UWORD16 arfcn;
1173 988 UWORD8 band;
1174 T_TX_LEVEL *a_tx_levels;
1175
1176 #if (APC_VBAT_COMP == 1)
1177 static UWORD16 apc_max_value = APC_MAX_VALUE;
1178 #endif
1179 989
1180 #if(ORDER2_TX_TEMP_CAL==1) 990 #if(ORDER2_TX_TEMP_CAL==1)
1181 WORD16 pwr_data; 991 WORD16 pwr_data;
1182 #else 992 #else
1183 UWORD16 pwr_data; 993 UWORD16 pwr_data;
1184 #endif 994 #endif
1185 995
1186 #if (L1_FF_MULTIBAND == 0) 996 band = Cust_is_band_high(radio_freq);
1187 UWORD8 band; 997 arfcn = Convert_l1_radio_freq(radio_freq);
1188 band = Cust_is_band_high(radio_freq); 998
1189 arfcn = Convert_l1_radio_freq(radio_freq); 999 i = rf_band[band].tx.levels[txpwr].chan_cal_index;
1190 #else
1191 WORD8 band;
1192 // Corrected for input being rf_freq and not l1_freq
1193 arfcn = rf_convert_l1freq_to_arfcn_rfband(rf_convert_rffreq_to_l1freq(radio_freq), &band);
1194 #endif //if( L1_FF_MULTIBAND == 0)
1195
1196 // band = Cust_is_band_high(radio_freq);
1197 // arfcn = Convert_l1_radio_freq(radio_freq);
1198
1199 a_tx_levels = &(rf_band[band].tx.levels[txpwr]); // get pointer to rf tx structure
1200
1201 #if REL99
1202 #if FF_PRF
1203 // uplink power reduction feature which decrease power level in case of uplink multislot
1204 a_tx_levels = Cust_get_uplink_apc_power_reduction(band, number_uplink_timeslot, a_tx_levels);
1205 #endif
1206 #endif
1207
1208 // get uncalibrated apc
1209 pwr_data = a_tx_levels->apc;
1210
1211 i = a_tx_levels->chan_cal_index; // get index for channel compensation
1212 j=0; 1000 j=0;
1001 // get uncalibrated apc
1002 pwr_data = rf_band[band].tx.levels[txpwr].apc;
1213 1003
1214 while (arfcn > rf_band[band].tx.chan_cal_table[i][j].arfcn_limit) 1004 while (arfcn > rf_band[band].tx.chan_cal_table[i][j].arfcn_limit)
1215 j++; 1005 j++;
1216 1006
1217 // channel calibrate apc 1007 // channel calibrate apc
1218 pwr_data = ((UWORD32) (pwr_data * rf_band[band].tx.chan_cal_table[i][j].chan_cal))/128; 1008 pwr_data = ((UWORD32) (pwr_data * rf_band[band].tx.chan_cal_table[i][j].chan_cal))/128;
1219 1009
1220 // temperature compensate apc 1010 // temperature compensate apc
1221 { 1011 {
1222 T_TX_TEMP_CAL *pt; 1012 T_TX_TEMP_CAL *pt;
1223 1013
1224 pt = rf_band[band].tx.temp; 1014 pt = rf_band[band].tx.temp;
1225 while (((WORD16)adc.converted[ADC_RFTEMP] > pt->temperature) && ((pt-rf_band[band].tx.temp) < (RF_TX_CAL_TEMP_SIZE-1))) 1015 while (((WORD16)adc.converted[ADC_RFTEMP] > pt->temperature) && ((pt-rf_band[band].tx.temp) < (RF_TX_CAL_TEMP_SIZE-1)))
1226 pt++; 1016 pt++;
1227 #if(ORDER2_TX_TEMP_CAL==1) 1017 #if(ORDER2_TX_TEMP_CAL==1)
1228 pwr_data += (txpwr*(pt->a*txpwr + pt->b) + pt->c) / 64; //delta apc = ax^2+bx+c 1018 pwr_data += (txpwr*(pt->a*txpwr + pt->b) + pt->c) / 64; //delta apc = ax^2+bx+c
1229 if(pwr_data < 0) pwr_data = 0; 1019 if(pwr_data < 0) pwr_data = 0;
1230 #else 1020 #else
1231 pwr_data += pt->apc_calib; 1021 pwr_data += pt->apc_calib;
1232 #endif 1022 #endif
1233 } 1023 }
1234
1235 // Vbat compensate apc
1236 #if (APC_VBAT_COMP == 1)
1237
1238 if (adc.converted[ADC_VBAT] < VBAT_LOW_THRESHOLD)
1239 apc_max_value = APC_MAX_VALUE_LOW_BAT;
1240
1241 else if (adc.converted[ADC_VBAT] > VBAT_HIGH_THRESHOLD)
1242 apc_max_value = APC_MAX_VALUE;
1243
1244 // else do nothing as Vbat is staying between VBAT_LOW_THRESHOLD and
1245 // VBAT_HIGH_THRESHOLD -> max APC value is still the same than previous one
1246
1247 if (pwr_data > apc_max_value)
1248 pwr_data = apc_max_value;
1249 #endif // APC_VBAT_COMP == 1
1250
1251 return(pwr_data); 1024 return(pwr_data);
1252 } 1025 }
1253 #endif
1254
1255
1256 #if(REL99 && FF_PRF)
1257
1258 /*-------------------------------------------------------*/
1259 /* Cust_get_uplink_apc_power_reduction */
1260 /*-------------------------------------------------------*/
1261 /* Parameters : */
1262 /* - frenquency band */
1263 /* - modulation type */
1264 /* - number of uplink timeslot */
1265 /* - pointer to radio power control structure */
1266 /* Return : */
1267 /* - pointer to radio power control structure */
1268 /* */
1269 /* Functionality : This function returns a pointer to */
1270 /* the radio power control structure after power */
1271 /* reduction processing. */
1272 /* Depending of the number of uplink timeslot, the */
1273 /* analogue power control (apc) value can be reduced */
1274 /* in order to limit effect of terminal heat */
1275 /* dissipation due to power amplifier. */
1276 /*-------------------------------------------------------*/
1277
1278 T_TX_LEVEL *Cust_get_uplink_apc_power_reduction(UWORD8 band,
1279 UWORD8 number_uplink_timeslot,
1280 T_TX_LEVEL *p_tx_level)
1281 {
1282 T_TX_LEVEL *p_power_reduction_tx_level;
1283
1284 #if TESTMODE
1285 if ((l1_config.TestMode == TRUE) && (l1_config.tmode.tx_params.power_reduction_enable == FALSE))
1286 return p_tx_level ; // return without any power reduction
1287 #endif
1288
1289 if ((number_uplink_timeslot >= 1) && (number_uplink_timeslot <= MAX_UPLINK_TIME_SLOT))
1290 {
1291 number_uplink_timeslot--; // index start from 0
1292 }
1293 else
1294 {
1295 return p_tx_level; // abnormal case we do not apply any power reduction
1296 }
1297
1298 p_power_reduction_tx_level = &(rf_band[band].tx.levels_power_reduction[number_uplink_timeslot]);
1299
1300 // We select the lowest power level in order to apply power reduction
1301 #if (CODE_VERSION != SIMULATION)
1302 if (p_tx_level->apc > p_power_reduction_tx_level->apc) // higher apc value means higher transmit power
1303 #else
1304 if (p_tx_level->apc < p_power_reduction_tx_level->apc) // ! for simulation rf apc tables are inverted so comparaison is the reverse
1305 #endif
1306 return p_power_reduction_tx_level;
1307 else
1308 return p_tx_level;
1309 }
1310
1311 #endif 1026 #endif
1312 #endif /* !RUN_FLASH */ 1027 #endif /* !RUN_FLASH */
1313 1028
1314 #ifndef RUN_INT_RAM 1029 #ifndef RUN_INT_RAM
1315 /*-------------------------------------------------------*/ 1030 /*-------------------------------------------------------*/