FreeCalypso > hg > fc-magnetite

comparison src/g23m-gprs/grr/grr_ctrlf.c @ 183:219afcfc6250

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/g23m-gprs: initial import from TCS3.2/LoCosto
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 13 Oct 2016 04:24:13 +0000
parents
children
comparison
equal deleted inserted replaced
182:f02d0a0e1849 183:219afcfc6250
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GPRS (8441)
4 | Modul : GRR
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 implements local functions for service CTRL of
18 | entity GRR.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef GRR_CTRLF_C
23 #define GRR_CTRLF_C
24 #endif
25
26 #define ENTITY_GRR
27
28 /*==== INCLUDES =============================================================*/
29
30 #include "typedefs.h" /* to get Condat data types */
31
32 #include "vsi.h" /* to get a lot of macros */
33 #include "macdef.h"
34 #include "gprs.h"
35 #include "gsm.h" /* to get a lot of macros */
36 #include "ccdapi.h" /* to get CCD API */
37 #include "cnf_grr.h" /* to get cnf-definitions */
38 #include "mon_grr.h" /* to get mon-definitions */
39 #include "prim.h" /* to get the definitions of used SAP and directions */
40 #include "message.h"
41 #include "grr.h" /* to get the global entity definitions */
42 #include "grr_f.h"
43
44 #include "grr_ctrlf.h" /* */
45 #include "grr_ctrls.h"
46
47 #include "grr_meass.h" /* */
48 #include "grr_pgs.h" /* */
49 #include "grr_psis.h" /* */
50 #include "grr_css.h" /* */
51 #include "grr_tcs.h" /* */
52
53 #include <string.h> /* for memcpy */
54 #include "pcm.h"
55
56 #ifdef _TARGET_
57 #include "ffs/ffs.h"
58 #endif
59
60
61
62 /*==== CONST ================================================================*/
63
64 #define BCC_OF_BSIC 7
65
66 /*==== LOCAL VARS ===========================================================*/
67
68 /*==== PRIVATE FUNCTIONS ====================================================*/
69
70 LOCAL void ctrl_set_final_pckt_mode ( void );
71 LOCAL BOOL ctrl_set_transient_pckt_mode ( T_GLBL_PCKT_MODE final_pckt_mode,
72 T_CTRL_TASK *ctrl_task );
73 LOCAL void ctrl_enter_pim ( void );
74 LOCAL void ctrl_leave_to_pam ( void );
75 LOCAL void ctrl_enter_pam ( void );
76 LOCAL void ctrl_enter_ptm ( void );
77 LOCAL BOOL ctrl_check_cco_freq ( USHORT arfcn );
78 /*==== PUBLIC FUNCTIONS =====================================================*/
79
80
81
82 /*
83 +------------------------------------------------------------------------------
84 | Function : ctrl_stop_all_activities
85 +------------------------------------------------------------------------------
86 | Description : The function ctrl_stop_all_activities() ....
87 |
88 | Parameters : void
89 |
90 +------------------------------------------------------------------------------
91 */
92 GLOBAL void ctrl_stop_all_activities ( T_CTRL_DISABLE_CAUSE dc,
93 void *data )
94 {
95 BOOL is_pbcch_reset_needed = FALSE;
96
97 TRACE_FUNCTION( "ctrl_stop_all_activities" );
98
99 /*
100 * inform the service PG
101 * parameters dc and data are not of interest
102 */
103 sig_ctrl_pg_stop( );
104
105 /*
106 * inform the service MEAS
107 * parameter data is not of interest
108 */
109 switch( dc )
110 {
111 case( CTRL_DC_OTHER ):
112 case( CTRL_DC_SUSPEND_NORMAL ):
113 case( CTRL_DC_SUSPEND_IMM_REL ):
114 case( CTRL_DC_CR_NW_RR ):
115 case( CTRL_DC_CR_NW_GRR ):
116 case( CTRL_DC_CR_MS_GRR_NORMAL ):
117 case( CTRL_DC_PSI_MANAGEMENT ):
118 case( CTRL_DC_CR_MS_RR_NORMAL ):
119 case( CTRL_DC_CR_MS_RR_IMM_REL ):
120 case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
121 sig_ctrl_meas_stop( );
122 break;
123
124 default:
125 TRACE_EVENT( "FATAL ERROR 1 in ctrl_stop_all_activities" );
126 break;
127 }
128
129 /*
130 * inform the service CS
131 */
132 switch( dc )
133 {
134 case( CTRL_DC_OTHER ):
135 vsi_t_stop( GRR_handle, T3174 );
136 vsi_t_stop( GRR_handle, T3176 );
137 #ifdef _SIMULATION_
138 sig_ctrl_cs_simu_timer_stop();
139 #endif
140
141 /*lint -fallthrough*/
142
143 case( CTRL_DC_CR_MS_GRR_NORMAL ):
144 case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
145 case( CTRL_DC_PSI_MANAGEMENT ):
146 case( CTRL_DC_CR_MS_RR_NORMAL ):
147 case( CTRL_DC_CR_MS_RR_IMM_REL ):
148 sig_ctrl_cs_stop(CS_DC_OTHER);
149 break;
150
151 case( CTRL_DC_SUSPEND_NORMAL ):
152 case( CTRL_DC_SUSPEND_IMM_REL ):
153 sig_ctrl_cs_stop( CS_DC_DEDICATED );
154 break;
155
156 case( CTRL_DC_CR_NW_RR ):
157 sig_ctrl_cs_cc_order_ind( NULL, (T_D_CHANGE_ORDER *)data );
158 break;
159
160 case( CTRL_DC_CR_NW_GRR ):
161 if (grr_t_status( T3174 ) > 0 )
162 {
163 sig_ctrl_cs_cc_order_ind( (T_D_CELL_CHAN_ORDER *)data, NULL );
164 }
165 else
166 {
167 sig_ctrl_cs_stop(CS_DC_OTHER);
168 }
169 break;
170
171 default:
172 TRACE_EVENT( "FATAL ERROR 2 in ctrl_stop_all_activities" );
173 break;
174 }
175
176 /*
177 * inform the service PSI
178 * parameter data is not of interest
179 */
180 switch( dc )
181 {
182 case( CTRL_DC_OTHER ):
183 case( CTRL_DC_CR_MS_RR_NORMAL ):
184 case( CTRL_DC_CR_MS_RR_IMM_REL ):
185 case( CTRL_DC_CR_MS_GRR_NORMAL ):
186 sig_ctrl_psi_stop( );
187
188
189 is_pbcch_reset_needed = TRUE;
190 break;
191
192 case( CTRL_DC_SUSPEND_NORMAL ):
193 case( CTRL_DC_SUSPEND_IMM_REL ):
194 case( CTRL_DC_CR_NW_RR ):
195 case( CTRL_DC_CR_NW_GRR ):
196 case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
197 sig_ctrl_psi_suspend( );
198 break;
199
200 case( CTRL_DC_PSI_MANAGEMENT ):
201 /* do nothing */
202 break;
203
204 default:
205 TRACE_EVENT( "FATAL ERROR 3 in ctrl_stop_all_activities" );
206 break;
207 }
208
209 /*
210 * inform the service TC
211 * parameter data is not of interest
212 */
213 switch( dc )
214 {
215 case( CTRL_DC_OTHER ):
216 case( CTRL_DC_PSI_MANAGEMENT ):
217 ctrl_send_access_disable_if_needed
218 ( TC_DC_OTHER, sig_tc_ctrl_tbf_release_cnf );
219 break;
220
221 case( CTRL_DC_CR_NW_RR ):
222 case( CTRL_DC_CR_NW_GRR ):
223 ctrl_send_access_disable_if_needed
224 ( TC_DC_CR_NETWORK, sig_tc_ctrl_cr_started_rsp );
225 break;
226
227 case( CTRL_DC_CR_MS_RR_NORMAL ):
228 ctrl_send_access_disable_if_needed
229 ( TC_DC_CR_NORMAL, sig_tc_ctrl_cr_started_rsp );
230 break;
231
232 case( CTRL_DC_CR_MS_RR_IMM_REL ):
233 case( CTRL_DC_CR_MS_GRR_NORMAL ):
234 ctrl_send_access_disable_if_needed
235 ( TC_DC_CR_IMM_REL, sig_tc_ctrl_cr_started_rsp );
236 break;
237
238 case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
239 ctrl_send_access_disable_if_needed
240 ( TC_DC_CR_ABNORMAL, sig_tc_ctrl_cr_started_rsp );
241 break;
242
243 case( CTRL_DC_SUSPEND_NORMAL ):
244 ctrl_send_access_disable_if_needed
245 ( TC_DC_SUSPEND_NORMAL, sig_tc_ctrl_suspend_cnf );
246 break;
247
248 case( CTRL_DC_SUSPEND_IMM_REL ):
249 ctrl_send_access_disable_if_needed
250 ( TC_DC_SUSPEND_IMM_REL, sig_tc_ctrl_suspend_cnf );
251 break;
252
253 default:
254 TRACE_EVENT( "FATAL ERROR 4 in ctrl_stop_all_activities" );
255 break;
256 }
257
258 if( is_pbcch_reset_needed )
259 {
260 grr_set_pbcch( FALSE );
261 }
262 } /* ctrl_stop_all_activities() */
263
264 /*
265 +------------------------------------------------------------------------------
266 | Function : ctrl_init
267 +------------------------------------------------------------------------------
268 | Description : The function ctrl_init() ....
269 |
270 | Parameters : void
271 |
272 +------------------------------------------------------------------------------
273 */
274 GLOBAL void ctrl_init ( void)
275 {
276 TRACE_FUNCTION( "ctrl_init" );
277
278 /* init parameters of CTRL*/
279
280 INIT_STATE( CTRL, CTRL_NULL );
281 INIT_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL );
282
283 grr_data->ctrl.new_cell_responded = FALSE;
284 grr_data->ctrl.psi_tbf_rel_cause = CTRL_PTRC_NONE;
285 grr_data->ctrl_glbl.ctrl_task = CTRL_TASK_NONE;
286
287 #ifdef _SIMULATION_
288
289 TRACE_EVENT_P1( "ctrl_init - ctrl_task: %d", grr_data->ctrl_glbl.ctrl_task );
290
291 #endif /* #ifdef _SIMULATION_ */
292
293 grr_data->ctrl.rr_state.monitoring_stopped = FALSE;
294 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_NONE;
295
296 ctrl_read_pcm();
297
298 } /* ctrl_init() */
299
300
301
302 /*
303 +------------------------------------------------------------------------------
304 | Function : ctrl_start_monitoring_bcch
305 +------------------------------------------------------------------------------
306 | Description : The function ctrl_start_monitoring_bcch() This function starts
307 | reading System Information (SI) on BCCH
308 |
309 | Parameters : void
310 |
311 +------------------------------------------------------------------------------
312 */
313 GLOBAL void ctrl_start_monitoring_bcch ( UBYTE si_to_read )
314 {
315 TRACE_FUNCTION( "ctrl_start_monitoring_bcch" );
316
317 {
318 PALLOC( rrgrr_start_mon_bcch_req, RRGRR_START_MON_BCCH_REQ );
319
320 rrgrr_start_mon_bcch_req->si_to_read = psc_db->si_to_acquire = si_to_read;
321
322 PSEND( hCommRR, rrgrr_start_mon_bcch_req );
323 }
324 } /* ctrl_start_monitoring_bcch() */
325
326
327 /*
328 +------------------------------------------------------------------------------
329 | Function : ctrl_stop_monitoring_ccch
330 +------------------------------------------------------------------------------
331 | Description : The function ctrl_stop_monitoring_ccch() This function stops
332 | monitoring CCCH
333 |
334 | Parameters : void
335 |
336 +------------------------------------------------------------------------------
337 */
338 GLOBAL void ctrl_stop_monitoring_ccch ( void )
339 {
340 TRACE_FUNCTION( "ctrl_stop_monitoring_ccch" );
341
342 if(!grr_data->ctrl.rr_state.monitoring_stopped OR (grr_data->test_mode NEQ CGRLC_NO_TEST_MODE))
343 {
344 PALLOC ( rrgrr_stop_mon_ccch_req, RRGRR_STOP_MON_CCCH_REQ);
345 rrgrr_stop_mon_ccch_req->is_pbcch_present = grr_is_pbcch_present();
346 PSEND (hCommRR, rrgrr_stop_mon_ccch_req);
347 }
348 grr_data->ctrl.rr_state.monitoring_stopped = TRUE;
349 } /* ctrl_stop_monitoring_ccch() */
350
351 /*
352 +------------------------------------------------------------------------------
353 | Function : ctrl_start_monitoring_ccch
354 +------------------------------------------------------------------------------
355 | Description : The function ctrl_start_monitoring_ccch() This function starts
356 | monitoring CCCH
357 |
358 | Parameters : pag_mode : indicates the page, which shall be uese by RR/L1
359 |
360 +------------------------------------------------------------------------------
361 */
362 GLOBAL void ctrl_start_monitoring_ccch ( UBYTE pag_mode )
363 {
364 TRACE_FUNCTION( "ctrl_start_monitoring_ccch" );
365
366 {
367 PALLOC ( rrgrr_start_mon_ccch_req, RRGRR_START_MON_CCCH_REQ);
368 rrgrr_start_mon_ccch_req->pag_mode = pag_mode;
369 #if defined (REL99) AND defined (TI_PS_FF_EMR)
370 #else
371 rrgrr_start_mon_ccch_req->split_pg = grr_data->ms.split_pg_cycle;
372 #endif
373 PSEND (hCommRR, rrgrr_start_mon_ccch_req);
374 }
375 grr_data->ctrl.rr_state.monitoring_stopped = FALSE;
376 } /* ctrl_start_monitoring_ccch() */
377
378 /*
379 +------------------------------------------------------------------------------
380 | Function : ctrl_send_rr_est_req
381 +------------------------------------------------------------------------------
382 | Description : The function ctrl_send_rr_est_req() ....
383 |
384 | Parameters : UBYTE susp_req: whether RR needs to send
385 | GPRS Suspension Request or not
386 |
387 +------------------------------------------------------------------------------
388 */
389 GLOBAL void ctrl_send_rr_est_req ( UBYTE susp_req)
390 {
391 TRACE_FUNCTION( "ctrl_send_rr_est_req" );
392 {
393 PALLOC ( rrgrr_rr_est_req, RRGRR_RR_EST_REQ);
394
395 if(psc_db->v_non_gprs_opt EQ TRUE)
396 {
397 rrgrr_rr_est_req->non_gprs.v_non_gprs = TRUE;
398
399 /* Copy non GPRS options */
400 ctrl_copy_non_gprs_opt(&rrgrr_rr_est_req->non_gprs);
401 }
402 else
403 rrgrr_rr_est_req->non_gprs.v_non_gprs = FALSE;
404
405 rrgrr_rr_est_req->ch_needed = grr_data->pg.ch_needed;
406
407 rrgrr_rr_est_req->emlpp_prio.v_emlpp = grr_data->pg.v_emlpp_prio;
408 rrgrr_rr_est_req->emlpp_prio.emlpp = grr_data->pg.emlpp_prio;
409
410 rrgrr_rr_est_req->susp_req = susp_req;
411
412 rrgrr_rr_est_req->ident_type = grr_data->pg.type; /* IMSI TMSI ??*/
413
414 PSEND (hCommRR, rrgrr_rr_est_req);
415 }
416 } /* ctrl_send_rr_est_req() */
417
418 /*
419 +------------------------------------------------------------------------------
420 | Function : ctrl_send_rr_est_rsp
421 +------------------------------------------------------------------------------
422 | Description : The function ctrl_send_rr_est_rsp() ....
423 | Informs the RR whether the RR connection should be established or not!
424 | Parameters : UBYTE susp_req: Suspension request needed or not
425 | UBYTE rsp: CS_PAGE was accepted or not
426 |
427 +------------------------------------------------------------------------------
428 */
429 GLOBAL void ctrl_send_rr_est_rsp ( UBYTE susp_req, UBYTE rsp )
430 {
431 TRACE_FUNCTION( "ctrl_send_rr_est_rsp" );
432 {
433 PALLOC(rrgrr_rr_est_rsp, RRGRR_RR_EST_RSP);
434
435 rrgrr_rr_est_rsp->rr_est = (rsp EQ GMMRR_CS_PAGE_REJ) ? RR_EST_NOT_ALLOWED : RR_EST_ALLOWED;
436
437 rrgrr_rr_est_rsp->susp_req = susp_req;
438
439 PSEND(hCommRR, rrgrr_rr_est_rsp);
440 }
441 }/* ctrl_send_rr_est_rsp*/
442
443 /*
444 +------------------------------------------------------------------------------
445 | Function : ctrl_suspend_services
446 +------------------------------------------------------------------------------
447 | Description : The function ctrl_suspend_services() ....
448 | This function suspends working services in GRR
449 | Parameters : void
450 |
451 +------------------------------------------------------------------------------
452 */
453 GLOBAL void ctrl_suspend_services ( UBYTE susp_cause )
454 {
455 TRACE_FUNCTION( "ctrl_suspend_services" );
456
457 if(susp_cause EQ GMMRR_ABNORMAL_RELEASE)
458 ctrl_stop_all_activities( CTRL_DC_SUSPEND_IMM_REL, NULL );
459 else
460 ctrl_stop_all_activities( CTRL_DC_SUSPEND_NORMAL, NULL );
461
462 }/* ctrl_suspend_services*/
463
464 /*
465 +------------------------------------------------------------------------------
466 | Function : ctrl_suspend_services
467 +------------------------------------------------------------------------------
468 | Description : The function ctrl_copy_non_gprs_opt() ....
469 | Copies the stored non-GPRS options into the given structure
470 | Parameters : p_non_gprs_opt: Pointer to the structure for non-GPRS access; derived from
471 | RRGRR.doc
472 |
473 +------------------------------------------------------------------------------
474 */
475 GLOBAL void ctrl_copy_non_gprs_opt( T_non_gprs *p_non_gprs_opt)
476 {
477
478 TRACE_FUNCTION( "ctrl_copy_non_gprs_opt" );
479
480 /* Copy non GPRS options */
481 p_non_gprs_opt->att = psc_db->non_gprs_opt.att; /*< 0> Attach / detach allowed */
482
483 p_non_gprs_opt->v_T3212 = psc_db->non_gprs_opt.v_t3212; /*< 1> valid-flag */
484 p_non_gprs_opt->T3212 = psc_db->non_gprs_opt.t3212; /*< 2> T 3212 time-out value */
485
486 p_non_gprs_opt->neci = psc_db->non_gprs_opt.neci; /*< 3> Half rate support */
487 p_non_gprs_opt->pwrc = psc_db->non_gprs_opt.pwcr; /*< 4> Power Control */
488 p_non_gprs_opt->dtx = psc_db->non_gprs_opt.dtx; /*< 5> Discontinuous Transmission (BCCH) */
489 p_non_gprs_opt->radio_link_timeout = psc_db->non_gprs_opt.rl_timeout; /*< 6> Radio Link Timeout */
490 p_non_gprs_opt->bs_ag_blks_res = psc_db->non_gprs_opt.bs_ag_blks_res; /*< 7> BS_AG_BLKS_RES */
491 p_non_gprs_opt->ccch_conf = psc_db->non_gprs_opt.ccch_conf; /*< 8> CCCF-CONF */
492 p_non_gprs_opt->bs_pa_mfrms = psc_db->non_gprs_opt.bs_pa_mfrms; /*< 9> BS-PA-MFRMS */
493 p_non_gprs_opt->max_retrans = psc_db->non_gprs_opt.max_retrans; /*< 10> MAX_RETRANS */
494 p_non_gprs_opt->tx_integer = psc_db->non_gprs_opt.tx_integer; /*< 11> TX_INTEGER */
495 p_non_gprs_opt->ec = psc_db->non_gprs_opt.ec; /*< 12> EC */
496 p_non_gprs_opt->gprs_ms_txpwr_max_cch = psc_db->non_gprs_opt.txpwr_max_cch; /*< 13> GPRS_MS_TXPWR_MAX_CCH */
497
498 #ifdef REL99
499 /* copy non GPRS extension information */
500 if( (psc_db->non_gprs_opt.v_non_gprs_ext_bits EQ TRUE) AND
501 (psc_db->non_gprs_opt.non_gprs_ext_bits.ext_len) )
502 {
503 /* copy Early classmark sending control flag from GRR database */
504 p_non_gprs_opt->ecsc =
505 psc_db->non_gprs_opt.non_gprs_ext_bits.non_gprs_ext_info.ecsc;
506 }
507 else
508 {
509 p_non_gprs_opt->ecsc = ECS_ALLOWED;
510 }
511 #endif
512
513 }/* ctrl_copy_non_gprs_opt*/
514
515
516 /*
517 +------------------------------------------------------------------------------
518 | Function : ctrl_is_gprs_suspension_request_needed
519 +------------------------------------------------------------------------------
520 | Description : The function ctrl_is_gprs_suspension_request_needed() ....
521 | checks whether MS has to send GPRS Suspension Request to the network
522 | or not
523 | Parameters : void
524 |
525 +------------------------------------------------------------------------------
526 */
527 GLOBAL BOOL ctrl_is_gprs_suspension_request_needed( void)
528 {
529 TRACE_FUNCTION( "ctrl_is_gprs_suspension_request_needed" );
530
531 if(
532 (psc_db->cell_info_for_gmm.cell_info.net_mode NEQ GMMRR_NET_MODE_III)
533 AND
534 (
535 /* BEGIN GRR_NMO_III*/
536 (grr_data->ms.class_of_mode EQ GMMRR_CLASS_B) OR
537 /* END GRR_NMO_III*/
538 (grr_data->ms.class_of_mode EQ GMMRR_CLASS_BC) OR
539 (grr_data->ms.class_of_mode EQ GMMRR_CLASS_BG)
540 )
541 )
542 {
543 /* We have to suspend GPRS activities on the network side, because of MS
544 * is not able to handle GPRS activities during the dedicated mode of operations
545 */
546 return TRUE;
547 }
548 return FALSE;
549 }/* ctrl_is_gprs_suspension_request_needed*/
550
551
552 /*
553 +------------------------------------------------------------------------------
554 | Function : ctrl_get_number_of_digits
555 +------------------------------------------------------------------------------
556 | Description : The function ctrl_get_number_of_digits() ....
557 | gets the number of valid digits in the array e.g. IMSI digits
558 | Parameters : void
559 |
560 +------------------------------------------------------------------------------
561 */
562 GLOBAL UBYTE ctrl_get_number_of_digits( UBYTE *digits)
563 {
564 UBYTE i = 0;
565
566 TRACE_FUNCTION ("ctrl_get_number_of_digits");
567
568 while (digits[i] < 0x0A AND i < 16)
569 i++;
570
571 return i;
572 }/* ctrl_get_number_of_digits*/
573
574 /*
575 +------------------------------------------------------------------------------
576 | Function : ctrl_send_cell_reselection_req
577 +------------------------------------------------------------------------------
578 | Description : The function ctrl_send_cell_reselection_req() ....
579 | Prepares the cell reselection parameters for RR
580 |
581 | Parameters :
582 |
583 +------------------------------------------------------------------------------
584 */
585 GLOBAL void ctrl_send_cell_reselection_req ( UBYTE cr_type )
586 {
587 TRACE_FUNCTION( "ctrl_send_cell_reselection_req" );
588
589 switch( cr_type )
590 {
591 case( CR_NEW ):
592 case( CR_NEW_NOT_SYNCED ):
593 {
594 ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE );
595
596 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;
597
598 if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE )
599 {
600 ctrl_handle_parked_rrgrr_cr_ind( GET_STATE( CTRL ) );
601 }
602 else
603 {
604 PALLOC( rrgrr_cr_req, RRGRR_CR_REQ );
605
606 rrgrr_cr_req->cr_type = cr_type;
607
608 if( grr_t_status( T3176 ) > 0 )
609 {
610 /*TRACE_ASSERT( posc_db NEQ NULL );*/
611
612 rrgrr_cr_req->arfcn = grr_data->ctrl.old_arfcn;
613 rrgrr_cr_req->bsic = grr_data->ctrl.old_bsic;
614 }
615 else
616 {
617 T_NC_MVAL *nc_mval;
618
619 nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
620
621 rrgrr_cr_req->arfcn = nc_mval->arfcn;
622 rrgrr_cr_req->bsic = nc_mval->sync_info.bsic;
623 }
624
625 TRACE_EVENT_P3( "RRGRR_CR_REQ: %d %d %d",
626 rrgrr_cr_req->cr_type,
627 rrgrr_cr_req->arfcn,
628 rrgrr_cr_req->bsic );
629
630 PSEND( hCommRR, rrgrr_cr_req );
631 }
632 }
633 break;
634
635 case( CR_COMPLETE ):
636 {
637 switch( grr_data->ctrl.rr_state.cr_ind_return )
638 {
639 case( CR_IND_RETURN_NONE ):
640 {
641 TRACE_EVENT( "RRGRR_CR_REQ: CR_IND_RETURN_NONE" );
642 }
643 break;
644
645 case( CR_IND_RETURN_RESPONSE ):
646 {
647 PALLOC( cr_rsp, RRGRR_CR_RSP );
648
649 TRACE_EVENT( "RRGRR_CR_RSP: CR_IND_RETURN_RESPONSE" );
650
651 PSEND( hCommRR, cr_rsp );
652
653 ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE );
654
655 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;
656 }
657 break;
658
659 case( CR_IND_RETURN_COMPLETE ):
660 {
661 PALLOC( rrgrr_cr_req, RRGRR_CR_REQ );
662
663 rrgrr_cr_req->cr_type = cr_type;
664 rrgrr_cr_req->arfcn = 0;
665 rrgrr_cr_req->bsic = 0;
666
667 TRACE_EVENT_P1( "RRGRR_CR_REQ: %d", rrgrr_cr_req->cr_type );
668
669 PSEND( hCommRR, rrgrr_cr_req );
670
671 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_NONE;
672 }
673 break;
674
675 default:
676 {
677 TRACE_ASSERT
678 ( grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_NONE OR
679 grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_RESPONSE OR
680 grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_COMPLETE );
681 }
682 break;
683 }
684 }
685 break;
686
687 case( CR_CS ):
688 {
689 ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE );
690 }
691
692 /*lint -fallthrough*/
693
694 case( CR_CONT ):
695 {
696 PALLOC( rrgrr_cr_req, RRGRR_CR_REQ );
697
698 rrgrr_cr_req->cr_type = cr_type;
699
700 TRACE_EVENT_P1( "RRGRR_CR_REQ: %d", rrgrr_cr_req->cr_type );
701
702 PSEND( hCommRR, rrgrr_cr_req );
703
704 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;
705 }
706 break;
707
708 default:
709 {
710 TRACE_ASSERT( cr_type EQ CR_NEW OR
711 cr_type EQ CR_NEW_NOT_SYNCED OR
712 cr_type EQ CR_COMPLETE OR
713 cr_type EQ CR_CONT OR
714 cr_type EQ CR_CS );
715 }
716 break;
717 }
718 }/* ctrl_send_cell_reselection_req */
719
720 /*
721 +------------------------------------------------------------------------------
722 | Function : ctrl_enable_serving_cell
723 +------------------------------------------------------------------------------
724 | Description : The function ctrl_enable_serving_cell() ....
725 |
726 | Parameters : void
727 |
728 +------------------------------------------------------------------------------
729 */
730 GLOBAL void ctrl_enable_serving_cell( UBYTE final )
731 {
732 TRACE_FUNCTION( "ctrl_enable_serving_cell" );
733
734 if( final )
735 {
736 ctrl_install_new_scell( );
737 }
738
739 #ifdef REL99
740 /* Update SGSN release in the common library */
741 cl_nwrl_set_sgsn_release(psc_db->sgsn_rel);
742 #endif
743
744 ctrl_send_cell_ind();
745
746 sig_ctrl_pg_start();
747
748 sig_ctrl_cs_pim();
749
750 sig_ctrl_cs_start( );
751
752 sig_ctrl_meas_pim( );
753
754 sig_ctrl_meas_start( );
755
756 ctrl_tc_access_enable( sig_ctrl_tc_disable_prim_queue );
757
758 }/* ctrl_enable_serving_cell */
759
760 /*
761 +------------------------------------------------------------------------------
762 | Function : ctrl_install_new_scell
763 +------------------------------------------------------------------------------
764 | Description : The function ctrl_install_new_scell() ....
765 |
766 | Parameters : void
767 |
768 +------------------------------------------------------------------------------
769 */
770 GLOBAL void ctrl_install_new_scell( void )
771 {
772 TRACE_FUNCTION( "ctrl_install_new_scell" );
773
774 if( ctrl_get_gprs_service( ) NEQ GPRS_SERVICE_NONE )
775 {
776 sig_ctrl_cs_install_new_scell( );
777 }
778
779 sig_ctrl_cs_cc_result( TRUE );
780
781 }/* ctrl_install_new_scell */
782
783 /*
784 +------------------------------------------------------------------------------
785 | Function : ctrl_reinstall_old_scell_req
786 +------------------------------------------------------------------------------
787 | Description : The function ctrl_reinstall_old_scell_req() ....
788 |
789 | Parameters :
790 |
791 +------------------------------------------------------------------------------
792 */
793 GLOBAL void ctrl_reinstall_old_scell_req( BOOL is_pcco, UBYTE cause )
794 {
795 TRACE_FUNCTION( "ctrl_reinstall_old_scell_req" );
796
797 if( grr_get_db_mode( ) EQ DB_MODE_CC_REQ )
798 {
799 ctrl_stop_all_activities( CTRL_DC_OTHER, NULL );
800 }
801
802 ctrl_send_reconnect_dcch_req( cause );
803
804 }/* ctrl_reinstall_old_scell_req */
805
806 /*
807 +------------------------------------------------------------------------------
808 | Function : ctrl_reinstall_old_scell_cnf
809 +------------------------------------------------------------------------------
810 | Description : The function ctrl_reinstall_old_scell_cnf() ....
811 |
812 | Parameters : void
813 |
814 +------------------------------------------------------------------------------
815 */
816 GLOBAL void ctrl_reinstall_old_scell_cnf( BOOL is_success )
817 {
818 TRACE_FUNCTION( "ctrl_reinstall_old_scell_cnf" );
819
820 if( is_success )
821 {
822 ctrl_cc_rejected( );
823 }
824 else
825 {
826 grr_set_db_ptr( DB_MODE_CC_REJ );
827
828 /*
829 * service PSI is still suspended, we have to stop it finally
830 */
831 sig_ctrl_psi_stop( );
832 /* grr_set_pbcch( FALSE ); */
833 }
834 }/* ctrl_reinstall_old_scell_cnf */
835
836 /*
837 +------------------------------------------------------------------------------
838 | Function : ctrl_send_cell_ind
839 +------------------------------------------------------------------------------
840 | Description : ctrl_send_cell_ind: composes and sends a GMMRR_CELL_IND message
841 |
842 | Parameters : void
843 |
844 +------------------------------------------------------------------------------
845 */
846 GLOBAL void ctrl_send_cell_ind()
847 {
848 TRACE_FUNCTION( "ctrl_send_cell_ind" );
849 {
850 PALLOC(gmmrr_cell_ind, GMMRR_CELL_IND);
851
852 grr_set_cell_info_service( );
853
854 memcpy( &gmmrr_cell_ind->cell_info,
855 &psc_db->cell_info_for_gmm.cell_info,
856 sizeof( T_cell_info ) );
857
858 #if !defined (NTRACE)
859
860 if( grr_data->cs.v_crp_trace EQ TRUE )
861 {
862 TRACE_EVENT_P9( "CELL_ENV: %x%x%x %x%x%x %x %x %x",
863 gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[0],
864 gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[1],
865 gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[2],
866 gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[0],
867 gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[1],
868 gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[2],
869 gmmrr_cell_ind->cell_info.cell_env.rai.lac,
870 gmmrr_cell_ind->cell_info.cell_env.rai.rac,
871 gmmrr_cell_ind->cell_info.cell_env.cid );
872 }
873
874 #endif /* #if !defined (NTRACE) */
875 grr_data->cell_res_status = FALSE;
876 PSEND(hCommGMM, gmmrr_cell_ind);
877 }
878 }/*ctrl_send_cell_ind */
879
880 /*
881 +------------------------------------------------------------------------------
882 | Function : ctrl_init_params
883 +------------------------------------------------------------------------------
884 | Description : ctrl_init_params initializes the parameters of the CTRL service
885 |
886 | Parameters : void
887 |
888 +------------------------------------------------------------------------------
889 */
890 GLOBAL void ctrl_init_params()
891 {
892 TRACE_FUNCTION( "ctrl_init_params" );
893
894 grr_data->ctrl.imm_rel = 0;
895 grr_data->cc_running = FALSE;
896 grr_data->pcco_failure_cause = 8;
897
898 }/* ctrl_init_params */
899
900 /*
901 +------------------------------------------------------------------------------
902 | Function : ctrl_copy_pbcch_des_from_ncell
903 +------------------------------------------------------------------------------
904 | Description : Copies pbcch description from the ncell description to a
905 | specific database
906 |
907 | Parameters : void
908 |
909 +------------------------------------------------------------------------------
910 */
911 GLOBAL void ctrl_copy_pbcch_des_from_ncell( T_SC_DATABASE *db )
912 {
913 T_NC_MVAL *nc_mval;
914 T_ncell_info *ncell_info;
915
916 nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
917 ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );
918
919 TRACE_FUNCTION( "ctrl_copy_pbcch_des_from_ncell" );
920
921 if( ncell_info NEQ NULL )
922 {
923 db->pbcch.pbcch_des.pb = 0;
924 db->pbcch.pbcch_des.tn = ncell_info->cr_par.si13_pbcch.pbcch_location;
925
926 /*
927 * for broadcast and common control channels, the TSC must be equal to BCC
928 */
929 db->pbcch.pbcch_des.tsc = ncell_info->bsic & BCC_OF_BSIC;
930
931 /*
932 * to indicate that the arfcn of the BCCH carrier should be used
933 */
934 db->pbcch.pbcch_des.flag = 0;
935 db->pbcch.pbcch_des.v_flag2 = 0;
936 db->pbcch.pbcch_des.flag2 = 0;
937
938 db->pbcch.bcch.arfcn = ncell_info->arfcn;
939 db->pbcch.bcch.bsic = ncell_info->bsic;
940 db->pbcch.bcch.pbcch_present = TRUE;
941
942 db->pccch.bs_pbcch_blks = 0;
943
944 db->psi1_params.psi1_repeat_period
945 = ncell_info->cr_par.si13_pbcch.psi1_repeat_period;
946 }
947 else
948 {
949 TRACE_ERROR( "ctrl_copy_pbcch_des_from_ncell: ncell_info EQ NULL" );
950 }
951 }/*ctrl_copy_pbcch_des_from_ncell*/
952
953
954 /*
955 +------------------------------------------------------------------------------
956 | Function : ctrl_sync_to_given_cell()
957 +------------------------------------------------------------------------------
958 | Description : This function starts synchronisation to the given cell
959 | neighbour cell
960 |
961 | Parameters : void
962 |
963 +------------------------------------------------------------------------------
964 */
965 GLOBAL void ctrl_sync_to_given_cell ( void )
966 {
967 T_NC_MVAL *nc_mval;
968 T_ncell_info *ncell_info;
969
970 TRACE_FUNCTION( "ctrl_sync_to_given_cell" );
971
972 nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
973 ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );
974
975 if( ncell_info NEQ NULL )
976 {
977 ctrl_stop_rr_task_req( GLBL_PCKT_MODE_SYNC, TASK_STOP_DUMMY_VALUE );
978
979 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;
980
981 if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE )
982 {
983 ctrl_handle_parked_rrgrr_cr_ind( GET_STATE( CTRL ) );
984 }
985 else
986 {
987 PALLOC( rrgrr_sync_req, RRGRR_SYNC_REQ );
988
989 rrgrr_sync_req->arfcn = ncell_info->arfcn;
990 rrgrr_sync_req->bsic = ncell_info->bsic;
991
992 PSEND( hCommRR, rrgrr_sync_req );
993 }
994
995 }
996 else
997 {
998 TRACE_ERROR( "ctrl_sync_to_given_cell: ncell_info EQ NULL" );
999 }
1000 } /* ctrl_sync_to_given_cell */
1001
1002
1003
1004 /*
1005 +------------------------------------------------------------------------------
1006 | Function : ctrl_stop_T3174
1007 +------------------------------------------------------------------------------
1008 | Description : The function stops T3174 when running.
1009 |
1010 | Parameters : void
1011 |
1012 +------------------------------------------------------------------------------
1013 */
1014 GLOBAL void ctrl_stop_T3174 ( void )
1015 {
1016 TRACE_FUNCTION( "ctrl_stop_T3174" );
1017
1018 TRACE_EVENT( "T3174 for packet cell change stopped" );
1019
1020 vsi_t_stop( GRR_handle, T3174 );
1021
1022 } /* ctrl_stop_T3174 */
1023
1024 /*
1025 +------------------------------------------------------------------------------
1026 | Function : ctrl_send_access_disable_if_needed()
1027 +------------------------------------------------------------------------------
1028 | Description : The function sends access disabled signal to TC, if needed
1029 |
1030 | Parameters : dc - disable cause
1031 |
1032 +------------------------------------------------------------------------------
1033 */
1034 GLOBAL void ctrl_send_access_disable_if_needed
1035 ( T_TC_DISABLE_CAUSE disable_cause,
1036 T_TC_DISABLE_CALLBACK_FUNC callback_func )
1037 {
1038 TRACE_FUNCTION( "ctrl_send_access_disable_if_needed" );
1039
1040 psc_db->is_access_enabled = FALSE;
1041
1042 sig_ctrl_tc_access_disable( disable_cause, callback_func );
1043
1044 } /* ctrl_send_access_disable_if_needed() */
1045
1046 /*
1047 +------------------------------------------------------------------------------
1048 | Function : ctrl_copy_cell_env()
1049 +------------------------------------------------------------------------------
1050 | Description :
1051 | Parameters :
1052 +------------------------------------------------------------------------------
1053 */
1054 GLOBAL void ctrl_copy_cell_env( T_cell_env *cell_env,
1055 T_serving_cell_info *scell_info )
1056 {
1057 TRACE_FUNCTION( "ctrl_copy_cell_env" );
1058
1059 psc_db->pbcch.bcch.arfcn = scell_info->bcch_arfcn;
1060 psc_db->pbcch.bcch.bsic = scell_info->bcch_bsic;
1061
1062 cell_env->rai.plmn = scell_info->rr_cell_env.plmn;
1063 cell_env->rai.lac = scell_info->rr_cell_env.lac;
1064 cell_env->cid = scell_info->rr_cell_env.cid;
1065
1066 #ifdef _SIMULATION_
1067
1068 TRACE_EVENT_P2( "ctrl_copy_cell_env - SCELL: %d %d",
1069 psc_db->pbcch.bcch.arfcn, psc_db->pbcch.bcch.bsic );
1070
1071 #endif /* #ifdef _SIMULATION_ */
1072
1073 } /* ctrl_copy_cell_env */
1074
1075 /*
1076 +------------------------------------------------------------------------------
1077 | Function : ctrl_copy_scell_params()
1078 +------------------------------------------------------------------------------
1079 | Description : This function copies some serving cell specific parameters into
1080 | database of GRR
1081 |
1082 | Parameters : sc_inf: pointer to serving cell information
1083 |
1084 +------------------------------------------------------------------------------
1085 */
1086 GLOBAL BOOL ctrl_copy_scell_params( T_serving_cell_info *sc_inf )
1087 {
1088 BOOL ba_bcch_changed = FALSE;
1089
1090 TRACE_FUNCTION("ctrl_copy_scell_params");
1091
1092 psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch
1093 = sc_inf->gprs_ms_txpwr_max_cch;
1094 psc_db->prach.ac_class = sc_inf->ac_class;
1095
1096 ctrl_copy_cell_env( &psc_db->cell_info_for_gmm.cell_info.cell_env, sc_inf );
1097
1098 grr_data->meas.pwr_offset = sc_inf->pwr_offset;
1099 psc_db->net_ctrl.bs_pa_mfrms = sc_inf->bs_pa_mfrms;
1100
1101 if(sc_inf->arfcn[0] EQ RRGRR_INVALID_ARFCN)
1102 {
1103 TRACE_EVENT("No BA list sent with SI13 info");
1104 return ba_bcch_changed;
1105 }
1106 #if defined (REL99) AND defined (TI_PS_FF_EMR)
1107 /* Copy ba_ind of the NC list */
1108 if(sc_inf->ba_ind NEQ psc_db->ba_ind)
1109 {
1110 grr_init_ba_bcch_nc_list(psc_db);
1111 psc_db->ba_ind = sc_inf->ba_ind;
1112 }
1113 #endif
1114
1115 if( grr_t_status( T3176 ) > 0 )
1116 {
1117 TRACE_EVENT
1118 ( "ctrl_copy_scell_params: packet cell change order - do not delete psc_db->nc_cw.list.number" );
1119 }
1120 else
1121 {
1122 UBYTE i = 0; /* used for counting */
1123
1124 while( i < RRGRR_BA_LIST_SIZE AND
1125 i < MAX_NR_OF_NCELL AND
1126 sc_inf->arfcn[i] NEQ RRGRR_INVALID_ARFCN )
1127 {
1128 if( psc_db->nc_cw.list.info[i].index NEQ i OR
1129 psc_db->nc_cw.list.info[i].arfcn NEQ sc_inf->arfcn[i] OR
1130 psc_db->nc_cw.list.info[i].bsic NEQ RRGRR_INVALID_BSIC )
1131 {
1132 psc_db->nc_cw.list.info[i].index = i;
1133 psc_db->nc_cw.list.info[i].arfcn = sc_inf->arfcn[i];
1134 psc_db->nc_cw.list.info[i].bsic = RRGRR_INVALID_BSIC;
1135
1136 NC_SET_TYPE ( psc_db->nc_cw.list.info[i].info_src, INFO_TYPE_BA_BCCH );
1137 NC_SET_INSTANCE( psc_db->nc_cw.list.info[i].info_src, 0 );
1138 NC_SET_NUMBER ( psc_db->nc_cw.list.info[i].info_src, 0 );
1139
1140 ba_bcch_changed = TRUE;
1141 }
1142
1143 i++;
1144 }
1145
1146 if( psc_db->nc_cw.list.number NEQ i )
1147 {
1148 psc_db->nc_cw.list.number = i;
1149 ba_bcch_changed = TRUE;
1150 }
1151 }
1152
1153 grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
1154 grr_data->pwr_ctrl_valid_flags.v_freq_param = TRUE;
1155
1156 return( ba_bcch_changed );
1157
1158 }/* ctrl_copy_scell_params */
1159
1160 /*
1161 +------------------------------------------------------------------------------
1162 | Function : ctrl_cell_change_order
1163 +------------------------------------------------------------------------------
1164 | Description : Start processing packet cell change order or cell change order
1165 |
1166 | Parameters :
1167 |
1168 +------------------------------------------------------------------------------
1169 */
1170 GLOBAL void ctrl_cell_change_order ( T_CTRL_CCO_TYPE type, void *data )
1171 {
1172 T_NC_MVAL *nc_mval;
1173
1174 TRACE_FUNCTION("ctrl_cell_change_order");
1175 TRACE_EVENT("ctrl_cell_change_order_started");/*to show the trace on target*/
1176
1177 switch( type )
1178 {
1179 case( CCO_TYPE_RR ):
1180 {
1181 T_D_CHANGE_ORDER *d_change_order = (T_D_CHANGE_ORDER *)data;
1182
1183 SET_STATE(CTRL,CTRL_RR_NC_CCO); /* set network commanded cell change order */
1184
1185 ctrl_stop_all_activities( CTRL_DC_CR_NW_RR, d_change_order );
1186
1187 grr_init_db( pcr_db );
1188
1189 /* process BCCH ARFCN and BSIC */
1190 pcr_db->pbcch.bcch.arfcn =
1191 ((USHORT)d_change_order->cell_desc.bcch_arfcn_hi << 8) +
1192 (USHORT)d_change_order->cell_desc.bcch_arfcn_lo;
1193 pcr_db->pbcch.bcch.bsic =
1194 (d_change_order->cell_desc.ncc << 3) +
1195 d_change_order->cell_desc.bcc;
1196
1197 /* process state variable */
1198 grr_data->cc_running = TRUE;
1199
1200 vsi_t_start(GRR_handle,T3134,T3134_VALUE);
1201 }
1202 break;
1203
1204 case( CCO_TYPE_GRR ):
1205 {
1206 T_D_CELL_CHAN_ORDER *d_cell_chan_order = ( T_D_CELL_CHAN_ORDER *)data;
1207
1208 grr_data->ctrl.pcc_arfcn = d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn;
1209 grr_data->ctrl.pcc_bsic = d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic;;
1210 grr_data->ctrl.old_arfcn = psc_db->pbcch.bcch.arfcn;
1211 grr_data->ctrl.old_bsic = psc_db->pbcch.bcch.bsic ;
1212
1213 TRACE_EVENT_P2("ctrl_cell_change_order:commanded cell is arfcn:%d ,bsic:%d",
1214 d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn,
1215 d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic);
1216
1217 if( grr_data->cs.gmm_state EQ STANDBY_STATE )
1218 {
1219 TRACE_EVENT("ctrl_cell_change_order:GMM in STANDBY state");
1220 grr_data->pcco_failure_cause = 5;/*MS in GMM standby mode*/
1221 ctrl_build_pcco_failure_msg(grr_data->ctrl.pcc_arfcn, grr_data->ctrl.pcc_bsic);
1222
1223 }
1224 else
1225 if (ctrl_check_cco_freq(grr_data->ctrl.pcc_arfcn))
1226 {
1227 SET_STATE( CTRL, CTRL_GRR_NC_CCO );
1228 ctrl_start_T3174( );
1229 sig_ctrl_cs_check_cell_location
1230 ( d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn,
1231 d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic);
1232
1233 nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
1234
1235 /* ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic ); */
1236
1237 grr_data->ctrl.imm_rel = d_cell_chan_order->tgt_cell_gsm_info.im_rel_c0;
1238
1239 ctrl_stop_all_activities( CTRL_DC_CR_NW_GRR, d_cell_chan_order );
1240
1241 grr_init_db( pcr_db );
1242
1243 pcr_db->pbcch.bcch.arfcn = nc_mval->arfcn;
1244 pcr_db->pbcch.bcch.bsic = nc_mval->sync_info.bsic;
1245 }
1246 else
1247 {
1248 TRACE_EVENT("ctrl_cell_change_order:frequency not implemented");
1249 grr_data->pcco_failure_cause = 0;/*Freq_Not_Impl*/
1250 ctrl_build_pcco_failure_msg(grr_data->ctrl.pcc_arfcn, grr_data->ctrl.pcc_bsic);
1251 }
1252 }
1253 break;
1254 }
1255 }/* ctrl_cell_change_order */
1256
1257 /*
1258 +------------------------------------------------------------------------------
1259 | Function : ctrl_send_reconnect_dcch_req
1260 +------------------------------------------------------------------------------
1261 | Description : This is only to be sent when cell change failure occures
1262 |
1263 | Parameters :
1264 |
1265 +------------------------------------------------------------------------------
1266 */
1267 GLOBAL void ctrl_send_reconnect_dcch_req ( UBYTE cause )
1268 {
1269 TRACE_FUNCTION( "ctrl_send_reconnect_dcch_req" );
1270
1271 {
1272 PALLOC( rrgrr_reconnect_dcch_req, RRGRR_RECONNECT_DCCH_REQ );
1273
1274 rrgrr_reconnect_dcch_req->reconn_cause = cause;
1275
1276 PSEND( hCommRR, rrgrr_reconnect_dcch_req );
1277 }
1278 }/* ctrl_send_reconnect_dcch_req */
1279
1280 /*
1281 +------------------------------------------------------------------------------
1282 | Function : ctrl_si13_received
1283 +------------------------------------------------------------------------------
1284 | Description :
1285 |
1286 | Parameters :
1287 |
1288 +------------------------------------------------------------------------------
1289 */
1290 GLOBAL void ctrl_si13_received( T_RRGRR_GPRS_SI13_IND * rrgrr_si13_ind )
1291 {
1292 BOOL ba_bcch_changed;
1293
1294 TRACE_FUNCTION( "ctrl_si13_received" );
1295
1296 ctrl_set_gprs_service( rrgrr_si13_ind->cause,
1297 rrgrr_si13_ind->serving_cell_info.limited );
1298
1299 ba_bcch_changed = ctrl_copy_scell_params( &rrgrr_si13_ind->serving_cell_info );
1300
1301 if( rrgrr_si13_ind->cause EQ GPRS_SUPPORTED )
1302 {
1303 sig_ctrl_psi_si13_received( rrgrr_si13_ind, ba_bcch_changed );
1304 }
1305
1306 grr_cgrlc_pwr_ctrl_req( FALSE );
1307
1308 }/* ctrl_si13_received */
1309
1310 /*
1311 +------------------------------------------------------------------------------
1312 | Function : ctrl_cc_rejected
1313 +------------------------------------------------------------------------------
1314 | Description :
1315 |
1316 | Parameters :
1317 |
1318 +------------------------------------------------------------------------------
1319 */
1320 GLOBAL void ctrl_cc_rejected ( void )
1321 {
1322 TRACE_FUNCTION( "ctrl_cc_rejected" );
1323
1324 grr_set_db_ptr( DB_MODE_CC_REJ );
1325
1326 if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE )
1327 {
1328 sig_ctrl_cs_cc_result( TRUE );
1329 }
1330 else
1331 {
1332 sig_ctrl_cs_cc_result( FALSE );
1333 }
1334 }/* ctrl_cc_rejected */
1335
1336 /*
1337 +------------------------------------------------------------------------------
1338 | Function : ctrl_failure_processing
1339 +------------------------------------------------------------------------------
1340 | Description :
1341 |
1342 | Parameters :
1343 |
1344 +------------------------------------------------------------------------------
1345 */
1346 GLOBAL void ctrl_failure_processing ( T_FAILURE_SIGNAL fail_sig )
1347 {
1348 UBYTE state = GET_STATE( CTRL );
1349
1350 TRACE_FUNCTION( "ctrl_failure_processing" );
1351
1352 TRACE_EVENT_P1( "ctrl_failure_processing: failure signal %d", fail_sig );
1353
1354 switch( state )
1355 {
1356 case CTRL_READY_TO_PROGRESS:
1357 if (grr_data->db.old_scell.pbcch_present EQ TRUE)
1358 {
1359 grr_set_db_ptr( DB_MODE_CC_REJ );
1360 sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL );
1361 }
1362 else
1363 {
1364 /* The old cell is without PBBCH */
1365 ctrl_send_cell_reselection_req( CR_CONT );
1366 }
1367 break;
1368
1369 case CTRL_READY:
1370 case CTRL_ACCESS_DISABLED:
1371 case CTRL_IN_PROGRESS:
1372 if (fail_sig EQ FAIL_SIG_DSF_IND)
1373 {
1374 sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_DL_SIG_FAIL );
1375 }
1376 else
1377 {
1378 sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL );
1379 }
1380 break;
1381
1382 case CTRL_RR_CR_IN_SUSP:
1383 case CTRL_AUTO_RR_CR:
1384 ctrl_send_cell_reselection_req( CR_CONT );
1385 break;
1386
1387 case CTRL_CR:
1388 case CTRL_CR_IN_SUSP:
1389 SET_STATE_FAILED_CR( state );
1390
1391 ctrl_cc_rejected( );
1392 break;
1393
1394 case CTRL_RR_NC_CCO:
1395 SET_STATE( CTRL, CTRL_IN_PROGRESS );
1396
1397 ctrl_reinstall_old_scell_req( FALSE, RECONN_NO_ACTIVITY );
1398 break;
1399 case CTRL_GRR_NC_CCO:
1400 if ( grr_t_status(T3174) > 0)
1401 {
1402 ctrl_stop_T3174();
1403 }
1404 ctrl_pcco_failure( );
1405 break;
1406
1407 default:
1408 TRACE_ERROR( "ctrl_failure_processing: failure signal unexpected" );
1409 break;
1410 }
1411 } /* ctrl_failure_processing */
1412
1413 /*
1414 +------------------------------------------------------------------------------
1415 | Function : ctrl_pcco_failure
1416 +------------------------------------------------------------------------------
1417 | Description : Handles the internal signal ctrl_pcco_failure
1418 |
1419 | Parameters : void
1420 |
1421 +------------------------------------------------------------------------------
1422 */
1423
1424 GLOBAL void ctrl_pcco_failure(void)
1425 {
1426 TRACE_ISIG( "ctrl_pcco_failure" );
1427
1428 vsi_t_start( GRR_handle, T3176, T3176_VALUE );
1429
1430 TRACE_EVENT( "ctrl_pcco_failure:T3176 started." );
1431
1432 ctrl_stop_all_activities( CTRL_DC_CR_NW_GRR, NULL );
1433
1434 } /* ctrl_pcoo_failure */
1435
1436
1437 /*
1438 +------------------------------------------------------------------------------
1439 | Function : ctrl_build_pcco_failure_msg
1440 +------------------------------------------------------------------------------
1441 | Description : The function is to send packet cell change failure message
1442 |
1443 | Parameters : void
1444 |
1445 +------------------------------------------------------------------------------
1446 */
1447 GLOBAL void ctrl_build_pcco_failure_msg(USHORT arfcn, UBYTE bsic)
1448 {
1449 TRACE_FUNCTION( "ctrl_build_pcco_failure_msg" );
1450 TRACE_EVENT("ctrl_build_pcco_failure_msg");
1451 {
1452 T_U_CELL_CHAN_FAILURE u_cell_chan_failure;
1453
1454 u_cell_chan_failure.msg_type = U_CELL_CHAN_FAILURE_c;
1455
1456 grr_set_buf_tlli( &u_cell_chan_failure.tlli_value, grr_get_tlli( ) );
1457
1458 u_cell_chan_failure.arfcn = arfcn;
1459 u_cell_chan_failure.bsic = bsic;
1460 u_cell_chan_failure.failure_cause = grr_data->pcco_failure_cause;
1461
1462 TRACE_EVENT_P2("ctrl_build_pcco_failure_msg: pcc_arfcn = %1d,pcc_bsic = %1d", arfcn,bsic);
1463
1464 ctrl_send_control_block( CGRLC_BLK_OWNER_CTRL, (void*)(&u_cell_chan_failure) );
1465 }
1466 } /*ctrl_build_pcco_failure_msg */
1467
1468 /*
1469 +------------------------------------------------------------------------------
1470 | Function : ctrl_send_control_block
1471 +------------------------------------------------------------------------------
1472 | Description : This function is used to signal service TC the request for
1473 | sending a control block.
1474 |
1475 | Parameters : void
1476 |
1477 +------------------------------------------------------------------------------
1478 */
1479 GLOBAL void ctrl_send_control_block ( T_BLK_OWNER blk_owner,
1480 void * blk_struct )
1481 {
1482
1483 TRACE_FUNCTION( "ctrl_send_control_block" );
1484 TRACE_EVENT( "ctrl_send_control_block" );
1485
1486 switch( blk_owner )
1487 {
1488 case( CGRLC_BLK_OWNER_MEAS ):
1489 case( CGRLC_BLK_OWNER_CS ):
1490 /*
1491 * If the timers related to measurement reporting expire while the
1492 * reselection procedure has not yet been completed, these timers
1493 * shall be restarted so that the mobile station resumes measurement
1494 * reporting procedures once camped on the new cell
1495 */
1496 if( grr_t_status( T3174 ) > 0 OR grr_t_status( T3176 ) > 0 )
1497 {
1498 ctrl_send_control_block_result( blk_owner, FALSE );
1499
1500 TRACE_ERROR( "ctrl_send_control_block: measurement reporting not allowed" );
1501 }
1502 else
1503 {
1504 sig_ctrl_tc_control_block( blk_owner, blk_struct );
1505 }
1506 break;
1507
1508 default:
1509 sig_ctrl_tc_control_block( blk_owner, blk_struct );
1510 break;
1511 }
1512 } /* ctrl_send_control_block */
1513
1514 /*
1515 +------------------------------------------------------------------------------
1516 | Function : ctrl_cancel_control_block
1517 +------------------------------------------------------------------------------
1518 | Description :
1519 |
1520 | Parameters : void
1521 |
1522 +------------------------------------------------------------------------------
1523 */
1524 GLOBAL void ctrl_cancel_control_block ( T_BLK_OWNER blk_owner )
1525 {
1526 TRACE_FUNCTION( "ctrl_cancel_control_block" );
1527
1528 sig_ctrl_tc_cancel_control_block( blk_owner );
1529
1530 } /* ctrl_cancel_control_block */
1531
1532 /*
1533 +------------------------------------------------------------------------------
1534 | Function : ctrl_send_control_block_result
1535 +------------------------------------------------------------------------------
1536 | Description :
1537 |
1538 | Parameters : void
1539 |
1540 +------------------------------------------------------------------------------
1541 */
1542 GLOBAL void ctrl_send_control_block_result ( T_BLK_OWNER blk_owner,
1543 BOOL is_success )
1544 {
1545 TRACE_FUNCTION( "ctrl_send_control_block_result" );
1546
1547 switch( blk_owner )
1548 {
1549 case( CGRLC_BLK_OWNER_MEAS ):
1550 if( is_success ) sig_ctrl_meas_pmr_accept( );
1551 else sig_ctrl_meas_pmr_reject( );
1552 break;
1553
1554 case( CGRLC_BLK_OWNER_CS ):
1555 if( is_success ) sig_ctrl_cs_pmr_accept( );
1556 else sig_ctrl_cs_pmr_reject( );
1557 break;
1558
1559 case( CGRLC_BLK_OWNER_CTRL ):
1560 vsi_t_stop( GRR_handle, T3176 );
1561 TRACE_EVENT("ctrl_send_control_block_result:T3176 stopped");
1562 break;
1563
1564 default:
1565 TRACE_ERROR( "ctrl_send_control_block_result: blk_owner out of range" );
1566 break;
1567 }
1568 } /* ctrl_send_control_block_result */
1569
1570 /*
1571 +------------------------------------------------------------------------------
1572 | Function : ctrl_resp_resume
1573 +------------------------------------------------------------------------------
1574 | Description : The function ctrl_resp_resume() ....
1575 |
1576 | Parameters : void
1577 |
1578 +------------------------------------------------------------------------------
1579 */
1580 GLOBAL void ctrl_resp_resume( void )
1581 {
1582 psc_db->is_access_enabled = TRUE;
1583
1584 ctrl_send_cell_ind();
1585
1586 sig_ctrl_pg_start();
1587
1588 sig_ctrl_psi_resumpt();
1589
1590 sig_ctrl_cs_pim( );
1591
1592 sig_ctrl_cs_start( );
1593
1594 sig_ctrl_meas_pim( );
1595
1596 sig_ctrl_meas_resume( );
1597
1598 ctrl_tc_access_enable( sig_ctrl_tc_disable_prim_queue );
1599
1600 }/* ctrl_resp_resume */
1601
1602 /*
1603 +------------------------------------------------------------------------------
1604 | Function : ctrl_handle_new_candidate
1605 +------------------------------------------------------------------------------
1606 | Description :
1607 |
1608 | Parameters : void
1609 |
1610 +------------------------------------------------------------------------------
1611 */
1612 GLOBAL void ctrl_handle_new_candidate( BOOL initial )
1613 {
1614 UBYTE state;
1615 T_NC_MVAL *nc_mval;
1616 T_ncell_info *ncell_info;
1617
1618 TRACE_FUNCTION( "ctrl_handle_new_candidate" );
1619
1620 grr_init_db( pcr_db );
1621
1622 state = GET_STATE( CTRL );
1623
1624 switch( state )
1625 {
1626 case CTRL_CR:
1627 case CTRL_FAILED_CR:
1628 case CTRL_GRR_NC_CCO:
1629 SET_STATE( CTRL, CTRL_CR );
1630 break;
1631
1632 case CTRL_CR_IN_SUSP:
1633 case CTRL_FAILED_CR_IN_SUSP:
1634 SET_STATE( CTRL, CTRL_CR_IN_SUSP );
1635 break;
1636
1637 default:
1638 TRACE_EVENT_P1( "ctrl_handle_new_candidate: unexpected state %d", state );
1639 break;
1640 }
1641
1642 nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
1643 ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );
1644
1645 /*
1646 * Store ARFCN and BSIC of the cell re-selection candidate,
1647 * these parameters should be used to avoid considering RRGRR_SI13_IND
1648 * and RRGRR_GPRS_IND primitives which maybe present in the data queue
1649 * of GRR but belong to the old serving cell.
1650 */
1651 pcr_db->pbcch.bcch.arfcn = nc_mval->arfcn;
1652 pcr_db->pbcch.bcch.bsic = nc_mval->sync_info.bsic;
1653
1654 if( ncell_info NEQ NULL )
1655 {
1656
1657 #ifdef _SIMULATION_
1658
1659 if( ncell_info->cr_par.v_si13_pbcch AND
1660 !ncell_info->cr_par.si13_pbcch.v_si13_location )
1661 {
1662 /*
1663 * Copy pbcch description from the ncell description to pcr_db
1664 */
1665 ctrl_copy_pbcch_des_from_ncell( pcr_db );
1666
1667 /*
1668 * We have to synchronize to the new cell to be able
1669 * to read full PSI in the new cell
1670 */
1671 ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW_PBCCH_INFO, initial );
1672 }
1673 else
1674
1675 #endif /* #ifdef _SIMULATION_ */
1676
1677 {
1678 ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW, initial );
1679 }
1680 }
1681 else
1682 {
1683 ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW, initial );
1684 }
1685 } /* ctrl_handle_new_candidate */
1686
1687 /*
1688 +------------------------------------------------------------------------------
1689 | Function : ctrl_handle_no_more_candidate
1690 +------------------------------------------------------------------------------
1691 | Description :
1692 |
1693 | Parameters : void
1694 |
1695 +------------------------------------------------------------------------------
1696 */
1697 GLOBAL void ctrl_handle_no_more_candidate( T_CTRL_CR_TYPE ctrl_cr_type,
1698 BOOL initial )
1699 {
1700 TRACE_FUNCTION( "ctrl_handle_no_more_candidate" );
1701
1702 SET_STATE( CTRL, CTRL_READY );
1703
1704 /* grr_set_db_ptr( DB_MODE_INIT ); */
1705 ctrl_start_cell_reselection( ctrl_cr_type, initial );
1706
1707 } /* ctrl_handle_no_more_candidate */
1708
1709 /*
1710 +------------------------------------------------------------------------------
1711 | Function : ctrl_start_rr_task
1712 +------------------------------------------------------------------------------
1713 | Description :
1714 |
1715 | Parameters : void
1716 |
1717 +------------------------------------------------------------------------------
1718 */
1719 GLOBAL void ctrl_start_rr_task ( UBYTE state )
1720 {
1721 TRACE_FUNCTION( "ctrl_start_rr_task" );
1722
1723 if( state EQ TASK_STATE_PTM OR grr_is_pbcch_present( ) )
1724 {
1725 PALLOC( rrgrr_start_task_req, RRGRR_START_TASK_REQ );
1726
1727 rrgrr_start_task_req->state = state;
1728
1729 PSEND( hCommRR, rrgrr_start_task_req );
1730 }
1731 } /* ctrl_start_rr_task */
1732
1733 /*
1734 +------------------------------------------------------------------------------
1735 | Function : ctrl_stop_rr_task_req
1736 +------------------------------------------------------------------------------
1737 | Description :
1738 |
1739 | Parameters : void
1740 |
1741 +------------------------------------------------------------------------------
1742 */
1743 GLOBAL void ctrl_stop_rr_task_req
1744 ( T_GLBL_PCKT_MODE final_pckt_mode, UBYTE param )
1745 {
1746 BOOL pbcch_present = grr_is_pbcch_present( );
1747 BOOL change_pckt_mode;
1748 UBYTE curr_pckt_mode;
1749 T_CTRL_TASK ctrl_task;
1750
1751 TRACE_FUNCTION( "ctrl_stop_rr_task_req" );
1752
1753 change_pckt_mode = ctrl_set_transient_pckt_mode( final_pckt_mode, &ctrl_task );
1754 curr_pckt_mode = GET_STATE( CTRL_GLBL );
1755
1756 if( change_pckt_mode )
1757 {
1758 if( curr_pckt_mode EQ GLBL_PCKT_MODE_IDLE_ASSIGNED OR
1759 curr_pckt_mode EQ GLBL_PCKT_MODE_IDLE_ACCESS OR
1760 ( curr_pckt_mode EQ GLBL_PCKT_MODE_TRANSFER_ACCESS AND
1761 !pbcch_present ) OR
1762 curr_pckt_mode EQ GLBL_PCKT_MODE_RELEASED_ACCESS )
1763 {
1764 ctrl_leave_to_pam( );
1765 }
1766
1767 if( ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_NULL AND
1768 pbcch_present EQ TRUE )
1769 {
1770 grr_data->ctrl_glbl.ctrl_task = ctrl_task;
1771
1772 sig_ctrl_psi_rel_state( REL_PERFORMED );
1773 ctrl_stop_rr_task_cnf( TRUE );
1774 }
1775 else if( ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SUSP )
1776 {
1777 grr_data->ctrl_glbl.ctrl_task = ctrl_task;
1778
1779 ctrl_stop_rr_task_cnf( TRUE );
1780 }
1781 else if( pbcch_present )
1782 {
1783 if( ctrl_task NEQ CTRL_TASK_NONE AND
1784 ctrl_task NEQ CTRL_TASK_PBCCH_LEAVE_SYNC )
1785 {
1786 ctrl_send_rrgrr_stop_task_req( ctrl_task, param );
1787 }
1788 else
1789 {
1790 ctrl_stop_rr_task_cnf( change_pckt_mode );
1791 }
1792 }
1793 else
1794 {
1795 ctrl_stop_rr_task_cnf( change_pckt_mode );
1796 }
1797 }
1798 else
1799 {
1800 if ( curr_pckt_mode EQ GLBL_PCKT_MODE_ACCESS )
1801 {
1802 ctrl_enter_pam( );
1803 }
1804 else if( curr_pckt_mode EQ GLBL_PCKT_MODE_ACCESS_TWO_PHASE )
1805 {
1806 sig_ctrl_pg_mode_ind( PACKET_MODE_2P_PTM );
1807 }
1808 else if( curr_pckt_mode EQ GLBL_PCKT_MODE_MEAS_REP_IDLE )
1809 {
1810 sig_ctrl_pg_mode_ind( PACKET_MODE_PIM );
1811 }
1812 else if( curr_pckt_mode EQ GLBL_PCKT_MODE_SUSP )
1813 {
1814 ctrl_start_rr_task( TASK_STATE_PIM );
1815 }
1816
1817 ctrl_stop_rr_task_cnf( change_pckt_mode );
1818 }
1819 } /* ctrl_stop_rr_task_req */
1820
1821 /*
1822 +------------------------------------------------------------------------------
1823 | Function : ctrl_stop_rr_task_cnf
1824 +------------------------------------------------------------------------------
1825 | Description :
1826 |
1827 | Parameters : void
1828 |
1829 +------------------------------------------------------------------------------
1830 */
1831 GLOBAL void ctrl_stop_rr_task_cnf ( BOOL change_pckt_mode )
1832 {
1833 TRACE_FUNCTION( "ctrl_stop_rr_task_cnf" );
1834
1835 ctrl_set_final_pckt_mode( );
1836
1837 if( change_pckt_mode )
1838 {
1839 T_GLBL_PCKT_MODE pckt_mode = GET_STATE( CTRL_GLBL );
1840
1841 if( pckt_mode EQ GLBL_PCKT_MODE_IDLE )
1842 {
1843 if ( grr_data->ctrl_glbl.ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SUSP )
1844 {
1845 ctrl_resp_resume( );
1846 }
1847 else if( grr_data->ctrl_glbl.ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SYNC )
1848 {
1849 /*
1850 * just set the correct state,
1851 * detailed processing will be performed by the calling function
1852 */
1853 }
1854 else if( grr_data->ctrl_glbl.ctrl_task NEQ CTRL_TASK_PBCCH_LEAVE_NULL )
1855 {
1856 ctrl_enter_pim( );
1857 ctrl_start_rr_task( TASK_STATE_PIM );
1858 }
1859 }
1860 else if( pckt_mode EQ GLBL_PCKT_MODE_ACCESS )
1861 {
1862 ctrl_enter_pam( );
1863
1864 if( grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_NULL )
1865 {
1866 ctrl_start_rr_task( TASK_STATE_PAM );
1867 }
1868 else
1869 {
1870 TRACE_EVENT( "No task start for PAM, DL assignment received" );
1871 }
1872 }
1873 else if( pckt_mode EQ GLBL_PCKT_MODE_ASSIGNED )
1874 {
1875 if( grr_data->tc.last_eval_assign.ccch_read EQ DONT_STOP_CCCH )
1876 {
1877 sig_ctrl_pg_mode_ind( PACKET_MODE_PAM );
1878 }
1879
1880 sig_ctrl_tc_leave_to_ptm( );
1881 }
1882 else if( pckt_mode EQ GLBL_PCKT_MODE_TRANSFER )
1883 {
1884 ctrl_enter_ptm( );
1885 ctrl_start_rr_task( TASK_STATE_PTM );
1886 }
1887 else if( pckt_mode EQ GLBL_PCKT_MODE_RELEASED )
1888 {
1889 sig_ctrl_tc_leave_to_pim( );
1890 }
1891 }
1892
1893 grr_data->ctrl_glbl.ctrl_task = CTRL_TASK_NONE;
1894 } /* ctrl_stop_rr_task_cnf */
1895
1896 /*
1897 +------------------------------------------------------------------------------
1898 | Function : ctrl_send_rrgrr_stop_task_req
1899 +------------------------------------------------------------------------------
1900 | Description :
1901 |
1902 | Parameters :
1903 |
1904 +------------------------------------------------------------------------------
1905 */
1906 GLOBAL void ctrl_send_rrgrr_stop_task_req ( T_CTRL_TASK ctrl_task, UBYTE param )
1907 {
1908 PALLOC( rrgrr_stop_task_req, RRGRR_STOP_TASK_REQ );
1909
1910 TRACE_FUNCTION( "ctrl_send_rrgrr_stop_task_req" );
1911
1912 switch( ctrl_task )
1913 {
1914 case CTRL_TASK_PBCCH_LEAVE_IDLE:
1915 rrgrr_stop_task_req->ctrl_task = LEAVE_PIM_PBCCH;
1916 rrgrr_stop_task_req->task.v_pim_pbcch = param;
1917 break;
1918
1919 case CTRL_TASK_PBCCH_LEAVE_ACCESS:
1920 rrgrr_stop_task_req->ctrl_task = LEAVE_PAM_PBCCH;
1921 rrgrr_stop_task_req->task.v_pam_pbcch = param;
1922 break;
1923
1924 case CTRL_TASK_PBCCH_LEAVE_TRANSFER:
1925 rrgrr_stop_task_req->ctrl_task = LEAVE_PTM_PBCCH;
1926 rrgrr_stop_task_req->task.v_ptm_pbcch = param;
1927 break;
1928
1929 case CTRL_TASK_BCCH:
1930 rrgrr_stop_task_req->ctrl_task = RR_TASK_1;
1931 rrgrr_stop_task_req->task.v_stop_ccch = param;
1932 break;
1933
1934 default:
1935 PFREE( rrgrr_stop_task_req );
1936
1937 TRACE_ERROR( "ctrl_send_rrgrr_stop_task_req: invalid control task" );
1938 TRACE_EVENT_P1( "FATAL ERROR: ctrl_send_rrgrr_stop_task_req: %d",
1939 ctrl_task );
1940 return;
1941 }
1942
1943 /*
1944 * Issue #22667, Patch FDS 28-04-04 - Fix for TIL 06 in spain
1945 * Don't change the ctrl state if RR doesn't respond to the stop_task_req
1946 */
1947
1948 if ( (ctrl_task NEQ CTRL_TASK_BCCH) OR (param NEQ INVALID_MSG) )
1949 grr_data->ctrl_glbl.ctrl_task = ctrl_task;
1950
1951 #ifdef _SIMULATION_
1952
1953 TRACE_EVENT_P1( "ctrl_send_rrgrr_stop_task_req - ctrl_task: %d",
1954 grr_data->ctrl_glbl.ctrl_task );
1955
1956 #endif /* #ifdef _SIMULATION_ */
1957
1958 PSEND( hCommRR, rrgrr_stop_task_req );
1959
1960 } /* ctrl_send_rrgrr_stop_task_req */
1961
1962
1963 /*
1964 +------------------------------------------------------------------------------
1965 | Function : ctrl_set_final_pckt_mode
1966 +------------------------------------------------------------------------------
1967 | Description :
1968 |
1969 | Parameters : void
1970 |
1971 +------------------------------------------------------------------------------
1972 */
1973 LOCAL void ctrl_set_final_pckt_mode ( void )
1974 {
1975 UBYTE pckt_mode = GET_STATE( CTRL_GLBL );
1976
1977 TRACE_FUNCTION( "ctrl_set_final_pckt_mode" );
1978
1979 switch( pckt_mode )
1980 {
1981 case( GLBL_PCKT_MODE_NULL_IDLE ):
1982 case( GLBL_PCKT_MODE_SUSP_IDLE ):
1983 case( GLBL_PCKT_MODE_SYNC_IDLE ):
1984 case( GLBL_PCKT_MODE_ACCESS_IDLE ):
1985 case( GLBL_PCKT_MODE_ASSIGNED_IDLE ):
1986 case( GLBL_PCKT_MODE_TRANSFER_IDLE ):
1987 case( GLBL_PCKT_MODE_RELEASED_IDLE ):
1988 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE );
1989 break;
1990
1991 case( GLBL_PCKT_MODE_IDLE_ACCESS ):
1992 case( GLBL_PCKT_MODE_TRANSFER_ACCESS ):
1993 case( GLBL_PCKT_MODE_RELEASED_ACCESS ):
1994 case( GLBL_PCKT_MODE_ACCESS_TWO_PHASE ):
1995 case( GLBL_PCKT_MODE_MEAS_REP_IDLE ):
1996 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );
1997 break;
1998
1999 case( GLBL_PCKT_MODE_IDLE_ASSIGNED ):
2000 case( GLBL_PCKT_MODE_ACCESS_ASSIGNED ):
2001 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED );
2002 break;
2003
2004 case( GLBL_PCKT_MODE_IDLE_TRANSFER ):
2005 case( GLBL_PCKT_MODE_ASSIGNED_TRANSFER ):
2006 case( GLBL_PCKT_MODE_ACCESS_TRANSFER ):
2007 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER );
2008 break;
2009
2010 case( GLBL_PCKT_MODE_TRANSFER_RELEASED ):
2011 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED );
2012 break;
2013
2014 case( GLBL_PCKT_MODE_NULL ):
2015 case( GLBL_PCKT_MODE_SUSP ):
2016 case( GLBL_PCKT_MODE_SYNC ):
2017 case( GLBL_PCKT_MODE_IDLE ):
2018 case( GLBL_PCKT_MODE_ACCESS ):
2019 case( GLBL_PCKT_MODE_ASSIGNED ):
2020 case( GLBL_PCKT_MODE_TRANSFER ):
2021 case( GLBL_PCKT_MODE_RELEASED ):
2022 /* do nothing */
2023 break;
2024
2025 default:
2026 TRACE_ERROR( "ctrl_set_final_pckt_mode: invalid transition packet mode" );
2027 TRACE_EVENT_P1( "FATAL ERROR: ctrl_set_final_pckt_mode: %d", pckt_mode );
2028 break;
2029 }
2030 } /* ctrl_set_final_pckt_mode */
2031
2032 /*
2033 +------------------------------------------------------------------------------
2034 | Function : ctrl_set_transient_pckt_mode
2035 +------------------------------------------------------------------------------
2036 | Description :
2037 |
2038 | Parameters :
2039 |
2040 +------------------------------------------------------------------------------
2041 */
2042 LOCAL BOOL ctrl_set_transient_pckt_mode
2043 ( T_GLBL_PCKT_MODE final_pckt_mode, T_CTRL_TASK *ctrl_task )
2044 {
2045 BOOL change_pckt_mode = TRUE;
2046 UBYTE curr_pckt_mode = GET_STATE( CTRL_GLBL );
2047
2048 TRACE_FUNCTION( "ctrl_set_transient_pckt_mode" );
2049
2050 *ctrl_task = CTRL_TASK_NONE;
2051
2052 switch( final_pckt_mode )
2053 {
2054 case( GLBL_PCKT_MODE_NULL ):
2055 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL );
2056
2057 change_pckt_mode = FALSE;
2058 break;
2059
2060 case( GLBL_PCKT_MODE_SUSP ):
2061 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SUSP );
2062
2063 change_pckt_mode = FALSE;
2064 break;
2065
2066 case( GLBL_PCKT_MODE_SYNC ):
2067 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SYNC );
2068
2069 change_pckt_mode = FALSE;
2070 break;
2071
2072 case( GLBL_PCKT_MODE_IDLE ):
2073 switch( curr_pckt_mode )
2074 {
2075 case( GLBL_PCKT_MODE_NULL ):
2076 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL_IDLE );
2077
2078 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_NULL;
2079 break;
2080
2081 case( GLBL_PCKT_MODE_SUSP ):
2082 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SUSP_IDLE );
2083
2084 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_SUSP;
2085 break;
2086
2087 case( GLBL_PCKT_MODE_SYNC ):
2088 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SYNC_IDLE );
2089
2090 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_SYNC;
2091 break;
2092
2093 case( GLBL_PCKT_MODE_IDLE ):
2094 change_pckt_mode = FALSE;
2095 break;
2096
2097 case( GLBL_PCKT_MODE_ACCESS ):
2098 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_IDLE );
2099
2100 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS;
2101 break;
2102
2103 case( GLBL_PCKT_MODE_ASSIGNED ):
2104 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED_IDLE );
2105 break;
2106
2107 case( GLBL_PCKT_MODE_TRANSFER ):
2108 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_IDLE );
2109
2110 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER;
2111 break;
2112
2113 case( GLBL_PCKT_MODE_RELEASED ):
2114 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED_IDLE );
2115 break;
2116
2117 default:
2118 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE );
2119
2120 change_pckt_mode = FALSE;
2121
2122 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2123 curr_pckt_mode, final_pckt_mode );
2124 break;
2125 }
2126 break;
2127
2128 case( GLBL_PCKT_MODE_ACCESS ):
2129 switch( curr_pckt_mode )
2130 {
2131 case( GLBL_PCKT_MODE_IDLE ):
2132 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_ACCESS );
2133
2134 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE;
2135 break;
2136
2137 case( GLBL_PCKT_MODE_ACCESS ):
2138 change_pckt_mode = FALSE;
2139 break;
2140
2141 case( GLBL_PCKT_MODE_TRANSFER ):
2142 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_ACCESS );
2143
2144 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER;
2145 break;
2146
2147 case( GLBL_PCKT_MODE_RELEASED ):
2148 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED_ACCESS );
2149 break;
2150
2151 default:
2152 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );
2153
2154 change_pckt_mode = FALSE;
2155
2156 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2157 curr_pckt_mode, final_pckt_mode );
2158 break;
2159 }
2160 break;
2161
2162 case( GLBL_PCKT_MODE_ACCESS_TWO_PHASE ):
2163 switch( curr_pckt_mode )
2164 {
2165 case( GLBL_PCKT_MODE_ACCESS ):
2166 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_TWO_PHASE );
2167
2168 change_pckt_mode = FALSE;
2169 break;
2170
2171 default:
2172 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );
2173
2174 change_pckt_mode = FALSE;
2175
2176 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2177 curr_pckt_mode, final_pckt_mode );
2178 break;
2179 }
2180 break;
2181
2182 case( GLBL_PCKT_MODE_MEAS_REP_IDLE ):
2183 switch( curr_pckt_mode )
2184 {
2185 case( GLBL_PCKT_MODE_ACCESS ):
2186 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_MEAS_REP_IDLE );
2187
2188 change_pckt_mode = FALSE;
2189 break;
2190
2191 default:
2192 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );
2193
2194 change_pckt_mode = FALSE;
2195
2196 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2197 curr_pckt_mode, final_pckt_mode );
2198 break;
2199 }
2200 break;
2201
2202 case( GLBL_PCKT_MODE_ASSIGNED ):
2203 switch( curr_pckt_mode )
2204 {
2205 case( GLBL_PCKT_MODE_IDLE ):
2206 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_ASSIGNED );
2207
2208 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE;
2209 break;
2210
2211 case( GLBL_PCKT_MODE_ACCESS ):
2212 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_ASSIGNED );
2213
2214 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS;
2215 break;
2216
2217 case( GLBL_PCKT_MODE_ASSIGNED ):
2218 change_pckt_mode = FALSE;
2219 break;
2220
2221 default:
2222 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED );
2223
2224 change_pckt_mode = FALSE;
2225
2226 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2227 curr_pckt_mode, final_pckt_mode );
2228 break;
2229 }
2230 break;
2231
2232 case( GLBL_PCKT_MODE_TRANSFER ):
2233 switch( curr_pckt_mode )
2234 {
2235 case( GLBL_PCKT_MODE_IDLE ):
2236 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_TRANSFER );
2237
2238 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE;
2239 break;
2240
2241 case( GLBL_PCKT_MODE_ACCESS ):
2242 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_TRANSFER );
2243
2244 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS;
2245 break;
2246
2247 case( GLBL_PCKT_MODE_ASSIGNED ):
2248 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED_TRANSFER );
2249 break;
2250
2251 case( GLBL_PCKT_MODE_TRANSFER ):
2252 change_pckt_mode = FALSE;
2253 break;
2254
2255 default:
2256 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER );
2257
2258 change_pckt_mode = FALSE;
2259
2260 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2261 curr_pckt_mode, final_pckt_mode );
2262 break;
2263 }
2264 break;
2265
2266 case( GLBL_PCKT_MODE_RELEASED ):
2267 switch( curr_pckt_mode )
2268 {
2269 case( GLBL_PCKT_MODE_TRANSFER ):
2270 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_RELEASED );
2271
2272 *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER;
2273 break;
2274
2275 case( GLBL_PCKT_MODE_RELEASED ):
2276 change_pckt_mode = FALSE;
2277 break;
2278
2279 default:
2280 SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED );
2281
2282 change_pckt_mode = FALSE;
2283
2284 TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
2285 curr_pckt_mode, final_pckt_mode );
2286 break;
2287 }
2288 break;
2289
2290 default:
2291 change_pckt_mode = FALSE;
2292
2293 TRACE_ERROR ( "ctrl_set_transient_pckt_mode: invalid final packet mode" );
2294 TRACE_EVENT_P1( "FATAL ERROR: ctrl_set_transient_pckt_mode: %d",
2295 final_pckt_mode );
2296 break;
2297 }
2298
2299 return( change_pckt_mode );
2300
2301 } /* ctrl_set_transient_pckt_mode */
2302
2303 /*
2304 +------------------------------------------------------------------------------
2305 | Function : ctrl_enter_pim
2306 +------------------------------------------------------------------------------
2307 | Description :
2308 |
2309 | Parameters : void
2310 |
2311 +------------------------------------------------------------------------------
2312 */
2313 LOCAL void ctrl_enter_pim ( void )
2314 {
2315 TRACE_FUNCTION( "ctrl_enter_pim" );
2316
2317 /*
2318 * Reset TA-Values
2319 */
2320 memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS));
2321 grr_data->ta_params.ta_valid = FALSE;
2322
2323 sig_ctrl_pg_mode_ind( PACKET_MODE_PIM );
2324 sig_ctrl_psi_pim( );
2325 sig_ctrl_meas_pim( );
2326 sig_ctrl_cs_pim( );
2327
2328 } /* ctrl_enter_pim */
2329
2330 /*
2331 +------------------------------------------------------------------------------
2332 | Function : ctrl_leave_to_pam
2333 +------------------------------------------------------------------------------
2334 | Description :
2335 |
2336 | Parameters : void
2337 |
2338 +------------------------------------------------------------------------------
2339 */
2340 LOCAL void ctrl_leave_to_pam ( void )
2341 {
2342 TRACE_FUNCTION( "ctrl_leave_to_pam" );
2343
2344 sig_ctrl_meas_pam( );
2345 sig_ctrl_psi_pam( );
2346 sig_ctrl_cs_leave_to_pam( );
2347
2348 } /* ctrl_leave_to_pam */
2349
2350 /*
2351 +------------------------------------------------------------------------------
2352 | Function : ctrl_enter_pam
2353 +------------------------------------------------------------------------------
2354 | Description :
2355 |
2356 | Parameters : void
2357 |
2358 +------------------------------------------------------------------------------
2359 */
2360 LOCAL void ctrl_enter_pam ( void )
2361 {
2362 TRACE_FUNCTION( "ctrl_enter_pam" );
2363
2364 sig_ctrl_pg_mode_ind( PACKET_MODE_PAM );
2365 sig_ctrl_cs_enter_pam( );
2366
2367 /*
2368 * PATCH 1 BEGIN 10.12.2002
2369 */
2370
2371 /*
2372 * wait 2 ms after pccch_req, otherwise prach will not sent --> L1 BUG02724
2373 */
2374 vsi_t_sleep( VSI_CALLER 2 );
2375
2376 /*
2377 * PATCH 1 END 10.12.2002
2378 */
2379
2380 sig_ctrl_tc_enter_pam( );
2381 } /* ctrl_enter_pam */
2382
2383 /*
2384 +------------------------------------------------------------------------------
2385 | Function : ctrl_enter_ptm
2386 +------------------------------------------------------------------------------
2387 | Description :
2388 |
2389 | Parameters : void
2390 |
2391 +------------------------------------------------------------------------------
2392 */
2393 LOCAL void ctrl_enter_ptm ( void )
2394 {
2395 TRACE_FUNCTION( "ctrl_enter_ptm" );
2396
2397 sig_ctrl_psi_ptm( );
2398 sig_ctrl_pg_mode_ind( PACKET_MODE_PTM );
2399 sig_ctrl_meas_ptm( );
2400 sig_ctrl_cs_ptm( );
2401 } /* ctrl_enter_ptm */
2402
2403 /*
2404 +------------------------------------------------------------------------------
2405 | Function : ctrl_set_old_scell
2406 +------------------------------------------------------------------------------
2407 | Description :
2408 |
2409 | Parameters : void
2410 |
2411 +------------------------------------------------------------------------------
2412 */
2413 GLOBAL void ctrl_set_old_scell ( BOOL service )
2414 {
2415 TRACE_FUNCTION( "ctrl_set_old_scell" );
2416
2417 ctrl_send_gmmrr_cr_ind( );
2418
2419 if( service )
2420 {
2421 grr_data->db.old_scell.arfcn = psc_db->pbcch.bcch.arfcn;
2422 grr_data->db.old_scell.bsic = psc_db->pbcch.bcch.bsic;
2423 grr_data->db.old_scell.pbcch_present = psc_db->pbcch.bcch.pbcch_present;
2424 }
2425 else
2426 {
2427 grr_data->db.old_scell.arfcn = RRGRR_INVALID_ARFCN;
2428 grr_data->db.old_scell.bsic = RRGRR_INVALID_BSIC;
2429 grr_data->db.old_scell.pbcch_present = FALSE;
2430 }
2431
2432 grr_data->ctrl.new_cell_responded = FALSE;
2433 grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_RESPONSE;
2434
2435 #ifdef _SIMULATION_
2436
2437 TRACE_EVENT_P2( "ctrl_set_old_scell - old SCELL: %d %d",
2438 grr_data->db.old_scell.arfcn, grr_data->db.old_scell.bsic );
2439
2440 #endif /* #ifdef _SIMULATION_ */
2441
2442 } /* ctrl_set_old_scell( ) */
2443
2444 /*
2445 +------------------------------------------------------------------------------
2446 | Function : ctrl_send_gmmrr_cr_ind
2447 +------------------------------------------------------------------------------
2448 | Description :
2449 |
2450 | Parameters : void
2451 |
2452 +------------------------------------------------------------------------------
2453 */
2454 GLOBAL void ctrl_send_gmmrr_cr_ind ( void )
2455 {
2456 PALLOC( gmmrr_cr_ind, GMMRR_CR_IND );
2457 PSEND( hCommGMM, gmmrr_cr_ind );
2458
2459 TRACE_FUNCTION( "ctrl_send_gmmrr_cr_ind" );
2460 } /* ctrl_send_gmmrr_cr_ind( ) */
2461
2462 /*
2463 +------------------------------------------------------------------------------
2464 | Function : ctrl_start_cell_reselection
2465 +------------------------------------------------------------------------------
2466 | Description :
2467 |
2468 | Parameters :
2469 |
2470 +------------------------------------------------------------------------------
2471 */
2472 GLOBAL void ctrl_start_cell_reselection ( T_CTRL_CR_TYPE ctrl_cr_type,
2473 BOOL initial )
2474 {
2475 UBYTE cr_type = CR_CS;
2476
2477 TRACE_FUNCTION( "ctrl_start_cell_reselection" );
2478
2479 if( initial EQ TRUE )
2480 {
2481 ctrl_set_old_scell( TRUE );
2482 }
2483
2484 switch( ctrl_cr_type )
2485 {
2486 case CTRL_CR_TYPE_CS : /* nothing to do */ break;
2487 case CTRL_CR_TYPE_NEW :
2488 case CTRL_CR_TYPE_NEW_PBCCH_INFO: cr_type = CR_NEW; break;
2489 case CTRL_CR_TYPE_NEW_NOT_SYNCED: cr_type = CR_NEW_NOT_SYNCED; break;
2490 case CTRL_CR_TYPE_CONT : cr_type = CR_CONT; break;
2491
2492 default:
2493 TRACE_ASSERT( ctrl_cr_type EQ CTRL_CR_TYPE_CS OR
2494 ctrl_cr_type EQ CTRL_CR_TYPE_NEW OR
2495 ctrl_cr_type EQ CTRL_CR_TYPE_NEW_PBCCH_INFO OR
2496 ctrl_cr_type EQ CTRL_CR_TYPE_NEW_NOT_SYNCED OR
2497 ctrl_cr_type EQ CTRL_CR_TYPE_CONT );
2498 break;
2499 }
2500
2501 if( ctrl_cr_type EQ CTRL_CR_TYPE_NEW_PBCCH_INFO )
2502 {
2503 ctrl_sync_to_given_cell( );
2504 }
2505 else
2506 {
2507 ctrl_send_cell_reselection_req( cr_type );
2508 }
2509
2510 sig_ctrl_cs_start_cell_selection( cr_type );
2511
2512 } /* ctrl_start_cell_reselection() */
2513
2514 /*
2515 +------------------------------------------------------------------------------
2516 | Function : ctrl_cell_has_changed
2517 +------------------------------------------------------------------------------
2518 | Description :
2519 |
2520 | Parameters :
2521 |
2522 +------------------------------------------------------------------------------
2523 */
2524 GLOBAL BOOL ctrl_cell_has_changed ( void )
2525 {
2526 #ifdef _SIMULATION_
2527
2528 TRACE_EVENT_P5( "ctrl_cell_has_changed - %d - new SCELL: %d %d - old SCELL: %d %d",
2529 grr_data->ctrl.new_cell_responded,
2530 psc_db->pbcch.bcch.arfcn,
2531 psc_db->pbcch.bcch.bsic,
2532 grr_data->db.old_scell.arfcn,
2533 grr_data->db.old_scell.bsic );
2534
2535 #endif /* #ifdef _SIMULATION_ */
2536
2537 return
2538 ( grr_data->ctrl.new_cell_responded EQ FALSE AND
2539 ( grr_data->db.old_scell.arfcn NEQ psc_db->pbcch.bcch.arfcn OR
2540 grr_data->db.old_scell.bsic NEQ psc_db->pbcch.bcch.bsic ) );
2541 } /* ctrl_cell_has_changed() */
2542
2543 /*
2544 +------------------------------------------------------------------------------
2545 | Function : ctrl_tc_access_enable
2546 +------------------------------------------------------------------------------
2547 | Description :
2548 |
2549 | Parameters :
2550 |
2551 +------------------------------------------------------------------------------
2552 */
2553 GLOBAL void ctrl_tc_access_enable( T_TC_ACCESS_ENABLE_FUNC access_enable_func )
2554 {
2555 grr_data->ctrl.new_cell_responded |=
2556 access_enable_func( ctrl_cell_has_changed( ) );
2557
2558 #ifdef _SIMULATION_
2559
2560 TRACE_EVENT_P5( "ctrl_tc_access_enable - %d - new SCELL: %d %d - old SCELL: %d %d",
2561 grr_data->ctrl.new_cell_responded,
2562 psc_db->pbcch.bcch.arfcn,
2563 psc_db->pbcch.bcch.bsic,
2564 grr_data->db.old_scell.arfcn,
2565 grr_data->db.old_scell.bsic );
2566
2567 #endif /* #ifdef _SIMULATION_ */
2568
2569 } /* ctrl_tc_access_enable() */
2570
2571 /*
2572 +------------------------------------------------------------------------------
2573 | Function : ctrl_check_cco_freq
2574 +------------------------------------------------------------------------------
2575 | Description : Check if the frequency in the Cell change order is capable of
2576 | using
2577 |
2578 | Parameters :
2579 |
2580 +------------------------------------------------------------------------------
2581 */
2582 LOCAL BOOL ctrl_check_cco_freq ( USHORT arfcn )
2583 {
2584 BOOL result = FALSE;
2585
2586 TRACE_FUNCTION( "ctrl_check_cco_freq" );
2587 TRACE_EVENT( "ctrl_check_cco_freq started" );/*for target trace*/
2588
2589 switch( std )
2590 {
2591 case STD_900: /* frequencies must between 1 and 124 */
2592
2593 if(( arfcn >= LOW_CHANNEL_900 ) AND ( arfcn <= HIGH_CHANNEL_900))
2594 {
2595 result = TRUE;
2596 }
2597 break;
2598
2599 case STD_EGSM:
2600
2601 if(( arfcn <= HIGH_CHANNEL_900) OR
2602 (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)))
2603 {
2604 result = TRUE;
2605 }
2606 break;
2607
2608 case STD_1900:
2609
2610 if(( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900))
2611 {
2612 result = TRUE;
2613 }
2614 break;
2615
2616 case STD_1800:
2617
2618 if(( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800))
2619 {
2620 result = TRUE;
2621 }
2622 break;
2623
2624 case STD_850:
2625
2626 if(( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850))
2627 {
2628 result = TRUE;
2629 }
2630 break;
2631
2632 case STD_DUAL:
2633
2634 if ((( arfcn >= LOW_CHANNEL_900 ) AND ( arfcn <= HIGH_CHANNEL_900)) OR
2635 (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)))
2636 {
2637 result = TRUE;
2638 }
2639 break;
2640
2641 case STD_DUAL_EGSM:
2642
2643 if((( arfcn <= HIGH_CHANNEL_900) OR
2644 (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)))
2645 OR
2646 (( arfcn >= LOW_CHANNEL_1800 ) AND
2647 ( arfcn <= HIGH_CHANNEL_1800)))
2648 {
2649 result = TRUE;
2650 }
2651 break;
2652
2653 case STD_DUAL_US:
2654 if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
2655 (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)))
2656 {
2657 result = TRUE;
2658 }
2659 break;
2660
2661 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT
2662 case STD_850_1800:
2663 if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
2664 (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)))
2665 {
2666 result = TRUE;
2667 }
2668 break;
2669
2670 case STD_900_1900:
2671 if(( arfcn <= HIGH_CHANNEL_900) OR
2672 (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR
2673 (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)))
2674 {
2675 result = TRUE;
2676 }
2677 break;
2678
2679 case STD_850_900_1800:
2680 if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
2681 ( arfcn <= HIGH_CHANNEL_900) OR
2682 (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR
2683 (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)))
2684 {
2685 result = TRUE;
2686 }
2687 break;
2688
2689 case STD_850_900_1900:
2690 if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
2691 ( arfcn <= HIGH_CHANNEL_900) OR
2692 (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR
2693 (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)))
2694 {
2695 result = TRUE;
2696 }
2697 break;
2698 #endif
2699
2700 default:
2701 break;
2702 }
2703 return(result);
2704
2705 } /* ctrl_check_cco_freq() */
2706
2707 /*
2708 +------------------------------------------------------------------------------
2709 | Function : ctrl_get_gprs_service
2710 +------------------------------------------------------------------------------
2711 | Description :
2712 |
2713 | Parameters :
2714 |
2715 +------------------------------------------------------------------------------
2716 */
2717 GLOBAL T_GPRS_SERVICE ctrl_get_gprs_service ( void )
2718 {
2719 TRACE_FUNCTION( "ctrl_get_gprs_service" );
2720
2721 return( psc_db->cell_info_for_gmm.gprs_service );
2722 } /* ctrl_get_gprs_service() */
2723
2724 /*
2725 +------------------------------------------------------------------------------
2726 | Function : ctrl_set_gprs_service
2727 +------------------------------------------------------------------------------
2728 | Description :
2729 |
2730 | Parameters :
2731 |
2732 +------------------------------------------------------------------------------
2733 */
2734 GLOBAL void ctrl_set_gprs_service ( UBYTE cause, UBYTE limited )
2735 {
2736 TRACE_FUNCTION( "ctrl_set_gprs_service" );
2737
2738 switch( cause )
2739 {
2740 case GPRS_SUPPORTED:
2741 psc_db->cell_info_for_gmm.gprs_service =
2742 ( limited EQ TRUE ? GPRS_SERVICE_LIMITED : GPRS_SERVICE_FULL );
2743 break;
2744
2745 case GPRS_NOT_SUPPORTED:
2746 case GPRS_CELL_NOT_SUITABLE:
2747 default:
2748 psc_db->cell_info_for_gmm.gprs_service = GPRS_SERVICE_NONE;
2749 break;
2750 }
2751
2752 grr_set_cell_info_service( );
2753
2754 } /* ctrl_set_gprs_service() */
2755
2756 /*
2757 +------------------------------------------------------------------------------
2758 | Function : ctrl_send_gmmrr_suspend_cnf
2759 +------------------------------------------------------------------------------
2760 | Description :
2761 |
2762 | Parameters :
2763 |
2764 +------------------------------------------------------------------------------
2765 */
2766 GLOBAL void ctrl_send_gmmrr_suspend_cnf ( void )
2767 {
2768 TRACE_FUNCTION( "ctrl_send_gmmrr_suspend_cnf" );
2769
2770 {
2771 PALLOC( gmmrr_suspend_cnf, GMMRR_SUSPEND_CNF );
2772 PSEND( hCommGMM, gmmrr_suspend_cnf );
2773 }
2774 } /* ctrl_send_gmmrr_suspend_cnf() */
2775
2776 /*
2777 +------------------------------------------------------------------------------
2778 | Function : ctrl_handle_gmmrr_cs_page_ind
2779 +------------------------------------------------------------------------------
2780 | Description :
2781 |
2782 | Parameters :
2783 |
2784 +------------------------------------------------------------------------------
2785 */
2786 GLOBAL void ctrl_handle_gmmrr_cs_page_ind( UBYTE state )
2787 {
2788 TRACE_FUNCTION( "ctrl_handle_gmmrr_cs_page_ind" );
2789
2790 grr_data->ctrl.last_state = state;
2791
2792 {
2793 PALLOC( gmmrr_cs_page_ind, GMMRR_CS_PAGE_IND );
2794 PSEND( hCommGMM, gmmrr_cs_page_ind );
2795 }
2796 } /* ctrl_handle_gmmrr_cs_page_ind() */
2797
2798 /*
2799 +------------------------------------------------------------------------------
2800 | Function : ctrl_handle_parked_rrgrr_cr_ind
2801 +------------------------------------------------------------------------------
2802 | Description :
2803 |
2804 | Parameters :
2805 |
2806 +------------------------------------------------------------------------------
2807 */
2808 GLOBAL void ctrl_handle_parked_rrgrr_cr_ind( UBYTE state )
2809 {
2810 UBYTE glbl_state = GET_STATE( CTRL_GLBL );
2811
2812 TRACE_FUNCTION( "ctrl_handle_parked_rrgrr_cr_ind" );
2813
2814 if( glbl_state EQ GLBL_PCKT_MODE_NULL OR
2815 glbl_state EQ GLBL_PCKT_MODE_SYNC OR
2816 glbl_state EQ GLBL_PCKT_MODE_SUSP )
2817 {
2818 /*
2819 * In this state the cell re-selection triggered by GRR
2820 * is already requested with a RRGRR_CR_REQ
2821 */
2822 if( state EQ CTRL_CR )
2823 {
2824 SET_STATE( CTRL, CTRL_AUTO_RR_CR );
2825 }
2826 else if( state EQ CTRL_CR_IN_SUSP )
2827 {
2828 SET_STATE( CTRL, CTRL_RR_CR_IN_SUSP );
2829 }
2830 else
2831 {
2832 TRACE_EVENT_P1( "ctrl_handle_parked_rrgrr_cr_ind in state %d", state );
2833 }
2834
2835 ctrl_cc_rejected( );
2836 ctrl_set_old_scell( FALSE );
2837 ctrl_send_cell_reselection_req( CR_COMPLETE );
2838
2839 grr_data->ctrl.parked_rrgrr_cr_ind = FALSE;
2840 }
2841 } /* ctrl_handle_parked_rrgrr_cr_ind() */
2842
2843
2844 /*
2845 +------------------------------------------------------------------------------
2846 | Function : ctrl_read_pcm
2847 +------------------------------------------------------------------------------
2848 | Description : The function ctrl_read_pcm read some info from ffs to decide
2849 | if nc2 should be switched on or off
2850 |
2851 | Parameters : void
2852 |
2853 +------------------------------------------------------------------------------
2854 */
2855
2856 GLOBAL void ctrl_read_pcm ( void )
2857 {
2858 #ifdef _TARGET_
2859 T_GRR_FFS GRR_ffsBuffer;
2860 T_FFS_SIZE size = ffs_fread("/GPRS/grr", &GRR_ffsBuffer, sizeof(GRR_ffsBuffer));
2861 #endif
2862
2863 TRACE_FUNCTION( "ctrl_read_pcm" );
2864
2865 grr_data->nc2_on = TRUE;
2866 #ifdef _TARGET_
2867 if ( size != sizeof(GRR_ffsBuffer) )
2868 {
2869 if ( size < 0 )
2870 {
2871 TRACE_EVENT_P1("FFS can not be read \"/GPRS/grr\" (%d)", size);
2872 }
2873 else
2874 {
2875 TRACE_EVENT_P2("FFS contains old file of \"/GPRS/grr\": %dBytes long, but %dBytes expected",
2876 size, sizeof(GRR_ffsBuffer));
2877 }
2878 }
2879 else
2880 {
2881 grr_data->nc2_on = GRR_ffsBuffer.nc2_on;
2882 }
2883 #endif
2884 TRACE_EVENT_P1("ctrl_read_pcm: grr_data->nc2_on is %d",grr_data->nc2_on);
2885 return;
2886 }
2887
2888 /*
2889 +------------------------------------------------------------------------------
2890 | Function : ctrl_enter_standby_state
2891 +------------------------------------------------------------------------------
2892 | Description :
2893 |
2894 | Parameters :
2895 |
2896 +------------------------------------------------------------------------------
2897 */
2898 GLOBAL void ctrl_enter_standby_state( void )
2899 {
2900 TRACE_FUNCTION( "ctrl_enter_standby_state" );
2901
2902 switch( GET_STATE( CTRL ) )
2903 {
2904 case CTRL_NULL:
2905 TRACE_ERROR( "ctrl_enter_standby_state: unexpected signalling" );
2906 break;
2907
2908 default:
2909 sig_ctrl_cs_gmm_state( STANDBY_STATE );
2910
2911 if( grr_is_pbcch_present( ) EQ FALSE )
2912 {
2913 PALLOC( rrgrr_standby_state_ind, RRGRR_STANDBY_STATE_IND );
2914 PSEND( hCommRR, rrgrr_standby_state_ind );
2915 }
2916 break;
2917 }
2918 } /* ctrl_enter_standby_state() */
2919
2920 /*
2921 +------------------------------------------------------------------------------
2922 | Function : ctrl_enter_ready_state
2923 +------------------------------------------------------------------------------
2924 | Description :
2925 |
2926 | Parameters :
2927 |
2928 +------------------------------------------------------------------------------
2929 */
2930 GLOBAL void ctrl_enter_ready_state( void )
2931 {
2932 TRACE_FUNCTION( "ctrl_enter_ready_state" );
2933
2934 switch( GET_STATE( CTRL ) )
2935 {
2936 case CTRL_NULL:
2937 TRACE_ERROR( "ctrl_enter_ready_state: unexpected signalling" );
2938 break;
2939
2940 default:
2941 sig_ctrl_cs_gmm_state( READY_STATE );
2942
2943 if( grr_is_pbcch_present( ) EQ FALSE )
2944 {
2945 PALLOC( rrgrr_ready_state_ind, RRGRR_READY_STATE_IND );
2946 PSEND( hCommRR, rrgrr_ready_state_ind );
2947 }
2948 break;
2949 }
2950 } /* ctrl_enter_ready_state() */
2951
2952 #ifdef REL99
2953 /*
2954 +------------------------------------------------------------------------------
2955 | Function : ctrl_create_freq_list_cbch
2956 +------------------------------------------------------------------------------
2957 | Description : Creates the frequency list to be used for mobile allocation
2958 | when CBCH has hopping channel.
2959 | Parameters. : cbch_req -output ; points the cbch information structure
2960 | that would be sent in RRGRR_CBCH_INFO_IND
2961 | freq_par : frequency parameters struct received in PSI 8
2962 | describing the CBCH channel.
2963 | gp_ma : GPRS mobile allocation IE referred in Freq parametrs
2964 | struct.
2965 | ma_num : MA_NUM received in freq params, when indirect encoding
2966 | is used. Otherwise, this parameter is not important.
2967 +------------------------------------------------------------------------------
2968 */
2969 GLOBAL BOOL ctrl_create_freq_list_cbch(T_cbch *cbch_req,const T_freq_par *freq_par,const T_gprs_ms_alloc_ie *gp_ma,UBYTE ma_num)
2970 {
2971 T_LIST list1; /*lint !e813*/
2972 USHORT list2[64]; /*lint !e813*/
2973 USHORT count = 0;
2974 TRACE_FUNCTION( "ctrl_create_freq_list_cbch" );
2975 memset(&list1, 0, sizeof(T_LIST));
2976 memset(list2, NOT_PRESENT_16BIT, sizeof(list2));
2977 /*
2978 * Now we have the GPRS Mobile Allocation corresponding to the ma_num.
2979 * Get the referenced set of radio frequency lists for this
2980 * particular GPRS Mobile Allocation IE.
2981 * If RFL number list is not present in the IE, then cell allocation
2982 * would be returned by this function.
2983 */
2984 if(!grr_get_ref_list_or_cell_allocation(&list1,gp_ma,ma_num))
2985 {
2986 TRACE_ERROR("Could not get ref list");
2987 return FALSE;
2988 }
2989
2990 /*
2991 * Copy ARFCN values into freq_list
2992 */
2993 srv_create_list (&list1, list2, 64, TRUE, 0);
2994
2995 /*
2996 * Take MA_BITMAP or ARFCN_INDEX into account
2997 */
2998 grr_ma_filter_list( list2, /* input */
2999 cbch_req->ma, /* output */
3000 gp_ma
3001 );
3002
3003 /*
3004 * Get number of copied frequencies
3005 */
3006 if(!grr_validate_and_count_frequencies( cbch_req->ma,&count))
3007 {
3008 TRACE_ERROR( "grr_create_freq_list: validation failed/freq count zero" );
3009 return FALSE;
3010 }
3011
3012 /* The hopping frequency list has to be sent to RR should be in the form
3013 * that is used in MPH sap. The T_p_freq_list used in MPHP sap. The temporary
3014 * variable temp_p_freq_list has been temporarily used here to reuse the
3015 * code. The last element in temp_p_freq_list should be set to NOT_PRESENT_16BIT
3016 * and then copied back to T_cbch cbch_req.
3017 */
3018 cbch_req->ma[count] = NOT_PRESENT_16BIT;
3019
3020 /*There is no need to convert the frequencies to L1 form. This would be
3021 * done by ALR when this information is passed to it by RR.
3022 */
3023
3024 cbch_req->hsn = gp_ma->hsn;
3025 return TRUE;
3026 }/* ctrl_create_freq_list_cbch */
3027
3028 /*
3029 +------------------------------------------------------------------------------
3030 | Function : ctrl_fill_cbch_hopping_params
3031 +------------------------------------------------------------------------------
3032 | Description : Fills the hopping list to be sent in RRGRR_CBCH_INFO_IND
3033 |
3034 | Parameters : cbch_req - points to cbch info that would go in primitive.
3035 | freq_par - frequency parameters received in psi8
3036 |
3037 +------------------------------------------------------------------------------
3038 */
3039 GLOBAL BOOL ctrl_fill_cbch_hopping_params(T_cbch *cbch_req,const T_freq_par *freq_par)
3040 {
3041 T_gprs_ms_alloc_ie *gp_ma = NULL;
3042 BOOL result = FALSE;
3043
3044
3045 TRACE_FUNCTION("ctrl_fill_cbch_hopping_params");
3046
3047 if(freq_par->v_indi_encod)
3048 {
3049 result = grr_validate_ma_num_in_freq_par(freq_par,GRR_FREQ_PARAM_RECEIVED_IN_NON_ASSIGNMENT);
3050 if(result)
3051 {
3052 gp_ma = grr_get_gprs_ma(freq_par->indi_encod.ma_num);
3053 if(gp_ma EQ NULL)
3054 {
3055 TRACE_EVENT("No valid GPRS_MA found");
3056 return FALSE;
3057 }
3058 if(!ctrl_create_freq_list_cbch(cbch_req,
3059 freq_par,
3060 gp_ma,
3061 freq_par->indi_encod.ma_num))
3062 {
3063 TRACE_EVENT("Failed to create freq list for cbch");
3064 return FALSE;
3065 }
3066 cbch_req->maio = freq_par->indi_encod.maio;
3067 }
3068 else
3069 {
3070 TRACE_ERROR("error creating frequency list,Invalid MA_NUM");
3071 result = FALSE;
3072 }
3073 } /* if(freq_par->v_indi_encod) */
3074 else if(freq_par->v_di_encod1)
3075 {
3076
3077 /* In this case, the GPRS mobile allocation IE is present
3078 * in the message itself.
3079 */
3080 if(!ctrl_create_freq_list_cbch(cbch_req,
3081 freq_par,
3082 &freq_par->di_encod1.gprs_ms_alloc_ie,
3083 0))
3084 {
3085 TRACE_EVENT("Failed to create freq list for cbch");
3086 return FALSE;
3087 }
3088 cbch_req->maio = freq_par->di_encod1.maio;
3089
3090 } /* if(freq_par->v_di_encod1) */
3091 else if(freq_par->v_di_encod2)
3092 {
3093 /* processing of T_freq_par from assignment and non-assignment messages
3094 * when direct encoding 2 is used, should be done in same object module as
3095 * this involvs use of temporary static array variables which are local to the
3096 * object module they are used in(_local_dummy_list and _local_rfl_contents).
3097 * Hence processing for both assignment and non-assignement messages is done
3098 * in grr_f.c. If they are put in different files, we will have to duplicate
3099 * the temporary static arrays.
3100 */
3101 result = grr_cnv_freq_para_in_psi8_direct_enc_2(cbch_req,freq_par);
3102
3103 } /* if(freq_par->v_di_encod2) */
3104 else
3105 {
3106 TRACE_ERROR("FATAL ERROR: no frequency params in cbch description.");
3107 }
3108
3109 return (result);
3110 }/* ctrl_fill_cbch_hopping_params */
3111 #endif
3112