fs_writefat.c

這是一個實時嵌入式作業系統 實作了MCS51 ARM等MCU

 * Input:
 *    fmt  - User specified format parameters
 *    var  - Other format parameters that are not user specifiable
 *    sectno - On FAT32, the root directory is a cluster chain.
 *        This value indicates which sector of the cluster should be produced.
 *
 * Return:
 *    None; caller is responsible for providing valid parameters.
 *
 ****************************************************************************/
static inline void mkfatfs_initrootdir(FAR struct fat_format_s *fmt,
                                       FAR struct fat_var_s *var, int sectno)
{
  memset(var->fv_sect, 0, var->fv_sectorsize);
  if (sectno == 0)
    {
      /* It is only necessary to set data in the first sector of the directory */
      
      if (memcmp(fmt->ff_volumelabel, "           ", 11))
        {
          memcpy(&var->fv_sect[DIR_NAME], fmt->ff_volumelabel, 11);
        }

      DIR_PUTATTRIBUTES(var->fv_sect, FATATTR_VOLUMEID);
      DIR_PUTCRTIME(var->fv_sect, var->fv_createtime & 0xffff);
      DIR_PUTWRTTIME(var->fv_sect, var->fv_createtime & 0xffff);
      DIR_PUTCRDATE(var->fv_sect, var->fv_createtime >> 16);
      DIR_PUTWRTDATE(var->fv_sect, var->fv_createtime >> 16);
    }
}

/****************************************************************************
 * Name: mkfatfs_writembr
 *
 * Description:
 *   Write the master boot record and, for FAT32, the backup boot record and
 *   the fsinfo sector.
 *
 * Input:
 *    fmt  - User specified format parameters
 *    var  - Other format parameters that are not user specifiable
 *
 * Return:
 *    Zero on success; negated errno on failure
 *
 ****************************************************************************/
static inline int mkfatfs_writembr(FAR struct fat_format_s *fmt,
                                   FAR struct fat_var_s *var)
{
  int sectno;
  int ret;

  /* Create an image of the configured master boot record */

  mkfatfs_initmbr(fmt, var);

  /* Write the master boot record as sector zero */

  ret = DEV_WRITE(var->fv_sect, 0, 1);

  /* Write all of the reserved sectors */

  memset(var->fv_sect, 0, var->fv_sectorsize);
 for (sectno = 1; sectno < fmt->ff_rsvdseccount && ret >= 0; sectno++)
    {
      ret = DEV_WRITE(var->fv_sect, sectno, 1);
    }
 
  /* Write FAT32-specific sectors */

  if (ret >= 0 && fmt->ff_fattype == 32)
    {
      /* Write the backup master boot record */

      if (fmt->ff_backupboot != 0)
        {
          /* Create another copy of the configured master boot record */

          mkfatfs_initmbr(fmt, var);

          /* Write it to the backup location */

          ret = DEV_WRITE(var->fv_sect, fmt->ff_backupboot, 1);
        }

      if (ret >= 0)
        {
          /* Create an image of the fsinfo sector*/

          mkfatfs_initfsinfo(fmt, var);

          /* Write the fsinfo sector */

          ret = DEV_WRITE(var->fv_sect, FAT_DEFAULT_FSINFO_SECTOR, 1);
        }
    }

  return ret;
}

/****************************************************************************
 * Name: mkfatfs_writefat
 *
 * Description:
 *   Write the FAT sectors
 *
 * Input:
 *    fmt  - User specified format parameters
 *    var  - Other format parameters that are not user specifiable
 *
 * Return:
 *    Zero on success; negated errno on failure
 *
 ****************************************************************************/
static inline int mkfatfs_writefat(FAR struct fat_format_s *fmt,
                                   FAR struct fat_var_s *var)
{
  size_t offset = fmt->ff_rsvdseccount;
  int fatno;
  int sectno;
  int ret;

  /* Loop for each FAT copy */

  for (fatno = 0; fatno < fmt->ff_nfats; fatno++)
    {
      /* Loop for each sector in the FAT */

       for (sectno = 0; sectno < var->fv_nfatsects; sectno++)
         {
           memset(var->fv_sect, 0, var->fv_sectorsize);

          /* Mark cluster allocations in sector one of each FAT */

           if (sectno == 0)
             {
               memset(var->fv_sect, 0, var->fv_sectorsize);
               switch(fmt->ff_fattype)
                 {
                   case 12:
                     /* Mark the first two full FAT entries -- 24 bits, 3 bytes total */

                     memset(var->fv_sect, 0xff, 3);
                     break;

                   case 16:
                     /* Mark the first two full FAT entries -- 32 bits, 4 bytes total */

                     memset(var->fv_sect, 0xff, 4);
                     break;

                   case 32:
                   default: /* Shouldn't happen */
                     /* Mark the first two full FAT entries -- 64 bits, 8 bytes total */

                     memset(var->fv_sect, 0xff, 8);

                     /* Cluster 2 is used as the root directory.  Mark as EOF */

                     var->fv_sect[8] =  0xf8;
                     memset(&var->fv_sect[9], 0xff, 3);
                     break;
                 }

               /* Save the media type in the first byte of the FAT */

               var->fv_sect[0] = FAT_DEFAULT_MEDIA_TYPE;
            }

           /* Write the FAT sector */

           ret = DEV_WRITE(var->fv_sect, offset, 1);
           if (ret < 0)
             {
               return ret;
             }
           offset++;
         }
     }
   return OK;
}

/****************************************************************************
 * Name: mkfatfs_writerootdir
 *
 * Description:
 *   Write the root directory sectors
 *
 * Input:
 *    fmt  - User specified format parameters
 *    var  - Other format parameters that are not user specifiable
 *
 * Return:
 *    Zero on success; negated errno on failure
 *
 ****************************************************************************/
static inline int mkfatfs_writerootdir(FAR struct fat_format_s *fmt,
                                       FAR struct fat_var_s *var)
{
  size_t offset = fmt->ff_rsvdseccount + fmt->ff_nfats * var->fv_nfatsects;
  int ret;
  int i;

  /* Write the root directory after the last FAT. This is the root directory
   * area for FAT12/16, and the first cluster on FAT32.
   */

  for (i = 0; i < var->fv_nrootdirsects; i++)
    {
      /* Format the next sector of the root directory */

      mkfatfs_initrootdir(fmt, var, i);

      /* Write the next sector of the root directory */

      ret = DEV_WRITE(var->fv_sect, offset, 1);
      if (ret < 0)
        {
          return ret;
        }
      offset++;
    }
  return 0;
}

/****************************************************************************
 * Global Functions
 ****************************************************************************/

/****************************************************************************
 * Name: mkfatfs_writefat
 *
 * Description:
 *   Write the configured fat filesystem to the block device
 *
 * Input:
 *    fmt  - Caller specified format parameters
 *    var  - Other format parameters that are not caller specifiable. (Most
 *           set by mkfatfs_configfatfs()).
 *
 * Return:
 *    Zero on success; negated errno on failure
 *
 ****************************************************************************/
int mkfatfs_writefatfs(FAR struct fat_format_s *fmt,
                       FAR struct fat_var_s *var)
{
  int ret;

  /* Write the master boot record (also the backup and fsinfo sectors) */

  ret = mkfatfs_writembr(fmt, var);

  /* Write FATs */

  if (ret >= 0)
    {
      ret = mkfatfs_writefat(fmt, var);
    }

  /* Write the root directory after the last FAT. */

  if (ret >= 0)
    {
      ret = mkfatfs_writerootdir(fmt, var);
    }
  return ret;
}