FreeCalypso > hg > tcs211-c139

comparison g23m/condat/ms/src/mfw/mfw_gprs.c @ 0:509db1a7b7b8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:509db1a7b7b8
1 /*
2 +--------------------------------------------------------------------+
3 | PROJECT: MMI-Framework (8417) $Workfile:: mfw_gprs.c $|
4 | $Author: KGT $Revision:: 1 $|
5 | CREATED: 13.02.2001 $Modtime:: 13.02.2001 |
6 | STATE : code |
7 +--------------------------------------------------------------------+
8
9 MODULE : MFW_GPRS
10
11 PURPOSE : This modul contains functions needed for the GPRS
12 management in MFW.
13
14 $History: Mfw_gprs.c
15
16 Feb 24, 2006 REF:DR OMAPS00068976 x0035544
17 Description: GPRS attach icon - MMI follow up issue of OMAPS00051034
18 solution: Added the function p_gprs_status() to querry the gprs status and to
19 store the status info in the structure variable stat.
20
21 $End
22 */
23
24 /* include necessary header files ----------------------------------*/
25
26 #ifndef NEW_FRAME
27 #error GPRS need NEW_FRAME
28 #endif /* NEW_FRAME */
29
30 #include <string.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33
34 #include "typedefs.h"
35 #include "mfw_mfw.h"
36 #include "vsi.h"
37 #include "custom.h"
38 #include "gsm.h"
39
40 #include "message.h"
41 #include "prim.h"
42 #include "aci_cmh.h" /* include types declared in ACI */
43
44 // ADDED BY RAVI - 30-11-2005
45 #if (defined(FF_2TO1_PS) || (BOARD == 61))
46 #include "aci_all.h"
47 #include "ati_cmd.h"
48 #include "aci_cmd.h"
49 #include "aci.h"
50 #include "dti_conn_mng.h"
51 #include "dti_cntrl_mng.h"
52 #include "gaci.h"
53 #endif
54 // END RAVI
55
56 #include "gaci_cmh.h" /* include types declared in GACI */
57 //#include "cus_aci.h"
58 #include "prim.h"
59 #ifndef PCM_2_FFS
60 #include "pcm.h"
61 #endif
62
63 #include "mfw_win.h"
64 #include "mfw_gprs.h"
65
66 /* import of external globals --------------------------------------*/
67 EXTERN MfwHdr *current_mfw_elem;
68
69 /* definition of globals -------------------------------------------*/
70
71 /* definition of constants -----------------------------------------*/
72
73 /* definition of internal functions --------------------------------*/
74
75 static BOOL gprs_sign_exec ( T_MFW_HDR *cur_elem, T_MFW_EVENT event,
76 T_MFW_GPRS_PARA *para );
77
78 /*
79 +--------------------------------------------------------------------+
80 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
81 | STATE : code ROUTINE: gprs_init |
82 +--------------------------------------------------------------------+
83
84
85 PURPOSE : initialize for GPRS magangement
86
87 */
88 void gprs_init ( void )
89 {
90 TRACE_FUNCTION ("gprs_init()");
91
92 /*
93 * set callback for MFW commands
94 */
95 mfwCommand[MfwTypGprs] = (MfwCb) gprsCommand;
96 }
97
98
99 /*
100 +--------------------------------------------------------------------+
101 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
102 | STATE : code ROUTINE: gprs_exit |
103 +--------------------------------------------------------------------+
104
105
106 PURPOSE : finalize for GPRS magangement
107
108 */
109 void gprs_exit ( void )
110 {
111 TRACE_FUNCTION ("gprs_exit()");
112 }
113
114
115 /*
116 +--------------------------------------------------------------------+
117 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
118 | STATE : code ROUTINE: gprs_create |
119 +--------------------------------------------------------------------+
120
121
122 PURPOSE : create event for gprs management
123
124 PARAMETERS :
125
126 RETURNS :
127 */
128 T_MFW_HND gprs_create ( T_MFW_HND h,
129 T_MFW_EVENT event,
130 T_MFW_CB cbfunc )
131 {
132 T_MFW_HDR *hdr;
133 T_MFW_GPRS *gprs_data;
134 #if(BOARD != 61)
135 T_CGATT_STATE state; // OMAPS00041266 - RAVI
136 T_CGCLASS_CLASS cls; // OMAPS00041266 - RAVI
137 T_CGREG_STAT regState; // OMAPS00041266 - RAVI
138 USHORT lac; // OMAPS00041266 - RAVI
139 USHORT ci; // OMAPS00041266 - RAVI
140 #endif
141 MfwHdr *insert_status =0;
142
143 TRACE_FUNCTION ("gprs_create()");
144
145 hdr = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR));
146 gprs_data = (T_MFW_GPRS *) mfwAlloc(sizeof (T_MFW_GPRS));
147
148 if ( !hdr OR !gprs_data )
149 {
150 TRACE_ERROR("ERROR: gprs_create() Mem Alloc Failed.");
151
152 if(hdr)
153 mfwFree((U8*)hdr,sizeof(MfwHdr));
154
155 if(gprs_data)
156 mfwFree((U8*)gprs_data,sizeof(T_MFW_GPRS));
157
158 return FALSE;
159 }
160
161 /*
162 * initialisation of the handler
163 */
164 gprs_data->emask = event;
165 gprs_data->handler = cbfunc;
166
167 hdr->data = gprs_data; /* store gprs control block in node */
168 hdr->type = MfwTypGprs; /* store type of event handler */
169
170
171 /*
172 * initialisation of gprs data
173 */
174 gprs_data->data.numContexts = 0;
175
176 gprs_data->data.tclass = (T_CGCLASS_CLASS)NULL;
177 //x0035544 Feb 23, 2006 DR:OMAPS00068976
178 gprs_data->data.Reg_state.regState = (T_CGREG_STAT)NULL;
179 gprs_data->data.attached = (T_CGATT_STATE)NULL;
180
181 gprs_data->data.contexts =
182 (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT) * MAX_CID_PLUS_EINS);
183
184 /*
185 * installation of the handler
186 */
187 insert_status = mfwInsert((T_MFW_HDR *)h, hdr);
188
189 if(!insert_status)
190 {
191 TRACE_ERROR("ERROR: gprs_create() Failed to Install Handler. ");
192 mfwFree((U8*)hdr,sizeof(MfwHdr));
193 mfwFree((U8*)gprs_data,sizeof(T_MFW_GPRS));
194 return 0;
195 }
196 return insert_status;
197 }
198
199
200 /*
201 +--------------------------------------------------------------------+
202 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
203 | STATE : code ROUTINE: gprs_delete |
204 +--------------------------------------------------------------------+
205
206
207 PURPOSE : delete event for gprs management
208
209 PARAMETERS :
210
211 RETURNS :
212 MFW_RES_OK, on success
213 MFW_RES_ILL_HND, on failure
214 */
215 T_MFW_RES gprs_delete ( T_MFW_HND h )
216 {
217 T_MFW_GPRS *gprs_data;
218
219 TRACE_FUNCTION ("gprs_delete()");
220
221 if ( !h OR !((T_MFW_HDR *)h)->data )
222 return MFW_RES_ILL_HND;
223
224 /*
225 * deinstallation of the handler
226 */
227
228 //if ( !mfwRemove((T_MFW_HDR *)h) )
229 if ( !mfwRemove(h) )
230 return MFW_RES_ILL_HND;
231
232 gprs_data = ((T_MFW_HDR *) h)->data;
233
234 while ( gprs_data->data.numContexts )
235 {
236 mfwFree((U8 *)&(gprs_data->data.contexts[gprs_data->data.numContexts]),
237 sizeof(T_MFW_GPRS_CONTEXT));
238 gprs_data->data.numContexts--;
239 }
240 mfwFree((U8 *)&(gprs_data->data), sizeof(T_MFW_GPRS_DATA));
241 mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_GPRS));
242 mfwFree((U8 *)h,sizeof(T_MFW_HDR));
243
244 return MFW_RES_OK;
245 }
246
247
248 /*
249 +--------------------------------------------------------------------+
250 | PROJECT : MMI-Framework (8417) MODULE : MFW_GPRS |
251 | STATE : code ROUTINE : gprsCommand |
252 +--------------------------------------------------------------------+
253
254 PURPOSE : handle mfw windows command
255
256 PARAMETERS :
257
258 Returns : 0, on failure
259 1, on success
260 */
261
262 int gprsCommand (U32 cmd, void *h)
263 {
264 switch ( cmd )
265 {
266 case MfwCmdDelete: /* delete me */
267 if ( !h )
268 return 0;
269 gprs_delete(h);
270 return 1;
271 default:
272 break;
273 }
274
275 return 0;
276 }
277
278
279 /*
280 +--------------------------------------------------------------------+
281 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
282 | STATE : code ROUTINE: gprs_signal |
283 +--------------------------------------------------------------------+
284
285 PURPOSE : send a event signal.
286
287 PARAMETERS :
288 event : current event
289 *para : pointer to the event parameters
290
291 */
292 void gprs_signal( T_MFW_EVENT event,
293 void *para)
294 {/*MC, SPR 1389, we have to enable the display whenever
295 we send an event up to the MMI*/
296 UBYTE temp = dspl_Enable(0);
297
298 TRACE_FUNCTION ("gprs_signal()");
299
300 if ( mfwSignallingMethod EQ 0 )
301 {
302 /*
303 * focus is on a window
304 */
305 if ( mfwFocus )
306 {
307 /*
308 * send event to sim management handler if available
309 */
310 if (gprs_sign_exec (mfwFocus, event, para))
311 { dspl_Enable(temp);/*MC, SPR 1389*/
312 return;
313 }
314 }
315
316 /*
317 * acutal focussed window is not available or has no
318 * network management registration handler, then search
319 * all nodes from the root.
320 */
321 if ( mfwRoot )
322 gprs_sign_exec (mfwRoot, event, para);
323 }
324 else
325 {
326 MfwHdr *h = 0;
327
328 /*
329 * Focus set, then start here
330 */
331 if ( mfwFocus )
332 h = mfwFocus;
333
334 /*
335 * Focus not set, then start at root
336 */
337 if ( !h )
338 h = mfwRoot;
339
340 /*
341 * while elements found
342 */
343 while ( h )
344 {
345 /*
346 * Signal consumed, then return
347 */
348 if ( gprs_sign_exec (h, event, para) )
349 { dspl_Enable(temp);/*MC, SPR 1389*/
350 return;
351 }
352
353 /*
354 * All windows tried inclusive root
355 */
356 if ( h == mfwRoot )
357 { dspl_Enable(temp);/*MC, SPR 1389*/
358 return;
359 }
360
361 /*
362 * get parent window
363 */
364 h = mfwParent(mfwParent(h));
365
366 /*
367 * look for next element
368 */
369 if ( h )
370 h = ((MfwWin * )(h->data))->elems;
371 }
372 gprs_sign_exec (mfwRoot, event, para);
373 }
374 dspl_Enable(temp);/*MC, SPR 1389*/
375
376 }
377
378
379 /*
380 +--------------------------------------------------------------------+
381 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
382 | STATE : code ROUTINE: gprs_sign_exec |
383 +--------------------------------------------------------------------+
384
385
386 PURPOSE : Handle a signal if GPRS management handler.
387
388 PARAMETERS :
389
390 RETURNS :
391 TRUE, if signal is processed
392 FALSE, if signal is not processed
393 */
394 BOOL gprs_sign_exec ( T_MFW_HDR *cur_elem,
395 T_MFW_EVENT event,
396 T_MFW_GPRS_PARA *para )
397 {
398 int i,j;
399 T_CGATT_STATE state;
400 #if(BOARD != 61)
401 T_GPRS_CONT_REC tst_ctrc[MAX_CID_PLUS_EINS];
402 #endif
403 SHORT tst_cid;
404 USHORT lac;
405 USHORT ci;
406
407 TRACE_FUNCTION ("gprs_sign_exec()");
408
409 /*
410 * while event handler is available
411 */
412 while ( cur_elem )
413 {
414 /*
415 * if handler is GPRS management handler
416 */
417 if ( cur_elem->type EQ MfwTypGprs )
418 {
419 T_MFW_GPRS *gprs_data;
420 gprs_data = (T_MFW_GPRS *)cur_elem->data;
421
422 /*
423 * if event is expected by the call back function
424 */
425 if ( gprs_data->emask & event )
426 {
427 gprs_data->event = event;
428
429 switch ( event )
430 {
431 case E_MFW_GPRS_S_CNTXT:
432 /*
433 * Check if contexts is defined in ACI ( if too many context
434 * are defined, the new one will not be defined
435 */
436 #ifndef FF_2TO1_PS
437 qAT_PlusCGDCONT(CMD_SRC_LCL, &tst_ctrc, &tst_cid);
438 #endif
439
440 if ( tst_cid >= gprs_data->data.numContexts + 1)
441 {
442
443 /*
444 * insert the new context
445 */
446 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts]), para,
447 sizeof (T_MFW_GPRS_CONTEXT));
448 gprs_data->data.numContexts++;
449 }
450 break;
451
452 case E_MFW_GPRS_S_ATT:
453 case E_MFW_GPRS_R_EREP_ATT:
454 /* SPR#1983 - SH -'attached' is now of correct type.
455 * Don't check if unchanged, as this rejects some cases
456 * where signal needs to be sent to BMI
457 */
458
459 gprs_data->data.attached = para->attached;
460
461 /*
462 * set all contexts to deactivated after detach
463 */
464 if ( gprs_data->data.attached == CGATT_STATE_DETACHED )
465 {
466 for ( i=0; i > gprs_data->data.numContexts; i++)
467 {
468 gprs_data->data.contexts[i].activated = CGACT_STATE_DEACTIVATED;
469 }
470 }
471 else
472 {
473 if (qAT_PlusCGCLASS(CMD_SRC_LCL, &gprs_data->data.tclass) == AT_FAIL )
474 {
475 TRACE_EVENT("MFW_GPRS: Error. qAT_PlusCGCLASS failed");
476 }
477 //x0035544 Feb 23, 2006 DR:OMAPS00068976
478 if (qAT_PercentCGREG(CMD_SRC_LCL, &gprs_data->data.Reg_state.p_reg_State, &lac, &ci) == AT_FAIL )
479 {
480 TRACE_EVENT("MFW_GPRS: Error. qAT_PercentCGREG failed");
481 }
482 }
483 break;
484
485 case E_MFW_GPRS_S_ACT:
486 /*
487 * search in the known context for the context ids given
488 * in the parameter
489 */
490 for ( i=0; i > gprs_data->data.numContexts; i++)
491 {
492 j=0;
493
494 do
495 {
496 /*
497 * set the new activation state for the found context id
498 */
499 if ( para->contextAct.ids[j] == gprs_data->data.contexts[i].id)
500 {
501 gprs_data->data.contexts[i].activated = para->contextAct.state;
502 }
503 }
504 while ( j < MAX_CID &&
505 (para->contextAct.ids[j] != gprs_data->data.contexts[i].id) );
506 }
507 break;
508
509 case E_MFW_GPRS_S_DATA:
510 /*
511 * if attached mode was detached, set mode to attached
512 */
513 if ( gprs_data->data.attached == CGATT_STATE_DETACHED )
514 {
515 gprs_data->data.attached = CGATT_STATE_ATTACHED;
516 }
517
518 /*
519 * search in the known context for the context ids given
520 * in the parameter
521 */
522 for ( i=0; i < gprs_data->data.numContexts; i++)
523 {
524 j=0;
525
526 do
527 {
528 /*
529 * if context id of parameter is known, set the activation state
530 * to activated when it was detached and copy L2P value
531 */
532 if ( para->contextL2P.ids[j] == gprs_data->data.contexts[i].id)
533 {
534 if ( gprs_data->data.contexts[j].activated == CGACT_STATE_DEACTIVATED )
535 {
536 gprs_data->data.contexts[j].activated = CGACT_STATE_ACTIVATED;
537 }
538
539 if (!(gprs_data->data.contexts[i].L2P) )
540 gprs_data->data.contexts[i].L2P =
541 (char *) mfwAlloc(sizeof(char) * strlen(para->contextL2P.L2P));
542
543 memcpy (gprs_data->data.contexts[i].L2P, para->contextL2P.L2P,
544 strlen( para->contextL2P.L2P ) * sizeof(char));
545 }
546 j++;
547 }
548 while ( j < MAX_CID &&
549 ( para->contextL2P.ids[j]!= gprs_data->data.contexts[i].id) );
550 }
551 break;
552
553 case E_MFW_GPRS_R_ACT:
554 case E_MFW_GPRS_R_DATA:
555 case E_MFW_GPRS_R_ANS:
556 gprs_data->data.link_id = para->link_id;
557 break;
558
559 case E_MFW_GPRS_S_QOS:
560 case E_MFW_GPRS_R_QOS:
561 for ( i=0; (i > gprs_data->data.numContexts) &&
562 (gprs_data->data.contexts[i].id == para->context.id); i++);
563
564 if (gprs_data->data.contexts[i].id == para->context.id)
565 memcpy (&(gprs_data->data.contexts[i].data.qos),
566 #ifdef FF_2TO1_PS
567 &(para->context.data.qos), sizeof(T_PS_qos));
568 #else
569 &(para->context.data.qos), sizeof(T_QOS));
570 #endif
571 else
572 TRACE_ERROR("context id not defined");
573 break;
574
575 case E_MFW_GPRS_S_QOS_MIN:
576 for ( i=0; (i > gprs_data->data.numContexts) &&
577 (gprs_data->data.contexts[i].id == para->context.id); i++);
578
579 if (gprs_data->data.contexts[i].id == para->context.id)
580 memcpy (&(gprs_data->data.contexts[i].data.min_qos),
581 #ifdef FF_2TO1_PS
582 &(para->context.data.min_qos), sizeof(T_PS_qos));
583 #else
584 &(para->context.data.min_qos), sizeof(T_QOS));
585 #endif
586 else
587 TRACE_ERROR("context id not defined");
588 break;
589
590 case E_MFW_GPRS_S_CLASS:
591 case E_MFW_GPRS_R_EREP_CLASS:
592 memcpy (&(gprs_data->data.tclass), &(para->tclass), sizeof (T_CGCLASS_CLASS));
593 break;
594
595 case E_MFW_GPRS_R_EREP_ACT:
596 /*
597 * search for context
598 */
599 /* SPR#2243 - SH - Changed 'para->context' to 'para->erepAct' */
600 for ( i=0; (i > gprs_data->data.numContexts) &&
601 (gprs_data->data.contexts[i].id == para->erepAct.cid); i++);
602
603 /*
604 * if context found, copy PDP address data to MFW data
605 */
606 /* SPR#2243 - SH - Changed 'para->context' to 'para->erepAct' */
607 if (gprs_data->data.contexts[i].id == para->erepAct.cid)
608 {
609 #ifdef FF_2TO1_PS
610 memcpy (&(gprs_data->data.contexts[i].data.attributes.pdp_addr),
611 &para->erepAct.pdp_addr, sizeof(T_NAS_ip));
612 memcpy (&(gprs_data->data.contexts[i].data.attributes.pdp_type),
613 &para->erepAct.pdp_type, sizeof(T_NAS_ip));
614 #else
615 memcpy (&(gprs_data->data.contexts[i].data.pdp_addr),
616 para->erepAct.pdp_addr, sizeof(T_PDP_ADDRESS));
617 memcpy (&(gprs_data->data.contexts[i].data.pdp_type),
618 para->erepAct.pdp_type, sizeof(T_PDP_TYPE));
619 #endif
620 gprs_data->data.contexts[i].activated = CGACT_STATE_ACTIVATED;
621 }
622 else
623 {
624 if (gprs_data->data.numContexts < MAX_CID )
625 {
626 #ifdef FF_2TO1_PS
627 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.attributes.pdp_addr),
628 &para->erepAct.pdp_addr, sizeof (T_NAS_ip));
629 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.attributes.pdp_type),
630 para->erepAct.pdp_type, sizeof (T_PDP_TYPE));
631 gprs_data->data.contexts[gprs_data->data.numContexts].id = (U8)para->erepAct.cid;
632 #else
633 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.pdp_addr), para->erepAct.pdp_addr,
634 sizeof (T_PDP_ADDRESS));
635 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.pdp_type), para->erepAct.pdp_type,
636 sizeof (T_PDP_TYPE));
637 gprs_data->data.contexts[gprs_data->data.numContexts].id = para->erepAct.cid;
638 #endif
639 gprs_data->data.contexts[gprs_data->data.numContexts].activated = CGACT_STATE_ACTIVATED;
640 gprs_data->data.numContexts++;
641 }
642 else
643 TRACE_ERROR("MFW_GPRS: ERROR: Too many contexts!");
644 }
645 break;
646
647 /* SPR#2243 - SH - This is now a separate case from the above.
648 * Uses para->context throughout. */
649 case E_MFW_GPRS_S_PDPADDR:
650 /*
651 * search for context
652 */
653 for ( i=0; (i > gprs_data->data.numContexts) &&
654 (gprs_data->data.contexts[i].id == para->context.id); i++);
655
656 /*
657 * if context found, copy PDP address data to MFW data
658 */
659 if (gprs_data->data.contexts[i].id == para->context.id)
660 {
661 #ifdef FF_2TO1_PS
662 memcpy (&(gprs_data->data.contexts[i].data.attributes.pdp_addr),
663 &para->context.data.attributes.pdp_addr, sizeof(T_NAS_ip));
664 memcpy (&(gprs_data->data.contexts[i].data.attributes.pdp_type),
665 &para->context.data.attributes.pdp_type, sizeof(T_PDP_TYPE));
666 #else
667 memcpy (&(gprs_data->data.contexts[i].data.pdp_addr),
668 para->context.data.pdp_addr, sizeof(T_PDP_ADDRESS));
669 memcpy (&(gprs_data->data.contexts[i].data.pdp_type),
670 para->context.data.pdp_type, sizeof(T_PDP_TYPE));
671 #endif
672 gprs_data->data.contexts[i].activated = para->context.activated;
673 }
674 else
675 {
676 if (gprs_data->data.numContexts < MAX_CID )
677 {
678 #ifdef FF_2TO1_PS
679 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.attributes.pdp_addr),
680 &para->context.data.attributes.pdp_addr, sizeof (T_NAS_ip));
681 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.attributes.pdp_type),
682 &para->context.data.attributes.pdp_type, sizeof (T_PDP_TYPE));
683 gprs_data->data.contexts[gprs_data->data.numContexts].id = para->context.data.cid;
684 #else
685 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.pdp_addr), para->context.data.pdp_addr,
686 sizeof (T_PDP_ADDRESS));
687 memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts].data.pdp_type), para->context.data.pdp_type,
688 sizeof (T_PDP_TYPE));
689 gprs_data->data.contexts[gprs_data->data.numContexts].id = para->context.id;
690 #endif
691 gprs_data->data.contexts[gprs_data->data.numContexts].activated = para->context.activated;
692 gprs_data->data.numContexts++;
693 }
694 else
695 TRACE_ERROR("MFW_GPRS: ERROR: Too many contexts!");
696 }
697 break;
698
699 case E_MFW_GPRS_R_EREP_DEACT:
700 /*
701 * search for context
702 */
703 for ( i=0; (i < gprs_data->data.numContexts) &&
704 (gprs_data->data.contexts[i].id != para->erepAct.cid); i++);
705
706 /*
707 * if context found, set mode to deactivated
708 */
709 if (gprs_data->data.contexts[i].id == para->erepAct.cid)
710 {
711 gprs_data->data.contexts[i].activated = CGACT_STATE_DEACTIVATED;
712 }
713 else
714 {
715 for ( i=0; (i < gprs_data->data.numContexts) &&
716 #ifdef FF_2TO1_PS
717 ( strcmp(gprs_data->data.contexts[i].data.attributes.pdp_type, para->erepAct.pdp_type) ||
718 strcmp((const char *)&gprs_data->data.contexts[i].data.attributes.pdp_addr.ip_address.ipv4_addr.a4,
719 (const char *)&para->erepAct.pdp_addr.ip_address.ipv4_addr.a4) ); i++);
720
721 #else
722 ( strcmp(gprs_data->data.contexts[i].data.pdp_type, para->erepAct.pdp_type) ||
723 strcmp(gprs_data->data.contexts[i].data.pdp_addr, para->erepAct.pdp_addr) ); i++);
724 #endif
725
726 /*
727 * if context found, set mode to deactivated
728 */
729 #ifdef FF_2TO1_PS
730 if (!strcmp((const char *)&gprs_data->data.contexts[i].data.attributes.pdp_type, (const char *)&para->erepAct.pdp_type) &&
731 !strcmp((const char *)&gprs_data->data.contexts[i].data.attributes.pdp_addr.ip_address.ipv4_addr.a4, (const char *)&para->erepAct.pdp_addr.ip_address.ipv4_addr.a4) )
732 #else
733 if (!strcmp(gprs_data->data.contexts[i].data.pdp_type, para->erepAct.pdp_type) &&
734 !strcmp(gprs_data->data.contexts[i].data.pdp_addr, para->erepAct.pdp_addr) )
735 #endif
736 {
737 gprs_data->data.contexts[i].activated = CGACT_STATE_DEACTIVATED;
738 }
739 }
740
741 break;
742
743 case E_MFW_GPRS_S_AUTORESP:
744 gprs_data->data.autoResponse = para->mode;
745 break;
746
747 case E_MFW_GPRS_S_ANS:
748 break;
749
750 case E_MFW_GPRS_S_EREP:
751 /*
752 * copy new event reporting settings to MFW data
753 */
754 gprs_data->data.eventRep.mode = para->eventRep.mode;
755 gprs_data->data.eventRep.bfr = para->eventRep.bfr;
756 break;
757
758 case E_MFW_GPRS_R_EREP_RJ:
759 break;
760
761 case E_MFW_GPRS_R_REG:
762 /*
763 * copy new registration status to MFW data
764 */
765 /* SH - now with cell reselection data */
766 //x0035544 Feb 23, 2006 DR:OMAPS00068976
767 gprs_data->data.Reg_state.regState = para->cell.stat;
768 gprs_data->data.lac = para->cell.lac;
769 gprs_data->data.ci = para->cell.ci;
770
771 /*
772 * check if attachement state has changed
773 */
774 if (qAT_PlusCGATT(CMD_SRC_LCL, &state) != AT_FAIL )
775 gprs_data->data.attached = state;
776 else
777 TRACE_EVENT("MFW_GPRS: Error. qAT_PlusCGATT failed");
778 break;
779
780 case E_MFW_GPRS_S_SMSSERV:
781 /*
782 * copy new SMS service mode to MFW data
783 */
784 gprs_data->data.SMSService = para->service;
785 break;
786
787 case E_MFW_GPRS_COUNTER:
788 /* SPR#1574 - SH - Small change to ensure counter value copied correctly */
789 memcpy(&gprs_data->data.counter, &para->counter, sizeof(T_MFW_GPRS_COUNTER));
790 break;
791
792 case E_MFW_GPRS_OK:
793 case E_MFW_GPRS_ERROR:
794 case E_MFW_GPRS_CONNECT:
795 case E_MFW_GPRS_ERR_CONNECT:
796 break;
797
798
799 default:
800 /*
801 * an event has been used, which is not handled.
802 * perhaps an error?
803 */
804 TRACE_EVENT("mfw_gprs.gprs_sign_exec: unused event");
805 break;
806 }
807
808 /*
809 * if callback defined, call it
810 */
811 if ( gprs_data->handler )
812 {
813 current_mfw_elem = cur_elem;
814
815 if ( (*(gprs_data->handler))( gprs_data->event,
816 (void*)&gprs_data->data ) )
817 return TRUE;
818 }
819 }
820 }
821
822 /*
823 * look for next element
824 */
825 cur_elem = cur_elem->next;
826 }
827 return FALSE;
828 }
829
830
831 /*
832 +--------------------------------------------------------------------+
833 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
834 | STATE : code ROUTINE: gprs_ok |
835 +--------------------------------------------------------------------+
836
837 PURPOSE : success indication from ACI
838 (This function is called by rAT_OK)
839
840 PARAMETERS : AT command ID
841 */
842 void gprs_ok(T_ACI_AT_CMD cmdId)
843 {
844 TRACE_FUNCTION("mfw_gprs.gprs_ok");
845
846 gprs_signal(E_MFW_GPRS_OK, &cmdId);
847
848 return;
849 }
850
851
852 /*
853 +--------------------------------------------------------------------+
854 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
855 | STATE : code ROUTINE: gprs_error |
856 +--------------------------------------------------------------------+
857
858 PURPOSE : failure indication from ACI
859 (This function is called by rAT_PlusCME)
860
861 PARAMETERS : AT command ID
862 */
863 void gprs_error(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR err)
864 {
865 TRACE_FUNCTION("mfw_gprs.gprs_error");
866
867 gprs_signal(E_MFW_GPRS_ERROR, &cmdId);
868
869 return;
870 }
871
872
873 /*
874 +--------------------------------------------------------------------+
875 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
876 | STATE : code ROUTINE: gprs_connect |
877 +--------------------------------------------------------------------+
878
879 PURPOSE : success indication from ACI for connection
880 (This function is called by rAT_CONNECT)
881 */
882 void gprs_connect(SHORT cId)
883 {
884 TRACE_FUNCTION("mfw_gprs.gprs_connect");
885
886 gprs_signal(E_MFW_GPRS_CONNECT, &cId);
887 return;
888 }
889
890
891 /*
892 +--------------------------------------------------------------------+
893 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
894 | STATE : code ROUTINE: gprs_err_connect |
895 +--------------------------------------------------------------------+
896
897 PURPOSE : error indication from ACI for connection
898 (This function is called by rAT_BUSY, rAT_NO_CARRIER,
899 rAT_NO_ANSWERE)
900
901 */
902 void gprs_err_connect(SHORT cId)
903 {
904 TRACE_FUNCTION("mfw_gprs.gprs_err_connect");
905
906 gprs_signal(E_MFW_GPRS_ERR_CONNECT, &cId);
907
908 return;
909 }
910
911
912
913 /*--------------------------------------------------------------------
914 MMI-MFW Interface Functions
915 --------------------------------------------------------------------*/
916
917 /*
918 +---------------------------------------------------------------------+
919 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
920 | STATE : code ROUTINE: gprs_definePDPContext|
921 +---------------------------------------------------------------------+
922
923
924 PURPOSE : Define PDP context. If the contexts for cid does not
925 exist in the contexts list, the new context will be
926 inserted in the contexts list.
927
928 PARAMETERS :
929 cid : context ID
930 *context: context data
931 */
932 #ifdef FF_2TO1_PS
933 T_MFW_RES gprs_definePDPContext(SHORT cid, T_PDP_CONTEXT *inputCtxt)
934 {
935 T_MFW_GPRS_CONTEXT *context;
936
937 TRACE_FUNCTION ("gprs_definePDPContext()");
938
939 /*
940 * ACI call
941 */
942 if (sAT_PlusCGDCONT(CMD_SRC_LCL, (U8)cid, inputCtxt) == AT_FAIL)
943 {
944 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGDCONT failed");
945 return MFW_RES_ERR;
946 }
947
948 /*
949 * insert context into MFW GPRS data
950 */
951 context = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
952
953 context->id = (U8)cid;
954 memcpy (&(context->data.attributes), inputCtxt, sizeof (T_GPRS_CONT_REC));
955 context->activated = CGACT_STATE_DEACTIVATED; /* not yet activated */
956
957 gprs_signal(E_MFW_GPRS_S_CNTXT, context);
958
959 mfwFree((void *) context, sizeof(T_MFW_GPRS_CONTEXT));
960
961 return MFW_RES_OK;
962 }
963 #else
964 T_MFW_RES gprs_definePDPContext(SHORT cid, T_GPRS_CONT_REC *inputCtxt)
965 {
966 T_MFW_GPRS_CONTEXT *context;
967
968 TRACE_FUNCTION ("gprs_definePDPContext()");
969
970 /*
971 * ACI call
972 */
973 if (sAT_PlusCGDCONT(CMD_SRC_LCL, cid, inputCtxt) == AT_FAIL)
974 {
975 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGDCONT failed");
976 return MFW_RES_ERR;
977 }
978
979 /*
980 * insert context into MFW GPRS data
981 */
982 context = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
983
984 context->id = cid;
985 memcpy (&(context->data), inputCtxt, sizeof (T_GPRS_CONT_REC));
986 context->activated = CGACT_STATE_DEACTIVATED; /* not yet activated */
987
988 gprs_signal(E_MFW_GPRS_S_CNTXT, context);
989
990 mfwFree((void *) context, sizeof(T_MFW_GPRS_CONTEXT));
991
992 return MFW_RES_OK;
993 }
994 #endif
995
996
997
998 /*
999 +---------------------------------------------------------------------+
1000 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1001 | STATE : code ROUTINE: gprs_setQOS |
1002 +---------------------------------------------------------------------+
1003
1004
1005 PURPOSE : Set the Quality of Service Profile for the context
1006 specified by cid. The Quality of Service Profile is given
1007 in the pointer parameter qos.
1008
1009 PARAMETERS :
1010 cid : context ID
1011 *inputQos : quality of service data
1012 */
1013 #ifdef FF_2TO1_PS
1014 T_MFW_RES gprs_setQOS(SHORT cid ,T_PS_qos *inputQos)
1015 {
1016 T_MFW_GPRS_CONTEXT *cntxt;
1017
1018 TRACE_FUNCTION ("gprs_setQOS()");
1019
1020 /*
1021 * ACI call
1022 */
1023 if(sAT_PlusCGQREQ(CMD_SRC_LCL, (U8)cid, inputQos) == AT_FAIL)
1024 {
1025 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGQREQ failed");
1026 return MFW_RES_ERR;
1027 }
1028
1029 /*
1030 * change qos data in MFW GPRS data
1031 */
1032 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
1033
1034 cntxt->id = (U8)cid;
1035 memcpy (&(cntxt->data.qos), inputQos, sizeof (T_PS_qos));
1036
1037 gprs_signal(E_MFW_GPRS_S_QOS, cntxt);
1038
1039 return MFW_RES_OK;
1040 }
1041 #else
1042 T_MFW_RES gprs_setQOS(SHORT cid ,T_QOS *inputQos)
1043 {
1044 T_MFW_GPRS_CONTEXT *cntxt;
1045
1046 TRACE_FUNCTION ("gprs_setQOS()");
1047
1048 /*
1049 * ACI call
1050 */
1051 if(sAT_PlusCGQREQ(CMD_SRC_LCL, cid, inputQos) == AT_FAIL)
1052 {
1053 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGQREQ failed");
1054 return MFW_RES_ERR;
1055 }
1056
1057 /*
1058 * change qos data in MFW GPRS data
1059 */
1060 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
1061
1062 cntxt->id = cid;
1063 memcpy (&(cntxt->data.qos), inputQos, sizeof (T_QOS));
1064
1065 gprs_signal(E_MFW_GPRS_S_QOS, cntxt);
1066
1067 return MFW_RES_OK;
1068 }
1069 #endif
1070
1071
1072 /*
1073 +---------------------------------------------------------------------+
1074 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1075 | STATE : code ROUTINE: gprs_setQOSMin |
1076 +---------------------------------------------------------------------+
1077
1078
1079 PURPOSE : Set the minimum acceptable Quality of Service Profile for
1080 the context specified by cid.
1081
1082 PARAMETERS :
1083 cid : context ID
1084 *inputQos : quality of service data
1085 */
1086 #ifdef FF_2TO1_PS
1087 T_MFW_RES gprs_setQOSMin(SHORT cid ,T_PS_qos *inputQos)
1088 {
1089 T_MFW_GPRS_CONTEXT *cntxt;
1090
1091 TRACE_FUNCTION ("gprs_setQOSMin()");
1092
1093 /*
1094 * ACI call
1095 */
1096 if (sAT_PlusCGQMIN(CMD_SRC_LCL, (U8)cid, (T_PS_min_qos*)inputQos) == AT_FAIL)
1097 {
1098 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGQMIN failed");
1099 return MFW_RES_ERR;
1100 }
1101
1102 /*
1103 * change mininum acceptable qos data in MFW GPRS data
1104 */
1105 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
1106
1107 cntxt->id = (U8)cid;
1108 memcpy (&(cntxt->data.min_qos), inputQos, sizeof (T_PS_qos));
1109
1110 gprs_signal(E_MFW_GPRS_S_QOS_MIN, cntxt);
1111
1112 return MFW_RES_OK;
1113 }
1114 #else
1115 T_MFW_RES gprs_setQOSMin(SHORT cid ,T_QOS *inputQos)
1116 {
1117 T_MFW_GPRS_CONTEXT *cntxt;
1118
1119 TRACE_FUNCTION ("gprs_setQOSMin()");
1120
1121 /*
1122 * ACI call
1123 */
1124 if (sAT_PlusCGQMIN(CMD_SRC_LCL, cid, inputQos) == AT_FAIL)
1125 {
1126 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGQMIN failed");
1127 return MFW_RES_ERR;
1128 }
1129
1130 /*
1131 * change mininum acceptable qos data in MFW GPRS data
1132 */
1133 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
1134
1135 cntxt->id = cid;
1136 memcpy (&(cntxt->data.min_qos), inputQos, sizeof (T_QOS));
1137
1138 gprs_signal(E_MFW_GPRS_S_QOS_MIN, cntxt);
1139
1140 return MFW_RES_OK;
1141 }
1142 #endif
1143
1144
1145 /*
1146 +---------------------------------------------------------------------+
1147 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1148 | STATE : code ROUTINE: gprs_attach |
1149 +---------------------------------------------------------------------+
1150
1151
1152 PURPOSE : Attach to or detach from the GPRS Service. The parameter
1153 state indicates the state of GPRS attchement
1154
1155 PARAMETERS :
1156 state : attachement state ( 0 - detached, 1 - attached)
1157
1158 */
1159 T_MFW_RES gprs_attach(T_CGATT_STATE state)
1160 {
1161 T_ACI_RETURN result;
1162
1163 TRACE_FUNCTION ("gprs_attach()");
1164
1165 /*
1166 * ACI call
1167 * SPR#1574 - SH - Don't return fail for AT_CMPL result
1168 */
1169 result = sAT_PlusCGATT(CMD_SRC_LCL, state);
1170 if ( result!= AT_EXCT && result!=AT_CMPL)
1171 {
1172 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGATT failed");
1173 return MFW_RES_ERR;
1174 }
1175
1176 /*
1177 * change attachement state in MFW GPRS data
1178 */
1179 gprs_signal(E_MFW_GPRS_S_ATT, &state);
1180
1181
1182 return MFW_RES_OK;
1183 }
1184
1185
1186 /*
1187 +---------------------------------------------------------------------+
1188 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1189 | STATE : code ROUTINE: gprs_attach_abort |
1190 +---------------------------------------------------------------------+
1191
1192
1193 PURPOSE : Cancel attachment to or detachment from GPRS service
1194 SPR#1983 - SH - Added.
1195
1196 PARAMETERS : None.
1197
1198 */
1199 T_MFW_RES gprs_attach_abort(void)
1200 {
1201 T_ACI_RETURN result;
1202
1203 TRACE_EVENT("gprs_attach_abort()");
1204
1205 result = sAT_Abort(CMD_SRC_LCL, AT_CMD_CGATT);
1206
1207 if (result==AT_FAIL)
1208 return MFW_RES_ERR;
1209
1210 return MFW_RES_OK;
1211 }
1212
1213
1214 /*
1215 +----------------------------------------------------------------------+
1216 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1217 | STATE : code ROUTINE: gprs_contextActivation|
1218 +----------------------------------------------------------------------+
1219
1220
1221 PURPOSE : Activate or Deactivate PDP contexts. The parameter state
1222 indicates the state of GPRS activation.
1223 The parameter cids points to a list of contexts definitions.
1224 If the list is empty all contexts will be attached or
1225 detached. If the mobile is not attached before, a GPRS
1226 attach is first performed.
1227
1228 PARAMETERS :
1229 state : activation state ( 0 - deactivated, 1 - activated)
1230 cids : list of contexts
1231 */
1232 T_MFW_RES gprs_contextActivation(T_CGACT_STATE state, SHORT *cids)
1233 {
1234 T_MFW_GPRS_CNTXT_ACT *cntxtAct;
1235
1236 TRACE_FUNCTION ("gprs_contextActivation()");
1237
1238 /*
1239 * ACI call
1240 */
1241 #ifdef FF_2TO1_PS
1242 if (sAT_PlusCGACT(CMD_SRC_LCL, state, (U8 *)cids) == AT_FAIL)
1243 #else
1244 if (sAT_PlusCGACT(CMD_SRC_LCL, state, cids) == AT_FAIL)
1245 #endif
1246 {
1247 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGCACT failed");
1248 return MFW_RES_ERR;
1249 }
1250
1251
1252 /*
1253 * change context activation data in MFW GPRS data
1254 */
1255 cntxtAct = (T_MFW_GPRS_CNTXT_ACT *) mfwAlloc(sizeof(T_MFW_GPRS_CNTXT_ACT));
1256
1257 memcpy (&(cntxtAct->ids), cids, sizeof (SHORT));
1258 cntxtAct->state = state;
1259
1260 gprs_signal(E_MFW_GPRS_S_ACT, cntxtAct);
1261
1262 return MFW_RES_OK;
1263 }
1264
1265
1266 /*
1267 +---------------------------------------------------------------------+
1268 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1269 | STATE : code ROUTINE: gprs_setData |
1270 +---------------------------------------------------------------------+
1271
1272
1273 PURPOSE : Enter data state. Whatever actions are necessary to
1274 establish communication between the TE and the network
1275 will be performed (e.g. attach, context activate)
1276 PARAMETERS :
1277 L2P : Layer 2 protocoll
1278 cids : list of contexts
1279
1280 */
1281 #ifdef FF_2TO1_PS
1282 T_MFW_RES gprs_setData(char *L2P, SHORT *cids)
1283 {
1284 T_MFW_GPRS_CNTXT_L2P *cntxtL2P;
1285
1286 TRACE_FUNCTION ("gprs_setData()");
1287
1288 /*
1289 * ACI call
1290 */
1291 if (sAT_PlusCGDATA(CMD_SRC_LCL, L2P, (U8 *)cids) == AT_FAIL)
1292 {
1293 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGDATA failed");
1294 return MFW_RES_ERR;
1295 }
1296
1297
1298 /*
1299 * change attachement, activation and L2P data in MFW GPRS data
1300 */
1301 cntxtL2P = (T_MFW_GPRS_CNTXT_L2P *) mfwAlloc(sizeof(T_MFW_GPRS_CNTXT_L2P));
1302 cntxtL2P->L2P = (char *) mfwAlloc((U16)(sizeof(char) * strlen(L2P)));
1303 cntxtL2P->ids = (USHORT *) mfwAlloc(sizeof(SHORT) * MAX_CID);
1304
1305 memcpy (cntxtL2P->L2P, L2P, sizeof (CHAR) * strlen(L2P));
1306 memcpy (cntxtL2P->ids, cids, sizeof (SHORT));
1307
1308 gprs_signal(E_MFW_GPRS_S_DATA, cntxtL2P);
1309
1310 mfwFree( (U8 *) cntxtL2P->L2P, (U16)(sizeof(char) * strlen(L2P)));
1311 mfwFree( (U8 *) cntxtL2P->ids, (U16)(sizeof(SHORT) * MAX_CID));
1312
1313 return MFW_RES_OK;
1314 }
1315 #else
1316 T_MFW_RES gprs_setData(char *L2P, SHORT *cids)
1317 {
1318 T_MFW_GPRS_CNTXT_L2P *cntxtL2P;
1319
1320 TRACE_FUNCTION ("gprs_setData()");
1321
1322 /*
1323 * ACI call
1324 */
1325 if (sAT_PlusCGDATA(CMD_SRC_LCL, L2P, cids) == AT_FAIL)
1326 {
1327 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGDATA failed");
1328 return MFW_RES_ERR;
1329 }
1330
1331
1332 /*
1333 * change attachement, activation and L2P data in MFW GPRS data
1334 */
1335 cntxtL2P = (T_MFW_GPRS_CNTXT_L2P *) mfwAlloc(sizeof(T_MFW_GPRS_CNTXT_L2P));
1336 cntxtL2P->L2P = (char *) mfwAlloc(sizeof(char) * strlen(L2P));
1337 cntxtL2P->ids = (USHORT *) mfwAlloc(sizeof(SHORT) * MAX_CID);
1338
1339 memcpy (cntxtL2P->L2P, L2P, sizeof (CHAR) * strlen(L2P));
1340 memcpy (cntxtL2P->ids, cids, sizeof (SHORT));
1341
1342 gprs_signal(E_MFW_GPRS_S_DATA, cntxtL2P);
1343
1344 mfwFree( (void *) cntxtL2P->L2P, sizeof(char) * strlen(L2P));
1345 mfwFree( (void *) cntxtL2P->ids, sizeof(SHORT) * MAX_CID);
1346
1347 return MFW_RES_OK;
1348 }
1349 #endif
1350
1351
1352
1353 /*
1354 +-----------------------------------------------------------------------+
1355 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1356 | STATE : code ROUTINE: gprs_showPDPAddress |
1357 +-----------------------------------------------------------------------+
1358
1359
1360 PURPOSE : Show PDP address. The Function sets the pointer pdp_adress
1361 to a list of PDP addresses for the specified context
1362 identifiers in the parameter cids.
1363
1364 PARAMETERS :
1365 pdp_address: list of contexts
1366
1367 RETURNS:
1368 MFW_RES_OK: On success
1369 MFW_RES_ERR: On failure
1370 */
1371 #ifdef FF_2TO1_PS
1372 T_MFW_RES gprs_showPDPAddress(SHORT *cids, T_NAS_ip *pdp_address)
1373 {
1374 int i;
1375
1376 T_MFW_GPRS_CONTEXT *cntxt;
1377
1378 TRACE_FUNCTION ("gprs_showPDPAddress()");
1379
1380 /*
1381 * ACI call, get PDP addresses
1382 */
1383 if (sAT_PlusCGPADDR(CMD_SRC_LCL, (U8*)cids, pdp_address) == AT_FAIL)
1384 {
1385 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGPADDR failed");
1386 return MFW_RES_ERR;
1387 }
1388
1389
1390 /*
1391 * change PDP address data in MFW GPRS data
1392 */
1393 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
1394
1395 for (i=0; i < MAX_CID; i++)
1396 {
1397 cntxt->id = (U8)cids[i];
1398 memcpy (&(cntxt->data.attributes.pdp_addr), &pdp_address[i], sizeof (T_NAS_ip));
1399
1400 gprs_signal(E_MFW_GPRS_S_PDPADDR, cntxt);
1401 }
1402
1403 return MFW_RES_OK;
1404 }
1405 #else
1406 T_MFW_RES gprs_showPDPAddress(SHORT *cids, T_PDP_ADDRESS *pdp_address)
1407 {
1408 int i;
1409
1410 T_MFW_GPRS_CONTEXT *cntxt;
1411
1412 TRACE_FUNCTION ("gprs_showPDPAddress()");
1413
1414 /*
1415 * ACI call, get PDP addresses
1416 */
1417 if (sAT_PlusCGPADDR(CMD_SRC_LCL, cids, pdp_address) == AT_FAIL)
1418 {
1419 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGPADDR failed");
1420 return MFW_RES_ERR;
1421 }
1422
1423
1424 /*
1425 * change PDP address data in MFW GPRS data
1426 */
1427 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
1428
1429 for (i=0; i < MAX_CID; i++)
1430 {
1431 cntxt->id = cids[i];
1432 memcpy (&(cntxt->data.pdp_addr), pdp_address[i], sizeof (T_PDP_ADDRESS));
1433
1434 gprs_signal(E_MFW_GPRS_S_PDPADDR, cntxt);
1435 }
1436
1437 return MFW_RES_OK;
1438 }
1439 #endif
1440
1441
1442 /*
1443 +----------------------------------------------------------------------+
1444 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1445 | STATE : code ROUTINE: gprs_setAutoResponse |
1446 +----------------------------------------------------------------------+
1447
1448
1449 PURPOSE : Enable or Disable an automatic positive response to the
1450 receipt of Context Activation Requests from the network.
1451 The parameter mode indicates if the automatic response will
1452 be enabled or disabled.
1453
1454 PARAMETERS :
1455 mode : mode of auto response
1456 */
1457 T_MFW_RES gprs_setAutoResponse(T_CGAUTO_N mode)
1458 {
1459
1460 TRACE_FUNCTION ("gprs_setAutoResponse()");
1461
1462 /*
1463 * ACI call
1464 */
1465 if (sAT_PlusCGAUTO(CMD_SRC_LCL, mode) == AT_FAIL)
1466 {
1467 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGAUTO failed");
1468 return MFW_RES_ERR;
1469 }
1470
1471 /*
1472 * change auto response mode in MFW GPRS data
1473 */
1474 gprs_signal(E_MFW_GPRS_S_AUTORESP, &mode);
1475
1476 return MFW_RES_OK;
1477 }
1478
1479
1480 /*
1481 +----------------------------------------------------------------------+
1482 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1483 | STATE : code ROUTINE: gprs_ManualResponse |
1484 +----------------------------------------------------------------------+
1485
1486
1487 PURPOSE : This Function is for a manual response to network request
1488 for PDP context activation. The parameter response
1489 indicates if the request will be accepted or rejected.
1490 PARAMETERS :
1491 response : ( 0 - rejected, 1 - accepted)
1492 */
1493 T_MFW_RES gprs_ManualResponse(USHORT response, char *l2p, SHORT cid)
1494 {
1495 TRACE_FUNCTION ("gprs_ManualResponse()");
1496
1497 /*
1498 * send signal to current MFW element
1499 */
1500 gprs_signal(E_MFW_GPRS_S_ANS, &cid);
1501
1502 /*
1503 * ACI call
1504 */
1505 if (sAT_PlusCGANS(CMD_SRC_LCL, response, l2p, cid) == AT_FAIL)
1506 {
1507 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGANS failed");
1508 return MFW_RES_ERR;
1509 }
1510
1511 return MFW_RES_OK;
1512 }
1513
1514
1515 /*
1516 +----------------------------------------------------------------------+
1517 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1518 | STATE : code ROUTINE: gprs_setClass |
1519 +----------------------------------------------------------------------+
1520
1521
1522 PURPOSE : Set the mobile to operate according to a GPRS mobile class.
1523
1524 PARAMETERS :
1525 m_class : GPRS mobile class
1526 */
1527 T_MFW_RES gprs_setClass(T_CGCLASS_CLASS new_cls)
1528 {
1529 T_CGATT_STATE state;
1530
1531 TRACE_FUNCTION ("gprs_setClass()");
1532
1533 /*
1534 * ACI call
1535 */
1536 if (sAT_PlusCGCLASS(CMD_SRC_LCL, new_cls) == AT_FAIL)
1537 {
1538 TRACE_EVENT("MFW_GPRS: Error. sAT_PlusCGCLASS failed");
1539 return MFW_RES_ERR;
1540 }
1541
1542
1543 /*
1544 * change class data in MFW GPRS data
1545 */
1546 gprs_signal(E_MFW_GPRS_S_CLASS, &new_cls);
1547
1548
1549 /*
1550 * check if attachement mode has changed while class change
1551 */
1552 if (qAT_PlusCGATT(CMD_SRC_LCL, &state) != AT_FAIL )
1553 gprs_signal(E_MFW_GPRS_S_ATT, &state);
1554 else
1555 TRACE_EVENT("MFW_GPRS: Error. qAT_PlusCGATT failed");
1556
1557 return MFW_RES_OK;
1558 }
1559
1560
1561 /*
1562 +----------------------------------------------------------------------+
1563 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1564 | STATE : code ROUTINE: gprs_setEventReporting|
1565 +----------------------------------------------------------------------+
1566
1567
1568 PURPOSE : Enables or Disables the sending of certain events
1569 occuring in the GPRS ME or the network to the TE.
1570
1571 PARAMETERS :
1572 mode : mode to specifies if the event reporting will be
1573 enabled or disabled
1574 bfr : controls the effect on buffered events.
1575 */
1576 T_MFW_RES gprs_setEventReporting(T_CGEREP_MODE mode, T_CGEREP_BFR bfr)
1577 {
1578 T_MFW_GPRS_EVENTREP *eventRep;
1579
1580 TRACE_FUNCTION ("gprs_setEventReporting()");
1581
1582 /*
1583 * ACI call
1584 */
1585 if (sAT_PlusCGEREP(CMD_SRC_LCL, mode, bfr) == AT_FAIL)
1586 return MFW_RES_ERR;
1587
1588 /*
1589 * change event reporting data in MFW GPRS data
1590 */
1591 eventRep = (T_MFW_GPRS_EVENTREP *) mfwAlloc(sizeof(T_MFW_GPRS_EVENTREP));
1592
1593 eventRep->mode = mode;
1594 eventRep->bfr = bfr;
1595 gprs_signal(E_MFW_GPRS_S_EREP, eventRep);
1596
1597 return MFW_RES_OK;
1598 }
1599
1600
1601 /*
1602 +----------------------------------------------------------------------+
1603 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1604 | STATE : code ROUTINE: gprs_setServiceSMS |
1605 +----------------------------------------------------------------------+
1606
1607
1608 PURPOSE : The function specifies the service or service preference
1609 to be used for SMS.
1610
1611
1612 PARAMETERS :
1613 n : service to use for SMS ( 0 - GPRS, 1 - circuit switch,
1614 2 - GPRS preferred, 3 circuit switch preferred)
1615 */
1616
1617 T_MFW_RES gprs_setServiceSMS(T_CGSMS_SERVICE service)
1618 {
1619 TRACE_FUNCTION ("gprs_setServiceSMS()");
1620
1621 /*
1622 * ACI call
1623 */
1624 if (sAT_PlusCGSMS(CMD_SRC_LCL, service) == AT_FAIL)
1625 return MFW_RES_ERR;
1626
1627
1628 /*
1629 * change SMS service data in MFW GPRS data
1630 */
1631 gprs_signal(E_MFW_GPRS_S_SMSSERV, &service);
1632
1633 return MFW_RES_OK;
1634 }
1635
1636
1637 /*
1638 +----------------------------------------------------------------------+
1639 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1640 | STATE : code ROUTINE: gprs_getServiceSMS |
1641 +----------------------------------------------------------------------+
1642
1643
1644 PURPOSE : This function returns the service preference to be used for SMS.
1645
1646
1647 PARAMETERS :
1648 n : service to use for SMS ( 0 - GPRS, 1 - circuit switch,
1649 2 - GPRS preferred, 3 circuit switch preferred)
1650 */
1651
1652 T_CGSMS_SERVICE gprs_getServiceSMS(void)
1653 {
1654 T_CGSMS_SERVICE service;
1655
1656 if (qAT_PlusCGSMS(CMD_SRC_LCL, &service) != AT_FAIL )
1657 return service;
1658 else
1659 TRACE_EVENT("MFW_GPRS: Error. qAT_PlusCGCLASS failed");
1660 return CGSMS_SERVICE_INVALID;
1661 }
1662
1663
1664 /*
1665 +----------------------------------------------------------------------+
1666 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1667 | STATE : code ROUTINE: gprs_counter |
1668 +----------------------------------------------------------------------+
1669
1670
1671 PURPOSE : SPR#1450 - SH
1672
1673 Resets the data counter if reset_counter is TRUE.
1674 In either case, response returned in rAT_PercentSNCNT below.
1675 */
1676
1677 T_MFW_RES gprs_counter(BOOL reset_counter)
1678 {
1679 T_ACI_RETURN result;
1680 TRACE_FUNCTION("gprs_counter");
1681
1682 result = sAT_PercentSNCNT(CMD_SRC_LCL, reset_counter);
1683
1684 if (result!=AT_EXCT && result!=AT_CMPL)
1685 return MFW_RES_ERR;
1686
1687 if (result==AT_CMPL)
1688 return MfwResDone; /* No response expected */
1689
1690 return MFW_RES_OK;
1691 }
1692
1693
1694 /*
1695 +---------------------------------------------------------------------+
1696 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1697 | STATE : code ROUTINE: gprs_counter_abort |
1698 +---------------------------------------------------------------------+
1699
1700
1701 PURPOSE : Cancel request for data count
1702 SPR#1983 - SH - Added.
1703
1704 PARAMETERS : None.
1705
1706 */
1707
1708 T_MFW_RES gprs_counter_abort(void)
1709 {
1710 T_ACI_RETURN result;
1711
1712 result = sAT_Abort(CMD_SRC_LCL, AT_CMD_SNCNT);
1713
1714 if (result==AT_FAIL)
1715 return MFW_RES_ERR;
1716
1717 return MFW_RES_OK;
1718 }
1719
1720
1721 /*
1722 +----------------------------------------------------------------------+
1723 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1724 | STATE : code ROUTINE: gprs_status |
1725 +----------------------------------------------------------------------+
1726
1727
1728 PURPOSE : Returns the GPRS status value
1729 */
1730
1731 T_CGREG_STAT gprs_status()
1732 {
1733 #if(BOARD != 61)
1734 T_ACI_RETURN result; // OMAPS00042166 - RAVI
1735 #endif
1736 T_CGREG_STAT status = (T_CGREG_STAT)0;
1737 USHORT lac, ci;
1738
1739 TRACE_FUNCTION("gprs_status");
1740
1741 if (qAT_PlusCGREG(CMD_SRC_LCL, &status, &lac, &ci) == AT_FAIL )
1742 {
1743 TRACE_EVENT("MFW_GPRS: Error. qAT_PlusCGREG failed");
1744 }
1745
1746 return status;
1747 }
1748 //x0035544 Feb 23, 2006 DR:OMAPS00068976
1749 /*
1750 PURPOSE : Returns the GPRS status value
1751 */
1752 T_P_CGREG_STAT p_gprs_status()
1753 {
1754 #if(BOARD != 61)
1755 T_ACI_RETURN result; // OMAPS00042166 - RAVI
1756 #endif
1757 T_P_CGREG_STAT status = (T_P_CGREG_STAT)0;
1758 USHORT lac, ci;
1759
1760 TRACE_FUNCTION("p_gprs_status");
1761
1762 if (qAT_PercentCGREG(CMD_SRC_LCL, &status, &lac, &ci) == AT_FAIL )
1763 {
1764 TRACE_EVENT("MFW_GPRS: Error. qAT_PercentCGREG failed");
1765 }
1766
1767 return status;
1768 }
1769
1770
1771 /*--------------------------------------------------------------------
1772 ACI callback functions
1773 --------------------------------------------------------------------*/
1774
1775 /*
1776 +--------------------------------------------------------------------+
1777 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1778 | STATE : code ROUTINE: rAT_PlusCGACT |
1779 +--------------------------------------------------------------------+
1780
1781
1782 PURPOSE : The function rAt_PlusCGACT informs the application about
1783 the link identifier for the data transfer.
1784 ( ACI callback funtion )
1785
1786 PARAMETERS :
1787 link_id: Link identifier
1788
1789 */
1790 void rAT_PlusCGACT ( SHORT link_id )
1791 {
1792 TRACE_FUNCTION ("rAT_PlusCGACT()");
1793
1794 /*
1795 * send event and link id to the current mfw element
1796 */
1797 gprs_signal(E_MFW_GPRS_R_ACT, &link_id);
1798 }
1799
1800
1801 /*
1802 +--------------------------------------------------------------------+
1803 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1804 | STATE : code ROUTINE: rAT_PlusCGDATA |
1805 +--------------------------------------------------------------------+
1806
1807
1808 PURPOSE : The function rAt_PlusCGDATA informs the application about
1809 the link identifier for the data transfer after
1810 activation/deactivation (without connect).
1811 ( ACI callback funtion )
1812
1813 PARAMETERS :
1814 link_id: Link identifier
1815 */
1816 void rAT_PlusCGDATA ( SHORT link_id )
1817 {
1818 TRACE_FUNCTION ("rAT_PlusCGDATA()");
1819
1820 /*
1821 * send event and link id to the current mfw element
1822 */
1823 gprs_signal(E_MFW_GPRS_R_DATA, &link_id);
1824 }
1825
1826
1827 /*
1828 +--------------------------------------------------------------------+
1829 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1830 | STATE : code ROUTINE: rAT_PlusCGANS |
1831 +--------------------------------------------------------------------+
1832
1833
1834 PURPOSE : The function rAt_PlusCGANS informs the application about
1835 the link identifier for the data transfer. It is a
1836 manual reponse to a network request for PDP context
1837 activation (after request by +CRING or RING).
1838 ( ACI callback funtion )
1839
1840 PARAMETERS :
1841 link_id: Link identifier
1842 */
1843 void rAT_PlusCGANS ( SHORT link_id )
1844 {
1845 TRACE_FUNCTION ("rAT_PlusCGANS()");
1846
1847 /*
1848 * send event and link id to the current mfw element
1849 */
1850 gprs_signal(E_MFW_GPRS_R_ANS, &link_id);
1851 }
1852
1853
1854 /*
1855 +--------------------------------------------------------------------+
1856 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1857 | STATE : code ROUTINE: rAT_PlusCGEREP |
1858 +--------------------------------------------------------------------+
1859
1860
1861 PURPOSE : The function rAt_PlusCGEREP informs the application about
1862 GPRS events connect.
1863 ( ACI callback funtion )
1864
1865 PARAMETERS :
1866 event : GPRS event
1867 param : event parameter
1868
1869 */
1870 void rAT_PlusCGEREP ( T_CGEREP_EVENT event,
1871 T_CGEREP_EVENT_REP_PARAM *param )
1872 {
1873 #if(BOARD!=61)
1874 char msg[30]; // OMAPS00041266 - RAVI
1875 #endif
1876 T_CGATT_STATE state;
1877
1878 TRACE_FUNCTION ("rAT_PlusCGEREP()");
1879 TRACE_EVENT_P1("GPRS eventrep: %d", (short)event);
1880
1881 /*
1882 * send event and data to the current mfw element
1883 * SPR#2243 - SH - Use appropriate union fields in each gprs_signal.
1884 */
1885 switch ( event )
1886 {
1887 case CGEREP_EVENT_REJECT:
1888 gprs_signal(E_MFW_GPRS_R_EREP_RJ, &param->reject);
1889 break;
1890
1891 case CGEREP_EVENT_NW_DETACH:
1892 case CGEREP_EVENT_ME_DETACH:
1893 state = CGATT_STATE_DETACHED;
1894 gprs_signal(E_MFW_GPRS_R_EREP_ATT, &state);
1895 break;
1896
1897 case CGEREP_EVENT_NW_REACT:
1898 gprs_signal(E_MFW_GPRS_R_EREP_ACT, &param->act);
1899 break;
1900
1901 case CGEREP_EVENT_NW_DEACT:
1902 case CGEREP_EVENT_ME_DEACT:
1903 gprs_signal(E_MFW_GPRS_R_EREP_DEACT, &param->act);
1904 break;
1905
1906 case CGEREP_EVENT_NW_CLASS:
1907 case CGEREP_EVENT_ME_CLASS:
1908 gprs_signal(E_MFW_GPRS_R_EREP_CLASS, &param->mobile_class);
1909 break;
1910 }
1911 }
1912
1913 /*
1914 +--------------------------------------------------------------------+
1915 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1916 | STATE : code ROUTINE : rAT_PercentCGEV |
1917 +--------------------------------------------------------------------+
1918
1919 PURPOSE : handles rAT_PercentCGEV call back
1920
1921 */
1922 GLOBAL void rAT_PercentCGEV (T_CGEREP_EVENT event, T_CGEREP_EVENT_REP_PARAM *param )
1923 {
1924 T_CGATT_STATE state;
1925
1926 TRACE_FUNCTION ("rAT_PercentCGEV()");
1927 TRACE_EVENT_P1("GPRS eventrep: %d", (short)event);
1928
1929 /*
1930 * send event and data to the current mfw element
1931 */
1932 switch ( event )
1933 {
1934 case CGEREP_EVENT_REJECT:
1935 /* gprs_signal(E_MFW_GPRS_R_EREP_RJ, &param->reject); - Use a different event for %CGEV */
1936 break;
1937
1938 case CGEREP_EVENT_NW_DETACH:
1939 case CGEREP_EVENT_ME_DETACH:
1940 state = CGATT_STATE_DETACHED;
1941 /* gprs_signal(E_MFW_GPRS_R_EREP_ATT, &state); - Use a different event for %CGEV */
1942 break;
1943
1944 case CGEREP_EVENT_NW_REACT:
1945 /* gprs_signal(E_MFW_GPRS_R_EREP_ACT, &param->act); - Use a different event for %CGEV */
1946 break;
1947
1948 case CGEREP_EVENT_NW_DEACT:
1949 case CGEREP_EVENT_ME_DEACT:
1950 /* gprs_signal(E_MFW_GPRS_R_EREP_DEACT, &param->act); - Use a different event for %CGEV */
1951 break;
1952
1953 case CGEREP_EVENT_NW_CLASS:
1954 case CGEREP_EVENT_ME_CLASS:
1955 /* gprs_signal(E_MFW_GPRS_R_EREP_CLASS, &param->mobile_class); - Use a different event for %CGEV */
1956 break;
1957
1958 /* BEGIN ADD: Neptune Alignment*/
1959 #ifndef NEPTUNE_BOARD
1960 /* END ADD: Neptune Alignment */
1961 case CGEREP_EVENT_NW_ACT:
1962 case CGEREP_EVENT_ME_ACT:
1963 state = CGATT_STATE_ATTACHED;
1964 /* gprs_signal(E_MFW_GPRS_R_EREP_ATT, &state); - Use a different event for %CGEV */
1965 break;
1966 /* BEGIN ADD: Neptune Alignment*/
1967 #endif
1968 /* END ADD: Neptune Alignment */
1969
1970 }
1971 }
1972
1973
1974 /*
1975 +--------------------------------------------------------------------+
1976 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
1977 | STATE : code ROUTINE: rAT_PlusCGREG |
1978 +--------------------------------------------------------------------+
1979
1980
1981 PURPOSE : The function rAt_PlusCGREG informs the application about
1982 the GPRS registration status and location information.
1983 ( ACI callback funtion )
1984
1985 PARAMETERS :
1986 stat : indicates the current registration
1987 lac : two byte location area code
1988 ci : two byte cell ID
1989 */
1990 void rAT_PlusCGREG ( T_CGREG_STAT stat,
1991 USHORT lac,
1992 USHORT ci )
1993 {
1994 T_MFW_GPRS_CELL_STRUCT cell;
1995
1996 TRACE_FUNCTION ("rAT_PlusCGREG()");
1997 #ifndef WIN32
1998 TRACE_EVENT_P3("GPRS regState: %d, lac %X, ci %X", (short)stat, lac, ci);
1999 #endif
2000 /*
2001 * send signal for changed registry state to current
2002 * MFW element
2003 */
2004
2005 cell.stat = stat;
2006 cell.lac = lac;
2007 cell.ci = ci;
2008 gprs_signal(E_MFW_GPRS_R_REG, &cell);
2009 }
2010
2011
2012
2013 /*
2014 +--------------------------------------------------------------------+
2015 | PROJECT : GPRS (8441) MODULE : GACI_RET |
2016 | STATE : code ROUTINE : rAT_PercentCGREG |
2017 +--------------------------------------------------------------------+
2018
2019 PURPOSE : handles rAT_PercentCGREG call back
2020
2021 */
2022
2023 GLOBAL void rAT_PercentCGREG ( T_P_CGREG_STAT stat, USHORT lac, USHORT ci, BOOL bActiveContext )
2024
2025 {
2026
2027 T_MFW_GPRS_CELL_STRUCT_P cell;
2028
2029 TRACE_FUNCTION ("rAT_PercentCGREG()");
2030 #ifndef WIN32
2031 TRACE_EVENT_P3("GPRS regState: %d, lac %X, ci %X", (short)stat, lac, ci);
2032 #endif
2033 /*
2034 * send signal for changed registry state to current
2035 * MFW element
2036 */
2037 TRACE_EVENT_P3("State received in RAT-GPRS State: %d, lac %X, ci %X", (short)stat, lac, ci);
2038 cell.stat = stat;
2039 cell.lac = lac;
2040 cell.ci = ci;
2041 gprs_signal(E_MFW_GPRS_R_REG, &cell);
2042
2043 }
2044
2045
2046
2047 /*
2048 +--------------------------------------------------------------------+
2049 | PROJECT: MMI-Framework (8417) MODULE: MFW_GPRS |
2050 | STATE : code ROUTINE: rAT_changedQOS |
2051 +--------------------------------------------------------------------+
2052
2053
2054 PURPOSE : The function rAt_changedQOS informs the application about
2055 changes for the Quality of Service Profiles.
2056 ( ACI callback funtion )
2057
2058 PARAMETERS :
2059 cid :
2060 *qos :
2061 */
2062 // ADDED BY RAVI - 1-11-2005
2063 #ifdef FF_2TO1_PS
2064 void rAT_changedQOS ( U8 cid,
2065 T_PS_qos *qos )
2066 {
2067 T_MFW_GPRS_CONTEXT *cntxt;
2068
2069 TRACE_FUNCTION ("rAT_changedQOS()");
2070
2071 /*
2072 * send signal for changed quality of service profile to current
2073 * MFW element
2074 */
2075 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
2076
2077 cntxt->id = cid;
2078 memcpy (&(cntxt->data.qos), qos, sizeof (T_PS_qos));
2079
2080 gprs_signal(E_MFW_GPRS_R_QOS, cntxt);
2081 }
2082
2083 #else
2084 void rAT_changedQOS ( SHORT cid,
2085 T_QOS *qos )
2086 {
2087 T_MFW_GPRS_CONTEXT *cntxt;
2088
2089 TRACE_FUNCTION ("rAT_changedQOS()");
2090
2091 /*
2092 * send signal for changed quality of service profile to current
2093 * MFW element
2094 */
2095 cntxt = (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT));
2096
2097 cntxt->id = (U8)cid;
2098 memcpy (&(cntxt->data.qos), qos, sizeof (T_QOS));
2099
2100 gprs_signal(E_MFW_GPRS_R_QOS, cntxt);
2101 }
2102
2103 #endif
2104 // END RAVI - 1-11-2005
2105
2106 /*
2107 +--------------------------------------------------------------------+
2108 | PROJECT : GPRS (8441) MODULE : MFW_GPRS |
2109 | STATE : code ROUTINE : rAT_PercentSNCNT |
2110 +--------------------------------------------------------------------+
2111
2112 PURPOSE : handles rAT_PercentSNCNT call back
2113
2114 */
2115
2116 GLOBAL void rAT_PercentSNCNT ( UBYTE c_id,
2117 ULONG octets_uplink,
2118 ULONG octets_downlink,
2119 ULONG packets_uplink,
2120 ULONG packets_downlink )
2121 {
2122 T_MFW_GPRS_COUNTER counter;
2123
2124 TRACE_FUNCTION("rAT_PercentSNCNT()");
2125
2126 counter.octets_uplink = octets_uplink;
2127 counter.octets_downlink = octets_downlink;
2128 counter.packets_uplink = packets_uplink;
2129 counter.packets_downlink = packets_downlink;
2130
2131 gprs_signal(E_MFW_GPRS_COUNTER, &counter);
2132
2133 return;
2134 }