Merge pull request #4737 from mysterywolf/3,1,xformatv3.1.5

[lts 3.1.x] format codes

13 files changed, 350 insertions, 350 deletions

diff --git a/components/drivers/usb/usbhost/class/adk.c b/components/drivers/usb/usbhost/class/adk.c
index 2425de7bba..492a2f9bb7 100644
--- a/components/drivers/usb/usbhost/class/adk.c
+++ b/components/drivers/usb/usbhost/class/adk.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
diff --git a/components/drivers/usb/usbhost/class/adk.h b/components/drivers/usb/usbhost/class/adk.h
index c582ad7f17..aebe7de705 100644
--- a/components/drivers/usb/usbhost/class/adk.h
+++ b/components/drivers/usb/usbhost/class/adk.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -19,7 +19,7 @@ struct uadkinst
     upipe_t pipe_out;
 
     struct rt_device device;
-};    
+};
 typedef struct uadkinst* uadk_t;
 
 #define USB_ACCESSORY_VENDOR_ID         0x18D1
diff --git a/components/drivers/usb/usbhost/class/hid.c b/components/drivers/usb/usbhost/class/hid.c
index e16096877f..4038d3b321 100644
--- a/components/drivers/usb/usbhost/class/hid.c
+++ b/components/drivers/usb/usbhost/class/hid.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -23,31 +23,31 @@ static rt_list_t _protocal_list;
  * @param intf the interface instance.
  * @duration the idle period of requesting data.
  * @report_id the report id
- * 
+ *
  * @return the error code, RT_EOK on successfully.
 */
 rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id)
 {
     struct urequest setup;
-    struct uinstance* device;    
+    struct uinstance* device;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(intf != RT_NULL);
     RT_ASSERT(intf->device != RT_NULL);
 
     device = intf->device;
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_INTERFACE;
     setup.request = USB_REQ_SET_IDLE;
     setup.index = 0;
     setup.length = 0;
     setup.value = (duration << 8 )| report_id;
 
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, 
+    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
         timeout) == 0) return RT_EOK;
-    else return -RT_FALSE;    
+    else return -RT_FALSE;
 }
 
 /**
@@ -56,32 +56,32 @@ rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id)
  * @param intf the interface instance.
  * @buffer the data buffer to save usb report descriptor.
  * @param nbytes the size of buffer
- * 
+ *
  * @return the error code, RT_EOK on successfully.
 */
-rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type, 
+rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type,
     rt_uint8_t id, rt_uint8_t *buffer, rt_size_t size)
 {
     struct urequest setup;
     struct uinstance* device;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(intf != RT_NULL);
     RT_ASSERT(intf->device != RT_NULL);
 
     device = intf->device;
 
-    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_INTERFACE;
     setup.request = USB_REQ_GET_REPORT;
     setup.index = intf->intf_desc->bInterfaceNumber;
     setup.length = size;
     setup.value = (type << 8 ) + id;
 
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size, 
+    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size,
         timeout) == size) return RT_EOK;
-    else return -RT_FALSE;    
+    else return -RT_FALSE;
 }
 
 /**
@@ -90,31 +90,31 @@ rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type,
  * @param intf the interface instance.
  * @buffer the data buffer to save usb report descriptor.
  * @param nbytes the size of buffer
- * 
+ *
  * @return the error code, RT_EOK on successfully.
 */
 rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size)
 {
     struct urequest setup;
-    struct uinstance* device;        
+    struct uinstance* device;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(intf != RT_NULL);
     RT_ASSERT(intf->device != RT_NULL);
-    
+
     device = intf->device;
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_INTERFACE;
     setup.request = USB_REQ_SET_REPORT;
     setup.index = intf->intf_desc->bInterfaceNumber;
     setup.length = size;
     setup.value = 0x02 << 8;
 
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size, 
+    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size,
         timeout) == size) return RT_EOK;
-    else return -RT_FALSE;    
+    else return -RT_FALSE;
 }
 
 /**
@@ -122,7 +122,7 @@ rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_
  *
  * @param intf the interface instance.
  * @param protocol the protocol id.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol)
@@ -130,56 +130,56 @@ rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol)
     struct urequest setup;
     struct uinstance* device;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(intf != RT_NULL);
     RT_ASSERT(intf->device != RT_NULL);
-    
+
     device = intf->device;
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_INTERFACE;
     setup.request = USB_REQ_SET_PROTOCOL;
     setup.index = 0;
     setup.length = 0;
     setup.value = protocol;
 
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, 
+    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
         timeout) == 0) return RT_EOK;
-    else return -RT_FALSE;    
+    else return -RT_FALSE;
 }
 
 /**
- * This function will do USB_REQ_GET_DESCRIPTOR request for the device instance 
+ * This function will do USB_REQ_GET_DESCRIPTOR request for the device instance
  * to set feature of the hub port.
  *
  * @param intf the interface instance.
  * @buffer the data buffer to save usb report descriptor.
  * @param nbytes the size of buffer
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf, 
+rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf,
     rt_uint8_t *buffer, rt_size_t size)
 {
     struct urequest setup;
-    struct uinstance* device;    
+    struct uinstance* device;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(intf != RT_NULL);
     RT_ASSERT(intf->device != RT_NULL);
-    
+
     device = intf->device;
 
-    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD| 
+    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD|
         USB_REQ_TYPE_INTERFACE;
     setup.request = USB_REQ_GET_DESCRIPTOR;
     setup.index = 0;
     setup.length = size;
     setup.value = USB_DESC_TYPE_REPORT << 8;
 
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size, 
+    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size,
         timeout) == size) return RT_EOK;
     else return -RT_FALSE;
 }
@@ -188,7 +188,7 @@ rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf,
  * This function will register specified hid protocal to protocal list
  *
  * @param protocal the specified protocal.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hid_protocal_register(uprotocal_t protocal)
@@ -199,26 +199,26 @@ rt_err_t rt_usbh_hid_protocal_register(uprotocal_t protocal)
 
     /* insert class driver into driver list */
     rt_list_insert_after(&_protocal_list, &(protocal->list));
-    
-    return RT_EOK;    
+
+    return RT_EOK;
 }
 
 /**
  * This function is the callback function of hid's int endpoint, it is invoked when data comes.
  *
  * @param context the context of the callback function.
- * 
+ *
  * @return none.
  */
 static void rt_usbh_hid_callback(void* context)
 {
-    upipe_t pipe; 
+    upipe_t pipe;
     struct uhid* hid;
     int timeout = USB_TIMEOUT_LONG;
 
     /* parameter check */
     RT_ASSERT(context != RT_NULL);
-    
+
     pipe = (upipe_t)context;
     hid = (struct uhid*)pipe->intf->user_data;
 
@@ -228,7 +228,7 @@ static void rt_usbh_hid_callback(void* context)
     /* parameter check */
      RT_ASSERT(pipe->intf->device->hcd != RT_NULL);
 
-    rt_usb_hcd_int_xfer(pipe->intf->device->hcd, pipe, hid->buffer, 
+    rt_usb_hcd_int_xfer(pipe->intf->device->hcd, pipe, hid->buffer,
         pipe->ep.wMaxPacketSize, timeout);
 }
 
@@ -236,7 +236,7 @@ static void rt_usbh_hid_callback(void* context)
  * This function will find specified hid protocal from protocal list
  *
  * @param pro_id the protocal id.
- * 
+ *
  * @return the found protocal or RT_NULL if there is no this protocal.
  */
 static uprotocal_t rt_usbh_hid_protocal_find(int pro_id)
@@ -246,7 +246,7 @@ static uprotocal_t rt_usbh_hid_protocal_find(int pro_id)
     /* try to find protocal object */
     for (node = _protocal_list.next; node != &_protocal_list; node = node->next)
     {
-        uprotocal_t protocal = 
+        uprotocal_t protocal =
             (uprotocal_t)rt_list_entry(node, struct uprotocal, list);
         if (protocal->pro_id == pro_id) return protocal;
     }
@@ -260,18 +260,18 @@ static uprotocal_t rt_usbh_hid_protocal_find(int pro_id)
  *  as a hid class device, it will continue the enumulate process.
  *
  * @param arg the argument.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t rt_usbh_hid_enable(void* arg)
 {
     int i = 0, pro_id;
-    uprotocal_t protocal;    
+    uprotocal_t protocal;
     struct uhid* hid;
     struct uintf* intf = (struct uintf*)arg;
     int timeout = USB_TIMEOUT_BASIC;
     upipe_t pipe;
-    
+
     /* parameter check */
     if(intf == RT_NULL)
     {
@@ -282,65 +282,65 @@ static rt_err_t rt_usbh_hid_enable(void* arg)
     pro_id = intf->intf_desc->bInterfaceProtocol;
 
     RT_DEBUG_LOG(RT_DEBUG_USB,
-                 ("HID device enable, protocal id %d\n", pro_id));   
+                 ("HID device enable, protocal id %d\n", pro_id));
 
-    protocal = rt_usbh_hid_protocal_find(pro_id);    
+    protocal = rt_usbh_hid_protocal_find(pro_id);
     if(protocal == RT_NULL)
     {
         rt_kprintf("can't find hid protocal %d\n", pro_id);
-        intf->user_data = RT_NULL;        
+        intf->user_data = RT_NULL;
         return -RT_ERROR;
     }
-    
+
     hid = rt_malloc(sizeof(struct uhid));
     RT_ASSERT(hid != RT_NULL);
 
-    /* initilize the data structure */    
+    /* initilize the data structure */
     rt_memset(hid, 0, sizeof(struct uhid));
     intf->user_data = (void*)hid;
     hid->protocal = protocal;
-    
+
     for(i=0; i<intf->intf_desc->bNumEndpoints; i++)
-    {    
+    {
         rt_err_t ret;
         uep_desc_t ep_desc;
 
-        /* get endpoint descriptor */        
+        /* get endpoint descriptor */
         rt_usbh_get_endpoint_descriptor(intf->intf_desc, i, &ep_desc);
         if(ep_desc == RT_NULL)
         {
             rt_kprintf("rt_usbh_get_endpoint_descriptor error\n");
             return -RT_ERROR;
         }
-                
-        if(USB_EP_ATTR(ep_desc->bmAttributes) != USB_EP_ATTR_INT) 
+
+        if(USB_EP_ATTR(ep_desc->bmAttributes) != USB_EP_ATTR_INT)
             continue;
-    
+
         if(!(ep_desc->bEndpointAddress & USB_DIR_IN)) continue;
 
-        ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &hid->pipe_in, 
-            intf, ep_desc, rt_usbh_hid_callback);        
+        ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &hid->pipe_in,
+            intf, ep_desc, rt_usbh_hid_callback);
         if(ret != RT_EOK) return ret;
     }
 
     /* initialize hid protocal */
-    hid->protocal->init((void*)intf);    
+    hid->protocal->init((void*)intf);
     pipe = hid->pipe_in;
 
     /* parameter check */
      RT_ASSERT(pipe->intf->device->hcd != RT_NULL);
-    
-    rt_usb_hcd_int_xfer(pipe->intf->device->hcd, hid->pipe_in, 
+
+    rt_usb_hcd_int_xfer(pipe->intf->device->hcd, hid->pipe_in,
         hid->buffer, hid->pipe_in->ep.wMaxPacketSize, timeout);
     return RT_EOK;
 }
 
 /**
- * This function will be invoked when usb device plug out is detected and it would clean 
+ * This function will be invoked when usb device plug out is detected and it would clean
  * and release all hub class related resources.
  *
  * @param arg the argument.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t rt_usbh_hid_disable(void* arg)
@@ -361,10 +361,10 @@ static rt_err_t rt_usbh_hid_disable(void* arg)
             rt_usb_hcd_free_pipe(intf->device->hcd, hid->pipe_in);
         }
 
-        /* free the hid instance */    
+        /* free the hid instance */
         rt_free(hid);
     }
-    
+
     /* free the instance */
     rt_free(intf);
 
@@ -374,7 +374,7 @@ static rt_err_t rt_usbh_hid_disable(void* arg)
 /**
  * This function will register hid class driver to the usb class driver manager.
  * and it should be invoked in the usb system initialization.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 ucd_t rt_usbh_class_driver_hid(void)
@@ -382,7 +382,7 @@ ucd_t rt_usbh_class_driver_hid(void)
     rt_list_init(&_protocal_list);
 
     hid_driver.class_code = USB_CLASS_HID;
-    
+
     hid_driver.enable = rt_usbh_hid_enable;
     hid_driver.disable = rt_usbh_hid_disable;
 
diff --git a/components/drivers/usb/usbhost/class/hid.h b/components/drivers/usb/usbhost/class/hid.h
index 8e446c8cea..10d3c6ee4d 100644
--- a/components/drivers/usb/usbhost/class/hid.h
+++ b/components/drivers/usb/usbhost/class/hid.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -18,7 +18,7 @@ struct uhid
     upipe_t pipe_in;
     rt_uint8_t buffer[8];
     uprotocal_t protocal;
-};    
+};
 typedef struct uhid uhid_t;
 
 #define USB_REQ_GET_REPORT      0x01
@@ -28,7 +28,7 @@ typedef struct uhid uhid_t;
 #define USB_REQ_SET_IDLE        0x0a
 #define USB_REQ_SET_PROTOCOL    0x0b
 
-#define USB_HID_KEYBOARD        1    
+#define USB_HID_KEYBOARD        1
 #define USB_HID_MOUSE            2
 
 rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id);
diff --git a/components/drivers/usb/usbhost/class/mass.c b/components/drivers/usb/usbhost/class/mass.c
index 20048873f5..abd89a5efc 100644
--- a/components/drivers/usb/usbhost/class/mass.c
+++ b/components/drivers/usb/usbhost/class/mass.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -24,29 +24,29 @@ static struct uclass_driver storage_driver;
  *
  * @param intf the interface instance.
  * @param max_lun the buffer to save max_lun.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t _pipe_check(struct uhintf* intf, upipe_t pipe)
 {
-    struct uinstance* device;        
+    struct uinstance* device;
     rt_err_t ret;
     ustor_t stor;
-    int size = 0; 
+    int size = 0;
     struct ustorage_csw csw;
 
     if(intf == RT_NULL || pipe == RT_NULL)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
+    }
 
-    /* get usb device instance from the interface instance */    
-    device = intf->device;    
+    /* get usb device instance from the interface instance */
+    device = intf->device;
 
-    /* get storage instance from the interface instance */        
+    /* get storage instance from the interface instance */
     stor = (ustor_t)intf->user_data;
-    
+
     /* check pipe status */
     if(pipe->status == UPIPE_STATUS_OK) return RT_EOK;
 
@@ -58,11 +58,11 @@ static rt_err_t _pipe_check(struct uhintf* intf, upipe_t pipe)
     if(pipe->status == UPIPE_STATUS_STALL)
     {
         /* clear the pipe stall status */
-        ret = rt_usbh_clear_feature(device, pipe->ep.bEndpointAddress, 
+        ret = rt_usbh_clear_feature(device, pipe->ep.bEndpointAddress,
             USB_FEATURE_ENDPOINT_HALT);
         if(ret != RT_EOK) return ret;
     }
-    
+
 
     rt_thread_delay(50);
 
@@ -73,14 +73,14 @@ static rt_err_t _pipe_check(struct uhintf* intf, upipe_t pipe)
     RT_DEBUG_LOG(RT_DEBUG_USB, ("clean storage in pipe stall\n"));
 
     /* it should receive csw after clear the stall feature */
-    size = rt_usb_hcd_pipe_xfer(stor->pipe_in->inst->hcd, 
+    size = rt_usb_hcd_pipe_xfer(stor->pipe_in->inst->hcd,
         stor->pipe_in, &csw, SIZEOF_CSW, 100);
-    if(size != SIZEOF_CSW) 
+    if(size != SIZEOF_CSW)
     {
         rt_kprintf("receive the csw after stall failed\n");
         return -RT_EIO;
     }
-    
+
     return -RT_ERROR;
 }
 
@@ -89,35 +89,35 @@ static rt_err_t _pipe_check(struct uhintf* intf, upipe_t pipe)
  *
  * @param intf the interface instance.
  * @param max_lun the buffer to save max_lun.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-static rt_err_t rt_usb_bulk_only_xfer(struct uhintf* intf, 
+static rt_err_t rt_usb_bulk_only_xfer(struct uhintf* intf,
     ustorage_cbw_t cmd, rt_uint8_t* buffer, int timeout)
 {
     rt_size_t size;
-    rt_err_t ret;    
+    rt_err_t ret;
     upipe_t pipe;
     struct ustorage_csw csw;
     ustor_t stor;
 
-    RT_ASSERT(cmd != RT_NULL);    
+    RT_ASSERT(cmd != RT_NULL);
 
     if(intf == RT_NULL)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
     }
-    
-    /* get storage instance from the interface instance */    
+
+    /* get storage instance from the interface instance */
     stor = (ustor_t)intf->user_data;
 
     do
     {
         /* send the cbw */
-        size = rt_usb_hcd_pipe_xfer(stor->pipe_out->inst->hcd, stor->pipe_out, 
+        size = rt_usb_hcd_pipe_xfer(stor->pipe_out->inst->hcd, stor->pipe_out,
             cmd, SIZEOF_CBW, timeout);
-        if(size != SIZEOF_CBW) 
+        if(size != SIZEOF_CBW)
         {
             rt_kprintf("CBW size error\n");
             return -RT_EIO;
@@ -126,20 +126,20 @@ static rt_err_t rt_usb_bulk_only_xfer(struct uhintf* intf,
         {
             pipe = (cmd->dflags == CBWFLAGS_DIR_IN) ? stor->pipe_in :
                 stor->pipe_out;
-            size = rt_usb_hcd_pipe_xfer(pipe->inst->hcd, pipe, (void*)buffer, 
+            size = rt_usb_hcd_pipe_xfer(pipe->inst->hcd, pipe, (void*)buffer,
                 cmd->xfer_len, timeout);
             if(size != cmd->xfer_len)
             {
-                rt_kprintf("request size %d, transfer size %d\n", 
+                rt_kprintf("request size %d, transfer size %d\n",
                     cmd->xfer_len, size);
                 break;
-            }    
+            }
         }
-        
+
         /* receive the csw */
-        size = rt_usb_hcd_pipe_xfer(stor->pipe_in->inst->hcd, stor->pipe_in, 
+        size = rt_usb_hcd_pipe_xfer(stor->pipe_in->inst->hcd, stor->pipe_in,
             &csw, SIZEOF_CSW, timeout);
-        if(size != SIZEOF_CSW) 
+        if(size != SIZEOF_CSW)
         {
             rt_kprintf("csw size error\n");
             return -RT_EIO;
@@ -148,12 +148,12 @@ static rt_err_t rt_usb_bulk_only_xfer(struct uhintf* intf,
 
     /* check in pipes status */
     ret = _pipe_check(intf, stor->pipe_in);
-    if(ret != RT_EOK) 
+    if(ret != RT_EOK)
     {
         rt_kprintf("in pipe error\n");
         return ret;
     }
-    
+
     /* check out pipes status */
     ret = _pipe_check(intf, stor->pipe_out);
     if(ret != RT_EOK)
@@ -161,20 +161,20 @@ static rt_err_t rt_usb_bulk_only_xfer(struct uhintf* intf,
         rt_kprintf("out pipe error\n");
         return ret;
     }
-    
+
     /* check csw status */
     if(csw.signature != CSW_SIGNATURE || csw.tag != CBW_TAG_VALUE)
     {
         rt_kprintf("csw signature error\n");
         return -RT_EIO;
     }
-    
+
     if(csw.status != 0)
     {
         //rt_kprintf("csw status error:%d\n",csw.status);
         return -RT_ERROR;
     }
-    
+
     return RT_EOK;
 }
 
@@ -183,12 +183,12 @@ static rt_err_t rt_usb_bulk_only_xfer(struct uhintf* intf,
  *
  * @param intf the interface instance.
  * @param max_lun the buffer to save max_lun.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_storage_get_max_lun(struct uhintf* intf, rt_uint8_t* max_lun)
 {
-    struct uinstance* device;    
+    struct uinstance* device;
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
 
@@ -196,17 +196,17 @@ rt_err_t rt_usbh_storage_get_max_lun(struct uhintf* intf, rt_uint8_t* max_lun)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
+    }
 
     /* parameter check */
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_get_max_lun\n"));
 
-    /* get usb device instance from the interface instance */    
-    device = intf->device;    
+    /* get usb device instance from the interface instance */
+    device = intf->device;
 
     /* construct the request */
-    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_INTERFACE;
     setup.bRequest = USBREQ_GET_MAX_LUN;
     setup.wValue = intf->intf_desc->bInterfaceNumber;
@@ -233,13 +233,13 @@ rt_err_t rt_usbh_storage_get_max_lun(struct uhintf* intf, rt_uint8_t* max_lun)
  * This function will do USBREQ_MASS_STORAGE_RESET request for the usb interface instance.
  *
  * @param intf the interface instance.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_storage_reset(struct uhintf* intf)
 {
     struct urequest setup;
-    struct uinstance* device;    
+    struct uinstance* device;
     int timeout = USB_TIMEOUT_BASIC;
 
     /* parameter check */
@@ -247,16 +247,16 @@ rt_err_t rt_usbh_storage_reset(struct uhintf* intf)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
+    }
 
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_reset\n"));
 
-    /* get usb device instance from the interface instance */    
-    device = intf->device;    
+    /* get usb device instance from the interface instance */
+    device = intf->device;
 
     /* construct the request */
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_INTERFACE;
     setup.bRequest = USBREQ_MASS_STORAGE_RESET;
     setup.wIndex = intf->intf_desc->bInterfaceNumber;
@@ -279,12 +279,12 @@ rt_err_t rt_usbh_storage_reset(struct uhintf* intf)
  *
  * @param intf the interface instance.
  * @param buffer the data buffer to save read data
- * @param sector the start sector address to read. 
+ * @param sector the start sector address to read.
  * @param sector the sector count to read.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_storage_read10(struct uhintf* intf, rt_uint8_t *buffer, 
+rt_err_t rt_usbh_storage_read10(struct uhintf* intf, rt_uint8_t *buffer,
     rt_uint32_t sector, rt_size_t count, int timeout)
 {
     struct ustorage_cbw cmd;
@@ -294,8 +294,8 @@ rt_err_t rt_usbh_storage_read10(struct uhintf* intf, rt_uint8_t *buffer,
     {
         rt_kprintf("interface is not available\n");
         return -RT_EIO;
-    }    
-    
+    }
+
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_read10\n"));
 
@@ -325,12 +325,12 @@ rt_err_t rt_usbh_storage_read10(struct uhintf* intf, rt_uint8_t *buffer,
  *
  * @param intf the interface instance.
  * @param buffer the data buffer to save write data
- * @param sector the start sector address to write. 
+ * @param sector the start sector address to write.
  * @param sector the sector count to write.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_storage_write10(struct uhintf* intf, rt_uint8_t *buffer, 
+rt_err_t rt_usbh_storage_write10(struct uhintf* intf, rt_uint8_t *buffer,
     rt_uint32_t sector, rt_size_t count, int timeout)
 {
     struct ustorage_cbw cmd;
@@ -340,8 +340,8 @@ rt_err_t rt_usbh_storage_write10(struct uhintf* intf, rt_uint8_t *buffer,
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
-    
+    }
+
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_write10\n"));
 
@@ -371,7 +371,7 @@ rt_err_t rt_usbh_storage_write10(struct uhintf* intf, rt_uint8_t *buffer,
  *
  * @param intf the interface instance.
  * @param buffer the data buffer to save sense data
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_storage_request_sense(struct uhintf* intf, rt_uint8_t* buffer)
@@ -384,12 +384,12 @@ rt_err_t rt_usbh_storage_request_sense(struct uhintf* intf, rt_uint8_t* buffer)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
-    
+    }
+
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_request_sense\n"));
 
-    /* construct the command block wrapper */    
+    /* construct the command block wrapper */
     rt_memset(&cmd, 0, sizeof(struct ustorage_cbw));
     cmd.signature = CBW_SIGNATURE;
     cmd.tag = CBW_TAG_VALUE;
@@ -407,7 +407,7 @@ rt_err_t rt_usbh_storage_request_sense(struct uhintf* intf, rt_uint8_t* buffer)
  * This function will execute SCSI_TEST_UNIT_READY command to get unit ready status.
  *
  * @param intf the interface instance.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_storage_test_unit_ready(struct uhintf* intf)
@@ -420,8 +420,8 @@ rt_err_t rt_usbh_storage_test_unit_ready(struct uhintf* intf)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
-    
+    }
+
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_test_unit_ready\n"));
 
@@ -434,7 +434,7 @@ rt_err_t rt_usbh_storage_test_unit_ready(struct uhintf* intf)
     cmd.lun = 0;
     cmd.cb_len = 12;
     cmd.cb[0] = SCSI_TEST_UNIT_READY;
- 
+
     return rt_usb_bulk_only_xfer(intf, &cmd, RT_NULL, timeout);
 }
 
@@ -443,21 +443,21 @@ rt_err_t rt_usbh_storage_test_unit_ready(struct uhintf* intf)
  *
  * @param intf the interface instance.
  * @param buffer the data buffer to save inquiry data
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_storage_inquiry(struct uhintf* intf, rt_uint8_t* buffer)
 {
     struct ustorage_cbw cmd;
     int timeout = USB_TIMEOUT_LONG;
-    
+
     /* parameter check */
     if(intf == RT_NULL)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
-    
+    }
+
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_inquiry\n"));
 
@@ -480,7 +480,7 @@ rt_err_t rt_usbh_storage_inquiry(struct uhintf* intf, rt_uint8_t* buffer)
  *
  * @param intf the interface instance.
  * @param buffer the data buffer to save capacity data
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_storage_get_capacity(struct uhintf* intf, rt_uint8_t* buffer)
@@ -493,7 +493,7 @@ rt_err_t rt_usbh_storage_get_capacity(struct uhintf* intf, rt_uint8_t* buffer)
     {
         rt_kprintf("the interface is not available\n");
         return -RT_EIO;
-    }    
+    }
 
     RT_ASSERT(intf->device != RT_NULL);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_get_capacity\n"));
@@ -513,17 +513,17 @@ rt_err_t rt_usbh_storage_get_capacity(struct uhintf* intf, rt_uint8_t* buffer)
 
 /**
  * This function will run mass storage class driver when usb device is detected
- * and identified as a mass storage class device, it will continue to do the enumulate 
+ * and identified as a mass storage class device, it will continue to do the enumulate
  * process.
  *
  * @param arg the argument.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t rt_usbh_storage_enable(void* arg)
 {
     int i = 0;
-    rt_err_t ret;    
+    rt_err_t ret;
     ustor_t stor;
     struct uhintf* intf = (struct uhintf*)arg;
 
@@ -534,25 +534,25 @@ static rt_err_t rt_usbh_storage_enable(void* arg)
         return -RT_EIO;
     }
 
-    RT_DEBUG_LOG(RT_DEBUG_USB, ("subclass %d, protocal %d\n", 
+    RT_DEBUG_LOG(RT_DEBUG_USB, ("subclass %d, protocal %d\n",
         intf->intf_desc->bInterfaceSubClass,
         intf->intf_desc->bInterfaceProtocol));
-        
+
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_storage_run\n"));
 
     /* only support SCSI subclass and bulk only protocal */
-    
+
     stor = rt_malloc(sizeof(struct ustor));
     RT_ASSERT(stor != RT_NULL);
 
     /* initilize the data structure */
-    rt_memset(stor, 0, sizeof(struct ustor));    
+    rt_memset(stor, 0, sizeof(struct ustor));
     intf->user_data = (void*)stor;
 
     for(i=0; i<intf->intf_desc->bNumEndpoints; i++)
-    {        
+    {
         uep_desc_t ep_desc;
-        
+
         /* get endpoint descriptor from interface descriptor */
         rt_usbh_get_endpoint_descriptor(intf->intf_desc, i, &ep_desc);
         if(ep_desc == RT_NULL)
@@ -560,11 +560,11 @@ static rt_err_t rt_usbh_storage_enable(void* arg)
             rt_kprintf("rt_usb_get_endpoint_descriptor error\n");
             return -RT_ERROR;
         }
-        
-        /* the endpoint type of mass storage class should be BULK */    
+
+        /* the endpoint type of mass storage class should be BULK */
         if((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) != USB_EP_ATTR_BULK)
             continue;
-        
+
         /* allocate pipes according to the endpoint type */
         if(ep_desc->bEndpointAddress & USB_DIR_IN)
         {
@@ -572,7 +572,7 @@ static rt_err_t rt_usbh_storage_enable(void* arg)
             stor->pipe_in = rt_usb_instance_find_pipe(intf->device,ep_desc->bEndpointAddress);
         }
         else
-        {        
+        {
             /* alloc an output pipe for the storage instance */
             stor->pipe_out = rt_usb_instance_find_pipe(intf->device,ep_desc->bEndpointAddress);
         }
@@ -583,8 +583,8 @@ static rt_err_t rt_usbh_storage_enable(void* arg)
     {
         rt_kprintf("pipe error, unsupported device\n");
         return -RT_ERROR;
-    }    
-    
+    }
+
     /* should implement as callback */
     ret = rt_udisk_run(intf);
     if(ret != RT_EOK) return ret;
@@ -593,11 +593,11 @@ static rt_err_t rt_usbh_storage_enable(void* arg)
 }
 
 /**
- * This function will be invoked when usb device plug out is detected and it would clean 
+ * This function will be invoked when usb device plug out is detected and it would clean
  * and release all mass storage class related resources.
  *
  * @param arg the argument.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t rt_usbh_storage_disable(void* arg)
@@ -617,7 +617,7 @@ static rt_err_t rt_usbh_storage_disable(void* arg)
 
     rt_udisk_stop(intf);
 
-    
+
     /* free storage instance */
     if(stor != RT_NULL) rt_free(stor);
     return RT_EOK;
@@ -626,13 +626,13 @@ static rt_err_t rt_usbh_storage_disable(void* arg)
 /**
  * This function will register mass storage class driver to the usb class driver manager.
  * and it should be invoked in the usb system initialization.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 ucd_t rt_usbh_class_driver_storage(void)
 {
     storage_driver.class_code = USB_CLASS_MASS_STORAGE;
-    
+
     storage_driver.enable = rt_usbh_storage_enable;
     storage_driver.disable = rt_usbh_storage_disable;
 
diff --git a/components/drivers/usb/usbhost/class/mass.h b/components/drivers/usb/usbhost/class/mass.h
index 770e64a03f..2578fb54c7 100644
--- a/components/drivers/usb/usbhost/class/mass.h
+++ b/components/drivers/usb/usbhost/class/mass.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -30,17 +30,17 @@ struct ustor
     upipe_t pipe_in;
     upipe_t pipe_out;
     rt_uint32_t capicity[2];
-    
+
     struct rt_device dev[MAX_PARTITION_COUNT];
     rt_uint8_t dev_cnt;
-};    
+};
 typedef struct ustor* ustor_t;
 
 rt_err_t rt_usbh_storage_get_max_lun(struct uhintf* intf, rt_uint8_t* max_lun);
 rt_err_t rt_usbh_storage_reset(struct uhintf* intf);
-rt_err_t rt_usbh_storage_read10(struct uhintf* intf, rt_uint8_t *buffer, 
+rt_err_t rt_usbh_storage_read10(struct uhintf* intf, rt_uint8_t *buffer,
     rt_uint32_t sector, rt_size_t count, int timeout);
-rt_err_t rt_usbh_storage_write10(struct uhintf* intf, rt_uint8_t *buffer, 
+rt_err_t rt_usbh_storage_write10(struct uhintf* intf, rt_uint8_t *buffer,
     rt_uint32_t sector, rt_size_t count, int timeout);
 rt_err_t rt_usbh_storage_request_sense(struct uhintf* intf, rt_uint8_t* buffer);
 rt_err_t rt_usbh_storage_test_unit_ready(struct uhintf* intf);
diff --git a/components/drivers/usb/usbhost/class/udisk.c b/components/drivers/usb/usbhost/class/udisk.c
index 6c8030b29a..8be311e657 100644
--- a/components/drivers/usb/usbhost/class/udisk.c
+++ b/components/drivers/usb/usbhost/class/udisk.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
diff --git a/components/drivers/usb/usbhost/class/ukbd.c b/components/drivers/usb/usbhost/class/ukbd.c
index 7d608de259..c89d60cd36 100644
--- a/components/drivers/usb/usbhost/class/ukbd.c
+++ b/components/drivers/usb/usbhost/class/ukbd.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -14,13 +14,13 @@
 
 #if defined(RT_USBH_HID) && defined(RT_USBH_HID_KEYBOARD)
 
-static struct uprotocal kbd_protocal; 
+static struct uprotocal kbd_protocal;
 
 static rt_err_t rt_usbh_hid_kbd_callback(void* arg)
 {
     int int1, int2;
-    struct uhid* hid; 
-    
+    struct uhid* hid;
+
     hid = (struct uhid*)arg;
 
     int1 = *(rt_uint32_t*)hid->buffer;
@@ -28,9 +28,9 @@ static rt_err_t rt_usbh_hid_kbd_callback(void* arg)
 
     if(int1 != 0 || int2 != 0)
     {
-        RT_DEBUG_LOG(RT_DEBUG_USB, ("key down 0x%x, 0x%x\n", int1, int2));    
+        RT_DEBUG_LOG(RT_DEBUG_USB, ("key down 0x%x, 0x%x\n", int1, int2));
     }
-    
+
     return RT_EOK;
 }
 
@@ -38,20 +38,20 @@ static rt_err_t rt_usbh_hid_kbd_init(void* arg)
 {
     struct uintf* intf = (struct uintf*)arg;
 
-    RT_ASSERT(intf != RT_NULL);        
-    
+    RT_ASSERT(intf != RT_NULL);
+
     rt_usbh_hid_set_protocal(intf, 0);
 
     rt_usbh_hid_set_idle(intf, 10, 0);
 
-    //RT_DEBUG_LOG(RT_DEBUG_USB, ("start usb keyboard\n"));    
+    //RT_DEBUG_LOG(RT_DEBUG_USB, ("start usb keyboard\n"));
 
     return RT_EOK;
 }
 
 /**
  * This function will define the hid keyboard protocal, it will be register to the protocal list.
- * 
+ *
  * @return the keyboard protocal structure.
  */
 uprotocal_t rt_usbh_hid_protocal_kbd(void)
diff --git a/components/drivers/usb/usbhost/class/umouse.c b/components/drivers/usb/usbhost/class/umouse.c
index e769475a98..94fca210bb 100644
--- a/components/drivers/usb/usbhost/class/umouse.c
+++ b/components/drivers/usb/usbhost/class/umouse.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
diff --git a/components/drivers/usb/usbhost/core/driver.c b/components/drivers/usb/usbhost/core/driver.c
index 37327108c1..6dad1409a0 100644
--- a/components/drivers/usb/usbhost/core/driver.c
+++ b/components/drivers/usb/usbhost/core/driver.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -17,21 +17,21 @@ static rt_list_t _driver_list;
 /**
  * This function will initilize the usb class driver related data structure,
  * and it should be invoked in the usb system initialization.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_class_driver_init(void)
 {
     rt_list_init(&_driver_list);
 
-    return RT_EOK;    
+    return RT_EOK;
 }
 
 /**
  * This function will register an usb class driver to the class driver manager.
  *
  * @param drv the pointer of the usb class driver.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 
@@ -41,15 +41,15 @@ rt_err_t rt_usbh_class_driver_register(ucd_t drv)
 
     /* insert class driver into driver list */
     rt_list_insert_after(&_driver_list, &(drv->list));
-    
-    return RT_EOK;    
+
+    return RT_EOK;
 }
 
 /**
  * This function will removes a previously registed usb class driver.
  *
  * @param drv the pointer of the usb class driver structure.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_class_driver_unregister(ucd_t drv)
@@ -67,7 +67,7 @@ rt_err_t rt_usbh_class_driver_unregister(ucd_t drv)
  *
  * @param drv the pointer of usb class driver.
  * @param args the parameter of run function.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_class_driver_enable(ucd_t drv, void* args)
@@ -85,7 +85,7 @@ rt_err_t rt_usbh_class_driver_enable(ucd_t drv, void* args)
  *
  * @param drv the pointer of usb class driver structure.
  * @param args the argument of the stop function.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_class_driver_disable(ucd_t drv, void* args)
@@ -102,7 +102,7 @@ rt_err_t rt_usbh_class_driver_disable(ucd_t drv, void* args)
 /**
  * This function finds a usb class driver by specified class code and subclass code.
  *
- * @param class_code the usb class driver's class code. 
+ * @param class_code the usb class driver's class code.
  * @param subclass_code the usb class driver's sub class code.
  *
  * @return the registered usb class driver on successful, or RT_NULL on failure.
@@ -118,7 +118,7 @@ ucd_t rt_usbh_class_driver_find(int class_code, int subclass_code)
     /* try to find driver object */
     for (node = _driver_list.next; node != &_driver_list; node = node->next)
     {
-        ucd_t drv = 
+        ucd_t drv =
             (ucd_t)rt_list_entry(node, struct uclass_driver, list);
         if (drv->class_code == class_code)
         {
diff --git a/components/drivers/usb/usbhost/core/hub.c b/components/drivers/usb/usbhost/core/hub.c
index eefa571472..b6381ec300 100644
--- a/components/drivers/usb/usbhost/core/hub.c
+++ b/components/drivers/usb/usbhost/core/hub.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -77,7 +77,7 @@ static rt_err_t root_hub_ctrl(struct uhcd *hcd, rt_uint16_t port, rt_uint8_t cmd
         return RT_ERROR;
     }
     return RT_EOK;
-} 
+}
 void rt_usbh_root_hub_connect_handler(struct uhcd *hcd, rt_uint8_t port, rt_bool_t isHS)
 {
     struct uhost_msg msg;
@@ -106,23 +106,23 @@ void rt_usbh_root_hub_disconnect_handler(struct uhcd *hcd, rt_uint8_t port)
 }
 
 /**
- * This function will do USB_REQ_GET_DESCRIPTOR bRequest for the device instance 
+ * This function will do USB_REQ_GET_DESCRIPTOR bRequest for the device instance
  * to get usb hub descriptor.
  *
  * @param intf the interface instance.
  * @buffer the data buffer to save usb hub descriptor.
  * @param nbytes the size of buffer
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hub_get_descriptor(struct uinstance* device, rt_uint8_t *buffer, rt_size_t nbytes)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(device != RT_NULL);
-    
+
     setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_DEVICE;
     setup.bRequest = USB_REQ_GET_DESCRIPTOR;
     setup.wIndex = 0;
@@ -135,24 +135,24 @@ rt_err_t rt_usbh_hub_get_descriptor(struct uinstance* device, rt_uint8_t *buffer
         {
             return RT_EOK;
         }
-    } 
-    return -RT_FALSE;    
+    }
+    return -RT_FALSE;
 }
 
 /**
- * This function will do USB_REQ_GET_STATUS bRequest for the device instance 
+ * This function will do USB_REQ_GET_STATUS bRequest for the device instance
  * to get usb hub status.
  *
  * @param intf the interface instance.
  * @buffer the data buffer to save usb hub status.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint32_t* buffer)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-    
+
     /* parameter check */
     RT_ASSERT(device != RT_NULL);
 
@@ -168,31 +168,31 @@ rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint32_t* buffer)
             return RT_EOK;
         }
     }
-    return -RT_FALSE;    
+    return -RT_FALSE;
 }
 
 /**
- * This function will do USB_REQ_GET_STATUS bRequest for the device instance 
+ * This function will do USB_REQ_GET_STATUS bRequest for the device instance
  * to get hub port status.
  *
  * @param intf the interface instance.
  * @port the hub port to get status.
  * @buffer the data buffer to save usb hub status.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hub_get_port_status(uhub_t hub, rt_uint16_t port, rt_uint32_t* buffer)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-    
+
     /* parameter check */
     RT_ASSERT(hub != RT_NULL);
 
     /* get roothub port status */
     if(hub->is_roothub)
     {
-        root_hub_ctrl(hub->hcd, port, RH_GET_PORT_STATUS, 
+        root_hub_ctrl(hub->hcd, port, RH_GET_PORT_STATUS,
             (void*)buffer);
         return RT_EOK;
     }
@@ -210,36 +210,36 @@ rt_err_t rt_usbh_hub_get_port_status(uhub_t hub, rt_uint16_t port, rt_uint32_t*
             return RT_EOK;
         }
     }
-    return -RT_FALSE;        
+    return -RT_FALSE;
 }
 
 /**
- * This function will do USB_REQ_CLEAR_FEATURE bRequest for the device instance 
+ * This function will do USB_REQ_CLEAR_FEATURE bRequest for the device instance
  * to clear feature of the hub port.
  *
  * @param intf the interface instance.
  * @port the hub port.
  * @feature feature to be cleared.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hub_clear_port_feature(uhub_t hub, rt_uint16_t port, rt_uint16_t feature)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(hub != RT_NULL);
 
     /* clear roothub feature */
     if(hub->is_roothub)
     {
-        root_hub_ctrl(hub->hcd, port, RH_CLEAR_PORT_FEATURE, 
+        root_hub_ctrl(hub->hcd, port, RH_CLEAR_PORT_FEATURE,
             (void*)(rt_uint32_t)feature);
         return RT_EOK;
     }
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_OTHER;
     setup.bRequest = USB_REQ_CLEAR_FEATURE;
     setup.wIndex = port;
@@ -250,37 +250,37 @@ rt_err_t rt_usbh_hub_clear_port_feature(uhub_t hub, rt_uint16_t port, rt_uint16_
     {
         return RT_EOK;
     }
-    return -RT_FALSE;    
+    return -RT_FALSE;
 }
 
 /**
- * This function will do USB_REQ_SET_FEATURE bRequest for the device instance 
+ * This function will do USB_REQ_SET_FEATURE bRequest for the device instance
  * to set feature of the hub port.
  *
  * @param intf the interface instance.
  * @port the hub port.
  * @feature feature to be set.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_hub_set_port_feature(uhub_t hub, rt_uint16_t port, 
+rt_err_t rt_usbh_hub_set_port_feature(uhub_t hub, rt_uint16_t port,
     rt_uint16_t feature)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-        
+
     /* parameter check */
     RT_ASSERT(hub != RT_NULL);
 
     /* clear roothub feature */
     if(hub->is_roothub)
     {
-        root_hub_ctrl(hub->hcd, port, RH_SET_PORT_FEATURE, 
+        root_hub_ctrl(hub->hcd, port, RH_SET_PORT_FEATURE,
             (void*)(rt_uint32_t)feature);
         return RT_EOK;
     }
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
         USB_REQ_TYPE_OTHER;
     setup.bRequest = USB_REQ_SET_FEATURE;
     setup.wIndex = port;
@@ -291,7 +291,7 @@ rt_err_t rt_usbh_hub_set_port_feature(uhub_t hub, rt_uint16_t port,
     {
         return RT_EOK;
     }
-    else return -RT_FALSE;        
+    else return -RT_FALSE;
 }
 
 /**
@@ -299,17 +299,17 @@ rt_err_t rt_usbh_hub_set_port_feature(uhub_t hub, rt_uint16_t port,
  *
  * @param intf the interface instance.
  * @param port the hub port.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hub_reset_port(uhub_t hub, rt_uint16_t port)
 {
     rt_err_t ret;
     rt_uint32_t pstatus;
-    
+
     /* parameter check */
     RT_ASSERT(hub != RT_NULL);
-    
+
     rt_thread_delay(50);
 
     /* reset hub port */
@@ -321,12 +321,12 @@ rt_err_t rt_usbh_hub_reset_port(uhub_t hub, rt_uint16_t port)
         ret = rt_usbh_hub_get_port_status(hub, port, &pstatus);
         if(!(pstatus & PORT_PRS)) break;
     }
-    
+
     /* clear port reset feature */
-    ret = rt_usbh_hub_clear_port_feature(hub, port, PORT_FEAT_C_RESET);    
+    ret = rt_usbh_hub_clear_port_feature(hub, port, PORT_FEAT_C_RESET);
     if(ret != RT_EOK) return ret;
 
-    rt_thread_delay(50);    
+    rt_thread_delay(50);
 
     return RT_EOK;
 }
@@ -336,7 +336,7 @@ rt_err_t rt_usbh_hub_reset_port(uhub_t hub, rt_uint16_t port)
  *
  * @param device the usb instance.
  * @param port the hub port.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_hub_port_debounce(uhub_t hub, rt_uint16_t port)
@@ -356,15 +356,15 @@ rt_err_t rt_usbh_hub_port_debounce(uhub_t hub, rt_uint16_t port)
     {
         ret = rt_usbh_hub_get_port_status(hub, port, &pstatus);
         if(ret != RT_EOK) return ret;
-            
-        if(!(pstatus & PORT_CCS)) 
+
+        if(!(pstatus & PORT_CCS))
         {
             connect = RT_FALSE;
             break;
         }
-        
+
         rt_thread_delay(delayticks);
-    }        
+    }
 
     if(connect) return RT_EOK;
     else return -RT_ERROR;
@@ -375,7 +375,7 @@ rt_err_t rt_usbh_hub_port_debounce(uhub_t hub, rt_uint16_t port)
  * disconnect events.
  *
  * @param intf the interface instance.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t rt_usbh_hub_port_change(uhub_t hub)
@@ -386,7 +386,7 @@ static rt_err_t rt_usbh_hub_port_change(uhub_t hub)
     /* parameter check */
     RT_ASSERT(hub != RT_NULL);
 
-    /* get usb device instance */    
+    /* get usb device instance */
     for (i = 0; i < hub->num_ports; i++)
     {
         rt_err_t ret;
@@ -394,7 +394,7 @@ static rt_err_t rt_usbh_hub_port_change(uhub_t hub)
         rt_uint32_t pstatus = 0;
 
         reconnect = RT_FALSE;
-        
+
         /* get hub port status */
         ret = rt_usbh_hub_get_port_status(hub, i + 1, &pstatus);
         if(ret != RT_EOK) continue;
@@ -402,8 +402,8 @@ static rt_err_t rt_usbh_hub_port_change(uhub_t hub)
         RT_DEBUG_LOG(RT_DEBUG_USB, ("port %d status 0x%x\n", i + 1, pstatus));
 
         /* check port status change */
-        if (pstatus & PORT_CCSC) 
-        {        
+        if (pstatus & PORT_CCSC)
+        {
             /* clear port status change feature */
             rt_usbh_hub_clear_port_feature(hub, i + 1, PORT_FEAT_C_CONNECTION);
             reconnect = RT_TRUE;
@@ -411,39 +411,39 @@ static rt_err_t rt_usbh_hub_port_change(uhub_t hub)
 
         if(pstatus & PORT_PESC)
         {
-            rt_usbh_hub_clear_port_feature(hub, i + 1, PORT_FEAT_C_ENABLE);            
+            rt_usbh_hub_clear_port_feature(hub, i + 1, PORT_FEAT_C_ENABLE);
             reconnect = RT_TRUE;
         }
-        
+
         if(reconnect)
-        {            
+        {
             if(hub->child[i] != RT_NULL && hub->child[i]->status != DEV_STATUS_IDLE)
-            { 
+            {
                 rt_usbh_detach_instance(hub->child[i]);
 
                 /* Child device have been detach. Set hub->child[i] to NULL. */
                 hub->child[i] = RT_NULL;
             }
-            
+
             ret = rt_usbh_hub_port_debounce(hub, i + 1);
             if(ret != RT_EOK) continue;
-            
+
             /* allocate an usb instance for new connected device */
             device = rt_usbh_alloc_instance(hub->hcd);
             if(device == RT_NULL) break;
-            
+
             /* set usb device speed */
             device->speed = (pstatus & PORT_LSDA) ? 1 : 0;
-            device->parent_hub = hub;    
+            device->parent_hub = hub;
             device->hcd = hub->hcd;
             device->port = i + 1;
             hub->child[i] = device;
 
             /* reset usb roothub port */
             rt_usbh_hub_reset_port(hub, i + 1);
-            
+
             /* attatch the usb instance to the hcd */
-            rt_usbh_attatch_instance(device); 
+            rt_usbh_attatch_instance(device);
         }
     }
 
@@ -454,7 +454,7 @@ static rt_err_t rt_usbh_hub_port_change(uhub_t hub)
  * This function is the callback function of hub's int endpoint, it is invoked when data comes.
  *
  * @param context the context of the callback function.
- * 
+ *
  * @return none.
  */
 static void rt_usbh_hub_irq(void* context)
@@ -462,9 +462,9 @@ static void rt_usbh_hub_irq(void* context)
     upipe_t pipe;
     uhub_t hub;
     int timeout = USB_TIMEOUT_BASIC;
-    
+
     RT_ASSERT(context != RT_NULL);
-    
+
     pipe = (upipe_t)context;
     hub = (uhub_t)pipe->user_data;
 
@@ -473,14 +473,14 @@ static void rt_usbh_hub_irq(void* context)
         RT_DEBUG_LOG(RT_DEBUG_USB,("hub irq error\n"));
         return;
     }
-    
+
     rt_usbh_hub_port_change(hub);
 
     RT_DEBUG_LOG(RT_DEBUG_USB,("hub int xfer...\n"));
 
     /* parameter check */
      RT_ASSERT(pipe->inst->hcd != RT_NULL);
-    
+
     rt_usb_hcd_pipe_xfer(hub->self->hcd, pipe, hub->buffer, pipe->ep.wMaxPacketSize, timeout);
 }
 
@@ -489,7 +489,7 @@ static void rt_usbh_hub_irq(void* context)
  * as a hub class device, it will continue to do the enumulate process.
  *
  * @param arg the argument.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 
@@ -505,7 +505,7 @@ static rt_err_t rt_usbh_hub_enable(void *arg)
     int timeout = USB_TIMEOUT_LONG;
     /* paremeter check */
     RT_ASSERT(intf != RT_NULL);
-    
+
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_hub_run\n"));
 
     /* get usb device instance */
@@ -515,7 +515,7 @@ static rt_err_t rt_usbh_hub_enable(void *arg)
     hub = rt_malloc(sizeof(struct uhub));
     RT_ASSERT(hub != RT_NULL);
     rt_memset(hub, 0, sizeof(struct uhub));
-    
+
     /* make interface instance's user data point to hub instance */
     intf->user_data = (void*)hub;
 
@@ -524,17 +524,17 @@ static rt_err_t rt_usbh_hub_enable(void *arg)
     if(ret != RT_EOK)
     {
         rt_kprintf("get hub descriptor failed\n");
-        return -RT_ERROR;        
+        return -RT_ERROR;
     }
 
     /* get full hub descriptor */
-    ret = rt_usbh_hub_get_descriptor(device, (rt_uint8_t*)&hub->hub_desc, 
+    ret = rt_usbh_hub_get_descriptor(device, (rt_uint8_t*)&hub->hub_desc,
         hub->hub_desc.length);
     if(ret != RT_EOK)
     {
         rt_kprintf("get hub descriptor again failed\n");
-        return -RT_ERROR;        
-    }    
+        return -RT_ERROR;
+    }
 
     /* get hub ports number */
     /* If hub device supported ports over USB_HUB_PORT_NUM(Ex: 8 port hub). Set hub->num_ports to USB_HUB_PORT_NUM */
@@ -554,7 +554,7 @@ static rt_err_t rt_usbh_hub_enable(void *arg)
             * 2 * RT_TICK_PER_SECOND / 1000 );
     }
 
-    if(intf->intf_desc->bNumEndpoints != 1) 
+    if(intf->intf_desc->bNumEndpoints != 1)
         return -RT_ERROR;
 
     /* get endpoint descriptor from interface descriptor */
@@ -565,12 +565,12 @@ static rt_err_t rt_usbh_hub_enable(void *arg)
         return -RT_ERROR;
     }
 
-    /* the endpoint type of hub class should be interrupt */        
+    /* the endpoint type of hub class should be interrupt */
     if( USB_EP_ATTR(ep_desc->bmAttributes) == USB_EP_ATTR_INT)
     {
         /* the endpoint direction of hub class should be in */
         if(ep_desc->bEndpointAddress & USB_DIR_IN)
-        {    
+        {
             /* allocate a pipe according to the endpoint type */
             pipe_in = rt_usb_instance_find_pipe(device,ep_desc->bEndpointAddress);
             if(pipe_in == RT_NULL)
@@ -585,17 +585,17 @@ static rt_err_t rt_usbh_hub_enable(void *arg)
     /* parameter check */
     RT_ASSERT(device->hcd != RT_NULL);
     pipe_in->user_data = hub;
-    rt_usb_hcd_pipe_xfer(hub->hcd, pipe_in, hub->buffer, 
+    rt_usb_hcd_pipe_xfer(hub->hcd, pipe_in, hub->buffer,
         pipe_in->ep.wMaxPacketSize, timeout);
     return RT_EOK;
 }
 
 /**
- * This function will be invoked when usb hub plug out is detected and it would clean 
+ * This function will be invoked when usb hub plug out is detected and it would clean
  * and release all hub class related resources.
  *
  * @param arg the argument.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 static rt_err_t rt_usbh_hub_disable(void* arg)
@@ -615,7 +615,7 @@ static rt_err_t rt_usbh_hub_disable(void* arg)
         if(hub->child[i] != RT_NULL)
             rt_usbh_detach_instance(hub->child[i]);
     }
-    
+
     if(hub != RT_NULL) rt_free(hub);
 
     return RT_EOK;
@@ -624,13 +624,13 @@ static rt_err_t rt_usbh_hub_disable(void* arg)
 /**
  * This function will register hub class driver to the usb class driver manager.
  * and it should be invoked in the usb system initialization.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 ucd_t rt_usbh_class_driver_hub(void)
-{    
+{
     hub_driver.class_code = USB_CLASS_HUB;
-    
+
     hub_driver.enable = rt_usbh_hub_enable;
     hub_driver.disable = rt_usbh_hub_disable;
 
@@ -638,27 +638,27 @@ ucd_t rt_usbh_class_driver_hub(void)
 }
 
 /**
- * This function is the main entry of usb hub thread, it is in charge of 
- * processing all messages received from the usb message buffer.  
+ * This function is the main entry of usb hub thread, it is in charge of
+ * processing all messages received from the usb message buffer.
  *
  * @param parameter the parameter of the usb host thread.
- * 
+ *
  * @return none.
  */
 static void rt_usbh_hub_thread_entry(void* parameter)
-{    
+{
     while(1)
-    {    
+    {
         struct uhost_msg msg;
-        
+
         /* receive message */
-        if(rt_mq_recv(usb_mq, &msg, sizeof(struct uhost_msg), RT_WAITING_FOREVER) 
+        if(rt_mq_recv(usb_mq, &msg, sizeof(struct uhost_msg), RT_WAITING_FOREVER)
             != RT_EOK ) continue;
 
         //RT_DEBUG_LOG(RT_DEBUG_USB, ("msg type %d\n", msg.type));
-        
+
         switch (msg.type)
-        {        
+        {
         case USB_MSG_CONNECT_CHANGE:
             rt_usbh_hub_port_change(msg.content.hub);
             break;
@@ -668,7 +668,7 @@ static void rt_usbh_hub_thread_entry(void* parameter)
             break;
         default:
             break;
-        }            
+        }
     }
 }
 
@@ -676,8 +676,8 @@ static void rt_usbh_hub_thread_entry(void* parameter)
  * This function will post an message to the usb message queue,
  *
  * @param msg the message to be posted
- * 
- * @return the error code, RT_EOK on successfully. 
+ *
+ * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_event_signal(struct uhost_msg* msg)
 {
@@ -693,7 +693,7 @@ rt_err_t rt_usbh_event_signal(struct uhost_msg* msg)
  * This function will initialize usb hub thread.
  *
  * @return none.
- * 
+ *
  */
 void rt_usbh_hub_init(uhcd_t hcd)
 {
@@ -705,9 +705,9 @@ void rt_usbh_hub_init(uhcd_t hcd)
     root_hub.num_ports = hcd->num_ports;
     /* create usb message queue */
     usb_mq = rt_mq_create("usbh", 32, 16, RT_IPC_FLAG_FIFO);
-    
+
     /* create usb hub thread */
-    thread = rt_thread_create("usbh", rt_usbh_hub_thread_entry, RT_NULL, 
+    thread = rt_thread_create("usbh", rt_usbh_hub_thread_entry, RT_NULL,
         USB_THREAD_STACK_SIZE, 8, 20);
     if(thread != RT_NULL)
     {
diff --git a/components/drivers/usb/usbhost/core/usbhost.c b/components/drivers/usb/usbhost/core/usbhost.c
index f0294238c4..a76f6d4586 100644
--- a/components/drivers/usb/usbhost/core/usbhost.c
+++ b/components/drivers/usb/usbhost/core/usbhost.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -19,13 +19,13 @@
 /**
  * This function will initialize the usb host stack, all the usb class driver and
  * host controller driver are also be initialized here.
- * 
+ *
  * @return none.
  */
 rt_err_t rt_usb_host_init(void)
 {
     ucd_t drv;
-    rt_device_t uhc;    
+    rt_device_t uhc;
 
     uhc = rt_device_find(USB_HOST_CONTROLLER_NAME);
     if(uhc == RT_NULL)
diff --git a/components/drivers/usb/usbhost/core/usbhost_core.c b/components/drivers/usb/usbhost/core/usbhost_core.c
index d72dca82f2..71fe3b8b3f 100644
--- a/components/drivers/usb/usbhost/core/usbhost_core.c
+++ b/components/drivers/usb/usbhost/core/usbhost_core.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -27,28 +27,28 @@ uinst_t rt_usbh_alloc_instance(uhcd_t uhcd)
 
     /* lock scheduler */
     rt_enter_critical();
-    
+
     for(i=0; i<USB_MAX_DEVICE; i++)
     {
         /* to find an idle instance handle */
         if(dev[i].status != DEV_STATUS_IDLE) continue;
-        
+
         /* initialize the usb device instance */
         rt_memset(&dev[i], 0, sizeof(struct uinstance));
-        
+
         dev[i].status = DEV_STATUS_BUSY;
         dev[i].index = i + 1;
         dev[i].address = 0;
         dev[i].max_packet_size = 0x8;
         rt_list_init(&dev[i].pipe);
         dev[i].hcd = uhcd;
-        /* unlock scheduler */        
+        /* unlock scheduler */
         rt_exit_critical();
         return &dev[i];
     }
 
-    /* unlock scheduler */            
-    rt_exit_critical();     
+    /* unlock scheduler */
+    rt_exit_critical();
 
     return RT_NULL;
 }
@@ -59,10 +59,10 @@ uinst_t rt_usbh_alloc_instance(uhcd_t uhcd)
  *
  * @param hcd the host controller driver.
  * @param device the usb device instance.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-static struct uendpoint_descriptor ep0_out_desc = 
+static struct uendpoint_descriptor ep0_out_desc =
 {
     /*endpoint descriptor*/
     USB_DESC_LENGTH_ENDPOINT,
@@ -72,7 +72,7 @@ static struct uendpoint_descriptor ep0_out_desc =
     0x00,
     0x00,
 };
-static struct uendpoint_descriptor ep0_in_desc = 
+static struct uendpoint_descriptor ep0_in_desc =
 {
     /*endpoint descriptor*/
     USB_DESC_LENGTH_ENDPOINT,
@@ -95,10 +95,10 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
     ucd_t drv;
 
     RT_ASSERT(device != RT_NULL);
-    
+
     rt_memset(&cfg_desc, 0, sizeof(struct uconfig_descriptor));
     dev_desc = &device->dev_desc;
-    
+
     /* alloc address 0 ep0 pipe*/
     ep0_out_desc.wMaxPacketSize = 8;
     ep0_in_desc.wMaxPacketSize = 8;
@@ -106,7 +106,7 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
     rt_usb_hcd_alloc_pipe(device->hcd, &device->pipe_ep0_in, device, &ep0_in_desc);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("start enumnation\n"));
-    
+
     /* get device descriptor head */
     ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_DEVICE, (void*)dev_desc, 8);
     if(ret != RT_EOK)
@@ -114,7 +114,7 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
         rt_kprintf("get device descriptor head failed\n");
         return ret;
     }
-    
+
     /* reset bus */
     rt_usbh_hub_reset_port(device->parent_hub, device->port);
     rt_thread_delay(2);
@@ -127,20 +127,20 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
         return ret;
     }
     /* free address 0 ep0 pipe*/
-    
+
     rt_usb_hcd_free_pipe(device->hcd,device->pipe_ep0_out);
     rt_usb_hcd_free_pipe(device->hcd,device->pipe_ep0_in);
-    
+
     /* set device max packet size */
     ep0_out_desc.wMaxPacketSize = device->dev_desc.bMaxPacketSize0;
     ep0_in_desc.wMaxPacketSize = device->dev_desc.bMaxPacketSize0;
-    
+
     /* alloc true address ep0 pipe*/
     rt_usb_hcd_alloc_pipe(device->hcd, &device->pipe_ep0_out, device, &ep0_out_desc);
     rt_usb_hcd_alloc_pipe(device->hcd, &device->pipe_ep0_in, device, &ep0_in_desc);
     RT_DEBUG_LOG(RT_DEBUG_USB, ("get device descriptor length %d\n",
                                 dev_desc->bLength));
-    
+
     /* get full device descriptor again */
     ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_DEVICE, (void*)dev_desc, dev_desc->bLength);
     if(ret != RT_EOK)
@@ -169,7 +169,7 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
     rt_memset(device->cfg_desc, 0, cfg_desc.wTotalLength);
 
     /* get full configuration descriptor */
-    ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_CONFIGURATION, 
+    ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_CONFIGURATION,
         device->cfg_desc, cfg_desc.wTotalLength);
     if(ret != RT_EOK)
     {
@@ -179,12 +179,12 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
 
     /* set configuration */
     ret = rt_usbh_set_configure(device, 1);
-    if(ret != RT_EOK) 
+    if(ret != RT_EOK)
     {
         return ret;
     }
     for(i=0; i<device->cfg_desc->bNumInterfaces; i++)
-    {        
+    {
         /* get interface descriptor through configuration descriptor */
         ret = rt_usbh_get_interface_descriptor(device->cfg_desc, i, &intf_desc);
         if(ret != RT_EOK)
@@ -193,7 +193,7 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
             return -RT_ERROR;
         }
 
-        RT_DEBUG_LOG(RT_DEBUG_USB, ("interface class 0x%x, subclass 0x%x\n", 
+        RT_DEBUG_LOG(RT_DEBUG_USB, ("interface class 0x%x, subclass 0x%x\n",
                                     intf_desc->bInterfaceClass,
                                     intf_desc->bInterfaceSubClass));
         /* alloc pipe*/
@@ -216,9 +216,9 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
             }
         }
         /* find driver by class code found in interface descriptor */
-        drv = rt_usbh_class_driver_find(intf_desc->bInterfaceClass, 
+        drv = rt_usbh_class_driver_find(intf_desc->bInterfaceClass,
             intf_desc->bInterfaceSubClass);
-        
+
         if(drv != RT_NULL)
         {
             /* allocate memory for interface device */
@@ -245,7 +245,7 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
             continue;
         }
     }
-    
+
     return RT_EOK;
 }
 
@@ -254,19 +254,19 @@ rt_err_t rt_usbh_attatch_instance(uinst_t device)
  * and release all resource.
  *
  * @param device the usb device instance.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_detach_instance(uinst_t device)
 {
     int i = 0;
     rt_list_t * l;
-    if(device == RT_NULL) 
+    if(device == RT_NULL)
     {
         rt_kprintf("no usb instance to detach\n");
         return -RT_ERROR;
     }
-    
+
     /* free configration descriptor */
     if (device->cfg_desc) {
         for (i = 0; i < device->cfg_desc->bNumInterfaces; i++)
@@ -282,10 +282,10 @@ rt_err_t rt_usbh_detach_instance(uinst_t device)
         }
         rt_free(device->cfg_desc);
     }
-    
+
     rt_usb_hcd_free_pipe(device->hcd,device->pipe_ep0_out);
     rt_usb_hcd_free_pipe(device->hcd,device->pipe_ep0_in);
-    
+
     while(device->pipe.next!= &device->pipe)
     {
         l = device->pipe.next;
@@ -293,29 +293,29 @@ rt_err_t rt_usbh_detach_instance(uinst_t device)
         rt_usb_hcd_free_pipe(device->hcd,rt_list_entry(l,struct upipe,list));
     }
     rt_memset(device, 0, sizeof(struct uinstance));
-    
+
     return RT_EOK;
 }
 
 /**
  * This function will do USB_REQ_GET_DESCRIPTO' bRequest for the usb device instance,
  *
- * @param device the usb device instance. 
+ * @param device the usb device instance.
  * @param type the type of descriptor bRequest.
  * @param buffer the data buffer to save requested data
  * @param nbytes the size of buffer
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_get_descriptor(uinst_t device, rt_uint8_t type, void* buffer, 
+rt_err_t rt_usbh_get_descriptor(uinst_t device, rt_uint8_t type, void* buffer,
     int nbytes)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-    
+
     RT_ASSERT(device != RT_NULL);
 
-    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD | 
+    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD |
         USB_REQ_TYPE_DEVICE;
     setup.bRequest = USB_REQ_GET_DESCRIPTOR;
     setup.wIndex = 0;
@@ -339,19 +339,19 @@ rt_err_t rt_usbh_get_descriptor(uinst_t device, rt_uint8_t type, void* buffer,
  * This function will set an address to the usb device.
  *
  * @param device the usb device instance.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_set_address(uinst_t device)
 {
     struct urequest setup;
     int timeout = USB_TIMEOUT_BASIC;
-    
+
     RT_ASSERT(device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_set_address\n"));
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
         USB_REQ_TYPE_DEVICE;
     setup.bRequest = USB_REQ_SET_ADDRESS;
     setup.wIndex = 0;
@@ -375,7 +375,7 @@ rt_err_t rt_usbh_set_address(uinst_t device)
  *
  * @param device the usb device instance.
  * @param config the configuration number.
-  * 
+  *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_set_configure(uinst_t device, int config)
@@ -386,7 +386,7 @@ rt_err_t rt_usbh_set_configure(uinst_t device, int config)
     /* check parameter */
     RT_ASSERT(device != RT_NULL);
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
         USB_REQ_TYPE_DEVICE;
     setup.bRequest = USB_REQ_SET_CONFIGURATION;
     setup.wIndex = 0;
@@ -401,7 +401,7 @@ rt_err_t rt_usbh_set_configure(uinst_t device, int config)
     {
         return RT_ERROR;
     }
-    return RT_EOK;    
+    return RT_EOK;
 }
 
 /**
@@ -409,7 +409,7 @@ rt_err_t rt_usbh_set_configure(uinst_t device, int config)
  *
  * @param device the usb device instance.
  * @param intf the interface number.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_set_interface(uinst_t device, int intf)
@@ -420,7 +420,7 @@ rt_err_t rt_usbh_set_interface(uinst_t device, int intf)
     /* check parameter */
     RT_ASSERT(device != RT_NULL);
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
         USB_REQ_TYPE_INTERFACE;
     setup.bRequest = USB_REQ_SET_INTERFACE;
     setup.wIndex = 0;
@@ -431,8 +431,8 @@ rt_err_t rt_usbh_set_interface(uinst_t device, int intf)
     {
         return RT_ERROR;
     }
-    
-    return RT_EOK;    
+
+    return RT_EOK;
 }
 
 /**
@@ -440,7 +440,7 @@ rt_err_t rt_usbh_set_interface(uinst_t device, int intf)
  *
  * @param device the usb device instance.
  * @param endpoint the endpoint number of the usb device.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
 rt_err_t rt_usbh_clear_feature(uinst_t device, int endpoint, int feature)
@@ -451,7 +451,7 @@ rt_err_t rt_usbh_clear_feature(uinst_t device, int endpoint, int feature)
     /* check parameter */
     RT_ASSERT(device != RT_NULL);
 
-    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | 
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
         USB_REQ_TYPE_ENDPOINT;
     setup.bRequest = USB_REQ_CLEAR_FEATURE;
     setup.wIndex = endpoint;
@@ -462,8 +462,8 @@ rt_err_t rt_usbh_clear_feature(uinst_t device, int endpoint, int feature)
     {
         return RT_ERROR;
     }
-    
-    return RT_EOK;    
+
+    return RT_EOK;
 }
 
 /**
@@ -472,10 +472,10 @@ rt_err_t rt_usbh_clear_feature(uinst_t device, int endpoint, int feature)
  * @param cfg_desc the point of configuration descriptor structure.
  * @param num the number of interface descriptor.
  * @intf_desc the point of interface descriptor point.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, 
+rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num,
     uintf_desc_t* intf_desc)
 {
     rt_uint32_t ptr, depth = 0;
@@ -487,9 +487,9 @@ rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num,
     ptr = (rt_uint32_t)cfg_desc + cfg_desc->bLength;
     while(ptr < (rt_uint32_t)cfg_desc + cfg_desc->wTotalLength)
     {
-        if(depth++ > 0x20) 
+        if(depth++ > 0x20)
         {
-            *intf_desc = RT_NULL;        
+            *intf_desc = RT_NULL;
             return -RT_EIO;
         }
         desc = (udesc_t)ptr;
@@ -500,10 +500,10 @@ rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num,
                 *intf_desc = (uintf_desc_t)desc;
 
                 RT_DEBUG_LOG(RT_DEBUG_USB,
-                             ("rt_usb_get_interface_descriptor: %d\n", num));                
+                             ("rt_usb_get_interface_descriptor: %d\n", num));
                 return RT_EOK;
             }
-        }    
+        }
         ptr = (rt_uint32_t)desc + desc->bLength;
     }
 
@@ -517,14 +517,14 @@ rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num,
  * @param intf_desc the point of interface descriptor structure.
  * @param num the number of endpoint descriptor.
  * @param ep_desc the point of endpoint descriptor point.
- * 
+ *
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_get_endpoint_descriptor(uintf_desc_t intf_desc, int num, 
+rt_err_t rt_usbh_get_endpoint_descriptor(uintf_desc_t intf_desc, int num,
     uep_desc_t* ep_desc)
 {
     int count = 0, depth = 0;
-    rt_uint32_t ptr;    
+    rt_uint32_t ptr;
     udesc_t desc;
 
     /* check parameter */
@@ -535,15 +535,15 @@ rt_err_t rt_usbh_get_endpoint_descriptor(uintf_desc_t intf_desc, int num,
     ptr = (rt_uint32_t)intf_desc + intf_desc->bLength;
     while(count < intf_desc->bNumEndpoints)
     {
-        if(depth++ > 0x20) 
+        if(depth++ > 0x20)
         {
-            *ep_desc = RT_NULL;            
+            *ep_desc = RT_NULL;
             return -RT_EIO;
         }
-        desc = (udesc_t)ptr;        
+        desc = (udesc_t)ptr;
         if(desc->type == USB_DESC_TYPE_ENDPOINT)
         {
-            if(num == count) 
+            if(num == count)
             {
                 *ep_desc = (uep_desc_t)desc;