diff --git a/model/usb/src/usb_ddk_pnp_loader.c b/model/usb/src/usb_ddk_pnp_loader.c
index c8be7990eacd3e8c846e1d0586ad2b85c8526f19..41d2dac84b83e926a06cacb2bb5228660ec83a95 100755
--- a/model/usb/src/usb_ddk_pnp_loader.c
+++ b/model/usb/src/usb_ddk_pnp_loader.c
@@ -1006,7 +1006,8 @@ int UsbDdkPnpLoaderEventHandle(void)
     }
     return status;
 error:
-    for (idTable = g_usbPnpMatchIdTable[0]; idTable != NULL;) {
+    idTable = g_usbPnpMatchIdTable[0];
+    while (idTable != NULL) {
         tableCount++;
         idTable = g_usbPnpMatchIdTable[tableCount];
     }
diff --git a/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h b/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h
old mode 100644
new mode 100755
index e28d2ad985e9988584bc64dd5858608db83e405d..95b0049482a77c79b01c41e79bf97d56b46ec94d
--- a/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h
+++ b/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h
@@ -126,7 +126,6 @@ struct CtrlInfo {
     struct AcmDevice         *acm;
 };
 
-extern struct UsbFnDeviceDesc g_acmFnDevice;
 struct AcmDevice *SetUpAcmDevice(void);
 void ReleaseAcmDevice(struct AcmDevice *acm);
 void AcmEventCallback(struct UsbFnEvent *event);
diff --git a/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c b/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c
index 841d89300ba89c3fa3fa7857db85e4086892d9f8..7250a9366257d11b54bb3b68fa0ce72a479274a3 100755
--- a/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c
+++ b/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c
@@ -335,13 +335,42 @@ static struct Serial *SerialAlloc(void)
     return port;
 }
 
+static void ParsePipes(struct AcmDevice *acmDevice, struct UsbFnInterface *fnIface, UsbFnInterfaceHandle handle)
+{
+    uint32_t j;
+    int ret;
+    for (j = 0; j < fnIface->info.numPipes; j++) {
+        struct UsbFnPipeInfo pipeInfo;
+        ret = UsbFnGetInterfacePipeInfo(fnIface, j, &pipeInfo);
+        if (ret != HDF_SUCCESS) {
+            return;
+        }
+        if (pipeInfo.type == USB_PIPE_TYPE_INTERRUPT) {
+            acmDevice->notifyPipe.id = pipeInfo.id;
+            acmDevice->notifyPipe.maxPacketSize = pipeInfo.maxPacketSize;
+            acmDevice->ctrlIface.fn = fnIface;
+            acmDevice->ctrlIface.handle = handle;
+        } else if (pipeInfo.type == USB_PIPE_TYPE_BULK) {
+            if (pipeInfo.dir == USB_PIPE_DIRECTION_IN) {
+                acmDevice->dataInPipe.id = pipeInfo.id;
+                acmDevice->dataInPipe.maxPacketSize = pipeInfo.maxPacketSize;
+                acmDevice->dataIface.fn = fnIface;
+                acmDevice->dataIface.handle = handle;
+            } else {
+                acmDevice->dataOutPipe.id = pipeInfo.id;
+                acmDevice->dataOutPipe.maxPacketSize = pipeInfo.maxPacketSize;
+                acmDevice->dataIface.fn = fnIface;
+                acmDevice->dataIface.handle = handle;
+            }
+        }
+    }
+}
+
 static int ParseInterfaces(struct AcmDevice *acmDevice)
 {
     uint32_t i;
-    uint32_t j;
     struct UsbFnInterface *fnIface = NULL;
-    UsbFnInterfaceHandle handle = NULL;
-    int ret;
+    UsbFnInterfaceHandle handle;
 
     for (i = 0; i < acmDevice->fnDev->numInterfaces; i++) {
         fnIface = (struct UsbFnInterface *)UsbFnGetInterface(acmDevice->fnDev, i);
@@ -352,31 +381,7 @@ static int ParseInterfaces(struct AcmDevice *acmDevice)
         if (handle == NULL) {
             return -1;
         }
-        for (j = 0; j < fnIface->info.numPipes; j++) {
-            struct UsbFnPipeInfo pipeInfo;
-            ret = UsbFnGetInterfacePipeInfo(fnIface, j, &pipeInfo);
-            if (ret != HDF_SUCCESS) {
-                return -1;
-            }
-            if (pipeInfo.type == USB_PIPE_TYPE_INTERRUPT) {
-                acmDevice->notifyPipe.id = pipeInfo.id;
-                acmDevice->notifyPipe.maxPacketSize = pipeInfo.maxPacketSize;
-                acmDevice->ctrlIface.fn = fnIface;
-                acmDevice->ctrlIface.handle = handle;
-            } else if (pipeInfo.type == USB_PIPE_TYPE_BULK) {
-                if (pipeInfo.dir == USB_PIPE_DIRECTION_IN) {
-                    acmDevice->dataInPipe.id = pipeInfo.id;
-                    acmDevice->dataInPipe.maxPacketSize = pipeInfo.maxPacketSize;
-                    acmDevice->dataIface.fn = fnIface;
-                    acmDevice->dataIface.handle = handle;
-                } else {
-                    acmDevice->dataOutPipe.id = pipeInfo.id;
-                    acmDevice->dataOutPipe.maxPacketSize = pipeInfo.maxPacketSize;
-                    acmDevice->dataIface.fn = fnIface;
-                    acmDevice->dataIface.handle = handle;
-                }
-            }
-        }
+        ParsePipes(acmDevice, fnIface, handle);
     }
     return 0;
 }
diff --git a/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c b/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c
old mode 100644
new mode 100755
index 3a2e38ac24ffab11fe549a3c20962224a185af68..d9ea3c27071d88770e5563a297c3dffb54e4ed67
--- a/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c
+++ b/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c
@@ -18,6 +18,7 @@
 #define HDF_LOG_TAG usb_device_sdk_test
 
 static struct AcmDevice *g_acmDevice = NULL;
+extern struct UsbFnDeviceDesc g_acmFnDevice;
 
 #include "usb_device_lite_sdk_io_test.c"
 
diff --git a/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c b/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c
old mode 100644
new mode 100755
index a806584e8d1ed91da05fcd97c8b16d1b5779344f..b18304794ece0687acc9df210c3f770e110f0479
--- a/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c
+++ b/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c
@@ -570,6 +570,37 @@ int32_t UsbFnDviceTestCancelRequest005(void)
     return HDF_SUCCESS;
 }
 
+int32_t TestCancelRequest(struct UsbFnRequest *req, struct UsbFnRequest *req2)
+{
+    int ret;
+    ret = UsbFnSubmitRequestAsync(req2);
+    if (HDF_SUCCESS != ret) {
+        HDF_LOGE("%s: request async error", __func__);
+        return HDF_FAILURE;
+    }
+    ret = UsbFnCancelRequest(req2);
+    if (HDF_SUCCESS != ret) {
+        dprintf("%s: cancel request error", __func__);
+        return HDF_FAILURE;
+    }
+    ret = UsbFnCancelRequest(req);
+    if (HDF_SUCCESS != ret) {
+        dprintf("%s: cancel request error", __func__);
+        return HDF_FAILURE;
+    }
+    ret = UsbFnFreeRequest(req);
+    if (HDF_SUCCESS != ret) {
+        dprintf("%s: free Request error", __func__);
+        return HDF_FAILURE;
+    }
+    ret = UsbFnFreeRequest(req2);
+    if (HDF_SUCCESS != ret) {
+        dprintf("%s: free Request error", __func__);
+        return HDF_FAILURE;
+    }
+    return HDF_SUCCESS;
+}
+
 int32_t UsbFnDviceTestCancelRequest006(void)
 {
     int ret;
@@ -604,31 +635,6 @@ int32_t UsbFnDviceTestCancelRequest006(void)
         HDF_LOGE("%s: request async error", __func__);
         return HDF_FAILURE;
     }
-    ret = UsbFnSubmitRequestAsync(req2);
-    if (HDF_SUCCESS != ret) {
-        HDF_LOGE("%s: request async error", __func__);
-        return HDF_FAILURE;
-    }
-    ret = UsbFnCancelRequest(req2);
-    if (HDF_SUCCESS != ret) {
-        dprintf("%s: cancel request error", __func__);
-        return HDF_FAILURE;
-    }
-    ret = UsbFnCancelRequest(req);
-    if (HDF_SUCCESS != ret) {
-        dprintf("%s: cancel request error", __func__);
-        return HDF_FAILURE;
-    }
-    ret = UsbFnFreeRequest(req);
-    if (HDF_SUCCESS != ret) {
-        dprintf("%s: free Request error", __func__);
-        return HDF_FAILURE;
-    }
-    ret = UsbFnFreeRequest(req2);
-    if (HDF_SUCCESS != ret) {
-        dprintf("%s: free Request error", __func__);
-        return HDF_FAILURE;
-    }
-    return HDF_SUCCESS;
+    return TestCancelRequest(req, req2);
 }
 
diff --git a/test/unittest/model/usb/host/include/usb_raw_test.h b/test/unittest/model/usb/host/include/usb_raw_test.h
index b02a0fa0e70d78d508598e160e23f7e45fc99552..de9c6ac37f72ccbced69efe68052e58041a2f824 100755
--- a/test/unittest/model/usb/host/include/usb_raw_test.h
+++ b/test/unittest/model/usb/host/include/usb_raw_test.h
@@ -352,13 +352,12 @@ struct UsbFillRequestData {
     UsbRequestCallback userCallback;
 };
 
-extern struct AcmRawDevice *g_acm;
-
 struct UsbRawTestFunc {
     enum UsbRawTestCmd type;
     int32_t (*Func)(void);
 };
 
+struct AcmRawDevice *UsbGetIoAcm(void);
 int UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescriptor *config);
 int AcmWriteBufAlloc(struct AcmRawDevice *acm);
 void AcmNotifyReqCallback(const void *requestArg);
diff --git a/test/unittest/model/usb/host/src/usb_raw_io.c b/test/unittest/model/usb/host/src/usb_raw_io.c
index dc0da48c61e10fcf296bdf10a7992b939cb87e95..42ee4a508182aaf71b2a6a91650ad0a84c2132ee 100755
--- a/test/unittest/model/usb/host/src/usb_raw_io.c
+++ b/test/unittest/model/usb/host/src/usb_raw_io.c
@@ -30,12 +30,17 @@ int g_activeConfig;
 bool g_initFlag;
 bool g_stopIoThreadFlag = false;
 
+struct AcmRawDevice *UsbGetIoAcm(void)
+{
+    return g_acm;
+}
+
 int UsbIoThread(void *data)
 {
     int ret;
     struct AcmRawDevice *acm = (struct AcmRawDevice *)data;
 
-    for (;;) {
+    while (true) {
         printf("%s:%d\n", __func__, __LINE__);
         if (acm == NULL) {
             printf("%s:%d acm is NULL\n", __func__, __LINE__);
@@ -206,11 +211,11 @@ void AcmNotifyReqCallback(const void *requestArg)
     printf("Irqstatus:%d,actualLength:%u\n", req->status, currentSize);
 }
 
-static int AcmWriteBufAllocHandle(struct AcmRawDevice *acm)
+static int AcmWriteBufAllocHandle(const struct AcmRawDevice *acm)
 {
     int i;
     struct RawWb *wb;
-    for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
+    for (wb = (struct RawWb *)&acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
         wb->buf = OsalMemCalloc(acm->dataOutEp.maxPacketSize);
         if (!wb->buf) {
             while (i != 0) {
@@ -257,7 +262,8 @@ void AcmCtrlReqCallback(const void *requestArg)
     printf("%s:%d entry!", __func__, __LINE__);
 }
 
-static void AcmParaseInterfaceClass(struct AcmRawDevice *acm, const struct UsbRawInterface *interface, uint8_t number)
+static void AcmParaseInterfaceClass(
+    struct AcmRawDevice * const acm, const struct UsbRawInterface *interface, uint8_t number)
 {
     uint8_t ifaceClass;
     uint8_t numEndpoints;
@@ -295,7 +301,6 @@ static void AcmParaseInterfaceClass(struct AcmRawDevice *acm, const struct UsbRa
             printf("%s:%d wrong descriptor type\n", __func__, __LINE__);
             break;
     }
-
 }
 
 int UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescriptor *config)
diff --git a/test/unittest/model/usb/host/src/usb_raw_test.c b/test/unittest/model/usb/host/src/usb_raw_test.c
index 423dcc99edb78ac262a8e98429e80f5d72ba2c3a..1f6d0098542c2f56d9cc005e6d425a5b737e1082 100755
--- a/test/unittest/model/usb/host/src/usb_raw_test.c
+++ b/test/unittest/model/usb/host/src/usb_raw_test.c
@@ -52,8 +52,9 @@ int32_t CheckRawSdkIfClaimInterface001(void)
 int32_t CheckRawSdkIfClaimInterface005(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbParseConfigDescriptor(g_acm, g_acm->config);
+    ret = UsbParseConfigDescriptor(rawAcm, rawAcm->config);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -65,8 +66,9 @@ int32_t CheckRawSdkIfClaimInterface005(void)
 int32_t CheckRawSdkIfReleaseInterface001(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawReleaseInterface(NULL, g_acm->ctrlIface);
+    ret = UsbRawReleaseInterface(NULL, rawAcm->ctrlIface);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -78,8 +80,9 @@ int32_t CheckRawSdkIfReleaseInterface001(void)
 int32_t CheckRawSdkIfReleaseInterface002(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->ctrlIface);
+    ret = UsbRawReleaseInterface(rawAcm->devHandle, rawAcm->ctrlIface);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -91,8 +94,9 @@ int32_t CheckRawSdkIfReleaseInterface002(void)
 int32_t CheckRawSdkIfReleaseInterface003(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawReleaseInterface(NULL, g_acm->dataIface);
+    ret = UsbRawReleaseInterface(NULL, rawAcm->dataIface);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -104,8 +108,9 @@ int32_t CheckRawSdkIfReleaseInterface003(void)
 int32_t CheckRawSdkIfReleaseInterface004(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->dataIface);
+    ret = UsbRawReleaseInterface(rawAcm->devHandle, rawAcm->dataIface);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -117,8 +122,9 @@ int32_t CheckRawSdkIfReleaseInterface004(void)
 int32_t CheckRawSdkIfClaimInterface006(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbParseConfigDescriptor(g_acm, g_acm->config);
+    ret = UsbParseConfigDescriptor(rawAcm, rawAcm->config);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -131,17 +137,18 @@ int32_t CheckRawSdkIfAllocRequest001(void)
 {
     int i;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = AcmWriteBufAlloc(g_acm);
+    ret = AcmWriteBufAlloc(rawAcm);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
 
     for (i = 0; i < ACM_NW; i++) {
-        g_acm->wb[i].request = UsbRawAllocRequest(NULL, 0, g_acm->dataOutEp.maxPacketSize);
-        g_acm->wb[i].instance = g_acm;
-        if (g_acm->wb[i].request) {
+        rawAcm->wb[i].request = UsbRawAllocRequest(NULL, 0, rawAcm->dataOutEp.maxPacketSize);
+        rawAcm->wb[i].instance = rawAcm;
+        if (rawAcm->wb[i].request) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
@@ -154,18 +161,19 @@ int32_t CheckRawSdkIfAllocRequest002(void)
 {
     int i;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = AcmWriteBufAlloc(g_acm);
+    ret = AcmWriteBufAlloc(rawAcm);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
 
     for (i = 0; i < ACM_NW; i++) {
-        g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp.maxPacketSize);
-        g_acm->wb[i].instance = g_acm;
-        ((struct UsbHostRequest *)(g_acm->wb[i].request))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
-        if (g_acm->wb[i].request == NULL) {
+        rawAcm->wb[i].request = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataOutEp.maxPacketSize);
+        rawAcm->wb[i].instance = rawAcm;
+        ((struct UsbHostRequest *)(rawAcm->wb[i].request))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
+        if (rawAcm->wb[i].request == NULL) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
@@ -177,10 +185,11 @@ int32_t CheckRawSdkIfAllocRequest002(void)
 int32_t CheckRawSdkIfAllocRequest003(void)
 {
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NR; i++) {
-        g_acm->readReq[i] = UsbRawAllocRequest(NULL, 0, g_acm->dataInEp.maxPacketSize);
-        if (g_acm->readReq[i]) {
+        rawAcm->readReq[i] = UsbRawAllocRequest(NULL, 0, rawAcm->dataInEp.maxPacketSize);
+        if (rawAcm->readReq[i]) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
@@ -192,11 +201,12 @@ int32_t CheckRawSdkIfAllocRequest003(void)
 int32_t CheckRawSdkIfAllocRequest004(void)
 {
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NR; i++) {
-        g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp.maxPacketSize);
-        ((struct UsbHostRequest *)(g_acm->readReq[i]))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
-        if (g_acm->readReq[i] == NULL) {
+        rawAcm->readReq[i] = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataInEp.maxPacketSize);
+        ((struct UsbHostRequest *)(rawAcm->readReq[i]))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
+        if (rawAcm->readReq[i] == NULL) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
@@ -207,8 +217,9 @@ int32_t CheckRawSdkIfAllocRequest004(void)
 
 int32_t CheckRawSdkIfAllocRequest005(void)
 {
-    g_acm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE);
-    if (g_acm->ctrlReq) {
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    rawAcm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE);
+    if (rawAcm->ctrlReq) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
@@ -218,9 +229,10 @@ int32_t CheckRawSdkIfAllocRequest005(void)
 
 int32_t CheckRawSdkIfAllocRequest006(void)
 {
-    g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE);
-    ((struct UsbHostRequest *)(g_acm->ctrlReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
-    if (g_acm->ctrlReq == NULL) {
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    rawAcm->ctrlReq = UsbRawAllocRequest(rawAcm->devHandle, 0, USB_CTRL_REQ_SIZE);
+    ((struct UsbHostRequest *)(rawAcm->ctrlReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
+    if (rawAcm->ctrlReq == NULL) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
@@ -230,8 +242,9 @@ int32_t CheckRawSdkIfAllocRequest006(void)
 
 int32_t CheckRawSdkIfAllocRequest007(void)
 {
-    g_acm->notifyReq = UsbRawAllocRequest(NULL, 0, g_acm->notifyEp.maxPacketSize);
-    if (g_acm->notifyReq) {
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    rawAcm->notifyReq = UsbRawAllocRequest(NULL, 0, rawAcm->notifyEp.maxPacketSize);
+    if (rawAcm->notifyReq) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
@@ -241,9 +254,10 @@ int32_t CheckRawSdkIfAllocRequest007(void)
 
 int32_t CheckRawSdkIfAllocRequest008(void)
 {
-    g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp.maxPacketSize);
-    ((struct UsbHostRequest *)(g_acm->notifyReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
-    if (g_acm->notifyReq == NULL) {
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    rawAcm->notifyReq = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->notifyEp.maxPacketSize);
+    ((struct UsbHostRequest *)(rawAcm->notifyReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
+    if (rawAcm->notifyReq == NULL) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
@@ -252,23 +266,25 @@ int32_t CheckRawSdkIfAllocRequest008(void)
 }
 int32_t CheckRawSdkIfAllocRequest010(void)
 {
-    g_acm->isoReq = UsbRawAllocRequest(NULL, USB_ISO_PACKAT_CNT, g_acm->isoEp.maxPacketSize);
-    if (g_acm->isoReq == NULL) {
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    rawAcm->isoReq = UsbRawAllocRequest(NULL, USB_ISO_PACKAT_CNT, rawAcm->isoEp.maxPacketSize);
+    if (rawAcm->isoReq == NULL) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
-    ((struct UsbHostRequest *)(g_acm->isoReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
+    ((struct UsbHostRequest *)(rawAcm->isoReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
 }
 int32_t CheckRawSdkIfAllocRequest011(void)
 {
-    g_acm->isoReq = UsbRawAllocRequest(g_acm->devHandle, USB_ISO_PACKAT_CNT, g_acm->isoEp.maxPacketSize);
-    if (g_acm->isoReq == NULL) {
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    rawAcm->isoReq = UsbRawAllocRequest(rawAcm->devHandle, USB_ISO_PACKAT_CNT, rawAcm->isoEp.maxPacketSize);
+    if (rawAcm->isoReq == NULL) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
-    ((struct UsbHostRequest *)(g_acm->isoReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
+    ((struct UsbHostRequest *)(rawAcm->isoReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
 }
@@ -276,13 +292,14 @@ int32_t CheckRawSdkIfAllocRequest011(void)
 int32_t CheckRawSdkIfFreeRequest006(void)
 {
     int32_t ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawFreeRequest(g_acm->isoReq);
+    ret = UsbRawFreeRequest(rawAcm->isoReq);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
-    g_acm->isoReq = NULL;
+    rawAcm->isoReq = NULL;
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
 }
@@ -294,17 +311,18 @@ int32_t CheckRawSdkIfFillIsoRequest001(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
-    size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size;
+    size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->isoEp.addr;
+        reqData.endPoint      = rawAcm->isoEp.addr;
         reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
         reqData.callback      = AcmWriteIsoCallback;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
         reqData.buffer        = (unsigned char*)sendData;
         reqData.length        = size;
-        ret = UsbRawFillIsoRequest(g_acm->isoReq, g_acm->devHandle, &reqData);
+        ret = UsbRawFillIsoRequest(rawAcm->isoReq, rawAcm->devHandle, &reqData);
         if (ret) {
             printf("%s: error++ret=%d\n", __func__, ret);
             return HDF_FAILURE;
@@ -321,17 +339,18 @@ int32_t CheckRawSdkIfFillIsoRequest002(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
-    size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size;
+    size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->isoEp.addr;
+        reqData.endPoint      = rawAcm->isoEp.addr;
         reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
         reqData.callback      = AcmWriteIsoCallback;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
         reqData.buffer        = (unsigned char*)sendData;
         reqData.length        = size;
-        ret = UsbRawFillIsoRequest(NULL, g_acm->devHandle, &reqData);
+        ret = UsbRawFillIsoRequest(NULL, rawAcm->devHandle, &reqData);
         if (ret) {
             printf("%s: error++ret=%d\n", __func__, ret);
             return HDF_FAILURE;
@@ -348,17 +367,18 @@ int32_t CheckRawSdkIfFillIsoRequest003(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
-    size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size;
+    size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->isoEp.addr;
+        reqData.endPoint      = rawAcm->isoEp.addr;
         reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
         reqData.callback      = AcmWriteIsoCallback;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
         reqData.buffer        = (unsigned char*)sendData;
         reqData.length        = size;
-        ret = UsbRawFillIsoRequest(g_acm->isoReq, g_acm->devHandle, NULL);
+        ret = UsbRawFillIsoRequest(rawAcm->isoReq, rawAcm->devHandle, NULL);
         if (ret) {
             printf("%s: error++ret=%d\n", __func__, ret);
             return HDF_FAILURE;
@@ -375,17 +395,18 @@ int32_t CheckRawSdkIfFillIsoRequest004(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
-    size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size;
+    size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->isoEp.addr;
+        reqData.endPoint      = rawAcm->isoEp.addr;
         reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
         reqData.callback      = AcmWriteIsoCallback;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
         reqData.buffer        = (unsigned char*)sendData;
         reqData.length        = size;
-        ret = UsbRawFillIsoRequest(g_acm->isoReq, NULL, &reqData);
+        ret = UsbRawFillIsoRequest(rawAcm->isoReq, NULL, &reqData);
         if (ret) {
             printf("%s: error++ret=%d\n", __func__, ret);
             return HDF_FAILURE;
@@ -402,11 +423,12 @@ int32_t CheckRawSdkIfFillIsoRequest005(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
-    size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size;
+    size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->isoEp.addr;
+        reqData.endPoint      = rawAcm->isoEp.addr;
         reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
         reqData.callback      = AcmWriteIsoCallback;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
@@ -429,11 +451,12 @@ int32_t CheckRawSdkIfFillIsoRequest006(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
-    size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size;
+    size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->isoEp.addr;
+        reqData.endPoint      = rawAcm->isoEp.addr;
         reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
         reqData.callback      = AcmWriteIsoCallback;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
@@ -452,16 +475,17 @@ int32_t CheckRawSdkIfFreeRequest001(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NW; i++) {
-        ret = UsbRawFreeRequest(g_acm->wb[i].request);
+        ret = UsbRawFreeRequest(rawAcm->wb[i].request);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
-        g_acm->wb[i].request = NULL;
+        rawAcm->wb[i].request = NULL;
     }
-    AcmWriteBufFree(g_acm);
+    AcmWriteBufFree(rawAcm);
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
 }
@@ -470,14 +494,15 @@ int32_t CheckRawSdkIfFreeRequest002(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NW; i++) {
-        ret = UsbRawFreeRequest(g_acm->readReq[i]);
+        ret = UsbRawFreeRequest(rawAcm->readReq[i]);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
-        g_acm->readReq[i] = NULL;
+        rawAcm->readReq[i] = NULL;
     }
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
@@ -486,13 +511,14 @@ int32_t CheckRawSdkIfFreeRequest002(void)
 int32_t CheckRawSdkIfFreeRequest003(void)
 {
     int32_t ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawFreeRequest(g_acm->ctrlReq);
+    ret = UsbRawFreeRequest(rawAcm->ctrlReq);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
-    g_acm->ctrlReq = NULL;
+    rawAcm->ctrlReq = NULL;
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
 }
@@ -500,13 +526,14 @@ int32_t CheckRawSdkIfFreeRequest003(void)
 int32_t CheckRawSdkIfFreeRequest004(void)
 {
     int32_t ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawFreeRequest(g_acm->notifyReq);
+    ret = UsbRawFreeRequest(rawAcm->notifyReq);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
-    g_acm->notifyReq = NULL;
+    rawAcm->notifyReq = NULL;
     HDF_LOGE("%s: success", __func__);
     return HDF_SUCCESS;
 }
@@ -528,38 +555,39 @@ int32_t CheckRawSdkIfAllocRequest009(void)
 {
     int i;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = AcmWriteBufAlloc(g_acm);
+    ret = AcmWriteBufAlloc(rawAcm);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
 
     for (i = 0; i < ACM_NW; i++) {
-        g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp.maxPacketSize);
-        g_acm->wb[i].instance = g_acm;
-        if (g_acm->wb[i].request == NULL) {
+        rawAcm->wb[i].request = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataOutEp.maxPacketSize);
+        rawAcm->wb[i].instance = rawAcm;
+        if (rawAcm->wb[i].request == NULL) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
     }
 
     for (i = 0; i < ACM_NR; i++) {
-        g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp.maxPacketSize);
-        if (g_acm->readReq[i] == NULL) {
+        rawAcm->readReq[i] = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataInEp.maxPacketSize);
+        if (rawAcm->readReq[i] == NULL) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
         }
     }
 
-    g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE);
-    if (g_acm->ctrlReq == NULL) {
+    rawAcm->ctrlReq = UsbRawAllocRequest(rawAcm->devHandle, 0, USB_CTRL_REQ_SIZE);
+    if (rawAcm->ctrlReq == NULL) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
 
-    g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp.maxPacketSize);
-    if (g_acm->notifyReq == NULL) {
+    rawAcm->notifyReq = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->notifyEp.maxPacketSize);
+    if (rawAcm->notifyReq == NULL) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
     }
@@ -572,6 +600,7 @@ int32_t CheckRawSdkIfGetDescriptor001(void)
     struct UsbRawDescriptorParam param;
     unsigned char *data = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
     if (data == NULL) {
@@ -579,7 +608,7 @@ int32_t CheckRawSdkIfGetDescriptor001(void)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, &param, data);
+    ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, &param, data);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         ret = HDF_FAILURE;
@@ -599,6 +628,7 @@ int32_t CheckRawSdkIfGetDescriptor002(void)
     struct UsbRawDescriptorParam param;
     unsigned char *data = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
     if (data == NULL) {
@@ -606,7 +636,7 @@ int32_t CheckRawSdkIfGetDescriptor002(void)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, &param, data);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, &param, data);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         ret = HDF_FAILURE;
@@ -652,6 +682,7 @@ int32_t CheckRawSdkIfGetDescriptor004(void)
 {
     unsigned char *data = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
     if (data == NULL) {
@@ -659,7 +690,7 @@ int32_t CheckRawSdkIfGetDescriptor004(void)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, data);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, NULL, data);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         ret = HDF_FAILURE;
@@ -678,8 +709,9 @@ int32_t CheckRawSdkIfGetDescriptor005(void)
 {
     struct UsbRawDescriptorParam param;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, &param, NULL);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, &param, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -693,6 +725,7 @@ int32_t CheckRawSdkIfGetDescriptor006(void)
     struct UsbRawDescriptorParam param;
     unsigned char *data = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
     if (data == NULL) {
@@ -704,7 +737,7 @@ int32_t CheckRawSdkIfGetDescriptor006(void)
     param.descIndex = 0;
     param.length = USB_BUFFER_MAX_SIZE;
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, &param, data);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, &param, data);
     if (ret < 0) {
         HDF_LOGE("%s: error", __func__);
         ret = HDF_FAILURE;
@@ -723,6 +756,7 @@ int32_t CheckRawSdkIfGetDescriptor007(void)
 {
     unsigned char *data = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
     if (data == NULL) {
@@ -730,7 +764,7 @@ int32_t CheckRawSdkIfGetDescriptor007(void)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, data);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, NULL, data);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         ret = HDF_FAILURE;
@@ -748,8 +782,9 @@ error:
 int32_t CheckRawSdkIfGetDescriptor008(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, NULL);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, NULL, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -762,6 +797,7 @@ int32_t CheckRawSdkIfGetDescriptor009(void)
 {
     unsigned char *data = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
     if (data == NULL) {
@@ -769,7 +805,7 @@ int32_t CheckRawSdkIfGetDescriptor009(void)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, data);
+    ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, NULL, data);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         ret = HDF_FAILURE;
@@ -789,12 +825,13 @@ int32_t CheckRawSdkIfGetDescriptor010(void)
     struct UsbRawDescriptorParam param;
     unsigned char data[100];
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     param.descType = 0;
     param.descIndex = 0;
     param.length = sizeof(data);
 
-    ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, &param, NULL);
+    ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, &param, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -808,12 +845,13 @@ int32_t CheckRawSdkIfGetDescriptor011(void)
     struct UsbRawDescriptorParam param;
     unsigned char data[100];
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     param.descType = 0;
     param.descIndex = 0;
     param.length = sizeof(data);
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, &param, NULL);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, &param, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -870,8 +908,9 @@ int32_t CheckRawSdkIfGetDescriptor013(void)
 int32_t CheckRawSdkIfGetDescriptor014(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, NULL);
+    ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, NULL, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -883,8 +922,9 @@ int32_t CheckRawSdkIfGetDescriptor014(void)
 int32_t CheckRawSdkIfGetDescriptor015(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, NULL);
+    ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, NULL, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -913,29 +953,30 @@ int32_t CheckRawSdkIfFillBulkRequest001(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     size = strlen(sendData) + 1;
     printf("---size:%d\n", size);
 
-    size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size;
+    size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size;
     for (i = 0; i < 1; i++) {
-        struct RawWb *snd = &g_acm->wb[i];
+        struct RawWb *snd = &rawAcm->wb[i];
         snd->len = size;
-        ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size);
+        ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size);
         if (ret) {
             printf("memcpy_s fial");
         }
-        g_acm->transmitting++;
+        rawAcm->transmitting++;
 
-        reqData.endPoint      = g_acm->dataOutEp.addr;
+        reqData.endPoint      = rawAcm->dataOutEp.addr;
         reqData.numIsoPackets = 0;
         reqData.callback      = AcmWriteBulkCallback;
         reqData.userData      = (void *)snd;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
         reqData.buffer        = snd->buf;
         reqData.length        = snd->len;
-        printf("maxPacketSize:%d+snd->request:%p\n", g_acm->dataOutEp.maxPacketSize, snd->request);
-        ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData);
+        printf("maxPacketSize:%d+snd->request:%p\n", rawAcm->dataOutEp.maxPacketSize, snd->request);
+        ret = UsbRawFillBulkRequest(snd->request, rawAcm->devHandle, &reqData);
         if (ret) {
             printf("%s: error++ret=%d\n", __func__, ret);
             return HDF_FAILURE;
@@ -950,17 +991,18 @@ int32_t CheckRawSdkIfFillBulkRequest002(void)
     struct UsbRawFillRequestData reqData;
     int32_t ret;
     int i;
-    int size = g_acm->dataInEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->dataInEp.maxPacketSize;
 
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->dataInEp.addr;
+        reqData.endPoint      = rawAcm->dataInEp.addr;
         reqData.numIsoPackets = 0;
         reqData.callback      = AcmReadBulkCallback;
-        reqData.userData      = (void *)g_acm;
+        reqData.userData      = (void *)rawAcm;
         reqData.timeout       = USB_CTRL_SET_TIMEOUT;
         reqData.length        = size;
 
-        ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
+        ret = UsbRawFillBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -974,16 +1016,17 @@ int32_t CheckRawSdkIfFillInterruptRequest001(void)
 {
     struct UsbRawFillRequestData fillRequestData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    fillRequestData.endPoint = g_acm->notifyEp.addr;
+    fillRequestData.endPoint = rawAcm->notifyEp.addr;
     fillRequestData.length = size;
     fillRequestData.numIsoPackets = 0;
     fillRequestData.callback = AcmNotifyReqCallback;
-    fillRequestData.userData = (void *)g_acm;
+    fillRequestData.userData = (void *)rawAcm;
     fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
 
-    ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData);
+    ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &fillRequestData);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -996,16 +1039,17 @@ int32_t CheckRawSdkIfFillInterruptRequest002(void)
 {
     struct UsbRawFillRequestData fillRequestData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    fillRequestData.endPoint = g_acm->notifyEp.addr;
+    fillRequestData.endPoint = rawAcm->notifyEp.addr;
     fillRequestData.length = size;
     fillRequestData.numIsoPackets = 0;
     fillRequestData.callback = AcmNotifyReqCallback;
-    fillRequestData.userData = (void *)g_acm;
+    fillRequestData.userData = (void *)rawAcm;
     fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
 
-    ret = UsbRawFillInterruptRequest(NULL, g_acm->devHandle, &fillRequestData);
+    ret = UsbRawFillInterruptRequest(NULL, rawAcm->devHandle, &fillRequestData);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1018,16 +1062,17 @@ int32_t CheckRawSdkIfFillInterruptRequest003(void)
 {
     struct UsbRawFillRequestData fillRequestData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    fillRequestData.endPoint = g_acm->notifyEp.addr;
+    fillRequestData.endPoint = rawAcm->notifyEp.addr;
     fillRequestData.length = size;
     fillRequestData.numIsoPackets = 0;
     fillRequestData.callback = AcmNotifyReqCallback;
-    fillRequestData.userData = (void *)g_acm;
+    fillRequestData.userData = (void *)rawAcm;
     fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
 
-    ret = UsbRawFillInterruptRequest(g_acm->notifyReq, NULL, &fillRequestData);
+    ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, NULL, &fillRequestData);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1040,16 +1085,17 @@ int32_t CheckRawSdkIfFillInterruptRequest004(void)
 {
     struct UsbRawFillRequestData fillRequestData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    fillRequestData.endPoint = g_acm->notifyEp.addr;
+    fillRequestData.endPoint = rawAcm->notifyEp.addr;
     fillRequestData.length = size;
     fillRequestData.numIsoPackets = 0;
     fillRequestData.callback = AcmNotifyReqCallback;
-    fillRequestData.userData = (void *)g_acm;
+    fillRequestData.userData = (void *)rawAcm;
     fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
 
-    ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL);
+    ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1063,12 +1109,13 @@ int32_t CheckRawSdkIfFillControlRequest001(void)
     struct UsbRawFillRequestData fillRequestData;
     int ret;
     int completed = 0;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     fillRequestData.callback  = AcmCtrlReqCallback;
     fillRequestData.userData  = &completed;
     fillRequestData.timeout   = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, &fillRequestData);
+    ret = UsbRawFillControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, &fillRequestData);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1082,12 +1129,13 @@ int32_t CheckRawSdkIfFillControlRequest002(void)
     struct UsbRawFillRequestData fillRequestData;
     int ret;
     int completed = 0;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     fillRequestData.callback  = AcmCtrlReqCallback;
     fillRequestData.userData  = &completed;
     fillRequestData.timeout   = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, &fillRequestData);
+    ret = UsbRawFillControlRequest(NULL, rawAcm->devHandle, &fillRequestData);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1101,12 +1149,13 @@ int32_t CheckRawSdkIfFillControlRequest003(void)
     struct UsbRawFillRequestData fillRequestData;
     int ret;
     int completed = 0;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     fillRequestData.callback  = AcmCtrlReqCallback;
     fillRequestData.userData  = &completed;
     fillRequestData.timeout   = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, &fillRequestData);
+    ret = UsbRawFillControlRequest(rawAcm->ctrlReq, NULL, &fillRequestData);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1120,12 +1169,13 @@ int32_t CheckRawSdkIfFillControlRequest004(void)
     struct UsbRawFillRequestData fillRequestData;
     int ret;
     int completed = 0;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     fillRequestData.callback  = AcmCtrlReqCallback;
     fillRequestData.userData  = &completed;
     fillRequestData.timeout   = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL);
+    ret = UsbRawFillControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1139,12 +1189,13 @@ int32_t CheckRawSdkIfFillControlRequest005(void)
     struct UsbRawFillRequestData fillRequestData;
     int ret;
     int completed = 0;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     fillRequestData.callback  = AcmCtrlReqCallback;
     fillRequestData.userData  = &completed;
     fillRequestData.timeout   = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, NULL);
+    ret = UsbRawFillControlRequest(NULL, rawAcm->devHandle, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1158,12 +1209,13 @@ int32_t CheckRawSdkIfFillControlRequest006(void)
     struct UsbRawFillRequestData fillRequestData;
     int ret;
     int completed = 0;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     fillRequestData.callback  = AcmCtrlReqCallback;
     fillRequestData.userData  = &completed;
     fillRequestData.timeout   = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, NULL);
+    ret = UsbRawFillControlRequest(rawAcm->ctrlReq, NULL, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1214,17 +1266,18 @@ int32_t CheckRawSdkIfFillControlSetup001(void)
 {
     struct UsbControlRequestData ctrlReq;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
-    g_acm->lineCoding.bCharFormat = CHARFORMAT;
-    g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
+    rawAcm->lineCoding.bCharFormat = CHARFORMAT;
+    rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
+    rawAcm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
 
     ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
     ctrlReq.requestCmd  = USB_DDK_CDC_REQ_SET_LINE_CODING;
     ctrlReq.value       = CpuToLe16(0);
     ctrlReq.index       = 0;
-    ctrlReq.data        = (unsigned char *)&g_acm->lineCoding;
+    ctrlReq.data        = (unsigned char *)&rawAcm->lineCoding;
     ctrlReq.length      = sizeof(struct UsbCdcLineCoding);
     ctrlReq.timeout     = USB_CTRL_SET_TIMEOUT;
 
@@ -1281,17 +1334,18 @@ int32_t CheckRawSdkIfFillControlSetup004(void)
     struct UsbControlRequestData ctrlReq;
     unsigned char *setup = NULL;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
-    g_acm->lineCoding.bCharFormat = CHARFORMAT;
-    g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
+    rawAcm->lineCoding.bCharFormat = CHARFORMAT;
+    rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
+    rawAcm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
 
     ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
     ctrlReq.requestCmd  = USB_DDK_CDC_REQ_SET_LINE_CODING;
     ctrlReq.value       = CpuToLe16(0);
     ctrlReq.index       = 0;
-    ctrlReq.data        = (unsigned char *)&g_acm->lineCoding;
+    ctrlReq.data        = (unsigned char *)&rawAcm->lineCoding;
     ctrlReq.length      = sizeof(struct UsbCdcLineCoding);
     ctrlReq.timeout     = USB_CTRL_SET_TIMEOUT;
 
@@ -1320,20 +1374,21 @@ int32_t CheckRawSdkIfSendControlRequest001(void)
 {
     struct UsbControlRequestData ctrlReq;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
-    g_acm->lineCoding.bCharFormat = CHARFORMAT;
-    g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
+    rawAcm->lineCoding.bCharFormat = CHARFORMAT;
+    rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
+    rawAcm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
     ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
     ctrlReq.requestCmd  = USB_DDK_CDC_REQ_SET_LINE_CODING;
     ctrlReq.value       = CpuToLe16(0);
     ctrlReq.index       = 0;
-    ctrlReq.data        = (unsigned char *)&g_acm->lineCoding;
+    ctrlReq.data        = (unsigned char *)&rawAcm->lineCoding;
     ctrlReq.length      = sizeof(struct UsbCdcLineCoding);
     ctrlReq.timeout     = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, &ctrlReq);
+    ret = UsbRawSendControlRequest(NULL, rawAcm->devHandle, &ctrlReq);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1346,20 +1401,21 @@ int32_t CheckRawSdkIfSendControlRequest002(void)
 {
     struct UsbControlRequestData ctrlReq;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
-    g_acm->lineCoding.bCharFormat = CHARFORMAT;
-    g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
+    rawAcm->lineCoding.bCharFormat = CHARFORMAT;
+    rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
+    rawAcm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
     ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
     ctrlReq.requestCmd  = USB_DDK_CDC_REQ_SET_LINE_CODING;
     ctrlReq.value       = CpuToLe16(0);
     ctrlReq.index       = 0;
-    ctrlReq.data        = (unsigned char *)&g_acm->lineCoding;
+    ctrlReq.data        = (unsigned char *)&rawAcm->lineCoding;
     ctrlReq.length      = sizeof(struct UsbCdcLineCoding);
     ctrlReq.timeout     = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, &ctrlReq);
+    ret = UsbRawSendControlRequest(rawAcm->ctrlReq, NULL, &ctrlReq);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1371,7 +1427,8 @@ int32_t CheckRawSdkIfSendControlRequest002(void)
 int32_t CheckRawSdkIfSendControlRequest003(void)
 {
     int ret;
-    ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL);
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    ret = UsbRawSendControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1384,20 +1441,21 @@ int32_t CheckRawSdkIfSendControlRequest004(void)
 {
     struct UsbControlRequestData ctrlReq;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
-    g_acm->lineCoding.bCharFormat = CHARFORMAT;
-    g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
+    rawAcm->lineCoding.bCharFormat = CHARFORMAT;
+    rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
+    rawAcm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
     ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
     ctrlReq.requestCmd  = USB_DDK_CDC_REQ_SET_LINE_CODING;
     ctrlReq.value       = CpuToLe16(0);
     ctrlReq.index       = 2;
-    ctrlReq.data        = (unsigned char *)&g_acm->lineCoding;
+    ctrlReq.data        = (unsigned char *)&rawAcm->lineCoding;
     ctrlReq.length      = sizeof(struct UsbCdcLineCoding);
     ctrlReq.timeout     = USB_CTRL_SET_TIMEOUT;
 
-    ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, &ctrlReq);
+    ret = UsbRawSendControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, &ctrlReq);
     if (ret < 0) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1410,16 +1468,17 @@ int32_t CheckRawSdkIfSendControlRequest005(void)
 {
     struct UsbControlRequestData ctrlReq;
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
-    g_acm->lineCoding.bCharFormat = CHARFORMAT;
-    g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
+    rawAcm->lineCoding.bCharFormat = CHARFORMAT;
+    rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
+    rawAcm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
     ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
     ctrlReq.requestCmd  = USB_DDK_CDC_REQ_SET_LINE_CODING;
     ctrlReq.value       = CpuToLe16(0);
     ctrlReq.index       = 0;
-    ctrlReq.data        = (unsigned char *)&g_acm->lineCoding;
+    ctrlReq.data        = (unsigned char *)&rawAcm->lineCoding;
     ctrlReq.length      = sizeof(struct UsbCdcLineCoding);
     ctrlReq.timeout     = USB_CTRL_SET_TIMEOUT;
 
@@ -1435,8 +1494,9 @@ int32_t CheckRawSdkIfSendControlRequest005(void)
 int32_t CheckRawSdkIfSendControlRequest006(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, NULL);
+    ret = UsbRawSendControlRequest(NULL, rawAcm->devHandle, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1448,8 +1508,9 @@ int32_t CheckRawSdkIfSendControlRequest006(void)
 int32_t CheckRawSdkIfSendControlRequest007(void)
 {
     int ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, NULL);
+    ret = UsbRawSendControlRequest(rawAcm->ctrlReq, NULL, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1465,20 +1526,21 @@ int32_t CheckRawSdkIfSendBulkRequest001(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcd\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     size = strlen(sendData) + 1;
-    size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size;
+    size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size;
 
     for (i = 0; i < 1; i++) {
-        struct RawWb *snd = &g_acm->wb[i];
+        struct RawWb *snd = &rawAcm->wb[i];
         snd->len = size;
-        ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size);
+        ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size);
         if (ret) {
             printf("memcpy_s fial");
         }
-        g_acm->transmitting++;
+        rawAcm->transmitting++;
 
-        reqData.endPoint      = g_acm->dataOutEp.addr;
+        reqData.endPoint      = rawAcm->dataOutEp.addr;
         reqData.timeout       = USB_RAW_REQUEST_TIME_ZERO_MS;
         reqData.data        = snd->buf;
         reqData.length        = snd->len;
@@ -1486,9 +1548,9 @@ int32_t CheckRawSdkIfSendBulkRequest001(void)
     }
 
     for (i = 0; i < 1; i++) {
-        struct RawWb *snd = &g_acm->wb[i];
+        struct RawWb *snd = &rawAcm->wb[i];
         printf("UsbRawSendBulkRequest i = [%d]\n", i);
-        ret = UsbRawSendBulkRequest(snd->request, g_acm->devHandle, &reqData);
+        ret = UsbRawSendBulkRequest(snd->request, rawAcm->devHandle, &reqData);
         if (ret) {
             printf("%s: error+ret:%d", __func__, ret);
             return HDF_FAILURE;
@@ -1503,19 +1565,20 @@ int32_t CheckRawSdkIfSendBulkRequest002(void)
     struct UsbRequestData reqData;
     int32_t ret;
     int i;
-    int size = g_acm->dataInEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->dataInEp.maxPacketSize;
 
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->dataInEp.addr;
+        reqData.endPoint      = rawAcm->dataInEp.addr;
         reqData.timeout       = USB_RAW_REQUEST_TIME_ZERO_MS;
         reqData.length        = size;
-        reqData.data        = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer;
+        reqData.data        = ((struct UsbRawRequest *)rawAcm->readReq[i])->buffer;
         reqData.requested      = (int *)&size;
     }
 
     for (i = 0; i < 1; i++) {
         printf("UsbRawSendBulkRequest i = [%d]\n", i);
-        ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
+        ret = UsbRawSendBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1530,19 +1593,20 @@ int32_t CheckRawSdkIfSendBulkRequest003(void)
     struct UsbRequestData reqData;
     int32_t ret;
     int i;
-    int size = g_acm->dataInEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->dataInEp.maxPacketSize;
 
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->dataInEp.addr;
+        reqData.endPoint      = rawAcm->dataInEp.addr;
         reqData.timeout       = USB_RAW_REQUEST_TIME_ZERO_MS;
         reqData.length        = size;
-        reqData.data        = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer;
+        reqData.data        = ((struct UsbRawRequest *)rawAcm->readReq[i])->buffer;
         reqData.requested      = (int *)&size;
     }
 
     for (i = 0; i < 1; i++) {
         printf("UsbRawSendBulkRequest i = [%d]\n", i);
-        ret = UsbRawSendBulkRequest(NULL, g_acm->devHandle, &reqData);
+        ret = UsbRawSendBulkRequest(NULL, rawAcm->devHandle, &reqData);
         if (ret != HDF_ERR_INVALID_PARAM) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1557,18 +1621,19 @@ int32_t CheckRawSdkIfSendBulkRequest004(void)
     struct UsbRequestData reqData;
     int32_t ret;
     int i;
-    int size = g_acm->dataInEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->dataInEp.maxPacketSize;
 
     for (i = 0; i < 1; i++) {
-        reqData.endPoint      = g_acm->dataInEp.addr;
+        reqData.endPoint      = rawAcm->dataInEp.addr;
         reqData.timeout       = USB_RAW_REQUEST_TIME_ZERO_MS;
         reqData.length        = size;
-        reqData.data        = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer;
+        reqData.data        = ((struct UsbRawRequest *)rawAcm->readReq[i])->buffer;
         reqData.requested      = (int *)&size;
     }
     for (i = 0; i < 1; i++) {
         printf("UsbRawSendBulkRequest i = [%d]\n", i);
-        ret = UsbRawSendBulkRequest(g_acm->readReq[i], NULL, &reqData);
+        ret = UsbRawSendBulkRequest(rawAcm->readReq[i], NULL, &reqData);
         if (ret != HDF_ERR_INVALID_PARAM) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1582,10 +1647,11 @@ int32_t CheckRawSdkIfSendBulkRequest005(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < 1; i++) {
         printf("UsbRawSendBulkRequest i = [%d]\n", i);
-        ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, NULL);
+        ret = UsbRawSendBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, NULL);
         if (ret != HDF_ERR_INVALID_PARAM) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1599,14 +1665,15 @@ int32_t CheckRawSdkIfSendInterruptRequest001(void)
 {
     struct UsbRequestData reqData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    reqData.endPoint = g_acm->notifyEp.addr;
+    reqData.endPoint = rawAcm->notifyEp.addr;
     reqData.length = size;
     reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
-    reqData.data        = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer;
+    reqData.data        = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer;
     reqData.requested      = (int *)&size;
-    ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &reqData);
+    ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &reqData);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1619,15 +1686,16 @@ int32_t CheckRawSdkIfSendInterruptRequest002(void)
 {
     struct UsbRequestData reqData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    reqData.endPoint = g_acm->notifyEp.addr;
+    reqData.endPoint = rawAcm->notifyEp.addr;
     reqData.length = size;
     reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
-    reqData.data        = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer;
+    reqData.data        = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer;
     reqData.requested      = (int *)&size;
 
-    ret = UsbRawSendInterruptRequest(NULL, g_acm->devHandle, &reqData);
+    ret = UsbRawSendInterruptRequest(NULL, rawAcm->devHandle, &reqData);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1640,15 +1708,16 @@ int32_t CheckRawSdkIfSendInterruptRequest003(void)
 {
     struct UsbRequestData reqData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
 
-    reqData.endPoint = g_acm->notifyEp.addr;
+    reqData.endPoint = rawAcm->notifyEp.addr;
     reqData.length = size;
     reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
-    reqData.data        = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer;
+    reqData.data        = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer;
     reqData.requested      = (int *)&size;
 
-    ret = UsbRawSendInterruptRequest(g_acm->notifyReq, NULL, &reqData);
+    ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, NULL, &reqData);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1660,8 +1729,9 @@ int32_t CheckRawSdkIfSendInterruptRequest003(void)
 int32_t CheckRawSdkIfSendInterruptRequest004(void)
 {
     int32_t ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL);
+    ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, NULL);
     if (ret != HDF_ERR_INVALID_PARAM) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1677,19 +1747,20 @@ int32_t CheckRawSdkIfFillBulkRequest003(void)
     int i;
     uint32_t size;
     char sendData[] = {"abcde\0"};
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
     size = strlen(sendData) + 1;
-    size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size;
+    size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size;
 
     for (i = 0; i < ACM_NW; i++) {
-        struct RawWb *snd = &g_acm->wb[i];
+        struct RawWb *snd = &rawAcm->wb[i];
         snd->len = size;
-        ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size);
+        ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size);
         if (ret) {
             printf("memcpy_s fial");
         }
-        g_acm->transmitting++;
+        rawAcm->transmitting++;
 
-        reqData.endPoint      = g_acm->dataOutEp.addr;
+        reqData.endPoint      = rawAcm->dataOutEp.addr;
         reqData.numIsoPackets = 0;
         reqData.callback      = AcmWriteBulkCallback;
         reqData.userData      = (void *)snd;
@@ -1697,7 +1768,7 @@ int32_t CheckRawSdkIfFillBulkRequest003(void)
         reqData.buffer        = snd->buf;
         reqData.length        = snd->len;
 
-        ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData);
+        ret = UsbRawFillBulkRequest(snd->request, rawAcm->devHandle, &reqData);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1712,16 +1783,17 @@ int32_t CheckRawSdkIfFillBulkRequest004(void)
     struct UsbRawFillRequestData reqData;
     int32_t ret;
     int i;
-    int size = g_acm->dataInEp.maxPacketSize;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->dataInEp.maxPacketSize;
 
     for (i = 0; i < ACM_NW; i++) {
-        reqData.endPoint      = g_acm->dataInEp.addr;
+        reqData.endPoint      = rawAcm->dataInEp.addr;
         reqData.numIsoPackets = 0;
         reqData.callback      = AcmReadBulkCallback;
-        reqData.userData      = (void *)g_acm;
+        reqData.userData      = (void *)rawAcm;
         reqData.timeout       = USB_RAW_REQUEST_TIME_ZERO_MS;
         reqData.length        = size;
-        ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
+        ret = UsbRawFillBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1735,14 +1807,15 @@ int32_t CheckRawSdkIfFillInterruptRequest005(void)
 {
     struct UsbRawFillRequestData fillRequestData;
     int32_t ret;
-    int size = g_acm->notifyEp.maxPacketSize;
-    fillRequestData.endPoint = g_acm->notifyEp.addr;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
+    int size = rawAcm->notifyEp.maxPacketSize;
+    fillRequestData.endPoint = rawAcm->notifyEp.addr;
     fillRequestData.length = size;
     fillRequestData.numIsoPackets = 0;
     fillRequestData.callback = AcmNotifyReqCallback;
-    fillRequestData.userData = (void *)g_acm;
+    fillRequestData.userData = (void *)rawAcm;
     fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
-    ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData);
+    ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &fillRequestData);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1755,9 +1828,10 @@ int32_t CheckRawSdkIfSubmitRequest001(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NW; i++) {
-        struct RawWb *snd = &g_acm->wb[i];
+        struct RawWb *snd = &rawAcm->wb[i];
         printf("UsbRawSubmitRequest i = [%d]\n", i);
         ret = UsbRawSubmitRequest(snd->request);
         if (ret) {
@@ -1773,10 +1847,11 @@ int32_t CheckRawSdkIfSubmitRequest002(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NW; i++) {
         printf("UsbRawSubmitRequest i = [%d]\n", i);
-        ret = UsbRawSubmitRequest(g_acm->readReq[i]);
+        ret = UsbRawSubmitRequest(rawAcm->readReq[i]);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
             return HDF_FAILURE;
@@ -1789,8 +1864,9 @@ int32_t CheckRawSdkIfSubmitRequest002(void)
 int32_t CheckRawSdkIfSubmitRequest003(void)
 {
     int32_t ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawSubmitRequest(g_acm->notifyReq);
+    ret = UsbRawSubmitRequest(rawAcm->notifyReq);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
@@ -1816,9 +1892,10 @@ int32_t CheckRawSdkIfCancelRequest001(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NW; i++) {
-        struct RawWb *snd = &g_acm->wb[i];
+        struct RawWb *snd = &rawAcm->wb[i];
         ret = UsbRawCancelRequest(snd->request);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
@@ -1833,9 +1910,10 @@ int32_t CheckRawSdkIfCancelRequest002(void)
 {
     int32_t ret;
     int i;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
     for (i = 0; i < ACM_NR; i++) {
-        ret = UsbRawCancelRequest(g_acm->readReq[i]);
+        ret = UsbRawCancelRequest(rawAcm->readReq[i]);
         printf("%s+%d+ret:%d\n", __func__, __LINE__, ret);
         if (ret) {
             HDF_LOGE("%s: error", __func__);
@@ -1849,8 +1927,9 @@ int32_t CheckRawSdkIfCancelRequest002(void)
 int32_t CheckRawSdkIfCancelRequest003(void)
 {
     int32_t ret;
+    struct AcmRawDevice *rawAcm = UsbGetIoAcm();
 
-    ret = UsbRawCancelRequest(g_acm->notifyReq);
+    ret = UsbRawCancelRequest(rawAcm->notifyReq);
     if (ret) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;