Fatfs Cleanup

9 files changed, 433 insertions, 413 deletions

diff --git a/src/gfile/fatfs/fatfs.c b/src/gfile/fatfs/fatfs.c
new file mode 100644
index 00000000..f9d11aeb
--- /dev/null
+++ b/src/gfile/fatfs/fatfs.c
@@ -0,0 +1,20 @@
+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ *              http://ugfx.org/license.html
+ */
+
+/**
+ * @file    src/gfile/fatfs/fatfs.c
+ * @brief   GFILE FATFS wrapper.
+ *
+ */
+
+#include "gfx.h"
+
+#if GFX_USE_GFILE && GFILE_NEED_FATFS
+
+#include "src/ff.c"
+
+#endif // GFX_USE_GFILE && GFILE_NEED_FATFS
diff --git a/src/gfile/fatfs/fatfs.mk b/src/gfile/fatfs/fatfs.mk
index 0b540a41..683cea5b 100644
--- a/src/gfile/fatfs/fatfs.mk
+++ b/src/gfile/fatfs/fatfs.mk
@@ -1,6 +1,6 @@
-GFXSRC +=    $(GFXLIB)/src/gfile/fatfs/src/ff.c \
-             $(GFXLIB)/src/gfile/fatfs/src/chibios_fatfs_diskio.c \
-             $(GFXLIB)/src/gfile/fatfs/src/syscall.c
+GFXSRC +=    $(GFXLIB)/src/gfile/fatfs/fatfs.c \
+             $(GFXLIB)/src/gfile/fatfs/fatfs_syscall.c \
+             $(GFXLIB)/src/gfile/fatfs/fatfs_chibios_diskio.c
 
 
 GFXINC +=    $(GFXLIB)/src/gfile/fatfs/src
diff --git a/src/gfile/fatfs/src/chibios_fatfs_diskio.c b/src/gfile/fatfs/fatfs_chibios_diskio.c
index f882aa41..d770e2a1 100644
--- a/src/gfile/fatfs/src/chibios_fatfs_diskio.c
+++ b/src/gfile/fatfs/fatfs_chibios_diskio.c
@@ -1,254 +1,257 @@
-/*-----------------------------------------------------------------------*/

-/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2007        */

-/*-----------------------------------------------------------------------*/

-/* This is a stub disk I/O module that acts as front end of the existing */

-/* disk I/O modules and attach it to FatFs module with common interface. */

-/*-----------------------------------------------------------------------*/

-

-#include "ch.h"

-#include "hal.h"

-#include "ffconf.h"

-#include "diskio.h"

-

-#if HAL_USE_MMC_SPI && HAL_USE_SDC

-#error "cannot specify both MMC_SPI and SDC drivers"

-#endif

-

-#if HAL_USE_MMC_SPI

-extern MMCDriver MMCD1;

-#elif HAL_USE_SDC

-extern SDCDriver SDCD1;

-#else

-#error "MMC_SPI or SDC driver must be specified"

-#endif

-

-#if HAL_USE_RTC

-#include "chrtclib.h"

-extern RTCDriver RTCD1;

-#endif

-

-/*-----------------------------------------------------------------------*/

-/* Correspondence between physical drive number and physical drive.      */

-

-#define MMC     0

-#define SDC     0

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Inidialize a Drive                                                    */

-

-DSTATUS disk_initialize (

-    BYTE drv                /* Physical drive nmuber (0..) */

-)

-{

-  DSTATUS stat;

-

-  switch (drv) {

-#if HAL_USE_MMC_SPI

-  case MMC:

-    stat = 0;

-    /* It is initialized externally, just reads the status.*/

-    if (blkGetDriverState(&MMCD1) != BLK_READY)

-      stat |= STA_NOINIT;

-    if (mmcIsWriteProtected(&MMCD1))

-      stat |=  STA_PROTECT;

-    return stat;

-#else

-  case SDC:

-    stat = 0;

-    /* It is initialized externally, just reads the status.*/

-    if (blkGetDriverState(&SDCD1) != BLK_READY)

-      stat |= STA_NOINIT;

-    if (sdcIsWriteProtected(&SDCD1))

-      stat |=  STA_PROTECT;

-    return stat;

-#endif

-  }

-  return STA_NODISK;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Return Disk Status                                                    */

-

-DSTATUS disk_status (

-    BYTE drv        /* Physical drive nmuber (0..) */

-)

-{

-  DSTATUS stat;

-

-  switch (drv) {

-#if HAL_USE_MMC_SPI

-  case MMC:

-    stat = 0;

-    /* It is initialized externally, just reads the status.*/

-    if (blkGetDriverState(&MMCD1) != BLK_READY)

-      stat |= STA_NOINIT;

-    if (mmcIsWriteProtected(&MMCD1))

-      stat |= STA_PROTECT;

-    return stat;

-#else

-  case SDC:

-    stat = 0;

-    /* It is initialized externally, just reads the status.*/

-    if (blkGetDriverState(&SDCD1) != BLK_READY)

-      stat |= STA_NOINIT;

-    if (sdcIsWriteProtected(&SDCD1))

-      stat |= STA_PROTECT;

-    return stat;

-#endif

-  }

-  return STA_NODISK;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Read Sector(s)                                                        */

-

-DRESULT disk_read (

-    BYTE drv,        /* Physical drive nmuber (0..) */

-    BYTE *buff,        /* Data buffer to store read data */

-    DWORD sector,    /* Sector address (LBA) */

-    UINT count        /* Number of sectors to read (1..255) */

-)

-{

-  switch (drv) {

-#if HAL_USE_MMC_SPI

-  case MMC:

-    if (blkGetDriverState(&MMCD1) != BLK_READY)

-      return RES_NOTRDY;

-    if (mmcStartSequentialRead(&MMCD1, sector))

-      return RES_ERROR;

-    while (count > 0) {

-      if (mmcSequentialRead(&MMCD1, buff))

-        return RES_ERROR;

-      buff += MMCSD_BLOCK_SIZE;

-      count--;

-    }

-    if (mmcStopSequentialRead(&MMCD1))

-        return RES_ERROR;

-    return RES_OK;

-#else

-  case SDC:

-    if (blkGetDriverState(&SDCD1) != BLK_READY)

-      return RES_NOTRDY;

-    if (sdcRead(&SDCD1, sector, buff, count))

-      return RES_ERROR;

-    return RES_OK;

-#endif

-  }

-  return RES_PARERR;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Write Sector(s)                                                       */

-

-#if _READONLY == 0

-DRESULT disk_write (

-    BYTE drv,            /* Physical drive nmuber (0..) */

-    const BYTE *buff,    /* Data to be written */

-    DWORD sector,        /* Sector address (LBA) */

-    UINT count            /* Number of sectors to write (1..255) */

-)

-{

-  switch (drv) {

-#if HAL_USE_MMC_SPI

-  case MMC:

-    if (blkGetDriverState(&MMCD1) != BLK_READY)

-        return RES_NOTRDY;

-    if (mmcIsWriteProtected(&MMCD1))

-        return RES_WRPRT;

-    if (mmcStartSequentialWrite(&MMCD1, sector))

-        return RES_ERROR;

-    while (count > 0) {

-        if (mmcSequentialWrite(&MMCD1, buff))

-            return RES_ERROR;

-        buff += MMCSD_BLOCK_SIZE;

-        count--;

-    }

-    if (mmcStopSequentialWrite(&MMCD1))

-        return RES_ERROR;

-    return RES_OK;

-#else

-  case SDC:

-    if (blkGetDriverState(&SDCD1) != BLK_READY)

-      return RES_NOTRDY;

-    if (sdcWrite(&SDCD1, sector, buff, count))

-      return RES_ERROR;

-    return RES_OK;

-#endif

-  }

-  return RES_PARERR;

-}

-#endif /* _READONLY */

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Miscellaneous Functions                                               */

-

-DRESULT disk_ioctl (

-    BYTE drv,        /* Physical drive nmuber (0..) */

-    BYTE ctrl,        /* Control code */

-    void *buff        /* Buffer to send/receive control data */

-)

-{

-  switch (drv) {

-#if HAL_USE_MMC_SPI

-  case MMC:

-    switch (ctrl) {

-    case CTRL_SYNC:

-        return RES_OK;

-    case GET_SECTOR_SIZE:

-        *((WORD *)buff) = MMCSD_BLOCK_SIZE;

-        return RES_OK;

-#if _USE_ERASE

-    case CTRL_ERASE_SECTOR:

-        mmcErase(&MMCD1, *((DWORD *)buff), *((DWORD *)buff + 1));

-        return RES_OK;

-#endif

-    default:

-        return RES_PARERR;

-    }

-#else

-  case SDC:

-    switch (ctrl) {

-    case CTRL_SYNC:

-        return RES_OK;

-    case GET_SECTOR_COUNT:

-        *((DWORD *)buff) = mmcsdGetCardCapacity(&SDCD1);

-        return RES_OK;

-    case GET_SECTOR_SIZE:

-        *((WORD *)buff) = MMCSD_BLOCK_SIZE;

-        return RES_OK;

-    case GET_BLOCK_SIZE:

-        *((DWORD *)buff) = 256; /* 512b blocks in one erase block */

-        return RES_OK;

-#if _USE_ERASE

-    case CTRL_ERASE_SECTOR:

-        sdcErase(&SDCD1, *((DWORD *)buff), *((DWORD *)buff + 1));

-        return RES_OK;

-#endif

-    default:

-        return RES_PARERR;

-    }

-#endif

-  }

-  return RES_PARERR;

-}

-

-DWORD get_fattime(void) {

-#if HAL_USE_RTC

-    return rtcGetTimeFat(&RTCD1);

-#else

-    return ((uint32_t)0 | (1 << 16)) | (1 << 21); /* wrong but valid time */

-#endif

-}

-

-

-

+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2007        */
+/*-----------------------------------------------------------------------*/
+/* This is a stub disk I/O module that acts as front end of the existing */
+/* disk I/O modules and attach it to FatFs module with common interface. */
+/*-----------------------------------------------------------------------*/
+
+#include "gfx.h"
+
+#if GFX_USE_GFILE && GFILE_NEED_FATFS && GFX_USE_OS_CHIBIOS
+
+#include "ffconf.h"
+#include "diskio.h"
+
+#if HAL_USE_MMC_SPI && HAL_USE_SDC
+#error "cannot specify both MMC_SPI and SDC drivers"
+#endif
+
+#if HAL_USE_MMC_SPI
+extern MMCDriver MMCD1;
+#elif HAL_USE_SDC
+extern SDCDriver SDCD1;
+#else
+#error "MMC_SPI or SDC driver must be specified"
+#endif
+
+#if HAL_USE_RTC
+#include "chrtclib.h"
+extern RTCDriver RTCD1;
+#endif
+
+/*-----------------------------------------------------------------------*/
+/* Correspondence between physical drive number and physical drive.      */
+
+#define MMC     0
+#define SDC     0
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+
+DSTATUS disk_initialize (
+    BYTE drv                /* Physical drive nmuber (0..) */
+)
+{
+  DSTATUS stat;
+
+  switch (drv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&MMCD1) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (mmcIsWriteProtected(&MMCD1))
+      stat |=  STA_PROTECT;
+    return stat;
+#else
+  case SDC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&SDCD1) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (sdcIsWriteProtected(&SDCD1))
+      stat |=  STA_PROTECT;
+    return stat;
+#endif
+  }
+  return STA_NODISK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Return Disk Status                                                    */
+
+DSTATUS disk_status (
+    BYTE drv        /* Physical drive nmuber (0..) */
+)
+{
+  DSTATUS stat;
+
+  switch (drv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&MMCD1) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (mmcIsWriteProtected(&MMCD1))
+      stat |= STA_PROTECT;
+    return stat;
+#else
+  case SDC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&SDCD1) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (sdcIsWriteProtected(&SDCD1))
+      stat |= STA_PROTECT;
+    return stat;
+#endif
+  }
+  return STA_NODISK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+
+DRESULT disk_read (
+    BYTE drv,        /* Physical drive nmuber (0..) */
+    BYTE *buff,        /* Data buffer to store read data */
+    DWORD sector,    /* Sector address (LBA) */
+    UINT count        /* Number of sectors to read (1..255) */
+)
+{
+  switch (drv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    if (blkGetDriverState(&MMCD1) != BLK_READY)
+      return RES_NOTRDY;
+    if (mmcStartSequentialRead(&MMCD1, sector))
+      return RES_ERROR;
+    while (count > 0) {
+      if (mmcSequentialRead(&MMCD1, buff))
+        return RES_ERROR;
+      buff += MMCSD_BLOCK_SIZE;
+      count--;
+    }
+    if (mmcStopSequentialRead(&MMCD1))
+        return RES_ERROR;
+    return RES_OK;
+#else
+  case SDC:
+    if (blkGetDriverState(&SDCD1) != BLK_READY)
+      return RES_NOTRDY;
+    if (sdcRead(&SDCD1, sector, buff, count))
+      return RES_ERROR;
+    return RES_OK;
+#endif
+  }
+  return RES_PARERR;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+
+#if _READONLY == 0
+DRESULT disk_write (
+    BYTE drv,            /* Physical drive nmuber (0..) */
+    const BYTE *buff,    /* Data to be written */
+    DWORD sector,        /* Sector address (LBA) */
+    UINT count            /* Number of sectors to write (1..255) */
+)
+{
+  switch (drv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    if (blkGetDriverState(&MMCD1) != BLK_READY)
+        return RES_NOTRDY;
+    if (mmcIsWriteProtected(&MMCD1))
+        return RES_WRPRT;
+    if (mmcStartSequentialWrite(&MMCD1, sector))
+        return RES_ERROR;
+    while (count > 0) {
+        if (mmcSequentialWrite(&MMCD1, buff))
+            return RES_ERROR;
+        buff += MMCSD_BLOCK_SIZE;
+        count--;
+    }
+    if (mmcStopSequentialWrite(&MMCD1))
+        return RES_ERROR;
+    return RES_OK;
+#else
+  case SDC:
+    if (blkGetDriverState(&SDCD1) != BLK_READY)
+      return RES_NOTRDY;
+    if (sdcWrite(&SDCD1, sector, buff, count))
+      return RES_ERROR;
+    return RES_OK;
+#endif
+  }
+  return RES_PARERR;
+}
+#endif /* _READONLY */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+
+DRESULT disk_ioctl (
+    BYTE drv,        /* Physical drive nmuber (0..) */
+    BYTE ctrl,        /* Control code */
+    void *buff        /* Buffer to send/receive control data */
+)
+{
+  switch (drv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    switch (ctrl) {
+    case CTRL_SYNC:
+        return RES_OK;
+    case GET_SECTOR_SIZE:
+        *((WORD *)buff) = MMCSD_BLOCK_SIZE;
+        return RES_OK;
+#if _USE_ERASE
+    case CTRL_ERASE_SECTOR:
+        mmcErase(&MMCD1, *((DWORD *)buff), *((DWORD *)buff + 1));
+        return RES_OK;
+#endif
+    default:
+        return RES_PARERR;
+    }
+#else
+  case SDC:
+    switch (ctrl) {
+    case CTRL_SYNC:
+        return RES_OK;
+    case GET_SECTOR_COUNT:
+        *((DWORD *)buff) = mmcsdGetCardCapacity(&SDCD1);
+        return RES_OK;
+    case GET_SECTOR_SIZE:
+        *((WORD *)buff) = MMCSD_BLOCK_SIZE;
+        return RES_OK;
+    case GET_BLOCK_SIZE:
+        *((DWORD *)buff) = 256; /* 512b blocks in one erase block */
+        return RES_OK;
+#if _USE_ERASE
+    case CTRL_ERASE_SECTOR:
+        sdcErase(&SDCD1, *((DWORD *)buff), *((DWORD *)buff + 1));
+        return RES_OK;
+#endif
+    default:
+        return RES_PARERR;
+    }
+#endif
+  }
+  return RES_PARERR;
+}
+
+DWORD get_fattime(void) {
+#if HAL_USE_RTC
+    return rtcGetTimeFat(&RTCD1);
+#else
+    return ((uint32_t)0 | (1 << 16)) | (1 << 21); /* wrong but valid time */
+#endif
+}
+
+#endif // GFX_USE_GFILE && GFILE_NEED_FATFS && GFX_USE_OS_CHIBIOS
+
+
diff --git a/src/gfile/fatfs/src/syscall.c b/src/gfile/fatfs/fatfs_syscall.c
index ccc22bdb..80342731 100644
--- a/src/gfile/fatfs/src/syscall.c
+++ b/src/gfile/fatfs/fatfs_syscall.c
@@ -1,75 +1,80 @@
-/*

- * This file is subject to the terms of the GFX License. If a copy of

- * the license was not distributed with this file, you can obtain one at:

- *

- *              http://ugfx.org/license.html

- */

-

-#include "gfx.h"

-#include "ff.h"

-

-#if _FS_REENTRANT

-

-/*------------------------------------------------------------------------*/

-/* Static array of Synchronization Objects                                */

-/*------------------------------------------------------------------------*/

-static gfxSem ff_sem[_VOLUMES];

-

-/*------------------------------------------------------------------------*/

-/* Create a Synchronization Object                                        */

-/*------------------------------------------------------------------------*/

-int ff_cre_syncobj(BYTE vol, _SYNC_t *sobj)

-{

-	*sobj = ff_sem[vol];

-	gfxSemInit(sobj, 1, MAX_SEMAPHORE_COUNT);

-

-	return 1;

-}

-

-/*------------------------------------------------------------------------*/

-/* Delete a Synchronization Object                                        */

-/*------------------------------------------------------------------------*/

-int ff_del_syncobj(_SYNC_t sobj)

-{

-	gfxSemDestroy( (gfxSem*)&sobj );

-

-	return 1;

-}

-

-/*------------------------------------------------------------------------*/

-/* Request Grant to Access the Volume                                     */

-/*------------------------------------------------------------------------*/

-int ff_req_grant(_SYNC_t sobj)

-{

-	if (gfxSemWait( (gfxSem*)&sobj, (delaytime_t)_FS_TIMEOUT) )

-		return TRUE;

-	return FALSE;

-}

-

-/*------------------------------------------------------------------------*/

-/* Release Grant to Access the Volume                                     */

-/*------------------------------------------------------------------------*/

-void ff_rel_grant(_SYNC_t sobj)

-{

-	gfxSemSignal( (gfxSem*)&sobj );

-}

-#endif /* _FS_REENTRANT */

-

-#if _USE_LFN == 3	/* LFN with a working buffer on the heap */

-/*------------------------------------------------------------------------*/

-/* Allocate a memory block                                                */

-/*------------------------------------------------------------------------*/

-void *ff_memalloc(UINT size)

-{

-	return gfxAlloc( (size_t)size );

-}

-

-/*------------------------------------------------------------------------*/

-/* Free a memory block                                                    */

-/*------------------------------------------------------------------------*/

-void ff_memfree(void *mblock)

-{

-	gfxFree(mblock);

-}

-#endif /* _USE_LFN == 3 */

-

+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ *              http://ugfx.org/license.html
+ */
+
+#include "gfx.h"
+
+#if GFX_USE_GFILE && GFILE_NEED_FATFS
+
+#include "ff.h"
+
+#if _FS_REENTRANT
+
+/*------------------------------------------------------------------------*/
+/* Static array of Synchronization Objects                                */
+/*------------------------------------------------------------------------*/
+static gfxSem ff_sem[_VOLUMES];
+
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+int ff_cre_syncobj(BYTE vol, _SYNC_t *sobj)
+{
+	*sobj = ff_sem[vol];
+	gfxSemInit(sobj, 1, MAX_SEMAPHORE_COUNT);
+
+	return 1;
+}
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+int ff_del_syncobj(_SYNC_t sobj)
+{
+	gfxSemDestroy( (gfxSem*)&sobj );
+
+	return 1;
+}
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+int ff_req_grant(_SYNC_t sobj)
+{
+	if (gfxSemWait( (gfxSem*)&sobj, (delaytime_t)_FS_TIMEOUT) )
+		return TRUE;
+	return FALSE;
+}
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+void ff_rel_grant(_SYNC_t sobj)
+{
+	gfxSemSignal( (gfxSem*)&sobj );
+}
+#endif /* _FS_REENTRANT */
+
+#if _USE_LFN == 3	/* LFN with a working buffer on the heap */
+/*------------------------------------------------------------------------*/
+/* Allocate a memory block                                                */
+/*------------------------------------------------------------------------*/
+void *ff_memalloc(UINT size)
+{
+	return gfxAlloc( (size_t)size );
+}
+
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+void ff_memfree(void *mblock)
+{
+	gfxFree(mblock);
+}
+#endif /* _USE_LFN == 3 */
+
+#endif // GFX_USE_GFILE && GFILE_NEED_FATFS
+
diff --git a/src/gfile/gfile.c b/src/gfile/gfile.c
index a410a801..b7ebbc97 100644
--- a/src/gfile/gfile.c
+++ b/src/gfile/gfile.c
@@ -477,35 +477,33 @@ bool_t gfileEOF(GFILE *f) {
 	return f->vmt->eof(f);
 }
 
-#if GFILE_NEED_FATFS
-	bool_t gfileMount(char fs, const char* drive) {
-		const GFILEVMT *p;
-
-		// Find the correct VMT
-		for(p = FsChain; p; p = p->next) {
-			if (p->prefix == fs) {
-				if (!p->mount)
-					return FALSE;
-				return p->mount(drive);
-			}
+bool_t gfileMount(char fs, const char* drive) {
+	const GFILEVMT *p;
+
+	// Find the correct VMT
+	for(p = FsChain; p; p = p->next) {
+		if (p->prefix == fs) {
+			if (!p->mount)
+				return FALSE;
+			return p->mount(drive);
 		}
-		return FALSE;
 	}
+	return FALSE;
+}
 
-	bool_t gfileUnmount(char fs, const char* drive) {
-		const GFILEVMT *p;
+bool_t gfileUnmount(char fs, const char* drive) {
+	const GFILEVMT *p;
 
-		// Find the correct VMT
-		for(p = FsChain; p; p = p->next) {
-			if (p->prefix == fs) {
-				if (!p->mount)
-					return FALSE;
-				return p->unmount(drive);
-			}
+	// Find the correct VMT
+	for(p = FsChain; p; p = p->next) {
+		if (p->prefix == fs) {
+			if (!p->mount)
+				return FALSE;
+			return p->unmount(drive);
 		}
-		return FALSE;
 	}
-#endif
+	return FALSE;
+}
 
 /********************************************************
  * String VMT routines
diff --git a/src/gfile/inc_fatfs.c b/src/gfile/inc_fatfs.c
index ff75eb3b..a9066bf9 100644
--- a/src/gfile/inc_fatfs.c
+++ b/src/gfile/inc_fatfs.c
@@ -56,20 +56,21 @@ static const GFILEVMT FsFatFSVMT = {
 static bool_t fatfs_mounted = FALSE;
 static FATFS fatfs_fs;
 
-static void _flags2mode(GFILE* f, BYTE* mode)
+static BYTE fatfs_flags2mode(GFILE* f)
 {
-	*mode = 0;
+	BYTE mode = 0;
 
 	if (f->flags & GFILEFLG_READ)
-		*mode |= FA_READ;
+		mode |= FA_READ;
 	if (f->flags & GFILEFLG_WRITE)
-		*mode |= FA_WRITE;
+		mode |= FA_WRITE;
 	if (f->flags & GFILEFLG_APPEND)
-		*mode |= 0;  // ToDo
+		mode |= 0;  // ToDo
 	if (f->flags & GFILEFLG_TRUNC)
-		*mode |= FA_CREATE_ALWAYS;
+		mode |= FA_CREATE_ALWAYS;
 
-	/* ToDo - Complete */	
+	/* ToDo - Complete */
+	return mode;
 }
 
 static bool_t fatfsDel(const char* fname)
@@ -121,19 +122,16 @@ static bool_t fatfsRename(const char* oldname, const char* newname)
 static bool_t fatfsOpen(GFILE* f, const char* fname)
 {
 	FIL* fd;
-	BYTE mode;
-	FRESULT ferr;
-/*
-	if (!fatfs_mounted && !fatfsMount(""))
-		return FALSE;
-*/
+
+	#if !GFILE_NEED_NOAUTOMOUNT
+		if (!fatfs_mounted && !fatfsMount(""))
+			return FALSE;
+	#endif
+
 	if (!(fd = gfxAlloc(sizeof(FIL))))
 		return FALSE;
 
-	_flags2mode(f, &mode);
-
-	ferr = f_open(fd, fname, mode);
-	if (ferr != FR_OK) {
+	if (f_open(fd, fname, fatfs_flags2mode(f)) != FR_OK) {
 		gfxFree(fd);
 		f->obj = 0;
 
diff --git a/src/gfile/inc_nativefs.c b/src/gfile/inc_nativefs.c
index 26dc33c5..98e0ab10 100644
--- a/src/gfile/inc_nativefs.c
+++ b/src/gfile/inc_nativefs.c
@@ -51,7 +51,7 @@ static const GFILEVMT FsNativeVMT = {
 #undef GFILE_CHAINHEAD
 #define GFILE_CHAINHEAD		&FsNativeVMT
 
-static void flags2mode(char *buf, uint16_t flags) {
+static void Native_flags2mode(char *buf, uint16_t flags) {
 	if (flags & GFILEFLG_MUSTEXIST)
 		*buf = 'r';
 	else if (flags & GFILEFLG_APPEND)
@@ -90,7 +90,7 @@ static bool_t NativeOpen(GFILE *f, const char *fname) {
 	FILE *fd;
 	char mode[5];
 
-	flags2mode(mode, f->flags);
+	Native_flags2mode(mode, f->flags);
 	if (!(fd = fopen(fname, mode)))
 		return FALSE;
 	f->obj = (void *)fd;
diff --git a/src/gfile/sys_defs.h b/src/gfile/sys_defs.h
index cf5235d2..6b1d27ff 100644
--- a/src/gfile/sys_defs.h
+++ b/src/gfile/sys_defs.h
@@ -197,6 +197,35 @@ extern "C" {
 	 */
 	bool_t		gfileEOF(GFILE *f);
 
+	/**
+	 * @brief					Mount a logical drive (aka partition)
+	 *
+	 * @details					Not supported by every file system
+	 * @details					Currently just one drive at one is supported.
+	 *
+	 * @param[in] fs			The file system (F for FatFS)
+	 * @param[in] drive			The logical drive prefix
+	 *
+	 * @return					TRUE on success, FALSE otherwise
+	 *
+	 * @api
+	 */
+	bool_t gfileMount(char fs, const char *drive);
+
+	/**
+	 * @brief					Unmount a logical drive (aka partition)
+	 *
+	 * @details					Does have no effect if @p gfileMount() as been called before hand
+	 *
+	 * @param[in] fs			The file system (F for FatFS)
+	 * @param[in] drive			The logical drive prefix
+	 *
+	 * @return					TRUE on success, FALSE otherwise
+	 *
+	 * @api
+	 */
+	bool_t gfileUnmount(char fs, const char *drive);
+
 	#if GFILE_NEED_CHIBIOSFS && GFX_USE_OS_CHIBIOS
 		GFILE *		gfileOpenBaseFileStream(void *BaseFileStreamPtr, const char *mode);
 	#endif
@@ -205,37 +234,6 @@ extern "C" {
 		GFILE *		gfileOpenMemory(void *memptr, const char *mode);
 	#endif
 
-	#if GFILE_NEED_FATFS
-		/**
-		 * @brief					Mount a logical drive (aka partition)
-		 *
-		 * @details					Not supported by every file system
-		 * @details					Currently just one drive at one is supported.
-		 *
-		 * @param[in] fs			The file system (F for FatFS)
-		 * @param[in] drive			The logical drive prefix
-		 *
-		 * @return					TRUE on success, FALSE otherwise
-		 *
-		 * @api
-		 */
-		bool_t gfileMount(char fs, const char *drive);
-
-		/**
-		 * @brief					Unmount a logical drive (aka partition)
-		 *
-		 * @details					Does have no effect if @p gfileMount() as been called before hand
-		 *
-		 * @param[in] fs			The file system (F for FatFS)
-		 * @param[in] drive			The logical drive prefix
-		 *
-		 * @return					TRUE on success, FALSE otherwise
-		 *
-		 * @api
-		 */
-		bool_t gfileUnmount(char fs, const char *drive);	
-	#endif
-
 	#if GFILE_NEED_PRINTG
 		#include <stdarg.h>
 
diff --git a/src/gfile/sys_options.h b/src/gfile/sys_options.h
index 71eb6611..41cf6a63 100644
--- a/src/gfile/sys_options.h
+++ b/src/gfile/sys_options.h
@@ -21,16 +21,14 @@
  * @{
  */
 	/**
-	 * @brief	Should the filesystem be mounted automatically
-	 * @details	The filesystem will be mounted automatically if the
-	 *			user does not do it manually.
+	 * @brief	Should the filesystem not be mounted automatically
+	 * @details	The filesystem is normally mounted automatically if the
+	 *			user does not do it manually. This option turns that off
+	 *			so the user must manually mount the file-system first.
 	 * @details	Defaults to FALSE
-	 *
-	 * @note	Only available for filesystems that actually implement a
-	 *			mounting routine.
 	 */
-	#ifndef GFILE_NEED_AUTOMOUNT
-		#define GFILE_NEED_AUTOMOUNT	FALSE
+	#ifndef GFILE_NEED_NOAUTOMOUNT
+		#define GFILE_NEED_NOAUTOMOUNT	FALSE
 	#endif
 	/**
 	 * @brief   Include printg, fprintg etc functions