#include "conf_explorer.h"
#include "fs_com.h"
#include "fat.h"
#include <LIB_MEM>
#include <LIB_CTRLACCESS>
Go to the source code of this file.
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) |
This file is a set of rarely-used FAT functions.
Definition in file fat_unusual.c.
Bool fat_write_MBR | ( | void | ) |
Bool fat_initialize_fat | ( | void | ) |
This function translates a date FAT value to ascii string.
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 1244 of file fat_unusual.c.
References fat_translate_number_to_ascii().
Referenced by fat_get_date().
01245 { 01246 FS_STRING ptr_string_date; 01247 U8 u8_i; 01248 U8 msb_date, lsb_date, msb_time, lsb_time, u8_ms = 0; 01249 01250 // Read entry value of date and time 01251 if( enable_ms ) 01252 { 01253 u8_ms = *ptr_date; 01254 ptr_date++; 01255 } 01256 lsb_time = *ptr_date; 01257 ptr_date++; 01258 msb_time = *ptr_date; 01259 ptr_date++; 01260 lsb_date = *ptr_date; 01261 ptr_date++; 01262 msb_date = *ptr_date; 01263 01264 // Initialise the string with "1980000000000000" (Year = 1980 and other at 0) 01265 ptr_string_date = sz_date; 01266 *ptr_string_date = '1'; 01267 ptr_string_date++; 01268 *ptr_string_date = '9'; 01269 ptr_string_date++; 01270 *ptr_string_date = '8'; 01271 ptr_string_date++; 01272 for( u8_i=(15-2) ; u8_i!=0 ; u8_i-- ) 01273 { 01274 *ptr_string_date = '0'; 01275 ptr_string_date++; 01276 } 01277 01278 // Get the year 01279 fat_translate_number_to_ascii( sz_date, 4 , msb_date>>1 ); 01280 01281 // Get the month 01282 fat_translate_number_to_ascii( &sz_date[4] , 2 , ((msb_date & 0x01)<<3) + (lsb_date>>5) ); 01283 01284 // Get the day 01285 fat_translate_number_to_ascii( &sz_date[6] , 2 , lsb_date & 0x1F ); 01286 01287 // Get the hour 01288 fat_translate_number_to_ascii( &sz_date[8] , 2 , msb_time >> (11-8) ); 01289 01290 // Get the minute 01291 fat_translate_number_to_ascii( &sz_date[10] , 2 , ((msb_time & 0x07)<<3) + (lsb_time>>5) ); 01292 01293 // Get the seconde 01294 fat_translate_number_to_ascii( &sz_date[12] , 2 , (lsb_time & 0x1F)<<1 ); 01295 if( 99 < u8_ms ) 01296 { 01297 // Add one seconde 01298 fat_translate_number_to_ascii( &sz_date[12] , 2 , 1 ); 01299 u8_ms -= 100; 01300 } 01301 01302 // Get the miliseconde 01303 fat_translate_number_to_ascii( &sz_date[14] , 2 , u8_ms ); 01304 }
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.
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 1317 of file fat_unusual.c.
Referenced by fat_translatedate_number_to_ascii().
01318 { 01319 FS_STRING ptr_sz_ascii_number; 01320 01321 u8_size_number_ascii--; 01322 01323 for( ; u8_nb_increment != 0 ; u8_nb_increment-- ) 01324 { 01325 ptr_sz_ascii_number = sz_ascii_number + u8_size_number_ascii; 01326 ptr_sz_ascii_number[0]++; 01327 while( ('9'+1) == *ptr_sz_ascii_number ) 01328 { 01329 *ptr_sz_ascii_number = '0'; 01330 ptr_sz_ascii_number--; 01331 ptr_sz_ascii_number[0]++; 01332 } 01333 } 01334 }
void fat_translatedate_ascii_to_number | ( | const FS_STRING | sz_date, | |
PTR_CACHE | ptr_date, | |||
Bool | enable_ms | |||
) |
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.
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 105 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.
00106 { 00107 U8 u8_sector_size; 00108 U8 u8_tmp; 00109 U16 u16_tmp; 00110 U32 u32_tmp; 00111 00112 // Select the root directory 00113 fs_g_nav.u32_cluster_sel_dir = 0; 00114 // No selected file 00115 fat_clear_entry_info_and_ptr(); 00116 00117 fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_UNM; 00118 fs_gu32_addrsector = 0; // Start read at the beginning of memory 00119 00120 // Check if the drive is availabled 00121 if( !fat_check_device() ) 00122 return FALSE; 00123 00124 while( 1 ) // Search a valid partition 00125 { 00126 // Read one sector 00127 if( !fat_cache_read_sector( TRUE )) 00128 return FALSE; 00129 00130 // Check PBR/MBR signature 00131 if ( (fs_g_sector[510] != FS_BR_SIGNATURE_LOW ) 00132 && (fs_g_sector[511] != FS_BR_SIGNATURE_HIGH ) ) 00133 { 00134 fs_g_status = FS_ERR_NO_FORMAT; 00135 return FALSE; 00136 } 00137 00138 if ( 0 == fs_gu32_addrsector ) 00139 { 00140 //** first sector then check a MBR structure 00141 // Search the first partition supported 00142 #if (FS_MULTI_PARTITION == ENABLED) 00143 u16_tmp=0; // Init to "no valid partition found" 00144 #endif 00145 for( u8_tmp=0 ; u8_tmp!=4 ; u8_tmp++ ) 00146 { 00147 // The first sector must be a MBR, then check the partition entry in the MBR 00148 if ( ((fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+0] == FS_PART_BOOTABLE )|| 00149 (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+0] == FS_PART_NO_BOOTABLE ) ) 00150 && ((fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT12 )|| 00151 (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT16_INF32M )|| 00152 (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT16_SUP32M )|| 00153 (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT16_SUP32M_BIS)|| 00154 (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT32 )|| 00155 (fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+4] == FS_PART_TYPE_FAT32_BIS )) ) 00156 { 00157 // A valid partition is found 00158 #if (FS_MULTI_PARTITION == ENABLED) 00159 if( u16_tmp == fs_g_nav.u8_partition ) 00160 break; // The selected partition is valid 00161 u16_tmp++; 00162 #else 00163 break; 00164 #endif 00165 } 00166 } 00167 if( u8_tmp != 4 ) 00168 { 00169 // Partition found -> Get partition position (unit sector) at offset 8 00170 LSB0(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+8]; 00171 LSB1(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+9]; 00172 LSB2(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+10]; 00173 LSB3(fs_gu32_addrsector) = fs_g_sector[FS_MBR_OFFSET_PART_ENTRY(u8_tmp)+11]; 00174 fs_gu32_addrsector *= mem_sector_size( fs_g_nav.u8_lun ); 00175 continue; // Go to check PBR of partition 00176 } 00177 00178 // No MBR found then check PBR 00179 #if (FS_MULTI_PARTITION == ENABLED) 00180 // The device don't have mutli partition, but only one 00181 if ( 0 != fs_g_nav.u8_partition ) 00182 { 00183 fs_g_status = FS_ERR_NO_PART; 00184 return FALSE; 00185 } 00186 #endif 00187 } 00188 00189 //** Check a PBR structure 00190 if ( (fs_g_sector[0] == 0xEB) && // PBR Byte 0 00191 (fs_g_sector[2] == 0x90) && // PBR Byte 2 00192 ((fs_g_sector[21] & 0xF0) == 0xF0) ) // PBR Byte 21 : Media byte 00193 { 00194 break; // valid PBR found 00195 } 00196 // PBR not found 00197 fs_g_status = FS_ERR_NO_PART; 00198 return FALSE; 00199 } 00200 00201 fs_g_status = FS_ERR_NO_SUPPORT_PART; // by default partition no supported 00202 00203 // Get sector size of File System (unit 512B) 00204 // To translate from sector disk unit to sector 512B unit 00205 u8_sector_size = HIGH_16_BPB_BytsPerSec/2; 00206 00207 // Read BPB_SecPerClus (unit sector) 00208 fs_g_nav.u8_BPB_SecPerClus = U8_BPB_SecPerClus * u8_sector_size; 00209 00210 //** FAT Type determination (algorithm of "Hardware White Paper FAT") 00211 // Get FAT size (unit sector) 00212 LSB( u16_tmp ) = LOW_16_BPB_FATSz16; 00213 MSB( u16_tmp ) = HIGH_16_BPB_FATSz16; 00214 if ( 0==u16_tmp ) 00215 { 00216 LSB( u16_tmp ) = LOW0_32_BPB_FATSz32; 00217 MSB( u16_tmp ) = LOW1_32_BPB_FATSz32; 00218 // a large FAT32 isn't supported by this file system 00219 if( (0 != LOW2_32_BPB_FATSz32 ) 00220 || (0 != LOW3_32_BPB_FATSz32 ) ) 00221 { 00222 return FALSE; 00223 } 00224 } 00225 fs_g_nav.u16_fat_size = u16_tmp * u8_sector_size; 00226 00227 // Get total count of sectors in partition 00228 if ( (0==LOW_16_BPB_TotSec16) && (0==HIGH_16_BPB_TotSec16) ) 00229 { 00230 LSB0( u32_tmp ) = LOW0_32_BPB_TotSec32; 00231 LSB1( u32_tmp ) = LOW1_32_BPB_TotSec32; 00232 LSB2( u32_tmp ) = LOW2_32_BPB_TotSec32; 00233 LSB3( u32_tmp ) = LOW3_32_BPB_TotSec32; 00234 } 00235 else 00236 { 00237 LSB0( u32_tmp ) = LOW_16_BPB_TotSec16; 00238 LSB1( u32_tmp ) = HIGH_16_BPB_TotSec16; 00239 LSB2( u32_tmp ) = 0; 00240 LSB3( u32_tmp ) = 0; 00241 } 00242 u32_tmp *= u8_sector_size; // Translate from sector disk unit to sector 512B unit 00243 00244 // Compute the offset (unit 512B) between the end of FAT (beginning of root dir in FAT1x) and the beginning of PBR 00245 fs_g_nav.rootdir.seg.u16_pos = FS_NB_FAT * fs_g_nav.u16_fat_size; 00246 00247 // Compute the root directory size (unit sector), for FAT32 is always 0 00248 LSB( u16_tmp ) = LOW_16_BPB_RootEntCnt; 00249 MSB( u16_tmp ) = HIGH_16_BPB_RootEntCnt; 00250 fs_g_nav.rootdir.seg.u16_size = ((u16_tmp * FS_SIZE_FILE_ENTRY) + ((FS_512B*u8_sector_size)-1)) / (FS_512B*u8_sector_size); 00251 fs_g_nav.rootdir.seg.u16_size *= u8_sector_size; 00252 00253 // Get number of reserved sector 00254 LSB( u16_tmp ) = LOW_16_BPB_ResvSecCnt; 00255 MSB( u16_tmp ) = HIGH_16_BPB_ResvSecCnt; 00256 // Get FSInfo position 00257 fs_g_nav.u16_offset_FSInfo = (u16_tmp-LOW_16_BPB_FSInfo)*u8_sector_size; 00258 u16_tmp *= u8_sector_size; // number of reserved sector translated in unit 512B 00259 00260 // Compute the FAT address (unit 512B) 00261 fs_g_nav.u32_ptr_fat = fs_gu32_addrsector + u16_tmp; 00262 00263 // Compute the offset (unit 512B) between the first data cluster and the FAT beginning 00264 fs_g_nav.u32_offset_data = (FS_NB_FAT * (U32)fs_g_nav.u16_fat_size) + (U32)fs_g_nav.rootdir.seg.u16_size; 00265 00266 // Compute the data region (clusters space = Total - Sector used) size (unit 512B) 00267 u32_tmp -= ((U32)u16_tmp + fs_g_nav.u32_offset_data); 00268 00269 // Compute the count of CLUSTER in the data region 00270 // !!!Optimization -> u32_CountofCluster (unit 512B)/ fs_g_nav.u8_BPB_SecPerClus (unit 512B & power of 2) 00271 if (!fs_g_nav.u8_BPB_SecPerClus) 00272 return FALSE; 00273 for( u8_tmp = fs_g_nav.u8_BPB_SecPerClus; u8_tmp!=1 ; u8_tmp >>= 1 ) 00274 { 00275 u32_tmp >>= 1; // This computation round down 00276 } 00277 fs_g_nav.u32_CountofCluster = u32_tmp+2; // The total of cluster include the two reserved clusters 00278 00279 // Determine the FAT type 00280 if (u32_tmp < FS_FAT12_MAX_CLUSTERS) 00281 { 00282 // Is FAT 12 00283 #if (FS_FAT_12 == DISABLED) 00284 return FALSE; 00285 #endif 00286 fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_12; 00287 } else { 00288 if (u32_tmp < FS_FAT16_MAX_CLUSTERS) 00289 { 00290 // Is FAT 16 00291 #if (FS_FAT_16 == DISABLED) 00292 return FS_NO_SUPPORT_PART; 00293 #endif 00294 fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_16; 00295 } else { 00296 // Is FAT 32 00297 #if (FS_FAT_32 == DISABLED) 00298 return FALSE; 00299 #endif 00300 fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_32; 00301 // In FAT32, the root dir is like another directory, this one have a cluster list 00302 // Get the first cluster number of root 00303 LSB0( fs_g_nav.rootdir.u32_cluster ) = LOW0_32_BPB_RootClus; 00304 LSB1( fs_g_nav.rootdir.u32_cluster ) = LOW1_32_BPB_RootClus; 00305 LSB2( fs_g_nav.rootdir.u32_cluster ) = LOW2_32_BPB_RootClus; 00306 LSB3( fs_g_nav.rootdir.u32_cluster ) = LOW3_32_BPB_RootClus; 00307 } 00308 } 00309 00310 return TRUE; 00311 }
This function reads the information about a date.
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 1221 of file fat_unusual.c.
References FALSE, fat_get_ptr_entry(), fat_translatedate_number_to_ascii(), FS_DATE_LAST_WRITE, and TRUE.
01222 { 01223 PTR_CACHE ptr_entry; 01224 01225 ptr_entry = fat_get_ptr_entry(); 01226 if( FS_DATE_LAST_WRITE == type_date ) 01227 { 01228 fat_translatedate_number_to_ascii( sz_date , &ptr_entry[22] , FALSE ); 01229 } 01230 else 01231 { 01232 fat_translatedate_number_to_ascii( sz_date , &ptr_entry[13] , TRUE ); 01233 } 01234 }
U32 fat_getfreespace | ( | void | ) |
This function returns the space free in the partition.
Definition at line 2132 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.
02133 { 02134 U32 u32_nb_free_cluster = 0; 02135 02136 // Read ALL FAT1 02137 fs_g_cluster.u32_pos = 2; 02138 02139 if( Is_fat12 ) 02140 { // FAT12 only 02141 for( 02142 ; fs_g_cluster.u32_pos < fs_g_nav.u32_CountofCluster 02143 ; fs_g_cluster.u32_pos++ ) 02144 { 02145 // Get the value of the cluster 02146 if ( !fat_cluster_val( FS_CLUST_VAL_READ ) ) 02147 return 0; 02148 02149 if ( 0 == fs_g_cluster.u32_val ) 02150 u32_nb_free_cluster++; 02151 } 02152 } 02153 else 02154 { 02155 if( Is_fat32 ) 02156 { 02157 u32_nb_free_cluster = fat_read_fat32_FSInfo(); 02158 if( 0xFFFFFFFF != u32_nb_free_cluster ) 02159 goto endof_fat_getfreespace; 02160 u32_nb_free_cluster = 0; 02161 } 02162 // Speed optimization only for FAT16 and FAT32 02163 // init first value used by fat_cluster_readnext() 02164 if( !fat_cluster_val( FS_CLUST_VAL_READ )) 02165 return FALSE; 02166 for( 02167 ; fs_g_cluster.u32_pos < fs_g_nav.u32_CountofCluster 02168 ; fs_g_cluster.u32_pos++ ) 02169 { 02170 if ( 0 == fs_g_cluster.u32_val ) 02171 u32_nb_free_cluster++; 02172 if( !fat_cluster_readnext() ) 02173 return FALSE; 02174 } 02175 #if (FSFEATURE_WRITE_COMPLET == (FS_LEVEL_FEATURES & FSFEATURE_WRITE_COMPLET) ) 02176 if( Is_fat32 ) 02177 { 02178 // Save value for the future call 02179 fat_write_fat32_FSInfo( u32_nb_free_cluster ); 02180 } 02181 #endif 02182 } 02183 endof_fat_getfreespace: 02184 return (u32_nb_free_cluster * fs_g_nav.u8_BPB_SecPerClus); 02185 }
U8 fat_getfreespace_percent | ( | void | ) |
This function returns the space free in percent.
//! More speed than fat_getfreespace() routine but error delta 1% //!
Definition at line 2197 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.
02198 { 02199 U32 u32_nb_free_cluster = 0; 02200 U16 u16_tmp, u16_pos; 02201 02202 if( Is_fat12 ) 02203 { // No speed optimization necessary on FAT12 02204 return (((fat_getfreespace()/fs_g_nav.u8_BPB_SecPerClus)*100) / fs_g_nav.u32_CountofCluster); 02205 } 02206 02207 02208 fs_g_cluster.u32_pos = 2; 02209 // Init first value used by fat_cluster_readnext() 02210 if( !fat_cluster_val( FS_CLUST_VAL_READ )) 02211 return FALSE; 02212 02213 // The optimization is to 02214 // - read only the LSB byte of cluster 02215 // - read only 1 cluster for 2 clusters 02216 if( Is_fat32 ) 02217 { 02218 u32_nb_free_cluster = fat_read_fat32_FSInfo(); 02219 if( 0xFFFFFFFF != u32_nb_free_cluster ) 02220 goto endof_fat_getfreespace_percent; 02221 u32_nb_free_cluster = 0; 02222 02223 u16_pos = 2*4; 02224 for( u16_tmp = fs_g_nav.u16_fat_size 02225 ; u16_tmp!=0 02226 ; u16_tmp-- ) 02227 { 02228 for( ; u16_pos < 512 ; u16_pos += (2*4) ) 02229 { 02230 if( 0 == fs_g_sector[u16_pos] ) 02231 u32_nb_free_cluster+=2; 02232 } 02233 // Read next sector in FAT 02234 u16_pos = 0; 02235 fs_gu32_addrsector++; 02236 if( !fat_cache_read_sector( TRUE )) 02237 return 0; 02238 } 02239 } 02240 02241 if ( Is_fat16 ) 02242 { 02243 u16_pos = 2*2; 02244 02245 for( u16_tmp = fs_g_nav.u16_fat_size 02246 ; u16_tmp!=0 02247 ; u16_tmp-- ) 02248 { 02249 for( ; u16_pos < 512 ; u16_pos += (2*2) ) 02250 { 02251 if( 0 == fs_g_sector[u16_pos] ) 02252 u32_nb_free_cluster+=2; 02253 } 02254 // Read next sector in FAT 02255 u16_pos = 0; 02256 fs_gu32_addrsector++; 02257 if( !fat_cache_read_sector( TRUE )) 02258 return 0; 02259 } 02260 } 02261 02262 // Compute percent 02263 if( u32_nb_free_cluster > fs_g_nav.u32_CountofCluster ) 02264 return 100; 02265 if( u32_nb_free_cluster > ((fs_g_nav.u32_CountofCluster-u32_nb_free_cluster)/256) ) 02266 { 02267 // Compute and add a delta error 02268 u32_nb_free_cluster -= ((fs_g_nav.u32_CountofCluster-u32_nb_free_cluster)/256); 02269 } 02270 endof_fat_getfreespace_percent: 02271 return ((u32_nb_free_cluster * 100) / fs_g_nav.u32_CountofCluster); 02272 }