FreeCalypso > hg > leo2moko-debug

comparison g23m/condat/ms/src/aci/cmh_simr.c @ 0:509db1a7b7b8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:509db1a7b7b8
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-PS (6147)
4 | Modul : CMH_SIMR
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 which are responsible
18 | for the responses of the protocol stack adapter for
19 | the subscriber identity module.
20 +-----------------------------------------------------------------------------
21 */
22
23 #ifndef CMH_SIMR_C
24 #define CMH_SIMR_C
25 #endif
26
27 #include "aci_all.h"
28 /*==== INCLUDES ===================================================*/
29 #include "aci_mem.h"
30
31 #include "aci_cmh.h"
32 #include "ati_cmd.h"
33 #include "aci_cmd.h"
34 #include "pcm.h"
35
36 #ifdef FAX_AND_DATA
37 #include "aci_fd.h"
38 #endif /* of #ifdef FAX_AND_DATA */
39
40 #ifndef _SIMULATION_
41 #include "ffs/ffs.h"
42 #include "ffs_coat.h"
43 #endif
44
45 #ifdef DTI
46 #include "dti.h" /* functionality of the dti library */
47 #include "dti_conn_mng.h"
48 #include "dti_cntrl_mng.h"
49 #endif /* DTI */
50
51 #include "phb.h"
52 #include "ksd.h"
53 #include "aci.h"
54 #include "psa.h"
55 #include "psa_sim.h"
56 #include "psa_cc.h"
57 #include "psa_sat.h"
58 #include "psa_mm.h"
59 #include "cmh.h"
60 #include "cmh_sim.h"
61 #include "cmh_mm.h"
62 #include "cmh_phb.h"
63
64 #include "aci_ext_pers.h"
65 #include "aci_slock.h"
66
67 #ifdef SIM_PERS
68 #include "general.h" // included for compilation error UNIT8 in sec_drv.h
69 #include "sec_drv.h"
70 #endif
71
72 #ifdef GPRS
73 #include "gaci.h"
74 #include "gaci_cmh.h"
75 #include "psa_gmm.h"
76 #include "cmh_gmm.h"
77 #endif
78
79 #include "p_mmcc.h"
80 #include "m_cc.h"
81
82 #include "aoc.h"
83
84 #ifdef DTI
85 #include "wap_aci.h"
86 #include "psa_tcpip.h"
87 #include "psa_l2r.h"
88 #endif
89
90 #ifdef SIM_PERS
91 EXTERN T_ACI_SIM_CONFIG aci_slock_sim_config; /* SIM configuration, initialised by a T_SIM_MMI_INSERT_IND */
92 EXTERN T_SEC_DRV_CONFIGURATION *cfg_data ;
93 #endif
94
95 /*==== CONSTANTS ==================================================*/
96
97
98 /*==== TYPES ======================================================*/
99
100
101 /*==== EXPORT =====================================================*/
102
103
104 /*==== VARIABLES ==================================================*/
105
106 /*==== FUNCTIONS ==================================================*/
107
108 /*
109 +-------------------------------------------------------------------+
110 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
111 | ROUTINE : cmhSIM_SIMSync |
112 +-------------------------------------------------------------------+
113
114 PURPOSE : SIM data synchronized
115
116 */
117
118 GLOBAL void cmhSIM_SIMSync ( void )
119 {
120 TRACE_FUNCTION ("cmhSIM_SIMSync()");
121
122 /* process event */
123 switch( simEntStat.curCmd )
124 {
125 case( AT_CMD_CFUN ):
126 if (mmEntStat.curCmd NEQ AT_CMD_CFUN) /* Has MM already deregistered? */
127 {
128 R_AT( RAT_OK, simEntStat.entOwn )
129 ( AT_CMD_CFUN );
130
131 /* log result */
132 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_CFUN, -1, -1, -1 );
133 }
134 /*lint -fallthrough*/
135 case( AT_CMD_COPS ):
136 case( AT_CMD_P_COPS ):
137
138 simEntStat.curCmd = AT_CMD_NONE;
139 break;
140 }
141 }
142
143 /*
144 +-------------------------------------------------------------------+
145 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
146 | ROUTINE : clck_fdn_accepted() |
147 +-------------------------------------------------------------------+
148
149 PURPOSE : PIN2 status allows CLCK changing the status concerning FDN.
150
151 */
152
153 LOCAL void clck_fdn_accepted ( void )
154 {
155 switch( simShrdPrm.setPrm[simEntStat.entOwn].actProc )
156 {
157 case( SIM_FDN_ENABLE ):
158 if( simShrdPrm.crdFun EQ SIM_ADN_ENABLED )
159 {
160 simShrdPrm.crdFun = SIM_FDN_ENABLED;
161 }
162 if( simShrdPrm.crdFun EQ SIM_ADN_BDN_ENABLED )
163 {
164 simShrdPrm.crdFun = SIM_FDN_BDN_ENABLED;
165 }
166
167 pb_switch_adn_fdn( FDN_ENABLE, simShrdPrm.classFDN ); /* inform PHB */
168 break;
169
170 case( SIM_FDN_DISABLE ):
171 if( simShrdPrm.crdFun EQ SIM_FDN_ENABLED )
172 {
173 simShrdPrm.crdFun = SIM_ADN_ENABLED;
174 }
175 if( simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED )
176 {
177 simShrdPrm.crdFun = SIM_ADN_BDN_ENABLED;
178 }
179 pb_switch_adn_fdn( FDN_DISABLE, simShrdPrm.classFDN ); /* inform PHB */
180 break;
181 }
182 }
183
184 /*
185 +-------------------------------------------------------------------+
186 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
187 | ROUTINE : cmhsim_simactivated_clck |
188 +-------------------------------------------------------------------+
189 PURPOSE : SIM activated after AT+CLCK
190 */
191
192 LOCAL void cmhsim_simactivated_clck( void )
193 {
194 T_ACI_CME_ERR err = CME_ERR_Unknown;
195 T_SIM_SET_PRM *sim_set_prm;
196
197 TRACE_FUNCTION ("cmhsim_simactivated_clck()");
198
199 simEntStat.curCmd = AT_CMD_NONE;
200 sim_set_prm = &simShrdPrm.setPrm[simEntStat.entOwn];
201
202 switch( simShrdPrm.rslt )
203 {
204 case( SIM_NO_ERROR ):
205 clck_fdn_accepted();
206
207 R_AT( RAT_OK, simEntStat.entOwn )
208 ( AT_CMD_CLCK );
209 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_CLCK, -1, -1, -1 );
210 return;
211
212 case( SIM_CAUSE_PIN2_EXPECT ):
213 TRACE_EVENT_P1("simShrdPrm.pn2Stat: %d", simShrdPrm.pn2Stat);
214
215 if ( simShrdPrm.pn2Stat EQ PS_PIN2 )
216 {
217 if ( ( simShrdPrm.setPrm[simEntStat.entOwn].curPIN[0] NEQ 0x00 ) AND
218 ( simShrdPrm.setPrm[simEntStat.entOwn].curPIN[0] NEQ NOT_PRESENT_CHAR ) )
219 {
220 /* if PIN2 is required and a pin is given, then check pin with PIN2 */
221 simEntStat.curCmd = AT_CMD_CLCK; /* further processing */
222
223 simShrdPrm.setPrm[simEntStat.entOwn].PINType = PHASE_2_PIN_2;
224 psaSIM_VerifyPIN(); /* verify PIN */
225 return;
226 }
227 else
228 {
229 /* if PIN2 is required and no pin is given, then send cme_err with PIN2
230 required message code */
231 if ( simShrdPrm.PINStat EQ PS_RDY )
232 {
233 simShrdPrm.PINStat = PS_PIN2;
234 }
235 err = CME_ERR_SimPin2Req;
236 }
237 }
238 else
239 {
240 err = CME_ERR_WrongPasswd;
241 }
242 break;
243
244 /*case( SIM_CAUSE_PIN1_EXPECT ):
245 case( SIM_CAUSE_PUK1_EXPECT ):*/
246
247 /* Should be CME_ERR_SimPuk2Req, and it is done
248 in the default case
249 case( SIM_CAUSE_PIN2_BLOCKED):
250 case( SIM_CAUSE_PUK2_EXPECT ):
251 err = CME_ERR_WrongPasswd;
252 break;*/
253
254 default:
255 err = cmhSIM_GetCmeFromSim( simShrdPrm.rslt );
256 break;
257 }
258
259 R_AT( RAT_CME, simEntStat.entOwn )
260 ( AT_CMD_CLCK, err );
261 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CLCK,
262 -1, -1, err );
263
264 }
265
266 /*
267 +-------------------------------------------------------------------+
268 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
269 | ROUTINE : cmhsim_simactivated_start |
270 +-------------------------------------------------------------------+
271 PURPOSE : SIM activated after AT+CFUN, +CPIN, +CIMI and %NRG
272 */
273 LOCAL void simactivated_cpinresult( T_ACI_CPIN_RSLT cpin_result )
274 {
275 R_AT( RAT_CPIN, simEntStat.entOwn )
276 ( cpin_result );
277 R_AT( RAT_OK, simEntStat.entOwn )
278 ( AT_CMD_CPIN );
279 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_CPIN,
280 -1, -1, -1 );
281 }
282
283 LOCAL void simactivated_errorresult( T_ACI_CME_ERR error_result, UBYTE cmdBuf )
284 {
285 R_AT( RAT_CME, simEntStat.entOwn )
286 ( cmdBuf, error_result );
287
288 if( cmdBuf NEQ AT_CMD_CIMI )
289 {
290 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
291 -1, -1, error_result );
292 }
293 }
294
295 LOCAL void cmhsim_simactivated_start( void )
296 {
297 UBYTE cmdBuf = simEntStat.curCmd; /* buffers current command */
298
299 TRACE_FUNCTION ("cmhsim_simactivated_start()");
300
301 simEntStat.curCmd = AT_CMD_NONE;
302
303 switch( simShrdPrm.SIMStat )
304 {
305 case( SS_INV ):
306 simactivated_errorresult( CME_ERR_SimWrong, cmdBuf );
307 return;
308
309 case( SS_URCHB ):
310 simactivated_errorresult( CME_ERR_SimNotIns, cmdBuf );
311 return;
312
313 case( NO_VLD_SS ):
314 simactivated_errorresult( CME_ERR_NotPresent, cmdBuf );
315 return;
316
317 case( SS_OK ):
318 switch( simShrdPrm.PINStat )
319 {
320 case( PS_PIN1 ):
321 if( cmdBuf EQ AT_CMD_CPIN )
322 {
323 simactivated_cpinresult( CPIN_RSLT_SimPinReq );
324 }
325 else
326 {
327 simactivated_errorresult( CME_ERR_SimPinReq, cmdBuf );
328 }
329 break;
330
331 case( PS_PIN2 ):
332 if( cmdBuf EQ AT_CMD_CPIN )
333 {
334 simactivated_cpinresult( CPIN_RSLT_SimPin2Req );
335 }
336 else
337 {
338 simactivated_errorresult( CME_ERR_SimPin2Req, cmdBuf );
339 }
340 break;
341
342 case( PS_RDY ):
343 /* wait for SIM insert indication to complete command */
344 simEntStat.curCmd = cmdBuf;
345 break;
346 }
347 break;
348
349 case( SS_BLKD ):
350
351 switch( simShrdPrm.PINStat )
352 {
353 case( PS_PUK1 ):
354 if( cmdBuf EQ AT_CMD_CPIN )
355 {
356 simactivated_cpinresult( CPIN_RSLT_SimPukReq );
357 }
358 else
359 {
360 simactivated_errorresult( CME_ERR_SimPukReq, cmdBuf );
361 }
362 break;
363
364 case( PS_PUK2 ):
365 if( cmdBuf EQ AT_CMD_CPIN )
366 {
367 simactivated_cpinresult( CPIN_RSLT_SimPuk2Req );
368 }
369 else
370 {
371 simactivated_errorresult( CME_ERR_SimPuk2Req, cmdBuf );
372 }
373 break;
374 }
375 break;
376
377 }
378 }
379
380 /*
381 +-------------------------------------------------------------------+
382 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
383 | ROUTINE : cmhSIM_SIMActivated |
384 +-------------------------------------------------------------------+
385
386 PURPOSE : SIM activated
387
388 */
389
390 GLOBAL void cmhSIM_SIMActivated ( void )
391 {
392 T_ACI_CMD_SRC idx;
393
394 TRACE_FUNCTION ("cmhSIM_SIMActivated()");
395
396 /* check for command context */
397 switch( simEntStat.curCmd )
398 {
399 case( AT_CMD_CFUN ):
400 case( AT_CMD_CPIN ):
401 case( AT_CMD_CIMI ):
402 case( AT_CMD_NRG ):
403 case( AT_CMD_SIMRST):
404 /* process event for +CFUN, +CPIN, +CIMI and for %NRG command */
405 cmhsim_simactivated_start( );
406 break;
407
408 case( AT_CMD_CLCK ):
409 /* process event for +CLCK command */
410 cmhsim_simactivated_clck( );
411 break;
412
413 case( AT_CMD_NONE ):
414 /* process event spontaneous insertion */
415 if (simShrdPrm.rslt EQ SIM_NO_ERROR)
416 {
417 ; /* do nothing right now since the %SIMINS: -1 must be
418 syncronized with SIM_MMI_INSERT_IND which will come later! */
419 }
420 else
421 {
422 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
423 {
424 R_AT( RAT_SIMINS, idx )(cmhSIM_GetCmeFromSim (simShrdPrm.rslt));
425 }
426 }
427 break;
428 }
429 }
430
431 /*
432 +-------------------------------------------------------------------+
433 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
434 | ROUTINE : cmhSIM_SIMInserted |
435 +-------------------------------------------------------------------+
436
437 PURPOSE : SIM inserted
438
439 */
440
441 GLOBAL void cmhSIM_SIMInserted ( void )
442 {
443 UBYTE cmdBuf; /* buffers current command */
444 CHAR imsiBuf[MAX_IMSI_LEN+1]; /* buffer IMSI representation +1 for '\0'*/
445 T_ACI_CME_ERR err_code = CME_ERR_NotPresent; /* code holding the correct error code calculated */
446 BOOL return_rat_ok = 1; /* return ok? */
447
448 TRACE_FUNCTION ("cmhSIM_SIMInserted()");
449
450 /* Check if the SIM is functional and the IMSI value is valid*/
451 if ( simShrdPrm.crdFun EQ SIM_NO_OPERATION OR
452 simShrdPrm.imsi.c_field EQ 0 )
453 {
454 simShrdPrm.SIMStat = SS_INV;
455 err_code = CME_ERR_SimWrong;
456 }
457
458 switch( simEntStat.curCmd )
459 {
460 case( AT_CMD_CFUN ):
461 case( AT_CMD_CPIN ):
462 case( AT_CMD_PVRF ):
463 case( AT_CMD_SIMRST):
464 case( KSD_CMD_UBLK):
465 /*
466 *----------------------------------------------------------------
467 * process event for +CFUN, +CPIN, %PVRF commands and for the
468 SIM reset condition
469 *----------------------------------------------------------------
470 */
471
472 cmdBuf = simEntStat.curCmd;
473 simEntStat.curCmd = AT_CMD_NONE;
474 #ifdef SIM_PERS
475 if((aci_slock_sim_config.sim_type EQ SIM_TYPEAPPROVAL) AND AciSLockShrd.blocked)
476 {
477 simShrdPrm.SIMStat = SS_INV;
478 err_code = CME_ERR_SimWrong;
479 }
480 if(cfg_data EQ NULL)
481 {
482 simShrdPrm.SIMStat = SS_INV;
483 err_code = CME_ERR_Unknown;
484 R_AT( RAT_CME, simEntStat.entOwn ) ( cmdBuf, err_code );
485 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf, -1, -1, err_code );
486 simShrdPrm.PINQuery = 0;
487 return;
488 }
489 #endif
490
491 if( err_code EQ CME_ERR_SimWrong )
492 {
493 R_AT( RAT_CME, simEntStat.entOwn ) ( cmdBuf, err_code );
494 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf, -1, -1, err_code );
495 simShrdPrm.PINQuery = 0;
496 return;
497 }
498
499 #ifdef SIM_PERS
500 /* check for personalisation locking. If SIM was detected as not correct, do signal AT_CPIN */
501
502 if ( AciSLockShrd.blocked)
503 {
504 /* @GBR: Alternativly CME_ERR_SimWrong might be returned, but this way is telling the MMI mor specific, what went wrong. */
505 aci_set_cme_error_code(AciSLockShrd.current_lock,&err_code);
506
507 return_rat_ok = 0;
508 R_AT( RAT_CME, simEntStat.entOwn )
509 ( cmdBuf, err_code );
510 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf, -1, -1, err_code );
511 }
512
513 #endif
514 if ( (cmdBuf EQ AT_CMD_CPIN) AND (simShrdPrm.PINQuery EQ 1) ) /* Case when PIN is disabled and CFUN=0 */
515 {
516 R_AT( RAT_CPIN, simEntStat.entOwn )
517 ( CPIN_RSLT_SimReady );
518 simShrdPrm.PINQuery = 0;
519 }
520
521 #if defined (GPRS) AND defined (DTI)
522 gprs_sim_inserted();
523 #endif /* GPRS */
524
525 if (return_rat_ok EQ 1) /* @gbr: only send ok, if everhing went okay. The +CFUN might not be ready here, so don't send something! */
526 {
527
528 R_AT( RAT_OK, simEntStat.entOwn ) ( cmdBuf );
529 cmh_logRslt ( simEntStat.entOwn, RAT_OK, cmdBuf, -1, -1, -1 );
530 }
531 break;
532
533 case( AT_CMD_CIMI ):
534 /*
535 *----------------------------------------------------------------
536 * process event for +CIMI command
537 *----------------------------------------------------------------
538 */
539
540
541 if( err_code EQ CME_ERR_SimWrong )
542 {
543 R_AT( RAT_CME, simEntStat.entOwn ) ( AT_CMD_CIMI, err_code );
544 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CIMI, -1, -1, err_code );
545 return;
546 }
547
548 R_AT( RAT_CIMI, simEntStat.entOwn )
549 ( psaSIM_cnvrtIMSI2ASCII( imsiBuf ));
550
551 simEntStat.curCmd = AT_CMD_NONE;
552
553 R_AT( RAT_OK, simEntStat.entOwn )
554 ( AT_CMD_CIMI );
555 break;
556
557 case( AT_CMD_NRG ):
558 /*
559 *----------------------------------------------------------------
560 * process event for %NRG
561 *----------------------------------------------------------------
562 */
563 cmdBuf = simEntStat.curCmd;
564 if( err_code EQ CME_ERR_SimWrong )
565 {
566 simEntStat.curCmd = AT_CMD_NONE;
567 mmEntStat.curCmd = AT_CMD_NONE;
568 R_AT( RAT_CME, simEntStat.entOwn ) ( cmdBuf, err_code );
569 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf, -1, -1, err_code );
570 return;
571 }
572
573 switch( cmhPrm[simShrdPrm.owner].mmCmdPrm.NRGregMode )
574 {
575 case( NRG_RGMD_Auto ):
576
577 mmShrdPrm.regMode = MODE_AUTO;
578
579 simEntStat.curCmd = AT_CMD_NONE;
580 mmEntStat.curCmd = AT_CMD_NRG;
581 mmEntStat.entOwn = mmShrdPrm.owner = simShrdPrm.owner;
582
583 #if defined (GPRS) AND defined (DTI)
584 (void)psaG_MM_CMD_REG (); /* register to network */
585 #else
586 (void)psaMM_Registrate (); /* register to network */
587 #endif
588
589 cmhMM_Ntfy_NtwRegistrationStatus(CREG_STAT_Search);
590 break;
591
592 case( NRG_RGMD_Manual ):
593
594 mmShrdPrm.regMode = MODE_MAN;
595
596 simEntStat.curCmd = AT_CMD_NONE;
597 mmEntStat.curCmd = AT_CMD_NRG;
598 mmEntStat.entOwn = mmShrdPrm.owner = simShrdPrm.owner;
599
600 #if defined (GPRS) && defined (DTI)
601 psaG_MM_CMD_NET_SEL ( ); /* register to network */
602 #else
603 psaMM_NetSel (); /* register to network */
604 #endif
605
606 cmhMM_Ntfy_NtwRegistrationStatus(CREG_STAT_Search);
607 break;
608 }
609 break;
610
611 case( AT_CMD_NONE ):
612 {
613 T_ACI_CMD_SRC idx;
614 /* process event spontaneous insertion */
615 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
616 {
617 R_AT( RAT_SIMINS, idx )( err_code );
618 }
619 }
620 break;
621
622 }
623 }
624
625 /*
626 +-------------------------------------------------------------------+
627 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
628 | ROUTINE : cmhSIM_SIMRemoved |
629 +-------------------------------------------------------------------+
630
631 PURPOSE : SIM removed
632
633 */
634
635 GLOBAL void cmhSIM_SIMRemoved ( void )
636 {
637 UBYTE cmdBuf; /* buffers command */
638 T_ACI_CMD_SRC idx;
639 T_ACI_CME_ERR cme_error; /* CME error code */
640 T_ACI_SIMREM_TYPE srt; /* type of SIM remove */
641
642 TRACE_FUNCTION ("cmhSIM_SIMRemoved()");
643
644 if (simEntStat.curCmd NEQ AT_CMD_NONE)
645 {
646 cmdBuf = simEntStat.curCmd;
647 simEntStat.curCmd = AT_CMD_NONE;
648
649 if (simShrdPrm.rslt EQ SIM_NO_ERROR)
650 cme_error = CME_ERR_SimBusy;
651 else
652 cme_error = cmhSIM_GetCmeFromSim (simShrdPrm.rslt);
653
654 R_AT( RAT_CME, simEntStat.entOwn )
655 ( cmdBuf, cme_error );
656 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
657 -1, -1, cme_error );
658 }
659 EfPLMNselStat = EF_STAT_UNKNWN;
660 /*
661 *----------------------------------------------------------------
662 * send unsolicited result
663 *----------------------------------------------------------------
664 */
665 TRACE_EVENT_P1("Result of SIM remove indication: %x", simShrdPrm.rslt);
666 switch (simShrdPrm.rslt)
667 {
668 case SIM_NO_ERROR:
669 /* In this case the AT command state is set to SIM RESET */
670 /* NO, don't do this!
671 This line would prevent a %SIMIND: 11 and instead leads to
672 "+CME ERROR: SIM PIN required" without any command context which is wrong */
673 /* simEntStat.curCmd = AT_CMD_SIMRST; */
674 srt = SIMREM_RESET;
675 break;
676 case SIM_CAUSE_DRV_TEMPFAIL:
677 srt = SIMREM_RETRY;
678 break;
679 default:
680 srt = SIMREM_FAILURE;
681 break;
682 }
683
684 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
685 {
686 R_AT( RAT_SIMREM, idx )(srt);
687 }
688 }
689
690 /*
691 +-------------------------------------------------------------------+
692 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
693 | ROUTINE : cmhSIM_PINVerified |
694 +-------------------------------------------------------------------+
695
696 PURPOSE : SIM verified
697
698 */
699 LOCAL void pin_verified_clck (USHORT sim_result)
700 {
701 TRACE_FUNCTION ("pin_verified_clck()");
702
703 switch(sim_result)
704 {
705 case( SIM_NO_ERROR ):
706 /* now do it ! */
707
708 /* Check if we want to do FDN Lock or ALS Lock */
709 switch (simShrdPrm.setPrm[simShrdPrm.owner].actProc)
710 {
711 case SIM_FDN_ENABLE:
712 case SIM_FDN_DISABLE:
713 /* FDN Lock */
714 if( psaSIM_ActivateSIM() < 0 ) /* activate SIM card */
715 {
716 simEntStat.curCmd = AT_CMD_NONE;
717
718 R_AT( RAT_CME, simEntStat.entOwn )
719 ( AT_CMD_CLCK, CME_ERR_Unknown );
720 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CLCK,
721 -1, -1, CME_ERR_Unknown );
722 }
723 break;
724
725 case SIM_ALS_LOCK:
726 case SIM_ALS_UNLOCK:
727 /* ALS Lock to PIN2 */
728 if (simShrdPrm.setPrm[simShrdPrm.owner].actProc EQ SIM_ALS_LOCK)
729 {
730 ALSlock = cmhPrm[simShrdPrm.owner].ccCmdPrm.ALSmode;
731 /* pull all sources to the current ALSmode, otherwise a lock won't make sense */
732 {
733 int i;
734 for (i=0; i<OWN_MAX; i++)
735 cmhPrm[i].ccCmdPrm.ALSmode = ALSlock;
736 /* and lock them all */
737 }
738 #ifndef _SIMULATION_
739 /* write Lock to FFS */
740 FFS_fwrite("/gsm/com/ALSlock", &ALSlock, sizeof(ALSlock));
741 #endif
742 }
743 else
744 /* unlock ALS */
745 {
746 ALSlock = ALS_MOD_NOTPRESENT;
747 #ifndef _SIMULATION_
748 /* remove lock from FFS */
749 FFS_remove("/gsm/com/ALSlock");
750 #endif
751 }
752
753 simEntStat.curCmd = AT_CMD_NONE;
754
755 R_AT( RAT_OK, simEntStat.entOwn )
756 ( AT_CMD_CLCK );
757 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_CLCK, -1, -1, -1 );
758 break;
759
760 }
761 break; /* SIM_NO_ERROR */
762
763 case( SIM_CAUSE_PIN1_EXPECT ):
764 case( SIM_CAUSE_PIN2_EXPECT ):
765 case( SIM_CAUSE_PIN1_BLOCKED ):
766 case( SIM_CAUSE_PUK1_EXPECT ):
767 case( SIM_CAUSE_PIN2_BLOCKED ):
768 case( SIM_CAUSE_PUK2_EXPECT ):
769 simEntStat.curCmd = AT_CMD_NONE;
770
771 R_AT( RAT_CME, simEntStat.entOwn )
772 ( AT_CMD_CLCK, cmhSIM_GetCmeFromSim ( sim_result ) /*CME_ERR_WrongPasswd*/ );
773 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CLCK,
774 -1, -1, CME_ERR_WrongPasswd );
775 break;
776
777 default:
778 simEntStat.curCmd = AT_CMD_NONE;
779 R_AT( RAT_CME, simEntStat.entOwn )
780 ( AT_CMD_CLCK, CME_ERR_SimFail );
781 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CLCK,
782 -1, -1, CME_ERR_SimFail );
783 break;
784 }
785 }
786
787 GLOBAL void cmhSIM_PINVerified ( void )
788 {
789 UBYTE cmdBuf; /* buffers command */
790 T_PHB_CMD_PRM * pPHBCmdPrm; /* points to PHB command parameters */
791
792 TRACE_FUNCTION ("cmhSIM_PINVerified()");
793
794 pPHBCmdPrm = &cmhPrm[simShrdPrm.owner].phbCmdPrm;
795
796 /*
797 *-------------------------------------------------------------------
798 * check for command context
799 *-------------------------------------------------------------------
800 */
801 switch( simEntStat.curCmd )
802 {
803 case( AT_CMD_CLCK ):
804 /* process event for +CLCK command */
805 pin_verified_clck( simShrdPrm.rslt );
806 return;
807
808 case( AT_CMD_CPIN ):
809 case( AT_CMD_PVRF ):
810 /*
811 *----------------------------------------------------------------
812 * process event for +CPIN and %PVRF command
813 *----------------------------------------------------------------
814 */
815 switch( simShrdPrm.rslt )
816 {
817 case( SIM_NO_ERROR ):
818
819 /* if verified PIN was PIN 2 or PIN 1 was already entered */
820 if( simShrdPrm.setPrm[simEntStat.entOwn].PINType EQ
821 PHASE_2_PIN_2 OR
822 simShrdPrm.crdPhs NEQ 0xFF )
823 {
824 cmdBuf = simEntStat.curCmd;
825 simEntStat.curCmd = AT_CMD_NONE;
826
827 R_AT( RAT_OK, simEntStat.entOwn )
828 ( cmdBuf );
829 cmh_logRslt ( simEntStat.entOwn, RAT_OK, cmdBuf, -1, -1, -1 );
830 }
831 /* otherwise wait for SIM insert indication to complete command */
832 break;
833
834 case( SIM_CAUSE_PIN1_EXPECT ):
835 case( SIM_CAUSE_PIN2_EXPECT ):
836 case( SIM_CAUSE_PUK1_EXPECT ):
837 case( SIM_CAUSE_PUK2_EXPECT ):
838 cmdBuf = simEntStat.curCmd;
839 simEntStat.curCmd = AT_CMD_NONE;
840
841 R_AT( RAT_CME, simEntStat.entOwn )
842 ( cmdBuf, CME_ERR_WrongPasswd );
843 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
844 -1, -1, CME_ERR_WrongPasswd );
845 break;
846 case( SIM_CAUSE_PIN1_BLOCKED):
847 cmdBuf = simEntStat.curCmd;
848 simEntStat.curCmd = AT_CMD_NONE;
849
850 R_AT( RAT_CME, simEntStat.entOwn )
851 ( cmdBuf, CME_ERR_SimPukReq );
852 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
853 -1, -1, CME_ERR_SimPukReq );
854 break;
855 case( SIM_CAUSE_PIN2_BLOCKED):
856 cmdBuf = simEntStat.curCmd;
857 simEntStat.curCmd = AT_CMD_NONE;
858
859 R_AT( RAT_CME, simEntStat.entOwn )
860 ( cmdBuf, CME_ERR_SimPuk2Req );
861 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
862 -1, -1, CME_ERR_SimPuk2Req );
863 break;
864 default:
865 cmdBuf = simEntStat.curCmd;
866 simEntStat.curCmd = AT_CMD_NONE;
867 R_AT( RAT_CME, simEntStat.entOwn )
868 ( cmdBuf, CME_ERR_SimFail );
869 break;
870 }
871 break;
872
873 case( AT_CMD_CAMM ):
874 /*
875 *----------------------------------------------------------------
876 * process event for +CAMM command
877 *----------------------------------------------------------------
878 */
879 switch( simShrdPrm.rslt )
880 {
881 case( SIM_NO_ERROR ):
882 /*
883 * Try it again
884 */
885 simEntStat.curCmd = AT_CMD_NONE;
886 aoc_update_acmmax (SECOND_UPDATE, 0L);
887 break;
888
889 default:
890 simEntStat.curCmd = AT_CMD_NONE;
891 R_AT( RAT_CME, simEntStat.entOwn )
892 ( AT_CMD_CAMM, CME_ERR_WrongPasswd );
893 break;
894 }
895 break;
896
897 case( AT_CMD_CPUC ):
898 /*
899 *----------------------------------------------------------------
900 * process event for +CPUC command
901 *----------------------------------------------------------------
902 */
903 switch( simShrdPrm.rslt )
904 {
905 case( SIM_NO_ERROR ):
906 /*
907 * Try it again
908 */
909 simEntStat.curCmd = AT_CMD_NONE;
910 aoc_update_puct (SECOND_UPDATE, 0L);
911 break;
912
913 default:
914 simEntStat.curCmd = AT_CMD_NONE;
915 R_AT( RAT_CME, simEntStat.entOwn )
916 ( AT_CMD_CPUC, CME_ERR_WrongPasswd );
917 break;
918 }
919 break;
920
921 case( AT_CMD_CACM ):
922 /*
923 *----------------------------------------------------------------
924 * process event for +CACM command
925 *----------------------------------------------------------------
926 */
927 switch( simShrdPrm.rslt )
928 {
929 case( SIM_NO_ERROR ):
930 /*
931 * Try it again
932 */
933 simEntStat.curCmd = AT_CMD_NONE;
934 aoc_update_acm (SECOND_UPDATE, 0L);
935 break;
936
937 default:
938 simEntStat.curCmd = AT_CMD_NONE;
939 R_AT( RAT_CME, simEntStat.entOwn )
940 ( AT_CMD_CACM, CME_ERR_WrongPasswd );
941 break;
942 }
943 break;
944
945 /*----------------------------------------------------------*
946 * The below code is for CPBW SIM verification response *
947 *----------------------------------------------------------*/
948
949 case( AT_CMD_CPBS ):
950 /*
951 *----------------------------------------------------------------
952 * process event for +CPBW command
953 *----------------------------------------------------------------
954 */
955 switch( simShrdPrm.rslt )
956 {
957 case( SIM_NO_ERROR ):
958
959 /*-----------------------------------------------*
960 * if verified PIN was PIN 2 was already entered *
961 *-----------------------------------------------*/
962
963 cmdBuf = simEntStat.curCmd;
964 simEntStat.curCmd = AT_CMD_NONE;
965
966 pPHBCmdPrm->cmhStor = pPHBCmdPrm->temp_cmhStor;
967 pPHBCmdPrm->phbStor = pPHBCmdPrm->temp_phbStor;
968
969 R_AT( RAT_OK, simEntStat.entOwn )
970 ( cmdBuf );
971
972 cmh_logRslt ( simEntStat.entOwn, RAT_OK, cmdBuf, -1, -1, -1 );
973
974 /*---------------------------------------------------------------*
975 * otherwise wait for SIM insert indication to complete command *
976 *---------------------------------------------------------------*/
977
978 break;
979
980 case( SIM_CAUSE_PUK2_EXPECT ):
981 case( SIM_CAUSE_PIN2_BLOCKED):
982 case( SIM_CAUSE_PIN2_EXPECT ):
983
984 cmdBuf = simEntStat.curCmd;
985 simEntStat.curCmd = AT_CMD_NONE;
986
987 R_AT( RAT_CME, simEntStat.entOwn )
988 ( cmdBuf, CME_ERR_WrongPasswd );
989 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
990 -1, -1, CME_ERR_WrongPasswd );
991 break;
992
993 default:
994 cmdBuf = simEntStat.curCmd;
995 simEntStat.curCmd = AT_CMD_NONE;
996 R_AT( RAT_CME, simEntStat.entOwn )
997 ( cmdBuf, CME_ERR_SimFail );
998 break;
999 }
1000 break;
1001
1002 default:
1003
1004 simEntStat.curCmd = AT_CMD_NONE;
1005 R_AT( RAT_CME, simEntStat.entOwn )
1006 ( AT_CMD_CPIN, CME_ERR_Unknown );
1007 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CPIN,
1008 -1, -1, CME_ERR_Unknown );
1009 break;
1010 }
1011 }
1012
1013 /*
1014 +-------------------------------------------------------------------+
1015 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
1016 | ROUTINE : cmhSIM_PINChanged |
1017 +-------------------------------------------------------------------+
1018
1019 PURPOSE : SIM changed
1020
1021 */
1022
1023 GLOBAL void cmhSIM_PINChanged ( void )
1024 {
1025 T_ACI_CME_ERR err;
1026 UBYTE cmdBuf;
1027
1028 TRACE_FUNCTION ("cmhSIM_PINChanged()");
1029
1030 /*
1031 *-------------------------------------------------------------------
1032 * check for command context
1033 *-------------------------------------------------------------------
1034 */
1035 switch( simEntStat.curCmd )
1036 {
1037 case( AT_CMD_CPWD ):
1038 /*lint -e{408} */
1039 case( KSD_CMD_PWD ): /* KSD_CMD_* extends AT_CMD_* */
1040 /*
1041 *----------------------------------------------------------------
1042 * process event for +CPWD and KSD PWD command
1043 *----------------------------------------------------------------
1044 */
1045 switch( simShrdPrm.rslt )
1046 {
1047 case( SIM_NO_ERROR ):
1048
1049 cmdBuf = simEntStat.curCmd;
1050 simEntStat.curCmd = AT_CMD_NONE;
1051
1052 R_AT( RAT_OK, simEntStat.entOwn )
1053 ( cmdBuf );
1054 cmh_logRslt ( simEntStat.entOwn, RAT_OK, cmdBuf, -1, -1, -1 );
1055 return;
1056
1057 /* why not use a meaningful CME error code?
1058 case( SIM_CAUSE_PUK1_EXPECT ):
1059 case( SIM_CAUSE_PUK2_EXPECT ): */
1060 case( SIM_CAUSE_PIN1_EXPECT ):
1061 case( SIM_CAUSE_PIN2_EXPECT ):
1062 err = CME_ERR_WrongPasswd;
1063 break;
1064
1065 default:
1066 err = cmhSIM_GetCmeFromSim ( simShrdPrm.rslt );
1067 break;
1068 }
1069
1070 cmdBuf = simEntStat.curCmd;
1071 simEntStat.curCmd = AT_CMD_NONE;
1072
1073 R_AT( RAT_CME, simEntStat.entOwn )
1074 ( cmdBuf, err );
1075 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
1076 -1, -1, err );
1077 break;
1078 }
1079 }
1080
1081 /*
1082 +-------------------------------------------------------------------+
1083 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
1084 | ROUTINE : cmhSIM_PINEnabled |
1085 +-------------------------------------------------------------------+
1086
1087 PURPOSE : SIM enabled
1088
1089 */
1090
1091 GLOBAL void cmhSIM_PINEnabled ( void )
1092 {
1093 T_ACI_CME_ERR err;
1094
1095 TRACE_FUNCTION ("cmhSIM_PINEnabled()");
1096
1097 /*
1098 *-------------------------------------------------------------------
1099 * check for command context
1100 *-------------------------------------------------------------------
1101 */
1102 switch( simEntStat.curCmd )
1103 {
1104 case( AT_CMD_CLCK ):
1105 /*
1106 *----------------------------------------------------------------
1107 * process event for +CLCK command
1108 *----------------------------------------------------------------
1109 */
1110 switch( simShrdPrm.rslt )
1111 {
1112 case( SIM_NO_ERROR ):
1113
1114 simEntStat.curCmd = AT_CMD_NONE;
1115
1116 R_AT( RAT_OK, simEntStat.entOwn )
1117 ( AT_CMD_CLCK );
1118 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_CLCK, -1, -1, -1 );
1119 return;
1120
1121 case( SIM_CAUSE_PIN1_EXPECT ):
1122 case( SIM_CAUSE_PIN1_BLOCKED ):
1123 err = CME_ERR_WrongPasswd;
1124 break;
1125
1126 default:
1127 err = cmhSIM_GetCmeFromSim ( simShrdPrm.rslt );
1128 break;
1129 }
1130
1131 simEntStat.curCmd = AT_CMD_NONE;
1132
1133 R_AT( RAT_CME, simEntStat.entOwn )
1134 ( AT_CMD_CLCK, err );
1135 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CLCK,
1136 -1, -1, err );
1137 break;
1138 }
1139 }
1140
1141 /*
1142 +-------------------------------------------------------------------+
1143 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
1144 | ROUTINE : cmhSIM_PINDisabled |
1145 +-------------------------------------------------------------------+
1146
1147 PURPOSE : SIM disabled
1148
1149 */
1150
1151 GLOBAL void cmhSIM_PINDisabled ( void )
1152 {
1153 T_ACI_CME_ERR err;
1154
1155 TRACE_FUNCTION ("cmhSIM_PINDisabled()");
1156
1157 /*
1158 *-------------------------------------------------------------------
1159 * check for command context
1160 *-------------------------------------------------------------------
1161 */
1162 switch( simEntStat.curCmd )
1163 {
1164 case( AT_CMD_CLCK ):
1165 /*
1166 *----------------------------------------------------------------
1167 * process event for +CLCK command
1168 *----------------------------------------------------------------
1169 */
1170 switch( simShrdPrm.rslt )
1171 {
1172 case( SIM_NO_ERROR ):
1173
1174 simEntStat.curCmd = AT_CMD_NONE;
1175
1176 R_AT( RAT_OK, simEntStat.entOwn )
1177 ( AT_CMD_CLCK );
1178 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_CLCK, -1, -1, -1 );
1179 return;
1180
1181 case( SIM_CAUSE_PIN1_EXPECT ):
1182 case( SIM_CAUSE_PIN1_BLOCKED ):
1183 err = CME_ERR_WrongPasswd;
1184 break;
1185
1186 default:
1187 err = cmhSIM_GetCmeFromSim ( simShrdPrm.rslt );
1188 break;
1189 }
1190
1191 simEntStat.curCmd = AT_CMD_NONE;
1192
1193 R_AT( RAT_CME, simEntStat.entOwn )
1194 ( AT_CMD_CLCK, err );
1195 cmh_logRslt ( simEntStat.entOwn, RAT_CME, AT_CMD_CLCK,
1196 -1, -1, err );
1197 break;
1198 }
1199 }
1200
1201 /*
1202 +-------------------------------------------------------------------+
1203 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
1204 | ROUTINE : cmhSIM_CardUnblocked |
1205 +-------------------------------------------------------------------+
1206
1207 PURPOSE : Card unblocked
1208
1209 */
1210
1211 GLOBAL void cmhSIM_CardUnblocked ( void )
1212 {
1213 UBYTE cmdBuf;
1214 T_ACI_CME_ERR err;
1215
1216 TRACE_FUNCTION ("cmhSIM_CardUnblocked()");
1217
1218 /*
1219 *-------------------------------------------------------------------
1220 * check for command context
1221 *-------------------------------------------------------------------
1222 */
1223 switch( simEntStat.curCmd )
1224 {
1225 case( AT_CMD_CPIN ):
1226 case( AT_CMD_PVRF ):
1227 /*lint -e{408} */
1228 case( KSD_CMD_UBLK ):
1229 /*
1230 *----------------------------------------------------------------
1231 * process event for +CPIN, %PVRF and KSD UBLK command
1232 *----------------------------------------------------------------
1233 */
1234 switch( simShrdPrm.rslt )
1235 {
1236 case( SIM_NO_ERROR ):
1237
1238 if(simShrdPrm.crdPhs NEQ 0xFF)/* If SIM insert indication is already received*/
1239 {
1240 cmdBuf = simEntStat.curCmd;
1241 simEntStat.curCmd = AT_CMD_NONE;
1242
1243 R_AT( RAT_OK, simEntStat.entOwn )
1244 ( cmdBuf );
1245 cmh_logRslt ( simEntStat.entOwn, RAT_OK, cmdBuf, -1, -1, -1 );
1246 }/* else wait till SIM insert indication is received*/
1247 return;
1248
1249 /* why not use a meaningful CME error code?
1250 case( SIM_CAUSE_PUK1_EXPECT ):
1251 case( SIM_CAUSE_PUK2_EXPECT ): */
1252 case( SIM_CAUSE_PIN1_EXPECT ):
1253 case( SIM_CAUSE_PIN2_EXPECT ):
1254 err = CME_ERR_WrongPasswd;
1255 break;
1256
1257 default:
1258 err = cmhSIM_GetCmeFromSim ( simShrdPrm.rslt );
1259 break;
1260 }
1261
1262 cmdBuf = simEntStat.curCmd;
1263 simEntStat.curCmd = AT_CMD_NONE;
1264
1265 R_AT( RAT_CME, simEntStat.entOwn )
1266 ( cmdBuf, err );
1267 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
1268 -1, -1, err );
1269 break;
1270 }
1271 }
1272
1273 /*
1274 +-------------------------------------------------------------------+
1275 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
1276 | ROUTINE : cmhSIM_SIMResponseData |
1277 +-------------------------------------------------------------------+
1278
1279 PURPOSE : SIM response data
1280
1281 */
1282
1283 GLOBAL void cmhSIM_SIMResponseData( T_SIM_TRNS_RSP_PRM* rsp )
1284 {
1285 UBYTE cmdBuf; /* buffers command */
1286 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
1287 UBYTE *rspData;
1288
1289 TRACE_FUNCTION ("cmhSIM_SIMResponseData()");
1290
1291 cmdBuf = simEntStat.curCmd;
1292 simEntStat.curCmd = AT_CMD_NONE;
1293
1294 ownBuf = simEntStat.entOwn;
1295 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1296
1297 /*
1298 *-------------------------------------------------------------------
1299 * check for command context
1300 *-------------------------------------------------------------------
1301 */
1302 switch( cmdBuf )
1303 {
1304 case( AT_CMD_CRSM ):
1305 if (simShrdPrm.rslt NEQ SIM_NO_ERROR AND
1306 GET_CAUSE_DEFBY(simShrdPrm.rslt) EQ DEFBY_CONDAT )
1307 {
1308 /*
1309 *----------------------------------------------------------------
1310 * error event for +CRSM
1311 *----------------------------------------------------------------
1312 */
1313 R_AT( RAT_CME, ownBuf )
1314 (
1315 cmdBuf,
1316 cmhSIM_GetCmeFromSim ( simShrdPrm.rslt )
1317 );
1318 }
1319 else
1320 {
1321 /*
1322 *----------------------------------------------------------------
1323 * process event for +CRSM
1324 *----------------------------------------------------------------
1325 */
1326 R_AT( RAT_CRSM, ownBuf )
1327 ( rsp->sw1, rsp->sw2, rsp->rspLen, ((rsp->rspLen)?rsp->rsp:NULL));
1328
1329 R_AT( RAT_OK, ownBuf )
1330 ( cmdBuf );
1331 }
1332 break;
1333
1334 case( AT_CMD_CSIM ):
1335 /*
1336 *----------------------------------------------------------------
1337 * error event for +CSIM
1338 *----------------------------------------------------------------
1339 */
1340 if (simShrdPrm.rslt NEQ SIM_NO_ERROR)
1341 {
1342 R_AT( RAT_CME, ownBuf )
1343 (
1344 cmdBuf,
1345 cmhSIM_GetCmeFromSim ( simShrdPrm.rslt )
1346 );
1347
1348 return;
1349 }
1350 /*
1351 *----------------------------------------------------------------
1352 * process event for +CSIM
1353 *----------------------------------------------------------------
1354 */
1355 ACI_MALLOC(rspData, MAX_SIM_CMD+2); /* alloc 2 byte more for sw1 and sw2 */
1356 memcpy (rspData, rsp->rsp, rsp->rspLen);
1357 rspData[rsp->rspLen++] = rsp->sw1;
1358 rspData[rsp->rspLen++] = rsp->sw2;
1359
1360 R_AT( RAT_CSIM, ownBuf )
1361 ( rsp->rspLen, rspData);
1362
1363 ACI_MFREE(rspData);
1364
1365 R_AT( RAT_OK, ownBuf )
1366 ( cmdBuf );
1367 break;
1368
1369 default:
1370 TRACE_EVENT("wrong command context (+CRSM or +CSIM expected)");
1371 break;
1372 }
1373 }
1374
1375 /*
1376 +--------------------------------------------------------------------+
1377 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
1378 | ROUTINE : cmhSIM_CnfMsisdn |
1379 +--------------------------------------------------------------------+
1380
1381 PURPOSE : This function handles the confirmation of reading
1382 EF MSISDN from SIM.
1383 */
1384 GLOBAL void cmhSIM_CnfMsisdn ( SHORT table_id )
1385 {
1386 T_SIM_CMD_PRM* pSIMCmdPrm; /* points to SIM command parameters */
1387 T_ACI_AT_CMD cmdBuf; /* buffers current command */
1388 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
1389
1390 UBYTE* ptr; /* pointer to decoded data */
1391 UBYTE alphaLen; /* max. length of alpha identifier */
1392 UBYTE tmpActRec; /* actual record number */
1393 UBYTE* pExchData; /* points to exchange data buffer */
1394 UBYTE dataLen; /* holds length of data */
1395
1396 TRACE_FUNCTION ("cmhSIM_CnfMsisdn()");
1397
1398 pSIMCmdPrm = &cmhPrm[simEntStat.entOwn].simCmdPrm;
1399 cmdBuf = simEntStat.curCmd;
1400 ownBuf = simEntStat.entOwn;
1401 pExchData = simShrdPrm.atb[table_id].exchData;
1402 dataLen = simShrdPrm.atb[table_id].dataLen;
1403
1404
1405 switch ( simShrdPrm.atb[table_id].errCode )
1406 {
1407 case ( SIM_NO_ERROR ):
1408 {
1409 /*
1410 *-------------------------------------------------------------
1411 * check basic consistency of read data
1412 *-------------------------------------------------------------
1413 */
1414 if ( pExchData EQ NULL OR
1415 dataLen < ACI_MIN_SIZE_EF_MSISDN )
1416 {
1417 simEntStat.curCmd = AT_CMD_NONE;
1418 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1419
1420 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
1421 }
1422 else
1423 {
1424 ptr = pExchData;
1425 alphaLen = dataLen - ACI_MIN_SIZE_EF_MSISDN;
1426
1427 /*
1428 *-----------------------------------------------------------
1429 * process parameter <lenEfMsisdn>
1430 *-----------------------------------------------------------
1431 */
1432 CNUMLenEfMsisdn = dataLen;
1433
1434 /*
1435 *-----------------------------------------------------------
1436 * process parameter <cnumMaxRec>
1437 *-----------------------------------------------------------
1438 */
1439 if ( pSIMCmdPrm -> CNUMActRec EQ 1 )
1440 CNUMMaxRec = simShrdPrm.atb[table_id].recMax;
1441
1442 /*
1443 *-----------------------------------------------------------
1444 * process parameter <alpha>
1445 *-----------------------------------------------------------
1446 */
1447 cmhPHB_getTagNt ( ptr,
1448 alphaLen,
1449 CNUMMsisdn[CNUMMsisdnIdx].alpha,
1450 MAX_ALPHA_LEN );
1451
1452 ptr += alphaLen;
1453
1454 /*
1455 *-----------------------------------------------------------
1456 * process parameter <number>
1457 *-----------------------------------------------------------
1458 */
1459 cmhPHB_getAdrStr ( CNUMMsisdn[CNUMMsisdnIdx].number,
1460 MAX_PHB_NUM_LEN - 1,
1461 ptr + 2,
1462 *ptr );
1463
1464 /*
1465 *-----------------------------------------------------------
1466 * validate entry of MSISDN list
1467 *-----------------------------------------------------------
1468 */
1469 /* VO patch 14.03.01
1470 * move validate entry to after decoding alpha and number
1471 * and set the vldFlag only when the alpha or the number exists. */
1472 if ( strlen(CNUMMsisdn[CNUMMsisdnIdx].number) OR
1473 strlen(CNUMMsisdn[CNUMMsisdnIdx].alpha) )
1474 {
1475 CNUMMsisdn[CNUMMsisdnIdx].vldFlag = TRUE;
1476 pSIMCmdPrm -> CNUMOutput++;
1477 }
1478
1479 /*
1480 *-----------------------------------------------------------
1481 * process parameter <type>
1482 *-----------------------------------------------------------
1483 */
1484 cmhPHB_toaDmrg ( *( ptr + 1 ),
1485 &CNUMMsisdn[CNUMMsisdnIdx].type );
1486
1487 ptr += 12;
1488
1489 /*
1490 *-----------------------------------------------------------
1491 * invalidate parameter <speed>, <service>, <itc>
1492 *-----------------------------------------------------------
1493 */
1494 CNUMMsisdn[CNUMMsisdnIdx].speed = BS_SPEED_NotPresent;
1495 CNUMMsisdn[CNUMMsisdnIdx].service = CNUM_SERV_NotPresent;
1496 CNUMMsisdn[CNUMMsisdnIdx].itc = CNUM_ITC_NotPresent;
1497
1498 if ( *ptr NEQ 0xFF )
1499 {
1500 /*
1501 *---------------------------------------------------------
1502 * bearer capability EF present
1503 *---------------------------------------------------------
1504 */
1505 if ( cmhSIM_ReqCcp ( ownBuf, *ptr++ ) NEQ AT_EXCT )
1506 {
1507 simEntStat.curCmd = AT_CMD_NONE;
1508 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1509
1510 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
1511 }
1512 }
1513 else
1514 {
1515 /*
1516 *---------------------------------------------------------
1517 * tmpActRec is used to prevent conflicts with global
1518 * variable pSIMCmdPrm -> CNUMActRec
1519 *---------------------------------------------------------
1520 */
1521 tmpActRec = pSIMCmdPrm -> CNUMActRec;
1522
1523 /*
1524 *---------------------------------------------------------
1525 * bearer capability EF abscent
1526 *---------------------------------------------------------
1527 */
1528 /* VO patch 14.03.01 - check vldFlag when it isn't TRUE decrease CNUMMsisdnIdx.
1529 * read the next entry and write the entry in the CNUMMsisdnIdx again */
1530 if ( CNUMMsisdn[CNUMMsisdnIdx].vldFlag EQ FALSE )
1531 CNUMMsisdnIdx--;
1532
1533 if ( CNUMMsisdnIdx EQ MAX_MSISDN - 1 OR
1534 tmpActRec EQ CNUMMaxRec )
1535 {
1536 simEntStat.curCmd = AT_CMD_NONE;
1537 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1538
1539 R_AT( RAT_CNUM, ownBuf ) ( &CNUMMsisdn[0], CNUMMaxRec );
1540
1541 if ( tmpActRec EQ CNUMMaxRec )
1542 {
1543 if (pSIMCmdPrm -> CNUMOutput)
1544 {
1545 R_AT( RAT_OK, ownBuf ) ( cmdBuf );
1546 }
1547 else
1548 {
1549 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_NotFound );
1550 }
1551 }
1552 }
1553 else
1554 {
1555 CNUMMsisdnIdx++;
1556 pSIMCmdPrm -> CNUMActRec++;
1557
1558 if ( cmhSIM_ReqMsisdn
1559 ( ownBuf, pSIMCmdPrm -> CNUMActRec ) NEQ AT_EXCT )
1560 {
1561 simEntStat.curCmd = AT_CMD_NONE;
1562 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1563
1564 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
1565 }
1566 }
1567 }
1568 }
1569
1570 break;
1571 }
1572
1573 default:
1574 {
1575 simEntStat.curCmd = AT_CMD_NONE;
1576 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1577
1578 R_AT( RAT_CME, ownBuf )
1579 (
1580 cmdBuf,
1581 cmhSIM_GetCmeFromSim ( simShrdPrm.atb[table_id].errCode )
1582 );
1583 break;
1584 }
1585
1586 }
1587
1588 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1589 }
1590
1591 /*
1592 +--------------------------------------------------------------------+
1593 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
1594 | STATE : code ROUTINE : cmhSIM_CnfCcp |
1595 +--------------------------------------------------------------------+
1596
1597 PURPOSE : This function handles the confirmation of reading
1598 EF CCP from SIM.
1599 */
1600 GLOBAL void cmhSIM_CnfCcp ( SHORT table_id )
1601 {
1602 T_SIM_CMD_PRM* pSIMCmdPrm; /* points to SIM command parameters */
1603 T_ACI_AT_CMD cmdBuf; /* buffers current command */
1604 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
1605
1606 T_U_CALL_CONF* callCnf; /* call confirm message */
1607 T_bearer_cap* bearCap; /* bearer capability */
1608 UBYTE tmpActRec; /* actual record number */
1609 UBYTE* pExchData; /* points to exchange data buffer */
1610 UBYTE dataLen; /* holds length of data */
1611
1612 TRACE_FUNCTION ("cmhSIM_CnfCcp()");
1613
1614 pSIMCmdPrm = &cmhPrm[simEntStat.entOwn].simCmdPrm;
1615 cmdBuf = simEntStat.curCmd;
1616 ownBuf = simEntStat.entOwn;
1617 dataLen = simShrdPrm.atb[table_id].dataLen;
1618 pExchData = simShrdPrm.atb[table_id].exchData;
1619
1620 switch ( simShrdPrm.atb[table_id].errCode )
1621 {
1622 case ( SIM_NO_ERROR ):
1623 {
1624 /*
1625 *-------------------------------------------------------------
1626 * check basic consistency of read data
1627 *-------------------------------------------------------------
1628 */
1629 if ( pExchData EQ NULL OR
1630 dataLen NEQ ACI_SIZE_EF_CCP )
1631 {
1632 simEntStat.curCmd = AT_CMD_NONE;
1633 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1634
1635 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
1636 }
1637 else
1638 {
1639 /*
1640 *-----------------------------------------------------------
1641 * extracting the relevant data from bearer capability IE
1642 *-----------------------------------------------------------
1643 */
1644 UBYTE bearCapLen = pExchData[0];
1645
1646 if (bearCapLen <= 13 ) /* do not decode empty or invalid entries,
1647 see 11.11/10.5.4.1 max 14 bytes */
1648 {
1649 PALLOC_MSG ( msg, MMCC_DATA_REQ, U_CALL_CONF);
1650
1651 msg -> sdu.l_buf = bearCapLen * 0x08;
1652 msg -> sdu.o_buf = 0x08;
1653 msg -> sdu.buf[0] = 0x83;
1654 msg -> sdu.buf[1] = U_CALL_CONF;
1655
1656 memcpy ( &msg -> sdu.buf[2],
1657 pExchData,
1658 bearCapLen + 1 );
1659
1660 /*
1661 *-----------------------------------------------------------
1662 * use of CCD for decoding of bearer capability
1663 *-----------------------------------------------------------
1664 */
1665 CCD_START;
1666
1667 memset (_decodedMsg, 0, sizeof (_decodedMsg));
1668
1669 if ( ccd_decodeMsg ( CCDENT_CC,
1670 UPLINK,
1671 (T_MSGBUF *) &msg->sdu,
1672 (UBYTE *) _decodedMsg,
1673 NOT_PRESENT_8BIT) EQ ccdOK
1674 AND
1675
1676 _decodedMsg[0] EQ U_CALL_CONF )
1677 {
1678 callCnf = ( T_U_CALL_CONF * )&_decodedMsg[0];
1679
1680 if ( callCnf -> v_bearer_cap )
1681 {
1682 bearCap = &callCnf -> bearer_cap;
1683
1684 /*
1685 *-------------------------------------------------------
1686 * process parameter <speed> of MSISDN
1687 *-------------------------------------------------------
1688 */
1689 if ( bearCap -> v_user_rate )
1690 {
1691 CNUMMsisdn[CNUMMsisdnIdx].speed =
1692 cmhSIM_GetUserRate ( bearCap -> user_rate );
1693 }
1694
1695 /*
1696 *-------------------------------------------------------
1697 * process parameter <itc> and <service> of MSISDN
1698 *-------------------------------------------------------
1699 */
1700 if ( bearCap -> v_trans_cap )
1701 {
1702 CNUMMsisdn[CNUMMsisdnIdx].itc =
1703 cmhSIM_GetItc ( bearCap -> trans_cap );
1704 }
1705
1706 if ( bearCap -> v_user_inf_l2_prot AND
1707 bearCap -> user_inf_l2_prot EQ L2_X25 AND
1708 bearCap -> v_sync_async AND
1709 bearCap -> sync_async EQ SYNCHRONOUS )
1710 {
1711 CNUMMsisdn[CNUMMsisdnIdx].service =
1712 CNUM_SERV_PacketSynch;
1713 }
1714 else if
1715 ( bearCap -> v_sig_access_prot
1716 AND
1717 ( bearCap -> sig_access_prot EQ SIAP_X28_INDIV_NUI OR
1718 bearCap -> sig_access_prot EQ SIAP_X28_UNIV_NUI OR
1719 bearCap -> sig_access_prot EQ SIAP_X28_NON_DEDIC
1720 )
1721 AND
1722 bearCap -> v_sync_async
1723 AND
1724 bearCap -> sync_async EQ ASYNCHRONOUS
1725 )
1726 {
1727 CNUMMsisdn[CNUMMsisdnIdx].service =
1728 CNUM_SERV_PadAsynch;
1729 }
1730 else if ( bearCap -> v_sync_async )
1731 {
1732 CNUMMsisdn[CNUMMsisdnIdx].service =
1733 cmhSIM_GetSrvFromSync ( bearCap -> sync_async );
1734
1735 }
1736 else if ( bearCap -> v_trans_cap )
1737 {
1738 CNUMMsisdn[CNUMMsisdnIdx].service =
1739 cmhSIM_GetSrvFromItc ( bearCap -> trans_cap );
1740 }
1741 }
1742 }
1743 CCD_END;
1744
1745 PFREE ( msg );
1746 }
1747
1748 /*
1749 *-----------------------------------------------------------
1750 * tmpActRec is used to prevent conflicts with global
1751 * variable pSIMCmdPrm -> CNUMActRec
1752 *-----------------------------------------------------------
1753 */
1754 tmpActRec = pSIMCmdPrm -> CNUMActRec;
1755
1756 if ( CNUMMsisdnIdx EQ MAX_MSISDN - 1 OR
1757 tmpActRec EQ CNUMMaxRec )
1758 {
1759 simEntStat.curCmd = AT_CMD_NONE;
1760 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1761
1762 R_AT( RAT_CNUM, ownBuf ) ( &CNUMMsisdn[0], CNUMMaxRec );
1763
1764 if ( tmpActRec EQ CNUMMaxRec )
1765 {
1766 if (pSIMCmdPrm -> CNUMOutput)
1767 {
1768 R_AT( RAT_OK, ownBuf ) ( cmdBuf );
1769 }
1770 else
1771 {
1772 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_NotFound );
1773 }
1774 }
1775 }
1776 else
1777 {
1778 CNUMMsisdnIdx++;
1779 pSIMCmdPrm -> CNUMActRec++;
1780
1781 if ( cmhSIM_ReqMsisdn
1782 ( ownBuf, pSIMCmdPrm -> CNUMActRec ) NEQ AT_EXCT )
1783 {
1784 simEntStat.curCmd = AT_CMD_NONE;
1785 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1786
1787 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
1788 }
1789 }
1790 }
1791
1792 break;
1793 }
1794
1795 default:
1796 {
1797 simEntStat.curCmd = AT_CMD_NONE;
1798 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1799
1800 R_AT( RAT_CME, ownBuf )
1801 (
1802 cmdBuf,
1803 cmhSIM_GetCmeFromSim ( simShrdPrm.atb[table_id].errCode )
1804 );
1805 break;
1806 }
1807
1808 }
1809
1810 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1811 }
1812
1813 /*
1814 +--------------------------------------------------------------------+
1815 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
1816 | STATE : code ROUTINE : cmhSIM_RdCnfPlmnSel|
1817 +--------------------------------------------------------------------+
1818
1819 PURPOSE : This function handles the confirmation of reading
1820 EF PLMN SEL from SIM.
1821 */
1822 GLOBAL void cmhSIM_RdCnfPlmnSel ( SHORT table_id )
1823 {
1824 T_SIM_CMD_PRM * pSIMCmdPrm; /* points to SIM command parameters */
1825 T_ACI_AT_CMD cmdBuf; /* buffers current command */
1826 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
1827 T_ACI_CPOL_LST CPOLPlmnSelLst; /* PLMN SEL list */
1828 T_ACI_RETURN ret;
1829 SHORT lastIdx; /* holds last index */
1830 SHORT usdNtry; /* holds number of used entries */
1831
1832 TRACE_FUNCTION ("cmhSIM_RdCnfPlmnSel()");
1833
1834 pSIMCmdPrm = &cmhPrm[simEntStat.entOwn].simCmdPrm;
1835 cmdBuf = simEntStat.curCmd;
1836 ownBuf = simEntStat.entOwn;
1837
1838
1839 switch ( simShrdPrm.atb[table_id].errCode )
1840 {
1841 case ( SIM_NO_ERROR ):
1842 {
1843 /*
1844 *-------------------------------------------------------------
1845 * check basic consistency of read data
1846 *-------------------------------------------------------------
1847 */
1848 if ( simShrdPrm.atb[table_id].exchData EQ NULL OR
1849 simShrdPrm.atb[table_id].dataLen < ACI_MIN_SIZE_EF_PLMN_SEL)
1850 {
1851 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
1852 simEntStat.curCmd = AT_CMD_NONE;
1853 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1854
1855 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
1856 break;
1857 }
1858
1859 EfPLMNselStat = EF_STAT_READ;
1860 CPOLSimEfDataLen = simShrdPrm.atb[table_id].dataLen;
1861
1862 if( pSIMCmdPrm->CPOLmode EQ CPOL_MOD_CompactList )
1863 {
1864 cmhSIM_CmpctPlmnSel( simShrdPrm.atb[table_id].dataLen,
1865 simShrdPrm.atb[table_id].exchData );
1866 }
1867
1868 /*
1869 *-----------------------------------------------------------
1870 * what is to do ?
1871 *-----------------------------------------------------------
1872 */
1873 switch( pSIMCmdPrm->CPOLact )
1874 {
1875 /*
1876 *-----------------------------------------------------------
1877 * read out PLMN SEL list
1878 *-----------------------------------------------------------
1879 */
1880 case( CPOL_ACT_Read ):
1881
1882 /* fill in buffer */
1883 lastIdx = cmhSIM_FillPlmnSelList(pSIMCmdPrm->CPOLidx,
1884 pSIMCmdPrm->CPOLfrmt,
1885 &CPOLPlmnSelLst[0],
1886 simShrdPrm.atb[table_id].dataLen,
1887 (UBYTE *)simShrdPrm.atb[table_id].exchData);
1888 /* notify about PLMN SEL list */
1889 simEntStat.curCmd = AT_CMD_NONE;
1890 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1891
1892 R_AT( RAT_CPOL, ownBuf ) ( ACI_NumParmNotPresent,
1893 lastIdx,
1894 &CPOLPlmnSelLst[0],
1895 ACI_NumParmNotPresent );
1896
1897 R_AT( RAT_OK, ownBuf )( AT_CMD_CPOL );
1898 break;
1899
1900 /*
1901 *-----------------------------------------------------------
1902 * write PLMN SEL list
1903 *-----------------------------------------------------------
1904 */
1905 case( CPOL_ACT_Write ):
1906
1907 if( pSIMCmdPrm->CPOLidx EQ NOT_PRESENT_8BIT )
1908
1909 ret = cmhSIM_FndEmptyPlmnSel( simEntStat.entOwn,
1910 pSIMCmdPrm->CPOLplmn );
1911 else
1912
1913 ret = cmhSIM_UpdPlmnSel( simEntStat.entOwn,
1914 pSIMCmdPrm->CPOLidx,
1915 pSIMCmdPrm->CPOLplmn,
1916 pSIMCmdPrm->CPOLmode);
1917 if( ret EQ AT_FAIL )
1918 {
1919 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
1920 simEntStat.curCmd = AT_CMD_NONE;
1921 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1922
1923 R_AT( RAT_CME, simEntStat.entOwn )
1924 (
1925 AT_CMD_CPOL,
1926 ACI_ERR_DESC_NR( aciErrDesc )
1927 );
1928 }
1929 break;
1930
1931 /*
1932 *-----------------------------------------------------------
1933 * delete PLMN SEL entry
1934 *-----------------------------------------------------------
1935 */
1936 case( CPOL_ACT_Delete ):
1937
1938 if( pSIMCmdPrm->CPOLidx2 EQ NOT_PRESENT_8BIT )
1939
1940 ret = cmhSIM_DelPlmnSel( simEntStat.entOwn,
1941 pSIMCmdPrm->CPOLidx,
1942 pSIMCmdPrm->CPOLmode );
1943 else
1944
1945 ret = cmhSIM_ChgPlmnSel( simEntStat.entOwn,
1946 pSIMCmdPrm->CPOLidx,
1947 pSIMCmdPrm->CPOLidx2 );
1948
1949 if( ret EQ AT_FAIL )
1950 {
1951 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
1952 simEntStat.curCmd = AT_CMD_NONE;
1953 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1954
1955 R_AT( RAT_CME, simEntStat.entOwn )
1956 (
1957 AT_CMD_CPOL,
1958 ACI_ERR_DESC_NR( aciErrDesc )
1959 );
1960 }
1961 break;
1962
1963 /*
1964 *-----------------------------------------------------------
1965 * test PLMN SEL entry number
1966 *-----------------------------------------------------------
1967 */
1968 case( CPOL_ACT_Test ):
1969
1970 /* notify about PLMN SEL entry number */
1971 simEntStat.curCmd = AT_CMD_NONE;
1972 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1973
1974 lastIdx = CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY;
1975 usdNtry = cmhSIM_UsdPlmnSelNtry( CPOLSimEfDataLen,
1976 (UBYTE *)simShrdPrm.atb[table_id].exchData );
1977
1978 R_AT( RAT_CPOL, ownBuf ) ( ACI_NumParmNotPresent,
1979 lastIdx,
1980 NULL,
1981 usdNtry );
1982
1983 R_AT( RAT_OK, ownBuf )( AT_CMD_CPOL );
1984 break;
1985 }
1986 break;
1987 }
1988
1989 case ( SIM_CAUSE_UNKN_FILE_ID ):
1990 EfPLMNselStat = EF_STAT_NOT_AVAIL;
1991 /*lint -fallthrough*/
1992 /*lint -fallthrough*/
1993 default:
1994 {
1995 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
1996 simEntStat.curCmd = AT_CMD_NONE;
1997 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
1998
1999 R_AT( RAT_CME, ownBuf )
2000 (
2001 cmdBuf,
2002 cmhSIM_GetCmeFromSim ( simShrdPrm.atb[table_id].errCode )
2003 );
2004 break;
2005 }
2006
2007 }
2008
2009 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2010
2011 }
2012
2013 /*
2014 +--------------------------------------------------------------------+
2015 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2016 | STATE : code ROUTINE : cmhSIM_WrCnfPlmnSel|
2017 +--------------------------------------------------------------------+
2018
2019 PURPOSE : This function handles the confirmation of writing
2020 EF PLMN SEL to SIM.
2021 */
2022 GLOBAL void cmhSIM_WrCnfPlmnSel ( SHORT table_id )
2023 {
2024 T_SIM_CMD_PRM * pSIMCmdPrm; /* points to SIM command parameters */
2025 UBYTE ownBuf;
2026
2027 TRACE_FUNCTION ("cmhSIM_WrCnfPlmnSel()");
2028
2029 pSIMCmdPrm = &cmhPrm[simEntStat.entOwn].simCmdPrm;
2030 ownBuf = simEntStat.entOwn;
2031
2032 switch ( simShrdPrm.atb[table_id].errCode )
2033 {
2034 /* successful PLMN SEL list update */
2035 case ( SIM_NO_ERROR ):
2036 {
2037 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
2038 simEntStat.curCmd = AT_CMD_NONE;
2039 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2040
2041 R_AT( RAT_OK, ownBuf )( AT_CMD_CPOL );
2042 break;
2043 }
2044 case SIM_CAUSE_ACCESS_PROHIBIT:
2045 {
2046 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
2047 simEntStat.curCmd = AT_CMD_NONE;
2048 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2049
2050 R_AT( RAT_CME, ownBuf /*simEntStat.entOwn*/ )
2051 (
2052 AT_CMD_CPOL,
2053 CME_ERR_OpNotAllow
2054 );
2055 break;
2056 }
2057
2058 /* unsuccessful PLMN SEL list update */
2059 default:
2060 {
2061 pSIMCmdPrm->CPOLact = CPOL_ACT_None;
2062 simEntStat.curCmd = AT_CMD_NONE;
2063 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2064
2065 R_AT( RAT_CME, ownBuf /*simEntStat.entOwn*/ )
2066 (
2067 AT_CMD_CPOL,
2068 cmhSIM_GetCmeFromSim ( simShrdPrm.atb[table_id].errCode )
2069 );
2070 break;
2071 }
2072 }
2073
2074 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2075 }
2076
2077 /*
2078 +--------------------------------------------------------------------+
2079 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2080 | STATE : code ROUTINE : cmhSIM_RdCnfLangELP|
2081 +--------------------------------------------------------------------+
2082
2083 PURPOSE : This function handles the confirmation of reading
2084 from the SIM (EF ELP).
2085 */
2086 GLOBAL void cmhSIM_RdCnfLangELP ( SHORT table_id )
2087 {
2088 T_SIM_CMD_PRM *pSIMCmdPrm; /* points to SIM command parameters */
2089 T_PHB_CMD_PRM *pPHBCmdPrm; /* points to PHB command parameter */
2090
2091 T_ACI_AT_CMD cmdBuf; /* buffers current command */
2092 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
2093 CHAR Clang_buffer[3]={0};/* Current language */
2094 T_ACI_LAN_SUP clng;
2095 CHAR *ef = EF_CLNG_ID;
2096 EF_CLNG lng;
2097 BOOL Suplng = FALSE;
2098 T_ACI_LAN_SUP LngPCMsupLst[MAX_LAN];
2099 SHORT lastIdx;
2100 T_ACI_RETURN ret ;
2101
2102 TRACE_FUNCTION ("cmhSIM_RdCnfLangELP()");
2103
2104 pSIMCmdPrm = &cmhPrm[simEntStat.entOwn].simCmdPrm;
2105 cmdBuf = simEntStat.curCmd;
2106 ownBuf = simEntStat.entOwn;
2107 pPHBCmdPrm = &cmhPrm[ownBuf].phbCmdPrm;
2108 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2109 simEntStat.curCmd = AT_CMD_NONE;
2110
2111 clng.str = Clang_buffer;
2112
2113 switch ( simShrdPrm.atb[table_id].errCode )
2114 {
2115 case ( SIM_NO_ERROR ):
2116 /*
2117 *-------------------------------------------------------------
2118 * check basic consistency of read data
2119 *-------------------------------------------------------------
2120 */
2121 if ( simShrdPrm.atb[table_id].exchData EQ NULL OR
2122 simShrdPrm.atb[table_id].dataLen < ACI_MIN_SIZE_EF_LAN)
2123
2124 {
2125 pSIMCmdPrm->CLANact = CLAN_ACT_None;
2126 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2127
2128 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
2129 return;
2130 }
2131
2132 memcpy(clng.str, (UBYTE *)simShrdPrm.atb[table_id].exchData, CLAN_CODE_LEN);
2133 ret=getSupLangFromPCM(&LngPCMsupLst[0], &lastIdx);
2134 if (ret EQ AT_FAIL)
2135 {
2136 return;
2137 }
2138 Suplng=checkSuppLang(&LngPCMsupLst[0],lastIdx, &clng);
2139
2140 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2141
2142 /*
2143 *---------------------------------------------------------------------
2144 * check if the language,which was read from EF ELP is supported in PCM
2145 *---------------------------------------------------------------------
2146 */
2147 if(Suplng)
2148 {
2149 switch( pSIMCmdPrm->CLANact )
2150 {
2151 case( CLAN_ACT_Read ):
2152 R_AT( RAT_CLAN, ownBuf ) (&clng);
2153 R_AT( RAT_OK, ownBuf )( AT_CMD_CLAN );
2154 break;
2155 case( CLAN_ACT_Write ):
2156 memcpy(lng.data,clng.str ,CLAN_CODE_LEN);
2157 pcm_WriteFile (( UBYTE* )ef,SIZE_EF_CLNG,( UBYTE*) &lng);
2158
2159 if (pPHBCmdPrm->CLAEmode EQ CLAE_MOD_Enable)
2160 R_AT( RAT_CLAE, ownBuf ) (&clng);
2161
2162 R_AT( RAT_OK, ownBuf )( AT_CMD_CLAN );
2163 break;
2164 }
2165 }
2166 else
2167 /*
2168 *-------------------------------------------------------------
2169 * read the EF LP if the language is not supported in PCM
2170 *-------------------------------------------------------------
2171 */
2172 cmhSIM_ReqLanguageLP (ownBuf );
2173 break;
2174
2175 /*
2176 *-------------------------------------------------------------
2177 * read the EF LP if the EF ELP not available
2178 *-------------------------------------------------------------
2179 */
2180 case ( SIM_CAUSE_UNKN_FILE_ID ):
2181 cmhSIM_ReqLanguageLP (ownBuf );
2182 break;
2183
2184 default:
2185 pSIMCmdPrm->CLANact = CLAN_ACT_None;
2186 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2187
2188 R_AT( RAT_CME, ownBuf) ( AT_CMD_CLAN, CME_ERR_Unknown );
2189 break;
2190
2191 }
2192
2193 }
2194
2195
2196 /*
2197 +------------------------------------------------------------------------+
2198 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2199 | STATE : code ROUTINE : cmhSIM_RdCnfLangPrfELP |
2200 +------------------------------------------------------------------------+
2201
2202 PURPOSE : This function handles the confirmation of reading
2203 from the SIM (EF ELP) for SAT feature LS.
2204 */
2205 GLOBAL void cmhSIM_RdCnfLangPrfELP ( SHORT table_id )
2206 {
2207
2208 T_ACI_SAT_TERM_RESP resp_data;
2209 CHAR Clang_buffer[3]={0};/* Current language */
2210 T_ACI_LAN_SUP clng;
2211 BOOL Suplng = FALSE;
2212 T_ACI_LAN_SUP LngPCMsupLst[MAX_LAN];
2213 SHORT lastIdx;
2214 T_ACI_RETURN ret ;
2215
2216
2217 TRACE_FUNCTION ("cmhSIM_RdCnfLangPrfELP()");
2218
2219 psaSAT_InitTrmResp( &resp_data );
2220
2221 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2222
2223 clng.str = Clang_buffer;
2224
2225 switch ( simShrdPrm.atb[table_id].errCode )
2226 {
2227 case ( SIM_NO_ERROR ):
2228 /*
2229 *-------------------------------------------------------------
2230 * check basic consistency of read data
2231 *-------------------------------------------------------------
2232 */
2233 if ( simShrdPrm.atb[table_id].exchData EQ NULL OR
2234 simShrdPrm.atb[table_id].dataLen < ACI_MIN_SIZE_EF_LAN)
2235
2236 {
2237 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2238 return;
2239 }
2240
2241 memcpy(clng.str, (UBYTE *)simShrdPrm.atb[table_id].exchData, CLAN_CODE_LEN);
2242 ret=getSupLangFromPCM(&LngPCMsupLst[0], &lastIdx);
2243 if (ret EQ AT_FAIL)
2244 {
2245 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2246 return;
2247 }
2248
2249 Suplng=checkSuppLang(&LngPCMsupLst[0],lastIdx, &clng);
2250
2251
2252 /*
2253 *---------------------------------------------------------------------
2254 * check if the language,which was read from EF ELP is supported in PCM
2255 *---------------------------------------------------------------------
2256 */
2257 if(Suplng)
2258 {
2259 /* Send Terminal resp*/
2260 memcpy(&resp_data.lang, (UBYTE *)simShrdPrm.atb[table_id].exchData, CLAN_CODE_LEN);
2261
2262 #ifdef _SIMULATION_
2263 memset(resp_data.lang, 0xA0, 2);
2264 #endif
2265
2266 psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
2267
2268 }
2269 else
2270 {
2271 /*
2272 *-------------------------------------------------------------
2273 * read the EF LP if the language is not supported in PCM
2274 *-------------------------------------------------------------
2275 */
2276 if (cmhSIM_ReqLanguagePrfLP () EQ FALSE)
2277 {
2278 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2279 }
2280 }
2281 break;
2282
2283 /*
2284 *-------------------------------------------------------------
2285 * read the EF LP if the EF ELP not available
2286 *-------------------------------------------------------------
2287 */
2288 case ( SIM_CAUSE_UNKN_FILE_ID ):
2289 if (cmhSIM_ReqLanguagePrfLP () EQ FALSE)
2290 {
2291 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2292 }
2293 break;
2294
2295 default:
2296 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2297 break;
2298
2299 }
2300 }
2301
2302
2303 /*
2304 +--------------------------------------------------------------------+
2305 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2306 | STATE : code ROUTINE : cmhSIM_RdCnfLangLP |
2307 +--------------------------------------------------------------------+
2308
2309 PURPOSE : This function handles the confirmation of reading
2310 EF LP from SIM.
2311 */
2312 GLOBAL void cmhSIM_RdCnfLangLP ( SHORT table_id )
2313 {
2314 T_SIM_CMD_PRM * pSIMCmdPrm; /* points to SIM command parameters */
2315 T_PHB_CMD_PRM * pPHBCmdPrm; /* points to PHB command parameter */
2316 T_ACI_AT_CMD cmdBuf; /* buffers current command */
2317 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
2318 T_ACI_LAN_SUP clng;
2319 CHAR* ef = EF_CLNG_ID;
2320 EF_CLNG lng;
2321 BOOL Suplng= FALSE;
2322 SHORT lastIdx;
2323 T_ACI_LAN_SUP LngPCMsupLst[MAX_LAN];
2324
2325
2326 TRACE_FUNCTION ("cmhSIM_RdCnfLangLP()");
2327
2328 pSIMCmdPrm = &cmhPrm[simEntStat.entOwn].simCmdPrm;
2329 cmdBuf = simEntStat.curCmd;
2330 ownBuf = simEntStat.entOwn;
2331 pPHBCmdPrm = &cmhPrm[ownBuf].phbCmdPrm;
2332 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2333 simEntStat.curCmd = AT_CMD_NONE;
2334
2335 clng.lng=(UBYTE )simShrdPrm.atb[table_id].exchData[0];
2336
2337 getSupLangFromPCM(&LngPCMsupLst[0], &lastIdx);
2338 Suplng=checkSuppLangInLP(&LngPCMsupLst[0],lastIdx, &clng);
2339
2340 if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR AND
2341 Suplng )
2342 {
2343
2344 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2345 /*
2346 *-------------------------------------------------------------
2347 * check basic consistency of read data
2348 *-------------------------------------------------------------
2349 */
2350 if ( simShrdPrm.atb[table_id].exchData EQ NULL OR
2351 simShrdPrm.atb[table_id].dataLen < ACI_LEN_LAN_LP_NTRY)
2352
2353 {
2354 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2355 pSIMCmdPrm->CLANact = CLAN_ACT_None;
2356 R_AT( RAT_CME, ownBuf ) ( cmdBuf, CME_ERR_Unknown );
2357 return;
2358 }
2359
2360 #ifdef SIM_TOOLKIT
2361 if (simShrdPrm.fuRef >= 0)
2362 {
2363 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCCESS);
2364 }
2365 #endif
2366
2367 /*
2368 *-----------------------------------------------------
2369 * read the supported laguage or write it PCM
2370 *-----------------------------------------------------
2371 */
2372 switch( pSIMCmdPrm->CLANact )
2373 {
2374 case( CLAN_ACT_Read ):
2375 R_AT( RAT_CLAN, ownBuf ) (&clng);
2376 R_AT( RAT_OK, ownBuf )( AT_CMD_CLAN );
2377 break;
2378 case( CLAN_ACT_Write ):
2379 memcpy(lng.data,(UBYTE *) clng.str,CLAN_CODE_LEN);
2380 pcm_WriteFile (( UBYTE* )ef,SIZE_EF_CLNG,( UBYTE*) &lng);
2381 if (pPHBCmdPrm->CLAEmode EQ CLAE_MOD_Enable)
2382 { R_AT( RAT_CLAE, ownBuf ) (&clng);}
2383
2384 R_AT( RAT_OK, ownBuf )( AT_CMD_CLAN );
2385 break;
2386
2387 }
2388 }
2389 else
2390 {
2391
2392 #ifdef SIM_TOOLKIT
2393 if (simShrdPrm.fuRef >= 0)
2394 {
2395 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR);
2396 }
2397 #endif
2398 /*
2399 *---------------------------------------------------------------
2400 * Preferred language is not supported in MS
2401 *---------------------------------------------------------------
2402 */
2403 if ( simShrdPrm.atb[table_id].errCode EQ SIM_CAUSE_UNKN_FILE_ID OR
2404 !Suplng )
2405 {
2406 TRACE_FUNCTION ("preferred language not supported");
2407
2408 switch( pSIMCmdPrm->CLANact )
2409 {
2410 case( CLAN_ACT_Read ):
2411 R_AT( RAT_CLAN, ownBuf ) (&LngPCMsupLst[0]);
2412 R_AT( RAT_OK, ownBuf )( AT_CMD_CLAN );
2413 break;
2414 case( CLAN_ACT_Write ): /* Preferred Language not supported,so not change CLAN */
2415 R_AT( RAT_OK, ownBuf )( AT_CMD_CLAN );
2416 break;
2417 }
2418 }
2419 else
2420 {
2421 pSIMCmdPrm->CLANact = CLAN_ACT_None;
2422 simEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
2423 R_AT( RAT_CME, ownBuf) ( AT_CMD_CLAN, CME_ERR_Unknown );
2424 }
2425 }
2426 }
2427
2428
2429 /*
2430 +-----------------------------------------------------------------------+
2431 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2432 | STATE : code ROUTINE : cmhSIM_RdCnfLangPrfLP |
2433 +-----------------------------------------------------------------------+
2434
2435 PURPOSE : This function handles the confirmation of reading
2436 EF LP from SIM for SAT feature LS.
2437 */
2438 GLOBAL void cmhSIM_RdCnfLangPrfLP ( SHORT table_id )
2439 {
2440
2441 T_ACI_SAT_TERM_RESP resp_data;
2442 T_ACI_LAN_SUP clng;
2443 BOOL Suplng= FALSE;
2444 SHORT lastIdx;
2445 T_ACI_LAN_SUP lngPCMsupLst[MAX_LAN];
2446 T_ACI_RETURN ret;
2447
2448 TRACE_FUNCTION ("cmhSIM_RdCnfLangPrfLP()");
2449
2450 psaSAT_InitTrmResp( &resp_data );
2451
2452 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2453
2454 clng.lng=(UBYTE )simShrdPrm.atb[table_id].exchData[0];
2455 ret = getSupLangFromPCM(&lngPCMsupLst[0], &lastIdx);
2456 if(ret EQ AT_FAIL)
2457 {
2458 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2459 return;
2460 }
2461
2462 Suplng=checkSuppLangInLP(&lngPCMsupLst[0],lastIdx, &clng);
2463
2464 if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR AND
2465 Suplng )
2466 {
2467
2468
2469 /*
2470 *-------------------------------------------------------------
2471 * check basic consistency of read data
2472 *-------------------------------------------------------------
2473 */
2474 if ( simShrdPrm.atb[table_id].exchData EQ NULL OR
2475 simShrdPrm.atb[table_id].dataLen < ACI_LEN_LAN_LP_NTRY)
2476
2477 {
2478 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2479 return;
2480 }
2481
2482
2483 #ifdef SIM_TOOLKIT
2484 if (simShrdPrm.fuRef >= 0)
2485 {
2486 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCCESS);
2487 }
2488 #endif
2489
2490 /*
2491 *-----------------------------------------------------
2492 * Send the Terminal Response
2493 *-----------------------------------------------------
2494 */
2495 memcpy(&resp_data.lang, (UBYTE* )simShrdPrm.atb[table_id].exchData, CLAN_CODE_LEN);
2496 #ifdef _SIMULATION_
2497 memset(resp_data.lang, 0xA0, 2);
2498 #endif
2499 psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
2500 }
2501 else
2502 {
2503
2504 #ifdef SIM_TOOLKIT
2505 if (simShrdPrm.fuRef >= 0)
2506 {
2507 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR);
2508 }
2509 #endif
2510 /*
2511 *---------------------------------------------------------------
2512 * read default language from ME
2513 *---------------------------------------------------------------
2514 */
2515
2516 if ( simShrdPrm.atb[table_id].errCode EQ SIM_CAUSE_UNKN_FILE_ID OR
2517 !Suplng )
2518 {
2519 TRACE_FUNCTION ("default language is selected");
2520 memcpy(&resp_data.lang, &lngPCMsupLst[0].str, CLAN_CODE_LEN);
2521 #ifdef _SIMULATION_
2522 memset(resp_data.lang, 0xA0, 2);
2523 #endif
2524 psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
2525
2526 }
2527 else
2528 {
2529 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
2530 }
2531
2532 }
2533
2534 }
2535
2536
2537 /*
2538 +--------------------------------------------------------------------------+
2539 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2540 | STATE : code ROUTINE : SIM_ENT_CSDconnect_dti_cb |
2541 +--------------------------------------------------------------------------+
2542
2543 PURPOSE : Callback for connection between SIM and TRA/L2R for CSD.
2544
2545 */
2546 #ifdef FF_SAT_E
2547 #ifdef DTI
2548 GLOBAL BOOL SIM_ENT_CSDconnect_dti_cb(UBYTE dti_id, T_DTI_CONN_STATE result_type)
2549 {
2550 TRACE_FUNCTION("SIM_ENT_CSDconnect_dti_cb");
2551
2552 switch( result_type)
2553 {
2554 case DTI_CONN_STATE_DISCONNECTING:
2555 break;
2556 case DTI_CONN_STATE_DISCONNECTED:
2557 /* wap_state is set to IPA_Deactivated in psaTCPIP_config_dispatch() */
2558 if (wap_state EQ UDPA_Deactivation)
2559 {
2560 wap_state = IPA_Deactivation;
2561 psaUDPIP_config_dispatch();
2562 }
2563 dti_cntrl_erase_entry(dti_id);
2564 dti_cntrl_clear_conn_parms(dti_id);
2565 if (simShrdPrm.sat_class_e_dti_id EQ dti_id)
2566 {
2567 simShrdPrm.sat_class_e_dti_id = DTI_DTI_ID_NOTPRESENT;
2568 TRACE_EVENT("sat_class_e_dti_id reset");
2569 }
2570 break;
2571 case DTI_CONN_STATE_CONNECTING:
2572 break;
2573 case DTI_CONN_STATE_CONNECTED:
2574 /* the SIM-SNDCP connection has been established, now send SIM_BIP_CONFIG
2575 * request to SIM */
2576 psaSIM_Bip_Config_Req();
2577
2578 break;
2579 case DTI_CONN_STATE_ERROR:
2580 /* connection not possible: disconnect UDP, L2R or TRA */
2581 TRACE_EVENT("SIM_ENT_CSDconnect_dti_cb connection not possible: disconnect UDP,L2R or TRA");
2582 dti_cntrl_close_dpath_from_dti_id( dti_id );
2583 break;
2584 case DTI_CONN_STATE_UNKNOWN:
2585 default:
2586 TRACE_EVENT("SIM_ENT_CSDconnect_dti_cb call with not awaited value");
2587 break;
2588 }
2589 return TRUE;
2590 }
2591 #endif /* DTI */
2592
2593 #if defined (GPRS) AND defined (DTI)
2594 /*
2595 +---------------------------------------------------------------------------+
2596 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2597 | STATE : code ROUTINE : SIM_SNDCP_connect_dti_cb |
2598 +---------------------------------------------------------------------------+
2599
2600 PURPOSE : Callback for connection between SIM and SNDCP.
2601
2602 */
2603 GLOBAL BOOL SIM_SNDCP_connect_dti_cb(UBYTE dti_id, T_DTI_CONN_STATE result_type)
2604 {
2605 TRACE_FUNCTION("SIM_SNDCP_connect_dti_cb");
2606
2607 switch( result_type)
2608 {
2609 case DTI_CONN_STATE_DISCONNECTING:
2610 break;
2611 case DTI_CONN_STATE_DISCONNECTED:
2612 dti_cntrl_erase_entry(dti_id);
2613 if (simShrdPrm.sat_class_e_dti_id EQ dti_id)
2614 {
2615 simShrdPrm.sat_class_e_dti_id = DTI_DTI_ID_NOTPRESENT;
2616 TRACE_EVENT("sat_class_e_dti_id reset");
2617 }
2618 break;
2619 case DTI_CONN_STATE_CONNECTING:
2620 break;
2621 case DTI_CONN_STATE_CONNECTED:
2622 /* the SIM-SNDCP connection has been established, now send SIM_BIP_CONFIG
2623 * request to SIM */
2624 psaSIM_Bip_Config_Req();
2625 break;
2626 case DTI_CONN_STATE_ERROR:
2627 /* connection not possible: disconnect SNDCP */
2628 dti_cntrl_close_dpath_from_dti_id( dti_id );
2629 break;
2630 case DTI_CONN_STATE_UNKNOWN:
2631 default:
2632 TRACE_EVENT("SIM_SNDCP_connect_dti_cb call with not awaited value");
2633 break;
2634 }
2635 return TRUE;
2636 }
2637
2638
2639 /*
2640 +--------------------------------------------------------------------------+
2641 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMR |
2642 | STATE : code ROUTINE : SIM_ENT_GPRSconnect_dti_cb|
2643 +--------------------------------------------------------------------------+
2644
2645 PURPOSE : Callback for connection between SIM and UDP/SNDCP for GPRS.
2646
2647 */
2648
2649 GLOBAL BOOL SIM_ENT_GPRSconnect_dti_cb(UBYTE dti_id, T_DTI_CONN_STATE result_type)
2650 {
2651 TRACE_FUNCTION("SIM_ENT_GPRSconnect_dti_cb");
2652
2653 switch( result_type)
2654 {
2655 case DTI_CONN_STATE_DISCONNECTING:
2656 break;
2657 case DTI_CONN_STATE_DISCONNECTED:
2658 dti_cntrl_erase_entry(dti_id);
2659 if (simShrdPrm.sat_class_e_dti_id EQ dti_id)
2660 {
2661 simShrdPrm.sat_class_e_dti_id = DTI_DTI_ID_NOTPRESENT;
2662 TRACE_EVENT("sat_class_e_dti_id reset");
2663 }
2664 break;
2665 case DTI_CONN_STATE_CONNECTING:
2666 case DTI_CONN_STATE_CONNECTED:
2667 break;
2668 case DTI_CONN_STATE_ERROR:
2669 /* connection not possible: disconnect UDP or SNDCP */
2670 TRACE_EVENT("SIM_ENT_GPRSconnect_dti_cb connection not possible: disconnect UDP or SNDCP");
2671 dti_cntrl_close_dpath_from_dti_id( dti_id );
2672 break;
2673 case DTI_CONN_STATE_UNKNOWN:
2674 default:
2675 TRACE_EVENT("SIM_ENT_GPRSconnect_dti_cb call with not awaited value");
2676 break;
2677 }
2678 return TRUE;
2679 }
2680
2681 #endif /* GPRS */
2682
2683 #endif /* FF_SAT_E */
2684
2685 #ifdef FF_DUAL_SIM
2686
2687 /*
2688 +-------------------------------------------------------------------+
2689 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMR |
2690 | ROUTINE : cmhSIM_SIMSelected |
2691 +-------------------------------------------------------------------+
2692
2693 PURPOSE : Informs the upper layer the result of the SIM Selection process.
2694
2695 */
2696 GLOBAL void cmhSIM_SIMSelected ( void )
2697 {
2698 UBYTE cmdBuf;
2699 T_ACI_CME_ERR err;
2700
2701 TRACE_FUNCTION("cmhSIM_SIMSelected()");
2702
2703 switch(simEntStat.curCmd)
2704 {
2705 case(AT_CMD_SIM):
2706
2707 switch( simShrdPrm.rslt )
2708 {
2709 case( SIM_NO_ERROR ):
2710
2711 simEntStat.curCmd = AT_CMD_NONE;
2712
2713 R_AT( RAT_OK, simEntStat.entOwn )
2714 ( AT_CMD_SIM );
2715 cmh_logRslt ( simEntStat.entOwn, RAT_OK, AT_CMD_SIM, -1, -1, -1 );
2716 return;
2717
2718 default:
2719 err = cmhSIM_GetCmeFromSim ( simShrdPrm.rslt );
2720 break;
2721 }
2722
2723 cmdBuf = simEntStat.curCmd;
2724 simEntStat.curCmd = AT_CMD_NONE;
2725
2726 R_AT( RAT_CME, simEntStat.entOwn )
2727 ( cmdBuf, err );
2728 cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf,
2729 -1, -1, err );
2730 break;
2731 }
2732 }
2733 #endif /*FF_DUAL_SIM*/
2734
2735 /*==== EOF ========================================================*/
2736