4 * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
\r
6 * Contact: Ja-young Gu <jygu@samsung.com>
\r
8 * PROPRIETARY/CONFIDENTIAL
\r
10 * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
\r
11 * You shall not disclose such Confidential Information and shall
\r
12 * use it only in accordance with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
\r
13 * SAMSUNG make no representations or warranties about the suitability
\r
14 * of the software, either express or implied, including but not
\r
15 * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement.
\r
16 * SAMSUNG shall not be liable for any damages suffered by licensee as
\r
17 * a result of using, modifying or distributing this software or its derivatives.
\r
28 #include <core_object.h>
\r
31 #include <co_network.h>
\r
34 #include <storage.h>
\r
38 #include "s_common.h"
\r
39 #include "s_network.h"
\r
41 #define AT_CREG_STAT_NOT_REG 0 /* not registered, MT is not currently searching a new operator to register to */
\r
42 #define AT_CREG_STAT_REG_HOME 1 /* registered, home network */
\r
43 #define AT_CREG_STAT_SEARCHING 2 /* not registered, but MT is currently searching a new operator to register to */
\r
44 #define AT_CREG_STAT_REG_DENIED 3 /* registration denied */
\r
45 #define AT_CREG_STAT_UNKNOWN 4 /* unknown */
\r
46 #define AT_CREG_STAT_REG_ROAM 5 /* registered, roaming */
\r
48 #define AT_COPS_MODE_AUTOMATIC 0 /* automatic (<oper> field is ignored) */
\r
49 #define AT_COPS_MODE_MANUAL 1 /* manual (<oper> field shall be present, and <AcT> optionally) */
\r
50 #define AT_COPS_MODE_DEREGISTER 2 /* deregister from network */
\r
51 #define AT_COPS_MODE_SET_ONLY 3 /* set only <format> */
\r
52 #define AT_COPS_MODE_MANUAL_AUTOMATIC 4 /*automatic - manual*/
\r
54 #define AT_COPS_FORMAT_LONG_ALPHANUMERIC 0 /* long format alphanumeric <oper> */
\r
55 #define AT_COPS_FORMAT_SHORT_ALPHANUMERIC 1 /* short format alphanumeric <oper> */
\r
56 #define AT_COPS_FORMAT_NUMERIC 2 /* numeric <oper> */
\r
58 #define AT_COPS_ACT_GSM 0 /* GSM */
\r
59 #define AT_COPS_ACT_GSM_COMPACT 1 /* GSM Compact */
\r
60 #define AT_COPS_ACT_UTRAN 2 /* UTRAN */
\r
61 #define AT_COPS_ACT_GSM_EGPRS 3 /* GSM w/EGPRS */
\r
62 #define AT_COPS_ACT_UTRAN_HSDPA 4 /* UTRAN w/HSDPA */
\r
63 #define AT_COPS_ACT_UTRAN_HSUPA 5 /* UTRAN w/HSUPA */
\r
64 #define AT_COPS_ACT_UTRAN_HSDPA_HSUPA 6 /* UTRAN w/HSDPA and HSUPA */
\r
65 #define AT_COPS_ACT_E_UTRAN 7 /* E-UTRAN */
\r
67 #define AT_GSM_XBANDSEL_AUTOMATIC 0
\r
68 #define AT_GSM_XBANDSEL_1800 1800
\r
69 #define AT_GSM_XBANDSEL_1900 1900
\r
70 #define AT_GSM_XBANDSEL_900 900
\r
71 #define AT_GSM_XBANDSEL_850 850
\r
72 #define AT_GSM_XBANDSEL_450 450
\r
73 #define AT_GSM_XBANDSEL_480 480
\r
74 #define AT_GSM_XBANDSEL_750 750
\r
75 #define AT_GSM_XBANDSEL_380 380
\r
76 #define AT_GSM_XBANDSEL_410 410
\r
78 #define AT_XRAT_GSM 0
\r
79 #define AT_XRAT_DUAL 1
\r
80 #define AT_XRAT_UMTS 2
\r
82 #define MAX_NETWORKS_PREF_PLMN_SUPPORT 150
\r
83 #define MAX_NETWORKS_MANUAL_SEARCH_SUPPORT 20
\r
85 static unsigned int lookup_tbl_net_status[] = {
\r
86 [AT_CREG_STAT_NOT_REG] = NETWORK_SERVICE_DOMAIN_STATUS_NO,
\r
87 [AT_CREG_STAT_REG_HOME] = NETWORK_SERVICE_DOMAIN_STATUS_FULL,
\r
88 [AT_CREG_STAT_SEARCHING] = NETWORK_SERVICE_DOMAIN_STATUS_SEARCH,
\r
89 [AT_CREG_STAT_REG_DENIED] = NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY,
\r
90 [AT_CREG_STAT_UNKNOWN] = NETWORK_SERVICE_DOMAIN_STATUS_NO,
\r
91 [AT_CREG_STAT_REG_ROAM] = NETWORK_SERVICE_DOMAIN_STATUS_FULL,
\r
94 static unsigned int lookup_tbl_access_technology[] = {
\r
95 [AT_COPS_ACT_GSM] = NETWORK_ACT_GSM,
\r
96 [AT_COPS_ACT_GSM_COMPACT] = NETWORK_ACT_GSM,
\r
97 [AT_COPS_ACT_UTRAN] = NETWORK_ACT_UTRAN,
\r
98 [AT_COPS_ACT_GSM_EGPRS] = NETWORK_ACT_EGPRS,
\r
99 [AT_COPS_ACT_UTRAN_HSDPA] = NETWORK_ACT_UTRAN,
\r
100 [AT_COPS_ACT_UTRAN_HSUPA] = NETWORK_ACT_UTRAN,
\r
101 [AT_COPS_ACT_UTRAN_HSDPA_HSUPA] = NETWORK_ACT_UTRAN,
\r
102 [AT_COPS_ACT_E_UTRAN] = NETWORK_ACT_GSM_UTRAN,
\r
105 static gboolean get_serving_network(CoreObject *o, UserRequest *ur);
\r
108 static void on_confirmation_network_message_send(TcorePending *p, gboolean result, void *user_data)
\r
110 dbg("on_confirmation_modem_message_send - msg out from queue.\n");
\r
112 if (result == FALSE) {
\r
121 static void nwk_prepare_and_send_pending_request(TcorePlugin *plugin, char *co_name, const char *at_cmd, const char* prefix,enum tcore_at_command_type at_cmd_type, UserRequest *ur, TcorePendingResponseCallback callback)
\r
123 TcoreATRequest *req = NULL;
\r
125 CoreObject *o= NULL;
\r
126 TcorePending *pending = NULL;
\r
129 o = tcore_plugin_ref_core_object(plugin, co_name);
\r
130 hal = tcore_object_get_hal(o);
\r
132 pending = tcore_pending_new(o, 0);
\r
133 req = tcore_at_request_new(at_cmd, prefix, at_cmd_type);
\r
135 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
137 tcore_pending_set_request_data(pending, 0, req);
\r
138 tcore_pending_set_response_callback(pending, callback, req->cmd);
\r
139 tcore_pending_link_user_request(pending, ur);
\r
140 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
142 ret = tcore_hal_send_request(hal, pending);
\r
147 static void _insert_mcc_mnc_oper_list(TcorePlugin *p, CoreObject *o)
\r
152 char query[255] = { 0, };
\r
153 GHashTableIter iter;
\r
154 gpointer key, value;
\r
155 GHashTable *result = NULL, *row = NULL;
\r
156 struct tcore_network_operator_info *noi = NULL;
\r
159 s = tcore_plugin_ref_server(p);
\r
160 strg = tcore_server_find_storage(s, "database");
\r
162 handle = tcore_storage_create_handle(strg, "/opt/dbspace/.mcc_mnc_oper_list.db");
\r
164 dbg("fail to create database handle");
\r
168 snprintf(query, 255, "select country, mcc, mnc, oper from mcc_mnc_oper_list");
\r
170 result = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
\r
171 (GDestroyNotify) g_hash_table_destroy);
\r
173 tcore_storage_read_query_database(strg, handle, query, NULL, result, 4);
\r
175 g_hash_table_iter_init(&iter, result);
\r
176 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
\r
179 noi = calloc(sizeof(struct tcore_network_operator_info), 1);
\r
181 snprintf(noi->mcc, 4, "%s", (char *)g_hash_table_lookup(row, "1"));
\r
182 snprintf(noi->mnc, 4, "%s", (char *)g_hash_table_lookup(row, "2"));
\r
183 snprintf(noi->name, 41, "%s", (char *)g_hash_table_lookup(row, "3"));
\r
184 snprintf(noi->country, 4, "%s", (char *)g_hash_table_lookup(row, "0"));
\r
186 tcore_network_operator_info_add(o, noi);
\r
191 dbg("count = %d", count);
\r
193 g_hash_table_destroy(result);
\r
195 tcore_storage_remove_handle(strg, handle);
\r
198 static enum telephony_network_service_type _get_service_type(enum telephony_network_service_type prev_type,
\r
199 int domain, int act, int cs_status, int ps_status)
\r
201 enum telephony_network_service_type ret;
\r
206 case NETWORK_ACT_UNKNOWN:
\r
207 ret = NETWORK_SERVICE_TYPE_UNKNOWN;
\r
210 case NETWORK_ACT_GSM:
\r
211 if (prev_type == NETWORK_SERVICE_TYPE_2_5G_EDGE && domain == NETWORK_SERVICE_DOMAIN_CS)
\r
212 ret = NETWORK_SERVICE_TYPE_2_5G_EDGE;
\r
214 ret = NETWORK_SERVICE_TYPE_2G;
\r
217 case NETWORK_ACT_EGPRS:
\r
218 return NETWORK_SERVICE_TYPE_2_5G_EDGE;
\r
221 case NETWORK_ACT_UMTS:
\r
222 ret = NETWORK_SERVICE_TYPE_3G;
\r
227 if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_NO && ps_status == NETWORK_SERVICE_DOMAIN_STATUS_NO) {
\r
228 ret = NETWORK_SERVICE_TYPE_NO_SERVICE;
\r
230 else if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_SEARCH || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_SEARCH)
\r
232 if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL)
\r
238 ret = NETWORK_SERVICE_TYPE_SEARCH;
\r
241 else if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY)
\r
243 if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL)
\r
249 ret = NETWORK_SERVICE_TYPE_EMERGENCY;
\r
256 static void _ps_set(TcorePlugin *p, int status)
\r
258 GSList *co_list = NULL;
\r
260 co_list = tcore_plugin_get_core_objects_bytype(p, CORE_OBJECT_TYPE_PS);
\r
262 CoreObject *o = NULL;
\r
263 o = (CoreObject *) co_list->data;
\r
267 if (status == NETWORK_SERVICE_DOMAIN_STATUS_FULL) {
\r
268 tcore_ps_set_online(o, TRUE);
\r
271 tcore_ps_set_online(o, FALSE);
\r
273 } while ((co_list = g_slist_next(co_list)));
\r
275 g_slist_free(co_list);
\r
278 static void on_timeout_search_network(TcorePending *p, void *user_data)
\r
281 struct tresp_network_search resp;
\r
283 dbg("TIMEOUT !!!!! pending=%p", p);
\r
285 memset(&resp, 0, sizeof(struct tresp_network_search));
\r
287 resp.list_count = 0;
\r
289 ur = tcore_pending_ref_user_request(p);
\r
291 tcore_user_request_send_response(ur, TRESP_NETWORK_SEARCH, sizeof(struct tresp_network_search), &resp);
\r
295 static void on_response_set_plmn_selection_mode(TcorePending *p, int data_len, const void *data, void *user_data)
\r
298 const TcoreATResponse *atResp = data;
\r
299 //GSList *tokens = NULL;
\r
300 //char * line = NULL;
\r
301 struct tresp_network_set_plmn_selection_mode resp = {0};
\r
303 if(atResp->success > 0)
\r
305 dbg("RESPONSE OK");
\r
306 resp.result = TCORE_RETURN_SUCCESS;
\r
310 dbg("RESPONSE NOK");
\r
311 resp.result = TCORE_RETURN_FAILURE;
\r
314 ur = tcore_pending_ref_user_request(p);
\r
316 tcore_user_request_send_response(ur, TRESP_NETWORK_SET_PLMN_SELECTION_MODE, sizeof(struct tresp_network_set_plmn_selection_mode), &resp);
\r
320 static void on_response_get_plmn_selection_mode(TcorePending *p, int data_len, const void *data, void *user_data)
\r
323 struct tresp_network_get_plmn_selection_mode resp = {0};
\r
324 const TcoreATResponse *atResp = data;
\r
325 GSList *tokens = NULL;
\r
326 char * line = NULL;
\r
329 resp.result = TCORE_RETURN_FAILURE;
\r
331 if(atResp->success > 0)
\r
333 dbg("RESPONSE OK");
\r
334 /* Format of output
\r
335 +COPS: <mode>[,<format>,<oper>[,< AcT>]]
\r
340 line = (char*)atResp->lines->data;
\r
341 tokens = tcore_at_tok_new(line);
\r
342 if (g_slist_length(tokens) < 1){
\r
343 msg("invalid message");
\r
346 mode = atoi(tcore_at_tok_nth(tokens, 0));
\r
347 dbg("mode = %d", mode);
\r
350 case AT_COPS_MODE_AUTOMATIC:
\r
351 resp.mode = NETWORK_SELECT_MODE_GLOBAL_AUTOMATIC;
\r
353 case AT_COPS_MODE_MANUAL:
\r
354 case AT_COPS_MODE_MANUAL_AUTOMATIC:
\r
355 resp.mode = NETWORK_SELECT_MODE_GSM_MANUAL;
\r
357 case AT_COPS_MODE_DEREGISTER:
\r
358 case AT_COPS_MODE_SET_ONLY:
\r
359 resp.result = TCORE_RETURN_FAILURE;
\r
362 resp.result = TCORE_RETURN_SUCCESS;
\r
367 dbg("RESPONSE NOK");
\r
368 resp.result = TCORE_RETURN_FAILURE;
\r
372 ur = tcore_pending_ref_user_request(p);
\r
374 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_PLMN_SELECTION_MODE, sizeof(struct tresp_network_get_plmn_selection_mode), &resp);
\r
378 tcore_at_tok_free(tokens);
\r
384 static void on_response_search_network(TcorePending *p, int data_len, const void *data, void *user_data)
\r
387 struct tresp_network_search resp;
\r
390 const TcoreATResponse *atResp = data;
\r
391 GSList *tokens = NULL;
\r
392 GSList *network_token = NULL;
\r
394 char* temp_plmn_info =NULL;
\r
395 char *pResp = NULL;
\r
396 int num_network_avail = 0;
\r
398 memset(&resp, 0, sizeof(struct tresp_network_search));
\r
399 resp.result = TCORE_RETURN_FAILURE;
\r
400 resp.list_count = 0;
\r
402 if(atResp->success > 0)
\r
404 dbg("RESPONSE OK");
\r
405 if(atResp->lines) {
\r
406 line = (char*)atResp->lines->data;
\r
407 tokens = tcore_at_tok_new(line);
\r
408 num_network_avail = g_slist_length(tokens);
\r
409 dbg(" length of tokens is %d\n", num_network_avail);
\r
410 if (num_network_avail < 1) {
\r
411 msg("invalid message");
\r
416 resp.result = TCORE_RETURN_SUCCESS;
\r
418 * +COPS: [list of supported (<stat>,long alphanumeric <oper>,short alphanumeric <oper>,numeric <oper>[,<AcT>])s]
\r
419 * [,,(list of supported <mode>s),(list of supported <format>s)]
\r
422 /* (2,"IND airtel","airtel","40445",2,),(1,"IND airtel","airtel","40445",0,),(3,"TATA DOCOMO","TATA DO","405034",2,) */
\r
424 for(i=0; ((i<num_network_avail) && (i<MAX_NETWORKS_MANUAL_SEARCH_SUPPORT)); i++)
\r
426 /* (2,"IND airtel","airtel","40445",2,) */
\r
427 network_token = tcore_at_tok_new(g_slist_nth_data(tokens, i));
\r
429 pResp = (tcore_at_tok_nth(network_token, 0));
\r
431 dbg("status : %s",pResp);
\r
432 resp.list[i].status = (enum telephony_network_plmn_status)atoi(pResp);
\r
435 if ((pResp = tcore_at_tok_nth(network_token, 1)))
\r
436 { /* Long Aplha name */
\r
437 dbg("Long Aplha name : %s",pResp);
\r
439 if(strlen(pResp) > 0)
\r
440 /* Strip off starting quote & ending quote */
\r
441 strncpy(resp.list[i].name, pResp+1, strlen(pResp)-2);
\r
443 else if ((pResp = tcore_at_tok_nth(network_token, 2)))
\r
445 dbg("Short Aplha name : %s",pResp);
\r
446 /* Short Aplha name */
\r
447 /* Strip off starting quote & ending quote */
\r
448 if(strlen(pResp) > 0)
\r
449 strncpy(resp.list[i].name, pResp+1, strlen(pResp)-2);
\r
453 pResp = tcore_at_tok_nth(network_token, 3);
\r
456 dbg("PLMN ID : %s",pResp);
\r
457 if(strlen(pResp) > 0){
\r
458 temp_plmn_info = malloc((strlen(pResp) - 2)+1); /* 1 extra character for NULL storage */
\r
459 memset(temp_plmn_info, 0x00, strlen(pResp) -2+1);
\r
461 /* Strip off starting quotes & ending quotes */
\r
462 strncpy(temp_plmn_info, pResp+1, strlen(pResp)-2);
\r
466 memcpy(resp.list[i].plmn, temp_plmn_info, 6);
\r
467 if (resp.list[i].plmn[5] == '#')
\r
468 resp.list[i].plmn[5] = '\0';
\r
470 /* Parse Access Technology */
\r
471 if((pResp = tcore_at_tok_nth(tokens, 4)))
\r
473 if(strlen(pResp) > 0){
\r
477 resp.list[i].act = NETWORK_ACT_GSM;
\r
479 resp.list[i].act = NETWORK_ACT_UMTS;
\r
483 dbg("Operator [%d] :: stat = %d, Name =%s, plmnId = %s, AcT=%d\n", resp.list_count, resp.list[i].status, resp.list[i].name, resp.list[i].plmn, resp.list[i].act);
\r
486 tcore_at_tok_free(network_token);
\r
487 free(temp_plmn_info);
\r
492 dbg("RESPONSE NOK");
\r
493 resp.result = TCORE_RETURN_FAILURE;
\r
497 ur = tcore_pending_ref_user_request(p);
\r
499 tcore_user_request_send_response(ur, TRESP_NETWORK_SEARCH, sizeof(struct tresp_network_search), &resp);
\r
501 tcore_at_tok_free(tokens);
\r
505 static void on_response_set_umts_band(TcorePending *p, int data_len, const void *data, void *user_data)
\r
507 const TcoreATResponse *atResp = data;
\r
509 dbg("On Response Set UMTS Band");
\r
511 if(atResp->success > 0) {
\r
512 dbg("Response OK");
\r
515 dbg("Response NOK");
\r
518 dbg("Wait for response of XRAT before sending final band setting response to AP");
\r
523 static void on_response_set_gsm_band(TcorePending *p, int data_len, const void *data, void *user_data)
\r
525 const TcoreATResponse *atResp = data;
\r
527 dbg("On Response Set GSM Band");
\r
528 if(atResp->success > 0){
\r
529 dbg("Response OK");
\r
532 dbg("Response NOK");
\r
535 dbg("Wait for response of XRAT before sending final band setting response to AP");
\r
539 static void on_response_get_umts_band(TcorePending *p, int data_len, const void *data, void *user_data)
\r
541 const TcoreATResponse *atResp = data;
\r
542 GSList *tokens = NULL;
\r
543 const char *line=NULL;
\r
544 int total_umts_bands = 0;
\r
546 char *band_token = NULL;
\r
547 char umts_band[20] = {0};
\r
548 char umts_band_1 = 0;
\r
549 char umts_band_2 = 0;
\r
550 char umts_band_5 = 0;
\r
551 UserRequest *ur = NULL;
\r
552 struct tresp_network_get_band resp = {0};
\r
554 dbg("Entry on_response_get_umts_band");
\r
556 resp.mode = NETWORK_BAND_MODE_PREFERRED;
\r
557 resp.result = TCORE_RETURN_SUCCESS;
\r
559 if(atResp->success > 0)
\r
561 dbg("RESPONSE OK");
\r
562 if(atResp->lines) {
\r
563 line = (char*)atResp->lines->data;
\r
564 tokens = tcore_at_tok_new(line);
\r
565 total_umts_bands = g_slist_length(tokens);
\r
566 dbg("Total UMTS bands enabled are : %d\n", total_umts_bands);
\r
567 if (total_umts_bands < 1) {
\r
574 dbg("RESPONSE NOK");
\r
578 for (i = 0; i<total_umts_bands; i++)
\r
580 band_token = tcore_at_tok_nth(tokens, i);
\r
582 if(band_token == NULL)
\r
585 memset(umts_band, 0x00, sizeof(umts_band));
\r
587 if(atoi(band_token) == 0){ /* 0 means UMTS automatic */
\r
588 umts_band_1 = umts_band_2 = umts_band_5 = TRUE;
\r
592 /* Strip off starting quotes & ending quotes */
\r
593 strncpy(umts_band, band_token+1, strlen(band_token)-2);
\r
595 if (!strcmp(umts_band, "UMTS_BAND_I")) {
\r
596 umts_band_1 = TRUE;
\r
598 else if (!strcmp(umts_band, "UMTS_BAND_II")){
\r
599 umts_band_2 = TRUE;
\r
601 else if (!strcmp(umts_band, "UMTS_BAND_II")){
\r
602 umts_band_5 = TRUE;
\r
605 /* Telephony is not interest */
\r
606 dbg("Telephony is not interested in %s band", umts_band);
\r
611 if((umts_band_1) && (umts_band_2) && (umts_band_5)){
\r
612 resp.band = NETWORK_BAND_TYPE_WCDMA;
\r
614 else if (umts_band_1){
\r
615 resp.band = NETWORK_BAND_TYPE_WCDMA2100;
\r
617 else if (umts_band_2){
\r
618 resp.band = NETWORK_BAND_TYPE_WCDMA1900;
\r
620 else if (umts_band_5){
\r
621 resp.band = NETWORK_BAND_TYPE_WCDMA850;
\r
624 resp.result = TCORE_RETURN_FAILURE;
\r
627 dbg("Final resp.band sent to TS = %d", resp.band);
\r
629 ur = tcore_pending_ref_user_request(p);
\r
631 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);
\r
635 tcore_at_tok_free(tokens);
\r
637 dbg("Exit on_response_get_umts_band");
\r
641 static void on_response_get_gsm_band(TcorePending *p, int data_len, const void *data, void *user_data)
\r
643 struct tresp_network_get_band resp = {0};
\r
644 const TcoreATResponse *atResp = data;
\r
645 GSList *tokens = NULL;
\r
646 int total_gsm_bands = 0;
\r
647 const char *line=NULL;
\r
649 char *band_token = NULL;
\r
650 UserRequest *ur = NULL;
\r
656 dbg("Entry on_response_get_gsm_band");
\r
658 resp.mode = NETWORK_BAND_MODE_PREFERRED;
\r
659 resp.result = TCORE_RETURN_SUCCESS;
\r
661 if(atResp->success > 0)
\r
663 dbg("RESPONSE OK");
\r
664 if(atResp->lines) {
\r
665 line = (char*)atResp->lines->data;
\r
666 tokens = tcore_at_tok_new(line);
\r
667 total_gsm_bands = g_slist_length(tokens);
\r
668 dbg("Total GSM bands enabled are : %d\n", total_gsm_bands);
\r
669 if (total_gsm_bands < 1)
\r
674 for (i = 0; i<total_gsm_bands; i++)
\r
676 band_token = tcore_at_tok_nth(tokens, i);
\r
678 if(band_token == NULL)
\r
681 if(atoi(band_token) == 0){ /* 0 means GSM automatic */
\r
682 gsm_850 = gsm_900 = gsm_1800 = gsm_1900 = TRUE;
\r
686 switch(atoi(band_token)) {
\r
687 case AT_GSM_XBANDSEL_850:
\r
691 case AT_GSM_XBANDSEL_900:
\r
695 case AT_GSM_XBANDSEL_1800:
\r
699 case AT_GSM_XBANDSEL_1900:
\r
710 if(gsm_850 && gsm_900 && gsm_1800 && gsm_1900) {
\r
711 resp.band = NETWORK_BAND_TYPE_GSM;
\r
713 else if (gsm_850 && gsm_1900) {
\r
714 resp.band = NETWORK_BAND_TYPE_GSM_850_1900;
\r
716 else if (gsm_900 && gsm_1800) {
\r
717 resp.band = NETWORK_BAND_TYPE_GSM_900_1800;
\r
719 else if (gsm_1900) {
\r
720 resp.band = NETWORK_BAND_TYPE_GSM1900;
\r
722 else if (gsm_850) {
\r
723 resp.band = NETWORK_BAND_TYPE_GSM850;
\r
725 else if (gsm_1800) {
\r
726 resp.band = NETWORK_BAND_TYPE_GSM1800;
\r
728 else if (gsm_900) {
\r
729 resp.band = NETWORK_BAND_TYPE_GSM900;
\r
732 resp.result = TCORE_RETURN_FAILURE;
\r
735 dbg("Final resp.band sent to TS = %d", resp.band);
\r
737 ur = tcore_pending_ref_user_request(p);
\r
739 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);
\r
743 tcore_at_tok_free(tokens);
\r
745 dbg("Exit on_response_get_gsm_band");
\r
750 static void on_response_get_xrat(TcorePending *p, int data_len, const void *data, void *user_data)
\r
752 TcoreHal *h = NULL;
\r
753 UserRequest *ur = NULL;
\r
755 TcoreATRequest *atreq;
\r
756 char*cmd_str = NULL;
\r
757 UserRequest *dup_ur = NULL;
\r
758 const TcoreATResponse *atResp = data;
\r
759 const char *line=NULL;
\r
760 char *pResp = NULL;
\r
761 GSList *tokens = NULL;
\r
762 TcorePending *pending = NULL;
\r
763 CoreObject *o = NULL;
\r
765 struct tresp_network_get_band resp = {0};
\r
767 dbg("Enter on_response_get_xrat !!");
\r
769 resp.mode = NETWORK_BAND_MODE_PREFERRED;
\r
771 ur = tcore_pending_ref_user_request(p);
\r
772 h = tcore_object_get_hal(tcore_pending_ref_core_object(p));
\r
773 o = tcore_pending_ref_core_object(p);
\r
775 if(atResp->success > 0)
\r
777 dbg("RESPONSE OK");
\r
778 if(atResp->lines) {
\r
779 line = (char*)atResp->lines->data;
\r
780 tokens = tcore_at_tok_new(line);
\r
781 if ( g_slist_length(tokens) < 1){
\r
782 msg("invalid message");
\r
787 if((pResp = tcore_at_tok_nth(tokens, 0))){
\r
788 cp_xrat = atoi(pResp);
\r
790 if((cp_xrat == AT_XRAT_DUAL)){ /* mode is Dual, send reply to Telephony */
\r
791 resp.result = TCORE_RETURN_SUCCESS;
\r
792 resp.band = NETWORK_BAND_TYPE_ANY;
\r
794 ur = tcore_pending_ref_user_request(p);
\r
796 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);
\r
800 else if((cp_xrat == AT_XRAT_UMTS)){
\r
801 /* Get UMTS Band Information */
\r
802 dup_ur = tcore_user_request_ref(ur); /* duplicate user request for AT+XUBANDSEL */
\r
803 cmd_str = g_strdup_printf("AT+XUBANDSEL?");
\r
804 atreq = tcore_at_request_new(cmd_str, "+XUBANDSEL", TCORE_AT_SINGLELINE);
\r
805 pending = tcore_pending_new(o, 0);
\r
806 tcore_pending_set_request_data(pending, 0, atreq);
\r
807 tcore_pending_set_response_callback(pending, on_response_get_umts_band, NULL);
\r
808 tcore_pending_link_user_request(pending, ur);
\r
809 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
810 tcore_hal_send_request(h, pending);
\r
812 else if((cp_xrat == AT_XRAT_UMTS)){
\r
813 /* Get GSM Band Information */
\r
814 dup_ur = tcore_user_request_ref(ur); /* duplicate user request for AT+XBANDSEL */
\r
815 cmd_str = g_strdup_printf("AT+XBANDSEL?");
\r
816 atreq = tcore_at_request_new(cmd_str, "+XBANDSEL", TCORE_AT_SINGLELINE);
\r
817 pending = tcore_pending_new(o, 0);
\r
818 tcore_pending_set_request_data(pending, 0, atreq);
\r
819 tcore_pending_set_response_callback(pending, on_response_get_gsm_band, NULL);
\r
820 tcore_pending_link_user_request(pending, dup_ur);
\r
821 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
822 tcore_hal_send_request(h, pending);
\r
827 dbg("RESPONSE NOK");
\r
829 resp.result = TCORE_RETURN_FAILURE;
\r
830 resp.band = NETWORK_BAND_TYPE_ANY;
\r
832 ur = tcore_pending_ref_user_request(p);
\r
834 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);
\r
840 tcore_at_tok_free(tokens);
\r
842 dbg("Exit on_response_get_xrat !!");
\r
848 static void on_response_set_xrat(TcorePending *p, int data_len, const void *data, void *user_data)
\r
850 UserRequest *ur = NULL;
\r
851 struct tresp_network_set_band resp = {0};
\r
852 const TcoreATResponse *atResp = data;
\r
854 dbg("On Response Set XRAT");
\r
856 if(atResp->success > 0){
\r
857 dbg("Response OK");
\r
858 resp.result = TCORE_RETURN_SUCCESS;
\r
860 dbg("Response NOK");
\r
861 resp.result = TCORE_RETURN_FAILURE;
\r
864 ur = tcore_pending_ref_user_request(p);
\r
866 tcore_user_request_send_response(ur, TRESP_NETWORK_SET_BAND, sizeof(struct tresp_network_set_band), &resp);
\r
872 static void on_response_set_preferred_plmn(TcorePending *p, int data_len, const void *data, void *user_data)
\r
874 UserRequest *ur = NULL;
\r
875 struct tresp_network_set_preferred_plmn resp = {0};
\r
876 const TcoreATResponse *atResp = data;
\r
878 dbg("ENTER on_response_set_preferred_plmn");
\r
880 if(atResp->success > 0)
\r
882 dbg("Response OK");
\r
883 resp.result = TCORE_RETURN_SUCCESS;
\r
886 dbg("Response NOK");
\r
887 resp.result = TCORE_RETURN_FAILURE;
\r
890 ur = tcore_pending_ref_user_request(p);
\r
892 tcore_user_request_send_response(ur, TRESP_NETWORK_SET_PREFERRED_PLMN, sizeof(struct tresp_network_set_preferred_plmn), &resp);
\r
895 dbg("Exit on_response_set_preferred_plmn");
\r
899 static void on_response_get_nitz_name(TcorePending *p, int data_len, const void *data, void *user_data)
\r
903 const TcoreATResponse *atResp = data;
\r
904 GSList *tokens = NULL;
\r
905 const char *line=NULL;
\r
906 CoreObject *o = NULL;
\r
907 struct tnoti_network_identity noti;
\r
910 int net_name_type = 0;
\r
911 char *pResp = NULL;
\r
913 dbg("Entry on_response_get_nitz_name (+XCOPS)");
\r
914 o = tcore_pending_ref_core_object(p);
\r
915 if(atResp->success > 0)
\r
917 dbg("RESPONSE OK");
\r
919 if(atResp->lines) {
\r
920 nol = g_slist_length(atResp->lines);
\r
922 msg("invalid message");
\r
926 for(count =0; count < nol; count++){
\r
928 line = g_slist_nth_data(atResp->lines, count);
\r
929 tokens = tcore_at_tok_new(line);
\r
930 dbg("line %d start---------------",count);
\r
932 if ((pResp = tcore_at_tok_nth(tokens, 0))){
\r
933 net_name_type = atoi(pResp);
\r
934 dbg("Net name type : %d", net_name_type);
\r
936 switch(net_name_type)
\r
938 case 0: /* plmn_id (mcc, mnc) */
\r
939 if ((pResp = tcore_at_tok_nth(tokens, 1))){
\r
940 strncpy(noti.plmn, pResp+1, strlen(pResp)-2); /* skip quotes (") while copying */
\r
944 case 5: /* Short Nitz name*/
\r
945 if ((pResp = tcore_at_tok_nth(tokens, 1))){
\r
946 strncpy(noti.short_name, pResp+1, strlen(pResp)-2); /* skip quotes (") while copying */
\r
950 case 6: /* Full Nitz name */
\r
951 if ((pResp = tcore_at_tok_nth(tokens, 1))){
\r
952 strncpy(noti.full_name, pResp+1, strlen(pResp)-2); /* skip quotes (") while copying */
\r
961 tcore_at_tok_free(tokens);
\r
964 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_IDENTITY,
\r
965 sizeof(struct tnoti_network_identity), ¬i);
\r
969 dbg("RESPONSE NOK");
\r
973 dbg("Exit on_response_get_nitz_name");
\r
977 static void on_response_get_preferred_plmn(TcorePending *p, int data_len, const void *data, void *user_data)
\r
982 const TcoreATResponse *atResp = data;
\r
983 GSList *tokens = NULL;
\r
984 char temp_plmn_info[17] = {0};
\r
985 char *pResp = NULL;
\r
986 int plmn_format = 0;
\r
988 struct tresp_network_get_preferred_plmn resp = {0};
\r
989 int total_lines = 0;
\r
990 int GSM_AcT2 = 0, GSM_Compact_AcT2= 0, UTRAN_AcT2 = 0;
\r
992 dbg("Entry on_response_get_preferred_plmn");
\r
994 if(atResp->success > 0)
\r
996 dbg("RESPONSE OK");
\r
997 if(atResp->lines) {
\r
998 total_lines = g_slist_length(atResp->lines);
\r
999 dbg("Total number of network present in Preferred PLMN list is %d\n", total_lines);
\r
1001 if (total_lines < 1) {
\r
1002 msg("invalid message");
\r
1006 if (total_lines >= MAX_NETWORKS_PREF_PLMN_SUPPORT)
\r
1007 total_lines = MAX_NETWORKS_PREF_PLMN_SUPPORT;
\r
1010 +COPL: <index1>,<format>,<oper1>[,<GSM_AcT1>,<GSM_Compact_AcT1>,<UTRAN_AcT1>,<E-UTRAN_AcT1>] [<CR><LF>
\r
1011 +CPOL: <index2>,<format>,<oper2>[,<GSM_AcT2>,<GSM_Compact_AcT2>,<UTRAN_AcT2>,<E-UTRAN_AcT2>]
\r
1014 resp.result = TCORE_RETURN_SUCCESS;
\r
1016 for (i=0; i<total_lines; i++) {
\r
1017 /* Take each line response at a time & parse it */
\r
1018 line = tcore_at_tok_nth(atResp->lines, i);
\r
1019 tokens = tcore_at_tok_new(line);
\r
1021 /* <index2>,<format>,<oper2>[,<GSM_AcT2>,<GSM_Compact_AcT2>,<UTRAN_AcT2>,<E-UTRAN_AcT2>] */
\r
1024 if ((pResp = tcore_at_tok_nth(tokens, 0)))
\r
1026 dbg("Index : %s",pResp);
\r
1027 resp.list[i].ef_index = atoi(pResp);
\r
1030 if((pResp = tcore_at_tok_nth(tokens, 1)))
\r
1032 dbg("format : %s",pResp);
\r
1033 plmn_format = atoi(pResp);
\r
1036 /* Operator PLMN ID */
\r
1037 if((pResp = tcore_at_tok_nth(tokens, 2)))
\r
1039 dbg("plmn ID : %s",pResp);
\r
1041 if(strlen(pResp) > 0){
\r
1042 strncpy(temp_plmn_info, pResp+1, (strlen(pResp))-2);
\r
1044 //Get only PLMN ID
\r
1045 if (plmn_format == 2)
\r
1047 //cp_plmn = util_hexStringToBytes(temp_plmn_info);
\r
1049 if (strncmp((char *)temp_plmn_info, "000000", 6) == 0)
\r
1052 memcpy(resp.list[i].plmn, temp_plmn_info, 6);
\r
1053 if (resp.list[i].plmn[5] == '#')
\r
1054 resp.list[i].plmn[5] = '\0';
\r
1061 if((pResp = tcore_at_tok_nth(tokens, 3))){
\r
1062 dbg("GSM_AcT2 : %s",pResp);
\r
1063 GSM_AcT2 = atoi(pResp);
\r
1066 if((pResp = tcore_at_tok_nth(tokens, 4))){
\r
1067 dbg("GSM_Compact AcT2 : %s",pResp);
\r
1068 GSM_Compact_AcT2 = atoi(pResp);
\r
1071 if((pResp = tcore_at_tok_nth(tokens, 5))){
\r
1072 dbg("UTRAN_AcT2 : %s",pResp);
\r
1073 UTRAN_AcT2 = atoi(pResp);
\r
1076 if(UTRAN_AcT2 && (GSM_AcT2 ||GSM_Compact_AcT2))
\r
1077 resp.list[i].act = NETWORK_ACT_GSM_UTRAN;
\r
1078 else if (UTRAN_AcT2)
\r
1079 resp.list[i].act = NETWORK_ACT_UMTS;
\r
1080 else if (GSM_AcT2 || GSM_Compact_AcT2)
\r
1081 resp.list[i].act = NETWORK_ACT_GPRS;
\r
1083 (resp.list_count)++;
\r
1085 tcore_at_tok_free(tokens);
\r
1090 ur = tcore_pending_ref_user_request(p);
\r
1092 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_PREFERRED_PLMN, sizeof(struct tresp_network_get_preferred_plmn), &resp);
\r
1098 static void on_response_get_serving_network(TcorePending *p, int data_len, const void *data, void *user_data)
\r
1100 const TcoreATResponse* resp = data;
\r
1102 struct tresp_network_get_serving_network Tresp = {0};
\r
1103 char plmn[7] = {0};
\r
1104 char *long_plmn_name = NULL;
\r
1105 char *short_plmn_name = NULL;
\r
1107 GSList *tokens=NULL;
\r
1109 int network_mode = -1;
\r
1110 int plmn_format = -1;
\r
1112 struct tnoti_network_identity noti;
\r
1113 char *pResp = NULL;
\r
1114 int nol, count =0;
\r
1116 o = tcore_pending_ref_core_object(p);
\r
1118 if(resp->success <= 0){
\r
1119 dbg("RESPONSE NOK");
\r
1121 ur = tcore_pending_ref_user_request(p);
\r
1123 Tresp.result = TCORE_RETURN_FAILURE;
\r
1124 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_SERVING_NETWORK, sizeof(struct tresp_network_get_serving_network), &Tresp);
\r
1129 dbg("RESPONSE OK");
\r
1130 nol = g_slist_length(resp->lines);
\r
1131 dbg("nol : %d", nol);
\r
1133 for(count =0; count < nol; count++){
\r
1134 //parse each line
\r
1135 line = g_slist_nth_data(resp->lines, count);
\r
1136 tokens = tcore_at_tok_new(line);
\r
1137 dbg("line %d start---------------",count);
\r
1139 if((pResp = tcore_at_tok_nth(tokens, 0))){
\r
1140 dbg("mode : %s",pResp);
\r
1141 network_mode = atoi(pResp);
\r
1144 //format (optional)
\r
1145 if((pResp = tcore_at_tok_nth(tokens, 1)))
\r
1147 dbg("format : %s",pResp);
\r
1148 if(strlen(pResp)>0)
\r
1149 plmn_format = atoi(pResp);
\r
1153 switch(plmn_format)
\r
1155 case AT_COPS_FORMAT_LONG_ALPHANUMERIC:
\r
1156 if((pResp = tcore_at_tok_nth(tokens, 2)))
\r
1158 dbg("long PLMN : %s",pResp);
\r
1159 if(strlen(pResp) > 0){
\r
1160 long_plmn_name = malloc((strlen(pResp) - 2)+1); /* 1 extra character for NULL storage */
\r
1161 memset(long_plmn_name, 0x00, strlen(pResp) -2+1);
\r
1162 /* Strip off starting quotes & ending quotes */
\r
1163 strncpy(long_plmn_name, pResp+1, strlen(pResp)-2);
\r
1165 //set network name into po
\r
1166 tcore_network_set_network_name(o,TCORE_NETWORK_NAME_TYPE_FULL,long_plmn_name);
\r
1171 case AT_COPS_FORMAT_SHORT_ALPHANUMERIC:
\r
1172 if((pResp = tcore_at_tok_nth(tokens, 2)))
\r
1174 dbg("short PLMN : %s",pResp);
\r
1175 if(strlen(pResp)>0){
\r
1176 short_plmn_name = malloc((strlen(pResp) - 2)+1); /* 1 extra character for NULL storage */
\r
1177 memset(short_plmn_name, 0x00, strlen(pResp) -2+1);
\r
1178 /* Strip off starting quotes & ending quotes */
\r
1179 strncpy(short_plmn_name, pResp+1, strlen(pResp)-2);
\r
1181 //set network name into po
\r
1182 tcore_network_set_network_name(o,TCORE_NETWORK_NAME_TYPE_SHORT,short_plmn_name);
\r
1187 case AT_COPS_FORMAT_NUMERIC:
\r
1188 if((pResp = tcore_at_tok_nth(tokens, 2)))
\r
1190 dbg("numeric : %s", pResp);
\r
1191 if(strlen(pResp)>0){
\r
1192 memset(plmn, 0, 7);
\r
1193 /* Strip off starting quotes & ending quotes */
\r
1194 strncpy(plmn, pResp+1, strlen(pResp)-2);
\r
1195 tcore_network_set_plmn(o,plmn);
\r
1205 if((pResp = tcore_at_tok_nth(tokens, 3)))
\r
1207 dbg("AcT : %s",pResp);
\r
1208 if(strlen(pResp)>0){
\r
1209 AcT = atoi(pResp);
\r
1210 tcore_network_set_access_technology(o, lookup_tbl_access_technology[AcT]);
\r
1214 tcore_at_tok_free(tokens);
\r
1217 memcpy(Tresp.plmn, plmn, 7);
\r
1218 tcore_network_get_access_technology(o, &(Tresp.act));
\r
1219 tcore_network_get_lac(o, &(Tresp.gsm.lac));
\r
1221 ur = tcore_pending_ref_user_request(p);
\r
1223 Tresp.result = TCORE_RETURN_SUCCESS;
\r
1224 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_SERVING_NETWORK, sizeof(struct tresp_network_get_serving_network), &Tresp);
\r
1228 /* Network change noti */
\r
1229 struct tnoti_network_change network_change;
\r
1231 memset(&network_change, 0, sizeof(struct tnoti_network_change));
\r
1232 memcpy(network_change.plmn, plmn, 7);
\r
1233 tcore_network_get_access_technology(o, &(network_change.act));
\r
1234 tcore_network_get_lac(o, &(network_change.gsm.lac));
\r
1236 tcore_server_send_notification(tcore_plugin_ref_server(tcore_pending_ref_plugin(p)), tcore_pending_ref_core_object(p),
\r
1237 TNOTI_NETWORK_CHANGE, sizeof(struct tnoti_network_change), &network_change);
\r
1238 dbg("dbg.. network_change.plmn : %s",network_change.plmn);
\r
1239 dbg("dbg.. network_change.act : %d",network_change.act);
\r
1240 dbg("dbg.. network_change.gsm.lac : %d",network_change.gsm.lac);
\r
1242 if((AT_COPS_MODE_DEREGISTER !=network_mode) &&
\r
1243 (AT_COPS_MODE_SET_ONLY != network_mode)){
\r
1244 /*Network identity noti*/
\r
1245 memset(¬i, 0x0, sizeof(struct tnoti_network_change));
\r
1246 if(long_plmn_name)
\r
1247 memcpy(noti.full_name, long_plmn_name, MIN(33, strlen(long_plmn_name)) );
\r
1248 if(short_plmn_name)
\r
1249 memcpy(noti.short_name, short_plmn_name, MIN(17, strlen(long_plmn_name)) );
\r
1250 memcpy(noti.plmn, plmn,7);
\r
1251 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)),
\r
1252 o, TNOTI_NETWORK_IDENTITY, sizeof(struct tnoti_network_identity), ¬i);
\r
1253 dbg("dbg.. noti.short_name : %s",noti.short_name);
\r
1254 dbg("dbg.. noti.full_name : %s",noti.full_name);
\r
1255 dbg("dbg.. noti.plmn : %s",noti.plmn);
\r
1259 if(long_plmn_name)
\r
1260 free(long_plmn_name);
\r
1261 if(short_plmn_name)
\r
1262 free(short_plmn_name);
\r
1269 static gboolean on_event_ps_network_regist(CoreObject *o, const void *data, void *user_data)
\r
1271 struct tnoti_network_registration_status regist_status;
\r
1272 enum telephony_network_service_domain_status cs_status;
\r
1273 enum telephony_network_service_domain_status ps_status;
\r
1274 enum telephony_network_service_type service_type;
\r
1275 enum telephony_network_access_technology act = NETWORK_ACT_UNKNOWN;
\r
1276 struct tnoti_network_location_cellinfo net_lac_cell_info = {0};
\r
1277 struct tnoti_ps_protocol_status noti = {0};
\r
1278 unsigned char svc_domain = NETWORK_SERVICE_DOMAIN_PS;
\r
1279 int stat= 0, AcT=0;
\r
1280 unsigned int lac=0xffff, ci=0xffff;
\r
1281 unsigned int rac = 0xffff;
\r
1282 GSList* tokens = NULL;
\r
1284 char *line = NULL;
\r
1285 GSList *lines = NULL;
\r
1287 lines = (GSList*)data;
\r
1288 if (1 != g_slist_length(lines)) {
\r
1289 dbg("unsolicited msg but multiple line");
\r
1292 line = (char*)(lines->data);
\r
1293 dbg("+CGREG NOTI RECEIVED");
\r
1296 +CREG: <stat> [[,<lac>,<ci>[AcT]]
\r
1298 Possible values of <stat> can be
\r
1299 0 Not registered, ME is not currently searching a new operator to register to
\r
1300 1 Registered, home network
\r
1301 2 Not registered, but ME is currently searching a new operator to register
\r
1302 3 Registration denied
\r
1304 5 Registered, in roaming
\r
1307 string type; two byte location area code in hexadecimal format (e.g. �00C3�)
\r
1310 string type; four byte cell ID in hexadecimal format (e.g. �0000A13F�)
\r
1318 6 UTRAN w/HSDPA and HSUPA
\r
1319 Note: <Act> is supporting from R7 and above Protocol Stack.
\r
1321 <rac>: is R7 and above feature, string type; one byte routing area code in hexadecimal format.
\r
1325 tokens = tcore_at_tok_new(line);
\r
1326 if(g_slist_length(tokens) < 1) {
\r
1327 msg("invalid message");
\r
1331 if(!(pResp = g_slist_nth_data(tokens, 0)))
\r
1333 dbg("No STAT in +CGREG");
\r
1338 stat = atoi(pResp);
\r
1339 if((pResp = g_slist_nth_data(tokens, 1)))
\r
1340 lac = atoi(pResp);
\r
1342 if((pResp = g_slist_nth_data(tokens, 2)))
\r
1345 dbg("No ci in +CGREG");
\r
1347 if((pResp = g_slist_nth_data(tokens, 3)))
\r
1348 AcT = atoi(pResp);
\r
1350 dbg("No AcT in +CGREG");
\r
1352 if((pResp = g_slist_nth_data(tokens, 4)))
\r
1353 rac = atoi(pResp);
\r
1355 dbg("No rac in +CGREG");
\r
1359 dbg("stat=%d, lac=0x%lx, ci=0x%lx, Act=%d, rac = 0x%x", stat, lac, ci, AcT, rac);
\r
1361 ps_status = lookup_tbl_net_status[stat];
\r
1363 tcore_network_set_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, ps_status);
\r
1364 _ps_set(tcore_object_ref_plugin(o), ps_status);
\r
1366 tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, &cs_status);
\r
1368 act = lookup_tbl_access_technology[AcT];
\r
1369 tcore_network_set_access_technology(o, act);
\r
1371 if (stat == AT_CREG_STAT_REG_ROAM)
\r
1372 tcore_network_set_roaming_state(o, TRUE);
\r
1374 tcore_network_set_roaming_state(o, FALSE);
\r
1376 tcore_network_get_service_type(o, &service_type);
\r
1377 dbg("prev_service_type = 0x%x", service_type);
\r
1378 service_type = _get_service_type(service_type, svc_domain, act, cs_status, ps_status);
\r
1379 dbg("new_service_type = 0x%x", service_type);
\r
1380 tcore_network_set_service_type(o, service_type);
\r
1382 tcore_network_set_lac(o, lac);
\r
1383 tcore_network_set_cell_id(o, ci);
\r
1384 tcore_network_set_rac(o, rac);
\r
1386 net_lac_cell_info.lac = lac;
\r
1387 net_lac_cell_info.cell_id = ci;
\r
1389 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_LOCATION_CELLINFO,
\r
1390 sizeof(struct tnoti_network_location_cellinfo), &net_lac_cell_info);
\r
1392 regist_status.cs_domain_status = cs_status;
\r
1393 regist_status.ps_domain_status = ps_status;
\r
1394 regist_status.service_type = service_type;
\r
1395 regist_status.roaming_status = tcore_network_get_roaming_state(o);
\r
1397 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o,
\r
1398 TNOTI_NETWORK_REGISTRATION_STATUS, sizeof(struct tnoti_network_registration_status), ®ist_status);
\r
1400 if(service_type == NETWORK_SERVICE_TYPE_HSDPA)
\r
1401 noti.status = TELEPHONY_HSDPA_ON;
\r
1403 noti.status = TELEPHONY_HSDPA_OFF;
\r
1405 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_PS_PROTOCOL_STATUS,
\r
1406 sizeof(struct tnoti_ps_protocol_status), ¬i);
\r
1408 /* Get PLMN ID needed to application */
\r
1409 //get_serving_network(o, NULL);
\r
1415 dbg("Response NOK");
\r
1420 tcore_at_tok_free(tokens);
\r
1424 static gboolean on_event_cs_network_regist(CoreObject *o, const void *event_info, void *user_data)
\r
1426 GSList *lines = NULL;
\r
1427 char *line = NULL;
\r
1428 struct tnoti_network_registration_status regist_status;
\r
1429 enum telephony_network_service_domain_status cs_status;
\r
1430 enum telephony_network_service_domain_status ps_status;
\r
1431 enum telephony_network_service_type service_type;
\r
1432 enum telephony_network_access_technology act = NETWORK_ACT_UNKNOWN;
\r
1433 struct tnoti_network_location_cellinfo net_lac_cell_info = {0};
\r
1436 unsigned char svc_domain = NETWORK_SERVICE_DOMAIN_CS;
\r
1437 int stat= 0, AcT=0;
\r
1438 unsigned int lac=0xffff, ci=0xffff;
\r
1439 GSList* tokens = NULL;
\r
1442 lines = (GSList*)event_info;
\r
1443 if (1 != g_slist_length(lines)) {
\r
1444 dbg("unsolicited msg but multiple line");
\r
1447 line = (char*)(lines->data);
\r
1449 dbg("+CREG NOTI RECEIVED");
\r
1452 +CREG: <stat> [[,<lac>,<ci>[AcT]]
\r
1454 Possible values of <stat> can be
\r
1455 0 Not registered, ME is not currently searching a new operator to register to
\r
1456 1 Registered, home network
\r
1457 2 Not registered, but ME is currently searching a new operator to register
\r
1458 3 Registration denied
\r
1460 5 Registered, in roaming
\r
1463 string type; two byte location area code in hexadecimal format (e.g. �00C3�)
\r
1466 string type; four byte cell ID in hexadecimal format (e.g. �0000A13F�)
\r
1474 6 UTRAN w/HSDPA and HSUPA
\r
1475 Note: <Act> is supporting from R7 and above Protocol Stack.
\r
1479 tokens = tcore_at_tok_new(line);
\r
1480 if(g_slist_length(tokens) < 1) {
\r
1481 msg("invalid message");
\r
1485 if(!(pResp = g_slist_nth_data(tokens, 0)))
\r
1487 dbg("No STAT in +CREG");
\r
1492 stat = atoi(pResp);
\r
1493 if((pResp = g_slist_nth_data(tokens, 1)))
\r
1494 lac = atoi(pResp);
\r
1496 if((pResp = g_slist_nth_data(tokens, 2)))
\r
1499 dbg("No ci in +CREG");
\r
1501 if((pResp = g_slist_nth_data(tokens, 3)))
\r
1502 AcT = atoi(pResp);
\r
1504 dbg("No AcT in +CREG");
\r
1508 dbg("stat=%d, lac=0x%lx, ci=0x%lx, Act=%d", stat, lac, ci, AcT);
\r
1510 cs_status = lookup_tbl_net_status[stat];
\r
1511 tcore_network_set_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, cs_status);
\r
1513 // tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, &cs_status);
\r
1514 tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, &ps_status);
\r
1516 act = lookup_tbl_access_technology[AcT];
\r
1517 tcore_network_set_access_technology(o, act);
\r
1519 if (stat == AT_CREG_STAT_REG_ROAM)
\r
1520 tcore_network_set_roaming_state(o, TRUE);
\r
1522 tcore_network_set_roaming_state(o, FALSE);
\r
1524 tcore_network_get_service_type(o, &service_type);
\r
1525 dbg("prev_service_type = 0x%x", service_type);
\r
1526 service_type = _get_service_type(service_type, svc_domain, act, cs_status, ps_status);
\r
1527 dbg("new_service_type = 0x%x", service_type);
\r
1528 tcore_network_set_service_type(o, service_type);
\r
1530 tcore_network_set_lac(o, lac);
\r
1531 tcore_network_set_cell_id(o, ci);
\r
1533 net_lac_cell_info.lac = lac;
\r
1534 net_lac_cell_info.cell_id = ci;
\r
1536 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_LOCATION_CELLINFO,
\r
1537 sizeof(struct tnoti_network_location_cellinfo), &net_lac_cell_info);
\r
1539 regist_status.cs_domain_status = cs_status;
\r
1540 regist_status.ps_domain_status = ps_status;
\r
1541 regist_status.service_type = service_type;
\r
1542 regist_status.roaming_status = tcore_network_get_roaming_state(o);
\r
1544 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o,
\r
1545 TNOTI_NETWORK_REGISTRATION_STATUS, sizeof(struct tnoti_network_registration_status), ®ist_status);
\r
1547 /* Get PLMN ID needed to application */
\r
1548 if((NETWORK_SERVICE_DOMAIN_STATUS_FULL == cs_status )||
\r
1549 NETWORK_SERVICE_DOMAIN_STATUS_FULL ==ps_status )
\r
1550 get_serving_network(o, NULL);
\r
1554 dbg("Response NOK");
\r
1559 tcore_at_tok_free(tokens);
\r
1564 static gboolean on_event_network_icon_info(CoreObject *o, const void *event_info, void *user_data)
\r
1566 struct tnoti_network_icon_info net_icon_info = {0};
\r
1567 char *line = NULL;
\r
1568 char * rssiToken = NULL;
\r
1569 char *batteryToken = NULL;
\r
1570 GSList* tokens = NULL;
\r
1571 GSList *lines = NULL;
\r
1573 lines = (GSList*)event_info;
\r
1574 if (1 != g_slist_length(lines)) {
\r
1575 dbg("unsolicited msg but multiple line");
\r
1578 line = (char*)(lines->data);
\r
1579 dbg("+XCIEV Network Icon Info Noti Recieve");
\r
1580 memset(&net_icon_info, 0, sizeof(struct tnoti_network_icon_info));
\r
1584 dbg("Response OK");
\r
1586 tokens = tcore_at_tok_new(line);
\r
1587 if (g_slist_length(tokens) != 2) {
\r
1588 msg("invalid message");
\r
1592 rssiToken = (char *)g_slist_nth_data(tokens, 0);
\r
1594 if (strlen(rssiToken)>0)
\r
1596 net_icon_info.type = NETWORK_ICON_INFO_RSSI;
\r
1597 net_icon_info.rssi= atoi(g_slist_nth_data(tokens, 0));
\r
1598 dbg("rssi level : %d",net_icon_info.rssi);
\r
1601 batteryToken = (char *)g_slist_nth_data(tokens,1);
\r
1602 if (strlen(batteryToken)>0)
\r
1604 net_icon_info.type = NETWORK_ICON_INFO_BATTERY;
\r
1605 net_icon_info.battery= atoi(g_slist_nth_data(tokens, 1));
\r
1606 dbg("battery level : %d",net_icon_info.battery);
\r
1609 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_ICON_INFO,
\r
1610 sizeof(struct tnoti_network_icon_info), &net_icon_info);
\r
1614 dbg("Response NOK");
\r
1620 tcore_at_tok_free(tokens);
\r
1626 static gboolean on_event_network_ds_time_info(CoreObject *o, const void *event_info, void *user_data)
\r
1630 <dst> daylight savings time value:
\r
1631 0 No adjustment for Daylight Saving Time
\r
1632 1 +1 hour adjustment for Daylight Saving Time
\r
1633 2 +2 hours adjustment for Daylight Saving Time
\r
1639 static gboolean on_event_network_ctzv_time_info(CoreObject *o, const void *event_info, void *user_data)
\r
1641 struct tnoti_network_timeinfo net_time_info = {0};
\r
1642 char *line = NULL;
\r
1643 GSList* tokens = NULL;
\r
1645 char *time_zone = NULL;
\r
1646 GSList *lines = NULL;
\r
1647 char ptime_param[20] = {0};
\r
1648 UserRequest *ur = NULL;
\r
1649 dbg("Enter : on_event_network_ctzv_time_info");
\r
1651 lines = (GSList*)event_info;
\r
1652 if (1 != g_slist_length(lines)) {
\r
1653 dbg("unsolicited msg but multiple line");
\r
1656 line = (char*)(lines->data);
\r
1659 +CTZV: <tz>,<time>
\r
1660 <tz> integer value indicating the time zone (e.g. -22 or +34)
\r
1661 <time> string type value; format is “yy/MM/dd,hh:mms”, wherein characters indicates year, month, day, hour,
\r
1664 dbg("Network time info (+CTZV) recieved");
\r
1668 dbg("Response OK");
\r
1669 dbg("noti line is %s", line);
\r
1671 tokens = tcore_at_tok_new(line);
\r
1673 if(g_slist_length(tokens) < 2) {
\r
1674 msg("invalid message");
\r
1678 if ((time_zone = g_slist_nth_data(tokens, 0))){
\r
1679 net_time_info.gmtoff = atoi(time_zone) * 15; /* TZ in minutes */
\r
1682 if (tcore_network_get_plmn(o) != NULL)
\r
1683 strcpy(net_time_info.plmn, tcore_network_get_plmn(o));
\r
1685 if ((time = g_slist_nth_data(tokens, 1)) && (strlen(time) >18)){
\r
1686 strncpy(ptime_param, time+1, 2); /* skip past initial quote (") */
\r
1687 net_time_info.year = atoi(ptime_param);
\r
1689 strncpy(ptime_param, time+4, 2); /* skip slash (/) after year param */
\r
1690 net_time_info.month = atoi(ptime_param);
\r
1692 strncpy(ptime_param, time+7, 2); /* skip past slash (/) after month param */
\r
1693 net_time_info.day = atoi(ptime_param);
\r
1695 strncpy(ptime_param, time+10, 2); /* skip past comma (,) after day param */
\r
1696 net_time_info.hour = atoi(ptime_param);
\r
1698 strncpy(ptime_param, time+13, 2); /* skip past colon (:) after hour param */
\r
1699 net_time_info.minute = atoi(ptime_param);
\r
1701 strncpy(ptime_param, time+16, 2); /* skip past colon (:) after minute param */
\r
1702 net_time_info.second = atoi(ptime_param);
\r
1704 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_TIMEINFO, sizeof(struct tnoti_network_timeinfo), &net_time_info);
\r
1706 dbg("new pending(AT+XOPS=0/5/6 for Nitz PLMN name)");
\r
1708 /* Get NITZ name and plmn_id via AT+XCOPS = 0/5/6 */
\r
1709 nwk_prepare_and_send_pending_request(tcore_object_ref_plugin(o), "umts_network", "AT+XCOPS=0;+XCOPS=5;+XCOPS=6", "+XCOPS", TCORE_AT_MULTILINE, ur, on_response_get_nitz_name);
\r
1713 dbg("line is NULL");
\r
1718 tcore_at_tok_free(tokens);
\r
1720 dbg("Exit: on_event_network_ctzv_time_info");
\r
1724 static void on_sim_resp_hook_get_netname(UserRequest *ur, enum tcore_response_command command, unsigned int data_len,
\r
1725 const void *data, void *user_data)
\r
1727 const struct tresp_sim_read *resp = data;
\r
1728 CoreObject *o = user_data;
\r
1730 if (command == TRESP_SIM_GET_SPN) {
\r
1731 dbg("OK SPN GETTING!!");
\r
1732 dbg("resp->result = 0x%x", resp->result);
\r
1733 dbg("resp->data.spn.display_condition = 0x%x", resp->data.spn.display_condition);
\r
1734 dbg("resp->data.spn.spn = [%s]", resp->data.spn.spn);
\r
1736 tcore_network_set_network_name(o, TCORE_NETWORK_NAME_TYPE_SPN, (const char *)resp->data.spn.spn);
\r
1739 * display condition
\r
1740 * bit[0]: 0 = display of registered PLMN name not required when registered PLMN is either HPLMN or a PLMN in the service provider PLMN list
\r
1741 * 1 = display of registered PLMN name required when registered PLMN is either HPLMN or a PLMN in the service provider PLMN list
\r
1742 * bit[1]: 0 = display of the service provider name is required when registered PLMN is neither HPLMN nor a PLMN in the service provider PLMN list
\r
1743 * 1 = display of the service provider name is not required when registered PLMN is neither HPLMN nor a PLMN in the service provider PLMN list
\r
1745 if (resp->data.spn.display_condition & 0x01) {
\r
1746 tcore_network_set_network_name_priority(o, TCORE_NETWORK_NAME_PRIORITY_NETWORK);
\r
1748 if ((resp->data.spn.display_condition & 0x02) == 0) {
\r
1749 tcore_network_set_network_name_priority(o, TCORE_NETWORK_NAME_PRIORITY_SPN);
\r
1751 if ((resp->data.spn.display_condition & 0x03) == 0x01) {
\r
1752 tcore_network_set_network_name_priority(o, TCORE_NETWORK_NAME_PRIORITY_ANY);
\r
1757 static enum tcore_hook_return on_hook_sim_init(Server *s, CoreObject *source, enum tcore_notification_command command,
\r
1758 unsigned int data_len, void *data, void *user_data)
\r
1760 const struct tnoti_sim_status *sim = data;
\r
1761 UserRequest *ur = NULL;
\r
1763 if (sim->sim_status == SIM_STATUS_INIT_COMPLETED) {
\r
1764 ur = tcore_user_request_new(NULL, NULL);
\r
1765 tcore_user_request_set_command(ur, TREQ_SIM_GET_SPN);
\r
1766 tcore_user_request_set_response_hook(ur, on_sim_resp_hook_get_netname, user_data);
\r
1767 tcore_object_dispatch_request(source, ur);
\r
1770 return TCORE_HOOK_RETURN_CONTINUE;
\r
1773 static TReturn search_network(CoreObject *o, UserRequest *ur)
\r
1775 TcoreHal *h = NULL;
\r
1776 TcorePending *pending = NULL;
\r
1777 TcoreATRequest *atreq = NULL;
\r
1779 char*cmd_str = NULL;
\r
1780 dbg("search_network - ENTER!!");
\r
1783 return TCORE_RETURN_EINVAL;
\r
1785 h = tcore_object_get_hal(o);
\r
1786 pending = tcore_pending_new(o, 0);
\r
1788 cmd_str = g_strdup_printf("AT+COPS=?");
\r
1789 atreq = tcore_at_request_new(cmd_str, "+COPS", TCORE_AT_SINGLELINE);
\r
1791 tcore_pending_set_request_data(pending, 0, atreq);
\r
1792 tcore_pending_set_timeout(pending, 60);
\r
1793 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
\r
1794 tcore_pending_set_response_callback(pending, on_response_search_network, NULL);
\r
1795 tcore_pending_set_timeout_callback(pending, on_timeout_search_network, NULL);
\r
1796 tcore_pending_link_user_request(pending, ur);
\r
1797 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
1799 tcore_hal_send_request(h, pending);
\r
1801 return TCORE_RETURN_SUCCESS;
\r
1804 static TReturn set_plmn_selection_mode(CoreObject *o, UserRequest *ur)
\r
1806 TcoreHal *h = NULL;
\r
1807 TcorePending *pending = NULL;
\r
1808 TcoreATRequest *atreq;
\r
1809 char*cmd_str = NULL;
\r
1810 int format = 0; /* default value for long alphanumeric */
\r
1812 char plmn[7] = {0};
\r
1815 const struct treq_network_set_plmn_selection_mode *req_data;
\r
1818 dbg("set_plmn_selection_mode - ENTER!!");
\r
1821 return TCORE_RETURN_EINVAL;
\r
1823 req_data = tcore_user_request_ref_data(ur, NULL);
\r
1824 h = tcore_object_get_hal(o);
\r
1825 pending = tcore_pending_new(o, 0);
\r
1827 // Command Format - AT+COPS=[<mode>[,<format>[,<oper>[,< AcT>]]]]
\r
1828 /* oper parameter format
\r
1829 - 0 <oper> format presentations are set to long alphanumeric. If Network name not available it displays combination of Mcc and MNC in string format.
\r
1830 - 1 <oper> format presentation is set to short alphanumeric.
\r
1831 - 2 <oper> format presentations set to numeric.
\r
1834 if((req_data->act == NETWORK_ACT_GSM ) || (req_data->act == NETWORK_ACT_EGPRS ))
\r
1839 switch(req_data->mode) {
\r
1840 case NETWORK_SELECT_MODE_GSM_MANUAL:
\r
1842 mode = AT_COPS_MODE_MANUAL;
\r
1843 format = AT_COPS_FORMAT_NUMERIC;
\r
1845 memset(plmn, 0, 7);
\r
1846 memcpy(plmn, req_data->plmn, 6);
\r
1848 if (strlen(req_data->plmn) == 6) {
\r
1853 cmd_str = g_strdup_printf("AT+COPS=%d,%d,\"%s\",%d", mode, format, plmn, act);
\r
1857 case NETWORK_SELECT_MODE_GLOBAL_AUTOMATIC:
\r
1859 cmd_str = g_strdup("AT+COPS=0");
\r
1864 atreq = tcore_at_request_new(cmd_str, "+COPS", TCORE_AT_NO_RESULT);
\r
1866 tcore_pending_set_request_data(pending, 0, atreq);
\r
1867 tcore_pending_set_response_callback(pending, on_response_set_plmn_selection_mode, NULL);
\r
1868 tcore_pending_link_user_request(pending, ur);
\r
1869 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
1872 tcore_hal_send_request(h, pending);
\r
1874 return TCORE_RETURN_SUCCESS;
\r
1877 static TReturn get_plmn_selection_mode(CoreObject *o, UserRequest *ur)
\r
1879 TcoreHal *h = NULL;
\r
1880 TcorePending *pending = NULL;
\r
1881 TcoreATRequest *atreq;
\r
1882 char*cmd_str = NULL;
\r
1884 dbg("get_plmn_selection_mode - ENTER!!");
\r
1887 return TCORE_RETURN_EINVAL;
\r
1889 h = tcore_object_get_hal(o);
\r
1890 pending = tcore_pending_new(o, 0);
\r
1892 cmd_str = g_strdup_printf("AT+COPS?");
\r
1893 atreq = tcore_at_request_new(cmd_str, "+COPS", TCORE_AT_SINGLELINE);
\r
1895 tcore_pending_set_request_data(pending, 0, atreq);
\r
1896 tcore_pending_set_response_callback(pending, on_response_get_plmn_selection_mode, NULL);
\r
1897 tcore_pending_link_user_request(pending, ur);
\r
1898 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
1900 tcore_hal_send_request(h, pending);
\r
1902 return TCORE_RETURN_SUCCESS;
\r
1906 static TReturn set_band(CoreObject *o, UserRequest *ur)
\r
1908 TcoreHal *h = NULL;
\r
1909 TcorePending *pending = NULL;
\r
1910 TcorePending *pending_gsm = NULL;
\r
1911 TcorePending *pending_umts = NULL;
\r
1912 TcoreATRequest *atreq;
\r
1913 char*cmd_str = NULL;
\r
1914 const struct treq_network_set_band *req_data;
\r
1915 gboolean set_gsm_band = 0;
\r
1916 gboolean set_umts_band = 0;
\r
1917 int gsm_band = 255;
\r
1918 int gsm_band2 = 255;
\r
1919 char *umts_band = NULL;
\r
1920 UserRequest *dup_ur_gsm = NULL;
\r
1921 UserRequest *dup_ur_umts = NULL;
\r
1923 dbg("set_band - ENTER!!");
\r
1926 return TCORE_RETURN_EINVAL;
\r
1928 req_data = tcore_user_request_ref_data(ur, NULL);
\r
1929 h = tcore_object_get_hal(o);
\r
1931 dbg("set_band - called with band = %d", req_data->band);
\r
1933 switch (req_data->band)
\r
1935 case NETWORK_BAND_TYPE_GSM850:
\r
1936 gsm_band = AT_GSM_XBANDSEL_850;
\r
1937 set_gsm_band = TRUE;
\r
1940 case NETWORK_BAND_TYPE_GSM_900_1800:
\r
1941 gsm_band = AT_GSM_XBANDSEL_900;
\r
1942 gsm_band2 = AT_GSM_XBANDSEL_1800;
\r
1943 set_gsm_band = TRUE;
\r
1946 case NETWORK_BAND_TYPE_GSM1900:
\r
1947 gsm_band = AT_GSM_XBANDSEL_1900;
\r
1948 set_gsm_band = TRUE;
\r
1951 case NETWORK_BAND_TYPE_GSM1800:
\r
1952 gsm_band = AT_GSM_XBANDSEL_1800;
\r
1953 set_gsm_band = TRUE;
\r
1956 case NETWORK_BAND_TYPE_GSM_850_1900:
\r
1957 gsm_band = AT_GSM_XBANDSEL_850;
\r
1958 gsm_band2 = AT_GSM_XBANDSEL_1900;
\r
1959 set_gsm_band = TRUE;
\r
1962 case NETWORK_BAND_TYPE_ANY:
\r
1963 gsm_band = AT_GSM_XBANDSEL_AUTOMATIC;
\r
1964 set_umts_band = TRUE;
\r
1965 set_gsm_band = TRUE;
\r
1968 case NETWORK_BAND_TYPE_WCDMA:
\r
1969 set_umts_band = TRUE;
\r
1972 case NETWORK_BAND_TYPE_WCDMA2100:
\r
1973 umts_band = "UMTS_BAND_I";
\r
1974 set_umts_band = TRUE;
\r
1977 case NETWORK_BAND_TYPE_WCDMA1900:
\r
1978 umts_band = "UMTS_BAND_II";
\r
1979 set_umts_band = TRUE;
\r
1982 case NETWORK_BAND_TYPE_WCDMA850:
\r
1983 umts_band = "UMTS_BAND_V";
\r
1984 set_umts_band = TRUE;
\r
1991 dbg("set_band > set_umts_band = %d, set_gsm_band = %d", set_umts_band, set_gsm_band);
\r
1993 if(set_umts_band == TRUE)
\r
1995 if((req_data->band == NETWORK_BAND_TYPE_WCDMA) || (req_data->band == NETWORK_BAND_TYPE_ANY))
\r
1996 cmd_str = g_strdup_printf("AT+XUBANDSEL=0");
\r
1998 cmd_str = g_strdup_printf("AT+XUBANDSEL=%s", umts_band);
\r
2000 atreq = tcore_at_request_new(cmd_str, "+XUBANDSEL", TCORE_AT_NO_RESULT);
\r
2001 pending_umts = tcore_pending_new(o, 0);
\r
2003 tcore_pending_set_request_data(pending_umts, 0, atreq);
\r
2004 tcore_pending_set_timeout(pending_umts, 0);
\r
2005 tcore_pending_set_priority(pending_umts, TCORE_PENDING_PRIORITY_DEFAULT);
\r
2006 tcore_pending_set_response_callback(pending_umts, on_response_set_umts_band, NULL);
\r
2008 /* duplicate user request for UMTS Band setting AT command for same UR */
\r
2009 dup_ur_umts = tcore_user_request_ref(ur);
\r
2010 tcore_pending_link_user_request(pending_umts, dup_ur_umts);
\r
2011 tcore_pending_set_send_callback(pending_umts, on_confirmation_network_message_send, NULL);
\r
2013 tcore_hal_send_request(h, pending_umts);
\r
2016 if(set_gsm_band == TRUE)
\r
2018 dbg("Entered set_gsm_band");
\r
2019 if (gsm_band2 == 255)
\r
2020 cmd_str = g_strdup_printf("AT+XBANDSEL=%d", gsm_band);
\r
2022 cmd_str = g_strdup_printf("AT+XBANDSEL=%d,%d", gsm_band, gsm_band2);
\r
2024 dbg("Command string: %s",cmd_str);
\r
2025 atreq = tcore_at_request_new(cmd_str, "+XBANDSEL", TCORE_AT_NO_RESULT);
\r
2026 pending_gsm = tcore_pending_new(o, 0);
\r
2028 tcore_pending_set_request_data(pending_gsm, 0, atreq);
\r
2029 tcore_pending_set_timeout(pending_gsm, 0);
\r
2030 tcore_pending_set_priority(pending_gsm, TCORE_PENDING_PRIORITY_DEFAULT);
\r
2031 tcore_pending_set_response_callback(pending_gsm, on_response_set_gsm_band, NULL);
\r
2033 /* duplicate user request for GSM Band setting AT command for same UR */
\r
2034 dup_ur_gsm = tcore_user_request_ref(ur);
\r
2035 tcore_pending_link_user_request(pending_gsm, dup_ur_gsm);
\r
2036 tcore_pending_set_send_callback(pending_gsm, on_confirmation_network_message_send, NULL);
\r
2038 tcore_hal_send_request(h, pending_gsm);
\r
2041 /* Lock device to specific RAT as requested by application */
\r
2043 AT+XRAT=<Act>[,<PreferredAct>]
\r
2044 <AcT> indicates the radio access technology and may be
\r
2046 1 GSM / UMTS Dual mode
\r
2049 if ((set_umts_band == TRUE) && (set_gsm_band == TRUE)){
\r
2050 cmd_str = g_strdup_printf("AT+XRAT=%d", AT_XRAT_DUAL);
\r
2052 else if (set_umts_band == TRUE){
\r
2053 cmd_str = g_strdup_printf("AT+XRAT=%d", AT_XRAT_UMTS);
\r
2056 cmd_str = g_strdup_printf("AT+XRAT=%d", AT_XRAT_GSM);
\r
2058 atreq = tcore_at_request_new(cmd_str, "+XRAT", TCORE_AT_NO_RESULT);
\r
2059 pending = tcore_pending_new(o, 0);
\r
2061 tcore_pending_set_request_data(pending, 0, atreq);
\r
2062 tcore_pending_set_timeout(pending, 0);
\r
2063 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
\r
2064 tcore_pending_set_response_callback(pending, on_response_set_xrat, NULL);
\r
2065 tcore_pending_link_user_request(pending, ur);
\r
2066 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
2068 tcore_hal_send_request(h, pending);
\r
2070 return TCORE_RETURN_SUCCESS;
\r
2073 static TReturn get_band(CoreObject *o, UserRequest *ur)
\r
2075 TcoreHal *h = NULL;
\r
2076 TcorePending *pending = NULL;
\r
2078 TcoreATRequest *atreq;
\r
2079 char*cmd_str = NULL;
\r
2080 dbg("get_band - ENTER!!");
\r
2083 return TCORE_RETURN_EINVAL;
\r
2085 h = tcore_object_get_hal(o);
\r
2087 /* Get RAT Information Information. Based on RAT read response, we will get specific RAT bands only */
\r
2088 cmd_str = g_strdup_printf("AT+XRAT?");
\r
2089 atreq = tcore_at_request_new(cmd_str, "+XRAT", TCORE_AT_SINGLELINE);
\r
2090 pending = tcore_pending_new(o, 0);
\r
2091 tcore_pending_set_request_data(pending, 0, atreq);
\r
2092 tcore_pending_set_response_callback(pending, on_response_get_xrat, NULL);
\r
2093 tcore_pending_link_user_request(pending, ur);
\r
2094 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
2095 tcore_hal_send_request(h, pending);
\r
2097 return TCORE_RETURN_SUCCESS;
\r
2100 static TReturn set_preferred_plmn(CoreObject *o, UserRequest *ur)
\r
2102 TcoreHal *h = NULL;
\r
2103 TcorePlugin *p = NULL;
\r
2104 TcorePending *pending = NULL;
\r
2105 TcoreATRequest *atreq = NULL;
\r
2106 const struct treq_network_set_preferred_plmn *req_data = NULL;
\r
2107 char*cmd_str = NULL;
\r
2108 int format = 2; /* Alway use numeric format, as application gives data in this default format */
\r
2110 int gsm_compact_act = 0;
\r
2111 int utran_act = 0;
\r
2114 return TCORE_RETURN_EINVAL;
\r
2116 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2118 dbg("Entry set_preferred_plmn");
\r
2120 p = tcore_object_ref_plugin(o);
\r
2121 h = tcore_object_get_hal(o);
\r
2125 [<index>][,<format>[,<oper>[,<GSM_AcT>,
\r
2126 <GSM_Compact_AcT>,<UTRAN_AcT>]]]
\r
2129 if((req_data->act == NETWORK_ACT_GSM) || (req_data->act == NETWORK_ACT_GPRS) || (req_data->act == NETWORK_ACT_EGPRS))
\r
2131 else if ((req_data->act == NETWORK_ACT_UMTS) || (req_data->act == NETWORK_ACT_UTRAN))
\r
2133 else if (req_data->act == NETWORK_ACT_GSM_UTRAN)
\r
2134 gsm_act= utran_act = TRUE;
\r
2136 cmd_str = g_strdup_printf("AT+CPOL=%d,%d,\"%s\",%d, %d,%d",req_data->ef_index, format, req_data->plmn, gsm_act, gsm_compact_act, utran_act);
\r
2137 atreq = tcore_at_request_new(cmd_str, "+CPOL", TCORE_AT_NO_RESULT);
\r
2139 tcore_pending_set_request_data(pending, 0, atreq);
\r
2140 tcore_pending_set_response_callback(pending, on_response_set_preferred_plmn, NULL);
\r
2141 tcore_pending_link_user_request(pending, ur);
\r
2142 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
2144 tcore_hal_send_request(h, pending);
\r
2146 dbg("Exit set_preferred_plmn");
\r
2147 return TCORE_RETURN_SUCCESS;
\r
2150 static TReturn get_preferred_plmn(CoreObject *o, UserRequest *ur)
\r
2153 TcoreHal *h = NULL;
\r
2154 TcorePending *pending = NULL;
\r
2155 TcoreATRequest *atreq = NULL;
\r
2157 char*cmd_str = NULL;
\r
2159 dbg("get_preferred_plmn - ENTER!!");
\r
2162 return TCORE_RETURN_EINVAL;
\r
2164 h = tcore_object_get_hal(o);
\r
2165 pending = tcore_pending_new(o, 0);
\r
2167 cmd_str = g_strdup_printf("AT+CPOL?");
\r
2168 atreq = tcore_at_request_new(cmd_str, "+CPOL", TCORE_AT_MULTILINE);
\r
2170 tcore_pending_set_request_data(pending, 0, atreq);
\r
2171 tcore_pending_set_response_callback(pending, on_response_get_preferred_plmn, NULL);
\r
2172 tcore_pending_link_user_request(pending, ur);
\r
2173 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);
\r
2175 tcore_hal_send_request(h, pending);
\r
2177 dbg("get_preferred_plmn - EXIT!!");
\r
2179 return TCORE_RETURN_SUCCESS;
\r
2182 static TReturn get_serving_network(CoreObject *o, UserRequest *ur)
\r
2184 dbg("get_serving_network - ENTER!!");
\r
2187 return TCORE_RETURN_EINVAL;
\r
2189 dbg("new pending(AT+COPS?)");
\r
2191 nwk_prepare_and_send_pending_request(tcore_object_ref_plugin(o), "umts_network", "AT+COPS=3,2;+COPS?;+COPS=3,0;+COPS?", "+COPS", TCORE_AT_MULTILINE, ur, on_response_get_serving_network);
\r
2192 return TCORE_RETURN_SUCCESS;
\r
2195 static struct tcore_network_operations network_ops = {
\r
2196 .search = search_network,
\r
2197 .set_plmn_selection_mode = set_plmn_selection_mode,
\r
2198 .get_plmn_selection_mode = get_plmn_selection_mode,
\r
2199 .set_service_domain = NULL,
\r
2200 .get_service_domain = NULL,
\r
2201 .set_band = set_band,
\r
2202 .get_band = get_band,
\r
2203 .set_preferred_plmn = set_preferred_plmn,
\r
2204 .get_preferred_plmn = get_preferred_plmn,
\r
2205 .set_order = NULL,
\r
2206 .get_order = NULL,
\r
2207 .set_power_on_attach = NULL,
\r
2208 .get_power_on_attach = NULL,
\r
2209 .set_cancel_manual_search = NULL,
\r
2210 .get_serving_network = get_serving_network,
\r
2213 gboolean s_network_init(TcorePlugin *p, TcoreHal *h)
\r
2215 CoreObject *o = NULL;
\r
2217 o = tcore_network_new(p, "umts_network", &network_ops, h);
\r
2221 tcore_object_add_callback(o,"+CREG", on_event_cs_network_regist, NULL);
\r
2222 tcore_object_add_callback(o,"+CGREG", on_event_ps_network_regist, NULL);
\r
2223 tcore_object_add_callback(o, "+XCIEV", on_event_network_icon_info, NULL);
\r
2225 /* +CTZV: <tz>,<time> */
\r
2226 tcore_object_add_callback(o, "+CTZV", on_event_network_ctzv_time_info, NULL);
\r
2227 /* +CTZDST: <dst> */
\r
2228 tcore_object_add_callback(o, "+CTZDST", on_event_network_ds_time_info, NULL);
\r
2230 tcore_server_add_notification_hook(tcore_plugin_ref_server(p), TNOTI_SIM_STATUS, on_hook_sim_init, o);
\r
2232 _insert_mcc_mnc_oper_list(p, o);
\r
2237 void s_network_exit(TcorePlugin *p)
\r
2241 o = tcore_plugin_ref_core_object(p, "umts_network");
\r
2243 tcore_network_free(o);
\r