/*C**************************************************************************
* NAME:         fat.c
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-demo-hdd-0_2_0      
* REVISION:     1.1     
*----------------------------------------------------------------------------
* PURPOSE:
* FAT32 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 */

xdata Byte fat_buf_sector[MAX_DIRECTORY_FILE]; /* 512 bytes buffer */

/* disk management */
static  data  Uint32  fat_ptr_fats;         /* address of the first byte of FAT */
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_is_fat32;         /* TRUE: FAT32 - FALSE: FAT12/FAT16 */
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;

static  xdata Uint32  fat_count_of_clusters;/* number of cluster - 2 */
static  xdata Union32 fat_file_size;
static  xdata Uint32  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  idata 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_last_dclust_index;/* index of the last cluster in directory chain */

static  idata Uint16  fat_dir_list_index;   /* index of current entry in dir list */
static  idata 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  idata Uint32  fat_dir_current_sect; /* sector of selected entry in dir list */
static  xdata Uint32  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  idata  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  idata  Byte    fat_fchain_index;     /* the number of the fragment of the file, in fact
                                               the index of the table in the cluster chain */
              
static  idata  Uint16  fat_fchain_nb_clust;  /* the offset of the cluster from the first cluster
                                               of the file fragment */

static xdata  Uint32  fat_current_file_size;
static xdata  Uint32  fat_rootclus_fat32;                  /* root cluster address */
static bdata bit fat_last_dir_cluster_full;
static bdata bit fat_no_entries_free;
static xdata Uint16 fat_total_clusters;
static xdata Uint32 last_free_cluster;

/* Mode repeat A/B variables */
static xdata  Byte    fat_fchain_index_save;         
static xdata  Byte    fat_fchain_nb_clust_save;
static xdata  Uint16  fat_fclust_byte_count_save;

xdata Byte current_ext;

idata Uint16 fat_current_end_entry_position;
idata Uint16 fat_current_start_entry_position;
xdata Uint16 fat_nb_deleted_entries;
xdata Uint16 fat_nb_total_entries;


/*_____ 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_get_free_clusters (bit);
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
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit fat_install (void)
{          
Byte i;
Uint32 tot_sect;
Uint32 fat_nb_sector;
Uint16 bpb_rsvd_sec_cnt;
Byte bpb_num_fat;
Uint16 bpb_root_ent_count;

  Hard_read_open(MBR_ADDRESS);
  Hard_load_sector();
  Hard_read_close();

  /* 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;
  }

  Hard_read_open(MBR_ADDRESS);
  Hard_load_sector();
  Hard_read_close();

  /* 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;
    /* reserved sector number */
    ((Byte*)&bpb_rsvd_sec_cnt)[1] = Hard_read_byte();
    ((Byte*)&bpb_rsvd_sec_cnt)[0] = Hard_read_byte();
    /* number of FATs */
    bpb_num_fat = Hard_read_byte();
    if (bpb_num_fat == 2)
      fat_2_is_present = TRUE;
    else
      fat_2_is_present = FALSE;    
    
    /* read number of dir entries*/
    ((Byte*)&bpb_root_ent_count)[3] = Hard_read_byte();
    ((Byte*)&bpb_root_ent_count)[2] = 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] = 0x00;
    ((Byte*)&fat_nb_sector)[0] = 0x00;
    Hard_read_byte();
    Hard_read_byte();                               /* FAT size for FAT12/16 */
    Hard_read_byte();
    
    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();

    fat_is_fat16 = FALSE;
    fat_is_fat32 = FALSE;

    fat_ptr_data = (bpb_root_ent_count * DIR_SIZE) / SECTOR_SIZE;

    /* Here start the structure for FAT32 */
    /* Offset 36 : 32 bits size of fat */
    ((Byte*)&fat_fat_size)[3] = Hard_read_byte();
    ((Byte*)&fat_fat_size)[2] = Hard_read_byte();
    ((Byte*)&fat_fat_size)[1] = Hard_read_byte();
    ((Byte*)&fat_fat_size)[0] = Hard_read_byte();

    tot_sect = fat_nb_sector - (Uint32)(((Uint32)(bpb_rsvd_sec_cnt) + (Uint32)((bpb_num_fat * (Uint32)(fat_fat_size))) + fat_ptr_data));
    fat_count_of_clusters = tot_sect / fat_cluster_size;
       
    /* Offset 40 : ExtFlags */
    Hard_read_byte();
    Hard_read_byte();
    /* Offset 42 : FS Version */
    Hard_read_byte();
    Hard_read_byte();
    /* Offset 44 : Root Cluster */
    ((Byte*)&fat_rootclus_fat32)[3] = Hard_read_byte();
    ((Byte*)&fat_rootclus_fat32)[2] = Hard_read_byte();
    ((Byte*)&fat_rootclus_fat32)[1] = Hard_read_byte();
    ((Byte*)&fat_rootclus_fat32)[0] = Hard_read_byte();

    fat_ptr_fats += bpb_rsvd_sec_cnt;
    fat_ptr_data = fat_ptr_fats + (bpb_num_fat * fat_fat_size);

    /* Offset 48 : FS Info */
    /* Offset 50 : Backup Boot Sector */
    /* Offset 52 : Reserved */
    /* Offset 64 - 89 : Data */
    /* Offset 90 : 510 : Free */
    for (i = 231; i != 0; i--)
    {
      Hard_read_byte();
      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;
  }
}

#define UPLOAD      0
#define DOWNLOAD    1
#define FETCH_NEXT  0
#define FETCH_PREV  1

/*F**************************************************************************
* NAME: fat_calc_cluster
*----------------------------------------------------------------------------
* PARAMS:
*   
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   Calculate fat_dir_current_sect and update directory variable from the
*   value of fat_dir_current_offs.
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   
*----------------------------------------------------------------------------
* REQUIREMENTS:
*   
*****************************************************************************/
void fat_calc_cluster(void)
{
Uint32   i;
  fat_dchain_index = 0;
  fat_dchain_nb_clust = 0;
  for (i = (fat_dir_current_offs / SECTOR_SIZE / fat_cluster_size) + 1; i != 0; i--)
  {
    if (dclusters[fat_dchain_index].number == fat_dchain_nb_clust)
    { /* new fragment */
      fat_dchain_index++;
      fat_dchain_nb_clust = 1;
    }
    else
    { /* no new fragment */
      fat_dchain_nb_clust++;