FreeCalypso > hg > freecalypso-citrine
comparison g23m-gsm/alr/alr_main.c @ 0:75a11d740a02
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 09 Jun 2016 00:02:41 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:75a11d740a02 |
---|---|
1 /* | |
2 +----------------------------------------------------------------------------- | |
3 | Project : GSM-PS | |
4 | Modul : ALR_MAIN | |
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 Modul defines the functions for the SDL process | |
18 | Main_Control of the ALR functionality. | |
19 +----------------------------------------------------------------------------- | |
20 */ | |
21 | |
22 #ifndef ALR_MAIN_C | |
23 #define ALR_MAIN_C | |
24 | |
25 #include "config.h" | |
26 #include "fixedconf.h" | |
27 #include "condat-features.h" | |
28 | |
29 #define ENTITY_PL | |
30 | |
31 /*==== INCLUDES ===================================================*/ | |
32 #include <string.h> | |
33 #include <stdlib.h> | |
34 #include <ctype.h> | |
35 #include "typedefs.h" | |
36 #include "message.h" | |
37 #include "ccdapi.h" | |
38 #include "vsi.h" | |
39 #include "custom.h" | |
40 #include "gsm.h" | |
41 #include "prim.h" | |
42 #include "cnf_alr.h" | |
43 #include "mon_alr.h" | |
44 #include "pei.h" | |
45 #include "tok.h" | |
46 #include "pcm.h" | |
47 | |
48 #ifdef GPRS | |
49 #include "alr_gprs.h" | |
50 #endif | |
51 | |
52 #if defined (WIN32) | |
53 #define TRACING | |
54 #else | |
55 /* #define TRACING */ | |
56 /* #define DL_TRACE_ENABLED */ | |
57 #endif | |
58 | |
59 #include "alr.h" | |
60 #include "alr_em.h" | |
61 | |
62 #if defined (TRACING) | |
63 #define ALR_TRACE_MAIN(a) ALR_TRACE(a) | |
64 #else | |
65 #define ALR_TRACE_MAIN(a) | |
66 #endif | |
67 | |
68 #if defined (TRACING) | |
69 | |
70 #define ALR_TRACE_MAIN_BSIC_REQ(s) TRACE_EVENT_P1 ("bsic_req state %d",s) | |
71 #define ALR_TRACE_MAIN_RAND_ACC(s,m) TRACE_EVENT_P2 ("con est on for: %d %d times", s, m); | |
72 #define ALR_TRACE_MAIN_SCELL(o,s) TRACE_EVENT_P2 ("SC [%d]->[%d]", o, s) | |
73 #define ALR_TRACE_MAIN_VALID_BLOCK(m) TRACE_EVENT_P1 ("VALID BLOCK %d", m) | |
74 #define ALR_TRACE_MAIN_SI_UNEQ(c) TRACE_EVENT_P1 ("si uneq %d", c) | |
75 #define ALR_TRACE_MAIN_CR(m) TRACE_EVENT_P1 ("VALID BLOCK CR %d",m) | |
76 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
77 #define ALR_TRACE_MAIN_RACH(t) TRACE_EVENT_P1 ("powerclass txpwr %d", t) | |
78 #else | |
79 #define ALR_TRACE_MAIN_RACH(p,t) TRACE_EVENT_P2 ("powerclass gsm %d txpwr %d", p, t) | |
80 #endif | |
81 #define ALR_TRACE_MAIN_POWER_CNF { USHORT i; \ | |
82 TRACE_EVENT_P1 ("power cnf: %d channels", mph_power_cnf->num_of_chan)\ | |
83 for (i = 0; i < mph_power_cnf->num_of_chan; i++) { \ | |
84 TRACE_EVENT_P2 ("rx_lev[%4d]= %d", \ | |
85 mph_power_cnf->arfcn[i]&ARFCN_MASK, \ | |
86 mph_power_cnf->rx_lev[i]);} } | |
87 #define ALR_TRACE_MAIN_RA_CNF(t1,t2,t3) TRACE_EVENT_P3 ("af: %d %d %d", t1,t2,t3) | |
88 | |
89 #else /* TRACING */ | |
90 | |
91 #define ALR_TRACE_MAIN_BSIC_REQ(s) | |
92 #define ALR_TRACE_MAIN_RAND_ACC(s,m) | |
93 #define ALR_TRACE_MAIN_SCELL(o,s) | |
94 #define ALR_TRACE_MAIN_VALID_BLOCK(m) | |
95 #define ALR_TRACE_MAIN_SI_UNEQ(c) | |
96 #define ALR_TRACE_MAIN_CR(m) | |
97 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
98 #define ALR_TRACE_MAIN_RACH(t) | |
99 #else | |
100 #define ALR_TRACE_MAIN_RACH(p,t) | |
101 #endif | |
102 #define ALR_TRACE_MAIN_POWER_CNF | |
103 #define ALR_TRACE_MAIN_RA_CNF(t1,t2,t3) | |
104 | |
105 #endif /* TRACING */ | |
106 | |
107 /*==== EXPORT =====================================================*/ | |
108 | |
109 /*==== PRIVAT =====================================================*/ | |
110 | |
111 /*==== VARIABLES ==================================================*/ | |
112 LOCAL UBYTE from_dedicated = FALSE; | |
113 | |
114 /*==== FUNCTIONS ==================================================*/ | |
115 | |
116 LOCAL BOOL ma_compare_dedi_sys_buffer (T_MPHC_DATA_IND *mphc_data_ind, | |
117 UBYTE msg_t); | |
118 LOCAL void ma_fill_dedi_sys_buffer (T_MPHC_DATA_IND *mphc_data_ind, | |
119 UBYTE msg_t); | |
120 LOCAL void ma_stop_rxlev_periodic_req (void); | |
121 LOCAL BOOL ma_compare_sys_buffer (T_MPHC_DATA_IND *mphc_data_ind, | |
122 UBYTE msg_t); | |
123 LOCAL void ma_send_dedi_unitdata (T_MPHC_DATA_IND *data_ind); | |
124 LOCAL void ma_sync_ind (UBYTE cause, USHORT arfcn); | |
125 LOCAL void ma_set_si_bitmap (UBYTE msg_t); | |
126 LOCAL void ma_fill_sys_buffer (T_MPHC_DATA_IND *data_ind, UBYTE msg_t); | |
127 LOCAL void ma_dedi_data_out (T_PH_DATA_IND *data_ind); | |
128 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
129 LOCAL void compare_l1_frequency_band_with_ffs (T_MPHC_INIT_L1_CON *init_l1_cnf); | |
130 #endif | |
131 | |
132 /* | |
133 +--------------------------------------------------------------------+ | |
134 | PROJECT : GSM-PS (6103) MODULE : ALR_CS | | |
135 | STATE : code ROUTINE : ma_init | | |
136 +--------------------------------------------------------------------+ | |
137 | |
138 PURPOSE : Initialize Main Control. | |
139 | |
140 */ | |
141 | |
142 GLOBAL void ma_init (void) | |
143 { | |
144 GET_INSTANCE_DATA; | |
145 memset (alr_data, 0, sizeof (T_ALR_DATA)); | |
146 alr_data->state[STATE_MA] = MA_NULL; | |
147 | |
148 alr_data->mmi = 2; /* EVA 4 Board */ | |
149 alr_data->keypad = 2; /* EVA 4 Board */ | |
150 alr_data->ext_display = FALSE; /* internal display */ | |
151 alr_data->pch_data.last_start_ccch_req.bs_pa_mfrms = NOT_PRESENT_8BIT; | |
152 ma_clean_sys_buffer (IND_ALL_SI); | |
153 ma_clean_dedi_sys_buffer (); | |
154 } | |
155 | |
156 /* | |
157 +--------------------------------------------------------------------+ | |
158 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
159 | STATE : code ROUTINE : ma_mph_idle_req | | |
160 +--------------------------------------------------------------------+ | |
161 | |
162 PURPOSE : Process the primitive MPH_IDLE_REQ. | |
163 | |
164 */ | |
165 | |
166 UBYTE v_eotd = 0; /* for test automation */ | |
167 | |
168 GLOBAL void ma_mph_idle_req (T_MPH_IDLE_REQ* idle) | |
169 { | |
170 GET_INSTANCE_DATA; | |
171 if(idle->mod EQ MODE_CELL_SELECTION) | |
172 { | |
173 alr_data->nc_data.eotd_avail = idle->eotd_avail | v_eotd; | |
174 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
175 if(idle->si2quater_status EQ SI2QUATER_CONFIGURE) | |
176 { | |
177 alr_data->nc_data.si2quater_status = SI2QUATER_CONFIGURE; | |
178 alr_data->nc_data.si2quater_pos = idle->si2quater_pos; | |
179 } | |
180 else if(idle->si2quater_status EQ SI2QUATER_ABSENT ) | |
181 { | |
182 alr_data->nc_data.si2quater_status = SI2QUATER_ABSENT; | |
183 } | |
184 alr_data->nc_data.si2_count = NOT_PRESENT_8BIT; | |
185 #endif | |
186 } | |
187 | |
188 switch (GET_STATE (STATE_MA)) | |
189 { | |
190 case MA_DEDICATED: | |
191 ALR_TRACE_MAIN ("leave dedi"); | |
192 ma_stop_active_procs(DONT_STOP_PCH_READING); | |
193 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
194 nc_new_serving_cell (idle->arfcn); | |
195 | |
196 switch(idle->mod) | |
197 { | |
198 case MODE_CELL_RESELECTION: | |
199 ALR_TRACE_MAIN ("CR"); | |
200 trc_state_transition(__LINE__, MA_CELL_RESELECTION); | |
201 SET_STATE (STATE_MA, MA_CELL_RESELECTION); | |
202 #ifdef GPRS | |
203 /* | |
204 * if going to a PBCCH cell we have to update the | |
205 * ncell states with GRR | |
206 */ | |
207 gprs_alr_init(); | |
208 alr_data->nc_sync_with_grr = TRUE; | |
209 #endif | |
210 from_dedicated = TRUE; | |
211 rach_init (); | |
212 rach_configure_power (idle->power); | |
213 pch_configure (idle, PGM_REORG); | |
214 pch_save_pgm(PGM_REORG_CS); /* reset saved pgm to REORG_CS */ | |
215 nc_suspend (); /* to set the nc state */ | |
216 nc_start_reselect (idle->arfcn); | |
217 break; | |
218 case MODE_CELL_SELECTION: | |
219 ALR_TRACE_MAIN ("CS"); | |
220 if (idle->arfcn NEQ alr_data->old_serving_cell) | |
221 { | |
222 ALR_TRACE_MAIN ("CS but different cell!!!"); | |
223 } | |
224 trc_state_transition(__LINE__, MA_IDLE); | |
225 SET_STATE(STATE_MA, MA_IDLE); | |
226 nc_suspend(); /* stop dedicated mode activity */ | |
227 nc_add_offset(); | |
228 #ifdef GPRS | |
229 set_gprs_support(idle->gprs_support); | |
230 #endif | |
231 pch_configure (idle, SAVED_PGM); | |
232 pch_start_ccch_req(); | |
233 cb_start(); | |
234 | |
235 nc_start_monitoring(); | |
236 break; | |
237 #ifdef GPRS | |
238 case MODE_CONFIG_PL: /* Cell has PBCCH */ | |
239 ma_stop_active_procs(STOP_PCH_READING); | |
240 nc_suspend(); /* stop dedicated mode activity */ | |
241 gprs_alr_init(); | |
242 set_gprs_support(idle->gprs_support); | |
243 alr_data->nc_sync_with_grr = TRUE; | |
244 alr_data->gprs_data.pbcch = TRUE; | |
245 nc_add_offset(); /* convert counters */ | |
246 | |
247 rach_init (); | |
248 rach_configure_power (idle->power); | |
249 pch_configure (idle, PGM_NORMAL); | |
250 alr_data->nc_sync_with_grr = TRUE; | |
251 SET_STATE(STATE_MA, MA_IDLE); | |
252 break; | |
253 #endif | |
254 default: | |
255 break; | |
256 } | |
257 break; | |
258 case MA_CON_EST: | |
259 #ifdef GPRS | |
260 if(idle->mod EQ MODE_PACKET_TRANSFER) /* transition to PTM */ | |
261 { /* | |
262 * NC BCCH reading doesn't need to be stopped, because it has | |
263 * already been stopped when entering MA_CON_EST | |
264 */ | |
265 ma_stop_active_procs(STOP_PCH_READING); | |
266 SET_STATE (STATE_MA, MA_PTM); | |
267 } | |
268 else | |
269 { | |
270 #endif /* GPRS */ | |
271 ma_stop_active_procs(DONT_STOP_PCH_READING); | |
272 rach_configure_power (idle->power); | |
273 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
274 nc_new_serving_cell (idle->arfcn); | |
275 #ifdef GPRS | |
276 if(idle->mod EQ MODE_CONFIG_PL) | |
277 { | |
278 ma_stop_active_procs(STOP_PCH_READING); | |
279 gprs_alr_init(); | |
280 set_gprs_support(idle->gprs_support); | |
281 alr_data->gprs_data.pbcch = TRUE; | |
282 alr_data->nc_sync_with_grr = TRUE; | |
283 rach_init (); | |
284 rach_configure_power (idle->power); | |
285 pch_configure (idle, PGM_NORMAL); | |
286 SET_STATE(STATE_MA, MA_IDLE); | |
287 } | |
288 else | |
289 { | |
290 #endif | |
291 if (idle->arfcn EQ alr_data->old_serving_cell) | |
292 { | |
293 /* coming back after RACH failure */ | |
294 trc_state_transition(__LINE__, MA_IDLE); | |
295 SET_STATE (STATE_MA, MA_IDLE); | |
296 #ifdef GPRS | |
297 set_gprs_support(idle->gprs_support); | |
298 #endif | |
299 pch_configure (idle, SAVED_PGM); | |
300 pch_start_ccch_req(); | |
301 cb_start(); | |
302 nc_start_monitoring(); | |
303 } | |
304 else | |
305 { | |
306 trc_state_transition(__LINE__, MA_CELL_RESELECTION); | |
307 SET_STATE (STATE_MA, MA_CELL_RESELECTION); | |
308 #ifdef GPRS | |
309 /* | |
310 * if going to a PBCCH cell we have to update the | |
311 * ncell states with GRR | |
312 */ | |
313 gprs_alr_init(); | |
314 alr_data->nc_sync_with_grr = TRUE; | |
315 #endif | |
316 pch_configure (idle, PGM_REORG); | |
317 pch_save_pgm(PGM_REORG_CS); /* reset saved pgm to REORG_CS */ | |
318 nc_start_reselect (idle->arfcn); | |
319 } | |
320 #ifdef GPRS | |
321 } | |
322 } | |
323 #endif | |
324 break; | |
325 case MA_CELL_SELECTION: | |
326 TRACE_EVENT_P1 ("SC[%u] in use, leave CS", idle->arfcn); | |
327 | |
328 #ifdef GPRS | |
329 if(idle->mod EQ MODE_CONFIG_PL) | |
330 { | |
331 ma_stop_active_procs(STOP_PCH_READING); | |
332 gprs_alr_init(); | |
333 set_gprs_support(idle->gprs_support); | |
334 alr_data->gprs_data.pbcch = TRUE; | |
335 alr_data->nc_sync_with_grr = TRUE; | |
336 rach_init (); | |
337 rach_configure_power (idle->power); | |
338 nc_new_serving_cell (idle->arfcn); | |
339 pch_configure (idle, PGM_NORMAL); | |
340 SET_STATE(STATE_MA, MA_IDLE); | |
341 break; | |
342 } | |
343 #endif | |
344 | |
345 ALR_EM_CONFIGURE_IDLE_MODE; | |
346 | |
347 ma_stop_active_procs(DONT_STOP_PCH_READING); | |
348 | |
349 trc_state_transition(__LINE__, MA_IDLE); | |
350 SET_STATE (STATE_MA, MA_IDLE); | |
351 #ifdef GPRS | |
352 alr_data->nc_sync_with_grr=FALSE; | |
353 set_gprs_support(idle->gprs_support); | |
354 #endif | |
355 rach_configure_power (idle->power); | |
356 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
357 nc_check_new_ncc_permitted (idle->ncc_permitted); | |
358 nc_new_serving_cell (idle->arfcn); | |
359 pch_configure (idle, PGM_REORG_CS); | |
360 pch_save_pgm(0); /* reset saved pgm to REORG_CS */ | |
361 pch_start_ccch_req(); | |
362 /* | |
363 * nc_start_monitoring will be called when ncell list from RR | |
364 * is received | |
365 */ | |
366 break; | |
367 | |
368 case MA_IDLE: | |
369 switch (idle->mod) | |
370 { | |
371 #ifdef GPRS | |
372 case MODE_PACKET_TRANSFER: /* transition to PTM */ | |
373 /*NC BCCH reading will be stopped when leaving idle*/ | |
374 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); | |
375 SET_STATE (STATE_MA, MA_PTM); | |
376 break; | |
377 case MODE_CONFIG_PL: | |
378 ma_stop_active_procs(STOP_PCH_READING|STOP_MEASUREMENTS); | |
379 gprs_alr_init(); | |
380 set_gprs_support(idle->gprs_support); | |
381 /* PBCCH activated in cell */ | |
382 alr_data->nc_sync_with_grr = TRUE; | |
383 alr_data->gprs_data.pbcch = TRUE; | |
384 rach_init (); | |
385 rach_configure_power (idle->power); | |
386 pch_configure (idle, PGM_NORMAL); | |
387 SET_STATE(STATE_MA, MA_IDLE); | |
388 break; | |
389 #endif /* GPRS */ | |
390 | |
391 case MODE_CELL_RESELECTION: | |
392 ALR_TRACE_MAIN ("idle mode cr"); | |
393 | |
394 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); | |
395 | |
396 trc_state_transition(__LINE__, MA_CELL_RESELECTION); | |
397 SET_STATE (STATE_MA, MA_CELL_RESELECTION); | |
398 #ifdef GPRS | |
399 /* | |
400 * if going to a PBCCH cell we have to update the | |
401 * ncell states with GRR | |
402 */ | |
403 gprs_alr_init(); | |
404 alr_data->nc_sync_with_grr = TRUE; | |
405 #endif | |
406 rach_init (); | |
407 rach_configure_power (idle->power); | |
408 TRACE_EVENT("IDLE_REQ : Cell found after CR"); | |
409 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
410 // nc_check_new_ncc_permitted(idle->ncc_permitted); | |
411 nc_new_serving_cell (idle->arfcn); | |
412 pch_configure (idle, PGM_REORG); | |
413 pch_save_pgm(PGM_REORG_CS); /* reset saved pgm to REORG_CS */ | |
414 nc_start_reselect (idle->arfcn); | |
415 break; | |
416 #ifdef GPRS | |
417 case MODE_CELL_RESELECTION_SYNC_ONLY: | |
418 if(alr_data->gprs_data.pbcch) | |
419 { | |
420 alr_data->gprs_data.sync_only=1; | |
421 alr_data->gprs_data.ptm=0; | |
422 ma_stop_active_procs(STOP_PCH_READING); | |
423 trc_state_transition(__LINE__, MA_CELL_RESELECTION); | |
424 SET_STATE (STATE_MA, MA_CELL_RESELECTION); | |
425 nc_new_serving_cell (idle->arfcn); | |
426 nc_start_reselect (idle->arfcn); | |
427 } | |
428 break; | |
429 #endif | |
430 case MODE_SYS_INFO_CHANGE: | |
431 ALR_TRACE_MAIN ("idle mode sys info changed"); | |
432 rach_init (); | |
433 rach_configure_power (idle->power); | |
434 | |
435 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
436 nc_check_new_ncc_permitted (idle->ncc_permitted); | |
437 | |
438 if((idle->tn/2) NEQ | |
439 (alr_data->pch_data.pl_idle.ccch_group) | |
440 #ifdef GPRS | |
441 OR alr_data->gprs_data.pbcch | |
442 #endif | |
443 ) | |
444 { | |
445 /* stop CCCH reading beforehand */ | |
446 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); | |
447 #ifdef GPRS | |
448 gprs_alr_init(); | |
449 set_gprs_support(idle->gprs_support); | |
450 #endif | |
451 pch_configure (idle, PGM_REORG_CS); | |
452 pch_save_pgm(PGM_REORG_CS); /* reset saved pgm to REORG_CS */ | |
453 pch_start_ccch_req(); | |
454 | |
455 nc_start_monitoring (); | |
456 } | |
457 else | |
458 { | |
459 #ifdef GPRS | |
460 if(idle->reorg_only EQ NORMAL_PGM AND | |
461 alr_data->gprs_data.ign_pgm EQ TRUE) | |
462 { | |
463 /* | |
464 * use last page mode read on PCH | |
465 * when the NON_DRX_TIMER has expired | |
466 */ | |
467 pch_configure (idle, SAVED_PGM); | |
468 pch_start_ccch_req(); | |
469 alr_data->gprs_data.ign_pgm = FALSE; | |
470 } | |
471 else if(alr_data->gprs_data.ign_pgm EQ FALSE) | |
472 { | |
473 set_gprs_support(idle->gprs_support); | |
474 if(gprs_alr_is_supported()) | |
475 { | |
476 gprs_alr_init(); | |
477 set_gprs_support(idle->gprs_support); | |
478 ma_stop_scell_bcch_req(); | |
479 } | |
480 #endif | |
481 pch_save_pgm(0); /* save current pgm */ | |
482 pch_configure (idle, SAVED_PGM); | |
483 pch_start_ccch_req(); | |
484 #ifdef GPRS | |
485 } | |
486 /* other case should not happen */ | |
487 #endif | |
488 | |
489 } | |
490 break; | |
491 case MODE_CELL_SELECTION: | |
492 /* XXX does not seem to be used by RR*/ | |
493 break; | |
494 default: | |
495 break; | |
496 } | |
497 break; | |
498 case MA_CELL_RESELECTION: | |
499 switch(idle->mod) | |
500 { | |
501 case MODE_CELL_SELECTION: | |
502 | |
503 ALR_TRACE_MAIN ("from cr use cell"); | |
504 /* we have found a suitable cell */ | |
505 ma_stop_active_procs(DONT_STOP_PCH_READING); | |
506 rach_init (); | |
507 rach_configure_power (idle->power); | |
508 TRACE_EVENT("IDLE_REQ : PM config after CR"); | |
509 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
510 nc_check_new_ncc_permitted (idle->ncc_permitted); | |
511 if (from_dedicated) | |
512 { | |
513 from_dedicated = FALSE; | |
514 nc_add_offset (); | |
515 } | |
516 pch_configure (idle, SAVED_PGM); | |
517 | |
518 /* | |
519 * For OMAPS#90692 - Move to MA_IDLE before configuring | |
520 * the serving cell BCCH request, so as not to reset the | |
521 * si_bitmap again | |
522 */ | |
523 trc_state_transition(__LINE__, MA_IDLE); | |
524 SET_STATE (STATE_MA, MA_IDLE); | |
525 pch_start_ccch_req(); | |
526 #ifdef GPRS | |
527 alr_data->nc_sync_with_grr=FALSE; | |
528 set_gprs_support(idle->gprs_support); | |
529 #endif | |
530 | |
531 /* | |
532 * resume neighbourcell operation | |
533 */ | |
534 nc_start_monitoring (); | |
535 break; | |
536 case MODE_CELL_RESELECTION: | |
537 /* the last cell wasn't the right one, try again */ | |
538 ma_stop_active_procs(STOP_PCH_READING); | |
539 /* don't forget to stop all processes */ | |
540 #ifdef GPRS | |
541 gprs_alr_init(); | |
542 #endif | |
543 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
544 // nc_check_new_ncc_permitted (idle->ncc_permitted); | |
545 nc_new_serving_cell (idle->arfcn); | |
546 pch_configure (idle, PGM_REORG); | |
547 pch_save_pgm(PGM_REORG_CS); /* reset saved pgm to REORG_CS */ | |
548 nc_start_reselect (idle->arfcn); | |
549 break; | |
550 #ifdef GPRS | |
551 case MODE_CONFIG_PL: | |
552 ma_stop_active_procs(STOP_PCH_READING); | |
553 if (from_dedicated) from_dedicated = FALSE; | |
554 | |
555 gprs_alr_init(); | |
556 set_gprs_support(idle->gprs_support); | |
557 alr_data->gprs_data.pbcch = TRUE; | |
558 alr_data->nc_sync_with_grr = TRUE; | |
559 rach_init (); | |
560 rach_configure_power (idle->power); | |
561 pch_configure (idle, PGM_NORMAL); | |
562 SET_STATE(STATE_MA, MA_IDLE); | |
563 break; | |
564 #endif | |
565 default: | |
566 break; | |
567 } | |
568 break; | |
569 #ifdef GPRS | |
570 case MA_PTM: | |
571 /* back to packet idle */ | |
572 ma_stop_active_procs(DONT_STOP_PCH_READING); | |
573 rach_configure_power (idle->power); | |
574 alr_data->bs_pa_mfrms = idle->bs_pa_mfrms; | |
575 nc_new_serving_cell (idle->arfcn); | |
576 nc_suspend(); | |
577 if (idle->arfcn EQ alr_data->old_serving_cell) | |
578 { | |
579 trc_state_transition(__LINE__, MA_IDLE); | |
580 SET_STATE(STATE_MA, MA_IDLE); | |
581 #ifdef GPRS | |
582 set_gprs_support(idle->gprs_support); | |
583 #endif | |
584 | |
585 if(idle->reorg_only EQ REORG_ONLY) | |
586 { | |
587 pch_configure (idle, PGM_REORG_CS); | |
588 alr_data->gprs_data.ign_pgm = TRUE; | |
589 } | |
590 else | |
591 { | |
592 pch_configure (idle, SAVED_PGM); | |
593 alr_data->gprs_data.ign_pgm = FALSE; | |
594 } | |
595 pch_start_ccch_req(); | |
596 cb_start(); | |
597 nc_start_monitoring(); | |
598 } | |
599 else | |
600 { | |
601 trc_state_transition(__LINE__, MA_CELL_RESELECTION); | |
602 SET_STATE (STATE_MA, MA_CELL_RESELECTION); | |
603 #ifdef GPRS | |
604 /* | |
605 * if going to a PBCCH cell we have to update the | |
606 * ncell states with GRR | |
607 */ | |
608 gprs_alr_init(); | |
609 alr_data->nc_sync_with_grr = TRUE; | |
610 #endif | |
611 pch_configure (idle, PGM_REORG); | |
612 pch_save_pgm(PGM_REORG_CS); /* reset saved pgm to REORG_CS */ | |
613 nc_start_reselect (idle->arfcn); | |
614 } | |
615 break; | |
616 #endif | |
617 default: | |
618 break; | |
619 } | |
620 PFREE (idle); | |
621 } | |
622 | |
623 | |
624 /* | |
625 +--------------------------------------------------------------------+ | |
626 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
627 | STATE : code ROUTINE : ma_mph_neighbourcell_req | | |
628 +--------------------------------------------------------------------+ | |
629 | |
630 PURPOSE : Process the primitive MPH_NEIGHBOURCELL_REQ. | |
631 | |
632 */ | |
633 | |
634 GLOBAL void ma_mph_neighbourcell_req (T_MPH_NEIGHBOURCELL_REQ* mph_neighbourcell_req) | |
635 { | |
636 GET_INSTANCE_DATA; | |
637 | |
638 switch (GET_STATE (STATE_MA)) | |
639 { | |
640 case MA_IDLE: | |
641 case MA_DEDICATED: | |
642 nc_ncell_list (mph_neighbourcell_req); | |
643 | |
644 ALR_EM_CONFIGURE_NEIGHBOUERCELL_LIST; | |
645 | |
646 break; | |
647 #ifdef GPRS | |
648 case MA_PTM: | |
649 /*In PTM just update the BA list. No need to start monitoring at L1 through MPHC*/ | |
650 /* | |
651 * mix new list with old list | |
652 */ | |
653 nc_update_ba_list (alr_data->serving_cell, mph_neighbourcell_req); | |
654 break; | |
655 #endif | |
656 | |
657 default: | |
658 break; | |
659 } | |
660 PFREE (mph_neighbourcell_req); | |
661 } | |
662 | |
663 | |
664 /* | |
665 +--------------------------------------------------------------------+ | |
666 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
667 | STATE : code ROUTINE : ma_mph_dedicated_req | | |
668 +--------------------------------------------------------------------+ | |
669 | |
670 PURPOSE : Process the primitive MPH_DEDICATED_REQ. | |
671 | |
672 */ | |
673 | |
674 GLOBAL void ma_mph_dedicated_req (T_MPH_DEDICATED_REQ* dedi) | |
675 { | |
676 GET_INSTANCE_DATA; | |
677 switch (GET_STATE (STATE_MA)) | |
678 { | |
679 case MA_CON_EST: | |
680 ALR_TRACE_MAIN ("dedi on"); | |
681 | |
682 ma_stop_active_procs (STOP_PCH_READING); | |
683 trc_state_transition(__LINE__, MA_DEDICATED); | |
684 SET_STATE (STATE_MA, MA_DEDICATED); | |
685 dedi_req (dedi); | |
686 ma_clean_dedi_sys_buffer (); | |
687 nc_start_dedicated (dedi->tr_para.pwrc, dedi->tr_para.dtx); | |
688 break; | |
689 | |
690 case MA_DEDICATED: | |
691 dedi_req (dedi); | |
692 break; | |
693 | |
694 default: | |
695 break; | |
696 } | |
697 PFREE (dedi); | |
698 } | |
699 | |
700 | |
701 /* | |
702 +--------------------------------------------------------------------+ | |
703 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
704 | STATE : code ROUTINE : ma_mph_dedicated_fail_req | | |
705 +--------------------------------------------------------------------+ | |
706 | |
707 PURPOSE : Process the primitive MPH_DEDICATED_FAIL_REQ. | |
708 | |
709 */ | |
710 | |
711 GLOBAL void ma_mph_dedicated_fail_req (T_MPH_DEDICATED_FAIL_REQ* mph_dedicated_fail_req) | |
712 { | |
713 dedi_fail_req (); | |
714 PFREE (mph_dedicated_fail_req); | |
715 } | |
716 | |
717 | |
718 /* | |
719 +--------------------------------------------------------------------+ | |
720 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
721 | STATE : code ROUTINE : ma_mph_ciphering_req | | |
722 +--------------------------------------------------------------------+ | |
723 | |
724 PURPOSE : Process the primitive MPH_CIPHERING_REQ. | |
725 | |
726 */ | |
727 | |
728 GLOBAL void ma_mph_ciphering_req (T_MPH_CIPHERING_REQ* mph_ciphering_req) | |
729 { | |
730 dedi_ciph_req (mph_ciphering_req); | |
731 PFREE(mph_ciphering_req); | |
732 } | |
733 | |
734 /* | |
735 +--------------------------------------------------------------------+ | |
736 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
737 | STATE : code ROUTINE : ma_mph_freq_redef_req | | |
738 +--------------------------------------------------------------------+ | |
739 | |
740 PURPOSE : Process the primitive MPH_FREQ_REDEF_REQ. | |
741 | |
742 */ | |
743 | |
744 GLOBAL void ma_mph_freq_redef_req (T_MPH_FREQ_REDEF_REQ* mph_freq_redef_req) | |
745 { | |
746 dedi_freq_redef_req(mph_freq_redef_req); | |
747 PFREE(mph_freq_redef_req); | |
748 } | |
749 | |
750 /* | |
751 +--------------------------------------------------------------------+ | |
752 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
753 | STATE : code ROUTINE : ma_mph_channel_mode_req | | |
754 +--------------------------------------------------------------------+ | |
755 | |
756 PURPOSE : Process the primitive MPH_CHANNEL_MODE_REQ. | |
757 | |
758 */ | |
759 | |
760 GLOBAL void ma_mph_channel_mode_req (T_MPH_CHANNEL_MODE_REQ* mph_channel_mode_req) | |
761 { | |
762 dedi_chan_mode_req (mph_channel_mode_req); | |
763 PFREE(mph_channel_mode_req); | |
764 } | |
765 | |
766 | |
767 /* | |
768 +--------------------------------------------------------------------+ | |
769 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
770 | STATE : code ROUTINE : ma_mph_deactivate_req | | |
771 +--------------------------------------------------------------------+ | |
772 | |
773 PURPOSE : Process the primitive MPH_DEACTIVATE_REQ. | |
774 | |
775 */ | |
776 | |
777 GLOBAL void ma_mph_deactivate_req (T_MPH_DEACTIVATE_REQ* mph_deactivate_req) | |
778 { | |
779 GET_INSTANCE_DATA; | |
780 UBYTE flags = 0; | |
781 PREUSE (mph_deactivate_req, mphc_deactivate_req, MPHC_DEACTIVATE_REQ); | |
782 | |
783 if (alr_data->pch_data.last_start_ccch_req.bs_pa_mfrms NEQ NOT_PRESENT_8BIT) | |
784 flags |= STOP_PCH_READING; | |
785 | |
786 switch (GET_STATE(STATE_MA)) | |
787 { | |
788 case MA_CELL_SELECTION: | |
789 case MA_CELL_RESELECTION: | |
790 case MA_CON_EST: | |
791 case MA_DEDICATED: | |
792 #ifdef GPRS | |
793 case MA_PTM: | |
794 #endif | |
795 break; | |
796 case MA_IDLE: | |
797 #ifdef GPRS | |
798 if (alr_data->gprs_data.pbcch EQ TRUE) | |
799 break; | |
800 #endif | |
801 /*lint -fallthrough*/ | |
802 default: | |
803 flags |= STOP_MEASUREMENTS; | |
804 break; | |
805 } | |
806 | |
807 ma_stop_active_procs(flags); | |
808 | |
809 ALR_EM_DEACTIVATE_L1; | |
810 | |
811 /* | |
812 * There is no activation request for ALR. Therefore ALR is prepared | |
813 * here for the next powering on by stopping really all running processes | |
814 * and reinitialising the state variables. | |
815 */ | |
816 nc_stop (); | |
817 | |
818 cb_init (); | |
819 cs_init (); | |
820 pch_init (); | |
821 dedi_init (); | |
822 SET_STATE(STATE_MA, MA_NULL); /* it isn't clear whether the whole ma_init() should be performed */ | |
823 ma_clean_sys_buffer (IND_ALL_SI); | |
824 ma_clean_dedi_sys_buffer (); | |
825 | |
826 PSENDX(L1, mphc_deactivate_req); | |
827 } | |
828 | |
829 | |
830 /* | |
831 +--------------------------------------------------------------------+ | |
832 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
833 | STATE : code ROUTINE : ma_mph_classmark_req | | |
834 +--------------------------------------------------------------------+ | |
835 | |
836 PURPOSE : Process the primitive MPH_CLASSMARK_REQ. | |
837 | |
838 */ | |
839 | |
840 GLOBAL void ma_mph_classmark_req (T_MPH_CLASSMARK_REQ* classmark) | |
841 { | |
842 rach_configure_class (classmark->classmark.pclass, | |
843 classmark->classmark.pclass2); | |
844 | |
845 ALR_EM_CONFIGURE_CLASSMARK; | |
846 | |
847 PFREE (classmark); | |
848 } | |
849 | |
850 | |
851 /* | |
852 +--------------------------------------------------------------------+ | |
853 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
854 | STATE : code ROUTINE : ma_mph_ext_meas_req | | |
855 +--------------------------------------------------------------------+ | |
856 | |
857 PURPOSE : Process the primitive MPH_EXT_MEAS_REQ. | |
858 | |
859 */ | |
860 | |
861 GLOBAL void ma_mph_ext_meas_req (T_MPH_EXT_MEAS_REQ* mph_ext_meas_req) | |
862 { | |
863 GET_INSTANCE_DATA; | |
864 /* Process CS must be state CS_NULL (no Cell Selection active) */ | |
865 | |
866 if ( GET_STATE ( STATE_CS ) EQ CS_NULL ) | |
867 { | |
868 mph_ext_meas_req->pch_interrupt = NO_PCH_INTERRUPT; | |
869 | |
870 /* alr_data->cs_data.mph_ext_meas_req must be NULL */ | |
871 | |
872 if ( IS_EXT_MEAS_RUNNING ) /*alr_data->cs_data.mph_ext_meas_req NEQ NULL*/ | |
873 { | |
874 PFREE ( alr_data->cs_data.mph_ext_meas_req ); | |
875 } | |
876 alr_data->cs_data.mph_ext_meas_req = mph_ext_meas_req; | |
877 alr_data->cs_data.ext_meas_state_pend = CS_NULL; | |
878 | |
879 ma_mph_power_req((T_MPH_POWER_REQ*) mph_ext_meas_req); | |
880 } | |
881 else | |
882 { | |
883 PALLOC ( mph_ext_meas_cnf, MPH_EXT_MEAS_CNF ); | |
884 mph_ext_meas_cnf->num_of_chan = 0; | |
885 PSENDX ( RR, mph_ext_meas_cnf ); | |
886 | |
887 PFREE (mph_ext_meas_req); | |
888 } | |
889 } | |
890 | |
891 /* | |
892 +--------------------------------------------------------------------+ | |
893 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
894 | STATE : code ROUTINE : ma_mph_tch_loop_req | | |
895 +--------------------------------------------------------------------+ | |
896 | |
897 PURPOSE : Process the primitive MPH_TCH_LOOP_REQ. | |
898 | |
899 */ | |
900 | |
901 GLOBAL void ma_mph_tch_loop_req (T_MPH_TCH_LOOP_REQ* mph_tch_loop_req) | |
902 { | |
903 dedi_tch_loop_req (mph_tch_loop_req); | |
904 PFREE(mph_tch_loop_req); | |
905 } | |
906 | |
907 | |
908 /* | |
909 +--------------------------------------------------------------------+ | |
910 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
911 | STATE : code ROUTINE : ma_mph_dai_req | | |
912 +--------------------------------------------------------------------+ | |
913 | |
914 PURPOSE : Process the primitive MPH_DAI_REQ. | |
915 | |
916 */ | |
917 | |
918 GLOBAL void ma_mph_dai_req (T_MPH_DAI_REQ* mph_dai_req) | |
919 { | |
920 dedi_dai_req (mph_dai_req); | |
921 PFREE(mph_dai_req); | |
922 } | |
923 | |
924 /* | |
925 +--------------------------------------------------------------------+ | |
926 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
927 | STATE : code ROUTINE : ma_mph_cbch_req | | |
928 +--------------------------------------------------------------------+ | |
929 | |
930 PURPOSE : Process the primitive MPH_CBCH_REQ. | |
931 | |
932 */ | |
933 | |
934 | |
935 GLOBAL void ma_mph_cbch_req (T_MPH_CBCH_REQ* cbch_req) | |
936 { | |
937 cb_mph_cbch_req( &cbch_req->cbch); | |
938 PFREE (cbch_req); | |
939 } | |
940 | |
941 /* | |
942 +--------------------------------------------------------------------+ | |
943 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
944 | STATE : code ROUTINE : ma_mph_identity_req | | |
945 +--------------------------------------------------------------------+ | |
946 | |
947 PURPOSE : Process the primitive MPH_IDENTITY_REQ. | |
948 | |
949 */ | |
950 | |
951 GLOBAL void ma_mph_identity_req (T_MPH_IDENTITY_REQ* mph_identity_req) | |
952 { | |
953 pch_identity_req (mph_identity_req); | |
954 PFREE (mph_identity_req); | |
955 } | |
956 | |
957 /* | |
958 +--------------------------------------------------------------------+ | |
959 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
960 | STATE : code ROUTINE : ma_mph_sync_req | | |
961 +--------------------------------------------------------------------+ | |
962 | |
963 PURPOSE : Process the primitive MPH_SYNC_REQ. | |
964 | |
965 */ | |
966 | |
967 GLOBAL void ma_mph_sync_req (T_MPH_SYNC_REQ* mph_sync_req) | |
968 { | |
969 GET_INSTANCE_DATA; | |
970 switch (mph_sync_req->cs) | |
971 { | |
972 case CS_CLEAN_SYS_INFO: | |
973 /* | |
974 * clean stored system information messages to force | |
975 * sending to RR. | |
976 */ | |
977 ma_clean_dedi_sys_buffer (); | |
978 break; | |
979 | |
980 case CS_STOP_BCCH_READING: | |
981 switch (GET_STATE (STATE_MA)) | |
982 { | |
983 case MA_CELL_SELECTION: | |
984 cs_stop (); | |
985 break; | |
986 case MA_IDLE: | |
987 nc_stop_rr_activity (FALSE); | |
988 break; | |
989 } | |
990 break; | |
991 | |
992 case CS_STOP_PLMN_SEARCH: | |
993 switch (GET_STATE (STATE_MA)) | |
994 { | |
995 case MA_CELL_SELECTION: | |
996 cs_stop (); | |
997 break; | |
998 case MA_IDLE: | |
999 /* | |
1000 * PLMN search is stopped. If mobile was in REORG before | |
1001 * PLMN search, this is set again after finishing all BCCH reading. | |
1002 */ | |
1003 if(alr_data->pch_data.pl_idle.page_mode EQ PGM_REORG_NC_SYNC) | |
1004 { | |
1005 alr_data->pch_data.pl_idle.page_mode = page_mode_before_hplmn_search; | |
1006 pch_start_ccch_req (); | |
1007 ALR_TRACE_MAIN ("PLMN search complete - REORG reestablished"); | |
1008 } | |
1009 cs_stop (); | |
1010 nc_stop_rr_activity (TRUE); | |
1011 break; | |
1012 } | |
1013 break; | |
1014 case CS_STOP_PLMN_SEARCH_AND_DEACTIVATE: | |
1015 switch (GET_STATE (STATE_MA)) | |
1016 { | |
1017 case MA_CELL_SELECTION: | |
1018 cs_stop (); | |
1019 break; | |
1020 case MA_IDLE: | |
1021 /* | |
1022 * If mobile was in REORG before PLMN search, this is set again after | |
1023 * finishing PLMN search. L1 is not configured, because PCH reading | |
1024 * is stopped anyway | |
1025 */ | |
1026 if(alr_data->pch_data.pl_idle.page_mode EQ PGM_REORG_NC_SYNC) | |
1027 { | |
1028 alr_data->pch_data.pl_idle.page_mode = page_mode_before_hplmn_search; | |
1029 ALR_TRACE_MAIN ("PLMN search complete - REORG reestablished"); | |
1030 } | |
1031 cs_stop (); | |
1032 nc_stop_rr_activity (TRUE); | |
1033 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); | |
1034 break; | |
1035 } | |
1036 { | |
1037 PALLOC(deact_req, MPHC_DEACTIVATE_REQ); | |
1038 PSENDX(L1, deact_req); | |
1039 } | |
1040 break; | |
1041 #ifdef GPRS | |
1042 case CS_START_PCCO: | |
1043 alr_data->gprs_data.pcco_active = TRUE; | |
1044 if ( GET_STATE(STATE_MA) EQ MA_PTM ) | |
1045 { | |
1046 ma_stop_active_procs(STOP_MEASUREMENTS |STOP_PCH_READING); | |
1047 SET_STATE(STATE_MA, MA_IDLE); | |
1048 } | |
1049 break; | |
1050 #endif | |
1051 case CS_RXLEV_VAL_REQ: | |
1052 switch (GET_STATE(STATE_MA)) | |
1053 { | |
1054 #ifdef GPRS | |
1055 case MA_PTM: | |
1056 case MA_IDLE: | |
1057 break; | |
1058 #endif /* GPRS */ | |
1059 case MA_DEDICATED: | |
1060 /* EMO */ | |
1061 break; | |
1062 } | |
1063 break; | |
1064 case CS_SYS_INFO_2BIS_SUPPORT_CHANGED: | |
1065 if((GET_STATE(STATE_MA) EQ MA_IDLE) AND | |
1066 (alr_data->pch_data.pl_idle.page_mode EQ PGM_NORMAL OR | |
1067 alr_data->pch_data.pl_idle.page_mode EQ PGM_EXTENDED) AND | |
1068 (alr_data->pch_data.reorg_bcch_reading EQ FALSE)) | |
1069 { | |
1070 ma_stop_scell_bcch_req (); | |
1071 if(alr_data->cs_data.si_bitmap & SI_2BIS_READ) | |
1072 alr_data->cs_data.si_bitmap &= ~(SI_2BIS_READ); | |
1073 else | |
1074 alr_data->cs_data.si_bitmap |= SI_2BIS_READ; | |
1075 sc_start_periodic(); | |
1076 } | |
1077 break; | |
1078 case CS_SYS_INFO_2TER_SUPPORT_CHANGED: | |
1079 /* Dont start periodic reading if we are in PGM_REORG */ | |
1080 if((GET_STATE(STATE_MA) EQ MA_IDLE) AND | |
1081 (alr_data->pch_data.pl_idle.page_mode EQ PGM_NORMAL OR | |
1082 alr_data->pch_data.pl_idle.page_mode EQ PGM_EXTENDED) AND | |
1083 (alr_data->pch_data.reorg_bcch_reading EQ FALSE)) | |
1084 { | |
1085 ma_stop_scell_bcch_req (); | |
1086 if(alr_data->cs_data.si_bitmap & SI_2TER_READ) | |
1087 alr_data->cs_data.si_bitmap &= ~(SI_2TER_READ); | |
1088 else | |
1089 alr_data->cs_data.si_bitmap |= SI_2TER_READ; | |
1090 sc_start_periodic(); | |
1091 } | |
1092 break; | |
1093 default: | |
1094 break; | |
1095 } | |
1096 | |
1097 PFREE (mph_sync_req); | |
1098 } | |
1099 | |
1100 /* | |
1101 +--------------------------------------------------------------------+ | |
1102 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1103 | STATE : code ROUTINE : ma_mph_clean_buf_req | | |
1104 +--------------------------------------------------------------------+ | |
1105 | |
1106 PURPOSE : Process the primitive MPH_CLEAN_BUF_REQ. | |
1107 | |
1108 */ | |
1109 | |
1110 GLOBAL void ma_mph_clean_buf_req (T_MPH_CLEAN_BUF_REQ* mph_clean_buf_req) | |
1111 { | |
1112 ma_clean_sys_buffer(mph_clean_buf_req->si_to_clean); | |
1113 PFREE(mph_clean_buf_req); | |
1114 } | |
1115 | |
1116 /* | |
1117 +--------------------------------------------------------------------+ | |
1118 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1119 | STATE : code ROUTINE : ma_mph_stop_dedi_req | | |
1120 +--------------------------------------------------------------------+ | |
1121 | |
1122 PURPOSE : Process the primitive MPH_STOP_DEDICATED_REQ. | |
1123 | |
1124 */ | |
1125 GLOBAL void ma_mph_stop_dedi_req(T_MPH_STOP_DEDICATED_REQ *stop_dedi) | |
1126 { | |
1127 dedi_stop(); | |
1128 PFREE(stop_dedi); | |
1129 } | |
1130 | |
1131 /* | |
1132 +--------------------------------------------------------------------+ | |
1133 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1134 | STATE : code ROUTINE : ma_mph_power_req | | |
1135 +--------------------------------------------------------------------+ | |
1136 | |
1137 PURPOSE : Process the primitive MPH_POWER_REQ and MPH_EXT_MEAS_REQ. | |
1138 | |
1139 */ | |
1140 | |
1141 GLOBAL void ma_mph_power_req(T_MPH_POWER_REQ* mph_power_req) | |
1142 { | |
1143 GET_INSTANCE_DATA; | |
1144 if ( D_OPC(mph_power_req) EQ MPH_POWER_REQ && IS_EXT_MEAS_RUNNING ) | |
1145 { | |
1146 PALLOC ( mph_power_cnf, MPH_POWER_CNF ); | |
1147 mph_power_cnf->num_of_chan = 0; | |
1148 PSENDX ( RR, mph_power_cnf ); | |
1149 TRACE_ERROR ( "Cell Sel during Ext Meas"); | |
1150 PFREE (mph_power_req); | |
1151 return; | |
1152 } | |
1153 | |
1154 if (mph_power_req->freq_bands EQ 0) | |
1155 { | |
1156 TRACE_ERROR ("MPH_POWER_REQ with freq_bands=0 (Invalid value)!"); | |
1157 TRACE_ASSERT (mph_power_req->freq_bands EQ 0); | |
1158 } | |
1159 | |
1160 if(!IS_EXT_MEAS_RUNNING) | |
1161 { | |
1162 /* CSI-LLD Section : 4.1.3.4.2.2 */ | |
1163 if(alr_data->cs_data.p_power_req NEQ NULL) | |
1164 { | |
1165 TRACE_ERROR("MPH_POWER_REQ buffer leakage"); | |
1166 PFREE(alr_data->cs_data.p_power_req); | |
1167 } | |
1168 /* Store the MPH_POWER_REQ pointer for later usage */ | |
1169 alr_data->cs_data.p_power_req = mph_power_req; | |
1170 } | |
1171 | |
1172 alr_data->cs_data.freq_bands = mph_power_req->freq_bands; | |
1173 | |
1174 ALR_EM_POWER_MEASSUREMENT_REQUEST; | |
1175 | |
1176 switch (mph_power_req->pch_interrupt) | |
1177 { | |
1178 case NO_PCH_INTERRUPT: | |
1179 /* | |
1180 * Full list power measurements without changing the current state | |
1181 */ | |
1182 alr_data->plmn_search_running = TRUE; | |
1183 nc_suspend(); | |
1184 cs_power_req (NO_PCH_INTERRUPT); | |
1185 break; | |
1186 case PCH_INTERRUPT: | |
1187 /* | |
1188 * Full list power measurements for Cell Selection | |
1189 */ | |
1190 alr_data->plmn_search_running = FALSE; | |
1191 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
1192 alr_multiband_std = NOT_PRESENT_8BIT; | |
1193 #endif | |
1194 #ifdef GPRS | |
1195 gprs_alr_init(); | |
1196 #endif | |
1197 switch (GET_STATE(STATE_MA)) | |
1198 { | |
1199 case MA_NULL: | |
1200 case MA_CELL_SELECTION: | |
1201 ma_stop_active_procs(DONT_STOP_PCH_READING); | |
1202 SET_STATE(STATE_MA, MA_CELL_SELECTION); | |
1203 cs_power_req (PCH_INTERRUPT); | |
1204 break; | |
1205 case MA_CELL_RESELECTION: | |
1206 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); | |
1207 nc_stop(); | |
1208 SET_STATE(STATE_MA, MA_CELL_SELECTION); | |
1209 cs_power_req (PCH_INTERRUPT); | |
1210 break; | |
1211 case MA_CON_EST: | |
1212 case MA_DEDICATED: | |
1213 case MA_IDLE: | |
1214 #ifdef GPRS | |
1215 case MA_PTM: | |
1216 alr_data->nc_sync_with_grr = TRUE; | |
1217 #endif | |
1218 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); | |
1219 /* | |
1220 * call this explicitly here, because stop_active_procs only | |
1221 * suspends ncell procedures | |
1222 */ | |
1223 nc_stop(); | |
1224 SET_STATE(STATE_MA, MA_CELL_SELECTION); | |
1225 cs_power_req (PCH_INTERRUPT); | |
1226 break; | |
1227 default: | |
1228 if(!IS_EXT_MEAS_RUNNING) | |
1229 { | |
1230 PFREE (mph_power_req); | |
1231 alr_data->cs_data.p_power_req = NULL; | |
1232 TRACE_ERROR ("MPH_POWER_REQ received in invalid MA state"); | |
1233 } | |
1234 break; | |
1235 } | |
1236 break; | |
1237 default: | |
1238 if(!IS_EXT_MEAS_RUNNING) | |
1239 { | |
1240 PFREE (mph_power_req); | |
1241 alr_data->cs_data.p_power_req = NULL; | |
1242 TRACE_ERROR ("MPH_POWER_REQ: Invalid search type"); | |
1243 } | |
1244 break; | |
1245 } | |
1246 } | |
1247 | |
1248 /* | |
1249 +--------------------------------------------------------------------+ | |
1250 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1251 | STATE : code ROUTINE : ma_mph_bsic_req | | |
1252 +--------------------------------------------------------------------+ | |
1253 | |
1254 PURPOSE : Process the primitive MPH_BSIC_REQ. | |
1255 | |
1256 */ | |
1257 | |
1258 GLOBAL void ma_mph_bsic_req (T_MPH_BSIC_REQ* mph_bsic_req) | |
1259 { | |
1260 GET_INSTANCE_DATA; | |
1261 ALR_TRACE_MAIN_BSIC_REQ (GET_STATE(STATE_MA)); | |
1262 | |
1263 #ifdef GPRS | |
1264 if(alr_data->gprs_data.pcco_active) | |
1265 { | |
1266 cs_bsic_req(mph_bsic_req); | |
1267 PFREE (mph_bsic_req); | |
1268 return; | |
1269 } | |
1270 #endif | |
1271 | |
1272 switch (GET_STATE (STATE_MA)) | |
1273 { | |
1274 case MA_CELL_SELECTION: | |
1275 cs_bsic_req (mph_bsic_req); | |
1276 break; | |
1277 case MA_IDLE: | |
1278 nc_bsic_req (mph_bsic_req); | |
1279 break; | |
1280 #ifdef GPRS | |
1281 case MA_DEDICATED: | |
1282 | |
1283 ma_stop_active_procs(STOP_PCH_READING | STOP_MEASUREMENTS); /* DEDI-state is now DEDI_INACTIVE */ | |
1284 /* DEDI-state is now DEDI_INACTIVE */ | |
1285 SET_STATE(STATE_NC, NC_NULL); | |
1286 #ifdef NOT_YET | |
1287 nc_suspend(); /* stop dedicated mode activity */ | |
1288 #endif | |
1289 | |
1290 SET_STATE(STATE_MA, MA_CELL_SELECTION); | |
1291 cs_bsic_req (mph_bsic_req); | |
1292 break; | |
1293 #endif | |
1294 default: | |
1295 break; | |
1296 } | |
1297 | |
1298 PFREE (mph_bsic_req); | |
1299 } | |
1300 | |
1301 | |
1302 /* | |
1303 +--------------------------------------------------------------------+ | |
1304 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1305 | STATE : code ROUTINE : ma_mph_meas_rep_req | | |
1306 +--------------------------------------------------------------------+ | |
1307 | |
1308 PURPOSE : Process the primitive MPH_MEAS_REP_REQ. | |
1309 */ | |
1310 | |
1311 #ifdef GPRS | |
1312 GLOBAL void ma_mph_meas_rep_req(T_MPH_MEAS_REP_REQ * mph_meas_rep_req) | |
1313 { | |
1314 GET_INSTANCE_DATA; | |
1315 USHORT i; | |
1316 TRACE_EVENT("mph_meas_rep_req"); | |
1317 | |
1318 switch(mph_meas_rep_req->cause) | |
1319 { | |
1320 case NC_START_MEAS: | |
1321 /* | |
1322 * Reset nc mease results database | |
1323 */ | |
1324 for(i=0;i<=BA_LIST_SIZE;i++) | |
1325 { | |
1326 alr_data->nc_data.cell[i].nc_rxlev = 0; | |
1327 alr_data->nc_data.cell[i].c_nc_rxlev = 0; | |
1328 } | |
1329 /* | |
1330 * activate rx_lev averaging when NC=1 or NC=2 | |
1331 */ | |
1332 alr_data->nwctrl_meas_active = TRUE; | |
1333 break; | |
1334 case NC_REPORT_MEAS: | |
1335 /* | |
1336 * Calculate rx_lev average and send the report to RR. RR forwards this to GRR | |
1337 */ | |
1338 if(alr_data->nwctrl_meas_active) | |
1339 { | |
1340 PALLOC(mph_meas_rep_cnf, MPH_MEAS_REP_CNF); | |
1341 memset(mph_meas_rep_cnf,0,sizeof(T_MPH_MEAS_REP_CNF)); | |
1342 nc_build_nwctrl_rr_report(mph_meas_rep_cnf); | |
1343 PSENDX ( RR, mph_meas_rep_cnf); | |
1344 for(i=0;i<=BA_LIST_SIZE;i++) | |
1345 { | |
1346 alr_data->nc_data.cell[i].nc_rxlev = 0; | |
1347 alr_data->nc_data.cell[i].c_nc_rxlev = 0; | |
1348 } | |
1349 } | |
1350 break; | |
1351 case NC_STOP_MEAS: | |
1352 /* | |
1353 * De-activate rx_lev averaging for Network control | |
1354 */ | |
1355 alr_data->nwctrl_meas_active = FALSE; | |
1356 break; | |
1357 default: | |
1358 break; | |
1359 } | |
1360 PFREE(mph_meas_rep_req); | |
1361 } | |
1362 #endif | |
1363 | |
1364 | |
1365 /* | |
1366 +--------------------------------------------------------------------+ | |
1367 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1368 | STATE : code ROUTINE : ma_mph_random_access_req | | |
1369 +--------------------------------------------------------------------+ | |
1370 | |
1371 PURPOSE : Process the primitive MPH_RANDOM_ACCESS_REQ. | |
1372 | |
1373 */ | |
1374 | |
1375 GLOBAL void ma_mph_random_access_req (T_MPH_RANDOM_ACCESS_REQ* mph_random_access_req) | |
1376 { | |
1377 GET_INSTANCE_DATA; | |
1378 switch (GET_STATE (STATE_MA)) | |
1379 { | |
1380 case MA_IDLE: | |
1381 ALR_TRACE_MAIN_RAND_ACC(alr_data->serving_cell, mph_random_access_req->send_mode.no); | |
1382 | |
1383 /* | |
1384 * suspend neighbour cell procedures | |
1385 */ | |
1386 ma_stop_active_procs(DONT_STOP_PCH_READING | STOP_MEASUREMENTS); | |
1387 SET_STATE (STATE_MA, MA_CON_EST); | |
1388 /* | |
1389 * switch to full downlink CCCH listening | |
1390 */ | |
1391 pch_save_pgm(0); | |
1392 pch_configure(NULL, PGM_REORG_CS); | |
1393 pch_start_ccch_req (); | |
1394 /* | |
1395 * Send uplink Random Bursts | |
1396 */ | |
1397 rach_random_req (mph_random_access_req); | |
1398 break; | |
1399 #ifdef GPRS | |
1400 case MA_PTM: | |
1401 ma_stop_active_procs(DONT_STOP_PCH_READING| STOP_MEASUREMENTS); | |
1402 // nc_suspend(); gprs_alr_nc_leave_ptm(); | |
1403 SET_STATE (STATE_MA, MA_CON_EST); | |
1404 /* | |
1405 * switch to full downlink CCCH listening | |
1406 */ | |
1407 /*pch_save_pgm(0);*/ | |
1408 pch_configure(NULL, PGM_REORG_CS); | |
1409 pch_start_ccch_req (); | |
1410 /* | |
1411 * Send uplink Random Bursts | |
1412 */ | |
1413 rach_random_req (mph_random_access_req); | |
1414 break; | |
1415 #endif | |
1416 case MA_CON_EST: | |
1417 SET_STATE (STATE_MA, MA_CON_EST); | |
1418 rach_random_req (mph_random_access_req); | |
1419 break; | |
1420 | |
1421 default: | |
1422 break; | |
1423 } | |
1424 | |
1425 PFREE (mph_random_access_req); | |
1426 } | |
1427 | |
1428 /* | |
1429 +--------------------------------------------------------------------+ | |
1430 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1431 | STATE : code ROUTINE : ma_mph_mph_emo_req | | |
1432 +--------------------------------------------------------------------+ | |
1433 | |
1434 PURPOSE : Process the primitive MPH_MPH_EMO_REQ. | |
1435 | |
1436 */ | |
1437 | |
1438 GLOBAL void ma_mph_emo_req (T_MPH_EMO_REQ *mph_emo_req) | |
1439 { | |
1440 GET_INSTANCE_DATA; | |
1441 switch (GET_STATE (STATE_MA)) | |
1442 { | |
1443 case MA_DEDICATED: | |
1444 { | |
1445 UBYTE i,n; | |
1446 USHORT *radio_freq; | |
1447 USHORT *arfcn; | |
1448 USHORT sc = alr_data->serving_cell; | |
1449 BOOL sc_ok; | |
1450 PALLOC (mphc_update_ba_list, MPHC_UPDATE_BA_LIST); | |
1451 | |
1452 alr_data->dedi_data.emo_ba_id = mph_emo_req->ba_id; | |
1453 | |
1454 n = mph_emo_req->c_arfcn; | |
1455 if ( n >= BA_LIST_SIZE ) | |
1456 n = BA_LIST_SIZE; | |
1457 | |
1458 /* | |
1459 * Initialize the outgoing primitive MPHC_UPDATE_BA_LIST. | |
1460 */ | |
1461 | |
1462 radio_freq = &mphc_update_ba_list->chan_list.radio_freq[0]; | |
1463 arfcn = &mph_emo_req->arfcn[0]; | |
1464 sc_ok = FALSE; | |
1465 | |
1466 for ( i = 0; i < n; i++ ) | |
1467 { | |
1468 radio_freq[i] = ARFCN_TO_L1 (arfcn[i]); | |
1469 if ( radio_freq[i] EQ sc ) | |
1470 { | |
1471 sc_ok = TRUE; | |
1472 } | |
1473 } | |
1474 if ( !sc_ok AND n < BA_LIST_SIZE ) /* add the serving cell ARFCN */ | |
1475 { | |
1476 radio_freq[n++] = sc; | |
1477 } | |
1478 mphc_update_ba_list->num_of_chans = n; | |
1479 mphc_update_ba_list->pwrc = alr_data->nc_data.pwrc; | |
1480 mphc_update_ba_list->dtx_allowed = alr_data->nc_data.dtx; | |
1481 mphc_update_ba_list->ba_id = mph_emo_req->ba_id; | |
1482 | |
1483 PSENDX (L1, mphc_update_ba_list); | |
1484 | |
1485 break; | |
1486 } | |
1487 } | |
1488 PFREE (mph_emo_req); | |
1489 } | |
1490 /* | |
1491 +--------------------------------------------------------------------+ | |
1492 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1493 | STATE : code ROUTINE : ma_mph_mph_emo_req | | |
1494 +--------------------------------------------------------------------+ | |
1495 | |
1496 PURPOSE : Process the primitive MPH_MPH_EMO_REQ. | |
1497 | |
1498 */ | |
1499 | |
1500 GLOBAL void ma_mph_ncell_pos_req (T_MPH_NCELL_POS_REQ *mph_ncell_pos_req) | |
1501 { | |
1502 nc_ncell_pos_req(mph_ncell_pos_req); | |
1503 } | |
1504 /* ------------------------------------------------------------------ | |
1505 * ------------------------------------------------------------------ | |
1506 * Functions for the lower layer(MPHC) primitive processing | |
1507 * ------------------------------------------------------------------ | |
1508 * ------------------------------------------------------------------ | |
1509 */ | |
1510 | |
1511 | |
1512 /* | |
1513 +--------------------------------------------------------------------+ | |
1514 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1515 | STATE : code ROUTINE : ma_mphc_rxlev_con | | |
1516 +--------------------------------------------------------------------+ | |
1517 | |
1518 PURPOSE : Process the primitive MPHC_RXLEV_CON. | |
1519 | |
1520 */ | |
1521 | |
1522 GLOBAL void ma_mphc_rxlev_ind (T_MPHC_RXLEV_IND* rxlev_ind) | |
1523 { | |
1524 GET_INSTANCE_DATA; | |
1525 | |
1526 USHORT cs_state = GET_STATE (STATE_CS); | |
1527 switch (cs_state) | |
1528 { | |
1529 default: | |
1530 TRACE_EVENT_P1 ("wrong CS state (%u) in ma_mphc_rxlev_ind()", cs_state); | |
1531 /*lint -fallthrough*/ | |
1532 case CS_ACTIVE_MEASURE: | |
1533 SET_STATE(STATE_CS, CS_MEASURED); | |
1534 break; | |
1535 } | |
1536 | |
1537 ALR_EM_FIELDSTRENGTH_MEASUREMENT_CONFIRM; | |
1538 cs_rxlev_ind (rxlev_ind); | |
1539 PFREE (rxlev_ind); | |
1540 } | |
1541 | |
1542 /* | |
1543 +--------------------------------------------------------------------+ | |
1544 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1545 | STATE : code ROUTINE : ma_mphc_stop_rxlev_con | | |
1546 +--------------------------------------------------------------------+ | |
1547 | |
1548 PURPOSE : Process the primitive MPHC_RXLEV_CON. | |
1549 | |
1550 */ | |
1551 | |
1552 GLOBAL void ma_mphc_stop_rxlev_cnf (T_MPHC_STOP_RXLEV_CON * rxlev_cnf) | |
1553 { | |
1554 GET_INSTANCE_DATA; | |
1555 if ( IS_EXT_MEAS_RUNNING ) | |
1556 { | |
1557 nc_stop_ext_meas_ind(); | |
1558 alr_data->cs_data.ext_meas_state_pend = CS_NULL; | |
1559 } | |
1560 PFREE(rxlev_cnf); | |
1561 } | |
1562 | |
1563 | |
1564 /* | |
1565 +--------------------------------------------------------------------+ | |
1566 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1567 | STATE : code ROUTINE : ma_stop_cnf | | |
1568 +--------------------------------------------------------------------+ | |
1569 | |
1570 PURPOSE : Processes the primitives MPHC_STOP_*_CON. | |
1571 | |
1572 */ | |
1573 | |
1574 GLOBAL void ma_mphc_empty_cnf (void *cnf) | |
1575 { | |
1576 PFREE (cnf); | |
1577 } | |
1578 | |
1579 /* | |
1580 +--------------------------------------------------------------------+ | |
1581 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1582 | STATE : code ROUTINE : ma_mphc_network_sync_ind | | |
1583 +--------------------------------------------------------------------+ | |
1584 | |
1585 PURPOSE : Process the primitive MPHC_NETWORK_SYNC_IND. | |
1586 | |
1587 */ | |
1588 | |
1589 GLOBAL void ma_mphc_network_sync_ind (T_MPHC_NETWORK_SYNC_IND* sync_ind) | |
1590 { | |
1591 TIMERSTOP(TIM_NW_SYNC_GUARD); | |
1592 cs_network_sync_ind (sync_ind); | |
1593 PFREE(sync_ind); | |
1594 } | |
1595 | |
1596 #if defined(STOP_SYNC_TASK) | |
1597 /* | |
1598 +----------------------------------------------------------------------------+ | |
1599 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1600 | STATE : code ROUTINE : ma_mphc_stop_network_sync_req | | |
1601 +----------------------------------------------------------------------------+ | |
1602 | |
1603 PURPOSE : Process the primitive MPHC_STOP_NETWORK_SYNC_REQ. | |
1604 | |
1605 */ | |
1606 | |
1607 GLOBAL void ma_cs_stop_network_sync_req(void) | |
1608 { | |
1609 GET_INSTANCE_DATA; | |
1610 if (alr_data->cs_data.sync_active) | |
1611 { | |
1612 PALLOC (stop_sync_task, MPHC_STOP_NETWORK_SYNC_REQ); /* T_MPHC_STOP_NETWORK_SYNC_REQ */ | |
1613 TRACE_EVENT ("STOP_NETWORK_SYNC_REQ"); | |
1614 PSENDX(L1, stop_sync_task); | |
1615 } | |
1616 } | |
1617 | |
1618 /* | |
1619 +----------------------------------------------------------------------------+ | |
1620 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1621 | STATE : code ROUTINE : ma_mphc_stop_network_sync_cnf | | |
1622 +----------------------------------------------------------------------------+ | |
1623 | |
1624 PURPOSE : Process the primitive MPHC_STOP_NETWORK_SYNC_CON. | |
1625 | |
1626 */ | |
1627 | |
1628 GLOBAL void ma_mphc_stop_network_sync_cnf(T_MPHC_STOP_NETWORK_SYNC_CON *stop_network_sync_cnf) | |
1629 { | |
1630 GET_INSTANCE_DATA; | |
1631 alr_data->cs_data.sync_active = FALSE; | |
1632 switch(GET_STATE(STATE_CS)) | |
1633 { | |
1634 case CS_STOP_SYNC: | |
1635 SET_STATE (STATE_CS, CS_STOP_SYNC_DONE); | |
1636 cs_bsic_req(NULL); | |
1637 break; | |
1638 | |
1639 case CS_NW_SYNC_TIMEOUT: | |
1640 /* Inform RR that no BCCH was found */ | |
1641 SET_STATE (STATE_CS, CS_ACTIVE_SYNC); | |
1642 | |
1643 { | |
1644 PALLOC (mph_bsic_cnf, MPH_BSIC_CNF); | |
1645 mph_bsic_cnf->cs = CS_NO_BCCH_AVAIL; | |
1646 PSENDX (RR, mph_bsic_cnf); | |
1647 } | |
1648 break; | |
1649 | |
1650 default: | |
1651 break; | |
1652 } | |
1653 | |
1654 PFREE(stop_network_sync_cnf); | |
1655 } | |
1656 #endif /* STOP_SYNC_TASK */ | |
1657 | |
1658 /* | |
1659 +--------------------------------------------------------------------+ | |
1660 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1661 | STATE : code ROUTINE : ma_mphc_new_scell_cnf | | |
1662 +--------------------------------------------------------------------+ | |
1663 | |
1664 PURPOSE : Process the primitive MPHC_NEW_SCELL_CON. | |
1665 | |
1666 */ | |
1667 | |
1668 GLOBAL void ma_mphc_new_scell_cnf (T_MPHC_NEW_SCELL_CON* new_scell_cnf) | |
1669 { | |
1670 GET_INSTANCE_DATA; | |
1671 /* we have a new serving cell */ | |
1672 vsi_t_sleep(VSI_CALLER 10); | |
1673 | |
1674 switch (GET_STATE(STATE_MA)) | |
1675 { | |
1676 case MA_CELL_SELECTION: | |
1677 /* | |
1678 * we are synchronized to the new cell | |
1679 * now read the BCCH to check if the cell | |
1680 * is suitable | |
1681 */ | |
1682 cs_read_scell_bcch (); | |
1683 break; | |
1684 case MA_CELL_RESELECTION: | |
1685 ALR_TRACE_MAIN ("new sc in cr"); | |
1686 if (alr_data->old_serving_cell NEQ alr_data->serving_cell) | |
1687 { | |
1688 ALR_TRACE_MAIN_SCELL(alr_data->old_serving_cell, alr_data->serving_cell); | |
1689 ALR_TRACE_MAIN ("update timebase"); | |
1690 /* | |
1691 * update the timebase now | |
1692 */ | |
1693 nc_update_list (alr_data->serving_cell); | |
1694 /* | |
1695 * removing of the old serving cell only just if | |
1696 * RR gives a positive receipt for cell selection. | |
1697 * obsolet: nc_update_serving_cell (alr_data->old_serving_cell); | |
1698 */ | |
1699 | |
1700 /* | |
1701 * In case the serving cell has been changed, the last CCCH configuration | |
1702 * is not valid anymore! It will delete now, so that the sucessful | |
1703 * comparison inside ma_pch_start_ccch_req() will not prevent a new | |
1704 * CCCH configuration of L1. | |
1705 */ | |
1706 memset (&alr_data->pch_data.last_start_ccch_req, 0, | |
1707 sizeof (alr_data->pch_data.last_start_ccch_req)); | |
1708 } | |
1709 #ifdef GPRS | |
1710 if(alr_data->gprs_data.sync_only) | |
1711 { | |
1712 PALLOC(sync, MPH_SYNC_IND); | |
1713 sync->cs = CS_SCELL_IS_SYNCED; | |
1714 alr_data->gprs_data.sync_only=0; | |
1715 SET_STATE(STATE_MA, MA_IDLE); | |
1716 PSENDX (RR, sync); | |
1717 } | |
1718 else | |
1719 { | |
1720 #endif | |
1721 pch_start_ccch_req(); | |
1722 #ifdef GPRS | |
1723 } | |
1724 #endif | |
1725 break; | |
1726 case MA_IDLE: | |
1727 ALR_TRACE_MAIN ("new sc in idle"); | |
1728 if (alr_data->old_serving_cell NEQ alr_data->serving_cell) | |
1729 nc_update_list (alr_data->serving_cell); | |
1730 break; | |
1731 case MA_CON_EST: | |
1732 break; | |
1733 default: | |
1734 break; | |
1735 } | |
1736 | |
1737 PFREE (new_scell_cnf); | |
1738 } | |
1739 | |
1740 /* | |
1741 +--------------------------------------------------------------------+ | |
1742 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1743 | STATE : code ROUTINE : ma_mphc_ncell_bcch_ind | | |
1744 +--------------------------------------------------------------------+ | |
1745 | |
1746 PURPOSE : Process the primitive MPHC_NCELL_BCCH_IND. | |
1747 | |
1748 */ | |
1749 | |
1750 GLOBAL void ma_mphc_ncell_bcch_ind (T_MPHC_NCELL_BCCH_IND* ncell_bcch_ind) | |
1751 { | |
1752 nc_bcch_ind (ncell_bcch_ind); | |
1753 PFREE (ncell_bcch_ind); | |
1754 } | |
1755 | |
1756 /* | |
1757 +--------------------------------------------------------------------+ | |
1758 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1759 | STATE : code ROUTINE : ma_mphc_ncell_sync_ind | | |
1760 +--------------------------------------------------------------------+ | |
1761 | |
1762 PURPOSE : Process the primitive MPHC_NCELL_SYNC_IND. | |
1763 | |
1764 */ | |
1765 | |
1766 GLOBAL void ma_mphc_ncell_sync_ind (T_MPHC_NCELL_SYNC_IND* ncell_sync_ind) | |
1767 { | |
1768 nc_sync_ind (ncell_sync_ind); | |
1769 PFREE (ncell_sync_ind); | |
1770 } | |
1771 | |
1772 /* | |
1773 +--------------------------------------------------------------------+ | |
1774 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1775 | STATE : code ROUTINE : ma_mphc_stop_ncell_sync_cnf | | |
1776 +--------------------------------------------------------------------+ | |
1777 | |
1778 PURPOSE : Process the primitive MPHC_NCELL_SYNC_IND. | |
1779 | |
1780 */ | |
1781 | |
1782 GLOBAL void ma_mphc_stop_ncell_sync_cnf (T_MPHC_STOP_NCELL_SYNC_CON *cnf ) | |
1783 { | |
1784 GET_INSTANCE_DATA; | |
1785 if ( IS_EXT_MEAS_RUNNING ) | |
1786 { | |
1787 nc_stop_ext_meas_ind(); | |
1788 alr_data->cs_data.ext_meas_state_pend = CS_NULL; | |
1789 } | |
1790 PFREE (cnf); | |
1791 } | |
1792 | |
1793 /* | |
1794 +--------------------------------------------------------------------+ | |
1795 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1796 | STATE : code ROUTINE : ma_mphc_ncell_bcch_ind | | |
1797 +--------------------------------------------------------------------+ | |
1798 | |
1799 PURPOSE : Process the primitive MPHC_RXLEV_PERIODIC_IND. | |
1800 | |
1801 */ | |
1802 | |
1803 GLOBAL void ma_mphc_rxlev_periodic_ind (T_MPHC_RXLEV_PERIODIC_IND* | |
1804 rxlev_periodic_ind) | |
1805 { | |
1806 GET_INSTANCE_DATA; | |
1807 | |
1808 switch (GET_STATE (STATE_MA)) | |
1809 { | |
1810 case MA_CELL_RESELECTION: | |
1811 case MA_CON_EST: | |
1812 case MA_IDLE: | |
1813 nc_report (rxlev_periodic_ind); | |
1814 #ifdef TI_PS_HCOMM_CHANGE | |
1815 PSIGNAL (_hCommDL, PH_TRACE_IND, NULL); | |
1816 #else | |
1817 PSIGNAL (hCommDL, PH_TRACE_IND, NULL); | |
1818 #endif /* TI_PS_HCOMM_CHANGE */ | |
1819 alr_trc_read (8); | |
1820 break; | |
1821 | |
1822 default: | |
1823 break; | |
1824 } | |
1825 PFREE (rxlev_periodic_ind); | |
1826 } | |
1827 | |
1828 /* | |
1829 +--------------------------------------------------------------------+ | |
1830 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1831 | STATE : code ROUTINE : ma_mphc_ra_cnf | | |
1832 +--------------------------------------------------------------------+ | |
1833 | |
1834 PURPOSE : Process the primitive MPHC_RA_CON. | |
1835 | |
1836 */ | |
1837 | |
1838 GLOBAL void ma_mphc_ra_cnf (T_MPHC_RA_CON* ra_cnf) | |
1839 { | |
1840 GET_INSTANCE_DATA; | |
1841 | |
1842 switch (GET_STATE (STATE_MA)) | |
1843 { | |
1844 case MA_CON_EST: | |
1845 rach_ra_cnf (ra_cnf); | |
1846 break; | |
1847 default: | |
1848 break; | |
1849 } | |
1850 PFREE (ra_cnf); | |
1851 } | |
1852 | |
1853 /* | |
1854 +--------------------------------------------------------------------+ | |
1855 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
1856 | STATE : code ROUTINE : ma_trc_data_ind | | |
1857 +--------------------------------------------------------------------+ | |
1858 | |
1859 PURPOSE : Trace the primitive MPHC_DATA_IND. | |
1860 | |
1861 configure the output with the following command: | |
1862 CONFIG TRC_DATA_IND=n | |
1863 | |
1864 the available decimal values of the bit mask 'n' are: | |
1865 ID_TRC_DATA_IND_ALL 255 | |
1866 ID_TRC_DATA_IND_VALID 127 | |
1867 ID_TRC_DATA_IND_INVALID 128 | |
1868 ID_TRC_DATA_IND_BCCH 1 normal and extended BCCH | |
1869 ID_TRC_DATA_IND_PCH 2 normal and extended PCH | |
1870 ID_TRC_DATA_IND_CCCH 4 | |
1871 ID_TRC_DATA_IND_CBCH 8 | |
1872 ID_TRC_DATA_IND_SCCH 16 SACCH and SDCCH | |
1873 ID_TRC_DATA_IND_FCCH 32 full and half rate FACCH | |
1874 ID_TRC_DATA_IND_STATE 64 MA status | |
1875 | |
1876 ID_TRC_DATA_IND_INIT 63 all valid frames without stati | |
1877 ID_TRC_DATA_IND_INIT2 31 ... without FACCH | |
1878 */ | |
1879 #if !defined(NCONFIG) | |
1880 static void ma_trc_data_ind(T_MPHC_DATA_IND* data_ind) | |
1881 { | |
1882 GET_INSTANCE_DATA; | |
1883 char *msg_s = ""; | |
1884 UBYTE msg_t = 0; | |
1885 | |
1886 if (data_ind->error_flag NEQ VALID_BLOCK) | |
1887 { | |
1888 if (v_mon_trc_data_ind & ID_TRC_DATA_IND_INVALID) | |
1889 { | |
1890 #if !defined(DL_TRACE_ENABLED) | |
1891 SYST_TRACE ("invalid block"); | |
1892 #else /* !DL_TRACE_ENABLED */ | |
1893 DL_OFFLINE_TRACE ("invalid block"); | |
1894 #endif /* !DL_TRACE_ENABLED */ | |
1895 } | |
1896 return; | |
1897 } | |
1898 | |
1899 switch (data_ind->l2_channel) | |
1900 { | |
1901 case L2_CHANNEL_SACCH: | |
1902 case L2_CHANNEL_SDCCH: | |
1903 if ((v_mon_trc_data_ind & ID_TRC_DATA_IND_SCCH) EQ 0) | |
1904 msg_t = (UBYTE)-1; | |
1905 break; | |
1906 case L2_CHANNEL_FACCH_H: | |
1907 case L2_CHANNEL_FACCH_F: | |
1908 if ((v_mon_trc_data_ind & ID_TRC_DATA_IND_FCCH) EQ 0) | |
1909 msg_t = (UBYTE)-1; | |
1910 break; | |
1911 case L2_CHANNEL_CCCH: | |
1912 if ((v_mon_trc_data_ind & ID_TRC_DATA_IND_CCCH) EQ 0) | |
1913 return; | |
1914 break; | |
1915 case L2_CHANNEL_NBCCH: | |
1916 case L2_CHANNEL_EBCCH: | |
1917 if ((v_mon_trc_data_ind & ID_TRC_DATA_IND_BCCH) EQ 0) | |
1918 msg_t = (UBYTE)-1; | |
1919 break; | |
1920 case L2_CHANNEL_PCH: | |
1921 case L2_CHANNEL_EPCH: | |
1922 if ((v_mon_trc_data_ind & ID_TRC_DATA_IND_PCH) EQ 0) | |
1923 msg_t = (UBYTE)-1; | |
1924 break; | |
1925 case L2_CHANNEL_CBCH: | |
1926 if ((v_mon_trc_data_ind & ID_TRC_DATA_IND_CBCH) EQ 0) | |
1927 msg_t = (UBYTE)-1; | |
1928 break; | |
1929 default: | |
1930 msg_t = (UBYTE)-1; | |
1931 SYST_TRACE_P((SYST, "trc_data_ind %02x ch=%d", | |
1932 v_mon_trc_data_ind, data_ind->l2_channel)); | |
1933 break; | |
1934 } | |
1935 | |
1936 if (msg_t) | |
1937 { | |
1938 return; | |
1939 } | |
1940 | |
1941 if (data_ind->error_flag EQ VALID_BLOCK) | |
1942 { | |
1943 msg_t = data_ind->l2_frame.content[SI_CONTENTS_MSG_T]; | |
1944 switch (msg_t) | |
1945 { | |
1946 case D_IMM_ASSIGN: | |
1947 msg_s = "IMM_ASS"; | |
1948 break; | |
1949 case D_IMM_ASSIGN_EXT: | |
1950 msg_s = "IMM_ASS_EXT"; | |
1951 break; | |
1952 case D_IMM_ASSIGN_REJ: | |
1953 msg_s = "IMM_ASS_REJ"; | |
1954 break; | |
1955 case D_PAG_REQ_1: | |
1956 msg_s = "PAG1"; | |
1957 break; | |
1958 case D_PAG_REQ_2: | |
1959 msg_s = "PAG2"; | |
1960 break; | |
1961 case D_PAG_REQ_3: | |
1962 msg_s = "PAG3"; | |
1963 break; | |
1964 case D_SYS_INFO_1: | |
1965 msg_s = "SI 1"; | |
1966 break; | |
1967 case D_SYS_INFO_2: | |
1968 msg_s = "SI 2"; | |
1969 break; | |
1970 case D_SYS_INFO_2BIS: | |
1971 msg_s = "SI 2bis"; | |
1972 break; | |
1973 case D_SYS_INFO_2TER: | |
1974 msg_s = "SI 2ter"; | |
1975 break; | |
1976 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
1977 case D_SYS_INFO_2QUATER: | |
1978 msg_s = "SI 2quater"; | |
1979 break; | |
1980 #endif | |
1981 case D_SYS_INFO_3: | |
1982 msg_s = "SI 3"; | |
1983 /* | |
1984 TRACE_EVENT_P8 ("SI3: lai=%x%x%x %x%x%x %02x%02x", | |
1985 data_ind->l2_frame.content[5]&0x0f, | |
1986 data_ind->l2_frame.content[5]>>4, | |
1987 data_ind->l2_frame.content[6]&0x0f, | |
1988 | |
1989 data_ind->l2_frame.content[7]&0x0f, | |
1990 data_ind->l2_frame.content[7]>>4, | |
1991 data_ind->l2_frame.content[6]>>4, | |
1992 | |
1993 data_ind->l2_frame.content[8], | |
1994 data_ind->l2_frame.content[9]); | |
1995 */ | |
1996 break; | |
1997 case D_SYS_INFO_4: | |
1998 msg_s = "SI 4"; | |
1999 /* | |
2000 TRACE_EVENT_P8 ("SI4: lai=%x%x%x %x%x%x %02x%02x", | |
2001 data_ind->l2_frame.content[3]&0x0f, | |
2002 data_ind->l2_frame.content[3]>>4, | |
2003 data_ind->l2_frame.content[4]&0x0f, | |
2004 | |
2005 data_ind->l2_frame.content[5]&0x0f, | |
2006 data_ind->l2_frame.content[5]>>4, | |
2007 data_ind->l2_frame.content[4]>>4, | |
2008 | |
2009 data_ind->l2_frame.content[6], | |
2010 data_ind->l2_frame.content[7]); | |
2011 */ | |
2012 break; | |
2013 case D_SYS_INFO_5: | |
2014 msg_s = "SI 5"; | |
2015 break; | |
2016 case D_SYS_INFO_5BIS: | |
2017 msg_s = "SI 5bis"; | |
2018 break; | |
2019 case D_SYS_INFO_5TER: | |
2020 msg_s = "SI 5ter"; | |
2021 break; | |
2022 case D_SYS_INFO_6: | |
2023 msg_s = "SI 6"; | |
2024 break; | |
2025 #ifdef GPRS | |
2026 case D_SYS_INFO_13: | |
2027 msg_s = "SI 13"; | |
2028 break; | |
2029 #endif /* GPRS */ | |
2030 default: | |
2031 if (data_ind->l2_channel EQ L2_CHANNEL_CBCH) | |
2032 msg_s = "CBCH"; | |
2033 else | |
2034 msg_s = 0; | |
2035 break; | |
2036 } | |
2037 } | |
2038 | |
2039 #if !defined(DL_TRACE_ENABLED) | |
2040 if (msg_s) | |
2041 { | |
2042 if (v_mon_trc_data_ind & ID_TRC_DATA_IND_STATE) | |
2043 { | |
2044 SYST_TRACE_P((SYST, "[%u] %s %s", | |
2045 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, | |
2046 msg_s, STATE_MA_NAME[GET_STATE (STATE_MA)])); | |
2047 } | |
2048 else | |
2049 { | |
2050 SYST_TRACE_P((SYST, "[%u] %s", | |
2051 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, msg_s)); | |
2052 } | |
2053 } | |
2054 else | |
2055 { | |
2056 /* protocol discriminator */ | |
2057 UBYTE pd = data_ind->l2_frame.content[SI_CONTENTS_MSG_T-1]; | |
2058 char buf[47]; | |
2059 | |
2060 if (v_mon_trc_data_ind & ID_TRC_DATA_IND_STATE) | |
2061 { | |
2062 SYST_TRACE_P((SYST, "[%u] unknown %02x (PD%02x, ch=%d) %s", | |
2063 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, msg_t, pd, | |
2064 data_ind->l2_channel, STATE_MA_NAME[GET_STATE (STATE_MA)])); | |
2065 } | |
2066 else | |
2067 { | |
2068 SYST_TRACE_P((SYST, "[%u] unknown %02x (PD%02x, ch=%d)", | |
2069 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, | |
2070 msg_t, pd, data_ind->l2_channel)); | |
2071 } | |
2072 for (pd=0; pd<23; pd++) | |
2073 sprintf (buf+(pd<<1), "%02x", (UBYTE)data_ind->l2_frame.content[pd]); | |
2074 SYST_TRACE(buf); | |
2075 } | |
2076 #else /* !DL_TRACE_ENABLED */ | |
2077 { | |
2078 if (msg_s) | |
2079 { | |
2080 if (v_mon_trc_data_ind & ID_TRC_DATA_IND_STATE) | |
2081 { | |
2082 sprintf (dl_trace_buf, "[%u] %s %s", | |
2083 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, | |
2084 msg_s, STATE_MA_NAME[GET_STATE (STATE_MA)]); | |
2085 } | |
2086 else | |
2087 { | |
2088 sprintf (dl_trace_buf, "[%u] %s", | |
2089 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, msg_s); | |
2090 } | |
2091 } | |
2092 else | |
2093 { | |
2094 /* protocol discriminator */ | |
2095 UBYTE pd = data_ind->l2_frame.content[SI_CONTENTS_MSG_T-1]; | |
2096 | |
2097 sprintf (dl_trace_buf, "[%u] unknown %02x (PD%02x, ch=%d)", | |
2098 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, | |
2099 msg_t, pd, data_ind->l2_channel); | |
2100 } | |
2101 DL_OFFLINE_TRACE (dl_trace_buf); | |
2102 } | |
2103 #endif /* !DL_TRACE_ENABLED */ | |
2104 } | |
2105 | |
2106 /* | |
2107 +--------------------------------------------------------------------+ | |
2108 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
2109 | STATE : code ROUTINE : trc_state_transition | | |
2110 +--------------------------------------------------------------------+ | |
2111 | |
2112 PURPOSE : Traces state transition | |
2113 | |
2114 */ | |
2115 | |
2116 | |
2117 #if !defined(NTRACE) && defined(TRACE_STATE_TRANSITION) | |
2118 void trc_state_transition(int line, UBYTE newstate) | |
2119 { | |
2120 #if defined(DL_TRACE_ENABLED) | |
2121 sprintf (dl_trace_buf, "%s->%s (#%u)", | |
2122 STATE_MA_NAME[GET_STATE (STATE_MA)], STATE_MA_NAME[newstate], line); | |
2123 DL_OFFLINE_TRACE (dl_trace_buf); | |
2124 #else /* DL_TRACE_ENABLED */ | |
2125 SYST_TRACE_P((SYST, "%s->%s (#%u)", | |
2126 STATE_MA_NAME[GET_STATE (STATE_MA)], STATE_MA_NAME[newstate], line)); | |
2127 #endif /* DL_TRACE_ENABLED */ | |
2128 } | |
2129 #endif /* !NTRACE && TRACE_STATE_TRANSITION */ | |
2130 #endif /* !NCONFIG */ | |
2131 | |
2132 /* | |
2133 +--------------------------------------------------------------------+ | |
2134 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
2135 | STATE : code ROUTINE : trc_paging | | |
2136 +--------------------------------------------------------------------+ | |
2137 | |
2138 PURPOSE : Traces state transition | |
2139 | |
2140 */ | |
2141 | |
2142 | |
2143 #if !defined(NTRACE) && 0 | |
2144 void trc_paging(T_MPHC_DATA_IND* data_ind) | |
2145 { | |
2146 if ((data_ind->error_flag EQ VALID_BLOCK) AND | |
2147 ((data_ind->l2_channel EQ L2_CHANNEL_PCH) OR | |
2148 (data_ind->l2_channel EQ L2_CHANNEL_EPCH))) | |
2149 { | |
2150 char *str; | |
2151 | |
2152 switch (data_ind->l2_frame.content[SI_CONTENTS_MSG_T]) // SI_CONTENTS_MSG_T=2 | |
2153 { | |
2154 case D_PAG_REQ_1: | |
2155 str="D_PAG_REQ_1"; | |
2156 break; | |
2157 case D_PAG_REQ_2: | |
2158 str="D_PAG_REQ_2"; | |
2159 break; | |
2160 case D_PAG_REQ_3: | |
2161 str="D_PAG_REQ_3"; | |
2162 break; | |
2163 default: | |
2164 str = NULL; | |
2165 break; | |
2166 } | |
2167 | |
2168 if (str) | |
2169 { | |
2170 /* TRACE_BINDUMP first available with FRAME_2.9.18 */ | |
2171 #ifdef TI_PS_HCOMM_CHANGE | |
2172 TRACE_BINDUMP(_hCommPL ,TC_EVENT, str, data_ind->l2_frame.content, | |
2173 MAX_L2_FRAME_SIZE); | |
2174 #else | |
2175 TRACE_BINDUMP(hCommPL ,TC_EVENT, str, data_ind->l2_frame.content, | |
2176 MAX_L2_FRAME_SIZE); | |
2177 #endif /* TI_PS_HCOMM_CHANGE */ | |
2178 } | |
2179 } | |
2180 | |
2181 } | |
2182 #endif /* !NTRACE */ | |
2183 | |
2184 /* | |
2185 +--------------------------------------------------------------------+ | |
2186 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
2187 | STATE : code ROUTINE : ma_mphc_data_ind | | |
2188 +--------------------------------------------------------------------+ | |
2189 | |
2190 PURPOSE : Process the primitive MPHC_DATA_IND. | |
2191 | |
2192 */ | |
2193 | |
2194 GLOBAL void ma_mphc_data_ind (T_MPHC_DATA_IND* data_ind) | |
2195 { | |
2196 GET_INSTANCE_DATA; | |
2197 USHORT length=0, valid=0; | |
2198 UBYTE msg_t; | |
2199 | |
2200 alr_trc_read (1); | |
2201 | |
2202 #if !defined(NTRACE) && 0 | |
2203 trc_paging(data_ind); | |
2204 #endif /* !NTRACE */ | |
2205 | |
2206 #if !defined(NCONFIG) | |
2207 if (v_mon_trc_data_ind) | |
2208 ma_trc_data_ind(data_ind); | |
2209 | |
2210 /* IOT and FT trace */ | |
2211 if (data_ind->l2_channel NEQ L2_CHANNEL_CBCH AND | |
2212 data_ind->l2_channel NEQ L2_CHANNEL_SACCH) | |
2213 { | |
2214 /* Implements Measure#32: Row 90,...,101 */ | |
2215 if(data_ind->error_flag EQ VALID_BLOCK) | |
2216 { | |
2217 length = MAX_L2_FRAME_SIZE; | |
2218 valid = 1; | |
2219 } | |
2220 switch (data_ind->l2_frame.content[SI_CONTENTS_MSG_T]) | |
2221 { | |
2222 case D_SYS_INFO_1: | |
2223 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_1 block: Valid=%d", | |
2224 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2225 break; | |
2226 case D_SYS_INFO_2: | |
2227 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_2 block: Valid=%d", | |
2228 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2229 break; | |
2230 case D_SYS_INFO_2BIS: | |
2231 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_2BIS block: Valid=%d", | |
2232 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2233 break; | |
2234 case D_SYS_INFO_2TER: | |
2235 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_2TER block: Valid=%d", | |
2236 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2237 break; | |
2238 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
2239 case D_SYS_INFO_2QUATER: | |
2240 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_2QUATER block: Valid=%d", | |
2241 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2242 break; | |
2243 #endif | |
2244 case D_SYS_INFO_3: | |
2245 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_3 block: Valid=%d", | |
2246 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2247 break; | |
2248 case D_SYS_INFO_4: | |
2249 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_4 block: Valid=%d", | |
2250 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2251 break; | |
2252 #ifdef GPRS | |
2253 case D_SYS_INFO_13: | |
2254 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_SYS_INFO_13 block: Valid=%d", | |
2255 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2256 break; | |
2257 #endif | |
2258 case D_IMM_ASSIGN: | |
2259 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_IMM_ASSIGN block: Valid=%d", | |
2260 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2261 break; | |
2262 case D_IMM_ASSIGN_EXT: | |
2263 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_IMM_ASSIGN_EXT block: Valid=%d", | |
2264 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2265 break; | |
2266 case D_IMM_ASSIGN_REJ: | |
2267 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] D_IMM_ASSIGN_REJ block: Valid=%d", | |
2268 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2269 break; | |
2270 case D_PAG_REQ_1: | |
2271 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] PAG_REQ_1 DL block: Valid=%d", | |
2272 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2273 break; | |
2274 case D_PAG_REQ_2: | |
2275 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] PAG_REQ_2 DL block: Valid=%d", | |
2276 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2277 break; | |
2278 case D_PAG_REQ_3: | |
2279 TRACE_USER_CLASS_P2 (TC_USER4, "[%u] PAG_REQ_3 DL block: Valid=%d", | |
2280 ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK, valid); | |
2281 break; | |
2282 default: | |
2283 break; | |
2284 } | |
2285 switch (data_ind->l2_frame.content[SI_CONTENTS_MSG_T]) | |
2286 { | |
2287 case D_SYS_INFO_1: | |
2288 #ifdef TI_PS_HCOMM_CHANGE | |
2289 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2290 "D_SYS_INFO_1", | |
2291 data_ind->l2_frame.content, | |
2292 length); | |
2293 #else /* not TI_PS_HCOMM_CHANGE */ | |
2294 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2295 "D_SYS_INFO_1", | |
2296 data_ind->l2_frame.content, | |
2297 length); | |
2298 #endif /* TI_PS_HCOMM_CHANGE */ | |
2299 break; | |
2300 case D_SYS_INFO_2: | |
2301 #ifdef TI_PS_HCOMM_CHANGE | |
2302 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2303 "D_SYS_INFO_2", | |
2304 data_ind->l2_frame.content, | |
2305 length); | |
2306 #else /* not TI_PS_HCOMM_CHANGE */ | |
2307 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2308 "D_SYS_INFO_2", | |
2309 data_ind->l2_frame.content, | |
2310 length); | |
2311 #endif /* TI_PS_HCOMM_CHANGE */ | |
2312 break; | |
2313 case D_SYS_INFO_2BIS: | |
2314 #ifdef TI_PS_HCOMM_CHANGE | |
2315 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2316 "D_SYS_INFO_2BIS", | |
2317 data_ind->l2_frame.content, | |
2318 length); | |
2319 #else /* not TI_PS_HCOMM_CHANGE */ | |
2320 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2321 "D_SYS_INFO_2BIS", | |
2322 data_ind->l2_frame.content, | |
2323 length); | |
2324 #endif /* TI_PS_HCOMM_CHANGE */ | |
2325 break; | |
2326 case D_SYS_INFO_2TER: | |
2327 #ifdef TI_PS_HCOMM_CHANGE | |
2328 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2329 "D_SYS_INFO_2TER", | |
2330 data_ind->l2_frame.content, | |
2331 length); | |
2332 #else /* not TI_PS_HCOMM_CHANGE */ | |
2333 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2334 "D_SYS_INFO_2TER", | |
2335 data_ind->l2_frame.content, | |
2336 length); | |
2337 #endif /* TI_PS_HCOMM_CHANGE */ | |
2338 break; | |
2339 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
2340 case D_SYS_INFO_2QUATER: | |
2341 #ifdef TI_PS_HCOMM_CHANGE | |
2342 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2343 "D_SYS_INFO_2QUATER", | |
2344 data_ind->l2_frame.content, | |
2345 length); | |
2346 #else /* not TI_PS_HCOMM_CHANGE */ | |
2347 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2348 "D_SYS_INFO_2QUATER", | |
2349 data_ind->l2_frame.content, | |
2350 length); | |
2351 #endif /* TI_PS_HCOMM_CHANGE */ | |
2352 break; | |
2353 #endif | |
2354 case D_SYS_INFO_3: | |
2355 #ifdef TI_PS_HCOMM_CHANGE | |
2356 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2357 "D_SYS_INFO_3", | |
2358 data_ind->l2_frame.content, | |
2359 length); | |
2360 #else /* not TI_PS_HCOMM_CHANGE */ | |
2361 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2362 "D_SYS_INFO_3", | |
2363 data_ind->l2_frame.content, | |
2364 length); | |
2365 #endif /* TI_PS_HCOMM_CHANGE */ | |
2366 break; | |
2367 case D_SYS_INFO_4: | |
2368 #ifdef TI_PS_HCOMM_CHANGE | |
2369 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2370 "D_SYS_INFO_4", | |
2371 data_ind->l2_frame.content, | |
2372 length); | |
2373 #else /* not TI_PS_HCOMM_CHANGE */ | |
2374 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2375 "D_SYS_INFO_4", | |
2376 data_ind->l2_frame.content, | |
2377 length); | |
2378 #endif /* TI_PS_HCOMM_CHANGE */ | |
2379 break; | |
2380 #ifdef GPRS | |
2381 case D_SYS_INFO_13: | |
2382 #ifdef TI_PS_HCOMM_CHANGE | |
2383 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2384 "D_SYS_INFO_13", | |
2385 data_ind->l2_frame.content, | |
2386 length); | |
2387 #else /* not TI_PS_HCOMM_CHANGE */ | |
2388 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2389 "D_SYS_INFO_13", | |
2390 data_ind->l2_frame.content, | |
2391 length); | |
2392 #endif /* TI_PS_HCOMM_CHANGE */ | |
2393 break; | |
2394 #endif | |
2395 case D_IMM_ASSIGN: | |
2396 #ifdef TI_PS_HCOMM_CHANGE | |
2397 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2398 "D_IMM_ASSIGN", | |
2399 data_ind->l2_frame.content, | |
2400 length); | |
2401 #else /* not TI_PS_HCOMM_CHANGE */ | |
2402 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2403 "D_IMM_ASSIGN", | |
2404 data_ind->l2_frame.content, | |
2405 length); | |
2406 #endif /* TI_PS_HCOMM_CHANGE */ | |
2407 break; | |
2408 case D_IMM_ASSIGN_EXT: | |
2409 #ifdef TI_PS_HCOMM_CHANGE | |
2410 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2411 "D_IMM_ASSIGN_EXT", | |
2412 data_ind->l2_frame.content, | |
2413 length); | |
2414 #else /* not TI_PS_HCOMM_CHANGE */ | |
2415 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2416 "D_IMM_ASSIGN_EXT", | |
2417 data_ind->l2_frame.content, | |
2418 length); | |
2419 #endif /* TI_PS_HCOMM_CHANGE */ | |
2420 break; | |
2421 case D_IMM_ASSIGN_REJ: | |
2422 #ifdef TI_PS_HCOMM_CHANGE | |
2423 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2424 "D_IMM_ASSIGN_REJ", | |
2425 data_ind->l2_frame.content, | |
2426 length); | |
2427 #else /* not TI_PS_HCOMM_CHANGE */ | |
2428 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2429 "D_IMM_ASSIGN_REJ", | |
2430 data_ind->l2_frame.content, | |
2431 length); | |
2432 #endif /* TI_PS_HCOMM_CHANGE */ | |
2433 break; | |
2434 case D_PAG_REQ_1: | |
2435 #ifdef TI_PS_HCOMM_CHANGE | |
2436 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2437 "PAG_REQ_1 DL", | |
2438 data_ind->l2_frame.content, | |
2439 length); | |
2440 #else /* not TI_PS_HCOMM_CHANGE */ | |
2441 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2442 "PAG_REQ_1 DL", | |
2443 data_ind->l2_frame.content, | |
2444 length); | |
2445 #endif /* TI_PS_HCOMM_CHANGE */ | |
2446 break; | |
2447 case D_PAG_REQ_2: | |
2448 #ifdef TI_PS_HCOMM_CHANGE | |
2449 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2450 "PAG_REQ_2 DL", | |
2451 data_ind->l2_frame.content, | |
2452 length); | |
2453 #else /* not TI_PS_HCOMM_CHANGE */ | |
2454 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2455 "PAG_REQ_2 DL", | |
2456 data_ind->l2_frame.content, | |
2457 length); | |
2458 #endif /* TI_PS_HCOMM_CHANGE */ | |
2459 break; | |
2460 case D_PAG_REQ_3: | |
2461 #ifdef TI_PS_HCOMM_CHANGE | |
2462 TRACE_BINDUMP(_hCommPL , TC_USER4, | |
2463 "PAG_REQ_3 DL", | |
2464 data_ind->l2_frame.content, | |
2465 length); | |
2466 #else /* not TI_PS_HCOMM_CHANGE */ | |
2467 TRACE_BINDUMP(hCommPL , TC_USER4, | |
2468 "PAG_REQ_3 DL", | |
2469 data_ind->l2_frame.content, | |
2470 length); | |
2471 #endif /* TI_PS_HCOMM_CHANGE */ | |
2472 break; | |
2473 default: | |
2474 break; | |
2475 } | |
2476 } | |
2477 #endif /* !NCONFIG */ | |
2478 | |
2479 | |
2480 if (data_ind->l2_channel EQ L2_CHANNEL_CBCH) | |
2481 { | |
2482 cb_data_ind (data_ind); | |
2483 } | |
2484 else | |
2485 { | |
2486 if (data_ind->error_flag EQ VALID_BLOCK AND | |
2487 data_ind->l2_channel EQ L2_CHANNEL_SACCH) | |
2488 { | |
2489 /* | |
2490 * store Timing Advance contained in every decodable downlink SACCH frame | |
2491 */ | |
2492 nc_store_tav((USHORT)(data_ind->l2_frame.content[1] & 63)); | |
2493 } | |
2494 | |
2495 msg_t = data_ind->l2_frame.content[SI_CONTENTS_MSG_T]; | |
2496 switch (GET_STATE (STATE_MA)) | |
2497 { | |
2498 case MA_NULL: | |
2499 /* | |
2500 * no message expected | |
2501 */ | |
2502 break; | |
2503 case MA_CELL_SELECTION: | |
2504 if (data_ind->error_flag EQ VALID_BLOCK) | |
2505 { | |
2506 ALR_TRACE_MAIN_VALID_BLOCK(msg_t); | |
2507 | |
2508 switch (msg_t) | |
2509 { | |
2510 case D_SYS_INFO_1: | |
2511 case D_SYS_INFO_2: | |
2512 case D_SYS_INFO_2BIS: | |
2513 case D_SYS_INFO_2TER: | |
2514 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
2515 case D_SYS_INFO_2QUATER: | |
2516 #endif | |
2517 case D_SYS_INFO_3: | |
2518 case D_SYS_INFO_4: | |
2519 #ifdef GPRS | |
2520 case D_SYS_INFO_13: | |
2521 #endif | |
2522 switch(data_ind->l2_channel) | |
2523 { | |
2524 case L2_CHANNEL_NBCCH: | |
2525 if (data_ind->tc EQ 0 AND msg_t NEQ D_SYS_INFO_1) | |
2526 ma_sync_ind (CS_SYS_INFO_1_NOT_NEEDED, | |
2527 ARFCN_TO_G23(data_ind->radio_freq)); | |
2528 /*lint -fallthrough*/ | |
2529 case L2_CHANNEL_EBCCH: | |
2530 ma_send_unitdata (data_ind); | |
2531 ma_fill_sys_buffer (data_ind, msg_t); | |
2532 | |
2533 ma_set_si_bitmap(msg_t); | |
2534 | |
2535 ALR_EM_IDLE_MODE_BCCH_PARAMETER_CHANGED; | |
2536 cs_increment_bfc(); | |
2537 | |
2538 break; | |
2539 default: | |
2540 ALR_TRACE_MAIN ("stray SI"); | |
2541 break; | |
2542 } | |
2543 break; | |
2544 default: | |
2545 break; | |
2546 } | |
2547 } | |
2548 else | |
2549 { | |
2550 ALR_TRACE_MAIN ("INVALID BLOCK"); | |
2551 if (data_ind->l2_channel EQ L2_CHANNEL_NBCCH OR | |
2552 data_ind->l2_channel EQ L2_CHANNEL_EBCCH) | |
2553 { | |
2554 ma_error_ind (CS_BCCH_READ_ERROR, | |
2555 ARFCN_TO_G23(data_ind->radio_freq)); | |
2556 cs_decrement_bfc(); | |
2557 } | |
2558 } | |
2559 break; | |
2560 case MA_IDLE: | |
2561 if (data_ind->error_flag EQ VALID_BLOCK) | |
2562 { | |
2563 switch (msg_t) | |
2564 { | |
2565 case D_SYS_INFO_2: | |
2566 /* | |
2567 * setting ncc permitted directly after receive sys info 2 | |
2568 */ | |
2569 nc_check_new_ncc_permitted (data_ind->l2_frame.content[SI_CONTENTS_MSG_T+17]); | |
2570 /*lint -fallthrough*/ | |
2571 case D_SYS_INFO_1: | |
2572 case D_SYS_INFO_2BIS: | |
2573 case D_SYS_INFO_2TER: | |
2574 case D_SYS_INFO_3: | |
2575 case D_SYS_INFO_4: | |
2576 if(data_ind->l2_channel NEQ L2_CHANNEL_NBCCH) | |
2577 { | |
2578 ALR_TRACE_MAIN ("stray SI"); | |
2579 } | |
2580 | |
2581 if (data_ind->tc EQ 0 AND msg_t NEQ D_SYS_INFO_1) | |
2582 { | |
2583 ma_sync_ind (CS_SYS_INFO_1_NOT_NEEDED, | |
2584 ARFCN_TO_G23(data_ind->radio_freq)); | |
2585 alr_data->pch_data.si_bitmap |= SYSTEM_INFO_1_READ; | |
2586 } | |
2587 | |
2588 if( alr_data->pch_data.reorg_bcch_reading EQ TRUE) | |
2589 { | |
2590 if(msg_t EQ D_SYS_INFO_1) | |
2591 alr_data->pch_data.si_bitmap |= SYSTEM_INFO_1_READ; | |
2592 else if(msg_t EQ D_SYS_INFO_2) | |
2593 alr_data->pch_data.si_bitmap |= SYSTEM_INFO_2_READ; | |
2594 else if(msg_t EQ D_SYS_INFO_3) | |
2595 alr_data->pch_data.si_bitmap |= SYSTEM_INFO_3_READ; | |
2596 else if(msg_t EQ D_SYS_INFO_4) | |
2597 alr_data->pch_data.si_bitmap |= SYSTEM_INFO_4_READ; | |
2598 | |
2599 ma_set_si_bitmap(msg_t); | |
2600 | |
2601 #ifdef GPRS | |
2602 if( !gprs_alr_is_supported() ) | |
2603 #endif | |
2604 { | |
2605 if( (alr_data->pch_data.si_bitmap & ALL_SI_READ_EXCEPT_SI13) | |
2606 EQ ALL_SI_READ_EXCEPT_SI13) | |
2607 { | |
2608 alr_data->pch_data.reorg_bcch_reading = FALSE; | |
2609 if((alr_data->pch_data.pl_idle.page_mode EQ PGM_NORMAL) OR | |
2610 (alr_data->pch_data.pl_idle.page_mode EQ PGM_EXTENDED)) | |
2611 { | |
2612 sc_start_periodic(); | |
2613 } | |
2614 } | |
2615 } | |
2616 } | |
2617 if (!ma_compare_sys_buffer (data_ind, msg_t)) | |
2618 { | |
2619 ALR_TRACE_MAIN_SI_UNEQ(data_ind->l2_channel); | |
2620 | |
2621 ma_send_unitdata (data_ind); | |
2622 ma_fill_sys_buffer (data_ind, msg_t); | |
2623 | |
2624 ALR_EM_IDLE_MODE_BCCH_PARAMETER_CHANGED; | |
2625 | |
2626 } | |
2627 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
2628 if ( (msg_t EQ D_SYS_INFO_2) OR (msg_t EQ D_SYS_INFO_2BIS) OR (msg_t EQ D_SYS_INFO_2TER) ) | |
2629 { | |
2630 if ( (alr_data->nc_data.si2_count NEQ NOT_PRESENT_8BIT ) AND | |
2631 (alr_data->nc_data.si2_count NEQ 0) ) | |
2632 alr_data->nc_data.si2_count--; | |
2633 /*Required SI-2 variants have been acquired, now we will configure | |
2634 L1 for SI-2quater if it's required to be configured*/ | |
2635 if ((alr_data->nc_data.si2quater_status NEQ SI2QUATER_ABSENT ) AND | |
2636 (alr_data->nc_data.si2quater_pos EQ SI2QUATER_ON_EBCCH) AND | |
2637 (alr_data->nc_data.si2_count EQ 0)) | |
2638 { | |
2639 ma_scell_mon_si2quater_ebcch(); | |
2640 alr_data->nc_data.si2_count = NOT_PRESENT_8BIT; | |
2641 } | |
2642 } | |
2643 break; | |
2644 case D_SYS_INFO_2QUATER: | |
2645 ALR_TRACE_MAIN_SI_UNEQ(data_ind->l2_channel); | |
2646 ma_send_unitdata (data_ind); | |
2647 #endif | |
2648 break; | |
2649 #ifdef GPRS | |
2650 case D_SYS_INFO_13: | |
2651 if(gprs_alr_is_supported()) | |
2652 { | |
2653 alr_data->pch_data.si_bitmap |= SYSTEM_INFO_13_READ; | |
2654 alr_data->pch_data.reorg_bcch_reading = FALSE; | |
2655 } | |
2656 if(! pch_mode_reorg() AND gprs_alr_is_supported()) | |
2657 { | |
2658 /* stop scell BCCH */ | |
2659 ma_stop_scell_bcch_req(); | |
2660 } | |
2661 ma_send_unitdata (data_ind); | |
2662 ma_fill_sys_buffer (data_ind, msg_t); | |
2663 | |
2664 ALR_EM_IDLE_MODE_BCCH_PARAMETER_CHANGED; | |
2665 | |
2666 ALR_TRACE_MAIN ("SI13"); | |
2667 break; | |
2668 #endif /* GPRS */ | |
2669 | |
2670 case D_PAG_REQ_1: | |
2671 ALR_TRACE_MAIN("PG1"); | |
2672 | |
2673 pch_check_pag_1 (data_ind); | |
2674 | |
2675 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2676 { | |
2677 /* | |
2678 * check only if it is the own paging group | |
2679 */ | |
2680 #ifdef GPRS | |
2681 gprs_check_page_mode(data_ind); | |
2682 #else | |
2683 pch_check_page_mode (data_ind); | |
2684 #endif /* GPRS */ | |
2685 pch_increment_dlt (); | |
2686 } | |
2687 break; | |
2688 case D_PAG_REQ_2: | |
2689 ALR_TRACE_MAIN ("PG2"); | |
2690 if (alr_data->pch_data.pl_idle.page_mode EQ PGM_NORMAL) | |
2691 { | |
2692 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2693 pch_check_pag_2 (data_ind); | |
2694 else | |
2695 { | |
2696 ALR_TRACE_MAIN ("PCH block skipped"); | |
2697 } | |
2698 } | |
2699 else | |
2700 pch_check_pag_2 (data_ind); | |
2701 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2702 { | |
2703 /* check only if it is the own paging group */ | |
2704 #ifdef GPRS | |
2705 gprs_check_page_mode(data_ind); | |
2706 #else | |
2707 pch_check_page_mode (data_ind); | |
2708 #endif /* GPRS */ | |
2709 pch_increment_dlt (); | |
2710 } | |
2711 break; | |
2712 case D_PAG_REQ_3: | |
2713 ALR_TRACE_MAIN ("PG3"); | |
2714 | |
2715 if (alr_data->pch_data.pl_idle.page_mode EQ PGM_NORMAL) | |
2716 { | |
2717 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2718 pch_check_pag_3 (data_ind); | |
2719 else | |
2720 { | |
2721 ALR_TRACE_MAIN ("PCH block skipped"); | |
2722 } | |
2723 } | |
2724 else | |
2725 pch_check_pag_3 (data_ind); | |
2726 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2727 { | |
2728 /* check only if it is the own paging group */ | |
2729 #ifdef GPRS | |
2730 gprs_check_page_mode(data_ind); | |
2731 #else | |
2732 pch_check_page_mode (data_ind); | |
2733 #endif/* GPRS */ | |
2734 pch_increment_dlt (); | |
2735 } | |
2736 break; | |
2737 case D_IMM_ASSIGN: | |
2738 #ifdef GPRS | |
2739 gprs_alr_check_downlink_assign(data_ind); | |
2740 /*lint -fallthrough*/ | |
2741 #endif | |
2742 case D_IMM_ASSIGN_EXT: | |
2743 case D_IMM_ASSIGN_REJ: | |
2744 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2745 { | |
2746 /* check only if it is the own paging group */ | |
2747 #ifdef GPRS | |
2748 gprs_check_page_mode(data_ind); | |
2749 #else | |
2750 pch_check_page_mode (data_ind); | |
2751 #endif /* GPRS */ | |
2752 pch_increment_dlt (); | |
2753 } | |
2754 break; | |
2755 default: | |
2756 break; | |
2757 } /* message type */ | |
2758 } | |
2759 else | |
2760 { | |
2761 /* | |
2762 * invalid block | |
2763 */ | |
2764 ALR_TRACE_MAIN ("INVALID"); | |
2765 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2766 pch_decrement_dlt (); | |
2767 } | |
2768 break; | |
2769 #ifdef GPRS | |
2770 case MA_PTM: | |
2771 if (data_ind->error_flag EQ VALID_BLOCK) | |
2772 { | |
2773 switch (msg_t) | |
2774 { | |
2775 case D_SYS_INFO_2: | |
2776 /* | |
2777 * setting ncc permitted directly after receive sys info 2 | |
2778 */ | |
2779 nc_check_new_ncc_permitted (data_ind->l2_frame.content[SI_CONTENTS_MSG_T+17]); | |
2780 /*lint -fallthrough*/ | |
2781 case D_SYS_INFO_1: | |
2782 case D_SYS_INFO_2BIS: | |
2783 case D_SYS_INFO_2TER: | |
2784 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
2785 case D_SYS_INFO_2QUATER: | |
2786 #endif | |
2787 case D_SYS_INFO_3: | |
2788 case D_SYS_INFO_4: | |
2789 if(data_ind->l2_channel NEQ L2_CHANNEL_NBCCH) | |
2790 { | |
2791 ALR_TRACE_MAIN ("stray SI"); | |
2792 } | |
2793 if (data_ind->tc EQ 0 AND msg_t NEQ D_SYS_INFO_1) | |
2794 ma_sync_ind (CS_SYS_INFO_1_NOT_NEEDED, | |
2795 ARFCN_TO_G23(data_ind->radio_freq)); | |
2796 if (!ma_compare_sys_buffer (data_ind, msg_t)) | |
2797 { | |
2798 ALR_TRACE_MAIN_SI_UNEQ(data_ind->l2_channel); | |
2799 | |
2800 ma_send_unitdata (data_ind); | |
2801 ma_fill_sys_buffer (data_ind, msg_t); | |
2802 | |
2803 ALR_EM_IDLE_MODE_BCCH_PARAMETER_CHANGED; | |
2804 | |
2805 } | |
2806 break; | |
2807 case D_SYS_INFO_13: | |
2808 /* stop scell BCCH */ | |
2809 ma_stop_scell_bcch_req(); | |
2810 | |
2811 ma_send_unitdata (data_ind); | |
2812 | |
2813 ALR_EM_IDLE_MODE_BCCH_PARAMETER_CHANGED; | |
2814 | |
2815 ma_fill_sys_buffer (data_ind, msg_t); | |
2816 break; | |
2817 case D_PAG_REQ_1: | |
2818 ALR_TRACE_MAIN("PG1"); | |
2819 | |
2820 pch_check_pag_1 (data_ind); | |
2821 | |
2822 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2823 { | |
2824 /* | |
2825 * check only if it is the own paging group | |
2826 */ | |
2827 //pch_increment_dlt (); | |
2828 } | |
2829 break; | |
2830 case D_PAG_REQ_2: | |
2831 pch_check_pag_2 (data_ind); | |
2832 //pch_increment_dlt (); | |
2833 | |
2834 break; | |
2835 case D_PAG_REQ_3: | |
2836 pch_check_pag_3 (data_ind); | |
2837 //pch_increment_dlt (); | |
2838 break; | |
2839 default: | |
2840 break; | |
2841 } | |
2842 } | |
2843 break; | |
2844 #endif /* GPRS */ | |
2845 case MA_CELL_RESELECTION: | |
2846 if (data_ind->error_flag EQ VALID_BLOCK) | |
2847 { | |
2848 ALR_TRACE_MAIN_CR(msg_t); | |
2849 | |
2850 switch (msg_t) | |
2851 { | |
2852 case D_IMM_ASSIGN: | |
2853 #ifdef GPRS | |
2854 TRACE_EVENT_P1 ("downlink assign %02x", data_ind->l2_frame.content[3]); | |
2855 gprs_alr_check_downlink_assign(data_ind); | |
2856 /*lint -fallthrough*/ | |
2857 #endif | |
2858 case D_IMM_ASSIGN_EXT: | |
2859 case D_IMM_ASSIGN_REJ: | |
2860 break; | |
2861 case D_PAG_REQ_1: | |
2862 ALR_TRACE_MAIN ("PG1"); | |
2863 pch_check_pag_1 (data_ind); | |
2864 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2865 { | |
2866 pch_increment_dlt (); | |
2867 pch_check_page_mode_cr (data_ind); | |
2868 } | |
2869 break; | |
2870 case D_PAG_REQ_2: | |
2871 ALR_TRACE_MAIN ("PG2"); | |
2872 pch_check_pag_2 (data_ind); | |
2873 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2874 { | |
2875 pch_increment_dlt (); | |
2876 pch_check_page_mode_cr (data_ind); | |
2877 } | |
2878 break; | |
2879 case D_PAG_REQ_3: | |
2880 ALR_TRACE_MAIN ("PG3"); | |
2881 pch_check_pag_3 (data_ind); | |
2882 if (data_ind->l2_channel EQ L2_CHANNEL_PCH) | |
2883 { | |
2884 pch_increment_dlt (); | |
2885 pch_check_page_mode_cr (data_ind); | |
2886 } | |
2887 break; | |
2888 case D_SYS_INFO_1: | |
2889 case D_SYS_INFO_2: | |
2890 case D_SYS_INFO_2BIS: | |
2891 case D_SYS_INFO_2TER: | |
2892 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
2893 case D_SYS_INFO_2QUATER: | |
2894 #endif | |
2895 case D_SYS_INFO_3: | |
2896 case D_SYS_INFO_4: | |
2897 #ifdef GPRS | |
2898 case D_SYS_INFO_13: | |
2899 #endif | |
2900 ALR_TRACE_MAIN ("cr si"); | |
2901 if (data_ind->tc EQ 0 AND msg_t NEQ D_SYS_INFO_1) | |
2902 ma_sync_ind (CS_SYS_INFO_1_NOT_NEEDED, ARFCN_TO_G23(data_ind->radio_freq)); | |
2903 ma_send_unitdata (data_ind); | |
2904 ma_fill_sys_buffer (data_ind, msg_t); | |
2905 | |
2906 ma_set_si_bitmap(msg_t); | |
2907 ALR_EM_IDLE_MODE_BCCH_PARAMETER_CHANGED; | |
2908 | |
2909 /* | |
2910 * When having received all SI in cell reselection state RR will | |
2911 * send an MPH_IDLE_REQ and ALR will send an MPHC_START_CCCH_REQ | |
2912 * This is not a good timing for FTA 20.19 because L1 is then | |
2913 * unable to detect a paging for some blocks. The test device will | |
2914 * not send the paging near the SI3. Therefore the | |
2915 * MPHC_START_CCCH_REQ is sent here (and may be overwritten be the | |
2916 * later when ALR receives the MPH_IDLE_REQ with other parameters). | |
2917 */ | |
2918 if (msg_t EQ D_SYS_INFO_3 AND | |
2919 alr_data->pch_data.imsi[0] AND | |
2920 ARFCN_TO_G23(data_ind->radio_freq) EQ alr_data->serving_cell) | |
2921 pch_config_resel(data_ind); | |
2922 break; | |
2923 default: | |
2924 break; | |
2925 } | |
2926 } | |
2927 else /* invalid block */ | |
2928 { | |
2929 if (data_ind->l2_channel EQ L2_CHANNEL_NBCCH OR | |
2930 data_ind->l2_channel EQ L2_CHANNEL_EBCCH) | |
2931 { | |
2932 ALR_TRACE_MAIN ("INVALID BLOCK"); | |
2933 ma_error_ind (CS_BCCH_READ_ERROR, | |
2934 ARFCN_TO_G23(data_ind->radio_freq)); | |
2935 cs_decrement_bfc(); | |
2936 } | |
2937 } | |
2938 | |
2939 break; | |
2940 case MA_CON_EST: | |
2941 if (data_ind->error_flag EQ VALID_BLOCK) | |
2942 { | |
2943 switch (msg_t) | |
2944 { | |
2945 case D_IMM_ASSIGN: | |
2946 case D_IMM_ASSIGN_EXT: | |
2947 case D_IMM_ASSIGN_REJ: | |
2948 ALR_TRACE_MAIN ("IA"); | |
2949 ma_send_unitdata (data_ind); | |
2950 break; | |
2951 #ifdef GPRS | |
2952 case D_PAG_REQ_1: | |
2953 pch_check_pag_1 (data_ind); | |
2954 break; | |
2955 case D_PAG_REQ_2: | |
2956 pch_check_pag_2 (data_ind); | |
2957 break; | |
2958 case D_PAG_REQ_3: | |
2959 pch_check_pag_3 (data_ind); | |
2960 break; | |
2961 #endif /* GPRS */ | |
2962 default: | |
2963 break; | |
2964 } | |
2965 } | |
2966 break; | |
2967 case MA_DEDICATED: | |
2968 if (data_ind->error_flag EQ VALID_BLOCK) | |
2969 { | |
2970 switch (data_ind->l2_channel) | |
2971 { | |
2972 case L2_CHANNEL_SACCH: | |
2973 if ((data_ind->l2_frame.content[3] & 0xEF) EQ 3) /* layer 2 Control field octet */ | |
2974 { | |
2975 /* | |
2976 * check control field of l2 header | |
2977 * UI Frame received | |
2978 */ | |
2979 UBYTE msg_t = data_ind->l2_frame.content[6]; /* layer 3 Message Type octet */ | |
2980 | |
2981 switch (msg_t) | |
2982 { | |
2983 case D_SYS_INFO_6: | |
2984 /* | |
2985 * setting ncc permitted directly after receive sys info 6 | |
2986 */ | |
2987 nc_check_new_ncc_permitted (data_ind->l2_frame.content[15]); | |
2988 | |
2989 /*lint -fallthrough*/ | |
2990 case D_SYS_INFO_5: | |
2991 case D_SYS_INFO_5BIS: | |
2992 case D_SYS_INFO_5TER: | |
2993 | |
2994 if (!ma_compare_dedi_sys_buffer (data_ind, msg_t)) | |
2995 { | |
2996 ma_send_dedi_unitdata (data_ind); | |
2997 ma_fill_dedi_sys_buffer (data_ind, msg_t); | |
2998 } | |
2999 break; | |
3000 | |
3001 case D_EXT_MEAS_ORDER: | |
3002 ma_send_dedi_unitdata (data_ind); | |
3003 break; | |
3004 | |
3005 default: | |
3006 break; | |
3007 } | |
3008 } | |
3009 else | |
3010 { | |
3011 /* | |
3012 * no unacknowledged frame or short PD header (format type Bter) | |
3013 * must be handled by DL | |
3014 * is forwarded in original primitive format | |
3015 */ | |
3016 ma_dedi_data_out ((T_PH_DATA_IND *)data_ind); | |
3017 data_ind = NULL; /* must not be freed by ALR */ | |
3018 } | |
3019 dedi_increment_rlt (); | |
3020 break; | |
3021 default: | |
3022 break; | |
3023 } /*l2_channel*/ | |
3024 } | |
3025 else | |
3026 { | |
3027 /* invalid block */ | |
3028 if (data_ind->l2_channel EQ L2_CHANNEL_SACCH) | |
3029 dedi_decrement_rlt (); | |
3030 } | |
3031 break; | |
3032 default: | |
3033 break; | |
3034 } | |
3035 } | |
3036 | |
3037 if (data_ind) | |
3038 { | |
3039 PFREE (data_ind); | |
3040 } | |
3041 } | |
3042 | |
3043 | |
3044 /* | |
3045 +----------------------------------------------------------------------+ | |
3046 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3047 | STATE : code ROUTINE : ma_mphc_change_frequency_cnf | | |
3048 +----------------------------------------------------------------------+ | |
3049 | |
3050 PURPOSE : Process the primitive MPHC_CHANGE_FREQUENCY_CON. | |
3051 | |
3052 */ | |
3053 | |
3054 GLOBAL void ma_mphc_change_frequency_cnf (T_MPHC_CHANGE_FREQUENCY_CON* change_frequency_cnf) | |
3055 { | |
3056 PFREE (change_frequency_cnf); | |
3057 dedi_change_freq_cnf (); | |
3058 } | |
3059 | |
3060 /* | |
3061 +--------------------------------------------------------------------+ | |
3062 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3063 | STATE : code ROUTINE : ma_mphc_async_ho_cnf | | |
3064 +--------------------------------------------------------------------+ | |
3065 | |
3066 PURPOSE : Process the primitive MPHC_ASYNC_HO_CNF. | |
3067 | |
3068 */ | |
3069 | |
3070 GLOBAL void ma_mphc_async_ho_cnf (T_MPHC_ASYNC_HO_CON* async_ho_cnf) | |
3071 { | |
3072 PFREE (async_ho_cnf); | |
3073 dedi_ho_cnf(HO_TYPE_ASYNC); | |
3074 } | |
3075 | |
3076 /* | |
3077 +---------------------------------------------------------------------+ | |
3078 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3079 | STATE : code ROUTINE : ma_mphc_channel_assign_cnf | | |
3080 +---------------------------------------------------------------------+ | |
3081 | |
3082 PURPOSE : Process the primitive MPHC_CHANNEL_ASSIGN_CON. | |
3083 | |
3084 */ | |
3085 | |
3086 GLOBAL void ma_mphc_channel_assign_cnf (T_MPHC_CHANNEL_ASSIGN_CON* channel_assign_cnf) | |
3087 { | |
3088 PFREE (channel_assign_cnf); | |
3089 #if defined(DL_TRACE_ENABLED) | |
3090 DL_OFFLINE_TRACE ("MPHC_CHANNEL_ASSIGN_CON"); | |
3091 #else | |
3092 SYST_TRACE ("dedi chan ass con"); | |
3093 #endif /* DL_TRACE_ENABLED */ | |
3094 dedi_chan_ass_cnf (); | |
3095 } | |
3096 | |
3097 /* | |
3098 +--------------------------------------------------------------------+ | |
3099 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3100 | STATE : code ROUTINE : ma_mphc_handover_fail_cnf | | |
3101 +--------------------------------------------------------------------+ | |
3102 | |
3103 PURPOSE : Process the primitive MPHC_HANDOVER_FAIL_CON. | |
3104 | |
3105 */ | |
3106 | |
3107 GLOBAL void ma_mphc_handover_fail_cnf (T_MPHC_HANDOVER_FAIL_CON* handover_fail_cnf) | |
3108 { | |
3109 PFREE (handover_fail_cnf); | |
3110 dedi_ho_fail_cnf (); | |
3111 } | |
3112 | |
3113 /* | |
3114 +--------------------------------------------------------------------+ | |
3115 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3116 | STATE : code ROUTINE : ma_mphc_immed_assign_cnf | | |
3117 +--------------------------------------------------------------------+ | |
3118 | |
3119 PURPOSE : Process the primitive MPHC_IMMED_ASSIGN_CON. | |
3120 | |
3121 */ | |
3122 | |
3123 GLOBAL void ma_mphc_immed_assign_cnf (T_MPHC_IMMED_ASSIGN_CON* immed_assign_cnf) | |
3124 { | |
3125 PFREE (immed_assign_cnf); | |
3126 #if defined(DL_TRACE_ENABLED) | |
3127 DL_OFFLINE_TRACE ("MPHC_IMMED_ASSIGN_CON"); | |
3128 #endif /* DL_TRACE_ENABLED */ | |
3129 dedi_imm_ass_cnf (); | |
3130 } | |
3131 | |
3132 /* | |
3133 +--------------------------------------------------------------------+ | |
3134 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3135 | STATE : code ROUTINE : ma_mphc_pre_sync_ho_cnf | | |
3136 +--------------------------------------------------------------------+ | |
3137 | |
3138 PURPOSE : Process the primitive MPHC_PRE_SYNC_HO_CON. | |
3139 | |
3140 */ | |
3141 | |
3142 GLOBAL void ma_mphc_pre_sync_ho_cnf (T_MPHC_PRE_SYNC_HO_CON* pre_sync_ho_cnf) | |
3143 { | |
3144 PFREE (pre_sync_ho_cnf); | |
3145 dedi_ho_cnf(HO_TYPE_PRE_SYNC); | |
3146 } | |
3147 | |
3148 | |
3149 /* | |
3150 +--------------------------------------------------------------------+ | |
3151 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3152 | STATE : code ROUTINE : ma_mphc_sync_ho_cnf | | |
3153 +--------------------------------------------------------------------+ | |
3154 | |
3155 PURPOSE : Process the primitive MPHC_SYNC_HO_CON. | |
3156 | |
3157 */ | |
3158 | |
3159 GLOBAL void ma_mphc_sync_ho_cnf (T_MPHC_SYNC_HO_CON* sync_ho_cnf) | |
3160 { | |
3161 PFREE (sync_ho_cnf); | |
3162 dedi_ho_cnf(HO_TYPE_SYNC); | |
3163 } | |
3164 | |
3165 /* | |
3166 +--------------------------------------------------------------------+ | |
3167 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3168 | STATE : code ROUTINE : ma_mphc_ta_fail_ind | | |
3169 +--------------------------------------------------------------------+ | |
3170 | |
3171 PURPOSE : Process the primitive MPHC_TA_FAIL_IND. | |
3172 | |
3173 */ | |
3174 | |
3175 GLOBAL void ma_mphc_ta_fail_ind (T_MPHC_TA_FAIL_IND* ta_fail_ind) | |
3176 { | |
3177 PFREE (ta_fail_ind); | |
3178 dedi_ta_fail_ind (); | |
3179 } | |
3180 | |
3181 /* | |
3182 +-----------------------------------------------------------------------+ | |
3183 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3184 | STATE : code ROUTINE : ma_mphc_handover_finished_ind | | |
3185 +-----------------------------------------------------------------------+ | |
3186 | |
3187 PURPOSE : Process the primitive MPHC_HANDOVER_FINISHED. | |
3188 | |
3189 */ | |
3190 | |
3191 GLOBAL void ma_mphc_handover_finished_ind (T_MPHC_HANDOVER_FINISHED* ho_finished) | |
3192 { | |
3193 dedi_ho_finished (ho_finished); | |
3194 PFREE (ho_finished); | |
3195 } | |
3196 | |
3197 /* | |
3198 +--------------------------------------------------------------------+ | |
3199 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3200 | STATE : code ROUTINE : ma_mphc_meas_report_ind_emo| | |
3201 +--------------------------------------------------------------------+ | |
3202 | |
3203 PURPOSE : Process the primitive MPHC_MEAS_REPORT for | |
3204 Extended Measurement procedure. | |
3205 | |
3206 */ | |
3207 | |
3208 LOCAL BOOL ma_mphc_meas_report_ind_emo (T_MPHC_MEAS_REPORT* mphc_meas_report) | |
3209 { | |
3210 GET_INSTANCE_DATA; | |
3211 UBYTE emo_ba_id = alr_data->dedi_data.emo_ba_id; | |
3212 UBYTE rep_ba_id = mphc_meas_report->ba_id; | |
3213 | |
3214 if ( INRANGE(RR_BA_LOW,rep_ba_id,RR_BA_HIGH) AND | |
3215 mphc_meas_report->meas_valid ) | |
3216 { | |
3217 if ( rep_ba_id EQ emo_ba_id ) | |
3218 { | |
3219 T_ncell_meas *ncell_meas = &mphc_meas_report->ncell_meas; | |
3220 T_res_list *res_list = &ncell_meas->res_list[0]; | |
3221 T_meas_results *meas_results; | |
3222 USHORT k,n; | |
3223 UBYTE nmax; | |
3224 | |
3225 PALLOC (mph_emo_meas_ind, MPH_EMO_MEAS_IND); | |
3226 | |
3227 meas_results = &mph_emo_meas_ind->meas_results[0]; | |
3228 | |
3229 mph_emo_meas_ind->ba_id = mphc_meas_report->ba_id; | |
3230 mph_emo_meas_ind->dtx = mphc_meas_report->dtx_used; | |
3231 | |
3232 nmax = sizeof mph_emo_meas_ind->meas_results / | |
3233 sizeof mph_emo_meas_ind->meas_results[0]; | |
3234 | |
3235 if ( mphc_meas_report->no_of_ncells_meas > nmax ) | |
3236 mphc_meas_report->no_of_ncells_meas = nmax; | |
3237 | |
3238 n = mph_emo_meas_ind->c_meas_results = mphc_meas_report->no_of_ncells_meas; | |
3239 for ( k = 0; k < n; k++ ) | |
3240 { | |
3241 SHORT rx_lev = (SHORT)res_list[k].rxlev_acc / | |
3242 (BYTE) res_list[k].rxlev_nbr_meas; | |
3243 | |
3244 if ( rx_lev < 0 ) | |
3245 rx_lev = 0; | |
3246 | |
3247 meas_results[k].rx_lev = (UBYTE) rx_lev; | |
3248 meas_results[k].arfcn = ARFCN_TO_G23 ( res_list[k].bcch_freq ); | |
3249 } | |
3250 | |
3251 PSENDX(RR, mph_emo_meas_ind); | |
3252 } | |
3253 return TRUE; /* primitive handled */ | |
3254 } | |
3255 | |
3256 return FALSE; /* indicate that the primitive has not been handled */ | |
3257 } | |
3258 | |
3259 /* | |
3260 +--------------------------------------------------------------------+ | |
3261 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3262 | STATE : code ROUTINE : ma_mphc_meas_report_ind | | |
3263 +--------------------------------------------------------------------+ | |
3264 | |
3265 PURPOSE : Process the primitive MPHC_MEAS_REPORT. | |
3266 | |
3267 */ | |
3268 | |
3269 GLOBAL void ma_mphc_meas_report_ind (T_MPHC_MEAS_REPORT* report) | |
3270 { | |
3271 GET_INSTANCE_DATA; | |
3272 switch (GET_STATE (STATE_MA)) | |
3273 { | |
3274 case MA_DEDICATED: | |
3275 | |
3276 if (report->meas_valid) | |
3277 { | |
3278 if ( ma_mphc_meas_report_ind_emo ( report ) ) | |
3279 { | |
3280 PFREE ( report ); /*report isn't used any more*/ | |
3281 return; | |
3282 } | |
3283 nc_report_dedicated (report); | |
3284 } | |
3285 else | |
3286 { | |
3287 PALLOC (rr_report, MPH_MEASUREMENT_IND); | |
3288 memset (rr_report, 0, sizeof (T_MPH_MEASUREMENT_IND)); | |
3289 | |
3290 #ifdef GPRS | |
3291 rr_report->gprs_sync = NORMAL_MEAS_REP; | |
3292 #endif | |
3293 | |
3294 if (alr_data->nc_data.update) | |
3295 nc_fill_report_sc_dedi (rr_report, 0); | |
3296 ma_nc_report_res (rr_report); | |
3297 } | |
3298 alr_data->nc_data.update = FALSE; | |
3299 break; | |
3300 default: | |
3301 break; | |
3302 } | |
3303 | |
3304 PFREE (report); | |
3305 } | |
3306 | |
3307 /* | |
3308 +--------------------------------------------------------------------+ | |
3309 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3310 | STATE : code ROUTINE : mphc_adc_ind | | |
3311 +--------------------------------------------------------------------+ | |
3312 | |
3313 PURPOSE : Process the primitive CST_ADC_RESULT. | |
3314 */ | |
3315 | |
3316 | |
3317 GLOBAL void ma_mphc_adc_ind (T_MPHC_ADC_IND *adc_results) | |
3318 { | |
3319 /* | |
3320 * FreeCalypso note: in the TCS211 version this function forwarded | |
3321 * the ADC results to the CST entity, but in the LoCosto version | |
3322 * that code has been deleted w/o explanation. The proper course | |
3323 * of action for FreeCalypso remains to be decided. | |
3324 */ | |
3325 PFREE (adc_results); | |
3326 } | |
3327 | |
3328 /* ------------------------------------------------------------------- | |
3329 * ------------------------------------------------------------------- | |
3330 * SIGNAL Processing functions | |
3331 * These are called by the other ALR processes | |
3332 * ------------------------------------------------------------------- | |
3333 * ------------------------------------------------------------------- | |
3334 */ | |
3335 | |
3336 /* | |
3337 +--------------------------------------------------------------------+ | |
3338 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3339 | STATE : code ROUTINE : ma_rach_ra_req | | |
3340 +--------------------------------------------------------------------+ | |
3341 | |
3342 PURPOSE : Process the signal rach_ra_req from SDL process | |
3343 RACH_Control. | |
3344 | |
3345 */ | |
3346 | |
3347 GLOBAL void ma_rach_ra_req (T_MPHC_RA_REQ * mph_ra_req) | |
3348 { | |
3349 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
3350 ALR_TRACE_MAIN_RACH (mph_ra_req->txpwr); | |
3351 #else | |
3352 ALR_TRACE_MAIN_RACH (mph_ra_req->powerclass_gsm, mph_ra_req->txpwr); | |
3353 #endif | |
3354 #ifdef TI_PS_HCOMM_CHANGE | |
3355 TRACE_BINDUMP(_hCommPL, | |
3356 TC_USER4, | |
3357 "CHANNEL_REQ UL", | |
3358 &mph_ra_req->channel_request, | |
3359 sizeof(mph_ra_req->channel_request)); | |
3360 #else | |
3361 TRACE_BINDUMP(hCommPL, | |
3362 TC_USER4, | |
3363 "CHANNEL_REQ UL", | |
3364 &mph_ra_req->channel_request, | |
3365 sizeof(mph_ra_req->channel_request)); | |
3366 #endif /* TI_PS_HCOMM_CHANGE */ | |
3367 | |
3368 PSENDX (L1, mph_ra_req); | |
3369 } | |
3370 | |
3371 /* | |
3372 +--------------------------------------------------------------------+ | |
3373 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3374 | STATE : code ROUTINE : ma_cs_power_cnf | | |
3375 +--------------------------------------------------------------------+ | |
3376 | |
3377 PURPOSE : Sends the power measurement results to RR. | |
3378 | |
3379 */ | |
3380 | |
3381 GLOBAL void ma_cs_power_cnf (T_MPH_POWER_CNF *mph_power_cnf) | |
3382 { | |
3383 GET_INSTANCE_DATA; | |
3384 #if 0 || defined(TRACING) | |
3385 int i; | |
3386 TRACE_EVENT_P1 ("mph_power_cnf: %u freq.", mph_power_cnf->num_of_chan); | |
3387 | |
3388 for (i = 0; i < mph_power_cnf->num_of_chan AND i<10; i++) | |
3389 TRACE_EVENT_P3("[%u] std=%u rx_lev=%u", | |
3390 mph_power_cnf->arfcn[i]&ARFCN_MASK, | |
3391 STD_GET_FROM_ARFCN(mph_power_cnf->arfcn[i]), | |
3392 mph_power_cnf->rx_lev[i]); | |
3393 #endif /* TRACING */ | |
3394 | |
3395 if ( IS_EXT_MEAS_RUNNING ) /*alr_data->cs_data.mph_ext_meas_req NEQ NULL */ | |
3396 { | |
3397 D_OPC ( mph_power_cnf ) = MPH_EXT_MEAS_CNF; | |
3398 } | |
3399 | |
3400 PSENDX (RR, mph_power_cnf); | |
3401 } | |
3402 | |
3403 /* | |
3404 +--------------------------------------------------------------------+ | |
3405 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3406 | STATE : code ROUTINE : ma_cs_rxlev_req | | |
3407 +--------------------------------------------------------------------+ | |
3408 | |
3409 PURPOSE : Process the signal cs_rxlev_req from SDL process | |
3410 Cell_Selection. | |
3411 | |
3412 */ | |
3413 | |
3414 GLOBAL void ma_cs_rxlev_req (void) | |
3415 { | |
3416 GET_INSTANCE_DATA; | |
3417 T_POWER_MEAS* power_meas = NULL; | |
3418 | |
3419 TRACE_FUNCTION ("ma_cs_rxlev_req()"); | |
3420 | |
3421 switch (GET_STATE (STATE_CS)) | |
3422 { | |
3423 case CS_INIT_L1: | |
3424 power_meas = cs_prepare_power_req(); | |
3425 /* init radio band before measurement */ | |
3426 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
3427 ma_cs_init_l1_req(); | |
3428 #else | |
3429 ma_cs_init_l1_req(alr_data->cs_data.std); | |
3430 #endif | |
3431 SET_STATE(STATE_CS, CS_INIT_ACTIVE); | |
3432 return; /* wait of MPHC_INIT_L1_CON */ | |
3433 case CS_INIT_ACTIVE: | |
3434 return; /* wait of MPHC_INIT_L1_CON */ | |
3435 case CS_INIT_DONE: | |
3436 /* go through and wait or start the first resp. next measurement */ | |
3437 case CS_START_MEASURE: | |
3438 /* without or after configuration of radio band */ | |
3439 if (IS_TIMER_ACTIVE(TIM_POWERMEAS)) | |
3440 { | |
3441 /* | |
3442 * use time to spread power measurements also to write out | |
3443 * possible available DL offline traces | |
3444 */ | |
3445 #ifdef TI_PS_HCOMM_CHANGE | |
3446 PSIGNAL (_hCommDL, PH_TRACE_IND, NULL); | |
3447 #else | |
3448 PSIGNAL (hCommDL, PH_TRACE_IND, NULL); | |
3449 #endif /* TI_PS_HCOMM_CHANGE */ | |
3450 return; /* do nothing and wait for timer delay */ | |
3451 } | |
3452 break; /* OK start the first resp. next measurement */ | |
3453 default: | |
3454 TRACE_EVENT_P1 ("wrong CS state (%u) in ma_cs_rxlev_req()", GET_STATE (STATE_CS)); | |
3455 return; | |
3456 } | |
3457 | |
3458 power_meas = cs_prepare_power_req(); | |
3459 if (power_meas) | |
3460 { | |
3461 PALLOC(rxlev_req, MPHC_RXLEV_REQ); | |
3462 rxlev_req->shared_ptr = (ULONG) power_meas; | |
3463 SET_STATE(STATE_CS, CS_ACTIVE_MEASURE); | |
3464 PSENDX(L1, rxlev_req); | |
3465 /* start timer new */ | |
3466 TIMERSTART(TIM_POWERMEAS, alr_data->cs_data.c_tim_meas); | |
3467 | |
3468 ALR_EM_FIELDSTRENGTH_MEASUREMENT_REQUEST; | |
3469 | |
3470 } | |
3471 } | |
3472 | |
3473 | |
3474 /* | |
3475 +--------------------------------------------------------------------+ | |
3476 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3477 | STATE : code ROUTINE : ma_cs_init_l1_req | | |
3478 +--------------------------------------------------------------------+ | |
3479 | |
3480 PURPOSE : set the radio band configuration. | |
3481 */ | |
3482 | |
3483 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
3484 GLOBAL void ma_cs_init_l1_req () | |
3485 #else | |
3486 GLOBAL void ma_cs_init_l1_req (UBYTE radio_band_config) | |
3487 #endif | |
3488 { | |
3489 PALLOC (init_l1_req, MPHC_INIT_L1_REQ); /* T_MPHC_INIT_L1_REQ */ | |
3490 /* No need to configure L1 for different bands. l1 is capable of scanning across different bands */ | |
3491 #ifndef TI_PS_FF_QUAD_BAND_SUPPORT | |
3492 init_l1_req->radio_band_config = radio_band_config; | |
3493 TRACE_EVENT_P1 ("radio_band_config=%u", init_l1_req->radio_band_config); | |
3494 #endif | |
3495 PSENDX(L1, init_l1_req); | |
3496 cs_set_wideband_sync(); | |
3497 } | |
3498 | |
3499 /* | |
3500 +--------------------------------------------------------------------+ | |
3501 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3502 | STATE : code ROUTINE : ma_cs_network_sync_req | | |
3503 +--------------------------------------------------------------------+ | |
3504 | |
3505 PURPOSE : Process the signal cs_network_sync_req from SDL process | |
3506 Cell_Selection. | |
3507 */ | |
3508 | |
3509 GLOBAL void ma_cs_network_sync_req (USHORT channel) | |
3510 { | |
3511 GET_INSTANCE_DATA; | |
3512 PALLOC (network_sync_req, MPHC_NETWORK_SYNC_REQ); | |
3513 | |
3514 network_sync_req->radio_freq = channel; | |
3515 network_sync_req->fn_offset = 0; | |
3516 network_sync_req->time_alignment = 0; | |
3517 network_sync_req->timing_validity = TV_INVALID_TIMING_INFO; | |
3518 network_sync_req->search_mode = alr_data->cs_data.search_mode; | |
3519 alr_data->cs_data.sync_active = TRUE; | |
3520 PSENDX(L1, network_sync_req); | |
3521 | |
3522 TIMERSTART(TIM_NW_SYNC_GUARD, TIM_NW_SYNC_GUARD_VALUE); | |
3523 | |
3524 } | |
3525 | |
3526 | |
3527 /* | |
3528 +--------------------------------------------------------------------+ | |
3529 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3530 | STATE : code ROUTINE : ma_nc_rxlev_periodic_req | | |
3531 +--------------------------------------------------------------------+ | |
3532 | |
3533 PURPOSE : Process the signal nc_rxlev_periodic_req from SDL process | |
3534 Idle_Neighbour_Cell. | |
3535 | |
3536 */ | |
3537 | |
3538 GLOBAL void ma_nc_rxlev_periodic_req (T_MPHC_RXLEV_PERIODIC_REQ* update) | |
3539 { | |
3540 GET_INSTANCE_DATA; | |
3541 switch (GET_STATE (STATE_MA)) | |
3542 { | |
3543 case MA_CELL_RESELECTION: | |
3544 case MA_IDLE: | |
3545 PSENDX (L1, update); | |
3546 break; | |
3547 | |
3548 default: | |
3549 PFREE (update); | |
3550 break; | |
3551 } | |
3552 } | |
3553 | |
3554 | |
3555 /* | |
3556 +--------------------------------------------------------------------+ | |
3557 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3558 | STATE : code ROUTINE : ma_nc_stop_ncell_bcch_req | | |
3559 +--------------------------------------------------------------------+ | |
3560 | |
3561 PURPOSE : Process the signal nc_stop_ncell_bcch_req from SDL process | |
3562 Idle_Neighbour_Cell. | |
3563 | |
3564 */ | |
3565 | |
3566 GLOBAL void ma_nc_stop_ncell_bcch_req (USHORT arfcn) | |
3567 { | |
3568 PALLOC(stop_req, MPHC_STOP_NCELL_BCCH_REQ); | |
3569 | |
3570 memset (stop_req, 0, sizeof(T_MPHC_STOP_NCELL_BCCH_REQ)); | |
3571 stop_req->radio_freq_array_size = 1; | |
3572 stop_req->radio_freq_array[0] = ARFCN_TO_L1(arfcn); | |
3573 | |
3574 PSENDX(L1, stop_req); | |
3575 | |
3576 } | |
3577 | |
3578 /* | |
3579 +--------------------------------------------------------------------+ | |
3580 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3581 | STATE : code ROUTINE : ma_nc_stop_ncell_bcch_req | | |
3582 +--------------------------------------------------------------------+ | |
3583 | |
3584 PURPOSE : Process the signal nc_stop_ncell_bcch_req from SDL process | |
3585 Idle_Neighbour_Cell. | |
3586 | |
3587 */ | |
3588 | |
3589 GLOBAL void ma_nc_stop_ncell_sync_req (USHORT arfcn) | |
3590 { | |
3591 PALLOC (mphc_stop_ncell_sync_req, MPHC_STOP_NCELL_SYNC_REQ); | |
3592 | |
3593 mphc_stop_ncell_sync_req->radio_freq_array_size = 1; | |
3594 mphc_stop_ncell_sync_req->radio_freq_array[0] = ARFCN_TO_L1(arfcn); | |
3595 | |
3596 PSENDX(L1, mphc_stop_ncell_sync_req); | |
3597 } | |
3598 /* | |
3599 +--------------------------------------------------------------------+ | |
3600 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3601 | STATE : code ROUTINE : ma_nc_sync_req | | |
3602 +--------------------------------------------------------------------+ | |
3603 | |
3604 PURPOSE : Process the signal nc_sync_req from SDL process | |
3605 Idle_Neighbour_Cell. | |
3606 | |
3607 */ | |
3608 | |
3609 GLOBAL void ma_nc_sync_req (T_MPHC_NCELL_SYNC_REQ *sync_req) | |
3610 { | |
3611 PSENDX(L1, sync_req); | |
3612 } | |
3613 | |
3614 /* | |
3615 +--------------------------------------------------------------------+ | |
3616 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3617 | STATE : code ROUTINE : ma_nc_list_sync_req | | |
3618 +--------------------------------------------------------------------+ | |
3619 | |
3620 PURPOSE : Process the signal nc_list_sync_req from SDL process | |
3621 Idle_Neighbour_Cell. | |
3622 | |
3623 */ | |
3624 | |
3625 GLOBAL void ma_nc_list_sync_req (T_MPHC_NCELL_LIST_SYNC_REQ *list_sync_req) | |
3626 { | |
3627 PSENDX(L1, list_sync_req); | |
3628 } | |
3629 | |
3630 /* | |
3631 +--------------------------------------------------------------------+ | |
3632 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3633 | STATE : code ROUTINE : ma_nc_bcch_req | | |
3634 +--------------------------------------------------------------------+ | |
3635 | |
3636 PURPOSE : Process the signal nc_bcch_req from SDL process | |
3637 Idle_Neighbour_Cell. | |
3638 | |
3639 */ | |
3640 | |
3641 GLOBAL void ma_nc_bcch_req (T_MPHC_NCELL_BCCH_REQ *bcch_req) | |
3642 { | |
3643 | |
3644 ALR_EM_READ_NEIGHBOURCELL_BCCH; | |
3645 | |
3646 PSENDX(L1, bcch_req); | |
3647 } | |
3648 | |
3649 /* | |
3650 +--------------------------------------------------------------------+ | |
3651 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3652 | STATE : code ROUTINE : ma_nc_update_ba_list | | |
3653 +--------------------------------------------------------------------+ | |
3654 | |
3655 PURPOSE : Process the signal nc_update_ba_list from SDL process | |
3656 Idle_Neighbour_Cell. | |
3657 | |
3658 */ | |
3659 | |
3660 GLOBAL void ma_nc_update_ba_list (T_MPHC_UPDATE_BA_LIST *update_ba_list) | |
3661 { | |
3662 GET_INSTANCE_DATA; | |
3663 switch (GET_STATE (STATE_MA)) | |
3664 { | |
3665 case MA_DEDICATED: | |
3666 PSENDX (L1, update_ba_list); | |
3667 break; | |
3668 | |
3669 default: | |
3670 PFREE (update_ba_list); | |
3671 break; | |
3672 } | |
3673 } | |
3674 | |
3675 | |
3676 /* | |
3677 +--------------------------------------------------------------------+ | |
3678 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3679 | STATE : code ROUTINE : ma_nc_report_res | | |
3680 +--------------------------------------------------------------------+ | |
3681 | |
3682 PURPOSE : Process the signal nc_report_res from SDL process | |
3683 Idle_Neighbour_Cell. | |
3684 | |
3685 */ | |
3686 | |
3687 GLOBAL void ma_nc_report_res (T_MPH_MEASUREMENT_IND *mph_measurement_ind) | |
3688 { | |
3689 GET_INSTANCE_DATA; | |
3690 TRACE_ASSERT((GET_STATE(STATE_MA) NEQ MA_NULL) OR | |
3691 (GET_STATE(STATE_MA) NEQ MA_CELL_SELECTION)); | |
3692 | |
3693 switch (GET_STATE (STATE_MA)) | |
3694 { | |
3695 case MA_IDLE: | |
3696 #ifdef GPRS | |
3697 case MA_PTM: | |
3698 #endif | |
3699 case MA_CON_EST: | |
3700 case MA_CELL_RESELECTION: | |
3701 case MA_DEDICATED: | |
3702 PSENDX (RR, mph_measurement_ind); | |
3703 break; | |
3704 default: | |
3705 PFREE (mph_measurement_ind); | |
3706 break; | |
3707 } | |
3708 } | |
3709 | |
3710 /* | |
3711 +--------------------------------------------------------------------+ | |
3712 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3713 | STATE : code ROUTINE : ma_dedi_stop_req | | |
3714 +--------------------------------------------------------------------+ | |
3715 | |
3716 PURPOSE : Process the signal ma_dedi_stop_req from SDL process | |
3717 Dedicated_Control. | |
3718 | |
3719 */ | |
3720 | |
3721 GLOBAL void ma_dedi_stop_req (void) | |
3722 { | |
3723 PALLOC (stop_dedicated, MPHC_STOP_DEDICATED_REQ); | |
3724 #if defined(DL_TRACE_ENABLED) | |
3725 DL_OFFLINE_TRACE ("MPHC_STOP_DEDICATED_REQ"); | |
3726 #endif /* DL_TRACE_ENABLED */ | |
3727 PSENDX (L1, stop_dedicated); | |
3728 } | |
3729 | |
3730 /* | |
3731 +--------------------------------------------------------------------+ | |
3732 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3733 | STATE : code ROUTINE : ma_dedi_cnf | | |
3734 +--------------------------------------------------------------------+ | |
3735 | |
3736 PURPOSE : Process the signal ma_dedi_cnf from SDL process | |
3737 Dedicated_Control. | |
3738 | |
3739 */ | |
3740 | |
3741 GLOBAL void ma_dedi_cnf (UBYTE cause) | |
3742 { | |
3743 PALLOC (dedicated_cnf, MPH_DEDICATED_CNF); | |
3744 | |
3745 dedicated_cnf->dedi_res = cause; | |
3746 PSENDX (RR, dedicated_cnf); | |
3747 } | |
3748 | |
3749 /* | |
3750 +--------------------------------------------------------------------+ | |
3751 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3752 | STATE : code ROUTINE : ma_dedi_chan_ass_req | | |
3753 +--------------------------------------------------------------------+ | |
3754 | |
3755 PURPOSE : Process the signal ma_dedi_chan_ass_req from SDL process | |
3756 Dedi Control. | |
3757 | |
3758 */ | |
3759 | |
3760 GLOBAL void ma_dedi_chan_ass_req (T_MPHC_CHANNEL_ASSIGN_REQ *mphc_channel_assign_req) | |
3761 { | |
3762 #if defined(DL_TRACE_ENABLED) | |
3763 DL_OFFLINE_TRACE ("MPHC_CHANNEL_ASSIGN_REQ"); | |
3764 #else | |
3765 SYST_TRACE_P ((SYST, "dedi chan ass req %d", | |
3766 mphc_channel_assign_req->channel_desc_1.channel_type)); | |
3767 #endif /* DL_TRACE_ENABLED */ | |
3768 PSENDX (L1, mphc_channel_assign_req); | |
3769 } | |
3770 | |
3771 /* | |
3772 +--------------------------------------------------------------------+ | |
3773 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3774 | STATE : code ROUTINE : ma_dedi_async_ho_req | | |
3775 +--------------------------------------------------------------------+ | |
3776 | |
3777 PURPOSE : Process the signal ma_dedi_async_ho_req from SDL process | |
3778 Dedi Control. | |
3779 | |
3780 */ | |
3781 | |
3782 GLOBAL void ma_dedi_async_ho_req (T_MPHC_ASYNC_HO_REQ *async_ho_req) | |
3783 { | |
3784 PSENDX (L1, async_ho_req); | |
3785 } | |
3786 | |
3787 /* | |
3788 +--------------------------------------------------------------------+ | |
3789 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3790 | STATE : code ROUTINE : ma_dedi_sync_ho_req | | |
3791 +--------------------------------------------------------------------+ | |
3792 | |
3793 PURPOSE : Process the signal ma_dedi_sync_ho_req from SDL process | |
3794 Dedi Control. | |
3795 | |
3796 */ | |
3797 | |
3798 GLOBAL void ma_dedi_sync_ho_req (T_MPHC_SYNC_HO_REQ * sync_ho_req) | |
3799 { | |
3800 PSENDX (L1, sync_ho_req); | |
3801 } | |
3802 | |
3803 /* | |
3804 +--------------------------------------------------------------------+ | |
3805 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3806 | STATE : code ROUTINE : ma_dedi_pre_sync_ho_req | | |
3807 +--------------------------------------------------------------------+ | |
3808 | |
3809 PURPOSE : Process the signal ma_dedi_pre_sync_ho_req from | |
3810 SDL process Dedi Control. | |
3811 | |
3812 */ | |
3813 | |
3814 GLOBAL void ma_dedi_pre_sync_ho_req (T_MPHC_PRE_SYNC_HO_REQ *pre_sync_ho_req) | |
3815 { | |
3816 PSENDX (L1, pre_sync_ho_req); | |
3817 } | |
3818 | |
3819 /* | |
3820 +--------------------------------------------------------------------+ | |
3821 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3822 | STATE : code ROUTINE : ma_dedi_fail_cnf | | |
3823 +--------------------------------------------------------------------+ | |
3824 | |
3825 PURPOSE : Process the signal ma_dedi_fail_cnf from SDL process | |
3826 Dedicated_Control. | |
3827 | |
3828 */ | |
3829 | |
3830 GLOBAL void ma_dedi_fail_cnf (void) | |
3831 { | |
3832 PALLOC (mph_dedicated_fail_cnf, MPH_DEDICATED_FAIL_CNF); | |
3833 PSENDX (RR, mph_dedicated_fail_cnf); | |
3834 } | |
3835 | |
3836 /* | |
3837 +--------------------------------------------------------------------+ | |
3838 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3839 | STATE : code ROUTINE : ma_dedi_ho_fail_req | | |
3840 +--------------------------------------------------------------------+ | |
3841 | |
3842 PURPOSE : Process the signal ma_dedi_ho_fail_req from SDL process | |
3843 Dedicated_Control. | |
3844 | |
3845 */ | |
3846 | |
3847 GLOBAL void ma_dedi_ho_fail_req (void) | |
3848 { | |
3849 PALLOC (handover_fail_req, MPHC_HANDOVER_FAIL_REQ); | |
3850 PSENDX (L1, handover_fail_req); | |
3851 } | |
3852 | |
3853 /* | |
3854 +--------------------------------------------------------------------+ | |
3855 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3856 | STATE : code ROUTINE : ma_dedi_imm_ass_req | | |
3857 +--------------------------------------------------------------------+ | |
3858 | |
3859 PURPOSE : Process the signal ma_dedi_imm_ass_req from SDL process | |
3860 Dedicated_Control. | |
3861 | |
3862 */ | |
3863 | |
3864 GLOBAL void ma_dedi_imm_ass_req (T_MPHC_IMMED_ASSIGN_REQ *immed_assign_req) | |
3865 { | |
3866 #if defined(DL_TRACE_ENABLED) | |
3867 DL_OFFLINE_TRACE ("MPHC_IMMED_ASSIGN_REQ"); | |
3868 #else | |
3869 SYST_TRACE_P ((SYST, "dedi imm ass req %d", | |
3870 immed_assign_req->channel_desc.channel_type)); | |
3871 #endif /* DL_TRACE_ENABLED */ | |
3872 PSENDX (L1, immed_assign_req); | |
3873 } | |
3874 | |
3875 /* | |
3876 +--------------------------------------------------------------------+ | |
3877 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3878 | STATE : code ROUTINE : ma_dedi_change_freq_req | | |
3879 +--------------------------------------------------------------------+ | |
3880 | |
3881 PURPOSE : Process the signal ma_dedi_change_freq_req from | |
3882 SDL process Dedicated_Control. | |
3883 | |
3884 */ | |
3885 | |
3886 GLOBAL void ma_dedi_change_freq_req (T_MPHC_CHANGE_FREQUENCY *change_frequency) | |
3887 { | |
3888 PSENDX (L1, change_frequency); | |
3889 } | |
3890 | |
3891 /* | |
3892 +--------------------------------------------------------------------+ | |
3893 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3894 | STATE : code ROUTINE : ma_dedi_chan_mode_req | | |
3895 +--------------------------------------------------------------------+ | |
3896 | |
3897 PURPOSE : Process the signal ma_dedi_chan_mode_req from | |
3898 SDL process Dedicated_Control. | |
3899 | |
3900 */ | |
3901 | |
3902 GLOBAL void ma_dedi_chan_mode_req (T_MPHC_CHANNEL_MODE_MODIFY_REQ *channel_mode_modify_req) | |
3903 { | |
3904 PSENDX (L1, channel_mode_modify_req); | |
3905 } | |
3906 | |
3907 | |
3908 /* | |
3909 +--------------------------------------------------------------------+ | |
3910 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3911 | STATE : code ROUTINE : ma_dedi_ciph_req | | |
3912 +--------------------------------------------------------------------+ | |
3913 | |
3914 PURPOSE : Process the signal ma_dedi_ciph_req from | |
3915 SDL process Dedicated_Control. | |
3916 | |
3917 */ | |
3918 | |
3919 GLOBAL void ma_dedi_ciph_req (T_MPHC_SET_CIPHERING_REQ *set_ciphering_req) | |
3920 { | |
3921 PSENDX (L1, set_ciphering_req); | |
3922 } | |
3923 | |
3924 /* | |
3925 +--------------------------------------------------------------------+ | |
3926 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3927 | STATE : code ROUTINE : ma_dedi_data_out | | |
3928 +--------------------------------------------------------------------+ | |
3929 | |
3930 PURPOSE : Acknowledged frame or short PD header (format type Bter) | |
3931 Forward the message to DL. Uses the original primitive format. | |
3932 | |
3933 */ | |
3934 | |
3935 LOCAL void ma_dedi_data_out (T_PH_DATA_IND *data_ind) | |
3936 { | |
3937 PPASS (data_ind, ph_data_ind, PH_DATA_IND); | |
3938 PSENDX (DL, ph_data_ind); | |
3939 } | |
3940 | |
3941 | |
3942 /* | |
3943 +--------------------------------------------------------------------+ | |
3944 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
3945 | STATE : code ROUTINE : ma_send_dedi_unitdata | | |
3946 +--------------------------------------------------------------------+ | |
3947 | |
3948 PURPOSE : Sends an unacknowledged message on SACCH to RR. | |
3949 | |
3950 */ | |
3951 | |
3952 LOCAL void ma_send_dedi_unitdata (T_MPHC_DATA_IND *data_ind) | |
3953 { | |
3954 USHORT len_in_bits = 19 * 8; | |
3955 PALLOC_SDU (data_out, MPH_UNITDATA_IND, len_in_bits); | |
3956 | |
3957 data_out->sdu.l_buf = 18 * 8; | |
3958 data_out->sdu.o_buf = 8; | |
3959 data_out->sdu.buf[0] = 0; | |
3960 /*lint -e{419} (Warning -- Apparent data overrun) */ | |
3961 memcpy (&data_out->sdu.buf[1], &data_ind->l2_frame.content[5], 18); | |
3962 data_out->arfcn = ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK; | |
3963 data_out->fn = data_ind->fn; | |
3964 | |
3965 PSENDX (RR, data_out); | |
3966 } | |
3967 /* | |
3968 +--------------------------------------------------------------------+ | |
3969 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3970 | STATE : code ROUTINE : ma_dedi_open_tch_loop_req | | |
3971 +--------------------------------------------------------------------+ | |
3972 | |
3973 PURPOSE : Process the signal ma_dedi_open_tch_loop_req from | |
3974 SDL process Dedicated_Control. | |
3975 | |
3976 */ | |
3977 | |
3978 GLOBAL void ma_dedi_open_tch_loop_req (void) | |
3979 { | |
3980 PALLOC (oml1_open_tch_loop_req, OML1_OPEN_TCH_LOOP_REQ); | |
3981 PSENDX (L1, oml1_open_tch_loop_req); | |
3982 } | |
3983 | |
3984 | |
3985 /* | |
3986 +--------------------------------------------------------------------+ | |
3987 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
3988 | STATE : code ROUTINE : ma_dedi_stop_dai_req | | |
3989 +--------------------------------------------------------------------+ | |
3990 | |
3991 PURPOSE : Process the signal ma_dedi_stop_dai_req from | |
3992 SDL process Dedicated_Control. | |
3993 | |
3994 */ | |
3995 GLOBAL void ma_dedi_stop_dai_req (void) | |
3996 { | |
3997 PALLOC (oml1_stop_dai_test_req, OML1_STOP_DAI_TEST_REQ); | |
3998 PSENDX (L1, oml1_stop_dai_test_req); | |
3999 } | |
4000 | |
4001 | |
4002 /* | |
4003 +--------------------------------------------------------------------+ | |
4004 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
4005 | STATE : code ROUTINE : ma_dedi_close_tch_loop_req | | |
4006 +--------------------------------------------------------------------+ | |
4007 | |
4008 PURPOSE : Process the signal ma_dedi_close_tch_loop_req from | |
4009 SDL process Dedicated_Control. | |
4010 | |
4011 */ | |
4012 | |
4013 GLOBAL void ma_dedi_close_tch_loop_req (T_OML1_CLOSE_TCH_LOOP_REQ *oml1_close_tch_loop_req) | |
4014 { | |
4015 PSENDX (L1, oml1_close_tch_loop_req); | |
4016 } | |
4017 | |
4018 | |
4019 /* | |
4020 +--------------------------------------------------------------------+ | |
4021 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
4022 | STATE : code ROUTINE : ma_dedi_start_dai_req | | |
4023 +--------------------------------------------------------------------+ | |
4024 | |
4025 PURPOSE : Process the signal ma_dedi_start_dai_req from | |
4026 SDL process Dedicated_Control. | |
4027 | |
4028 */ | |
4029 | |
4030 GLOBAL void ma_dedi_start_dai_req (T_OML1_START_DAI_TEST_REQ *oml1_start_dai_test_req) | |
4031 { | |
4032 PSENDX (L1, oml1_start_dai_test_req); | |
4033 } | |
4034 | |
4035 /* | |
4036 +--------------------------------------------------------------------+ | |
4037 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4038 | STATE : code ROUTINE : ma_rach_stop_ra_req | | |
4039 +--------------------------------------------------------------------+ | |
4040 | |
4041 PURPOSE : Process the signal rach_stop_ra_req from SDL process | |
4042 RACH_Control. | |
4043 | |
4044 */ | |
4045 | |
4046 GLOBAL void ma_rach_stop_ra_req (void) | |
4047 { | |
4048 PALLOC (stop_ra_req, MPHC_STOP_RA_REQ); | |
4049 | |
4050 PSENDX (L1, stop_ra_req); | |
4051 } | |
4052 | |
4053 /* | |
4054 +--------------------------------------------------------------------+ | |
4055 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4056 | STATE : code ROUTINE : ma_pch_start_ccch_req | | |
4057 +--------------------------------------------------------------------+ | |
4058 | |
4059 PURPOSE : Process the signal pch_start_ccch_req from SDL process | |
4060 PCH_Control. | |
4061 | |
4062 */ | |
4063 | |
4064 GLOBAL void ma_pch_start_ccch_req (T_MPHC_START_CCCH_REQ *pl_idle) | |
4065 { | |
4066 GET_INSTANCE_DATA; | |
4067 if (memcmp ( &(alr_data->pch_data.last_start_ccch_req), | |
4068 pl_idle, | |
4069 sizeof(T_MPHC_START_CCCH_REQ) ) NEQ 0) | |
4070 { | |
4071 memcpy ( &(alr_data->pch_data.last_start_ccch_req), | |
4072 pl_idle, | |
4073 sizeof(T_MPHC_START_CCCH_REQ)); | |
4074 PSENDX (L1, pl_idle); | |
4075 } | |
4076 else | |
4077 { | |
4078 PFREE(pl_idle); | |
4079 } | |
4080 } | |
4081 | |
4082 /* | |
4083 +--------------------------------------------------------------------+ | |
4084 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4085 | STATE : code ROUTINE : ma_rach_random_cnf | | |
4086 +--------------------------------------------------------------------+ | |
4087 | |
4088 PURPOSE : Process the signal rach_random_cnf from SDL process | |
4089 RACH_Control. | |
4090 | |
4091 */ | |
4092 | |
4093 GLOBAL void ma_rach_random_cnf (T_MPH_RANDOM_ACCESS_CNF * mph_random_access_cnf) | |
4094 { | |
4095 GET_INSTANCE_DATA; | |
4096 switch (GET_STATE (STATE_MA)) | |
4097 { | |
4098 case MA_CON_EST: | |
4099 ALR_TRACE_MAIN_RA_CNF(mph_random_access_cnf->frame_no.t1, | |
4100 mph_random_access_cnf->frame_no.t2, | |
4101 mph_random_access_cnf->frame_no.t3); | |
4102 | |
4103 #if !defined (NCONFIG) | |
4104 if(v_cfg_rach_failure) | |
4105 memset(mph_random_access_cnf,0, sizeof(T_MPH_RANDOM_ACCESS_CNF)); | |
4106 #endif | |
4107 | |
4108 PSENDX (RR, mph_random_access_cnf); | |
4109 break; | |
4110 | |
4111 default: | |
4112 PFREE (mph_random_access_cnf); | |
4113 break; | |
4114 } | |
4115 } | |
4116 | |
4117 /* | |
4118 +--------------------------------------------------------------------+ | |
4119 | PROJECT : GSM-PS (6103) MODULE : ALR_PCH | | |
4120 | STATE : code ROUTINE : ma_pch_paging_ind | | |
4121 +--------------------------------------------------------------------+ | |
4122 | |
4123 PURPOSE : Sends a paging indication to RR. | |
4124 | |
4125 */ | |
4126 | |
4127 GLOBAL void ma_pch_paging_ind (UBYTE id_type, UBYTE channel_needed) | |
4128 { | |
4129 PALLOC (mph_paging_ind, MPH_PAGING_IND); | |
4130 | |
4131 ALR_EM_PAGING_DETECTED; | |
4132 | |
4133 mph_paging_ind->identity_type = id_type; | |
4134 mph_paging_ind->channel_needed = channel_needed; | |
4135 | |
4136 // vsi_o_ttrace(VSI_CALLER 0xFFFF, "PAG IND ch=%x", channel_needed); | |
4137 #if defined(DL_TRACE_ENABLED) | |
4138 { | |
4139 sprintf (dl_trace_buf, "PAG%u ch=%u", id_type,channel_needed); | |
4140 DL_OFFLINE_TRACE (dl_trace_buf); | |
4141 } | |
4142 #else /* DL_TRACE_ENABLED */ | |
4143 SYST_TRACE_P ((SYST, "PAG%u ch=%u", id_type,channel_needed)); | |
4144 #endif /* DL_TRACE_ENABLED */ | |
4145 | |
4146 | |
4147 PSENDX (RR, mph_paging_ind); | |
4148 } | |
4149 | |
4150 /* | |
4151 +--------------------------------------------------------------------+ | |
4152 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4153 | STATE : code ROUTINE : ma_pch_stop | | |
4154 +--------------------------------------------------------------------+ | |
4155 | |
4156 PURPOSE : Stop CCCH reading. | |
4157 */ | |
4158 | |
4159 GLOBAL void ma_pch_stop(void) | |
4160 { | |
4161 GET_INSTANCE_DATA; | |
4162 PALLOC(stop_req, MPHC_STOP_CCCH_REQ); | |
4163 alr_data->pch_data.last_start_ccch_req.bs_pa_mfrms = NOT_PRESENT_8BIT; | |
4164 PSENDX(L1, stop_req); | |
4165 } | |
4166 | |
4167 | |
4168 | |
4169 /* | |
4170 +--------------------------------------------------------------------+ | |
4171 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4172 | STATE : code ROUTINE : ma_mmi_cbch_req | | |
4173 +--------------------------------------------------------------------+ | |
4174 | |
4175 PURPOSE : Process the primitive MMI_CBCH_REQ. | |
4176 | |
4177 */ | |
4178 | |
4179 GLOBAL void ma_mmi_cbch_req (T_MMI_CBCH_REQ *cbch_req) | |
4180 { | |
4181 TRACE_EVENT ("MMI_CBCH_REQ"); | |
4182 cb_mmi_cbch_req (cbch_req); | |
4183 PFREE (cbch_req); | |
4184 } | |
4185 | |
4186 /* | |
4187 +--------------------------------------------------------------------+ | |
4188 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4189 | STATE : code ROUTINE : ma_mmi_cbch_req | | |
4190 +--------------------------------------------------------------------+ | |
4191 | |
4192 PURPOSE : Process the primitive MMI_CBCH_REQ. | |
4193 | |
4194 */ | |
4195 | |
4196 GLOBAL void ma_mmi_sat_cbch_dwnld_req (T_MMI_SAT_CBCH_DWNLD_REQ *cbch_req) | |
4197 { | |
4198 TRACE_EVENT ("MMI_SAT_CBCH_DWNLD_REQ"); | |
4199 cb_mmi_sat_cbch_req (cbch_req); | |
4200 PFREE (cbch_req); | |
4201 } | |
4202 | |
4203 /* | |
4204 +--------------------------------------------------------------------+ | |
4205 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4206 | STATE : code ROUTINE : ma_cb_stop_cbch_req | | |
4207 +--------------------------------------------------------------------+ | |
4208 | |
4209 PURPOSE : Process the signal ma_cb_stop_cbch_req. | |
4210 | |
4211 */ | |
4212 GLOBAL void ma_cb_stop_cbch_req (void) | |
4213 { | |
4214 PALLOC(stop_cbch_req, MPHC_STOP_CBCH_REQ); | |
4215 | |
4216 stop_cbch_req->normal_cbch = CBCH_STOP; | |
4217 stop_cbch_req->extended_cbch = CBCH_STOP; | |
4218 TRACE_EVENT ("MPHC_STOP_CBCH_REQ"); | |
4219 PSENDX(L1, stop_cbch_req); | |
4220 } | |
4221 | |
4222 /* | |
4223 +--------------------------------------------------------------------+ | |
4224 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4225 | STATE : code ROUTINE : ma_cb_sched_req | | |
4226 +--------------------------------------------------------------------+ | |
4227 | |
4228 PURPOSE : Process the signal ma_cb_sched_req. | |
4229 | |
4230 */ | |
4231 GLOBAL void ma_cb_sched_req (T_MPHC_CBCH_SCHEDULE_REQ *sched_req) | |
4232 { | |
4233 /* | |
4234 TRACE_EVENT ("MPHC_CBCH_SCHEDULE_REQ"); | |
4235 */ | |
4236 PSENDX (L1, sched_req); | |
4237 } | |
4238 | |
4239 /* | |
4240 +--------------------------------------------------------------------+ | |
4241 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4242 | STATE : code ROUTINE : ma_cb_config_cbch | | |
4243 +--------------------------------------------------------------------+ | |
4244 | |
4245 PURPOSE : Process the signal ma_cb_config_cbch. | |
4246 | |
4247 */ | |
4248 GLOBAL void ma_cb_config_cbch (T_MPHC_CONFIG_CBCH_REQ *config_cbch) | |
4249 { | |
4250 TRACE_EVENT ("MPHC_CONFIG_CBCH_REQ"); | |
4251 PSENDX(L1, config_cbch); | |
4252 } | |
4253 | |
4254 /* | |
4255 +--------------------------------------------------------------------+ | |
4256 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4257 | STATE : code ROUTINE : ma_cb_mmi_cbch_ind | | |
4258 +--------------------------------------------------------------------+ | |
4259 | |
4260 PURPOSE : Process the signal ma_cb_mmi_cbch_ind. | |
4261 | |
4262 */ | |
4263 GLOBAL void ma_cb_mmi_cbch_ind (T_MMI_CBCH_IND *mmi_cbch_ind) | |
4264 { | |
4265 TRACE_EVENT ("MMI_CBCH_IND"); | |
4266 PSENDX (MMI, mmi_cbch_ind); | |
4267 } | |
4268 | |
4269 /* | |
4270 +--------------------------------------------------------------------+ | |
4271 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4272 | STATE : code ROUTINE : ma_cb_info_req | | |
4273 +--------------------------------------------------------------------+ | |
4274 | |
4275 PURPOSE : Process the signal ma_cb_info_req. | |
4276 | |
4277 */ | |
4278 GLOBAL void ma_cb_info_req (UBYTE bitmap) | |
4279 { | |
4280 PALLOC(info_req, MPHC_CBCH_INFO_REQ); | |
4281 | |
4282 info_req->tb_bitmap = bitmap; | |
4283 TRACE_EVENT ("MPHC_CBCH_INFO_REQ"); | |
4284 PSENDX (L1, info_req); | |
4285 } | |
4286 /*==================================================================== | |
4287 *Functions used by more than one process | |
4288 *==================================================================== | |
4289 | |
4290 +--------------------------------------------------------------------+ | |
4291 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4292 | STATE : code ROUTINE : ma_scell_nbcch_req | | |
4293 +--------------------------------------------------------------------+ | |
4294 | |
4295 PURPOSE : Process the signal ma_scell_nbcch_req . | |
4296 | |
4297 */ | |
4298 | |
4299 GLOBAL void ma_scell_full_nbcch (void) | |
4300 { | |
4301 GET_INSTANCE_DATA; | |
4302 PALLOC(scell_nbcch_req, MPHC_SCELL_NBCCH_REQ); | |
4303 | |
4304 ALR_TRACE_MAIN ("start full sc bcch"); | |
4305 | |
4306 switch(GET_STATE(STATE_MA)) | |
4307 { | |
4308 case MA_CELL_SELECTION: | |
4309 case MA_CELL_RESELECTION: | |
4310 alr_data->cs_data.si_bitmap = 0; | |
4311 break; | |
4312 } | |
4313 scell_nbcch_req->schedule_array_size = 1; | |
4314 scell_nbcch_req->schedule_array[0].modulus = 1; | |
4315 scell_nbcch_req->schedule_array[0].relative_position = 0; | |
4316 ma_scell_nbcch_req(scell_nbcch_req); | |
4317 } | |
4318 | |
4319 GLOBAL void ma_scell_nbcch_req (T_MPHC_SCELL_NBCCH_REQ *nbcch_req) | |
4320 { | |
4321 ALR_TRACE_MAIN ("start sc bcch"); | |
4322 | |
4323 PSENDX (L1, nbcch_req); | |
4324 } | |
4325 | |
4326 /* | |
4327 +--------------------------------------------------------------------+ | |
4328 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4329 | STATE : code ROUTINE : ma_scell_ebcch_req | | |
4330 +--------------------------------------------------------------------+ | |
4331 | |
4332 PURPOSE : Process the signal cs_scell_nbcch_req from SDL process | |
4333 Cell_Selection. | |
4334 */ | |
4335 | |
4336 GLOBAL void ma_scell_ebcch_req (T_MPHC_SCELL_EBCCH_REQ *ebcch_req) | |
4337 { | |
4338 PSENDX (L1, ebcch_req); | |
4339 } | |
4340 | |
4341 | |
4342 /* | |
4343 +--------------------------------------------------------------------+ | |
4344 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4345 | STATE : code ROUTINE : ma_stop_active_procs | | |
4346 +--------------------------------------------------------------------+ | |
4347 | |
4348 PURPOSE : Stop all active procedures. | |
4349 */ | |
4350 GLOBAL void ma_stop_active_procs (UBYTE flags) | |
4351 { | |
4352 GET_INSTANCE_DATA; | |
4353 if (flags & STOP_PCH_READING) | |
4354 { | |
4355 pch_stop(); | |
4356 } | |
4357 | |
4358 if (flags & STOP_MEASUREMENTS) | |
4359 { | |
4360 ma_stop_rxlev_periodic_req(); | |
4361 } | |
4362 | |
4363 switch (GET_STATE(STATE_MA)) | |
4364 { | |
4365 case MA_CELL_SELECTION: | |
4366 /* | |
4367 * if we are doing measurements or synchronising or | |
4368 * reading the BCCH of a cell, stop the process | |
4369 */ | |
4370 cs_stop(); | |
4371 break; | |
4372 case MA_CELL_RESELECTION: | |
4373 ma_stop_scell_bcch_req (); | |
4374 break; | |
4375 case MA_CON_EST: | |
4376 /* | |
4377 * Stop Uplink Random Burst Sending | |
4378 */ | |
4379 rach_stop(); | |
4380 break; | |
4381 case MA_DEDICATED: | |
4382 dedi_stop(); | |
4383 break; | |
4384 case MA_IDLE: | |
4385 /* if we are reading the FCH or SCH of a ncell | |
4386 or reading its BCCH, stop it */ | |
4387 nc_suspend(); | |
4388 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
4389 /* before stop reading the scell BCCH reset the SIq_status to configure | |
4390 when it is in pending state, so that it is easy to reconfigure again*/ | |
4391 if((alr_data->nc_data.si2quater_status EQ SI2QUATER_ACQ_PENDING) OR | |
4392 (alr_data->nc_data.si2quater_status EQ SI2QUATER_ACQ_FULL_BCCH)) | |
4393 { | |
4394 alr_data->nc_data.si2quater_status = SI2QUATER_CONFIGURE; | |
4395 } | |
4396 #endif | |
4397 /* if we are reading the BCCH of the serving cell, | |
4398 stop it */ | |
4399 ma_stop_scell_bcch_req(); | |
4400 /* if we are reading the CBCH, stop it */ | |
4401 cb_stop(); | |
4402 break; | |
4403 #ifdef GPRS | |
4404 case MA_PTM: | |
4405 /* if we are reading the FCH or SCH of a ncell | |
4406 or reading its BCCH, stop it */ | |
4407 nc_suspend(); | |
4408 /* if we are reading the BCCH of the serving cell, | |
4409 stop it */ | |
4410 /* | |
4411 ma_stop_scell_bcch_req(); | |
4412 */ | |
4413 break; | |
4414 #endif /* GPRS */ | |
4415 }; | |
4416 } | |
4417 | |
4418 /* | |
4419 +--------------------------------------------------------------------+ | |
4420 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4421 | STATE : code ROUTINE : ma_send_unitdata | | |
4422 +--------------------------------------------------------------------+ | |
4423 | |
4424 PURPOSE : Cut pseudo length and send data directly to RR. | |
4425 | |
4426 */ | |
4427 | |
4428 GLOBAL void ma_send_unitdata (T_MPHC_DATA_IND * data_ind) | |
4429 { | |
4430 #define SYS_INFO_LEN 24 | |
4431 | |
4432 USHORT len_in_bits = SYS_INFO_LEN * BITS_PER_BYTE; | |
4433 | |
4434 PALLOC_SDU (data_out, MPH_UNITDATA_IND, len_in_bits); | |
4435 | |
4436 /* No IE and Pseudo Length */ | |
4437 data_out->sdu.l_buf = (SYS_INFO_LEN - 2) * BITS_PER_BYTE; | |
4438 /* Pseudo Length */ | |
4439 data_out->sdu.o_buf = 1 * BITS_PER_BYTE; | |
4440 /* No IE */ | |
4441 /*lint -e{419} (Warning -- Apparent data overrun) */ | |
4442 memcpy (data_out->sdu.buf, &data_ind->l2_frame, SYS_INFO_LEN - 1); | |
4443 data_out->arfcn = ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK; | |
4444 data_out->fn = data_ind->fn; | |
4445 | |
4446 #if 0 && defined(DL_TRACE_ENABLED) | |
4447 { | |
4448 sprintf (dl_trace_buf, "DATA ind msg=%u", msg_t); | |
4449 DL_OFFLINE_TRACE (dl_trace_buf); | |
4450 } | |
4451 #endif /* DL_TRACE_ENABLED */ | |
4452 | |
4453 PSENDX (RR, data_out); | |
4454 } | |
4455 | |
4456 /* | |
4457 +--------------------------------------------------------------------+ | |
4458 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
4459 | STATE : code ROUTINE : ma_error_ind | | |
4460 +--------------------------------------------------------------------+ | |
4461 | |
4462 PURPOSE : send a MPH_ERROR_IND to RR. | |
4463 | |
4464 */ | |
4465 | |
4466 GLOBAL void ma_error_ind (UBYTE cause, USHORT arfcn) | |
4467 { | |
4468 PALLOC (error_ind, MPH_ERROR_IND); | |
4469 | |
4470 ALR_TRACE_MAIN ("err ind"); | |
4471 | |
4472 ALR_EM_ERROR_IND(cause, arfcn); | |
4473 | |
4474 error_ind->cs = cause; | |
4475 error_ind->arfcn = arfcn; | |
4476 | |
4477 PSENDX (RR, error_ind); | |
4478 /* | |
4479 * These errors could mean that the AFC value in L1 might be srewed | |
4480 * up somehow. So go back to wide band search mode for next CS to be | |
4481 * safe. | |
4482 */ | |
4483 if( (cause EQ CS_DOWN_LINK_FAIL) OR (cause EQ CS_RADIO_LINK_FAIL)) | |
4484 cs_set_wideband_sync(); | |
4485 } | |
4486 | |
4487 /* | |
4488 +--------------------------------------------------------------------+ | |
4489 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
4490 | STATE : code ROUTINE : ma_sync_ind | | |
4491 +--------------------------------------------------------------------+ | |
4492 | |
4493 PURPOSE : Send a synchronisation primitive to RR. | |
4494 | |
4495 */ | |
4496 | |
4497 LOCAL void ma_sync_ind (UBYTE cause, | |
4498 USHORT arfcn) | |
4499 { | |
4500 PALLOC (sync_ind, MPH_SYNC_IND); | |
4501 | |
4502 TRACE_FUNCTION ("ma_sync_ind()"); | |
4503 | |
4504 sync_ind->cs = cause; | |
4505 sync_ind->arfcn = arfcn; | |
4506 PSENDX (RR, sync_ind); | |
4507 } | |
4508 | |
4509 | |
4510 /* | |
4511 +--------------------------------------------------------------------+ | |
4512 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4513 | STATE : code ROUTINE : ma_stop_scell_bcch_req | | |
4514 +--------------------------------------------------------------------+ | |
4515 | |
4516 PURPOSE : Process the signal cs_stop_bcch_reading from SDL processes | |
4517 Cell_Selection or Serving_Cell. | |
4518 | |
4519 */ | |
4520 | |
4521 GLOBAL void ma_stop_scell_bcch_req (void) | |
4522 { | |
4523 PALLOC (stop_bcch_req, MPHC_STOP_SCELL_BCCH_REQ); | |
4524 | |
4525 ALR_TRACE_MAIN ("stop sc bcch"); | |
4526 | |
4527 PSENDX (L1, stop_bcch_req); | |
4528 } | |
4529 | |
4530 /* | |
4531 +--------------------------------------------------------------------+ | |
4532 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4533 | STATE : code ROUTINE : ma_stop_rxlev_periodic_req | | |
4534 +--------------------------------------------------------------------+ | |
4535 | |
4536 PURPOSE : Stops the periodic fieldstrength measurements during | |
4537 idle mode. | |
4538 | |
4539 */ | |
4540 | |
4541 | |
4542 LOCAL void ma_stop_rxlev_periodic_req (void) | |
4543 { | |
4544 PALLOC (stop_rxlev_req, MPHC_STOP_RXLEV_PERIODIC_REQ); | |
4545 | |
4546 ALR_TRACE_MAIN ("stop rxlev perio."); | |
4547 | |
4548 PSENDX (L1, stop_rxlev_req); | |
4549 } | |
4550 | |
4551 | |
4552 | |
4553 /* | |
4554 +--------------------------------------------------------------------+ | |
4555 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4556 | STATE : code ROUTINE : ma_bsic_cnf | | |
4557 +--------------------------------------------------------------------+ | |
4558 | |
4559 PURPOSE : Sends the synchronisation result to RR. | |
4560 | |
4561 */ | |
4562 | |
4563 GLOBAL void ma_bsic_cnf (T_MPH_BSIC_CNF* mph_bsic_cnf) | |
4564 { | |
4565 PSENDX (RR, mph_bsic_cnf); | |
4566 } | |
4567 | |
4568 /* | |
4569 +--------------------------------------------------------------------+ | |
4570 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4571 | STATE : code ROUTINE : ma_new_scell_req | | |
4572 +--------------------------------------------------------------------+ | |
4573 | |
4574 PURPOSE : Sends a new scell request to layer 1. | |
4575 | |
4576 */ | |
4577 | |
4578 GLOBAL void ma_new_scell_req(T_MPHC_NEW_SCELL_REQ *new_scell) | |
4579 { | |
4580 GET_INSTANCE_DATA; | |
4581 alr_data->bsic = new_scell->tsc; | |
4582 PSENDX(L1, new_scell); | |
4583 } | |
4584 | |
4585 /* | |
4586 +--------------------------------------------------------------------+ | |
4587 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
4588 | STATE : code ROUTINE : ma_mphc_init_l1_cnf | | |
4589 +--------------------------------------------------------------------+ | |
4590 | |
4591 PURPOSE : Process the primitive MPHC_INIT_L1_CON. | |
4592 | |
4593 */ | |
4594 | |
4595 GLOBAL void ma_mphc_init_l1_cnf (T_MPHC_INIT_L1_CON *init_l1_cnf) | |
4596 { | |
4597 GET_INSTANCE_DATA; | |
4598 | |
4599 switch (GET_STATE (STATE_CS)) | |
4600 { | |
4601 case CS_INIT_ACTIVE: | |
4602 SET_STATE (STATE_CS, CS_INIT_DONE); | |
4603 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
4604 compare_l1_frequency_band_with_ffs (init_l1_cnf); | |
4605 #endif | |
4606 ma_cs_rxlev_req (); | |
4607 break; | |
4608 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
4609 default : | |
4610 TRACE_EVENT_P1 ("MPHC_INIT_L1_CON received in the wrong CS state %d", GET_STATE (STATE_CS)); | |
4611 break; | |
4612 #else | |
4613 case CS_INIT_SYNC: | |
4614 SET_STATE (STATE_CS, CS_INIT_DONE); | |
4615 cs_bsic_req (NULL); | |
4616 #endif | |
4617 } | |
4618 PFREE (init_l1_cnf); | |
4619 } | |
4620 | |
4621 /* | |
4622 +--------------------------------------------------------------------+ | |
4623 | PROJECT : GSM-PS (6302) MODULE : ALR_MAIN | | |
4624 | STATE : code ROUTINE : ma_mphc_stop_dedi_con | | |
4625 +--------------------------------------------------------------------+ | |
4626 | |
4627 PURPOSE : Process the primitive MPHC_STOP_DEDICATED_CON. | |
4628 | |
4629 */ | |
4630 | |
4631 GLOBAL void ma_mphc_stop_dedi_con (T_MPHC_STOP_DEDICATED_CON *stop_cnf) | |
4632 { | |
4633 #ifdef GPRS | |
4634 GET_INSTANCE_DATA; | |
4635 #endif | |
4636 PFREE (stop_cnf); | |
4637 | |
4638 #ifdef GPRS | |
4639 if(alr_data->dedi_data.act_mode EQ MODE_PDCH_ASSIGN) | |
4640 { | |
4641 /* | |
4642 * Notify RR about the actions performed due to PDCH Assignment. | |
4643 * Note that MPH_DEDICATED_CNF is misleading as L1 is in Idle Mode now. | |
4644 */ | |
4645 ma_dedi_cnf (DEDI_RES_OK); | |
4646 trc_state_transition(0, MA_IDLE); | |
4647 SET_STATE(STATE_MA, MA_IDLE); /* allow PTM with next MPH_IDLE_REQ(PTM) */ | |
4648 return; | |
4649 } | |
4650 #endif | |
4651 { | |
4652 PALLOC(mph_dedi_cnf, MPH_STOP_DEDICATED_CNF); | |
4653 PSENDX ( RR, mph_dedi_cnf ); | |
4654 } | |
4655 } | |
4656 | |
4657 /* | |
4658 * The following two functions convert ARFCNs between the official GSM | |
4659 * spec notation and the numbering scheme used by TI's L1. The latter | |
4660 * scheme changed with the new way of multiband handling found in the | |
4661 * LoCosto source, but not in TCS211. | |
4662 * | |
4663 * The original L1 frequency channel numbering scheme (used in TCS211) | |
4664 * looks like this: | |
4665 | |
4666 Frequency Band config. ETSI GSM spec. coding used in L1 | |
4667 GSM 900 STD_900 1-124 1-124 | |
4668 E-GSM STD_EGSM 1-124, 1-124, | |
4669 975-1023, 0 125-174 | |
4670 PCS 1900 STD_1900 512-810 512-810 | |
4671 DCS 1800 STD_1800 512-885 512-885 | |
4672 GSM 900/DCS 1800 STD_DUAL 1-124, 1-124, | |
4673 512-885 125-498 | |
4674 E-GSM/DCS 1800 STD_DUAL_EGSM 1-124, 1-124, | |
4675 975-1023,0 125-174, | |
4676 512-885 175-548 | |
4677 GSM 850 STD_850 128-251 128-251 | |
4678 GSM 850/PCS 1900 STD_DUAL_US 128-251, 1-124, | |
4679 512-810 125-424 | |
4680 | |
4681 * The new-fangled scheme found in the LoCosto source looks like this: | |
4682 | |
4683 Frequency Band config. ETSI GSM spec. coding used in L1 | |
4684 GSM 900 STD_900 1-124 1-124 | |
4685 E-GSM STD_EGSM 1-124, 1-124, | |
4686 975-1023, 0 975-1023, 0 | |
4687 PCS 1900 STD_1900 512-810 1024-1322 | |
4688 DCS 1800 STD_1800 512-885 512-885 | |
4689 GSM 900/DCS 1800 STD_DUAL 1-124, 1-124, | |
4690 512-885 512-885 | |
4691 E-GSM/DCS 1800 STD_DUAL_EGSM 1-124, 1-124, | |
4692 975-1023,0 975-1023,0 | |
4693 512-885 512-885 | |
4694 GSM 850 STD_850 128-251 128-251 | |
4695 GSM 850/PCS 1900 STD_DUAL_US 128-251, 128-251, | |
4696 512-810 1024-1322 | |
4697 GSM 850/DCS 1800 STD_850_1800 128-251, 128-251, | |
4698 512-885 512-885 | |
4699 GSM 900/PCS 1900 STD_900_1900 1-124, 1-124, | |
4700 512-810 1024-1322 | |
4701 | |
4702 * The implementation of the two functions below, taken from the | |
4703 * LoCosto source, has interspersed #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
4704 * conditionals, selecting between the two possible configurations. | |
4705 */ | |
4706 | |
4707 /* | |
4708 +--------------------------------------------------------------------+ | |
4709 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4710 | STATE : code ROUTINE : convert_arfcn_to_l1 | | |
4711 +--------------------------------------------------------------------+ | |
4712 | |
4713 PURPOSE : Convert_arfcn_to_l1 converts the arfcn given by the upper | |
4714 layer (ETSI GSM spec.) to the internal format of layer 1. | |
4715 | |
4716 */ | |
4717 | |
4718 GLOBAL USHORT convert_arfcn_to_l1 (USHORT arfcn, UBYTE local_std) | |
4719 { | |
4720 #ifdef WIN32 | |
4721 GET_INSTANCE_DATA; | |
4722 if (!alr_data->mb_testing) | |
4723 arfcn = arfcn&ARFCN_MASK; | |
4724 else | |
4725 { | |
4726 #endif | |
4727 if (local_std EQ 0) | |
4728 local_std = std; | |
4729 arfcn &= ARFCN_MASK; | |
4730 switch (local_std) | |
4731 { | |
4732 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
4733 case STD_1900: | |
4734 case STD_DUAL_US: | |
4735 case STD_900_1900: | |
4736 case STD_850_900_1900: | |
4737 if ((arfcn >= LOW_CHANNEL_1900) AND (arfcn <= HIGH_CHANNEL_1900)) | |
4738 arfcn += LOW_CHANNEL_1900; | |
4739 break; | |
4740 #else | |
4741 case STD_DUAL: | |
4742 if (arfcn >= LOW_CHANNEL_1800) | |
4743 arfcn -= (LOW_CHANNEL_1800-125); | |
4744 break; | |
4745 | |
4746 case STD_EGSM: | |
4747 case STD_DUAL_EGSM: | |
4748 if (arfcn >= LOW_CHANNEL_EGSM) | |
4749 arfcn -= (LOW_CHANNEL_EGSM-125); | |
4750 else if (arfcn >= LOW_CHANNEL_1800) | |
4751 arfcn -= (LOW_CHANNEL_1800-175); | |
4752 else if (arfcn EQ CHANNEL_0) | |
4753 arfcn = 174; | |
4754 break; | |
4755 | |
4756 case STD_DUAL_US: | |
4757 if (arfcn >= LOW_CHANNEL_1900) | |
4758 arfcn -= (LOW_CHANNEL_1900-125); | |
4759 else | |
4760 arfcn -= (LOW_CHANNEL_850-1); | |
4761 break; | |
4762 #endif | |
4763 default: | |
4764 break; | |
4765 } | |
4766 #ifdef WIN32 | |
4767 } | |
4768 #endif | |
4769 return arfcn; | |
4770 } | |
4771 | |
4772 /* | |
4773 +--------------------------------------------------------------------+ | |
4774 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4775 | STATE : code ROUTINE : convert_arfcn_to_g23 | | |
4776 +--------------------------------------------------------------------+ | |
4777 | |
4778 PURPOSE : Convert_arfcn_to_g23 converts the radio frequence given by | |
4779 layer 1 to the common format of the upper layer (ETSI GSM spec.). | |
4780 | |
4781 */ | |
4782 | |
4783 GLOBAL USHORT convert_arfcn_to_g23 (USHORT arfcn, UBYTE local_std) | |
4784 { | |
4785 #ifdef WIN32 | |
4786 GET_INSTANCE_DATA; | |
4787 if (!alr_data->mb_testing) | |
4788 arfcn = arfcn&ARFCN_MASK; | |
4789 else | |
4790 { | |
4791 #endif | |
4792 if (local_std EQ 0) | |
4793 local_std = std; | |
4794 arfcn &= ARFCN_MASK; | |
4795 switch (local_std) | |
4796 { | |
4797 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
4798 case STD_1900: | |
4799 case STD_DUAL_US: | |
4800 case STD_900_1900: | |
4801 case STD_850_900_1900: | |
4802 if (arfcn >= LOW_CHANNEL_1900_INTERNAL) | |
4803 arfcn -= LOW_CHANNEL_1900; | |
4804 break; | |
4805 #else | |
4806 case STD_DUAL: | |
4807 if (arfcn >=125) | |
4808 arfcn += (LOW_CHANNEL_1800-125); | |
4809 break; | |
4810 | |
4811 case STD_EGSM: | |
4812 case STD_DUAL_EGSM: | |
4813 if (arfcn >= 175) | |
4814 arfcn += (LOW_CHANNEL_1800-175); | |
4815 else if (arfcn EQ 174) | |
4816 arfcn = CHANNEL_0; | |
4817 else if (arfcn >= 125) | |
4818 arfcn += (LOW_CHANNEL_EGSM-125); | |
4819 break; | |
4820 | |
4821 case STD_DUAL_US: | |
4822 if (arfcn >= 125) | |
4823 arfcn += (LOW_CHANNEL_1900-125); | |
4824 else | |
4825 arfcn += (LOW_CHANNEL_850-1); | |
4826 /*lint -fallthrough*/ | |
4827 case STD_850: | |
4828 case STD_1900: | |
4829 /* only for MPH_POWER_CNF and MPH_BSIC_CNF | |
4830 arfcn |= US_BIT; | |
4831 */ | |
4832 break; | |
4833 #endif | |
4834 default: | |
4835 break; | |
4836 } | |
4837 #ifdef WIN32 | |
4838 } | |
4839 #endif | |
4840 return arfcn; | |
4841 } | |
4842 | |
4843 /* | |
4844 +--------------------------------------------------------------------+ | |
4845 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4846 | STATE : code ROUTINE : ma_clean_dedi_sys_buffer | | |
4847 +--------------------------------------------------------------------+ | |
4848 | |
4849 PURPOSE : Cleans System Information Message from SACCH. | |
4850 | |
4851 */ | |
4852 | |
4853 GLOBAL void ma_clean_dedi_sys_buffer (void) | |
4854 { | |
4855 GET_INSTANCE_DATA; | |
4856 memset (alr_data->ma_data.sys_info_5, 0, 18); | |
4857 memset (alr_data->ma_data.sys_info_5bis, 0, 18); | |
4858 memset (alr_data->ma_data.sys_info_5ter, 0, 18); | |
4859 memset (alr_data->ma_data.sys_info_6, 0, 18); | |
4860 } | |
4861 | |
4862 | |
4863 /* | |
4864 +--------------------------------------------------------------------+ | |
4865 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4866 | STATE : code ROUTINE : ma_set_si_bitmap | | |
4867 +--------------------------------------------------------------------+ | |
4868 | |
4869 PURPOSE : Updates the si_bitmap. | |
4870 | |
4871 */ | |
4872 | |
4873 LOCAL void ma_set_si_bitmap (UBYTE msg_t) | |
4874 { | |
4875 GET_INSTANCE_DATA; | |
4876 switch(msg_t) | |
4877 { | |
4878 case D_SYS_INFO_1: | |
4879 alr_data->cs_data.si_bitmap |= SI_1_READ; | |
4880 break; | |
4881 case D_SYS_INFO_2: | |
4882 alr_data->cs_data.si_bitmap |= SI_2_READ; | |
4883 break; | |
4884 case D_SYS_INFO_3: | |
4885 alr_data->cs_data.si_bitmap |= SI_3_READ; | |
4886 break; | |
4887 case D_SYS_INFO_4: | |
4888 alr_data->cs_data.si_bitmap |= SI_4_READ; | |
4889 break; | |
4890 case D_SYS_INFO_2BIS: | |
4891 alr_data->cs_data.si_bitmap |= SI_2BIS_READ; | |
4892 break; | |
4893 case D_SYS_INFO_2TER: | |
4894 alr_data->cs_data.si_bitmap |= SI_2TER_READ; | |
4895 break; | |
4896 default: | |
4897 break; | |
4898 } | |
4899 } | |
4900 /* | |
4901 +--------------------------------------------------------------------+ | |
4902 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4903 | STATE : code ROUTINE : ma_fill_sys_buffer | | |
4904 +--------------------------------------------------------------------+ | |
4905 | |
4906 PURPOSE : Stores a System Information Message. | |
4907 | |
4908 */ | |
4909 | |
4910 LOCAL void ma_fill_sys_buffer (T_MPHC_DATA_IND* data_ind, UBYTE msg_t) | |
4911 { | |
4912 GET_INSTANCE_DATA; | |
4913 switch (msg_t) | |
4914 { | |
4915 case D_SYS_INFO_1: | |
4916 memcpy (alr_data->ma_data.sys_info_1, | |
4917 &data_ind->l2_frame.content[1], 22); | |
4918 break; | |
4919 case D_SYS_INFO_2: | |
4920 memcpy (alr_data->ma_data.sys_info_2, | |
4921 &data_ind->l2_frame.content[1], 22); | |
4922 break; | |
4923 case D_SYS_INFO_2BIS: | |
4924 memcpy (alr_data->ma_data.sys_info_2bis, | |
4925 &data_ind->l2_frame.content[1], 22); | |
4926 break; | |
4927 case D_SYS_INFO_2TER: | |
4928 memcpy (alr_data->ma_data.sys_info_2ter, | |
4929 &data_ind->l2_frame.content[1], 22); | |
4930 break; | |
4931 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
4932 case D_SYS_INFO_2QUATER: | |
4933 memcpy (alr_data->ma_data.sys_info_2quater, | |
4934 &data_ind->l2_frame.content[1], 22); | |
4935 break; | |
4936 #endif | |
4937 case D_SYS_INFO_3: | |
4938 memcpy (alr_data->ma_data.sys_info_3, | |
4939 &data_ind->l2_frame.content[1], 22); | |
4940 break; | |
4941 case D_SYS_INFO_4: | |
4942 memcpy (alr_data->ma_data.sys_info_4, | |
4943 &data_ind->l2_frame.content[1], 22); | |
4944 break; | |
4945 #ifdef GPRS | |
4946 case D_SYS_INFO_13: | |
4947 memcpy (alr_data->ma_data.sys_info_13, | |
4948 &data_ind->l2_frame.content[1], 22); | |
4949 break; | |
4950 #endif /* GPRS */ | |
4951 default: | |
4952 break; | |
4953 } | |
4954 } | |
4955 | |
4956 /* | |
4957 +--------------------------------------------------------------------+ | |
4958 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
4959 | STATE : code ROUTINE : ma_compare_sys_buffer | | |
4960 +--------------------------------------------------------------------+ | |
4961 | |
4962 PURPOSE : Compares a System Information Message. | |
4963 | |
4964 */ | |
4965 LOCAL BOOL ma_compare_sys_buffer (T_MPHC_DATA_IND *mphc_data_ind, | |
4966 UBYTE msg_t) | |
4967 { | |
4968 GET_INSTANCE_DATA; | |
4969 switch (msg_t) | |
4970 { | |
4971 case D_SYS_INFO_1: | |
4972 return (!memcmp (alr_data->ma_data.sys_info_1, | |
4973 &mphc_data_ind->l2_frame.content[1], 22)); | |
4974 /*break;*/ | |
4975 case D_SYS_INFO_2: | |
4976 return (!memcmp (alr_data->ma_data.sys_info_2, | |
4977 &mphc_data_ind->l2_frame.content[1], 22)); | |
4978 /*break;*/ | |
4979 case D_SYS_INFO_2BIS: | |
4980 return (!memcmp (alr_data->ma_data.sys_info_2bis, | |
4981 &mphc_data_ind->l2_frame.content[1], 22)); | |
4982 /*break;*/ | |
4983 case D_SYS_INFO_2TER: | |
4984 return (!memcmp (alr_data->ma_data.sys_info_2ter, | |
4985 &mphc_data_ind->l2_frame.content[1], 18));/* Ignore si2ter_rest_octets changes */ | |
4986 /*break;*/ | |
4987 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
4988 case D_SYS_INFO_2QUATER: | |
4989 return 0; | |
4990 /*break;*/ | |
4991 #endif | |
4992 case D_SYS_INFO_3: | |
4993 return (!memcmp (alr_data->ma_data.sys_info_3, | |
4994 &mphc_data_ind->l2_frame.content[1], 22)); | |
4995 /*break;*/ | |
4996 case D_SYS_INFO_4: | |
4997 return (!memcmp (alr_data->ma_data.sys_info_4, | |
4998 &mphc_data_ind->l2_frame.content[1], 22)); | |
4999 /*break;*/ | |
5000 #ifdef GPRS | |
5001 case D_SYS_INFO_13: | |
5002 return (!memcmp (alr_data->ma_data.sys_info_13, | |
5003 &mphc_data_ind->l2_frame.content[1], 22)); | |
5004 /*break;*/ | |
5005 #endif /* GPRS */ | |
5006 default: | |
5007 break; | |
5008 } | |
5009 return 0; | |
5010 } | |
5011 | |
5012 | |
5013 GLOBAL void sc_start_periodic (void) | |
5014 { | |
5015 GET_INSTANCE_DATA; | |
5016 #ifdef GPRS | |
5017 if(gprs_check_read_si13_only()) | |
5018 #endif /* GPRS */ | |
5019 { | |
5020 USHORT i; | |
5021 UBYTE k, si_bitmap = alr_data->cs_data.si_bitmap; | |
5022 PALLOC(scell_bcch_req, MPHC_SCELL_NBCCH_REQ); | |
5023 | |
5024 /* 3GPP TS 05.02 Section 6.3.1.3: If only one of SI2bis and | |
5025 * SI2ter is there it will be sent when TC=5 | |
5026 */ | |
5027 if((si_bitmap&SI_2BIS_READ) EQ 0 AND | |
5028 (si_bitmap&SI_2TER_READ) NEQ 0) | |
5029 si_bitmap = (si_bitmap & ~(SI_2TER_READ)) | SI_2BIS_READ; | |
5030 | |
5031 /* we want to read all SYSTEM INFO's broadcasted, TC=0..7 */ | |
5032 for (i=0,k=0; i < 8; i++ ) | |
5033 { | |
5034 if( (si_bitmap&(1<<i)) != 0) | |
5035 { | |
5036 scell_bcch_req->schedule_array[k].modulus = THIRTY_SECONDS_SCELL_BCCH; | |
5037 scell_bcch_req->schedule_array[k].relative_position = i; | |
5038 k++; | |
5039 } | |
5040 } | |
5041 scell_bcch_req->schedule_array_size = k; | |
5042 ma_scell_nbcch_req(scell_bcch_req); | |
5043 } | |
5044 | |
5045 } | |
5046 | |
5047 /* | |
5048 +--------------------------------------------------------------------+ | |
5049 | PROJECT : GSM-PS (6103) MODULE : alr_MAIN | | |
5050 | STATE : code ROUTINE : ma_is_ptm | | |
5051 +--------------------------------------------------------------------+ | |
5052 | |
5053 PURPOSE : Returns True if the current state is MA_PTM, | |
5054 otherwise returns FALSE. | |
5055 | |
5056 */ | |
5057 | |
5058 | |
5059 #ifdef GPRS | |
5060 GLOBAL BOOL ma_is_ptm(void) | |
5061 { | |
5062 GET_INSTANCE_DATA; | |
5063 if(GET_STATE(STATE_MA) EQ MA_PTM) | |
5064 return TRUE; | |
5065 else | |
5066 return FALSE; | |
5067 } | |
5068 #endif /* GPRS */ | |
5069 | |
5070 /* | |
5071 +--------------------------------------------------------------------+ | |
5072 | PROJECT : GSM-PS (6103) MODULE : alr_MAIN | | |
5073 | STATE : code ROUTINE : ma_nc_rxlev_sc_req | | |
5074 +--------------------------------------------------------------------+ | |
5075 | |
5076 PURPOSE : A new RXLEV value of the serving cell has been measured. | |
5077 Inform GPL in case it is necessary. | |
5078 | |
5079 */ | |
5080 #ifdef GPRS | |
5081 | |
5082 GLOBAL void ma_nc_rxlev_sc_req (T_TB_RXLEV_SC_REQ *rxlev_sc_req) | |
5083 { | |
5084 GET_INSTANCE_DATA; | |
5085 if(GET_STATE (STATE_MA) EQ MA_IDLE AND | |
5086 gprs_alr_is_supported( ) EQ TRUE ) | |
5087 { | |
5088 PSENDX (GPL, rxlev_sc_req); | |
5089 } | |
5090 else | |
5091 { | |
5092 PFREE (rxlev_sc_req); | |
5093 } | |
5094 } | |
5095 | |
5096 #endif /* #ifdef GPRS */ | |
5097 | |
5098 /* | |
5099 *-------------------------------------------------------------------- | |
5100 * helper functions for main process | |
5101 * these should all be LOCAL | |
5102 *-------------------------------------------------------------------- | |
5103 */ | |
5104 | |
5105 /* | |
5106 +--------------------------------------------------------------------+ | |
5107 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5108 | STATE : code ROUTINE : ma_clean_sys_buffer | | |
5109 +--------------------------------------------------------------------+ | |
5110 | |
5111 PURPOSE : Cleans System Information Message from BCCH. | |
5112 | |
5113 */ | |
5114 | |
5115 GLOBAL void ma_clean_sys_buffer (USHORT si_mask) | |
5116 { | |
5117 GET_INSTANCE_DATA; | |
5118 if ( si_mask & IND_SI_1 ) memset (alr_data->ma_data.sys_info_1, 0, 22); | |
5119 if ( si_mask & IND_SI_2 ) memset (alr_data->ma_data.sys_info_2, 0, 22); | |
5120 if ( si_mask & IND_SI_2BIS ) memset (alr_data->ma_data.sys_info_2bis, 0, 22); | |
5121 if ( si_mask & IND_SI_3 ) memset (alr_data->ma_data.sys_info_3, 0, 22); | |
5122 if ( si_mask & IND_SI_4 ) memset (alr_data->ma_data.sys_info_4, 0, 22); | |
5123 if ( si_mask & IND_SI_2TER ) memset (alr_data->ma_data.sys_info_2ter, 0, 22); | |
5124 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
5125 if ( si_mask & IND_SI_2QUATER ) memset (alr_data->ma_data.sys_info_2quater, 0, 22); | |
5126 #endif | |
5127 #ifdef GPRS | |
5128 if ( si_mask & IND_SI_13 ) memset (alr_data->ma_data.sys_info_13, 0, 22); | |
5129 #endif | |
5130 if ( si_mask & IND_SI_5 ) memset (alr_data->ma_data.sys_info_5, 0, 18); | |
5131 if ( si_mask & IND_SI_5BIS ) memset (alr_data->ma_data.sys_info_5bis, 0, 18); | |
5132 if ( si_mask & IND_SI_5TER ) memset (alr_data->ma_data.sys_info_5ter, 0, 18); | |
5133 if ( si_mask & IND_SI_6 ) memset (alr_data->ma_data.sys_info_6, 0, 18); | |
5134 } | |
5135 | |
5136 | |
5137 | |
5138 /* | |
5139 +--------------------------------------------------------------------+ | |
5140 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5141 | STATE : code ROUTINE : ma_fill_dedi_sys_buffer | | |
5142 +--------------------------------------------------------------------+ | |
5143 | |
5144 PURPOSE : Stores a System Information Message from SACCH. | |
5145 | |
5146 */ | |
5147 LOCAL void ma_fill_dedi_sys_buffer (T_MPHC_DATA_IND * mphc_data_ind, | |
5148 UBYTE msg_t) | |
5149 { | |
5150 GET_INSTANCE_DATA; | |
5151 switch (msg_t) | |
5152 { | |
5153 case D_SYS_INFO_5: | |
5154 memcpy (alr_data->ma_data.sys_info_5, | |
5155 &mphc_data_ind->l2_frame.content[5], 18); | |
5156 break; | |
5157 case D_SYS_INFO_5BIS: | |
5158 memcpy (alr_data->ma_data.sys_info_5bis, | |
5159 &mphc_data_ind->l2_frame.content[5], 18); | |
5160 break; | |
5161 case D_SYS_INFO_5TER: | |
5162 memcpy (alr_data->ma_data.sys_info_5ter, | |
5163 &mphc_data_ind->l2_frame.content[5], 18); | |
5164 break; | |
5165 case D_SYS_INFO_6: | |
5166 memcpy (alr_data->ma_data.sys_info_6, | |
5167 &mphc_data_ind->l2_frame.content[5], 18); | |
5168 break; | |
5169 } | |
5170 } | |
5171 | |
5172 /* | |
5173 +--------------------------------------------------------------------+ | |
5174 | PROJECT : GSM-PS (6103) MODULE : alr_MAIN | | |
5175 | STATE : code ROUTINE : ma_compare_dedi_sys_buffer | | |
5176 +--------------------------------------------------------------------+ | |
5177 | |
5178 PURPOSE : Compares a System Information Message on SACCH. | |
5179 | |
5180 */ | |
5181 | |
5182 LOCAL BOOL ma_compare_dedi_sys_buffer (T_MPHC_DATA_IND * mphc_data_ind, | |
5183 UBYTE msg_t) | |
5184 { | |
5185 GET_INSTANCE_DATA; | |
5186 switch (msg_t) | |
5187 { | |
5188 case D_SYS_INFO_5: | |
5189 return (!memcmp (alr_data->ma_data.sys_info_5, | |
5190 &mphc_data_ind->l2_frame.content[5], 18)); | |
5191 /*break;*/ | |
5192 case D_SYS_INFO_5BIS: | |
5193 return (!memcmp (alr_data->ma_data.sys_info_5bis, | |
5194 &mphc_data_ind->l2_frame.content[5], 18)); | |
5195 /*break;*/ | |
5196 case D_SYS_INFO_5TER: | |
5197 return (!memcmp (alr_data->ma_data.sys_info_5ter, | |
5198 &mphc_data_ind->l2_frame.content[5], 18)); | |
5199 /*break;*/ | |
5200 case D_SYS_INFO_6: | |
5201 return (!memcmp (alr_data->ma_data.sys_info_6, | |
5202 &mphc_data_ind->l2_frame.content[5], 18)); | |
5203 /*break;*/ | |
5204 default: | |
5205 break; | |
5206 } | |
5207 return FALSE; | |
5208 } | |
5209 | |
5210 /* | |
5211 +--------------------------------------------------------------------+ | |
5212 | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | |
5213 | STATE : code ROUTINE : tim_stop_sync_to_nw | | |
5214 +--------------------------------------------------------------------+ | |
5215 | |
5216 PURPOSE : Timeout of TIM_NW_SYNC_GUARD - Time to cancel Nw | |
5217 search as it is taking too long | |
5218 | |
5219 */ | |
5220 GLOBAL void tim_stop_sync_to_nw( void ) | |
5221 { | |
5222 GET_INSTANCE_DATA; | |
5223 /* Change the CS State to CS_NW_SYNC_TIMEOUT only if NW Sync is active */ | |
5224 if(alr_data->cs_data.sync_active) | |
5225 { | |
5226 SET_STATE(STATE_CS, CS_NW_SYNC_TIMEOUT); | |
5227 ma_cs_stop_network_sync_req(); | |
5228 } | |
5229 } | |
5230 | |
5231 #ifdef _TARGET_ | |
5232 #ifndef FAX_AND_DATA | |
5233 /* | |
5234 * Dummy functions for RA (needed when building voice-only PS w/ F&D TI | |
5235 * layer 1 libs). | |
5236 */ | |
5237 GLOBAL void dll_data_ul | |
5238 ( | |
5239 USHORT *_ul_buffer_address, | |
5240 USHORT *_d_ra_conf, | |
5241 USHORT *_d_ra_act, | |
5242 USHORT *_d_ra_test, | |
5243 USHORT *_d_ra_statu, | |
5244 USHORT *_d_fax | |
5245 ) | |
5246 { | |
5247 /* do nothing */ | |
5248 } | |
5249 | |
5250 GLOBAL void dll_data_dl | |
5251 ( | |
5252 USHORT *_dl_buffer_address, | |
5253 USHORT *_d_ra_act, | |
5254 USHORT *_d_ra_statd | |
5255 ) | |
5256 { | |
5257 /* do nothing */ | |
5258 } | |
5259 #endif /* !_FAX_AND_DATA_ */ | |
5260 | |
5261 #ifndef GPRS | |
5262 /* | |
5263 * Dummy functions for GRR (needed when building non-GPRS PS w/ GPRS TI | |
5264 * layer 1 libs). | |
5265 */ | |
5266 typedef void T_ul_poll_resp; | |
5267 typedef void T_ul_data; | |
5268 typedef void T_dl_struct; | |
5269 typedef UBYTE UWORD8; | |
5270 typedef ULONG UWORD32; | |
5271 #define WORD8 UBYTE | |
5272 #define UWORD16 USHORT | |
5273 | |
5274 GLOBAL void maca_power_control ( UWORD8 assignment_id, | |
5275 BOOL crc_error, | |
5276 WORD8 bcch_level, | |
5277 UWORD16 *radio_freq, | |
5278 WORD8 *burst_level, | |
5279 UWORD8 *pch ) | |
5280 { | |
5281 /* do nothing */ | |
5282 } | |
5283 | |
5284 GLOBAL void rlc_uplink ( UWORD8 assignment_id, | |
5285 UWORD8 tx_data_no, | |
5286 UWORD32 fn, | |
5287 UWORD8 timing_advance_value, | |
5288 T_ul_poll_resp * ul_poll_response, | |
5289 T_ul_data * ul_data, | |
5290 BOOL allocation_exhausted) | |
5291 { | |
5292 /* do nothing */ | |
5293 } | |
5294 | |
5295 GLOBAL void rlc_downlink ( UWORD8 assignment_id, | |
5296 UWORD32 fn, | |
5297 T_dl_struct *data_ptr, | |
5298 UWORD8 rlc_blocks_sent, | |
5299 UWORD8 last_poll_response) | |
5300 { | |
5301 /* do nothing */ | |
5302 } | |
5303 #endif /* !GPRS */ | |
5304 #endif /* _TARGET_ */ | |
5305 #if defined (REL99) && defined (TI_PS_FF_EMR) | |
5306 /* | |
5307 +--------------------------------------------------------------------+ | |
5308 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5309 | STATE : code ROUTINE : ma_mph_enhpara_update_req | | |
5310 +--------------------------------------------------------------------+ | |
5311 | |
5312 PURPOSE : Process the primitive MPH_ENHPARA_UPDATE_REQ. | |
5313 | |
5314 */ | |
5315 | |
5316 GLOBAL void ma_mph_enhpara_update_req (T_MPH_ENHPARA_UPDATE_REQ* p_enh) | |
5317 { | |
5318 GET_INSTANCE_DATA; | |
5319 /*UBYTE i=0;*/ | |
5320 | |
5321 alr_data->nc_data.emr_data.rep_type = p_enh->rep_type; | |
5322 alr_data->nc_data.emr_data.enh_para = p_enh->enh_para; | |
5323 PFREE(p_enh); | |
5324 return; | |
5325 } | |
5326 | |
5327 /* | |
5328 +--------------------------------------------------------------------+ | |
5329 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5330 | STATE : code ROUTINE : ma_mph_mon_ctrl_req | | |
5331 +--------------------------------------------------------------------+ | |
5332 | |
5333 PURPOSE : Process the primitive MPH_MON_CTRL_REQ. | |
5334 | |
5335 */ | |
5336 GLOBAL void ma_mph_mon_ctrl_req(T_MPH_MON_CTRL_REQ* ctrl_req) | |
5337 { | |
5338 GET_INSTANCE_DATA; | |
5339 TRACE_EVENT ("ma_mph_mon_ctrl_req"); | |
5340 /*Note: Request for monitoring SI-2quater will always be | |
5341 given for serving cell and when it is in stable IDLE state | |
5342 So, no need to check for MA_STATE here*/ | |
5343 if ( (ctrl_req->action EQ START_MON_NBCCH ) AND | |
5344 (ctrl_req->si_to_read EQ UPDATE_SI2QUATER ) ) | |
5345 { | |
5346 if(alr_data->ma_data.sys_info_2quater[1] EQ D_SYS_INFO_2QUATER) | |
5347 { | |
5348 ma_send_stored_SI2qtr(&alr_data->ma_data.sys_info_2quater[0]); | |
5349 memset (alr_data->ma_data.sys_info_2quater, 0, 22); | |
5350 } | |
5351 ma_scell_mon_si2quater_nbcch(); | |
5352 } | |
5353 else if ( (ctrl_req->action EQ START_MON_EBCCH ) AND | |
5354 (ctrl_req->si_to_read EQ UPDATE_SI2QUATER ) ) | |
5355 { | |
5356 if(alr_data->ma_data.sys_info_2quater[1] EQ D_SYS_INFO_2QUATER) | |
5357 { | |
5358 ma_send_stored_SI2qtr(&alr_data->ma_data.sys_info_2quater[0]); | |
5359 memset (alr_data->ma_data.sys_info_2quater, 0, 22); | |
5360 } | |
5361 ma_scell_mon_si2quater_ebcch(); | |
5362 } | |
5363 else if((ctrl_req->si_to_read EQ UPDATE_SI2QUATER_AGAIN) AND | |
5364 (ctrl_req->action EQ START_MON_EBCCH )) | |
5365 { | |
5366 ma_scell_mon_si2quater_ebcch(); | |
5367 } | |
5368 else if((ctrl_req->si_to_read EQ UPDATE_SI2QUATER_AGAIN) AND | |
5369 (ctrl_req->action EQ START_MON_NBCCH )) | |
5370 { | |
5371 ma_scell_mon_si2quater_nbcch(); | |
5372 } | |
5373 | |
5374 else if ( (ctrl_req->action EQ STOP_MON_BCCH)AND | |
5375 (ctrl_req->si_to_read EQ UPDATE_SI2QUATER ) ) | |
5376 { | |
5377 if ( alr_data->nc_data.si2quater_status EQ SI2QUATER_ACQ_PENDING) | |
5378 { | |
5379 if(alr_data->nc_data.si2quater_pos EQ SI2QUATER_ON_EBCCH) | |
5380 { | |
5381 ma_stop_scell_bcch_req(); | |
5382 } | |
5383 sc_start_periodic(); | |
5384 } | |
5385 alr_data->nc_data.si2quater_status = SI2QUATER_ACQ_COMP; | |
5386 } | |
5387 else if((ctrl_req->action EQ STOP_MON_BCCH)AND | |
5388 (ctrl_req->si_to_read EQ UPDATE_SI2QUATER_AGAIN) ) | |
5389 { | |
5390 if (alr_data->nc_data.si2quater_status EQ SI2QUATER_ACQ_PENDING) | |
5391 { | |
5392 if(alr_data->nc_data.si2quater_pos EQ SI2QUATER_ON_EBCCH) | |
5393 { | |
5394 ma_stop_scell_bcch_req(); | |
5395 } | |
5396 sc_start_periodic(); | |
5397 } | |
5398 alr_data->nc_data.si2quater_status = SI2QUATER_ACQ_WRONG_BAIND; | |
5399 } | |
5400 | |
5401 #ifdef GPRS | |
5402 else | |
5403 { | |
5404 gprs_alr_mon_ctrl_req(ctrl_req); | |
5405 return; | |
5406 } | |
5407 #endif | |
5408 | |
5409 #ifdef _SIMULATION_ | |
5410 switch(alr_data->nc_data.si2quater_status) { | |
5411 case SI2QUATER_ACQ_PENDING: | |
5412 TRACE_EVENT ("Status of SI-2quater : SI2QUATER_ACQ_PENDING"); | |
5413 break; | |
5414 case SI2QUATER_ACQ_FULL_BCCH: | |
5415 TRACE_EVENT ("Status of SI-2quater : SI2QUATER_ACQ_FULL_BCCH"); | |
5416 break; | |
5417 case SI2QUATER_ACQ_COMP: | |
5418 TRACE_EVENT ("Status of SI-2quater : SI2QUATER_ACQ_COMP"); | |
5419 break; | |
5420 case SI2QUATER_ACQ_WRONG_BAIND: | |
5421 TRACE_EVENT ("Status of SI-2quater : SI2QUATER_ACQ_WRONG_BAIND"); | |
5422 break; | |
5423 default: | |
5424 TRACE_EVENT ("Status of SI-2quater : SI2QUATER_ABSENT"); | |
5425 } | |
5426 #endif | |
5427 PFREE(ctrl_req); | |
5428 return; | |
5429 } | |
5430 | |
5431 /* | |
5432 +--------------------------------------------------------------------+ | |
5433 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5434 | STATE : code ROUTINE : ma_scell_mon_si2quater_ebcch | | |
5435 +--------------------------------------------------------------------+ | |
5436 | |
5437 PURPOSE : configure L1 for monitoring SI-2quater on EBCCH. | |
5438 | |
5439 */ | |
5440 GLOBAL void ma_scell_mon_si2quater_ebcch(void) | |
5441 { | |
5442 GET_INSTANCE_DATA; | |
5443 PALLOC(req, MPHC_SCELL_EBCCH_REQ); | |
5444 TRACE_EVENT ("ma_scell_mon_si2quater_ebcch"); | |
5445 req->schedule_array_size = 1; | |
5446 req->schedule_array[0].relative_position = 5; | |
5447 req->schedule_array[0].modulus = 8; | |
5448 ma_scell_ebcch_req(req); | |
5449 alr_data->nc_data.si2quater_status = SI2QUATER_ACQ_PENDING; | |
5450 } | |
5451 | |
5452 /* | |
5453 +--------------------------------------------------------------------+ | |
5454 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5455 | STATE : code ROUTINE : ma_scell_mon_si2quater_nbcch | | |
5456 +--------------------------------------------------------------------+ | |
5457 | |
5458 PURPOSE : configure L1 for monitoring SI-2quater on NBCCH. | |
5459 | |
5460 */ | |
5461 GLOBAL void ma_scell_mon_si2quater_nbcch(void) | |
5462 { | |
5463 GET_INSTANCE_DATA; | |
5464 PALLOC(req, MPHC_SCELL_NBCCH_REQ); | |
5465 TRACE_EVENT ("ma_scell_mon_si2quater_nbcch"); | |
5466 /*on N-BCCH, SI-2quater can be received on either | |
5467 TC = 5 or 4 depending on scheduling of SI-2bis/ter */ | |
5468 req->schedule_array_size = 2; | |
5469 req->schedule_array[0].relative_position = 5; | |
5470 req->schedule_array[0].modulus = 8; | |
5471 req->schedule_array[1].relative_position = 4; | |
5472 req->schedule_array[1].modulus = 8; | |
5473 ma_scell_nbcch_req(req); | |
5474 alr_data->nc_data.si2quater_status = SI2QUATER_ACQ_PENDING; | |
5475 return; | |
5476 } | |
5477 | |
5478 /* BCCH MAPPING | |
5479 ==================================================================== | |
5480 System Information Message | Sent when TC = | Allocation | |
5481 ==================================================================== | |
5482 Type 1 0 BCCH Norm | |
5483 ----------------------------------------------------------------- | |
5484 Type 2 1 BCCH Norm | |
5485 ----------------------------------------------------------------- | |
5486 Type 2 bis 5 BCCH Norm | |
5487 ----------------------------------------------------------------- | |
5488 Type 2 ter 5 or 4 BCCH Norm | |
5489 ----------------------------------------------------------------- | |
5490 Type 2 quater 5 BCCH Norm | |
5491 or | |
5492 4or5 BCCH Ext | |
5493 ----------------------------------------------------------------- | |
5494 Type 3 2 and 6 BCCH Norm | |
5495 ----------------------------------------------------------------- | |
5496 Type 4 3 and 7 BCCH Norm | |
5497 ----------------------------------------------------------------- | |
5498 Type 7 7 BCCH Ext | |
5499 ----------------------------------------------------------------- | |
5500 Type 8 3 BCCH Ext | |
5501 ----------------------------------------------------------------- | |
5502 Type 9 4 BCCH Norm | |
5503 ----------------------------------------------------------------- | |
5504 Type 13 4 BCCH Norm | |
5505 or | |
5506 0 BCCH Ext | |
5507 ----------------------------------------------------------------- | |
5508 Type 16 6 BCCH Ext | |
5509 ----------------------------------------------------------------- | |
5510 Type 17 2 BCCH Ext | |
5511 ----------------------------------------------------------------- | |
5512 */ | |
5513 | |
5514 /* | |
5515 +--------------------------------------------------------------------+ | |
5516 | PROJECT : GSM-PS (6103) MODULE : ALR_MAIN | | |
5517 | STATE : code ROUTINE : ma_send_stored_SI2qtr | | |
5518 +--------------------------------------------------------------------+ | |
5519 | |
5520 PURPOSE : Cut pseudo length and send the stored SI2qtr data to RR. | |
5521 | |
5522 */ | |
5523 GLOBAL void ma_send_stored_SI2qtr(UBYTE* si_2quater) | |
5524 { | |
5525 GET_INSTANCE_DATA; | |
5526 USHORT len_in_bits = 22 * BITS_PER_BYTE; | |
5527 PALLOC_SDU (data_out, MPH_UNITDATA_IND, len_in_bits); | |
5528 | |
5529 /* No IE and Pseudo Length */ | |
5530 data_out->sdu.l_buf = (22 ) * BITS_PER_BYTE; | |
5531 /* Pseudo Length */ | |
5532 data_out->sdu.o_buf = 0; | |
5533 /* No IE */ | |
5534 /*lint -e{419} (Warning -- Apparent data overrun) */ | |
5535 memcpy (data_out->sdu.buf, &si_2quater[0], 22 ); | |
5536 data_out->arfcn = alr_data->serving_cell; | |
5537 TRACE_EVENT("SI2qtr sent from the function ma_send_stored_SI2qtr"); | |
5538 PSENDX (RR, data_out); | |
5539 } | |
5540 #endif | |
5541 | |
5542 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT | |
5543 LOCAL void compare_l1_frequency_band_with_ffs (T_MPHC_INIT_L1_CON *init_l1_cnf) | |
5544 { | |
5545 GET_INSTANCE_DATA; | |
5546 int i; | |
5547 U16 freq_band ; | |
5548 | |
5549 PALLOC(mph_init_rr_ind, MPH_INIT_RR_IND); | |
5550 | |
5551 for (i=0; i<NB_MAX_GSM_BANDS; i++) | |
5552 { | |
5553 if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_PGSM900) | |
5554 { | |
5555 freq_band |= BAND_GSM_900; | |
5556 mph_init_rr_ind->pclass_900 = init_l1_cnf->multiband_power_class[i].power_class; | |
5557 } | |
5558 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_GSM850) | |
5559 { | |
5560 freq_band |= BAND_GSM_850; | |
5561 mph_init_rr_ind->pclass_850 = init_l1_cnf->multiband_power_class[i].power_class; | |
5562 } | |
5563 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_PCS1900) | |
5564 { | |
5565 freq_band |= BAND_PCS_1900; | |
5566 mph_init_rr_ind->pclass_1900 = init_l1_cnf->multiband_power_class[i].power_class; | |
5567 } | |
5568 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_DCS1800) | |
5569 { | |
5570 freq_band |= BAND_DCS_1800; | |
5571 mph_init_rr_ind->pclass_1800 = init_l1_cnf->multiband_power_class[i].power_class; | |
5572 } | |
5573 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_GSM480) | |
5574 { | |
5575 freq_band |= BAND_GSM_480; | |
5576 } | |
5577 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_GSM450) | |
5578 { | |
5579 freq_band |= BAND_GSM_450; | |
5580 } | |
5581 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_EGSM900) | |
5582 { | |
5583 freq_band |= BAND_E_GSM; | |
5584 mph_init_rr_ind->pclass_900 = init_l1_cnf->multiband_power_class[i].power_class; | |
5585 } | |
5586 else if (init_l1_cnf->multiband_power_class[i].radio_band == RADIO_BAND_RGSM900) | |
5587 { | |
5588 freq_band |= BAND_R_GSM; | |
5589 } | |
5590 } | |
5591 | |
5592 mph_init_rr_ind->freq_bands = freq_band; | |
5593 PSENDX (RR, mph_init_rr_ind); | |
5594 /* | |
5595 if (freq_band NEQ alr_data->cs_data.freq_bands) | |
5596 { | |
5597 TRACE_EVENT_P2 ("FFS data %x, doen't match L1 compilation flag %x", alr_data->cs_data.freq_bands, freq_band); | |
5598 TRACE_ERROR ("FFS data doesn't match L1 compilation flag"); | |
5599 TRACE_ASSERT (freq_band NEQ alr_data->cs_data.freq_bands); | |
5600 }*/ | |
5601 } | |
5602 #endif | |
5603 | |
5604 #endif /* ALR_MAIN_C */ |