activating msc in RP2040USB

[WMXZ-EU]

I wanted to activate msc module in RP2040USB (not using Adafruit tinyusb implementation)
I moved the tud_msc_xxxx_cb functions from RP2040USB to a place where I have access to SD class
I created void __USBInstallMassStorage() {} to include msc descriptor.
Compile with Arduino2.3.3
run
disk symbol is created in PC File explorer (windows 11) showing vendor product information given in inquiry_cb.
but indicates disk not mounted
so far so good
As soon as I have unit_ready_cb returning true, PC repeats flashing disk symbol (assume interrogating capacity) and crashing sometimes.
So something is missing in the setup.
The capacity callback is rather simple (even putting 1024 as block_count and 512 as block_size in numbers)

Running tud_task() from ino file did not change result (I guess that is not needed)

Does there exist an msc example that is not using the Adafruit tinyusb implementation?

Here is a strip down code

     #include <SdFat.h>

      // for SPI
      #define SPI_SCK   18
      #define SPI_MOSI  19
      #define SPI_MISO  20
      #define SPI_CS    23
      #define mSPI    SPI1

     #if ENABLE_DEDICATED_SPI !=1
     #error "ENABLE_DEDICATED_SPI !=1: edit SdFatConfig.h"
     #endif

  // Try max SPI clock for an SD. Reduce SPI_CLOCK if errors occur.
  #define SD_CONFIG SdSpiConfig(SPI_CS, DEDICATED_SPI, SD_SCK_MHZ(50),(SpiPort_t *) &mSPI)

  SdFs sd;

  void spi_init()
  { pinMode(SPI_CS, OUTPUT);
    mSPI.setCS(SPI_CS);
    mSPI.setRX(SPI_MISO);
    mSPI.setTX(SPI_MOSI);
    mSPI.setSCK(SPI_SCK);
  }

uint32_t msc_status=0;
uint32_t haveStore=0;
uint32_t sdSectorCount;
void setup() {
  // put your setup code here, to run once:
  while(!Serial) continue;
  spi_init();

  if (sd.begin(SD_CONFIG)) 
  { Serial.println("card initialized.");
    sdSectorCount=sd.card()->sectorCount();
    haveStore=1;
    Serial.println(sdSectorCount);
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  if(msc_status>0) Serial.println(msc_status);
  msc_status=0;
  delay(100);
}

  // Callback invoked when received READ10 command.
  // Copy disk's data to buffer (up to bufsize) and
  // return number of copied bytes (must be multiple of block size)
  int32_t msc_read_cb (uint32_t lba, void* buffer, uint32_t bufsize) {
    bool rc;

  #if SD_FAT_VERSION >= 20000
    rc = sd.card()->readSectors(lba, (uint8_t*) buffer, bufsize/512);
  #else
    rc = sd.card()->readBlocks(lba, (uint8_t*) buffer, bufsize/512);
  #endif

    return rc ? bufsize : -1;
  }

  // Callback invoked when received WRITE10 command.
  // Process data in buffer to disk's storage and 
  // return number of written bytes (must be multiple of block size)
  int32_t msc_write_cb (uint32_t lba, uint8_t* buffer, uint32_t bufsize) {
    bool rc;

    //digitalWrite(LED_BUILTIN, HIGH);

  #if SD_FAT_VERSION >= 20000
    rc = sd.card()->writeSectors(lba, buffer, bufsize/512);
  #else
    rc = sd.card()->writeBlocks(lba, buffer, bufsize/512);
  #endif

    return rc ? bufsize : -1;
  }


  void __USBInstallMassStorage() {}

  #define min(x,y) (x<y?x:y)
  extern "C" void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4]) 
  {
      (void) lun;

    const char *vid =  "WMXZ";
    const char *pid =  "Mass Storage";
    const char *rev =  "1.0";

    msc_status=1;
    memcpy(vendor_id, vid, min(strlen(vid), 8));
    memcpy(product_id, pid, min(strlen(pid), 16));
    memcpy(product_rev, rev, min(strlen(rev), 4));
  }

  extern "C" bool tud_msc_test_unit_ready_cb(uint8_t lun) 
  {
      (void) lun;
      msc_status=2;
      //return false; // disable MSC as it does not yet work 
    return haveStore? true: false;
  }

  extern "C" void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_size) 
  {
      (void) lun;
      *block_count=0;
      *block_size=0;
      msc_status=3;
    if(!haveStore) return;
    *block_count = 1024;//sdSectorCount;
    *block_size = 512;
  }

  extern "C" int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize) 
  {
      (void) lun;
      (void) offset;
    //
      msc_status=4;
    return msc_write_cb(lba, (uint8_t*) buffer, bufsize/512);
  }

  extern "C" int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize) 
  {
      (void) lun;
      (void) offset;
    //
      msc_status=5;
    return msc_write_cb(lba, (uint8_t*) buffer, bufsize/512);
  }

  extern "C" int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize) 
  {
      (void) lun;
      (void) buffer;
      (void) bufsize;
      msc_status=6;
    if(!haveStore) return -1;
    for(int ii=0;ii<8;ii++){Serial.print(scsi_cmd[ii]); Serial.print(' ');} Serial.println(); 
    return 0;
  }

[earlephilhower]

I would suggest starting with SingleFileDrive as a base and working from there, since it's already hooking into TinyUSB and the MSC device.

[WMXZ-EU]

Update: Using the SingleFileDrive as base for replacing littleFS by SdFat, I noted the origin of the failure. USB msc buffer size is only 64 (forgot about it), while disk access is in blocks of 512 bytes. Could get success for read access by reading full blocks and extracting data according to offset, but write access (read-modify-write) still corrupts the file system.