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

[lts 3.1.x] format codes

1 files changed, 124 insertions, 124 deletions

diff --git a/components/drivers/usb/usbdevice/class/mstorage.c b/components/drivers/usb/usbdevice/class/mstorage.c
index 0cee2c3e16..89be813ad1 100644
--- a/components/drivers/usb/usbdevice/class/mstorage.c
+++ b/components/drivers/usb/usbdevice/class/mstorage.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
  *
@@ -7,7 +7,7 @@
  * Date           Author       Notes
  * 2012-10-01     Yi Qiu       first version
  * 2012-11-25     Heyuanjie87  reduce the memory consumption
- * 2012-12-09     Heyuanjie87  change function and endpoint handler 
+ * 2012-12-09     Heyuanjie87  change function and endpoint handler
  * 2013-07-25     Yi Qiu       update for USB CV test
  */
 
@@ -20,10 +20,10 @@
 enum STAT
 {
     STAT_CBW,
-    STAT_CMD,        
+    STAT_CMD,
     STAT_CSW,
     STAT_RECEIVE,
-    STAT_SEND,        
+    STAT_SEND,
 };
 
 typedef enum
@@ -45,7 +45,7 @@ typedef rt_size_t (*cbw_handler)(ufunction_t func, ustorage_cbw_t cbw);
 struct scsi_cmd
 {
     rt_uint16_t cmd;
-    cbw_handler handler;    
+    cbw_handler handler;
     rt_size_t cmd_len;
     CB_SIZE_TYPE type;
     rt_size_t data_size;
@@ -53,10 +53,10 @@ struct scsi_cmd
 };
 
 struct mstorage
-{    
+{
     struct ustorage_csw csw_response;
     uep_t ep_in;
-    uep_t ep_out;    
+    uep_t ep_out;
     int status;
     rt_uint32_t cb_data_size;
     rt_device_t disk;
@@ -64,7 +64,7 @@ struct mstorage
     rt_int32_t count;
     rt_int32_t size;
     struct scsi_cmd* processing;
-    struct rt_device_blk_geometry geometry;    
+    struct rt_device_blk_geometry geometry;
 };
 
 ALIGN(4)
@@ -179,9 +179,9 @@ static struct scsi_cmd cmd_data[] =
     {SCSI_REQUEST_SENSE,   _request_sense,   6,  COUNT,       0, DIR_IN},
     {SCSI_INQUIRY_CMD,     _inquiry_cmd,     6,  COUNT,       0, DIR_IN},
     {SCSI_ALLOW_REMOVAL,   _allow_removal,   6,  FIXED,       0, DIR_NONE},
-    {SCSI_MODE_SENSE_6,    _mode_sense_6,    6,  COUNT,       0, DIR_IN},             
-    {SCSI_START_STOP,      _start_stop,      6,  FIXED,       0, DIR_NONE},            
-    {SCSI_READ_CAPACITIES, _read_capacities, 10, COUNT,       0, DIR_NONE},            
+    {SCSI_MODE_SENSE_6,    _mode_sense_6,    6,  COUNT,       0, DIR_IN},
+    {SCSI_START_STOP,      _start_stop,      6,  FIXED,       0, DIR_NONE},
+    {SCSI_READ_CAPACITIES, _read_capacities, 10, COUNT,       0, DIR_NONE},
     {SCSI_READ_CAPACITY,   _read_capacity,   10, FIXED,       8, DIR_IN},
     {SCSI_READ_10,         _read_10,         10, BLOCK_COUNT, 0, DIR_IN},
     {SCSI_WRITE_10,        _write_10,        10, BLOCK_COUNT, 0, DIR_OUT},
@@ -196,9 +196,9 @@ static void _send_status(ufunction_t func)
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_send_status\n"));
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     data->ep_in->request.buffer = (rt_uint8_t*)&data->csw_response;
-    data->ep_in->request.size = SIZEOF_CSW;    
+    data->ep_in->request.size = SIZEOF_CSW;
     data->ep_in->request.req_type = UIO_REQUEST_WRITE;
     rt_usbd_io_request(func->device, data->ep_in, &data->ep_in->request);
     data->status = STAT_CSW;
@@ -209,13 +209,13 @@ static rt_size_t _test_unit_ready(ufunction_t func, ustorage_cbw_t cbw)
     struct mstorage *data;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_test_unit_ready\n"));
 
     data = (struct mstorage*)func->user_data;
     data->csw_response.status = 0;
-        
+
     return 0;
 }
 
@@ -224,7 +224,7 @@ static rt_size_t _allow_removal(ufunction_t func, ustorage_cbw_t cbw)
     struct mstorage *data;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_allow_removal\n"));
 
@@ -237,7 +237,7 @@ static rt_size_t _allow_removal(ufunction_t func, ustorage_cbw_t cbw)
 /**
  * This function will handle inquiry command request.
  *
- * @param func the usb function object. 
+ * @param func the usb function object.
  * @param cbw the command block wrapper.
  *
  * @return RT_EOK on successful.
@@ -249,12 +249,12 @@ static rt_size_t _inquiry_cmd(ufunction_t func, ustorage_cbw_t cbw)
     rt_uint8_t *buf;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_inquiry_cmd\n"));
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     buf = data->ep_in->buffer;
 
     *(rt_uint32_t*)&buf[0] = 0x0 | (0x80 << 8);
@@ -277,7 +277,7 @@ static rt_size_t _inquiry_cmd(ufunction_t func, ustorage_cbw_t cbw)
 /**
  * This function will handle sense request.
  *
- * @param func the usb function object. 
+ * @param func the usb function object.
  * @param cbw the command block wrapper.
  *
  * @return RT_EOK on successful.
@@ -288,12 +288,12 @@ static rt_size_t _request_sense(ufunction_t func, ustorage_cbw_t cbw)
     struct request_sense_data *buf;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_request_sense\n"));
-    
-    data = (struct mstorage*)func->user_data;   
+
+    data = (struct mstorage*)func->user_data;
     buf = (struct request_sense_data *)data->ep_in->buffer;
 
     buf->ErrorCode = 0x70;
@@ -321,7 +321,7 @@ static rt_size_t _request_sense(ufunction_t func, ustorage_cbw_t cbw)
  * This function will handle mode_sense_6 request.
  *
  * @param func the usb function object.
- * @param cbw the command block wrapper. 
+ * @param cbw the command block wrapper.
  *
  * @return RT_EOK on successful.
  */
@@ -331,12 +331,12 @@ static rt_size_t _mode_sense_6(ufunction_t func, ustorage_cbw_t cbw)
     rt_uint8_t *buf;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_mode_sense_6\n"));
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     buf = data->ep_in->buffer;
     buf[0] = 3;
     buf[1] = 0;
@@ -356,7 +356,7 @@ static rt_size_t _mode_sense_6(ufunction_t func, ustorage_cbw_t cbw)
 /**
  * This function will handle read_capacities request.
  *
- * @param func the usb function object. 
+ * @param func the usb function object.
  * @param cbw the command block wrapper.
  *
  * @return RT_EOK on successful.
@@ -368,12 +368,12 @@ static rt_size_t _read_capacities(ufunction_t func, ustorage_cbw_t cbw)
     rt_uint32_t sector_count, sector_size;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_read_capacities\n"));
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     buf = data->ep_in->buffer;
     sector_count = data->geometry.sector_count;
     sector_size = data->geometry.bytes_per_sector;
@@ -401,7 +401,7 @@ static rt_size_t _read_capacities(ufunction_t func, ustorage_cbw_t cbw)
 /**
  * This function will handle read_capacity request.
  *
- * @param func the usb function object. 
+ * @param func the usb function object.
  * @param cbw the command block wapper.
  *
  * @return RT_EOK on successful.
@@ -414,13 +414,13 @@ static rt_size_t _read_capacity(ufunction_t func, ustorage_cbw_t cbw)
     rt_uint32_t sector_count, sector_size;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_read_capacity\n"));
 
-    data = (struct mstorage*)func->user_data;   
-    buf = data->ep_in->buffer;    
+    data = (struct mstorage*)func->user_data;
+    buf = data->ep_in->buffer;
     sector_count = data->geometry.sector_count - 1; /* Last Logical Block Address */
     sector_size = data->geometry.bytes_per_sector;
 
@@ -455,19 +455,19 @@ static rt_size_t _read_10(ufunction_t func, ustorage_cbw_t cbw)
 {
     struct mstorage *data;
     rt_size_t size;
-    
+
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL);    
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
-    data = (struct mstorage*)func->user_data;           
+    data = (struct mstorage*)func->user_data;
     data->block = cbw->cb[2]<<24 | cbw->cb[3]<<16 | cbw->cb[4]<<8  |
              cbw->cb[5]<<0;
     data->count = cbw->cb[7]<<8 | cbw->cb[8]<<0;
 
     RT_ASSERT(data->count < data->geometry.sector_count);
 
-    data->csw_response.data_reside = data->cb_data_size;    
+    data->csw_response.data_reside = data->cb_data_size;
     size = rt_device_read(data->disk, data->block, data->ep_in->buffer, 1);
     if(size == 0)
     {
@@ -475,11 +475,11 @@ static rt_size_t _read_10(ufunction_t func, ustorage_cbw_t cbw)
     }
 
     data->ep_in->request.buffer = data->ep_in->buffer;
-    data->ep_in->request.size = data->geometry.bytes_per_sector;    
-    data->ep_in->request.req_type = UIO_REQUEST_WRITE;    
+    data->ep_in->request.size = data->geometry.bytes_per_sector;
+    data->ep_in->request.req_type = UIO_REQUEST_WRITE;
     rt_usbd_io_request(func->device, data->ep_in, &data->ep_in->request);
     data->status = STAT_SEND;
-    
+
     return data->geometry.bytes_per_sector;
 }
 
@@ -499,7 +499,7 @@ static rt_size_t _write_10(ufunction_t func, ustorage_cbw_t cbw)
     RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
 
     data->block = cbw->cb[2]<<24 | cbw->cb[3]<<16 | cbw->cb[4]<<8  |
              cbw->cb[5]<<0;
@@ -511,13 +511,13 @@ static rt_size_t _write_10(ufunction_t func, ustorage_cbw_t cbw)
                                 data->count, data->block, data->geometry.sector_count));
 
     data->csw_response.data_reside = data->cb_data_size;
-    
+
     data->ep_out->request.buffer = data->ep_out->buffer;
-    data->ep_out->request.size = data->geometry.bytes_per_sector;    
+    data->ep_out->request.size = data->geometry.bytes_per_sector;
     data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;
     rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);
     data->status = STAT_RECEIVE;
-    
+
     return data->geometry.bytes_per_sector;
 }
 
@@ -533,42 +533,42 @@ static rt_size_t _verify_10(ufunction_t func, ustorage_cbw_t cbw)
     struct mstorage *data;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_verify_10\n"));
 
     data = (struct mstorage*)func->user_data;
     data->csw_response.status = 0;
-        
+
     return 0;
 }
 
-static rt_size_t _start_stop(ufunction_t func, 
+static rt_size_t _start_stop(ufunction_t func,
     ustorage_cbw_t cbw)
 {
     struct mstorage *data;
 
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL); 
+    RT_ASSERT(func->device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_start_stop\n"));
 
     data = (struct mstorage*)func->user_data;
     data->csw_response.status = 0;
-        
+
     return 0;
 }
 
 static rt_err_t _ep_in_handler(ufunction_t func, rt_size_t size)
 {
     struct mstorage *data;
-    
+
     RT_ASSERT(func != RT_NULL);
     RT_ASSERT(func->device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_ep_in_handler\n"));
-    
-    data = (struct mstorage*)func->user_data;   
+
+    data = (struct mstorage*)func->user_data;
 
     switch(data->status)
     {
@@ -576,15 +576,15 @@ static rt_err_t _ep_in_handler(ufunction_t func, rt_size_t size)
         if(data->ep_in->request.size != SIZEOF_CSW)
         {
             rt_kprintf("Size of csw command error\n");
-            rt_usbd_ep_set_stall(func->device, data->ep_in);            
+            rt_usbd_ep_set_stall(func->device, data->ep_in);
         }
         else
         {
             RT_DEBUG_LOG(RT_DEBUG_USB, ("return to cbw status\n"));
             data->ep_out->request.buffer = data->ep_out->buffer;
             data->ep_out->request.size = SIZEOF_CBW;
-            data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;    
-            rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);            
+            data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;
+            rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);
             data->status = STAT_CBW;
         }
         break;
@@ -597,47 +597,47 @@ static rt_err_t _ep_in_handler(ufunction_t func, rt_size_t size)
         {
             data->csw_response.data_reside -= data->ep_in->request.size;
             if(data->csw_response.data_reside != 0)
-            {            
-                RT_DEBUG_LOG(RT_DEBUG_USB, ("data_reside %d, request %d\n", 
+            {
+                RT_DEBUG_LOG(RT_DEBUG_USB, ("data_reside %d, request %d\n",
                     data->csw_response.data_reside, data->ep_in->request.size));
                 if(data->processing->dir == DIR_OUT)
                 {
                     rt_usbd_ep_set_stall(func->device, data->ep_out);
                 }
                 else
-                {   
+                {
                     //rt_kprintf("warning:in stall path but not stall\n");
-                    
+
                     /* FIXME: Disable the operation or the disk cannot work. */
-                    //rt_usbd_ep_set_stall(func->device, data->ep_in);                    
+                    //rt_usbd_ep_set_stall(func->device, data->ep_in);
                 }
                 data->csw_response.data_reside = 0;
             }
             }
         _send_status(func);
         break;
-     case STAT_SEND:        
+     case STAT_SEND:
         data->csw_response.data_reside -= data->ep_in->request.size;
-        data->count--;    
-        data->block++;        
+        data->count--;
+        data->block++;
         if(data->count > 0 && data->csw_response.data_reside > 0)
         {
             if(rt_device_read(data->disk, data->block, data->ep_in->buffer, 1) == 0)
             {
                 rt_kprintf("disk read error\n");
                 rt_usbd_ep_set_stall(func->device, data->ep_in);
-                return -RT_ERROR;                
+                return -RT_ERROR;
             }
 
             data->ep_in->request.buffer = data->ep_in->buffer;
-            data->ep_in->request.size = data->geometry.bytes_per_sector;    
-            data->ep_in->request.req_type = UIO_REQUEST_WRITE;    
-            rt_usbd_io_request(func->device, data->ep_in, &data->ep_in->request);            
+            data->ep_in->request.size = data->geometry.bytes_per_sector;
+            data->ep_in->request.req_type = UIO_REQUEST_WRITE;
+            rt_usbd_io_request(func->device, data->ep_in, &data->ep_in->request);
         }
         else
         {
-            _send_status(func);            
-        }        
+            _send_status(func);
+        }
         break;
      }
 
@@ -667,7 +667,7 @@ static struct scsi_cmd* _find_cbw_command(rt_uint16_t cmd)
     {
         if(cmd_data[i].cmd == cmd)
             return &cmd_data[i];
-    }    
+    }
 
     return RT_NULL;
 }
@@ -681,7 +681,7 @@ static void _cb_len_calc(ufunction_t func, struct scsi_cmd* cmd,
     RT_ASSERT(cmd != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     if(cmd->cmd_len == 6)
     {
         switch(cmd->type)
@@ -695,9 +695,9 @@ static void _cb_len_calc(ufunction_t func, struct scsi_cmd* cmd,
         case FIXED:
             data->cb_data_size = cmd->data_size;
             break;
-        default:       
+        default:
             break;
-        }        
+        }
     }
     else if(cmd->cmd_len == 10)
     {
@@ -707,32 +707,32 @@ static void _cb_len_calc(ufunction_t func, struct scsi_cmd* cmd,
             data->cb_data_size = cbw->cb[7]<<8 | cbw->cb[8];
             break;
         case BLOCK_COUNT:
-            data->cb_data_size = (cbw->cb[7]<<8 | cbw->cb[8]) * 
+            data->cb_data_size = (cbw->cb[7]<<8 | cbw->cb[8]) *
                 data->geometry.bytes_per_sector;
             break;
         case FIXED:
             data->cb_data_size = cmd->data_size;
             break;
-        default:      
+        default:
             break;
         }
     }
-    
+
     //workaround: for stability in full-speed mode
     else if(cmd->cmd_len == 12)
     {
         switch(cmd->type)
         {
         case COUNT:
-            data->cb_data_size = cbw->cb[4]; 
+            data->cb_data_size = cbw->cb[4];
             break;
-        default:      
+        default:
             break;
         }
     }
     else
     {
-        rt_kprintf("cmd_len error %d\n", cmd->cmd_len);      
+        rt_kprintf("cmd_len error %d\n", cmd->cmd_len);
     }
 }
 
@@ -745,7 +745,7 @@ static rt_bool_t _cbw_verify(ufunction_t func, struct scsi_cmd* cmd,
     RT_ASSERT(cbw != RT_NULL);
     RT_ASSERT(func != RT_NULL);
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     if(cmd->cmd_len != cbw->cb_len)
     {
         rt_kprintf("cb_len error\n");
@@ -776,7 +776,7 @@ static rt_bool_t _cbw_verify(ufunction_t func, struct scsi_cmd* cmd,
         rt_kprintf("xfer_len > data_size\n");
         return RT_FALSE;
     }
-    
+
     if(cbw->xfer_len < data->cb_data_size)
     {
         rt_kprintf("xfer_len < data_size\n");
@@ -784,18 +784,18 @@ static rt_bool_t _cbw_verify(ufunction_t func, struct scsi_cmd* cmd,
         data->csw_response.status = 1;
     }
 
-    return RT_TRUE; 
+    return RT_TRUE;
 }
 
 static rt_size_t _cbw_handler(ufunction_t func, struct scsi_cmd* cmd,
     ustorage_cbw_t cbw)
-{    
+{
     struct mstorage *data;
 
     RT_ASSERT(func != RT_NULL);
     RT_ASSERT(cbw != RT_NULL);
     RT_ASSERT(cmd->handler != RT_NULL);
-        
+
     data = (struct mstorage*)func->user_data;
     data->processing = cmd;
     return cmd->handler(func, cbw);
@@ -815,21 +815,21 @@ static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
     struct scsi_cmd* cmd;
     rt_size_t len;
     struct ustorage_cbw* cbw;
-    
+
     RT_ASSERT(func != RT_NULL);
     RT_ASSERT(func->device != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("_ep_out_handler %d\n", size));
-    
+
     data = (struct mstorage*)func->user_data;
-    cbw = (struct ustorage_cbw*)data->ep_out->buffer;    
+    cbw = (struct ustorage_cbw*)data->ep_out->buffer;
     if(data->status == STAT_CBW)
     {
         /* dump cbw information */
         if(cbw->signature != CBW_SIGNATURE || size != SIZEOF_CBW)
         {
             goto exit;
-        }        
+        }
 
         data->csw_response.signature = CSW_SIGNATURE;
         data->csw_response.tag = cbw->tag;
@@ -837,33 +837,33 @@ static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
         data->csw_response.status = 0;
 
         RT_DEBUG_LOG(RT_DEBUG_USB, ("ep_out reside %d\n", data->csw_response.data_reside));
-        
+
         cmd = _find_cbw_command(cbw->cb[0]);
         if(cmd == RT_NULL)
         {
             rt_kprintf("can't find cbw command\n");
             goto exit;
-        }        
+        }
 
         _cb_len_calc(func, cmd, cbw);
         if(!_cbw_verify(func, cmd, cbw))
         {
             goto exit;
         }
-        
+
         len = _cbw_handler(func, cmd, cbw);
         if(len == 0)
         {
             _send_status(func);
-        }      
-        
-        return RT_EOK;        
+        }
+
+        return RT_EOK;
     }
     else if(data->status == STAT_RECEIVE)
     {
         RT_DEBUG_LOG(RT_DEBUG_USB, ("\nwrite size %d block 0x%x oount 0x%x\n",
                                     size, data->block, data->size));
-        
+
         data->size -= size;
         data->csw_response.data_reside -= size;
 
@@ -872,10 +872,10 @@ static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
         if(data->csw_response.data_reside != 0)
         {
             data->ep_out->request.buffer = data->ep_out->buffer;
-            data->ep_out->request.size = data->geometry.bytes_per_sector;    
-            data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;    
+            data->ep_out->request.size = data->geometry.bytes_per_sector;
+            data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;
             rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);
-            data->block ++;                        
+            data->block ++;
         }
         else
         {
@@ -900,7 +900,7 @@ exit:
     }
     data->csw_response.status = 1;
     _send_status(func);
-    
+
     return -RT_ERROR;
 }
 
@@ -915,21 +915,21 @@ exit:
 static rt_err_t _interface_handler(ufunction_t func, ureq_t setup)
 {
     rt_uint8_t lun = 0;
-    
+
     RT_ASSERT(func != RT_NULL);
-    RT_ASSERT(func->device != RT_NULL);    
+    RT_ASSERT(func->device != RT_NULL);
     RT_ASSERT(setup != RT_NULL);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("mstorage_interface_handler\n"));
 
     switch(setup->bRequest)
     {
-    case USBREQ_GET_MAX_LUN:        
-        
+    case USBREQ_GET_MAX_LUN:
+
         RT_DEBUG_LOG(RT_DEBUG_USB, ("USBREQ_GET_MAX_LUN\n"));
-        
+
         if(setup->wValue || setup->wLength != 1)
-        {        
+        {
             rt_usbd_ep0_set_stall(func->device);
         }
         else
@@ -940,14 +940,14 @@ static rt_err_t _interface_handler(ufunction_t func, ureq_t setup)
     case USBREQ_MASS_STORAGE_RESET:
 
         RT_DEBUG_LOG(RT_DEBUG_USB, ("USBREQ_MASS_STORAGE_RESET\n"));
-        
+
         if(setup->wValue || setup->wLength != 0)
         {
             rt_usbd_ep0_set_stall(func->device);
         }
         else
-        {   
-            dcd_ep0_send_status(func->device->dcd);     
+        {
+            dcd_ep0_send_status(func->device->dcd);
         }
         break;
     default:
@@ -984,14 +984,14 @@ static rt_err_t _function_enable(ufunction_t func)
         rt_kprintf("disk open error\n");
         return -RT_ERROR;
     }
-    
-    if(rt_device_control(data->disk, RT_DEVICE_CTRL_BLK_GETGEOME, 
+
+    if(rt_device_control(data->disk, RT_DEVICE_CTRL_BLK_GETGEOME,
         (void*)&data->geometry) != RT_EOK)
     {
         rt_kprintf("get disk info error\n");
         return -RT_ERROR;
     }
-    
+
     data->ep_in->buffer = (rt_uint8_t*)rt_malloc(data->geometry.bytes_per_sector);
     if(data->ep_in->buffer == RT_NULL)
     {
@@ -1004,14 +1004,14 @@ static rt_err_t _function_enable(ufunction_t func)
         rt_free(data->ep_in->buffer);
         rt_kprintf("no memory\n");
         return -RT_ENOMEM;
-    }    
- 
+    }
+
     /* prepare to read CBW request */
     data->ep_out->request.buffer = data->ep_out->buffer;
-    data->ep_out->request.size = SIZEOF_CBW;    
-    data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;    
+    data->ep_out->request.size = SIZEOF_CBW;
+    data->ep_out->request.req_type = UIO_REQUEST_READ_FULL;
     rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);
-    
+
     return RT_EOK;
 }
 
@@ -1029,11 +1029,11 @@ static rt_err_t _function_disable(ufunction_t func)
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("Mass storage function disabled\n"));
 
-    data = (struct mstorage*)func->user_data;   
+    data = (struct mstorage*)func->user_data;
     if(data->ep_in->buffer != RT_NULL)
     {
         rt_free(data->ep_in->buffer);
-        data->ep_in->buffer = RT_NULL;               
+        data->ep_in->buffer = RT_NULL;
     }
 
     if(data->ep_out->buffer != RT_NULL)
@@ -1046,9 +1046,9 @@ static rt_err_t _function_disable(ufunction_t func)
         rt_device_close(data->disk);
         data->disk = RT_NULL;
     }
-    
+
     data->status = STAT_CBW;
-    
+
     return RT_EOK;
 }
 
@@ -1087,11 +1087,11 @@ ufunction_t rt_usbd_function_mstorage_create(udevice_t device)
 
     /* set usb device string description */
     rt_usbd_device_set_string(device, _ustring);
-    
+
     /* create a mass storage function */
     func = rt_usbd_function_new(device, &dev_desc, &ops);
     device->dev_qualifier = &dev_qualifier;
-    
+
     /* allocate memory for mass storage function data */
     data = (struct mstorage*)rt_malloc(sizeof(struct mstorage));
     rt_memset(data, 0, sizeof(struct mstorage));
@@ -1102,7 +1102,7 @@ ufunction_t rt_usbd_function_mstorage_create(udevice_t device)
 
     /* create an alternate setting object */
     setting = rt_usbd_altsetting_new(sizeof(struct umass_descriptor));
-    
+
     /* config desc in alternate setting */
     rt_usbd_altsetting_config_descriptor(setting, &_mass_desc, (rt_off_t)&((umass_desc_t)0)->intf_desc);
 
@@ -1127,7 +1127,7 @@ ufunction_t rt_usbd_function_mstorage_create(udevice_t device)
 
     return func;
 }
-struct udclass msc_class = 
+struct udclass msc_class =
 {
     .rt_usbd_function_create = rt_usbd_function_mstorage_create
 };