FreeCalypso > hg > tcs211-pirelli

comparison g23m/condat/ms/src/aci/cmh_simf.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_SIMF
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 used by the commad
18 | handler for the subscriber identity module.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef CMH_SIMF_C
23 #define CMH_SIMF_C
24 #endif
25
26 #include "aci_all.h"
27 /*==== INCLUDES ===================================================*/
28 #include "aci_cmh.h"
29 #include "ati_cmd.h"
30 #include "aci_cmd.h"
31 #include "pcm.h"
32
33 #ifdef DTI
34 #include "dti.h"
35 #include "dti_conn_mng.h"
36 #endif
37
38 #ifdef FAX_AND_DATA
39 #include "aci_fd.h"
40 #endif /* of #ifdef FAX_AND_DATA */
41
42 #include "aci.h"
43 #include "psa.h"
44 #include "psa_sim.h"
45 #include "psa_cc.h"
46 #include "psa_sat.h"
47 #include "psa_mm.h"
48 #include "psa_util.h"
49 #include "cmh.h"
50 #include "cmh_sim.h"
51 #include "cmh_mm.h"
52 #include "phb.h"
53 #ifdef SIM_PERS
54 #include "aci_ext_pers.h"
55 #include "aci_slock.h"
56 #include "general.h" // inluded for UINT8 compilation error in sec_drv.h
57 #include "sec_drv.h"
58
59 EXTERN T_ACI_SIM_CONFIG aci_slock_sim_config;
60 EXTERN T_SEC_DRV_CONFIGURATION *cfg_data;
61 #endif
62
63 EXTERN T_SIM_MMI_INSERT_IND *last_sim_mmi_insert_ind;
64 /* #include "m_cc.h" */
65
66 /*==== CONSTANTS ==================================================*/
67
68 /*==== TYPES ======================================================*/
69
70 /*==== EXPORT =====================================================*/
71
72 /*==== VARIABLES ==================================================*/
73 const UBYTE PLMNselEmpty[] = { 0xFF, 0xFF, 0xFF };
74 #ifdef SIM_PERS_OTA
75 UBYTE nw_ctrl_key[9], nw_subset_ctrl_key[9], sp_ctrl_key[9], corp_ctrl_key[9];
76 #define MAX_DCK_LEN 16
77 #endif
78
79 /*==== FUNCTIONS ==================================================*/
80 void cmhSIM_Read_AD_cb(SHORT table_id);
81 void cmhSIM_Get_CSP_cb(SHORT table_id);
82 void cmhSIM_Read_CSP_cb(SHORT table_id);
83 #ifdef SIM_PERS_OTA
84 void cmhSIM_Read_DCK_cb(SHORT table_id);
85 void cmhSIM_Read_DCK_init_cb(SHORT table_id);
86 void cmhSIM_WriteDefaultValue_DCK_cb(SHORT table_id);
87 #endif
88 /*
89 +-------------------------------------------------------------------+
90 | PROJECT : GSM-PS (6147) MODULE : CMH_SIM |
91 | ROUTINE : cmhSIM_FillInPIN |
92 +-------------------------------------------------------------------+
93
94 PURPOSE : fill in the PIN into the PIN field of size length and
95 stuff unused chars with 0xFF.
96
97 */
98
99 GLOBAL void cmhSIM_FillInPIN ( CHAR * PINStr, CHAR * PINFld, UBYTE len )
100 {
101 UBYTE idx;
102
103 strncpy( PINFld, PINStr, len );
104
105 for( idx = strlen( PINStr ); idx < len; idx++ )
106 {
107 PINFld[idx] = NOT_PRESENT_CHAR;
108 }
109 }
110
111 /*
112 +-------------------------------------------------------------------+
113 | PROJECT : GSM-PS (6147) MODULE : CMH_SIM |
114 | ROUTINE : cmhSIM_GetHomePLMN |
115 +-------------------------------------------------------------------+
116
117 PURPOSE : Extract home PLMN out of the IMSI.
118
119 */
120
121 GLOBAL void cmhSIM_GetHomePLMN ( SHORT * mccBuf, SHORT * mncBuf )
122 {
123 UBYTE digit; /* holds 4bit digit */
124 UBYTE i; /* holds counter */
125
126 if( simShrdPrm.imsi.c_field EQ 0 )
127 {
128 /*
129 * No SIM present
130 */
131 *mccBuf = *mncBuf = -1;
132 }
133 else
134 {
135 /*
136 * SIM present
137 */
138 *mccBuf = *mncBuf = 0;
139
140 /* Convert MCC and MNC. */
141 for (i = 0; i < SIZE_MCC + SIZE_MNC; i++)
142 {
143 digit = (i & 1) ?
144 (simShrdPrm.imsi.field[(i + 1)/2] & 0x0f) :
145 (simShrdPrm.imsi.field[(i + 1)/2] & 0xf0) >> 4;
146 if (i < SIZE_MCC)
147 *mccBuf = (*mccBuf << 4) | digit;
148 else
149 *mncBuf = (*mncBuf << 4) | digit;
150 }
151 /* The only 3 digit mnc codes that are valid are the values between 310 and 316 */
152 if ((*mccBuf >= 0x310) AND (*mccBuf <= 0x316)
153 OR simShrdPrm.mnc_len EQ 3)
154 {
155 /* used in the US - mcc = 0x310 */
156 }
157 /* Set the third digit of the MNC to 'F' if the SIM indicates a 2-digit MNC country */
158 else /* if (simShrdPrm.mnc_len EQ 2) */
159 {
160 /* The MS digit of the mnc is not valid, so replace the LSB it with 0xF. */
161 *mncBuf |= 0x00F;
162 }
163 }
164 }
165
166 /*
167 +-------------------------------------------------------------------+
168 | PROJECT : GSM-PS (6147) MODULE : CMH_MM |
169 | ROUTINE : cmhSIM_plmn_equal_sim |
170 +-------------------------------------------------------------------+
171
172 PURPOSE : Return TRUE if the PLMN received equals the PLMN
173 stored on the SIM.
174 This is not exactly the algorithm as shown for HPLMN
175 matching as shown in 03.22 Normative Annex A, this version
176 here is more universal.
177
178 */
179
180 GLOBAL BOOL cmhSIM_plmn_equal_sim (SHORT bcch_mcc, SHORT bcch_mnc,
181 SHORT sim_mcc, SHORT sim_mnc)
182 {
183 /*TRACE_FUNCTION ("cmhSIM_plmn_equal_sim()");*/
184
185 /* Check MCC */
186 if (sim_mcc NEQ bcch_mcc)
187 return FALSE;
188
189 /* Check first 2 MNC digits */
190 if ((sim_mnc & 0xff0) NEQ (bcch_mnc & 0xff0))
191 return FALSE;
192
193 /* Check for full match */
194 if ((sim_mnc & 0xf) EQ (bcch_mnc & 0xf))
195 return TRUE;
196
197 /* The 3rd digit of the MNC differs */
198 if ((bcch_mcc >= 0x310) AND (bcch_mcc <= 0x316)
199 OR simShrdPrm.mnc_len EQ 3)
200 {
201 /*
202 * The MCC is in the range 310..316, this means North America.
203 * The zero suffix rule applies.
204 */
205 return ((((sim_mnc & 0xf) EQ 0xf) AND ((bcch_mnc & 0xf) EQ 0x0)) OR
206 (((sim_mnc & 0xf) EQ 0x0) AND ((bcch_mnc & 0xf) EQ 0xf)));
207 }
208 return ((bcch_mnc & 0xf) EQ 0xf);
209 }
210
211 /*
212 +-------------------------------------------------------------------+
213 | PROJECT : GSM-PS (6147) MODULE : CMH_MM |
214 | ROUTINE : cmhSIM_plmn_is_hplmn |
215 +-------------------------------------------------------------------+
216
217 PURPOSE : Return TRUE if the PLMN received is the HPLMN, otherwise
218 return FALSE.
219
220 */
221
222 GLOBAL BOOL cmhSIM_plmn_is_hplmn (SHORT bcch_mcc, SHORT bcch_mnc)
223 {
224 SHORT sim_mcc; /* Holds the MCC of the HPLMN from the SIM */
225 SHORT sim_mnc; /* Holds the MNC of the HPLMN from the SIM */
226
227 TRACE_FUNCTION ("cmhSIM_plmn_is_hplmn()");
228
229 if(!cmhMM_GetActingHPLMN(&sim_mcc, &sim_mnc))/*Enhancement Acting HPLMN*/
230 {
231 /* Extract the HPLMN identification out of the IMSI digits. */
232 cmhSIM_GetHomePLMN (&sim_mcc, &sim_mnc);
233 }
234
235 return cmhSIM_plmn_equal_sim (bcch_mcc, bcch_mnc, sim_mcc, sim_mnc);
236 }
237
238 /*
239 +-------------------------------------------------------------------+
240 | PROJECT : GSM-PS (6147) MODULE : CMH_SIM |
241 | ROUTINE : cmhSIM_GetCmeFromSim |
242 +-------------------------------------------------------------------+
243
244 PURPOSE : Mapping of SIM error code to ACI error code.
245
246 */
247 GLOBAL T_ACI_CME_ERR cmhSIM_GetCmeFromSim ( USHORT errCode )
248 {
249 switch ( errCode )
250 {
251 case SIM_NO_ERROR:
252 return CME_ERR_NotPresent;
253
254 case SIM_CAUSE_PIN1_EXPECT:
255 return CME_ERR_SimPinReq;
256
257 case SIM_CAUSE_PIN2_EXPECT:
258 return CME_ERR_SimPin2Req;
259
260 case SIM_CAUSE_PUK1_EXPECT:
261 return CME_ERR_WrongPasswd;
262 case SIM_CAUSE_PIN1_BLOCKED:
263 return CME_ERR_SimPukReq;
264
265 case SIM_CAUSE_PUK2_EXPECT:
266 return CME_ERR_WrongPasswd;
267 case SIM_CAUSE_PIN2_BLOCKED:
268 return CME_ERR_SimPuk2Req;
269
270 case SIM_CAUSE_PUK1_BLOCKED:
271 case SIM_CAUSE_PUK2_BLOCKED:
272 return CME_ERR_SimWrong;
273
274 case SIM_CAUSE_NO_SELECT:
275 case SIM_CAUSE_UNKN_FILE_ID:
276 return CME_ERR_NotFound;
277
278 case SIM_CAUSE_EF_INVALID:
279 return CME_ERR_OpNotSupp;
280
281 case SIM_CAUSE_ADDR_WRONG:
282 return CME_ERR_InvIdx;
283
284 case SIM_CAUSE_CMD_INCONSIST:
285 case SIM_CAUSE_MAX_INCREASE:
286 case SIM_CAUSE_CHV_NOTSET:
287 case SIM_CAUSE_CHV_VALIDATED:
288 return CME_ERR_OpNotAllow;
289
290 case SIM_CAUSE_ACCESS_PROHIBIT:
291 return CME_ERR_WrongPasswd;
292
293 case SIM_CAUSE_CARD_REMOVED:
294 case SIM_CAUSE_DRV_NOCARD:
295 return CME_ERR_SimNotIns;
296
297 case SIM_CAUSE_CLA_WRONG:
298 case SIM_CAUSE_INS_WRONG:
299 case SIM_CAUSE_P1P2_WRONG:
300 case SIM_CAUSE_P3_WRONG:
301 case SIM_CAUSE_PARAM_WRONG:
302 return CME_ERR_PhoneFail;
303
304 case SIM_CAUSE_SAT_BUSY:
305 return CME_ERR_SimBusy;
306
307 case SIM_CAUSE_DNL_ERROR:
308 return CME_ERR_Unknown;
309
310 case SIM_CAUSE_DRV_TEMPFAIL:
311 return CME_ERR_SimFail;
312
313 default:
314 if (GET_CAUSE_DEFBY(errCode) EQ DEFBY_CONDAT AND
315 GET_CAUSE_ORIGSIDE(errCode) EQ ORIGSIDE_MS)
316 {
317 return CME_ERR_Unknown;
318 }
319 return CME_ERR_Unknown;
320 }
321 }
322
323 /*
324 +--------------------------------------------------------------------+
325 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
326 | STATE : code ROUTINE : cmhSIM_getUserRate |
327 +--------------------------------------------------------------------+
328
329 PURPOSE :
330 */
331 GLOBAL T_ACI_BS_SPEED cmhSIM_GetUserRate ( UBYTE userRate )
332 {
333 switch( userRate )
334 {
335 case ( UR_0_3_KBIT ): return BS_SPEED_300_V110;
336 case ( UR_1_2_KBIT ): return BS_SPEED_1200_V110;
337 case ( UR_2_4_KBIT ): return BS_SPEED_2400_V110;
338 case ( UR_4_8_KBIT ): return BS_SPEED_4800_V110;
339 case ( UR_9_6_KBIT ): return BS_SPEED_9600_V110;
340 case ( UR_1_2_KBIT_V23 ): return BS_SPEED_1200_75_V23;
341 case ( UR_12_0_KBIT_TRANS ):
342 default: return BS_SPEED_NotPresent;
343 }
344 }
345
346 /*
347 +--------------------------------------------------------------------+
348 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
349 | STATE : code ROUTINE : cmhSIM_getSrvFromSync |
350 +--------------------------------------------------------------------+
351
352 PURPOSE :
353 */
354 GLOBAL T_ACI_CNUM_SERV cmhSIM_GetSrvFromSync ( UBYTE sync )
355 {
356 switch( sync )
357 {
358 case ( ASYNCHRONOUS ): return CNUM_SERV_Asynch;
359 case ( SYNCHRONOUS ): return CNUM_SERV_Synch;
360 default: return CNUM_SERV_NotPresent;
361 }
362 }
363
364 /*
365 +--------------------------------------------------------------------+
366 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
367 | STATE : code ROUTINE : cmhSIM_getSrvFromItc |
368 +--------------------------------------------------------------------+
369
370 PURPOSE :
371 */
372 GLOBAL T_ACI_CNUM_SERV cmhSIM_GetSrvFromItc ( UBYTE itc )
373 {
374 switch( itc )
375 {
376 case ( ITC_SPEECH ): return CNUM_SERV_Voice;
377 case ( ITC_FAX_GROUP_3 ): return CNUM_SERV_Fax;
378 default: return CNUM_SERV_NotPresent;
379 }
380 }
381
382 /*
383 +--------------------------------------------------------------------+
384 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
385 | STATE : code ROUTINE : cmhSIM_getUserRate |
386 +--------------------------------------------------------------------+
387
388 PURPOSE :
389 */
390 GLOBAL T_ACI_CNUM_ITC cmhSIM_GetItc ( UBYTE itc )
391 {
392 switch( itc )
393 {
394 case ( ITC_DIGITAL_UNRESTRICTED ): return CNUM_ITC_Udi;
395 case ( ITC_AUDIO ): return CNUM_ITC_3_1_kHz;
396 default: return CNUM_ITC_NotPresent;
397 }
398 }
399
400 /*
401 +--------------------------------------------------------------------+
402 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
403 | STATE : code ROUTINE : cmhSIM_getMncMccFrmPLMNsel |
404 +--------------------------------------------------------------------+
405
406 PURPOSE : get MNC and MCC out of EF PLMNsel entry
407 */
408
409 GLOBAL void cmhSIM_getMncMccFrmPLMNsel(const UBYTE *ntry,
410 SHORT *mcc,
411 SHORT *mnc )
412 {
413 if (memcmp (ntry, PLMNselEmpty, sizeof(PLMNselEmpty)) EQ 0)
414 {
415 *mcc = *mnc = -1;
416 }
417 else
418 {
419 *mcc = ( ntry[0] & 0x0f) << 8;
420 *mcc |= ((ntry[0] >> 4) & 0x0f) << 4;
421 *mcc |= ( ntry[1] & 0x0f);
422 *mnc = ( ntry[2] & 0x0f) << 8;
423 *mnc |= ((ntry[2] >> 4) & 0x0f) << 4;
424 *mnc |= ((ntry[1] >> 4) & 0x0f);
425 }
426 }
427
428 /*
429 +--------------------------------------------------------------------+
430 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
431 | STATE : code ROUTINE : cmhSIM_GetCodedPLMN |
432 +--------------------------------------------------------------------+
433
434 PURPOSE : Code MNC and MCC according a EF PLMNsel entry
435 */
436
437 GLOBAL BOOL cmhSIM_GetCodedPLMN( const CHAR *oper, T_ACI_CPOL_FRMT format,
438 UBYTE *sim_plmn )
439 {
440 T_OPER_ENTRY operDesc; /* operator description */
441 BOOL found;
442
443 /* get MNC and MCC */
444 switch( format )
445 {
446 case( CPOL_FRMT_Long ):
447 found = cmhMM_FindName( &operDesc, oper, COPS_FRMT_Long );
448 break;
449 case( CPOL_FRMT_Short ):
450 found = cmhMM_FindName( &operDesc, oper, COPS_FRMT_Short );
451 break;
452 case( CPOL_FRMT_Numeric ):
453 found = cmhMM_FindNumeric( &operDesc, oper );
454 break;
455 default:
456 return( FALSE );
457 }
458
459 if( !found )
460 return( FALSE );
461
462 /* code MCC and MNC */
463 sim_plmn[0] = (operDesc.mcc & 0xf00) >> 8;
464 sim_plmn[0] |= (operDesc.mcc & 0x0f0) ;
465 sim_plmn[1] = (operDesc.mcc & 0x00f) ;
466 sim_plmn[1] |= (operDesc.mnc & 0x00f) << 4;
467 sim_plmn[2] = (operDesc.mnc & 0xf00) >> 8;
468 sim_plmn[2] |= (operDesc.mnc & 0x0f0) ;
469
470 return( TRUE );
471 }
472
473 /*
474 +--------------------------------------------------------------------+
475 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
476 | STATE : code ROUTINE : cmhSIM_FillPlmnSelList |
477 +--------------------------------------------------------------------+
478
479 PURPOSE : Fills in the CPOL list out of EF PLMNsel and returns the
480 last written index.
481 */
482 GLOBAL SHORT cmhSIM_FillPlmnSelList ( UBYTE index,
483 T_ACI_CPOL_FRMT frmt,
484 T_ACI_CPOL_OPDESC* operLst,
485 UBYTE length,
486 UBYTE* pData )
487 {
488 BOOL found; /* cmhMM_FindXXX found an entry */
489 UBYTE idx; /* holds list index */
490 SHORT off; /* holds PLMNsel offset */
491 SHORT lastIdx; /* holds last index written to list */
492 SHORT mcc; /* holds mcc value */
493 SHORT mnc; /* holds mnc value */
494 T_OPER_ENTRY OpDsc; /* operator description */
495
496 /*
497 *-----------------------------------------------------------------
498 * calculate PLMNsel offset
499 *-----------------------------------------------------------------
500 */
501 off = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
502
503 /*
504 *-----------------------------------------------------------------
505 * fill the preferred operator list
506 *-----------------------------------------------------------------
507 */
508 idx = 0;
509 lastIdx = ACI_NumParmNotPresent;
510
511 do
512 {
513 /* get mnc and mcc out of PLMNsel field */
514 cmhSIM_getMncMccFrmPLMNsel( (pData+off), &mcc, & mnc );
515
516 /* end of PLMNsel field */
517 if( off >= length )
518 {
519 operLst[idx].index = ACI_NumParmNotPresent;
520 operLst[idx].format = CPOL_FRMT_NotPresent;
521 operLst[idx].oper[0] = 0x0;
522 break;
523 }
524
525 /* valid entry */
526 if( !(mcc < 0 AND mnc < 0) )
527 {
528 operLst[idx].index = index;
529 operLst[idx].format = frmt;
530
531 found = cmhMM_FindPLMN( &OpDsc, mcc, mnc, NOT_PRESENT_16BIT, FALSE);
532
533 switch( frmt )
534 {
535 case( CPOL_FRMT_Long ):
536 if (OpDsc.pnn)
537 {
538 if (OpDsc.long_len)
539 {
540 switch (OpDsc.long_ext_dcs>>4 & 0x07)
541 {
542 case 0x00:
543 utl_cvtPnn7To8((UBYTE *)OpDsc.longName,
544 OpDsc.long_len,
545 OpDsc.long_ext_dcs,
546 (UBYTE *)operLst[idx].oper);
547 break;
548 case 0x01:
549 TRACE_ERROR ("ERROR: Unhandled UCS2");
550 break;
551 default:
552 TRACE_ERROR ("ERROR: Unknown DCS");
553 break;
554 }
555 }
556 else
557 {
558 operLst[idx].oper[0] = '\0';
559 }
560 }
561 else
562 {
563 /* MAX_LONG_OPER_LEN <= MAX_ALPHA_OPER_LEN, no length check needed */
564 strcpy( operLst[idx].oper, OpDsc.longName );
565 }
566 break;
567
568 case( CPOL_FRMT_Short ):
569 if (OpDsc.pnn)
570 {
571 if (OpDsc.shrt_len)
572 {
573 switch (OpDsc.shrt_ext_dcs>>4 & 0x07)
574 {
575 case 0x00:
576 utl_cvtPnn7To8((UBYTE *)OpDsc.shrtName,
577 OpDsc.shrt_len,
578 OpDsc.shrt_ext_dcs,
579 (UBYTE *)operLst[idx].oper);
580 break;
581 case 0x01:
582 TRACE_ERROR ("ERROR: Unhandled UCS2");
583 break;
584 default:
585 TRACE_ERROR ("ERROR: Unknown DCS");
586 break;
587 }
588 }
589 else
590 {
591 operLst[idx].oper[0] = '\0';
592 }
593 }
594 else
595 {
596 /* MAX_SHRT_OPER_LEN <= MAX_ALPHA_OPER_LEN, no length check needed */
597 strcpy( operLst[idx].oper, OpDsc.shrtName );
598 }
599 break;
600
601 case( CPOL_FRMT_Numeric ):
602 if ((mnc & 0x00F) EQ 0xF)
603 sprintf (operLst[idx].oper, "%03X%02X", mcc, (mnc & 0xff0) >> 4);
604 else
605 sprintf (operLst[idx].oper, "%03X%03X", mcc, mnc);
606 break;
607 }
608 idx++;
609 lastIdx = index;
610 }
611
612 off += ACI_LEN_PLMN_SEL_NTRY;
613 index++;
614
615 } while( idx < MAX_OPER );
616
617 return( lastIdx );
618 }
619
620 /*
621 +--------------------------------------------------------------------+
622 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
623 | STATE : code ROUTINE : cmhSIM_UsdPlmnSelNtry |
624 +--------------------------------------------------------------------+
625
626 PURPOSE : Counts the used entries of the preferred PLMN list and
627 returns the number of used entries.
628 */
629 GLOBAL SHORT cmhSIM_UsdPlmnSelNtry ( UBYTE length,
630 UBYTE* pData )
631 {
632 UBYTE idx; /* holds list index */
633 SHORT off; /* holds PLMNsel offset */
634 UBYTE maxNtry; /* holds the maximum number of entries */
635 SHORT used; /* holds number of used entries */
636 SHORT mcc; /* holds mcc value */
637 SHORT mnc; /* holds mnc value */
638
639 /*
640 *-----------------------------------------------------------------
641 * count the used entries
642 *-----------------------------------------------------------------
643 */
644 maxNtry = length / ACI_LEN_PLMN_SEL_NTRY;
645
646 for( idx = 0, used = 0, off = 0;
647 idx < maxNtry;
648 idx++, off += ACI_LEN_PLMN_SEL_NTRY )
649 {
650 /* get mnc and mcc out of PLMNsel field */
651 cmhSIM_getMncMccFrmPLMNsel( (pData+off), &mcc, & mnc );
652
653 /* valid entry */
654 if( !(mcc < 0 AND mnc < 0) )
655 {
656 used++;
657 }
658 }
659
660 return( used );
661 }
662
663 /*
664 +--------------------------------------------------------------------+
665 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
666 | STATE : code ROUTINE : cmhSIM_CmpctPlmnSel |
667 +--------------------------------------------------------------------+
668
669 PURPOSE : Shoves entries of preferred PLMN list to remove empty
670 entries of the list.
671 */
672 GLOBAL void cmhSIM_CmpctPlmnSel ( UBYTE length, UBYTE* pData )
673 {
674 UBYTE maxNtry; /* holds the maximum number of entries */
675 UBYTE lstIdx; /* holds list index */
676 UBYTE* dstNtry; /* points to destination entry index */
677
678 /*
679 *-----------------------------------------------------------------
680 * compact the list
681 *-----------------------------------------------------------------
682 */
683 lstIdx = 0;
684 dstNtry = pData;
685
686 maxNtry = length / ACI_LEN_PLMN_SEL_NTRY;
687
688 while( lstIdx < maxNtry )
689 {
690 if(memcmp( pData, PLMNselEmpty, sizeof(PLMNselEmpty)))
691 {
692 if( pData NEQ dstNtry )
693 {
694 memcpy( dstNtry, pData, ACI_LEN_PLMN_SEL_NTRY );
695 memcpy( pData, PLMNselEmpty, ACI_LEN_PLMN_SEL_NTRY);
696 }
697 dstNtry += ACI_LEN_PLMN_SEL_NTRY;
698 }
699 lstIdx++;
700 pData += ACI_LEN_PLMN_SEL_NTRY;
701 }
702 }
703
704 /*
705 +--------------------------------------------------------------------+
706 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
707 | STATE : code ROUTINE : cmhSIM_ReqPlmnSel |
708 +--------------------------------------------------------------------+
709
710 PURPOSE : This function starts reading of EF PLMN SEL from SIM.
711 */
712 GLOBAL T_ACI_RETURN cmhSIM_ReqPlmnSel ( T_ACI_CMD_SRC srcId )
713 {
714 T_ACI_RETURN ret = AT_FAIL;
715 SHORT table_id;
716
717 TRACE_FUNCTION ("cmhSIM_ReqPlmnSel()");
718
719 /*
720 *-----------------------------------------------------------------
721 * request table id for SIM SAP access
722 *-----------------------------------------------------------------
723 */
724 table_id = psaSIM_atbNewEntry();
725
726 if(table_id NEQ NO_ENTRY)
727 {
728 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
729 simShrdPrm.atb[table_id].reqDataFld = SIM_PLMNSEL;
730 simShrdPrm.atb[table_id].dataOff = 0;
731 /* length is variable */
732 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
733 simShrdPrm.atb[table_id].recMax = ACI_LEN_PLMN_SEL_FLD;
734 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
735 simShrdPrm.atb[table_id].exchData = CPOLSimEfData;
736 simShrdPrm.atb[table_id].rplyCB = cmhSIM_RdCnfPlmnSel;
737
738 simShrdPrm.aId = table_id;
739
740 simEntStat.curCmd = AT_CMD_CPOL;
741 simEntStat.entOwn = simShrdPrm.owner = srcId;
742
743 if(psaSIM_AccessSIMData() < 0)
744 {
745 TRACE_EVENT("FATAL ERROR psaSIM in +CPOL");
746 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
747 }
748 else
749 {
750 ret = AT_EXCT;
751 }
752 }
753
754 return ( ret );
755 }
756
757 /*
758 +--------------------------------------------------------------------+
759 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
760 | STATE : code ROUTINE : cmhSIM_UpdPlmnSel |
761 +--------------------------------------------------------------------+
762
763 PURPOSE : This function updates the indexed EF PLMN SEL entry and
764 writes the field to the SIM.
765 */
766 GLOBAL T_ACI_RETURN cmhSIM_UpdPlmnSel ( T_ACI_CMD_SRC srcId,
767 SHORT index,
768 UBYTE *plmn,
769 T_ACI_CPOL_MOD mode )
770 {
771 SHORT off; /* holds EF offset */
772 SHORT cpyOff; /* holds offset for copy operation */
773 UBYTE maxIdx; /* holds maximum number of index */
774
775 TRACE_FUNCTION ("cmhSIM_UpdPlmnSel()");
776
777 /*
778 *-----------------------------------------------------------------
779 * update EF PLMNsel RAM copy
780 *-----------------------------------------------------------------
781 */
782 maxIdx = CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY;
783
784 off = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
785
786 if( mode EQ CPOL_MOD_Insert AND index < maxIdx )
787 {
788 cmhSIM_CmpctPlmnSel ( CPOLSimEfDataLen, CPOLSimEfData );
789
790 cpyOff = (maxIdx-1) * ACI_LEN_PLMN_SEL_NTRY;
791
792 cpyOff -= ACI_LEN_PLMN_SEL_NTRY; /* need not copy since last index will fall out of list! */
793
794 while( cpyOff >= off AND cpyOff >= 0 )
795 {
796 memcpy( CPOLSimEfData+cpyOff+ACI_LEN_PLMN_SEL_NTRY,
797 CPOLSimEfData+cpyOff, ACI_LEN_PLMN_SEL_NTRY );
798
799 cpyOff -= ACI_LEN_PLMN_SEL_NTRY;
800 }
801 }
802
803 memcpy( CPOLSimEfData+off, plmn, ACI_LEN_PLMN_SEL_NTRY );
804
805 return ( cmhSIM_WritePlmnSel( srcId ));
806 }
807
808 /*
809 +--------------------------------------------------------------------+
810 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
811 | STATE : code ROUTINE : cmhSIM_FndEmptyPlmnSel |
812 +--------------------------------------------------------------------+
813
814 PURPOSE : This function searches for an empty entry in EF PLMN SEL,
815 fills it and writes the field to the SIM.
816 */
817 GLOBAL T_ACI_RETURN cmhSIM_FndEmptyPlmnSel ( T_ACI_CMD_SRC srcId,
818 UBYTE *plmn )
819 {
820 UBYTE maxNtry; /* holds maximum number of entries */
821 SHORT off; /* holds EF offset */
822
823 TRACE_FUNCTION ("cmhSIM_FndEmptyPlmnSel()");
824
825 /*
826 *-----------------------------------------------------------------
827 * search for an empty entry, and update
828 *-----------------------------------------------------------------
829 */
830 maxNtry = CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY;
831
832 for( off = 0; maxNtry > 0; off += ACI_LEN_PLMN_SEL_NTRY, maxNtry-- )
833 {
834 if( !memcmp( CPOLSimEfData+off, PLMNselEmpty,
835 ACI_LEN_PLMN_SEL_NTRY ))
836 {
837 memcpy( CPOLSimEfData+off, plmn, ACI_LEN_PLMN_SEL_NTRY );
838
839 return ( cmhSIM_WritePlmnSel( srcId ));
840 }
841 }
842
843 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFull );
844 return( AT_FAIL );
845 }
846
847 /*
848 +--------------------------------------------------------------------+
849 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
850 | STATE : code ROUTINE : cmhSIM_DelPlmnSel |
851 +--------------------------------------------------------------------+
852
853 PURPOSE : This function updates the indexed EF PLMN SEL entry and
854 writes the field to the SIM.
855 */
856 GLOBAL T_ACI_RETURN cmhSIM_DelPlmnSel ( T_ACI_CMD_SRC srcId,
857 SHORT index,
858 T_ACI_CPOL_MOD mode )
859 {
860 SHORT off; /* holds EF offset */
861
862 TRACE_FUNCTION ("cmhSIM_DelPlmnSel()");
863
864 /*
865 *-----------------------------------------------------------------
866 * delete entry in EF PLMNsel RAM copy
867 *-----------------------------------------------------------------
868 */
869
870 off = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
871
872 memcpy( CPOLSimEfData+off, PLMNselEmpty, ACI_LEN_PLMN_SEL_NTRY );
873
874 if( mode EQ CPOL_MOD_CompactList )
875
876 cmhSIM_CmpctPlmnSel ( CPOLSimEfDataLen, CPOLSimEfData );
877
878 return ( cmhSIM_WritePlmnSel( srcId ));
879 }
880
881 /*
882 +--------------------------------------------------------------------+
883 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
884 | STATE : code ROUTINE : cmhSIM_ChgPlmnSel |
885 +--------------------------------------------------------------------+
886
887 PURPOSE : This function exchanges the indexed EF PLMN SEL entries and
888 writes the field to the SIM.
889 */
890 GLOBAL T_ACI_RETURN cmhSIM_ChgPlmnSel ( T_ACI_CMD_SRC srcId,
891 SHORT index,
892 SHORT index2 )
893 {
894 SHORT off1, off2; /* holds EF offset */
895 UBYTE plmn1[ACI_LEN_PLMN_SEL_NTRY]; /* buffers PLMN 1 */
896 UBYTE plmn2[ACI_LEN_PLMN_SEL_NTRY]; /* buffers PLMN 2 */
897
898 TRACE_FUNCTION ("cmhSIM_ChgPlmnSel()");
899
900 /*
901 *-----------------------------------------------------------------
902 * change entries in EF PLMNsel RAM copy
903 *-----------------------------------------------------------------
904 */
905
906 off1 = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
907 off2 = (index2-1) * ACI_LEN_PLMN_SEL_NTRY;
908
909 memcpy( plmn1, CPOLSimEfData+off1, ACI_LEN_PLMN_SEL_NTRY );
910 memcpy( plmn2, CPOLSimEfData+off2, ACI_LEN_PLMN_SEL_NTRY );
911
912 memcpy( CPOLSimEfData+off1, plmn2, ACI_LEN_PLMN_SEL_NTRY );
913 memcpy( CPOLSimEfData+off2, plmn1, ACI_LEN_PLMN_SEL_NTRY );
914
915 return ( cmhSIM_WritePlmnSel( srcId ));
916 }
917
918 /*
919 +--------------------------------------------------------------------+
920 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
921 | STATE : code ROUTINE : cmhSIM_WritePlmnSel|
922 +--------------------------------------------------------------------+
923
924 PURPOSE : This function starts writing of EF PLMN SEL to SIM.
925 */
926 GLOBAL T_ACI_RETURN cmhSIM_WritePlmnSel ( T_ACI_CMD_SRC srcId )
927 {
928 T_ACI_RETURN ret = AT_FAIL;
929 SHORT table_id;
930
931 TRACE_FUNCTION ("cmhSIM_WritePlmnSel()");
932
933 /*
934 *-----------------------------------------------------------------
935 * request table id for SIM SAP access
936 *-----------------------------------------------------------------
937 */
938 table_id = psaSIM_atbNewEntry();
939
940 if(table_id NEQ NO_ENTRY)
941 {
942 simShrdPrm.atb[table_id].accType = ACT_WR_DAT;
943 simShrdPrm.atb[table_id].reqDataFld = SIM_PLMNSEL;
944 simShrdPrm.atb[table_id].dataOff = 0;
945 /* length is variable */
946 simShrdPrm.atb[table_id].dataLen = CPOLSimEfDataLen;
947 simShrdPrm.atb[table_id].recMax = NOT_PRESENT_8BIT;
948 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
949 simShrdPrm.atb[table_id].exchData = CPOLSimEfData;
950 simShrdPrm.atb[table_id].rplyCB = cmhSIM_WrCnfPlmnSel;
951
952 simShrdPrm.aId = table_id;
953
954 simEntStat.curCmd = AT_CMD_CPOL;
955 simEntStat.entOwn = simShrdPrm.owner = srcId;
956
957 if(psaSIM_AccessSIMData() < 0)
958 {
959 TRACE_EVENT("FATAL ERROR psaSIM in +CPOL");
960 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
961 }
962 else
963 {
964 ret = AT_EXCT;
965 }
966 }
967
968 return ( ret );
969 }
970
971 /*
972 +--------------------------------------------------------------------+
973 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
974 | STATE : code ROUTINE : cmhSIM_WriteTranspEF |
975 +--------------------------------------------------------------------+
976
977 PURPOSE : This function starts writing of a transparent EF to SIM.
978 (SIM only busy with valid 'srcId')
979 */
980 GLOBAL T_ACI_RETURN cmhSIM_WriteTranspEF (T_ACI_CMD_SRC srcId,
981 T_ACI_AT_CMD cmd,
982 USHORT datafield,
983 USHORT offset,
984 UBYTE datalen,
985 UBYTE * exchData,
986 void (*rplyCB)(SHORT))
987 {
988 T_ACI_RETURN ret = AT_FAIL;
989 SHORT table_id;
990
991 TRACE_FUNCTION ("cmhSIM_WriteTranspEF()");
992
993 /*
994 *-----------------------------------------------------------------
995 * request table id for SIM SAP access
996 *-----------------------------------------------------------------
997 */
998 table_id = psaSIM_atbNewEntry();
999
1000 if(table_id NEQ NO_ENTRY)
1001 {
1002 simShrdPrm.atb[table_id].accType = ACT_WR_DAT;
1003 simShrdPrm.atb[table_id].reqDataFld = datafield;
1004 simShrdPrm.atb[table_id].dataOff = offset;
1005 simShrdPrm.atb[table_id].recNr = 0;
1006 simShrdPrm.atb[table_id].dataLen = datalen;
1007 simShrdPrm.atb[table_id].recMax = NOT_PRESENT_8BIT;
1008 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1009 simShrdPrm.atb[table_id].exchData = exchData;
1010 simShrdPrm.atb[table_id].rplyCB = rplyCB;
1011
1012 simShrdPrm.aId = table_id;
1013
1014 if (srcId NEQ CMD_SRC_NONE)
1015 {
1016 simEntStat.curCmd = cmd;
1017 simEntStat.entOwn = simShrdPrm.owner = srcId;
1018 }
1019 if(psaSIM_AccessSIMData() < 0)
1020 {
1021 TRACE_EVENT("FATAL ERROR psaSIM");
1022 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1023 }
1024 else
1025 {
1026 ret = AT_EXCT;
1027 }
1028 }
1029
1030 return ( ret );
1031 }
1032
1033 /*
1034 +--------------------------------------------------------------------+
1035 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1036 | STATE : code ROUTINE : cmhSIM_ReadTranspEF |
1037 +--------------------------------------------------------------------+
1038
1039 PURPOSE : This function starts reading of EF PLMN SEL from SIM.
1040 (SIM only busy with valid 'srcId')
1041 */
1042 GLOBAL T_ACI_RETURN cmhSIM_ReadTranspEF ( T_ACI_CMD_SRC srcId,
1043 T_ACI_AT_CMD cmd,
1044 USHORT datafield,
1045 USHORT offset,
1046 UBYTE explen,
1047 UBYTE * exchData,
1048 void (*rplyCB)(SHORT))
1049 {
1050 T_ACI_RETURN ret = AT_FAIL;
1051 SHORT table_id;
1052
1053 TRACE_FUNCTION ("cmhSIM_ReadTranspEF()");
1054
1055 /*
1056 *-----------------------------------------------------------------
1057 * request table id for SIM SAP access
1058 *-----------------------------------------------------------------
1059 */
1060 table_id = psaSIM_atbNewEntry();
1061
1062 if(table_id NEQ NO_ENTRY)
1063 {
1064 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
1065 simShrdPrm.atb[table_id].reqDataFld = datafield;
1066 simShrdPrm.atb[table_id].dataOff = offset;
1067 simShrdPrm.atb[table_id].recNr = 0;
1068 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
1069 simShrdPrm.atb[table_id].recMax = explen;
1070 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1071 simShrdPrm.atb[table_id].exchData = exchData;
1072 simShrdPrm.atb[table_id].rplyCB = rplyCB;
1073
1074 simShrdPrm.aId = table_id;
1075
1076 if (srcId NEQ CMD_SRC_NONE)
1077 {
1078 simEntStat.curCmd = cmd;
1079 simEntStat.entOwn = simShrdPrm.owner = srcId;
1080 }
1081 if(psaSIM_AccessSIMData() < 0)
1082 {
1083 TRACE_EVENT("FATAL ERROR psaSIM");
1084 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1085 }
1086 else
1087 {
1088 ret = AT_EXCT;
1089 }
1090 }
1091
1092 return ( ret );
1093 }
1094
1095 /*
1096 +--------------------------------------------------------------------+
1097 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1098 | STATE : code ROUTINE : cmhSIM_WriteRecordEF |
1099 +--------------------------------------------------------------------+
1100
1101 PURPOSE : This function starts writing of a transparent EF to SIM.
1102 (SIM only busy with valid 'srcId')
1103 */
1104 GLOBAL T_ACI_RETURN cmhSIM_WriteRecordEF (T_ACI_CMD_SRC srcId,
1105 T_ACI_AT_CMD cmd,
1106 USHORT datafield,
1107 UBYTE record,
1108 UBYTE datalen,
1109 UBYTE * exchData,
1110 void (*rplyCB)(SHORT))
1111 {
1112 T_ACI_RETURN ret = AT_FAIL;
1113 SHORT table_id;
1114
1115 TRACE_FUNCTION ("cmhSIM_WriteRecordEF()");
1116
1117 /*
1118 *-----------------------------------------------------------------
1119 * request table id for SIM SAP access
1120 *-----------------------------------------------------------------
1121 */
1122 table_id = psaSIM_atbNewEntry();
1123
1124 if(table_id NEQ NO_ENTRY)
1125 {
1126 simShrdPrm.atb[table_id].accType = ACT_WR_REC;
1127 simShrdPrm.atb[table_id].reqDataFld = datafield;
1128 simShrdPrm.atb[table_id].dataOff = 0;
1129 simShrdPrm.atb[table_id].dataLen = datalen;
1130 simShrdPrm.atb[table_id].recNr = record;
1131 simShrdPrm.atb[table_id].recMax = NOT_PRESENT_8BIT;
1132 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1133 simShrdPrm.atb[table_id].exchData = exchData;
1134 simShrdPrm.atb[table_id].rplyCB = rplyCB;
1135
1136 simShrdPrm.aId = table_id;
1137
1138 if (srcId NEQ CMD_SRC_NONE)
1139 {
1140 simEntStat.curCmd = cmd;
1141 simEntStat.entOwn = simShrdPrm.owner = srcId;
1142 }
1143 if(psaSIM_AccessSIMData() < 0)
1144 {
1145 TRACE_EVENT("FATAL ERROR psaSIM");
1146 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1147 }
1148 else
1149 {
1150 ret = AT_EXCT;
1151 }
1152 }
1153
1154 return ( ret );
1155 }
1156
1157 /*
1158 +--------------------------------------------------------------------+
1159 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1160 | STATE : code ROUTINE : cmhSIM_ReadRecordEF |
1161 +--------------------------------------------------------------------+
1162
1163 PURPOSE : This function starts reading of EF PLMN SEL from SIM.
1164 (SIM only busy with valid 'srcId')
1165 */
1166 GLOBAL T_ACI_RETURN cmhSIM_ReadRecordEF ( T_ACI_CMD_SRC srcId,
1167 T_ACI_AT_CMD cmd,
1168 USHORT datafield,
1169 UBYTE record,
1170 UBYTE explen,
1171 UBYTE * exchData,
1172 void (*rplyCB)(SHORT))
1173 {
1174 T_ACI_RETURN ret = AT_FAIL;
1175 SHORT table_id;
1176
1177 TRACE_FUNCTION ("cmhSIM_ReadRecordEF()");
1178
1179 /*
1180 *-----------------------------------------------------------------
1181 * request table id for SIM SAP access
1182 *-----------------------------------------------------------------
1183 */
1184 table_id = psaSIM_atbNewEntry();
1185
1186 if(table_id NEQ NO_ENTRY)
1187 {
1188 simShrdPrm.atb[table_id].accType = ACT_RD_REC;
1189 simShrdPrm.atb[table_id].reqDataFld = datafield;
1190 simShrdPrm.atb[table_id].dataOff = 0;
1191 simShrdPrm.atb[table_id].recNr = record;
1192 /* for CPHS (and this shall probably be extended to other SIM
1193 access operations) dataLen passed in SIM_READ_RECORD_REQ should
1194 be NOT_PRESENT_8BIT (to let the SIM entity handling this length:
1195 ACI does not know it anyway...). Yet size of received data should
1196 be checked when conf is received (to avoid crashes with exotic SIM cards */
1197 #ifdef FF_CPHS
1198 if(cmd EQ AT_CMD_CPHS)
1199 {
1200 simShrdPrm.atb[table_id].check_dataLen = TRUE;
1201 }
1202 #endif /* FF_CPHS */
1203 simShrdPrm.atb[table_id].dataLen = explen;
1204 simShrdPrm.atb[table_id].recMax = NOT_PRESENT_8BIT;
1205 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1206 simShrdPrm.atb[table_id].exchData = exchData;
1207 simShrdPrm.atb[table_id].rplyCB = rplyCB;
1208
1209 simShrdPrm.aId = table_id;
1210
1211 if (srcId NEQ CMD_SRC_NONE)
1212 {
1213 simEntStat.curCmd = cmd;
1214 simEntStat.entOwn = simShrdPrm.owner = srcId;
1215 }
1216 if(psaSIM_AccessSIMData() < 0)
1217 {
1218 TRACE_EVENT("FATAL ERROR psaSIM");
1219 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1220 }
1221 else
1222 {
1223 ret = AT_EXCT;
1224 }
1225 }
1226
1227 return ( ret );
1228 }
1229
1230 /*
1231 +--------------------------------------------------------------------+
1232 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1233 | STATE : code ROUTINE : SimStatusError |
1234 +--------------------------------------------------------------------+
1235
1236 PURPOSE : sync_notification: TRUE if notification through asynchrone callback
1237 FALSE if notif. whithin synchrone context.
1238
1239 */
1240 #define GetSIMError (1)
1241 #define CheckSimStatus (0)
1242
1243 LOCAL T_ACI_RETURN SimStatusError ( T_ACI_CMD_SRC srcBuf,
1244 T_ACI_AT_CMD cmdBuf,
1245 UBYTE sync_notification)
1246 {
1247 T_ACI_CPIN_RSLT code = CPIN_RSLT_NotPresent;
1248 T_ACI_CME_ERR err = CME_ERR_NotPresent;
1249
1250 /* trace if needed... TRACE_EVENT_P1("simShrdPrm.SIMStat: %d", simShrdPrm.SIMStat); */
1251
1252 switch( simShrdPrm.SIMStat )
1253 {
1254 case( SS_OK ):
1255 if ( qAT_PlusCPIN(CMD_SRC_LCL, &code) EQ AT_CMPL )
1256 {
1257 switch ( code )
1258 {
1259 case CPIN_RSLT_PhSimPinReq:
1260 err = CME_ERR_PhSimPinReq;
1261 break;
1262 case CPIN_RSLT_SimPinReq:
1263 err = CME_ERR_SimPinReq;
1264 break;
1265 case CPIN_RSLT_SimPin2Req:
1266 err = CME_ERR_SimPin2Req;
1267 break;
1268 case(CPIN_RSLT_PhFSimPinReq):
1269 err = CME_ERR_PhFSimPinReq;
1270 break;
1271 case(CPIN_RSLT_PhFSimPukReq):
1272 err = CME_ERR_PhFSimPukReq;
1273 break;
1274 case(CPIN_RSLT_PhNetPinReq):
1275 err = CME_ERR_NetworkPersPinReq;
1276 break;
1277 case(CPIN_RSLT_PhNetPukReq):
1278 err = CME_ERR_NetworkPersPukReq;
1279 break;
1280 case(CPIN_RSLT_PhNetSubPinReq):
1281 err = CME_ERR_NetworkSubsetPersPinReq;
1282 break;
1283 case(CPIN_RSLT_PhNetSubPukReq):
1284 err = CME_ERR_NetworkSubsetPersPukReq;
1285 break;
1286 case(CPIN_RSLT_PhSPPinReq):
1287 err = CME_ERR_ProviderPersPinReq;
1288 break;
1289 case(CPIN_RSLT_PhSPPukReq):
1290 err = CME_ERR_ProviderPersPukReq;
1291 break;
1292 case(CPIN_RSLT_PhCorpPinReq):
1293 err = CME_ERR_CorporatePersPinReq;
1294 break;
1295 case(CPIN_RSLT_PhCorpPukReq):
1296 err = CME_ERR_CorporatePersPukReq;
1297 break;
1298
1299 }
1300 }
1301 break;
1302
1303 case( SS_BLKD ):
1304 if ( qAT_PlusCPIN(CMD_SRC_LCL, &code) EQ AT_CMPL )
1305 {
1306 switch ( code )
1307 {
1308 case CPIN_RSLT_SimPukReq:
1309 err = CME_ERR_SimPukReq;
1310 break;
1311 case CPIN_RSLT_SimPuk2Req:
1312 err = CME_ERR_SimPuk2Req;
1313 break;
1314 }
1315 }
1316 break;
1317
1318 case( SS_INV ):
1319 err = CME_ERR_SimWrong;
1320 break;
1321
1322 case( SS_URCHB ):
1323 err = CME_ERR_SimFail;
1324 break;
1325
1326 default: /* unexpected result */
1327 break;
1328 }
1329
1330 if( err EQ CME_ERR_NotPresent )
1331 {
1332 return ( AT_FAIL );
1333 }
1334 else
1335 {
1336 TRACE_EVENT_P1("err: %d", err);
1337 }
1338
1339 switch( sync_notification )
1340 {
1341 case( GetSIMError ):
1342 R_AT( RAT_CME, srcBuf ) ( cmdBuf, err );
1343 break;
1344
1345 case( CheckSimStatus ):
1346 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, err );
1347 break;
1348 }
1349 return( AT_CMPL );
1350 }
1351
1352 /*
1353 +--------------------------------------------------------------------+
1354 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1355 | STATE : code ROUTINE : cmhSIM_GetSIMError |
1356 +--------------------------------------------------------------------+
1357
1358 PURPOSE : This function is used to request the SIM error status.
1359
1360 */
1361 GLOBAL T_ACI_RETURN cmhSIM_GetSIMError ( T_ACI_CMD_SRC srcBuf,
1362 T_ACI_AT_CMD cmdBuf )
1363 {
1364 TRACE_FUNCTION("cmhSIM_GetSIMError");
1365
1366 return(SimStatusError( srcBuf, cmdBuf, GetSIMError ));
1367 }
1368
1369 /*
1370 +--------------------------------------------------------------------+
1371 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1372 | STATE : code ROUTINE : cmhSIM_GetSIMError |
1373 +--------------------------------------------------------------------+
1374
1375 PURPOSE : This function is used to check the SIM pin status.
1376
1377 */
1378 GLOBAL T_ACI_RETURN cmhSIM_CheckSimPinStatus ( T_ACI_CMD_SRC srcBuf,
1379 T_ACI_AT_CMD cmdBuf )
1380 {
1381 TRACE_FUNCTION("cmhSIM_CheckSimPinStatus");
1382
1383 return(SimStatusError( srcBuf, cmdBuf, CheckSimStatus ));
1384 }
1385
1386 /*
1387 +--------------------------------------------------------------------+
1388 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
1389 | STATE : code ROUTINE : cmhSIM_ReqLanguage |
1390 +--------------------------------------------------------------------+
1391
1392 PURPOSE : This function starts reading of ELP field from SIM.
1393 */
1394 GLOBAL T_ACI_RETURN cmhSIM_ReqLanguage ( T_ACI_CMD_SRC srcId)
1395
1396 {
1397 T_ACI_RETURN ret = AT_FAIL;
1398 SHORT table_id;
1399
1400 TRACE_FUNCTION ("cmhSIM_ReqLanguage()");
1401
1402 /*
1403 *-----------------------------------------------------------------
1404 * request table id for SIM SAP access
1405 *-----------------------------------------------------------------
1406 */
1407 table_id = psaSIM_atbNewEntry();
1408
1409 if(table_id NEQ NO_ENTRY)
1410 {
1411 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
1412 simShrdPrm.atb[table_id].reqDataFld = SIM_ELP;
1413 simShrdPrm.atb[table_id].dataOff = 0;
1414 /* length is variable */
1415 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
1416 simShrdPrm.atb[table_id].recMax = ACI_LEN_LAN_FLD;
1417 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1418 simShrdPrm.atb[table_id].exchData = CLANSimEfData;
1419 simShrdPrm.atb[table_id].rplyCB = cmhSIM_RdCnfLangELP;
1420
1421
1422 simShrdPrm.aId = table_id;
1423
1424 simEntStat.curCmd = AT_CMD_CLAN;
1425 simEntStat.entOwn = simShrdPrm.owner = srcId;
1426
1427 if(psaSIM_AccessSIMData() < 0)
1428 {
1429 TRACE_EVENT("FATAL ERROR psaSIM in +CLAN");
1430 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1431 }
1432 else
1433 {
1434 ret = AT_EXCT;
1435 }
1436 }
1437
1438 return ( ret );
1439 }
1440
1441
1442 /*
1443 +-----------------------------------------------------------------------+
1444 | PROJECT : MODULE : SAT |
1445 | STATE : code ROUTINE : cmhSIM_ReqLanguagePrf |
1446 +-----------------------------------------------------------------------+
1447
1448 PURPOSE : This function starts reading of ELP field from SIM for SAT feature LS.
1449 */
1450 GLOBAL BOOL cmhSIM_ReqLanguagePrf(void)
1451
1452 {
1453 BOOL ret = FALSE;
1454 SHORT table_id;
1455
1456 TRACE_FUNCTION ("cmhSIM_ReqLanguagePrf()");
1457
1458 /*
1459 *-----------------------------------------------------------------
1460 * request table id for SIM SAP access
1461 *-----------------------------------------------------------------
1462 */
1463 table_id = psaSIM_atbNewEntry();
1464
1465 if(table_id NEQ NO_ENTRY)
1466 {
1467 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
1468 simShrdPrm.atb[table_id].reqDataFld = SIM_ELP;
1469 simShrdPrm.atb[table_id].dataOff = 0;
1470 // length is variable
1471 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
1472 simShrdPrm.atb[table_id].recMax = ACI_LEN_LAN_FLD;
1473 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1474 simShrdPrm.atb[table_id].exchData = CLANSimEfData;
1475 simShrdPrm.atb[table_id].rplyCB = cmhSIM_RdCnfLangPrfELP;
1476
1477
1478 simShrdPrm.aId = table_id;
1479
1480
1481 if(psaSIM_AccessSIMData() < 0)
1482 {
1483 return ( ret );
1484 }
1485 else
1486 {
1487 ret = TRUE;
1488 }
1489 }
1490
1491 return ( ret );
1492 }
1493
1494
1495
1496 /*
1497 +--------------------------------------------------------------------+
1498 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1499 | STATE : code ROUTINE : getSupLangFromPCM |
1500 +--------------------------------------------------------------------+
1501
1502 PURPOSE : get Supported Language from PCM and compare it
1503 with Language table.
1504 */
1505 GLOBAL T_ACI_RETURN getSupLangFromPCM ( T_ACI_LAN_SUP *lanlst, SHORT *lastIdx)
1506
1507 {
1508 CHAR *ef = EF_MSSUP_ID;
1509 pcm_FileInfo_Type fileInfo;
1510 EF_MSSUP mssup;
1511 LONG value;
1512 SHORT i, idx=0;
1513 LONG bitmask = 0x01;
1514
1515 TRACE_FUNCTION ("getSupLangFromPCM()");
1516
1517 /*
1518 *-------------------------------------------------------------------
1519 * read supported language from ME
1520 *-------------------------------------------------------------------
1521 */if (pcm_GetFileInfo ( (UBYTE*)ef, &fileInfo) NEQ PCM_OK)
1522 {
1523 TRACE_EVENT("Error getting datas from PCM");
1524 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFail );
1525 return( AT_FAIL );
1526 }
1527 else
1528 {
1529 if ( pcm_ReadFile ( ( UBYTE* )ef,fileInfo.FileSize,
1530 ( UBYTE*) &mssup,
1531 &fileInfo.Version) EQ PCM_OK )
1532 {
1533 value =mssup.lng1;
1534 value |=mssup.lng2 <<8;
1535 value |=mssup.lng3 <<16;
1536
1537 for(i=0;i<MAX_LAN;i++)
1538 {
1539 if (bitmask & value)
1540 {
1541 lanlst[idx].lng =i;
1542 idx++;
1543 }
1544
1545 bitmask= bitmask<< 1;
1546 }
1547
1548 }
1549 else
1550 {
1551 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFail );
1552 return( AT_FAIL );
1553 }
1554 }
1555
1556 /*
1557 *-------------------------------------------------------------------
1558 * terminate list and set last index
1559 *-------------------------------------------------------------------
1560 */
1561 if( idx < MAX_LAN )
1562 {
1563 lanlst[idx].str = 0x0;
1564 lanlst[idx].lng = 0x0;
1565
1566 }
1567 *lastIdx = idx;
1568
1569 /*
1570 *-------------------------------------------------------------------
1571 * compare the code of supported language in PCM with
1572 * Language table to get the char code
1573 *-------------------------------------------------------------------
1574 */
1575 for(i=0;i < *lastIdx;i++)
1576 {
1577 idx=0;
1578 while (lngs[idx].str NEQ NULL AND
1579 lngs[idx].lng NEQ lanlst[i].lng)
1580 idx++;
1581
1582 if (lngs[idx].lng EQ lanlst[i].lng)
1583 lanlst[i].str=lngs[idx].str;
1584 }
1585
1586 return( AT_CMPL );
1587 }
1588
1589
1590 /*
1591 +--------------------------------------------------------------------+
1592 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1593 | STATE : code ROUTINE : checkSuppLangInELP |
1594 +--------------------------------------------------------------------+
1595
1596 PURPOSE : check if the language to be read from the EF ELP
1597 is supported in PCM
1598
1599 SupLng: is true if the language is supprted else False
1600 */
1601
1602 GLOBAL BOOL checkSuppLang (T_ACI_LAN_SUP *lanlst,
1603 SHORT lastIdx,
1604 T_ACI_LAN_SUP *clng)
1605 {
1606 USHORT i;
1607 BOOL SupLng=FALSE;
1608
1609 /*
1610 *-----------------------------------------------------------------
1611 * check if the Language from EF ELP is supported in PCM
1612 *-----------------------------------------------------------------
1613 */
1614 for(i=0;i < lastIdx;i++)
1615 {
1616 if (!strcmp(lanlst[i].str,clng->str) )
1617 {
1618 clng->lng=lanlst[i].lng;
1619 SupLng= TRUE;
1620 break;
1621 }
1622 }
1623
1624 return( SupLng );
1625 }
1626
1627 /*
1628 +--------------------------------------------------------------------+
1629 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1630 | STATE : code ROUTINE : checkSuppLangInLP |
1631 +--------------------------------------------------------------------+
1632
1633 PURPOSE : check if the language to be read from the EF LP
1634 is supported in PCM
1635
1636 SupLng: is true if the language is supprted else False
1637 */
1638
1639 GLOBAL BOOL checkSuppLangInLP(T_ACI_LAN_SUP *lanlst,SHORT lastIdx,
1640 T_ACI_LAN_SUP *clng)
1641 {
1642 USHORT i;
1643 BOOL SupLng=FALSE;
1644
1645 /*
1646 *-----------------------------------------------------------------
1647 * check if the Language from EF LP is supported in PCM
1648 *-----------------------------------------------------------------
1649 */
1650 for(i=0;i < lastIdx;i++)
1651 {
1652 if (lanlst[i].lng EQ clng->lng )
1653 {
1654 clng->str=lanlst[i].str;
1655 SupLng= TRUE;
1656 break;
1657 }
1658 }
1659
1660 return( SupLng );
1661 }
1662
1663 #if 0
1664 /*
1665 +------------------------------------------------------------------------+
1666 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
1667 | STATE : code ROUTINE : cmhSIM_LanguageLP_Update|
1668 +------------------------------------------------------------------------+
1669
1670 PURPOSE :
1671 */
1672 GLOBAL BOOL cmhSIM_LanguageLP_Update ( int ref, T_SIM_FILE_UPDATE_IND *fu)
1673 {
1674 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
1675 UBYTE i;
1676 BOOL found = FALSE;
1677
1678 char *auptr="au";
1679 CHAR *ef = EF_CLNG_ID;
1680 pcm_FileInfo_Type fileInfo;
1681 EF_CLNG lng;
1682
1683
1684 TRACE_FUNCTION ("cmhSIM_LanguageLP_Update()");
1685
1686 ownBuf = simEntStat.entOwn;
1687
1688 for (i = 0; i < (int)fu->val_nr; i++)
1689 {
1690 if (!found AND
1691 (fu->file_id[i] EQ SIM_LP))
1692 {
1693 found = TRUE;
1694 }
1695 }
1696
1697 if (found)
1698 {
1699 /*
1700 *-------------------------------------------------------------------
1701 * read supported language from ME
1702 *-------------------------------------------------------------------
1703 */
1704 if (pcm_GetFileInfo ( ( UBYTE* ) ef, &fileInfo) NEQ PCM_OK)
1705 {
1706 TRACE_EVENT("cmhSIM_LanguageLP_Update: error returned by pcm_GetFileInfo()" );
1707 return TRUE;
1708 }
1709 else
1710 {
1711
1712 if ( pcm_ReadFile ( (UBYTE*)ef,
1713 fileInfo.FileSize,
1714 (UBYTE*) &lng,
1715 &fileInfo.Version) EQ PCM_OK )
1716 {
1717 }
1718 else
1719 {
1720 TRACE_EVENT("cmhSIM_LanguageLP_Update: error returned by pcm_ReadFile()" );
1721 return TRUE;
1722 }
1723 }
1724
1725 /*
1726 *-------------------------------------------------------------------
1727 * Read EF LP from the sim if Automatic language is selected
1728 *-------------------------------------------------------------------
1729 */
1730 if (!strncmp((char*)&lng.data[0], auptr, 2))
1731 {
1732 cmhSIM_ReqLanguageLP(ownBuf); /* reading files */
1733 simShrdPrm.fuRef = (UBYTE)ref;
1734 return FALSE;
1735 }
1736 else
1737 {
1738 return TRUE;
1739 }
1740 }
1741 else
1742 {
1743 return TRUE; /* nothing to do */
1744 }
1745 }
1746 #endif
1747
1748 /*
1749 +--------------------------------------------------------------------+
1750 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
1751 | STATE : code ROUTINE : cmhSIM_ReqLanguageLP|
1752 +--------------------------------------------------------------------+
1753
1754 PURPOSE : This function starts reading of ELP OR LP field from SIM.
1755 */
1756 GLOBAL T_ACI_RETURN cmhSIM_ReqLanguageLP ( T_ACI_CMD_SRC srcId )
1757 {
1758 T_ACI_RETURN ret = AT_FAIL;
1759 SHORT table_id;
1760
1761 TRACE_FUNCTION ("cmhSIM_ReqLanguageLP()");
1762
1763 /*
1764 *-----------------------------------------------------------------
1765 * request table id for SIM SAP access
1766 *-----------------------------------------------------------------
1767 */
1768 table_id = psaSIM_atbNewEntry();
1769
1770 if(table_id NEQ NO_ENTRY)
1771 {
1772 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
1773 simShrdPrm.atb[table_id].reqDataFld = SIM_LP;
1774 simShrdPrm.atb[table_id].dataOff = 0;
1775 /* length is variable */
1776 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
1777 simShrdPrm.atb[table_id].recMax = ACI_MAX_LAN_LP_NTRY;
1778 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1779 simShrdPrm.atb[table_id].exchData = CLANSimEfDataLP;
1780 simShrdPrm.atb[table_id].rplyCB = cmhSIM_RdCnfLangLP;
1781
1782
1783 simShrdPrm.aId = table_id;
1784
1785 simEntStat.curCmd = AT_CMD_CLAN;
1786 simEntStat.entOwn = simShrdPrm.owner = srcId;
1787
1788 if(psaSIM_AccessSIMData() < 0)
1789 {
1790 TRACE_EVENT("FATAL ERROR psaSIM in +CLAN");
1791 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1792 }
1793 else
1794 {
1795 ret = AT_EXCT;
1796 }
1797 }
1798
1799 return ( ret );
1800 }
1801
1802
1803 /*
1804 +-----------------------------------------------------------------------+
1805 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMS |
1806 | STATE : code ROUTINE : cmhSIM_ReqLanguagePrfLP|
1807 +-----------------------------------------------------------------------+
1808
1809 PURPOSE : This function starts reading of LP field from SIM for SAT
1810 fetaure LS.
1811 */
1812 GLOBAL BOOL cmhSIM_ReqLanguagePrfLP (void)
1813 {
1814 BOOL ret = FALSE;
1815 SHORT table_id;
1816
1817 TRACE_FUNCTION ("cmhSIM_ReqLanguagePrfLP()");
1818
1819 /*
1820 *-----------------------------------------------------------------
1821 * request table id for SIM SAP access
1822 *-----------------------------------------------------------------
1823 */
1824 table_id = psaSIM_atbNewEntry();
1825
1826 if(table_id NEQ NO_ENTRY)
1827 {
1828 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
1829 simShrdPrm.atb[table_id].reqDataFld = SIM_LP;
1830 simShrdPrm.atb[table_id].dataOff = 0;
1831 // length is variable
1832 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
1833 simShrdPrm.atb[table_id].recMax = ACI_MAX_LAN_LP_NTRY;
1834 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1835 simShrdPrm.atb[table_id].exchData = CLANSimEfDataLP;
1836 simShrdPrm.atb[table_id].rplyCB = cmhSIM_RdCnfLangPrfLP;
1837
1838 simShrdPrm.aId = table_id;
1839
1840
1841 if(psaSIM_AccessSIMData() < 0)
1842 {
1843 return ( ret );
1844 }
1845 else
1846 {
1847 ret = TRUE;
1848 }
1849 }
1850
1851 return ( ret );
1852 }
1853
1854
1855 /*
1856 +--------------------------------------------------------------------+
1857 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1858 | STATE : code ROUTINE : cmhSIM_AD_Update |
1859 +--------------------------------------------------------------------+
1860
1861 PURPOSE : This function is used to request the SIM Administrative
1862 Data (EF_AD).
1863
1864 */
1865 GLOBAL BOOL cmhSIM_AD_Update (int ref, T_SIM_FILE_UPDATE_IND *fu)
1866 {
1867 BOOL found = FALSE;
1868 UBYTE i;
1869 TRACE_FUNCTION ("cmhSIM_AD_Update()");
1870
1871 for (i = 0; i < (int)fu->val_nr; i++)
1872 {
1873 if (!found AND (fu->file_id[i] EQ SIM_AD))
1874 {
1875 found = TRUE;
1876 }
1877 }
1878 if (found)
1879 {
1880 cmhSIM_Read_AD();
1881 simShrdPrm.fuRef = (UBYTE)ref;
1882 return FALSE; /* reading files */
1883 }
1884 else
1885 {
1886 return TRUE; /* nothing to do */
1887 }
1888 }
1889
1890
1891 /*
1892 +--------------------------------------------------------------------+
1893 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1894 | STATE : code ROUTINE : cmhSIM_Read_AD |
1895 +--------------------------------------------------------------------+
1896
1897 PURPOSE : This function is used to request the SIM Administrative
1898 Data (EF_AD).
1899
1900 */
1901 GLOBAL T_ACI_RETURN cmhSIM_Read_AD()
1902 {
1903 SHORT table_id;
1904
1905 TRACE_FUNCTION ("cmhSIM_Read_AD()");
1906
1907 table_id = psaSIM_atbNewEntry();
1908
1909 if(table_id NEQ NO_ENTRY)
1910 {
1911 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1912 simShrdPrm.atb[table_id].accType = ACT_RD_DAT;
1913 simShrdPrm.atb[table_id].reqDataFld = SIM_AD;
1914 simShrdPrm.atb[table_id].dataOff = 0;
1915 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
1916 simShrdPrm.atb[table_id].recMax = 0;
1917 simShrdPrm.atb[table_id].exchData = NULL;
1918 simShrdPrm.atb[table_id].rplyCB = cmhSIM_Read_AD_cb;
1919
1920 simShrdPrm.aId = table_id;
1921
1922 if(psaSIM_AccessSIMData() < 0)
1923 {
1924 TRACE_EVENT("FATAL ERROR");
1925 return ( AT_FAIL );
1926 }
1927
1928 return ( AT_CMPL );
1929 }
1930 return ( AT_FAIL );
1931 }
1932
1933 /*
1934 +-------------------------------------------------------------------+
1935 | PROJECT : MODULE : CMH_SIMF |
1936 | STATE : code ROUTINE : cmhSIM_EvalMNCLength |
1937 +-------------------------------------------------------------------+
1938
1939 PURPOSE : This function evaluates the MNC length by extracting MNC
1940 from IMSI and comparing it with the MNC in operListFixed.
1941 */
1942 GLOBAL UBYTE cmhSIM_EvalMNCLength(void)
1943 {
1944 UBYTE digit; /* holds 4bit digit */
1945 USHORT i; /* holds counter */
1946 SHORT sim_mcc; /* holds mcc from operListFixed */
1947 SHORT sim_mnc; /* holds mnc from operListFixed */
1948 SHORT mcc; /* holds mcc extracted from IMSI */
1949 SHORT mnc; /* holds mnc extracted from IMSI */
1950
1951 mcc = mnc = 0; /* Initialize mcc, mnc */
1952
1953 for (i = 0; i < SIZE_MCC + SIZE_MNC; i++) /* Extract MCC and MNC. */
1954 {
1955 digit = (i & 1) ?
1956 (simShrdPrm.imsi.field[(i + 1)/2] & 0x0f) :
1957 (simShrdPrm.imsi.field[(i + 1)/2] & 0xf0) >> 4;
1958 if (i < SIZE_MCC)
1959 mcc = (mcc << 4) | digit;
1960 else
1961 mnc = (mnc << 4) | digit;
1962 }
1963
1964 for( i = 0; operListFixed[i].mcc NEQ -1 AND operListFixed[i].mnc NEQ -1; i++ ) /* Evaluate mnc length */
1965 {
1966 sim_mcc = operListFixed[i].mcc;
1967 sim_mnc = operListFixed[i].mnc;
1968
1969 if ( sim_mcc EQ mcc )
1970 {
1971 if ( (sim_mnc & 0xff0) EQ (mnc & 0xff0) )
1972 {
1973 if ( (sim_mnc & 0x0f) EQ 0x0f )
1974 {
1975 return 2;
1976 }
1977 else
1978 {
1979 return 3;
1980 }
1981 }
1982 }
1983 }
1984 return NOT_PRESENT_8BIT;
1985 }
1986
1987 /*
1988 +--------------------------------------------------------------------+
1989 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
1990 | STATE : code ROUTINE : cmhSIM_Read_AD_cb |
1991 +--------------------------------------------------------------------+
1992
1993 PURPOSE : Call back for SIM read (EF_AD).
1994
1995 */
1996 void cmhSIM_Read_AD_cb(SHORT table_id)
1997 {
1998 #ifdef SIM_PERS
1999 T_SIMLOCK_STATUS sl_status;
2000 #endif
2001
2002
2003 TRACE_FUNCTION ("cmhSIM_Read_AD_cb()");
2004
2005 if ( simShrdPrm.atb[table_id].reqDataFld EQ SIM_AD )
2006 {
2007 if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
2008 {
2009 /*
2010 * byte 2 and byte 3 of EF AD have only a meaning
2011 * if the bit1 of byte 1 is set
2012 */
2013 if (simShrdPrm.atb[table_id].exchData[0] & 0x01)
2014 {
2015 if (simShrdPrm.atb[table_id].exchData[2] & 0x01)
2016 {
2017 /* ci enabled on SIM */
2018 simShrdPrm.ciSIMEnabled = TRUE;
2019 }
2020 else
2021 {
2022 /* ci disabled on SIM, don't show indications */
2023 simShrdPrm.ciSIMEnabled = FALSE;
2024 }
2025 }
2026 /* byte 4 is optional */
2027 if (simShrdPrm.atb[table_id].dataLen >= 4)
2028 {
2029 switch (simShrdPrm.atb[table_id].exchData[3] & 0x0F)
2030 {
2031 case 2: simShrdPrm.mnc_len = 2; break;
2032 case 3: simShrdPrm.mnc_len = 3; break;
2033 default: simShrdPrm.mnc_len =NOT_PRESENT_8BIT;
2034 }
2035 }
2036 else
2037 {
2038 simShrdPrm.mnc_len = NOT_PRESENT_8BIT;
2039 }
2040 if (simShrdPrm.mnc_len NEQ 3) /* Update MNC length */
2041 {
2042 simShrdPrm.mnc_len = cmhSIM_EvalMNCLength();
2043 }
2044
2045 }
2046 #ifdef SIM_TOOLKIT
2047 if (simShrdPrm.fuRef >= 0)
2048 {
2049 psaSAT_FUConfirm (simShrdPrm.fuRef,
2050 (USHORT)((simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)?
2051 SIM_FU_SUCCESS: SIM_FU_ERROR));
2052 }
2053 #endif
2054 }
2055 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2056 if(last_sim_mmi_insert_ind NEQ NULL)
2057 {
2058 #ifdef SIM_PERS
2059 aci_slock_sim_config.sim_read_ad_first_byte = simShrdPrm.atb[table_id].exchData[0] ;
2060 aci_slock_sim_init(last_sim_mmi_insert_ind);
2061 /* To set the global variable config data */
2062 aci_slock_set_CFG();
2063
2064 if(cfg_data EQ NULL)
2065 {
2066 AciSLockShrd.blocked = TRUE;
2067 cmhSIM_SIMInserted();
2068 PFREE (last_sim_mmi_insert_ind); /* 11_Apr_05 */
2069 last_sim_mmi_insert_ind= NULL;
2070 return;
2071 }
2072 aci_slock_init();
2073 sl_status = SIMLOCK_ENABLED;
2074 AciSLockShrd.pb_load = FALSE;
2075 AciSLockShrd.check_lock = SIMLOCK_CHECK_PERS;
2076 sl_status = aci_slock_checkpersonalisation(SIMLOCK_NETWORK);
2077
2078 #else
2079 /*
2080 * Start to build phonebook
2081 */
2082 pb_reset();
2083
2084 #ifdef TI_PS_FFS_PHB
2085 pb_inserted_sim (MAX_SRV_TBL,
2086 last_sim_mmi_insert_ind->sim_serv,
2087 &last_sim_mmi_insert_ind->imsi_field,
2088 last_sim_mmi_insert_ind->func,
2089 last_sim_mmi_insert_ind->phase);
2090 #else
2091 pb_build_req(last_sim_mmi_insert_ind);
2092 #endif
2093
2094 /* Request the Customer Service Profile from the SIM (EF_CPHS_CSP) */
2095 cmhSIM_Get_CSP();
2096
2097 #ifdef SIM_TOOLKIT
2098 cmhSMS_ReadCbDtaDwnl (last_sim_mmi_insert_ind);
2099 #endif
2100
2101 #ifdef FF_MMI_RIV
2102 rAT_PlusCFUNP (last_sim_mmi_insert_ind);
2103 #endif /* FF_MMI_RIV */
2104 PFREE (last_sim_mmi_insert_ind); /* 11_Apr_05 */
2105 last_sim_mmi_insert_ind= NULL;
2106
2107 cmhSIM_SIMInserted();
2108 #endif
2109 }
2110
2111 }
2112
2113 /*
2114 +--------------------------------------------------------------------+
2115 | PROJECT : EONS MODULE : CMH_SIMF |
2116 | STATE : code ROUTINE : cmhSIM_OpUpdate |
2117 +--------------------------------------------------------------------+
2118
2119 PURPOSE : This function will be used to process the update of EFopl and EFpnn.
2120
2121 */
2122 GLOBAL BOOL cmhSIM_OpUpdate (int ref, T_SIM_FILE_UPDATE_IND *fu)
2123 {
2124 UBYTE i;
2125 BOOL ps_is_not_reading_files_1 = FALSE,
2126 ps_is_not_reading_files_2 = FALSE;
2127
2128 TRACE_FUNCTION ("cmhSIM_OpUpdate()");
2129
2130 for (i = 0; i < (int)fu->val_nr; i++)
2131 {
2132 switch(fu->file_id[i])
2133 {
2134 case SIM_OPL:
2135 TRACE_EVENT("EF_OPL has been updated ");
2136 ps_is_not_reading_files_1 = cmhSIM_UpdateOperatorName(SIM_OPL);
2137 /*lint -fallthrough */
2138
2139 case SIM_PNN:
2140 if(fu->file_id[i] NEQ SIM_OPL)
2141 {
2142 TRACE_EVENT("EF_PNN has been updated ");
2143 }
2144 ps_is_not_reading_files_2 = !cmhMM_OpUpdateName();
2145 cmhMM_Registered();
2146 simShrdPrm.fuRef = (UBYTE)ref;
2147 if(ps_is_not_reading_files_1 OR
2148 ps_is_not_reading_files_2)
2149 return(TRUE);
2150
2151 return(FALSE); /* reading files ? */
2152
2153 default:
2154 break;
2155 }
2156 }
2157 return(TRUE); /* nothing to do */
2158 }
2159
2160
2161 /*
2162 +-------------------------------------------------------------------+
2163 | PROJECT : EONS MODULE : CMH_SIMF |
2164 | STATE : code ROUTINE : cmhSIM_OpReadOplRcd |
2165 +-------------------------------------------------------------------+
2166
2167 PURPOSE : Sends a SIM read request
2168 */
2169
2170 GLOBAL BOOL cmhSIM_OpReadOplRcd(UBYTE rcd)
2171 {
2172 SHORT table_id;
2173
2174 TRACE_FUNCTION ("cmhSIM_OpReadOplRcd()");
2175
2176 table_id = psaSIM_atbNewEntry();
2177
2178 if(table_id NEQ NO_ENTRY)
2179 {
2180 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
2181 simShrdPrm.atb[table_id].accType = ACT_RD_REC;
2182 simShrdPrm.atb[table_id].reqDataFld = SIM_OPL;
2183 simShrdPrm.atb[table_id].dataOff = 0;
2184 simShrdPrm.atb[table_id].recNr = rcd;
2185 simShrdPrm.atb[table_id].recMax = 0;
2186 simShrdPrm.atb[table_id].exchData = NULL;
2187 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
2188 simShrdPrm.atb[table_id].rplyCB = cmhSIM_OpReadOplRcdCb;
2189
2190 simShrdPrm.aId = table_id;
2191
2192 if(psaSIM_AccessSIMData() < 0)
2193 {
2194 TRACE_EVENT("FATAL ERROR");
2195 return FALSE;
2196 }
2197
2198 return TRUE;
2199 }
2200 return TRUE;
2201 }
2202
2203
2204 /*
2205 +-------------------------------------------------------------------+
2206 | PROJECT : EONS MODULE : CMH_SIMF |
2207 | STATE : code ROUTINE : cmhSIM_OpReadPnnRcd |
2208 +-------------------------------------------------------------------+
2209
2210 PURPOSE : Sends a SIM read request
2211 */
2212 GLOBAL BOOL cmhSIM_OpReadPnnRcd(UBYTE rcd)
2213 {
2214 SHORT table_id;
2215
2216 TRACE_FUNCTION ("cmhSIM_OpReadPnnRcd()");
2217
2218 table_id = psaSIM_atbNewEntry();
2219
2220 if(table_id NEQ NO_ENTRY)
2221 {
2222 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
2223 simShrdPrm.atb[table_id].accType = ACT_RD_REC;
2224 simShrdPrm.atb[table_id].reqDataFld = SIM_PNN;
2225 simShrdPrm.atb[table_id].dataOff = 0;
2226 simShrdPrm.atb[table_id].recNr = rcd;
2227 simShrdPrm.atb[table_id].recMax = 0;
2228 simShrdPrm.atb[table_id].exchData = NULL;
2229 simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT;
2230 simShrdPrm.atb[table_id].rplyCB = cmhSIM_OpReadPnnRcdCb;
2231
2232 simShrdPrm.aId = table_id;
2233
2234 if(psaSIM_AccessSIMData() < 0)
2235 {
2236 TRACE_EVENT("FATAL ERROR");
2237 return FALSE;
2238 }
2239
2240 return TRUE;
2241 }
2242 return TRUE;
2243 }
2244
2245
2246 /*
2247 +-------------------------------------------------------------------+
2248 | PROJECT : EONS MODULE : CMH_SIMF |
2249 | STATE : code ROUTINE : cmhSIM_BuildOPLList |
2250 +-------------------------------------------------------------------+
2251
2252 PURPOSE :
2253 */
2254 LOCAL void cmhSIM_BuildOPLList(SHORT table_id)
2255 {
2256 UBYTE *data = simShrdPrm.atb[table_id].exchData;
2257 T_opl *opl_entry = &simShrdPrm.opl_list.opl_rcd[simShrdPrm.opl_list.num_rcd];
2258
2259 /* Test if record is valid */
2260 /* opl_entry->plmn.v_plmn = (data[0] EQ 0xFF) ? INVLD_PLMN : VLD_PLMN; */
2261
2262 /* Copy MCC and MNC from SIM data to OPL list */
2263 memcpy (opl_entry->plmn, data, UBYTES_PER_PLMN);
2264
2265 /* Extract LAC from SIM data and copy to OPL list*/
2266 opl_entry->lac1 = data[3] << 8 | data[4];
2267 opl_entry->lac2 = data[5] << 8 | data[6];
2268
2269 /* Extract PNN record number from SIM data and copy to OPL list*/
2270 opl_entry->pnn_rec_num = data[7];
2271 }
2272
2273
2274 /*
2275 +-------------------------------------------------------------------+
2276 | PROJECT : EONS MODULE : CMH_SIMF |
2277 | STATE : code ROUTINE : cmhSIM_OpReadOplRcdCb |
2278 +-------------------------------------------------------------------+
2279
2280 PURPOSE : Call back for SIM retrieval of EF_OPL.
2281 */
2282 GLOBAL void cmhSIM_OpReadOplRcdCb(SHORT table_id)
2283 {
2284 TRACE_FUNCTION("cmhSIM_OpReadOplRcdCb");
2285
2286 /* Decode and copy OPL record data to OPL list*/
2287 /*------------------------------------------*/
2288 if(simShrdPrm.atb[table_id].dataLen AND simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)
2289 {
2290 cmhSIM_BuildOPLList(table_id);
2291
2292 simShrdPrm.opl_list.opl_status = TRUE;
2293 /*
2294 if ((memcmp (simShrdPrm.opl_list.opl_rcd[simShrdPrm.opl_list.num_rcd].plmn,
2295 PLMNselEmpty,
2296 UBYTES_PER_PLMN) NEQ 0))
2297 {
2298 cmhSIM_OpReadPnnRcd(simShrdPrm.opl_list.opl_rcd[simShrdPrm.opl_list.num_rcd].pnn_rec_num);
2299 }
2300 */
2301 }
2302 else
2303 {
2304 TRACE_EVENT("Empty OPL record");
2305 }
2306
2307 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2308
2309
2310 /* If not last EF_OPL reoord retrieve next record*/
2311 /*------------------------------------------*/
2312 simShrdPrm.atb[table_id].recNr++;
2313 simShrdPrm.opl_list.num_rcd++;
2314
2315 if(simShrdPrm.opl_list.num_rcd > OPL_MAX_RECORDS)
2316 {
2317 TRACE_EVENT("Max OPL records reached");
2318 }
2319 else if(simShrdPrm.atb[table_id].recNr <= simShrdPrm.atb[table_id].recMax )
2320 {
2321 TRACE_EVENT_P1("Read next OPL record: %d",simShrdPrm.atb[table_id].recNr);
2322 cmhSIM_OpReadOplRcd(simShrdPrm.atb[table_id].recNr);
2323 return;
2324 }
2325
2326 TRACE_EVENT("Retrieval of OPL records finished");
2327 /* continue with next one */
2328 cmhSIM_StartOperatorName();
2329 }
2330
2331
2332
2333 /*
2334 +-------------------------------------------------------------------+
2335 | PROJECT : EONS MODULE : CMH_SIMF |
2336 | STATE : code ROUTINE : cmhSIM_BuildPnnList |
2337 +-------------------------------------------------------------------+
2338
2339 PURPOSE : decodes EF_PNN record read from SIM
2340 */
2341 LOCAL void cmhSIM_BuildPnnList(SHORT table_id)
2342 {
2343 UBYTE *data = simShrdPrm.atb[table_id].exchData;
2344 T_pnn *pnn_entry = &simShrdPrm.pnn_list.pnn_rcd[simShrdPrm.pnn_list.num_rcd];
2345
2346 if (*data++ EQ PNN_LONG_NAME_IEI)
2347 {
2348 pnn_entry->v_plmn = TRUE;
2349
2350 pnn_entry->long_len = (*data++)-1; /* adjust dcs */
2351 pnn_entry->long_ext_dcs = *data++;
2352 memcpy(pnn_entry->long_name,
2353 data,
2354 MINIMUM(pnn_entry->long_len, sizeof(pnn_entry->long_name)));
2355 data += pnn_entry->long_len;
2356
2357 /*----- IEI PNN short name ------*/
2358 if (*data++ EQ PNN_SHORT_NAME_IEI)
2359 {
2360 pnn_entry->shrt_len = (*data++)-1; /* adjust dcs */
2361 pnn_entry->shrt_ext_dcs = *data++;
2362 memcpy(pnn_entry->shrt_name,
2363 data,
2364 MINIMUM(pnn_entry->shrt_len, sizeof(pnn_entry->shrt_name)));
2365 }
2366 else
2367 {
2368 pnn_entry->shrt_len = 0;
2369 }
2370 }
2371 else
2372 {
2373 /* marc record as unused */
2374 pnn_entry->v_plmn = FALSE;
2375 pnn_entry->long_len = pnn_entry->shrt_len = 0;
2376 }
2377
2378 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2379 }
2380
2381
2382 /*
2383 +-------------------------------------------------------------------+
2384 | PROJECT : EONS MODULE : CMH_SIMF |
2385 | STATE : code ROUTINE : cmhSIM_OpReadPnnRcdCb |
2386 +-------------------------------------------------------------------+
2387
2388 PURPOSE : Call back for SIM retrieval of EF_PNN.
2389 */
2390 GLOBAL void cmhSIM_OpReadPnnRcdCb(SHORT table_id)
2391 {
2392
2393 TRACE_FUNCTION("cmhSIM_OpReadPnnRcdCb");
2394
2395 /* Decode and copy PNN record data to PNN list*/
2396 /*------------------------------------------*/
2397 if(simShrdPrm.atb[table_id].dataLen AND simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
2398 {
2399 cmhSIM_BuildPnnList(table_id);
2400 simShrdPrm.pnn_list.pnn_status = TRUE;
2401 }
2402 else
2403 {
2404 TRACE_EVENT("Empty PNN record");
2405 }
2406
2407 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2408
2409
2410 /* If not last EF_PNN reoord retrieve next record*/
2411 /*------------------------------------------*/
2412 simShrdPrm.atb[table_id].recNr++;
2413 simShrdPrm.pnn_list.num_rcd++;
2414
2415 if(simShrdPrm.pnn_list.num_rcd > PNN_MAX_RECORDS)
2416 {
2417 TRACE_EVENT("Max OPL records reached");
2418 }
2419 else if(simShrdPrm.atb[table_id].recNr <= simShrdPrm.atb[table_id].recMax )
2420 {
2421 TRACE_EVENT_P1("Read next PNN record: %d",simShrdPrm.atb[table_id].recNr);
2422 cmhSIM_OpReadPnnRcd(simShrdPrm.atb[table_id].recNr);
2423 return;
2424 }
2425
2426 TRACE_EVENT("Retrieval of PNN records finished");
2427
2428 /* continue with next one */
2429 cmhSIM_StartOperatorName();
2430 }
2431
2432
2433 /*
2434 +-------------------------------------------------------------------+
2435 | PROJECT : EONS MODULE : CMH_SIMF |
2436 | STATE : code ROUTINE : cmhSIM_StartOperatorName |
2437 +-------------------------------------------------------------------+
2438
2439 PURPOSE : Start retireval of EF_OPL from SIM
2440 */
2441 GLOBAL BOOL cmhSIM_StartOperatorName()
2442 {
2443 TRACE_FUNCTION ("cmhSIM_StartOperatorName()");
2444
2445 /* If EF_PNN and/or EF_OPL are allocated then start retrieval of from EF_OPL */
2446 if (simShrdPrm.opl_list.num_rcd EQ 0 AND psaSIM_ChkSIMSrvSup(SRV_PNN) AND psaSIM_ChkSIMSrvSup(SRV_OPL))
2447 {
2448 TRACE_EVENT (" start reading SIM_OPL");
2449 return(!cmhSIM_OpReadOplRcd(1));
2450 }
2451
2452 if (simShrdPrm.pnn_list.num_rcd EQ 0 AND psaSIM_ChkSIMSrvSup(SRV_PNN))
2453 {
2454 TRACE_EVENT (" start reading SIM_PNN");
2455 return(!cmhSIM_OpReadPnnRcd(1));
2456 }
2457
2458 TRACE_EVENT (" reading finished!");
2459
2460 if(psaSIM_ChkSIMSrvSup(SRV_PNN))
2461 {
2462 if (simShrdPrm.pnn_list.pnn_status EQ TRUE)
2463 {
2464 percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_Ready);
2465 }
2466 else if (psaSIM_ChkSIMSrvSup(SRV_OPL) AND simShrdPrm.opl_list.opl_status EQ TRUE)
2467 {
2468 percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_Ready);
2469 }
2470 else
2471 {
2472 percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_NotReady);
2473 }
2474 }
2475 else
2476 {
2477 percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_NotReady);
2478 }
2479
2480
2481
2482 if (mmShrdPrm.regStat EQ RS_FULL_SRV)
2483 {
2484 cmhMM_Registered();
2485 }
2486
2487 return(TRUE);
2488 }
2489
2490
2491 /*
2492 +-------------------------------------------------------------------+
2493 | PROJECT : EONS MODULE : CMH_SIMF |
2494 | STATE : code ROUTINE : cmhSIM_UpdateOperatorName |
2495 +-------------------------------------------------------------------+
2496
2497 PURPOSE : Start File Update of EF_OPL from SIM
2498 */
2499 GLOBAL BOOL cmhSIM_UpdateOperatorName(USHORT reqDataFld)
2500 {
2501 int i;
2502 TRACE_FUNCTION ("cmhSIM_UpdateOperatorName()");
2503
2504 if (reqDataFld EQ SIM_OPL OR reqDataFld EQ NOT_PRESENT_16BIT)
2505 {
2506 simShrdPrm.opl_list.num_rcd = 0;
2507 for (i=0; i<OPL_MAX_RECORDS; i++)
2508 {
2509 memcpy (simShrdPrm.opl_list.opl_rcd[i].plmn,
2510 PLMNselEmpty,
2511 UBYTES_PER_PLMN);
2512 }
2513 }
2514
2515 if (reqDataFld EQ SIM_PNN OR reqDataFld EQ NOT_PRESENT_16BIT)
2516 {
2517 simShrdPrm.pnn_list.num_rcd = 0;
2518 for (i=0; i<PNN_MAX_RECORDS; i++)
2519 {
2520 simShrdPrm.pnn_list.pnn_rcd[i].v_plmn=FALSE;
2521 }
2522 }
2523
2524 return (!cmhSIM_StartOperatorName());
2525 }
2526
2527
2528 GLOBAL T_opl_field* cmhSIM_GetOPL()
2529 {
2530 return &simShrdPrm.opl_list;
2531 }
2532
2533 /*
2534 +--------------------------------------------------------------------+
2535 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2536 | STATE : code ROUTINE : cmhSIM_Read_AD |
2537 +--------------------------------------------------------------------+
2538
2539 PURPOSE : This function returns the current PLMN mode bit value
2540
2541 */
2542 GLOBAL UBYTE cmhSIM_isplmnmodebit_set()
2543 {
2544 return simShrdPrm.PLMN_Mode_Bit;
2545 }
2546 /*
2547 +--------------------------------------------------------------------+
2548 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2549 | STATE : code ROUTINE : cmhSIM_ONS_Update |
2550 +--------------------------------------------------------------------+
2551
2552 PURPOSE : This function is used to Read the CPHS ONS file EF_ONS.
2553
2554 */
2555
2556 GLOBAL BOOL cmhSIM_ONS_Update (int ref, T_SIM_FILE_UPDATE_IND *fu)
2557 {
2558 BOOL found = FALSE;
2559 UBYTE i;
2560 TRACE_FUNCTION ("cmhSIM_ONS_Update()");
2561
2562 for (i = 0; i < (int)fu->val_nr; i++)
2563 {
2564 if (fu->file_id[i] EQ SIM_CPHS_ONSTR)
2565 {
2566 found = TRUE;
2567 break;
2568 }
2569 }
2570 if (found)
2571 {
2572 cmhMM_ONSReadName();
2573 simShrdPrm.fuRef = (UBYTE)ref;
2574 return FALSE; /* reading files */
2575 }
2576 else
2577 {
2578 return TRUE; /* nothing to do */
2579 }
2580 }
2581
2582 /*
2583 +--------------------------------------------------------------------+
2584 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2585 | STATE : code ROUTINE : cmhSIM_Get_CSP |
2586 +--------------------------------------------------------------------+
2587
2588 PURPOSE : This function is used to request the SIM CPHS file
2589
2590 */
2591 GLOBAL void cmhSIM_Get_CSP()
2592 {
2593
2594 TRACE_FUNCTION ("cmhSIM_Get_CSP()");
2595
2596 cmhSIM_ReadTranspEF( CMD_SRC_NONE,
2597 AT_CMD_NONE,
2598 SIM_CPHS_CINF,
2599 0,
2600 ACI_CPHS_INFO_SIZE,
2601 NULL,
2602 cmhSIM_Get_CSP_cb );
2603
2604 }
2605
2606
2607 /*
2608 +--------------------------------------------------------------------+
2609 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2610 | STATE : code ROUTINE : cmhSIM_Get_CSP_cb |
2611 +--------------------------------------------------------------------+
2612
2613 PURPOSE : Call back for SIM read for CPHS.
2614
2615 */
2616 void cmhSIM_Get_CSP_cb(SHORT table_id)
2617 {
2618
2619 TRACE_FUNCTION ("cmhSIM_Get_CSP_cb()");
2620
2621 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2622
2623 /* Step #1: Reading of CPHS Info */
2624 if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR OR
2625 simShrdPrm.atb[table_id].exchData EQ NULL OR
2626 simShrdPrm.atb[table_id].dataLen < ACI_CPHS_INFO_SIZE )
2627 {
2628 ; /* CPHS info not supported or invalid */
2629 }
2630 else if ((simShrdPrm.atb[table_id].exchData[1] & 0x03) EQ ALLOCATED_AND_ACTIVATED)
2631 {
2632 /* continue with reading of CSP file */
2633 cmhSIM_Read_CSP();
2634 return;
2635 }
2636
2637 }
2638
2639 /*
2640 +--------------------------------------------------------------------+
2641 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2642 | STATE : code ROUTINE : cmhSIM_AD_Update |
2643 +--------------------------------------------------------------------+
2644
2645 PURPOSE : This function is used to request the SIM Customer Service Profile (EF_CPHS_CSP).
2646
2647 */
2648 GLOBAL BOOL cmhSIM_CSP_Update (int ref, T_SIM_FILE_UPDATE_IND *fu)
2649 {
2650 BOOL found = FALSE;
2651 UBYTE i;
2652 TRACE_FUNCTION ("cmhSIM_CSP_Update()");
2653
2654 for (i = 0; i < (int)fu->val_nr; i++)
2655 {
2656 if (!found AND (fu->file_id[i] EQ SIM_CPHS_CSP))
2657 {
2658 found = TRUE;
2659 }
2660 }
2661 if (found)
2662 {
2663 cmhSIM_Read_CSP();
2664 simShrdPrm.fuRef = (UBYTE)ref;
2665 return FALSE; /* reading files */
2666 }
2667 else
2668 {
2669 return TRUE; /* nothing to do */
2670 }
2671 }
2672
2673 /*
2674 +--------------------------------------------------------------------+
2675 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2676 | STATE : code ROUTINE : cmhSIM_Read_CSP |
2677 +--------------------------------------------------------------------+
2678
2679 PURPOSE : This function is used to request the SIM Customer Service Profile
2680 (EF_CSP).
2681
2682 */
2683 GLOBAL void cmhSIM_Read_CSP()
2684 {
2685
2686 TRACE_FUNCTION ("cmhSIM_Read_CSP()");
2687
2688 cmhSIM_ReadTranspEF( CMD_SRC_NONE,
2689 AT_CMD_NONE,
2690 SIM_CPHS_CSP,
2691 0,
2692 0,
2693 NULL,
2694 cmhSIM_Read_CSP_cb );
2695
2696 }
2697
2698
2699 /*
2700 +--------------------------------------------------------------------+
2701 | PROJECT : GSM-F&D (8411) MODULE : CMH_SIMF |
2702 | STATE : code ROUTINE : cmhSIM_Read_CSP_cb |
2703 +--------------------------------------------------------------------+
2704
2705 PURPOSE : Call back for SIM read (EF_CSP).
2706
2707 */
2708 void cmhSIM_Read_CSP_cb(SHORT table_id)
2709 {
2710
2711 TRACE_FUNCTION ("cmhSIM_Read_CSP_cb()");
2712
2713 if ( simShrdPrm.atb[table_id].reqDataFld EQ SIM_CPHS_CSP )
2714 {
2715 if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
2716 {
2717 if(simShrdPrm.atb[table_id].dataLen >= ACI_CPHS_CSP_SIZE)
2718 {
2719 USHORT idx;
2720 for(idx=0; idx < simShrdPrm.atb[table_id].dataLen; idx = idx+2)
2721 {
2722 if(simShrdPrm.atb[table_id].exchData[idx] EQ VAS_SERVICE_GROUP_CODE)
2723 {
2724 if(simShrdPrm.atb[table_id].exchData[idx+1] & PLMN_MODE_BIT_ON)
2725 {
2726 simShrdPrm.PLMN_Mode_Bit = CPHS_CSP_PLMN_MODE_BIT_ON;
2727 }
2728 else
2729 {
2730 simShrdPrm.PLMN_Mode_Bit = CPHS_CSP_PLMN_MODE_BIT_OFF;
2731 }
2732 break;
2733 }
2734 }
2735 }
2736 }
2737
2738 #ifdef SIM_TOOLKIT
2739 if (simShrdPrm.fuRef >= 0)
2740 {
2741 psaSAT_FUConfirm (simShrdPrm.fuRef,
2742 (USHORT)((simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)?
2743 SIM_FU_SUCCESS: SIM_FU_ERROR));
2744 }
2745 #endif
2746 }
2747 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2748 }
2749
2750
2751 #ifdef SIM_PERS_OTA
2752
2753 /*
2754 +------------------------------------------------------------------------------
2755 | Function : cmhSIM_Register_Read_DCK
2756 +------------------------------------------------------------------------------
2757 | Description : This function is used to request the SIM De-personalization Control Keys
2758 | (EF_DCK)
2759 | Parameters : ref - Reference for file update
2760 | *fu - Pointer to T_SIM_FILE_UPDATE_IND
2761 |
2762 | Return : TRUE if no files left to read,
2763 | FALSE if some files are there to read
2764 |
2765 +------------------------------------------------------------------------------
2766 */
2767
2768 GLOBAL BOOL cmhSIM_Register_Read_DCK (int ref, T_SIM_FILE_UPDATE_IND *fu)
2769 {
2770 BOOL found = FALSE;
2771 UBYTE i;
2772
2773 TRACE_FUNCTION ("cmhSIM_Register_Read_DCK()");
2774
2775 for (i = 0; i < (int)fu->val_nr AND (fu->file_id[i] NEQ SIM_DCK); i++)
2776 {
2777 }
2778
2779 if (i NEQ (int)fu->val_nr )
2780 {
2781
2782 if (psaSIM_ChkSIMSrvSup(SRV_DePersCK))
2783 {
2784 TRACE_FUNCTION("SRV_DePersCK supported.");
2785 cmhSIM_ReadTranspEF( CMD_SRC_NONE,
2786 AT_CMD_NONE,
2787 SIM_DCK,
2788 0,
2789 16,
2790 NULL,
2791 cmhSIM_Read_DCK_cb );
2792 }
2793
2794 simShrdPrm.fuRef = (UBYTE)ref;
2795 return FALSE; /* reading files */
2796 }
2797 else
2798 {
2799 return TRUE; /* nothing to do */
2800 }
2801 }
2802
2803
2804
2805
2806 /*
2807 +------------------------------------------------------------------------------
2808 | Function : cmhSIM_Read_DCK_cb
2809 +------------------------------------------------------------------------------
2810 | Description : Call back for SIM read (EF_DCK).
2811 | Parameters : SHORT table_id
2812 |
2813 | Return : void
2814 |
2815 +------------------------------------------------------------------------------
2816 */
2817 void cmhSIM_Read_DCK_cb(SHORT table_id)
2818 {
2819 TRACE_FUNCTION ("cmhSIM_Read_DCK_cb()");
2820
2821 if ( simShrdPrm.atb[table_id].reqDataFld EQ SIM_DCK )
2822 {
2823 if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
2824 {
2825 aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[0], 8, (char *) nw_ctrl_key);
2826 aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[4], 8, (char *) nw_subset_ctrl_key);
2827 aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[8], 8, (char *) sp_ctrl_key);
2828 aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[12], 8, (char *) corp_ctrl_key);
2829
2830 aci_slock_unlock(SIMLOCK_NETWORK, (char *) nw_ctrl_key);
2831 aci_slock_unlock(SIMLOCK_NETWORK_SUBSET, (char *) nw_subset_ctrl_key);
2832 aci_slock_unlock(SIMLOCK_SERVICE_PROVIDER, (char *) sp_ctrl_key);
2833 aci_slock_unlock(SIMLOCK_CORPORATE, (char *) corp_ctrl_key);
2834 cmhSIM_WriteDefaultValue_DCK();
2835 }
2836 }
2837 }
2838
2839
2840 /*
2841 +------------------------------------------------------------------------------
2842 | Function : cmhSIM_WriteDefaultValue_DCK
2843 +------------------------------------------------------------------------------
2844 | Description : This function is used to write back the SIM De-personalization Control Keys
2845 | (EF_DCK) read during init after depersonalizing the ME
2846 |
2847 | Parameters : none
2848 |
2849 | Return : void
2850 |
2851 +------------------------------------------------------------------------------
2852 */
2853 GLOBAL void cmhSIM_WriteDefaultValue_DCK()
2854 {
2855 UBYTE all_keys[MAX_DCK_LEN];
2856
2857 TRACE_FUNCTION ("cmhSIM_WriteDefaultValue_DCK()");
2858 memset(all_keys,NOT_PRESENT_8BIT,MAX_DCK_LEN);
2859 cmhSIM_WriteTranspEF( CMD_SRC_NONE,
2860 AT_CMD_NONE,
2861 SIM_DCK,
2862 0,
2863 MAX_DCK_LEN,
2864 all_keys ,
2865 NULL );
2866 }
2867
2868
2869 #endif //SIM_PERS_OTA
2870 /*==== EOF ========================================================*/
2871