ATMEL: fat_unusual.c File Reference

Bool fat_select_filesystem	(	U8	u8_fat_type,
		Bool	b_MBR
	)

Bool fat_write_MBR ( void )

Bool fat_write_PBR ( Bool b_MBR )

Bool fat_clean_zone ( Bool b_MBR )

Bool fat_initialize_fat ( void )

void fat_translatedate_number_to_ascii	(	FS_STRING	sz_date,
		PTR_CACHE	ptr_date,
		Bool	enable_ms
	)

This function translates a date FAT value to ascii string.

Parameters:

	sz_date	table to store the date information storage format (ASCII) = "YYYYMMDDHHMMSSMS" = year, month, day, hour, minute, seconde, miliseconde
	ptr_date	pointer on date in internal cache
	enable_ms	TRUE, translate the millisecond field

Definition at line 1219 of file fat_unusual.c.

References fat_translate_number_to_ascii().

Referenced by fat_get_date().

01220 {
01221    FS_STRING ptr_string_date;
01222    U8 u8_i;
01223    U8 msb_date, lsb_date, msb_time, lsb_time, u8_ms = 0;
01224 
01225    // Read entry value of date and time
01226    if( enable_ms )
01227    {
01228       u8_ms = *ptr_date;
01229       ptr_date++;
01230    }
01231    lsb_time = *ptr_date;
01232    ptr_date++;
01233    msb_time = *ptr_date;
01234    ptr_date++;
01235    lsb_date = *ptr_date;
01236    ptr_date++;
01237    msb_date = *ptr_date;
01238 
01239    // Initialise the string with "1980000000000000" (Year = 1980 and other at 0)
01240    ptr_string_date = sz_date;
01241    *ptr_string_date = '1';
01242    ptr_string_date++;
01243    *ptr_string_date = '9';
01244    ptr_string_date++;
01245    *ptr_string_date = '8';
01246    ptr_string_date++;
01247    for( u8_i=(15-2) ; u8_i!=0 ; u8_i-- )
01248    {
01249       *ptr_string_date = '0';
01250       ptr_string_date++;
01251    }
01252 
01253    // Get the year
01254    fat_translate_number_to_ascii( sz_date, 4 , msb_date>>1 );
01255 
01256    // Get the month
01257    fat_translate_number_to_ascii( &sz_date[4] , 2 , ((msb_date & 0x01)<<3) + (lsb_date>>5) );
01258 
01259    // Get the day
01260    fat_translate_number_to_ascii( &sz_date[6] , 2 , lsb_date & 0x1F );
01261 
01262    // Get the hour
01263    fat_translate_number_to_ascii( &sz_date[8] , 2 , msb_time >> (11-8) );
01264 
01265    // Get the minute
01266    fat_translate_number_to_ascii( &sz_date[10] , 2 , ((msb_time & 0x07)<<3) + (lsb_time>>5) );
01267 
01268    // Get the seconde
01269    fat_translate_number_to_ascii( &sz_date[12] , 2 , (lsb_time & 0x1F)<<1 );
01270    if( 99 < u8_ms )
01271    {
01272      // Add one seconde
01273      fat_translate_number_to_ascii( &sz_date[12] , 2 , 1 );
01274      u8_ms -= 100;
01275    }
01276 
01277    // Get the miliseconde
01278    fat_translate_number_to_ascii( &sz_date[14] , 2 , u8_ms );
01279 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fat_translate_number_to_ascii	(	FS_STRING	sz_ascii_number,
		U8	u8_size_number_ascii,
		U8	u8_nb_increment
	)

This function translates a digital number to a ASCII number.

Parameters:

	sz_ascii_number	ascii string to increment (ex:"1907")
	u8_size_number_ascii	number of digit (ex:4)
	u8_nb_increment	number to add (ex:"102")

//! OUT, Update sz_ascii_number (ex:"2009")
//!

Definition at line 1292 of file fat_unusual.c.

Referenced by fat_translatedate_number_to_ascii().

01293 {
01294    FS_STRING ptr_sz_ascii_number;
01295 
01296    u8_size_number_ascii--;
01297 
01298    for( ; u8_nb_increment != 0 ; u8_nb_increment-- )
01299    {
01300       ptr_sz_ascii_number = sz_ascii_number + u8_size_number_ascii;
01301       ptr_sz_ascii_number[0]++;
01302       while( ('9'+1) == *ptr_sz_ascii_number )
01303       {
01304          *ptr_sz_ascii_number = '0';
01305          ptr_sz_ascii_number--;
01306          ptr_sz_ascii_number[0]++;
01307       }
01308    }
01309 }

Here is the caller graph for this function:

void fat_translatedate_ascii_to_number	(	const FS_STRING	sz_date,
		PTR_CACHE	ptr_date,
		Bool	enable_ms
	)

U16 fat_translate_ascii_to_number	(	const FS_STRING	sz_ascii_number,
		U8	u8_size_number_ascii
	)

void fat_create_long_name_entry	(	FS_STRING	sz_name,
		U8	u8_crc,
		U8	u8_id
	)

U8 fat_create_short_entry_name	(	FS_STRING	sz_name,
		FS_STRING	short_name,
		U8	nb,
		Bool	mode
	)

U8 fat_find_short_entry_name ( FS_STRING sz_name )

Bool fat_entry_shortname_compare ( FS_STRING short_name )

U8 fat_check_name ( FS_STRING sz_name )

U8 fat_translate_char_shortname ( U8 character )

Bool fat_alloc_entry_free ( U8 u8_nb_entry )

Bool fat_garbage_collector_entry ( void )

Bool fat_mount ( void )

This function mounts a partition file system (FAT12, FAT16 or FAT32) of selected drive.

This function mounts a partition.

Returns:: FALSE in case of error, see global value "fs_g_status" for more detail
TRUE otherwise

//! Global variables used
//! IN :
//!   fs_g_nav.u8_lun            Indicate the drive to mount
//!   fs_g_nav.u8_partition      Indicate the partition to mount (if FS_MULTI_PARTITION =  ENABLED )
//! OUT:
//!   fs_g_nav                   update structure
//! If the FS_MULTI_PARTITION option is disabled
//! then the mount routine selects the first partition supported by file system. <br>
//!

Definition at line 102 of file fat_unusual.c.

References FALSE, fat_cache_read_sector(), fat_check_device(), fat_clear_entry_info_and_ptr(), FS_512B, FS_BR_SIGNATURE_HIGH, FS_BR_SIGNATURE_LOW, FS_ERR_NO_FORMAT, FS_ERR_NO_PART, FS_ERR_NO_SUPPORT_PART, FS_FAT12_MAX_CLUSTERS, FS_FAT16_MAX_CLUSTERS, fs_g_nav, fs_g_nav_fast, fs_g_sector, fs_g_status, fs_gu32_addrsector, FS_MBR_OFFSET_PART_ENTRY, FS_NB_FAT, FS_PART_BOOTABLE, FS_PART_NO_BOOTABLE, FS_PART_TYPE_FAT12, FS_PART_TYPE_FAT16_INF32M, FS_PART_TYPE_FAT16_SUP32M, FS_PART_TYPE_FAT16_SUP32M_BIS, FS_PART_TYPE_FAT32, FS_PART_TYPE_FAT32_BIS, FS_SIZE_FILE_ENTRY, FS_TYPE_FAT_12, FS_TYPE_FAT_16, FS_TYPE_FAT_32, FS_TYPE_FAT_UNM, HIGH_16_BPB_BytsPerSec, HIGH_16_BPB_FATSz16, HIGH_16_BPB_ResvSecCnt, HIGH_16_BPB_RootEntCnt, HIGH_16_BPB_TotSec16, LOW0_32_BPB_FATSz32, LOW0_32_BPB_RootClus, LOW0_32_BPB_TotSec32, LOW1_32_BPB_FATSz32, LOW1_32_BPB_RootClus, LOW1_32_BPB_TotSec32, LOW2_32_BPB_FATSz32, LOW2_32_BPB_RootClus, LOW2_32_BPB_TotSec32, LOW3_32_BPB_FATSz32, LOW3_32_BPB_RootClus, LOW3_32_BPB_TotSec32, LOW_16_BPB_FATSz16, LOW_16_BPB_FSInfo, LOW_16_BPB_ResvSecCnt, LOW_16_BPB_RootEntCnt, LOW_16_BPB_TotSec16, LSB, LSB0, LSB1, LSB2, LSB3, mem_sector_size(), MSB, Fs_management::rootdir, Fs_rootdir::seg, TRUE, Fs_management::u16_fat_size, Fs_management::u16_offset_FSInfo, Fs_rootdir::u16_pos, Fs_rootdir::u16_size, Fs_rootdir::u32_cluster, Fs_management::u32_cluster_sel_dir, Fs_management::u32_CountofCluster, Fs_management::u32_offset_data, Fs_management::u32_ptr_fat, U8_BPB_SecPerClus, Fs_management::u8_BPB_SecPerClus, Fs_management::u8_lun, Fs_management::u8_partition, and Fs_management_fast::u8_type_fat.

00103 {
00104    U8  u8_sector_size;
00105    U8  u8_tmp;
00106    U16 u16_tmp;
00107    U32 u32_tmp;
00108 
00109    // Select the root directory
00110    fs_g_nav.u32_cluster_sel_dir   = 0;
00111    // No selected file
00112    fat_clear_entry_info_and_ptr();
00113 
00114    fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_UNM;
00115    fs_gu32_addrsector = 0;    // Start read at the beginning of memory
00116 
00117    // Check if the drive is availabled
00118    if( !fat_check_device() )
00119       return FALSE;
00120 
00121    while( 1 )  // Search a valid partition
00122    {
00123       // Read one sector
00124       if( !fat_cache_read_sector( TRUE ))
00125          return FALSE;
00126 
00127       // Check PBR/MBR signature
00128       if ( (fs_g_sector[510] != FS_BR_SIGNATURE_LOW  )
00129       &&   (fs_g_sector[511] != FS_BR_SIGNATURE_HIGH ) )
00130       {
00131          fs_g_status = FS_ERR_NO_FORMAT;
00132          return FALSE;
00133       }
00134 
00135       if ( 0 == fs_gu32_addrsector )
00136       {
00137          //** first sector then check a MBR structure
00138          // Search the first partition supported
00139 #if (FS_MULTI_PARTITION == ENABLED)
00140          u16_tmp=0;  // Init to "no valid partition found"
00141 #endif
00142          for( u8_tmp=0 ; u8_tmp!=4 ; u8_tmp++ )
00143          {
00144             // The first sector must be a MBR, then check the partition entry in the MBR
00145             if ( ((fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+0] == FS_PART_BOOTABLE             )||
00146                   (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+0] == FS_PART_NO_BOOTABLE          )  )
00147             &&   ((fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT12           )||
00148                   (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT16_INF32M    )||
00149                   (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT16_SUP32M    )||
00150                   (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT16_SUP32M_BIS)||
00151                   (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT32           )||
00152                   (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT32_BIS       )) )
00153             {
00154                // A valid partition is found
00155 #if (FS_MULTI_PARTITION == ENABLED)
00156                if( u16_tmp == fs_g_nav.u8_partition )
00157                   break;   // The selected partition is valid
00158                u16_tmp++;
00159 #else
00160                break;
00161 #endif
00162             }
00163          }
00164          if( u8_tmp != 4 )
00165          {
00166             // Partition found -> Get partition position (unit sector) at offset 8
00167             LSB0(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+8];
00168             LSB1(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+9];
00169             LSB2(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+10];
00170             LSB3(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+11];
00171             fs_gu32_addrsector *= mem_sector_size( fs_g_nav.u8_lun );
00172             continue;   // Go to check PBR of partition
00173          }
00174 
00175          // No MBR found then check PBR
00176 #if (FS_MULTI_PARTITION == ENABLED)
00177          // The device don't have mutli partition, but only one
00178          if ( 0 != fs_g_nav.u8_partition )
00179          {
00180             fs_g_status = FS_ERR_NO_PART;
00181             return FALSE;
00182          }
00183 #endif
00184       }
00185 
00186       //** Check a PBR structure
00187       if ( (fs_g_sector[0] == 0xEB) &&          // PBR Byte 0
00188            (fs_g_sector[2] == 0x90) &&          // PBR Byte 2
00189            ((fs_g_sector[21] & 0xF0) == 0xF0) ) // PBR Byte 21 : Media byte
00190       {
00191          break;   // valid PBR found
00192       }
00193       // PBR not found
00194       fs_g_status = FS_ERR_NO_PART;
00195       return FALSE;
00196    }
00197 
00198    fs_g_status = FS_ERR_NO_SUPPORT_PART;  // by default partition no supported
00199 
00200    // Get sector size of File System (unit 512B)
00201    // To translate from sector disk unit to sector 512B unit
00202    u8_sector_size = HIGH_16_BPB_BytsPerSec/2;
00203 
00204    // Read BPB_SecPerClus (unit sector)
00205    fs_g_nav.u8_BPB_SecPerClus = U8_BPB_SecPerClus * u8_sector_size;
00206 
00207    //** FAT Type determination (algorithm of "Hardware White Paper FAT")
00208    // Get FAT size (unit sector)
00209    LSB( u16_tmp ) = LOW_16_BPB_FATSz16;
00210    MSB( u16_tmp ) = HIGH_16_BPB_FATSz16;
00211    if ( 0==u16_tmp )
00212    {
00213       LSB( u16_tmp ) = LOW0_32_BPB_FATSz32;
00214       MSB( u16_tmp ) = LOW1_32_BPB_FATSz32;
00215       // a large FAT32 isn't supported by this file system
00216       if( (0 != LOW2_32_BPB_FATSz32 )
00217       ||  (0 != LOW3_32_BPB_FATSz32 ) )
00218       {
00219          return FALSE;
00220       }
00221    }
00222    fs_g_nav.u16_fat_size = u16_tmp * u8_sector_size;
00223 
00224    // Get total count of sectors in partition
00225    if ( (0==LOW_16_BPB_TotSec16) && (0==HIGH_16_BPB_TotSec16) )
00226    {
00227       LSB0( u32_tmp ) = LOW0_32_BPB_TotSec32;
00228       LSB1( u32_tmp ) = LOW1_32_BPB_TotSec32;
00229       LSB2( u32_tmp ) = LOW2_32_BPB_TotSec32;
00230       LSB3( u32_tmp ) = LOW3_32_BPB_TotSec32;
00231    }
00232    else
00233    {
00234       LSB0( u32_tmp ) = LOW_16_BPB_TotSec16;
00235       LSB1( u32_tmp ) = HIGH_16_BPB_TotSec16;
00236       LSB2( u32_tmp ) = 0;
00237       LSB3( u32_tmp ) = 0;
00238    }
00239    u32_tmp *= u8_sector_size;   // Translate from sector disk unit to sector 512B unit
00240 
00241    // Compute the offset (unit 512B) between the end of FAT (beginning of root dir in FAT1x) and the beginning of PBR
00242    fs_g_nav.rootdir.seg.u16_pos = FS_NB_FAT * fs_g_nav.u16_fat_size;
00243 
00244    // Compute the root directory size (unit sector), for FAT32 is always 0
00245    LSB( u16_tmp ) = LOW_16_BPB_RootEntCnt;
00246    MSB( u16_tmp ) = HIGH_16_BPB_RootEntCnt;
00247    fs_g_nav.rootdir.seg.u16_size = ((u16_tmp * FS_SIZE_FILE_ENTRY) + ((FS_512B*u8_sector_size)-1)) / (FS_512B*u8_sector_size);
00248    fs_g_nav.rootdir.seg.u16_size *= u8_sector_size;
00249 
00250    // Get number of reserved sector
00251    LSB( u16_tmp ) = LOW_16_BPB_ResvSecCnt;
00252    MSB( u16_tmp ) = HIGH_16_BPB_ResvSecCnt;
00253    // Get FSInfo position
00254    fs_g_nav.u16_offset_FSInfo = (u16_tmp-LOW_16_BPB_FSInfo)*u8_sector_size;
00255    u16_tmp *= u8_sector_size; // number of reserved sector translated in unit 512B
00256 
00257    // Compute the FAT address (unit 512B)
00258    fs_g_nav.u32_ptr_fat = fs_gu32_addrsector + u16_tmp;
00259 
00260    // Compute the offset (unit 512B) between the first data cluster and the FAT beginning
00261    fs_g_nav.u32_offset_data = (FS_NB_FAT * (U32)fs_g_nav.u16_fat_size) + (U32)fs_g_nav.rootdir.seg.u16_size;
00262 
00263    // Compute the data region (clusters space = Total - Sector used) size (unit 512B)
00264    u32_tmp -= ((U32)u16_tmp + fs_g_nav.u32_offset_data);
00265 
00266    // Compute the count of CLUSTER in the data region
00267    // !!!Optimization -> u32_CountofCluster (unit 512B)/ fs_g_nav.u8_BPB_SecPerClus (unit 512B & power of 2)
00268    for( u8_tmp = fs_g_nav.u8_BPB_SecPerClus; u8_tmp!=1 ; u8_tmp >>= 1 )
00269    {
00270      u32_tmp  >>= 1;   // This computation round down
00271    }
00272    fs_g_nav.u32_CountofCluster = u32_tmp+2; // The total of cluster include the two reserved clusters
00273 
00274    // Determine the FAT type
00275    if (u32_tmp < FS_FAT12_MAX_CLUSTERS)
00276    {
00277       // Is FAT 12
00278 #if (FS_FAT_12 == DISABLED)
00279       return FALSE;
00280 #endif
00281       fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_12;
00282    } else {
00283    if (u32_tmp < FS_FAT16_MAX_CLUSTERS)
00284    {
00285       // Is FAT 16
00286 #if (FS_FAT_16 == DISABLED)
00287       return FS_NO_SUPPORT_PART;
00288 #endif
00289       fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_16;
00290    } else {
00291       // Is FAT 32
00292 #if (FS_FAT_32 == DISABLED)
00293       return FALSE;
00294 #endif
00295       fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_32;
00296       // In FAT32, the root dir is like another directory, this one have a cluster list
00297       // Get the first cluster number of root
00298       LSB0( fs_g_nav.rootdir.u32_cluster ) = LOW0_32_BPB_RootClus;
00299       LSB1( fs_g_nav.rootdir.u32_cluster ) = LOW1_32_BPB_RootClus;
00300       LSB2( fs_g_nav.rootdir.u32_cluster ) = LOW2_32_BPB_RootClus;
00301       LSB3( fs_g_nav.rootdir.u32_cluster ) = LOW3_32_BPB_RootClus;
00302    }
00303    }
00304 
00305    return TRUE;
00306 }

Here is the call graph for this function:

void fat_get_date	(	FS_STRING	sz_date,
		Bool	type_date
	)

This function reads the information about a date.

Parameters:

	type_date	choose the date type (FS_DATE_LAST_WRITE or FS_DATE_CREATION)
	sz_date	table to store the date storage format (ASCII) = "YYYYMMDDHHMMSSMS" = year, month, day, hour, minute, seconde, miliseconde

Definition at line 1196 of file fat_unusual.c.

References FALSE, fat_get_ptr_entry(), fat_translatedate_number_to_ascii(), FS_DATE_LAST_WRITE, and TRUE.

01197 {
01198    PTR_CACHE ptr_entry;
01199 
01200    ptr_entry = fat_get_ptr_entry();
01201    if( FS_DATE_LAST_WRITE == type_date )
01202    {
01203       fat_translatedate_number_to_ascii( sz_date , &ptr_entry[22] , FALSE );
01204    }
01205    else
01206    {
01207       fat_translatedate_number_to_ascii( sz_date , &ptr_entry[13] , TRUE );
01208    }
01209 }

Here is the call graph for this function:

U32 fat_getfreespace ( void )

This function returns the space free in the partition.

Returns:: the number of sector free
if 0, then error or full

Definition at line 2107 of file fat_unusual.c.

References FALSE, fat_cluster_readnext(), fat_cluster_val(), fat_read_fat32_FSInfo(), fat_write_fat32_FSInfo(), FS_CLUST_VAL_READ, fs_g_cluster, fs_g_nav, Is_fat12, Is_fat32, Fs_management::u32_CountofCluster, Fs_cluster::u32_pos, Fs_cluster::u32_val, and Fs_management::u8_BPB_SecPerClus.

02108 {
02109    U32 u32_nb_free_cluster = 0;
02110 
02111    // Read ALL FAT1
02112    fs_g_cluster.u32_pos = 2;
02113 
02114    if( Is_fat12 )
02115    {  // FAT12 only
02116       for(
02117       ;     fs_g_cluster.u32_pos < fs_g_nav.u32_CountofCluster
02118       ;     fs_g_cluster.u32_pos++ )
02119       {
02120          // Get the value of the cluster
02121          if ( !fat_cluster_val( FS_CLUST_VAL_READ ) )
02122             return 0;
02123 
02124          if ( 0 == fs_g_cluster.u32_val )
02125             u32_nb_free_cluster++;
02126       }
02127    }
02128    else
02129    {
02130       if( Is_fat32 )
02131       {
02132          u32_nb_free_cluster = fat_read_fat32_FSInfo();
02133          if( 0xFFFFFFFF != u32_nb_free_cluster )
02134             goto endof_fat_getfreespace;
02135          u32_nb_free_cluster = 0;
02136       }
02137       // Speed optimization only for FAT16 and FAT32
02138       // init first value used by fat_cluster_readnext()
02139       if( !fat_cluster_val( FS_CLUST_VAL_READ ))
02140          return FALSE;
02141       for(
02142       ;     fs_g_cluster.u32_pos < fs_g_nav.u32_CountofCluster
02143       ;     fs_g_cluster.u32_pos++ )
02144       {
02145          if ( 0 == fs_g_cluster.u32_val )
02146             u32_nb_free_cluster++;
02147          if( !fat_cluster_readnext() )
02148             return FALSE;
02149       }
02150 #if (FSFEATURE_WRITE_COMPLET == (FS_LEVEL_FEATURES & FSFEATURE_WRITE_COMPLET) )
02151       if( Is_fat32 )
02152       {
02153          // Save value for the future call
02154          fat_write_fat32_FSInfo( u32_nb_free_cluster );
02155       }
02156 #endif
02157    }
02158 endof_fat_getfreespace:
02159    return (u32_nb_free_cluster * fs_g_nav.u8_BPB_SecPerClus);
02160 }

Here is the call graph for this function:

U8 fat_getfreespace_percent ( void )

This function returns the space free in percent.

Returns:: percent of free space (1 to 100) if 0, then error or full

//! More speed than fat_getfreespace() routine but error delta 1%
//!

Definition at line 2172 of file fat_unusual.c.

References FALSE, fat_cache_read_sector(), fat_cluster_val(), fat_getfreespace(), fat_read_fat32_FSInfo(), FS_CLUST_VAL_READ, fs_g_cluster, fs_g_nav, fs_g_sector, fs_gu32_addrsector, Is_fat12, Is_fat16, Is_fat32, TRUE, Fs_management::u16_fat_size, Fs_management::u32_CountofCluster, Fs_cluster::u32_pos, and Fs_management::u8_BPB_SecPerClus.

02173 {
02174    U32 u32_nb_free_cluster = 0;
02175    U16 u16_tmp, u16_pos;
02176 
02177    if( Is_fat12 )
02178    {  // No speed optimization necessary on FAT12
02179       return (((fat_getfreespace()/fs_g_nav.u8_BPB_SecPerClus)*100) / fs_g_nav.u32_CountofCluster);
02180    }
02181 
02182 
02183    fs_g_cluster.u32_pos = 2;
02184    // Init first value used by fat_cluster_readnext()
02185    if( !fat_cluster_val( FS_CLUST_VAL_READ ))
02186       return FALSE;
02187 
02188    // The optimization is to
02189    // - read only the LSB byte of cluster
02190    // - read only 1 cluster for 2 clusters
02191    if( Is_fat32 )
02192    {
02193       u32_nb_free_cluster = fat_read_fat32_FSInfo();
02194       if( 0xFFFFFFFF != u32_nb_free_cluster )
02195          goto endof_fat_getfreespace_percent;
02196       u32_nb_free_cluster = 0;
02197 
02198       u16_pos = 2*4;
02199       for(  u16_tmp = fs_g_nav.u16_fat_size
02200       ;     u16_tmp!=0
02201       ;     u16_tmp-- )
02202       {
02203          for( ; u16_pos < 512 ; u16_pos += (2*4) )
02204          {
02205             if( 0 == fs_g_sector[u16_pos] )
02206                u32_nb_free_cluster+=2;
02207          }
02208          // Read next sector in FAT
02209          u16_pos = 0;
02210          fs_gu32_addrsector++;
02211          if( !fat_cache_read_sector( TRUE ))
02212             return 0;
02213       }
02214    }
02215 
02216    if ( Is_fat16 )
02217    {
02218       u16_pos = 2*2;
02219 
02220       for(  u16_tmp = fs_g_nav.u16_fat_size
02221       ;     u16_tmp!=0
02222       ;     u16_tmp-- )
02223       {
02224          for( ; u16_pos < 512 ; u16_pos += (2*2) )
02225          {
02226             if( 0 == fs_g_sector[u16_pos] )
02227                u32_nb_free_cluster+=2;
02228          }
02229          // Read next sector in FAT
02230          u16_pos = 0;
02231          fs_gu32_addrsector++;
02232          if( !fat_cache_read_sector( TRUE ))
02233             return 0;
02234       }
02235    }
02236 
02237    // Compute percent
02238    if( u32_nb_free_cluster > fs_g_nav.u32_CountofCluster )
02239       return 100;
02240    if( u32_nb_free_cluster > ((fs_g_nav.u32_CountofCluster-u32_nb_free_cluster)/256) )
02241    {
02242       // Compute and add a delta error
02243       u32_nb_free_cluster -= ((fs_g_nav.u32_CountofCluster-u32_nb_free_cluster)/256);
02244    }
02245 endof_fat_getfreespace_percent:
02246    return ((u32_nb_free_cluster * 100) / fs_g_nav.u32_CountofCluster);
02247 }

Here is the call graph for this function:

fat_unusual.c File Reference

Functions

Detailed Description

Function Documentation


Functions
Bool	fat_select_filesystem (U8 u8_fat_type, Bool b_MBR)
Bool	fat_write_MBR (void)
Bool	fat_write_PBR (Bool b_MBR)
Bool	fat_clean_zone (Bool b_MBR)
Bool	fat_initialize_fat (void)
Bool	fat_mount (void)
	This function mounts a partition file system (FAT12, FAT16 or FAT32) of selected drive.
void	fat_get_date (FS_STRING sz_date, Bool type_date)
	This function reads the information about a date.
U32	fat_getfreespace (void)
	This function returns the space free in the partition.
U8	fat_getfreespace_percent (void)
	This function returns the space free in percent.
Sub routines used by date read-write routines
void	fat_translatedate_number_to_ascii (FS_STRING sz_date, PTR_CACHE ptr_date, Bool enable_ms)
	This function translates a date FAT value to ascii string.
void	fat_translate_number_to_ascii (FS_STRING sz_ascii_number, U8 u8_size_number_ascii, U8 u8_nb_increment)
	This function translates a digital number to a ASCII number.
void	fat_translatedate_ascii_to_number (const FS_STRING sz_date, PTR_CACHE ptr_date, Bool enable_ms)
U16	fat_translate_ascii_to_number (const FS_STRING sz_ascii_number, U8 u8_size_number_ascii)
Sub routine used to create a entry file
void	fat_create_long_name_entry (FS_STRING sz_name, U8 u8_crc, U8 u8_id)
U8	fat_create_short_entry_name (FS_STRING sz_name, FS_STRING short_name, U8 nb, Bool mode)
U8	fat_find_short_entry_name (FS_STRING sz_name)
Bool	fat_entry_shortname_compare (FS_STRING short_name)
U8	fat_check_name (FS_STRING sz_name)
U8	fat_translate_char_shortname (U8 character)
Bool	fat_alloc_entry_free (U8 u8_nb_entry)
Bool	fat_garbage_collector_entry (void)