diff --git a/Inc/stm32g0xx_hal_hcd.h b/Inc/stm32g0xx_hal_hcd.h
index d849cde..b0f29b9 100644
--- a/Inc/stm32g0xx_hal_hcd.h
+++ b/Inc/stm32g0xx_hal_hcd.h
@@ -90,6 +90,7 @@
   HCD_TypeDef               *Instance;  /*!< Register base address    */
   HCD_InitTypeDef           Init;       /*!< HCD required parameters  */
   HCD_HCTypeDef             hc[16];     /*!< Host channels parameters */
+  uint32_t                  ep0_PmaAllocState;  /*!< EP0 PMA allocation State (allocated, virtual Ch, EP0 direction) */
   uint16_t                  phy_chin_state[8];  /*!< Physical Channel in State (Used/Free) */
   uint16_t                  phy_chout_state[8]; /*!< Physical Channel out State (Used/Free)*/
   uint32_t                  PMALookupTable[PMA_BLOCKS]; /*PMA LookUp Table */
@@ -362,7 +363,7 @@
   * @param   bChNum, bDir
   * @retval None
   */
-#define HCD_FreeUserBuffer                     USB_DRD_FreeUserBuffer
+#define HCD_FREE_USER_BUFFER                   USB_DRD_FREE_USER_BUFFER
 
 /**
   * @brief Set the Setup bit in the corresponding channel, when a Setup
@@ -400,12 +401,15 @@
 #define HCD_GET_CH_TX_STATUS                   USB_DRD_GET_CHEP_TX_STATUS
 #define HCD_GET_CH_RX_STATUS                   USB_DRD_GET_CHEP_RX_STATUS
 /**
-  * @brief  Sets/clears directly EP_KIND bit in the endpoint register.
+  * @brief  Sets/clears CH_KIND bit in the Channel register.
   * @param  USBx USB peripheral instance register address.
   * @param  bChNum Endpoint Number.
   * @retval None
   */
-#define HCD_SET_CH_DBUF                        USB_DRD_SET_CH_KIND
+#define HCD_SET_CH_KIND                        USB_DRD_SET_CH_KIND
+#define HCD_CLEAR_CH_KIND                      USB_DRD_CLEAR_CH_KIND
+#define HCD_SET_BULK_CH_DBUF                   HCD_SET_CH_KIND
+#define HCD_CLEAR_BULK_CH_DBUF                 HCD_CLEAR_CH_KIND
 
 /**
   * @brief  Clears bit ERR_RX in the Channel register
diff --git a/Inc/stm32g0xx_hal_pcd.h b/Inc/stm32g0xx_hal_pcd.h
index 5f3e294..4f48c94 100644
--- a/Inc/stm32g0xx_hal_pcd.h
+++ b/Inc/stm32g0xx_hal_pcd.h
@@ -188,16 +188,16 @@
   */
 
 
-#define __HAL_PCD_ENABLE(__HANDLE__)                                  (void)USB_EnableGlobalInt ((__HANDLE__)->Instance)
-#define __HAL_PCD_DISABLE(__HANDLE__)                                 (void)USB_DisableGlobalInt ((__HANDLE__)->Instance)
-#define __HAL_PCD_GET_FLAG(__HANDLE__, __INTERRUPT__)                 ((USB_ReadInterrupts((__HANDLE__)->Instance)\
-                                                                        & (__INTERRUPT__)) == (__INTERRUPT__))
+#define __HAL_PCD_ENABLE(__HANDLE__)                              (void)USB_EnableGlobalInt ((__HANDLE__)->Instance)
+#define __HAL_PCD_DISABLE(__HANDLE__)                             (void)USB_DisableGlobalInt ((__HANDLE__)->Instance)
+#define __HAL_PCD_GET_FLAG(__HANDLE__, __INTERRUPT__)             ((USB_ReadInterrupts((__HANDLE__)->Instance)\
+                                                                    & (__INTERRUPT__)) == (__INTERRUPT__))
 
-#define __HAL_PCD_CLEAR_FLAG(__HANDLE__, __INTERRUPT__)               (((__HANDLE__)->Instance->ISTR)\
-                                                                       &= (uint16_t)(~(__INTERRUPT__)))
+#define __HAL_PCD_CLEAR_FLAG(__HANDLE__, __INTERRUPT__)           (((__HANDLE__)->Instance->ISTR)\
+                                                                   &= (uint16_t)(~(__INTERRUPT__)))
 
-#define __HAL_USB_WAKEUP_EXTI_ENABLE_IT()                             EXTI->IMR2 |= USB_WAKEUP_EXTI_LINE
-#define __HAL_USB_WAKEUP_EXTI_DISABLE_IT()                            EXTI->IMR2 &= ~(USB_WAKEUP_EXTI_LINE)
+#define __HAL_USB_WAKEUP_EXTI_ENABLE_IT()                         EXTI->IMR2 |= USB_WAKEUP_EXTI_LINE
+#define __HAL_USB_WAKEUP_EXTI_DISABLE_IT()                        EXTI->IMR2 &= ~(USB_WAKEUP_EXTI_LINE)
 
 
 /**
@@ -341,13 +341,12 @@
 HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef *hpcd, uint8_t ep_addr,
                                       uint8_t *pBuf, uint32_t len);
 
-
 HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr);
 HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr);
 HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr);
+HAL_StatusTypeDef HAL_PCD_EP_Abort(PCD_HandleTypeDef *hpcd, uint8_t ep_addr);
 HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd);
 HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd);
-
 uint32_t          HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef *hpcd, uint8_t ep_addr);
 /**
   * @}
@@ -441,7 +440,7 @@
   * @param   bEpNum, bDir
   * @retval None
   */
-#define PCD_FreeUserBuffer                     USB_DRD_FreeUserBuffer
+#define PCD_FREE_USER_BUFFER                   USB_DRD_FREE_USER_BUFFER
 
 /**
   * @brief  sets the status for tx transfer (bits STAT_TX[1:0]).
@@ -467,8 +466,11 @@
   * @param  bEpNum Endpoint Number.
   * @retval None
   */
-#define PCD_SET_EP_DBUF                        USB_DRD_SET_CHEP_KIND
-#define PCD_CLEAR_EP_DBUF                      USB_DRD_CLEAR_CHEP_KIND
+#define PCD_SET_EP_KIND                        USB_DRD_SET_CHEP_KIND
+#define PCD_CLEAR_EP_KIND                      USB_DRD_CLEAR_CHEP_KIND
+#define PCD_SET_BULK_EP_DBUF                   PCD_SET_EP_KIND
+#define PCD_CLEAR_BULK_EP_DBUF                 PCD_CLEAR_EP_KIND
+
 
 /**
   * @brief  Clears bit CTR_RX / CTR_TX in the endpoint register.
diff --git a/Inc/stm32g0xx_hal_pcd_ex.h b/Inc/stm32g0xx_hal_pcd_ex.h
index 952abbc..6b3a439 100644
--- a/Inc/stm32g0xx_hal_pcd_ex.h
+++ b/Inc/stm32g0xx_hal_pcd_ex.h
@@ -23,7 +23,7 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif
+#endif /* __cplusplus */
 
 /* Includes ------------------------------------------------------------------*/
 #include "stm32g0xx_hal_def.h"
@@ -83,7 +83,7 @@
 
 #ifdef __cplusplus
 }
-#endif
+#endif /* __cplusplus */
 
 
 #endif /* STM32G0xx_HAL_PCD_EX_H */
diff --git a/Inc/stm32g0xx_ll_usb.h b/Inc/stm32g0xx_ll_usb.h
index 058bcf5..e0e1641 100644
--- a/Inc/stm32g0xx_ll_usb.h
+++ b/Inc/stm32g0xx_ll_usb.h
@@ -23,7 +23,7 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif
+#endif /* __cplusplus */
 
 /* Includes ------------------------------------------------------------------*/
 #include "stm32g0xx_hal_def.h"
@@ -80,14 +80,6 @@
   HC_ACK
 } USB_DRD_HCStateTypeDef;
 
-/**
-  * USB HOST Double buffer Isochronous State
-  */
-typedef enum
-{
-  USB_PMABUF_EMPTY = 0U,
-  USB_PMABUF_NOT_EMPTY = 1U
-} USB_BuffStateTypedDef;
 
 /**
   * @brief  USB Instance Initialization Structure definition
@@ -106,6 +98,8 @@
                                          This parameter can be any value of @ref PCD_Speed/HCD_Speed
                                                                                  (HCD_SPEED_xxx, HCD_SPEED_xxx) */
 
+  uint32_t dma_enable;              /*!< dma_enable state unused, DMA not supported by FS instance              */
+
   uint32_t ep0_mps;                 /*!< Set the Endpoint 0 Max Packet size.                                    */
 
   uint32_t phy_itface;              /*!< Select the used PHY interface.
@@ -141,16 +135,16 @@
                                        This parameter can be any value of @ref USB_LL_EP_Type                   */
 
   uint16_t  pmaadress;            /*!< PMA Address
-                                       This parameter can be any value between Min_addr = 0 and Max_addr = 1K    */
+                                       This parameter can be any value between Min_addr = 0 and Max_addr = 1K   */
 
   uint16_t  pmaaddr0;             /*!< PMA Address0
-                                       This parameter can be any value between Min_addr = 0 and Max_addr = 1K    */
+                                       This parameter can be any value between Min_addr = 0 and Max_addr = 1K   */
 
   uint16_t  pmaaddr1;             /*!< PMA Address1
-                                       This parameter can be any value between Min_addr = 0 and Max_addr = 1K    */
+                                       This parameter can be any value between Min_addr = 0 and Max_addr = 1K   */
 
   uint8_t   doublebuffer;         /*!< Double buffer enable
-                                       This parameter can be 0 or 1                                              */
+                                       This parameter can be 0 or 1                                             */
 
   uint8_t   data_pid_start;       /*!< Initial data PID
                                        This parameter must be a number between Min_Data = 0 and Max_Data = 1    */
@@ -213,23 +207,19 @@
   uint8_t   toggle_out;         /*!< OUT transfer current toggle flag
                                      This parameter must be a number between Min_Data = 0 and Max_Data = 1      */
 
-  uint32_t  ErrCnt;             /*!< Host channel error count.                                                 */
+  uint32_t  ErrCnt;             /*!< Host channel error count.                                                  */
 
   uint16_t  pmaadress;          /*!< PMA Address
-                                     This parameter can be any value between Min_addr = 0 and Max_addr = 1K    */
+                                     This parameter can be any value between Min_addr = 0 and Max_addr = 1K     */
 
   uint16_t  pmaaddr0;           /*!< PMA Address0
-                                     This parameter can be any value between Min_addr = 0 and Max_addr = 1K    */
+                                     This parameter can be any value between Min_addr = 0 and Max_addr = 1K     */
 
   uint16_t  pmaaddr1;           /*!< PMA Address1
-                                     This parameter can be any value between Min_addr = 0 and Max_addr = 1K    */
+                                     This parameter can be any value between Min_addr = 0 and Max_addr = 1K     */
 
   uint8_t   doublebuffer;       /*!< Double buffer enable
-                                     This parameter can be 0 or 1                                              */
-
-  USB_BuffStateTypedDef  pmabuff0_state;   /*!< PMA Buffer0 State empty / notEmpty : used in double buffer OUT isochronous */
-
-  USB_BuffStateTypedDef  pmabuff1_state;   /*!< PMA Buffer1 State empty / notEmpty : used in double buffer OUT isochronous */
+                                     This parameter can be 0 or 1                                               */
 
   USB_DRD_URBStateTypeDef urb_state;  /*!< URB state.
                                             This parameter can be any value of @ref USB_OTG_URBStateTypeDef */
@@ -283,6 +273,10 @@
 
 #define EP_ADDR_MSK                            0x7U
 
+#ifndef USE_USB_DOUBLE_BUFFER
+#define USE_USB_DOUBLE_BUFFER                  1U
+#endif /* USE_USB_DOUBLE_BUFFER */
+
 /*!< USB Speed */
 #define USB_DRD_SPEED_FS                       1U
 #define USB_DRD_SPEED_LS                       2U
@@ -303,17 +297,17 @@
 #define USB_DRD_USED_CHANNELS                  8U
 #endif /* USB_DRD_USED_CHANNELS */
 
-/* First available address in PMA */
-#define PMA_START_ADDR          (0x10U + (8U *(USB_DRD_USED_CHANNELS - 2U)))
-#define PMA_END_ADDR             USB_DRD_PMA_SIZE
-
-
 /**
   * used for USB_HC_DoubleBuffer API
   */
-#define USB_DRD_DBUFF_ENBALE                   1U
-#define USB_DRD_DBUFF_DISABLE                  2U
+#define USB_DRD_BULK_DBUFF_ENBALE                   1U
+#define USB_DRD_BULK_DBUFF_DISABLE                  2U
+#define USB_DRD_ISOC_DBUFF_ENBALE                   3U
+#define USB_DRD_ISOC_DBUFF_DISABLE                  4U
 
+/* First available address in PMA */
+#define PMA_START_ADDR          (0x10U + (8U *(USB_DRD_USED_CHANNELS - 2U)))
+#define PMA_END_ADDR             USB_DRD_PMA_SIZE
 
 /* Exported macro ------------------------------------------------------------*/
 /**
@@ -339,7 +333,7 @@
   * @param   bEpChNum, bDir
   * @retval None
   */
-#define USB_DRD_FreeUserBuffer(USBx, bEpChNum, bDir) \
+#define USB_DRD_FREE_USER_BUFFER(USBx, bEpChNum, bDir) \
   do { \
     if ((bDir) == 0U) \
     { \
@@ -668,18 +662,22 @@
     uint32_t wNBlocks; \
     \
     (pdwReg) &= USB_PMA_RXBD_COUNTMSK; \
-    if ((wCount) == 0U) \
+    \
+    if ((wCount) > 62U) \
     { \
-      (pdwReg) &= (uint32_t)~USB_CNTRX_NBLK_MSK; \
-      (pdwReg) |= USB_CNTRX_BLSIZE; \
-    } \
-    else if((wCount) <= 62U) \
-    { \
-      USB_DRD_CALC_BLK2((pdwReg), (wCount), wNBlocks); \
+      USB_DRD_CALC_BLK32((pdwReg), (wCount), wNBlocks); \
     } \
     else \
     { \
-      USB_DRD_CALC_BLK32((pdwReg), (wCount), wNBlocks); \
+      if ((wCount) == 0U) \
+      { \
+        (pdwReg) &= (uint32_t)~USB_CNTRX_NBLK_MSK; \
+        (pdwReg) |= USB_CNTRX_BLSIZE; \
+      } \
+      else \
+      { \
+        USB_DRD_CALC_BLK2((pdwReg), (wCount), wNBlocks); \
+      } \
     } \
   } while(0) /* USB_DRD_SET_CHEP_CNT_RX_REG */
 
@@ -700,13 +698,11 @@
     (USB_DRD_PMA_BUFF + (bEpChNum))->TXBD |= (uint32_t)((uint32_t)(wCount) << 16U); \
   } while(0)
 
+#define USB_DRD_SET_CHEP_RX_DBUF0_CNT(USBx, bEpChNum, wCount) \
+  USB_DRD_SET_CHEP_CNT_RX_REG(((USB_DRD_PMA_BUFF + (bEpChNum))->TXBD), (wCount))
 
-#define USB_DRD_SET_CHEP_RX_DBUF0_CNT(USBx, bEpChNum, wCount)      USB_DRD_SET_CHEP_CNT_RX_REG(((USB_DRD_PMA_BUFF\
-                                                                   + (bEpChNum))->TXBD), (wCount))
-
-#define USB_DRD_SET_CHEP_RX_CNT(USBx, bEpChNum, wCount)            USB_DRD_SET_CHEP_CNT_RX_REG(((USB_DRD_PMA_BUFF\
-                                                                   + (bEpChNum))->RXBD), (wCount))
-
+#define USB_DRD_SET_CHEP_RX_CNT(USBx, bEpChNum, wCount) \
+  USB_DRD_SET_CHEP_CNT_RX_REG(((USB_DRD_PMA_BUFF + (bEpChNum))->RXBD), (wCount))
 
 /**
   * @brief  gets counter of the tx buffer.
@@ -833,7 +829,8 @@
 HAL_StatusTypeDef USB_EPStartXfer(USB_DRD_TypeDef *USBx, USB_DRD_EPTypeDef *ep);
 HAL_StatusTypeDef USB_EPSetStall(USB_DRD_TypeDef *USBx, USB_DRD_EPTypeDef *ep);
 HAL_StatusTypeDef USB_EPClearStall(USB_DRD_TypeDef *USBx, USB_DRD_EPTypeDef *ep);
-#endif /* HAL_PCD_MODULE_ENABLED */
+HAL_StatusTypeDef USB_EPStopXfer(USB_DRD_TypeDef *USBx, USB_DRD_EPTypeDef *ep);
+#endif /* defined (HAL_PCD_MODULE_ENABLED) */
 
 HAL_StatusTypeDef USB_SetDevAddress(USB_DRD_TypeDef *USBx, uint8_t address);
 HAL_StatusTypeDef USB_DevConnect(USB_DRD_TypeDef *USBx);
@@ -882,7 +879,7 @@
 
 #ifdef __cplusplus
 }
-#endif
+#endif /* __cplusplus */
 
 
 #endif /* STM32G0xx_LL_USB_H */
diff --git a/README.md b/README.md
index e8de06c..1ca31cb 100644
--- a/README.md
+++ b/README.md
@@ -40,11 +40,12 @@
 
 HAL Driver G0 | CMSIS Device G0 | CMSIS Core     | Was delivered in the full MCU package
 ------------- | --------------- | -------------- | -----------------------------------------------------
-Tag v1.2.0    | Tag v1.2.0      | Tag v4.5_cm0   | Tag v1.2.0 (and following, if any, till next new tag)
-Tag v1.3.0    | Tag v1.3.0      | Tag v5.4.0_cm0 | Tag v1.3.0 (and following, if any, till next new tag)
-Tag v1.4.0    | Tag v1.4.0      | Tag v5.6.0_cm0 | Tag v1.4.0 (and following, if any, till next new tag)
-Tag v1.4.1    | Tag v1.4.0      | Tag v5.6.0_cm0 | Tag v1.4.1 (and following, if any, till next new tag)
-Tag v1.4.2    | Tag v1.4.1      | Tag v5.6.0_cm0 | Tag v1.5.0 (and following, if any, till next new tag)
+Tag v1.2.0    | Tag v1.2.0      | Tag v4.5_cm0   | Tag v1.2.0 (and following, if any, till next HAL tag)
+Tag v1.3.0    | Tag v1.3.0      | Tag v5.4.0_cm0 | Tag v1.3.0 (and following, if any, till next HAL tag)
+Tag v1.4.0    | Tag v1.4.0      | Tag v5.6.0_cm0 | Tag v1.4.0 (and following, if any, till next HAL tag)
+Tag v1.4.1    | Tag v1.4.0      | Tag v5.6.0_cm0 | Tag v1.4.1 (and following, if any, till next HAL tag)
+Tag v1.4.2    | Tag v1.4.1      | Tag v5.6.0_cm0 | Tag v1.5.0 (and following, if any, till next HAL tag)
+Tag v1.4.3    | Tag v1.4.1      | Tag v5.6.0_cm0 | None (will be integrated into next HAL tag v1.4.4)
 
 The full **STM32CubeG0** MCU package is available [here](https://github.com/STMicroelectronics/STM32CubeG0).
 
diff --git a/Release_Notes.html b/Release_Notes.html
index 1150f2b..2f55b1f 100644
--- a/Release_Notes.html
+++ b/Release_Notes.html
@@ -45,11 +45,52 @@
 <section id="update-history" class="col-sm-12 col-lg-8">
 <h1>Update History</h1>
 <div class="collapse">
-<input type="checkbox" id="collapse-section5" checked aria-hidden="true"> <label for="collapse-section5" aria-hidden="true">V1.4.2 / 17-Juin-2021</label>
+<input type="checkbox" id="collapse-section6" checked aria-hidden="true"> <label for="collapse-section6" aria-hidden="true">V1.4.3 / 15-December-2021</label>
 <div>
 <h2 id="main-changes">Main Changes</h2>
 <h3 id="maintenance-release">Maintenance release</h3>
 <ul>
+<li><strong>HAL/LL Drivers</strong> updates
+<ul>
+<li><strong>HAL USB</strong> update
+<ul>
+<li>Footprint optimization in case USB double buffer mode not used, code protected with new define USE_USB_DOUBLE_BUFFER</li>
+<li>Update to avoid multiple reads of USB ISR register</li>
+<li>Add new API HAL_PCD_EP_Abort() to abort current USB endpoint transfer.</li>
+<li>Adding support of Azure USBx middleware stack</li>
+</ul></li>
+</ul></li>
+</ul>
+<h2 id="known-limitations">Known limitations</h2>
+<ul>
+<li>USB HAL limitation: Double buffer mode is not functional with isochronous data transfers in host mode.</li>
+</ul>
+<h2 id="development-toolchains-and-compilers">Development Toolchains and Compilers</h2>
+<ul>
+<li>IAR Embedded Workbench for ARM (EWARM) toolchain V8.50.9</li>
+<li>RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.31</li>
+<li>STM32CubeIDE toolchain v1.7.0</li>
+</ul>
+<h2 id="supported-devices-and-boards">Supported Devices and boards</h2>
+<p>Supported Devices:</p>
+<ul>
+<li>STM32G0C1xx, STM32G0B1xx, STM32G0B0xx</li>
+<li>STM32G061xx, STM32G051xx, STM32G050xx</li>
+<li>STM32G081xx, STM32G071xx, STM32G070xx</li>
+<li>STM32G041xx, STM32G031xx, STM32G030xx ## Backward Compatibility</li>
+</ul>
+<p>This release is compatible with the previous versions.</p>
+<h2 id="dependencies">Dependencies</h2>
+<p><br />
+</p>
+</div>
+</div>
+<div class="collapse">
+<input type="checkbox" id="collapse-section5" aria-hidden="true"> <label for="collapse-section5" aria-hidden="true">V1.4.2 / 17-Juin-2021</label>
+<div>
+<h2 id="main-changes-1">Main Changes</h2>
+<h3 id="maintenance-release-1">Maintenance release</h3>
+<ul>
 <li><p>General updates to fix known defects and enhancements implementation.</p></li>
 <li><p><strong>HAL/LL Drivers</strong> updates</p></li>
 <li><p><strong>HAL CEC</strong> update</p>
@@ -178,17 +219,17 @@
 <li>Add fix transfer complete for IN Interrupt transaction in single buffer mode.</li>
 </ul></li>
 </ul>
-<h2 id="known-limitations">Known limitations</h2>
+<h2 id="known-limitations-1">Known limitations</h2>
 <ul>
 <li>USB HAL limitation: Double buffer mode is not functional with isochronous data transfers in host mode.</li>
 </ul>
-<h2 id="development-toolchains-and-compilers">Development Toolchains and Compilers</h2>
+<h2 id="development-toolchains-and-compilers-1">Development Toolchains and Compilers</h2>
 <ul>
 <li>IAR Embedded Workbench for ARM (EWARM) toolchain V8.50.9</li>
 <li>RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.31</li>
 <li>STM32CubeIDE toolchain v1.7.0</li>
 </ul>
-<h2 id="supported-devices-and-boards">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-1">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li>STM32G0C1xx, STM32G0B1xx, STM32G0B0xx</li>
@@ -197,7 +238,7 @@
 <li>STM32G041xx, STM32G031xx, STM32G030xx ## Backward Compatibility</li>
 </ul>
 <p>This release is compatible with the previous versions.</p>
-<h2 id="dependencies">Dependencies</h2>
+<h2 id="dependencies-1">Dependencies</h2>
 <p><br />
 </p>
 </div>
@@ -205,7 +246,7 @@
 <div class="collapse">
 <input type="checkbox" id="collapse-section6" aria-hidden="true"> <label for="collapse-section6" aria-hidden="true">V1.4.1 / 25-February-2021</label>
 <div>
-<h2 id="main-changes-1">Main Changes</h2>
+<h2 id="main-changes-2">Main Changes</h2>
 <h3 id="patch-release">Patch release</h3>
 <p>Patch release of <strong>HAL and Low Layer</strong> drivers</p>
 <p><strong>Additional features</strong></p>
@@ -221,17 +262,17 @@
 </tr>
 </tbody>
 </table>
-<h2 id="known-limitations-1">Known limitations</h2>
+<h2 id="known-limitations-2">Known limitations</h2>
 <ul>
 <li>USB HAL limitation: Double buffer mode is not functional with isochronous data transfers in host mode.</li>
 </ul>
-<h2 id="development-toolchains-and-compilers-1">Development Toolchains and Compilers</h2>
+<h2 id="development-toolchains-and-compilers-2">Development Toolchains and Compilers</h2>
 <ul>
 <li>IAR Embedded Workbench for ARM (EWARM) toolchain V8.30.1</li>
 <li>RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.29</li>
 <li>STM32CubeIDE toolchain v1.5.0</li>
 </ul>
-<h2 id="supported-devices-and-boards-1">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-2">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li>STM32G0C1xx, STM32G0B1xx, STM32G0B0xx</li>
@@ -241,7 +282,7 @@
 </ul>
 <h2 id="backward-compatibility">Backward Compatibility</h2>
 <p>This release is compatible with the previous versions.</p>
-<h2 id="dependencies-1">Dependencies</h2>
+<h2 id="dependencies-2">Dependencies</h2>
 <p><br />
 </p>
 </div>
@@ -249,7 +290,7 @@
 <div class="collapse">
 <input type="checkbox" id="collapse-section5" aria-hidden="true"> <label for="collapse-section5" aria-hidden="true">V1.4.0 / 29-October-2020</label>
 <div>
-<h2 id="main-changes-2">Main Changes</h2>
+<h2 id="main-changes-3">Main Changes</h2>
 <h3 id="maintenance-release-and-product-update">Maintenance release and Product Update</h3>
 <p><strong>Official release</strong> of HAL and Low layers drivers introducing <strong>STM32G0C1xx/STM32G0B1xx/STM32G0B0xx</strong> devices and <strong>STM32G061xx/STM32G051xx/STM32G050xx</strong> devices.</p>
 <p>Maintenance release of HAL and Low layers drivers supporting STM32G041xx/STM32G031xx/STM32G030xx and STM32G081xx/STM32G071xx/STM32G070xx devices.</p>
@@ -716,17 +757,17 @@
 </tr>
 </tbody>
 </table>
-<h2 id="known-limitations-2">Known limitations</h2>
+<h2 id="known-limitations-3">Known limitations</h2>
 <ul>
 <li>USB HAL limitation: Double buffer mode is not functional with isochronous data transfers in host mode.</li>
 </ul>
-<h2 id="development-toolchains-and-compilers-2">Development Toolchains and Compilers</h2>
+<h2 id="development-toolchains-and-compilers-3">Development Toolchains and Compilers</h2>
 <ul>
 <li>IAR Embedded Workbench for ARM (EWARM) toolchain V8.30.1</li>
 <li>RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.29</li>
 <li>STM32CubeIDE toolchain v1.5.0</li>
 </ul>
-<h2 id="supported-devices-and-boards-2">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-3">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li><strong>STM32G0C1xx, STM32G0B1xx, STM32G0B0xx</strong></li>
@@ -736,7 +777,7 @@
 </ul>
 <h2 id="backward-compatibility-1">Backward Compatibility</h2>
 <p>This release is compatible with the previous versions.</p>
-<h2 id="dependencies-2">Dependencies</h2>
+<h2 id="dependencies-3">Dependencies</h2>
 <p><br />
 </p>
 </div>
@@ -744,8 +785,8 @@
 <div class="collapse">
 <input type="checkbox" id="collapse-section4" aria-hidden="true"> <label for="collapse-section4" aria-hidden="true">V1.3.0 / 25-June-2019</label>
 <div>
-<h2 id="main-changes-3">Main Changes</h2>
-<h3 id="maintenance-release-1">Maintenance release</h3>
+<h2 id="main-changes-4">Main Changes</h2>
+<h3 id="maintenance-release-2">Maintenance release</h3>
 <p>Maintenance release of HAL and Low layers drivers supporting STM32G041xx/STM32G031xx/STM32G030xx and STM32G081xx/STM32G071xx/STM32G070xx devices.</p>
 <p><strong>Fixed bugs list</strong></p>
 <table>
@@ -814,13 +855,13 @@
 </tr>
 </tbody>
 </table>
-<h2 id="development-toolchains-and-compilers-3">Development Toolchains and Compilers</h2>
+<h2 id="development-toolchains-and-compilers-4">Development Toolchains and Compilers</h2>
 <ul>
 <li>IAR Embedded Workbench for ARM (EWARM) toolchain V8.20.2</li>
 <li>RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.25</li>
 <li>System Workbench STM32 (SW4STM32) toolchain V2.7.2</li>
 </ul>
-<h2 id="supported-devices-and-boards-3">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-4">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li>STM32G081xx, STM32G071xx, STM32G070xx</li>
@@ -828,13 +869,13 @@
 </ul>
 <h2 id="backward-compatibility-2">Backward Compatibility</h2>
 <p>This release is compatible with the previous versions.</p>
-<h2 id="dependencies-3">Dependencies</h2>
+<h2 id="dependencies-4">Dependencies</h2>
 </div>
 </div>
 <div class="collapse">
 <input type="checkbox" id="collapse-section3" aria-hidden="true"> <label for="collapse-section3" aria-hidden="true">V1.2.0 / 05-April-2019</label>
 <div>
-<h2 id="main-changes-4">Main Changes</h2>
+<h2 id="main-changes-5">Main Changes</h2>
 <h3 id="maintenance-release-and-product-update-1">Maintenance release and product update</h3>
 <p>First release of HAL and Low layers drivers to introduce support of <strong>STM32G041xx/STM32G031xx/STM32G030xx devices</strong>.</p>
 <p>Maintenance release of HAL and Low layers drivers supporting STM32G081xx/STM32G071xx/STM32G070xx devices.</p>
@@ -921,13 +962,13 @@
 </tr>
 </tbody>
 </table>
-<h2 id="development-toolchains-and-compilers-4">Development Toolchains and Compilers</h2>
+<h2 id="development-toolchains-and-compilers-5">Development Toolchains and Compilers</h2>
 <ul>
 <li>IAR Embedded Workbench for ARM (EWARM) toolchain V8.20.2</li>
 <li>RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.25</li>
 <li>System Workbench STM32 (SW4STM32) toolchain V2.7.2</li>
 </ul>
-<h2 id="supported-devices-and-boards-4">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-5">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li>STM32G081xx, STM32G071xx, STM32G070xx</li>
@@ -935,13 +976,13 @@
 </ul>
 <h2 id="backward-compatibility-3">Backward Compatibility</h2>
 <p>This release is compatible with the previous versions.</p>
-<h2 id="dependencies-4">Dependencies</h2>
+<h2 id="dependencies-5">Dependencies</h2>
 </div>
 </div>
 <div class="collapse">
 <input type="checkbox" id="collapse-section2" aria-hidden="true"> <label for="collapse-section2" aria-hidden="true">V1.1.0 / 06-February-2019</label>
 <div>
-<h2 id="main-changes-5">Main Changes</h2>
+<h2 id="main-changes-6">Main Changes</h2>
 <h3 id="maintenance-release-and-product-update-2">Maintenance release and product update</h3>
 <p>Maintenance release of HAL and Low layers drivers to support STM32G071xx/STM32G081xx/STM32G070xx devices.</p>
 <p><strong>Additional features</strong></p>
@@ -1030,7 +1071,7 @@
 </tr>
 </tbody>
 </table>
-<h2 id="supported-devices-and-boards-5">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-6">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li>STM32G0<strong>81</strong>xx</li>
@@ -1039,23 +1080,23 @@
 </ul>
 <h2 id="backward-compatibility-4">Backward Compatibility</h2>
 <p>This release is compatible with the previous versions.</p>
-<h2 id="dependencies-5">Dependencies</h2>
+<h2 id="dependencies-6">Dependencies</h2>
 </div>
 </div>
 <div class="collapse">
 <input type="checkbox" id="collapse-section1" aria-hidden="true"> <label for="collapse-section1" aria-hidden="true">V1.0.0 / 26-October-2018</label>
 <div>
-<h2 id="main-changes-6">Main Changes</h2>
+<h2 id="main-changes-7">Main Changes</h2>
 <h3 id="first-release">First release</h3>
 <p>First official release of HAL and Low layers drivers to support STM32G071xx/STM32G081xx/STM32G070xx</p>
-<h2 id="supported-devices-and-boards-6">Supported Devices and boards</h2>
+<h2 id="supported-devices-and-boards-7">Supported Devices and boards</h2>
 <p>Supported Devices:</p>
 <ul>
 <li>STM32G0<strong>81</strong>xx</li>
 <li>STM32G0<strong>71</strong>xx</li>
 <li>STM32G0<strong>70</strong>xx</li>
 </ul>
-<h2 id="dependencies-6">Dependencies</h2>
+<h2 id="dependencies-7">Dependencies</h2>
 </div>
 </div>
 </section>
diff --git a/Src/stm32g0xx_hal.c b/Src/stm32g0xx_hal.c
index e2208fa..efa598b 100644
--- a/Src/stm32g0xx_hal.c
+++ b/Src/stm32g0xx_hal.c
@@ -57,7 +57,7 @@
   */
 #define __STM32G0xx_HAL_VERSION_MAIN   (0x01U) /*!< [31:24] main version */
 #define __STM32G0xx_HAL_VERSION_SUB1   (0x04U) /*!< [23:16] sub1 version */
-#define __STM32G0xx_HAL_VERSION_SUB2   (0x02U) /*!< [15:8]  sub2 version */
+#define __STM32G0xx_HAL_VERSION_SUB2   (0x03U) /*!< [15:8]  sub2 version */
 #define __STM32G0xx_HAL_VERSION_RC     (0x00U) /*!< [7:0]  release candidate */
 #define __STM32G0xx_HAL_VERSION         ((__STM32G0xx_HAL_VERSION_MAIN << 24U)\
                                         |(__STM32G0xx_HAL_VERSION_SUB1 << 16U)\
diff --git a/Src/stm32g0xx_hal_hcd.c b/Src/stm32g0xx_hal_hcd.c
index 55aee18..f62c075 100644
--- a/Src/stm32g0xx_hal_hcd.c
+++ b/Src/stm32g0xx_hal_hcd.c
@@ -81,8 +81,11 @@
 static uint8_t HAL_HCD_Check_usedChannel(HCD_HandleTypeDef *hhcd, uint8_t ch_num);
 static uint8_t HAL_HCD_Get_FreePhyChannel(HCD_HandleTypeDef *hhcd, uint8_t ch_num, uint8_t epnum, uint8_t ep_type);
 
+#if (USE_USB_DOUBLE_BUFFER == 1U)
 static void HCD_HC_IN_BulkDb(HCD_HandleTypeDef *hhcd, uint8_t ch_num, uint8_t phy_chnum, uint32_t regvalue);
 static void HCD_HC_OUT_BulkDb(HCD_HandleTypeDef *hhcd, uint8_t ch_num, uint8_t phy_chnum, uint32_t regvalue);
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
+
 static uint16_t HAL_HCD_GetFreePMA(HCD_HandleTypeDef *hhcd, uint16_t mps);
 static HAL_StatusTypeDef  HAL_HCD_PMAFree(HCD_HandleTypeDef *hhcd, uint32_t pma_base, uint16_t mps);
 static void inline HCD_HC_IN_ISO(HCD_HandleTypeDef *hhcd, uint8_t ch_num, uint8_t phy_chnum, uint32_t regvalue);
@@ -154,24 +157,27 @@
   /* Disable the Interrupts */
   (void)__HAL_HCD_DISABLE(hhcd);
 
-  /*Init the Core (common init.) */
+  /* Dma not supported, force to zero */
+  hhcd->Init.dma_enable = 0U;
+
+  /* Init the Core (common init.) */
   (void)USB_CoreInit(hhcd->Instance, hhcd->Init);
 
-  /* Force Host Mode*/
+  /* Force Host Mode */
   (void)USB_SetCurrentMode(hhcd->Instance, USB_HOST_MODE);
 
   /* Init Host */
   (void)USB_HostInit(hhcd->Instance, hhcd->Init);
 
-  /* Deactivate the power down*/
+  /* Deactivate the power down */
   hhcd->Instance->CNTR  &= ~USB_CNTR_PDWN;
 
   hhcd->State = HAL_HCD_STATE_READY;
 
-  /*Host Port State*/
+  /* Host Port State */
   hhcd->HostState = HCD_HCD_STATE_DISCONNECTED;
 
-  /*Init PMA Address */
+  /* Init PMA Address */
   (void)HAL_HCD_PMAReset(hhcd);
 
   hhcd->State = HAL_HCD_STATE_READY;
@@ -209,19 +215,20 @@
 {
   HAL_StatusTypeDef status;
   uint8_t used_channel;
+  uint8_t ep0_virtual_channel;
 
   __HAL_LOCK(hhcd);
 
   /* Check if the logical channel are already allocated */
   used_channel = HAL_HCD_Check_usedChannel(hhcd, ch_num);
 
-  /*Check if the channel is not already opened */
+  /* Check if the channel is not already opened */
   if (used_channel == 0U)
   {
-    /*Allocate New Physical channel */
+    /* Allocate New Physical channel */
     hhcd->hc[ch_num & 0xFU].phy_ch_num = HAL_HCD_Get_FreePhyChannel(hhcd, ch_num, epnum, ep_type);
 
-    /*if it is not able to allocate channel  */
+    /* No free Channel available, return error */
     if (hhcd->hc[ch_num & 0xFU].phy_ch_num == HCD_FREE_CH_NOT_FOUND)
     {
       return HAL_ERROR;
@@ -230,7 +237,7 @@
   /* Channel already opened */
   else
   {
-    /*Get Physical Channel number */
+    /* Get Physical Channel number */
     hhcd->hc[ch_num & 0xFU].phy_ch_num = (used_channel & 0xF0U) >> 4U;
   }
 
@@ -249,7 +256,7 @@
   hhcd->hc[ch_num & 0xFU].ep_num     = epnum & 0x7FU;
   hhcd->hc[ch_num & 0xFU].speed      = speed;
 
-  /*Check if the channel is not already opened */
+  /* Check if the channel is not already opened */
   if (used_channel == 0U)
   {
     if (((ep_type == EP_TYPE_ISOC) && (hhcd->Init.iso_singlebuffer_enable == 0U)) ||
@@ -257,19 +264,118 @@
     {
       /* PMA Dynamic Allocation */
       status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_DBL_BUF, mps);
+
       if (status == HAL_ERROR)
       {
         return HAL_ERROR;
       }
+
+      /* Clear Channel DTOG_TX */
+      HCD_CLEAR_TX_DTOG(hhcd->Instance, hhcd->hc[ch_num & 0xFU].phy_ch_num);
+
+      /* Clear Channel DTOG RX */
+      HCD_CLEAR_RX_DTOG(hhcd->Instance, hhcd->hc[ch_num & 0xFU].phy_ch_num);
+
     }
     else
     {
-      /* PMA Dynamic Allocation */
-      status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_SNG_BUF, mps);
-      if (status == HAL_ERROR)
+      if (hhcd->hc[ch_num & 0xFU].ep_num != 0U)
       {
-        return HAL_ERROR;
+        status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_SNG_BUF, mps);
+
+        if (status == HAL_ERROR)
+        {
+          return HAL_ERROR;
+        }
       }
+      else
+      {
+        if (ch_num == 0U)
+        {
+          ep0_virtual_channel = (uint8_t)(hhcd->ep0_PmaAllocState & 0xFU);
+
+          if ((ep0_virtual_channel != 0U) && (((hhcd->ep0_PmaAllocState & 0xF0U) >> 4) == CH_IN_DIR))
+          {
+            if (hhcd->hc[ch_num & 0xFU].ch_dir == CH_OUT_DIR)
+            {
+              status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_SNG_BUF, 64U);
+
+              if (status == HAL_ERROR)
+              {
+                return HAL_ERROR;
+              }
+            }
+            else
+            {
+              return HAL_ERROR;
+            }
+          }
+          else
+          {
+            /* PMA Dynamic Allocation for EP0 OUT direction */
+            hhcd->hc[ch_num & 0xFU].ch_dir = CH_OUT_DIR;
+            status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_SNG_BUF, 64U);
+
+            if (status == HAL_ERROR)
+            {
+              return HAL_ERROR;
+            }
+
+            /* PMA Dynamic Allocation for EP0 IN direction */
+            hhcd->hc[ch_num & 0xFU].ch_dir = CH_IN_DIR;
+            status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_SNG_BUF, 64U);
+
+            if (status == HAL_ERROR)
+            {
+              return HAL_ERROR;
+            }
+          }
+        }
+        else
+        {
+          if (((hhcd->ep0_PmaAllocState & 0xF00U) >> 8) == 1U)
+          {
+            ep0_virtual_channel = (uint8_t)(hhcd->ep0_PmaAllocState & 0xFU);
+
+            if (((hhcd->ep0_PmaAllocState & 0xF0U) >> 4) == CH_IN_DIR)
+            {
+              hhcd->hc[ch_num & 0xFU].pmaaddr1 = hhcd->hc[ep0_virtual_channel & 0xFU].pmaaddr1;
+            }
+            else
+            {
+              hhcd->hc[ch_num & 0xFU].pmaaddr0 = hhcd->hc[ep0_virtual_channel & 0xFU].pmaaddr0;
+            }
+          }
+          else
+          {
+            status = HAL_HCD_PMAlloc(hhcd, ch_num, HCD_SNG_BUF, 64U);
+
+            if (status == HAL_ERROR)
+            {
+              return HAL_ERROR;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if ((epnum & 0x80U) != 0U)
+  {
+    hhcd->hc[ch_num & 0xFU].ch_dir = CH_IN_DIR;
+
+    if (hhcd->hc[ch_num & 0xFU].ep_num == 0U)
+    {
+      hhcd->hc[ch_num & 0xFU].pmaadress = hhcd->hc[ch_num & 0xFU].pmaaddr1;
+    }
+  }
+  else
+  {
+    hhcd->hc[ch_num & 0xFU].ch_dir = CH_OUT_DIR;
+
+    if (hhcd->hc[ch_num & 0xFU].ep_num == 0U)
+    {
+      hhcd->hc[ch_num & 0xFU].pmaadress = hhcd->hc[ch_num & 0xFU].pmaaddr0;
     }
   }
 
@@ -282,11 +388,9 @@
   {
     if (hhcd->Init.iso_singlebuffer_enable == 1U)
     {
-      (void)USB_HC_DoubleBuffer(hhcd->Instance, hhcd->hc[ch_num & 0xFU].phy_ch_num, USB_DRD_DBUFF_ENBALE);
+      (void)USB_HC_DoubleBuffer(hhcd->Instance, hhcd->hc[ch_num & 0xFU].phy_ch_num,
+                                USB_DRD_ISOC_DBUFF_DISABLE);
     }
-    /*Init Buffer State */
-    hhcd->hc[ch_num & 0xFU].pmabuff0_state = USB_PMABUF_EMPTY;
-    hhcd->hc[ch_num & 0xFU].pmabuff1_state = USB_PMABUF_EMPTY;
   }
 
   /* Bulk double buffer check */
@@ -294,9 +398,11 @@
   {
     if (hhcd->Init.bulk_doublebuffer_enable == 1U)
     {
-      (void)USB_HC_DoubleBuffer(hhcd->Instance, hhcd->hc[ch_num & 0xFU].phy_ch_num, USB_DRD_DBUFF_ENBALE);
+      (void)USB_HC_DoubleBuffer(hhcd->Instance, hhcd->hc[ch_num & 0xFU].phy_ch_num,
+                                USB_DRD_BULK_DBUFF_ENBALE);
     }
   }
+
   __HAL_UNLOCK(hhcd);
 
   return status;
@@ -379,6 +485,9 @@
     hhcd->phy_chout_state[idx] = 0U;
   }
 
+  /* reset Ep0 Pma allocation state */
+  hhcd->ep0_PmaAllocState = 0U;
+
   return HAL_OK;
 }
 
@@ -600,6 +709,7 @@
   uint8_t phy_chnum;
   uint8_t chnum;
   uint32_t epch_reg;
+  uint32_t wIstr = USB_ReadInterrupts(hhcd->Instance);
 
   /* check if this is an USB pending IT */
   if ((SYSCFG->IT_LINE_SR[8] & (0x1U << 2)) == 0U)
@@ -608,22 +718,24 @@
   }
 
   /* Port Change Detected (Connection/Disconnection) */
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_DCON))
+  if ((wIstr & USB_ISTR_DCON) == USB_ISTR_DCON)
   {
     /* Clear Flag */
     __HAL_HCD_CLEAR_FLAG(hhcd, USB_ISTR_DCON);
 
     /* Call Port IRQHandler */
     HCD_Port_IRQHandler(hhcd);
+
+    return;
   }
 
   /* Correct Transaction Detected -------*/
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_CTR))
+  if ((wIstr & USB_ISTR_CTR) == USB_ISTR_CTR)
   {
     /* Handle Host channel Interrupt */
     for (phy_chnum = 0U; phy_chnum < hhcd->Init.Host_channels; phy_chnum++)
     {
-      if ((HCD_GET_CHANNEL(hhcd->Instance, phy_chnum)  &USB_CH_VTRX) != 0U)
+      if ((HCD_GET_CHANNEL(hhcd->Instance, phy_chnum) & USB_CH_VTRX) != 0U)
       {
         /* Get Logical channel to check if the channel is already opened */
         chnum = HAL_HCD_GetLogical_Channel(hhcd, phy_chnum, 1U);
@@ -644,9 +756,9 @@
         }
       }
 
-      if ((HCD_GET_CHANNEL(hhcd->Instance, phy_chnum)  &USB_CH_VTTX) != 0U)
+      if ((HCD_GET_CHANNEL(hhcd->Instance, phy_chnum) & USB_CH_VTTX) != 0U)
       {
-        /*Get Logical channel to check if the channel is already opened*/
+        /* Get Logical channel to check if the channel is already opened */
         chnum = HAL_HCD_GetLogical_Channel(hhcd, phy_chnum, 0U);
 
         if (chnum != HCD_LOGICAL_CH_NOT_OPENED)
@@ -656,7 +768,7 @@
         }
         else
         {
-          /*Clear Error & unwanted VTTX or Channel was not closed correctly */
+          /* Clear Error & unwanted VTTX or Channel was not closed correctly */
           epch_reg = HCD_GET_CHANNEL(hhcd->Instance, phy_chnum);
           epch_reg = (epch_reg & (USB_CHEP_REG_MASK & (~USB_CH_ERRTX) & (~USB_CH_VTTX))) |
                      (USB_CH_VTRX | USB_CH_ERRRX);
@@ -666,13 +778,11 @@
       }
     }
 
-    /* Clear Correct Transfer */
-    __HAL_HCD_CLEAR_FLAG(hhcd, USB_ISTR_CTR);
-
+    return;
   }
 
   /* Wakeup Flag Detected */
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_WKUP))
+  if ((wIstr & USB_ISTR_WKUP) == USB_ISTR_WKUP)
   {
     if (hhcd->HostState == HCD_HCD_STATE_SUSPEND)
     {
@@ -688,27 +798,33 @@
     }
     else
     {
-      /*Clear the wake-up flag*/
+      /* Clear the wake-up flag */
       __HAL_HCD_CLEAR_FLAG(hhcd, USB_ISTR_WKUP);
     }
+
+    return;
   }
 
-  /*Global Error Flag Detected */
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_ERR))
+  /* Global Error Flag Detected */
+  if ((wIstr & USB_ISTR_ERR) == USB_ISTR_ERR)
   {
     __HAL_HCD_CLEAR_FLAG(hhcd, USB_ISTR_ERR);
+
+    return;
   }
 
   /* PMA Overrun detected */
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_PMAOVR))
+  if ((wIstr & USB_ISTR_PMAOVR) == USB_ISTR_PMAOVR)
   {
     __HAL_HCD_CLEAR_FLAG(hhcd, USB_ISTR_PMAOVR);
+
+    return;
   }
 
   /* Suspend Detected */
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_SUSP))
+  if ((wIstr & USB_ISTR_SUSP) == USB_ISTR_SUSP)
   {
-    /*Set HAL State to Suspend */
+    /* Set HAL State to Suspend */
     hhcd->HostState = HCD_HCD_STATE_SUSPEND;
 
     /* Force low-power mode in the macrocell */
@@ -717,12 +833,14 @@
     /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
     __HAL_HCD_CLEAR_FLAG(hhcd, USB_ISTR_SUSP);
 
-    /*Call suspend Callback*/
+    /* Call suspend Callback */
     HAL_HCD_SuspendCallback(hhcd);
+
+    return;
   }
 
-  /*Start Of Frame Detected */
-  if (__HAL_HCD_GET_FLAG(hhcd, USB_ISTR_SOF))
+  /* Start Of Frame Detected */
+  if ((wIstr & USB_ISTR_SOF) == USB_ISTR_SOF)
   {
 #if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
     hhcd->SOFCallback(hhcd);
@@ -737,8 +855,15 @@
     {
       /* HAL State */
       hhcd->HostState = HCD_HCD_STATE_RUN;
+
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->PortEnabledCallback(hhcd);
+#else
       HAL_HCD_PortEnabled_Callback(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
     }
+
+    return;
   }
 }
 
@@ -970,7 +1095,7 @@
   /* Process locked */
   __HAL_LOCK(hhcd);
 
-  /* Setup Legacy weak Callbacks  */
+  /* Setup Legacy weak Callbacks */
   if (hhcd->State == HAL_HCD_STATE_READY)
   {
     switch (CallbackID)
@@ -1183,6 +1308,9 @@
   /* Reset the PMA current pointer */
   (void)HAL_HCD_PMAReset(hhcd);
 
+  /* reset Ep0 Pma allocation state */
+  hhcd->ep0_PmaAllocState = 0U;
+
   __HAL_UNLOCK(hhcd);
   return HAL_OK;
 }
@@ -1194,7 +1322,7 @@
   */
 HAL_StatusTypeDef HAL_HCD_Suspend(HCD_HandleTypeDef *hhcd)
 {
-  uint32_t count = 0U;
+  __IO uint32_t count = 0U;
 
   /* Set Suspend Mode */
   hhcd->Instance->CNTR |= USB_CNTR_SUSPEN;
@@ -1369,6 +1497,7 @@
   return (USB_GetHostSpeed(hhcd->Instance));
 }
 
+#if (USE_USB_DOUBLE_BUFFER == 1U)
 /**
   * @brief  Handle Host Channel OUT Double Buffer Bulk requests.
   * @param  hhcd HCD handle
@@ -1407,7 +1536,9 @@
       if ((regvalue & USB_CH_DTOG_RX) != 0U)
       {
         /* Toggle SwBuff */
-        HCD_FreeUserBuffer(hhcd->Instance, phy_chnum, 1U);
+        HCD_CLEAR_TX_DTOG(hhcd->Instance, phy_chnum);
+        HCD_CLEAR_RX_DTOG(hhcd->Instance, phy_chnum);
+        HCD_TX_DTOG(hhcd->Instance, phy_chnum);
       }
 
       /* hhcd->hc[ch_num&0xFU].xfer_len_db==0 ==> when all data are written in the PMA to yet transferred */
@@ -1428,7 +1559,7 @@
         }
 
         /* Write remaining data to Buffer0 */
-        HCD_SET_CH_TX_CNT(hhcd->Instance, phy_chnum, (uint16_t)len);
+        HCD_SET_CH_DBUF0_CNT(hhcd->Instance, phy_chnum, 1U, (uint16_t)len);
         USB_WritePMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
                      hhcd->hc[ch_num & 0xFU].pmaaddr0, (uint16_t)len);
       }
@@ -1466,7 +1597,9 @@
       if ((regvalue & USB_CH_DTOG_RX) == 0U)
       {
         /* Toggle SwBuff */
-        HCD_FreeUserBuffer(hhcd->Instance, phy_chnum, 1U);
+        HCD_CLEAR_TX_DTOG(hhcd->Instance, phy_chnum);
+        HCD_CLEAR_RX_DTOG(hhcd->Instance, phy_chnum);
+        HCD_RX_DTOG(hhcd->Instance, phy_chnum);
       }
 
       /* hhcd->hc[ch_num&0xFU].xfer_len_db==0 ==> when all data are written in the PMA to yet transferred */
@@ -1487,11 +1620,12 @@
         }
 
         /* Write remaining data to Buffer0 */
-        HCD_SET_CH_DBUF1_CNT(hhcd->Instance, phy_chnum, 0U, (uint16_t)len);
+        HCD_SET_CH_DBUF1_CNT(hhcd->Instance, phy_chnum, 1U, (uint16_t)len);
 
         USB_WritePMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
                      hhcd->hc[ch_num & 0xFU].pmaaddr1, (uint16_t)len);
       }
+
       /* start a new transfer */
       HCD_SET_CH_TX_STATUS(hhcd->Instance, phy_chnum, USB_CH_TX_VALID);
     }
@@ -1502,6 +1636,7 @@
       hhcd->hc[ch_num & 0xFU].state = HC_XFRC;
       hhcd->hc[ch_num & 0xFU].urb_state  = URB_DONE;
       hhcd->hc[ch_num & 0xFU].toggle_out ^= 1U;
+
       /* Close the channel */
       HCD_SET_CH_TX_STATUS(hhcd->Instance, phy_chnum, USB_CH_TX_DIS);
     }
@@ -1510,6 +1645,96 @@
 
 
 /**
+  * @brief  Handle Host Channel IN Double Buffer Bulk requests.
+  * @param  hhcd HCD handle
+  * @param  ch_num Channel number: This parameter can be a value from 1 to 15
+  * @param  phy_chnum Physical Channel number [0..7]
+  * @param  regvalue contain Snapshot of the EPCHn register when ISR is detected
+  * @retval none
+  */
+static void HCD_HC_IN_BulkDb(HCD_HandleTypeDef *hhcd,
+                             uint8_t ch_num, uint8_t phy_chnum, uint32_t regvalue)
+{
+  uint16_t received_bytes;
+
+  /* Read from Buffer 0 */
+  if ((regvalue & USB_CH_DTOG_RX) != 0U)
+  {
+    received_bytes = (uint16_t)HCD_GET_CH_DBUF0_CNT(hhcd->Instance, phy_chnum);
+
+    if (hhcd->hc[ch_num & 0xFU].xfer_len <= received_bytes)
+    {
+      hhcd->hc[ch_num & 0xFU].xfer_len = 0U;
+    }
+    else
+    {
+      hhcd->hc[ch_num & 0xFU].xfer_len -= received_bytes;
+    }
+
+    /* Check if we Need to free the other buffer for the IP */
+    if ((hhcd->hc[ch_num & 0xFU].xfer_len != 0U) && ((regvalue & USB_CH_DTOG_TX) != 0U))
+    {
+      /* Toggle SwBuff to Allow the IP to submit a new IN */
+      HCD_FREE_USER_BUFFER(hhcd->Instance, phy_chnum, 0U);
+    }
+
+    /* Read the byte from PMA to user Buffer(System Memory) */
+    USB_ReadPMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
+                hhcd->hc[ch_num & 0xFU].pmaaddr0, (uint16_t)received_bytes);
+  }
+  else
+  {
+    /* Read from Buffer 1 */
+    received_bytes = (uint16_t) HCD_GET_CH_DBUF1_CNT(hhcd->Instance, phy_chnum);
+
+    if (hhcd->hc[ch_num & 0xFU].xfer_len <= received_bytes)
+    {
+      hhcd->hc[ch_num & 0xFU].xfer_len = 0U;
+    }
+    else
+    {
+      hhcd->hc[ch_num & 0xFU].xfer_len -= received_bytes;
+    }
+
+    /* Check if we Need to free the other buffer for the IP */
+    if ((hhcd->hc[ch_num & 0xFU].xfer_len != 0U) && ((regvalue & USB_CH_DTOG_TX) == 0U))
+    {
+      /* Toggle SwBuff */
+      HCD_FREE_USER_BUFFER(hhcd->Instance, phy_chnum, 0U);
+    }
+
+    /* Read the byte from PMA to user Buffer(System Memory) */
+    USB_ReadPMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
+                hhcd->hc[ch_num & 0xFU].pmaaddr1, (uint16_t)received_bytes);
+  }
+
+  /* update the global number of all received bytes */
+  hhcd->hc[ch_num & 0xFU].xfer_count += received_bytes;
+
+  /* Transfer complete state */
+  hhcd->hc[ch_num & 0xFU].state = HC_ACK;
+  hhcd->hc[ch_num & 0xFU].ErrCnt = 0U;
+
+  if ((hhcd->hc[ch_num & 0xFU].xfer_len == 0U) ||
+      ((received_bytes < hhcd->hc[ch_num & 0xFU].max_packet)))
+  {
+    hhcd->hc[ch_num & 0xFU].urb_state  = URB_DONE;
+    hhcd->hc[ch_num & 0xFU].state  = HC_XFRC;
+
+    /* disable channel */
+    HCD_SET_CH_RX_STATUS(hhcd->Instance, phy_chnum, USB_CH_RX_DIS);
+  }
+  else
+  {
+    hhcd->hc[ch_num & 0xFU].xfer_buff += received_bytes;
+
+    /* Reactivate the Channel Submit an other URB since the Transfer is not yet completed */
+    HCD_SET_CH_RX_STATUS(hhcd->Instance, phy_chnum, USB_CH_RX_STRX);
+  }
+}
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
+
+/**
   * @brief  Handle Host Channel IN Isochronous Transaction
   * @param  hhcd HCD handle
   * @param  ch_num Channel number: This parameter can be a value from 1 to 15
@@ -1521,7 +1746,21 @@
                                  uint8_t phy_chnum, uint32_t regvalue)
 {
   /* Check if Double buffer isochronous */
-  if ((regvalue & USB_CH_KIND) == 0U)
+  if ((regvalue & USB_CH_KIND) != 0U)
+  {
+    /* Get Data IN Packet */
+    hhcd->hc[ch_num & 0xFU].xfer_count = HCD_GET_CH_RX_CNT(hhcd->Instance, phy_chnum);
+    if (hhcd->hc[ch_num & 0xFU].xfer_count != 0U)
+    {
+      USB_ReadPMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
+                  hhcd->hc[ch_num & 0xFU].pmaadress,
+                  (uint16_t)hhcd->hc[ch_num & 0xFU].xfer_count);
+
+      hhcd->hc[ch_num & 0xFU].urb_state = URB_DONE;
+    }
+  }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+  else  /* double buffer isochronous */
   {
     /* Read from Buffer0 */
     if ((regvalue & USB_CH_DTOG_RX) != 0U)
@@ -1555,112 +1794,13 @@
       }
     }
   }
-  else  /* single buffer isochronous */
-  {
-    /* Get Control Data OUT Packet*/
-    hhcd->hc[ch_num & 0xFU].xfer_count = HCD_GET_CH_RX_CNT(hhcd->Instance, phy_chnum);
-    if (hhcd->hc[ch_num & 0xFU].xfer_count != 0U)
-    {
-      USB_ReadPMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
-                  hhcd->hc[ch_num & 0xFU].pmaadress,
-                  (uint16_t)hhcd->hc[ch_num & 0xFU].xfer_count);
-
-      hhcd->hc[ch_num & 0xFU].urb_state = URB_DONE;
-    }
-  }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   /* Transfer complete state */
   hhcd->hc[ch_num & 0xFU].state = HC_XFRC;
 
   /* Clear VTRX */
   HCD_CLEAR_RX_CH_CTR(hhcd->Instance, phy_chnum);
-
-}
-/**
-  * @brief  Handle Host Channel IN Double Buffer Bulk requests.
-  * @param  hhcd HCD handle
-  * @param  ch_num Channel number: This parameter can be a value from 1 to 15
-  * @param  phy_chnum Physical Channel number [0..7]
-  * @param  regvalue contain Snapshot of the EPCHn register when ISR is detected
-  * @retval none
-  */
-static void HCD_HC_IN_BulkDb(HCD_HandleTypeDef *hhcd,
-                             uint8_t ch_num, uint8_t phy_chnum, uint32_t regvalue)
-{
-  uint16_t received_bytes;
-
-  /* Read from Buffer 0 */
-  if ((regvalue & USB_CH_DTOG_RX) != 0U)
-  {
-    received_bytes = (uint16_t)HCD_GET_CH_DBUF0_CNT(hhcd->Instance, phy_chnum);
-
-    if (hhcd->hc[ch_num & 0xFU].xfer_len <= received_bytes)
-    {
-      hhcd->hc[ch_num & 0xFU].xfer_len = 0U;
-    }
-    else
-    {
-      hhcd->hc[ch_num & 0xFU].xfer_len -= received_bytes;
-    }
-    /* Check if we Need to free the other buffer for the IP */
-    if ((hhcd->hc[ch_num & 0xFU].xfer_len != 0U) && ((regvalue & USB_CH_DTOG_TX) != 0U))
-    {
-      /* Toggle SwBuff */
-      HCD_FreeUserBuffer(hhcd->Instance, phy_chnum, 0U);/* Allow the IP to submit a new IN */
-    }
-    /* Read the byte from PMA to user Buffer(System Memory) */
-    USB_ReadPMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
-                hhcd->hc[ch_num & 0xFU].pmaaddr0, (uint16_t)received_bytes);
-  }
-  else
-  {
-    /* Read from Buffer 1 */
-    received_bytes = (uint16_t) HCD_GET_CH_DBUF1_CNT(hhcd->Instance, phy_chnum);
-
-    if (hhcd->hc[ch_num & 0xFU].xfer_len <= received_bytes)
-    {
-      hhcd->hc[ch_num & 0xFU].xfer_len = 0U;
-    }
-    else
-    {
-      hhcd->hc[ch_num & 0xFU].xfer_len -= received_bytes;
-    }
-
-    /* Check if we Need to free the other buffer for the IP */
-    if ((hhcd->hc[ch_num & 0xFU].xfer_len != 0U) && ((regvalue & USB_CH_DTOG_TX) == 0U))
-    {
-      /* Toggle SwBuff */
-      HCD_FreeUserBuffer(hhcd->Instance, phy_chnum, 0U);
-    }
-
-    /* Read the byte from PMA to user Buffer(System Memory) */
-    USB_ReadPMA(hhcd->Instance, hhcd->hc[ch_num & 0xFU].xfer_buff,
-                hhcd->hc[ch_num & 0xFU].pmaaddr1, (uint16_t)received_bytes);
-  }
-
-  /* update the global number of all received bytes */
-  hhcd->hc[ch_num & 0xFU].xfer_count += received_bytes;
-
-  /* Transfer complete state */
-  hhcd->hc[ch_num & 0xFU].state = HC_ACK;
-  hhcd->hc[ch_num & 0xFU].ErrCnt = 0U;
-
-  if ((hhcd->hc[ch_num & 0xFU].xfer_len == 0U) ||
-      ((received_bytes < hhcd->hc[ch_num & 0xFU].max_packet)))
-  {
-    hhcd->hc[ch_num & 0xFU].urb_state  = URB_DONE;
-    hhcd->hc[ch_num & 0xFU].state  = HC_XFRC;
-
-    /* disable channel */
-    HCD_SET_CH_RX_STATUS(hhcd->Instance, phy_chnum, USB_CH_RX_DIS);
-  }
-  else
-  {
-    hhcd->hc[ch_num & 0xFU].xfer_buff += received_bytes;
-
-    /* Reactivate the Channel Submit an other URB since the Transfer is not yet completed */
-    HCD_SET_CH_RX_STATUS(hhcd->Instance, phy_chnum, USB_CH_RX_STRX);
-  }
 }
 
 /**
@@ -1704,6 +1844,7 @@
         /* Transfer complete state */
         hhcd->hc[ch_num & 0xFU].state = HC_ACK;
         hhcd->hc[ch_num & 0xFU].ErrCnt = 0U;
+
         if (hhcd->hc[ch_num & 0xFU].xfer_len <= received_bytes)
         {
           hhcd->hc[ch_num & 0xFU].xfer_len = 0U;
@@ -1712,6 +1853,7 @@
         {
           hhcd->hc[ch_num & 0xFU].xfer_len -= received_bytes;
         }
+
         if ((hhcd->hc[ch_num & 0xFU].xfer_len == 0U) ||
             ((received_bytes < hhcd->hc[ch_num & 0xFU].max_packet)))
         {
@@ -1725,13 +1867,13 @@
           /* Reactivate the Channel to Submit another URB since the Transfer is not yet completed */
           HCD_SET_CH_RX_STATUS(hhcd->Instance, phy_chnum, USB_CH_RX_STRX);
         }
+
         if ((hhcd->hc[ch_num & 0xFU].ep_type == EP_TYPE_BULK) ||
             (hhcd->hc[ch_num & 0xFU].ep_type == EP_TYPE_INTR))
         {
           hhcd->hc[ch_num & 0xFU].toggle_out ^= 1U;
         }
       }
-
       /* manage NACK Response */
       else if (((ch_reg & USB_CH_RX_STRX) == USB_CH_RX_NAK)
                && (hhcd->hc[ch_num & 0xFU].urb_state != URB_DONE))
@@ -1740,7 +1882,6 @@
         hhcd->hc[ch_num & 0xFU].ErrCnt = 0U;
         hhcd->hc[ch_num & 0xFU].state = HC_NAK;
       }
-
       /* manage STALL Response */
       else if ((ch_reg & USB_CH_RX_STRX) == USB_CH_RX_STALL)
       {
@@ -1751,7 +1892,7 @@
         /* Close the channel */
         HCD_SET_CH_RX_STATUS(hhcd->Instance, phy_chnum, USB_CH_RX_DIS);
       }
-
+#if (USE_USB_DOUBLE_BUFFER == 1U)
       /* Double Buffer Management in case of Bulk Transaction */
       else  if (((ch_reg & USB_CH_RX_STRX) == USB_CH_RX_ACK_DBUF)
                 && ((ch_reg & USB_CH_KIND) != 0U))
@@ -1759,13 +1900,18 @@
         /* Bulk IN Double Buffer ISR */
         HCD_HC_IN_BulkDb(hhcd, ch_num, phy_chnum, ch_reg);
       }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
       else
       {
         /*....*/
         /* not defined state: STRX=11 in single buffer no iso is not defined */
       }
-      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num,
-                                          hhcd->hc[ch_num & 0xFU].urb_state);
+
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num & 0xFU].urb_state);
+#else
+      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num & 0xFU].urb_state);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
 
       /*Clear VTRX */
       HCD_CLEAR_RX_CH_CTR(hhcd->Instance, phy_chnum);
@@ -1790,8 +1936,12 @@
       /* Clear pending err_tx */
       HCD_CLEAR_RX_CH_ERR(hhcd->Instance, phy_chnum);
     }
-    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num,
-                                        hhcd->hc[ch_num & 0xFU].urb_state);
+
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num & 0xFU].urb_state);
+#else
+    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num & 0xFU].urb_state);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
   }
 }
 
@@ -1806,12 +1956,13 @@
 static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
 {
   uint16_t data_xfr;
+  __IO uint32_t WregCh;
 
   /* Get Physical Channel number */
   uint32_t phy_chnum = (uint8_t)__HAL_HCD_GET_CHNUM(hhcd);
 
   /* Take a Flag snapshot from the CHEP register, due to STRX bits are used for both control &status */
-  __IO uint32_t ch_reg =  *(__IO uint32_t *)(&(hhcd->Instance->CHEP0R) + phy_chnum);
+  uint32_t ch_reg =  *(__IO uint32_t *)(&(hhcd->Instance->CHEP0R) + phy_chnum);
 
   /*------ Manage Correct Transaction ------*/
   if ((ch_reg & USB_CH_ERRTX) == 0U)
@@ -1822,24 +1973,28 @@
       /* correct transaction */
       if ((hhcd->Instance->ISTR & USB_ISTR_ERR) == 0U)
       {
-        /* Double buffer isochronous out*/
-        if ((ch_reg & USB_CH_KIND) == 0U)
+        /* Double buffer isochronous out */
+        if ((ch_reg & USB_CH_KIND) != 0U)
+        {
+          HCD_SET_CH_TX_CNT(hhcd->Instance, phy_chnum, 0U);
+        }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+        else /* double buffer isochronous out */
         {
           /* Odd Transaction */
           if ((ch_reg & USB_CH_DTOG_TX) != 0U)
           {
-            hhcd->hc[chnum & 0xFU].pmabuff0_state = USB_PMABUF_EMPTY;
+            HCD_SET_CH_TX_CNT(hhcd->Instance, phy_chnum, 0U);
           }
           /* Even Transaction */
           else
           {
-            hhcd->hc[chnum & 0xFU].pmabuff1_state = USB_PMABUF_EMPTY;
+            HCD_SET_CH_RX_CNT(hhcd->Instance, phy_chnum, 0U);
           }
+
+          USB_DRD_SET_CHEP_TX_STATUS(hhcd->Instance, phy_chnum, USB_CH_TX_DIS);
         }
-        else /* single buffer isochronous out */
-        {
-          HCD_SET_CH_TX_CNT(hhcd->Instance, phy_chnum, (uint16_t)0U);
-        }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
         /* Transfer complete state */
         hhcd->hc[chnum & 0xFU].state = HC_XFRC;
@@ -1848,6 +2003,14 @@
 
       /*Clear Correct Transfer */
       HCD_CLEAR_TX_CH_CTR(hhcd->Instance, phy_chnum);
+
+      /*TX COMPLETE*/
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#else
+      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+
     }
     else /* Manage all Non Isochronous Transaction */
     {
@@ -1881,6 +2044,7 @@
           hhcd->hc[chnum & 0xFU].xfer_count += data_xfr;
           hhcd->hc[chnum & 0xFU].state = HC_XFRC;
           hhcd->hc[chnum & 0xFU].urb_state = URB_DONE;
+
           if ((hhcd->hc[chnum & 0xFU].ep_type == EP_TYPE_BULK) ||
               (hhcd->hc[chnum & 0xFU].ep_type == EP_TYPE_INTR))
           {
@@ -1888,40 +2052,65 @@
           }
         }
       }
-
       /* Check NACK Response */
-      else if ((ch_reg & USB_CH_TX_STTX) == USB_CH_TX_NAK)
+      else if (((ch_reg & USB_CHEP_NAK) == USB_CHEP_NAK) ||
+               ((ch_reg & USB_CH_TX_STTX) == USB_CH_TX_NAK))
       {
+        /* Update Channel status */
+        hhcd->hc[chnum & 0xFU].state = HC_NAK;
         hhcd->hc[chnum & 0xFU].urb_state = URB_NOTREADY;
         hhcd->hc[chnum & 0xFU].ErrCnt = 0U;
-        hhcd->hc[chnum & 0xFU].state = HC_NAK;
-      }
 
-      /*Check STALL Response*/
+        /* Get Channel register value */
+        WregCh = *(__IO uint32_t *)(&(hhcd->Instance->CHEP0R) + phy_chnum);
+
+        /*clear NAK status*/
+        WregCh &= ~USB_CHEP_NAK & USB_CHEP_REG_MASK;
+
+        /* Update channel register Value */
+        HCD_SET_CHANNEL(hhcd->Instance, phy_chnum, WregCh);
+
+        if (hhcd->hc[chnum & 0xFU].doublebuffer == 0U)
+        {
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+          hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#else
+          HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+        }
+      }
+      /* Check STALL Response */
       else if ((ch_reg & USB_CH_TX_STTX) == USB_CH_TX_STALL)
       {
         (void) HAL_HCD_HC_Halt(hhcd, (uint8_t)chnum);
         hhcd->hc[chnum & 0xFU].state = HC_STALL;
         hhcd->hc[chnum & 0xFU].urb_state = URB_STALL;
       }
-
-      /*Check double buffer ACK in case of bulk transaction */
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+      /* Check double buffer ACK in case of bulk transaction */
       else if ((ch_reg & USB_CH_TX_STTX) == USB_CH_TX_ACK_DBUF)
       {
-        /*Double buffer management Bulk Out*/
+        /* Double buffer management Bulk Out */
         (void) HCD_HC_OUT_BulkDb(hhcd, chnum, (uint8_t)phy_chnum, ch_reg);
       }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
       else
       {
         /*...*/
       }
 
-      HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)chnum,
-                                          hhcd->hc[chnum & 0xFU].urb_state);
+      if ((ch_reg & USB_CH_TX_STTX) != USB_CH_TX_NAK)
+      {
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+        hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#else
+        HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+      }
+
       HCD_CLEAR_TX_CH_CTR(hhcd->Instance, phy_chnum);
     }  /* end no isochronous */
   }
-
   /*------ Manage Transaction Error------*/
   else
   {
@@ -1940,8 +2129,12 @@
 
     /*Clear ERR_TX*/
     HCD_CLEAR_TX_CH_ERR(hhcd->Instance, phy_chnum);
-    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)chnum,
-                                        hhcd->hc[chnum & 0xFU].urb_state);
+
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#else
+    HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)chnum, hhcd->hc[chnum & 0xFU].urb_state);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
   }
 }
 
@@ -1953,52 +2146,76 @@
   */
 static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd)
 {
-  /* J-state detected & LastState=Disconnected   */
-  if (((hhcd->Instance->FNR & USB_FNR_RXDP) != 0U) &&
-      ((hhcd->HostState == HCD_HCD_STATE_DISCONNECTED) != 0U))
-  {
-    HAL_HCD_Connect_Callback(hhcd);
-    hhcd->HostState = HCD_HCD_STATE_CONNECTED;
-  }
-  /* K-state detected & LastState=Disconnected  */
-  else  if (((hhcd->Instance->ISTR & USB_ISTR_LS_DCONN) != 0U)
-            && ((hhcd->HostState == HCD_HCD_STATE_DISCONNECTED) != 0U))
-  {
-    HAL_HCD_Connect_Callback(hhcd);
-    hhcd->HostState = HCD_HCD_STATE_CONNECTED;
-  }
+  uint32_t FnrReg = hhcd->Instance->FNR;
+  uint32_t IstrReg = hhcd->Instance->ISTR;
+
   /* SE0 detected USB Disconnected state */
-  else if ((hhcd->Instance->FNR & (USB_FNR_RXDP | USB_FNR_RXDM)) == 0U)
+  if ((FnrReg & (USB_FNR_RXDP | USB_FNR_RXDM)) == 0U)
   {
-    /*Host Port State*/
+    /* Host Port State */
     hhcd->HostState = HCD_HCD_STATE_DISCONNECTED;
-    /*Disconnection Callback */
+
+    /* clear all allocated virtual channel */
+    HAL_HCD_ClearPhyChannel(hhcd);
+
+    /* Reset the PMA current pointer */
+    (void)HAL_HCD_PMAReset(hhcd);
+
+    /* reset Ep0 Pma allocation state */
+    hhcd->ep0_PmaAllocState = 0U;
+
+    /* Disconnection Callback */
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+    hhcd->DisconnectCallback(hhcd);
+#else
     HAL_HCD_Disconnect_Callback(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+
+    return;
   }
-  /* J-state detected & lastState=Connected: a Missing disconnection is detected */
-  else if (((hhcd->Instance->FNR & USB_FNR_RXDP) != 0U) &&
-           ((hhcd->HostState == HCD_HCD_STATE_CONNECTED) != 0U))
+
+  if ((hhcd->HostState == HCD_HCD_STATE_DISCONNECTED) != 0U)
   {
-    /*Disconnection Callback */
-    HAL_HCD_Disconnect_Callback(hhcd);
-    /*Host Port State*/
-    hhcd->HostState = HCD_HCD_STATE_DISCONNECTED;
-  }
-  /* K-state detected & LastState=Disconnected: a Missing disconnection is detected */
-  else if (((hhcd->Instance->ISTR & USB_ISTR_LS_DCONN) != 0U)
-           && ((hhcd->HostState == HCD_HCD_STATE_CONNECTED) != 0U))
-  {
-    /*Disconnection Callback */
-    HAL_HCD_Disconnect_Callback(hhcd);
-    /*Host Port State*/
-    hhcd->HostState = HCD_HCD_STATE_DISCONNECTED;
+    /* J-state or K-state detected & LastState=Disconnected */
+    if (((FnrReg & USB_FNR_RXDP) != 0U) || ((IstrReg & USB_ISTR_LS_DCONN) != 0U))
+    {
+      hhcd->HostState = HCD_HCD_STATE_CONNECTED;
+
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->ConnectCallback(hhcd);
+#else
+      HAL_HCD_Connect_Callback(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    }
   }
   else
   {
-    /* should not be here */
+    /* J-state or K-state detected & lastState=Connected: a Missed disconnection is detected */
+    if (((FnrReg & USB_FNR_RXDP) != 0U) || ((IstrReg & USB_ISTR_LS_DCONN) != 0U))
+    {
+      /* Host Port State */
+      hhcd->HostState = HCD_HCD_STATE_DISCONNECTED;
+
+      /* clear all allocated virtual channel */
+      HAL_HCD_ClearPhyChannel(hhcd);
+
+      /* Reset the PMA current pointer */
+      (void)HAL_HCD_PMAReset(hhcd);
+
+      /* reset Ep0 PMA allocation state */
+      hhcd->ep0_PmaAllocState = 0U;
+
+      /* Disconnection Callback */
+#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
+      hhcd->DisconnectCallback(hhcd);
+#else
+      HAL_HCD_Disconnect_Callback(hhcd);
+#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
+    }
   }
 }
 
+
 /**
   * @brief  Check if the ch_num are already reserved to a physical channel
   * @param  hhcd  HCD handle
@@ -2013,11 +2230,14 @@
   /* Check if the logical channel are already opened  */
   for (idx = 0U; idx < hhcd->Init.Host_channels; idx++)
   {
-    if ((((hhcd->phy_chin_state[idx] & 0x00F0U) >> 4U) == ((uint16_t)ch_num + 1U)) && (hhcd->phy_chin_state[idx] != 0U))
+    if ((((hhcd->phy_chin_state[idx] & 0xF0U) >> 4U) == ((uint16_t)ch_num + 1U)) &&
+        (hhcd->phy_chin_state[idx] != 0U))
     {
       return (1U | (idx << 4U));
     }
-    if ((((hhcd->phy_chout_state[idx] & 0x00F0U) >> 4U) == ((uint16_t)ch_num + 1U)) && (hhcd->phy_chout_state[idx] != 0U))
+
+    if ((((hhcd->phy_chout_state[idx] & 0xF0U) >> 4U) == ((uint16_t)ch_num + 1U)) &&
+        (hhcd->phy_chout_state[idx] != 0U))
     {
       return (1U | (idx << 4U));
     }
@@ -2026,6 +2246,7 @@
   return 0U;
 }
 
+
 /**
   * @brief  Get a Logical Channel number from  physical Channel
   * @param  hhcd  HCD handle
@@ -2048,7 +2269,7 @@
     }
     else
     {
-      /*Channel not registered Error*/
+      /* Channel not registered Error */
       return HCD_LOGICAL_CH_NOT_OPENED;
     }
   }
@@ -2061,11 +2282,13 @@
     }
     else
     {
-      /*Channel not registered Error*/
+      /* Channel not registered Error */
       return HCD_LOGICAL_CH_NOT_OPENED;
     }
   }
 }
+
+
 /**
   * @brief  Get a free physical Channel number according to the direction
   * @param  hhcd HCD handle
@@ -2087,17 +2310,66 @@
 {
   uint8_t idx;
 
+  if ((epnum & 0x7FU) == 0U)
+  {
+    idx = 0U;
+
+    if (ch_num == 0U)
+    {
+      if (hhcd->phy_chin_state[idx] == 0U)
+      {
+        /* chin_state will store the ep_type to be used for the same channel in OUT direction */
+        hhcd->phy_chin_state[idx] = (((uint16_t)ch_num + 1U) << 4U) |
+                                    ((uint16_t)ep_type + 1U) | /* ep_type(0/1/2/3) so adding + 1 to avoid having a 0 value */
+                                    (((uint16_t)epnum & 0x0FU) << 8U);
+      }
+
+      if (hhcd->phy_chout_state[idx] == 0U)
+      {
+        /* chout_state will store the ep_type to be used for the same channel in IN direction */
+        hhcd->phy_chout_state[idx] = (((uint16_t)ch_num + 1U) << 4U) |
+                                     ((uint16_t)ep_type + 1U) | /* ep_type(0/1/2/3) so adding + 1 to avoid having a 0 value */
+                                     (((uint16_t)epnum & 0x0FU) << 8U);
+      }
+    }
+    else
+    {
+      if ((epnum & 0x80U) != 0U)
+      {
+        if (((hhcd->phy_chin_state[idx] & 0xF0U) >> 4U) != ((uint16_t)ch_num + 1U))
+        {
+          /* chin_state will store the ep_type to be used for the same channel in OUT direction */
+          hhcd->phy_chin_state[idx] = (((uint16_t)ch_num + 1U) << 4U) |
+                                      ((uint16_t)ep_type + 1U) | /* ep_type(0/1/2/3) so adding + 1 to avoid having a 0 value */
+                                      (((uint16_t)epnum & 0x0FU) << 8U);
+        }
+      }
+      else
+      {
+        if (((hhcd->phy_chout_state[idx] & 0xF0U) >> 4U) != ((uint16_t)ch_num + 1U))
+        {
+          /* chout_state will store the ep_type to be used for the same channel in IN direction */
+          hhcd->phy_chout_state[idx] = (((uint16_t)ch_num + 1U) << 4U) |
+                                       ((uint16_t)ep_type + 1U) | /* ep_type(0/1/2/3) so adding + 1 to avoid having a 0 value */
+                                       (((uint16_t)epnum & 0x0FU) << 8U);
+        }
+      }
+    }
+
+    return idx;
+  }
+
   if ((epnum & 0x80U) != 0U)
   {
     /* Find a new available physical in channel */
-    for (idx = 0U; idx < hhcd->Init.Host_channels; idx++)
+    for (idx = 1U; idx < hhcd->Init.Host_channels; idx++)
     {
       if ((hhcd->phy_chin_state[idx] == 0U) &&   /* if PhysicalChannelx(EPCHidx) IN is Free */
           ((((hhcd->phy_chout_state[idx] & 0x000FU) == ((uint16_t)ep_type + 1U)) && /* if  the same (EPCHidx) Channelx OUT is already opened check if the same type is allocated */
             (((hhcd->phy_chout_state[idx] & 0x0F00U) == ((uint16_t)epnum & 0x0FU)))) || /* Check if the same Epnum is allocated then allocate the same physical channelOUT for IN Logical Channel */
            (hhcd->phy_chout_state[idx] == 0U))) /* OR if  physical Channel OUT (EPCHidx)is free */
       {
-        /* chin_state will store the ep_type to be used for the same channel in out direction */
+        /* chin_state will store the ep_type to be used for the same channel in OUT direction */
         hhcd->phy_chin_state[idx] = (((uint16_t)ch_num + 1U) << 4U) |
                                     ((uint16_t)ep_type + 1U) | /* ep_type(0/1/2/3) so adding + 1 to avoid having a 0 value */
                                     (((uint16_t)epnum & 0x0FU) << 8U);
@@ -2109,7 +2381,7 @@
   else
   {
     /* Find a new available physical out channel */
-    for (idx = 0U; idx < hhcd->Init.Host_channels; idx++)
+    for (idx = 1U; idx < hhcd->Init.Host_channels; idx++)
     {
       /* if there is a free out channel and the same channel is used for the in direction then check if same ep_type used */
       if ((hhcd->phy_chout_state[idx] == 0U) &&
@@ -2117,7 +2389,7 @@
             ((hhcd->phy_chin_state[idx] & 0x0F00U) == ((uint16_t)epnum & 0x0FU))) ||
            (hhcd->phy_chin_state[idx] == 0U)))
       {
-        /* chin_state will store the ep_type to be used for the same channel in out direction */
+        /* chout_state will store the ep_type to be used for the same channel in IN direction */
         hhcd->phy_chout_state[idx] = (((uint16_t)ch_num + 1U) << 4U) |
                                      ((uint16_t)ep_type + 1U) |  /* ep_type(0/1/2/3) so adding +1 to avoid having a 0 value */
                                      (((uint16_t)epnum & 0x0FU) << 8U);
@@ -2127,7 +2399,7 @@
     }
   }
 
-  /*in case of Error */
+  /* in case of Error */
   return HCD_FREE_CH_NOT_FOUND;
 }
 
@@ -2171,8 +2443,10 @@
   */
 static uint16_t HAL_HCD_GetFreePMA(HCD_HandleTypeDef *hhcd, uint16_t mps)
 {
-  uint32_t Entry, FreeBlocks = 0U;
-  uint8_t FirstFreeBlock_col = 0U, FirstFreeBlock_line = 0U;
+  uint32_t Entry;
+  uint32_t FreeBlocks = 0U;
+  uint8_t FirstFreeBlock_col = 0U;
+  uint8_t FirstFreeBlock_line = 0U;
   uint8_t ColIndex;
   uint16_t NbrReqBlocks;
   uint16_t mps_t = mps;
@@ -2278,7 +2552,9 @@
                                    uint16_t ch_kind, uint16_t mps)
 {
   uint16_t pma_addr0;
+#if (USE_USB_DOUBLE_BUFFER == 1U)
   uint16_t pma_addr1; /* used for double buffer mode if enabled */
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   /* Host Channel */
   HCD_HCTypeDef *hc = &(hhcd->hc[ch_num]);
@@ -2299,19 +2575,33 @@
       /* Single Buffer */
       hc->doublebuffer = 0U;
 
+      if (hc->ep_num == 0U)
+      {
+        hhcd->ep0_PmaAllocState = ch_num;
+        hhcd->ep0_PmaAllocState |= (1U << 8);
+      }
+
       /* Configure the PMA */
       if (hc->ch_dir == CH_IN_DIR)
       {
-        (USB_DRD_PMA_BUFF + hc->phy_ch_num)->RXBD = pma_addr0;
+        hc->pmaaddr1 = pma_addr0;
+        (USB_DRD_PMA_BUFF + hc->phy_ch_num)->RXBD = hc->pmaaddr1;
+
+        if (hc->ep_num == 0U)
+        {
+          hhcd->ep0_PmaAllocState |= (CH_IN_DIR << 4);
+        }
       }
       else
       {
-        (USB_DRD_PMA_BUFF + hc->phy_ch_num)->TXBD = pma_addr0;
+        hc->pmaaddr0 = pma_addr0;
+        (USB_DRD_PMA_BUFF + hc->phy_ch_num)->TXBD = hc->pmaaddr0;
       }
 
-      /* Set the Pmaaddress */
+      /* Set the PmaAddress */
       hc->pmaadress = pma_addr0;
     }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
     else /* USB_DBL_BUF */
     {
       /* Double Buffer Endpoint */
@@ -2349,6 +2639,7 @@
         }
       }
     }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
   }
 
   return HAL_OK;
@@ -2362,8 +2653,10 @@
   */
 HAL_StatusTypeDef  HAL_HCD_PMADeAlloc(HCD_HandleTypeDef *hhcd, uint8_t  ch_num)
 {
-  HAL_StatusTypeDef status;
+  HAL_StatusTypeDef status = HAL_OK;
+#if (USE_USB_DOUBLE_BUFFER == 1U)
   uint8_t Err = 0U;
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   /* Host Channel */
   HCD_HCTypeDef *hc = &(hhcd->hc[ch_num]);
@@ -2373,6 +2666,7 @@
   {
     status = HAL_HCD_PMAFree(hhcd, hc->pmaadress, hc->max_packet);
   }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
   else   /* Double buffer */
   {
     status = HAL_HCD_PMAFree(hhcd, hc->pmaaddr0, hc->max_packet);
@@ -2392,6 +2686,7 @@
       return HAL_ERROR;
     }
   }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   return status;
 }
@@ -2420,7 +2715,7 @@
 }
 
 /**
-  * @brief  PMA FRee
+  * @brief  PMA Free
   * @param  hhcd   Host instance
   * @param  pma_base PMA base offset stored in hhcd->hc.pmaaddr
   * @param  mps  Max Packet Size
diff --git a/Src/stm32g0xx_hal_pcd.c b/Src/stm32g0xx_hal_pcd.c
index 7e21083..48cceb9 100644
--- a/Src/stm32g0xx_hal_pcd.c
+++ b/Src/stm32g0xx_hal_pcd.c
@@ -88,8 +88,10 @@
   */
 
 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);
+#if (USE_USB_DOUBLE_BUFFER == 1U)
 static HAL_StatusTypeDef HAL_PCD_EP_DB_Transmit(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep, uint16_t wEPVal);
 static uint16_t HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep, uint16_t wEPVal);
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
 /**
   * @}
@@ -167,6 +169,9 @@
 
   hpcd->State = HAL_PCD_STATE_BUSY;
 
+  /* DMA Not supported for FS instance, Force to Zero */
+  hpcd->Init.dma_enable = 0U;
+
   /* Disable the Interrupts */
   __HAL_PCD_DISABLE(hpcd);
 
@@ -396,7 +401,7 @@
 
 /**
   * @brief  Unregister an USB PCD Callback
-  *         USB PCD callabck is redirected to the weak predefined callback
+  *         USB PCD callback is redirected to the weak predefined callback
   * @param  hpcd USB PCD handle
   * @param  CallbackID ID of the callback to be unregistered
   *         This parameter can be one of the following values:
@@ -1005,20 +1010,24 @@
   */
 void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
 {
+  uint32_t wIstr = USB_ReadInterrupts(hpcd->Instance);
+
   /* check if this is an USB pending IT */
   if ((SYSCFG->IT_LINE_SR[8] & (0x1U << 2)) == 0U)
   {
     return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_CTR))
+  if ((wIstr & USB_ISTR_CTR) == USB_ISTR_CTR)
   {
     /* servicing of the endpoint correct transfer interrupt */
     /* clear of the CTR flag into the sub */
     (void)PCD_EP_ISR_Handler(hpcd);
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_RESET))
+  if ((wIstr & USB_ISTR_RESET) == USB_ISTR_RESET)
   {
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);
 
@@ -1029,19 +1038,25 @@
 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
 
     (void)HAL_PCD_SetAddress(hpcd, 0U);
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_PMAOVR))
+  if ((wIstr & USB_ISTR_PMAOVR) == USB_ISTR_PMAOVR)
   {
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_ERR))
+  if ((wIstr & USB_ISTR_ERR) == USB_ISTR_ERR)
   {
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_WKUP))
+  if ((wIstr & USB_ISTR_WKUP) == USB_ISTR_WKUP)
   {
     hpcd->Instance->CNTR &= ~(USB_CNTR_SUSPRDY);
     hpcd->Instance->CNTR &= ~(USB_CNTR_SUSPEN);
@@ -1063,9 +1078,11 @@
 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
 
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_SUSP))
+  if ((wIstr & USB_ISTR_SUSP) == USB_ISTR_SUSP)
   {
     /* Force low-power mode in the macrocell */
     hpcd->Instance->CNTR |= USB_CNTR_SUSPEN;
@@ -1080,10 +1097,12 @@
 #else
     HAL_PCD_SuspendCallback(hpcd);
 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
+
+    return;
   }
 
   /* Handle LPM Interrupt */
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_L1REQ))
+  if ((wIstr & USB_ISTR_L1REQ) == USB_ISTR_L1REQ)
   {
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_L1REQ);
     if (hpcd->LPM_State == LPM_L0)
@@ -1108,9 +1127,11 @@
       HAL_PCD_SuspendCallback(hpcd);
 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     }
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_SOF))
+  if ((wIstr & USB_ISTR_SOF) == USB_ISTR_SOF)
   {
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);
 
@@ -1119,12 +1140,16 @@
 #else
     HAL_PCD_SOFCallback(hpcd);
 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
+
+    return;
   }
 
-  if (__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_ESOF))
+  if ((wIstr & USB_ISTR_ESOF) == USB_ISTR_ESOF)
   {
     /* clear ESOF flag in ISTR */
     __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);
+
+    return;
   }
 }
 
@@ -1592,6 +1617,32 @@
 }
 
 /**
+   * @brief  Abort an USB EP transaction.
+   * @param  hpcd PCD handle
+   * @param  ep_addr endpoint address
+   * @retval HAL status
+   */
+HAL_StatusTypeDef HAL_PCD_EP_Abort(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
+{
+  HAL_StatusTypeDef ret;
+  PCD_EPTypeDef *ep;
+
+  if ((0x80U & ep_addr) == 0x80U)
+  {
+    ep = &hpcd->IN_ep[ep_addr & EP_ADDR_MSK];
+  }
+  else
+  {
+    ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
+  }
+
+  /* Stop Xfer */
+  ret = USB_EPStopXfer(hpcd->Instance, ep);
+
+  return ret;
+}
+
+/**
   * @brief  Flush an endpoint
   * @param  hpcd PCD handle
   * @param  ep_addr endpoint address
@@ -1677,7 +1728,10 @@
 static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
 {
   PCD_EPTypeDef *ep;
-  uint16_t count, wIstr, wEPVal, TxByteNbre;
+  uint16_t count;
+  uint16_t wIstr;
+  uint16_t wEPVal;
+  uint16_t TxPctSize;
   uint8_t epindex;
 
   /* stay in loop while pending interrupts */
@@ -1797,6 +1851,7 @@
             USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, count);
           }
         }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
         else
         {
           /* manage double buffer bulk out */
@@ -1807,7 +1862,7 @@
           else /* manage double buffer iso out */
           {
             /* free EP OUT Buffer */
-            PCD_FreeUserBuffer(hpcd->Instance, ep->num, 0U);
+            PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
 
             if ((PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX) != 0U)
             {
@@ -1831,6 +1886,8 @@
             }
           }
         }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
+
         /* multi-packet on the NON control OUT endpoint */
         ep->xfer_count += count;
         ep->xfer_buff += count;
@@ -1848,7 +1905,6 @@
         {
           (void) USB_EPStartXfer(hpcd->Instance, ep);
         }
-
       }
 
       if ((wEPVal & USB_EP_VTTX) != 0U)
@@ -1858,44 +1914,73 @@
         /* clear int flag */
         PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
 
-        /* Manage all non bulk/isoc transaction Bulk Single Buffer Transaction */
-        if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_CTRL) ||
-           ((ep->type == EP_TYPE_BULK) && ((wEPVal & USB_EP_KIND) == 0U)))
+        if (ep->type != EP_TYPE_BULK)
         {
-          /* multi-packet on the NON control IN endpoint */
-          TxByteNbre = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
+          ep->xfer_len = 0U;
 
-          if (ep->xfer_len > TxByteNbre)
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+          if (ep->doublebuffer != 0U)
           {
-            ep->xfer_len -= TxByteNbre;
+            if ((wEPVal & USB_EP_DTOG_TX) != 0U)
+            {
+              PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
+            }
+            else
+            {
+              PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
+            }
           }
-          else
-          {
-            ep->xfer_len = 0U;
-          }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
-          /* Zero Length Packet? */
-          if (ep->xfer_len == 0U)
-          {
-            /* TX COMPLETE */
+          /* TX COMPLETE */
 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
-            hpcd->DataInStageCallback(hpcd, ep->num);
+          hpcd->DataInStageCallback(hpcd, ep->num);
 #else
-            HAL_PCD_DataInStageCallback(hpcd, ep->num);
+          HAL_PCD_DataInStageCallback(hpcd, ep->num);
 #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
-          }
-          else
-          {
-            /* Transfer is not yet Done */
-            ep->xfer_buff += TxByteNbre;
-            ep->xfer_count += TxByteNbre;
-            (void)USB_EPStartXfer(hpcd->Instance, ep);
-          }
         }
-        /* Double Buffer Iso/bulk IN (bulk transfer Len > Ep_Mps) */
         else
         {
-          (void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);
+          /* Manage Bulk Single Buffer Transaction */
+          if ((wEPVal & USB_EP_KIND) == 0U)
+          {
+            /* multi-packet on the NON control IN endpoint */
+            TxPctSize = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
+
+            if (ep->xfer_len > TxPctSize)
+            {
+              ep->xfer_len -= TxPctSize;
+            }
+            else
+            {
+              ep->xfer_len = 0U;
+            }
+
+            /* Zero Length Packet? */
+            if (ep->xfer_len == 0U)
+            {
+              /* TX COMPLETE */
+#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
+              hpcd->DataInStageCallback(hpcd, ep->num);
+#else
+              HAL_PCD_DataInStageCallback(hpcd, ep->num);
+#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
+            }
+            else
+            {
+              /* Transfer is not yet Done */
+              ep->xfer_buff += TxPctSize;
+              ep->xfer_count += TxPctSize;
+              (void)USB_EPStartXfer(hpcd->Instance, ep);
+            }
+          }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+          /* Double Buffer bulk IN (bulk transfer Len > Ep_Mps) */
+          else
+          {
+            (void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);
+          }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
         }
       }
     }
@@ -1905,6 +1990,7 @@
 }
 
 
+#if (USE_USB_DOUBLE_BUFFER == 1U)
 /**
   * @brief  Manage double buffer bulk out transaction from ISR
   * @param  hpcd PCD handle
@@ -1938,10 +2024,10 @@
       PCD_SET_EP_RX_STATUS(hpcd->Instance, ep->num, USB_EP_RX_NAK);
     }
 
-    /* Check if Buffer1 is in blocked sate which requires to toggle */
+    /* Check if Buffer1 is in blocked state which requires to toggle */
     if ((wEPVal & USB_EP_DTOG_TX) != 0U)
     {
-      PCD_FreeUserBuffer(hpcd->Instance, ep->num, 0U);
+      PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
     }
 
     if (count != 0U)
@@ -1973,7 +2059,7 @@
     /*Need to FreeUser Buffer*/
     if ((wEPVal & USB_EP_DTOG_TX) == 0U)
     {
-      PCD_FreeUserBuffer(hpcd->Instance, ep->num, 0U);
+      PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 0U);
     }
 
     if (count != 0U)
@@ -1997,22 +2083,23 @@
                                                 PCD_EPTypeDef *ep, uint16_t wEPVal)
 {
   uint32_t len;
-  uint16_t TxByteNbre;
+  uint16_t TxPctSize;
 
   /* Data Buffer0 ACK received */
   if ((wEPVal & USB_EP_DTOG_TX) != 0U)
   {
     /* multi-packet on the NON control IN endpoint */
-    TxByteNbre = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
+    TxPctSize = (uint16_t)PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
 
-    if (ep->xfer_len > TxByteNbre)
+    if (ep->xfer_len > TxPctSize)
     {
-      ep->xfer_len -= TxByteNbre;
+      ep->xfer_len -= TxPctSize;
     }
     else
     {
       ep->xfer_len = 0U;
     }
+
     /* Transfer is completed */
     if (ep->xfer_len == 0U)
     {
@@ -2028,7 +2115,7 @@
 
       if ((wEPVal & USB_EP_DTOG_RX) != 0U)
       {
-        PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);
+        PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
       }
     }
     else /* Transfer is not yet Done */
@@ -2036,14 +2123,14 @@
       /* need to Free USB Buff */
       if ((wEPVal & USB_EP_DTOG_RX) != 0U)
       {
-        PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);
+        PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
       }
 
       /* Still there is data to Fill in the next Buffer */
       if (ep->xfer_fill_db == 1U)
       {
-        ep->xfer_buff += TxByteNbre;
-        ep->xfer_count += TxByteNbre;
+        ep->xfer_buff += TxPctSize;
+        ep->xfer_count += TxPctSize;
 
         /* Calculate the len of the new buffer to fill */
         if (ep->xfer_len_db >= ep->maxpacket)
@@ -2053,7 +2140,7 @@
         }
         else if (ep->xfer_len_db == 0U)
         {
-          len = TxByteNbre;
+          len = TxPctSize;
           ep->xfer_fill_db = 0U;
         }
         else
@@ -2075,11 +2162,11 @@
   else /* Data Buffer1 ACK received */
   {
     /* multi-packet on the NON control IN endpoint */
-    TxByteNbre = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
+    TxPctSize = (uint16_t)PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
 
-    if (ep->xfer_len >= TxByteNbre)
+    if (ep->xfer_len >= TxPctSize)
     {
-      ep->xfer_len -= TxByteNbre;
+      ep->xfer_len -= TxPctSize;
     }
     else
     {
@@ -2102,7 +2189,7 @@
       /* need to Free USB Buff */
       if ((wEPVal & USB_EP_DTOG_RX) == 0U)
       {
-        PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);
+        PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
       }
     }
     else /* Transfer is not yet Done */
@@ -2110,14 +2197,14 @@
       /* need to Free USB Buff */
       if ((wEPVal & USB_EP_DTOG_RX) == 0U)
       {
-        PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);
+        PCD_FREE_USER_BUFFER(hpcd->Instance, ep->num, 1U);
       }
 
       /* Still there is data to Fill in the next Buffer */
       if (ep->xfer_fill_db == 1U)
       {
-        ep->xfer_buff += TxByteNbre;
-        ep->xfer_count += TxByteNbre;
+        ep->xfer_buff += TxPctSize;
+        ep->xfer_count += TxPctSize;
 
         /* Calculate the len of the new buffer to fill */
         if (ep->xfer_len_db >= ep->maxpacket)
@@ -2127,7 +2214,7 @@
         }
         else if (ep->xfer_len_db == 0U)
         {
-          len = TxByteNbre;
+          len = TxPctSize;
           ep->xfer_fill_db = 0U;
         }
         else
@@ -2151,6 +2238,7 @@
 
   return HAL_OK;
 }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
 
 
diff --git a/Src/stm32g0xx_hal_pcd_ex.c b/Src/stm32g0xx_hal_pcd_ex.c
index c88c44e..3448b2a 100644
--- a/Src/stm32g0xx_hal_pcd_ex.c
+++ b/Src/stm32g0xx_hal_pcd_ex.c
@@ -101,6 +101,7 @@
     /* Configure the PMA */
     ep->pmaadress = (uint16_t)pmaadress;
   }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
   else /* USB_DBL_BUF */
   {
     /* Double Buffer Endpoint */
@@ -109,6 +110,7 @@
     ep->pmaaddr0 = (uint16_t)(pmaadress & 0xFFFFU);
     ep->pmaaddr1 = (uint16_t)((pmaadress & 0xFFFF0000U) >> 16);
   }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   return HAL_OK;
 }
@@ -160,7 +162,7 @@
   USB_DRD_TypeDef *USBx = hpcd->Instance;
   uint32_t tickstart = HAL_GetTick();
 
-  /* Wait Detect flag or a timeout is happen*/
+  /* Wait Detect flag or a timeout is happen */
   while ((USBx->BCDR & USB_BCDR_DCDET) == 0U)
   {
     /* Check for the Timeout */
diff --git a/Src/stm32g0xx_ll_usb.c b/Src/stm32g0xx_ll_usb.c
index a83ddc8..be46615 100644
--- a/Src/stm32g0xx_ll_usb.c
+++ b/Src/stm32g0xx_ll_usb.c
@@ -53,8 +53,8 @@
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 
-
 static HAL_StatusTypeDef USB_CoreReset(USB_DRD_TypeDef *USBx);
+#if (USE_USB_DOUBLE_BUFFER == 1U)
 static HAL_StatusTypeDef USB_HC_BULK_DB_StartXfer(USB_DRD_TypeDef *USBx,
                                                   USB_DRD_HCTypeDef *hc,
                                                   uint32_t ch_reg,
@@ -63,6 +63,7 @@
 static HAL_StatusTypeDef USB_HC_ISO_DB_StartXfer(USB_DRD_TypeDef *USBx,
                                                  USB_DRD_HCTypeDef *hc,
                                                  uint32_t len);
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
 /**
   * @brief  Reset the USB Core (needed after USB clock settings change)
@@ -260,22 +261,31 @@
     }
     else
     {
-      /*Set the endpoint Receive buffer address */
+      /* Set the endpoint Receive buffer address */
       PCD_SET_EP_RX_ADDRESS(USBx, ep->num, ep->pmaadress);
 
-      /*Set the endpoint Receive buffer counter*/
+      /* Set the endpoint Receive buffer counter */
       PCD_SET_EP_RX_CNT(USBx, ep->num, ep->maxpacket);
       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 
-      /* Configure VALID status for the Endpoint*/
+      /* Configure VALID status for the Endpoint */
       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
     }
   }
-  /*Double Buffer*/
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+  /* Double Buffer */
   else
   {
-    /* Set the endpoint as double buffered */
-    PCD_SET_EP_DBUF(USBx, ep->num);
+    if (ep->type == EP_TYPE_BULK)
+    {
+      /* Set bulk endpoint as double buffered */
+      PCD_SET_BULK_EP_DBUF(USBx, ep->num);
+    }
+    else
+    {
+      /* Set the ISOC endpoint in double buffer mode */
+      PCD_CLEAR_EP_KIND(USBx, ep->num);
+    }
 
     /* Set buffer address for double buffered mode */
     PCD_SET_EP_DBUF_ADDR(USBx, ep->num, ep->pmaaddr0, ep->pmaaddr1);
@@ -309,6 +319,7 @@
       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
     }
   }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   return ret;
 }
@@ -327,18 +338,20 @@
     {
       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 
-      /* Configure DISABLE status for the Endpoint*/
+      /* Configure DISABLE status for the Endpoint */
       PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
     }
+
     else
     {
       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 
-      /* Configure DISABLE status for the Endpoint*/
+      /* Configure DISABLE status for the Endpoint */
       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
     }
   }
-  /*Double Buffer*/
+#if (USE_USB_DOUBLE_BUFFER == 1U)
+  /* Double Buffer */
   else
   {
     if (ep->is_in == 0U)
@@ -365,6 +378,7 @@
       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
     }
   }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   return HAL_OK;
 }
@@ -378,8 +392,10 @@
 HAL_StatusTypeDef USB_EPStartXfer(USB_DRD_TypeDef *USBx, USB_DRD_EPTypeDef *ep)
 {
   uint32_t len;
+#if (USE_USB_DOUBLE_BUFFER == 1U)
   uint16_t pmabuffer;
   uint16_t wEPVal;
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
   /* IN endpoint */
   if (ep->is_in == 1U)
@@ -400,6 +416,7 @@
       USB_WritePMA(USBx, ep->xfer_buff, ep->pmaadress, (uint16_t)len);
       PCD_SET_EP_TX_CNT(USBx, ep->num, len);
     }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
     else
     {
       /* double buffer bulk management */
@@ -408,7 +425,7 @@
         if (ep->xfer_len_db > ep->maxpacket)
         {
           /* enable double buffer */
-          PCD_SET_EP_DBUF(USBx, ep->num);
+          PCD_SET_BULK_EP_DBUF(USBx, ep->num);
 
           /* each Time to write in PMA xfer_len_db will */
           ep->xfer_len_db -= len;
@@ -474,8 +491,8 @@
         {
           len = ep->xfer_len_db;
 
-          /* disable double buffer mode */
-          PCD_CLEAR_EP_DBUF(USBx, ep->num);
+          /* disable double buffer mode for Bulk endpoint */
+          PCD_CLEAR_BULK_EP_DBUF(USBx, ep->num);
 
           /* Set Tx count with nbre of byte to be transmitted */
           PCD_SET_EP_TX_CNT(USBx, ep->num, len);
@@ -484,14 +501,9 @@
           /* Write the user buffer to USB PMA */
           USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
         }
-      }/* end if bulk double buffer */
-
-      /* manage isochronous double buffer IN mode */
-      else
+      }
+      else /* manage isochronous double buffer IN mode */
       {
-        /* enable double buffer */
-        PCD_SET_EP_DBUF(USBx, ep->num);
-
         /* each Time to write in PMA xfer_len_db will */
         ep->xfer_len_db -= len;
 
@@ -504,27 +516,6 @@
 
           /* Write the user buffer to USB PMA */
           USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-          ep->xfer_buff += len;
-
-          if (ep->xfer_len_db > ep->maxpacket)
-          {
-            ep->xfer_len_db -= len;
-          }
-          else
-          {
-            len = ep->xfer_len_db;
-            ep->xfer_len_db = 0U;
-          }
-
-          if (len > 0U)
-          {
-            /* Set the Double buffer counter for pmabuffer0 */
-            PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
-            pmabuffer = ep->pmaaddr0;
-
-            /* Write the user buffer to USB PMA */
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-          }
         }
         else
         {
@@ -534,30 +525,10 @@
 
           /* Write the user buffer to USB PMA */
           USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-          ep->xfer_buff += len;
-
-          if (ep->xfer_len_db > ep->maxpacket)
-          {
-            ep->xfer_len_db -= len;
-          }
-          else
-          {
-            len = ep->xfer_len_db;
-            ep->xfer_len_db = 0U;
-          }
-
-          if (len > 0U)
-          {
-            /* Set the Double buffer counter for pmabuffer1 */
-            PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
-            pmabuffer = ep->pmaaddr1;
-
-            /* Write the user buffer to USB PMA */
-            USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
-          }
         }
       }
     }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
     PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_VALID);
   }
@@ -579,6 +550,7 @@
       /* configure and validate Rx endpoint */
       PCD_SET_EP_RX_CNT(USBx, ep->num, len);
     }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
     else
     {
       /* First Transfer Coming From HAL_PCD_EP_Receive & From ISR */
@@ -597,7 +569,7 @@
           if ((((wEPVal & USB_EP_DTOG_RX) != 0U) && ((wEPVal & USB_EP_DTOG_TX) != 0U)) ||
               (((wEPVal & USB_EP_DTOG_RX) == 0U) && ((wEPVal & USB_EP_DTOG_TX) == 0U)))
           {
-            PCD_FreeUserBuffer(USBx, ep->num, 0U);
+            PCD_FREE_USER_BUFFER(USBx, ep->num, 0U);
           }
         }
       }
@@ -622,6 +594,7 @@
         return HAL_ERROR;
       }
     }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
     PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
   }
@@ -681,7 +654,52 @@
 
   return HAL_OK;
 }
-#endif /* HAL_PCD_MODULE_ENABLED */
+
+/**
+   * @brief  USB_EPStoptXfer  Stop transfer on an EP
+   * @param  USBx  usb device instance
+   * @param  ep pointer to endpoint structure
+   * @retval HAL status
+   */
+HAL_StatusTypeDef USB_EPStopXfer(USB_DRD_TypeDef *USBx, USB_DRD_EPTypeDef *ep)
+{
+  /* IN endpoint */
+  if (ep->is_in == 1U)
+  {
+    if (ep->doublebuffer == 0U)
+    {
+      if (ep->type != EP_TYPE_ISOC)
+      {
+        /* Configure NAK status for the Endpoint */
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
+      }
+      else
+      {
+        /* Configure TX Endpoint to disabled state */
+        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
+      }
+    }
+  }
+  else /* OUT endpoint */
+  {
+    if (ep->doublebuffer == 0U)
+    {
+      if (ep->type != EP_TYPE_ISOC)
+      {
+        /* Configure NAK status for the Endpoint */
+        PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_NAK);
+      }
+      else
+      {
+        /* Configure RX Endpoint to disabled state */
+        PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
+      }
+    }
+  }
+
+  return HAL_OK;
+}
+#endif /* defined (HAL_PCD_MODULE_ENABLED) */
 
 /**
   * @brief  USB_StopDevice Stop the usb device mode
@@ -794,7 +812,8 @@
 void USB_WritePMA(USB_DRD_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
 {
   UNUSED(USBx);
-  uint32_t count, tmp;
+  uint32_t tmp;
+  uint32_t count;
   __IO uint32_t *pdwVal;
   uint32_t NbWords = ((uint32_t)wNBytes + 3U) >> 2U;
   /* Due to the PMA access 32bit only so the last non word data should be processed alone */
@@ -850,7 +869,8 @@
 void USB_ReadPMA(USB_DRD_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
 {
   UNUSED(USBx);
-  uint32_t count, tmp;
+  uint32_t count;
+  uint32_t tmp;
   __IO uint32_t *pdwVal;
   uint32_t NbWords = ((uint32_t)wNBytes + 3U) >> 2U;
   /*Due to the PMA access 32bit only so the last non word data should be processed alone */
@@ -985,7 +1005,7 @@
   * @brief  Set the channel Kind (Single/double buffer mode)
   * @param  USBx Selected device
   * @param  phy_ch_num Selected device
-  * @param  db_state double state can be USB_DRD_DBUFF_ENBALE/USB_DRD_DBUFF_DISABLE
+  * @param  db_state double state can be USB_DRD_XXX_DBUFF_ENBALE/USB_DRD_XXX_DBUFF_DISABLE
   * @retval HAL status
   */
 HAL_StatusTypeDef USB_HC_DoubleBuffer(USB_DRD_TypeDef *USBx,
@@ -993,7 +1013,7 @@
 {
   uint32_t tmp;
 
-  if (db_state == USB_DRD_DBUFF_ENBALE)
+  if ((db_state == USB_DRD_BULK_DBUFF_ENBALE) || (db_state == USB_DRD_ISOC_DBUFF_DISABLE))
   {
     tmp = (USB_DRD_GET_CHEP(USBx, phy_ch_num) | USB_CH_KIND) & USB_CHEP_DB_MSK;
   }
@@ -1039,6 +1059,8 @@
   uint32_t wChRegVal;
   uint32_t HostCoreSpeed;
 
+  UNUSED(mps);
+
   wChRegVal = USB_DRD_GET_CHEP(USBx, phy_ch_num) & USB_CH_T_MASK;
 
   /* initialize host Channel */
@@ -1081,9 +1103,6 @@
   /* Set the dev_address & ep type */
   USB_DRD_SET_CHEP(USBx, phy_ch_num, (wChRegVal | USB_CH_VTRX | USB_CH_VTTX));
 
-  /* Set the Rx Count */
-  USB_DRD_SET_CHEP_RX_CNT(USBx, phy_ch_num, mps);
-
   return ret;
 }
 
@@ -1093,12 +1112,13 @@
   * @param  hc pointer to host channel structure
   * @retval HAL state
   */
-HAL_StatusTypeDef USB_HC_StartXfer(USB_DRD_TypeDef *USBx,
-                                   USB_DRD_HCTypeDef *hc)
+HAL_StatusTypeDef USB_HC_StartXfer(USB_DRD_TypeDef *USBx, USB_DRD_HCTypeDef *hc)
 {
   uint32_t len;
   uint32_t phy_ch_num = (uint32_t)hc->phy_ch_num;
+#if (USE_USB_DOUBLE_BUFFER == 1U)
   uint32_t ch_reg = USB_DRD_GET_CHEP(USBx, phy_ch_num);
+#endif /* USE_USB_DOUBLE_BUFFER */
 
   if (hc->ch_dir == CH_IN_DIR)  /* In Channel */
   {
@@ -1117,19 +1137,21 @@
       /* Set RX buffer count */
       USB_DRD_SET_CHEP_RX_CNT(USBx, phy_ch_num, len);
     }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
     else if (hc->ep_type == EP_TYPE_BULK)
     {
       /* Double buffer activated */
       if ((hc->xfer_len > hc->max_packet))
       {
-        (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_DBUFF_ENBALE);
+        (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_BULK_DBUFF_ENBALE);
 
         /*Set the Double buffer counter*/
-        USB_DRD_SET_CHEP_DBUF_CNT(USBx, phy_ch_num, hc->ch_dir, len);
+        USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, 0U, len);
+        USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, 0U, len);
       }
       else  /* switch to single buffer mode */
       {
-        (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_DBUFF_DISABLE);
+        (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_BULK_DBUFF_DISABLE);
 
         /* Set RX buffer count */
         USB_DRD_SET_CHEP_RX_CNT(USBx, phy_ch_num, len);
@@ -1137,9 +1159,11 @@
     }
     else  /* isochronous */
     {
-      /*Set the Double buffer counter*/
-      USB_DRD_SET_CHEP_DBUF_CNT(USBx, phy_ch_num, hc->ch_dir, len);
+      /* Set the Double buffer counter */
+      USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, 0U, len);
+      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, 0U, len);
     }
+#endif /* USE_USB_DOUBLE_BUFFER */
 
     /*Enable host channel */
     USB_DRD_SET_CHEP_RX_STATUS(USBx, phy_ch_num, USB_CHEP_RX_STRX);
@@ -1161,12 +1185,14 @@
     {
       USB_WritePMA(USBx, hc->xfer_buff, hc->pmaadress, (uint16_t)len);
       USB_DRD_SET_CHEP_TX_CNT(USBx, phy_ch_num, (uint16_t)len);
+
       /*SET PID SETUP  */
       if ((hc->data_pid) == HC_PID_SETUP)
       {
         USB_DRD_CHEP_TX_SETUP(USBx,  phy_ch_num);
       }
     }
+#if (USE_USB_DOUBLE_BUFFER == 1U)
     else if (hc->ep_type == EP_TYPE_BULK)
     {
       (void)USB_HC_BULK_DB_StartXfer(USBx, hc, ch_reg, &len);
@@ -1175,6 +1201,7 @@
     {
       (void)USB_HC_ISO_DB_StartXfer(USBx, hc, len);
     }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
 
     /* Enable host channel */
     USB_DRD_SET_CHEP_TX_STATUS(USBx, hc->phy_ch_num, USB_CH_TX_VALID);
@@ -1182,6 +1209,8 @@
 
   return HAL_OK;
 }
+
+#if (USE_USB_DOUBLE_BUFFER == 1U)
 /**
   * @brief  Start Transfer of Channel isochronous out double buffer
   * @param  USBx Selected device
@@ -1199,57 +1228,16 @@
   /* check the DTOG_TX to determine in which buffer we should write */
   if ((USB_DRD_GET_CHEP(USBx, phy_ch_num) & USB_CH_DTOG_TX) != 0U)
   {
-    if (hc->pmabuff1_state == USB_PMABUF_EMPTY)
-    {
-      /* Set the Double buffer counter for pmabuffer1 */
-      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, hc->ch_dir, len);
-      hc->pmabuff1_state = USB_PMABUF_NOT_EMPTY;
-      USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr1, (uint16_t)len);
-
-      if (hc->pmabuff0_state == USB_PMABUF_EMPTY)
-      {
-        hc->urb_state = URB_DONE;
-      }
-    }
-    else if (hc->pmabuff0_state == USB_PMABUF_EMPTY)
-    {
-      /* Set the Double buffer counter for pmabuffer0 */
-      USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, hc->ch_dir, len);
-      USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr0, (uint16_t)len);
-      hc->pmabuff0_state = USB_PMABUF_NOT_EMPTY;
-    }
-    else
-    {
-      /* both buffer are not empty, should not be in this condition */
-      /*...*/
-    }
+    USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, 1U, len);
+    USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr0, (uint16_t)len);
   }
   else
   {
     /* DTOGTX=0 */
-    if (hc->pmabuff0_state == USB_PMABUF_EMPTY)
-    {
-      /* Set the Double buffer counter for pmabuffer0 */
-      USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, hc->ch_dir, len);
-      USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr0, (uint16_t)len);
-      hc->pmabuff0_state = USB_PMABUF_NOT_EMPTY;
-      if (hc->pmabuff1_state == USB_PMABUF_EMPTY)
-      {
-        hc->urb_state = URB_DONE;
-      }
+    /* Set the Double buffer counter for pmabuffer0 */
+    USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num,1U, len);
+    USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr1, (uint16_t)len);
     }
-    else if (hc->pmabuff1_state == USB_PMABUF_EMPTY)
-    {
-      /* Set the Double buffer counter for pmabuffer1 */
-      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, hc->ch_dir, len);
-      hc->pmabuff1_state = USB_PMABUF_NOT_EMPTY;
-      USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr1, (uint16_t)len);
-    }
-    else
-    {
-      /*...*/
-    }
-  }
 
   return HAL_OK;
 }
@@ -1274,7 +1262,7 @@
   if (hc->xfer_len_db > hc->max_packet)
   {
     /* enable double buffer mode */
-    (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_DBUFF_ENBALE);
+    (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_BULK_DBUFF_ENBALE);
     *len = hc->max_packet;
     hc->xfer_len_db -= *len;
 
@@ -1282,13 +1270,13 @@
     if ((ch_reg & USB_CH_DTOG_TX) == 0U)
     {
       /* Write Buffer0 */
-      USB_DRD_SET_CHEP_TX_CNT(USBx, phy_ch_num, (uint16_t)*len);
+      USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, 1U, (uint16_t)*len);
       USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr0, (uint16_t)*len);
     }
     else
     {
       /* Write Buffer1 */
-      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, (uint8_t) phy_ch_num, 0U, (uint16_t)*len);
+      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, 1U, (uint16_t)*len);
       USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr1, (uint16_t)*len);
     }
 
@@ -1308,27 +1296,28 @@
     if ((ch_reg & USB_CH_DTOG_TX) == 0U)
     {
       /* Write Buffer1 */
-      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, 0U, (uint16_t)*len);
+      USB_DRD_SET_CHEP_DBUF1_CNT(USBx, phy_ch_num, 1U, (uint16_t)*len);
       USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr1, (uint16_t)*len);
     }
     else
     {
       /* Write Buffer0 */
-      USB_DRD_SET_CHEP_TX_CNT(USBx, phy_ch_num, (uint16_t)*len);
+      USB_DRD_SET_CHEP_DBUF0_CNT(USBx, phy_ch_num, 1U, (uint16_t)*len);
       USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr0, (uint16_t)*len);
     }
   }
   else
   {
-    /* Disable double buffer mode */
-    (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_DBUFF_DISABLE);
-
+    /* Disable bulk double buffer mode */
+    (void)USB_HC_DoubleBuffer(USBx, (uint8_t)phy_ch_num, USB_DRD_BULK_DBUFF_DISABLE);
     USB_WritePMA(USBx, hc->xfer_buff, hc->pmaaddr0, (uint16_t)*len);
     USB_DRD_SET_CHEP_TX_CNT(USBx, phy_ch_num, (uint16_t)*len);
   }
 
   return HAL_OK;
 }
+#endif /* (USE_USB_DOUBLE_BUFFER == 1U) */
+
 
 /**
   * @brief  Halt a host channel in
@@ -1344,6 +1333,8 @@
 
   return HAL_OK;
 }
+
+
 /**
   * @brief  Halt a host channel out
   * @param  USBx Selected device