/*FUNCTION*-------------------------------------------------------------------
*
* Function Name : MFS_Read_data_sector
* Returned Value : error_code
* Comments :
* Readsone sector into the DATA_SECTOR buffer
*END*---------------------------------------------------------------------*/
_mfs_error MFS_Read_data_sector
(
MFS_DRIVE_STRUCT_PTR drive_ptr,
MFS_HANDLE_PTR handle, /*[IN] handle of the file for which we are doing the read/write */
uint_32 sector_number, /*[IN] sector number to read/write from/to file system medium */
boolean hw_read /*[IN] if read of a sector is needed or just validation of a new one */
)
{
_mfs_error error;
error = MFS_NO_ERROR;
if ( sector_number != drive_ptr->DATA_SECTOR_NUMBER )
{
MFS_Flush_data_sector_buffer(drive_ptr);
MFS_Invalidate_data_sector(drive_ptr);
if (hw_read)
{
error = MFS_Read_device_sector(drive_ptr,sector_number,drive_ptr->DATA_SECTOR_PTR);
}
else
{
error = MFS_NO_ERROR;
}
if ( error == MFS_NO_ERROR )
{
drive_ptr->DATA_SECTOR_NUMBER = sector_number;
}
}
return(error);
}
pointer MFS_Read_directory_sector
(
MFS_DRIVE_STRUCT_PTR drive_ptr,
uint_32 cluster, /*[IN] number of the cluster containing the sector to be read */
uint_16 sector, /*[IN] index of the sector within the cluster */
_mfs_error_ptr error_ptr
)
{
uint_32 abs_sector;
if ( cluster == 0 )
{
/*
** Reading the root directory
*/
abs_sector = drive_ptr->ROOT_START_SECTOR+sector;
/*
** Overflow...
*/
if ( abs_sector >= drive_ptr->DATA_START_SECTOR )
{
*error_ptr = MFS_Flush_directory_sector_buffer(drive_ptr);
drive_ptr->DIR_SECTOR_NUMBER = 0;
return(NULL);
}
}
else
{
abs_sector = CLUSTER_TO_SECTOR(cluster) + sector;
}
if ( abs_sector > drive_ptr->BPB.MEGA_SECTORS )
{
*error_ptr = MFS_Flush_directory_sector_buffer(drive_ptr);
return(NULL);
}
if ( abs_sector != drive_ptr->DIR_SECTOR_NUMBER )
{
*error_ptr = MFS_Flush_directory_sector_buffer(drive_ptr);
if ( *error_ptr )
{
return(NULL);
}
*error_ptr = MFS_Read_device_sector(drive_ptr, abs_sector, drive_ptr->DIR_SECTOR_PTR);
if ( *error_ptr )
{
MFS_Invalidate_directory_sector(drive_ptr);
return( NULL );
}
drive_ptr->DIR_SECTOR_NUMBER = abs_sector;
}
else
{
*error_ptr = MFS_NO_ERROR;
}
return(drive_ptr->DIR_SECTOR_PTR);
}
_mfs_error MFS_Read_fat
(
MFS_DRIVE_STRUCT_PTR drive_ptr,
uint_32 offset /*[IN] the offset byte in the FAT that we are looking for */
)
{
uint_32 needed_sector,needed_end_sector,i;
_mfs_error error_code;
error_code = MFS_NO_ERROR;
needed_sector = offset / drive_ptr->BPB.SECTOR_SIZE;
MFS_LOG(printf("\nRead fat: Offset = %d\n", offset));
if ( drive_ptr->FAT_TYPE == MFS_FAT12 )
{
needed_end_sector = (offset+1)/ drive_ptr->BPB.SECTOR_SIZE;
}
else
{
needed_end_sector = needed_sector;
}
/*
** If the FAT fragment that we already have in memory is requested, do
** not update or re-read it.
*/
if ( (needed_sector < drive_ptr->FAT_CACHE_START) || (needed_end_sector > drive_ptr->FAT_CACHE_START + drive_ptr->FAT_CACHE_SIZE - 1) )
{
error_code = MFS_Flush_fat_cache(drive_ptr);
if ( error_code )
{
return(error_code);
}
if ( drive_ptr->FAT_TYPE == MFS_FAT32 )
{
if ( needed_sector > (drive_ptr->BPB32.FAT_SIZE - drive_ptr->FAT_CACHE_SIZE) )
{
needed_sector = drive_ptr->BPB32.FAT_SIZE - drive_ptr->FAT_CACHE_SIZE;
}
}
else
{
if ( needed_sector > (drive_ptr->BPB.SECTORS_PER_FAT - drive_ptr->FAT_CACHE_SIZE) )
{
needed_sector = drive_ptr->BPB.SECTORS_PER_FAT - drive_ptr->FAT_CACHE_SIZE;
}
}
for ( i=0;i<(drive_ptr->FAT_CACHE_SIZE) && (error_code==MFS_NO_ERROR);i++ )
{
error_code = MFS_Read_device_sector (drive_ptr, drive_ptr->FAT_START_SECTOR + needed_sector + i,
(pointer) &drive_ptr->FAT_CACHE_PTR[drive_ptr->BPB.SECTOR_SIZE*i]);
}
if ( error_code == MFS_NO_ERROR )
{
drive_ptr->FAT_CACHE_START = needed_sector;
drive_ptr->FAT_CACHE_DIRTY = FALSE;
}
}
return(error_code);
}
int_32 MFS_Open_Device
(
MQX_FILE_PTR fd_ptr, /* [IN] the MFS file handle for the device being opened */
MFS_DRIVE_STRUCT_PTR drive_ptr
)
{
MQX_FILE_PTR dev_fd;
uint_32 sector_size, k;
int_32 error_code;
dev_fd = drive_ptr->DEV_FILE_PTR;
fd_ptr->DEV_DATA_PTR = NULL;
drive_ptr->MFS_FILE_PTR = fd_ptr;
/* Select partition, if desired */
if (drive_ptr->DRV_NUM)
{
error_code = ioctl(dev_fd, IO_IOCTL_SEL_PART, &drive_ptr->DRV_NUM);
if (error_code)
{
return error_code;
}
}
/*
** obtain the buffer for configuration data and for storing general
** sector reads
*/
error_code = _mfs_validate_device(dev_fd, §or_size, &drive_ptr->BLOCK_MODE);
if ( error_code )
{
/* Device isn't valid */
drive_ptr->MFS_FILE_PTR = NULL;
return error_code;
}
_lwsem_wait(&drive_ptr->SEM);
drive_ptr->BPB.SECTOR_SIZE = (uint_16) sector_size;
drive_ptr->DIR_SECTOR_PTR = MFS_mem_alloc_system_zero(sector_size);
MFS_Invalidate_directory_sector(drive_ptr);
if ( drive_ptr->DIR_SECTOR_PTR == NULL )
{
_lwsem_post(&drive_ptr->SEM);
drive_ptr->MFS_FILE_PTR = NULL;
return MFS_INSUFFICIENT_MEMORY;
}
_mem_set_type(drive_ptr->DIR_SECTOR_PTR, MEM_TYPE_MFS_DIRECTORY_SECTOR);
_queue_init(&drive_ptr->HANDLE_LIST, 0);
k = drive_ptr->BPB.SECTOR_SIZE;
for ( drive_ptr->SECTOR_POWER = 0; !(k & 1);
drive_ptr->SECTOR_POWER++ )
{
k>>=1;
}
/*
** read boot sector and get the BIOS Parameter Block
*/
error_code = MFS_Read_device_sector(drive_ptr, BOOT_SECTOR, drive_ptr->DIR_SECTOR_PTR);
if ( error_code == MFS_NO_ERROR )
{
drive_ptr->DIR_SECTOR_NUMBER = BOOT_SECTOR;
error_code = MFS_Mount_drive_internal(drive_ptr);
}
if ( !error_code )
{
/* Determine the real sector size */
if ( sector_size != drive_ptr->BPB.SECTOR_SIZE )
{
_mem_free(drive_ptr->DIR_SECTOR_PTR);
drive_ptr->DIR_SECTOR_PTR = MFS_mem_alloc_system_zero(drive_ptr->BPB.SECTOR_SIZE);
MFS_Invalidate_directory_sector(drive_ptr);
if ( drive_ptr->DIR_SECTOR_PTR == NULL )
{
error_code = MFS_INSUFFICIENT_MEMORY;
drive_ptr->MFS_FILE_PTR = NULL;
}
else
{
_mem_set_type(drive_ptr->DIR_SECTOR_PTR, MEM_TYPE_MFS_DIRECTORY_SECTOR);
}
}
/* Calculate the free space on disk */
#if MFSCFG_CALCULATE_FREE_SPACE_ON_OPEN
if ( !error_code )
{
MFS_Get_disk_free_space_internal(drive_ptr,(uint_32_ptr)&error_code);
}
#endif
}
else {
printf(" open fs read secotor err+\n");
drive_ptr->MFS_FILE_PTR = NULL;
if(drive_ptr->DIR_SECTOR_PTR) {
_mem_free(drive_ptr->DIR_SECTOR_PTR);
drive_ptr->DIR_SECTOR_PTR = NULL;
}
printf(" open fs read secotor err+\n");
}
_lwsem_post(&drive_ptr->SEM);
return(error_code);
}
