Release v2.11.6

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

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

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

Class/CCID/Src/usbd_ccid_cmd.c

@@ -42,8 +42,8 @@ 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];
   uint8_t voltage;

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

Class/CDC/Src/usbd_cdc.c

@@ -161,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

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
 

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

Class/CDC_RNDIS/Src/usbd_cdc_rndis.c

@@ -1414,7 +1414,7 @@ static uint8_t USBD_CDC_RNDIS_ProcessQueryMsg(USBD_HandleTypeDef *pdev,
     case OID_GEN_VENDOR_DESCRIPTION:
       QueryResponse->InfoBufLength = (strlen(USBD_CDC_RNDIS_VENDOR_DESC) + 1U);
       (void)USBD_memcpy(QueryResponse->InfoBuf, USBD_CDC_RNDIS_VENDOR_DESC,
-                        strlen(USBD_CDC_RNDIS_VENDOR_DESC));
+                        strlen(USBD_CDC_RNDIS_VENDOR_DESC) + 1U);
 
       QueryResponse->Status = CDC_RNDIS_STATUS_SUCCESS;
       break;
@@ -1452,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;
 
@@ -1641,6 +1641,13 @@ static uint8_t USBD_CDC_RNDIS_ProcessPacketMsg(USBD_HandleTypeDef *pdev,
   /* Use temporary storage variables to comply with MISRA-C 2012 rule of (+) operand allowed types */
   tmp1 = (uint32_t)PacketMsg;
   tmp2 = (uint32_t)(PacketMsg->DataOffset);
+
+  /* Validate DataOffset and DataLength against the received MsgLength */
+  if ((tmp2 + CDC_RNDIS_PCKTMSG_DATAOFFSET_OFFSET + PacketMsg->DataLength) > PacketMsg->MsgLength)
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
   hcdc->RxBuffer = (uint8_t *)(tmp1 + tmp2 + CDC_RNDIS_PCKTMSG_DATAOFFSET_OFFSET);
   hcdc->RxLength = PacketMsg->DataLength;
 

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);
@@ -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,7 +1408,7 @@ 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;

Class/CustomHID/Inc/usbd_customhid.h

@@ -103,9 +103,16 @@ 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 */

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
@@ -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);
@@ -397,9 +405,17 @@ static uint8_t USBD_CUSTOM_HID_Setup(USBD_HandleTypeDef *pdev,
           }
 #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
@@ -479,7 +495,15 @@ static uint8_t USBD_CUSTOM_HID_Setup(USBD_HandleTypeDef *pdev,
             }
           }
 
+          if (pbuf != NULL)
+          {
             (void)USBD_CtlSendData(pdev, pbuf, len);
+          }
+          else
+          {
+            USBD_CtlError(pdev, req);
+            ret = USBD_FAIL;
+          }
           break;
 
         case USB_REQ_GET_INTERFACE:
@@ -667,6 +691,11 @@ static uint8_t USBD_CUSTOM_HID_DataIn(USBD_HandleTypeDef *pdev, uint8_t 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 */
+  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
   ((USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId])->state = CUSTOM_HID_IDLE;
 
   return (uint8_t)USBD_OK;
@@ -693,8 +722,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;
 }
@@ -747,8 +781,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,11 @@ 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);
@@ -49,6 +53,9 @@ __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,
@@ -95,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)
@@ -151,7 +165,7 @@ static int8_t TEMPLATE_CUSTOM_HID_CtrlReqComplete(uint8_t request, uint16_t wLen
 static uint8_t *TEMPLATE_CUSTOM_HID_GetReport(uint16_t *ReportLength)
 {
   UNUSED(ReportLength);
-  uint8_t *pbuff;
+  uint8_t *pbuff = NULL;
 
   return (pbuff);
 }

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
@@ -525,7 +526,7 @@ static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
   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)
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U) || (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
   uint32_t VendorStatus = 0U;
 #endif /* USBD_DFU_VENDOR_CMD_ENABLED */
 
@@ -619,7 +620,6 @@ static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
             hdfu->dev_status[4] = hdfu->dev_state;
             return (uint8_t)USBD_FAIL;
           }
-
         }
 #if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
         else
@@ -647,14 +647,58 @@ static uint8_t  USBD_DFU_EP0_TxReady(USBD_HandleTypeDef *pdev)
       }
       else
       {
-        /* Reset the global length and block number */
+#if (USBD_DFU_VENDOR_CMD_ENABLED == 1U)
-        hdfu->wlength = 0U;
+        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
+        {
+          /* 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
+        /* 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 */
     else
@@ -856,10 +900,10 @@ 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_CMD_ENABLED == 1U)
+#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_CMD_ENABLED */
+#endif /* USBD_DFU_VENDOR_CHECK_ENABLED */
 
   if (hdfu == NULL)
   {
@@ -896,6 +940,12 @@ static void DFU_Download(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)
     if ((hdfu->dev_state == DFU_STATE_DNLOAD_IDLE) || (hdfu->dev_state == DFU_STATE_IDLE))
     {
 #if (USBD_DFU_VENDOR_CHECK_ENABLED == 1U)
+      /* Fill the buffer to be checked with the address stored in data buffer */
+      hdfu->buffer.d8[1] = (uint8_t)(hdfu->data_ptr & 0xFFU);
+      hdfu->buffer.d8[2] = (uint8_t)((hdfu->data_ptr & 0xFF00U) >> 8U);
+      hdfu->buffer.d8[3] = (uint8_t)((hdfu->data_ptr & 0xFF0000U) >> 16U);
+      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 */

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
@@ -615,6 +618,11 @@ 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 */
+  if (pdev->pClassDataCmsit[pdev->classId] == NULL)
+  {
+    return (uint8_t)USBD_FAIL;
+  }
+
   ((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 + 1U];
-  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

@@ -44,6 +44,8 @@ extern "C" {
 #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
@@ -88,9 +90,8 @@ extern "C" {
 #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 */
@@ -309,6 +312,7 @@ 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
@@ -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

@@ -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);
@@ -346,7 +346,7 @@ static void  MSC_BOT_SendData(USBD_HandleTypeDef *pdev, uint8_t *pbuf, uint32_t
 
   length = MIN(hmsc->cbw.dDataLength, len);
 
-  hmsc->csw.dDataResidue -= len;
+  hmsc->csw.dDataResidue -= length;
   hmsc->csw.bStatus = USBD_CSW_CMD_PASSED;
   hmsc->bot_state = USBD_BOT_SEND_DATA;
 

Class/MSC/Src/usbd_msc_data.c

@@ -81,7 +81,7 @@ uint8_t MSC_Page80_Inquiry_Data[LENGTH_INQUIRY_PAGE80] =
   0x00,
   0x80,
   0x00,
-  LENGTH_INQUIRY_PAGE80,
+  (LENGTH_INQUIRY_PAGE80 - 4U),
   0x20,     /* Put Product Serial number */
   0x20,
   0x20,
@@ -118,6 +118,19 @@ uint8_t MSC_Mode_Sense10_data[MODE_SENSE10_LEN] =
   0x00,     /* BLOCK DESCRIPTOR LENGTH MSB. */
   0x00      /* BLOCK DESCRIPTOR LENGTH LSB. */
 };
+
+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

@@ -85,6 +85,10 @@ static int8_t SCSI_ReadCapacity16(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
 static int8_t SCSI_RequestSense(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_StartStopUnit(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_AllowPreventRemovable(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
+static int8_t SCSI_ProcessModeSelect(USBD_HandleTypeDef *pdev, uint8_t lun,
+                                     uint32_t param_list_length);
+static int8_t SCSI_ModeSelect6(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
+static int8_t SCSI_ModeSelect10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_ModeSense6(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_ModeSense10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
 static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params);
@@ -92,6 +96,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);
 
@@ -150,6 +156,14 @@ int8_t SCSI_ProcessCmd(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *cmd)
       ret = SCSI_AllowPreventRemovable(pdev, lun, cmd);
       break;
 
+    case SCSI_MODE_SELECT6:
+      ret = SCSI_ModeSelect6(pdev, lun, cmd);
+      break;
+
+    case SCSI_MODE_SELECT10:
+      ret = SCSI_ModeSelect10(pdev, lun, cmd);
+      break;
+
     case SCSI_MODE_SENSE6:
       ret = SCSI_ModeSense6(pdev, lun, cmd);
       break;
@@ -190,9 +204,17 @@ 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;
+      hmsc->bot_state = USBD_BOT_NO_DATA;
       ret = -1;
       break;
   }
@@ -283,7 +305,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;
     }
@@ -319,14 +341,17 @@ 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;
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
-  ret = ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &hmsc->scsi_blk_nbr,
+  p_scsi_blk = &hmsc->scsi_blk[lun];
-                                                                             &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))
   {
@@ -334,20 +359,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;
-
 }
 
 
@@ -360,18 +384,21 @@ 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);
   uint32_t idx;
+  uint32_t alloc_len;
   int8_t ret;
   USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk;
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
-  ret = ((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &hmsc->scsi_blk_nbr,
+  p_scsi_blk = &hmsc->scsi_blk[lun];
-                                                                             &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))
   {
@@ -379,31 +406,30 @@ static int8_t SCSI_ReadCapacity16(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
     return -1;
   }
 
-  hmsc->bot_data_length = ((uint32_t)params[10] << 24) |
+  /* READ CAPACITY(16) response is 32 bytes per SBC-3 */
-                          ((uint32_t)params[11] << 16) |
+  for (idx = 0U; idx < 32U; idx++)
-                          ((uint32_t)params[12] <<  8) |
-                          (uint32_t)params[13];
-
-  for (idx = 0U; idx < hmsc->bot_data_length; idx++)
   {
     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) |
+  /* Clamp transfer length to actual response size (32 bytes) */
+  alloc_len = ((uint32_t)params[10] << 24) |
               ((uint32_t)params[11] << 16) |
               ((uint32_t)params[12] <<  8) |
               (uint32_t)params[13];
 
+  hmsc->bot_data_length = MIN(alloc_len, 32U);
+
   return 0;
 }
 
@@ -417,8 +443,8 @@ static int8_t SCSI_ReadCapacity16(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t
   */
 static int8_t SCSI_ReadFormatCapacity(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
 {
-  UNUSED(params);
   uint16_t blk_size;
+  uint16_t alloc_len;
   uint32_t blk_nbr;
   uint16_t i;
   int8_t ret;
@@ -453,12 +479,116 @@ static int8_t SCSI_ReadFormatCapacity(USBD_HandleTypeDef *pdev, uint8_t lun, uin
   hmsc->bot_data[10] = (uint8_t)(blk_size >>  8);
   hmsc->bot_data[11] = (uint8_t)(blk_size);
 
-  hmsc->bot_data_length = 12U;
+  alloc_len = ((uint16_t)params[7] << 8) | (uint16_t)params[8];
+  hmsc->bot_data_length = MIN(alloc_len, READ_FORMAT_CAPACITY_DATA_LEN);
 
   return 0;
 }
 
 
+/**
+  * @brief  SCSI_ProcessModeSelect
+  *         Drain MODE SELECT parameter data without applying mode pages
+  * @param  lun: Logical unit number
+  * @param  param_list_length: Mode parameter list length from the CDB
+  * @retval status
+  */
+static int8_t SCSI_ProcessModeSelect(USBD_HandleTypeDef *pdev, uint8_t lun,
+                                     uint32_t param_list_length)
+{
+  USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
+  USBD_MSC_BOT_LUN_TypeDef *p_scsi_blk;
+  uint32_t packet_length;
+  uint32_t rx_length;
+
+  UNUSED(param_list_length);
+
+  if (hmsc == NULL)
+  {
+    return -1;
+  }
+
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
+#ifdef USE_USBD_COMPOSITE
+  /* Get the Endpoints addresses allocated for this class instance */
+  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)
+  {
+    if ((hmsc->cbw.bmFlags & 0x80U) == 0x80U)
+    {
+      hmsc->bot_state = USBD_BOT_NO_DATA;
+      hmsc->bot_data_length = 0U;
+      return 0;
+    }
+
+    if (hmsc->cbw.dDataLength == 0U)
+    {
+      hmsc->bot_data_length = 0U;
+      return 0;
+    }
+
+    p_scsi_blk->len = hmsc->cbw.dDataLength;
+    hmsc->bot_state = USBD_BOT_DATA_OUT;
+
+    packet_length = MIN(p_scsi_blk->len, MSC_MEDIA_PACKET);
+    (void)USBD_LL_PrepareReceive(pdev, MSCOutEpAdd, hmsc->bot_data, packet_length);
+
+    return 0;
+  }
+
+  rx_length = USBD_LL_GetRxDataSize(pdev, MSCOutEpAdd);
+
+  if (rx_length >= p_scsi_blk->len)
+  {
+    hmsc->csw.dDataResidue -= p_scsi_blk->len;
+    p_scsi_blk->len = 0U;
+    MSC_BOT_SendCSW(pdev, USBD_CSW_CMD_PASSED);
+  }
+  else
+  {
+    p_scsi_blk->len -= rx_length;
+    hmsc->csw.dDataResidue -= rx_length;
+    packet_length = MIN(p_scsi_blk->len, MSC_MEDIA_PACKET);
+    (void)USBD_LL_PrepareReceive(pdev, MSCOutEpAdd, hmsc->bot_data, packet_length);
+  }
+
+  return 0;
+}
+
+
+/**
+  * @brief  SCSI_ModeSelect6
+  *         Process Mode Select6 command
+  * @param  lun: Logical unit number
+  * @param  params: Command parameters
+  * @retval status
+  */
+static int8_t SCSI_ModeSelect6(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
+{
+  return SCSI_ProcessModeSelect(pdev, lun, params[4]);
+}
+
+
+/**
+  * @brief  SCSI_ModeSelect10
+  *         Process Mode Select10 command
+  * @param  lun: Logical unit number
+  * @param  params: Command parameters
+  * @retval status
+  */
+static int8_t SCSI_ModeSelect10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params)
+{
+  uint32_t param_list_length;
+
+  param_list_length = ((uint32_t)params[7] << 8) | (uint32_t)params[8];
+
+  return SCSI_ProcessModeSelect(pdev, lun, param_list_length);
+}
+
+
 /**
   * @brief  SCSI_ModeSense6
   *         Process Mode Sense6 command
@@ -468,7 +598,6 @@ static int8_t SCSI_ReadFormatCapacity(USBD_HandleTypeDef *pdev, uint8_t lun, uin
   */
 static int8_t SCSI_ModeSense6(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 len = MODE_SENSE6_LEN;
 
@@ -480,7 +609,11 @@ static int8_t SCSI_ModeSense6(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *pa
   /* Check If media is write-protected */
   if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsWriteProtected(lun) != 0)
   {
-    MSC_Mode_Sense6_data[2] |= 0x80U;
+    MSC_Mode_Sense6_data[2] |= (0x1U << 7); /* Set the WP (write protection) bit */
+  }
+  else
+  {
+    MSC_Mode_Sense6_data[2] &= ~(0x1U << 7); /* Clear the WP (write protection) bit */
   }
 
   if (params[4] <= len)
@@ -503,9 +636,9 @@ static int8_t SCSI_ModeSense6(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *pa
   */
 static int8_t SCSI_ModeSense10(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 len = MODE_SENSE10_LEN;
+  uint16_t alloc_len;
 
   if (hmsc == NULL)
   {
@@ -515,12 +648,19 @@ static int8_t SCSI_ModeSense10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *p
   /* Check If media is write-protected */
   if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsWriteProtected(lun) != 0)
   {
-    MSC_Mode_Sense10_data[3] |= 0x80U;
+    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)
+  /* Allocation length is a 16-bit field: CDB bytes 7-8 */
+  alloc_len = ((uint16_t)params[7] << 8) | (uint16_t)params[8];
+
+  if (alloc_len < len)
   {
-    len = params[8];
+    len = alloc_len;
   }
 
   (void)SCSI_UpdateBotData(hmsc, MSC_Mode_Sense10_data, len);
@@ -613,6 +753,16 @@ void SCSI_SenseCode(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t sKey, uint8_t
   {
     hmsc->scsi_sense_tail = 0U;
   }
+
+  if (hmsc->scsi_sense_tail == hmsc->scsi_sense_head)
+  {
+    hmsc->scsi_sense_head++;
+
+    if (hmsc->scsi_sense_head == SENSE_LIST_DEEPTH)
+    {
+      hmsc->scsi_sense_head = 0U;
+    }
+  }
 }
 
 
@@ -635,7 +785,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;
   }
@@ -704,12 +854,15 @@ 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;
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
   if (hmsc->bot_state == USBD_BOT_IDLE) /* Idle */
   {
     /* case 10 : Ho <> Di */
@@ -732,21 +885,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[4] <<  8) |
                        (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;
@@ -770,12 +922,15 @@ 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;
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
   if (hmsc->bot_state == USBD_BOT_IDLE) /* Idle */
   {
     /* case 10 : Ho <> Di */
@@ -797,24 +952,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[4] <<  8) |
                        (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[8] << 8) |
                       (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;
@@ -838,6 +992,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;
   uint32_t len;
 
   if (hmsc == NULL)
@@ -845,6 +1000,8 @@ static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
     return -1;
   }
 
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
   MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
@@ -865,10 +1022,18 @@ static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
       return -1;
     }
 
+    if (hmsc->scsi_medium_state == SCSI_MEDIUM_EJECTED)
+    {
+      SCSI_SenseCode(pdev, lun, NOT_READY, MEDIUM_NOT_PRESENT);
+      hmsc->bot_state = USBD_BOT_NO_DATA;
+      return -1;
+    }
+
     /* Check whether Media is ready */
     if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsReady(lun) != 0)
     {
       SCSI_SenseCode(pdev, lun, NOT_READY, MEDIUM_NOT_PRESENT);
+      hmsc->bot_state = USBD_BOT_NO_DATA;
       return -1;
     }
 
@@ -876,25 +1041,25 @@ static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
     if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsWriteProtected(lun) != 0)
     {
       SCSI_SenseCode(pdev, lun, NOT_READY, WRITE_PROTECTED);
+      hmsc->bot_state = USBD_BOT_NO_DATA;
       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[4] << 8) |
                        (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];
 
     /* 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)
@@ -928,12 +1093,16 @@ 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;
   uint32_t len;
 
   if (hmsc == NULL)
   {
     return -1;
   }
+
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
   MSCOutEpAdd = USBD_CoreGetEPAdd(pdev, USBD_EP_OUT, USBD_EP_TYPE_BULK, (uint8_t)pdev->classId);
@@ -954,6 +1123,13 @@ static int8_t SCSI_Write12(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *param
       return -1;
     }
 
+    if (hmsc->scsi_medium_state == SCSI_MEDIUM_EJECTED)
+    {
+      SCSI_SenseCode(pdev, lun, NOT_READY, MEDIUM_NOT_PRESENT);
+      hmsc->bot_state = USBD_BOT_NO_DATA;
+      return -1;
+    }
+
     /* Check whether Media is ready */
     if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsReady(lun) != 0)
     {
@@ -970,24 +1146,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[4] << 8) |
                        (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[8] << 8) |
                       (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)
@@ -1021,19 +1196,51 @@ 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];
+  uint32_t blk_offset;
+  uint32_t blk_nbr;
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
+  if (hmsc->cbw.dDataLength != 0U)
+  {
+    SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_CDB);
+    hmsc->bot_state = USBD_BOT_NO_DATA;
+    return -1;
+  }
+
+  if (hmsc->scsi_medium_state == SCSI_MEDIUM_EJECTED)
+  {
+    SCSI_SenseCode(pdev, lun, NOT_READY, MEDIUM_NOT_PRESENT);
+    hmsc->bot_state = USBD_BOT_NO_DATA;
+    return -1;
+  }
+
+  if (((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->IsReady(lun) != 0)
+  {
+    SCSI_SenseCode(pdev, lun, NOT_READY, MEDIUM_NOT_PRESENT);
+    hmsc->bot_state = USBD_BOT_NO_DATA;
+    return -1;
+  }
+
   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);
+    hmsc->bot_state = USBD_BOT_NO_DATA;
     return -1; /* Error, Verify Mode Not supported*/
   }
 
-  if (SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr, hmsc->scsi_blk_len) < 0)
+  /* Decode LBA and verification length from current CDB */
+  blk_offset = ((uint32_t)params[2] << 24) |
+               ((uint32_t)params[3] << 16) |
+               ((uint32_t)params[4] <<  8) |
+               (uint32_t)params[5];
+
+  blk_nbr = ((uint32_t)params[7] <<  8) | (uint32_t)params[8];
+
+  if (SCSI_CheckAddressRange(pdev, lun, blk_offset, blk_nbr) < 0)
   {
     return -1; /* error */
   }
@@ -1043,6 +1250,111 @@ 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 report_idx;
+  uint32_t lun_list_length;
+  uint32_t total_length;
+  uint32_t alloc_len;
+  uint8_t lun_idx;
+
+  UNUSED(lun);
+
+  /* Define the report LUNs buffer: 8-byte header + 8 bytes per LUN entry */
+  static uint8_t lun_report[8U + (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 */
+  for (report_idx = 0U; report_idx < sizeof(lun_report); report_idx++)
+  {
+    lun_report[report_idx] = 0U;
+  }
+
+  /* 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;
+
+  /* Clamp to allocation length from CDB bytes 6-9 */
+  alloc_len = ((uint32_t)params[6] << 24) |
+              ((uint32_t)params[7] << 16) |
+              ((uint32_t)params[8] <<  8) |
+              (uint32_t)params[9];
+
+  if (alloc_len < total_length)
+  {
+    total_length = alloc_len;
+  }
+
+  /* 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;
+
+  if (hmsc == NULL)
+  {
+    return -1;
+  }
+
+  /* Extract the allocation length from the CDB */
+  allocation_length = (((uint16_t)params[3] << 8) | (uint16_t)params[4]);
+
+  if (allocation_length == 0U)
+  {
+    hmsc->bot_data_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
@@ -1055,13 +1367,21 @@ 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;
 
   if (hmsc == NULL)
   {
     return -1;
   }
 
-  if ((blk_offset + blk_nbr) > hmsc->scsi_blk_nbr)
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
+  /* Refresh cached capacity for this LUN so multi-LUN configs
+     with different sizes use the correct block count. */
+  (void)((USBD_StorageTypeDef *)pdev->pUserData[pdev->classId])->GetCapacity(lun, &p_scsi_blk->nbr,
+                                                                             &p_scsi_blk->size);
+
+  if ((blk_nbr > p_scsi_blk->nbr) || (blk_offset > (p_scsi_blk->nbr - blk_nbr)))
   {
     SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, ADDRESS_OUT_OF_RANGE);
     return -1;
@@ -1079,6 +1399,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;
   uint32_t len;
 
   if (hmsc == NULL)
@@ -1086,7 +1407,9 @@ static int8_t SCSI_ProcessRead(USBD_HandleTypeDef *pdev, uint8_t lun)
     return -1;
   }
 
-  len = hmsc->scsi_blk_len * hmsc->scsi_blk_size;
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
+  len = p_scsi_blk->len * p_scsi_blk->size;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
@@ -1096,8 +1419,8 @@ static int8_t SCSI_ProcessRead(USBD_HandleTypeDef *pdev, uint8_t lun)
   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;
@@ -1105,13 +1428,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;
   }
@@ -1128,6 +1451,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;
   uint32_t len;
 
   if (hmsc == NULL)
@@ -1135,7 +1459,9 @@ static int8_t SCSI_ProcessWrite(USBD_HandleTypeDef *pdev, uint8_t lun)
     return -1;
   }
 
-  len = hmsc->scsi_blk_len * hmsc->scsi_blk_size;
+  p_scsi_blk = &hmsc->scsi_blk[lun];
+
+  len = p_scsi_blk->len * p_scsi_blk->size;
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */
@@ -1144,27 +1470,26 @@ static int8_t SCSI_ProcessWrite(USBD_HandleTypeDef *pdev, uint8_t lun)
 
   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
@@ -484,7 +487,7 @@ static uint8_t USBD_MTP_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
         /* prepare to receive next operation */
         len = MIN(hmtp->MaxPcktLen, pdev->request.wLength);
 
-        (void)USBD_LL_PrepareReceive(pdev, MTPInEpAdd, (uint8_t *)&hmtp->rx_buff, len);
+        (void)USBD_LL_PrepareReceive(pdev, MTPOutEpAdd, (uint8_t *)&hmtp->rx_buff, len);
         break;
 
       case MTP_PHASE_IDLE :

Class/MTP/Src/usbd_mtp_opt.c

@@ -23,7 +23,7 @@
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
-static uint8_t  ObjInfo_buff[255];
+static uint8_t  ObjInfo_buff[576];
 static uint32_t objhandle;
 static uint16_t obj_format;
 static uint32_t storage_id;
@@ -385,7 +385,6 @@ void USBD_MTP_OPT_SendObject(USBD_HandleTypeDef  *pdev, uint8_t *buff, uint32_t
 {
   USBD_MTP_HandleTypeDef  *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   USBD_MTP_ItfTypeDef     *hmtpif = (USBD_MTP_ItfTypeDef *)pdev->pUserData[pdev->classId];
-  static uint32_t tmp = 0U;
 
   switch (hmtp->RECEIVE_DATA_STATUS)
   {
@@ -410,8 +409,7 @@ void USBD_MTP_OPT_SendObject(USBD_HandleTypeDef  *pdev, uint8_t *buff, uint32_t
       {
         hmtp->RECEIVE_DATA_STATUS = RECEIVE_REST_OF_DATA;
       }
-      tmp = (uint32_t)buff;
+      hmtpif->WriteData(len, (buff + 12U));
-      hmtpif->WriteData(len, (uint8_t *)(tmp + 12U));
       break;
 
     case RECEIVE_REST_OF_DATA:
@@ -474,21 +472,26 @@ void USBD_MTP_OPT_SendObjectInfo(USBD_HandleTypeDef  *pdev, uint8_t *buff, uint3
       tmp = buff;
 
       (void)USBD_memcpy(ObjInfo_buff, tmp + 12U,
-                        (uint16_t)(hmtp->MaxPcktLen - MTP_CONT_HEADER_SIZE));
+                        (uint16_t)MIN(hmtp->MaxPcktLen - MTP_CONT_HEADER_SIZE,
+                                      sizeof(ObjInfo_buff)));
 
       hmtp->RECEIVE_DATA_STATUS = RECEIVE_REST_OF_DATA;
       break;
 
     case RECEIVE_REST_OF_DATA:
-
+      if (len < (uint32_t)sizeof(ObjInfo_buff))
-      (void)USBD_memcpy(ObjInfo_buff + len, buff, hmtp->MaxPcktLen);
+      {
-
+        (void)USBD_memcpy(ObjInfo_buff + len, buff,
+                          (uint16_t)MIN(hmtp->MaxPcktLen,
+                                        sizeof(ObjInfo_buff) - len));
+      }
       break;
 
     case SEND_RESPONSE:
       (void)USBD_memcpy((uint8_t *)&ObjectInfo, ObjInfo_buff, dataLength);
       (void)USBD_memcpy((uint8_t *)&ObjectInfo.Filename, (ObjInfo_buff + dataLength),
-                        ((uint32_t)(ObjectInfo.Filename_len) * 2U));
+                        MIN((uint32_t)(ObjectInfo.Filename_len) * 2U,
+                            (uint32_t)(sizeof(ObjInfo_buff) - dataLength)));
 
       obj_format = ObjectInfo.ObjectFormat;
 
@@ -537,50 +540,31 @@ 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,
-
+                        MIN(hmtp->ResponseLength, MTP_MEDIA_PACKET));
-      for (i = 0U; i < hmtp->ResponseLength; i++)
-      {
-        hmtp->GenericContainer.data[i] = buffer[i];
-      }
       break;
 
     case MTP_OP_GET_OBJECT_INFO:
@@ -589,12 +573,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 +583,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 +592,14 @@ 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,
-      {
+                        MIN(hmtp->ResponseLength, MTP_MEDIA_PACKET));
-        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 +805,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;
@@ -919,9 +887,12 @@ static uint8_t *MTP_Get_ObjectPropValue(USBD_HandleTypeDef *pdev)
     case MTP_OB_PROP_OBJ_FILE_NAME:
       MTP_FileName.FileName_len = hmtpif->GetObjectName_len(hmtp->OperationsContainer.Param1);
       hmtpif->GetObjectName(hmtp->OperationsContainer.Param1, MTP_FileName.FileName_len, (uint16_t *)buf);
-      (void)USBD_memcpy(MTP_FileName.FileName, (uint16_t *)buf, ((uint32_t)MTP_FileName.FileName_len * 2U) + 1U);
+      (void)USBD_memcpy(MTP_FileName.FileName, (uint16_t *)buf,
+                        MIN(((uint32_t)MTP_FileName.FileName_len * 2U) + 1U,
+                            sizeof(MTP_FileName.FileName)));
 
-      hmtp->ResponseLength = ((uint32_t)MTP_FileName.FileName_len * 2U) + 1U;
+      hmtp->ResponseLength = MIN(((uint32_t)MTP_FileName.FileName_len * 2U) + 1U,
+                                 sizeof(MTP_FileName.FileName));
       break;
 
     case MTP_OB_PROP_PARENT_OBJECT :
@@ -960,6 +931,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 */
@@ -991,7 +963,9 @@ static void MTP_Get_ObjectPropList(USBD_HandleTypeDef  *pdev)
         /* MTP_FileName.FileName_len value shall be set before USBD_MTP_FS_GetObjectName */
         MTP_FileName.FileName_len = hmtpif->GetObjectName_len(hmtp->OperationsContainer.Param1);
         hmtpif->GetObjectName(hmtp->OperationsContainer.Param1, MTP_FileName.FileName_len, filename);
-        (void)USBD_memcpy(MTP_FileName.FileName, filename, ((uint32_t)MTP_FileName.FileName_len * 2U) + 1U);
+        (void)USBD_memcpy(MTP_FileName.FileName, filename,
+                          MIN(((uint32_t)MTP_FileName.FileName_len * 2U) + 1U,
+                              sizeof(MTP_FileName.FileName)));
         MTP_PropertiesList.MTP_Properties[i].propval = (uint8_t *)&MTP_FileName;
         break;
 
@@ -1015,14 +989,20 @@ static void MTP_Get_ObjectPropList(USBD_HandleTypeDef  *pdev)
         /* MTP_FileName.FileName_len value shall be set before USBD_MTP_FS_GetObjectName */
         MTP_FileName.FileName_len = hmtpif->GetObjectName_len(hmtp->OperationsContainer.Param1);
         hmtpif->GetObjectName(hmtp->OperationsContainer.Param1, MTP_FileName.FileName_len, filename);
-        (void)USBD_memcpy(MTP_FileName.FileName, filename, ((uint32_t)MTP_FileName.FileName_len * 2U) + 1U);
+        (void)USBD_memcpy(MTP_FileName.FileName, filename,
+                          MIN(((uint32_t)MTP_FileName.FileName_len * 2U) + 1U,
+                              sizeof(MTP_FileName.FileName)));
         MTP_PropertiesList.MTP_Properties[i].propval = (uint8_t *)&MTP_FileName;
         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 :
@@ -1099,7 +1079,9 @@ static void MTP_Get_ObjectInfo(USBD_HandleTypeDef  *pdev)
   /* we have to get this value before MTP_ObjectInfo.Filename */
   MTP_ObjectInfo.Filename_len = hmtpif->GetObjectName_len(hmtp->OperationsContainer.Param1);
   hmtpif->GetObjectName(hmtp->OperationsContainer.Param1, MTP_ObjectInfo.Filename_len, filename);
-  (void)USBD_memcpy(MTP_ObjectInfo.Filename, filename, ((uint32_t)MTP_FileName.FileName_len * 2U) + 1U);
+  (void)USBD_memcpy(MTP_ObjectInfo.Filename, filename,
+                    MIN(((uint32_t)MTP_ObjectInfo.Filename_len * 2U) + 1U,
+                        sizeof(MTP_ObjectInfo.Filename)));
 
   MTP_ObjectInfo.CaptureDate = 0U;
   MTP_ObjectInfo.ModificationDate = 0U;
@@ -1128,42 +1110,55 @@ static void MTP_Get_StorageIDS(void)
 static uint32_t MTP_build_data_propdesc(USBD_HandleTypeDef  *pdev, MTP_ObjectPropDescTypeDef def)
 {
   USBD_MTP_HandleTypeDef *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
-  uint8_t DefValue_size = (MTP_FileName.FileName_len * 2U) + 1U;
+  uint32_t DefValue_size;
   uint32_t dataLength = offsetof(MTP_ObjectPropDescTypeDef, DefValue);
+  uint32_t totalLength;
 
-  (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&def, dataLength);
+  /* Determine DefValue size based on data type */
-
   switch (def.DataType)
   {
     case MTP_DATATYPE_UINT16:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength, def.DefValue, sizeof(uint16_t));
+      DefValue_size = sizeof(uint16_t);
-      dataLength += sizeof(uint16_t);
       break;
 
     case MTP_DATATYPE_UINT32:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength, def.DefValue,  sizeof(uint32_t));
+      DefValue_size = sizeof(uint32_t);
-      dataLength += sizeof(uint32_t);
       break;
 
     case MTP_DATATYPE_UINT64:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength, def.DefValue,  sizeof(uint64_t));
+      DefValue_size = sizeof(uint64_t);
-      dataLength += sizeof(uint64_t);
       break;
 
     case MTP_DATATYPE_STR:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength, def.DefValue,  DefValue_size);
+      DefValue_size = ((uint32_t)MTP_FileName.FileName_len * 2U) + 1U;
-      dataLength += DefValue_size;
       break;
 
     case MTP_DATATYPE_UINT128:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength, def.DefValue, (sizeof(uint64_t) * 2U));
+      DefValue_size = (sizeof(uint64_t) * 2U);
-      dataLength += (sizeof(uint64_t) * 2U);
       break;
 
     default:
+      DefValue_size = 0U;
       break;
   }
 
+  /* Check if there is enough room in GenericContainer.data */
+  totalLength = dataLength + DefValue_size + sizeof(MTP_ObjectPropDesc.GroupCode)
+                + sizeof(MTP_ObjectPropDesc.FormFlag);
+
+  if (totalLength > MTP_MEDIA_PACKET)
+  {
+    return 0U;
+  }
+
+  (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&def, dataLength);
+
+  if ((DefValue_size > 0U) && (def.DefValue != NULL))
+  {
+    (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength, def.DefValue, DefValue_size);
+    dataLength += DefValue_size;
+  }
+
   (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength,
                     (const uint8_t *)&MTP_ObjectPropDesc.GroupCode, sizeof(MTP_ObjectPropDesc.GroupCode));
 
@@ -1187,55 +1182,57 @@ 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;
   uint32_t dataLength;
+  uint32_t payloadSize;
 
   dataLength = offsetof(MTP_PropertiesTypedef, propval);
 
+  /* Determine the payload size based on data type */
+  switch (proplist.MTP_Properties[idx].Datatype)
+  {
+    case MTP_DATATYPE_UINT16:
+      payloadSize = sizeof(uint16_t);
+      break;
+
+    case MTP_DATATYPE_UINT32:
+      payloadSize = sizeof(uint32_t);
+      break;
+
+    case MTP_DATATYPE_STR:
+      payloadSize = ((uint32_t)propval[0] * 2U) + 1U;
+      break;
+
+    case MTP_DATATYPE_UINT64:
+      payloadSize = sizeof(uint64_t);
+      break;
+
+    case MTP_DATATYPE_UINT128:
+      payloadSize = (sizeof(uint64_t) * 2U);
+      break;
+
+    default:
+      payloadSize = 0U;
+      break;
+  }
+
+  /* Check if there is enough room in GenericContainer.data for header + payload */
+  if ((hmtp->ResponseLength + dataLength + payloadSize) > MTP_MEDIA_PACKET)
+  {
+    return hmtp->ResponseLength;
+  }
+
   (void)USBD_memcpy(hmtp->GenericContainer.data + hmtp->ResponseLength,
                     (const uint8_t *)&proplist.MTP_Properties[idx], dataLength);
 
   dataLength += hmtp->ResponseLength;
 
-  switch (proplist.MTP_Properties[idx].Datatype)
+  if (payloadSize > 0U)
   {
-    case MTP_DATATYPE_UINT16:
     (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength,
-                        proplist.MTP_Properties[idx].propval, sizeof(uint16_t));
+                      proplist.MTP_Properties[idx].propval, payloadSize);
 
-      dataLength += sizeof(uint16_t);
+    dataLength += payloadSize;
-      break;
-
-    case MTP_DATATYPE_UINT32:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength,
-                        proplist.MTP_Properties[idx].propval, sizeof(uint32_t));
-
-      dataLength += sizeof(uint32_t);
-      break;
-
-    case MTP_DATATYPE_STR:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength,
-                        proplist.MTP_Properties[idx].propval, propval_size);
-
-      dataLength += propval_size;
-      break;
-
-    case MTP_DATATYPE_UINT64:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength,
-                        proplist.MTP_Properties[idx].propval, sizeof(uint64_t));
-
-      dataLength += sizeof(uint64_t);
-      break;
-
-    case MTP_DATATYPE_UINT128:
-      (void)USBD_memcpy(hmtp->GenericContainer.data + dataLength,
-                        proplist.MTP_Properties[idx].propval, (sizeof(uint64_t) * 2U));
-
-      dataLength += (sizeof(uint64_t) * 2U);
-      break;
-
-    default:
-      break;
   }
 
   return dataLength;
@@ -1251,17 +1248,25 @@ static uint32_t MTP_build_data_ObjInfo(USBD_HandleTypeDef *pdev, MTP_ObjectInfoT
 {
   USBD_MTP_HandleTypeDef *hmtp = (USBD_MTP_HandleTypeDef *)pdev->pClassDataCmsit[pdev->classId];
   uint32_t ObjInfo_len = offsetof(MTP_ObjectInfoTypeDef, Filename);
+  uint32_t fname_size;
 
   (void)USBD_memcpy(hmtp->GenericContainer.data, (const uint8_t *)&objinfo, ObjInfo_len);
+
+  fname_size = MIN((uint32_t)objinfo.Filename_len * sizeof(uint16_t),
+                   (uint32_t)(MTP_MEDIA_PACKET - ObjInfo_len));
+
     (void)USBD_memcpy(hmtp->GenericContainer.data + ObjInfo_len,
-                    (const uint8_t *)&objinfo.Filename, objinfo.Filename_len * sizeof(uint16_t));
+                      (const uint8_t *)&objinfo.Filename, fname_size);
 
-  ObjInfo_len = ObjInfo_len + (objinfo.Filename_len * sizeof(uint16_t));
+    ObjInfo_len = ObjInfo_len + fname_size;
 
+  if ((ObjInfo_len + sizeof(objinfo.CaptureDate)) <= MTP_MEDIA_PACKET)
+  {
     (void)USBD_memcpy(hmtp->GenericContainer.data + ObjInfo_len,
                       (const uint8_t *)&objinfo.CaptureDate, sizeof(objinfo.CaptureDate));
 
     ObjInfo_len = ObjInfo_len + sizeof(objinfo.CaptureDate);
+  }
 
   return ObjInfo_len;
 }

Class/MTP/Src/usbd_mtp_storage.c

@@ -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));
 
+        if (((MTP_DataLength.totallen + MTP_CONT_HEADER_SIZE) % hmtp->MaxPcktLen) == 0U)
+        {
+          /* 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;
         }
+      }
       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;
@@ -414,11 +449,26 @@ static uint8_t USBD_MTP_STORAGE_ReceiveContainer(USBD_HandleTypeDef  *pdev,
   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;
+  }
+
+  /* Convert byte count to uint32_t element count */
+  len = len / sizeof(uint32_t);
+
+  /* Clamp copy length to the size of OperationsContainer */
+  if (len > (sizeof(MTP_OperationsTypeDef) / sizeof(uint32_t)))
+  {
+    len = (sizeof(MTP_OperationsTypeDef) / sizeof(uint32_t));
+  }
+
+  for (Counter = 0U; Counter < len; Counter++)
   {
     *pdst = (hmtp->rx_buff[Counter]);
     pdst++;
   }
+
   return (uint8_t)USBD_OK;
 }
 
@@ -456,17 +506,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, (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

Class/Template/Src/usbd_template.c

@@ -76,13 +76,10 @@
   */
 
 
-
-
 /** @defgroup USBD_TEMPLATE_Private_FunctionPrototypes
   * @{
   */
 
-
 static uint8_t USBD_TEMPLATE_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx);
 static uint8_t USBD_TEMPLATE_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx);
 static uint8_t USBD_TEMPLATE_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req);

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) */
@@ -315,7 +318,7 @@ __ALIGN_BEGIN static uint8_t USBD_VIDEO_CfgDesc[] __ALIGN_END =
   UVC_IN_EP,                                     /* bEndpointAddress */
   0x05,                                          /* bmAttributes: ISO transfer */
   LOBYTE(UVC_ISO_FS_MPS),                        /* wMaxPacketSize */
-  LOBYTE(UVC_ISO_FS_MPS),
+  HIBYTE(UVC_ISO_FS_MPS),
   0x01,                                          /* bInterval: 1 frame interval */
 };
 
@@ -687,9 +690,12 @@ static uint8_t  USBD_VIDEO_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
           i++;
         }
         else
+        {
+          if (RemainData > 2U)
           {
             (void)USBD_memcpy((packet + ((DataOffset + 0U) * i) + 2U),
                               Pcktdata + ((DataOffset - 2U) * i), (RemainData - 2U));
+          }
 
           RemainData = 0U;
         }
@@ -723,7 +729,7 @@ static uint8_t  USBD_VIDEO_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
 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};
+  static uint8_t payload[2] = {0x02U, 0x00U};
 
 #ifdef USE_USBD_COMPOSITE
   /* Get the Endpoints addresses allocated for this class instance */

Core/Inc/usbd_conf_template.h

@@ -79,10 +79,12 @@ 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 */
@@ -175,8 +177,6 @@ extern "C" {
   * @}
   */
 
-
-
 /**
   * @}
   */

Core/Inc/usbd_core.h

@@ -55,13 +55,11 @@ extern "C" {
   * @{
   */
 
-
 /**
   * @}
   */
 
 
-
 /** @defgroup USBD_CORE_Exported_Macros
   * @{
   */
@@ -171,5 +169,3 @@ USBD_DescHeaderTypeDef *USBD_GetNextDesc(uint8_t *pbuf, uint16_t *ptr);
 /**
   * @}
   */
-
-

Core/Inc/usbd_ctlreq.h

@@ -53,7 +53,6 @@ extern "C" {
   */
 
 
-
 /** @defgroup USBD_REQ_Exported_Macros
   * @{
   */
@@ -97,5 +96,3 @@ void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len);
 /**
   * @}
   */
-
-

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
@@ -417,7 +418,6 @@ typedef enum
   */
 
 
-
 /** @defgroup USBD_DEF_Exported_Macros
   * @{
   */

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/Inc/usbd_ioreq.h

@@ -40,6 +40,7 @@ extern "C" {
 /** @defgroup USBD_IOREQ_Exported_Defines
   * @{
   */
+
 /**
   * @}
   */
@@ -49,13 +50,11 @@ extern "C" {
   * @{
   */
 
-
 /**
   * @}
   */
 
 
-
 /** @defgroup USBD_IOREQ_Exported_Macros
   * @{
   */
@@ -110,4 +109,3 @@ uint32_t USBD_GetRxCount(USBD_HandleTypeDef *pdev, uint8_t ep_addr);
 /**
   * @}
   */
-

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)
@@ -105,21 +105,22 @@ USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev,
 
 #ifdef USE_USBD_COMPOSITE
   /* Parse the table of classes in use */
-  for (uint32_t i = 0; i < USBD_MAX_SUPPORTED_CLASS; i++)
+  for (uint32_t i = 0U; i < USBD_MAX_SUPPORTED_CLASS; i++)
   {
     /* Unlink previous class*/
     pdev->pClass[i] = NULL;
     pdev->pUserData[i] = NULL;
 
     /* Set class as inactive */
-    pdev->tclasslist[i].Active = 0;
+    pdev->tclasslist[i].Active = 0U;
-    pdev->NumClasses = 0;
+    pdev->NumClasses = 0U;
-    pdev->classId = 0;
+    pdev->classId = 0U;
   }
 #else
   /* Unlink previous class*/
   pdev->pClass[0] = NULL;
   pdev->pUserData[0] = NULL;
+  pdev->NumClasses = 0U;
 #endif /* USE_USBD_COMPOSITE */
 
   pdev->pConfDesc = NULL;
@@ -142,9 +143,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 +196,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 +229,7 @@ USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDe
 #endif /* USE_USB_FS */
 
   /* Increment the NumClasses */
-  pdev->NumClasses ++;
+  pdev->NumClasses++;
 
   return USBD_OK;
 }
@@ -291,12 +292,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;
 
@@ -374,6 +375,7 @@ USBD_StatusTypeDef USBD_RegisterDevStateCallback(USBD_HandleTypeDef *pdev, USBD_
   return USBD_OK;
 }
 #endif /* USBD_USER_REGISTER_CALLBACK */
+
 /**
   * @brief  USBD_Start
   *         Start the USB Device Core.
@@ -499,7 +501,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)
 {
@@ -539,6 +541,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)
@@ -588,6 +591,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];
@@ -597,8 +602,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
       {
@@ -673,6 +679,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,
@@ -682,6 +689,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];
@@ -691,8 +700,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);
@@ -765,7 +775,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;
@@ -848,7 +857,6 @@ USBD_StatusTypeDef USBD_LL_SetSpeed(USBD_HandleTypeDef *pdev,
   * @param  pdev: device instance
   * @retval status
   */
-
 USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef *pdev)
 {
   if (pdev->dev_state != USBD_STATE_SUSPENDED)
@@ -867,7 +875,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)
@@ -884,7 +891,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 */
@@ -925,6 +931,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,
@@ -950,6 +957,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,

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 */
 /**
   * @}
   */
@@ -359,6 +361,12 @@ USBD_StatusTypeDef USBD_StdEPReq(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef
               break;
 
             case USBD_STATE_CONFIGURED:
+              if ((ep_addr & 0x7FU) > 0x0FU)
+              {
+                USBD_CtlError(pdev, req);
+                break;
+              }
+
               if ((ep_addr & 0x80U) == 0x80U)
               {
                 if (pdev->ep_in[ep_addr & 0xFU].is_used == 0U)
@@ -376,8 +384,8 @@ USBD_StatusTypeDef USBD_StdEPReq(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef
                 }
               }
 
-              pep = ((ep_addr & 0x80U) == 0x80U) ? &pdev->ep_in[ep_addr & 0x7FU] : \
+              pep = ((ep_addr & 0x80U) == 0x80U) ? &pdev->ep_in[ep_addr & 0xFU] : \
-                    &pdev->ep_out[ep_addr & 0x7FU];
+                    &pdev->ep_out[ep_addr & 0xFU];
 
               if ((ep_addr == 0x00U) || (ep_addr == 0x80U))
               {
@@ -421,7 +429,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)
 {
@@ -675,7 +683,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)
 {
@@ -814,7 +822,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)
 {
@@ -848,7 +856,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)
 {
@@ -889,7 +897,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)
 {
@@ -915,7 +923,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)
 {
@@ -941,8 +949,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)
@@ -1002,14 +1010,14 @@ 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++;
   unicode[idx] = USB_DESC_TYPE_STRING;
   idx++;
 
-  while (*pdesc != (uint8_t)'\0')
+  while ((*pdesc != (uint8_t)'\0') && (idx < *len))
   {
     unicode[idx] = *pdesc;
     pdesc++;

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))

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

@@ -1,80 +1,94 @@
-SLA0044 Rev5/February 2018
+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 INSTALLING, COPYING, DOWNLOADING, ACCESSING OR OTHERWISE USING THIS SOFTWARE
+BY CLICKING ON THE "I ACCEPT" BUTTON OR BY UNZIPPING, INSTALLING, COPYING,
-OR ANY PART THEREOF (AND THE RELATED DOCUMENTATION) FROM STMICROELECTRONICS
+DOWNLOADING, ACCESSING OR OTHERWISE USING THIS SOFTWARE OR ANY PART THEREOF, 
-INTERNATIONAL N.V, SWISS BRANCH AND/OR ITS AFFILIATED COMPANIES
+INCLUDING ANY RELATED DOCUMENTATION (collectively the “SOFTWARE”) 
-(STMICROELECTRONICS), THE RECIPIENT, ON BEHALF OF HIMSELF OR HERSELF, OR ON
+FROM STMICROELECTRONICS INTERNATIONAL N.V, SWISS BRANCH AND/OR 
-BEHALF OF ANY ENTITY BY WHICH SUCH RECIPIENT IS EMPLOYED AND/OR ENGAGED AGREES
+ITS AFFILIATED COMPANIES (collectively “STMICROELECTRONICS”),
-TO BE BOUND BY THIS SOFTWARE LICENSE AGREEMENT.
+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,
+Under STMICROELECTRONICS’ intellectual property rights, the redistribution,
-reproduction and use in source and binary forms of the software or any part
+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
+notice accompanying the SOFTWARE, this list of conditions and the disclaimer below.
-and 11.
 
-2. Redistributions in binary form, except as embedded into microcontroller or
+2. Redistributions in binary form, except as embedded into a processing unit device
-microprocessor device manufactured by or for STMicroelectronics or a software
+manufactured by or for STMicroelectronics or a software update for any such device,
-update for such device, must reproduce any copyright notice provided with the
+must reproduce the accompanying copyright notice, this list of conditions,
-binary code, this list of conditions, and the disclaimer set forth below as
+and the below disclaimer in capital type, in the documentation and/or
-items 10 and 11, in documentation and/or other materials provided with the
+other materials provided with the distribution.
-distribution.
 
-3. Neither the name of STMicroelectronics nor the names of other contributors to
+3. Neither the name of STMicroelectronics nor the names of other contributors
-this software may be used to endorse or promote products derived from this
+to the SOFTWARE may be used to endorse or promote products derived
-software or part thereof without specific written permission.
+from the SOFTWARE or part thereof without specific written permission.
 
-4. This software or any part thereof, including modifications and/or derivative
+4. The SOFTWARE or any part thereof, including modifications and/or
-works of this software, must be used and execute solely and exclusively on or in
+derivative works of the SOFTWARE, must be used and execute solely
-combination with a microcontroller or microprocessor device manufactured by or
+and exclusively on or in combination with a processing unit device
-for STMicroelectronics.
+manufactured by or for STMicroelectronics.
 
-5. No use, reproduction or redistribution of this software partially or totally
+5. No use, reproduction or redistribution of the SOFTWARE partially
-may be done in any manner that would subject this software to any Open Source
+or totally may be done in any manner that would subject the SOFTWARE
-Terms. “Open Source Terms” shall mean any open source license which requires as
+to any Open Source Terms. “Open Source Terms” shall mean
-part of distribution of software that the source code of such software is
+any open source license which requires as part of distribution
-distributed therewith or otherwise made available, or open source license that
+of software that the source code of such software is distributed
-substantially complies with the Open Source definition specified at
+therewith or otherwise made available, or open source license
-www.opensource.org and any other comparable open source license such as for
+that substantially complies with the Open Source definition specified
-example GNU General Public License (GPL), Eclipse Public License (EPL), Apache
+at www.opensource.org and any other comparable open source license
-Software License, BSD license or MIT 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
+6. STMicroelectronics has no obligation to provide any maintenance,
-updates for the software.
+support or updates for the SOFTWARE.
 
-7. The software is and will remain the exclusive property of STMicroelectronics
+7. The SOFTWARE is and will remain the exclusive property of
-and its licensors. The recipient will not take any action that jeopardizes
+STMicroelectronics and its licensors. The RECIPIENT will not take
-STMicroelectronics and its licensors' proprietary rights or acquire any rights
+any action that jeopardizes STMicroelectronics and its
-in the software, except the limited rights specified hereunder.
+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
+8. The RECIPIENT shall comply with all applicable laws and regulations
-the use of the software or any part thereof including any applicable export
+affecting the use of the SOFTWARE or any part thereof including
-control law or regulation.
+any applicable export control law or regulation.
 
-9. Redistribution and use of this software or any part thereof other than as
+9. Redistribution and use of the SOFTWARE or any part thereof other
-permitted under this license is void and will automatically terminate your
+than as permitted under this AGREEMENT is void and will automatically
-rights under this license.
+terminate RECIPIENT’s rights under this AGREEMENT.
 
-10. THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" AND
+10. The RECIPIENT shall be solely liable to determine and verify that
-ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+the SOFTWARE is fit for the RECIPIENT intended use, environment or
-IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+application and comply with all regulatory, safety and security
-NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, WHICH ARE
+related requirements concerning any use.
-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
+DISCLAIMER:
-EXPRESS OR IMPLIED, ARE GRANTED UNDER ANY PATENT OR OTHER INTELLECTUAL PROPERTY
+
-RIGHTS OF STMICROELECTRONICS OR ANY THIRD PARTY.
+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.

Release_Notes.md

@@ -1,545 +0,0 @@
----
-pagetitle: Release Notes for STM32Cube USB Device Library
-lang: en
-header-includes: <link rel="icon" type="image/x-icon" href="_htmresc/favicon.png" />
----
-
-::: {.row}
-::: {.col-sm-12 .col-lg-4}
-
-<center>
-# Release Notes for <mark>STM32Cube USB Device Library</mark>
-Copyright &copy; 2015 STMicroelectronics\
-
-[![ST logo](_htmresc/st_logo_2020.png)](https://www.st.com){.logo}
-</center>
-
-# Purpose
-
-The USB device library comes on top of the STM32Cube™ USB device HAL driver and
-offers all the APIs required to develop an USB device application.
-
-The main USB device library features are:
-
- - Support of multi packet transfer features allowing sending big amount of data without
-   splitting it into max packet size transfers.
- - Support of most common USB Class drivers (HID, MSC, DFU, CDC-ACM, CDC-ECM, RNDIS, MTP, AUDIO1.0, Printer, Video, Composite)
- - Configuration files to interface with Cube HAL and change the library configuration without changing
-   the library code (Read Only).
- - 32-bits aligned data structures to handle DMA based transfer in High speed modes.
-
-Here is the list of references to user documents:
-
--   [UM1734](https://www.st.com/resource/en/user_manual/DM00108129.pdf) : STM32Cube USB device library User Manual
--   [Wiki Page](https://wiki.st.com/stm32mcu/wiki/USB_overview) : STM32Cube USB Wiki Page
-
-:::
-
-::: {.col-sm-12 .col-lg-8}
-# Update History
-::: {.collapse}
-<input type="checkbox" id="collapse-section23" checked aria-hidden="true">
-<label for="collapse-section23" aria-hidden="true">V2.11.2 / 27-September-2022</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **USB Core:**
- Adding user callback to get device configuration state
- **USB DFU Class:**
- Adding DFU Vendor Commands support
- **USB MSC Class:**
- fix data sense response to be aligned with SBC-3 specification
- **USB AUDIO Class:**
- restart AUDIO ISO endpoint during ISO incomplete event
- **USB VIDEO Class:**
- restart VIDEO ISO endpoint during ISO incomplete event
-
-</div>
-:::
-
-::: {.col-sm-12 .col-lg-8}
-# Update History
-::: {.collapse}
-<input type="checkbox" id="collapse-section22" aria-hidden="true">
-<label for="collapse-section22" aria-hidden="true">V2.11.1 / 27-September-2022</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Improvement of the memory management
- **USB Core:**
- Fix some compilation warnings related to unused parameters
- Improve some code parts style
- Add check on the USB Device status in USBD_LL_Suspend before suspending it
- **USB CDC-ACM Class:**
- Remove redundant prototype declaration of USBD_CDC_GetOtherSpeedCfgDesc()
- **USB CompositeBuilder, CCID, CDC_ECM, CDC_RNDIS, CustomHID, MSC & Video Classes:**
- Improve some code parts style
-
-</div>
-:::
-
-::: {.col-sm-12 .col-lg-8}
-# Update History
-::: {.collapse}
-<input type="checkbox" id="collapse-section21" aria-hidden="true">
-<label for="collapse-section21" aria-hidden="true">V2.11.0 / 25-March-2022</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **USB VIDEO Class:**
- Correction of the support of VS_PROBE_CONTROL & VS_COMMIT_CONTROL requests
- **USB AUDIO Class:**
- Correction of the check on AUDIO_TOTAL_BUF_SIZE to avoid vulnerabilities
- **USB HID Class:**
- Modification of some constants names to avoid duplication versus USB host library
- **USB CustomHID Class:**
- Add support of Get Report control request
- Allow disabling EP OUT prepare receive using a dedicated macros that can be defined in usbd_conf.h application file
- Add support of Report Descriptor with length greater than 255 bytes
- **USB CCID Class:**
- Fix minor Code Spelling warning
- **USB All Classes:**
- Update all classes to support composite multi-instance using the class id parameter
- Fix code spelling and improve code style
- fix misraC 2012 rule 10.3
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section20" aria-hidden="true">
-<label for="collapse-section20" aria-hidden="true">V2.10.0 / 03-Sept-2021</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **Integration of  new USB device Class driver:**
- Adding support of Composite devices with an auto generation of composite device configuration descriptors
- **USB All Classes:**
- Fix Code Spelling and improve Code Style
- Update device class drivers to support Composite devices
- Improve declaration of USB configuration descriptor table which is allocated if the composite builder is not selected
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section19" aria-hidden="true">
-<label for="collapse-section19" aria-hidden="true">V2.9.0 / 06-July-2021</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **Integration of  new USB device Class driver:**
- USB CCID Class driver based on Universal Serial Bus Device Class Definition for Integrated Circuit(s) Cards Interface Devices Revision 1.1
- USB MTP Class driver based on Universal Serial Bus Device Class Media Transfer Protocol Revision 1.1
- **USB All Classes:**
- Fix Code Spelling and improve Code Style
- Update the way to declare licenses
- **USB CDC/RNDIS/ECM Classes:**
- Fix compilation warning with C++ due to missing casting during class handler allocation
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section18" aria-hidden="true">
-<label for="collapse-section18" aria-hidden="true">V2.8.0 / 10-Mars-2021</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **Integration of  new USB device Class driver:**
- USB Printer Class driver based on Universal Serial Bus Device Class Definition for Printing Devices Version 1.1
- **USB All Classes:**
- Fix USB buffer overflow vulnerability for CDC, CDC-ECM, CDC-RNDIS, DFU, AUDIO, CustomHID, and Video Classes
- Fix compilation warning with C++ due to missing casting during class handler allocation
- Enhance comments of USB configuration descriptors fields
- **USB Video Class:**
- Fix missing closing bracket for extern "C" in usbd_video.h
- Fix USBCV test with Uncompressed video format support
-
-
-</div>
-:::
-
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section17" aria-hidden="true">
-<label for="collapse-section17" aria-hidden="true">V2.7.1 / 18-August-2020</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- USB All Class: Add NULL pointer access check to Class handler
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section16" aria-hidden="true">
-<label for="collapse-section16" aria-hidden="true">V2.7.0 / 12-August-2020</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **Integration of  new USB device Class driver:**
- USB video Class driver based on USB-IF video class definition version 1.1
- **USB Core:**
- Enhance NULL pointer check in Core APIs
- Allow supporting both USER and USER Class string desc
- Add support of USB controller which handles packet-size splitting by hardware
- Avoid compilation warning due macro redefinition
- change added to USBD_HandleTypeDef structure: dev_state, old_dev_state and ep0_state declaration become volatile to disable compiler optimization
- Word spelling correction and file indentation improved
- usbd_conf.h/c Template file updated to suggest using by default a static memory allocation for Class handler
- **USB All Classes:**
- Word spelling correction and file indentation improved
- Allow updating device config descriptor Max power from user code usbd_conf.h using USBD_MAX_POWER define
- Fix device config descriptor bmAttributes value which depends on user code define USBD_SELF_POWERED
- **USB CDC Class:**
- Class specific request, add protection to limit the maximum data length to be sent by the CDC device
- **USB CustomHID Class:**
- Allow changing CustomHID data EP size from user code
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section15" aria-hidden="true">
-<label for="collapse-section15" aria-hidden="true">V2.6.1 / 05-June-2020</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Fix minor misra-c 2012 violations
- **USB Core:**
- minor rework on USBD_Init() USBD_DeInit()
- Fix warning issue with Keil due to missing return value of setup API
- **USB CDC Class:**
- Fix file indentation
- Avoid accessing to NULL pointer in case TransmitCplt() user fops is not defined to allow application compatibility with device library version below v2.6.0
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section14" aria-hidden="true">
-<label for="collapse-section14" aria-hidden="true">V2.6.0 / 27-December-2019</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Integration of three new USB device Class drivers:CDC ECM , CDC RNDIS Microsoft, USB Billboard
- Fix mandatory misra-c 2012 violations
- update user core and class template files
- **USB Core:**
- Fix unexpected EP0 stall during enumeration phase
- Improve APIs error management and prevent accessing NULL pointers
- **USB MSC Class:**
- Fix USBCV specific class tests
- Fix multiple error with SCSI commands handling
- Protect medium access when host ask for medium ejection
- **USB CDC Class:**
- Add new function to inform user that current IN transfer is completed
- update transmit and receive APIs to transfer up to 64KB
- **USB AUDIO Class:**
- Fix audio sync start buffer size
- update user callback periodicTC args by adding pointer to user buffer and size
- **USB CustomHID Class:**
- Rework the OUT transfer complete and prevent automatically re-enabling the OUT EP
- Add new user API to restart the OUT transfer: USBD_CUSTOM_HID_ReceivePacket()
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section13" aria-hidden="true">
-<label for="collapse-section13" aria-hidden="true">V2.5.3 / 30-April-2019</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Fix misra-c 2012 high severity violations
- **Core driver:**
- protect shared macros __ALIGN_BEGIN, __ALIGN_END with C directive #ifndef
- update Core driver and DFU Class driver to use USBD_SUPPORT_USER_STRING_DESC instead of  USBD_SUPPORT_USER_STRING
- prevent accessing to NULL pointer if the get descriptor functions are not defined
- Update on USBD_LL_Resume(),  restore the device state only if the current state is USBD_STATE_SUSPENDED
-
-
-</div>
-:::
-
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section12" aria-hidden="true">
-<label for="collapse-section12" aria-hidden="true">V2.5.2 / 27-Mars-2019</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- DFU Class: fix compilation warning due to unreachable instruction code introduced with CMSIS V5.4.0 NVIC_SystemReset() prototype change
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section11" aria-hidden="true">
-<label for="collapse-section11" aria-hidden="true">V2.5.1 / 03-August-2018</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Update license section by adding path to get copy of ST Ultimate Liberty license
- Core: Fix unexpected stall during status OUT phase
- DFU Class: rework hdfu struct to prevent unaligned addresses
- MSC Class: fix lba address overflow during large file transfers greater than 4Go
- Template Class: add missing Switch case Break on USBD_Template_Setup API
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section10" aria-hidden="true">
-<label for="collapse-section10" aria-hidden="true">V2.5.0 / 15-December-2017</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Update license section
- Update some functions to be MISRAC 2004 compliant
- Add HS and OtherSpeed configuration descriptor for HID and CustomHID classes
- Correct error handling in all class setup function
- Add usbd_desc_template.c/ usbd_desc_template.h templates files
- Add support of class and vendor request
- CDC Class: fix zero-length packet issue in bulk IN transfer
- Fix compilation warning with unused arguments for some functions
- Improve USB Core enumeration state machine
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section9" aria-hidden="true">
-<label for="collapse-section9" aria-hidden="true">V2.4.2 / 11-December-2015</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **CDC Class**
- usbd_cdc.c: change #include "USBD_CDC.h" by #include "usbd_cdc.h"
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section8" aria-hidden="true">
-<label for="collapse-section8" aria-hidden="true">V2.4.1 / 19-June-2015</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **CDC Class**
- usbd_cdc.c: comments update
- **MSC Class**
- usbd_msc_bot.h: update to be C++ compliant
- **AUDIO Class**
- usbd_audio.c: fix issue when Host sends GetInterface command it gets a wrong value
- usbd_audio.c: remove useless management of DMA half transfer
-
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section7" aria-hidden="true">
-<label for="collapse-section7" aria-hidden="true">V2.4.0 / 28-February-2015</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- **Core Driver**
- Add support of Link Power Management (LPM): add new API GetBOSDescriptor(), that is used only if USBD_LPM_ENABLED switch is enabled in usbd_conf.h file
- usbd_core.c: Fix bug of unsupported premature Host Out stage during data In stage (ie. when endpoint 0 maximum data size is 8 and Host requests GetDeviceDescriptor for the first time)
- usbd_ctlreq.c: Fix bug of unsupported Endpoint Class requests (ie. Audio SetCurrent request for endpoint sampling rate setting)
- **HID Class**
- Updating Polling time API USBD_HID_GetPollingInterval() to query this period for HS and FS
- usbd_hid.c: Fix USBD_LL_CloseEP() function call in USBD_HID_DeInit() replacing endpoint size by endpoint address.
- **CDC Class**
- usbd_cdc.c: Add missing GetInterface request management in USBD_CDC_Setup() function
- usbd_cdc.c: Update USBD_CDC_Setup() function to allow correct user implementation of CDC_SET_CONTROL_LINE_STATE and similar no-data setup requests.
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section6" aria-hidden="true">
-<label for="collapse-section6" aria-hidden="true">V2.3.0 / 04-November-2014</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Update all drivers to be C++ compliant
- **CDC Class**
- usbd_cdc.c: fix clear flag issue in USBD_CDC_TransmitPacket() function
- usbd_cdc_if_template.c: update TEMPLATE_Receive() function header comment
- Miscellaneous source code comments update
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section5" aria-hidden="true">
-<label for="collapse-section5" aria-hidden="true">V2.2.0 / 13-June-2014</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Source code comments review and update
- **HID class**
-  Remove unused API USBD_HID_DeviceQualifierDescriptor()
-  Add a new API in the HID class to query the poll time USBD_HID_GetPollingInterval()
- **CDC class**
-  Bug fix: missing handling ZeroLength Setup request
- **All classes**
- Add alias for the class definition, it's defined as macro with capital letter
- ex. for the HID, the USBD_HID_CLASS macro is defined this way #define USBD_HID_CLASS  &USBD_HID
- and the application code can use the previous definition: &USBD_HID ex. USBD_RegisterClass(&USBD_Device, &USBD_HID) or the new USBD_HID_CLASS ex. USBD_RegisterClass(&USBD_Device, USBD_HID_CLASS)
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section4" aria-hidden="true">
-<label for="collapse-section4" aria-hidden="true">V2.1.0 / 22-April-2014</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- usbd_conf_template.c: update file with the right content (it was using MSC memory management layer)
- usbd_conf_template.h: change include of stm32f4xx.h by stm32xxx.h and add comment to inform user to adapt it to the device used
- Several enhancements in CustomHID class
- Update the Custom HID class driver to simplify the link with user processes
- Optimize the Custom HID class driver and reduce footprint
- Add USBD_CUSTOM_HID_RegisterInterface() API to link user process to custom HID class
- Add Custom HID interface template file usbd_customhid_if_template.c/h
- Miscellaneous comments update
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section3" aria-hidden="true">
-<label for="collapse-section3" aria-hidden="true">V2.0.0 / 18-February-2014</label>
-<div>
-
-## Main Changes
-
-Major update based on STM32Cube specification.
-
- Headline
- ---------
- Library Core, Classes architecture and APIs modified vs. V1.1.0, and thus the 2 versions are not compatible.
-
-
-**This version has to be used only with STM32Cube based development**
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section2" aria-hidden="true">
-<label for="collapse-section2" aria-hidden="true">V1.1.0 / 19-March-2012</label>
-<div>
-
-## Main Changes
-
- Headline
- ---------
- Official support of STM32F4xx devices
- All source files: license disclaimer text update and add link to the License file on ST Internet.
- Handle test mode in the set feature request
- Handle dynamically the USB SELF POWERED feature
- Handle correctly the USBD_CtlError process to take into account error during Control OUT stage
- Miscellaneous bug fix
-
-</div>
-:::
-
-::: {.collapse}
-<input type="checkbox" id="collapse-section1" aria-hidden="true">
-<label for="collapse-section1" aria-hidden="true">V1.0.0 / 22-July-2011</label>
-<div>
-
-## Main Changes
-
-First official version for STM32F105/7xx and STM32F2xx devices
-
-</div>
-:::
-
-:::
-:::
-
-<footer class="sticky">
-::: {.columns}
-::: {.column width="95%"}
-:::
-::: {.column width="5%"}
-<abbr title="Based on template cx566953 version 2.1">Info</abbr>
-:::
-:::
-</footer>

SECURITY.md

@@ -1,31 +0,0 @@
-# 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.

SW_Security_Level.md

@@ -0,0 +1,47 @@
+<!-- SW Security Level -->
+
+## Copyright (c) 2026 STMicroelectronics.
+## All rights reserved
+<BR>
+<BR>
+
+## SW Security Classification
+
+[STM32Trust software security policies](https://wiki.st.com/stm32mcu/wiki/Security:STM32Trust_software_security_policies) define four levels of SW Security classification, each level defines a set of security policies for the applicable SW.
+
+| SW                                | SW Security Level
+|:--------------------------------  |:-------|
+| **STM32Cube USB Device Library**  | Medium|
+
+
+<BR>
+
+## IMPORTANT SECURITY NOTICE
+
+The STMicroelectronics group of companies (ST) places a high value on product security, which is why the ST product(s) identified in this documentation may be certified by various security certification bodies and/or may implement our own security measures as set forth herein. However, no level of security certification and/or built-in security measures can guarantee that ST products are resistant to all forms of attacks. As such, it is the responsibility of each of ST's customers to determine if the level of security provided in an ST product meets the customer needs both in relation to the ST product alone, as well as when combined with other components and/or software for the customer end product or application. In particular, take note that:
+
+-  ST products may have been certified by one or more security certification bodies, such as Platform Security Architecture (www.psacertified.org) and/or Security Evaluation standard for IoT Platforms (www.trustcb.com). For details concerning whether the ST product(s) referenced herein have received security certification along with the level and current status of such certification, either visit the relevant certification standards website or go to the relevant product page on www.st.com for the most up to date information. As the status and/or level of security certification for an ST product can change from time to time, customers should re-check security certification status/level as needed. If an ST product is not shown to be certified under a particular security standard, customers should not assume it is certified.
+
+-  Certification bodies have the right to evaluate, grant and revoke security certification in relation to ST products. These certification bodies are therefore independently responsible for granting or revoking security certification for an ST product, and ST does not take any responsibility for mistakes, evaluations, assessments, testing, or other activity carried out by the certification body with respect to any ST product.
+
+-  Industry-based cryptographic algorithms (such as AES, DES, or MD5) and other open standard technologies which may be used in conjunction with an ST product are based on standards which were not developed by ST. ST does not take responsibility for any flaws in such cryptographic algorithms or open technologies or for any methods which have been or may be developed to bypass, decrypt or crack such algorithms or technologies.
+
+-  While robust security testing may be done, no level of certification can absolutely guarantee protections against all attacks, including, for example, against advanced attacks which have not been tested for, against new or unidentified forms of attack, or against any form of attack when using an ST product outside of its specification or intended use, or in conjunction with other components or software which are used by customer to create their end product or application. ST is not responsible for resistance against such attacks. As such, regardless of the incorporated security features and/or any information or support that may be provided by ST, each customer is solely responsible for determining if the level of attacks tested for meets their needs, both in relation to the ST product alone and when incorporated into a customer end product or application.
+
+-  All security features of ST products (inclusive of any hardware, software, documentation, and the like), including but not limited to any enhanced security features added by ST, are provided on an "AS IS" BASIS.
+
+AS SUCH, TO THE EXTENT PERMITTED BY APPLICABLE LAW, ST DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, unless the applicable written and signed contract terms specifically provide otherwise.
+
+<BR>
+
+## IMPORTANT NOTICE - READ CAREFULLY
+
+STMicroelectronics NV and its subsidiaries ("ST") reserve the right to make changes, corrections, enhancements, modifications, and improvements to ST products and/or to this document at any time without notice. Purchasers should obtain the latest relevant information on ST products before placing orders. ST products are sold pursuant to ST's terms and conditions of sale in place at the time of order acknowledgment.
+
+Purchasers are solely responsible for the choice, selection, and use of ST products and ST assumes no liability for application assistance or the design of purchasers' products.
+No license, express or implied, to any intellectual property right is granted by ST herein.
+Resale of ST products with provisions different from the information set forth herein shall void any warranty granted by ST for such product.
+ST and the ST logo are trademarks of ST. For additional information about ST trademarks, refer to www.st.com/trademarks. All other product or service names are the property of their respective owners.
+Information in this document supersedes and replaces information previously supplied in any prior versions of this document.
+
+Copyright (c) 2026 STMicroelectronics - All rights reserved

_htmresc/Add_button.svg

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 200"><g fill="#13254a"><path d="M100 .212C44.868.212 0 44.889 0 99.788c0 55.132 44.868 100 100 100s100-44.868 100-100C200 44.889 155.132.212 100 .212zm0 181.164c-44.974 0-81.587-36.614-81.587-81.587 0-44.762 36.614-81.164 81.587-81.164 44.995 0 81.587 36.402 81.587 81.164 0 44.973-36.592 81.587-81.587 81.587z" style="fill: #e6007e;"/><path d="M141.1 88.127h-29.439V58.688c0-6.392-5.185-11.598-11.598-11.598-6.413 0-11.619 5.206-11.619 11.598v29.439H58.476c-6.392 0-11.598 5.185-11.598 11.598 0 6.413 5.206 11.619 11.598 11.619h29.968v29.968c0 6.392 5.206 11.598 11.619 11.598 6.413 0 11.598-5.206 11.598-11.598v-29.968H141.1c6.392 0 11.598-5.206 11.598-11.619 0-6.413-5.206-11.598-11.598-11.598z" style="fill: #e6007e;"/></g></svg>

_htmresc/Update.svg

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 200"><g fill="#03234b"><path d="M170.934 64.569l-.04-.055-29.049 40.038-.057.079h14.867a59.366 59.366 0 0 1-1.488 15.615c-1.158 5.318-3.807 13.448-9.848 21.977-2.766 4.118-6.375 7.726-9.208 10.408-3.426 2.857-7.461 6.095-12 8.376-8.121 4.568-17.881 7.138-28.225 7.432-10.907.248-20.201-2.61-26.072-5.052-8.283-3.479-14.111-7.807-16.85-10.078-1.254-.956-2.25-1.907-3.057-2.676a28.662 28.662 0 0 0-1.157-1.069 158.874 158.874 0 0 0-1.479-1.362l-4.435-3.956 3.569 4.81.183.243c.2.263.548.722 1.048 1.389.276.334.579.747.93 1.226l.008.01c.689.939 1.546 2.107 2.664 3.322 3 3.536 8.178 8.801 15.808 13.801 5.969 3.866 15.672 8.901 28.001 10.935a79.05 79.05 0 0 0 12.485.998c7.97 0 15.651-1.228 22.828-3.649 6.366-1.877 12.192-4.981 17.053-7.771 6.16-3.936 10.817-7.586 14.654-11.488 8.084-7.899 14.884-17.913 19.15-28.199 3.259-7.594 5.456-15.727 6.529-24.175l.055-.425.083-.641H200l-29.066-40.063zM58.159 99.232l-12.655.563c-.097-.881-.159-1.986-.227-3.474a59.184 59.184 0 0 1 1.446-16.56c1.157-5.316 3.804-13.444 9.848-21.977 2.168-3.228 5.009-6.44 9.208-10.415 3.41-2.849 7.432-6.08 12.005-8.375 8.114-4.568 17.87-7.138 28.213-7.432 10.9-.25 20.196 2.607 26.072 5.045 8.258 3.473 14.105 7.812 16.857 10.091 1.257.951 2.253 1.904 3.057 2.673l.017.016c.43.411.801.766 1.136 1.051.475.438.841.777 1.091 1.01l.138.128.248.229 4.04 3.613-3.165-4.456c-.058-.083-.312-.417-.73-.971l-.507-.67a28.922 28.922 0 0 1-.901-1.192l-.02-.027c-.69-.945-1.548-2.121-2.677-3.346-3.002-3.537-8.182-8.803-15.813-13.801-5.964-3.865-15.662-8.9-27.997-10.935-8.484-1.363-21.496-2.009-35.313 2.651-6.355 1.88-12.186 4.983-17.054 7.772-6.163 3.944-10.82 7.595-14.654 11.488-8.079 7.894-14.882 17.909-19.155 28.2-3.268 7.624-5.463 15.757-6.523 24.173-.436 3.281-.642 5.421-.664 6.926L0 101.831l30.683 38.727.042.053 27.38-41.298.054-.081z" style="fill: #e6007e;"/></g></svg>

_htmresc/mini-st_2020.css

@@ -45,8 +45,16 @@ body {
   @background: var(--back-color);
   background: var(--back-color) linear-gradient(#ffd200, #ffd200) repeat-y left top;
   background-size: var(--background-margin);
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
   }
 
+footer.sticky,
+.sticky {
+  margin-top: auto;
+}
+
 details {
   display: block; }
 
@@ -1597,7 +1605,7 @@ span.icon-user {
 span.icon-st-update {
   background-image: url("Update.svg"); }
 span.icon-st-add {
-  background-image: url("Add button.svg"); }
+  background-image: url("Add_button.svg"); }
 
 /*
   Definitions for utilities and helper classes.