FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/aoc.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 : AOC
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This module defines the functions for the
18 | advice of charge handling of ACI.
19 +-----------------------------------------------------------------------------
20 */
21
22 #include "config.h"
23 #include "fixedconf.h"
24 #include "condat-features.h"
25 #include "aci_conf.h"
26
27 #include "aci_all.h"
28
29 #include "l4_tim.h"
30
31 #include "pcm.h"
32
33 #include "aci_cmh.h"
34
35 #include "psa.h"
36 #include "psa_sim.h"
37 #include "psa_mm.h"
38
39 #include "aoc.h"
40 #include "psa_cc.h"
41 #include "cmh.h"
42 #include "cmh_cc.h"
43
44 #ifdef SIM_TOOLKIT
45 #include "psa_sat.h"
46 #endif
47
48 #ifdef FAX_AND_DATA
49 #include "aci_fd.h"
50 #endif /* of #ifdef FAX_AND_DATA */
51
52 #ifdef UART
53 #include "dti.h"
54 #include "dti_conn_mng.h"
55 #endif
56
57 #include "cmh_sim.h"
58
59 #define MC_AOC_ROUND_UP(X) ((((X)%100) EQ 0) ? ((X)/100) : (((X)/100) + 1))
60 #define E_IN_MS(X) ((X)*100)
61
62 #ifdef TI_PS_OP_VSI_NO_CALL_ID
63 #define TIMER_START(C,I,T) vsi_t_start_nc(I,T)
64 #define TIMER_PSTART(C,I,T,R) vsi_t_pstart_nc(I,T,R)
65 #define TIMER_STOP(C,I) vsi_t_stop_nc(I)
66 #define TIMER_STATUS(C,I,T) vsi_t_status_nc(I,T)
67 #define SUSPEND_SELF(C,T) vsi_t_sleep_nc(T)
68 #define SYSTEM_TIME(C,T) vsi_t_time_nc(T)
69 #else /* TI_PS_OP_VSI_NO_CALL_ID */
70 #define TIMER_START(C,I,T) vsi_t_start(C,I,T)
71 #define TIMER_PSTART(C,I,T,R) vsi_t_pstart(C,I,T,R)
72 #define TIMER_STOP(C,I) vsi_t_stop(C,I)
73 #define TIMER_STATUS(C,I,T) vsi_t_status(C,I,T)
74 #define SUSPEND_SELF(C,T) vsi_t_sleep(C,T)
75 #define SYSTEM_TIME(C,T) vsi_t_time(C,T)
76 #endif /* TI_PS_OP_VSI_NO_CALL_ID */
77
78 /********* current define *********************************************/
79 static UBYTE aoc_state = AOC_NULL; /* actual AoC state */
80 static UBYTE sim_data[10]; /* SIM data exchange */
81 static UBYTE currency [4]; /* used for currency */
82 static ULONG ccm; /* current call meter */
83 static ULONG ccm_already_incremented; /* value of CCM increm. */
84 static ULONG acm; /* accumulated call meter */
85 static UBYTE acm_increment_flag; /* counter for incr. ACM */
86 static ULONG acmmax; /* maximum of ACM */
87 static ULONG eppu; /* elementary unit price */
88 static ULONG sexp; /* sign of expression */
89 static ULONG exp; /* expression value */
90 static UBYTE pwd [9]; /* password */
91 static UBYTE act_upd_op; /* actual update operation*/
92 static ULONG act_value; /* new value for ACM(Max) */
93 static T_ACI_CMD_SRC act_src_id; /* source of AT command */
94
95 GLOBAL T_CC_AOC_TBL cc_aoc_table[MAX_CALL_NR]; /* AoC Call Table */
96 EXTERN T_PCEER causeMod;
97 EXTERN SHORT causeCeer;
98
99 static ULONG cct; /* current call timer */
100 /*static ULONG act; *//* accumulated call timer */ /* never used */
101 static USHORT ct_running; /* call timer is running */
102 static UBYTE limit_reached = FALSE; /* ACM over limit ? */
103
104 static const ULONG ppu_values [16][2] =
105 {
106 /* exp, sexp index */
107 1L, 0L, /* 0 */
108 1L, 0L, /* 1 */
109 10L, 0L, /* 2 */
110 10L, 1L, /* 3 */
111 100L, 0L, /* 4 */
112 100L, 1L, /* 5 */
113 1000L, 0L, /* 6 */
114 1000L, 1L, /* 7 */
115 10000L, 0L, /* 8 */
116 10000L, 1L, /* 9 */
117 100000L, 0L, /* 10 */
118 100000L, 1L, /* 11 */
119 1000000L, 0L, /* 12 */
120 1000000L, 1L, /* 13 */
121 10000000L, 0L, /* 14 */
122 10000000L, 1L /* 15 */
123 };
124
125 #ifdef SIM_TOOLKIT
126 BOOL aoc_update (int ref, T_SIM_FILE_UPDATE_IND *fu);
127 #endif
128 static UBYTE ccwv_charging = CCWV_CHRG_Termination;
129
130 /********* function prototypes **************************************/
131 void aoc_calc_acm_wrn_evnt ( ULONG charge,
132 BOOL aoc_running );
133
134 void aoc_set_time_ut_charge ( SHORT cId,
135 T_TIME time );
136 void aoc_calc_expct_charge ( UBYTE mode );
137 void aoc_ntfy_acm_wrn_evnt ( T_ACI_CCWV_CHRG charging );
138
139 T_TIME aoc_calc_time_ut_charge ( SHORT cId,
140 UBYTE e_value_flag );
141
142 void aoc_start_info_newcall (SHORT Cid);
143 void aoc_start_newinfo_existingcall (SHORT Cid);
144
145 static void aoc_calculate_charging_parameter_part1 (SHORT Cid);
146 static void aoc_calculate_charging_parameter_part2 (SHORT Cid);
147 /********* functions ************************************************/
148 LOCAL void aoc_update_sim_datafield_cb(SHORT table_id, T_ACI_AT_CMD at_cmd_idn);
149 LOCAL void aoc_read_sim_datafield (UBYTE accType,
150 USHORT reqDataFld,
151 void (*rplyCB)(SHORT),
152 UBYTE dataLen);
153 /*
154 +--------------------------------------------------------------------+
155 | PROJECT: GSM-PS (6147) MODULE: AOC |
156 | STATE : code ROUTINE: aoc_init |
157 +--------------------------------------------------------------------+
158
159
160 PURPOSE : Initialisation of the Advice of charge module. The function
161 is called after PIN entering. The actual phase of the SIM
162 card, the SIM service table and the PCM entry is checked.
163 The return value indicates whether AoC is supported.
164
165 */
166
167 UBYTE aoc_init (UBYTE phase, UBYTE * sim_service_table)
168 {
169 EF_MSSUP mssup;
170 UBYTE version;
171
172 TRACE_FUNCTION ("aoc_init()");
173
174 aoc_state = AOC_DISABLE;
175 /* Check Phase. It must be at least Phase 2 */
176 if (phase <= PHASE_1_SIM)
177 return FALSE;
178 TRACE_EVENT ("AOC: Card >= Phase 2");
179
180 /* Check SIM Service Table */
181 if (aoc_ssc(SRV_AOC,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
182 return FALSE;
183 TRACE_EVENT ("AOC: Card supports AoC");
184
185 /* check PCM entry in MSCAP field */
186 pcm_Init ();
187 /* Implements Measure#32: Row 60 & 1039 */
188 pcm_ReadFile ((UBYTE *)ef_mssup_id, SIZE_EF_MSSUP, (UBYTE *)&mssup, &version);
189 if (FldGet(mssup.feat1, AoC))
190 {
191 /* start reading ACM, ACMMax and PUCT */
192 TRACE_EVENT ("AOC: MS supports AoC");
193 aoc_state = AOC_ENABLE;
194 /* Implements Measure 156 and 157 */
195 aoc_read_sim_datafield ( ACT_RD_REC, SIM_ACM, aoc_read_acm_cb, 3 );
196 return TRUE;
197 }
198
199 #ifdef _SIMULATION_
200 aoc_state = AOC_ENABLE;
201 return TRUE;
202 #else
203 return FALSE;
204 #endif
205
206 }
207
208 /*
209 +--------------------------------------------------------------------+
210 | PROJECT: GSM-PS (6147) MODULE: AOC |
211 | STATE : code ROUTINE: aoc_reset |
212 +--------------------------------------------------------------------+
213
214 PURPOSE : Deactivation of AoC Service. Necessary, when SIM card
215 becomes unavailable
216 */
217
218 void aoc_reset (void)
219 {
220 TRACE_FUNCTION ("aoc_reset()");
221 aoc_state = AOC_DISABLE;
222 }
223
224 /*
225 +--------------------------------------------------------------------+
226 | PROJECT: GSM-PS (6147) MODULE: AOC |
227 | STATE : code ROUTINE: aoc_sms |
228 +--------------------------------------------------------------------+
229
230
231 PURPOSE : Indication that a SMS has received. This can be a trigger
232 for changed ACM or ACMMax on the SIM card.
233 */
234
235 void aoc_sms (void)
236 {
237 TRACE_FUNCTION ("aoc_sms()");
238 if (aoc_state EQ AOC_ENABLE)
239 {
240 /* start reading ACM, ACMMax and PUCT again */
241 /* Implements Measure 156 and 157 */
242 aoc_read_sim_datafield ( ACT_RD_REC, SIM_ACM, aoc_read_acm_cb, 3 );
243 }
244 }
245
246 /*
247 +--------------------------------------------------------------------+
248 | PROJECT: GSM-PS (6147) MODULE: AOC |
249 | STATE : code ROUTINE: aoc_update |
250 +--------------------------------------------------------------------+
251
252 PURPOSE : Evaluation of File Change Notification and update AOC,
253 if required.
254 */
255
256 #ifdef SIM_TOOLKIT
257 BOOL aoc_update (int ref, T_SIM_FILE_UPDATE_IND *fu)
258 {
259 BOOL found = FALSE;
260 int i;
261
262 TRACE_FUNCTION ("aoc_update ()");
263
264 if (aoc_state NEQ AOC_ENABLE)
265 return TRUE; /* not used at all! */ /* AOC not supported */
266
267 for (i = 0; i < (int)fu->val_nr; i++)
268 {
269 /* Check the full path as well */
270 if (fu->file_info[i].v_path_info EQ TRUE AND
271 fu->file_info[i].path_info.df_level1 EQ SIM_DF_GSM AND
272 fu->file_info[i].path_info.v_df_level2 EQ FALSE AND
273 ( fu->file_info[i].datafield EQ SIM_ACM OR
274 fu->file_info[i].datafield EQ SIM_ACMMAX OR
275 fu->file_info[i].datafield EQ SIM_PUCT ) )
276 {
277 found = TRUE;
278 break;
279 }
280 }
281
282 if (found)
283 {
284 simShrdPrm.fuRef = ref;
285 /* Implements Measure 156 and 157 */
286 aoc_read_sim_datafield ( ACT_RD_REC, SIM_ACM, aoc_read_acm_cb, 3 );
287 return FALSE;
288 }
289 else
290 {
291 simShrdPrm.fuRef = -1; /* no update needed */
292 return TRUE;
293 }
294 }
295 #endif
296
297 /*
298 +--------------------------------------------------------------------+
299 | PROJECT: GSM-PS (6147) MODULE: AOC |
300 | STATE : code ROUTINE: aoc_info |
301 +--------------------------------------------------------------------+
302
303 PURPOSE : Information of the Advice of charge module. The following
304 causes are defined:
305 AOC_START_TIME Start call time measurements.
306 AOC_STOP_TIME Stop call timer measurements.
307 AOC_START_AOC Advice of Charge is started.
308 AOC_SUSPEND_AOC Suspension of Call.
309 AOC_RESUME_AOC Resumption of Call.
310 */
311
312 UBYTE aoc_info (SHORT Cid, UBYTE cause)
313 {
314 BOOL calFlg; /* call flag */
315
316 TRACE_FUNCTION ("aoc_info()");
317
318 switch (cause)
319 {
320 case AOC_START_TIME: /* Indication of a new call. */
321 #ifdef _SIMULATION_
322 TRACE_EVENT ("AOC_START_TIME");
323 #endif
324 /* Call Time Measurements shall be
325 * started if it is the first call (ct_runnning = 0) */
326 if (ct_running EQ 0)
327 {
328 /* this is the first call. Then start call timer (periodic)
329 * and clear current calltimer value and current call meter. */
330 cct = ccm = ccm_already_incremented = 0L;
331 TIMER_PSTART (aci_handle, AOC_CALLTIMER, AOC_THOUSAND_MILLISECONDS, AOC_THOUSAND_MILLISECONDS);
332
333 simShrdPrm.synCs = SYNC_START_CALL;
334 psaSIM_SyncSIM();
335 }
336
337 cmhCC_flagCall( Cid, &ct_running );
338
339 /* Clear aoc table parameter */
340 memset (&cc_aoc_table[Cid], 0, sizeof(T_CC_AOC_TBL));
341 break;
342
343 case AOC_STOP_TIME: /* Indication of the end of a call. */
344 #ifdef _SIMULATION_
345 TRACE_EVENT ("AOC_STOP_TIME");
346 #endif
347 TRACE_EVENT_P1("CT Running = %4X", ct_running);
348 calFlg = cmhCC_tstAndUnflagCall( Cid, &ct_running );
349
350 /*Call Time Measurements shall be
351 * stopped if it is the last call (ct_runnning <= 1) */
352 if (ct_running EQ 0 AND calFlg)
353 {
354 /* this is the last call. Then stop call timer. */
355 TRACE_EVENT ("Last Call Stop Call Timer");
356 TIMER_STOP (aci_handle, AOC_CALLTIMER);
357
358
359 simShrdPrm.synCs = SYNC_STOP_CALL;
360 psaSIM_SyncSIM();
361
362 aoc_ntfy_acm_wrn_evnt ( CCWV_CHRG_Termination );
363 }
364
365 if (cc_aoc_table[Cid].aoc_timer_running) /* stop AoC timer if running */
366 {
367 TIMER_STOP (aci_handle, (USHORT)(AOC_AOCTIMER+Cid));
368 cc_aoc_table[Cid].aoc_timer_running = FALSE;
369 aoc_increment_charge (0L, TRUE); /* add rest to SIM */
370 }
371 break;
372
373 case AOC_START_AOC: /* Advice of Charge information has received for the indicated call. */
374 #ifdef _SIMULATION_
375 TRACE_EVENT ("*** AOC_START_AOC");
376 #endif
377 TRACE_EVENT_P2("AOC started Cid = %u State = %u", Cid, aoc_state);
378
379 if (aoc_state EQ AOC_ENABLE) /* AoC is supported */
380 {
381 limit_reached = FALSE;
382
383 if (cc_aoc_table[Cid].aoc_timer_running)
384 aoc_start_newinfo_existingcall(Cid);
385 else
386 aoc_start_info_newcall(Cid);
387
388 return TRUE;
389 }
390 else /* AoC not supported */
391 {
392 TRACE_EVENT ("AOC not supported");
393 return FALSE;
394 }
395
396 case AOC_SUSPEND_AOC: /* Suspension of Call is indicated. */
397 #ifdef _SIMULATION_
398 TRACE_EVENT ("*** AOC_SUSPEND_AOC");
399 #endif
400 if (aoc_state EQ AOC_ENABLE AND
401 cc_aoc_table[Cid].aoc_timer_running) /* AoC timer is running, then stop it. */
402 {
403 /* save remaining timeslice prior stopping the timer */
404 TIMER_STATUS (aci_handle, (USHORT)(AOC_AOCTIMER+Cid), &cc_aoc_table[Cid].remaining_time);
405 TIMER_STOP (aci_handle, (USHORT)(AOC_AOCTIMER+Cid));
406
407 cc_aoc_table[Cid].aoc_timer_running = FALSE;
408 }
409 break;
410
411 case AOC_RESUME_AOC: /* Resumption of Call is indicated. */
412 #ifdef _SIMULATION_
413 TRACE_EVENT ("*** AOC_RESUME_AOC");
414 #endif
415 if (aoc_state EQ AOC_ENABLE AND
416 aoc_non_zero_cai (Cid))
417 {
418 /* AoC info is available, then start again. calculate the remaining time */
419 TIMER_PSTART (aci_handle, (USHORT)(AOC_AOCTIMER + Cid),
420 cc_aoc_table[Cid].remaining_time,
421 cc_aoc_table[Cid].next_interval);
422 cc_aoc_table[Cid].aoc_timer_running = TRUE;
423
424 aoc_set_time_ut_charge ( Cid, cc_aoc_table[Cid].remaining_time );
425 }
426 break;
427
428 case AOC_CALL_CONNECTED: /* Call active state of a Call is indicated. */
429 #ifdef _SIMULATION_
430 TRACE_EVENT ("*** AOC_CALL_CONNECTED");
431 #endif
432 if (aoc_state EQ AOC_ENABLE AND
433 aoc_non_zero_cai (Cid))
434 {
435 /* AoC info is available, then start send initial CCM value to MMI. */
436 aoc_send_ccm ();
437 }
438 break;
439
440 default:
441 #ifdef _SIMULATION_
442 TRACE_EVENT ("*** Wrong cause ***");
443 #endif
444 break;
445
446 }
447 return TRUE;
448 }
449
450 /*
451 +--------------------------------------------------------------------+
452 | PROJECT: GSM-PS (6147) MODULE: AOC |
453 | STATE : code ROUTINE: aoc_get_values |
454 +--------------------------------------------------------------------+
455
456 PURPOSE : Request of Advice of Charge Values.
457 */
458
459 void aoc_get_values (UBYTE value_type, void * value)
460 {
461 ULONG * longPtr = value;
462 T_puct_raw * raw_puct;
463
464 TRACE_FUNCTION ("aoc_get_values()");
465
466 switch (value_type)
467 {
468 case AOC_CTV: /* Current Timer Value */
469 *longPtr = cct;
470 break;
471
472 case AOC_CCM: /* Current Call Meter Value */
473 #if defined _SIMULATION_
474 TRACE_EVENT_P1("CCM = %u", MC_AOC_ROUND_UP(ccm));
475 #endif
476 *longPtr = MC_AOC_ROUND_UP(ccm);
477 break;
478
479 case AOC_ACM: /* Accumulated Call Meter Value */
480 *longPtr = MC_AOC_ROUND_UP(acm);
481 break;
482
483 case AOC_ACMMAX: /* Maximum Accumulated Call Meter Value */
484 *longPtr = MC_AOC_ROUND_UP(acmmax);
485 break;
486
487 case AOC_PUCT: /* Price per Unit and Currency */
488 aoc_calculate_puct (1L, (T_puct *)value);
489 break;
490
491 case AOC_PUCT_RAW: /* Price per Unit and Currency as RAW data */
492 raw_puct = (T_puct_raw *)value;
493 raw_puct->exp = exp;
494 raw_puct->sexp = sexp;
495 raw_puct->eppu = eppu;
496 memcpy (raw_puct->currency, currency, 4);
497 break;
498
499 case AOC_CCM_PUCT: /* CCM in Price per Unit and Currency */
500 aoc_calculate_puct (MC_AOC_ROUND_UP(ccm), (T_puct *)value);
501 break;
502
503 case AOC_ACM_PUCT: /* ACM in Price per Unit and Currency */
504 aoc_calculate_puct (MC_AOC_ROUND_UP(acm), (T_puct *)value);
505 break;
506
507 case AOC_ACMMAX_PUCT: /* ACMMax in Price per Unit and Currency */
508 aoc_calculate_puct (MC_AOC_ROUND_UP(acmmax), (T_puct *)value);
509 break;
510 }
511 }
512
513 /*
514 +--------------------------------------------------------------------+
515 | PROJECT: GSM-PS (6147) MODULE: AOC |
516 | STATE : code ROUTINE: aoc_set_values |
517 +--------------------------------------------------------------------+
518
519 PURPOSE : Setting of Advice of charge values.
520 */
521
522 T_ACI_RETURN aoc_set_values (T_ACI_CMD_SRC srcId,
523 UBYTE value_type,
524 void *value,
525 UBYTE *password)
526 {
527 TRACE_FUNCTION ("aoc_set_values()");
528
529 /* Store Password, if available and start writing to the SIM Card. */
530 memcpy (pwd, password, 9);
531 act_src_id = srcId;
532
533 /* AOC not supported in SIM, Check for aoc_state return AT_FAIL */
534 if( aoc_state NEQ AOC_ENABLE )
535 {
536 return( AT_FAIL );
537 }
538
539 switch (value_type)
540 {
541 case AOC_ACM:
542 /* Implements Measure 152 */
543 act_value = 0L;
544 aoc_update_sim_datafield ( FIRST_UPDATE, ACT_WR_REC,
545 SIM_ACM, aoc_update_acm_cb );
546 break;
547
548 case AOC_ACMMAX:
549 /* Implements Measure 152 */
550 act_value = (ULONG)value;
551 aoc_update_sim_datafield ( FIRST_UPDATE, ACT_WR_DAT,
552 SIM_ACMMAX, aoc_update_acmmax_cb );
553 break;
554
555 case AOC_PUCT:
556 aoc_update_puct (FIRST_UPDATE, (T_puct *)value);
557 break;
558 }
559
560 return( AT_EXCT );
561 }
562
563 /*
564 +--------------------------------------------------------------------+
565 | PROJECT: GSM-PS (6147) MODULE: AOC |
566 | STATE : code ROUTINE: aoc_check_moc |
567 +--------------------------------------------------------------------+
568
569 PURPOSE : The function checks whether ACM is greater than ACMMax.
570 In this case only emergency calls are allowed for mobile
571 originated call direction.
572 */
573
574 UBYTE aoc_check_moc (void)
575 {
576 TRACE_FUNCTION ("aoc_check_moc()");
577
578 return aoc_check_acm();
579 }
580
581
582 /*
583 +--------------------------------------------------------------------+
584 | PROJECT: GSM-PS (6147) MODULE: AOC |
585 | STATE : code ROUTINE: aoc_ssc |
586 +--------------------------------------------------------------------+
587
588 PURPOSE : Check SIM service status. The value of service nr is
589 extracted from the SIM service table.
590 */
591
592 UBYTE aoc_ssc (UBYTE nr, UBYTE * serv_table)
593 {
594 TRACE_FUNCTION ("aoc_ssc()");
595
596 if (nr > MAX_SRV_TBL*4)
597 {
598 TRACE_ERROR ("serv_table overflow in pb_ssc()");
599 return NO_ALLOCATED;
600 }
601
602 return ( *(serv_table+(nr-1)/4) >> (((nr-1)&3)*2) & 0x03);
603 }
604
605
606 /*
607 +--------------------------------------------------------------------+
608 | PROJECT: GSM-PS (6147) MODULE: AOC |
609 | STATE : code ROUTINE: aoc_read_acm_cb |
610 +--------------------------------------------------------------------+
611
612 PURPOSE : Callback function for reading ACM.
613 */
614
615 void aoc_read_acm_cb(SHORT table_id)
616 {
617 TRACE_FUNCTION ("aoc_read_acm_cb()");
618
619 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
620
621 if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR)
622 {
623 /* ACM is not readable, disable set to default values */
624 acm=0L;
625 TRACE_EVENT ("AOC: Card has no ACM field");
626 #ifdef SIM_TOOLKIT
627 if (simShrdPrm.fuRef >= 0)
628 {
629 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR);
630 }
631 #endif
632 }
633 else
634 {
635 /* calculate ACM and start reading ACMMax */
636 acm = (sim_data[0]<<16) + (sim_data[1]<<8) + sim_data[2];
637 acm *= 100; /* internal unit is 1/100 */
638 TRACE_EVENT_P1("ACM value = %u", (USHORT)acm);
639 /* Implements Measure 156 and 157 */
640 aoc_read_sim_datafield ( ACT_RD_DAT, SIM_ACMMAX, aoc_read_acmmax_cb, 3 );
641
642 }
643 }
644
645
646 /*
647 +--------------------------------------------------------------------+
648 | PROJECT: GSM-PS (6147) MODULE: AOC |
649 | STATE : code ROUTINE: aoc_read_acmmax_cb |
650 +--------------------------------------------------------------------+
651
652 PURPOSE : Callback function for reading ACMMax.
653 */
654
655 void aoc_read_acmmax_cb(SHORT table_id)
656 {
657 TRACE_FUNCTION ("aoc_read_acmmax_cb()");
658
659 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
660
661 if (simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)
662 {
663 /* calculate ACMMAX and start reading PUCT */
664 acmmax = (sim_data[0]<<16) + (sim_data[1]<<8) + sim_data[2];
665 acmmax *= 100; /* internal unit is 1/100 */
666 TRACE_EVENT_P1("ACMMAX value = %u", (USHORT)acmmax);
667 /* Implements Measure 156 and 157 */
668 aoc_read_sim_datafield ( ACT_RD_DAT, SIM_PUCT, aoc_read_puct_cb, 5 );
669 }
670 else
671 {
672 /* ACMMAX is not readable, disable set to default values */
673 acmmax=0;
674 TRACE_EVENT ("AOC: Card has no ACMmax field");
675 #ifdef SIM_TOOLKIT
676 if (simShrdPrm.fuRef >= 0)
677 {
678 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR);
679 }
680 #endif
681 }
682 }
683
684
685 /*
686 +--------------------------------------------------------------------+
687 | PROJECT: GSM-PS (6147) MODULE: AOC |
688 | STATE : code ROUTINE: aoc_read_puct_cb |
689 +--------------------------------------------------------------------+
690
691 PURPOSE : Callback function for reading PUCT.
692 */
693
694 void aoc_read_puct_cb(SHORT table_id)
695 {
696 UBYTE index;
697
698 TRACE_FUNCTION ("aoc_read_puct_cb()");
699 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
700
701 if (simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)
702 {
703 /* calculate PUCT */
704 #if defined WIN32
705 TRACE_EVENT_P2("PUCT %x %x",sim_data[3],sim_data[4]);
706 #endif
707
708 currency [0] = sim_data[0];
709 currency [1] = sim_data[1];
710 currency [2] = sim_data[2];
711 currency [3] = 0;
712 eppu = (sim_data[3]<<4 & 0xFF0) + (sim_data[4] & 0x0F);
713 index = sim_data[4]>>4 & 0x0F;
714 if (index > 15) /* only 0 to 15 */
715 {
716 index = 15;
717 }
718 exp = ppu_values[index][0];
719 sexp = ppu_values[index][1];
720 }
721 else
722 {
723 /* PUCT is not readable, disable set to default values */
724 eppu = exp = sexp = 0;
725 TRACE_EVENT ("AOC: Card has no PUCT field");
726 }
727
728 #ifdef SIM_TOOLKIT
729 if (simShrdPrm.fuRef >= 0)
730 {
731 psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCC_ADD);
732 }
733 #endif
734 }
735
736
737 /*
738 +--------------------------------------------------------------------+
739 | PROJECT: GSM-PS (6147) MODULE: AOC |
740 | STATE : code ROUTINE: aoc_init_calltable |
741 +--------------------------------------------------------------------+
742
743 PURPOSE : Initialisation of the AoC parameters of the call table.
744
745 */
746
747 void aoc_init_calltable (void)
748 {
749 TRACE_FUNCTION ("aoc_init_calltable()");
750
751 /* Initialize AoC parameters and open
752 * the call dependent AoC timer */
753 memset (cc_aoc_table, 0, sizeof (cc_aoc_table));
754
755 /* Initialize AoC Parameter */
756 ccm = 0L;
757 ccm_already_incremented = 0L;
758 acm_increment_flag = 0;
759
760 /* Initialize the Call Timer Variables */
761 cct = 0L;
762 /* act = 0L; */
763 ct_running = 0;
764
765 #ifdef SIM_TOOLKIT
766 simShrdPrm.fuRef = -1;
767 if (!psaSAT_FURegister (aoc_update))
768 {
769 TRACE_EVENT ("FAILED to register the handler aoc_update() for FU");
770 }
771
772 #endif
773 }
774
775 /*
776 +--------------------------------------------------------------------+
777 | PROJECT: GSM-PS (6147) MODULE: AOC |
778 | STATE : code ROUTINE: aoc_timeout |
779 +--------------------------------------------------------------------+
780
781 PURPOSE : A timeout has occured for a timer. The funtion returns
782 TRUE, if it is a call timer or a AoC timer, else FALSE
783 is returned to indicate that the timer has not been
784 processed.
785
786 */
787 UBYTE aoc_timeout (USHORT index)
788 {
789 if (index EQ AOC_CALLTIMER)
790 {
791 /* timeout call timer */
792 aoc_timeout_call_timer ();
793 return TRUE;
794 }
795 else if (index >= AOC_AOCTIMER AND index < AOC_AOCTIMER+MAX_CALL_NR)
796 {
797 /* Check Advice of Charge Timer */
798 aoc_timeout_aoc_timer ((USHORT)(index - AOC_AOCTIMER));
799 return TRUE;
800 }
801 else
802 {
803 /* the timeout is not for AoC */
804 return FALSE;
805 }
806 }
807
808 /*
809 +--------------------------------------------------------------------+
810 | PROJECT: GSM-PS (6147) MODULE : AOC |
811 | STATE : code ROUTINE: aoc_timeout_call_timer |
812 +--------------------------------------------------------------------+
813
814 PURPOSE : the call timer timeout has occured. The CCT and ACT are
815 increased.
816
817 */
818
819 void aoc_timeout_call_timer (void)
820 {
821 int Cid;
822 T_ACI_CMD_SRC idx;
823 UBYTE five_second_have_just_elapsed = FALSE;
824
825 /* TRACE_FUNCTION ("aoc_timeout_call_timer()"); */
826
827 cct++;
828 /* act++; */
829
830 if (acm_increment_flag EQ 1)
831 five_second_have_just_elapsed = TRUE;
832
833 /* Flag to realize 5 second delay for incrementing ACM on the SIM card. */
834 if (acm_increment_flag)
835 acm_increment_flag--;
836
837 /* flush the charge on the SIM, 5 seconds after the last writing,
838 * if there some units to add */
839 if (five_second_have_just_elapsed)
840 aoc_increment_charge (0L, FALSE);
841
842 /* Update the remaining time for running AoC timer */
843 for (Cid=0; Cid<MAX_CALL_NR; Cid++)
844 {
845 if (cc_aoc_table[Cid].aoc_timer_running AND
846 cc_aoc_table[Cid].remaining_time > 0)
847 {
848 TIMER_STATUS (aci_handle, (USHORT)(AOC_AOCTIMER + Cid), &cc_aoc_table[Cid].remaining_time);
849 }
850 }
851
852 for( idx = CMD_SRC_LCL; idx < CMD_SRC_MAX; idx++ )
853 {
854 R_AT( RAT_CTV, idx )( );
855 }
856
857 aoc_set_time_ut_charge ( ACI_NumParmNotPresent, 0L );
858 }
859
860
861 /*
862 +--------------------------------------------------------------------+
863 | PROJECT: GSM-PS (6147) MODULE : AOC |
864 | STATE : code ROUTINE: aoc_timeout_aoc_timer |
865 +--------------------------------------------------------------------+
866
867 PURPOSE : An AoC timer timeout has occured.
868
869 */
870
871 void aoc_timeout_aoc_timer (SHORT Cid)
872 {
873 SHORT dummy_waitId; /* holds call waiting id */
874 T_ACI_CMD_SRC src_dummy = CMD_SRC_NONE;
875
876 TRACE_FUNCTION ("aoc_timeout_aoc_timer()");
877
878 if ((aoc_check_acm () EQ FALSE) AND
879 (cc_aoc_table[Cid].aoci_active EQ FALSE) AND
880 (cc_aoc_table[Cid].next_unit) ) /* check if the next intervall would charge (time related charge > 0)*/
881 {
882 /* ACM exceeds ACMMax, and call is not free, so disconnect call */
883 TRACE_EVENT ("ACM > ACMMax");
884 cmhCC_ClearCall (Cid,
885 CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, MNCC_CAUSE_ACM_MAX),
886 src_dummy, AT_CMD_NONE, &dummy_waitId);
887 }
888 //TISH, patch for OMAPS00128043
889 //start
890 else if (ccShrdPrm.ctb[Cid]->prio EQ 1) //PRIO_EMERG_CALL
891 return;
892 //end
893 else
894 {
895 /* e3 may have changed during the current intervall but recalc is already done */
896 aoc_increment_charge (cc_aoc_table[Cid].next_unit, FALSE);
897 if (cc_aoc_table[Cid].new_data_avail)
898 {
899 /* New Parameter available */
900 /* 4.3.e) bring parameters held in abeyance into operation */
901 if (cc_aoc_table[Cid].e_next_bitmap & E1_CHANGED) cc_aoc_table[Cid].e1 = cc_aoc_table[Cid].e1_next;
902 if (cc_aoc_table[Cid].e_next_bitmap & E2_CHANGED) cc_aoc_table[Cid].e2 = cc_aoc_table[Cid].e2_next;
903 if (cc_aoc_table[Cid].e_next_bitmap & E3_CHANGED) cc_aoc_table[Cid].e3 = cc_aoc_table[Cid].e3_next;
904 if (cc_aoc_table[Cid].e_next_bitmap & E7_CHANGED) cc_aoc_table[Cid].e7 = cc_aoc_table[Cid].e7_next;
905
906 aoc_calculate_charging_parameter_part2 (Cid);
907
908 /* timing has changed? */
909 if (cc_aoc_table[Cid].e_next_bitmap & (E2_CHANGED | E7_CHANGED))
910 {
911 /* reschedule timer */
912 TIMER_STOP (aci_handle, (USHORT)(AOC_AOCTIMER + Cid));
913 TIMER_PSTART (aci_handle, (USHORT)(AOC_AOCTIMER + Cid), cc_aoc_table[Cid].first_interval,
914 cc_aoc_table[Cid].next_interval);
915 cc_aoc_table[Cid].remaining_time = cc_aoc_table[Cid].first_interval;
916 }
917 else
918 /* ask the timer since we could already be ahead */
919 /* cc_aoc_table[Cid].remaining_time = cc_aoc_table[Cid].next_interval; */
920 TIMER_STATUS (aci_handle, (USHORT)(AOC_AOCTIMER + Cid), &cc_aoc_table[Cid].remaining_time);
921
922 cc_aoc_table[Cid].new_data_avail = FALSE;
923 cc_aoc_table[Cid].e_next_bitmap &= ~(E1_CHANGED | E2_CHANGED | E3_CHANGED | E7_CHANGED);
924 }
925 else
926 {
927 /* re-initialise remaining time counter */
928 /* ask the timer since we could already be ahead */
929 /* cc_aoc_table[Cid].remaining_time = cc_aoc_table[Cid].next_interval; */
930 TIMER_STATUS (aci_handle, (USHORT)(AOC_AOCTIMER + Cid), &cc_aoc_table[Cid].remaining_time);
931 }
932
933 /* check if timer had e2=0 and e7>= */
934 if (cc_aoc_table[Cid].next_interval == 0)
935 {
936 cc_aoc_table[Cid].aoc_timer_running = FALSE;
937 /* cc_aoc_table[Cid].aoci_active = FALSE;*/
938 cc_aoc_table[Cid].remaining_time = 0L;
939 aoc_set_time_ut_charge ( Cid, (ULONG)ACI_NumParmNotPresent );
940 }
941 else
942 aoc_set_time_ut_charge ( Cid, cc_aoc_table[Cid].remaining_time );
943 }
944 }
945
946
947 /*
948 +--------------------------------------------------------------------+
949 | PROJECT: GSM-PS (6147) MODULE : AOC |
950 | STATE : code ROUTINE: aoc_start_aoc_timer |
951 +--------------------------------------------------------------------+
952
953 PURPOSE : AoC is started for the indicated call or
954 new AoC parameter are received.
955 */
956
957 void aoc_start_newinfo_existingcall (SHORT Cid)
958 {
959 UBYTE no_more_timer_running = FALSE;
960 T_ACI_CMD_SRC src_dummy = CMD_SRC_NONE;
961 SHORT dummy_waitId;
962
963 TRACE_FUNCTION ("aoc_start_newinfo_existingcall()");
964
965 if(!aoc_non_zero_cai (Cid))
966 {
967 return;
968 }
969
970 if (cc_aoc_table[Cid].aoc_timer_running EQ FALSE)
971 {
972 /* New Parameter available */
973 /* 4.3.e) bring parameters held in abeyance into operation */
974 if (cc_aoc_table[Cid].e_next_bitmap & E1_CHANGED) cc_aoc_table[Cid].e1 = cc_aoc_table[Cid].e1_next;
975 if (cc_aoc_table[Cid].e_next_bitmap & E2_CHANGED) cc_aoc_table[Cid].e2 = cc_aoc_table[Cid].e2_next;
976 if (cc_aoc_table[Cid].e_next_bitmap & E3_CHANGED) cc_aoc_table[Cid].e3 = cc_aoc_table[Cid].e3_next;
977 if (cc_aoc_table[Cid].e_next_bitmap & E7_CHANGED) cc_aoc_table[Cid].e7 = cc_aoc_table[Cid].e7_next;
978
979 aoc_calculate_charging_parameter_part2 (Cid);
980
981 /* vsi_t_status (VSI_CALLER (USHORT)(AOC_AOCTIMER + Cid), &cc_aoc_table[Cid].remaining_time);*/
982
983 cc_aoc_table[Cid].new_data_avail = FALSE;
984 cc_aoc_table[Cid].e_next_bitmap &= ~(E1_CHANGED | E2_CHANGED | E3_CHANGED | E7_CHANGED);
985 no_more_timer_running = TRUE;
986 }
987
988
989 /* charging information available, else wait for end of interval.*/
990 if ( (cc_aoc_table[Cid].next_interval EQ 0) AND
991 ((cc_aoc_table[Cid].first_interval EQ 0) OR (cc_aoc_table[Cid].remaining_time EQ 0)) )
992 {
993 /* if CDUR is not actively timing (i.e. due to e2 being zero,
994 * e7 being zero or the processing of e7 has been completed),
995 * then a new value of e2 and/or e7 is applied immediately as per a normal call. */
996 no_more_timer_running = TRUE;
997 }
998
999 /* charging information available, else wait for end of interval. */
1000 if ((aoc_check_acm () EQ TRUE) OR
1001 (cc_aoc_table[Cid].aoci_active EQ TRUE))
1002 {
1003 /* ACM has not exceeded ACMMax then calculate charging parameters and increment inital charge */
1004 aoc_calculate_charging_parameter_part1 (Cid);
1005 aoc_increment_initial_charge (Cid);
1006 cc_aoc_table[Cid].new_data_avail = TRUE;
1007 }
1008 else
1009 {
1010 /*
1011 * ACM has reached ACM max, the call is kept till the next interval elapses
1012 * but if there is no timer running, for a new reception of CAI non zero,
1013 * we behave as on reception of a first CAI for a call, if acm has reached ACM max,
1014 * we disconnect the call.
1015 * "Rec 2.24 : 4.2.2 ACM : If the ACM max is valid and the ACM is equal to or greater
1016 * than the value of ACM max, and an incoming call is received and subsequently
1017 * a non-zero CAI is received for that call, then the call shall be terminated by
1018 * the ME with an appropriate indication given to the user."
1019 */
1020 if (no_more_timer_running)
1021 {
1022 /* if we are here, it means that it's a non-zero CAI, so no need to test it again */
1023 TRACE_EVENT("no more timer running clear call");
1024 cmhCC_ClearCall (Cid,
1025 CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, MNCC_CAUSE_ACM_MAX),
1026 src_dummy, AT_CMD_NONE, &dummy_waitId);
1027 }
1028 }
1029
1030 if (no_more_timer_running)
1031 {
1032 /* New Parameter available */
1033 aoc_calculate_charging_parameter_part2 (Cid);
1034
1035 cc_aoc_table[Cid].new_data_avail = FALSE;
1036 TIMER_STOP (aci_handle, (USHORT)(AOC_AOCTIMER + Cid));
1037 TIMER_PSTART (aci_handle, (USHORT)(AOC_AOCTIMER + Cid), cc_aoc_table[Cid].first_interval,
1038 cc_aoc_table[Cid].next_interval);
1039 /* re-initialise remaining time counter for first interval */
1040 cc_aoc_table[Cid].remaining_time = cc_aoc_table[Cid].first_interval;
1041 }
1042 }
1043
1044 void aoc_start_info_newcall (SHORT Cid)
1045 {
1046 T_ACI_CMD_SRC src_dummy = CMD_SRC_NONE;
1047 SHORT dummy_waitId;
1048
1049 TRACE_FUNCTION ("aoc_start_info_newcall()");
1050
1051 if( !aoc_non_zero_cai(Cid) )
1052 {
1053 return;
1054 }
1055 /* charging information available */
1056
1057 if( (aoc_check_acm() EQ FALSE) AND
1058 (cc_aoc_table[Cid].aoci_active EQ FALSE) )
1059 {
1060 /* ACM exceeds ACMMax, disconnect call */
1061 TRACE_EVENT("clear call on initial call");
1062 cmhCC_ClearCall (Cid,
1063 CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, MNCC_CAUSE_ACM_MAX),
1064 src_dummy,
1065 AT_CMD_NONE,
1066 &dummy_waitId);
1067 return;
1068 }
1069
1070 /* ACM has not exceeded ACMMax then calculate charging parameters,
1071 * increment inital charge and start AoC Timer. */
1072 {
1073 /* bring new parameters into operation */
1074
1075 if (cc_aoc_table[Cid].e_next_bitmap & E1_CHANGED) cc_aoc_table[Cid].e1 = cc_aoc_table[Cid].e1_next;
1076 if (cc_aoc_table[Cid].e_next_bitmap & E2_CHANGED) cc_aoc_table[Cid].e2 = cc_aoc_table[Cid].e2_next;
1077 if (cc_aoc_table[Cid].e_next_bitmap & E3_CHANGED) cc_aoc_table[Cid].e3 = cc_aoc_table[Cid].e3_next;
1078 if (cc_aoc_table[Cid].e_next_bitmap & E7_CHANGED) cc_aoc_table[Cid].e7 = cc_aoc_table[Cid].e7_next;
1079
1080 /* cc_aoc_table[Cid].new_data_avail = FALSE;*/
1081 cc_aoc_table[Cid].e_next_bitmap &= ~(E1_CHANGED | E2_CHANGED | E3_CHANGED | E7_CHANGED);
1082 }
1083
1084 aoc_calculate_charging_parameter (Cid);
1085 aoc_increment_initial_charge (Cid);
1086
1087 if(cc_aoc_table[Cid].first_interval)
1088 {
1089 TIMER_PSTART (aci_handle, (USHORT)(AOC_AOCTIMER + Cid), cc_aoc_table[Cid].first_interval,
1090 cc_aoc_table[Cid].next_interval);
1091
1092 cc_aoc_table[Cid].aoc_timer_running = TRUE;
1093 }
1094
1095 cc_aoc_table[Cid].new_data_avail = FALSE;
1096 cc_aoc_table[Cid].remaining_time = cc_aoc_table[Cid].first_interval;
1097
1098 aoc_set_time_ut_charge ( Cid, cc_aoc_table[Cid].remaining_time );
1099 }
1100
1101
1102 /*
1103 +--------------------------------------------------------------------+
1104 | PROJECT: GSM-PS (6147) MODULE : AOC |
1105 | STATE : code ROUTINE: aoc_non_zero_cai |
1106 +--------------------------------------------------------------------+
1107
1108 PURPOSE : Checks whether the Advice of Charge parameter indicate
1109 a free call (parameters are not available or equal zero).
1110 */
1111
1112 UBYTE aoc_non_zero_cai (SHORT Cid)
1113 {
1114 TRACE_FUNCTION ("aoc_non_zero_cai()");
1115
1116 /* AoC = e3 * { e4 + e1*INT(CDUR/(e7,e2)) + e5*INT(SEG/e6) }
1117 * = scaling * { constant + time related + data related}
1118 *
1119 * Ref. GSM 2.24 Section 4 Functional operation in MS */
1120
1121 if ((cc_aoc_table[Cid].e3 EQ 0) OR
1122 ((cc_aoc_table[Cid].e1 EQ 0) AND (cc_aoc_table[Cid].e4 EQ 0) /* AND (cc_aoc_table[Cid].e5 EQ 0) */ ))
1123 /* e5, e6 is currently not supported */
1124 return FALSE;
1125
1126 return TRUE;
1127 }
1128
1129 /*
1130 +--------------------------------------------------------------------+
1131 | PROJECT: GSM-PS (6147) MODULE : AOC |
1132 | STATE : code ROUTINE: aoc_check_acm |
1133 +--------------------------------------------------------------------+
1134
1135 PURPOSE : The function indicates whether ACM exceeds ACMMax.
1136
1137 */
1138
1139 UBYTE aoc_check_acm (void)
1140 {
1141 TRACE_FUNCTION ("aoc_check_acm()");
1142
1143 TRACE_EVENT_P2("ACM=%u ACMMax=%u", acm, acmmax);
1144
1145 if (acmmax NEQ 0)
1146 {
1147 /*
1148 * ACMMax is valid
1149 */
1150 if (acm >= acmmax)
1151 {
1152 causeMod = P_CEER_sim; /* Set the module to sim to report ceer */
1153 causeCeer = P_CEER_ACMMaxReachedOrExceeded; /* Set proprietary cause */
1154 return FALSE; /* ACM exceeds ACMMax */
1155 }
1156 else
1157 {
1158 causeMod = P_CEER_mod; /* Clear module which is set */
1159 causeCeer = P_CEER_NotPresent; /* Clear proprietary cause */
1160 }
1161 }
1162 return TRUE;
1163 }
1164
1165 /*
1166 +--------------------------------------------------------------------+
1167 | PROJECT: GSM-PS (6147) MODULE : AOC |
1168 | STATE : code ROUTINE: aoc_calculate_charging_params_part1 |
1169 +--------------------------------------------------------------------+
1170
1171 PURPOSE : The function calculates an initial rime related charge
1172
1173 */
1174
1175 static void aoc_calculate_charging_parameter_part1 (SHORT Cid)
1176 {
1177 TRACE_FUNCTION ("aoc_calculate_charging_parameter_part1()");
1178
1179 /*
1180 * Calculation for inital charge
1181 */
1182 cc_aoc_table[Cid].first_unit =
1183 ((ULONG)cc_aoc_table[Cid].e3 * (ULONG)cc_aoc_table[Cid].e4) / 10;
1184 }
1185
1186 /*
1187 +--------------------------------------------------------------------+
1188 | PROJECT: GSM-PS (6147) MODULE : AOC |
1189 | STATE : code ROUTINE: aoc_calculate_charging_params_part2 |
1190 +--------------------------------------------------------------------+
1191
1192 PURPOSE : The function calculates the interval length and the
1193 number of units which will be incremented at interval
1194 end.
1195
1196 */
1197
1198 static void aoc_calculate_charging_parameter_part2 (SHORT Cid)
1199 {
1200
1201 TRACE_FUNCTION ("aoc_calculate_charging_parameter_part2()");
1202
1203 /* Calculation of first time interval */
1204 cc_aoc_table[Cid].first_interval = (T_TIME) E_IN_MS(cc_aoc_table[Cid].e7);
1205
1206 /* Calculation of next time interval */
1207 cc_aoc_table[Cid].next_interval = (T_TIME) E_IN_MS(cc_aoc_table[Cid].e2);
1208
1209
1210 /* 4.3.a) E7 is not available or E7 is equal zero then use E2 */
1211 if (cc_aoc_table[Cid].first_interval EQ 0L)
1212 cc_aoc_table[Cid].first_interval = cc_aoc_table[Cid].next_interval;
1213
1214 /*
1215 * Calculation for charge of next units
1216 */
1217 cc_aoc_table[Cid].next_unit =
1218 ((ULONG)cc_aoc_table[Cid].e3 * (ULONG)cc_aoc_table[Cid].e1) / 10;
1219 }
1220
1221 /*
1222 +--------------------------------------------------------------------+
1223 | PROJECT: GSM-PS (6147) MODULE : AOC |
1224 | STATE : code ROUTINE: aoc_calculate_charging_params |
1225 +--------------------------------------------------------------------+
1226
1227 PURPOSE : The function calculates the interval length and the
1228 number of units which will be incremented at interval
1229 end.
1230
1231 */
1232
1233 void aoc_calculate_charging_parameter (SHORT Cid)
1234 {
1235 TRACE_FUNCTION ("aoc_calculate_charging_parameter()");
1236
1237 aoc_calculate_charging_parameter_part1 (Cid);
1238 aoc_calculate_charging_parameter_part2 (Cid);
1239 }
1240
1241 /*
1242 +--------------------------------------------------------------------+
1243 | PROJECT: GSM-PS (6147) MODULE : AOC |
1244 | STATE : code ROUTINE: aoc_increment_initial_charge |
1245 +--------------------------------------------------------------------+
1246
1247 PURPOSE : The function increments the inital charge to CCM and ACM.
1248
1249 */
1250
1251 void aoc_increment_initial_charge (SHORT Cid)
1252 {
1253 TRACE_FUNCTION ("aoc_increment_inital_charge()");
1254
1255 if (cc_aoc_table[Cid].first_unit)
1256 {
1257 /*
1258 * if initial charge is available, charge it and
1259 * inform MMI about it although it has no charge.
1260 */
1261 aoc_increment_charge (cc_aoc_table[Cid].first_unit, FALSE);
1262 cc_aoc_table[Cid].first_unit = 0L;
1263 }
1264 aoc_send_ccm ();
1265 }
1266
1267
1268 /*
1269 +--------------------------------------------------------------------+
1270 | PROJECT: GSM-PS (6147) MODULE : AOC |
1271 | STATE : code ROUTINE: aoc_increment_charge |
1272 +--------------------------------------------------------------------+
1273
1274 PURPOSE : The function increments charge to CCM and ACM. If necessary
1275 the ACM is incremented on the SIM card.
1276
1277 */
1278
1279 void aoc_increment_charge (ULONG charge, UBYTE ever)
1280 {
1281 SHORT table_id;
1282 ULONG acm_for_sim;
1283
1284 TRACE_FUNCTION ("aoc_increment_charge()");
1285
1286 /*
1287 * Both CCM is incremented
1288 */
1289 ccm += charge;
1290
1291 if (ccm > (0xFFFFFF * 100)) /* limit to 0xffffff since datafeld is only 3 bytes long.*/
1292 ccm = (0xFFFFFF * 100);
1293
1294
1295
1296 TRACE_EVENT_P2("NewCCM %u charge %u", ccm, charge);
1297
1298 /*
1299 * the update on the SIM is the difference between the rounded up value of the current CCM
1300 * and the old CCM (already rounded up)
1301 */
1302 acm_for_sim = MC_AOC_ROUND_UP(ccm) - MC_AOC_ROUND_UP(ccm_already_incremented);
1303
1304 if (acm_for_sim)
1305 {
1306 if (acm_increment_flag EQ 0 OR ever)
1307 {
1308 /*
1309 * Nothing stored in the last five seconds on the SIM card
1310 * and now something to store
1311 */
1312 acm_increment_flag = 5;
1313
1314 ccm_already_incremented += acm_for_sim * 100;
1315
1316 acm += acm_for_sim * 100;
1317
1318 if (acm > (0xFFFFFF * 100))
1319 acm = (0xFFFFFF * 100);
1320
1321 if (limit_reached EQ FALSE)
1322 {
1323 /*
1324 * request table id for SIM SAP access
1325 */
1326 table_id = psaSIM_atbNewEntry();
1327
1328 if(table_id NEQ NO_ENTRY)
1329 {
1330 /*
1331 * Fill formular for access
1332 *
1333 * set datafield type = Binary field
1334 * set datafield = SIM_ACM
1335 * set offset = 0 Bytes
1336 * set length = 3 Bytes
1337 */
1338 simShrdPrm.atb[table_id].accType = ACT_INC_DAT;
1339 simShrdPrm.atb[table_id].v_path_info = FALSE;
1340 simShrdPrm.atb[table_id].reqDataFld = SIM_ACM;
1341 simShrdPrm.atb[table_id].dataOff = 0;
1342 simShrdPrm.atb[table_id].dataLen = 3;
1343 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1344 simShrdPrm.atb[table_id].exchData = sim_data;
1345 simShrdPrm.atb[table_id].rplyCB = aoc_increment_cb;
1346 simShrdPrm.aId = table_id;
1347 sim_data[0] = (UBYTE)(acm_for_sim >> 16);
1348 sim_data[1] = (UBYTE)(acm_for_sim >> 8);
1349 sim_data[2] = (UBYTE)(acm_for_sim & 0xFF);
1350
1351 TRACE_EVENT_P1("ACM increment = %u", acm_for_sim);
1352
1353 if(psaSIM_AccessSIMData() < 0)
1354 {
1355 TRACE_EVENT("FATAL ERROR");
1356 }
1357 }
1358 }
1359 }
1360 aoc_send_ccm ();
1361 }
1362 }
1363
1364
1365 /*
1366 +--------------------------------------------------------------------+
1367 | PROJECT: GSM-PS (6147) MODULE: AOC |
1368 | STATE : code ROUTINE: aoc_increment_cb |
1369 +--------------------------------------------------------------------+
1370
1371 PURPOSE : Callback function for incrementing ACM.
1372
1373 */
1374
1375 void aoc_increment_cb(SHORT table_id)
1376 {
1377 UBYTE i;
1378 SHORT dummy_waitId; /* holds call waiting id */
1379 T_ACI_CMD_SRC src_dummy = CMD_SRC_NONE;
1380
1381
1382 TRACE_FUNCTION ("aoc_increment_cb()");
1383
1384 switch (simShrdPrm.atb[table_id].errCode)
1385 {
1386 case SIM_NO_ERROR:
1387 break;
1388 case SIM_CAUSE_MAX_INCREASE:
1389 /*
1390 * ACM has reached limit 0xFFFFFF,
1391 * If ACMMAX is zero, ACM shall be cleared
1392 * by MMI. Only an indication is forwarded
1393 * to MMI, else the call is released.
1394 */
1395 if (acmmax EQ 0)
1396 {
1397 limit_reached = TRUE;
1398 R_AT( RAT_CME, simEntStat.entOwn )
1399 ( AT_CMD_CACM, CME_ERR_AcmResetNeeded );
1400 break;
1401 }
1402 /*lint -fallthrough */
1403 default:
1404 /*
1405 * ACM increment is not successfull
1406 */
1407 aoc_state = AOC_DISABLE;
1408
1409 /*
1410 * release all chargeable calls
1411 */
1412 for (i=0;i<MAX_CALL_NR;i++)
1413 {
1414 if (aoc_non_zero_cai(i))
1415 {
1416 cmhCC_ClearCall (i,
1417 CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, MNCC_CAUSE_ACM_MAX),
1418 src_dummy, AT_CMD_NONE,
1419 &dummy_waitId);
1420 }
1421 }
1422 break;
1423 }
1424 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1425 }
1426
1427 /*
1428 +--------------------------------------------------------------------+
1429 | PROJECT: GSM-PS (6147) MODULE: AOC |
1430 | STATE : code ROUTINE: aoc_calculate_puct |
1431 +--------------------------------------------------------------------+
1432
1433 PURPOSE : Calculate counter in PUCT.
1434
1435 */
1436
1437 void aoc_calculate_puct (ULONG value, T_puct * result)
1438 {
1439 TRACE_FUNCTION ("aoc_calculate_puct()");
1440 #if defined WIN32
1441 {
1442 TRACE_EVENT_P1("EPPU %u",eppu);
1443 TRACE_EVENT_P1("SEXP %u",sexp);
1444 TRACE_EVENT_P1("EXP %u",exp);
1445 TRACE_EVENT_P1("VAL %u",value);
1446 }
1447 #endif
1448 /*
1449 * copy currency
1450 */
1451 memcpy (result->currency, currency, 4);
1452
1453 /*
1454 * Multiply counter value with elementary price per unit
1455 */
1456 value *= eppu;
1457 /*
1458 * If sexp is set divide by logarithm of ten, else multiply
1459 */
1460 if (sexp)
1461 {
1462 value *= 1000; /* internal calculation is 1/1000 unit */
1463 value /= exp; /* to support e-3 to e-1 */
1464 sprintf ((char *) result->value, "%u.%03u", value / 1000, value % 1000);
1465 }
1466 else
1467 {
1468 value *= exp;
1469 sprintf ((char *) result->value, "%u", value );
1470 }
1471 }
1472
1473
1474 /*
1475 +--------------------------------------------------------------------+
1476 | PROJECT: GSM-PS (6147) MODULE : AOC |
1477 | STATE : code ROUTINE: aoc_update_acm |
1478 +--------------------------------------------------------------------+
1479
1480 PURPOSE : The function tries to reset the ACM field on the SIM card.
1481
1482 */
1483
1484 void aoc_update_acm (UBYTE operation, ULONG value)
1485 {
1486 SHORT table_id;
1487
1488 TRACE_FUNCTION ("aoc_update_acm()");
1489
1490 /*
1491 * request table id for SIM SAP access
1492 */
1493 table_id = psaSIM_atbNewEntry();
1494 act_upd_op = operation;
1495
1496 if(table_id NEQ NO_ENTRY)
1497 {
1498 switch (operation)
1499 {
1500 case FIRST_UPDATE:
1501 /*
1502 * This is the first access to ACM. It may fail,
1503 * because PIN2 is needed.
1504 */
1505 act_value = 0L;
1506 /*lint -fallthrough*/
1507 case SECOND_UPDATE:
1508 /*
1509 * This is the second access to ACM after PIN entering.
1510 */
1511 simShrdPrm.atb[table_id].accType = ACT_WR_REC;
1512 simShrdPrm.atb[table_id].v_path_info = FALSE;
1513 simShrdPrm.atb[table_id].reqDataFld = SIM_ACM;
1514 simShrdPrm.atb[table_id].dataOff = 0;
1515 simShrdPrm.atb[table_id].dataLen = 3;
1516 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1517 simShrdPrm.atb[table_id].exchData = sim_data;
1518 simShrdPrm.atb[table_id].rplyCB = aoc_update_acm_cb;
1519 simShrdPrm.aId = table_id;
1520 sim_data[0] = (UBYTE)(act_value >> 16);
1521 sim_data[1] = (UBYTE)(act_value >> 8);
1522 sim_data[2] = (UBYTE)(act_value & 0xFF);
1523
1524 if(psaSIM_AccessSIMData() < 0)
1525 {
1526 TRACE_EVENT("FATAL ERROR");
1527 }
1528 break;
1529 }
1530 }
1531 }
1532
1533 /*
1534 +--------------------------------------------------------------------+
1535 | PROJECT: GSM-PS (6147) MODULE: AOC |
1536 | STATE : code ROUTINE: aoc_update_acm_cb |
1537 +--------------------------------------------------------------------+
1538
1539 PURPOSE : Callback function for updating ACM.
1540
1541 */
1542
1543 void aoc_update_acm_cb(SHORT table_id)
1544 {
1545
1546 TRACE_FUNCTION ("aoc_update_acm_cb()");
1547 /* Implements Measure 213 */
1548 aoc_update_sim_datafield_cb( table_id, AT_CMD_CACM );
1549 }
1550
1551
1552 /*
1553 +--------------------------------------------------------------------+
1554 | PROJECT: GSM-PS (6147) MODULE : AOC |
1555 | STATE : code ROUTINE: aoc_update_acmmax |
1556 +--------------------------------------------------------------------+
1557
1558 PURPOSE : The function tries to set the ACMMAX field on the SIM card.
1559
1560 */
1561
1562 void aoc_update_acmmax (UBYTE operation, ULONG value)
1563 {
1564 SHORT table_id;
1565
1566 TRACE_FUNCTION ("aoc_update_acmmax()");
1567
1568 /*
1569 * request table id for SIM SAP access
1570 */
1571 table_id = psaSIM_atbNewEntry();
1572 act_upd_op = operation;
1573
1574 if(table_id NEQ NO_ENTRY)
1575 {
1576 switch (operation)
1577 {
1578 case FIRST_UPDATE:
1579 /*
1580 * This is the first access to ACMMAX. It may fail,
1581 * because PIN2 is needed.
1582 */
1583 act_value = value;
1584 /*lint -fallthrough*/
1585 case SECOND_UPDATE:
1586 /*
1587 * This is the second access to ACMMAX after PIN entering.
1588 */
1589 simShrdPrm.atb[table_id].accType = ACT_WR_DAT;
1590 simShrdPrm.atb[table_id].v_path_info = FALSE;
1591 simShrdPrm.atb[table_id].reqDataFld = SIM_ACMMAX;
1592 simShrdPrm.atb[table_id].dataOff = 0;
1593 simShrdPrm.atb[table_id].dataLen = 3;
1594 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1595 simShrdPrm.atb[table_id].exchData = sim_data;
1596 simShrdPrm.atb[table_id].rplyCB = aoc_update_acmmax_cb;
1597 simShrdPrm.aId = table_id;
1598 sim_data[0] = (UBYTE)(act_value >> 16);
1599 sim_data[1] = (UBYTE)(act_value >> 8);
1600 sim_data[2] = (UBYTE)(act_value & 0xFF);
1601
1602 if(psaSIM_AccessSIMData() < 0)
1603 {
1604 TRACE_EVENT("FATAL ERROR");
1605 }
1606 break;
1607 }
1608 }
1609 }
1610
1611 /*
1612 +--------------------------------------------------------------------+
1613 | PROJECT: GSM-PS (6147) MODULE: AOC |
1614 | STATE : code ROUTINE: aoc_update_acmmax_cb |
1615 +--------------------------------------------------------------------+
1616
1617 PURPOSE : Callback function for updating ACMMax.
1618
1619 */
1620
1621 void aoc_update_acmmax_cb(SHORT table_id)
1622 {
1623
1624 TRACE_FUNCTION ("aoc_update_acmmax_cb()");
1625 /* Implements Measure 213 */
1626 aoc_update_sim_datafield_cb( table_id, AT_CMD_CAMM );
1627 }
1628
1629 /*
1630 +--------------------------------------------------------------------+
1631 | PROJECT: GSM-PS (6147) MODULE : AOC |
1632 | STATE : code ROUTINE: aoc_update_puct |
1633 +--------------------------------------------------------------------+
1634
1635 PURPOSE : The function tries to modify the PUCT field on the SIM card.
1636
1637 */
1638
1639 void aoc_update_puct (UBYTE operation, T_puct * value)
1640 {
1641 SHORT table_id;
1642
1643 TRACE_FUNCTION ("aoc_update_puct()");
1644
1645 /*
1646 * request table id for SIM SAP access
1647 */
1648 table_id = psaSIM_atbNewEntry();
1649 act_upd_op = operation;
1650
1651 if(table_id NEQ NO_ENTRY)
1652 {
1653 switch (operation)
1654 {
1655 case FIRST_UPDATE:
1656 /*
1657 * This is the first access to PUCT. It may fail,
1658 * because PIN2 is needed.
1659 */
1660 if (aoc_set_puct_values (value) EQ FALSE)
1661 {
1662 R_AT( RAT_CME, simEntStat.entOwn )
1663 ( AT_CMD_CPUC, CME_ERR_OpNotAllow );
1664
1665 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1666 return;
1667 }
1668 /*lint -fallthrough*/
1669 case SECOND_UPDATE:
1670 /*
1671 * This is the second access to PUCT after PIN entering.
1672 */
1673 simShrdPrm.atb[table_id].accType = ACT_WR_DAT;
1674 simShrdPrm.atb[table_id].v_path_info = FALSE;
1675 simShrdPrm.atb[table_id].reqDataFld = SIM_PUCT;
1676 simShrdPrm.atb[table_id].dataOff = 0;
1677 simShrdPrm.atb[table_id].dataLen = 5;
1678 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
1679 simShrdPrm.atb[table_id].exchData = sim_data;
1680 simShrdPrm.atb[table_id].rplyCB = aoc_update_puct_cb;
1681 simShrdPrm.aId = table_id;
1682 if(psaSIM_AccessSIMData() < 0)
1683 {
1684 TRACE_EVENT("FATAL ERROR");
1685 }
1686 break;
1687 }
1688 }
1689 }
1690
1691 /*
1692 +--------------------------------------------------------------------+
1693 | PROJECT: GSM-PS (6147) MODULE: AOC |
1694 | STATE : code ROUTINE: aoc_update_puct_cb |
1695 +--------------------------------------------------------------------+
1696
1697 PURPOSE : Callback function for updating PUCT.
1698
1699 */
1700
1701 void aoc_update_puct_cb(SHORT table_id)
1702 {
1703 T_SIM_SET_PRM * pSIMSetPrm; /* points to MM parameter set */
1704 UBYTE index;
1705
1706 TRACE_FUNCTION ("aoc_update_puct_cb()");
1707
1708 switch (simShrdPrm.atb[table_id].errCode)
1709 {
1710 case SIM_NO_ERROR:
1711 /*
1712 * No error has occured, read ACM etc. again from SIM Card
1713 */
1714 currency [0] = sim_data[0];
1715 currency [1] = sim_data[1];
1716 currency [2] = sim_data[2];
1717 currency [3] = 0;
1718 eppu = (sim_data[3]<<4 & 0xFF0) + (sim_data[4] & 0x0F);
1719 index = sim_data[4]>>4 & 0x0F;
1720
1721 if (index > 15) /* only 0 to 15 */
1722 {
1723 index = 15;
1724 }
1725
1726 exp = ppu_values[index][0];
1727 sexp = ppu_values[index][1];
1728
1729 simEntStat.curCmd = AT_CMD_NONE;
1730 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1731 R_AT( RAT_OK, simEntStat.entOwn) (AT_CMD_CPUC );
1732 aoc_sms ();
1733 break;
1734 case SIM_CAUSE_PIN2_EXPECT:
1735 /*
1736 * error has occured, maybe PIN2 is needed
1737 */
1738 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1739 if (strlen ((char *) pwd) AND
1740 act_upd_op EQ FIRST_UPDATE)
1741 {
1742 /*
1743 * Password is available and
1744 * it is the first update, then
1745 * try to verify PIN2
1746 */
1747 act_upd_op = VERIFY_PWD;
1748 pSIMSetPrm = &simShrdPrm.setPrm[act_src_id];
1749
1750 cmhSIM_FillInPIN ( (char *) pwd, pSIMSetPrm -> curPIN, PIN_LEN);
1751 pSIMSetPrm -> PINType = PHASE_2_PIN_2;
1752 simEntStat.curCmd = AT_CMD_CPUC;
1753 simShrdPrm.owner = (T_OWN)act_src_id;
1754 simEntStat.entOwn = act_src_id;
1755
1756 if ( psaSIM_VerifyPIN() < 0 ) /* verify PIN */
1757 {
1758 TRACE_EVENT( "FATAL RETURN psaSIM in +CAMM" );
1759 }
1760 }
1761 else
1762 {
1763 /*
1764 * PIN2 not available or second attempt
1765 */
1766 simEntStat.curCmd = AT_CMD_NONE;
1767 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1768 if (act_upd_op EQ FIRST_UPDATE)
1769 {
1770 R_AT( RAT_CME, simEntStat.entOwn )
1771 ( AT_CMD_CPUC, CME_ERR_SimPin2Req );
1772 }
1773 else
1774 {
1775 R_AT( RAT_CME, simEntStat.entOwn )
1776 ( AT_CMD_CPUC, CME_ERR_WrongPasswd );
1777 }
1778 }
1779 break;
1780 default:
1781 /*
1782 * Any other error, respective error code is returned
1783 */
1784 simEntStat.curCmd = AT_CMD_NONE;
1785 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
1786 R_AT( RAT_CME, simEntStat.entOwn )
1787 (
1788 AT_CMD_CPUC,
1789 cmhSIM_GetCmeFromSim ( simShrdPrm.atb[table_id].errCode )
1790 );
1791 break;
1792 }
1793 }
1794
1795 /*
1796 +--------------------------------------------------------------------+
1797 | PROJECT: GSM-PS (6147) MODULE: AOC |
1798 | STATE : code ROUTINE: aoc_set_puct_values |
1799 +--------------------------------------------------------------------+
1800
1801 PURPOSE : Converts the PUCT values from string to SIM format.
1802 */
1803
1804 UBYTE aoc_set_puct_values(T_puct * puct)
1805 {
1806 UBYTE first_digit = FALSE;
1807 UBYTE colon_found = FALSE;
1808 UBYTE position_dot = 0;
1809 SHORT temp_pos = 0;
1810 SHORT position = 0;
1811 SHORT length = 0;
1812 ULONG eppu = 0L;
1813 ULONG temp_eppu = 0L;
1814 UBYTE i;
1815
1816 TRACE_FUNCTION ("aoc_set_puct_values()");
1817
1818 sim_data[0] = puct->currency [0];
1819 sim_data[1] = puct->currency [1];
1820 sim_data[2] = puct->currency [2];
1821
1822 for (i=0;i<20;i++)
1823 {
1824 if (puct->value[i] EQ '\0')
1825 break;
1826
1827 if (first_digit)
1828 {
1829 /* at least one digit detected */
1830 if (colon_found)
1831 {
1832 /* checking the digits after the colon */
1833 switch (puct->value[i])
1834 {
1835 case '0':
1836 /* zeros after the colon are counted */
1837 temp_eppu = temp_eppu * 10 + (puct->value[i] - '0');
1838 temp_pos++;
1839 break;
1840
1841 default:
1842 /* digits available before the colon */
1843 eppu = (temp_eppu * 10) + (puct->value[i] - '0');
1844 temp_eppu = eppu;
1845 length = length + temp_pos + 1;
1846 temp_pos = 0;
1847 if (position_dot)
1848 {
1849 position = position_dot;
1850 position_dot = 0;
1851 }
1852 break;
1853 }
1854 }
1855 else
1856 {
1857 /* checking the digits before the colon */
1858 switch (puct->value[i])
1859 {
1860 case '0':
1861 /* zeros before the colon are counted */
1862 temp_eppu = temp_eppu * 10 + (puct->value[i] - '0');
1863 temp_pos++;
1864 break;
1865
1866 case '.':
1867 colon_found = TRUE;
1868 position_dot = position + temp_pos;
1869 length += temp_pos;
1870 temp_pos = 0;
1871 break;
1872
1873 default:
1874 /* digits available before the colon */
1875 if (temp_pos)
1876 eppu = (temp_eppu * 10) + (puct->value[i] - '0');
1877 else
1878 eppu = eppu * 10 + (puct->value[i] - '0');
1879 temp_eppu = eppu;
1880 length = length + temp_pos + 1;
1881 position = position + temp_pos + 1;
1882 temp_pos = 0;
1883 break;
1884 }
1885 }
1886 }
1887 else
1888 {
1889 /* no digit found */
1890 if (colon_found)
1891 {
1892 /* searching for the first digit after the colon
1893 * e.g. 0.0034 */
1894 switch (puct->value[i])
1895 {
1896 case '0':
1897 /* count the number of zeros after the colon */
1898 temp_pos++;
1899 break;
1900
1901 default:
1902 /* digits available before the colon */
1903 first_digit = TRUE;
1904 position -= temp_pos;
1905 temp_pos = 0;
1906 temp_eppu = eppu = puct->value[i]-'0';
1907 length++;
1908 break;
1909 }
1910 }
1911 else
1912 {
1913 /* checking the digits before the colon
1914 * e.g 234.56 looking for the 2 */
1915 switch (puct->value[i])
1916 {
1917 case '0':
1918 /* leading zeros are ignored */
1919 break;
1920 case '.':
1921 /* no digits before the colon, e.g. 0.23 */
1922 colon_found = TRUE;
1923 break;
1924 default:
1925 /* digits available before the colon */
1926 first_digit = TRUE;
1927 temp_eppu = eppu = puct->value[i]-'0';
1928 position++;
1929 length++;
1930 break;
1931 }
1932 }
1933 }
1934
1935 if (puct->value[i] EQ 0)
1936 break;
1937 }
1938
1939 #if defined WIN32
1940 {
1941 TRACE_EVENT_P2("PUCT POS=%d LEN=%d", position, length);
1942 TRACE_EVENT_P1("EPPU=%d", eppu);
1943 }
1944 #endif
1945
1946 /*
1947 * check the maximum of EPPU
1948 */
1949 if (eppu > 0xFFF)
1950 return FALSE;
1951
1952 /*
1953 * set the EPPU, SEXP and EXP for the SIM Card
1954 */
1955
1956 sim_data[3] = (UBYTE)(eppu >> 4);
1957 sim_data[4] = (UBYTE)(eppu & 0xF);
1958
1959
1960 /*
1961 * for the case : reset PUCT
1962 */
1963 if (!first_digit)
1964 {
1965 /*
1966 * set the first 4 bits of the fifth bytes to 0 (exp2, exp1, exp0, sexp)
1967 */
1968 sim_data[4] = sim_data[4] & 0x0F;
1969 }
1970 else
1971 {
1972 if (!colon_found)
1973 {
1974 if (temp_pos)
1975 {
1976 sim_data[4] += (temp_pos << 5);
1977 }
1978 else
1979 {
1980 sim_data[4] += ((length - position) << 5);
1981 }
1982 }
1983 else
1984 {
1985 if (position_dot NEQ 0)
1986 sim_data[4] += ((length - position) << 5);
1987 else
1988 sim_data[4] += 0x10 + ((length - position) << 5);
1989 }
1990 }
1991 return TRUE;
1992 }
1993
1994
1995 /*
1996 +--------------------------------------------------------------------+
1997 | PROJECT: GSM-PS (6147) MODULE: AOC |
1998 | STATE : code ROUTINE: aoc_parameter |
1999 +--------------------------------------------------------------------+
2000
2001 PURPOSE : Copies the e-parameters of the facility IE.
2002
2003 */
2004 void aoc_parameter(SHORT Cid, T_FWD_CHG_ADVICE_INV * aoc_para)
2005 {
2006 T_chargingInformation * charge;
2007
2008 TRACE_FUNCTION ("aoc_parameter()");
2009
2010 switch (aoc_para->forwardChargeAdviceArg.ssCode)
2011 {
2012 case(SS_CD_AOCI):
2013 cc_aoc_table[Cid].aoci_active=TRUE;
2014 break;
2015 case(SS_CD_AOCC):
2016 cc_aoc_table[Cid].aoci_active=FALSE;
2017 break;
2018 default:
2019 TRACE_EVENT_P1("UNEXPECTED SS_CODE in FWD_AOC %d, assume AOCC", aoc_para->forwardChargeAdviceArg.ssCode);
2020 cc_aoc_table[Cid].aoci_active=FALSE;
2021 }
2022
2023 charge = &aoc_para->forwardChargeAdviceArg.chargingInformation;
2024
2025 cc_aoc_table[Cid].new_data_avail = TRUE;
2026
2027 if (charge->v_e1)
2028 {
2029 if (cc_aoc_table[Cid].aoc_timer_running)
2030 {
2031 /* E1 is available, 4.3.e) special */
2032 cc_aoc_table[Cid].e1_next = aoc_getEVal(&charge->e1);
2033 cc_aoc_table[Cid].e_next_bitmap |= E1_CHANGED;
2034 TRACE_EVENT_P1("E1 = %u", cc_aoc_table[Cid].e1_next);
2035 }
2036 else
2037 {
2038 cc_aoc_table[Cid].e1 = aoc_getEVal(&charge->e1);
2039 TRACE_EVENT_P1("E1 = %u", cc_aoc_table[Cid].e1);
2040 }
2041
2042 }
2043
2044 if (charge->v_e2)
2045 {
2046 if (cc_aoc_table[Cid].aoc_timer_running)
2047 {
2048 /* E2 is available, 4.3.e) special */
2049 cc_aoc_table[Cid].e2_next = aoc_getEVal(&charge->e2);
2050 cc_aoc_table[Cid].e_next_bitmap |= E2_CHANGED;
2051 TRACE_EVENT_P1("E2 = %u", cc_aoc_table[Cid].e2_next);
2052 }
2053 else
2054 {
2055 cc_aoc_table[Cid].e2 = aoc_getEVal(&charge->e2);
2056 TRACE_EVENT_P1("E2 = %u", cc_aoc_table[Cid].e2);
2057 }
2058 }
2059
2060 if (charge->v_e3)
2061 {
2062 /* Special handling of E3, see AOC08226 */
2063 cc_aoc_table[Cid].e3_next = aoc_getEVal(&charge->e3);
2064 cc_aoc_table[Cid].e_next_bitmap |= E3_CHANGED;
2065 TRACE_EVENT_P1("E3 = %u", cc_aoc_table[Cid].e3_next);
2066 }
2067
2068 if (charge->v_e4)
2069 {
2070 cc_aoc_table[Cid].e4 = aoc_getEVal(&charge->e4);
2071 cc_aoc_table[Cid].e_next_bitmap |= E4_CHANGED;
2072 TRACE_EVENT_P1("E4 = %u", cc_aoc_table[Cid].e4);
2073 }
2074
2075 /* e5 and e6 are not (yet?) supported */
2076 if (charge->v_e5)
2077 {
2078 cc_aoc_table[Cid].e5 = aoc_getEVal(&charge->e5);
2079 TRACE_EVENT_P1("E5 = %u", cc_aoc_table[Cid].e5);
2080 }
2081
2082 if (charge->v_e6)
2083 {
2084 cc_aoc_table[Cid].e6 = aoc_getEVal(&charge->e6);
2085 TRACE_EVENT_P1("E6 = %u", cc_aoc_table[Cid].e6);
2086 }
2087
2088 if (charge->v_e7)
2089 {
2090 if (cc_aoc_table[Cid].aoc_timer_running)
2091 {
2092 /* E7 is available, 4.3.e) special */
2093 cc_aoc_table[Cid].e7_next = aoc_getEVal(&charge->e7);
2094 cc_aoc_table[Cid].e_next_bitmap |= E7_CHANGED;
2095 TRACE_EVENT_P1("E7 = %u", cc_aoc_table[Cid].e7_next);
2096 }
2097 else
2098 {
2099 cc_aoc_table[Cid].e7 = aoc_getEVal(&charge->e7);
2100 TRACE_EVENT_P1("E7 = %u", cc_aoc_table[Cid].e7);
2101 }
2102
2103 }
2104
2105 if(cc_aoc_table[Cid].e_next_bitmap & (E1_CHANGED | E2_CHANGED | E7_CHANGED))
2106 {
2107 /* e3 should be applied to the parameters held in abeyance, see AOC08226 */
2108 }
2109 else
2110 {
2111 /* bring e3 immediately into operation */
2112 cc_aoc_table[Cid].e3 = cc_aoc_table[Cid].e3_next;
2113 }
2114
2115
2116
2117 if(cc_aoc_table[Cid].e_next_bitmap & E3_CHANGED)
2118 {
2119 /* e3 is updated recalc is needed now */
2120 aoc_calculate_charging_parameter_part2( Cid );
2121 }
2122
2123 /*
2124 if(cc_aoc_table[Cid].e_next_bitmap & E4_CHANGED)
2125 {
2126 if e4 is updated while charging running, charge amount now
2127 if (cc_aoc_table[Cid].aoc_timer_running EQ TRUE)
2128 {
2129 aoc_calculate_charging_parameter_part1( Cid );
2130 aoc_increment_initial_charge( Cid );
2131 cc_aoc_table[Cid].e_next_bitmap &= ~E4_CHANGED;
2132 }
2133 }
2134 */
2135
2136 }
2137
2138 /*
2139 +--------------------------------------------------------------------+
2140 | PROJECT: GSM-PS (6147) MODULE: AOC |
2141 | STATE : code ROUTINE: aoc_getEVal |
2142 +--------------------------------------------------------------------+
2143
2144 PURPOSE : Assembles e-value out of the facility IE.
2145 */
2146
2147 USHORT aoc_getEVal( void * eBuf )
2148 {
2149 T_e1 *pE = (T_e1*)eBuf;
2150 USHORT val = 0;
2151 UBYTE len;
2152
2153 for( len = 0; len < pE->c_e_val; len++ )
2154 {
2155 val<<= 8;
2156 val += pE->e_val[len];
2157 }
2158
2159 return( val );
2160 }
2161
2162
2163 /*
2164 +--------------------------------------------------------------------+
2165 | PROJECT: GSM-PS (6147) MODULE: AOC |
2166 | STATE : code ROUTINE: aoc_send_ccm |
2167 +--------------------------------------------------------------------+
2168
2169 PURPOSE : The ccm is forwarded if at least one of the calls is
2170 active.
2171 */
2172
2173 void aoc_send_ccm ()
2174 {
2175 ULONG ccm_output;
2176 T_ACI_CMD_SRC idx;
2177
2178 if (qAT_CallActive())
2179 {
2180 /* call back function to notify the MMI */
2181 for( idx = CMD_SRC_LCL; idx < CMD_SRC_MAX; idx++ )
2182 {
2183 /*
2184 * forward ccm in whole units to MMI
2185 */
2186 ccm_output = MC_AOC_ROUND_UP(ccm);
2187
2188 R_AT( RAT_CCCM, idx )( &ccm_output );
2189 }
2190 }
2191 }
2192
2193 /*
2194 +--------------------------------------------------------------------+
2195 | PROJECT: GSM-PS (6147) MODULE: AOC |
2196 | STATE : code ROUTINE: aoc_set_time_ut_charge |
2197 +--------------------------------------------------------------------+
2198
2199 PURPOSE : This function is used to set the period of time until
2200 the next charging occur.
2201 */
2202
2203 void aoc_set_time_ut_charge ( SHORT cId, T_TIME time )
2204 {
2205 UBYTE mode = AOC_CALL_TIMER_ELAPSED; /* indicates the elapsed */
2206 /* timer */
2207 /*
2208 * in case an AoC timer is elapsed the time until
2209 * next charging will be fixed to the new value
2210 */
2211 if ( cId NEQ ACI_NumParmNotPresent )
2212 {
2213 cc_aoc_table[cId].time_ut_charge = time;
2214 mode = AOC_AOC_TIMER_ELAPSED;
2215 }
2216
2217 aoc_calc_expct_charge ( mode );
2218 }
2219
2220 /*
2221 +--------------------------------------------------------------------+
2222 | PROJECT: GSM-PS (6147) MODULE: AOC |
2223 | STATE : code ROUTINE: aoc_calc_expct_charge |
2224 +--------------------------------------------------------------------+
2225
2226 PURPOSE : This function is used to calculate the amount of charge
2227 which is going to be consumed during the period of time
2228 fixed by AOC_MAX_REMAIN_CALL_TIME.
2229 */
2230
2231 void aoc_calc_expct_charge ( UBYTE mode )
2232 {
2233 ULONG expct_charge = 0; /* expected charge */
2234 T_TIME remain_time; /* remaining time until next */
2235 ULONG num_chrg_pts; /* number of charging points */
2236 UBYTE idx; /* used for counting */
2237 BOOL aoc_running = FALSE; /* indicates whether at least */
2238 /* one AoC timer is running */
2239
2240 for ( idx = 0; idx < MAX_CALL_NR; idx++ )
2241 {
2242 if ( cc_aoc_table[idx].aoc_timer_running AND cc_aoc_table[idx].e1 )
2243 {
2244 aoc_running = TRUE;
2245
2246 if ( mode EQ AOC_CALL_TIMER_ELAPSED )
2247 {
2248 #if defined (WIN32)
2249 TRACE_EVENT_P1("time to charge: %d ms",
2250 cc_aoc_table[idx].time_ut_charge - AOC_THOUSAND_MILLISECONDS);
2251 #endif
2252
2253 /* in case the call timer is elapsed the actual
2254 * time until next charging will be calculated */
2255 if (cc_aoc_table[idx].time_ut_charge >= AOC_THOUSAND_MILLISECONDS)
2256 {
2257 cc_aoc_table[idx].time_ut_charge -= AOC_THOUSAND_MILLISECONDS;
2258 }
2259 else
2260 {
2261 /* calculate the expected charging intervals based on the E parameter */
2262 if ( cc_aoc_table[idx].new_data_avail EQ TRUE AND
2263 cc_aoc_table[idx].e_next_bitmap & E7_CHANGED )
2264 {
2265 cc_aoc_table[idx].time_ut_charge = aoc_calc_time_ut_charge ( idx, E7_CHANGED );
2266 }
2267 else if ( cc_aoc_table[idx].e_next_bitmap & E2_CHANGED )
2268 {
2269 cc_aoc_table[idx].time_ut_charge = aoc_calc_time_ut_charge ( idx, E2_CHANGED );
2270 }
2271 else
2272 {
2273 cc_aoc_table[idx].time_ut_charge = ~0L;
2274 }
2275
2276 /* calculate the expected initial charge and
2277 * add to the expected charge */
2278 /* The fixed amount is charged immediately and not somewhen later
2279 if ( cc_aoc_table[idx].new_data_avail EQ TRUE AND
2280 cc_aoc_table[idx].e_bitmap & E4_AVAILABLE )
2281 {
2282 expct_charge += ( ( ULONG ) cc_aoc_table[idx].e3 *
2283 ( ULONG ) cc_aoc_table[idx].e4 ) / 10;
2284 }
2285 */
2286 }
2287 }
2288
2289 /* calculate expected charge for next AOC_MAX_REMAIN_CALL_TIME milliseconds */
2290 num_chrg_pts = 1;
2291
2292 if ( cc_aoc_table[idx].time_ut_charge <= AOC_MAX_REMAIN_CALL_TIME )
2293 {
2294 if (cc_aoc_table[idx].e2)
2295 {
2296 remain_time = AOC_MAX_REMAIN_CALL_TIME -
2297 cc_aoc_table[idx].time_ut_charge;
2298 num_chrg_pts +=
2299 (ULONG)(remain_time / E_IN_MS ( cc_aoc_table[idx].e2 ));
2300 }
2301
2302 expct_charge += ( num_chrg_pts *
2303 ( cc_aoc_table[idx].e1 * cc_aoc_table[idx].e3 ) / 10 );
2304 }
2305 }
2306 }
2307
2308 aoc_calc_acm_wrn_evnt ( expct_charge, aoc_running );
2309 }
2310
2311 /*
2312 +--------------------------------------------------------------------+
2313 | PROJECT: GSM-PS (6147) MODULE: AOC |
2314 | STATE : code ROUTINE: aoc_calc_acm_wrn_evnt |
2315 +--------------------------------------------------------------------+
2316
2317 PURPOSE : In case the remaining credit is low a call timer warning
2318 event is generated.
2319 */
2320
2321 void aoc_calc_acm_wrn_evnt ( ULONG charge, BOOL aoc_running )
2322 {
2323 ULONG credit; /* remaining credit */
2324 ULONG acm_for_sim; /* lack of the actual ACM value */
2325 T_ACI_CCWV_CHRG charging; /* CCWV mode indicated to MMI */
2326
2327 /*
2328 * the update on the SIM is the difference between the rounded up
2329 * value of the current CCM and the old CCM (already rounded up)
2330 */
2331 acm_for_sim = MC_AOC_ROUND_UP(ccm) - MC_AOC_ROUND_UP(ccm_already_incremented);
2332 credit = acmmax - acm - ( acm_for_sim * 100 );
2333
2334 #if defined (WIN32)
2335 {
2336 TRACE_EVENT_P2("AoC charge for next %u ms = %u", AOC_MAX_REMAIN_CALL_TIME, charge );
2337 }
2338 #endif
2339
2340 if ( aoc_running EQ TRUE )
2341 {
2342 if ( charge >= credit )
2343 charging = CCWV_CHRG_Shortage;
2344 else
2345 charging = CCWV_CHRG_Abundance;
2346 }
2347 else
2348 charging = CCWV_CHRG_Termination;
2349
2350 aoc_ntfy_acm_wrn_evnt ( charging );
2351 }
2352
2353 /*
2354 +--------------------------------------------------------------------+
2355 | PROJECT: GSM-PS (6147) MODULE: AOC |
2356 | STATE : code ROUTINE: aoc_ntfy_acm_wrn_evnt |
2357 +--------------------------------------------------------------------+
2358
2359 PURPOSE : Notifies the MMI about the call meter warning event.
2360
2361 */
2362 void aoc_ntfy_acm_wrn_evnt ( T_ACI_CCWV_CHRG charging )
2363 {
2364 T_ACI_CMD_SRC idx;
2365
2366 if ( ccwv_charging NEQ charging )
2367 {
2368 ccwv_charging = charging;
2369
2370 for( idx=CMD_SRC_LCL; idx<CMD_SRC_MAX; idx++ )
2371 {
2372 R_AT( RAT_CCWV, idx )( charging );
2373 }
2374 }
2375 }
2376
2377 /*
2378 +--------------------------------------------------------------------+
2379 | PROJECT: GSM-PS (6147) MODULE: AOC |
2380 | STATE : code ROUTINE: aoc_calc_time_ut_charge |
2381 +--------------------------------------------------------------------+
2382
2383 PURPOSE : This function calculates the new time to charge with
2384 respect to the previous value.
2385
2386 */
2387 T_TIME aoc_calc_time_ut_charge ( SHORT cId,
2388 UBYTE e_value_flag )
2389 {
2390 T_TIME new_time = ~0L; /* new time until next charging */
2391 T_TIME e_value; /* interval value */
2392
2393 switch ( e_value_flag )
2394 {
2395 case (E2_CHANGED): e_value = E_IN_MS ( cc_aoc_table[cId].e2 );
2396 break;
2397 case (E7_CHANGED): e_value = E_IN_MS ( cc_aoc_table[cId].e7 );
2398 break;
2399 default : e_value = 0L;
2400 break;
2401 }
2402
2403 if ( e_value <= ( AOC_THOUSAND_MILLISECONDS - cc_aoc_table[cId].time_ut_charge ) )
2404 {
2405 new_time = e_value;
2406 }
2407 else if ( e_value NEQ 0L )
2408 {
2409 new_time = e_value - ( AOC_THOUSAND_MILLISECONDS - cc_aoc_table[cId].time_ut_charge );
2410 }
2411
2412 return new_time;
2413 }
2414
2415 /* Implements Measure 213 */
2416 /*
2417 +------------------------------------------------------------------------------
2418 | Function : aoc_update_sim_datafield_cb
2419 +------------------------------------------------------------------------------
2420 | Purpose : Callback function for updating ACM.or ACMMAX Field
2421 | on the SIM Card.
2422 |
2423 | Parameters : table_id -
2424 | at_cmd_idn - AT COMMAND Identifier
2425 | (AT_CMD_CAMM or AT_CMD_CACM)
2426 |
2427 | Return : void
2428 +------------------------------------------------------------------------------
2429 */
2430
2431 LOCAL void aoc_update_sim_datafield_cb(SHORT table_id, T_ACI_AT_CMD at_cmd_idn)
2432 {
2433 T_SIM_SET_PRM * pSIMSetPrm; /* points to MM parameter set */
2434
2435 TRACE_FUNCTION ("aoc_update_sim_datafield_cb()");
2436
2437 simEntStat.curCmd = AT_CMD_NONE;
2438 simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
2439
2440 switch (simShrdPrm.atb[table_id].errCode)
2441 {
2442 case SIM_NO_ERROR:
2443 /*
2444 * No error has occured, read ACM etc. again from SIM Card
2445 */
2446 R_AT( RAT_OK, simEntStat.entOwn) (at_cmd_idn);
2447 aoc_sms ();
2448
2449 if (at_cmd_idn EQ AT_CMD_CAMM)
2450 {
2451 aoc_set_time_ut_charge ( ACI_NumParmNotPresent, 0L );
2452 }
2453 break;
2454 case SIM_CAUSE_PIN2_EXPECT:
2455 /*
2456 * error has occured, maybe PIN2 is needed
2457 */
2458 if (strlen ((char *) pwd) AND
2459 act_upd_op EQ FIRST_UPDATE)
2460 {
2461 /*
2462 * Password is available and
2463 * it is the first update, then
2464 * try to verify PIN2
2465 */
2466 act_upd_op = VERIFY_PWD;
2467 pSIMSetPrm = &simShrdPrm.setPrm[act_src_id];
2468
2469 cmhSIM_FillInPIN ( (char *) pwd, pSIMSetPrm -> curPIN, PIN_LEN);
2470 pSIMSetPrm -> PINType = PHASE_2_PIN_2;
2471 simEntStat.curCmd = at_cmd_idn;
2472 simShrdPrm.owner = (T_OWN)act_src_id;
2473 simEntStat.entOwn = act_src_id;
2474
2475 if ( psaSIM_VerifyPIN() < 0 ) /* verify PIN */
2476 {
2477 TRACE_EVENT( "FATAL RETURN psaSIM in +CACM or +CAMM" );
2478 }
2479 }
2480 else
2481 {
2482 /*
2483 * PIN2 not available or second attempt
2484 */
2485 if (act_upd_op EQ FIRST_UPDATE)
2486 {
2487 R_AT( RAT_CME, simEntStat.entOwn )
2488 ( at_cmd_idn, CME_ERR_SimPin2Req );
2489 }
2490 else
2491 {
2492 R_AT( RAT_CME, simEntStat.entOwn )
2493 ( at_cmd_idn, CME_ERR_WrongPasswd );
2494 }
2495 }
2496 break;
2497 default:
2498 /*
2499 * Any other error, respective error code is returned
2500 */
2501 R_AT( RAT_CME, simEntStat.entOwn )
2502 (
2503 at_cmd_idn,
2504 cmhSIM_GetCmeFromSim ( simShrdPrm.atb[table_id].errCode )
2505 );
2506 break;
2507 }
2508 }
2509
2510 /* Implements Measure 156 and 157 */
2511 /*
2512 +------------------------------------------------------------------------------
2513 | Function : aoc_read_sim_datafield
2514 +------------------------------------------------------------------------------
2515 | Purpose : Reads the SIM_ACM , SIM_ACMMAX and SIM_PUCT field
2516 | on the SIM card
2517 |
2518 | Parameters : accType - ACCESS TYPE, (ACT_RD_REC or ACT_RD_DAT)
2519 | reqDataFld - Requested DataField Identifier
2520 | (SIM_ACM/SIM_ACMMAX/SIM_PUCT)
2521 | rplyCB - Pointer to the Reply Call Back Function
2522 | (aoc_read_acm_cb or aoc_read_acmmax_cb)
2523 | dataLen - Data Length depending upon the which
2524 | field to be read.
2525 |
2526 | Return : void
2527 +------------------------------------------------------------------------------
2528 */
2529
2530 LOCAL void aoc_read_sim_datafield ( UBYTE accType, USHORT reqDataFld,
2531 void (*rplyCB)(SHORT), UBYTE dataLen)
2532 {
2533 SHORT table_id;
2534
2535 TRACE_FUNCTION ("aoc_read_sim_datafield()");
2536
2537 table_id = psaSIM_atbNewEntry();
2538
2539 if(table_id NEQ NO_ENTRY)
2540 {
2541 simShrdPrm.atb[table_id].accType = accType;
2542 simShrdPrm.atb[table_id].v_path_info = FALSE;
2543 simShrdPrm.atb[table_id].reqDataFld = reqDataFld;
2544 if (reqDataFld EQ SIM_ACM)
2545 {
2546 simShrdPrm.atb[table_id].recNr = 1;
2547 }
2548 else
2549 {
2550 simShrdPrm.atb[table_id].dataOff = 0;
2551 }
2552 simShrdPrm.atb[table_id].dataLen = dataLen;
2553 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
2554 simShrdPrm.atb[table_id].exchData = sim_data;
2555 simShrdPrm.atb[table_id].rplyCB = rplyCB;
2556
2557 simShrdPrm.aId = table_id;
2558 if(psaSIM_AccessSIMData() < 0)
2559 {
2560 TRACE_EVENT("FATAL ERROR");
2561 }
2562 }
2563 }
2564
2565 /* Implements Measure 152 */
2566 /*
2567 +------------------------------------------------------------------------------
2568 | Function : aoc_update_sim_datafield
2569 +------------------------------------------------------------------------------
2570 | Purpose : Updates the ACM field on the SIM card
2571 |
2572 | Parameters : operation - FIRST_UPDATE or SECOND_UPDATE
2573 | accType - ACCESS TYPE, (ACT_WR_REC or ACT_WR_DAT)
2574 | reqDataFld - Requested DataField Identifier
2575 | (SIM_ACM or SIM_ACMMAX)
2576 | rplyCB - Pointer to the Reply Call Back Function
2577 | (aoc_update_acm_cb or aoc_update_acmmax_cb)
2578 |
2579 | Return : void
2580 +------------------------------------------------------------------------------
2581 */
2582
2583 void aoc_update_sim_datafield ( UBYTE operation, UBYTE accType,
2584 USHORT reqDataFld, void (*rplyCB)(SHORT) )
2585 {
2586 SHORT table_id;
2587
2588 TRACE_FUNCTION ("aoc_update_sim_datafield()");
2589
2590 /*
2591 * request table id for SIM SAP access
2592 */
2593 table_id = psaSIM_atbNewEntry();
2594 act_upd_op = operation;
2595
2596 if(table_id NEQ NO_ENTRY)
2597 {
2598 simShrdPrm.atb[table_id].accType = accType;
2599 simShrdPrm.atb[table_id].v_path_info = FALSE;
2600 simShrdPrm.atb[table_id].reqDataFld = reqDataFld;
2601 simShrdPrm.atb[table_id].dataOff = 0;
2602 simShrdPrm.atb[table_id].dataLen = 3;
2603 simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
2604 simShrdPrm.atb[table_id].exchData = sim_data;
2605 simShrdPrm.atb[table_id].rplyCB = rplyCB;
2606 simShrdPrm.aId = table_id;
2607
2608 sim_data[0] = (UBYTE)(act_value >> 16);
2609 sim_data[1] = (UBYTE)(act_value >> 8);
2610 sim_data[2] = (UBYTE)(act_value & 0xFF);
2611
2612 if(psaSIM_AccessSIMData() < 0)
2613 {
2614 TRACE_EVENT("FATAL ERROR");
2615 }
2616 }
2617 }
2618