Double buffering fix for reception.

In the case of double buffering, it is impossible to determine exactly
how large the allocated buffer should be. To achieve double-buffering
acceleration, the PCD_FreeUserBuffer call must occur before the
HAL_PCD_DataOutStageCallback call. But the real data buffer can be
allocated only in this callback. It turns out that the approach itself
needs to be changed - always allocate maximum allowable endpoint buffer
size (it's already happends in USB_ActivateEndpoint). At the same time
we need to check the size of the data received. This check be done at
the time of data receipt. During reception confirmation, it may be that
there is no allocated buffer at all. In this case, we will have to
leave the filled PMA intact and not complete its release. In this case,
this operation will be repeated in HAL_PCD_EP_ReceiveData.

Author: makarenya

system/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_ll_usb.h

@@ -269,20 +269,23 @@ typedef struct
 
   uint8_t   doublebuffer;    /*!< Double buffer enable
                                  This parameter can be 0 or 1                                             */
-  
-  uint16_t  tx_fifo_num;    /*!< This parameter is not required by USB Device FS peripheral, it is used 
+
+  uint16_t  tx_fifo_num;    /*!< This parameter is not required by USB Device FS peripheral, it is used
                                  only by USB OTG FS peripheral    
                                  This parameter is added to ensure compatibility across USB peripherals   */
 
   uint32_t  maxpacket;      /*!< Endpoint Max packet size
                                  This parameter must be a number between Min_Data = 0 and Max_Data = 64KB */
 
   uint8_t   *xfer_buff;     /*!< Pointer to transfer buffer                                               */
-  
+
+
   uint32_t  xfer_len;       /*!< Current transfer length                                                  */
 
   uint32_t  xfer_count;     /*!< Partial transfer length in case of multi packet transfer                 */
 
+  uint16_t  pending;        /*!, Fact, that double buffering transfer have pended data                    */
+
 } USB_EPTypeDef;
 #endif /* USB */
 /**

system/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_pcd.c

@@ -116,6 +116,7 @@ static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t
 
 #if defined (USB)
 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);
+static HAL_StatusTypeDef HAL_PCD_EP_ReceiveData(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef* ep)
 #endif /* USB */
 /**
   * @}
@@ -190,6 +191,7 @@ HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
     hpcd->IN_ep[index].maxpacket =  0U;
     hpcd->IN_ep[index].xfer_buff = 0U;
     hpcd->IN_ep[index].xfer_len = 0U;
+    hpcd->IN_ep[index].pending = 0U;
   }
 
   for (index = 0U; index < 15U ; index++)
@@ -202,6 +204,7 @@ HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
     hpcd->OUT_ep[index].maxpacket = 0U;
     hpcd->OUT_ep[index].xfer_buff = 0U;
     hpcd->OUT_ep[index].xfer_len = 0U;
+    hpcd->OUT_ep[index].pending = 0U;
   }
 
   /* Init Device */
@@ -907,7 +910,6 @@ HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
   return HAL_OK;
 }
 
-
 /**
   * @brief  Receive an amount of data
   * @param  hpcd: PCD handle
@@ -919,7 +921,7 @@ HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
 HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
 {
   PCD_EPTypeDef *ep = NULL;
-  
+
   ep = &hpcd->OUT_ep[ep_addr & 0x7FU];
 
   /*setup and start the Xfer */
@@ -933,7 +935,7 @@ HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, u
   }
   else
   {
-    USB_EPStartXfer(hpcd->Instance , ep);
+    HAL_PCD_EP_ReceiveData(hpcd, ep);
   }
 
   return HAL_OK;
@@ -1192,7 +1194,7 @@ static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
   uint16_t count = 0;
   uint16_t pmaBuffer = 0;
   uint8_t epindex = 0;
-  __IO uint16_t wIstr = 0;  
+  __IO uint16_t wIstr = 0;
   __IO uint16_t wEPVal = 0;
 
   /* stay in loop while pending interrupts */
@@ -1220,14 +1222,14 @@ static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
 
         /* TX COMPLETE */
         HAL_PCD_DataInStageCallback(hpcd, 0U);
-        
-        
+
+
         if((hpcd->USB_Address > 0U)&& ( ep->xfer_len == 0U))
         {
           hpcd->Instance->DADDR = (hpcd->USB_Address | USB_DADDR_EF);
           hpcd->USB_Address = 0U;
         }
-        
+
       }
       else
       {
@@ -1242,14 +1244,14 @@ static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
         {
           /* Get SETUP Packet*/
           ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
-          USB_ReadPMA(hpcd->Instance, (uint8_t*)hpcd->Setup ,ep->pmaadress , ep->xfer_count);       
+          USB_ReadPMA(hpcd->Instance, (uint8_t*)hpcd->Setup ,ep->pmaadress , ep->xfer_count);
           /* SETUP bit kept frozen while CTR_RX = 1*/ 
           PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0); 
 
           /* Process SETUP Packet*/
           HAL_PCD_SetupStageCallback(hpcd);
         }
-        
+
         else if ((wEPVal & USB_EP_CTR_RX) != 0U)
         {
           PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
@@ -1281,7 +1283,7 @@ static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
         /* clear int flag */
         PCD_CLEAR_RX_EP_CTR(hpcd->Instance, epindex);
         ep = &hpcd->OUT_ep[epindex];
-        
+
         /* OUT double Buffering*/
         if (ep->doublebuffer == 0U)
         {
@@ -1302,24 +1304,38 @@ static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
             count = (uint16_t) PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
             pmaBuffer = ep->pmaaddr1;
           }
-          PCD_FreeUserBuffer(hpcd->Instance, ep->num, PCD_EP_DBUF_OUT);  
+          if (ep->xfer_len == 0 || ep->xfer_buff == 0)
+          {
+            /* have no buffer at all, leave data untouched and exit */
+            ep->pending = 1U;
+            return HAL_OK;
+          }
+          PCD_FreeUserBuffer(hpcd->Instance, ep->num, PCD_EP_DBUF_OUT);
         }
+
         if (count != 0U)
         {
+          /* buffer doesn't contains enough space, stall and error */
+          if (count > ep->xfer_len)
+          {
+            USB_EPSetStall(hpcd->Instance, ep);
+            return HAL_ERROR;
+          }
           USB_ReadPMA(hpcd->Instance, ep->xfer_buff, pmaBuffer, count);
         }
         /*multi-packet on the NON control OUT endpoint*/
         ep->xfer_count+=count;
         ep->xfer_buff+=count;
-       
+        ep->xfer_len-=count;
+
         if ((ep->xfer_len == 0U) || (count < ep->maxpacket))
         {
           /* RX COMPLETE */
           HAL_PCD_DataOutStageCallback(hpcd, ep->num);
         }
-        else
+        else if (ep->doublebuffer == 0U)
         {
-          HAL_PCD_EP_Receive(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
+          PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_VALID);
         }
 
       } /* if((wEPVal & EP_CTR_RX) */
@@ -1369,6 +1385,57 @@ static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
   }
   return HAL_OK;
 }
+
+HAL_StatusTypeDef HAL_PCD_EP_ReceiveData(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef* ep)
+{
+  uint16_t count;
+  uint16_t pmaBuffer;
+
+  if (ep->pending)
+  {
+    ep->pending = 0U;
+    PCD_FreeUserBuffer(hpcd->Instance, ep->num, ep->is_in);
+    if (PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX)
+    {
+      /*read from endpoint BUF0Addr buffer*/
+      count = (uint16_t) PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
+      pmaBuffer = ep->pmaaddr0;
+    }
+    else
+    {
+      /*read from endpoint BUF1Addr buffer*/
+      count = (uint16_t) PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
+      pmaBuffer = ep->pmaaddr1;
+    }
+
+    /* buffer doesn't contains enough space, stall and error */
+    if (count > ep->xfer_len)
+    {
+      USB_EPSetStall(hpcd->Instance, ep);
+      return HAL_ERROR;
+    }
+
+    USB_ReadPMA(hpcd->Instance, ep->xfer_buff, pmaBuffer, count);
+
+    /*multi-packet on the NON control OUT endpoint*/
+    ep->xfer_count += count;
+    ep->xfer_buff += count;
+    ep->xfer_len -= count;
+
+    if ((ep->xfer_len == 0U) || (count < ep->maxpacket))
+    {
+      /* RX COMPLETE */
+      HAL_PCD_DataOutStageCallback(hpcd, ep->num);
+      return HAL_OK;
+    }
+  }
+  if (ep->doublebuffer == 0U)
+  {
+    PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_VALID);
+  }
+  return HAL_OK;
+}
+
 #endif /* USB */
 
 /**

system/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_ll_usb.c

@@ -1887,35 +1887,11 @@ HAL_StatusTypeDef USB_EPStartXfer(USB_TypeDef *USBx , USB_EPTypeDef *ep)
       PCD_FreeUserBuffer(USBx, ep->num, ep->is_in);
     }
   }
-  else /* OUT endpoint */
+  else
   {
-    /* Multi packet transfer*/
-    if (ep->xfer_len > ep->maxpacket)
-    {
-      len=ep->maxpacket;
-      ep->xfer_len-=len; 
-    }
-    else
-    {
-      len=ep->xfer_len;
-      ep->xfer_len =0;
-    }
-    
-    /* configure and validate Rx endpoint */
-    if (ep->doublebuffer == 0) 
-    {
-      /*Set RX buffer count*/
-      PCD_SET_EP_RX_CNT(USBx, ep->num, len);
-    }
-    else
-    {
-      /*Set the Double buffer counter*/
-      PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, len);
-    }
-    
     PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
   }
-  
+
   return HAL_OK;
 }