USBX MSC + LVLX, USBD_STORAGE_Write and USBD_STORAGE_Read

Question

USBX MSC + LVLX, USBD_STORAGE_Write and USBD_STORAGE_Read

RemiNao 20

ello, I am trying to set up an external flash memory (MX25V1635F) on a Nucleo-U575ZI-Q using SPI.

I managed to simulate a disk using RAM memory, Windows formats it perfectly, which leads me to believe that my USBX configuration is correct.
I also tested my LevelX functions for reading and writing to my NOR flash, and they seem to be working correctly, which leads me to believe that the LevelX configuration is correct.
I disabled all my FileX functions (format, open, read, and write) because it seems that Windows (USB Host) takes over the formatting. (Btw, if FileX can't be used, how can I write a formatted file to my flash memory?).

My problem: when I leave the USBD_STORAGE_Write and USBD_STORAGE_Read functions empty, Windows can see the size of my disk and offers to format it (without success):

RemiNao_0-1760366801083

And when I implement these two functions (based on the only example I found online using the Levelx functions lx_nor_flash_sector_write and lx_nor_flash_sector_read: LINK), Windows can no longer read my disk volume or offer to format it. I think my functions are not defined correctly :

/**
  * @brief  USBD_STORAGE_Read
  *         This function is invoked to read from media.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  data_pointer: Address of the buffer to be used for reading or writing.
  * @PAram  number_blocks: number of sectors to read/write.
  * @PAram  lba: Logical block address is the sector address to read.
  * @PAram  media_status: should be filled out exactly like the media status
  *                       callback return value.
  * @retval status
  */
UINT USBD_STORAGE_Read(VOID *storage_instance, ULONG lun, UCHAR *data_pointer,
                       ULONG number_blocks, ULONG lba, ULONG *media_status)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Read */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(media_status);
  while(number_blocks--)
      {
 //         status =  fx_media_read(&nor_flash_disk,lba,data_pointer);
          status = lx_nor_flash_sector_read(&nor_flash,lba,data_pointer);
          data_pointer+=SECTOR_SIZE_LOGICAL;//512
          lba++;
          if (status != FX_SUCCESS) {
        	  Error_Handler();
          }
      }
//
//  for (UINT block = 0; block < number_blocks; block++)
//      {
//          //status =  fx_media_read(&nor_flash_disk,lba,data_pointer);
//          status = lx_nor_flash_sector_read(&nor_flash, lba + block, data_pointer);
//          data_pointer += SECTOR_SIZE_LOGICAL;//512
//          if(status != UX_SUCCESS)
//          {
//              break;
//          }
//      }

  /* USER CODE END USBD_STORAGE_Read */

  return status;
}

/**
  * @brief  USBD_STORAGE_Write
  *         This function is invoked to write in media.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  data_pointer: Address of the buffer to be used for reading or writing.
  * @PAram  number_blocks: number of sectors to read/write.
  * @PAram  lba: Logical block address is the sector address to read.
  * @PAram  media_status: should be filled out exactly like the media status
  *                       callback return value.
  * @retval status
  */
UINT USBD_STORAGE_Write(VOID *storage_instance, ULONG lun, UCHAR *data_pointer,
                        ULONG number_blocks, ULONG lba, ULONG *media_status)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Write */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(media_status);
  while(number_blocks--)
     {
//         status =  fx_media_write(&nor_flash_disk,lba,data_pointer);
         status = lx_nor_flash_sector_write(&nor_flash,lba,data_pointer);
         data_pointer+=SECTOR_SIZE_LOGICAL;//512
         lba++;
         if(status != FX_SUCCESS)
         {
        	 Error_Handler();
         }
     }
//  for (UINT block = 0; block < number_blocks; block++)
//     {
//         //status = fx_media_write(&nor_flash_disk, lba + block, data_pointer);
//	       status = lx_nor_flash_sector_write(&nor_flash, lba + block, data_pointer);
//         data_pointer += SECTOR_SIZE_LOGICAL;//512
//         if(status != UX_SUCCESS)
//         {
//             break;
//         }
//     }
  /* USER CODE END USBD_STORAGE_Write */

  return status;
}

For your information, here is the information from my storage instance when I do:

lx_nor_flash_open(&nor_flash, "NOR_FLASH_DISK", lx_stm32_nor_custom_driver_initialize);

Does LX_NOR_SECTOR_SIZE correspond to the size of a physical sector? Mine are 4096 bytes (or 1024 words). And will this value define the size of the logical sectors? I have the impression that the logical sectors need to be 512 bytes.

Can you help me? thanks

Nikhil Jha (Accenture International Limited) 4,230 Reputation points Microsoft External Staff Moderator

2025-10-16T07:14:57.1233333+00:00

Good day.

Will look into your issue and respond.
Allow me some time.
RemiNao 20 Reputation points

2025-10-16T07:35:53.41+00:00

Thank you,

For information, i'm already returning :
status = UX_STATE_NEXT in the read/write functions,

and i'm opening the nor flash in the activate function;

RemiNao 20

After debbug, my program go in hardfault handler after trying de read (USBD_STORAGE_Read) only when number_blocks are superior to 1.
Here is my updated code :

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    ux_device_msc.c
  * @author  MCD Application Team
  * @brief   USBX Device applicative file
  ******************************************************************************
   * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "ux_device_msc.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define STORAGE_LUN_NBR                  1
#define STORAGE_BLK_NBR                  500
#define STORAGE_BLK_SIZ                  0x200
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
extern FX_MEDIA nor_flash_disk;
extern LX_NOR_FLASH nor_flash;


__attribute__ ((section (".usb_data"))) volatile uint8_t etx_buffer[STORAGE_BLK_NBR*STORAGE_BLK_SIZ];

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  USBD_STORAGE_Activate
  *         This function is called when insertion of a storage device.
  * @PAram  storage_instance: Pointer to the storage class instance.
  * @retval none
  */
VOID USBD_STORAGE_Activate(VOID *storage_instance)
{
  /* USER CODE BEGIN USBD_STORAGE_Activate */
  UX_PARAMETER_NOT_USED(storage_instance);
  UINT status;
  status = _lx_nor_flash_open(&nor_flash, "NOR_FLASH_DISK", lx_stm32_nor_custom_driver_initialize);
  /* USER CODE END USBD_STORAGE_Activate */

  return;
}

/**
  * @brief  USBD_STORAGE_Deactivate
  *         This function is called when extraction of a storage device.
  * @PAram  storage_instance: Pointer to the storage class instance.
  * @retval none
  */
VOID USBD_STORAGE_Deactivate(VOID *storage_instance)
{
  /* USER CODE BEGIN USBD_STORAGE_Deactivate  */
  UX_PARAMETER_NOT_USED(storage_instance);
  /* USER CODE END USBD_STORAGE_Deactivate */

  return;
}

/**
  * @brief  USBD_STORAGE_Read
  *         This function is invoked to read from media.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  data_pointer: Address of the buffer to be used for reading or writing.
  * @PAram  number_blocks: number of sectors to read/write.
  * @PAram  lba: Logical block address is the sector address to read.
  * @PAram  media_status: should be filled out exactly like the media status
  *                       callback return value.
  * @retval status
  */
UINT USBD_STORAGE_Read(VOID *storage_instance, ULONG lun, UCHAR *data_pointer,
                       ULONG number_blocks, ULONG lba, ULONG *media_status)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Read */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(media_status);

  while(number_blocks>0)
      {
	  	  number_blocks--;
          status = lx_nor_flash_sector_read(&nor_flash,lba,data_pointer);
          data_pointer+=512;//512, 128
          lba++;
          if (status != LX_SUCCESS) {
        	  Error_Handler();
          }
      }

  status = UX_STATE_NEXT;
  //status = UX_SUCCESS;

  /* USER CODE END USBD_STORAGE_Read */

  return status;
}

/**
  * @brief  USBD_STORAGE_Write
  *         This function is invoked to write in media.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  data_pointer: Address of the buffer to be used for reading or writing.
  * @PAram  number_blocks: number of sectors to read/write.
  * @PAram  lba: Logical block address is the sector address to read.
  * @PAram  media_status: should be filled out exactly like the media status
  *                       callback return value.
  * @retval status
  */
UINT USBD_STORAGE_Write(VOID *storage_instance, ULONG lun, UCHAR *data_pointer,
                        ULONG number_blocks, ULONG lba, ULONG *media_status)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Write */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(media_status);

  while(number_blocks>0)
     {
	  	 number_blocks--;
         status = lx_nor_flash_sector_write(&nor_flash,lba,data_pointer);
         data_pointer+=512;//512, 128
         lba++;
         if(status != LX_SUCCESS)
         {
        	 Error_Handler();
         }
     }

  status = UX_STATE_NEXT;
  //status = UX_SUCCESS;

  /* USER CODE END USBD_STORAGE_Write */

  return status;
}

/**
  * @brief  USBD_STORAGE_Flush
  *         This function is invoked to flush media.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  number_blocks: number of sectors to read/write.
  * @PAram  lba: Logical block address is the sector address to read.
  * @PAram  media_status: should be filled out exactly like the media status
  *                       callback return value.
  * @retval status
  */
UINT USBD_STORAGE_Flush(VOID *storage_instance, ULONG lun, ULONG number_blocks,
                        ULONG lba, ULONG *media_status)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Flush */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(lun);
  UX_PARAMETER_NOT_USED(number_blocks);
  UX_PARAMETER_NOT_USED(lba);
  UX_PARAMETER_NOT_USED(media_status);

  //fx_media_flush(&nor_flash_disk);
  /* USER CODE END USBD_STORAGE_Flush */

  return status;
}

/**
  * @brief  USBD_STORAGE_Status
  *         This function is invoked to obtain the status of the device.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  media_id: is not currently used.
  * @PAram  media_status: should be filled out exactly like the media status
  *                       callback return value.
  * @retval status
  */
UINT USBD_STORAGE_Status(VOID *storage_instance, ULONG lun, ULONG media_id,
                         ULONG *media_status)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Status */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(lun);
  UX_PARAMETER_NOT_USED(media_id);

  //*media_status = UX_SUCCESS;
  /* USER CODE END USBD_STORAGE_Status */

  return status;
}

/**
  * @brief  USBD_STORAGE_Notification
  *         This function is invoked to obtain the notification of the device.
  * @PAram  storage_instance : Pointer to the storage class instance.
  * @PAram  lun: Logical unit number is the command is directed to.
  * @PAram  media_id: is not currently used.
  * @PAram  notification_class: specifies the class of notification.
  * @PAram  media_notification: response for the notification.
  * @PAram  media_notification_length: length of the response buffer.
  * @retval status
  */
UINT USBD_STORAGE_Notification(VOID *storage_instance, ULONG lun, ULONG media_id,
                               ULONG notification_class, UCHAR **media_notification,
                               ULONG *media_notification_length)
{
  UINT status = UX_SUCCESS;

  /* USER CODE BEGIN USBD_STORAGE_Notification */
  UX_PARAMETER_NOT_USED(storage_instance);
  UX_PARAMETER_NOT_USED(lun);
  UX_PARAMETER_NOT_USED(media_id);
  UX_PARAMETER_NOT_USED(notification_class);
  UX_PARAMETER_NOT_USED(media_notification);
  UX_PARAMETER_NOT_USED(media_notification_length);
  /* USER CODE END USBD_STORAGE_Notification */

  return status;
}

/**
  * @brief  USBD_STORAGE_GetMediaLastLba
  *         Get Media last LBA.
  * @PAram  none
  * @retval last lba
  */
ULONG USBD_STORAGE_GetMediaLastLba(VOID)
{
  ULONG LastLba = 0U;

  /* USER CODE BEGIN USBD_STORAGE_GetMediaLastLba */

  LastLba =  4096 - 1; //

  /* USER CODE END USBD_STORAGE_GetMediaLastLba */

  return LastLba;
}

/**
  * @brief  USBD_STORAGE_GetMediaBlocklength
  *         Get Media block length.
  * @PAram  none.
  * @retval block length.
  */
ULONG USBD_STORAGE_GetMediaBlocklength(VOID)
{
  ULONG MediaBlockLen = 0U;

  /* USER CODE BEGIN USBD_STORAGE_GetMediaBlocklength */

  MediaBlockLen = 512;//LX_NOR_SECTOR_SIZE; //SECTOR_SIZE_LOGICAL;

  /* USER CODE END USBD_STORAGE_GetMediaBlocklength */

  return MediaBlockLen;
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

And here are my physical read/write functions, lx_nor_driver_read and lx_nor_driver_write. These are called by the sector read/write functions :


static UINT lx_nor_driver_read(ULONG *flash_address, ULONG *destination, ULONG words)
{
    UINT ret = LX_SUCCESS;

    /* USER CODE BEGIN NOR_READ */

    uint32 byte_addr = (uint32)(flash_address); // + offset si besoin
    uint32 byte_len = words * sizeof(ULONG);

    if (CMD_READ(byte_addr, (uint8*)destination, byte_len) != FlashOperationSuccess){
    	ret = LX_ERROR;
    }

    /* USER CODE END  NOR_READ */

    return ret;
}

static UINT lx_nor_driver_write(ULONG *flash_address, ULONG *source, ULONG words)
{
    UINT ret = LX_SUCCESS;

    /* USER CODE BEGIN NOR_DRIVER_WRITE */

    uint32 byte_addr = (uint32)(flash_address);
    uint32 byte_len = words * sizeof(ULONG);

    // Programmer page par page (Max 256 bytes)
    uint32 offset = 0;
    uint32 chunk;
    while (offset < byte_len)
    {
    	if ((byte_len - offset) > NOR_PAGE_SIZE)
    	{
    	    chunk = NOR_PAGE_SIZE;
    	}
    	else
    	{
    	    chunk = byte_len - offset;
    	}
        if (CMD_PP(byte_addr + offset, ((uint8*)source) + offset, chunk) != FlashOperationSuccess)
        {
            ret = LX_ERROR;
            break;
        }
        offset += chunk;
    }

    /* USER CODE END  NOR_DRIVER_WRITE */

    return ret;
}

Answer accepted by question author

0 additional answers

Your answer

Nikhil Jha (Accenture International Limited) 4,230 Reputation points Microsoft External Staff Moderator

2025-10-16T07:14:57.1233333+00:00

Good day.

Will look into your issue and respond.
Allow me some time.
RemiNao 20 Reputation points

2025-10-16T07:35:53.41+00:00

Thank you,

For information, i'm already returning :
status = UX_STATE_NEXT in the read/write functions,

and i'm opening the nor flash in the activate function;

Answer 1

Hello RemiNao,

From your detailed post, code, and debug information. I have isolated the problem. Your tests with the RAM disk (proving USBX is correct) and standalone LevelX (proving your driver is correct) are perfect. The issue is, as you suspect, in the integration.

This symptom points directly to a fundamental mismatch between your USBX and LevelX configurations, which is causing a classic buffer overflow.

Possible cause you are facing is of Sector Size Mismatch:

USBX MSC Config: Your USBD_STORAGE_GetMediaBlocklength function correctly tells Windows that your disk's logical block (sector) size is 512 bytes. This is the standard for USB mass storage.
LevelX Config: Your debug screenshot of the nor_flash struct shows lx_nor_flash_sector_size: 4096. This means you have configured LevelX to use a 4096-byte logical sector.

These two systems are not speaking the same language. Windows is asking for blocks of 512 bytes, but LevelX is reading and writing blocks of 4096 bytes.

Workaround I would recommend:
You must configure LevelX to use the same 512-byte logical sector size that USBX is using. The physical sector size of your flash (4096 bytes) is different, and LevelX's entire purpose is to manage this translation.

You need to do this in your lx_stm32_nor_custom_driver_initialize function, which you pass to _lx_nor_flash_open. In that function, you must define the driver parameters.

You need to set:

Physical Sector Size: The erase-block size of your flash. This should be 4096.
Logical Sector Size: The block size you want to expose. This must be 512 to match USBX.

LevelX also requires an internal "scratch" buffer equal to the size of at least one physical sector (4096 bytes) to perform its read-modify-erase-write wear-leveling operations. You must also allocate and provide this buffer during initialization.

Once LevelX is configured with a 512-byte logical sector, your USBD_STORAGE_Read and USBD_STORAGE_Write loops will work perfectly, as lx_nor_flash_sector_read will correctly read/write one 512-byte block at a time.

Answering your other question "if FileX can't be used, how can I write a formatted file to my flash memory?"

When used as a USB Mass Storage device, the Host (Windows) is the master. It controls the file system (FAT, exFAT, etc.).

Your device's only job is to provide raw block-level access via USBD_STORAGE_Read and USBD_STORAGE_Write. You cannot (and must not) use FileX on the device at the same time, as the two file systems would instantly corrupt each other. If you need to pre-load the disk with a file, you will have to:

Implement your FileX code first.
In a "first boot" routine, open the media with FileX, format it, create a file, write to it, and close the media.
Then, un-initialize FileX and start the USBX MSC class, handing over control to the host.

Please accept the answer and upvote for visibility to other community members.

Share via

USBX MSC + LVLX, USBD_STORAGE_Write and USBD_STORAGE_Read

0 additional answers

Your answer