FreeCalypso > hg > freecalypso-citrine

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