FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/cmh_sims.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 : CMH_SIMS
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 provides the set functions related to the
18 | protocol stack adapter for the subscriber identity
19 | module.
20 +-----------------------------------------------------------------------------
21 */
22
23 #ifndef CMH_SIMS_C
24 #define CMH_SIMS_C
25 #endif
26
27 #include "config.h"
28 #include "fixedconf.h"
29 #include "condat-features.h"
30 #include "aci_conf.h"
31
32 #include "aci_all.h"
33 /*==== INCLUDES ===================================================*/
34 #include "aci_cmh.h"
35
36 #ifdef UART
37 #include "dti.h" /* functionality of the dti library */
38 #include "dti.h"
39 #include "dti_conn_mng.h"
40 #endif
41
42 #include "ati_cmd.h"
43
44 #ifdef FF_ATI
45 #include "aci_io.h"
46 #endif /* of #ifdef FF_ATI */
47
48 #ifdef FAX_AND_DATA
49 #include "aci_fd.h"
50 #endif /* of #ifdef FAX_AND_DATA */
51
52 #include "psa.h"
53 #include "psa_sim.h"
54 #include "psa_mm.h"
55 #include "cmh.h"
56 #include "cmh_sim.h"
57 #include "cmh_mm.h"
58
59 #ifdef GPRS
60 #include "dti_cntrl_mng.h"
61 #include "gaci.h"
62 #include "gaci_cmh.h"
63 #include "psa_gmm.h"
64 #include "cmh_gmm.h"
65 #endif
66
67 #include "aci.h"
68
69 /* #include "m_fac.h" */
70 #include "aoc.h"
71 #include "ati_cmd.h"
72 #include "aci_cmd.h"
73 #include "phb.h"
74
75 #include "aci_ext_pers.h"
76 #include "aci_slock.h"
77
78 #include "cl_imei.h"
79
80
81 #ifdef SIM_PERS
82 #include "general.h" // included for compilation error UNIT8 in sec_drv.h
83 #include "sec_drv.h"
84 #include "cmh.h"
85 #include "aci_cmh.h"
86
87 EXTERN T_SIM_MMI_INSERT_IND *last_sim_mmi_insert_ind;
88 EXTERN T_SEC_DRV_CATEGORY *personalisation_nw;
89 EXTERN T_SEC_DRV_CATEGORY *personalisation_ns;
90 EXTERN T_SEC_DRV_CATEGORY *personalisation_sp;
91 EXTERN T_SEC_DRV_CATEGORY *personalisation_cp;
92 EXTERN T_SEC_DRV_CATEGORY *personalisation_sim;
93 EXTERN T_SEC_DRV_CONFIGURATION *cfg_data ;
94 #endif
95
96 /*==== CONSTANTS ==================================================*/
97
98 /*==== EXPORT =====================================================*/
99
100 /*==== VARIABLES ==================================================*/
101
102 /*==== FUNCTIONS ==================================================*/
103 LOCAL T_ACI_RETURN cmhSIM_analyze_SIMLOCK_STATUS( T_SIMLOCK_STATUS status );
104 LOCAL T_ACI_RETURN sAT_Plus_CAMM_CACM ( T_ACI_AT_CMD at_cmd_id,
105 T_ACI_CMD_SRC srcId,
106 UBYTE value_type,
107 void *value,
108 UBYTE *pwd );
109 /*
110 +--------------------------------------------------------------------+
111 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
112 | STATE : code ROUTINE : sAT_PlusCFUN |
113 +--------------------------------------------------------------------+
114
115 PURPOSE : This is the functional counterpart to the +CFUN AT command
116 which is responsible to set the phone functionality.
117
118 <fun>: defines the level of functionality to switch to.
119 <rst>: reset mode
120 */
121
122 GLOBAL T_ACI_RETURN sAT_PlusCFUN ( T_ACI_CMD_SRC srcId,
123 T_ACI_CFUN_FUN fun,
124 T_ACI_CFUN_RST rst )
125 {
126 T_SIM_SET_PRM * pSIMSetPrm; /* points to MM parameter set */
127 T_ACI_RETURN retCd; /* holds return code */
128 UBYTE idx; /* holds index value */
129
130 /* variables for IMEI control mechanism */
131 #ifndef _SIMULATION_
132 BYTE retVal; /* holds return value */
133 UBYTE dummyIMEIBuf[CL_IMEI_SIZE]; /* dummy IMEI buffer */
134 #endif /* if NOT defined windows simulation */
135
136 TRACE_FUNCTION ("sAT_PlusCFUN()");
137
138 #ifndef _SIMULATION_
139 /*
140 *-------------------------------------------------------------------
141 * check IMEI
142 *-------------------------------------------------------------------
143 */
144
145 retVal = cl_get_imeisv(CL_IMEI_SIZE, dummyIMEIBuf, CL_IMEI_CONTROL_IMEI);
146
147 if( retVal NEQ CL_IMEI_OK )
148 {
149 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_IMEICheck );
150 TRACE_EVENT("IMEI not valid");
151 simShrdPrm.imei_blocked = TRUE;
152 /*return( AT_FAIL ); We dont return here to enable the stack to go to the state of "Limited Service' to enable emergency calls. */
153 }
154 #endif /* if NOT defined windows simulation */
155
156 /*
157 *-------------------------------------------------------------------
158 * check command source
159 *-------------------------------------------------------------------
160 */
161 if(!cmh_IsVldCmdSrc (srcId))
162 {
163 return( AT_FAIL );
164 }
165
166 pSIMSetPrm = &simShrdPrm.setPrm[srcId];
167
168 /*
169 *-------------------------------------------------------------------
170 * check entity status
171 *-------------------------------------------------------------------
172 */
173 if( simEntStat.curCmd NEQ AT_CMD_NONE )
174 {
175 TRACE_EVENT("Entity SIM is busy: cannot proceed command...");
176 return( AT_BUSY );
177 }
178
179 /*
180 *-------------------------------------------------------------------
181 * process the <rst> parameter
182 *-------------------------------------------------------------------
183 */
184 switch( rst )
185 {
186 case( CFUN_RST_NotPresent ): /* default value */
187 case( CFUN_RST_NoReset ):
188
189 break;
190
191 default: /* unexpected parameter */
192 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
193 return( AT_FAIL );
194 }
195
196 /*
197 *-------------------------------------------------------------------
198 * process the <fun> parameter
199 *-------------------------------------------------------------------
200 */
201 if( fun EQ CFUN_FUN_NotPresent ) fun = CFUNfun;
202
203 switch( fun )
204 {
205 case( CFUN_FUN_Minimum ): /* set ME to minimum functionality */
206 CFUNfun = fun;
207 simEntStat.curCmd = AT_CMD_CFUN;
208 simShrdPrm.owner = (T_OWN)srcId;
209 simEntStat.entOwn = srcId;
210
211 /* Turn off all possible ringing */
212 #ifdef FF_ATI
213 io_setRngInd ( IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
214 #endif
215 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
216 {
217 R_AT( RAT_CRING_OFF, (T_ACI_CMD_SRC)idx )( 0 ); /* Turn of all ringing */
218 }
219
220
221 /* We have to wait for both entities to finish in CFUN. So both EntStat are set to AT_CMD_CFUN and
222 when a certain entity finished it also emits AT_OK if the other entity has already finished */
223
224 simEntStat.curCmd = AT_CMD_CFUN;
225 simShrdPrm.owner = (T_OWN)srcId;
226 simEntStat.entOwn = srcId;
227
228 mmEntStat.curCmd = AT_CMD_CFUN;
229 mmShrdPrm.owner = (T_OWN)srcId;
230 mmEntStat.entOwn = srcId;
231
232 pb_exit();
233
234 /* simShrdPrm.synCs = SYNC_DEACTIVATE; */ /* This is moved to pb_exit */
235 /* psaSIM_SyncSIM(); */
236
237 /* Reset ONSDesc */
238 cmhMM_Reset_ONSDesc();
239
240
241 #if defined (GPRS) AND defined (DTI)
242 mmShrdPrm.nrgCs = GMMREG_DT_POWER_OFF;
243 if( psaG_MM_CMD_DEREG ( mmShrdPrm.nrgCs ) < 0 ) /* deregister from network */
244 #else
245 mmShrdPrm.nrgCs = CS_POW_OFF;
246 if( psaMM_DeRegistrate () < 0 ) /* deregister from network */
247 #endif
248 {
249 TRACE_EVENT( "FATAL RETURN psaMM_DeRegistrate in +COPS" );
250 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
251 return( AT_FAIL );
252 }
253
254 percentCSTAT_indication(STATE_MSG_SMS, ENTITY_STATUS_NotReady);
255
256 retCd = AT_EXCT;
257 break;
258
259 case( CFUN_FUN_Full ): /* set ME to full functionality */
260 if ( (CFUNfun EQ CFUN_FUN_Minimum) OR (simShrdPrm.PINStat NEQ PS_RDY) )
261 {
262 CFUNfun = fun;
263 pSIMSetPrm -> actProc = SIM_INITIALISATION;
264
265 simEntStat.curCmd = AT_CMD_CFUN;
266 simShrdPrm.owner = (T_OWN)srcId;
267 simEntStat.entOwn = srcId;
268
269 if( psaSIM_ActivateSIM() < 0 ) /* activate SIM card */
270 {
271 TRACE_EVENT( "FATAL RETURN psaSIM in +CFUN" );
272 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
273 return( AT_FAIL );
274 }
275
276 retCd = AT_EXCT;
277 #ifdef GPRS
278 {
279 PALLOC (gmmreg_attach_req, GMMREG_ATTACH_REQ);
280
281 /* This is just a dummy req to trigger lower layer
282 for power scanning. It will be done based on bootup_act.*/
283 gmmreg_attach_req->bootup_act = QUICK_REG;
284
285 PSEND (hCommGMM,gmmreg_attach_req);
286 }
287 #else
288 {
289 PALLOC (mmr_reg_req, MMR_REG_REQ);
290
291 /* This is just a dummy req to trigger lower layer
292 for power scanning. It will be done based on bootup_act.
293 Other parameters is filled for the simulation test cases to pass */
294 mmr_reg_req->bootup_act = QUICK_REG;
295
296 PSENDX (MM, mmr_reg_req);
297 }
298 #endif
299 }
300 #ifdef SIM_PERS
301 else if (CFUNfun EQ CFUN_FUN_Full )
302 {
303 TRACE_EVENT("This is for if MMI calls sAT_PlusCFUN repetedly for verification of LOCKS");
304 CFUNfun = fun;
305 pSIMSetPrm -> actProc = SIM_INITIALISATION;
306
307 simEntStat.curCmd = AT_CMD_CFUN;
308 simShrdPrm.owner = (T_OWN)srcId;
309 simEntStat.entOwn = srcId;
310
311 if( psaSIM_ActivateSIM() < 0 ) /* activate SIM card */
312 {
313 TRACE_EVENT( "FATAL RETURN psaSIM in +CFUN" );
314 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
315 return( AT_FAIL );
316 }
317
318 retCd = AT_EXCT;
319 }
320 #endif
321 else
322 {
323 TRACE_EVENT("Switch mobile back on after radio low (CFUN=4)");
324 CFUNfun = fun;
325 retCd = AT_CMPL;
326 }
327 break;
328
329 case (CFUN_FUN_Disable_TX_RX_RF):
330 if (CFUNfun EQ CFUN_FUN_Minimum)
331 {
332 /* User directly goes to flight mode from power off. Only initialise
333 the SIM data */
334 CFUNfun = fun;
335 pSIMSetPrm -> actProc = SIM_INITIALISATION;
336
337 simEntStat.curCmd = AT_CMD_CFUN;
338 simShrdPrm.owner = (T_OWN)srcId;
339 simEntStat.entOwn = srcId;
340
341 if( psaSIM_ActivateSIM() < 0 ) /* activate SIM card */
342 {
343 TRACE_EVENT( "FATAL RETURN psaSIM in +CFUN" );
344 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
345 return( AT_FAIL );
346 }
347
348 retCd = AT_EXCT;
349 break;
350 }
351 CFUNfun = fun;
352
353 /* Turn off all possible ringing */
354 #ifdef FF_ATI
355 io_setRngInd ( IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
356 #endif
357 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
358 {
359 R_AT( RAT_CRING_OFF, (T_ACI_CMD_SRC)idx )( 0 ); /* Turn of all ringing */
360 }
361
362 if( mmEntStat.curCmd NEQ AT_CMD_BAND )
363 {
364 /* If sAT_PlusCFUN has been called by sAT_PercentBAND !!! */
365 mmEntStat.curCmd = AT_CMD_CFUN;
366 }
367 mmShrdPrm.owner = (T_OWN)srcId;
368 mmEntStat.entOwn = srcId;
369
370 #if defined (GPRS) AND defined (DTI)
371 mmShrdPrm.nrgCs = GMMREG_DT_SOFT_OFF;
372 if( psaG_MM_CMD_DEREG ( mmShrdPrm.nrgCs ) < 0 ) /* deregister from network */
373 #else
374 mmShrdPrm.nrgCs = CS_SOFT_OFF;
375 if( psaMM_DeRegistrate () < 0 ) /* deregister from network */
376 #endif
377 {
378 TRACE_EVENT( "FATAL RETURN psaMM_DeRegistrate in +COPS" );
379 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
380 return( AT_FAIL );
381 }
382
383 retCd = AT_EXCT;
384 break;
385
386 default: /* unexpected parameter */
387
388 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
389 return( AT_FAIL );
390 }
391
392 /*
393 *-------------------------------------------------------------------
394 * log command execution
395 *-------------------------------------------------------------------
396 */
397 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
398 if( mmEntStat.curCmd NEQ AT_CMD_BAND
399 AND simEntStat.curCmd NEQ AT_CMD_BAND )
400 {
401 T_ACI_CLOG cmdLog; /* holds logging info */
402
403 cmdLog.atCmd = AT_CMD_CFUN;
404 cmdLog.cmdType = CLOG_TYPE_Set;
405 cmdLog.retCode = retCd;
406 cmdLog.cId = ACI_NumParmNotPresent;
407 cmdLog.sId = ACI_NumParmNotPresent;
408 cmdLog.cmdPrm.sCFUN.srcId = srcId;
409 cmdLog.cmdPrm.sCFUN.fun = fun;
410 cmdLog.cmdPrm.sCFUN.rst = rst;
411
412 rAT_PercentCLOG( &cmdLog );
413 }
414 #endif
415
416 return( retCd );
417
418 }
419
420 #ifdef TI_PS_FF_AT_P_CMD_SECP
421 /*
422 +--------------------------------------------------------------------+
423 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
424 | STATE : code ROUTINE : sAT_PercentSECP |
425 +--------------------------------------------------------------------+
426
427 PURPOSE : This is the functional counterpart to the %SEC AT command
428 which is responsible to enter a PIN.
429
430 <pin>: string of PIN chars.
431 <newpin>: string of PIN chars required if requested PIN is
432 SIM PUK
433 */
434
435 GLOBAL T_ACI_RETURN sAT_PercentSECP ( T_ACI_CMD_SRC srcId,
436 CHAR * pin,
437 CHAR * newpin )
438 {
439 T_SIMLOCK_STATUS result;
440
441 TRACE_FUNCTION ("sAT_PercentSECP()");
442
443 /*
444 *-------------------------------------------------------------------
445 * check command source
446 *-------------------------------------------------------------------
447 */
448 if(!cmh_IsVldCmdSrc (srcId))
449 {
450 return( AT_FAIL );
451 }
452
453 /* Check validity of pin str*/
454 if( pin EQ NULL)
455 {
456 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
457 return( AT_FAIL );
458 }
459
460 /* Try to set new pin */
461 result = aci_ext_personalisation_CS_change_password( pin, newpin );
462
463 /* Implements Measure 50 */
464 return ( cmhSIM_analyze_SIMLOCK_STATUS ( result ) );
465
466 }
467 #endif /* TI_PS_FF_AT_P_CMD_SECP */
468
469 #ifdef TI_PS_FF_AT_P_CMD_SECS
470 /*
471 +--------------------------------------------------------------------+
472 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
473 | STATE : code ROUTINE : sAT_PercentSECS |
474 +--------------------------------------------------------------------+
475
476 PURPOSE : This is the functional counterpart to the %SECS? AT command
477 which is responsible to set the status of the Security Code.
478
479 <securityStatus>: Status of the security code.
480 <code>: Security code required to change the status.
481 */
482
483
484 GLOBAL T_ACI_RETURN sAT_PercentSECS ( T_ACI_CMD_SRC srcId,
485 T_ACI_SECS_STA securityState,
486 CHAR * code )
487 {
488
489 T_SIMLOCK_STATUS result;
490
491 TRACE_FUNCTION ("sAT_PercentSECS()");
492
493
494 /*
495 *-------------------------------------------------------------------
496 * check command source
497 *-------------------------------------------------------------------
498 */
499 if(!cmh_IsVldCmdSrc (srcId))
500 {
501 return( AT_FAIL );
502 }
503
504 /*
505 *-------------------------------------------------------------------
506 * check status value
507 *-------------------------------------------------------------------
508 */
509 switch (securityState)
510 {
511 case( SECS_STA_Enable ):
512 result = aci_ext_personalisation_CS_set_status(SIMLOCK_ENABLED, code);
513 break;
514 case( SECS_STA_Disable ):
515 result = aci_ext_personalisation_CS_set_status(SIMLOCK_DISABLED, code);
516 break;
517 default:
518 return( AT_FAIL );
519 }
520
521 /*
522 *-------------------------------------------------------------------
523 * analyze answer
524 *-------------------------------------------------------------------
525 */
526 /* Implements Measure 50 */
527 return ( cmhSIM_analyze_SIMLOCK_STATUS ( result ) );
528 }
529 #endif /* TI_PS_FF_AT_P_CMD_SECS */
530
531
532
533
534
535 /*
536 +--------------------------------------------------------------------+
537 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
538 | STATE : code ROUTINE : sAT_PlusCPIN |
539 +--------------------------------------------------------------------+
540
541 PURPOSE : This is the functional counterpart to the +CPIN AT command
542 which is responsible to enter a PIN.
543
544 <pin>: string of PIN chars.
545 <newpin>: string of PIN chars required if requested PIN is
546 SIM PUK
547 */
548
549 GLOBAL T_ACI_RETURN sAT_PlusCPIN ( T_ACI_CMD_SRC srcId,
550 CHAR * pin,
551 CHAR * newpin )
552 {
553 T_SIM_SET_PRM * pSIMSetPrm; /* points to SIM parameter set */
554 T_ACI_RETURN retCd; /* holds return code */
555 T_SIMLOCK_STATUS retSlStatus; /* holds return code */
556
557 TRACE_FUNCTION ("sAT_PlusCPIN()");
558
559 /*
560 *-------------------------------------------------------------------
561 * check command source
562 *-------------------------------------------------------------------
563 */
564 if(!cmh_IsVldCmdSrc (srcId))
565 {
566 return( AT_FAIL );
567 }
568
569 pSIMSetPrm = &simShrdPrm.setPrm[srcId];
570
571 /*
572 *-------------------------------------------------------------------
573 * check entity status
574 *-------------------------------------------------------------------
575 */
576 if( simEntStat.curCmd NEQ AT_CMD_NONE )
577
578 return( AT_BUSY );
579
580 /*
581 *-------------------------------------------------------------------
582 * check for PIN status
583 *-------------------------------------------------------------------
584 */
585 switch( simShrdPrm.PINStat )
586 {
587 case( PS_RDY ):
588 /*
589 *---------------------------------------------------------------
590 * Not a SIM PIN State, but a ME personalisation PIN
591 *---------------------------------------------------------------
592 */
593 #ifdef SIM_PERS
594 if (AciSLockShrd.blocked)
595 {
596 retSlStatus = aci_slock_authenticate(AciSLockShrd.current_lock, pin);
597 if ( retSlStatus NEQ SIMLOCK_DISABLED)
598 {
599 TRACE_EVENT( "Wrong PIN given for SIM lock." );
600 if (retSlStatus EQ SIMLOCK_BLOCKED)
601 {
602 if(!aci_slock_set_CFG())
603 {
604 ACI_ERR_DESC( ACI_ERR_CLASS_Ext,EXT_ERR_NoMEPD);
605 return( AT_FAIL );
606 }
607 aci_set_cme_error(AciSLockShrd.current_lock);
608 MFREE(cfg_data);
609 }
610 else
611 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
612 return( AT_FAIL );
613 }
614 else
615 {
616 simEntStat.curCmd = AT_CMD_CPIN;
617 if(!aci_slock_set_CFG())
618 {
619 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_NoMEPD);
620 return( AT_FAIL );
621 }
622 aci_slock_init();
623
624 retSlStatus = SIMLOCK_ENABLED;
625 if(AciSLockShrd.current_lock < SIMLOCK_SIM)
626 {
627 AciSLockShrd.current_lock=(T_SIMLOCK_TYPE)(AciSLockShrd.current_lock +SIMLOCK_NETWORK_SUBSET);
628 AciSLockShrd.check_lock = SIMLOCK_CHECK_PERS;
629 retSlStatus = aci_slock_checkpersonalisation(AciSLockShrd.current_lock);
630 }
631 switch(retSlStatus)
632 {
633 case SIMLOCK_ENABLED :
634 return( AT_CMPL);
635 case SIMLOCK_BLOCKED :
636 return( AT_FAIL);
637 case SIMLOCK_WAIT :
638 return (AT_EXCT);
639
640 }
641 }
642
643 }
644
645 #endif
646 /*
647 *---------------------------------------------------------------
648 * no PIN input is required
649 *---------------------------------------------------------------
650 */
651 retCd = AT_FAIL;
652 break;
653
654 case( NO_VLD_PS ):
655 /*
656 *---------------------------------------------------------------
657 * PIN Status is unknown
658 *---------------------------------------------------------------
659 */
660
661 /* invoke SIM activate and enter PIN if needed ???? */
662 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
663 return( AT_FAIL );
664
665 case( PS_PIN1 ):
666 /*
667 *---------------------------------------------------------------
668 * PIN 1 input is required
669 *---------------------------------------------------------------
670 */
671 if( pin EQ NULL OR
672 strlen( pin ) < MIN_PIN_LEN OR
673 strlen( pin ) > PIN_LEN )
674 {
675 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
676 return( AT_FAIL );
677 }
678
679 cmhSIM_FillInPIN ( pin, pSIMSetPrm -> curPIN, PIN_LEN );
680 pSIMSetPrm -> PINType = PHASE_2_PIN_1;
681 simEntStat.curCmd = AT_CMD_CPIN;
682 simShrdPrm.owner = (T_OWN)srcId;
683 simEntStat.entOwn = srcId;
684
685 if( psaSIM_VerifyPIN() < 0 ) /* verify PIN */
686 {
687 TRACE_EVENT( "FATAL RETURN psaSIM in +CPIN" );
688 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
689 return( AT_FAIL );
690 }
691
692 retCd = AT_EXCT;
693 break;
694
695 case( PS_PIN2 ):
696 /*
697 *---------------------------------------------------------------
698 * PIN 2 input is required
699 *---------------------------------------------------------------
700 */
701 if( pin EQ NULL OR
702 strlen( pin ) < MIN_PIN_LEN OR
703 strlen( pin ) > PIN_LEN )
704 {
705 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
706 return( AT_FAIL );
707 }
708
709 cmhSIM_FillInPIN ( pin, pSIMSetPrm -> curPIN, PIN_LEN );
710 pSIMSetPrm -> PINType = PHASE_2_PIN_2;
711 simEntStat.curCmd = AT_CMD_CPIN;
712 simShrdPrm.owner = (T_OWN)srcId;
713 simEntStat.entOwn = srcId;
714
715 if( psaSIM_VerifyPIN() < 0 ) /* verify PIN */
716 {
717 TRACE_EVENT( "FATAL RETURN psaSIM in +CPIN" );
718 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
719 return( AT_FAIL );
720 }
721
722 retCd = AT_EXCT;
723 break;
724
725 case( PS_PUK1 ):
726 /*
727 *---------------------------------------------------------------
728 * PUK 1 input is required
729 *---------------------------------------------------------------
730 */
731 if( newpin EQ NULL OR
732 strlen( newpin ) EQ 0)
733 {
734 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPukReq ); /* inform about needed PUK */
735 return( AT_FAIL );
736 }
737 if( pin EQ NULL OR
738 newpin EQ NULL OR
739 strlen( pin ) NEQ PUK_LEN OR
740 strlen( newpin ) < MIN_PIN_LEN OR
741 strlen( newpin ) > PIN_LEN )
742 {
743 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
744 return( AT_FAIL );
745 }
746
747 cmhSIM_FillInPIN ( pin, pSIMSetPrm -> unblkKey, PUK_LEN );
748 cmhSIM_FillInPIN ( newpin, pSIMSetPrm -> curPIN, PIN_LEN );
749 pSIMSetPrm -> PINType = PHASE_2_PUK_1;
750 simEntStat.curCmd = AT_CMD_CPIN;
751 simShrdPrm.owner = (T_OWN)srcId;
752 simEntStat.entOwn = srcId;
753
754 if( psaSIM_UnblockCard( ) < 0 ) /* verify PIN */
755 {
756 TRACE_EVENT( "FATAL RETURN psaSIM in +CPIN" );
757 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
758 return( AT_FAIL );
759 }
760
761 retCd = AT_EXCT;
762 break;
763
764 case( PS_PUK2 ):
765 /*
766 *---------------------------------------------------------------
767 * PUK 2 input is required
768 *---------------------------------------------------------------
769 */
770 if( newpin EQ NULL OR
771 strlen( newpin ) EQ 0)
772 {
773 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPuk2Req ); /* inform about needed PUK2 */
774 return( AT_FAIL );
775 }
776 if( pin EQ NULL OR
777 newpin EQ NULL OR
778 strlen( pin ) NEQ PUK_LEN OR
779 strlen( newpin ) < MIN_PIN_LEN OR
780 strlen( newpin ) > PIN_LEN )
781 {
782 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
783 return( AT_FAIL );
784 }
785
786 cmhSIM_FillInPIN ( pin, pSIMSetPrm -> unblkKey, PUK_LEN );
787 cmhSIM_FillInPIN ( newpin, pSIMSetPrm -> curPIN, PIN_LEN );
788 pSIMSetPrm -> PINType = PHASE_2_PUK_2;
789 simEntStat.curCmd = AT_CMD_CPIN;
790 simShrdPrm.owner = (T_OWN)srcId;
791 simEntStat.entOwn = srcId;
792
793 if( psaSIM_UnblockCard( ) < 0 ) /* verify PIN */
794 {
795 TRACE_EVENT( "FATAL RETURN psaSIM in +CPIN" );
796 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
797 return( AT_FAIL );
798 }
799
800 retCd = AT_EXCT;
801 break;
802
803 default:
804 /*
805 *---------------------------------------------------------------
806 * unexpected PIN state
807 *---------------------------------------------------------------
808 */
809 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_DataCorrupt );
810 return( AT_FAIL );
811 }
812
813 /*
814 *-------------------------------------------------------------------
815 * log command execution
816 *-------------------------------------------------------------------
817 */
818 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
819 {
820 T_ACI_CLOG cmdLog; /* holds logging info */
821
822 cmdLog.atCmd = AT_CMD_CPIN;
823 cmdLog.cmdType = CLOG_TYPE_Set;
824 cmdLog.retCode = retCd;
825 cmdLog.cId = ACI_NumParmNotPresent;
826 cmdLog.sId = ACI_NumParmNotPresent;
827 cmdLog.cmdPrm.sCPIN.srcId = srcId;
828 cmdLog.cmdPrm.sCPIN.pin = pin;
829 cmdLog.cmdPrm.sCPIN.newpin = newpin;
830
831 rAT_PercentCLOG( &cmdLog );
832 }
833 #endif
834
835 return( retCd );
836 }
837
838 /*
839 +--------------------------------------------------------------------+
840 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
841 | STATE : code ROUTINE : sAT_PlusCAMM |
842 +--------------------------------------------------------------------+
843
844 PURPOSE : This is the functional counterpart to the +CAMM AT command
845 which is responsible to set the ACMMax.
846 */
847
848 GLOBAL T_ACI_RETURN sAT_PlusCAMM ( T_ACI_CMD_SRC srcId,
849 LONG acmmax,
850 CHAR * pwd)
851 {
852 /* Implements Measure 40 */
853 return ( sAT_Plus_CAMM_CACM( AT_CMD_CAMM, srcId, AOC_ACMMAX,
854 (void *) acmmax, (UBYTE *) pwd ));
855 }
856
857 /*
858 +--------------------------------------------------------------------+
859 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
860 | STATE : code ROUTINE : sAT_PlusCPUC |
861 +--------------------------------------------------------------------+
862
863 PURPOSE : This is the functional counterpart to the +CPUC AT command
864 which is responsible to set the PUCT values.
865 */
866
867 GLOBAL T_ACI_RETURN sAT_PlusCPUC ( T_ACI_CMD_SRC srcId,
868 CHAR * currency,
869 CHAR * ppu,
870 CHAR * pwd)
871 {
872 T_puct puct;
873 T_ACI_RETURN ret = AT_FAIL;
874
875 TRACE_FUNCTION ("sAT_PlusCPUC()");
876 /*
877 *-------------------------------------------------------------------
878 * check command source
879 *-------------------------------------------------------------------
880 */
881 if(!cmh_IsVldCmdSrc (srcId))
882 {
883 return( AT_FAIL );
884 }
885
886 /*
887 *-------------------------------------------------------------------
888 * send parameters to advice of charge module.
889 *-------------------------------------------------------------------
890 */
891 strcpy ((char *) puct.currency, currency);
892 strcpy ((char *) puct.value, ppu);
893 simEntStat.curCmd = AT_CMD_CPUC;
894 simShrdPrm.owner = (T_OWN)srcId;
895 simEntStat.entOwn = srcId;
896 ret = aoc_set_values (srcId,
897 AOC_PUCT,
898 (void *)&puct,
899 (UBYTE *) pwd);
900
901 /*
902 *-------------------------------------------------------------------
903 * Check return value of aoc_set_values() equal to AT_FAIL,
904 * resets simEntStat.curcmd and simEntStat.entown.
905 *-------------------------------------------------------------------
906 */
907
908 if( ret EQ AT_FAIL )
909 {
910 simEntStat.curCmd = AT_CMD_NONE;
911 simShrdPrm.owner = (T_OWN)CMD_SRC_NONE;
912 simEntStat.entOwn = CMD_SRC_NONE;
913 }
914
915 return( ret );
916 }
917
918 /*
919 +--------------------------------------------------------------------+
920 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
921 | STATE : code ROUTINE : sAT_PlusCACM |
922 +--------------------------------------------------------------------+
923
924 PURPOSE : This is the functional counterpart to the +CACM AT command
925 which is responsible to reset the ACM value.
926 */
927
928 GLOBAL T_ACI_RETURN sAT_PlusCACM ( T_ACI_CMD_SRC srcId,
929 CHAR * pwd)
930 {
931 /* Implements Measure 40 */
932 return ( sAT_Plus_CAMM_CACM( AT_CMD_CACM, srcId, AOC_ACM,
933 (void *) NULL, (UBYTE *) pwd ));
934 }
935
936 /*
937 +--------------------------------------------------------------------+
938 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
939 | STATE : code ROUTINE : sAT_PlusCPOL |
940 +--------------------------------------------------------------------+
941
942 PURPOSE : This is the functional counterpart to the +CPOL AT command
943 which is responsible to access the preferred PLMN list.
944
945 <index>: PLMN list index
946 <format>: PLMN format
947 <oper>: PLMN name
948 <index2>: second PLMN list index for exchange operation
949 <mode>: supplemental mode information
950 */
951
952 GLOBAL T_ACI_RETURN sAT_PlusCPOL ( T_ACI_CMD_SRC srcId,
953 SHORT index,
954 T_ACI_CPOL_FRMT format,
955 CHAR * oper,
956 SHORT index2,
957 T_ACI_CPOL_MOD mode )
958 {
959 T_SIM_CMD_PRM * pSIMCmdPrm; /* points to SIM command parameters */
960 UBYTE plmn[ACI_LEN_PLMN_SEL_NTRY];/* holds coded plmn id */
961
962 TRACE_FUNCTION ("sAT_PlusCPOL()");
963
964 /*
965 *-------------------------------------------------------------------
966 * check command source
967 *-------------------------------------------------------------------
968 */
969 if(!cmh_IsVldCmdSrc (srcId))
970 {
971 return( AT_FAIL );
972 }
973 pSIMCmdPrm = &cmhPrm[srcId].simCmdPrm;
974
975 /*
976 *-------------------------------------------------------------------
977 * check mode parameter
978 *-------------------------------------------------------------------
979 */
980 switch( mode )
981 {
982 case( CPOL_MOD_CompactList ):
983 case( CPOL_MOD_Insert ):
984 case( CPOL_MOD_NotPresent ):
985 break;
986
987 default:
988 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
989 return( AT_FAIL );
990 }
991
992 /*
993 *-------------------------------------------------------------------
994 * check format parameter
995 *-------------------------------------------------------------------
996 */
997 switch( format )
998 {
999 case( CPOL_FRMT_Long ):
1000 case( CPOL_FRMT_Short ):
1001 case( CPOL_FRMT_Numeric ):
1002
1003 if( index EQ ACI_NumParmNotPresent AND !oper )
1004 {
1005 pSIMCmdPrm->CPOLfrmt = format;
1006 return( AT_CMPL );
1007 }
1008 break;
1009
1010 case( CPOL_FRMT_NotPresent ):
1011
1012 format = pSIMCmdPrm->CPOLfrmt;
1013 break;
1014
1015 default:
1016 {
1017 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1018 return( AT_FAIL );
1019 }
1020 }
1021
1022 /*
1023 *-------------------------------------------------------------------
1024 * check for write entry
1025 *-------------------------------------------------------------------
1026 */
1027 if( oper )
1028 {
1029 /* code plmn id */
1030 if( ! cmhSIM_GetCodedPLMN( oper, format, plmn ))
1031 {
1032 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1033 return( AT_FAIL );
1034 }
1035
1036 /* if EF is already read */
1037 if( EfPLMNselStat EQ EF_STAT_READ )
1038 {
1039 if( mode EQ CPOL_MOD_CompactList )
1040 {
1041 cmhSIM_CmpctPlmnSel( CPOLSimEfDataLen, CPOLSimEfData );
1042 }
1043
1044 if( index NEQ ACI_NumParmNotPresent )
1045 {
1046 if( index > (CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY))
1047 {
1048 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_InvIdx );
1049 return( AT_FAIL );
1050 }
1051
1052 return cmhSIM_UpdPlmnSel( srcId, index, plmn, mode );
1053 }
1054 else
1055
1056 return cmhSIM_FndEmptyPlmnSel( srcId, plmn );
1057 }
1058 else
1059 {
1060 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1061
1062 return( AT_BUSY );
1063
1064 pSIMCmdPrm->CPOLidx = (UBYTE)(index EQ ACI_NumParmNotPresent)?
1065 NOT_PRESENT_8BIT:index;
1066 pSIMCmdPrm->CPOLmode = mode;
1067 pSIMCmdPrm->CPOLact = CPOL_ACT_Write;
1068 memcpy( pSIMCmdPrm->CPOLplmn, plmn, ACI_LEN_PLMN_SEL_NTRY );
1069
1070 simEntStat.curCmd = AT_CMD_CPOL;
1071 simEntStat.entOwn = srcId;
1072
1073 /* Implements Measure 150 and 159 */
1074 return cmhSIM_Req_or_Write_PlmnSel( srcId, ACT_RD_DAT );
1075 }
1076 }
1077
1078 /*
1079 *-------------------------------------------------------------------
1080 * check for delete entry
1081 *-------------------------------------------------------------------
1082 */
1083 else
1084 {
1085 /* check presence of index */
1086 if( index EQ ACI_NumParmNotPresent )
1087 {
1088 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_InvIdx );
1089 return( AT_FAIL );
1090 }
1091
1092 /* if EF is already read */
1093 if( EfPLMNselStat EQ EF_STAT_READ )
1094 {
1095 if( mode EQ CPOL_MOD_CompactList )
1096 {
1097 cmhSIM_CmpctPlmnSel( CPOLSimEfDataLen, CPOLSimEfData );
1098 }
1099
1100 if( index > (CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY) OR
1101 (index2 > (CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY) AND
1102 index2 NEQ ACI_NumParmNotPresent))
1103 {
1104 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_InvIdx );
1105 return( AT_FAIL );
1106 }
1107
1108 if( index2 EQ ACI_NumParmNotPresent )
1109
1110 return cmhSIM_DelPlmnSel( srcId, index, mode );
1111
1112 else
1113
1114 return cmhSIM_ChgPlmnSel( srcId, index, index2 );
1115 }
1116 else
1117 {
1118 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1119
1120 return( AT_BUSY );
1121
1122 pSIMCmdPrm->CPOLidx = (UBYTE)index;
1123 pSIMCmdPrm->CPOLidx2 = (index2 NEQ ACI_NumParmNotPresent)?
1124 (UBYTE)index2:NOT_PRESENT_8BIT;
1125 pSIMCmdPrm->CPOLmode = mode;
1126 pSIMCmdPrm->CPOLact = CPOL_ACT_Delete;
1127
1128 simEntStat.curCmd = AT_CMD_CPOL;
1129 simEntStat.entOwn = srcId;
1130
1131 /* Implements Measure 150 and 159 */
1132 return cmhSIM_Req_or_Write_PlmnSel( srcId, ACT_RD_DAT );
1133 }
1134 }
1135 }
1136
1137 /*
1138 +--------------------------------------------------------------------+
1139 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1140 | STATE : code ROUTINE : sAT_PlusCRSM |
1141 +--------------------------------------------------------------------+
1142
1143 PURPOSE : This is the functional counterpart to the +CRSM AT command
1144 which is responsible for restricted SIM access.
1145
1146 <cmd>: access command.
1147 <fileId>: file identifier
1148 <p1>: parameter 1
1149 <p2>: parameter 2
1150 <p3>: parameter 3
1151 <dataLen>: length of data
1152 <data>: pointer to data
1153 */
1154
1155 T_ACI_RETURN sAT_PlusCRSM ( T_ACI_CMD_SRC srcId,
1156 T_ACI_CRSM_CMD cmd,
1157 SHORT fileId,
1158 SHORT p1,
1159 SHORT p2,
1160 SHORT p3,
1161 SHORT dataLen,
1162 UBYTE *data )
1163 {
1164 T_SIM_TRNS_ACC_PRM prm; /* holds access parameter */
1165
1166 TRACE_FUNCTION ("sAT_PlusCRSM()");
1167
1168 /*
1169 *-------------------------------------------------------------------
1170 * check command source
1171 *-------------------------------------------------------------------
1172 */
1173 if(!cmh_IsVldCmdSrc (srcId))
1174 {
1175 return( AT_FAIL );
1176 }
1177
1178 /*
1179 *-------------------------------------------------------------------
1180 * check entity status
1181 *-------------------------------------------------------------------
1182 */
1183 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1184
1185 return( AT_BUSY );
1186
1187 /*
1188 *-------------------------------------------------------------------
1189 * check command, data, p1, p2 and p3 parameters
1190 *-------------------------------------------------------------------
1191 */
1192 switch( cmd )
1193 {
1194 case( CRSM_CMD_UpdBin ):
1195 case( CRSM_CMD_UpdRec ):
1196
1197 if( !data OR !dataLen )
1198 {
1199 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1200 return( AT_FAIL );
1201 }
1202 /*lint -fallthrough*/
1203
1204 case( CRSM_CMD_ReadBin ):
1205 case( CRSM_CMD_ReadRec ):
1206
1207 if( p1 EQ ACI_NumParmNotPresent OR
1208 p2 EQ ACI_NumParmNotPresent OR
1209 p3 EQ ACI_NumParmNotPresent )
1210 {
1211 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1212 return( AT_FAIL );
1213 }
1214 break;
1215
1216 case( CRSM_CMD_GetResp ):
1217 case( CRSM_CMD_Status ):
1218
1219 if( p3 EQ ACI_NumParmNotPresent )
1220 p3 = 0;
1221 break;
1222
1223 case( CRSM_CMD_NotPresent ):
1224 default:
1225 {
1226 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1227 return( AT_FAIL );
1228 }
1229 }
1230
1231 /*
1232 *-------------------------------------------------------------------
1233 * check fileId parameter
1234 *-------------------------------------------------------------------
1235 */
1236 if( fileId EQ ACI_NumParmNotPresent AND cmd NEQ CRSM_CMD_Status )
1237 {
1238 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1239 return( AT_FAIL );
1240 }
1241
1242 /*
1243 *-------------------------------------------------------------------
1244 * convert command
1245 *-------------------------------------------------------------------
1246 */
1247 switch( cmd )
1248 {
1249 case( CRSM_CMD_UpdBin ): prm.cmd = SIM_UPDATE_BINARY;break;
1250 case( CRSM_CMD_UpdRec ): prm.cmd = SIM_UPDATE_RECORD;break;
1251 case( CRSM_CMD_ReadBin ): prm.cmd = SIM_READ_BINARY;break;
1252 case( CRSM_CMD_ReadRec ): prm.cmd = SIM_READ_RECORD;break;
1253 case( CRSM_CMD_GetResp ): prm.cmd = SIM_GET_RESPONSE;break;
1254 case( CRSM_CMD_Status ): prm.cmd = SIM_STATUS;break;
1255 }
1256
1257 /*
1258 *-------------------------------------------------------------------
1259 * access SIM
1260 *-------------------------------------------------------------------
1261 */
1262 simEntStat.curCmd = AT_CMD_CRSM;
1263 simEntStat.entOwn = srcId;
1264
1265 prm.reqDataFld = (USHORT)fileId;
1266 prm.p1 = (UBYTE)p1;
1267 prm.p2 = (UBYTE)p2;
1268 prm.p3 = (UBYTE)p3;
1269 prm.dataLen = (UBYTE)dataLen;
1270 prm.transData = data;
1271
1272 psaSIM_TrnsSIMAccess( &prm );
1273
1274 return( AT_EXCT );
1275 }
1276
1277 /*
1278 +--------------------------------------------------------------------+
1279 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1280 | STATE : code ROUTINE : sAT_PlusCSIM |
1281 +--------------------------------------------------------------------+
1282
1283 PURPOSE : This is the functional counterpart to the +CSIM AT command
1284 which is responsible for generic SIM access.
1285
1286 */
1287
1288 T_ACI_RETURN sAT_PlusCSIM ( T_ACI_CMD_SRC srcId,
1289 USHORT dataLen,
1290 UBYTE *data )
1291 {
1292 T_SIM_TRNS_ACC_PRM prm; /* holds access parameter */
1293
1294 TRACE_FUNCTION ("sAT_PlusCSIM()");
1295
1296 /*
1297 *-------------------------------------------------------------------
1298 * check command source
1299 *-------------------------------------------------------------------
1300 */
1301 if(!cmh_IsVldCmdSrc (srcId))
1302 {
1303 return( AT_FAIL );
1304 }
1305
1306 /*
1307 *-------------------------------------------------------------------
1308 * check entity status
1309 *-------------------------------------------------------------------
1310 */
1311 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1312 {
1313 return( AT_BUSY );
1314 }
1315
1316 if (data[0] EQ GSM_CLASS)
1317 {
1318 /* GSM instruction class is not allowed */
1319 TRACE_EVENT("GSM instruction class is not allowed");
1320 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
1321 return( AT_FAIL );
1322 }
1323 #if 0 /* do we really need the check for the ATP source ? */
1324 #ifdef _TARGET_
1325 if (ati_is_src_type((UBYTE)srcId, ATI_SRC_TYPE_RIV) EQ FALSE)
1326 {
1327 /* don't allow other source type than RIV */
1328 TRACE_EVENT("other src type than RIV is not allowed");
1329 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
1330 return( AT_FAIL );
1331 }
1332 #endif /*_TARGET_*/
1333 #endif /* */
1334 if (dataLen > MAX_SIM_TRANSP)
1335 {
1336 /* wrong length value */
1337 TRACE_EVENT("wrong length value");
1338 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1339 return( AT_FAIL );
1340 }
1341
1342 /*
1343 *-------------------------------------------------------------------
1344 * access SIM
1345 *-------------------------------------------------------------------
1346 */
1347 simEntStat.curCmd = AT_CMD_CSIM;
1348 simEntStat.entOwn = srcId;
1349
1350 prm.cmd = SIM_TRANSP_CMD;
1351 prm.dataLen = dataLen;
1352 prm.transData = data;
1353
1354 psaSIM_TrnsSIMAccess( &prm );
1355
1356 return( AT_EXCT );
1357
1358 }
1359
1360 /*
1361 +--------------------------------------------------------------------+
1362 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1363 | STATE : code ROUTINE : sAT_PercentPVRF |
1364 +--------------------------------------------------------------------+
1365
1366 PURPOSE : This is the functional counterpart to the %PVRF AT command
1367 which is responsible to verify a specific PIN.
1368
1369 <pin>: string of PIN chars.
1370 <newpin>: string of PIN chars required if requested PIN is
1371 SIM PUK
1372 */
1373
1374 GLOBAL T_ACI_RETURN sAT_PercentPVRF( T_ACI_CMD_SRC srcId,
1375 T_ACI_PVRF_TYPE type,
1376 CHAR * pin,
1377 CHAR * newpin )
1378 {
1379 T_SIM_SET_PRM * pSIMSetPrm; /* points to SIM parameter set */
1380 T_ACI_RETURN retCd; /* holds return code */
1381
1382 TRACE_FUNCTION ("sAT_PercentPVRF()");
1383
1384 /*
1385 *-------------------------------------------------------------------
1386 * check command source
1387 *-------------------------------------------------------------------
1388 */
1389 if(!cmh_IsVldCmdSrc (srcId))
1390 {
1391 return( AT_FAIL );
1392 }
1393
1394 pSIMSetPrm = &simShrdPrm.setPrm[srcId];
1395
1396 /*
1397 *-------------------------------------------------------------------
1398 * check entity status
1399 *-------------------------------------------------------------------
1400 */
1401 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1402
1403 return( AT_BUSY );
1404
1405 /*
1406 *-------------------------------------------------------------------
1407 * check for PIN type
1408 *-------------------------------------------------------------------
1409 */
1410 switch( type )
1411 {
1412 case( PVRF_TYPE_Pin1 ):
1413 case( PVRF_TYPE_Pin2 ):
1414 /*
1415 *---------------------------------------------------------------
1416 * PIN 1/2 verify is required
1417 *---------------------------------------------------------------
1418 */
1419 if( pin EQ NULL OR
1420 strlen( pin ) < MIN_PIN_LEN OR
1421 strlen( pin ) > PIN_LEN )
1422 {
1423 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1424 return( AT_FAIL );
1425 }
1426
1427 cmhSIM_FillInPIN ( pin, pSIMSetPrm -> curPIN, PIN_LEN );
1428 pSIMSetPrm -> PINType = (type EQ PVRF_TYPE_Pin1)?
1429 PHASE_2_PIN_1:PHASE_2_PIN_2;
1430 simEntStat.curCmd = AT_CMD_PVRF;
1431 simShrdPrm.owner = (T_OWN)srcId;
1432 simEntStat.entOwn = srcId;
1433
1434 if( psaSIM_VerifyPIN() < 0 ) /* verify PIN */
1435 {
1436 TRACE_EVENT( "FATAL RETURN psaSIM in %%PVRF" );
1437 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1438 return( AT_FAIL );
1439 }
1440
1441 retCd = AT_EXCT;
1442 break;
1443
1444 case( PVRF_TYPE_Puk1 ):
1445 case( PVRF_TYPE_Puk2 ):
1446 /*
1447 *---------------------------------------------------------------
1448 * PUK 1/2 verify is required
1449 *---------------------------------------------------------------
1450 */
1451 if( pin EQ NULL OR
1452 newpin EQ NULL OR
1453 strlen( pin ) NEQ PUK_LEN OR
1454 strlen( newpin ) < MIN_PIN_LEN OR
1455 strlen( newpin ) > PIN_LEN )
1456 {
1457 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1458 return( AT_FAIL );
1459 }
1460
1461 cmhSIM_FillInPIN ( pin, pSIMSetPrm -> unblkKey, PUK_LEN );
1462 cmhSIM_FillInPIN ( newpin, pSIMSetPrm -> curPIN, PIN_LEN );
1463 pSIMSetPrm -> PINType = (type EQ PVRF_TYPE_Puk1)?
1464 PHASE_2_PUK_1:PHASE_2_PUK_2;
1465 simEntStat.curCmd = AT_CMD_PVRF;
1466 simShrdPrm.owner = (T_OWN)srcId;
1467 simEntStat.entOwn = srcId;
1468
1469 if( psaSIM_UnblockCard( ) < 0 ) /* verify PIN */
1470 {
1471 TRACE_EVENT( "FATAL RETURN psaSIM in %%PVRF" );
1472 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1473 return( AT_FAIL );
1474 }
1475
1476 retCd = AT_EXCT;
1477 break;
1478
1479 default:
1480 /*
1481 *---------------------------------------------------------------
1482 * unexpected PIN state
1483 *---------------------------------------------------------------
1484 */
1485 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_DataCorrupt );
1486 return( AT_FAIL );
1487 }
1488
1489 /*
1490 *-------------------------------------------------------------------
1491 * log command execution
1492 *-------------------------------------------------------------------
1493 */
1494 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1495 {
1496 T_ACI_CLOG cmdLog; /* holds logging info */
1497
1498 cmdLog.atCmd = AT_CMD_PVRF;
1499 cmdLog.cmdType = CLOG_TYPE_Set;
1500 cmdLog.retCode = retCd;
1501 cmdLog.cId = ACI_NumParmNotPresent;
1502 cmdLog.sId = ACI_NumParmNotPresent;
1503 cmdLog.cmdPrm.sPVRF.srcId = srcId;
1504 cmdLog.cmdPrm.sPVRF.type = type;
1505 cmdLog.cmdPrm.sPVRF.pin = pin;
1506 cmdLog.cmdPrm.sPVRF.newpin = newpin;
1507
1508 rAT_PercentCLOG( &cmdLog );
1509 }
1510 #endif
1511
1512 return( retCd );
1513 }
1514
1515
1516 /*
1517 +-------------------------------------------------------------------+
1518 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1519 | ROUTINE : sAT_PercentCPRI |
1520 +-------------------------------------------------------------------+
1521
1522 PURPOSE : set the CPRI mode for displaying/not displaying
1523 ciphering indications
1524 */
1525
1526 GLOBAL T_ACI_RETURN sAT_PercentCPRI( T_ACI_CMD_SRC srcId,
1527 UBYTE mode )
1528 {
1529 TRACE_FUNCTION ("sAT_PercentCPRI()");
1530
1531 if( !cmh_IsVldCmdSrc( srcId ) )
1532 {
1533 return( AT_FAIL );
1534 }
1535
1536 if (simShrdPrm.ciSIMEnabled NEQ FALSE) /* Since this function is used by MMI,it just returns AT_CMPL */
1537 {
1538 return( AT_CMPL ); /* If CPRI is enabled in the SIM,it just returns AT_CMPL */
1539 }
1540
1541 else
1542 {
1543 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
1544 return( AT_FAIL );
1545 }
1546 }
1547
1548 #ifdef FF_DUAL_SIM
1549 /*
1550 +-------------------------------------------------------------------+
1551 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1552 | ROUTINE : sAT_PercentSIM |
1553 +-------------------------------------------------------------------+
1554
1555 PURPOSE : Select the SIM to be powered on
1556 */
1557
1558 GLOBAL T_ACI_RETURN sAT_PercentSIM( T_ACI_CMD_SRC srcId,
1559 UBYTE sim_num )
1560 {
1561 T_SIM_SET_PRM * pSIMSetPrm; /* points to SIM parameter set */
1562
1563 TRACE_FUNCTION ("sAT_PercentSIM()");
1564
1565 if( !cmh_IsVldCmdSrc( srcId ) )
1566 {
1567 return( AT_FAIL );
1568 }
1569
1570 pSIMSetPrm = &simShrdPrm.setPrm[srcId];
1571
1572 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1573 {
1574 TRACE_EVENT("Entity SIM is busy: cannot proceed command...");
1575 return( AT_BUSY );
1576 }
1577
1578 if(CFUNfun EQ CFUN_FUN_Full)
1579 {
1580 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
1581 return( AT_FAIL );
1582 }
1583
1584 if(sim_num < SIM_NUM_0 OR sim_num > SIM_NUM_2)
1585 {
1586 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
1587 return( AT_FAIL );
1588 }
1589
1590 pSIMSetPrm->SIM_Selected = sim_num;
1591
1592 simEntStat.curCmd = AT_CMD_SIM;
1593 simShrdPrm.owner = (T_OWN)srcId;
1594 simEntStat.entOwn = srcId;
1595
1596 if( psaSIM_SelectSIM() < 0 ) /* select SIM card */
1597 {
1598 TRACE_EVENT( "FATAL RETURN psaSIM in %SIM" );
1599 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1600 return( AT_FAIL );
1601 }
1602 return(AT_EXCT);
1603 }
1604 #endif /*FF_DUAL_SIM*/
1605
1606 #ifdef FF_CPHS_REL4
1607 /*
1608 +-------------------------------------------------------------------+
1609 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1610 | ROUTINE : sAT_PercentCFIS |
1611 +-------------------------------------------------------------------+
1612
1613 PURPOSE : Set/Read the CFU staus in EF-CFIS file present in SIM
1614 */
1615
1616 GLOBAL T_ACI_RETURN sAT_PercentCFIS( T_ACI_CMD_SRC srcId,
1617 T_ACI_CFIS_MOD mode,
1618 UBYTE index,
1619 UBYTE mspId,
1620 UBYTE cfuStat,
1621 CHAR* number,
1622 T_ACI_TOA* type,
1623 UBYTE cc2_id)
1624 {
1625
1626 TRACE_FUNCTION ("sAT_PercentCFIS()");
1627
1628 /*
1629 *-------------------------------------------------------------------
1630 * check command source
1631 *-------------------------------------------------------------------
1632 */
1633 if(!cmh_IsVldCmdSrc (srcId))
1634 {
1635 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1636 return( AT_FAIL );
1637 }
1638
1639 /*
1640 *-------------------------------------------------------------------
1641 * check entity status
1642 *-------------------------------------------------------------------
1643 */
1644 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1645 return( AT_BUSY );
1646
1647 /*
1648 *-------------------------------------------------------------------
1649 * process parameter <mode>
1650 *-------------------------------------------------------------------
1651 */
1652 switch( mode )
1653 {
1654 case ( CFIS_MOD_Write ):
1655 case ( CFIS_MOD_Delete ):
1656 return cmhSIM_WrCfis (srcId,mode,index,mspId,cfuStat,number,
1657 type,cc2_id);
1658 default:
1659 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1660 return( AT_FAIL );
1661 }
1662 }
1663 /*
1664 +-------------------------------------------------------------------+
1665 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1666 | ROUTINE : sAT_PercentMWIS |
1667 +-------------------------------------------------------------------+
1668
1669 PURPOSE :Set the Message Waiting status in EF-MWIS file in SIM
1670 */
1671
1672 GLOBAL T_ACI_RETURN sAT_PercentMWIS( T_ACI_CMD_SRC srcId,
1673 T_ACI_MWIS_MOD mode,
1674 UBYTE mspId,
1675 T_ACI_MWIS_MWI *mwis)
1676 {
1677
1678 TRACE_FUNCTION ("sAT_PercentMWIS()");
1679
1680 /*
1681 *-------------------------------------------------------------------
1682 * check command source
1683 *-------------------------------------------------------------------
1684 */
1685 if(!cmh_IsVldCmdSrc (srcId))
1686 {
1687 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1688 return( AT_FAIL );
1689 }
1690
1691 /*
1692 *-------------------------------------------------------------------
1693 * check entity status
1694 *-------------------------------------------------------------------
1695 */
1696 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1697 return( AT_BUSY );
1698
1699 /*
1700 *-------------------------------------------------------------------
1701 * process parameter <mode>
1702 *-------------------------------------------------------------------
1703 */
1704 switch( mode )
1705 {
1706 case ( MWIS_MOD_Write ):
1707 case ( MWIS_MOD_Delete ):
1708 return cmhSIM_WrMwis (srcId,mode,mspId,mwis);
1709 break;
1710 default:
1711 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1712 return( AT_FAIL );
1713 }
1714 }
1715 /*
1716 +-------------------------------------------------------------------+
1717 | PROJECT : GSM-PS (6147) MODULE : CMH_SIMS |
1718 | ROUTINE : sAT_PercentMBDN |
1719 +-------------------------------------------------------------------+
1720
1721 PURPOSE : Set/Read the Mailbox Numbers in EF-MBDN file present in SIM
1722 */
1723
1724 GLOBAL T_ACI_RETURN sAT_PercentMBDN( T_ACI_CMD_SRC srcId,
1725 T_ACI_MBN_MODE mode,
1726 UBYTE index,
1727 CHAR* number,
1728 T_ACI_TOA* type,
1729 UBYTE cc2_id,
1730 T_ACI_PB_TEXT *text)
1731 {
1732
1733 TRACE_FUNCTION ("sAT_PercentMBDN()");
1734
1735 #ifndef NO_ASCIIZ
1736 /* convert Text */
1737 if ( text NEQ NULL )
1738 {
1739 UBYTE tmpBuf[MAX_ALPHA_LEN];
1740 USHORT len;
1741 text->cs = CS_Sim;
1742 cmh_cvtToDefGsm ( (CHAR*)text->data, (CHAR*)tmpBuf, &len );
1743 text->len = (UBYTE)len;
1744 memcpy ( text->data, tmpBuf, text->len );
1745 }
1746 #endif /* #ifndef NO_ASCIIZ */
1747 /*
1748 *-------------------------------------------------------------------
1749 * check command source
1750 *-------------------------------------------------------------------
1751 */
1752 if(!cmh_IsVldCmdSrc (srcId))
1753 {
1754 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1755 return( AT_FAIL );
1756 }
1757
1758 /*
1759 *-------------------------------------------------------------------
1760 * check entity status
1761 *-------------------------------------------------------------------
1762 */
1763 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1764 return( AT_BUSY );
1765
1766 /*
1767 *-------------------------------------------------------------------
1768 * process parameter <mode>
1769 *-------------------------------------------------------------------
1770 */
1771 switch( mode )
1772 {
1773 case ( MBN_Mode_Write ):
1774 if (number EQ NULL)
1775 {
1776 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1777 return (AT_FAIL);
1778 }
1779 /* lint-fallthrough */
1780 case ( MBN_Mode_Delete ):
1781 return cmhSIM_WrMbdn (srcId, mode, index, number,
1782 type, cc2_id, text);
1783 default:
1784 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1785 return( AT_FAIL );
1786 }
1787 }
1788 #endif /* FF_CPHS_REL4 */
1789
1790
1791 /* Implements Measure 50 */
1792 /*
1793 +------------------------------------------------------------------------------
1794 | Function : cmhSIM_analyze_SIMLOCK_STATUS
1795 +------------------------------------------------------------------------------
1796 | Description : This Function will analyze the SIMLOCK STATUS, passed as an
1797 | argument to this function and accordingly returns AT_CMPL
1798 | AT_FAIL
1799 |
1800 | Parameters : status - SIMLOCK STATUS that needs to be analyzed
1801 |
1802 | Return : ACI Return Codes (Either AT_CMPL or AT_FAIL)
1803 +------------------------------------------------------------------------------
1804 */
1805
1806 LOCAL T_ACI_RETURN cmhSIM_analyze_SIMLOCK_STATUS( T_SIMLOCK_STATUS status )
1807 {
1808 TRACE_FUNCTION ( "cmhSIM_analyze_SIMLOCK_STATUS()" );
1809
1810 switch ( status )
1811 {
1812 case SIMLOCK_ENABLED:
1813 case SIMLOCK_DISABLED:
1814 /* success */
1815 return AT_CMPL;
1816
1817 case SIMLOCK_BLOCKED: /* password tried too many times, phone blocked */
1818 ACI_ERR_DESC(ACI_ERR_CLASS_Cme, CME_ERR_PhoneFail);
1819 return AT_FAIL;
1820
1821 case SIMLOCK_LOCKED: /* password wrong */
1822 ACI_ERR_DESC(ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd);
1823 return AT_FAIL;
1824
1825 default: /* other error */
1826 ACI_ERR_DESC(ACI_ERR_CLASS_Cme, CME_ERR_Unknown);
1827 return AT_FAIL;
1828 }
1829 }
1830
1831 /* Implements Measure 40 */
1832 /*
1833 +------------------------------------------------------------------------------
1834 | Function : sAT_Plus_CAMM_CACM
1835 +------------------------------------------------------------------------------
1836 | Description : This is the functional counterpart to the +CACM or +CAMM
1837 | AT commands.
1838 |
1839 | Parameters : at_cmd_id - AT command identifier
1840 | srcId - AT command source identifier
1841 | value_type - AOC_ACM or AOC_ACMMAX
1842 | value - NULL in case of +CACM
1843 | acmmax in case of +CAMM
1844 | pwd - password
1845 |
1846 | Return : ACI functional return codes
1847 +------------------------------------------------------------------------------
1848 */
1849
1850 LOCAL T_ACI_RETURN sAT_Plus_CAMM_CACM ( T_ACI_AT_CMD at_cmd_id,
1851 T_ACI_CMD_SRC srcId,
1852 UBYTE value_type,
1853 void *value,
1854 UBYTE *pwd )
1855 {
1856 T_ACI_RETURN ret = AT_FAIL;
1857
1858 TRACE_FUNCTION ( "sAT_Plus_CAMM_CACM()" );
1859 /*
1860 *-------------------------------------------------------------------
1861 * check command source
1862 *-------------------------------------------------------------------
1863 */
1864 if(!cmh_IsVldCmdSrc (srcId))
1865 {
1866 return( AT_FAIL );
1867 }
1868
1869 /*
1870 *-------------------------------------------------------------------
1871 * send parameters to advice of charge module.
1872 *-------------------------------------------------------------------
1873 */
1874 simEntStat.curCmd = at_cmd_id;
1875 simShrdPrm.owner = (T_OWN)srcId;
1876 simEntStat.entOwn = srcId;
1877 ret = aoc_set_values ( srcId,
1878 value_type,
1879 value,
1880 pwd );
1881
1882 /*
1883 *-------------------------------------------------------------------
1884 * Check return value of aoc_set_values() equal to AT_FAIL,
1885 * resets simEntStat.curcmd and simEntStat.entown.
1886 *-------------------------------------------------------------------
1887 */
1888
1889 if( ret EQ AT_FAIL )
1890 {
1891 simEntStat.curCmd = AT_CMD_NONE;
1892 simShrdPrm.owner = (T_OWN)srcId;
1893 simEntStat.entOwn = srcId;
1894 }
1895
1896 return( ret );
1897
1898 }
1899
1900
1901
1902
1903 /*==== EOF ========================================================*/