!19330 fix：Refresh USB Community Driver Document

Merge pull request !19330 from 王易朋/master

zh-cn/device-dev/driver/driver-peripherals-usb-des.md

@@ -84,69 +84,69 @@ USB主机端驱动程序开发相关接口（普通模式）如下，具体接
 
   **表1** USB主机端驱动程序开发相关接口（普通模式）
 
-| 接口名称 | 功能描述 | 
+| 接口名称 | 功能描述 |
 | -------- | -------- |
-| int32_t UsbInitHostSdk(struct UsbSession \*\*session); | USB主机端驱动开发工具包初始化 | 
-| const&nbsp;struct&nbsp;UsbInterface&nbsp;\*UsbClaimInterface(const<br/>struct&nbsp;UsbSession&nbsp;\*session,&nbsp;uint8_t&nbsp;busNum,&nbsp;uint8_t<br/>usbAddr,&nbsp;uint8_t&nbsp;interfaceIndex); | 获取USB接口对象 | 
-| UsbInterfaceHandle&nbsp;\*UsbOpenInterface(const&nbsp;struct<br/>UsbInterface&nbsp;\*interfaceObj); | 打开USB对象接口 | 
-| int32_t&nbsp;UsbGetPipeInfo(const&nbsp;UsbInterfaceHandle<br/>\*interfaceHandle,&nbsp;uint8_t&nbsp;settingIndex,&nbsp;uint8_t&nbsp;pipeId,<br/>struct&nbsp;UsbPipeInfo&nbsp;\*pipeInfo); | 获取指定可选设置的管道信息 | 
-| struct&nbsp;UsbRequest&nbsp;\*UsbAllocRequest(const<br/>UsbInterfaceHandle&nbsp;\*interfaceHandle,&nbsp;int32_t&nbsp;isoPackets<br/>,&nbsp;int32_t&nbsp;length); | 分配请求对象 | 
-| int32_t&nbsp;UsbFillRequest(const&nbsp;struct&nbsp;UsbRequest<br/>\*request,&nbsp;const&nbsp;UsbInterfaceHandle&nbsp;\*interfaceHandle,<br/>const&nbsp;struct&nbsp;UsbRequestParams&nbsp;\*params); | 填充请求 | 
-| int32_t&nbsp;UsbSubmitRequestSync(const&nbsp;struct&nbsp;UsbRequest<br/>\*request); | 发送同步请求 | 
+| int32_t&nbsp;UsbInitHostSdk(struct&nbsp;UsbSession&nbsp;\*\*session); | USB主机端驱动开发工具包初始化 |
+| struct UsbInterface *UsbClaimInterface(const struct<br/> UsbSession *session, uint8_t busNum, uint8_t usbAddr, <br/>uint8_t interfaceIndex) | 获取USB接口对象 |
+| UsbInterfaceHandle&nbsp;\*UsbOpenInterface(const&nbsp;struct<br/>UsbInterface&nbsp;\*interfaceObj); | 打开USB对象接口 |
+| int32_t&nbsp;UsbGetPipeInfo(const&nbsp;UsbInterfaceHandle<br/>\*interfaceHandle,&nbsp;uint8_t&nbsp;settingIndex,&nbsp;uint8_t&nbsp;pipeId,<br/>struct&nbsp;UsbPipeInfo&nbsp;\*pipeInfo); | 获取指定可选设置的管道信息 |
+| struct&nbsp;UsbRequest&nbsp;\*UsbAllocRequest(const<br/>UsbInterfaceHandle&nbsp;\*interfaceHandle,&nbsp;int32_t&nbsp;isoPackets<br/>,&nbsp;int32_t&nbsp;length); | 分配请求对象 |
+| int32_t&nbsp;UsbFillRequest(const&nbsp;struct&nbsp;UsbRequest<br/>\*request,&nbsp;const&nbsp;UsbInterfaceHandle&nbsp;\*interfaceHandle,<br/>const&nbsp;struct&nbsp;UsbRequestParams&nbsp;\*params); | 填充请求 |
+| int32_t&nbsp;UsbSubmitRequestSync(const&nbsp;struct&nbsp;UsbRequest<br/>\*request); | 发送同步请求 |
 
 USB主机端驱动程序开发相关接口（专家模式）如下，具体接口定义[见源码](https://gitee.com/openharmony/drivers_peripheral/blob/master/usb/interfaces/ddk/host/usb_raw_api.h)。
 
   **表2** USB主机端驱动程序开发相关接口（专家模式）
 
-| 接口名称 | 功能描述 | 
+| 接口名称 | 功能描述 |
 | -------- | -------- |
-| int32_t&nbsp;UsbRawInit(struct&nbsp;UsbSession&nbsp;\*\*session); | USB驱动开发工具包专家模式初始化 | 
-| UsbRawHandle&nbsp;\*UsbRawOpenDevice(const&nbsp;struct<br/>UsbSession&nbsp;\*session,&nbsp;uint8_t&nbsp;busNum,&nbsp;uint8_t<br/>usbAddr); | 打开USB设备对象 | 
-| int32_t&nbsp;UsbRawSendControlRequest(const&nbsp;struct<br/>UsbRawRequest&nbsp;\*request,&nbsp;const&nbsp;UsbRawHandle<br/>\*devHandle,&nbsp;const&nbsp;struct&nbsp;UsbControlRequestData<br/>\*requestData); | 执行同步控制传输 | 
-| int32_t&nbsp;UsbRawSendBulkRequest(const&nbsp;struct<br/>UsbRawRequest&nbsp;\*request,&nbsp;const&nbsp;UsbRawHandle<br/>\*devHandle,&nbsp;const&nbsp;struct&nbsp;UsbRequestData<br/>\*requestData); | 执行同步批量传输 | 
-| int32_t&nbsp;UsbRawSendInterruptRequest(const&nbsp;struct<br/>UsbRawRequest&nbsp;\*request,&nbsp;const&nbsp;UsbRawHandle<br/>\*devHandle,&nbsp;const&nbsp;struct&nbsp;UsbRequestData<br/>\*requestData); | 执行同步中断传输 | 
-| int32_t&nbsp;UsbRawGetConfigDescriptor(const&nbsp;UsbRawDevice<br/>\*rawDev,&nbsp;uint8_t&nbsp;configIndex,&nbsp;struct<br/>UsbRawConfigDescriptor&nbsp;\*\*config); | 获取给定设备指定ID的设备配置描述符 | 
-| int32_t&nbsp;UsbRawFillInterruptRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request,&nbsp;const&nbsp;UsbRawHandle&nbsp;\*devHandle,&nbsp;const&nbsp;struct<br/>UsbRawFillRequestData&nbsp;\*fillData); | 填充中断传输请求所需信息 | 
-| int32_t&nbsp;UsbRawFillIsoRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request,&nbsp;const&nbsp;UsbRawHandle&nbsp;\*devHandle,&nbsp;const&nbsp;struct<br/>UsbRawFillRequestData&nbsp;\*fillData); | 填充同步传输（Isochronous&nbsp;Transfers）请求所需信息 | 
-| int32_t&nbsp;UsbRawSubmitRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request); | 提交一个传输请求 | 
-| int32_t&nbsp;UsbRawCancelRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request); | 取消一个传输请求 | 
-| int32_t&nbsp;UsbRawHandleRequests(const&nbsp;UsbRawHandle<br/>\*devHandle); | 传输请求事件完成处理 | 
+| int32_t&nbsp;UsbRawInit(struct&nbsp;UsbSession&nbsp;\*\*session); | USB驱动开发工具包专家模式初始化 |
+| UsbRawHandle&nbsp;\*UsbRawOpenDevice(const&nbsp;struct<br/>UsbSession&nbsp;\*session,&nbsp;uint8_t&nbsp;busNum,&nbsp;uint8_t<br/>usbAddr); | 打开USB设备对象 |
+| int32_t&nbsp;UsbRawSendControlRequest(const&nbsp;struct<br/>UsbRawRequest&nbsp;\*request,&nbsp;const&nbsp;UsbRawHandle<br/>\*devHandle,&nbsp;const&nbsp;struct&nbsp;UsbControlRequestData<br/>\*requestData); | 执行同步控制传输 |
+| int32_t&nbsp;UsbRawSendBulkRequest(const&nbsp;struct<br/>UsbRawRequest&nbsp;\*request,&nbsp;const&nbsp;UsbRawHandle<br/>\*devHandle,&nbsp;const&nbsp;struct&nbsp;UsbRequestData<br/>\*requestData); | 执行同步批量传输 |
+| int32_t&nbsp;UsbRawSendInterruptRequest(const&nbsp;struct<br/>UsbRawRequest&nbsp;\*request,&nbsp;const&nbsp;UsbRawHandle<br/>\*devHandle,&nbsp;const&nbsp;struct&nbsp;UsbRequestData<br/>\*requestData); | 执行同步中断传输 |
+| int32_t&nbsp;UsbRawGetConfigDescriptor(const&nbsp;UsbRawDevice<br/>\*rawDev,&nbsp;uint8_t&nbsp;configIndex,&nbsp;struct<br/>UsbRawConfigDescriptor&nbsp;\*\*config); | 获取给定设备指定ID的设备配置描述符 |
+| int32_t&nbsp;UsbRawFillInterruptRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request,&nbsp;const&nbsp;UsbRawHandle&nbsp;\*devHandle,&nbsp;const&nbsp;struct<br/>UsbRawFillRequestData&nbsp;\*fillData); | 填充中断传输请求所需信息 |
+| int32_t&nbsp;UsbRawFillIsoRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request,&nbsp;const&nbsp;UsbRawHandle&nbsp;\*devHandle,&nbsp;const&nbsp;struct<br/>UsbRawFillRequestData&nbsp;\*fillData); | 填充同步传输（Isochronous&nbsp;Transfers）请求所需信息 |
+| int32_t&nbsp;UsbRawSubmitRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request); | 提交一个传输请求 |
+| int32_t&nbsp;UsbRawCancelRequest(const&nbsp;struct&nbsp;UsbRawRequest<br/>\*request); | 取消一个传输请求 |
+| int32_t&nbsp;UsbRawHandleRequests(const&nbsp;UsbRawHandle<br/>\*devHandle); | 传输请求事件完成处理 |
 
 USB设备端用于管理USB设备的相关接口如下，具体接口定义[见源码](https://gitee.com/openharmony/drivers_peripheral/blob/master/usb/interfaces/ddk/device/usbfn_device.h)。
 
   **表3** USB设备端用于管理USB设备的相关接口
 
-| 接口名称 | 功能描述 | 
+| 接口名称 | 功能描述 |
 | -------- | -------- |
-| const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnCreateDevice(const<br/>char&nbsp;\*udcName,&nbsp;const&nbsp;struct&nbsp;UsbFnDescriptorData<br/>\*descriptor); | 创建USB设备 | 
-| int32_t&nbsp;UsbFnRemoveDevice(struct&nbsp;UsbFnDevice<br/>\*fnDevice); | 删除USB设备 | 
-| const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnGetDevice(const&nbsp;char<br/>\*udcName); | 获取USB设备 | 
+| const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnCreateDevice(const<br/>char&nbsp;\*udcName,&nbsp;const&nbsp;struct&nbsp;UsbFnDescriptorData<br/>\*descriptor); | 创建USB设备 |
+| int32_t&nbsp;UsbFnRemoveDevice(struct&nbsp;UsbFnDevice<br/>\*fnDevice); | 删除USB设备 |
+| const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnGetDevice(const&nbsp;char<br/>\*udcName); | 获取USB设备 |
 
 USB设备端用于USB接口定义的相关接口如下，具体接口定义[见源码](https://gitee.com/openharmony/drivers_peripheral/blob/master/usb/interfaces/ddk/device/usbfn_interface.h)。
 
   **表4** USB设备端用于USB接口定义的相关接口
 
-| 接口名称 | 功能描述 | 
+| 接口名称 | 功能描述 |
 | -------- | -------- |
-| int32_t&nbsp;UsbFnStartRecvInterfaceEvent(struct<br/>UsbFnInterface&nbsp;\*interface,&nbsp;uint32_t&nbsp;eventMask,<br/>UsbFnEventCallback&nbsp;callback,&nbsp;void&nbsp;\*context); | 开始接受Event事件 | 
-| int32_t&nbsp;UsbFnStopRecvInterfaceEvent(struct<br/>UsbFnInterface&nbsp;\*interface); | 停止接受Event事件 | 
-| UsbFnInterfaceHandle&nbsp;UsbFnOpenInterface(struct&nbsp;UsbFnInterface&nbsp;\*interface); | 打开一个接口 | 
-| int32_t&nbsp;UsbFnCloseInterface(UsbFnInterfaceHandle&nbsp;handle); | 关闭一个接口 | 
-| int32_t&nbsp;UsbFnGetInterfacePipeInfo(struct&nbsp;UsbFnInterface<br/>\*interface,&nbsp;uint8_t&nbsp;pipeId,&nbsp;struct&nbsp;UsbFnPipeInfo&nbsp;\*info); | 获取管道信息 | 
-| int32_t&nbsp;UsbFnSetInterfaceProp(const&nbsp;struct&nbsp;UsbFnInterface<br/>\*interface,&nbsp;const&nbsp;char&nbsp;\*name,&nbsp;const&nbsp;char&nbsp;\*value); | 设置自定义属性 | 
+| int32_t&nbsp;UsbFnStartRecvInterfaceEvent(struct<br/>UsbFnInterface&nbsp;\*interface,&nbsp;uint32_t&nbsp;eventMask,<br/>UsbFnEventCallback&nbsp;callback,&nbsp;void&nbsp;\*context); | 开始接受Event事件 |
+| int32_t&nbsp;UsbFnStopRecvInterfaceEvent(struct<br/>UsbFnInterface&nbsp;\*interface); | 停止接受Event事件 |
+| UsbFnInterfaceHandle&nbsp;UsbFnOpenInterface(struct&nbsp;UsbFnInterface&nbsp;\*interface); | 打开一个接口 |
+| int32_t&nbsp;UsbFnCloseInterface(UsbFnInterfaceHandle&nbsp;handle); | 关闭一个接口 |
+| int32_t&nbsp;UsbFnGetInterfacePipeInfo(struct&nbsp;UsbFnInterface<br/>\*interface,&nbsp;uint8_t&nbsp;pipeId,&nbsp;struct&nbsp;UsbFnPipeInfo&nbsp;\*info); | 获取管道信息 |
+| int32_t&nbsp;UsbFnSetInterfaceProp(const&nbsp;struct&nbsp;UsbFnInterface<br/>\*interface,&nbsp;const&nbsp;char&nbsp;\*name,&nbsp;const&nbsp;char&nbsp;\*value); | 设置自定义属性 |
 
 USB设备端用于管理USB数据请求的相关接口如下，具体接口定义[见源码](https://gitee.com/openharmony/drivers_peripheral/blob/master/usb/interfaces/ddk/device/usbfn_request.h)。
 
   **表5** USB设备端用于管理USB数据请求的相关接口
 
-| 接口名称 | 功能描述 | 
+| 接口名称 | 功能描述 |
 | -------- | -------- |
-| struct&nbsp;UsbFnRequest<br/>\*UsbFnAllocCtrlRequest(UsbFnInterfaceHandle&nbsp;handle,<br/>uint32_t&nbsp;len); | 申请一个控制请求 | 
-| struct&nbsp;UsbFnRequest&nbsp;\*UsbFnAllocRequest(UsbFnInterfaceHandle&nbsp;handle,<br/>uint8_t&nbsp;pipe,&nbsp;uint32_t&nbsp;len); | 申请一个数据请求 | 
-| int32_t&nbsp;UsbFnFreeRequest(struct&nbsp;UsbFnRequest&nbsp;\*req); | 释放一个请求 | 
-| int32_t&nbsp;UsbFnSubmitRequestAsync(struct&nbsp;UsbFnRequest<br/>\*req); | 发送异步请求 | 
-| int32_t&nbsp;UsbFnSubmitRequestSync(struct&nbsp;UsbFnRequest<br/>\*req,&nbsp;uint32_t&nbsp;timeout); | 发送同步请求 | 
-| int32_t&nbsp;UsbFnCancelRequest(struct&nbsp;UsbFnRequest&nbsp;\*req); | 取消请求 | 
+| struct&nbsp;UsbFnRequest<br/>\*UsbFnAllocCtrlRequest(UsbFnInterfaceHandle&nbsp;handle,<br/>uint32_t&nbsp;len); | 申请一个控制请求 |
+| struct&nbsp;UsbFnRequest&nbsp;\*UsbFnAllocRequest(UsbFnInterfaceHandle&nbsp;handle,<br/>uint8_t&nbsp;pipe,&nbsp;uint32_t&nbsp;len); | 申请一个数据请求 |
+| int32_t&nbsp;UsbFnFreeRequest(struct&nbsp;UsbFnRequest&nbsp;\*req); | 释放一个请求 |
+| int32_t&nbsp;UsbFnSubmitRequestAsync(struct&nbsp;UsbFnRequest<br/>\*req); | 发送异步请求 |
+| int32_t&nbsp;UsbFnSubmitRequestSync(struct&nbsp;UsbFnRequest<br/>\*req,&nbsp;uint32_t&nbsp;timeout); | 发送同步请求 |
+| int32_t&nbsp;UsbFnCancelRequest(struct&nbsp;UsbFnRequest&nbsp;\*req); | 取消请求 |
 
 
 ### 开发步骤
@@ -295,14 +295,13 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
 1. 在设备功能代码中构造描述符。
 
     ```cpp
-    static struct UsbFnFunction g_acmFunction = { // 功能描述符
-        .enable         = true,
-        .funcName       = "f_generic.a",
-        .strings        = g_acmStrings,
-        .fsDescriptors  = g_acmFsFunction,
-        .hsDescriptors  = g_acmHsFunction,
-        .ssDescriptors  = g_acmSsFunction,
-        .sspDescriptors = NULL,
+    static struct UsbFnFunction g_acmFunction = {
+        .funcName = "f_generic.a",                     //功能名称
+        .strings = g_acmStrings,                       //字符串
+        .fsDescriptors = g_acmFsFunction,              //初始化fs描述符
+        .hsDescriptors = g_acmHsFunction,              //初始化hs描述符
+        .ssDescriptors = g_acmSsFunction,              //初始化ss描述符
+        .sspDescriptors = nullptr,                     //ss描述符置空
     };
     struct UsbFnFunction *g_functions[] = {
     #ifdef CDC_ECM
@@ -311,8 +310,7 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
     #ifdef CDC_ACM
         &g_acmFunction,
     #endif
-    NULL
-    };
+        nullptr};
     static struct UsbFnConfiguration g_masterConfig = { // 配置描述符
         .configurationValue = 1,
         .iConfiguration     = USB_FUNC_CONFIG_IDX,
@@ -322,10 +320,10 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
     };
     static struct UsbFnConfiguration *g_configs[] = {
         &g_masterConfig,
-        NULL,
+        nullptr,
     };
-    static struct UsbDeviceDescriptor g_cdcMasterDeviceDesc = { // 设备描述符
-        .bLength            = sizeof(g_cdcMasterDeviceDesc),
+    static struct UsbDeviceDescriptor g_cdcUsbFnDeviceDesc = { // 设备描述符
+        .bLength            = sizeof(g_cdcUsbFnDeviceDesc),
         .bDescriptorType    = USB_DDK_DT_DEVICE,
         .bcdUSB             = CpuToLe16(BCD_USB),
         .bDeviceClass       = 0,
@@ -340,10 +338,10 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
         .iSerialNumber      = USB_FUNC_SERIAL_IDX,
         .bNumConfigurations = 1,
     };
-    static struct UsbFnDeviceDesc g_masterFuncDevice = { // 描述符入口
-        .deviceDesc    = &g_cdcMasterDeviceDesc,
+    struct UsbFnDeviceDesc g_acmFnDevice = { //描述符入口
+        .deviceDesc = &g_cdcUsbFnDeviceDesc,
         .deviceStrings = g_devStrings,
-        .configs       = g_configs,
+        .configs = g_configs,
     };
     ```
 
@@ -351,14 +349,14 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
 
     ```cpp
     if (useHcs == 0) { // 使用代码编写的描述符
-        descData.type        = USBFN_DESC_DATA_TYPE_DESC;
-        descData.descriptor = &g_acmFuncDevice;
+        descData.type = USBFN_DESC_DATA_TYPE_DESC;
+        descData.descriptor = &g_acmFnDevice;
     } else {             // 使用hcs编写的描述符
-        descData.type         = USBFN_DESC_DATA_TYPE_PROP;
-        descData.property    = acm->device->property;
+        devMgr->descData.type = USBFN_DESC_DATA_TYPE_PROP;
+        devMgr->descData.property = device->property;
     }
     // 创建设备
-    fnDev = (struct UsbFnDevice *) UsbFnCreateDevice(acm->udcName, &descData);
+    fnDev = (struct UsbFnDevice *)UsbFnCreateDevice(devMgr->udcName, &devMgr->descData);
     ```
 
 3. 设备创建后，使用UsbFnGetInterface函数获取UsbInterface接口对象，并通过UsbFnGetInterfacePipeInfo函数获取USB管道信息。
@@ -371,56 +369,53 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
     // 获取Handle
     handle = UsbFnOpenInterface(fnIface);
     // 获取控制（EP0）Request
-    req = UsbFnAllocCtrlRequest(acm->ctrlIface.handle,
-                sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
+    req = UsbFnAllocCtrlRequest(acmDevice->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
     // 获取Request
-    req = UsbFnAllocCtrlRequest(acm->ctrlIface.handle,
-                sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
+    req = UsbFnAllocCtrlRequest(acmDevice->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
     ```
 
 4. 通过UsbFnStartRecvInterfaceEvent函数接收Event事件，并通过UsbFnEventCallback回调函数对Event事件做出响应。
 
     ```cpp
     // 开始接收Event事件
-    ret = UsbFnStartRecvInterfaceEvent(acm->ctrlIface.fn, 0xff, UsbAcmEventCallback, acm);
+    ret = UsbFnStartRecvInterfaceEvent(acmDevice->ctrlIface.fn, 0xff, AcmEventCallback, acmDevice);
     // Event处理回调函数
     static void UsbAcmEventCallback(struct UsbFnEvent *event)
     {
         struct UsbAcmDevice *acm = NULL;
         if (event == NULL || event->context == NULL) {
-            HDF_LOGE("%s: event is null", __func__);
+            HDF_LOGE("%{public}s: event is null", __func__);
             return;
         }
-
         acm = (struct UsbAcmDevice *)event->context;
         switch (event->type) {
             case USBFN_STATE_BIND:
-                HDF_LOGI("%s: receive bind event", __func__);
+                HDF_LOGI("%{public}s: receive bind event", __func__);
                 break;
             case USBFN_STATE_UNBIND:
-                HDF_LOGI("%s: receive unbind event", __func__);
+                HDF_LOGI("%{public}s: receive unbind event", __func__);
                 break;
             case USBFN_STATE_ENABLE:
-                HDF_LOGI("%s: receive enable event", __func__);
+                HDF_LOGI("%{public}s: receive enable event", __func__);
                 AcmEnable(acm);
                 break;
             case USBFN_STATE_DISABLE:
-                HDF_LOGI("%s: receive disable event", __func__);
+                HDF_LOGI("%{public}s: receive disable event", __func__);
                 AcmDisable(acm);
                 acm->enableEvtCnt = 0;
                 break;
             case USBFN_STATE_SETUP:
-                HDF_LOGI("%s: receive setup event", __func__);
+                HDF_LOGI("%{public}s: receive setup event", __func__);
                 if (event->setup != NULL) {
                     AcmSetup(acm, event->setup);
                 }
                 break;
             case USBFN_STATE_SUSPEND:
-                HDF_LOGI("%s: receive suspend event", __func__);
+                HDF_LOGI("%{public}s: receive suspend event", __func__);
                 AcmSuspend(acm);
                 break;
             case USBFN_STATE_RESUME:
-                HDF_LOGI("%s: receive resume event", __func__);
+                HDF_LOGI("%{public}s: receive resume event", __func__);
                 AcmResume(acm);
                 break;
             default:
@@ -434,10 +429,16 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
     ```cpp
     notify = (struct UsbCdcNotification *)req->buf;
     ...
-    if (memcpy_s((void *)(notify + 1), length, data, length) != EOK) {
+    ret = memcpy_s((void *)(notify + 1), length, data, length);
+    if (ret != EOK) {
+        HDF_LOGE("%s: memcpy_s failed", __func__);
         return HDF_FAILURE;
     }
     ret = UsbFnSubmitRequestAsync(req); // 异步发送
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: send notify request failed", __func__);
+        acm->notifyReq = req;
+    } 
     ```
 
 ### 开发实例
@@ -450,34 +451,35 @@ USB驱动基于HDF框架、Platform和OSAL基础接口进行开发，不区分
 #include "usb_serial.h"
 #include "hdf_base.h"
 #include "hdf_log.h"
+#include "hdf_usb_pnp_manage.h"
 #include "osal_mem.h"
 #include "osal_time.h"
 #include "securec.h"
 #include "usb_ddk_interface.h"
-#include "hdf_usb_pnp_manage.h"
 
 #define HDF_LOG_TAG USB_HOST_ACM
 #define STR_LEN     512
 
-static struct UsbRequest *g_syncRequest = NULL; // 定义一个USB请求
+static struct UsbRequest *g_syncRequest = NULL;  // 定义一个USB请求
 static struct UsbRequest *g_ctrlCmdRequest = NULL;
 static bool g_acmReleaseFlag = false;
 static uint8_t *g_acmReadBuffer = NULL;
 ...
-static int32_t SerialCtrlMsg(struct AcmDevice *acm, uint8_t request,
-    uint16_t value, void *buf, uint16_t len)
+static int32_t SerialCtrlMsg(struct AcmDevice *acm, uint8_t request, uint16_t value, void *buf, uint16_t len)
 {
     int32_t ret;
-    uint16_t index = acm->intPipe->interfaceId;
-    struct UsbControlParams controlParams;
-    struct UsbRequestParams params; // 定义一个USB请求参数对象
-    if (acm == NULL || buf == NULL) {
+    if (acm == NULL || buf == NULL || acm->intPipe == NULL) {
+        HDF_LOGE("%s:invalid param", __func__);
         return HDF_ERR_IO;
     }
+    uint16_t index = acm->intPipe->interfaceId;
+    struct UsbControlParams controlParams = {};
+    struct UsbRequestParams parmas = {}; // 定义一个USB请求参数对象
     if (acm->ctrlReq == NULL) {
         // 为获取到的UsbInterfaceHandle预先分配待发送的IO Request对象
         acm->ctrlReq = UsbAllocRequest(acm->ctrDevHandle, 0, len);
         if (acm->ctrlReq == NULL) {
+            HDF_LOGE("%s: UsbAllocRequest failed", __func__);
             return HDF_ERR_IO;
         }
     }
@@ -485,72 +487,70 @@ static int32_t SerialCtrlMsg(struct AcmDevice *acm, uint8_t request,
     controlParams.request = request;
     controlParams.target = USB_REQUEST_TARGET_INTERFACE; // 接口对象
     controlParams.reqType = USB_REQUEST_TYPE_CLASS; // 请求类型
-    controlParams.direction = USB_REQUEST_DIR_TO_DEVICE; // 从主机到设备的数据传输
+    controlParams.directon = USB_REQUEST_DIR_TO_DEVICE; // 从主机到设备的数据传输
     controlParams.value = value;
     controlParams.index = index;
     controlParams.data = buf;
     controlParams.size = len;
 
-    params.interfaceId = USB_CTRL_INTERFACE_ID; // 定义USB控制接口的默认ID
-    params.pipeAddress = acm->ctrPipe->pipeAddress;
-    params.pipeId = acm->ctrPipe->pipeId;
-    params.requestType = USB_REQUEST_PARAMS_CTRL_TYPE; // 控制类型
-    params.timeout = USB_CTRL_SET_TIMEOUT; // 设置超时时间
-    params.ctrlReq = UsbControlSetUp(&controlParams);
+    parmas.interfaceId = USB_CTRL_INTERFACE_ID; // 定义USB控制接口的默认ID
+    if (acm->ctrPipe != NULL) {
+        parmas.pipeAddress = acm->ctrPipe->pipeAddress; 
+        parmas.pipeId = acm->ctrPipe->pipeId;
+    }
+    parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE; // 控制类型
+    parmas.timeout = USB_CTRL_SET_TIMEOUT; // 设置超时时间
+    parmas.ctrlReq = UsbControlSetUp(&controlParams);
+    parmas.callback = NULL;
     // 根据params填充预先分配的IO Request
-    ret = UsbFillRequest(acm->ctrlReq, acm->ctrDevHandle, &params);
+    ret = UsbFillRequest(acm->ctrlReq, acm->ctrDevHandle, &parmas);
     if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: UsbFillRequest failed, ret = %d ", __func__, ret);
         return ret;
     }
     // 发送同步IO Request
     ret = UsbSubmitRequestSync(acm->ctrlReq);
     if (ret != HDF_SUCCESS) {
+        HDF_LOGE("UsbSubmitRequestSync failed, ret = %d ", ret);
         return ret;
     }
     if (!acm->ctrlReq->compInfo.status) {
-        HDF_LOGE("%s status=%d ", __func__, acm->ctrlReq->compInfo.status);
+        HDF_LOGE("%s  status=%d ", __func__, acm->ctrlReq->compInfo.status);
     }
     return HDF_SUCCESS;
 }
 ...
-static struct UsbInterface *GetUsbInterfaceById(const struct AcmDevice *acm,
-    uint8_t interfaceIndex)
+static struct UsbInterface *GetUsbInterfaceById(const struct AcmDevice *acm, uint8_t interfaceIndex)
 {
-    struct UsbInterface *tmpIf = NULL;
     // 获取UsbInterface接口对象
-    tmpIf = (struct UsbInterface *)UsbClaimInterface(acm->session, acm->busNum, acm->devAddr, interfaceIndex);
-    return tmpIf;
+    return UsbClaimInterface(acm->session, acm->busNum, acm->devAddr, interfaceIndex);
 }
 ...
-static struct UsbPipeInfo *EnumePipe(const struct AcmDevice *acm,
-    uint8_t interfaceIndex, UsbPipeType pipeType, UsbPipeDirection pipeDirection)
+static struct UsbPipeInfo *EnumePipe(
+    const struct AcmDevice *acm, uint8_t interfaceIndex, UsbPipeType pipeType, UsbPipeDirection pipeDirection)
 {
-    uint8_t i;
-    int32_t ret;
     struct UsbInterfaceInfo *info = NULL; // 定义一个USB接口信息对象
     UsbInterfaceHandle *interfaceHandle = NULL; // 定义一个USB接口操作句柄，就是void *类型
-    if (pipeType == USB_PIPE_TYPE_CONTROL)
-    {
+    if (pipeType == USB_PIPE_TYPE_CONTROL) {
         info = &acm->ctrIface->info;
         interfaceHandle = acm->ctrDevHandle;
-    }
-    else
-    {
-        info = &acm->iface[interfaceIndex]->info;
+    } else {
         // 根据interfaceIndex获取设备句柄
+        info = &acm->iface[interfaceIndex]->info;
         interfaceHandle = InterfaceIdToHandle(acm, info->interfaceIndex);
     }
 
-    for (i = 0;  i <= info->pipeNum; i++) {
+    for (uint8_t i = 0; i <= info->pipeNum; i++) {
         struct UsbPipeInfo p;
         // 获取指定索引为i的pipeInfo信息
-        ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &p);
+        int32_t ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &p);
         if (ret < 0) {
             continue;
         }
         if ((p.pipeDirection == pipeDirection) && (p.pipeType == pipeType)) {
             struct UsbPipeInfo *pi = OsalMemCalloc(sizeof(*pi)); // 开辟内存并初始化
             if (pi == NULL) {
+                HDF_LOGE("%s: Alloc pipe failed", __func__);
                 return NULL;
             }
             p.interfaceId = info->interfaceIndex;
@@ -561,11 +561,11 @@ static struct UsbPipeInfo *EnumePipe(const struct AcmDevice *acm,
     return NULL;
 }
 
-static struct UsbPipeInfo *GetPipe(const struct AcmDevice *acm,
-    UsbPipeType pipeType, UsbPipeDirection pipeDirection)
+static struct UsbPipeInfo *GetPipe(const struct AcmDevice *acm, UsbPipeType pipeType, UsbPipeDirection pipeDirection)
 {
     uint8_t i;
     if (acm == NULL) {
+        HDF_LOGE("%s: invalid param", __func__);
         return NULL;
     }
     for (i = 0; i < acm->interfaceCnt; i++) {
@@ -590,39 +590,48 @@ static int32_t UsbSerialDriverBind(struct HdfDeviceObject *device)
     errno_t err;
     struct AcmDevice *acm = NULL;
     if (device == NULL) {
+        HDF_LOGE("%s: device is null", __func__);
         return HDF_ERR_INVALID_OBJECT;
     }
+    //开辟内存空间
     acm = (struct AcmDevice *)OsalMemCalloc(sizeof(*acm));
     if (acm == NULL) {
+        HDF_LOGE("%s: Alloc usb serial device failed", __func__);
         return HDF_FAILURE;
     }
     // 初始化互斥锁，&acm->lock表示指向互斥量的指针
     if (OsalMutexInit(&acm->lock) != HDF_SUCCESS) {
-        goto error;
+        HDF_LOGE("%s:%d OsalMutexInit failed", __func__, __LINE__);
+        goto ERROR;
     }
     info = (struct UsbPnpNotifyServiceInfo *)device->priv;
     if (info != NULL) {
-        acm->busNum = info->busNum;
-        acm->devAddr = info->devNum;
+        HDF_LOGD("%s:%d busNum=%d,devAddr=%d,interfaceLength=%d", __func__, __LINE__, info->busNum, info->devNum,
+            info->interfaceLength);
+        acm->busNum = (uint8_t)info->busNum;
+        acm->devAddr = (uint8_t)info->devNum;
         acm->interfaceCnt = info->interfaceLength;
-        err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES,
-              (const void*)info->interfaceNumber, info->interfaceLength);
+        err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES, (const void *)info->interfaceNumber,
+            info->interfaceLength);
         if (err != EOK) {
-            goto lock_error;
+            HDF_LOGE("%s:%d memcpy_s failed err = %d", __func__, __LINE__, err);
+            goto LOCK_ERROR;
         }
     } else {
-        goto lock_error;
+        HDF_LOGE("%s:%d info is null!", __func__, __LINE__);
+        goto LOCK_ERROR;
     }
-    acm->device  = device;
+    acm->device = device;
     device->service = &(acm->service);
     acm->device->service->Dispatch = UsbSerialDeviceDispatch;
+    HDF_LOGD("UsbSerialDriverBind=========================OK");
     return HDF_SUCCESS;
 
-lock_error:
+LOCK_ERROR:
     if (OsalMutexDestroy(&acm->lock)) {
         HDF_LOGE("%s:%d OsalMutexDestroy failed", __func__, __LINE__);
     }
-error:
+ERROR:
     OsalMemFree(acm);
     acm = NULL;
     return HDF_FAILURE;
@@ -631,32 +640,34 @@ error:
 static int32_t AcmAllocReadRequests(struct AcmDevice *acm)
 {
     int32_t ret;
-    struct UsbRequestParams readParams;
+    struct UsbRequestParams readParmas = {};
     for (int32_t i = 0; i < ACM_NR; i++) {
         // 分配待发送的readReq IO Request对象
         acm->readReq[i] = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), 0, acm->readSize);
         if (!acm->readReq[i]) {
-            goto error;
+            HDF_LOGE("readReq request failed\n");
+            goto ERROR;
         }
-        readParams.userData = (void *)acm;
-        readParams.pipeAddress = acm->dataInPipe->pipeAddress;
-        readParams.pipeId = acm->dataInPipe->pipeId;
-        readParams.interfaceId = acm->dataInPipe->interfaceId;
-        readParams.callback = AcmReadBulk;
-        readParams.requestType = USB_REQUEST_PARAMS_DATA_TYPE; /* Data type */
-        readParams.timeout = USB_CTRL_SET_TIMEOUT;
-        readParams.dataReq.numIsoPackets = 0;
-        readParams.dataReq.direction = (acm->dataInPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1;
-        readParams.dataReq.length = acm->readSize;
+        readParmas.userData = (void *)acm;
+        readParmas.pipeAddress = acm->dataInPipe->pipeAddress;
+        readParmas.pipeId = acm->dataInPipe->pipeId;
+        readParmas.interfaceId = acm->dataInPipe->interfaceId;
+        readParmas.callback = AcmReadBulk;
+        readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; /* Data type */
+        readParmas.timeout = USB_CTRL_SET_TIMEOUT;
+        readParmas.dataReq.numIsoPackets = 0;
+        readParmas.dataReq.directon = (((uint8_t)acm->dataInPipe->pipeDirection) >> USB_PIPE_DIR_OFFSET) & 0x1;
+        readParmas.dataReq.length = (int)acm->readSize;
         // 根据readParams填充预先分配待发送的readReq IO Request对象
-        ret = UsbFillRequest(acm->readReq[i], InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), &readParams);
+        ret = UsbFillRequest(acm->readReq[i], InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), &readParmas);
         if (ret != HDF_SUCCESS) {
-            goto error;
+            HDF_LOGE("%s: UsbFillRequest failed, ret=%d \n", __func__, ret);
+            goto ERROR;
         }
     }
     return HDF_SUCCESS;
 
-error:
+ERROR:
     AcmFreeReadRequests(acm);
     return HDF_ERR_MALLOC_FAIL;
 }
@@ -664,37 +675,39 @@ error:
 static int32_t AcmAllocNotifyRequest(struct AcmDevice *acm)
 {
     int32_t ret;
-    struct UsbRequestParams intParams = {};
+    struct UsbRequestParams intParmas = {};
     // 分配待发送的中断IO Request对象
     acm->notifyReq = UsbAllocRequest(InterfaceIdToHandle(acm, acm->intPipe->interfaceId), 0, acm->intSize);
     if (!acm->notifyReq) {
+        HDF_LOGE("notifyReq request failed.\n");
         return HDF_ERR_MALLOC_FAIL;
     }
-    intParams.userData = (void *)acm;
-    intParams.pipeAddress = acm->intPipe->pipeAddress;
-    intParams.pipeId = acm->intPipe->pipeId;
-    intParams.interfaceId = acm->intPipe->interfaceId;
-    intParams.callback = AcmCtrlIrq;
-    intParams.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
-    intParams.timeout = USB_CTRL_SET_TIMEOUT;
-    intParams.dataReq.numIsoPackets = 0;
-    intParams.dataReq.direction = (acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK;
-    intParams.dataReq.length = acm->intSize;
+    intParmas.userData = (void *)acm;
+    intParmas.pipeAddress = acm->intPipe->pipeAddress;
+    intParmas.pipeId = acm->intPipe->pipeId;
+    intParmas.interfaceId = acm->intPipe->interfaceId;
+    intParmas.callback = AcmCtrlIrq;
+    intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
+    intParmas.timeout = USB_CTRL_SET_TIMEOUT;
+    intParmas.dataReq.numIsoPackets = 0;
+    intParmas.dataReq.directon = (((uint8_t)acm->intPipe->pipeDirection) >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK;
+    intParmas.dataReq.length = (int)acm->intSize;
     // 填充预先分配的中断IO Request
-    ret = UsbFillRequest(acm->notifyReq, InterfaceIdToHandle(acm, acm->intPipe->interfaceId), &intParams);
+    ret = UsbFillRequest(acm->notifyReq, InterfaceIdToHandle(acm, acm->intPipe->interfaceId), &intParmas);
     if (ret != HDF_SUCCESS) {
-        goto error;
+        HDF_LOGE("%s: UsbFillRequest failed, ret = %d", __func__, ret);
+        goto ERROR;
     }
     return HDF_SUCCESS;
 
-error:
-    AcmFreeNotifyRequest(acm);
+ERROR:
+    AcmFreeNotifyReqeust(acm);
     return ret;
 }
 
 static void AcmReleaseInterfaces(struct AcmDevice *acm)
 {
-    for (int32_t i = 0; i < acm->interfaceCnt; i++) {
+    for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
         if (acm->iface[i]) {
             // 释放一个USB接口对象
             UsbReleaseInterface(acm->iface[i]);
@@ -709,23 +722,24 @@ static void AcmReleaseInterfaces(struct AcmDevice *acm)
 
 static int32_t AcmClaimInterfaces(struct AcmDevice *acm)
 {
-    for (int32_t i = 0; i < acm->interfaceCnt; i++) {
+    for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
         // 获取UsbInterface接口对象
         acm->iface[i] = GetUsbInterfaceById((const struct AcmDevice *)acm, acm->interfaceIndex[i]);
         if (acm->iface[i] == NULL) {
-            goto error;
+            HDF_LOGE("%s: interface%d is null", __func__, acm->interfaceIndex[i]);
+            goto ERROR;
         }
     }
-
-    // 获取控制接口对应的UsbInterface接口对象
+	// 获取控制接口对应的UsbInterface接口对象
     acm->ctrIface = GetUsbInterfaceById((const struct AcmDevice *)acm, USB_CTRL_INTERFACE_ID);
     if (acm->ctrIface == NULL) {
-        goto error;
+        HDF_LOGE("%s: GetUsbInterfaceById null", __func__);
+        goto ERROR;
     }
 
     return HDF_SUCCESS;
 
- error:
+ERROR:
     // 根据acm->interfaceCnt循环释放接口对象
     AcmReleaseInterfaces(acm);
     return HDF_FAILURE;
@@ -733,7 +747,7 @@ static int32_t AcmClaimInterfaces(struct AcmDevice *acm)
 
 static void AcmCloseInterfaces(struct AcmDevice *acm)
 {
-    for (int32_t i = 0; i < acm->interfaceCnt; i++) {
+    for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
         if (acm->devHandle[i]) {
             // 关闭一个USB设备对象
             UsbCloseInterface(acm->devHandle[i]);
@@ -748,23 +762,25 @@ static void AcmCloseInterfaces(struct AcmDevice *acm)
 
 static int32_t AcmOpenInterfaces(struct AcmDevice *acm)
 {
-    for (int32_t i = 0; i < acm->interfaceCnt; i++) {
+    for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
         if (acm->iface[i]) {
             // 打开获取到的UsbInterface接口对象
             acm->devHandle[i] = UsbOpenInterface(acm->iface[i]);
             if (acm->devHandle[i] == NULL) {
-                goto error;
+                HDF_LOGE("%s: UsbOpenInterface null", __func__);
+                goto ERROR;
             }
         }
     }
     acm->ctrDevHandle = UsbOpenInterface(acm->ctrIface);
     if (acm->ctrDevHandle == NULL) {
-        goto error;
+        HDF_LOGE("%s: ctrDevHandle UsbOpenInterface null", __func__);
+        goto ERROR;
     }
 
     return HDF_SUCCESS;
 
-error:
+ERROR:
     // 关闭所有UsbInterface接口对象
     AcmCloseInterfaces(acm);
     return HDF_FAILURE;
@@ -775,34 +791,36 @@ static int32_t AcmGetPipes(struct AcmDevice *acm)
     // 获取dataInPipe的pipeInfo信息
     acm->dataInPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_IN);
     if (acm->dataInPipe == NULL) {
-        goto error;
+        HDF_LOGE("dataInPipe is null");
+        goto ERROR;
     }
-
-    // 获取dataOutPipe的pipeInfo信息
+	// 获取dataOutPipe的pipeInfo信息
     acm->dataOutPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_OUT);
     if (acm->dataOutPipe == NULL) {
-        goto error;
+        HDF_LOGE("dataOutPipe is null");
+        goto ERROR;
     }
-
-    // 获取控制pipe的pipeInfo信息
+	// 获取控制pipe的pipeInfo信息
     acm->ctrPipe = EnumePipe(acm, acm->ctrIface->info.interfaceIndex, USB_PIPE_TYPE_CONTROL, USB_PIPE_DIRECTION_OUT);
     if (acm->ctrPipe == NULL) {
-        goto error;
+        HDF_LOGE("ctrPipe is null");
+        goto ERROR;
     }
-
     // 获取中断pipe的pipeInfo信息
     acm->intPipe = GetPipe(acm, USB_PIPE_TYPE_INTERRUPT, USB_PIPE_DIRECTION_IN);
     if (acm->intPipe == NULL) {
-        goto error;
+        HDF_LOGE("intPipe is null");
+        goto ERROR;
     }
 
-    acm->readSize  = acm->dataInPipe->maxPacketSize;
+    acm->readSize = acm->dataInPipe->maxPacketSize;
     acm->writeSize = acm->dataOutPipe->maxPacketSize;
-    acm->ctrlSize  = acm->ctrPipe->maxPacketSize;
-    acm->intSize   = acm->intPipe->maxPacketSize;
+    acm->ctrlSize = acm->ctrPipe->maxPacketSize;
+    acm->intSize = acm->intPipe->maxPacketSize;
+
     return HDF_SUCCESS;
 
-error:
+ERROR:
     // 释放设备中所有的管道信息
     AcmFreePipes(acm);
     return HDF_FAILURE;
@@ -815,105 +833,112 @@ static void AcmFreeRequests(struct AcmDevice *acm)
         g_syncRequest = NULL;
     }
     AcmFreeReadRequests(acm);
-    AcmFreeNotifyRequest(acm);
+    AcmFreeNotifyReqeust(acm);
     AcmFreeWriteRequests(acm);
     AcmWriteBufFree(acm);
 }
 
-static int32_t AcmAllocRequests(struct AcmDevice *acm)
+static int32_t AcmAllocRequests(const struct AcmDevice *acm)
 {
     int32_t ret;
 
     if (AcmWriteBufAlloc(acm) < 0) {
+        HDF_LOGE("%s: AcmWriteBufAlloc failed", __func__);
         return HDF_ERR_MALLOC_FAIL;
     }
 
     for (int32_t i = 0; i < ACM_NW; i++) {
-        struct AcmWb *snd = &(acm->wb[i]);
+        struct AcmWb *snd = (struct AcmWb *)&(acm->wb[i]);
         // 分配待发送的IO Request对象
-        snd->request = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataOutPipe->interfaceId), 0, acm->writeSize);
-        snd->instance = acm;
+        snd->request = UsbAllocRequest(
+            InterfaceIdToHandle((struct AcmDevice *)acm, acm->dataOutPipe->interfaceId), 0, acm->writeSize);
+        snd->instance = (struct AcmDevice *)acm; 
         if (snd->request == NULL) {
-            goto error_alloc_write_req;
+            HDF_LOGE("%s:%d snd request fail", __func__, __LINE__);
+            goto ERROR_ALLOC_WRITE_REQ;
         }
     }
 
-    ret = AcmAllocNotifyRequest(acm); // 分配并填充中断IO Request对象
+    ret = AcmAllocNotifyRequest((struct AcmDevice *)acm); // 分配并填充中断IO Request对象
     if (ret != HDF_SUCCESS) {
-        goto error_alloc_int_req;
+        HDF_LOGE("%s:%d AcmAllocNotifyRequest fail", __func__, __LINE__);
+        goto ERROR_ALLOC_INT_REQ;
     }
 
-    ret = AcmAllocReadRequests(acm); // 分配并填充readReq IO Request对象
+    ret = AcmAllocReadRequests((struct AcmDevice *)acm); // 分配并填充readReq IO Request对象
     if (ret) {
-        goto error_alloc_read_req;
+        HDF_LOGE("%s:%d AcmAllocReadRequests fail", __func__, __LINE__);
+        goto ERROR_ALLOC_READ_REQ;
     }
 
     return HDF_SUCCESS;
 
-error_alloc_read_req:
-    AcmFreeNotifyRequest(acm);
-error_alloc_int_req:
-    AcmFreeWriteRequests(acm);
-error_alloc_write_req:
-    AcmWriteBufFree(acm);
+ERROR_ALLOC_READ_REQ:
+    AcmFreeNotifyReqeust((struct AcmDevice *)acm);
+ERROR_ALLOC_INT_REQ:
+    AcmFreeWriteRequests((struct AcmDevice *)acm);
+ERROR_ALLOC_WRITE_REQ:
+    AcmWriteBufFree((struct AcmDevice *)acm);
     return HDF_FAILURE;
 }
 
 static int32_t AcmInit(struct AcmDevice *acm)
 {
     int32_t ret;
-    struct UsbSession *session = NULL;
 
-    if (acm->initFlag == true) {
+    if (acm->initFlag) {
+        HDF_LOGE("%{public}s: initFlag is true", __func__);
         return HDF_SUCCESS;
     }
-
-    // 初始化Host DDK
+	// 初始化Host DDK
     ret = UsbInitHostSdk(NULL);
     if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%{public}s: UsbInitHostSdk failed", __func__);
         return HDF_ERR_IO;
     }
-    acm->session = session;
-
-    // 根据acm->interfaceIndex[i]分别获取UsbInterface接口对象
+    acm->session = NULL;
+	// 根据acm->interfaceIndex[i]分别获取UsbInterface接口对象
     ret = AcmClaimInterfaces(acm);
     if (ret != HDF_SUCCESS) {
-        goto error_claim_interfaces;
+        HDF_LOGE("%{public}s: AcmClaimInterfaces failed", __func__);
+        goto ERROR_CLAIM_INTERFACES;
     }
-
     // 根据acm->iface[i]分别打开UsbInterface接口对象
     ret = AcmOpenInterfaces(acm);
     if (ret != HDF_SUCCESS) {
-        goto error_open_interfaces;
+        HDF_LOGE("%{public}s: AcmOpenInterfaces failed", __func__);
+        goto ERROR_OPEN_INTERFACES;
     }
-
     // 获取管道信息的指针
     ret = AcmGetPipes(acm);
     if (ret != HDF_SUCCESS) {
-        goto error_get_pipes;
+        HDF_LOGE("%{public}s: AcmGetPipes failed", __func__);
+        goto ERROR_GET_PIPES;
     }
 
     ret = AcmAllocRequests(acm);
     if (ret != HDF_SUCCESS) {
-        goto error_alloc_reqs;
+        HDF_LOGE("%{public}s: AcmAllocRequests failed", __func__);
+        goto ERROR_ALLOC_REQS;
     }
 
-    acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); // 转换为小端数据
-    acm->lineCoding.bCharFormat = CHARFORMAT; // 8
+    acm->lineCoding.dwDTERate = CPU_TO_LE32(DATARATE);
+    acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
     acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS;
+    acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
     acm->initFlag = true;
+
     return HDF_SUCCESS;
 
-error_alloc_reqs:
+ERROR_ALLOC_REQS:
     AcmFreePipes(acm);
-error_get_pipes:
-    // 关闭所有UsbInterface接口对象  
+ERROR_GET_PIPES:
+    // 关闭所有UsbInterface接口对象
     AcmCloseInterfaces(acm);
-error_open_interfaces:
-    // 释放所有UsbInterface接口对象  
+ERROR_OPEN_INTERFACES:
+    // 释放所有UsbInterface接口对象 
     AcmReleaseInterfaces(acm);
-error_claim_interfaces:
+ERROR_CLAIM_INTERFACES:
     // 在主机端退出USB DDK，acm->session代表指向会话上下文的指针
     UsbExitHostSdk(acm->session);
     acm->session = NULL;
@@ -922,17 +947,19 @@ error_claim_interfaces:
 
 static void AcmRelease(struct AcmDevice *acm)
 {
-    if (acm->initFlag == false) {
+    if (!(acm->initFlag)) {
+        HDF_LOGE("%s:%d: initFlag is false", __func__, __LINE__);
         return;
     }
 
-    AcmFreeRequests(acm);
-    AcmFreePipes(acm);
     AcmCloseInterfaces(acm);
     AcmReleaseInterfaces(acm);
+    AcmFreeRequests(acm);
+    AcmFreePipes(acm);
     // 在主机端退出USB DDK
     UsbExitHostSdk(acm->session);
     acm->session = NULL;
+
     acm->initFlag = false;
 }
 
@@ -942,14 +969,17 @@ static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device)
     struct AcmDevice *acm = NULL;
 
     if (device == NULL) {
+        HDF_LOGE("%s: device is null", __func__);
         return HDF_ERR_INVALID_OBJECT;
     }
     acm = (struct AcmDevice *)device->service;
     // 初始化互斥锁，&acm->readLock表示指向互斥量的指针
+    if (acm == NULL) {
+        return HDF_ERR_INVALID_OBJECT;
+    }
     OsalMutexInit(&acm->readLock);
     OsalMutexInit(&acm->writeLock);
-    HDF_LOGD("%s:%d busNum=%d,devAddr=%d", __func__, __LINE__, acm->busNum, acm->devAddr);
-
+    HDF_LOGD("%s:%d busNum = %d,devAddr = %d", __func__, __LINE__, acm->busNum, acm->devAddr);
     // 给USB串口设备信息开辟空间并赋值
     ret = UsbSerialDeviceAlloc(acm);
     if (ret != HDF_SUCCESS) {
@@ -958,6 +988,9 @@ static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device)
 
     acm->initFlag = false;
     g_acmReleaseFlag = false;
+
+    HDF_LOGD("%s:%d init ok!", __func__, __LINE__);
+
     return ret;
 }
 
@@ -966,16 +999,19 @@ static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
     struct AcmDevice *acm = NULL;
 
     if (device == NULL) {
+        HDF_LOGE("%s: device is null", __func__);
         return;
     }
     acm = (struct AcmDevice *)device->service;
     if (acm == NULL) {
+        HDF_LOGE("%s: acm is null", __func__);
         return;
     }
 
     g_acmReleaseFlag = true;
 
-    if (acm->initFlag == true) {
+    if (acm->initFlag) {
+        HDF_LOGE("%s:%d AcmRelease", __func__, __LINE__);
         AcmRelease(acm);
     }
     // 释放usb串口设备信息
@@ -986,21 +1022,21 @@ static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
     OsalMutexDestroy(&acm->lock);
     OsalMemFree(acm);
     acm = NULL;
+    HDF_LOGD("%s:%d exit", __func__, __LINE__);
 }
-
 // 驱动的Bind、Init、及Release操作
 struct HdfDriverEntry g_usbSerialDriverEntry = {
     .moduleVersion = 1,
-    .moduleName    = "usbhost_acm", // 驱动模块名称，必须与hcs文件中配置的名称一致
-    .Bind          = UsbSerialDriverBind,
-    .Init          = UsbSerialDriverInit,
-    .Release       = UsbSerialDriverRelease,
+    .moduleName = "usbhost_acm", // 驱动模块名称，必须与hcs文件中配置的名称一致
+    .Bind = UsbSerialDriverBind,
+    .Init = UsbSerialDriverInit,
+    .Release = UsbSerialDriverRelease,
 };
 HDF_INIT(g_usbSerialDriverEntry); // 驱动入口
 ```
 
 #### Host RAW API驱动开发
-  
+
 ```cpp
 root {
     module = "usb_pnp_device";
@@ -1051,27 +1087,27 @@ root {
 ```
 
 ```cpp
-#include "usb_serial_rawapi.h"
 #include <unistd.h>
-#include "osal_mem.h"
-#include "osal_time.h"
-#include "securec.h"
+
 #include "hdf_base.h"
 #include "hdf_log.h"
 #include "hdf_usb_pnp_manage.h"
+#include "osal_mem.h"
+#include "osal_time.h"
+#include "securec.h"
+#include "usb_serial_rawapi.h"
 
-#define HDF_LOG_TAG                     USB_HOST_ACM_RAW_API // 日志中可查寻的标签
-#define USB_CTRL_REQ_SIZE               64
-#define USB_IO_THREAD_STACK_SIZE        8192
-#define USB_RAW_IO_SLEEP_MS_TIME        100
-#define USB_RAW_IO_STOP_WAIT_MAX_TIME   3
+#define HDF_LOG_TAG                   USB_HOST_ACM_RAW_API
+#define USB_CTRL_REQ_SIZE             64
+#define USB_IO_THREAD_STACK_SIZE      8192
+#define USB_RAW_IO_SLEEP_MS_TIME      100
+#define USB_RAW_IO_STOP_WAIT_MAX_TIME 3
 
 static struct UsbRawRequest *g_syncRequest = NULL;
 static UsbRawIoProcessStatusType g_stopIoStatus = USB_RAW_IO_PROCESS_RUNNING;
 struct OsalMutex g_stopIoLock;
 static bool g_rawAcmReleaseFlag = false;
-......
-
+...
 static int32_t UsbGetConfigDescriptor(UsbRawHandle *devHandle, struct UsbRawConfigDescriptor **config)
 {
     UsbRawDevice *dev = NULL;
@@ -1079,30 +1115,33 @@ static int32_t UsbGetConfigDescriptor(UsbRawHandle *devHandle, struct UsbRawConf
     int32_t ret;
 
     if (devHandle == NULL) {
+        HDF_LOGE("%s:%d devHandle is null", __func__, __LINE__);
         return HDF_ERR_INVALID_PARAM;
     }
-
     // 获取主用设备配置
     ret = UsbRawGetConfiguration(devHandle, &activeConfig);
-    if (ret != HDF_SUCCESS) {
+    if (ret) {
+        HDF_LOGE("%s:%d UsbRawGetConfiguration failed, ret = %d", __func__, __LINE__, ret);
         return HDF_FAILURE;
     }
-
+    HDF_LOGE("%s:%d activeConfig = %d", __func__, __LINE__, activeConfig);
     // 根据指定的设备句柄获取设备指针
     dev = UsbRawGetDevice(devHandle);
     if (dev == NULL) {
+        HDF_LOGE("%s:%d UsbRawGetDevice failed", __func__, __LINE__);
         return HDF_FAILURE;
     }
-
     // 根据指定的设备ID获取设备配置描述符
     ret = UsbRawGetConfigDescriptor(dev, activeConfig, config);
-    if (ret != HDF_SUCCESS) {
-        HDF_LOGE("UsbRawGetConfigDescriptor failed, ret=%d\n", ret);
+    if (ret) {
+        HDF_LOGE("UsbRawGetConfigDescriptor failed, ret = %d\n", ret);
+        return HDF_FAILURE;
     }
-    return ret;
+
+    return HDF_SUCCESS;
 }
 ...
-static int32_t UsbAllocWriteRequests(struct AcmDevice *acm)
+    static int32_t UsbAllocWriteRequests(struct AcmDevice *acm)
 {
     int32_t i;
 
@@ -1112,6 +1151,7 @@ static int32_t UsbAllocWriteRequests(struct AcmDevice *acm)
         snd->request = UsbRawAllocRequest(acm->devHandle, 0, acm->dataOutEp->maxPacketSize);
         snd->instance = acm;
         if (snd->request == NULL) {
+            HDF_LOGE("%s: UsbRawAllocRequest failed", __func__);
             return HDF_ERR_MALLOC_FAIL;
         }
     }
@@ -1127,41 +1167,47 @@ static int32_t UsbSerialDriverBind(struct HdfDeviceObject *device)
     errno_t err;
 
     if (device == NULL) {
+        HDF_LOGE("%s: device is null", __func__);
         return HDF_ERR_INVALID_OBJECT;
     }
 
     acm = (struct AcmDevice *)OsalMemCalloc(sizeof(*acm));
     if (acm == NULL) {
+        HDF_LOGE("%s: Alloc usb serial device failed", __func__);
         return HDF_FAILURE;
     }
     if (OsalMutexInit(&acm->lock) != HDF_SUCCESS) {
-        goto error;
+        HDF_LOGE("%s:%d OsalMutexInit fail", __func__, __LINE__);
+        goto ERROR;
     }
 
     info = (struct UsbPnpNotifyServiceInfo *)device->priv;
     if (info != NULL) {
-        acm->busNum       = info->busNum;
-        acm->devAddr      = info->devNum;
+        acm->busNum = (uint8_t)info->busNum;
+        acm->devAddr = (uint8_t)info->devNum;
         acm->interfaceCnt = info->interfaceLength;
-        err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES,
-                       (const void*)info->interfaceNumber, info->interfaceLength);
+        err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES, (const void *)info->interfaceNumber,
+            info->interfaceLength);
         if (err != EOK) {
-            goto lock_error;
+            HDF_LOGE("%s:%d memcpy_s failed err=%d", __func__, __LINE__, err);
+            goto LOCK_ERROR;
         }
     } else {
-        goto lock_error;
+        HDF_LOGE("%s:%d info is NULL!", __func__, __LINE__);
+        goto LOCK_ERROR;
     }
 
     device->service = &(acm->service);
     device->service->Dispatch = UsbSerialDeviceDispatch;
     acm->device = device;
+    HDF_LOGD("UsbSerialDriverBind=========================OK");
     return HDF_SUCCESS;
 
-lock_error:
+LOCK_ERROR:
     if (OsalMutexDestroy(&acm->lock)) {
-        HDF_LOGE("%s:%d OsalMutexDestroy failed", __func__, __LINE__);
+        HDF_LOGE("%s:%d OsalMutexDestroy fail", __func__, __LINE__);
     }
-error:
+ERROR:
     OsalMemFree(acm);
     acm = NULL;
     return HDF_FAILURE;
@@ -1170,26 +1216,26 @@ error:
 static int32_t UsbAllocReadRequests(struct AcmDevice *acm)
 {
     struct UsbRawFillRequestData reqData;
-    int32_t size = acm->dataInEp->maxPacketSize;
-    int32_t ret;
+    uint32_t size = acm->dataInEp->maxPacketSize;
 
     for (int32_t i = 0; i < ACM_NR; i++) {
         // 分配一个具有指定数目的同步传输分组描述符的传输请求
         acm->readReq[i] = UsbRawAllocRequest(acm->devHandle, 0, size);
         if (!acm->readReq[i]) {
+            HDF_LOGE("readReq request failed\n");
             return HDF_ERR_MALLOC_FAIL;
         }
 
-        reqData.endPoint      = acm->dataInEp->addr;
+        reqData.endPoint = acm->dataInEp->addr;
         reqData.numIsoPackets = 0;
-        reqData.callback      = AcmReadBulkCallback;
-        reqData.userData      = (void *)acm;
-        reqData.timeout       = USB_CTRL_SET_TIMEOUT;
-        reqData.length        = size;
-
+        reqData.callback = AcmReadBulkCallback;
+        reqData.userData = (void *)acm;
+        reqData.timeout = USB_CTRL_SET_TIMEOUT;
+        reqData.length = size;
         // 在批量传输请求中填写所需信息
-        ret = UsbRawFillBulkRequest(acm->readReq[i], acm->devHandle, &reqData);
+        int32_t ret = UsbRawFillBulkRequest(acm->readReq[i], acm->devHandle, &reqData);
         if (ret != HDF_SUCCESS) {
+            HDF_LOGE("%s: FillBulkRequest failed, ret=%d\n", __func__, ret);
             return HDF_FAILURE;
         }
     }
@@ -1200,12 +1246,12 @@ static int32_t UsbAllocReadRequests(struct AcmDevice *acm)
 static int32_t UsbAllocNotifyRequest(struct AcmDevice *acm)
 {
     struct UsbRawFillRequestData fillRequestData;
-    int32_t size = acm->notifyEp->maxPacketSize;
+    uint32_t size = acm->notifyEp->maxPacketSize;
     int32_t ret;
-
     // 分配一个具有指定数目的同步传输分组描述符的传输请求
     acm->notifyReq = UsbRawAllocRequest(acm->devHandle, 0, size);
     if (!acm->notifyReq) {
+        HDF_LOGE("notifyReq request fail\n");
         return HDF_ERR_MALLOC_FAIL;
     }
 
@@ -1215,10 +1261,10 @@ static int32_t UsbAllocNotifyRequest(struct AcmDevice *acm)
     fillRequestData.callback = AcmNotifyReqCallback;
     fillRequestData.userData = (void *)acm;
     fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
-
     // 在中断传输请求中填充所需的信息
     ret = UsbRawFillInterruptRequest(acm->notifyReq, acm->devHandle, &fillRequestData);
-    if (ret != HDF_SUCCESS) {
+    if (ret) {
+        HDF_LOGE("%s: FillInterruptRequest failed, ret=%d", __func__, ret);
         return HDF_FAILURE;
     }
 
@@ -1231,98 +1277,111 @@ static int32_t UsbSerialInit(struct AcmDevice *acm)
     UsbRawHandle *devHandle = NULL;
     int32_t ret;
 
-    if (acm->initFlag == true) {
+    if (acm->initFlag) {
+        HDF_LOGE("%s:%d: initFlag is true", __func__, __LINE__);
         return HDF_SUCCESS;
     }
-
     // 以专家模式初始化USB DDK
     ret = UsbRawInit(NULL);
-    if (ret != HDF_SUCCESS) {
+    if (ret) {
+        HDF_LOGE("%s:%d UsbRawInit failed", __func__, __LINE__);
         return HDF_ERR_IO;
     }
     acm->session = session;
-
     // 打开一个USB设备对象
     devHandle = UsbRawOpenDevice(session, acm->busNum, acm->devAddr);
     if (devHandle == NULL) {
-        ret =  HDF_FAILURE;
-        goto err_open_device;
+        HDF_LOGE("%s:%d UsbRawOpenDevice failed", __func__, __LINE__);
+        ret = HDF_FAILURE;
+        goto ERR_OPEN_DEVICE;
     }
     acm->devHandle = devHandle;
     // 获取主用设备配置、设备指针及配置描述符
     ret = UsbGetConfigDescriptor(devHandle, &acm->config);
-    if (ret != HDF_SUCCESS) {
-        ret =  HDF_FAILURE;
-        goto err_get_desc;
+    if (ret) {
+        HDF_LOGE("%s:%d UsbGetConfigDescriptor failed", __func__, __LINE__);
+        ret = HDF_FAILURE;
+        goto ERR_GET_DESC;
     }
     ret = UsbParseConfigDescriptor(acm, acm->config);
     if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s:%d UsbParseConfigDescriptor failed", __func__, __LINE__);
         ret = HDF_FAILURE;
-        goto err_parse_desc;
+        goto ERR_PARSE_DESC;
     }
 
     ret = AcmWriteBufAlloc(acm);
     if (ret < 0) {
+        HDF_LOGE("%s:%d AcmWriteBufAlloc failed", __func__, __LINE__);
         ret = HDF_FAILURE;
-        goto err_alloc_write_buf;
+        goto ERR_ALLOC_WRITE_BUF;
     }
     ret = UsbAllocWriteRequests(acm);
     if (ret < 0) {
+        HDF_LOGE("%s:%d UsbAllocWriteRequests failed", __func__, __LINE__);
         ret = HDF_FAILURE;
-        goto err_alloc_write_reqs;
+        goto ERR_ALLOC_WRITE_REQS;
     }
     ret = UsbAllocNotifyRequest(acm);
     if (ret) {
-        goto err_alloc_notify_req;
+        HDF_LOGE("%s:%d UsbAllocNotifyRequests failed", __func__, __LINE__);
+        goto ERR_ALLOC_NOTIFY_REQ;
     }
     ret = UsbAllocReadRequests(acm);
     if (ret) {
-        goto err_alloc_read_reqs;
+        HDF_LOGE("%s:%d UsbAllocReadRequests failed", __func__, __LINE__);
+        goto ERR_ALLOC_READ_REQS;
     }
     ret = UsbStartIo(acm);
     if (ret) {
-        goto err_start_io;
+        HDF_LOGE("%s:%d UsbAllocReadRequests failed", __func__, __LINE__);
+        goto ERR_START_IO;
     }
 
-    acm->lineCoding.dwDTERate   = CpuToLe32(DATARATE);
-    acm->lineCoding.bCharFormat = CHARFORMAT;
+    acm->lineCoding.dwDTERate = CPU_TO_LE32(DATARATE);
+    acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
     acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
-    acm->lineCoding.bDataBits   = USB_CDC_1_STOP_BITS;
+    acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
 
     ret = UsbRawSubmitRequest(acm->notifyReq);
     if (ret) {
-        goto err_submit_req;
+        HDF_LOGE("%s:%d UsbRawSubmitRequest failed", __func__, __LINE__);
+        goto ERR_SUBMIT_REQ;
     }
 
     acm->initFlag = true;
+
+    HDF_LOGD("%s:%d=========================OK", __func__, __LINE__);
+
     return HDF_SUCCESS;
 
-err_submit_req:
+ERR_SUBMIT_REQ:
     UsbStopIo(acm); // 停止IO线程并释放所有资源
-err_start_io:
+ERR_START_IO:
     UsbFreeReadRequests(acm);
-err_alloc_read_reqs:
-    UsbFreeNotifyRequest(acm);
- err_alloc_notify_req:
+ERR_ALLOC_READ_REQS:
+    UsbFreeNotifyReqeust(acm);
+ERR_ALLOC_NOTIFY_REQ:
     UsbFreeWriteRequests(acm);
-err_alloc_write_reqs:
+ERR_ALLOC_WRITE_REQS:
     AcmWriteBufFree(acm);
-err_alloc_write_buf:
+ERR_ALLOC_WRITE_BUF:
     UsbReleaseInterfaces(acm);
-err_parse_desc:
+ERR_PARSE_DESC:
     UsbRawFreeConfigDescriptor(acm->config);
     acm->config = NULL;
-err_get_desc:
+ERR_GET_DESC:
     (void)UsbRawCloseDevice(devHandle); // 关闭USB设备对象
-err_open_device:
+ERR_OPEN_DEVICE:
     UsbRawExit(acm->session); // 退出USB DDK的专家模式
 
     return ret;
 }
-
+...
 static void UsbSerialRelease(struct AcmDevice *acm)
 {
-    if (acm->initFlag == false) {
+    if (!(acm->initFlag)) {
+        HDF_LOGE("%s:%d: initFlag is false", __func__, __LINE__);
         return;
     }
 
@@ -1333,11 +1392,11 @@ static void UsbSerialRelease(struct AcmDevice *acm)
         g_syncRequest = NULL;
     }
     UsbFreeReadRequests(acm);
-    UsbFreeNotifyRequest(acm);
+    UsbFreeNotifyReqeust(acm);
     UsbFreeWriteRequests(acm);
     AcmWriteBufFree(acm);
-    (void)UsbRawCloseDevice(acm->devHandle);
     UsbReleaseInterfaces(acm);
+    (void)UsbRawCloseDevice(acm->devHandle);
     UsbRawFreeConfigDescriptor(acm->config);
     acm->config = NULL;
     // 退出USB DDK的专家模式
@@ -1352,12 +1411,16 @@ static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device)
     int32_t ret;
 
     if (device == NULL) {
+        HDF_LOGE("%s:%d device is null", __func__, __LINE__);
         return HDF_ERR_INVALID_OBJECT;
     }
     acm = (struct AcmDevice *)device->service;
+    if (acm == NULL) {
+        return HDF_ERR_INVALID_OBJECT;
+    }
     OsalMutexInit(&acm->readLock);
     OsalMutexInit(&acm->writeLock);
-
+	// 设备申请连续的内存
     ret = UsbSerialDeviceAlloc(acm);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s:%d UsbSerialDeviceAlloc failed", __func__, __LINE__);
@@ -1365,6 +1428,7 @@ static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device)
 
     acm->initFlag = false;
     g_rawAcmReleaseFlag = false;
+    HDF_LOGD("%s:%d init ok!", __func__, __LINE__);
     return ret;
 }
 
@@ -1372,17 +1436,20 @@ static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
 {
     struct AcmDevice *acm = NULL;
     if (device == NULL) {
+        HDF_LOGE("%s: device is null", __func__);
         return;
     }
 
     acm = (struct AcmDevice *)device->service;
     if (acm == NULL) {
+        HDF_LOGE("%s: acm is null", __func__);
         return;
     }
 
     g_rawAcmReleaseFlag = true;
 
-    if (acm->initFlag == true) {
+    if (acm->initFlag) {
+        HDF_LOGE("%s:%d UsbSerialRelease", __func__, __LINE__);
         UsbSerialRelease(acm);
     }
     UsbSeriaDevicelFree(acm);
@@ -1391,14 +1458,15 @@ static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
     OsalMutexDestroy(&acm->lock);
     OsalMemFree(acm);
     acm = NULL;
+    HDF_LOGD("%s:%d exit", __func__, __LINE__);
 }
 
 struct HdfDriverEntry g_usbSerialRawDriverEntry = {
     .moduleVersion = 1,
-    .moduleName    = "usbhost_acm_rawapi", // 驱动模块名称，必须与hcs文件中配置的名称一致
-    .Bind          = UsbSerialDriverBind,
-    .Init          = UsbSerialDriverInit,
-    .Release       = UsbSerialDriverRelease,
+    .moduleName = "usbhost_acm_rawapi", // 驱动模块名称，必须与hcs文件中配置的名称一致
+    .Bind = UsbSerialDriverBind,
+    .Init = UsbSerialDriverInit,
+    .Release = UsbSerialDriverRelease,
 };
 HDF_INIT(g_usbSerialRawDriverEntry);
 ```
@@ -1412,24 +1480,30 @@ USB ACM设备核心代码路径为drivers\peripheral\usb\gadget\function\acm\cdc
     ```cpp
     static int32_t AcmCreateFuncDevice(struct UsbAcmDevice *acm, struct DeviceResourceIface *iface)
     {
+        int32_t ret;
         struct UsbFnDevice *fnDev = NULL;
-        struct UsbFnDescriptorData descData;
-        uint8_t useHcs;
-        ...
-        if (useHcs == 0) { // 描述符来自于代码中编码
-            descData.type = USBFN_DESC_DATA_TYPE_DESC;
-            descData.descriptor = &g_masterFuncDevice;
-        } else { // 描述符来自于解析hcs文件
-            descData.type = USBFN_DESC_DATA_TYPE_PROP;
-            descData.property = device->property;
+    // 读取hcs文件中的udc_name节点的字符串值
+        if (iface->GetString(acm->device->property, "udc_name", (const char **)&acm->udcName, UDC_NAME) != HDF_SUCCESS) {
+            HDF_LOGE("%s: read udc_name failed, use default", __func__);
+            return HDF_FAILURE;
         }
-        /* 创建设备 */
-        fnDev = (struct UsbFnDevice *)UsbFnDeviceCreate(acm->udcName, &descData);
+
+        fnDev = (struct UsbFnDevice *)UsbFnGetDevice(acm->udcName);
         if (fnDev == NULL) {
+            HDF_LOGE("%s: create usb function device failed", __func__);
             return HDF_FAILURE;
         }
-        ...
+    // 解析acm每一个Iface
+        ret = AcmParseEachIface(acm, fnDev);
+        if (ret != HDF_SUCCESS) {
+            HDF_LOGE("%s: get pipes failed", __func__);
+            return HDF_FAILURE;
+        }
+
+        acm->fnDev = fnDev;
+        return HDF_SUCCESS;
     }
+
     ```
 
 2. 获取接口，打开接口，获取Pipe信息
@@ -1437,28 +1511,69 @@ USB ACM设备核心代码路径为drivers\peripheral\usb\gadget\function\acm\cdc
     ```cpp
     static int32_t AcmParseEachPipe(struct UsbAcmDevice *acm, struct UsbAcmInterface *iface)
     {
-        ...
-        for (i = 0; i < fnIface->info.numPipes; i++) {
+        struct UsbFnInterface *fnIface = iface->fn;
+        for (uint32_t i = 0; i < fnIface->info.numPipes; i++) {
             struct UsbFnPipeInfo pipeInfo;
+            // pipeInfo清除缓存区内容
+            (void)memset_s(&pipeInfo, sizeof(pipeInfo), 0, sizeof(pipeInfo));
             /* 获取pipe信息 */
-            ret = UsbFnInterfaceGetPipeInfo(fnIface, i, &pipeInfo);
-            ...
+            int32_t ret = UsbFnGetInterfacePipeInfo(fnIface, i, &pipeInfo);
+            if (ret != HDF_SUCCESS) {
+                HDF_LOGE("%s: get pipe info error", __func__);
+                return ret;
+            }
+            // PIPE的中断和管脚
+            switch (pipeInfo.type) {
+                case USB_PIPE_TYPE_INTERRUPT:
+                    acm->notifyPipe.id = pipeInfo.id;
+                    acm->notifyPipe.maxPacketSize = pipeInfo.maxPacketSize;
+                    acm->ctrlIface = *iface;
+                    break;
+                case USB_PIPE_TYPE_BULK:
+                    if (pipeInfo.dir == USB_PIPE_DIRECTION_IN) {
+                        acm->dataInPipe.id = pipeInfo.id;
+                        acm->dataInPipe.maxPacketSize = pipeInfo.maxPacketSize;
+                        acm->dataIface = *iface;
+                    } else {
+                        acm->dataOutPipe.id = pipeInfo.id;
+                        acm->dataOutPipe.maxPacketSize = pipeInfo.maxPacketSize;
+                    }
+                    break;
+                default:
+                    HDF_LOGE("%s: pipe type %d don't support", __func__, pipeInfo.type);
+                    break;
+            }
         }
+
         return HDF_SUCCESS;
     }
     /* 获取接口，打开接口获取handle */ 
     static int32_t AcmParseEachIface(struct UsbAcmDevice *acm, struct UsbFnDevice *fnDev)
     {
-        ...
+        struct UsbFnInterface *fnIface = NULL;
+        uint32_t i;
+        if (fnDev == NULL) {
+            return HDF_FAILURE;
+        }
         for (i = 0; i < fnDev->numInterfaces; i++) {
-            /* 获取接口 */
             fnIface = (struct UsbFnInterface *)UsbFnGetInterface(fnDev, i);
-            ...
-            /* 打开接口 */
-            handle = UsbFnInterfaceOpen(fnIface);
-            ...
+            if (fnIface == NULL) {
+                HDF_LOGE("%s: get interface failed", __func__);
+                return HDF_FAILURE;
+            }
+
+            if (fnIface->info.subclass == USB_DDK_CDC_SUBCLASS_ACM) {
+                (void)AcmParseAcmIface(acm, fnIface);
+                fnIface = (struct UsbFnInterface *)UsbFnGetInterface(fnDev, i + 1);
+                if (fnIface == NULL) {
+                    HDF_LOGE("%s: get interface failed", __func__);
+                    return HDF_FAILURE;
+                }
+                (void)AcmParseAcmIface(acm, fnIface);
+                return HDF_SUCCESS;
+            }
         }
-        return HDF_SUCCESS;
+        return HDF_FAILURE;
     }
     ```
 
@@ -1467,30 +1582,77 @@ USB ACM设备核心代码路径为drivers\peripheral\usb\gadget\function\acm\cdc
     ```cpp
     static int32_t AcmAllocCtrlRequests(struct UsbAcmDevice *acm, int32_t num)
     {
-        ...
-        req = UsbFnCtrlRequestAlloc(acm->ctrlIface.handle,
-            sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
-        ...
-    }
-    static int32_t AcmDriverInit(struct HdfDeviceObject *device)
-    {
-        ...    
-        /* 开始接收Event */ 
-        ret = UsbFnInterfaceStartRecvEvent(acm->ctrlIface.fn, 0xff, UsbAcmEventCallback, acm);
-        ...
+        struct DListHead *head = &acm->ctrlPool;
+        struct UsbFnRequest *req = NULL;
+        struct CtrlInfo *ctrlInfo = NULL;
+        int32_t i;
+
+        DListHeadInit(&acm->ctrlPool);
+        acm->ctrlReqNum = 0;
+
+        for (i = 0; i < num; i++) {
+            // 申请内存
+            ctrlInfo = (struct CtrlInfo *)OsalMemCalloc(sizeof(*ctrlInfo));
+            if (ctrlInfo == NULL) {
+                HDF_LOGE("%s: Allocate ctrlInfo failed", __func__);
+                goto OUT;
+            }
+            ctrlInfo->acm = acm;
+            req = UsbFnAllocCtrlRequest(
+                acm->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
+            if (req == NULL) {
+                goto OUT;
+            }
+            req->complete = AcmCtrlComplete;
+            req->context = ctrlInfo;
+            DListInsertTail(&req->list, head);
+            acm->ctrlReqNum++;
+        }
+        return HDF_SUCCESS;
+
+    OUT:
+        return DListIsEmpty(head) ? HDF_FAILURE : HDF_SUCCESS;
     }
     ```
 
 4. 进行USB通信（读写等）
 
     ```cpp
-    static int32_t AcmSendNotifyRequest(struct UsbAcmDevice *acm, uint8_t type,
-        uint16_t value, void *data, uint32_t length)
+    static int32_t AcmSendNotifyRequest(
+        struct UsbAcmDevice *acm, uint8_t type, uint16_t value, const void *data, uint32_t length)
     {
-        ...
-        /* 异步发送 */ 
-        ret = UsbFnRequestSubmitAsync(req);
-        ...
+        struct UsbFnRequest *req = acm->notifyReq;
+        struct UsbCdcNotification *notify = NULL;
+        int32_t ret;
+
+        if (req == NULL || req->buf == NULL) {
+            HDF_LOGE("%s: req is null", __func__);
+            return HDF_FAILURE;
+        }
+
+        acm->notifyReq = NULL;
+        acm->pending = false;
+        req->length = sizeof(*notify) + length;
+
+        notify = (struct UsbCdcNotification *)req->buf;
+        notify->bmRequestType = USB_DDK_DIR_IN | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
+        notify->bNotificationType = type;
+        notify->wValue = CPU_TO_LE16(value);
+        notify->wIndex = CPU_TO_LE16(acm->ctrlIface.fn->info.index);
+        notify->wLength = CPU_TO_LE16(length);
+        ret = memcpy_s((void *)(notify + 1), length, data, length);
+        if (ret != EOK) {
+            HDF_LOGE("%s: memcpy_s failed", __func__);
+            return HDF_FAILURE;
+        }
+
+        ret = UsbFnSubmitRequestAsync(req);
+        if (ret != HDF_SUCCESS) {
+            HDF_LOGE("%s: send notify request failed", __func__);
+            acm->notifyReq = req;
+        }
+
+        return ret;
     }
     ```
 
@@ -1512,6 +1674,22 @@ USB ACM设备核心代码路径为drivers\peripheral\usb\gadget\function\acm\cdc
         }
         return ret;
     }
+    static int32_t AcmReleaseFuncDevice(struct UsbAcmDevice *acm)
+    {
+        int32_t ret = HDF_SUCCESS;
+        if (acm->fnDev == NULL) {
+            HDF_LOGE("%s: fnDev is null", __func__);
+            return HDF_FAILURE;
+        }
+        //释放通知请求
+        AcmFreeCtrlRequests(acm);
+        AcmFreeNotifyRequest(acm);
+         /* 停止接收Event EP0控制传输 */
+        (void)UsbFnCloseInterface(acm->ctrlIface.handle);
+        (void)UsbFnCloseInterface(acm->dataIface.handle);
+        (void)UsbFnStopRecvInterfaceEvent(acm->ctrlIface.fn);
+        return ret;
+    }
     ```
 
 ## 参考