FATFS fatFs;
FRESULT fResult;
      
fResult = f_mount(&fatFs, "0", 1);

/* Create a partition in this function */
if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &n_vol) != RES_OK || n_vol < 128)
    return FR_DISK_ERR;

if (disk_read(fs->drv, fs->win.d8, sector, 1))
    return FR_DISK_ERR;

................
    DWORD    database;        /* Data start sector */
    DWORD    winsect;        /* Current sector appearing in the win[] */
    BYTE    win[_MAX_SS];    /* Disk access window for Directory, FAT (and Data on tiny cfg) */
} FATFS;

static
BYTE check_fs (    /* 0:FAT boor sector, 1:Valid boor sector but not FAT, 2:Not a boot sector, 3:Disk error */
    FATFS* fs,    /* File system object */
    DWORD sect    /* Sector# (lba) to check if it is an FAT boot record or not */
)
{
    fs->wflag = 0; fs->winsect = 0xFFFFFFFF;    /* Invaidate window */
    if (move_window(fs, sect) != FR_OK)            /* Load boot record */
        return 3;

    if (LD_WORD(&fs->win.d8[BS_55AA]) != 0xAA55)    /* Check boot record signature (always placed at offset 510 even if the sector size is >512) */
        return 2;

    if ((LD_DWORD(&fs->win.d8[BS_FilSysType]) & 0xFFFFFF) == 0x544146)        /* Check "FAT" string */
        return 0;
    if ((LD_DWORD(&fs->win.d8[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)    /* Check "FAT" string */
        return 0;

    return 1;
}

fp->sclust = clst = create_chain(fp->fs, 0);    /* Create a new cluster chain */

if (clst == 0) break;        /* Could not allocate a new cluster (disk full) */

#include "diskio.h"
#include "ff_gen_drv.h"
#include "flash.h"
#include "spi.h"

extern Disk_drvTypeDef disk;
extern Spi spi(GPIO_PIN_10, GPIO_PIN_11, GPIO_PIN_12, GPIO_PIN_2);
extern Flash flash(spi);

/**
* @brief Initializes a Drive
* @param pdrv: Physical drive number (0..)
* @retval DSTATUS: Operation status
*/
DSTATUS disk_initialize(BYTE pdrv)
{
DSTATUS stat = RES_OK;

if(disk.is_initialized[pdrv] == 0)
{
disk.is_initialized[pdrv] = 1;
stat = disk.drv[pdrv]->disk_initialize();
}
return stat;
}

/**
* @brief Gets Disk Status
* @param pdrv: Physical drive number (0..)
* @retval DSTATUS: Operation status
*/
DSTATUS disk_status(BYTE pdrv)
{
DSTATUS stat;

stat = disk.drv[pdrv]->disk_status();
return stat;
}

/**
* @brief Reads Sector(s)
* @param pdrv: Physical drive number (0..)
* @param *buff: Data buffer to store read data
* @param sector: Sector address (LBA)
* @param count: Number of sectors to read (1..128)
* @retval DRESULT: Operation result
*/
DRESULT disk_read(BYTE pdrv, BYTE *buff, DWORD sector, BYTE count)
{
DWORD realSector = sector * 512;

flash.readArray(realSector, count * 512, buff);

return RES_OK;
}

/**
* @brief Writes Sector(s)
* @param pdrv: Physical drive number (0..)
* @param *buff: Data to be written
* @param sector: Sector address (LBA)
* @param count: Number of sectors to write (1..128)
* @retval DRESULT: Operation result
*/
#if _USE_WRITE == 1
DRESULT disk_write(BYTE pdrv, const BYTE *buff, DWORD sector, BYTE count)
{
DWORD realSector = sector * 512;

for (int i = 0; i < count; ++i)
{
flash.eraseBlock512(realSector + i * 512);
}

for(int i = 0; i < (count * 2); ++i)
{
uint8_t temp[256];
for(int j = 0; j < sizeof(temp); ++j)
{
temp[j] = buff[i * 256 + j];
}
flash.writeData(realSector + i * 256, sizeof(temp), temp);
}

return RES_OK;
}
#endif /* _USE_WRITE == 1 */

/**
* @brief I/O control operation
* @param pdrv: Physical drive number (0..)
* @param cmd: Control code
* @param *buff: Buffer to send/receive control data
* @retval DRESULT: Operation result
*/
#if _USE_IOCTL == 1
DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff)
{
DRESULT res = RES_ERROR;

switch (cmd)
{
case CTRL_SYNC:
res = RES_OK;
break;

case GET_SECTOR_COUNT:
*(DWORD*)buff = 2048;
res = RES_OK;
break;

case GET_SECTOR_SIZE:
*(DWORD*)buff = 512;
res = RES_OK;
break;

case GET_BLOCK_SIZE:
*(DWORD*)buff = 512;
res = RES_OK;
break;
}

return res;
}
#endif /* _USE_IOCTL == 1 */

/**
* @brief Gets Time from RTC
* @param None
* @retval Time in DWORD
*/
DWORD get_fattime (void)
{
return 0;
}

ncl = scl;                /* Start cluster */
    for (;;) {
        ncl++;                            /* Next cluster */
        if (ncl >= fs->n_fatent) {        /* Wrap around */
            ncl = 2;
            if (ncl > scl) return 0;    /* No free cluster */
        }
        cs = get_fat(fs, ncl);            /* Get the cluster status */
        if (cs == 0) break;                /* Found a free cluster */
        if (cs == 0xFFFFFFFF || cs == 1)/* An error occurred */
            return cs;
        if (ncl == scl) return 0;        /* No free cluster */
    }

void Flash::eraseBlock512(uint32_t address)
{
    uint8_t source[7 * 512];
    readArray(address + 512, sizeof(source), source);
    eraseBlock(address, Block4k);
    uint8_t temp[256];
    for(int i = 0; i < 14; ++i)
    {
        for(int j = 0; j < sizeof(temp); ++j)
        {
            temp[j] = source[i * 256 + j];
        }
        writeData(address + 512 + i * 256, sizeof(temp), temp);
    }
}