amt630hv160-sdk-release/amt630hv160-freertos-beta/FreeRTOS-Plus/FreeRTOS-FAT/ff_format.c

/*
 * FreeRTOS+FAT V2.3.3
 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 * https://github.com/FreeRTOS
 *
 */

/**
 *	@file		ff_format.c
 *	@ingroup	FORMAT
 *
 *	@defgroup	FAT Fat File-System
 *	@brief		Format a drive, given the number of sectors.
 *
 **/

#include "ff_headers.h"

#include <time.h>
#include <string.h>

#if defined( __BORLANDC__ )
    #include "ff_windows.h"
#else
    #include "FreeRTOS.h"
    #include "task.h" /* For FreeRTOS date/time function */
#endif


/*=========================================================================================== */

#define OFS_PART_ACTIVE_8               0x000 /* 0x01BE 0x80 if active */
#define OFS_PART_START_HEAD_8           0x001 /* 0x01BF */
#define OFS_PART_START_SEC_TRACK_16     0x002 /* 0x01C0 */
#define OFS_PART_ID_NUMBER_8            0x004 /* 0x01C2 */
#define OFS_PART_ENDING_HEAD_8          0x005 /* 0x01C3 */
#define OFS_PART_ENDING_SEC_TRACK_16    0x006 /* 0x01C4   = SectorCount - 1 - ulHiddenSectors */
#define OFS_PART_STARTING_LBA_32        0x008 /* 0x01C6   = ulHiddenSectors (This is important) */
#define OFS_PART_LENGTH_32              0x00C /* 0x01CA   = SectorCount - 1 - ulHiddenSectors */

#define OFS_PTABLE_MACH_CODE            0x000 /* 0x0000 */
#define OFS_PTABLE_PART_0               0x1BE /* 446 */
#define OFS_PTABLE_PART_1               0x1CE /* 462 */
#define OFS_PTABLE_PART_2               0x1DE /* 478 */
#define OFS_PTABLE_PART_3               0x1FE /* 494 */
#define OFS_PTABLE_PART_LEN             16

/*=========================================================================================== */

#define OFS_BPB_jmpBoot_24             0x000 /* uchar jmpBoot[3] "0xEB 0x00 0x90" */
#define OFS_BPB_OEMName_64             0x003 /* uchar BS_OEMName[8] "MSWIN4.1" */

#define OFS_BPB_BytsPerSec_16          0x00B /* Only 512, 1024, 2048 or 4096 */
#define OFS_BPB_SecPerClus_8           0x00D /* Only 1, 2, 4, 8, 16, 32, 64, 128 */
#define OFS_BPB_ResvdSecCnt_16         0x00E /* ulFATReservedSectors, e.g. 1 (FAT12/16) or 32 (FAT32) */

#define OFS_BPB_NumFATs_8              0x010 /* 2 recommended */
#define OFS_BPB_RootEntCnt_16          0x011 /* ((iFAT16RootSectors * 512) / 32) 512 (FAT12/16) or 0 (FAT32) */
#define OFS_BPB_TotSec16_16            0x013 /* xxx (FAT12/16) or 0 (FAT32) */
#define OFS_BPB_Media_8                0x015 /* 0xF0 (rem media) also in FAT[0] low byte */

#define OFS_BPB_FATSz16_16             0x016
#define OFS_BPB_SecPerTrk_16           0x018 /* n.a. CF has no tracks */
#define OFS_BPB_NumHeads_16            0x01A /* n.a. 1 ? */
#define OFS_BPB_HiddSec_32             0x01C /* n.a.	0 for nonparitioned volume */
#define OFS_BPB_TotSec32_32            0x020 /* >= 0x10000 */

#define OFS_BPB_16_DrvNum_8            0x024 /* n.a. */
#define OFS_BPB_16_Reserved1_8         0x025 /* n.a. */
#define OFS_BPB_16_BootSig_8           0x026 /* n.a. */
#define OFS_BPB_16_BS_VolID_32         0x027 /* "unique" number */
#define OFS_BPB_16_BS_VolLab_88        0x02B /* "NO NAME    " */
#define OFS_BPB_16_FilSysType_64       0x036 /* "FAT12   " */

#define OFS_BPB_32_FATSz32_32          0x024 /* Only when BPB_FATSz16 = 0 */
#define OFS_BPB_32_ExtFlags_16         0x028 /* FAT32 only */
#define OFS_BPB_32_FSVer_16            0x02A /* 0:0 */
#define OFS_BPB_32_RootClus_32         0x02C /* See 'iFAT32RootClusters' Normally 2 */
#define OFS_BPB_32_FSInfo_16           0x030 /* Normally 1 */
#define OFS_BPB_32_BkBootSec_16        0x032 /* Normally 6 */
#define OFS_BPB_32_Reserved_96         0x034 /* Zeros */
#define OFS_BPB_32_DrvNum_8            0x040 /* n.a. */
#define OFS_BPB_32_Reserved1_8         0x041 /* n.a. */
#define OFS_BPB_32_BootSig_8           0x042 /* n.a. */
#define OFS_BPB_32_VolID_32            0x043 /* "unique" number */
#define OFS_BPB_32_VolLab_88           0x047 /* "NO NAME    " */
#define OFS_BPB_32_FilSysType_64       0x052 /* "FAT12   " */

#define OFS_FSI_32_LeadSig             0x000 /* With contents 0x41615252 */
#define OFS_FSI_32_Reserved1           0x004 /* 480 times 0 */
#define OFS_FSI_32_StrucSig            0x1E4 /* With contents 0x61417272 */
#define OFS_FSI_32_Free_Count          0x1E8 /* last known free cluster count on the volume, ~0 for unknown */
#define OFS_FSI_32_Nxt_Free            0x1EC /* cluster number at which the driver should start looking for free clusters */
#define OFS_FSI_32_Reserved2           0x1F0 /* zero's */
#define OFS_FSI_32_TrailSig            0x1FC /* 0xAA550000 (little endian) */

#define RESV_COUNT                     32

#define MX_LBA_TO_MOVE_FAT             8192uL
#define SIZE_512_MB                    0x100000uL

#ifdef ffconfigMIN_CLUSTERS_FAT32
    #define MIN_CLUSTER_COUNT_FAT32    ffconfigMIN_CLUSTERS_FAT32
#else
    #define MIN_CLUSTER_COUNT_FAT32    ( 65525 )
#endif

#ifdef ffconfigMIN_CLUSTERS_FAT16
    #define MIN_CLUSTERS_FAT16    ffconfigMIN_CLUSTERS_FAT16
#else
    #define MIN_CLUSTERS_FAT16    ( 4085 + 1 )
#endif

#ifndef ffconfigFAT16_ROOT_SECTORS
    #define ffconfigFAT16_ROOT_SECTORS    32
#endif

/*-----------------------------------------------------------*/

/** A set of variables needed while formatting a disk, it is passed to the helper functions. */
struct xFormatSet
{
    uint32_t ulHiddenSectors;         /**< Space from MBR ( Master Boot Record ) and partition table. */
    uint32_t ulFSInfo;                /**< Sector number of FSINFO structure within the reserved area. */
    uint32_t ulBackupBootSector;      /**< Sector number of "copy of the boot record" within the reserved area. */
    BaseType_t xFATCount;             /**< Number of FAT's, which is fixed as 2. */
    uint32_t ulFATReservedSectors;    /**< Space between the partition table and FAT table. */
    int32_t iFAT16RootSectors;        /**< Number of sectors reserved for root directory ( FAT16 only ). */
    int32_t iFAT32RootClusters;       /**< Initial amount of clusters claimed for root directory ( FAT32 only ). */
    uint8_t ucFATType;                /**< Either 'FF_T_FAT16' or 'FF_T_FAT32'. */
    uint32_t ulVolumeID;              /**< A pseudo Volume ID. */

    uint32_t ulSectorsPerFAT;         /**< Number of sectors used by a single FAT table. */
    uint32_t ulClustersPerFATSector;  /**< # of clusters which can be described within a sector ( either 256 or 128 ). */
    uint32_t ulSectorsPerCluster;     /**< Size of a cluster ( # of sectors ). */
    uint32_t ulUsableDataSectors;     /**< Usable data sectors ( = SectorCount - ( ulHiddenSectors + ulFATReservedSectors ) ). */
    uint32_t ulUsableDataClusters;    /**< equals "ulUsableDataSectors / ulSectorsPerCluster". */
    uint32_t ulNonDataSectors;        /**< ulFATReservedSectors + ulHiddenSectors + iFAT16RootSectors. */
    uint32_t ulClusterBeginLBA;       /**< Sector address of the first data cluster. */
    uint32_t ulSectorCount;           /**< The total number of sectors in the partition. */
    uint8_t * pucSectorBuffer;        /**< A buffer big enough to contain the contents of one sector ( see pxIOManager->usSectorSize ). */
    FF_SPartFound_t xPartitionsFound; /**< An array of descriptors of partitions. */
    FF_Part_t * pxMyPartition;        /**< A pointer to the partition descriptor for the disk to be formatted. */
    FF_IOManager_t * pxIOManager;     /**< The IO-manager. */
};

/** A set of variables needed while partitioning a disk, it is passed to the helper functions. */
struct xPartitionSet
{
    uint32_t ulInterSpace;                            /**< Hidden space between 2 extended partitions. */
    FF_Part_t pxPartitions[ ffconfigMAX_PARTITIONS ]; /**< A short description of all partitions. */
    BaseType_t xPartitionCount;                       /**< The number of partitions wanted by the caller. */
    FF_IOManager_t * pxIOManager;                     /**< The +FAT IO-manager. */
};

/*-----------------------------------------------------------*/

/* Five helper functions for FF_FormatDisk(). */
static FF_Error_t prvFormatGetClusterSize( struct xFormatSet * pxSet,
                                           BaseType_t xPreferFAT16,
                                           BaseType_t xSmallClusters );

static void prvFormatOptimiseFATLocation( struct xFormatSet * pxSet );

static FF_Error_t prvFormatWriteBPB( struct xFormatSet * pxSet,
                                     const char * pcVolumeName );

static FF_Error_t prvFormatInitialiseFAT( struct xFormatSet * pxSet,
                                          int32_t lFatBeginLBA );

static FF_Error_t prvFormatInitialiseRootDir( struct xFormatSet * pxSet,
                                              int32_t lDirectoryBegin,
                                              const char * pcVolumeName );

/* And two helper functions for FF_Partition(). */
static FF_Error_t prvPartitionPrimary( struct xPartitionSet * pxSet );

static FF_Error_t prvPartitionExtended( struct xPartitionSet * pxSet,
                                        FF_PartitionParameters_t * pParams );

/*-----------------------------------------------------------*/

static portINLINE uint32_t ulMin32( uint32_t a,
                                    uint32_t b )
{
    uint32_t ulReturn;

    if( a <= b )
    {
        ulReturn = a;
    }
    else
    {
        ulReturn = b;
    }

    return ulReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief: Decide whether FAT32 or FAT16 shall be used and try to find an optimum cluster size.
 * @param[in] pxSet: A set of parameters describing this format session.
 * @param[in] xPreferFAT16: When pdTRUE, it will use FAT16 in stead of FAT32.
 * @param[in] xSmallClusters: When pdTRUE, it will make the cluster size as small as possible.
 * @return A standard +FAT error code ( not an errno ).
 * @note In order to get the best speed, use pdFALSE, pdFALSE: to get FAT32 with large clusters.
 */
static FF_Error_t prvFormatGetClusterSize( struct xFormatSet * pxSet,
                                           BaseType_t xPreferFAT16,
                                           BaseType_t xSmallClusters )
{
    FF_Error_t xReturn = FF_ERR_NONE;

    /* Either search from small to large or v.v. */
    if( xSmallClusters != 0 )
    {
        /* The caller prefers to have small clusters.
         * Less waste but it can be slower. */
        pxSet->ulSectorsPerCluster = 1U;
    }
    else
    {
        if( pxSet->ucFATType == FF_T_FAT32 )
        {
            pxSet->ulSectorsPerCluster = 64U;
        }
        else
        {
            pxSet->ulSectorsPerCluster = 32U;
        }
    }

    for( ; ; )
    {
        int32_t groupSize;
        /* Usable sectors */
        pxSet->ulUsableDataSectors = pxSet->ulSectorCount - pxSet->ulNonDataSectors;
        /* Each group consists of 'xFATCount' sectors + 'ulClustersPerFATSector' clusters */
        groupSize = pxSet->xFATCount + pxSet->ulClustersPerFATSector * pxSet->ulSectorsPerCluster;
        /* This amount of groups will fit: */
        pxSet->ulSectorsPerFAT = ( pxSet->ulUsableDataSectors + groupSize - pxSet->ulSectorsPerCluster - pxSet->xFATCount ) / groupSize;

        pxSet->ulUsableDataClusters = ulMin32(
            ( uint32_t ) ( pxSet->ulUsableDataSectors - pxSet->xFATCount * pxSet->ulSectorsPerFAT ) / pxSet->ulSectorsPerCluster,
            ( uint32_t ) ( pxSet->ulClustersPerFATSector * pxSet->ulSectorsPerFAT ) );
        pxSet->ulUsableDataSectors = pxSet->ulUsableDataClusters * pxSet->ulSectorsPerCluster;

        if( ( pxSet->ucFATType == FF_T_FAT16 ) && ( pxSet->ulUsableDataClusters >= MIN_CLUSTERS_FAT16 ) && ( pxSet->ulUsableDataClusters < 65536U ) )
        {
            break;
        }

        if( ( pxSet->ucFATType == FF_T_FAT32 ) && ( pxSet->ulUsableDataClusters >= 65536U ) && ( pxSet->ulUsableDataClusters < 0x0FFFFFEFU ) )
        {
            break;
        }

        /* Was this the last test? */
        if( ( ( xSmallClusters != pdFALSE ) && ( pxSet->ulSectorsPerCluster == 32U ) ) ||
            ( ( xSmallClusters == pdFALSE ) && ( pxSet->ulSectorsPerCluster == 1U ) ) )
        {
            FF_PRINTF( "FF_Format: Can not make a FAT%d (tried %d) with %u sectors\n",
                       pxSet->ucFATType == FF_T_FAT32 ? 32 : 16,
                       xPreferFAT16 ? 16 : 32,
                       ( unsigned ) pxSet->ulSectorCount );
            xReturn = FF_ERR_IOMAN_BAD_MEMSIZE | FF_MODULE_FORMAT;
            break;
        }

        /* No it wasn't, try next clustersize */
        if( xSmallClusters != pdFALSE )
        {
            pxSet->ulSectorsPerCluster <<= 1;
        }
        else
        {
            pxSet->ulSectorsPerCluster >>= 1;
        }
    } /* for( ;; ) */

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief: Optimise FAT location: for bigger disks, let the FAT start at 4MB.
 * @param[in] pxSet: A set of parameters describing this format session.
 */
static void prvFormatOptimiseFATLocation( struct xFormatSet * pxSet )
{
    if( ( pxSet->ucFATType == FF_T_FAT32 ) &&
        ( pxSet->ulSectorCount >= SIZE_512_MB ) &&
        ( pxSet->pxMyPartition->ulStartLBA < MX_LBA_TO_MOVE_FAT ) )
    {
        uint32_t ulRemaining;

        /*
         * Putting the FAT-table into the second 4MB erase block gives
         * a higher performance and a longer life-time.
         * See e.g. here:
         * http://3gfp.com/wp/2014/07/formatting-sd-cards-for-speed-and-lifetime/
         */
        pxSet->ulFATReservedSectors = MX_LBA_TO_MOVE_FAT - pxSet->ulHiddenSectors;
        pxSet->ulNonDataSectors = pxSet->ulFATReservedSectors + pxSet->iFAT16RootSectors;

        ulRemaining = ( pxSet->ulNonDataSectors + 2U * pxSet->ulSectorsPerFAT ) % 128U;

        if( ulRemaining != 0U )
        {
            /* In order to get ClusterBeginLBA well aligned (on a 128 sector boundary) */
            pxSet->ulFATReservedSectors += ( 128U - ulRemaining );
            pxSet->ulNonDataSectors = pxSet->ulFATReservedSectors + pxSet->iFAT16RootSectors;
        }

        pxSet->ulUsableDataSectors = pxSet->ulSectorCount - pxSet->ulNonDataSectors - 2 * pxSet->ulSectorsPerFAT;
        pxSet->ulUsableDataClusters = pxSet->ulUsableDataSectors / pxSet->ulSectorsPerCluster;
    }
}
/*-----------------------------------------------------------*/

/**
 * @brief: Write the so-called BIOS Parameter Block ( BPB ). It describes the FAT partition.
 * @param[in] pxSet: A set of parameters describing this format session.
 * @return A standard +FAT error code.
 */
static FF_Error_t prvFormatWriteBPB( struct xFormatSet * pxSet,
                                     const char * pcVolumeName )
{
    FF_Error_t xReturn;
    char pcName[ 12 ];

    ( void ) strncpy( pcName, pcVolumeName, sizeof( pcName ) - 1 );
    pcName[ sizeof( pcName ) - 1 ] = 0;

    /* Clear all fields that aren't set explicitely. */
    ( void ) memset( pxSet->pucSectorBuffer, 0, pxSet->pxIOManager->usSectorSize );

    ( void ) memcpy( pxSet->pucSectorBuffer + OFS_BPB_jmpBoot_24, "\xEB\x00\x90" "FreeRTOS", 11 );                      /* Includes OFS_BPB_OEMName_64 */

    FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_BytsPerSec_16, pxSet->pxIOManager->usSectorSize );                     /* 0x00B / Only 512, 1024, 2048 or 4096 */
    FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_ResvdSecCnt_16, ( uint32_t ) pxSet->ulFATReservedSectors );            /*  0x00E / 1 (FAT12/16) or 32 (FAT32) */

    FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_NumFATs_8, 2 );                                                         /* 0x010 / 2 recommended */
    FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_RootEntCnt_16, ( uint32_t ) ( pxSet->iFAT16RootSectors * 512 ) / 32 ); /* 0x011 / 512 (FAT12/16) or 0 (FAT32) */

    /* For FAT12 and FAT16 volumes, this field contains the count of 32- */
    /* byte directory entries in the root directory */

    FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_Media_8, 0xF8 );                                         /* 0x015 / 0xF0 (rem media) also in FAT[0] low byte */

    FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_SecPerTrk_16, 0x3F );                                   /* 0x18 n.a. CF has no tracks */
    FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_NumHeads_16, 255 );                                     /* 0x01A / n.a. 1 ? */
    FF_putLong( pxSet->pucSectorBuffer, OFS_BPB_HiddSec_32, ( uint32_t ) pxSet->ulHiddenSectors );       /* 0x01C / n.a.	0 for nonparitioned volume */

    FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_SecPerClus_8, ( uint32_t ) pxSet->ulSectorsPerCluster ); /*  0x00D / Only 1, 2, 4, 8, 16, 32, 64, 128 */
    FF_PRINTF( "FF_Format: SecCluster %lu DatSec %lu DataClus %lu pxSet->ulClusterBeginLBA %lu\n",
               pxSet->ulSectorsPerCluster, pxSet->ulUsableDataSectors, pxSet->ulUsableDataClusters, pxSet->ulClusterBeginLBA );

    /* This field is the new 32-bit total count of sectors on the volume. */
    /* This count includes the count of all sectors in all four regions of the volume */
    FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_TotSec16_16, 0 );                   /* 0x013 / xxx (FAT12/16) or 0 (FAT32) */

    FF_putLong( pxSet->pucSectorBuffer, OFS_BPB_TotSec32_32, pxSet->ulSectorCount ); /* 0x020 / >= 0x10000 */

    if( pxSet->ucFATType == FF_T_FAT32 )
    {
        FF_putLong( pxSet->pucSectorBuffer, OFS_BPB_32_FATSz32_32, pxSet->ulSectorsPerFAT );                  /* 0x24 / Only when BPB_FATSz16 = 0 */
        FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_32_ExtFlags_16, 0 );                                     /* 0x28 / FAT32 only */
        FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_32_FSVer_16, 0 );                                        /* 0x2A / 0:0 */
        FF_putLong( pxSet->pucSectorBuffer, OFS_BPB_32_RootClus_32, ( uint32_t ) pxSet->iFAT32RootClusters ); /* 0x2C / Normally 2 */
        FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_32_FSInfo_16, pxSet->ulFSInfo );                         /* 0x30 / Normally 1 */
        FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_32_BkBootSec_16, pxSet->ulBackupBootSector );            /* 0x32 / Normally 6 */
        FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_32_DrvNum_8, 0 );                                         /* 0x40 / n.a. */
        FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_32_BootSig_8, 0x29 );                                     /* 0x42 / n.a. */
        FF_putLong( pxSet->pucSectorBuffer, OFS_BPB_32_VolID_32, ( uint32_t ) pxSet->ulVolumeID );            /* 0x43 / "unique" number */
        ( void ) memcpy( pxSet->pucSectorBuffer + OFS_BPB_32_VolLab_88, pcName, 11 );                         /* 0x47 / "NO NAME    " */
        ( void ) memcpy( pxSet->pucSectorBuffer + OFS_BPB_32_FilSysType_64, "FAT32   ", 8 );                  /* 0x52 / "FAT12   " */
    }
    else
    {
        FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_16_DrvNum_8, 0u );                                /* 0x024 / n.a. */
        FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_16_Reserved1_8, 0 );                              /* 0x025 / n.a. */
        FF_putChar( pxSet->pucSectorBuffer, OFS_BPB_16_BootSig_8, 0x29 );                             /* 0x026 / n.a. */
        FF_putLong( pxSet->pucSectorBuffer, OFS_BPB_16_BS_VolID_32, ( uint32_t ) pxSet->ulVolumeID ); /* 0x027 / "unique" number */

        FF_putShort( pxSet->pucSectorBuffer, OFS_BPB_FATSz16_16, pxSet->ulSectorsPerFAT );            /* 0x16 */

        ( void ) memcpy( pxSet->pucSectorBuffer + OFS_BPB_16_BS_VolLab_88, "MY NAME    ", 11 );       /* 0x02B / "NO NAME    " */
        ( void ) memcpy( pxSet->pucSectorBuffer + OFS_BPB_16_FilSysType_64, "FAT16   ", 8 );          /* 0x036 / "FAT12   " */
    }

    pxSet->pucSectorBuffer[ FF_FAT_MBR_SIGNATURE + 0 ] = 0x55;
    pxSet->pucSectorBuffer[ FF_FAT_MBR_SIGNATURE + 1 ] = 0xAA;

    xReturn = FF_BlockWrite( pxSet->pxIOManager, pxSet->ulHiddenSectors, 1, pxSet->pucSectorBuffer, 0u );

    if( ( pxSet->ucFATType == FF_T_FAT32 ) &&
        ( FF_isERR( xReturn ) == pdFALSE ) )
    {
        /* Store a backup copy of the boot sector. */
        xReturn = FF_BlockWrite( pxSet->pxIOManager, pxSet->ulHiddenSectors + pxSet->ulBackupBootSector, 1, pxSet->pucSectorBuffer, pdFALSE );
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief: Initialise and clear the File Allocation Table ( FAT ).
 * @param[in] pxSet: A set of parameters describing this format session.
 * @param[in] lFatBeginLBA: The number of first sector of the FAT.
 * @return A standard +FAT error code.
 */
static FF_Error_t prvFormatInitialiseFAT( struct xFormatSet * pxSet,
                                          int32_t lFatBeginLBA )
{
    FF_Error_t xReturn;

    ( void ) memset( pxSet->pucSectorBuffer, 0, pxSet->pxIOManager->usSectorSize );

    switch( pxSet->ucFATType )
    {
        case FF_T_FAT16:
            FF_putShort( pxSet->pucSectorBuffer, 0, 0xFFF8U ); /* First FAT entry. */
            FF_putShort( pxSet->pucSectorBuffer, 2, 0xFFFFU ); /* RESERVED alloc. */
            break;

        case FF_T_FAT32:
            FF_putLong( pxSet->pucSectorBuffer, 0, 0x0FFFFFF8U ); /* FAT32 FAT sig. */
            FF_putLong( pxSet->pucSectorBuffer, 4, 0xFFFFFFFFU ); /* RESERVED alloc. */
            FF_putLong( pxSet->pucSectorBuffer, 8, 0x0FFFFFFFU ); /* Root dir allocation. */
            break;

        default:
            break;
    }

    xReturn = FF_BlockWrite( pxSet->pxIOManager, ( uint32_t ) lFatBeginLBA, 1, pxSet->pucSectorBuffer, pdFALSE );

    if( FF_isERR( xReturn ) == pdFALSE )
    {
        xReturn = FF_BlockWrite( pxSet->pxIOManager, ( uint32_t ) lFatBeginLBA + pxSet->ulSectorsPerFAT, 1, pxSet->pucSectorBuffer, pdFALSE );
    }

    FF_PRINTF( "FF_Format: Clearing entire FAT (2 x %lu sectors):\n", pxSet->ulSectorsPerFAT );
    {
        int32_t addr;

        ( void ) memset( pxSet->pucSectorBuffer, 0, pxSet->pxIOManager->usSectorSize );

        for( addr = lFatBeginLBA + 1;
             ( addr < ( lFatBeginLBA + ( int32_t ) pxSet->ulSectorsPerFAT ) ) &&
             ( FF_isERR( xReturn ) == pdFALSE );
             addr++ )
        {
            xReturn = FF_BlockWrite( pxSet->pxIOManager, ( uint32_t ) addr, 1, pxSet->pucSectorBuffer, pdFALSE );

            if( FF_isERR( xReturn ) == pdFALSE )
            {
                xReturn = FF_BlockWrite( pxSet->pxIOManager, ( uint32_t ) addr + pxSet->ulSectorsPerFAT, 1, pxSet->pucSectorBuffer, pdFALSE );
            }
        }
    }
    FF_PRINTF( "FF_Format: Clearing done\n" );

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief: Initialise and clear the root directory.
 * @param[in] pxSet: A set of parameters describing this format session.
 * @return A standard +FAT error code.
 */
static FF_Error_t prvFormatInitialiseRootDir( struct xFormatSet * pxSet,
                                              int32_t lDirectoryBegin,
                                              const char * pcVolumeName )
{
    FF_Error_t xReturn = FF_ERR_NONE;
    int32_t lAddress;
    int32_t lLastAddress;
    BaseType_t xHasCleared = pdFALSE;

    ( void ) memset( pxSet->pucSectorBuffer, 0, pxSet->pxIOManager->usSectorSize );
    ( void ) memcpy( pxSet->pucSectorBuffer, pcVolumeName, 11 );
    pxSet->pucSectorBuffer[ 11 ] = FF_FAT_ATTR_VOLID;

    if( pxSet->iFAT16RootSectors != 0 )
    {
        lLastAddress = lDirectoryBegin + pxSet->iFAT16RootSectors;
    }
    else
    {
        lLastAddress = lDirectoryBegin + pxSet->ulSectorsPerCluster;
    }

    FF_PRINTF( "FF_Format: Clearing root directory at %08lX: %lu sectors\n", lDirectoryBegin, lLastAddress - lDirectoryBegin );

    for( lAddress = lDirectoryBegin;
         ( lAddress < lLastAddress ) && ( FF_isERR( xReturn ) == pdFALSE );
         lAddress++ )
    {
        xReturn = FF_BlockWrite( pxSet->pxIOManager, ( uint32_t ) lAddress, 1, pxSet->pucSectorBuffer, 0u );

        if( xHasCleared == pdFALSE )
        {
            xHasCleared = pdTRUE;
            ( void ) memset( pxSet->pucSectorBuffer, 0, pxSet->pxIOManager->usSectorSize );
        }
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Now deprecated, please use the new function 'FF_FormatDisk()'.
 * @param[in] pxDisk: The disk object.
 * @param[in] xPartitionNumber: the numer of the partitioned that must be FAT-formatted.
 * @param[in] xPreferFAT16: When pdTRUE, it will use FAT16 in stead of FAT32.
 * @param[in] xSmallClusters: When pdTRUE, it will make the cluster size as small as possible.
 * @return A standard +FAT error code ( not an errno ).
 */
FF_Error_t FF_Format( FF_Disk_t * pxDisk,
                      BaseType_t xPartitionNumber,
                      BaseType_t xPreferFAT16,
                      BaseType_t xSmallClusters )
{
    return FF_FormatDisk( pxDisk, xPartitionNumber, xPreferFAT16, xSmallClusters, "MY_DISK    " );
}
/*-----------------------------------------------------------*/

/*_RB_ Candidate for splitting into multiple functions? */

/**
 * @brief Format a partition of a disk, either as FAT16 or FAT32. It assumes that
 *        is has already been partitioned.
 * @param[in] pxDisk: The disk object.
 * @param[in] xPartitionNumber: the numer of the partitioned that must be FAT-formatted.
 * @param[in] xPreferFAT16: When pdTRUE, it will use FAT16 in stead of FAT32.
 * @param[in] xSmallClusters: When pdTRUE, it will make the cluster size as small as possible.
 * @param[in] pcVolumeName: A  string of 11 characters representing the name of the disk.
 * @return A standard +FAT error code ( not an errno ).
 */
FF_Error_t FF_FormatDisk( FF_Disk_t * pxDisk,
                          BaseType_t xPartitionNumber,
                          BaseType_t xPreferFAT16,
                          BaseType_t xSmallClusters,
                          const char * pcVolumeName )
{
    struct xFormatSet xSet;
    int32_t lFatBeginLBA;
    int32_t lDirectoryBegin;
    FF_Error_t xReturn = FF_ERR_NONE;

    memset( &( xSet ), 0, sizeof xSet );

    xSet.ulFSInfo = 1;           /* Sector number of FSINFO structure within the reserved area */
    xSet.ulBackupBootSector = 6; /* Sector number of "copy of the boot record" within the reserved area */
    xSet.xFATCount = 2;          /* Number of FAT's */
    xSet.pxIOManager = pxDisk->pxIOManager;

    FF_PartitionSearch( xSet.pxIOManager, &xSet.xPartitionsFound );

    /* Introducing a do {} while(false) loop for easy exit without return. */
    do
    {
        if( xPartitionNumber >= xSet.xPartitionsFound.iCount )
        {
            xReturn = FF_ERR_IOMAN_INVALID_PARTITION_NUM | FF_MODULE_FORMAT;
            break;
        }

        xSet.pxMyPartition = xSet.xPartitionsFound.pxPartitions + xPartitionNumber;
        xSet.ulSectorCount = xSet.pxMyPartition->ulSectorCount;

        xSet.ulHiddenSectors = xSet.pxMyPartition->ulStartLBA;

        if( ( ( xPreferFAT16 == pdFALSE ) && ( ( xSet.ulSectorCount - RESV_COUNT ) >= 65536 ) ) ||
            ( ( xSet.ulSectorCount - RESV_COUNT ) >= ( 64 * MIN_CLUSTER_COUNT_FAT32 ) ) )
        {
            xSet.ucFATType = FF_T_FAT32;
            xSet.iFAT32RootClusters = 2;
            xSet.ulFATReservedSectors = RESV_COUNT;
            xSet.iFAT16RootSectors = 0;
        }
        else
        {
            xSet.ucFATType = FF_T_FAT16;
            xSet.iFAT32RootClusters = 0;
            xSet.ulFATReservedSectors = 1u;
            xSet.iFAT16RootSectors = ffconfigFAT16_ROOT_SECTORS; /* 32 sectors to get 512 dir entries */
        }

        /* Set start sector and length to allow FF_BlockRead/Write */
        xSet.pxIOManager->xPartition.ulTotalSectors = xSet.pxMyPartition->ulSectorCount;
        xSet.pxIOManager->xPartition.ulBeginLBA = xSet.pxMyPartition->ulStartLBA;

        /* TODO: Find some solution here to get a unique disk ID */
        xSet.ulVolumeID = ( rand() << 16 ) | rand(); /*_RB_ rand() has proven problematic in some environments. */

        /* Sectors within partition which can not be used */
        xSet.ulNonDataSectors = xSet.ulFATReservedSectors + xSet.iFAT16RootSectors;

        /* A fs dependent constant: */
        if( xSet.ucFATType == FF_T_FAT32 )
        {
            /* In FAT32, 4 bytes are needed to store the address (LBA) of a cluster.
             * A FAT sector of 512 bytes can contain 512 / 4 = 128 entries. */
            xSet.ulClustersPerFATSector = xSet.pxIOManager->usSectorSize / sizeof( uint32_t );
        }
        else
        {
            /* In FAT16, 2 bytes are needed to store the address (LBA) of a cluster.
             * A FAT sector of 512 bytes can contain 512 / 2 = 256 entries. */
            xSet.ulClustersPerFATSector = xSet.pxIOManager->usSectorSize / sizeof( uint16_t );
        }

        FF_PRINTF( "FF_Format: Secs %lu Rsvd %lu Hidden %lu Root %lu Data %lu\n",
                   xSet.ulSectorCount, xSet.ulFATReservedSectors, xSet.ulHiddenSectors, xSet.iFAT16RootSectors, xSet.ulSectorCount - xSet.ulNonDataSectors );

        /*****************************/

        /* Try to find the optimum sector size, and choose betwee FAT16 and FAT32.
         */
        xReturn = prvFormatGetClusterSize( &( xSet ), xPreferFAT16, xSmallClusters );

        if( FF_isERR( xReturn ) != pdFALSE )
        {
            break;
        }

        /*****************************/

        /* Optimise FAT location: for bigger disks, let the FAT start at an offset of 4MB,
         * because that memory is optimised for FAT purposes ( i.e. frequent changes ).
         */
        prvFormatOptimiseFATLocation( &( xSet ) );

        xSet.ulClusterBeginLBA = xSet.ulHiddenSectors + xSet.ulFATReservedSectors + 2 * xSet.ulSectorsPerFAT;

        /* Allocate a buffer space to hold a full sector. */
        xSet.pucSectorBuffer = ( uint8_t * ) ffconfigMALLOC( xSet.pxIOManager->usSectorSize );

        if( xSet.pucSectorBuffer == NULL )
        {
            xReturn = FF_ERR_NOT_ENOUGH_MEMORY | FF_MODULE_FORMAT;
            break;
        }

        /*****************************/

        /* Write the so-called BIOS parameter block (BPB). It describes the FAT partition. */
        xReturn = prvFormatWriteBPB( &( xSet ), pcVolumeName );

        if( FF_isERR( xReturn ) != pdFALSE )
        {
            break;
        }

        /*****************************/

        if( xSet.ucFATType == FF_T_FAT32 )
        {
            /* FAT32 stores extra information in the FSInfo sector, usually sector 1. */
            ( void ) memset( xSet.pucSectorBuffer, 0, xSet.pxIOManager->usSectorSize );

            FF_putLong( xSet.pucSectorBuffer, OFS_FSI_32_LeadSig, 0x41615252 );                   /* to validate that this is in fact an FSInfo sector. */
            /* OFS_FSI_32_Reserved1		0x004 / 480 times 0 */
            FF_putLong( xSet.pucSectorBuffer, OFS_FSI_32_StrucSig, 0x61417272 );                  /* Another signature that is more localized in the */
            /* sector to the location of the fields that are used. */
            FF_putLong( xSet.pucSectorBuffer, OFS_FSI_32_Free_Count, xSet.ulUsableDataClusters ); /* last known free cluster count on the volume, ~0 for unknown */
            FF_putLong( xSet.pucSectorBuffer, OFS_FSI_32_Nxt_Free, 2 );                           /* cluster number at which the driver should start looking for free clusters */
            /* OFS_FSI_32_Reserved2		0x1F0 / zero's */
            FF_putLong( xSet.pucSectorBuffer, OFS_FSI_32_TrailSig, 0xAA550000 );                  /* Will correct for endianness */

            FF_BlockWrite( xSet.pxIOManager, xSet.ulHiddenSectors + xSet.ulFSInfo, 1, xSet.pucSectorBuffer, pdFALSE );
            FF_BlockWrite( xSet.pxIOManager, xSet.ulHiddenSectors + xSet.ulFSInfo + xSet.ulBackupBootSector, 1, xSet.pucSectorBuffer, pdFALSE );
        }

        /*****************************/
        lFatBeginLBA = xSet.ulHiddenSectors + xSet.ulFATReservedSectors;

        /* Initialise the FAT. */
        xReturn = prvFormatInitialiseFAT( &( xSet ), lFatBeginLBA );

        if( FF_isERR( xReturn ) != pdFALSE )
        {
            break;
        }

        /*****************************/
        lDirectoryBegin = lFatBeginLBA + ( 2 * xSet.ulSectorsPerFAT );
        #if ( ffconfigTIME_SUPPORT != 0 )
            {
                FF_SystemTime_t str_t;
                int16_t myShort;

                FF_GetSystemTime( &str_t );

                myShort = ( ( str_t.Hour << 11 ) & 0xF800 ) |
                          ( ( str_t.Minute << 5 ) & 0x07E0 ) |
                          ( ( str_t.Second / 2 ) & 0x001F );
                FF_putShort( xSet.pucSectorBuffer, 22, ( uint32_t ) myShort );

                myShort = ( ( ( str_t.Year - 1980 ) << 9 ) & 0xFE00 ) |
                          ( ( str_t.Month << 5 ) & 0x01E0 ) |
                          ( str_t.Day & 0x001F );
                FF_putShort( xSet.pucSectorBuffer, 24, ( uint32_t ) myShort );
            }
        #endif /* ffconfigTIME_SUPPORT */

        /* Initialise and clear the root directory. */
        xReturn = prvFormatInitialiseRootDir( &( xSet ), lDirectoryBegin, pcVolumeName );
    }
    while( pdFALSE );

    /* Free the sector buffer. */
    ffconfigFREE( xSet.pucSectorBuffer );

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Create primary and extended partitions.
 * @param[in] pxSet: A set of parameters describing this format session.
 * @return A standard +FAT error code.
 */
static FF_Error_t prvPartitionPrimary( struct xPartitionSet * pxSet )
{
    FF_Error_t xReturn = FF_ERR_NONE;
    FF_Buffer_t * pxSectorBuffer;
    uint8_t * pucBuffer;
    uint32_t ulPartitionOffset; /* Pointer within partition table */
    BaseType_t xPartitionNumber;

    pxSectorBuffer = FF_GetBuffer( pxSet->pxIOManager, 0, ( uint8_t ) FF_MODE_WRITE );
    {
        if( pxSectorBuffer == NULL )
        {
            return FF_ERR_DEVICE_DRIVER_FAILED;
        }
    }

    pucBuffer = pxSectorBuffer->pucBuffer;
    ( void ) memset( pucBuffer, 0, pxSet->pxIOManager->usSectorSize );
    ( void ) memcpy( pucBuffer + OFS_BPB_jmpBoot_24, "\xEB\x00\x90" "FreeRTOS", 11 ); /* Includes OFS_BPB_OEMName_64 */
    ulPartitionOffset = OFS_PTABLE_PART_0;

    for( xPartitionNumber = 0; xPartitionNumber < ffconfigMAX_PARTITIONS; xPartitionNumber++ )
    {
        FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_ACTIVE_8, pxSet->pxPartitions[ xPartitionNumber ].ucActive );                  /* 0x01BE 0x80 if active */
        FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_START_HEAD_8, 1 );                                                             /* 0x001 / 0x01BF */
        FF_putShort( pucBuffer, ulPartitionOffset + OFS_PART_START_SEC_TRACK_16, 1 );                                                      /* 0x002 / 0x01C0 */
        FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_ID_NUMBER_8, pxSet->pxPartitions[ xPartitionNumber ].ucPartitionID );          /* 0x004 / 0x01C2 */
        FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_ENDING_HEAD_8, 0xFE );                                                         /* 0x005 / 0x01C3 */
        FF_putShort( pucBuffer, ulPartitionOffset + OFS_PART_ENDING_SEC_TRACK_16, pxSet->pxPartitions[ xPartitionNumber ].ulSectorCount ); /* 0x006 / 0x01C4 */
        FF_putLong( pucBuffer, ulPartitionOffset + OFS_PART_STARTING_LBA_32, pxSet->pxPartitions[ xPartitionNumber ].ulStartLBA );         /* 0x008 / 0x01C6 This is important */
        FF_putLong( pucBuffer, ulPartitionOffset + OFS_PART_LENGTH_32, pxSet->pxPartitions[ xPartitionNumber ].ulSectorCount );            /* 0x00C / 0x01CA Equal to total sectors */
        ulPartitionOffset += 16;
    }

    pucBuffer[ FF_FAT_MBR_SIGNATURE + 0 ] = 0x55;
    pucBuffer[ FF_FAT_MBR_SIGNATURE + 1 ] = 0xAA;

    FF_ReleaseBuffer( pxSet->pxIOManager, pxSectorBuffer );
    FF_FlushCache( pxSet->pxIOManager );

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Create primary and extended partitions.
 * @param[in] pxSet: A set of parameters describing this format session.
 * @param[in] pParams: A set of variables describing the partitions.
 * @return A standard +FAT error code.
 */
static FF_Error_t prvPartitionExtended( struct xPartitionSet * pxSet,
                                        FF_PartitionParameters_t * pParams )
{
    /* Create at least 1 extended/logical partition */
    FF_Error_t xReturn = FF_ERR_NONE;
    int index;
    /* Start of the big extended partition */
    unsigned extendedLBA = pParams->ulHiddenSectors;
    /* Where to write the table */
    uint32_t ulLBA = 0;
    /* Contents of the table */
    FF_Part_t writeParts[ 4 ];
    BaseType_t xPartitionNumber;
    FF_Buffer_t * pxSectorBuffer;
    uint8_t * pucBuffer;
    uint32_t ulPartitionOffset; /**< Pointer within partition table */

    for( index = -1; index < pxSet->xPartitionCount; index++ )
    {
        uint32_t ulNextLBA;

        ( void ) memset( writeParts, 0, sizeof( writeParts ) );

        if( index < 0 )
        {
            /* We're at sector 0: */
            /* Write primary partitions, if any */
            /* Create big extended partition */
            uint32_t ulStartLBA = pParams->ulHiddenSectors;

            for( xPartitionNumber = 0; xPartitionNumber < pParams->xPrimaryCount; xPartitionNumber++ )
            {
                writeParts[ xPartitionNumber ].ulStartLBA = ulStartLBA;
                writeParts[ xPartitionNumber ].ulSectorCount = pxSet->pxPartitions[ xPartitionNumber ].ulSectorCount;
                writeParts[ xPartitionNumber ].ucActive = 0x80;
                writeParts[ xPartitionNumber ].ucPartitionID = 0x0B;
                ulStartLBA += writeParts[ xPartitionNumber ].ulSectorCount;
                index++;
            }

            /* _HT_ index = 0, 1, or 2. index < xPrimaryCount. */
            /* _HT_ xPartitionNumber == pParams->xPrimaryCount. */
            /* Now define the extended partition. */
            extendedLBA = ulStartLBA;
            writeParts[ xPartitionNumber ].ulStartLBA = ulStartLBA;
            writeParts[ xPartitionNumber ].ulSectorCount = pParams->ulSectorCount - ulStartLBA;
            writeParts[ xPartitionNumber ].ucActive = 0x80;
            writeParts[ xPartitionNumber ].ucPartitionID = FF_DOS_EXT_PART; /* 0x05 */
            ulNextLBA = ulStartLBA;
        }
        else
        {
            /* Create a logical partition with "ulSectorCount" sectors: */
            writeParts[ 0 ].ulStartLBA = pxSet->ulInterSpace;
            writeParts[ 0 ].ulSectorCount = pxSet->pxPartitions[ index ].ulSectorCount;
            writeParts[ 0 ].ucActive = 0x80;
            writeParts[ 0 ].ucPartitionID = 0x0B;

            if( index < pxSet->xPartitionCount - 1 )
            {
                /* Next extended partition */
                writeParts[ 1 ].ulStartLBA = pxSet->ulInterSpace + ulLBA - extendedLBA + writeParts[ 0 ].ulSectorCount;
                /* Compilers may warn about the out-of-bounds indexing 'pxSet->pxPartitions[index+1]'. */
                writeParts[ 1 ].ulSectorCount = pxSet->pxPartitions[ index + 1 ].ulSectorCount + pxSet->ulInterSpace;
                writeParts[ 1 ].ucActive = 0x80;
                writeParts[ 1 ].ucPartitionID = 0x05;
            }

            ulNextLBA = writeParts[ 1 ].ulStartLBA + extendedLBA;
        }

        pxSectorBuffer = FF_GetBuffer( pxSet->pxIOManager, ( uint32_t ) ulLBA, ( uint8_t ) FF_MODE_WRITE );
        {
            if( pxSectorBuffer == NULL )
            {
                return FF_ERR_DEVICE_DRIVER_FAILED;
            }
        }
        pucBuffer = pxSectorBuffer->pucBuffer;
        ( void ) memset( pucBuffer, 0, pxSet->pxIOManager->usSectorSize );
        ( void ) memcpy( pucBuffer + OFS_BPB_jmpBoot_24, "\xEB\x00\x90" "FreeRTOS", 11 ); /* Includes OFS_BPB_OEMName_64 */

        ulPartitionOffset = OFS_PTABLE_PART_0;

        for( xPartitionNumber = 0; xPartitionNumber < ffconfigMAX_PARTITIONS; xPartitionNumber++, ulPartitionOffset += 16 )
        {
            FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_ACTIVE_8, writeParts[ xPartitionNumber ].ucActive );                  /* 0x01BE 0x80 if active */
            FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_START_HEAD_8, 1 );                                                    /* 0x001 / 0x01BF */
            FF_putShort( pucBuffer, ulPartitionOffset + OFS_PART_START_SEC_TRACK_16, 1 );                                             /* 0x002 / 0x01C0 */
            FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_ID_NUMBER_8, writeParts[ xPartitionNumber ].ucPartitionID );          /* 0x004 / 0x01C2 */
            FF_putChar( pucBuffer, ulPartitionOffset + OFS_PART_ENDING_HEAD_8, 0xFE );                                                /* 0x005 / 0x01C3 */
            FF_putShort( pucBuffer, ulPartitionOffset + OFS_PART_ENDING_SEC_TRACK_16, writeParts[ xPartitionNumber ].ulSectorCount ); /* 0x006 / 0x01C4 */
            FF_putLong( pucBuffer, ulPartitionOffset + OFS_PART_STARTING_LBA_32, writeParts[ xPartitionNumber ].ulStartLBA );         /* 0x008 / 0x01C6 This is important */
            FF_putLong( pucBuffer, ulPartitionOffset + OFS_PART_LENGTH_32, writeParts[ xPartitionNumber ].ulSectorCount );            /* 0x00C / 0x01CA Equal to total sectors */
        }

        pucBuffer[ FF_FAT_MBR_SIGNATURE + 0 ] = 0x55;
        pucBuffer[ FF_FAT_MBR_SIGNATURE + 1 ] = 0xAA;

        FF_ReleaseBuffer( pxSet->pxIOManager, pxSectorBuffer );
        FF_FlushCache( pxSet->pxIOManager );
        ulLBA = ulNextLBA;
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Create/initialise the partitions of a disk.
 * @param[in] pxDisk : The definition of the disk.
 * @param[in] pParams : A description of how the partitions shall be formatted.
 * @return A standard +FAT error code ( not an errno ).
 */
FF_Error_t FF_Partition( FF_Disk_t * pxDisk,
                         FF_PartitionParameters_t * pParams )
{
    FF_Error_t xReturn = FF_ERR_NONE;
    struct xPartitionSet xSet;
    BaseType_t xNeedExtended; /* When more than 4 partitions are requested, extended partitions are needed. */
    uint32_t ulAvailable;     /* The number of sectors available. */
    BaseType_t xPartitionNumber;
    uint32_t ulSummedSizes;   /* Summed sizes as a percentage or as number of sectors. */
    uint32_t ulReservedSpace; /**< Space needed for the extended partitions. */

    memset( &( xSet ), 0, sizeof( xSet ) );

    /* Hidden space between 2 extended partitions */
    xSet.ulInterSpace = pParams->ulInterSpace ? pParams->ulInterSpace : 2048;
    /* The +FAT IO-manager. */
    xSet.pxIOManager = pxDisk->pxIOManager;


    /* Clear caching without flushing first. */
    FF_IOMAN_InitBufferDescriptors( xSet.pxIOManager );

    /* Avoid sanity checks by FF_BlockRead/Write. */
    xSet.pxIOManager->xPartition.ulTotalSectors = 0;

    /* Get the sum of sizes and number of actual partitions. */
    for( xPartitionNumber = 0; xPartitionNumber < ffconfigMAX_PARTITIONS; xPartitionNumber++ )
    {
        if( pParams->xSizes[ xPartitionNumber ] > 0 )
        {
            xSet.xPartitionCount++;
            ulSummedSizes += pParams->xSizes[ xPartitionNumber ];
        }
    }

    /* xSet.xPartitionCount is at most 'ffconfigMAX_PARTITIONS' */
    if( xSet.xPartitionCount == 0 )
    {
        xSet.xPartitionCount = 1;

        /* 'ffconfigMAX_PARTITIONS' must be 1 or more. */
        if( pParams->eSizeType == eSizeIsSectors )
        {
            pParams->xSizes[ 0 ] = pParams->ulSectorCount;
        }
        else
        {
            pParams->xSizes[ 0 ] = 100;
        }

        ulSummedSizes = pParams->xSizes[ 0 ];
    }

    /* Correct PrimaryCount if necessary. */
    if( pParams->xPrimaryCount > ( ( xSet.xPartitionCount > 4 ) ? 3 : xSet.xPartitionCount ) )
    {
        pParams->xPrimaryCount = ( xSet.xPartitionCount > 4 ) ? 3 : xSet.xPartitionCount;
    }

    /* Now see if extended is necessary. */
    xNeedExtended = ( xSet.xPartitionCount > pParams->xPrimaryCount ) ? pdTRUE : pdFALSE;

    if( xNeedExtended != pdFALSE )
    {
        if( pParams->ulHiddenSectors < 4096 )
        {
            pParams->ulHiddenSectors = 4096;
        }

        ulReservedSpace = xSet.ulInterSpace * ( xSet.xPartitionCount - pParams->xPrimaryCount );
    }
    else
    {
        /* There must be at least 1 hidden sector. */
        if( pParams->ulHiddenSectors < 1 )
        {
            pParams->ulHiddenSectors = 1;
        }

        ulReservedSpace = 0;
    }

    ulAvailable = pParams->ulSectorCount - pParams->ulHiddenSectors - ulReservedSpace;

    /* Check validity of Sizes */
    switch( pParams->eSizeType )
    {
        case eSizeIsQuota: /* Assign a quotum (sum of Sizes is free, all disk space will be allocated) */
            break;

        case eSizeIsPercent: /* Assign a percentage of the available space (sum of Sizes must be <= 100) */

            if( ulSummedSizes > 100 )
            {
                return FF_FORMATPARTITION | FF_ERR_IOMAN_BAD_MEMSIZE;
            }

            ulSummedSizes = 100;
            break;

        case eSizeIsSectors: /* Assign fixed number of sectors (512 byte each) */

            if( ulSummedSizes > ulAvailable )
            {
                return FF_FORMATPARTITION | FF_ERR_IOMAN_BAD_MEMSIZE;
            }

            break;
    }

    {
        uint32_t ulRemaining = ulAvailable;
        uint32_t ulLBA = pParams->ulHiddenSectors;

        /* Divide the available sectors among the partitions: */

        for( xPartitionNumber = 0; xPartitionNumber < xSet.xPartitionCount; xPartitionNumber++ )
        {
            if( pParams->xSizes[ xPartitionNumber ] > 0 )
            {
                uint32_t ulSize;

                switch( pParams->eSizeType )
                {
                    case eSizeIsQuota:   /* Assign a quotum (sum of Sizes is free, all disk space will be allocated) */
                    case eSizeIsPercent: /* Assign a percentage of the available space (sum of Sizes must be <= 100) */
                        ulSize = ( uint32_t ) ( ( ( uint64_t ) pParams->xSizes[ xPartitionNumber ] * ulAvailable ) / ulSummedSizes );
                        break;

                    case eSizeIsSectors: /* Assign fixed number of sectors (512 byte each) */
                    default:             /* Just for the compiler(s) */
                        ulSize = pParams->xSizes[ xPartitionNumber ];
                        break;
                }

                if( ulSize > ulRemaining )
                {
                    ulSize = ulRemaining;
                }

                ulRemaining -= ulSize;
                xSet.pxPartitions[ xPartitionNumber ].ulSectorCount = ulSize;
                xSet.pxPartitions[ xPartitionNumber ].ucActive = 0x80;
                xSet.pxPartitions[ xPartitionNumber ].ulStartLBA = ulLBA; /* ulStartLBA might still change for logical partitions */
                xSet.pxPartitions[ xPartitionNumber ].ucPartitionID = 0x0B;
                ulLBA += ulSize;
            }
        }
    }

    if( xNeedExtended == pdFALSE )
    {
        xReturn = prvPartitionPrimary( &( xSet ) );
    }
    else
    {
        xReturn = prvPartitionExtended( &( xSet ), pParams );
    }

    return xReturn;
}
/*-----------------------------------------------------------*/