diff --git a/mbtk/include/mbtk/mbtk_device.h b/mbtk/include/mbtk/mbtk_device.h
index f7e7cef..b2f1729 100755
--- a/mbtk/include/mbtk/mbtk_device.h
+++ b/mbtk/include/mbtk/mbtk_device.h
@@ -6,17 +6,15 @@
 * Author : lb
 * Date   : 2023/12/30 11:36:35
 */
-#ifndef _MBTK_DEVICE_V2_H
-#define _MBTK_DEVICE_V2_H
+#ifndef _MBTK_DEVICE_H
+#define _MBTK_DEVICE_H
 //#include "mbtk_type.h"
 
 #define MBTK_DEVICE_INFO_PARTITION_NAME "device_info"
 #define MBTK_DEVICE_INFO_PARTITION_TAG 0x87878787
-#define MBTK_DEVICE_INFO_CURR_VERSION 2
 
-#define MBTK_DEV_INFO_PARTITION_ADDR 0x02A20000
+#define MBTK_DEV_INFO_PARTITION_ADDR 0x005C0000
 
-// 78,147,482,134742231
 #define MBTK_BAND_ALL_GSM_DEFAULT 78             // GSM : ASR default.
 #define MBTK_BAND_ALL_WCDMA_DEFAULT 147          // WCDMA : ASR default.
 #define MBTK_BAND_ALL_TDLTE_DEFAULT 482          // TDD-LTE : ASR default.
@@ -27,45 +25,11 @@
 #define MBTK_BAND_ALL_NR_1_DEFAULT 256           // n41
 #define MBTK_BAND_ALL_NR_0_DEFAULT 134217877     // n1/n3/n5/n8/n28
 
-#define MBTK_BAND_CN_GSM_DEFAULT 11             // GSM : B3/B8 (PGSM 900/DCS GSM 1800/EGSM 900)
-#define MBTK_BAND_CN_WCDMA_DEFAULT 145          // WCDMA : B1/B5/B8
-#define MBTK_BAND_CN_TDLTE_DEFAULT 482          // TDD-LTE : B34/B38/B39/B40/B41
-#define MBTK_BAND_CN_FDDLTE_DEFAULT 149         // FDD-LTE : B1/B3/B5/B8
-#define MBTK_BAND_CN_EXT_LTE_DEFAULT 0          // EXT-LTE
-#define MBTK_BAND_CN_NR_3_DEFAULT 0
-#define MBTK_BAND_CN_NR_2_DEFAULT 24576         // n78/n79
-#define MBTK_BAND_CN_NR_1_DEFAULT 384           // n40/n41
-#define MBTK_BAND_CN_NR_0_DEFAULT 134217877     // n1/n3/n5/n8/n28
-
-#define MBTK_BAND_EU_GSM_DEFAULT 11             // GSM : B3/B8 (PGSM 900/DCS GSM 1800/EGSM 900)
-#define MBTK_BAND_EU_WCDMA_DEFAULT 145          // WCDMA : B1/B5/B8
-#define MBTK_BAND_EU_TDLTE_DEFAULT 416          // TDD-LTE : B38/B40/B41
-#define MBTK_BAND_EU_FDDLTE_DEFAULT 134742229   // FDD-LTE : B1/B3/B5/B7/B8/B20/B28
-#define MBTK_BAND_EU_EXT_LTE_DEFAULT 0          // EXT-LTE
-#define MBTK_BAND_EU_NR_3_DEFAULT 0
-#define MBTK_BAND_EU_NR_2_DEFAULT 12352         // n71/n77/n78
-#define MBTK_BAND_EU_NR_1_DEFAULT 416           // n38/n40/n41
-#define MBTK_BAND_EU_NR_0_DEFAULT 134742229     // n1/n3/n5/n7/n8/n20/n28
-
-#define MBTK_BAND_SA_GSM_DEFAULT 79             // GSM : B2/B3/B5/B8(GSM 850/PGSM 900/EGSM 900/DCS GSM 1800/PCS GSM 1900)
-#define MBTK_BAND_SA_WCDMA_DEFAULT 155          // WCDMA : B1/B2/B4/B5/B8
-#define MBTK_BAND_SA_TDLTE_DEFAULT 128          // TDD-LTE : B40
-#define MBTK_BAND_SA_FDDLTE_DEFAULT 134217951  // FDD-LTE : B1/B2/B3/B4/B5/B7/B8/B28
-#define MBTK_BAND_SA_EXT_LTE_DEFAULT 2          // EXT-LTE : B66
-#define MBTK_BAND_SA_NR_3_DEFAULT MBTK_BAND_ALL_NR_3_DEFAULT
-#define MBTK_BAND_SA_NR_2_DEFAULT MBTK_BAND_ALL_NR_2_DEFAULT
-#define MBTK_BAND_SA_NR_1_DEFAULT MBTK_BAND_ALL_NR_1_DEFAULT
-#define MBTK_BAND_SA_NR_0_DEFAULT MBTK_BAND_ALL_NR_0_DEFAULT
-
 #define MBTK_DEVICE_INFO_ITEM_STR_BASIC "BASIC"
 #define MBTK_DEVICE_INFO_ITEM_STR_FOTA "FOTA"
 #define MBTK_DEVICE_INFO_ITEM_STR_MODEM "MODEM"
 #define MBTK_DEVICE_INFO_ITEM_STR_LOG "LOG"
 
-#define MBTK_DEVICE_INFO_ITEM_ADDR_BASIC    0x100   // Header is 0x100
-#define MBTK_DEVICE_INFO_ITEM_ADDR_FOTA     0x500   // Basic is 1k
-#define MBTK_DEVICE_INFO_ITEM_ADDR_MODEM    0x900   // Fota is 1k
-#define MBTK_DEVICE_INFO_ITEM_ADDR_LOG      0xD00   // Modem is 1k
 
 #define MBTK_NET_SUPPORT_2G (1)
 #define MBTK_NET_SUPPORT_3G (1<<1)
@@ -94,6 +58,11 @@
 } mbtk_device_info_header_t;
 
 typedef enum {
+    DEV_INFO_VERSION_V1 = 1,
+    DEV_INFO_VERSION_V2,
+} mbtk_device_info_version_enum;
+
+typedef enum {
     MBTK_REBOOT_FLAG_NORMAL = 0,
     MBTK_REBOOT_FLAG_DOWNLOAD,
     MBTK_REBOOT_FLAG_POWER_OFF,  //Power off and restart
@@ -113,13 +82,41 @@
     uint8 revision_out[48];     // L508_X6v01.01b04.00
     uint8 revision_in[64];
     uint8 build_time[64];
-    uint8 asr_baseline[64];
+} mbtk_device_info_basic_v1_t;
+
+typedef struct {
+    uint8 name[16];
+    uint32 version;             // Default : 0x01
+    uint8 project[16];          // T108 / L508_X6
+    uint8 project_cust[16];     // T108_C1 / L508_X6_C1  (Refer to: Custom_Model in blf file.)
+    uint32 ab_support;          // 1 for ab
+    mbtk_device_info_reboot_flag_enum reboot_flag;
+    uint8 revision_out[48];     // L508_X6v01.01b04.00
+    uint8 revision_in[64];
+    uint8 build_time[64];
+    uint8 asr_baseline[128];
+} mbtk_device_info_basic_v2_t;
+
+typedef struct {
+    mbtk_device_info_version_enum version;
+    union {
+        mbtk_device_info_basic_v1_t v1;
+        mbtk_device_info_basic_v2_t v2;
+    } basic;
 } mbtk_device_info_basic_t;
 
 typedef struct {
     uint8 name[16];
     uint32 version;             // Default : 0x01
     uint32 state;               //
+} mbtk_device_info_fota_v1_t, mbtk_device_info_fota_v2_t;
+
+typedef struct {
+    mbtk_device_info_version_enum version;
+    union {
+        mbtk_device_info_fota_v1_t v1;
+        mbtk_device_info_fota_v2_t v2;
+    } fota;
 } mbtk_device_info_fota_t;
 
 typedef enum {
@@ -133,6 +130,17 @@
     uint8 name[16];
     uint32 version;             // Default : 0x01
     mbtk_modem_band_area_enum band_area;
+    uint32 band_gsm;
+    uint32 band_wcdma;
+    uint32 band_tdlte;
+    uint32 band_fddlte;
+    uint32 band_lte_ext;
+} mbtk_device_info_modem_v1_t;
+
+typedef struct {
+    uint8 name[16];
+    uint32 version;             // Default : 0x01
+    mbtk_modem_band_area_enum band_area;
     uint32 net_pref;    // Refor to : mbtk_net_pref_enum
     uint32 net_support; // 1:GSM      2:WCDMA   4:LTE   8:NR
     uint32 band_gsm;
@@ -144,25 +152,33 @@
     uint32 band_nr_2;
     uint32 band_nr_1;
     uint32 band_nr_0;
+} mbtk_device_info_modem_v2_t;
+
+typedef struct {
+    mbtk_device_info_version_enum version;
+    union {
+        mbtk_device_info_modem_v1_t v1;
+        mbtk_device_info_modem_v2_t v2;
+    } modem;
 } mbtk_device_info_modem_t;
 
 typedef struct {
     uint8 name[16];
     uint32 version;             // Default : 0x01
     uint32 state;               //
+} mbtk_device_info_log_v1_t, mbtk_device_info_log_v2_t;
+
+typedef struct {
+    mbtk_device_info_version_enum version;
+    union {
+        mbtk_device_info_log_v1_t v1;
+        mbtk_device_info_log_v2_t v2;
+    } log;
 } mbtk_device_info_log_t;
 
-
-/*
-* MBTK_DEVICE_INFO_ITEM_BASIC - mbtk_device_info_basic_t
-* MBTK_DEVICE_INFO_ITEM_FOTA - mbtk_device_info_fota_t
-* MBTK_DEVICE_INFO_ITEM_MODEM - mbtk_device_info_modem_t
-* MBTK_DEVICE_INFO_ITEM_LOG - mbtk_device_info_log_t
-*/
 int mbtk_dev_info_read(mbtk_device_info_item_enum item_type, void *item_ptr, int item_size);
 int mbtk_dev_info_write(mbtk_device_info_item_enum item_type, void *item_ptr, int item_size);
 int mbtk_dev_info_revision_get(char *revision_out, char *revision_in, char *project_cust, char *band_area,
             char* build_time);
 
-#endif /* _MBTK_DEVICE_V2_H */
-
+#endif /* _MBTK_DEVICE_H */
diff --git a/mbtk/include/mbtk/mbtk_info_api.h b/mbtk/include/mbtk/mbtk_info_api.h
old mode 100644
new mode 100755
index f713273..362b592
--- a/mbtk/include/mbtk/mbtk_info_api.h
+++ b/mbtk/include/mbtk/mbtk_info_api.h
@@ -818,6 +818,14 @@
     MBTK_ECALL_URC_ID_MSD_SEND_FAIL_FOR_NG  // NG-eCall fail to transfer MSD
 } mbtk_ecall_urc_id_enum;
 
+typedef struct{
+    uint8            cid; //cid number
+    bool             connect_state; //true: connect, false: disconnect;
+    bool             auto_urc; //urc generated by manual/auto dialing
+    uint8            pdp_result; //The cause of the dialing result 
+    mbtk_ipv4_info_t ipv4; //ipv4 info
+    mbtk_ipv6_info_t ipv6; //ipv6 info
+}mbtk_pdp_cb_info_s;
 
 int ipv6_2_str(const void *ipv6, void *ipv6_str);
 
diff --git a/mbtk/include/mbtk/mbtk_rtp.h b/mbtk/include/mbtk/mbtk_rtp.h
index 8786c36..a449c72 100755
--- a/mbtk/include/mbtk/mbtk_rtp.h
+++ b/mbtk/include/mbtk/mbtk_rtp.h
@@ -20,6 +20,8 @@
 
 int mbtk_rtp_remote_ip_set(const char *ipv4);
 
+int mbtk_rtp_vlan_set(const char *vlan);
+
 int mbtk_rtp_server_port_set(int port);
 
 int mbtk_rtp_client_port_set(int port);
diff --git a/mbtk/libmbtk_lib/Makefile b/mbtk/libmbtk_lib/Makefile
index 52d5886..3129978 100755
--- a/mbtk/libmbtk_lib/Makefile
+++ b/mbtk/libmbtk_lib/Makefile
@@ -78,7 +78,8 @@
 	common/mbtk_version.c \
 	common/mbtk_gpio.c \
 	common/mbtk_adc.c \
-	common/mbtk_loopbuff.c
+	common/mbtk_loopbuff.c \
+	common/mbtk_oem_rw.c 
 
 ifeq ($(MBTK_SOURCE_VERSION), 2)
 LOCAL_SRC_FILES += common/mbtk_led_control.c
diff --git a/mbtk/libmbtk_lib/common/mbtk_device_info.c b/mbtk/libmbtk_lib/common/mbtk_device_info.c
index 670a320..3924297 100755
--- a/mbtk/libmbtk_lib/common/mbtk_device_info.c
+++ b/mbtk/libmbtk_lib/common/mbtk_device_info.c
@@ -42,46 +42,6 @@
     mbtk_device_info_header_t info_header;
     memset(&info_header, 0, sizeof(mbtk_device_info_header_t));
 
-    switch(item_type) {
-        case MBTK_DEVICE_INFO_ITEM_BASIC:
-        {
-            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_basic_t)) {
-                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
-                return -1;
-            }
-            break;
-        }
-        case MBTK_DEVICE_INFO_ITEM_FOTA:
-        {
-            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_fota_t)) {
-                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
-                return -1;
-            }
-            break;
-        }
-        case MBTK_DEVICE_INFO_ITEM_MODEM:
-        {
-            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_modem_t)) {
-                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
-                return -1;
-            }
-            break;
-        }
-        case MBTK_DEVICE_INFO_ITEM_LOG:
-        {
-            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_log_t)) {
-                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
-                return -1;
-            }
-            break;
-        }
-        default:
-        {
-            LOGE("Item type[%d] error.", item_type);
-            return -1;
-        }
-    }
-
     mbtk_partition_info_t *partition_info = mbtk_partition_get();
     if(partition_info == NULL) {
         LOGE("mbtk_partition_get() fail.");
@@ -121,12 +81,7 @@
         goto fail;
     }
 
-    if(info_header.version != MBTK_DEVICE_INFO_CURR_VERSION) {
-        LOGE("Version error : %d", info_header.version);
-        goto fail;
-    }
-
-    LOGD("Item count:%d", info_header.item_count);
+    LOGD("Dev info version : %d, Item count:%d", info_header.version, info_header.item_count);
 
     if(info_header.item_header[item_type].addr == 0) {
         LOGE("No found item : %d", item_type);
@@ -134,9 +89,110 @@
     }
 
     lseek(fd, info_header.item_header[item_type].addr, SEEK_SET);
-    if (read(fd, item_ptr, item_size) != item_size) {
-        LOGE("Read fail:%d", errno);
-        goto fail;
+
+
+    switch(item_type) {
+        case MBTK_DEVICE_INFO_ITEM_BASIC:
+        {
+            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_basic_t)) {
+                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
+                goto fail;
+            }
+
+            mbtk_device_info_basic_t *basic_ptr = (mbtk_device_info_basic_t*)item_ptr;
+            basic_ptr->version = (mbtk_device_info_version_enum)info_header.version;
+            if(basic_ptr->version == DEV_INFO_VERSION_V1) {
+                if (read(fd, &(basic_ptr->basic.v1), sizeof(mbtk_device_info_basic_v1_t)) !=
+                        sizeof(mbtk_device_info_basic_v1_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            } else {
+                if (read(fd, &(basic_ptr->basic.v2), sizeof(mbtk_device_info_basic_v2_t)) !=
+                        sizeof(mbtk_device_info_basic_v2_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            }
+            break;
+        }
+        case MBTK_DEVICE_INFO_ITEM_FOTA:
+        {
+            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_fota_t)) {
+                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
+                goto fail;
+            }
+
+            mbtk_device_info_fota_t *fota_ptr = (mbtk_device_info_fota_t*)item_ptr;
+            fota_ptr->version = (mbtk_device_info_version_enum)info_header.version;
+            if(fota_ptr->version == DEV_INFO_VERSION_V1) {
+                if (read(fd, &(fota_ptr->fota.v1), sizeof(mbtk_device_info_fota_v1_t)) !=
+                        sizeof(mbtk_device_info_fota_v1_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            } else {
+                if (read(fd, &(fota_ptr->fota.v2), sizeof(mbtk_device_info_fota_v2_t)) !=
+                        sizeof(mbtk_device_info_fota_v2_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            }
+            break;
+        }
+        case MBTK_DEVICE_INFO_ITEM_MODEM:
+        {
+            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_modem_t)) {
+                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
+                goto fail;
+            }
+
+            mbtk_device_info_modem_t *modem_ptr = (mbtk_device_info_modem_t*)item_ptr;
+            modem_ptr->version = (mbtk_device_info_version_enum)info_header.version;
+            if(modem_ptr->version == DEV_INFO_VERSION_V1) {
+                if (read(fd, &(modem_ptr->modem.v1), sizeof(mbtk_device_info_modem_v1_t)) !=
+                        sizeof(mbtk_device_info_modem_v1_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            } else {
+                if (read(fd, &(modem_ptr->modem.v2), sizeof(mbtk_device_info_modem_v2_t)) !=
+                        sizeof(mbtk_device_info_modem_v2_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            }
+            break;
+        }
+        case MBTK_DEVICE_INFO_ITEM_LOG:
+        {
+            if(item_ptr == NULL || item_size != sizeof(mbtk_device_info_log_t)) {
+                LOGE("ARG error:item-%d, item_size-%d", item_type, item_size);
+                goto fail;
+            }
+
+            mbtk_device_info_log_t *log_ptr = (mbtk_device_info_log_t*)item_ptr;
+            log_ptr->version = (mbtk_device_info_version_enum)info_header.version;
+            if(log_ptr->version == DEV_INFO_VERSION_V1) {
+                if (read(fd, &(log_ptr->log.v1), sizeof(mbtk_device_info_log_v1_t)) !=
+                        sizeof(mbtk_device_info_log_v1_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            } else {
+                if (read(fd, &(log_ptr->log.v2), sizeof(mbtk_device_info_log_v2_t)) !=
+                        sizeof(mbtk_device_info_log_v2_t)) {
+                    LOGE("Read fail:%d", errno);
+                    goto fail;
+                }
+            }
+            break;
+        }
+        default:
+        {
+            LOGE("Item type[%d] error.", item_type);
+            goto fail;
+        }
     }
 
     close(fd);
@@ -154,49 +210,9 @@
         return -1;
     }
 
-    switch(item_type) {
-        case MBTK_DEVICE_INFO_ITEM_BASIC:
-        {
-            if(item_size != sizeof(mbtk_device_info_basic_t)) {
-                LOGE("item_size != sizeof(mbtk_device_info_basic_t)\n\r");
-                return -1;
-            }
-            break;
-        }
-        case MBTK_DEVICE_INFO_ITEM_FOTA:
-        {
-            if(item_size != sizeof(mbtk_device_info_fota_t)) {
-                LOGE("item_size != sizeof(mbtk_device_info_fota_t)\n\r");
-                return -1;
-            }
-            break;
-        }
-        case MBTK_DEVICE_INFO_ITEM_MODEM:
-        {
-            if(item_size != sizeof(mbtk_device_info_modem_t)) {
-                LOGE("item_size != sizeof(mbtk_device_info_modem_t)\n\r");
-                return -1;
-            }
-            break;
-        }
-        case MBTK_DEVICE_INFO_ITEM_LOG:
-        {
-            if(item_size != sizeof(mbtk_device_info_log_t)) {
-                LOGE("item_size != sizeof(mbtk_device_info_log_t)\n\r");
-                return -1;
-            }
-            break;
-        }
-        default:
-        {
-            LOGE("Item type[%d] error.\n\r", item_type);
-            return -1;
-        }
-    }
-
     mbtk_partition_info_t info;
     memset(&info, 0x0, sizeof(mbtk_partition_info_t));
-    if(mbtk_partition_get_by_name("device_info", &info)) {
+    if(mbtk_partition_get_by_name(MBTK_DEVICE_INFO_PARTITION_NAME, &info)) {
         LOGE("mbtk_partition_get_by_name() fail.");
         return -1;
     }
@@ -218,7 +234,7 @@
     char *mtd_buff = (char*)malloc(info.erase_size);
     if(mtd_buff == NULL) {
         LOGE("malloc() failed\n");
-		return -1;
+        return -1;
     }
     memset(mtd_buff, 0xFF, info.erase_size);
     int len = read(fd, mtd_buff, info.erase_size);
@@ -240,7 +256,101 @@
 	ioctl(fd, MEMERASE, &mtdEraseInfo);
 
     mbtk_device_info_header_t *info_header = (mbtk_device_info_header_t*)mtd_buff;
-    memcpy(mtd_buff + info_header->item_header[item_type].addr, item_ptr, item_size);
+    switch(item_type) {
+        case MBTK_DEVICE_INFO_ITEM_BASIC:
+        {
+            if(item_size != sizeof(mbtk_device_info_basic_t)) {
+                LOGE("item_size != sizeof(mbtk_device_info_basic_t)\n\r");
+                goto fail;
+            }
+
+            mbtk_device_info_basic_t *basic_ptr = (mbtk_device_info_basic_t*)item_ptr;
+            if(info_header->version != basic_ptr->version) {
+                LOGE("basic version error.");
+                goto fail;
+            }
+
+            if(basic_ptr->version == DEV_INFO_VERSION_V1) {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(basic_ptr->basic.v1),
+                    sizeof(mbtk_device_info_basic_v1_t));
+            } else {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(basic_ptr->basic.v2),
+                    sizeof(mbtk_device_info_basic_v2_t));
+            }
+            break;
+        }
+        case MBTK_DEVICE_INFO_ITEM_FOTA:
+        {
+            if(item_size != sizeof(mbtk_device_info_fota_t)) {
+                LOGE("item_size != sizeof(mbtk_device_info_fota_t)\n\r");
+                goto fail;
+            }
+
+            mbtk_device_info_fota_t *fota_ptr = (mbtk_device_info_fota_t*)item_ptr;
+            if(info_header->version != fota_ptr->version) {
+                LOGE("fota version error.");
+                goto fail;
+            }
+
+            if(fota_ptr->version == DEV_INFO_VERSION_V1) {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(fota_ptr->fota.v1),
+                    sizeof(mbtk_device_info_fota_v1_t));
+            } else {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(fota_ptr->fota.v2),
+                    sizeof(mbtk_device_info_fota_v2_t));
+            }
+            break;
+        }
+        case MBTK_DEVICE_INFO_ITEM_MODEM:
+        {
+            if(item_size != sizeof(mbtk_device_info_modem_t)) {
+                LOGE("item_size != sizeof(mbtk_device_info_modem_t)\n\r");
+                goto fail;
+            }
+
+            mbtk_device_info_modem_t *modem_ptr = (mbtk_device_info_modem_t*)item_ptr;
+            if(info_header->version != modem_ptr->version) {
+                LOGE("modem version error.");
+                goto fail;
+            }
+
+            if(modem_ptr->version == DEV_INFO_VERSION_V1) {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(modem_ptr->modem.v1),
+                    sizeof(mbtk_device_info_modem_v1_t));
+            } else {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(modem_ptr->modem.v2),
+                    sizeof(mbtk_device_info_modem_v2_t));
+            }
+            break;
+        }
+        case MBTK_DEVICE_INFO_ITEM_LOG:
+        {
+            if(item_size != sizeof(mbtk_device_info_log_t)) {
+                LOGE("item_size != sizeof(mbtk_device_info_log_t)\n\r");
+                goto fail;
+            }
+
+            mbtk_device_info_log_t *log_ptr = (mbtk_device_info_log_t*)item_ptr;
+            if(info_header->version != log_ptr->version) {
+                LOGE("log version error.");
+                goto fail;
+            }
+
+            if(log_ptr->version == DEV_INFO_VERSION_V1) {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(log_ptr->log.v1),
+                    sizeof(mbtk_device_info_log_v1_t));
+            } else {
+                memcpy(mtd_buff + info_header->item_header[item_type].addr, &(log_ptr->log.v2),
+                    sizeof(mbtk_device_info_log_v2_t));
+            }
+            break;
+        }
+        default:
+        {
+            LOGE("Item type[%d] error.\n\r", item_type);
+            goto fail;
+        }
+    }
 
     lseek(fd, 0, SEEK_SET);
     if (write(fd, mtd_buff, info.erase_size) != info.erase_size) {
@@ -279,20 +389,40 @@
         return -1;
     }
 
-    if(strlen((char*)info_basic.revision_out) > 0) {
-        memcpy(revision_out, info_basic.revision_out, strlen((char*)info_basic.revision_out));
-    }
-    if(strlen((char*)info_basic.revision_in) > 0) {
-        memcpy(revision_in, info_basic.revision_in, strlen((char*)info_basic.revision_in));
-    }
-    if(strlen((char*)info_basic.project_cust) > 0) {
-        memcpy(project_cust, info_basic.project_cust, strlen((char*)info_basic.project_cust));
-    }
-    if(strlen((char*)info_basic.build_time) > 0) {
-        memcpy(build_time, info_basic.build_time, strlen((char*)info_basic.build_time));
+    mbtk_modem_band_area_enum modem_band_area = MBTK_MODEM_BAND_AREA_ALL;
+    if(info_basic.version == DEV_INFO_VERSION_V1) {
+        if(strlen((char*)info_basic.basic.v1.revision_out) > 0) {
+            memcpy(revision_out, info_basic.basic.v1.revision_out, strlen((char*)info_basic.basic.v1.revision_out));
+        }
+        if(strlen((char*)info_basic.basic.v1.revision_in) > 0) {
+            memcpy(revision_in, info_basic.basic.v1.revision_in, strlen((char*)info_basic.basic.v1.revision_in));
+        }
+        if(strlen((char*)info_basic.basic.v1.project_cust) > 0) {
+            memcpy(project_cust, info_basic.basic.v1.project_cust, strlen((char*)info_basic.basic.v1.project_cust));
+        }
+        if(strlen((char*)info_basic.basic.v1.build_time) > 0) {
+            memcpy(build_time, info_basic.basic.v1.build_time, strlen((char*)info_basic.basic.v1.build_time));
+        }
+
+        modem_band_area = info_modem.modem.v1.band_area;
+    } else {
+        if(strlen((char*)info_basic.basic.v2.revision_out) > 0) {
+            memcpy(revision_out, info_basic.basic.v2.revision_out, strlen((char*)info_basic.basic.v2.revision_out));
+        }
+        if(strlen((char*)info_basic.basic.v2.revision_in) > 0) {
+            memcpy(revision_in, info_basic.basic.v2.revision_in, strlen((char*)info_basic.basic.v2.revision_in));
+        }
+        if(strlen((char*)info_basic.basic.v2.project_cust) > 0) {
+            memcpy(project_cust, info_basic.basic.v2.project_cust, strlen((char*)info_basic.basic.v2.project_cust));
+        }
+        if(strlen((char*)info_basic.basic.v2.build_time) > 0) {
+            memcpy(build_time, info_basic.basic.v2.build_time, strlen((char*)info_basic.basic.v2.build_time));
+        }
+
+        modem_band_area = info_modem.modem.v2.band_area;
     }
 
-    switch(info_modem.band_area) {
+    switch(modem_band_area) {
         case MBTK_MODEM_BAND_AREA_CN:
             memcpy(band_area, "CN", 2);
             break;
diff --git a/mbtk/libmbtk_lib/common/mbtk_oem_rw.c b/mbtk/libmbtk_lib/common/mbtk_oem_rw.c
new file mode 100755
index 0000000..74cd150
--- /dev/null
+++ b/mbtk/libmbtk_lib/common/mbtk_oem_rw.c
@@ -0,0 +1,230 @@
+#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 "mbtk_log.h"
+
+
+
+
+#define FLASH_DEVICE    "/dev/mtd32"
+#define BACKUP_DEVICE   "/dev/mtd33"
+
+
+/**
+ * @brief 从指定的flash页面读取数据
+ * @param block_id 块ID（从1开始）
+ * @param data 存储读取数据的缓冲区
+ * @param len 存储读取数据长度的指针
+ * @return GSW_HAL_SUCCESS 或 GSW_HAL_FAIL
+ */
+int mbtk_oem_read_data_ext(unsigned int block_id, void *data, unsigned int *len) 
+{
+    int fd;
+    struct mtd_info_user mtd_info;
+    off_t offset;
+    ssize_t bytes_read;
+    unsigned int max_block_id;
+    // 输入参数验证
+    if (!data || !len) 
+    {
+        LOGE("invalid ：data or len is NULL\n");
+        return -2;
+    }
+
+    // 打开flash设备
+    fd = open(FLASH_DEVICE, O_RDONLY);
+    if (fd == -1) 
+    {
+        LOGE("open flash device error %s\n", strerror(errno));
+        return -1;
+    }
+
+    // 获取MTD设备信息
+    if (ioctl(fd, MEMGETINFO, &mtd_info) < 0) 
+    {
+        LOGE("Get MTD info erro：%s\n", strerror(errno));
+        close(fd);
+        return -1;
+    }
+
+    // 计算最大块ID
+    max_block_id = mtd_info.size / mtd_info.erasesize;
+
+    // 验证block_id
+    if (block_id < 1 || block_id > max_block_id) 
+    {
+        LOGE("invalid block_id: %u (max: %u)\n", block_id, max_block_id);
+        close(fd);
+        return -2;
+    }
+
+    // 计算偏移量（block_id从1开始）
+    offset = (block_id - 1) * mtd_info.erasesize;
+
+    // 定位到块位置
+    if (lseek(fd, offset, SEEK_SET) == -1) 
+    {
+        LOGE("lseek block error:%s\n", strerror(errno));
+        close(fd);
+        return -1;
+    }
+
+    // 读取块
+    bytes_read = read(fd, data, mtd_info.erasesize);
+    if (bytes_read != mtd_info.erasesize) 
+    {
+        LOGE("Read block fail:%s\n", strerror(errno));
+        close(fd);
+        return -1;
+    }
+
+    *len = bytes_read;
+    close(fd);
+    return 0;
+}
+
+/**
+ * @brief 向指定的flash页面写入数据并进行备份
+ * @param block_id 块ID（从1开始）
+ * @param data 要写入的数据
+ * @param len 要写入的数据长度
+ * @return GSW_HAL_SUCCESS 或 GSW_HAL_FAIL
+ */
+int mbtk_oem_write_data_ext(unsigned int block_id, void *data, unsigned int len) 
+{
+    int fd_main;
+    int fd_backup;
+    struct mtd_info_user mtd_info;
+    off_t offset_main;
+    off_t offset_backup;
+    ssize_t bytes_written;
+    unsigned int max_block_id;
+    struct erase_info_user erase_info; 
+    // 输入参数验证
+    if (!data) 
+    {
+        printf("invalid data is NULL\n");
+        return -2;
+    }
+
+    // 首先打开主设备以获取MTD信息
+    fd_main = open(FLASH_DEVICE, O_RDWR);
+    if (fd_main == -1) 
+    {
+        printf("open flash error %s\n", strerror(errno));
+        return -1;
+    }
+
+    // 获取MTD设备信息
+    if (ioctl(fd_main, MEMGETINFO, &mtd_info) < 0)
+    {
+        printf("get mtd block info error %s\n", strerror(errno));
+        close(fd_main);
+        return -1;
+    }
+
+    // 计算最大块ID
+    max_block_id = mtd_info.size / mtd_info.erasesize;
+
+    // 验证block_id和len
+    if (block_id < 1 || block_id > max_block_id)
+    {
+        LOGE("invalid block_id: %u (max:%u)\n", block_id, max_block_id);
+        close(fd_main);
+        return -2;
+    }
+
+    if (len > mtd_info.erasesize)
+    {
+        LOGE("invalid len: %u (max: %u)\n", len, mtd_info.erasesize);
+        close(fd_main);
+        return -2;
+    }
+
+    // 打开备份设备
+    fd_backup = open(BACKUP_DEVICE, O_RDWR);
+    if (fd_backup == -1) 
+    {
+        LOGE("open bak device fail %s\n", strerror(errno));
+        close(fd_main);
+        return -1;
+    }
+
+    // 计算偏移量
+    offset_main = (block_id - 1) * mtd_info.erasesize;
+    offset_backup = (block_id - 1) * mtd_info.erasesize;
+
+    // 准备erase_info结构体
+    erase_info.start = offset_main; // 设置主设备的起始位置
+    erase_info.length = mtd_info.erasesize; // 设置擦除长度
+
+    // 首先写入备份
+    if (ioctl(fd_backup, MEMERASE, &erase_info) < 0) 
+    {
+        LOGE("MEMERASE backup block faile:%s\n", strerror(errno));
+        close(fd_main);
+        close(fd_backup);
+        return -1;
+    }
+
+    if (lseek(fd_backup, offset_backup, SEEK_SET) == -1) 
+    {
+        LOGE("lseek backup device failed %s\n", strerror(errno));
+        close(fd_main);
+        close(fd_backup);
+        return -1;
+    }
+
+    bytes_written = write(fd_backup, data, len);
+    if (bytes_written != len) 
+    {
+        LOGE("write to backup flahs  failed %s\n", strerror(errno));
+        close(fd_main);
+        close(fd_backup);
+        return -1;
+    }
+    
+    erase_info.start = offset_main; 
+    erase_info.length = mtd_info.erasesize; 
+
+    // 然后写入主flash
+    if (ioctl(fd_main, MEMERASE, &erase_info) < 0) 
+    {
+        LOGE("MEMERASE main flash failed %s\n", strerror(errno));
+        close(fd_main);
+        close(fd_backup);
+        return -1;
+    }
+
+    if (lseek(fd_main, offset_main, SEEK_SET) == -1) 
+    {
+        LOGE("lseek main flash failed %s\n", strerror(errno));
+        close(fd_main);
+        close(fd_backup);
+        return -1;
+    }
+
+    bytes_written = write(fd_main, data, len);
+    if (bytes_written != len) 
+    {
+        LOGE(" write to main flash failed %s\n", strerror(errno));
+        close(fd_main);
+        close(fd_backup);
+        return -1;
+    }
+    
+    // 确保数据已写入flash
+    fsync(fd_main);
+    fsync(fd_backup);
+
+    close(fd_main);
+    close(fd_backup);
+    return 0;
+}
+
diff --git a/mbtk/libmbtk_lib/rtp/mbtk_rtp.c b/mbtk/libmbtk_lib/rtp/mbtk_rtp.c
index 961b9c5..58d1077 100755
--- a/mbtk/libmbtk_lib/rtp/mbtk_rtp.c
+++ b/mbtk/libmbtk_lib/rtp/mbtk_rtp.c
@@ -192,6 +192,36 @@
     }
 }
 
+int mbtk_rtp_vlan_set(const char *vlan)
+{
+    if(rtp_cli_fd < 0) {
+        LOGW("RTP client not inited.");
+        return -1;
+    }
+
+    if(str_empty(vlan)) {
+        LOGE("vlan is empty.");
+        return -1;
+    }
+
+    char cmd[100] = {0};
+    char rsp[100] = {0};
+    snprintf(cmd, sizeof(cmd), "vlan %s", vlan); // vlan <dev>
+    char *result = rtp_cmd_exec(cmd, rsp, sizeof(rsp));
+    if(!result) {
+        return -1;
+    }
+
+    // vlan:<err>
+    if(strcmp(result, "vlan:0") == 0) {
+        return 0;
+    } else {
+        LOGE("CMD exec error:%s", result);
+        return -1;
+    }
+}
+
+
 int mbtk_rtp_server_port_set(int port)
 {
     if(rtp_cli_fd < 0) {
diff --git a/mbtk/mbtk_rild/src/main.c b/mbtk/mbtk_rild/src/main.c
index 22e739c..a527ed1 100755
--- a/mbtk/mbtk_rild/src/main.c
+++ b/mbtk/mbtk_rild/src/main.c
@@ -217,9 +217,9 @@
             cgact_wait.waitting = false;
         }
 
-        uint8 data_pdp;
-        data_pdp = 1;       //
-        urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
+        //uint8 data_pdp;
+        //data_pdp = 1;       //
+        //urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
     }
     // +CGEV:
     // +CGEV: NW DEACT <cid>,<cid>
@@ -240,14 +240,23 @@
     // +CGEV: NW REATTACH
     else if(strStartsWith(s, "+CGEV:"))
     {
-        if(at_process && !at_cfun_command) {
-            if(cgact_wait.act) {
-                if(strStartsWith(s, "+CGEV: ME PDN ACT ")) { // +CGEV: ME PDN ACT 15,4
-                    if(cgact_wait.cid == atoi(s + 18)) {
+        if(at_process && !at_cfun_command)
+        {
+            mbtk_pdp_cb_info_s pdp_cb_info;
+            memset(&pdp_cb_info, 0x00, sizeof(mbtk_pdp_cb_info_s));
+            pdp_cb_info.auto_urc = false;
+            if(cgact_wait.act)
+            {
+                if(strStartsWith(s, "+CGEV: ME PDN ACT ")) // +CGEV: ME PDN ACT 15,4
+                {
+                    if(cgact_wait.cid == atoi(s + 18))
+                    {
                         cgact_wait.waitting = false;
                     }
 
-                    uint8 data_pdp;
+                    pdp_cb_info.cid = atoi(s + 18);
+                    pdp_cb_info.connect_state = true;
+#if 0
                     char* tmp_s = memdup(s + 18,strlen(s + 18));
                     char* free_ptr = tmp_s;
                     char *line = tmp_s;
@@ -264,10 +273,10 @@
                     {
                         goto at_PDP_CREG_EXIT;
                     }
-                    data_pdp = tmp_int;
+                    pdp_cb_info.pdp_result = tmp_int;
 at_PDP_CREG_EXIT:
                     free(free_ptr);
-
+                    free_ptr = NULL;
                     //data_pdp = (uint8)atoi(s + 20);  //reason
                     if(cgact_wait.cid >= 1 && cgact_wait.cid < 8)
                     {
@@ -302,71 +311,69 @@
                             urc_msg_distribute(true, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
                         }
                     }
-                } else if(strStartsWith(s, "+CGEV: NW MODIFY ")) { // +CGEV: NW MODIFY 1,4
-                    if(cgact_wait.cid == atoi(s + 17)) {
-                        cgact_wait.waitting = false;
-                    }
+#endif
+                    urc_msg_distribute(true, INFO_URC_MSG_PDP_STATE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
                 }
-            } else {
-                if(strStartsWith(s, "+CGEV: ME PDN DEACT ")) { // +CGEV: ME PDN DEACT 1
-                    if(cgact_wait.cid == atoi(s + 20)) {
+                else if(strStartsWith(s, "+CGEV: NW MODIFY ")) // +CGEV: NW MODIFY 1,4
+                { 
+                    if(cgact_wait.cid == atoi(s + 17))
+                    {
                         cgact_wait.waitting = false;
                     }
-                    uint8 data_pdp;
-                    data_pdp = 0;       //
-                    urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
-                    if(cgact_wait.cid != 0)
+                    
+                    pdp_cb_info.cid = atoi(s + 17);
+                    pdp_cb_info.connect_state = true;
+                    //urc_msg_distribute(true, INFO_URC_MSG_PDP_STATE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+                }
+            } 
+            else
+            {
+                if(strStartsWith(s, "+CGEV: ME PDN DEACT ")) // +CGEV: ME PDN DEACT 1
+                {
+                    if(cgact_wait.cid == atoi(s + 20))
                     {
-                        data_pdp = cgact_wait.cid + 100;
-                        urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
+                        cgact_wait.waitting = false;
                     }
+                    
+                    pdp_cb_info.cid = atoi(s + 20);
+                    pdp_cb_info.connect_state = false;
+                    urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
                 }
             }
-        } else {
-            // apn_state_set
-
+        } 
+        else
+        {
             // +CGEV: NW PDN DEACT <cid>
-
             // +CGEV: EPS PDN ACT 1
             // +CGEV: ME PDN ACT 8,1
-
             // +CGEV: ME PDN ACT 2,4
-            uint8 data[2] = {0xFF};
-            if(strStartsWith(s, "+CGEV: NW PDN DEACT ")) { // +CGEV: NW PDN DEACT <cid>
-                //apn_state_set(atoi(s + 20), false);
-                data[0] = (uint8)0;
-                data[1] = (uint8)atoi(s + 20);
+            mbtk_pdp_cb_info_s pdp_cb_info;
+            memset(&pdp_cb_info, 0x00, sizeof(mbtk_pdp_cb_info_s));
+            pdp_cb_info.auto_urc = true;
+            if(strStartsWith(s, "+CGEV: NW PDN DEACT ")) // +CGEV: NW PDN DEACT <cid>
+            { 
+                pdp_cb_info.cid = (uint8)atoi(s + 20);
+                pdp_cb_info.connect_state = false;
+                urc_msg_distribute(true, INFO_URC_MSG_CGEV, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+            }
+            else if(strStartsWith(s, "+CGEV: EPS PDN ACT ")) // +CGEV: EPS PDN ACT <cid>
+            { 
+                pdp_cb_info.cid = (uint8)atoi(s + 19);
+                pdp_cb_info.connect_state = true;
+            }
+            else if(strStartsWith(s, "+CGEV: ME PDN DEACT ")) // +CGEV: EPS PDN DEACT <cid>
+            {
+                pdp_cb_info.cid = (uint8)atoi(s + 20);
+                pdp_cb_info.connect_state = false;
+                urc_msg_distribute(true, INFO_URC_MSG_CGEV, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+            }
+            else if(strStartsWith(s, "+CGEV: ME PDN ACT ")) // +CGEV: ME PDN ACT <cid>,1
+            {
+                pdp_cb_info.cid = (uint8)atoi(s + 18);
+                pdp_cb_info.connect_state = true;
+                //urc_msg_distribute(true, INFO_URC_MSG_PDP_STATE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
 
-                uint8 data_pdp;
-                data_pdp = 0;       //
-                urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
-                data_pdp = data[1] + 100;
-                urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
-            } else if(strStartsWith(s, "+CGEV: EPS PDN ACT ")) { // +CGEV: EPS PDN ACT <cid>
-                //apn_state_set(atoi(s + 19), true);
-#if (defined(MBTK_AF_SUPPORT) || defined(MBTK_ALL_CID_SUPPORT))
-				//data[0] = (uint8)1;
-                //data[1] = (uint8)atoi(s + 19);
-#else
-                data[0] = (uint8)1;
-                data[1] = (uint8)atoi(s + 19);
-#endif
-            } else if(strStartsWith(s, "+CGEV: ME PDN DEACT ")) { // +CGEV: EPS PDN DEACT <cid>
-                //apn_state_set(atoi(s + 19), true);
-                data[0] = (uint8)0;
-                data[1] = (uint8)atoi(s + 20);
-
-                uint8 data_pdp;
-                data_pdp = 0;       //
-                urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
-                data_pdp = data[1] + 100;
-                urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
-            } else if(strStartsWith(s, "+CGEV: ME PDN ACT ")) { // +CGEV: ME PDN ACT <cid>,1
-                //apn_state_set(atoi(s + 18), true);
-                data[0] = (uint8)1;
-                data[1] = (uint8)atoi(s + 18);
-
-                uint8 data_pdp;
+#if 0
                 char* tmp_s = memdup(s + 18,strlen(s + 18));
                 char* free_ptr = tmp_s;
                 char *line = tmp_s;
@@ -413,16 +420,19 @@
                     {
 
                     }
-
                     data_pdp = data[1] + 200;
                     urc_msg_distribute(true, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
 					data[1] = 0;
                 }
-            } else {
+#endif
+
+            } 
+            else
+            {
                 LOGI("No process : %s", s);
             }
 
-			urc_msg_distribute(true, INFO_URC_MSG_CGEV, data, sizeof(uint8) * 2);
+			//urc_msg_distribute(true, INFO_URC_MSG_CGEV, data, sizeof(uint8) * 2);
         }
     }
     // +CREG: 1, "8010", "000060a5", 0, 2, 0
@@ -520,12 +530,14 @@
         } else {
             data[2] = (uint8)0xFF; // AcT
         }
+#if 0
         if(data[1] == 5)
         {
             uint8 data_pdp;
             data_pdp = 5;       //
             urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
         }
+#endif
         urc_msg_distribute(false, INFO_URC_MSG_NET_CS_REG_STATE, data, sizeof(data));
         urc_msg_distribute(true, INFO_URC_MSG_NET_STATE_LOG, NULL, 0);
 CREG_EXIT:
@@ -686,12 +698,14 @@
             sim_info_reg.sim = 0;
         else if(strStartsWith(s, "*SIMDETEC:1,SIM"))
             sim_info_reg.sim = 1;
+#if 0
         if(sim_info_reg.sim == 0)
         {
             uint8 data_pdp;
             data_pdp = 11;       //
             urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
         }
+#endif
         urc_msg_distribute(false, INFO_URC_MSG_SIM_STATE, &sim_info_reg, sizeof(mbtk_sim_card_info));
     }
     // *EUICC:1
@@ -814,14 +828,14 @@
         }
         else
             sim_info_reg.sim = 20;
-
+#if 0
         if(sim_info_reg.sim == 18)
         {
             uint8 data_pdp;
             data_pdp = 11;       //
             urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
         }
-
+#endif
         urc_msg_distribute(false, INFO_URC_MSG_SIM_STATE, &sim_info_reg, sizeof(mbtk_sim_card_info));
     }
     // +CMT: ,23
diff --git a/mbtk/mbtk_rild/src/mbtk_info_server.c b/mbtk/mbtk_rild/src/mbtk_info_server.c
index 5c1469a..3ebaf1a 100755
--- a/mbtk/mbtk_rild/src/mbtk_info_server.c
+++ b/mbtk/mbtk_rild/src/mbtk_info_server.c
@@ -5556,13 +5556,13 @@
                                 err = MBTK_INFO_ERR_CID_EXIST;
                                 break;
                             }
-
+#if 0
                             if(mbtk_check_default_pdp_state(cid))
                             {
                                 err = MBTK_INFO_ERR_UNSUPPORTED;
                                 break;
                             }
-
+#endif
                             data_call_reconn:
                             //mbtk wyq for data_call_ex add end
                             cgact_wait.waitting = true;
@@ -5707,12 +5707,26 @@
                                     }
 
                                     cid_active[cid] = 1;
-                                    mbtk_set_default_pdp_state(true, cid);
-                                    mbtk_qser_route_config(cid, &ipv4, &ipv6);
+                                    //mbtk_set_default_pdp_state(true, cid);
+                                    //mbtk_qser_route_config(cid, &ipv4, &ipv6);
                                     if(cli_info->fd != DATA_CALL_BOOTCONN_FD)
                                     {
                                         mbtk_net_led_set(MBTK_NET_LED_DATA_CONNECT);
                                         pack_rsp_send(cli_info->fd, MBTK_INFO_ID_NET_DATA_CALL_RSP, NULL, 0);
+#ifdef MBTK_ALL_CID_SUPPORT
+										if(cid == 1) //cid 1 as a special treatment
+										{
+											mbtk_pdp_cb_info_s pdp_cb_info;
+											memset(&pdp_cb_info, 0x00, sizeof(mbtk_pdp_cb_info_s));
+											pdp_cb_info.cid = cid;
+											pdp_cb_info.auto_urc = false;
+											pdp_cb_info.connect_state = true;
+											memcpy(&(pdp_cb_info.ipv4), &ipv4, sizeof(mbtk_ipv4_info_t));
+											memcpy(&(pdp_cb_info.ipv6), &ipv6, sizeof(mbtk_ipv6_info_t));
+											usleep(1000);
+											pack_rsp_send(cli_info->fd , MBTK_INFO_ID_IND_PDP_STATE_CHANGE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+										}
+#endif
                                     }
                                     else
                                     {
@@ -5738,8 +5752,8 @@
                             if(cid == 1)
                             {
                                 char dev[20] = {0};
-                                uint8 pdp_data = cid + 100;
-                                pack_rsp_send(cli_info->fd , MBTK_INFO_ID_IND_PDP_STATE_CHANGE, &pdp_data, sizeof(uint8));
+                                mbtk_pdp_cb_info_s pdp_cb_info;
+                                memset(&pdp_cb_info, 0x00, sizeof(mbtk_pdp_cb_info_s));
 
                                 sprintf(dev, "ccinet%d", cid - 1);
 
@@ -5749,8 +5763,13 @@
                                 } else {
                                     LOGD("Config %s IPv4 0 success.", dev);
                                 }
+                                pdp_cb_info.cid = cid;
+                                pdp_cb_info.connect_state = false;
+                                pdp_cb_info.auto_urc = false;
+                                pack_rsp_send(cli_info->fd , MBTK_INFO_ID_IND_PDP_STATE_CHANGE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+                                
                                 cid_active[cid] = 0;
-                                mbtk_set_default_pdp_state(false, cid);
+                                //mbtk_set_default_pdp_state(false, cid);
                                 mbtk_net_led_set(MBTK_NET_LED_NET_CONNECT);
                                 pack_rsp_send(cli_info->fd, MBTK_INFO_ID_NET_DATA_CALL_RSP, NULL, 0);
                                 break;
@@ -5793,7 +5812,7 @@
                                 }
 #endif
                                 cid_active[cid] = 0;
-                                mbtk_set_default_pdp_state(false, cid);
+                                //mbtk_set_default_pdp_state(false, cid);
                                 mbtk_net_led_set(MBTK_NET_LED_NET_CONNECT);
                                 pack_rsp_send(cli_info->fd, MBTK_INFO_ID_NET_DATA_CALL_RSP, NULL, 0);
                             }
@@ -6765,7 +6784,7 @@
 }
 */
 
-static void net_ifc_state_change(bool act, int cid, mbtk_pdp_act_info_t *act_info)
+static void net_ifc_state_change(bool act, int cid, mbtk_pdp_cb_info_s *pdp_cb_info)
 {
     if(cid < MBTK_APN_CID_MIN || cid > MBTK_APN_CID_MAX) { // No nothing for cid 1 and 8
         return;
@@ -6815,9 +6834,9 @@
             }
 #endif
 
-            if(act_info) {
-                memcpy(&(act_info->ipv4), &ipv4, sizeof(mbtk_ipv4_info_t));
-                memcpy(&(act_info->ipv6), &ipv6, sizeof(mbtk_ipv6_info_t));
+            if(pdp_cb_info) {
+                memcpy(&(pdp_cb_info->ipv4), &ipv4, sizeof(mbtk_ipv4_info_t));
+                memcpy(&(pdp_cb_info->ipv6), &ipv6, sizeof(mbtk_ipv6_info_t));
             }
 
             // Config IPv4 address.
@@ -6851,7 +6870,7 @@
                 }
             }
 
-            mbtk_qser_route_config(cid, &ipv4, &ipv6);
+            //mbtk_qser_route_config(cid, &ipv4, &ipv6);
         }
     } else { // Del IP
         if(mbtk_ifc_configure2(dev, NULL, 0, NULL, NULL)) {
@@ -6862,6 +6881,7 @@
     }
 }
 
+#if 0
 static void data_call_restart()
 {
 #if 0
@@ -6885,34 +6905,36 @@
 #endif
     // +CGACT
     int cid;
-    uint8 data_pdp = 0;
+    mbtk_pdp_cb_info_s pdp_cb_info;
     LOGD("Start active APN.");
-    at_process = true;
+    //at_process = true;
     cgact_wait.act = true;
-    for(cid = MBTK_APN_CID_MIN; cid <= MBTK_APN_CID_MAX; cid++) {
+    for(cid = MBTK_APN_CID_MIN; cid <= MBTK_APN_CID_MAX; cid++)
+    {
         if(cid_active[cid])
         {
             LOG("Active cid : %d", cid);
+            memset(&pdp_cb_info, 0x00, sizeof(mbtk_pdp_cb_info_s));
             cgact_wait.waitting = true;
             cgact_wait.cid = cid;
+            
             net_ifc_state_change(false, cid, NULL);
-            data_pdp = cid + 100;
-            urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &data_pdp, sizeof(uint8));
+            pdp_cb_info.cid = cid;
+            pdp_cb_info.connect_state = false;
+            pdp_cb_info.auto_urc = true;
+            urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+            
             req_data_call_start(cid, NULL);
             wait_cgact_complete(10);
-
-            mbtk_pdp_act_info_t act_info;
-            memset(&act_info, 0, sizeof(mbtk_pdp_act_info_t));
-            data_pdp = cid + 220;
-            act_info.state = data_pdp;
-
-            net_ifc_state_change(true, cid, &act_info);
-
-            urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &act_info, sizeof(mbtk_pdp_act_info_t));
+          
+            net_ifc_state_change(true, cid, &pdp_cb_info);
+            pdp_cb_info.connect_state = true;
+            urc_msg_distribute(false, INFO_URC_MSG_PDP_STATE, &pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
         }
     }
-    at_process = false;
+    //at_process = false;
 }
+#endif
 
 static void urc_msg_process(info_urc_msg_t *msg)
 {
@@ -6932,32 +6954,29 @@
         }
         case INFO_URC_MSG_CGEV:
         {
-            bool act = data[0];
-            int cid = data[1];
-            if(cid > 0) {
-                net_ifc_state_change(act, cid, NULL);
+            mbtk_pdp_cb_info_s *pdp_cb_info = (mbtk_pdp_cb_info_s *)(msg->data);
+            if(pdp_cb_info->cid >= MBTK_APN_CID_MIN && pdp_cb_info->cid <= MBTK_APN_CID_MAX)
+            {
+                net_ifc_state_change(pdp_cb_info->connect_state, pdp_cb_info->cid, NULL);
+                cid_active[pdp_cb_info->cid] = 0;
+                pdp_state_change(pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
+            }
+            else
+            {
+                LOGD("[%s] pdp_cb_info->cid unknown.[%d]", __func__, pdp_cb_info->cid);
             }
             break;
         }
         case INFO_URC_MSG_PDP_STATE:
         {
-            // pdp_state_change
-            mbtk_pdp_act_info_t act_info;
-            memset(&act_info, 0, sizeof(mbtk_pdp_act_info_t));
+            //data call connect success
             int cme_err = MBTK_INFO_ERR_CME_NON;
-            uint8 cid = *((uint8*)(msg->data));
-            act_info.state = cid;
-#if 0
-            if(cid > 220) {
-                cid -= 220;
-            } else { // > 200
-                cid -= 200;
-            }
-#endif
-            if(!req_data_call_state_get(cid, &(act_info.ipv4), &(act_info.ipv6), &cme_err) && cme_err == MBTK_INFO_ERR_CME_NON)
+            mbtk_pdp_cb_info_s *pdp_cb_info = (mbtk_pdp_cb_info_s *)(msg->data);
+            if(req_data_call_state_get(pdp_cb_info->cid, &(pdp_cb_info->ipv4), &(pdp_cb_info->ipv6), &cme_err) || cme_err != MBTK_INFO_ERR_CME_NON)
             {
-                pdp_state_change(&act_info, sizeof(mbtk_pdp_act_info_t));
+                LOGE("[%s] req_data_call_state_get() fail.[%d]", __func__, cme_err);
             }
+            pdp_state_change(pdp_cb_info, sizeof(mbtk_pdp_cb_info_s));
             break;
         }
         case INFO_URC_MSG_NET_PS_REG_STATE:
@@ -6976,10 +6995,11 @@
                 {
                     net_data[2] = info.net_type;
                     net_state_change(net_data, sizeof(net_data));
-
+#if 0
                     if(info.net_type >= MBTK_RADIO_TECH_UTRAN) {
                         data_call_restart();
                     }
+#endif
                 } else {
                     net_data[2] = (uint8)0xFF;
                     net_state_change(net_data, sizeof(net_data));
@@ -7331,12 +7351,21 @@
         band_set_info.band_fddlte = MBTK_BAND_ALL_FDDLTE_DEFAULT;
         band_set_info.band_lte_ext = MBTK_BAND_ALL_EXT_LTE_DEFAULT;
     } else {
-        band_area = info_modem.band_area;
-        band_set_info.band_gsm = info_modem.band_gsm;
-        band_set_info.band_wcdma = info_modem.band_wcdma;
-        band_set_info.band_tdlte = info_modem.band_tdlte;
-        band_set_info.band_fddlte = info_modem.band_fddlte;
-        band_set_info.band_lte_ext = info_modem.band_lte_ext;
+        if(info_modem.version == DEV_INFO_VERSION_V1) {
+            band_area = info_modem.modem.v1.band_area;
+            band_set_info.band_gsm = info_modem.modem.v1.band_gsm;
+            band_set_info.band_wcdma = info_modem.modem.v1.band_wcdma;
+            band_set_info.band_tdlte = info_modem.modem.v1.band_tdlte;
+            band_set_info.band_fddlte = info_modem.modem.v1.band_fddlte;
+            band_set_info.band_lte_ext = info_modem.modem.v1.band_lte_ext;
+        } else {
+            band_area = info_modem.modem.v2.band_area;
+            band_set_info.band_gsm = info_modem.modem.v2.band_gsm;
+            band_set_info.band_wcdma = info_modem.modem.v2.band_wcdma;
+            band_set_info.band_tdlte = info_modem.modem.v2.band_tdlte;
+            band_set_info.band_fddlte = info_modem.modem.v2.band_fddlte;
+            band_set_info.band_lte_ext = info_modem.modem.v2.band_lte_ext;
+        }
     }
 
     bool is_first = TRUE;
@@ -7383,10 +7412,15 @@
     }
     else
     {
-        reboot_reason = info_basic.reboot_flag;
-        if(info_basic.reboot_flag != MBTK_REBOOT_FLAG_NORMAL)
+        reboot_reason = info_basic.version == DEV_INFO_VERSION_V1 ? info_basic.basic.v1.reboot_flag :
+            info_basic.basic.v2.reboot_flag;
+        if(reboot_reason != MBTK_REBOOT_FLAG_NORMAL)
         {
-            info_basic.reboot_flag = MBTK_REBOOT_FLAG_NORMAL;
+            if(info_basic.version == DEV_INFO_VERSION_V1) {
+                info_basic.basic.v1.reboot_flag = MBTK_REBOOT_FLAG_NORMAL;
+            } else {
+                info_basic.basic.v2.reboot_flag = MBTK_REBOOT_FLAG_NORMAL;
+            }
             ret = mbtk_dev_info_write(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
             if(ret != 0) {
                 LOGE("[%s] mbtk_dev_info_write(BASIC) fail.", __func__);
diff --git a/mbtk/mbtk_rild_v2/src/main.c b/mbtk/mbtk_rild_v2/src/main.c
index ae286cc..c4befdf 100755
--- a/mbtk/mbtk_rild_v2/src/main.c
+++ b/mbtk/mbtk_rild_v2/src/main.c
@@ -2910,27 +2910,37 @@
         band_info.band_support.nr_0_band = 0;
 #endif
     } else {
-        band_info.band_area = info_modem.band_area;
-        band_info.net_support = info_modem.net_support;
-        if(info_modem.net_pref < MBTK_NET_PREF_MAX) {
-            band_info.band_support.net_pref = info_modem.net_pref;
+        if(info_modem.version == DEV_INFO_VERSION_V1) {
+            band_info.band_area = info_modem.modem.v1.band_area;
+            band_info.band_support.net_pref = MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF;  // 15
+            band_info.band_support.gsm_band = info_modem.modem.v1.band_gsm;
+            band_info.band_support.umts_band = info_modem.modem.v1.band_wcdma;
+            band_info.band_support.tdlte_band = info_modem.modem.v1.band_tdlte;
+            band_info.band_support.fddlte_band = info_modem.modem.v1.band_fddlte;
+            band_info.band_support.lte_ext_band = info_modem.modem.v1.band_lte_ext;
         } else {
-            if(band_info.net_support & MBTK_NET_SUPPORT_5G) {
-                band_info.band_support.net_pref = MBTK_NET_PREF_LTE_NR_NR_PREF;  // 19
+            band_info.band_area = info_modem.modem.v2.band_area;
+            band_info.net_support = info_modem.modem.v2.net_support;
+            if(info_modem.modem.v2.net_pref < MBTK_NET_PREF_MAX) {
+                band_info.band_support.net_pref = info_modem.modem.v2.net_pref;
             } else {
-                band_info.band_support.net_pref = MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF;  // 15
+                if(band_info.net_support & MBTK_NET_SUPPORT_5G) {
+                    band_info.band_support.net_pref = MBTK_NET_PREF_LTE_NR_NR_PREF;  // 19
+                } else {
+                    band_info.band_support.net_pref = MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF;  // 15
+                }
             }
-        }
-        band_info.band_support.gsm_band = info_modem.band_gsm;
-        band_info.band_support.umts_band = info_modem.band_wcdma;
-        band_info.band_support.tdlte_band = info_modem.band_tdlte;
-        band_info.band_support.fddlte_band = info_modem.band_fddlte;
-        band_info.band_support.lte_ext_band = info_modem.band_lte_ext;
+            band_info.band_support.gsm_band = info_modem.modem.v2.band_gsm;
+            band_info.band_support.umts_band = info_modem.modem.v2.band_wcdma;
+            band_info.band_support.tdlte_band = info_modem.modem.v2.band_tdlte;
+            band_info.band_support.fddlte_band = info_modem.modem.v2.band_fddlte;
+            band_info.band_support.lte_ext_band = info_modem.modem.v2.band_lte_ext;
 
-        band_info.band_support.nr_3_band = info_modem.band_nr_3;
-        band_info.band_support.nr_2_band = info_modem.band_nr_2;
-        band_info.band_support.nr_1_band = info_modem.band_nr_1;
-        band_info.band_support.nr_0_band = info_modem.band_nr_0;
+            band_info.band_support.nr_3_band = info_modem.modem.v2.band_nr_3;
+            band_info.band_support.nr_2_band = info_modem.modem.v2.band_nr_2;
+            band_info.band_support.nr_1_band = info_modem.modem.v2.band_nr_1;
+            band_info.band_support.nr_0_band = info_modem.modem.v2.band_nr_0;
+        }
     }
 }
 
diff --git a/mbtk/mbtk_rtpd/src/main.c b/mbtk/mbtk_rtpd/src/main.c
index d09098c..ec2baad 100755
--- a/mbtk/mbtk_rtpd/src/main.c
+++ b/mbtk/mbtk_rtpd/src/main.c
@@ -169,6 +169,13 @@
         char rsp[100] = {0};
         sprintf(rsp, "%cchannel:%d%c", MBTK_IND_START_FLAG, ret, MBTK_IND_END_FLAG);
         mbtk_write(fd, rsp, strlen(rsp));
+    } else if(memcmp(msg, "vlan", 4) == 0) {// vlan <dev>
+        int ret = 0;
+        memcpy(rtp_confs.vlan, msg + 5, strlen(msg + 5) + 1);
+
+        char rsp[100] = {0};
+        sprintf(rsp, "%cvlan:%d%c", MBTK_IND_START_FLAG, ret, MBTK_IND_END_FLAG);
+        mbtk_write(fd, rsp, strlen(rsp));
     } else {
         LOGW("Unknown RTP msg : %s", msg);
     }
diff --git a/mbtk/mbtk_rtpd/src/rtp_server.c b/mbtk/mbtk_rtpd/src/rtp_server.c
index 4ae8a74..155ade2 100755
--- a/mbtk/mbtk_rtpd/src/rtp_server.c
+++ b/mbtk/mbtk_rtpd/src/rtp_server.c
@@ -41,6 +41,7 @@
 #include "mbtk_utils.h"
 #include "mbtk_audio2.h"
 #include "mbtk_rtp_internal.h"
+#include "mbtk_ifc.h"
 
 #define RTP_DEBUG_PCM_FILE 1
 #define RTP_UDP_READ_BUFF_SIZE 2048
@@ -375,6 +376,26 @@
     return ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
 }
 
+int ip_get_from_dev(const char *dev_name, void *addr)
+{
+    int ret = 0;
+    if(mbtk_ifc_open()) {
+        LOGE("mbtk_ifc_open() fail.");
+        ret = -1;
+        goto return_result;
+    }
+
+    if(mbtk_ifc_get_addr(dev_name, addr)) {
+        LOGE("mbtk_ifc_get_addr() fail.");
+        ret = -1;
+        goto return_result;
+    }
+
+return_result:
+    mbtk_ifc_close();
+    return ret;
+}
+
 static void voip_playback_thread(void *arg)
 {
     UNUSED(arg);
@@ -522,18 +543,36 @@
     return -1;
 }
 
-static int rtp_udp_cli_open(const char *remote_addr, int remote_port)
+static int rtp_udp_cli_open(const char *vlan, const char *remote_addr, int remote_port)
 {
-    struct sockaddr_in dst_sa4, src_sa4;
-    if (inet_pton(AF_INET, "0.0.0.0", &src_sa4.sin_addr) > 0) {
-        src_sa4.sin_family = AF_INET;
-        src_sa4.sin_port = htons(0);
-        memset(&src_sa4.sin_zero, 0, sizeof(src_sa4.sin_zero));
-    } else {
-        LOGE("Set src addr fail.");
+    int fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if(fd < 0){
+        LOGE("socket() fail.[%d]", errno);
         return -1;
     }
 
+#if 0
+    struct sockaddr_in src_sa4;
+    memset(&src_sa4, 0, sizeof(src_sa4));
+    src_sa4.sin_family = AF_INET;
+    src_sa4.sin_port = htons(0);
+    src_sa4.sin_addr.s_addr = inet_addr("127.0.0.1");
+
+    if (bind(fd, (struct sockaddr*) &src_sa4, sizeof(src_sa4)) < 0) {
+        LOGE("bind() failed: %d", errno);
+        goto result_fail_with_close;
+    }
+#else
+    if(strlen(vlan) > 0) {
+        if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
+                       vlan, strlen(vlan)) < 0) {
+            LOGE("setsockopt(SO_BINDTODEVICE) failed");
+            return -1;
+        }
+    }
+#endif
+
+    struct sockaddr_in dst_sa4;
     if (inet_pton(AF_INET, remote_addr, &dst_sa4.sin_addr) > 0) {
         dst_sa4.sin_family = AF_INET;
         dst_sa4.sin_port = htons(remote_port);
@@ -543,17 +582,6 @@
         return -1;
     }
 
-    int fd = socket(AF_INET, SOCK_DGRAM, 0);
-    if(fd < 0){
-        LOGE("socket() fail.[%d]", errno);
-        return -1;
-    }
-
-    if (bind(fd, (struct sockaddr*) &src_sa4, sizeof(src_sa4)) < 0) {
-        LOGE("bind() failed: %d", errno);
-        goto result_fail_with_close;
-    }
-
     if (connect(fd, (struct sockaddr*) &dst_sa4, sizeof(dst_sa4)) < 0) {
         LOGE("connect() failed: %d", errno);
         goto result_fail_with_close;
@@ -726,7 +754,7 @@
     }
 
     LOGD("Start open UDP client : %s-%d", conf_info->remote_ip, conf_info->server_port);
-    rtp_info.udp_send_sock.fd = rtp_udp_cli_open(conf_info->remote_ip, conf_info->server_port);
+    rtp_info.udp_send_sock.fd = rtp_udp_cli_open(conf_info->vlan, conf_info->remote_ip, conf_info->server_port);
     if(rtp_info.udp_send_sock.fd < 0) {
         LOGE("Can not connected to %s:%d [errno-%d].", conf_info->remote_ip, conf_info->server_port, errno);
         goto error;
diff --git a/mbtk/mbtk_servicesd_v2/src/reboot_reason.c b/mbtk/mbtk_servicesd_v2/src/reboot_reason.c
index e40c7f4..f1dfc8c 100755
--- a/mbtk/mbtk_servicesd_v2/src/reboot_reason.c
+++ b/mbtk/mbtk_servicesd_v2/src/reboot_reason.c
@@ -39,8 +39,8 @@
     mbtk_device_info_reboot_flag_enum reboot_reason = MBTK_REBOOT_FLAG_NORMAL;
     mbtk_device_info_basic_t info_basic = {0};
     memset(&info_basic, 0, sizeof(mbtk_device_info_basic_t));
-    
-    
+
+
     ret = mbtk_dev_info_read(MBTK_DEVICE_INFO_ITEM_BASIC, &(info_basic), sizeof(mbtk_device_info_basic_t));
     if(ret != 0)
     {
@@ -49,14 +49,27 @@
     }
     else
     {
-        reboot_reason = info_basic.reboot_flag;
-        if(info_basic.reboot_flag != MBTK_REBOOT_FLAG_NORMAL)
-        {
-            info_basic.reboot_flag = MBTK_REBOOT_FLAG_NORMAL;
-            ret = mbtk_dev_info_write(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
-            if(ret != 0) {
-                LOGE("[%s] mbtk_dev_info_write(BASIC) fail.", __func__);
+        if(info_basic.version == DEV_INFO_VERSION_V1) {
+            reboot_reason = info_basic.basic.v1.reboot_flag;
+            if(reboot_reason != MBTK_REBOOT_FLAG_NORMAL)
+            {
+                info_basic.basic.v1.reboot_flag = MBTK_REBOOT_FLAG_NORMAL;
+                ret = mbtk_dev_info_write(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
+                if(ret != 0) {
+                    LOGE("[%s] mbtk_dev_info_write(BASIC) fail.", __func__);
+                }
             }
+        } else {
+            reboot_reason = info_basic.basic.v2.reboot_flag;
+            if(reboot_reason != MBTK_REBOOT_FLAG_NORMAL)
+            {
+                info_basic.basic.v2.reboot_flag = MBTK_REBOOT_FLAG_NORMAL;
+                ret = mbtk_dev_info_write(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
+                if(ret != 0) {
+                    LOGE("[%s] mbtk_dev_info_write(BASIC) fail.", __func__);
+                }
+            }
+
         }
     }
 
@@ -64,7 +77,7 @@
     memset(buff, 0x0, 32);
     sprintf(buff, "%d", reboot_reason);
     property_set("persist.mbtk.reboot_reason", buff);
-    
+
     LOGD("[%s] reboot reason exit.", __func__);
 
     return 0;
diff --git a/mbtk/mbtk_utils/device_info.c b/mbtk/mbtk_utils/device_info.c
index a5cc759..976f289 100755
--- a/mbtk/mbtk_utils/device_info.c
+++ b/mbtk/mbtk_utils/device_info.c
@@ -125,35 +125,36 @@
     memset(info_modem, 0, sizeof(mbtk_device_info_modem_t));
     if(mbtk_dev_info_read(MBTK_DEVICE_INFO_ITEM_MODEM, info_modem, sizeof(mbtk_device_info_modem_t))) {
         printf("mbtk_dev_info_read(MODEM) fail, use default band.\n");
-        info_modem->band_area = MBTK_MODEM_BAND_AREA_ALL;
+        info_modem->version = DEV_INFO_VERSION_V2;
+        info_modem->modem.v2.band_area = MBTK_MODEM_BAND_AREA_ALL;
 #ifdef MBTK_5G_SUPPORT
-        info_modem->net_pref = 19; // MBTK_NET_PREF_LTE_NR_NR_PREF
-        info_modem->net_support = MBTK_NET_SUPPORT_4G | MBTK_NET_SUPPORT_5G;
+        info_modem->modem.v2.net_pref = 19; // MBTK_NET_PREF_LTE_NR_NR_PREF
+        info_modem->modem.v2.net_support = MBTK_NET_SUPPORT_4G | MBTK_NET_SUPPORT_5G;
 
-        info_modem->band_gsm = 0;
-        info_modem->band_wcdma = 0;
-        info_modem->band_tdlte = MBTK_BAND_ALL_TDLTE_DEFAULT;
-        info_modem->band_fddlte = MBTK_BAND_ALL_FDDLTE_DEFAULT;
-        info_modem->band_lte_ext = MBTK_BAND_ALL_EXT_LTE_DEFAULT;
+        info_modem->modem.v2.band_gsm = 0;
+        info_modem->modem.v2.band_wcdma = 0;
+        info_modem->modem.v2.band_tdlte = MBTK_BAND_ALL_TDLTE_DEFAULT;
+        info_modem->modem.v2.band_fddlte = MBTK_BAND_ALL_FDDLTE_DEFAULT;
+        info_modem->modem.v2.band_lte_ext = MBTK_BAND_ALL_EXT_LTE_DEFAULT;
 
-        info_modem->band_nr_3 = MBTK_BAND_ALL_NR_3_DEFAULT;
-        info_modem->band_nr_2 = MBTK_BAND_ALL_NR_2_DEFAULT;
-        info_modem->band_nr_1 = MBTK_BAND_ALL_NR_1_DEFAULT;
-        info_modem->band_nr_0 = MBTK_BAND_ALL_NR_0_DEFAULT;
+        info_modem->modem.v2.band_nr_3 = MBTK_BAND_ALL_NR_3_DEFAULT;
+        info_modem->modem.v2.band_nr_2 = MBTK_BAND_ALL_NR_2_DEFAULT;
+        info_modem->modem.v2.band_nr_1 = MBTK_BAND_ALL_NR_1_DEFAULT;
+        info_modem->modem.v2.band_nr_0 = MBTK_BAND_ALL_NR_0_DEFAULT;
 #else
-        info_modem->net_pref = 15; // MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF
-        info_modem->net_support = MBTK_NET_SUPPORT_2G | MBTK_NET_SUPPORT_3G | MBTK_NET_SUPPORT_4G;
+        info_modem->modem.v2.net_pref = 15; // MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF
+        info_modem->modem.v2.net_support = MBTK_NET_SUPPORT_2G | MBTK_NET_SUPPORT_3G | MBTK_NET_SUPPORT_4G;
 
-        info_modem->band_gsm = MBTK_BAND_ALL_GSM_DEFAULT;
-        info_modem->band_wcdma = MBTK_BAND_ALL_WCDMA_DEFAULT;
-        info_modem->band_tdlte = MBTK_BAND_ALL_TDLTE_DEFAULT;
-        info_modem->band_fddlte = MBTK_BAND_ALL_FDDLTE_DEFAULT;
-        info_modem->band_lte_ext = MBTK_BAND_ALL_EXT_LTE_DEFAULT;
+        info_modem->modem.v2.band_gsm = MBTK_BAND_ALL_GSM_DEFAULT;
+        info_modem->modem.v2.band_wcdma = MBTK_BAND_ALL_WCDMA_DEFAULT;
+        info_modem->modem.v2.band_tdlte = MBTK_BAND_ALL_TDLTE_DEFAULT;
+        info_modem->modem.v2.band_fddlte = MBTK_BAND_ALL_FDDLTE_DEFAULT;
+        info_modem->modem.v2.band_lte_ext = MBTK_BAND_ALL_EXT_LTE_DEFAULT;
 
-        info_modem->band_nr_3 = 0;
-        info_modem->band_nr_2 = 0;
-        info_modem->band_nr_1 = 0;
-        info_modem->band_nr_0 = 0;
+        info_modem->modem.v2.band_nr_3 = 0;
+        info_modem->modem.v2.band_nr_2 = 0;
+        info_modem->modem.v2.band_nr_1 = 0;
+        info_modem->modem.v2.band_nr_0 = 0;
 #endif
     }
 }
@@ -164,20 +165,24 @@
     char rsp[100] = {0};
 
     // Only support 4G/5G
-    if(band->net_support & MBTK_NET_SUPPORT_5G) {
+    if(band->modem.v2.net_support & MBTK_NET_SUPPORT_5G) {
         // AT*band=19,0,0,482,134742231,0,24576,256,134217877,0
-        if(band->band_lte_ext > 0) {
-            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d,%d,%d,%d,%d,0,,,,%d", band->net_pref, band->band_gsm, band->band_wcdma, band->band_tdlte, band->band_fddlte,
-                band->band_nr_3, band->band_nr_2, band->band_nr_1, band->band_nr_0, band->band_lte_ext);
+        if(band->modem.v2.band_lte_ext > 0) {
+            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d,%d,%d,%d,%d,0,,,,%d", band->modem.v2.net_pref, band->modem.v2.band_gsm,
+                band->modem.v2.band_wcdma, band->modem.v2.band_tdlte, band->modem.v2.band_fddlte,
+                band->modem.v2.band_nr_3, band->modem.v2.band_nr_2, band->modem.v2.band_nr_1,
+                band->modem.v2.band_nr_0, band->modem.v2.band_lte_ext);
         } else {
-            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d,%d,%d,%d,%d,0", band->net_pref, band->band_gsm, band->band_wcdma, band->band_tdlte, band->band_fddlte,
-                band->band_nr_3, band->band_nr_2, band->band_nr_1, band->band_nr_0);
+            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d,%d,%d,%d,%d,0", band->modem.v2.net_pref, band->modem.v2.band_gsm,
+                band->modem.v2.band_wcdma, band->modem.v2.band_tdlte, band->modem.v2.band_fddlte,
+                band->modem.v2.band_nr_3, band->modem.v2.band_nr_2, band->modem.v2.band_nr_1, band->modem.v2.band_nr_0);
         }
     } else {
-        if(band->band_lte_ext > 0) {
-            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d,,,,%d", band->net_pref, band->band_gsm, band->band_wcdma, band->band_tdlte, band->band_fddlte, band->band_lte_ext);
+        if(band->modem.v2.band_lte_ext > 0) {
+            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d,,,,%d", band->modem.v2.net_pref, band->modem.v2.band_gsm, band->modem.v2.band_wcdma,
+                band->modem.v2.band_tdlte, band->modem.v2.band_fddlte, band->modem.v2.band_lte_ext);
         } else {
-            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d", band->net_pref, band->band_gsm, band->band_wcdma, band->band_tdlte, band->band_fddlte);
+            sprintf(cmd, "serial_atcmd AT*BAND=%d,%d,%d,%d,%d", band->modem.v2.net_pref, band->modem.v2.band_gsm, band->modem.v2.band_wcdma, band->modem.v2.band_tdlte, band->modem.v2.band_fddlte);
         }
     }
 
@@ -205,11 +210,11 @@
     }
     else // Set band success.
     {
-        if(info_modem->band_area == MBTK_MODEM_BAND_AREA_CN) {
+        if(info_modem->modem.v2.band_area == MBTK_MODEM_BAND_AREA_CN) {
             property_set("persist.mbtk.band_config", "CN");
-        } else if(info_modem->band_area == MBTK_MODEM_BAND_AREA_EU) {
+        } else if(info_modem->modem.v2.band_area == MBTK_MODEM_BAND_AREA_EU) {
             property_set("persist.mbtk.band_config", "EU");
-        } else if(info_modem->band_area == MBTK_MODEM_BAND_AREA_SA) {
+        } else if(info_modem->modem.v2.band_area == MBTK_MODEM_BAND_AREA_SA) {
             property_set("persist.mbtk.band_config", "SA");
         } else {
             property_set("persist.mbtk.band_config", "ALL");
@@ -258,14 +263,25 @@
             uint8 revision_out[48];     // L508_X6v01.01b04.00
             uint8 revision_in[64];
         */
-        printf("Project:%s\n", info_basic.project);
-        printf("Custom_Model:%s\n", info_basic.project_cust);
-        printf("Revision_Out:%s\n", info_basic.revision_out);
-        printf("Revision_In:%s\n", info_basic.revision_in);
-        printf("Build_Time:%s\n", info_basic.build_time);
-        printf("AB System:%s\n", info_basic.ab_support ? "Yes" : "No");
-        printf("Reboot flag:%d\n", info_basic.reboot_flag);
-        printf("ASR Baseline:%s\n", info_basic.asr_baseline);
+        printf("Version:%d\n", info_basic.version);
+        if(info_basic.version == DEV_INFO_VERSION_V1) {
+            printf("Project:%s\n", info_basic.basic.v1.project);
+            printf("Custom_Model:%s\n", info_basic.basic.v1.project_cust);
+            printf("Revision_Out:%s\n", info_basic.basic.v1.revision_out);
+            printf("Revision_In:%s\n", info_basic.basic.v1.revision_in);
+            printf("Build_Time:%s\n", info_basic.basic.v1.build_time);
+            printf("AB System:%s\n", info_basic.basic.v1.ab_support ? "Yes" : "No");
+            printf("Reboot flag:%d\n", info_basic.basic.v1.reboot_flag);
+        } else {
+            printf("Project:%s\n", info_basic.basic.v2.project);
+            printf("Custom_Model:%s\n", info_basic.basic.v2.project_cust);
+            printf("Revision_Out:%s\n", info_basic.basic.v2.revision_out);
+            printf("Revision_In:%s\n", info_basic.basic.v2.revision_in);
+            printf("Build_Time:%s\n", info_basic.basic.v2.build_time);
+            printf("AB System:%s\n", info_basic.basic.v2.ab_support ? "Yes" : "No");
+            printf("Reboot flag:%d\n", info_basic.basic.v2.reboot_flag);
+            printf("ASR Baseline:%s\n", info_basic.basic.v2.asr_baseline);
+        }
 
         mbtk_device_info_modem_t info_modem;
         memset(&info_modem, 0, sizeof(mbtk_device_info_modem_t));
@@ -275,18 +291,27 @@
             return -1;
         }
 
-        printf("net_pref:%d\n", info_modem.net_pref);
-        printf("net_support:%s\n", net_support_str_get(info_modem.net_support));
-        printf("Band:%s\n", band_2_str(info_modem.band_area));
-        printf("Band GSM:0x%08x(%s)\n", info_modem.band_gsm, band_str_get(info_modem.band_gsm, 0));
-        printf("Band WCDMA:0x%08x(%s)\n", info_modem.band_wcdma, band_str_get(info_modem.band_wcdma, 0));
-        printf("Band TDLTE:0x%08x(%s)\n", info_modem.band_tdlte, band_str_get(info_modem.band_tdlte, 1));
-        printf("Band FDDLTE:0x%08x(%s)\n", info_modem.band_fddlte, band_str_get(info_modem.band_fddlte, 0));
-        printf("Band EXT_LTE:0x%08x(%s)\n", info_modem.band_lte_ext, band_str_get(info_modem.band_lte_ext, 0));
-        printf("Band NR_3:0x%08x(%s)\n", info_modem.band_nr_3, band_str_get(info_modem.band_nr_3, 3));
-        printf("Band NR_2:0x%08x(%s)\n", info_modem.band_nr_2, band_str_get(info_modem.band_nr_2, 2));
-        printf("Band NR_1:0x%08x(%s)\n", info_modem.band_nr_1, band_str_get(info_modem.band_nr_1, 1));
-        printf("Band NR_0:0x%08x(%s)\n", info_modem.band_nr_0, band_str_get(info_modem.band_nr_0, 0));
+        if(info_modem.version == DEV_INFO_VERSION_V1) {
+            printf("Band:%s\n", band_2_str(info_modem.modem.v1.band_area));
+            printf("Band GSM:0x%08x(%s)\n", info_modem.modem.v1.band_gsm, band_str_get(info_modem.modem.v1.band_gsm, 0));
+            printf("Band WCDMA:0x%08x(%s)\n", info_modem.modem.v1.band_wcdma, band_str_get(info_modem.modem.v1.band_wcdma, 0));
+            printf("Band TDLTE:0x%08x(%s)\n", info_modem.modem.v1.band_tdlte, band_str_get(info_modem.modem.v1.band_tdlte, 1));
+            printf("Band FDDLTE:0x%08x(%s)\n", info_modem.modem.v1.band_fddlte, band_str_get(info_modem.modem.v1.band_fddlte, 0));
+            printf("Band EXT_LTE:0x%08x(%s)\n", info_modem.modem.v1.band_lte_ext, band_str_get(info_modem.modem.v1.band_lte_ext, 0));
+        } else {
+            printf("net_pref:%d\n", info_modem.modem.v2.net_pref);
+            printf("net_support:%s\n", net_support_str_get(info_modem.modem.v2.net_support));
+            printf("Band:%s\n", band_2_str(info_modem.modem.v2.band_area));
+            printf("Band GSM:0x%08x(%s)\n", info_modem.modem.v2.band_gsm, band_str_get(info_modem.modem.v2.band_gsm, 0));
+            printf("Band WCDMA:0x%08x(%s)\n", info_modem.modem.v2.band_wcdma, band_str_get(info_modem.modem.v2.band_wcdma, 0));
+            printf("Band TDLTE:0x%08x(%s)\n", info_modem.modem.v2.band_tdlte, band_str_get(info_modem.modem.v2.band_tdlte, 1));
+            printf("Band FDDLTE:0x%08x(%s)\n", info_modem.modem.v2.band_fddlte, band_str_get(info_modem.modem.v2.band_fddlte, 0));
+            printf("Band EXT_LTE:0x%08x(%s)\n", info_modem.modem.v2.band_lte_ext, band_str_get(info_modem.modem.v2.band_lte_ext, 0));
+            printf("Band NR_3:0x%08x(%s)\n", info_modem.modem.v2.band_nr_3, band_str_get(info_modem.modem.v2.band_nr_3, 3));
+            printf("Band NR_2:0x%08x(%s)\n", info_modem.modem.v2.band_nr_2, band_str_get(info_modem.modem.v2.band_nr_2, 2));
+            printf("Band NR_1:0x%08x(%s)\n", info_modem.modem.v2.band_nr_1, band_str_get(info_modem.modem.v2.band_nr_1, 1));
+            printf("Band NR_0:0x%08x(%s)\n", info_modem.modem.v2.band_nr_0, band_str_get(info_modem.modem.v2.band_nr_0, 0));
+        }
     }
     return 0;
 }
diff --git a/mbtk/mbtk_utils/mbtk_reboot.c b/mbtk/mbtk_utils/mbtk_reboot.c
index a355235..d3861e2 100755
--- a/mbtk/mbtk_utils/mbtk_reboot.c
+++ b/mbtk/mbtk_utils/mbtk_reboot.c
@@ -45,7 +45,11 @@
         return -1;
     }
 
-    info_basic.reboot_flag = MBTK_REBOOT_FLAG_DOWNLOAD;
+    if(info_basic.version == DEV_INFO_VERSION_V1) {
+        info_basic.basic.v1.reboot_flag = MBTK_REBOOT_FLAG_DOWNLOAD;
+    } else {
+        info_basic.basic.v2.reboot_flag = MBTK_REBOOT_FLAG_DOWNLOAD;
+    }
     result = mbtk_dev_info_write(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
     if(result) {
         printf("mbtk_dev_info_write(BASIC) fail.\n");
diff --git a/mbtk/mbtk_utils_linux/Makefile b/mbtk/mbtk_utils_linux/Makefile
index c2427bc..9e6c72b 100755
--- a/mbtk/mbtk_utils_linux/Makefile
+++ b/mbtk/mbtk_utils_linux/Makefile
@@ -5,8 +5,8 @@
 #DEFINE = -DMBTK_DEV_INFO_VERSION_2
 #endif
 
-INC_DIR += \
-		-I$(LOCAL_PATH)
+#INC_DIR += \
+#		-I$(LOCAL_PATH)
 
 CC=gcc
 
diff --git a/mbtk/mbtk_utils_linux/mbtk_device.h b/mbtk/mbtk_utils_linux/mbtk_device.h
new file mode 100755
index 0000000..1850811
--- /dev/null
+++ b/mbtk/mbtk_utils_linux/mbtk_device.h
@@ -0,0 +1,155 @@
+/*
+* mbtk_device.h
+*
+* MBTK device_info partition data header.
+*
+* Author : lb
+* Date   : 2023/12/30 11:36:35
+*/
+#ifndef _MBTK_DEVICE_H
+#define _MBTK_DEVICE_H
+//#include "mbtk_type.h"
+
+#define MBTK_DEVICE_INFO_PARTITION_NAME "device_info"
+#define MBTK_DEVICE_INFO_PARTITION_TAG 0x87878787
+#define MBTK_DEVICE_INFO_CURR_VERSION 2
+
+// 78,147,482,134742231
+#define MBTK_BAND_ALL_GSM_DEFAULT 78             // GSM : ASR default.
+#define MBTK_BAND_ALL_WCDMA_DEFAULT 147          // WCDMA : ASR default.
+#define MBTK_BAND_ALL_TDLTE_DEFAULT 482          // TDD-LTE : ASR default.
+#define MBTK_BAND_ALL_FDDLTE_DEFAULT 134742231   // FDD-LTE : ASR default.
+#define MBTK_BAND_ALL_EXT_LTE_DEFAULT 0          // EXT-LTE
+#define MBTK_BAND_ALL_NR_3_DEFAULT 0
+#define MBTK_BAND_ALL_NR_2_DEFAULT 24576         // n78/n79
+#define MBTK_BAND_ALL_NR_1_DEFAULT 256           // n41
+#define MBTK_BAND_ALL_NR_0_DEFAULT 134217877     // n1/n3/n5/n8/n28
+
+#define MBTK_BAND_CN_GSM_DEFAULT 11             // GSM : B3/B8 (PGSM 900/DCS GSM 1800/EGSM 900)
+#define MBTK_BAND_CN_WCDMA_DEFAULT 129          // WCDMA : B1/B8
+#define MBTK_BAND_CN_TDLTE_DEFAULT 482          // TDD-LTE : B34/B38/B39/B40/B41
+#define MBTK_BAND_CN_FDDLTE_DEFAULT 149         // FDD-LTE : B1/B3/B5/B8
+#define MBTK_BAND_CN_EXT_LTE_DEFAULT 0          // EXT-LTE
+#define MBTK_BAND_CN_NR_3_DEFAULT 0
+#define MBTK_BAND_CN_NR_2_DEFAULT 24576         // n78/n79
+#define MBTK_BAND_CN_NR_1_DEFAULT 384           // n40/n41
+#define MBTK_BAND_CN_NR_0_DEFAULT 134217877     // n1/n3/n5/n8/n28
+
+#define MBTK_BAND_EU_GSM_DEFAULT 11             // GSM : B3/B8 (PGSM 900/DCS GSM 1800/EGSM 900)
+#define MBTK_BAND_EU_WCDMA_DEFAULT 145          // WCDMA : B1/B5/B8
+#define MBTK_BAND_EU_TDLTE_DEFAULT 416          // TDD-LTE : B38/B40/B41
+#define MBTK_BAND_EU_FDDLTE_DEFAULT 134742229   // FDD-LTE : B1/B3/B5/B7/B8/B20/B28
+#define MBTK_BAND_EU_EXT_LTE_DEFAULT 0          // EXT-LTE
+#define MBTK_BAND_EU_NR_3_DEFAULT 0
+#define MBTK_BAND_EU_NR_2_DEFAULT 12352         // n71/n77/n78
+#define MBTK_BAND_EU_NR_1_DEFAULT 416           // n38/n40/n41
+#define MBTK_BAND_EU_NR_0_DEFAULT 134742229     // n1/n3/n5/n7/n8/n20/n28
+
+#define MBTK_BAND_SA_GSM_DEFAULT 79             // GSM : B2/B3/B5/B8(GSM 850/PGSM 900/EGSM 900/DCS GSM 1800/PCS GSM 1900)
+#define MBTK_BAND_SA_WCDMA_DEFAULT 155          // WCDMA : B1/B2/B4/B5/B8
+#define MBTK_BAND_SA_TDLTE_DEFAULT 128          // TDD-LTE : B40
+#define MBTK_BAND_SA_FDDLTE_DEFAULT 134217951  // FDD-LTE : B1/B2/B3/B4/B5/B7/B8/B28
+#define MBTK_BAND_SA_EXT_LTE_DEFAULT 2          // EXT-LTE : B66
+#define MBTK_BAND_SA_NR_3_DEFAULT MBTK_BAND_ALL_NR_3_DEFAULT
+#define MBTK_BAND_SA_NR_2_DEFAULT MBTK_BAND_ALL_NR_2_DEFAULT
+#define MBTK_BAND_SA_NR_1_DEFAULT MBTK_BAND_ALL_NR_1_DEFAULT
+#define MBTK_BAND_SA_NR_0_DEFAULT MBTK_BAND_ALL_NR_0_DEFAULT
+
+#define MBTK_DEVICE_INFO_ITEM_STR_BASIC "BASIC"
+#define MBTK_DEVICE_INFO_ITEM_STR_FOTA "FOTA"
+#define MBTK_DEVICE_INFO_ITEM_STR_MODEM "MODEM"
+#define MBTK_DEVICE_INFO_ITEM_STR_LOG "LOG"
+
+#define MBTK_DEVICE_INFO_ITEM_ADDR_BASIC    0x100   // Header is 0x100
+#define MBTK_DEVICE_INFO_ITEM_ADDR_FOTA     0x500   // Basic is 1k
+#define MBTK_DEVICE_INFO_ITEM_ADDR_MODEM    0x900   // Fota is 1k
+#define MBTK_DEVICE_INFO_ITEM_ADDR_LOG      0xD00   // Modem is 1k
+
+#define MBTK_NET_SUPPORT_2G (1)
+#define MBTK_NET_SUPPORT_3G (1<<1)
+#define MBTK_NET_SUPPORT_4G (1<<2)
+#define MBTK_NET_SUPPORT_5G (1<<3)
+
+typedef enum {
+    MBTK_DEVICE_INFO_ITEM_BASIC = 0,
+    MBTK_DEVICE_INFO_ITEM_FOTA,
+    MBTK_DEVICE_INFO_ITEM_MODEM,
+    MBTK_DEVICE_INFO_ITEM_LOG,
+
+    MBTK_DEVICE_INFO_ITEM_NUM
+} mbtk_device_info_item_enum;
+
+typedef struct {
+    mbtk_device_info_item_enum item;
+    uint32 addr;
+} mbtk_device_info_item_header_t;
+
+typedef struct {
+    uint32 tag;
+    uint32 version;             // Default : 0x01
+    uint32 item_count;
+    mbtk_device_info_item_header_t item_header[MBTK_DEVICE_INFO_ITEM_NUM];
+} mbtk_device_info_header_t;
+
+typedef enum {
+    MBTK_REBOOT_FLAG_NORMAL = 0,
+    MBTK_REBOOT_FLAG_DOWNLOAD,
+    MBTK_REBOOT_FLAG_POWER_OFF,  //Power off and restart
+    MBTK_REBOOT_FLAG_HARDWARE,   //Hardware restart
+    MBTK_REBOOT_FLAG_COMMAND,    //"reboot" "reboot -f" Command restart
+    MBTK_REBOOT_FLAG_ABNORMAL,   //Abnormal restart
+    MBTK_REBOOT_FLAG_UNKNOWN,    //unknown restart
+} mbtk_device_info_reboot_flag_enum;
+
+typedef struct {
+    uint8 name[16];
+    uint32 version;             // Default : 0x01
+    uint8 project[16];          // T108 / L508_X6
+    uint8 project_cust[16];     // T108_C1 / L508_X6_C1  (Refer to: Custom_Model in blf file.)
+    uint32 ab_support;          // 1 for ab
+    mbtk_device_info_reboot_flag_enum reboot_flag;
+    uint8 revision_out[48];     // L508_X6v01.01b04.00
+    uint8 revision_in[64];
+    uint8 build_time[64];
+    uint8 asr_baseline[64];
+} mbtk_device_info_basic_t;
+
+typedef struct {
+    uint8 name[16];
+    uint32 version;             // Default : 0x01
+    uint32 state;               //
+} mbtk_device_info_fota_t;
+
+typedef enum {
+    MBTK_MODEM_BAND_AREA_ALL,
+    MBTK_MODEM_BAND_AREA_CN,
+    MBTK_MODEM_BAND_AREA_EU,
+    MBTK_MODEM_BAND_AREA_SA
+} mbtk_modem_band_area_enum;
+
+typedef struct {
+    uint8 name[16];
+    uint32 version;             // Default : 0x01
+    mbtk_modem_band_area_enum band_area;
+    uint32 net_pref;    // Refor to : mbtk_net_pref_enum
+    uint32 net_support; // 1:GSM      2:WCDMA   4:LTE   8:NR
+    uint32 band_gsm;
+    uint32 band_wcdma;
+    uint32 band_tdlte;
+    uint32 band_fddlte;
+    uint32 band_lte_ext;
+    uint32 band_nr_3;
+    uint32 band_nr_2;
+    uint32 band_nr_1;
+    uint32 band_nr_0;
+} mbtk_device_info_modem_t;
+
+typedef struct {
+    uint8 name[16];
+    uint32 version;             // Default : 0x01
+    uint32 state;               //
+} mbtk_device_info_log_t;
+
+
+#endif /* _MBTK_DEVICE_H */
+
diff --git a/mbtk/mbtk_utils_linux/mbtk_type.h b/mbtk/mbtk_utils_linux/mbtk_type.h
new file mode 100755
index 0000000..c7fc885
--- /dev/null
+++ b/mbtk/mbtk_utils_linux/mbtk_type.h
@@ -0,0 +1,123 @@
+#ifndef MBTK_TYPE_INCLUDE
+#define MBTK_TYPE_INCLUDE
+#include <stdio.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#ifndef MBTK_PLATFORM_LINUX
+#define MBTK_PLATFORM_LINUX
+#endif
+
+#ifndef MBTK_PLATFORM_QCOMM
+//#define MBTK_PLATFORM_QCOMM
+#endif
+
+#define MBTK_SUCCESS 0
+#define MBTK_FAILE (-1)
+
+#ifndef UNUSED
+#define UNUSED(param) ((void) param)
+#endif
+
+#ifndef UNUSEDPARAM
+#define UNUSEDPARAM(param) ((void) param)
+#endif
+
+#ifndef TRUE
+#define TRUE   1   /* Boolean true value. */
+#endif
+
+#ifndef true
+#define true   1   /* Boolean true value. */
+#endif
+
+#ifndef FALSE
+#define FALSE  0   /* Boolean false value. */
+#endif
+
+#ifndef false
+#define false  0   /* Boolean false value. */
+#endif
+
+
+#ifndef NULL
+#define NULL  0
+#endif
+
+
+#ifndef null
+#define null  0
+#endif
+
+/**
+ * Compiler-digit : 16
+ * char : 1     (%c)
+ * char* : 2
+ * short int : 2
+ * int : 2      (%d)
+ * unsigned int : 2  (%u)
+ * float : 4    (%f)
+ * double : 8   (%f)
+ * long : 4
+ * unsigned long : 4
+ * long long : 8
+ * unsigned long long : 8
+ *
+ *
+ * Compiler-digit : 32
+ * char : 1
+ * char* : 4
+ * short int : 2
+ * int : 4
+ * unsigned int : 4
+ * float : 4
+ * double : 8
+ * long : 4
+ * unsigned long : 4
+ * long long : 8
+ * unsigned long long : 8
+ *
+ *
+ * Compiler-digit : 64
+ * char : 1
+ * char* : 8
+ * short int : 2
+ * int : 4
+ * unsigned int : 4
+ * float : 4
+ * double : 8
+ * long : 8
+ * unsigned long : 8
+ * long long : 8
+ * unsigned long long : 8
+ */
+typedef unsigned char boolean; /* Boolean value type. */
+// typedef unsigned char bool; /* Boolean value type. */
+typedef unsigned long long uint64; /* Unsigned 64 bit value */
+typedef unsigned long long uint64_t; /* Unsigned 64 bit value */
+typedef unsigned int uint32; /* Unsigned 32 bit value */
+typedef unsigned int uint32_t; /* Unsigned 32 bit value */
+typedef unsigned short uint16; /* Unsigned 16 bit value */
+typedef unsigned short uint16_t;
+typedef unsigned char uint8; /* Unsigned 8  bit value */
+typedef unsigned char uint8_t;
+typedef signed long long int64; /* Signed 64 bit value */
+typedef signed long long sint64; /* Signed 64 bit value */
+typedef signed int int32; /* Signed 32 bit value */
+typedef signed int sint32; /* Signed 32 bit value */
+typedef signed short int16; /* Signed 16 bit value */
+typedef signed short sint16; /* Signed 16 bit value */
+typedef signed char int8; /* Signed 8  bit value */
+typedef signed char sint8; /* Signed 8  bit value */
+typedef unsigned char byte; /* byte type */
+
+
+typedef struct
+{
+    char *buffer;
+    int size;
+    int size_max;
+} mbtk_buffer_t;
+
+
+#endif /* MBTK_TYPE_INCLUDE */
diff --git a/mbtk/test/libmbtk_lib/mbtk_rtp_test.c b/mbtk/test/libmbtk_lib/mbtk_rtp_test.c
index 2140e25..bc20847 100755
--- a/mbtk/test/libmbtk_lib/mbtk_rtp_test.c
+++ b/mbtk/test/libmbtk_lib/mbtk_rtp_test.c
@@ -15,6 +15,7 @@
     printf("rtp_mode <0/1>: Disable/Enable RTP.\n");
     printf("volume <0-7>: Set volume.\n");
     printf("remote_ip <xxx:xxx:xxx:xxx>: Set remote ip.\n");
+    printf("vlan <dev>: Set local device.\n");
     printf("client_port <port>: Set client(local) port.\n");
     printf("server_port <port>: Set server(remote) port.\n");
     printf("sample_rate <8000/16000>: Set sample rate.\n");
@@ -93,6 +94,16 @@
                     }
                 }
             }
+            else if(!strncasecmp(cmd, "vlan", 4)){
+                char vlan[20] = {0};
+                if(1 == sscanf(cmd, "vlan %s", vlan)) {
+                    if(mbtk_rtp_vlan_set(vlan)) {
+                        printf("Error\n");
+                    } else {
+                        printf("Success\n");
+                    }
+                }
+            }
             else if(!strncasecmp(cmd, "client_port", 11)){
                 int temp;
                 if(1 == sscanf(cmd, "client_port %d", &temp)) {