FreeCalypso > hg > fc-magnetite

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/g23m-gprs: initial import from TCS3.2/LoCosto
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 13 Oct 2016 04:24:13 +0000
parents
children
comparison
equal deleted inserted replaced
182:f02d0a0e1849 183:219afcfc6250
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GPRS (8441)
4 | Modul : GRR
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This module implements signal handler functions for service
18 | CPAP of entity GRR.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef GRR_CPAPS_C
23 #define GRR_CPAPS_C
24 #endif
25
26 #define ENTITY_GRR
27
28 /*==== INCLUDES =============================================================*/
29
30 #include "typedefs.h" /* to get Condat data types */
31
32 #include "vsi.h" /* to get a lot of macros */
33 #include "macdef.h"
34 #include "gprs.h"
35 #include "gsm.h" /* to get a lot of macros */
36 #include "ccdapi.h" /* to get CCD API */
37 #include "cnf_grr.h" /* to get cnf-definitions */
38 #include "mon_grr.h" /* to get mon-definitions */
39 #include "prim.h" /* to get the definitions of used SAP and directions */
40 #include "message.h"
41 #include <string.h>
42 #include "grr.h" /* to get the global entity definitions */
43 #include "grr_f.h"
44 #include "grr_tcs.h"
45 #include "grr_cpapf.h"
46
47
48
49
50 /*==== CONST ================================================================*/
51
52 /*==== DIAGNOSTICS ==========================================================*/
53
54 /*==== LOCAL VARS ===========================================================*/
55
56 /*==== PRIVATE FUNCTIONS ====================================================*/
57
58 /*==== PUBLIC FUNCTIONS =====================================================*/
59 /*
60 +------------------------------------------------------------------------------
61 | Function : sig_tc_cpap_abort_access
62 +------------------------------------------------------------------------------
63 | Description : Handles the internal signal SIG_TC_CPAP_ABORT_ACCESS
64 |
65 | Parameters : void
66 |
67 +------------------------------------------------------------------------------
68 */
69 GLOBAL void sig_tc_cpap_abort_access ( void )
70 {
71 TRACE_ISIG( "sig_tc_cpap_abort_access" );
72
73 switch( GET_STATE( CPAP ) )
74 {
75 case CPAP_WAIT_STOP_TASK_CNF:
76 cpap_mfree_ia( FALSE );
77
78 /*lint -fallthrough*/
79
80 case CPAP_SB_STARTED:
81 case CPAP_1P_STARTED:
82 case CPAP_WAIT_PDCH_ASSIGN:
83 SET_STATE( CPAP, CPAP_IDLE );
84
85 sig_cpap_tc_error_pim();
86 break;
87 default:
88 TRACE_ERROR( "SIG_TC_CPAP_ABORT_ACCESS unexpected" );
89 break;
90 }
91 } /* sig_tc_cpap_abort_access() */
92
93 /*
94 +------------------------------------------------------------------------------
95 | Function : sig_tc_cpap_acc_req
96 +------------------------------------------------------------------------------
97 | Description : Handles the internal signal SIG_TC_CPAP_ACC_REQ
98 |
99 | Parameters : void
100 |
101 +------------------------------------------------------------------------------
102 */
103 GLOBAL void sig_tc_cpap_acc_req ( void )
104 {
105 /* UBYTE random_value = 0; random value is handled by rr */
106 UBYTE req_data = 0;
107
108 TRACE_ISIG( "sig_tc_cpap_acc_req" );
109
110
111
112 switch( GET_STATE( CPAP ) )
113 {
114 case CPAP_IDLE:
115 /* estimate access type */
116 switch(grr_data->uplink_tbf.access_type)
117 {
118 case CGRLC_AT_ONE_PHASE:
119 case CGRLC_AT_SHORT_ACCESS:
120 /*
121 * if ms class allows more than one uplink slot,
122 * then two phase access is triggered.
123 * Otherwise multislot uplink is not assigned on some network vendors */
124 #ifdef _TARGET_
125 if(grr_data->ms_cap[grr_get_gprs_ms_class( )-1].Tx > 1)
126 {
127 SET_STATE(CPAP,CPAP_SB_STARTED);
128 req_data = 0x70;
129 TRACE_EVENT_P1("2 PHASE FOR UPLINK MULTISLLOT ms_class=%d"
130 ,grr_get_gprs_ms_class( ));
131 break;
132 }
133 #endif
134 case CGRLC_AT_PAGE_RESPONSE:
135 case CGRLC_AT_MM_PROCEDURE:
136 case CGRLC_AT_CELL_UPDATE:
137 req_data = 0x78;
138 /*
139 * due to 04.08. chapter 9.1.8 random value for last 3 bit
140 * shall be between 0 and 7
141 */
142 /* random value is handled by rr */
143 SET_STATE(CPAP,CPAP_1P_STARTED);
144 break;
145
146 case CGRLC_AT_TWO_PHASE:
147 case CGRLC_AT_SINGLE_BLOCK:
148 req_data = 0x70;
149 /*
150 * due to 04.08. chapter 9.1.8 random value for last 3 bit
151 * shall be between 0 and 7
152 */
153 /* random value is handled by rr */
154 SET_STATE(CPAP,CPAP_SB_STARTED);
155 break;
156 default:
157 break;
158 }
159 {
160 PALLOC(rrgrr_gprs_data_req,RRGRR_GPRS_DATA_REQ);
161
162 cpap_build_gprs_data_request(rrgrr_gprs_data_req);
163 sig_cpap_tc_send_gprs_data_req(rrgrr_gprs_data_req);
164 }
165 sig_cpap_tc_channel_req(req_data);
166 break;
167
168 default:
169 /*
170 * SZML-CPAP/017
171 */
172 TRACE_ERROR( "SIG_TC_CPAP_ACC_REQ unexpected" );
173 break;
174 }
175 } /* sig_tc_cpap_acc_req() */
176
177
178
179
180 /*
181 +------------------------------------------------------------------------------
182 | Function : sig_tc_cpap_pdch_assign_received
183 +------------------------------------------------------------------------------
184 | Description : Handles the internal signal SIG_TC_CPAP_PDCH_ASSIGN_RECEIVED
185 |
186 | Parameters : fn - reception frame number
187 |
188 +------------------------------------------------------------------------------
189 */
190 GLOBAL void sig_tc_cpap_pdch_assign_received (T_RRGRR_DATA_IND *rrgrr_data_ind)
191 {
192 TRACE_ISIG( "sig_tc_cpap_pdch_assign_received" );
193 grr_data->dl_fn = rrgrr_data_ind->fn;
194 grr_data->ul_fn = rrgrr_data_ind->fn;
195 switch( GET_STATE( CPAP ) )
196 {
197 case CPAP_WAIT_PDCH_ASSIGN:
198 switch(cpap_eval_pdch_assignment())
199 {
200 case E_PDCH_ASSIGN_UL:
201 memcpy(&grr_data->cpap.pdch_ass_cmd,_decodedMsg,sizeof(T_D_PDCH_ASS_CMD));
202 grr_data->cpap.new_tbf_type = CGRLC_TBF_MODE_UL;
203 SET_STATE(CPAP,CPAP_WAIT_DEDI_SUSPEND);
204 sig_cpap_tc_suspend_dedi_chan();
205 break;
206 case E_PDCH_ASSIGN_SB:
207 break;
208 case E_PDCH_ASSIGN_DL:
209 break;
210 case E_PDCH_ASSIGN_IGNORE:
211 break;
212 case E_PDCH_ASSIGN_ERROR:
213 cpap_send_ass_fail(RRC_CHANNEL_MODE);
214 break;
215 default:
216 break;
217 }
218 break;
219
220 default:
221 TRACE_ERROR( "sig_tc_cpap_pdch_assign_received unexpected" );
222 break;
223 }
224 } /* sig_tc_cpap_pdch_assign_received() */
225
226
227 /*
228 +------------------------------------------------------------------------------
229 | Function : sig_tc_cpap_ia_received
230 +------------------------------------------------------------------------------
231 | Description : Handles the internal signal SIG_TC_CPAP_IA_RECEIVED
232 |
233 | Parameters : void
234 |
235 +------------------------------------------------------------------------------
236 */
237 GLOBAL void sig_tc_cpap_ia_received (T_RRGRR_IA_IND *rrgrr_ia_ind)
238 {
239 MCAST(d_imm_assign,D_IMM_ASSIGN); /* T_D_IMM_ASSIGN */
240 T_EVAL_IA eval;
241
242 TRACE_ISIG( "sig_tc_cpap_ia_received" );
243
244 grr_data->dl_fn = rrgrr_ia_ind->fn;
245 grr_data->ul_fn = rrgrr_ia_ind->fn;
246 grr_data->r_bit = rrgrr_ia_ind->r_bit; /* chan req is sent at least twice on ccch */
247 switch( GET_STATE( CPAP ) )
248 {
249 case CPAP_SB_STARTED:
250 case CPAP_1P_STARTED:
251 eval = cpap_eval_ia();
252 if(E_IA_TMA_SECOND EQ eval)
253 { /* 2nd message of TMA */
254 if(grr_data->cpap.v_tma_ia)
255 {
256 cpap_join_tma_messages();
257 eval = cpap_eval_ia();
258 }
259 else
260 {
261 TRACE_ERROR("2nd TMA IA received without 1st!");
262 SET_STATE(CPAP,CPAP_IDLE);
263
264 sig_cpap_tc_error_pim( );
265 return;
266 }
267 }
268
269 grr_data->cpap.last_ia_type = IA_TYPE_UL;
270 grr_data->cpap.last_eval_ia.param_ul.eval_ia = eval;
271
272 if( E_IA_UL EQ eval )
273 { /* Dynamic Allocation */
274 grr_data->cpap.v_tma_ia = FALSE;
275
276 if(d_imm_assign->ia_rest_oct.ia_assign_par.pck_upl_ass_ia.tfi_ass_alloc.v_tbf_start_time)
277 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
278 else
279 sig_cpap_tc_send_stop_task_req( STOP_CCCH );
280
281 cpap_malloc_ia( );
282
283 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
284 return;
285 }
286 else if(E_IA_DCCH EQ eval)
287 { /* continue on DCCH */
288 if(grr_t_status( T3172_1 ) > 0 )
289 {
290 /*
291 * Timer is stil running
292 */
293 sig_cpap_tc_stop_T3142();
294 }
295
296 grr_data->cpap.v_tma_ia = FALSE;
297 SET_STATE(CPAP,CPAP_WAIT_PDCH_ASSIGN);
298 }
299 else if(E_IA_SB_2PHASE_ACCESS EQ eval)
300 { /* Allocation for 2 Phase of 2_Phase-Access */
301 grr_data->cpap.v_tma_ia = FALSE;
302
303 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
304 cpap_malloc_ia( );
305
306 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
307 }
308 else if(E_IA_TMA EQ eval)
309 { /* 1st message of TMA */
310 cpap_store_ia_message();
311 }
312 else if(E_IA_ERROR_RA EQ eval)
313 {
314 /* errornous messages are ignored?!? */
315 TRACE_ERROR("ia message contents nonsense!");
316 SET_STATE(CPAP,CPAP_IDLE);
317 grr_data->cpap.v_tma_ia = FALSE;
318 sig_cpap_tc_error_pim();
319 }
320 else if(E_IA_NULL EQ eval)
321 {
322 /* unforeseen mesage content*/
323 }
324 else if(E_IA_SB_WITHOUT_TBF EQ eval)
325 {
326 grr_data->cpap.v_tma_ia = FALSE;
327
328 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
329 cpap_malloc_ia( );
330
331 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
332 /*TRACE_EVENT("E_IA_SB_WITHOUT_TBF: stop task");*/
333 }
334
335 if( grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param OR
336 grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param OR
337 grr_data->pwr_ctrl_valid_flags.v_freq_param )
338 {
339 grr_cgrlc_pwr_ctrl_req( FALSE );
340 }
341 break;
342
343 case CPAP_IDLE:
344 case CPAP_WAIT_PDCH_ASSIGN:
345 default:
346 TRACE_ERROR( "SIG_TC_CPAP_IA_RECEIVED unexpected" );
347 break;
348 }
349 } /* sig_tc_cpap_ia_received() */
350
351 /*
352 +------------------------------------------------------------------------------
353 | Function : sig_tc_cpap_iaext_received
354 +------------------------------------------------------------------------------
355 | Description : Handles the internal signal SIG_TC_CPAP_IAEXT_RECEIVED
356 |
357 | Parameters : ia_index - indicates the correct immediate assignment
358 |
359 +------------------------------------------------------------------------------
360 */
361 GLOBAL void sig_tc_cpap_iaext_received ( T_RRGRR_IAEXT_IND *rrgrr_iaext_ind )
362 {
363 TRACE_ISIG( "sig_tc_cpap_iaext_received" );
364 /*
365 * SZML-CPAP/024
366 */
367 grr_data->dl_fn = rrgrr_iaext_ind->fn;
368 grr_data->ul_fn = rrgrr_iaext_ind->fn;
369 grr_data->r_bit = rrgrr_iaext_ind->r_bit; /* chan req is sent at least twice on ccch */
370
371 switch( GET_STATE( CPAP ) )
372 {
373 case CPAP_IDLE:
374 /* SZML-CPAP/025 */
375 break;
376 case CPAP_SB_STARTED:
377 case CPAP_1P_STARTED:
378 SET_STATE(CPAP,CPAP_WAIT_PDCH_ASSIGN);
379 break;
380 case CPAP_WAIT_PDCH_ASSIGN:
381 break;
382
383 default:
384 TRACE_ERROR( "SIG_TC_CPAP_IAEXT_RECEIVED unexpected" );
385 break;
386 }
387 } /* sig_tc_cpap_iaext_received() */
388
389 /*
390 +------------------------------------------------------------------------------
391 | Function : sig_tc_cpap_iarej_received
392 +------------------------------------------------------------------------------
393 | Description : Handles the internal signal SIG_TC_CPAP_IAREJ_RECEIVED
394 |
395 | Parameters : wait_ind - is taken from the corresponding air message
396 |
397 +------------------------------------------------------------------------------
398 */
399 GLOBAL void sig_tc_cpap_iarej_received (T_RRGRR_ASSIGNMENT_REJ_IND *rrgrr_assignment_rej_ind)
400 {
401 TRACE_ISIG( "sig_tc_cpap_iarej_received" );
402 grr_data->r_bit = rrgrr_assignment_rej_ind->r_bit; /* chan req is sent at least twice on ccch */
403
404 switch( GET_STATE( CPAP ) )
405 {
406 case CPAP_SB_STARTED:
407 case CPAP_1P_STARTED:
408 if(grr_t_status( T3172_1 ) EQ 0 )
409 {
410 /*Timer not running*/
411 if(rrgrr_assignment_rej_ind->wait_ind)
412 {
413 sig_cpap_tc_start_T3142(1000 * rrgrr_assignment_rej_ind->wait_ind);
414 }
415 else
416 {
417 SET_STATE(CPAP, CPAP_IDLE);
418
419 sig_cpap_tc_error_pim();
420 }
421 } /* no else path because additional rejects have to be ignored!! */
422 break;
423
424 default:
425 TRACE_ERROR( "SIG_TC_CPAP_IAREJ_RECEIVED unexpected" );
426 break;
427 }
428 } /* sig_tc_cpap_iarej_received() */
429
430 /*
431 +------------------------------------------------------------------------------
432 | Function : sig_tc_cpap_ia_downlink_received
433 +------------------------------------------------------------------------------
434 | Description : Handles the internal signal SIG_TC_CPAP_IA_DOWNLINK_RECEIVED
435 |
436 | Parameters : void
437 |
438 +------------------------------------------------------------------------------
439 */
440 GLOBAL void sig_tc_cpap_ia_downlink_received (T_RRGRR_IA_DOWNLINK_IND *rrgrr_ia_downlink_ind)
441 {
442 MCAST(d_imm_assign,D_IMM_ASSIGN);/* T_D_IMM_ASSIGN */
443 UBYTE state = GET_STATE( CPAP );
444 T_EVAL_IA_DL eval;
445
446 TRACE_ISIG( "sig_tc_cpap_ia_downlink_received" );
447
448 /* SZML-CPAP/026 */
449
450 grr_data->dl_fn = rrgrr_ia_downlink_ind->fn;
451 grr_data->ul_fn = rrgrr_ia_downlink_ind->fn;
452
453 switch( state )
454 {
455 case CPAP_IDLE:
456 eval = cpap_eval_ia_dl();
457
458 if(E_IA_DL_TMA_SECOND EQ eval)
459 {
460 if(grr_data->cpap.v_tma_ia)
461 {
462 cpap_join_tma_messages();
463 eval = cpap_eval_ia_dl();
464 }
465 else
466 {
467 TRACE_ERROR("2nd TMA IA received without 1st!");
468 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
469 return;
470 }
471 }
472
473 grr_data->cpap.last_ia_type = IA_TYPE_DL;
474 grr_data->cpap.last_eval_ia.param_dl.state = state;
475 grr_data->cpap.last_eval_ia.param_dl.eval_ia_dl = eval;
476
477 if(E_IA_DL_SB EQ eval)
478 {
479 grr_data->cpap.v_tma_ia = FALSE;
480 cpap_malloc_ia( );
481 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
482 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
483 }
484 else if(E_IA_DL_ASSIGN EQ eval)
485 {
486 grr_data->cpap.v_tma_ia = FALSE;
487 if(d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia.v_tbf_start_time)
488 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
489 else
490 sig_cpap_tc_send_stop_task_req( STOP_CCCH );
491
492 cpap_malloc_ia( );
493 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
494 }
495 else if(E_IA_DL_TMA EQ eval)
496 {
497 cpap_store_ia_message();
498 }
499 else if(E_IA_DL_NOT_OURS EQ eval)
500 {
501 TRACE_EVENT("Message not adressed to MS");
502 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
503 }
504 else if(E_IA_DL_IGNORE EQ eval)
505 {
506 TRACE_EVENT("INVALID DL IA RECEIVED 1 ");
507 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
508 }
509
510 if( grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param OR
511 grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param OR
512 grr_data->pwr_ctrl_valid_flags.v_freq_param )
513 {
514 grr_cgrlc_pwr_ctrl_req( FALSE );
515 }
516 break;
517 case CPAP_SB_STARTED:
518 case CPAP_1P_STARTED:
519 eval = cpap_eval_ia_dl();
520
521 if(E_IA_DL_TMA_SECOND EQ eval)
522 {
523 if(grr_data->cpap.v_tma_ia)
524 {
525 cpap_join_tma_messages();
526 eval = cpap_eval_ia_dl();
527 }
528 else
529 {
530 TRACE_ERROR("2nd TMA IA received without 1st!");
531 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
532 return;
533 }
534 }
535
536 grr_data->cpap.last_ia_type = IA_TYPE_DL;
537 grr_data->cpap.last_eval_ia.param_dl.state = state;
538 grr_data->cpap.last_eval_ia.param_dl.eval_ia_dl = eval;
539
540
541 if(E_IA_DL_ASSIGN EQ eval)
542 {
543 grr_data->cpap.v_tma_ia = FALSE;
544 if(d_imm_assign->ia_rest_oct.ia_assign_par.pck_downl_ass_ia.v_tbf_start_time)
545 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
546 else
547 sig_cpap_tc_send_stop_task_req( STOP_CCCH );
548
549 cpap_malloc_ia( );
550 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
551 }
552 else if(E_IA_DL_SB EQ eval)
553 {
554 TRACE_EVENT_P3("IA_DL_SB ia_type=%d dl_state =%d eval_ia=%d",grr_data->cpap.last_ia_type
555 ,grr_data->cpap.last_eval_ia.param_dl.state
556 ,grr_data->cpap.last_eval_ia.param_dl.eval_ia_dl);
557 grr_data->cpap.v_tma_ia = FALSE;
558 cpap_malloc_ia( );
559 sig_cpap_tc_send_stop_task_req( DONT_STOP_CCCH );
560 SET_STATE( CPAP, CPAP_WAIT_STOP_TASK_CNF );
561 }
562 else if(E_IA_DL_TMA EQ eval)
563 {
564 cpap_store_ia_message();
565 }
566 else if(E_IA_DL_NOT_OURS EQ eval)
567 {
568 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
569 TRACE_EVENT("Message not addressed to MS");
570 }
571 else if(E_IA_DL_IGNORE EQ eval)
572 {
573 TRACE_EVENT("INVALID DL IA RECEIVED 2 ");
574 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
575 }
576
577 if( grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param OR
578 grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param OR
579 grr_data->pwr_ctrl_valid_flags.v_freq_param )
580 {
581 grr_cgrlc_pwr_ctrl_req( FALSE );
582 }
583 break;
584 case CPAP_WAIT_STOP_TASK_CNF:
585 {
586 TRACE_EVENT( "SIG_TC_CPAP_IA_DOWNLINK_RECEIVED processing of another IA not finished" );
587 }
588 break;
589 default:
590 {
591 TRACE_ERROR( "SIG_TC_CPAP_IA_DOWNLINK_RECEIVED unexpected" );
592 sig_cpap_tc_send_stop_task_req( INVALID_MSG );
593 }
594 break;
595 }
596 } /* sig_tc_cpap_ia_downlink_received() */
597
598 /*
599 +------------------------------------------------------------------------------
600 | Function : sig_tc_cpap_stop_task_cnf_received
601 +------------------------------------------------------------------------------
602 | Description : Handles the internal signal SIG_TC_CPAP_STOP_TASK_CNF
603 |
604 | Parameters :
605 |
606 +------------------------------------------------------------------------------
607 */
608 GLOBAL void sig_tc_cpap_stop_task_cnf_received( void )
609 {
610 T_TBF_TYPE tbf_type;
611
612 TRACE_ISIG( "sig_tc_cpap_stop_task_cnf_received" );
613 /*
614 TRACE_EVENT_P3("IA_DL_SB ia_type=%d dl_state =%d eval_ia=%d",grr_data->cpap.last_ia_type
615 ,grr_data->cpap.last_eval_ia.param_dl.state
616 ,grr_data->cpap.last_eval_ia.param_dl.eval_ia_dl);
617 */
618 switch( GET_STATE( CPAP ) )
619 {
620 case CPAP_WAIT_STOP_TASK_CNF:
621
622 cpap_mfree_ia( TRUE );
623
624 switch( grr_data->cpap.last_ia_type )
625 {
626 case IA_TYPE_UL:
627
628 switch( grr_data->cpap.last_eval_ia.param_ul.eval_ia )
629 {
630 case E_IA_UL:
631 tbf_type = CGRLC_TBF_MODE_UL;
632 if( cpap_send_assign_req_ia( tbf_type ) )
633 {
634 if(grr_t_status( T3172_1 ) > 0 )
635 {
636 sig_cpap_tc_stop_T3142( );
637 }
638
639 SET_STATE( CPAP,CPAP_IDLE );
640
641 sig_cpap_tc_tbf_created( tbf_type );
642 }
643 else
644 {
645 SET_STATE( CPAP,CPAP_IDLE );
646
647 sig_cpap_tc_error_pim();
648 }
649 break;
650 case E_IA_SB_2PHASE_ACCESS:
651 if(cpap_send_resource_request_ia())
652 {
653 SET_STATE( CPAP,CPAP_IDLE );
654 if(grr_t_status( T3172_1 ) > 0 )
655 {
656 sig_cpap_tc_stop_T3142();
657 }
658 }
659 else
660 {
661 SET_STATE( CPAP,CPAP_IDLE );
662 sig_cpap_tc_error_pim();
663 }
664 break;
665 case E_IA_SB_WITHOUT_TBF:
666 SET_STATE(CPAP,CPAP_IDLE);
667 /*TRACE_EVENT("E_IA_SB_WITHOUT_TBF: stop task cnf received");*/
668 if(cpap_send_single_block_without_tbf())
669 {
670 if(grr_t_status( T3172_1 ) > 0 )
671 {
672 sig_cpap_tc_stop_T3142();
673 }
674 }
675 else
676 {
677 sig_cpap_tc_error_pim();
678 }
679 break;
680 default:
681 SET_STATE( CPAP, CPAP_IDLE );
682 TRACE_ERROR( "SIG_TC_CPAP_STOP_TASK_CNF: eval_ia invalid" );
683 return;
684 }
685
686 break;
687
688 case IA_TYPE_DL:
689
690 switch( grr_data->cpap.last_eval_ia.param_dl.state )
691 {
692 case CPAP_IDLE:
693 case CPAP_SB_STARTED:
694 case CPAP_1P_STARTED:
695 switch( grr_data->cpap.last_eval_ia.param_dl.eval_ia_dl )
696 {
697 case E_IA_DL_ASSIGN:
698 if( cpap_send_assign_req_ia( CGRLC_TBF_MODE_DL ) )
699 {
700 if(grr_t_status( T3172_1 ) > 0 )
701 {
702 sig_cpap_tc_stop_T3142( );
703 }
704 sig_cpap_tc_tbf_created( CGRLC_TBF_MODE_DL );
705 }
706 else
707 {
708 sig_cpap_tc_error_pim();
709 }
710 break;
711 case E_IA_DL_SB:
712 if(!cpap_send_receive_normal_burst())
713 {
714 sig_cpap_tc_error_pim();
715 }
716 else if(grr_t_status( T3172_1 ) > 0)
717 {
718 sig_cpap_tc_stop_T3142();
719 }
720 break;
721 default:
722 TRACE_ERROR( "SIG_TC_CPAP_STOP_TASK_CNF: eval_ia_dl invalid cpap_sb_1p_started" );
723 sig_cpap_tc_error_pim();
724 return;
725 }
726 SET_STATE( CPAP,CPAP_IDLE );
727 break;
728
729 default:
730 SET_STATE( CPAP, CPAP_IDLE );
731 TRACE_ERROR( "SIG_TC_CPAP_STOP_TASK_CNF: state invalid" );
732 return;
733 }
734 break;
735
736 default:
737 SET_STATE( CPAP, CPAP_IDLE );
738 TRACE_ERROR( "SIG_TC_CPAP_STOP_TASK_CNF: last_ia_type invalid" );
739 return;
740 }
741 break;
742
743 default:
744 TRACE_ERROR( "SIG_TC_CPAP_STOP_TASK_CNF unexpected" );
745 break;
746 }
747 } /* sig_tc_cpap_stop_task_cnf_received() */
748
749 /*
750 +------------------------------------------------------------------------------
751 | Function : sig_tc_cpap_new_cell
752 +------------------------------------------------------------------------------
753 | Description : Handles the internal signal SIG_TC_CPAP_NEW_CELL in case of
754 | T3142 is running it shall bestopped. New Access procedures if
755 | necessary will be started by service TC.
756 |
757 | Parameters : void
758 |
759 +------------------------------------------------------------------------------
760 */
761 GLOBAL void sig_tc_cpap_new_cell ( void )
762 {
763 if( GET_STATE( CPAP ) EQ CPAP_WAIT_STOP_TASK_CNF )
764 {
765 cpap_mfree_ia( FALSE );
766 }
767
768 SET_STATE(CPAP,CPAP_IDLE);
769 } /* sig_tc_cpap_new_cell() */
770
771
772
773
774 /*
775 +------------------------------------------------------------------------------
776 | Function : sig_tc_cpap_con_res_fail
777 +------------------------------------------------------------------------------
778 | Description : Handles the internal signal SIG_TC_CPAP_CON_RES_FAIL
779 |
780 | Parameters : void
781 |
782 +------------------------------------------------------------------------------
783 */
784 GLOBAL void sig_tc_cpap_con_res_fail ( void )
785 {
786 TRACE_ISIG( "sig_tc_cpap_con_res_fail" );
787
788 switch(GET_STATE(CPAP))
789 {
790 default:
791 TRACE_ERROR("sig_tc_cpap_con_res_fail unexpected!");
792 break;
793 case CPAP_IDLE:
794 SET_STATE(CPAP,CPAP_WAIT_PDCH_ASSIGN);
795 sig_cpap_tc_resume_dedi_chan();
796 cpap_send_ass_fail(RRC_PROT_UNSPECIFIED);
797 break;
798 }
799
800
801 } /* sig_tc_cpap_con_res_fail() */
802
803
804
805 /*
806 +------------------------------------------------------------------------------
807 | Function : sig_tc_cpap_suspend_dcch_cnf
808 +------------------------------------------------------------------------------
809 | Description : Handles the internal signal SIG_TC_CPAP_SUSPEND_DCCH_CNF
810 |
811 | Parameters : void
812 |
813 +------------------------------------------------------------------------------
814 */
815 GLOBAL void sig_tc_cpap_suspend_dcch_cnf ( void )
816 {
817 TRACE_ISIG( "sig_tc_cpap_suspend_dcch_cnf" );
818
819 switch(GET_STATE(CPAP))
820 {
821 case CPAP_WAIT_DEDI_SUSPEND:
822 memcpy(_decodedMsg,&grr_data->cpap.pdch_ass_cmd,sizeof(T_D_PDCH_ASS_CMD));
823 cpap_send_assign_req_pdch(grr_data->cpap.new_tbf_type);
824 sig_cpap_tc_ctrl_ptm();
825 sig_cpap_tc_tbf_created(grr_data->cpap.new_tbf_type);
826
827 break;
828 default:
829 TRACE_ERROR("sig_tc_cpap_suspend_dcch_cnf unexpected!");
830 break;
831 }
832
833
834 } /* sig_tc_cpap_suspend_dcch_cnf() */
835
836 /*
837 +------------------------------------------------------------------------------
838 | Function : sig_tc_cpap_t3142
839 +------------------------------------------------------------------------------
840 | Description : Handles the internal signal SIG_TC_CPAP_T3142
841 |
842 | Parameters : void
843 |
844 +------------------------------------------------------------------------------
845 */
846 GLOBAL void sig_tc_cpap_t3142 ( void )
847 {
848 TRACE_FUNCTION( "sig_tc_cpap_t3142" );
849
850 switch( GET_STATE( CPAP ) )
851 {
852
853
854 case CPAP_IDLE:
855 /* nothing to do */
856 TRACE_EVENT( "SIG_TC_CPAP_T3142 in CPAP_IDLE: nothing to do" );
857 /* this should not happen */
858 break;
859 case CPAP_1P_STARTED:
860 case CPAP_SB_STARTED:
861 SET_STATE(CPAP,CPAP_IDLE);
862 /* sig_cpap_tc_error_pim(); */
863 break;
864 case CPAP_WAIT_STOP_TASK_CNF:
865 SET_STATE(CPAP,CPAP_IDLE);
866
867 cpap_mfree_ia( FALSE );
868 /* sig_cpap_tc_error_pim(); */
869 break;
870 default:
871 TRACE_ERROR( "SIG_TC_CPAP_T3142 unexpected" );
872 break;
873
874 }
875
876 } /* sig_tc_cpap_t3142() */
877
878 /*
879 +------------------------------------------------------------------------------
880 | Function : sig_tc_cpap_reconnect_ind
881 +------------------------------------------------------------------------------
882 | Description : Handles the internal signal SIG_TC_CPAP_RECONNECT_IND
883 |
884 | Parameters : void
885 |
886 +------------------------------------------------------------------------------
887 */
888
889 GLOBAL void sig_tc_cpap_reconnect_ind ( void )
890 {
891 switch(GET_STATE(CPAP))
892 {
893 case CPAP_WAIT_STOP_TASK_CNF:
894 cpap_mfree_ia( FALSE );
895
896 /*lint -fallthrough*/
897
898 case CPAP_IDLE:
899 case CPAP_SB_STARTED:
900 case CPAP_1P_STARTED:
901 case CPAP_WAIT_DEDI_SUSPEND:
902 SET_STATE(CPAP,CPAP_WAIT_PDCH_ASSIGN);
903 break;
904 default:
905 TRACE_ERROR("sig_tc_cpap_reconnect_ind unexpected!");
906 break;
907 }
908 } /* sig_tc_cpap_reconnect_ind ()*/