Release v2.11.5

Signed-off-by: Jiri Novotny <jiri.novotny3@jablotron.cz>

CONTRIBUTING.md

@@ -1,31 +1,46 @@
-## Contributing guide
+# Contributing guide
-This document serves as a checklist before contributing to this repository.
-It includes links to read up on if topics are unclear to you.
 
-This guide mainly focuses on the proper use of Git.
+This guide mainly focuses on the steps to follow to submit an issue or a pull request.
 
-### 1. Before opening an issue
+## 1. Issues
-Please check the following boxes before posting an issue:
-- [ ] `Make sure you are using the latest commit (major releases are Tagged, but corrections are available as new commits).`
-- [ ] `Make sure your issue is a question/feedback/suggestions RELATED TO the software provided in this repository.` Otherwise, it should be discussed on the [ST Community/STM32 MCUs forum](https://community.st.com/s/group/0F90X000000AXsASAW/stm32-mcus).
-- [ ] `Make sure your issue is not already reported/fixed on GitHub or discussed on a previous issue.` Please refer to this [dashboard](https://github.com/orgs/STMicroelectronics/projects/5) for the list of issues and pull-requests. Do not forget to browse into the **closed** issues.
 
-### 2. Posting the issue
+### 1.1 Before opening an issue
-When you have checked the previous boxes. You will find two templates (Bug Report or Other Issue) available in the **Issues** tab of the repository ([link](https://github.com/STMicroelectronics/stm32_mw_usb_device/issues/new/choose)).
+
+Before posting an issue, please ensure:
+* You are using the latest commit.
+* Your issue is **not** a vulnerability. Otherwise, please refer to section [3](CONTRIBUTING.md#3-vulnerabilities) below.
+* Your issue is **related to** the software provided in this repository. Otherwise, please refer to section [4](CONTRIBUTING.md#4-support-requests-and-miscellaneous) below.
+* Your issue is not already reported, fixed or discussed in a previous one. Remember to browse the **closed** issues.
+
+### 1.2 Posting the issue
+
+When you have checked the previous points, create a new report from the **Issues** tab of this repository. A couple of templates are available [here](../../issues/new/choose).
+
+## 2. Pull Requests
+
+### 2.1 Before opening a pull request
 
-### 3. Pull Requests
 STMicrolectronics is happy to receive contributions from the community, based on an initial Contributor License Agreement (CLA) procedure.
 
-* If you are an individual writing original source code and you are sure **you own the intellectual property**, then you need to sign an Individual CLA (https://cla.st.com).
+* If you are an individual writing original source code and you are sure **you own the intellectual property**, then you need to sign an **Individual** [CLA](https://cla.st.com).
-* If you work for a company that wants also to allow you to contribute with your work, your company needs to provide a Corporate CLA (https://cla.st.com) mentioning your GitHub account name.
+* If you work for a company that wants also to allow you to contribute with your work, your company needs to provide a **Corporate** [CLA](https://cla.st.com) mentioning your GitHub account name.
-* If you are not sure that a CLA (Individual or Corporate) has been signed for your GitHub account you can check here (https://cla.st.com).
+* If you are not sure that a CLA (Individual or Corporate) has been signed for your GitHub account you can check the [CLA](https://cla.st.com) dedicated page.
 
-Please note that:
+> [!IMPORTANT]
-* The Corporate CLA will always take precedence over the Individual CLA.
+> Please note that:
-* One CLA submission is sufficient, for any project proposed by STMicroelectronics.
+> * The Corporate CLA will always take precedence over the Individual CLA.
+> * One CLA submission is sufficient, for any project proposed by STMicroelectronics.
 
-#### How to proceed
+### 2.2 How to proceed
 
-* We recommend to engage first a communication thru an issue, in order to present your proposal. Just to confirm that it corresponds to STMicroelectronics domain or scope.
+* We recommend to engage first a communication thru an issue, in order to present your proposal, just to confirm that it corresponds to STMicroelectronics' domain or scope.
 * Then fork the project to your GitHub account to further develop your contribution. Please use the latest commit version.
-* Please, submit one Pull Request for one new feature or proposal. This will ease the analysis and the final merge if accepted.
+* Please, submit one pull request per new feature or proposal. This will ease the analysis and the final merge if accepted.
+
+## 3. Vulnerabilities
+
+To report a **vulnerability**, please refer to the [SECURITY.md](./SECURITY.md) file for instructions.
+
+## 4. Support requests and miscellaneous
+
+For support requests or any other topics not related to the content of this repository, you can submit a post to the **ST Community** on the appropriate topic [page](https://community.st.com/s/topiccatalog).

Class/AUDIO/Inc/usbd_audio.h

@@ -71,6 +71,7 @@ extern "C" {
 #define USB_DEVICE_CLASS_AUDIO                        0x01U
 #define AUDIO_SUBCLASS_AUDIOCONTROL                   0x01U
 #define AUDIO_SUBCLASS_AUDIOSTREAMING                 0x02U
+#define AUDIO_SUBCLASS_MIDISTREAMING                  0x03U
 #define AUDIO_PROTOCOL_UNDEFINED                      0x00U
 #define AUDIO_STREAMING_GENERAL                       0x01U
 #define AUDIO_STREAMING_FORMAT_TYPE                   0x02U

Class/AUDIO/Src/usbd_audio.c

@@ -162,6 +162,9 @@ USBD_ClassTypeDef USBD_AUDIO =
   USBD_AUDIO_GetCfgDesc,
   USBD_AUDIO_GetDeviceQualifierDesc,
 #endif /* USE_USBD_COMPOSITE  */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -368,7 +371,7 @@ static uint8_t USBD_AUDIO_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  AUDIOOutEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_ISOC);
+  AUDIOOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->dev_speed == USBD_SPEED_HIGH)
@@ -418,7 +421,7 @@ static uint8_t USBD_AUDIO_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  AUDIOOutEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_ISOC);
+  AUDIOOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Open EP OUT */
@@ -742,8 +745,19 @@ static uint8_t USBD_AUDIO_IsoINIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnu
   */
 static uint8_t USBD_AUDIO_IsoOutIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum)
 {
-  UNUSED(pdev);
+  USBD_AUDIO_HandleTypeDef *haudio;
-  UNUSED(epnum);
+
+  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
+  haudio = (USBD_AUDIO_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+
+  /* Prepare Out endpoint to receive next audio packet */
+  (void)USBD_LL_PrepareReceive(pdev, epnum,
+                               &haudio->buffer[haudio->wr_ptr],
+                               AUDIO_OUT_PACKET);
 
   return (uint8_t)USBD_OK;
 }
@@ -761,7 +775,7 @@ static uint8_t USBD_AUDIO_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  AUDIOOutEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_ISOC);
+  AUDIOOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   haudio = (USBD_AUDIO_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
@@ -783,7 +797,7 @@ static uint8_t USBD_AUDIO_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
     /* Increment the Buffer pointer or roll it back when all buffers are full */
     haudio->wr_ptr += PacketSize;
 
-    if (haudio->wr_ptr == AUDIO_TOTAL_BUF_SIZE)
+    if (haudio->wr_ptr >= AUDIO_TOTAL_BUF_SIZE)
     {
       /* All buffers are full: roll back */
       haudio->wr_ptr = 0U;

Class/CCID/Inc/usbd_ccid.h

@@ -60,10 +60,12 @@ extern "C" {
 #define CCID_CMD_FS_BINTERVAL                                 0x10U
 #endif /* CCID_CMD_FS_BINTERVAL */
 
+#ifndef CCID_CMD_PACKET_SIZE
+#define CCID_CMD_PACKET_SIZE                                  8U  /* Control Endpoint Packet size */
+#endif /* CCID_CMD_PACKET_SIZE */
 
 #define CCID_DATA_HS_MAX_PACKET_SIZE                          512U  /* Endpoint IN & OUT Packet size */
 #define CCID_DATA_FS_MAX_PACKET_SIZE                          64U  /* Endpoint IN & OUT Packet size */
-#define CCID_CMD_PACKET_SIZE                                  8U  /* Control Endpoint Packet size */
 
 #define USB_CCID_CONFIG_DESC_SIZ                              93U
 #define CCID_DATA_HS_IN_PACKET_SIZE                           CCID_DATA_HS_MAX_PACKET_SIZE
@@ -263,7 +265,7 @@ typedef struct
 } USBD_CCID_ParamTypeDef;
 
 /*
- * CCID Class specification revsion 1.1
+ * CCID Class specification revision 1.1
  * Smart Card Device Class Descriptor Table
  */
 

Class/CCID/Inc/usbd_ccid_cmd.h

@@ -55,7 +55,7 @@ extern "C" {
   an unimplemented slot, then the Slot Error register shall be set to 5 (index of bSlot field) */
 
 /*
- * CCID Class specification revsion 1.1
+ * CCID Class specification revision 1.1
  */
 
 /* Following Parameters used in PC_to_RDR_XfrBlock */

Class/CCID/Src/usbd_ccid.c

@@ -129,6 +129,9 @@ USBD_ClassTypeDef USBD_CCID =
   USBD_CCID_GetOtherSpeedCfgDesc,
   USBD_CCID_GetDeviceQualifierDescriptor,
 #endif /* USE_USBD_COMPOSITE  */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -289,9 +292,9 @@ static uint8_t USBD_CCID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CCIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  CCIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CCIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  CCIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Init the CCID parameters into a state where it can receive a new command message */
@@ -337,9 +340,9 @@ static uint8_t USBD_CCID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CCIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  CCIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CCIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  CCIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -474,8 +477,8 @@ static uint8_t USBD_CCID_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CCIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  CCIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (epnum == (CCIDInEpAdd & 0x7FU))
@@ -530,7 +533,7 @@ static uint8_t USBD_CCID_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CCIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  CCIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hccid == NULL)
@@ -816,7 +819,7 @@ uint8_t USBD_CCID_IntMessage(USBD_HandleTypeDef  *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CCIDCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Check if there is change in Smartcard Slot status */

Class/CCID/Src/usbd_ccid_cmd.c

@@ -42,10 +42,10 @@ static void CCID_UpdateCommandStatus(USBD_HandleTypeDef  *pdev, uint8_t cmd_stat
 uint8_t PC_to_RDR_IccPowerOn(USBD_HandleTypeDef *pdev)
 {
   /* Apply the ICC VCC
-  Fills the Response buffer with ICC ATR
+   * Fills the Response buffer with ICC ATR
-  This Command is returned with RDR_to_PC_DataBlock();
+   * This Command is returned with RDR_to_PC_DataBlock();
-  */
+   */
-  USBD_CCID_HandleTypeDef  *hccid = (USBD_CCID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_CCID_HandleTypeDef *hccid = (USBD_CCID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   uint8_t voltage;
   uint8_t sc_voltage = 0U;
   uint8_t index;

Class/CCID/Src/usbd_ccid_smartcard_template.c

@@ -79,7 +79,8 @@ static void SC_SendData(SC_ADPU_CommandsTypeDef *SCADPU, SC_ADPU_ResponseTypeDef
   */
 void SC_Handler(SC_State *SCState, SC_ADPU_CommandsTypeDef *SC_ADPU, SC_ADPU_ResponseTypeDef *SC_Response)
 {
-  uint32_t i, j;
+  uint32_t i;
+  uint32_t j;
 
   switch (*SCState)
   {
@@ -316,8 +317,11 @@ static void SC_AnswerReq(SC_State *SC_state, uint8_t *atr_buffer, uint8_t length
   */
 static uint8_t SC_decode_Answer2reset(uint8_t *card)
 {
-  uint32_t i, flag = 0U, protocol;
+  uint32_t i = 0U;
-  uint8_t index = 0U, level = 0U;
+  uint32_t flag = 0U;
+  uint32_t protocol;
+  uint8_t index = 0U;
+  uint8_t level = 0U;
 
   /******************************TS/T0 Decode************************************/
   index++;

Class/CDC/Inc/usbd_cdc.h

@@ -58,10 +58,13 @@ extern "C" {
 #define CDC_FS_BINTERVAL                            0x10U
 #endif /* CDC_FS_BINTERVAL */
 
+#ifndef CDC_CMD_PACKET_SIZE
+#define CDC_CMD_PACKET_SIZE                         8U  /* Control Endpoint Packet size */
+#endif /* CDC_CMD_PACKET_SIZE */
+
 /* CDC Endpoints parameters: you can fine tune these values depending on the needed baudrates and performance. */
 #define CDC_DATA_HS_MAX_PACKET_SIZE                 512U  /* Endpoint IN & OUT Packet size */
 #define CDC_DATA_FS_MAX_PACKET_SIZE                 64U  /* Endpoint IN & OUT Packet size */
-#define CDC_CMD_PACKET_SIZE                         8U  /* Control Endpoint Packet size */
 
 #define USB_CDC_CONFIG_DESC_SIZ                     67U
 #define CDC_DATA_HS_IN_PACKET_SIZE                  CDC_DATA_HS_MAX_PACKET_SIZE
@@ -154,12 +157,17 @@ extern USBD_ClassTypeDef USBD_CDC;
 uint8_t USBD_CDC_RegisterInterface(USBD_HandleTypeDef *pdev,
                                    USBD_CDC_ItfTypeDef *fops);
 
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff,
+                             uint32_t length, uint8_t ClassId);
+uint8_t USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t ClassId);
+#else
 uint8_t USBD_CDC_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff,
                              uint32_t length);
-
+uint8_t USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev);
+#endif /* USE_USBD_COMPOSITE */
 uint8_t USBD_CDC_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff);
 uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev);
-uint8_t USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev);
 /**
   * @}
   */

Class/CDC/Src/usbd_cdc.c

@@ -109,7 +109,6 @@ static uint8_t USBD_CDC_EP0_RxReady(USBD_HandleTypeDef *pdev);
 static uint8_t *USBD_CDC_GetFSCfgDesc(uint16_t *length);
 static uint8_t *USBD_CDC_GetHSCfgDesc(uint16_t *length);
 static uint8_t *USBD_CDC_GetOtherSpeedCfgDesc(uint16_t *length);
-static uint8_t *USBD_CDC_GetOtherSpeedCfgDesc(uint16_t *length);
 uint8_t *USBD_CDC_GetDeviceQualifierDescriptor(uint16_t *length);
 #endif /* USE_USBD_COMPOSITE  */
 
@@ -162,6 +161,9 @@ USBD_ClassTypeDef  USBD_CDC =
   USBD_CDC_GetOtherSpeedCfgDesc,
   USBD_CDC_GetDeviceQualifierDescriptor,
 #endif /* USE_USBD_COMPOSITE  */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -305,9 +307,9 @@ static uint8_t USBD_CDC_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CDCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  CDCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CDCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  CDCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CDCCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CDCCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->dev_speed == USBD_SPEED_HIGH)
@@ -393,9 +395,9 @@ static uint8_t USBD_CDC_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this CDC class instance */
-  CDCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  CDCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CDCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  CDCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  CDCCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CDCCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -746,17 +748,26 @@ uint8_t USBD_CDC_RegisterInterface(USBD_HandleTypeDef *pdev,
   return (uint8_t)USBD_OK;
 }
 
+
 /**
   * @brief  USBD_CDC_SetTxBuffer
   * @param  pdev: device instance
   * @param  pbuff: Tx Buffer
-  * @param  length: Tx Buffer length
+  * @param  length: length of data to be sent
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_SetTxBuffer(USBD_HandleTypeDef *pdev,
+                             uint8_t *pbuff, uint32_t length, uint8_t ClassId)
+{
+  USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CDC_SetTxBuffer(USBD_HandleTypeDef *pdev,
                              uint8_t *pbuff, uint32_t length)
 {
   USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
 
   if (hcdc == NULL)
   {
@@ -789,22 +800,32 @@ uint8_t USBD_CDC_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff)
   return (uint8_t)USBD_OK;
 }
 
+
 /**
   * @brief  USBD_CDC_TransmitPacket
   *         Transmit packet on IN endpoint
   * @param  pdev: device instance
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t ClassId)
+{
+  USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev)
 {
   USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif  /* USE_USBD_COMPOSITE */
+
   USBD_StatusTypeDef ret = USBD_BUSY;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CDCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  CDCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, ClassId);
-#endif /* USE_USBD_COMPOSITE */
+#endif  /* USE_USBD_COMPOSITE */
-  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+
+  if (hcdc == NULL)
   {
     return (uint8_t)USBD_FAIL;
   }
@@ -838,7 +859,7 @@ uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CDCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  CDCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)

Class/CDC_ECM/Inc/usbd_cdc_ecm.h

@@ -68,6 +68,10 @@ extern "C" {
 #define CDC_ECM_FS_BINTERVAL                            0x10U
 #endif /* CDC_ECM_FS_BINTERVAL */
 
+#ifndef CDC_ECM_CMD_PACKET_SIZE
+#define CDC_ECM_CMD_PACKET_SIZE                         16U  /* Control Endpoint Packet size */
+#endif /* CDC_ECM_CMD_PACKET_SIZE */
+
 #ifndef USBD_SUPPORT_USER_STRING_DESC
 #define USBD_SUPPORT_USER_STRING_DESC                   1U
 #endif /* USBD_SUPPORT_USER_STRING_DESC */
@@ -75,7 +79,6 @@ extern "C" {
 /* CDC_ECM Endpoints parameters: you can fine tune these values depending on the needed baudrates and performance. */
 #define CDC_ECM_DATA_HS_MAX_PACKET_SIZE                 512U  /* Endpoint IN & OUT Packet size */
 #define CDC_ECM_DATA_FS_MAX_PACKET_SIZE                 64U   /* Endpoint IN & OUT Packet size */
-#define CDC_ECM_CMD_PACKET_SIZE                         16U    /* Control Endpoint Packet size */
 
 #define CDC_ECM_CONFIG_DESC_SIZ                         79U
 
@@ -243,15 +246,19 @@ extern USBD_ClassTypeDef  USBD_CDC_ECM;
 uint8_t  USBD_CDC_ECM_RegisterInterface(USBD_HandleTypeDef *pdev,
                                         USBD_CDC_ECM_ItfTypeDef *fops);
 
-uint8_t  USBD_CDC_ECM_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff,
-                                  uint32_t length);
-
 uint8_t  USBD_CDC_ECM_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff);
 
 uint8_t  USBD_CDC_ECM_ReceivePacket(USBD_HandleTypeDef *pdev);
 
+#ifdef USE_USBD_COMPOSITE
+uint8_t  USBD_CDC_ECM_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t ClassId);
+uint8_t  USBD_CDC_ECM_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff,
+                                  uint32_t length, uint8_t ClassId);
+#else
 uint8_t  USBD_CDC_ECM_TransmitPacket(USBD_HandleTypeDef *pdev);
-
+uint8_t  USBD_CDC_ECM_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff,
+                                  uint32_t length);
+#endif /* USE_USBD_COMPOSITE */
 uint8_t  USBD_CDC_ECM_SendNotification(USBD_HandleTypeDef *pdev,
                                        USBD_CDC_NotifCodeTypeDef  Notif,
                                        uint16_t bVal, uint8_t *pData);

Class/CDC_ECM/Src/usbd_cdc_ecm.c

@@ -295,9 +295,9 @@ static uint8_t USBD_CDC_ECM_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  ECMCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  ECMCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   hcdc = (USBD_CDC_ECM_HandleTypeDef *)USBD_malloc(sizeof(USBD_CDC_ECM_HandleTypeDef));
@@ -364,7 +364,8 @@ static uint8_t USBD_CDC_ECM_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   hcdc->TxLength = 0U;
   hcdc->LinkStatus = 0U;
   hcdc->NotificationStatus = 0U;
-  hcdc->MaxPcktLen = (pdev->dev_speed == USBD_SPEED_HIGH) ? CDC_ECM_DATA_HS_MAX_PACKET_SIZE : CDC_ECM_DATA_FS_MAX_PACKET_SIZE;
+  hcdc->MaxPcktLen = (pdev->dev_speed == USBD_SPEED_HIGH) ? CDC_ECM_DATA_HS_MAX_PACKET_SIZE : \
+                     CDC_ECM_DATA_FS_MAX_PACKET_SIZE;
 
   if (hcdc->RxBuffer == NULL)
   {
@@ -390,9 +391,9 @@ static uint8_t USBD_CDC_ECM_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  ECMCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  ECMCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -427,8 +428,7 @@ static uint8_t USBD_CDC_ECM_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   * @param  req: usb requests
   * @retval status
   */
-static uint8_t USBD_CDC_ECM_Setup(USBD_HandleTypeDef *pdev,
+static uint8_t USBD_CDC_ECM_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
-                                  USBD_SetupReqTypedef *req)
 {
   USBD_CDC_ECM_HandleTypeDef *hcdc = (USBD_CDC_ECM_HandleTypeDef *) pdev->pClassDataCmsit[pdev->classId];
   USBD_CDC_ECM_ItfTypeDef *EcmInterface = (USBD_CDC_ECM_ItfTypeDef *)pdev->pUserData[pdev->classId];
@@ -449,8 +449,7 @@ static uint8_t USBD_CDC_ECM_Setup(USBD_HandleTypeDef *pdev,
       {
         if ((req->bmRequest & 0x80U) != 0U)
         {
-          EcmInterface->Control(req->bRequest,
+          EcmInterface->Control(req->bRequest, (uint8_t *)hcdc->data, req->wLength);
-                                (uint8_t *)hcdc->data, req->wLength);
 
           len = MIN(CDC_ECM_DATA_BUFFER_SIZE, req->wLength);
           (void)USBD_CtlSendData(pdev, (uint8_t *)hcdc->data, len);
@@ -537,7 +536,7 @@ static uint8_t USBD_CDC_ECM_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  ECMInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)
@@ -561,7 +560,8 @@ static uint8_t USBD_CDC_ECM_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
       hcdc->TxState = 0U;
       if (((USBD_CDC_ECM_ItfTypeDef *)pdev->pUserData[pdev->classId])->TransmitCplt != NULL)
       {
-        ((USBD_CDC_ECM_ItfTypeDef *)pdev->pUserData[pdev->classId])->TransmitCplt(hcdc->TxBuffer, &hcdc->TxLength, epnum);
+        ((USBD_CDC_ECM_ItfTypeDef *)pdev->pUserData[pdev->classId])->TransmitCplt(hcdc->TxBuffer,
+                                                                                  &hcdc->TxLength, epnum);
       }
     }
   }
@@ -569,8 +569,7 @@ static uint8_t USBD_CDC_ECM_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
   {
     if (hcdc->NotificationStatus != 0U)
     {
-      (void)USBD_CDC_ECM_SendNotification(pdev, CONNECTION_SPEED_CHANGE,
+      (void)USBD_CDC_ECM_SendNotification(pdev, CONNECTION_SPEED_CHANGE, 0U, (uint8_t *)ConnSpeedTab);
-                                          0U, (uint8_t *)ConnSpeedTab);
 
       hcdc->NotificationStatus = 0U;
     }
@@ -597,7 +596,7 @@ static uint8_t USBD_CDC_ECM_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)
@@ -807,7 +806,10 @@ static uint8_t *USBD_CDC_ECM_USRStringDescriptor(USBD_HandleTypeDef *pdev, uint8
   /* Check if the requested string interface is supported */
   if (index == CDC_ECM_MAC_STRING_INDEX)
   {
-    USBD_GetString((uint8_t *)((USBD_CDC_ECM_ItfTypeDef *)pdev->pUserData[pdev->classId])->pStrDesc, USBD_StrDesc, length);
+    USBD_GetString((uint8_t *)((USBD_CDC_ECM_ItfTypeDef *)pdev->pUserData[pdev->classId])->pStrDesc,
+                   USBD_StrDesc,
+                   length);
+
     return USBD_StrDesc;
   }
   /* Not supported Interface Descriptor index */
@@ -823,11 +825,18 @@ static uint8_t *USBD_CDC_ECM_USRStringDescriptor(USBD_HandleTypeDef *pdev, uint8
   * @param  pdev: device instance
   * @param  pbuff: Tx Buffer
   * @param  length: Tx Buffer length
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_ECM_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff, uint32_t length, uint8_t ClassId)
+{
+  USBD_CDC_ECM_HandleTypeDef *hcdc = (USBD_CDC_ECM_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CDC_ECM_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff, uint32_t length)
 {
   USBD_CDC_ECM_HandleTypeDef *hcdc = (USBD_CDC_ECM_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
 
   if (hcdc == NULL)
   {
@@ -861,23 +870,32 @@ uint8_t USBD_CDC_ECM_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff)
   return (uint8_t)USBD_OK;
 }
 
+
 /**
   * @brief  USBD_CDC_ECM_TransmitPacket
   *         Transmit packet on IN endpoint
   * @param  pdev: device instance
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_ECM_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t ClassId)
+{
+  USBD_CDC_ECM_HandleTypeDef *hcdc = (USBD_CDC_ECM_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CDC_ECM_TransmitPacket(USBD_HandleTypeDef *pdev)
 {
   USBD_CDC_ECM_HandleTypeDef *hcdc = (USBD_CDC_ECM_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
+
   USBD_StatusTypeDef ret = USBD_BUSY;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  ECMInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, ClassId);
 #endif /* USE_USBD_COMPOSITE */
 
-  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+  if (hcdc == NULL)
   {
     return (uint8_t)USBD_FAIL;
   }
@@ -912,7 +930,7 @@ uint8_t USBD_CDC_ECM_ReceivePacket(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  ECMOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)
@@ -951,7 +969,7 @@ uint8_t USBD_CDC_ECM_SendNotification(USBD_HandleTypeDef *pdev,
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  ECMCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  ECMCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Initialize the request fields */

Class/CDC_ECM/Src/usbd_cdc_ecm_if_template.c

@@ -85,7 +85,11 @@ static int8_t CDC_ECM_Itf_Init(void)
   }
 
   /* Set Application Buffers */
+#ifdef USE_USBD_COMPOSITE
+  (void)USBD_CDC_ECM_SetTxBuffer(&USBD_Device, UserTxBuffer, 0U, 0U);
+#else
   (void)USBD_CDC_ECM_SetTxBuffer(&USBD_Device, UserTxBuffer, 0U);
+#endif /* USE_USBD_COMPOSITE */
   (void)USBD_CDC_ECM_SetRxBuffer(&USBD_Device, UserRxBuffer);
 
   return (0);
@@ -100,7 +104,8 @@ static int8_t CDC_ECM_Itf_Init(void)
 static int8_t CDC_ECM_Itf_DeInit(void)
 {
 #ifdef USE_USBD_COMPOSITE
-  USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *)(USBD_Device.pClassDataCmsit[USBD_Device.classId]);
+  USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *) \
+                                             (USBD_Device.pClassDataCmsit[USBD_Device.classId]);
 #else
   USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *)(USBD_Device.pClassData);
 #endif /* USE_USBD_COMPOSITE */
@@ -122,7 +127,8 @@ static int8_t CDC_ECM_Itf_DeInit(void)
 static int8_t CDC_ECM_Itf_Control(uint8_t cmd, uint8_t *pbuf, uint16_t length)
 {
 #ifdef USE_USBD_COMPOSITE
-  USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *)(USBD_Device.pClassDataCmsit[USBD_Device.classId]);
+  USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *) \
+                                             (USBD_Device.pClassDataCmsit[USBD_Device.classId]);
 #else
   USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *)(USBD_Device.pClassData);
 #endif /* USE_USBD_COMPOSITE */
@@ -197,7 +203,8 @@ static int8_t CDC_ECM_Itf_Receive(uint8_t *Buf, uint32_t *Len)
 {
   /* Get the CDC_ECM handler pointer */
 #ifdef USE_USBD_COMPOSITE
-  USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *)(USBD_Device.pClassDataCmsit[USBD_Device.classId]);
+  USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *) \
+                                             (USBD_Device.pClassDataCmsit[USBD_Device.classId]);
 #else
   USBD_CDC_ECM_HandleTypeDef *hcdc_cdc_ecm = (USBD_CDC_ECM_HandleTypeDef *)(USBD_Device.pClassData);
 #endif /* USE_USBD_COMPOSITE */

Class/CDC_RNDIS/Inc/usbd_cdc_rndis.h

@@ -66,12 +66,14 @@ extern "C" {
 #define CDC_RNDIS_FS_BINTERVAL                            0x10U
 #endif /* CDC_RNDIS_FS_BINTERVAL */
 
+#ifndef CDC_RNDIS_CMD_PACKET_SIZE
+#define CDC_RNDIS_CMD_PACKET_SIZE                         16U  /* Control Endpoint Packet size */
+#endif /* CDC_RNDIS_CMD_PACKET_SIZE */
 
 /* CDC_RNDIS Endpoints parameters: you can fine tune these values
    depending on the needed baudrates and performance. */
 #define CDC_RNDIS_DATA_HS_MAX_PACKET_SIZE                 512U  /* Endpoint IN & OUT Packet size */
 #define CDC_RNDIS_DATA_FS_MAX_PACKET_SIZE                 64U   /* Endpoint IN & OUT Packet size */
-#define CDC_RNDIS_CMD_PACKET_SIZE                         16U   /* Control Endpoint Packet size */
 
 #define CDC_RNDIS_CONFIG_DESC_SIZ                         75U
 #define CDC_RNDIS_DATA_HS_IN_PACKET_SIZE                  CDC_RNDIS_DATA_HS_MAX_PACKET_SIZE
@@ -493,14 +495,18 @@ extern USBD_ClassTypeDef USBD_CDC_RNDIS;
   */
 uint8_t USBD_CDC_RNDIS_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff);
 uint8_t USBD_CDC_RNDIS_ReceivePacket(USBD_HandleTypeDef *pdev);
-uint8_t USBD_CDC_RNDIS_TransmitPacket(USBD_HandleTypeDef *pdev);
 
 uint8_t USBD_CDC_RNDIS_RegisterInterface(USBD_HandleTypeDef *pdev,
                                          USBD_CDC_RNDIS_ItfTypeDef *fops);
-
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_RNDIS_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t ClassId);
+uint8_t USBD_CDC_RNDIS_SetTxBuffer(USBD_HandleTypeDef *pdev,
+                                   uint8_t *pbuff, uint32_t length, uint8_t ClassId);
+#else
+uint8_t USBD_CDC_RNDIS_TransmitPacket(USBD_HandleTypeDef *pdev);
 uint8_t USBD_CDC_RNDIS_SetTxBuffer(USBD_HandleTypeDef *pdev,
                                    uint8_t *pbuff, uint32_t length);
-
+#endif /* USE_USBD_COMPOSITE */
 uint8_t USBD_CDC_RNDIS_SendNotification(USBD_HandleTypeDef *pdev,
                                         USBD_CDC_NotifCodeTypeDef Notif,
                                         uint16_t bVal, uint8_t *pData);

Class/CDC_RNDIS/Src/usbd_cdc_rndis.c

@@ -357,9 +357,9 @@ static uint8_t USBD_CDC_RNDIS_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  RNDISCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  RNDISCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hcdc == NULL)
@@ -427,7 +427,8 @@ static uint8_t USBD_CDC_RNDIS_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   hcdc->TxLength = 0U;
   hcdc->LinkStatus = 0U;
   hcdc->NotificationStatus = 0U;
-  hcdc->MaxPcktLen = (pdev->dev_speed == USBD_SPEED_HIGH) ? CDC_RNDIS_DATA_HS_MAX_PACKET_SIZE : CDC_RNDIS_DATA_FS_MAX_PACKET_SIZE;
+  hcdc->MaxPcktLen = (pdev->dev_speed == USBD_SPEED_HIGH) ? CDC_RNDIS_DATA_HS_MAX_PACKET_SIZE : \
+                     CDC_RNDIS_DATA_FS_MAX_PACKET_SIZE;
 
   if (hcdc->RxBuffer == NULL)
   {
@@ -454,9 +455,9 @@ static uint8_t USBD_CDC_RNDIS_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  RNDISCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  RNDISCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -637,7 +638,7 @@ static uint8_t USBD_CDC_RNDIS_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  RNDISInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)
@@ -664,7 +665,8 @@ static uint8_t USBD_CDC_RNDIS_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
       if (((USBD_CDC_RNDIS_ItfTypeDef *)pdev->pUserData[pdev->classId])->TransmitCplt != NULL)
       {
-        ((USBD_CDC_RNDIS_ItfTypeDef *)pdev->pUserData[pdev->classId])->TransmitCplt(hcdc->TxBuffer, &hcdc->TxLength, epnum);
+        ((USBD_CDC_RNDIS_ItfTypeDef *)pdev->pUserData[pdev->classId])->TransmitCplt(hcdc->TxBuffer, \
+                                                                                    &hcdc->TxLength, epnum);
       }
     }
   }
@@ -699,7 +701,7 @@ static uint8_t USBD_CDC_RNDIS_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
   uint32_t CurrPcktLen;
 
 #ifdef USE_USBD_COMPOSITE  /* Get the Endpoints addresses allocated for this class instance */
-  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)
@@ -936,16 +938,25 @@ static uint8_t *USBD_CDC_RNDIS_USRStringDescriptor(USBD_HandleTypeDef *pdev, uin
 }
 #endif /* USBD_SUPPORT_USER_STRING_DESC */
 
+
 /**
   * @brief  USBD_CDC_RNDIS_SetTxBuffer
   * @param  pdev: device instance
   * @param  pbuff: Tx Buffer
   * @param  length: Tx Buffer length
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_RNDIS_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff, uint32_t length, uint8_t ClassId)
+{
+  USBD_CDC_RNDIS_HandleTypeDef *hcdc = (USBD_CDC_RNDIS_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CDC_RNDIS_SetTxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff, uint32_t length)
 {
+
   USBD_CDC_RNDIS_HandleTypeDef *hcdc = (USBD_CDC_RNDIS_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
 
   if (hcdc == NULL)
   {
@@ -984,25 +995,32 @@ uint8_t USBD_CDC_RNDIS_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *pbuff)
   * @brief  USBD_CDC_RNDIS_TransmitPacket
   *         Transmit packet on IN endpoint
   * @param  pdev: device instance
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CDC_RNDIS_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t ClassId)
+{
+  USBD_CDC_RNDIS_HandleTypeDef *hcdc = (USBD_CDC_RNDIS_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CDC_RNDIS_TransmitPacket(USBD_HandleTypeDef *pdev)
 {
-  USBD_CDC_RNDIS_HandleTypeDef *hcdc;
+  USBD_CDC_RNDIS_HandleTypeDef *hcdc = (USBD_CDC_RNDIS_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
+
   USBD_CDC_RNDIS_PacketMsgTypeDef *PacketMsg;
   USBD_StatusTypeDef ret = USBD_BUSY;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  RNDISInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, ClassId);
 #endif /* USE_USBD_COMPOSITE */
 
-  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+  if (hcdc == NULL)
   {
     return (uint8_t)USBD_FAIL;
   }
 
-  hcdc = (USBD_CDC_RNDIS_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   PacketMsg = (USBD_CDC_RNDIS_PacketMsgTypeDef *)(void *)hcdc->TxBuffer;
 
   if (hcdc->TxState == 0U)
@@ -1048,7 +1066,7 @@ uint8_t USBD_CDC_RNDIS_ReceivePacket(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  RNDISOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->pClassDataCmsit[pdev->classId] == NULL)
@@ -1094,7 +1112,7 @@ uint8_t USBD_CDC_RNDIS_SendNotification(USBD_HandleTypeDef *pdev,
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  RNDISCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  RNDISCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Initialize the request fields */
@@ -1434,7 +1452,7 @@ static uint8_t USBD_CDC_RNDIS_ProcessQueryMsg(USBD_HandleTypeDef *pdev,
 
     case OID_GEN_CURRENT_PACKET_FILTER:
       QueryResponse->InfoBufLength = sizeof(uint32_t);
-      QueryResponse->InfoBuf[0] = 0xFFFFFFU; /* USBD_CDC_RNDIS_DEVICE.packetFilter; */
+      QueryResponse->InfoBuf[0] = 0xFFFFFFU; /* USBD_CDC_RNDIS_DEVICE.packetFilter */
       QueryResponse->Status = CDC_RNDIS_STATUS_SUCCESS;
       break;
 
@@ -1598,7 +1616,8 @@ static uint8_t USBD_CDC_RNDIS_ProcessResetMsg(USBD_HandleTypeDef *pdev,
 static uint8_t USBD_CDC_RNDIS_ProcessPacketMsg(USBD_HandleTypeDef *pdev,
                                                USBD_CDC_RNDIS_PacketMsgTypeDef *Msg)
 {
-  uint32_t tmp1, tmp2;
+  uint32_t tmp1;
+  uint32_t tmp2;
 
   /* Get the CDC_RNDIS handle pointer */
   USBD_CDC_RNDIS_HandleTypeDef *hcdc = (USBD_CDC_RNDIS_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];

Class/CDC_RNDIS/Src/usbd_cdc_rndis_if_template.c

@@ -95,7 +95,11 @@ static int8_t CDC_RNDIS_Itf_Init(void)
   }
 
   /* Set Application Buffers */
+#ifdef USE_USBD_COMPOSITE
+  (void)USBD_CDC_RNDIS_SetTxBuffer(&USBD_Device, UserTxBuffer, 0U, 0U);
+#else
   (void)USBD_CDC_RNDIS_SetTxBuffer(&USBD_Device, UserTxBuffer, 0U);
+#endif /* USE_USBD_COMPOSITE */
   (void)USBD_CDC_RNDIS_SetRxBuffer(&USBD_Device, UserRxBuffer);
 
   return (0);
@@ -110,7 +114,8 @@ static int8_t CDC_RNDIS_Itf_Init(void)
 static int8_t CDC_RNDIS_Itf_DeInit(void)
 {
 #ifdef USE_USBD_COMPOSITE
-  USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *)(USBD_Device.pClassDataCmsit[USBD_Device.classId]);
+  USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *) \
+                                                 (USBD_Device.pClassDataCmsit[USBD_Device.classId]);
 #else
   USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *)(USBD_Device.pClassData);
 #endif /* USE_USBD_COMPOSITE */
@@ -136,7 +141,8 @@ static int8_t CDC_RNDIS_Itf_DeInit(void)
 static int8_t CDC_RNDIS_Itf_Control(uint8_t cmd, uint8_t *pbuf, uint16_t length)
 {
 #ifdef USE_USBD_COMPOSITE
-  USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *)(USBD_Device.pClassDataCmsit[USBD_Device.classId]);
+  USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *) \
+                                                 (USBD_Device.pClassDataCmsit[USBD_Device.classId]);
 #else
   USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *)(USBD_Device.pClassData);
 #endif /* USE_USBD_COMPOSITE */
@@ -183,7 +189,8 @@ static int8_t CDC_RNDIS_Itf_Receive(uint8_t *Buf, uint32_t *Len)
 {
   /* Get the CDC_RNDIS handler pointer */
 #ifdef USE_USBD_COMPOSITE
-  USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *)(USBD_Device.pClassDataCmsit[USBD_Device.classId]);
+  USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *) \
+                                                 (USBD_Device.pClassDataCmsit[USBD_Device.classId]);
 #else
   USBD_CDC_RNDIS_HandleTypeDef *hcdc_cdc_rndis = (USBD_CDC_RNDIS_HandleTypeDef *)(USBD_Device.pClassData);
 #endif /* USE_USBD_COMPOSITE */

Class/CompositeBuilder/Inc/usbd_composite_builder.h

@@ -172,10 +172,10 @@ typedef struct
 #if (USBD_CMPSIT_ACTIVATE_CDC == 1) || (USBD_CMPSIT_ACTIVATE_RNDIS == 1) || (USBD_CMPSIT_ACTIVATE_CDC_ECM == 1)
 typedef struct
 {
-/*
+  /*
- * CDC Class specification revision 1.2
+   * CDC Class specification revision 1.2
- * Table 15: Class-Specific Descriptor Header Format
+   * Table 15: Class-Specific Descriptor Header Format
- */
+   */
   /* Header Functional Descriptor */
   uint8_t           bLength;
   uint8_t           bDescriptorType;
@@ -204,10 +204,10 @@ typedef struct
 
 typedef struct
 {
-/*
+  /*
- * CDC Class specification revision 1.2
+   * CDC Class specification revision 1.2
- * Table 16: Union Interface Functional Descriptor
+   * Table 16: Union Interface Functional Descriptor
- */
+   */
   /* Union Functional Descriptor */
   uint8_t           bLength;
   uint8_t           bDescriptorType;
@@ -249,7 +249,7 @@ uint8_t USBD_CMPST_ClearConfDesc(USBD_HandleTypeDef *pdev);
     pEpDesc->bDescriptorType    = USB_DESC_TYPE_ENDPOINT; \
     pEpDesc->bEndpointAddress   = (epadd); \
     pEpDesc->bmAttributes       = (eptype); \
-    pEpDesc->wMaxPacketSize     = (epsize); \
+    pEpDesc->wMaxPacketSize     = (uint16_t)(epsize); \
     if(speed == (uint8_t)USBD_SPEED_HIGH) \
     { \
       pEpDesc->bInterval        = HSinterval; \

Class/CompositeBuilder/Src/usbd_composite_builder.c

@@ -511,11 +511,11 @@ uint8_t  USBD_CMPSIT_AddToConfDesc(USBD_HandleTypeDef *pdev)
 
       /* Set IN endpoint slot */
       iEp = pdev->tclasslist[pdev->classId].EpAdd[0];
-      USBD_CMPSIT_AssignEp(pdev, iEp, USBD_EP_TYPE_INTR, pdev->tclasslist[pdev->classId].CurrPcktSze);
+      USBD_CMPSIT_AssignEp(pdev, iEp, USBD_EP_TYPE_INTR,CUSTOM_HID_EPIN_SIZE);
 
       /* Set OUT endpoint slot */
       iEp = pdev->tclasslist[pdev->classId].EpAdd[1];
-      USBD_CMPSIT_AssignEp(pdev, iEp, USBD_EP_TYPE_INTR, pdev->tclasslist[pdev->classId].CurrPcktSze);
+      USBD_CMPSIT_AssignEp(pdev, iEp, USBD_EP_TYPE_INTR, CUSTOM_HID_EPOUT_SIZE);
 
       /* Configure and Append the Descriptor */
       USBD_CMPSIT_CUSTOMHIDDesc(pdev, (uint32_t)pCmpstFSConfDesc, &CurrFSConfDescSz, (uint8_t)USBD_SPEED_FULL);
@@ -844,7 +844,7 @@ static void  USBD_CMPSIT_HIDMouseDesc(USBD_HandleTypeDef *pdev, uint32_t pConf,
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength  = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength  = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_HID == 1 */
 
@@ -881,7 +881,7 @@ static void  USBD_CMPSIT_MSCDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_MSC == 1 */
 
@@ -979,7 +979,7 @@ static void  USBD_CMPSIT_CDCDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 2U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_CDC == 1 */
 
@@ -1018,7 +1018,7 @@ static void  USBD_CMPSIT_DFUDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 
   UNUSED(idx);
 }
@@ -1113,7 +1113,7 @@ static void  USBD_CMPSIT_CDC_ECMDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, _
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 2U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_CDC_ECM */
 
@@ -1249,7 +1249,7 @@ static void  USBD_CMPSIT_AUDIODesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __I
   pSpEpDesc->bDescriptorType = USB_DESC_TYPE_ENDPOINT;
   pSpEpDesc->bEndpointAddress = pdev->tclasslist[pdev->classId].Eps[0].add;
   pSpEpDesc->bmAttributes = USBD_EP_TYPE_ISOC;
-  pSpEpDesc->wMaxPacketSize = USBD_AUDIO_GetEpPcktSze(pdev, 0U, 0U);
+  pSpEpDesc->wMaxPacketSize = (uint16_t)USBD_AUDIO_GetEpPcktSze(pdev, 0U, 0U);
   pSpEpDesc->bInterval = 0x01U;
   pSpEpDesc->bRefresh = 0x00U;
   pSpEpDesc->bSynchAddress = 0x00U;
@@ -1267,7 +1267,7 @@ static void  USBD_CMPSIT_AUDIODesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __I
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 2U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_AUDIO */
 
@@ -1363,7 +1363,7 @@ static void  USBD_CMPSIT_RNDISDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __I
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 2U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_RNDIS == 1 */
 
@@ -1393,7 +1393,12 @@ static void  USBD_CMPSIT_CUSTOMHIDDesc(USBD_HandleTypeDef *pdev, uint32_t pConf,
   pDesc->bCountryCode = 0x00U;
   pDesc->bNumDescriptors = 0x01U;
   pDesc->bDescriptorType = 0x22U;
+#ifdef USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED
+  pDesc->wItemLength = ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->wReportDescLen;
+#else
   pDesc->wItemLength = USBD_CUSTOM_HID_REPORT_DESC_SIZE;
+#endif /* USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED */
+
   *Sze += (uint32_t)sizeof(USBD_DescTypeDef);
 
   /* Descriptor of Custom HID endpoints */
@@ -1403,11 +1408,11 @@ static void  USBD_CMPSIT_CUSTOMHIDDesc(USBD_HandleTypeDef *pdev, uint32_t pConf,
 
   /* Append Endpoint descriptor to Configuration descriptor */
   __USBD_CMPSIT_SET_EP(pdev->tclasslist[pdev->classId].Eps[1].add, \
-                       USBD_EP_TYPE_INTR, CUSTOM_HID_EPIN_SIZE, CUSTOM_HID_HS_BINTERVAL, CUSTOM_HID_FS_BINTERVAL);
+                       USBD_EP_TYPE_INTR, CUSTOM_HID_EPOUT_SIZE, CUSTOM_HID_HS_BINTERVAL, CUSTOM_HID_FS_BINTERVAL);
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_CUSTOMHID == 1U */
 
@@ -1585,8 +1590,7 @@ static void  USBD_CMPSIT_VIDEODesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __I
 
   /* USB Standard VS Interface  Descriptor - data transfer mode */
   /* Interface 1, Alternate Setting 1*/
-  __USBD_CMPSIT_SET_IF(1U, 1U, 1U, UVC_CC_VIDEO, \
+  __USBD_CMPSIT_SET_IF(1U, 1U, 1U, UVC_CC_VIDEO, SC_VIDEOSTREAMING, PC_PROTOCOL_UNDEFINED, 0U);
-                       SC_VIDEOSTREAMING, PC_PROTOCOL_UNDEFINED, 0U);
 
   /* Standard VS (Video Streaming) data Endpoint */
   pSVCDEP = ((USBD_StandardVCDataEPDescTypeDef *)(pConf + *Sze));
@@ -1609,7 +1613,7 @@ static void  USBD_CMPSIT_VIDEODesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __I
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 2U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_VIDEO == 1 */
 
@@ -1645,7 +1649,7 @@ static void  USBD_CMPSIT_PRNTDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_PRINTER == 1 */
 
@@ -1715,7 +1719,7 @@ static void  USBD_CMPSIT_CCIDDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_CCID == 1 */
 
@@ -1735,8 +1739,8 @@ static void  USBD_CMPSIT_MTPDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Append MTP Interface descriptor */
   __USBD_CMPSIT_SET_IF((pdev->tclasslist[pdev->classId].Ifs[0]), (0U), \
-                       (uint8_t)(pdev->tclasslist[pdev->classId].NumEps), USB_MTP_INTRERFACE_CLASS, USB_MTP_INTRERFACE_SUB_CLASS,
+                       (uint8_t)(pdev->tclasslist[pdev->classId].NumEps), USB_MTP_INTRERFACE_CLASS, \
-                       USB_MTP_INTRERFACE_PROTOCOL, (0U));
+                       USB_MTP_INTRERFACE_SUB_CLASS, USB_MTP_INTRERFACE_PROTOCOL, (0U));
 
   if (speed == (uint8_t)USBD_SPEED_HIGH)
   {
@@ -1757,7 +1761,7 @@ static void  USBD_CMPSIT_MTPDesc(USBD_HandleTypeDef *pdev, uint32_t pConf, __IO
 
   /* Update Config Descriptor and IAD descriptor */
   ((USBD_ConfigDescTypeDef *)pConf)->bNumInterfaces += 1U;
-  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = *Sze;
+  ((USBD_ConfigDescTypeDef *)pConf)->wTotalLength = (uint16_t)(*Sze);
 }
 #endif /* USBD_CMPSIT_ACTIVATE_MTP == 1 */
 
@@ -1778,7 +1782,8 @@ uint32_t  USBD_CMPSIT_SetClassID(USBD_HandleTypeDef *pdev, USBD_CompositeClassTy
   for (idx = 0U; idx < pdev->NumClasses; idx++)
   {
     /* Check if the class correspond to the requested type and if it is active */
-    if (((USBD_CompositeClassTypeDef)(pdev->tclasslist[idx].ClassType) == Class) && ((pdev->tclasslist[idx].Active) == 1U))
+    if (((USBD_CompositeClassTypeDef)(pdev->tclasslist[idx].ClassType) == Class) &&
+        ((pdev->tclasslist[idx].Active) == 1U))
     {
       if (inst == Instance)
       {
@@ -1817,7 +1822,8 @@ uint32_t  USBD_CMPSIT_GetClassID(USBD_HandleTypeDef *pdev, USBD_CompositeClassTy
   for (idx = 0U; idx < pdev->NumClasses; idx++)
   {
     /* Check if the class correspond to the requested type and if it is active */
-    if (((USBD_CompositeClassTypeDef)(pdev->tclasslist[idx].ClassType) == Class) && ((pdev->tclasslist[idx].Active) == 1U))
+    if (((USBD_CompositeClassTypeDef)(pdev->tclasslist[idx].ClassType) == Class) &&
+        ((pdev->tclasslist[idx].Active) == 1U))
     {
       if (inst == Instance)
       {

Class/CustomHID/Inc/usbd_customhid.h

@@ -103,10 +103,22 @@ typedef enum
 typedef struct _USBD_CUSTOM_HID_Itf
 {
   uint8_t *pReport;
+#ifdef USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED
+  uint16_t wReportDescLen;
+#endif /* USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED */
   int8_t (* Init)(void);
   int8_t (* DeInit)(void);
+#ifdef USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED
+  int8_t (* OutEvent)(uint8_t *report_buffer);
+#else
   int8_t (* OutEvent)(uint8_t event_idx, uint8_t state);
-
+#endif /* USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED */
+#ifdef USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED
+  int8_t (* CtrlReqComplete)(uint8_t request, uint16_t wLength);
+#endif /* USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+#ifdef USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED
+  uint8_t *(* GetReport)(uint16_t *ReportLength);
+#endif /* USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */
 } USBD_CUSTOM_HID_ItfTypeDef;
 
 typedef struct
@@ -162,9 +174,13 @@ extern USBD_ClassTypeDef USBD_CUSTOM_HID;
 /** @defgroup USB_CORE_Exported_Functions
   * @{
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CUSTOM_HID_SendReport(USBD_HandleTypeDef *pdev,
+                                   uint8_t *report, uint16_t len, uint8_t ClassId);
+#else
 uint8_t USBD_CUSTOM_HID_SendReport(USBD_HandleTypeDef *pdev,
                                    uint8_t *report, uint16_t len);
-
+#endif /* USE_USBD_COMPOSITE */
 uint8_t USBD_CUSTOM_HID_ReceivePacket(USBD_HandleTypeDef *pdev);
 
 uint8_t USBD_CUSTOM_HID_RegisterInterface(USBD_HandleTypeDef *pdev,

Class/CustomHID/Src/usbd_customhid.c

@@ -128,6 +128,9 @@ USBD_ClassTypeDef  USBD_CUSTOM_HID =
   USBD_CUSTOM_HID_GetOtherSpeedCfgDesc,
   USBD_CUSTOM_HID_GetDeviceQualifierDesc,
 #endif /* USE_USBD_COMPOSITE  */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -136,8 +139,8 @@ __ALIGN_BEGIN static uint8_t USBD_CUSTOM_HID_CfgDesc[USB_CUSTOM_HID_CONFIG_DESC_
 {
   0x09,                                               /* bLength: Configuration Descriptor size */
   USB_DESC_TYPE_CONFIGURATION,                        /* bDescriptorType: Configuration */
-  USB_CUSTOM_HID_CONFIG_DESC_SIZ,                     /* wTotalLength: Bytes returned */
+  LOBYTE(USB_CUSTOM_HID_CONFIG_DESC_SIZ),             /* wTotalLength: Bytes returned */
-  0x00,
+  HIBYTE(USB_CUSTOM_HID_CONFIG_DESC_SIZ),
   0x01,                                               /* bNumInterfaces: 1 interface */
   0x01,                                               /* bConfigurationValue: Configuration value */
   0x00,                                               /* iConfiguration: Index of string descriptor
@@ -170,8 +173,8 @@ __ALIGN_BEGIN static uint8_t USBD_CUSTOM_HID_CfgDesc[USB_CUSTOM_HID_CONFIG_DESC_
   0x01,                                               /* bNumDescriptors: Number of CUSTOM_HID class descriptors
                                                          to follow */
   0x22,                                               /* bDescriptorType */
-  USBD_CUSTOM_HID_REPORT_DESC_SIZE,                   /* wItemLength: Total length of Report descriptor */
+  LOBYTE(USBD_CUSTOM_HID_REPORT_DESC_SIZE),           /* wItemLength: Total length of Report descriptor */
-  0x00,
+  HIBYTE(USBD_CUSTOM_HID_REPORT_DESC_SIZE),
   /******************** Descriptor of Custom HID endpoints ********************/
   /* 27 */
   0x07,                                               /* bLength: Endpoint Descriptor size */
@@ -179,8 +182,8 @@ __ALIGN_BEGIN static uint8_t USBD_CUSTOM_HID_CfgDesc[USB_CUSTOM_HID_CONFIG_DESC_
 
   CUSTOM_HID_EPIN_ADDR,                               /* bEndpointAddress: Endpoint Address (IN) */
   0x03,                                               /* bmAttributes: Interrupt endpoint */
-  CUSTOM_HID_EPIN_SIZE,                               /* wMaxPacketSize: 2 Bytes max */
+  LOBYTE(CUSTOM_HID_EPIN_SIZE),                       /* wMaxPacketSize: 2 Bytes max */
-  0x00,
+  HIBYTE(CUSTOM_HID_EPIN_SIZE),
   CUSTOM_HID_FS_BINTERVAL,                            /* bInterval: Polling Interval */
   /* 34 */
 
@@ -188,8 +191,8 @@ __ALIGN_BEGIN static uint8_t USBD_CUSTOM_HID_CfgDesc[USB_CUSTOM_HID_CONFIG_DESC_
   USB_DESC_TYPE_ENDPOINT,                             /* bDescriptorType: */
   CUSTOM_HID_EPOUT_ADDR,                              /* bEndpointAddress: Endpoint Address (OUT) */
   0x03,                                               /* bmAttributes: Interrupt endpoint */
-  CUSTOM_HID_EPOUT_SIZE,                              /* wMaxPacketSize: 2 Bytes max  */
+  LOBYTE(CUSTOM_HID_EPOUT_SIZE),                      /* wMaxPacketSize: 2 Bytes max  */
-  0x00,
+  HIBYTE(CUSTOM_HID_EPOUT_SIZE),
   CUSTOM_HID_FS_BINTERVAL,                            /* bInterval: Polling Interval */
   /* 41 */
 };
@@ -207,8 +210,8 @@ __ALIGN_BEGIN static uint8_t USBD_CUSTOM_HID_Desc[USB_CUSTOM_HID_DESC_SIZ] __ALI
   0x01,                                               /* bNumDescriptors: Number of CUSTOM_HID class descriptors
                                                          to follow */
   0x22,                                               /* bDescriptorType */
-  USBD_CUSTOM_HID_REPORT_DESC_SIZE,                   /* wItemLength: Total length of Report descriptor */
+  LOBYTE(USBD_CUSTOM_HID_REPORT_DESC_SIZE),                   /* wItemLength: Total length of Report descriptor */
-  0x00,
+  HIBYTE(USBD_CUSTOM_HID_REPORT_DESC_SIZE),
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -263,8 +266,8 @@ static uint8_t USBD_CUSTOM_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CUSTOMHIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CUSTOMHIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
-  CUSTOMHIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_INTR);
+  CUSTOMHIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->dev_speed == USBD_SPEED_HIGH)
@@ -284,6 +287,11 @@ static uint8_t USBD_CUSTOM_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
   pdev->ep_in[CUSTOMHIDInEpAdd & 0xFU].is_used = 1U;
 
+  if (USBD_CUSTOMHID_OUTREPORT_BUF_SIZE < CUSTOM_HID_EPOUT_SIZE)
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
   /* Open EP OUT */
   (void)USBD_LL_OpenEP(pdev, CUSTOMHIDOutEpAdd, USBD_EP_TYPE_INTR,
                        CUSTOM_HID_EPOUT_SIZE);
@@ -294,9 +302,11 @@ static uint8_t USBD_CUSTOM_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
   ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->Init();
 
+#ifndef USBD_CUSTOMHID_OUT_PREPARE_RECEIVE_DISABLED
   /* Prepare Out endpoint to receive 1st packet */
   (void)USBD_LL_PrepareReceive(pdev, CUSTOMHIDOutEpAdd, hhid->Report_buf,
                                USBD_CUSTOMHID_OUTREPORT_BUF_SIZE);
+#endif /* USBD_CUSTOMHID_OUT_PREPARE_RECEIVE_DISABLED */
 
   return (uint8_t)USBD_OK;
 }
@@ -314,8 +324,8 @@ static uint8_t USBD_CUSTOM_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  CUSTOMHIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CUSTOMHIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
-  CUSTOMHIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_INTR);
+  CUSTOMHIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close CUSTOM_HID EP IN */
@@ -352,6 +362,9 @@ static uint8_t USBD_CUSTOM_HID_Setup(USBD_HandleTypeDef *pdev,
 {
   USBD_CUSTOM_HID_HandleTypeDef *hhid = (USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   uint16_t len = 0U;
+#ifdef USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED
+  uint16_t ReportLength = 0U;
+#endif /* USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */
   uint8_t  *pbuf = NULL;
   uint16_t status_info = 0U;
   USBD_StatusTypeDef ret = USBD_OK;
@@ -383,10 +396,67 @@ static uint8_t USBD_CUSTOM_HID_Setup(USBD_HandleTypeDef *pdev,
           break;
 
         case CUSTOM_HID_REQ_SET_REPORT:
+#ifdef USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED
+          if (((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->CtrlReqComplete != NULL)
+          {
+            /* Let the application decide when to enable EP0 to receive the next report */
+            ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->CtrlReqComplete(req->bRequest,
+                                                                                            req->wLength);
+          }
+#endif /* USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+#ifndef USBD_CUSTOMHID_EP0_OUT_PREPARE_RECEIVE_DISABLED
+
+          if (req->wLength > USBD_CUSTOMHID_OUTREPORT_BUF_SIZE)
+          {
+            /* Stall EP0 */
+            USBD_CtlError(pdev, req);
+            return USBD_FAIL;
+          }
+
           hhid->IsReportAvailable = 1U;
-          (void)USBD_CtlPrepareRx(pdev, hhid->Report_buf,
+
-                                  MIN(req->wLength, USBD_CUSTOMHID_OUTREPORT_BUF_SIZE));
+          (void)USBD_CtlPrepareRx(pdev, hhid->Report_buf, req->wLength);
+#endif /* USBD_CUSTOMHID_EP0_OUT_PREPARE_RECEIVE_DISABLED */
           break;
+#ifdef USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED
+        case CUSTOM_HID_REQ_GET_REPORT:
+          if (((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->GetReport != NULL)
+          {
+            ReportLength = req->wLength;
+
+            /* Get report data buffer */
+            pbuf = ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->GetReport(&ReportLength);
+          }
+
+          if ((pbuf != NULL) && (ReportLength != 0U))
+          {
+            len = MIN(ReportLength, req->wLength);
+
+            /* Send the report data over EP0 */
+            (void)USBD_CtlSendData(pdev, pbuf, len);
+          }
+          else
+          {
+#ifdef USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED
+            if (((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->CtrlReqComplete != NULL)
+            {
+              /* Let the application decide what to do, keep EP0 data phase in NAK state and
+                 use USBD_CtlSendData() when data become available or stall the EP0 data phase */
+              ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->CtrlReqComplete(req->bRequest,
+                                                                                              req->wLength);
+            }
+            else
+            {
+              /* Stall EP0 if no data available */
+              USBD_CtlError(pdev, req);
+            }
+#else
+            /* Stall EP0 if no data available */
+            USBD_CtlError(pdev, req);
+#endif /* USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+          }
+          break;
+#endif /* USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */
 
         default:
           USBD_CtlError(pdev, req);
@@ -425,7 +495,15 @@ static uint8_t USBD_CUSTOM_HID_Setup(USBD_HandleTypeDef *pdev,
             }
           }
 
-          (void)USBD_CtlSendData(pdev, pbuf, len);
+          if (pbuf != NULL)
+          {
+            (void)USBD_CtlSendData(pdev, pbuf, len);
+          }
+          else
+          {
+            USBD_CtlError(pdev, req);
+            ret = USBD_FAIL;
+          }
           break;
 
         case USB_REQ_GET_INTERFACE:
@@ -475,25 +553,31 @@ static uint8_t USBD_CUSTOM_HID_Setup(USBD_HandleTypeDef *pdev,
   *         Send CUSTOM_HID Report
   * @param  pdev: device instance
   * @param  buff: pointer to report
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_CUSTOM_HID_SendReport(USBD_HandleTypeDef *pdev,
+                                   uint8_t *report, uint16_t len, uint8_t ClassId)
+{
+  USBD_CUSTOM_HID_HandleTypeDef *hhid = (USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_CUSTOM_HID_SendReport(USBD_HandleTypeDef *pdev,
                                    uint8_t *report, uint16_t len)
 {
-  USBD_CUSTOM_HID_HandleTypeDef *hhid;
+  USBD_CUSTOM_HID_HandleTypeDef *hhid = (USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
 
-  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+  if (hhid == NULL)
   {
     return (uint8_t)USBD_FAIL;
   }
 
 #ifdef USE_USBD_COMPOSITE
   /* Get Endpoint IN address allocated for this class instance */
-  CUSTOMHIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  CUSTOMHIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, ClassId);
 #endif /* USE_USBD_COMPOSITE */
 
-  hhid = (USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
-
   if (pdev->dev_state == USBD_STATE_CONFIGURED)
   {
     if (hhid->state == CUSTOM_HID_IDLE)
@@ -633,8 +717,13 @@ static uint8_t USBD_CUSTOM_HID_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
   /* USB data will be immediately processed, this allow next USB traffic being
   NAKed till the end of the application processing */
+
+#ifdef USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED
+  ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->OutEvent(hhid->Report_buf);
+#else
   ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->OutEvent(hhid->Report_buf[0],
                                                                            hhid->Report_buf[1]);
+#endif /* USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED */
 
   return (uint8_t)USBD_OK;
 }
@@ -657,7 +746,7 @@ uint8_t USBD_CUSTOM_HID_ReceivePacket(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get OUT Endpoint address allocated for this class instance */
-  CUSTOMHIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_INTR);
+  CUSTOMHIDOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   hhid = (USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
@@ -687,8 +776,12 @@ static uint8_t USBD_CUSTOM_HID_EP0_RxReady(USBD_HandleTypeDef *pdev)
 
   if (hhid->IsReportAvailable == 1U)
   {
+#ifdef USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED
+    ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->OutEvent(hhid->Report_buf);
+#else
     ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData[pdev->classId])->OutEvent(hhid->Report_buf[0],
                                                                              hhid->Report_buf[1]);
+#endif /* USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED */
     hhid->IsReportAvailable = 0U;
   }
 

Class/CustomHID/Src/usbd_customhid_if_template.c

@@ -32,7 +32,19 @@ EndBSPDependencies */
 
 static int8_t TEMPLATE_CUSTOM_HID_Init(void);
 static int8_t TEMPLATE_CUSTOM_HID_DeInit(void);
+#ifdef USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED
+static int8_t TEMPLATE_CUSTOM_HID_OutEvent(uint8_t *report_buffer);
+#else
 static int8_t TEMPLATE_CUSTOM_HID_OutEvent(uint8_t event_idx, uint8_t state);
+#endif /* USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED */
+
+#ifdef USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED
+static int8_t TEMPLATE_CUSTOM_HID_CtrlReqComplete(uint8_t request, uint16_t wLength);
+#endif /* USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+
+#ifdef USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED
+static uint8_t *TEMPLATE_CUSTOM_HID_GetReport(uint16_t *ReportLength);
+#endif /* USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */
 /* Private variables ---------------------------------------------------------*/
 extern USBD_HandleTypeDef USBD_Device;
 
@@ -41,9 +53,18 @@ __ALIGN_BEGIN static uint8_t TEMPLATE_CUSTOM_HID_ReportDesc[USBD_CUSTOM_HID_REPO
 USBD_CUSTOM_HID_ItfTypeDef USBD_CustomHID_template_fops =
 {
   TEMPLATE_CUSTOM_HID_ReportDesc,
+#ifdef USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED
+  USBD_CUSTOM_HID_REPORT_DESC_SIZE,
+#endif /* USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED */
   TEMPLATE_CUSTOM_HID_Init,
   TEMPLATE_CUSTOM_HID_DeInit,
   TEMPLATE_CUSTOM_HID_OutEvent,
+#ifdef USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED
+  TEMPLATE_CUSTOM_HID_CtrlReqComplete,
+#endif /* USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+#ifdef USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED
+  TEMPLATE_CUSTOM_HID_GetReport,
+#endif /* USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */
 };
 
 /* Private functions ---------------------------------------------------------*/
@@ -81,10 +102,17 @@ static int8_t TEMPLATE_CUSTOM_HID_DeInit(void)
   * @param  state: event state
   * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
   */
+
+#ifdef USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED
+static int8_t TEMPLATE_CUSTOM_HID_OutEvent(uint8_t *report_buffer)
+{
+  UNUSED(report_buffer);
+#else
 static int8_t TEMPLATE_CUSTOM_HID_OutEvent(uint8_t event_idx, uint8_t state)
 {
   UNUSED(event_idx);
   UNUSED(state);
+#endif /* USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED */
 
   /* Start next USB packet transfer once data processing is completed */
   if (USBD_CUSTOM_HID_ReceivePacket(&USBD_Device) != (uint8_t)USBD_OK)
@@ -95,3 +123,50 @@ static int8_t TEMPLATE_CUSTOM_HID_OutEvent(uint8_t event_idx, uint8_t state)
   return (0);
 }
 
+#ifdef USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED
+/**
+  * @brief  TEMPLATE_CUSTOM_HID_CtrlReqComplete
+  *         Manage the CUSTOM HID control request complete
+  * @param  request: control request
+  * @param  wLength: request wLength
+  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static int8_t TEMPLATE_CUSTOM_HID_CtrlReqComplete(uint8_t request, uint16_t wLength)
+{
+  UNUSED(wLength);
+
+  switch (request)
+  {
+    case CUSTOM_HID_REQ_SET_REPORT:
+
+      break;
+
+    case CUSTOM_HID_REQ_GET_REPORT:
+
+      break;
+
+    default:
+      break;
+  }
+
+  return (0);
+}
+#endif /* USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+
+
+#ifdef USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED
+/**
+  * @brief  TEMPLATE_CUSTOM_HID_GetReport
+  *         Manage the CUSTOM HID control Get Report request
+  * @param  event_idx: event index
+  * @param  state: event state
+  * @retval return pointer to HID report
+  */
+static uint8_t *TEMPLATE_CUSTOM_HID_GetReport(uint16_t *ReportLength)
+{
+  UNUSED(ReportLength);
+  uint8_t *pbuff = NULL;
+
+  return (pbuff);
+}
+#endif /* USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */

Class/DFU/Inc/usbd_dfu.h

@@ -65,6 +65,8 @@ extern "C" {
 
 #define DFU_DESCRIPTOR_TYPE            0x21U
 
+#define DFU_VENDOR_CMD_MAX             32U
+
 
 /**************************************************/
 /* DFU Requests  DFU states                       */
@@ -126,6 +128,11 @@ extern "C" {
 #define DFU_MANIFEST_MASK              (1U << 2)
 #define DFU_STATUS_DEPTH               6U
 
+#define IS_DFU_DOWNLOAD                0x0DFDFU
+#define IS_DFU_UPLOAD                  0x1DFDFU
+#define IS_DFU_SETADDRESSPOINTER       0x2DFDFU
+#define IS_DFU_PHY_ADDRESS             0x3DFDFU
+
 typedef enum
 {
   DFU_DETACH = 0U,
@@ -176,6 +183,7 @@ typedef struct
   uint32_t wblock_num;
   uint32_t wlength;
   uint32_t data_ptr;
+  uint32_t app_addr_ptr;
   uint32_t alt_setting;
 
   uint8_t dev_status[DFU_STATUS_DEPTH];
@@ -193,6 +201,17 @@ typedef struct
   uint16_t (* Write)(uint8_t *src, uint8_t *dest, uint32_t Len);
   uint8_t *(* Read)(uint8_t *src, uint8_t *dest, uint32_t Len);
   uint16_t (* GetStatus)(uint32_t Add, uint8_t cmd, uint8_t *buff);
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+  uint16_t (* GetVendorCMD)(uint8_t *cmd, uint8_t *cmdlength);
+  uint16_t (* VendorDownloadCMD)(uint8_t *pbuf, uint32_t BlockNumber, uint32_t wlength, uint32_t *status);
+  uint16_t (* VendorUploadCMD)(uint32_t Add, uint32_t BlockNumber, uint32_t *status);
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+  uint16_t (* VendorCheck)(uint8_t *pbuf, uint32_t ReqType, uint32_t *status);
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+#if (USBD_DFU_VENDOR_EXIT_ENABLED == 1U)
+  uint16_t (* LeaveDFU)(uint32_t Add);
+#endif /* USBD_DFU_VENDOR_EXIT_ENABLED */
 } USBD_DFU_MediaTypeDef;
 
 typedef struct

Class/DFU/Src/usbd_dfu.c

@@ -512,6 +512,7 @@ static uint8_t USBD_DFU_EP0_RxReady(USBD_HandleTypeDef *pdev)
 
   return (uint8_t)USBD_OK;
 }
+
 /**
   * @brief  USBD_DFU_EP0_TxReady
   *         handle EP0 TRx Ready event
@@ -521,9 +522,13 @@ static uint8_t USBD_DFU_EP0_RxReady(USBD_HandleTypeDef *pdev)
 static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
 {
   USBD_SetupReqTypedef req;
+  uint32_t app_addr_ptr;
   uint32_t addr;
   USBD_DFU_HandleTypeDef *hdfu = (USBD_DFU_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   USBD_DFU_MediaTypeDef *DfuInterface = (USBD_DFU_MediaTypeDef *)pdev->pUserData[pdev->classId];
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U) || (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+  uint32_t VendorStatus = 0U;
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
 
   if (hdfu == NULL)
   {
@@ -541,11 +546,43 @@ static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
         {
           /* Nothing to do */
         }
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+        else
+        {
+          /* Vendor specific DFU CMD */
+          if (DfuInterface->VendorDownloadCMD(hdfu->buffer.d8, hdfu->wblock_num,
+                                              hdfu->wlength, &VendorStatus) != USBD_OK)
+          {
+            /* Update the state machine */
+            hdfu->dev_state = DFU_STATE_ERROR;
+            hdfu->dev_status[0] = (uint8_t)VendorStatus;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+            return (uint8_t)USBD_FAIL;
+          }
+        }
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
       }
       else if (hdfu->wlength == 5U)
       {
         if (hdfu->buffer.d8[0] == DFU_CMD_SETADDRESSPOINTER)
         {
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+          if (DfuInterface->VendorCheck(hdfu->buffer.d8, IS_DFU_SETADDRESSPOINTER, &VendorStatus) != USBD_OK)
+          {
+            /* Update the state machine */
+            hdfu->dev_state = DFU_STATE_ERROR;
+            hdfu->dev_status[0] = (uint8_t)VendorStatus;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+            return (uint8_t)USBD_FAIL;
+          }
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+
           hdfu->data_ptr = hdfu->buffer.d8[1];
           hdfu->data_ptr += (uint32_t)hdfu->buffer.d8[2] << 8;
           hdfu->data_ptr += (uint32_t)hdfu->buffer.d8[3] << 16;
@@ -553,30 +590,114 @@ static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
         }
         else if (hdfu->buffer.d8[0] == DFU_CMD_ERASE)
         {
-          hdfu->data_ptr = hdfu->buffer.d8[1];
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
-          hdfu->data_ptr += (uint32_t)hdfu->buffer.d8[2] << 8;
+          if (DfuInterface->VendorCheck(hdfu->buffer.d8, IS_DFU_DOWNLOAD, &VendorStatus) != USBD_OK)
-          hdfu->data_ptr += (uint32_t)hdfu->buffer.d8[3] << 16;
-          hdfu->data_ptr += (uint32_t)hdfu->buffer.d8[4] << 24;
-
-          if (DfuInterface->Erase(hdfu->data_ptr) != USBD_OK)
           {
+            /* Update the state machine */
+            hdfu->dev_state = DFU_STATE_ERROR;
+            hdfu->dev_status[0] = (uint8_t)VendorStatus;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+            return (uint8_t)USBD_FAIL;
+          }
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+
+          app_addr_ptr = hdfu->buffer.d8[1];
+          app_addr_ptr += (uint32_t)hdfu->buffer.d8[2] << 8;
+          app_addr_ptr += (uint32_t)hdfu->buffer.d8[3] << 16;
+          app_addr_ptr += (uint32_t)hdfu->buffer.d8[4] << 24;
+
+          if (DfuInterface->Erase(app_addr_ptr) != USBD_OK)
+          {
+            /* Update the state machine */
+            hdfu->dev_state = DFU_STATE_ERROR;
+            hdfu->dev_status[0] = DFU_ERROR_VENDOR;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+            return (uint8_t)USBD_FAIL;
+          }
+        }
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+        else
+        {
+          /* Vendor specific DFU CMD */
+          if (DfuInterface->VendorDownloadCMD(hdfu->buffer.d8, hdfu->wblock_num,
+                                              hdfu->wlength, &VendorStatus) != USBD_OK)
+          {
+            /* Update the state machine */
+            hdfu->dev_state =  DFU_STATE_ERROR;
+            hdfu->dev_status[0] = (uint8_t)VendorStatus;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+            return (uint8_t)USBD_FAIL;
+          }
+        }
+#else
+        else
+        {
+          return (uint8_t)USBD_FAIL;
+        }
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+      }
+      else
+      {
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+        if (hdfu->wlength > 0U)
+        {
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+          if (DfuInterface->VendorCheck(hdfu->buffer.d8, IS_DFU_DOWNLOAD, &VendorStatus) != USBD_OK)
+          {
+            /* Update the state machine */
+            hdfu->dev_state = DFU_STATE_ERROR;
+            hdfu->dev_status[0] = (uint8_t)VendorStatus;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+            return (uint8_t)USBD_FAIL;
+          }
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+
+          /* Vendor specific DFU CMD */
+          if (DfuInterface->VendorDownloadCMD(hdfu->buffer.d8, hdfu->wblock_num,
+                                              hdfu->wlength, &VendorStatus) != USBD_OK)
+          {
+            /* Update the state machine */
+            hdfu->dev_state =  DFU_STATE_ERROR;
+            hdfu->dev_status[0] = (uint8_t)VendorStatus;
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
             return (uint8_t)USBD_FAIL;
           }
         }
         else
         {
-          return (uint8_t)USBD_FAIL;
+          /* Reset the block number */
+          hdfu->wblock_num = 0U;
+
+          /* Call the error management function (command will be NAKed) */
+          req.bmRequest = 0U;
+          req.wLength = 1U;
+          USBD_CtlError(pdev, &req);
         }
-      }
+#else
-      else
-      {
         /* Reset the global length and block number */
         hdfu->wlength = 0U;
         hdfu->wblock_num = 0U;
+
         /* Call the error management function (command will be NAKed) */
         req.bmRequest = 0U;
         req.wLength = 1U;
         USBD_CtlError(pdev, &req);
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
       }
     }
     /* Regular Download Command */
@@ -584,12 +705,33 @@ static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
     {
       if (hdfu->wblock_num > 1U)
       {
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+        if (DfuInterface->VendorCheck(hdfu->buffer.d8, IS_DFU_DOWNLOAD, &VendorStatus) != USBD_OK)
+        {
+          /* Update the state machine */
+          hdfu->dev_state = DFU_STATE_ERROR;
+          hdfu->dev_status[0] = (uint8_t)VendorStatus;
+          hdfu->dev_status[1] = 0U;
+          hdfu->dev_status[2] = 0U;
+          hdfu->dev_status[3] = 0U;
+          hdfu->dev_status[4] = hdfu->dev_state;
+          return (uint8_t)USBD_FAIL;
+        }
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+
         /* Decode the required address */
         addr = ((hdfu->wblock_num - 2U) * USBD_DFU_XFER_SIZE) + hdfu->data_ptr;
 
         /* Perform the write operation */
         if (DfuInterface->Write(hdfu->buffer.d8, (uint8_t *)addr, hdfu->wlength) != USBD_OK)
         {
+          /* Update the state machine */
+          hdfu->dev_state = DFU_STATE_ERROR;
+          hdfu->dev_status[0] = DFU_ERROR_VENDOR;
+          hdfu->dev_status[1] = 0U;
+          hdfu->dev_status[2] = 0U;
+          hdfu->dev_status[3] = 0U;
+          hdfu->dev_status[4] = hdfu->dev_state;
           return (uint8_t)USBD_FAIL;
         }
       }
@@ -670,7 +812,7 @@ static uint8_t *USBD_DFU_GetUsrStringDesc(USBD_HandleTypeDef *pdev, uint8_t inde
   else
   {
     /* Not supported Interface Descriptor index */
-    length = 0U;
+    *length = 0U;
     return NULL;
   }
 }
@@ -758,6 +900,11 @@ static void DFU_Download(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
   USBD_DFU_HandleTypeDef *hdfu = (USBD_DFU_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
 
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+  USBD_DFU_MediaTypeDef *DfuInterface = (USBD_DFU_MediaTypeDef *)pdev->pUserData[pdev->classId];
+  uint32_t VendorStatus = 0U;
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+
   if (hdfu == NULL)
   {
     return;
@@ -789,15 +936,36 @@ static void DFU_Download(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
   /* 0 Data DNLOAD request */
   else
   {
-    /* End of DNLOAD operation*/
+    /* End of DNLOAD operation */
     if ((hdfu->dev_state == DFU_STATE_DNLOAD_IDLE) || (hdfu->dev_state == DFU_STATE_IDLE))
     {
-      hdfu->manif_state = DFU_MANIFEST_IN_PROGRESS;
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
-      hdfu->dev_state = DFU_STATE_MANIFEST_SYNC;
+      /* Fill the buffer to be checked with the address stored in data buffer */
-      hdfu->dev_status[1] = 0U;
+      hdfu->buffer.d8[1] = (uint8_t)(hdfu->data_ptr & 0xFFU);
-      hdfu->dev_status[2] = 0U;
+      hdfu->buffer.d8[2] = (uint8_t)((hdfu->data_ptr & 0xFF00U) >> 8U);
-      hdfu->dev_status[3] = 0U;
+      hdfu->buffer.d8[3] = (uint8_t)((hdfu->data_ptr & 0xFF0000U) >> 16U);
-      hdfu->dev_status[4] = hdfu->dev_state;
+      hdfu->buffer.d8[4] = (uint8_t)((hdfu->data_ptr & 0xFF000000U) >> 24U);
+
+      if (DfuInterface->VendorCheck(hdfu->buffer.d8, IS_DFU_SETADDRESSPOINTER, &VendorStatus) != USBD_OK)
+      {
+        /* Update the state machine */
+        hdfu->dev_state = DFU_STATE_ERROR;
+        hdfu->dev_status[0] = (uint8_t)VendorStatus;
+        hdfu->dev_status[1] = 0U;
+        hdfu->dev_status[2] = 0U;
+        hdfu->dev_status[3] = 0U;
+        hdfu->dev_status[4] = hdfu->dev_state;
+      }
+      else
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+      {
+        hdfu->manif_state = DFU_MANIFEST_IN_PROGRESS;
+        hdfu->dev_state = DFU_STATE_MANIFEST_SYNC;
+        hdfu->dev_status[1] = 0U;
+        hdfu->dev_status[2] = 0U;
+        hdfu->dev_status[3] = 0U;
+        hdfu->dev_status[4] = hdfu->dev_state;
+      }
     }
     else
     {
@@ -820,6 +988,13 @@ static void DFU_Upload(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
   USBD_DFU_MediaTypeDef *DfuInterface = (USBD_DFU_MediaTypeDef *)pdev->pUserData[pdev->classId];
   uint8_t *phaddr;
   uint32_t addr;
+  uint32_t CmdLength;
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+  uint32_t VendorStatus = 0U;
+  uint8_t VendorCmdLength = 0U;
+  uint8_t VendorCmdBuffer[DFU_VENDOR_CMD_MAX];
+  uint8_t idx;
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
 
   if (hdfu == NULL)
   {
@@ -851,8 +1026,24 @@ static void DFU_Upload(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
         hdfu->buffer.d8[1] = DFU_CMD_SETADDRESSPOINTER;
         hdfu->buffer.d8[2] = DFU_CMD_ERASE;
 
+        CmdLength = 3U;
+
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+        if (DfuInterface->GetVendorCMD != NULL)
+        {
+          (void)DfuInterface->GetVendorCMD(VendorCmdBuffer, (uint8_t *)&VendorCmdLength);
+
+          for (idx = 0U; idx < MIN(VendorCmdLength, DFU_VENDOR_CMD_MAX); idx++)
+          {
+            hdfu->buffer.d8[idx + 3U] = VendorCmdBuffer[idx];
+          }
+
+          CmdLength += MIN(VendorCmdLength, DFU_VENDOR_CMD_MAX);
+        }
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+
         /* Send the status data over EP0 */
-        (void)USBD_CtlSendData(pdev, (uint8_t *)(&(hdfu->buffer.d8[0])), 3U);
+        (void)USBD_CtlSendData(pdev, (uint8_t *)(&(hdfu->buffer.d8[0])), CmdLength);
       }
       else if (hdfu->wblock_num > 1U)
       {
@@ -863,13 +1054,48 @@ static void DFU_Upload(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
         hdfu->dev_status[3] = 0U;
         hdfu->dev_status[4] = hdfu->dev_state;
 
-        addr = ((hdfu->wblock_num - 2U) * USBD_DFU_XFER_SIZE) + hdfu->data_ptr;
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+        /* Vendor specific DFU CMD */
+        if (DfuInterface->VendorUploadCMD(hdfu->data_ptr, hdfu->wblock_num, &VendorStatus) != USBD_OK)
+        {
+          /* Update the state machine */
+          hdfu->dev_state = DFU_ERROR_STALLEDPKT;
+          hdfu->dev_status[0] = (uint8_t)VendorStatus;
+          hdfu->dev_status[1] = 0U;
+          hdfu->dev_status[2] = 0U;
+          hdfu->dev_status[3] = 0U;
+          hdfu->dev_status[4] = hdfu->dev_state;
 
-        /* Return the physical address where data are stored */
+          /* Call the error management function (command will be NAKed) */
-        phaddr = DfuInterface->Read((uint8_t *)addr, hdfu->buffer.d8, hdfu->wlength);
+          USBD_CtlError(pdev, req);
+        }
 
-        /* Send the status data over EP0 */
+        if (VendorStatus == IS_DFU_PHY_ADDRESS)
-        (void)USBD_CtlSendData(pdev, phaddr, hdfu->wlength);
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+        {
+          addr = ((hdfu->wblock_num - 2U) * USBD_DFU_XFER_SIZE) + hdfu->data_ptr;
+
+          /* Return the physical address where data are stored */
+          phaddr = DfuInterface->Read((uint8_t *)addr, hdfu->buffer.d8, hdfu->wlength);
+
+          if (phaddr == NULL)
+          {
+            hdfu->dev_state = DFU_ERROR_STALLEDPKT;
+
+            hdfu->dev_status[1] = 0U;
+            hdfu->dev_status[2] = 0U;
+            hdfu->dev_status[3] = 0U;
+            hdfu->dev_status[4] = hdfu->dev_state;
+
+            /* Call the error management function (command will be NAKed) */
+            USBD_CtlError(pdev, req);
+          }
+          else
+          {
+            /* Send the status data over EP0 */
+            (void)USBD_CtlSendData(pdev, phaddr, hdfu->wlength);
+          }
+        }
       }
       else  /* unsupported hdfu->wblock_num */
       {
@@ -880,7 +1106,7 @@ static void DFU_Upload(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
         hdfu->dev_status[3] = 0U;
         hdfu->dev_status[4] = hdfu->dev_state;
 
-        /* Call the error management function (command will be NAKed */
+        /* Call the error management function (command will be NAKed) */
         USBD_CtlError(pdev, req);
       }
     }
@@ -890,7 +1116,7 @@ static void DFU_Upload(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
       hdfu->wlength = 0U;
       hdfu->wblock_num = 0U;
 
-      /* Call the error management function (command will be NAKed */
+      /* Call the error management function (command will be NAKed) */
       USBD_CtlError(pdev, req);
     }
   }
@@ -944,7 +1170,7 @@ static void DFU_GetStatus(USBD_HandleTypeDef *pdev)
           DfuInterface->GetStatus(hdfu->data_ptr, DFU_MEDIA_PROGRAM, hdfu->dev_status);
         }
       }
-      else  /* (hdfu->wlength==0)*/
+      else  /* (hdfu->wlength == 0U) */
       {
         hdfu->dev_state = DFU_STATE_DNLOAD_IDLE;
 
@@ -960,7 +1186,7 @@ static void DFU_GetStatus(USBD_HandleTypeDef *pdev)
       {
         hdfu->dev_state = DFU_STATE_MANIFEST;
 
-        hdfu->dev_status[1] = 1U;             /*bwPollTimeout = 1ms*/
+        hdfu->dev_status[1] = 1U;             /* bwPollTimeout = 1ms */
         hdfu->dev_status[2] = 0U;
         hdfu->dev_status[3] = 0U;
         hdfu->dev_status[4] = hdfu->dev_state;
@@ -1088,9 +1314,10 @@ static void DFU_Abort(USBD_HandleTypeDef *pdev)
 static void DFU_Leave(USBD_HandleTypeDef *pdev)
 {
   USBD_DFU_HandleTypeDef *hdfu = (USBD_DFU_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_DFU_MediaTypeDef *DfuInterface = (USBD_DFU_MediaTypeDef *)pdev->pUserData[pdev->classId];
   USBD_DFUFuncDescTypeDef *pDfuFunc = (USBD_DFUFuncDescTypeDef *)USBD_DFU_GetDfuFuncDesc(pdev->pConfDesc);
 
-  if ((hdfu == NULL) || (pDfuFunc == NULL))
+  if ((hdfu == NULL) || (DfuInterface == NULL) || (pDfuFunc == NULL))
   {
     return;
   }
@@ -1119,8 +1346,13 @@ static void DFU_Leave(USBD_HandleTypeDef *pdev)
     /* Disconnect the USB device */
     (void)USBD_Stop(pdev);
 
+#if (USBD_DFU_VENDOR_EXIT_ENABLED == 1U)
+    /* Jump should be ensured by user application */
+    DfuInterface->LeaveDFU(hdfu->data_ptr);
+#else
     /* Generate system reset to allow jumping to the user code */
     NVIC_SystemReset();
+#endif /* USBD_DFU_VENDOR_EXIT_ENABLED */
 
     /* The next instructions will not be reached (system reset) */
   }

Class/DFU/Src/usbd_dfu_media_template.c

@@ -38,6 +38,17 @@ uint16_t MEM_If_Write(uint8_t *src, uint8_t *dest, uint32_t Len);
 uint8_t *MEM_If_Read(uint8_t *src, uint8_t *dest, uint32_t Len);
 uint16_t MEM_If_DeInit(void);
 uint16_t MEM_If_GetStatus(uint32_t Add, uint8_t Cmd, uint8_t *buffer);
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+uint16_t MEM_If_GetVendorCMD(uint8_t *cmd, uint8_t *cmdlength);
+uint16_t MEM_If_VendorDownloadCMD(uint8_t *pbuf, uint32_t BlockNumber, uint32_t wlength, uint32_t *status);
+uint16_t MEM_If_VendorUploadCMD(uint32_t Add, uint32_t BlockNumber, uint32_t *status);
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+uint16_t MEM_If_VendorCheck(uint8_t *pbuf, uint32_t ReqType, uint32_t *status);
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+#if (USBD_DFU_VENDOR_EXIT_ENABLED == 1U)
+uint16_t MEM_If_LeaveDFU(uint32_t Add);
+#endif /* USBD_DFU_VENDOR_EXIT_ENABLED */
 
 USBD_DFU_MediaTypeDef USBD_DFU_MEDIA_Template_fops =
 {
@@ -48,8 +59,19 @@ USBD_DFU_MediaTypeDef USBD_DFU_MEDIA_Template_fops =
   MEM_If_Write,
   MEM_If_Read,
   MEM_If_GetStatus,
-
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+  MEM_If_GetVendorCMD,
+  MEM_If_VendorDownloadCMD,
+  MEM_If_VendorUploadCMD,
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+  MEM_If_VendorCheck,
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+#if (USBD_DFU_VENDOR_EXIT_ENABLED == 1U)
+  MEM_If_LeaveDFU
+#endif /* USBD_DFU_VENDOR_EXIT_ENABLED */
 };
+
 /**
   * @brief  MEM_If_Init
   *         Memory initialization routine.
@@ -115,7 +137,7 @@ uint8_t *MEM_If_Read(uint8_t *src, uint8_t *dest, uint32_t Len)
   UNUSED(Len);
 
   /* Return a valid address to avoid HardFault */
-  return (uint8_t *)(0);
+  return NULL;
 }
 
 /**
@@ -144,3 +166,85 @@ uint16_t MEM_If_GetStatus(uint32_t Add, uint8_t Cmd, uint8_t *buffer)
   return (0);
 }
 
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
+/**
+  * @brief  Get supported vendor specific commands
+  * @param  pointer to supported vendor commands
+  * @param  pointer to length of supported vendor commands
+  * @retval 0 if operation is successful
+  */
+uint16_t MEM_If_GetVendorCMD(uint8_t *cmd, uint8_t *cmdlength)
+{
+  UNUSED(cmd);
+  UNUSED(cmdlength);
+
+  return 0U;
+}
+
+/**
+  * @brief  Vendor specific download commands
+  * @param  pbuf DFU data buffer
+  * @param  BlockNumber DFU memory block number
+  * @param  wLength DFU request length
+  * @param  pointer to DFU status
+  * @retval 0 if operation is successful
+  */
+uint16_t MEM_If_VendorDownloadCMD(uint8_t *pbuf, uint32_t BlockNumber, uint32_t wlength, uint32_t *status)
+{
+  UNUSED(pbuf);
+  UNUSED(BlockNumber);
+  UNUSED(wlength);
+  UNUSED(status);
+
+  return 0U;
+}
+
+
+/**
+  * @brief  Vendor specific upload commands
+  * @param  Add memory Address
+  * @param  BlockNumber DFU memory block number
+  * @param  pointer to DFU status
+  * @retval 0 if operation is successful
+  */
+uint16_t MEM_If_VendorUploadCMD(uint32_t Add, uint32_t BlockNumber, uint32_t *status)
+{
+  UNUSED(Add);
+  UNUSED(BlockNumber);
+  UNUSED(status);
+
+  return 0U;
+}
+#endif /* USBD_DFU_VENDOR_CMD_ENABLED */
+
+#if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+/**
+  * @brief  Vendor memory check
+  * @param  pbuf DFU data buffer
+  * @param  ReqType IS_DFU_SETADDRESSPOINTER/DOWNLOAD/UPLOAD
+  * @param  pointer to DFU status
+  * @retval 0 if operation is successful
+  */
+uint16_t MEM_If_VendorCheck(uint8_t *pbuf, uint32_t ReqType, uint32_t *status)
+{
+  UNUSED(pbuf);
+  UNUSED(ReqType);
+  UNUSED(status);
+
+  return 0U;
+}
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
+
+#if (USBD_DFU_VENDOR_EXIT_ENABLED == 1U)
+/**
+  * @brief  Vendor Leave DFU
+  * @param  Application address
+  * @retval 0 if operation is successful
+  */
+uint16_t MEM_If_LeaveDFU(uint32_t Add)
+{
+  UNUSED(Add);
+
+  return 0U;
+}
+#endif /* USBD_DFU_VENDOR_EXIT_ENABLED */

Class/HID/Inc/usbd_hid.h

@@ -60,14 +60,14 @@ extern "C" {
 #define HID_FS_BINTERVAL                           0x0AU
 #endif /* HID_FS_BINTERVAL */
 
-#define HID_REQ_SET_PROTOCOL                       0x0BU
+#define USBD_HID_REQ_SET_PROTOCOL                       0x0BU
-#define HID_REQ_GET_PROTOCOL                       0x03U
+#define USBD_HID_REQ_GET_PROTOCOL                       0x03U
 
-#define HID_REQ_SET_IDLE                           0x0AU
+#define USBD_HID_REQ_SET_IDLE                           0x0AU
-#define HID_REQ_GET_IDLE                           0x02U
+#define USBD_HID_REQ_GET_IDLE                           0x02U
 
-#define HID_REQ_SET_REPORT                         0x09U
+#define USBD_HID_REQ_SET_REPORT                         0x09U
-#define HID_REQ_GET_REPORT                         0x01U
+#define USBD_HID_REQ_GET_REPORT                         0x01U
 /**
   * @}
   */
@@ -78,9 +78,9 @@ extern "C" {
   */
 typedef enum
 {
-  HID_IDLE = 0,
+  USBD_HID_IDLE = 0,
-  HID_BUSY,
+  USBD_HID_BUSY,
-} HID_StateTypeDef;
+} USBD_HID_StateTypeDef;
 
 
 typedef struct
@@ -88,7 +88,7 @@ typedef struct
   uint32_t Protocol;
   uint32_t IdleState;
   uint32_t AltSetting;
-  HID_StateTypeDef state;
+  USBD_HID_StateTypeDef state;
 } USBD_HID_HandleTypeDef;
 
 /*
@@ -134,7 +134,11 @@ extern USBD_ClassTypeDef USBD_HID;
 /** @defgroup USB_CORE_Exported_Functions
   * @{
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_HID_SendReport(USBD_HandleTypeDef *pdev, uint8_t *report, uint16_t len, uint8_t ClassId);
+#else
 uint8_t USBD_HID_SendReport(USBD_HandleTypeDef *pdev, uint8_t *report, uint16_t len);
+#endif /* USE_USBD_COMPOSITE */
 uint32_t USBD_HID_GetPollingInterval(USBD_HandleTypeDef *pdev);
 
 /**

Class/HID/Src/usbd_hid.c

@@ -128,6 +128,9 @@ USBD_ClassTypeDef USBD_HID =
   USBD_HID_GetOtherSpeedCfgDesc,
   USBD_HID_GetDeviceQualifierDesc,
 #endif /* USE_USBD_COMPOSITE  */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -295,7 +298,7 @@ static uint8_t USBD_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  HIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  HIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->dev_speed == USBD_SPEED_HIGH)
@@ -311,7 +314,7 @@ static uint8_t USBD_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   (void)USBD_LL_OpenEP(pdev, HIDInEpAdd, USBD_EP_TYPE_INTR, HID_EPIN_SIZE);
   pdev->ep_in[HIDInEpAdd & 0xFU].is_used = 1U;
 
-  hhid->state = HID_IDLE;
+  hhid->state = USBD_HID_IDLE;
 
   return (uint8_t)USBD_OK;
 }
@@ -329,7 +332,7 @@ static uint8_t USBD_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  HIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  HIDInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close HID EPs */
@@ -372,19 +375,19 @@ static uint8_t USBD_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *re
     case USB_REQ_TYPE_CLASS :
       switch (req->bRequest)
       {
-        case HID_REQ_SET_PROTOCOL:
+        case USBD_HID_REQ_SET_PROTOCOL:
           hhid->Protocol = (uint8_t)(req->wValue);
           break;
 
-        case HID_REQ_GET_PROTOCOL:
+        case USBD_HID_REQ_GET_PROTOCOL:
           (void)USBD_CtlSendData(pdev, (uint8_t *)&hhid->Protocol, 1U);
           break;
 
-        case HID_REQ_SET_IDLE:
+        case USBD_HID_REQ_SET_IDLE:
           hhid->IdleState = (uint8_t)(req->wValue >> 8);
           break;
 
-        case HID_REQ_GET_IDLE:
+        case USBD_HID_REQ_GET_IDLE:
           (void)USBD_CtlSendData(pdev, (uint8_t *)&hhid->IdleState, 1U);
           break;
 
@@ -472,16 +475,24 @@ static uint8_t USBD_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *re
   return (uint8_t)ret;
 }
 
+
 /**
   * @brief  USBD_HID_SendReport
   *         Send HID Report
   * @param  pdev: device instance
   * @param  buff: pointer to report
+  * @param  ClassId: The Class ID
   * @retval status
   */
+#ifdef USE_USBD_COMPOSITE
+uint8_t USBD_HID_SendReport(USBD_HandleTypeDef *pdev, uint8_t *report, uint16_t len, uint8_t ClassId)
+{
+  USBD_HID_HandleTypeDef *hhid = (USBD_HID_HandleTypeDef *)pdev->pClassDataCmsit[ClassId];
+#else
 uint8_t USBD_HID_SendReport(USBD_HandleTypeDef *pdev, uint8_t *report, uint16_t len)
 {
   USBD_HID_HandleTypeDef *hhid = (USBD_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+#endif /* USE_USBD_COMPOSITE */
 
   if (hhid == NULL)
   {
@@ -490,14 +501,14 @@ uint8_t USBD_HID_SendReport(USBD_HandleTypeDef *pdev, uint8_t *report, uint16_t
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  HIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  HIDInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, ClassId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->dev_state == USBD_STATE_CONFIGURED)
   {
-    if (hhid->state == HID_IDLE)
+    if (hhid->state == USBD_HID_IDLE)
     {
-      hhid->state = HID_BUSY;
+      hhid->state = USBD_HID_BUSY;
       (void)USBD_LL_Transmit(pdev, HIDInEpAdd, report, len);
     }
   }
@@ -607,7 +618,7 @@ static uint8_t USBD_HID_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
   UNUSED(epnum);
   /* Ensure that the FIFO is empty before a new transfer, this condition could
   be caused by  a new transfer before the end of the previous transfer */
-  ((USBD_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId])->state = HID_IDLE;
+  ((USBD_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId])->state = USBD_HID_IDLE;
 
   return (uint8_t)USBD_OK;
 }

Class/MSC/Inc/usbd_msc.h

@@ -62,6 +62,10 @@ extern "C" {
 #define MSC_EPOUT_ADDR               0x01U
 #endif /* MSC_EPOUT_ADDR */
 
+#ifndef MSC_BOT_MAX_LUN
+#define MSC_BOT_MAX_LUN              0x2U
+#endif /* MSC_BOT_MAX_LUN */
+
 /**
   * @}
   */
@@ -82,6 +86,13 @@ typedef struct _USBD_STORAGE
 
 } USBD_StorageTypeDef;
 
+typedef struct
+{
+  uint16_t size;
+  uint32_t nbr;
+  uint32_t addr;
+  uint32_t len;
+} USBD_MSC_BOT_LUN_TypeDef;
 
 typedef struct
 {
@@ -99,11 +110,7 @@ typedef struct
   uint8_t                  scsi_sense_tail;
   uint8_t                  scsi_medium_state;
 
-  uint16_t                 scsi_blk_size;
+  USBD_MSC_BOT_LUN_TypeDef scsi_blk[MSC_BOT_MAX_LUN];
-  uint32_t                 scsi_blk_nbr;
-
-  uint32_t                 scsi_blk_addr;
-  uint32_t                 scsi_blk_len;
 } USBD_MSC_BOT_HandleTypeDef;
 
 /* Structure for MSC process */

Class/MSC/Inc/usbd_msc_data.h

@@ -39,11 +39,13 @@ extern "C" {
 /** @defgroup USB_INFO_Exported_Defines
   * @{
   */
-#define MODE_SENSE6_LEN                    0x17U
+#define MODE_SENSE6_LEN                    0x04U
-#define MODE_SENSE10_LEN                   0x1BU
+#define MODE_SENSE10_LEN                   0x08U
 #define LENGTH_INQUIRY_PAGE00              0x06U
 #define LENGTH_INQUIRY_PAGE80              0x08U
 #define LENGTH_FORMAT_CAPACITIES           0x14U
+#define DIAGNOSTIC_DATA_LEN                0x08U
+#define LOG_PAGE_DATA_LEN                  0x10U
 
 /**
   * @}
@@ -74,6 +76,8 @@ extern uint8_t MSC_Page00_Inquiry_Data[LENGTH_INQUIRY_PAGE00];
 extern uint8_t MSC_Page80_Inquiry_Data[LENGTH_INQUIRY_PAGE80];
 extern uint8_t MSC_Mode_Sense6_data[MODE_SENSE6_LEN];
 extern uint8_t MSC_Mode_Sense10_data[MODE_SENSE10_LEN];
+extern uint8_t MSC_Diagnostic_Data[DIAGNOSTIC_DATA_LEN];
+extern uint8_t MSC_Log_Page_Data[LOG_PAGE_DATA_LEN];
 
 /**
   * @}

Class/MSC/Inc/usbd_msc_scsi.h

@@ -70,8 +70,10 @@ extern "C" {
 #define SCSI_VERIFY12                               0xAFU
 #define SCSI_VERIFY16                               0x8FU
 
-#define SCSI_SEND_DIAGNOSTIC                        0x1DU
 #define SCSI_READ_FORMAT_CAPACITIES                 0x23U
+#define SCSI_RECEIVE_DIAGNOSTIC_RESULTS             0x1CU
+#define SCSI_SEND_DIAGNOSTIC                        0x1DU
+#define SCSI_REPORT_LUNS                            0xA0U
 
 #define NO_SENSE                                    0U
 #define RECOVERED_ERROR                             1U
@@ -82,15 +84,14 @@ extern "C" {
 #define UNIT_ATTENTION                              6U
 #define DATA_PROTECT                                7U
 #define BLANK_CHECK                                 8U
-#define VENDOR_SPECIFIC                             9U
+#define MSC_VENDOR_SPECIFIC                         9U
 #define COPY_ABORTED                                10U
 #define ABORTED_COMMAND                             11U
 #define VOLUME_OVERFLOW                             13U
 #define MISCOMPARE                                  14U
 
-
 #define INVALID_CDB                                 0x20U
-#define INVALID_FIELED_IN_COMMAND                   0x24U
+#define INVALID_FIELD_IN_COMMAND                    0x24U
 #define PARAMETER_LIST_LENGTH_ERROR                 0x1AU
 #define INVALID_FIELD_IN_PARAMETER_LIST             0x26U
 #define ADDRESS_OUT_OF_RANGE                        0x21U

Class/MSC/Src/usbd_msc.c

@@ -125,6 +125,9 @@ USBD_ClassTypeDef  USBD_MSC =
   USBD_MSC_GetOtherSpeedCfgDesc,
   USBD_MSC_GetDeviceQualifierDescriptor,
 #endif /* USE_USBD_COMPOSITE */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 /* USB Mass storage device Configuration Descriptor */
@@ -229,8 +232,8 @@ uint8_t USBD_MSC_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (pdev->dev_speed == USBD_SPEED_HIGH)
@@ -273,8 +276,8 @@ uint8_t USBD_MSC_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close MSC EPs */
@@ -309,12 +312,13 @@ uint8_t USBD_MSC_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   USBD_StatusTypeDef ret = USBD_OK;
+  uint32_t max_lun;
   uint16_t status_info = 0U;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -332,7 +336,8 @@ uint8_t USBD_MSC_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
           if ((req->wValue  == 0U) && (req->wLength == 1U) &&
               ((req->bmRequest & 0x80U) == 0x80U))
           {
-            hmsc->max_lun = (uint32_t)((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetMaxLun();
+            max_lun = (uint32_t)((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetMaxLun();
+            hmsc->max_lun = (max_lun > MSC_BOT_MAX_LUN) ? MSC_BOT_MAX_LUN : max_lun;
             (void)USBD_CtlSendData(pdev, (uint8_t *)&hmsc->max_lun, 1U);
           }
           else

Class/MSC/Src/usbd_msc_bot.c

@@ -101,8 +101,8 @@ void MSC_BOT_Init(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -139,8 +139,8 @@ void MSC_BOT_Reset(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -259,8 +259,8 @@ static void  MSC_BOT_CBW_Decode(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -273,7 +273,7 @@ static void  MSC_BOT_CBW_Decode(USBD_HandleTypeDef *pdev)
 
   if ((USBD_LL_GetRxDataSize(pdev, MSCOutEpAdd) != USBD_BOT_CBW_LENGTH) ||
       (hmsc->cbw.dSignature != USBD_BOT_CBW_SIGNATURE) ||
-      (hmsc->cbw.bLUN > 1U) || (hmsc->cbw.bCBLength < 1U) ||
+      (hmsc->cbw.bLUN > hmsc->max_lun) || (hmsc->cbw.bCBLength < 1U) ||
       (hmsc->cbw.bCBLength > 16U))
   {
     SCSI_SenseCode(pdev, hmsc->cbw.bLUN, ILLEGAL_REQUEST, INVALID_CDB);
@@ -335,8 +335,8 @@ static void  MSC_BOT_SendData(USBD_HandleTypeDef *pdev, uint8_t *pbuf, uint32_t
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -366,8 +366,8 @@ void  MSC_BOT_SendCSW(USBD_HandleTypeDef *pdev, uint8_t CSW_Status)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -400,8 +400,8 @@ static void  MSC_BOT_Abort(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)
@@ -439,8 +439,8 @@ void  MSC_BOT_CplClrFeature(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc == NULL)

Class/MSC/Src/usbd_msc_data.c

@@ -91,63 +91,46 @@ uint8_t MSC_Page80_Inquiry_Data[LENGTH_INQUIRY_PAGE80] =
 /* USB Mass storage sense 6 Data */
 uint8_t MSC_Mode_Sense6_data[MODE_SENSE6_LEN] =
 {
-  0x22,
+  0x03,     /* MODE DATA LENGTH. The number of bytes that follow. */
-  0x00,
+  0x00,     /* MEDIUM TYPE. 00h for SBC devices. */
-  0x00,
+  0x00,     /* DEVICE-SPECIFIC PARAMETER. For SBC devices:
-  0x00,
+             *   bit 7: WP. Set to 1 if the media is write-protected.
-  0x08,
+             *   bits 6..5: reserved
-  0x12,
+             *   bit 4: DPOFUA. Set to 1 if the device supports the DPO and FUA bits
-  0x00,
+             *   bits 3..0: reserved */
-  0x00,
+  0x00      /* BLOCK DESCRIPTOR LENGTH */
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00
 };
 
 
-/* USB Mass storage sense 10  Data */
+/* USB Mass storage sense 10 Data */
 uint8_t MSC_Mode_Sense10_data[MODE_SENSE10_LEN] =
 {
-  0x00,
+  0x00,     /* MODE DATA LENGTH MSB. */
-  0x26,
+  0x06,     /* MODE DATA LENGTH LSB. The number of bytes that follow. */
-  0x00,
+  0x00,     /* MEDIUM TYPE. 00h for SBC devices. */
-  0x00,
+  0x00,     /* DEVICE-SPECIFIC PARAMETER. For SBC devices:
-  0x00,
+             *   bit 7: WP. Set to 1 if the media is write-protected.
-  0x00,
+             *   bits 6..5: reserved
-  0x00,
+             *   bit 4: DPOFUA. Set to 1 if the device supports the DPO and FUA bits
-  0x00,
+             *   bits 3..0: reserved */
-  0x08,
+  0x00,     /* LONGLBA Set to zero */
-  0x12,
+  0x00,     /* Reserved */
-  0x00,
+  0x00,     /* BLOCK DESCRIPTOR LENGTH MSB. */
-  0x00,
+  0x00      /* BLOCK DESCRIPTOR LENGTH LSB. */
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00,
-  0x00
 };
+
+uint8_t MSC_Diagnostic_Data[DIAGNOSTIC_DATA_LEN] =
+{
+  0x00, /* Byte 0: ADDITIONAL LENGTH (MSB) */
+  0x00, /* Byte 1: ADDITIONAL LENGTH (LSB) */
+  0x00, /* Byte 2: FRU CODE (most probable) */
+  0x00, /* Byte 3: FRU CODE */
+  0x00, /* Byte 4: FRU CODE */
+  0x00, /* Byte 5: FRU CODE (least probable) */
+  0x00, /* Byte 6: ERROR CODE (MSB) */
+  0x00, /* Byte 7: ERROR CODE (LSB) */
+};
+
 /**
   * @}
   */

Class/MSC/Src/usbd_msc_scsi.c

@@ -92,6 +92,8 @@ static int8_t SCSI_Write12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
 static int8_t SCSI_Read10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_Read12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_Verify10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
+static int8_t SCSI_ReportLuns(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
+static int8_t SCSI_ReceiveDiagnosticResults(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_CheckAddressRange(USBD_HandleTypeDef *pdev, uint8_t lun,
                                      uint32_t blk_offset, uint32_t blk_nbr);
 
@@ -190,9 +192,16 @@ int8_t SCSI_ProcessCmd(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *cmd)
       ret = SCSI_Verify10(pdev, lun, cmd);
       break;
 
+    case SCSI_REPORT_LUNS:
+      ret = SCSI_ReportLuns(pdev, lun, cmd);
+      break;
+
+    case SCSI_RECEIVE_DIAGNOSTIC_RESULTS:
+      ret = SCSI_ReceiveDiagnosticResults(pdev, lun, cmd);
+      break;
+
     default:
       SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_CDB);
-      hmsc->bot_status = USBD_BOT_STATUS_ERROR;
       ret = -1;
       break;
   }
@@ -283,7 +292,7 @@ static int8_t SCSI_Inquiry(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
     else /* Request Not supported */
     {
       SCSI_SenseCode(pdev, hmsc->cbw.bLUN, ILLEGAL_REQUEST,
-                     INVALID_FIELED_IN_COMMAND);
+                     INVALID_FIELD_IN_COMMAND);
 
       return -1;
     }
@@ -291,7 +300,8 @@ static int8_t SCSI_Inquiry(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
   else
   {
 
-    pPage = (uint8_t *) & ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->pInquiry[lun * STANDARD_INQUIRY_DATA_LEN];
+    pPage = (uint8_t *) & ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId]) \
+            ->pInquiry[lun * STANDARD_INQUIRY_DATA_LEN];
     len = (uint16_t)pPage[4] + 5U;
 
     if (params[4] <= len)
@@ -318,13 +328,15 @@ static int8_t SCSI_ReadCapacity10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
   UNUSED(params);
   int8_t ret;
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
-  ret = ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &hmsc->scsi_blk_nbr, &hmsc->scsi_blk_size);
+  ret = ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &p_scsi_blk->nbr,
+                                                                             &p_scsi_blk->size);
 
   if ((ret != 0) || (hmsc->scsi_medium_state == SCSI_MEDIUM_EJECTED))
   {
@@ -332,20 +344,19 @@ static int8_t SCSI_ReadCapacity10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
     return -1;
   }
 
-  hmsc->bot_data[0] = (uint8_t)((hmsc->scsi_blk_nbr - 1U) >> 24);
+  hmsc->bot_data[0] = (uint8_t)((p_scsi_blk->nbr - 1U) >> 24);
-  hmsc->bot_data[1] = (uint8_t)((hmsc->scsi_blk_nbr - 1U) >> 16);
+  hmsc->bot_data[1] = (uint8_t)((p_scsi_blk->nbr - 1U) >> 16);
-  hmsc->bot_data[2] = (uint8_t)((hmsc->scsi_blk_nbr - 1U) >>  8);
+  hmsc->bot_data[2] = (uint8_t)((p_scsi_blk->nbr - 1U) >>  8);
-  hmsc->bot_data[3] = (uint8_t)(hmsc->scsi_blk_nbr - 1U);
+  hmsc->bot_data[3] = (uint8_t)(p_scsi_blk->nbr - 1U);
 
-  hmsc->bot_data[4] = (uint8_t)(hmsc->scsi_blk_size >>  24);
+  hmsc->bot_data[4] = (uint8_t)(p_scsi_blk->size >> 24);
-  hmsc->bot_data[5] = (uint8_t)(hmsc->scsi_blk_size >>  16);
+  hmsc->bot_data[5] = (uint8_t)(p_scsi_blk->size >> 16);
-  hmsc->bot_data[6] = (uint8_t)(hmsc->scsi_blk_size >>  8);
+  hmsc->bot_data[6] = (uint8_t)(p_scsi_blk->size >> 8);
-  hmsc->bot_data[7] = (uint8_t)(hmsc->scsi_blk_size);
+  hmsc->bot_data[7] = (uint8_t)(p_scsi_blk->size);
 
   hmsc->bot_data_length = 8U;
 
   return 0;
-
 }
 
 
@@ -359,16 +370,18 @@ static int8_t SCSI_ReadCapacity10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
 static int8_t SCSI_ReadCapacity16(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
   UNUSED(params);
-  uint8_t idx;
+  uint32_t idx;
   int8_t ret;
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
-  ret = ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &hmsc->scsi_blk_nbr, &hmsc->scsi_blk_size);
+  ret = ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &p_scsi_blk->nbr,
+                                                                             &p_scsi_blk->size);
 
   if ((ret != 0) || (hmsc->scsi_medium_state == SCSI_MEDIUM_EJECTED))
   {
@@ -386,15 +399,15 @@ static int8_t SCSI_ReadCapacity16(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
     hmsc->bot_data[idx] = 0U;
   }
 
-  hmsc->bot_data[4] = (uint8_t)((hmsc->scsi_blk_nbr - 1U) >> 24);
+  hmsc->bot_data[4] = (uint8_t)((p_scsi_blk->nbr - 1U) >> 24);
-  hmsc->bot_data[5] = (uint8_t)((hmsc->scsi_blk_nbr - 1U) >> 16);
+  hmsc->bot_data[5] = (uint8_t)((p_scsi_blk->nbr - 1U) >> 16);
-  hmsc->bot_data[6] = (uint8_t)((hmsc->scsi_blk_nbr - 1U) >>  8);
+  hmsc->bot_data[6] = (uint8_t)((p_scsi_blk->nbr - 1U) >>  8);
-  hmsc->bot_data[7] = (uint8_t)(hmsc->scsi_blk_nbr - 1U);
+  hmsc->bot_data[7] = (uint8_t)(p_scsi_blk->nbr - 1U);
 
-  hmsc->bot_data[8] = (uint8_t)(hmsc->scsi_blk_size >>  24);
+  hmsc->bot_data[8] = (uint8_t)(p_scsi_blk->size >>  24);
-  hmsc->bot_data[9] = (uint8_t)(hmsc->scsi_blk_size >>  16);
+  hmsc->bot_data[9] = (uint8_t)(p_scsi_blk->size >>  16);
-  hmsc->bot_data[10] = (uint8_t)(hmsc->scsi_blk_size >>  8);
+  hmsc->bot_data[10] = (uint8_t)(p_scsi_blk->size >>  8);
-  hmsc->bot_data[11] = (uint8_t)(hmsc->scsi_blk_size);
+  hmsc->bot_data[11] = (uint8_t)(p_scsi_blk->size);
 
   hmsc->bot_data_length = ((uint32_t)params[10] << 24) |
                           ((uint32_t)params[11] << 16) |
@@ -474,6 +487,16 @@ static int8_t SCSI_ModeSense6(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *pa
     return -1;
   }
 
+  /* Check If media is write-protected */
+  if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsWriteProtected(lun) != 0)
+  {
+    MSC_Mode_Sense6_data[2] |= (0x1U << 7); /* Set the WP (write protection) bit */
+  }
+  else
+  {
+    MSC_Mode_Sense10_data[2] &= ~(0x1U << 7); /* Clear the WP (write protection) bit */
+  }
+
   if (params[4] <= len)
   {
     len = params[4];
@@ -503,6 +526,16 @@ static int8_t SCSI_ModeSense10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *p
     return -1;
   }
 
+  /* Check If media is write-protected */
+  if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsWriteProtected(lun) != 0)
+  {
+    MSC_Mode_Sense10_data[3] |= (0x1U << 7); /* Set the WP (write protection) bit */
+  }
+  else
+  {
+    MSC_Mode_Sense10_data[3] &= ~(0x1U << 7); /* Clear the WP (write protection) bit */
+  }
+
   if (params[8] <= len)
   {
     len = params[8];
@@ -620,7 +653,7 @@ static int8_t SCSI_StartStopUnit(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
 
   if ((hmsc->scsi_medium_state == SCSI_MEDIUM_LOCKED) && ((params[4] & 0x3U) == 2U))
   {
-    SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_FIELED_IN_COMMAND);
+    SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_FIELD_IN_COMMAND);
 
     return -1;
   }
@@ -689,6 +722,7 @@ static int8_t SCSI_AllowPreventRemovable(USBD_HandleTypeDef *pdev, uint8_t lun,
 static int8_t SCSI_Read10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
 
   if (hmsc == NULL)
   {
@@ -717,21 +751,20 @@ static int8_t SCSI_Read10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params
       return -1;
     }
 
-    hmsc->scsi_blk_addr = ((uint32_t)params[2] << 24) |
+    p_scsi_blk->addr = ((uint32_t)params[2] << 24) |
-                          ((uint32_t)params[3] << 16) |
+                       ((uint32_t)params[3] << 16) |
-                          ((uint32_t)params[4] <<  8) |
+                       ((uint32_t)params[4] <<  8) |
-                          (uint32_t)params[5];
+                       (uint32_t)params[5];
 
-    hmsc->scsi_blk_len = ((uint32_t)params[7] <<  8) | (uint32_t)params[8];
+    p_scsi_blk->len = ((uint32_t)params[7] <<  8) | (uint32_t)params[8];
 
-    if (SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr,
+    if (SCSI_CheckAddressRange(pdev, lun, p_scsi_blk->addr, p_scsi_blk->len) < 0)
-                               hmsc->scsi_blk_len) < 0)
     {
       return -1; /* error */
     }
 
     /* cases 4,5 : Hi <> Dn */
-    if (hmsc->cbw.dDataLength != (hmsc->scsi_blk_len * hmsc->scsi_blk_size))
+    if (hmsc->cbw.dDataLength != (p_scsi_blk->len * p_scsi_blk->size))
     {
       SCSI_SenseCode(pdev, hmsc->cbw.bLUN, ILLEGAL_REQUEST, INVALID_CDB);
       return -1;
@@ -755,6 +788,7 @@ static int8_t SCSI_Read10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params
 static int8_t SCSI_Read12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
 
   if (hmsc == NULL)
   {
@@ -782,24 +816,23 @@ static int8_t SCSI_Read12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params
       return -1;
     }
 
-    hmsc->scsi_blk_addr = ((uint32_t)params[2] << 24) |
+    p_scsi_blk->addr = ((uint32_t)params[2] << 24) |
-                          ((uint32_t)params[3] << 16) |
+                       ((uint32_t)params[3] << 16) |
-                          ((uint32_t)params[4] <<  8) |
+                       ((uint32_t)params[4] <<  8) |
-                          (uint32_t)params[5];
+                       (uint32_t)params[5];
 
-    hmsc->scsi_blk_len = ((uint32_t)params[6] << 24) |
+    p_scsi_blk->len = ((uint32_t)params[6] << 24) |
-                         ((uint32_t)params[7] << 16) |
+                      ((uint32_t)params[7] << 16) |
-                         ((uint32_t)params[8] << 8) |
+                      ((uint32_t)params[8] << 8) |
-                         (uint32_t)params[9];
+                      (uint32_t)params[9];
 
-    if (SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr,
+    if (SCSI_CheckAddressRange(pdev, lun, p_scsi_blk->addr, p_scsi_blk->len) < 0)
-                               hmsc->scsi_blk_len) < 0)
     {
       return -1; /* error */
     }
 
     /* cases 4,5 : Hi <> Dn */
-    if (hmsc->cbw.dDataLength != (hmsc->scsi_blk_len * hmsc->scsi_blk_size))
+    if (hmsc->cbw.dDataLength != (p_scsi_blk->len * p_scsi_blk->size))
     {
       SCSI_SenseCode(pdev, hmsc->cbw.bLUN, ILLEGAL_REQUEST, INVALID_CDB);
       return -1;
@@ -823,6 +856,7 @@ static int8_t SCSI_Read12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params
 static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
   uint32_t len;
 
   if (hmsc == NULL)
@@ -832,7 +866,7 @@ static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc->bot_state == USBD_BOT_IDLE) /* Idle */
@@ -864,22 +898,21 @@ static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
       return -1;
     }
 
-    hmsc->scsi_blk_addr = ((uint32_t)params[2] << 24) |
+    p_scsi_blk->addr = ((uint32_t)params[2] << 24) |
-                          ((uint32_t)params[3] << 16) |
+                       ((uint32_t)params[3] << 16) |
-                          ((uint32_t)params[4] << 8) |
+                       ((uint32_t)params[4] << 8) |
-                          (uint32_t)params[5];
+                       (uint32_t)params[5];
 
-    hmsc->scsi_blk_len = ((uint32_t)params[7] << 8) |
+    p_scsi_blk->len = ((uint32_t)params[7] << 8) |
-                         (uint32_t)params[8];
+                      (uint32_t)params[8];
 
     /* check if LBA address is in the right range */
-    if (SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr,
+    if (SCSI_CheckAddressRange(pdev, lun, p_scsi_blk->addr, p_scsi_blk->len) < 0)
-                               hmsc->scsi_blk_len) < 0)
     {
       return -1; /* error */
     }
 
-    len = hmsc->scsi_blk_len * hmsc->scsi_blk_size;
+    len = p_scsi_blk->len * p_scsi_blk->size;
 
     /* cases 3,11,13 : Hn,Ho <> D0 */
     if (hmsc->cbw.dDataLength != len)
@@ -913,6 +946,7 @@ static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
 static int8_t SCSI_Write12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
   uint32_t len;
 
   if (hmsc == NULL)
@@ -921,7 +955,7 @@ static int8_t SCSI_Write12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
   }
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmsc->bot_state == USBD_BOT_IDLE) /* Idle */
@@ -955,24 +989,23 @@ static int8_t SCSI_Write12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
       return -1;
     }
 
-    hmsc->scsi_blk_addr = ((uint32_t)params[2] << 24) |
+    p_scsi_blk->addr = ((uint32_t)params[2] << 24) |
-                          ((uint32_t)params[3] << 16) |
+                       ((uint32_t)params[3] << 16) |
-                          ((uint32_t)params[4] << 8) |
+                       ((uint32_t)params[4] << 8) |
-                          (uint32_t)params[5];
+                       (uint32_t)params[5];
 
-    hmsc->scsi_blk_len = ((uint32_t)params[6] << 24) |
+    p_scsi_blk->len = ((uint32_t)params[6] << 24) |
-                         ((uint32_t)params[7] << 16) |
+                      ((uint32_t)params[7] << 16) |
-                         ((uint32_t)params[8] << 8) |
+                      ((uint32_t)params[8] << 8) |
-                         (uint32_t)params[9];
+                      (uint32_t)params[9];
 
     /* check if LBA address is in the right range */
-    if (SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr,
+    if (SCSI_CheckAddressRange(pdev, lun, p_scsi_blk->addr, p_scsi_blk->len) < 0)
-                               hmsc->scsi_blk_len) < 0)
     {
       return -1; /* error */
     }
 
-    len = hmsc->scsi_blk_len * hmsc->scsi_blk_size;
+    len = p_scsi_blk->len * p_scsi_blk->size;
 
     /* cases 3,11,13 : Hn,Ho <> D0 */
     if (hmsc->cbw.dDataLength != len)
@@ -1006,6 +1039,7 @@ static int8_t SCSI_Write12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
 static int8_t SCSI_Verify10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
 
   if (hmsc == NULL)
   {
@@ -1014,11 +1048,11 @@ static int8_t SCSI_Verify10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *para
 
   if ((params[1] & 0x02U) == 0x02U)
   {
-    SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_FIELED_IN_COMMAND);
+    SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_FIELD_IN_COMMAND);
     return -1; /* Error, Verify Mode Not supported*/
   }
 
-  if (SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr, hmsc->scsi_blk_len) < 0)
+  if (SCSI_CheckAddressRange(pdev, lun, p_scsi_blk->addr, p_scsi_blk->len) < 0)
   {
     return -1; /* error */
   }
@@ -1028,6 +1062,90 @@ static int8_t SCSI_Verify10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *para
   return 0;
 }
 
+/**
+  * @brief  SCSI_ReportLuns12
+  *         Process ReportLuns command
+  * @retval status
+  */
+static int8_t SCSI_ReportLuns(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
+{
+  USBD_MSC_BOT_HandleTypeDef *hmsc;
+  uint32_t lun_list_length;
+  uint32_t total_length;
+  uint8_t lun_idx;
+
+  UNUSED(lun);
+  UNUSED(params);
+
+  /* Define the report LUNs buffer Each LUN entry is 8 bytes */
+  static uint8_t lun_report[8U * (MSC_BOT_MAX_LUN + 1U)];
+
+  hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+
+  if (hmsc == NULL)
+  {
+    return -1;
+  }
+
+  /* Initialize the report LUNs buffer */
+  (void)USBD_memset(lun_report, 0, sizeof(lun_report));
+
+  /* Set the LUN list length in the first 4 bytes */
+  lun_list_length = 8U * (hmsc->max_lun + 1U);
+  lun_report[0] = (uint8_t)(lun_list_length >> 24);
+  lun_report[1] = (uint8_t)(lun_list_length >> 16);
+  lun_report[2] = (uint8_t)(lun_list_length >> 8);
+  lun_report[3] = (uint8_t)(lun_list_length & 0xFFU);
+
+  /* Update the LUN list */
+  for (lun_idx = 0U; lun_idx <= hmsc->max_lun; lun_idx++)
+  {
+    /* LUN identifier is placed at the second byte of each 8-byte entry */
+    lun_report[(8U * (lun_idx + 1U)) + 1U] = lun_idx;
+  }
+
+  /* Calculate the total length of the report LUNs buffer */
+  total_length = lun_list_length + 8U;
+
+  /* Update the BOT data with the report LUNs buffer */
+  (void)SCSI_UpdateBotData(hmsc, lun_report, (uint16_t)total_length);
+
+  return 0;
+}
+
+/**
+  * @brief  SCSI_ReceiveDiagnosticResults
+  *         Process SCSI_Receive Diagnostic Results command
+  * @param  lun: Logical unit number
+  * @param  params: Command parameters
+  * @retval status
+  */
+static int8_t SCSI_ReceiveDiagnosticResults(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
+{
+  UNUSED(lun);
+  USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  uint16_t allocation_length;
+
+  /* Extract the allocation length from the CDB */
+  allocation_length = (((uint16_t)params[3] << 8) | (uint16_t)params[4]);
+
+  if (allocation_length == 0U)
+  {
+    return 0;
+  }
+
+  /* Ensure the allocation length does not exceed the diagnostic data length */
+  if (allocation_length > DIAGNOSTIC_DATA_LEN)
+  {
+    allocation_length = DIAGNOSTIC_DATA_LEN;
+  }
+
+  /* Send the diagnostic data to the host */
+  (void)SCSI_UpdateBotData(hmsc, MSC_Diagnostic_Data, allocation_length);
+
+  return 0;
+}
+
 /**
   * @brief  SCSI_CheckAddressRange
   *         Check address range
@@ -1040,13 +1158,14 @@ static int8_t SCSI_CheckAddressRange(USBD_HandleTypeDef *pdev, uint8_t lun,
                                      uint32_t blk_offset, uint32_t blk_nbr)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
-  if ((blk_offset + blk_nbr) > hmsc->scsi_blk_nbr)
+  if ((blk_offset + blk_nbr) > p_scsi_blk->nbr)
   {
     SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, ADDRESS_OUT_OF_RANGE);
     return -1;
@@ -1064,6 +1183,7 @@ static int8_t SCSI_CheckAddressRange(USBD_HandleTypeDef *pdev, uint8_t lun,
 static int8_t SCSI_ProcessRead(USBD_HandleTypeDef *pdev, uint8_t lun)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
   uint32_t len;
 
   if (hmsc == NULL)
@@ -1071,18 +1191,18 @@ static int8_t SCSI_ProcessRead(USBD_HandleTypeDef *pdev, uint8_t lun)
     return -1;
   }
 
-  len = hmsc->scsi_blk_len * hmsc->scsi_blk_size;
+  len = p_scsi_blk->len * p_scsi_blk->size;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MSCInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   len = MIN(len, MSC_MEDIA_PACKET);
 
   if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->Read(lun, hmsc->bot_data,
-                                                                    hmsc->scsi_blk_addr,
+                                                                    p_scsi_blk->addr,
-                                                                    (len / hmsc->scsi_blk_size)) < 0)
+                                                                    (len / p_scsi_blk->size)) < 0)
   {
     SCSI_SenseCode(pdev, lun, HARDWARE_ERROR, UNRECOVERED_READ_ERROR);
     return -1;
@@ -1090,13 +1210,13 @@ static int8_t SCSI_ProcessRead(USBD_HandleTypeDef *pdev, uint8_t lun)
 
   (void)USBD_LL_Transmit(pdev, MSCInEpAdd, hmsc->bot_data, len);
 
-  hmsc->scsi_blk_addr += (len / hmsc->scsi_blk_size);
+  p_scsi_blk->addr += (len / p_scsi_blk->size);
-  hmsc->scsi_blk_len -= (len / hmsc->scsi_blk_size);
+  p_scsi_blk->len -= (len / p_scsi_blk->size);
 
   /* case 6 : Hi = Di */
   hmsc->csw.dDataResidue -= len;
 
-  if (hmsc->scsi_blk_len == 0U)
+  if (p_scsi_blk->len == 0U)
   {
     hmsc->bot_state = USBD_BOT_LAST_DATA_IN;
   }
@@ -1113,6 +1233,7 @@ static int8_t SCSI_ProcessRead(USBD_HandleTypeDef *pdev, uint8_t lun)
 static int8_t SCSI_ProcessWrite(USBD_HandleTypeDef *pdev, uint8_t lun)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk = &hmsc->scsi_blk[lun];
   uint32_t len;
 
   if (hmsc == NULL)
@@ -1120,36 +1241,35 @@ static int8_t SCSI_ProcessWrite(USBD_HandleTypeDef *pdev, uint8_t lun)
     return -1;
   }
 
-  len = hmsc->scsi_blk_len * hmsc->scsi_blk_size;
+  len = p_scsi_blk->len * p_scsi_blk->size;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   len = MIN(len, MSC_MEDIA_PACKET);
 
-  if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->Write(lun, hmsc->bot_data,
+  if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->Write(lun, hmsc->bot_data, p_scsi_blk->addr,
-                                                                     hmsc->scsi_blk_addr,
+                                                                     (len / p_scsi_blk->size)) < 0)
-                                                                     (len / hmsc->scsi_blk_size)) < 0)
   {
     SCSI_SenseCode(pdev, lun, HARDWARE_ERROR, WRITE_FAULT);
     return -1;
   }
 
-  hmsc->scsi_blk_addr += (len / hmsc->scsi_blk_size);
+  p_scsi_blk->addr += (len / p_scsi_blk->size);
-  hmsc->scsi_blk_len -= (len / hmsc->scsi_blk_size);
+  p_scsi_blk->len -= (len / p_scsi_blk->size);
 
   /* case 12 : Ho = Do */
   hmsc->csw.dDataResidue -= len;
 
-  if (hmsc->scsi_blk_len == 0U)
+  if (p_scsi_blk->len == 0U)
   {
     MSC_BOT_SendCSW(pdev, USBD_CSW_CMD_PASSED);
   }
   else
   {
-    len = MIN((hmsc->scsi_blk_len * hmsc->scsi_blk_size), MSC_MEDIA_PACKET);
+    len = MIN((p_scsi_blk->len * p_scsi_blk->size), MSC_MEDIA_PACKET);
 
     /* Prepare EP to Receive next packet */
     (void)USBD_LL_PrepareReceive(pdev, MSCOutEpAdd, hmsc->bot_data, len);

Class/MTP/Inc/usbd_mtp.h

@@ -67,9 +67,12 @@ extern "C" {
 #define MTP_FS_BINTERVAL                                            0x10U
 #endif /* MTP_FS_BINTERVAL */
 
+#ifndef MTP_CMD_PACKET_SIZE
+#define MTP_CMD_PACKET_SIZE                                         8U  /* Control Endpoint Packet size */
+#endif /* MTP_CMD_PACKET_SIZE */
+
 #define MTP_DATA_MAX_HS_PACKET_SIZE                                 512U
 #define MTP_DATA_MAX_FS_PACKET_SIZE                                 64U         /* Endpoint IN & OUT Packet size */
-#define MTP_CMD_PACKET_SIZE                                         8U          /* Control Endpoint Packet size */
 
 #define MTP_MEDIA_PACKET                                            512U
 #define MTP_CONT_HEADER_SIZE                                        12U

Class/MTP/Inc/usbd_mtp_opt.h

@@ -283,7 +283,7 @@ extern "C" {
  * Appendix C. Device Properties
  */
 
-/* MTP device properties code*/
+/* MTP device properties code */
 #define    MTP_DEV_PROP_UNDEFINED                               0x5000U
 #define    MTP_DEV_PROP_BATTERY_LEVEL                           0x5001U
 #define    MTP_DEV_PROP_FUNCTIONAL_MODE                         0x5002U
@@ -336,7 +336,7 @@ extern "C" {
 #define    MTP_CONT_TYPE_EVENT                                  4U
 
 #ifndef    MTP_STORAGE_ID
-#define    MTP_STORAGE_ID                             0x00010001U   /* SD card is inserted*/
+#define    MTP_STORAGE_ID                                       0x00010001U   /* SD card is inserted */
 #endif  /* MTP_STORAGE_ID */
 
 #define    MTP_NBR_STORAGE_ID                                   1U

Class/MTP/Inc/usbd_mtp_storage.h

@@ -53,15 +53,16 @@ extern "C" {
 
 typedef enum
 {
-  DATA_TYPE = 0x00,
+  DATA_TYPE = 0x00U,
-  REP_TYPE = 0x01,
+  REP_TYPE = 0x01U,
 } MTP_CONTAINER_TYPE;
 
 
 typedef enum
 {
-  READ_FIRST_DATA = 0x00,
+  READ_FIRST_DATA = 0x00U,
-  READ_REST_OF_DATA = 0x01,
+  READ_REST_OF_DATA = 0x01U,
+  READ_SEND_ZLP_DATA = 0x02U
 } MTP_READ_DATA_STATUS;
 
 

Class/MTP/Src/usbd_mtp.c

@@ -128,6 +128,9 @@ USBD_ClassTypeDef USBD_MTP =
   USBD_MTP_GetOtherSpeedCfgDesc,
   USBD_MTP_GetDeviceQualifierDescriptor,
 #endif /* USE_USBD_COMPOSITE  */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -242,9 +245,9 @@ static uint8_t USBD_MTP_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MTPCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  MTPCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
 
@@ -292,9 +295,9 @@ static uint8_t USBD_MTP_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this MTP class instance */
-  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MTPCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR);
+  MTPCmdEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_INTR, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -338,7 +341,7 @@ static uint8_t USBD_MTP_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *re
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this MTP class instance */
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hmtp == NULL)
@@ -460,8 +463,8 @@ static uint8_t USBD_MTP_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this MTP class instance */
-  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (epnum == (MTPInEpAdd & 0x7FU))
@@ -516,7 +519,7 @@ static uint8_t USBD_MTP_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this MTP class instance */
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   (void)USBD_MTP_STORAGE_ReceiveOpt(pdev);

Class/MTP/Src/usbd_mtp_opt.c

@@ -537,50 +537,30 @@ static void MTP_Get_PayloadContent(USBD_HandleTypeDef *pdev)
 {
   USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   USBD_MTP_ItfTypeDef     *hmtpif = (USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId];
-  uint8_t *buffer = hmtp->GenericContainer.data;
+  uint8_t *buffer;
-  uint32_t i;
   uint32_t n_idx;
 
   switch (hmtp->OperationsContainer.code)
   {
     case MTP_OP_GET_DEVICE_INFO:
       (void)MTP_Get_DeviceInfo();
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_DeviceInfo, sizeof(MTP_DeviceInfo));
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_DeviceInfo,
-
+                        MIN(sizeof(MTP_DeviceInfo), MTP_MEDIA_PACKET));
-      for (i = 0U; i < sizeof(MTP_StorageIDS); i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_STORAGE_IDS:
       (void)MTP_Get_StorageIDS();
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_StorageIDS, sizeof(MTP_StorageIDS));
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_StorageIDS, sizeof(MTP_StorageIDS));
-
-      for (i = 0U; i < sizeof(MTP_StorageIDS); i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_STORAGE_INFO:
       (void)MTP_Get_StorageInfo(pdev);
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_StorageInfo, sizeof(MTP_StorageInfo));
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_StorageInfo, sizeof(MTP_StorageInfo));
-
-      for (i = 0U; i < sizeof(MTP_StorageInfo); i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_OBJECT_HANDLES:
       (void)MTP_Get_ObjectHandle(pdev);
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_ObjectHandle, hmtp->ResponseLength);
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_ObjectHandle, hmtp->ResponseLength);
-
-      for (i = 0U; i < hmtp->ResponseLength; i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_OBJECT_INFO:
@@ -589,12 +569,7 @@ static void MTP_Get_PayloadContent(USBD_HandleTypeDef *pdev)
 
     case MTP_OP_GET_OBJECT_PROPS_SUPPORTED:
       (void)MTP_Get_ObjectPropSupp();
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_ObjectPropSupp, sizeof(MTP_ObjectPropSupp));
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_ObjectPropSupp, sizeof(MTP_ObjectPropSupp));
-
-      for (i = 0U; i < sizeof(MTP_ObjectPropSupp); i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_OBJECT_PROP_DESC:
@@ -604,12 +579,7 @@ static void MTP_Get_PayloadContent(USBD_HandleTypeDef *pdev)
 
     case MTP_OP_GET_OBJECT_PROP_REFERENCES:
       MTP_Ref.ref_len = 0U;
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_Ref.ref_len, sizeof(MTP_Ref.ref_len));
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_Ref.ref_len, sizeof(MTP_Ref.ref_len));
-
-      for (i = 0U; i < sizeof(MTP_Ref.ref_len); i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_OBJECT_PROPLIST:
@@ -618,20 +588,13 @@ static void MTP_Get_PayloadContent(USBD_HandleTypeDef *pdev)
 
     case MTP_OP_GET_OBJECT_PROP_VALUE:
       buffer = MTP_Get_ObjectPropValue(pdev);
-      for (i = 0U; i < hmtp->ResponseLength; i++)
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)buffer, hmtp->ResponseLength);
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
-
       break;
 
     case MTP_OP_GET_DEVICE_PROP_DESC:
       (void)MTP_Get_DevicePropDesc();
-      (void)USBD_memcpy(buffer, (const uint8_t *)&MTP_DevicePropDesc, sizeof(MTP_DevicePropDesc));
+      (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&MTP_DevicePropDesc,
-      for (i = 0U; i < sizeof(MTP_DevicePropDesc); i++)
+                        MIN(sizeof(MTP_DevicePropDesc), MTP_MEDIA_PACKET));
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_SEND_OBJECT_INFO:
@@ -837,7 +800,7 @@ static void MTP_Get_ObjectPropDesc(USBD_HandleTypeDef  *pdev)
 
     case MTP_OB_PROP_PARENT_OBJECT :
       MTP_ObjectPropDesc.ObjectPropertyCode = (uint16_t)(hmtp->OperationsContainer.Param1);
-      MTP_ObjectPropDesc.DataType = MTP_DATATYPE_STR;
+      MTP_ObjectPropDesc.DataType = MTP_DATATYPE_UINT32;
       MTP_ObjectPropDesc.GetSet = MTP_PROP_GET;
       MTP_ObjectPropDesc.DefValue = 0U;
       MTP_ObjectPropDesc.GroupCode = 0U;
@@ -951,8 +914,8 @@ static uint8_t *MTP_Get_ObjectPropValue(USBD_HandleTypeDef *pdev)
   */
 static void MTP_Get_ObjectPropList(USBD_HandleTypeDef  *pdev)
 {
-  USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MTP_HandleTypeDef *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
-  USBD_MTP_ItfTypeDef     *hmtpif = (USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId];
+  USBD_MTP_ItfTypeDef    *hmtpif = (USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId];
   uint16_t filename[255];
   uint32_t storageid = MTP_STORAGE_ID;
   uint32_t default_val = 0U;
@@ -960,6 +923,7 @@ static void MTP_Get_ObjectPropList(USBD_HandleTypeDef  *pdev)
   uint16_t format;
   uint64_t objsize;
   uint32_t parent_proval;
+  uint8_t mtp_pers_uniq_obj_id[16] = {0};
 
   MTP_PropertiesList.MTP_Properties_len = SUPP_OBJ_PROP_LEN;
   hmtp->ResponseLength = 4U;    /* size of MTP_PropertiesList.MTP_Properties_len */
@@ -1020,9 +984,13 @@ static void MTP_Get_ObjectPropList(USBD_HandleTypeDef  *pdev)
         break;
 
       case MTP_OB_PROP_PERS_UNIQ_OBJ_IDEN :
+        /* Fill in the first 4 bytes with Param1 (Object ID) */
+        (void)USBD_memcpy(mtp_pers_uniq_obj_id, &hmtp->OperationsContainer.Param1,
+                          sizeof(hmtp->OperationsContainer.Param1));
+
         MTP_PropertiesList.MTP_Properties[i].PropertyCode = MTP_OB_PROP_PERS_UNIQ_OBJ_IDEN;
         MTP_PropertiesList.MTP_Properties[i].Datatype = MTP_DATATYPE_UINT128;
-        MTP_PropertiesList.MTP_Properties[i].propval = (uint8_t *)&hmtp->OperationsContainer.Param1;
+        MTP_PropertiesList.MTP_Properties[i].propval = (uint8_t *)mtp_pers_uniq_obj_id;
         break;
 
       case MTP_OB_PROP_PROTECTION_STATUS :
@@ -1187,7 +1155,8 @@ static uint32_t MTP_build_data_proplist(USBD_HandleTypeDef  *pdev,
                                         MTP_PropertiesListTypedef proplist, uint32_t idx)
 {
   USBD_MTP_HandleTypeDef *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
-  uint8_t propval_size = (MTP_FileName.FileName_len * 2U) + 1U;
+  uint8_t *propval = proplist.MTP_Properties[idx].propval;
+  uint8_t propval_size = (propval[0] * 2U) + 1U;
   uint32_t dataLength;
 
   dataLength = offsetof(MTP_PropertiesTypedef, propval);

Class/MTP/Src/usbd_mtp_storage.c

@@ -50,7 +50,7 @@ uint8_t USBD_MTP_STORAGE_Init(USBD_HandleTypeDef  *pdev)
   USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Initialize the HW layyer of the file system */
@@ -95,26 +95,38 @@ uint8_t USBD_MTP_STORAGE_ReadData(USBD_HandleTypeDef  *pdev)
 {
   USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   uint32_t *data_buff;
+  uint32_t buffer_size;
 
   /* Get the data buffer pointer from the low layer interface */
   data_buff = ((USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId])->ScratchBuff;
 
+  /* Get Data Buffer Size */
+  buffer_size = ((USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId])->ScratchBuffSze;
+
+  if ((data_buff == NULL) || (buffer_size < MTP_CONT_HEADER_SIZE))
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
   switch (ReadDataStatus)
   {
     case READ_FIRST_DATA:
       /* Reset the data length */
       MTP_DataLength.temp_length = 0U;
 
-      /* Perform the low layer read operation on the scratch buffer */
-      (void)((USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId])->ReadData(hmtp->OperationsContainer.Param1,
-                                                                              (uint8_t *)data_buff, &MTP_DataLength);
-
       /* Add the container header to the data buffer */
       (void)USBD_memcpy((uint8_t *)data_buff, (uint8_t *)&hmtp->GenericContainer, MTP_CONT_HEADER_SIZE);
 
+      /* Perform the low layer read operation on the scratch buffer
+       * first packet expected data length: MPS - MTP_CONT_HEADER_SIZE
+       */
+      (void)((USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId])->ReadData(hmtp->OperationsContainer.Param1,
+                                                                              (uint8_t *)data_buff +
+                                                                              MTP_CONT_HEADER_SIZE, &MTP_DataLength);
+
       /* Start USB data transmission to the host */
       (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)data_buff,
-                                      MTP_DataLength.readbytes + MTP_CONT_HEADER_SIZE);
+                                      MIN((MTP_DataLength.readbytes + MTP_CONT_HEADER_SIZE), buffer_size));
 
       /* Check if this will be the last packet to send ? */
       if (MTP_DataLength.readbytes < ((uint32_t)hmtp->MaxPcktLen - MTP_CONT_HEADER_SIZE))
@@ -138,24 +150,45 @@ uint8_t USBD_MTP_STORAGE_ReadData(USBD_HandleTypeDef  *pdev)
       if (MTP_DataLength.temp_length == MTP_DataLength.totallen)
       {
         /* Start USB data transmission to the host */
-        (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)data_buff, MTP_DataLength.readbytes);
+        (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)data_buff, MIN(MTP_DataLength.readbytes, buffer_size));
 
-        /* Move to response phase */
+        if (((MTP_DataLength.totallen + MTP_CONT_HEADER_SIZE) % hmtp->MaxPcktLen) == 0U)
-        hmtp->MTP_ResponsePhase = MTP_RESPONSE_PHASE;
+        {
+          /* Send ZLP Packet */
+          ReadDataStatus = READ_SEND_ZLP_DATA;
+        }
+        else
+        {
+          /* Move to response phase */
+          hmtp->MTP_ResponsePhase = MTP_RESPONSE_PHASE;
 
-        /* Reset the stat machine */
+          /* Reset the state machine */
-        ReadDataStatus = READ_FIRST_DATA;
+          ReadDataStatus = READ_FIRST_DATA;
+        }
       }
       else
       {
         /* Start USB data transmission to the host */
-        (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)data_buff, MTP_DataLength.readbytes);
+        (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)data_buff, MIN(MTP_DataLength.readbytes, buffer_size));
 
         /* Keep the state machine into sending next packet of data */
         ReadDataStatus = READ_REST_OF_DATA;
       }
       break;
 
+    case READ_SEND_ZLP_DATA:
+
+      /* Send ZLP to the host */
+      (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)data_buff, 0U);
+
+      /* Move to response phase */
+      hmtp->MTP_ResponsePhase = MTP_RESPONSE_PHASE;
+
+      /* Reset the state machine */
+      ReadDataStatus = READ_FIRST_DATA;
+
+      break;
+
     default:
       break;
   }
@@ -176,7 +209,8 @@ uint8_t USBD_MTP_STORAGE_SendContainer(USBD_HandleTypeDef  *pdev, MTP_CONTAINER_
   {
     case DATA_TYPE:
       /* send header + data : hmtp->ResponseLength = header size + data size */
-      (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)&hmtp->GenericContainer, hmtp->ResponseLength);
+      (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)&hmtp->GenericContainer, MIN(sizeof(MTP_GenericContainerTypeDef),
+                                                                                    hmtp->ResponseLength));
       break;
     case REP_TYPE:
       /* send header without data */
@@ -185,7 +219,8 @@ uint8_t USBD_MTP_STORAGE_SendContainer(USBD_HandleTypeDef  *pdev, MTP_CONTAINER_
       hmtp->GenericContainer.length = hmtp->ResponseLength;
       hmtp->GenericContainer.type = MTP_CONT_TYPE_RESPONSE;
 
-      (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)&hmtp->GenericContainer, hmtp->ResponseLength);
+      (void)USBD_MTP_STORAGE_SendData(pdev, (uint8_t *)&hmtp->GenericContainer, MIN(sizeof(MTP_GenericContainerTypeDef),
+                                                                                    hmtp->ResponseLength));
       break;
     default:
       break;
@@ -205,7 +240,7 @@ uint8_t USBD_MTP_STORAGE_ReceiveOpt(USBD_HandleTypeDef  *pdev)
   uint32_t *pMsgBuffer;
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  MTPOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
   MTP_DataLength.rx_length = USBD_GetRxCount(pdev, MTPOutEpAdd);
 
@@ -245,7 +280,7 @@ uint8_t USBD_MTP_STORAGE_ReceiveOpt(USBD_HandleTypeDef  *pdev)
   */
 uint8_t USBD_MTP_STORAGE_ReceiveData(USBD_HandleTypeDef  *pdev)
 {
-  USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MTP_HandleTypeDef *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   switch (hmtp->RECEIVE_DATA_STATUS)
   {
     case RECEIVE_COMMAND_DATA :
@@ -410,15 +445,21 @@ static uint8_t USBD_MTP_STORAGE_DecodeOperations(USBD_HandleTypeDef  *pdev)
 static uint8_t USBD_MTP_STORAGE_ReceiveContainer(USBD_HandleTypeDef  *pdev,
                                                  uint32_t *pDst, uint32_t len)
 {
-  USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MTP_HandleTypeDef *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   uint32_t Counter;
   uint32_t *pdst = pDst;
 
-  for (Counter = 0; Counter < len; Counter++)
+  if ((pDst == NULL) || (len > MTP_MEDIA_PACKET))
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
+  for (Counter = 0U; Counter < len; Counter++)
   {
     *pdst = (hmtp->rx_buff[Counter]);
     pdst++;
   }
+
   return (uint8_t)USBD_OK;
 }
 
@@ -456,17 +497,14 @@ void USBD_MTP_STORAGE_Cancel(USBD_HandleTypeDef  *pdev,
   * @param  len: Data Length
   * @retval status value
   */
-static uint8_t USBD_MTP_STORAGE_SendData(USBD_HandleTypeDef  *pdev, uint8_t *buf,
+static uint8_t USBD_MTP_STORAGE_SendData(USBD_HandleTypeDef *pdev, uint8_t *buf, uint32_t len)
-                                         uint32_t len)
 {
-  USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
-  uint32_t length = MIN(hmtp->GenericContainer.length, len);
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  MTPInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  MTPInEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
-  (void)USBD_LL_Transmit(pdev, MTPInEpAdd, buf, length);
+  (void)USBD_LL_Transmit(pdev, MTPInEpAdd, buf, len);
 
   return (uint8_t)USBD_OK;
 }

Class/Printer/Src/usbd_printer.c

@@ -141,6 +141,9 @@ USBD_ClassTypeDef USBD_PRNT =
   USBD_PRNT_GetOtherSpeedCfgDesc,
   USBD_PRNT_GetDeviceQualifierDescriptor,
 #endif /* USE_USBD_COMPOSITE */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 #ifndef USE_USBD_COMPOSITE
@@ -249,8 +252,8 @@ static uint8_t USBD_PRNT_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  PRNTInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  PRNTInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  PRNTOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  PRNTOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Setup the max packet size according to selected speed */
@@ -305,8 +308,8 @@ static uint8_t USBD_PRNT_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  PRNTInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  PRNTInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  PRNTOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  PRNTOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -622,8 +625,8 @@ uint8_t USBD_PRNT_ReceivePacket(USBD_HandleTypeDef *pdev)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  PRNTInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK);
+  PRNTInEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
-  PRNTOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK);
+  PRNTOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   if (hPRNT == NULL)

Class/VIDEO/Inc/usbd_video.h

@@ -377,7 +377,8 @@ typedef struct
 {
   uint32_t                   interface;
   uint32_t                   uvc_state;
-  uint8_t                    buffer[UVC_TOTAL_BUF_SIZE];
+  uint32_t                   uvc_size;
+  uint8_t                    *uvc_buffer;
   VIDEO_OffsetTypeDef        offset;
   USBD_VIDEO_ControlTypeDef  control;
 } USBD_VIDEO_HandleTypeDef;

Class/VIDEO/Src/usbd_video.c

@@ -140,6 +140,9 @@ USBD_ClassTypeDef  USBD_VIDEO =
   USBD_VIDEO_GetOtherSpeedCfgDesc,
   USBD_VIDEO_GetDeviceQualifierDesc,
 #endif /* USE_USBD_COMPOSITE */
+#if (USBD_SUPPORT_USER_STRING_DESC == 1U)
+  NULL,
+#endif /* USBD_SUPPORT_USER_STRING_DESC  */
 };
 
 /* USB VIDEO device Configuration Descriptor (same for all speeds thanks to user defines) */
@@ -414,7 +417,7 @@ static uint8_t USBD_VIDEO_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  VIDEOinEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC);
+  VIDEOinEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Open EP IN */
@@ -466,7 +469,7 @@ static uint8_t USBD_VIDEO_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
-  VIDEOinEpAdd  = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC);
+  VIDEOinEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
 #endif /* USE_USBD_COMPOSITE */
 
   /* Close EP IN */
@@ -498,6 +501,11 @@ static uint8_t USBD_VIDEO_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *
   uint16_t len;
   uint8_t *pbuf;
 
+#ifdef USE_USBD_COMPOSITE
+  /* Get the Endpoints addresses allocated for this class instance */
+  VIDEOinEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
+#endif /* USE_USBD_COMPOSITE */
+
   switch (req->bmRequest & USB_REQ_TYPE_MASK)
   {
     /* Class Requests -------------------------------*/
@@ -640,7 +648,13 @@ static uint8_t  USBD_VIDEO_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
   static uint16_t PcktSze = UVC_PACKET_SIZE;
   static uint8_t  payload_header[2] = {0x02U, 0x00U};
   uint8_t i = 0U;
-  uint32_t RemainData, DataOffset = 0U;
+  uint32_t RemainData = 0U;
+  uint32_t DataOffset = 0U;
+
+#ifdef USE_USBD_COMPOSITE
+  /* Get the Endpoints addresses allocated for this class instance */
+  VIDEOinEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
+#endif /* USE_USBD_COMPOSITE */
 
   /* Check if the Streaming has already been started */
   if (hVIDEO->uvc_state == UVC_PLAY_STATUS_STREAMING)
@@ -691,9 +705,12 @@ static uint8_t  USBD_VIDEO_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
       packet[1] = payload_header[1];
     }
 
+    hVIDEO->uvc_buffer = (uint8_t *)&packet;
+    hVIDEO->uvc_size = (uint32_t)PcktSze;
+
     /* Transmit the packet on Endpoint */
     (void)USBD_LL_Transmit(pdev, (uint8_t)(epnum | 0x80U),
-                           (uint8_t *)&packet, (uint32_t)PcktSze);
+                           hVIDEO->uvc_buffer, hVIDEO->uvc_size);
   }
 
   /* Exit with no error code */
@@ -711,11 +728,19 @@ static uint8_t  USBD_VIDEO_SOF(USBD_HandleTypeDef *pdev)
   USBD_VIDEO_HandleTypeDef *hVIDEO = (USBD_VIDEO_HandleTypeDef *) pdev->pClassDataCmsit[pdev->classId];
   uint8_t payload[2] = {0x02U, 0x00U};
 
+#ifdef USE_USBD_COMPOSITE
+  /* Get the Endpoints addresses allocated for this class instance */
+  VIDEOinEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
+#endif /* USE_USBD_COMPOSITE */
+
   /* Check if the Streaming has already been started by SetInterface AltSetting 1 */
   if (hVIDEO->uvc_state == UVC_PLAY_STATUS_READY)
   {
+    hVIDEO->uvc_buffer = (uint8_t *)&payload;
+    hVIDEO->uvc_size = 2U;
+
     /* Transmit the first packet indicating that Streaming is starting */
-    (void)USBD_LL_Transmit(pdev, VIDEOinEpAdd, (uint8_t *)payload, 2U);
+    (void)USBD_LL_Transmit(pdev, VIDEOinEpAdd, hVIDEO->uvc_buffer, hVIDEO->uvc_size);
 
     /* Enable Streaming state */
     hVIDEO->uvc_state = UVC_PLAY_STATUS_STREAMING;
@@ -734,8 +759,17 @@ static uint8_t  USBD_VIDEO_SOF(USBD_HandleTypeDef *pdev)
   */
 static uint8_t USBD_VIDEO_IsoINIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum)
 {
-  UNUSED(pdev);
+  USBD_VIDEO_HandleTypeDef *hVIDEO = (USBD_VIDEO_HandleTypeDef *) pdev->pClassDataCmsit[pdev->classId];
-  UNUSED(epnum);
+
+#ifdef USE_USBD_COMPOSITE
+  /* Get the Endpoints addresses allocated for this class instance */
+  VIDEOinEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_IN, USBD_EP_TYPE_ISOC, (uint8_t)pdev->classId);
+#endif /* USE_USBD_COMPOSITE */
+
+  if (epnum == (VIDEOinEpAdd & 0xFU))
+  {
+    (void)USBD_LL_Transmit(pdev, VIDEOinEpAdd, hVIDEO->uvc_buffer, hVIDEO->uvc_size);
+  }
 
   return (uint8_t)USBD_OK;
 }
@@ -836,19 +870,18 @@ static void VIDEO_REQ_GetCurrent(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef
   */
 static void VIDEO_REQ_SetCurrent(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
-  USBD_VIDEO_HandleTypeDef *hVIDEO = (USBD_VIDEO_HandleTypeDef *)(pdev->pClassDataCmsit[pdev->classId]);
 
   /* Check that the request has control data */
   if (req->wLength > 0U)
   {
     /* Prepare the reception of the buffer over EP0 */
-    if (LOBYTE(req->wValue) == (uint8_t)VS_PROBE_CONTROL)
+    if (req->wValue == (uint16_t)VS_PROBE_CONTROL)
     {
       /* Probe Request */
       (void) USBD_CtlPrepareRx(pdev, (uint8_t *)&video_Probe_Control,
                                MIN(req->wLength, sizeof(USBD_VideoControlTypeDef)));
     }
-    else if (LOBYTE(req->wValue) == (uint8_t)VS_COMMIT_CONTROL)
+    else if (req->wValue == (uint16_t)VS_COMMIT_CONTROL)
     {
       /* Commit Request */
       (void) USBD_CtlPrepareRx(pdev, (uint8_t *)&video_Commit_Control,
@@ -856,9 +889,7 @@ static void VIDEO_REQ_SetCurrent(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef
     }
     else
     {
-      /* Prepare the reception of the buffer over EP0 */
+      (void)USBD_LL_StallEP(pdev, 0x80U);
-      (void) USBD_CtlPrepareRx(pdev, hVIDEO->control.data,
-                               MIN(req->wLength, USB_MAX_EP0_SIZE));
     }
   }
 }

Class/VIDEO/Src/usbd_video_if_template.c

@@ -234,14 +234,16 @@ static int8_t VIDEO_Itf_Data(uint8_t **pbuf, uint16_t *psize, uint16_t *pcktidx)
     *psize = (uint16_t)UVC_PACKET_SIZE;
 
     /* Get the pointer to the next packet to be transmitted */
-    *pbuf = (uint8_t *)(*(ImagePtr + img_count) + (packet_index * ((uint16_t)(UVC_PACKET_SIZE - (UVC_HEADER_PACKET_CNT * 2U)))));
+    *pbuf = (uint8_t *)(*(ImagePtr + img_count) + \
+                        (packet_index * ((uint16_t)(UVC_PACKET_SIZE - (UVC_HEADER_PACKET_CNT * 2U)))));
   }
   else if ((packet_index == packet_count))
   {
     if (packet_remainder != 0U)
     {
       /* Get the pointer to the next packet to be transmitted */
-      *pbuf = (uint8_t *)(*(ImagePtr + img_count) + (packet_index * ((uint16_t)(UVC_PACKET_SIZE - (UVC_HEADER_PACKET_CNT * 2U)))));
+      *pbuf = (uint8_t *)(*(ImagePtr + img_count) + \
+                          (packet_index * ((uint16_t)(UVC_PACKET_SIZE - (UVC_HEADER_PACKET_CNT * 2U)))));
 
       /* Set the current packet size */
       *psize = (uint16_t)(packet_remainder + (UVC_HEADER_PACKET_CNT * 2U));

Core/Inc/usbd_conf_template.h

@@ -48,6 +48,7 @@ extern "C" {
 #define USBD_MAX_STR_DESC_SIZ                       0x100U
 #define USBD_SELF_POWERED                           1U
 #define USBD_DEBUG_LEVEL                            2U
+/* #define USBD_USER_REGISTER_CALLBACK                 1U */
 
 /* ECM, RNDIS, DFU Class Config */
 #define USBD_SUPPORT_USER_STRING_DESC               1U
@@ -64,6 +65,8 @@ extern "C" {
 #define USBD_CDC_INTERVAL                           2000U
 
 /* DFU Class Config */
+/* #define USBD_DFU_VENDOR_CMD_ENABLED                 1U */
+/* #define USBD_DFU_VENDOR_EXIT_ENABLED                1U */
 #define USBD_DFU_MAX_ITF_NUM                        1U
 #define USBD_DFU_XFERS_IZE                          1024U
 
@@ -76,6 +79,13 @@ extern "C" {
 #define USBD_CUSTOMHID_OUTREPORT_BUF_SIZE           0x02U
 #define USBD_CUSTOM_HID_REPORT_DESC_SIZE            163U
 
+/* #define USBD_CUSTOMHID_REPORT_DESC_SIZE_ENABLED */
+/* #define USBD_CUSTOMHID_CTRL_REQ_GET_REPORT_ENABLED */
+/* #define USBD_CUSTOMHID_OUT_PREPARE_RECEIVE_DISABLED */
+/* #define USBD_CUSTOMHID_EP0_OUT_PREPARE_RECEIVE_DISABLED */
+/* #define USBD_CUSTOMHID_CTRL_REQ_COMPLETE_CALLBACK_ENABLED */
+/* #define USBD_CUSTOMHID_REPORT_BUFFER_EVENT_ENABLED */
+
 /* VIDEO Class Config */
 #define UVC_1_1 /* #define UVC_1_0 */
 

Core/Inc/usbd_core.h

@@ -86,13 +86,16 @@ USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev);
 USBD_StatusTypeDef USBD_Start(USBD_HandleTypeDef *pdev);
 USBD_StatusTypeDef USBD_Stop(USBD_HandleTypeDef *pdev);
 USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass);
+#if (USBD_USER_REGISTER_CALLBACK == 1U)
+USBD_StatusTypeDef USBD_RegisterDevStateCallback(USBD_HandleTypeDef *pdev, USBD_DevStateCallbackTypeDef pUserCallback);
+#endif /* USBD_USER_REGISTER_CALLBACK */
 
 #ifdef USE_USBD_COMPOSITE
 USBD_StatusTypeDef  USBD_RegisterClassComposite(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass,
                                                 USBD_CompositeClassTypeDef classtype, uint8_t *EpAddr);
 
 USBD_StatusTypeDef  USBD_UnRegisterClassComposite(USBD_HandleTypeDef *pdev);
-uint8_t USBD_CoreGetEPAdd(USBD_HandleTypeDef *pdev, uint8_t ep_dir, uint8_t ep_type);
+uint8_t USBD_CoreGetEPAdd(USBD_HandleTypeDef *pdev, uint8_t ep_dir, uint8_t ep_type, uint8_t ClassId);
 #endif /* USE_USBD_COMPOSITE */
 
 uint8_t USBD_CoreFindIF(USBD_HandleTypeDef *pdev, uint8_t index);

Core/Inc/usbd_def.h

@@ -305,12 +305,13 @@ typedef struct
 /* USB Device handle structure */
 typedef struct
 {
-  uint32_t status;
   uint32_t total_length;
   uint32_t rem_length;
-  uint32_t maxpacket;
+  uint32_t bInterval;
-  uint16_t is_used;
+  uint16_t maxpacket;
-  uint16_t bInterval;
+  uint8_t status;
+  uint8_t is_used;
+  uint8_t *pbuffer;
 } USBD_EndpointTypeDef;
 
 #ifdef USE_USBD_COMPOSITE
@@ -390,8 +391,15 @@ typedef struct _USBD_HandleTypeDef
 #ifdef USE_USBD_COMPOSITE
   USBD_CompositeElementTypeDef tclasslist[USBD_MAX_SUPPORTED_CLASS];
 #endif /* USE_USBD_COMPOSITE */
+#if (USBD_USER_REGISTER_CALLBACK == 1U)
+  void (* DevStateCallback)(uint8_t dev_state, uint8_t cfgidx);                    /*!< User Notification callback      */
+#endif /* USBD_USER_REGISTER_CALLBACK */
 } USBD_HandleTypeDef;
 
+#if (USBD_USER_REGISTER_CALLBACK == 1U)
+typedef void (*USBD_DevStateCallbackTypeDef)(uint8_t dev_state, uint8_t cfgidx);   /*!< pointer to User callback function  */
+#endif /* USBD_USER_REGISTER_CALLBACK */
+
 /* USB Device endpoint direction */
 typedef enum
 {
@@ -416,7 +424,9 @@ typedef enum
   */
 __STATIC_INLINE uint16_t SWAPBYTE(uint8_t *addr)
 {
-  uint16_t _SwapVal, _Byte1, _Byte2;
+  uint16_t _SwapVal;
+  uint16_t _Byte1;
+  uint16_t _Byte2;
   uint8_t *_pbuff = addr;
 
   _Byte1 = *(uint8_t *)_pbuff;

Core/Inc/usbd_desc_template.h

@@ -25,6 +25,10 @@
 
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
+/*
+ * User to provide a unique ID to define the USB device serial number
+ * The use of UID_BASE register can be considered as an example
+ */
 #define         DEVICE_ID1          (UID_BASE)
 #define         DEVICE_ID2          (UID_BASE + 0x4U)
 #define         DEVICE_ID3          (UID_BASE + 0x8U)

Core/Src/usbd_conf_template.c

@@ -256,6 +256,7 @@ USBD_StatusTypeDef USBD_LL_SetTestMode(USBD_HandleTypeDef *pdev, uint8_t testmod
   */
 void *USBD_static_malloc(uint32_t size)
 {
+  UNUSED(size);
   static uint32_t mem[(sizeof(USBD_HID_HandleTypeDef) / 4) + 1]; /* On 32-bit boundary */
   return mem;
 }
@@ -267,7 +268,7 @@ void *USBD_static_malloc(uint32_t size)
   */
 void USBD_static_free(void *p)
 {
-
+  UNUSED(p);
 }
 
 /**

Core/Src/usbd_core.c

@@ -83,11 +83,11 @@
 
 /**
   * @brief  USBD_Init
-  *         Initializes the device stack and load the class driver
+  *         Initialize the device stack and load the class driver
   * @param  pdev: device instance
   * @param  pdesc: Descriptor structure address
   * @param  id: Low level core index
-  * @retval None
+  * @retval status: USBD Status
   */
 USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev,
                              USBD_DescriptorsTypeDef *pdesc, uint8_t id)
@@ -142,9 +142,9 @@ USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev,
 
 /**
   * @brief  USBD_DeInit
-  *         Re-Initialize the device library
+  *         De-Initialize the device library
   * @param  pdev: device instance
-  * @retval status: status
+  * @retval status: USBD Status
   */
 USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev)
 {
@@ -195,7 +195,7 @@ USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev)
 /**
   * @brief  USBD_RegisterClass
   *         Link class driver to Device Core.
-  * @param  pDevice : Device Handle
+  * @param  pdev: Device Handle
   * @param  pclass: Class handle
   * @retval USBD Status
   */
@@ -228,7 +228,7 @@ USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDe
 #endif /* USE_USB_FS */
 
   /* Increment the NumClasses */
-  pdev->NumClasses ++;
+  pdev->NumClasses++;
 
   return USBD_OK;
 }
@@ -243,10 +243,10 @@ USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDe
   * @param  EpAddr: Endpoint Address handle
   * @retval USBD Status
   */
-USBD_StatusTypeDef  USBD_RegisterClassComposite(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass,
+USBD_StatusTypeDef USBD_RegisterClassComposite(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass,
-                                                USBD_CompositeClassTypeDef classtype, uint8_t *EpAddr)
+                                               USBD_CompositeClassTypeDef classtype, uint8_t *EpAddr)
 {
-  USBD_StatusTypeDef   ret = USBD_OK;
+  USBD_StatusTypeDef ret = USBD_OK;
   uint16_t len = 0U;
 
   if ((pdev->classId < USBD_MAX_SUPPORTED_CLASS) && (pdev->NumClasses < USBD_MAX_SUPPORTED_CLASS))
@@ -291,12 +291,12 @@ USBD_StatusTypeDef  USBD_RegisterClassComposite(USBD_HandleTypeDef *pdev, USBD_C
 /**
   * @brief  USBD_UnRegisterClassComposite
   *         UnLink all composite class drivers from Device Core.
-  * @param  pDevice : Device Handle
+  * @param  pdev: Device Handle
   * @retval USBD Status
   */
 USBD_StatusTypeDef  USBD_UnRegisterClassComposite(USBD_HandleTypeDef *pdev)
 {
-  USBD_StatusTypeDef   ret = USBD_FAIL;
+  USBD_StatusTypeDef   ret = USBD_OK;
   uint8_t idx1;
   uint8_t idx2;
 
@@ -358,10 +358,23 @@ USBD_StatusTypeDef  USBD_UnRegisterClassComposite(USBD_HandleTypeDef *pdev)
 
   return ret;
 }
-
-
 #endif /* USE_USBD_COMPOSITE */
 
+#if (USBD_USER_REGISTER_CALLBACK == 1U)
+/**
+  * @brief  USBD_RegisterDevStateCallback
+  * @param  pdev : Device Handle
+  * @param  pUserCallback: User Callback
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_RegisterDevStateCallback(USBD_HandleTypeDef *pdev, USBD_DevStateCallbackTypeDef pUserCallback)
+{
+  pdev->DevStateCallback = pUserCallback;
+
+  return USBD_OK;
+}
+#endif /* USBD_USER_REGISTER_CALLBACK */
+
 /**
   * @brief  USBD_Start
   *         Start the USB Device Core.
@@ -487,7 +500,7 @@ USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   *         Clear current configuration
   * @param  pdev: device instance
   * @param  cfgidx: configuration index
-  * @retval status: USBD_StatusTypeDef
+  * @retval status
   */
 USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
 {
@@ -527,6 +540,7 @@ USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
   * @brief  USBD_LL_SetupStage
   *         Handle the setup stage
   * @param  pdev: device instance
+  * @param  psetup: setup packet buffer pointer
   * @retval status
   */
 USBD_StatusTypeDef USBD_LL_SetupStage(USBD_HandleTypeDef *pdev, uint8_t *psetup)
@@ -576,6 +590,8 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
   USBD_StatusTypeDef ret = USBD_OK;
   uint8_t idx;
 
+  UNUSED(pdata);
+
   if (epnum == 0U)
   {
     pep = &pdev->ep_out[0];
@@ -585,8 +601,9 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
       if (pep->rem_length > pep->maxpacket)
       {
         pep->rem_length -= pep->maxpacket;
+        pep->pbuffer += pep->maxpacket;
 
-        (void)USBD_CtlContinueRx(pdev, pdata, MIN(pep->rem_length, pep->maxpacket));
+        (void)USBD_CtlContinueRx(pdev, pep->pbuffer, MAX(pep->rem_length, pep->maxpacket));
       }
       else
       {
@@ -629,19 +646,6 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
         (void)USBD_CtlSendStatus(pdev);
       }
     }
-    else
-    {
-#if 0
-      if (pdev->ep0_state == USBD_EP0_STATUS_OUT)
-      {
-        /*
-          * STATUS PHASE completed, update ep0_state to idle
-          */
-        pdev->ep0_state = USBD_EP0_IDLE;
-        (void)USBD_LL_StallEP(pdev, 0U);
-      }
-#endif
-    }
   }
   else
   {
@@ -674,6 +678,7 @@ USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
   *         Handle data in stage
   * @param  pdev: device instance
   * @param  epnum: endpoint index
+  * @param  pdata: data pointer
   * @retval status
   */
 USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
@@ -683,6 +688,8 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
   USBD_StatusTypeDef ret;
   uint8_t idx;
 
+  UNUSED(pdata);
+
   if (epnum == 0U)
   {
     pep = &pdev->ep_in[0];
@@ -692,8 +699,9 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
       if (pep->rem_length > pep->maxpacket)
       {
         pep->rem_length -= pep->maxpacket;
+        pep->pbuffer += pep->maxpacket;
 
-        (void)USBD_CtlContinueSendData(pdev, pdata, pep->rem_length);
+        (void)USBD_CtlContinueSendData(pdev, pep->pbuffer, pep->rem_length);
 
         /* Prepare endpoint for premature end of transfer */
         (void)USBD_LL_PrepareReceive(pdev, 0U, NULL, 0U);
@@ -726,16 +734,6 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
         }
       }
     }
-    else
-    {
-#if 0
-      if ((pdev->ep0_state == USBD_EP0_STATUS_IN) ||
-          (pdev->ep0_state == USBD_EP0_IDLE))
-      {
-        (void)USBD_LL_StallEP(pdev, 0x80U);
-      }
-#endif
-    }
 
     if (pdev->dev_test_mode != 0U)
     {
@@ -776,7 +774,6 @@ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev,
   * @param  pdev: device instance
   * @retval status
   */
-
 USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef *pdev)
 {
   USBD_StatusTypeDef ret = USBD_OK;
@@ -859,10 +856,13 @@ USBD_StatusTypeDef USBD_LL_SetSpeed(USBD_HandleTypeDef *pdev,
   * @param  pdev: device instance
   * @retval status
   */
-
 USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef *pdev)
 {
-  pdev->dev_old_state = pdev->dev_state;
+  if (pdev->dev_state != USBD_STATE_SUSPENDED)
+  {
+    pdev->dev_old_state = pdev->dev_state;
+  }
+
   pdev->dev_state = USBD_STATE_SUSPENDED;
 
   return USBD_OK;
@@ -874,7 +874,6 @@ USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef *pdev)
   * @param  pdev: device instance
   * @retval status
   */
-
 USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef *pdev)
 {
   if (pdev->dev_state == USBD_STATE_SUSPENDED)
@@ -891,7 +890,6 @@ USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef *pdev)
   * @param  pdev: device instance
   * @retval status
   */
-
 USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef *pdev)
 {
   /* The SOF event can be distributed for all classes that support it */
@@ -932,6 +930,7 @@ USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef *pdev)
   * @brief  USBD_LL_IsoINIncomplete
   *         Handle iso in incomplete event
   * @param  pdev: device instance
+  * @param  epnum: Endpoint number
   * @retval status
   */
 USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef *pdev,
@@ -957,6 +956,7 @@ USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef *pdev,
   * @brief  USBD_LL_IsoOUTIncomplete
   *         Handle iso out incomplete event
   * @param  pdev: device instance
+  * @param  epnum: Endpoint number
   * @retval status
   */
 USBD_StatusTypeDef USBD_LL_IsoOUTIncomplete(USBD_HandleTypeDef *pdev,
@@ -1123,20 +1123,21 @@ uint8_t USBD_CoreFindEP(USBD_HandleTypeDef *pdev, uint8_t index)
   * @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
+  * @param  ClassId: The Class ID
   * @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 USBD_CoreGetEPAdd(USBD_HandleTypeDef *pdev, uint8_t ep_dir, uint8_t ep_type, uint8_t ClassId)
 {
   uint8_t idx;
 
   /* Find the EP address in the selected class table */
-  for (idx = 0; idx < pdev->tclasslist[pdev->classId].NumEps; idx++)
+  for (idx = 0; idx < pdev->tclasslist[ClassId].NumEps; idx++)
   {
-    if (((pdev->tclasslist[pdev->classId].Eps[idx].add & USBD_EP_IN) == ep_dir) && \
+    if (((pdev->tclasslist[ClassId].Eps[idx].add & USBD_EP_IN) == ep_dir) && \
-        (pdev->tclasslist[pdev->classId].Eps[idx].type == ep_type) && \
+        (pdev->tclasslist[ClassId].Eps[idx].type == ep_type) && \
-        (pdev->tclasslist[pdev->classId].Eps[idx].is_used != 0U))
+        (pdev->tclasslist[ClassId].Eps[idx].is_used != 0U))
     {
-      return (pdev->tclasslist[pdev->classId].Eps[idx].add);
+      return (pdev->tclasslist[ClassId].Eps[idx].add);
     }
   }
 

Core/Src/usbd_ctlreq.c

@@ -46,7 +46,9 @@
 /** @defgroup USBD_REQ_Private_Defines
   * @{
   */
-
+#ifndef USBD_MAX_STR_DESC_SIZ
+#define USBD_MAX_STR_DESC_SIZ                          64U
+#endif /* USBD_MAX_STR_DESC_SIZ */
 /**
   * @}
   */
@@ -421,7 +423,7 @@ USBD_StatusTypeDef USBD_StdEPReq(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef
   *         Handle Get Descriptor requests
   * @param  pdev: device instance
   * @param  req: usb request
-  * @retval status
+  * @retval None
   */
 static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
@@ -454,7 +456,7 @@ static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *r
 #ifdef USE_USBD_COMPOSITE
         if ((uint8_t)(pdev->NumClasses) > 0U)
         {
-          pbuf   = (uint8_t *)USBD_CMPSIT.GetHSConfigDescriptor(&len);
+          pbuf = (uint8_t *)USBD_CMPSIT.GetHSConfigDescriptor(&len);
         }
         else
 #endif /* USE_USBD_COMPOSITE */
@@ -468,12 +470,12 @@ static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *r
 #ifdef USE_USBD_COMPOSITE
         if ((uint8_t)(pdev->NumClasses) > 0U)
         {
-          pbuf   = (uint8_t *)USBD_CMPSIT.GetFSConfigDescriptor(&len);
+          pbuf = (uint8_t *)USBD_CMPSIT.GetFSConfigDescriptor(&len);
         }
         else
 #endif /* USE_USBD_COMPOSITE */
         {
-          pbuf   = (uint8_t *)pdev->pClass[0]->GetFSConfigDescriptor(&len);
+          pbuf = (uint8_t *)pdev->pClass[0]->GetFSConfigDescriptor(&len);
         }
         pbuf[1] = USB_DESC_TYPE_CONFIGURATION;
       }
@@ -558,7 +560,6 @@ static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *r
 #if (USBD_SUPPORT_USER_STRING_DESC == 1U)
           pbuf = NULL;
 
-
           for (uint32_t idx = 0U; (idx < pdev->NumClasses); idx++)
           {
             if (pdev->pClass[idx]->GetUsrStrDescriptor != NULL)
@@ -576,13 +577,12 @@ static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *r
               }
             }
           }
-
 #endif /* USBD_SUPPORT_USER_STRING_DESC  */
 
 #if (USBD_CLASS_USER_STRING_DESC == 1U)
           if (pdev->pDesc->GetUserStrDescriptor != NULL)
           {
-            pbuf = pdev->pDesc->GetUserStrDescriptor(pdev->dev_speed, (req->wValue), &len);
+            pbuf = pdev->pDesc->GetUserStrDescriptor(pdev->dev_speed, LOBYTE(req->wValue), &len);
           }
           else
           {
@@ -677,7 +677,7 @@ static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *r
   *         Set device address
   * @param  pdev: device instance
   * @param  req: usb request
-  * @retval status
+  * @retval None
   */
 static void USBD_SetAddress(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
@@ -751,6 +751,13 @@ static USBD_StatusTypeDef USBD_SetConfig(USBD_HandleTypeDef *pdev, USBD_SetupReq
         {
           (void)USBD_CtlSendStatus(pdev);
           pdev->dev_state = USBD_STATE_CONFIGURED;
+
+#if (USBD_USER_REGISTER_CALLBACK == 1U)
+          if (pdev->DevStateCallback != NULL)
+          {
+            pdev->DevStateCallback(USBD_STATE_CONFIGURED, cfgidx);
+          }
+#endif /* USBD_USER_REGISTER_CALLBACK */
         }
       }
       else
@@ -809,7 +816,7 @@ static USBD_StatusTypeDef USBD_SetConfig(USBD_HandleTypeDef *pdev, USBD_SetupReq
   *         Handle Get device configuration request
   * @param  pdev: device instance
   * @param  req: usb request
-  * @retval status
+  * @retval None
   */
 static void USBD_GetConfig(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
@@ -843,7 +850,7 @@ static void USBD_GetConfig(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
   *         Handle Get Status request
   * @param  pdev: device instance
   * @param  req: usb request
-  * @retval status
+  * @retval None
   */
 static void USBD_GetStatus(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
@@ -884,7 +891,7 @@ static void USBD_GetStatus(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
   *         Handle Set device feature request
   * @param  pdev: device instance
   * @param  req: usb request
-  * @retval status
+  * @retval None
   */
 static void USBD_SetFeature(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
@@ -895,7 +902,7 @@ static void USBD_SetFeature(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
   }
   else if (req->wValue == USB_FEATURE_TEST_MODE)
   {
-    pdev->dev_test_mode = req->wIndex >> 8;
+    pdev->dev_test_mode = (uint8_t)(req->wIndex >> 8);
     (void)USBD_CtlSendStatus(pdev);
   }
   else
@@ -910,7 +917,7 @@ static void USBD_SetFeature(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
   *         Handle clear device feature request
   * @param  pdev: device instance
   * @param  req: usb request
-  * @retval status
+  * @retval None
   */
 static void USBD_ClrFeature(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 {
@@ -936,8 +943,8 @@ static void USBD_ClrFeature(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
 /**
   * @brief  USBD_ParseSetupRequest
   *         Copy buffer into setup structure
-  * @param  pdev: device instance
   * @param  req: usb request
+  * @param  pdata: setup data pointer
   * @retval None
   */
 void USBD_ParseSetupRequest(USBD_SetupReqTypedef *req, uint8_t *pdata)
@@ -997,7 +1004,7 @@ void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
   }
 
   pdesc = desc;
-  *len = ((uint16_t)USBD_GetLen(pdesc) * 2U) + 2U;
+  *len = MIN(USBD_MAX_STR_DESC_SIZ, ((uint16_t)USBD_GetLen(pdesc) * 2U) + 2U);
 
   unicode[idx] = *(uint8_t *)len;
   idx++;

Core/Src/usbd_desc_template.c

@@ -65,7 +65,7 @@ USBD_DescriptorsTypeDef Class_Desc =
   USBD_Class_ConfigStrDescriptor,
   USBD_Class_InterfaceStrDescriptor,
 #if (USBD_CLASS_USER_STRING_DESC == 1)
-  USBD_CLASS_UserStrDescriptor,
+  USBD_Class_UserStrDescriptor,
 #endif /* USB_CLASS_USER_STRING_DESC */
 
 #if ((USBD_LPM_ENABLED == 1) || (USBD_CLASS_BOS_ENABLED == 1))
@@ -374,7 +374,9 @@ uint8_t *USBD_Class_InterfaceStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *le
   */
 static void Get_SerialNum(void)
 {
-  uint32_t deviceserial0, deviceserial1, deviceserial2;
+  uint32_t deviceserial0;
+  uint32_t deviceserial1;
+  uint32_t deviceserial2;
 
   deviceserial0 = *(uint32_t *)DEVICE_ID1;
   deviceserial1 = *(uint32_t *)DEVICE_ID2;

Core/Src/usbd_ioreq.c

@@ -89,6 +89,7 @@ USBD_StatusTypeDef USBD_CtlSendData(USBD_HandleTypeDef *pdev,
   /* Set EP0 State */
   pdev->ep0_state = USBD_EP0_DATA_IN;
   pdev->ep_in[0].total_length = len;
+  pdev->ep_in[0].pbuffer = pbuf;
 
 #ifdef USBD_AVOID_PACKET_SPLIT_MPS
   pdev->ep_in[0].rem_length = 0U;
@@ -133,6 +134,7 @@ USBD_StatusTypeDef USBD_CtlPrepareRx(USBD_HandleTypeDef *pdev,
   /* Set EP0 State */
   pdev->ep0_state = USBD_EP0_DATA_OUT;
   pdev->ep_out[0].total_length = len;
+  pdev->ep_out[0].pbuffer = pbuf;
 
 #ifdef USBD_AVOID_PACKET_SPLIT_MPS
   pdev->ep_out[0].rem_length = 0U;

LICENSE.md

@@ -0,0 +1,94 @@
+This software component is provided to you as part of a software package and
+applicable license terms are in the Package_license file. If you received this
+software component outside of a package or without applicable license terms,
+the terms of the SLA0044 license shall apply and are fully reproduced below:
+
+SLA0044 Rev6/October 2025
+
+## Software license agreement
+
+### __ULTIMATE LIBERTY SOFTWARE LICENSE AGREEMENT__
+
+BY CLICKING ON THE "I ACCEPT" BUTTON OR BY UNZIPPING, INSTALLING, COPYING,
+DOWNLOADING, ACCESSING OR OTHERWISE USING THIS SOFTWARE OR ANY PART THEREOF, 
+INCLUDING ANY RELATED DOCUMENTATION (collectively the “SOFTWARE”) 
+FROM STMICROELECTRONICS INTERNATIONAL N.V, SWISS BRANCH AND/OR 
+ITS AFFILIATED COMPANIES (collectively “STMICROELECTRONICS”),
+YOU (hereinafter referred also to as “THE RECIPIENT”), ON BEHALF OF YOURSELF,
+OR ON BEHALF OF ANY ENTITY BY WHICH YOU ARE EMPLOYED AND/OR ENGAGED, 
+AGREE TO BE BOUND BY THIS AGREEMENT.
+
+Under STMICROELECTRONICS’ intellectual property rights, the redistribution,
+reproduction and use in source and binary forms of the SOFTWARE or any part
+thereof, with or without modification, are permitted provided that the following
+conditions are met:
+
+1. Redistribution of source code (modified or not) must retain any copyright
+notice accompanying the SOFTWARE, this list of conditions and the disclaimer below.
+
+2. Redistributions in binary form, except as embedded into a processing unit device
+manufactured by or for STMicroelectronics or a software update for any such device,
+must reproduce the accompanying copyright notice, this list of conditions,
+and the below disclaimer in capital type, in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of STMicroelectronics nor the names of other contributors
+to the SOFTWARE may be used to endorse or promote products derived
+from the SOFTWARE or part thereof without specific written permission.
+
+4. The SOFTWARE or any part thereof, including modifications and/or
+derivative works of the SOFTWARE, must be used and execute solely
+and exclusively on or in combination with a processing unit device
+manufactured by or for STMicroelectronics.
+
+5. No use, reproduction or redistribution of the SOFTWARE partially
+or totally may be done in any manner that would subject the SOFTWARE
+to any Open Source Terms. “Open Source Terms” shall mean
+any open source license which requires as part of distribution
+of software that the source code of such software is distributed
+therewith or otherwise made available, or open source license
+that substantially complies with the Open Source definition specified
+at www.opensource.org and any other comparable open source license
+such as for example GNU General Public License (GPL),
+Eclipse Public License (EPL), Apache Software License, BSD license
+or MIT license.
+
+6. STMicroelectronics has no obligation to provide any maintenance,
+support or updates for the SOFTWARE.
+
+7. The SOFTWARE is and will remain the exclusive property of
+STMicroelectronics and its licensors. The RECIPIENT will not take
+any action that jeopardizes STMicroelectronics and its
+licensors' proprietary rights or acquire any rights in the SOFTWARE,
+except the limited rights specified hereunder.
+
+8. The RECIPIENT shall comply with all applicable laws and regulations
+affecting the use of the SOFTWARE or any part thereof including
+any applicable export control law or regulation.
+
+9. Redistribution and use of the SOFTWARE or any part thereof other
+than as permitted under this AGREEMENT is void and will automatically
+terminate RECIPIENT’s rights under this AGREEMENT.
+
+10. The RECIPIENT shall be solely liable to determine and verify that
+the SOFTWARE is fit for the RECIPIENT intended use, environment or
+application and comply with all regulatory, safety and security
+related requirements concerning any use.
+
+DISCLAIMER:
+
+THE SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING,BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, ARE
+DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW.
+IN NO EVENT SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+EXCEPT AS EXPRESSLY PERMITTED HEREUNDER, NO LICENSE OR OTHER RIGHTS,
+WHETHER EXPRESS OR IMPLIED, ARE GRANTED UNDER ANY PATENT OR OTHER INTELLECTUAL
+PROPERTY RIGHTS OF STMICROELECTRONICS OR ANY THIRD PARTY.

LICENSE.txt

@@ -1,86 +0,0 @@
-This software component is provided to you as part of a software package and
-applicable license terms are in the Package_license file. If you received this
-software component outside of a package or without applicable license terms,
-the terms of the SLA0044 license shall apply and are fully reproduced below:
-
-SLA0044 Rev5/February 2018
-
-Software license agreement
-
-ULTIMATE LIBERTY SOFTWARE LICENSE AGREEMENT
-
-BY INSTALLING, COPYING, DOWNLOADING, ACCESSING OR OTHERWISE USING THIS SOFTWARE
-OR ANY PART THEREOF (AND THE RELATED DOCUMENTATION) FROM STMICROELECTRONICS
-INTERNATIONAL N.V, SWISS BRANCH AND/OR ITS AFFILIATED COMPANIES
-(STMICROELECTRONICS), THE RECIPIENT, ON BEHALF OF HIMSELF OR HERSELF, OR ON
-BEHALF OF ANY ENTITY BY WHICH SUCH RECIPIENT IS EMPLOYED AND/OR ENGAGED AGREES
-TO BE BOUND BY THIS SOFTWARE LICENSE AGREEMENT.
-
-Under STMicroelectronics’ intellectual property rights, the redistribution,
-reproduction and use in source and binary forms of the software or any part
-thereof, with or without modification, are permitted provided that the following
-conditions are met:
-
-1. Redistribution of source code (modified or not) must retain any copyright
-notice, this list of conditions and the disclaimer set forth below as items 10
-and 11.
-
-2. Redistributions in binary form, except as embedded into microcontroller or
-microprocessor device manufactured by or for STMicroelectronics or a software
-update for such device, must reproduce any copyright notice provided with the
-binary code, this list of conditions, and the disclaimer set forth below as
-items 10 and 11, in documentation and/or other materials provided with the
-distribution.
-
-3. Neither the name of STMicroelectronics nor the names of other contributors to
-this software may be used to endorse or promote products derived from this
-software or part thereof without specific written permission.
-
-4. This software or any part thereof, including modifications and/or derivative
-works of this software, must be used and execute solely and exclusively on or in
-combination with a microcontroller or microprocessor device manufactured by or
-for STMicroelectronics.
-
-5. No use, reproduction or redistribution of this software partially or totally
-may be done in any manner that would subject this software to any Open Source
-Terms. “Open Source Terms” shall mean any open source license which requires as
-part of distribution of software that the source code of such software is
-distributed therewith or otherwise made available, or open source license that
-substantially complies with the Open Source definition specified at
-www.opensource.org and any other comparable open source license such as for
-example GNU General Public License (GPL), Eclipse Public License (EPL), Apache
-Software License, BSD license or MIT license.
-
-6. STMicroelectronics has no obligation to provide any maintenance, support or
-updates for the software.
-
-7. The software is and will remain the exclusive property of STMicroelectronics
-and its licensors. The recipient will not take any action that jeopardizes
-STMicroelectronics and its licensors' proprietary rights or acquire any rights
-in the software, except the limited rights specified hereunder.
-
-8. The recipient shall comply with all applicable laws and regulations affecting
-the use of the software or any part thereof including any applicable export
-control law or regulation.
-
-9. Redistribution and use of this software or any part thereof other than as
-permitted under this license is void and will automatically terminate your
-rights under this license.
-
-10. THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, WHICH ARE
-DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT SHALL
-STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-11. EXCEPT AS EXPRESSLY PERMITTED HEREUNDER, NO LICENSE OR OTHER RIGHTS, WHETHER
-EXPRESS OR IMPLIED, ARE GRANTED UNDER ANY PATENT OR OTHER INTELLECTUAL PROPERTY
-RIGHTS OF STMICROELECTRONICS OR ANY THIRD PARTY.
-

License.md

@@ -1,80 +0,0 @@
-SLA0044 Rev5/February 2018
-
-## Software license agreement
-
-### __ULTIMATE LIBERTY SOFTWARE LICENSE AGREEMENT__
-
-BY INSTALLING, COPYING, DOWNLOADING, ACCESSING OR OTHERWISE USING THIS SOFTWARE
-OR ANY PART THEREOF (AND THE RELATED DOCUMENTATION) FROM STMICROELECTRONICS
-INTERNATIONAL N.V, SWISS BRANCH AND/OR ITS AFFILIATED COMPANIES
-(STMICROELECTRONICS), THE RECIPIENT, ON BEHALF OF HIMSELF OR HERSELF, OR ON
-BEHALF OF ANY ENTITY BY WHICH SUCH RECIPIENT IS EMPLOYED AND/OR ENGAGED AGREES
-TO BE BOUND BY THIS SOFTWARE LICENSE AGREEMENT.
-
-Under STMicroelectronics’ intellectual property rights, the redistribution,
-reproduction and use in source and binary forms of the software or any part
-thereof, with or without modification, are permitted provided that the following
-conditions are met:
-
-1. Redistribution of source code (modified or not) must retain any copyright
-notice, this list of conditions and the disclaimer set forth below as items 10
-and 11.
-
-2. Redistributions in binary form, except as embedded into microcontroller or
-microprocessor device manufactured by or for STMicroelectronics or a software
-update for such device, must reproduce any copyright notice provided with the
-binary code, this list of conditions, and the disclaimer set forth below as
-items 10 and 11, in documentation and/or other materials provided with the
-distribution.
-
-3. Neither the name of STMicroelectronics nor the names of other contributors to
-this software may be used to endorse or promote products derived from this
-software or part thereof without specific written permission.
-
-4. This software or any part thereof, including modifications and/or derivative
-works of this software, must be used and execute solely and exclusively on or in
-combination with a microcontroller or microprocessor device manufactured by or
-for STMicroelectronics.
-
-5. No use, reproduction or redistribution of this software partially or totally
-may be done in any manner that would subject this software to any Open Source
-Terms. “Open Source Terms” shall mean any open source license which requires as
-part of distribution of software that the source code of such software is
-distributed therewith or otherwise made available, or open source license that
-substantially complies with the Open Source definition specified at
-www.opensource.org and any other comparable open source license such as for
-example GNU General Public License (GPL), Eclipse Public License (EPL), Apache
-Software License, BSD license or MIT license.
-
-6. STMicroelectronics has no obligation to provide any maintenance, support or
-updates for the software.
-
-7. The software is and will remain the exclusive property of STMicroelectronics
-and its licensors. The recipient will not take any action that jeopardizes
-STMicroelectronics and its licensors' proprietary rights or acquire any rights
-in the software, except the limited rights specified hereunder.
-
-8. The recipient shall comply with all applicable laws and regulations affecting
-the use of the software or any part thereof including any applicable export
-control law or regulation.
-
-9. Redistribution and use of this software or any part thereof other than as
-permitted under this license is void and will automatically terminate your
-rights under this license.
-
-10. THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, WHICH ARE
-DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT SHALL
-STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-11. EXCEPT AS EXPRESSLY PERMITTED HEREUNDER, NO LICENSE OR OTHER RIGHTS, WHETHER
-EXPRESS OR IMPLIED, ARE GRANTED UNDER ANY PATENT OR OTHER INTELLECTUAL PROPERTY
-RIGHTS OF STMICROELECTRONICS OR ANY THIRD PARTY.

README.md

@@ -1,36 +1,40 @@
-# Middleware USB Device MCU Component
+# USB Device Middleware Library MCU Software Component
 
-## Overview
+![latest tag](https://img.shields.io/github/v/tag/STMicroelectronics/stm32-mw-usb-device.svg?color=brightgreen)
 
-**STM32Cube** is an STMicroelectronics original initiative to ease the developers life by reducing efforts, time and cost.
+## Overview of the STM32Cube MCU offer on GitHub
 
-**STM32Cube** covers the overall STM32 products portfolio. It includes a comprehensive embedded software platform, delivered for each STM32 series.
+**STM32Cube** is an original initiative by STMicroelectronics to **simplify** prototyping and development by **reducing** effort, time, and cost. It supports the entire ARM™ Cortex-based STM32 microcontroller portfolio and provides a **comprehensive** software solution including:
-   * The CMSIS modules (core and device) corresponding to the ARM(tm) core implemented in this STM32 product.
+  * The CMSIS Core and Device interfaces enabling access to processor core features and device-specific peripherals of STM32 microcontrollers.
-   * The STM32 HAL-LL drivers : an abstraction drivers layer, the API ensuring maximized portability across the STM32 portfolio.
+  * The STM32 HAL-LL drivers, an abstraction layer offering a set of APIs ensuring maximized portability across the STM32 portfolio.
-   * The BSP Drivers of each evaluation or demonstration board provided by this STM32 series.
+  * The BSP drivers enabling access to peripherals on the STM32 development boards, external to the microcontroller itself.
-   * A consistent set of middlewares components such as RTOS, USB, FatFS, Graphics, STM32_TouchSensing_Library...
+  * A consistent set of middleware libraries offering standardized, high-level functionalities — such as USB, TCP/IP, file systems, and graphics.
-   * A full set of software projects (basic examples, applications or demonstrations) for each board provided by this STM32 series.
+  * A full set of software projects (basic examples, applications, and demonstrations) that showcase specific functionalities or use cases, and provided with support for multiple IDEs.
 
-Two models of publication are proposed for the STM32Cube embedded software:
+The **STM32Cube embedded software** is available in two flavors:
-   * The monolithic **MCU Package** : all STM32Cube software modules of one STM32 series are present (Drivers, Middlewares, Projects, Utilities) in the repo (usual name **STM32Cubexx**, xx corresponding to the STM32 series).
+  * The **MCU Firmware** _monolithic_ offer, where **all** software components (Drivers, Middleware, Projects, Utilities) are included in a **single** repository for each STM32 series.
-   * The **MCU component** : progressively from November 2019, each STM32Cube software module being part of the STM32Cube MCU Package, will be delivered as an individual repo, allowing the user to select and get only the required software functions.
+  * The **MCU Software Components** _modular_ offer, where **each** software component (mainly Drivers and Middleware) is provided in a **dedicated** repository, allowing users to **select** only the components they need.
 
-## Description
+The complete list of repositories is available [here](https://github.com/STMicroelectronics/STM32Cube_MCU_Overall_Offer/blob/master/README.md#content).
 
-This **stm32_mw_usb_device** MCU component repository is one element **common to all** STM32Cube MCU embedded software packages, providing the **USB Device MCU Middleware** part.
+## Repository content
 
-## License
+This repository provides the STM32Cube **USB Device** Middleware Library, **common to every** STM32Cube MCU firmware that supports it.
 
-Copyright (c) 2015 STMicroelectronics.
+This represents STMicroelectronics’ offering to support the USB Device role on STM32 MCUs. It includes two main modules:
 
-This software component is licensed by  ST under Ultimate Liberty license SLA0044, the "License". You may not use this file except in compliance with this license. You may obtain a copy of the license [here](https://www.st.com/SLA0044).
+- **Core**: provides USB Device standard peripheral control APIs implementing the USB 2.0 standard code for a USB device. These APIs are called in every USB Device application, regardless of the desired functionality.
+
+- **Class**: provides APIs for commonly supported USB Device classes complying with USB 2.0 standard and their respective class specifications. These APIs are called in USB Device applications based on the desired functionality.
 
 ## Release note
 
-Details about the content of this release are available in the release note [here](https://htmlpreview.github.io/?https://github.com/STMicroelectronics/stm32_mw_usb_device/blob/master/Release_Notes.html).
+Details about the content of this release are available in the release note [here](https://htmlpreview.github.io/?https://github.com/STMicroelectronics/stm32-mw-usb-device/blob/master/Release_Notes.html).
 
-## Troubleshooting
+## Compatibility information
 
-If you have any issue with the **software content** of this repository, you can file an issue [here](https://github.com/STMicroelectronics/stm32_mw_usb_device/issues/new/choose).
+Please refer to the **release note** in the firmware repository for the STM32 series you are using ([list](https://github.com/STMicroelectronics/STM32Cube_MCU_Overall_Offer/blob/master/README.md#stm32cube-mcu-packages)). It is **important** to use a **consistent set** of software component versions (i.e., CMSIS, HAL-LL, BSP, MW) as specified in the release note.
 
-For any other question related to the product, the tools, the environment, you can submit a topic to the [ST Community](https://community.st.com/s/).
+## Feedback and contributions
+
+Please refer to the [CONTRIBUTING.md](CONTRIBUTING.md) guide.

SECURITY.md

@@ -0,0 +1,31 @@
+# Report potential product security vulnerabilities
+
+ST places a high priority on security, and our Product Security Incident
+Response Team (PSIRT) is committed to rapidly addressing potential security
+vulnerabilities affecting our products. PSIRT's long history and vast experience
+in security allows ST to perform clear analyses and provide appropriate guidance
+on mitigations and solutions when applicable.
+
+If you wish to report potential security vulnerabilities regarding our products,
+**please do not report them through public GitHub issues.** Instead, we
+encourage you to report them to our ST PSIRT following the process described at:
+**https://www.st.com/content/st_com/en/security/report-vulnerabilities.html**
+
+### IMPORTANT - READ CAREFULLY:
+
+STMicroelectronics International N.V., on behalf of itself, its affiliates and
+subsidiaries, (collectively “ST”) takes all potential security vulnerability
+reports or other related communications (“Report(s)”) seriously. In order to
+review Your Report (the terms “You” and “Yours” include your employer, and all
+affiliates, subsidiaries and related persons or entities) and take actions as
+deemed appropriate, ST requires that we have the rights and Your permission to
+do so.
+
+As such, by submitting Your Report to ST, You agree that You have the right to
+do so, and You grant to ST the rights to use the Report for purposes related to
+security vulnerability analysis, testing, correction, patching, reporting and
+any other related purpose or function.
+
+By submitting Your Report, You agree that ST’s
+[Privacy Policy](https://www.st.com/content/st_com/en/common/privacy-portal.html)
+applies to all related communications.