Move FAT-related files to fs/fat

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@798 42af7a65-404d-4744-a932-0658087f49c3

8 files changed, 15 insertions, 5437 deletions

diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog
index be4610ec0..ce39a4c14 100644
--- a/nuttx/ChangeLog
+++ b/nuttx/ChangeLog
@@ -386,4 +386,5 @@
 	* Same issue on closing file descriptors in exit()
 	* Fixed in error in stdio flush logic.  Needed ssize_t vs size_t for error
 	  check.
+	* Moved all FAT related files from fs to fs/fat
 
diff --git a/nuttx/Documentation/NuttX.html b/nuttx/Documentation/NuttX.html
index e75d27e30..84a8926af 100644
--- a/nuttx/Documentation/NuttX.html
+++ b/nuttx/Documentation/NuttX.html
@@ -8,7 +8,7 @@
   <tr align="center" bgcolor="#e4e4e4">
     <td>
       <h1><big><font color="#3c34ec"><i>NuttX RTOS</i></font></big></h1>
-      <p>Last Updated: July 30, 2008</p>
+      <p>Last Updated: August 2, 2008</p>
     </td>
   </tr>
 </table>
@@ -1035,6 +1035,7 @@ nuttx-0.3.12 2008-xx-xx Gregory Nutt &lt;spudmonkey@racsa.co.cr&gt;
 	* Same issue on closing file descriptors in exit()
 	* Fixed in error in stdio flush logic.  Needed ssize_t vs size_t for error
 	  check.
+	* Moved all FAT related files from fs to fs/fat
 
 pascal-0.1.3 2008-xx-xx Gregory Nutt &lt;spudmonkey@racsa.co.cr&gt;
 
diff --git a/nuttx/fs/Makefile b/nuttx/fs/Makefile
index c14128276..14a618803 100644
--- a/nuttx/fs/Makefile
+++ b/nuttx/fs/Makefile
@@ -56,10 +56,7 @@ CSRCS		+= fs_registerblockdriver.c fs_unregisterblockdriver.c \
 		   fs_mount.c fs_umount.c \
 		   fs_fsync.c fs_unlink.c fs_rename.c \
 		   fs_mkdir.c fs_rmdir.c
-
-ifeq ($(CONFIG_FS_FAT),y)
-CSRCS		+= fs_fat32.c fs_fat32util.c fs_fat32attrib.c
-endif
+include fat/Make.defs
 endif
 endif
 
@@ -70,6 +67,9 @@ OBJS		= $(AOBJS) $(COBJS)
 
 BIN		= libfs$(LIBEXT)
 
+SUBDIRS		= fat
+VPATH		= fat
+
 all:	$(BIN)
 
 $(AOBJS): %$(OBJEXT): %.S
@@ -84,7 +84,7 @@ $(BIN):	$(OBJS)
 	done ; )
 
 .depend: Makefile $(SRCS)
-	@$(MKDEP) $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
+	@$(MKDEP) --dep-path . --dep-path fat $(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
 	@touch $@
 
 depend: .depend
@@ -92,6 +92,9 @@ depend: .depend
 clean:
 	@rm -f $(BIN) *~ .*.swp
 	$(call CLEAN)
+	@( for dir in $(SUBDIRS); do \
+		rm -f $${dir}/*~ $${dir}/.*.swp; \
+	done ; )
 
 distclean: clean
 	@rm -f Make.dep .depend
diff --git a/nuttx/fs/fat/Make.defs b/nuttx/fs/fat/Make.defs
index 2b5fdda45..d331a13d9 100644
--- a/nuttx/fs/fat/Make.defs
+++ b/nuttx/fs/fat/Make.defs
@@ -33,5 +33,7 @@
 #
 ############################################################################
 
-FAT_ASRCS =
-FAT_CSRCS =  fs_fat32.c fs_fat32attrib.c fs_fat32util.c
+ifeq ($(CONFIG_FS_FAT),y)
+ASRCS		+=
+CSRCS		+= fs_fat32.c fs_fat32attrib.c fs_fat32util.c
+endif
diff --git a/nuttx/fs/fs_fat32.c b/nuttx/fs/fs_fat32.c
deleted file mode 100644
index a54298bce..000000000
--- a/nuttx/fs/fs_fat32.c
+++ /dev/null
@@ -1,2210 +0,0 @@
-/****************************************************************************
- * fs_fat32.c
- *
- *   Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
- *
- * References:
- *   Microsoft FAT documentation
- *   Some good ideas were leveraged from the FAT implementation:
- *     'Copyright (C) 2007, ChaN, all right reserved.'
- *     which has an unrestricted license.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- *    used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/statfs.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <semaphore.h>
-#include <assert.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <debug.h>
-
-#include <nuttx/fs.h>
-#include <nuttx/fat.h>
-
-#include "fs_internal.h"
-#include "fs_fat32.h"
-
-/****************************************************************************
- * Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-static int     fat_open(FAR struct file *filp, const char *relpath,
-                        int oflags, mode_t mode);
-static int     fat_close(FAR struct file *filp);
-static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen);
-static ssize_t fat_write(FAR struct file *filp, const char *buffer,
-                         size_t buflen);
-static off_t   fat_seek(FAR struct file *filp, off_t offset, int whence);
-static int     fat_ioctl(FAR struct file *filp, int cmd, unsigned long arg);
-static int     fat_sync(FAR struct file *filp);
-
-static int     fat_opendir(struct inode *mountpt, const char *relpath,
-                           struct internal_dir_s *dir);
-static int     fat_readdir(struct inode *mountpt, struct internal_dir_s *dir);
-static int     fat_rewinddir(struct inode *mountpt, struct internal_dir_s *dir);
-
-static int     fat_bind(FAR struct inode *blkdriver, const void *data,
-                        void **handle);
-static int     fat_unbind(void *handle, FAR struct inode **blkdriver);
-static int     fat_statfs(struct inode *mountpt, struct statfs *buf);
-
-static int     fat_unlink(struct inode *mountpt, const char *relpath);
-static int     fat_mkdir(struct inode *mountpt, const char *relpath,
-                         mode_t mode);
-static int     fat_rmdir(struct inode *mountpt, const char *relpath);
-static int     fat_rename(struct inode *mountpt, const char *oldrelpath,
-                          const char *newrelpath);
-static int     fat_stat(struct inode *mountpt, const char *relpath, struct stat *buf);
-
-/****************************************************************************
- * Private Variables
- ****************************************************************************/
-
-/****************************************************************************
- * Public Variables
- ****************************************************************************/
-
-/* See fs_mount.c -- this structure is explicitly externed there.
- * We use the old-fashioned kind of initializers so that this will compile
- * with any compiler.
- */
-
-const struct mountpt_operations fat_operations =
-{
-  fat_open,
-  fat_close,
-  fat_read,
-  fat_write,
-  fat_seek,
-  fat_ioctl,
-  fat_sync,
-
-  fat_opendir,
-  NULL,
-  fat_readdir,
-  fat_rewinddir,
-
-  fat_bind,
-  fat_unbind,
-  fat_statfs,
-
-  fat_unlink,
-  fat_mkdir,
-  fat_rmdir,
-  fat_rename,
-  fat_stat
-};
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: fat_open
- ****************************************************************************/
-
-static int fat_open(FAR struct file *filp, const char *relpath,
-                    int oflags, mode_t mode)
-{
-  struct fat_dirinfo_s  dirinfo;
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv == NULL && filp->f_inode != NULL);
-
-  /* Get the mountpoint inode reference from the file structure and the
-   * mountpoint private data from the inode structure
-   */
-
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Initialize the directory info structure */
-
-  memset(&dirinfo, 0, sizeof(struct fat_dirinfo_s));
-
-  /* Locate the directory entry for this path */
-
-  ret = fat_finddirentry(fs, &dirinfo, relpath);
-
-  /* Three possibililities: (1) a node exists for the relpath and
-   * dirinfo describes the directory entry of the entity, (2) the
-   * node does not exist, or (3) some error occurred.
-   */
-
-  if (ret == OK)
-    {
-      boolean readonly;
-
-      /* The name exists -- but is it a file or a directory? */
-
-      if (dirinfo.fd_entry == NULL ||
-         (DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_DIRECTORY))
-        {
-          /* It is a directory */
-          ret = -EISDIR;
-          goto errout_with_semaphore;
-        }
-
-      /* It would be an error if we are asked to create it exclusively */
-
-      if ((oflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
-        {
-          /* Already exists -- can't create it exclusively */
-          ret = -EEXIST;
-          goto errout_with_semaphore;
-        }
-
-#ifdef CONFIG_FILE_MODE
-# warning "Missing check for privileges based on inode->i_mode"
-#endif
-
-      /* Check if the caller has sufficient privileges to open the file */
-
-      readonly = ((DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_READONLY) != 0);
-      if (((oflags & O_WRONLY) != 0) && readonly)
-        {
-          ret = -EACCES;
-          goto errout_with_semaphore;
-        }
-
-      /* If O_TRUNC is specified and the file is opened for writing,
-       * then truncate the file.  This operation requires that the file is
-       * writable, but we have already checked that. O_TRUNC without write
-       * access is ignored.
-       */
-
-      if ((oflags & (O_TRUNC|O_WRONLY)) == (O_TRUNC|O_WRONLY))
-        {
-          /* Truncate the file to zero length */
-
-          ret = fat_dirtruncate(fs, &dirinfo);
-          if (ret < 0)
-            {
-              goto errout_with_semaphore;
-            }
-        }
-
-      /* fall through to finish the file open operations */
-
-    }
-  else if (ret == -ENOENT)
-    {
-      /* The file does not exist.  Were we asked to create it? */
-
-      if ((oflags & O_CREAT) == 0)
-        {
-          /* No.. then we fail with -ENOENT */
-          ret = -ENOENT;
-          goto errout_with_semaphore;
-        }
-
-      /* Yes.. create the file */
-
-      ret = fat_dircreate(fs, &dirinfo);
-      if (ret < 0)
-        {
-          goto errout_with_semaphore;
-        }
-
-      /* Fall through to finish the file open operation */
-    }
-  else
-    {
-      /* An error occurred while checking for file existence --
-       * such as if an invalid path were provided.
-       */
-
-      goto errout_with_semaphore;
-    }
-
-  /* Create an instance of the file private date to describe the opened
-   * file.
-   */
-
-  ff = (struct fat_file_s *)zalloc(sizeof(struct fat_file_s));
-  if (!ff)
-    {
-      ret = -ENOMEM;
-      goto errout_with_semaphore;
-    }
-  
-  /* Create a file buffer to support partial sector accesses */
-
-  ff->ff_buffer = (ubyte*)malloc(fs->fs_hwsectorsize);
-  if (!ff->ff_buffer)
-    {
-      ret = -ENOMEM;
-      goto errout_with_struct;
-    }
-
-  /* Initialize the file private data (only need to initialize non-zero elements) */
-
-  ff->ff_open             = TRUE;
-  ff->ff_oflags           = oflags;
-  ff->ff_sectorsincluster = 1;
-
-  /* Save information that can be used later to recover the directory entry */
-
-  ff->ff_dirsector        = fs->fs_currentsector;
-  ff->ff_dirindex         = dirinfo.dir.fd_index;
-
-  /* File cluster/size info */
-
-  ff->ff_startcluster     =
-    ((uint32)DIR_GETFSTCLUSTHI(dirinfo.fd_entry) << 16) |
-      DIR_GETFSTCLUSTLO(dirinfo.fd_entry);
-
-  ff->ff_size             = DIR_GETFILESIZE(dirinfo.fd_entry);
-
-  /* In write/append mode, we need to set the file pointer to the end of the file */
-
-  if ((oflags & (O_APPEND|O_WRONLY)) == (O_APPEND|O_WRONLY))
-    {
-        ff->ff_position   = ff->ff_size;
-    }
-
-  /* Attach the private date to the struct file instance */
-
-  filp->f_priv = ff;
-
-  /* Then insert the new instance into the mountpoint structure.
-   * It needs to be there (1) to handle error conditions that effect
-   * all files, and (2) to inform the umount logic that we are busy
-   * (but a simple reference count could have done that).
-   */
-
-  ff->ff_next = fs->fs_head;
-  fs->fs_head = ff->ff_next;
-
-  fat_semgive(fs);
-  return OK;
-
-  /* Error exits -- goto's are nasty things, but they sure can make error
-   * handling a lot simpler.
-   */
-
-errout_with_struct:
-  free(ff);
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_close
- ****************************************************************************/
-
-static int fat_close(FAR struct file *filp)
-{
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  int                   ret = OK;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL);
-
-  /* Recover our private data from the struct file instance */
-
-  ff    = filp->f_priv;
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Do not check if the mount is healthy.  We must support closing of
-   * the file even when there is healthy mount.
-   */
-
-  /* Synchronize the file buffers and disk content; update times */
-
-  ret = fat_sync(filp);
-
-  /* Then deallocate the memory structures created when the open method
-   * was called.
-   *
-   * Free the sector buffer that was used to manage partial sector accesses.
-   */
-
-  if (ff->ff_buffer)
-  {
-      free(ff->ff_buffer);
-  }
-
-  /* Then free the file structure itself. */
-
-  free(ff);
-  filp->f_priv = NULL;
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_read
- ****************************************************************************/
-
-static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen)
-{
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  uint32                cluster;
-  unsigned int          bytesread;
-  unsigned int          readsize;
-  unsigned int          nsectors;
-  size_t                readsector;
-  size_t                bytesleft;
-  ubyte                 *userbuffer = (ubyte*)buffer;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL);
-
-  /* Recover our private data from the struct file instance */
-
-  ff    = filp->f_priv;
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Check if the file was opened with read access */
-
-  if ((ff->ff_oflags & O_RDOK) == 0)
-    {
-      ret = -EACCES;
-      goto errout_with_semaphore;
-    }
-
-  /* Get the number of bytes left in the file */
-
-  bytesleft = ff->ff_size - ff->ff_position;
-
-  /* Truncate read count so that it does not exceed the number
-   * of bytes left in the file.
-   */
-
-  if (buflen > bytesleft)
-  {
-      buflen = bytesleft;
-  }
-
-  /* Loop until either (1) all data has been transferred, or (2) an
-   * error occurs.
-   */
-
-  readsize   = 0;
-  readsector = ff->ff_currentsector;
-  while (buflen > 0)
-    {
-      /* Get offset into the sector where we begin the read */
-
-      int sectorindex = ff->ff_position & SEC_NDXMASK(fs);
-      bytesread = 0;
-
-      /* Check if the current read stream happens to lie on a
-       * sector boundary.
-       */
-
-      if (sectorindex == 0)
-        {
-          /* Try to read another contiguous sector from the cluster */
-
-          ff->ff_sectorsincluster--;
-
-          /* Are there unread sectors remaining in the cluster? */
-
-          if (ff->ff_sectorsincluster > 0)
-            {
-              /* Yes.. There are more sectors in this cluster to be read
-               * just increment the current sector number and read.
-               */
-
-              readsector = ff->ff_currentsector + 1;
-            }
-          else
-            {
-              /* No.. Handle the case of the first sector of the file */
-
-              if (ff->ff_position == 0)
-                {
-                  /* Get the first cluster of the file */
-
-                  cluster = ff->ff_startcluster;
-                }
-
-              /* But in the general case, we have to find the next cluster
-               * in the FAT.
-               */
-
-              else
-                {
-                  cluster = fat_getcluster(fs, ff->ff_currentcluster);
-                }
-
-              /* Verify the cluster number */
-
-              if (cluster < 2 || cluster >= fs->fs_nclusters)
-                {
-                  ret = -EINVAL; /* Not the right error */
-                  goto errout_with_semaphore;
-                }
-
-              /* Setup to read the first sector from the new cluster */
-
-              ff->ff_currentcluster   = cluster;
-              ff->ff_sectorsincluster = fs->fs_fatsecperclus;
-              readsector              = fat_cluster2sector(fs, cluster);
-            }
-        }
-
-      /* Check if the user has provided a buffer large enough to
-       * hold one or more complete sectors.
-       */
-
-      nsectors = buflen / fs->fs_hwsectorsize;
-      if (nsectors > 0)
-        {
-          /* Read maximum contiguous sectors directly to the user's
-           * buffer without using our tiny read buffer.
-           *
-           * Limit the number of sectors that we read on this time
-           * through the loop to the remaining contiguous sectors
-           * in this cluster
-           */
-
-          if (nsectors > ff->ff_sectorsincluster)
-            {
-              nsectors = ff->ff_sectorsincluster;
-            }
-
-          /* We are not sure of the state of the file buffer so
-           * the safest thing to do is just invalidate it
-           */
-
-          (void)fat_ffcacheinvalidate(fs, ff);
-
-          /* Read all of the sectors directory into user memory */
-
-          ret = fat_hwread(fs, userbuffer, readsector, nsectors);
-          if (ret < 0)
-            {
-              goto errout_with_semaphore;
-            }
-
-          ff->ff_sectorsincluster -= nsectors - 1;
-          ff->ff_currentsector     = readsector + nsectors - 1;
-          bytesread                = nsectors * fs->fs_hwsectorsize;
-        }
-      else
-        {
-          /* We are reading a partial sector.  First, read the whole sector
-           * into the file data buffer.  This is a caching buffer so if
-           * it is already there then all is well.
-           */
-
-          ret = fat_ffcacheread(fs, ff, readsector);
-          if (ret < 0)
-            {
-              goto errout_with_semaphore;
-            }
-
-          /* Copy the partial sector into the user buffer */
-
-          bytesread = fs->fs_hwsectorsize - sectorindex;
-          if (bytesread > buflen)
-            {
-              bytesread = buflen;
-            }
-
-          memcpy(userbuffer, &ff->ff_buffer[sectorindex], bytesread);
-          ff->ff_currentsector = readsector;
-        }
-
-      /* Set up for the next sector read */
-
-      userbuffer      += bytesread;
-      ff->ff_position += bytesread;
-      readsize        += bytesread;
-      buflen          -= bytesread;
-    }
-
-  fat_semgive(fs);
-  return readsize;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_write
- ****************************************************************************/
-
-static ssize_t fat_write(FAR struct file *filp, const char *buffer,
-                         size_t buflen)
-{
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  sint32                cluster;
-  size_t                writesector;
-  unsigned int          byteswritten;
-  unsigned int          writesize;
-  unsigned int          nsectors;
-  ubyte                *userbuffer = (ubyte*)buffer;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL);
-
-  /* Recover our private data from the struct file instance */
-
-  ff    = filp->f_priv;
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Check if the file was opened for write access */
-
-  if ((ff->ff_oflags & O_WROK) == 0)
-    {
-      ret = -EACCES;
-      goto errout_with_semaphore;
-    }
-
-  /* Check if the file size would exceed the range of size_t */
-
-  if (ff->ff_size + buflen < ff->ff_size)
-    {
-      ret = -EFBIG;
-      goto errout_with_semaphore;
-    }
-
-  /* Loop until either (1) all data has been transferred, or (2) an
-   * error occurs.
-   */
-
-  byteswritten = 0;
-  writesector = ff->ff_currentsector;
-  while (buflen > 0)
-    {
-      /* Get offset into the sector where we begin the read */
-
-      int sectorindex = ff->ff_position & SEC_NDXMASK(fs);
-
-      /* Check if the current read stream happens to lie on a
-       * sector boundary.
-       */
-
-      if (sectorindex == 0)
-        {
-          /* Decrement the number of sectors left in this cluster */
-
-          ff->ff_sectorsincluster--;
-
-          /* Are there unwritten sectors remaining in this cluster */
-
-          if (ff->ff_sectorsincluster > 0)
-            {
-              /* Yes.. There are more sectors in this cluster to be written.
-               * just increment the current sector number and write.
-               */
-
-              writesector = ff->ff_currentsector + 1;
-            }
-          else
-            {
-              /* No.. Handle the case of the first sector of the file */
-
-              if (ff->ff_position == 0)
-                {
-                  /* Check the first cluster of the file.  Zero means that
-                   * the file is empty -- perhaps the file was truncated or
-                   * created when it was opened
-                   */
-
-                  if (ff->ff_startcluster == 0)
-                    {
-                      /* In this case, we have to create a new cluster chain */
-
-                      ff->ff_startcluster = fat_createchain(fs);
-                    }
-
-                  /* Start writing at the first cluster of the file */
-
-                  cluster = ff->ff_startcluster;
-                }
-
-              /* But in the general case, we have to extend the current
-               * cluster by one (unless lseek was used to move the file
-               * position back from the end of the file)
-               */
-
-              else
-                {
-                    /* Extend the chain by adding a new cluster after
-                     * the last one
-                     */
-
-                    cluster = fat_extendchain(fs, ff->ff_currentcluster);
-                }
-
-              /* Verify the cluster number */
-
-              if (cluster < 0)
-                {
-                  ret = cluster;
-                  goto errout_with_semaphore;
-                }
-              else if (cluster < 2 || cluster >= fs->fs_nclusters)
-                {
-                  ret = -ENOSPC;
-                  goto errout_with_semaphore;
-                }
-
-              /* Setup to write the first sector from the new cluster */
-
-              ff->ff_currentcluster   = cluster;
-              ff->ff_sectorsincluster = fs->fs_fatsecperclus;
-              writesector             = fat_cluster2sector(fs, cluster);
-            }
-        }
-
-      /* Check if there is unwritten data in the file buffer */
-
-      ret = fat_ffcacheflush(fs, ff);
-      if (ret < 0)
-        {
-          goto errout_with_semaphore;
-        }
-
-      /* Check if the user has provided a buffer large enough to
-       * hold one or more complete sectors.
-       */
-
-      nsectors = buflen / fs->fs_hwsectorsize;
-      if (nsectors > 0)
-        {
-          /* Write maximum contiguous sectors directly from the user's
-           * buffer without using our tiny read buffer.
-           *
-           * Limit the number of sectors that we write on this time
-           * through the loop to the remaining contiguous sectors
-           * in this cluster
-           */
-
-          if (nsectors > ff->ff_sectorsincluster)
-            {
-              nsectors = ff->ff_sectorsincluster;
-            }
-
-          /* We are not sure of the state of the file buffer so
-           * the safest thing to do is just invalidate it
-           */
-
-          (void)fat_ffcacheinvalidate(fs, ff);
-
-          /* Write all of the sectors directory from user memory */
-
-          ret = fat_hwwrite(fs, userbuffer, writesector, nsectors);
-          if (ret < 0)
-            {
-              goto errout_with_semaphore;
-            }
-
-          ff->ff_sectorsincluster -= nsectors - 1;
-          ff->ff_currentsector     = writesector + nsectors - 1;
-          writesize                = nsectors * fs->fs_hwsectorsize;
-          ff->ff_bflags           |= FFBUFF_MODIFIED;
-        }
-      else
-        {
-          /* We are write a partial sector.  We will first have to
-           * read the full sector in memory as part of a read-modify-write
-           * operation.
-           */
-
-          if (ff->ff_position < ff->ff_size)
-            {
-              ff->ff_currentsector = writesector;
-              ret = fat_ffcacheread(fs, ff, writesector);
-              if (ret < 0)
-                {
-                  goto errout_with_semaphore;
-                }
-            }
-
-          /* Copy the partial sector from the user buffer */
-
-          writesize = fs->fs_hwsectorsize - sectorindex;
-          if (writesize > buflen)
-            {
-              writesize = buflen;
-            }
-
-          memcpy(&ff->ff_buffer[sectorindex], userbuffer, writesize);
-          ff->ff_currentsector = writesector;
-          ff->ff_bflags |= (FFBUFF_DIRTY|FFBUFF_VALID|FFBUFF_MODIFIED);
-        }
-
-      /* Set up for the next write */
-
-      userbuffer += writesize;
-      ff->ff_position += writesize;
-      byteswritten += writesize;
-      buflen -= writesize;
-    }
-
-  /* The transfer has completed without error.  Update the file size */
-
-  if (ff->ff_position > ff->ff_size)
-    {
-      ff->ff_size = ff->ff_position;
-    }
-
-  fat_semgive(fs);
-  return byteswritten;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_seek
- ****************************************************************************/
-
-static off_t fat_seek(FAR struct file *filp, off_t offset, int whence)
-{
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  sint32                cluster;
-  ssize_t               position;
-  unsigned int          clustersize;
-  unsigned int          sectoroffset;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL);
-
-  /* Recover our private data from the struct file instance */
-
-  ff    = filp->f_priv;
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Map the offset according to the whence option */
-  switch (whence)
-  {
-      case SEEK_SET: /* The offset is set to offset bytes. */
-          position = offset;
-          break;
-
-      case SEEK_CUR: /* The offset is set to its current location plus
-                      * offset bytes. */
-
-          position = offset + ff->ff_position;
-          break;
-
-      case SEEK_END: /* The offset is set to the size of the file plus
-                      * offset bytes. */
-
-          position = offset + ff->ff_size;
-          break;
-
-      default:
-          return -EINVAL;
-  }
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-        goto errout_with_semaphore;
-    }
-
-  /* Check if there is unwritten data in the file buffer */
-
-  ret = fat_ffcacheflush(fs, ff);
-  if (ret < 0)
-  {
-      goto errout_with_semaphore;
-  }
-
-  /* Attempts to set the position beyound the end of file will
-   * work if the file is open for write access.
-   */
-
-  if (position > ff->ff_size && (ff->ff_oflags & O_WROK) == 0)
-    {
-        /* Otherwise, the position is limited to the file size */
-        position = ff->ff_size;
-    }
-
-  /* Set file position to the beginning of the file */
-
-  ff->ff_position         = 0;
-  ff->ff_sectorsincluster = 1;
-
-  /* Move file position if necessary */
-
-  if (position)
-    {
-        /* Get the start cluster of the file */
-
-        cluster = ff->ff_startcluster;
-        if (!cluster)
-        {
-            /* Create a new cluster chain if the file does not have one */
-
-            cluster = fat_createchain(fs);
-            if (cluster < 0)
-            {
-                ret = cluster;
-                goto errout_with_semaphore;
-            }
-            ff->ff_startcluster = cluster;
-        }
-
-        if (cluster)
-        {
-            /* If the file has a cluster chain, follow it to the
-             * requested position.
-             */
-
-            clustersize = fs->fs_fatsecperclus * fs->fs_hwsectorsize;
-            for (;;)
-            {
-                /* Skip over clusters prior to the one containing
-                 * the requested position.
-                 */
-
-                ff->ff_currentcluster = cluster;
-                if (position <= clustersize)
-                {
-                    break;
-                }
-
-                /* Extend the cluster chain if write in enabled.  NOTE:
-                 * this is not consistent with the lseek description:
-                 * "The  lseek() function allows the file offset to be
-                 * set beyond the end of the file (but this does not
-                 * change the size of the file).  If data is later written
-                 * at  this  point, subsequent reads of the data in the
-                 * gap (a "hole") return null bytes ('\0') until data
-                 * is actually written into the gap."
-                 */
-
-                if ((ff->ff_oflags & O_WROK) != 0)
-                {
-                    /* Extend the cluster chain (fat_extendchain
-                     * will follow the existing chain or add new
-                     * clusters as needed.
-                     */
-
-                    cluster = fat_extendchain(fs, cluster);
-                }
-                else
-                {
-                    /* Other we can only follong the existing chain */
-
-                    cluster = fat_getcluster(fs, cluster);
-                }
-
-                if (cluster < 0)
-                {
-                    /* An error occurred getting the cluster */
-
-                    ret = cluster;
-                    goto errout_with_semaphore;
-                }
-
-                /* Zero means that there is no further clusters available
-                 * in the chain.
-                 */
-
-                if (cluster == 0)
-                {
-                    /* At the position to the current locaiton and
-                     * break out.
-                     */
-
-                    position = clustersize;
-                    break;
-                }
-
-                if (cluster >= fs->fs_nclusters)
-                {
-                    ret = -ENOSPC;
-                    goto errout_with_semaphore;
-                }
-
-                /* Otherwise, update the position and continue looking */
-
-                ff->ff_position += clustersize;
-                position        -= clustersize;
-            }
-
-            /* We get here after we have found the sector containing
-             * the requested position.
-             */
-
-            sectoroffset = (position - 1) / fs->fs_hwsectorsize;
-
-            /* And get the current sector from the cluster and
-             * the sectoroffset into the cluster.
-             */
-
-            ff->ff_currentsector =
-                fat_cluster2sector(fs, cluster) + sectoroffset;
-
-            /* Load the sector corresponding to the position */
-
-            if ((position & SEC_NDXMASK(fs)) != 0)
-            {
-                ret = fat_ffcacheread(fs, ff, ff->ff_currentsector);
-                if (ret < 0)
-                {
-                    goto errout_with_semaphore;
-                }
-            }
-
-            /* Save the number of sectors left in the cluster */
-
-            ff->ff_sectorsincluster = fs->fs_fatsecperclus - sectoroffset;
-
-            /* And save the new file position */
-
-            ff->ff_position += position;
-        }
-    }
-
-  /* If we extended the size of the file, then mark the file as modified. */
-
-  if ((ff->ff_oflags & O_WROK) != 0 &&  ff->ff_position > ff->ff_size)
-    {
-        ff->ff_size    = ff->ff_position;
-        ff->ff_bflags |= FFBUFF_MODIFIED;
-    }
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_ioctl
- ****************************************************************************/
-
-static int fat_ioctl(FAR struct file *filp, int cmd, unsigned long arg)
-{
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL);
-
-  /* Recover our private data from the struct file instance */
-
-  ff    = filp->f_priv;
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      fat_semgive(fs);
-      return ret;
-    }
-
-  /* ioctl calls are just passed through to the contained block driver */
-
-  fat_semgive(fs);
-  return -ENOSYS;
-}
-
-/****************************************************************************
- * Name: fat_sync
- *
- * Description: Synchronize the file state on disk to match internal, in-
- *   memory state.
- *
- ****************************************************************************/
-
-static int fat_sync(FAR struct file *filp)
-{
-  struct inode         *inode;
-  struct fat_mountpt_s *fs;
-  struct fat_file_s    *ff;
-  uint32                wrttime;
-  ubyte                *direntry;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(filp->f_priv != NULL && filp->f_inode != NULL);
-
-  /* Recover our private data from the struct file instance */
-
-  ff    = filp->f_priv;
-  inode = filp->f_inode;
-  fs    = inode->i_private;
-
-  DEBUGASSERT(fs != NULL);
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Check if the has been modified in any way */
-  if ((ff->ff_bflags & FFBUFF_MODIFIED) != 0)
-    {
-      /* Flush any unwritten data in the file buffer */
-
-      ret = fat_ffcacheflush(fs, ff);
-      if (ret < 0)
-        {
-          goto errout_with_semaphore;
-        }
-
-      /* Update the directory entry.  First read the directory
-       * entry into the fs_buffer (preserving the ff_buffer)
-       */
-
-      ret = fat_fscacheread(fs, ff->ff_dirsector);
-      if (ret < 0)
-        {
-          goto errout_with_semaphore;
-        }
-
-      /* Recover a pointer to the specific directory entry
-       * in the sector using the saved directory index.
-       */
-
-      direntry = &fs->fs_buffer[ff->ff_dirindex * 32];
-
-      /* Set the archive bit, set the write time, and update
-       * anything that may have* changed in the directory
-       * entry: the file size, and the start cluster
-       */
-
-      direntry[DIR_ATTRIBUTES] |= FATATTR_ARCHIVE;
-
-      DIR_PUTFILESIZE(direntry, ff->ff_size);
-      DIR_PUTFSTCLUSTLO(direntry, ff->ff_startcluster);
-      DIR_PUTFSTCLUSTHI(direntry, ff->ff_startcluster >> 16);
-
-      wrttime = fat_systime2fattime();
-      DIR_PUTWRTTIME(direntry, wrttime & 0xffff);
-      DIR_PUTWRTDATE(direntry, wrttime >> 16);
-
-      /* Clear the modified bit in the flags */
-
-      ff->ff_bflags &= ~FFBUFF_MODIFIED;
-
-      /* Flush these change to disk and update FSINFO (if
-       * appropriate.
-       */
-
-      fs->fs_dirty = TRUE;
-      ret          = fat_updatefsinfo(fs);
-    }
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_opendir
- *
- * Description: Open a directory for read access
- *
- ****************************************************************************/
-
-static int fat_opendir(struct inode *mountpt, const char *relpath, struct internal_dir_s *dir)
-{
-  struct fat_mountpt_s *fs;
-  struct fat_dirinfo_s  dirinfo;
-  int                     ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
-
-  /* Recover our private data from the inode instance */
-
-  fs = mountpt->i_private;
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Find the requested directory */
-
-  ret = fat_finddirentry(fs, &dirinfo, relpath);
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Check if this is the root directory */
-
-  if (dirinfo.fd_entry == NULL)
-    {
-      /* Handle the FAT12/16/32 root directory using the values setup by
-       * fat_finddirentry() above.
-       */
-
-      dir->u.fat.fd_startcluster = dirinfo.dir.fd_startcluster;
-      dir->u.fat.fd_currcluster  = dirinfo.dir.fd_currcluster;
-      dir->u.fat.fd_currsector   = dirinfo.dir.fd_currsector;
-      dir->u.fat.fd_index        = dirinfo.dir.fd_index;
-    }
-
-  /* This is not the root directory.  Verify that it is some kind of directory */
-
-  else if ((DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_DIRECTORY) == 0)
-    {
-       /* The entry is not a directory */
-       ret = -ENOTDIR;
-       goto errout_with_semaphore;
-    }
-  else
-    {
-       /* The entry is a directory */
-
-      dir->u.fat.fd_startcluster = 
-          ((uint32)DIR_GETFSTCLUSTHI(dirinfo.fd_entry) << 16) |
-                   DIR_GETFSTCLUSTLO(dirinfo.fd_entry);
-      dir->u.fat.fd_currcluster  = dir->u.fat.fd_startcluster;
-      dir->u.fat.fd_currsector   = fat_cluster2sector(fs, dir->u.fat.fd_currcluster);
-      dir->u.fat.fd_index        = 2;
-    }
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ERROR;
-}
-
-/****************************************************************************
- * Name: fat_readdir
- *
- * Description: Read the next directory entry
- *
- ****************************************************************************/
-
-static int fat_readdir(struct inode *mountpt, struct internal_dir_s *dir)
-{
-  struct fat_mountpt_s *fs;
-  unsigned int            dirindex;
-  ubyte                  *direntry;
-  ubyte                   ch;
-  ubyte                   attribute;
-  int                     ret = OK;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
-
-  /* Recover our private data from the inode instance */
-
-  fs = mountpt->i_private;
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Read the next directory entry */
-
-  dir->fd_dir.d_name[0] = '\0';
-  while (dir->u.fat.fd_currsector && dir->fd_dir.d_name[0] == '\0')
-    {
-      ret = fat_fscacheread(fs, dir->u.fat.fd_currsector);
-      if (ret < 0)
-        {
-          goto errout_with_semaphore;
-        }
-
-      /* Get a reference to the current directory entry */
-
-      dirindex = (dir->u.fat.fd_index & DIRSEC_NDXMASK(fs)) * 32;
-      direntry = &fs->fs_buffer[dirindex];
-
-      /* Has it reached to end of the directory */
-
-      ch = *direntry;
-      if (ch == DIR0_ALLEMPTY)
-        {
-          /* We signal the end of the directory by returning the
-           * special error -ENOENT
-           */
-
-          ret = -ENOENT;
-          goto errout_with_semaphore;
-        }
-
-      /* No, is the current entry a valid entry? */
-
-      attribute = DIR_GETATTRIBUTES(direntry);
-      if (ch != DIR0_EMPTY && (attribute & FATATTR_VOLUMEID) == 0)
-        {
-          /* Yes.. get the name from the directory info */
-
-          (void)fat_dirname2path(dir->fd_dir.d_name, direntry);
-
-          /* And the file type */
-
-          if ((attribute & FATATTR_DIRECTORY) == 0)
-            {
-              dir->fd_dir.d_type = DTYPE_FILE;
-            }
-          else
-            {
-              dir->fd_dir.d_type = DTYPE_DIRECTORY;
-            }
-        }
-
-      /* Set up the next directory index */
-
-      if (fat_nextdirentry(fs, &dir->u.fat) != OK)
-        {
-          ret = -ENOENT;
-          goto errout_with_semaphore;
-        }
-    }
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_rewindir
- *
- * Description: Reset directory read to the first entry
- *
- ****************************************************************************/
-
-static int fat_rewinddir(struct inode *mountpt, struct internal_dir_s *dir)
-{
-  struct fat_mountpt_s *fs;
-  int ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
-
-  /* Recover our private data from the inode instance */
-
-  fs = mountpt->i_private;
-
-  /* Make sure that the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Check if this is the root directory */
-
-  if (fs->fs_type != FSTYPE_FAT32 &&
-      dir->u.fat.fd_startcluster == 0)
-    {
-      /* Handle the FAT12/16 root directory */
-
-      dir->u.fat.fd_currcluster  = 0;
-      dir->u.fat.fd_currsector   = fs->fs_rootbase;
-      dir->u.fat.fd_index        = 0;
-    }
-  else if (fs->fs_type == FSTYPE_FAT32 &&
-           dir->u.fat.fd_startcluster == fs->fs_rootbase)
-    {
-      /* Handle the FAT32 root directory */
-
-      dir->u.fat.fd_currcluster = dir->u.fat.fd_startcluster;
-      dir->u.fat.fd_currsector  = fat_cluster2sector(fs, fs->fs_rootbase);
-      dir->u.fat.fd_index       = 0;
-    }
-
-  /* This is not the root directory */
-
-  else
-    {
-      dir->u.fat.fd_currcluster  = dir->u.fat.fd_startcluster;
-      dir->u.fat.fd_currsector   = fat_cluster2sector(fs, dir->u.fat.fd_currcluster);
-      dir->u.fat.fd_index        = 2;
-    }
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ERROR;
-}
-
-/****************************************************************************
- * Name: fat_bind
- *
- * Description: This implements a portion of the mount operation. This
- *  function allocates and initializes the mountpoint private data and
- *  binds the blockdriver inode to the filesystem private data.  The final
- *  binding of the private data (containing the blockdriver) to the
- *  mountpoint is performed by mount().
- *
- ****************************************************************************/
-
-static int fat_bind(FAR struct inode *blkdriver, const void *data,
-                    void **handle)
-{
-  struct fat_mountpt_s *fs;
-  int ret;
-
-  /* Open the block driver */
-
-  if (!blkdriver || !blkdriver->u.i_bops)
-    {
-      return -ENODEV;
-    }
-
-  if (blkdriver->u.i_bops->open &&
-       blkdriver->u.i_bops->open(blkdriver) != OK)
-    {
-      return -ENODEV;
-    }
-
-  /* Create an instance of the mountpt state structure */
-
-  fs = (struct fat_mountpt_s *)zalloc(sizeof(struct fat_mountpt_s));
-  if (!fs)
-    {
-      return -ENOMEM;
-    }
-
-  /* Initialize the allocated mountpt state structure.  The filesystem is
-   * responsible for one reference ont the blkdriver inode and does not
-   * have to addref() here (but does have to release in ubind().
-   */
-
-  fs->fs_blkdriver = blkdriver;  /* Save the block driver reference */
-  sem_init(&fs->fs_sem, 0, 0);   /* Initialize the semaphore that controls access */
-
-  /* Then get information about the FAT32 filesystem on the devices managed
-   * by this block driver.
-   */
-
-  ret = fat_mount(fs, TRUE);
-  if (ret != 0)
-    {
-      sem_destroy(&fs->fs_sem);
-      free(fs);
-      return ret;
-    }
-
-  *handle = (void*)fs;
-  fat_semgive(fs);
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_unbind
- *
- * Description: This implements the filesystem portion of the umount
- *   operation.
- *
- ****************************************************************************/
-
-static int fat_unbind(void *handle, FAR struct inode **blkdriver)
-{
-  struct fat_mountpt_s *fs = (struct fat_mountpt_s*)handle;
-  int ret;
-
-  if (!fs)
-    {
-      return -EINVAL;
-    }
-
-  /* Check if there are sill any files opened on the filesystem. */
-
-  ret = OK; /* Assume success */
-  fat_semtake(fs);
-  if (fs->fs_head)
-    {
-      /* We cannot unmount now.. there are open files */
-
-      ret = -EBUSY;
-    }
-  else
-    {
-       /* Unmount ... close the block driver */
-
-      if (fs->fs_blkdriver)
-        {
-          struct inode *inode = fs->fs_blkdriver;
-          if (inode)
-            {
-              if (inode->u.i_bops && inode->u.i_bops->close)
-                {
-                  (void)inode->u.i_bops->close(inode);
-                }
-
-              /* We hold a reference to the block driver but should
-               * not but mucking with inodes in this context.  So, we will just return
-               * our contained reference to the block driver inode and let the umount
-               * logic dispose of it.
-               */
-
-              if (blkdriver)
-                {
-                  *blkdriver = inode;
-                }
-            }
-        }
-
-      /* Release the mountpoint private data */
-
-      if (fs->fs_buffer)
-        {
-          free(fs->fs_buffer);
-        }
-      free(fs);
-    }
-
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_statfs
- *
- * Description: Return filesystem statistics
- *
- ****************************************************************************/
-
-static int fat_statfs(struct inode *mountpt, struct statfs *buf)
-{
-  struct fat_mountpt_s *fs;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt && mountpt->i_private);
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = mountpt->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret < 0)
-    {
-       goto errout_with_semaphore;
-    }
-
-  /* Fill in the statfs info */
-
-  memset(buf, 0, sizeof(struct statfs));
-  buf->f_type    = MSDOS_SUPER_MAGIC;
-
-  /* We will claim that the optimal transfer size is the size of a cluster in bytes */
-
-  buf->f_bsize   = fs->fs_fatsecperclus * fs->fs_hwsectorsize;
-
-  /* Everything else follows in units of clusters */
-
-  buf->f_blocks  = fs->fs_nclusters;                        /* Total data blocks in the file system */
-  ret = fat_nfreeclusters(fs, &buf->f_bfree);               /* Free blocks in the file system */
-  buf->f_bavail  = buf->f_bfree;                            /* Free blocks avail to non-superuser */
-  buf->f_namelen = (8+1+3);                                 /* Maximum length of filenames */
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_unlink
- *
- * Description: Remove a file
- *
- ****************************************************************************/
-
-static int fat_unlink(struct inode *mountpt, const char *relpath)
-{
-  struct fat_mountpt_s *fs;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt && mountpt->i_private);
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = mountpt->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret == OK)
-    {
-      /* If the file is open, the correct behavior is to remove the file
-       * name, but to keep the file cluster chain in place until the last
-       * open reference to the file is closed.
-       */
-
-#warning "Need to defer deleting cluster chain if the file is open"
-
-      /* Remove the file */
-
-      ret = fat_remove(fs, relpath, FALSE);
-    }
-
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_mkdir
- *
- * Description: Create a directory
- *
- ****************************************************************************/
-
-static int fat_mkdir(struct inode *mountpt, const char *relpath, mode_t mode)
-{
-  struct fat_mountpt_s *fs;
-  struct fat_dirinfo_s  dirinfo;
-  ubyte       *direntry;
-  ubyte       *direntry2;
-  size_t       parentsector;
-  ssize_t      dirsector;
-  sint32       dircluster;
-  uint32       parentcluster;
-  uint32       crtime;
-  unsigned int i;
-  int          ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt && mountpt->i_private);
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = mountpt->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Find the directory where the new directory should be created. */
-
-  ret = fat_finddirentry(fs, &dirinfo, relpath);
-
-  /* If anything exists at this location, then we fail with EEXIST */
-
-  if (ret == OK)
-    {
-      ret = -EEXIST;
-      goto errout_with_semaphore;
-    }
-
-  /* What we want to see is for fat_finddirentry to fail with -ENOENT.
-   * This error means that no failure occurred but that nothing exists
-   * with this name.
-   */
-
-  if (ret != -ENOENT)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* NOTE: There is no check that dirinfo.fd_name contains the final
-   * directory name.  We could be creating an intermediate directory
-   * in the full relpath.
-   */
-
-  /* Allocate a directory entry for the new directory in this directory */
-
-  ret = fat_allocatedirentry(fs, &dirinfo);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-  parentsector = fs->fs_currentsector;
-
-  /* Allocate a cluster for new directory */
-
-  dircluster = fat_createchain(fs);
-  if (dircluster < 0)
-    {
-      ret = dircluster;
-      goto errout_with_semaphore;
-    }
-  else if (dircluster < 2)
-    {
-      ret = -ENOSPC;
-      goto errout_with_semaphore;
-    }
-
-  dirsector = fat_cluster2sector(fs, dircluster);
-  if (dirsector < 0)
-    {
-      ret = dirsector;
-      goto errout_with_semaphore;
-    }
-
-  /* Flush any existing, dirty data in fs_buffer (because we need 
-   * it to create the directory entries.
-   */
-
-  ret = fat_fscacheflush(fs);
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Get a pointer to the first directory entry in the sector */
-
-  direntry = fs->fs_buffer;
-
-  /* Now erase the contents of fs_buffer */
-
-  fs->fs_currentsector = dirsector;
-  memset(direntry, 0, fs->fs_hwsectorsize);
-
-  /* Now clear all sectors in the new directory cluster (except for the first) */
-
-  for (i = 1; i < fs->fs_fatsecperclus; i++)
-    {
-      ret = fat_hwwrite(fs, direntry, ++dirsector, 1);
-      if (ret < 0)
-        {
-          goto errout_with_semaphore;
-        }
-    }
-
-  /* Now create the "." directory entry in the first directory slot */
-
-  memset(&direntry[DIR_NAME], ' ', 8+3);
-  direntry[DIR_NAME] = '.';
-  DIR_PUTATTRIBUTES(direntry, FATATTR_DIRECTORY);
-
-  crtime = fat_systime2fattime();
-  DIR_PUTCRTIME(direntry, crtime & 0xffff);
-  DIR_PUTWRTTIME(direntry, crtime & 0xffff);
-  DIR_PUTCRDATE(direntry, crtime >> 16);
-  DIR_PUTWRTDATE(direntry, crtime >> 16);
-
-  /* Create ".." directory entry in the second directory slot */
-
-  direntry2 = direntry + 32;
-
-  /* So far, the two entries are nearly the same */
-
-  memcpy(direntry2, direntry, 32);
-  direntry2[DIR_NAME+1] = '.';
-
-  /* Now add the cluster information to both directory entries */
-
-  DIR_PUTFSTCLUSTHI(direntry, dircluster >> 16);
-  DIR_PUTFSTCLUSTLO(direntry, dircluster);
-
-  parentcluster = dirinfo.dir.fd_startcluster;
-  if (fs->fs_type != FSTYPE_FAT32 && parentcluster == fs->fs_rootbase)
-    {
-      parentcluster = 0;
-    }
-
-  DIR_PUTFSTCLUSTHI(direntry2, parentcluster >> 16);
-  DIR_PUTFSTCLUSTLO(direntry2, parentcluster);
-
-  /* Save the first sector of the directory cluster and re-read
-   *  the parentsector
-   */
-
-  fs->fs_dirty = TRUE;
-  ret = fat_fscacheread(fs, parentsector);
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Initialize the new entry directory entry in the parent directory */
-
-  direntry = dirinfo.fd_entry;
-  memset(direntry, 0, 32);
-
-  memcpy(direntry, dirinfo.fd_name, 8+3);
-#ifdef CONFIG_FLAT_LCNAMES
-  DIR_PUTNTRES(direntry, dirinfo.fd_ntflags);
-#endif
-  DIR_PUTATTRIBUTES(dirinfo.fd_entry, FATATTR_DIRECTORY);
-
-  /* Same creation time as for . and .. */
-
-  DIR_PUTCRTIME(dirinfo.fd_entry, crtime & 0xffff);
-  DIR_PUTWRTTIME(dirinfo.fd_entry, crtime & 0xffff);
-  DIR_PUTCRDATE(dirinfo.fd_entry, crtime >> 16);
-  DIR_PUTWRTDATE(dirinfo.fd_entry, crtime >> 16);
-
-  /* Set subdirectory start cluster */
-
-  DIR_PUTFSTCLUSTLO(dirinfo.fd_entry, dircluster);
-  DIR_PUTFSTCLUSTHI(dirinfo.fd_entry, dircluster >> 16);
-
-  /* Now update the FAT32 FSINFO sector */
-
-  fs->fs_dirty = TRUE;
-  ret = fat_updatefsinfo(fs);
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_rmdir
- *
- * Description: Remove a directory
- *
- ****************************************************************************/
-
-int fat_rmdir(struct inode *mountpt, const char *relpath)
-{
-  struct fat_mountpt_s *fs;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt && mountpt->i_private);
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = mountpt->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret == OK)
-    {
-      /* If the directory is open, the correct behavior is to remove the directory
-       * name, but to keep the directory cluster chain in place until the last
-       * open reference to the directory is closed.
-       */
-
-#warning "Need to defer deleting cluster chain if the directory is open"
-
-      /* Remove the directory */
-
-      ret = fat_remove(fs, relpath, TRUE);
-    }
-
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_rename
- *
- * Description: Rename a file or directory
- *
- ****************************************************************************/
-
-int fat_rename(struct inode *mountpt, const char *oldrelpath,
-               const char *newrelpath)
-{
-  struct fat_mountpt_s *fs;
-  struct fat_dirinfo_s  dirinfo;
-  size_t                oldsector;
-  ubyte                *olddirentry;
-  ubyte                *newdirentry;
-  ubyte                 dirstate[32-11];
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt && mountpt->i_private);
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = mountpt->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Find the directory entry for the oldrelpath */
-
-  ret = fat_finddirentry(fs, &dirinfo, oldrelpath);
-  if (ret != OK)
-    {
-      /* Some error occurred -- probably -ENOENT */
-
-      goto errout_with_semaphore;
-    }
-
-  /* Save the information that will need to recover the
-   * directory sector and directory entry offset to the
-   * old directory.
-   */
-
-  olddirentry = dirinfo.fd_entry;
-
-  /* One more check:  Make sure that the oldrelpath does
-   * not refer to the root directory.  We can't rename the
-   * root directory.
-   */
-
-  if (!olddirentry)
-    {
-      ret = -EXDEV;
-      goto errout_with_semaphore;
-    }
-
-  oldsector   = fs->fs_currentsector;
-  memcpy(dirstate, &olddirentry[DIR_ATTRIBUTES], 32-11);
-
-  /* No find the directory where we should create the newpath object */
-
-  ret = fat_finddirentry(fs, &dirinfo, newrelpath);
-  if (ret == OK)
-    {
-      /* It is an error if the object at newrelpath already exists */
-
-      ret = -EEXIST;
-      goto errout_with_semaphore;
-    }
-
-  /* What we expect is -ENOENT mean that the full directory path was
-   * followed but that the object does not exists in the terminal directory.
-   */
-
-  if (ret != -ENOENT)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Reserve a directory entry */
-
-  ret = fat_allocatedirentry(fs, &dirinfo);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Create the new directory entry */
-
-  newdirentry = dirinfo.fd_entry;
-
-  memcpy(&newdirentry[DIR_ATTRIBUTES], dirstate, 32-11);
-  memcpy(&newdirentry[DIR_NAME], dirinfo.fd_name, 8+3);
-#ifdef CONFIG_FLAT_LCNAMES
-  DIR_PUTNTRES(newdirentry, dirinfo.fd_ntflags);
-#else
-  DIR_PUTNTRES(newdirentry, 0);
-#endif
-  fs->fs_dirty = TRUE;
-
-  /* Now flush the new directory entry to disk and read the sector
-   * containing the old directory entry.
-   */
-
-  ret = fat_fscacheread(fs, oldsector);
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Remove the old entry */
-
-  olddirentry[DIR_NAME] = DIR0_EMPTY;
-  fs->fs_dirty = TRUE;
-
-  /* Write the old entry to disk and update FSINFO if necessary */
-
-  ret = fat_updatefsinfo(fs);
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  fat_semgive(fs);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_stat
- *
- * Description: Return information about a file or directory
- *
- ****************************************************************************/
-
-static int fat_stat(struct inode *mountpt, const char *relpath, struct stat *buf)
-{
-  struct fat_mountpt_s *fs;
-  struct fat_dirinfo_s  dirinfo;
-  uint16                date;
-  uint16                date2;
-  uint16                time;
-  ubyte                 attribute;
-  int                   ret;
-
-  /* Sanity checks */
-
-  DEBUGASSERT(mountpt && mountpt->i_private);
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = mountpt->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Find the directory entry corresponding to relpath. */
-
-  ret = fat_finddirentry(fs, &dirinfo, relpath);
-
-  /* If nothing was found, then we fail with EEXIST */
-
-  if (ret < 0)
-    {
-      goto errout_with_semaphore;
-    }
-
-  memset(buf, 0, sizeof(struct stat));
-  if (!dirinfo.fd_entry)
-    {
-      /* It's directory name of mount point */
-
-      buf->st_mode = S_IFDIR|S_IROTH|S_IRGRP|S_IRUSR|S_IWOTH|S_IWGRP|S_IWUSR;
-      ret = OK;
-      goto errout_with_semaphore;
-    }
-
-  /* Get the FAT attribute and map it so some meaningful mode_t values */
-
-  attribute = DIR_GETATTRIBUTES(dirinfo.fd_entry);
-  if ((attribute & FATATTR_VOLUMEID) != 0)
-    {
-      ret = -ENOENT;
-      goto errout_with_semaphore;
-    }
-
-  /* Set the access permissions.  The file/directory is always readable
-   * by everyone but may be writeable by no-one.
-   */
-
-  buf->st_mode = S_IROTH|S_IRGRP|S_IRUSR;
-  if ((attribute & FATATTR_READONLY) == 0)
-    {
-      buf->st_mode |= S_IWOTH|S_IWGRP|S_IWUSR;
-    }
-
-  /* We will report only types file or directory */
-
-  if ((attribute & FATATTR_DIRECTORY) != 0)
-    {
-      buf->st_mode |= S_IFDIR;
-    }
-  else
-    {
-      buf->st_mode |= S_IFREG;
-    }
-
-  /* File/directory size, access block size */
-
-  buf->st_size      = DIR_GETFILESIZE(dirinfo.fd_entry);
-  buf->st_blksize   = fs->fs_fatsecperclus * fs->fs_hwsectorsize;
-  buf->st_blocks    = (buf->st_size + buf->st_blksize - 1) / buf->st_blksize;
-
-  /* Times */
-
-  date              = DIR_GETWRTDATE(dirinfo.fd_entry);
-  time              = DIR_GETWRTTIME(dirinfo.fd_entry);
-  buf->st_mtime     = fat_fattime2systime(time, date);
-
-  date2             = DIR_GETLASTACCDATE(dirinfo.fd_entry);
-  if (date == date2)
-    {
-      buf->st_atime = buf->st_mtime;
-    }
-  else
-    {
-      buf->st_atime = fat_fattime2systime(0, date2);
-    }
-
-  date              = DIR_GETCRDATE(dirinfo.fd_entry);
-  time              = DIR_GETCRTIME(dirinfo.fd_entry);
-  buf->st_ctime     = fat_fattime2systime(time, date);
-
-  ret = OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-  return ret;
-}
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
diff --git a/nuttx/fs/fs_fat32.h b/nuttx/fs/fs_fat32.h
deleted file mode 100644
index ab48fa796..000000000
--- a/nuttx/fs/fs_fat32.h
+++ /dev/null
@@ -1,584 +0,0 @@
-/****************************************************************************
- * fs_fat32.h
- *
- *   Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- *    used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-#ifndef __FS_FAT_H
-#define __FS_FAT_H
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-#include <sys/types.h>
-#include <semaphore.h>
-#include <time.h>
-
-/****************************************************************************
- * Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * These offsets describes the master boot record.
- *
- * The folowing fields are common to FAT12/16/32 (but all value descriptions
- * refer to the interpretation under FAT32.
- */
-
-#define BS_JUMP             0 /*  3@0:  Jump instruction to boot code (ignored) */
-#define BS_OEMNAME          3 /*  8@3:  Usually "MSWIN4.1" */
-#define BS_BYTESPERSEC     11 /*  2@11: Bytes per sector: 512, 1024, 2048, 4096  */
-#define BS_SECPERCLUS      13 /*  1@13: Sectors per allocation unit: 2**n, n=0..7 */
-#define BS_RESVDSECCOUNT   14 /*  2@14: Reserved sector count: Usually 32 */
-#define BS_NUMFATS         16 /*  1@16: Number of FAT data structures: always 2 */
-#define BS_ROOTENTCNT      17 /*  2@17: FAT12/16: Must be 0 for FAT32 */
-#define BS_TOTSEC16        19 /*  2@19: FAT12/16: Must be 0, see BS32_totsec32 */
-#define BS_MEDIA           21 /*  1@21: Media code: f0, f8, f9-fa, fc-ff */ 
-#define BS_FATSZ16         22 /*  2@22: FAT12/16: Must be 0, see BS32_fatsz32 */
-#define BS_SECPERTRK       24 /*  2@24: Sectors per track geometry value */
-#define BS_NUMHEADS        26 /*  2@26: Number of heads geometry value */
-#define BS_HIDSEC          28 /*  4@28: Count of hidden sectors preceding FAT */
-#define BS_TOTSEC32        32 /*  4@32: Total count of sectors on the volume */
-
-/* The following fields are only valid for FAT12/16 */
-
-#define BS16_DRVNUM        36 /*  1@36: Drive number for MSDOS bootstrap */
-                              /*  1@37: Reserved (zero) */
-#define BS16_BOOTSIG       38 /*  1@38: Extended boot signature: 0x29 if following valid */
-#define BS16_VOLID         39 /*  4@39: Volume serial number */
-#define BS16_VOLLAB        43 /* 11@43: Volume label */
-#define BS16_FILESYSTYPE   54 /*  8@54: "FAT12  ", "FAT16  ", or "FAT    " */
-
-#define BS16_BOOTCODE      62 /* Boot code may be placed in the remainder of the sector */
-#define BS16_BOOTCODESIZE 448
-
-/* The following fields are only valid for FAT32 */
-
-#define BS32_FATSZ32       36 /*  4@36: Count of sectors occupied by one FAT */
-#define BS32_EXTFLAGS      40 /*  2@40: 0-3:Active FAT, 7=0 both FATS, 7=1 one FAT */ 
-#define BS32_FSVER         42 /*  2@42: MSB:Major LSB:Minor revision number (0.0) */
-#define BS32_ROOTCLUS      44 /*  4@44: Cluster no. of 1st cluster of root dir */
-#define BS32_FSINFO        48 /*  2@48: Sector number of fsinfo structure. Usually 1. */
-#define BS32_BKBOOTSEC     50 /*  2@50: Sector number of boot record. Usually 6  */
-                              /* 12@52: Reserved (zero) */
-#define BS32_DRVNUM        64 /*  1@64: Drive number for MSDOS bootstrap */
-                              /*  1@65: Reserverd (zero) */
-#define BS32_BOOTSIG       66 /*  1@66: Extended boot signature: 0x29 if following valid */
-#define BS32_VOLID         67 /*  4@67: Volume serial number */
-#define BS32_VOLLAB        71 /* 11@71: Volume label */
-#define BS32_FILESYSTYPE   82 /*  8@82: "FAT12  ", "FAT16  ", or "FAT    " */
-
-#define BS32_BOOTCODE      90 /* Boot code may be placed in the remainder of the sector */
-#define BS32_BOOTCODESIZE 420
-
-/* If the sector is not an MBR, then it could have a partition table at
- * this offset.
- */
-
-#define MBR_TABLE         446
-
-/* The magic bytes at the end of the MBR are common to FAT12/16/32 */
-
-#define BS_SIGNATURE      510 /*  2@510: Valid MBRs have 0x55aa here */
-
-/****************************************************************************
- * Each FAT directory entry is 32-bytes long.  The following define offsets
- * relative to the beginning of a directory entry.
- */
-
-#define DIR_NAME            0 /* 11@ 0: NAME: 8 bytes + 3 byte extension */
-#define DIR_ATTRIBUTES     11 /*  1@11: File attibutes (see below) */
-#define DIR_NTRES          12 /*  1@12: Reserved for use by NT */
-#define DIR_CRTTIMETENTH   13 /*  1@13: Tenth sec creation timestamp */
-#define DIR_CRTIME         14 /*  2@14: Time file created */
-#define DIR_CRDATE         16 /*  2@16: Date file created */
-#define DIR_LASTACCDATE    18 /*  2@19: Last access date */
-#define DIR_FSTCLUSTHI     20 /*  2@20: MS first cluster number */
-#define DIR_WRTTIME        22 /*  2@22: Time of last write */
-#define DIR_WRTDATE        24 /*  2@24: Date of last write */
-#define DIR_FSTCLUSTLO     26 /*  2@26: LS first cluster number */
-#define DIR_FILESIZE       28 /*  4@28: File size in bytes */
-#define DIR_SIZE           32
-
-/* First byte of the directory name has special meanings: */
-
-#define DIR0_EMPTY        0xe5 /* The directory entry is empty */
-#define DIR0_ALLEMPTY     0x00 /* This entry and all following are empty */
-#define DIR0_E5           0x05 /* The actual value is 0xe5 */
-
-/* NTRES flags in the FAT directory */
-
-#define FATNTRES_LCNAME   0x08 /* Lower case in name */
-#define FATNTRES_LCEXT    0x10 /* Lower case in extension */
-
-/* Directory indexing helper.  Each directory entry is 32-bytes in length.
- * The number of directory entries in a sector then varies with the size
- * of the sector supported in hardware.
- */
-
-#define DIRSEC_NDXMASK(f)   (((f)->fs_hwsectorsize - 1) >> 5)
-#define DIRSEC_NDIRS(f)     (((f)->fs_hwsectorsize) >> 5)
-#define DIRSEC_BYTENDX(f,i) (((i) & DIRSEC_NDXMASK(fs)) << 5)
-
-#define SEC_NDXMASK(f)      ((f)->fs_hwsectorsize - 1)
-#define SEC_NSECTORS(f,n)   ((n) / (f)->fs_hwsectorsize)
-
-/****************************************************************************
- * File system types */
-
-#define FSTYPE_FAT12        0
-#define FSTYPE_FAT16        1
-#define FSTYPE_FAT32        2
-
-/* File buffer flags */
-
-#define FFBUFF_VALID        1
-#define FFBUFF_DIRTY        2
-#define FFBUFF_MODIFIED     4
-
-/****************************************************************************
- * These offset describe the FSINFO sector
- */
-
-#define FSI_LEADSIG         0 /*   4@0:   0x41615252 */
-                              /* 480@4:   Reserved (zero) */
-#define FSI_STRUCTSIG     484 /*   4@484: 0x61417272 */
-#define FSI_FREECOUNT     488 /*   4@488: Last free cluster count on volume */
-#define FSI_NXTFREE       492 /*   4@492: Cluster number of 1st free cluster */
-                              /*  12@496: Reserved (zero) */
-#define FSI_TRAILSIG      508 /*   4@508: 0xaa550000 */
-
-/****************************************************************************
- * Access to data in raw sector data */
-
-#define UBYTE_VAL(p,o)            (((ubyte*)(p))[o])
-#define UBYTE_PTR(p,o)            &UBYTE_VAL(p,o)
-#define UBYTE_PUT(p,o,v)          (UBYTE_VAL(p,o)=(ubyte)(v))
-
-#define UINT16_PTR(p,o)           ((uint16*)UBYTE_PTR(p,o))
-#define UINT16_VAL(p,o)           (*UINT16_PTR(p,o))
-#define UINT16_PUT(p,o,v)         (UINT16_VAL(p,o)=(uint16)(v))
-
-#define UINT32_PTR(p,o)           ((uint32*)UBYTE_PTR(p,o))
-#define UINT32_VAL(p,o)           (*UINT32_PTR(p,o))
-#define UINT32_PUT(p,o,v)         (UINT32_VAL(p,o)=(uint32)(v))
-
-/* Regardless of the endian-ness of the target or alignment of the data, no
- * special operations are required for byte, string or byte array accesses.
- * The FAT data stream is little endian so multiple byte values must be
- * accessed byte-by-byte for big-endian targets.
- */
-
-#define MBR_GETSECPERCLUS(p)      UBYTE_VAL(p,BS_SECPERCLUS)
-#define MBR_GETNUMFATS(p)         UBYTE_VAL(p,BS_NUMFATS)
-#define MBR_GETMEDIA(p)           UBYTE_VAL(p,BS_MEDIA)
-#define MBR_GETDRVNUM16(p)        UBYTE_VAL(p,BS16_DRVNUM)
-#define MBR_GETDRVNUM32(p)        UBYTE_VAL(p,BS32_DRVNUM)
-#define MBR_GETBOOTSIG16(p)       UBYTE_VAL(p,BS16_BOOTSIG)
-#define MBR_GETBOOTSIG32(p)       UBYTE_VAL(p,BS32_BOOTSIG)
-
-#define DIR_GETATTRIBUTES(p)      UBYTE_VAL(p,DIR_ATTRIBUTES)
-#define DIR_GETNTRES(p)           UBYTE_VAL(p,DIR_NTRES)
-#define DIR_GETCRTTIMETENTH(p)    UBYTE_VAL(p,DIR_CRTTIMETENTH)
-
-#define MBR_PUTSECPERCLUS(p,v)    UBYTE_PUT(p,BS_SECPERCLUS),v)
-#define MBR_PUTNUMFATS(p,v)       UBYTE_PUT(p,BS_NUMFATS,v)
-#define MBR_PUTMEDIA(p,v)         UBYTE_PUT(p,BS_MEDIA,v)
-#define MBR_PUTDRVNUM16(p,v)      UBYTE_PUT(p,BS16_DRVNUM,v)
-#define MBR_PUTDRVNUM32(p,v)      UBYTE_PUT(p,BS32_DRVNUM,v)
-#define MBR_PUTBOOTSIG16(p,v)     UBYTE_PUT(p,BS16_BOOTSIG,v)
-#define MBR_PUTBOOTSIG32(p,v)     UBYTE_PUT(p,BS32_BOOTSIG,v)
-
-#define DIR_PUTATTRIBUTES(p,v)    UBYTE_PUT(p,DIR_ATTRIBUTES,v)
-#define DIR_PUTNTRES(p,v)         UBYTE_PUT(p,DIR_NTRES,v)
-#define DIR_PUTCRTTIMETENTH(p,v)  UBYTE_PUT(p,DIR_CRTTIMETENTH,v)
-
-/* For the all targets, unaligned values need to be accessed byte-by-byte.
- * Some architectures may handle unaligned accesses with special interrupt
- * handlers.  But even in that case, it is more efficient to avoid the traps.
- */
-
-/* Unaligned multi-byte access macros */
-
-#define MBR_GETBYTESPERSEC(p)      fat_getuint16(UBYTE_PTR(p,BS_BYTESPERSEC))
-#define MBR_GETROOTENTCNT(p)       fat_getuint16(UBYTE_PTR(p,BS_ROOTENTCNT))
-#define MBR_GETTOTSEC16(p)         fat_getuint16(UBYTE_PTR(p,BS_TOTSEC16))
-#define MBR_GETVOLID16(p)          fat_getuint32(UBYTE_PTR(p,BS16_VOLID))
-#define MBR_GETVOLID32(p)          fat_getuint32(UBYTE_PTR(p,BS32_VOLID))
-
-#define MBR_PUTBYTESPERSEC(p,v)    fat_putuint16(UBYTE_PTR(p,BS_BYTESPERSEC),v)
-#define MBR_PUTROOTENTCNT(p,v)     fat_putuint16(UBYTE_PTR(p,BS_ROOTENTCNT),v)
-#define MBR_PUTTOTSEC16(p,v)       fat_putuint16(UBYTE_PTR(p,BS_TOTSEC16),v)
-#define MBR_PUTVOLID16(p,v)        fat_putuint32(UBYTE_PTR(p,BS16_VOLID),v)
-#define MBR_PUTVOLID32(p,v)        fat_putuint32(UBYTE_PTR(p,BS32_VOLID),v)
-
-/* But for multi-byte values, the endian-ness of the target vs. the little
- * endian order of the byte stream or alignment of the data within the byte
- * stream can force special, byte-by-byte accesses.
- */
-
-#ifdef CONFIG_ENDIAN_BIG
-
-/* If the target is big-endian, then even aligned multi-byte values must be
- * accessed byte-by-byte.
- */
-
-# define MBR_GETRESVDSECCOUNT(p)   fat_getuint16(UBYTE_PTR(p,BS_RESVDSECCOUNT))
-# define MBR_GETFATSZ16(p)         fat_getuint16(UBYTE_PTR(p,BS_FATSZ16))
-# define MBR_GETSECPERTRK(p)       fat_getuint16(UBYTE_PTR(p,BS_SECPERTRK))
-# define MBR_GETNUMHEADS(p)        fat_getuint16(UBYTE_PTR(p,BS_NUMHEADS))
-# define MBR_GETHIDSEC(p)          fat_getuint32(UBYTE_PTR(p,BS_HIDSEC))
-# define MBR_GETTOTSEC32(p)        fat_getuint32(UBYTE_PTR(p,BS_TOTSEC32))
-# define MBR_GETFATSZ32(p)         fat_getuint32(UBYTE_PTR(p,BS32_FATSZ32))
-# define MBR_GETEXTFLAGS(p)        fat_getuint16(UBYTE_PTR(p,BS32_EXTFLAGS))
-# define MBR_GETFSVER(p)           fat_getuint16(UBYTE_PTR(p,BS32_FSVER))
-# define MBR_GETROOTCLUS(p)        fat_getuint32(UBYTE_PTR(p,BS32_ROOTCLUS))
-# define MBR_GETFSINFO(p)          fat_getuint16(UBYTE_PTR(p,BS32_FSINFO))
-# define MBR_GETBKBOOTSEC(p)       fat_getuint16(UBYTE_PTR(p,BS32_BKBOOTSEC))
-# define MBR_GETSIGNATURE(p)       fat_getuint16(UBYTE_PTR(p,BS_SIGNATURE))
-
-# define MBR_GETPARTSECTOR(s)      fat_getuint32(s)
-
-# define FSI_GETLEADSIG(p)         fat_getuint32(UBYTE_PTR(p,FSI_LEADSIG))
-# define FSI_GETSTRUCTSIG(p)       fat_getuint32(UBYTE_PTR(p,FSI_STRUCTSIG))
-# define FSI_GETFREECOUNT(p)       fat_getuint32(UBYTE_PTR(p,FSI_FREECOUNT))
-# define FSI_GETNXTFREE(p)         fat_getuint32(UBYTE_PTR(p,FSI_NXTFREE))
-# define FSI_GETTRAILSIG(p)        fat_getuint32(UBYTE_PTR(p,FSI_TRAILSIG))
-
-# define DIR_GETCRTIME(p)          fat_getuint16(UBYTE_PTR(p,DIR_CRTIME))
-# define DIR_GETCRDATE(p)          fat_getuint16(UBYTE_PTR(p,DIR_CRDATE))
-# define DIR_GETLASTACCDATE(p)     fat_getuint16(UBYTE_PTR(p,DIR_LASTACCDATE))
-# define DIR_GETFSTCLUSTHI(p)      fat_getuint16(UBYTE_PTR(p,DIR_FSTCLUSTHI))
-# define DIR_GETWRTTIME(p)         fat_getuint16(UBYTE_PTR(p,DIR_WRTTIME))
-# define DIR_GETWRTDATE(p)         fat_getuint16(UBYTE_PTR(p,DIR_WRTDATE))
-# define DIR_GETFSTCLUSTLO(p)      fat_getuint16(UBYTE_PTR(p,DIR_FSTCLUSTLO))
-# define DIR_GETFILESIZE(p)        fat_getuint32(UBYTE_PTR(p,DIR_FILESIZE))
-
-# define FSI_GETLEADSIG(p)         fat_getuint32(UBYTE_PTR(p,FSI_LEADSIG))
-# define FSI_GETSTRUCTSIG(p)       fat_getuint32(UBYTE_PTR(p,FSI_STRUCTSIG))
-# define FSI_GETFREECOUNT(p)       fat_getuint32(UBYTE_PTR(p,FSI_FREECOUNT))
-# define FSI_GETNXTFREE(p)         fat_getuint32(UBYTE_PTR(p,FSI_NXTFREE))
-# define FSI_GETTRAILSIG(p)        fat_getuint32(UBYTE_PTR(p,FSI_TRAILSIG))
-
-# define FAT_GETFAT16(p,i)         fat_getuint16(UBYTE_PTR(p,i))
-# define FAT_GETFAT32(p,i)         fat_getuint32(UBYTE_PTR(p,i))
-
-# define MBR_PUTRESVDSECCOUNT(p,v) fat_putuint16(UBYTE_PTR(p,BS_RESVDSECCOUNT,v))
-# define MBR_PUTFATSZ16(p,v)       fat_putuint16(UBYTE_PTR(p,BS_FATSZ16,v))
-# define MBR_PUTSECPERTRK(p,v)     fat_putuint16(UBYTE_PTR(p,BS_SECPERTRK,v))
-# define MBR_PUTNUMHEADS(p,v)      fat_putuint16(UBYTE_PTR(p,BS_NUMHEADS,v))
-# define MBR_PUTHIDSEC(p,v)        fat_putuint32(UBYTE_PTR(p,BS_HIDSEC,v))
-# define MBR_PUTTOTSEC32(p,v)      fat_putuint32(UBYTE_PTR(p,BS_TOTSEC32,v))
-# define MBR_PUTFATSZ32(p,v)       fat_putuint32(UBYTE_PTR(p,BS32_FATSZ32,v))
-# define MBR_PUTEXTFLAGS(p,v)      fat_putuint16(UBYTE_PTR(p,BS32_EXTFLAGS,v))
-# define MBR_PUTFSVER(p,v)         fat_putuint16(UBYTE_PTR(p,BS32_FSVER,v))
-# define MBR_PUTROOTCLUS(p,v)      fat_putuint32(UBYTE_PTR(p,BS32_ROOTCLUS,v))
-# define MBR_PUTFSINFO(p,v)        fat_putuint16(UBYTE_PTR(p,BS32_FSINFO,v))
-# define MBR_PUTBKBOOTSEC(p,v)     fat_putuint16(UBYTE_PTR(p,BS32_BKBOOTSEC,v))
-# define MBR_PUTSIGNATURE(p,v)     fat_getuint16(UBYTE_PTR(p,BS_SIGNATURE),v)
-
-# define FSI_PUTLEADSIG(p,v)       fat_putuint32(UBYTE_PTR(p,FSI_LEADSIG),v)
-# define FSI_PUTSTRUCTSIG(p,v)     fat_putuint32(UBYTE_PTR(p,FSI_STRUCTSIG),v)
-# define FSI_PUTFREECOUNT(p,v)     fat_putuint32(UBYTE_PTR(p,FSI_FREECOUNT),v)
-# define FSI_PUTNXTFREE(p,v)       fat_putuint32(UBYTE_PTR(p,FSI_NXTFREE),v)
-# define FSI_PUTTRAILSIG(p,v)      fat_putuint32(UBYTE_PTR(p,FSI_TRAILSIG),v)
-
-# define DIR_PUTCRTIME(p,v)        fat_putuint16(UBYTE_PTR(p,DIR_CRTIME),v)
-# define DIR_PUTCRDATE(p,v)        fat_putuint16(UBYTE_PTR(p,DIR_CRDATE),v)
-# define DIR_PUTLASTACCDATE(p,v)   fat_putuint16(UBYTE_PTR(p,DIR_LASTACCDATE),v)
-# define DIR_PUTFSTCLUSTHI(p,v)    fat_putuint16(UBYTE_PTR(p,DIR_FSTCLUSTHI),v)
-# define DIR_PUTWRTTIME(p,v)       fat_putuint16(UBYTE_PTR(p,DIR_WRTTIME),v)
-# define DIR_PUTWRTDATE(p,v)       fat_putuint16(UBYTE_PTR(p,DIR_WRTDATE),v)
-# define DIR_PUTFSTCLUSTLO(p,v)    fat_putuint16(UBYTE_PTR(p,DIR_FSTCLUSTLO),v)
-# define DIR_PUTFILESIZE(p,v)      fat_putuint32(UBYTE_PTR(p,DIR_FILESIZE),v)
-
-# define FSI_PUTLEADSIG(p,v)       fat_putuint32(UBYTE_PTR(p,FSI_LEADSIG),v)
-# define FSI_PUTSTRUCTSIG(p,v)     fat_putuint32(UBYTE_PTR(p,FSI_STRUCTSIG),v)
-# define FSI_PUTFREECOUNT(p,v)     fat_putuint32(UBYTE_PTR(p,FSI_FREECOUNT),v)
-# define FSI_PUTNXTFREE(p,v)       fat_putuint32(UBYTE_PTR(p,FSI_NXTFREE),v)
-# define FSI_PUTTRAILSIG(p,v)      fat_putuint32(UBYTE_PTR(p,FSI_TRAILSIG),v)
-
-# define FAT_PUTFAT16(p,i,v)       fat_putuint16(UBYTE_PTR(p,i),v)
-# define FAT_PUTFAT32(p,i,v)       fat_putuint32(UBYTE_PTR(p,i),v)
-
-#else
-
-/* But nothing special has to be done for the little endian-case for access
- * to aligned mulitbyte values.
- */
-
-# define MBR_GETRESVDSECCOUNT(p)   UINT16_VAL(p,BS_RESVDSECCOUNT)
-# define MBR_GETFATSZ16(p)         UINT16_VAL(p,BS_FATSZ16)
-# define MBR_GETSECPERTRK(p)       UINT16_VAL(p,BS_SECPERTRK)
-# define MBR_GETNUMHEADS(p)        UINT16_VAL(p,BS_NUMHEADS)
-# define MBR_GETHIDSEC(p)          UINT32_VAL(p,BS_HIDSEC)
-# define MBR_GETTOTSEC32(p)        UINT32_VAL(p,BS_TOTSEC32)
-# define MBR_GETFATSZ32(p)         UINT32_VAL(p,BS32_FATSZ32)
-# define MBR_GETEXTFLAGS(p)        UINT16_VAL(p,BS32_EXTFLAGS)
-# define MBR_GETFSVER(p)           UINT16_VAL(p,BS32_FSVER)
-# define MBR_GETROOTCLUS(p)        UINT32_VAL(p,BS32_ROOTCLUS)
-# define MBR_GETFSINFO(p)          UINT16_VAL(p,BS32_FSINFO)
-# define MBR_GETBKBOOTSEC(p)       UINT16_VAL(p,BS32_BKBOOTSEC)
-# define MBR_GETSIGNATURE(p)       UINT16_VAL(p,BS_SIGNATURE)
-
-# define MBR_GETPARTSECTOR(s)      (*((uint32*)(s)))
-
-# define FSI_GETLEADSIG(p)         UINT32_VAL(p,FSI_LEADSIG)
-# define FSI_GETSTRUCTSIG(p)       UINT32_VAL(p,FSI_STRUCTSIG)
-# define FSI_GETFREECOUNT(p)       UINT32_VAL(p,FSI_FREECOUNT)
-# define FSI_GETNXTFREE(p)         UINT32_VAL(p,FSI_NXTFREE)
-# define FSI_GETTRAILSIG(p)        UINT32_VAL(p,FSI_TRAILSIG)
-
-# define DIR_GETCRTIME(p)          UINT16_VAL(p,DIR_CRTIME)
-# define DIR_GETCRDATE(p)          UINT16_VAL(p,DIR_CRDATE)
-# define DIR_GETLASTACCDATE(p)     UINT16_VAL(p,DIR_LASTACCDATE)
-# define DIR_GETFSTCLUSTHI(p)      UINT16_VAL(p,DIR_FSTCLUSTHI)
-# define DIR_GETWRTTIME(p)         UINT16_VAL(p,DIR_WRTTIME)
-# define DIR_GETWRTDATE(p)         UINT16_VAL(p,DIR_WRTDATE)
-# define DIR_GETFSTCLUSTLO(p)      UINT16_VAL(p,DIR_FSTCLUSTLO)
-# define DIR_GETFILESIZE(p)        UINT32_VAL(p,DIR_FILESIZE)
-
-# define FSI_GETLEADSIG(p)         UINT32_VAL(p,FSI_LEADSIG)
-# define FSI_GETSTRUCTSIG(p)       UINT32_VAL(p,FSI_STRUCTSIG)
-# define FSI_GETFREECOUNT(p)       UINT32_VAL(p,FSI_FREECOUNT)
-# define FSI_GETNXTFREE(p)         UINT32_VAL(p,FSI_NXTFREE)
-# define FSI_GETTRAILSIG(p)        UINT32_VAL(p,FSI_TRAILSIG)
-
-# define FAT_GETFAT16(p,i)         UINT16_VAL(p,i)
-# define FAT_GETFAT32(p,i)         UINT32_VAL(p,i)
-
-# define MBR_PUTRESVDSECCOUNT(p,v) UINT16_PUT(p,BS_RESVDSECCOUNT,v)
-# define MBR_PUTFATSZ16(p,v)       UINT16_PUT(p,BS_FATSZ16,v)
-# define MBR_PUTSECPERTRK(p,v)     UINT16_PUT(p,BS_SECPERTRK,v)
-# define MBR_PUTNUMHEADS(p,v)      UINT16_PUT(p,BS_NUMHEADS,v)
-# define MBR_PUTHIDSEC(p,v)        UINT32_PUT(p,BS_HIDSEC,v)
-# define MBR_PUTTOTSEC32(p,v)      UINT32_PUT(p,BS_TOTSEC32,v)
-# define MBR_PUTFATSZ32(p,v)       UINT32_PUT(p,BS32_FATSZ32,v)
-# define MBR_PUTEXTFLAGS(p,v)      UINT16_PUT(p,BS32_EXTFLAGS,v)
-# define MBR_PUTFSVER(p,v)         UINT16_PUT(p,BS32_FSVER,v)
-# define MBR_PUTROOTCLUS(p,v)      UINT32_PUT(p,BS32_ROOTCLUS,v)
-# define MBR_PUTFSINFO(p,v)        UINT16_PUT(p,BS32_FSINFO,v)
-# define MBR_PUTBKBOOTSEC(p,v)     UINT16_PUT(p,BS32_BKBOOTSEC,v)
-# define MBR_PUTSIGNATURE(p,v)     UINT16_PUT(p,BS_SIGNATURE,v)
-
-# define FSI_PUTLEADSIG(p,v)       UINT32_PUT(p,FSI_LEADSIG,v)
-# define FSI_PUTSTRUCTSIG(p,v)     UINT32_PUT(p,FSI_STRUCTSIG,v)
-# define FSI_PUTFREECOUNT(p,v)     UINT32_PUT(p,FSI_FREECOUNT,v)
-# define FSI_PUTNXTFREE(p,v)       UINT32_PUT(p,FSI_NXTFREE,v)
-# define FSI_PUTTRAILSIG(p,v)      UINT32_PUT(p,FSI_TRAILSIG,v)
-
-# define DIR_PUTCRTIME(p,v)        UINT16_PUT(p,DIR_CRTIME,v)
-# define DIR_PUTCRDATE(p,v)        UINT16_PUT(p,DIR_CRDATE,v)
-# define DIR_PUTLASTACCDATE(p,v)   UINT16_PUT(p,DIR_LASTACCDATE,v)
-# define DIR_PUTFSTCLUSTHI(p,v)    UINT16_PUT(p,DIR_FSTCLUSTHI,v)
-# define DIR_PUTWRTTIME(p,v)       UINT16_PUT(p,DIR_WRTTIME,v)
-# define DIR_PUTWRTDATE(p,v)       UINT16_PUT(p,DIR_WRTDATE,v)
-# define DIR_PUTFSTCLUSTLO(p,v)    UINT16_PUT(p,DIR_FSTCLUSTLO,v)
-# define DIR_PUTFILESIZE(p,v)      UINT32_PUT(p,DIR_FILESIZE,v)
-
-# define FSI_PUTLEADSIG(p,v)       UINT32_PUT(p,FSI_LEADSIG,v)
-# define FSI_PUTSTRUCTSIG(p,v)     UINT32_PUT(p,FSI_STRUCTSIG,v)
-# define FSI_PUTFREECOUNT(p,v)     UINT32_PUT(p,FSI_FREECOUNT,v)
-# define FSI_PUTNXTFREE(p,v)       UINT32_PUT(p,FSI_NXTFREE,v)
-# define FSI_PUTTRAILSIG(p,v)      UINT32_PUT(p,FSI_TRAILSIG,v)
-
-# define FAT_PUTFAT16(p,i,v)       UINT16_PUT(p,i,v)
-# define FAT_PUTFAT32(p,i,v)       UINT32_PUT(p,i,v)
-
-#endif
-
-/****************************************************************************
- * Public Types
- ****************************************************************************/
-
-/* This structure represents the overall mountpoint state.  An instance of this
- * structure is retained as inode private data on each mountpoint that is
- * mounted with a fat32 filesystem.
- */
-
-struct fat_file_s;
-struct fat_mountpt_s
-{
-  struct inode      *fs_blkdriver; /* The block driver inode that hosts the FAT32 fs */
-  struct fat_file_s *fs_head;      /* A list to all files opened on this mountpoint */
-
-  sem_t    fs_sem;                 /* Used to assume thread-safe access */
-  size_t   fs_hwsectorsize;        /* HW: Sector size reported by block driver*/
-  size_t   fs_hwnsectors;          /* HW: The number of sectors reported by the hardware */
-  size_t   fs_fatbase;             /* Logical block of start of filesystem (past resd sectors) */
-  size_t   fs_rootbase;            /* MBR: Cluster no. of 1st cluster of root dir */
-  size_t   fs_database;            /* Logical block of start data sectors */
-  size_t   fs_fsinfo;              /* MBR: Sector number of FSINFO sector */
-  size_t   fs_currentsector;       /* The sector number buffered in fs_buffer */
-  uint32   fs_nclusters;           /* Maximum number of data clusters */
-  uint32   fs_fatsize;             /* MBR: Count of sectors occupied by one fat */
-  uint32   fs_fattotsec;           /* MBR: Total count of sectors on the volume */
-  uint32   fs_fsifreecount;        /* FSI: Last free cluster count on volume */
-  uint32   fs_fsinextfree;         /* FSI: Cluster number of 1st free cluster */
-  uint16   fs_fatresvdseccount;    /* MBR: The total number of reserved sectors */
-  uint16   fs_rootentcnt;          /* MBR: Count of 32-bit root directory entries */
-  boolean  fs_mounted;             /* TRUE: The file system is ready */
-  boolean  fs_dirty;               /* TRUE: fs_buffer is dirty */
-  boolean  fs_fsidirty;            /* TRUE: FSINFO sector must be written to disk */
-  ubyte    fs_type;                /* FSTYPE_FAT12, FSTYPE_FAT16, or FSTYPE_FAT32 */
-  ubyte    fs_fatnumfats;          /* MBR: Number of FATs (probably 2) */
-  ubyte    fs_fatsecperclus;       /* MBR: Sectors per allocation unit: 2**n, n=0..7 */
-  ubyte   *fs_buffer;              /* This is an allocated buffer to hold one sector
-                                    * from the device */
-};
-
-/* This structure represents on open file under the mountpoint.  An instance
- * of this structure is retained as struct file specific information on each
- * opened file.
- */
-
-struct fat_file_s
-{
-  struct fat_file_s *ff_next;      /* Retained in a singly linked list */
-  boolean  ff_open;                /* TRUE: The file is (still) open */
-  ubyte    ff_bflags;              /* The file buffer flags */
-  ubyte    ff_oflags;              /* Flags provided when file was opened */
-  ubyte    ff_sectorsincluster;    /* Sectors remaining in cluster */
-  uint16   ff_dirindex;            /* Index into ff_dirsector to directory entry */
-  uint32   ff_currentcluster;      /* Current cluster being accessed */
-  size_t   ff_dirsector;           /* Sector containing the directory entry */
-  size_t   ff_position;            /* File position for read/write/seek in bytes */
-  size_t   ff_size;                /* Size of the file in bytes */
-  size_t   ff_startcluster;        /* Start cluster of file on media */
-  size_t   ff_currentsector;       /* Current sector in the file buffer */
-  ubyte   *ff_buffer;              /* File buffer (for partial sector accesses) */
-};
-
-/* This structure is used internally for describing directory entries */
-
-struct fat_dirinfo_s
-{
-  ubyte    fd_name[8+3];           /* Filename -- directory format*/
-#ifdef CONFIG_FAT_LCNAMES
-  ubyte    fd_ntflags;             /* NTRes lower case flags */
-#endif
-  struct fs_fatdir_s dir;        /* Used with opendir, readdir, etc. */
-  ubyte   *fd_entry;               /* A pointer to the raw 32-byte entry */
-};
-
-/****************************************************************************
- * Global Variables
- ****************************************************************************/
-
-/****************************************************************************
- * Pulblic Function Prototypes
- ****************************************************************************/
-
-#undef EXTERN
-#if defined(__cplusplus)
-#define EXTERN extern "C"
-extern "C" {
-#else
-#define EXTERN extern
-#endif
-
-/* Utitilies to handle unaligned or byte swapped accesses */
-
-EXTERN uint16 fat_getuint16(ubyte *ptr);
-EXTERN uint32 fat_getuint32(ubyte *ptr);
-EXTERN void   fat_putuint16(ubyte *ptr, uint16 value16);
-EXTERN void   fat_putuint32(ubyte *ptr, uint32 value32);
-
-/* Manage the per-mount semaphore that protects access to shared resources */
-
-EXTERN void   fat_semtake(struct fat_mountpt_s *fs);
-EXTERN void   fat_semgive(struct fat_mountpt_s *fs);
-
-/* Get the current time for FAT creation and write times */
-
-EXTERN uint32 fat_systime2fattime(void);
-EXTERN time_t fat_fattime2systime(uint16 time, uint16 date);
-
-/* Handle hardware interactions for mounting */
-
-EXTERN int    fat_mount(struct fat_mountpt_s *fs, boolean writeable);
-EXTERN int    fat_checkmount(struct fat_mountpt_s *fs);
-
-/* low-level hardware access */
-
-EXTERN int    fat_hwread(struct fat_mountpt_s *fs, ubyte *buffer,
-                         size_t sector, unsigned int nsectors);
-EXTERN int    fat_hwwrite(struct fat_mountpt_s *fs, ubyte *buffer,
-                          size_t sector, unsigned int nsectors);
-
-/* Cluster / cluster chain access helpers */
-
-EXTERN ssize_t fat_cluster2sector(struct fat_mountpt_s *fs,  uint32 cluster );
-EXTERN ssize_t fat_getcluster(struct fat_mountpt_s *fs, uint32 clusterno);
-EXTERN int    fat_putcluster(struct fat_mountpt_s *fs, uint32 clusterno,
-                             size_t startsector);
-EXTERN int    fat_removechain(struct fat_mountpt_s *fs, uint32 cluster);
-EXTERN sint32 fat_extendchain(struct fat_mountpt_s *fs, uint32 cluster);
-
-#define fat_createchain(fs) fat_extendchain(fs, 0)
-
-/* Help for traversing directory trees */
-
-EXTERN int    fat_nextdirentry(struct fat_mountpt_s *fs, struct fs_fatdir_s *dir);
-EXTERN int    fat_finddirentry(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo,
-                               const char *path);
-EXTERN int    fat_allocatedirentry(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo);
-
-EXTERN int    fat_dirname2path(char *path, ubyte *direntry);
-
-/* File creation and removal helpers */
-
-EXTERN int    fat_dirtruncate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo);
-EXTERN int    fat_dircreate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo);
-EXTERN int    fat_remove(struct fat_mountpt_s *fs, const char *relpath, boolean directory);
-
-/* Mountpoint and file buffer cache (for partial sector accesses) */
-
-EXTERN int    fat_fscacheflush(struct fat_mountpt_s *fs);
-EXTERN int    fat_fscacheread(struct fat_mountpt_s *fs, size_t sector);
-EXTERN int    fat_ffcacheflush(struct fat_mountpt_s *fs, struct fat_file_s *ff);
-EXTERN int    fat_ffcacheread(struct fat_mountpt_s *fs, struct fat_file_s *ff, size_t sector);
-EXTERN int    fat_ffcacheinvalidate(struct fat_mountpt_s *fs, struct fat_file_s *ff);
-
-/* FSINFO sector support */
-
-EXTERN int fat_updatefsinfo(struct fat_mountpt_s *fs);
-EXTERN int fat_nfreeclusters(struct fat_mountpt_s *fs, size_t *pfreeclusters);
-
-#undef EXTERN
-#if defined(__cplusplus)
-}
-#endif
-
-#endif /* __FS_FAT32_H */
diff --git a/nuttx/fs/fs_fat32attrib.c b/nuttx/fs/fs_fat32attrib.c
deleted file mode 100644
index 7537fbf98..000000000
--- a/nuttx/fs/fs_fat32attrib.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/************************************************************
- * fs_fat32attrib.c
- *
- *   Copyright (C) 2007 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- * 3. Neither the name Gregory Nutt nor the names of its contributors may be
- *    used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ************************************************************/
-
-/************************************************************
- * Compilation Switches
- ************************************************************/
-
-/************************************************************
- * Included Files
- ************************************************************/
-
-#include <nuttx/config.h>
-#include <sys/types.h>
-#include <errno.h>
-
-#include <nuttx/fs.h>
-#include <nuttx/fat.h>
-
-#include "fs_internal.h"
-#include "fs_fat32.h"
-
-/************************************************************
- * Private Functions
- ************************************************************/
-
-/************************************************************
- * Name: fat_attrib
- ************************************************************/
-
-static int fat_attrib(const char *path, fat_attrib_t *retattrib,
-                      fat_attrib_t setbits, fat_attrib_t clearbits)
-{
-  struct fat_mountpt_s *fs;
-  struct fat_dirinfo_s  dirinfo;
-  FAR struct inode     *inode;
-  const char             *relpath = NULL;
-  ubyte                   oldattributes;
-  ubyte                   newattributes;
-  int                     ret;
-
-  /* Get an inode for this file */
-
-  inode = inode_find(path, &relpath);
-  if (!inode)
-    {
-      /* There is no mountpoint that includes in this path */
-
-      ret = ENOENT;
-      goto errout;
-    }
-
-  /* Verify that the inode is a valid mountpoint. */
-
-  if (!INODE_IS_MOUNTPT(inode) || !inode->u.i_mops || !inode->i_private)
-    {
-      ret = ENXIO;
-      goto errout_with_inode;
-    }
-
-  /* Get the mountpoint private data from the inode structure */
-
-  fs = inode->i_private;
-
-  /* Check if the mount is still healthy */
-
-  fat_semtake(fs);
-  ret = fat_checkmount(fs);
-  if (ret != OK)
-    {
-      goto errout_with_semaphore;
-    }
-
-  /* Find the file/directory entry for the oldrelpath */
-
-  ret = fat_finddirentry(fs, &dirinfo, relpath);
-  if (ret != OK)
-    {
-      /* Some error occurred -- probably -ENOENT */
-
-      goto errout_with_semaphore;
-    }
-
-  /* Make sure that we found some valid file or directory */
-
-  if (!dirinfo.fd_entry)
-    {
-      /* Ooops.. we found the root directory */
-
-      ret = EACCES;
-      goto errout_with_semaphore;
-    }
-
-  /* Get the current attributes */
-
-  oldattributes = DIR_GETATTRIBUTES(dirinfo.fd_entry);
-  newattributes = oldattributes;
-
-  /* Set or clear any bits as requested */
-
-  newattributes &= ~(clearbits & (FATATTR_READONLY|FATATTR_HIDDEN|FATATTR_SYSTEM|FATATTR_ARCHIVE));
-  newattributes |=  (setbits   & (FATATTR_READONLY|FATATTR_HIDDEN|FATATTR_SYSTEM|FATATTR_ARCHIVE));
-
-  /* Did any thingchange? */
-
-  if (newattributes != oldattributes)
-    {
-      DIR_PUTATTRIBUTES(dirinfo.fd_entry, newattributes);
-      fs->fs_dirty = TRUE;
-      ret = fat_updatefsinfo(fs);
-      if (ret != OK)
-        {
-          ret = -ret;
-          goto errout_with_semaphore;
-        }
-    }
-
-  /* Success */
-
-  if (retattrib)
-    {
-      *retattrib = newattributes;
-    }
-
-  fat_semgive(fs);
-  inode_release(inode);
-  return OK;
-
-errout_with_semaphore:
-  fat_semgive(fs);
-errout_with_inode:
-  inode_release(inode);
-errout:
-  *get_errno_ptr() = ret;
-  return ERROR;
-}
-
-/************************************************************
- * Global Functions
- ************************************************************/
-
-/************************************************************
- * Name: fat_getattrib
- ************************************************************/
-
-int fat_getattrib(const char *path, fat_attrib_t *attrib)
-{
-  return fat_attrib(path, attrib, 0, 0);
-}
-
-/************************************************************
- * Name: fat_setattrib
- ************************************************************/
-
-int fat_setattrib(const char *path, fat_attrib_t setbits, fat_attrib_t clearbits)
-{
-  return fat_attrib(path, NULL, setbits, clearbits);
-}
-
diff --git a/nuttx/fs/fs_fat32util.c b/nuttx/fs/fs_fat32util.c
deleted file mode 100644
index 48d1a6e19..000000000
--- a/nuttx/fs/fs_fat32util.c
+++ /dev/null
@@ -1,2445 +0,0 @@
-/****************************************************************************
- * fs_fat32util.c
- *
- *   Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
- *
- * References:
- *   Microsoft FAT documentation
- *   Some good ideas were leveraged from the FAT implementation:
- *     'Copyright (C) 2007, ChaN, all right reserved.'
- *     which has an unrestricted license.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- *    used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/config.h>
-#include <sys/types.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <semaphore.h>
-#include <assert.h>
-#include <errno.h>
-#include <debug.h>
-
-#include <nuttx/fs.h>
-#include <nuttx/fat.h>
-
-#include "fs_internal.h"
-#include "fs_fat32.h"
-
-/****************************************************************************
- * Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/****************************************************************************
- * Private Variables
- ****************************************************************************/
-
-/****************************************************************************
- * Public Variables
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: fat_path2dirname
- *
- * Desciption:  Convert a user filename into a properly formatted FAT
- *   (short) filname as it would appear in a directory entry.  Here are the
- *    rules for the 11 byte name in the directory:
- *
- *   The first byte:
- *   - 0xe5 = The directory is free
- *   - 0x00 = This directory and all following directories are free
- *   - 0x05 = Really 0xe5
- *   - 0x20 = May NOT be ' '
- *
- *   Any bytes
- *     0x00-0x1f = (except for 0x00 and 0x05 in the first byte)
- *     0x22      = '"'
- *     0x2a-0x2c = '*', '+', ','
- *     0x2e-0x2f = '.', '/'
- *     0x3a-0x3f = ':', ';', '<', '=', '>', '?'
- *     0x5b-0x5d = '[', '\\', ;]'
- *     0x7c      = '|'
- *
- *   Upper case characters are not allowed in directory names (without some
- *   poorly documented operatgions on the NTRes directory byte).  Lower case
- *   codes may represent different characters in other character sets ("DOS
- *   code pages".  The logic below does not, at present, support any other
- *   character sets.
- *
- ****************************************************************************/
-
-static inline int fat_path2dirname(const char **path, struct fat_dirinfo_s *dirinfo,
-                                   char *terminator)
-{
-#ifdef CONFIG_FAT_LCNAMES
-    unsigned int ntlcenable = FATNTRES_LCNAME | FATNTRES_LCEXT;
-    unsigned int ntlcfound  = 0;
-#endif
-    const char *node = *path;
-    int endndx;
-    ubyte ch;
-    int ndx = 0;
-
-    /* Initialized the name with all spaces */
-
-    memset(dirinfo->fd_name, ' ', 8+3);
- 
-    /* Loop until the name is successfully parsed or an error occurs */
-
-    endndx  = 8;
-    for (;;)
-      {
-        /* Get the next byte from the path */
-
-        ch = *node++;
-
-        /* Check if this the last byte in this node of the name */
-
-        if ((ch == '\0' || ch == '/') && ndx != 0 )
-          {
-            /* Return the accumulated NT flags and the terminating character */
-#ifdef CONFIG_FAT_LCNAMES
-            dirinfo->fd_ntflags = ntlcfound & ntlcenable;
-#endif
-            *terminator = ch;
-            *path       = node;
-            return OK;
-          }
-
-        /* Accept only the printable character set.  Note the first byte
-         * of the name could be 0x05 meaning that is it 0xe5, but this is
-         * not a printable character in this character in either case.
-         */
-
-        else if (!isgraph(ch))
-          {
-            goto errout;
-          }
-
-        /* Check for transition from name to extension */
-
-        else if (ch == '.')
-          {
-            /* Starting the extension */
-
-            ndx    = 8;
-            endndx = 11;
-            continue;
-          }
-
-        /* Reject printable characters forbidden by FAT */
-
-        else if (ch == '"'  ||  (ch >= '*' && ch <= ',') ||
-                 ch == '.'  ||   ch == '/'               ||
-                (ch >= ':'  &&   ch <= '?')              ||
-                (ch >= '['  &&   ch <= ']')              ||
-                (ch == '|'))
-          {
-            goto errout;
-          }
-
-        /* Check for upper case charaters */
-
-#ifdef CONFIG_FAT_LCNAMES
-        else if (isupper(ch))
-          {
-            /* Some or all of the characters in the name or extension
-             * are upper case. Force all of the characters to be interpreted
-             * as upper case.
-             */
-
-              if ( endndx == 8)
-                {
-                  /* Clear lower case name bit in mask*/
-                  ntlcenable &= FATNTRES_LCNAME;
-                }
-              else
-                {
-                  /* Clear lower case extension in mask */
-                  ntlcenable &= FATNTRES_LCNAME;
-                }
-          }
-#endif
-
-        /* Check for lower case characters */
-
-        else if (islower(ch))
-          {
-            /* Convert the character to upper case */
-
-            ch = toupper(ch);
-
-            /* Some or all of the characters in the name or extension
-             * are lower case.  They can be interpreted as lower case if
-             * only if all of the characters in the name or extension are
-             * lower case.
-             */
-
-#ifdef CONFIG_FAT_LCNAMES
-            if ( endndx == 8)
-              {
-                /* Set lower case name bit */
-                ntlcfound |= FATNTRES_LCNAME;
-              }
-            else
-              {
-                /* Set lower case extension bit */
-                ntlcfound |= FATNTRES_LCNAME;
-              }
-#endif
-          }
-
-        /* Check if the file name exceeds the size permitted (without
-         * long file name support
-         */
-
-        if (ndx >= endndx)
-          {
-            goto errout;
-          }
-
-        /* Save next character in the accumulated name */
-
-        dirinfo->fd_name[ndx++] = ch;
-      }
-
- errout:
-    return -EINVAL;
-}
-
-/****************************************************************************
- * Name: fat_checkfsinfo
- *
- * Desciption: Read the FAT32 FSINFO sector
- *
- ****************************************************************************/
-
-static int fat_checkfsinfo(struct fat_mountpt_s *fs)
-{
-  /* Verify that this is, indeed, an FSINFO sector */
-
-  if (FSI_GETLEADSIG(fs->fs_buffer) == 0x41615252  &&
-      FSI_GETSTRUCTSIG(fs->fs_buffer) == 0x61417272 &&
-      FSI_GETTRAILSIG(fs->fs_buffer) == 0xaa550000)
-    {
-      fs->fs_fsinextfree  = FSI_GETFREECOUNT(fs->fs_buffer);
-      fs->fs_fsifreecount = FSI_GETNXTFREE(fs->fs_buffer);
-      return OK;
-    }
-  return -ENODEV;
-}
-
-/****************************************************************************
- * Name: fat_checkbootrecord
- *
- * Desciption: Read a sector and verify that it is a a FAT boot record.
- *
- ****************************************************************************/
-
-static int fat_checkbootrecord(struct fat_mountpt_s *fs)
-{
-  uint32  ndatasectors;
-  uint32  fatsize;
-  uint16  rootdirsectors = 0;
-  boolean notfat32 = FALSE;
-
-  /* Verify the MBR signature at offset 510 in the sector (true even
-   * if the sector size is greater than 512.  All FAT file systems have
-   * this signature. On a FAT32 volume, the RootEntCount , FatSz16, and
-   * FatSz32 values should always be zero.  The FAT sector size should
-   * match the reported hardware sector size.
-   */
-
-  if (MBR_GETSIGNATURE(fs->fs_buffer) != 0xaa55 ||
-      MBR_GETBYTESPERSEC(fs->fs_buffer) != fs->fs_hwsectorsize)
-    {
-      return -ENODEV;
-    }
-
-  /* Verify the FAT32 file system type. The determination of the file
-   * system type is based on the number of clusters on the volume:  FAT12
-   * volume has < 4085 cluseter, a FAT16 volume has fewer than 65,525
-   * clusters, and any larger is FAT32.
-   *
-   * Get the number of 32-bit directory entries in root directory (zero
-   * for FAT32.
-   */
-
-  fs->fs_rootentcnt = MBR_GETROOTENTCNT(fs->fs_buffer);
-  if (fs->fs_rootentcnt != 0)
-  {
-      notfat32       = TRUE; /* Must be zero for FAT32 */
-      rootdirsectors = (32 * fs->fs_rootentcnt  + fs->fs_hwsectorsize - 1) / fs->fs_hwsectorsize;
-  }
-
-  /* Determine the number of sectors in a FAT. */
-
-  fs->fs_fatsize = MBR_GETFATSZ16(fs->fs_buffer); /* Should be zero */
-  if (fs->fs_fatsize)
-    {
-      notfat32 = TRUE; /* Must be zero for FAT32 */
-    }
-  else
-    {
-      fs->fs_fatsize = MBR_GETFATSZ32(fs->fs_buffer);
-    }
-
-  if (!fs->fs_fatsize || fs->fs_fatsize >= fs->fs_hwnsectors)
-    {
-      return -ENODEV;
-    }
-
-  /* Get the total number of sectors on the volume. */
-
-  fs->fs_fattotsec = MBR_GETTOTSEC16(fs->fs_buffer); /* Should be zero */
-  if (fs->fs_fattotsec)
-    {
-      notfat32 = TRUE; /* Must be zero for FAT32 */
-    }
-  else
-    {
-      fs->fs_fattotsec = MBR_GETTOTSEC32(fs->fs_buffer);
-    }
-
-  if (!fs->fs_fattotsec || fs->fs_fattotsec > fs->fs_hwnsectors)
-    {
-      return -ENODEV;
-    }
-
-  /* Get the total number of reserved sectors */
-
-  fs->fs_fatresvdseccount = MBR_GETRESVDSECCOUNT(fs->fs_buffer);
-  if (fs->fs_fatresvdseccount > fs->fs_hwnsectors)
-    {
-      return -ENODEV;
-    }
-
-  /* Get the number of FATs. This is probably two but could have other values */
-
-  fs->fs_fatnumfats = MBR_GETNUMFATS(fs->fs_buffer);
-  fatsize = fs->fs_fatnumfats * fs->fs_fatsize;
-
-  /* Get the total number of data sectors */
-
-  ndatasectors = fs->fs_fattotsec - fs->fs_fatresvdseccount - fatsize - rootdirsectors;
-  if (ndatasectors > fs->fs_hwnsectors)
-    {
-      return -ENODEV;
-    }
-
-  /* Get the sectors per cluster */
-
-  fs->fs_fatsecperclus = MBR_GETSECPERCLUS(fs->fs_buffer);
-
-  /* Calculate the number of clusters */
-
-  fs->fs_nclusters = ndatasectors / fs->fs_fatsecperclus;
-
-  /* Finally, the test: */
-
-  if (fs->fs_nclusters < 4085)
-    {
-      fs->fs_fsinfo = 0;
-      fs->fs_type   = FSTYPE_FAT12;
-    }
-  else if (fs->fs_nclusters < 65525)
-    {
-      fs->fs_fsinfo = 0;
-      fs->fs_type   = FSTYPE_FAT16;
-    }
-  else if (!notfat32)
-    {
-      fs->fs_fsinfo   = fs->fs_fatbase + MBR_GETFSINFO(fs->fs_buffer);
-      fs->fs_type     = FSTYPE_FAT32;
-    }
-  else
-    {
-      return -ENODEV;
-    }
-
-  /* We have what appears to be a valid FAT filesystem! Save a few more things
-   * from the boot record that we will need later.
-   */
-
-  fs->fs_fatbase     += fs->fs_fatresvdseccount;
-
-  if (fs->fs_type == FSTYPE_FAT32)
-    {
-      fs->fs_rootbase = MBR_GETROOTCLUS(fs->fs_buffer);
-    }
-  else
-    {
-      fs->fs_rootbase = fs->fs_fatbase + fatsize; 
-    }
-
-  fs->fs_database     = fs->fs_fatbase + fatsize + fs->fs_rootentcnt / DIRSEC_NDIRS(fs);
-  fs->fs_fsifreecount = 0xffffffff;
-
-  return OK;
-}
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: fat_getuint16
- ****************************************************************************/
-
-uint16 fat_getuint16(ubyte *ptr)
-{
-#ifdef CONFIG_ENDIAN_BIG
-  /* The bytes always have to be swapped if the target is big-endian */
-
-  return ((uint16)ptr[0] << 8) | ptr[1];
-#else
-  /* Byte-by-byte transfer is still necessary if the address is un-aligned */
-
-  return ((uint16)ptr[1] << 8) | ptr[0];
-#endif
-}
-
-/****************************************************************************
- * Name: fat_getuint32
- ****************************************************************************/
-
-uint32 fat_getuint32(ubyte *ptr)
-{
-#ifdef CONFIG_ENDIAN_BIG
-  /* The bytes always have to be swapped if the target is big-endian */
-
-  return ((uint32)fat_getuint16(&ptr[0]) << 16) | fat_getuint16(&ptr[2]);
-#else
-  /* Byte-by-byte transfer is still necessary if the address is un-aligned */
-
-  return ((uint32)fat_getuint16(&ptr[2]) << 16) | fat_getuint16(&ptr[0]);
-#endif
-}
-
-/****************************************************************************
- * Name: fat_putuint16
- ****************************************************************************/
-
-void fat_putuint16(ubyte *ptr, uint16 value16)
-{
-  ubyte *val = (ubyte*)&value16;
-#ifdef CONFIG_ENDIAN_BIG
-  /* The bytes always have to be swapped if the target is big-endian */
-
-  ptr[0] = val[1];
-  ptr[1] = val[0];
-#else
-  /* Byte-by-byte transfer is still necessary if the address is un-aligned */
-
-  ptr[0] = val[0];
-  ptr[1] = val[1];
-#endif
-}
-
-/****************************************************************************
- * Name: fat_putuint32
- ****************************************************************************/
-
-void fat_putuint32(ubyte *ptr, uint32 value32)
-{
-  uint16 *val = (uint16*)&value32;
-#ifdef CONFIG_ENDIAN_BIG
-  /* The bytes always have to be swapped if the target is big-endian */
-
-  fat_putuint16(&ptr[0], val[2]);
-  fat_putuint16(&ptr[2], val[0]);
-#else
-  /* Byte-by-byte transfer is still necessary if the address is un-aligned */
-
-  fat_putuint16(&ptr[0], val[0]);
-  fat_putuint16(&ptr[2], val[2]);
-#endif
-}
-
-/****************************************************************************
- * Name: fat_semtake
- ****************************************************************************/
-
-void fat_semtake(struct fat_mountpt_s *fs)
-{
-  /* Take the semaphore (perhaps waiting) */
-
-  while (sem_wait(&fs->fs_sem) != 0)
-    {
-      /* The only case that an error should occur here is if
-       * the wait was awakened by a signal.
-       */
-
-      ASSERT(*get_errno_ptr() == EINTR);
-    }
-}
-
-/****************************************************************************
- * Name: fat_semgive
- ****************************************************************************/
-
-void fat_semgive(struct fat_mountpt_s *fs)
-{
-   sem_post(&fs->fs_sem);
-}
-
-/****************************************************************************
- * Name: fat_systime2fattime
- *
- * Desciption: Get the system time convertto a time and and date suitble
- * for writing into the FAT FS.
- *
- *    TIME in LS 16-bits:
- *      Bits 0:4   = 2 second count (0-29 representing 0-58 seconds)
- *      Bits 5-10  = minutes (0-59)
- *      Bits 11-15 = hours (0-23)
- *    DATE in MS 16-bits
- *      Bits 0:4   = Day of month (0-31)
- *      Bits 5:8   = Month of year (1-12)
- *      Bits 9:15  = Year from 1980 (0-127 representing 1980-2107)
- *
- ****************************************************************************/
-
-uint32 fat_systime2fattime(void)
-{
-#warning "Time not implemented"
-    return 0;
-}
-
-/****************************************************************************
- * Name: fat_fattime2systime
- *
- * Desciption: Convert FAT data and time to a system time_t
- *
- *    16-bit FAT time:
- *      Bits 0:4   = 2 second count (0-29 representing 0-58 seconds)
- *      Bits 5-10  = minutes (0-59)
- *      Bits 11-15 = hours (0-23)
- *    16-bit FAT date:
- *      Bits 0:4   = Day of month (0-31)
- *      Bits 5:8   = Month of year (1-12)
- *      Bits 9:15  = Year from 1980 (0-127 representing 1980-2107)
- *
- ****************************************************************************/
-
-time_t fat_fattime2systime(uint16 fattime, uint16 fatdate)
-{
-#warning "Time not implemented"
-    return 0;
-}
-
-/****************************************************************************
- * Name: fat_mount
- *
- * Desciption: This function is called only when the mountpoint is first
- *   established.  It initializes the mountpoint structure and verifies
- *   that a valid FAT32 filesystem is provided by the block driver.
- *
- *   The caller should hold the mountpoint semaphore
- *
- ****************************************************************************/
-
-int fat_mount(struct fat_mountpt_s *fs, boolean writeable)
-{
-  FAR struct inode *inode;
-  struct geometry geo;
-  int ret;
-
-  /* Assume that the mount is successful */
-
-  fs->fs_mounted = TRUE;
-
-  /* Check if there is media available */
-
-  inode = fs->fs_blkdriver;
-  if (!inode || !inode->u.i_bops || !inode->u.i_bops->geometry ||
-      inode->u.i_bops->geometry(inode, &geo) != OK || !geo.geo_available)
-    {
-      ret = -ENODEV;
-      goto errout;
-    }
-
-  /* Make sure that that the media is write-able (if write access is needed) */
-
-  if (writeable && !geo.geo_writeenabled)
-    {
-      ret = -EACCES;
-      goto errout;
-    }
-
-  /* Save the hardware geometry */
-
-  fs->fs_hwsectorsize = geo.geo_sectorsize;
-  fs->fs_hwnsectors   = geo.geo_nsectors;
-
-  /* Allocate a buffer to hold one hardware sector */
-
-  fs->fs_buffer = (ubyte*)malloc(fs->fs_hwsectorsize);
-  if (!fs->fs_buffer)
-    {
-      ret = -ENOMEM;
-      goto errout;
-    }
-
-  /* Search FAT boot record on the drive.  First check at sector zero.  This
-   * could be either the boot record or a partition that refers to the boot
-   * record.
-   *
-   * First read sector zero.  This will be the first access to the drive and a
-   * likely failure point.
-   */
-
-  fs->fs_fatbase = 0;
-  ret = fat_hwread(fs, fs->fs_buffer, 0, 1);
-  if (ret < 0)
-    {
-      goto errout_with_buffer;
-    }
-
-  if (fat_checkbootrecord(fs) != OK)
-    {
-      /* The contents of sector 0 is not a boot record.  It could be a
-       * partition, however.  Assume it is a partition and get the offset
-       * into the partition table.  This table is at offset MBR_TABLE and is
-       * indexed by 16x the partition number.  Here we support only
-       * parition 0.
-       */
-
-      ubyte *partition = &fs->fs_buffer[MBR_TABLE + 0];
-
-      /* Check if the partition exists and, if so, get the bootsector for that
-       * partition and see if we can find the boot record there.
-       */
- 
-      if (partition[4])
-        {
-          /* There appears to be a partition, get the sector number of the
-           * partition (LBA)
-           */
-
-          fs->fs_fatbase = MBR_GETPARTSECTOR(&partition[8]);
-
-          /* Read the new candidate boot sector */
-
-          ret = fat_hwread(fs, fs->fs_buffer, fs->fs_fatbase, 1);
-          if (ret < 0)
-          {
-              goto errout_with_buffer;
-          }
-
-          /* Check if this is a boot record */
-
-          if (fat_checkbootrecord(fs) != OK)
-            {
-              goto errout_with_buffer;
-            }
-        }
-    }
-
-  /* We have what appears to be a valid FAT filesystem! Now read the
-   * FSINFO sector (FAT32 only)
-   */
-
-  if (fs->fs_type == FSTYPE_FAT32)
-  {
-      ret = fat_checkfsinfo(fs);
-      if (ret != OK)
-      {
-          goto errout_with_buffer;
-      }
-  }
-
-  /* We did it! */
-
-  fdbg("FAT%d:\n", fs->fs_type == 0 ? 12 : fs->fs_type == 1  ? 16 : 32);
-  fdbg("\tHW  sector size:     %d\n", fs->fs_hwsectorsize);
-  fdbg("\t    sectors:         %d\n", fs->fs_hwnsectors);
-  fdbg("\tFAT reserved:        %d\n", fs->fs_fatresvdseccount);
-  fdbg("\t    sectors:         %d\n", fs->fs_fattotsec);
-  fdbg("\t    start sector:    %d\n", fs->fs_fatbase);
-  fdbg("\t    root sector:     %d\n", fs->fs_rootbase);
-  fdbg("\t    root entries:    %d\n", fs->fs_rootentcnt);
-  fdbg("\t    data sector:     %d\n", fs->fs_database);
-  fdbg("\t    FSINFO sector:   %d\n", fs->fs_fsinfo);
-  fdbg("\t    Num FATs:        %d\n", fs->fs_fatnumfats);
-  fdbg("\t    FAT size:        %d\n", fs->fs_fatsize);
-  fdbg("\t    sectors/cluster: %d\n", fs->fs_fatsecperclus);
-  fdbg("\t    max clusters:    %d\n", fs->fs_nclusters);
-  fdbg("\tFSI free count       %d\n", fs->fs_fsifreecount);
-  fdbg("\t    next free        %d\n", fs->fs_fsinextfree);
-
-  return OK;
-
- errout_with_buffer:
-  free(fs->fs_buffer);
-  fs->fs_buffer = 0;
- errout:
-  fs->fs_mounted = FALSE;
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_checkmount
- *
- * Desciption: Check if the mountpoint is still valid.
- *
- *   The caller should hold the mountpoint semaphore
- *
- ****************************************************************************/
-
-int fat_checkmount(struct fat_mountpt_s *fs)
-{
-  /* If the fs_mounted flag is FALSE, then we have already handled the loss
-   * of the mount.
-   */
-
-  if (fs && fs->fs_mounted)
-    {
-      struct fat_file_s *file;
-
-      /* We still think the mount is healthy.  Check an see if this is
-       * still the case
-       */
-
-      if (fs->fs_blkdriver)
-        {
-          struct inode *inode = fs->fs_blkdriver;
-          if (inode && inode->u.i_bops && inode->u.i_bops->geometry)
-            {
-              struct geometry geo;
-              int errcode = inode->u.i_bops->geometry(inode, &geo);
-              if (errcode == OK && geo.geo_available && !geo.geo_mediachanged)
-                {
-                  return OK;
-                }
-            }
-        }
-
-      /* If we get here, the mount is NOT healthy */
-
-      fs->fs_mounted = FALSE;
-
-      /* Make sure that this is flagged in every opened file */
-
-      for (file = fs->fs_head; file; file = file->ff_next)
-        {
-          file->ff_open = FALSE;
-        }
-    }
-  return -ENODEV;
-}
-
-/****************************************************************************
- * Name: fat_hwread
- *
- * Desciption: Read the specified sector into the sector buffer
- *
- ****************************************************************************/
-
-int fat_hwread(struct fat_mountpt_s *fs, ubyte *buffer,  size_t sector,
-               unsigned int nsectors)
-{
-  int ret = -ENODEV;
-  if (fs && fs->fs_blkdriver )
-    {
-      struct inode *inode = fs->fs_blkdriver;
-      if (inode && inode->u.i_bops && inode->u.i_bops->read)
-        {
-          ssize_t nSectorsRead = inode->u.i_bops->read(inode, buffer,
-                                                       sector, nsectors);
-          if (nSectorsRead == nsectors)
-            {
-              ret = OK;
-            }
-          else if (nSectorsRead < 0)
-            {
-              ret = nSectorsRead;
-            }
-        }
-    }
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_hwwrite
- *
- * Desciption: Write the sector buffer to the specified sector
- *
- ****************************************************************************/
-
-int fat_hwwrite(struct fat_mountpt_s *fs, ubyte *buffer, size_t sector,
-                unsigned int nsectors)
-{
-  int ret = -ENODEV;
-  if (fs && fs->fs_blkdriver )
-    {
-      struct inode *inode = fs->fs_blkdriver;
-      if (inode && inode->u.i_bops && inode->u.i_bops->write)
-        {
-          ssize_t nSectorsWritten =
-              inode->u.i_bops->write(inode, buffer, sector, nsectors);
-
-          if (nSectorsWritten == nsectors)
-            {
-              ret = OK;
-            }
-          else if (nSectorsWritten < 0)
-            {
-              ret = nSectorsWritten;
-            }
-        }
-    }
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_cluster2sector
- *
- * Desciption: Convert a cluster number to a start sector number
- *
- ****************************************************************************/
-
-ssize_t fat_cluster2sector(struct fat_mountpt_s *fs,  uint32 cluster )
-{
-  cluster -= 2;
-  if (cluster >= fs->fs_nclusters - 2)
-    {
-       return -EINVAL;
-    }
-  return cluster * fs->fs_fatsecperclus + fs->fs_database;
-}
-
-/****************************************************************************
- * Name: fat_getcluster
- *
- * Desciption: Get the cluster start sector into the FAT.
- *
- * Return:  <0: error, 0:cluster unassigned, >=0: start sector of cluster
- *
- ****************************************************************************/
-
-ssize_t fat_getcluster(struct fat_mountpt_s *fs, uint32 clusterno)
-{
-  /* Verify that the cluster number is within range */
-
-  if (clusterno >= 2 && clusterno < fs->fs_nclusters)
-    {
-      /* Okay.. Read the next cluster from the FAT.  The way we will do
-       * this depends on the type of FAT filesystm we are dealing with.
-       */
-
-      switch (fs->fs_type)
-        {
-          case FSTYPE_FAT12 :
-            {
-              size_t       fatsector;
-              unsigned int fatoffset;
-              unsigned int startsector;
-              unsigned int fatindex;
-
-              /* FAT12 is more complex because it has 12-bits (1.5 bytes)
-               * per FAT entry. Get the offset to the first byte:
-               */
-
-              fatoffset = (clusterno * 3) / 2;
-              fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-
-              /* Read the sector at this offset */
-
-              if (fat_fscacheread(fs, fatsector) < 0)
-                {
-                  /* Read error */
-                  break;
-                }
-
-              /* Get the first, LS byte of the cluster from the FAT */
-
-              fatindex    = fatoffset & SEC_NDXMASK(fs);
-              startsector = fs->fs_buffer[fatindex];
-
-              /* With FAT12, the second byte of the cluster number may lie in
-               * a different sector than the first byte.
-               */
-
-              fatindex++;
-              if (fatindex >= fs->fs_hwsectorsize)
-                {
-                  fatsector++;
-                  fatindex = 0;
-
-                  if (fat_fscacheread(fs, fatsector) < 0)
-                    {
-                      /* Read error */
-                      break;
-                    }
-                }
-
-              /* Get the second, MS byte of the cluster for 16-bits.  The
-               * does not depend on the endian-ness of the target, but only
-               * on the fact that the byte stream is little-endian.
-               */
-
-              startsector |= (unsigned int)fs->fs_buffer[fatindex] << 8;
-
-              /* Now, pick out the correct 12 bit cluster start sector value */
-
-              if ((clusterno & 1) != 0)
-                {
-                  /* Odd.. take the MS 12-bits */
-                  startsector >>= 4;
-                }
-              else
-                {
-                  /* Even.. take the LS 12-bits */
-                  startsector &= 0x0fff;
-                }
-              return startsector;
-            }
-
-          case FSTYPE_FAT16 :
-            {
-              unsigned int fatoffset = 2 * clusterno;
-              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
-
-              if (fat_fscacheread(fs, fatsector) < 0)
-                {
-                  /* Read error */
-                  break;
-                }
-              return FAT_GETFAT16(fs->fs_buffer, fatindex);
-            }
-
-          case FSTYPE_FAT32 :
-            {
-              unsigned int fatoffset = 4 * clusterno;
-              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
-
-              if (fat_fscacheread(fs, fatsector) < 0)
-                {
-                  /* Read error */
-                  break;
-                }
-              return FAT_GETFAT16(fs->fs_buffer, fatindex) & 0x0fffffff;
-            }
-          default:
-              break;
-        }
-    }
-
-  /* There is no cluster information, or an error occured */
-
-  return (ssize_t)-EINVAL;
-}
-
-/****************************************************************************
- * Name: fat_putcluster
- *
- * Desciption: Write a new cluster start sector into the FAT
- *
- ****************************************************************************/
-
-int fat_putcluster(struct fat_mountpt_s *fs, uint32 clusterno, size_t startsector)
-{
-  /* Verify that the cluster number is within range.  Zero erases the cluster. */
-
-  if (clusterno == 0 || (clusterno >= 2 && clusterno < fs->fs_nclusters))
-    {
-      /* Okay.. Write the next cluster into the FAT.  The way we will do
-       * this depends on the type of FAT filesystm we are dealing with.
-       */
-
-      switch (fs->fs_type)
-        {
-          case FSTYPE_FAT12 :
-            {
-              size_t       fatsector;
-              unsigned int fatoffset;
-              unsigned int fatindex;
-              ubyte        value;
-
-              /* FAT12 is more complex because it has 12-bits (1.5 bytes)
-               * per FAT entry. Get the offset to the first byte:
-               */
-
-              fatoffset = (clusterno * 3) / 2;
-              fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-
-              /* Make sure that the sector at this offset is in the cache */
-
-              if (fat_fscacheread(fs, fatsector)< 0)
-                {
-                  /* Read error */
-                  break;
-                }
-
-              /* Output the LS byte first handling the 12-bit alignment within
-               * the 16-bits
-               */
-
-              fatindex = fatoffset & SEC_NDXMASK(fs);
-              if ((clusterno & 1) != 0)
-                {
-                  value = (fs->fs_buffer[fatindex] & 0x0f) | startsector << 4;
-                }
-              else
-                {
-                  value = (ubyte)startsector;
-                }
-              fs->fs_buffer[fatindex] = value;
-
-              /* With FAT12, the second byte of the cluster number may lie in
-               * a different sector than the first byte.
-               */
-
-              fatindex++;
-              if (fatindex >= fs->fs_hwsectorsize)
-                {
-                  /* Read the next sector */
-
-                  fatsector++;
-                  fatindex = 0;
-
-                  /* Set the dirty flag to make sure the sector that we
-                   * just modified is written out.
-                   */
-
-                  fs->fs_dirty = TRUE;
-                  if (fat_fscacheread(fs, fatsector) < 0)
-                    {
-                      /* Read error */
-                      break;
-                    }
-                }
-
-              /* Output the MS byte first handling the 12-bit alignment within
-               * the 16-bits
-               */
-
-              if ((clusterno & 1) != 0)
-                {
-                  value = (ubyte)(startsector >> 4);
-                }
-              else
-                {
-                  value = (fs->fs_buffer[fatindex] & 0xf0) | (startsector & 0x0f);
-                }
-              fs->fs_buffer[fatindex] = value;
-            }
-          break;
-
-          case FSTYPE_FAT16 :
-            {
-              unsigned int fatoffset = 2 * clusterno;
-              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
-
-              if (fat_fscacheread(fs, fatsector) < 0)
-                {
-                  /* Read error */
-                  break;
-                }
-              FAT_PUTFAT16(fs->fs_buffer, fatindex, startsector & 0xffff);
-            }
-          break;
-
-          case FSTYPE_FAT32 :
-            {
-              unsigned int fatoffset = 4 * clusterno;
-              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
-
-              if (fat_fscacheread(fs, fatsector) < 0)
-                {
-                  /* Read error */
-                  break;
-                }
-              FAT_PUTFAT32(fs->fs_buffer, fatindex, startsector & 0x0fffffff);
-            }
-          break;
-
-          default:
-              return -EINVAL;
-        }
-
-      /* Mark the modified sector as "dirty" and return success */
-
-      fs->fs_dirty = 1;
-      return OK;
-    }
-
-  return -EINVAL;
-}
-
-/****************************************************************************
- * Name: fat_removechain
- *
- * Desciption: Remove an entire chain of clusters, starting with 'cluster'
- *
- ****************************************************************************/
-
-int fat_removechain(struct fat_mountpt_s *fs, uint32 cluster)
-{
-  sint32 nextcluster;
-  int    ret;
-
-  /* Loop while there are clusters in the chain */
-
-  while (cluster >= 2 && cluster < fs->fs_nclusters)
-    {
-      /* Get the next cluster after the current one */
-
-      nextcluster = fat_getcluster(fs, cluster);
-      if (nextcluster < 0)
-        {
-          /* Error! */
-          return nextcluster;
-        }
-
-      /* Then nullify current cluster -- removing it from the chain */
-
-      ret = fat_putcluster(fs, cluster, 0);
-      if (ret < 0)
-        {
-          return ret;
-        }
-
-      /* Update FSINFINFO data */
-
-      if (fs->fs_fsifreecount != 0xffffffff)
-        {
-          fs->fs_fsifreecount++;
-          fs->fs_fsidirty = 1;
-        }
-
-      /* Then set up to remove the next cluster */
-
-      cluster = nextcluster;
-  }
-
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_extendchain
- *
- * Desciption: Add a new cluster to the chain following cluster (if cluster
- *   is non-NULL).  if cluster is zero, then a new chain is created.
- *
- * Return: <0:error, 0: no free cluster, >=2: new cluster number
- *
- ****************************************************************************/
-
-sint32 fat_extendchain(struct fat_mountpt_s *fs, uint32 cluster)
-{
-  ssize_t startsector;
-  uint32  newcluster;
-  uint32  startcluster;
-  int     ret;
-
-  /* The special value 0 is used when the new chain should start */
-
-  if (cluster == 0)
-    {
-      /* The FSINFO NextFree entry should be a good starting point
-       * in the search for a new cluster
-       */
-
-      startcluster = fs->fs_fsinextfree;
-      if (startcluster == 0 || startcluster >= fs->fs_nclusters)
-        {
-          /* But it is bad.. we have to start at the beginning */
-          startcluster = 1;
-        }
-    }
-  else
-    {
-      /* We are extending an existing chain. Verify that this
-       * is a valid cluster by examining its start sector.
-       */
-
-      startsector = fat_getcluster(fs, cluster);
-      if (startsector < 0)
-        {
-          /* An error occurred, return the error value */
-          return startsector;
-        }
-      else if (startsector < 2)
-        {
-          /* Oops.. this cluster does not exist. */
-          return 0;
-        }
-      else if (startsector < fs->fs_nclusters)
-        {
-          /* It is already followed by next cluster */
-          return startsector;
-        }
-
-      /* Okay.. it checks out */
-
-      startcluster = cluster;
-    }
-
-  /* Loop until (1) we discover that there are not free clusters
-   * (return 0), an errors occurs (return -errno), or (3) we find
-   * the next cluster (return the new cluster number).
-   */
-
-  newcluster = startcluster;
-  for (;;)
-    {
-      /* Examine the next cluster in the FAT */
-
-      newcluster++;
-      if (newcluster >= fs->fs_nclusters)
-        {
-          /* If we hit the end of the available clusters, then
-           * wrap back to the beginning because we might have
-           * started at a non-optimal place.  But don't continue
-           * past the start cluster.
-           */
-
-          newcluster = 2;
-          if (newcluster > startcluster)
-            {
-              /* We are back past the starting cluster, then there
-               * is no free cluster.
-               */
-
-              return 0;
-            }
-        }
-
-      /* We have a candidate cluster.  Check if the cluster number is
-       * mapped to a group of sectors.
-       */
-
-      startsector = fat_getcluster(fs, newcluster);
-      if (startsector == 0)
-        {
-          /* Found have found a free cluster break out*/
-          break;
-        }
-      else if (startsector < 0)
-        {
-          /* Some error occurred, return the error number */
-          return startsector;
-        }
-
-      /* We wrap all the back to the starting cluster?  If so, then
-       * there are no free clusters.
-       */
-
-      if (newcluster == startcluster)
-        {
-          return 0;
-        }
-    }
-
-  /* We get here only if we break out with an available cluster
-   * number in 'newcluster'  Now mark that cluster as in-use.
-   */
-
-  ret = fat_putcluster(fs, newcluster, 0x0fffffff);
-  if (ret < 0)
-    {
-      /* An error occurred */ 
-      return ret;
-    }
-
-  /* And link if to the start cluster (if any)*/
-
-  if (cluster)
-    {
-      /* There is a start cluster -- link it */
-
-      ret = fat_putcluster(fs, cluster, newcluster);
-      if (ret < 0)
-        {
-          return ret;
-        }
-    }
-
-  /* And update the FINSINFO for the next time we have to search */
-
-  fs->fs_fsinextfree = newcluster;
-  if (fs->fs_fsifreecount != 0xffffffff)
-    {
-      fs->fs_fsifreecount--;
-      fs->fs_fsidirty = 1;
-    }
-
-  /* Return then number of the new cluster that was added to the chain */
-
-  return newcluster;
-}
-
-/****************************************************************************
- * Name: fat_nextdirentry
- *
- * Desciption: Read the next directory entry from the sector in cache,
- *   reading the next sector(s) in the cluster as necessary.
- *
- ****************************************************************************/
-
-int fat_nextdirentry(struct fat_mountpt_s *fs, struct fs_fatdir_s *dir)
-{
-  unsigned int cluster;
-  unsigned int ndx;
-
-  /* Increment the index to the next 32-byte directory entry */
-
-  ndx = dir->fd_index + 1;
-
-  /* Check if all of the directory entries in this sectory have
-   * been examined.
-   */
-
-  if ((ndx & (DIRSEC_NDIRS(fs)-1)) == 0)
-    {
-      /* Yes, then we will have to read the next sector */
-
-      dir->fd_currsector++;
-
-      /* For FAT12/16, the root directory is a group of sectors relative
-       * to the first sector of the fat volume.
-       */
-
-      if (!dir->fd_currcluster)
-        {
-          /* For FAT12/16, the boot record tells us number of 32-bit directories
-           * that are contained in the root directory.  This should correspond to
-           * an even number of sectors.
-           */
-
-          if (ndx >= fs->fs_rootentcnt)
-            {
-              /* When we index past this count, we have examined all of the entries in
-               * the root directory.
-               */
-
-              return ERROR;
-            }
-        }
-      else
-        {
-          /* Not a FAT12/16 root directory, check if we have examined the entire
-           * cluster comprising the directory.
-           *
-           * The current sector within the cluster is the entry number divided
-           * byte the number of entries per sector
-           */
-
-          int sector = ndx / DIRSEC_NDIRS(fs);
-
-          /* We are finished with the cluster when the last sector of the cluster
-           * has been examined.
-           */
-
-          if ((sector & (fs->fs_fatsecperclus-1)) == 0)
-            {
-              /* Get next cluster */
-
-              cluster = fat_getcluster(fs, dir->fd_currcluster);
-
-              /* Check if a valid cluster was obtained. */
-
-              if (cluster < 2 || cluster >= fs->fs_nclusters)
-                {
-                  /* No, we have probably reached the end of the cluster list */
-                  return ERROR;
-                }
-
-              /* Initialize for new cluster */
-
-              dir->fd_currcluster = cluster;
-              dir->fd_currsector  = fat_cluster2sector(fs, cluster);
-            }
-        }
-    }
-
-  /* Save the new index into dir->fd_currsector */
-
-  dir->fd_index = ndx;
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_finddirentry
- *
- * Desciption: Given a path to something that may or may not be in the file
- *   system, return the directory entry of the item.
- *
- ****************************************************************************/
-
-int fat_finddirentry(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo,
-                     const char *path)
-{
-  size_t cluster;
-  ubyte *direntry = NULL;
-  char terminator;
-  int ret;
-
-  /* Initialize to traverse the chain.  Set it to the cluster of
-   * the root directory
-   */
-
-  cluster = fs->fs_rootbase;
-  if (fs->fs_type == FSTYPE_FAT32)
-    {
-      /* For FAT32, the root directory is variable sized and is a
-       * cluster chain like any other directory.  fs_rootbase holds
-       * the first cluster of the root directory.
-       */
-
-      dirinfo->dir.fd_startcluster = cluster;
-      dirinfo->dir.fd_currcluster  = cluster;
-      dirinfo->dir.fd_currsector   = fat_cluster2sector(fs, cluster);
-    }
-  else
-    {
-      /* For FAT12/16, the first sector of the root directory is a sector
-       * relative to the first sector of the fat volume.
-       */
-
-      dirinfo->dir.fd_startcluster = 0;
-      dirinfo->dir.fd_currcluster  = 0;
-      dirinfo->dir.fd_currsector   = cluster;
-    }
-
-  /* fd_index is the index into the current directory table */
-
-  dirinfo->dir.fd_index = 0;
-
-  /* If no path was provided, then the root directory must be exactly
-   * what the caller is looking for.
-   */
-
-  if (*path == '\0')
-    {
-      dirinfo->fd_entry = NULL;
-      return OK;
-    }
-
-  /* Otherwise, loop until the path is found */
-
-  for (;;)
-    {
-      /* Convert the next the path segment name into the kind of
-       * name that we would see in the directory entry.
-       */
-
-      ret = fat_path2dirname(&path, dirinfo, &terminator);
-      if (ret < 0)
-        {
-          /* ERROR:  The filename contains invalid characters or is
-           * too long.
-           */
-
-          return ret;
-        }
-
-      /* Now search the current directory entry for an entry with this
-       * matching name.
-       */
-
-      for (;;)
-        {
-          /* Read the next sector into memory */
-
-          ret = fat_fscacheread(fs, dirinfo->dir.fd_currsector);
-          if (ret < 0)
-            {
-              return ret;
-            }
-
-          /* Get a pointer to the directory entry */
-
-          direntry = &fs->fs_buffer[DIRSEC_BYTENDX(fs, dirinfo->dir.fd_index)];
-
-          /* Check if we are at the end of the directory */
-
-          if (direntry[DIR_NAME] == DIR0_ALLEMPTY)
-            {
-              return -ENOENT;
-            }
-
-          /* Check if we have found the directory entry that we are looking for */
-
-          if (direntry[DIR_NAME] != DIR0_EMPTY &&
-              !(DIR_GETATTRIBUTES(direntry) & FATATTR_VOLUMEID) &&
-              !memcmp(&direntry[DIR_NAME], dirinfo->fd_name, 8+3) )
-            {
-              /* Yes.. break out of the loop */
-              break;
-            }
-
-          /* No... get the next directory index and try again */
-
-          if (fat_nextdirentry(fs, &dirinfo->dir) != OK)
-            {
-              return -ENOENT;
-            }
-        }
-
-      /* We get here only if we have found a directory entry that matches
-       * the path element that we are looking for.
-       *
-       * If the terminator character in the path was the end of the string
-       * then we have successfully found the directory entry that describes
-       * the path.
-       */
-
-      if (!terminator)
-        {
-          /* Return the pointer to the matching directory entry */
-          dirinfo->fd_entry = direntry;
-          return OK;
-        }
-
-      /* No.. then we have found one of the intermediate directories on
-       * the way to the final path target.  In this case, make sure
-       * the thing that we found is, indeed, a directory.
-       */
-
-      if (!(DIR_GETATTRIBUTES(direntry) & FATATTR_DIRECTORY))
-        {
-          /* Ooops.. we found something else */
-          return -ENOTDIR;
-        }
-
-      /* Get the cluster number of this directory */
-
-      cluster =
-          ((uint32)DIR_GETFSTCLUSTHI(direntry) << 16) |
-          DIR_GETFSTCLUSTLO(direntry);
-
-      /* The restart scanning at the new directory */
-
-      dirinfo->dir.fd_currcluster = dirinfo->dir.fd_startcluster = cluster;
-      dirinfo->dir.fd_currsector  = fat_cluster2sector(fs, cluster);
-      dirinfo->dir.fd_index       = 2;
-    }
-}
-
-/****************************************************************************
- * Name: fat_allocatedirentry
- *
- * Desciption: Find a free directory entry
- *
- ****************************************************************************/
-
-int fat_allocatedirentry(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
-{
-  sint32 cluster;
-  size_t sector;
-  ubyte *direntry;
-  ubyte  ch;
-  int    ret;
-  int    i;
-
-  /* Re-initialize directory object */
-
-  cluster = dirinfo->dir.fd_startcluster;
-  if (cluster)
-    {
-     /* Cluster chain can be extended */
-
-      dirinfo->dir.fd_currcluster = cluster;
-      dirinfo->dir.fd_currsector  = fat_cluster2sector(fs, cluster);
-    }
-  else
-    {
-      /* Fixed size FAT12/16 root directory is at fixxed offset/size */
-
-      dirinfo->dir.fd_currsector = fs->fs_rootbase;
-    }
-  dirinfo->dir.fd_index = 0;
-
-  for (;;)
-    {
-      unsigned int dirindex;
-
-      /* Read the directory sector into fs_buffer */
-
-      ret = fat_fscacheread(fs, dirinfo->dir.fd_currsector);
-      if (ret < 0)
-        {
-          return ret;
-        }
-
-      /* Get a pointer to the entry at fd_index */
-
-      dirindex = (dirinfo->dir.fd_index & DIRSEC_NDXMASK(fs)) * 32;
-      direntry = &fs->fs_buffer[dirindex];
-
-      /* Check if this directory entry is empty */
-
-      ch = direntry[DIR_NAME];
-      if (ch == DIR0_ALLEMPTY || ch == DIR0_EMPTY)
-        {
-          /* It is empty -- we have found a directory entry */
-
-          dirinfo->fd_entry = direntry;
-          return OK;
-        }
-
-      ret = fat_nextdirentry(fs, &dirinfo->dir);
-      if (ret < 0)
-        {
-          return ret;
-        }
-    }
-
-  /* If we get here, then we have reached the end of the directory table
-   * in this sector without finding a free directory enty.
-   *
-   * It this is a fixed size dirctory entry, then this is an error.
-   * Otherwise, we can try to extend the directory cluster chain to
-   * make space for the new directory entry.
-   */
-
-  if (!cluster)
-    {
-      /* The size is fixed */
-      return -ENOSPC;
-    }
-
-  /* Try to extend the cluster chain for this directory */
-
-  cluster = fat_extendchain(fs, dirinfo->dir.fd_currcluster);
-  if (cluster < 0)
-    {
-      return cluster;
-    }
-
- /* Flush out any cached date in fs_buffer.. we are going to use
-  * it to initialize the new directory cluster.
-  */
-
-  ret = fat_fscacheflush(fs);
-  if (ret < 0)
-    {
-      return ret;
-    }
-
-  /* Clear all sectors comprising the new directory cluster */
-
-  fs->fs_currentsector = fat_cluster2sector(fs, cluster);
-  memset(fs->fs_buffer, 0, fs->fs_hwsectorsize);
-
-  sector = sector;
-  for (i = fs->fs_fatsecperclus; i; i--)
-    {
-      ret = fat_hwwrite(fs, fs->fs_buffer, sector, 1);
-      if ( ret < 0)
-        {
-          return ret;
-        }
-      sector++;
-    }
-
-  dirinfo->fd_entry = fs->fs_buffer;
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_dirname2path
- *
- * Desciption:  Convert a filename in a raw directory entry into a user
- *    filename.  This is essentially the inverse operation of that performed
- *    by fat_path2dirname.  See that function for more details.
- *
- ****************************************************************************/
-
-int fat_dirname2path(char *path, ubyte *direntry)
-{
-#ifdef CONFIG_FAT_LCNAMES
-    ubyte ntflags;
-#endif
-    int  ch;
-    int  ndx;
-
-    /* Check if we will be doing upper to lower case conversions */
-
-#ifdef CONFIG_FAT_LCNAMES
-    ntflags = DIR_GETNTRES(direntry);
-#endif
-
-    /* Get the 8-byte filename */
-
-    for (ndx = 0; ndx < 8; ndx++)
-      {
-        /* Get the next filename character from the directory entry */
-
-        ch = direntry[ndx];
-
-        /* Any space (or ndx==8) terminates the filename */
-
-        if (ch == ' ')
-          {
-            break;
-          }
-
-        /* In this version, we never write 0xe5 in the directoryfilenames
-         * (because we do not handle any character sets where 0xe5 is valid
-         * in a filaname), but we could encounted this in a filesystem
-         * written by some other system
-         */
-
-        if (ndx == 0 && ch == DIR0_E5)
-          {
-            ch = 0xe5;
-          }
-
-        /* Check if we should perform upper to lower case conversion
-         * of the (whole) filename.
-         */
-
-#ifdef CONFIG_FAT_LCNAMES
-        if (ntflags & FATNTRES_LCNAME && isupper(ch))
-          {
-            ch = tolower(ch);
-          }
-#endif
-        /* Copy the next character into the filename */
-
-        *path++ = ch;
-      }
-
-    /* Check if there is an extension */
-
-    if (direntry[8] != ' ')
-      {
-        /* Yes, output the dot before the extension */
-
-        *path++ = '.';
-
-        /* Then output the (up to) 3 character extension */
-
-        for (ndx = 8; ndx < 11; ndx++)
-          {
-            /* Get the next extensions character from the directory entry */
-
-            ch = direntry[DIR_NAME + ndx];
-
-            /* Any space (or ndx==11) terminates the extension */
-
-            if (ch == ' ')
-              {
-                break;
-              }
-
-            /* Check if we should perform upper to lower case conversion
-             * of the (whole) filename.
-             */
-
-#ifdef CONFIG_FAT_LCNAMES
-            if (ntflags & FATNTRES_LCEXT && isupper(ch))
-              {
-                ch = tolower(ch);
-              }
-#endif
-        /* Copy the next character into the filename */
-
-            *path++ = ch;
-          }
-      }
-
-    /* Put a null terminator at the end of the filename */
-
-    *path = '\0';
-    return OK;
-}
-
-/****************************************************************************
- * Name: fat_dirtruncate
- *
- * Desciption: Truncate an existing file to zero length
- *
- * Assumptions:  The caller holds mountpoint semaphore, fs_buffer holds
- *   the directory entry, dirinfo refers to the current fs_buffer content.
- *
- ****************************************************************************/
-
-int  fat_dirtruncate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
-{
-  unsigned int startcluster;
-  uint32       writetime;
-  size_t       savesector;
-  int          ret;
-
-  /* Get start cluster of the file to truncate */
-
-  startcluster =
-      ((uint32)DIR_GETFSTCLUSTHI(dirinfo->fd_entry) << 16) |
-      DIR_GETFSTCLUSTLO(dirinfo->fd_entry);
-
-  /* Clear the cluster start value in the directory and set the file size
-   * to zero.  This makes the file look empty but also have to dispose of
-   * all of the clusters in the chain.
-   */
-
-  DIR_PUTFSTCLUSTHI(dirinfo->fd_entry, 0);
-  DIR_PUTFSTCLUSTLO(dirinfo->fd_entry, 0);
-  DIR_PUTFILESIZE(dirinfo->fd_entry, 0);
-
-  /* Set the ARCHIVE attribute and update the write time */
-
-  DIR_PUTATTRIBUTES(dirinfo->fd_entry, FATATTR_ARCHIVE);
- 
-  writetime = fat_systime2fattime();
-  DIR_PUTWRTTIME(dirinfo->fd_entry, writetime & 0xffff);
-  DIR_PUTWRTDATE(dirinfo->fd_entry, writetime > 16);
-
-  /* This sector needs to be written back to disk eventually */
-
-  fs->fs_dirty = TRUE;
-
-  /* Now remove the entire cluster chain comprising the file */
-
-  savesector = fs->fs_currentsector;
-  ret = fat_removechain(fs, startcluster);
-  if (ret < 0)
-  {
-    return ret;
-  }
-
-  /* Setup FSINFO to resuse this cluster next */
-
-  fs->fs_fsinextfree = startcluster - 1;
-
-  /* Make sure that the directory is still in the cache */
-
-  return fat_fscacheread(fs, savesector);
-}
-
-/****************************************************************************
- * Name: fat_dircreate
- *
- * Desciption: Create a directory entry for a new file
- *
- ****************************************************************************/
-
-int fat_dircreate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
-{
-  ubyte  *direntry;
-  uint32  time;
-  int     ret;
-
-  /* Set up the directory entry */
-
-  ret = fat_allocatedirentry(fs, dirinfo);
-  if (ret != OK)
-    {
-      /* Failed to set up directory entry */
-      return ret;
-    }
-
-  /* Initialize the 32-byte directory entry */
-
-  direntry = dirinfo->fd_entry;
-  memset(direntry, 0, 32);
-
-  /* Directory name info */
-
-  memcpy(&direntry[DIR_NAME], dirinfo->fd_name, 8+3);
-#ifdef CONFIG_FLAT_LCNAMES
-  DIR_PUTNTRES(dirinfo->fd_entry, dirinfo->fd_ntflags);
-#else
-  DIR_PUTNTRES(dirinfo->fd_entry, 0);
-#endif
-
-  /* ARCHIVE attribute, write time, creation time */
-  DIR_PUTATTRIBUTES(dirinfo->fd_entry, FATATTR_ARCHIVE);
- 
-  time = fat_systime2fattime();
-  DIR_PUTWRTTIME(dirinfo->fd_entry, time & 0xffff);
-  DIR_PUTCRTIME(dirinfo->fd_entry, time & 0xffff);
-  DIR_PUTWRTDATE(dirinfo->fd_entry, time >> 16);
-  DIR_PUTCRDATE(dirinfo->fd_entry, time >> 16);
-
-  fs->fs_dirty = TRUE;
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_remove
- *
- * Desciption: Remove a directory or file from the file system.  This
- *   implements both rmdir() and unlink().
- *
- ****************************************************************************/
-
-int fat_remove(struct fat_mountpt_s *fs, const char *relpath, boolean directory)
-{
-  struct fat_dirinfo_s dirinfo;
-  uint32  dircluster;
-  size_t  dirsector;
-  int     ret;
-
-  /* Find the directory entry referring to the entry to be deleted */
-
-  ret = fat_finddirentry(fs, &dirinfo, relpath);
-  if (ret != OK)
-    {
-      /* No such path */
-
-      return -ENOENT;
-    }
-
-  /* Check if this is a FAT12/16 root directory */
-
-  if (dirinfo.fd_entry == NULL)
-    {
-      /* The root directory cannot be removed */
-
-      return -EPERM;
-    }
-
-  /* The object has to have write access to be deleted */
-
-  if ((DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_READONLY) != 0)
-    {
-      /* It is a read-only entry */
-
-      return -EACCES;
-    }
-
-  /* Get the directory sector and cluster containing the
-   * entry to be deleted
-   */
-
-  dirsector  = fs->fs_currentsector;
-  dircluster =
-      ((uint32)DIR_GETFSTCLUSTHI(dirinfo.fd_entry) << 16) |
-      DIR_GETFSTCLUSTLO(dirinfo.fd_entry);
-
-  /* Is this entry a directory? */
-
-  if (DIR_GETATTRIBUTES(dirinfo.fd_entry) & FATATTR_DIRECTORY)
-    {
-      /* It is a sub-directory. Check if we are be asked to remove
-       * a directory or a file.
-       */
-
-      if (!directory)
-        {
-          /* We are asked to delete a file */
-
-          return -EISDIR;
-        }
-
-      /* We are asked to delete a directory. Check if this
-       * sub-directory is empty
-       */
-
-      dirinfo.dir.fd_currcluster = dircluster;
-      dirinfo.dir.fd_currsector  = fat_cluster2sector(fs, dircluster);
-      dirinfo.dir.fd_index       = 2;
-
-      /* Loop until either (1) an entry is found in the directory
-       * (error), (2) the directory is found to be empty, or (3) some
-       * error occurs.
-       */
-
-      for (;;)
-        {
-          unsigned int subdirindex;
-          ubyte       *subdirentry;
-
-          /* Make sure that the sector containing the of the
-           * subdirectory sector is in the cache
-           */
-
-          ret = fat_fscacheread(fs, dirinfo.dir.fd_currsector);
-          if (ret < 0)
-            {
-              return ret;
-            }
-
-          /* Get a reference to the next entry in the directory */
-
-          subdirindex = (dirinfo.dir.fd_index & DIRSEC_NDXMASK(fs)) * 32;
-          subdirentry = &fs->fs_buffer[subdirindex];
-
-          /* Is this the last entry in the direcory? */
-
-          if (subdirentry[DIR_NAME] == DIR0_ALLEMPTY)
-            {
-              /* Yes then the directory is empty.  Break out of the
-               * loop and delete the directory.
-               */
-
-              break;
-            }
-
-          /* Check if the next entry refers to a file or directory */
-
-          if (subdirentry[DIR_NAME] != DIR0_EMPTY &&
-              !(DIR_GETATTRIBUTES(subdirentry) & FATATTR_VOLUMEID))
-            {
-              /* The directory is not empty */
-
-              return -ENOTEMPTY;
-            }
-
-          /* Get the next directgory entry */
-
-          ret = fat_nextdirentry(fs, &dirinfo.dir);
-          if (ret < 0)
-            {
-              return ret;
-            }
-        }
-    }
-  else
-    {
-      /* It is a file. Check if we are be asked to remove a directory
-       * or a file.
-       */
-
-      if (directory)
-        {
-          /* We are asked to remove a directory */
-
-          return -ENOTDIR;
-        }
-    }
-
-  /* Make sure that the directory containing the entry to be deleted is
-   * in the cache.
-   */
-
-  ret = fat_fscacheread(fs, dirsector);
-  if (ret < 0)
-    {
-      return ret;
-    }
-
-  /* Mark the directory entry 'deleted' */
-
-  dirinfo.fd_entry[DIR_NAME] = DIR0_EMPTY;
-  fs->fs_dirty = TRUE;
-
-  /* And remove the cluster chain making up the subdirectory */
-
-  ret = fat_removechain(fs, dircluster);
-  if (ret < 0)
-    {
-      return ret;
-    }
-
-  /* Update the FSINFO sector (FAT32) */
-
-  ret = fat_updatefsinfo(fs);
-  if (ret < 0)
-    {
-      return ret;
-    }
-
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_fscacheflush
- *
- * Desciption: Flush any dirty sector if fs_buffer as necessary
- *
- ****************************************************************************/
-
-int fat_fscacheflush(struct fat_mountpt_s *fs)
-{
-  int ret;
-
-  /* Check if the fs_buffer is dirty.  In this case, we will write back the
-   * contents of fs_buffer.
-   */
-
-  if (fs->fs_dirty)
-  {
-      /* Write the dirty sector */
-
-      ret = fat_hwwrite(fs, fs->fs_buffer, fs->fs_currentsector, 1);
-      if (ret < 0)
-      {
-          return ret;
-      }
-
-      /* Does the sector lie in the FAT region? */
-
-      if (fs->fs_currentsector < fs->fs_fatbase + fs->fs_fatsize)
-      {
-          /* Yes, then make the change in the FAT copy as well */
-          int i;
-
-          for (i = fs->fs_fatnumfats; i >= 2; i--)
-          { 
-              fs->fs_currentsector += fs->fs_fatsize;
-              ret = fat_hwwrite(fs, fs->fs_buffer, fs->fs_currentsector, 1);
-              if (ret < 0)
-              {
-                  return ret;
-              }
-          }
-      }
-
-      /* No longer dirty */
-
-      fs->fs_dirty = FALSE;
-  }
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_fscacheread
- *
- * Desciption: Read the specified sector into the sector cache, flushing any
- *   existing dirty sectors as necessary.
- *
- ****************************************************************************/
-
-int fat_fscacheread(struct fat_mountpt_s *fs, size_t sector)
-{
-  int ret;
-
-  /* fs->fs_currentsector holds the current sector that is buffered in
-   * fs->fs_buffer. If the requested sector is the same as this sector, then
-   * we do nothing. Otherwise, we will have to read the new sector.
-   */
-
-    if (fs->fs_currentsector != sector)
-      {
-        /* We will need to read the new sector.  First, flush the cached
-         * sector if it is dirty.
-         */
-
-        ret = fat_fscacheflush(fs);
-        if (ret < 0)
-          {
-              return ret;
-          }
-
-        /* Then read the specified sector into the cache */
-
-        ret = fat_hwread(fs, fs->fs_buffer, sector, 1);
-        if (ret < 0)
-          {
-            return ret;
-          }
-
-        /* Update the cached sector number */
-
-        fs->fs_currentsector = sector;
-    }
-
-    return OK;
-}
-
-/****************************************************************************
- * Name: fat_ffcacheflush
- *
- * Desciption: Flush any dirty sectors as necessary
- *
- ****************************************************************************/
-
-int fat_ffcacheflush(struct fat_mountpt_s *fs, struct fat_file_s *ff)
-{
-  int ret;
-
-  /* Check if the ff_buffer is dirty.  In this case, we will write back the
-   * contents of ff_buffer.
-   */
-
-  if (ff->ff_bflags && (FFBUFF_DIRTY|FFBUFF_VALID) == (FFBUFF_DIRTY|FFBUFF_VALID))
-  {
-      /* Write the dirty sector */
-
-      ret = fat_hwwrite(fs, ff->ff_buffer, ff->ff_currentsector, 1);
-      if (ret < 0)
-      {
-          return ret;
-      }
-
-      /* No longer dirty */
-
-      ff->ff_bflags &= ~FFBUFF_DIRTY;
-  }
-
-  return OK;
-}
-
-/****************************************************************************
- * Name: fat_ffcacheread
- *
- * Desciption: Read the specified sector into the sector cache, flushing any
- *   existing dirty sectors as necessary.
- *
- ****************************************************************************/
-
-int fat_ffcacheread(struct fat_mountpt_s *fs, struct fat_file_s *ff, size_t sector)
-{
-  int ret;
-
-  /* ff->ff_currentsector holds the current sector that is buffered in
-   * ff->ff_buffer. If the requested sector is the same as this sector, then
-   * we do nothing. Otherwise, we will have to read the new sector.
-   */
-
-  if (ff->ff_currentsector != sector || (ff->ff_bflags & FFBUFF_VALID) == 0)
-      {
-        /* We will need to read the new sector.  First, flush the cached
-         * sector if it is dirty.
-         */
-
-        ret = fat_ffcacheflush(fs, ff);
-        if (ret < 0)
-          {
-              return ret;
-          }
-
-        /* Then read the specified sector into the cache */
-
-        ret = fat_hwread(fs, ff->ff_buffer, sector, 1);
-        if (ret < 0)
-          {
-            return ret;
-          }
-
-        /* Update the cached sector number */
-
-        ff->ff_currentsector = sector;
-        ff->ff_bflags |= FFBUFF_VALID;
-    }
-    return OK;
-}
-
-/****************************************************************************
- * Name: fat_ffcacheread
- *
- * Desciption: Invalidate the current file buffer contents
- *
- ****************************************************************************/
-
-int fat_ffcacheinvalidate(struct fat_mountpt_s *fs, struct fat_file_s *ff)
-{
-  int ret;
-
-  /* Is there anything valid in the buffer now? */
-
-  if ((ff->ff_bflags & FFBUFF_VALID) != 0)
-      {
-        /* We will invalidate the buffered sector */
-
-        ret = fat_ffcacheflush(fs, ff);
-        if (ret < 0)
-          {
-              return ret;
-          }
-
-        /* Then discard the current cache contents */
-
-        ff->ff_bflags &= ~FFBUFF_VALID;
-    }
-    return OK;
-}
-
-/****************************************************************************
- * Name: fat_updatefsinfo
- *
- * Desciption: Flush evertyhing buffered for the mountpoint and update
- *   the FSINFO sector, if appropriate
- *
- ****************************************************************************/
-
-int fat_updatefsinfo(struct fat_mountpt_s *fs)
-{
-  int ret;
-
-  /* Flush the fs_buffer if it is dirty */
-
-  ret = fat_fscacheflush(fs);
-  if (ret == OK)
-    {
-      /* The FSINFO sector only has to be update for the case of a FAT32 file
-       * system.  Check if the file system type.. If this is a FAT32 file
-       * system then the fs_fsidirty flag will indicate if the FSINFO sector
-       * needs to be re-written.
-       */
-
-      if (fs->fs_type == FSTYPE_FAT32 && fs->fs_fsidirty)
-        {
-          /* Create an image of the FSINFO sector in the fs_buffer */
-
-          memset(fs->fs_buffer, 0, fs->fs_hwsectorsize);
-          FSI_PUTLEADSIG(fs->fs_buffer, 0x41615252);
-          FSI_PUTSTRUCTSIG(fs->fs_buffer, 0x61417272);
-          FSI_PUTFREECOUNT(fs->fs_buffer, fs->fs_fsifreecount);
-          FSI_PUTNXTFREE(fs->fs_buffer, fs->fs_fsinextfree);
-          FSI_PUTTRAILSIG(fs->fs_buffer, 0xaa550000);
-
-          /* Then flush this to disk */
-
-          fs->fs_currentsector = fs->fs_fsinfo;
-          fs->fs_dirty         = TRUE;
-          ret                  = fat_fscacheflush(fs);
-
-          /* No longer dirty */
-
-          fs->fs_fsidirty = FALSE;
-        }
-    }
-  return ret;
-}
-
-/****************************************************************************
- * Name: fat_nfreeclusters
- *
- * Desciption: Get the number of free clusters
- *
- ****************************************************************************/
-
-int fat_nfreeclusters(struct fat_mountpt_s *fs, size_t *pfreeclusters)
-{
-  uint32 nfreeclusters;
-
-  /* If number of the first free cluster is valid, then just return that value. */
-
-  if (fs->fs_fsifreecount <= fs->fs_nclusters - 2)
-    {
-      *pfreeclusters = fs->fs_fsifreecount;
-      return OK;
-    }
-
-  /* Otherwise, we will have to count the number of free clusters */
-
-  nfreeclusters = 0;
-  if (fs->fs_type == FSTYPE_FAT12)
-    {
-      size_t sector;
-
-      /* Examine every cluster in the fat */
-
-      for (sector = 2; sector < fs->fs_nclusters; sector++)
-        {
-
-          /* If the cluster is unassigned, then increment the count of free clusters */
-
-          if ((uint16)fat_getcluster(fs, sector) == 0)
-            {
-              nfreeclusters++;
-            }
-        }
-    }
-  else
-    {
-      unsigned int cluster;
-      size_t       fatsector;
-      unsigned int offset;
-      int          ret;
-
-      fatsector    = fs->fs_fatbase;
-      offset       = fs->fs_hwsectorsize;
-
-      /* Examine each cluster in the fat */
-
-      for (cluster = fs->fs_nclusters; cluster > 0; cluster--)
-        {
-          /* If we are starting a new sector, then read the new sector in fs_buffer */
-
-          if (offset >= fs->fs_hwsectorsize)
-            {
-              ret = fat_fscacheread(fs, fatsector++);
-              if (ret < 0)
-                {
-                  return ret;
-                }
-
-              /* Reset the offset to the next FAT entry.
-               * Increment the sector number to read next time around.
-               */
-
-              offset = 0;
-              fatsector++;
-            }
-
-          /* FAT16 and FAT32 differ only on the size of each cluster start
-           * sector number in the FAT.
-           */
-
-          if (fs->fs_type == FSTYPE_FAT16)
-            {
-              if (FAT_GETFAT16(fs->fs_buffer, offset) == 0)
-                {
-                  nfreeclusters++;
-                }
-              offset += 2;
-            }
-          else
-            {
-              if (FAT_GETFAT32(fs->fs_buffer, offset) == 0)
-                {
-                  nfreeclusters++;
-                }
-
-              offset += 4;
-            }
-        }
-    }
-
-    fs->fs_fsifreecount = nfreeclusters;
-    if (fs->fs_type == FSTYPE_FAT32)
-      {
-        fs->fs_fsidirty = TRUE;
-      }
-
-    *pfreeclusters = nfreeclusters;
-    return OK;
-}
-