diff --git a/mbtk/libgsw_lib/gsw_voice_interface.c b/mbtk/libgsw_lib/gsw_voice_interface.c
new file mode 100755
index 0000000..1063c79
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_voice_interface.c
@@ -0,0 +1,1012 @@
+#include "gsw_voice_interface.h"
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.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 GSW_VOICE "[HAL][GSW_VOICE]"
+
+#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: "GSW_VOICE"" 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: "GSW_VOICE"" 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: "GSW_VOICE"" 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: "GSW_VOICE"" 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: "GSW_VOICE"" 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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_FAIL;
+    }
+
+    mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+    if (mbtk_log_init == NULL) 
+    {
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+    if (mbtk_log == NULL) 
+    {
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+    if (mbtk_info_handle_get == NULL) 
+    {
+        LOGE("mbtk_info_handle_get dlsym fail\n");
+        return GSW_HAL_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_ARG_INVALID;
+    }
+
+    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_NORMAL_FAIL;
+    }
+
+    mbtk_log_init("syslog", "MBTK_RIL");
+
+    
+    if(ret < 0)
+    {
+        LOGE("mbtk_call_api_import fail,ret = %d\n",ret);
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    ret=mbtk_rtp_init();
+
+    if(ret!=0)
+    {
+        LOGE("[gsw_voice_sdk_init]mbtk_rtp_init fail\n");        
+        return GSW_HAL_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_FAIL;
+    }
+
+    return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief start a voice call
+* @param  [in] char *callNumber
+* @param  [out] CallHandle *handle
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_normal_voice_start(CallHandle *handle, const char *callNumber)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    mbtk_call_info_t reg = {0};
+    int ret = -1;
+
+
+    if(handle == NULL)
+    {
+        LOGE("handle is null\n");
+        return GSW_HAL_ARG_INVALID;
+    }
+
+    if(callNumber == NULL)
+    {
+        LOGE("callNumber is null\n");
+        return GSW_HAL_ARG_INVALID;
+    }
+
+
+    ret = mbtk_call_start(call_info_handle, (char *)callNumber);
+
+    if(ret != 0)
+    {
+        LOGE("mbtk_call_start fail,ret = %d\n",ret);
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    //get call id
+    mbtk_call_reg_get(call_info_handle, &reg);
+    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_NORMAL_FAIL
+*/
+int32_t gsw_voice_answer(CallHandle handle)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_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_NORMAL_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_NORMAL_FAIL
+*/
+int32_t gsw_voice_hangup(CallHandle handle)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_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_NORMAL_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_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_auto_answer_mode(int32_t mode)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_audio_mode(AudioMode audioMode)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    int ret=mbtk_rtp_enable(audioMode);
+    if(ret !=0 )
+    {
+        return GSW_HAL_NORMAL_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_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_remote_rtp_ip(const char *ip, int32_t len)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_FAIL;
+    }
+
+    int ret=mbtk_rtp_remote_ip_set(ip);
+    if(ret !=0 )
+    {
+        return GSW_HAL_NORMAL_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_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_rtp_port(RTPMode rtpMode, int32_t port)
+{
+    if(gsw_voice_init_flag == 0)
+    {
+        return GSW_HAL_NORMAL_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_NORMAL_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_NORMAL_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_NORMAL_FAIL;
+    }
+
+    int ret=mbtk_rtp_channel_set(channel);
+    if(ret==0)
+    {
+       ret=mbtk_rtp_sample_rate_set(clockRate);    
+    }
+    if(ret !=0 )
+    {
+        return GSW_HAL_NORMAL_FAIL;
+    }
+    return GSW_HAL_SUCCESS;  
+}
+/*##########################################rtp end*/
+