## f_mkfs

The f_mkfs function creates an FAT/exFAT volume on the logical drive.

    FRESULT f_mkfs (
      const TCHAR* path,   /* [IN] Logical drive number */
      const MKFS_PARM* opt,/* [IN] Format options */
      void* work,          /* [-]  Working buffer */
      UINT len             /* [IN] Size of working buffer */
    );

#### Parameters

path
  Pointer to the null-terminated string specifies the logical drive to be formatted. If it does not have a drive number in it, it means to specify the default drive. The logical drive may or may not have been mounted for the format process.
opt
  Specifies the format option structure `MKFS_PARM` holding format options. If a null pointer is given, it gives the function all options in default value. The structure has five members described below:
  BYTE fmt
    Specifies combination of FAT type flags, `FM_FAT`, `FM_FAT32`, `FM_EXFAT` and bitwise-or of these three, `FM_ANY`. `FM_EXFAT` is ignored when exFAT is not enabled. These flags specify which FAT type to be created on the volume. If two or more types are specified, one out of them will be selected depends on the volume size and `au_size`. The flag `FM_SFD` specifies to create the volume on the drive in SFD format. The default value is `FM_ANY`.
  DWORD au_size
    Specifies size of the allocation unit (cluter) in unit of byte. The valid value is power of 2 between sector size and 128 * sector size inclusive for FAT/FAT32 volume, or up to 16 MB for exFAT volume. If a zero (default value) or any invalid value is given, the function uses default allocation unit size depends on the volume size.
  UINT n_align
    Specifies alignment of the volume data area (file allocation pool, usually erase block boundary of flash memory media) in unit of sector. The valid value for this member is between 1 and 32768 inclusive in power of 2. If a zero (the default value) or any invalid value is given, the function obtains the block size from lower layer with `disk_ioctl` function.
  BYTE n_fat
    Specifies number of FAT copies on the FAT/FAT32 volume. Valid value for this member is 1 or 2. The default value (0) and any invaid value gives 1. If the FAT type is exFAT, this member has no effect.
  UINT n_root
    Specifies number of root directory entries on the FAT volume. Valid value for this member is up to 32768 and aligned to sector size / 32. The default value (0) and any invaid value gives 512. If the FAT type is FAT32 or exFAT, this member has no effect.
work
  Pointer to the working buffer used for the format process. If a null pointer is given with `FF_USE_LFN == 3`, the function obtains a memory block for the working buffer in this function.
len
  Size of the working buffer in unit of byte. It needs to be `FF_MAX_SS` at least. Plenty of working buffer reduces number of write transactions to the drive and the format process will finish quickly.

#### Return Values

FR_OK, FR_DISK_ERR, FR_NOT_READY, FR_WRITE_PROTECTED, FR_INVALID_DRIVE, FR_MKFS_ABORTED, FR_INVALID_PARAMETER, FR_NOT_ENOUGH_CORE

#### Description

The FAT sub-type, FAT12/FAT16/FAT32, of FAT volume except exFAT is determined by only number of clusters on the volume and nothing else, according to the FAT specification issued by Microsoft. Thus the FAT sub-type of created volume depends on the volume size and the cluster size. In case of the combination of FAT type and cluter size specified by argument is not valid for the volume size, the function will fail with `FR_MKFS_ABORTED`.

The allocation unit, also known as cluster, is a unit of disk space allocation for files. When the size of allocation unit is 32768 bytes, a file with 100 bytes in size occupies 32768 bytes of disk space. The space efficiency of disk usage gets worse as increasing size of allocation unit, but, on the other hand, the read/write performance increases. Therefore the size of allocation unit is a trade-off between space efficiency and performance. For the large volumes in GB order, 32768 bytes or larger, automatically selected by default, is recommended for most case unless extremely many small files are created in the volume.

When the logical drive to be formatted is associated with a physical drive (`FF_MULTI_PARTITION == 0` or `VolToPart[].pt == 0`) and `FM_SFD` flag is not specified, a partition occupies entire drive space is created and then the FAT volume is created in the partition. When `FM_SFD` flag is specified, the FAT volume is created without any disk partitioning.

When the logical drive to be formatted is associated with a specific partition by multiple partition feature (`FF_MULTI_PARTITION == 1` and `VolToPart[].pt > 0`), the FAT volume is created in the partition of the physical drive specified by volume mapping table and `FM_SFD` flag is ignored. The hosting physical drive needs to be partitioned with `f_fdisk` function or any partitioning tool prior to create the FAT volume with this function. If the partition is not exist, the function aborts with `FR_MKFS_ABORTED`.

There are three standard disk partitioning formats, MBR, GPT and SFD. The MBR format, also known as FDISK format, is usually used for harddisk, memory card and U disk. It can divide a physical drive into one or more partitions with a partition table. The GPT, GUID Partition Table, is a newly defined patitioning format for large storage devices. FatFs suppors the GPT only when 64-bit LBA is enabled. The SFD, Super-Floppy Disk, is non-partitioned disk format. The FAT volume is located at LBA 0 and occupies the entire physical drive without any disk partitioning. It is usually used for floppy disk, optical disk and most super-floppy media. Some combination of systems and media support only either partitioned format or non-partitioned format and the other is not supported.

Some systems manage the partitions in the on-board storage in non-standard format. The partitions are mapped as physical drives identified by `pdrv` in `disk_*` functions. For such systems, SFD format is suitable to create the FAT volume in the partition.

#### QuickInfo

Available when `FF_FS_READOLNY == 0` and `FF_USE_MKFS == 1`.

#### Example

    /* Format default drive and create a file */
    int main (void)
    {
        FATFS fs;           /* Filesystem object */
        FIL fil;            /* File object */
        FRESULT res;        /* API result code */
        UINT bw;            /* Bytes written */
        BYTE work[FF_MAX_SS]; /* Work area (larger is better for processing time) */

        /* Format the default drive with default parameters */
        res = f_mkfs("", 0, work, sizeof work);
        if (res) ...

        /* Give a work area to the default drive */
        f_mount(&fs, "", 0);

        /* Create a file as new */
        res = f_open(&fil, "hello.txt", FA_CREATE_NEW | FA_WRITE);
        if (res) ...

        /* Write a message */
        f_write(&fil, "Hello, World!\r\n", 15, &bw);
        if (bw != 15) ...

        /* Close the file */
        f_close(&fil);

        /* Unregister work area */
        f_mount(0, "", 0);

        ...

#### See Also

Example of volume size and format parameters, Volume management, `f_fdisk`

Return