Gitiles
Code Review Sign In
192.168.1.100 / T108_Public / 4d35fdd8690c0ce7a6cbfe5f692deaeaeed66d97 / . / mbtk / libql_lib / src / ql_quec_nw.c
blob: 8f1758b61f77baecf6247ccc1acf823540e1da1a [file] [log] [blame]
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]1#include "ql/ql_nw.h"
2#include "mbtk_type.h"
3#include "mbtk_info_api.h"
4
5extern mbtk_info_handle_t* ql_info_handle;
6extern int ql_info_handle_num;
7static bool inited = FALSE;
8
liuyangc989a662024-07-10 19:02:23 +0800[diff] [blame]9#define SIGNAL_STRENGTH_INVALID_1 99
10#define SIGNAL_STRENGTH_INVALID_2 255
11
12
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]13typedef struct
14{
15 uint8 *operator_l;
16 uint8 *operator_s;
17 uint32 mcc_mnc;
18} operator_mcc_mnc_t;
19
20typedef struct
21{
22 QL_NW_EventHandlerFunc_t handlerPtr;
23 void* contextPtr;
24} ql_cust_cb_func;
25
26static ql_cust_cb_func ql_func_cb_handle;
27
28static int roaming_pref = 1; // Open roaming for default.
29
30static operator_mcc_mnc_t operator_mcc_mnc [] =
31{
32 {"China Mobile","CMCC",46000},
33 {"China Unicom","CU",46001},
34 {"China Mobile","CMCC",46002},
35 {"China Telecom","CT",46003},
36 {"China Mobile","CMCC",46004},
37 {"China Telecom","CT",46005},
38 {"China Unicom","CU",46006},
39 {"China Mobile","CMCC",46007},
40 {"China Mobile","CMCC",46008},
41 {"China Unicom","CU",46009},
42 {"China Telecom","CT",46011}
43};
44
45typedef enum {
46 RADIO_TECH_3GPP = 1, /* 3GPP Technologies - GSM, WCDMA */
47 RADIO_TECH_3GPP2 = 2 /* 3GPP2 Technologies - CDMA */
48} RIL_RadioTechnologyFamily;
49
50void ql_nw_state_change_cb(const void* data, int data_len)
51{
52 ///mbtk_net_info_t *reg = (mbtk_net_info_t *)data;
53 uint8 *net_data = NULL;
54
55 net_data = (uint8*)data;
56 /*
57 uint8 data[3];
58 data[0] = (uint8)MBTK_NET_CS_STATE;
59
60 net_data[0] = *(uint8 *)(data); //MBTK_NET_PS_STATE
61 net_data[1] = *(uint8 *)(data + sizeof(uint8)); //mbtk_net_reg_state_enum state Reg State
62 net_data[2] = *(uint8 *)(data + sizeof(uint8) + sizeof(uint8)); //act
63 */
64 if(roaming_pref == 0)
65 {
66 mbtk_modem_info_t info;
67 if(*net_data == 5)
68 {
69 info.fun=4;
70 //ql_netw_status_cb(5);
71 }
72 else
73 info.fun=1;
74 info.rst=0;
liuyang4d35fdd2024-07-18 10:55:02 +0800[diff] [blame^]75 //mbtk_set_modem_fun(ql_info_handle, &info);
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]76 }
77
78 if(ql_func_cb_handle.handlerPtr != NULL)
79 {
80 ql_func_cb_handle.handlerPtr(QL_NW_IND_DATA_REG_EVENT_FLAG,&(net_data[2]), sizeof(&(net_data[2])), NULL);
81 }
82}
83
84QL_NW_ERROR_CODE ql_nw_init()
85{
86 if(!inited && ql_info_handle == NULL)
87 {
88 ql_info_handle = mbtk_info_handle_get();
89 if(ql_info_handle)
90 {
91 ql_info_handle_num++;
92 inited = TRUE;
93 return QL_NW_SUCCESS;
94 } else {
95 LOGE("mbtk_info_handle_get() fail.");
96 return QL_NW_GENERIC_FAILURE;
97 }
98 } else {
99 if(!inited) {
100 ql_info_handle_num++;
101 inited = TRUE;
102 }
103 return QL_NW_SUCCESS;
104 }
105}
106
107QL_NW_ERROR_CODE ql_nw_release()
108{
109 if(ql_info_handle)
110 {
111 LOGD("ql_info_handle_num = %d", ql_info_handle_num);
112 if(ql_info_handle_num == 1) { // 最后一个引用，可释放。
113 int ret = mbtk_info_handle_free(&ql_info_handle);
114 if(ret) {
115 LOGE("mbtk_info_handle_free() fail.");
116 return QL_NW_GENERIC_FAILURE;
117 }
118 else
119 {
120 ql_info_handle_num = 0;
121 ql_info_handle = NULL;
122 return QL_NW_SUCCESS;
123 }
124 } else {
125 ql_info_handle_num--;
126 return QL_NW_SUCCESS;
127 }
128 }
129 else
130 {
131 LOGE("NW handle not inited.");
132 return QL_NW_GENERIC_FAILURE;
133 }
134}
135
136static uint8 net_pre_change(bool mbtk_2_ql,int net_mode)
137{
138 uint8 mbtk_net_pre = 0xFF;
139
140 /*
141 QL_NW_PREF_NET_TYPE_GSM_WCDMA = 0, //4
142 QL_NW_PREF_NET_TYPE_GSM_ONLY = 1, //0
143 QL_NW_PREF_NET_TYPE_WCDMA = 2, //1
144 QL_NW_PREF_NET_TYPE_GSM_WCDMA_AUTO = 3, //2
145 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA = 9, //12
146 QL_NW_PREF_NET_TYPE_LTE_ONLY = 11, //5
147 QL_NW_PREF_NET_TYPE_LTE_WCDMA = 12, //9
148 QL_NW_PREF_NET_TYPE_LTE_GSM_GSM_PREF = 13, //7
149 QL_NW_PREF_NET_TYPE_LTE_GSM_LTE_PREF = 14, //8
150 QL_NW_PREF_NET_TYPE_LTE_GSM = 15, //6
151 QL_NW_PREF_NET_TYPE_LTE_WCDMA_WCDMA_PREF = 16, //10
152 QL_NW_PREF_NET_TYPE_LTE_WCDMA_LTE_PREF = 17, //11
153 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_GSM_PREF = 19, //13
154 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_WCDMA_PREF = 20, //14
155 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF = 21, //15
156 */
157 /*
158 0 : GSM only
159 1 : UMTS only
160 2 : GSM/UMTS(auto)
161 3 : GSM/UMTS(GSM preferred)
162 4 : GSM/UMTS(UMTS preferred)
163 5 : LTE only
164 6 : GSM/LTE(auto)
165 7 : GSM/LTE(GSM preferred)
166 8 : GSM/LTE(LTE preferred)
167 9 : UMTS/LTE(auto)
168 10 : UMTS/LTE(UMTS preferred)
169 11 : UMTS/LTE(LTE preferred)
170 12 : GSM/UMTS/LTE(auto)
171 13 : GSM/UMTS/LTE(GSM preferred)
172 14 : GSM/UMTS/LTE(UMTS preferred)
173 15 : GSM/UMTS/LTE(LTE preferred)
174 */
175
176 if(mbtk_2_ql) {
177 switch(net_mode)
178 {
179 case MBTK_NET_PREF_GSM_UMTS_UMTS_PREF:
180 mbtk_net_pre = QL_NW_PREF_NET_TYPE_GSM_WCDMA;
181 break;
182 case MBTK_NET_PREF_GSM_ONLY:
183 mbtk_net_pre = QL_NW_PREF_NET_TYPE_GSM_ONLY;
184 break;
185 case MBTK_NET_PREF_UMTS_ONLY:
186 mbtk_net_pre = QL_NW_PREF_NET_TYPE_WCDMA;
187 break;
188 case MBTK_NET_PREF_GSM_UMTS_AUTO:
189 mbtk_net_pre = QL_NW_PREF_NET_TYPE_GSM_WCDMA_AUTO;
190 break;
191 case MBTK_NET_PREF_GSM_UMTS_LTE_AUTO:
192 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA;
193 break;
194 case MBTK_NET_PREF_LTE_ONLY:
195 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_ONLY;
196 break;
197 case MBTK_NET_PREF_UMTS_LTE_AUTO:
198 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_WCDMA;
199 break;
200 case MBTK_NET_PREF_GSM_LTE_GSM_PREF:
201 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_GSM_PREF;
202 break;
203 case MBTK_NET_PREF_GSM_LTE_LTE_PREF:
204 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_LTE_PREF;
205 break;
206 case MBTK_NET_PREF_GSM_LTE_AUTO:
207 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM;
208 break;
209 case MBTK_NET_PREF_UMTS_LTE_UMTS_PREF:
210 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_WCDMA_WCDMA_PREF;
211 break;
212 case MBTK_NET_PREF_UMTS_LTE_LTE_PREF:
213 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_WCDMA_LTE_PREF;
214 break;
215 case MBTK_NET_PREF_GSM_UMTS_LTE_GSM_PREF:
216 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_GSM_PREF;
217 break;
218 case MBTK_NET_PREF_GSM_UMTS_LTE_UMTS_PREF:
219 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_WCDMA_PREF;
220 break;
221 case MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF:
222 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF;
223 break;
224 default:
225 mbtk_net_pre = 0xFF;
226 break;
227 }
228 } else {
229 switch(net_mode)
230 {
231 case QL_NW_PREF_NET_TYPE_GSM_WCDMA:
232 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_UMTS_PREF;
233 break;
234 case QL_NW_PREF_NET_TYPE_GSM_ONLY:
235 mbtk_net_pre = MBTK_NET_PREF_GSM_ONLY;
236 break;
237 case QL_NW_PREF_NET_TYPE_WCDMA:
238 mbtk_net_pre = MBTK_NET_PREF_UMTS_ONLY;
239 break;
240 case QL_NW_PREF_NET_TYPE_GSM_WCDMA_AUTO:
241 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_AUTO;
242 break;
243 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA:
244 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_AUTO;
245 break;
246 case QL_NW_PREF_NET_TYPE_LTE_ONLY:
247 mbtk_net_pre = MBTK_NET_PREF_LTE_ONLY;
248 break;
249 case QL_NW_PREF_NET_TYPE_LTE_WCDMA:
250 mbtk_net_pre = MBTK_NET_PREF_UMTS_LTE_AUTO;
251 break;
252 case QL_NW_PREF_NET_TYPE_LTE_GSM_GSM_PREF:
253 mbtk_net_pre = MBTK_NET_PREF_GSM_LTE_GSM_PREF;
254 break;
255 case QL_NW_PREF_NET_TYPE_LTE_GSM_LTE_PREF:
256 mbtk_net_pre = MBTK_NET_PREF_GSM_LTE_LTE_PREF;
257 break;
258 case QL_NW_PREF_NET_TYPE_LTE_GSM:
259 mbtk_net_pre = MBTK_NET_PREF_GSM_LTE_AUTO;
260 break;
261 case QL_NW_PREF_NET_TYPE_LTE_WCDMA_WCDMA_PREF:
262 mbtk_net_pre = MBTK_NET_PREF_UMTS_LTE_UMTS_PREF;
263 break;
264 case QL_NW_PREF_NET_TYPE_LTE_WCDMA_LTE_PREF:
265 mbtk_net_pre = MBTK_NET_PREF_UMTS_LTE_LTE_PREF;
266 break;
267 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_GSM_PREF:
268 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_GSM_PREF;
269 break;
270 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_WCDMA_PREF:
271 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_UMTS_PREF;
272 break;
273 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF:
274 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF;
275 break;
276 default:
277 mbtk_net_pre = 0xFF;
278 break;
279 }
280 }
281 return mbtk_net_pre;
282}
283
284QL_NW_ERROR_CODE ql_nw_set_config(QL_NW_CONFIG_INFO_T *pt_info)
285{
286 if(ql_info_handle == NULL || pt_info == NULL)
287 {
288 LOGE("ARG error.");
289 return QL_NW_GENERIC_FAILURE;
290 }
291
292 if(pt_info->preferred_nw_mode < QL_NW_PREF_NET_TYPE_GSM_WCDMA || pt_info->preferred_nw_mode > QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF)
293 {
294 LOGE("Unknown preferred_nw_mode(%d) error.", pt_info->preferred_nw_mode);
295 return QL_NW_GENERIC_FAILURE;
296 }
297
298 roaming_pref = pt_info->roaming_pref;
299
300 mbtk_band_info_t band;
301 memset(&band, 0, sizeof(mbtk_band_info_t));
302 band.net_pref = net_pre_change(FALSE, pt_info->preferred_nw_mode);
303 if(band.net_pref == 0xFF)
304 {
305 LOGE("net_pre_change() fail.");
306 return QL_NW_GENERIC_FAILURE;
307 }
308 if(mbtk_current_band_set(ql_info_handle, &band)) {
309 return QL_NW_GENERIC_FAILURE;
310 } else {
311 return QL_NW_SUCCESS;
312 }
313}
314
315QL_NW_ERROR_CODE ql_nw_get_config(QL_NW_CONFIG_INFO_T *pt_info)
316{
317 if(ql_info_handle == NULL || pt_info == NULL)
318 {
319 LOGE("ARG error.");
320 return QL_NW_GENERIC_FAILURE;
321 }
322 pt_info->roaming_pref = roaming_pref;
323 mbtk_band_info_t band;
324 if(mbtk_current_band_get(ql_info_handle, &band)) {
325 return QL_NW_GENERIC_FAILURE;
326 } else {
327 pt_info->preferred_nw_mode = (QL_NW_PREFERRED_NETWORK_TYPE)net_pre_change(TRUE, band.net_pref);
328 return QL_NW_SUCCESS;
329 }
330}
331
332QL_NW_ERROR_CODE ql_nw_get_nitz_time_info(QL_NW_NITZ_TIME_INFO_T *pt_info)
333{
334 if(ql_info_handle == NULL || pt_info == NULL)
335 {
336 LOGE("ARG error.");
337 return QL_NW_GENERIC_FAILURE;
338 }
339 memset(pt_info, 0x0, sizeof(QL_NW_NITZ_TIME_INFO_T));
340 char time_str[100]={0};
341 ///printf("mbtk_net_time_get begin\n");
342 int err = mbtk_net_time_get(ql_info_handle, time_str);
343 if(err) {
344 LOGE("mbtk_net_time_get() fail.");
345 return QL_NW_GENERIC_FAILURE;
346 } else {
347 memset(pt_info->nitz_time,0,32);
348 memcpy(pt_info->nitz_time,time_str,strlen(time_str));
349 if(mbtk_get_abs_time(time_str, &(pt_info->abs_time))) {
350 LOGE("mbtk_get_abs_time() fail.");
351 return QL_NW_GENERIC_FAILURE;
352 }
353
354 pt_info->leap_sec = 0;
355
356 return QL_NW_SUCCESS;
357 }
358}
359
360//--------------------------------------------------------------------------------------
361QL_NW_ERROR_CODE ql_nw_event_register(unsigned int bitmask)
362{
363 /*
364 NW_IND_VOICE_REG_EVENT_IND_FLAG 语音拨号注册事件
365 NW_IND_DATA_REG_EVENT_IND_FLAG (1 << 1) 数据拨号注册事件
366 NW_IND_SIGNAL_STRENGTH_EVENT_IND_FLAG (1 << 2) 信号强度事件
367 NW_IND_NITZ_TIME_UPDATE_EVENT_IND_FLAG (1 << 3) 网络时间更新事件
368 */
369 if(bitmask == QL_NW_IND_VOICE_REG_EVENT_FLAG)
370 {}
371 if(bitmask == QL_NW_IND_DATA_REG_EVENT_FLAG)
372 {}
373 if(bitmask == QL_NW_IND_SIGNAL_STRENGTH_EVENT_FLAG)
374 {}
375 if(bitmask == QL_NW_IND_NITZ_TIME_UPDATE_EVENT_FLAG)
376 {}
377 return QL_NW_SUCCESS;
378}
379//--------------------------------------------------------------------------------------
380
381QL_NW_ERROR_CODE ql_nw_get_operator_name(QL_NW_OPERATOR_INFO_T *pt_info)
382{
383 if(ql_info_handle == NULL || pt_info == NULL)
384 {
385 LOGE("ARG error.");
386 return QL_NW_GENERIC_FAILURE;
387 }
388 char OperatorFN[128];
389 char OperatorSH[128];
390 char MccMnc[128];
391 mbtk_net_info_t net;
392 if(!mbtk_net_sel_mode_get(ql_info_handle, &net) && net.plmn > 0)
393 {
394 // printf("Net : %d, %d, %d\n", net.net_sel_mode, net.net_type, net.plmn);
395 int i = 0;
396 while(i < ARRAY_SIZE(operator_mcc_mnc))
397 {
398 if(operator_mcc_mnc[i].mcc_mnc == net.plmn)
399 break;
400 i++;
401 }
402
403 if(i == ARRAY_SIZE(operator_mcc_mnc)) // No found mcc&mnc
404 {
405 strcpy(OperatorFN, "UNKNOWN");
406 strcpy(OperatorSH, "UNKNOWN");
407 sprintf(MccMnc, "%d", net.plmn);
408 }
409 else
410 {
411 strcpy(OperatorFN, operator_mcc_mnc[i].operator_l);
412 strcpy(OperatorSH, operator_mcc_mnc[i].operator_s);
413 sprintf(MccMnc, "%d", operator_mcc_mnc[i].mcc_mnc);
414 }
415 memset(pt_info->long_eons,0,128);
416 memcpy(pt_info->long_eons,operator_mcc_mnc[i].operator_l,strlen(operator_mcc_mnc[i].operator_l));
417 memset(pt_info->short_eons,0,128);
418 memcpy(pt_info->short_eons,operator_mcc_mnc[i].operator_s,strlen(operator_mcc_mnc[i].operator_s));
419 memset(pt_info->mcc,0,4);
420 memset(pt_info->mnc,0,4);
421 sprintf(pt_info->mcc, "%d", (operator_mcc_mnc[i].mcc_mnc)/100);
422 sprintf(pt_info->mnc, "%d", (operator_mcc_mnc[i].mcc_mnc)%100);
423 //pt_info->act;
424 return QL_NW_SUCCESS;
425 }
426
427 return QL_NW_GENERIC_FAILURE;
428}
429
430QL_NW_ERROR_CODE ql_nw_perform_scan(QL_NW_SCAN_RESULT_LIST_INFO_T *pt_info)
431{
432 if(ql_info_handle == NULL || pt_info == NULL)
433 {
434 LOGE("ARG error.");
435 return -1;
436 }
437 list_node_t* net_list = NULL;
438 int ret = mbtk_available_net_get(ql_info_handle, &net_list);
439 if(ret != 0)
440 {
441 LOGE("mbtk_available_net_get fail.");
442 return QL_NW_GENERIC_FAILURE;
443 }
444 else
445 {
446 memset(pt_info, 0x0, sizeof(QL_NW_SCAN_RESULT_LIST_INFO_T));
447 mbtk_net_info_t* net = NULL;
448 list_first(net_list);
449 int i=0;
450 while ((net = (mbtk_net_info_t*) list_next(net_list)))
451 {
452 //printf("Net : %d, %d, %d, %d\n", net->net_sel_mode, net->net_type, net->net_state, net->plmn);
453 if(net->net_state == 8)
454 pt_info->entry[i].status = QL_NW_ACCESS_TECH_E_UTRAN_CA;
455 else if(net->net_state == 0xff)
456 pt_info->entry[i].status = QL_NW_ACCESS_TECH_NONE;
457 else
458 pt_info->entry[i].status = net->net_state;
459
460 int j = 0;
461 while(j < ARRAY_SIZE(operator_mcc_mnc))
462 {
463 if(operator_mcc_mnc[j].mcc_mnc == net->plmn)
464 break;
465 j++;
466 }
467 if(j == ARRAY_SIZE(operator_mcc_mnc)) // No found mcc&mnc
468 {
469 strcpy(pt_info->entry[i].operator_name.long_eons, "UNKNOWN");
470 strcpy(pt_info->entry[i].operator_name.short_eons, "UNKNOWN");
471 sprintf(pt_info->entry[i].operator_name.mcc, "%d", (net->plmn)/100);
472 sprintf(pt_info->entry[i].operator_name.mnc, "%d", (net->plmn)%100);
473 }
474 else
475 {
476 strcpy(pt_info->entry[i].operator_name.long_eons, operator_mcc_mnc[j].operator_l);
477 strcpy(pt_info->entry[i].operator_name.short_eons, operator_mcc_mnc[j].operator_s);
478 sprintf(pt_info->entry[i].operator_name.mcc, "%d", (net->plmn)/100);
479 sprintf(pt_info->entry[i].operator_name.mnc, "%d", (net->plmn)%100);
480 }
481 pt_info->entry[i].operator_name ;
482 pt_info->entry[i].act = net->net_type;
483 i++;
484 if(i > 40)
485 break;
486 }
487 pt_info->entry_len = i;
488 list_free(net_list);
489 return QL_NW_SUCCESS;
490 }
491}
492
493#if 0
494static int ql_query_registration_state(const char *type, int* regState,int *imsRegState,int * LAC, int *CID,int *netType,int * radioTechFam,int *netRejected)
495{
496 if(ql_info_handle == NULL || str_empty(type) || regState == NULL || imsRegState == NULL
497 || LAC == NULL || CID == NULL || netType == NULL || radioTechFam == NULL || netRejected == NULL)
498 {
499 return -1;
500 }
501 mbtk_net_reg_info_t reg;
502 int err = mbtk_net_reg_get(ql_info_handle, &reg);
503 if(err) {
504 *netRejected = err;
505 return -1;
506 } else {
507 //printf("REG : %d, %d, %d, %04x, %08o\n", reg.state, reg.type, reg.ims_reg, reg.lac, reg.ci);
508 // Voice/Data/IMS
509 if(strcmp("VOICE", type) == 0) {
510 *regState = reg.call_state;
511 } else if(strcmp("DATA", type) == 0) {
512 *regState = reg.data_state;
513 } else if(strcmp("IMS", type) == 0) {
514 *imsRegState = reg.ims_state;
515 } else {
516 return -1;
517 }
518
519 if(reg.call_state != MBTK_NET_REG_STATE_NON || reg.data_state != MBTK_NET_REG_STATE_NON || reg.ims_state != MBTK_NET_REG_STATE_NON) {
520 sprintf(LAC, "%04x", reg.lac);
521 sprintf(CID, "%08o", reg.ci);
522 *netType = reg.type;
523 *radioTechFam = RADIO_TECH_3GPP;
524 }
525 return 0;
526 }
527
528}
529#endif
530
531QL_NW_ERROR_CODE ql_nw_get_reg_status(QL_NW_REG_STATUS_INFO_T *pt_info)
532{
533 if(ql_info_handle == NULL || pt_info == NULL)
534 {
535 LOGE("ARG error.");
536 return QL_NW_GENERIC_FAILURE;
537 }
538 /*VOICE/DATA/IMS*/
539 mbtk_net_reg_info_t reg;
540 int err = mbtk_net_reg_get(ql_info_handle, &reg);
541 if(err) {
542 LOGE("mbtk_net_reg_get fail.");
543 return QL_NW_GENERIC_FAILURE;
544 } else {
545 memset(pt_info, 0x0, sizeof(QL_NW_REG_STATUS_INFO_T));
546 pt_info->data_reg.state = (QL_NW_REG_STATE)reg.data_state;
547 pt_info->data_reg.lac = reg.lac;
548 pt_info->data_reg.cid = reg.ci;
549 pt_info->voice_reg.state = (QL_NW_REG_STATE)reg.call_state;
550 pt_info->voice_reg.lac = reg.lac;
551 pt_info->voice_reg.cid = reg.ci;
552 switch(reg.type)
553 {
554 case MBTK_RADIO_TECH_GSM:
555 case MBTK_RADIO_TECH_GSM_COMPACT:
556 case MBTK_RADIO_TECH_GSM_EGPRS:
557 case MBTK_RADIO_TECH_UTRAN_HSPA:
558 {
559 pt_info->data_reg.rat = QL_NW_RADIO_TECH_GPRS;
560 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_GSM;
561 break;
562 }
563 case MBTK_RADIO_TECH_UTRAN:
564 case MBTK_RADIO_TECH_UTRAN_HSDPA:
565 case MBTK_RADIO_TECH_UTRAN_HSUPA:
566 case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
567 {
568 pt_info->data_reg.rat = QL_NW_RADIO_TECH_UMTS;
569 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_UMTS;
570 break;
571 }
572 case MBTK_RADIO_TECH_E_UTRAN:
573 {
574 pt_info->data_reg.rat = QL_NW_RADIO_TECH_LTE;
575 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_LTE;
576 break;
577 }
578 default:
579 {
580 pt_info->data_reg.rat = QL_NW_RADIO_TECH_UNKNOWN;
581 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_UNKNOWN;
582 break;
583 }
584 }
585 }
586
587 return 0;
588
589#if 0
590 int ret = ql_query_registration_state("VOICE", &(pt_info->voice_reg.state), &imsRegState, &(pt_info->voice_reg.lac), &(pt_info->voice_reg.cid), &netType, &(pt_info->voice_reg.rejectCause), &netRejected);
591 if(ret != 0)
592 err = QL_NW_GENERIC_FAILURE;
593 else
594 err = QL_NW_SUCCESS;
595 ret = ql_query_registration_state("DATA", &(pt_info->data_reg.state), &imsRegState, &(pt_info->data_reg.lac), &(pt_info->data_reg.cid), &netType, &(pt_info->data_reg.rejectCause), &netRejected);
596 if(ret != 0)
597 err = QL_NW_GENERIC_FAILURE;
598 else
599 err = QL_NW_SUCCESS;
600
601 if(err == QL_NW_SUCCESS)
602 {
603 if(netType < 0 || netType > 8)
604 pt_info->data_reg.rat = QL_NW_ACCESS_TECH_NONE;
605 else
606 pt_info->data_reg.rat = netType;
607 }
608 return err;
609#endif
610}
611
612QL_NW_ERROR_CODE ql_nw_set_selection(QL_NW_SELECTION_INFO_T *pt_info)
613{
614 if(ql_info_handle == NULL || pt_info == NULL)
615 {
616 LOGE("ARG error.");
617 return QL_NW_GENERIC_FAILURE;
618 }
619
620 mbtk_net_info_t net;
621 net.net_type = 0xFF;
622 char mccmnc[10];
623 if(pt_info->nw_selection_mode == 0)
624 {
625 net.net_sel_mode = 0;
626 net.plmn = 0;
627 }
628 else if(pt_info->nw_selection_mode == 1 && !str_empty(pt_info->mnc) && !str_empty(pt_info->mcc))
629 {
630 net.net_sel_mode = 1;
631 memset(mccmnc, 0, 10);
632 //memcpy(mccmnc, pt_info->mcc, 3);
633 //memcpy(mccmnc + 3, pt_info->mnc, 3);
634 sprintf(mccmnc,"%s%s",pt_info->mcc,pt_info->mnc);
635 net.plmn = (uint32)atoi(mccmnc);
636 if(pt_info->act < QL_NW_ACCESS_TECH_GSM || pt_info->act > QL_NW_ACCESS_TECH_UTRAN_HSPAP)
637 net.net_type = 0xff;
638 else
639 net.net_type = pt_info->act;
640 }
641 else
642 {
643 LOGE("ARG error.");
644 return QL_NW_GENERIC_FAILURE;
645 }
646 //printf("mccmnc = %s\n",mccmnc);
647 //printf("net.plmn = %d\n",net.plmn);
648 int ret = mbtk_net_sel_mode_set(ql_info_handle, &net);
649 if(ret == 0)
650 {
651 return QL_NW_SUCCESS;
652 }
653 else
654 {
655 printf("mbtk_net_sel_mode_set error: %d\n",ret );
656 return QL_NW_GENERIC_FAILURE;
657 }
658}
659
660QL_NW_ERROR_CODE ql_nw_get_selection(QL_NW_SELECTION_INFO_T *pt_info)
661{
662 if(ql_info_handle == NULL || pt_info == NULL)
663 {
664 LOGE("ARG error.");
665 return QL_NW_GENERIC_FAILURE;
666 }
667 char OperatorFN[128];
668 char OperatorSH[128];
669 char MccMnc[128];
670 mbtk_net_info_t net;
671 if(!mbtk_net_sel_mode_get(ql_info_handle, &net) && net.plmn > 0)
672 {
673 memset(pt_info, 0x0, sizeof(QL_NW_SELECTION_INFO_T));
674 // printf("Net : %d, %d, %d\n", net.net_sel_mode, net.net_type, net.plmn);
675 int i = 0;
676 while(i < ARRAY_SIZE(operator_mcc_mnc))
677 {
678 if(operator_mcc_mnc[i].mcc_mnc == net.plmn)
679 break;
680 i++;
681 }
682 if(i == ARRAY_SIZE(operator_mcc_mnc)) // No found mcc&mnc
683 {
684 strcpy(OperatorFN, "UNKNOWN");
685 strcpy(OperatorSH, "UNKNOWN");
686 sprintf(MccMnc, "%d", net.plmn);
687 }
688 else
689 {
690 strcpy(OperatorFN, operator_mcc_mnc[i].operator_l);
691 strcpy(OperatorSH, operator_mcc_mnc[i].operator_s);
692 sprintf(MccMnc, "%d", operator_mcc_mnc[i].mcc_mnc);
693
694 sprintf(pt_info->mcc,"%d",operator_mcc_mnc[i].mcc_mnc/100);
695 sprintf(pt_info->mnc,"%d",operator_mcc_mnc[i].mcc_mnc%100);
696
697 }
698 pt_info->nw_selection_mode = net.net_sel_mode;
699
700 pt_info->act = net.net_type;
701 return QL_NW_SUCCESS;
702 }
703
704 return QL_NW_GENERIC_FAILURE;
705
706}
707
708QL_NW_ERROR_CODE ql_nw_get_signal_strength(QL_NW_SIGNAL_STRENGTH_INFO_T *pt_info)
709{
710 if(ql_info_handle == NULL || pt_info == NULL)
711 {
712 LOGE("ARG error.");
713 return QL_NW_GENERIC_FAILURE;
714 }
715
716 int ret;
717 mbtk_signal_info_t signal;
718 ret = mbtk_net_signal_get(ql_info_handle, &signal);
719 if(ret != 0) {
720 LOGE("mbtk_net_signal_get fail.");
721 return QL_NW_GENERIC_FAILURE;
722 }
723 else
724 {
liuyangc989a662024-07-10 19:02:23 +0800[diff] [blame]725 int rssi = 0;
726 if(SIGNAL_STRENGTH_INVALID_1 == signal.rssi)
727 {
728 rssi = SIGNAL_STRENGTH_INVALID_1;
729 }
730 else
731 {
732 rssi = 2 * signal.rssi - 113;
733 }
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]734 if(signal.type == MBTK_RADIO_TECH_GSM) //GSM
735 {
736 pt_info->GW_SignalStrength.bitErrorRate = signal.ber;
737 pt_info->GW_SignalStrength.ecio = signal.ecno;
738 pt_info->GW_SignalStrength.rscp = signal.rscp;
liuyangc989a662024-07-10 19:02:23 +0800[diff] [blame]739 pt_info->GW_SignalStrength.rssi = rssi;
740
741 pt_info->LTE_SignalStrength.rsrp = SIGNAL_STRENGTH_INVALID_1;
742 pt_info->LTE_SignalStrength.rsrq = SIGNAL_STRENGTH_INVALID_1;
743 pt_info->LTE_SignalStrength.rssnr = SIGNAL_STRENGTH_INVALID_2;
744 pt_info->LTE_SignalStrength.rssi = SIGNAL_STRENGTH_INVALID_1;
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]745 }
746 else if(signal.type == MBTK_RADIO_TECH_E_UTRAN) //LTE
747 {
liuyangc989a662024-07-10 19:02:23 +0800[diff] [blame]748 pt_info->LTE_SignalStrength.cqi = SIGNAL_STRENGTH_INVALID_1;
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]749 pt_info->LTE_SignalStrength.rsrp = signal.rsrp;
750 pt_info->LTE_SignalStrength.rsrq = signal.rsrq;
751 pt_info->LTE_SignalStrength.rssnr = signal.ecno;
liuyangc989a662024-07-10 19:02:23 +0800[diff] [blame]752 pt_info->LTE_SignalStrength.rssi = rssi;
753
754 pt_info->GW_SignalStrength.bitErrorRate = SIGNAL_STRENGTH_INVALID_1;
755 pt_info->GW_SignalStrength.ecio = SIGNAL_STRENGTH_INVALID_2;
756 pt_info->GW_SignalStrength.rscp = SIGNAL_STRENGTH_INVALID_2;
757 pt_info->GW_SignalStrength.rssi = SIGNAL_STRENGTH_INVALID_1;
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]758 }
759 else
760 {
761 return QL_NW_GENERIC_FAILURE;
762 }
liuyangc989a662024-07-10 19:02:23 +0800[diff] [blame]763 LOGI("ql_GW_SignalStrength: %d , %d, %d, %d", pt_info->GW_SignalStrength.rssi,
764 pt_info->GW_SignalStrength.bitErrorRate, pt_info->GW_SignalStrength.rscp, pt_info->GW_SignalStrength.ecio);
765 LOGI("ql_LTE_SignalStrength: %d , %d, %d, %d", pt_info->LTE_SignalStrength.rssi,
766 pt_info->LTE_SignalStrength.rsrp, pt_info->LTE_SignalStrength.rsrq, pt_info->LTE_SignalStrength.rssnr, pt_info->LTE_SignalStrength.cqi);
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]767 return QL_NW_SUCCESS;
768 }
769}
770
771QL_NW_ERROR_CODE ql_nw_get_cell_info(QL_NW_CELL_INFO_T *pt_info)
772{
773 list_node_t* cell_list = NULL;
774 mbtk_cell_type_enum type;
775 if(ql_info_handle == NULL || pt_info == NULL)
776 {
777 LOGE("ARG error.");
778 return QL_NW_GENERIC_FAILURE;
779 }
780
781 memset(pt_info, 0, sizeof(QL_NW_CELL_INFO_T));
782 int err = mbtk_cell_get(ql_info_handle, &type, &cell_list);
783 if(err || cell_list == NULL) {
784 LOGE("mbtk_cell_get fail.");
785 return QL_NW_GENERIC_FAILURE;
786 } else {
787 list_first(cell_list);
788 mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list);
789 if(cell) { // Current server cell.
790 switch(type)
791 {
792 case MBTK_CELL_TYPE_GSM:
793 {
794 LOGD("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d", cell->value1, cell->value2, cell->value3, cell->value4);
795 pt_info->gsm_info[0].lac = cell->value1;
796 pt_info->gsm_info[0].cid = cell->value2;
797 pt_info->gsm_info[0].arfcn = cell->value3;
798 pt_info->gsm_info[0].bsic = cell->value4;
799 pt_info->gsm_info[0].mcc = cell->value5;
800 pt_info->gsm_info[0].mnc = cell->value6;
801 pt_info->gsm_info[0].flag = 0;
802 pt_info->gsm_info_num++;
803 pt_info->gsm_info_valid = 1;
804 }
805 break;
806 case MBTK_CELL_TYPE_UMTS:
807 {
808 LOGD("UMTS : lac=%d, ci=%d, arfcn=%d", cell->value1, cell->value2, cell->value3);
809 pt_info->umts_info[0].lac = cell->value1;
810 pt_info->umts_info[0].cid = cell->value2;
811 pt_info->umts_info[0].uarfcn = cell->value3;
812 pt_info->umts_info[0].mcc = cell->value4;
813 pt_info->umts_info[0].mnc = cell->value5;
814 pt_info->umts_info[0].psc = cell->value6;
815 pt_info->umts_info[0].flag = 0;
816 pt_info->umts_info_num++;
817 pt_info->umts_info_valid = 1;
818 }
819 break;
820 case MBTK_CELL_TYPE_LTE:
821 {
822 LOGD("LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
823 pt_info->lte_info[0].tac = cell->value1;
824 pt_info->lte_info[0].pci = cell->value2;
825 pt_info->lte_info[0].earfcn = cell->value3;
826 pt_info->lte_info[0].cid = cell->value8;
827 pt_info->lte_info[0].mcc = cell->value6;
828 pt_info->lte_info[0].mnc = cell->value7;
829 pt_info->lte_info[0].flag = 0;
830 pt_info->lte_info_num++;
831 pt_info->lte_info_valid = 1;
832 break;
833 }
834 default:
835 break;
836 }
837 }
838 while ((cell = (mbtk_cell_info_t*) list_next(cell_list)))
839 {
840 switch(type)
841 {
842 case MBTK_CELL_TYPE_GSM:
843 {
844 LOGD("CELL : %d, %d, %d, %d, %d", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
845 pt_info->gsm_info[pt_info->gsm_info_num].lac = cell->value1;
846 pt_info->gsm_info[pt_info->gsm_info_num].cid = cell->value2;
847 pt_info->gsm_info[pt_info->gsm_info_num].arfcn = cell->value3;
848 pt_info->gsm_info[pt_info->gsm_info_num].bsic = cell->value4;
849 pt_info->gsm_info[pt_info->gsm_info_num].flag = 1;
850 pt_info->gsm_info_num++;
851 pt_info->gsm_info_valid = 1;
852 }
853 break;
854 case MBTK_CELL_TYPE_UMTS:
855 {
856 LOGD("CELL : lac=%d, ci=%d, arfcn=%d", cell->value1, cell->value2, cell->value3);
857 pt_info->umts_info[pt_info->umts_info_num].lac = cell->value1;
858 pt_info->umts_info[pt_info->umts_info_num].cid = cell->value2;
859 pt_info->umts_info[pt_info->umts_info_num].uarfcn = cell->value3;
860 pt_info->umts_info[pt_info->umts_info_num].flag = 1;
861 pt_info->umts_info_num++;
862 pt_info->umts_info_valid = 1;
863 }
864 break;
865 case MBTK_CELL_TYPE_LTE:
866 {
867 LOGD("CELL : phyCellId=%d, euArfcn=%d, rsrp=%d, rsrq=%d", cell->value1, cell->value2, cell->value3, cell->value4);
868 pt_info->lte_info[pt_info->lte_info_num].cid = cell->value1;
869 pt_info->lte_info[pt_info->lte_info_num].earfcn = cell->value2;
870 pt_info->lte_info[pt_info->lte_info_num].tac = cell->value3;
871 pt_info->lte_info[pt_info->lte_info_num].pci = cell->value4;
872 pt_info->lte_info[pt_info->lte_info_num].flag = 1;
873 pt_info->lte_info_num++;
874 pt_info->lte_info_valid = 1;
875 }
876 break;
877 default:
878 break;
879 }
880 }
881 list_free(cell_list);
882 }
883
884 LOGD("get_cell_success: %d, %d, %d.",pt_info->gsm_info_valid, pt_info->umts_info_valid, pt_info->lte_info_valid);
885 return QL_NW_SUCCESS;
886}
887
888QL_NW_ERROR_CODE ql_nw_add_event_handler(QL_NW_EventHandlerFunc_t handlerPtr,void* contextPtr)
889{
890 if(ql_info_handle == NULL || handlerPtr == NULL)
891 {
892 LOGE("ARG error.");
893 return QL_NW_GENERIC_FAILURE;
894 }
895 mbtk_net_state_change_cb_reg(ql_info_handle, ql_nw_state_change_cb);
896 ql_func_cb_handle.handlerPtr = handlerPtr;
897 ql_func_cb_handle.contextPtr = contextPtr;
898 return QL_NW_SUCCESS;
899}
900
901QL_NW_ERROR_CODE ql_nw_get_volte_state(VOLTE_STATE *state)
902{
903 int ret;
904 if(ql_info_handle == NULL || state == NULL)
905 {
906 LOGE("ARG error.");
907 return QL_NW_GENERIC_FAILURE;
908 }
909 ret = mbtk_volte_state_get(ql_info_handle, &(state->reg_state));
910 if(ret != 0)
911 return QL_NW_GENERIC_FAILURE;
912 else
913 return QL_NW_SUCCESS;
914}
915
916QL_NW_ERROR_CODE ql_nw_csq_get_signal_strength(QL_NW_CSQ_SIGNAL_STRENGTH_INFO_T *pt_info)
917{
918 int ret;
919 if(ql_info_handle == NULL || pt_info == NULL)
920 {
921 LOGE("ARG error.");
922 return QL_NW_GENERIC_FAILURE;
923 }
924 mbtk_signal_info_t signal;
925 ret = mbtk_net_signal_get(ql_info_handle, &signal);
926 if(ret != 0)
927 return QL_NW_GENERIC_FAILURE;
928 else
929 {
930 pt_info->rssi = (signal.rssi * 2 - 113);
931 pt_info->bitErrorRate = signal.ber;
932 LOGD("pt_info->rssi = %d pt_info->bitErrorRate = %d",pt_info->rssi,pt_info->bitErrorRate);
933 return QL_NW_SUCCESS;
934 }
935}
936
937//*********************************************************************************
938