FreeCalypso > hg > freecalypso-citrine

comparison g23m-gsm/rr/rr_cs.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 functions for Cell Selection
18 | capability of Radio Resource.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef RR_CS_C
23 #define RR_CS_C
24
25 #include "config.h"
26 #include "fixedconf.h"
27 #include "condat-features.h"
28
29 #define ENTITY_RR
30
31 /*==== INCLUDES ===================================================*/
32
33 #include <string.h>
34 #include <stdlib.h>
35 #include <stddef.h> /* offsetof */
36 #include "typedefs.h"
37 #include "pcm.h"
38 #include "pconst.cdg"
39 #include "mconst.cdg"
40 #include "message.h"
41 #include "ccdapi.h"
42 #include "vsi.h"
43 #include "custom.h"
44 #include "gsm.h"
45 #include "prim.h"
46 #include "cnf_rr.h"
47 #include "tok.h"
48 #include "rr.h"
49
50 /*==== EXPORT =====================================================*/
51
52 /*==== PRIVATE ====================================================*/
53 static void cs_remove_co_chan (USHORT arfcn, USHORT co_arfcn);
54 static void cs_remove_co_channels (USHORT arfcn);
55 static UBYTE cs_check_channel (USHORT arfcn);
56 static BOOL cs_sync_next_bsic (void);
57
58
59 /*==== VARIABLES ==================================================*/
60
61 EXTERN UBYTE test_house;
62
63 /*==== FUNCTIONS ==================================================*/
64
65 LOCAL void cs_add_current_network_to_found_list ();
66 LOCAL BOOL cs_check_black_list_criteria(U8 region, U16 arfcn, U8 rxlev);
67 LOCAL BOOL cs_is_in_black_list(U8 region, U16 arfcn);
68 LOCAL BOOL cs_is_in_white_list(U8 region, U16 arfcn);
69 LOCAL U8 cs_get_sync_fail_counter(U8 region, U16 arfcn);
70 LOCAL void cs_reset_sync_fail_counter(U8 region, U16 arfcn);
71 LOCAL void cs_inc_sync_fail_counter(U8 region, U16 arfcn);
72 LOCAL void cs_use_white_list_info(U8 num_of_chan);
73 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
74 LOCAL UBYTE cs_update_std_ffs (UBYTE new_std);
75 #else
76 LOCAL UBYTE get_band_index(USHORT arfcn);
77 #endif
78
79
80 /*
81 * -------------------------------------------------------------------
82 * Procedures
83 * -------------------------------------------------------------------
84 */
85
86 /*
87 * The cell selection process bases on attributes for each channel
88 * of the power campaign. This attributes are defined by a bitmap
89 *
90 * Bit 1 0 priority
91 * ---------------------------------
92 * 0 0 low priority
93 * 0 1 mid priority
94 * 1 0 high priority
95 * 1 1 reserved
96 *
97 * The selection of a cell for synchronisation depends on
98 * the priority and the fieldstrength. It will be the cell
99 * selected, which is not checked yet, has the highest
100 * priority and the highest fieldstrength.
101 *
102 * Bit 2 reserved
103 *
104 * Bit 3 checked flag
105 * ---------------------------------
106 * 0 cell is not checked
107 * 1 cell is checked
108 *
109 * The flag indicates whether a cell is already checked or not.
110 *
111 * Bit 4 detected flag
112 * ---------------------------------
113 * 0 bcch is not detected
114 * 1 bcch is checked
115 *
116 * The flag indicates whether a BCCH is detected or not.
117 *
118 * Bit 5 emergency cell flag
119 * ---------------------------------
120 * 0 emergency services possible
121 * 1 emergency services not possible
122 *
123 * The flag indicates whether emergency services are possible or not.
124 *
125 * Bit 6 low priority cell flag
126 * ---------------------------------
127 * 0 no low priority cell
128 * 1 low priority cell
129 *
130 * The flag indicates whether a cell has a low priority or not.
131 *
132 * Bit 8 BCCH info list flag
133 * ---------------------------------
134 * 0 not member of the BCCH info list
135 * 1 member of the BCCH info list
136 *
137 * The flag indicates whether a cell is member of the BCCH information
138 * list or not.
139 */
140
141 /*
142 +--------------------------------------------------------------------+
143 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
144 | STATE : code ROUTINE : cs_init_process |
145 +--------------------------------------------------------------------+
146
147 PURPOSE : Initialisation of the cell selection process.
148 Called from 'pei_init' exclusively and rr_deactivate.
149
150 */
151
152 GLOBAL void cs_init_process (void)
153 {
154 GET_INSTANCE_DATA;
155 TRACE_FUNCTION ("cs_init_process()");
156
157 /*
158 * set the state and clear all variables.
159 */
160 SET_STATE (STATE_CELL_SEL, CS_NULL);
161 memset (&rr_data->cs_data, 0, sizeof (&rr_data->cs_data));
162
163 rr_data->cs_data.arfcn_sc = NOT_PRESENT_16BIT;
164 rr_data->cs_data.arfcn_cr = NOT_PRESENT_16BIT;
165
166 /* CSI-LLD section:4.1.1.11 */
167 rr_data->cs_data.initial_plmn_search = INITIAL_PLMN_SEARCH_NOT_ACTIVE;
168
169 /* In all simulation testcases written prior to cell selection
170 * improvements feature, US_BIT and STD values were not set in
171 * the ARFCN field
172 */
173 #if !defined (_SIMULATION_)
174 rr_data->cs_data.region = NOT_PRESENT_8BIT;
175 #endif
176
177 rr_data->cs_data.white_list.last_sc_arfcn = NOT_PRESENT_16BIT;
178 rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT;
179 TRACE_EVENT_P1("white_list_region %d", rr_data->cs_data.white_list.region);
180
181 rr_data->start_cell_reselection = TRUE;
182 TRACE_EVENT_P1("start_cell_reselection %d", rr_data->start_cell_reselection);
183
184 /* Dynamic configuration parameters */
185 rr_data->dyn_config.bl_cs_en = TRUE;
186 rr_data->dyn_config.tfast_cs_val = TFAST_CS_VALUE;
187 rr_data->dyn_config.tnormal_cs_val = TNORMAL_CS_VALUE;
188 rr_data->dyn_config.lim_ser_nps_delay= DELAY_NON_PAR_SEARCH_LIM_SER;
189
190 #if defined(_SIMULATION_FFS_)
191 rr_csf_ffs_init();
192 #endif
193 }
194
195 /*
196 +--------------------------------------------------------------------+
197 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
198 | STATE : code ROUTINE : cs_set_bcch_info |
199 +--------------------------------------------------------------------+
200
201 PURPOSE : The function merges bcch information from SIM to White list
202 database
203 CSI-LLD - 4.1.2.2.1
204 */
205
206 GLOBAL void cs_set_bcch_info (T_bcch_info * sim_bcch_info)
207 {
208 GET_INSTANCE_DATA;
209 T_LIST tmp_list;
210 BUF_neigh_cell_desc cd;
211
212 TRACE_FUNCTION ("cs_set_bcch_info()");
213
214 /* Check for availability of sim_bcch_info data */
215 if(cs_check_region(rr_data->cs_data.white_list.region) AND
216 (sim_bcch_info NEQ NULL))
217 {
218 if(sim_bcch_info->v_bcch)
219 {
220 /* Store the sim_bcch_info data to white_list structure */
221 memcpy(cd.b_neigh_cell_desc,sim_bcch_info->bcch,BA_BITMAP_SIZE);
222 cd.o_neigh_cell_desc = 0;
223 cd.l_neigh_cell_desc = NCELL_DESC_BIT_LEN;
224
225 /* Merge BCCH info into white list */
226 for_create_channel_list((T_f_range *)&cd,&tmp_list);
227 srv_merge_list(&rr_data->cs_data.white_list.list,&tmp_list);
228 }
229 }
230 }
231
232 /*
233 +--------------------------------------------------------------------+
234 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
235 | STATE : code ROUTINE : cs_clear_white_list |
236 +--------------------------------------------------------------------+
237
238 PURPOSE : The function clears the bcch information (neigbour cell
239 description) of sys info 2, 2bis and 2ter stored in RAM
240 and FFS.
241 CSI-LLD - 4.1.2.2.6
242 */
243
244 GLOBAL void cs_clear_white_list(U8 clr_bcch_info)
245 {
246 GET_INSTANCE_DATA;
247 TRACE_FUNCTION ("cs_clear_white_list()");
248
249 if (clr_bcch_info & CLR_WHITE_LIST_SIM)
250 {
251 dat_send_bcchinfo_mm (NULL);
252
253 TRACE_EVENT ("White List: SIM cleared");
254 }
255
256 if (clr_bcch_info & CLR_WHITE_LIST_RAM)
257 {
258 rr_data->cs_data.arfcn_sc = NOT_PRESENT_16BIT;
259 rr_data->cs_data.arfcn_cr = NOT_PRESENT_16BIT;
260
261 memset(&rr_data->cs_data.white_list, 0 , sizeof(T_CS_WHITE_LIST));
262
263 rr_data->cs_data.white_list.last_sc_arfcn = NOT_PRESENT_16BIT;
264 rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT;
265
266 TRACE_EVENT ("White List: RAM cleared");
267 }
268
269 #if defined (_SIMULATION_FFS_)
270 if (clr_bcch_info & CLR_WHITE_LIST_FFS)
271 {
272 T_CS_WHITE_LIST white_list;
273 memset(&white_list,0,sizeof(T_CS_WHITE_LIST));
274
275 rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT;
276 rr_data->cs_data.white_list.last_sc_arfcn = NOT_PRESENT_16BIT;
277
278 rr_csf_write_white_list(&white_list);
279
280 TRACE_EVENT ("White List: FFS cleared");
281 }
282 #endif /* _SIMULATION_FFS_ */
283 }
284
285
286 #if defined (_SIMULATION_FFS_)
287 /*
288 +--------------------------------------------------------------------+
289 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
290 | STATE : code ROUTINE : cs_store_white_list |
291 +--------------------------------------------------------------------+
292
293 PURPOSE : The function stores while list information to FFS.
294 CSI-LLD - 4.1.2.2.3
295 */
296
297 GLOBAL void cs_store_white_list (void)
298 {
299 GET_INSTANCE_DATA;
300 /* Store the white List to FFS */
301 rr_csf_write_white_list(&rr_data->cs_data.white_list);
302 }
303 #endif /*_SIMULATION_FFS_*/
304
305 /*
306 +--------------------------------------------------------------------+
307 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
308 | STATE : code ROUTINE : cs_use_white_list_info |
309 +--------------------------------------------------------------------+
310
311 PURPOSE : The function uses the stored white list information and
312 increases the priority of these channels.
313 CSI-LLD - 4.1.2.2.8
314 */
315
316 LOCAL void cs_use_white_list_info(U8 num_of_chan)
317 {
318 GET_INSTANCE_DATA;
319 U8 i, priority;
320
321 TRACE_FUNCTION ("cs_use_white_list_info()");
322
323 /* Boot Time: If white list is invalidated by the second activate_req,
324 * decrease priority of white list carriers in power_cnf
325 */
326 priority = (cs_check_region(rr_data->cs_data.white_list.region)) ?
327 CS_HIGH_PRIORITY : CS_LOW_PRIORITY ;
328
329 for (i=0;i<num_of_chan;i++)
330 {
331 /*
332 * Power cnf always contains White list carriers at the top
333 */
334 rr_data->cs_data.attributes [i] = priority;
335
336 TRACE_EVENT_P3 ("Whie List: change prio of [%d]%u to 0x%02x",
337 rr_data->cs_data.arfcn[i]&ARFCN_MASK,
338 i, rr_data->cs_data.attributes [i]);
339 }
340 }
341
342 /*
343 +--------------------------------------------------------------------+
344 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
345 | STATE : code ROUTINE : cs_set_all |
346 +--------------------------------------------------------------------+
347
348 PURPOSE : The function clears all attributes and all stored BCCH
349 information.
350
351 */
352
353 GLOBAL void cs_set_all (void)
354 {
355 GET_INSTANCE_DATA;
356 TRACE_FUNCTION ("cs_set_all()");
357
358 /*
359 * clear all attributes
360 */
361 memset (&rr_data->cs_data.attributes, 0, sizeof (rr_data->cs_data.attributes));
362 }
363
364 /*
365 +--------------------------------------------------------------------+
366 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
367 | STATE : code ROUTINE : cs_set_freq_band |
368 +--------------------------------------------------------------------+
369
370 PURPOSE : This function sets the frequency band bit mask.
371
372 */
373
374 GLOBAL UBYTE cs_get_freq_band (UBYTE pch_interrupt)
375 {
376 UBYTE freq_bands;
377
378 rr_csf_get_freq_bands (&freq_bands);
379
380 if (!pch_interrupt)
381 {
382 /*
383 * Power measurements without PCH interruption => PLMN search
384 * ----------------------------------------------------------
385 * In this case we use the found and set value of 'std' for the frequency
386 * area to mask out not available frequencies from 'freq_bands'.
387 * Use only frequencies of the current area.
388 */
389 switch (std)
390 {
391 case STD_900:
392 freq_bands &= BAND_GSM_900;
393 break;
394 case STD_EGSM:
395 freq_bands &= BAND_E_GSM; /* BAND_GSM_900|BAND_E_GSM */
396 break;
397 case STD_1900:
398 freq_bands &= BAND_PCS_1900;
399 break;
400 case STD_1800:
401 freq_bands &= BAND_DCS_1800;
402 break;
403 case STD_DUAL:
404 freq_bands &= BAND_DUAL; /* BAND_GSM_900|BAND_DCS_1800 */
405 break;
406 case STD_DUAL_EGSM:
407 freq_bands &= BAND_DUAL_EXT; /* BAND_GSM_900|BAND_E_GSM|BAND_DCS_1800 */
408 break;
409 case STD_850:
410 freq_bands &= BAND_GSM_850;
411 break;
412 case STD_DUAL_US:
413 freq_bands &= BAND_DUAL_US; /* BAND_GSM_850|BAND_PCS_1900 */
414 break;
415 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
416 case STD_850_1800:
417 freq_bands &= BAND_850_1800; /* BAND_GSM_850|BAND_DCS_1800 */
418 break;
419 case STD_900_1900:
420 freq_bands &= BAND_900_1900; /* BAND_E_GSM|BAND_PCS_1900 */
421 break;
422 case STD_850_900_1800:
423 freq_bands &= BAND_850_900_1800; /* BAND_E_GSM|BAND_GSM_850|BAND_DCS_1800 */
424 break;
425 case STD_850_900_1900:
426 freq_bands &= BAND_850_900_1900; /* BAND_GSM_850|BAND_E_GSM|BAND_PCS_1900 */
427 break;
428 #endif
429 }
430 }
431 return freq_bands;
432 }
433
434 /*
435 +--------------------------------------------------------------------+
436 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
437 | STATE : code ROUTINE : get_band_index |
438 +--------------------------------------------------------------------+
439
440 PURPOSE : The function extracts the frequency band index from the given
441 'arfcn' parameter.
442 */
443
444 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
445 GLOBAL UBYTE cs_get_band_index (USHORT arfcn)
446 #else
447 GLOBAL UBYTE get_band_index (USHORT arfcn)
448 #endif
449 {
450 UBYTE local_std = STD_GET_FROM_ARFCN(arfcn);
451 UBYTE sc_band;
452
453 if(local_std EQ STD_NOT_PRESENT)
454 {
455 /* Parallel search case */
456 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
457 local_std = std;
458 #else
459 local_std = std_bands[std-1];
460 #endif
461 }
462
463 switch (local_std)
464 {
465 case STD_900:
466 sc_band = B_GSM_900;
467 break;
468
469 case STD_EGSM:
470 sc_band = B_E_GSM;
471 break;
472
473 case STD_1800:
474 sc_band = B_DCS_1800;
475 break;
476
477 case STD_1900:
478 sc_band = B_PCS_1900;
479 break;
480
481 case STD_850:
482 sc_band = B_GSM_850;
483 break;
484
485 case STD_DUAL:
486 if (arfcn >= LOW_CHANNEL_1800)
487 sc_band = B_DCS_1800;
488 else
489 sc_band = B_GSM_900;
490 break;
491
492 case STD_DUAL_EGSM:
493 if (arfcn >= LOW_CHANNEL_EGSM)
494 sc_band = B_E_GSM;
495 else if (arfcn >= LOW_CHANNEL_1800)
496 sc_band = B_DCS_1800;
497 else if (arfcn EQ CHANNEL_0)
498 sc_band = B_E_GSM;
499 else
500 sc_band = B_GSM_900;
501 break;
502
503 case STD_DUAL_US:
504 if (arfcn >= LOW_CHANNEL_1900)
505 sc_band = B_PCS_1900;
506 else
507 sc_band = B_GSM_850;
508 break;
509
510 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
511 case STD_850_1800:
512 if (arfcn >= LOW_CHANNEL_1800)
513 sc_band = B_DCS_1800;
514 else
515 sc_band = B_GSM_850;
516 break;
517
518 case STD_900_1900:
519 if (arfcn >= LOW_CHANNEL_EGSM)
520 sc_band = B_E_GSM;
521 else if (arfcn >= LOW_CHANNEL_1900)
522 sc_band = B_PCS_1900;
523 else if (arfcn EQ CHANNEL_0)
524 sc_band = B_E_GSM;
525 else
526 sc_band = B_GSM_900;
527 break;
528
529 case STD_850_900_1800:
530 if (arfcn >= LOW_CHANNEL_EGSM)
531 sc_band = B_E_GSM;
532 else if (arfcn >= LOW_CHANNEL_1800)
533 sc_band = B_DCS_1800;
534 else if (arfcn EQ CHANNEL_0)
535 sc_band = B_E_GSM;
536 else if (arfcn >= LOW_CHANNEL_850)
537 sc_band = B_GSM_850;
538 else
539 sc_band = B_GSM_900;
540 break;
541
542 case STD_850_900_1900:
543 if (arfcn >= LOW_CHANNEL_EGSM)
544 sc_band = B_E_GSM;
545 else if (arfcn >= LOW_CHANNEL_1900)
546 sc_band = B_PCS_1900;
547 else if (arfcn EQ CHANNEL_0)
548 sc_band = B_E_GSM;
549 else if (arfcn >= LOW_CHANNEL_850)
550 sc_band = B_GSM_850;
551 else
552 sc_band = B_GSM_900;
553 break;
554 #endif
555
556 default:
557 sc_band = MAX_NUM_BANDS;
558 break;
559 }
560 /* this trace causes a lot of trace load; switch on only if needed
561 TRACE_EVENT_P3 (" [%u] std=%02x, sc_band=%02x", arfcn&ARFCN_MASK, local_std, sc_band);
562 */
563 return sc_band;
564 }
565
566 /*
567 +--------------------------------------------------------------------+
568 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
569 | STATE : code ROUTINE : cs_start_scan |
570 +--------------------------------------------------------------------+
571
572 PURPOSE : This function starts the scanning. The power measurements
573 are triggered. Power measurements means that layer 1
574 performs fieldstrength measurements on all carriers and
575 sends a list of the best to RR back for FB/SB scanning and
576 BCCH reading. There are two variants: with or without
577 paging channel (PCH) interruption. If RR is already in
578 idle mode, scanning without PCH interruption is performed,
579 that means the MS is pageable during that time.
580
581 */
582
583 GLOBAL void cs_start_scan ()
584 {
585 GET_INSTANCE_DATA;
586 U16 arfcn;
587 U8 i=0;
588 U8 region;
589 PALLOC (mph_power_req, MPH_POWER_REQ);/* T_MPH_POWER_REQ */
590
591 TRACE_FUNCTION ("cs_start_scan()");
592
593 memset(mph_power_req,0,sizeof(T_MPH_POWER_REQ ));
594
595 TIMERSTOP (TREG);
596 rr_data->cs_data.act_index = NOT_PRESENT_8BIT;
597
598 switch (GET_STATE (STATE_CELL_SEL))
599 {
600 case CS_NULL:
601 case CS_NULL_ACTIVE:
602 /*
603 * start power measurements with PCH interruption
604 */
605 mph_power_req->pch_interrupt = PCH_INTERRUPT;
606 rr_data->first_meas_received = FALSE;
607 rr_data->resel_pending = FALSE;
608 rr_data->c_ncell_bcch = NOT_INITIALISED;
609 rr_data->cs_data.all_freq_area = FALSE;
610 /* In all simulation testcases written prior to cell selection
611 * improvements feature, US_BIT and STD values were not set in
612 * the ARFCN field
613 */
614 #if !defined (_SIMULATION_)
615 rr_data->cs_data.region = NOT_PRESENT_8BIT;
616 #endif
617
618 dat_att_null ();
619 SET_STATE (STATE_CELL_SEL, CS_NULL_ACTIVE);
620
621 /* stop possibly parallel search and allow start of cell reselection */
622 att_notify_stop_plmn_search (FALSE);
623 break;
624
625 case CS_IDLE:
626 case CS_IDLE_ACTIVE:
627 /*
628 * start power measurements without PCH interruption.
629 */
630 mph_power_req->pch_interrupt = NO_PCH_INTERRUPT;
631 SET_STATE (STATE_CELL_SEL, CS_IDLE_ACTIVE);
632
633 /* indicate suspend state of nc monitoring in lower layer */
634 rr_data->start_cell_reselection = FALSE;
635 TRACE_EVENT_P1("start_cell_reselection %d", rr_data->start_cell_reselection);
636 break;
637
638 default:
639 break;
640 }
641
642 #ifndef TI_PS_FF_QUAD_BAND_SUPPORT
643 mph_power_req->freq_bands = cs_get_freq_band (mph_power_req->pch_interrupt);
644 #endif
645
646 /* CSI-LLD : 4.1.3.4.1.4 */
647 /* Set the new search mode */
648 mph_power_req->search_mode = CS_GET_CURRENT_SEARCH_MODE;
649
650 /* Set Lower Rxlev threshold */
651 memcpy( mph_power_req->lower_rxlevel_threshold, rr_data->dyn_config.lower_rxlev_thr, MAX_NUM_BANDS*sizeof(UBYTE));
652
653 /* Copy the black list information */
654 for(i=0;i<MAX_REGIONS;i++)
655 {
656 srv_copy_list ((T_LIST *)&mph_power_req->black_list.list[i],
657 &rr_data->cs_data.black_list.list[i],sizeof(T_LIST));
658 }
659
660 /* In case of Black List search, include "grey" carriers also
661 * in the Black list while sending to ALR
662 */
663 if(CS_GET_CURRENT_SEARCH_MODE EQ BLACK_LIST_SEARCH_MODE)
664 {
665 TRACE_EVENT(" Black_List_Search_Started");
666
667 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
668 mph_power_req->freq_bands = cs_get_freq_band (FALSE);
669 #endif
670
671 region = rr_data->cs_data.region;
672
673 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
674 if (region EQ BOTH_REGIONS)
675 {
676 for (i=0; i<MAX_REGIONS; i++)
677 {
678 for(arfcn=CHANNEL_0;arfcn<CHANNEL_0_INTERNAL;arfcn++)
679 {
680 /* Since Black List search is always a parallel search, "grey" carriers
681 * belonging to the current region only have to be added
682 */
683 if(cs_get_sync_fail_counter(i,arfcn))
684 srv_set_channel((T_LIST*)&mph_power_req->black_list.list[i],arfcn);
685 }
686 }
687 }
688 else
689 {
690 #endif
691 for(arfcn=CHANNEL_0;arfcn<CHANNEL_0_INTERNAL;arfcn++)
692 {
693 /* Since Black List search is always a parallel search, "grey" carriers
694 * belonging to the current region only have to be added
695 */
696 if(cs_get_sync_fail_counter(region,arfcn))
697 srv_set_channel((T_LIST*)&mph_power_req->black_list.list[region],arfcn);
698 }
699 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
700 }
701 #endif
702 }
703 else
704 {
705 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
706 mph_power_req->freq_bands = cs_get_freq_band (TRUE);
707 #endif
708
709 TRACE_EVENT_P9 ( "White List:[%d]Reg,[%d]Arfcn, MCC/MNC r=%x%x%x/%x%x%x/%d",
710 rr_data->cs_data.white_list.region,
711 rr_data->cs_data.white_list.last_sc_arfcn,
712 rr_data->cs_data.white_list.last_sc_lac.mcc[0],
713 rr_data->cs_data.white_list.last_sc_lac.mcc[1],
714 rr_data->cs_data.white_list.last_sc_lac.mcc[2],
715 rr_data->cs_data.white_list.last_sc_lac.mnc[0],
716 rr_data->cs_data.white_list.last_sc_lac.mnc[1],
717 rr_data->cs_data.white_list.last_sc_lac.mnc[2],
718 rr_data->cs_data.white_list.last_sc_lac.lac);
719
720 /* Copy white list information
721 * White list cannot be used, when the region it belongs to, is not known
722 * or its PLMN ID does not match with the requested PLMN
723 */
724 if((!cs_check_region(rr_data->cs_data.white_list.region)) OR
725 ((rr_data->ms_data.req_mm_service NEQ FUNC_PLMN_SRCH) AND
726 (GET_STATE(STATE_ATT) NEQ ATT_CS_INIT)) OR
727 ((rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH) AND
728 (!dat_plmn_equal_req(rr_data->cs_data.white_list.last_sc_lac.mcc,
729 rr_data->cs_data.white_list.last_sc_lac.mnc,
730 rr_data->ms_data.plmn.mcc,
731 rr_data->ms_data.plmn.mnc))))
732 {
733 TRACE_EVENT("White List is not used");
734 }
735 else
736 {
737 /* Copy the white list information */
738 srv_copy_list((T_LIST*)&mph_power_req->white_list.list,
739 &rr_data->cs_data.white_list.list,sizeof (T_LIST));
740
741 /* Set the region */
742 mph_power_req->white_list.region = rr_data->cs_data.white_list.region;
743
744 /* White list is valid */
745 mph_power_req->white_list.white_list_valid = TRUE;
746 }
747 }
748
749 /* Handle the search mode timers based on the new search mode */
750 cs_handle_search_mode_timer(CS_GET_CURRENT_SEARCH_MODE);
751
752 /*
753 * reset the time for net search to finish
754 * a PLMN available search during 35 seconds.
755 */
756 if( rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI)
757 TIMERSTART(T_PLMN_SEARCH, T_PLMN_SEARCH_VALUE);
758
759 /*
760 * start power measurements in layer 1.
761 */
762 TRACE_EVENT_P2 ("cs_start_scan(): freq_bands=%02x Search Mode = %d",
763 mph_power_req->freq_bands,mph_power_req->search_mode);
764
765 PSENDX (PL, mph_power_req);
766 }
767
768 /*
769 +--------------------------------------------------------------------+
770 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
771 | STATE : code ROUTINE : cs_start_sync |
772 +--------------------------------------------------------------------+
773
774 PURPOSE : Start the synchronisation to FB/SB without power measurements.
775 Synchronisation to the frequency correction burst (FB) followed
776 by a synchronisation to the synchron burst (SB) is carried
777 out by layer 1. It means that the MS is synchronised to the
778 base station and then able to read the BCCH to check the cell.
779
780 */
781
782 GLOBAL void cs_start_sync (void)
783 {
784 GET_INSTANCE_DATA;
785 UBYTE i;
786
787 TRACE_FUNCTION ("cs_start_sync()");
788
789 /* While scanning for limited service, we scan all carriers */
790 if((CS_GET_PREVIOUS_SEARCH_MODE NEQ FAST_SEARCH_MODE) AND
791 (rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN))
792 {
793 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
794 /*
795 * reset check bit for all channels
796 */
797 rr_data->cs_data.attributes[i] &= CS_NON_CHECKED_BITS;
798 }
799
800 if (cs_sync_next_bsic () EQ FALSE)
801 {
802 /*
803 * indicate the end of scanning to attachment process
804 */
805 TIMERSTOP(T_PLMN_SEARCH);
806 att_no_bsic_ind ();
807 }
808 else
809 {
810 /*
811 * Another FB/SB scan is requested
812 */
813 SET_STATE (STATE_CELL_SEL, CS_IDLE_ACTIVE);
814 }
815 }
816
817
818 /*
819 +--------------------------------------------------------------------+
820 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
821 | STATE : code ROUTINE : cs_del_list |
822 +--------------------------------------------------------------------+
823
824 PURPOSE : A list of carriers (neighbourcell list) is used to speed up
825 the cell selection process. All members of the list and the
826 list of the power campaign are set to low priority.
827
828 */
829
830 GLOBAL void cs_del_list (T_LIST *list)
831 {
832 GET_INSTANCE_DATA;
833 UBYTE i;
834
835 TRACE_FUNCTION ("cs_del_list()");
836
837 /*
838 * for all cells of the power campaign list
839 */
840
841 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
842 {
843 /*
844 * if they are member of the given list and not just checked
845 */
846 if (srv_get_channel (list, (USHORT)(rr_data->cs_data.arfcn[i]&ARFCN_MASK)) AND
847 rr_data->cs_data.act_index NEQ i)
848 {
849 /*
850 * set to low priority
851 */
852 rr_data->cs_data.attributes [i] &= CS_SET_TO_LOW_PRIORITY;
853 /*TRACE_EVENT_P1("[%u] del from list",rr_data->cs_data.arfcn[i]);*/
854 }
855 }
856 }
857
858 /*
859 +--------------------------------------------------------------------+
860 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
861 | STATE : code ROUTINE : cs_set_list |
862 +--------------------------------------------------------------------+
863
864 PURPOSE : A list of carriers (neighbourcell list) is used to speed up
865 the cell selection process. All members of the list and the
866 list of the power campaign are set to high priority.
867
868
869 */
870
871 GLOBAL void cs_set_list (T_LIST *list)
872 {
873 GET_INSTANCE_DATA;
874 UBYTE i;
875
876 TRACE_FUNCTION ("cs_set_list()");
877
878 /*
879 * Not in the test house
880 */
881 if (rr_data->cell_test_operation OR
882 dat_test_sim_available ())
883 return;
884
885 /*
886 * for all channels in the power campaign list
887 */
888 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
889 {
890 /*
891 * if they are also member of the given list
892 */
893 if (srv_get_channel (list, (USHORT)(rr_data->cs_data.arfcn[i]&ARFCN_MASK)))
894 {
895 /*
896 * set to high priority
897 */
898 rr_data->cs_data.attributes [i] &= CS_SET_TO_LOW_PRIORITY;
899 rr_data->cs_data.attributes [i] += CS_HIGH_PRIORITY;
900 }
901 }
902 }
903
904 /*
905 +--------------------------------------------------------------------+
906 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
907 | STATE : code ROUTINE : cs_def_list |
908 +--------------------------------------------------------------------+
909
910 PURPOSE : Checks whether a member of the list has the requested
911 attributes (e.g. emergency or low priority cell)
912
913 */
914
915 GLOBAL UBYTE cs_def_list (UBYTE attribute)
916 {
917 GET_INSTANCE_DATA;
918 UBYTE i;
919 UBYTE result = FALSE;
920
921 TRACE_FUNCTION ("cs_def_list()");
922
923 /*
924 * for all channels of the power campaign list
925 */
926 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
927 {
928 /*
929 * check only cells which have high/mid priority
930 */
931 if ((rr_data->cs_data.attributes [i] & CS_CHECK_FLAG) EQ 0 AND
932 (rr_data->cs_data.attributes [i] & CS_PRIORITY) NEQ 0)
933 /*
934 * channel is not checked yet, so it is possible that
935 * the channel has this attribute
936 */
937 {
938 rr_data->cs_data.attributes [i] = CS_MID_PRIORITY;
939 result = TRUE;
940 }
941
942 /*
943 * check the attribute of the cell. If an attribute
944 * like emergency or low priority cell is set, the channel
945 * has been checked.
946 */
947 if (rr_data->cs_data.attributes[i] & attribute)
948 {
949 /*
950 * channel has this attribute, then set priority to high
951 */
952 rr_data->cs_data.attributes [i] &= CS_SET_TO_LOW_PRIORITY;
953 rr_data->cs_data.attributes [i] += CS_HIGH_PRIORITY;
954
955 /* reset check bit for this channel */
956 rr_data->cs_data.attributes[i] &= CS_NON_CHECKED_BITS;
957 result = TRUE;
958 }
959 }
960
961 return result;
962 }
963
964 /*
965 +--------------------------------------------------------------------+
966 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
967 | STATE : code ROUTINE : cs_sync_next |
968 +--------------------------------------------------------------------+
969
970 PURPOSE : The function starts the next FB/SB synchronisation request.
971 It selects the channel with the highest priority and field-
972 strength which is not checked yet.
973
974 */
975
976 GLOBAL BOOL cs_sync_next (void)
977 {
978 GET_INSTANCE_DATA;
979 TRACE_FUNCTION ("cs_sync_next()");
980
981 /*
982 * no further channel is possible
983 */
984 if (cs_sync_next_bsic () EQ FALSE)
985 {
986 /*
987 * stop any timer which controls cell selection
988 */
989 TIMERSTOP (T_RESELECT);
990 SET_STATE (STATE_CELL_SEL, CS_IDLE);
991
992 /*
993 * indicate end of search to attachment process
994 */
995 TIMERSTOP(T_PLMN_SEARCH);
996 att_no_bsic_ind ();
997
998 return FALSE;
999 }
1000
1001 return TRUE;
1002 }
1003
1004 /*
1005 +--------------------------------------------------------------------+
1006 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1007 | STATE : code ROUTINE : cs_sync_next_bsic |
1008 +--------------------------------------------------------------------+
1009
1010 PURPOSE : The function looks for the next candidate for a FB/SB
1011 sync request. The channel is not checked yet, has the
1012 highest priority and the highest fieldstrength.
1013 Return TRUE if another MPH_BSIC_REQ is sent.
1014 */
1015
1016 static BOOL cs_sync_next_bsic (void)
1017 {
1018 GET_INSTANCE_DATA;
1019 UBYTE i;
1020 UBYTE x = NOT_PRESENT_8BIT;
1021
1022 TRACE_FUNCTION ("cs_sync_next_bsic()");
1023
1024 /*
1025 * try to use 'found channel' from previous cell selection
1026 */
1027
1028 if( rr_data->found_channel NEQ NOT_PRESENT_16BIT )
1029 {
1030 for ( i = 0; i < rr_data->cs_data.max_arfcn; i++ )
1031 {
1032 if ( ((rr_data->cs_data.arfcn[i] & ARFCN_MASK) EQ
1033 (rr_data->found_channel & ARFCN_MASK)) AND
1034 ((rr_data->cs_data.arfcn[i] & US_BIT) EQ
1035 (rr_data->found_channel & US_BIT)) AND
1036 (rr_data->cs_data.attributes[i] & CS_CHECK_FLAG) EQ 0)
1037 {
1038 TRACE_EVENT ( "rr_found_channel in CS_DATA" );
1039 rr_data->found_channel = NOT_PRESENT_16BIT;
1040 x = i;
1041 break;
1042 }
1043 }
1044 }
1045
1046 /*
1047 * for all channels of the power campaign list
1048 */
1049 if ( x EQ NOT_PRESENT_8BIT )
1050 {
1051 for ( i=0; i < rr_data->cs_data.max_arfcn; i++ )
1052 {
1053 if ((rr_data->cs_data.attributes[i] & CS_CHECK_FLAG) EQ 0)
1054 {
1055 /*
1056 * channel is not checked yet
1057 */
1058 if (x EQ NOT_PRESENT_8BIT)
1059 {
1060 /*
1061 * first channel which is not checked yet
1062 */
1063 x = i;
1064
1065 /* High priority cell. Start sync */
1066 if((rr_data->cs_data.attributes[i] & CS_PRIORITY) EQ CS_HIGH_PRIORITY)
1067 break;
1068 }
1069 else
1070 {
1071 if ((rr_data->cs_data.attributes[i] & CS_PRIORITY) >
1072 (rr_data->cs_data.attributes[x] & CS_PRIORITY))
1073 {
1074 /*
1075 * new channel has higher priority
1076 */
1077 x = i;
1078 }
1079 }
1080 } /* CS_CHECK FLAG */
1081 } /* i < max_arfcn */
1082 } /* x NEQ NOT_PRESENT_8BIT */
1083
1084 if (x NEQ NOT_PRESENT_8BIT)
1085 {
1086 rr_data->cs_data.act_index = x;
1087
1088 if ((rr_data->ms_data.rr_service NEQ NO_SERVICE) AND
1089 (rr_data->cs_data.arfcn[x] EQ rr_data->nc_data[SC_INDEX].arfcn))
1090 {
1091 /*
1092 * Synchronization request for serving cell.
1093 * No need to send MPH_BSIC_REQ as we are already synchronized to
1094 * serving cell, instead fake MPH_BSIC_CNF.
1095 */
1096 PALLOC (mph_bsic_cnf, MPH_BSIC_CNF); /* T_MPH_BSIC_CNF */
1097 mph_bsic_cnf->arfcn = rr_data->cs_data.arfcn[x];
1098 mph_bsic_cnf->bsic = rr_data->nc_data[SC_INDEX].bsic;
1099 mph_bsic_cnf->cs = CS_NO_ERROR;
1100 if (srv_store_prim ((T_PRIM *)D2P(mph_bsic_cnf)))
1101 {
1102 TRACE_EVENT ("Shortcut for sync to SC taken");
1103 USE_STORED_ENTRIES();
1104 return TRUE;
1105 }
1106 else
1107 {
1108 /* In the unlikely event that we could not store the primitive */
1109 PFREE (mph_bsic_cnf);
1110 }
1111 }
1112 else
1113 {
1114
1115 /*
1116 *start BSIC Reading;For fast search, the first scan is only on reasonably strong carriers.i.e carrires with rxlev>MEDIUM_RXLEV_THRESHOLD
1117 *This is as per the cell selection improvements document. Hence dont send BSIC request on white listed low power carrires for first scan.
1118 *(OMAPS00109145)*/
1119 if( (rr_data->cs_data.previous_search_mode EQ FAST_SEARCH_MODE) AND (rr_data->cs_data.scan_mode NEQ CS_SECOND_SCAN) AND ( rr_data->cs_data.rxlev[x]<MEDIUM_RXLEV_THRESHOLD))
1120 return FALSE;
1121 else
1122 {
1123 PALLOC (mph_bsic_req, MPH_BSIC_REQ);
1124
1125 mph_bsic_req->arfcn = rr_data->cs_data.arfcn[x];
1126
1127 TRACE_EVENT_P3 ("BSIC REQ[%u]%u a=0x%x",
1128 rr_data->cs_data.arfcn[x] & ARFCN_MASK,
1129 x, rr_data->cs_data.attributes[x]);
1130
1131 PSENDX (PL, mph_bsic_req);
1132 }
1133 return TRUE;
1134 }
1135 }
1136 else
1137 return FALSE;
1138 }
1139
1140 /*
1141 +--------------------------------------------------------------------+
1142 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1143 | STATE : code ROUTINE : cs_set_null |
1144 +--------------------------------------------------------------------+
1145
1146 PURPOSE : Initialize the cell selection process.
1147
1148 */
1149
1150 GLOBAL void cs_set_null (void)
1151 {
1152 GET_INSTANCE_DATA;
1153 TRACE_FUNCTION ("cs_set_null()");
1154
1155 SET_STATE (STATE_CELL_SEL, CS_NULL);
1156 }
1157
1158 /*
1159 +--------------------------------------------------------------------+
1160 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1161 | STATE : code ROUTINE : cs_set_stop_active |
1162 +--------------------------------------------------------------------+
1163
1164 PURPOSE : The function resets the state of the cell selection
1165 process to an non-active state.
1166
1167 */
1168
1169 GLOBAL void cs_set_stop_active (void)
1170 {
1171 GET_INSTANCE_DATA;
1172 TRACE_FUNCTION ("cs_set_stop_active()");
1173
1174 switch (GET_STATE(STATE_CELL_SEL))
1175 {
1176 case CS_NULL:
1177 case CS_NULL_ACTIVE:
1178 SET_STATE (STATE_CELL_SEL, CS_NULL);
1179 break;
1180 case CS_IDLE:
1181 case CS_IDLE_ACTIVE:
1182 SET_STATE (STATE_CELL_SEL, CS_IDLE);
1183 break;
1184 }
1185 }
1186
1187 /*
1188 +--------------------------------------------------------------------+
1189 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1190 | STATE : code ROUTINE : cs_set_attributes |
1191 +--------------------------------------------------------------------+
1192
1193 PURPOSE : The function sets an attribute for a channel (e.g.
1194 emergency or low priority cell).
1195
1196 */
1197
1198 GLOBAL void cs_set_attributes (UBYTE attribute, USHORT arfcn)
1199 {
1200 GET_INSTANCE_DATA;
1201 UBYTE i;
1202
1203 TRACE_FUNCTION ("cs_set_attributes()");
1204
1205 /*
1206 * for all channels of the power campaign list
1207 */
1208 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
1209 {
1210 /*
1211 * if it is the given channel number, set the attributes.
1212 */
1213 if ((rr_data->cs_data.arfcn[i]&ARFCN_MASK) EQ arfcn)
1214 rr_data->cs_data.attributes [i] |= attribute;
1215 }
1216 }
1217
1218 /*
1219 +--------------------------------------------------------------------+
1220 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1221 | STATE : code ROUTINE : cs_set_rxlev |
1222 +--------------------------------------------------------------------+
1223
1224 PURPOSE : Updating of a fieldstrength value in the list of the
1225 power campaign.
1226
1227 */
1228
1229 GLOBAL void cs_set_rxlev (UBYTE rxlev, USHORT arfcn)
1230 {
1231 GET_INSTANCE_DATA;
1232 UBYTE i;
1233
1234 TRACE_FUNCTION ("cs_set_rxlev()");
1235
1236 /*
1237 * for all channels in the power campaign list
1238 */
1239 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
1240 {
1241 /*
1242 * if it is the given channel number, update the fieldstrength.
1243 */
1244 if ((rr_data->cs_data.arfcn[i]&ARFCN_MASK) EQ arfcn)
1245 rr_data->cs_data.rxlev [i] = rxlev;
1246 }
1247 }
1248
1249 /*
1250 +--------------------------------------------------------------------+
1251 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1252 | STATE : code ROUTINE : cs_clear_attributes |
1253 +--------------------------------------------------------------------+
1254
1255 PURPOSE : The function clears an attribute for a channel (e.g.
1256 emergency or low priority cell).
1257
1258 */
1259
1260 GLOBAL void cs_clear_attributes (UBYTE attribute, USHORT arfcn)
1261 {
1262 GET_INSTANCE_DATA;
1263 UBYTE i;
1264
1265 TRACE_FUNCTION ("cs_clear_attributes()");
1266
1267 /*
1268 * for all channels in the power campaign list
1269 */
1270 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
1271 {
1272 /*
1273 * if it is the given channel number, clear the attributes.
1274 */
1275 if ((rr_data->cs_data.arfcn[i]&ARFCN_MASK) EQ arfcn)
1276 rr_data->cs_data.attributes [i] &= ~attribute;
1277 }
1278 }
1279
1280 /*
1281 +--------------------------------------------------------------------+
1282 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1283 | STATE : code ROUTINE : cs_mph_power_cnf |
1284 +--------------------------------------------------------------------+
1285
1286 PURPOSE : The result of a power request to layer 1. Layer 1 returns
1287 a list of up to 40 GSM 900 + 40 DCS 1800 channels to RR.
1288
1289 */
1290
1291 GLOBAL void cs_mph_power_cnf (T_MPH_POWER_CNF * mph_power_cnf)
1292 {
1293 GET_INSTANCE_DATA;
1294 UBYTE i,j,rxlev;
1295 USHORT mask = 0xFFFF; /* no mask */
1296 U8 x;
1297 BOOL copy = TRUE;
1298
1299 TRACE_FUNCTION ("cs_mph_power_cnf()");
1300
1301 if(GET_STATE(STATE_ATT) EQ ATT_CS_INIT )
1302 {
1303 if( !srv_store_prim ((T_PRIM *)D2P(mph_power_cnf)) )
1304 {
1305 /*
1306 * primitive storing failed
1307 */
1308 PFREE (mph_power_cnf);
1309 SET_STATE(STATE_CELL_SEL, CS_NULL);
1310 SET_STATE(STATE_ATT, ATT_NULL);
1311 }
1312 else
1313 {
1314 /*
1315 * Boot Time: Do not store primitive for more than 10 s in case
1316 * of quick registration. If the second activate_req does not
1317 * come before this time move to ATT_NULL.
1318 * The T_RESELECT timer is used for a different purpose here.
1319 */
1320 TIMERSTART(T_RESELECT, TRESELECT_VALUE);
1321 }
1322 return;
1323 }
1324
1325 TRACE_EVENT_P1 ("mph_power_cnf: %u freq.", mph_power_cnf->num_of_chan);
1326
1327 for (i = 0; i < mph_power_cnf->num_of_chan; i++)
1328 {
1329 TRACE_EVENT_P3("[%4u] std=%u rx_lev=%2u",
1330 mph_power_cnf->arfcn[i]&ARFCN_MASK,
1331 STD_GET_FROM_ARFCN(mph_power_cnf->arfcn[i]),
1332 mph_power_cnf->rx_lev[i]);
1333 }
1334
1335 /* Remove the inactive carriers from Black List */
1336 if((CS_GET_CURRENT_SEARCH_MODE EQ BLACK_LIST_SEARCH_MODE) OR
1337 (mph_power_cnf->num_of_chan))
1338 {
1339 /* In case of "Full", "Normal" and "Fast" search modes, remove
1340 * inactive carriers from Black List, only when there is atleast
1341 * one strong carrier in that area
1342 */
1343 cs_rem_inactive_carriers_from_bl(mph_power_cnf);
1344 }
1345
1346 if(CS_GET_CURRENT_SEARCH_MODE NEQ BLACK_LIST_SEARCH_MODE)
1347 {
1348 /* Update previous search mode */
1349 CS_SET_PREVIOUS_SEARCH_MODE(CS_GET_CURRENT_SEARCH_MODE);
1350
1351 switch (GET_STATE(STATE_CELL_SEL))
1352 {
1353 case CS_IDLE_ACTIVE:
1354 /* We will start parallel scan in 2 cases
1355 1. After HPLMN timer expiry
1356 2. After TREG timer expiry
1357 In these both cases don't mask out std and US_BIT
1358 */
1359 #ifndef TI_PS_FF_QUAD_BAND_SUPPORT
1360 mask = ARFCN_MASK; /* for parallel search mask out 'std' and US_BIT. */
1361 #endif
1362 /*lint -fallthrough*/
1363 case CS_NULL_ACTIVE:
1364 /*
1365 * copy channel list from layer 1, set the number
1366 * of entries in the list
1367 */
1368 rr_data->cs_data.max_arfcn = mph_power_cnf->num_of_chan;
1369
1370 /*
1371 * for all channels coming from layer 1
1372 */
1373 for (i=0,j=0;i<mph_power_cnf->num_of_chan;i++)
1374 {
1375 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1376 x = cs_get_band_index(mph_power_cnf->arfcn[i]);
1377 #else
1378 x = get_band_index(mph_power_cnf->arfcn[i]);
1379 #endif
1380
1381 /* for OMAPS00109145, in which the I-Sample is not camping on to the agilent ,once down link failure is
1382 occured on current cell and at power levels < -100dB, this is because in the fast search mode we are not
1383 considering the low rxlev carriers. So this modification is required in order to come back to the network
1384 even after a down link failure has happened and if another BCCH carrer of less power become active and available
1385 for the mobile to camp */
1386
1387 rxlev = rr_data->dyn_config.lower_rxlev_thr[x];
1388 copy = TRUE;
1389
1390 if((i >= mph_power_cnf->num_of_white_list_chan) AND
1391 (mph_power_cnf->rx_lev[i] < rxlev))
1392
1393 {
1394 copy = FALSE;
1395 }
1396
1397 /*
1398 * check against band restrictions
1399 */
1400 if (copy AND cs_check_channel ((USHORT)(mph_power_cnf->arfcn[i]&ARFCN_MASK)))
1401 {
1402 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1403 /* For parallel search mask serving cell */
1404 if ((GET_STATE(STATE_CELL_SEL) EQ CS_IDLE_ACTIVE) AND (rr_data->nc_data[SC_INDEX].arfcn EQ (mph_power_cnf->arfcn[i]&ARFCN_MASK)))
1405 rr_data->cs_data.arfcn[j] = mph_power_cnf->arfcn[i]&ARFCN_MASK;
1406 else
1407 #endif
1408 rr_data->cs_data.arfcn[j] = mph_power_cnf->arfcn[i]&mask;
1409 rr_data->cs_data.rxlev[j] = mph_power_cnf->rx_lev[i];
1410 /*
1411 * set initial to middle priority
1412 */
1413 rr_data->cs_data.attributes [j++] = CS_MID_PRIORITY;
1414 }
1415 else
1416 {
1417 /*
1418 * a cell is not copied due to band restrictions
1419 */
1420 rr_data->cs_data.max_arfcn--;
1421 }
1422 }
1423
1424 TRACE_EVENT_P2("No_chan > [%d]min_rxlev copied:%d",rxlev,rr_data->cs_data.max_arfcn);
1425
1426 /* Increase the priority of white list carriers */
1427 if(rr_data->cs_data.max_arfcn )
1428 cs_use_white_list_info(mph_power_cnf->num_of_white_list_chan);
1429
1430 /*
1431 * add actual PLMN to the found list, if available
1432 */
1433 if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI AND
1434 GET_STATE(STATE_ATT) EQ ATT_IDLE AND
1435 (!rr_data->net_lost))
1436 cs_add_current_network_to_found_list ();
1437
1438 /*
1439 * Select channel with the highest fieldstrength and priority
1440 * and start BSIC scanning, else send signal that no further
1441 * channel is available
1442 */
1443 if (cs_sync_next_bsic () EQ FALSE)
1444 {
1445 SET_STATE (STATE_CELL_SEL, CS_IDLE);
1446 TIMERSTOP(T_PLMN_SEARCH);
1447 att_no_bsic_ind ();
1448 }
1449 else
1450 {
1451 SET_STATE (STATE_CELL_SEL, CS_IDLE_ACTIVE);
1452 }
1453
1454 /*
1455 * CS power measurements may be used to reorder arfcns'n in
1456 * MPH_NEIGHBOURCELL_REQ while TCSVALID is running
1457 */
1458 TIMERSTART(TCSVALID, THIRTY_SEC);
1459 break;
1460 }
1461 } /* NEQ black list search */
1462 else
1463 {
1464
1465 /* Stop the parallel PLMN search */
1466 att_notify_stop_plmn_search(FALSE);
1467
1468 SET_STATE (STATE_CELL_SEL, CS_IDLE);
1469
1470 /* Black list search is a temporary search. It is not used
1471 * in deciding the next search. Hence we need to update current search
1472 * mode when Black List search is over */
1473 CS_SET_CURRENT_SEARCH_MODE(CS_GET_PREVIOUS_SEARCH_MODE);
1474
1475
1476 } /* Black list search */
1477
1478 PFREE (mph_power_cnf);
1479 srv_use_stored_prim ();
1480 }
1481
1482 /*
1483 +--------------------------------------------------------------------+
1484 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1485 | STATE : code ROUTINE : cs_mph_bsic_cnf |
1486 +--------------------------------------------------------------------+
1487
1488 PURPOSE : The response of a FB/SB synchronisation request from layer 1.
1489
1490 */
1491
1492 GLOBAL void cs_mph_bsic_cnf (T_MPH_BSIC_CNF * mph_bsic_cnf)
1493 {
1494 GET_INSTANCE_DATA;
1495 U8 local_region;
1496 U16 local_arfcn;
1497
1498 TRACE_FUNCTION ("cs_mph_bsic_cnf()");
1499
1500 switch (GET_STATE (STATE_CELL_SEL))
1501 {
1502 case CS_IDLE_ACTIVE:
1503 if (mph_bsic_cnf->cs EQ CS_NO_ERROR)
1504 {
1505 UBYTE new_std = STD_GET_FROM_ARFCN(mph_bsic_cnf->arfcn);
1506 /*
1507 * FB / SB is decoded, cell has the attributes
1508 * BCCH detected and checked
1509 */
1510 /*
1511 * reset std from the current MPH_BSIC_CNF(only if it is non-zero)
1512 */
1513 TRACE_EVENT_P2("reset std: new_std = %d, old_std = %d", new_std, std);
1514 if(new_std)
1515 {
1516 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1517 UBYTE new_region;
1518
1519 std = cs_update_std_ffs (new_std);
1520 new_region = srv_get_region_from_std(std);
1521 TRACE_EVENT_P1("update std: new_std = %d", std);
1522 #else
1523 UBYTE new_region = srv_get_region_from_std(new_std);
1524
1525 std = new_std;
1526 #endif
1527
1528 /* Both American and European bands are detected in the current
1529 * region. Following TREG timer expiry in Limited Service state,
1530 * non-parallel search will be issued
1531 * CSI-LLD section:4.3
1532 */
1533 if(rr_data->cs_data.region NEQ NOT_PRESENT_8BIT)
1534 {
1535 if(rr_data->cs_data.region NEQ new_region)
1536 {
1537 rr_data->cs_data.all_freq_area = TRUE;
1538 TRACE_EVENT("all_freq_area : 1");
1539 }
1540 }
1541
1542 /* CSI-LLD section:4.1.1.3.12
1543 * This stores region in rr_data base by extracting from std
1544 */
1545 rr_data->cs_data.region = new_region;
1546 }
1547 /*
1548 * remove co channels
1549 */
1550 if (test_house EQ FALSE)
1551 cs_remove_co_channels ((USHORT)(mph_bsic_cnf->arfcn&ARFCN_MASK));
1552
1553 rr_data->cs_data.attributes [rr_data->cs_data.act_index] |=
1554 (CS_CHECK_FLAG | CS_BCCH_READ);
1555
1556 /* CSI-LLD section:4.1.1.11
1557 * Synchronisation succeeded. Remove the carrier from black list
1558 */
1559 cs_del_from_black_list(rr_data->cs_data.region,
1560 (U16)(mph_bsic_cnf->arfcn&ARFCN_MASK));
1561
1562 att_bsic_ind ((USHORT)(mph_bsic_cnf->arfcn&ARFCN_MASK),
1563 rr_data->cs_data.rxlev [rr_data->cs_data.act_index],
1564 mph_bsic_cnf->bsic);
1565 }
1566 else
1567 {
1568 /*
1569 * FB / SB is not decoded, cell has the attributes
1570 * BCCH not detected and checked
1571 */
1572 rr_data->cs_data.attributes [rr_data->cs_data.act_index] |= CS_CHECK_FLAG;
1573
1574 /* Extract region information */
1575
1576 local_arfcn = rr_data->cs_data.arfcn[rr_data->cs_data.act_index];
1577
1578 if(STD_GET_FROM_ARFCN(local_arfcn) NEQ STD_NOT_PRESENT)
1579 {
1580 /* During Non-Parallel search, region information is available
1581 * in ARFCN
1582 */
1583 local_region = CS_GET_REGION_FROM_FREQ(local_arfcn);
1584 }
1585 else
1586 {
1587 /* Parallel search case */
1588 local_region = srv_get_region_from_std(std);
1589 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
1590 if (local_region EQ BOTH_REGIONS)
1591 local_region = srv_get_region_from_std_arfcn (std, local_arfcn);
1592 #endif
1593 }
1594
1595 /* CSI-LLD section:4.1.1.6
1596 * Sync failed. Add the carrier to Black list
1597 */
1598 cs_add_to_black_list(local_region,
1599 (U16)(local_arfcn),
1600 rr_data->cs_data.rxlev[rr_data->cs_data.act_index]);
1601
1602 /* CSI-LLD section:4.1.1.11
1603 * Set the BLACK LIST attribute flag for this carrier
1604 */
1605 if(rr_data->cs_data.initial_plmn_search EQ INITIAL_PLMN_SEARCH_ACTIVE)
1606 {
1607 CS_SET_BLACK_LIST_FLAG(rr_data->cs_data.act_index);
1608 }
1609
1610 if (cs_sync_next_bsic () EQ FALSE)
1611 {
1612 TIMERSTOP(T_PLMN_SEARCH);
1613 SET_STATE (STATE_CELL_SEL, CS_IDLE);
1614 att_no_bsic_ind (); /* stop in RR */
1615 }
1616 }
1617 break;
1618
1619 #ifdef GPRS
1620 case CS_CCO:
1621 SET_STATE (STATE_CELL_SEL, CS_IDLE);
1622 if (rr_data->gprs_data.cr_pbcch_active OR rr_data->gprs_data.cr_pcco_active)
1623 {
1624 /*
1625 * a Packet Cell Change Order for a cell which
1626 * is not in the BA list has been requested by the NW
1627 */
1628 if (mph_bsic_cnf->cs EQ CS_NO_ERROR AND
1629 (mph_bsic_cnf->arfcn&ARFCN_MASK) EQ rr_data->gprs_data.arfcn AND
1630 mph_bsic_cnf->bsic EQ rr_data->gprs_data.bsic )
1631 {
1632 /*
1633 * PL successfuly sycnhronized to the cell
1634 * now RR will do a normal Cell Reselection
1635 */
1636 memset (&rr_data->nc_data[CR_INDEX],
1637 0,
1638 sizeof (T_NC_DATA));
1639 rr_data->nc_data[CR_INDEX].arfcn = mph_bsic_cnf->arfcn&ARFCN_MASK;
1640 rr_data->nc_data[CR_INDEX].bsic = mph_bsic_cnf->bsic;
1641
1642 /* CSI-LLD section:4.1.1.11
1643 * Synchronisation succeeded. Remove the carrier from black list
1644 */
1645 cs_del_from_black_list(rr_data->cs_data.region,
1646 (U16)(mph_bsic_cnf->arfcn&ARFCN_MASK));
1647
1648 if( rr_data->gprs_data.cr_pbcch_active )
1649 att_start_cell_reselection_pbcch(MODE_CELL_RESELECTION);
1650 else
1651 {
1652 att_init_cell_selection(CELL_RESELECTION, RR_ORIGINATED);
1653 rr_data->dyn_config.fcr = 0;
1654 rr_data->dyn_config.scr = 0;
1655 rr_data->bcch_error = 0;
1656 rr_data->pag_rec = FALSE;
1657 srv_clear_stored_prim (MPH_PAGING_IND);
1658 gprs_init_data_cr();
1659 dat_att_null();
1660 SET_STATE (STATE_ATT, ATT_CS3);
1661 att_build_idle_req (CR_INDEX, MODE_CELL_RESELECTION);
1662 }
1663 }
1664 else
1665 {
1666 /*
1667 * PL did not sycnhronize to the cell
1668 * inform GRR and wait for a CR_REQ(CR_REQ) with
1669 * the old cell and return to it
1670 */
1671 PALLOC(gprs_ind, RRGRR_GPRS_SI13_IND);
1672 rr_data->gprs_data.cr_pbcch_active = FALSE;
1673
1674 gprs_ind->cause = GPRS_CELL_NOT_SUITABLE;
1675 gprs_ind->serving_cell_info.bcch_arfcn = rr_data->gprs_data.arfcn;
1676 gprs_ind->serving_cell_info.bcch_bsic = rr_data->gprs_data.bsic;
1677
1678 TRACE_EVENT_P4 ("cs=%u C[%d] bsic=%u #%u",
1679 gprs_ind->cause,
1680 gprs_ind->serving_cell_info.bcch_arfcn,
1681 gprs_ind->serving_cell_info.bcch_bsic,
1682 __LINE__);
1683
1684 PSENDX(GRR, gprs_ind);
1685 /* wait for CR_REQ for old cell */
1686 }
1687 }
1688 else
1689 if (mph_bsic_cnf->cs EQ CS_NO_ERROR AND
1690 (mph_bsic_cnf->arfcn&ARFCN_MASK) EQ rr_data->gprs_data.arfcn AND
1691 mph_bsic_cnf->bsic EQ rr_data->gprs_data.bsic )
1692 {
1693 rr_data->gprs_data.tbf_est = TBF_EST_CCO;
1694
1695 rr_data->nc_data[CR_INDEX].arfcn = rr_data->gprs_data.arfcn;
1696 rr_data->nc_data[CR_INDEX].rxlev = 0;
1697 rr_data->nc_data[CR_INDEX].bsic = rr_data->gprs_data.bsic;
1698
1699 att_init_cr_data();
1700 TIMERSTART (T_RESELECT, TRESELECT_VALUE);
1701 rr_data->nc_data[CR_INDEX].bcch_error = 0;
1702 srv_clear_list (&rr_data->cr_data.cd.ncell_list);
1703 SET_STATE (STATE_ATT, ATT_CS2);
1704
1705 /* CSI-LLD section:4.1.1.11
1706 * Synchronisation succeeded. Remove the carrier from black list
1707 */
1708 cs_del_from_black_list(rr_data->cs_data.region,
1709 (U16)(mph_bsic_cnf->arfcn&ARFCN_MASK));
1710 /* wait for System Information Messages */
1711 }
1712 else /* initiate switch back to old cell */
1713 {
1714 dat_code_mph_old_chan_req();
1715
1716 PFREE ( rr_data->gprs_data.dl_data_ind );
1717 rr_data->gprs_data.dl_data_ind = NULL;
1718
1719 rr_data->gprs_data.reconn_cause = RRC_PROT_UNSPECIFIED;
1720 rr_data->gprs_data.cco_need_reconnect_cnf = FALSE;
1721 SET_STATE (STATE_DAT, DAT_CCO_3);
1722 }
1723 break;
1724
1725 case CS_XMEAS:
1726
1727 /* enter result in rr_data->gprs_data.rrgrr_ext_meas_cnf, call att_ext_meas_next_bsic */
1728
1729 {
1730 UBYTE bsic = mph_bsic_cnf->bsic;
1731 T_GPRS_DATA *gprs_data = &rr_data->gprs_data;
1732 T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req;
1733
1734
1735 if ( rrgrr_ext_meas_req->report_type EQ REP_TYPE_1 OR /* "6 strongest carriers independent of BSIC decoding or not" */
1736 rrgrr_ext_meas_req->report_type EQ REP_TYPE_2 AND /* "BSICs for 6 carriers with decoded BSIC with allowed NCC" */
1737 mph_bsic_cnf->cs EQ CS_NO_ERROR AND
1738 (rrgrr_ext_meas_req->ncc_permitted & (1 << ((bsic>>3) & 0x07)))) /* check for "NCC allowed" */
1739 {
1740 T_RRGRR_EXT_MEAS_CNF *rrgrr_ext_meas_cnf = gprs_data->rrgrr_ext_meas_cnf;
1741 T_MPH_EXT_MEAS_CNF *mph_ext_meas_cnf = gprs_data->mph_ext_meas_cnf;
1742 UBYTE n = gprs_data->mph_ext_meas_num;
1743 USHORT arfcn = mph_ext_meas_cnf->arfcn[n];
1744 UBYTE rx_lev = mph_ext_meas_cnf->rx_lev[n];
1745 UBYTE idx = rr_ext_meas_idx ( arfcn );
1746 UBYTE k = rrgrr_ext_meas_cnf->c_xmeas_res++;
1747 T_xmeas_res *xmeas_res = &rrgrr_ext_meas_cnf-> xmeas_res[k];
1748
1749 /*
1750 * Function att_ext_meas_next_bsic checks for the maximum number of elements in the
1751 * array rrgrr_ext_meas_cnf->xmeas_res. Therefore this check is not performed here.
1752 */
1753
1754 xmeas_res->arfcn_idx.arfcn = arfcn;
1755 xmeas_res->arfcn_idx.idx = idx;
1756 xmeas_res->rxlev = rx_lev;
1757 if (mph_bsic_cnf->cs EQ CS_NO_ERROR)
1758 xmeas_res->bsic = bsic;
1759 else
1760 xmeas_res->bsic = RRGRR_INVALID_BSIC;
1761 }
1762 }
1763
1764 rr_data->gprs_data.mph_ext_meas_num++;
1765 att_ext_meas_next_bsic();
1766 break;
1767 #endif
1768 default:
1769 break;
1770 }
1771 PFREE (mph_bsic_cnf);
1772 }
1773
1774
1775 /*
1776 +--------------------------------------------------------------------+
1777 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1778 | STATE : code ROUTINE : cs_get_channel_from_found_list |
1779 +--------------------------------------------------------------------+
1780
1781 PURPOSE : If a network available list was created in former times
1782 (found_plmn / found_channel) and one of this networks is
1783 requested, the associated channel is stored to give it
1784 high priority to speed up cell selection.
1785
1786 */
1787 GLOBAL void cs_get_channel_from_found_list ()
1788 {
1789 GET_INSTANCE_DATA;
1790 UBYTE i;
1791 T_FOUND_ELEMENT * found;
1792
1793 TRACE_FUNCTION ("cs_get_channel_from_found_list()");
1794
1795 /*
1796 * initialise the local variable
1797 */
1798 rr_data->found_channel = NOT_PRESENT_16BIT;
1799
1800 /*
1801 * for all PLMNs stored in the found list
1802 */
1803 found = &rr_data->sc_data.found[0];
1804 for (i=0; i<rr_data->sc_data.found_entries; i++, found++)
1805 {
1806 /*
1807 * if the network in the found list is equal to the PLMN requested by MM,
1808 * set the found channel
1809 */
1810 /* Implements Measure#32: Row 124 */
1811 att_print_mcc_mnc(found->arfcn, found->plmn.mcc, found->plmn.mnc, S2I_STRING("list"));
1812 if (dat_plmn_equal_req (found->plmn.mcc,
1813 found->plmn.mnc,
1814 rr_data->ms_data.plmn.mcc,
1815 rr_data->ms_data.plmn.mnc))
1816 {
1817 rr_data->found_channel = found->arfcn;
1818
1819 /* Embed region information in the found channel arfcn */
1820 if(found->region EQ AMERICAN_REGION)
1821 rr_data->found_channel |= US_BIT;
1822 /* Implements Measure#32: Row 125 */
1823 att_print_mcc_mnc(found->arfcn, found->plmn.mcc, found->plmn.mnc, S2I_STRING("found_channel"));
1824 return;
1825 }
1826 }
1827 }
1828
1829 /*
1830 +--------------------------------------------------------------------+
1831 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1832 | STATE : code ROUTINE : cs_clear_channel_from_found_list |
1833 +--------------------------------------------------------------------+
1834
1835 PURPOSE : If a network available list was created in former times
1836 (found_plmn / rr_found_channel) and one of this networks is
1837 requested, the associated channel is stored to give it
1838 high priority to speed up cell selection. This function
1839 clear the stored data if a network or limited search is
1840 started.
1841
1842 */
1843
1844 GLOBAL void cs_clear_channel_from_found_list (void)
1845 {
1846 GET_INSTANCE_DATA;
1847 /*
1848 * initialize the found channel number
1849 */
1850 rr_data->found_channel = NOT_PRESENT_16BIT;
1851 }
1852
1853 /*
1854 +--------------------------------------------------------------------+
1855 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1856 | STATE : code ROUTINE : cs_remove_co_channels |
1857 +--------------------------------------------------------------------+
1858
1859 PURPOSE : If a channel x fails and the channels x-1 and x+1 have
1860 a fieldstrength difference greater 9 dB, it is not necessary
1861 to try on this cells. Sense of this is to speed up search.
1862
1863 */
1864
1865 static void cs_remove_co_channels (USHORT arfcn)
1866 {
1867 /*
1868 * depending on the channel number. Some extra cases
1869 * for channel numbers on the boarders of the frequency Band
1870 */
1871 switch (arfcn)
1872 {
1873 case CHANNEL_0:
1874 /*
1875 * E-GSM channel 0 has no co-channels
1876 */
1877 break;
1878
1879 /*
1880 * all LOW channel boarders
1881 */
1882 case LOW_CHANNEL_850:
1883 case LOW_CHANNEL_900:
1884 case LOW_CHANNEL_1800:
1885 case LOW_CHANNEL_EGSM:
1886 cs_remove_co_chan (arfcn, (USHORT)(arfcn+1));
1887 break;
1888
1889 /*
1890 * all HIGH channel boarders
1891 */
1892 case HIGH_CHANNEL_1900:
1893 if (std NEQ STD_1900 AND std NEQ STD_DUAL_US)
1894 {
1895 cs_remove_co_chan (arfcn, (USHORT)(arfcn+1));/* DCS 1800 */
1896 }
1897 /*lint -fallthrough*/
1898 case HIGH_CHANNEL_850:
1899 case HIGH_CHANNEL_900:
1900 case HIGH_CHANNEL_1800:
1901 case HIGH_CHANNEL_EGSM-1:
1902 cs_remove_co_chan (arfcn, (USHORT)(arfcn-1));
1903 break;
1904
1905 default:
1906 /*
1907 * all other channels inside the frequency bands
1908 */
1909 cs_remove_co_chan (arfcn, (USHORT)(arfcn+1));
1910 cs_remove_co_chan (arfcn, (USHORT)(arfcn-1));
1911 break;
1912 }
1913 }
1914
1915
1916 /*
1917 +--------------------------------------------------------------------+
1918 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1919 | STATE : code ROUTINE : cs_remove_co_chan |
1920 +--------------------------------------------------------------------+
1921
1922 PURPOSE : if co_chan - chan has a fieldstrength difference greater
1923 9 dBm, remove the channel.
1924
1925 */
1926
1927 static void cs_remove_co_chan (USHORT arfcn, USHORT co_arfcn)
1928 {
1929 GET_INSTANCE_DATA;
1930 UBYTE index_arfcn = NOT_PRESENT_8BIT;
1931 UBYTE index_co_arfcn = NOT_PRESENT_8BIT;
1932 UBYTE i;
1933 SHORT rxlev_arfcn;
1934 SHORT rxlev_co_arfcn;
1935 USHORT *p_arfcn;
1936 TRACE_FUNCTION ("cs_remove_co_chan()");
1937
1938 /*
1939 * calculate the index in the power campaign list
1940 * for the channel
1941 */
1942 p_arfcn = rr_data->cs_data.arfcn;
1943 for (i=0; i<rr_data->cs_data.max_arfcn; i++)
1944 {
1945 if (arfcn EQ (p_arfcn[i]&ARFCN_MASK))
1946 {
1947 index_arfcn = i;
1948 break;
1949 }
1950 }
1951 /*
1952 * if the channel is not inside the list,
1953 * then nothing is to compare else get the
1954 * fieldstrength.
1955 */
1956 if (index_arfcn EQ NOT_PRESENT_8BIT)
1957 return;
1958
1959 /*
1960 * calculate the index in the power campaign list
1961 * for the co-channel
1962 */
1963 for (i=0;i<rr_data->cs_data.max_arfcn;i++)
1964 {
1965 if (co_arfcn EQ (p_arfcn[i]&ARFCN_MASK))
1966 {
1967 index_co_arfcn = i;
1968 break;
1969 }
1970 }
1971 /*
1972 * if the co-channel is not inside the list,
1973 * then nothing is to compare else get the
1974 * fieldstrength.
1975 */
1976 if (index_co_arfcn EQ NOT_PRESENT_8BIT)
1977 return;
1978
1979 rxlev_arfcn = (SHORT)rr_data->cs_data.rxlev [index_arfcn];
1980 rxlev_co_arfcn = (SHORT)rr_data->cs_data.rxlev [index_co_arfcn];
1981
1982 /*
1983 * if the difference is > 9 dBm,
1984 * set to low priority.
1985 */
1986 if ((rxlev_arfcn - rxlev_co_arfcn) > 9)
1987 {
1988 rr_data->cs_data.attributes [index_co_arfcn] &= CS_SET_TO_LOW_PRIORITY;
1989 }
1990 }
1991
1992 /*
1993 +---------------------------------------------------------------------+
1994 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
1995 | STATE : code ROUTINE : cs_add_current_network .... |
1996 +---------------------------------------------------------------------+
1997
1998 PURPOSE : Adds the current PLMN to the found list if available.
1999
2000 */
2001 LOCAL void cs_add_current_network_to_found_list (void)
2002 {
2003 GET_INSTANCE_DATA;
2004 T_loc_area_ident *lai = &rr_data->nc_data[SC_INDEX].lai;
2005
2006 TRACE_FUNCTION ("cs_add_current_network_to_found_list()");
2007
2008 switch (rr_data->ms_data.rr_service)
2009 {
2010 case LIMITED_SERVICE:
2011 case FULL_SERVICE:
2012 /*
2013 * The mobile was in full service
2014 * Add this PLMN to the list of found PLMN
2015 * and clean power measurement list.
2016 */
2017 if (! att_plmn_in_found_list (lai->mcc, lai->mnc) AND
2018 rr_data->sc_data.found_entries < MAX_PLMN)
2019 {
2020 att_save_found_plmn (
2021 &rr_data->sc_data.found[rr_data->sc_data.found_entries],
2022 lai->mcc, lai->mnc,
2023 rr_data->nc_data[SC_INDEX].arfcn,
2024 rr_data->nc_data[SC_INDEX].rxlev, lai->lac, 0);
2025 rr_data->sc_data.found_entries++;
2026 }
2027 /*
2028 * Consider only high priority cells to speed up search
2029 */
2030 cs_del_list (&rr_data->sc_data.cd.ncell_list);
2031 break;
2032 }
2033 }
2034
2035 /*
2036 +--------------------------------------------------------------------+
2037 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2038 | STATE : code ROUTINE : cs_check_channel |
2039 +--------------------------------------------------------------------+
2040
2041 PURPOSE : Depending on the settings (default, GSM 900, DCS 1800)
2042 all non-interesting channels are removed.
2043
2044 */
2045 static UBYTE cs_check_channel (USHORT arfcn)
2046 {
2047 GET_INSTANCE_DATA;
2048 /*
2049 * TRACE_FUNCTION ("cs_check_channel")
2050 */
2051 {
2052 switch (rr_data->dyn_config.set_band)
2053 {
2054 case 0:
2055 /*
2056 * default behaviour
2057 */
2058 return TRUE;
2059
2060 case 1:
2061 /*
2062 * set to GSM 900
2063 */
2064 /*
2065 if (arfcn <= LOW_CHANNEL_900 OR
2066 arfcn >= HIGH_CHANNEL_900)
2067 */
2068 if (INRANGE(LOW_CHANNEL_900,arfcn,HIGH_CHANNEL_900))
2069 return FALSE;
2070 else
2071 return TRUE;
2072
2073 case 2:
2074 /*
2075 * set to DCS 1800
2076 */
2077 /*
2078 if (arfcn >= LOW_CHANNEL_1800 AND
2079 arfcn <= HIGH_CHANNEL_1800)
2080 */
2081 if (INRANGE(LOW_CHANNEL_1800,arfcn,HIGH_CHANNEL_1800))
2082 return TRUE;
2083 else
2084 return FALSE;
2085 }
2086 }
2087 return TRUE;
2088 }
2089
2090 /*
2091 +----------------------------------------------------------------------+
2092 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2093 | STATE : code ROUTINE : cs_check_region |
2094 +----------------------------------------------------------------------+
2095
2096 PURPOSE : This routine validates the region
2097 Cell Selection Improvements-LLD section:4.1.1.2
2098 */
2099
2100 GLOBAL BOOL cs_check_region(U8 region)
2101 {
2102 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2103 if((region EQ EUROPEAN_REGION) OR (region EQ AMERICAN_REGION) OR (region EQ BOTH_REGIONS))
2104 #else
2105 if((region EQ EUROPEAN_REGION) OR (region EQ AMERICAN_REGION))
2106 #endif
2107 {
2108 return TRUE;
2109 }
2110 else
2111 {
2112 TRACE_ERROR("Invalid region");
2113 return FALSE;
2114 }
2115 }
2116
2117 /*
2118 +----------------------------------------------------------------------+
2119 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2120 | STATE : code ROUTINE : cs_validate_arfcn_index |
2121 +----------------------------------------------------------------------+
2122
2123 PURPOSE : This routine validates the ARFCN index
2124 Cell Selection Improvements-LLD section:4.1.1.2
2125 */
2126
2127 GLOBAL BOOL cs_check_arfcn_range(U16 arfcn)
2128 {
2129 if(arfcn EQ CHANNEL_0)
2130 arfcn = CHANNEL_0_INTERNAL;
2131
2132 if((arfcn > CHANNEL_0) AND (arfcn <= CHANNEL_0_INTERNAL))
2133 {
2134 return TRUE;
2135 }
2136 else
2137 {
2138 TRACE_ERROR("Invalid ARFCN");
2139 return FALSE;
2140 }
2141 }
2142
2143 /*
2144 +----------------------------------------------------------------------+
2145 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2146 | STATE : code ROUTINE : cs_inc_sync_fail_counter |
2147 +----------------------------------------------------------------------+
2148
2149 PURPOSE : This routine increments the sync fail counter value for GSM
2150 carrier. Seperate counters are maintained for European and
2151 American regions.The size of SFC counter is 4 bits. As a
2152 result two carriers are accommodated in one byte. This function
2153 first converts the ARFCN range from 1-1023 to 0-511 format and
2154 increments the SFC accordingly. The SFC format is shown below
2155
2156 CSI-LLD section:4.1.1.5.9
2157
2158 ------------------------------------------
2159 | Index | MSB 4 bits | LSB 4 bits |
2160 ------------------------------------------
2161 | 0 | ARFCN : 2 | ARFCN : 1 |
2162 ------------------------------------------
2163 | 1 | ARFCN : 4 | ARFCN 3 |
2164 ------------------------------------------
2165 | - | - | - |
2166 ------------------------------------------
2167 | - | - | - |
2168 ------------------------------------------
2169 | 510 | ARFCN : 1022 | ARFCN: 1021 |
2170 ------------------------------------------
2171 | 511 | ARFCN : 0 | ARFCN :1023 |
2172 -----------------------------------------
2173 ARFCN: 0 = CHANNEL_0_INTERNAL
2174
2175 */
2176
2177 LOCAL void cs_inc_sync_fail_counter(U8 region, U16 arfcn)
2178 {
2179 GET_INSTANCE_DATA;
2180 U16 index=0;
2181 U8 inc = 0;
2182
2183 if(!cs_check_region(region))
2184 return;
2185
2186 if(!cs_check_arfcn_range((U16)(arfcn & ARFCN_MASK)))
2187 return;
2188
2189 if(arfcn EQ CHANNEL_0)
2190 arfcn = CHANNEL_0_INTERNAL;
2191
2192 /* Convert ARFCN range to 0-511 from 1-1023 range */
2193 index = ((arfcn & ARFCN_MASK) -1) >> 1;
2194
2195 if(arfcn & 0x01)
2196 {
2197 /* Increment LSB 4 bits for odd ARFCN */
2198 inc = 0x01;
2199 }
2200 else
2201 {
2202 /* Increment MSB 4 bits for even ARFCN */
2203 inc = 0x10;
2204 }
2205
2206 /* Increment the synchronisation counter */
2207 rr_data->cs_data.black_list.sfc[region][index] += inc;
2208
2209 TRACE_EVENT_P3("[%d]Reg,[%d]Arfcn, SFC = 0x%x",
2210 region,
2211 arfcn,
2212 rr_data->cs_data.black_list.sfc[region][index]);
2213 }
2214
2215 /*
2216 +----------------------------------------------------------------------+
2217 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2218 | STATE : code ROUTINE : cs_reset_sync_fail_counter |
2219 +----------------------------------------------------------------------+
2220
2221 PURPOSE : This routine resets the synchronisation fail counter value of
2222 GSM carrier.
2223 Seperate counters are maintained for European and American
2224 regions.The size of SFC counter is 4 bits. As a result two
2225 carriers are accommodated in one byte. This function
2226 first converts the ARFCN range from 1-1023 to 0-511 format and
2227 increments the SFC accordingly.The SFC format is shown below
2228
2229 CSI-LLD section:4.1.1.5.10
2230
2231 ------------------------------------------
2232 | Index | MSB 4 bits | LSB 4 bits |
2233 ------------------------------------------
2234 | 0 | ARFCN : 2 | ARFCN : 1 |
2235 ------------------------------------------
2236 | 1 | ARFCN : 4 | ARFCN 3 |
2237 ------------------------------------------
2238 | - | - | - |
2239 ------------------------------------------
2240 | - | - | - |
2241 ------------------------------------------
2242 | 510 | ARFCN : 1022 | ARFCN: 1021 |
2243 ------------------------------------------
2244 | 511 | ARFCN : 0 | ARFCN :1023 |
2245 -----------------------------------------
2246 ARFCN: 0 = CHANNEL_0_INTERNAL
2247 */
2248
2249 LOCAL void cs_reset_sync_fail_counter(U8 region, U16 arfcn)
2250 {
2251 GET_INSTANCE_DATA;
2252 USHORT index=0;
2253
2254 if(!cs_check_region(region))
2255 return;
2256
2257 if(!cs_check_arfcn_range((U16)(arfcn & ARFCN_MASK)))
2258 return;
2259
2260 if(arfcn EQ CHANNEL_0)
2261 arfcn = CHANNEL_0_INTERNAL;
2262
2263 /* Convert ARFCN range to 0-511 from 1-1023 range */
2264 index = ((arfcn & ARFCN_MASK) -1) >> 1;
2265
2266 if(arfcn & 0x01)
2267 {
2268 /* Reset LSB 4 bits for odd ARFCN */
2269 rr_data->cs_data.black_list.sfc[region][index] &=0xf0;
2270 }
2271 else
2272 {
2273 /* Reset MSB 4 bits for even ARFCN */
2274 rr_data->cs_data.black_list.sfc[region][index] &=0x0f;
2275 }
2276
2277 TRACE_EVENT_P2("SFC reset for [%d]Reg,[%d]Arfcn",region,arfcn);
2278 }
2279
2280 /*
2281 +----------------------------------------------------------------------+
2282 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2283 | STATE : code ROUTINE : cs_get_sync_fail_counter |
2284 +----------------------------------------------------------------------+
2285
2286 PURPOSE : This function returns the SFC counter of GSM carriers
2287 Seperate counters are maintained for European and American
2288 regions.The size of SFC counter is 4 bits. As a result two
2289 carriers are accommodated in one byte. This function
2290 first converts the ARFCN range from 1-1023 to 0-511 format and
2291 increments the SFC accordingly.The SFC format is shown below
2292
2293 CSI-LLD section:4.1.1.5.11
2294
2295 ------------------------------------------
2296 | Index | MSB 4 bits | LSB 4 bits |
2297 ------------------------------------------
2298 | 0 | ARFCN : 2 | ARFCN : 1 |
2299 ------------------------------------------
2300 | 1 | ARFCN : 4 | ARFCN 3 |
2301 ------------------------------------------
2302 | - | - | - |
2303 ------------------------------------------
2304 | - | - | - |
2305 ------------------------------------------
2306 | 510 | ARFCN : 1022 | ARFCN: 1021 |
2307 ------------------------------------------
2308 | 511 | ARFCN : 0 | ARFCN :1023 |
2309 -----------------------------------------
2310 ARFCN: 0 = CHANNEL_0_INTERNAL
2311 */
2312
2313 LOCAL U8 cs_get_sync_fail_counter(U8 region, U16 arfcn)
2314 {
2315 GET_INSTANCE_DATA;
2316 USHORT index=0;
2317 UBYTE sfc_count=0;
2318
2319 if(!cs_check_region(region))
2320 return sfc_count;
2321
2322 if(!cs_check_arfcn_range((U16)(arfcn & ARFCN_MASK)))
2323 return sfc_count;
2324
2325 if(arfcn EQ CHANNEL_0)
2326 arfcn = CHANNEL_0_INTERNAL;
2327
2328 /* Convert to 0-511 range from 1-1024 range */
2329 index = ((arfcn & ARFCN_MASK) -1) >> 1;
2330
2331 if(arfcn & 0x01)
2332 {
2333 /* obtain LSB 4 bits for odd ARFCN */
2334 sfc_count = (rr_data->cs_data.black_list.sfc[region][index] & 0x0f);
2335 }
2336 else
2337 {
2338 /* obtain MSB 4 bits for even ARFCN */
2339 sfc_count = (rr_data->cs_data.black_list.sfc[region][index] & 0xf0) >> 4;
2340 }
2341
2342 return sfc_count;
2343 }
2344
2345 /*
2346 +--------------------------------------------------------------------+
2347 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2348 | STATE : code ROUTINE : cs_add_to_black_list |
2349 +--------------------------------------------------------------------+
2350
2351 PURPOSE : This function is used to add GSM channels to "Black List".
2352 The function checks the "Black List" criteria before adding
2353 it to the list. This function is called whenever MS fails
2354 to synchronize to a GSM channel.
2355 CSI-LLD section:4.1.1.5.5
2356 */
2357
2358 GLOBAL void cs_add_to_black_list(U8 region, U16 arfcn, U8 rxlev)
2359 {
2360 GET_INSTANCE_DATA;
2361 U16 local_arfcn = arfcn & ARFCN_MASK;
2362
2363 TRACE_FUNCTION("cs_add_to_black_list()");
2364
2365 /* "Region" and "arfcn" are used to index "Black List" database
2366 * Check whether they are within proper range
2367 */
2368 if(!cs_check_region(region))
2369 return;
2370
2371 if(!cs_check_arfcn_range(local_arfcn))
2372 return;
2373
2374 /* Check Black List criteria */
2375 if(cs_check_black_list_criteria(region,arfcn,rxlev))
2376 {
2377 /* Add the channel to Black List */
2378 srv_set_channel(&rr_data->cs_data.black_list.list[region],local_arfcn);
2379
2380 /* Reset the sync fail counter for this channel. So that when this
2381 * carrier is removed from BL(BA_MA list), counter will start from zero
2382 * again
2383 */
2384 cs_reset_sync_fail_counter(region, local_arfcn);
2385
2386 TRACE_EVENT_P2("[%d]Reg[%d]Arfcn added to BL",region,local_arfcn);
2387 }
2388 }
2389
2390 /*
2391 +--------------------------------------------------------------------+
2392 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2393 | STATE : code ROUTINE : cs_del_from_black_list |
2394 +--------------------------------------------------------------------+
2395
2396 PURPOSE : This routine removes the arfcn from black list and resets the sync
2397 fail counter for that arfcn
2398 CSI-LLD section:4.1.1.5.6
2399 */
2400
2401 GLOBAL void cs_del_from_black_list(U8 region, U16 arfcn)
2402 {
2403 GET_INSTANCE_DATA;
2404 USHORT local_arfcn = arfcn & ARFCN_MASK;
2405 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2406 UBYTE i;
2407 #endif
2408
2409 TRACE_FUNCTION("cs_del_from_black_list()");
2410
2411 /* "Region" and "arfcn" are used to index "Black List" database
2412 * Check whether they are within proper range
2413 */
2414 if(!cs_check_region(region))
2415 return;
2416
2417 if(!cs_check_arfcn_range(local_arfcn))
2418 return;
2419
2420 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2421 if (region EQ BOTH_REGIONS)
2422 {
2423 for (i=0; i<MAX_REGIONS; i++)
2424 {
2425 if(srv_get_channel(&rr_data->cs_data.black_list.list[i],local_arfcn))
2426 {
2427 /* Remove the channel from Black List */
2428 srv_unset_channel(&rr_data->cs_data.black_list.list[i],local_arfcn);
2429
2430 /* Reset the sync fail counter for this channel */
2431 cs_reset_sync_fail_counter(i, local_arfcn);
2432
2433 TRACE_EVENT_P2("ARFCN:%d Region:%d deleted from BL",local_arfcn,i);
2434 }
2435 }
2436 }
2437 else
2438 {
2439 #endif
2440 if(srv_get_channel(&rr_data->cs_data.black_list.list[region],local_arfcn))
2441 {
2442 /* Remove the channel from Black List */
2443 srv_unset_channel(&rr_data->cs_data.black_list.list[region],local_arfcn);
2444
2445 /* Reset the sync fail counter for this channel */
2446 cs_reset_sync_fail_counter(region, local_arfcn);
2447
2448 TRACE_EVENT_P2("ARFCN:%d Region:%d deleted from BL",local_arfcn,region);
2449 }
2450 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2451 }
2452 #endif
2453 }
2454
2455 /*
2456 +--------------------------------------------------------------------+
2457 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2458 | STATE : code ROUTINE : cs_clear_black_list |
2459 +--------------------------------------------------------------------+
2460
2461 PURPOSE : This function is used to clear "Black List" database.
2462 The function clears the "Black List" database from
2463 1) Only RAM
2464 2) Only FFS
2465 3) Both RAM and FFS.
2466
2467 This function is called in the following cases
2468 1) In response to "ERASE_BL" dynamic configuration command
2469 2) After Initial PLMN search based on its outcome
2470
2471 CSI-LLD section:4.1.1.5.1
2472 */
2473
2474 GLOBAL void cs_clear_black_list(U8 erase_type)
2475 {
2476 GET_INSTANCE_DATA;
2477 TRACE_FUNCTION ("cs_clear_black_list()");
2478
2479 /* clear Black List from RAM */
2480 if(erase_type & CLR_BLACK_LIST_RAM)
2481 {
2482 memset(&rr_data->cs_data.black_list,0,sizeof(T_CS_BLACK_LIST));
2483
2484 TRACE_EVENT ("Black List: RAM cleared");
2485 }
2486
2487 /* Clear Black List from FFS */
2488 #if defined(_SIMULATION_FFS_)
2489 if(erase_type & CLR_BLACK_LIST_FFS)
2490 {
2491 T_LIST local_black_list[MAX_REGIONS];
2492
2493 memset(&local_black_list[0],0,MAX_REGIONS*sizeof(T_LIST));
2494
2495 rr_csf_write_black_list(&local_black_list[0]);
2496
2497 TRACE_EVENT ("Black List: FFS cleared");
2498 }
2499 #endif
2500
2501 }
2502
2503 /*
2504 +--------------------------------------------------------------------+
2505 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2506 | STATE : code ROUTINE : cs_remove_BA_MA_from_black_list|
2507 +--------------------------------------------------------------------+
2508
2509 PURPOSE : This function is used to remove the GSM channels present
2510 in MA and BA lists from the "Black List". The function
2511 deletes these channels from the "Black List" and also
2512 resets their SFC counter to zero. This function is called
2513 whenever MS receives BA and MA list information in any RR
2514 message.
2515 CSI-LLD section:4.1.1.5.7
2516 */
2517
2518 GLOBAL void cs_remove_BA_MA_from_black_list(U8 region, T_LIST *source_list)
2519 {
2520 GET_INSTANCE_DATA;
2521
2522 TRACE_FUNCTION("cs_remove_BA_MA_from_black_list()");
2523
2524 /* "Region" is to index "Black List" database
2525 * Check whether it is within proper range
2526 */
2527 if(!cs_check_region(region))
2528 return;
2529
2530 if(source_list NEQ NULL)
2531 {
2532 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2533 if (region EQ BOTH_REGIONS)
2534 {
2535 cs_remove_BA_MA_from_black_list(EUROPEAN_REGION,source_list);
2536 cs_remove_BA_MA_from_black_list(AMERICAN_REGION,source_list);
2537 }
2538 else
2539 #endif
2540 srv_unmask_list(&rr_data->cs_data.black_list.list[region],source_list);
2541
2542 TRACE_EVENT("BL updated with BA/MA/Inactive carrier list");
2543 }
2544 }
2545
2546
2547 /*
2548 +--------------------------------------------------------------------+
2549 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2550 | STATE : code ROUTINE : cs_rem_inactive_carriers_from_bl|
2551 +--------------------------------------------------------------------+
2552
2553 PURPOSE : This function is used to remove the inactive carriers from
2554 the "Black List". This is done whenever the mobile changes
2555 LA/RA
2556 Cell Selection Improvements-LLD section:4.1.1.3.4
2557 */
2558
2559 GLOBAL void cs_rem_inactive_carriers_from_bl(T_MPH_POWER_CNF *mph_power_cnf)
2560 {
2561
2562 TRACE_FUNCTION("cs_remove_inactive_from_black_list");
2563
2564 /* Remove the inactive carriers from Black list for European region */
2565 cs_remove_BA_MA_from_black_list(EUROPEAN_REGION,
2566 (T_LIST *)&mph_power_cnf->inactive_carrier_list.list[EUROPEAN_REGION]);
2567
2568 /* Remove the inactive carriers from Black list for American region */
2569 cs_remove_BA_MA_from_black_list(AMERICAN_REGION,
2570 (T_LIST *)&mph_power_cnf->inactive_carrier_list.list[AMERICAN_REGION]);
2571 }
2572
2573
2574 /*
2575 +--------------------------------------------------------------------+
2576 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2577 | STATE : code ROUTINE : cs_is_in_black_list |
2578 +--------------------------------------------------------------------+
2579
2580 PURPOSE : This routine checks whether a carrier is already part of Black
2581 list or not
2582 CSI-LLD section:4.1.1.5.12
2583 */
2584
2585 LOCAL BOOL cs_is_in_black_list(U8 region, U16 arfcn)
2586 {
2587 GET_INSTANCE_DATA;
2588 U8 status;
2589
2590 status = srv_get_channel((T_LIST*)&rr_data->cs_data.black_list.list[region],
2591 (USHORT)arfcn & ARFCN_MASK);
2592
2593 TRACE_EVENT_P3("[%d]Reg[%d]Arfcn, BL status:%d",region,arfcn,status);
2594
2595 return status;
2596 }
2597
2598 /*
2599 +--------------------------------------------------------------------+
2600 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2601 | STATE : code ROUTINE : cs_is_in_white_list |
2602 +--------------------------------------------------------------------+
2603
2604 PURPOSE : This routine checks whether a carrier is part of White
2605 list or not
2606 CSI-LLD section:4.1.2.2.7
2607 */
2608
2609 LOCAL BOOL cs_is_in_white_list(U8 region, U16 arfcn)
2610 {
2611 GET_INSTANCE_DATA;
2612 U8 status = FALSE;
2613
2614 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2615 if((rr_data->cs_data.white_list.region EQ BOTH_REGIONS) OR
2616 (region EQ rr_data->cs_data.white_list.region))
2617 #else
2618 if(region EQ rr_data->cs_data.white_list.region)
2619 #endif
2620 {
2621 status = srv_get_channel(&rr_data->cs_data.white_list.list,
2622 ((U16)arfcn & ARFCN_MASK));
2623 }
2624
2625 TRACE_EVENT_P3("[%d]Reg[%d]Arfcn, WL status:%d", region,arfcn,status);
2626
2627 return status;
2628 }
2629
2630 /*
2631 +---------------------------------------------------------------------+
2632 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2633 | STATE : code ROUTINE : cs_check_black_list_criteria|
2634 +---------------------------------------------------------------------+
2635
2636 PURPOSE : This function checks the criteria for adding a GSM channel
2637 to "Black List". GSM channels are added to "Black List" only
2638 after they satisfy this criteria.
2639 CSI-LLD section:4.1.1.5.13
2640 */
2641
2642 LOCAL BOOL cs_check_black_list_criteria(U8 region,U16 arfcn,U8 rxlev)
2643 {
2644 GET_INSTANCE_DATA;
2645 UBYTE band_index;
2646 U16 local_arfcn = arfcn&ARFCN_MASK;
2647 TRACE_FUNCTION("cs_check_black_list_criteria()");
2648
2649 /* Check if the carrier is already present in the black list */
2650 if(cs_is_in_black_list(region, local_arfcn))
2651 return FALSE;
2652
2653 /* Check if the carrier is present in White List */
2654 if(cs_is_in_white_list(region, local_arfcn))
2655 return FALSE;
2656
2657 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2658 band_index = cs_get_band_index(arfcn);
2659 #else
2660 band_index = get_band_index(arfcn);
2661 #endif
2662 /* RxLev of carrier is above upper threshold. Add the carrier
2663 * to Black List immediately
2664 */
2665 if(rxlev >= rr_data->dyn_config.upper_rxlev_thr[band_index])
2666 {
2667 return TRUE;
2668 }
2669
2670 /* Reasonably strong carrier. Add to Black List only if its sync fail
2671 * counter criteria is satisfied
2672 */
2673 if((rxlev >= rr_data->dyn_config.medium_rxlev_thr[band_index]) AND
2674 (rxlev < rr_data->dyn_config.upper_rxlev_thr[band_index]))
2675 {
2676 cs_inc_sync_fail_counter(region, local_arfcn);
2677
2678 if(cs_get_sync_fail_counter(region, local_arfcn) >= MAX_SYNC_FAILURES)
2679 {
2680 return TRUE;
2681 }
2682 }
2683 return FALSE;
2684 }
2685
2686 /*
2687 +----------------------------------------------------------------+
2688 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2689 | STATE : code ROUTINE : cs_update_black_list |
2690 +----------------------------------------------------------------+
2691
2692 PURPOSE : This function is used to update "Black List" database
2693 after initial PLMN search.It first clears the current
2694 "Black list" database from RAM and then adds some cells
2695 to "Black List" according to the current attrib-utes
2696 array values(BLACK_LIST_FLAG) of the Initial PLMN
2697 selection process. This function is called un-der the
2698 following cases
2699 1.MS enters Limited or No service after Initial PLMN search
2700 2.MS enters Full service in a different Location area
2701 from where it is switched off after initial PLMN search
2702 CSI-LLD section:4.1.1.5.8
2703 */
2704
2705 GLOBAL void cs_update_black_list(void)
2706 {
2707 GET_INSTANCE_DATA;
2708
2709 U8 update_black_list = FALSE;
2710 U8 i, region;
2711
2712 TRACE_FUNCTION("cs_update_black_list()");
2713
2714 /* If the outcome of first FUNC_PLMN_SEARCH is not full service.
2715 * Erase the Black List
2716 */
2717 if((rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH AND
2718 rr_data->ms_data.rr_service NEQ FULL_SERVICE))
2719 {
2720 update_black_list = TRUE;
2721 }
2722
2723 TRACE_EVENT_P8 ( "Old [%d]SC MCC/MNC r=%x%x%x/%x%x%x/%d",
2724 rr_data->cs_data.white_list.last_sc_arfcn,
2725 rr_data->cs_data.white_list.last_sc_lac.mcc[0],
2726 rr_data->cs_data.white_list.last_sc_lac.mcc[1],
2727 rr_data->cs_data.white_list.last_sc_lac.mcc[2],
2728 rr_data->cs_data.white_list.last_sc_lac.mnc[0],
2729 rr_data->cs_data.white_list.last_sc_lac.mnc[1],
2730 rr_data->cs_data.white_list.last_sc_lac.mnc[2],
2731 rr_data->cs_data.white_list.last_sc_lac.lac);
2732
2733 TRACE_EVENT_P8 ( "New [%d]SC MCC/MNC r=%x%x%x/%x%x%x/%d",
2734 rr_data->nc_data[SC_INDEX].arfcn,
2735 rr_data->nc_data[SC_INDEX].lai.mcc[0],
2736 rr_data->nc_data[SC_INDEX].lai.mcc[1],
2737 rr_data->nc_data[SC_INDEX].lai.mcc[2],
2738 rr_data->nc_data[SC_INDEX].lai.mnc[0],
2739 rr_data->nc_data[SC_INDEX].lai.mnc[1],
2740 rr_data->nc_data[SC_INDEX].lai.mnc[2],
2741 rr_data->nc_data[SC_INDEX].lai.lac);
2742
2743 /* If the current serving cell belongs to a different Location area.
2744 * Erase the Black List
2745 */
2746 if((rr_data->ms_data.rr_service EQ FULL_SERVICE) AND
2747 ((rr_data->cs_data.white_list.last_sc_arfcn EQ NOT_PRESENT_16BIT) OR
2748 (!dat_plmn_equal_req(rr_data->cs_data.white_list.last_sc_lac.mcc,
2749 rr_data->cs_data.white_list.last_sc_lac.mnc,
2750 rr_data->nc_data[SC_INDEX].lai.mcc,
2751 rr_data->nc_data[SC_INDEX].lai.mnc)) OR
2752 (rr_data->cs_data.white_list.last_sc_lac.lac NEQ
2753 rr_data->nc_data[SC_INDEX].lai.lac)))
2754 {
2755 update_black_list = TRUE;
2756 }
2757
2758 if(update_black_list)
2759 {
2760 /* Erase the current Black List */
2761 cs_clear_black_list(CLR_BLACK_LIST_RAM);
2762
2763 for(i=0;i<rr_data->cs_data.max_arfcn;i++)
2764 {
2765 if(CS_GET_BLACK_LIST_FLAG(i))
2766 {
2767 /* Obtain the region */
2768 region = CS_GET_REGION_FROM_FREQ(rr_data->cs_data.arfcn[i]);
2769
2770 cs_add_to_black_list(region,
2771 (USHORT)(rr_data->cs_data.arfcn[i]),
2772 rr_data->cs_data.rxlev[i]);
2773 }
2774 } /* i < max_arfcn */
2775
2776 TRACE_EVENT("BL updated after inital PLMN search");
2777 }
2778 }
2779
2780 /*
2781 +----------------------------------------------------------------------+
2782 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2783 | STATE : code ROUTINE : cs_store_black_list |
2784 +----------------------------------------------------------------------+
2785
2786 PURPOSE : This is a wrapper function for storing "Black List"
2787 information to FFS . This in turn calls
2788 rr_csf_write_black_list( ) to store "Black List" to FFS.
2789 This function is called during power off.
2790 CSI-LLD section:4.1.1.5.2
2791 */
2792
2793 GLOBAL void cs_store_black_list(void)
2794 {
2795 GET_INSTANCE_DATA;
2796 #if defined(_SIMULATION_FFS_)
2797 rr_csf_write_black_list(&rr_data->cs_data.black_list.list[0]);
2798 #endif
2799 }
2800
2801 /*
2802 +----------------------------------------------------------------------+
2803 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2804 | STATE : code ROUTINE : cs_get_new_search_mode |
2805 +----------------------------------------------------------------------+
2806
2807 PURPOSE : This routine returns the new search mode depending on the timer
2808 active and the previous search mode
2809 CSI-LLD section:4.1.3.4.1.1
2810 */
2811
2812 GLOBAL U8 cs_get_new_search_mode(void)
2813 {
2814 GET_INSTANCE_DATA;
2815 TRACE_FUNCTION("cs_get_new_search_mode()");
2816
2817 if(IS_TIMER_ACTIVE(T_FAST_CS))
2818 {
2819 /* Fast search timer is active */
2820 return FAST_SEARCH_MODE;
2821 }
2822
2823 if(IS_TIMER_ACTIVE(T_NORMAL_CS))
2824 {
2825 /* Normal search timer is active */
2826 return NORMAL_SEARCH_MODE;
2827 }
2828
2829 TRACE_EVENT_P1("Previous Search Mode : %d",
2830 rr_data->cs_data.previous_search_mode);
2831
2832 if((rr_data->cs_data.previous_search_mode EQ FULL_SEARCH_MODE)
2833 OR (rr_data->cs_data.previous_search_mode EQ FAST_SEARCH_MODE))
2834 {
2835 return NORMAL_SEARCH_MODE;
2836 }
2837
2838 if(rr_data->cs_data.previous_search_mode EQ NORMAL_SEARCH_MODE)
2839 {
2840 return FULL_SEARCH_MODE;
2841 }
2842
2843 return FULL_SEARCH_MODE;
2844 }
2845 /*
2846 +----------------------------------------------------------------------+
2847 | PROJECT : GSM-PS (8403) MODULE : RR_CS |
2848 | STATE : code ROUTINE : cs_handle_search_mode_timer |
2849 +----------------------------------------------------------------------+
2850
2851 PURPOSE : This routine handles the timers for the new search modes
2852 CSI-LLD section:4.1.3.4.1.2
2853 */
2854 GLOBAL void cs_handle_search_mode_timer(U8 search_mode)
2855 {
2856 GET_INSTANCE_DATA;
2857 TRACE_FUNCTION("cs_handle_search_mode_timer()");
2858
2859 if((search_mode EQ FAST_SEARCH_MODE) AND (rr_data->dyn_config.tfast_cs_val))
2860 {
2861 if(!IS_TIMER_ACTIVE(T_FAST_CS))
2862 {
2863 TIMERSTART (T_FAST_CS,rr_data->dyn_config.tfast_cs_val);
2864 }
2865 }
2866
2867 if((search_mode EQ NORMAL_SEARCH_MODE) AND (rr_data->dyn_config.tnormal_cs_val))
2868 {
2869 if(!IS_TIMER_ACTIVE(T_NORMAL_CS))
2870 {
2871 TIMERSTART (T_NORMAL_CS, rr_data->dyn_config.tnormal_cs_val);
2872 }
2873 }
2874
2875 if(search_mode EQ FULL_SEARCH_MODE)
2876 {
2877 if(rr_data->sc_data.mm_started EQ MM_ORIGINATED AND
2878 rr_data->ms_data.req_mm_service NEQ FUNC_NET_SRCH_BY_MMI)
2879 {
2880 TIMERSTOP(T_FAST_CS);
2881 TIMERSTOP(T_NORMAL_CS);
2882 }
2883 }
2884 }
2885
2886 /*
2887 +--------------------------------------------------------------------+
2888 | PROJECT : GSM-PS (6147) MODULE : RR_CS |
2889 | STATE : code ROUTINE : cs_update_std_ffs |
2890 +--------------------------------------------------------------------+
2891
2892 PURPOSE : This function updates the std value depending upon the
2893 frequency band support by MS. Frequncy band support is
2894 available in the FFS.
2895
2896 */
2897 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2898 LOCAL UBYTE cs_update_std_ffs (UBYTE new_std)
2899 {
2900 UBYTE freq_bands;
2901
2902 rr_csf_get_freq_bands (&freq_bands);
2903 switch (new_std)
2904 {
2905 case STD_DUAL_EGSM:
2906 if ((freq_bands & BAND_GSM_850) EQ BAND_GSM_850)
2907 {
2908 return STD_850_900_1800;
2909 }
2910 break;
2911 case STD_DUAL_US:
2912 if ((freq_bands & BAND_GSM_900) EQ BAND_GSM_900)
2913 {
2914 return STD_850_900_1900;
2915 }
2916 break;
2917 default:
2918 TRACE_EVENT_P1 ("wrong std for updation using FFS %x", new_std);
2919 }
2920 return new_std;
2921 }
2922 #endif
2923 #endif