fat.c

MP3播放器详细设计方案

/*C**************************************************************************
* $RCSfile: fat.c,v $
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      $Name: DEMO_FAT_1_9_9 $      
* REVISION:     $Revision: 1.15 $     
* FILE_CVSID:   $Id: fat.c,v 1.15 2002/09/06 12:59:09 njourdan Exp $       
*----------------------------------------------------------------------------
* PURPOSE:
* FAT16/FAT12 file-system basics functions
* 
* NOTES:
* Supports only the first partition
* Supports only 512 bytes sector size
* Supports only file fragmentation < MAX_FILE_FRAGMENT_NUMBER
* Supports only one file openned at a time
*
* Global Variables:
*   - gl_buffer: array of bytes in pdata space
*****************************************************************************/

/*_____ I N C L U D E S ____________________________________________________*/

#include "config.h"                         /* system configuration */
#include "..\mem\hard.h"                    /* low level function definition */
#include "file.h"                           /* file function definition */
#include "fat.h"                            /* fat file-system definition */


/*_____ M A C R O S ________________________________________________________*/


/*_____ D E F I N I T I O N ________________________________________________*/

extern  pdata Byte    gl_buffer[];

char    pdata *lfn_name = &(gl_buffer[32]); /* long filename limited to MAX_FILENAME_LEN chars */

/* disk management */
static  data  Uint32  fat_ptr_fats;         /* address of the first byte of FAT */
static  data  Uint32  fat_ptr_rdir;         /* address of the first byte of root dir */
static  data  Uint32  fat_ptr_data;         /* address of the first byte of data */
static  data  Byte    fat_cluster_size;     /* cluster size (sector count) */
static  data  Byte    fat_cluster_mask;     /* mask for end of cluster test */

static  bdata bit     dir_is_root;          /* TRUE: point the root directory  */
static  bdata bit     fat_is_fat16;         /* TRUE: FAT16 - FALSE: FAT12 */
static  bdata bit     fat_open_mode;        /* READ or WRITE */
static  bdata bit     fat_2_is_present;     /* TRUE: 2 FATs - FALSE: 1 FAT */
static  bdata bit     flag_end_disk_file;

#define fat_buf_sector  fat_dir_entry_list  /* manual variable overlay */

static  xdata Uint16  fat_count_of_clusters;/* number of cluster - 2 */
static  xdata Uint16  fat_root_entry;       /* position in root dir */
static  xdata Union32 fat_file_size;
static  xdata Uint16  fat_fat_size;         /* FAT size in sector count */


/* directory management */
static  xdata fat_st_clust_chain dclusters[MAX_DIR_FRAGMENT_NUMBER];
                                            /* cluster chain for the current directory */
static  xdata Uint16  fat_dclust_byte_count;/* byte counter in directory sector */

static  idata Uint16  fat_dchain_index;     /* the number of the fragment of the dir, in fact
                                               the index of the table in the cluster chain */
static  idata Byte    fat_dchain_nb_clust;  /* the offset of the cluster from the first cluster
                                               of the dir fragment */

static  xdata Byte    fat_dir_entry_list[MAX_DIRECTORY_FILE]; /* list of relative entries position */
static  idata Uint16  fat_dir_list_index;   /* index of current entry in dir list */
static  xdata Uint16  fat_dir_list_last;    /* index of last entry in dir list */
static  xdata Uint32  fat_dir_start_sect;   /* start sector of dir list */
static  xdata Uint32  fat_dir_current_sect; /* sector of selected entry in dir list */
static  xdata Uint16  fat_dir_current_offs; /* entry offset from fat_dir_current_sect */

static  xdata fat_st_cache   fat_cache;     /* The cache structure, see the .h for more info */
static  xdata char  ext[3];                 /* file extension (limited to 3 characters) */


/* file management */
static  xdata fat_st_clust_chain fclusters[MAX_FILE_FRAGMENT_NUMBER];
                                            /* cluster chain for the current file */
static  data  Byte    fat_last_clust_index; /* index of the last cluster in file chain */

static  data  Uint16  fat_fclust_byte_count;/* byte counter in file cluster */

static  data  Byte    fat_fchain_index;     /* the number of the fragment of the file, in fact
                                               the index of the table in the cluster chain */
              
static  data  Byte    fat_fchain_nb_clust;  /* the offset of the cluster from the first cluster
                                               of the file fragment */

static xdata  Uint32  fat_current_file_size;

/*_____ D E C L A R A T I O N ______________________________________________*/

static  void    fat_get_dir_entry (fat_st_dir_entry xdata *);
static  void    fat_get_dir_file_list (Byte);
static  bit     fat_get_clusters (fat_st_clust_chain xdata *, Byte);
static  bit     fat_set_clusters (void);
static  bit     fat_dopen (void);
static  bit     fat_dseek (Int16);
static  Byte    fat_dgetc (void);


/*F**************************************************************************
* NAME: fat_install
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   - OK: intallation succeeded
*   - KO: - partition 1 not active
*         - FAT type is not FAT16
*         - sector size is not 512 bytes
*         - MBR or PBR signatures are not correct
*         - low level read open failure
*----------------------------------------------------------------------------
* PURPOSE:
*   Install the fat system, read mbr, bootrecords...
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   if MBR not found, try to mount unpartitionned FAT
*   sector size is fixed to 512 bytes to simplify low level drivers
*   fat_ptr_fats = partition offset + nb_reserved_sector
*   fat_ptr_rdir = fat_ptr_fat + fat_size * nb_fat
*   fat_ptr_data = fat_ptr_rdir + nb_root_entries * 32 / 512
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit fat_install (void)
{          
Byte i;
Uint32 tot_sect;
Uint32 fat_nb_sector;
Uint16 fat_size;                            /* local copy in data segment */

  /* read and check usefull MBR info */
  /* go to the first partition field */
  if (Hard_read_open(MBR_ADDRESS) == OK) 
  {
    for (i = 446/2; i != 0; i--)
    {
      Hard_read_byte();                     /* go to first partition entry */
      Hard_read_byte();
    }
    /* check first partition state */
    if (Hard_read_byte() != PARTITION_ACTIVE)
    {
      Hard_read_close();                    /* close physical read */
      fat_ptr_fats = 0x00000000;            /* disk may not be partitionned */
    }
    else
    {
      Hard_read_byte();                     /* dummy reads */
      Hard_read_byte();
      Hard_read_byte();
      Hard_read_byte();
      Hard_read_byte();
      Hard_read_byte();
      Hard_read_byte();
      /* read partition offset (in sectors) at offset 8 */
      ((Byte*)&fat_ptr_fats)[3] = Hard_read_byte();
      ((Byte*)&fat_ptr_fats)[2] = Hard_read_byte();
      ((Byte*)&fat_ptr_fats)[1] = Hard_read_byte();
      ((Byte*)&fat_ptr_fats)[0] = Hard_read_byte();
      /* go to the MBR signature field */
      for (i = 52; i != 0; i--)
      {
        Hard_read_byte();                   /* dummy reads */
      }
      /* check MBR signature */
      if ((Hard_read_byte() != LOW(BR_SIGNATURE)) &&
          (Hard_read_byte() != HIGH(BR_SIGNATURE)))
      {
        fat_ptr_fats = 0x00000000;          /* disk may not be partitionned */
      }
      Hard_read_close();                    /* close physical read */
    }
  }
  else
  { /* low level error */
    return KO;
  }

  /* read and check usefull PBR info */
  if (Hard_read_open(fat_ptr_fats) == OK) 
  {
    /* go to sector size field */
    for (i = 11; i != 0; i--)
    {
      Hard_read_byte();                     /* dummy reads */
    }
    /* read sector size (in bytes) */
    if ((Hard_read_byte() != LOW(SECTOR_SIZE)) ||
        (Hard_read_byte() != HIGH(SECTOR_SIZE)))
    {
      Hard_read_close();                    /* close physical read */
      return KO;
    }
    /* read cluster size (in sector) */
    fat_cluster_size = Hard_read_byte();
    fat_cluster_mask = HIGH((Uint16)fat_cluster_size * SECTOR_SIZE) - 1;
    /* compute FATs sector address: add reserved sector number */
    fat_ptr_fats += Hard_read_byte();
    fat_ptr_fats += (Uint16)Hard_read_byte() << 8;
    /* read number of FATs */
    i = Hard_read_byte();
    if (i == 2)
      fat_2_is_present = TRUE;
    else
      fat_2_is_present = FALSE;
    /* read number of dir entries  and compute rdir offset */
    ((Byte*)&fat_ptr_data)[3] = Hard_read_byte();
    ((Byte*)&fat_ptr_data)[2] = Hard_read_byte();
    ((Byte*)&fat_ptr_data)[1] = 0;
    ((Byte*)&fat_ptr_data)[0] = 0;
    fat_ptr_data = (fat_ptr_data * DIR_SIZE) / SECTOR_SIZE;
    /* read number of sector in partition (<32Mb) */
    ((Byte*)&fat_nb_sector)[3] = Hard_read_byte();
    ((Byte*)&fat_nb_sector)[2] = Hard_read_byte();
    ((Byte*)&fat_nb_sector)[1] = 0x00;
    ((Byte*)&fat_nb_sector)[0] = 0x00;
    Hard_read_byte();
    /* compute root directory sector address */
    ((Byte*)&fat_size)[1] = Hard_read_byte();
    ((Byte*)&fat_size)[0] = Hard_read_byte();
    
    fat_ptr_rdir = i * fat_size;
    fat_ptr_rdir += fat_ptr_fats;
    fat_fat_size = fat_size;                /* save fat size for FAT update */

    Hard_read_byte();
    Hard_read_byte();
    Hard_read_byte();
    Hard_read_byte();
    Hard_read_byte();
    Hard_read_byte();
    Hard_read_byte();
    Hard_read_byte();

    /* read number of sector in partition (>32Mb) */
    ((Byte*)&fat_nb_sector)[3] += Hard_read_byte();
    ((Byte*)&fat_nb_sector)[2] += Hard_read_byte();
    ((Byte*)&fat_nb_sector)[1] += Hard_read_byte();
    ((Byte*)&fat_nb_sector)[0] += Hard_read_byte();

    tot_sect = fat_nb_sector - (1 + (i * fat_fat_size) + fat_ptr_data);
    fat_count_of_clusters = tot_sect / fat_cluster_size;
    if (fat_count_of_clusters <= MAX_CLUSTERS12)
      fat_is_fat16 = FALSE;
    else
      if (fat_count_of_clusters <= MAX_CLUSTERS16)
        fat_is_fat16 = TRUE;
      /* else is FAT32 not supported */

    /* compute data sector address */
    fat_ptr_data += fat_ptr_rdir;
    /* go to the signature field */
    for (i = 237; i != 0; i--)
    {
      Hard_read_byte();                     /* dummy reads */
      Hard_read_byte();
    }
    /* check partition signature */
    if ((Hard_read_byte() != LOW(BR_SIGNATURE)) &&
        (Hard_read_byte() != HIGH(BR_SIGNATURE)))
    {
      Hard_read_close();                    /* close physical read */
      return KO;
    }
    Hard_read_close();                      /* close physical read */
    return OK;
  }
  else
  { /* low level error */
    return KO;
  }
}


/*F**************************************************************************
* NAME: fat_get_dir_entry
*----------------------------------------------------------------------------
* PARAMS:
*   entry: directory entry structure
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   Get from directory all information about a directory or file entry
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   This function reads directly datas from sectors
*   It automaticaly computes difference between LFN and normal entries
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void fat_get_dir_entry (fat_st_dir_entry xdata *entry)
{
bit     exit_flag = FALSE;
bit     lfn_entry_found = FALSE;
Byte    i;

  /* clear the name buffer */
  for (i = MAX_FILENAME_LEN; i != 0; lfn_name[--i] = '\0');

  while (!exit_flag)
  /* loop while the entry is not a normal one. */
  {
    /* read the directory entry */
    if (dir_is_root == TRUE)
    { /* root dir is linear -> Hard_read_byte() */
      for (i = 0; i < DIR_SIZE; i++)
        gl_buffer[i] = Hard_read_byte();
    }
    else
    { /* subdir can be fragmented -> dgetc() */
      for (i = 0; i < DIR_SIZE; i++)
        gl_buffer[i] = fat_dgetc();
    }

    /*computes gathered data
    /* check if we have a LFN entry */
    if (gl_buffer[11] != ATTR_LFN_ENTRY)
    {
      if (!lfn_entry_found)
      {
        /* true DOS 8.3 entry format */
        for (i = 0; i < 8; i++)
        {
          lfn_name[i] = gl_buffer[i];
          
          if (lfn_name[i] == ' ')
          { /* space is end of name */
            break;
          }
        }
        /* append extension */
        lfn_name[i++] = '.';
        lfn_name[i++] = gl_buffer[8];
        lfn_name[i++] = gl_buffer[9];
        lfn_name[i++] = gl_buffer[10];

        for (; i != 14; i++)
        {
          lfn_name[i] = ' ';       /* append spaces for display reason */
        }
        lfn_name[i] = '\0';        /* end of string */
      }
        
      else
      { /* LFN name treatment */
        i = 0;
        /* search for the end of the string */
        while (lfn_name[i] != '\0')
        { 
          i++;
        }
        if (i <= 14)
        { /* append spaces for display reason (no scrolling) */
          while (i != 14)
          {
            lfn_name[i++] = ' ';
          }
        }
        else
        { /* append beginning of name to ease scrolling display */
          lfn_name[i++] = ' ';
          lfn_name[i++] = ' ';
          lfn_name[i++] = lfn_name[0];
          lfn_name[i++] = lfn_name[1];
          lfn_name[i++] = lfn_name[2];
          lfn_name[i++] = lfn_name[3];
          lfn_name[i++] = lfn_name[4];
          lfn_name[i++] = lfn_name[5];
          lfn_name[i++] = lfn_name[6];
          lfn_name[i++] = lfn_name[7];
          lfn_name[i++] = lfn_name[8];