FreeCalypso > hg > freecalypso-citrine

comparison g23m-gsm/rr/rr_csf.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project :
4 | Modul :
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This module defines the custom specific functions
18 | for the component RR of the mobile station
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef RR_CSF_C
23 #define RR_CSF_C
24
25 #include "config.h"
26 #include "fixedconf.h"
27 #include "condat-features.h"
28
29 #define ENTITY_RR
30 #define SAP_ACI
31
32 /*==== INCLUDES ===================================================*/
33
34 #include <string.h>
35 #include <stdlib.h>
36 #include <stddef.h> /* offsetof */
37 #include "typedefs.h"
38 #include "pcm.h"
39 #include "pconst.cdg"
40 #include "mconst.cdg"
41 #include "message.h"
42 #include "ccdapi.h"
43 #include "vsi.h"
44 #include "custom.h"
45 #include "gsm.h"
46 #include "prim.h"
47 #include "cnf_rr.h"
48 #include "tok.h"
49 #include "rr.h"
50 #include "cl_imei.h" /* IMEI common library */
51 #if defined(_SIMULATION_FFS_)
52 #include "../../services/ffs/ffs.h"
53 #include "ffs_coat.h"
54 #endif /* _SIMULATION_FFS_ */
55
56 /*==== EXPORT =====================================================*/
57
58 /*==== PRIVAT =====================================================*/
59 #if defined(_SIMULATION_FFS_)
60 LOCAL BOOL rr_csf_handle_ffs_read_result(T_FFS_SIZE status_read);
61 LOCAL BOOL rr_csf_handle_ffs_write_result(T_FFS_RET status_write);
62 LOCAL void rr_csf_check_ffs_dirs( void );
63 LOCAL void rr_csf_create_ffs_dirs(const char *dir_name);
64 #endif /* _SIMULATION_FFS_ */
65
66
67
68 /*==== VARIABLES ==================================================*/
69 /* Cell selection improvements LLD section 4.1.1.1 */
70 #if defined(_SIMULATION_)
71 T_LIST win_black_list[MAX_REGIONS]; /* Simulates FFS for "Black List" */
72 T_CS_WHITE_LIST win_white_list; /* Simulates FFS for "White List */
73
74 /*Simulates FFS for lower rxlevel thresholds*/
75 UBYTE win_lower_rxlev_thr[MAX_NUM_BANDS] = { LOWER_RXLEV_THRESHOLD_850, LOWER_RXLEV_THRESHOLD, \
76 LOWER_RXLEV_THRESHOLD, LOWER_RXLEV_THRESHOLD, LOWER_RXLEV_THRESHOLD };
77 /*Simulates FFS for medium rxlevel thresholds*/
78 UBYTE win_medium_rxlev_thr[MAX_NUM_BANDS] = { MEDIUM_RXLEV_THRESHOLD, MEDIUM_RXLEV_THRESHOLD, \
79 MEDIUM_RXLEV_THRESHOLD, MEDIUM_RXLEV_THRESHOLD, MEDIUM_RXLEV_THRESHOLD };
80 /*Simulates FFS for upper rxlevel thresholds*/
81 UBYTE win_upper_rxlev_thr[MAX_NUM_BANDS] = { UPPER_RXLEV_THRESHOLD, UPPER_RXLEV_THRESHOLD, \
82 UPPER_RXLEV_THRESHOLD, UPPER_RXLEV_THRESHOLD, UPPER_RXLEV_THRESHOLD };
83 /* Initialize the simulated rxlevel thresholds here itself */
84 #endif
85
86 /*
87 +--------------------------------------------------------------------+
88 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
89 | STATE : code ROUTINE : rr_csf_read_imei |
90 +--------------------------------------------------------------------+
91
92 PURPOSE : The function reads the International mobile identity number
93 from the non-volantile memory into an internal data structure.
94
95 */
96
97 GLOBAL void rr_csf_read_imei (T_mob_ident *imei)
98 {
99 UBYTE buf[CL_IMEI_SIZE];
100
101 TRACE_FUNCTION ("rr_csf_read_imei()");
102
103 imei->v_ident_dig = TRUE;
104 imei->v_tmsi_1 = FALSE;
105 imei->ident_type = 3; /* set to TYPE_IMEISV */
106 imei->c_ident_dig = 16;
107 imei->odd_even = 0;
108
109 /* Get IMEISV from IMEI common library */
110 cl_get_imeisv(CL_IMEI_SIZE, buf, CL_IMEI_GET_SECURE_IMEI);
111
112 /* copy digits */
113 imei->ident_dig[0] = (buf [0] >> 4) & 0x0F; /* TAC 8 byte */
114 imei->ident_dig[1] = buf [0] & 0x0F;
115 imei->ident_dig[2] = (buf [1] >> 4) & 0x0F;
116 imei->ident_dig[3] = buf [1] & 0x0F;
117 imei->ident_dig[4] = (buf [2] >> 4) & 0x0F;
118 imei->ident_dig[5] = buf [2] & 0x0F;
119 imei->ident_dig[6] = (buf [3] >> 4) & 0x0F;
120 imei->ident_dig[7] = buf [3] & 0x0F;
121 imei->ident_dig[8] = (buf [4] >> 4) & 0x0F; /* SNR 6 byte */
122 imei->ident_dig[9] = buf [4] & 0x0F;
123 imei->ident_dig[10]= (buf [5] >> 4) & 0x0F;
124 imei->ident_dig[11]= buf [5] & 0x0F;
125 imei->ident_dig[12]= (buf [6] >> 4) & 0x0F;
126 imei->ident_dig[13]= buf [6] & 0x0F;
127 imei->ident_dig[14]= (buf [7] >> 4) & 0x0F; /* SV 2 byte */
128 imei->ident_dig[15]= buf [7] & 0x0F;
129
130 TRACE_EVENT_P8("RR INFO IMEI: TAC %1x%1x%1x%1x%1x%1x%1x%1x",
131 imei->ident_dig[0], imei->ident_dig[1], imei->ident_dig[2],
132 imei->ident_dig[3], imei->ident_dig[4], imei->ident_dig[5],
133 imei->ident_dig[6], imei->ident_dig[7]);
134 TRACE_EVENT_P6("RR INFO IMEI: SNR %1x%1x%1x%1x%1x%1x",
135 imei->ident_dig[8], imei->ident_dig[9], imei->ident_dig[10],
136 imei->ident_dig[11], imei->ident_dig[12], imei->ident_dig[13]);
137 TRACE_EVENT_P2("RR INFO IMEI: SV %1x%1x", imei->ident_dig[14],
138 imei->ident_dig[15]);
139 }
140
141 #if !defined(NTRACE)
142 GLOBAL void rr_csf_trace_power (void)
143 {
144 GET_INSTANCE_DATA;
145 UBYTE setbands = rr_data->ms_data.rf_cap.setbands;
146 UBYTE bands = rr_data->ms_data.rf_cap.bands;
147 UBYTE stdbands;
148
149 if (setbands EQ 0)
150 {
151 setbands = bands; /* auto detection, use all supported bands */
152 }
153 else
154 setbands &= bands;/* bands set, use only supported bands */
155
156 /* bands which might be supported with current std */
157 stdbands = std_bands[std-1];
158
159 TRACE_EVENT_P5 ("std=%d(%02x), (set)bands=%02x(%02x)->%02x",
160 std, stdbands, rr_data->ms_data.rf_cap.setbands,
161 rr_data->ms_data.rf_cap.bands, setbands);
162 TRACE_EVENT_P6 ("%sGSM 900: power class=%u %s,%s%s%s",
163 (bands&0x08)?"E":" ",
164 rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_900].pow_class,
165 (bands&0x09)?"rfcap":" ",
166 (stdbands&0x09)?"std":" ",
167 (setbands&0x09)?",supported":"",
168 ((setbands&0x09) AND (setbands&0x09) EQ 0x01)?" (only GSM)":"");
169 TRACE_EVENT_P4 ("DCS 1800: power class=%u %s,%s%s",
170 rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class,
171 (bands&0x02)?"rfcap":" ",
172 (stdbands&0x02)?"std":" ",
173 (setbands&0x02)?",supported":"");
174 TRACE_EVENT_P4 ("PCS 1900: power class=%u %s,%s%s",
175 rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class,
176 (bands&0x04)?"rfcap":" ",
177 (stdbands&0x04)?"std":" ",
178 (setbands&0x04)?",supported":"");
179 TRACE_EVENT_P4 ("GSM 850: power class=%u %s,%s%s",
180 rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_850].pow_class,
181 (bands&0x10)?"rfcap":" ",
182 (stdbands&0x10)?"std":" ",
183 (setbands&0x10)?",supported":"");
184 TRACE_EVENT_P4 ("GSM 400: power class=%u %s,%s%s",
185 rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_400].pow_class,
186 (bands&0x60)?"rfcap":" ",
187 (stdbands&0x60)?"std":" ",
188 (setbands&0x60)?",supported":"");
189 TRACE_EVENT_P1 ("GPRS multislot class =%u",
190 rr_data->ms_data.rf_cap.rf_ms.gprs_ms_class);
191 }
192 #endif /* !NTRACE */
193
194 #if defined(_SIMULATION_) && !defined(NTRACE)
195 #define TRACE_STRUCT(struct_member) TRACE_EVENT_P1("0x%02x " #struct_member , *((unsigned int*)&struct_member))
196
197 LOCAL void rr_csf_trace_class1 (T_mob_class_1* cm1)
198 {
199 TRACE_STRUCT (cm1->rev_lev);
200 TRACE_STRUCT (cm1->es_ind);
201 TRACE_STRUCT (cm1->a5_1);
202 TRACE_STRUCT (cm1->rf_pow_cap);
203 }
204
205 LOCAL void rr_csf_trace_class2 (T_mob_class_2* cm2)
206 {
207 TRACE_STRUCT (cm2->rev_lev);
208 TRACE_STRUCT (cm2->es_ind);
209 TRACE_STRUCT (cm2->a5_1);
210 TRACE_STRUCT (cm2->rf_pow_cap);
211 TRACE_STRUCT (cm2->ps);
212 TRACE_STRUCT (cm2->ss_screen);
213 TRACE_STRUCT (cm2->mt_pp_sms);
214 TRACE_STRUCT (cm2->vbs);
215 TRACE_STRUCT (cm2->vgcs);
216 TRACE_STRUCT (cm2->egsm);
217 TRACE_STRUCT (cm2->class3);
218 TRACE_STRUCT (cm2->lcsva);
219 TRACE_STRUCT (cm2->ucs2_treat);
220 TRACE_STRUCT (cm2->solsa);
221 TRACE_STRUCT (cm2->cmsp);
222 TRACE_STRUCT (cm2->a5_3);
223 TRACE_STRUCT (cm2->a5_2);
224 }
225
226 LOCAL void rr_csf_trace_class3 (T_mob_class_3* cm3)
227 {
228 TRACE_STRUCT (cm3->mb_value);
229 TRACE_STRUCT (cm3->a5_7);
230 TRACE_STRUCT (cm3->a5_6);
231 TRACE_STRUCT (cm3->a5_5);
232 TRACE_STRUCT (cm3->a5_4);
233 if (cm3->v_radio_cap_2)
234 {
235 TRACE_STRUCT (cm3->radio_cap_2);
236 }
237 if (cm3->v_radio_cap_1)
238 {
239 TRACE_STRUCT (cm3->radio_cap_1);
240 }
241 if (cm3->v_rgsm_class)
242 {
243 TRACE_STRUCT (cm3->rgsm_class);
244 }
245 if (cm3->v_ms_class)
246 {
247 TRACE_STRUCT (cm3->ms_class);
248 }
249
250 TRACE_STRUCT (cm3->ucs2_treat);
251 TRACE_STRUCT (cm3->ext_meas);
252 if (cm3->v_measurement)
253 {
254 TRACE_STRUCT (cm3->measurement);
255 }
256 if (cm3->v_pos_method)
257 {
258 TRACE_STRUCT (cm3->pos_method);
259 }
260 if (cm3->v_edge_ms_class)
261 {
262 TRACE_STRUCT (cm3->edge_ms_class);
263 }
264 if (cm3->v_egde_struct)
265 {
266 TRACE_STRUCT (cm3->egde_struct.mod);
267 if (cm3->egde_struct.v_egde_pow1)
268 {
269 TRACE_STRUCT (cm3->egde_struct.egde_pow1);
270 }
271 if (cm3->egde_struct.v_egde_pow2)
272 {
273 TRACE_STRUCT (cm3->egde_struct.egde_pow2);
274 }
275 }
276 #ifdef REL99
277 if (cm3->v_gsm400_struct)
278 {
279 TRACE_STRUCT (cm3->gsm400_struct.gsm400_supp);
280 TRACE_STRUCT (cm3->gsm400_struct.gsm400_cap);
281 }
282 #endif
283 if (cm3->v_gsm850_cap)
284 {
285 TRACE_STRUCT (cm3->gsm850_cap);
286 }
287 if (cm3->v_pcs1900_cap)
288 {
289 TRACE_STRUCT (cm3->pcs1900_cap);
290 }
291 #ifdef REL99
292 TRACE_STRUCT (cm3->umts_fdd);
293 TRACE_STRUCT (cm3->umts_tdd);
294 TRACE_STRUCT (cm3->cdma2000);
295 #endif
296 if (cm3->v_dtm_ms)
297 {
298 TRACE_STRUCT (cm3->dtm_ms.dtm_g_ms_class);
299 TRACE_STRUCT (cm3->dtm_ms.mac_support);
300 if (cm3->dtm_ms.v_dtm_e_ms_class)
301 {
302 TRACE_STRUCT (cm3->dtm_ms.dtm_e_ms_class);
303 }
304 }
305 if (cm3->v_single_band)
306 {
307 TRACE_STRUCT (cm3->single_band);
308 }
309 }
310 #endif /* _SIMULATION_ && !NTRACE */
311
312 /*
313 +--------------------------------------------------------------------+
314 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
315 | STATE : code ROUTINE : rr_csf_ms_cap |
316 +--------------------------------------------------------------------+
317
318 PURPOSE : Read the mobile station capabilities from a non-volantile
319 memory into an internal data structure.
320
321 */
322 #if !defined(NTRACE)
323 #define RFCAP_TEST
324 #endif /* !NTRACE */
325
326 GLOBAL void rr_csf_ms_cap (void)
327 {
328 GET_INSTANCE_DATA;
329 drv_Return_Type pcm_ret;
330 UBYTE version;
331
332 TRACE_FUNCTION ("rr_csf_ms_cap()");
333
334 pcm_ret = pcm_ReadFile ((UBYTE *)EF_MSCAP_ID, SIZE_EF_MSCAP,
335 (UBYTE *)&rr_data->mscap, &version);
336 if(pcm_ret NEQ PCM_OK )
337 {
338 TRACE_ERROR( "MS RF capability (EF_MSCAP_ID) -> PCM read error" );
339 }
340 #if defined(RFCAP_TEST)
341 else
342 {
343 TRACE_ARRAY ((UBYTE*)&rr_data->mscap, SIZE_EF_MSCAP, "EF_MSCAP_ID");
344 }
345 #endif /* RFCAP_TEST */
346 }
347
348
349 /*
350 +--------------------------------------------------------------------+
351 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
352 | STATE : code ROUTINE : rr_csf_read_rf_cap |
353 +--------------------------------------------------------------------+
354
355 PURPOSE : Read the mobile station capabilities from a non-volantile
356 memory into an internal data structure.
357
358 */
359 GLOBAL void rr_csf_read_rfcap (void)
360 {
361 GET_INSTANCE_DATA;
362 #define FldSetEx(f,n,v) (f|=((((ULONG)f)&(~((ULONG)n##m)))|(((ULONG)v)<<n##s)))
363
364 EF_RFCAP rfcap_stream;
365 BYTE ccd_ret;
366 UBYTE version;
367 #if !defined(_SIMULATION_)
368 unsigned int ffs_ret;
369 #else
370 drv_Return_Type pcm_ret;
371 #endif /* _TMS470 */
372 UBYTE gprs_ms, cmsp;
373
374 TRACE_FUNCTION ("rr_csf_read_rfcap()");
375
376 /* save configured GPRS multislot class */
377 gprs_ms = rr_data->ms_data.rf_cap.rf_ms.gprs_ms_class;
378 /* save configured CMSP bit */
379 cmsp = rr_data->ms_data.rf_cap.cmsp;
380
381 #if !defined(_SIMULATION_)
382 ffs_ret = FFS_fread("/gsm/com/rfcap", (UBYTE *)&rfcap_stream, sizeof(EF_RFCAP));
383 if (ffs_ret EQ sizeof(EF_RFCAP))
384 version = TRUE;
385 else
386 version = FALSE;
387 #else
388 pcm_ret = pcm_ReadFile ((UBYTE *)EF_RFCAP_ID, SIZE_EF_RFCAP,
389 (UBYTE *)&rfcap_stream, &version);
390 if(pcm_ret EQ PCM_OK )
391 version = TRUE;
392 else
393 version = FALSE;
394 #endif
395 #define RFCAP_DEFAULT /* G23M/RR-ENH-9401 */
396 #if !defined(RFCAP_DEFAULT)
397 if (!version)
398 {
399 TRACE_ERROR ("MS RF capability (rfcap) -> FFS read error. Reset will follow ...");
400 /*
401 * the following delay is made on the target for reasons highlighted with
402 * issue 7510: some customers do during their production the download of the
403 * configuration to the flash whilst the target ist running; another reason is
404 * that the target is not accessable (e.g. via PTCM) during resets; thus
405 * the delay is present to allow that writing of config data is not disturbed
406 * by the reset
407 */
408 #if !defined(_SIMULATION_)
409 TRACE_ERROR ("... in some seconds; download config data to flash please!");
410 vsi_t_sleep(VSI_CALLER DELAY_RESET_NO_CONFIG_DATA);
411 #endif
412 assert (FALSE);
413 }
414 #else /* !RFCAP_DEFAULT */
415 if (!version)
416 {
417 /* Implements Measure#32: Row 150 */
418
419 /* error output via trace interface */
420 TRACE_ERROR( "MS RF capability (RFCAP) -> FFS/PCM read error: use default values instead");
421
422 #ifdef TI_PS_CUSTOM_RFCAP_DEFAULT
423 /* Update with the Custom defined default RF capabilities */
424 memcpy(&rfcap_stream, custom_rfcap_default, SIZE_EF_RFCAP);
425 TRACE_EVENT_P2("Using Custom RFCAP values: Set_bands=%d, Freq_bands=%d", rfcap_stream.setbands, rfcap_stream.bands);
426 #ifndef FF_L23_A5_3
427 FldSetEx (rfcap_stream.encryption, rfCap_A5_3, NO);
428 #endif
429 #else
430
431 memset (&rfcap_stream, 0, SIZE_EF_RFCAP);
432
433 /* default frequency bands */
434 rfcap_stream.setbands = BAND_AUTO;
435 rfcap_stream.bands = BAND_GSM_900|BAND_E_GSM|BAND_DCS_1800|BAND_PCS_1900|BAND_GSM_850;
436
437 /* power classes */
438 FldSetEx (rfcap_stream.power1, rfCap_900, POWER_CLASS_4);
439 FldSetEx (rfcap_stream.power1, rfCap_1800, POWER_CLASS_1);
440 FldSetEx (rfcap_stream.power2, rfCap_1900, POWER_CLASS_1);
441 FldSetEx (rfcap_stream.power2, rfCap_850, POWER_CLASS_4);
442
443 #if CONFIG_TARGET_PIRELLI || CONFIG_TARGET_FCDEV3B
444 /*
445 * The Pirelli is known to always be 900/1800/1900 MHz triband,
446 * so let's operate it as such by default.
447 *
448 * In the case of FCDEV3B there is at least a hypothetical possibility
449 * that we may need to build a tri850 version some day, but we can
450 * still default to tri900 - overriding defaults is what the FFS is for.
451 */
452 rfcap_stream.bands &= ~BAND_GSM_850;
453 FldSetEx (rfcap_stream.power2, rfCap_850, 0);
454 #endif
455
456 /* multi slot classes */
457 FldSetEx (rfcap_stream.msGPRS, rfCap_MSC, MSLOT_CLASS_10);
458
459 /* classmark 2 capabilities */
460 FldSetEx (rfcap_stream.capability1, rfCap_esind, YES);
461 FldSetEx (rfcap_stream.capability2, rfCap_vgcs, NOT_SUPPORTED);
462 FldSetEx (rfcap_stream.capability2, rfCap_vbs, NOT_SUPPORTED);
463 FldSetEx (rfcap_stream.capability1, rfCap_ppsms, SUPPORTED);
464 FldSetEx (rfcap_stream.capability2, rfCap_ssc, SS_SCREEN_PHASE_2);
465 FldSetEx (rfcap_stream.capability1, rfCap_ps, NOT_SUPPORTED);
466 FldSetEx (rfcap_stream.capability1, rfCap_cmsp, SUPPORTED);
467 FldSetEx (rfcap_stream.capability1, rfCap_solsa, NOT_SUPPORTED);
468 FldSetEx (rfcap_stream.capability2, rfCap_usc2, SUPPORTED);
469 FldSetEx (rfcap_stream.capability1, rfCap_lcsva, NOT_SUPPORTED);
470
471 /* classmark 3 capabilities */
472 FldSetEx (rfcap_stream.capability2, rfCap_extmeas, NOT_SUPPORTED);
473 FldSetEx (rfcap_stream.capability2, rfCap_meas, NO);
474 FldSetEx (rfcap_stream.switchmeasure, rfCap_smst, SM_1);
475 FldSetEx (rfcap_stream.switchmeasure, rfCap_smt, SM_1);
476
477 /* encryption algorithm */
478 /*
479 * note inverse logic for the A5/1 encryption algorithm between
480 * classmark 1 and 2 on the one hand and radio access capability
481 * on the other hand
482 */
483 FldSetEx (rfcap_stream.encryption, rfCap_A5_1, YES);
484 FldSetEx (rfcap_stream.encryption, rfCap_A5_2, NO);
485 #ifdef FF_L23_A5_3
486 FldSetEx (rfcap_stream.encryption, rfCap_A5_3, YES);
487 #else
488 FldSetEx (rfcap_stream.encryption, rfCap_A5_3, NO);
489 #endif
490 FldSetEx (rfcap_stream.encryption, rfCap_A5_4, NO);
491 FldSetEx (rfcap_stream.encryption, rfCap_A5_5, NO);
492 FldSetEx (rfcap_stream.encryption, rfCap_A5_6, NO);
493 FldSetEx (rfcap_stream.encryption, rfCap_A5_7, NO);
494 #endif /* TI_PS_CUSTOM_RFCAP_DEFAULT */
495 }
496 #endif /* !RFCAP_DEFAULT */
497
498 /* E-GSM includes P-GSM */
499 if (FldGet (rfcap_stream.bands, rf_EGSM))
500 {
501 FldSetEx (rfcap_stream.bands, rf_900, SUPPORTED);
502 }
503
504 #if defined(RFCAP_TEST)
505 TRACE_ARRAY ((UBYTE*)&rfcap_stream, SIZE_EF_RFCAP, "rfcap_stream");
506 #endif /* RFCAP_TEST */
507
508 {/* decode stream into c struct */
509 #define DECODE_TMP MS_RF_CAPABILITY
510 typedef struct
511 {
512 U32 dummy; /*< 0: 4> */
513 T_sdu sdu; /*< 4: ? > Service Data Unit */
514 } T_DECODE_TMP;
515 T_MS_RF_CAPABILITY *ms_rf_cap;
516 USHORT off;
517 PALLOC_SDU (encode, DECODE_TMP, (SIZE_EF_RFCAP + 1 ) * BITS_PER_BYTE);
518 MALLOC (ms_rf_cap, sizeof (T_MS_RF_CAPABILITY));
519
520 /* The dummy field is needed to make the structure compatible for *
521 * the CCD. We need to initialise it to keep LINT happy */
522 encode->dummy = 0x00;
523
524 off = (USHORT)(encode->sdu.o_buf / BITS_PER_BYTE);
525 memcpy ( &encode->sdu.buf[off+1], &rfcap_stream, SIZE_EF_RFCAP);
526 encode->sdu.buf[off] = MS_RF_CAPABILITY;
527
528 memset (ms_rf_cap, 0, sizeof (T_MS_RF_CAPABILITY));
529 ccd_ret = ccd_decodeMsg(CCDENT_RR_COM, DOWNLINK,
530 (T_MSGBUF *)&encode->sdu, (UBYTE *)ms_rf_cap,
531 0xFF);
532 rr_data->ms_data.rf_cap = ms_rf_cap->rf_cap; /* Struct copy */
533 MFREE (ms_rf_cap);
534 PFREE (encode);
535 }
536
537 /* restore configured GPRS multislot class */
538 if (rr_data->ms_data.multislot_class_configured)
539 {
540 rr_data->ms_data.rf_cap.rf_ms.gprs_ms_class = gprs_ms;
541 TRACE_EVENT_P1 ("'gprs_ms_class' configured to a value of %d (overwrite of rfcap)", gprs_ms);
542 }
543
544 /* restore configured CMSP bit */
545 if (rr_data->ms_data.cmsp_configured)
546 {
547 rr_data->ms_data.rf_cap.cmsp = cmsp;
548 TRACE_EVENT_P1 ("'cmsp' configured to a value of %d (overwrite of rfcap)", cmsp);
549 }
550
551 #if defined(RFCAP_TEST)
552 if (ccd_ret NEQ ccdOK)
553 {
554 /*
555 * CCD has detected an error
556 */
557 UBYTE first_err;
558 USHORT parlist [6];
559 /* Implements Measure#32: Row 152...165 */
560
561 TRACE_EVENT_P1 ("ccd_decodeMsg(): %02x", ccd_ret);
562 /*
563 * get the first error
564 */
565 first_err = ccd_getFirstError (CCDENT_RR, parlist);
566
567 /*
568 * Error Handling
569 */
570 do
571 {
572 /* Implements Measure#32: Row 152...165 */
573 switch (first_err)
574 {
575 case ERR_NO_MORE_ERROR:
576 TRACE_EVENT_P1("%u the end of the error list is reached", first_err);
577 break;
578 case ERR_INVALID_CALC:
579 TRACE_EVENT_P1("%u calculation of the element repeat value failed", first_err);
580 break;
581 case ERR_PATTERN_MISMATCH:
582 TRACE_EVENT_P1("%u a bit pattern was not expected", first_err);
583 break;
584 case ERR_COMPREH_REQUIRED:
585 TRACE_EVENT_P1("%u check for comprehension required failed", first_err);
586 break;
587 case ERR_IE_NOT_EXPECTED:
588 TRACE_EVENT_P1("%u an information element was not expected", first_err);
589 break;
590 case ERR_IE_SEQUENCE:
591 TRACE_EVENT_P1("%u wrong sequence of information elements", first_err);
592 break;
593 case ERR_MAX_IE_EXCEED:
594 TRACE_EVENT_P1("%u maximum amount of repeatable information elements has exceeded", first_err);
595 break;
596 case ERR_MAX_REPEAT:
597 TRACE_EVENT_P1("%u a repeatable element occurs too often in the message", first_err);
598 break;
599 case ERR_MAND_ELEM_MISS:
600 TRACE_EVENT_P1("%u a mandatory information element is missing", first_err);
601 break;
602 case ERR_INVALID_MID:
603 TRACE_EVENT_P1("%u the message ID is not correct", first_err);
604 break;
605 case ERR_INVALID_TYPE:
606 TRACE_EVENT_P1("%u the information element is not a spare padding", first_err);
607 break;
608 case ERR_EOC_TAG_MISSING:
609 TRACE_EVENT_P1("%u indefinite length is specified for the ASN.1-BER but the end tag is missing", first_err);
610 break;
611 case ERR_INTERNAL_ERROR:
612 TRACE_EVENT_P1("%u an internal CCD error occured ", first_err);
613 break;
614 default:
615 TRACE_EVENT_P1("%u unknown error", first_err);
616 break;
617 }
618 first_err = ccd_getNextError (CCDENT_RR, parlist);
619 }while (first_err);
620
621 }
622
623 #if 0
624 if (ccd_ret < ccdError)
625 {
626 rr_csf_trace_power ();
627 }
628 #endif /* 0|1 */
629 #endif /* RFCAP_TEST */
630 }
631
632 GLOBAL void rr_csf_get_freq_bands (UBYTE *pfreq_bands)
633 {
634 GET_INSTANCE_DATA;
635 T_rf_cap *rfc = &rr_data->ms_data.rf_cap;
636
637 #if defined(_SIMULATION_)
638 rr_csf_check_rfcap (FALSE);
639 #endif /* _SIMULATION_ */
640
641 if (rfc->setbands EQ BAND_AUTO)
642 *pfreq_bands = rfc->bands;
643 else
644 *pfreq_bands = rfc->setbands & rfc->bands;
645 #if !defined(NTRACE)
646 rr_csf_trace_power ();
647 #endif /* !NTRACE */
648 }
649
650 /*
651 +--------------------------------------------------------------------+
652 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
653 | STATE : code ROUTINE : rr_csf_get_classmark1 |
654 +--------------------------------------------------------------------+
655
656 PURPOSE : fills c structure of the mobile station classmark 1
657 information element; returns 0 if OK.
658
659 */
660 /*lint -esym(765,rr_csf_get_classmark1) | used by MM*/
661 /*lint -esym(714,rr_csf_get_classmark1) | used by MM */
662 GLOBAL UBYTE rr_csf_get_classmark1 (T_mob_class_1 *mob_class_1)
663 {
664 GET_INSTANCE_DATA;
665 TRACE_FUNCTION ("rr_csf_get_classmark1()");
666
667 #if defined(_SIMULATION_)
668 rr_csf_check_rfcap (FALSE);
669 #endif /* _SIMULATION_ */
670
671 *mob_class_1 = rr_data->ms_data.classmark1;
672
673 #if defined(_SIMULATION_) && !defined(NTRACE)
674 rr_csf_trace_class1 (mob_class_1);
675 #endif /* _SIMULATION_ && !NTRACE */
676 return 0;/* no error */
677 }
678
679 /*
680 +--------------------------------------------------------------------+
681 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
682 | STATE : code ROUTINE : rr_csf_get_classmark2 |
683 +--------------------------------------------------------------------+
684
685 PURPOSE : fills c structure of the mobile station classmark 2
686 information element; returns 0 if OK.
687
688 */
689 /*lint -esym(765,rr_csf_get_classmark2) | used by CC,MM */
690 /*lint -esym(714,rr_csf_get_classmark2) | used by CC,MM */
691 GLOBAL UBYTE rr_csf_get_classmark2 (T_mob_class_2 *mob_class_2)
692 {
693 GET_INSTANCE_DATA;
694 TRACE_FUNCTION ("rr_csf_get_classmark2()");
695
696 #if defined(_SIMULATION_)
697 rr_csf_check_rfcap (FALSE);
698 #endif /* _SIMULATION_ */
699
700 *mob_class_2 = rr_data->ms_data.classmark2;
701
702 #if defined(_SIMULATION_) && !defined(NTRACE)
703 rr_csf_trace_class2 (mob_class_2);
704 #endif /* _SIMULATION_ && !NTRACE */
705 return 0;/* no error */
706 }
707
708 /*
709 +--------------------------------------------------------------------+
710 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
711 | STATE : code ROUTINE : rr_csf_get_classmark3 |
712 +--------------------------------------------------------------------+
713
714 PURPOSE : fills c structure of the mobile station classmark 3
715 information element; returns 0 if OK.
716
717 */
718 #if 0
719 GLOBAL UBYTE rr_csf_get_classmark3 (T_mob_class_3 *mob_class_3)
720 {
721 TRACE_FUNCTION ("rr_csf_get_classmark3()");
722
723 #if defined(_SIMULATION_)
724 rr_csf_check_rfcap (FALSE);
725 #endif /* _SIMULATION_ */
726
727 *mob_class_3 = rr_data->ms_data.classmark3;
728
729 #if defined(_SIMULATION_) && !defined(NTRACE)
730 rr_csf_trace_class3 (mob_class_3);
731 #endif /* _SIMULATION_ && !NTRACE */
732 return 0;/* no error */
733 }
734 #endif
735
736 #ifdef GPRS
737 /* fills c structure of the mobile station radio access capability information element; returns 0 if OK */
738 /*lint -esym(765,rr_csf_get_radio_access_capability) | used by GMM,GRR */
739 /*lint -esym(714,rr_csf_get_radio_access_capability) | used by GMM,GRR */
740 GLOBAL UBYTE rr_csf_get_radio_access_capability (T_ra_cap *ra_cap)
741 {
742 GET_INSTANCE_DATA;
743 TRACE_FUNCTION ("rr_csf_get_radio_access_capability()");
744
745 #if defined(_SIMULATION_)
746 rr_csf_check_rfcap (FALSE);
747 #endif /* _SIMULATION_ */
748
749 *ra_cap = rr_data->ms_data.ra_cap;
750 return 0;
751 }
752 #endif
753
754 /* get pointer to mobile station RF capability c structure; returns NULL on error */
755 /*lint -esym(765,rr_csf_get_rf_capability) | used by GRR */
756 /*lint -esym(714,rr_csf_get_rf_capability) | used by GRR */
757 GLOBAL T_rf_cap* rr_csf_get_rf_capability (void)
758 {
759 GET_INSTANCE_DATA;
760 #if defined(_SIMULATION_)
761 rr_csf_check_rfcap (FALSE);
762 #endif /* _SIMULATION_ */
763
764 return &rr_data->ms_data.rf_cap;
765 }
766
767 GLOBAL void rr_csf_check_rfcap (UBYTE init)
768 {
769 GET_INSTANCE_DATA;
770 TRACE_FUNCTION ("rr_csf_check_rfcap()");
771
772 if (init OR (rr_data->ms_data.rf_cap.bands EQ 0))
773 {
774 rr_csf_read_rfcap ();
775 rr_csf_fit_capability ();
776 }
777 }
778
779
780 #ifndef REL99
781
782 #define RAC_RELEASE97
783 /*
784 +--------------------------------------------------------------------+
785 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
786 | STATE : code ROUTINE : rr_csf_fit_capability |
787 +--------------------------------------------------------------------+
788
789 PURPOSE : fit classmark 2 and 3 and radio access capabilities
790 depend on the value of 'std' and the readed values of
791 /gsm/com/rfcap file according to R99 specifications
792 */
793
794 GLOBAL UBYTE rr_csf_fit_capability (void)
795 {
796 GET_INSTANCE_DATA;
797 USHORT serving_cell;
798 T_rf_cap *rfc = &rr_data->ms_data.rf_cap;
799 #ifdef GPRS
800 T_ra_cap *rac = &rr_data->ms_data.ra_cap;
801 #endif
802 T_mob_class_1 *cm1 = &rr_data->ms_data.classmark1;
803 T_mob_class_2 *cm2 = &rr_data->ms_data.classmark2;
804 T_mob_class_3 *cm3 = &rr_data->ms_data.classmark3;
805
806 TRACE_FUNCTION ("rr_csf_fit_capability()");
807
808 if (rr_data->nc_data[SC_INDEX].bcch_status NEQ EMPTY)
809 serving_cell = rr_data->nc_data[SC_INDEX].arfcn;
810 else
811 serving_cell = (USHORT)-1;
812
813 memset (cm2, 0, sizeof(T_mob_class_2));
814 memset (cm3, 0, sizeof(T_mob_class_3));
815 #ifdef GPRS
816 memset (rac, 0, sizeof(T_ra_cap));
817 #endif
818
819 cm1->rev_lev = cm2->rev_lev = REV_LEV_PHASE_2; /* PHASE_1 | PHASE_2 | R99_SUPPORT */
820 #ifdef GPRS
821 #if !defined(RAC_RELEASE97)
822 rac->acc_cap.rev99 = REV_LEV_PHASE_1; /* PHASE_1 | RELEASE99 */
823 #endif /* !RAC_RELEASE97 */
824 #endif
825 cm1->es_ind = cm2->es_ind = rfc->es_ind;
826 cm2->ps = rfc->ps;
827 cm2->ss_screen = rfc->ss_screen;
828 cm2->mt_pp_sms = rfc->mt_pp_sms;
829 cm2->vbs = rfc->vbs;
830 cm2->vgcs = rfc->vgcs;
831 cm2->class3 = SUPPORTED; /* options indicated in classmark 3 */
832 cm2->lcsva = rfc->lcsva;
833 cm2->ucs2_treat = cm3->ucs2_treat = rfc->ucs2_treat;
834 cm2->solsa = rfc->solsa;
835 cm2->cmsp = rfc->cmsp;
836
837 /*
838 * note inverse logic for the A5/1 encryption algorithm between
839 * classmark 1 and 2 on the one hand and radio access capability
840 * on the other hand
841 */
842 cm1->a5_1 = cm2->a5_1 = !rfc->a5_bits.a5_1;
843 cm2->a5_2 = rfc->a5_bits.a5_2;
844 cm2->a5_3 = rfc->a5_bits.a5_3;
845
846 cm3->a5_4 = rfc->a5_bits.a5_4;
847 cm3->a5_5 = rfc->a5_bits.a5_5;
848 cm3->a5_6 = rfc->a5_bits.a5_6;
849 cm3->a5_7 = rfc->a5_bits.a5_7;
850
851 #ifdef GPRS
852 rac->acc_cap.es_ind = rfc->es_ind;
853 rac->acc_cap.ps = rfc->ps;
854 rac->acc_cap.vbs = rfc->vbs;
855 rac->acc_cap.vgcs = rfc->vgcs;
856 rac->acc_cap.v_a5_bits = SUPPORTED;
857 rac->acc_cap.a5_bits = rfc->a5_bits;
858 #if !defined(RAC_RELEASE97)
859 rac->acc_cap.compact = rfc->compact;
860 #endif /* !RAC_RELEASE97 */
861
862 /* single- or multiband */
863 rac->flag_ra_cap2 = rac->v_ra_cap2 = NO;
864
865 #endif
866
867 switch (std)
868 {
869 case STD_900:
870 cm3->mb_value = MB_GSM900;
871 #ifdef GPRS
872 rac->acc_tech_typ = ACC_GSM_P;
873 #endif
874 break;
875 case STD_EGSM:
876 cm2->egsm = SUPPORTED;
877 cm3->mb_value = MB_EGSM;
878 #ifdef GPRS
879 rac->acc_tech_typ = ACC_GSM_E;
880 #endif
881 break;
882 case STD_1800:
883 cm3->mb_value = MB_DCS1800;
884 #ifdef GPRS
885 rac->acc_tech_typ = ACC_GSM_1800;
886 #endif
887 break;
888 case STD_DUAL:
889 cm3->mb_value = MB_DUAL;
890 #ifdef GPRS
891 rac->acc_tech_typ = ACC_GSM_P;
892 rac->flag_ra_cap2 = rac->v_ra_cap2 = YES;
893 rac->ra_cap2.acc_tech_typ = ACC_GSM_1800;
894 rac->ra_cap2.acc_cap = rac->acc_cap;
895 rac->ra_cap2.acc_cap.v_a5_bits = NOT_SUPPORTED;
896 rac->ra_cap2.acc_cap.v_ms_struct = NOT_SUPPORTED;
897 #if !defined(RAC_RELEASE97)
898 rac->ra_cap2.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
899 #endif /* !RAC_RELEASE97 */
900 #endif
901 break;
902 case STD_DUAL_EGSM:
903 /* note: incase of 1800 band, the FC bit shall be set to 0 */
904 if ((rr_data->ms_data.rr_service EQ FULL_SERVICE) AND
905 (!INRANGE(LOW_CHANNEL_1800, rr_data->nc_data[SC_INDEX].arfcn,
906 HIGH_CHANNEL_1800)))
907 cm2->egsm = SUPPORTED;
908 cm3->mb_value = MB_DUAL_EXT;
909 #ifdef GPRS
910 rac->acc_tech_typ = ACC_GSM_E;
911 rac->flag_ra_cap2 = rac->v_ra_cap2 = YES;
912 rac->ra_cap2.acc_tech_typ = ACC_GSM_1800;
913 rac->ra_cap2.acc_cap = rac->acc_cap;
914 rac->ra_cap2.acc_cap.v_a5_bits = NOT_SUPPORTED;
915 rac->ra_cap2.acc_cap.v_ms_struct = NOT_SUPPORTED;
916 #if !defined(RAC_RELEASE97)
917 rac->ra_cap2.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
918 #endif /* !RAC_RELEASE97 */
919 #endif
920 break;
921
922 case STD_1900:
923 case STD_850:
924 case STD_DUAL_US:
925 /* no break; go through */
926 default:
927 cm3->mb_value = MB_NO_EUROPEAN_BAND;
928 break;
929 }
930
931 /* power classes */
932 if (rfc->bands & 0x80)
933 {
934 TRACE_ERROR("R-GSM not supported by PS software");
935 /* note: cm3->v_rgsm_class (and cm3->rgsm_class) are hard coded to 0 */
936 }
937 if (rfc->bands & 0x60)
938 {
939 TRACE_ERROR("GSM 400 not supported by PS software");
940 /* note: cm3->v_gsm400_struct (and cm3->gsm400_struct) are hard coded to 0 */
941 }
942 switch (std)
943 {
944 case STD_900:
945 case STD_EGSM:
946 cm3->v_radio_cap_1 = TRUE;
947 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
948 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
949 #ifdef GPRS
950 rac->acc_cap.pow_class = cm3->radio_cap_1;
951 #endif
952 break;
953
954 case STD_1800:
955 /* single band => only radio_cap_1 */
956 cm3->v_radio_cap_1 = TRUE;
957 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class;
958 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
959 #ifdef GPRS
960 rac->acc_cap.pow_class = cm3->radio_cap_1;
961 #endif
962 break;
963
964 case STD_DUAL:
965 case STD_DUAL_EGSM:
966 cm3->v_radio_cap_1 = TRUE;
967 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
968 cm3->v_radio_cap_2 = TRUE;
969 cm3->radio_cap_2 = rfc->rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class;
970 /* note: in case the sc is´nt set, it is out of range */
971 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
972 cm2->rf_pow_cap = cm3->radio_cap_2 - 1;
973 else
974 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
975 #ifdef GPRS
976 rac->acc_cap.pow_class = cm3->radio_cap_1;
977 rac->ra_cap2.acc_cap.pow_class = cm3->radio_cap_2;
978 #endif
979 break;
980
981 case STD_1900:
982 cm3->v_pcs1900_cap = SUPPORTED;
983 cm3->pcs1900_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class;
984 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
985 #ifdef GPRS
986 rac->acc_tech_typ = ACC_GSM_1900;
987 rac->acc_cap.pow_class = cm3->pcs1900_cap;
988 #endif
989 break;
990
991 case STD_850:
992 cm3->v_gsm850_cap = SUPPORTED;
993 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
994 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
995 #ifdef GPRS
996 rac->acc_tech_typ = ACC_GSM_850;
997 rac->acc_cap.pow_class = cm3->gsm850_cap;
998 #endif
999 break;
1000
1001 case STD_DUAL_US:
1002 cm3->v_gsm850_cap = SUPPORTED;
1003 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
1004 cm3->v_pcs1900_cap = SUPPORTED;
1005 cm3->pcs1900_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class;
1006 /* note: in case the sc isn't set, it is out of range */
1007 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1008 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
1009 else
1010 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1011 #ifdef GPRS
1012 rac->acc_tech_typ = ACC_GSM_850;
1013 rac->acc_cap.pow_class = cm3->gsm850_cap;
1014 rac->flag_ra_cap2 = rac->v_ra_cap2 = YES;
1015 rac->ra_cap2.acc_tech_typ = ACC_GSM_1900;
1016 rac->ra_cap2.acc_cap = rac->acc_cap;
1017 rac->ra_cap2.acc_cap.v_a5_bits = NOT_SUPPORTED;
1018 rac->ra_cap2.acc_cap.v_ms_struct = NOT_SUPPORTED;
1019 #if !defined(RAC_RELEASE97)
1020 rac->ra_cap2.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1021 #endif /* !RAC_RELEASE97 */
1022 rac->ra_cap2.acc_cap.pow_class = cm3->pcs1900_cap;
1023 #endif
1024 break;
1025
1026 default:
1027 break;
1028 }
1029 cm1->rf_pow_cap = cm2->rf_pow_cap;
1030
1031 #if defined(_SIMULATION_) && defined(RFCAP_TEST)
1032 rr_csf_trace_power ();
1033 #endif /* RFCAP_TEST*/
1034
1035 #if defined(FF_EGDE)
1036 if (rfc->mod OR rfc->rf_power.egde_pow1 OR rfc->rf_power.egde_pow2)
1037 {
1038 cm3->v_egde_struct = SUPPORTED;
1039 cm3->egde_struct.mod = rfc->mod;
1040 }
1041 switch (std)
1042 {
1043 case STD_900:
1044 case STD_EGSM:
1045 case STD_850:
1046 if (rfc->rf_power.egde_pow1)
1047 {
1048 if (rfc->mod)
1049 {
1050 cm3->egde_struct.v_egde_pow1 = SUPPORTED;
1051 cm3->egde_struct.egde_pow1 = rfc->rf_power.egde_pow1;
1052 }
1053 #ifdef GPRS
1054 rac->acc_cap.v_pow_8psk_cap = SUPPORTED;
1055 rac->acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow1;
1056 #endif
1057 }
1058 break;
1059 case STD_1800:
1060 case STD_1900:
1061 if (rfc->rf_power.egde_pow2)
1062 {
1063 if (rfc->mod)
1064 {
1065 cm3->egde_struct.v_egde_pow2 = SUPPORTED;
1066 cm3->egde_struct.egde_pow2 = rfc->rf_power.egde_pow2;
1067 }
1068 #ifdef GPRS
1069 rac->acc_cap.v_pow_8psk_cap = SUPPORTED;
1070 rac->acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow2;
1071 #endif
1072 }
1073 break;
1074 case STD_DUAL:
1075 case STD_DUAL_EGSM:
1076 case STD_DUAL_US:
1077 if (rfc->rf_power.egde_pow1)
1078 {
1079 if (rfc->mod)
1080 {
1081 cm3->egde_struct.v_egde_pow1 = SUPPORTED;
1082 cm3->egde_struct.egde_pow1 = rfc->rf_power.egde_pow1;
1083 }
1084 #ifdef GPRS
1085 rac->acc_cap.v_pow_8psk_cap = SUPPORTED;
1086 rac->acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow1;
1087 #endif
1088 }
1089 if (rfc->rf_power.egde_pow2)
1090 {
1091 if (rfc->mod)
1092 {
1093 cm3->egde_struct.v_egde_pow2 = SUPPORTED;
1094 cm3->egde_struct.egde_pow2 = rfc->rf_power.egde_pow2;
1095 }
1096 #ifdef GPRS
1097 rac->ra_cap2.acc_cap.v_pow_8psk_cap = SUPPORTED;
1098 rac->ra_cap2.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow2;
1099 #endif
1100 }
1101 break;
1102 default:
1103 break;
1104 }
1105 #endif /* FF_EGDE */
1106
1107 /* multi slot capabilities */
1108 if (rfc->rf_ms.gsm_ms_class)
1109 {
1110 cm3->v_ms_class = SUPPORTED;
1111 cm3->ms_class = rfc->rf_ms.gsm_ms_class;
1112 }
1113 #if defined(FF_EGDE)
1114 if (rfc->rf_ms.edge_ms_class)
1115 {
1116 cm3->v_edge_ms_class = SUPPORTED;
1117 cm3->edge_ms_class = rfc->rf_ms.edge_ms_class;
1118 }
1119 #endif /* FF_EGDE */
1120 if (rfc->rf_ms.dtm_g)
1121 {
1122 #ifdef GPRS
1123 rac->acc_cap.v_ms_struct = SUPPORTED;
1124 #endif
1125 cm3->v_dtm_ms = SUPPORTED;
1126 cm3->dtm_ms.mac_support = rfc->mac_support;
1127 cm3->dtm_ms.dtm_g_ms_class = rfc->rf_ms.dtm_g_ms_class;
1128 #ifdef GPRS
1129 #if !defined(RAC_RELEASE97)
1130 rac->acc_cap.ms_struct.v_dtm_struct = SUPPORTED;
1131 rac->acc_cap.ms_struct.dtm_struct.dtm_g_ms_class = rfc->rf_ms.dtm_g_ms_class;
1132 rac->acc_cap.ms_struct.dtm_struct.mac_support = rfc->mac_support;
1133 #endif /* !RAC_RELEASE97 */
1134 #endif
1135
1136 #if defined(FF_EGDE)
1137 if (rfc->rf_ms.dtm_e)
1138 {
1139 cm3->dtm_ms.v_dtm_e_ms_class = SUPPORTED;
1140 cm3->dtm_ms.dtm_e_ms_class = rfc->rf_ms.dtm_e_ms_class;
1141 #ifdef GPRS
1142 #if !defined(RAC_RELEASE97)
1143 rac->acc_cap.ms_struct.v_dtm_struct = SUPPORTED;
1144 rac->acc_cap.ms_struct.dtm_struct.v_dtm_e_ms_class = SUPPORTED;
1145 rac->acc_cap.ms_struct.dtm_struct.dtm_e_ms_class = rfc->rf_ms.dtm_e_ms_class;
1146 #endif /* !RAC_RELEASE97 */
1147 #endif
1148 }
1149 #endif /* FF_EGDE */
1150 }
1151
1152 #ifdef GPRS
1153 if (rfc->rf_ms.hscsd_ms_class)
1154 {
1155 rac->acc_cap.v_ms_struct = SUPPORTED;
1156 rac->acc_cap.ms_struct.v_hscsd_ms_class = SUPPORTED;
1157 rac->acc_cap.ms_struct.hscsd_ms_class = rfc->rf_ms.hscsd_ms_class;
1158 }
1159
1160 if (rfc->rf_ms.gprs_ms_class)
1161 {
1162 rac->acc_cap.v_ms_struct = SUPPORTED;
1163 rac->acc_cap.ms_struct.v_gprs_struct = SUPPORTED;
1164 rac->acc_cap.ms_struct.gprs_struct.gprs_ms_class = rfc->rf_ms.gprs_ms_class;
1165 rac->acc_cap.ms_struct.gprs_struct.gprs_eda = rfc->gprs_eda;
1166 }
1167 #endif
1168
1169 cm3->ext_meas = rfc->ext_meas;
1170
1171 if (rfc->meas)
1172 {
1173 #ifdef GPRS
1174 rac->acc_cap.v_ms_struct = SUPPORTED;
1175 rac->acc_cap.ms_struct.v_sms_sm_value = SUPPORTED;
1176 rac->acc_cap.ms_struct.sms_sm_value.sms_val = rfc->sms_val;
1177 rac->acc_cap.ms_struct.sms_sm_value.sm_val = rfc->sm_val;
1178 #endif
1179
1180 cm3->v_measurement = SUPPORTED;
1181 cm3->measurement.sms_val = rfc->sms_val;
1182 cm3->measurement.sm_val = rfc->sm_val;
1183 }
1184
1185 #ifdef GPRS
1186 if (rfc->rf_ms.ecsd_ms_class)
1187 {
1188 rac->acc_cap.v_ms_struct = SUPPORTED;
1189 #if !defined(RAC_RELEASE97)
1190 rac->acc_cap.ms_struct.v_ecsd_ms_class = SUPPORTED;
1191 rac->acc_cap.ms_struct.ecsd_ms_class = rfc->rf_ms.ecsd_ms_class;
1192 #endif /* !RAC_RELEASE97 */
1193 }
1194 #endif
1195
1196 #ifdef GPRS
1197 if (rfc->rf_ms.egprs_ms_class)
1198 {
1199 rac->acc_cap.v_ms_struct = SUPPORTED;
1200 #if !defined(RAC_RELEASE97)
1201 rac->acc_cap.ms_struct.v_egprs_struct = SUPPORTED;
1202 rac->acc_cap.ms_struct.egprs_struct.egprs_ms_class = rfc->rf_ms.egprs_ms_class;
1203 rac->acc_cap.ms_struct.egprs_struct.egprs_eda = rfc->egprs_eda;
1204 #endif /* !RAC_RELEASE97 */
1205 }
1206
1207 if (rac->v_ra_cap2 AND rac->acc_cap.v_ms_struct)
1208 {
1209 #if !defined(RAC_RELEASE97)
1210 rac->ra_cap2.acc_cap.rev99 = PHASE_1; /* PHASE_1 | RELEASE99 */
1211 rac->ra_cap2.acc_cap.compact = rfc->compact;
1212 #endif /* !RAC_RELEASE97 */
1213 rac->ra_cap2.acc_cap.es_ind = rfc->es_ind;
1214 rac->ra_cap2.acc_cap.ps = rfc->ps;
1215 rac->ra_cap2.acc_cap.vbs = rfc->vbs;
1216 rac->ra_cap2.acc_cap.vgcs = rfc->vgcs;
1217 /*
1218 * zero means that the same value for multislot parameters as given
1219 * in an earlier access capabilities field within this IE apply
1220 * also here.
1221 */
1222 rac->ra_cap2.acc_cap.v_ms_struct = FALSE;
1223 }
1224 #endif
1225
1226 #if defined FF_EOTD
1227 if (rfc->assist_eotd OR rfc->based_eotd OR rfc->assist_gps OR rfc->based_gps OR rfc->conv_gps)
1228 #else
1229 if (rfc->assist_gps OR rfc->based_gps OR rfc->conv_gps)
1230 #endif /* FF_EOTD */
1231 {
1232 cm3->v_pos_method = SUPPORTED;
1233 #if defined FF_EOTD
1234 cm3->pos_method.assist_eotd = rfc->assist_eotd;
1235 cm3->pos_method.based_eotd = rfc->based_eotd;
1236 #endif /* FF_EOTD */
1237 cm3->pos_method.assist_gps = rfc->assist_gps;
1238 cm3->pos_method.based_gps = rfc->based_gps;
1239 cm3->pos_method.conv_gps = rfc->conv_gps;
1240 }
1241
1242 #if defined TI_PS_FF_REL99_AND_ABOVE
1243 cm3->v_gsm700_cap = NOT_SUPPORTED;
1244 cm3->umts_tdd_128 = NOT_SUPPORTED;
1245 cm3->geran_feat_pack_1 = NOT_SUPPORTED;
1246 cm3->v_ext_dtm_ms = NOT_SUPPORTED;
1247 cm3->v_high_ms_cap = NOT_SUPPORTED;
1248 cm3->geran_iu_mod_cap = NOT_SUPPORTED;
1249 cm3->geran_feat_pack_2 = NOT_SUPPORTED;
1250 cm3->gmsk_ms_pwr_prof = MS_PWR_PROF0;
1251 cm3->psk8_ms_pwr_prof = MS_PWR_PROF0;
1252 cm3->v_t_gsm400_struct = NOT_SUPPORTED;
1253 cm3->v_t_gsm900_cap = NOT_SUPPORTED;
1254 #ifdef L1_SAIC
1255 /* To support SAIC release 6 feature */
1256 cm3->dl_adv_rx_per = DL_ADVANC_RX_PERF_PHASE1_SUPPORT;
1257 #else
1258 cm3->dl_adv_rx_per = DL_ADVANC_RX_PERF_NOT_SUPPORT;
1259 #endif /* L1_SAIC */
1260 cm3->dtm_enhance_cap = NOT_SUPPORTED;
1261 cm3->v_dtm_high_ms = NOT_SUPPORTED;
1262 #ifdef FF_REPEATED_SACCH
1263 cm3->rep_acch_cap = REP_SACCH_DL_FACCH;
1264 #else
1265 cm3->rep_acch_cap = REP_DL_FACCH;
1266 #endif /* FF_REPEATED_SACCH */
1267 #endif /* TI_PS_FF_REL99_AND_ABOVE */
1268
1269 #if defined(_SIMULATION_) && !defined(NTRACE)
1270 rr_csf_trace_class1 (cm1);
1271 rr_csf_trace_class2 (cm2);
1272 rr_csf_trace_class3 (cm3);
1273 #endif /* _SIMULATION_ && !NTRACE */
1274 /*
1275 * note: cm3->umts_fdd, cm3->umts_tdd, cm3->cdma2000, cm3->v_single_band and
1276 * cm3->single_band are hard coded to 0 due to the lack of information about
1277 * these features inside the T_rf_cap structure
1278 */
1279 return 0;
1280 }
1281
1282 #else /* Release 99 */
1283
1284 /*
1285 +--------------------------------------------------------------------+
1286 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
1287 | STATE : code ROUTINE : rr_csf_fit_capability |
1288 +--------------------------------------------------------------------+
1289
1290 PURPOSE : fit classmark 2 and 3 and radio access capabilities
1291 depend on the value of 'std' and the readed values of
1292 /gsm/com/rfcap file according to R99 specifications
1293
1294 */
1295
1296 GLOBAL UBYTE rr_csf_fit_capability (void)
1297 {
1298 GET_INSTANCE_DATA;
1299 USHORT serving_cell;
1300 T_rf_cap *rfc = &rr_data->ms_data.rf_cap;
1301 #ifdef GPRS
1302 T_ra_cap *rac = &rr_data->ms_data.ra_cap;
1303 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1304 int i;
1305 #endif
1306 #endif
1307 T_mob_class_1 *cm1 = &rr_data->ms_data.classmark1;
1308 T_mob_class_2 *cm2 = &rr_data->ms_data.classmark2;
1309 T_mob_class_3 *cm3 = &rr_data->ms_data.classmark3;
1310
1311 TRACE_FUNCTION ("rr_csf_fit_capability()");
1312
1313 if (rr_data->nc_data[SC_INDEX].bcch_status NEQ EMPTY)
1314 serving_cell = rr_data->nc_data[SC_INDEX].arfcn;
1315 else
1316 serving_cell = (USHORT)-1;
1317
1318 memset (cm2, 0, sizeof(T_mob_class_2));
1319 memset (cm3, 0, sizeof(T_mob_class_3));
1320 #ifdef GPRS
1321 memset (rac, 0, sizeof(T_ra_cap));
1322 #endif
1323
1324
1325 /* Set clasmark 1 fields */
1326 cm1->rev_lev = REV_LEV_R99_SUPPORT; /* R99 mobile */
1327 cm1->es_ind = rfc->es_ind;
1328 cm1->a5_1 = !rfc->a5_bits.a5_1;
1329
1330
1331 /* Set classmark 2 fields */
1332 cm2->rev_lev = REV_LEV_R99_SUPPORT;
1333 cm2->es_ind = rfc->es_ind;
1334 cm2->ps = rfc->ps;
1335 cm2->ss_screen = rfc->ss_screen;
1336 cm2->mt_pp_sms = rfc->mt_pp_sms;
1337 cm2->vbs = rfc->vbs;
1338 cm2->vgcs = rfc->vgcs;
1339 cm2->class3 = SUPPORTED;
1340 cm2->lcsva = rfc->lcsva;
1341 cm2->ucs2_treat = rfc->ucs2_treat;
1342 cm2->solsa = rfc->solsa;
1343 cm2->cmsp = rfc->cmsp;
1344 cm2->a5_1 = !rfc->a5_bits.a5_1;
1345 cm2->a5_2 = rfc->a5_bits.a5_2;
1346 cm2->a5_3 = rfc->a5_bits.a5_3;
1347
1348
1349 /* Set classmark 3 fields */
1350 cm3->a5_4 = rfc->a5_bits.a5_4;
1351 cm3->a5_5 = rfc->a5_bits.a5_5;
1352 cm3->a5_6 = rfc->a5_bits.a5_6;
1353 cm3->a5_7 = rfc->a5_bits.a5_7;
1354 cm3->ucs2_treat = rfc->ucs2_treat;
1355 cm3->ext_meas = rfc->ext_meas;
1356
1357 /* Set multi slot capabilities */
1358 if (rfc->rf_ms.gsm_ms_class)
1359 {
1360 cm3->v_ms_class = SUPPORTED;
1361 cm3->ms_class = rfc->rf_ms.gsm_ms_class;
1362 }
1363
1364 /* Set MS measurement capability */
1365 if (rfc->meas)
1366 {
1367 cm3->v_measurement = SUPPORTED;
1368 cm3->measurement.sms_val = rfc->sms_val;
1369 cm3->measurement.sm_val = rfc->sm_val;
1370 }
1371
1372 /* Set MS positioning method */
1373 #if defined FF_EOTD
1374 if (rfc->assist_eotd OR rfc->based_eotd OR rfc->assist_gps OR rfc->based_gps OR rfc->conv_gps)
1375 #else
1376 if (rfc->assist_gps OR rfc->based_gps OR rfc->conv_gps)
1377 #endif /* FF_EOTD */
1378 {
1379 cm3->v_pos_method = SUPPORTED;
1380 #if defined FF_EOTD
1381 cm3->pos_method.assist_eotd = rfc->assist_eotd;
1382 cm3->pos_method.based_eotd = rfc->based_eotd;
1383 #endif /* FF_EOTD */
1384 cm3->pos_method.assist_gps = rfc->assist_gps;
1385 cm3->pos_method.based_gps = rfc->based_gps;
1386 cm3->pos_method.conv_gps = rfc->conv_gps;
1387 }
1388
1389
1390 #ifdef GPRS
1391 /* Set Radio Access Capability info */
1392 rac->ra_cap_values.v_acc_cap = YES;
1393 rac->ra_cap_values.acc_cap.v_a5_bits = SUPPORTED;
1394
1395 rac->ra_cap_values.acc_cap.rev99 = RELEASE99;
1396 rac->ra_cap_values.acc_cap.es_ind = rfc->es_ind;
1397 rac->ra_cap_values.acc_cap.ps = rfc->ps;
1398 rac->ra_cap_values.acc_cap.vbs = rfc->vbs;
1399 rac->ra_cap_values.acc_cap.vgcs = rfc->vgcs;
1400 rac->ra_cap_values.acc_cap.a5_bits = rfc->a5_bits;
1401 rac->ra_cap_values.acc_cap.compact = rfc->compact;
1402
1403 rac->ra_cap_values.acc_cap.v_ms_struct = SUPPORTED;
1404 rac->ra_cap_values.acc_cap.ms_struct.v_ecsd_ms_class = NOT_SUPPORTED;/*CR 637 */
1405 rac->ra_cap_values.acc_cap.ms_struct.v_hscsd_ms_class = NOT_SUPPORTED;/*CR 637 */
1406 rac->ra_cap_values.acc_cap.ms_struct.v_sms_sm_value = NOT_SUPPORTED;/*CR 637 */
1407
1408 rac->c_ra_cap_r = NO;
1409 rac->v_ra_cap_r = NO;
1410
1411 #endif
1412
1413 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1414 /* Set the MS multiband capabilities */
1415 switch (std)
1416 {
1417 case STD_900:
1418 cm3->mb_value = MB_GSM900;
1419 #ifdef GPRS
1420 rac->ra_cap_values.acc_tech_typ = ACC_GSM_P;
1421 #endif
1422 break;
1423 case STD_EGSM:
1424 cm2->egsm = SUPPORTED;
1425 #ifdef GPRS
1426 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1427 #endif
1428 /* No break */
1429 case STD_900_1900:
1430 case STD_850_900_1900:
1431 cm3->mb_value = MB_EGSM;
1432 if ((!INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1433 AND (!INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850)))
1434 {
1435 cm2->egsm = SUPPORTED;
1436 }
1437 break;
1438 case STD_1800:
1439 #ifdef GPRS
1440 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1441 #endif
1442 /* NO break */
1443 case STD_850_1800:
1444 cm3->mb_value = MB_DCS1800;
1445 break;
1446 case STD_DUAL:
1447 cm3->mb_value = MB_DUAL;
1448 #ifdef GPRS
1449 rac->v_ra_cap_r = YES;
1450 rac->c_ra_cap_r++;
1451 rac->ra_cap_r[0].ra_cap_values.v_acc_cap = YES;
1452
1453 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1454 {
1455 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1456 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_P;
1457 }
1458 else
1459 {
1460 rac->ra_cap_values.acc_tech_typ = ACC_GSM_P;
1461 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1462 }
1463
1464 rac->ra_cap_r[0].ra_cap_values.acc_cap = rac->ra_cap_values.acc_cap;
1465 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1466 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1467 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1468 #endif
1469 break;
1470 case STD_DUAL_EGSM:
1471 case STD_850_900_1800:
1472 /* note: incase of 1800 band, the FC bit shall be set to 0 */
1473 if((!INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1474 AND (!INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850)))
1475 cm2->egsm = SUPPORTED;
1476 cm3->mb_value = MB_DUAL_EXT;
1477
1478 #ifdef GPRS
1479 rac->v_ra_cap_r = YES;
1480 rac->c_ra_cap_r++;
1481 rac->ra_cap_r[0].ra_cap_values.v_acc_cap = YES;
1482 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1483 {
1484 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1485 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_E;
1486 }
1487 else
1488 {
1489 if(INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850))
1490 {
1491 rac->ra_cap_values.acc_tech_typ = ACC_GSM_850;
1492 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1493 }
1494 else
1495 {
1496 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1497 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1498 }
1499 }
1500
1501 rac->ra_cap_r[0].ra_cap_values.acc_cap = rac->ra_cap_values.acc_cap;
1502 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1503 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1504 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1505 #endif
1506 break;
1507
1508 case STD_1900:
1509 case STD_850:
1510 case STD_DUAL_US:
1511 /* no break; go through */
1512 default:
1513 cm3->mb_value = MB_NO_EUROPEAN_BAND;
1514 break;
1515 }
1516 #else
1517 /* Set the MS multiband capabilities */
1518 switch (std)
1519 {
1520 case STD_900:
1521 cm3->mb_value = MB_GSM900;
1522 #ifdef GPRS
1523 rac->ra_cap_values.acc_tech_typ = ACC_GSM_P;
1524 #endif
1525 break;
1526 case STD_EGSM:
1527 cm2->egsm = SUPPORTED;
1528 cm3->mb_value = MB_EGSM;
1529 #ifdef GPRS
1530 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1531 #endif
1532 break;
1533 case STD_1800:
1534 cm3->mb_value = MB_DCS1800;
1535 #ifdef GPRS
1536 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1537 #endif
1538 break;
1539 case STD_DUAL:
1540 cm3->mb_value = MB_DUAL;
1541 #ifdef GPRS
1542 rac->v_ra_cap_r = YES;
1543 rac->c_ra_cap_r++;
1544 rac->ra_cap_r[0].ra_cap_values.v_acc_cap = YES;
1545
1546 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1547 {
1548 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1549 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_P;
1550 }
1551 else
1552 {
1553 rac->ra_cap_values.acc_tech_typ = ACC_GSM_P;
1554 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1555 }
1556
1557 rac->ra_cap_r[0].ra_cap_values.acc_cap = rac->ra_cap_values.acc_cap;
1558 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1559 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1560 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1561 #endif
1562 break;
1563 case STD_DUAL_EGSM:
1564 /* note: incase of 1800 band, the FC bit shall be set to 0 */
1565 if(!INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_1800))
1566 cm2->egsm = SUPPORTED;
1567 cm3->mb_value = MB_DUAL_EXT;
1568
1569 #ifdef GPRS
1570 rac->v_ra_cap_r = YES;
1571 rac->c_ra_cap_r++;
1572 rac->ra_cap_r[0].ra_cap_values.v_acc_cap = YES;
1573
1574 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1575 {
1576 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1577 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_E;
1578 }
1579 else
1580 {
1581 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1582 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1583 }
1584
1585 rac->ra_cap_r[0].ra_cap_values.acc_cap = rac->ra_cap_values.acc_cap;
1586 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1587 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1588 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1589 #endif
1590 break;
1591
1592 case STD_1900:
1593 case STD_850:
1594 case STD_DUAL_US:
1595 /* no break; go through */
1596 default:
1597 cm3->mb_value = MB_NO_EUROPEAN_BAND;
1598 break;
1599 }
1600 #endif
1601
1602 /* Set MS power classes info */
1603 if (rfc->bands & 0x80)
1604 {
1605 TRACE_ERROR("R-GSM not supported by PS software");
1606 /* note: cm3->v_rgsm_class (and cm3->rgsm_class) are hard coded to 0 */
1607 }
1608 if (rfc->bands & 0x60)
1609 {
1610 TRACE_ERROR("GSM 400 not supported by PS software");
1611 /* note: cm3->v_gsm400_struct (and cm3->gsm400_struct) are hard coded to 0 */
1612 }
1613
1614 switch (std)
1615 {
1616 case STD_900:
1617 case STD_EGSM:
1618 cm3->v_radio_cap_1 = TRUE;
1619 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
1620 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1621 #ifdef GPRS
1622 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1623 #endif
1624 break;
1625
1626 case STD_1800:
1627 /* single band => only radio_cap_1 */
1628 cm3->v_radio_cap_1 = TRUE;
1629 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class;
1630 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1631 #ifdef GPRS
1632 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1633 #endif
1634 break;
1635
1636 case STD_DUAL:
1637 case STD_DUAL_EGSM:
1638 cm3->v_radio_cap_1 = TRUE;
1639 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
1640 cm3->v_radio_cap_2 = TRUE;
1641 cm3->radio_cap_2 = rfc->rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class;
1642 /* note: in case the sc is´nt set, it is out of range */
1643 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1644 cm2->rf_pow_cap = cm3->radio_cap_2 - 1;
1645 else
1646 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1647 #ifdef GPRS
1648 if (rac->ra_cap_values.acc_tech_typ EQ ACC_GSM_1800)
1649 {
1650 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_2;
1651 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1652 }
1653 else
1654 {
1655 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1656 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_2;
1657 }
1658 #endif
1659 break;
1660
1661 case STD_1900:
1662 cm3->v_pcs1900_cap = SUPPORTED;
1663 cm3->pcs1900_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class;
1664 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
1665 #ifdef GPRS
1666 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1667 rac->ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1668 #endif
1669 break;
1670
1671 case STD_850:
1672 cm3->v_gsm850_cap = SUPPORTED;
1673 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
1674 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1675 #ifdef GPRS
1676 rac->ra_cap_values.acc_tech_typ = ACC_GSM_850;
1677 rac->ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1678 #endif
1679 break;
1680
1681 case STD_DUAL_US:
1682 cm3->v_gsm850_cap = SUPPORTED;
1683 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
1684 cm3->v_pcs1900_cap = SUPPORTED;
1685 cm3->pcs1900_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class;
1686
1687 /* note: in case the sc isn't set, it is out of range */
1688 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1689 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
1690 else
1691 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1692
1693 #ifdef GPRS
1694 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1695 {
1696 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
1697 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1698 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_850;
1699 rac->ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1700 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1701 }
1702 else
1703 {
1704 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1705 rac->ra_cap_values.acc_tech_typ = ACC_GSM_850;
1706 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1707 rac->ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1708 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1709 }
1710 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1711 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1712 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1713 #endif
1714 break;
1715
1716 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1717 case STD_900_1900:
1718 cm3->v_radio_cap_1 = TRUE;
1719 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
1720 cm3->v_pcs1900_cap = SUPPORTED;
1721 cm3->pcs1900_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class;
1722 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1723 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
1724 else
1725 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1726 #ifdef GPRS
1727 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1728 {
1729 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1730 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_E;
1731 rac->ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1732 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1733 }
1734 else
1735 {
1736 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1737 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1738 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1739 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1740 }
1741 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1742 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1743 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1744 #endif
1745 break;
1746
1747 case STD_850_1800:
1748 cm3->v_radio_cap_1 = TRUE;
1749 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class;
1750 cm3->v_gsm850_cap = SUPPORTED;
1751 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
1752 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1753 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1754 else
1755 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1756 #ifdef GPRS
1757 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1758 {
1759 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1760 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_850;
1761 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1762 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1763 }
1764 else
1765 {
1766 rac->ra_cap_values.acc_tech_typ = ACC_GSM_850;
1767 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1768 rac->ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1769 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1770 }
1771 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1772 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1773 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1774 #endif
1775 break;
1776
1777 case STD_850_900_1900:
1778 cm3->v_gsm850_cap = SUPPORTED;
1779 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
1780 cm3->v_pcs1900_cap = SUPPORTED;
1781 cm3->pcs1900_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class;
1782 cm3->v_radio_cap_1 = TRUE;
1783 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
1784 /* note: in case the sc is´nt set, it is out of range */
1785 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1786 cm2->rf_pow_cap = cm3->pcs1900_cap - 1;
1787 else if (INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850))
1788 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1789 else
1790 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1791
1792 #ifdef GPRS
1793 if (INRANGE(LOW_CHANNEL_1900,serving_cell,HIGH_CHANNEL_1900))
1794 {
1795 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1796 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_850;
1797 rac->ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1798 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1799 }
1800 else
1801 {
1802 if (INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850))
1803 {
1804 rac->ra_cap_values.acc_tech_typ = ACC_GSM_850;
1805 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1806 rac->ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1807 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1808 }
1809 else
1810 {
1811 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1812 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1900;
1813 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1814 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->pcs1900_cap;
1815 }
1816 }
1817 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1818 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1819 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1820 #endif
1821 break;
1822 case STD_850_900_1800:
1823 cm3->v_radio_cap_1 = TRUE;
1824 cm3->radio_cap_1 = rfc->rf_power.pow_class4[IDX_PWRCLASS_900].pow_class;
1825 cm3->v_radio_cap_2 = TRUE;
1826 cm3->radio_cap_2 = rfc->rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class;
1827 cm3->v_gsm850_cap = SUPPORTED;
1828 cm3->gsm850_cap = rfc->rf_power.pow_class4[IDX_PWRCLASS_850].pow_class;
1829 /* note: in case the sc is´nt set, it is out of range */
1830 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1831 cm2->rf_pow_cap = cm3->radio_cap_2 - 1;
1832 else if (INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850))
1833 cm2->rf_pow_cap = cm3->gsm850_cap - 1;
1834 else
1835 cm2->rf_pow_cap = cm3->radio_cap_1 - 1;
1836 #ifdef GPRS
1837 if (INRANGE(LOW_CHANNEL_1800,serving_cell,HIGH_CHANNEL_1800))
1838 {
1839 rac->ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1840 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_E;
1841 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_2;
1842 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1843 }
1844 else
1845 {
1846 if (INRANGE(LOW_CHANNEL_850,serving_cell,HIGH_CHANNEL_850))
1847 {
1848 rac->ra_cap_values.acc_tech_typ = ACC_GSM_850;
1849 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1850 rac->ra_cap_values.acc_cap.pow_class = cm3->gsm850_cap;
1851 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_2;
1852 }
1853 else
1854 {
1855 rac->ra_cap_values.acc_tech_typ = ACC_GSM_E;
1856 rac->ra_cap_r[0].ra_cap_values.acc_tech_typ = ACC_GSM_1800;
1857 rac->ra_cap_values.acc_cap.pow_class = cm3->radio_cap_1;
1858 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_class = cm3->radio_cap_2;
1859 }
1860 }
1861 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_a5_bits = NOT_SUPPORTED;
1862 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_ms_struct = NOT_SUPPORTED;
1863 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1864 #endif
1865 break;
1866 #endif
1867
1868 default:
1869 break;
1870 }
1871
1872 cm1->rf_pow_cap = cm2->rf_pow_cap;
1873
1874 #if defined(_SIMULATION_) && defined(RFCAP_TEST)
1875 rr_csf_trace_power ();
1876 #endif /* RFCAP_TEST*/
1877
1878 /*Set 8psk capability in uplink for EGPRS*/
1879 #if defined(FF_EGPRS)
1880
1881 /*Initialize with 8psk is not supported in uplink*/
1882 cm3->v_egde_struct = NOT_SUPPORTED;
1883 rac->ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1884 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = NOT_SUPPORTED;
1885
1886 switch (std)
1887 {
1888 case STD_900:
1889 case STD_EGSM:
1890 case STD_850:
1891 if (rfc->mod)
1892 {
1893 if (rfc->rf_power.egde_pow1)
1894 {
1895 cm3->v_egde_struct = TRUE;
1896 cm3->egde_struct.mod = SUPPORTED;
1897 cm3->egde_struct.v_egde_pow1 = TRUE;
1898 cm3->egde_struct.egde_pow1 = rfc->rf_power.egde_pow1;
1899 rac->ra_cap_values.acc_cap.v_pow_8psk_cap = TRUE;
1900 rac->ra_cap_values.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow1;
1901 TRACE_EVENT_P1 ("1: 8PSK SUPPORTED (EGPRS) POWER CLASS E1 = %d",rac->ra_cap_values.acc_cap.pow_8psk_cap);
1902 }
1903 }
1904 break;
1905 case STD_1800:
1906 case STD_1900:
1907 if (rfc->mod)
1908 {
1909 if (rfc->rf_power.egde_pow2)
1910 {
1911 cm3->v_egde_struct = TRUE;
1912 cm3->egde_struct.mod = SUPPORTED;
1913 cm3->egde_struct.v_egde_pow2 = TRUE;
1914 cm3->egde_struct.egde_pow2 = rfc->rf_power.egde_pow2;
1915 rac->ra_cap_values.acc_cap.v_pow_8psk_cap = TRUE;
1916 rac->ra_cap_values.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow2;
1917 TRACE_EVENT_P1 ("2: 8PSK SUPPORTED (EGPRS) POWER CLASS E2 = %d",rac->ra_cap_values.acc_cap.pow_8psk_cap);
1918 }
1919 }
1920 break;
1921 case STD_DUAL:
1922 case STD_DUAL_EGSM:
1923 case STD_DUAL_US:
1924 if ((rac->ra_cap_values.acc_tech_typ EQ ACC_GSM_1800) OR (rac->ra_cap_values.acc_tech_typ EQ ACC_GSM_1900))
1925 {
1926 if (rfc->mod)
1927 {
1928 if (rfc->rf_power.egde_pow2)
1929 {
1930 /*8psk is supported in uplink in 1800/1900 BAND*/
1931 cm3->v_egde_struct = TRUE;
1932 cm3->egde_struct.mod = SUPPORTED;
1933 cm3->egde_struct.v_egde_pow2 = TRUE;
1934 cm3->egde_struct.egde_pow2 = rfc->rf_power.egde_pow2;
1935 rac->ra_cap_values.acc_cap.v_pow_8psk_cap = TRUE;
1936 rac->ra_cap_values.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow2;
1937 TRACE_EVENT_P1 ("3: 8PSK SUPPORTED (EGPRS) POWER CLASS E2 = %d",rac->ra_cap_values.acc_cap.pow_8psk_cap);
1938 }
1939 if (rfc->rf_power.egde_pow1)
1940 {
1941 /*Set 8psk capability for 850/900 BAND*/
1942 cm3->v_egde_struct = TRUE;
1943 cm3->egde_struct.mod = SUPPORTED;
1944 cm3->egde_struct.v_egde_pow1 = TRUE;
1945 cm3->egde_struct.egde_pow1 = rfc->rf_power.egde_pow1;
1946 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = TRUE;
1947 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow1;
1948 TRACE_EVENT_P1 ("4: 8PSK SUPPORTED (EGPRS) POWER CLASS E1 = %d",rac->ra_cap_values.acc_cap.pow_8psk_cap);
1949 }
1950 }
1951 }
1952 else
1953 {
1954 if (rfc->mod)
1955 {
1956 if (rfc->rf_power.egde_pow1)
1957 {
1958 /*8psk is supported in uplink in 1800/1900*/
1959 cm3->v_egde_struct = TRUE;
1960 cm3->egde_struct.mod = SUPPORTED;
1961 cm3->egde_struct.v_egde_pow1 = TRUE;
1962 cm3->egde_struct.egde_pow1 = rfc->rf_power.egde_pow1;
1963 rac->ra_cap_values.acc_cap.v_pow_8psk_cap = TRUE;
1964 rac->ra_cap_values.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow1;
1965 TRACE_EVENT_P1 ("5: 8PSK SUPPORTED (EGPRS) POWER CLASS E1 = %d",rac->ra_cap_values.acc_cap.pow_8psk_cap);
1966 }
1967 if (rfc->rf_power.egde_pow2)
1968 {
1969 /*Set 8psk capability for 850/900*/
1970 cm3->v_egde_struct = TRUE;
1971 cm3->egde_struct.mod = SUPPORTED;
1972 cm3->egde_struct.v_egde_pow2 = TRUE;
1973 cm3->egde_struct.egde_pow2 = rfc->rf_power.egde_pow2;
1974 rac->ra_cap_r[0].ra_cap_values.acc_cap.v_pow_8psk_cap = TRUE;
1975 rac->ra_cap_r[0].ra_cap_values.acc_cap.pow_8psk_cap = rfc->rf_power.egde_pow2;
1976 TRACE_EVENT_P1 ("6: 8PSK SUPPORTED (EGPRS) POWER CLASS E2 = %d",rac->ra_cap_values.acc_cap.pow_8psk_cap);
1977 }
1978 }
1979 }
1980 break;
1981 default:
1982 break;
1983 }
1984 #endif /* FF_EGPRS */
1985
1986 if (rfc->rf_ms.dtm_g)
1987 {
1988 cm3->v_dtm_ms = SUPPORTED;
1989 cm3->dtm_ms.mac_support = rfc->mac_support;
1990 cm3->dtm_ms.dtm_g_ms_class = rfc->rf_ms.dtm_g_ms_class;
1991 #ifdef GPRS
1992 rac->ra_cap_values.acc_cap.ms_struct.v_dtm_struct = SUPPORTED;
1993 rac->ra_cap_values.acc_cap.ms_struct.dtm_struct.dtm_g_ms_class = rfc->rf_ms.dtm_g_ms_class;
1994 rac->ra_cap_values.acc_cap.ms_struct.dtm_struct.mac_support = rfc->mac_support;
1995 #endif
1996
1997 #if defined(FF_EGPRS)
1998 if (rfc->rf_ms.dtm_e)
1999 {
2000 cm3->dtm_ms.v_dtm_e_ms_class = SUPPORTED;
2001 cm3->dtm_ms.dtm_e_ms_class = rfc->rf_ms.dtm_e_ms_class;
2002 #ifdef GPRS
2003 rac->ra_cap_values.acc_cap.ms_struct.v_dtm_struct = SUPPORTED;
2004 rac->ra_cap_values.acc_cap.ms_struct.dtm_struct.v_dtm_e_ms_class = SUPPORTED;
2005 rac->ra_cap_values.acc_cap.ms_struct.dtm_struct.dtm_e_ms_class = rfc->rf_ms.dtm_e_ms_class;
2006 #endif
2007 }
2008 #endif /* FF_EGDE */
2009 }
2010
2011 #ifdef GPRS
2012
2013 #if 0 /* CR 637 */
2014 if (rfc->rf_ms.hscsd_ms_class)
2015 {
2016 rac->ra_cap_values.acc_cap.v_ms_struct = SUPPORTED;
2017 rac->ra_cap_values.acc_cap.ms_struct.v_hscsd_ms_class = SUPPORTED;
2018 rac->ra_cap_values.acc_cap.ms_struct.hscsd_ms_class = rfc->rf_ms.hscsd_ms_class;
2019 }
2020 #endif
2021
2022 if (rfc->rf_ms.gprs_ms_class)
2023 {
2024 rac->ra_cap_values.acc_cap.ms_struct.v_gprs_struct = SUPPORTED;
2025 rac->ra_cap_values.acc_cap.ms_struct.gprs_struct.gprs_ms_class = rfc->rf_ms.gprs_ms_class;
2026 rac->ra_cap_values.acc_cap.ms_struct.gprs_struct.gprs_eda = rfc->gprs_eda;
2027 }
2028
2029 if (rfc->meas)
2030 {
2031 rac->ra_cap_values.acc_cap.ms_struct.v_sms_sm_value = SUPPORTED;
2032 rac->ra_cap_values.acc_cap.ms_struct.sms_sm_value.sms_val = rfc->sms_val;
2033 rac->ra_cap_values.acc_cap.ms_struct.sms_sm_value.sm_val = rfc->sm_val;
2034 }
2035
2036 #if 0 /* CR 637 */
2037 if (rfc->rf_ms.ecsd_ms_class)
2038 {
2039 rac->ra_cap_values.acc_cap.v_ms_struct = SUPPORTED;
2040 rac->ra_cap_values.acc_cap.ms_struct.v_ecsd_ms_class = SUPPORTED;
2041 rac->ra_cap_values.acc_cap.ms_struct.ecsd_ms_class = rfc->rf_ms.ecsd_ms_class;
2042 }
2043 #endif
2044
2045 #if defined(FF_EGPRS)
2046 if (rfc->rf_ms.egprs_ms_class)
2047 {
2048 cm3->v_edge_ms_class = TRUE;
2049 cm3->edge_ms_class = rfc->rf_ms.egprs_ms_class;
2050 rac->ra_cap_values.acc_cap.ms_struct.v_egprs_struct = TRUE;
2051 rac->ra_cap_values.acc_cap.ms_struct.egprs_struct.egprs_ms_class = rfc->rf_ms.egprs_ms_class;
2052 rac->ra_cap_values.acc_cap.ms_struct.egprs_struct.egprs_eda = rfc->egprs_eda;
2053 }
2054 #endif
2055
2056 if ((rac->c_ra_cap_r > 0) AND rac->ra_cap_values.acc_cap.v_ms_struct)
2057 {
2058 rac->v_ra_cap_r = TRUE;
2059 rac->ra_cap_r[0].ra_cap_values.acc_cap.rev99 = RELEASE99;
2060
2061 rac->ra_cap_r[0].ra_cap_values.acc_cap.compact = rfc->compact;
2062 rac->ra_cap_r[0].ra_cap_values.acc_cap.es_ind = rfc->es_ind;
2063 rac->ra_cap_r[0].ra_cap_values.acc_cap.ps = rfc->ps;
2064 rac->ra_cap_r[0].ra_cap_values.acc_cap.vbs = rfc->vbs;
2065 rac->ra_cap_r[0].ra_cap_values.acc_cap.vgcs = rfc->vgcs;
2066
2067 #if defined(FF_EGPRS)
2068 if (rfc->rf_ms.egprs_ms_class)
2069 {
2070 rac->ra_cap_r[0].ra_cap_values.acc_cap.ms_struct.v_egprs_struct = TRUE;
2071 rac->ra_cap_r[0].ra_cap_values.acc_cap.ms_struct.egprs_struct.egprs_ms_class = rfc->rf_ms.egprs_ms_class;
2072 rac->ra_cap_r[0].ra_cap_values.acc_cap.ms_struct.egprs_struct.egprs_eda = rfc->egprs_eda;
2073 }
2074 #endif
2075
2076 }
2077 #endif
2078
2079 #if defined TI_PS_FF_REL99_AND_ABOVE
2080 /* To support SAIC release 6 feature */
2081 cm3->v_gsm700_cap = NOT_SUPPORTED;
2082 cm3->umts_tdd_128 = NOT_SUPPORTED;
2083 cm3->geran_feat_pack_1 = NOT_SUPPORTED;
2084 cm3->v_ext_dtm_ms = NOT_SUPPORTED;
2085 cm3->v_high_ms_cap = NOT_SUPPORTED;
2086 cm3->geran_iu_mod_cap = NOT_SUPPORTED;
2087 cm3->geran_feat_pack_2 = NOT_SUPPORTED;
2088 cm3->gmsk_ms_pwr_prof = MS_PWR_PROF0;
2089 cm3->psk8_ms_pwr_prof = MS_PWR_PROF0;
2090 cm3->v_t_gsm400_struct = NOT_SUPPORTED;
2091 cm3->v_t_gsm900_cap = NOT_SUPPORTED;
2092 cm3->dtm_enhance_cap = NOT_SUPPORTED;
2093 cm3->v_dtm_high_ms = NOT_SUPPORTED;
2094 #ifdef L1_SAIC
2095 /* To support SAIC release 6 feature */
2096 cm3->dl_adv_rx_per = DL_ADVANC_RX_PERF_PHASE1_SUPPORT;
2097 #else
2098 cm3->dl_adv_rx_per = DL_ADVANC_RX_PERF_NOT_SUPPORT;
2099 #endif /* L1_SAIC */
2100 #ifdef FF_REPEATED_SACCH
2101 cm3->rep_acch_cap = REP_SACCH_DL_FACCH;
2102 #else
2103 cm3->rep_acch_cap = REP_DL_FACCH;
2104 #endif /* FF_REPEATED_SACCH */
2105 #endif /* TI_PS_FF_REL99_AND_ABOVE */
2106
2107 #if defined(_SIMULATION_) && !defined(NTRACE)
2108 rr_csf_trace_class1 (cm1);
2109 rr_csf_trace_class2 (cm2);
2110 rr_csf_trace_class3 (cm3);
2111 #endif /* _SIMULATION_ && !NTRACE */
2112 /*
2113 * note: cm3->umts_fdd, cm3->umts_tdd, cm3->cdma2000, cm3->v_single_band and
2114 * cm3->single_band are hard coded to 0 due to the lack of information about
2115 * these features inside the T_rf_cap structure
2116 */
2117 return 0;
2118 }
2119 #endif
2120
2121 /*
2122 +--------------------------------------------------------------------+
2123 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2124 | STATE : code ROUTINE : RX_Enable |
2125 +--------------------------------------------------------------------+
2126
2127 PURPOSE : This function enables reporting of RX level.
2128
2129 */
2130 static T_VOID_FUNC rx_driver_entry = NULL;
2131 static UBYTE rx_act_value = 0;
2132 static UBYTE rx_act_qual = RX_QUAL_UNAVAILABLE;
2133 #ifdef FF_PS_RSSI
2134 static UBYTE rx_act_rxlev_access_min = RX_ACCE_UNAVAILABLE;
2135 #endif
2136
2137 /*lint -esym(765,RX_Enable) | used by RX driver */
2138 /*lint -esym(714,RX_Enable) | used by RX driver */
2139 GLOBAL void RX_Enable (T_VOID_FUNC rx_indication)
2140 {
2141 /*
2142 * store callback function
2143 */
2144 rx_driver_entry = rx_indication;
2145 }
2146
2147 /*
2148 +--------------------------------------------------------------------+
2149 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2150 | STATE : code ROUTINE : RX_SetValue |
2151 +--------------------------------------------------------------------+
2152
2153 PURPOSE : This function stores a new fieldstrength value and
2154 informs the RX driver if possible about a change.
2155
2156 */
2157
2158 /*
2159 * for reduce number of indications during dedicated mode
2160 */
2161 static UBYTE rssi_dedi_counter = 0;
2162
2163 /*
2164 * Minimum RSSI difference for indication to MMI
2165 */
2166 #define RSSI_MIN_DIFFERENCE 5
2167 #define RSSI_MIN_LEVEL 10
2168
2169
2170 #ifdef FF_PS_RSSI
2171 GLOBAL void RX_SetValue (UBYTE new_value, UBYTE new_qual, UBYTE new_access)
2172 #else
2173 GLOBAL void RX_SetValue (UBYTE new_value)
2174 #endif
2175 {
2176 GET_INSTANCE_DATA;
2177 UBYTE rssi_delta;
2178
2179 #ifdef FF_PS_RSSI
2180 rx_act_rxlev_access_min = new_access;
2181 #endif
2182
2183 if (rx_driver_entry EQ NULL)
2184 {
2185 rx_act_value = new_value;
2186 #ifdef FF_PS_RSSI
2187 rx_act_qual = new_qual;
2188 #endif
2189 }
2190 else /*if a callback is installed*/
2191 {
2192
2193 /*
2194 * Compute delta compared to last MMI value
2195 */
2196 rssi_delta = ( new_value >= rx_act_value ?
2197 ( new_value - rx_act_value ) :
2198 ( rx_act_value - new_value )
2199 );
2200 /*
2201 * if difference greather than defined threshold
2202 * rx_qual is available in dedicated state only
2203 * Change in RX_QUAL
2204 */
2205 if ((rssi_delta >= RSSI_MIN_DIFFERENCE) OR (new_value < RSSI_MIN_LEVEL)
2206 #ifdef FF_PS_RSSI
2207 OR (new_qual NEQ rx_act_qual)
2208 #endif
2209 )
2210 {
2211 if ( GET_STATE (STATE_ATT) NEQ ATT_DEDICATED )
2212 {
2213 rx_act_value = new_value;
2214 #ifdef FF_PS_RSSI
2215 rx_act_qual = new_qual;
2216 #endif
2217 (*rx_driver_entry)();
2218 }
2219 else
2220 {
2221 /*
2222 * in dedicated mode take only each 16 the attempt
2223 * equal 8 seconds
2224 */
2225 if (!((rssi_dedi_counter ++ ) & 0x0F ))
2226 {
2227 /*
2228 * New RSSI to be forwarded
2229 */
2230 rx_act_value = new_value;
2231 #ifdef FF_PS_RSSI
2232 rx_act_qual = new_qual;
2233 #endif
2234 (*rx_driver_entry)();
2235 }
2236 }
2237 }
2238 }
2239 }
2240
2241 /*
2242 +--------------------------------------------------------------------+
2243 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2244 | STATE : code ROUTINE : RX_GetValue |
2245 +--------------------------------------------------------------------+
2246
2247 PURPOSE : This function simulates a low level driver call to get
2248 the actual fieldstrength.
2249
2250 */
2251 /*lint -esym(765,RX_GetValue) | used by RX driver */
2252 /*lint -esym(714,RX_GetValue) | used by RX driver */
2253 GLOBAL USHORT RX_GetValue (void)
2254 {
2255 USHORT rx_level;
2256
2257 rx_level = (USHORT)rx_act_value;
2258
2259 return rx_level;
2260 }
2261
2262 #ifdef FF_PS_RSSI
2263 /*
2264 +--------------------------------------------------------------------+
2265 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2266 | STATE : code ROUTINE : RX_GetRxLevAccessMin |
2267 +--------------------------------------------------------------------+
2268
2269 PURPOSE : This function simulates a low level driver call to get
2270 the minimum access level.
2271
2272 */
2273 GLOBAL UBYTE RX_GetRxLevAccessMin (void)
2274 {
2275 return rx_act_rxlev_access_min;
2276 }
2277 #endif
2278
2279 /*
2280 +--------------------------------------------------------------------+
2281 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2282 | STATE : code ROUTINE : RX_SetRxQual |
2283 +--------------------------------------------------------------------+
2284
2285 PURPOSE : This function simulates a low level driver call to set
2286 the actual RXQUAL value.
2287
2288 */
2289 /*lint -esym(765,RX_SetRxQual) | used by GRR */
2290 /*lint -esym(714,RX_SetRxQual) | used by GRR */
2291 GLOBAL void RX_SetRxQual (UBYTE new_rx_qual)
2292 {
2293 rx_act_qual = new_rx_qual;
2294 }
2295
2296 /*
2297 +--------------------------------------------------------------------+
2298 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2299 | STATE : code ROUTINE : RX_GetRxQual |
2300 +--------------------------------------------------------------------+
2301
2302 PURPOSE : This function simulates a low level driver call to get
2303 the actual RXQUAL value.
2304
2305 */
2306 /*lint -esym(765,RX_GetRxQual) | used by RX driver */
2307 /*lint -esym(714,RX_GetRxQual) | used by RX driver */
2308 GLOBAL UBYTE RX_GetRxQual (void)
2309 {
2310 return rx_act_qual;
2311 }
2312
2313 /*
2314 +--------------------------------------------------------------------+
2315 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2316 | STATE : code ROUTINE : rr_get_found_channels |
2317 +--------------------------------------------------------------------+
2318
2319 PURPOSE : This function is a little bit dirty solution to get
2320 the BCCH channel numbers of a PLMN available list.
2321
2322 */
2323 #if 0
2324 GLOBAL USHORT * rr_get_found_channels (void)
2325 {
2326 static USHORT found_channels[MAX_PLMN];
2327 int i;
2328 for (i=0; i<MAX_PLMN; i++)
2329 found_channels[i] = rr_data->sc_data.found[i].arfcn;
2330 return found_channels;
2331 }
2332 #endif
2333 /*
2334 +--------------------------------------------------------------------+
2335 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2336 | STATE : code ROUTINE : rr_get_bcch_channel |
2337 +--------------------------------------------------------------------+
2338
2339 PURPOSE : This function is a little bit dirty solution to get
2340 the BCCH channel numbers of the current PLMN.
2341
2342 */
2343 #if 0
2344 GLOBAL USHORT rr_get_bcch_channel (void)
2345 {
2346 return rr_data->nc_data[SC_INDEX].arfcn;
2347 }
2348 #endif
2349
2350 /*
2351 * These functions (get_network_meas() & get_bcch_chan_list()) should only
2352 * temporary defined here.
2353 */
2354 /*lint -esym(765,get_network_meas) | used by SIM */
2355 /*lint -esym(714,get_network_meas) | used by SIM */
2356 GLOBAL UBYTE get_network_meas (UBYTE * chan_list)
2357 {
2358 GET_INSTANCE_DATA;
2359 #if defined (_SIMULATION_)
2360 /*
2361 * fixed values for the windows simulation
2362 */
2363 memset (chan_list, 0, 16);
2364 chan_list [0] = 0x32;
2365 chan_list [1] = 0x16;
2366 chan_list [2] = 0x7E;
2367 chan_list [3] = 0x52;
2368 chan_list [4] = 0x37;
2369 return 1;
2370 #else /* _SIMULATION_ */
2371 switch (GET_STATE (STATE_ATT))
2372 {
2373 case ATT_IDLE:
2374 memset (chan_list, 0, 16);
2375 chan_list [0] = rr_data->nc_data[SC_INDEX].rxlev;
2376 return 1;
2377 case ATT_DEDICATED:
2378 memcpy (chan_list, dl_get_sacch_buffer(), 16);
2379 return 1;
2380 default:
2381 return 0;
2382 }
2383 #endif /* _SIMULATION_ */
2384 }
2385
2386 #ifdef REL99
2387 /*
2388 +--------------------------------------------------------------------+
2389 | PROJECT : GPRS EDGE MODULE : RR_CSF |
2390 | STATE : code ROUTINE : get_msc_release_version |
2391 +--------------------------------------------------------------------+
2392
2393 PURPOSE : use to get the MSC release version of the serving cell.
2394 */
2395
2396 GLOBAL void get_msc_release_version(UBYTE* mscr)
2397 {
2398 GET_INSTANCE_DATA;
2399 T_NC_DATA * rrd;
2400 rrd = &rr_data->nc_data[SC_INDEX];
2401 *mscr = rrd->mscr_flag;
2402 }
2403 #endif
2404
2405
2406 /*
2407 +--------------------------------------------------------------------+
2408 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2409 | STATE : code ROUTINE : get_bcch_chan_list |
2410 +--------------------------------------------------------------------+
2411
2412 PURPOSE : This function returns the network measurement results
2413 in the SIM TOOLKIT Format.
2414
2415 */
2416 #if defined (_SIMULATION_)
2417 /*
2418 * predefined values for windows simulation
2419 */
2420 static USHORT win_list[MAX_NEIGHBOURCELLS] = { 124, 512, 17, 0xFFFF,
2421 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2422 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2423 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2424 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2425 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2426 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2427 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
2428 0xFFFF } ;
2429 #endif /* _SIMULATION_ */
2430 /*lint -esym(765,get_bcch_chan_list) | used by SIM */
2431 /*lint -esym(714,get_bcch_chan_list) | used by SIM */
2432 GLOBAL UBYTE get_bcch_chan_list (stk_data_type * out_stk_data)
2433 {
2434 GET_INSTANCE_DATA;
2435 UBYTE i;
2436 UBYTE value;
2437 #if defined (_SIMULATION_)
2438 USHORT * ncell_list = win_list;
2439 #else /* _SIMULATION_ */
2440 USHORT * ncell_list = rr_data->act_ncell_list;
2441 #endif /* _SIMULATION_ */
2442
2443 #if !defined (_SIMULATION_)
2444 switch (GET_STATE (STATE_ATT))
2445 {
2446 case ATT_IDLE:
2447 case ATT_DEDICATED:
2448 #endif /* !_SIMULATION_ */
2449
2450 /*
2451 * clear output parameter
2452 */
2453 memset (out_stk_data->stk_parameter, 0, sizeof (out_stk_data->stk_parameter));
2454 for (i=0;i<MAX_NEIGHBOURCELLS;i++)
2455 {
2456 if (ncell_list[i] EQ NOT_PRESENT_16BIT)
2457 {
2458 /*
2459 * if no further channel is available
2460 * calculate length in bytes
2461 * number of channels a 10 bit
2462 */
2463 out_stk_data->stk_length = (i*10+7)/8;
2464 return 1;
2465 }
2466 /*
2467 * channel is available
2468 * then use basic CCD function to add to bitstream
2469 */
2470 value = ncell_list[i] >> 8;
2471 ccd_codeByte (out_stk_data->stk_parameter, (USHORT)(i*10), 2, value);
2472 value = ncell_list[i] & 0xFF;
2473 ccd_codeByte (out_stk_data->stk_parameter, (USHORT)(i*10+2), 8, value);
2474 }
2475 /*
2476 * if no end indicator has been found
2477 * and all parameters are channels
2478 * calculate length in bytes
2479 * number of channels a 10 bit.
2480 */
2481 out_stk_data->stk_length = (i*10+7)/8;
2482 return 1;
2483 #if !defined (_SIMULATION_)
2484 default:
2485 return 0;
2486 }
2487 #endif /* _SIMULATION_ */
2488 }
2489
2490
2491 #if defined(_SIMULATION_FFS_)
2492
2493 /*
2494 +--------------------------------------------------------------------+
2495 | PROJECT : GSM-PS (6103) MODULE : RR_CSF |
2496 | STATE : code ROUTINE : rr_csf_ffs_init |
2497 +--------------------------------------------------------------------+
2498
2499 PURPOSE :
2500
2501 */
2502
2503 LOCAL const char rr_white_list_name[] = "/gsm/l3/rr_white_list";
2504 LOCAL const char rr_black_list_name[] = "/gsm/l3/rr_black_list";
2505 LOCAL const char rr_lower_rxlev_thr_name[] = "/gsm/l3/rr_lower_rxlev_thr";
2506 LOCAL const char rr_medium_rxlev_thr_name[] = "/gsm/l3/rr_medium_rxlev_thr";
2507 LOCAL const char rr_upper_rxlev_thr_name[] = "/gsm/l3/rr_upper_rxlev_thr";
2508 LOCAL const char rr_shield_mcc_name[] = "/gsm/l3/shield";
2509
2510 GLOBAL void rr_csf_ffs_init(void)
2511 {
2512 TRACE_FUNCTION ("rr_csf_ffs_init()");
2513
2514 /* If MM has to create the directories for FFS, there is no point
2515 * in carry on with the initialisation
2516 */
2517 rr_csf_check_ffs_dirs();
2518
2519 /* Read white list from FFS */
2520 rr_csf_read_white_list();
2521
2522 /* Read Black List from FFS */
2523 rr_csf_read_black_list();
2524
2525 /* Read RXlevel thresholds from FFS */
2526 rr_csf_read_rxlev_thr();
2527 }
2528
2529
2530 /*
2531 +------------------------------------------------------------------+
2532 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2533 | STATE : code ROUTINE : rr_csf_write_white_list |
2534 +------------------------------------------------------------------+
2535
2536 PURPOSE : This function writes the White list information to FFS.
2537 CSI-LLD - 4.1.2.2.4
2538 */
2539
2540 GLOBAL void rr_csf_write_white_list(T_CS_WHITE_LIST *white_list)
2541 {
2542 TRACE_FUNCTION ("rr_csf_write_white_list()");
2543
2544 #if defined(_SIMULATION_)
2545 memcpy(&win_white_list,white_list,sizeof(T_CS_WHITE_LIST));
2546 #else
2547 rr_csf_check_ffs_dirs();
2548 rr_csf_handle_ffs_write_result(ffs_file_write(rr_white_list_name,
2549 white_list,
2550 sizeof(T_CS_WHITE_LIST),
2551 FFS_O_CREATE | FFS_O_RDWR));
2552 #endif
2553
2554 TRACE_EVENT("White List written to FFS");
2555 }
2556
2557 /*
2558 +-----------------------------------------------------------------+
2559 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2560 | STATE : code ROUTINE : rr_csf_read_white_list |
2561 +-----------------------------------------------------------------+
2562
2563 PURPOSE : This function read the White list information from FFS.
2564 CSI-LLD - 4.1.2.2.5
2565 */
2566
2567 GLOBAL void rr_csf_read_white_list(void)
2568 {
2569 GET_INSTANCE_DATA;
2570 TRACE_FUNCTION ("rr_csf_read_white_list()");
2571
2572 TRACE_EVENT("Read White List from FFS");
2573
2574 #if defined(_SIMULATION_)
2575 memcpy(&rr_data->cs_data.white_list,&win_white_list,sizeof(T_CS_WHITE_LIST));
2576 #else
2577 rr_csf_check_ffs_dirs();
2578 if(!rr_csf_handle_ffs_read_result(ffs_file_read(rr_white_list_name,
2579 &rr_data->cs_data.white_list,
2580 sizeof(T_CS_WHITE_LIST))))
2581 {
2582 /* In case of read error, reset the White List */
2583 cs_clear_white_list(CLR_WHITE_LIST_RAM);
2584 }
2585 #endif
2586 }
2587
2588 /*
2589 +-----------------------------------------------------------------------+
2590 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2591 | STATE : code ROUTINE : rr_csf_write_black_list |
2592 +-----------------------------------------------------------------------+
2593
2594 PURPOSE : This function wirtes "Black List" information to FFS.
2595 In case of windows simulation environment, "Black List" is
2596 stored to simulated FFS area.
2597 This function is called during switch off.
2598 CSI-LLD section:4.1.1.5.3
2599 */
2600
2601 GLOBAL void rr_csf_write_black_list(T_LIST *black_list)
2602 {
2603 TRACE_FUNCTION ("rr_csf_write_black_list()");
2604
2605 #if defined(_SIMULATION_)
2606 memcpy(&win_black_list[0],black_list,MAX_REGIONS*sizeof(T_LIST));
2607 #else
2608 rr_csf_check_ffs_dirs();
2609 rr_csf_handle_ffs_write_result(ffs_file_write (rr_black_list_name,
2610 black_list,
2611 MAX_REGIONS*sizeof(T_LIST),
2612 FFS_O_CREATE | FFS_O_RDWR));
2613 #endif
2614
2615 TRACE_EVENT("Black List written to FFS");
2616 }
2617
2618
2619 /*
2620 +------------------------------------------------------------------------+
2621 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2622 | STATE : code ROUTINE : rr_csf_read_black_list |
2623 +------------------------------------------------------------------------+
2624
2625 PURPOSE : This function copies "Black List" information from FFS to RR
2626 internal "Black List" data structures. In case of windows
2627 simulation environment, "Black List" is read from simulated FFS
2628 area. This function is called after power on
2629 Cell Selection Improvements-LLD section:4.1.1.5.4
2630 */
2631
2632 GLOBAL void rr_csf_read_black_list(void)
2633 {
2634 GET_INSTANCE_DATA;
2635 TRACE_FUNCTION ("rr_csf_read_black_list()");
2636
2637 TRACE_EVENT("Read Black List from FFS");
2638
2639 #if defined(_SIMULATION_)
2640 memcpy(&rr_data->cs_data.black_list.list[0],&win_black_list[0],
2641 MAX_REGIONS*sizeof(T_LIST));
2642 #else
2643 rr_csf_check_ffs_dirs();
2644 if(!rr_csf_handle_ffs_read_result(ffs_file_read (rr_black_list_name,
2645 &rr_data->cs_data.black_list.list[0],
2646 MAX_REGIONS*sizeof(T_LIST))))
2647 {
2648 /* In case of read error, reset the Black List */
2649 cs_clear_black_list(CLR_BLACK_LIST_RAM);
2650 }
2651 #endif
2652 }
2653
2654 /*
2655 +-----------------------------------------------------------------------+
2656 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2657 | STATE : code ROUTINE : rr_csf_write_rxlev_thr |
2658 +-----------------------------------------------------------------------+
2659
2660 PURPOSE : This function wirtes "RXLevel Threshold" information to FFS.
2661 In case of windows simulation environment, "RXLevel Threshold" is
2662 stored to simulated FFS area.
2663 This function is called during dynamic configuration.
2664 */
2665
2666 GLOBAL void rr_csf_write_rxlev_thr(UBYTE rxt, SHORT valno, char* val[MAX_NUM_BANDS])
2667 {
2668 GET_INSTANCE_DATA;
2669 UBYTE i, rxlev_thr_val;
2670 UBYTE *rxlev_thr = NULL;
2671 #if defined(_SIMULATION_)
2672 UBYTE *win_rxlev_thr = NULL;
2673 #endif
2674 const char *rxlev_thr_name, *rxlev_thr_string;
2675 rxlev_thr_name = NULL;
2676 rxlev_thr_string = NULL;
2677 TRACE_FUNCTION ("rr_csf_write_rxlev_thr()");
2678
2679 switch(rxt)
2680 {
2681 case U_RXT: rxlev_thr_string = "Upper";
2682 rxlev_thr = &rr_data->dyn_config.upper_rxlev_thr[0];
2683 rxlev_thr_name = &rr_upper_rxlev_thr_name[0];
2684 #if defined(_SIMULATION_)
2685 win_rxlev_thr = &win_upper_rxlev_thr[0];
2686 #endif
2687 break;
2688 case M_RXT: rxlev_thr_string = "Medium";
2689 rxlev_thr = &rr_data->dyn_config.medium_rxlev_thr[0];
2690 rxlev_thr_name = &rr_medium_rxlev_thr_name[0];
2691 #if defined(_SIMULATION_)
2692 win_rxlev_thr = &win_medium_rxlev_thr[0];
2693 #endif
2694 break;
2695 case L_RXT: rxlev_thr_string = "Lower";
2696 rxlev_thr = &rr_data->dyn_config.lower_rxlev_thr[0];
2697 rxlev_thr_name = &rr_lower_rxlev_thr_name[0];
2698 #if defined(_SIMULATION_)
2699 win_rxlev_thr = &win_lower_rxlev_thr[0];
2700 #endif
2701 break;
2702 default:
2703 return;
2704 }
2705
2706 for( i=0 ; i<valno ; i++ )
2707 {
2708 rxlev_thr_val = atoi(val[i]);
2709 if( rxlev_thr_val > 0 AND rxlev_thr_val <= 63 )
2710 {
2711 rxlev_thr[i] = rxlev_thr_val;
2712 }
2713 else
2714 {
2715 TRACE_ERROR ("[PEI_CONFIG]: RxLev Threshold(0-63)-Incorrect Range");
2716 }
2717 }
2718 #if defined(_SIMULATION_)
2719 memcpy(win_rxlev_thr,rxlev_thr,MAX_NUM_BANDS*sizeof(UBYTE));
2720 #else
2721 rr_csf_check_ffs_dirs();
2722 rr_csf_handle_ffs_write_result(ffs_file_write(rxlev_thr_name,
2723 rxlev_thr,
2724 MAX_NUM_BANDS*sizeof(UBYTE),
2725 FFS_O_CREATE | FFS_O_RDWR));
2726 #endif
2727 TRACE_EVENT_P6("%s RxLev Threshold written to FFS: GSM 850=%d, PGSM 900=%d, DCS 1800=%d, PCS 1900=%d, EGSM=%d",
2728 rxlev_thr_string, rxlev_thr[B_GSM_850], rxlev_thr[B_GSM_900],
2729 rxlev_thr[B_DCS_1800], rxlev_thr[B_PCS_1900], rxlev_thr[B_E_GSM] );
2730
2731 }
2732
2733 /*
2734 +------------------------------------------------------------------------+
2735 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2736 | STATE : code ROUTINE : rr_csf_read_rxlev_thr |
2737 +------------------------------------------------------------------------+
2738
2739 PURPOSE : This function copies "RXLevel Threshold" information from FFS to RR
2740 internal "RXLevel Threshold" arrays. In case of windows
2741 simulation environment, "RXLevel Threshold" is read from simulated FFS
2742 area. This function is called after power on
2743 */
2744
2745 GLOBAL void rr_csf_read_rxlev_thr(void)
2746 {
2747
2748 UBYTE x;
2749 GET_INSTANCE_DATA;
2750 TRACE_FUNCTION ("rr_csf_read_rxlev_thr()");
2751
2752 TRACE_EVENT("Read RXLevel thresholds from FFS");
2753
2754 #if defined(_SIMULATION_)
2755 memcpy(rr_data->dyn_config.lower_rxlev_thr,win_lower_rxlev_thr,
2756 MAX_NUM_BANDS*sizeof(UBYTE));
2757 memcpy(rr_data->dyn_config.medium_rxlev_thr,win_medium_rxlev_thr,
2758 MAX_NUM_BANDS*sizeof(UBYTE));
2759 memcpy(rr_data->dyn_config.upper_rxlev_thr,win_upper_rxlev_thr,
2760 MAX_NUM_BANDS*sizeof(UBYTE));
2761 #else
2762 rr_csf_check_ffs_dirs();
2763 if(!rr_csf_handle_ffs_read_result(ffs_file_read (rr_lower_rxlev_thr_name,
2764 rr_data->dyn_config.lower_rxlev_thr,
2765 MAX_NUM_BANDS*sizeof(UBYTE))))
2766 {
2767 for( x=0 ; x<MAX_NUM_BANDS ; x++ )
2768 {
2769 rr_data->dyn_config.lower_rxlev_thr[x] = LOWER_RXLEV_THRESHOLD;
2770 }
2771 rr_data->dyn_config.lower_rxlev_thr[B_GSM_850] = LOWER_RXLEV_THRESHOLD_850;
2772 }
2773 if(!rr_csf_handle_ffs_read_result(ffs_file_read (rr_medium_rxlev_thr_name,
2774 rr_data->dyn_config.medium_rxlev_thr,
2775 MAX_NUM_BANDS*sizeof(UBYTE))))
2776 {
2777 for( x=0 ; x<MAX_NUM_BANDS ; x++ )
2778 {
2779 rr_data->dyn_config.medium_rxlev_thr[x] = MEDIUM_RXLEV_THRESHOLD;
2780 }
2781 }
2782 if(!rr_csf_handle_ffs_read_result(ffs_file_read (rr_upper_rxlev_thr_name,
2783 rr_data->dyn_config.upper_rxlev_thr,
2784 MAX_NUM_BANDS*sizeof(UBYTE))))
2785 {
2786 for( x=0 ; x<MAX_NUM_BANDS ; x++ )
2787 {
2788 rr_data->dyn_config.upper_rxlev_thr[x] = UPPER_RXLEV_THRESHOLD;
2789 }
2790 }
2791 #endif
2792 }
2793
2794 /*
2795 +-----------------------------------------------------------------------+
2796 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2797 | STATE : code ROUTINE : rr_csf_write_mcc_shield_to_ffs|
2798 +-----------------------------------------------------------------------+
2799
2800 PURPOSE : This function writes the mcc shield values to FFS
2801 */
2802
2803 GLOBAL void rr_csf_write_mcc_shield_to_ffs(void)
2804 {
2805 GET_INSTANCE_DATA;
2806 UBYTE count;
2807 TRACE_FUNCTION ("rr_csf_write_mcc_shield_to_ffs()");
2808
2809 rr_csf_check_ffs_dirs();
2810 rr_csf_handle_ffs_write_result(ffs_file_write (rr_shield_mcc_name,
2811 &rr_data->dyn_config.mcc_shield,
2812 sizeof(T_shield_mcc),
2813 FFS_O_CREATE | FFS_O_RDWR));
2814 for(count=0;count<MAX_MCC_SHIELD;count++)
2815 {
2816 TRACE_EVENT_P5 ( "Shield MCC=%d%d%d enabled=[%d]index=[%d]",
2817 rr_data->dyn_config.mcc_shield.mcc[count][0],
2818 rr_data->dyn_config.mcc_shield.mcc[count][1],
2819 rr_data->dyn_config.mcc_shield.mcc[count][2],
2820 rr_data->dyn_config.mcc_shield.enabled,
2821 rr_data->dyn_config.mcc_shield.index);
2822 }
2823 }
2824 /*
2825 +--------------------------------------------------------------------+
2826 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2827 | STATE : code ROUTINE : rr_csf_mcc_present |
2828 +--------------------------------------------------------------------+
2829
2830 PURPOSE : This function is used to find mcc already present or not
2831 */
2832
2833 GLOBAL UBYTE rr_csf_mcc_present(UBYTE* mcc_value)
2834 {
2835 GET_INSTANCE_DATA;
2836 U8 count = 0;
2837 for(count = 0;count<MAX_MCC_SHIELD;count++)
2838 {
2839 if((memcmp(rr_data->dyn_config.mcc_shield.mcc[count],mcc_value,SIZE_MCC)EQ 0))
2840 {
2841 return TRUE;
2842 }
2843 }
2844 return FALSE;
2845 }
2846
2847
2848 /*
2849 +-----------------------------------------------------------------------+
2850 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2851 | STATE : code ROUTINE : rr_csf_handle_ffs_read_result |
2852 +-----------------------------------------------------------------------+
2853
2854 PURPOSE : This function checks the status from FFS and returns
2855 TRUE if there is no error and FALSE if there is
2856 */
2857 LOCAL BOOL rr_csf_handle_ffs_read_result(T_FFS_SIZE status_read)
2858 {
2859 if(status_read>0)
2860 {
2861 TRACE_EVENT ("FFS Read OK");
2862 return TRUE;
2863 }
2864 else
2865 {
2866 TRACE_EVENT_P1("FFS Read ERROR - %x", status_read);
2867 return FALSE;
2868 }
2869 }
2870
2871 /*
2872 +------------------------------------------------------------------------+
2873 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2874 | STATE : code ROUTINE : rr_csf_handle_ffs_write_result |
2875 +------------------------------------------------------------------------+
2876
2877 PURPOSE : This function checks the status from FFS and returns
2878 TRUE if there is no error and FALSE if there is
2879 */
2880 LOCAL BOOL rr_csf_handle_ffs_write_result(T_FFS_RET status_write)
2881 {
2882 if(status_write >= EFFS_OK)
2883 {
2884 TRACE_EVENT("FFS Write OK");
2885 if(status_write)
2886 TRACE_EVENT_P1 ("Bytes written: %d",status_write);
2887
2888 return(TRUE);
2889 }
2890 else
2891 {
2892 TRACE_EVENT_P1 ("FFS Write Error - Status: %x",status_write);
2893 return(FALSE);
2894 }
2895 }
2896
2897 /*
2898 +--------------------------------------------------------------------+
2899 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2900 | STATE : code ROUTINE : rr_csf_check_ffs_dirs |
2901 +--------------------------------------------------------------------+
2902
2903 PURPOSE : This routine creates the /gsm/l3 directory for the last used
2904 sc arfcn in the FFS. The return result indicates whether either
2905 directories existed or not. There is no error handling.
2906 */
2907
2908 LOCAL void rr_csf_check_ffs_dirs( void )
2909 {
2910 const char gsm_name[] = "/gsm";
2911 const char gsm_l3_name[] = "/gsm/l3";
2912
2913 rr_csf_create_ffs_dirs(gsm_name);
2914 rr_csf_create_ffs_dirs(gsm_l3_name);
2915 }
2916
2917 /*
2918 +--------------------------------------------------------------------+
2919 | PROJECT : GSM-PS (6147) MODULE : RR_CSF |
2920 | STATE : code ROUTINE : rr_csf_create_ffs_dirs |
2921 +--------------------------------------------------------------------+
2922
2923 PURPOSE : This routine calls the ffs_mkdir() routine to create a
2924 specified directory. It returns whether the directory
2925 existed or not prior to creation.
2926 */
2927 LOCAL void rr_csf_create_ffs_dirs(const char *dir_name)
2928 {
2929 T_FFS_RET status;
2930
2931 status=ffs_mkdir(dir_name);
2932 switch(status)
2933 {
2934 case EFFS_EXISTS:
2935 case EFFS_OK:
2936 break;
2937
2938 default: /*Error*/
2939 TRACE_EVENT_P1("Create Dir error - %x",status);
2940 break;
2941 }
2942 }
2943 #endif /* _SIMULATION_FFS_ */
2944
2945 #endif