1 files changed, 89 insertions, 89 deletions

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;