FreeCalypso > hg > fc-tourmaline

comparison src/cs/layer1/cust0/l1_cust.c @ 0:4e78acac3d88

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/{condat,cs,gpf,nucleus}: import from Selenite
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 16 Oct 2020 06:23:26 +0000
parents
children 04aaa5622fa7
comparison
equal deleted inserted replaced
-1:000000000000 0:4e78acac3d88
1 /************* Revision Controle System Header *************
2 * GSM Layer 1 software
3 * L1_CUST.C
4 *
5 * Filename l1_cust.c
6 * Version 3.66
7 * Date 03/21/03
8 *
9 ************* Revision Controle System Header *************/
10
11 //#define GLOBAL
12
13
14 #include "string.h"
15
16 #include "l1_confg.h"
17 #include "l1_const.h"
18 #include "ulpd.h"
19 #include "tm_defs.h"
20 #include "l1_types.h"
21 #include "l1_time.h"
22 #include "l1_trace.h"
23 #include "sys_types.h"
24 #include "sim.h"
25 #include "buzzer.h"
26 #include "serialswitch.h"
27
28 #include "abb.h"
29
30 #if TESTMODE
31 #include "l1tm_defty.h"
32 #endif
33
34 #if (AUDIO_TASK == 1)
35 #include "l1audio_const.h"
36 #include "l1audio_cust.h"
37 #include "l1audio_defty.h"
38 #endif
39
40 #if (L1_GTT == 1)
41 #include "l1gtt_const.h"
42 #include "l1gtt_defty.h"
43 #endif
44 #include "l1_defty.h"
45 #include "l1_msgty.h"
46 #include "l1_tabs.h"
47 #include "l1_varex.h"
48
49 #if (VCXO_ALGO == 1)
50 #include "l1_ctl.h"
51 #endif
52
53 #if ((ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3))
54 #include "spi_drv.h"
55 #endif
56
57 #if (RF==35)
58 #include "tpudrv35.h"
59 #include "l1_rf35.h"
60 #include "l1_rf35.c"
61 #endif
62
63 #if (RF==12)
64 #include "tpudrv12.h"
65 #include "l1_rf12.h"
66 #include "l1_rf12.c"
67 #endif
68
69 #if (RF==10)
70 #include "tpudrv10.h"
71 #include "l1_rf10.h"
72 #include "l1_rf10.c"
73 #endif
74
75 #if (RF==8)
76 #include "tpudrv8.h"
77 #include "l1_rf8.h"
78 #include "l1_rf8.c"
79 #endif
80
81 #if (RF==2)
82 #include "l1_rf2.h"
83 #include "l1_rf2.c"
84 #endif
85
86 #include "rv/rv_defined_swe.h" // for RVM_FCHG_SWE
87 #ifdef RVM_FCHG_SWE
88 #include "fchg/fchg_struct.h"
89 #endif
90
91 // Nucleus functions
92 extern INT TMD_Timer_State;
93 extern UWORD32 TMD_Timer; // for big sleep
94 extern UWORD32 TCD_Priority_Groups;
95 extern VOID *TCD_Current_Thread;
96 extern TC_HCB *TCD_Active_HISR_Heads[TC_HISR_PRIORITIES];
97 extern TC_HCB *TCD_Active_HISR_Tails[TC_HISR_PRIORITIES];
98 extern TC_PROTECT TCD_System_Protect;
99
100 #if (L2_L3_SIMUL == 0)
101 #define FFS_WORKAROUND 1
102 #else
103 #define FFS_WORKAROUND 0
104 #endif
105 #if (FFS_WORKAROUND == 1)
106 #include "ffs.h"
107 #else
108 typedef signed int int32;
109 typedef signed char effs_t;
110 typedef int32 filesize_t;
111 effs_t ffs_fwrite(const char *name, void *addr, filesize_t size);
112 effs_t ffs_fread(const char *name, void *addr, filesize_t size);
113 #endif
114
115 // Import band configuration from Flash module (need to replace by an access function)
116 //extern UWORD8 std;
117 extern T_L1_CONFIG l1_config;
118 extern T_L1S_GLOBAL l1s;
119
120 #if (CODE_VERSION != SIMULATION)
121 // Import serial switch configuration
122 extern char ser_cfg_info[2];
123 #endif
124
125 void get_cal_from_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id);
126 UWORD8 save_cal_in_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id);
127 void config_rf_rw_band(char type, UWORD8 read);
128 void config_rf_read(char type);
129 void config_rf_write(char type);
130
131 enum {
132 RF_ID = 0,
133 ADC_ID = 1
134 };
135
136 /*-------------------------------------------------------*/
137 /* Parameters: none */
138 /* Return: none */
139 /* Functionality: Defines the location of rf-struct */
140 /* for each std. */
141 /*-------------------------------------------------------*/
142
143 const static T_BAND_CONFIG band_config[] =
144 { /*ffs name, default addr, max carrier, min tx pwr */
145 {"",(T_RF_BAND *) 0,0,0},//undefined
146 {"900", (T_RF_BAND *)&rf_900, 174, 19 },//EGSM
147 {"1800",(T_RF_BAND *)&rf_1800, 374, 15 },//DCS
148 {"1900",(T_RF_BAND *)&rf_1900, 299, 15 },//PCS
149 {"850", (T_RF_BAND *)&rf_850, 124, 19 },//GSM850
150 #if (RF == 10)
151 {"1900_us",(T_RF_BAND *)&rf_1900, 299, 15 },//usdual 1900 rf tables are the same as 3band 1900 rf tables at the moment
152 #endif
153 {"900", (T_RF_BAND *)&rf_900, 124, 19 } //GSM, this should be last entry
154 };
155
156 /*-------------------------------------------------------*/
157 /* Parameters: none */
158 /* Return: none */
159 /* Functionality: Defines the indices into band_config */
160 /* for each std. */
161 /*-------------------------------------------------------*/
162 const T_STD_CONFIG std_config[] =
163 {
164 /* band1 index, band2 index, txpwr turning point, first arfcn*/
165 { 0, 0, 0, 0 }, // std = 0 not used
166 { BAND_GSM900, BAND_NONE, 0, 1 }, // std = 1 GSM
167 { BAND_EGSM900, BAND_NONE, 0, 1 }, // std = 2 EGSM
168 { BAND_PCS1900, BAND_NONE, 21, 512 }, // std = 3 PCS
169 { BAND_DCS1800, BAND_NONE, 28, 512 }, // std = 4 DCS
170 { BAND_GSM900, BAND_DCS1800, 28, 1 }, // std = 5 DUAL
171 { BAND_EGSM900, BAND_DCS1800, 28, 1 }, // std = 6 DUALEXT
172 { BAND_GSM850, BAND_NONE, 0, 128 }, // std = 7 850
173 #if (RF == 10)
174 { BAND_GSM850, BAND_PCS1900_US, 21, 1 } // std = 8 850/1900
175 #else
176 { BAND_GSM850, BAND_PCS1900, 21, 1 } // std = 8 850/1900
177 #endif
178 };
179
180 /*-------------------------------------------------------*/
181 /* Prototypes of external functions used in this file. */
182 /*-------------------------------------------------------*/
183 void l1_initialize(T_MMI_L1_CONFIG *mmi_l1_config);
184 WORD16 Convert_l1_radio_freq (UWORD16 radio_freq);
185
186 /*-------------------------------------------------------*/
187 /* Cust_recover_Os() */
188 /*-------------------------------------------------------*/
189 /* */
190 /* Description: adjust OS from sleep duration */
191 /* ------------ */
192 /* This function fix the : */
193 /* - system clock */
194 /* - Nucleus timers */
195 /* - xxxxxx (customer dependant) */
196 /*-------------------------------------------------------*/
197
198 UWORD8 Cust_recover_Os(void)
199 {
200 #if (CODE_VERSION != SIMULATION)
201 UWORD32 current_system_clock;
202
203 /***************************************************/
204 // Fix System clock and Nucleus Timers if any.... */
205 /***************************************************/
206 // Fix System clock ....
207 current_system_clock = NU_Retrieve_Clock();
208 current_system_clock += l1s.pw_mgr.sleep_duration;
209 NU_Set_Clock(current_system_clock);
210
211 // Fix Nucleus timer (if needed) ....
212 if (TMD_Timer_State == TM_ACTIVE)
213 {
214 TMD_Timer -= l1s.pw_mgr.sleep_duration;
215 if (!TMD_Timer) TMD_Timer_State = TM_EXPIRED;
216 }
217
218 /***************************************************/
219 // Cust dependant part ... */
220 /***************************************************/
221 //.............
222 //.............
223 //..............
224 return(TRUE);
225
226 #endif
227 }
228
229
230
231 /*-------------------------------------------------------*/
232 /* Cust_check_system() */
233 /*-------------------------------------------------------*/
234 /* */
235 /* Description: */
236 /* ------------ */
237 /* GSM 1.5 : */
238 /* - authorize UWIRE clock to be stopped */
239 /* and write value in l1s.pw_mgr.modules_status. */
240 /* - authorize ARMIO clock to be stopped if the light is */
241 /* off and write value in l1s.pw_mgr.modules_status. */
242 /* - check if SIM clock have been stopped */
243 /* before allowing DEEP SLEEP. */
244 /* - check if UARTs are ready to enter deep sleep */
245 /* - choose the sleep mode */
246 /* */
247 /* Return: */
248 /* ------- */
249 /* DO_NOT_SLEEP, FRAME_STOP or CLOCK_STOP */
250 /*-------------------------------------------------------*/
251 UWORD8 Cust_check_system(void)
252 {
253 extern UWORD8 why_big_sleep;
254 #ifdef RVM_FCHG_SWE
255 extern T_PWR_CTRL_BLOCK *pwr_ctrl;
256 #endif
257 extern SYS_BOOL uart_sleep_timer_enabled;
258
259 #if (CODE_VERSION != SIMULATION)
260
261 //cut ARMIO and UWIRE clocks in big sleep
262 l1s.pw_mgr.modules_status = ARMIO_CLK_CUT | UWIRE_CLK_CUT;
263
264 #ifdef RVM_FCHG_SWE
265 // Forbig deep sleep when charging
266 if (pwr_ctrl && pwr_ctrl->state >= FCHG_STATE_I2V_CAL_1 &&
267 pwr_ctrl->state <= FCHG_STATE_CV_CHARGING)
268 {
269 why_big_sleep = BIG_SLEEP_DUE_TO_CHARGING;
270 return(FRAME_STOP); // BIG sleep
271 }
272 #endif
273
274 // Forbid deep sleep if the light is on
275 if (LT_Status())
276 {
277 why_big_sleep = BIG_SLEEP_DUE_TO_LIGHT_ON;
278 return(FRAME_STOP); // BIG sleep
279 }
280
281 // Forbid deep sleep if the SIM and UARTs not ready
282 if (!SIM_SleepStatus())
283 {
284 why_big_sleep = BIG_SLEEP_DUE_TO_SIM;
285 return(FRAME_STOP); // BIG sleep
286 }
287
288 /* FreeCalypso: check UART activity timer */
289 if (uart_sleep_timer_enabled)
290 {
291 why_big_sleep = BIG_SLEEP_DUE_TO_UART;
292 return(FRAME_STOP); // BIG sleep
293 }
294
295 if ((l1s.pw_mgr.mode_authorized == DEEP_SLEEP) ||
296 (l1s.pw_mgr.mode_authorized == ALL_SLEEP))
297 {
298 if(SER_UartSleepStatus())
299 return(CLOCK_STOP); // DEEP sleep
300 else
301 return(DO_NOT_SLEEP); /* wait another frame or two */
302 }
303 else
304 {
305 why_big_sleep = BIG_SLEEP_DUE_TO_SLEEP_MODE;
306 return(FRAME_STOP); // BIG sleep
307 }
308
309 #else // Simulation part
310 return(CLOCK_STOP); // DEEP sleep
311 #endif
312 }
313
314
315 /*-------------------------------------------------------*/
316 /* Parameters: none */
317 /* Return: none */
318 /* Functionality: Read the RF configuration, tables etc. */
319 /* from FFS files. */
320 /*-------------------------------------------------------*/
321 const static T_CONFIG_FILE config_files_common[] =
322 {
323 #if (CODE_VERSION != SIMULATION)
324
325 // The first char is NOT part of the filename. It is used for
326 // categorizing the ffs file contents:
327 // f=rf-cal, F=rf-config,
328 // t=tx-cal, T=tx-config,
329 // r=rx-cal, R=rx-config,
330 // s=sys-cal, S=sys-config,
331 "f/gsm/rf/afcdac", &rf.afc.eeprom_afc, sizeof(rf.afc.eeprom_afc),
332 "F/gsm/rf/stdmap", &rf.radio_band_support, sizeof(rf.radio_band_support),
333 #if (VCXO_ALGO == 1)
334 "F/gsm/rf/afcparams", &rf.afc.psi_sta_inv, 4 * sizeof(UWORD32) + 4 * sizeof(WORD16),
335 #else
336 "F/gsm/rf/afcparams", &rf.afc.psi_sta_inv, 4 * sizeof(UWORD32),
337 #endif
338
339 "R/gsm/rf/rx/agcglobals", &rf.rx.agc, 4 * sizeof(UWORD16),
340 "R/gsm/rf/rx/il2agc", &rf.rx.agc.il2agc_pwr[0], 3 * sizeof(rf.rx.agc.il2agc_pwr),
341 "R/gsm/rf/rx/agcwords", &AGC_TABLE, sizeof(AGC_TABLE),
342
343 "s/sys/adccal", &adc_cal, sizeof(adc_cal),
344
345 "S/sys/abb", &abb, sizeof(abb),
346 "S/sys/uartswitch", &ser_cfg_info, sizeof(ser_cfg_info),
347
348 #endif
349 NULL, 0, 0 // terminator
350 };
351
352 /*-------------------------------------------------------*/
353 /* Parameters: none */
354 /* Return: none */
355 /* Functionality: Read the RF configurations for */
356 /* each band from FFS files. These files */
357 /* are defined for one band, and and used */
358 /* for all bands. */
359 /*-------------------------------------------------------*/
360 const static T_CONFIG_FILE config_files_band[] =
361 {
362 // The first char is NOT part of the filename. It is used for
363 // categorizing the ffs file contents:
364 // f=rf-cal, F=rf-config,
365 // t=tx-cal, T=tx-config,
366 // r=rx-cal, R=rx-config,
367 // s=sys-cal, S=sys-config,
368
369 // generic for all bands
370 // band[0] is used as template for all bands.
371 "t/gsm/rf/tx/ramps", &rf_band[0].tx.ramp_tables, sizeof(rf_band[0].tx.ramp_tables),
372 "t/gsm/rf/tx/levels", &rf_band[0].tx.levels, sizeof(rf_band[0].tx.levels),
373 "t/gsm/rf/tx/calchan", &rf_band[0].tx.chan_cal_table, sizeof(rf_band[0].tx.chan_cal_table),
374 "T/gsm/rf/tx/caltemp", &rf_band[0].tx.temp, sizeof(rf_band[0].tx.temp),
375
376 "r/gsm/rf/rx/calchan", &rf_band[0].rx.agc_bands, sizeof(rf_band[0].rx.agc_bands),
377 "R/gsm/rf/rx/caltemp", &rf_band[0].rx.temp, sizeof(rf_band[0].rx.temp),
378 "r/gsm/rf/rx/agcparams", &rf_band[0].rx.rx_cal_params, sizeof(rf_band[0].rx.rx_cal_params),
379 NULL, 0, 0 // terminator
380 };
381
382 void config_ffs_read(char type)
383 {
384 config_rf_read(type);
385 config_rf_rw_band(type, 1);
386 }
387
388 void config_ffs_write(char type)
389 {
390 config_rf_write(type);
391 config_rf_rw_band(type, 0);
392 }
393
394 void config_rf_read(char type)
395 {
396 const T_CONFIG_FILE *file = config_files_common;
397
398 while (file->name != NULL)
399 {
400 if (type == '*' || type == file->name[0]) {
401 ffs_fread(&file->name[1], file->addr, file->size);
402 }
403 file++;
404 }
405 }
406
407 void config_rf_write(char type)
408 {
409 const T_CONFIG_FILE *file = config_files_common;
410
411 while (file->name != NULL)
412 {
413 if (type == '*' || type == file->name[0]) {
414 ffs_fwrite(&file->name[1], file->addr, file->size);
415 }
416 file++;
417 }
418 }
419
420 void config_rf_rw_band(char type, UWORD8 read)
421 {
422 const T_CONFIG_FILE *f1 = config_files_band;
423 UWORD8 i;
424 WORD32 offset;
425 char name[64];
426 char *p;
427 UWORD8 std = l1_config.std.id;
428
429 #if FFS_WORKAROUND == 1
430 struct stat_s stat;
431 UWORD16 time;
432 #endif
433 for (i=0; i< GSM_BANDS; i++)
434 {
435 if(std_config[std].band[i] !=0 )
436 {
437 f1 = &config_files_band[0];
438 while (f1->name != NULL)
439 {
440 offset = (WORD32) f1->addr - (WORD32) &rf_band[0]; //offset in bytes
441 p = ((char *) &rf_band[i]) + offset;
442 if (type == '*' || type == f1->name[0])
443 {
444 strcpy(name, &f1->name[1]);
445 strcat(name, ".");
446 strcat(name, band_config[std_config[std].band[i]].name);
447
448 if (read == 1)
449 ffs_fread(name, p, f1->size);
450 else //write == 0
451 {
452 ffs_fwrite(name, p, f1->size);
453
454 // wait until ffs write has finished
455 #if FFS_WORKAROUND == 1
456 stat.inode = 0;
457 time = 0;
458
459 do {
460 rvf_delay(10); // in milliseconds
461 time += 10;
462 ffs_stat(name, &stat);
463 } while (stat.inode == 0 && time < 500);
464 #endif
465 }
466 }
467 f1++;
468 }
469 }
470 }
471 }
472
473 /*-------------------------------------------------------*/
474 /* Cust_init_std() */
475 /*-------------------------------------------------------*/
476 /* Parameters : */
477 /* Return : */
478 /* Functionality : Init Standard variable configuration */
479 /*-------------------------------------------------------*/
480 void Cust_init_std(void)
481 {
482 UWORD8 std = l1_config.std.id;
483 UWORD8 band1, band2;
484 T_RF_BAND *pt1, *pt2;
485
486 band1 = std_config[std].band[0];
487 band2 = std_config[std].band[1];
488
489 //get these from std
490 pt1 = band_config[band1].addr;
491 pt2 = band_config[band2].addr;
492
493 // copy rf-struct from default flash to ram
494 memcpy(&rf_band[0], pt1, sizeof(T_RF_BAND));
495
496 if(std_config[std].band[1] != BAND_NONE )
497 memcpy(&rf_band[1], pt2, sizeof(T_RF_BAND));
498
499 // Read all RF and system configuration from FFS *before* we copy any of
500 // the rf structure variables to other places, like L1.
501
502 config_ffs_read('*');
503
504 l1_config.std.first_radio_freq = std_config[std].first_arfcn;
505
506 if(band2!=0)
507 l1_config.std.first_radio_freq_band2 = band_config[band1].max_carrier + 1;
508 else
509 l1_config.std.first_radio_freq_band2 = 0; //band1 carrier + 1 else 0
510
511 // if band2 is not used it is initialised with zeros
512 l1_config.std.nbmax_carrier = band_config[band1].max_carrier;
513 if(band2!=0)
514 l1_config.std.nbmax_carrier += band_config[band2].max_carrier;
515
516 l1_config.std.max_txpwr_band1 = band_config[band1].max_txpwr;
517 l1_config.std.max_txpwr_band2 = band_config[band2].max_txpwr;
518 l1_config.std.txpwr_turning_point = std_config[std].txpwr_tp;
519 l1_config.std.cal_freq1_band1 = 0;
520 l1_config.std.cal_freq1_band2 = 0;
521
522 l1_config.std.g_magic_band1 = rf_band[MULTI_BAND1].rx.rx_cal_params.g_magic;
523 l1_config.std.lna_att_band1 = rf_band[MULTI_BAND1].rx.rx_cal_params.lna_att;
524 l1_config.std.lna_switch_thr_low_band1 = rf_band[MULTI_BAND1].rx.rx_cal_params.lna_switch_thr_low;
525 l1_config.std.lna_switch_thr_high_band1 = rf_band[MULTI_BAND1].rx.rx_cal_params.lna_switch_thr_high;
526 l1_config.std.swap_iq_band1 = rf_band[MULTI_BAND1].swap_iq;
527
528 l1_config.std.g_magic_band2 = rf_band[MULTI_BAND2].rx.rx_cal_params.g_magic;
529 l1_config.std.lna_att_band2 = rf_band[MULTI_BAND2].rx.rx_cal_params.lna_att;
530 l1_config.std.lna_switch_thr_low_band2 = rf_band[MULTI_BAND2].rx.rx_cal_params.lna_switch_thr_low;
531 l1_config.std.lna_switch_thr_high_band2 = rf_band[MULTI_BAND2].rx.rx_cal_params.lna_switch_thr_high;
532 l1_config.std.swap_iq_band2 = rf_band[MULTI_BAND2].swap_iq;
533
534 l1_config.std.radio_freq_index_offset = l1_config.std.first_radio_freq-1;
535
536 // init variable indicating which radio bands are supported by the chosen RF
537 l1_config.std.radio_band_support = rf.radio_band_support;
538 }
539
540
541 /*-------------------------------------------------------*/
542 /* Cust_init_params() */
543 /*-------------------------------------------------------*/
544 /* Parameters : */
545 /* Return : */
546 /* Functionality : Init RF dependent paramters (AGC, TX) */
547 /*-------------------------------------------------------*/
548 void Cust_init_params(void)
549 {
550
551 #if (CODE_VERSION==SIMULATION)
552 extern UWORD16 simu_RX_SYNTH_SETUP_TIME; // set in xxx.txt l3 scenario file
553 extern UWORD16 simu_TX_SYNTH_SETUP_TIME; // set in xxx.txt l3 scenario file
554
555 l1_config.params.rx_synth_setup_time = simu_RX_SYNTH_SETUP_TIME;
556 l1_config.params.tx_synth_setup_time = simu_TX_SYNTH_SETUP_TIME;
557 #else
558 l1_config.params.rx_synth_setup_time = RX_SYNTH_SETUP_TIME;
559 l1_config.params.tx_synth_setup_time = TX_SYNTH_SETUP_TIME;
560 #endif
561
562
563 // Convert SYNTH_SETUP_TIME into SPLIT.
564 // We have kept a margin of 20qbit (EPSILON_MEAS) to cover offset change and Scenario closing time + margin.
565 l1_config.params.rx_synth_load_split = 1L + (l1_config.params.rx_synth_setup_time + EPSILON_MEAS) / (BP_DURATION/BP_SPLIT);
566 l1_config.params.tx_synth_load_split = 1L + (l1_config.params.tx_synth_setup_time + EPSILON_MEAS) / (BP_DURATION/BP_SPLIT);
567
568 l1_config.params.rx_synth_start_time = TPU_CLOCK_RANGE + PROVISION_TIME - l1_config.params.rx_synth_setup_time;
569 l1_config.params.tx_synth_start_time = TPU_CLOCK_RANGE - l1_config.params.tx_synth_setup_time;
570
571 l1_config.params.rx_change_synchro_time = l1_config.params.rx_synth_start_time - EPSILON_SYNC;
572 l1_config.params.rx_change_offset_time = l1_config.params.rx_synth_start_time - EPSILON_OFFS;
573
574 l1_config.params.tx_change_offset_time = TIME_OFFSET_TX -
575 TA_MAX -
576 l1_config.params.tx_synth_setup_time -
577 EPSILON_OFFS;
578
579 // TX duration = ramp up time + burst duration (data + tail bits)
580 l1_config.params.tx_nb_duration = UL_ABB_DELAY + rf.tx.guard_bits*4 + NB_BURST_DURATION_UL;
581 l1_config.params.tx_ra_duration = UL_ABB_DELAY + rf.tx.guard_bits*4 + RA_BURST_DURATION;
582
583 l1_config.params.tx_nb_load_split = 1L + (l1_config.params.tx_nb_duration - rf.tx.prg_tx - NB_MARGIN) / (BP_DURATION/BP_SPLIT);
584 l1_config.params.tx_ra_load_split = 1L + (l1_config.params.tx_ra_duration - rf.tx.prg_tx - NB_MARGIN) / (BP_DURATION/BP_SPLIT);
585
586 // time for the end of RX and TX TPU scenarios
587 l1_config.params.rx_tpu_scenario_ending = RX_TPU_SCENARIO_ENDING;
588 l1_config.params.tx_tpu_scenario_ending = TX_TPU_SCENARIO_ENDING;
589
590 // FB26 anchoring time is computed backward to leave only 6 qbit margin between
591 // FB26 window and next activity (RX time tracking).
592 // This margin is used as follow:
593 // Serving offset restore: 1 qbit (SERV_OFFS_REST_LOAD)
594 // Tpu Sleep: 2 qbit (TPU_SLEEP_LOAD)
595 // ---------
596 // Total: 3 qbit
597
598 l1_config.params.fb26_anchoring_time = (l1_config.params.rx_synth_start_time -
599 #if (CODE_VERSION == SIMULATION)
600 // simulator: end of scenario not included in window (no serialization)
601 1 -
602 #else
603 // RF dependent end of RX TPU scenario
604 l1_config.params.rx_tpu_scenario_ending -
605 #endif
606 EPSILON_SYNC -
607 TPU_SLEEP_LOAD -
608 SERV_OFFS_REST_LOAD -
609 FB26_ACQUIS_DURATION -
610 PROVISION_TIME +
611 TPU_CLOCK_RANGE) % TPU_CLOCK_RANGE;
612
613 l1_config.params.fb26_change_offset_time = l1_config.params.fb26_anchoring_time +
614 PROVISION_TIME -
615 l1_config.params.rx_synth_setup_time -
616 EPSILON_OFFS;
617
618 l1_config.params.guard_bits = rf.tx.guard_bits;
619
620 l1_config.params.prg_tx_gsm = rf.tx.prg_tx;
621 l1_config.params.prg_tx_dcs = rf.tx.prg_tx; //delay for dual band not implemented yet
622
623 l1_config.params.low_agc_noise_thr = rf.rx.agc.low_agc_noise_thr;
624 l1_config.params.high_agc_sat_thr = rf.rx.agc.high_agc_sat_thr;
625 l1_config.params.low_agc = rf.rx.agc.low_agc;
626 l1_config.params.high_agc = rf.rx.agc.high_agc;
627 l1_config.params.il_min = IL_MIN;
628
629 l1_config.params.fixed_txpwr = FIXED_TXPWR;
630 l1_config.params.eeprom_afc = rf.afc.eeprom_afc;
631 l1_config.params.setup_afc_and_rf = SETUP_AFC_AND_RF;
632
633 l1_config.params.psi_sta_inv = rf.afc.psi_sta_inv;
634 l1_config.params.psi_st = rf.afc.psi_st;
635 l1_config.params.psi_st_32 = rf.afc.psi_st_32;
636 l1_config.params.psi_st_inv = rf.afc.psi_st_inv;
637
638 #if (CODE_VERSION == SIMULATION)
639 #if (VCXO_ALGO == 1)
640 l1_config.params.afc_algo = ALGO_AFC_LQG_PREDICTOR; // VCXO|VCTCXO - Choosing AFC algorithm
641 #endif
642 #else
643 #if (VCXO_ALGO == 1)
644 l1_config.params.afc_dac_center = rf.afc.dac_center; // VCXO - assuming DAC linearity
645 l1_config.params.afc_dac_min = rf.afc.dac_min; // VCXO - assuming DAC linearity
646 l1_config.params.afc_dac_max = rf.afc.dac_max; // VCXO - assuming DAC linearity
647 l1_config.params.afc_snr_thr = rf.afc.snr_thr; // VCXO - SNR threshold
648 l1_config.params.afc_algo = ALGO_AFC_LQG_PREDICTOR; // VCXO|VCTCXO - Choosing AFC algorithm
649 l1_config.params.afc_win_avg_size_M = C_WIN_AVG_SIZE_M; // VCXO - Average psi values with this value
650 l1_config.params.rgap_algo = ALGO_AFC_RXGAP; // VCXO - Choosing Reception Gap algorithm
651 l1_config.params.rgap_bad_snr_count_B = C_RGAP_BAD_SNR_COUNT_B; // VCXO - Prediction SNR count
652 #endif
653 #endif
654
655 #if DCO_ALGO
656 #if (RF == 10)
657 // Enable DCO algorithm for direct conversion RFs
658 l1_config.params.dco_enabled = TRUE;
659 #else
660 l1_config.params.dco_enabled = FALSE;
661 #endif
662 #endif
663
664 #if (ANLG_FAM == 1)
665 l1_config.params.debug1 = C_DEBUG1; // Enable f_tx delay of 400000 cyc DEBUG
666 l1_config.params.afcctladd = abb[ABB_AFCCTLADD]; // Value at reset
667 l1_config.params.vbuctrl = abb[ABB_VBUCTRL]; // Uplink gain amp 0dB, Sidetone gain to mute
668 l1_config.params.vbdctrl = abb[ABB_VBDCTRL]; // Downlink gain amp 0dB, Volume control 0 dB
669 l1_config.params.bbctrl = abb[ABB_BBCTRL]; // value at reset
670 l1_config.params.apcoff = abb[ABB_APCOFF]; // value at reset
671 l1_config.params.bulioff = abb[ABB_BULIOFF]; // value at reset
672 l1_config.params.bulqoff = abb[ABB_BULQOFF]; // value at reset
673 l1_config.params.dai_onoff = abb[ABB_DAI_ON_OFF]; // value at reset
674 l1_config.params.auxdac = abb[ABB_AUXDAC]; // value at reset
675 l1_config.params.vbctrl = abb[ABB_VBCTRL]; // VULSWITCH=0, VDLAUX=1, VDLEAR=1
676 l1_config.params.apcdel1 = abb[ABB_APCDEL1]; // value at reset
677 #endif
678 #if (ANLG_FAM == 2)
679 l1_config.params.debug1 = C_DEBUG1; // Enable f_tx delay of 400000 cyc DEBUG
680 l1_config.params.afcctladd = abb[ABB_AFCCTLADD]; // Value at reset
681 l1_config.params.vbuctrl = abb[ABB_VBUCTRL]; // Uplink gain amp 0dB, Sidetone gain to mute
682 l1_config.params.vbdctrl = abb[ABB_VBDCTRL]; // Downlink gain amp 0dB, Volume control 0 dB
683 l1_config.params.bbctrl = abb[ABB_BBCTRL]; // value at reset
684 l1_config.params.bulgcal = abb[ABB_BULGCAL]; // value at reset
685 l1_config.params.apcoff = abb[ABB_APCOFF]; // value at reset
686 l1_config.params.bulioff = abb[ABB_BULIOFF]; // value at reset
687 l1_config.params.bulqoff = abb[ABB_BULQOFF]; // value at reset
688 l1_config.params.dai_onoff = abb[ABB_DAI_ON_OFF]; // value at reset
689 l1_config.params.auxdac = abb[ABB_AUXDAC]; // value at reset
690 l1_config.params.vbctrl1 = abb[ABB_VBCTRL1]; // VULSWITCH=0, VDLAUX=1, VDLEAR=1
691 l1_config.params.vbctrl2 = abb[ABB_VBCTRL2]; // MICBIASEL=0, VDLHSO=0, MICAUX=0
692 l1_config.params.apcdel1 = abb[ABB_APCDEL1]; // value at reset
693 l1_config.params.apcdel2 = abb[ABB_APCDEL2]; // value at reset
694 #endif
695 #if (ANLG_FAM == 3)
696 l1_config.params.debug1 = C_DEBUG1; // Enable f_tx delay of 400000 cyc DEBUG
697 l1_config.params.afcctladd = abb[ABB_AFCCTLADD]; // Value at reset
698 l1_config.params.vbuctrl = abb[ABB_VBUCTRL]; // Uplink gain amp 0dB, Sidetone gain to mute
699 l1_config.params.vbdctrl = abb[ABB_VBDCTRL]; // Downlink gain amp 0dB, Volume control 0 dB
700 l1_config.params.bbctrl = abb[ABB_BBCTRL]; // value at reset
701 l1_config.params.bulgcal = abb[ABB_BULGCAL]; // value at reset
702 l1_config.params.apcoff = abb[ABB_APCOFF]; // X2 Slope 128 and APCSWP disabled
703 l1_config.params.bulioff = abb[ABB_BULIOFF]; // value at reset
704 l1_config.params.bulqoff = abb[ABB_BULQOFF]; // value at reset
705 l1_config.params.dai_onoff = abb[ABB_DAI_ON_OFF]; // value at reset
706 l1_config.params.auxdac = abb[ABB_AUXDAC]; // value at reset
707 l1_config.params.vbctrl1 = abb[ABB_VBCTRL1]; // VULSWITCH=0
708 l1_config.params.vbctrl2 = abb[ABB_VBCTRL2]; // MICBIASEL=0, VDLHSO=0, MICAUX=0
709 l1_config.params.apcdel1 = abb[ABB_APCDEL1]; // value at reset
710 l1_config.params.apcdel2 = abb[ABB_APCDEL2]; // value at reset
711 l1_config.params.vbpop = abb[ABB_VBPOP]; // HSOAUTO enabled
712 l1_config.params.vau_delay_init = abb[ABB_VAUDINITD]; // 2 TDMA Frames between VDL "ON" and VDLHSO "ON"
713 l1_config.params.vaud_cfg = abb[ABB_VAUDCTRL]; // value at reset
714 l1_config.params.vauo_onoff = abb[ABB_VAUOCTRL]; // speech on AUX and EAR
715 l1_config.params.vaus_vol = abb[ABB_VAUSCTRL]; // value at reset
716 l1_config.params.vaud_pll = abb[ABB_VAUDPLL]; // value at reset
717 #endif
718
719 #if 0 /* present in MV100 version, but not in TCS211 */
720 // global variable for access to deep sleep time
721 l1_config.params.sleep_time = 0;
722 #endif
723 }
724
725
726 /************************************/
727 /* Automatic Gain Control */
728 /************************************/
729
730 /*-------------------------------------------------------*/
731 /* Cust_get_agc_from_IL() */
732 /*-------------------------------------------------------*/
733 /* Parameters : */
734 /* Return : */
735 /* Functionality : returns agc value */
736 /*-------------------------------------------------------*/
737 WORD8 Cust_get_agc_from_IL(UWORD16 radio_freq, UWORD16 agc_index, UWORD8 table_id)
738 {
739 WORD8 agc_value;
740
741 // radio_freq currently not used
742 // this parameter is passed in order to allow band dependent tables for specific RFs
743 // (e.g. dual band RF with separate AGC H/W blocks for GSM and DCS)
744
745 if (agc_index > 120)
746 agc_index = 120; // Clip agc_index
747
748 switch (table_id)
749 {
750 case MAX_ID:
751 agc_value = rf.rx.agc.il2agc_max[agc_index];
752 break;
753 case AV_ID:
754 agc_value = rf.rx.agc.il2agc_av[agc_index];
755 break;
756 case PWR_ID:
757 agc_value = rf.rx.agc.il2agc_pwr[agc_index];
758 break;
759 }
760
761 return agc_value;
762 }
763
764 /*-------------------------------------------------------*/
765 /* Cust_get_agc_band */
766 /*-------------------------------------------------------*/
767 /* Parameters : radio_freq */
768 /* Return : band number */
769 /* Functionality : Computes the band for RF calibration */
770 /*-------------------------------------------------------*/
771 /*---------------------------------------------*/
772
773
774 #if (CODE_VERSION == SIMULATION)
775 UWORD16 Cust_get_agc_band(UWORD16 arfcn, UWORD8 gsm_band)
776 #else
777 UWORD16 inline Cust_get_agc_band(UWORD16 arfcn, UWORD8 gsm_band)
778 #endif
779 {
780 WORD32 i ;
781
782 for (i=0;i<RF_RX_CAL_CHAN_SIZE;i++)
783 {
784 if (arfcn <= rf_band[gsm_band].rx.agc_bands[i].upper_bound)
785 return(i);
786 }
787 // Should never happen!
788 return(0);
789 }
790
791 /*-------------------------------------------------------*/
792 /* Cust_is_band_high */
793 /*-------------------------------------------------------*/
794 /* Parameters : arfcn */
795 /* Return : 0 if low band */
796 /* 1 if high band */
797 /* Functionality : Generic function which return 1 if */
798 /* arfcn is in the high band */
799 /*-------------------------------------------------------*/
800
801 UWORD8 Cust_is_band_high(UWORD16 radio_freq)
802 {
803 UWORD16 max_carrier;
804 UWORD8 std = l1_config.std.id;
805
806 max_carrier = band_config[std_config[std].band[0]].max_carrier;
807
808 return(((radio_freq >= l1_config.std.first_radio_freq) &&
809 (radio_freq < (l1_config.std.first_radio_freq + max_carrier))) ? MULTI_BAND1 : MULTI_BAND2);
810 }
811
812 /*-------------------------------------------------------*/
813 /* l1ctl_encode_delta2() */
814 /*-------------------------------------------------------*/
815 /* Parameters : */
816 /* Return : */
817 /* Functionality : */
818 /*-------------------------------------------------------*/
819 WORD8 l1ctl_encode_delta2(UWORD16 radio_freq)
820 {
821 WORD8 delta2_freq;
822 UWORD16 i;
823 UWORD16 arfcn;
824 UWORD8 band;
825
826 band = Cust_is_band_high(radio_freq);
827 arfcn = Convert_l1_radio_freq(radio_freq);
828
829 i = Cust_get_agc_band(arfcn,band); //
830 delta2_freq = rf_band[band].rx.agc_bands[i].agc_calib;
831
832 //temperature compensation
833 for (i=0;i<RF_RX_CAL_TEMP_SIZE;i++)
834 {
835 if ((WORD16)adc.converted[ADC_RFTEMP] <= rf_band[band].rx.temp[i].temperature)
836 {
837 delta2_freq += rf_band[band].rx.temp[i].agc_calib;
838 break;
839 }
840 }
841
842 return(delta2_freq);
843 }
844
845 /************************************/
846 /* TX Management */
847 /************************************/
848 /*-------------------------------------------------------*/
849 /* Cust_get_ramp_tab */
850 /*-------------------------------------------------------*/
851 /* Parameters : */
852 /* Return : */
853 /* Functionality : */
854 /*-------------------------------------------------------*/
855
856 void Cust_get_ramp_tab(API *a_ramp, UWORD8 txpwr_ramp_up, UWORD8 txpwr_ramp_down, UWORD16 radio_freq)
857 {
858 UWORD16 index_up, index_down, j;
859 UWORD8 band;
860
861 band = Cust_is_band_high(radio_freq);
862
863 index_up = rf_band[band].tx.levels[txpwr_ramp_up].ramp_index;
864 index_down = rf_band[band].tx.levels[txpwr_ramp_down].ramp_index;
865
866 #if ((ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3))
867 for (j=0; j<16; j++)
868 {
869 a_ramp[j]=((rf_band[band].tx.ramp_tables[index_down].ramp_down[j])<<11) |
870 ((rf_band[band].tx.ramp_tables[index_up].ramp_up[j]) << 6) |
871 0x14;
872 }
873 #endif
874 }
875
876 /*-------------------------------------------------------*/
877 /* get_pwr_data */
878 /*-------------------------------------------------------*/
879 /* Parameters : */
880 /* Return : */
881 /* Functionality : */
882 /*-------------------------------------------------------*/
883
884 #if ((ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3))
885 UWORD16 Cust_get_pwr_data(UWORD8 txpwr, UWORD16 radio_freq)
886 {
887
888 UWORD16 i,j;
889 UWORD16 arfcn;
890 UWORD8 band;
891
892 #if(ORDER2_TX_TEMP_CAL==1)
893 WORD16 pwr_data;
894 #else
895 UWORD16 pwr_data;
896 #endif
897
898 band = Cust_is_band_high(radio_freq);
899 arfcn = Convert_l1_radio_freq(radio_freq);
900
901 i = rf_band[band].tx.levels[txpwr].chan_cal_index;
902 j=0;
903 // get uncalibrated apc
904 pwr_data = rf_band[band].tx.levels[txpwr].apc;
905
906 while (arfcn > rf_band[band].tx.chan_cal_table[i][j].arfcn_limit)
907 j++;
908
909 // channel calibrate apc
910 pwr_data = ((UWORD32) (pwr_data * rf_band[band].tx.chan_cal_table[i][j].chan_cal))/128;
911
912 // temperature compensate apc
913 {
914 T_TX_TEMP_CAL *pt;
915
916 pt = rf_band[band].tx.temp;
917 while (((WORD16)adc.converted[ADC_RFTEMP] > pt->temperature) && ((pt-rf_band[band].tx.temp) < (RF_TX_CAL_TEMP_SIZE-1)))
918 pt++;
919 #if(ORDER2_TX_TEMP_CAL==1)
920 pwr_data += (txpwr*(pt->a*txpwr + pt->b) + pt->c) / 64; //delta apc = ax^2+bx+c
921 if(pwr_data < 0) pwr_data = 0;
922 #else
923 pwr_data += pt->apc_calib;
924 #endif
925 }
926 return(pwr_data);
927 }
928 #endif
929 /*-------------------------------------------------------*/
930 /* Cust_Init_Layer1 */
931 /*-------------------------------------------------------*/
932 /* Parameters : */
933 /* Return : */
934 /* Functionality : Load and boot the DSP */
935 /* Initialize shared memory and L1 data structures */
936 /*-------------------------------------------------------*/
937
938 void Cust_Init_Layer1(void)
939 {
940 T_MMI_L1_CONFIG cfg;
941
942 // Get the current band configuration from the flash
943 #if (OP_WCP==1)
944 extern unsigned char ffs_GetBand();
945 cfg.std = ffs_GetBand();
946 #else // NO OP_WCP
947 // cfg.std = std;
948 cfg.std = STD;
949 #endif // OP_WCP
950
951 cfg.tx_pwr_code = 1;
952
953 // sleep management configuration
954 cfg.pwr_mngt = 0;
955 cfg.pwr_mngt_mode_authorized = NO_SLEEP; //Sleep mode
956 cfg.pwr_mngt_clocks = 0x5ff; // list of clocks cut in Big Sleep
957
958
959
960 #if (CODE_VERSION != SIMULATION)
961 cfg.dwnld = DWNLD; //external define from makefile
962 #endif
963
964 l1_initialize(&cfg);
965
966 get_cal_from_nvmem((UWORD8 *)&rf, sizeof(rf), RF_ID);
967 get_cal_from_nvmem((UWORD8 *)&adc_cal, sizeof(adc_cal), ADC_ID);
968
969 }
970
971
972 /******************************************************************************/
973 /********************* TESTMODE functions *****************************/
974 /******************************************************************************/
975
976
977
978 /*------------------------------------------------------*/
979 /* madc_hex_2_physical */
980 /*------------------------------------------------------*/
981 /* Parameters : */
982 /* Return : */
983 /* Functionality : Function to convert MAD hexadecimal */
984 /* values into physical values */
985 /*------------------------------------------------------*/
986
987 void madc_hex_2_physical (UWORD16 *adc_hex, T_ADC *adc_phy)
988 {
989 WORD16 i;
990 UWORD16 y;
991 WORD16 Smin = 0, Smax = TEMP_TABLE_SIZE-1;
992 WORD16 index = (TEMP_TABLE_SIZE-1)/2; /* y is the adc code after compensation of ADC slope error introduced by VREF error */
993
994 //store raw ADC values
995 memcpy(&adc.raw[0], adc_hex, sizeof(adc.raw));
996
997 // Convert Vbat [mV] : direct equation with slope and offset compensation
998 for (i = ADC_VBAT; i<ADC_RFTEMP; i++)
999 adc.converted[i] = (((UWORD32)(adc_cal.a[i] * adc.raw[i])) >>10) + adc_cal.b[i];
1000
1001 /*Convert RF Temperature [Celsius]: binsearch into a table*/
1002 y = ((UWORD32)(adc_cal.a[ADC_RFTEMP] * adc.raw[ADC_RFTEMP]))>>8; /* rf.tempcal is the calibration of VREF*/
1003 while((Smax-Smin) > 1 )
1004 {
1005 if(y < temperature[index].adc)
1006 Smax=index;
1007 else
1008 Smin=index;
1009
1010 index = (Smax+Smin)/2;
1011 }
1012 adc.converted[ADC_RFTEMP] = temperature[index].temp;
1013
1014 for (i = ADC_RFTEMP+1; i<ADC_INDEX_END; i++)
1015 adc.converted[i] = (((UWORD32)(adc_cal.a[i] * adc.raw[i])) >>10) + adc_cal.b[i];
1016
1017 //store converted ADC values
1018 memcpy(adc_phy, &adc.converted[0], sizeof(adc.raw));
1019 }
1020
1021 /*
1022 * FreeCalypso: the following two functions have been added
1023 * to support the new battery charging code.
1024 */
1025
1026 UWORD16 madc_vbat_2_physical (UWORD16 adc_val)
1027 {
1028 return (((UWORD32)(adc_cal.a[ADC_VBAT] * adc_val)) >> 10) +
1029 adc_cal.b[ADC_VBAT];
1030 }
1031
1032 UWORD16 madc_vbat_inverse (UWORD16 mv)
1033 {
1034 return ((UWORD32)(mv - adc_cal.b[ADC_VBAT]) << 10) / adc_cal.a[ADC_VBAT];
1035 }
1036
1037 /*------------------------------------------------------*/
1038 /* get_cal_from_nvmem */
1039 /*------------------------------------------------------*/
1040 /* Parameters : */
1041 /* Return : */
1042 /* Functionality : Copy calibrated parameter to */
1043 /* calibration structure in RAM */
1044 /*------------------------------------------------------*/
1045
1046 void get_cal_from_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id)
1047 {
1048
1049 }
1050
1051 /*------------------------------------------------------*/
1052 /* save_cal_from_nvmem */
1053 /*------------------------------------------------------*/
1054 /* Parameters : */
1055 /* Return : */
1056 /* Functionality : Copy calibrated structure from RAM */
1057 /* into NV memory */
1058 /*------------------------------------------------------*/
1059
1060 UWORD8 save_cal_in_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id)
1061 {
1062 #if (OP_WCP == 1)
1063 // FFS backup implementation an Avenger 2
1064 // Request MPU-S to backup the FFS
1065 // after full calibration of device
1066 extern void ffs_backup(void);
1067 ffs_backup();
1068 #endif
1069 return (0);
1070 }
1071
1072 #if (TRACE_TYPE == 4)
1073
1074 /*------------------------------------------------------*/
1075 /* l1_cst_l1_parameters */
1076 /*------------------------------------------------------*/
1077 /* Parameters : s: pointer on configuration string */
1078 /* Return : nothing: global var are set */
1079 /* Functionality : Set global L1 vars for dynamic trace */
1080 /* and configuration */
1081 /* */
1082 /* This function is called when a CST message is sent */
1083 /* from the Condat Panel. */
1084 /*------------------------------------------------------*/
1085 void l1_cst_l1_parameters(char *s)
1086 {
1087 /*
1088 a sample command string can be:
1089 L1_PARAMS=<1,2,3,4,5> or
1090 L1_PARAMS=<1,23,3E32,4,5>
1091 with n parameters (here: 5 params); n>=1
1092 parameters are decoded as hexadecimal unsigned integers (UWORD16)
1093 */
1094
1095 UWORD8 uNParams = 0; /* Number of parameters */
1096 UWORD32 aParam[10]; /* Parameters array */
1097 UWORD8 uIndex = 0;
1098
1099 /* *** retrieve all parameters *** */
1100 while (s[uIndex] != '<') uIndex++;
1101 uIndex++;
1102 aParam[0] = 0;
1103
1104 /* uIndex points on 1st parameter */
1105
1106 while (s[uIndex] != '>')
1107 {
1108 if (s[uIndex] == ',')
1109 {
1110 uNParams++;
1111 aParam[uNParams] = 0;
1112 }
1113 else
1114 {
1115 /* uIndex points on a parameter char */
1116 UWORD8 uChar = s[uIndex];
1117 aParam[uNParams] = aParam[uNParams] << 4; /* shift 4 bits left */
1118 if ((uChar>='0') && (uChar<='9'))
1119 aParam[uNParams] += (uChar - '0'); /* retrieve value */
1120 else if ((uChar>='A') && (uChar<='F'))
1121 aParam[uNParams] += (10 + uChar - 'A'); /* retrieve value */
1122 else if ((uChar>='a') && (uChar<='f'))
1123 aParam[uNParams] += (10 + uChar - 'a'); /* retrieve value */
1124 }
1125
1126 uIndex++; /* go to next char */
1127 }
1128
1129 /* increment number of params */
1130 uNParams++;
1131
1132 /* *** handle parameters *** */
1133 /*
1134 1st param: command type
1135 2nd param: argument for command type
1136 */
1137 switch (aParam[0])
1138 {
1139 case 0: /* Trace setting */
1140 /* The 2nd parameter contains the trace bitmap*/
1141 if (uNParams >=2)
1142 trace_info.current_config->l1_dyn_trace = aParam[1];
1143 else
1144 trace_info.current_config->l1_dyn_trace = 0; /* error case: disable all trace */
1145 Trace_dyn_trace_change();
1146 break;
1147 default: /* ignore it */
1148 break;
1149 } // switch
1150 }
1151
1152 #endif
1153
1154 #if ((CHIPSET == 2) || (CHIPSET == 3) || (CHIPSET == 4) || \
1155 (CHIPSET == 5) || (CHIPSET == 6) || (CHIPSET == 7) || \
1156 (CHIPSET == 8) || (CHIPSET == 9) || (CHIPSET == 10) || \
1157 (CHIPSET == 11) || (CHIPSET == 12))
1158 /*-------------------------------------------------------*/
1159 /* power_down_config() : temporary implementation !!! */
1160 /*-------------------------------------------------------*/
1161 /* Parameters : sleep_mode (NO, SMALL, BIG, DEEP or ALL) */
1162 /* clocks to be cut in BIG sleep */
1163 /* Return : */
1164 /* Functionality : set the l1s variables */
1165 /* l1s.pw_mgr.mode_authorized and l1s.pw_mgr.clocks */
1166 /* according to the desired mode. */
1167 /*-------------------------------------------------------*/
1168 void power_down_config(UWORD8 sleep_mode, UWORD16 clocks)
1169 {
1170 #if (OP_L1_STANDALONE == 1)
1171 if(sleep_mode != NO_SLEEP)
1172 #endif
1173 {
1174 l1_config.pwr_mngt = PWR_MNGT;
1175 l1s.pw_mgr.mode_authorized = sleep_mode;
1176 l1s.pw_mgr.clocks = clocks;
1177 }
1178
1179 #if (OP_L1_STANDALONE == 0)
1180 l1s.pw_mgr.enough_gaug = FALSE;
1181 #endif
1182 }
1183 #endif