!3981 【OpenHarmony开源贡献者计划2022】peripherals相关格式及表达问题

Merge pull request !3981 from king_he/peripheral-3

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

@@ -5,7 +5,7 @@
 
 ### 功能简介
 
-Sensor驱动模型屏蔽硬件器件差异，为上层Sensor服务系统提供稳定的Sensor基础能力接口，包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅，Sensor参数配置等功能；Sensor设备驱动的开发是基于HDF驱动框架基础上，结合操作系统适配层（OSAL）和平台驱动接口（比如I2C/SPI/UART总线等平台资源）能力，屏蔽不同操作系统和平台总线资源差异，实现Sensor驱动“一次开发，多系统部署”的目标。Sensor驱动模型如图1所示。
+Sensor驱动模型屏蔽硬件器件差异，为上层Sensor服务系统提供稳定的Sensor基础能力接口，包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅，Sensor参数配置等功能。Sensor设备驱动的开发是基于HDF驱动框架基础上，结合操作系统适配层（OSAL）和平台驱动接口（比如I2C/SPI/UART总线等平台资源）能力，屏蔽不同操作系统和平台总线资源差异，实现Sensor驱动“一次开发，多系统部署”的目标。Sensor驱动模型如图1所示。
 
 **图 1**  Sensor驱动模型图
  
@@ -29,13 +29,13 @@ Sensor驱动模型屏蔽硬件器件差异，为上层Sensor服务系统提供
 
 Sensor驱动模型以标准系统Hi3516DV300产品中的加速度传感器驱动为例，介绍整个驱动加载及运行流程：
 
-1. 从device info HCS 的Sensor Host读取Sensor设备管理配置信息。
+1. 从device_info.hcs配置文件的Sensor Host读取Sensor设备管理配置信息。
 2. HDF配置框架从HCB数据库解析Sensor设备管理配置信息，并关联对应设备驱动。
 3. 加载并初始化Sensor设备管理驱动。
 4. Sensor设备管理驱动向HDI发布Sensor基础能力接口。
-5. 从device info HCS 的Sensor Host读取加速度传感器驱动配置信息。
+5. 从device_info.hcs配置文件的Sensor Host读取加速度传感器驱动配置信息。
 6. 加载加速度传感器抽象驱动，调用初始化接口，完成Sensor器件驱动资源分配和数据处理队列创建。
-7. 从accel_xxx_config HCS读取加速度传感器差异化驱动配置和私有化配置信息。
+7. 从accel_xxx_config.hcs配置文件读取加速度传感器差异化驱动配置和私有化配置信息。
 8. 加速度传感器差异化驱动，调用通用配置解析接口，完成器件属性信息解析，器件寄存器解析。
 9. 加速度传感器差异化驱动完成器件探测，并分配加速度传感器配置资源，完成加速度传感器差异化接口注册。
 10. 加速度传感器探测成功之后，加速度传感器差异化驱动通知加速度传感器抽象驱动，注册加速度传感器设备到Sensor设备管理中。
@@ -54,11 +54,11 @@ Sensor驱动模型以标准系统Hi3516DV300产品中的加速度传感器驱动
 
 Sensor驱动模型对外开放的API接口能力如下：
 
-- 提供Sensor HDI（Hardware  Device  Interface）能力接口，简化服务开发。
+- 提供Sensor HDI（Hardware Device Interface）能力接口，简化服务开发。
 - 提供Sensor驱动模型能力接口：
   - 依赖HDF驱动框架实现Sensor器件驱动的注册，加载，去注册，器件探测等能力。
   - 提供同一类型Sensor器件驱动归一接口, 寄存器配置解析操作接口，总线访问抽象接口，平台抽象接口。
-- 提供开发者实现的能力接口：依赖HDF驱动框架的HCS（HDF  Configuration  Source）配置管理，根据同类型Sensor差异化配置，实现Sensor器件参数序列化配置和器件部分操作接口，简化Sensor器件驱动开发。
+- 提供开发者实现的能力接口：依赖HDF驱动框架的HCS（HDF Configuration Source）配置管理，根据同类型Sensor差异化配置，实现Sensor器件参数序列化配置和器件部分操作接口，简化Sensor器件驱动开发。
 
 Sensor驱动模型对外开放的API接口能力的具体实现请参考：
 
@@ -122,14 +122,14 @@ Sensor驱动模型要求驱动开发者实现的接口功能，请参考：
      ```c
      /* 注册加速度计传感器入口数据结构体对象 */
      struct HdfDriverEntry g_sensorAccelDevEntry = {
-         .moduleVersion = 1, //加速度计传感器模块版本号
-         .moduleName = "HDF_SENSOR_ACCEL", //加速度计传感器模块名，要与device_info.hcs文件里的加速度计moduleName字段值一样
+         .moduleVersion = 1, // 加速度计传感器模块版本号
+         .moduleName = "HDF_SENSOR_ACCEL", // 加速度计传感器模块名，要与device_info.hcs文件里的加速度计moduleName字段值一样
          .Bind = BindAccelDriver, // 加速度计传感器绑定函数
          .Init = InitAccelDriver, // 加速度计传感器初始化函数
          .Release = ReleaseAccelDriver, // 加速度计传感器资源释放函数
      };
      
-     /* 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 */
+     /* 调用HDF_INIT将驱动入口注册到HDF框架中。在加载驱动时HDF框架会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 */
      HDF_INIT(g_sensorAccelDevEntry);
      ```
 
@@ -523,8 +523,8 @@ Sensor驱动模型要求驱动开发者实现的接口功能，请参考：
 驱动开发完成后，在传感器单元测试里面开发自测试用例，验证驱动基本功能。测试环境采用开发者自测试平台。
 
 ```
-static int32_t g_sensorDataFlag = 0; //标识是否上报传感器数据
-static const struct SensorInterface *g_sensorDev = nullptr; //保持获取的传感器接口实例地址
+static int32_t g_sensorDataFlag = 0; // 标识是否上报传感器数据
+static const struct SensorInterface *g_sensorDev = nullptr; // 保持获取的传感器接口实例地址
 
 /* 订阅者注册数据上报函数 */
 static int SensorTestDataCallback(struct SensorEvents *event)

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

@@ -34,7 +34,7 @@
 
 ## 接口说明
 
-Touchscreen器件的硬件接口相对简单，根据PIN脚的属性，可以简单分为如下三类:
+Touchscreen器件的硬件接口相对简单，根据PIN脚的属性，可以简单分为如下三类：
 
 - 电源接口
 
@@ -93,7 +93,7 @@ Input驱动模型是基于HDF框架、Platform接口和OSAL接口开发，不区
    配置对应的IO管脚功能，例如对单板上为Touchscreen设计预留的I2C Pin脚，需设置对应的寄存器，使其选择I2C的通信功能。
 
 3. 实现器件差异化适配接口
-   根据硬件单板设计的通信接口，使用Platform接口层提供的管脚操作接口配置对应的复位管脚、中断管脚以及电源操作，对于GPIO的操作，可参考[GPIO操作接口指导](../driver/driver-platform-gpio-des.md#概述)
+   根据硬件单板设计的通信接口，使用Platform接口层提供的管脚操作接口配置对应的复位管脚、中断管脚以及电源操作，对于GPIO的操作，可参考[GPIO操作接口指导](../driver/driver-platform-gpio-des.md#概述)。
 
 
 ## 开发实例
@@ -114,7 +114,7 @@ input :: host {
                 device0 :: deviceNode {
                     policy = 2;        // 向外发布服务
                     priority = 100;    // 加载优先级，在input模块内，manager模块优先级应为最高
-                    preload = 0;       // 加载该驱动 0:加载 1:不加载
+                    preload = 0;       // 加载该驱动，0：加载；1：不加载
                     permission = 0660;
                     moduleName = "HDF_INPUT_MANAGER";
                     serviceName = "input_dev_manager";

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

@@ -89,8 +89,8 @@ USB驱动模型Device侧开放的API接口功能，参考USB Device驱动模型
 | 接口名称 | 功能描述 | 
 | -------- | -------- |
 | const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnCreateDevice(const<br/>char&nbsp;\*udcName,&nbsp;const&nbsp;struct&nbsp;UsbFnDescriptorData<br/>\*descriptor); | 创建Usb设备 | 
-| int&nbsp;UsbFnRemoveDevice(struct&nbsp;UsbFnDevice<br/>\*fnDevice); | 删除Usb设备 | 
-| const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnGetDevice(const&nbsp;char<br/>\*udcName); | 获取Usb设备 | 
+| int&nbsp;UsbFnRemoveDevice(struct&nbsp;UsbFnDevice<br/>\*fnDevice); | 删除USB设备 | 
+| const&nbsp;struct&nbsp;UsbFnDevice&nbsp;\*UsbFnGetDevice(const&nbsp;char<br/>\*udcName); | 获取USB设备 | 
 
   **表4** usbfn_interface.h
 
@@ -182,37 +182,37 @@ root {
                 "host_acm_table"
             ];
             host_acm_table {
-                //驱动模块名，该字段的值必须和驱动入口结构的moduleName一致
+                // 驱动模块名，该字段的值必须和驱动入口结构的moduleName一致
                 moduleName = "usbhost_acm";
-                //驱动对外发布服务的名称，必须唯一
+                // 驱动对外发布服务的名称，必须唯一
                 serviceName = "usbhost_acm_pnp_service";
-                //驱动私有数据匹配关键字
+                // 驱动私有数据匹配关键字
                 deviceMatchAttr = "usbhost_acm_pnp_matchAttr";
-                //从该字段开始（包含该字段）之后数据长度，以byte为单位
+                // 从该字段开始（包含该字段）之后数据长度，以byte为单位
                 length = 21;
-                //USB驱动匹配规则vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber
+                // USB驱动匹配规则vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber
                 matchFlag = 0x0303;
-                //厂商编号
+                // 厂商编号
                 vendorId = 0x12D1;
-                //产品编号
+                // 产品编号
                 productId = 0x5000;
-                //设备出厂编号，低16位
+                // 设备出厂编号，低16位
                 bcdDeviceLow = 0x0000;
-                //设备出厂编号，高16位
+                // 设备出厂编号，高16位
                  bcdDeviceHigh = 0x0000;
-                //USB分配的设备类代码
+                // USB分配的设备类代码
                 deviceClass = 0;
-                //USB分配的子类代码
+                // USB分配的子类代码
                 deviceSubClass = 0;
-                //USB分配的设备协议代码
+                // USB分配的设备协议代码
                 deviceProtocol = 0;
-                //接口类型，根据实际需要可填写多个
+                // 接口类型，根据实际需要可填写多个
                 interfaceClass = [0];
-                //接口子类型，根据实际需要可填写多个
+                // 接口子类型，根据实际需要可填写多个
                 interfaceSubClass = [2, 0];
-                //接口所遵循的协议，根据实际需要可填写多个    
+                // 接口所遵循的协议，根据实际需要可填写多个    
                 interfaceProtocol = [1, 2];
-                //接口的编号，根据实际需要可填写多个
+                // 接口的编号，根据实际需要可填写多个
                 interfaceNumber = [2, 3];
             }
         }
@@ -291,7 +291,7 @@ static struct UsbInterface *GetUsbInterfaceById(const struct AcmDevice *acm,
 {
     struct UsbInterface *tmpIf = NULL;
     tmpIf = (struct UsbInterface *)UsbClaimInterface(acm->session, acm->busNum, 
-            acm->devAddr, interfaceIndex);    //获取UsbInterface接口对象
+            acm->devAddr, interfaceIndex);    // 获取UsbInterface接口对象
     return tmpIf;
 }
 ...
@@ -315,7 +315,7 @@ static struct UsbPipeInfo *EnumePipe(const struct AcmDevice *acm,
 
     for (i = 0;  i <= info->pipeNum; i++) {
         struct UsbPipeInfo p;
-        ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &p);//获取指定索引为i的pipeInfo信息
+        ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &p);// 获取指定索引为i的pipeInfo信息
         if (ret < 0) {
             continue;
         }
@@ -413,7 +413,7 @@ static int AcmAllocReadRequests(struct AcmDevice *acm)
     int ret;
     struct UsbRequestParams readParams;
     for (int i = 0; i < ACM_NR; i++) {
-        acm->readReq[i] = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), 0, acm->readSize);    //分配待发送的readReq IO Request对象
+        acm->readReq[i] = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), 0, acm->readSize);    // 分配待发送的readReq IO Request对象
         if (!acm->readReq[i]) {
             HDF_LOGE("readReq request failed");
             goto error;
@@ -428,7 +428,7 @@ static int AcmAllocReadRequests(struct AcmDevice *acm)
         readParams.dataReq.numIsoPackets = 0;
         readParams.dataReq.direction = (acm->dataInPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1;
         readParams.dataReq.length = acm->readSize;
-        ret = UsbFillRequest(acm->readReq[i], InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), &readParams);    //填充待发送的readReq对象
+        ret = UsbFillRequest(acm->readReq[i], InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), &readParams);    // 填充待发送的readReq对象
         if (HDF_SUCCESS != ret) {
             HDF_LOGE("%s: UsbFillRequest failed, ret=%d n", __func__, ret);
             goto error;
@@ -445,7 +445,7 @@ static int AcmAllocNotifyRequest(struct AcmDevice *acm)
 {
     int ret;
     struct UsbRequestParams intParams = {};
-    acm->notifyReq = UsbAllocRequest(InterfaceIdToHandle(acm, acm->intPipe->interfaceId), 0, acm->intSize);    //分配待发送的中断IO Request对象
+    acm->notifyReq = UsbAllocRequest(InterfaceIdToHandle(acm, acm->intPipe->interfaceId), 0, acm->intSize);    // 分配待发送的中断IO Request对象
     if (!acm->notifyReq) {
         HDF_LOGE("notifyReq request failed");
         return HDF_ERR_MALLOC_FAIL;
@@ -460,7 +460,7 @@ static int AcmAllocNotifyRequest(struct AcmDevice *acm)
     intParams.dataReq.numIsoPackets = 0;
     intParams.dataReq.direction = (acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK;
     intParams.dataReq.length = acm->intSize;
-    ret = UsbFillRequest(acm->notifyReq, InterfaceIdToHandle(acm, acm->intPipe->interfaceId), &intParams);    //填充预先分配的中断IO Request
+    ret = UsbFillRequest(acm->notifyReq, InterfaceIdToHandle(acm, acm->intPipe->interfaceId), &intParams);    // 填充预先分配的中断IO Request
     if (HDF_SUCCESS != ret) {
         HDF_LOGE("%s: UsbFillRequest failed, ret=%d n", __func__, ret);
         goto error;
@@ -489,14 +489,14 @@ static void AcmReleaseInterfaces(struct AcmDevice *acm)
 static int32_t AcmClaimInterfaces(struct AcmDevice *acm)
 {
     for (int i = 0; i < acm->interfaceCnt; i++) {
-        acm->iface[i] = GetUsbInterfaceById((const struct AcmDevice *)acm, acm->interfaceIndex[i]);    //获取UsbInterface接口对象
+        acm->iface[i] = GetUsbInterfaceById((const struct AcmDevice *)acm, acm->interfaceIndex[i]);    // 获取UsbInterface接口对象
         if (acm->iface[i] == NULL) {
             HDF_LOGE("%s: interface%d is null", __func__, acm->interfaceIndex[i]);
             goto error;
         }
     }
 
-    acm->ctrIface = GetUsbInterfaceById((const struct AcmDevice *)acm, USB_CTRL_INTERFACE_ID);    //获取控制接口对应的UsbInterface接口对象
+    acm->ctrIface = GetUsbInterfaceById((const struct AcmDevice *)acm, USB_CTRL_INTERFACE_ID);    // 获取控制接口对应的UsbInterface接口对象
     if (acm->ctrIface == NULL) {
         HDF_LOGE("%s: GetUsbInterfaceById null", __func__);
         goto error;
@@ -527,7 +527,7 @@ static int32_t AcmOpenInterfaces(struct AcmDevice *acm)
 {
     for (int i = 0; i < acm->interfaceCnt; i++) {
         if (acm->iface[i]) {
-            acm->devHandle[i] = UsbOpenInterface(acm->iface[i]);    //打开获取到的UsbInterface接口对象
+            acm->devHandle[i] = UsbOpenInterface(acm->iface[i]);    // 打开获取到的UsbInterface接口对象
             if (acm->devHandle[i] == NULL) {
                 HDF_LOGE("%s: UsbOpenInterface null", __func__);
                 goto error;
@@ -549,25 +549,25 @@ error:
 
 static int32_t AcmGetPipes(struct AcmDevice *acm)
 {
-    acm->dataInPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_IN);//获取dataInPipe的pipeInfo信息
+    acm->dataInPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_IN);// 获取dataInPipe的pipeInfo信息
     if (acm->dataInPipe == NULL) {
         HDF_LOGE("dataInPipe is NULL");
         goto error;
     }
 
-    acm->dataOutPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_OUT);//获取dataOutPipe的pipeInfo信息
+    acm->dataOutPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_OUT);// 获取dataOutPipe的pipeInfo信息
     if (acm->dataOutPipe == NULL) {
         HDF_LOGE("dataOutPipe is NULL");
         goto error;
     }
 
-    acm->ctrPipe = EnumePipe(acm, acm->ctrIface->info.interfaceIndex, USB_PIPE_TYPE_CONTROL, USB_PIPE_DIRECTION_OUT);    //获取控制pipe的pipeInfo信息
+    acm->ctrPipe = EnumePipe(acm, acm->ctrIface->info.interfaceIndex, USB_PIPE_TYPE_CONTROL, USB_PIPE_DIRECTION_OUT);    // 获取控制pipe的pipeInfo信息
     if (acm->ctrPipe == NULL) {
         HDF_LOGE("ctrPipe is NULL");
         goto error;
     }
 
-    acm->intPipe = GetPipe(acm, USB_PIPE_TYPE_INTERRUPT, USB_PIPE_DIRECTION_IN);//获取中断pipe的pipeInfo信息
+    acm->intPipe = GetPipe(acm, USB_PIPE_TYPE_INTERRUPT, USB_PIPE_DIRECTION_IN);// 获取中断pipe的pipeInfo信息
     if (acm->intPipe == NULL) {
         HDF_LOGE("intPipe is NULL");
         goto error;
@@ -616,13 +616,13 @@ static int32_t AcmAllocRequests(struct AcmDevice *acm)
         }
     }
 
-    ret = AcmAllocNotifyRequest(acm);    //分配并填充中断IO Request对象
+    ret = AcmAllocNotifyRequest(acm);    // 分配并填充中断IO Request对象
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s:%d AcmAllocNotifyRequest failed", __func__, __LINE__);
         goto error_alloc_int_req;
     }
 
-    ret = AcmAllocReadRequests(acm);    //分配并填充readReq IO Request对象
+    ret = AcmAllocReadRequests(acm);    // 分配并填充readReq IO Request对象
     if (ret) {
         HDF_LOGE("%s:%d AcmAllocReadRequests failed", __func__, __LINE__);
         goto error_alloc_read_req;
@@ -649,7 +649,7 @@ static int32_t AcmInit(struct AcmDevice *acm)
         return HDF_SUCCESS;
     }
 
-    ret = UsbInitHostSdk(NULL);    //初始化Host DDK
+    ret = UsbInitHostSdk(NULL);    // 初始化Host DDK
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: UsbInitHostSdk failed", __func__);
         return HDF_ERR_IO;
@@ -777,7 +777,7 @@ static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
 
 struct HdfDriverEntry g_usbSerialDriverEntry = {
     .moduleVersion = 1,
-    .moduleName    = "usbhost_acm",    //驱动模块名称，必须与hcs文件中配置的名称一致
+    .moduleName    = "usbhost_acm",    // 驱动模块名称，必须与hcs文件中配置的名称一致
     .Bind          = UsbSerialDriverBind,
     .Init          = UsbSerialDriverInit,
     .Release       = UsbSerialDriverRelease,
@@ -799,38 +799,38 @@ root {
             idTableList = [
                 "host_acm_rawapi_table"
             ];
-            host_acm_rawapi_table {    //驱动配置匹配表信息
-                //驱动模块名，该字段的值必须和驱动入口结构的moduleName一致
+            host_acm_rawapi_table {    // 驱动配置匹配表信息
+                // 驱动模块名，该字段的值必须和驱动入口结构的moduleName一致
                 moduleName = "usbhost_acm_rawapi";
-                //驱动对外发布服务的名称，必须唯一
+                // 驱动对外发布服务的名称，必须唯一
                 serviceName = "usbhost_acm_rawapi_service";
-                //驱动私有数据匹配关键字
+                // 驱动私有数据匹配关键字
                 deviceMatchAttr = "usbhost_acm_rawapi_matchAttr";
-                //从该字段开始（包含该字段）之后数据长度，以byte为单位
+                // 从该字段开始（包含该字段）之后数据长度，以byte为单位
                 length = 21;
-                //USB驱动匹配规则vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber
+                // USB驱动匹配规则vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber
                 matchFlag = 0x0303;
-                //厂商编号
+                // 厂商编号
                 vendorId = 0x12D1;
-                //产品编号
+                // 产品编号
                 productId = 0x5000;
-                //设备出厂编号，低16位
+                // 设备出厂编号，低16位
                 bcdDeviceLow = 0x0000;
-                //设备出厂编号，高16位
+                // 设备出厂编号，高16位
                 bcdDeviceHigh = 0x0000;
-                //USB分配的设备类代码
+                // USB分配的设备类代码
                 deviceClass = 0;
-                //USB分配的子类代码
+                // USB分配的子类代码
                 deviceSubClass = 0;
-                //USB分配的设备协议代码
+                // USB分配的设备协议代码
                 deviceProtocol = 0;
-                //接口类型，根据实际需要可填写多个
+                // 接口类型，根据实际需要可填写多个
                 interfaceClass = [0];
-                //接口子类型，根据实际需要可填写多个
+                // 接口子类型，根据实际需要可填写多个
                 interfaceSubClass = [2, 0];
-                //接口所遵循的协议，根据实际需要可填写多个
+                // 接口所遵循的协议，根据实际需要可填写多个
                 interfaceProtocol = [1, 2];
-                //接口的编号，根据实际需要可填写多个
+                // 接口的编号，根据实际需要可填写多个
                 interfaceNumber = [2, 3];
             }
         }
@@ -1224,7 +1224,7 @@ HDF_INIT(g_usbSerialRawDriverEntry);
 
 ### Device DDK API驱动开发
 
-USB ACM设备核心代码路径为drivers\peripheral\usb\gadget\function\acm\cdcacm.c，其使用示例如下所示，首先根据描述符创建设备，然后获取接口，打开接口，获取Pipe信息，接收Event事件，接着进行USB通信（读写等），设备卸载时候，关闭接口，停止Event接收，删除设备。
+USB ACM设备核心代码路径为drivers\peripheral\usb\gadget\function\acm\cdcacm.c。其使用示例如下所示，首先根据描述符创建设备，然后获取接口，打开接口，获取Pipe信息，接收Event事件，接着进行USB通信（读写等），设备卸载时候，关闭接口，停止Event接收，删除设备。
 
   
 ```

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

@@ -5,7 +5,7 @@
 
 ### 功能简介
 
-为了快速开发传感器驱动，基于HDF（Hardware Driver Foundation）驱动框架开发了马达驱动模型。马达驱动模型，屏蔽设备驱动与系统交互的实现，为硬件服务层提供统一稳定的驱动接口能力，为驱动开发者提供开放的接口和解析接口的能力。用于不同操作系统马达设备部件的部署指导和马达设备部件驱动的开发。马达驱动模型如图1所示：
+为了快速开发传感器驱动，基于HDF（Hardware Driver Foundation）驱动框架开发了马达（Vibrator）驱动模型。马达驱动模型，屏蔽设备驱动与系统交互的实现，为硬件服务层提供统一稳定的驱动接口能力，为驱动开发者提供开放的接口和解析接口的能力。用于不同操作系统马达设备部件的部署指导和马达设备部件驱动的开发。马达驱动模型如图1所示：
 
 **图 1** 马达驱动模型图
 
@@ -21,7 +21,7 @@
 
 - 周期振动
 
-  周期振动是指按照预置的效果模式控制振动。例如： 预置效果为“haptic.clock.timer” = [600, 600, 200, 600]，等待600ms，振动600ms，等待200ms，振动600ms。
+  周期振动是指按照预置的效果模式控制振动。例如：预置效果为“haptic.clock.timer” = [600, 600, 200, 600]，等待600ms，振动600ms，等待200ms，振动600ms。
 
 ### 运作机制
 
@@ -33,9 +33,9 @@
 
 马达驱动模型以标准系统Hi3516DV300产品为例，介绍整个驱动加载及运行流程：
 
-1. 从device info HCS 的Vibrator Host读取Vibrator管理配置信息。
+1. 从device_info.hcs配置文件中的Vibrator Host读取Vibrator管理配置信息。
 2. 解析Vibrator管理配置信息，并关联对应马达抽象驱动。
-3. 从linear_vibrator_config HCS读取Vibrator数据配置信息。
+3. 从linear_vibrator_config.hcs配置文件中读取Vibrator数据配置信息。
 4. 解析Vibrator数据配置信息，并关联对应Haptic驱动。
 5. 客户端下发Vibrator Stub控制到服务端。
 6. Vibrator Stub控制调用马达服务。
@@ -48,7 +48,7 @@
 
 ### 场景介绍
 
-当设备需要设置不同的振动效果时，可以调用 Vibrator 模块，例如，设备的按键可以设置不同强度和时长的振动，闹钟和来电可以设置不同强度和时长的单次或周期性振动。
+当设备需要设置不同的振动效果时，可以调用Vibrator模块，例如，设备的按键可以设置不同强度和时长的振动，闹钟和来电可以设置不同强度和时长的单次或周期性振动。
 
 ### 接口说明
 
@@ -64,7 +64,7 @@
 
 ### 开发步骤
 
-Vibrator驱动模型为上层马达硬件服务层提供稳定的马达控制能力接口，包括马达一次振动、马达效果配置震动、马达停止。基于HDF（Hardware Driver Foundation）驱动框架开发的马达驱动模型，实现跨操作系统迁移、器件差异配置等功能。马达具体的开发步骤如下：
+Vibrator驱动模型为上层马达硬件服务层提供稳定的马达控制能力接口，包括马达一次振动、马达效果配置震动、马达停止。基于HDF驱动框架开发的马达驱动模型，实现跨操作系统迁移、器件差异配置等功能。马达具体的开发步骤如下：
 
 1. 基于HDF驱动框架，按照驱动Driver Entry程序，完成马达抽象驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现，配置资源和HCS解析。
 
@@ -73,11 +73,11 @@ Vibrator驱动模型为上层马达硬件服务层提供稳定的马达控制能
      ```c
      /* 注册马达抽象驱动入口数据结构体对象 */
      struct HdfDriverEntry g_vibratorDriverEntry = {
-         .moduleVersion = 1, //马达模块版本号
-         .moduleName = "HDF_VIBRATOR", //马达模块名，要与device_info.hcs文件里的马达moduleName字段值一样
-         .Bind = BindVibratorDriver, //马达绑定函数
-         .Init = InitVibratorDriver, //马达初始化函数
-        .Release = ReleaseVibratorDriver, //马达资源释放函数
+         .moduleVersion = 1, // 马达模块版本号
+         .moduleName = "HDF_VIBRATOR", // 马达模块名，要与device_info.hcs文件里的马达moduleName字段值一样
+         .Bind = BindVibratorDriver, // 马达绑定函数
+         .Init = InitVibratorDriver, // 马达初始化函数
+        .Release = ReleaseVibratorDriver, // 马达资源释放函数
      };
      
      HDF_INIT(g_vibratorDriverEntry);
@@ -154,13 +154,13 @@ Vibrator驱动模型为上层马达硬件服务层提供稳定的马达控制能
                  hostName = "vibrator_host";
                  device_vibrator :: device {
                      device0 :: deviceNode {
-                         policy = 2; //驱动服务发布的策略
-                         priority = 100; //驱动启动优先级（0-200），值越大优先级越低，建议配置100，优先级相同则不保证device的加载顺序
-                         preload = 0; //驱动按需加载字段，0表示加载，2表示不加载
-                         permission = 0664; //驱动创建设备节点权限
-                         moduleName = "HDF_VIBRATOR"; //驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
-                         serviceName = "hdf_misc_vibrator"; //驱动对外发布服务的名称，必须唯一 
-                         deviceMatchAttr = "hdf_vibrator_driver"; //驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
+                         policy = 2; // 驱动服务发布的策略
+                         priority = 100; // 驱动启动优先级（0-200），值越大优先级越低，建议配置100，优先级相同则不保证device的加载顺序
+                         preload = 0; // 驱动按需加载字段，0表示加载，2表示不加载
+                         permission = 0664; // 驱动创建设备节点权限
+                         moduleName = "HDF_VIBRATOR"; // 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
+                         serviceName = "hdf_misc_vibrator"; // 驱动对外发布服务的名称，必须唯一 
+                         deviceMatchAttr = "hdf_vibrator_driver"; // 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
                      }
                  }
      ```
@@ -201,23 +201,23 @@ Vibrator驱动模型为上层马达硬件服务层提供稳定的马达控制能
      }
      ```
 
-   - 马达效果模型使用HCS作为配置描述源码，HCS配置字段详细介绍参考[配置管理](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/driver/driver-hdf-manage.md)。
+   - 马达效果模型使用HCS作为配置描述源码，hcs配置文件字段详细介绍参考[配置管理](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/driver/driver-hdf-manage.md)。
 
      ```
      /* 马达数据配置模板（vibrator_config.hcs） */
      root {
          vibratorConfig {
              boardConfig {
-                 match_attr = "hdf_vibrator_driver"; //需要和马达设备配置match_attr字段保持一致
+                 match_attr = "hdf_vibrator_driver"; // 需要和马达设备配置match_attr字段保持一致
                  vibratorAttr {
-                     /* 0:转子 1:线性 */
-                     deviceType = 1; //设备类型
-                     supportPreset = 1; //支持的预设类型
+                     /* 0：转子；1：线性 */
+                     deviceType = 1; // 设备类型
+                     supportPreset = 1; // 支持的预设类型
                  }
                  vibratorHapticConfig {
                      haptic_clock_timer {
                          effectName = "haptic.clock.timer";
-                         type = 1; // 0 内置模式, 1 时间序列
+                         type = 1; // 0：内置模式；1：时间序列
                          seq = [600, 600, 200, 600]; // 时间序列
                      }
                      haptic_default_effect {

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

 # 外设驱动使用
 
 
+- **[Audio](driver-peripherals-audio-des.md)**
+
+- **[Camera](driver-peripherals-camera-des.md)**
+
+- **[WLAN](driver-peripherals-external-des.md)**
+
+- **[Face_auth](driver-peripherals-face_auth-des.md)**
 
 - **[LCD](driver-peripherals-lcd-des.md)**
 
-- **[Touchscreen](driver-peripherals-touch-des.md)**
+- **[Light](driver-peripherals-light-des.md)**
 
-- **[SENSOR](driver-peripherals-sensor-des.md)**
+- **[Pin_auth](driver-peripherals-pinauth-des.md)**
 
-- **[WLAN](driver-peripherals-external-des.md)**
+- **[Sensor](driver-peripherals-sensor-des.md)**
+
+- **[Touchscreen](driver-peripherals-touch-des.md)**
+
+- **[USB](driver-peripherals-usb-des.md)**
 
-- **[USB](driver-peripherals-usb-des.md)**
+- **[Vibrator](driver-peripherals-vibrator-des.md)**
\ No newline at end of file