update docs

Signed-off-by: NAnnie_wang <annie.wangli@huawei.com>

en/device-dev/driver/driver-hdf-overview.md

@@ -11,9 +11,11 @@ The Hardware Driver Foundation (HDF) provides driver framework capabilities incl
 The HDF supports the following loading modes:
 
 - On-demand loading
+
   The driver is loaded by default during the operating system (OS) boot process or dynamically loaded after OS is started.
 
 - Sequential loading
+
   The driver is loaded based on its priority during the OS boot process.
 
 

en/device-dev/driver/driver-hdf-servicemanage.md

@@ -4,10 +4,10 @@
 Driver services are objects of capabilities provided by HDF driver devices to external systems and are managed by the HDF in a unified manner. Driver service management involves publishing and obtaining driver services.
 
 
-The HDF uses the **policy** field in the configuration file to define policies for drivers to publish services externally. The values this field are as follows:
+The HDF uses the **policy** field in the configuration file to define policies for a driver to provide services externally. The values this field are as follows:
+
 
 
-  
 ```
 typedef enum {
     /* The driver does not provide services. */
@@ -37,28 +37,28 @@ The table below describes the APIs for driver service management.
 
   **Table 1** APIs for driver service management
 
-| API| Description| 
+| API| Description|
 | -------- | -------- |
-| int32_t (\*Bind)(struct HdfDeviceObject \*deviceObject); | Binds a service API to the HDF. You need to implement the **Bind()** function.| 
-| const struct HdfObject \*DevSvcManagerClntGetService(const char \*svcName); | Obtains a driver service.| 
-| int&nbsp;HdfDeviceSubscribeService(<br>struct&nbsp;HdfDeviceObject&nbsp;\*deviceObject,&nbsp;const&nbsp;char&nbsp;\*serviceName,&nbsp;struct&nbsp;SubscriberCallback&nbsp;callback); | Subscribes to a driver service.| 
+| int32_t (\*Bind)(struct HdfDeviceObject \*deviceObject) | Binds a service API to the HDF. You need to implement the **Bind()** function.|
+| const struct HdfObject \*DevSvcManagerClntGetService(const char \*svcName)| Obtains a driver service.|
+|int HdfDeviceSubscribeService(struct HdfDeviceObject \*deviceObject, const char \*serviceName, struct SubscriberCallback callback) | Subscribes to a driver service.|
 
 
 ## How to Develop
 
 The development procedure is as follows:
 
-1. Define the services to be provided by the driver.
-     
+1. Define the services to be published by the driver.
+   
    ```
-   Define the driver service structure.
+   // Define the driver service structure.
    struct ISampleDriverService {
-       struct IDeviceIoService ioService;   // The first member must be of the IDeviceIoService type.
+       struct IDeviceIoService ioService;       // The first member must be of the IDeviceIoService type.
        int32_t (*ServiceA)(void);               // API of the first driver service.
        int32_t (*ServiceB)(uint32_t inputCode); // API of the second driver service. You can add more as required.
    };
    
-   Implement the driver service APIs.
+   // Implement the driver service APIs.
    int32_t SampleDriverServiceA(void)
    {
        // You need to implement the service logic.
@@ -73,7 +73,7 @@ The development procedure is as follows:
    ```
 
 2. Bind the driver service to the HDF and implement the **Bind()** function in the **HdfDriverEntry** structure.
-     
+   
    ```
    int32_t SampleDriverBind(struct HdfDeviceObject *deviceObject)
    {
@@ -92,52 +92,61 @@ The development procedure is as follows:
    ```
 
 3. Obtain the driver service.
+
    The driver service can be obtained by using the API or subscription mechanism provided by the HDF.
 
    - Using the API
-      Use the API provided by the HDF to obtain the driver service if the driver has been loaded.
-
-        
-      ```
-      const struct ISampleDriverService *sampleService =
-              (const struct ISampleDriverService *)DevSvcManagerClntGetService("sample_driver");
-      if (sampleService == NULL) {
-          return -1;
-      }
-      sampleService->ServiceA();
-      sampleService->ServiceB(5);
-      ```
+
+     Use the API provided by the HDF to obtain the driver service if the driver has been loaded.
+
+     ```
+     ​```
+     const struct ISampleDriverService *sampleService =
+             (const struct ISampleDriverService *)DevSvcManagerClntGetService("sample_driver");
+     if (sampleService == NULL) {
+         return -1;
+     }
+     sampleService->ServiceA();
+     sampleService->ServiceB(5);
+     ​```
+     ```
+
    - Using the subscription mechanism
-      If the kernel mode is unaware of the time for loading drivers on the same host, use the subscription mechanism provided by the HDF to subscribe to the drivers. After the drivers are loaded, the HDF sends the driver services to the subscriber. The implementation is as follows:
-
-        
-      ```
-      // Callback invoked to return the driver services after the subscribed driver is loaded.
-      // object is the pointer to the private data of the subscriber, and service is the pointer to the subscribed service object.
-      int32_t TestDriverSubCallBack(struct HdfDeviceObject *deviceObject, const struct HdfObject *service)
-      {
-          const struct ISampleDriverService *sampleService =
-              (const struct ISampleDriverService *)service;
-          if (sampleService == NULL) {
-              return -1;
-          }
-          sampleService->ServiceA();
-          sampleService->ServiceB(5);
-      }
-      // Implement the subscription process.
-      int32_t TestDriverInit(struct HdfDeviceObject *deviceObject)
-      {
-          if (deviceObject == NULL) {
-              HDF_LOGE("Test driver init failed, deviceObject is null!");
-              return -1;
-          }
-          struct SubscriberCallback callBack;
-          callBack.deviceObject = deviceObject;
-          callBack.OnServiceConnected = TestDriverSubCallBack;
-          int32_t ret = HdfDeviceSubscribeService(deviceObject, "sample_driver", callBack);
-          if (ret != 0) {
-              HDF_LOGE("Test driver subscribe sample driver failed!");
-          }
-          return ret;
-      }
-      ```
+
+     If the kernel mode is unaware of the time for loading drivers on the same host, use the subscription mechanism provided by the HDF to subscribe to the drivers. After the drivers are loaded, the HDF publishes the driver services to the subscriber. 
+
+     The implementation is as follows:
+
+     ```
+     // Callback invoked to return the driver services after the subscribed driver is loaded.
+     // object is the pointer to the private data of the subscriber, and service is the pointer to the subscribed service object.
+     int32_t TestDriverSubCallBack(struct HdfDeviceObject *deviceObject, const struct HdfObject *service)
+     {
+         const struct ISampleDriverService *sampleService =
+             (const struct ISampleDriverService *)service;
+         if (sampleService == NULL) {
+             return -1;
+         }
+         sampleService->ServiceA();
+         sampleService->ServiceB(5);
+     }
+     // Implement the subscription process.
+     int32_t TestDriverInit(struct HdfDeviceObject *deviceObject)
+     {
+         if (deviceObject == NULL) {
+             HDF_LOGE("Test driver init failed, deviceObject is null!");
+             return -1;
+         }
+         struct SubscriberCallback callBack;
+         callBack.deviceObject = deviceObject;
+         callBack.OnServiceConnected = TestDriverSubCallBack;
+         int32_t ret = HdfDeviceSubscribeService(deviceObject, "sample_driver", callBack);
+         if (ret != 0) {
+             HDF_LOGE("Test driver subscribe sample driver failed!");
+         }
+         return ret;
+     }
+     ```
+
+     
+