FAT access
[FAT support]

Collaboration diagram for FAT access:

Functions
struct fat_fs_struct *	fat_open (struct partition_struct *partition)
void	fat_close (struct fat_fs_struct *fs)
static uint8_t	fat_read_header (struct fat_fs_struct *fs)
static cluster_t	fat_get_next_cluster (const struct fat_fs_struct *fs, cluster_t cluster_num)
static cluster_t	fat_append_clusters (struct fat_fs_struct *fs, cluster_t cluster_num, cluster_t count)
static uint8_t	fat_free_clusters (struct fat_fs_struct *fs, cluster_t cluster_num)
static uint8_t	fat_terminate_clusters (struct fat_fs_struct *fs, cluster_t cluster_num)
static uint8_t	fat_clear_cluster (const struct fat_fs_struct *fs, cluster_t cluster_num)
static uintptr_t	fat_clear_cluster_callback (uint8_t *buffer, offset_t offset, void *p)
static offset_t	fat_cluster_offset (const struct fat_fs_struct *fs, cluster_t cluster_num)
static uint8_t	fat_dir_entry_read_callback (uint8_t *buffer, offset_t offset, void *p)
static uint8_t	fat_calc_83_checksum (const uint8_t *file_name_83)
static offset_t	fat_find_offset_for_dir_entry (struct fat_fs_struct *fs, const struct fat_dir_struct *parent, const struct fat_dir_entry_struct *dir_entry)
static uint8_t	fat_write_dir_entry (const struct fat_fs_struct *fs, struct fat_dir_entry_struct *dir_entry)
offset_t	fat_get_fs_size (const struct fat_fs_struct *fs)
offset_t	fat_get_fs_free (const struct fat_fs_struct *fs)
static uint8_t	fat_get_fs_free_16_callback (uint8_t *buffer, offset_t offset, void *p)

---

Detailed Description

Basic functions for handling a FAT filesystem.

---

Function Documentation

cluster_t fat_append_clusters	(	struct fat_fs_struct *	fs,
		cluster_t	cluster_num,
		cluster_t	count
	)			[static]

Appends a new cluster chain to an existing one.

Set cluster_num to zero to create a completely new one.

Parameters:

[in]	fs	The file system on which to operate.
[in]	cluster_num	The cluster to which to append the new chain.
[in]	count	The number of clusters to allocate.

Returns:

0 on failure, the number of the first new cluster on success.

Definition at line 493 of file fat.c.

References fat_fs_struct::cluster_free, partition_struct::device_read, partition_struct::device_write, FAT16_CLUSTER_FREE, FAT16_CLUSTER_LAST_MAX, FAT32_CLUSTER_FREE, FAT32_CLUSTER_LAST_MAX, fat_free_clusters(), fat_header_struct::fat_offset, fat_header_struct::fat_size, fat_fs_struct::header, htol16(), htol32(), fat_fs_struct::partition, PARTITION_TYPE_FAT32, and partition_struct::type.

Referenced by fat_create_dir(), fat_find_offset_for_dir_entry(), fat_resize_file(), and fat_write_file().

{
    if(!fs)
        return 0;

    device_read_t device_read = fs->partition->device_read;
    device_write_t device_write = fs->partition->device_write;
    offset_t fat_offset = fs->header.fat_offset;
    cluster_t count_left = count;
    cluster_t cluster_current = fs->cluster_free;
    cluster_t cluster_next = 0;
    cluster_t cluster_count;
    uint16_t fat_entry16;
#if FAT_FAT32_SUPPORT
    uint32_t fat_entry32;
    uint8_t is_fat32 = (fs->partition->type == PARTITION_TYPE_FAT32);

    if(is_fat32)
        cluster_count = fs->header.fat_size / sizeof(fat_entry32);
    else
#endif
        cluster_count = fs->header.fat_size / sizeof(fat_entry16);

    fs->cluster_free = 0;
    cluster_t cluster_left = cluster_count;
    for( cluster_left = cluster_count; cluster_left > 0; --cluster_left, ++cluster_current)
    {
        if(cluster_current < 2 || cluster_current >= cluster_count)
            cluster_current = 2;

#if FAT_FAT32_SUPPORT
        if(is_fat32)
        {
            if(!device_read(fat_offset + cluster_current * sizeof(fat_entry32), (uint8_t*) &fat_entry32, sizeof(fat_entry32)))
                return 0;
        }
        else
#endif
        {
            if(!device_read(fat_offset + cluster_current * sizeof(fat_entry16), (uint8_t*) &fat_entry16, sizeof(fat_entry16)))
                return 0;
        }

#if FAT_FAT32_SUPPORT
        if(is_fat32)
        {
            /* check if this is a free cluster */
            if(fat_entry32 != HTOL32(FAT32_CLUSTER_FREE))
                continue;

            /* If we don't need this free cluster for the
             * current allocation, we keep it in mind for
             * the next time.
             */
            if(count_left == 0)
            {
                fs->cluster_free = cluster_current;
                break;
            }

            /* allocate cluster */
            if(cluster_next == 0)
                fat_entry32 = HTOL32(FAT32_CLUSTER_LAST_MAX);
            else
                fat_entry32 = htol32(cluster_next);

            if(!device_write(fat_offset + cluster_current * sizeof(fat_entry32), (uint8_t*) &fat_entry32, sizeof(fat_entry32)))
                break;
        }
        else
#endif
        {
            /* check if this is a free cluster */
            if(fat_entry16 != HTOL16(FAT16_CLUSTER_FREE))
                continue;

            /* If we don't need this free cluster for the
             * current allocation, we keep it in mind for
             * the next time.
             */
            if(count_left == 0)
            {
                fs->cluster_free = cluster_current;
                break;
            }

            /* allocate cluster */
            if(cluster_next == 0)
                fat_entry16 = HTOL16(FAT16_CLUSTER_LAST_MAX);
            else
                fat_entry16 = htol16((uint16_t) cluster_next);

            if(!device_write(fat_offset + cluster_current * sizeof(fat_entry16), (uint8_t*) &fat_entry16, sizeof(fat_entry16)))
                break;
        }

        cluster_next = cluster_current;
        --count_left;
    }

    do
    {
        if(count_left > 0)
            break;

        /* We allocated a new cluster chain. Now join
         * it with the existing one (if any).
         */
        if(cluster_num >= 2)
        {
#if FAT_FAT32_SUPPORT
            if(is_fat32)
            {
                fat_entry32 = htol32(cluster_next);

                if(!device_write(fat_offset + cluster_num * sizeof(fat_entry32), (uint8_t*) &fat_entry32, sizeof(fat_entry32)))
                    break;
            }
            else
#endif
            {
                fat_entry16 = htol16((uint16_t) cluster_next);

                if(!device_write(fat_offset + cluster_num * sizeof(fat_entry16), (uint8_t*) &fat_entry16, sizeof(fat_entry16)))
                    break;
            }
        }

        return cluster_next;

    } while(0);

    /* No space left on device or writing error.
     * Free up all clusters already allocated.
     */
    fat_free_clusters(fs, cluster_next);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_calc_83_checksum

(

const uint8_t *

file_name_83

)

[static]

Calculates the checksum for 8.3 names used within the corresponding lfn directory entries.

Parameters:

[in]

file_name_83

The 11-byte file name buffer.

Returns:

The checksum of the given file name.

Definition at line 1708 of file fat.c.

Referenced by fat_dir_entry_read_callback(), and fat_write_dir_entry().

{
    uint8_t checksum = file_name_83[0];
    uint16_t i=0;
    for( i = 1; i < 11; ++i)
        checksum = ((checksum >> 1) | (checksum << 7)) + file_name_83[i];

    return checksum;
}

Here is the caller graph for this function:

uint8_t fat_clear_cluster	(	const struct fat_fs_struct *	fs,
		cluster_t	cluster_num
	)			[static]

Clears a single cluster.

The complete cluster is filled with zeros.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	cluster_num	The cluster to clear.

Returns:

0 on failure, 1 on success.

Definition at line 793 of file fat.c.

References fat_header_struct::cluster_size, partition_struct::device_write_interval, fat_clear_cluster_callback(), fat_cluster_offset(), fat_fs_struct::header, and fat_fs_struct::partition.

Referenced by fat_create_dir(), and fat_find_offset_for_dir_entry().

{
    if(cluster_num < 2)
        return 0;

    offset_t cluster_offset = fat_cluster_offset(fs, cluster_num);

    uint8_t zero[16];
    memset(zero, 0, sizeof(zero));
    return fs->partition->device_write_interval(cluster_offset,
                                                zero,
                                                fs->header.cluster_size,
                                                fat_clear_cluster_callback,
                                                0
                                               );
}

Here is the call graph for this function:

Here is the caller graph for this function:

uintptr_t fat_clear_cluster_callback	(	uint8_t *	buffer,
		offset_t	offset,
		void *	p
	)			[static]

Callback function for clearing a cluster.

Definition at line 816 of file fat.c.

Referenced by fat_clear_cluster().

{
    return 16;
}

Here is the caller graph for this function:

void fat_close

(

struct fat_fs_struct *

fs

)

Closes a FAT filesystem.

When this function returns, the given filesystem descriptor will be invalid.

Parameters:

[in]

fs

The filesystem to close.

See also:

fat_open

Definition at line 291 of file fat.c.

References fat_fs_struct::partition.

Referenced by WaspSD::close().

{
    if(!fs)
        return;

#if USE_DYNAMIC_MEMORY
    free(fs);
#else
    fs->partition = 0;
#endif
}

Here is the caller graph for this function:

offset_t fat_cluster_offset	(	const struct fat_fs_struct *	fs,
		cluster_t	cluster_num
	)			[static]

Calculates the offset of the specified cluster.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	cluster_num	The cluster whose offset to calculate.

Returns:

The cluster offset.

Definition at line 830 of file fat.c.

References fat_header_struct::cluster_size, fat_header_struct::cluster_zero_offset, and fat_fs_struct::header.

Referenced by fat_clear_cluster(), fat_find_offset_for_dir_entry(), fat_read_dir(), fat_read_file(), and fat_write_file().

{
    if(!fs || cluster_num < 2)
        return 0;

    return fs->header.cluster_zero_offset + (offset_t) (cluster_num - 2) * fs->header.cluster_size;
}

Here is the caller graph for this function:

uint8_t fat_dir_entry_read_callback	(	uint8_t *	buffer,
		offset_t	offset,
		void *	p
	)			[static]

Callback function for reading a directory entry.

Interprets a raw directory entry and puts the contained information into a fat_dir_entry_struct structure.

For a single file there may exist multiple directory entries. All except the last one are lfn entries, which contain parts of the long filename. The last directory entry is a traditional 8.3 style one. It contains all other information like size, cluster, date and time.

Parameters:

[in]	buffer	A pointer to 32 bytes of raw data.
[in]	offset	The absolute offset of the raw data.
[in,out]	p	An argument structure controlling operation.

Returns:

0 on failure or completion, 1 if reading has to be continued

Definition at line 1579 of file fat.c.

References fat_dir_entry_struct::attributes, fat_read_dir_callback_arg::bytes_read, fat_read_dir_callback_arg::checksum, fat_dir_entry_struct::cluster, fat_read_dir_callback_arg::dir_entry, fat_dir_entry_struct::entry_offset, fat_calc_83_checksum(), FAT_DIRENTRY_DELETED, fat_dir_entry_struct::file_size, fat_read_dir_callback_arg::finished, fat_dir_entry_struct::long_name, ltoh16, and ltoh32.

Referenced by fat_read_dir().

{
    struct fat_read_dir_callback_arg* arg = p;
    struct fat_dir_entry_struct* dir_entry = arg->dir_entry;

    arg->bytes_read += 32;

    /* skip deleted or empty entries */
    if(buffer[0] == FAT_DIRENTRY_DELETED || !buffer[0])
    {
#if FAT_LFN_SUPPORT
        arg->checksum = 0;
#endif
        return 1;
    }

#if !FAT_LFN_SUPPORT
    /* skip lfn entries */
    if(buffer[11] == 0x0f)
        return 1;
#endif

    char* long_name = dir_entry->long_name;
#if FAT_LFN_SUPPORT
    if(buffer[11] == 0x0f)
    {
        /* checksum validation */
        if(arg->checksum == 0 || arg->checksum != buffer[13])
        {
            /* reset directory entry */
            memset(dir_entry, 0, sizeof(*dir_entry));

            arg->checksum = buffer[13];
            dir_entry->entry_offset = offset;
        }

        /* lfn supports unicode, but we do not, for now.
         * So we assume pure ascii and read only every
         * second byte.
         */
        uint16_t char_offset = ((buffer[0] & 0x3f) - 1) * 13;
        const uint8_t char_mapping[] = { 1, 3, 5, 7, 9, 14, 16, 18, 20, 22, 24, 28, 30 };
        uint16_t i=0;
        for( i = 0; i <= 12 && char_offset + i < sizeof(dir_entry->long_name) - 1; ++i)
            long_name[char_offset + i] = buffer[char_mapping[i]];

        return 1;
    }
    else
#endif
    {
#if FAT_LFN_SUPPORT
        /* if we do not have a long name or the previous lfn does not match, take the 8.3 name */
        if(long_name[0] == '\0' || arg->checksum != fat_calc_83_checksum(buffer))
#endif
        {
            /* reset directory entry */
            memset(dir_entry, 0, sizeof(*dir_entry));
            dir_entry->entry_offset = offset;

            uint8_t i;
            for(i = 0; i < 8; ++i)
            {
                if(buffer[i] == ' ')
                    break;
                long_name[i] = buffer[i];

                /* Windows NT and later versions do not store lfn entries
                 * for 8.3 names which have a lowercase basename, extension
                 * or both when everything else is uppercase. They use two
                 * extra bits to signal a lowercase basename or extension.
                 */
                if((buffer[12] & 0x08) && buffer[i] >= 'A' && buffer[i] <= 'Z')
                    long_name[i] += 'a' - 'A';
            }
            if(long_name[0] == 0x05)
                long_name[0] = (char) FAT_DIRENTRY_DELETED;

            if(buffer[8] != ' ')
            {
                long_name[i++] = '.';

                uint8_t j = 8;
                for(; j < 11; ++j)
                {
                    if(buffer[j] == ' ')
                        break;
                    long_name[i] = buffer[j];

                    /* See above for the lowercase 8.3 name handling of
                     * Windows NT and later.
                     */
                    if((buffer[12] & 0x10) && buffer[j] >= 'A' && buffer[j] <= 'Z')
                        long_name[i] += 'a' - 'A';

                    ++i;
                }
            } 

            long_name[i] = '\0';
        }
        
        /* extract properties of file and store them within the structure */
        dir_entry->attributes = buffer[11];
        dir_entry->cluster = ltoh16(*((uint16_t*) &buffer[26]));
#if FAT_FAT32_SUPPORT
        dir_entry->cluster |= ((cluster_t) ltoh16(*((uint16_t*) &buffer[20]))) << 16;
#endif
        dir_entry->file_size = ltoh32(*((uint32_t*) &buffer[28]));

#if FAT_DATETIME_SUPPORT
        dir_entry->modification_time = ltoh16(*((uint16_t*) &buffer[22]));
        dir_entry->modification_date = ltoh16(*((uint16_t*) &buffer[24]));
#endif

        arg->finished = 1;
        return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

offset_t fat_find_offset_for_dir_entry	(	struct fat_fs_struct *	fs,
		const struct fat_dir_struct *	parent,
		const struct fat_dir_entry_struct *	dir_entry
	)			[static]

Searches for space where to store a directory entry.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	parent	The directory in which to search.
[in]	dir_entry	The directory entry for which to search space.

Returns:

0 on failure, a device offset on success.

Definition at line 1729 of file fat.c.

References fat_dir_entry_struct::cluster, fat_header_struct::cluster_size, fat_header_struct::cluster_zero_offset, partition_struct::device_read, fat_dir_struct::dir_entry, fat_append_clusters(), fat_clear_cluster(), fat_cluster_offset(), FAT_DIRENTRY_DELETED, fat_get_next_cluster(), fat_fs_struct::header, fat_dir_entry_struct::long_name, fat_fs_struct::partition, PARTITION_TYPE_FAT32, fat_header_struct::root_dir_offset, and partition_struct::type.

Referenced by fat_create_dir(), and fat_create_file().

{
    if(!fs || !dir_entry)
        return 0;

    /* search for a place where to write the directory entry to disk */
#if FAT_LFN_SUPPORT
    uint8_t free_dir_entries_needed = (strlen(dir_entry->long_name) + 12) / 13 + 1;
    uint8_t free_dir_entries_found = 0;
#endif
    cluster_t cluster_num = parent->dir_entry.cluster;
    offset_t dir_entry_offset = 0;
    offset_t offset = 0;
    offset_t offset_to = 0;
#if FAT_FAT32_SUPPORT
    uint8_t is_fat32 = (fs->partition->type == PARTITION_TYPE_FAT32);
#endif

    if(cluster_num == 0)
    {
#if FAT_FAT32_SUPPORT
        if(is_fat32)
        {
            cluster_num = fs->header.root_dir_cluster;
        }
        else
#endif
        {
            /* we read/write from the root directory entry */
            offset = fs->header.root_dir_offset;
            offset_to = fs->header.cluster_zero_offset;
            dir_entry_offset = offset;
        }
    }
    
    while(1)
    {
        if(offset == offset_to)
        {
            if(cluster_num == 0)
                /* We iterated through the whole root directory and
                 * could not find enough space for the directory entry.
                 */
                return 0;

            if(offset)
            {
                /* We reached a cluster boundary and have to
                 * switch to the next cluster.
                 */

                cluster_t cluster_next = fat_get_next_cluster(fs, cluster_num);
                if(!cluster_next)
                {
                    cluster_next = fat_append_clusters(fs, cluster_num, 1);
                    if(!cluster_next)
                        return 0;

                    /* we appended a new cluster and know it is free */
                    dir_entry_offset = fs->header.cluster_zero_offset +
                                       (offset_t) (cluster_next - 2) * fs->header.cluster_size;

                    /* clear cluster to avoid garbage directory entries */
                    fat_clear_cluster(fs, cluster_next);

                    break;
                }
                cluster_num = cluster_next;
            }

            offset = fat_cluster_offset(fs, cluster_num);
            offset_to = offset + fs->header.cluster_size;
            dir_entry_offset = offset;
#if FAT_LFN_SUPPORT
            free_dir_entries_found = 0;
#endif
        }
        
        /* read next lfn or 8.3 entry */
        uint8_t first_char;
        if(!fs->partition->device_read(offset, &first_char, sizeof(first_char)))
            return 0;

        /* check if we found a free directory entry */
        if(first_char == FAT_DIRENTRY_DELETED || !first_char)
        {
            /* check if we have the needed number of available entries */
#if FAT_LFN_SUPPORT
            ++free_dir_entries_found;
            if(free_dir_entries_found >= free_dir_entries_needed)
#endif
                break;

            offset += 32;
        }
        else
        {
            offset += 32;
            dir_entry_offset = offset;
#if FAT_LFN_SUPPORT
            free_dir_entries_found = 0;
#endif
        }
    }

    return dir_entry_offset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_free_clusters	(	struct fat_fs_struct *	fs,
		cluster_t	cluster_num
	)			[static]

Frees a cluster chain, or a part thereof.

Marks the specified cluster and all clusters which are sequentially referenced by it as free. They may then be used again for future file allocations.

Note:

If this function is used for freeing just a part of a cluster chain, the new end of the chain is not correctly terminated within the FAT. Use fat_terminate_clusters() instead.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	cluster_num	The starting cluster of the chain which to free.

Returns:

0 on failure, 1 on success.

See also:

fat_terminate_clusters

Definition at line 652 of file fat.c.

References fat_fs_struct::cluster_free, partition_struct::device_read, partition_struct::device_write, FAT16_CLUSTER_BAD, FAT16_CLUSTER_FREE, FAT16_CLUSTER_LAST_MAX, FAT16_CLUSTER_LAST_MIN, FAT16_CLUSTER_RESERVED_MAX, FAT16_CLUSTER_RESERVED_MIN, FAT32_CLUSTER_BAD, FAT32_CLUSTER_FREE, FAT32_CLUSTER_LAST_MAX, FAT32_CLUSTER_LAST_MIN, FAT32_CLUSTER_RESERVED_MAX, FAT32_CLUSTER_RESERVED_MIN, fat_header_struct::fat_offset, fat_fs_struct::header, ltoh16, ltoh32, fat_fs_struct::partition, PARTITION_TYPE_FAT32, and partition_struct::type.

Referenced by fat_append_clusters(), fat_create_dir(), fat_delete_file(), fat_resize_file(), and fat_terminate_clusters().

{
    if(!fs || cluster_num < 2)
        return 0;

    offset_t fat_offset = fs->header.fat_offset;
#if FAT_FAT32_SUPPORT
    if(fs->partition->type == PARTITION_TYPE_FAT32)
    {
        uint32_t fat_entry;
        while(cluster_num)
        {
            if(!fs->partition->device_read(fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry)))
                return 0;

            /* get next cluster of current cluster before freeing current cluster */
            uint32_t cluster_num_next = ltoh32(fat_entry);

            if(cluster_num_next == FAT32_CLUSTER_FREE)
                return 1;
            if(cluster_num_next == FAT32_CLUSTER_BAD ||
               (cluster_num_next >= FAT32_CLUSTER_RESERVED_MIN &&
                cluster_num_next <= FAT32_CLUSTER_RESERVED_MAX
               )
              )
                return 0;
            if(cluster_num_next >= FAT32_CLUSTER_LAST_MIN && cluster_num_next <= FAT32_CLUSTER_LAST_MAX)
                cluster_num_next = 0;

            /* We know we will free the cluster, so remember it as
             * free for the next allocation.
             */
            if(!fs->cluster_free)
                fs->cluster_free = cluster_num;

            /* free cluster */
            fat_entry = HTOL32(FAT32_CLUSTER_FREE);
            fs->partition->device_write(fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry));

            /* We continue in any case here, even if freeing the cluster failed.
             * The cluster is lost, but maybe we can still free up some later ones.
             */

            cluster_num = cluster_num_next;
        }
    }
    else
#endif
    {
        uint16_t fat_entry;
        while(cluster_num)
        {
            if(!fs->partition->device_read(fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry)))
                return 0;

            /* get next cluster of current cluster before freeing current cluster */
            uint16_t cluster_num_next = ltoh16(fat_entry);

            if(cluster_num_next == FAT16_CLUSTER_FREE)
                return 1;
            if(cluster_num_next == FAT16_CLUSTER_BAD ||
               (cluster_num_next >= FAT16_CLUSTER_RESERVED_MIN &&
                cluster_num_next <= FAT16_CLUSTER_RESERVED_MAX
               )
              )
                return 0;
            if(cluster_num_next >= FAT16_CLUSTER_LAST_MIN && cluster_num_next <= FAT16_CLUSTER_LAST_MAX)
                cluster_num_next = 0;

            /* free cluster */
            fat_entry = HTOL16(FAT16_CLUSTER_FREE);
            fs->partition->device_write(fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry));

            /* We continue in any case here, even if freeing the cluster failed.
             * The cluster is lost, but maybe we can still free up some later ones.
             */

            cluster_num = cluster_num_next;
        }
    }

    return 1;
}

Here is the caller graph for this function:

offset_t fat_get_fs_free

(

const struct fat_fs_struct *

fs

)

Returns the amount of free storage capacity on the filesystem in bytes.

Note:

As the FAT filesystem is cluster based, this function does not return continuous values but multiples of the cluster size.

Parameters:

[in]

fs

The filesystem on which to operate.

Returns:

0 on failure, the free filesystem space in bytes otherwise.

Definition at line 2376 of file fat.c.

References fat_usage_count_callback_arg::buffer_size, fat_usage_count_callback_arg::cluster_count, fat_header_struct::cluster_size, partition_struct::device_read_interval, FAT_FAT32_SUPPORT, fat_get_fs_free_16_callback(), fat_header_struct::fat_offset, fat_header_struct::fat_size, fat_fs_struct::header, fat_fs_struct::partition, PARTITION_TYPE_FAT16, and partition_struct::type.

Referenced by WaspSD::getDiskFree(), and WaspSD::print_disk_info().

{
    if(!fs)
        return 0;

    uint8_t fat[32];
    struct fat_usage_count_callback_arg count_arg;
    count_arg.cluster_count = 0;
    count_arg.buffer_size = sizeof(fat);

    offset_t fat_offset = fs->header.fat_offset;
    uint32_t fat_size = fs->header.fat_size;
    while(fat_size > 0)
    {
        uintptr_t length = UINTPTR_MAX - 1;
        if(fat_size < length)
            length = fat_size;

        if(!fs->partition->device_read_interval(fat_offset,
                                                fat,
                                                sizeof(fat),
                                                length,
#if FAT_FAT32_SUPPORT
                                                (fs->partition->type == PARTITION_TYPE_FAT16) ?
                                                    fat_get_fs_free_16_callback :
                                                    fat_get_fs_free_32_callback,
#else
                                                fat_get_fs_free_16_callback,
#endif
                                                &count_arg
                                               )
          )
            return 0;

        fat_offset += length;
        fat_size -= length;
    }

    return (offset_t) count_arg.cluster_count * fs->header.cluster_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_get_fs_free_16_callback	(	uint8_t *	buffer,
		offset_t	offset,
		void *	p
	)			[static]

Callback function used for counting free clusters in a FAT.

Definition at line 2421 of file fat.c.

References fat_usage_count_callback_arg::buffer_size, fat_usage_count_callback_arg::cluster_count, and FAT16_CLUSTER_FREE.

Referenced by fat_get_fs_free().

{
    struct fat_usage_count_callback_arg* count_arg = (struct fat_usage_count_callback_arg*) p;
    uintptr_t buffer_size = count_arg->buffer_size;

    uintptr_t i = 0;
    for( i = 0; i < buffer_size; i += 2, buffer += 2)
    {
        uint16_t cluster = *((uint16_t*) &buffer[0]);
        if(cluster == HTOL16(FAT16_CLUSTER_FREE))
            ++(count_arg->cluster_count);
    }

    return 1;
}

Here is the caller graph for this function:

offset_t fat_get_fs_size

(

const struct fat_fs_struct *

fs

)

Deletes a directory.

This is just a synonym for fat_delete_file(). If a directory is deleted without first deleting its subdirectories and files, disk space occupied by these files will get wasted as there is no chance to release it and mark it as free.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	dir_entry	The directory entry of the directory to delete.

Returns:

0 on failure, 1 on success.

See also:

fat_create_dir

Returns the amount of total storage capacity of the filesystem in bytes.

Parameters:

[in]

fs

The filesystem on which to operate.

Returns:

0 on failure, the filesystem size in bytes otherwise.

Definition at line 2353 of file fat.c.

References fat_header_struct::cluster_size, fat_header_struct::fat_size, fat_fs_struct::header, fat_fs_struct::partition, PARTITION_TYPE_FAT32, and partition_struct::type.

Referenced by WaspSD::getDiskSize(), and WaspSD::print_disk_info().

{
    if(!fs)
        return 0;

#if FAT_FAT32_SUPPORT
    if(fs->partition->type == PARTITION_TYPE_FAT32)
        return (offset_t) (fs->header.fat_size / 4 - 2) * fs->header.cluster_size;
    else
#endif
        return (offset_t) (fs->header.fat_size / 2 - 2) * fs->header.cluster_size;
}

Here is the caller graph for this function:

cluster_t fat_get_next_cluster	(	const struct fat_fs_struct *	fs,
		cluster_t	cluster_num
	)			[static]

Retrieves the next following cluster of a given cluster.

Using the filesystem file allocation table, this function returns the number of the cluster containing the data directly following the data within the cluster with the given number.

Parameters:

[in]	fs	The filesystem for which to determine the next cluster.
[in]	cluster_num	The number of the cluster for which to determine its successor.

Returns:

The wanted cluster number, or 0 on error.

Definition at line 438 of file fat.c.

References partition_struct::device_read, FAT16_CLUSTER_BAD, FAT16_CLUSTER_FREE, FAT16_CLUSTER_LAST_MAX, FAT16_CLUSTER_LAST_MIN, FAT16_CLUSTER_RESERVED_MAX, FAT16_CLUSTER_RESERVED_MIN, FAT32_CLUSTER_BAD, FAT32_CLUSTER_FREE, FAT32_CLUSTER_LAST_MAX, FAT32_CLUSTER_LAST_MIN, FAT32_CLUSTER_RESERVED_MAX, FAT32_CLUSTER_RESERVED_MIN, fat_header_struct::fat_offset, fat_fs_struct::header, ltoh16, ltoh32, fat_fs_struct::partition, PARTITION_TYPE_FAT32, and partition_struct::type.

Referenced by fat_find_offset_for_dir_entry(), fat_read_dir(), fat_read_file(), fat_resize_file(), fat_terminate_clusters(), and fat_write_file().

{
    if(!fs || cluster_num < 2)
        return 0;

#if FAT_FAT32_SUPPORT
    if(fs->partition->type == PARTITION_TYPE_FAT32)
    {
        /* read appropriate fat entry */
        uint32_t fat_entry;
        if(!fs->partition->device_read(fs->header.fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry)))
            return 0;

        /* determine next cluster from fat */
        cluster_num = ltoh32(fat_entry);
        
        if(cluster_num == FAT32_CLUSTER_FREE ||
           cluster_num == FAT32_CLUSTER_BAD ||
           (cluster_num >= FAT32_CLUSTER_RESERVED_MIN && cluster_num <= FAT32_CLUSTER_RESERVED_MAX) ||
           (cluster_num >= FAT32_CLUSTER_LAST_MIN && cluster_num <= FAT32_CLUSTER_LAST_MAX))
            return 0;
    }
    else
#endif
    {
        /* read appropriate fat entry */
        uint16_t fat_entry;
        if(!fs->partition->device_read(fs->header.fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry)))
            return 0;

        /* determine next cluster from fat */
        cluster_num = ltoh16(fat_entry);
        
        if(cluster_num == FAT16_CLUSTER_FREE ||
           cluster_num == FAT16_CLUSTER_BAD ||
           (cluster_num >= FAT16_CLUSTER_RESERVED_MIN && cluster_num <= FAT16_CLUSTER_RESERVED_MAX) ||
           (cluster_num >= FAT16_CLUSTER_LAST_MIN && cluster_num <= FAT16_CLUSTER_LAST_MAX))
            return 0;
    }

    return cluster_num;
}

Here is the caller graph for this function:

struct fat_fs_struct* fat_open

(

struct partition_struct *

partition

)

[read]

Opens a FAT filesystem.

Parameters:

[in]

partition

Discriptor of partition on which the filesystem resides.

Returns:

0 on error, a FAT filesystem descriptor on success.

See also:

fat_close

Definition at line 235 of file fat.c.

References partition_struct::device_write, partition_struct::device_write_interval, FAT_FS_COUNT, fat_fs_handles, fat_read_header(), FAT_WRITE_SUPPORT, and fat_fs_struct::partition.

Referenced by WaspSD::init().

{
    if(!partition ||
#if FAT_WRITE_SUPPORT
       !partition->device_write ||
       !partition->device_write_interval
#else
       0
#endif
      )
        return 0;

#if USE_DYNAMIC_MEMORY
    struct fat_fs_struct* fs = malloc(sizeof(*fs));
    if(!fs)
        return 0;
#else
    struct fat_fs_struct* fs = fat_fs_handles;
    uint8_t i;
    for(i = 0; i < FAT_FS_COUNT; ++i)
    {
        if(!fs->partition)
            break;

        ++fs;
    }
    if(i >= FAT_FS_COUNT)
        return 0;
#endif

    memset(fs, 0, sizeof(*fs));

    fs->partition = partition;
    if(!fat_read_header(fs))
    {
#if USE_DYNAMIC_MEMORY
        free(fs);
#else
        fs->partition = 0;
#endif
        return 0;
    }
    
    return fs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_read_header

(

struct fat_fs_struct *

fs

)

[static]

Reads and parses the header of a FAT filesystem.

Parameters:

inout]

fs The filesystem for which to parse the header.

Returns:

0 on failure, 1 on success.

Definition at line 310 of file fat.c.

References fat_header_struct::cluster_size, fat_header_struct::cluster_zero_offset, partition_struct::device_read, fat_header_struct::fat_offset, fat_header_struct::fat_size, fat_fs_struct::header, ltoh16, ltoh32, partition_struct::offset, fat_fs_struct::partition, PARTITION_TYPE_FAT16, PARTITION_TYPE_FAT32, fat_header_struct::root_dir_offset, fat_header_struct::sector_size, fat_header_struct::size, and partition_struct::type.

Referenced by fat_open().

{
    if(!fs)
        return 0;

    struct partition_struct* partition = fs->partition;
    if(!partition)
        return 0;

    /* read fat parameters */
#if FAT_FAT32_SUPPORT
    uint8_t buffer[37];
#else
    uint8_t buffer[25];
#endif
    offset_t partition_offset = (offset_t) partition->offset * 512;
    if(!partition->device_read(partition_offset + 0x0b, buffer, sizeof(buffer)))
        return 0;

    uint16_t bytes_per_sector = ltoh16(*((uint16_t*) &buffer[0x00]));
    uint16_t reserved_sectors = ltoh16(*((uint16_t*) &buffer[0x03]));
    uint8_t sectors_per_cluster = buffer[0x02];
    uint8_t fat_copies = buffer[0x05];
    uint16_t max_root_entries = ltoh16(*((uint16_t*) &buffer[0x06]));
    uint16_t sector_count_16 = ltoh16(*((uint16_t*) &buffer[0x08]));
    uint16_t sectors_per_fat = ltoh16(*((uint16_t*) &buffer[0x0b]));
    uint32_t sector_count = ltoh32(*((uint32_t*) &buffer[0x15]));
#if FAT_FAT32_SUPPORT
    uint32_t sectors_per_fat32 = ltoh32(*((uint32_t*) &buffer[0x19]));
    uint32_t cluster_root_dir = ltoh32(*((uint32_t*) &buffer[0x21]));
#endif

    if(sector_count == 0)
    {
        if(sector_count_16 == 0)
            /* illegal volume size */
            return 0;
        else
            sector_count = sector_count_16;
    }
#if FAT_FAT32_SUPPORT
    if(sectors_per_fat != 0)
        sectors_per_fat32 = sectors_per_fat;
    else if(sectors_per_fat32 == 0)
        /* this is neither FAT16 nor FAT32 */
        return 0;
#else
    if(sectors_per_fat == 0)
        /* this is not a FAT16 */
        return 0;
#endif

    /* determine the type of FAT we have here */
    uint32_t data_sector_count = sector_count
                                 - reserved_sectors
#if FAT_FAT32_SUPPORT
                                 - sectors_per_fat32 * fat_copies
#else
                                 - (uint32_t) sectors_per_fat * fat_copies
#endif
                                 - ((max_root_entries * 32 + bytes_per_sector - 1) / bytes_per_sector);
    uint32_t data_cluster_count = data_sector_count / sectors_per_cluster;
    if(data_cluster_count < 4085)
        /* this is a FAT12, not supported */
        return 0;
    else if(data_cluster_count < 65525)
        /* this is a FAT16 */
        partition->type = PARTITION_TYPE_FAT16;
    else
        /* this is a FAT32 */
        partition->type = PARTITION_TYPE_FAT32;

    /* fill header information */
    struct fat_header_struct* header = &fs->header;
    memset(header, 0, sizeof(*header));
    
    header->size = (offset_t) sector_count * bytes_per_sector;

    header->fat_offset = /* jump to partition */
                         partition_offset +
                         /* jump to fat */
                         (offset_t) reserved_sectors * bytes_per_sector;
    header->fat_size = (data_cluster_count + 2) * (partition->type == PARTITION_TYPE_FAT16 ? 2 : 4);

    header->sector_size = bytes_per_sector;
    header->cluster_size = (uint16_t) bytes_per_sector * sectors_per_cluster;

#if FAT_FAT32_SUPPORT
    if(partition->type == PARTITION_TYPE_FAT16)
#endif
    {
        header->root_dir_offset = /* jump to fats */
                                  header->fat_offset +
                                  /* jump to root directory entries */
                                  (offset_t) fat_copies * sectors_per_fat * bytes_per_sector;

        header->cluster_zero_offset = /* jump to root directory entries */
                                      header->root_dir_offset +
                                      /* skip root directory entries */
                                      (offset_t) max_root_entries * 32;
    }
#if FAT_FAT32_SUPPORT
    else
    {
        header->cluster_zero_offset = /* jump to fats */
                                      header->fat_offset +
                                      /* skip fats */
                                      (offset_t) fat_copies * sectors_per_fat32 * bytes_per_sector;

        header->root_dir_cluster = cluster_root_dir;
    }
#endif

    return 1;
}

Here is the caller graph for this function:

uint8_t fat_terminate_clusters	(	struct fat_fs_struct *	fs,
		cluster_t	cluster_num
	)			[static]

Frees a part of a cluster chain and correctly terminates the rest.

Marks the specified cluster as the new end of a cluster chain and frees all following clusters.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	cluster_num	The new end of the cluster chain.

Returns:

0 on failure, 1 on success.

See also:

fat_free_clusters

Definition at line 750 of file fat.c.

References partition_struct::device_write, FAT16_CLUSTER_LAST_MAX, FAT32_CLUSTER_LAST_MAX, fat_free_clusters(), fat_get_next_cluster(), fat_header_struct::fat_offset, fat_fs_struct::header, fat_fs_struct::partition, PARTITION_TYPE_FAT32, and partition_struct::type.

Referenced by fat_resize_file().

{
    if(!fs || cluster_num < 2)
        return 0;

    /* fetch next cluster before overwriting the cluster entry */
    cluster_t cluster_num_next = fat_get_next_cluster(fs, cluster_num);

    /* mark cluster as the last one */
#if FAT_FAT32_SUPPORT
    if(fs->partition->type == PARTITION_TYPE_FAT32)
    {
        uint32_t fat_entry = HTOL32(FAT32_CLUSTER_LAST_MAX);
        if(!fs->partition->device_write(fs->header.fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry)))
            return 0;
    }
    else
#endif
    {
        uint16_t fat_entry = HTOL16(FAT16_CLUSTER_LAST_MAX);
        if(!fs->partition->device_write(fs->header.fat_offset + cluster_num * sizeof(fat_entry), (uint8_t*) &fat_entry, sizeof(fat_entry)))
            return 0;
    }

    /* free remaining clusters */
    if(cluster_num_next)
        return fat_free_clusters(fs, cluster_num_next);
    else
        return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_write_dir_entry	(	const struct fat_fs_struct *	fs,
		struct fat_dir_entry_struct *	dir_entry
	)			[static]

Writes a directory entry to disk.

Note:

The file name is not checked for invalid characters.

The generation of the short 8.3 file name is quite simple. The first eight characters are used for the filename. The extension, if any, is made up of the first three characters following the last dot within the long filename. If the filename (without the extension) is longer than eight characters, the lower byte of the cluster number replaces the last two characters to avoid name clashes. In any other case, it is your responsibility to avoid name clashes.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	dir_entry	The directory entry to write.

Returns:

0 on failure, 1 on success.

Definition at line 1858 of file fat.c.

References fat_dir_entry_struct::attributes, fat_dir_entry_struct::cluster, partition_struct::device_write, fat_dir_entry_struct::entry_offset, fat_calc_83_checksum(), FAT_DIRENTRY_DELETED, FAT_DIRENTRY_LFNLAST, fat_get_datetime, fat_dir_entry_struct::file_size, htol16(), htol32(), fat_dir_entry_struct::long_name, min, and fat_fs_struct::partition.

Referenced by fat_close_file(), fat_create_dir(), fat_create_file(), fat_resize_file(), and fat_write_file().

{
    if(!fs || !dir_entry)
        return 0;
    
#if FAT_DATETIME_SUPPORT
    {
        uint16_t year;
        uint8_t month;
        uint8_t day;
        uint8_t hour;
        uint8_t min;
        uint8_t sec;

        fat_get_datetime(&year, &month, &day, &hour, &min, &sec);
        fat_set_file_modification_date(dir_entry, year, month, day);
        fat_set_file_modification_time(dir_entry, hour, min, sec);
    }
#endif

    device_write_t device_write = fs->partition->device_write;
    offset_t offset = dir_entry->entry_offset;
    const char* name = dir_entry->long_name;
    uint8_t name_len = strlen(name);
#if FAT_LFN_SUPPORT
    uint8_t lfn_entry_count = (name_len + 12) / 13;
#endif
    uint8_t buffer[32];

    /* write 8.3 entry */

    /* generate 8.3 file name */
    memset(&buffer[0], ' ', 11);
    char* name_ext = strrchr(name, '.');
    if(name_ext && *++name_ext)
    {
        uint8_t name_ext_len = strlen(name_ext);
        name_len -= name_ext_len + 1;

        if(name_ext_len > 3)
#if FAT_LFN_SUPPORT
            name_ext_len = 3;
#else
            return 0;
#endif
        
        memcpy(&buffer[8], name_ext, name_ext_len);
    }
    
    if(name_len <= 8)
    {
        memcpy(buffer, name, name_len);

#if FAT_LFN_SUPPORT
        /* For now, we create lfn entries for all files,
         * except the "." and ".." directory references.
         * This is to avoid difficulties with capitalization,
         * as 8.3 filenames allow uppercase letters only.
         *
         * Theoretically it would be possible to leave
         * the 8.3 entry alone if the basename and the
         * extension have no mixed capitalization.
         */
        if(name[0] == '.' &&
           ((name[1] == '.' && name[2] == '\0') ||
            name[1] == '\0')
          )
            lfn_entry_count = 0;
#endif
    }
    else
    {
#if FAT_LFN_SUPPORT
        memcpy(buffer, name, 8);

        /* Minimize 8.3 name clashes by appending
         * the lower byte of the cluster number.
         */
        uint8_t num = dir_entry->cluster & 0xff;

        buffer[6] = (num < 0xa0) ? ('0' + (num >> 4)) : ('a' + (num >> 4));
        num &= 0x0f;
        buffer[7] = (num < 0x0a) ? ('0' + num) : ('a' + num);
#else
        return 0;
#endif
    }
    if(buffer[0] == FAT_DIRENTRY_DELETED)
        buffer[0] = 0x05;

    /* fill directory entry buffer */
    memset(&buffer[11], 0, sizeof(buffer) - 11);
    buffer[0x0b] = dir_entry->attributes;
#if FAT_DATETIME_SUPPORT
    *((uint16_t*) &buffer[0x16]) = htol16(dir_entry->modification_time);
    *((uint16_t*) &buffer[0x18]) = htol16(dir_entry->modification_date);
#endif
#if FAT_FAT32_SUPPORT
    *((uint16_t*) &buffer[0x14]) = htol16((uint16_t) (dir_entry->cluster >> 16));
#endif
    *((uint16_t*) &buffer[0x1a]) = htol16(dir_entry->cluster);
    *((uint32_t*) &buffer[0x1c]) = htol32(dir_entry->file_size);

    /* write to disk */
#if FAT_LFN_SUPPORT
    if(!device_write(offset + (uint16_t) lfn_entry_count * 32, buffer, sizeof(buffer)))
#else
    if(!device_write(offset, buffer, sizeof(buffer)))
#endif
        return 0;
    
#if FAT_LFN_SUPPORT
    /* calculate checksum of 8.3 name */
    uint8_t checksum = fat_calc_83_checksum(buffer);
    
    /* write lfn entries */
    uint8_t lfn_entry =0;
    for( lfn_entry = lfn_entry_count; lfn_entry > 0; --lfn_entry)
    {
        memset(buffer, 0xff, sizeof(buffer));
        
        /* set file name */
        const char* long_name_curr = name + (lfn_entry - 1) * 13;
        uint8_t i = 1;
        while(i < 0x1f)
        {
            buffer[i++] = *long_name_curr;
            buffer[i++] = 0;

            switch(i)
            {
                case 0x0b:
                    i = 0x0e;
                    break;
                case 0x1a:
                    i = 0x1c;
                    break;
            }

            if(!*long_name_curr++)
                break;
        }
        
        /* set index of lfn entry */
        buffer[0x00] = lfn_entry;
        if(lfn_entry == lfn_entry_count)
            buffer[0x00] |= FAT_DIRENTRY_LFNLAST;

        /* mark as lfn entry */
        buffer[0x0b] = 0x0f;

        /* set 8.3 checksum */
        buffer[0x0d] = checksum;

        /* clear reserved bytes */
        buffer[0x0c] = 0;
        buffer[0x1a] = 0;
        buffer[0x1b] = 0;

        /* write entry */
        device_write(offset, buffer, sizeof(buffer));
    
        offset += sizeof(buffer);
    }
#endif
    
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function: