| #include <stdbool.h>
|
| #include <dlfcn.h>
|
| #include <time.h>
|
| #include <pthread.h>
|
| #include "gsw_nw_interface.h"
|
| #include "gsw_log_interface.h"
|
|
|
| #define SIG_TIMER 5
|
| #define MODEM_TIMER 5
|
| #define SERVING_TIMER 5
|
|
|
|
|
| //mbtk include
|
| #define LYNQ_AIR_PLANE_MODE_OFF 1 //at+cfun = 1
|
| #define LYNQ_AIR_PLANE_MODE_ON 4 // at+cfun = 4
|
| #define LYNQ_AIR_CFUN_MODE_OFF 0 // at+cfun = 0
|
|
|
| #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
| #define FPLMN_STRING_LENGTH 120
|
| #define ENTRY_LENGTH 6
|
| #define FPLMN_ARRAY_SIZE (FPLMN_STRING_LENGTH / 6) + 1
|
|
|
| #define MBTK_ERR_OK 0
|
| #define GSW_IMEI_LENGTH 15+1
|
|
|
| #define INT_32_MAX (0x7FFFFFFF)
|
| #define INVALID_AT_SIGNAL_LEVEL (99)
|
|
|
|
|
| #ifndef FALSE
|
| #define FALSE (0)
|
| #endif
|
|
|
|
|
| #ifndef TRUE
|
| #define TRUE (!FALSE)
|
| #endif
|
|
|
| typedef unsigned int uint32;
|
| typedef unsigned char uint8;
|
| typedef signed char int8;
|
| typedef unsigned short uint16;
|
| typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
|
|
|
| //#define MBTK_READY_UCI "persist.mbtk.sdk.state"
|
| #define SDK_READY_CMD "uci get lynq_uci.sdk_ready"
|
| #define MBTK_READY_STRING_SIZE_MAX (3+1)
|
|
|
|
|
| typedef enum{
|
| MBTK_READY_INIT = -1,
|
| MBTK_READY_SUCCESS,
|
| MBTK_READY_MODEM_FAIL,
|
| MBTK_READY_RESPONSE_FAIL,
|
| MBTK_READY_SOCKET_FAIL,
|
| MBTK_READY_RIL_FAIL
|
| }mbtk_ready_status_type;
|
|
|
| typedef enum
|
| {
|
| MBTK_DEV_MODEM_MIN_FUN, //Modem 最小功能
|
| MBTK_DEV_MODEM_FULL_FUN, //Modem 全功能
|
| MBTK_DEV_MODEM_DISABLE_RECEIVE_RF_CIRCUITS = 3, //Modem 禁用射频接收电路
|
| MBTK_DEV_MODEM_DISABLE_TRANSMIT_AND_RECEIVE_RF_CIRCUITS, //Modem禁用射频发射和接收电路
|
| MBTK_DEV_MODEM_DISABLE_SIM, //Modem 禁用(U)SIM 卡
|
| MBTK_DEV_MODEM_TURN_OFF_FULL_SECONDARY_RECEIVE, //Modem 完全禁用辅助接收
|
| }MBTK_DEV_MODEM_FUNCTION;
|
|
|
| typedef enum
|
| {
|
| MBTK_CELL_TYPE_GSM = 0,
|
| MBTK_CELL_TYPE_UMTS,
|
| MBTK_CELL_TYPE_LTE
|
| } mbtk_cell_type_enum;
|
|
|
| typedef struct
|
| {
|
| MBTK_DEV_MODEM_FUNCTION fun;
|
| int rst;
|
| } mbtk_modem_info_t;
|
|
|
| typedef struct
|
| {
|
| int client_fd;
|
| pthread_t read_thread_id;
|
| int exit_fd[2];
|
| bool is_waitting;
|
| pthread_cond_t cond;
|
| pthread_mutex_t mutex;
|
|
|
| pthread_mutex_t send_mutex;
|
|
|
| // Temp response data.
|
| uint16 info_err;
|
| uint16 data_len;
|
| void *data;
|
|
|
| //mbtk wyq for server_ready_status add start
|
| char server_ready_status;
|
| //mbtk wyq for server_ready_status add end
|
|
|
| mbtk_info_callback_func net_state_cb;
|
| mbtk_info_callback_func call_state_cb;
|
| mbtk_info_callback_func sms_state_cb;
|
| mbtk_info_callback_func radio_state_cb;
|
| mbtk_info_callback_func sim_state_cb;
|
| mbtk_info_callback_func pdp_state_cb;
|
| //add signal by xr
|
| mbtk_info_callback_func signal_state_cb;
|
| } mbtk_info_handle_t;
|
|
|
|
|
|
|
| typedef struct
|
| {
|
| // NR server cell:
|
| // NR cell:
|
| // LTE server cell: tac, PCI, dlEuarfcn, ulEuarfcn, band
|
| // LTE cell: phyCellId,euArfcn,rsrp,rsrq
|
| // WCDMA server cell: lac, ci, arfcn
|
| // WCDMA cell: lac, ci, arfcn
|
| // GSM server cell: lac, ci, arfcn, bsic
|
| // GSM cell:
|
| uint32 value1; //tac
|
| uint32 value2; //pci
|
| uint32 value3; //dlEuarfcn
|
| uint32 value4; //bler
|
| uint32 value5; //band
|
| uint32 value6; //mcc
|
| uint32 value7; //mnc
|
| uint32 value8; //rsrp
|
| uint32 value9; //rsrq
|
| uint32 value10; //cell identiy
|
| uint32 value11; //sinr
|
| uint32 value12; //is tdd
|
| uint32 value13;
|
| uint32 value14;
|
| uint32 value15;
|
| } __attribute__((packed)) mbtk_cell_info_t;
|
|
|
| typedef struct
|
| {
|
| uint8 net_pref; // mbtk_net_pref_enum
|
| uint16 gsm_band; // mbtk_gsm_band_enum
|
| uint16 umts_band; // mbtk_umts_band_enum
|
| uint32 tdlte_band; // mbtk_tdlte_band_enum
|
| uint32 fddlte_band; // mbtk_fddlte_band_enum
|
| uint32 lte_ext_band; // mbtk_lte_ext_band_enum
|
| } __attribute__((packed)) mbtk_band_info_t;
|
|
|
| typedef struct list_arraynode
|
| {
|
| void *data;
|
| struct list_arraynode *next;
|
| } list_arraynode_t;
|
|
|
| typedef struct list_treenode
|
| {
|
| list_arraynode_t *data;
|
| int count;
|
| struct list_treenode *left;
|
| struct list_treenode *right;
|
| } list_treenode_t;
|
|
|
| typedef int (*list_sort_func)(void *data1, void *data2);
|
| typedef void (*list_free_func)(void *data);
|
|
|
| typedef struct list_node
|
| {
|
| uint32 size;
|
| list_sort_func sort_func;
|
| list_free_func free_func;
|
|
|
| uint32 cur_index;
|
| list_arraynode_t *cur_array_data;
|
|
|
| list_arraynode_t array_data;
|
| list_treenode_t tree_data;
|
| } list_node_t;
|
|
|
| /*
|
| 0: GSM
|
| 1: GSM Compact
|
| 2: UTRAN
|
| 3: GSM w/EGPRS
|
| 4: UTRAN w/HSDPA
|
| 5: UTRAN w/HSUPA
|
| 6: UTRAN w/HSDPA and HSUPA
|
| 7: E-UTRAN
|
| 8: UTRAN HSPA+
|
| */
|
| typedef enum {
|
| MBTK_RADIO_TECH_GSM = 0,
|
| MBTK_RADIO_TECH_GSM_COMPACT,
|
| MBTK_RADIO_TECH_UTRAN,
|
| MBTK_RADIO_TECH_GSM_EGPRS,
|
| MBTK_RADIO_TECH_UTRAN_HSDPA,
|
| MBTK_RADIO_TECH_UTRAN_HSUPA,
|
| MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA,
|
| MBTK_RADIO_TECH_E_UTRAN, // LTE
|
| MBTK_RADIO_TECH_UTRAN_HSPA
|
| } mbtk_radio_technology_enum;
|
|
|
| typedef struct
|
| {
|
| /*
|
| 0: automatic
|
| 1: manual
|
| */
|
| uint8 net_sel_mode;
|
| /*
|
| 0: GSM
|
| 1: GSM Compact
|
| 2: UTRAN
|
| 3: GSM w/EGPRS
|
| 4: UTRAN w/HSDPA
|
| 5: UTRAN w/HSUPA
|
| 6: UTRAN w/HSDPA and HSUPA
|
| 7: E-UTRAN
|
| 8: UTRAN HSPA+
|
| 0xFF: Unused
|
| */
|
| uint8 net_type;
|
| //uint8 plmn[10]; // 46000
|
| /*
|
| 0: unknown
|
| 1: available
|
| 2: current
|
| 3: forbidden
|
| */
|
| uint8 net_state;
|
| uint32 plmn;
|
| } __attribute__((packed)) mbtk_net_info_t;
|
|
|
|
|
| typedef enum
|
| {
|
| MBTK_NET_REG_STATE_NON = 0,
|
| MBTK_NET_REG_STATE_HOME,
|
| MBTK_NET_REG_STATE_SEARCHING,
|
| MBTK_NET_REG_STATE_DENIED,
|
| MBTK_NET_REG_STATE_UNKNOWN,
|
| MBTK_NET_REG_STATE_ROAMING,
|
| MBTK_NET_REG_STATE_SMS_ONLY,
|
| MBTK_NET_REG_STATE_ROAMING_SMS,
|
| MBTK_NET_REG_STATE_ATTACHED_EMERGENCY,
|
| MBTK_NET_REG_STATE_CSFB_HOME,
|
| MBTK_NET_REG_STATE_CSFB_ROAMING,
|
| MBTK_NET_REG_STATE_EMERGENCY_ONLY
|
| } mbtk_net_reg_state_enum;
|
|
|
| typedef struct
|
| {
|
| uint8 call_state;// mbtk_net_reg_state_enum
|
| uint8 data_state;// mbtk_net_reg_state_enum
|
| uint8 ims_state;// mbtk_net_reg_state_enum
|
| uint8 type; // mbtk_radio_technology_enum
|
| uint16 lac;
|
| uint32 ci;
|
| } __attribute__((packed)) mbtk_net_reg_info_t;
|
|
|
| typedef struct
|
| {
|
| uint8 type; // mbtk_radio_technology_enum
|
| uint8 rssi; // 0: 113 dBm or less
|
| // 1: 111 dBm
|
| // 2��30: 109��53 dBm
|
| // 31: 51 dBm or greater
|
| // 99: not known or not detectable
|
| uint8 rxlev;// 0:rssi < -110 dBm
|
| // 1: -110 dBm �� rssi < -109 dBm
|
| // 2: -109 dBm �� rssi < -108 dBm
|
| // ......
|
| // 61: -50 dBm �� rssi < -49 dBm
|
| // 62: -49 dBm �� rssi < -48 dBm
|
| // 63: -48 dBm �� rssi
|
| // 99: not known or not detectable
|
| uint8 ber; // 0...7 as RXQUAL values in the table in 3GPP TS 45.008 [20] subclause 8.2.4
|
| // 99 not known or not detectable
|
| uint8 rscp; // 0: rscp < -120 dBm
|
| // 1: -120 dBm �� rscp < -119 dBm
|
| // 2: -119 dBm �� rscp < -118 dBm
|
| // ......
|
| // 94: -27 dBm �� rscp < -26 dBm
|
| // 95: -26 dBm �� rscp < -25 dBm
|
| // 96: - 25 dBm �� rscp
|
| // 255: not known or not detectable
|
| uint8 ecno; // 0: Ec/Io < -24 dB
|
| // 1: -24 dB �� Ec/Io < -23.5 dB
|
| // 2: -23.5 dB �� Ec/Io < -23 dB
|
| // ......
|
| // 47: -1 dB �� Ec/Io < -0.5 dB
|
| // 48: -0.5 dB �� Ec/Io < 0 dB
|
| // 49: 0 dB �� Ec/Io
|
| // 255: not known or not detectable
|
| uint8 rsrq; // 0: rsrq < -19.5 dB
|
| // 1: -19.5 dB �� rsrq < -19 dB
|
| // 2: -19 dB �� rsrq < -18.5 dB
|
| // ......
|
| // 32: -4 dB �� rsrq < -3.5 dB
|
| // 33: -3.5 dB �� rsrq < -3 dB
|
| // 34: -3 dB �� rsrq
|
| // 255: not known or not detectable
|
| uint8 rsrp; // 0: rsrp < -140 dBm
|
| // 1: -140 dBm �� rsrp < -139 dBm
|
| // 2: -139 dBm �� rsrp < -138 dBm
|
| // ......
|
| // 95: -46 dBm �� rsrp < -45 dBm
|
| // 96: -45 dBm �� rsrp < -44 dBm
|
| // 97: -44 dBm �� rsrp
|
| // 255: not known or not detectable
|
| int8 sinr; //-20-35 dbm
|
| } __attribute__((packed)) mbtk_signal_info_t;
|
|
|
| typedef struct{
|
| uint8_t mode;
|
| uint32_t oosPhase[3]; //单位为秒
|
| } mbtk_oos_info;
|
|
|
| typedef struct
|
| {
|
| /* Configuration parameters for MCM network full band network scan when OOS (out of service)*/
|
| int t_min;
|
| int t_step;
|
| int t_max;
|
| }GSW_NW_OOS_CONFIG_INFO_T;
|
|
|
| #define lib_mbtk_path "/lib/libmbtk_lib.so"
|
| mbtk_info_handle_t* nw_info_handle = NULL;
|
|
|
| static GSW_NW_ServingInfoHandlePtr serving_cb=NULL;
|
| static GSW_NW_SigInfoHandlePtr sig_cb=NULL;
|
| static GSW_NW_RejectCauseHandlePtr reject_cb=NULL;
|
| static GSW_NW_ModemStateHandlePtr modem_cb=NULL;
|
| static GSW_NW_AirplaneModeHandlePtr airplane_cb=NULL;
|
|
|
| static void *dlHandle_mbtk;
|
| int nw_init_flag = 0;
|
| int mode = -1;
|
| int fplmn_max_length = 0;
|
|
|
| gsw_nw_plmn_list_t gsw_nw_plmn_list;
|
| char fplmn_array[FPLMN_ARRAY_SIZE][7];
|
| int fplmn_index = 0;
|
|
|
| static mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
|
| static int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle);
|
| int (*mbtk_net_sel_mode_get)(mbtk_info_handle_t* handle, mbtk_net_info_t *net);
|
| int (*mbtk_net_reg_get)(mbtk_info_handle_t* handle, mbtk_net_reg_info_t *reg);
|
| int (*mbtk_cell_get)(mbtk_info_handle_t* handle, mbtk_cell_type_enum *type, list_node_t **cell_list);
|
| int (*mbtk_get_modem_fun)(mbtk_info_handle_t* handle, int* fun);
|
| static int (*mbtk_set_modem_fun)(mbtk_info_handle_t* handle, mbtk_modem_info_t *info);
|
| int (*mbtk_current_band_get)(mbtk_info_handle_t* handle, mbtk_band_info_t *band);
|
| int (*mbtk_current_band_set)(mbtk_info_handle_t* handle, const mbtk_band_info_t *band);
|
| int (*mbtk_net_signal_get)(mbtk_info_handle_t* handle, mbtk_signal_info_t *signal);
|
| int (*mbtk_wakeup_state_set)(mbtk_info_handle_t* handle, uint32 wakeup_state);
|
| int (*mbtk_signal_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
|
| int (*mbtk_net_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
|
| int (*mbtk_fplmn_get)(mbtk_info_handle_t *handle, void *fplmn);
|
| int (*mbtk_fplmn_set)(mbtk_info_handle_t *handle, void *fplmn);
|
| int (*mbtk_radio_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
|
| int (*mbtk_oos_get)(mbtk_info_handle_t* handle, mbtk_oos_info *oos_info);
|
| int (*mbtk_oos_set)(mbtk_info_handle_t* handle, mbtk_oos_info *oos_info);
|
| int (*mbtk_imei_get)(mbtk_info_handle_t* handle, void *imei);
|
| bool (*str_empty)(const void *str);
|
|
|
|
|
| #define GSW_NW "[HAL][GSW_NW]"
|
|
|
| typedef struct
|
| {
|
| char *lynq_operator_l;
|
| char *lynq_operator_s;
|
| uint32 lynq_mcc_mnc;
|
| } lynq_operator_mcc_mnc_t;
|
|
|
| static lynq_operator_mcc_mnc_t lynq_operator_mcc_mnc[] =
|
| {
|
| {"China Mobile","CMCC",46000},
|
| {"China Unicom","CU",46001},
|
| {"China Mobile","CMCC",46002},
|
| {"China Telecom","CT",46003},
|
| {"China Mobile","CMCC",46004},
|
| {"China Telecom","CT",46005},
|
| {"China Unicom","CU",46006},
|
| {"China Mobile","CMCC",46007},
|
| {"China Mobile","CMCC",46008},
|
| {"China Unicom","CU",46009},
|
| {"China Telecom","CT",46011}
|
| };
|
|
|
|
|
| //GSW include
|
| typedef enum prefer_mode
|
| {
|
| GSW_PREFER_MODE_GSW = 1, /**<2G only*/
|
| GSW_PREFER_MODE_WCDMA = 2, /**< 3G only*/
|
| GSW_PREFER_MODE_WCDMA_GSM = 3, /**< 3G/2G*/
|
| GSW_PREFER_MODE_LTE = 4, /**< 4G only*/
|
| GSW_PREFER_MODE_NR5G = 5, /**< 5G only*/
|
| GSW_PREFER_MODE_NR5G_LTE = 8, /**< 5G/4G*/
|
| GSW_PREFER_MODE_LTE_WCDMA_GSM = 9, /**< 4G/3G/2G*/
|
| GSW_PREFER_MODE_NR5G_LTE_WCDMA_GSM = 32, /**< 5G/4G/3G/2G*/
|
| } PREFER_MODE_E;
|
|
|
| #define NW_THEAD_NUM (3)
|
|
|
| static int mbtk_nw_api_import()
|
| {
|
| dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
|
| if (dlHandle_mbtk == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
|
| if (mbtk_info_handle_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_info_handle_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_info_handle_free = (int (*)(mbtk_info_handle_t** handle))dlsym(dlHandle_mbtk, "mbtk_info_handle_free");
|
| if (mbtk_info_handle_free == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_info_handle_free dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_net_sel_mode_get = (int (*)(mbtk_info_handle_t* handle, mbtk_net_info_t *net))dlsym(dlHandle_mbtk, "mbtk_net_sel_mode_get");
|
| if (mbtk_net_sel_mode_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_sel_mode_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_net_reg_get = (int (*)(mbtk_info_handle_t* handle, mbtk_net_reg_info_t *reg))dlsym(dlHandle_mbtk, "mbtk_net_reg_get");
|
| if (mbtk_net_reg_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_reg_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_get_modem_fun = (int (*)(mbtk_info_handle_t* handle, int* fun))dlsym(dlHandle_mbtk, "mbtk_get_modem_fun");
|
| if (mbtk_get_modem_fun == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_get_modem_fun dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_set_modem_fun = (int (*)(mbtk_info_handle_t* handle, mbtk_modem_info_t *info))dlsym(dlHandle_mbtk, "mbtk_set_modem_fun");
|
| if (mbtk_set_modem_fun == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_set_modem_fun dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_current_band_get = (int (*)(mbtk_info_handle_t* handle, mbtk_band_info_t *band))dlsym(dlHandle_mbtk, "mbtk_current_band_get");
|
| if (mbtk_current_band_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_current_band_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_current_band_set = (int (*)(mbtk_info_handle_t* handle, const mbtk_band_info_t *band))dlsym(dlHandle_mbtk, "mbtk_current_band_set");
|
| if (mbtk_current_band_set == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_current_band_set dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_net_signal_get = (int (*)(mbtk_info_handle_t* handle, mbtk_signal_info_t *signal))dlsym(dlHandle_mbtk, "mbtk_net_signal_get");
|
| if (mbtk_net_signal_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_signal_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_wakeup_state_set = (int (*)(mbtk_info_handle_t* handle, uint32 wakeup_state))dlsym(dlHandle_mbtk, "mbtk_wakeup_state_set");
|
| if (mbtk_wakeup_state_set == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_wakeup_state_set dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_cell_get = (int (*)(mbtk_info_handle_t* handle, mbtk_cell_type_enum *type, list_node_t **cell_list))dlsym(dlHandle_mbtk, "mbtk_cell_get");
|
| if (mbtk_cell_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_cell_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_signal_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_signal_state_change_cb_reg");
|
| if (mbtk_signal_state_change_cb_reg == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_signal_state_change_cb_reg dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_net_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_net_state_change_cb_reg");
|
| if (mbtk_net_state_change_cb_reg == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_state_change_cb_reg dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_fplmn_get = (int(*)(mbtk_info_handle_t *handle, void *fplmn))dlsym(dlHandle_mbtk, "mbtk_fplmn_get");
|
| if (mbtk_fplmn_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_fplmn_set = (int(*)(mbtk_info_handle_t *handle, void *fplmn))dlsym(dlHandle_mbtk, "mbtk_fplmn_set");
|
| if (mbtk_fplmn_set == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_radio_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_radio_state_change_cb_reg");
|
| if (mbtk_radio_state_change_cb_reg == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_radio_state_change_cb_reg dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_oos_get = (int (*)(mbtk_info_handle_t* handle, mbtk_oos_info *oos))dlsym(dlHandle_mbtk, "mbtk_oos_get");
|
| if (mbtk_oos_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_oos_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_oos_set = (int (*)(mbtk_info_handle_t* handle, mbtk_oos_info *oos))dlsym(dlHandle_mbtk, "mbtk_oos_set");
|
| if (mbtk_oos_set == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_oos_set dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_imei_get = (int (*)(mbtk_info_handle_t* handle, void *imei))dlsym(dlHandle_mbtk, "mbtk_imei_get");
|
| if (mbtk_imei_get == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_imei_get dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| str_empty = (bool (*)(const void *str))dlsym(dlHandle_mbtk, "str_empty");
|
| if (str_empty == NULL)
|
| {
|
| LOGE(GSW_NW,"str_empty dlsym fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| void list_first(list_node_t *list)
|
| {
|
| if (list) {
|
| list->cur_index = 0;
|
| list->cur_array_data = list->array_data.next;
|
| }
|
| }
|
|
|
| void* list_next(list_node_t *list)
|
| {
|
| if (list) {
|
| list_arraynode_t *node = list->cur_array_data;
|
| if (node) {
|
| LOGE(GSW_NW,"node is not null\n");
|
| list->cur_array_data = list->cur_array_data->next;
|
| list->cur_index++;
|
| return node->data;
|
| } else {
|
| LOGE(GSW_NW,"node is null\n");
|
| return NULL;
|
| }
|
| } else {
|
| LOGE(GSW_NW,"list is null\n");
|
| return NULL;
|
| }
|
| }
|
|
|
| void list_free(list_node_t *list)
|
| {
|
| if (list) {
|
| list_arraynode_t *node = &(list->array_data); // Head node
|
| list_arraynode_t *node_temp = NULL;
|
| while (node->next) {
|
| node_temp = node->next;
|
| node->next = node->next->next;
|
|
|
| if (list->free_func) {
|
| list->free_func(node_temp->data);
|
| } else {
|
| free(node_temp->data);
|
| }
|
| free(node_temp);
|
| }
|
| free(list);
|
| }
|
| }
|
|
|
| #if 0
|
| static int32_t gsm_rssi_convert_to_dBm(uint8 rssi)
|
| {
|
| if(rssi <= 31)
|
| {
|
| return rssi * 2 - 113; //0 map -113
|
| //31 map -51
|
| }
|
| else
|
| {
|
| return INT_32_MAX;
|
| }
|
| }
|
| #endif
|
|
|
| static int32_t rscp_convert_to_minus_dBm(uint8 rscp)
|
| {
|
| if(rscp <= 96)
|
| {
|
| return 121-rscp; // 96 map 25
|
| // 0 map -121, below -120
|
| }
|
| else
|
| {
|
| return INT_32_MAX;
|
| }
|
| }
|
|
|
| static int32_t rsrp_convert_to_minus_dBm(uint8 rsrp)
|
| {
|
| if(rsrp <= 97)
|
| {
|
| return 141-rsrp; // 97 map 44
|
| // 0 map 141 below 140
|
| }
|
| else
|
| {
|
| return INT_32_MAX;
|
| }
|
| }
|
|
|
| static int32_t rsrq_convert_to_minus_dB(uint8 rsrq)
|
| {
|
| if(rsrq <= 34)
|
| {
|
| return (40-rsrq)/2; //=20-rsrq / 2;
|
| // 34 map 3
|
| // 0 map 20
|
| }
|
| else
|
| {
|
| return INT_32_MAX;
|
| }
|
| }
|
|
|
| static int32_t sinr_convert_to_10_times_dB(int8 sinr)
|
| {
|
| if(sinr <=35 && sinr>=-20)
|
| {
|
| return sinr*10; //35 map 350 db
|
| // -20 map -2000 db
|
| }
|
| else
|
| {
|
| return INT_32_MAX;
|
| }
|
| }
|
|
|
| //int ecno; /**< Valid values are positive integers. This value is the actual Ec/Io multiplied
|
| // * by -10. Example: If the actual Ec/Io is -12.5 dB, then this response value
|
| // * will be 125.*/
|
| //uint8 ecno; // 0: Ec/Io < -24 dB
|
| // 1: -24 dB �� Ec/Io < -23.5 dB
|
| // 2: -23.5 dB �� Ec/Io < -23 dB
|
| // ......
|
| // 47: -1 dB �� Ec/Io < -0.5 dB
|
| // 48: -0.5 dB �� Ec/Io < 0 dB
|
| // 49: 0 dB �� Ec/Io
|
| // 255: not known or not detectabl
|
| static int32_t ecno_convert_to_minus_10_times_dB(uint8 ecno)
|
| {
|
| if(ecno <=49)
|
| {
|
| return 245-ecno*5; //49 map 0 db
|
| // 1 map 240 db
|
| // 0 map 245 below 240
|
| }
|
| else
|
| {
|
| return INT_32_MAX;
|
| }
|
| }
|
|
|
|
|
|
|
| /* change realCsq to level */
|
| static int rscpToLevel(int rscp)
|
| {
|
|
|
| if (rscp < -110) {
|
| return 0;
|
| } else if (rscp <= -95) {
|
| return rscp+111; // to 16
|
| } else if (rscp >=-93 && rscp <=-90) {
|
| return rscp+110; // to 20
|
| } else if (rscp >=-89 && rscp <=-59) {
|
| return (rscp+152)/3; // =(rscp+89)/3+21 to 31
|
| } else if (rscp ==- 94) { // Geely requirement, -94 map 16
|
| return 16;
|
| } else if(rscp <= -25) {
|
| return 31;
|
| }
|
| return 99;
|
| }
|
|
|
| static int rsrpToLevel(int rsrp)
|
| {
|
| if (rsrp < -130) {
|
| return 0;
|
| } else if (rsrp <= -118) {
|
| return (rsrp+132)/2; // to 7
|
| } else if (rsrp <=-109) {
|
| return rsrp+125; // to 16
|
| } else if (rsrp <=-103) {
|
| return (rsrp+141)/2; // =(rsrp+109)/2+16 to 19
|
| } else if (rsrp <=- 85) {
|
| return (rsrp+160)/3; // =(rsrp+103)/3+19 to 25
|
| } else if(rsrp <= -55) {
|
| return (rsrp+210)/5; // =(rsrp+85)/5+25 to 31
|
| } else if(rsrp <=-44)
|
| {
|
| return 31;
|
| }
|
| return 99;
|
| }
|
|
|
| //uint8 rssi; // 0: 113 dBm or less
|
| // 1: 111 dBm
|
| // 2��30: 109��53 dBm
|
| // 31: 51 dBm or greater
|
| // 99: not known or not detectable
|
| //uint8 rxlev;// 0:rssi < -110 dBm
|
| // 1: -110 dBm �� rssi < -109 dBm
|
| // 2: -109 dBm �� rssi < -108 dBm
|
| // 60 ......
|
| // 61: -50 dBm �� rssi < -49 dBm
|
| // 62: -49 dBm �� rssi < -48 dBm
|
| // 63: -48 dBm �� rssi
|
| // 99: not known or not detectable
|
|
|
| /* change realCsq to level */
|
| static int rxlevToLevel(uint8 rxlev)
|
| {
|
| if (rxlev <=60) {
|
| return (rxlev+3)/2; // =(rxlev+1)/2+1,
|
| // 0 map 1
|
| // 1,2 map 2
|
| // 59,60 map 31
|
| }
|
| else if(rxlev <=63)
|
| {
|
| return 31;
|
| }
|
| return INVALID_AT_SIGNAL_LEVEL;
|
| }
|
|
|
| static int convert_reg_state(int reg_state_t)
|
| {
|
| LOGD(GSW_NW,"reg_state_t = %d\n",reg_state_t);
|
| int reg_state = 0;
|
|
|
| switch (reg_state_t)
|
| {
|
| case MBTK_NET_REG_STATE_NON:
|
| {
|
| reg_state = GSW_NETWORK_REG_NOT_REGISTERED;
|
| break;
|
| }
|
| case MBTK_NET_REG_STATE_HOME:
|
| {
|
| reg_state = GSW_NETWORK_REG_REGISTERED;
|
| break;
|
| }
|
| case MBTK_NET_REG_STATE_SEARCHING:
|
| {
|
| reg_state = GSW_NETWORK_REG_NOT_REGISTERED_SEARCHING;
|
| break;
|
| }
|
| case MBTK_NET_REG_STATE_DENIED:
|
| {
|
| reg_state = GSW_NETWORK_REG_REGISTRATION_DENIED;
|
| break;
|
| }
|
| case MBTK_NET_REG_STATE_UNKNOWN:
|
| {
|
| reg_state = GSW_NETWORK_REG_REGISTRATION_UNKNOWN;
|
| break;
|
| }
|
| case MBTK_NET_REG_STATE_ROAMING:
|
| {
|
| reg_state = GSW_NETWORK_REG_REGISTRATION_ROAMING;
|
| break;
|
| }
|
| case MBTK_NET_REG_STATE_SMS_ONLY:
|
| case MBTK_NET_REG_STATE_ROAMING_SMS:
|
| case MBTK_NET_REG_STATE_ATTACHED_EMERGENCY:
|
| case MBTK_NET_REG_STATE_CSFB_HOME:
|
| case MBTK_NET_REG_STATE_CSFB_ROAMING:
|
| case MBTK_NET_REG_STATE_EMERGENCY_ONLY:
|
| {
|
| reg_state = GSW_NETWORK_REG_LIMITED_SERVICE;
|
| break;
|
| }
|
| }
|
|
|
| return reg_state;
|
| }
|
|
|
|
|
| static int convert_net_mode(int net_mode)
|
| {
|
| LOGD(GSW_NW,"net_mode = %d\n",net_mode);
|
| switch(net_mode)
|
| {
|
| case MBTK_RADIO_TECH_GSM:
|
| case MBTK_RADIO_TECH_GSM_COMPACT:
|
| case MBTK_RADIO_TECH_GSM_EGPRS:
|
| {
|
| return GSW_NETWORK_RADIO_GSM;
|
| }
|
| case MBTK_RADIO_TECH_UTRAN:
|
| case MBTK_RADIO_TECH_UTRAN_HSDPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSUPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSPA:
|
| {
|
| return GSW_NETWORK_RADIO_UMTS;
|
| }
|
| case MBTK_RADIO_TECH_E_UTRAN:
|
| {
|
| return GSW_NETWORK_RADIO_LTE;
|
| }
|
|
|
| default:
|
| {
|
| return GSW_NETWORK_RADIO_NO_SVC;
|
| }
|
| }
|
|
|
| return GSW_NETWORK_RADIO_NO_SVC;
|
| }
|
|
|
| static int convert_mbtk_net_config(int config)
|
| {
|
| int net_pref = -1;
|
|
|
| switch(config)
|
| {
|
| case GSW_PREFER_MODE_GSW:
|
| {
|
| net_pref = 0;
|
| break;
|
| }
|
|
|
| case GSW_PREFER_MODE_WCDMA:
|
| {
|
| net_pref = 1;
|
| break;
|
| }
|
|
|
| case GSW_PREFER_MODE_WCDMA_GSM:
|
| {
|
| net_pref = 2;
|
| break;
|
| }
|
|
|
| case GSW_PREFER_MODE_LTE:
|
| case GSW_PREFER_MODE_NR5G:
|
| case GSW_PREFER_MODE_NR5G_LTE:
|
| {
|
| net_pref = 5;
|
| break;
|
| }
|
|
|
| case GSW_PREFER_MODE_LTE_WCDMA_GSM:
|
| case GSW_PREFER_MODE_NR5G_LTE_WCDMA_GSM:
|
| {
|
| net_pref = 15;
|
| break;
|
| }
|
| }
|
|
|
| return net_pref;
|
| }
|
|
|
|
|
| static int convert_gsw_net_config(int config)
|
| {
|
| int net_config = -1;
|
| LOGD(GSW_NW,"config = %d\n",config);
|
|
|
| switch (config)
|
| {
|
| case 0:
|
| {
|
| net_config = GSW_PREFER_MODE_GSW;
|
| break;
|
| }
|
|
|
| case 1:
|
| {
|
| net_config = GSW_PREFER_MODE_WCDMA;
|
| break;
|
| }
|
|
|
| case 2:
|
| {
|
| net_config = GSW_PREFER_MODE_WCDMA_GSM;
|
| break;
|
| }
|
|
|
| case 5:
|
| {
|
| net_config = GSW_PREFER_MODE_LTE;
|
| break;
|
| }
|
|
|
| case 15:
|
| {
|
| net_config = GSW_PREFER_MODE_LTE_WCDMA_GSM;
|
| break;
|
| }
|
| }
|
|
|
| return net_config;
|
| }
|
|
|
| //64F010 -> 46001 (64->46,F0->0,10->01)
|
| static void transform_fplmn_str_to_plmn(char *entry)
|
| {
|
| if (strncmp(entry, "FFFFFF", ENTRY_LENGTH) == 0) {
|
| return; //if FFFFFF,means invalid fplmn, do nothing
|
| }
|
|
|
| char temp = entry[0];
|
| entry[0] = entry[1];
|
| entry[1] = temp;
|
|
|
| temp = entry[ENTRY_LENGTH - 2];
|
| entry[ENTRY_LENGTH - 2] = entry[ENTRY_LENGTH - 1];
|
| entry[ENTRY_LENGTH - 1] = temp;
|
|
|
| memmove(entry + 2, entry + 3, ENTRY_LENGTH - 2);
|
|
|
| LOGE(GSW_NW,"after transform_fplmn_str_to_plmn: %s\n", entry);
|
|
|
| //valid fplmn
|
| fplmn_index++;
|
| }
|
|
|
| static void extract_mcc_mnc(char *entry, char *mcc, char *mnc)
|
| {
|
| strncpy(mcc,entry,3);
|
| mcc[3] = '\0';
|
| strncpy(mnc,entry + 3,2);
|
| mnc[2] = '\0';
|
|
|
| LOGE(GSW_NW,"entry = %s, mcc = %s, mnc = %s\n", entry, mcc, mnc);
|
| }
|
|
|
|
|
| static void update_fplmn_list(char *fplmn_str)
|
| {
|
| LOGE(GSW_NW,"fplmn_str = %s\n",fplmn_str);
|
| char temp_fplmn_array[FPLMN_ARRAY_SIZE][7];
|
| memset(fplmn_array, 0, sizeof(fplmn_array));
|
| memset(temp_fplmn_array, 0, sizeof(temp_fplmn_array));
|
| fplmn_index = 0;
|
| int array_length = 0;
|
|
|
| for (int i = 0; i < strlen(fplmn_str); i += 6) {
|
|
|
| int length = (i + 6 < strlen(fplmn_str)) ? 6 : strlen(fplmn_str) - i;
|
| strncpy(temp_fplmn_array[array_length], fplmn_str + i, length);
|
| temp_fplmn_array[array_length][length] = '\0';
|
| array_length++;
|
| if (i + 6 >= strlen(fplmn_str)) {
|
| break;
|
| }
|
| }
|
|
|
| for (int i = 0; i < array_length; i++) {
|
| LOGE(GSW_NW,"array[%d] = %s\n", i, temp_fplmn_array[i]);
|
| transform_fplmn_str_to_plmn(temp_fplmn_array[i]);
|
| strncpy(fplmn_array[i], temp_fplmn_array[i], ENTRY_LENGTH);
|
| LOGE(GSW_NW,"fplmn_array[%d] = %s\n", i, fplmn_array[i]);
|
| }
|
|
|
| }
|
|
|
| static void format_plmn(char *result, char *plmn_entry)
|
| {
|
| strncpy(result, plmn_entry, strlen(plmn_entry));
|
| LOGE(GSW_NW,"result = %s, numStr = %s\n",result, plmn_entry);
|
|
|
| if (strlen(result) >= 2) {
|
| char temp = result[0];
|
| result[0] = result[1];
|
| result[1] = temp;
|
| }
|
|
|
| LOGE(GSW_NW,"1.result = %s\n",result);
|
|
|
| if (strlen(result) >= 3) {
|
| memmove(&result[3], &result[2], strlen(result) - 2 + 1);
|
| result[2] = 'F';
|
| }
|
|
|
| LOGE(GSW_NW,"2.result = %s\n",result);
|
|
|
| if (strlen(result) >= 2) {
|
| char temp = result[strlen(result) - 1];
|
| result[strlen(result) - 1] = result[strlen(result) - 2];
|
| result[strlen(result) - 2] = temp;
|
| }
|
|
|
| LOGE(GSW_NW,"3.result = %s\n",result);
|
| }
|
|
|
|
|
| static void convert_plmn_to_fplmn_str(char *fplmn_str)
|
| {
|
| char temp_fplmn_str[128] = {0};
|
| char temp[20]; // 临时存储单个格式化后的数字
|
| int index = 0;
|
|
|
| for (int i = 0; i < fplmn_index; i++) {
|
| memset(temp, 0x0, sizeof(temp));
|
| format_plmn(temp, fplmn_array[i]);
|
| strcat(temp_fplmn_str, temp);
|
| index += strlen(temp);
|
| }
|
|
|
| while(index < (6 * fplmn_max_length))
|
| {
|
| temp_fplmn_str[index++] = 'F';
|
| }
|
|
|
| // 修剪或截断formattedNumbers，确保它不超过6 * fplmn_max_length个字符
|
| if (index > (6 * fplmn_max_length)) {
|
| temp_fplmn_str[(6 * fplmn_max_length)] = '\0';
|
| }
|
|
|
| LOGE(GSW_NW,"%s\n", temp_fplmn_str);
|
| strncpy(fplmn_str, temp_fplmn_str, strlen(temp_fplmn_str));
|
| LOGE(GSW_NW,"fplmn_str = %s\n", fplmn_str);
|
| }
|
|
|
| static int check_index(char *mcc, char *mnc)
|
| {
|
| int i = 0;
|
|
|
| for(i = 0; i < fplmn_index; i++)
|
| {
|
| if(strncmp(fplmn_array[i], mcc, 3) == 0 && strncmp(fplmn_array[i] + 3, mnc, 2) == 0)
|
| {
|
| LOGE(GSW_NW,"index = %d\n", i);
|
| return i;
|
| }
|
| }
|
|
|
| LOGE(GSW_NW,"not find\n");
|
| return -1;
|
| }
|
|
|
| static void remove_fplmn(int index)
|
| {
|
| int write_index = 0;
|
| for (int i = 0; i < fplmn_index; i++) {
|
| if (i != index) {
|
| strncpy(fplmn_array[write_index++], fplmn_array[i], ENTRY_LENGTH);
|
| }
|
| }
|
| fplmn_index--;
|
| }
|
|
|
| static void convert_mbtk_sig_info_to_gsw_sig_info(const mbtk_signal_info_t* signal, signalStrength_t* sig_strength)
|
| {
|
| LOGD(GSW_NW,"signal->type=%d", signal->type);
|
| memset(sig_strength,0,sizeof (signalStrength_t));
|
| switch(signal->type)
|
| {
|
| case MBTK_RADIO_TECH_E_UTRAN:
|
| {
|
| LOGI(GSW_NW,"rsrp = %d",signal->rsrp);
|
| sig_strength->lte_sig_valid = 1;
|
| sig_strength->rsrp = rsrp_convert_to_minus_dBm(signal->rsrp);
|
| sig_strength->rsrq = rsrq_convert_to_minus_dB(signal->rsrq);
|
| sig_strength->rssnr= sinr_convert_to_10_times_dB(signal->sinr);
|
| break;
|
| }
|
| case MBTK_RADIO_TECH_UTRAN:
|
| case MBTK_RADIO_TECH_UTRAN_HSDPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSUPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSPA:
|
| {
|
| LOGI(GSW_NW,"rscp = %d",signal->rscp);
|
| sig_strength->wcdma_sig_valid = 1;
|
| sig_strength->rscp = rscp_convert_to_minus_dBm(signal->rscp);
|
| sig_strength->ecno = ecno_convert_to_minus_10_times_dB(signal->ecno);
|
| break;
|
| }
|
| case MBTK_RADIO_TECH_GSM:
|
| case MBTK_RADIO_TECH_GSM_COMPACT:
|
| case MBTK_RADIO_TECH_GSM_EGPRS:
|
| {
|
| LOGI(GSW_NW,"g rxlev = %d",signal->rxlev);
|
| sig_strength->gw_sig_valid = 1;
|
| sig_strength->rssi = rxlevToLevel(signal->rxlev);
|
| break;
|
| }
|
| default:
|
| {
|
| LOGE(GSW_NW,"[%s] unknown reg type.[%d]", __func__, signal->type);
|
| }
|
| }
|
|
|
| }
|
|
|
| /*
|
| typedef enum{ |
| MBTK_READY_INIT = -1, |
| MBTK_READY_SUCCESS, |
| MBTK_READY_MODEM_FAIL, |
| MBTK_READY_RESPONSE_FAIL, |
| MBTK_READY_SOCKET_FAIL, |
| MBTK_READY_RIL_FAIL |
| }mbtk_ready_status_type;
|
|
|
| typedef enum gsw_hal_nw_mode_state_type |
| { |
| GSW_MODEM_STATE_UNKNOWN = 0, |
| GSW_MODEM_STATE_ONLINE, |
| GSW_MODEM_STATE_OFFLINE, |
| GSW_SDK_STATE_SERVICE_DOWN, |
| GSW_SDK_STATE_SERVICE_UP,// service down->up 需要routectl 重启 |
| GSW_SDK_STATE_GPS_DOWN, |
| GSW_SDK_STATE_GPS_UP, |
| } gsw_mode_state_e;
|
|
|
| */
|
|
|
|
|
| static void gsw_serving_info_callback_thread()
|
| {
|
| GSW_NW_SERVING_INFO serving_info;
|
| int ret = gsw_get_nwinfo(&serving_info);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"cb gsw_get_nwinfo failed");
|
| return;
|
| }
|
|
|
| if(serving_cb!=NULL)
|
| {
|
| LOGE(GSW_NW,"serving cb called");
|
| serving_cb(serving_info);
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"serving cb is NULL");
|
| }
|
| }
|
|
|
| static void gsw_serving_info_callback(const void* data, int data_len)
|
| {
|
| if (nw_init_flag == 0)
|
| {
|
| printf("%s, nw not init\n",__func__);
|
| return;
|
| }
|
|
|
| pthread_t thread;
|
| int ret=pthread_create(&thread, NULL, (void*)gsw_serving_info_callback_thread, NULL);
|
| if(ret==0)
|
| {
|
| pthread_detach(thread);
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"create thread fail, ret is %d",ret);
|
| }
|
| }
|
|
|
|
|
| /*typedef struct
|
| { |
| 0 mbtk_radio_technology_enum type : 8; // mbtk_radio_technology_enum
|
| 1 uint8 rssi; // 0: 113 dBm or less
|
| // 1: 111 dBm |
| // 2��30: 109��53 dBm |
| // 31: 51 dBm or greater |
| // 99: not known or not detectable |
| 2 uint8 rxlev;// 0:rssi < -110 dBm
|
| // 1: -110 dBm �� rssi < -109 dBm |
| // 2: -109 dBm �� rssi < -108 dBm |
| // ...... |
| // 61: -50 dBm �� rssi < -49 dBm |
| // 62: -49 dBm �� rssi < -48 dBm |
| // 63: -48 dBm �� rssi |
| // 99: not known or not detectable |
| 3 uint8 ber; // 0...7 as RXQUAL values in the table in 3GPP TS 45.008 [20] subclause 8.2.4
|
| // 99 not known or not detectable |
| 4 uint8 rscp; // 0: rscp < -120 dBm
|
| // 1: -120 dBm �� rscp < -119 dBm |
| // 2: -119 dBm �� rscp < -118 dBm |
| // ...... |
| // 94: -27 dBm �� rscp < -26 dBm |
| // 95: -26 dBm �� rscp < -25 dBm |
| // 96: - 25 dBm �� rscp |
| // 255: not known or not detectable |
| 5 uint8 ecno; // 0: Ec/Io < -24 dB
|
| // 1: -24 dB �� Ec/Io < -23.5 dB |
| // 2: -23.5 dB �� Ec/Io < -23 dB |
| // ...... |
| // 47: -1 dB �� Ec/Io < -0.5 dB |
| // 48: -0.5 dB �� Ec/Io < 0 dB |
| // 49: 0 dB �� Ec/Io |
| // 255: not known or not detectable |
| 6 uint8 rsrq; // 0: rsrq < -19.5 dB
|
| // 1: -19.5 dB �� rsrq < -19 dB |
| // 2: -19 dB �� rsrq < -18.5 dB |
| // ...... |
| // 32: -4 dB �� rsrq < -3.5 dB |
| // 33: -3.5 dB �� rsrq < -3 dB |
| // 34: -3 dB �� rsrq |
| // 255: not known or not detectable |
| 7 uint8 rsrp; // 0: rsrp < -140 dBm
|
| // 1: -140 dBm �� rsrp < -139 dBm |
| // 2: -139 dBm �� rsrp < -138 dBm |
| // ...... |
| // 95: -46 dBm �� rsrp < -45 dBm |
| // 96: -45 dBm �� rsrp < -44 dBm |
| // 97: -44 dBm �� rsrp |
| // 255: not known or not detectable |
| 8 uint8 ss_rsrq; // 0: ss_rsrq < -43 dB
|
| // 1: -43 dB <= ss_rsrq < -42.5 dB |
| // 2: -42.5 dB <= ss_rsrq < -42 dB |
| // ...... |
| // 125: 19 dB <= ss_rsrq < 19.5 dB |
| // 126: 19.5 dB <= ss_rsrq < 20 dB |
| // 255: not known or not detectable |
| uint8 ss_rsrp; // 0: ss_rsrp < -156 dBm |
| // 1: -156 dBm <= ss_rsrp < -155 dBm |
| // 2: -155 dBm <= ss_rsrp < -154 dBm |
| // ...... |
| // 125: -32 dBm <= ss_rsrp < -31 dBm |
| // 126: -31 dBm <= ss_rsrp |
| // 255: not known or not detectable |
| uint8 ss_sinr; // 0: ss_sinr < -23 dB |
| // 1: -23 dB ss_sinr < -22.5 dB |
| // 2: -22.5 dB ss_sinr < -22 dB |
| // ...... |
| // 125: 39 dB ss_sinr < 39.5 dBm |
| // 126: 39.5 dB ss_sinr < 40 dB |
| // 127: 40 dB ss_sinr |
| // 255: not known or not detectable |
| } __attribute__((packed)) mbtk_signal_info_t;
|
| */
|
| static void gsw_sig_info_callback(const void* data, int data_len)
|
| {
|
| if (nw_init_flag == 0)
|
| {
|
| printf("%s, nw not init\n",__func__);
|
| return;
|
| }
|
|
|
| if(data && (data_len >= sizeof (mbtk_signal_info_t)))
|
| {
|
| signalStrength_t sig_strength;
|
| convert_mbtk_sig_info_to_gsw_sig_info(( const mbtk_signal_info_t*) data,&sig_strength);
|
|
|
| if(sig_cb != NULL)
|
| {
|
| sig_cb(sig_strength);
|
| }
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"data is NULL or data len %d error",data_len);
|
| }
|
| }
|
|
|
| static void gsw_operating_mode_event_callback(const void* data, int data_len)
|
| {
|
| if (nw_init_flag == 0)
|
| {
|
| printf("%s nw not init\n",__func__);
|
| return;
|
| }
|
|
|
| LOGE(GSW_NW,"gsw_operating_mode_event_callback start\n");
|
|
|
|
|
| if(data && data_len > 0)
|
| {
|
| const uint8 *cfun_state = (const uint8*)data;
|
| LOGE(GSW_NW,"gsw_operating_mode_event_callback,data = %d\n", *cfun_state);
|
| if(airplane_cb != NULL)
|
| {
|
| airplane_cb(*cfun_state);
|
| }
|
| }
|
|
|
| }
|
|
|
|
|
| static void gsw_reject_callback(GSW_NW_RADIO_ACCESS_TECH_E rat, GSW_SERVICE_DOMAIN_E domain, int cause)
|
| {
|
| if (nw_init_flag == 0)
|
| {
|
| printf("%s nw not init\n",__func__);
|
| return;
|
| }
|
|
|
| LOGE(GSW_NW,"gsw_reject_callback start,rat = %d,domain = %d,cause = %d\n",rat,domain,cause);
|
|
|
| if(reject_cb != NULL)
|
| {
|
| GSW_NW_REJ_CAUSE_E rej_cause;
|
| rej_cause.rej_cause = cause;
|
| rej_cause.rej_rat = rat;
|
| rej_cause.rej_domain = domain;
|
|
|
| LOGE(GSW_NW,"reject_cb called\n");
|
| reject_cb(&rej_cause);
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"reject_cb is NULL\n");
|
| }
|
| }
|
|
|
| void gsw_serving_info_timer()
|
| {
|
| if(nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return;
|
| }
|
|
|
| while(nw_init_flag)
|
| {
|
| gsw_serving_info_callback_thread();
|
| sleep(SERVING_TIMER);
|
| }
|
| }
|
|
|
| void gsw_sig_info_timer()
|
| {
|
| if(nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return;
|
| }
|
|
|
| mbtk_signal_info_t signal;
|
| signalStrength_t sig_strength;
|
|
|
| while(nw_init_flag)
|
| {
|
| int ret = mbtk_net_signal_get(nw_info_handle, &signal);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_signal_get fail, ret is %d\n",ret);
|
| memset((void*) &sig_strength,0,sizeof (sig_strength));
|
| }
|
| else
|
| {
|
| convert_mbtk_sig_info_to_gsw_sig_info(&signal,&sig_strength);
|
| }
|
| if(sig_cb != NULL)
|
| {
|
| sig_cb(sig_strength);
|
| }
|
| sleep(SIG_TIMER);
|
| }
|
| }
|
|
|
| int get_sdk_ready()
|
| {
|
| char buffer[MBTK_READY_STRING_SIZE_MAX];
|
| FILE *fp = popen(SDK_READY_CMD, "r");
|
| if(NULL == fp)
|
| {
|
| LOGE(GSW_NW,"popen sdk ready fail");
|
| return -1;
|
| }
|
| memset(buffer,0,sizeof(buffer));
|
| if(fgets(buffer, sizeof(buffer), fp) == NULL)
|
| {
|
| pclose(fp);
|
| LOGE(GSW_NW,"fgets failed:");
|
| return -1;
|
| }
|
| pclose(fp);
|
| LOGE(GSW_NW,"get_sdk_ready:%s",buffer);
|
| return atoi(buffer);
|
| }
|
|
|
| static int g_modem_state = ((int)(GSW_MODEM_STATE_UNKNOWN)) - 1;
|
| static int g_gnss_state = ((int)(GSW_MODEM_STATE_UNKNOWN)) - 1;
|
|
|
| void gsw_modem_state_timer()
|
| {
|
| int modem_state;
|
| int gnss_state;
|
|
|
| while (nw_init_flag)
|
| {
|
| int uci_value = get_sdk_ready();
|
| if (uci_value < 0)
|
| {
|
| modem_state = GSW_MODEM_STATE_UNKNOWN;
|
| gnss_state = GSW_SDK_STATE_GPS_DOWN;
|
| }
|
| else
|
| {
|
| if ((uci_value & 0x0F) == 0)
|
| {
|
| modem_state = GSW_MODEM_STATE_ONLINE;
|
| }
|
| else if (uci_value > 0 && uci_value <= 15)
|
| {
|
| modem_state = GSW_MODEM_STATE_OFFLINE;
|
| }
|
| else
|
| {
|
| modem_state = GSW_MODEM_STATE_UNKNOWN;
|
| }
|
|
|
| if (uci_value & (1 << 4))
|
| {
|
| gnss_state = GSW_SDK_STATE_GPS_DOWN;
|
| }
|
| else
|
| {
|
| gnss_state = GSW_SDK_STATE_GPS_UP;
|
| }
|
| }
|
|
|
| if (modem_cb != NULL)
|
| {
|
|
|
| if (modem_state != g_modem_state)
|
| {
|
| LOGE(GSW_NW, "Modem state changed from %d to %d", g_modem_state, modem_state);
|
| modem_cb(modem_state);
|
| g_modem_state = modem_state;
|
| }
|
|
|
| if (gnss_state != g_gnss_state)
|
| {
|
| LOGE(GSW_NW, "GNSS state changed from %d to %d", g_gnss_state, gnss_state);
|
| modem_cb(gnss_state);
|
| g_gnss_state = gnss_state;
|
| }
|
| }
|
| sleep(MODEM_TIMER);
|
| }
|
| }
|
|
|
|
|
|
|
| /**
|
| * @brief SDK interface to call back serving info
|
| * @param [in] handle_ptr
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_reg_serving_info_callback(GSW_NW_ServingInfoHandlePtr handle_ptr)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| void* cb_func;
|
| if(handle_ptr == NULL)
|
| {
|
| LOGE(GSW_NW,"serving info handle_ptr is NULL\n");
|
| cb_func=NULL;
|
| }
|
| else
|
| {
|
| cb_func=(void*) gsw_serving_info_callback;
|
| }
|
|
|
| int ret = mbtk_net_state_change_cb_reg(nw_info_handle, cb_func);
|
| if (ret != 0)
|
| {
|
| LOGW(GSW_NW,"mbtk_net_state_change_cb_reg fail, ret is %d",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| serving_cb=handle_ptr;
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /**
|
| * @brief SDK interface to call back sig info
|
| * @param [in] handle_ptr
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_reg_sig_info_callback(GSW_NW_SigInfoHandlePtr handle_ptr)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| void* cb_func;
|
| if(handle_ptr == NULL)
|
| {
|
| LOGE(GSW_NW,"serving info handle_ptr is NULL\n");
|
| cb_func=NULL;
|
| }
|
| else
|
| {
|
| cb_func=(void*) gsw_sig_info_callback;
|
| }
|
|
|
| int ret = mbtk_signal_state_change_cb_reg(nw_info_handle, cb_func);
|
|
|
| if (ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_signal_state_change_cb_reg fail, ret is %d", ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| sig_cb = handle_ptr;
|
|
|
| return GSW_HAL_SUCCESS;
|
|
|
| }
|
|
|
|
|
| /**
|
| * @brief SDK interface to call back rej cause
|
| * @param [in] handle_ptr
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_reg_rej_cause_callback(GSW_NW_RejectCauseHandlePtr handle_ptr)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(handle_ptr == NULL)
|
| {
|
| LOGE(GSW_NW,"rej cause handle_ptr is NULL\n");
|
| }
|
|
|
| reject_cb = handle_ptr;
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| static void gsw_un_reg_all()
|
| {
|
| gsw_reg_serving_info_callback(NULL);
|
| gsw_reg_sig_info_callback(NULL);
|
| gsw_reg_operating_mode_callback(NULL);
|
| gsw_reg_set_modem_status_event_callback(NULL);
|
| gsw_reg_rej_cause_callback(NULL);
|
| }
|
|
|
| pthread_t s_tid[NW_THEAD_NUM] = {-1,-1,-1};
|
| void* s_thread_func[NW_THEAD_NUM]={
|
| (void*)gsw_sig_info_timer,
|
| (void*)gsw_modem_state_timer,
|
| (void*)gsw_serving_info_timer
|
| };
|
|
|
| static void gsw_close_all_thread()
|
| {
|
| int i,ret;
|
|
|
|
|
| nw_init_flag=0;
|
|
|
| /* had better not use thread cancel, maybe handle->send_mutex is locked now, cancel will not release this mutex
|
| for(i=0; i<NW_THEAD_NUM; i++)
|
| {
|
| if(s_tid[i]!=-1)
|
| {
|
| ret = pthread_cancel(s_tid[i]);
|
| LOGE(GSW_NW,"pthread %d cancel, ret is %d",i, ret);
|
| }
|
| }
|
| */
|
|
|
| for(i=0;i<NW_THEAD_NUM;i++)
|
| {
|
| if(s_tid[i]!=-1)
|
| {
|
| ret = pthread_join(s_tid[i],NULL);
|
| LOGE(GSW_NW,"pthread %d join, ret is %d",i, ret);
|
| s_tid[i]=-1;
|
| }
|
| }
|
| }
|
|
|
| static int gsw_start_all_thread()
|
| {
|
| int i,ret;
|
| for(i=0; i<NW_THEAD_NUM;i++)
|
| {
|
| ret = pthread_create(&(s_tid[i]), NULL,s_thread_func[i], NULL);
|
| if (ret != 0)
|
| {
|
| LOGE(GSW_NW,"pthread_create fail %d，ret is %d",i,ret);
|
| gsw_close_all_thread();
|
| return GSW_HAL_ERROR_GNSS_NO_THRESHOLDS;
|
| }
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
|
|
| }
|
|
|
|
|
|
|
| /**
|
| * @brief network sdk init
|
| * @param [in] token usr id define by who use
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_nw_sdk_init(int token)
|
| {
|
| if (nw_init_flag == 1 && nw_info_handle != NULL)
|
| {
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| int ret = mbtk_nw_api_import();
|
| if (ret != 0)
|
| {
|
| printf("mbtk_nw_api_import fail");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| nw_info_handle = mbtk_info_handle_get();
|
|
|
| if (nw_info_handle == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_info_handle_get fail");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| char fplmn[256] = {0};
|
| ret = mbtk_fplmn_get(nw_info_handle, fplmn);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_get failed, ret is %d",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| fplmn_max_length = (strlen(fplmn)/6);
|
| LOGE(GSW_NW,"fplmn = %s, fplmn_max_length = %d",fplmn,fplmn_max_length);
|
|
|
| nw_init_flag = 1;
|
| ret=gsw_start_all_thread();
|
|
|
| if(ret != 0)
|
| {
|
| nw_init_flag = 0;
|
| LOGE(GSW_NW,"gsw_start_all_thread failed , ret is %d",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| LOGE(GSW_NW,"gsw nw init suc");
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /**
|
| * @brief network sdk deinit
|
| * @param
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_nw_sdk_deinit(void)
|
| {
|
| int ret = -1;
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| gsw_un_reg_all();// had better un-reg before thread close
|
| gsw_close_all_thread();//in it, nw_init_flag=0 and cb unreg
|
|
|
| ret = mbtk_info_handle_free(&nw_info_handle);
|
| if(ret != GSW_HAL_SUCCESS)
|
| {
|
| LOGE(GSW_NW,"mbtk_info_handle_free fail");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| dlclose(dlHandle_mbtk);
|
| nw_info_handle = NULL;
|
|
|
| LOGE(GSW_NW,"gsw_nw_sdk_deinit suc");
|
|
|
| return GSW_HAL_SUCCESS;
|
|
|
| }
|
|
|
|
|
| /**
|
| * @brief get current network reg info
|
| * @param [out] serving_info struct for network info
|
| * include regstate ps_state opreator name mcc mcn etc
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_nwinfo(GSW_NW_SERVING_INFO *serving_info)
|
| {
|
|
|
| int ret = -1;
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| printf("nw_sdk_deinit not init\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| LOGE(GSW_NW,"mbtk_net_reg_get start \n");
|
| //regstate
|
| mbtk_net_reg_info_t reg;
|
| ret = mbtk_net_reg_get(nw_info_handle, ®);
|
| if(ret)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_reg_get fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| LOGE(GSW_NW,"convert_cs_reg_state\n");
|
| //cs_state
|
| serving_info->reg_state = convert_reg_state(reg.call_state);
|
| LOGE(GSW_NW,"convert_ps_reg_state\n");
|
| //ps_state
|
| serving_info->ps_state = convert_reg_state(reg.data_state);
|
| LOGE(GSW_NW,"convert_rat_mode\n");
|
| //reg_rat
|
| serving_info->reg_rat = convert_net_mode(reg.type);
|
| //srv_domain
|
| if(serving_info->reg_state == GSW_NETWORK_REG_REGISTERED || serving_info->reg_state == GSW_NETWORK_REG_REGISTRATION_ROAMING)
|
| {
|
| if(serving_info->ps_state == GSW_NETWORK_REG_REGISTERED || serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_ROAMING)
|
| {
|
| serving_info->srv_domain = GSW_SRV_DOMAIN_CS_PS;
|
| }
|
|
|
| else
|
| {
|
| serving_info->srv_domain = GSW_SRV_DOMAIN_CS_ONLY;
|
| }
|
| }
|
|
|
| else if (serving_info->ps_state == GSW_NETWORK_REG_REGISTERED || serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_ROAMING)
|
| {
|
| serving_info->srv_domain = GSW_SRV_DOMAIN_PS_ONLY;
|
| }
|
|
|
| else
|
| {
|
| serving_info->srv_domain = GSW_SRV_DOMAIN_NO_SVC;
|
| //if ps and cs is both not registed, reg_rat seted to GSW_NETWORK_RADIO_NO_SVC
|
| serving_info->reg_rat = GSW_NETWORK_RADIO_NO_SVC;
|
| }
|
|
|
| LOGD(GSW_NW,"roaming_ind\n");
|
| //roaming_ind
|
| if(serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_ROAMING)
|
| {
|
| serving_info->roaming_ind = GSW_NETWORK_ROAMING_ON;
|
| }
|
| else
|
| {
|
| serving_info->roaming_ind = GSW_NETWORK_ROAMING_OFF;
|
| }
|
|
|
| LOGD(GSW_NW,"reject\n");
|
| //reject
|
| if(serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_DENIED || serving_info->reg_state == GSW_NETWORK_REG_REGISTRATION_DENIED)
|
| {
|
| LOGD(GSW_NW,"reject_callback\n");
|
| gsw_reject_callback(serving_info->reg_rat,serving_info->srv_domain,99);
|
| }
|
|
|
| LOGD(GSW_NW,"reg_plmn / operator name\n");
|
| //reg_plmn / operator name
|
| mbtk_net_info_t net;
|
| LOGD(GSW_NW,"mbtk_net_sel_mode_get start \n");
|
| ret = mbtk_net_sel_mode_get(nw_info_handle, &net);
|
| LOGD(GSW_NW,"mbtk_net_sel_mode_get end \n");
|
| if(ret == 0 && net.plmn > 0)
|
| {
|
| int i = 0;
|
|
|
| LOGD(GSW_NW,"start to find mcc");
|
| while(i < ARRAY_SIZE(lynq_operator_mcc_mnc))
|
| {
|
| if(lynq_operator_mcc_mnc[i].lynq_mcc_mnc == net.plmn)
|
| {
|
| LOGD(GSW_NW,"find mcc\n");
|
| break;
|
| }
|
| i++;
|
| }
|
|
|
|
|
| if(i == ARRAY_SIZE(lynq_operator_mcc_mnc))
|
| {
|
| LOGD(GSW_NW,"not find mcc");
|
| strcpy(serving_info->operator_name, "unknown");
|
| sprintf(serving_info->reg_plmn, "%u", net.plmn);
|
| }
|
|
|
| else
|
| {
|
| LOGD(GSW_NW,"find mcc\n");
|
| strcpy(serving_info->operator_name, lynq_operator_mcc_mnc[i].lynq_operator_l);
|
| sprintf(serving_info->reg_plmn, "%u", net.plmn);
|
| }
|
|
|
| LOGE(GSW_NW,"operator_name = %s\n", serving_info->operator_name);
|
| LOGE(GSW_NW,"reg_plmn = %s\n", serving_info->reg_plmn);
|
| }
|
|
|
|
|
| LOGD(GSW_NW,"get cell id/tac/lac/sid/nid\n");
|
| //cell id/tac/lac/sid/nid
|
| mbtk_cell_type_enum cell_type;
|
| list_node_t* cell_list = NULL;
|
|
|
| LOGD(GSW_NW,"mbtk_cell_get start\n");
|
| ret = mbtk_cell_get(nw_info_handle, &cell_type, &cell_list);
|
| if(ret != 0 || cell_list == NULL)
|
| {
|
| LOGE(GSW_NW,"mbtk_cell_get fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"mbtk_cell_get end,start to get node\n");
|
| list_first(cell_list);
|
| LOGE(GSW_NW,"list_first end\n");
|
| mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list);
|
| if(cell)
|
| {
|
| LOGE(GSW_NW,"cell is not null,value2 = %u\n",cell->value2);
|
| switch(cell_type)
|
| {
|
| case MBTK_CELL_TYPE_LTE:
|
| {
|
| LOGE(GSW_NW,"is lte\n");
|
| //LOGE(GSW_NW,"LTE : tac=%x, PCI=%x, dlEuarfcn=%x, ulEuarfcn=%x, band=%x\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
|
| LOGE(GSW_NW,"LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
|
| snprintf(serving_info->tac,sizeof(serving_info->tac),"%u",cell->value1);
|
| strcpy(serving_info->lac,"");
|
| snprintf(serving_info->cell_id,sizeof(serving_info->cell_id),"%u",cell->value10);
|
| break;
|
| }
|
|
|
| case MBTK_CELL_TYPE_GSM:
|
| {
|
| LOGE(GSW_NW,"is gsm\n");
|
| LOGE(GSW_NW,"GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell->value1, cell->value2, cell->value3, cell->value4);
|
| sprintf(serving_info->lac,"%u",cell->value1);
|
| memset(serving_info->tac,0,sizeof(serving_info->tac));
|
| sprintf(serving_info->cell_id,"%u",cell->value2);
|
| break;
|
| }
|
| case MBTK_CELL_TYPE_UMTS:
|
| {
|
| LOGE(GSW_NW,"is wcdma\n");
|
| LOGE(GSW_NW,"UMTS : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3);
|
| sprintf(serving_info->lac,"%u",cell->value1);
|
| memset(serving_info->tac,0,sizeof(serving_info->tac));
|
| sprintf(serving_info->cell_id,"%u",cell->value2);
|
| break;
|
| }
|
|
|
| default:
|
| break;
|
| }
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"cell is null\n");
|
| }
|
| }
|
|
|
| //not support now
|
| serving_info->sid = 0;
|
| serving_info->nid = 0;
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /**
|
| * @brief get current network type
|
| * @param [out] netype as GSW_NW_RADIO_ACCESS_TECH_E type
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_netype(int32_t *netype)
|
| {
|
| int ret = -1;
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| //regstate
|
| mbtk_net_reg_info_t reg;
|
| ret = mbtk_net_reg_get(nw_info_handle, ®);
|
| if(ret)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_reg_get fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(reg.data_state == MBTK_NET_REG_STATE_HOME || reg.data_state == MBTK_NET_REG_STATE_ROAMING)
|
| {
|
| *netype = convert_net_mode(reg.type);
|
| }
|
| else
|
| {
|
| *netype = GSW_NETWORK_RADIO_NO_SVC;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /**
|
| * @brief get radio opmode, as open and close airplane mode
|
| * @param [out] op_mode 1 is radio on, 0 is radio off
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_opmode(int *op_mode)
|
| {
|
| int tmp_rf = -1;
|
| int ret = -1;
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| ret = mbtk_get_modem_fun(nw_info_handle, &tmp_rf);
|
| if (ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_get_modem_fun fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| if(tmp_rf == LYNQ_AIR_CFUN_MODE_OFF)
|
| {
|
| *op_mode = GSW_OP_MODE_LPM;
|
| }
|
|
|
| if(tmp_rf == LYNQ_AIR_PLANE_MODE_ON)
|
| {
|
| *op_mode = GSW_OP_MODE_OFFLINE;
|
| }
|
|
|
| if(tmp_rf == LYNQ_AIR_PLANE_MODE_OFF)
|
| {
|
| *op_mode = GSW_OP_MODE_ONLINE;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
|
|
| /**
|
| * @brief set radio opmode, as open and close airplane mode
|
| * @param [in] op_mode 1 is radio on, 0 is radio off
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_set_opmode(int32_t op_mode)
|
| {
|
| mbtk_modem_info_t info;
|
| int rf_mode = -1;
|
| int ret = -1;
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(op_mode == GSW_OP_MODE_LPM)
|
| {
|
| rf_mode = LYNQ_AIR_CFUN_MODE_OFF;
|
| }
|
|
|
| if(op_mode == GSW_OP_MODE_ONLINE)
|
| {
|
| rf_mode = LYNQ_AIR_PLANE_MODE_OFF;
|
| }
|
|
|
| if(op_mode == GSW_OP_MODE_OFFLINE)
|
| {
|
| rf_mode = LYNQ_AIR_PLANE_MODE_ON;
|
| }
|
|
|
| if (rf_mode != LYNQ_AIR_PLANE_MODE_ON && rf_mode != LYNQ_AIR_PLANE_MODE_OFF && rf_mode != LYNQ_AIR_CFUN_MODE_OFF)
|
| {
|
| LOGE(GSW_NW,"Input mode is error!\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| info.fun = rf_mode;
|
| info.rst = 0;
|
| ret = mbtk_set_modem_fun(nw_info_handle, &info);
|
| if (ret != 0)
|
| {
|
| LOGE(GSW_NW,"gsw_set_opmode fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
|
|
| }
|
|
|
|
|
| /**
|
| * @brief get network mode preference of mdm search network scale
|
| * @param [out] mode_pref net_work pref mode:
|
| * enum prefer_mode
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_mode_preference(int32_t *mode_pref)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int ret = -1;
|
| mbtk_band_info_t band;
|
| memset(&band, 0, sizeof(mbtk_band_info_t));
|
|
|
| ret = mbtk_current_band_get(nw_info_handle, &band);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_current_band_get fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| *mode_pref = convert_gsw_net_config(band.net_pref);
|
| LOGE(GSW_NW,"band.net_pref = %d\n", *mode_pref);
|
| if(*mode_pref <= 0)
|
| {
|
| LOGE(GSW_NW,"no support mode\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| return GSW_HAL_SUCCESS;
|
|
|
|
|
| }
|
|
|
| /**
|
| * @brief set network mode preference of mdm search network scale
|
| * @param [in] mode_pref net_work pref mode:
|
| * enum prefer_mode
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_set_mode_preference(int32_t mode_pref)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int ret = -1;
|
|
|
| mbtk_band_info_t band;
|
| memset(&band, 0, sizeof(mbtk_band_info_t));
|
|
|
| band.net_pref = convert_mbtk_net_config(mode_pref);
|
| LOGE(GSW_NW,"band.net_pref = %d\n", band.net_pref);
|
|
|
| if(band.net_pref < 0)
|
| {
|
| LOGE(GSW_NW,"no support mode\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| ret = mbtk_current_band_set(nw_info_handle, &band);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_current_band_set fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /**
|
| * @brief get signal csq value
|
| * @param [out] csq_value csq of signalstrengh 0 - 31, 99 invalid
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_sig_info(int32_t *csq_value)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| mbtk_signal_info_t signal;
|
| int ret = mbtk_net_signal_get(nw_info_handle, &signal);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_net_signal_get fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| LOGD(GSW_NW,"signal.type=%d\n", signal.type);
|
| switch(signal.type)
|
| {
|
|
|
| case MBTK_RADIO_TECH_E_UTRAN:
|
| {
|
| LOGD(GSW_NW,"lte rsrp = %d dbm",signal.rsrp-141);
|
| *csq_value = rsrpToLevel(signal.rsrp-141);
|
| break;
|
| }
|
| case MBTK_RADIO_TECH_UTRAN:
|
| case MBTK_RADIO_TECH_UTRAN_HSDPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSUPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
|
| case MBTK_RADIO_TECH_UTRAN_HSPA:
|
| {
|
| LOGD(GSW_NW,"w rscp = %d dbm",signal.rscp-121);
|
| *csq_value = rscpToLevel(signal.rscp-121);
|
| break;
|
| }
|
| case MBTK_RADIO_TECH_GSM:
|
| case MBTK_RADIO_TECH_GSM_COMPACT:
|
| case MBTK_RADIO_TECH_GSM_EGPRS:
|
| {
|
| LOGD(GSW_NW,"gsm rxlev = %d (0-63)",signal.rxlev);
|
| *csq_value = rxlevToLevel(signal.rxlev);
|
| break;
|
| }
|
| default:
|
| {
|
| LOGE(GSW_NW,"[%s] unknown reg type.[%d]", __func__, signal.type);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| }
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /**
|
| * @brief set nework power mode, for tcam enter standby or exit standby
|
| * @param [in] mode TRUE(1) when enter standby, FALSE(0) after wake up
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
|
|
| int gsw_nw_power_mode = 0;
|
| int gsw_network_set_power_mode(char mode)
|
| {
|
| int ret = -1;
|
| if (nw_init_flag == 0)//nw_info_handle == NULL Don't need
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(mode != 0 && mode != 1)
|
| {
|
| LOGE(GSW_NW,"Input mode is error!\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(mode == 1)
|
| gsw_nw_power_mode = 3;
|
| else
|
| gsw_nw_power_mode = 1;
|
|
|
| LOGE(GSW_NW,"mode is %d\n",gsw_nw_power_mode);
|
| ret = mbtk_wakeup_state_set(nw_info_handle, gsw_nw_power_mode);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_wakeup_state_set fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
|
|
| }
|
|
|
| /**
|
| * @brief convert rsrp rscp rssi to csq value.
|
| * @param [in] netType signal radio tech 2 means 2G 3 mens 3G,4 is 4G,5 is 5G
|
| * @param [in] sigvalue input signal_strength for different nettype
|
| * rsrp for 4G/5G, rscp for 3G, rssi for 2G
|
|
|
| * @retval csq
|
| * @retval other: fail
|
| */
|
| int gsw_sigInfo_to_csq(int32_t netType, int32_t sigValue)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| switch(netType)
|
| {
|
| case 4:
|
| {
|
| return rsrpToLevel(-sigValue);
|
| }
|
| case 3: //WCDMA
|
| {
|
| return rscpToLevel(-sigValue);
|
| }
|
| case 2: //GSM
|
| {
|
| return sigValue;
|
| }
|
|
|
| default:
|
| {
|
| LOGE(GSW_NW,"parameter error\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| }
|
| }
|
|
|
| /*
|
| * @brief get mobile operator name
|
| @param [out] nw_operator_name_infos get the long and short operator name info
|
| @retval 0: success
|
| @retval 0: other: fail
|
| */
|
| int gsw_get_mobile_operator_name(gsw_mobile_operator_name *nw_operator_name_infos)
|
| {
|
| char OperatorFN[128];
|
| char OperatorSH[128];
|
| char temp[12];
|
| mbtk_net_info_t net;
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(!mbtk_net_sel_mode_get(nw_info_handle, &net) && net.plmn > 0)
|
| {
|
| LOGE(GSW_NW,"Net : %d, %d, %d\n", net.net_sel_mode, net.net_type, net.plmn);
|
| int i = 0;
|
| while(i < ARRAY_SIZE(lynq_operator_mcc_mnc))
|
| {
|
| if(lynq_operator_mcc_mnc[i].lynq_mcc_mnc == net.plmn)
|
| break;
|
| i++;
|
| }
|
|
|
| if(i == ARRAY_SIZE(lynq_operator_mcc_mnc)) // No found mcc&mnc
|
| {
|
| strcpy(OperatorFN, "UNKNOWN");
|
| strcpy(OperatorSH, "UNKNOWN");
|
| }
|
| else
|
| {
|
| strcpy(OperatorFN, lynq_operator_mcc_mnc[i].lynq_operator_l);
|
| strcpy(OperatorSH, lynq_operator_mcc_mnc[i].lynq_operator_s);
|
|
|
|
|
| sprintf(temp, "%u", (lynq_operator_mcc_mnc[i].lynq_mcc_mnc)/100);
|
| strncpy(nw_operator_name_infos->mcc, temp, strlen(temp));
|
|
|
|
|
| sprintf(temp, "%u", (lynq_operator_mcc_mnc[i].lynq_mcc_mnc)%100);
|
| strncpy(nw_operator_name_infos->mnc, temp, strlen(temp));
|
| }
|
|
|
| memset(nw_operator_name_infos->long_eons,0,128);
|
| memcpy(nw_operator_name_infos->long_eons,OperatorFN,strlen(OperatorFN));
|
| memset(nw_operator_name_infos->short_eons,0,128);
|
| memcpy(nw_operator_name_infos->short_eons,OperatorSH,strlen(OperatorSH));
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| else
|
| {
|
| LOGE(GSW_NW,"mbtk_net_sel_mode_get fail\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /*
|
| * @brief get current serving cell info
|
| * @param cell_info: [out] struct for current cell info
|
| * include earfcn mcc mnc pci psc tac lac etc.
|
| * @return int: 0 is success, other failed
|
| */
|
| int gsw_get_cell_info(GSW_NW_CELL_INFO *cell_info)
|
| {
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| printf("nw_sdk_deinit not init\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| list_node_t* cell_list = NULL;
|
| mbtk_cell_type_enum type;
|
| int ret = mbtk_cell_get(nw_info_handle, &type, &cell_list);
|
| if(ret || cell_list == NULL) {
|
| LOGE(GSW_NW,"mbtk_cell_get failed : %d\n", ret);
|
| list_free(cell_list);
|
| return GSW_HAL_NORMAL_FAIL;
|
| } else {
|
| memset(cell_info,0,sizeof(GSW_NW_CELL_INFO));
|
| list_first(cell_list);
|
| mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list);
|
| if(cell) { // Current server cell.
|
| switch(type)
|
| {
|
| case 0:
|
| {
|
| LOGD(GSW_NW,"GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell->value1, cell->value2, cell->value3, cell->value4);
|
| char gsm_temp[12];
|
|
|
| cell_info->rat = GSW_NETWORK_RADIO_GSM;
|
|
|
| cell_info->mcc_valid = 1;
|
| snprintf(gsm_temp, sizeof(gsm_temp) ,"%X", cell->value5);
|
| strncpy(cell_info->mcc, gsm_temp, sizeof(cell_info->mcc));
|
|
|
| cell_info->mnc_valid = 1;
|
| snprintf(gsm_temp, sizeof(gsm_temp) ,"%X", cell->value6);
|
| strncpy(cell_info->mnc, gsm_temp, sizeof(cell_info->mnc));
|
|
|
| cell_info->cell_id_valid = 1;
|
| cell_info->cell_id = cell->value2;
|
|
|
| cell_info->lac_valid = 1;
|
| cell_info->lac = cell->value1;
|
|
|
| cell_info->arfcn_valid = 1;
|
| cell_info->arfcn = cell->value3;
|
|
|
| cell_info->rssi=rxlevToLevel(cell->value7);
|
| cell_info->rssi_valid = (cell_info->rssi!=INVALID_AT_SIGNAL_LEVEL);
|
| break;
|
| }
|
|
|
| case 1:
|
| {
|
| LOGD(GSW_NW,"UMTS : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3);
|
| char wcdma_temp[12];
|
|
|
| cell_info->rat = GSW_NETWORK_RADIO_UMTS;
|
|
|
| cell_info->mcc_valid = 1;
|
| snprintf(wcdma_temp, sizeof(wcdma_temp) ,"%X", cell->value4);
|
| strncpy(cell_info->mcc, wcdma_temp, sizeof(cell_info->mcc));
|
|
|
| cell_info->mnc_valid = 1;
|
| snprintf(wcdma_temp, sizeof(wcdma_temp) ,"%X", cell->value5);
|
| strncpy(cell_info->mnc, wcdma_temp, sizeof(cell_info->mnc));
|
|
|
| cell_info->lac_valid = 1;
|
| cell_info->lac = cell->value1;
|
|
|
| cell_info->cell_id_valid = 1;
|
| cell_info->cell_id = cell->value2;
|
|
|
| cell_info->uarfcn_valid = 1;
|
| cell_info->uarfcn = cell->value3;
|
|
|
| cell_info->psc_valid = 1;
|
| cell_info->psc = cell->value6;
|
| break;
|
| }
|
|
|
| case 2:
|
| {
|
| LOGE(GSW_NW,"LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
|
|
|
| char lte_temp[12];
|
| cell_info->rat = GSW_NETWORK_RADIO_LTE;
|
|
|
| cell_info->mcc_valid = 1;
|
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value6);
|
| strncpy(cell_info->mcc, lte_temp, sizeof(cell_info->mcc));
|
|
|
| cell_info->mnc_valid = 1;
|
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value7);
|
| strncpy(cell_info->mnc, lte_temp, sizeof(cell_info->mnc));
|
|
|
| cell_info->tac_valid = 1;
|
| cell_info->tac = cell->value1;
|
|
|
| cell_info->pci_valid = 1;
|
| cell_info->pci = cell->value2;
|
|
|
| cell_info->earfcn_valid = 1;
|
| cell_info->earfcn = cell->value3;
|
|
|
| cell_info->bler_valid = 1;
|
| cell_info->bler = cell->value4;
|
|
|
| cell_info->band_valid = 1;
|
| cell_info->band = cell->value5;
|
|
|
| cell_info->rssnr = sinr_convert_to_10_times_dB(cell->value11);
|
| cell_info->rssnr_valid=(cell_info->rssnr!=INT_32_MAX);
|
|
|
| cell_info->lteMode_valid = 1;
|
| cell_info->lteMode =(!(cell->value12));
|
|
|
|
|
| cell_info->rsrp = rsrp_convert_to_minus_dBm(cell->value8);
|
| cell_info->rsrp_valid = (cell_info->rsrp!=INT_32_MAX);
|
|
|
| cell_info->rsrq = rsrq_convert_to_minus_dB(cell->value9);
|
| cell_info->rsrq_valid = (cell_info->rsrq!=INT_32_MAX);
|
|
|
| cell_info->cell_id_valid = 1;
|
| cell_info->cell_id = cell->value10;
|
|
|
| break;
|
| }
|
|
|
| default:
|
| break;
|
| }
|
| }
|
| int neibor_count = 0;
|
| while ((cell = (mbtk_cell_info_t*) list_next(cell_list)) && neibor_count < 5)
|
| {
|
| switch(type)
|
| {
|
| //GSM
|
| case 0:
|
| {
|
|
|
| }
|
| //WCDMA
|
| case 1:
|
| {
|
| LOGE(GSW_NW,"CELL : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3);
|
|
|
| //cell_info->ext_info[neibor_count]->lac = cell->value1;
|
|
|
| cell_info->ext_info[neibor_count].cell_id_valid = 1;
|
| cell_info->ext_info[neibor_count].cell_id = cell->value2;
|
|
|
| cell_info->ext_info[neibor_count].arfcn_valid = 1;
|
| cell_info->ext_info[neibor_count].arfcn = cell->value3;
|
|
|
| cell_info->ext_info[neibor_count].rat = cell_info->rat = GSW_NETWORK_RADIO_UMTS;
|
|
|
| neibor_count++;
|
|
|
| }
|
| //LTE
|
| case 2:
|
| {
|
| LOGE(GSW_NW,"CELL : phyCellId=%d, euArfcn=%d, rsrp=%d, rsrq=%d\n", cell->value1, cell->value2, cell->value3, cell->value4);
|
| char lte_temp[12] = {0};
|
| cell_info->ext_info[neibor_count].rat = GSW_NETWORK_RADIO_LTE;
|
|
|
|
|
| cell_info->ext_info[neibor_count].pci = cell->value1;
|
| cell_info->ext_info[neibor_count].pci_valid = 1;
|
|
|
| cell_info->ext_info[neibor_count].arfcn = cell->value2;
|
| cell_info->ext_info[neibor_count].arfcn_valid = 1;
|
|
|
| cell_info->ext_info[neibor_count].rsrp = rsrp_convert_to_minus_dBm(cell->value3);
|
| cell_info->ext_info[neibor_count].rsrp_valid = (cell_info->ext_info[neibor_count].rsrp!=INT_32_MAX);
|
|
|
| cell_info->ext_info[neibor_count].rsrq = rsrq_convert_to_minus_dB(cell->value4);
|
| cell_info->ext_info[neibor_count].rsrq_valid = (cell_info->ext_info[neibor_count].rsrq!=INT_32_MAX);
|
|
|
| if(cell->value7!=INT_32_MAX)
|
| {
|
| cell_info->ext_info[neibor_count].cell_id = cell->value5;
|
| cell_info->ext_info[neibor_count].cell_id_valid = 1;
|
|
|
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value6);
|
| strncpy(cell_info->ext_info[neibor_count].mcc, lte_temp, sizeof(cell_info->ext_info[neibor_count].mcc));
|
|
|
|
|
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value7);
|
| strncpy(cell_info->ext_info[neibor_count].mnc, lte_temp, sizeof(cell_info->ext_info[neibor_count].mnc));
|
|
|
|
|
| //value 8 is tac
|
|
|
| cell_info->ext_info[neibor_count].band = cell->value9;
|
| cell_info->ext_info[neibor_count].band_valid = 1;
|
| }
|
|
|
| neibor_count++;
|
| }
|
|
|
| default:
|
| break;
|
| }
|
| }
|
| cell_info->ext_info_len=neibor_count;
|
| }
|
| list_free(cell_list);
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /*
|
| * @brief set modem status event callback
|
| @param [in] handle_ptr callback function address
|
| @retval 0: success
|
| @retval 0: other: fail
|
| */
|
| int gsw_reg_set_modem_status_event_callback(GSW_NW_ModemStateHandlePtr handle_ptr)
|
| {
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(handle_ptr == NULL)
|
| {
|
| LOGE(GSW_NW,"reg modem state cb, handle_ptr is NULL\n");
|
| }
|
|
|
| modem_cb = handle_ptr;
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /*
|
| * @brief get PLMNs from the FPLMN list
|
| * @param [inout] plmn_list:
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_forbidden_networks(gsw_nw_plmn_list_t *plmn_list)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int ret = -1;
|
| char fplmn[256] = {0};
|
| LOGE(GSW_NW,"mbtk_fplmn_get enter\n");
|
| ret = mbtk_fplmn_get(nw_info_handle, fplmn);
|
| LOGE(GSW_NW,"mbtk_fplmn_get exit\n");
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_get failed : %d\n",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| update_fplmn_list(fplmn);
|
| for(int i = 0; i < fplmn_index; i++)
|
| {
|
| if(strcmp(fplmn_array[i],"FFFFFF") == 0)
|
| {
|
| continue;
|
| }
|
| extract_mcc_mnc(fplmn_array[i], plmn_list->plmn_list[plmn_list->plmn_list_len].mcc, plmn_list->plmn_list[plmn_list->plmn_list_len].mnc);
|
| LOGE(GSW_NW,"mcc = %s, mnc = %s\n", plmn_list->plmn_list[plmn_list->plmn_list_len].mcc, plmn_list->plmn_list[plmn_list->plmn_list_len].mnc);
|
| plmn_list->plmn_list_len++;
|
| }
|
|
|
| LOGE(GSW_NW,"fplmn = %s\n", fplmn);
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /*
|
| * @brief add PLMNs from the plmn_list to the FPLMN list
|
| * @param [in] plmn_list:
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_add_forbidden_networks(gsw_nw_plmn_list_t *plmn_list)
|
| {
|
|
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(plmn_list->plmn_list_len >= fplmn_max_length)
|
| {
|
| LOGE(GSW_NW,"can't save all the plmn\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int i = 0;
|
| int index = -1;
|
|
|
| for(i = 0; i < plmn_list->plmn_list_len; i++)
|
| {
|
| index = check_index(plmn_list->plmn_list[i].mcc, plmn_list->plmn_list[i].mnc);
|
|
|
| if(index == -1)
|
| {
|
| LOGE(GSW_NW,"no this PLMN, add it\n");
|
| if((fplmn_index + plmn_list->plmn_list_len) > fplmn_max_length)
|
| {
|
| LOGE(GSW_NW,"can't save all the plmn\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| else
|
| {
|
| memcpy(fplmn_array[fplmn_index], plmn_list->plmn_list[i].mcc, 3);
|
| memcpy(fplmn_array[fplmn_index] + 3, plmn_list->plmn_list[i].mnc, 2);
|
| fplmn_array[fplmn_index][5] = '\0';
|
| LOGE(GSW_NW,"fplmn_array[%d] = %s\n", fplmn_index, fplmn_array[fplmn_index]);
|
| fplmn_index++;
|
| }
|
| }
|
|
|
| else
|
| {
|
| LOGE(GSW_NW,"already have this PLMN, don't add it\n");
|
| }
|
| }
|
|
|
| char fplmn_str[256] = {0};
|
| convert_plmn_to_fplmn_str(fplmn_str);
|
|
|
| LOGE(GSW_NW,"fplmn_str = %s\n", fplmn_str);
|
|
|
| int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_set failed : %d\n",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| LOGE(GSW_NW,"gsw_add_forbidden_networks exit\n");
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /*
|
| * @brief Remove PLMNs from the plmn_list from the FPLMN list
|
| * @param [in] plmn_list:
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_remove_forbidden_networks(gsw_nw_plmn_list_t *plmn_list)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| printf("nw sdk has not init\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int i = 0;
|
| int index = -1;
|
|
|
| for(i = 0; i < plmn_list->plmn_list_len; i++)
|
| {
|
| index = check_index(plmn_list->plmn_list[i].mcc, plmn_list->plmn_list[i].mnc);
|
| if(index != -1)
|
| {
|
| remove_fplmn(index);
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"no this PLMN, can't remove it\n");
|
| }
|
| }
|
|
|
| for(i = 0; i < fplmn_index; i++)
|
| {
|
| LOGE(GSW_NW,"fplmn_array[%d] = %s\n", i, fplmn_array[i]);
|
| }
|
|
|
| char fplmn_str[256] = {0};
|
| convert_plmn_to_fplmn_str(fplmn_str);
|
| LOGE(GSW_NW,"fplmn_str = %s\n", fplmn_str);
|
|
|
| int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_set failed : %d\n",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| LOGE(GSW_NW,"gsw_remove_forbidden_networks exit\n");
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /*
|
| * @brief clear FPLMN list
|
| * @param
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_clear_forbidden_networks(void)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| char fplmn_str[FPLMN_STRING_LENGTH+1];
|
| memset(fplmn_str, 'F', (6 * fplmn_max_length));
|
| fplmn_str[(6 * fplmn_max_length)] = '\0';
|
|
|
| LOGE(GSW_NW,"%s\n", fplmn_str);
|
| int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_fplmn_set failed : %d\n",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /*
|
| * @brief get oos config
|
| * @param [in] oos_config
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_oos_config_get(GSW_NW_OOS_CONFIG_INFO_T *pt_info)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(pt_info == NULL)
|
| {
|
| LOGE(GSW_NW,"pt_info is null\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int ret = -1;
|
|
|
| mbtk_oos_info oos_info;
|
| memset(&oos_info, 0x00, sizeof(mbtk_oos_info));
|
|
|
| ret = mbtk_oos_get(nw_info_handle, &oos_info);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_oos_get failed : %d\n",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(oos_info.mode == 0)
|
| {
|
| pt_info->t_min = 0;
|
| pt_info->t_step = 0;
|
| pt_info->t_max = 0;
|
| }
|
|
|
| else
|
| {
|
| pt_info->t_min = (int)oos_info.oosPhase[0];
|
| pt_info->t_step = (int)oos_info.oosPhase[1];
|
| pt_info->t_max = (int)oos_info.oosPhase[2];
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
|
|
| /*
|
| * @brief set oos config
|
| * @param [in] oos_config
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_oos_config_set(GSW_NW_OOS_CONFIG_INFO_T *pt_info)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(pt_info == NULL)
|
| {
|
| LOGE(GSW_NW,"pt_info is null\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int ret = -1;
|
| mbtk_oos_info oos_info;
|
| memset(&oos_info, 0x00, sizeof(mbtk_oos_info));
|
|
|
| if (pt_info->t_min < 0 || pt_info->t_step < 0 || pt_info->t_max < 0)
|
| {
|
| LOGE(GSW_NW,"gsw_oos_config_set set time < 0 ");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| else if ((pt_info->t_min > 0 && pt_info->t_min <= 255) && pt_info->t_step == 0 && pt_info->t_max == 0)
|
| {
|
| oos_info.mode = 1;
|
| oos_info.oosPhase[0] = pt_info->t_min;
|
| }
|
| else if ((pt_info->t_min > 0 && pt_info->t_min <= 255) && (pt_info->t_step > 0 && pt_info->t_step <= 255) && pt_info->t_max == 0)
|
| {
|
| oos_info.mode = 1;
|
| oos_info.oosPhase[0] = pt_info->t_min;
|
| oos_info.oosPhase[1] = pt_info->t_step;
|
| }
|
| else if ((pt_info->t_min > 0 && pt_info->t_min <= 255) && (pt_info->t_step > 0 && pt_info->t_step <= 255) && (pt_info->t_max > 0 && pt_info->t_max <= 255))
|
| {
|
| oos_info.mode = 1;
|
| oos_info.oosPhase[0] = pt_info->t_min;
|
| oos_info.oosPhase[1] = pt_info->t_step;
|
| oos_info.oosPhase[2] = pt_info->t_max;
|
| }
|
| else if (pt_info->t_min == 0 && pt_info->t_step == 0 && pt_info->t_max == 0)
|
| {
|
| oos_info.mode = 0;
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"gsw_oos_config_set set Format err");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| ret = mbtk_oos_set(nw_info_handle, &oos_info);
|
| if(ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_oos_set failed : %d\n",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /**
|
| * @brief get imei function
|
| * @param [in] len imei length,max is 20
|
| * @param [out] imei return imei from this func
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_get_imei(int len, char *imei)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| printf("nw sdk has been deinit\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| if(imei == NULL)
|
| {
|
| LOGE(GSW_NW,"imei is NULL.");
|
| return GSW_HAL_ARG_INVALID;
|
| }
|
|
|
| if(len < GSW_IMEI_LENGTH)
|
| {
|
| LOGE(GSW_NW,"imei len is too short,len = %d\n", len);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| int ret = mbtk_imei_get(nw_info_handle, (void *)imei);
|
| if(ret != MBTK_ERR_OK)
|
| {
|
| LOGE(GSW_NW,"[gsw_nw] mbtk_imei_get fail [err = %d].", ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| /**
|
| * @brief reset modem stack only, notice: after use this method, all ril sdk
|
| * need restart by app, means network, sim, sms, data need deinit then init!
|
| * @param
|
| * @retval 0: success
|
| * @retval other: fail
|
| */
|
| int gsw_reset_modem(void)
|
| {
|
| int ret = -1;
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| printf("nw sdk has been deinit\n");
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| mbtk_modem_info_t info;
|
| info.fun = MBTK_DEV_MODEM_MIN_FUN;
|
| info.rst = 0;
|
|
|
| ret = mbtk_set_modem_fun(nw_info_handle, &info);
|
| if(ret)
|
| {
|
| LOGE(GSW_NW,"[gsw_nw] mbtk_set_modem_fun 0 fail [err = %d].", ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| sleep(1);
|
|
|
| info.fun = MBTK_DEV_MODEM_FULL_FUN;
|
| ret = mbtk_set_modem_fun(nw_info_handle, &info);
|
| if(ret)
|
| {
|
| LOGE(GSW_NW,"[gsw_nw] mbtk_set_modem_fun 1 fail [err = %d].", ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| int gsw_reg_operating_mode_callback(GSW_NW_AirplaneModeHandlePtr handle_ptr)
|
| {
|
| if (nw_init_flag == 0 || nw_info_handle == NULL)
|
| {
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| void* cb_func;
|
| if(handle_ptr == NULL)
|
| {
|
| LOGE(GSW_NW,"reg airplane mode cb is NULL");
|
| cb_func=NULL;
|
| }
|
| else
|
| {
|
| cb_func=(void*) gsw_operating_mode_event_callback;
|
| }
|
|
|
| int ret = mbtk_radio_state_change_cb_reg(nw_info_handle, cb_func);
|
|
|
| if (ret != 0)
|
| {
|
| LOGE(GSW_NW,"mbtk_radio_state_change_cb_reg fail, ret is %d",ret);
|
| return GSW_HAL_NORMAL_FAIL;
|
| }
|
|
|
| airplane_cb = handle_ptr;
|
|
|
| if(airplane_cb !=NULL)
|
| {
|
| int opmode;
|
| ret = gsw_get_opmode(&opmode);
|
| if(ret == 0)
|
| {
|
| airplane_cb(opmode);
|
| }
|
| else
|
| {
|
| LOGE(GSW_NW,"gsw_get_opmode fail, ret is%d", ret);
|
| }
|
| }
|
|
|
| return GSW_HAL_SUCCESS;
|
| }
|
|
|
| int gsw_get_apn_reserved_id(const char *apn)
|
| {
|
| return 0;
|
| }
|
|
|
| int gsw_set_apn_reserved_id(int reserved_id, const char *apn)
|
| {
|
| return 0;
|
| }
|
|
|
| int gsw_data_call_clear_session(int linkid, Link_Info_s *LinkInf)
|
| {
|
| return 0;
|
| }
|
|
|
| void *gsw_onUnsolicited(void *arg)
|
| {
|
| return 0;
|
| }
|
|
|
| int gsw_sdk_init(void)
|
| {
|
| return 0;
|
| }
|
|
|
| int gsw_get_modem_state_exp(void)
|
| {
|
| return 0;
|
| }
|