Fix mbtk from v1265 GSW
Change-Id: I5d8d395616f284bc74c8b9448cfa347164b5a668
diff --git a/mbtk/libgsw_lib/Makefile b/mbtk/libgsw_lib/Makefile
new file mode 100755
index 0000000..edeb244
--- /dev/null
+++ b/mbtk/libgsw_lib/Makefile
@@ -0,0 +1,55 @@
+BUILD_ROOT = $(shell pwd)/..
+include $(BUILD_ROOT)/Make.defines
+INSTALL_DIR := $(BUILD_ROOT)/../mbtk/rootfs/lib
+
+LOCAL_PATH=$(BUILD_ROOT)/libgsw_lib
+
+INC_DIR += \
+ -I$(LOCAL_PATH)
+
+LIB_DIR +=
+
+LIBS += -lmbtk_lib -llog -ldl
+
+CFLAGS += -shared -Wl,-shared,-Bsymbolic
+
+DEFINE +=
+
+MY_FILES_PATH:=$(LOCAL_PATH)
+#ifeq ($(CONFIG_MBTK_QL_SUPPORT),y)
+#MY_FILES_PATH += $(LOCAL_PATH)/ql
+#endif
+
+#ifeq ($(CONFIG_MBTK_PLATFORM),linux)
+#MY_FILES_PATH += $(LOCAL_PATH)/platform/linux
+#endif
+
+MY_FILES_SUFFIX:=%.c %.cpp
+My_All_Files := $(foreach src_path,$(MY_FILES_PATH), $(shell find "$(src_path)" -type f))
+MY_SRC_LIST := $(filter $(MY_FILES_SUFFIX),$(My_All_Files))
+MY_SRC_LIST := $(MY_SRC_LIST:$(LOCAL_PATH)/%=%)
+LOCAL_SRC_FILES += $(MY_SRC_LIST)
+$(info LOCAL_SRC_FILES = $(LOCAL_SRC_FILES))
+OBJS = $(patsubst %.c, %.o, $(patsubst %.cpp, %.o, $(LOCAL_SRC_FILES)))
+$(info OBJS = $(OBJS))
+
+dtarget := $(OUT_DIR)/lib/libgsw_lib.so
+
+all: $(dtarget) install
+
+$(dtarget): $(OBJS)
+ $(CC) $(CFLAGS) $(LIB_DIR) $(LIBS) $(OBJS) -o $@
+
+install:
+ cp $(dtarget) $(INSTALL_DIR)
+ @echo "Installed $(dtarget) to $(INSTALL_DIR)"
+
+%.o:%.c
+ $(CC) $(CFLAGS) $(INC_DIR) $(DEFINE) -c $< -o $@
+
+%.o:%.cpp
+ $(CC) $(CFLAGS) $(INC_DIR) $(DEFINE) -c $< -o $@
+
+clean:
+ rm -f $(OBJS) $(dtarget)
+
diff --git a/mbtk/libgsw_lib/gsw_at.c b/mbtk/libgsw_lib/gsw_at.c
new file mode 100755
index 0000000..fa34eda
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_at.c
@@ -0,0 +1,342 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdint.h>
+#include <dlfcn.h>
+#include <stdbool.h>
+#include "gsw_at.h"
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+#define GSW_HAL_SUCCESS 0
+#define GSW_HAL_FAIL -1 //表示失败(通用性)
+#define GSW_HAL_MEM_INVAILD -2 //表示入参地址为NULL
+
+#define OUT_MAX_SIZE 1024
+#define LINE __LINE__
+#define FUNC __FUNCTION__
+#define AT_EXTERSION_SOCKET_NAME "/tmp/atcmdext"
+#define SOCKET_ZERO 0
+#define SOCKET_SUCC 1
+#define SOCKET_FAIL -1
+
+typedef void (*mbtk_log)(int level, const char *format,...);
+typedef enum
+{
+ A_SUCCESS = 0,
+ A_ERROR = -1
+}LYNQ_AT_E;
+
+static mbtk_log fun_ptr_log = NULL;
+void *dlHandle_at = NULL;
+char *lynqLib_at = "/lib/libmbtk_lib.so";
+char *output = NULL;
+int sockfd = 0;
+int result = A_SUCCESS;
+char buffer_at[OUT_MAX_SIZE] = {0};
+struct sockaddr_in addr_serv;
+struct sockaddr_un addr_server;
+AT_CALLBACK tmp = NULL;
+static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
+socklen_t len;
+bool connect_state = false;
+
+
+int socket_local_client (char* name) {
+ LOGD("[%d][%s] enter",LINE,FUNC);
+ sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sockfd < 0)
+ {
+ LOGD("Can't open stream socket (%s)", name);
+ return -1;
+ }
+ addr_server.sun_family = AF_UNIX;
+ memset(addr_server.sun_path, '\0', sizeof(addr_server.sun_path));
+ strncpy(addr_server.sun_path, name, sizeof(addr_server.sun_path) - 1);
+ if (connect(sockfd, (struct sockaddr *) &addr_server, sizeof(struct sockaddr_un)) < 0)
+ {
+ close(sockfd);
+ LOGD("Can't connect to server side, path: %s, %s", name, strerror(errno));
+ return -1;
+ }
+ LOGD("[%d][%s] connect %s success",LINE,FUNC,name);
+ return sockfd;
+}
+bool send_msg_to_service(int fd,char *msg,int size)
+{
+ LOGD("[%d][%s] enter",LINE,FUNC);
+ if (fd < 0)
+ {
+ LOGD("fd invalid when send to atci service. errno = %d", errno);
+ return false;
+ }
+ if(NULL == msg)
+ {
+ LOGD("atcmd is null.");
+ return false;
+ }
+ int sendLen = send(fd, msg, size, 0);
+ if (sendLen != size)
+ {
+ LOGD("lose data when send to atci service. errno = %d", errno);
+ return false;
+ }
+ LOGD("client send to app demo: %s", msg);
+ return true;
+}
+
+int atsvc_cmd_recv(int fd, char *buf, int len)
+{
+ int ret = 0;
+ ret = recv(fd, buf, len, 0);
+ LOGD("[%d][%s] recv after",LINE,FUNC);
+ if (ret < 0)
+ {
+ LOGD("acti_cmd_recv client select error, ret=%d, error=%s(%d),fd=%d", ret,strerror(errno), errno, fd);
+ return SOCKET_FAIL;
+ }
+ else if(ret == 0)
+ {
+ LOGD("acti_cmd_recv client recv error, ret=%d, error=%s(%d),fd=%d", ret,strerror(errno), errno, fd);
+ return SOCKET_ZERO;
+ }
+ return SOCKET_SUCC;
+}
+/**
+ * @brief send third cmd to service and receive input,then send output to service
+ *
+ * @param parm
+ * @return void*
+ */
+void *thread_recv(void *parm)
+{
+ LOGD("[%d][%s] enter",LINE,FUNC);
+ char at_cmd[100] = {0};
+ int fd = -1;
+ int ret = 0;
+ fd = socket_local_client(AT_EXTERSION_SOCKET_NAME);
+ if(fd <= 0)
+ {
+ LOGE("socket_local_client fail\n");
+ connect_state = false;
+ pthread_mutex_unlock(&s_startupMutex);
+ return NULL;
+ }
+ int len_buf = strlen(buffer_at);
+ if(!send_msg_to_service(fd,buffer_at,len_buf))
+ {
+ LOGE("send_msg_to_service fail\n");
+ connect_state = false;
+ pthread_mutex_unlock(&s_startupMutex);
+ return NULL;
+ }
+ connect_state = true;
+ pthread_mutex_unlock(&s_startupMutex);
+ char *input = NULL;
+ output = (char *)malloc(sizeof(char)*OUT_MAX_SIZE);
+ if(NULL == output)
+ {
+ LOGE("thread_recv malloc fail\n");
+ return NULL;
+ }
+ TryNewLink:
+ if(connect_state == false)
+ {
+ if (connect(fd, (struct sockaddr *) &addr_server, sizeof(struct sockaddr_un)) < 0)
+ {
+ close(fd);
+ LOGE("Can't connect to server side, path: %s, errno:%d", AT_EXTERSION_SOCKET_NAME, errno);
+ return NULL;
+ }
+ connect_state = true;
+ }
+ while (1)
+ {
+ /*receive at cmd*/
+ memset(at_cmd, 0, sizeof(at_cmd));
+ ret = atsvc_cmd_recv(fd, at_cmd,sizeof(at_cmd));
+ if (ret < 0)
+ {
+ LOGE("[%d][%s]receive CMD error",LINE,FUNC);
+ continue;
+ }
+ else if(ret == SOCKET_ZERO)
+ {
+ LOGE("maybe client socket closed 1. retry new link!");
+ connect_state = false;
+ goto TryNewLink;
+ }
+ input = at_cmd;
+ int len = strlen(input);
+ while (len > 0 && (input[len - 1] == '\r' || input[len - 1] == '\n'))
+ {
+ input[--len] = '\0';
+ }
+ //begin deal with callback
+ tmp(input, output, OUT_MAX_SIZE);
+ LOGD("lynq_reg_third_at send output to service\n");
+ if(!send_msg_to_service(fd,output, strlen(output)))
+ {
+ LOGE("thread_recv send fail\n");
+ continue;
+ }
+ }
+ free(output);
+ output = NULL;
+ if(fd != 0)
+ {
+ close(fd);
+ }
+ return NULL;
+}
+
+/**
+ * @brief Threads are created to communicate with the server
+ *
+ * @return int
+ */
+int lynq_connect_service_start(void)
+{
+ LOGD("[%d][%s] enter",LINE,FUNC);
+ pthread_t lynq_at_tid;
+ int rt = pthread_create(&lynq_at_tid, NULL, thread_recv, NULL);
+ pthread_mutex_lock(&s_startupMutex);
+ LOGD("[%d][%s] pthread mutex unlock",LINE,FUNC);
+ if((connect_state != true) && rt < 0)
+ {
+ LOGE("connect fail,rt:%d,connect state:%d\n",rt,connect_state);
+ return -1;
+ }
+ return 0;
+}
+
+/**
+ * @brief Type:[IN] send third at cmd to service
+ * @param ext_at Type:[IN] input at cmd
+ * @param callback Type:[IN]
+ * @return int
+ */
+int32_t gsw_reg_atcmd(const char *atcmd,AT_CALLBACK func)
+{
+ if(NULL == atcmd || NULL == func)
+ {
+ return GSW_HAL_FAIL;
+ }
+ dlHandle_at = dlopen(lynqLib_at, RTLD_NOW);
+ fun_ptr_log = (mbtk_log)dlsym(dlHandle_at, "mbtk_log");
+ if(fun_ptr_log == NULL || dlHandle_at == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ memcpy(buffer_at, atcmd, strlen(atcmd));
+ tmp = func;
+ LOGD("lynq_reg_third_at start\n");
+ int ret = lynq_connect_service_start();
+
+ if(ret != 0)
+ {
+ LOGE("lynq_connect_service_start start failed\n");
+ return GSW_HAL_FAIL;
+ }
+ LOGD("lynq_connect_service_start success ret:%d\n",ret);
+ return GSW_HAL_SUCCESS;
+}
+
+int32_t gsw_sdk_at_init(void)
+{
+ return GSW_HAL_SUCCESS;
+}
diff --git a/mbtk/libgsw_lib/gsw_data.c b/mbtk/libgsw_lib/gsw_data.c
new file mode 100755
index 0000000..e26e35b
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_data.c
@@ -0,0 +1,931 @@
+#include "gsw_nw_interface.h"
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <pthread.h>
+
+
+//mbtk include
+#define MBTK_APN_NAME_SIZE 150+1
+#define MBTK_APN_USERNAME_SIZE 127+1
+#define MBTK_APN_PASSWORD_SIZE 127+1
+#define MBTK_APN_TYPE_SIZE 127+1
+
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+
+
+
+
+typedef unsigned int uint32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+typedef unsigned long long uint64_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 enum {
+ MBTK_IP_TYPE_IP,
+ MBTK_IP_TYPE_IPV6,
+ MBTK_IP_TYPE_IPV4V6,
+ MBTK_IP_TYPE_PPP
+} mbtk_ip_type_enum;
+
+typedef enum {
+ MBTK_APN_REQ_TYPE_SET = 0, // set apn req
+ MBTK_APN_REQ_TYPE_ADD // add apn req
+}mbtk_apn_req_type_enum;
+
+typedef enum {
+ MBTK_APN_AUTH_PROTO_DEFAULT = 0,
+ MBTK_APN_AUTH_PROTO_NONE,
+ MBTK_APN_AUTH_PROTO_PAP,
+ MBTK_APN_AUTH_PROTO_CHAP,
+#if 0
+ MBTK_APN_AUTH_PROTO_PAP_CHAP,
+ //NOT SUPPORT
+#endif
+} mbtk_apn_auth_proto_enum;
+
+
+typedef struct {
+ bool valid;
+ uint32 IPAddr;
+ uint32 PrimaryDNS;
+ uint32 SecondaryDNS;
+ uint32 GateWay;
+ uint32 NetMask;
+} __attribute__((packed)) mbtk_ipv4_info_t;
+
+typedef struct {
+ bool valid;
+ uint32 IPV6Addr[4];
+ uint32 PrimaryDNS[4];
+ uint32 SecondaryDNS[4];
+ uint32 GateWay[4];
+ uint32 NetMask[4];
+} __attribute__((packed)) mbtk_ipv6_info_t;
+
+
+
+typedef struct {
+ int cid; /*!< UMTS/CDMA profile ID. range: 0 - 7*/
+ mbtk_ip_type_enum ip_type; /*!< Packet Data Protocol (PDP) type specifies the type of data payload
+ exchanged over the airlink when the packet data session is
+ established with this profile. */
+ mbtk_apn_req_type_enum req_type; /*!< apn req type*/
+ mbtk_apn_auth_proto_enum auth_proto; /*!< Authentication Protocol. */
+ uint8 apn_name[MBTK_APN_NAME_SIZE]; /*!< A string parameter that is a logical name used to select the GGSN
+ and external packet data network. */
+ uint8 user_name[MBTK_APN_USERNAME_SIZE]; /*!< Username used during data network authentication. */
+ uint8 user_pass[MBTK_APN_PASSWORD_SIZE]; /*!< Password to be used during data network authentication. */
+ uint8 apn_type[MBTK_APN_TYPE_SIZE];
+} mbtk_qser_apn_info_s;
+
+static mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
+static int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle);
+int (*mbtk_pdp_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
+int (*mbtk_qser_apn_set)(mbtk_info_handle_t* handle, mbtk_qser_apn_info_s *apninfo, unsigned char *cid);
+int (*mbtk_data_call_start)(mbtk_info_handle_t* handle, int cid, int auto_conn_interval, bool boot_conn, int timeout);
+int (*mbtk_data_call_stop)(mbtk_info_handle_t* handle, int cid, int timeout);
+int (*mbtk_data_call_state_get)(mbtk_info_handle_t* handle, int cid, mbtk_ipv4_info_t *ipv4, mbtk_ipv6_info_t *ipv6);
+int (*mbtk_apn_set)(mbtk_info_handle_t* handle, int cid, mbtk_ip_type_enum ip_type, const void* apn_name, const void *user_name, const void *user_pass, const void *auth);
+int (*ipv6_2_str)(const void *ipv6, void *ipv6_str);
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+//define
+#define GSW_HAL_FAIL GSW_HAL_NORMAL_FAIL
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+pthread_mutex_t data_mutex = PTHREAD_MUTEX_INITIALIZER;
+static int data_call_lock = 0;
+static int data_init_flag = 0;
+static void *dlHandle_mbtk;
+static mbtk_info_handle_t* data_info_handle = NULL;
+static gsw_data_call_evt_cb_t gsw_data_call_evt_cb;
+
+Wan_State_ind_s *linkState_arr;
+
+static int Wan_State_ind_malloc(Wan_State_ind_s **linkState)
+{
+ (*linkState) = (Wan_State_ind_s *)malloc(sizeof(Wan_State_ind_s));
+ if((*linkState) == NULL)
+ {
+ LOGE("malloc Wan_State_ind_s fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ memset((*linkState), 0x00, sizeof(Wan_State_ind_s));
+
+ (*linkState)->handle = -1;
+ (*linkState)->cid = -1;
+ (*linkState)->state = 0;
+ (*linkState)->fail_cause = 0;
+
+ (*linkState)->type = (char *)malloc(GSW_PDP_TYPE_MAX_LEN);
+ memset((*linkState)->type, 0x00, GSW_PDP_TYPE_MAX_LEN);
+
+ (*linkState)->ifname = (char *)malloc(GSW_IFACE_NAME_MAX_LEN);
+ memset((*linkState)->ifname, 0x00, GSW_IFACE_NAME_MAX_LEN);
+
+ (*linkState)->v4_ip = (char *)malloc(GSW_PDP_ADDR_MAX_LEN);
+ memset((*linkState)->v4_ip, 0x00, GSW_PDP_ADDR_MAX_LEN);
+
+ (*linkState)->v4_pdns = (char *)malloc(GSW_DNS_ADDR_MAX_LEN);
+ memset((*linkState)->v4_pdns, 0x00, GSW_DNS_ADDR_MAX_LEN);
+
+ (*linkState)->v4_sdns = (char *)malloc(GSW_DNS_ADDR_MAX_LEN);
+ memset((*linkState)->v4_sdns, 0x00, GSW_DNS_ADDR_MAX_LEN);
+
+ (*linkState)->v4_gw = (char *)malloc(GSW_GETWAYS_ADDR_MAX_LEN);
+ memset((*linkState)->v4_gw, 0x00, GSW_GETWAYS_ADDR_MAX_LEN);
+
+ (*linkState)->v6_ip = (char *)malloc(GSW_PDP_ADDR_MAX_LEN);
+ memset((*linkState)->v6_ip, 0x00, GSW_PDP_ADDR_MAX_LEN);
+
+ (*linkState)->v6_pdns = (char *)malloc(GSW_DNS_ADDR_MAX_LEN);
+ memset((*linkState)->v6_pdns, 0x00, GSW_DNS_ADDR_MAX_LEN);
+
+ (*linkState)->v6_sdns = (char *)malloc(GSW_DNS_ADDR_MAX_LEN);
+ memset((*linkState)->v6_sdns, 0x00, GSW_DNS_ADDR_MAX_LEN);
+
+ return GSW_HAL_SUCCESS;
+}
+
+static int Wan_State_ind_free(Wan_State_ind_s **linkState)
+{
+ if ((*linkState) == NULL)
+ {
+ LOGE("(*linkState) is null\n");
+ return GSW_HAL_FAIL;
+ }
+
+ free((*linkState)->type);
+ (*linkState)->type = NULL;
+
+ free((*linkState)->ifname);
+ (*linkState)->ifname = NULL;
+
+ free((*linkState)->v4_ip);
+ (*linkState)->v4_ip = NULL;
+
+ free((*linkState)->v4_pdns);
+ (*linkState)->v4_pdns = NULL;
+
+ free((*linkState)->v4_sdns);
+ (*linkState)->v4_sdns = NULL;
+
+ free((*linkState)->v4_gw);
+ (*linkState)->v4_gw = NULL;
+
+ free((*linkState)->v6_ip);
+ (*linkState)->v6_ip = NULL;
+
+ free((*linkState)->v6_pdns);
+ (*linkState)->v6_pdns = NULL;
+
+ free((*linkState)->v6_sdns);
+ (*linkState)->v6_sdns = NULL;
+
+
+ free((*linkState));
+ (*linkState) = NULL;
+
+ return GSW_HAL_SUCCESS;
+}
+
+static int mbtk_data_api_import()
+{
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+ if (mbtk_info_handle_get == NULL)
+ {
+ LOGE("mbtk_info_handle_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_info_handle_free dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_pdp_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_pdp_state_change_cb_reg");
+ if (mbtk_pdp_state_change_cb_reg == NULL)
+ {
+ LOGE("mbtk_pdp_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_qser_apn_set = (int (*)(mbtk_info_handle_t* handle, mbtk_qser_apn_info_s *apninfo, unsigned char *cid))dlsym(dlHandle_mbtk, "mbtk_qser_apn_set");
+ if (mbtk_qser_apn_set == NULL)
+ {
+ LOGE("mbtk_qser_apn_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_data_call_start = (int (*)(mbtk_info_handle_t* handle, int cid, int auto_conn_interval, bool boot_conn, int timeout))dlsym(dlHandle_mbtk, "mbtk_data_call_start");
+ if (mbtk_data_call_start == NULL)
+ {
+ LOGE("mbtk_data_call_start dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_data_call_stop = (int (*)(mbtk_info_handle_t* handle, int cid, int timeout))dlsym(dlHandle_mbtk, "mbtk_data_call_stop");
+ if (mbtk_data_call_stop == NULL)
+ {
+ LOGE("mbtk_data_call_stop dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_data_call_state_get = (int (*)(mbtk_info_handle_t* handle, int cid, mbtk_ipv4_info_t *ipv4, mbtk_ipv6_info_t *ipv6))dlsym(dlHandle_mbtk, "mbtk_data_call_state_get");
+ if (mbtk_data_call_state_get == NULL)
+ {
+ LOGE("mbtk_data_call_state_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_apn_set = (int (*)(mbtk_info_handle_t* handle, int cid, mbtk_ip_type_enum ip_type, const void* apn_name, const void *user_name, const void *user_pass, const void *auth))dlsym(dlHandle_mbtk, "mbtk_apn_set");
+ if (mbtk_apn_set == NULL)
+ {
+ LOGE("mbtk_apn_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ipv6_2_str = (int (*)(const void *ipv6, void *ipv6_str))dlsym(dlHandle_mbtk, "ipv6_2_str");
+ if (ipv6_2_str == NULL)
+ {
+ LOGE("ipv6_2_str dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+
+static int data_call_state_query(int call_id,Wan_State_ind_s *linkState)
+{
+ int ret = -1;
+ mbtk_ipv4_info_t ipv4;
+ mbtk_ipv6_info_t ipv6;
+
+ LOGE("mbtk_data_call_state_get start\n");
+ ret = mbtk_data_call_state_get(data_info_handle, call_id, &ipv4, &ipv6);
+ LOGE("mbtk_data_call_state_get end\n");
+ if (ret != 0)
+ {
+ LOGE("mbtk_data_call_state_get fail\n");
+ return ret;
+ }
+
+ //ifname
+ sprintf(linkState->ifname, "ccinet%d", call_id-1);
+
+ //type
+ if(ipv4.valid)
+ {
+ if(ipv6.valid)
+ {
+ strcpy(linkState->type, "IPV4V6");
+ }
+ else {
+ strcpy(linkState->type, "IP");
+ }
+ }
+ else if(ipv6.valid)
+ {
+ strcpy(linkState->type, "IPV6");
+ }
+
+ //ip
+ LOGE("ipv4.valid = %d\n", ipv4.valid);
+ if(ipv4.valid)
+ {
+ if(linkState==NULL)
+ {
+ LOGE("linkState is NULL\n");
+ return GSW_HAL_FAIL;
+ }
+
+ //parse ipv4_addr,gw,dns,sdns
+ if(inet_ntop(AF_INET, &(ipv4.IPAddr), linkState->v4_ip , GSW_PDP_ADDR_MAX_LEN) == NULL) {
+ LOGE("IPv4 error.\n");
+ } else {
+ LOGE("IPv4 : %s\n", linkState->v4_ip);
+
+ }
+
+
+ if(inet_ntop(AF_INET, &(ipv4.GateWay), linkState->v4_gw , GSW_PDP_ADDR_MAX_LEN) == NULL) {
+ LOGE("GateWay error.\n");
+ } else {
+ LOGE("GateWay : %s\n", linkState->v4_gw);
+ }
+
+ if(inet_ntop(AF_INET, &(ipv4.PrimaryDNS), linkState->v4_pdns , GSW_DNS_ADDR_MAX_LEN) == NULL) {
+ LOGE("PrimaryDNS error.\n");
+ } else {
+ LOGE("PrimaryDNS : %s\n", linkState->v4_pdns);
+ }
+
+ if(inet_ntop(AF_INET, &(ipv4.SecondaryDNS), linkState->v4_sdns , GSW_DNS_ADDR_MAX_LEN) == NULL) {
+ LOGE("SecondaryDNS error.\n");
+ } else {
+ LOGE("SecondaryDNS : %s\n", linkState->v4_sdns);
+ }
+ }
+
+ LOGE("ipv6.valid = %d\n", ipv6.valid);
+ if(ipv6.valid)
+ {
+ //parse ipv6_addr,gw,dns,sdns
+ if(ipv6_2_str(&(ipv6.IPV6Addr), linkState->v6_ip)) {
+ LOGE("IPv6 error.\n");
+ } else {
+ LOGE("IPv6 : %s\n", linkState->v6_ip);
+ }
+
+ if(ipv6_2_str(&(ipv6.PrimaryDNS), linkState->v6_pdns)) {
+ LOGE("PrimaryDNS error.\n");
+ } else {
+ LOGE("PrimaryDNS : %s\n", linkState->v6_pdns);
+ }
+
+ if(ipv6_2_str(&(ipv6.SecondaryDNS), linkState->v6_sdns)) {
+ LOGE("SecondaryDNS error.\n");
+ } else {
+ LOGE("SecondaryDNS : %s\n", linkState->v6_sdns);
+ }
+ }
+
+
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+static void data_call_state_change_cb(const void* data, int data_len)
+{
+ LOGE("data_call_state_change_cb() start\n");
+
+ if(data == NULL || data_len == 0)
+ {
+ return;
+ }
+
+ int ret = -1;
+
+ LOGD("Wan_State_ind_malloc start\n");
+ ret = Wan_State_ind_malloc(&linkState_arr);
+ if (ret != 0)
+ {
+ LOGE("Wan_State_ind_malloc[0] fail\n");
+ return ;
+ }
+
+ if(linkState_arr == NULL)
+ {
+ LOGE("linkState_arr is NULL");
+ return ;
+ }
+ else
+ {
+ LOGE("linkState_arr is not NULL");
+ }
+
+ uint8 *net_data = NULL;
+ net_data = (uint8 *)data;
+ //disconnected
+ LOGE("net_data = %d\n", *net_data);
+ if(*net_data > 100 && *net_data < 200)
+ {
+ int apn_id = *net_data - 100;
+ int handle_temp = apn_id-2;
+ LOGE("apn_id = %d\n", apn_id);
+ linkState_arr->state = 0;//disconnected
+ linkState_arr->cid = -1;
+ linkState_arr->handle = handle_temp;
+
+ //get data_call_state
+ if(!data_call_lock)
+ {
+ data_call_state_query(apn_id, linkState_arr);
+ }
+
+ if(gsw_data_call_evt_cb)
+ {
+ gsw_data_call_evt_cb(linkState_arr);
+ }
+ }
+
+ else if(*net_data > 200 && *net_data < 220)
+ {
+ LOGE("cid[%d] is open.\n", *net_data - 200);
+ int apn_id = *net_data-200;
+ int handle_temp = apn_id-2;
+
+ linkState_arr->state = 2;//connected
+ linkState_arr->cid = apn_id;
+ linkState_arr->handle = handle_temp;
+ //get data_call_state
+ if(!data_call_lock)
+ {
+ data_call_state_query(apn_id, linkState_arr);
+ }
+
+ if(gsw_data_call_evt_cb)
+ {
+ gsw_data_call_evt_cb(linkState_arr);
+ }
+ }
+
+ else if(*net_data > 220)
+ {
+ LOGE("cid [%d] is reopen.\n", *net_data - 220);
+ int apn_id = *net_data-220;
+ int handle_temp = apn_id-2;
+
+ linkState_arr->state = 2;//connected
+ linkState_arr->cid = apn_id;
+ linkState_arr->handle = handle_temp;
+
+ //get data_call_state
+ if(!data_call_lock)
+ {
+ data_call_state_query(apn_id, linkState_arr);
+ }
+
+ if(gsw_data_call_evt_cb)
+ {
+ gsw_data_call_evt_cb(linkState_arr);
+ }
+ }
+
+ else if(*net_data == 1)
+ {
+ LOGE("pdp is open.\n");
+ }
+
+ else
+ {
+ LOGE("unknown param [%d].\n", *net_data);
+ }
+
+ ret = Wan_State_ind_free(&linkState_arr);
+ if (ret != 0)
+ {
+ LOGE("Wan_State_ind_free fail\n");
+ }
+
+}
+
+
+
+
+
+
+/**
+ * @brief datacall sdk init
+ * @param [in] evt_cb callback function for data connection state change event
+ * call back;
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_data_call_init(gsw_data_call_evt_cb_t evt_cb)
+{
+ int ret;
+ ret = mbtk_data_api_import();
+ if (ret != 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(data_init_flag != 0 && data_info_handle != NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if (ret != GSW_HAL_SUCCESS)
+ {
+ LOGE("mbtk_data_api_import fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ data_info_handle = (mbtk_info_handle_t*)mbtk_info_handle_get();
+ if (data_info_handle == NULL)
+ {
+ LOGE("mbtk_info_handle_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_pdp_state_change_cb_reg((mbtk_info_handle_t*)data_info_handle, data_call_state_change_cb);
+ if (ret != 0)
+ {
+ LOGE("mbtk_pdp_state_change_cb_reg fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ gsw_data_call_evt_cb = evt_cb;
+ data_init_flag = 1;
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief data_call sdk deinit
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_data_call_deinit(void)
+{
+ int ret;
+ if(data_init_flag == 0 && data_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_info_handle_free((mbtk_info_handle_t**)&data_info_handle);
+ if (ret != 0)
+ {
+ LOGE("mbtk_info_handle_free fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ data_init_flag = 0;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief set apn parameters for data call
+ * @param [in/out] LinkInf apn info for pub or private datacall
+ * inlcude apn name mcc mnc, passwork apnid type cid etc
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_data_call_set_apn(Link_Info_s *LinkInf)
+{
+ if(data_init_flag == 0 && data_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(LinkInf == NULL)
+ {
+ LOGE("apn info is null\n");
+ return GSW_HAL_FAIL;
+ }
+
+ int ret = 0;
+ mbtk_ip_type_enum ip_type;
+ int auth_type = -1;
+
+ //pdp type
+ if(strcmp(LinkInf->normalProtocol,"IPV4") == 0)
+ {
+ ip_type = MBTK_IP_TYPE_IP;
+ LOGE("pdp_type(protocol) is IPV4\n");
+ }
+ else if(strcmp(LinkInf->normalProtocol,"IPV6") == 0)
+ {
+ ip_type = MBTK_IP_TYPE_IPV6;
+ LOGE("pdp_type(protocol) is IPV6\n");
+ }
+ else if(strcmp(LinkInf->normalProtocol,"IPV4V6") == 0)
+ {
+ ip_type = MBTK_IP_TYPE_IPV4V6;
+ LOGE("pdp_type(protocol) is IPV4V6\n");
+ }
+ else
+ {
+ LOGE("pdp_type(protocol) error\n");
+ return GSW_HAL_FAIL;
+ }
+
+ //auth type
+ auth_type = atoi(LinkInf->authType);
+
+ ret = mbtk_apn_set(data_info_handle, LinkInf->handle+2, ip_type, LinkInf -> apn, LinkInf -> usr, LinkInf -> pwd, (const void *)auth_type);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_apn_set fail.");
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief set apn parameters for data call
+ * @param [in] linkid data connetion link number
+ * @param [in/out] LinkInf link info req: apn info for pub or private datacall
+ * inlcude apn name mcc mnc, passwork apnid etc
+ * resp: data call link state ipaddress type etc
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_data_call_connect(int linkid, Link_Info_s *LinkInf)
+{
+ int ret = -1;
+ if(data_init_flag == 0 && data_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(LinkInf == NULL)
+ {
+ LOGE("apn info is null\n");
+ return GSW_HAL_FAIL;
+ }
+
+ data_call_lock = 1;
+ ret = mbtk_data_call_start((mbtk_info_handle_t*)data_info_handle, linkid + 2, 0, FALSE, 0);
+ data_call_lock = 0;
+ if(ret != 0)
+ {
+ LOGE("mbtk_data_call_start fail,\n");
+ return GSW_HAL_FAIL;
+ }
+
+ uint8_t cid_temp = (uint8_t)(linkid + 202);
+ data_call_state_change_cb(&cid_temp,1);
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief set apn parameters for data call
+ * @param [in] linkid
+ * @param [in/out] LinkInf link info req: apn info for pub or private datacall
+ * inlcude apn name mcc mnc, passwork apnid etc
+ * resp: data call link state ipaddress type etc
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_data_call_disconnect(int linkid, Link_Info_s *LinkInf)
+{
+ int ret = -1;
+ if(data_init_flag == 0 && data_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(LinkInf == NULL)
+ {
+ LOGE("apn info is null\n");
+ return GSW_HAL_FAIL;
+ }
+ data_call_lock = 1;
+ ret = mbtk_data_call_stop((mbtk_info_handle_t*)data_info_handle, linkid + 2, 15);
+ data_call_lock = 0;
+ if(ret != 0)
+ {
+ LOGE("mbtk_data_call_stop fail,ret = %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+
+ uint8_t cid_temp = (uint8_t)(linkid + 102);
+ data_call_state_change_cb(&cid_temp,1);
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/*
+ * @brief get mobile operator name
+ @param [in] linkid apn id
+ @param [out] data_pkt obtian actual data call network card data traffic
+ @retval 0: success
+ @retval 0: other: fail
+ */
+int gsw_get_data_call_pkt_stats(int linkid, gsw_data_pkt_stats *data_pkt)
+{
+ char temp_linkid[12] = {0};
+ char interface_name[32] = {0};
+ sprintf(temp_linkid,"%d",linkid+1);
+ snprintf(interface_name, sizeof(interface_name),"ccinet%s", temp_linkid);
+
+ uint64_t tx_bytes = 0;
+ uint64_t tx_packets = 0;
+ uint64_t tx_dropped = 0;
+ uint64_t rx_bytes = 0;
+ uint64_t rx_packets = 0;
+ uint64_t rx_dropped = 0;
+ char command[128] = {0};
+ char* temp;
+ char buffer[512] = {0};
+
+ snprintf(command, sizeof(command), "ifconfig %s", interface_name);
+
+ FILE *fp = popen(command, "r");
+ if(fp == NULL)
+ {
+ LOGE("popen fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ //read line by line
+ while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+ // TX bytes
+ if (strstr(buffer, "TX bytes")) {
+ temp = strstr(buffer, "TX bytes");
+ sscanf(temp, " TX bytes:%llu ", &tx_bytes);
+ }
+ // TX packets
+ if (strstr(buffer, "TX packets")) {
+ sscanf(buffer, " TX packets:%llu ", &tx_packets);
+ sscanf(buffer, " TX packets:%*u errors:%*u dropped:%llu", &tx_dropped);
+ }
+ // RX bytes
+ if (strstr(buffer, "RX bytes")) {
+ LOGE("RX bytes %s\n",strstr(buffer, "RX bytes"));
+ sscanf(buffer, " RX bytes:%llu ", &rx_bytes);
+ }
+ // RX packets
+ if (strstr(buffer, "RX packets")) {
+ sscanf(buffer, " RX packets:%llu ", &rx_packets);
+ sscanf(buffer, " RX packets:%*u errors:%*u dropped:%llu", &rx_dropped);
+ }
+ }
+
+ // 关闭管道
+ pclose(fp);
+
+ // 输出结果
+ LOGE("TX Bytes: %llu\n", tx_bytes);
+ LOGE("TX Packets: %llu\n", tx_packets);
+ LOGE("TX Dropped: %llu\n", tx_dropped);
+ LOGE("RX Bytes: %llu\n", rx_bytes);
+ LOGE("RX Packets: %llu\n", rx_packets);
+ LOGE("RX Dropped: %llu\n", rx_dropped);
+
+ if(data_pkt == NULL)
+ {
+ LOGE("data_pkt is null\n");
+ return GSW_HAL_FAIL;
+ }
+
+ else
+ {
+ data_pkt->tx_bytes = tx_bytes;
+ data_pkt->tx_pkts = tx_packets;
+ data_pkt->tx_dropped_pkts = tx_dropped;
+ data_pkt->rx_bytes = rx_bytes;
+ data_pkt->rx_pkts = rx_packets;
+ data_pkt->rx_dropped_pkts = rx_dropped;
+ }
+
+ return GSW_HAL_SUCCESS;
+
+}
diff --git a/mbtk/libgsw_lib/gsw_ecall.c b/mbtk/libgsw_lib/gsw_ecall.c
new file mode 100755
index 0000000..e2c6d8f
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_ecall.c
@@ -0,0 +1,1193 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <stdint.h>
+
+#include <errno.h>
+#include <stdbool.h>
+#include <pthread.h>
+
+#include "gsw_ecall.h"
+
+#define RIL_MAX_NUMBER_LEN 40
+#define MBTK_ECALL_MSD_LEN_MAX 600
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+typedef void (*mbtk_log)(int level, const char *format,...);
+
+
+typedef unsigned int uint32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+
+typedef enum {
+ MBTK_ECALL_URC_ID_ALACK = 0, // AL-ACK signal received (refer to : urc_data)
+ MBTK_ECALL_URC_ID_SYNC_LOST, // eIM lost synchronization with PSAP
+ // (A resynch occurs after the synchronization is lost.)
+ MBTK_ECALL_URC_ID_NACK, // NACK signal received
+ MBTK_ECALL_URC_ID_RESERVED_3,
+ MBTK_ECALL_URC_ID_RESERVED_4,
+ MBTK_ECALL_URC_ID_RESERVED_5, // 5
+ MBTK_ECALL_URC_ID_3GPP_FATAL, // eIM is terminated: fatal error (3GPP Abort function)
+ MBTK_ECALL_URC_ID_CALL_DROP, // eIM is terminated: call drop
+ MBTK_ECALL_URC_ID_GENERIC, // Generic error
+ MBTK_ECALL_URC_ID_MSD_REQ, // PSAP request MSD (Only for PULL modem)
+ MBTK_ECALL_URC_ID_MSD_SEND_START, // 10 : eIM starts sending MSD
+ MBTK_ECALL_URC_ID_INITIATION, // The eIM starts sending the Initiation signal (Only for PUSH modem).
+ // It also indicates that the call setup is completed.
+ MBTK_ECALL_URC_ID_SEND_MSD, // PUSH: SEND_MSD -> MSD_SEND_START
+ // PULL: SEND_MSD -> MSD_REQ -> MSD_SEND_START
+ MBTK_ECALL_URC_ID_SEND_MSD_FULL,// SEND MSD signal received too often, PSAP sync failure assumed
+ MBTK_ECALL_URC_ID_SYNCED_PSAP, // IVS eIM is synced with PSAP
+ MBTK_ECALL_URC_ID_SYNCED_PSAP_EIM, // 15: IVS eIM is synced with PSAP eIM
+ MBTK_ECALL_URC_ID_LLACK, // Link layer ACK received
+ MBTK_ECALL_URC_ID_HLACK, // Higher Layer ACK received (similar to AL-ACK (#0) but without data)
+ MBTK_ECALL_URC_ID_EIM_RESET, // The eIM transmitter idles after a full reset. The eIM transmitter is reset after sync loss
+ // (for example, because of the end of PSAP transmission).
+ MBTK_ECALL_URC_ID_EIM_IDLES, // The eIM transmitter idles after the transmission of the Initiation signal (push mode)
+ MBTK_ECALL_URC_ID_MSD_UPDATE, // 20 : MSD update request is received.
+ MBTK_ECALL_URC_ID_MSD_UPDATE_DONE, // MSD update is done.
+ MBTK_ECALL_URC_ID_MSD_UPDATE_ERR, // MSD update request cannot be processed.
+ MBTK_ECALL_URC_ID_T3_EXPIRED, // T3 expired
+ MBTK_ECALL_URC_ID_T5_EXPIRED, // T5 expired
+ MBTK_ECALL_URC_ID_T6_EXPIRED, // 25 : T6 expired
+ MBTK_ECALL_URC_ID_T7_EXPIRED, // T7 expired
+ MBTK_ECALL_URC_ID_TH_EXPIRED, // TH expired
+ MBTK_ECALL_URC_ID_RESERVED_28,
+ MBTK_ECALL_URC_ID_RESERVED_29,
+ MBTK_ECALL_URC_ID_RESERVED_30, // 30
+ MBTK_ECALL_URC_ID_IVS_EVENT_TIMEOUT,
+ MBTK_ECALL_URC_ID_PSAP_REQ, // Only for ERA
+ MBTK_ECALL_URC_ID_MSD_SEND_FAIL_FOR_NG // NG-eCall fail to transfer MSD
+} mbtk_ecall_urc_id_enum;
+
+typedef enum {
+ MBTK_CLCC = 1,
+ MBTK_CPAS,
+ MBTK_DISCONNECTED,
+} mbtk_call_enum;
+
+typedef enum {
+ MBTK_CALL_RADY, //MT allows commands from TA/TE
+ MBTK_CALL_UNAVAILABLE, //MT does not allow commands from TA/TE
+ MBTK_CALL_UNKNOWN, //MT is not guaranteed to respond to instructions
+ MBTK_CALL_RINGING, //MT is ready for commands from TA/TE, but the ringer is active
+ MBTK_CALL_PROGRESS, //MT is ready for commands from TA/TE, but a call is in progress
+ MBTK_CALL_ASLEEP, //MT is unable to process commands from TA/TE because it is in a low functionality state
+ MBTK_CALL_ACTIVE,
+} mbtk_call_pas_enum;
+
+#define MBTK_ECALL_CFG_T3 (1 << MBTK_ECALL_CFG_ITEM_T3) // ms
+#define MBTK_ECALL_CFG_T5 (1 << MBTK_ECALL_CFG_ITEM_T5) // ms
+#define MBTK_ECALL_CFG_T6 (1 << MBTK_ECALL_CFG_ITEM_T6) // ms
+#define MBTK_ECALL_CFG_T7 (1 << MBTK_ECALL_CFG_ITEM_T7) // ms
+#define MBTK_ECALL_CFG_TH (1 << MBTK_ECALL_CFG_ITEM_TH) // ms
+#define MBTK_ECALL_CFG_TIMER_CALLBACK (1 << MBTK_ECALL_CFG_ITEM_TIMER_CALLBACK) // T9
+#define MBTK_ECALL_CFG_TIMER_CLEARDOWN (1 << MBTK_ECALL_CFG_ITEM_TIMER_CLEARDOWN) // T2
+#define MBTK_ECALL_CFG_TIMER_DEREG (1 << MBTK_ECALL_CFG_ITEM_TIMER_DEREG) // T10
+#define MBTK_ECALL_CFG_TIMER_DIAL (1 << MBTK_ECALL_CFG_ITEM_TIMER_DIAL) // "dial"
+#define MBTK_ECALL_CFG_TIMER_REDIAL (1 << MBTK_ECALL_CFG_ITEM_TIMER_REDIAL) // "redialtmr"
+#define MBTK_ECALL_CFG_TIMER_SMS (1 << MBTK_ECALL_CFG_ITEM_TIMER_SMS) // "sms" // 10
+#define MBTK_ECALL_CFG_REDIALCNT (1 << MBTK_ECALL_CFG_ITEM_REDIALCNT) // "redialcnt"
+#define MBTK_ECALL_CFG_SMSPROCESS (1 << MBTK_ECALL_CFG_ITEM_SMSPROCESS) // "smsprocess"
+#define MBTK_ECALL_CFG_SMSMSDCNT (1 << MBTK_ECALL_CFG_ITEM_SMSMSDCNT) // "smsmsdcnt"
+
+
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+
+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 enum {
+ MBTK_ECALL_CFG_ITEM_T3 = 0, // ms
+ MBTK_ECALL_CFG_ITEM_T5, // ms
+ MBTK_ECALL_CFG_ITEM_T6, // ms
+ MBTK_ECALL_CFG_ITEM_T7, // ms
+ MBTK_ECALL_CFG_ITEM_TH, // ms
+ MBTK_ECALL_CFG_ITEM_TIMER_CALLBACK, // T9 // 5
+ MBTK_ECALL_CFG_ITEM_TIMER_CLEARDOWN, // T2
+ MBTK_ECALL_CFG_ITEM_TIMER_DEREG, // T10
+ MBTK_ECALL_CFG_ITEM_TIMER_DIAL, // "dial"
+ MBTK_ECALL_CFG_ITEM_TIMER_REDIAL, // "redialtmr"
+ MBTK_ECALL_CFG_ITEM_TIMER_SMS, // "sms" // 10
+ MBTK_ECALL_CFG_ITEM_REDIALCNT, // "redialcnt"
+ MBTK_ECALL_CFG_ITEM_SMSPROCESS, // "smsprocess"
+ MBTK_ECALL_CFG_ITEM_SMSMSDCNT, // "smsmsdcnt"
+
+ MBTK_ECALL_CFG_ITEM_MAX
+} mbtk_ecall_cfg_item_enum;
+
+
+typedef enum {
+ MBTK_ECALL_MSD_ITEM_VERSION = 0,
+ MBTK_ECALL_MSD_ITEM_MSG_ID,
+ MBTK_ECALL_MSD_ITEM_CONTROLTYPE,
+ MBTK_ECALL_MSD_ITEM_VIN,
+ MBTK_ECALL_MSD_ITEM_STORAGETYPE,
+ MBTK_ECALL_MSD_ITEM_TIMESTAMP,
+ MBTK_ECALL_MSD_ITEM_LOCATION,
+ MBTK_ECALL_MSD_ITEM_DIRECTION,
+ MBTK_ECALL_MSD_ITEM_LOCATIONN1,
+ MBTK_ECALL_MSD_ITEM_LOCATIONN2,
+ MBTK_ECALL_MSD_ITEM_NUMBEROFOCCUPANTS,
+ MBTK_ECALL_MSD_ITEM_ADDITIONALDATA,
+ MBTK_ECALL_MSD_ITEM_ALL_IN_ONE,
+ MBTK_ECALL_MSD_ITEM_ASI,
+ MBTK_ECALL_MSD_ITEM_VEHICLE_DIAGNOSTIC,
+ MBTK_ECALL_MSD_ITEM_CRASH_INFO,
+ MBTK_ECALL_MSD_ITEM_GNSS_TYPE
+} mbtk_ecall_msd_item_enum;
+
+typedef enum {
+ MBTK_ECALL_ONLY_TYPE_DISABLE = 0,
+ MBTK_ECALL_ONLY_TYPE_ENABLE_ECALL,
+ MBTK_ECALL_ONLY_TYPE_ENABLE_NG_ECALL,
+ MBTK_ECALL_ONLY_TYPE_ENABLE_ALL,
+ MBTK_ECALL_ONLY_TYPE_CONF_NUM,
+ MBTK_ECALL_ONLY_TYPE_NORMAL
+} mbtk_ecall_only_type_enum;
+
+typedef struct
+{
+ mbtk_ecall_msd_item_enum item_type;
+
+ uint8 data[64];
+} mbtk_ecall_msd_cfg_info_t;
+
+typedef enum {
+ MBTK_ECALL_SIM_TYPE_NO_SUPPORT = 0,
+ MBTK_ECALL_SIM_TYPE_SUPPORT_ECALL,
+ MBTK_ECALL_SIM_TYPE_SUPPORT_ECALL_ONLY
+} mbtk_ecall_sim_type_enum;
+
+
+typedef struct {
+ mbtk_ecall_only_type_enum active : 8;
+ mbtk_ecall_sim_type_enum sim_type : 8; // Only for GET.
+ uint8 test_num[RIL_MAX_NUMBER_LEN];
+ uint8 reconfig_num[RIL_MAX_NUMBER_LEN];
+} mbtk_ecall_only_info_t;
+
+typedef enum {
+ MBTK_ECALL_MODE_TYPE_EU = 0,
+ MBTK_ECALL_MODE_TYPE_ERA
+} mbtk_ecall_mode_type_enum;
+
+
+typedef enum {
+ MBTK_ECALL_DIAL_TYPE_TEST = 0,
+ MBTK_ECALL_DIAL_TYPE_RECONFIG,
+ MBTK_ECALL_DIAL_TYPE_MANUALLY,
+ MBTK_ECALL_DIAL_TYPE_AUTO,
+ MBTK_ECALL_DIAL_TYPE_NOT_ACTIVATED,
+ MBTK_ECALL_DIAL_TYPE_RELEASE
+} mbtk_ecall_dial_type_enum;
+
+typedef struct {
+ uint32 type; // mbtk_ecall_cfg_item_enum
+
+#if 0
+ uint32 timer_t3; // ms
+ uint32 timer_t5; // ms
+ uint32 timer_t6; // ms
+ uint32 timer_t7; // ms
+ uint32 timer_th; // ms
+
+ uint32 timer_callback; // s (T9)
+ uint32 timer_cleardown; // s (T2)
+ uint32 timer_dereg; // s (T10)
+ uint32 timer_dial; // s
+ uint32 timer_redialtmr; // s
+ uint32 timer_sms; // s
+
+ uint32 redialcnt;
+ uint32 smsprocess;
+ uint32 smsmsdcnt;
+#else
+ uint8 data_valid[MBTK_ECALL_CFG_ITEM_MAX];
+ uint32 data[MBTK_ECALL_CFG_ITEM_MAX];
+#endif
+} mbtk_ecall_cfg_info_t;
+
+
+typedef struct
+{
+ uint8 urc_id;
+ uint8 urc_data[5];
+} mbtk_ril_ecall_state_info_t;
+
+
+typedef mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
+static mbtk_info_handle_get mbtk_info_handle_get_ptr = NULL;
+
+typedef int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle);
+static mbtk_info_handle_free mbtk_info_handle_free_ptr = NULL;
+
+static gsw_eu_ecall_status_cb_f gsw_eu_ecall_status_cb;
+
+static pthread_t gsw_ecall_status_cb_thread;
+static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
+static bool g_thread_running = false;
+
+static uint32_t g_sta_cb_id = 0;
+static gsw_eu_ecall_msd_trans_status_e g_msd_send_status = 0;
+
+#define LIB_PATH "/lib/libmbtk_lib.so"
+
+
+
+
+
+
+typedef int (*mbtk_ecall_msd_set)(mbtk_info_handle_t* handle, const void* msd);
+static mbtk_ecall_msd_set mbtk_ecall_msd_set_ptr = NULL;
+
+typedef int (*mbtk_ecall_push)(mbtk_info_handle_t* handle);
+static mbtk_ecall_push mbtk_ecall_push_ptr = NULL;
+
+typedef int (*mbtk_ecall_only_set)(mbtk_info_handle_t* handle, const mbtk_ecall_only_info_t* info);
+static mbtk_ecall_only_set mbtk_ecall_only_set_ptr = NULL;
+
+
+typedef int (*mbtk_ecall_reg_set)(mbtk_info_handle_t* handle, int reg);
+static mbtk_ecall_reg_set mbtk_ecall_reg_set_ptr = NULL;
+
+typedef int (*mbtk_ecall_dial_start)(mbtk_info_handle_t* handle, mbtk_ecall_dial_type_enum type);
+static mbtk_ecall_dial_start mbtk_ecall_dial_start_ptr = NULL;
+
+typedef int (*mbtk_ecall_mode_set)(mbtk_info_handle_t* handle, mbtk_ecall_mode_type_enum mode);
+static mbtk_ecall_mode_set mbtk_ecall_mode_set_ptr = NULL;
+
+
+typedef int (*mbtk_ecall_cfg_set)(mbtk_info_handle_t* handle, const mbtk_ecall_cfg_info_t *cfg);
+static mbtk_ecall_cfg_set mbtk_ecall_cfg_set_ptr = NULL;
+
+typedef int (*mbtk_ecall_cfg_get)(mbtk_info_handle_t* handle, mbtk_ecall_cfg_info_t* cfg);
+static mbtk_ecall_cfg_get mbtk_ecall_cfg_get_ptr = NULL;
+
+typedef int (*mbtk_ecall_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
+static mbtk_ecall_state_change_cb_reg mbtk_ecall_state_change_cb_reg_ptr = NULL;
+
+typedef int (*mbtk_call_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
+static mbtk_call_state_change_cb_reg mbtk_call_state_change_cb_reg_ptr = NULL;
+
+
+
+static int state_t = -1;
+
+
+
+typedef struct
+{
+ uint8 call_wait;
+ uint8 dir1;
+ uint8 dir;
+ uint8 state;
+ uint8 mode;
+ uint8 mpty;
+ char phone_number[100];
+ uint8 type;
+ uint8 pas;
+ uint8 disconnected_id;
+ uint8 end_reason[128];
+} __attribute__((packed)) mbtk_call_info_t;
+
+
+//static mbtk_info_handle_t* ecall_info_handle = NULL;
+
+
+typedef void (*mbtk_log_init)(char *path, char *tag);
+static mbtk_log_init mbtk_log_init_ptr = NULL;
+
+static void *handle = NULL;
+typedef void (*mbtk_log)(int level, const char *format,...);
+static mbtk_log fun_ptr_log = NULL;
+static int ecall_init_flag = 0;
+static mbtk_info_handle_t* ecall_info_handle = NULL;
+
+
+
+static uint8_t fail_redial = 1;
+
+static gsw_eu_ecall_event_cb_f gsw_eu_ecall_event_cb = NULL;
+static bool g_setevent_cb = false;
+
+static void mbtk_send_singnal()
+{
+ pthread_mutex_lock(&g_mutex);
+ pthread_cond_signal(&g_cond);
+ pthread_mutex_unlock(&g_mutex);
+
+}
+
+static void mbtk_wait_signal()
+{
+
+ pthread_mutex_lock(&g_mutex);
+ pthread_cond_wait(&g_cond, &g_mutex);
+ pthread_mutex_unlock(&g_mutex);
+}
+
+static void mbtk_ecall_api_ptr_deinit()
+{
+ dlclose(handle);
+ handle = NULL;
+ mbtk_log_init_ptr = NULL;
+ mbtk_info_handle_get_ptr=NULL;
+ mbtk_info_handle_free_ptr=NULL;
+ mbtk_ecall_msd_set_ptr=NULL;
+ mbtk_ecall_push_ptr=NULL;
+ mbtk_ecall_only_set_ptr=NULL;
+ mbtk_ecall_reg_set_ptr=NULL;
+ mbtk_ecall_dial_start_ptr=NULL;
+ mbtk_ecall_mode_set_ptr=NULL;
+ mbtk_ecall_cfg_set_ptr=NULL;
+ mbtk_ecall_cfg_get_ptr=NULL;
+ mbtk_ecall_state_change_cb_reg_ptr=NULL;
+ gsw_eu_ecall_status_cb=NULL;
+ gsw_eu_ecall_event_cb=NULL;
+ g_setevent_cb=false;
+ mbtk_ecall_only_set_ptr = NULL;
+ fun_ptr_log=NULL;
+
+}
+
+
+static int mbtk_ecall_api_import()
+{
+ handle = dlopen(LIB_PATH, RTLD_NOW);
+ if (handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(fun_ptr_log == NULL)
+ {
+ fun_ptr_log = (mbtk_log)dlsym(handle, "mbtk_log");
+ if(fun_ptr_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_log_init_ptr == NULL)
+ {
+ mbtk_log_init_ptr = (mbtk_log_init)dlsym(handle, "mbtk_log_init");
+ if(mbtk_log_init_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_info_handle_get_ptr == NULL)
+ {
+ mbtk_info_handle_get_ptr = (mbtk_info_handle_get)dlsym(handle, "mbtk_info_handle_get");
+ if(mbtk_info_handle_get_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_info_handle_free_ptr == NULL)
+ {
+ mbtk_info_handle_free_ptr = (mbtk_info_handle_free)dlsym(handle, "mbtk_info_handle_free");
+ if(mbtk_info_handle_free_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+
+
+ if(mbtk_ecall_msd_set_ptr == NULL)
+ {
+ mbtk_ecall_msd_set_ptr = (mbtk_ecall_msd_set)dlsym(handle, "mbtk_ecall_msd_set");
+ if(mbtk_ecall_msd_set_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_ecall_push_ptr == NULL)
+ {
+ mbtk_ecall_push_ptr = (mbtk_ecall_push)dlsym(handle, "mbtk_ecall_push");
+ if(mbtk_ecall_push_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ if(mbtk_ecall_only_set_ptr == NULL)
+ {
+ mbtk_ecall_only_set_ptr = (mbtk_ecall_only_set)dlsym(handle, "mbtk_ecall_only_set");
+ if(mbtk_ecall_only_set_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_ecall_reg_set_ptr == NULL)
+ {
+ mbtk_ecall_reg_set_ptr = (mbtk_ecall_reg_set)dlsym(handle, "mbtk_ecall_reg_set");
+ if(mbtk_ecall_reg_set_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ if(mbtk_ecall_dial_start_ptr == NULL)
+ {
+ mbtk_ecall_dial_start_ptr = (mbtk_ecall_dial_start)dlsym(handle, "mbtk_ecall_dial_start");
+ if(mbtk_ecall_dial_start_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_ecall_mode_set_ptr == NULL)
+ {
+ mbtk_ecall_mode_set_ptr = (mbtk_ecall_mode_set)dlsym(handle, "mbtk_ecall_mode_set");
+ if(mbtk_ecall_mode_set_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_ecall_cfg_set_ptr == NULL)
+ {
+ mbtk_ecall_cfg_set_ptr = (mbtk_ecall_cfg_set)dlsym(handle, "mbtk_ecall_cfg_set");
+ if(mbtk_ecall_cfg_set_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ if(mbtk_ecall_cfg_get_ptr == NULL)
+ {
+ mbtk_ecall_cfg_get_ptr = (mbtk_ecall_cfg_get)dlsym(handle, "mbtk_ecall_cfg_get");
+ if(mbtk_ecall_cfg_get_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ if(mbtk_ecall_state_change_cb_reg_ptr == NULL)
+ {
+ mbtk_ecall_state_change_cb_reg_ptr = (mbtk_ecall_state_change_cb_reg)dlsym(handle, "mbtk_ecall_state_change_cb_reg");
+ if(mbtk_ecall_state_change_cb_reg_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ if(mbtk_call_state_change_cb_reg_ptr == NULL)
+ {
+ mbtk_call_state_change_cb_reg_ptr = (mbtk_call_state_change_cb_reg)dlsym(handle, "mbtk_call_state_change_cb_reg");
+ if(mbtk_call_state_change_cb_reg_ptr == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+static void gsw_call_state_change_cb(const void *data, int data_len)
+{
+ mbtk_call_info_t *reg = (mbtk_call_info_t *)data;
+ switch (reg->call_wait)
+ {
+ case MBTK_CLCC:
+ {
+ LOGD("RING : %d, %d, %d, %d, %d, %s, %d, %d", reg->dir1, reg->dir, reg->state, reg->mode, reg->mpty, reg->phone_number, reg->type, reg->disconnected_id);
+ switch(reg->state)
+ {
+ case 0:
+ state_t = 0;
+ LOGD("reg->state = GSW_VOICE_CALL_CONNECTED ");
+ break;
+ case 1:
+ //state_t = GSW_VOICE_CALL_HOLDING;
+ LOGD("reg->state = GSW_VOICE_CALL_HOLDING ");
+ break;
+ case 2:
+ //state_t = GSW_VOICE_CALL_DIALING;
+ LOGD("reg->state = GSW_VOICE_CALL_DIALING ");
+ break;
+ case 3:
+ //state_t = GSW_VOICE_CALL_ALERTING;
+ LOGD("reg->state = GSW_VOICE_CALL_ALERTING ");
+ break;
+ case 4:
+ //state_t = GSW_VOICE_CALL_INCOMING;
+
+ LOGD("reg->state = GSW_VOICE_CALL_INCOMING ");
+ break;
+ case 5:
+ //state_t = GSW_VOICE_CALL_WAITING;
+ LOGD("reg->state = GSW_VOICE_CALL_WAITING ");
+ break;
+ case 6:
+ //state_t = GSW_VOICE_CALL_END;
+ LOGD("reg->state = GSW_VOICE_CALL_END ");
+ break;
+ }
+
+ g_sta_cb_id = reg->dir1;
+ }
+
+ break;
+ default:
+ LOGE("RING : None call_wait = %d", reg->call_wait);
+ break;
+ }
+}
+
+
+/**
+* @brief init the Europe Ecall voice
+* @param [in] None
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+
+int32_t gsw_eu_ecall_voice_init(void)
+{
+ int ret =-1;
+ ret = mbtk_ecall_api_import();
+ if(ret <0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init_ptr("syslog", "GSW_ECALL");
+
+ ecall_info_handle = mbtk_info_handle_get_ptr();
+ if(ecall_info_handle == NULL)
+ {
+ LOGE("mbtk_info_handle_get_ptr fail!!!");
+ return GSW_HAL_FAIL;
+ }
+
+ if(ecall_init_flag == 0)
+ {
+ ecall_init_flag = 1;
+ }
+ ret = mbtk_call_state_change_cb_reg_ptr(ecall_info_handle, gsw_call_state_change_cb);
+ if(ret < 0)
+ {
+ LOGE("mbtk_call_state_change_cb_reg_ptr failed");
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+/**
+* @brief deinit the Europe Ecall voice
+* @param [in] None
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_eu_ecall_voice_deinit(void)
+{
+ int ret = -1;
+ if(ecall_info_handle == NULL || ecall_init_flag ==0)
+ {
+ LOGE("No init can not deinit");
+ return GSW_HAL_FAIL;
+ }
+
+ g_thread_running = false;
+ mbtk_send_singnal();
+ if (gsw_ecall_status_cb_thread != 0)
+ {
+ pthread_cancel(gsw_ecall_status_cb_thread);
+ pthread_join(gsw_ecall_status_cb_thread, NULL);
+ gsw_ecall_status_cb_thread = 0;
+ }
+
+ ret = mbtk_info_handle_free_ptr(&ecall_info_handle);
+ if(ret < 0 )
+ {
+ LOGE("mbtk_info_handle_free handle faile");
+ }
+ ecall_info_handle = NULL;
+ ecall_init_flag = 0;
+
+ mbtk_ecall_api_ptr_deinit();
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+/**
+* @brief start a Europe Ecall
+* @param [in] gsw_eu_ecall_info_t *p_info: ecall info
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_eu_ecall_start(gsw_eu_ecall_info_t *p_info)
+{
+ int ret = -1;
+ mbtk_ecall_dial_type_enum ecall_type= -1;
+ mbtk_ecall_only_info_t only_info;
+
+
+ char tmp_number[GSW_EU_ECALL_MAX_PHONE_NUMBER] = {0};
+
+ char msd_data[500] = {0};
+
+ memset(&only_info, 0, sizeof(mbtk_ecall_only_info_t));
+
+ if(ecall_init_flag !=1)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(p_info == NULL || p_info->msd_len > GSW_EU_ECALL_MAX_MSD )
+ {
+ return GSW_HAL_FAIL;
+ }
+
+
+ if(p_info->type == GSW_EU_ECALL_TYPE_TEST)
+ {
+ //AT+CECALL =0
+ ecall_type = MBTK_ECALL_DIAL_TYPE_TEST;
+ snprintf(tmp_number,sizeof(tmp_number),"%s",p_info->ecall_number);
+ strncpy((char *)only_info.test_num,tmp_number,RIL_MAX_NUMBER_LEN);
+ //snprintf((char*)only_info.test_num,sizeof(only_info.test_num),"%s",p_info->ecall_number);
+ }
+
+ if(p_info->type == GSW_EU_ECALL_TYPE_RECONFIG )
+ {
+ //AT+CECALL =1
+ ecall_type = MBTK_ECALL_DIAL_TYPE_RECONFIG;
+ snprintf(tmp_number,sizeof(tmp_number),"%s",p_info->ecall_number);
+ strncpy((char *)only_info.test_num,tmp_number,RIL_MAX_NUMBER_LEN);
+ }
+
+ if(p_info->type == GSW_EU_ECALL_TYPE_EMERGENCY )
+ {
+ if(p_info->auto_trigger)
+ {
+ //AT+CECALL =1
+ ecall_type = MBTK_ECALL_DIAL_TYPE_AUTO;
+ }
+ else
+ {
+ //AT+CECALL =1
+ ecall_type = MBTK_ECALL_DIAL_TYPE_MANUALLY;//手动
+ }
+
+ }
+
+ //msd
+ for (int i = 0; i < p_info->msd_len; i++)
+ {
+ sprintf(msd_data + (i * 2), "%02x", p_info->msd[i]);
+ }
+
+ //
+ only_info.active = MBTK_ECALL_ONLY_TYPE_DISABLE ;
+
+ ret=mbtk_ecall_only_set_ptr(ecall_info_handle,&only_info);
+ if (ret != 0)
+ {
+ LOGE("mbtk_ecall_only_set_success failed");
+ return GSW_HAL_FAIL;
+ }
+
+ //set msd
+ ret= mbtk_ecall_msd_set_ptr(ecall_info_handle,(const void*)msd_data);
+ if (ret != 0)
+ {
+ LOGE("mbtk_ecall_msd_set_ptr failed");
+ return GSW_HAL_FAIL;
+ }
+
+ //dial
+ ret= mbtk_ecall_dial_start_ptr(ecall_info_handle,ecall_type);
+ if (ret != 0)
+ {
+ LOGE("mbtk_ecall_dial_start_ptr failed");
+ return GSW_HAL_FAIL;
+ }
+
+ //push mst
+ ret= mbtk_ecall_push_ptr(ecall_info_handle);
+ if (ret != 0)
+ {
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE;
+ mbtk_send_singnal();
+ LOGE("mbtk_ecall_push_ptr failed");
+ return GSW_HAL_FAIL;
+ }
+
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
+ mbtk_send_singnal();
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+/**
+* @brief hangup a Europe Ecall
+* @param [in] None
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_eu_ecall_hangup(void)
+{
+ int32_t ret = -1;
+ if(ecall_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_ecall_dial_start_ptr(ecall_info_handle,MBTK_ECALL_DIAL_TYPE_RELEASE);
+ if(ret != 0)
+ {
+ LOGE("hangup ecall faile ");
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief using push mode send msd data
+* @param [in] GSW_EU_ECALL_STATE_E state: ecall state
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+
+int32_t gsw_eu_ecall_updateMsd(const uint8_t *msd, uint32_t msd_len)
+{
+ int ret = -1;
+ char msd_data[500] = {0};
+
+ if(msd == NULL || msd_len == 0 ||ecall_info_handle == NULL)
+ {
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ //msd
+ for (int i = 0; i < msd_len; i++)
+ {
+ sprintf(msd_data + i * 2, "%02x", *(msd + i));
+ }
+ ret = mbtk_ecall_msd_set_ptr(ecall_info_handle,(const void*)msd_data);
+ if (ret != 0)
+ {
+ LOGE("mbtk_ecall_msd_get_ptr failed");
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+int32_t gsw_eu_ecall_pushMsd(gsw_eu_ecall_state_e state)
+{
+ int ret = -1;
+ if(ecall_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_ecall_push_ptr(ecall_info_handle);
+ if(ret != 0)
+ {
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE;
+ mbtk_send_singnal();
+ return GSW_HAL_FAIL;
+ }
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
+ mbtk_send_singnal();
+ return GSW_HAL_SUCCESS;
+
+
+}
+
+/**
+* @brief get ecall config
+* @param [in] None
+* @param [out] gsw_eu_ecall_config_t *p_config: ecall config
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_eu_ecall_getConfig(gsw_eu_ecall_config_t *p_config)
+{
+
+ if(ecall_info_handle==NULL || p_config == NULL)
+ {
+ LOGE("mbtk_ecall_cfg_get() fail.");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ p_config->fail_redial = fail_redial;
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set ecall config
+* @param [in] int32_t item: config item
+* @param [in] gsw_eu_ecall_config_t *p_config: config info
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+
+int32_t gsw_eu_ecall_setConfig(int32_t item, gsw_eu_ecall_config_t *p_config)
+{
+ if(ecall_info_handle == NULL || p_config == NULL)
+ {
+ LOGE("gsw_eu_ecall_setConfig no init");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ mbtk_ecall_cfg_info_t cfg_info = {0};
+
+ int ret =-1;
+ cfg_info.type = 0;
+
+ if(item & GSW_EU_ECALL_CONFIG_FAIL_REDIAL)
+ {
+ fail_redial = p_config->fail_redial;
+ if(p_config->fail_redial)
+ {
+ cfg_info.type |= MBTK_ECALL_CFG_TIMER_DIAL;
+ cfg_info.data[MBTK_ECALL_CFG_ITEM_TIMER_DIAL] = 60000;//timer 60s
+
+ }
+ else
+ {
+ cfg_info.type |= MBTK_ECALL_CFG_TIMER_DIAL;
+ cfg_info.data[MBTK_ECALL_CFG_ITEM_TIMER_DIAL] = 0;
+ }
+ }
+
+ ret = mbtk_ecall_cfg_set_ptr(ecall_info_handle, &cfg_info);
+ if (ret < 0)
+ {
+ LOGE("mbtk_ecall_cfg_set_ptr fail");
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+
+static void mbtk_ecall_state_change_cb(const void* data, int data_len)
+{
+ static gsw_eu_ecall_event_t event;
+ if(data)
+ {
+ mbtk_ril_ecall_state_info_t *ecall_data = (mbtk_ril_ecall_state_info_t*)data;
+ switch(ecall_data->urc_id)
+ {
+ case MBTK_ECALL_URC_ID_MSD_REQ:
+ {
+ LOGD("MBTK_ECALL_URC_ID_MSD_REQ");
+ event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_START_RECEIVED_MSD;
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_PSAP_REQURE_UPDATE_MSD;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_NONE;
+ break;
+ }
+ case MBTK_ECALL_URC_ID_MSD_SEND_START:
+ {
+ LOGD("MBTK_ECALL_URC_ID_MSD_SEND_START");
+
+ event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_START_RECEIVED_MSD;
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_PSAP_REQURE_UPDATE_MSD;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_NONE;
+ break;
+ }
+ case MBTK_ECALL_URC_ID_NACK:
+ {
+ LOGD("MBTK_ECALL_URC_ID_NACK");
+
+ event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_NACK_RECEIVED;
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_NONE;
+ break;
+ }
+ case MBTK_ECALL_URC_ID_LLACK:
+ {
+ LOGD("MBTK_ECALL_URC_ID_LLACK");
+
+ event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_ACK_RECEIVED;
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_IVS_LLACK_RECEIVED;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
+ mbtk_send_singnal();
+ break;
+ }
+ case MBTK_ECALL_URC_ID_HLACK:
+ {
+ LOGD("MBTK_ECALL_URC_ID_HLACK");
+ event.fail = GSW_EU_ECALL_EVENT_FAIL_NONE;
+ event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_HLACK_RECEIVED;
+
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
+ mbtk_send_singnal();
+ break;
+ }
+ case MBTK_ECALL_URC_ID_ALACK:
+ {
+ LOGD("MBTK_ECALL_URC_ID_ALACK");
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_IVS_ALACK_RECEIVED;
+ }
+ case MBTK_ECALL_URC_ID_MSD_UPDATE_DONE:
+ {
+ LOGD("MBTK_ECALL_URC_ID_MSD_UPDATE_DONE");
+ event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_NONE;
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
+
+ }
+ case MBTK_ECALL_URC_ID_T5_EXPIRED:
+ case MBTK_ECALL_URC_ID_T6_EXPIRED:
+ case MBTK_ECALL_URC_ID_T7_EXPIRED:
+ {
+ LOGD("MBTK_ECALL_URC_ID_T5_EXPIRED | MBTK_ECALL_URC_ID_T5_EXPIRED | MBTK_ECALL_URC_ID_T7_EXPIRED");
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_IVS_UPDATE_MSD_TIMEOUT;
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
+ g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE;
+ mbtk_send_singnal();
+ break;
+ }
+ case MBTK_ECALL_URC_ID_3GPP_FATAL:
+ case MBTK_ECALL_URC_ID_GENERIC:
+ {
+ LOGD("MBTK_ECALL_URC_ID_GENERIC|MBTK_ECALL_URC_ID_3GPP_FATAL");
+ event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
+ }
+ case MBTK_ECALL_URC_ID_MSD_UPDATE_ERR:
+ {
+ LOGD("MBTK_ECALL_URC_ID_MSD_UPDATE_ERR");
+ event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_IVS_UPDATE_MSD_TIMEOUT;
+
+ }
+ default:
+ {
+
+ LOGE("No process urc_id : %d", ecall_data->urc_id);
+ break;
+ }
+ }
+
+ }
+ if(gsw_eu_ecall_event_cb)
+ {
+ gsw_eu_ecall_event_cb(&event);
+ }
+}
+
+
+/**
+ * @brief register the ecall status callback
+* @param [in] gsw_eu_ecall_status_cb_f cb:callback
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_eu_ecall_setEventCB(gsw_eu_ecall_event_cb_f cb)
+{
+ int ret = -1;
+ if(ecall_info_handle==NULL)
+ {
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ gsw_eu_ecall_event_cb = cb;
+ if(!g_setevent_cb)
+ {
+ ret = mbtk_ecall_state_change_cb_reg_ptr(ecall_info_handle, mbtk_ecall_state_change_cb);
+ if(ret < 0)
+ {
+
+ LOGE("mbtk_ecall_state_change_cb_reg_ptr failed");
+ return GSW_HAL_FAIL;
+ }
+ g_setevent_cb = true;
+ }
+
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+
+static void* ecall_msd_status_cb_thread(void* arg)
+{
+ while(g_thread_running)
+ {
+ mbtk_wait_signal();
+ if(g_thread_running == false)
+ {
+ return NULL;
+ }
+ if(gsw_eu_ecall_status_cb)
+ {
+ gsw_eu_ecall_status_cb(g_sta_cb_id,g_msd_send_status);
+ }
+
+ }
+ return NULL;
+}
+
+/**
+* @brief register the ecall status callback
+* @param [in] gsw_eu_ecall_status_cb_f cb:callback
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_eu_ecall_setStatusCB(gsw_eu_ecall_status_cb_f cb)
+{
+ int ret = -1;
+ if(ecall_info_handle==NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ gsw_eu_ecall_status_cb = cb;
+ if (!g_thread_running)
+ {
+ ret = pthread_create(&gsw_ecall_status_cb_thread, NULL, ecall_msd_status_cb_thread, NULL);
+ if(ret < 0)
+ {
+ LOGE("pthread_create failed");
+ g_thread_running = false;
+ return GSW_HAL_FAIL;
+ }
+ g_thread_running = true;
+ }
+
+ return GSW_HAL_SUCCESS;
+
+}
diff --git a/mbtk/libgsw_lib/gsw_gnss.c b/mbtk/libgsw_lib/gsw_gnss.c
new file mode 100755
index 0000000..7beb0d1
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_gnss.c
@@ -0,0 +1,567 @@
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <termios.h>
+#include <time.h>
+#include <sys/ioctl.h>
+#include <dlfcn.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "gsw_gnss.h"
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+#define GSW_HAL_SUCCESS 0
+#define GSW_HAL_FAIL -1 //表示失败(通用性)
+#define GSW_HAL_MEM_INVAILD -2 //表示入参地址为NULL
+
+#define MOPEN_GNSS_NMEA_MAX_LENGTH 255 /** NMEA string maximum length. */
+static gsw_gnss_cb *gsw_cb = NULL;
+static bool inited = false;
+static bool strated = false;
+
+typedef void (*mbtk_gnss_callback_func)(uint32_t ind_type, const void* data, uint32_t data_len);
+typedef void (*mbtk_log)(int level, const char *format,...);
+static mbtk_log fun_ptr_log = NULL;
+
+int (*mbtk_gnss_init)(mbtk_gnss_callback_func cb);
+int (*mbtk_gnss_deinit)();
+
+int (*mbtk_gnss_ind_set)(uint32_t ,int);
+int (*mbtk_gnss_open)(int, int);
+int (*mbtk_gnss_close)(int);
+int (*mbtk_gnss_setting)(const char *setting_cmd, int);
+
+int (*mbtk_gnss_eph_download)(int);
+int (*mbtk_gnss_eph_inject)(int);
+
+int gnss_freq = -1;
+GSW_GNSS_MODE_CONFIGURATION gnss_startmode = -1;
+GSW_GNSS_CONF_SWITCH gnss_switch_op = -1;
+void *dlHandle_gnss;
+char *lynqLib_gnss = "/lib/libmbtk_lib.so";
+
+typedef enum
+{
+ E_MT_LOC_MSG_ID_LOCATION_INFO = 1, /**< pv_data = & mopen_location_info_t */
+ E_MT_LOC_MSG_ID_NMEA_INFO = 3, /**< pv_data = & mopen_gnss_nmea_info_t */
+} e_msg_id_t;
+
+typedef struct
+{
+ int64_t timestamp; /**< System Timestamp, marked for when got the nmea data */
+ int length; /**< NMEA string length. */
+ char nmea[MOPEN_GNSS_NMEA_MAX_LENGTH + 1]; /**< NMEA string.*/
+}mopen_gnss_nmea_info_t; /* Message */
+
+typedef struct
+{
+ uint32_t size; /**< Set to the size of mcm_gps_location_t. */
+ int flags; /**< Contains GPS location flags bits. */
+ int position_source; /**< Provider indicator for HYBRID or GPS. */ //功能暂未实现，可不用添加进结构体
+ double latitude; /**< Latitude in degrees. */
+ double longitude; /**< Longitude in degrees. */
+ double altitude; /**< Altitude in meters above the WGS 84 reference ellipsoid. */
+ float speed; /**< Speed in meters per second. */
+ float bearing; /**< Heading in degrees. */ //功能暂未实现，可不用添加进结构体
+ float accuracy; /**< Expected accuracy in meters. */ //功能暂未实现，可不用添加进结构体
+ int64_t timestamp; /**< Timestamp for the location fix in UTC million-second base. */
+ int32_t is_indoor; /**< Location is indoors. */ //功能暂未实现，可不用添加进结构体
+ float floor_number; /**< Indicates the floor number. */
+}mopen_location_info_t;//功能暂未实现，可不用添加进结构体
+
+
+typedef struct {
+ uint32_t flags;
+ double latitude; /**< Latitude in degrees. */
+ double longitude; /**< Longitude in degrees. */
+ double altitude; /**< Altitude in meters above the WGS 84 reference ellipsoid. */
+ float speed; /**< Speed in meters per second. */
+ float bearing; /**< Heading in degrees. */
+ int64_t timestamp; /**< Timestamp for the location fix in UTC million-second base. */
+} mbtk_gnss_location_info_t;
+
+typedef enum{
+ MODE_GPS = 1, /**< GPS only */
+ MODE_BEIDOU, /**< BEIDOU only*/
+ MODE_GPS_BEIDOU, /**< GPS+BEIDOU */
+ MODE_GLONASS, /**< GLONASS only */
+ MODE_GPS_GLONASS, /**< GPS+GLONASS */
+ MODE_GLONASS_BEIDOU, /**< GLONASS+BEIDOU */ /* The type does not support this type */
+ MODE_GPS_GLONASS_BEIDOU, /**< GPS+GLONASS+BEIDOU */ /* The type does not support this type */
+ MODE_GALILEO, /**< GALILEO only */
+ MODE_GPS_GALILEO, /**< GPS+GALILEO */
+ MODE_BEIDOU_GALILEO, /**< BEIDOU+GALILEO */
+ MODE_GPS_BEIDOU_GALILEO, /**< GPS+BEIDOU+GALILEO */
+ MODE_GLONASS_GALILEO, /**< GLONASS+GALILEO */
+ MODE_GPS_GLONASS_GALILEO, /**< GPS+GLONASS+GALILEO */
+ MODE_BEIDOU_GLONASS_GALILEO, /**< BEIDOU+GLONASS+GALILEO */ /* The type does not support this type */
+ MODE_END = -1, /**< init value */
+}GSW_GNSS_MODE_CONFIGURATION_HD;
+
+
+GSW_GNSS_MODE_CONFIGURATION_HD map_gnss_mode(GSW_GNSS_MODE_CONFIGURATION mode)
+{
+ switch (mode)
+ {
+ case GSW_MODE_GPS_GLONASS:
+ return MODE_GPS_GLONASS;
+ case GSW_MODE_GPS_BEIDOU:
+ return MODE_GPS_BEIDOU;
+ case GSW_MODE_GPS_GLONASS_BEIDOU:
+ return MODE_END;
+ case GSW_MODE_GPS:
+ return MODE_GPS;
+ case GSW_MODE_BEIDOU:
+ return MODE_BEIDOU;
+ case GSW_MODE_GLONASS:
+ return MODE_GLONASS;
+ case GSW_MODE_GPS_GLONASS_BEIDOU_GALILEO:
+ return MODE_END;
+ case GSW_MODE_GPS_GALILEO:
+ return MODE_GPS_GALILEO;
+ case GSW_MODE_GPS_GLONASS_GALILEO:
+ return MODE_GPS_GLONASS_GALILEO;
+ case GSW_MODE_GPS_GALILEO_ONLY:
+ return MODE_GALILEO;
+ case GSW_MODE_GPS_GLONASS_BEIDOU_GALILEO_NAVIC:
+ return MODE_END;
+ case GSW_MODE_GNSS_END:
+ return MODE_END;
+ default:
+ return MODE_END;
+ }
+}
+
+int mbtk_gnss_set_VTG()
+{
+ int ret;
+ char param_buf[32] = {0};
+ snprintf(param_buf, 32, "$MSGCFG,2,1000");
+ mbtk_gnss_setting=(int(*)(const char *setting_cmd, int))dlsym(dlHandle_gnss, "mbtk_gnss_setting");
+ ret = mbtk_gnss_setting(param_buf, QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_setting fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to set gnss sampling frequency, support 1Hz、2Hz、5Hz
+ * @param [in] freq
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_set_freq(int freq)
+{
+ int ret;
+ if (!strated)
+ {
+ gnss_freq = freq;
+ return GSW_HAL_SUCCESS;
+ }
+ char param_buf[32] = {0};
+ snprintf(param_buf, 32, "$FREQCFG,%d", freq);
+ mbtk_gnss_setting=(int(*)(const char *setting_cmd, int))dlsym(dlHandle_gnss, "mbtk_gnss_setting");
+ ret = mbtk_gnss_setting(param_buf, QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_setting fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to set gnss start mode,specific mode refreence GSW_HAL_GNSS_MODE_CONFIGURATION
+ * @param [in] start_mode
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_set_start_mode(GSW_GNSS_MODE_CONFIGURATION start_mode)
+{
+ int ret;
+ if (!strated)
+ {
+ gnss_startmode = start_mode;
+ return GSW_HAL_SUCCESS;
+ }
+ char param_buf[32] = {0};
+ snprintf(param_buf, 32, "$SYSCFG,%d", map_gnss_mode(start_mode));
+ if(map_gnss_mode(start_mode) == -1)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_start_mode con't support");
+ return GSW_HAL_FAIL;
+ }
+ mbtk_gnss_setting=(int(*)(const char *setting_cmd, int))dlsym(dlHandle_gnss, "mbtk_gnss_setting");
+ ret = mbtk_gnss_setting(param_buf, QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_setting fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to set EPO switch if open or close
+ * @param [in] switch_op
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_epo_switch(GSW_GNSS_CONF_SWITCH switch_op)
+{
+ int ret;
+ if (!strated)
+ {
+ gnss_switch_op = switch_op;
+ return GSW_HAL_SUCCESS;
+ }
+
+ if(switch_op)
+ {
+ mbtk_gnss_eph_download=(int(*)(int))dlsym(dlHandle_gnss, "mbtk_gnss_eph_download");
+ ret = mbtk_gnss_eph_download(QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_eph_download fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ mbtk_gnss_eph_inject=(int(*)(int))dlsym(dlHandle_gnss, "mbtk_gnss_eph_inject");
+ ret = mbtk_gnss_eph_inject(QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_eph_inject fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+static void gnss_callback(uint32_t ind_type, const void* data, uint32_t data_len)
+{
+ if(data == NULL || data_len <= 0)
+ {
+ LOGE("[GSW_gnss] data is NULL.");
+ return;
+ }
+
+ if(gsw_cb == NULL)
+ {
+ //LOGE("[qser_gnss] qser_gnss_callback is NULL.");
+ return;
+ }
+
+ if(ind_type == MBTK_GNSS_IND_LOCATION) {
+ if(data_len != sizeof(mbtk_gnss_location_info_t))
+ {
+ LOGE("[GSW_gnss] data size error");
+ return;
+ }
+ GSW_GNSS_LOCATION_EXT_T gsw_location;
+ GSW_GNSS_LOCATION_T gsw_location_t;
+ mbtk_gnss_location_info_t *locl_info = (mbtk_gnss_location_info_t *)data;
+ gsw_location_t.altitude = locl_info->altitude;
+ gsw_location_t.latitude = locl_info->latitude;
+ gsw_location_t.longitude = locl_info->longitude;
+ gsw_location_t.speed = locl_info->speed;
+ gsw_location_t.bearing = locl_info->bearing;
+ gsw_location_t.timestamp = locl_info->timestamp;
+ gsw_location.legacyLocation = gsw_location_t;
+ gsw_cb->gsw_location_cb(&gsw_location);
+ } else if(ind_type == MBTK_GNSS_IND_NMEA) {
+ mopen_gnss_nmea_info_t qser_nmea = {0};
+ memset(&qser_nmea, 0x0, sizeof(mopen_gnss_nmea_info_t));
+ qser_nmea.length = data_len;
+ memcpy(qser_nmea.nmea, (char *)data, data_len);
+ //qser_nmea.timestamp = qser_get_gnss_time_sec(data, data_len);
+ gsw_cb->gsw_nmea_cb(data,data_len);
+ } else {
+ LOGD("Unknown IND : %d\n", ind_type);
+ }
+}
+
+int gsw_gnss_init(void)
+{
+ int ret;
+ if(!inited)
+ {
+ dlHandle_gnss = dlopen(lynqLib_gnss, RTLD_NOW);
+ fun_ptr_log = (mbtk_log)dlsym(dlHandle_gnss, "mbtk_log");
+ if(fun_ptr_log == NULL || dlHandle_gnss == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ mbtk_gnss_init=(int(*)(mbtk_gnss_callback_func))dlsym(dlHandle_gnss, "mbtk_gnss_init");
+ ret = mbtk_gnss_init(gnss_callback);
+ if(ret == 0)
+ {
+ mbtk_gnss_ind_set=(int(*)(uint32_t ,int))dlsym(dlHandle_gnss, "mbtk_gnss_ind_set");
+ ret = mbtk_gnss_ind_set(MBTK_GNSS_IND_NMEA, QSER_GNSS_TIMEOUT);
+ if(ret == 0)
+ {
+ inited = true;
+ }
+ else
+ {
+ LOGE("[GSW_gnss] init mbtk_gnss_ind_set() fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ }
+ else
+ {
+ LOGE("[GSW_gnss] mbtk_gnss_init() fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to registered callback function
+ * @param [in] callback
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_reg_cb_group(gsw_gnss_cb callback)
+{
+ if(callback.gsw_location_cb == NULL && callback.gsw_nmea_cb == NULL)
+ {
+ LOGE("[GSW_gnss] handler_ptr is NULL.");
+ return GSW_HAL_FAIL;
+ }
+ if (gsw_cb == NULL)
+ {
+ gsw_cb = (gsw_gnss_cb *)malloc(sizeof(gsw_gnss_cb));
+ if (gsw_cb == NULL)
+ {
+ LOGE("[GSW_gnss] Memory allocation failed.");
+ return GSW_HAL_FAIL;
+ }
+ }
+ gsw_cb->gsw_location_cb = callback.gsw_location_cb;
+ gsw_cb->gsw_nmea_cb = callback.gsw_nmea_cb;
+ return GSW_HAL_SUCCESS;
+}
+/**
+ * @brief SDK interface to start gnss
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_start(void)
+{
+ int ret;
+ mbtk_gnss_open=(int(*)(int,int))dlsym(dlHandle_gnss, "mbtk_gnss_open");
+ ret = mbtk_gnss_open(255, QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[GSW_gnss] mbtk_gnss_open is error.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ strated = true;
+ if (gnss_freq > 0)
+ gsw_gnss_set_freq(gnss_freq);
+ if (gnss_startmode >= 0)
+ gsw_gnss_set_start_mode(gnss_startmode);
+ if (gnss_switch_op > 0)
+ gsw_gnss_epo_switch(gnss_switch_op);
+
+ mbtk_gnss_set_VTG();
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to stop gnss
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_stop(void)
+{
+ int ret;
+ mbtk_gnss_close=(int(*)(int))dlsym(dlHandle_gnss, "mbtk_gnss_close");
+ ret = mbtk_gnss_close(QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[GSW_gnss] mbtk_gnss_close is error.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ strated = false;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to de initialization gnss
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_deinit(void)
+{
+ int ret;
+ if(inited)
+ {
+ mbtk_gnss_deinit=(int(*)())dlsym(dlHandle_gnss, "mbtk_gnss_deinit");
+ ret = mbtk_gnss_deinit();
+ if(ret == 0)
+ {
+ inited = false;
+ }
+ else
+ {
+ LOGE("[GSW_gnss] mbtk_gnss_init() fail.ret = [%d]", ret);
+ dlclose(dlHandle_gnss);
+ dlHandle_gnss = NULL;
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ dlclose(dlHandle_gnss);
+ dlHandle_gnss = NULL;
+ gnss_freq = -1;
+ gnss_startmode = -1;
+ gnss_switch_op = -1;
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief SDK interface to enable XTRA switch
+ * @param [in] state
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_xtra_is_enable(gsw_xtra_state_e state)
+{
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief SDK interface to delete aiding data,delete aiding data for cold start(1-H,2-W,3-C)
+ * @param [in] switch_op
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_delete_aiding_data(unsigned int flags) /*1-don`t delete == hot_start ; 2-delete EPH == warm start ; 3-delete all == cold start*/
+{
+ int ret;
+ char param_buf[32] = {0};
+ snprintf(param_buf, 32, "$RESET,%u", flags);
+ mbtk_gnss_setting=(int(*)(const char *setting_cmd, int))dlsym(dlHandle_gnss, "mbtk_gnss_setting");
+ ret = mbtk_gnss_setting(param_buf, QSER_GNSS_TIMEOUT);
+ if(ret != 0)
+ {
+ LOGE("[qser_gnss] mbtk_gnss_setting fail.ret = [%d]", ret);
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief init and configure gps
+ * @param [in] init_configure
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_gnss_init_configure_gps(gsw_gnss_init_configure_t init_configure)
+{
+ return GSW_HAL_SUCCESS;
+}
diff --git a/mbtk/libgsw_lib/gsw_gpio.c b/mbtk/libgsw_lib/gsw_gpio.c
new file mode 100755
index 0000000..9bd8a79
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_gpio.c
@@ -0,0 +1,379 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdint.h>
+#include <string.h>
+#include <dlfcn.h>
+
+#include "gsw_gpio.h"
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+#define GSW_HAL_SUCCESS 0
+#define GSW_HAL_FAIL -1 //表示失败(通用性)
+#define GSW_HAL_MEM_INVAILD -2 //表示入参地址为NULL
+
+#define wakeout 117
+
+typedef void (*mbtk_log)(int level, const char *format,...);
+static mbtk_log fun_ptr_log = NULL;
+void *dlHandle_gpio = NULL;
+char *lynqLib_gpio = "/lib/libmbtk_lib.so";
+
+int gpio_check(int gpio)
+{
+ char buffer[128];
+ memset(buffer,0,128);
+ sprintf(buffer,"/sys/class/gpio/gpio%d/direction", gpio);
+ return access(buffer , F_OK);
+}
+
+static int handle()
+{
+ if(dlHandle_gpio == NULL || fun_ptr_log == NULL)
+ {
+ dlHandle_gpio = dlopen(lynqLib_gpio, RTLD_NOW);
+ fun_ptr_log = (mbtk_log)dlsym(dlHandle_gpio, "mbtk_log");
+ if(fun_ptr_log == NULL || dlHandle_gpio == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+static int gpio_export(int gpio)
+{
+ int file=-1;
+ int result =-1;
+ char pin_index_buffer[5]= {0};
+
+ if (gpio_check(gpio) == 0)
+ {
+ LOGE("export has been add\n");
+ return 0;
+ }
+
+ file = open("/sys/class/gpio/export",O_WRONLY);
+ if(file == -1)
+ {
+ LOGE("Open gpio export file fail.");
+ return -1;
+ }
+
+ memset(pin_index_buffer,0,5);
+ sprintf(pin_index_buffer,"%d", gpio);
+ result = write(file,pin_index_buffer,strlen(pin_index_buffer));
+ if(result < 0)
+ {
+ LOGE("Gpio[%d] export fail.", gpio);
+ close(file);
+ return -1;
+ }
+ close(file);
+
+ return 0;
+}
+
+static int gpio_unexport(int gpio)
+{
+ int file=-1;
+ int result =-1;
+ char pin_index_buffer[5]= {0};
+ if (gpio_check(gpio) == -1)
+ {
+ LOGE("export has been not add\n");
+ return -1;
+ }
+
+ file = open("/sys/class/gpio/unexport",O_WRONLY);
+ if(file == -1)
+ {
+ LOGE("Open gpio unexport file fail.");
+ return -1;
+ }
+
+ memset(pin_index_buffer,0,5);
+ sprintf(pin_index_buffer,"%d", gpio);
+ result=write(file,pin_index_buffer,strlen(pin_index_buffer));
+ if(result < 0)
+ {
+ close(file);
+ LOGE("Gpio[%d] unexport fail.", gpio);
+ return -1;
+ }
+ close(file);
+
+ return 0;
+}
+
+int32_t gsw_gpio_SetDirection(uint32_t gpioNum, gsw_hal_pinDirection dir)
+{
+ char buffer[128]= {0};
+ int file =-1;
+ int result =-1;
+ char direction[10] = {0};
+ memset(buffer,0,128);
+ if (handle())
+ return GSW_HAL_FAIL;
+
+ if (gpio_check(gpioNum) == -1)
+ {
+ LOGD("in dir export has been not add\n");
+ gpio_export(gpioNum);
+ }
+
+
+ sprintf(buffer,"/sys/class/gpio/gpio%u/direction", gpioNum);
+ file = open(buffer, O_WRONLY);
+ if(file == -1)
+ {
+ LOGE("Open gpio[%d] direct fail.", gpioNum);
+ return -1;
+ }
+ if (dir == GSW_HAL_PINDIR_IN)
+ sprintf(direction,"in");
+ else if (dir == GSW_HAL_PINDIR_OUT)
+ sprintf(direction,"out");
+
+ result = write(file,direction,strlen(direction));
+ if(result != strlen(direction))
+ {
+ LOGE("Set gpio[%d] direct fail.", gpioNum);
+ close(file);
+ gpio_unexport(gpioNum);
+ return GSW_HAL_FAIL;
+ }
+ close(file);
+ gpio_unexport(gpioNum);
+ return GSW_HAL_SUCCESS;
+}
+
+gsw_hal_pinLevel gsw_gpio_GetLevel(uint32_t gpioNum)
+{
+ char buffer[50];
+ char path[128];
+ int file =-1;
+ int result =-1;
+ memset(path,0,128);
+ memset(buffer,0,50);
+ if (handle())
+ return GSW_HAL_FAIL;
+
+ if (gpio_check(gpioNum) == -1)
+ {
+ LOGD("in get value export has been not add\n");
+ gpio_export(gpioNum);
+ }
+ sprintf(path,"/sys/class/gpio/gpio%u/value", gpioNum);
+ file = open(path,O_RDONLY);
+ if(file == -1)
+ {
+ LOGE("Open gpio[%d] fail.", gpioNum);
+ return -1;
+ }
+ result = read(file,buffer,50);
+ if(result <= 0)
+ {
+ LOGE("Get gpio[%d] value fail", gpioNum);
+ close(file);
+ gpio_unexport(gpioNum);
+ return GSW_HAL_FAIL;
+ }
+ close(file);
+ gpio_unexport(gpioNum);
+ return atoi(buffer);
+}
+
+int32_t gsw_gpio_SetLevel(uint32_t gpioNum, gsw_hal_pinLevel level)
+{
+ char buffer[128]= {0};
+ int file =-1;
+ int result =-1;
+ memset(buffer,0,50);
+ if (handle())
+ return GSW_HAL_FAIL;
+
+ if (gpio_check(gpioNum) == -1)
+ {
+ LOGD("in set value export has been not add\n");
+ gpio_export(gpioNum);
+ }
+
+ sprintf(buffer,"/sys/class/gpio/gpio%u/value", gpioNum);
+ file = open(buffer,O_WRONLY);
+ if(file == -1)
+ {
+ LOGE("Open gpio[%d] value fail.", gpioNum);
+ return -1;
+ }
+ if(level == GSW_HAL_LEVEL_LOW) {
+ result = write(file,"0",1);
+ } else {
+ result = write(file,"1",1);
+ }
+ if(result != 1)
+ {
+ LOGE("Set gpio[%d] value fail err =%d.", gpioNum, errno);
+ close(file);
+ gpio_unexport(gpioNum);
+ return GSW_HAL_FAIL;
+ }
+ close(file);
+ gpio_unexport(gpioNum);
+ return GSW_HAL_SUCCESS;
+}
+
+
+int32_t gsw_gpio_Init(uint32_t gpioNum, gsw_hal_pinDirection dir, gsw_hal_pinLevel level, gsw_hal_pinPullSel pullsel)
+{
+ if (handle())
+ return GSW_HAL_FAIL;
+
+ if (dir != 1 && dir != 0)
+ {
+ LOGE("[lynq_gpio_init] direction fail.");
+ return -1;
+ }
+
+ if (level != 1 && level != 0)
+ {
+ LOGE("[lynq_gpio_init] value fail.");
+ return GSW_HAL_FAIL;
+ }
+
+ if(gpio_export(gpioNum))
+ {
+ LOGE("[lynq_gpio_init]gpio_export fail.");
+ return GSW_HAL_FAIL;
+ }
+
+ if(gsw_gpio_SetDirection(gpioNum, dir))
+ {
+ LOGE("[lynq_gpio_init]gpio_direct_set fail.");
+ return GSW_HAL_FAIL;
+ }
+
+ if(dir == 1 && (gsw_gpio_SetLevel(gpioNum, level) != 0))
+ {
+ LOGE("[lynq_gpio_init]gpio_value_set fail.");
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+gsw_hal_usbStatus gsw_hwpin_is_usb_connected(void)
+{
+ FILE *fp;
+ char cmd[128] = {0};
+ char tmp_rsp[20] = {0};
+ //char *CONNECTED = "configured";
+ char *DISCONNECTED = "not attached";
+ if (handle())
+ return GSW_HAL_FAIL;
+
+ sprintf(cmd,"cat /sys/devices/platform/soc/d4200000.axi/c0000000.usb/udc/c0000000.usb/state");
+ fp=popen(cmd, "r");
+ if (fgets(tmp_rsp,sizeof(tmp_rsp),fp) == NULL)
+ LOGE("gsw_hwpin_is_usb_connected fail.");
+ pclose(fp);
+ if (strncmp(tmp_rsp,DISCONNECTED,strlen(DISCONNECTED)) == 0)
+ return GSW_HAL_USB_DISCONNECTED;
+ else
+ return GSW_HAL_USB_CONNECTED;
+}
+
+int32_t gsw_setWakeupLevel(gsw_hal_pinLevel level)
+{
+ if (gsw_gpio_SetLevel(wakeout, level) == GSW_HAL_FAIL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
diff --git a/mbtk/libgsw_lib/gsw_nw.c b/mbtk/libgsw_lib/gsw_nw.c
new file mode 100755
index 0000000..e485574
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_nw.c
@@ -0,0 +1,2572 @@
+#include "gsw_nw_interface.h"
+#include <dlfcn.h>
+#include <time.h>
+#include <pthread.h>
+
+//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
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+
+typedef unsigned int uint32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+
+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
+{
+ // 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;
+ uint32 value2;
+ uint32 value3;
+ uint32 value4;
+ uint32 value5;
+ uint32 value6;
+ uint32 value7;
+ uint32 value8;
+ uint32 value9;
+ uint32 value10;
+} __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
+} __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 GSW_HAL_FAIL GSW_HAL_NORMAL_FAIL
+#define GSW_HAL_MEM_INVAILD GSW_HAL_ARG_INVALID
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+mbtk_info_handle_t* nw_info_handle = NULL;
+
+static GSW_NW_ServingInfoHandlePtr serving_cb;
+static GSW_NW_SigInfoHandlePtr sig_cb;
+static GSW_NW_RejectCauseHandlePtr reject_cb;
+static GSW_NW_ModemStateHandlePtr modem_cb;
+
+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);
+
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+
+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;
+
+static int mbtk_nw_api_import()
+{
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+ if (mbtk_info_handle_get == NULL)
+ {
+ LOGE("mbtk_info_handle_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_info_handle_free dlsym fail\n");
+ return GSW_HAL_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("mbtk_net_sel_mode_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_net_reg_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_get_modem_fun dlsym fail\n");
+ return GSW_HAL_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("mbtk_set_modem_fun dlsym fail\n");
+ return GSW_HAL_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("mbtk_current_band_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_current_band_set dlsym fail\n");
+ return GSW_HAL_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("mbtk_net_signal_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_wakeup_state_set dlsym fail\n");
+ return GSW_HAL_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("mbtk_cell_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_signal_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_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("mbtk_net_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_fplmn_get = (int(*)(mbtk_info_handle_t *handle, void *fplmn))dlsym(dlHandle_mbtk, "mbtk_fplmn_get");
+ if (mbtk_fplmn_get == NULL)
+ {
+ LOGE("mbtk_fplmn_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_fplmn_set = (int(*)(mbtk_info_handle_t *handle, void *fplmn))dlsym(dlHandle_mbtk, "mbtk_fplmn_set");
+ if (mbtk_fplmn_set == NULL)
+ {
+ LOGE("mbtk_fplmn_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_radio_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_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("mbtk_oos_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_oos_set dlsym fail\n");
+ return GSW_HAL_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("node is not null\n");
+ list->cur_array_data = list->cur_array_data->next;
+ list->cur_index++;
+ return node->data;
+ } else {
+ LOGE("node is null\n");
+ return NULL;
+ }
+ } else {
+ LOGE("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);
+ }
+}
+
+static int gsw_rssi_to_csq(int rssi)
+{
+ LOGD("rssi = %d\n",rssi);
+ if(rssi >= -113 && rssi <= -51)
+ {
+ return (rssi + 113) / 2;
+ }
+
+ else
+ {
+ return 99;
+ }
+}
+
+static int gsw_rscp_to_csq(int rscp)
+{
+ LOGD("rscp = %d\n",rscp);
+ if(rscp <= -25 && rscp > -120)
+ {
+ return rscp + 120;
+ }
+ else
+ {
+ return 255;
+ }
+
+}
+
+static int gsw_rsrp_to_csq(int rsrp)
+{
+ LOGD("rsrp = %d\n",rsrp);
+
+ if(rsrp <= -44 && rsrp > -140)
+ {
+ return rsrp + 140;
+ }
+
+ else
+ {
+ return 255;
+ }
+}
+
+static int rscp_convert_to_dBm(int rscp)
+{
+ if(rscp <= 96 && rscp >= 0)
+ {
+ return rscp - 120;
+ }
+ else
+ {
+ return -25;
+ }
+}
+
+
+static int8_t rssi_convert_to_dBm(uint8 rssi)
+{
+ if(rssi <= 31)
+ {
+ return rssi * 2 - 113;
+ }
+ else
+ {
+ return -125;
+ }
+}
+
+static int16_t rsrp_convert_to_dBm(uint8 rsrp)
+{
+ if(rsrp <= 96)
+ {
+ return rsrp - 140;
+ }
+ else
+ {
+ return -44;
+ }
+}
+
+static int16_t rsrq_convert_to_dB(uint8 rsrq)
+{
+ if(rsrq >= 1 && rsrq <= 34)
+ {
+ return (rsrq + 1) / 2 - 20;
+ }
+ else
+ {
+ return -20;
+ }
+}
+
+static int16_t ecno_convert_to_dB(uint8 ecno)
+{
+ if(ecno >= 48)
+ {
+ return 0;
+ }
+ else if(ecno == 255)
+ {
+ return 255;
+ }
+ else
+ {
+ return 48 - ecno;
+ }
+}
+
+
+static int convert_reg_state(int reg_state_t)
+{
+ LOGD("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("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("config = %d\n");
+
+ 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("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("entry = %s, mcc = %s, mnc = %s\n", entry, mcc, mnc);
+}
+
+
+static void update_fplmn_list(char *fplmn_str)
+{
+ LOGE("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("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("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("result = %s, numStr = %s\n",result, plmn_entry);
+
+ if (strlen(result) >= 2) {
+ char temp = result[0];
+ result[0] = result[1];
+ result[1] = temp;
+ }
+
+ LOGE("1.result = %s\n",result);
+
+ if (strlen(result) >= 3) {
+ memmove(&result[3], &result[2], strlen(result) - 2 + 1);
+ result[2] = 'F';
+ }
+
+ LOGE("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("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("%s\n", temp_fplmn_str);
+ strncpy(fplmn_str, temp_fplmn_str, strlen(temp_fplmn_str));
+ LOGE("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("index = %d\n", i);
+ return i;
+ }
+ }
+
+ LOGE("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 gsw_serving_info_callback_thread()
+{
+ GSW_NW_SERVING_INFO *serving_info = (GSW_NW_SERVING_INFO*)malloc(sizeof(GSW_NW_SERVING_INFO));
+ memset(serving_info, 0x0, sizeof(GSW_NW_SERVING_INFO));
+ int ret = -1;
+ ret = gsw_get_nwinfo(serving_info);
+ if(ret != 0)
+ {
+ LOGE("gsw_get_nwinfo failed\n");
+ free(serving_info);
+ return;
+ }
+
+ if(serving_cb)
+ {
+ serving_cb(*serving_info);
+ free(serving_info);
+ }
+}
+
+static void gsw_serving_info_callback(const void* data, int data_len)
+{
+ LOGE("gsw_serving_info_callback start\n");
+
+ if(data && data_len > 0)
+ {
+ pthread_t thread;
+ pthread_create(&thread, NULL, (void*)gsw_serving_info_callback_thread, NULL);
+ }
+
+ else
+ {
+ LOGE("data is NULL\n");
+ return;
+ }
+
+}
+
+static void gsw_sig_info_callback(const void* data, int data_len)
+{
+ LOGE("gsw_sig_info_callback start\n");
+
+ if(data && data_len == 8)
+ {
+ uint8 *net_data = (uint8*)data;
+ mbtk_radio_technology_enum type = (mbtk_radio_technology_enum)net_data[0];
+
+ signalStrength_t sig_strength;
+ memset(&sig_strength, 0x0, sizeof(signalStrength_t));
+
+ sig_strength.gw_sig_valid = 0;
+ sig_strength.wcdma_sig_valid = 0;
+ sig_strength.lte_sig_valid = 0;
+ sig_strength.nr_sig_valid = 0;
+
+ if(type == MBTK_RADIO_TECH_GSM || type == MBTK_RADIO_TECH_GSM_COMPACT || \
+ type == MBTK_RADIO_TECH_GSM_EGPRS) //GSM
+ {
+ sig_strength.gw_sig_valid = 1;
+ sig_strength.rssi = rssi_convert_to_dBm(net_data[1]);
+ }
+
+ else if(type == MBTK_RADIO_TECH_E_UTRAN)
+ {
+ sig_strength.lte_sig_valid = 1;
+ sig_strength.rsrp = rsrp_convert_to_dBm(net_data[7]);
+ sig_strength.rsrq = rsrq_convert_to_dB(net_data[6]);
+ sig_strength.rssnr = -99;
+ }
+
+ else if (type == MBTK_RADIO_TECH_UTRAN || type == MBTK_RADIO_TECH_UTRAN_HSDPA || \
+ type == MBTK_RADIO_TECH_UTRAN_HSUPA || type == MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA || \
+ type == MBTK_RADIO_TECH_UTRAN_HSPA )//WCDMA
+ {
+ sig_strength.wcdma_sig_valid = 1;
+ sig_strength.rscp = rssi_convert_to_dBm(net_data[1]);
+ sig_strength.ecno = ecno_convert_to_dB(net_data[5]);
+ }
+
+ if(sig_cb != NULL)
+ {
+ sig_cb(sig_strength);
+ }
+ }
+
+ else
+ {
+ LOGE("data is NULL\n");
+ }
+}
+
+static void gsw_modem_status_event_callback(const void* data, int data_len)
+{
+ LOGE("gsw_modem_status_event_callback start\n");
+
+ gsw_mode_state_e state = GSW_MODEM_STATE_UNKNOWN;
+
+ if(data && data_len > 0)
+ {
+ uint8 *net_data = (uint8*)data;
+ LOGE("gsw_modem_status_event_callback,data = %d\n", *net_data);
+ if(*net_data == 1)
+ {
+ state = GSW_MODEM_STATE_ONLINE;
+ }
+ else if(*net_data == 0)
+ {
+ state = GSW_MODEM_STATE_OFFLINE;
+ }
+
+ if(modem_cb != NULL)
+ {
+ modem_cb(state);
+ }
+ }
+
+}
+
+static void gsw_reject_callback(GSW_NW_RADIO_ACCESS_TECH_E rat, GSW_SERVICE_DOMAIN_E domain, int cause)
+{
+ LOGE("gsw_reject_callback start,rat = %d,domain = %d,cause = %d\n",rat,domain,cause);
+
+ GSW_NW_REJ_CAUSE_E *rej_cause = (GSW_NW_REJ_CAUSE_E*)malloc(sizeof(GSW_NW_REJ_CAUSE_E));
+ memset(rej_cause, 0x0, sizeof(GSW_NW_REJ_CAUSE_E));
+
+ rej_cause->rej_cause = cause;
+ rej_cause->rej_rat = rat;
+ rej_cause->rej_domain = domain;
+
+ if(reject_cb != NULL)
+ {
+ LOGE("reject_cb is not NULL\n");
+ reject_cb(rej_cause);
+ }
+ else
+ {
+ LOGE("reject_cb is NULL\n");
+ }
+
+ free(rej_cause);
+ LOGE("gsw_reject_callback end\n");
+}
+
+
+
+/**
+ * @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_FAIL;
+ }
+
+ if(handle_ptr == NULL)
+ {
+ LOGE("handle_ptr is NULL\n");
+ return GSW_HAL_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_FAIL;
+ }
+
+ if(handle_ptr == NULL)
+ {
+ LOGE("handle_ptr is NULL\n");
+ return GSW_HAL_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_FAIL;
+ }
+
+ if(handle_ptr == NULL)
+ {
+ LOGE("handle_ptr is NULL\n");
+ return GSW_HAL_FAIL;
+ }
+
+ reject_cb = handle_ptr;
+
+ 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)
+{
+ int ret = -1;
+
+ if (nw_init_flag == 1 && nw_info_handle != NULL)
+ {
+ return GSW_HAL_SUCCESS;
+ }
+
+ ret = mbtk_nw_api_import();
+ if (ret != 0)
+ {
+ LOGE("mbtk_nw_api_import fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ nw_info_handle = mbtk_info_handle_get();
+
+ if (nw_info_handle == NULL)
+ {
+ LOGE("mbtk_info_handle_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ char fplmn[256] = {0};
+ ret = mbtk_fplmn_get(nw_info_handle, fplmn);
+ if(ret != 0)
+ {
+ LOGE("mbtk_fplmn_get failed : %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+ fplmn_max_length = (strlen(fplmn)/6);
+ LOGE("fplmn = %s, fplmn_max_length = %d\n",fplmn,fplmn_max_length);
+ ret = mbtk_signal_state_change_cb_reg(nw_info_handle, gsw_sig_info_callback);
+
+ if (ret != 0)
+ {
+ LOGE("mbtk_signal_state_change_cb_reg fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_net_state_change_cb_reg(nw_info_handle, gsw_serving_info_callback);
+ if (ret != 0)
+ {
+ LOGE("mbtk_net_state_change_cb_reg fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ nw_init_flag = 1;
+
+ 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_FAIL;
+ }
+
+ ret = mbtk_info_handle_free(&nw_info_handle);
+ if(ret != GSW_HAL_SUCCESS)
+ {
+ LOGE("mbtk_info_handle_free fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ dlclose(dlHandle_mbtk);
+ nw_info_handle = NULL;
+ nw_init_flag = 0;
+
+ 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;
+ LOGE("gsw_get_nwinfo start\n");
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ LOGE("nw_sdk_deinit not init\n");
+ return GSW_HAL_FAIL;
+ }
+
+ LOGE("mbtk_net_reg_get start \n");
+ //regstate
+ mbtk_net_reg_info_t reg;
+ memset(®, 0x0, sizeof(mbtk_net_reg_info_t));
+ ret = mbtk_net_reg_get(nw_info_handle, ®);
+ if(ret)
+ {
+ LOGE("mbtk_net_reg_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ LOGE("convert_cs_reg_state\n");
+ //cs_state
+ serving_info->reg_state = convert_reg_state(reg.call_state);
+ LOGE("convert_ps_reg_state\n");
+ //ps_state
+ serving_info->ps_state = convert_reg_state(reg.data_state);
+ LOGE("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("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("reject\n");
+ //reject
+ if(serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_DENIED || serving_info->reg_state == GSW_NETWORK_REG_REGISTRATION_DENIED)
+ {
+ LOGD("reject_callback\n");
+ gsw_reject_callback(serving_info->reg_rat,serving_info->srv_domain,99);
+ }
+
+ LOGD("reg_plmn / operator name\n");
+ //reg_plmn / operator name
+ mbtk_net_info_t net;
+ memset(&net, 0x0, sizeof(mbtk_net_info_t));
+ LOGD("mbtk_net_sel_mode_get start \n");
+ ret = mbtk_net_sel_mode_get(nw_info_handle, &net);
+ LOGD("mbtk_net_sel_mode_get end \n");
+ if(ret == 0 && net.plmn > 0)
+ {
+ int i = 0;
+
+ LOGD("start to find mcc");
+ while(i < ARRAY_SIZE(lynq_operator_mcc_mnc))
+ {
+ if(lynq_operator_mcc_mnc[i].lynq_mcc_mnc == net.plmn)
+ {
+ LOGD("find mcc\n");
+ break;
+ }
+ i++;
+ }
+
+
+ if(i == ARRAY_SIZE(lynq_operator_mcc_mnc))
+ {
+ LOGD("not find mcc");
+ strcpy(serving_info->operator_name, "unknown");
+ sprintf(serving_info->reg_plmn, "%d", net.plmn);
+ }
+
+ else
+ {
+ LOGD("find mcc\n");
+ strcpy(serving_info->operator_name, lynq_operator_mcc_mnc[i].lynq_operator_l);
+ sprintf(serving_info->reg_plmn, "%d", net.plmn);
+ }
+
+ LOGE("operator_name = %s\n", serving_info->operator_name);
+ LOGE("reg_plmn = %s\n", serving_info->reg_plmn);
+ }
+
+
+ LOGD("get cell id/tac/lac/sid/nid\n");
+ //cell id/tac/lac/sid/nid
+ mbtk_cell_type_enum cell_type;
+ if(serving_info->reg_rat == GSW_NETWORK_RADIO_GSM)
+ {
+ cell_type = MBTK_CELL_TYPE_GSM;
+ }
+ else if(serving_info->reg_rat == GSW_NETWORK_RADIO_UMTS)
+ {
+ cell_type = MBTK_CELL_TYPE_UMTS;
+ }
+ else
+ {
+ cell_type = MBTK_CELL_TYPE_LTE;
+ }
+
+ list_node_t* cell_list = NULL;
+
+ LOGD("mbtk_cell_get start\n");
+ ret = mbtk_cell_get(nw_info_handle, &cell_type, &cell_list);
+ if(ret != 0 || cell_list == NULL)
+ {
+ LOGE("mbtk_cell_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_cell_get end,start to get node\n");
+ list_first(cell_list);
+ LOGE("list_first end\n");
+ mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list);
+ if(cell)
+ {
+ LOGE("cell is not null,value2 = %u\n",cell->value2);
+ switch(cell_type)
+ {
+ case MBTK_CELL_TYPE_LTE:
+ {
+ LOGE("is lte\n");
+ //LOGE("LTE : tac=%x, PCI=%x, dlEuarfcn=%x, ulEuarfcn=%x, band=%x\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
+ LOGE("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),"%d",cell->value1);
+ strcpy(serving_info->lac,"");
+ snprintf(serving_info->cell_id,sizeof(serving_info->cell_id),"%d",cell->value8);
+ break;
+ }
+
+ case MBTK_CELL_TYPE_GSM:
+ {
+ LOGE("is gsm\n");
+ LOGE("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell->value1, cell->value2, cell->value3, cell->value4);
+ sprintf(serving_info->lac,"%d",cell->value1);
+ memset(serving_info->tac,0,sizeof(serving_info->tac));
+ sprintf(serving_info->cell_id,"%d",cell->value2);
+ break;
+ }
+ case MBTK_CELL_TYPE_UMTS:
+ {
+ LOGE("is wcdma\n");
+ LOGE("UMTS : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3);
+ sprintf(serving_info->lac,"%d",cell->value1);
+ memset(serving_info->tac,0,sizeof(serving_info->tac));
+ sprintf(serving_info->cell_id,"%d",cell->value2);
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ LOGE("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(int *netype)
+{
+ int ret = -1;
+
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ //regstate
+ mbtk_net_reg_info_t reg;
+ ret = mbtk_net_reg_get(nw_info_handle, ®);
+ if(ret)
+ {
+ LOGE("mbtk_net_reg_get fail\n");
+ return GSW_HAL_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_FAIL;
+ }
+
+ ret = mbtk_get_modem_fun(nw_info_handle, &tmp_rf);
+ if (ret != 0)
+ {
+ LOGE("mbtk_get_modem_fun fail\n");
+ return GSW_HAL_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(int 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_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("Input mode is error!\n");
+ return GSW_HAL_FAIL;
+ }
+
+ info.fun = rf_mode;
+ info.rst = 0;
+ ret = mbtk_set_modem_fun(nw_info_handle, &info);
+ if (ret != 0)
+ {
+ LOGE("gsw_set_opmode fail\n");
+ return GSW_HAL_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(int *mode_pref)
+{
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_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("mbtk_current_band_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ *mode_pref = convert_gsw_net_config(band.net_pref);
+ LOGE("band.net_pref = %d\n", *mode_pref);
+ if(*mode_pref <= 0)
+ {
+ LOGE("no support mode\n");
+ return GSW_HAL_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(int mode_pref)
+{
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_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("band.net_pref = %d\n", band.net_pref);
+
+ if(band.net_pref < 0)
+ {
+ LOGE("no support mode\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_current_band_set(nw_info_handle, &band);
+ if(ret != 0)
+ {
+ LOGE("mbtk_current_band_set fail\n");
+ return GSW_HAL_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(int *csq_value)
+{
+ int ret = -1;
+
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_signal_info_t signal;
+ memset(&signal, 0x0, sizeof(mbtk_signal_info_t));
+ ret = mbtk_net_signal_get(nw_info_handle, &signal);
+ if(ret != 0)
+ {
+ LOGE("mbtk_net_signal_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ LOGD("signal.type=%d\n", signal.type);
+ switch(signal.type)
+ {
+ case MBTK_RADIO_TECH_GSM:
+ case MBTK_RADIO_TECH_GSM_COMPACT:
+ case MBTK_RADIO_TECH_GSM_EGPRS:
+ {
+ LOGD("rssi = %d\n",signal.rssi);
+ *csq_value = rssi_convert_to_dBm(signal.rssi);
+ break;
+ }
+ case MBTK_RADIO_TECH_E_UTRAN:
+ {
+ LOGD("rsrp = %d\n",signal.rsrp);
+ *csq_value = rsrp_convert_to_dBm(signal.rsrp);
+ 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("rscp = %d\n",signal.rscp);
+ *csq_value = rscp_convert_to_dBm(signal.rscp);
+ break;
+ }
+ default:
+ {
+ LOGD("[%s] unknown reg type.[%d]\n", __func__, signal.type);
+ return GSW_HAL_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_network_set_power_mode(char mode)
+{
+ int ret = -1;
+
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(mode != 0 && mode != 1)
+ {
+ LOGE("Input mode is error!\n");
+ return GSW_HAL_FAIL;
+ }
+
+ if(mode == 1)
+ {
+ mode = 6;
+ }
+
+ ret = mbtk_wakeup_state_set(nw_info_handle, mode);
+ if(ret != 0)
+ {
+ LOGE("mbtk_wakeup_state_set fail\n");
+ return GSW_HAL_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(int netType, int sigValue)
+{
+ switch(netType)
+ {
+ case 1:
+ case 2:
+ case 3:
+ case 4: //GSM
+ {
+ return gsw_rssi_to_csq(sigValue);
+ }
+
+ case 5: //WCDMA
+ {
+ return gsw_rscp_to_csq(sigValue);
+ }
+
+ case 6: //LTE
+ {
+ return gsw_rsrp_to_csq(sigValue);
+ }
+
+ default:
+ {
+ LOGE("parameter error\n");
+ return GSW_HAL_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] = {0};
+ mbtk_net_info_t net;
+
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(!mbtk_net_sel_mode_get(nw_info_handle, &net) && net.plmn > 0)
+ {
+ LOGE("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);
+
+ memset(temp,0,12);
+ memset(nw_operator_name_infos->mcc,0,4);
+ sprintf(temp, "%d", (lynq_operator_mcc_mnc[i].lynq_mcc_mnc)/100);
+ strncpy(nw_operator_name_infos->mcc, temp, strlen(temp));
+
+ memset(temp,0,12);
+ memset(nw_operator_name_infos->mnc,0,4);
+ sprintf(temp, "%d", (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("mbtk_net_sel_mode_get fail\n");
+ return GSW_HAL_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)
+{
+ int ret = -1;
+
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ LOGE("nw_sdk_deinit not init\n");
+ return GSW_HAL_FAIL;
+ }
+
+ list_node_t* cell_list = NULL;
+ int neibor_count = 0;
+ mbtk_cell_type_enum type;
+ ret = mbtk_cell_get(nw_info_handle, &type, &cell_list);
+ if(ret || cell_list == NULL) {
+ LOGE("mbtk_cell_get failed : %d\n", ret);
+ } else {
+ 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("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell->value1, cell->value2, cell->value3, cell->value4);
+ char gsm_temp[12] = {0};
+
+ cell_info->rat = GSW_NETWORK_RADIO_GSM;
+
+ cell_info->mcc_valid = 1;
+ snprintf(gsm_temp, sizeof(gsm_temp) ,"%d", cell->value5);
+ strncpy(cell_info->mcc, gsm_temp, sizeof(cell_info->mcc));
+
+ memset(gsm_temp, 0, sizeof(gsm_temp));
+
+ cell_info->mnc_valid = 1;
+ snprintf(gsm_temp, sizeof(gsm_temp) ,"%d", 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;
+
+ break;
+ }
+
+ case 1:
+ {
+ LOGD("UMTS : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3);
+ char wcdma_temp[12] = {0};
+
+ cell_info->rat = GSW_NETWORK_RADIO_UMTS;
+
+ cell_info->mcc_valid = 1;
+ snprintf(wcdma_temp, sizeof(wcdma_temp) ,"%d", cell->value4);
+ strncpy(cell_info->mcc, wcdma_temp, sizeof(cell_info->mcc));
+
+ memset(wcdma_temp, 0, sizeof(wcdma_temp));
+
+ cell_info->mnc_valid = 1;
+ snprintf(wcdma_temp, sizeof(wcdma_temp) ,"%d", 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("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] = {0};
+
+ 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));
+
+ memset(lte_temp, 0, sizeof(lte_temp));
+
+ 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->rsrp_valid = 1;
+ cell_info->rsrp = cell->value8;
+
+ cell_info->rsrq_valid = 1;
+ cell_info->rsrq = cell->value9;
+
+ cell_info->cell_id_valid = 1;
+ cell_info->cell_id = cell->value10;
+
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+
+ while ((cell = (mbtk_cell_info_t*) list_next(cell_list)) && neibor_count < 5)
+ {
+ switch(type)
+ {
+ //GSM
+ case 0:
+ {
+
+ }
+ //WCDMA
+ case 1:
+ {
+ LOGE("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("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;
+
+ snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value6);
+ strncpy(cell_info->ext_info[neibor_count].mcc, lte_temp, sizeof(cell_info->mcc));
+
+ memset(lte_temp, 0, sizeof(lte_temp));
+
+ snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value7);
+ strncpy(cell_info->ext_info[neibor_count].mnc, lte_temp, sizeof(cell_info->mnc));
+
+ 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 = cell->value3;
+ cell_info->ext_info[neibor_count].rsrp_valid = 1;
+
+ cell_info->ext_info[neibor_count].rsrq = cell->value4;
+ cell_info->ext_info[neibor_count].rsrq_valid = 1;
+
+ cell_info->ext_info[neibor_count].cell_id = cell->value5;
+ cell_info->ext_info[neibor_count].cell_id_valid = 1;
+
+ cell_info->ext_info[neibor_count].band = cell->value9;
+ cell_info->ext_info[neibor_count].band_valid = 1;
+
+ cell_info->ext_info[neibor_count].rssi = cell->value10;
+ cell_info->ext_info[neibor_count].rssi_valid = 1;
+
+ neibor_count++;
+ }
+
+ default:
+ break;
+ }
+ }
+ }
+ 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_FAIL;
+ }
+
+ int ret = -1;
+
+ if(handle_ptr == NULL)
+ {
+ LOGE("handle_ptr is NULL\n");
+ return GSW_HAL_FAIL;
+ }
+
+ modem_cb = handle_ptr;
+
+ ret = mbtk_radio_state_change_cb_reg(nw_info_handle,gsw_modem_status_event_callback);
+ if(ret != 0)
+ {
+ LOGE("mbtk_radio_state_change_cb_reg failed : %d\n", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ 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_FAIL;
+ }
+
+ int ret = -1;
+ char fplmn[256] = {0};
+ LOGE("mbtk_fplmn_get enter\n");
+ ret = mbtk_fplmn_get(nw_info_handle, fplmn);
+ LOGE("mbtk_fplmn_get exit\n");
+ if(ret != 0)
+ {
+ LOGE("mbtk_fplmn_get failed : %d\n",ret);
+ return GSW_HAL_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("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("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_FAIL;
+ }
+
+ if(plmn_list->plmn_list_len >= fplmn_max_length)
+ {
+ LOGE("can't save all the plmn\n");
+ return GSW_HAL_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("no this PLMN, add it\n");
+ if((fplmn_index + plmn_list->plmn_list_len) > fplmn_max_length)
+ {
+ LOGE("can't save all the plmn\n");
+ return GSW_HAL_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("fplmn_array[%d] = %s\n", fplmn_index, fplmn_array[fplmn_index]);
+ fplmn_index++;
+ }
+ }
+
+ else
+ {
+ LOGE("already have this PLMN, don't add it\n");
+ }
+ }
+
+ char fplmn_str[256] = {0};
+ convert_plmn_to_fplmn_str(fplmn_str);
+
+ LOGE("fplmn_str = %s\n", fplmn_str);
+
+ int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str);
+ if(ret != 0)
+ {
+ LOGE("mbtk_fplmn_set failed : %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+
+ LOGE("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)
+{
+ LOGE("gsw_remove_forbidden_networks enter\n");
+ if (nw_init_flag == 0 || nw_info_handle == NULL)
+ {
+ return GSW_HAL_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("no this PLMN, can't remove it\n");
+ }
+ }
+
+ for(i = 0; i < fplmn_index; i++)
+ {
+ LOGE("fplmn_array[%d] = %s\n", i, fplmn_array[i]);
+ }
+
+ char fplmn_str[256] = {0};
+ convert_plmn_to_fplmn_str(fplmn_str);
+ LOGE("fplmn_str = %s\n", fplmn_str);
+
+ int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str);
+ if(ret != 0)
+ {
+ LOGE("mbtk_fplmn_set failed : %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+
+ LOGE("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_FAIL;
+ }
+
+ char fplmn_str[FPLMN_STRING_LENGTH+1];
+ memset(fplmn_str, 'F', (6 * fplmn_max_length));
+ fplmn_str[(6 * fplmn_max_length)] = '\0';
+
+ LOGE("%s\n", fplmn_str);
+ int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str);
+ if(ret != 0)
+ {
+ LOGE("mbtk_fplmn_set failed : %d\n",ret);
+ return GSW_HAL_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_FAIL;
+ }
+
+ if(pt_info == NULL)
+ {
+ LOGE("pt_info is null\n");
+ return GSW_HAL_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("mbtk_oos_get failed : %d\n",ret);
+ return GSW_HAL_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_FAIL;
+ }
+
+ if(pt_info == NULL)
+ {
+ LOGE("pt_info is null\n");
+ return GSW_HAL_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_oos_config_set set time < 0 ");
+ return GSW_HAL_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_oos_config_set set Format err");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_oos_set(nw_info_handle, &oos_info);
+ if(ret != 0)
+ {
+ LOGE("mbtk_oos_set failed : %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+
diff --git a/mbtk/libgsw_lib/gsw_oem_rw_interface.c b/mbtk/libgsw_lib/gsw_oem_rw_interface.c
new file mode 100755
index 0000000..6c60e98
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_oem_rw_interface.c
@@ -0,0 +1,262 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <mtd/mtd-user.h>
+#include <errno.h>
+#include <dlfcn.h>
+
+#include "gsw_oem_rw_interface.h"
+
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define ERASE_BLOCK_SIZE (256*1024)
+
+#define LIB_PATH "/lib/libmbtk_lib.so"
+
+
+#define StatFunc(x,y) stat(x,y)
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+typedef void (*mbtk_log)(int level, const char *format,...);
+
+typedef int (*mbtk_oem_read_data_ext)(unsigned int block_id, void *data, unsigned int *len);
+
+typedef int (*mbtk_oem_write_data_ext)(unsigned int block_id, void *data, unsigned int len);
+
+static mbtk_log fun_ptr_log = NULL;
+
+static mbtk_oem_read_data_ext mbtk_read_fun_ptr = NULL;
+static mbtk_oem_write_data_ext mbtk_write_fun_ptr = NULL;
+
+static void *handle = NULL;
+
+static int init_fun_handle()
+{
+ if(handle == NULL)
+ {
+ handle = dlopen(LIB_PATH, RTLD_NOW );
+ if(handle == NULL)
+ {
+ return -1;
+ }
+ if(fun_ptr_log == NULL)
+ {
+ fun_ptr_log = (mbtk_log)dlsym(handle, "mbtk_log");
+ if(fun_ptr_log == NULL)
+ {
+ return -1;
+ }
+ }
+ if(mbtk_read_fun_ptr == NULL)
+ {
+ mbtk_read_fun_ptr = (mbtk_oem_read_data_ext)dlsym(handle, "mbtk_oem_read_data_ext");
+ if(mbtk_read_fun_ptr == NULL)
+ {
+ return -1;
+ }
+ }
+ if(mbtk_write_fun_ptr == NULL)
+ {
+ mbtk_write_fun_ptr = (mbtk_oem_write_data_ext)dlsym(handle, "mbtk_oem_write_data_ext");
+ if(mbtk_write_fun_ptr == NULL)
+ {
+ return -1;
+ }
+ }
+
+ }
+ return 0;
+}
+
+static void deinit_fun_handle()
+{
+ if(handle != NULL)
+ {
+ dlclose(handle);
+ handle = NULL;
+ }
+
+ fun_ptr_log = NULL;
+ mbtk_write_fun_ptr = NULL;
+ mbtk_read_fun_ptr = NULL;
+
+}
+
+/**
+ * @brief Read data from spec block of flash
+ * @param [in] unsigned int
+ * @param [out] void *
+ * @param [out] unsigned int *
+ * @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+ */
+
+int gsw_oem_read_data_ext(unsigned int block_id, void *data, unsigned int *len)
+{
+
+ int ret = -1;
+ unsigned int actual_len = 0;
+ char *temp_buffer = NULL;
+ ret = init_fun_handle();
+ if(ret == -1)
+ {
+ printf(" init_fun_handle error ret %d\n",ret);
+ deinit_fun_handle();
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ if (!data || !len)
+ {
+ LOGE("invalid ：data or len us NULL\n");
+ deinit_fun_handle();
+ return GSW_HAL_ARG_INVALID;
+ }
+
+ temp_buffer = (char *)malloc(ERASE_BLOCK_SIZE);
+ if (temp_buffer == NULL)
+ {
+ LOGE("Failed to allocate read buffer ");
+ deinit_fun_handle();
+ return -1;
+ }
+
+ memset(temp_buffer, 0, ERASE_BLOCK_SIZE);
+
+ ret = mbtk_read_fun_ptr(block_id,temp_buffer,&actual_len);
+ if(ret != 0)
+ {
+ LOGE("mbtk_read_fun_ptr failed");
+ free(temp_buffer);
+ deinit_fun_handle();
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ *len = actual_len;
+ memcpy(data, temp_buffer, *len);
+ free(temp_buffer);
+ deinit_fun_handle();
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief Write data to spec block of flash
+ * @param [in] unsigned int
+ * @param [in] void *
+ * @param [in] unsigned int
+ * @retval 0: success
+ * @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+ */
+
+int gsw_oem_write_data_ext(unsigned int block_id, void *data, unsigned int len)
+{
+ int ret = -1;
+ ret = init_fun_handle();
+ if(ret == -1)
+ {
+ printf("init log error ret %d\n",ret);
+ deinit_fun_handle();
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ if (!data || len > ERASE_BLOCK_SIZE)
+ {
+ LOGE("invalid data is NULL ");
+ deinit_fun_handle();
+ return GSW_HAL_ARG_INVALID;
+ }
+
+ ret = mbtk_write_fun_ptr(block_id,data,len);
+ if(ret != 0)
+ {
+ LOGE("mbtk_write_fun_ptr failed");
+ deinit_fun_handle();
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ deinit_fun_handle();
+ return GSW_HAL_SUCCESS;
+}
diff --git a/mbtk/libgsw_lib/gsw_pm.c b/mbtk/libgsw_lib/gsw_pm.c
new file mode 100755
index 0000000..abf1a0d
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_pm.c
@@ -0,0 +1,363 @@
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <time.h>
+#include <sys/ioctl.h>
+#include <dlfcn.h>
+#include <stdint.h>
+#include "gsw_pm.h"
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+#define GSW_HAL_SUCCESS 0
+#define GSW_HAL_FAIL -1 //表示失败(通用性)
+#define GSW_HAL_MEM_INVAILD -2 //表示入参地址为NULL
+#define LOCK_MAX_SIZE 129
+
+typedef void (*mbtk_lpm_handler_t)(int32_t wakeup_in);
+typedef void (*mbtk_log)(int level, const char *format,...);
+
+int (*mbtk_autosuspend_enable)(char);
+int (*mbtk_wakelock_create)(const char* name , size_t);
+int (*mbtk_wakelock_lock)(int);
+int (*mbtk_wakelock_unlock)(int);
+int (*mbtk_wakelock_destroy)(int);
+int (*mbtk_lpm_init)(mbtk_lpm_handler_t );
+int lock_fd = -1;
+
+typedef struct
+{
+ int fd;
+ char *name;
+} mbtk_lock_name_s;
+static mbtk_lock_name_s lock_name[LOCK_MAX_SIZE]={0};
+
+static mbtk_log fun_ptr_log = NULL;
+void *dlHandle_sleep = NULL;
+char *lynqLib_sleep = "/lib/libmbtk_lib.so";
+
+
+/**
+* @brief Enable autosleep
+* @param void
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+
+static int handle()
+{
+ if(dlHandle_sleep == NULL || fun_ptr_log == NULL)
+ {
+ dlHandle_sleep = dlopen(lynqLib_sleep, RTLD_NOW);
+ fun_ptr_log = (mbtk_log)dlsym(dlHandle_sleep, "mbtk_log");
+ if(fun_ptr_log == NULL || dlHandle_sleep == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+int32_t gsw_autosleep_enable(void)
+{
+ int ret;
+ if (handle())
+ return GSW_HAL_FAIL;
+ mbtk_autosuspend_enable=(int(*)(char))dlsym(dlHandle_sleep, "mbtk_autosuspend_enable");
+ ret = mbtk_autosuspend_enable(1);
+ if(ret < 0)
+ {
+ LOGE("mbtk_autosuspend_enable FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief Disable autosleep
+* @param void
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_autosleep_disenable(void)
+{
+ int ret;
+ if (handle())
+ return GSW_HAL_FAIL;
+ mbtk_autosuspend_enable=(int(*)(char))dlsym(dlHandle_sleep, "mbtk_autosuspend_enable");
+ ret = mbtk_autosuspend_enable(0);
+ if(ret < 0)
+ {
+ LOGE("mbtk_autosuspend_enable FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief Init power manager module
+* @param [in]GSW_PM_WAKEUPCALLBACKHandler wakeup_callback
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_pm_sdk_init(GSW_PM_WAKEUPCALLBACK wakeup_callback)
+{
+ int ret;
+ if (handle())
+ return GSW_HAL_FAIL;
+ mbtk_lpm_init=(int(*)(mbtk_lpm_handler_t))dlsym(dlHandle_sleep, "mbtk_lpm_init");
+ ret = mbtk_lpm_init((mbtk_lpm_handler_t)wakeup_callback);
+ if(ret < 0)
+ {
+ LOGE("mbtk_lpm_init FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief Release wake lock, enter sleep
+* @param [in]int32_t wakeup_in
+* @retval int
+*/
+int32_t gsw_pm_enter_sleep(const char *gsw_wakelock_name)
+{
+ int ret;
+ int i;
+ if (handle())
+ return GSW_HAL_FAIL;
+ if (gsw_wakelock_name == NULL)
+ return GSW_HAL_FAIL;
+ for(i=0 ;i<LOCK_MAX_SIZE;i++)
+ {
+ if(lock_name[i].name != NULL && strcmp(lock_name[i].name, gsw_wakelock_name) == 0)
+ {
+ lock_fd = lock_name[i].fd;
+ break;
+ }
+ }
+ if (i >= LOCK_MAX_SIZE)
+ {
+ LOGE("mbtk_wakelock_lock not create.\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_wakelock_unlock=(int(*)(int))dlsym(dlHandle_sleep, "mbtk_wakelock_unlock");
+ ret = mbtk_wakelock_unlock(lock_fd);
+ if(ret < 0)
+ {
+ LOGE("mbtk_wakelock_unlock FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_wakelock_destroy=(int(*)(int))dlsym(dlHandle_sleep, "mbtk_wakelock_destroy");
+ ret = mbtk_wakelock_destroy(lock_fd);
+ if(ret < 0)
+ {
+ LOGE("mbtk_wakelock_destroy FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+ if (lock_name[i].name != NULL)
+ {
+ free(lock_name[i].name);
+ lock_name[i].name = NULL;
+ lock_name[i].fd = -1;
+ }
+
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief Creat wakeup lock
+* @param [in]int32_t wakeup_in
+* @retval int
+*/
+int32_t gsw_pm_exit_sleep(const char *gsw_wakelock_name)
+{
+ int ret;
+ int i;
+ if (handle())
+ return GSW_HAL_FAIL;
+ if (gsw_wakelock_name == NULL)
+ return GSW_HAL_FAIL;
+ mbtk_wakelock_create=(int(*)(const char* name , size_t))dlsym(dlHandle_sleep, "mbtk_wakelock_create");
+ lock_fd = mbtk_wakelock_create(gsw_wakelock_name, strlen(gsw_wakelock_name));
+ if(lock_fd < 0)
+ {
+ LOGE("mbtk_wakelock_create FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+ mbtk_wakelock_lock=(int(*)(int))dlsym(dlHandle_sleep, "mbtk_wakelock_lock");
+
+ ret = mbtk_wakelock_lock(lock_fd);
+ if(ret < 0)
+ {
+ LOGE("mbtk_wakelock_lock FAIL.\n");
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_FAIL;
+ }
+ for(i=0 ;i<LOCK_MAX_SIZE;i++)
+ {
+ if(lock_name[i].name == NULL)
+ break;
+ }
+ lock_name[i].name = malloc(strlen(gsw_wakelock_name)+1);
+ if (lock_name[i].name == NULL)
+ {
+ LOGE("mbtk_wakelock_lock remeber FAIL.\n");
+ return GSW_HAL_FAIL;
+ }
+ memcpy(lock_name[i].name, gsw_wakelock_name, strlen(gsw_wakelock_name)+1);
+ lock_name[i].fd = lock_fd;
+
+ dlclose(dlHandle_sleep);
+ dlHandle_sleep = NULL;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief Module log disk drop, used when restarting or hibernating
+* @param [in]void
+* @retval void
+*/
+void gsw_modem_log_sync(void)
+{
+ FILE *fp;
+ char command[256];
+ char buffer[256];
+ int pid = -1;
+ const char *process_name = "mbtk_logd";
+
+ snprintf(command, sizeof(command), "pgrep %s", process_name);
+ fp = popen(command, "r");
+ if (fp == NULL)
+ {
+ perror("error comman");
+ return;
+ }
+
+ if (fgets(buffer, sizeof(buffer), fp) != NULL)
+ {
+ pid = atoi(buffer);
+ }
+ pclose(fp);
+
+ if (pid != -1)
+ {
+ if (kill(pid, SIGTERM) == -1)
+ {
+ perror("send SIGTERM signal failed");
+ return;
+ }
+ }
+ return;
+}
\ No newline at end of file
diff --git a/mbtk/libgsw_lib/gsw_sim.c b/mbtk/libgsw_lib/gsw_sim.c
new file mode 100755
index 0000000..b8cfa52
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_sim.c
@@ -0,0 +1,660 @@
+#include "gsw_nw_interface.h"
+#include <unistd.h>
+#include <dlfcn.h>
+#include <time.h>
+
+#define MBTK_BUFF_TEMP_SIZE_32 32
+#define MBTK_ERR_OK 0
+#define MBTK_ERR_FAIL -1
+#define GSW_SIM_ICCID_LENGTH 20+1
+#define GSW_SIM_IMSI_LENGTH 20+1
+#define GSW_SIM_MSISDN_LENGTH 20+1
+#define GSW_SIM_IMEI_LENGTH 20+1
+
+//mbtk include
+typedef unsigned int uint32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+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 enum {
+ MBTK_SIM_ABSENT = 0,
+ MBTK_SIM_NOT_READY = 1,
+ MBTK_SIM_READY = 2,
+ MBTK_SIM_PIN = 3,
+ MBTK_SIM_PUK = 4,
+ MBTK_SIM_NETWORK_PERSONALIZATION = 5
+} mbtk_sim_state_enum;
+
+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 struct
+{
+ MBTK_DEV_MODEM_FUNCTION fun;
+ int rst;
+} mbtk_modem_info_t;
+
+//api
+
+static mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
+#define GSW_HAL_FAIL GSW_HAL_NORMAL_FAIL
+#define GSW_HAL_MEM_INVAILD GSW_HAL_ARG_INVALID
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+
+static int sim_init_flag = 0;
+mbtk_info_handle_t* sim_info_handle = NULL;
+static int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle);
+int (*mbtk_sim_state_get)(mbtk_info_handle_t* handle, mbtk_sim_state_enum *sim_state);
+int (*mbtk_imsi_get)(mbtk_info_handle_t* handle, void *imsi);
+int (*mbtk_iccid_get)(mbtk_info_handle_t* handle, void *iccid);
+int (*mbtk_phone_number_get)(mbtk_info_handle_t* handle, void *phone_number);
+int (*mbtk_imei_get)(mbtk_info_handle_t* handle, void *imei);
+int (*mbtk_set_modem_fun)(mbtk_info_handle_t* handle, mbtk_modem_info_t *info);
+int (*mbtk_sim_power_set)(int power);
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+
+
+static void *dlHandle_mbtk;
+
+
+static int gsw_sim_api_import()
+{
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+ if (mbtk_info_handle_get == NULL)
+ {
+ LOGE("mbtk_info_handle_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_info_handle_free dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_imsi_get = (int (*)(mbtk_info_handle_t* handle, void *imsi))dlsym(dlHandle_mbtk, "mbtk_imsi_get");
+ if (mbtk_imsi_get == NULL)
+ {
+ LOGE("mbtk_imsi_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_iccid_get = (int (*)(mbtk_info_handle_t* handle, void *iccid))dlsym(dlHandle_mbtk, "mbtk_iccid_get");
+ if (mbtk_iccid_get == NULL)
+ {
+ LOGE("mbtk_iccid_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_phone_number_get = (int (*)(mbtk_info_handle_t* handle, void *phone_number))dlsym(dlHandle_mbtk, "mbtk_phone_number_get");
+ if (mbtk_phone_number_get == NULL)
+ {
+ LOGE("mbtk_phone_number_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_imei_get = (int (*)(mbtk_info_handle_t* handle, void *imei))dlsym(dlHandle_mbtk, "mbtk_imei_get");
+ if (mbtk_imei_get == NULL)
+ {
+ LOGE("mbtk_imei_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sim_state_get = (int (*)(mbtk_info_handle_t* handle, mbtk_sim_state_enum *sim_state))dlsym(dlHandle_mbtk, "mbtk_sim_state_get");
+ if (mbtk_sim_state_get == NULL)
+ {
+ LOGE("mbtk_sim_state_get dlsym fail\n");
+ return GSW_HAL_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("mbtk_set_modem_fun dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sim_power_set = (int (*)(int power))dlsym(dlHandle_mbtk, "mbtk_sim_power_set");
+ if (mbtk_sim_power_set == NULL)
+ {
+ LOGE("mbtk_sim_power_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ LOGD("gsw_sim_api_import end\n");
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief sim sdk init
+ * @param [in] token usr id define by who use
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_sim_sdk_init(int32_t token)
+{
+ int ret = GSW_HAL_FAIL;
+
+ if(sim_init_flag == 1 && sim_info_handle != NULL)
+ {
+ return GSW_HAL_SUCCESS;
+ }
+
+ ret = gsw_sim_api_import();
+ if(ret != GSW_HAL_SUCCESS)
+ {
+ if(mbtk_log != NULL)
+ {
+ LOGE("gsw_sim_import fail\n");
+ }
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init("syslog", "MBTK_RIL");
+
+ sim_info_handle = mbtk_info_handle_get();
+ if(sim_info_handle == NULL)
+ {
+ LOGE("mbtk_info_handle_get fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ sim_init_flag = 1;
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief sim sdk deinit
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_sim_sdk_deinit(void)
+{
+ int ret = -1;
+
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_info_handle_free(&sim_info_handle);
+ if(ret != GSW_HAL_SUCCESS)
+ {
+ LOGE("mbtk_info_handle_free fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ sim_init_flag = 0;
+ sim_info_handle = NULL;
+ dlclose(dlHandle_mbtk);
+
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+/**
+ * @brief get sim state
+ * @param [out] sim_state sim status as sim_status_e_type
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_get_sim_status(int *sim_state)
+{
+ LOGD("gsw_get_sim_status enter\n");
+ int ret = -1;
+
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sim_state_enum sim = MBTK_SIM_ABSENT;
+
+ LOGD("mbtk_get_sim_status start\n");
+ ret = mbtk_sim_state_get(sim_info_handle, &sim);
+ if(ret)
+ {
+ LOGE("[gsw_get_sim_status] mbtk_sim_state_get fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ else
+ {
+ LOGD("[gsw_get_sim_status] sim = %d\n", sim);
+ switch (sim)
+ {
+ case MBTK_SIM_ABSENT:
+ {
+ *sim_state = SIM_STATUS_ABSENT;
+ break;
+ }
+ case MBTK_SIM_NOT_READY:
+ {
+ *sim_state = SIM_STATUS_PRESENT;
+ break;
+ }
+
+ case MBTK_SIM_READY:
+ {
+ *sim_state = SIM_STATUS_READY;
+ break;
+ }
+
+ case MBTK_SIM_PIN:
+ {
+ *sim_state = SIM_STATUS_PIN;
+ break;
+ }
+
+ case MBTK_SIM_PUK:
+ {
+ break;
+ }
+
+ case MBTK_SIM_NETWORK_PERSONALIZATION:
+ {
+ break;
+ }
+
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief get iccid function
+ * @param [in] len iccid length,max is 20
+ * @param [out] iccid return iccid from this func
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_get_sim_iccid(int len, char *iccid)
+{
+ int ret = -1;
+
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ if(iccid == NULL)
+ {
+ LOGE("iccid is NULL.");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ if(len < GSW_SIM_ICCID_LENGTH)
+ {
+ LOGE("iccid len is too short,len = %d\n", len);
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_iccid_get(sim_info_handle, (void *)iccid);
+ if(ret != MBTK_ERR_OK)
+ {
+ LOGE("[gsw_sim] mbtk_iccid_get fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief get imsi function
+ * @param [in] len imsi length,max is 20
+ * @param [out] iccid return imsi from this func
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_get_sim_imsi(int len, char *imsi)
+{
+ int ret = -1;
+
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ if(imsi == NULL)
+ {
+ LOGE("imsi is NULL.");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ if(len < GSW_SIM_IMSI_LENGTH)
+ {
+ LOGE("imsi len is too short,len = %d\n", len);
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_imsi_get(sim_info_handle, (void *)imsi);
+ if(ret != MBTK_ERR_OK)
+ {
+ LOGE("[gsw_sim] mbtk_imsi_get fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief get sim msisdn function
+ * @param [in] len msisdn length,max is 20
+ * @param [out] msisdn msisdn length,max is 20
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_get_sim_msisdn(int len, char *msisdn)
+{
+ int ret = -1;
+
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ printf("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ if(msisdn == NULL)
+ {
+ printf("msisdn is NULL.");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ if(len < GSW_SIM_MSISDN_LENGTH)
+ {
+ printf("msisdn len is too short,len = %d\n", len);
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_phone_number_get(sim_info_handle, (void *)msisdn);
+ if(ret != MBTK_ERR_OK)
+ {
+ LOGE("[gsw_sim] mbtk_phone_number_get fail [err = %d].", ret);
+ return GSW_HAL_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)
+{
+ int ret = -1;
+
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ if(imei == NULL)
+ {
+ LOGE("imei is NULL.");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ if(len < GSW_SIM_MSISDN_LENGTH)
+ {
+ LOGE("imei len is too short,len = %d\n", len);
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_imei_get(sim_info_handle, (void *)imei);
+ if(ret != MBTK_ERR_OK)
+ {
+ LOGE("[gsw_sim] mbtk_imei_get fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief set sim power down
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_set_sim_power_down(void)
+{
+ int ret = -1;
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_sim_power_set(0);
+ if(ret != MBTK_ERR_OK)
+ {
+ LOGE("[gsw_sim] mbtk_sim_power_set fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+
+
+/**
+ * @brief set sim power up
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_set_sim_power_up(void)
+{
+ int ret = -1;
+ if(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_sim_power_set(1);
+ if(ret != MBTK_ERR_OK)
+ {
+ LOGE("[gsw_sim] mbtk_sim_power_set fail [err = %d].", ret);
+ return GSW_HAL_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(sim_init_flag == 0 && sim_info_handle == NULL)
+ {
+ LOGE("sim sdk has been deinit\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_modem_info_t info;
+ info.fun = MBTK_DEV_MODEM_MIN_FUN;
+ info.rst = 0;
+
+ ret = mbtk_set_modem_fun(sim_info_handle, &info);
+ if(ret)
+ {
+ LOGE("[gsw_sim] mbtk_set_modem_fun fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ sleep(1);
+
+ info.fun = MBTK_DEV_MODEM_FULL_FUN;
+ ret = mbtk_set_modem_fun(sim_info_handle, &info);
+ if(ret)
+ {
+ LOGE("[gsw_sim] mbtk_set_modem_fun fail [err = %d].", ret);
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
\ No newline at end of file
diff --git a/mbtk/libgsw_lib/gsw_sms.c b/mbtk/libgsw_lib/gsw_sms.c
new file mode 100755
index 0000000..403bd4d
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_sms.c
@@ -0,0 +1,866 @@
+#include "gsw_nw_interface.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <dlfcn.h>
+#include <time.h>
+
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned char uint8_t;
+typedef unsigned short uint16;
+typedef uint32_t sms_client_handle_type;
+typedef int kal_int32;
+
+
+//qser include
+
+
+
+//mbtk include
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+typedef unsigned char uint8;
+
+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;
+
+// PDU include
+enum EnumDCS {
+ BIT7 = 0, // GSM 字符集
+ BIT8 = 1, // ASCII字符集
+ UCS2 = 2 // Unicode 字符集
+};
+
+struct SMS_Struct {
+ char *SCA; // 服务中心地址
+ char *OA; // 发送方地址
+ char *SCTS; // 服务中心时间戳
+ struct UDHS *UDH; // 用户数据头
+ char *UD; // 用户数据
+
+ bool RP; // 应答路径
+ bool UDHI; // 用户数据头标识
+ bool SRI; // 状态报告指示
+ bool MMS; // 更多信息发送
+ int MTI; // 信息类型指示
+
+ char PID; // PID 协议标识
+
+ enum EnumDCS DCS; // 数据编码方案
+ bool TC; // 文本压缩指示 0： 未压缩 1：压缩
+ int MC; // 消息类型 -1： 无 1：移动设备特定类型 2：SIM特定类型 3：终端设备特定类型
+
+};
+
+struct PDUS {
+ unsigned int count;
+ char **PDU;
+};
+
+enum MDAPI_RET_e {
+ MDAPI_RET_SUCCESS = 0,
+ MDAPI_RET_ERROR = 1,
+ MDAPI_RET_TIMEOUT = 2,
+ MDAPI_RET_NOT_SUPPORT = 3,
+};
+
+#define MDAPI_TIME_STR_SIZE 22
+#define MDAPI_PHONE_NUMBER_SIZE 32
+#define MDAPI_MAX_PDU_SIZE 512
+#define MSM_NUMBER_MAX 2048+1
+#define RES_NUM_MIN 128
+#define MIN_MSM_PARAM_NUM 4
+#define MIN_IMS_MSM_PARAM_NUM 6
+#define MIN_WRITMSM_PARAM_NUM 5
+#define MSG_MAX_LEN 1024
+#define TELEPHONNUM_LEN 64
+#define STORAGSMS_MAX_SIZE 128
+#define SMSC_MAX_LEN 22
+#define SMS_NUM_MAX 255
+#define MAX_OUT_SIZE 512
+#define MAX_PDU_SIZE 512
+#define MAX_DATE_SIZE 32
+
+
+GSW_SMS_Callback_fun gsw_sms_callback = NULL;
+
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+#define lib_qser_sms_path "/lib/liblynq-qser-sms.so"
+
+#define GSW_HAL_FAIL GSW_HAL_NORMAL_FAIL
+#define GSW_HAL_MEM_INVAILD GSW_HAL_ARG_INVALID
+
+
+static mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
+int (*mbtk_sms_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
+static int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle);
+struct SMS_Struct (*PDUDecoding)(const char *data);
+char *(*SCADecoding)(const char *data, int *EndIndex);
+char *(*SCAEncoding)(char *SCA);
+struct PDUS *(*PDUEncoding)(char *SCA, char *DA, char *UDC, struct UDHS *udhs);
+int (*mbtk_sms_cmgf_set)(mbtk_info_handle_t* handle, int mode);
+int (*mbtk_sms_cmgs_set)(mbtk_info_handle_t* handle, char * cmgs, char *resp);
+int (*mbtk_sms_csca_set)(mbtk_info_handle_t* handle, char * csca);
+int (*mbtk_sms_csca_get)(mbtk_info_handle_t* handle, char *buf);
+int (*mbtk_sms_cnmi_set)(mbtk_info_handle_t* handle);
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+int (*smsPduEncode)(const char *smsc, const char *da_num, const char *msg, int charset, char *smsc_pdu, char **pdu);
+int (*smsPduDecode)(const char *pdu_str, int pdu_len, char *da_num, char *smsc, char *msg, int *charset, int *curr_pack, int *total_pack, char *date);
+kal_int32 (*_mdapi_sms_get_msg_num)(const char *msg, int charset, kal_int32 *msg_num, kal_int32 *msg_len);
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+
+static mbtk_info_handle_t* sms_info_handle = NULL;
+static sms_client_handle_type handle;
+static char sms_center_address[SMSC_MAX_LEN] = {0};
+static void *dlHandle_mbtk;
+static int init_flag = 0;
+
+static int mbtk_sms_import()
+{
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+ if (mbtk_info_handle_get == NULL)
+ {
+ LOGE("mbtk_info_handle_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sms_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_sms_state_change_cb_reg");
+ if (mbtk_sms_state_change_cb_reg == NULL)
+ {
+ LOGE("mbtk_sms_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_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("mbtk_info_handle_free dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ PDUDecoding = (struct SMS_Struct (*)(const char *data))dlsym(dlHandle_mbtk, "PDUDecoding");
+ if (PDUDecoding == NULL)
+ {
+ LOGE("PDUDecoding dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ SCADecoding = (char *(*)(const char *data, int *EndIndex))dlsym(dlHandle_mbtk, "SCADecoding");
+ if (SCADecoding == NULL)
+ {
+ LOGE("SCADecoding dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ SCAEncoding = (char *(*)(char *SCA))dlsym(dlHandle_mbtk, "SCAEncoding");
+ if (SCAEncoding == NULL)
+ {
+ LOGE("SCAEncoding dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ PDUEncoding = (struct PDUS *(*)(char *SCA, char *DA, char *UDC, struct UDHS *udhs))dlsym(dlHandle_mbtk, "PDUEncoding");
+ if (PDUEncoding == NULL)
+ {
+ LOGE("PDUEncoding dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sms_cmgf_set = (int (*)(mbtk_info_handle_t* handle, int mode))dlsym(dlHandle_mbtk, "mbtk_sms_cmgf_set");
+ if (mbtk_sms_cmgf_set == NULL)
+ {
+ LOGE("mbtk_sms_cmgf_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sms_cmgs_set = (int (*)(mbtk_info_handle_t* handle, char * cmgs, char *resp))dlsym(dlHandle_mbtk, "mbtk_sms_cmgs_set");
+ if (mbtk_sms_cmgs_set == NULL)
+ {
+ LOGE("mbtk_sms_cmgs_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sms_csca_set = (int (*)(mbtk_info_handle_t* handle, char * csca))dlsym(dlHandle_mbtk, "mbtk_sms_csca_set");
+ if (mbtk_sms_csca_set == NULL)
+ {
+ LOGE("mbtk_sms_csca_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sms_csca_get = (int (*)(mbtk_info_handle_t* handle, char *buf))dlsym(dlHandle_mbtk, "mbtk_sms_csca_get");
+ if (mbtk_sms_csca_get == NULL)
+ {
+ LOGE("mbtk_sms_csca_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_sms_cnmi_set = (int (*)(mbtk_info_handle_t* handle))dlsym(dlHandle_mbtk, "mbtk_sms_cnmi_set");
+ if (mbtk_sms_cnmi_set == NULL)
+ {
+ LOGE("mbtk_sms_cnmi_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ smsPduEncode = (int (*)(const char *smsc, const char *da_num, const char *msg, int charset, char *smsc_pdu, char **pdu))dlsym(dlHandle_mbtk, "smsPduEncode");
+ if (smsPduEncode == NULL)
+ {
+ LOGE("smsPduEncode dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+
+ smsPduDecode = (int (*)(const char *pdu_str, int pdu_len, char *da_num, char *smsc, char *msg, int *charset, int *curr_pack, int *total_pack, char *date))dlsym(dlHandle_mbtk,"smsPduDecode");
+ if (smsPduDecode == NULL)
+ {
+ LOGE("smsPduDecode dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ _mdapi_sms_get_msg_num = (kal_int32 (*)(const char *msg, int charset, kal_int32 *msg_num, kal_int32 *msg_len))dlsym(dlHandle_mbtk,"_mdapi_sms_get_msg_num");
+ if (_mdapi_sms_get_msg_num == NULL)
+ {
+ LOGE("_mdapi_sms_get_msg_num dlsym fail");
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+
+}
+
+void ArrayToStr(unsigned char *Buff, unsigned int BuffLen, char *OutputStr)
+{
+ int i = 0;
+ char TempBuff[MSG_MAX_LEN * 2 +1] = {0};
+ char strBuff[MSG_MAX_LEN * 2 +1] = {0};
+
+ for(i = 0; i<BuffLen;i++)
+ {
+ sprintf(TempBuff,"%02x",(unsigned char)Buff[i]);
+ strncat(strBuff,TempBuff,BuffLen*2);
+ }
+ strncpy(OutputStr, strBuff, BuffLen*2);
+ return;
+}
+
+void gsw_sms_state_change_cb(const void* data, int data_len) {
+ LOGD("gsw_sms_state_change_cb -------start\n");
+
+ uint8 *ptr = (uint8*)data;
+
+ if (!strncmp("+CMT:", (const char *)ptr, 5))//丢弃无用消息
+ return ;
+
+ gsw_sms_msg_type_t gsw_sms_msg;
+ gsw_sms_date_t gsw_sms_date;
+
+ memset(&gsw_sms_msg, 0, sizeof(gsw_sms_msg_type_t));
+ memset(&gsw_sms_date, 0, sizeof(gsw_sms_date_t));
+
+ char smsc[MDAPI_MAX_PDU_SIZE] = {0};
+ char received_pdu[MDAPI_MAX_PDU_SIZE] = {0};
+ char msg[MDAPI_MAX_PDU_SIZE] = {0};
+ char num[MDAPI_MAX_PDU_SIZE] = {0};
+ char date[MAX_DATE_SIZE] = {0};
+ int charset = 0;
+ int ret = -1;
+ int curr_pack = 1;
+ int total_pack = 1;
+ if(ptr == NULL)
+ {
+ LOGE("ptr is null");
+ }
+ LOGE("ptr: %s\n,data_len = %d\n", (char *)ptr, data_len);
+ if(data_len > MDAPI_MAX_PDU_SIZE)
+ {
+ strncpy(received_pdu, (const char *)ptr, MDAPI_MAX_PDU_SIZE-1);
+ }
+ else
+ {
+ strncpy(received_pdu, (const char *)ptr, data_len);
+ }
+ ret = smsPduDecode((const char *)received_pdu, data_len, num, smsc, msg, &charset, &curr_pack, &total_pack,date);
+ if(ret != 0)
+ {
+ LOGE("smsPduDecode fail\n");
+ return ;
+ }
+ LOGE("smsPduDecode ret: %d\n", ret);
+ LOGE("SMS :%s, %s, %d\n", __FILE__, __FUNCTION__, __LINE__);
+ LOGE("[EVENT][MT_SMS]PDU decode:smsc: %s\n, phone number: %s\ncharset: %d\n msg_len: %d\n message content: %s\n curr_pack: %d\n total_pack: %d\n date: %s", smsc, num, charset, strlen(msg), msg, curr_pack, total_pack, date);
+
+ gsw_sms_msg.content_encode = charset;
+ memcpy(gsw_sms_msg.src_num, num, strlen(num));
+ gsw_sms_msg.content_len = strlen(msg);
+ memcpy(gsw_sms_msg.content, msg, strlen(msg));
+
+ if(sscanf(date, "%4[^-]-%2[^-]-%2[^ ] %2[^:]:%2[^:]:%2s", (char*)gsw_sms_date.year, (char*)gsw_sms_date.month, (char*)gsw_sms_date.day, (char*)gsw_sms_date.hour, (char*)gsw_sms_date.minutes, (char*)gsw_sms_date.seconds)<=0)
+ {
+ LOGE("sscanf failed\n");
+ }
+
+ snprintf((char *)gsw_sms_date.timezone, sizeof(gsw_sms_date.timezone), "%s","+8");
+
+ LOGE("Year: %s\n", (char*)gsw_sms_date.year);
+ LOGE("Month: %s\n", (char*)gsw_sms_date.month);
+ LOGE("Day: %s\n", (char*)gsw_sms_date.day);
+ LOGE("Hour: %s\n", (char*)gsw_sms_date.hour);
+ LOGE("Minute: %s\n", (char*)gsw_sms_date.minutes);
+ LOGE("Second: %s\n", (char*)gsw_sms_date.seconds);
+
+ gsw_sms_msg.date = gsw_sms_date;
+
+ if(gsw_sms_callback)
+ {
+ if(total_pack > 1 && curr_pack < total_pack)
+ {
+ gsw_sms_callback(GSW_SMS_RECEIVED_FLG, &gsw_sms_msg);
+ }
+ else
+ {
+ gsw_sms_callback(GSW_SMS_FULL_FLG, &gsw_sms_msg);
+ }
+
+ }
+
+}
+
+
+/**
+ * @brief SDK interface to call back sms messages
+ * @param [in] handle_ptr
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_sms_reg_callback(GSW_SMS_Callback_fun handle_ptr)
+{
+ if(init_flag == 0)
+ {
+ return -1;
+ }
+
+ if(handle_ptr == NULL)
+ {
+ LOGE("gsw_sms_reg_callback fail,handle_ptr is null\n");
+ return -1;
+ }
+ else
+ {
+ gsw_sms_callback = handle_ptr;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief sms sdk init
+ * @param [in] token
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_sms_sdk_init(int token)
+{
+ handle = token;
+ int ret = -1;
+
+ if(init_flag == 1)
+ {
+ LOGE("has init sms sdk,return\n");
+ return GSW_HAL_SUCCESS;
+ }
+
+ ret = mbtk_sms_import();
+ if(ret != 0)
+ {
+ if(mbtk_log != NULL)
+ {
+ LOGE("[gsw_sms_sdk_init]mbtk_sms_import fail\n");
+ }
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init("syslog", "MBTK_RIL");
+
+ sms_info_handle = mbtk_info_handle_get();
+ if(sms_info_handle == NULL)
+ {
+ LOGE("[gsw_sms_sdk_init] mbtk handle init fail\n");
+ dlclose(dlHandle_mbtk);
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_sms_cnmi_set(sms_info_handle);
+ if(ret != 0)
+ {
+ LOGE("mbtk_sms_cnmi_set fail.[%d]\n", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ ret = mbtk_sms_state_change_cb_reg(sms_info_handle, gsw_sms_state_change_cb);
+ if(ret != 0)
+ {
+ LOGE("mbtk_sms_state_change_cb_reg fail.[%d]\n", ret);
+ if(sms_info_handle)
+ {
+ mbtk_info_handle_free(&sms_info_handle);
+ sms_info_handle = NULL;
+ }
+ return GSW_HAL_FAIL;
+ }
+
+ LOGD("[gsw_sms_sdk_init]gsw_sms_sdk_init success\n");
+ init_flag = 1;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief sms sdk deinit
+ * @param
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_sms_sdk_deinit(void)
+{
+ int ret = -1;
+
+ if(init_flag == 0)
+ {
+ return -1;
+ }
+
+ LOGD("callback clear\n");
+ gsw_sms_callback = NULL;
+
+ LOGD("handle_free\n");
+ if(sms_info_handle != NULL)
+ {
+ ret = mbtk_info_handle_free(&sms_info_handle);
+ if(ret != 0)
+ {
+ LOGE("[gsw_sms_sdk_deinit]mbtk_info_handle_free fail\n");
+ return GSW_HAL_FAIL;
+ }
+ sms_info_handle = NULL;
+ }
+
+ LOGD("dlclose start\n");
+ if(dlHandle_mbtk == NULL)
+ {
+ LOGE("[gsw_sms_sdk_deinit]dlHandle_sms is null\n");
+ }
+ else
+ {
+ dlclose(dlHandle_mbtk);
+ }
+ LOGD("dlclose end\n");
+ init_flag = 0;
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief send sms fuction *
+ * @param [in] phone_num dest phone num send sms
+ * @param [in] char_set encode format for sms 0 7bit 1 binary 2 usc2
+ * @param [in] msg sms content
+ * @param [in] msg_len send sms length,max is 1024
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_send_sms(char *phone_num, int char_set, char *msg, int msg_len)
+{
+
+ if(init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(phone_num == NULL || msg == NULL)
+ {
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ if(strlen((char *)msg) > GSW_SMS_RECV_CONT_MAX || strlen((char *)msg) == 0 || strlen((char *)phone_num) == 0)
+ {
+ LOGE("strlen(telephony_num):%d", strlen((char *)phone_num));
+ LOGE("strlen(msg):%d", strlen((char *)msg));
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ int err = -1;
+
+ char smscPDU[30] = {0};
+ char **pdu = NULL;
+ char smsc[4] = {0};
+ char cmgs[MSM_NUMBER_MAX] = {0};
+ char resp[RES_NUM_MIN] = {0};
+ char msg_e_b[GSW_SMS_RECV_CONT_MAX+1] = {0};// +1 for end of string.*2:A char array contains two elements of a string for each value
+
+ kal_int32 msg_num = 0;
+ kal_int32 pdu_msg_len = 0;
+ kal_int32 status = MDAPI_RET_ERROR;
+ kal_int32 index = 0;
+
+ if(char_set == 1) //8bit
+ {
+ ArrayToStr((unsigned char *)msg, (unsigned int)msg_len, msg_e_b);
+ status = _mdapi_sms_get_msg_num(msg_e_b, char_set, &msg_num, &pdu_msg_len);
+ }
+
+ else //7bit usc2
+ {
+ status = _mdapi_sms_get_msg_num((char *)msg, char_set, &msg_num, &pdu_msg_len);
+ }
+
+ LOGE("%s, %s, %d, msg_len = [%d] ,msg_num=[%d]\n", __FILE__, __FUNCTION__, __LINE__, msg_len, msg_num);
+ if(status == MDAPI_RET_ERROR)
+ {
+ LOGE("get message number failed\n");
+ //return GSW_HAL_FAIL;
+ }
+ else
+ {
+ //allocate memery for **pdu
+ pdu = (char **)malloc(sizeof(char *) * msg_num);
+ if(pdu == NULL)
+ {
+ LOGE("%s, %s, %d, allocate memory for pdu failed\n", __FILE__, __FUNCTION__, __LINE__);
+ return GSW_HAL_FAIL;
+ }
+
+ else
+ {
+ for(index = 0; index < msg_num; index++)
+ {
+ pdu[index] = (char *)malloc(sizeof(char)*MAX_PDU_SIZE);
+ if(pdu[index] == NULL)
+ {
+ for(int i = 0; i < index; i++)
+ {
+ free(pdu[i]);
+ pdu[i] = NULL;
+ }
+ free(pdu);
+ pdu = NULL;
+ LOGE("%s, %s, %d, allocate memory for pdu[%d] failed\n", __FILE__, __FUNCTION__, __LINE__,index);
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ memset(pdu[index], 0, MAX_PDU_SIZE);
+ LOGE("%s, %s, %d, pdu[%d} init value is: %s \n", __FILE__, __FUNCTION__, __LINE__, index, pdu[index]);
+ }
+ }
+ }
+ }
+
+ //allocate memory for **pdu success
+ if(index == msg_num)
+ {
+ if(char_set == 1)//8bit
+ {
+ smsPduEncode(smsc, (char *)phone_num, msg_e_b, char_set, smscPDU, pdu);
+ }
+ else
+ {
+ smsPduEncode(smsc, (char *)phone_num, (char *)msg, char_set, smscPDU, pdu);
+ }
+ for(index = 0; index < msg_num; index++)
+ {
+ char pdu_data[MAX_PDU_SIZE] = {0};
+ char *p = pdu_data;
+
+ LOGE("index:%d\n",index);
+ LOGE("%s, %s, %d, smscPDU: %s, pdu: %s",__FILE__, __FUNCTION__, __LINE__, smscPDU, pdu[index]);
+ sprintf(p, "%s",smscPDU);
+ LOGE("pdu_data:%s\n", pdu_data);
+ int sc = strlen(pdu_data);
+ sprintf(p+strlen(p), "%s", pdu[index]);
+ LOGE("pdu_data:%s\n", pdu_data);
+
+ int t = strlen(pdu_data);
+ sprintf(cmgs, "%d,%s", (t-sc)/2, pdu_data);
+ LOGE("cmgs:%s\n", cmgs);
+ memset(resp, 0, sizeof(resp));
+
+ err = mbtk_sms_cmgf_set(sms_info_handle, 0);
+ if(err)
+ {
+ LOGE("cmgf set error : %d\n", err);
+ for(index = 0; index < msg_num; index++){
+ free(pdu[index]);
+ pdu[index] = NULL;
+ }
+ free(pdu);
+ pdu = NULL;
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ LOGD("cmgf set success\n");
+ }
+
+ err = mbtk_sms_cmgs_set(sms_info_handle, cmgs, resp);
+ if(err)
+ {
+ LOGE("cmgs send fail\n");
+ for(index = 0; index < msg_num; index++){
+ free(pdu[index]);
+ pdu[index] = NULL;
+ }
+ free(pdu);
+ pdu = NULL;
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ LOGD("cmgs send success, resp:%s\n", resp);
+ }
+
+ }
+ }
+
+ for(index = 0; index < msg_num; index++){
+ free(pdu[index]);
+ pdu[index] = NULL;
+ }
+ free(pdu);
+ pdu = NULL;
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+ * @brief get smsc fuction *
+ * @param [in] len input buf len for smsc,max is 32
+ * @param [out] smsc address for smsc get from this func *
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_get_smsc_address(int len, char *smsc)
+{
+ int ret = -1;
+ int len_t = 0;
+ char smsc_temp[SMSC_MAX_LEN] = {0};
+ char *p1, *p2 ,*substr;
+
+ if(init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(smsc == NULL || len <= 0)
+ {
+ LOGE("smsc is null or len = %d\n",len);
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ ret = mbtk_sms_csca_get(sms_info_handle, smsc_temp);
+ if(smsc_temp[0] == '\0')
+ {
+ LOGE("gsw_get_smsc_address Error : %d\n", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ else
+ {
+ p1 = strchr(smsc_temp, '\"');
+ p2 = strrchr(smsc_temp, '\"');
+ if (p1 && p2 && p2 > p1)
+ {
+ len_t = p2 - p1 - 1;
+ char* substr_t = NULL;
+ substr_t = (char *)malloc(len_t + 1);
+ if(substr_t == NULL)
+ {
+ LOGE("malloc substr_t fail\n");
+ return GSW_HAL_MEM_INVAILD;
+ }
+ strncpy(substr_t, p1 + 1, len_t);
+ substr_t[len_t] = '\0';
+
+ substr = substr_t;
+
+ memcpy(smsc, substr, strlen(substr));
+ memcpy(sms_center_address, substr, strlen(substr));
+
+ LOGE("qser_sms_getsmscenteraddress success, smsc = %s\n", sms_center_address);
+ free(substr_t);
+ }
+ else
+ {
+ LOGE("String inside double quotes not found\n");
+ return GSW_HAL_FAIL;
+ }
+ }
+
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+ * @brief set smsc fuction
+ * @param [out] smsc string value for smsc,max length is 32 *
+ * @retval 0: success
+ * @retval other: fail
+ */
+int gsw_set_smsc_address(const char *smsc)
+{
+ int ret = -1;
+
+ if(init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(smsc == NULL || strlen((char *)smsc) == 0)
+ {
+ LOGE("smsc is null or empty\n");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ ret = mbtk_sms_csca_set(sms_info_handle, (char *)smsc);
+
+ if(ret == 0)
+ {
+ LOGE("set smsc success,smsc = %s\n",smsc);
+ }
+ else
+ {
+ LOGE("set smsc fail,ret = %d\n", ret);
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
\ No newline at end of file
diff --git a/mbtk/libgsw_lib/gsw_tee.c b/mbtk/libgsw_lib/gsw_tee.c
new file mode 100755
index 0000000..2ba8ece
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_tee.c
@@ -0,0 +1,331 @@
+
+#include "gsw/gsw_tee.h"
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+
+#include <tee_client_api.h>
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+struct test_ctx {
+ TEEC_Context ctx;
+ TEEC_Session sess;
+};
+
+
+struct test_ctx ctx;
+
+#define lib_secure_path "/lib/libsecure_storage.so"
+static void *dlHandle_secure;
+
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+static void *dlHandle_mbtk;
+
+
+
+
+
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+
+
+
+int (*prepare_tee_session)(struct test_ctx *ctx);
+void (*terminate_tee_session)(struct test_ctx *ctx);
+TEEC_Result (*read_secure_object)(struct test_ctx *ctx, const char *id,char *data, size_t data_len);
+TEEC_Result (*write_secure_object)(struct test_ctx *ctx, const char *id,char *data, size_t data_len);
+TEEC_Result (*delete_secure_object)(struct test_ctx *ctx, const char *id);
+
+
+static int tee_api_import(void)
+{
+
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ dlHandle_secure = dlopen(lib_secure_path, RTLD_NOW);
+ if (dlHandle_secure == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ prepare_tee_session = (int (*)(struct test_ctx *ctx))dlsym(dlHandle_secure, "prepare_tee_session");
+ if (prepare_tee_session == NULL)
+ {
+ LOGE("prepare_tee_session dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ terminate_tee_session = (void (*)(struct test_ctx *ctx))dlsym(dlHandle_secure, "terminate_tee_session");
+ if (terminate_tee_session == NULL)
+ {
+ LOGE("terminate_tee_session dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ read_secure_object = (TEEC_Result (*)(struct test_ctx *ctx, const char *id,char *data, size_t data_len))dlsym(dlHandle_secure, "read_secure_object");
+ if (read_secure_object == NULL)
+ {
+ LOGE("read_secure_object dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ write_secure_object = (TEEC_Result (*)(struct test_ctx *ctx, const char *id,char *data, size_t data_len))dlsym(dlHandle_secure, "write_secure_object");
+ if (write_secure_object == NULL)
+ {
+ LOGE("write_secure_object dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ delete_secure_object = (TEEC_Result (*)(struct test_ctx *ctx, const char *id))dlsym(dlHandle_secure, "delete_secure_object");
+ if (delete_secure_object == NULL)
+ {
+ LOGE("delete_secure_object dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief init tee sdk
+* @param [in] None
+* @param [out] None
+* @retval GSW_HAL_SUCCESS is success\other is fail
+*/
+int32_t gsw_tee_sdk_init(void)
+{
+ int32_t ret = 0;
+ ret = tee_api_import();
+ if(ret)
+ {
+ LOGE("tee_api_import fail\n");
+ return ret;
+ }
+ ret = prepare_tee_session(&ctx);
+
+ return ret;
+}
+
+
+/**
+* @brief read sensitive data from tee
+* @param [in] char* in_obj_name :Sensitive data name
+* @param [in] unsigned int* p_out_buf_len：The size of sensitive data output cache
+* @param [out] char* out_buf：Cache of sensitive data output
+* @param [out] unsigned int* p_out_buf_len：Sensitive data length
+* @retval GSW_HAL_SUCCESS is success\other is fail
+*/
+#define basic_buf_len 7000
+int32_t gsw_tee_read_secure_data(const char* in_obj_name, char* out_buf, unsigned int* p_out_buf_len)
+{
+ int32_t ret = 0;
+ TEEC_Result res;
+ res = read_secure_object(&ctx, in_obj_name, out_buf, basic_buf_len);
+ if (res != TEEC_SUCCESS)
+ {
+ LOGE("Failed to read an object from the secure storage");
+ ret = -1;
+ }
+
+ *p_out_buf_len = strlen(out_buf);
+ return ret;
+}
+
+
+/**
+* @brief write sensitive data to tee
+* @param [in] char* in_obj_name :Sensitive data name
+* @param [in] char* in_buf：A cache for writing sensitive data
+* @param [out] unsigned int in_buf_len：Sensitive data length
+* @retval GSW_HAL_SUCCESS is success\other is fail
+*/
+int32_t gsw_tee_write_secure_data(const char* in_obj_name, char* in_buf, unsigned int in_buf_len)
+{
+ int32_t ret = 0;
+ TEEC_Result res;
+ res = write_secure_object(&ctx, in_obj_name,in_buf, in_buf_len);
+ if (res != TEEC_SUCCESS)
+ {
+ LOGE("Failed to write an object from the secure storage");
+ ret = -1;
+ }
+
+ return ret;
+}
+
+
+/**
+* @brief delete sensitive data from tee
+* @param [in] char* in_obj_name :Sensitive data name
+* @retval GSW_HAL_SUCCESS is success\other is fail
+*/
+int32_t gsw_tee_delete_secure_data(const char* in_obj_name)
+{
+ int32_t ret = 0;
+ TEEC_Result res;
+ res = delete_secure_object(&ctx, in_obj_name);
+ if (res != TEEC_SUCCESS)
+ {
+ LOGE("Failed to delete the object: 0x%x", res);
+ ret = -1;
+ }
+
+
+ return ret;
+
+}
+
+/**
+* @brief check sensitive data from tee
+* @param [in] char* in_obj_name :Sensitive data name
+* @retval GSW_HAL_SUCCESS is exist\ other is not exist or fail
+*/
+int32_t gsw_tee_check_secure_data(const char* in_obj_name)
+{
+ int32_t ret = 1;
+ TEEC_Result res;
+ char out_buf[4];
+ res = read_secure_object(&ctx, in_obj_name, out_buf, sizeof(out_buf));
+
+ if (res == TEEC_ERROR_ITEM_NOT_FOUND)
+ {
+ LOGE("the obj no found\n");
+ ret = GSW_HAL_NOFOUND;
+ }
+ else if (res == TEEC_SUCCESS)
+ {
+ LOGE("the obj is exist\n");
+ ret = GSW_HAL_SUCCESS;
+ }
+ else
+ {
+ LOGE("Failed to read an object from the secure storage");
+ ret = GSW_HAL_FAIL;
+ }
+
+ return ret;
+}
+
+int32_t gsw_tee_sdk_deinit(void)
+{
+ if (terminate_tee_session) {
+ terminate_tee_session(&ctx); // 终止TEE会话
+ terminate_tee_session = NULL;
+ }
+
+ if (dlHandle_secure) {
+ dlclose(dlHandle_secure); // 卸载安全库
+ dlHandle_secure = NULL;
+ }
+
+ if (dlHandle_mbtk) {
+ dlclose(dlHandle_mbtk); // 卸载日志库
+ dlHandle_mbtk = NULL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
diff --git a/mbtk/libgsw_lib/gsw_uart.c b/mbtk/libgsw_lib/gsw_uart.c
new file mode 100755
index 0000000..5b9738c
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_uart.c
@@ -0,0 +1,388 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
+#include <dlfcn.h>
+
+#include "gsw_uart.h"
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+typedef void (*mbtk_log)(int level, const char *format,...);
+static mbtk_log fun_ptr_log = NULL;
+void *dlHandle_uart = NULL;
+char *lynqLib_uart = "/lib/libmbtk_lib.so";
+
+static int handle()
+{
+ if(dlHandle_uart == NULL || fun_ptr_log == NULL)
+ {
+ dlHandle_uart = dlopen(lynqLib_uart, RTLD_NOW);
+ fun_ptr_log = (mbtk_log)dlsym(dlHandle_uart, "mbtk_log");
+ if(fun_ptr_log == NULL || dlHandle_uart == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+
+
+
+int32_t gsw_uart_open_ex(int8_t *port, gsw_hal_uart_baudrate baudrate, uint32_t bits, int8_t parity, uint32_t stop)
+{
+ if (handle())
+ return GSW_HAL_FAIL;
+ int fd = -1;
+ if((fd = open((const char *)port, O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0)
+ {
+ LOGE("open %s failed - %d", port, errno);
+ return -1;
+ }
+ LOGD("Open %s success.", port);
+
+ /* set newtio */
+ struct termios newtio;
+ memset(&newtio, 0, sizeof(newtio));
+ if (tcflush(fd, TCIOFLUSH) < 0) {
+ LOGE("Could not flush uart port");
+ return -1;
+ }
+
+ newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
+ newtio.c_cc[VMIN] = 0; /* blocking read until 5 chars received */
+
+ /* c_iflag 输入模式 */
+ newtio.c_iflag &= ~(ICRNL | INLCR);
+ newtio.c_iflag &= ~(IXON | IXOFF | IXANY);
+
+ // /* c_lflag 本地模式 */
+ newtio.c_cflag &= ~ INPCK;
+ newtio.c_cflag |= (CLOCAL | CREAD);
+
+ // /* c_lflag 本地模式 */
+ newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
+ /* c_oflag 输出模式 */
+ newtio.c_oflag &= ~ OPOST;
+ newtio.c_oflag &= ~(ONLCR | OCRNL);
+
+ /* c_cflag 控制模式 */
+ newtio.c_cflag &= ~ CSIZE;
+ newtio.c_cflag |= CS8;
+ newtio.c_cflag &= ~ CSTOPB;
+ newtio.c_cflag &= ~ PARENB;
+
+
+ switch(baudrate)
+ {
+ case GSW_HAL_BAUDRATE_1200:
+ cfsetospeed(&newtio, B1200);
+ cfsetispeed(&newtio, B1200);
+ break;
+ case GSW_HAL_BAUDRATE_1800:
+ cfsetospeed(&newtio, B1800);
+ cfsetispeed(&newtio, B1800);
+ break;
+ case GSW_HAL_BAUDRATE_4800:
+ cfsetospeed(&newtio, B4800);
+ cfsetispeed(&newtio, B4800);
+ break;
+ case GSW_HAL_BAUDRATE_9600:
+ cfsetospeed(&newtio, B9600);
+ cfsetispeed(&newtio, B9600);
+ break;
+ case GSW_HAL_BAUDRATE_19200:
+ cfsetospeed(&newtio, B19200);
+ cfsetispeed(&newtio, B19200);
+ break;
+ case GSW_HAL_BAUDRATE_38400:
+ cfsetospeed(&newtio, B38400);
+ cfsetispeed(&newtio, B38400);
+ break;
+ case GSW_HAL_BAUDRATE_57600:
+ cfsetospeed(&newtio, B57600);
+ cfsetispeed(&newtio, B57600);
+ break;
+ case GSW_HAL_BAUDRATE_115200:
+ cfsetospeed(&newtio, B115200);
+ cfsetispeed(&newtio, B115200);
+ break;
+ case GSW_HAL_BAUDRATE_230400:
+ cfsetospeed(&newtio, B230400);
+ cfsetispeed(&newtio, B230400);
+ break;
+ case GSW_HAL_BAUDRATE_460800:
+ cfsetospeed(&newtio, B460800);
+ cfsetispeed(&newtio, B460800);
+ break;
+ case GSW_HAL_BAUDRATE_500000:
+ cfsetospeed(&newtio, B500000);
+ cfsetispeed(&newtio, B500000);
+ break;
+ case GSW_HAL_BAUDRATE_576000:
+ cfsetospeed(&newtio, B576000);
+ cfsetispeed(&newtio, B576000);
+ break;
+ case GSW_HAL_BAUDRATE_921600:
+ cfsetospeed(&newtio, B921600);
+ cfsetispeed(&newtio, B921600);
+ break;
+ default:
+ cfsetospeed(&newtio, B115200);
+ cfsetispeed(&newtio, B115200);
+ break;
+ }
+
+ switch(bits)
+ {
+ case CS5:
+ newtio.c_cflag &= ~CSIZE;
+ newtio.c_cflag |= CS5;
+ break;
+ case CS6:
+ newtio.c_cflag &= ~CSIZE;
+ newtio.c_cflag |= CS6;
+ break;
+ case CS7:
+ newtio.c_cflag &= ~CSIZE;
+ newtio.c_cflag |= CS7;
+ break;
+ case CS8:
+ newtio.c_cflag &= ~CSIZE;
+ newtio.c_cflag |= CS8;
+ break;
+ default:
+ LOGD("No set databit.");
+ break;
+ }
+
+ if(stop == 2) {
+ newtio.c_cflag |= CSTOPB;
+ } else {
+ newtio.c_cflag &= ~CSTOPB;
+ }
+
+ switch (parity)
+ {
+ case '1':// 奇校验
+ newtio.c_cflag |= PARENB;
+ newtio.c_cflag |= PARODD;
+ break;
+ case '2':// 偶校验
+ newtio.c_cflag |= PARENB;
+ newtio.c_cflag &= ~PARODD;
+ break;
+ case '0':// 无奇偶校验
+ newtio.c_cflag &= ~PARENB;
+ break;
+ default:
+ LOGD("No set parity.");
+ break;
+ }
+
+ if (tcsetattr(fd, TCSANOW, &newtio) < 0) {
+ LOGE("Can't set port setting");
+ return -1;
+ }
+
+ return fd;
+}
+
+int32_t gsw_uart_flush(int32_t fd)
+{
+ if (tcflush(fd, TCIOFLUSH) < 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+
+int32_t gsw_uart_read(int32_t fd, uint8_t *buffer, uint32_t len, int32_t timeout_ms)
+{
+ if (handle())
+ return GSW_HAL_FAIL;
+ int flags = fcntl(fd, F_GETFL); // 获取当前状态标志
+ if (flags == -1)
+ {
+ perror("fcntl get");
+ return GSW_HAL_FAIL;
+ }
+
+ struct termios newtio;
+ if (tcgetattr(fd, &newtio) < 0) {
+ perror("tcgetattr failed");
+ return -1;
+ }
+ if (timeout_ms == 0)
+ {
+ flags |= O_NONBLOCK; // 设置非阻塞标志
+ fcntl(fd, F_SETFL, flags);
+ newtio.c_cc[VMIN] = 0;
+ newtio.c_cc[VTIME] = 0;
+ }
+ else if (timeout_ms == 1)
+ {
+ flags &= ~O_NONBLOCK; // 清除非阻塞标志
+ fcntl(fd, F_SETFL, flags);
+ newtio.c_cc[VMIN] = 1;
+ newtio.c_cc[VTIME] = timeout_ms/100;
+ }
+ else
+ {
+ flags &= ~O_NONBLOCK; // 清除非阻塞标志
+ fcntl(fd, F_SETFL, flags);
+ newtio.c_cc[VMIN] = 0;
+ newtio.c_cc[VTIME] = timeout_ms/100;
+ }
+ if(timeout_ms != 0)
+ LOGI("%s :VMIN = %d ;VTIME = %d\n",__func__,newtio.c_cc[VMIN],newtio.c_cc[VTIME]);
+ if (tcsetattr(fd, TCSANOW, &newtio) != 0)
+ {
+ perror("tcsetattr");
+ return -1;
+ }
+ //gsw_uart_flush(fd);
+ int data_len = read(fd, buffer, len);
+ if (data_len < 0)
+ {
+ if(errno == EAGAIN || errno == EWOULDBLOCK)
+ return 0;
+ else
+ return GSW_HAL_FAIL;
+ }
+ return data_len;
+}
+
+
+int32_t gsw_uart_write(int32_t fd, const uint8_t *buffer, uint32_t len)
+{
+ //gsw_uart_flush(fd);
+ if (write(fd, buffer, len) < 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+int32_t gsw_uart_ioctl(int32_t fd, uint32_t cmd, void *pvalue)
+{
+ if (handle())
+ return GSW_HAL_FAIL;
+ if (fd < 0 || pvalue == NULL)
+ {
+ LOGE("Invalid file descriptor");
+ return GSW_HAL_FAIL;
+ }
+ if (ioctl(fd, cmd, pvalue) < 0)
+ {
+ LOGE("Could not set DCB,error:%d, %s\n",errno, strerror(errno));
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+
+
+
+int32_t gsw_uart_close(int32_t fd)
+{
+ if (fd <= 0)
+ return GSW_HAL_FAIL;
+ //gsw_uart_flush(fd);
+ close(fd);
+ return GSW_HAL_SUCCESS;
+}
+
diff --git a/mbtk/libgsw_lib/gsw_voice.c b/mbtk/libgsw_lib/gsw_voice.c
new file mode 100755
index 0000000..a6f0883
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_voice.c
@@ -0,0 +1,1007 @@
+#include "gsw/gsw_voice.h"
+#include <dlfcn.h>
+#include <pthread.h>
+
+// mbtk includes
+
+typedef unsigned int uint32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+
+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
+{
+ uint8 call_wait;
+ uint8 dir1;
+ uint8 dir;
+ uint8 state;
+ uint8 mode;
+ uint8 mpty;
+ char phone_number[100];
+ uint8 type;
+ uint8 pas;
+ uint8 disconnected_id;
+ uint8 end_reason[128];
+} __attribute__((packed)) mbtk_call_info_t;
+
+typedef enum {
+ MBTK_CLCC = 1,
+ MBTK_CPAS,
+ MBTK_DISCONNECTED,
+} mbtk_call_enum;
+
+typedef enum {
+ MBTK_CALL_RADY, //MT allows commands from TA/TE
+ MBTK_CALL_UNAVAILABLE, //MT does not allow commands from TA/TE
+ MBTK_CALL_UNKNOWN, //MT is not guaranteed to respond to instructions
+ MBTK_CALL_RINGING, //MT is ready for commands from TA/TE, but the ringer is active
+ MBTK_CALL_PROGRESS, //MT is ready for commands from TA/TE, but a call is in progress
+ MBTK_CALL_ASLEEP, //MT is unable to process commands from TA/TE because it is in a low functionality state
+ MBTK_CALL_ACTIVE,
+} mbtk_call_pas_enum;
+
+
+//----------------end_reason start------------
+//mbtk end_reason define
+#define MBTK_VOICE_END_REASON_UNKNOWN "0 "
+#define MBTK_VOICE_END_REASON_UNASSIGNED_NUMBER "1 "
+#define MBTK_VOICE_END_REASON_NO_ROUTE_DES "3 "
+#define MBTK_VOICE_END_REASON_CHANNEL_UNACCEPTABLE "6 "
+#define MBTK_VOICE_END_REASON_OPERATOR_DETERMINED_BARRING "8 "
+#define MBTK_VOICE_END_REASON_NORMAL_CALL_CLEARING "16 "
+#define MBTK_VOICE_END_REASON_USER_BUSY "17 "
+#define MBTK_VOICE_END_REASON_NO_USER_RESPONDING "18 "
+#define MBTK_VOICE_END_REASON_USER_ALERTING_NO_ANSWER "19 "
+#define MBTK_VOICE_END_REASON_CALL_REJECTED "21 "
+#define MBTK_VOICE_END_REASON_NUMBER_CHANGED "22 "
+#define MBTK_VOICE_END_REASON_PREEMPTION "25 "
+#define MBTK_VOICE_END_REASON_NON_SELECTED_USER_CLEARING "26 "
+#define MBTK_VOICE_END_REASON_DESTINATION_OUT_OF_ORDER "27 "
+#define MBTK_VOICE_END_REASON_INVALID_NUMBER_FORMAT "28 "
+#define MBTK_VOICE_END_REASON_FACILITY_REJECTED "29 "
+#define MBTK_VOICE_END_REASON_STATUS_ENQUIRY "30 "
+#define MBTK_VOICE_END_REASON_NORMAL_UNSPECIFIED "31 "
+#define MBTK_VOICE_END_REASON_NO_CIRCUIT_AVAILABLE "34 "
+#define MBTK_VOICE_END_REASON_NETWORK_OUT_OF_ORDER "38 "
+#define MBTK_VOICE_END_REASON_TEMPORARY_FAILURE "41 "
+#define MBTK_VOICE_END_REASON_SWITCHING_EQUIPMENT_CONGESTION "42 "
+#define MBTK_VOICE_END_REASON_ACCESS_INFORMATION_DISCARDED "43 "
+#define MBTK_VOICE_END_REASON_REQUESTED_CIRCUIT_UNAVAILABLE "44 "
+#define MBTK_VOICE_END_REASON_RESOURCE_UNAVAILABLE "47 "
+#define MBTK_VOICE_END_REASON_QOS_UNAVAILABLE "49 "
+#define MBTK_VOICE_END_REASON_REQUESTED_FACILITY_NOT_SUBSCRIBED "50 "
+#define MBTK_VOICE_END_REASON_INCOMING_CALLS_BARRED_WITHIN_CUG "55 "
+#define MBTK_VOICE_END_REASON_BEARER_CAPABILITY_NOT_AUTHORIZED "57 "
+#define MBTK_VOICE_END_REASON_BEARER_CAPABILITY_NOT_AVAILABLE "58 "
+#define MBTK_VOICE_END_REASON_SERVICE_NOT_AVAILABLE "63 "
+#define MBTK_VOICE_END_REASON_BEARER_SERVICE_NOT_IMPLEMENTED "65 "
+#define MBTK_VOICE_END_REASON_ACM_MAX_REACHED "68 "
+#define MBTK_VOICE_END_REASON_FACILITY_NOT_IMPLEMENTED "69 "
+#define MBTK_VOICE_END_REASON_ONLY_RDI_BEARER_CAPABILITY_AVAILABLE "70 "
+#define MBTK_VOICE_END_REASON_SERVICE_NOT_IMPLEMENTED "79 "
+#define MBTK_VOICE_END_REASON_INVALID_TRANSACTION_ID "81 "
+#define MBTK_VOICE_END_REASON_USER_NOT_MEMBER_OF_CUG "87 "
+#define MBTK_VOICE_END_REASON_INCOMPATIBLE_DESTINATION "88 "
+#define MBTK_VOICE_END_REASON_INVALID_TRANSIT_NETWORK_SELECTION "91 "
+#define MBTK_VOICE_END_REASON_INCORRECT_MESSAGE "95 "
+#define MBTK_VOICE_END_REASON_INVALID_MANDATORY_INFORMATION "96 "
+#define MBTK_VOICE_END_REASON_MESSAGE_TYPE_NON_EXISTENT "97 "
+#define MBTK_VOICE_END_REASON_MESSAGE_TYPE_WRONG_STATE "98 "
+#define MBTK_VOICE_END_REASON_INFORMATION_ELEMENT_NOT_EXISTENT "99 "
+#define MBTK_VOICE_END_REASON_CONDITIONAL_IE_ERROR "100 "
+#define MBTK_VOICE_END_REASON_MESSAGE_WRONG_STATE "101 "
+#define MBTK_VOICE_END_REASON_RECOVERY_AFTER_TIMER_EXPIRY "102 "
+#define MBTK_VOICE_END_REASON_PROTOCOL_ERROR_UNSPECIFIED "111 "
+#define MBTK_VOICE_END_REASON_INERWORKING_UNSPECIFIED "127 "
+#define MBTK_VOICE_END_REASON_CALL_BARRING "224 "
+#define MBTK_VOICE_END_REASON_FDN_BLOCKED "241 "
+#define MBTK_VOICE_END_REASON_END "end"
+
+typedef enum{
+ GSW_LOCAL_END_NORMAL = 0,
+ GSW_PEER_END_NORMAL,
+ GSW_OTHER_END_NORMAL,
+ GSW_END_ABNORMAL,
+} gsw_call_end_reason_enum;
+
+//mbtk end_reason enum define
+typedef struct {
+ char mbtk_end_reason[128];
+ gsw_call_end_reason_enum end_reason;
+}end_reason_t;
+
+end_reason_t g_end_reason[] = {
+{MBTK_VOICE_END_REASON_UNASSIGNED_NUMBER, GSW_PEER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NO_ROUTE_DES, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_CHANNEL_UNACCEPTABLE, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_OPERATOR_DETERMINED_BARRING, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_NORMAL_CALL_CLEARING, GSW_LOCAL_END_NORMAL},
+{MBTK_VOICE_END_REASON_USER_BUSY, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NO_USER_RESPONDING, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_USER_ALERTING_NO_ANSWER, GSW_LOCAL_END_NORMAL},
+{MBTK_VOICE_END_REASON_CALL_REJECTED, GSW_LOCAL_END_NORMAL},
+{MBTK_VOICE_END_REASON_NUMBER_CHANGED, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_PREEMPTION, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NON_SELECTED_USER_CLEARING, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_DESTINATION_OUT_OF_ORDER, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_INVALID_NUMBER_FORMAT, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_FACILITY_REJECTED, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_STATUS_ENQUIRY, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NORMAL_UNSPECIFIED, GSW_PEER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NO_CIRCUIT_AVAILABLE, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NETWORK_OUT_OF_ORDER, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_TEMPORARY_FAILURE, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_SWITCHING_EQUIPMENT_CONGESTION, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_ACCESS_INFORMATION_DISCARDED, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_REQUESTED_CIRCUIT_UNAVAILABLE, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_SERVICE_NOT_AVAILABLE, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_END, GSW_OTHER_END_NORMAL}
+
+};
+
+int gsw_global_end_reason = GSW_OTHER_END_NORMAL;
+
+//----------------end_reason end------------
+
+
+typedef uint32_t voice_client_handle_type;
+
+
+
+static mbtk_info_handle_t* call_info_handle = NULL;
+static int level_call = 0;
+int gsw_voice_init_flag = 0;
+int auto_answer_flag = 0;
+voice_client_handle_type g_call_val = -1;
+CallStateInd gsw_voice_callback = NULL;
+
+
+int state_t = 0;
+char* phone_num_t = NULL;
+char* phone_num_t2 = NULL;
+int call_id_t = 0;
+int call_id_t2 = 0;
+
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+static void *dlHandle_mbtk;
+
+static mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
+int (*mbtk_call_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
+int (*mbtk_call_start)(mbtk_info_handle_t* handle, char* phone_number);
+int (*mbtk_call_hang)(mbtk_info_handle_t* handle);
+int (*mbtk_a_call_hang)(mbtk_info_handle_t* handle, int phone_id);
+int (*mbtk_call_answer)(mbtk_info_handle_t* handle);
+int (*mbtk_call_reg_get)(mbtk_info_handle_t* handle, mbtk_call_info_t *reg);
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+
+/*rtp begin*/
+int (*mbtk_rtp_init)();
+int (*mbtk_rtp_deinit)();
+int (*mbtk_rtp_enable)(bool enable);
+int (*mbtk_rtp_remote_ip_set)(const char *ipv4);
+int (*mbtk_rtp_server_port_set)(int port);
+int (*mbtk_rtp_client_port_set)(int port);
+int (*mbtk_rtp_sample_rate_set)(int sample_rate);
+int (*mbtk_rtp_channel_set)(int channel);
+/*rtp end*/
+
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+static int mbtk_rtp_api_import()
+{
+ mbtk_rtp_init = (int (*)(void))dlsym(dlHandle_mbtk, "mbtk_rtp_init");
+ if (mbtk_rtp_init == NULL)
+ {
+ LOGE("mbtk_rtp_init dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_deinit = (int (*)(void))dlsym(dlHandle_mbtk, "mbtk_rtp_deinit");
+ if (mbtk_rtp_deinit == NULL)
+ {
+ LOGE("mbtk_rtp_deinit dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_enable = (int (*)(bool enable))dlsym(dlHandle_mbtk, "mbtk_rtp_enable");
+ if (mbtk_rtp_enable == NULL)
+ {
+ LOGE("mbtk_rtp_enable dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_remote_ip_set = (int (*)(const char *ipv4))dlsym(dlHandle_mbtk, "mbtk_rtp_remote_ip_set");
+ if (mbtk_rtp_remote_ip_set == NULL)
+ {
+ LOGE("mbtk_rtp_remote_ip_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_server_port_set = (int (*)(int port))dlsym(dlHandle_mbtk, "mbtk_rtp_server_port_set");
+ if (mbtk_rtp_server_port_set == NULL)
+ {
+ LOGE("mbtk_rtp_server_port_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_client_port_set = (int (*)(int port))dlsym(dlHandle_mbtk, "mbtk_rtp_client_port_set");
+ if (mbtk_rtp_client_port_set == NULL)
+ {
+ LOGE("mbtk_rtp_client_port_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_sample_rate_set = (int (*)(int sample_rate))dlsym(dlHandle_mbtk, "mbtk_rtp_sample_rate_set");
+ if (mbtk_rtp_sample_rate_set == NULL)
+ {
+ LOGE("mbtk_rtp_sample_rate_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_rtp_channel_set = (int (*)(int channel))dlsym(dlHandle_mbtk, "mbtk_rtp_channel_set");
+ if (mbtk_rtp_channel_set == NULL)
+ {
+ LOGE("mbtk_rtp_channel_set dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+
+static int mbtk_call_api_import()
+{
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+ if (mbtk_info_handle_get == NULL)
+ {
+ LOGE("mbtk_info_handle_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_call_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_call_state_change_cb_reg");
+ if(mbtk_call_state_change_cb_reg == NULL)
+ {
+ LOGE("mbtk_call_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_call_start = (int (*)(mbtk_info_handle_t* handle, char* phone_number))dlsym(dlHandle_mbtk, "mbtk_call_start");
+ if(mbtk_call_start == NULL)
+ {
+ LOGE("mbtk_call_start dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_call_answer = (int (*)(mbtk_info_handle_t* handle))dlsym(dlHandle_mbtk, "mbtk_call_answer");
+ if(mbtk_call_answer == NULL)
+ {
+ LOGE("mbtk_call_answer dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_call_hang = (int (*)(mbtk_info_handle_t* handle))dlsym(dlHandle_mbtk, "mbtk_call_hang");
+ if(mbtk_call_hang == NULL)
+ {
+ LOGE("mbtk_call_hang dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_a_call_hang = (int (*)(mbtk_info_handle_t* handle, int phone_id))dlsym(dlHandle_mbtk, "mbtk_a_call_hang");
+ if(mbtk_a_call_hang == NULL)
+ {
+ LOGE("mbtk_a_call_hang dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_call_reg_get = (int (*)(mbtk_info_handle_t* handle, mbtk_call_info_t *reg))dlsym(dlHandle_mbtk, "mbtk_call_reg_get");
+ if(mbtk_call_reg_get == NULL)
+ {
+ LOGE("mbtk_call_reg_get dlsym fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ return mbtk_rtp_api_import();
+}
+
+static int end_reason_mbtk_to_gsw(char* mbtk_reason)
+{
+ LOGE("mbtk_reason:%s\n", mbtk_reason);
+ gsw_global_end_reason = GSW_OTHER_END_NORMAL;
+ for(int i = 0; 0 != strncmp(g_end_reason[i].mbtk_end_reason, MBTK_VOICE_END_REASON_END, strlen(MBTK_VOICE_END_REASON_END)); i++)
+ {
+ if(0 == strncmp(mbtk_reason, g_end_reason[i].mbtk_end_reason, strlen(g_end_reason[i].mbtk_end_reason)))
+ {
+ gsw_global_end_reason = g_end_reason[i].end_reason;
+ LOGE("gsw_global_end_reason:%d\n", gsw_global_end_reason);
+ break;
+ }
+ }
+
+ return 0;
+}
+
+void gsw_call_state_change_cb(const void *data, int data_len)
+{
+ mbtk_call_info_t *reg = (mbtk_call_info_t *)data;
+ switch (reg->call_wait)
+ {
+ case MBTK_CLCC:
+ {
+ LOGD("RING : %d, %d, %d, %d, %d, %s, %d, %d, end_reason:%s", reg->dir1, reg->dir, reg->state, reg->mode, reg->mpty, reg->phone_number, reg->type, reg->disconnected_id, reg->end_reason);
+ switch(reg->state)
+ {
+ case 0:
+ state_t = GSW_VOICE_CALL_CONNECTED;
+ break;
+ case 1:
+ state_t = GSW_VOICE_CALL_HOLDING;
+ break;
+ case 2:
+ state_t = GSW_VOICE_CALL_DIALING;
+ break;
+ case 3:
+ state_t = GSW_VOICE_CALL_ALERTING;
+ break;
+ case 4:
+ state_t = GSW_VOICE_CALL_INCOMING;
+ break;
+ case 5:
+ state_t = GSW_VOICE_CALL_WAITING;
+ break;
+ case 6:
+ {
+ state_t = GSW_VOICE_CALL_END;
+ call_id_t = reg->dir1;
+ end_reason_mbtk_to_gsw((char *)reg->end_reason);
+ break;
+ }
+
+ }
+
+ if(gsw_voice_callback)
+ {
+ gsw_voice_callback(reg->dir1, state_t);
+ }
+
+ }
+ break;
+ case MBTK_DISCONNECTED:
+ {
+ LOGD("RING : call dis connected!");
+ LOGD("RING : %d, %d, %d, %d, %d, %s, %d, %d, end_reason:%s", reg->dir1, reg->dir, reg->state, reg->mode, reg->mpty, reg->phone_number, reg->type, reg->disconnected_id, reg->end_reason);
+ state_t = GSW_VOICE_CALL_END;
+ call_id_t = reg->dir1;
+ end_reason_mbtk_to_gsw((char *)reg->end_reason);
+ if(gsw_voice_callback)
+ {
+ gsw_voice_callback(reg->disconnected_id, state_t);
+ }
+ }
+ break;
+ case MBTK_CPAS:
+ LOGD("CALL : Call state = %d", reg->pas);
+ switch (reg->pas)
+ {
+ case MBTK_CALL_RADY:
+ LOGD("CALL: call READY");
+ break;
+ case MBTK_CALL_UNAVAILABLE:
+ LOGD("CALL: call unavaliable");
+ break;
+ case MBTK_CALL_UNKNOWN:
+ LOGD("CALL: call unknown");
+ break;
+ case MBTK_CALL_RINGING:
+ LOGD("CALL: call ringing");
+ break;
+ case MBTK_CALL_PROGRESS:
+ LOGD("CALL: call progress");
+ break;
+ case MBTK_CALL_ASLEEP:
+ LOGD("CALL: call asleep");
+ break;
+ case MBTK_CALL_ACTIVE:
+ LOGD("CALL: call active");
+ break;
+ default:
+ //LOGE("\r\n");
+ break;
+ }
+ break;
+ default:
+ LOGE("RING : None call_wait = %d", reg->call_wait);
+ break;
+ }
+}
+
+
+/**
+* @brief init voice sdk,and register the status indicated callback function
+* @param [in] CallStateInd ind: status indicated callback function
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_sdk_init(CallStateInd ind)
+{
+ int ret;
+
+ if (gsw_voice_init_flag == 1 && call_info_handle != NULL)
+ {
+ return GSW_HAL_SUCCESS;
+ }
+
+ if(ind == NULL)
+ {
+ LOGE("parameter is null\n");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ ret = mbtk_call_api_import();
+ if(ret != 0)
+ {
+ if(mbtk_log != NULL)
+ {
+ LOGE("[gsw_voice_sdk_init]mbtk_call_api_import fail\n");
+ }
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_log_init("syslog", "MBTK_RIL");
+
+
+ if(ret < 0)
+ {
+ LOGE("mbtk_call_api_import fail,ret = %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+
+ ret=mbtk_rtp_init();
+
+ if(ret!=0)
+ {
+ LOGE("[gsw_voice_sdk_init]mbtk_rtp_init fail\n");
+ return GSW_HAL_FAIL;
+ }
+
+ if(call_info_handle == NULL)
+ {
+ call_info_handle = mbtk_info_handle_get();
+ if(call_info_handle != NULL)
+ {
+ LOGE("create gsw_voice_sdk_init success\n");
+
+ ret = mbtk_call_state_change_cb_reg(call_info_handle, gsw_call_state_change_cb);
+ if(ret)
+ {
+ LOGE("mbtk_call_state_change_cb_reg fail,ret = %d\n",ret);
+ (void) mbtk_rtp_deinit();
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ gsw_voice_init_flag = 1;
+ gsw_voice_callback = ind;
+ LOGE("create gsw_voice_sdk_init success\n");
+ return GSW_HAL_SUCCESS;
+ }
+
+ }
+
+ else
+ {
+ (void) mbtk_rtp_deinit();
+ LOGE("create gsw_voice_sdk_init fail\n");
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set speaker_volume
+* @param [in] int32_t volume：1(Min)-7(Max)
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_set_speaker_volume(int32_t volume)
+{
+ //UNUSED(volume);
+
+#if 0
+
+ if(volume < 0 || volume > 5)
+ {
+ level_call = 0;
+ }
+ else
+ {
+ //支持-36~12
+ switch(volume)
+ {
+ case 0 :
+ level_call = -20;
+ break;
+ case 1 :
+ level_call = -14;
+ break;
+ case 2 :
+ level_call = -8;
+ break;
+ case 3 :
+ level_call = 0;
+ break;
+ case 4 :
+ level_call = 5;
+ break;
+ case 5 :
+ level_call = 12;
+ break;
+ default:
+ break;
+ }
+ }
+
+ mbtk_audio_dsp_set(1, level_call);
+ if(err)
+ {
+ LOGE("Error : %d\n", err);
+ return -1;
+ }
+ else
+ {
+ LOGE("Set success.\n");
+ }
+#endif
+
+ char cmd[128] = {0};
+ int lv = 0;
+
+ memset(cmd ,0x00, sizeof(cmd));
+
+ if(volume < 1 || volume > 7)
+ {
+ LOGE("Error volume : %d", volume);
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ switch(volume)
+ {
+ case 1 :
+ lv = -36;
+ break;
+ case 2 :
+ lv = -36;
+ break;
+ case 3 :
+ lv = -27;
+ break;
+ case 4 :
+ lv = -18;
+ break;
+ case 5 :
+ lv = -9;
+ break;
+ case 6 :
+ lv = 0;
+ break;
+ case 7:
+ lv = 12;
+ break;
+ default:
+ break;
+ }
+ }
+
+ sprintf(cmd, "ubus call audio_if config_dspgain \"{\'type\':%d,\'gain\':%d}\"", 1, lv);
+// sLOGE(cmd, "ubus call audio_if volume_set \'{\"param0\":%d}\'", lv);
+ int err = system(cmd);
+ if ((err != -1) && (err != 127))
+ {
+ LOGE("Set success.");
+ level_call = volume;
+ }
+ else
+ {
+ LOGE("Error : %d", err);
+ return GSW_HAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief start a voice call
+* @param [in] char *callNumber
+* @param [out] CallHandle *handle
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_normal_voice_start(CallHandle *handle, const char *callNumber)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ mbtk_call_info_t reg = {0};
+ int ret = -1;
+
+
+ if(handle == NULL)
+ {
+ LOGE("handle is null\n");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+ if(callNumber == NULL)
+ {
+ LOGE("callNumber is null\n");
+ return GSW_HAL_MEM_INVAILD;
+ }
+
+
+ ret = mbtk_call_start(call_info_handle, (char *)callNumber);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_call_start fail,ret = %d\n",ret);
+ return GSW_HAL_FAIL;
+ }
+
+ //get call id
+ mbtk_call_reg_get(call_info_handle, ®);
+ LOGE("call id = %d\n",reg.dir1);
+ *handle = reg.dir1;
+ LOGE("gsw_voice_normal_voice_start id = %d\n", (int)*handle);
+
+
+ return GSW_HAL_SUCCESS;
+
+}
+
+/**
+* @brief answer a voice call
+* @param [in] CallHandle handle
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_answer(CallHandle handle)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int ret = -1;
+
+
+ ret = mbtk_call_answer(call_info_handle);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_call_answer fail,ret = %d\n", ret);
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_call_answer success\n");
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+* @brief hangup a voice call
+* @param [in] CallHandle handle
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_hangup(CallHandle handle)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int ret = -1;
+
+ ret = mbtk_a_call_hang(call_info_handle,handle);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_a_call_hang fail,ret = %d\n", ret);
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_a_call_hang success\n");
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set auto answer mode
+* @param [in] int32_t mode:0-1, 0:NO(close auto answer), 1:YES(auto answer)
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_set_auto_answer_mode(int32_t mode)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ if(mode == 1)
+ {
+ int ret = -1;
+
+ ret = mbtk_call_answer(call_info_handle);
+ if(ret != 0)
+ {
+ LOGE("mbtk_call_answer fail,ret = %d\n", ret);
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_call_answer success\n");
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+int32_t gsw_voice_get_current_call_end_reason(CallHandle handle)
+{
+ if(gsw_voice_init_flag == 0 || call_info_handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int reason = gsw_global_end_reason;
+
+ return reason;
+}
+
+
+
+/*##########################################rtp begin*/
+/**
+* @brief set audio mode
+* @param [in] AudioMode audioMode
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_set_audio_mode(AudioMode audioMode)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int ret=mbtk_rtp_enable(audioMode);
+ if(ret !=0 )
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set rtp ip address of remote
+* @param [in] char *ip :ip address
+* @param [in] int32_t len: length
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_set_remote_rtp_ip(const char *ip, int32_t len)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int ret=mbtk_rtp_remote_ip_set(ip);
+ if(ret !=0 )
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set rtp mode and port
+* @param [in] RTPMode rtpMode: rtp mode
+* @param [in] int32_t port:rtp port
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_set_rtp_port(RTPMode rtpMode, int32_t port)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int ret;
+ if(rtpMode==GSW_RTP_CLIENT)
+ {
+ ret = mbtk_rtp_client_port_set(port);
+ }
+ else
+ {
+ ret = mbtk_rtp_server_port_set(port);
+ }
+ if(ret !=0 )
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set rtp mode and port
+* @param [in] int32_t clockRate: clock rate
+* @param [in] int32_t channel:channel
+* @param [in] int32_t latency:latency
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_voice_set_rtp_param(int32_t clockRate, int32_t channel, int32_t latency)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_FAIL;
+ }
+
+ int ret=mbtk_rtp_channel_set(channel);
+ if(ret==0)
+ {
+ ret=mbtk_rtp_sample_rate_set(clockRate);
+ }
+ if(ret !=0 )
+ {
+ return GSW_HAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+/*##########################################rtp end*/
+
diff --git a/mbtk/libgsw_lib/libgsw_ota.c b/mbtk/libgsw_lib/libgsw_ota.c
new file mode 100755
index 0000000..93d1a6a
--- /dev/null
+++ b/mbtk/libgsw_lib/libgsw_ota.c
@@ -0,0 +1,552 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <stdint.h>
+
+#include <errno.h>
+#include <stdbool.h>
+
+#include "gsw_ota.h"
+
+
+
+#define LYNQ_OTA_INPROCESS 3
+#define LYNQ_OTA_SUCCESS 4
+#define LYNQ_OTA_FAILED 5
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+
+#define LIB_PATH "/lib/libmbtk_lib.so"
+
+
+#define StatFunc(x,y) stat(x,y)
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+
+
+typedef int (*mbtk_fota_get_active_absys_type)(void);
+typedef int (*mbtk_fota_fw_write)(char* fname, int segment_size);
+typedef int (*mbtk_fota_fw_write_by_url)(char* url, int segment_size,
+ int conn_timeout, int download_timeout);
+
+typedef int(*fota_callback)(int state, int percent);
+typedef int (*mbtk_fota_init)(fota_callback cb);
+typedef int (*mbtk_fota_status)(void);
+
+typedef void (*mbtk_log)(int level, const char *format,...);
+
+static int segment_size =0;
+static int Process_flag = 0;
+char addr_buf[256] = {0};
+static void *handle = NULL;
+static mbtk_log fun_ptr_log = NULL;
+
+static int s_ota_flag = -1;
+
+int fota_cb(int status, int percent)
+{
+ Process_flag = percent;
+ return 0;
+}
+
+static int funstat( char *filename)
+{
+ int ret = 0;
+ struct stat tmep_s;
+
+ memset(&tmep_s, 0, sizeof(stat));
+ ret = StatFunc(filename, &tmep_s);
+
+ if (ret)
+ {
+ LOGE("stat %s failed! error_code: %s", filename ,strerror(errno));
+ return -1;
+ }
+
+ if (tmep_s.st_size > 0)
+ {
+ segment_size = tmep_s.st_size;
+ }
+
+ return 0;
+}
+
+int32_t init_handle()
+{
+ if(handle == NULL)
+ {
+ handle = dlopen(LIB_PATH, RTLD_NOW );
+ if(handle == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ if(fun_ptr_log == NULL)
+ {
+ fun_ptr_log = (mbtk_log)dlsym(handle, "mbtk_log");
+ if(fun_ptr_log == NULL)
+ {
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ }
+
+
+
+ return GSW_HAL_SUCCESS;
+}
+
+void deinit_handle()
+{
+ dlclose(handle);
+ handle = NULL;
+ fun_ptr_log = NULL;
+
+}
+
+/**
+* @brief Start install modem software
+* @param [in] char* file_path
+* @param [out] NULL
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_start_autobackup(char* file_path)
+{
+
+ if(file_path == NULL)
+ {
+ LOGE("invalid file_path \n");
+ return GSW_HAL_FAIL;
+ }
+
+
+ mbtk_fota_fw_write func_ptr_update = NULL;
+ mbtk_fota_init func_ptr_init= NULL;
+ mbtk_fota_fw_write_by_url func_ptr_update_url = NULL;
+
+
+
+ int ret = -1;
+ ret = init_handle();
+ if(ret < 0)
+ {
+ LOGE("init_handle fail");
+ return GSW_HAL_FAIL;
+ }
+
+ func_ptr_update_url = (mbtk_fota_fw_write_by_url)dlsym(handle, "mbtk_fota_fw_write_by_url");
+ if(func_ptr_update_url == NULL)
+ {
+ LOGE("Error: %s", dlerror());
+ return GSW_HAL_FAIL;
+ }
+
+
+ // Get the function pointer
+ func_ptr_update = (mbtk_fota_fw_write)dlsym(handle, "mbtk_fota_fw_write");
+ if (func_ptr_update == NULL)
+ {
+ LOGE("Error: %s", dlerror());
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+
+ func_ptr_init = (mbtk_fota_init)dlsym(handle, "mbtk_fota_init");
+ if(func_ptr_init == NULL)
+ {
+ LOGE("Error: %s", dlerror());
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+
+
+ if(s_ota_flag == -1)
+ {
+ ret = func_ptr_init(fota_cb);
+ if(ret < 0)
+ {
+ LOGE("Error: mbtk_fota_init failed");
+
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ s_ota_flag = 0;
+ }
+ }
+
+ if(strncmp(file_path, "http", 4) == 0)
+ {
+ segment_size = 62914560;
+ ret = func_ptr_update_url(file_path, segment_size,10, 600);
+ }
+ else
+ {
+ if(strstr(file_path,"updata.bin") == NULL)
+ {
+ LOGE("Bad file path ");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+ else
+ {
+ if(access(file_path,F_OK) !=0)
+ {
+ LOGE("update file no exist");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+ }
+
+ ret = funstat(file_path);
+ if (ret)
+ {
+ LOGE("get segment_size fail");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+ ret = func_ptr_update(file_path, segment_size);
+ if(ret < 0)
+ {
+ LOGE("Error: mbtk_fota_fw_write failed\n");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+ }
+ return GSW_HAL_SUCCESS;
+
+}
+
+/**
+* @brief check the modem update condition
+* @param [in] NULL
+* @param [out] NULL
+* @retval TRUE/FALSE
+*/
+bool gsw_update_modem_check_condition(void)
+{
+ char command[32] = {0};
+ char buffer[64] = {0};
+ const char *process_ota = "{otad}";
+
+ snprintf(command,sizeof(command), "ps | grep %s | grep -v grep", process_ota);
+ FILE *fp = popen(command, "r");
+ if (fp == NULL)
+ {
+ return false;
+ }
+
+ if(fgets(buffer, sizeof(buffer), fp)!= NULL)
+ {
+ pclose(fp);
+ return true;
+ }
+ pclose(fp);
+ return false;
+
+}
+
+/**
+* @brief get update modem result
+* @param [in] NULL
+* @param [out] NULL
+* @retval E_GSW_OTA_RET
+*/
+E_GSW_OTA_RET gsw_update_modem_result_query(void)
+{
+
+ mbtk_fota_status func_ptr_get_result = NULL;
+ int ret = -1;
+
+ ret = init_handle();
+ if(ret < 0)
+ {
+ LOGE("init_handle fail");
+ return GSW_HAL_FAIL;
+ }
+
+ // Get the function pointer
+ func_ptr_get_result = (mbtk_fota_status)dlsym(handle, "mbtk_fota_status");
+ if (func_ptr_get_result == NULL)
+ {
+ LOGE("Error: %s\n", dlerror());
+ return GSW_HAL_FAIL;
+ }
+ ret = func_ptr_get_result();
+ if(ret < 0 && ret !=-1)
+ {
+ LOGE("Error: mbtk_fota_status failed\n");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+
+ deinit_handle();
+
+ if(ret == LYNQ_OTA_INPROCESS)
+ {
+ return GSW_OTA_INPROCESS;
+
+ }
+ else if(ret == LYNQ_OTA_SUCCESS)
+ {
+ return GSW_OTA_SUCCESS;
+ }
+ else if(ret == -1)
+ {
+ return GSW_OTA_NO_TASK;
+ }
+
+ return GSW_OTA_FAILURE;
+
+
+}
+
+/**
+* @brief Start install modem software
+* @param [in] char* file_path
+* @param [out] NULL
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_start_nobackup(char* file_path)
+{
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+* @brief get current system
+* @param [in] NULL
+* @param [out] NULL
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+E_GSW_OTA_SYSTEM gsw_update_modem_get_system(void)
+{
+ int ret = -1;
+
+ mbtk_fota_get_active_absys_type func_ptr;
+ ret = init_handle();
+ if(ret < 0)
+ {
+ LOGE("init_handle fail");
+ return GSW_HAL_FAIL;
+ }
+
+ // Get the function pointer
+ func_ptr = (mbtk_fota_get_active_absys_type)dlsym(handle, "mbtk_fota_get_active_absys_type");
+ if (func_ptr == NULL)
+ {
+ LOGE("Error: %s", dlerror());
+ return GSW_HAL_FAIL;
+ }
+ ret = func_ptr();
+ if(ret < 0)
+ {
+ LOGE("Error: mbtk_fota_get_active_absys_type failed");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+
+ }
+
+ deinit_handle();
+
+ return ret;
+
+}
+
+/**
+* @brief cancel update
+* @param [in] NULL
+* @param [out] NULL
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_cancel(void)
+{
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief get modem update info
+* @param [in] NULL
+* @param [out] gsw_update_info_s
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_get_info(gsw_update_info_s *update_info)
+{
+ int ret = -1;
+
+ mbtk_fota_status func_ptr_get_info = NULL;
+
+ ret = init_handle();
+ if(ret < 0)
+ {
+ LOGE("init_handle fail");
+ return GSW_HAL_FAIL;
+ }
+
+ // Get the function pointer
+ func_ptr_get_info = (mbtk_fota_status)dlsym(handle, "mbtk_fota_status");
+ if (func_ptr_get_info == NULL)
+ {
+ LOGE("Error: %s\n", dlerror());
+ return GSW_HAL_FAIL;
+ }
+ ret = func_ptr_get_info();
+ if(ret < 0 && ret != -1)
+ {
+ LOGE("Error: mbtk_fota_status failed\n");
+ deinit_handle();
+ return GSW_HAL_FAIL;
+ }
+
+ //升级成功之后，未重启，不可重复升级
+ if(ret == LYNQ_OTA_INPROCESS)
+ {
+ update_info->exit_code = GSW_UPDATE_NOGOING;
+ update_info->percentage = Process_flag;
+ update_info->update_state = GSW_UPDATE_INPROGRESS;
+ }
+ if(ret == LYNQ_OTA_SUCCESS)
+ {
+ update_info->exit_code = GSW_UPDATE_NOERROR;
+ update_info->percentage = Process_flag;
+ update_info->update_state = GSW_UPDATE_WAITEDONE;
+ }
+
+
+ if(ret == LYNQ_OTA_FAILED || ret == -1)
+ {
+ update_info->exit_code = GSW_UPDATE_GETOLDSOFTWAREFAILED;
+ update_info->percentage = Process_flag;
+ update_info->update_state = GSW_UPDATE_FAILED;
+ }
+
+ deinit_handle();
+ return GSW_HAL_SUCCESS;
+
+}
+
+
+/**
+* @brief get modem system status
+* @param [in] NULL
+* @param [out] gsw_system_status_s
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_get_status(gsw_system_status_s *system_status)
+{
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief A/B system sync
+* @param [in] NULL
+* @param [out] NULL
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_sync(void)
+{
+ return GSW_HAL_SUCCESS;
+
+}
+
+/**
+* @brief A/B system switch
+* @param [in] NULL
+* @param [out] NULL
+* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
+*/
+int32_t gsw_update_modem_switch(void)
+{
+ return GSW_HAL_SUCCESS;
+}
diff --git a/mbtk/libgsw_lib/libgsw_passwd.c b/mbtk/libgsw_lib/libgsw_passwd.c
new file mode 100755
index 0000000..ef3fdda
--- /dev/null
+++ b/mbtk/libgsw_lib/libgsw_passwd.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
+#include <dlfcn.h>
+
+
+#include "gsw_passwd.h"
+
+
+int gsw_set_passwd(char *username, char *passwd)
+{
+ int ret;
+ char cmd[256];
+ if((username == NULL) || (passwd ==NULL))
+ {
+ return -1;
+ }
+ sprintf(cmd, "echo \"%s:%s\"|chpasswd", username, passwd);
+ ret = system(cmd);
+ return ret;
+}
diff --git a/mbtk/libgsw_lib/libgsw_usb.c b/mbtk/libgsw_lib/libgsw_usb.c
new file mode 100755
index 0000000..400fcb2
--- /dev/null
+++ b/mbtk/libgsw_lib/libgsw_usb.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
+#include <dlfcn.h>
+
+
+#include "gsw_usb.h"
+
+#define TMP_USB_RESTART "/sbin/tmp_usb_init"
+#define USB_OPEN 3300
+#define USB_CLOSE 3329
+
+int32_t gsw_usb_permanent_switch(EN_GSW_USB_SWITCH_TYPE type)
+{
+ int ret;
+ char cmd[256];
+ if(type != EN_GSW_USB_SWITCH_OPEN && type != EN_GSW_USB_SWITCH_CLOSE)
+ return GSW_HAL_FAIL;
+ sprintf(cmd, "setprop persist.mbtk.usb_pid %d && %s %d &", type?USB_OPEN:USB_CLOSE, TMP_USB_RESTART, type?USB_OPEN:USB_CLOSE);
+ ret = system(cmd);
+ return ret;
+}
+
+int32_t gsw_usb_tempporary_switch(EN_GSW_USB_SWITCH_TYPE type)
+{
+ int ret;
+ char cmd[256];
+ if(type != EN_GSW_USB_SWITCH_OPEN && type != EN_GSW_USB_SWITCH_CLOSE)
+ return GSW_HAL_FAIL;
+ sprintf(cmd, "%s %d &", TMP_USB_RESTART, type?USB_OPEN:USB_CLOSE);
+ ret = system(cmd);
+ return ret;
+}
\ No newline at end of file