Release v2.10.0

2026-02-08 20:18:07 -05:00 · 2021-09-16 17:30:01 +01:00
parent 06808a92fe
commit 69fa8a86ad
60 changed files with 6008 additions and 2759 deletions
--- a/Core/Src/usbd_core.c
+++ b/Core/Src/usbd_core.c
@@ -19,6 +19,10 @@
 /* Includes ------------------------------------------------------------------*/
 #include "usbd_core.h"

+#ifdef USE_USBD_COMPOSITE
+#include "usbd_composite_builder.h"
+#endif /* USE_USBD_COMPOSITE */
+
 /** @addtogroup STM32_USBD_DEVICE_LIBRARY
  * @{
  */
@@ -95,13 +99,29 @@ USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev,
  {
 #if (USBD_DEBUG_LEVEL > 1U)
    USBD_ErrLog("Invalid Device handle");
-#endif
+#endif /* (USBD_DEBUG_LEVEL > 1U) */
    return USBD_FAIL;
  }

-  /* Unlink previous class resources */
-  pdev->pClass = NULL;
-  pdev->pUserData = NULL;
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0; i < USBD_MAX_SUPPORTED_CLASS; i++)
+  {
+    /* Unlink previous class*/
+    pdev->pClass[i] = NULL;
+    pdev->pUserData[i] = NULL;
+
+    /* Set class as inactive */
+    pdev->tclasslist[i].Active = 0;
+    pdev->NumClasses = 0;
+    pdev->classId = 0;
+  }
+#else
+  /* Unlink previous class*/
+  pdev->pClass[0] = NULL;
+  pdev->pUserData[0] = NULL;
+#endif /* USE_USBD_COMPOSITE */
+
  pdev->pConfDesc = NULL;

  /* Assign USBD Descriptors */
@@ -136,13 +156,31 @@ USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev)
  /* Set Default State */
  pdev->dev_state = USBD_STATE_DEFAULT;

-  /* Free Class Resources */
-  if (pdev->pClass != NULL)
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0; i < USBD_MAX_SUPPORTED_CLASS; i++)
  {
-    pdev->pClass->DeInit(pdev, (uint8_t)pdev->dev_config);
-    pdev->pClass = NULL;
-    pdev->pUserData = NULL;
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      if (pdev->pClass[i] != NULL)
+      {
+        pdev->classId = i;
+        /* Free Class Resources */
+        pdev->pClass[i]->DeInit(pdev, (uint8_t)pdev->dev_config);
+      }
+    }
  }
+#else
+  /* Free Class Resources */
+  if (pdev->pClass[0] != NULL)
+  {
+    pdev->pClass[0]->DeInit(pdev, (uint8_t)pdev->dev_config);
+  }
+
+  pdev->pUserData[0] = NULL;
+
+#endif /* USE_USBD_COMPOSITE */

  /* Free Device descriptors resources */
  pdev->pDesc = NULL;
@@ -169,29 +207,161 @@ USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDe
  {
 #if (USBD_DEBUG_LEVEL > 1U)
    USBD_ErrLog("Invalid Class handle");
-#endif
+#endif /* (USBD_DEBUG_LEVEL > 1U) */
    return USBD_FAIL;
  }

  /* link the class to the USB Device handle */
-  pdev->pClass = pclass;
+  pdev->pClass[0] = pclass;

  /* Get Device Configuration Descriptor */
 #ifdef USE_USB_HS
-  if (pdev->pClass->GetHSConfigDescriptor != NULL)
+  if (pdev->pClass[pdev->classId]->GetHSConfigDescriptor != NULL)
  {
-    pdev->pConfDesc = (void *)pdev->pClass->GetHSConfigDescriptor(&len);
+    pdev->pConfDesc = (void *)pdev->pClass[pdev->classId]->GetHSConfigDescriptor(&len);
  }
 #else /* Default USE_USB_FS */
-  if (pdev->pClass->GetFSConfigDescriptor != NULL)
+  if (pdev->pClass[pdev->classId]->GetFSConfigDescriptor != NULL)
  {
-    pdev->pConfDesc = (void *)pdev->pClass->GetFSConfigDescriptor(&len);
+    pdev->pConfDesc = (void *)pdev->pClass[pdev->classId]->GetFSConfigDescriptor(&len);
  }
 #endif /* USE_USB_FS */

+  /* Increment the NumClasses */
+  pdev->NumClasses ++;
+
  return USBD_OK;
 }

+#ifdef USE_USBD_COMPOSITE
+/**
+  * @brief  USBD_RegisterClassComposite
+  *         Link class driver to Device Core.
+  * @param  pdev : Device Handle
+  * @param  pclass: Class handle
+  * @param  classtype: Class type
+  * @param  EpAddr: Endpoint Address handle
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef  USBD_RegisterClassComposite(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass,
+                                                USBD_CompositeClassTypeDef classtype, uint8_t *EpAddr)
+{
+  USBD_StatusTypeDef   ret = USBD_OK;
+  uint16_t len = 0U;
+
+  if ((pdev->classId < USBD_MAX_SUPPORTED_CLASS) && (pdev->NumClasses < USBD_MAX_SUPPORTED_CLASS))
+  {
+    if ((uint32_t)pclass != 0U)
+    {
+      /* Link the class to the USB Device handle */
+      pdev->pClass[pdev->classId] = pclass;
+      ret = USBD_OK;
+
+      pdev->tclasslist[pdev->classId].EpAdd = EpAddr;
+
+      /* Call the composite class builder */
+      (void)USBD_CMPSIT_AddClass(pdev, pclass, classtype, 0);
+
+      /* Increment the ClassId for the next occurrence */
+      pdev->classId ++;
+      pdev->NumClasses ++;
+    }
+    else
+    {
+#if (USBD_DEBUG_LEVEL > 1U)
+      USBD_ErrLog("Invalid Class handle");
+#endif /* (USBD_DEBUG_LEVEL > 1U) */
+      ret = USBD_FAIL;
+    }
+  }
+
+  if (ret == USBD_OK)
+  {
+    /* Get Device Configuration Descriptor */
+#ifdef USE_USB_HS
+    pdev->pConfDesc = USBD_CMPSIT.GetHSConfigDescriptor(&len);
+#else /* Default USE_USB_FS */
+    pdev->pConfDesc = USBD_CMPSIT.GetFSConfigDescriptor(&len);
+#endif /* USE_USB_FS */
+  }
+
+  return ret;
+}
+
+/**
+  * @brief  USBD_UnRegisterClassComposite
+  *         UnLink all composite class drivers from Device Core.
+  * @param  pDevice : Device Handle
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef  USBD_UnRegisterClassComposite(USBD_HandleTypeDef *pdev)
+{
+  USBD_StatusTypeDef   ret = USBD_FAIL;
+  uint8_t idx1;
+  uint8_t idx2;
+
+  /* Unroll all activated classes */
+  for (idx1 = 0; idx1 < pdev->NumClasses; idx1++)
+  {
+    /* Check if the class correspond to the requested type and if it is active */
+    if (pdev->tclasslist[idx1].Active == 1U)
+    {
+      /* Set the new class ID */
+      pdev->classId = idx1;
+
+      /* Free resources used by the selected class */
+      if (pdev->pClass[pdev->classId] != NULL)
+      {
+        /* Free Class Resources */
+        if (pdev->pClass[pdev->classId]->DeInit(pdev, (uint8_t)pdev->dev_config) != 0U)
+        {
+#if (USBD_DEBUG_LEVEL > 1U)
+          USBD_ErrLog("Class DeInit didn't succeed!, can't unregister selected class");
+#endif /* (USBD_DEBUG_LEVEL > 1U) */
+
+          ret = USBD_FAIL;
+        }
+      }
+
+      /* Free the class pointer */
+      pdev->pClass[pdev->classId] = NULL;
+
+      /* Free the class location in classes table and reset its parameters to zero */
+      pdev->tclasslist[pdev->classId].ClassType = CLASS_TYPE_NONE;
+      pdev->tclasslist[pdev->classId].ClassId = 0U;
+      pdev->tclasslist[pdev->classId].Active = 0U;
+      pdev->tclasslist[pdev->classId].NumEps = 0U;
+      pdev->tclasslist[pdev->classId].NumIf = 0U;
+      pdev->tclasslist[pdev->classId].CurrPcktSze = 0U;
+
+      for (idx2 = 0U; idx2 < USBD_MAX_CLASS_ENDPOINTS; idx2++)
+      {
+        pdev->tclasslist[pdev->classId].Eps[idx2].add = 0U;
+        pdev->tclasslist[pdev->classId].Eps[idx2].type = 0U;
+        pdev->tclasslist[pdev->classId].Eps[idx2].size = 0U;
+        pdev->tclasslist[pdev->classId].Eps[idx2].is_used = 0U;
+      }
+
+      for (idx2 = 0U; idx2 < USBD_MAX_CLASS_INTERFACES; idx2++)
+      {
+        pdev->tclasslist[pdev->classId].Ifs[idx2] = 0U;
+      }
+    }
+  }
+
+  /* Reset the configuration descriptor */
+  (void)USBD_CMPST_ClearConfDesc(pdev);
+
+  /* Reset the class ID and number of classes */
+  pdev->classId = 0U;
+  pdev->NumClasses = 0U;
+
+  return ret;
+}
+
+
+#endif /* USE_USBD_COMPOSITE */
+
 /**
  * @brief  USBD_Start
  *         Start the USB Device Core.
@@ -200,6 +370,10 @@ USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDe
  */
 USBD_StatusTypeDef USBD_Start(USBD_HandleTypeDef *pdev)
 {
+#ifdef USE_USBD_COMPOSITE
+  pdev->classId = 0U;
+#endif /* USE_USBD_COMPOSITE */
+
  /* Start the low level driver  */
  return USBD_LL_Start(pdev);
 }
@@ -216,11 +390,31 @@ USBD_StatusTypeDef USBD_Stop(USBD_HandleTypeDef *pdev)
  (void)USBD_LL_Stop(pdev);

  /* Free Class Resources */
-  if (pdev->pClass != NULL)
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
  {
-    (void)pdev->pClass->DeInit(pdev, (uint8_t)pdev->dev_config);
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      if (pdev->pClass[i] != NULL)
+      {
+        pdev->classId = i;
+        /* Free Class Resources */
+        (void)pdev->pClass[i]->DeInit(pdev, (uint8_t)pdev->dev_config);
+      }
+    }
  }

+  /* Reset the class ID */
+  pdev->classId = 0U;
+#else
+  if (pdev->pClass[0] != NULL)
+  {
+    (void)pdev->pClass[0]->DeInit(pdev, (uint8_t)pdev->dev_config);
+  }
+#endif /* USE_USBD_COMPOSITE */
+
  return USBD_OK;
 }

@@ -230,12 +424,21 @@ USBD_StatusTypeDef USBD_Stop(USBD_HandleTypeDef *pdev)
  * @param  pdev: device instance
  * @retval status
  */
-USBD_StatusTypeDef USBD_RunTestMode(USBD_HandleTypeDef  *pdev)
+USBD_StatusTypeDef USBD_RunTestMode(USBD_HandleTypeDef *pdev)
 {
+#ifdef USBD_HS_TESTMODE_ENABLE
+  USBD_StatusTypeDef ret;
+
+  /* Run USB HS test mode */
+  ret = USBD_LL_SetTestMode(pdev, pdev->dev_test_mode);
+
+  return ret;
+#else
  /* Prevent unused argument compilation warning */
  UNUSED(pdev);

  return USBD_OK;
+#endif /* USBD_HS_TESTMODE_ENABLE */
 }

 /**
@@ -248,13 +451,33 @@ USBD_StatusTypeDef USBD_RunTestMode(USBD_HandleTypeDef  *pdev)

 USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 {
-  USBD_StatusTypeDef ret = USBD_FAIL;
+  USBD_StatusTypeDef ret = USBD_OK;

-  if (pdev->pClass != NULL)
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
+  {
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      if (pdev->pClass[i] != NULL)
+      {
+        pdev->classId = i;
+        /* Set configuration  and Start the Class*/
+        if (pdev->pClass[i]->Init(pdev, cfgidx) != 0U)
+        {
+          ret = USBD_FAIL;
+        }
+      }
+    }
+  }
+#else
+  if (pdev->pClass[0] != NULL)
  {
    /* Set configuration and Start the Class */
-    ret = (USBD_StatusTypeDef)pdev->pClass->Init(pdev, cfgidx);
+    ret = (USBD_StatusTypeDef)pdev->pClass[0]->Init(pdev, cfgidx);
  }
+#endif /* USE_USBD_COMPOSITE */

  return ret;
 }
@@ -268,13 +491,35 @@ USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
  */
 USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 {
-  /* Clear configuration and De-initialize the Class process */
-  if (pdev->pClass != NULL)
-  {
-    pdev->pClass->DeInit(pdev, cfgidx);
-  }
+  USBD_StatusTypeDef ret = USBD_OK;

-  return USBD_OK;
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
+  {
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      if (pdev->pClass[i] != NULL)
+      {
+        pdev->classId = i;
+        /* Clear configuration  and De-initialize the Class process */
+        if (pdev->pClass[i]->DeInit(pdev, cfgidx) != 0U)
+        {
+          ret = USBD_FAIL;
+        }
+      }
+    }
+  }
+#else
+  /* Clear configuration  and De-initialize the Class process */
+  if (pdev->pClass[0]->DeInit(pdev, cfgidx) != 0U)
+  {
+    ret = USBD_FAIL;
+  }
+#endif /* USE_USBD_COMPOSITE */
+
+  return ret;
 }


@@ -328,7 +573,8 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
                                        uint8_t epnum, uint8_t *pdata)
 {
  USBD_EndpointTypeDef *pep;
-  USBD_StatusTypeDef ret;
+  USBD_StatusTypeDef ret = USBD_OK;
+  uint8_t idx;

  if (epnum == 0U)
  {
@@ -344,11 +590,39 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
      }
      else
      {
-        if (pdev->dev_state == USBD_STATE_CONFIGURED)
+        /* Find the class ID relative to the current request */
+        switch (pdev->request.bmRequest & 0x1FU)
        {
-          if (pdev->pClass->EP0_RxReady != NULL)
+          case USB_REQ_RECIPIENT_DEVICE:
+            /* Device requests must be managed by the first instantiated class
+               (or duplicated by all classes for simplicity) */
+            idx = 0U;
+            break;
+
+          case USB_REQ_RECIPIENT_INTERFACE:
+            idx = USBD_CoreFindIF(pdev, LOBYTE(pdev->request.wIndex));
+            break;
+
+          case USB_REQ_RECIPIENT_ENDPOINT:
+            idx = USBD_CoreFindEP(pdev, LOBYTE(pdev->request.wIndex));
+            break;
+
+          default:
+            /* Back to the first class in case of doubt */
+            idx = 0U;
+            break;
+        }
+
+        if (idx < USBD_MAX_SUPPORTED_CLASS)
+        {
+          /* Setup the class ID and route the request to the relative class function */
+          if (pdev->dev_state == USBD_STATE_CONFIGURED)
          {
-            pdev->pClass->EP0_RxReady(pdev);
+            if (pdev->pClass[idx]->EP0_RxReady != NULL)
+            {
+              pdev->classId = idx;
+              pdev->pClass[idx]->EP0_RxReady(pdev);
+            }
          }
        }

@@ -371,17 +645,24 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
  }
  else
  {
-    if (pdev->dev_state == USBD_STATE_CONFIGURED)
-    {
-      if (pdev->pClass->DataOut != NULL)
-      {
-        ret = (USBD_StatusTypeDef)pdev->pClass->DataOut(pdev, epnum);
+    /* Get the class index relative to this interface */
+    idx = USBD_CoreFindEP(pdev, (epnum & 0x7FU));

-        if (ret != USBD_OK)
+    if (((uint16_t)idx != 0xFFU) && (idx < USBD_MAX_SUPPORTED_CLASS))
+    {
+      /* Call the class data out function to manage the request */
+      if (pdev->dev_state == USBD_STATE_CONFIGURED)
+      {
+        if (pdev->pClass[idx]->DataOut != NULL)
        {
-          return ret;
+          pdev->classId = idx;
+          ret = (USBD_StatusTypeDef)pdev->pClass[idx]->DataOut(pdev, epnum);
        }
      }
+      if (ret != USBD_OK)
+      {
+        return ret;
+      }
    }
  }

@@ -400,6 +681,7 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
 {
  USBD_EndpointTypeDef *pep;
  USBD_StatusTypeDef ret;
+  uint8_t idx;

  if (epnum == 0U)
  {
@@ -433,9 +715,10 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
        {
          if (pdev->dev_state == USBD_STATE_CONFIGURED)
          {
-            if (pdev->pClass->EP0_TxSent != NULL)
+            if (pdev->pClass[0]->EP0_TxSent != NULL)
            {
-              pdev->pClass->EP0_TxSent(pdev);
+              pdev->classId = 0U;
+              pdev->pClass[0]->EP0_TxSent(pdev);
            }
          }
          (void)USBD_LL_StallEP(pdev, 0x80U);
@@ -454,7 +737,7 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
 #endif
    }

-    if (pdev->dev_test_mode == 1U)
+    if (pdev->dev_test_mode != 0U)
    {
      (void)USBD_RunTestMode(pdev);
      pdev->dev_test_mode = 0U;
@@ -462,15 +745,23 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
  }
  else
  {
-    if (pdev->dev_state == USBD_STATE_CONFIGURED)
-    {
-      if (pdev->pClass->DataIn != NULL)
-      {
-        ret = (USBD_StatusTypeDef)pdev->pClass->DataIn(pdev, epnum);
+    /* Get the class index relative to this interface */
+    idx = USBD_CoreFindEP(pdev, ((uint8_t)epnum | 0x80U));

-        if (ret != USBD_OK)
+    if (((uint16_t)idx != 0xFFU) && (idx < USBD_MAX_SUPPORTED_CLASS))
+    {
+      /* Call the class data out function to manage the request */
+      if (pdev->dev_state == USBD_STATE_CONFIGURED)
+      {
+        if (pdev->pClass[idx]->DataIn != NULL)
        {
-          return ret;
+          pdev->classId = idx;
+          ret = (USBD_StatusTypeDef)pdev->pClass[idx]->DataIn(pdev, epnum);
+
+          if (ret != USBD_OK)
+          {
+            return ret;
+          }
        }
      }
    }
@@ -488,24 +779,50 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,

 USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef *pdev)
 {
+  USBD_StatusTypeDef ret = USBD_OK;
+
  /* Upon Reset call user call back */
  pdev->dev_state = USBD_STATE_DEFAULT;
  pdev->ep0_state = USBD_EP0_IDLE;
  pdev->dev_config = 0U;
  pdev->dev_remote_wakeup = 0U;
+  pdev->dev_test_mode = 0U;

-  if (pdev->pClass == NULL)
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
  {
-    return USBD_FAIL;
-  }
-
-  if (pdev->pClassData != NULL)
-  {
-    if (pdev->pClass->DeInit != NULL)
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
    {
-      (void)pdev->pClass->DeInit(pdev, (uint8_t)pdev->dev_config);
+      if (pdev->pClass[i] != NULL)
+      {
+        pdev->classId = i;
+        /* Clear configuration  and De-initialize the Class process*/
+
+        if (pdev->pClass[i]->DeInit != NULL)
+        {
+          if (pdev->pClass[i]->DeInit(pdev, (uint8_t)pdev->dev_config) != USBD_OK)
+          {
+            ret = USBD_FAIL;
+          }
+        }
+      }
    }
  }
+#else
+
+  if (pdev->pClass[0] != NULL)
+  {
+    if (pdev->pClass[0]->DeInit != NULL)
+    {
+      if (pdev->pClass[0]->DeInit(pdev, (uint8_t)pdev->dev_config) != USBD_OK)
+      {
+        ret = USBD_FAIL;
+      }
+    }
+  }
+#endif /* USE_USBD_COMPOSITE */

  /* Open EP0 OUT */
  (void)USBD_LL_OpenEP(pdev, 0x00U, USBD_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
@@ -519,7 +836,7 @@ USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef *pdev)

  pdev->ep_in[0].maxpacket = USB_MAX_EP0_SIZE;

-  return USBD_OK;
+  return ret;
 }

 /**
@@ -577,17 +894,35 @@ USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef *pdev)

 USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef *pdev)
 {
-  if (pdev->pClass == NULL)
-  {
-    return USBD_FAIL;
-  }
-
+  /* The SOF event can be distributed for all classes that support it */
  if (pdev->dev_state == USBD_STATE_CONFIGURED)
  {
-    if (pdev->pClass->SOF != NULL)
+#ifdef USE_USBD_COMPOSITE
+    /* Parse the table of classes in use */
+    for (uint32_t i = 0; i < USBD_MAX_SUPPORTED_CLASS; i++)
    {
-      (void)pdev->pClass->SOF(pdev);
+      /* Check if current class is in use */
+      if ((pdev->tclasslist[i].Active) == 1U)
+      {
+        if (pdev->pClass[i] != NULL)
+        {
+          if (pdev->pClass[i]->SOF != NULL)
+          {
+            pdev->classId = i;
+            (void)pdev->pClass[i]->SOF(pdev);
+          }
+        }
+      }
    }
+#else
+    if (pdev->pClass[0] != NULL)
+    {
+      if (pdev->pClass[0]->SOF != NULL)
+      {
+        (void)pdev->pClass[0]->SOF(pdev);
+      }
+    }
+#endif /* USE_USBD_COMPOSITE */
  }

  return USBD_OK;
@@ -602,16 +937,16 @@ USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef *pdev)
 USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef *pdev,
                                           uint8_t epnum)
 {
-  if (pdev->pClass == NULL)
+  if (pdev->pClass[pdev->classId] == NULL)
  {
    return USBD_FAIL;
  }

  if (pdev->dev_state == USBD_STATE_CONFIGURED)
  {
-    if (pdev->pClass->IsoINIncomplete != NULL)
+    if (pdev->pClass[pdev->classId]->IsoINIncomplete != NULL)
    {
-      (void)pdev->pClass->IsoINIncomplete(pdev, epnum);
+      (void)pdev->pClass[pdev->classId]->IsoINIncomplete(pdev, epnum);
    }
  }

@@ -627,16 +962,16 @@ USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef *pdev,
 USBD_StatusTypeDef USBD_LL_IsoOUTIncomplete(USBD_HandleTypeDef *pdev,
                                            uint8_t epnum)
 {
-  if (pdev->pClass == NULL)
+  if (pdev->pClass[pdev->classId] == NULL)
  {
    return USBD_FAIL;
  }

  if (pdev->dev_state == USBD_STATE_CONFIGURED)
  {
-    if (pdev->pClass->IsoOUTIncomplete != NULL)
+    if (pdev->pClass[pdev->classId]->IsoOUTIncomplete != NULL)
    {
-      (void)pdev->pClass->IsoOUTIncomplete(pdev, epnum);
+      (void)pdev->pClass[pdev->classId]->IsoOUTIncomplete(pdev, epnum);
    }
  }

@@ -665,16 +1000,210 @@ USBD_StatusTypeDef USBD_LL_DevConnected(USBD_HandleTypeDef *pdev)
  */
 USBD_StatusTypeDef USBD_LL_DevDisconnected(USBD_HandleTypeDef *pdev)
 {
+  USBD_StatusTypeDef   ret = USBD_OK;
+
  /* Free Class Resources */
  pdev->dev_state = USBD_STATE_DEFAULT;

-  if (pdev->pClass != NULL)
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0; i < USBD_MAX_SUPPORTED_CLASS; i++)
  {
-    (void)pdev->pClass->DeInit(pdev, (uint8_t)pdev->dev_config);
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      if (pdev->pClass[i] != NULL)
+      {
+        pdev->classId = i;
+        /* Clear configuration  and De-initialize the Class process*/
+        if (pdev->pClass[i]->DeInit(pdev, (uint8_t)pdev->dev_config) != 0U)
+        {
+          ret = USBD_FAIL;
+        }
+      }
+    }
+  }
+#else
+  if (pdev->pClass[0] != NULL)
+  {
+    if (pdev->pClass[0]->DeInit(pdev, (uint8_t)pdev->dev_config) != 0U)
+    {
+      ret = USBD_FAIL;
+    }
+  }
+#endif /* USE_USBD_COMPOSITE */
+
+  return ret;
+}
+
+/**
+  * @brief  USBD_CoreFindIF
+  *         return the class index relative to the selected interface
+  * @param  pdev: device instance
+  * @param  index : selected interface number
+  * @retval index of the class using the selected interface number. OxFF if no class found.
+  */
+uint8_t USBD_CoreFindIF(USBD_HandleTypeDef *pdev, uint8_t index)
+{
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
+  {
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      /* Parse all interfaces listed in the current class */
+      for (uint32_t j = 0U; j < pdev->tclasslist[i].NumIf; j++)
+      {
+        /* Check if requested Interface matches the current class interface */
+        if (pdev->tclasslist[i].Ifs[j] == index)
+        {
+          if (pdev->pClass[i]->Setup != NULL)
+          {
+            return (uint8_t)i;
+          }
+        }
+      }
+    }
  }

-  return USBD_OK;
+  return 0xFFU;
+#else
+  UNUSED(pdev);
+  UNUSED(index);
+
+  return 0x00U;
+#endif /* USE_USBD_COMPOSITE */
 }
+
+/**
+  * @brief  USBD_CoreFindEP
+  *         return the class index relative to the selected endpoint
+  * @param  pdev: device instance
+  * @param  index : selected endpoint number
+  * @retval index of the class using the selected endpoint number. 0xFF if no class found.
+  */
+uint8_t USBD_CoreFindEP(USBD_HandleTypeDef *pdev, uint8_t index)
+{
+#ifdef USE_USBD_COMPOSITE
+  /* Parse the table of classes in use */
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
+  {
+    /* Check if current class is in use */
+    if ((pdev->tclasslist[i].Active) == 1U)
+    {
+      /* Parse all endpoints listed in the current class */
+      for (uint32_t j = 0U; j < pdev->tclasslist[i].NumEps; j++)
+      {
+        /* Check if requested endpoint matches the current class endpoint */
+        if (pdev->tclasslist[i].Eps[j].add == index)
+        {
+          if (pdev->pClass[i]->Setup != NULL)
+          {
+            return (uint8_t)i;
+          }
+        }
+      }
+    }
+  }
+
+  return 0xFFU;
+#else
+  UNUSED(pdev);
+  UNUSED(index);
+
+  return 0x00U;
+#endif /* USE_USBD_COMPOSITE */
+}
+
+#ifdef USE_USBD_COMPOSITE
+/**
+  * @brief  USBD_CoreGetEPAdd
+  *         Get the endpoint address relative to a selected class
+  * @param  pdev: device instance
+  * @param  ep_dir: USBD_EP_IN or USBD_EP_OUT
+  * @param  ep_type: USBD_EP_TYPE_CTRL, USBD_EP_TYPE_ISOC, USBD_EP_TYPE_BULK or USBD_EP_TYPE_INTR
+  * @retval Address of the selected endpoint or 0xFFU if no endpoint found.
+  */
+uint8_t USBD_CoreGetEPAdd(USBD_HandleTypeDef *pdev, uint8_t ep_dir, uint8_t ep_type)
+{
+  uint8_t idx;
+
+  /* Find the EP address in the selected class table */
+  for (idx = 0; idx < pdev->tclasslist[pdev->classId].NumEps; idx++)
+  {
+    if (((pdev->tclasslist[pdev->classId].Eps[idx].add & USBD_EP_IN) == ep_dir) && \
+        (pdev->tclasslist[pdev->classId].Eps[idx].type == ep_type) && \
+        (pdev->tclasslist[pdev->classId].Eps[idx].is_used != 0U))
+    {
+      return (pdev->tclasslist[pdev->classId].Eps[idx].add);
+    }
+  }
+
+  /* If reaching this point, then no endpoint was found */
+  return 0xFFU;
+}
+#endif /* USE_USBD_COMPOSITE */
+
+/**
+  * @brief  USBD_GetEpDesc
+  *         This function return the Endpoint descriptor
+  * @param  pdev: device instance
+  * @param  pConfDesc:  pointer to Bos descriptor
+  * @param  EpAddr:  endpoint address
+  * @retval pointer to video endpoint descriptor
+  */
+void *USBD_GetEpDesc(uint8_t *pConfDesc, uint8_t EpAddr)
+{
+  USBD_DescHeaderTypeDef *pdesc = (USBD_DescHeaderTypeDef *)(void *)pConfDesc;
+  USBD_ConfigDescTypeDef *desc = (USBD_ConfigDescTypeDef *)(void *)pConfDesc;
+  USBD_EpDescTypeDef *pEpDesc = NULL;
+  uint16_t ptr;
+
+  if (desc->wTotalLength > desc->bLength)
+  {
+    ptr = desc->bLength;
+
+    while (ptr < desc->wTotalLength)
+    {
+      pdesc = USBD_GetNextDesc((uint8_t *)pdesc, &ptr);
+
+      if (pdesc->bDescriptorType == USB_DESC_TYPE_ENDPOINT)
+      {
+        pEpDesc = (USBD_EpDescTypeDef *)(void *)pdesc;
+
+        if (pEpDesc->bEndpointAddress == EpAddr)
+        {
+          break;
+        }
+        else
+        {
+          pEpDesc = NULL;
+        }
+      }
+    }
+  }
+
+  return (void *)pEpDesc;
+}
+
+/**
+  * @brief  USBD_GetNextDesc
+  *         This function return the next descriptor header
+  * @param  buf: Buffer where the descriptor is available
+  * @param  ptr: data pointer inside the descriptor
+  * @retval next header
+  */
+USBD_DescHeaderTypeDef *USBD_GetNextDesc(uint8_t *pbuf, uint16_t *ptr)
+{
+  USBD_DescHeaderTypeDef *pnext = (USBD_DescHeaderTypeDef *)(void *)pbuf;
+
+  *ptr += pnext->bLength;
+  pnext = (USBD_DescHeaderTypeDef *)(void *)(pbuf + pnext->bLength);
+
+  return (pnext);
+}
+
 /**
  * @}
  */