FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/psa_satf.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-PS (6147)
4 | Modul : PSA_SATF
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This module defines the functions for the protocol
18 | stack adapter for the SIM application toolkit.
19 +-----------------------------------------------------------------------------
20 */
21
22 #include "config.h"
23 #include "fixedconf.h"
24 #include "condat-features.h"
25 #include "aci_conf.h"
26
27 #ifdef SIM_TOOLKIT
28
29 #ifndef PSA_SATF_C
30 #define PSA_SATF_C
31 #endif
32
33 #include "aci_all.h"
34
35 /*==== INCLUDES ===================================================*/
36 #include "aci_cmh.h"
37 #include "aci_mem.h"
38
39 #ifdef GPRS
40 #include "gaci_cmh.h"
41 #endif
42
43 #ifdef FAX_AND_DATA
44 #include "aci_fd.h"
45 #endif /* of #ifdef FAX_AND_DATA */
46
47
48 #include "aci.h"
49 #include "psa.h"
50 #include "psa_cc.h"
51 #include "psa_sat.h"
52 #include "psa_util.h"
53 #include "cmh.h"
54 #include "cmh_sat.h"
55
56 #include "psa_mm.h"
57 #include "psa_ss.h"
58 #include "psa_sim.h"
59 #include "cmh_cc.h"
60
61 #include "ksd.h"
62
63 /*==== CONSTANTS ==================================================*/
64
65 #define ITM_WDT (14) /* item width in chars */
66 #define HDR_WDT (10) /* header width in chars */
67
68 /*==== TYPES ======================================================*/
69
70
71 /*==== EXPORT =====================================================*/
72
73
74 /*==== VARIABLES ==================================================*/
75 LOCAL UBYTE ssResPrms[MAXIMUM( sizeof(BUF_res_params_sat),
76 MAXIMUM(sizeof(BUF_rej_params_sat),
77 sizeof(BUF_err_params_sat)))];
78
79 /*==== FUNCTIONS ==================================================*/
80
81 LOCAL void psaSAT_getTonNpi(CHAR *inSeq, BOOL call_active,
82 UBYTE *ton, UBYTE *npi);
83
84
85
86 /*
87 +-------------------------------------------------------------------+
88 | PROJECT : GSM-PS (6147) MODULE : SAT |
89 | ROUTINE : psaSAT_BuildEnvCC |
90 +-------------------------------------------------------------------+
91
92 PURPOSE : Build envelope call control command.
93
94 */
95
96 GLOBAL void psaSAT_BuildEnvCC ( SHORT cId,
97 T_CLPTY_PRM *ss_cldPty,
98 T_sat_ussd *ussd,
99 T_MNCC_bcconf *ccp1,
100 T_MNCC_bcconf *ccp2)
101 {
102 T_CC_CALL_TBL *pCtbNtry = ccShrdPrm.ctb[cId];
103 UBYTE ton;
104 UBYTE npi;
105
106 /*
107 *-------------------------------------------------------------------
108 * build envelope call control command
109 *-------------------------------------------------------------------
110 */
111 {
112 MCAST( env, ENV_CMD );
113
114 memset( env, 0, sizeof( T_ENV_CMD ));
115
116 env->v_cc_cmd = TRUE;
117
118 /* device identities */
119 env->cc_cmd.v_dev_ids = TRUE;
120 env->cc_cmd.dev_ids.src_dev = DEV_SRC_ME;
121 env->cc_cmd.dev_ids.dest_dev = DEV_DST_SIM;
122
123 if( cId NEQ NO_ENTRY )
124 {
125 /* address */
126 env->cc_cmd.v_addr = TRUE;
127
128 if( (pCtbNtry->SATinv & SAT_REDIAL_ECCBE) AND
129 (rdlPrm.rdlState) )
130 {
131 memcpy(&env->cc_cmd.addr, &satRdlCCEnv.addr, sizeof(T_addr));
132 }
133 else
134 {
135 /* address */
136 env->cc_cmd.addr.v_noa = TRUE;
137 env->cc_cmd.addr.noa = pCtbNtry->cldPty.ton;
138
139 env->cc_cmd.addr.v_npi = TRUE;
140 env->cc_cmd.addr.npi = pCtbNtry->cldPty.npi;
141
142 env->cc_cmd.addr.c_bcdDigit = pCtbNtry->cldPty.c_called_num;
143 memcpy( env->cc_cmd.addr.bcdDigit,
144 pCtbNtry->cldPty.called_num,
145 pCtbNtry->cldPty.c_called_num );
146 }
147
148 #ifdef SIM_TOOLKIT
149 if ( !rdlPrm.rdlState )
150 {
151 memcpy(&satRdlCCEnv.addr, &env->cc_cmd.addr, sizeof(T_addr));
152 }
153 #endif
154
155
156 /* capability configuration parameters 1*/
157 if( ccp1 )
158 {
159 env->cc_cmd.v_cap_cnf_parms = TRUE;
160 env->cc_cmd.cap_cnf_parms.l_cap_cnf_parms = ccp1->bc_len<<3;
161
162 memcpy( env->cc_cmd.cap_cnf_parms.b_cap_cnf_parms, ccp1->bc,
163 ccp1->bc_len );
164 }
165
166 /* capability configuration parameters 2*/
167 if( ccp2 )
168 {
169 env->cc_cmd.v_cap_cnf_parms_2 = TRUE;
170 env->cc_cmd.cap_cnf_parms_2.l_cap_cnf_parms_2 = ccp2->bc_len<<3;
171
172 memcpy( env->cc_cmd.cap_cnf_parms_2.b_cap_cnf_parms_2, ccp2->bc,
173 ccp2->bc_len );
174 }
175
176 /* If ccp is present in the setUpCall */
177 if ((satShrdPrm.capParm.cntxt EQ CTX_SAT_SETUP) AND satShrdPrm.stk_ccp.l_cap_cnf_parms )
178 {
179 env->cc_cmd.v_cap_cnf_parms = TRUE;
180 /* Storing the ccp if ECCBE is enabled */
181 if( (ccShrdPrm.ctb[cId]->SATinv & SAT_REDIAL_ECCBE) AND
182 (rdlPrm.rdlState) )
183 {
184 memcpy(&env->cc_cmd.cap_cnf_parms, &satRdlCCEnv.ccp, sizeof(BUF_cap_cnf_parms));
185 }
186 else
187 {
188 env->cc_cmd.cap_cnf_parms.l_cap_cnf_parms = satShrdPrm.stk_ccp.l_cap_cnf_parms;
189 memcpy( env->cc_cmd.cap_cnf_parms.b_cap_cnf_parms, &satShrdPrm.stk_ccp.b_cap_cnf_parms,
190 satShrdPrm.stk_ccp.l_cap_cnf_parms );
191 }
192 #ifdef SIM_TOOLKIT
193 if ( !rdlPrm.rdlState )
194 {
195 memcpy( &satRdlCCEnv.ccp, &env->cc_cmd.cap_cnf_parms, sizeof(BUF_cap_cnf_parms));
196 }
197 #endif
198 }
199
200 /* subaddress */
201 if( pCtbNtry->cldPtySub.c_subaddr )
202 {
203 env->cc_cmd.v_subaddr = TRUE;
204
205 if( (pCtbNtry->SATinv & SAT_REDIAL_ECCBE) AND
206 (rdlPrm.rdlState) )
207 {
208 memcpy( &env->cc_cmd.subaddr, &satRdlCCEnv.sub_addr, sizeof(T_subaddr) );
209 }
210 else
211 {
212
213 env->cc_cmd.subaddr.v_tos = TRUE;
214 env->cc_cmd.subaddr.tos = pCtbNtry->cldPtySub.tos;
215
216 env->cc_cmd.subaddr.v_oei = TRUE;
217 env->cc_cmd.subaddr.oei = pCtbNtry->cldPtySub.odd_even;
218
219 env->cc_cmd.subaddr.c_subadr_str = pCtbNtry->cldPtySub.c_subaddr;
220 memcpy( env->cc_cmd.subaddr.subadr_str, pCtbNtry->cldPtySub.subaddr,
221 pCtbNtry->cldPtySub.c_subaddr );
222 }
223
224 #ifdef SIM_TOOLKIT
225 if ( !rdlPrm.rdlState )
226 {
227 memcpy( &satRdlCCEnv.sub_addr, &env->cc_cmd.subaddr, sizeof(T_subaddr));
228 }
229 #endif
230
231 }
232 }
233
234 else if( ss_cldPty NEQ NULL )
235 {
236 /* SS string */
237 env->cc_cmd.v_ss_string = TRUE;
238
239 psaSAT_getTonNpi(ss_cldPty->num, FALSE, &ton, &npi);
240
241 env->cc_cmd.ss_string.v_noa = TRUE;
242 env->cc_cmd.ss_string.noa = ton;
243 env->cc_cmd.ss_string.v_npi = TRUE;
244 env->cc_cmd.ss_string.npi = npi;
245
246 env->cc_cmd.ss_string.c_ss_ctrl_string =
247 (UBYTE)utl_dialStr2BCD (ss_cldPty->num, /*ssStr,*/
248 env->cc_cmd.ss_string.ss_ctrl_string,
249 MAX_SS_STRING_LEN);
250 }
251
252 else if( ussd NEQ NULL )
253 {
254 /* USSD string */
255 env->cc_cmd.v_ussd_string = TRUE;
256
257 env->cc_cmd.ussd_string.dcs = ussd->dcs;
258 env->cc_cmd.ussd_string.c_ussd_str = MINIMUM (ussd->c_ussd_str, MAX_SAT_USSD_LEN);
259
260 memcpy( env->cc_cmd.ussd_string.ussd_str,
261 ussd->ussd_str,
262 env->cc_cmd.ussd_string.c_ussd_str);
263 }
264
265 /* location information */
266
267 /* code MCC */
268 env->cc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mcc[1]<<4) + mmShrdPrm.usedPLMN.mcc[0]) <<16;
269 env->cc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mnc[2]<<4) + mmShrdPrm.usedPLMN.mcc[2]) << 8;
270
271 /* code MNC */
272 env->cc_cmd.cc_smc_loc_info.mnc_mcc |= (mmShrdPrm.usedPLMN.mnc[1]<<4)+mmShrdPrm.usedPLMN.mnc[0];
273
274 /* code LAC */
275 env->cc_cmd.cc_smc_loc_info.lac = mmShrdPrm.lac;
276
277 /* code CID */
278 env->cc_cmd.cc_smc_loc_info.cid = mmShrdPrm.cid;
279
280 env->cc_cmd.v_cc_smc_loc_info = TRUE;
281 }
282 }
283
284
285 /*
286 +--------------------------------------------------------------------+
287 | PROJECT : GSM-PS (6147) MODULE : psa_sat |
288 | STATE : code ROUTINE : psaSAT_getTonNpi |
289 +--------------------------------------------------------------------+
290
291 PURPOSE : Get TON and NPI. The SS string in inSeq will be
292 decoded to check if it contains a phone number. If
293 SS String contains a number, its TON and NPI will be
294 returned. Otherwise TON and NPI will be set to FF as
295 required in GSM 11.14/GSM 11.11.
296 */
297 LOCAL void psaSAT_getTonNpi(CHAR *inSeq, BOOL call_active,
298 UBYTE *ton, UBYTE *npi)
299 {
300 T_KSD_SEQGRP grp;
301 CHAR *rest;
302 T_KSD_SEQPARAM para;
303 CHAR seq[MAX_DIAL_LEN];
304
305 *ton = MNCC_TON_NOT_PRES;
306 *npi = MNCC_NPI_NOT_PRES;
307
308 strcpy(seq, inSeq);
309
310 /* decode sequence */
311 ksd_decode(seq, call_active, &grp, &rest, &para);
312
313 /* analyse TON and NPI */
314 switch( grp )
315 {
316 case SEQGRP_CF:
317
318 if ( (para.cf.num NEQ NULL) AND (para.cf.num[0] NEQ 0) )
319 {
320 *ton = para.cf.ton;
321 *npi = para.cf.npi;
322 }
323 break;
324
325 case SEQGRP_DIAL:
326
327 if ( ( para.dial.number NEQ NULL ) AND
328 ( para.dial.number[0] EQ 0 ) )
329 {
330 if ( para.dial.number[0] EQ '+' )
331 {
332 *ton = TON_International;
333 }
334 else
335 {
336 *ton = TON_Unknown;
337 }
338 *npi = NPI_IsdnTelephony;
339 }
340
341 break;
342
343 #ifdef SMI
344 case SEQGRP_SET_ABBR_DIAL:
345
346 if ( (para.abbrDial.number NEQ NULL) AND
347 ( para.abbrDial.number[0] EQ 0 ) )
348 {
349 if ( para.abbrDial.number[0] EQ '+' )
350 {
351 *ton = TON_International;
352 }
353 else
354 {
355 *ton = TON_Unknown;
356 }
357 *npi = NPI_IsdnTelephony;
358 }
359 break;
360 #endif /* SMI */
361
362 default:
363 /* Sequence group does not contain number. TON and NPI still set to FF */
364 break;
365 }
366 }
367
368 /*
369 +-------------------------------------------------------------------+
370 | PROJECT : GSM-PS (6147) MODULE : SAT |
371 | ROUTINE : psaSAT_BuildEnvCB |
372 +-------------------------------------------------------------------+
373
374 PURPOSE : Build envelope cell broadcast data download command.
375
376 */
377
378 GLOBAL void psaSAT_BuildEnvCB ( UBYTE *cbMsg, SHORT cbLen )
379 {
380
381 /*
382 *-------------------------------------------------------------------
383 * build envelope cell broadcast data download command
384 *-------------------------------------------------------------------
385 */
386 {
387 MCAST( env, ENV_CMD );
388
389 memset( env, 0, sizeof( T_ENV_CMD ));
390
391 env->v_cbd_cmd = TRUE;
392
393 /* device identities */
394 env->cbd_cmd.v_dev_ids = TRUE;
395 env->cbd_cmd.dev_ids.src_dev = DEV_SRC_NTW;
396 env->cbd_cmd.dev_ids.dest_dev = DEV_DST_SIM;
397
398 /* CB message */
399 env->cbd_cmd.v_cb_page = TRUE;
400 env->cbd_cmd.cb_page.l_cb_page = cbLen<<3;
401 env->cbd_cmd.cb_page.o_cb_page = 0;
402
403 memcpy( env->cbd_cmd.cb_page.b_cb_page, cbMsg, cbLen );
404 }
405 }
406
407 /*
408 +-------------------------------------------------------------------+
409 | PROJECT : GSM-PS (6147) MODULE : SAT |
410 | ROUTINE : psaSAT_BuildEnvMoSmCntr |
411 +-------------------------------------------------------------------+
412
413 PURPOSE : Build envelope cell broadcast data download command.
414
415 */
416
417 GLOBAL void psaSAT_BuildEnvMoSmCntr ( T_rp_addr sc_addr,
418 T_tp_da dest_addr )
419 {
420
421 /*
422 *-------------------------------------------------------------------
423 * build envelope
424 *-------------------------------------------------------------------
425 */
426 {
427 MCAST( env, ENV_CMD );
428
429 memset( env, 0, sizeof( T_ENV_CMD ));
430
431 env->v_smc_cmd = TRUE;
432
433 /* device identities */
434 env->smc_cmd.v_dev_ids = TRUE;
435 env->smc_cmd.dev_ids.src_dev = DEV_DST_ME;
436 env->smc_cmd.dev_ids.dest_dev = DEV_DST_SIM;
437
438 /* short message address */
439 env->smc_cmd.v_sm_addr = TRUE;
440
441 env->smc_cmd.sm_addr.v_noa = TRUE;
442 env->smc_cmd.sm_addr.noa = sc_addr.ton;
443
444 env->smc_cmd.sm_addr.v_npi = TRUE;
445 env->smc_cmd.sm_addr.npi = sc_addr.npi;
446
447 env->smc_cmd.sm_addr.c_bcdDigit = sc_addr.c_num;
448 memcpy(&(env->smc_cmd.sm_addr.bcdDigit[0]),
449 &(sc_addr.num[0]),
450 sc_addr.c_num /*MAX_SMS_DIGIT_LEN*/);
451
452 /* address 2 */
453 env->smc_cmd.v_sm_addr_2 = TRUE;
454
455 env->smc_cmd.sm_addr_2.v_noa = TRUE;
456 env->smc_cmd.sm_addr_2.noa = dest_addr.ton;
457
458 env->smc_cmd.sm_addr_2.v_npi = TRUE;
459 env->smc_cmd.sm_addr_2.npi = dest_addr.npi;
460
461 env->smc_cmd.sm_addr_2.c_bcdDigit = dest_addr.c_num;
462 memcpy(&(env->smc_cmd.sm_addr_2.bcdDigit[0]),
463 &(dest_addr.num[0]),
464 dest_addr.c_num /*MAX_SMS_DIGIT_LEN*/);
465
466 /* location information */
467
468 /* code MCC */
469 env->smc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mcc[1]<<4) + mmShrdPrm.usedPLMN.mcc[0]) <<16;
470 env->smc_cmd.cc_smc_loc_info.mnc_mcc |= ((mmShrdPrm.usedPLMN.mnc[2]<<4) + mmShrdPrm.usedPLMN.mcc[2]) << 8;
471
472 /* code MNC */
473 env->smc_cmd.cc_smc_loc_info.mnc_mcc |= (mmShrdPrm.usedPLMN.mnc[1]<<4)+mmShrdPrm.usedPLMN.mnc[0];
474
475 /* code LAC */
476 env->smc_cmd.cc_smc_loc_info.lac = mmShrdPrm.lac;
477
478 /* code CID */
479 env->smc_cmd.cc_smc_loc_info.cid = mmShrdPrm.cid;
480
481 env->smc_cmd.v_cc_smc_loc_info = TRUE;
482
483 }
484 }
485
486
487
488 /*
489 +-------------------------------------------------------------------+
490 | PROJECT : GSM-PS (6147) MODULE : SAT |
491 | ROUTINE : psaSAT_BuildEnvEventDwn |
492 +-------------------------------------------------------------------+
493
494 PURPOSE : Build envelope event download command.
495
496 */
497
498 GLOBAL BOOL psaSAT_BuildEnvEventDwn ( UBYTE event, SHORT callId, T_CC_INITIATER actionSrc )
499 {
500 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */
501 BOOL MT_flag;
502 UBYTE trans_id = 0xFF;
503 UBYTE ti_flag = 0xFF; /* lint: initialization warning */
504
505 TRACE_FUNCTION("psaSAT_BuildEnvEventDwn()");
506
507 pCtbNtry = ccShrdPrm.ctb[callId];
508
509 /*
510 *-------------------------------------------------------------------
511 * build envelope
512 *-------------------------------------------------------------------
513 */
514 {
515 MCAST( env, ENV_CMD );
516
517 memset( env, 0, sizeof( T_ENV_CMD ));
518
519 env->v_evd_cmd = TRUE;
520
521 /* event */
522 env->evd_cmd.v_ev_list = TRUE;
523 env->evd_cmd.ev_list.c_event = 1;
524 env->evd_cmd.ev_list.event[0] = event;
525
526 /* device identities */
527 env->evd_cmd.v_dev_ids = TRUE;
528 env->evd_cmd.dev_ids.dest_dev = DEV_DST_SIM;
529 switch( actionSrc )
530 {
531 case( NEAR_END ):
532 env->evd_cmd.dev_ids.src_dev = DEV_SRC_ME;
533 break;
534
535 case( FAR_END ):
536 env->evd_cmd.dev_ids.src_dev = DEV_SRC_NTW;
537 break;
538
539 default:
540 env->evd_cmd.v_dev_ids = FALSE;
541 }
542
543 if ( event EQ EVENT_MT_CALL OR
544 event EQ EVENT_CALL_CONN OR
545 event EQ EVENT_CALL_DISC )
546 {
547 /* process ti identifier */
548 env->evd_cmd.v_ti_list = TRUE;
549 env->evd_cmd.ti_list.c_ti_oct = 1;
550
551 MT_flag = pCtbNtry -> ti & 0x08; /* TRUE if MS terminated transaction */
552 trans_id = ( pCtbNtry -> ti) & 0x07; /* see GSM 04.07 ?1.2.3.1.3 */
553 }
554
555 switch( event )
556 {
557 case( EVENT_MT_CALL ):
558
559 /* ti identifier */
560 /* MNCC_SETUP_IND means message sent from the side that originated the TI */
561 env->evd_cmd.ti_list.ti_oct[0].ti = /*lint -e(644) */ trans_id;
562
563 /* address */
564 if (pCtbNtry->clgPty.c_num NEQ 0)
565 {
566 env->evd_cmd.v_addr = TRUE;
567
568 env->evd_cmd.addr.v_noa = TRUE;
569 env->evd_cmd.addr.noa = pCtbNtry->clgPty.ton;
570
571 env->evd_cmd.addr.v_npi = TRUE;
572 env->evd_cmd.addr.npi = pCtbNtry->clgPty.npi;
573
574 env->evd_cmd.addr.c_bcdDigit = pCtbNtry->clgPty.c_num;
575 memcpy(&(env->evd_cmd.addr.bcdDigit[0]),
576 &(pCtbNtry->clgPty.num[0]),
577 pCtbNtry->clgPty.c_num);
578 }
579
580 /* called party subaddress */
581 if (pCtbNtry->clgPtySub.c_subaddr NEQ 0)
582 {
583 env->evd_cmd.v_subaddr = TRUE;
584
585 env->evd_cmd.subaddr.v_tos = TRUE;
586 env->evd_cmd.subaddr.tos = pCtbNtry -> clgPtySub.tos;
587
588 env->evd_cmd.subaddr.v_oei = TRUE;
589 env->evd_cmd.subaddr.oei = pCtbNtry -> clgPtySub.odd_even;
590
591 env->evd_cmd.subaddr.c_subadr_str = pCtbNtry->clgPtySub.c_subaddr;
592 memcpy(&(env->evd_cmd.subaddr.subadr_str[0]),
593 &(pCtbNtry->clgPtySub.subaddr[0]),
594 pCtbNtry->clgPtySub.c_subaddr);
595 }
596 break;
597
598
599 case( EVENT_CALL_CONN ):
600 /* ti identifier */
601 /* MNCC_SETUP_CNF context with MO Call
602 or: MNCC_SETUP_RES context with MT Call
603 means: message sent to the side that originates the TI */
604 ti_flag = 0x08;
605 env->evd_cmd.ti_list.ti_oct[0].ti = trans_id | ti_flag;
606 break;
607
608
609 case( EVENT_CALL_DISC ):
610 /* ti identifier */
611 /*
612 means: message sent to the side that originates the TI */
613 switch (actionSrc)
614 {
615 case( NEAR_END ):
616 /* MNCC_REJ_IND / MNCC_DISC_REQ / MNCC_REL_REQ */
617 if ( /*lint -e(644) */ MT_flag )
618 ti_flag = 0x08;
619 else
620 ti_flag = 0x00;
621 break;
622
623 case( FAR_END ):
624 /* MNCC_DISC_IND / MNCC_REL_IND / MNCC_REL_REQ */
625 if ( MT_flag )
626 ti_flag = 0x00;
627 else
628 ti_flag = 0x08;
629 break;
630 }
631 env->evd_cmd.ti_list.ti_oct[0].ti = trans_id | ti_flag;
632
633 /* Cause */
634 env->evd_cmd.v_cause = TRUE;
635 if (pCtbNtry -> numRawCauseBytes EQ 0)
636 {
637 if (GET_CAUSE_VALUE(pCtbNtry -> rejCs) NEQ NOT_PRESENT_8BIT) /* radio-link failure */
638 {
639 env->evd_cmd.cause.c_cs = 0;
640 }
641 else
642 {
643 if (GET_CAUSE_VALUE(pCtbNtry -> nrmCs) NEQ NOT_PRESENT_8BIT)
644 {
645 env->evd_cmd.cause.c_cs = 2;
646
647 /*Location is user : 0 and coding standard defined for the GSM PLMNS : 3 */
648 env->evd_cmd.cause.cs[0] =0xE0;
649
650 env->evd_cmd.cause.cs[1] = GET_CAUSE_VALUE(pCtbNtry -> nrmCs) |0x80 ;
651 }
652 else
653 {
654 env->evd_cmd.v_cause = FALSE;
655 }
656 }
657 }
658 else
659 {
660 env->evd_cmd.cause.c_cs = pCtbNtry -> numRawCauseBytes;
661 memcpy( env->evd_cmd.cause.cs,
662 pCtbNtry -> rawCauseBytes,
663 pCtbNtry -> numRawCauseBytes );
664 }
665 break;
666
667
668 case( EVENT_LOC_STATUS ):
669 env->evd_cmd.v_loc_state = TRUE;
670
671 switch( satShrdPrm.locInfo.regStatus )
672 {
673 case( NO_VLD_RS ):
674 env->evd_cmd.v_loc_state = FALSE;
675 break;
676
677 case( RS_NO_SRV ):
678 env->evd_cmd.loc_state = 0x02;
679 break;
680
681 case( RS_LMTD_SRV ):
682 env->evd_cmd.loc_state = 0x01;
683 break;
684
685 case( RS_FULL_SRV ):
686 env->evd_cmd.loc_state = 0x00;
687
688 /*---------------------------------------------------
689 only in this case would location info be included
690 ----------------------------------------------------*/
691
692 /* location information */
693
694 /* code MCC */
695 env->evd_cmd.cc_smc_loc_info.mnc_mcc |=
696 ((satShrdPrm.locInfo.currPLMN.mcc[1]<<4) + satShrdPrm.locInfo.currPLMN.mcc[0]) <<16;
697 env->evd_cmd.cc_smc_loc_info.mnc_mcc |=
698 ((satShrdPrm.locInfo.currPLMN.mnc[2]<<4) + satShrdPrm.locInfo.currPLMN.mcc[2]) << 8;
699
700 /* code MNC */
701 env->evd_cmd.cc_smc_loc_info.mnc_mcc |=
702 (satShrdPrm.locInfo.currPLMN.mnc[1]<<4)+satShrdPrm.locInfo.currPLMN.mnc[0];
703
704 /* code LAC */
705 env->evd_cmd.cc_smc_loc_info.lac = satShrdPrm.locInfo.lac;
706
707 /* code CID */
708 env->evd_cmd.cc_smc_loc_info.cid = satShrdPrm.locInfo.cid;
709
710 env->evd_cmd.v_cc_smc_loc_info = TRUE;
711
712 break;
713 }
714
715 break;
716
717 #ifdef FF_SAT_E
718 case( EVENT_CHAN_STAT ):
719 env->evd_cmd.v_chan_stat = TRUE;
720 env->evd_cmd.chan_stat.chan_id = CHANNEL_ID_1;
721 env->evd_cmd.chan_stat.chan_stat_link = LINK_NO_ESTABL;
722 env->evd_cmd.chan_stat.chan_stat_inf2 = LINK_DROPPED;
723 break;
724 #endif /* FF_SAT_E */
725
726 default:
727 env->v_evd_cmd = FALSE;
728 TRACE_EVENT("wrong event id for SAT event download");
729 break;
730 }
731 /*
732 *-------------------------------------------------------------------
733 * check if a call control request is already in progress
734 *-------------------------------------------------------------------
735 */
736 if( satShrdPrm.SIMCCParm.busy EQ TRUE )
737 {
738 /* event has to be queued */
739 T_SAT_QUEUE *p_queue;
740
741 if (satShrdPrm.event.c_queued >= MAX_EVENT_QUEUED - 1 )
742 {
743 TRACE_EVENT("Too many events have been queued: failed to queue this new event");
744 return FALSE;
745 }
746
747 p_queue = &satShrdPrm.event.queued[satShrdPrm.event.c_queued - 1];
748 p_queue->owner = (T_OWN)satShrdPrm.owner;
749
750 if (p_queue->stk_cmd NEQ NULL)
751 {
752 MFREE (p_queue->stk_cmd); /* Should not happen */
753 }
754 ACI_MALLOC (p_queue->stk_cmd, sizeof (T_stk_cmd));
755 if (psaSAT_STKBuildCmd (p_queue->stk_cmd) < 0)
756 {
757 ACI_MFREE (p_queue->stk_cmd);
758 p_queue->stk_cmd = NULL;
759 TRACE_ERROR ("problem encoding SAT cmd");
760 return FALSE;
761 }
762 satShrdPrm.event.c_queued++;
763 }
764 return TRUE;
765 }
766 }
767
768
769
770
771 /*
772 +-------------------------------------------------------------------+
773 | PROJECT : GSM-PS (6147) MODULE : SAT |
774 | ROUTINE : psaSAT_SendTrmResp |
775 +-------------------------------------------------------------------+
776
777 PURPOSE : Send a terminal response for a previous SAT command.
778
779 */
780
781 GLOBAL void psaSAT_InitTrmResp ( T_ACI_SAT_TERM_RESP *init_resp )
782 {
783 init_resp->addLen = 0;
784 init_resp->add = NULL;
785 init_resp->add_content = 0;
786 init_resp->resCC = NULL;
787 init_resp->text = NULL;
788 init_resp->at_resp = NULL;
789 init_resp->at_resp_count = 0;
790 #ifdef FF_SAT_E
791 init_resp->chnStat = FALSE;
792 init_resp->bearDesc = FALSE;
793 init_resp->bufSize = FALSE;
794 #endif /* FF_SAT_E */
795 memset (init_resp->dtt_buf, 0xFF, TIME_STAMP_LENGTH);
796 memset (init_resp->lang, 0xFF, CLAN_CODE_LEN);
797 }
798
799 LOCAL void sat_build_cc_action_resp(UBYTE rspId,
800 UBYTE addLen,
801 UBYTE *add,
802 UBYTE *resCC,
803 T_TERM_RESP *res)
804 {
805 UBYTE byteLen; /* holds byte length */
806 UBYTE *p; /* byte pointer */
807
808 if( satShrdPrm.stkCnfPrim OR resCC )
809 {
810 p = (resCC)? resCC : satShrdPrm.stkCnfPrim->stk_cmd.cmd;
811
812 if( p[1] EQ 0x81 )
813 {
814 byteLen = p[2];
815 p = &p[3];
816 }
817 else
818 {
819 byteLen = p[1];
820 p = &p[2];
821 }
822
823 res->v_cc_req_act = TRUE;
824 res->cc_req_act.l_cc_req_act = byteLen<<3;
825 memcpy( res->cc_req_act.b_cc_req_act, p, byteLen );
826
827 /* result 2 */
828 res->v_res_2 = TRUE;
829 res->res_2.gen = res->res.gen;
830
831 /* adjust first result according to second result (GSM 11.14 / 9.1) */
832 if( rspId <= 0x1F )
833
834 res->res.gen = RSLT_PERF_MDFY_SIM;
835
836 else if( rspId >= 0x20 AND rspId <= 0x2F )
837
838 res->res.gen = RSLT_CC_SIM_TMP;
839
840 else if( rspId >= 0x30 AND rspId <= 0x3F )
841 {
842 res->res.gen = RSLT_CC_SIM_PRM;
843 res->res.v_add = TRUE;
844 res->res.add.l_add = 8;
845 res->res.add.b_add[0] = ADD_CC_REQ_CHNG;
846 }
847 if( addLen )
848 {
849 if( res->res.gen NEQ RSLT_CC_SIM_PRM ) res->res.v_add = FALSE;
850 res->res_2.v_add = TRUE;
851 res->res_2.add.l_add = addLen<<3;
852 memcpy( res->res_2.add.b_add,
853 add,
854 addLen );
855 }
856
857 /* free the primitive */
858 if( satShrdPrm.stkCnfPrim )
859 {
860 PFREE( satShrdPrm.stkCnfPrim );
861 satShrdPrm.stkCnfPrim = NULL;
862 }
863 }
864 }
865
866 GLOBAL BOOL psaSAT_SendTrmResp ( UBYTE rspId,
867 T_ACI_SAT_TERM_RESP *data_for_term_resp)
868 {
869 TRACE_FUNCTION("psaSAT_SendTrmResp()");
870
871 /*
872 *-------------------------------------------------------------------
873 * build terminal response
874 *-------------------------------------------------------------------
875 */
876 CCD_START;
877 {
878 MCAST( res, TERM_RESP );
879
880 memset( res, 0, sizeof( T_TERM_RESP ));
881
882 /* init of data_for_term_resp */
883 /* return network error cause GSM 11.14 / 12.12.3 (it's mandatory) */
884 if( ( data_for_term_resp->add_content NEQ 0 ) OR
885 ( rspId EQ RSLT_NTW_UNAB_PROC ) )
886 {
887 data_for_term_resp->add = &(data_for_term_resp->add_content);
888 data_for_term_resp->addLen = 1;
889 }
890
891 /* device identities */
892 res->v_cmd_details = TRUE;
893 res->cmd_details.cmd_nr = satShrdPrm.cmdDet.cmdNr;
894 res->cmd_details.cmd_typ = satShrdPrm.cmdDet.cmdType;
895 res->cmd_details.cmd_qlf = satShrdPrm.cmdDet.cmdQlf;
896
897 /* device identities */
898 res->v_dev_ids = TRUE;
899 res->dev_ids.src_dev = DEV_SRC_ME;
900 res->dev_ids.dest_dev = DEV_DST_SIM;
901
902 /* result */
903 res->v_res = TRUE;
904 res->res.gen = (rspId EQ RSLT_PERF_SUCCESS AND cmpFlg)?
905 RSLT_PERF_PART_CMPR:rspId;
906 if( data_for_term_resp->addLen )
907 {
908 res->res.v_add = TRUE;
909 res->res.add.l_add = data_for_term_resp->addLen<<3;
910 memcpy( res->res.add.b_add, data_for_term_resp->add, data_for_term_resp->addLen );
911 }
912
913 /* call control requested action */
914 sat_build_cc_action_resp( rspId,
915 data_for_term_resp->addLen,
916 data_for_term_resp->add,
917 data_for_term_resp->resCC,
918 res );
919
920 /* USSD related terminal response */
921 if( data_for_term_resp->text NEQ NULL )
922 {
923 res->v_text = TRUE;
924 res->text.dcs = data_for_term_resp->text->dcs;
925 res->text.c_text_str = data_for_term_resp->text->c_text_str;
926 memcpy( &(res->text.text_str),
927 data_for_term_resp->text->text_str,
928 data_for_term_resp->text->c_text_str);
929 }
930
931 /* Run AT related terminal response */
932 if( data_for_term_resp->at_resp NEQ NULL )
933 {
934 res->v_at_resp = TRUE;
935
936 memcpy( res->at_resp.text_str,
937 data_for_term_resp->at_resp,
938 data_for_term_resp->at_resp_count );
939
940 res->at_resp.c_text_str = (UBYTE)data_for_term_resp->at_resp_count;
941 }
942
943 /*
944 Provide Local Information (date, time and time zone)
945 related terminal response
946 */
947 if( data_for_term_resp->dtt_buf[0] NEQ 0xFF)
948 {
949 res->v_dtt = TRUE;
950
951 memcpy( res->dtt.text_str,
952 data_for_term_resp->dtt_buf,
953 TIME_STAMP_LENGTH );
954
955 res->dtt.c_text_str = (UBYTE)TIME_STAMP_LENGTH;
956 }
957
958 /*
959 Provide Local Information (Language Setting)
960 */
961
962 if( data_for_term_resp->lang[0] NEQ 0xFF)
963 {
964 res->v_lang = TRUE;
965
966 memcpy( res->lang.lang_buf,
967 data_for_term_resp->lang,
968 CLAN_CODE_LEN );
969
970 res->lang.c_lang_buf = (UBYTE)CLAN_CODE_LEN;
971 }
972
973 #ifdef FF_SAT_E
974 /* add channel status to terminal response */
975 if( data_for_term_resp->chnStat NEQ FALSE )
976 {
977 /* restricted to only one channel for class e */
978 res->v_chan_stat = TRUE;
979 res->c_chan_stat = 1;
980 res->chan_stat[0].chan_id = CHANNEL_ID_1;
981
982 res->chan_stat[0].chan_stat_inf2 = NO_FURTH_INFO;
983 res->chan_stat[0].chan_stat_link = LINK_NO_ESTABL;
984
985 if( satShrdPrm.chnTb.chnUsdFlg )
986 {
987 switch( satShrdPrm.chnTb.lnkStat )
988 {
989 case( SIM_LINK_CNCT ):
990
991 res->chan_stat[0].chan_stat_link = LINK_ESTABL;
992 break;
993
994 case( SIM_LINK_DROP ):
995
996 res->chan_stat[0].chan_stat_inf2 = LINK_DROPPED;
997 break;
998
999 default: /* already handled by pre-setting */
1000
1001 break;
1002 }
1003 }
1004 }
1005 /* add bearer description to terminal response */
1006 if( data_for_term_resp->bearDesc NEQ FALSE AND satShrdPrm.opchPrm )
1007 {
1008 if( satShrdPrm.opchType EQ B_CSD )
1009 {
1010 res->v_bear_desc = TRUE;
1011 res->bear_desc.bear_type = BT_CSD;
1012 res->bear_desc.v_csd_bear_prm = TRUE;
1013 res->bear_desc.csd_bear_prm = ((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->csd_bear_prm;
1014 }
1015 if( satShrdPrm.opchType EQ B_GPRS )
1016 {
1017 res->v_bear_desc = TRUE;
1018 res->bear_desc.bear_type = BT_GPRS;
1019 res->bear_desc.v_gprs_bear_prm = TRUE;
1020 res->bear_desc.gprs_bear_prm = ((T_SAT_GPRS_PRM*)satShrdPrm.opchPrm)->gprs_bear_prm;
1021 }
1022 }
1023 /* add buffer size to terminal response */
1024 if( data_for_term_resp->bufSize NEQ FALSE )
1025 {
1026 res->v_buffer_size = TRUE;
1027 res->buffer_size = satShrdPrm.buffer_size;
1028 }
1029 #endif /* FF_SAT_E */
1030
1031 cmpFlg = FALSE;
1032 }
1033
1034 /*
1035 *-------------------------------------------------------------------
1036 * send terminal response
1037 *-------------------------------------------------------------------
1038 */
1039 satShrdPrm.owner = OWN_SRC_INV;
1040
1041 satShrdPrm.ownSAT = FALSE;
1042 memset( &satShrdPrm.stk_ccp, 0, sizeof(BUF_cap_cnf_parms));
1043
1044
1045 #ifdef TI_PS_FF_AT_P_CMD_CUST
1046 if (satShrdPrm.cust1StkCmd != (void *)0)
1047 {
1048 ACI_MFREE(satShrdPrm.cust1StkCmd); /* Free the dynamically allocated Cust1 Stk Cmd memory */
1049
1050 satShrdPrm.cust1StkCmd = (void *)0;
1051 satShrdPrm.cust1StkCmdLen = 0;
1052 }
1053 #endif /* TI_PS_FF_AT_P_CMD_CUST */
1054
1055 if( psaSAT_STKResponse() < 0 ) /* STK command response */
1056 {
1057 TRACE_EVENT( "FATAL RETURN SAT in send term resp" );
1058 CCD_END;
1059 return( FALSE );
1060 }
1061
1062 CCD_END;
1063 return (TRUE);
1064 }
1065
1066 /*
1067 +-------------------------------------------------------------------+
1068 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
1069 | ROUTINE : psaSAT_dasmMECmd |
1070 +-------------------------------------------------------------------+
1071
1072 PURPOSE : disassemble ME proactive SIM command.
1073 */
1074
1075 GLOBAL BOOL psaSAT_dasmMECmd ( BUF_cmd_prms *cmdPrm )
1076 {
1077 UBYTE ccdRet, err;
1078 T_ACI_SAT_TERM_RESP resp_data;
1079
1080 BOOL aciOnlyEvents; /* holds information whether only ACI events are in SET UP
1081 EVENT LIST */
1082 BOOL sendRes; /* holds temporaly return result whether to send response
1083 or not */
1084
1085 /* response message in the case of SET UP EVENT LIST, only ACI events */
1086 static UBYTE TRSetEventOk [12] =
1087 {
1088 0x81, /* command details tag */
1089 0x03, /* command details length */
1090 0x00, /* will be updated to current cmd num */
1091 0x05, /* command SETUP EVENT LIST */
1092 0x00, /* not used */
1093 0x82, /* device details tag */
1094 0x02, /* device details length */
1095 0x82, /* source ME */
1096 0x81, /* destination SIM */
1097 0x83, /* result tag */
1098 0x01, /* result length */
1099 0x00 /* result OK */
1100 };
1101
1102 TRACE_FUNCTION("psaSAT_dasmMECmd");
1103
1104 psaSAT_InitTrmResp( &resp_data );
1105
1106 #ifdef TI_PS_FF_AT_P_CMD_CUST
1107 if ((satShrdPrm.cmdDet.cmdType NEQ SAT_CMD_EVENT_LIST) AND /* ACI has to process the event before */
1108 (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_NORMAL_BEHAVIOUR)) /* and NOT Cust1 behaviour */
1109 #else
1110 if (satShrdPrm.cmdDet.cmdType NEQ SAT_CMD_EVENT_LIST)
1111 #endif /* TI_PS_FF_AT_P_CMD_CUST */
1112 cmhSAT_STKUsrNtfy();
1113
1114 if( cmdPrm EQ NULL ) /* no parameter */
1115 {
1116 memset(&satShrdPrm.stkCmdPrm, 0,
1117 sizeof(satShrdPrm.stkCmdPrm));
1118 }
1119 else
1120 {
1121 memcpy( &satShrdPrm.stkCmdPrm, cmdPrm,
1122 sizeof(satShrdPrm.stkCmdPrm));
1123
1124 ccdRet = ccd_decodeMsg (CCDENT_SAT,
1125 DOWNLINK,
1126 (T_MSGBUF *) &satShrdPrm.stkCmdPrm,
1127 (UBYTE *) _decodedMsg,
1128 satShrdPrm.cmdDet.cmdType );
1129
1130 /* check for CCD error */
1131 if( ccdRet NEQ ccdOK )
1132 {
1133 TRACE_EVENT_P1( "CCD Decoding Error: %d", ccdRet );
1134
1135 err = psaSAT_ccdErrChk();
1136 if( err NEQ 0 )
1137 {
1138 psaSAT_SendTrmResp( err, &resp_data );
1139 return( FALSE );
1140 }
1141 }
1142 }
1143
1144 /* continue processing */
1145 switch( satShrdPrm.cmdDet.cmdType )
1146 {
1147 case( SAT_CMD_SETUP_CALL ):
1148 {
1149 MCAST( calCmd, SETUP_CALL );
1150
1151 return( cmhSAT_setupCall( calCmd ));
1152 }
1153
1154 case( SAT_CMD_SEND_SS ):
1155 {
1156 MCAST( ssCmd, SEND_SS );
1157
1158 return( cmhSAT_sendSS( ssCmd ));
1159 }
1160
1161 case( SAT_CMD_SEND_USSD ):
1162 {
1163 MCAST( ussdCmd, SEND_USSD );
1164
1165 return( cmhSAT_sendUSSD( ussdCmd ));
1166 }
1167
1168 case( SAT_CMD_SEND_SMS ):
1169 {
1170 MCAST( smCmd, SEND_SM );
1171
1172 return( cmhSAT_sendSM( smCmd ));
1173 }
1174
1175 case( SAT_CMD_SEND_DTMF ):
1176 {
1177 MCAST( dtmfCmd, SEND_DTMF );
1178
1179 return( cmhSAT_sendDTMF( dtmfCmd ));
1180 }
1181
1182 case( SAT_CMD_EVENT_LIST ):
1183 {
1184 MCAST( setEvent, SETUP_EVENT );
1185
1186 if (cmhSAT_setupEvent_Test( setEvent, &aciOnlyEvents ))
1187 {
1188 /* ACI-SPR-18200: If there are no Events to be processed by MMI
1189 ACI bypasses the MMI functionality and returns TR by itself */
1190
1191 /* something went wrong, temp event list is empty --> TR(30) */
1192 if ( satShrdPrm.event.temp_list EQ 0L )
1193 {
1194 psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
1195 return FALSE;
1196 }
1197
1198 if ( aciOnlyEvents )
1199 {
1200 /* prepare response to signal OK to SATK */
1201 TRSetEventOk[2] = satShrdPrm.cmdDet.cmdNr;
1202 satShrdPrm.setPrm[satShrdPrm.owner].stkCmd = TRSetEventOk;
1203 satShrdPrm.setPrm[satShrdPrm.owner].stkCmdLen = 12;
1204
1205 /* inform SIM about acknowledged event list */
1206 sendRes = cmhSAT_CheckSetEventResp( );
1207
1208 if (sendRes)
1209 {
1210 if( psaSAT_STKResponse() < 0 ) /* respond to STK command */
1211 {
1212 TRACE_EVENT( "FATAL RETURN - TR could not be send" );
1213 }
1214 }
1215 }
1216 else /* signal MMI to process further events */
1217 {
1218 cmhSAT_STKCmdInd();
1219 }
1220 return TRUE;
1221 }
1222 else
1223 {
1224 if ( satShrdPrm.event.temp_list NEQ 0L )
1225 {
1226 satShrdPrm.event.temp_list = 0L; /* reinitialize temp_event_list */
1227 psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data );
1228 }
1229 }
1230 }
1231 break;
1232
1233 case( SAT_CMD_RUN_AT ):
1234 {
1235 MCAST( calCmd, RUN_AT );
1236
1237 return( cmhSAT_runAt( calCmd ));
1238 }
1239
1240 case( SAT_CMD_LAUNCH_BROWSER ):
1241 {
1242 MCAST( launchBrowserCmd, LAUNCH_BROWSER );
1243
1244 return( cmhSAT_launchBrowser( launchBrowserCmd ));
1245 }
1246
1247 case( SAT_CMD_PROV_LOC_INFO):
1248 {
1249 return( cmhSAT_provLocalInfo());
1250 }
1251 #ifdef FF_SAT_E
1252 case( SAT_CMD_OPEN_CHANNEL ):
1253 {
1254 MCAST( opchCmd, OPEN_CHANNEL );
1255
1256 return( cmhSAT_OpenChannelReq( opchCmd ));
1257 }
1258 #endif /* FF_SAT_E */
1259 }
1260 return( FALSE );
1261 }
1262
1263 /*
1264 +-------------------------------------------------------------------+
1265 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
1266 | ROUTINE : psaSAT_SSResComp |
1267 +-------------------------------------------------------------------+
1268
1269 PURPOSE : SS result component handling.
1270 */
1271
1272 GLOBAL void psaSAT_SSResComp ( T_res_comp* resCmp )
1273 {
1274 UBYTE addLen = 0;
1275 T_ACI_SAT_TERM_RESP resp_data;
1276
1277 psaSAT_InitTrmResp( &resp_data );
1278
1279 /* Add the operation code and parameters to terminal response
1280 (reference: section 12.12.1 "Additional information for SEND SS" of 11.14)
1281 */
1282 if( resCmp -> v_sequence AND
1283 resCmp -> sequence.v_op_code )
1284 {
1285 ssResPrms[0] = resCmp -> sequence.op_code;
1286
1287 if( resCmp -> sequence.params.l_params )
1288 {
1289 addLen = resCmp -> sequence.params.l_params >> 3;
1290
1291 memcpy( &ssResPrms[1], resCmp -> sequence.params.b_params, addLen);
1292 }
1293 ++addLen;
1294 }
1295 resp_data.add = ssResPrms;
1296 resp_data.addLen = addLen;
1297
1298 psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
1299 }
1300
1301 /*
1302 +-------------------------------------------------------------------+
1303 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
1304 | ROUTINE : psaSAT_SSErrComp |
1305 +-------------------------------------------------------------------+
1306
1307 PURPOSE : SS error result component handling.
1308 */
1309
1310 GLOBAL void psaSAT_SSErrComp ( T_fac_inf* errCmp, BOOL is_fac_ussd )
1311 {
1312 UBYTE ccdRet;
1313 UBYTE addLen = 1;
1314 T_ACI_SAT_TERM_RESP resp_data;
1315
1316 MCAST( com, COMP_SAT );
1317
1318 TRACE_FUNCTION("psaSAT_SSErrComp()");
1319
1320 psaSAT_InitTrmResp( &resp_data );
1321 *ssResPrms = ADD_NO_CAUSE;
1322
1323 memset( com, 0, sizeof( T_COMP_SAT ));
1324
1325 ccdRet = ccd_decodeMsg (CCDENT_FAC,
1326 DOWNLINK,
1327 (T_MSGBUF *) errCmp,
1328 (UBYTE *) _decodedMsg,
1329 COMP_SAT);
1330
1331 if( ccdRet NEQ ccdOK )
1332 {
1333 TRACE_EVENT_P1("CCD Decoding Error: %d",ccdRet );
1334 }
1335 else
1336 {
1337 if( com->err_comp_sat.err_desc_sat.err_params_sat.
1338 l_err_params_sat )
1339 {
1340 addLen = com->err_comp_sat.err_desc_sat.err_params_sat.
1341 l_err_params_sat >> 3;
1342
1343 memcpy( ssResPrms,com->err_comp_sat.err_desc_sat.err_params_sat.
1344 b_err_params_sat, addLen );
1345 }
1346 }
1347 resp_data.add = ssResPrms;
1348 resp_data.addLen = addLen;
1349
1350 if( is_fac_ussd )
1351 {
1352 psaSAT_SendTrmResp( RSLT_USSD_ERR, &resp_data );
1353 }
1354 else
1355 {
1356 psaSAT_SendTrmResp( RSLT_SS_ERR, &resp_data );
1357 }
1358 }
1359
1360 /*
1361 +-------------------------------------------------------------------+
1362 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
1363 | ROUTINE : psaSAT_SSRejComp |
1364 +-------------------------------------------------------------------+
1365
1366 PURPOSE : SS reject component handling.
1367 */
1368
1369 GLOBAL void psaSAT_SSRejComp ( UBYTE cRejectInfo )
1370 {
1371 UBYTE addLen = 1;
1372 T_ACI_SAT_TERM_RESP resp_data;
1373
1374 TRACE_FUNCTION("psaSAT_SSRejComp()");
1375
1376 psaSAT_InitTrmResp( &resp_data );
1377 *ssResPrms = ADD_NO_CAUSE;
1378
1379 resp_data.add = ssResPrms;
1380 resp_data.addLen = addLen;
1381
1382 psaSAT_SendTrmResp( cRejectInfo, &resp_data );
1383 }
1384
1385 /*
1386 +-------------------------------------------------------------------+
1387 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
1388 | ROUTINE : psaSAT_ss_end_ind |
1389 +-------------------------------------------------------------------+
1390
1391 PURPOSE : handles SAT responses to SAT after a SAT originated SS.
1392 */
1393
1394 GLOBAL T_ACI_RETURN psaSAT_ss_end_ind ( SHORT sId,
1395 T_COMPONENT *com,
1396 T_MNSS_END_IND *mnss_end_ind,
1397 BOOL is_fac_ussd )
1398 {
1399 TRACE_FUNCTION("psaSAT_ss_end_ind()");
1400
1401 if( com->v_res_comp )
1402 {
1403 if( is_fac_ussd EQ FALSE ) /* not for USSD !! */
1404 {
1405 //TISH, patch for ASTec20762
1406 //start
1407 psaSS_dasmResultCmp( sId, &com->res_comp );
1408 //end
1409 psaSAT_SSResComp( &com->res_comp );
1410 }
1411 else
1412 {
1413 psaSS_dasmResultCmp( sId, &com->res_comp );
1414 }
1415 return( AT_EXCT );
1416 }
1417
1418 if( com->v_err_comp )
1419 {
1420 ssShrdPrm.stb[sId].failType = SSF_SS_ERR;
1421 psaSAT_SSErrComp( &mnss_end_ind -> fac_inf, is_fac_ussd );
1422 return( AT_FAIL );
1423 }
1424
1425 if( com->v_rej_comp )
1426 {
1427 UBYTE cRejectInfo = RSLT_NTW_UNAB_PROC;
1428
1429 /* check for protocol incompatibility for USSD */
1430 if ( (is_fac_ussd) AND
1431 (com->rej_comp.v_inv_problem) )
1432 {
1433 switch( com->rej_comp.inv_problem )
1434 {
1435 case 0x01 : /* invoke problem code #1 */
1436 {
1437 if (psaSS_asmUSSDProt1(sId))
1438 {
1439 /* facility with Protocole 1 format has been sent: wait for answer */
1440 return( AT_CMPL );
1441 }
1442 cRejectInfo = RSLT_NTW_UNAB_PROC;
1443 break;
1444 }
1445 case 0x02 : /* invoke problem code #2 */
1446 {
1447 cRejectInfo = RSLT_USSD_ERR;
1448 break;
1449 }
1450 default :
1451 {
1452 TRACE_EVENT_P1("psaSAT_ss_end_ind(): unknown invoke problem: %x", com->rej_comp.inv_problem );
1453 break;
1454 }
1455 }
1456 ssShrdPrm.stb[sId].failType = SSF_INV_PRB;
1457 }
1458
1459 /* check for protocol incompatibility for USSD */
1460 if ((is_fac_ussd EQ FALSE) AND (com->rej_comp.v_gen_problem))
1461 {
1462 ssShrdPrm.stb[sId].failType = SSF_GEN_PRB;
1463 /* for 27.22.4.11.1 Seq. 1.3 SEND SS */
1464 if (com->rej_comp.gen_problem EQ GEN_PROB_UNRECOG_CMP)
1465 {
1466 cRejectInfo = RSLT_SS_ERR;
1467 }
1468 }
1469
1470 psaSAT_SSRejComp( cRejectInfo );
1471 return( AT_FAIL );
1472 }
1473 return(AT_FAIL);
1474 }
1475
1476 /*
1477 +-------------------------------------------------------------------+
1478 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
1479 | ROUTINE : psaSAT_ccdErrChk |
1480 +-------------------------------------------------------------------+
1481
1482 PURPOSE : CCD error checking. The function returns a SAT result
1483 value unequal to 0 if the operation is must be terminated.
1484 Otherwise the condition is only a warning and the operation
1485 should be proceeded.
1486 */
1487
1488 GLOBAL UBYTE psaSAT_ccdErrChk ( void )
1489 {
1490 USHORT parLst[MAX_ERR_PAR];
1491 UBYTE ccdErr;
1492 UBYTE fstFlg = TRUE;
1493
1494 TRACE_FUNCTION("psaSAT_ccdErrChk()");
1495
1496 /*
1497 *-------------------------------------------------------------------
1498 * handling of first error
1499 *-------------------------------------------------------------------
1500 */
1501 do
1502 {
1503 memset (parLst,0, sizeof (parLst));
1504
1505 if( fstFlg )
1506 {
1507 ccdErr = ccd_getFirstError (CCDENT_SAT, parLst);
1508 fstFlg = FALSE;
1509 }
1510 else
1511
1512 ccdErr = ccd_getNextError (CCDENT_SAT, parLst);
1513
1514 switch (ccdErr)
1515 {
1516 case( ERR_IE_NOT_EXPECTED ): /* unexpected element */
1517 if( !((UBYTE)parLst[0] & 0x80) )
1518 {
1519 cmpFlg = TRUE;
1520 break;
1521 }
1522 /* otherwise continue, no break */
1523 /*lint -fallthrough*/
1524 case( ERR_COMPREH_REQUIRED ): /* comprehension required */
1525
1526 return( RSLT_UNKN_DATA );
1527
1528 case( ERR_MAND_ELEM_MISS ): /* mandatory elements missing */
1529
1530 return( RSLT_ERR_REQ_VAL );
1531 }
1532 } while( ccdErr NEQ ERR_NO_MORE_ERROR );
1533
1534 return( 0 );
1535 }
1536
1537 /*
1538 +-------------------------------------------------------------------+
1539 | PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
1540 | ROUTINE : psaSAT_DumpCmd |
1541 +-------------------------------------------------------------------+
1542
1543 PURPOSE : Dump SAT command to debug output.
1544
1545 */
1546
1547 GLOBAL void psaSAT_DumpCmd ( T_stk_cmd * cmd )
1548 {
1549 #define SAT_TRC_LEN 32
1550
1551 CHAR strBuf[2*SAT_TRC_LEN+1]; /* holds string buffer */
1552 ULONG idx, cnt, mcnt; /* buffer index */
1553 CHAR *pDest; /* points to destination */
1554
1555 TRACE_FUNCTION("psaSAT_DumpCmd()");
1556
1557 /*
1558 *-------------------------------------------------------------------
1559 * format command
1560 *-------------------------------------------------------------------
1561 */
1562 TRACE_EVENT( "SAT CMD SENT/RECEIVED:" );
1563
1564 mcnt = (ULONG)cmd->l_cmd >> 3;
1565
1566 if( !mcnt )
1567 {
1568 TRACE_EVENT_P1("an empty envelope. (%d)", (ULONG)cmd->l_cmd);
1569 return;
1570 }
1571
1572 for( cnt = 0; cnt < mcnt; cnt += SAT_TRC_LEN )
1573 {
1574 pDest = strBuf;
1575
1576 for( idx = 0; idx < SAT_TRC_LEN AND (idx + cnt) < mcnt; idx++ )
1577 {
1578 /* Implements Measure#32: Row 1277 */
1579 pDest += sprintf( pDest, format_2X_str, (UBYTE)cmd->cmd[idx + cnt] );
1580 }
1581
1582 *pDest = 0x0;
1583
1584 TRACE_EVENT_P1("%s", strBuf );
1585 }
1586 }
1587
1588 /*
1589 +-------------------------------------------------------------------+
1590 | PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
1591 | ROUTINE : psaSAT_FURegister |
1592 +-------------------------------------------------------------------+
1593
1594 PURPOSE : Register a handler for FILE UPDATE.
1595
1596 */
1597
1598 GLOBAL BOOL psaSAT_FURegister ( T_SAT_FU_FUNC fu_func )
1599 {
1600 int i;
1601
1602 TRACE_FUNCTION("psaSAT_FURegister()");
1603
1604 for (i = 0; i < MAX_FU_OPS; i++)
1605 {
1606 if (satShrdPrm.fu_func[i] EQ fu_func)
1607 {
1608 TRACE_EVENT ("FU func already registered");
1609 return TRUE;
1610 }
1611 if (satShrdPrm.fu_func[i] EQ NULL)
1612 {
1613 satShrdPrm.fu_func[i] = fu_func;
1614 return TRUE;
1615 }
1616 }
1617 return FALSE;
1618 }
1619
1620 /*
1621 +-------------------------------------------------------------------+
1622 | PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
1623 | ROUTINE : psaSAT_FUConfirm |
1624 +-------------------------------------------------------------------+
1625
1626 PURPOSE : Confirm a handled FILE UPDATE. The parameter is the same
1627 with which the handler was called and refers to the entry
1628 of the callback table.
1629
1630 */
1631
1632 GLOBAL void psaSAT_FUConfirm (int currFU, USHORT resFU)
1633 {
1634 BOOL fu_active;
1635 BOOL aci_sent_no_primitive;
1636
1637 TRACE_EVENT_P2("psaSAT_FUConfirm(): currFU: %d, resFU: %d", currFU, resFU);
1638
1639 if (resFU EQ SIM_FU_ERROR) /*If there is one error, the rest of the procedure is to be cancelled */
1640 {
1641 PALLOC (fu_res, SIM_FILE_UPDATE_RES);
1642
1643 fu_res->source = SRC_MMI;
1644 fu_res->fu_rsc = SIM_FU_ERROR;
1645
1646 if (satShrdPrm.fu_func_notif)
1647 (void)satShrdPrm.fu_func_notif((int)fu_res->fu_rsc,satShrdPrm.fu_ind); /*Sends the final result to MMI */
1648
1649 PSENDX (SIM, fu_res);
1650
1651 return;
1652 }
1653
1654 TRACE_EVENT_P1("satShrdPrm.fu_ind: %d", satShrdPrm.fu_ind);
1655
1656 if (satShrdPrm.fu_ind NEQ NULL AND currFU < MAX_FU_OPS)
1657 {
1658 if (currFU < 0)
1659 {
1660 if (satShrdPrm.fu_func_notif)
1661 { /*Sends the file update request notification to MMI */
1662 if (!satShrdPrm.fu_func_notif(-1,satShrdPrm.fu_ind))
1663 {
1664 PALLOC (fu_res, SIM_FILE_UPDATE_RES); /* If rejected, send negative response to SIM */
1665
1666 fu_res->source = SRC_MMI;
1667 fu_res->fu_rsc = SIM_FU_ERROR;
1668 PSENDX (SIM, fu_res);
1669 }
1670
1671 }
1672 currFU = 0;
1673 /*satShrdPrm.fu_rsc = SIM_FU_ERROR;*/ /* default*/
1674 fu_active = FALSE;
1675 }
1676 else
1677 {
1678 ++currFU;
1679
1680 if ( (resFU EQ SIM_FU_SUCC_ADD) AND (satShrdPrm.fu_rsc NEQ SIM_FU_ERROR) )
1681 {
1682 satShrdPrm.fu_rsc = resFU;
1683 }
1684
1685 /*
1686 switch (resFU)
1687 {
1688 case SIM_FU_SUCCESS:
1689 if (satShrdPrm.fu_rsc EQ SIM_FU_SUCC_ADD)
1690 break;
1691 case SIM_FU_SUCC_ADD:
1692 satShrdPrm.fu_rsc = resFU;
1693 }
1694 */
1695 fu_active = TRUE;
1696 }
1697
1698 for ( ; currFU < MAX_FU_OPS; currFU++)
1699 {
1700 if (satShrdPrm.fu_func[currFU] EQ NULL)
1701 continue;
1702 /* else
1703 fu_active = TRUE;*/
1704
1705 aci_sent_no_primitive = satShrdPrm.fu_func[currFU](currFU, satShrdPrm.fu_ind);
1706
1707 if (!aci_sent_no_primitive)
1708 {
1709 return; /* otherwise, result would be sent directly, and not at the end */
1710 }
1711 }
1712
1713 {
1714 PALLOC (fu_res, SIM_FILE_UPDATE_RES);
1715
1716 fu_res->source = SRC_MMI;
1717 fu_res->fu_rsc = (fu_active)? satShrdPrm.fu_rsc: SIM_FU_SUCCESS;
1718
1719 if (satShrdPrm.fu_func_notif)
1720 (void)satShrdPrm.fu_func_notif((int)fu_res->fu_rsc,satShrdPrm.fu_ind); /*Sends the final result to MMI */
1721
1722 TRACE_EVENT("FREE satShrdPrm.fu_ind");
1723 PFREE (satShrdPrm.fu_ind);
1724 satShrdPrm.fu_ind = NULL;
1725
1726 PSENDX (SIM, fu_res);
1727 simShrdPrm.fuRef = -1;
1728 }
1729 }
1730 }
1731
1732
1733 /*
1734 +-------------------------------------------------------------------+
1735 | PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
1736 | ROUTINE : psaSAT_FUNotifyRegister |
1737 +-------------------------------------------------------------------+
1738
1739 PURPOSE : Register a handler for FILE UPDATE.
1740
1741 */
1742
1743 GLOBAL BOOL psaSAT_FUNotifyRegister ( T_SAT_FU_FUNC fu_func )
1744 {
1745
1746 TRACE_FUNCTION("psaSAT_FUNotifyRegister()");
1747
1748 if (fu_func)
1749 {
1750 satShrdPrm.fu_func_notif = fu_func;
1751 return TRUE;
1752 }
1753 else
1754 return FALSE;
1755 }
1756
1757
1758
1759 /*
1760 +-------------------------------------------------------------------+
1761 | PROJECT : GSM-PS (6147) MODULE : PSA_SAT |
1762 | ROUTINE : psaSAT_Init |
1763 +-------------------------------------------------------------------+
1764
1765 PURPOSE : initialize the protocol stack adapter for SAT.
1766
1767 */
1768
1769 /* MACRO: initializer for set parameter */
1770 #define INIT_SAT_SET_PARM( dest, def )\
1771 for( LpCnt = 0; LpCnt < OWN_SRC_MAX; LpCnt++ )\
1772 satShrdPrm.setPrm[LpCnt].dest = def
1773
1774 GLOBAL void psaSAT_Init ( void )
1775 {
1776
1777 TRACE_FUNCTION("psaSAT_Init()");
1778 /*
1779 *-------------------------------------------------------------------
1780 * set default parms
1781 *-------------------------------------------------------------------
1782 */
1783 memset( &satShrdPrm, 0, sizeof(T_SAT_SHRD_PRM));
1784 satShrdPrm.dur = -1;
1785 satShrdPrm.SentUSSDid = NO_ENTRY;
1786 satShrdPrm.fu_rsc = SIM_FU_SUCCESS;
1787 satShrdPrm.fu_ind = NULL;
1788 satShrdPrm.sId_pwd_requested = NO_ENTRY;
1789 #ifdef TI_PS_FF_AT_P_CMD_CUST
1790 satShrdPrm.cust1SimRefreshRespRqd = FALSE;
1791 #endif /* TI_PS_FF_AT_P_CMD_CUST */
1792 satShrdPrm.locInfo.currPLMN.v_plmn = INVLD_PLMN;
1793 satShrdPrm.Cbch_EvtDnl = FALSE;
1794 satShrdPrm.ownSAT = FALSE;
1795 }
1796
1797 /*
1798 +-------------------------------------------------------------------+
1799 | PROJECT : GSM-PS (6147) MODULE : SAT |
1800 | ROUTINE : psaSAT_ChkEventList |
1801 +-------------------------------------------------------------------+
1802
1803 PURPOSE : Check if the event is monitored and shall alert SAT.
1804
1805 */
1806
1807 GLOBAL BOOL psaSAT_ChkEventList( UBYTE eventNr )
1808 {
1809 BOOL event_listed = FALSE;
1810
1811 TRACE_FUNCTION("psaSAT_ChkEventList()");
1812
1813 event_listed = (satShrdPrm.event.list >> eventNr ) & 0x01;
1814
1815 if( event_listed )
1816 return( TRUE );
1817
1818 return( FALSE );
1819 }
1820
1821 #ifdef FF_SAT_E
1822
1823 /*
1824 +-------------------------------------------------------------------+
1825 | PROJECT : GSM-PS (6147) MODULE : SAT |
1826 | ROUTINE : psaSAT_ctbFindActCall |
1827 +-------------------------------------------------------------------+
1828
1829 PURPOSE : Return the call id of a call which is in an active state.
1830 If no call could be found the function returns NO_ENTRY.
1831
1832 */
1833
1834 GLOBAL SHORT psaSAT_ctbFindActCall( void )
1835 {
1836 UBYTE ctbIdx;
1837 SHORT actId = NO_ENTRY;
1838
1839 TRACE_FUNCTION("psaSAT_ctbFindActCall()");
1840
1841 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
1842 {
1843 if (ccShrdPrm.ctb[ctbIdx] NEQ NULL)
1844 {
1845 switch( psaCC_ctb(ctbIdx)->calStat )
1846 {
1847 case( CS_ACT ):
1848 case( CS_ACT_REQ ):
1849 case( CS_MDF_REQ ):
1850
1851 actId = ctbIdx;
1852 break;
1853 }
1854 }
1855 }
1856
1857 return( actId );
1858 }
1859
1860 /*
1861 +-------------------------------------------------------------------+
1862 | PROJECT : GSM-PS (6147) MODULE : SAT |
1863 | ROUTINE : psaSAT_gprsFindFreeCntxt|
1864 +-------------------------------------------------------------------+
1865
1866 PURPOSE : Return a free context id, if busy return NO_ENTRY.
1867
1868 */
1869 #ifdef GPRS
1870 GLOBAL SHORT psaSAT_gprsFindFreeCntxt( void )
1871 {
1872 BOOL cntxtStat[MAX_CID+1];
1873 SHORT cntxtId[MAX_CID+1];
1874 SHORT cid = NO_ENTRY;
1875 UBYTE idx;
1876
1877 TRACE_FUNCTION("psaSAT_gprsFindFreeCntxt()");
1878
1879 if( qAT_PlusCGACT( CMD_SRC_LCL, cntxtStat, cntxtId ) NEQ AT_CMPL )
1880
1881 return( NO_ENTRY );
1882
1883 for( idx = 0; idx < MAX_CID; idx++ )
1884 {
1885 if( cntxtId[idx] NEQ INVALID_CID AND cntxtStat[idx] EQ TRUE ) continue;
1886
1887 cid = (cntxtId[idx] EQ INVALID_CID)? idx+1:cntxtId[idx];
1888 break;
1889 }
1890
1891 return( cid );
1892
1893 }
1894 #endif /* GPRS */
1895
1896 #endif /* FF_SAT_E */
1897
1898 #endif /* #ifdef SIM_TOOLKIT */
1899
1900 /*==== EOF ========================================================*/