filex/common/inc/fx_api.h

/***************************************************************************
 * Copyright (c) 2024 Microsoft Corporation 
 * 
 * This program and the accompanying materials are made available under the
 * terms of the MIT License which is available at
 * https://opensource.org/licenses/MIT.
 * 
 * SPDX-License-Identifier: MIT
 **************************************************************************/


/**************************************************************************/
/**************************************************************************/
/**                                                                       */
/** FileX Component                                                       */
/**                                                                       */
/**   Application Interface                                               */
/**                                                                       */
/**************************************************************************/
/**************************************************************************/


/**************************************************************************/
/*                                                                        */
/*  APPLICATION INTERFACE DEFINITION                       RELEASE        */
/*                                                                        */
/*    fx_api.h                                            PORTABLE C      */
/*                                                           6.4.0        */
/*  AUTHOR                                                                */
/*                                                                        */
/*    William E. Lamie, Microsoft Corporation                             */
/*                                                                        */
/*  DESCRIPTION                                                           */
/*                                                                        */
/*    This file defines the basic Application Interface (API) to the      */
/*    high-performance FileX FAT compatible embedded file system.         */
/*    All service prototypes and data structure definitions are defined   */
/*    in this file.                                                       */
/*                                                                        */
/*  RELEASE HISTORY                                                       */
/*                                                                        */
/*    DATE              NAME                      DESCRIPTION             */
/*                                                                        */
/*  05-19-2020     William E. Lamie         Initial Version 6.0           */
/*  09-30-2020     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            and added conditionals to   */
/*                                            disable few declarations    */
/*                                            for code size reduction,    */
/*                                            resulting in version 6.1    */
/*  11-09-2020     William E. Lamie         Modified comment(s),          */
/*                                            resulting in version 6.1.2  */
/*  12-31-2020     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.1.3  */
/*  03-02-2021     William E. Lamie         Modified comment(s), and      */
/*                                            added standalone support,   */
/*                                            resulting in version 6.1.5  */
/*  04-02-2021     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.1.6  */
/*  06-02-2021     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.1.7  */
/*  08-02-2021     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.1.8  */
/*  01-31-2022     Bhupendra Naphade        Modified comment(s),  fixed   */
/*                                            errors without cache,       */
/*                                            resulting in version 6.1.10 */
/*  04-25-2022     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.1.11 */
/*  07-29-2022     William E. Lamie         Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.1.12 */
/*  10-31-2022     Xiuwen Cai               Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.2.0  */
/*  03-08-2023     Xiuwen Cai               Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.2.1  */
/*  10-31-2023     Xiuwen Cai               Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.3.0  */
/*  12-31-2023     Xiuwen Cai               Modified comment(s), and      */
/*                                            updated product constants,  */
/*                                            resulting in version 6.4.0  */
/*                                                                        */
/**************************************************************************/

#ifndef FX_API_H
#define FX_API_H


/* Determine if a C++ compiler is being used.  If so, ensure that standard
   C is used to process the API information.  */

#ifdef __cplusplus

/* Yes, C++ compiler is present.  Use standard C.  */
extern   "C" {

#endif


/* Disable warning of parameter not used. */
#ifndef FX_PARAMETER_NOT_USED
#define FX_PARAMETER_NOT_USED(p) ((void)(p))
#endif /* FX_PARAMETER_NOT_USED */


/* Disable ThreadX error checking for internal FileX source code.  */

#ifdef FX_SOURCE_CODE
#ifndef TX_DISABLE_ERROR_CHECKING
#define TX_DISABLE_ERROR_CHECKING
#endif
#endif


/* Include the FileX port-specific file.  */

#include "fx_port.h"

/* Define compiler library include files */

#ifdef FX_STANDALONE_ENABLE
#include   "string.h"
#endif

/* Define the major/minor version information that can be used by the application
   and the FileX source as well.  */

#define AZURE_RTOS_FILEX
#define FILEX_MAJOR_VERSION     6
#define FILEX_MINOR_VERSION     4
#define FILEX_PATCH_VERSION     0

/* Define the following symbols for backward compatibility */
#define EL_PRODUCT_FILEX

#ifdef FX_STANDALONE_ENABLE

/* FileX will be used without Azure RTOS ThreadX */

#ifndef FX_SINGLE_THREAD
#define FX_SINGLE_THREAD
#endif /* !FX_SINGLE_THREAD */


/* FileX will be used with local path logic disabled */

#ifndef FX_NO_LOCAL_PATH
#define FX_NO_LOCAL_PATH
#endif /* !FX_NO_LOCAL_PATH */


/* FileX is built without update to the time parameters. */

#ifndef FX_NO_TIMER
#define FX_NO_TIMER
#endif /* !FX_NO_TIMER */

#endif


/* Override the interrupt protection provided in FileX port files to simply use ThreadX protection,
   which is often in-line assembly.  */

#ifndef FX_LEGACY_INTERRUPT_PROTECTION
#undef  FX_INT_SAVE_AREA
#undef  FX_DISABLE_INTS
#undef  FX_RESTORE_INTS
#define FX_INT_SAVE_AREA          TX_INTERRUPT_SAVE_AREA
#define FX_DISABLE_INTS           TX_DISABLE
#define FX_RESTORE_INTS           TX_RESTORE
#endif


/* Define the update rate of the system timer.  These values may also be defined at the command
   line when compiling the fx_system_initialize.c module in the FileX library build.  Alternatively, they can
   be modified in this file.  Note: the update rate must be an even number of seconds greater
   than or equal to 2, which is the minimal update rate for FAT time. */

#ifndef FX_UPDATE_RATE_IN_SECONDS
#define FX_UPDATE_RATE_IN_SECONDS       10     /* Update time at 10 second intervals */
#endif

#ifndef FX_UPDATE_RATE_IN_TICKS
#define FX_UPDATE_RATE_IN_TICKS         1000   /* Same update rate, but in ticks  */
#endif


/* Determine if fault tolerance is selected. If so, turn on the old fault tolerant options -
   if they are not defined already.  */

#ifdef FX_ENABLE_FAULT_TOLERANT
#ifndef FX_FAULT_TOLERANT_DATA
#define FX_FAULT_TOLERANT_DATA
#endif
#ifndef FX_FAULT_TOLERANT
#define FX_FAULT_TOLERANT
#endif
#endif


/* Determine if cache is disabled. If so, disable direct read sector cache.  */
#ifdef FX_DISABLE_CACHE
#ifndef FX_DISABLE_DIRECT_DATA_READ_CACHE_FILL
#define FX_DISABLE_DIRECT_DATA_READ_CACHE_FILL
#endif
#endif


/* Determine if local paths are enabled and if the local path setup code has not been defined.
   If so, define the default local path setup code for files that reference the local path.  */

#ifndef FX_NO_LOCAL_PATH
#ifndef FX_LOCAL_PATH_SETUP
#ifndef FX_SINGLE_THREAD
#define FX_LOCAL_PATH_SETUP     extern TX_THREAD *_tx_thread_current_ptr;
#else
#define FX_NO_LOCAL_PATH
#endif
#endif
#endif

/* Determine if tracing is enabled.  */

#if defined(TX_ENABLE_EVENT_TRACE) && !defined(FX_STANDALONE_ENABLE)


/* Trace is enabled. Remap calls so that interrupts can be disabled around the actual event logging.  */

#include "tx_trace.h"


/* Define the object types in FileX, if not defined.  */

#ifndef FX_TRACE_OBJECT_TYPE_MEDIA
#define FX_TRACE_OBJECT_TYPE_MEDIA                      9               /* P1 = FAT cache size, P2 = sector cache size       */
#define FX_TRACE_OBJECT_TYPE_FILE                       10              /* none                                              */
#endif


/* Define event filters that can be used to selectively disable certain events or groups of events.  */

#define FX_TRACE_ALL_EVENTS                             0x00007800      /* All FileX events                          */
#define FX_TRACE_INTERNAL_EVENTS                        0x00000800      /* FileX internal events                     */
#define FX_TRACE_MEDIA_EVENTS                           0x00001000      /* FileX media events                        */
#define FX_TRACE_DIRECTORY_EVENTS                       0x00002000      /* FileX directory events                    */
#define FX_TRACE_FILE_EVENTS                            0x00004000      /* FileX file events                         */


/* Define the trace events in FileX, if not defined.  */

/* Define FileX Trace Events, along with a brief description of the additional information fields,
   where I1 -> Information Field 1, I2 -> Information Field 2, etc.  */

/* Define the FileX internal events first.  */

#ifndef FX_TRACE_INTERNAL_LOG_SECTOR_CACHE_MISS
#define FX_TRACE_INTERNAL_LOG_SECTOR_CACHE_MISS         201             /* I1 = media ptr, I2 = sector, I3 = total misses, I4 = cache size          */
#define FX_TRACE_INTERNAL_DIR_CACHE_MISS                202             /* I1 = media ptr, I2 = total misses                                        */
#define FX_TRACE_INTERNAL_MEDIA_FLUSH                   203             /* I1 = media ptr, I2 = dirty sectors                                       */
#define FX_TRACE_INTERNAL_DIR_ENTRY_READ                204             /* I1 = media ptr                                                           */
#define FX_TRACE_INTERNAL_DIR_ENTRY_WRITE               205             /* I1 = media ptr                                                           */
#define FX_TRACE_INTERNAL_IO_DRIVER_READ                206             /* I1 = media ptr, I2 = sector, I3 = number of sectors, I4 = buffer         */
#define FX_TRACE_INTERNAL_IO_DRIVER_WRITE               207             /* I1 = media ptr, I2 = sector, I3 = number of sectors, I4 = buffer         */
#define FX_TRACE_INTERNAL_IO_DRIVER_FLUSH               208             /* I1 = media ptr                                                           */
#define FX_TRACE_INTERNAL_IO_DRIVER_ABORT               209             /* I1 = media ptr                                                           */
#define FX_TRACE_INTERNAL_IO_DRIVER_INIT                210             /* I1 = media ptr                                                           */
#define FX_TRACE_INTERNAL_IO_DRIVER_BOOT_READ           211             /* I1 = media ptr, I2 = buffer                                              */
#define FX_TRACE_INTERNAL_IO_DRIVER_RELEASE_SECTORS     212             /* I1 = media ptr, I2 = sector, I3 = number of sectors                      */
#define FX_TRACE_INTERNAL_IO_DRIVER_BOOT_WRITE          213             /* I1 = media ptr, I2 = buffer                                              */
#define FX_TRACE_INTERNAL_IO_DRIVER_UNINIT              214             /* I1 = media ptr                                                           */


/* Define the FileX API events.  */

#define FX_TRACE_DIRECTORY_ATTRIBUTES_READ              220             /* I1 = media ptr, I2 = directory name, I3 = attributes                     */
#define FX_TRACE_DIRECTORY_ATTRIBUTES_SET               221             /* I1 = media ptr, I2 = directory name, I3 = attributes                     */
#define FX_TRACE_DIRECTORY_CREATE                       222             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_DEFAULT_GET                  223             /* I1 = media ptr, I2 = return path name                                    */
#define FX_TRACE_DIRECTORY_DEFAULT_SET                  224             /* I1 = media ptr, I2 = new path name                                       */
#define FX_TRACE_DIRECTORY_DELETE                       225             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_FIRST_ENTRY_FIND             226             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_FIRST_FULL_ENTRY_FIND        227             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_INFORMATION_GET              228             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_LOCAL_PATH_CLEAR             229             /* I1 = media ptr                                                           */
#define FX_TRACE_DIRECTORY_LOCAL_PATH_GET               230             /* I1 = media ptr, I2 = return path name                                    */
#define FX_TRACE_DIRECTORY_LOCAL_PATH_RESTORE           231             /* I1 = media ptr, I2 = local path ptr                                      */
#define FX_TRACE_DIRECTORY_LOCAL_PATH_SET               232             /* I1 = media ptr, I2 = local path ptr, I3 = new path name                  */
#define FX_TRACE_DIRECTORY_LONG_NAME_GET                233             /* I1 = media ptr, I2 = short file name, I3 = long file name                */
#define FX_TRACE_DIRECTORY_NAME_TEST                    234             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_NEXT_ENTRY_FIND              235             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_NEXT_FULL_ENTRY_FIND         236             /* I1 = media ptr, I2 = directory name                                      */
#define FX_TRACE_DIRECTORY_RENAME                       237             /* I1 = media ptr, I2 = old directory name, I3 = new directory name         */
#define FX_TRACE_DIRECTORY_SHORT_NAME_GET               238             /* I1 = media ptr, I2 = long file name, I3 = short file name                */
#define FX_TRACE_FILE_ALLOCATE                          239             /* I1 = file ptr, I2 = size I3 = previous size, I4 = new size               */
#define FX_TRACE_FILE_ATTRIBUTES_READ                   240             /* I1 = media ptr, I2 = file name, I3 = attributes                          */
#define FX_TRACE_FILE_ATTRIBUTES_SET                    241             /* I1 = media ptr, I2 = file name, I3 = attributes                          */
#define FX_TRACE_FILE_BEST_EFFORT_ALLOCATE              242             /* I1 = file ptr, I2 = size, I3 = actual_size_allocated                     */
#define FX_TRACE_FILE_CLOSE                             243             /* I1 = file ptr, I3 = file size                                            */
#define FX_TRACE_FILE_CREATE                            244             /* I1 = media ptr, I2 = file name                                           */
#define FX_TRACE_FILE_DATE_TIME_SET                     245             /* I1 = media ptr, I2 = file name, I3 = year, I4 = month                    */
#define FX_TRACE_FILE_DELETE                            246             /* I1 = media ptr, I2 = file name                                           */
#define FX_TRACE_FILE_OPEN                              247             /* I1 = media ptr, I2 = file ptr, I3 = file name, I4 = open type            */
#define FX_TRACE_FILE_READ                              248             /* I1 = file ptr, I2 = buffer ptr, I3 = request size I4 = actual size       */
#define FX_TRACE_FILE_RELATIVE_SEEK                     249             /* I1 = file ptr, I2 = byte offset, I3 = seek from, I4 = previous offset    */
#define FX_TRACE_FILE_RENAME                            250             /* I1 = media ptr, I2 = old file name, I3 = new file name                   */
#define FX_TRACE_FILE_SEEK                              251             /* I1 = file ptr, I2 = byte offset, I3 = previous offset                    */
#define FX_TRACE_FILE_TRUNCATE                          252             /* I1 = file ptr, I2 = size, I3 = previous size, I4 = new size              */
#define FX_TRACE_FILE_TRUNCATE_RELEASE                  253             /* I1 = file ptr, I2 = size, I3 = previous size, I4 = new size              */
#define FX_TRACE_FILE_WRITE                             254             /* I1 = file ptr, I2 = buffer ptr, I3 = size, I4 = bytes written            */
#define FX_TRACE_MEDIA_ABORT                            255             /* I1 = media ptr                                                           */
#define FX_TRACE_MEDIA_CACHE_INVALIDATE                 256             /* I1 = media ptr                                                           */
#define FX_TRACE_MEDIA_CHECK                            257             /* I1 = media ptr, I2 = scratch memory, I3 = scratch memory size, I4 =errors*/
#define FX_TRACE_MEDIA_CLOSE                            258             /* I1 = media ptr                                                           */
#define FX_TRACE_MEDIA_FLUSH                            259             /* I1 = media ptr                                                           */
#define FX_TRACE_MEDIA_FORMAT                           260             /* I1 = media ptr, I2 = root entries, I3 = sectors, I4 = sectors per cluster*/
#define FX_TRACE_MEDIA_OPEN                             261             /* I1 = media ptr, I2 = media driver, I3 = memory ptr, I4 = memory size     */
#define FX_TRACE_MEDIA_READ                             262             /* I1 = media ptr, I2 = logical sector, I3 = buffer ptr, I4 = bytes read    */
#define FX_TRACE_MEDIA_SPACE_AVAILABLE                  263             /* I1 = media ptr, I2 = available bytes ptr, I3 = available clusters        */
#define FX_TRACE_MEDIA_VOLUME_GET                       264             /* I1 = media ptr, I2 = volume name, I3 = volume source                     */
#define FX_TRACE_MEDIA_VOLUME_SET                       265             /* I1 = media ptr, I2 = volume name                                         */
#define FX_TRACE_MEDIA_WRITE                            266             /* I1 = media ptr, I2 = logical_sector, I3 = buffer_ptr, I4 = byte written  */
#define FX_TRACE_SYSTEM_DATE_GET                        267             /* I1 = year, I2 = month, I3 = day                                          */
#define FX_TRACE_SYSTEM_DATE_SET                        268             /* I1 = year, I2 = month, I3 = day                                          */
#define FX_TRACE_SYSTEM_INITIALIZE                      269             /* None                                                                     */
#define FX_TRACE_SYSTEM_TIME_GET                        270             /* I1 = hour, I2 = minute, I3 = second                                      */
#define FX_TRACE_SYSTEM_TIME_SET                        271             /* I1 = hour, I2 = minute, I3 = second                                      */
#define FX_TRACE_UNICODE_DIRECTORY_CREATE               272             /* I1 = media ptr, I2 = source unicode, I3 = source length, I4 = short_name */
#define FX_TRACE_UNICODE_DIRECTORY_RENAME               273             /* I1 = media ptr, I2 = source unicode, I3 = source length, I4 = new_name   */
#define FX_TRACE_UNICODE_FILE_CREATE                    274             /* I1 = media ptr, I2 = source unicode, I3 = source length, I4 = short name */
#define FX_TRACE_UNICODE_FILE_RENAME                    275             /* I1 = media ptr, I2 = source unicode, I3 = source length, I4 = new name   */
#define FX_TRACE_UNICODE_LENGTH_GET                     276             /* I1 = unicode name, I2 = length                                           */
#define FX_TRACE_UNICODE_NAME_GET                       277             /* I1 = media ptr, I2 = source short name, I3 = unicode name, I4 = length   */
#define FX_TRACE_UNICODE_SHORT_NAME_GET                 278             /* I1 = media ptr, I2 = source unicode name, I3 = length, I4 =  short name  */
#endif


/* Map the trace macros to internal FileX versions so we can get interrupt protection.  */

#ifdef FX_SOURCE_CODE

#define FX_TRACE_OBJECT_REGISTER(t, p, n, a, b)         _fx_trace_object_register(t, (VOID *)p, (CHAR *)n, (ULONG)a, (ULONG)b);
#define FX_TRACE_OBJECT_UNREGISTER(o)                   _fx_trace_object_unregister((VOID *)o);
#define FX_TRACE_IN_LINE_INSERT(i, a, b, c, d, f, g, h) _fx_trace_event_insert((ULONG)i, (ULONG)a, (ULONG)b, (ULONG)c, (ULONG)d, (ULONG)f, g, h);
#define FX_TRACE_EVENT_UPDATE(e, t, i, a, b, c, d)      _fx_trace_event_update((TX_TRACE_BUFFER_ENTRY *)e, (ULONG)t, (ULONG)i, (ULONG)a, (ULONG)b, (ULONG)c, (ULONG)d);


/* Define FileX trace prototypes.  */

VOID _fx_trace_object_register(UCHAR object_type, VOID *object_ptr, CHAR *object_name, ULONG parameter_1, ULONG parameter_2);
VOID _fx_trace_object_unregister(VOID *object_ptr);
VOID _fx_trace_event_insert(ULONG event_id, ULONG info_field_1, ULONG info_field_2, ULONG info_field_3, ULONG info_field_4, ULONG filter, TX_TRACE_BUFFER_ENTRY **current_event, ULONG *current_timestamp);
VOID _fx_trace_event_update(TX_TRACE_BUFFER_ENTRY *event, ULONG timestamp, ULONG event_id, ULONG info_field_1, ULONG info_field_2, ULONG info_field_3, ULONG info_field_4);

#endif

#else
#define FX_TRACE_OBJECT_REGISTER(t, p, n, a, b)
#define FX_TRACE_OBJECT_UNREGISTER(o)
#define FX_TRACE_IN_LINE_INSERT(i, a, b, c, d, f, g, h)
#define FX_TRACE_EVENT_UPDATE(e, t, i, a, b, c, d)
#endif


/* Define basic constants for FileX.  */

#define FX_MEDIA_ID                            ((ULONG)0x4D454449)
#define FX_MEDIA_CLOSED_ID                     ((ULONG)0x4D454443)
#define FX_MEDIA_ABORTED_ID                    ((ULONG)0x4D454441)

#define FX_FILE_ID                             ((ULONG)0x46494C45)
#define FX_FILE_CLOSED_ID                      ((ULONG)0x46494C43)
#define FX_FILE_ABORTED_ID                     ((ULONG)0x46494C41)


/* The maximum path includes the entire path and the file name.  */

#ifndef FX_MAXIMUM_PATH
#define FX_MAXIMUM_PATH                        256
#endif


/* Define directory entry name sizes. Directory entries are found in the
   root directory and in directory files (sub-directories). Each directory
   entry has a short file name which is a fixed maximum of 13 characters and
   and optional 255 character long file name.  */

#ifndef FX_MAX_LONG_NAME_LEN
#define FX_MAX_LONG_NAME_LEN                   256      /* Minimum value is 13, Maximum value is 256.  */
#endif

#define FX_MAX_SHORT_NAME_LEN                  13       /* Only allowed value is 13.  */

#ifndef FX_MAX_LAST_NAME_LEN
#define FX_MAX_LAST_NAME_LEN                   256      /* Should be as large or larger than FX_MAX_LONG_NAME_LEN.  */
#endif


/* Define constants related to the logical sector cache. These constants represent the maximum
   number of logical sectors that can be cached. The actual number of logical sectors in the
   cache is determined by the amount of memory supplied to fx_media_open for the FX_MEDIA
   instance.  */

#ifndef FX_MAX_SECTOR_CACHE
#define FX_MAX_SECTOR_CACHE                    256      /* Maximum size of logical sector cache,
                                                           minimum value of 2 all other values must
                                                           be a power of 2.  */
#endif

/* Define the mask for the hash index into the logical sector cache.  If the logical sector cache
   determined by the amount of memory supplied by the application to fx_media_open is larger than
   FX_SECTOR_CACHE_HASH_ENABLE (usually 16) and can satisfy FX_MAX_SECTOR_CACHE sectors, the cache
   is divided into 4 entry pieces (FX_SECTOR_CACHE_DEPTH) that are indexed by the formula:

        index =  (cluster & media_ptr -> fx_media_sector_cache_hash_mask) * FX_SECTOR_CACHE_LEVELS

   The FX_SECTOR_CACHE_DEPTH define must not be changed unless the logical sector read/write
   code is also changed.  */

#define FX_SECTOR_CACHE_HASH_ENABLE            16
#define FX_SECTOR_CACHE_DEPTH                  4

#ifndef FX_FAT_MAP_SIZE
#define FX_FAT_MAP_SIZE                        128  /* Minimum 1, maximum any. This represents how many 32-bit words used for the written FAT sector bit map. */
#endif

#ifndef FX_MAX_FAT_CACHE
#define FX_MAX_FAT_CACHE                       16   /* Minimum value is 8, all values must be a power of 2.  */
#endif


/* Define the size of fault tolerant cache, which is used when freeing FAT chain. */

#ifndef FX_FAULT_TOLERANT_CACHE_SIZE
#define FX_FAULT_TOLERANT_CACHE_SIZE           1024
#endif /* FX_FAULT_TOLERANT_CACHE_SIZE */


/* Define the mask for the hash index into the FAT table.  The FAT cache is divided into 4 entry pieces
   that are indexed by the formula:

            index =  (cluster & FX_FAT_CACHE_HASH_MASK) * FX_FAT_CACHE_LEVELS

   The FX_FAT_CACHE_DEPTH define must not be changed unless the FAT entry read/write code is also changed.  */

#define FX_FAT_CACHE_DEPTH                     4
#define FX_FAT_CACHE_HASH_MASK                 ((FX_MAX_FAT_CACHE / FX_FAT_CACHE_DEPTH) - 1)


/* FileX API input parameters and general constants.  */

#define FX_TRUE                                1
#define FX_FALSE                               0
#define FX_NULL                                0
#define FX_OPEN_FOR_READ                       0
#define FX_OPEN_FOR_WRITE                      1
#define FX_OPEN_FOR_READ_FAST                  2

#define FX_12_BIT_FAT_SIZE                     4086
#define FX_16_BIT_FAT_SIZE                     65525
#define FX_MAX_12BIT_CLUST                     0x0FF0
#define FX_SIGN_EXTEND                         0xF000
#define FX_12BIT_SIZE                          3    /* 2 FAT entries per 3 bytes  */

#define FX_FAT_ENTRY_START                     2
#define FX_DIR_ENTRY_SIZE                      32
#define FX_DIR_NAME_SIZE                       8
#define FX_DIR_EXT_SIZE                        3
#define FX_DIR_RESERVED                        8
#define FX_DIR_ENTRY_FREE                      0xE5
#define FX_DIR_ENTRY_DONE                      0x00
#define FX_READ_ONLY                           0x01
#define FX_HIDDEN                              0x02
#define FX_SYSTEM                              0x04
#define FX_VOLUME                              0x08
#define FX_DIRECTORY                           0x10
#define FX_ARCHIVE                             0x20
#define FX_LONG_NAME                           (FX_READ_ONLY | FX_HIDDEN | FX_SYSTEM | FX_VOLUME)
#define FX_LONG_NAME_ENTRY_LEN                 13


/* Define FAT FAT entry values.  */

#define FX_FREE_CLUSTER                        0x0000
#define FX_NOT_USED                            0x0001
#define FX_RESERVED_1                          0xFFF0
#define FX_RESERVED_2                          0xFFF6
#define FX_BAD_CLUSTER                         0xFFF7
#define FX_LAST_CLUSTER_1                      0xFFF8
#define FX_LAST_CLUSTER_2                      0xFFFF

#define FX_RESERVED_1_32                       0x0FFFFFF0
#define FX_RESERVED_2_32                       0x0FFFFFF6
#define FX_BAD_CLUSTER_32                      0x0FFFFFF7
#define FX_LAST_CLUSTER_1_32                   0x0FFFFFF8
#define FX_LAST_CLUSTER_2_32                   0x0FFFFFFF


/* Define time/date FAT constants.  */

#define FX_YEAR_SHIFT                          9
#define FX_MONTH_SHIFT                         5
#define FX_HOUR_SHIFT                          11
#define FX_MINUTE_SHIFT                        5
#define FX_YEAR_MASK                           0x7F
#define FX_MONTH_MASK                          0x0F
#define FX_DAY_MASK                            0x1F
#define FX_HOUR_MASK                           0x1F
#define FX_MINUTE_MASK                         0x3F
#define FX_SECOND_MASK                         0x1F
#define FX_BASE_YEAR                           1980
#define FX_MAXIMUM_YEAR                        2107
#define FX_MAXIMUM_MONTH                       12
#define FX_MAXIMUM_HOUR                        23
#define FX_MAXIMUM_MINUTE                      59
#define FX_MAXIMUM_SECOND                      59
#define FX_INITIAL_DATE                        0x4A21   /* 01-01-2017 */
#define FX_INITIAL_TIME                        0x0000   /* 12:00 am   */

/* FileX API return values.  */

#define FX_SUCCESS                             0x00
#define FX_BOOT_ERROR                          0x01
#define FX_MEDIA_INVALID                       0x02
#define FX_FAT_READ_ERROR                      0x03
#define FX_NOT_FOUND                           0x04
#define FX_NOT_A_FILE                          0x05
#define FX_ACCESS_ERROR                        0x06
#define FX_NOT_OPEN                            0x07
#define FX_FILE_CORRUPT                        0x08
#define FX_END_OF_FILE                         0x09
#define FX_NO_MORE_SPACE                       0x0A
#define FX_ALREADY_CREATED                     0x0B
#define FX_INVALID_NAME                        0x0C
#define FX_INVALID_PATH                        0x0D
#define FX_NOT_DIRECTORY                       0x0E
#define FX_NO_MORE_ENTRIES                     0x0F
#define FX_DIR_NOT_EMPTY                       0x10
#define FX_MEDIA_NOT_OPEN                      0x11
#define FX_INVALID_YEAR                        0x12
#define FX_INVALID_MONTH                       0x13
#define FX_INVALID_DAY                         0x14
#define FX_INVALID_HOUR                        0x15
#define FX_INVALID_MINUTE                      0x16
#define FX_INVALID_SECOND                      0x17
#define FX_PTR_ERROR                           0x18
#define FX_INVALID_ATTR                        0x19
#define FX_CALLER_ERROR                        0x20
#define FX_BUFFER_ERROR                        0x21
#define FX_NOT_IMPLEMENTED                     0x22
#define FX_WRITE_PROTECT                       0x23
#define FX_INVALID_OPTION                      0x24
#define FX_SECTOR_INVALID                      0x89
#define FX_IO_ERROR                            0x90
#define FX_NOT_ENOUGH_MEMORY                   0x91
#define FX_ERROR_FIXED                         0x92
#define FX_ERROR_NOT_FIXED                     0x93
#define FX_NOT_AVAILABLE                       0x94
#define FX_INVALID_CHECKSUM                    0x95
#define FX_READ_CONTINUE                       0x96
#define FX_INVALID_STATE                       0x97


/* FileX driver interface constants.  */

#define FX_DRIVER_READ                         0
#define FX_DRIVER_WRITE                        1
#define FX_DRIVER_FLUSH                        2
#define FX_DRIVER_ABORT                        3
#define FX_DRIVER_INIT                         4
#define FX_DRIVER_BOOT_READ                    5
#define FX_DRIVER_RELEASE_SECTORS              6
#define FX_DRIVER_BOOT_WRITE                   7
#define FX_DRIVER_UNINIT                       8


/* Define relative seek constants.  */

#define FX_SEEK_BEGIN                          0
#define FX_SEEK_END                            1
#define FX_SEEK_FORWARD                        2
#define FX_SEEK_BACK                           3


/* Define types for logical sectors. This information is passed to the driver
   as additional information.  */

#define FX_UNKNOWN_SECTOR                      0
#define FX_BOOT_SECTOR                         1
#define FX_FAT_SECTOR                          2
#define FX_DIRECTORY_SECTOR                    3
#define FX_DATA_SECTOR                         4


/* Define media diagnostic constants.  */

#define FX_FAT_CHAIN_ERROR                     0x01
#define FX_DIRECTORY_ERROR                     0x02
#define FX_LOST_CLUSTER_ERROR                  0x04
#define FX_FILE_SIZE_ERROR                     0x08


/* Define boot record offset constants.  */

#define FX_JUMP_INSTR                          0x000
#define FX_OEM_NAME                            0x003
#define FX_BYTES_SECTOR                        0x00B
#define FX_SECTORS_CLUSTER                     0x00D
#define FX_RESERVED_SECTORS                    0x00E
#define FX_NUMBER_OF_FATS                      0x010
#define FX_ROOT_DIR_ENTRIES                    0x011
#define FX_SECTORS                             0x013
#define FX_MEDIA_TYPE                          0x015
#define FX_SECTORS_PER_FAT                     0x016
#define FX_SECTORS_PER_TRK                     0x018
#define FX_HEADS                               0x01A
#define FX_HIDDEN_SECTORS                      0x01C
#define FX_HUGE_SECTORS                        0x020
#define FX_DRIVE_NUMBER                        0x024
#define FX_RESERVED                            0x025
#define FX_BOOT_SIG                            0x026
#define FX_BOOT_SIG_32                         0x042
#define FX_VOLUME_ID                           0x027
#define FX_VOLUME_ID_32                        0x043
#define FX_VOLUME_LABEL                        0x02B
#define FX_VOLUME_LABEL_32                     0x047
#define FX_FILE_SYSTEM_TYPE                    0x036
#define FX_SIG_OFFSET                          0x1FE
#define FX_ROOT_CLUSTER_32                     0x02C
#define FX_SECTORS_PER_FAT_32                  0x024
#define FX_SIG_BYTE_1                          0x55
#define FX_SIG_BYTE_2                          0xAA


/* If not-defined, default port-specific processing extensions to white space.  */

#ifndef FX_FILE_OPEN_EXTENSION
#define FX_FILE_OPEN_EXTENSION
#endif

#ifndef FX_DIRECTORY_ENTRY_READ_EXTENSION
#define FX_DIRECTORY_ENTRY_READ_EXTENSION
#endif

#ifndef FX_DIRECTORY_ENTRY_WRITE_EXTENSION
#define FX_DIRECTORY_ENTRY_WRITE_EXTENSION
#endif

#ifndef FX_UTILITY_FAT_ENTRY_READ_EXTENSION
#define FX_UTILITY_FAT_ENTRY_READ_EXTENSION
#endif

#ifndef FX_UTILITY_FAT_ENTRY_WRITE_EXTENSION
#define FX_UTILITY_FAT_ENTRY_WRITE_EXTENSION
#endif

#ifndef FX_UTILITY_LOGICAL_SECTOR_FLUSH_EXTENSION
#define FX_UTILITY_LOGICAL_SECTOR_FLUSH_EXTENSION
#endif

#ifndef FX_UTILITY_LOGICAL_SECTOR_READ_EXTENSION
#define FX_UTILITY_LOGICAL_SECTOR_READ_EXTENSION
#endif

#ifndef FX_UTILITY_LOGICAL_SECTOR_READ_EXTENSION_1
#define FX_UTILITY_LOGICAL_SECTOR_READ_EXTENSION_1
#endif

#ifndef FX_UTILITY_LOGICAL_SECTOR_WRITE_EXTENSION
#define FX_UTILITY_LOGICAL_SECTOR_WRITE_EXTENSION
#endif




/* Define the control block definitions for all system objects.  */


/* Define a single entry in the FAT cache.  The FAT cache is used to reduce the
   number of times the actual FAT sectors need to be accessed, thereby improving
   performance.  */

typedef struct FX_FAT_CACHE_ENTRY_STRUCT
{
    ULONG fx_fat_cache_entry_cluster;
    ULONG fx_fat_cache_entry_value;
    ULONG fx_fat_cache_entry_dirty;
} FX_FAT_CACHE_ENTRY;


/* Define the directory entry structure that contains information about a specific
   directory entry.  */

typedef struct FX_DIR_ENTRY_STRUCT
{

    CHAR   *fx_dir_entry_name;
    CHAR    fx_dir_entry_short_name[FX_MAX_SHORT_NAME_LEN];                 /* Short file name, if LFN is present                */
    UINT    fx_dir_entry_long_name_present;                                 /* 0 (default) => LFN not present; 1 => LFN present  */
    UINT    fx_dir_entry_long_name_shorted;                                 /* LFN too large, file name was made shorter         */
    UCHAR   fx_dir_entry_attributes;                                        /* Directory entry attributes                        */
    UCHAR   fx_dir_entry_reserved;                                          /* NT reserved, write 0 at create, otherwise ignore  */
    UCHAR   fx_dir_entry_created_time_ms;                                   /* Create time in milliseconds, always write 0       */
    UINT    fx_dir_entry_created_time;                                      /* Created time                                      */
    UINT    fx_dir_entry_created_date;                                      /* Created date                                      */
    UINT    fx_dir_entry_last_accessed_date;                                /* Last accessed date                                */
    UINT    fx_dir_entry_time;                                              /* Modified time                                     */
    UINT    fx_dir_entry_date;                                              /* Modified cluster                                  */
    ULONG   fx_dir_entry_cluster;                                           /* File/directory's starting cluster                 */
    ULONG64 fx_dir_entry_file_size;                                         /* Size of the file in bytes                         */
    ULONG64 fx_dir_entry_log_sector;                                        /* Logical sector of this directory entry            */
    ULONG   fx_dir_entry_byte_offset;                                       /* Offset in logical sector of this directory entry  */
    ULONG   fx_dir_entry_number;                                            /* Index into the directory                          */
    ULONG   fx_dir_entry_last_search_cluster;                               /* Last cluster searched                             */
    ULONG   fx_dir_entry_last_search_relative_cluster;                      /* Last relative cluster searched                    */
    ULONG64 fx_dir_entry_last_search_log_sector;                            /* Last logical sector searched                      */
    ULONG   fx_dir_entry_last_search_byte_offset;                           /* Last offset in logical sector searched            */
    ULONG64 fx_dir_entry_next_log_sector;

} FX_DIR_ENTRY;

typedef FX_DIR_ENTRY  *FX_DIR_ENTRY_PTR;


/* Define the path data structure.  This structure will contain
   the current path and the information for performing directory
   entry operations.  */

typedef struct FX_PATH_STRUCT
{
    /* Define the path information.  */
    FX_DIR_ENTRY fx_path_directory;
    CHAR         fx_path_string[FX_MAXIMUM_PATH];
    CHAR         fx_path_name_buffer[FX_MAX_LONG_NAME_LEN];
    ULONG        fx_path_current_entry;
} FX_PATH;

typedef FX_PATH FX_LOCAL_PATH;


/* Define the cache control data structure.  There are FX_MAX_SECTOR_CACHE
   of these structures defined inside the FX_MEDIA structure.  Each entry
   maintains a cache representation of a media sector.  */

typedef struct FX_CACHED_SECTOR_STRUCT
{

    /* Define the buffer pointer associated with this cache entry.  */
    UCHAR               *fx_cached_sector_memory_buffer;

    /* Define the sector number that is cached.  */
    ULONG64             fx_cached_sector;

    /* Define the flag that indicates whether or not the cached sector
       has been modified and needs to be written to the media.  */
    UCHAR               fx_cached_sector_buffer_dirty;

    /* Define the valid flag that indicates whether or not this entry is
       still valid.  */
    UCHAR               fx_cached_sector_valid;

    /* Define the sector type, which indicates what type of sector is present.  */
    UCHAR               fx_cached_sector_type;

    /* Define a reserved byte, reserved for future use.  */
    UCHAR               fx_cached_sector_reserved;

    /* Define the next cached sector pointer.  This is used to implement
       the "last used" algorithm when looking for cache entry to swap out to
       the physical media.  */
    struct FX_CACHED_SECTOR_STRUCT
                        *fx_cached_sector_next_used;

} FX_CACHED_SECTOR;


/* Determine if the media control block has an extension defined. If not,
   define the extension to whitespace.  */

#ifndef FX_MEDIA_MODULE_EXTENSION
#define FX_MEDIA_MODULE_EXTENSION
#endif


/* Define the media control block.  All information about each open
   media device are maintained in by the FX_MEDIA data type.  */

typedef struct FX_MEDIA_STRUCT
{

    /* Define the media ID used for error checking.  */
    ULONG               fx_media_id;

    /* Define the media's name.  */
    CHAR                *fx_media_name;

    /* Remember the memory buffer area.  */
    UCHAR               *fx_media_memory_buffer;
    ULONG               fx_media_memory_size;

#ifdef FX_DISABLE_CACHE
    ULONG64             fx_media_memory_buffer_sector;
#else

    /* Define the flag that indicates whether the logical cache utilizes
       a hash function or is a linear search. If set, the logical cache
       is accessed via a hash function on the requested sector.  */
    UINT                fx_media_sector_cache_hashed;

    /* Define the number of sectors that can actually be cached based on the
       user supplied buffer at media open time.  */
    ULONG               fx_media_sector_cache_size;

    /* Define the end of the cache area.  This is used to determine
       if the I/O is for the internal memory of the media.  */
    UCHAR               *fx_media_sector_cache_end;

    /* Define the list head of the cached sector entries.  This
       pointer points to the most recently used cache sector.  */
    struct FX_CACHED_SECTOR_STRUCT
                        *fx_media_sector_cache_list_ptr;

    /* Define the bit map that represents the hashed cache sectors that are
       valid. This bit map will help optimize the invalidation of the hashed
       sector cache.  */
    ULONG               fx_media_sector_cache_hashed_sector_valid;

    /* Define the outstanding dirty sector counter. This is used to optimize
       the searching of sectors to flush to the media.  */
    ULONG               fx_media_sector_cache_dirty_count;
#endif /* FX_DISABLE_CACHE */

    /* Define the basic information about the associated media.  */
    UINT                fx_media_bytes_per_sector;
    UINT                fx_media_sectors_per_track;
    UINT                fx_media_heads;

    ULONG64             fx_media_total_sectors;
    ULONG               fx_media_total_clusters;


    UINT                fx_media_reserved_sectors;
    UINT                fx_media_root_sector_start;
    UINT                fx_media_root_sectors;
    UINT                fx_media_data_sector_start;
    UINT                fx_media_sectors_per_cluster;
    UINT                fx_media_sectors_per_FAT;
    UINT                fx_media_number_of_FATs;
    UINT                fx_media_12_bit_FAT;
    UINT                fx_media_32_bit_FAT;
    ULONG               fx_media_FAT32_additional_info_sector;
    UINT                fx_media_FAT32_additional_info_last_available;
#ifdef FX_DRIVER_USE_64BIT_LBA
    ULONG64             fx_media_hidden_sectors;
#else
    ULONG               fx_media_hidden_sectors;
#endif
    ULONG               fx_media_root_cluster_32;
    UINT                fx_media_root_directory_entries;
    ULONG               fx_media_available_clusters;
    ULONG               fx_media_cluster_search_start;

    /* Define the information pertinent to the I/O driver interface.  */

    VOID                *fx_media_driver_info;
    UINT                fx_media_driver_request;
    UINT                fx_media_driver_status;
    UCHAR               *fx_media_driver_buffer;
#ifdef FX_DRIVER_USE_64BIT_LBA
    ULONG64             fx_media_driver_logical_sector;
#else
    ULONG               fx_media_driver_logical_sector;
#endif
    ULONG               fx_media_driver_sectors;
    ULONG               fx_media_driver_physical_sector;
    UINT                fx_media_driver_physical_track;
    UINT                fx_media_driver_physical_head;
    UINT                fx_media_driver_write_protect;      /* The driver sets this to FX_TRUE when media is write protected.  */
    UINT                fx_media_driver_free_sector_update; /* The driver sets this to FX_TRUE when it needs to know freed clusters.  */
    UINT                fx_media_driver_system_write;
    UINT                fx_media_driver_data_sector_read;
    UINT                fx_media_driver_sector_type;

    /* Define the driver entry point.  */
    VOID                (*fx_media_driver_entry)(struct FX_MEDIA_STRUCT *);

    /* Define notify function called when media is open. */
    VOID                (*fx_media_open_notify)(struct FX_MEDIA_STRUCT *);

    /* Define notify function called when media is closed. */
    VOID                (*fx_media_close_notify)(struct FX_MEDIA_STRUCT *);

    /* Define the head pointer for the open files of this media.  */
    struct FX_FILE_STRUCT
                        *fx_media_opened_file_list;

    /* Define the counter for keeping track of how many open files are
       present.  */
    ULONG               fx_media_opened_file_count;

    /* Define the next and previous link pointers for the open media list.  */
    struct FX_MEDIA_STRUCT
                        *fx_media_opened_next,
                        *fx_media_opened_previous;

#ifndef FX_MEDIA_STATISTICS_DISABLE

    /* Define various statistics for this media instance. This information
       should be useful in performance tuning and optimizing the application.  */

    ULONG               fx_media_directory_attributes_reads;
    ULONG               fx_media_directory_attributes_sets;
    ULONG               fx_media_directory_creates;
    ULONG               fx_media_directory_default_gets;
    ULONG               fx_media_directory_default_sets;
    ULONG               fx_media_directory_deletes;
    ULONG               fx_media_directory_first_entry_finds;
    ULONG               fx_media_directory_first_full_entry_finds;
    ULONG               fx_media_directory_information_gets;
    ULONG               fx_media_directory_local_path_clears;
    ULONG               fx_media_directory_local_path_gets;
    ULONG               fx_media_directory_local_path_restores;
    ULONG               fx_media_directory_local_path_sets;
    ULONG               fx_media_directory_name_tests;
    ULONG               fx_media_directory_next_entry_finds;
    ULONG               fx_media_directory_next_full_entry_finds;
    ULONG               fx_media_directory_renames;
    ULONG               fx_media_file_allocates;
    ULONG               fx_media_file_attributes_reads;
    ULONG               fx_media_file_attributes_sets;
    ULONG               fx_media_file_best_effort_allocates;
    ULONG               fx_media_file_closes;
    ULONG               fx_media_file_creates;
    ULONG               fx_media_file_deletes;
    ULONG               fx_media_file_opens;
    ULONG               fx_media_file_reads;
    ULONG               fx_media_file_relative_seeks;
    ULONG               fx_media_file_renames;
    ULONG               fx_media_file_seeks;
    ULONG               fx_media_file_truncates;
    ULONG               fx_media_file_truncate_releases;
    ULONG               fx_media_file_writes;
    ULONG               fx_media_aborts;
    ULONG               fx_media_flushes;
    ULONG               fx_media_reads;
    ULONG               fx_media_writes;
    ULONG               fx_media_directory_entry_reads;
    ULONG               fx_media_directory_entry_writes;
    ULONG               fx_media_directory_searches;
    ULONG               fx_media_directory_free_searches;
    ULONG               fx_media_fat_entry_reads;
    ULONG               fx_media_fat_entry_writes;
    ULONG               fx_media_fat_entry_cache_read_hits;
    ULONG               fx_media_fat_entry_cache_read_misses;
    ULONG               fx_media_fat_entry_cache_write_hits;
    ULONG               fx_media_fat_entry_cache_write_misses;
    ULONG               fx_media_fat_cache_flushes;
    ULONG               fx_media_fat_sector_reads;
    ULONG               fx_media_fat_sector_writes;
    ULONG               fx_media_logical_sector_reads;
    ULONG               fx_media_logical_sector_writes;
    ULONG               fx_media_logical_sector_cache_read_hits;
    ULONG               fx_media_logical_sector_cache_read_misses;
    ULONG               fx_media_driver_read_requests;
    ULONG               fx_media_driver_write_requests;
    ULONG               fx_media_driver_boot_read_requests;
    ULONG               fx_media_driver_boot_write_requests;
    ULONG               fx_media_driver_release_sectors_requests;
    ULONG               fx_media_driver_flush_requests;
#ifndef FX_MEDIA_DISABLE_SEARCH_CACHE
    ULONG               fx_media_directory_search_cache_hits;
#endif
#endif

    /* Define the media's protection object, which is a ThreadX mutex.
       Only one thread is allowed to access any media or associated files
       at a time.  If FX_SINGLE_THREAD is defined, the FileX services are
       going to be called from only one thread, hence the protection is
       not needed.  */
#ifndef FX_SINGLE_THREAD
    TX_MUTEX            fx_media_protect;
#endif

#ifndef FX_MEDIA_DISABLE_SEARCH_CACHE

    /* Define the information used to remember the last directory entry found through
       searching or walking the directory via directory entry next. This information
       will be used to eliminate multiple searches for the same directory entry if
       the accesses are done sequentially.  */
    UINT                fx_media_last_found_directory_valid;
    FX_DIR_ENTRY        fx_media_last_found_directory;
    FX_DIR_ENTRY        fx_media_last_found_entry;
    CHAR                fx_media_last_found_file_name[FX_MAX_LONG_NAME_LEN];
    CHAR                fx_media_last_found_name[FX_MAX_LAST_NAME_LEN];
#endif

    /* Define the current directory information for the media.  */
    FX_PATH             fx_media_default_path;

    /* Define FAT entry cache and the variable used to index the cache.  */
    FX_FAT_CACHE_ENTRY  fx_media_fat_cache[FX_MAX_FAT_CACHE];

    /* Define the FAT secondary update map.  This will be used on flush and
       close to update sectors of any secondary FATs in the media.  */
    UCHAR               fx_media_fat_secondary_update_map[FX_FAT_MAP_SIZE];

    /* Define a variable for the application's use.  */
    ALIGN_TYPE          fx_media_reserved_for_user;

    /* Define an area to allocate long file names so that local storage on
       calling thread's stack is not used for long file names.  This helps
       reduce the amount of thread stack space needed when using FileX.  */
    CHAR                fx_media_name_buffer[4*FX_MAX_LONG_NAME_LEN];

#ifdef FX_RENAME_PATH_INHERIT

    /* Define the file and directory rename buffer that will be used to prepend
       paths when necessary to the target file name.  */
    CHAR                fx_media_rename_buffer[FX_MAXIMUM_PATH];
#endif

#ifndef FX_DISABLE_CACHE
    /* Define the sector cache control structures for this media.  */
    struct FX_CACHED_SECTOR_STRUCT
                        fx_media_sector_cache[FX_MAX_SECTOR_CACHE];

    /* Define the sector cache hash mask so that the hash algorithm can be used with
       any power of 2 number of cache sectors.  */
    ULONG               fx_media_sector_cache_hash_mask;
#endif /* FX_DISABLE_CACHE */

    /* Define a variable to disable burst cache. This is used by the underlying
       driver.  */
    ULONG               fx_media_disable_burst_cache;

#ifdef FX_ENABLE_FAULT_TOLERANT

    /* Fault tolerant information */
    /* Indicate whether fault tolerant is enabled. */

    UCHAR               fx_media_fault_tolerant_enabled;

    /* State of fault tolerant operation. */
    UCHAR               fx_media_fault_tolerant_state;

    /* Transaction recursive count. */
    USHORT              fx_media_fault_tolerant_transaction_count;

    /* Start cluster of log. */
    ULONG               fx_media_fault_tolerant_start_cluster;

    /* Count of consecutive clusters of log. */
    ULONG               fx_media_fault_tolerant_clusters;

    /* Count of total logs. */
    ULONG               fx_media_fault_tolerant_total_logs;

    /* Pointer to the memory buffer area used for fault tolerant operations.  */
    UCHAR              *fx_media_fault_tolerant_memory_buffer;

    /* Size of memory buffer area used for fault tolerant operations. */
    ULONG               fx_media_fault_tolerant_memory_buffer_size;

    /* Size of log file. */
    ULONG               fx_media_fault_tolerant_file_size;

    /* Memory space used during the release of FAT list. */
    ULONG               fx_media_fault_tolerant_cache[FX_FAULT_TOLERANT_CACHE_SIZE >> 2];

    /* Sector number of cached FAT entries. */
    ULONG               fx_media_fault_tolerant_cached_FAT_sector;
#endif /* FX_ENABLE_FAULT_TOLERANT */

    /* Reserved value of FAT table. */
    ULONG               fx_media_fat_reserved;

    /* Last value of FAT table. */
    ULONG               fx_media_fat_last;

    /* Media geometry structure */
    UCHAR               fx_media_FAT_type;

    /* Define the module port extension in the media control block. This
       is typically defined to whitespace in fx_port.h.  */
    FX_MEDIA_MODULE_EXTENSION

} FX_MEDIA;

typedef FX_MEDIA *      FX_MEDIA_PTR;


/* Determine if the file control block has an extension defined. If not,
   define the extension to whitespace.  */

#ifndef FX_FILE_MODULE_EXTENSION
#define FX_FILE_MODULE_EXTENSION
#endif


/* Define the FileX file control block.  All information about open
   files are found in this data type.  */

typedef struct FX_FILE_STRUCT
{

    /* Define the file ID used for error checking.  */
    ULONG               fx_file_id;

    /* Define the file's name.  */
    CHAR                *fx_file_name;

    /* Define the open mode request.  */
    ULONG               fx_file_open_mode;

    /* Define the file modified field.  */
    UCHAR               fx_file_modified;

    /* Define the data storage parameters.  */
    ULONG               fx_file_total_clusters;
    ULONG               fx_file_first_physical_cluster;
    ULONG               fx_file_consecutive_cluster;
    ULONG               fx_file_last_physical_cluster;
    ULONG               fx_file_current_physical_cluster;
    ULONG64             fx_file_current_logical_sector;
    ULONG               fx_file_current_logical_offset;
    ULONG               fx_file_current_relative_cluster;
    ULONG               fx_file_current_relative_sector;
    ULONG64             fx_file_current_file_offset;
    ULONG64             fx_file_current_file_size;
    ULONG64             fx_file_current_available_size;
#ifdef FX_ENABLE_FAULT_TOLERANT
    ULONG64             fx_file_maximum_size_used;
#endif /* FX_ENABLE_FAULT_TOLERANT */

    /* Remember the media that is associated with this file. */
    FX_MEDIA            *fx_file_media_ptr;

    /* Define the pointers necessary to maintain the open file on
       the list of open files.  */
    struct FX_FILE_STRUCT
                        *fx_file_opened_next,
                        *fx_file_opened_previous;

    /* Define the complete directory entry structure.  */
    FX_DIR_ENTRY        fx_file_dir_entry;
    CHAR                fx_file_name_buffer[FX_MAX_LONG_NAME_LEN];

    /* Define a variable for the application's use */
    ULONG               fx_file_disable_burst_cache;

    /* Define a notify function called when file is written to. */
    VOID               (*fx_file_write_notify)(struct FX_FILE_STRUCT *);

    /* Define the module port extension in the file control block. This
       is typically defined to whitespace in fx_port.h.  */
    FX_FILE_MODULE_EXTENSION

} FX_FILE;

typedef FX_FILE  *FX_FILE_PTR;


/* Define the FileX API mappings based on the error checking
   selected by the user.  Note: this section is only applicable to
   application source code, hence the conditional that turns off this
   stuff when the include file is processed by the FileX source. */

#ifndef FX_SOURCE_CODE

#ifdef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_seek(f, b)                    fx_file_extended_seek(f, (ULONG64)b)
#define fx_file_allocate(f, s)                fx_file_extended_allocate(f, (ULONG64)s);
#define fx_file_truncate(f, s)                fx_file_extended_truncate(f, (ULONG64)s);
#define fx_file_relative_seek(f, b, sf)       fx_file_extended_relative_seek(f, (ULONG64)b, sf);
#define fx_file_truncate_release(f, s)        fx_file_extended_truncate_release(f, (ULONG64)s);
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */

/* Determine if error checking is desired.  If so, map API functions
   to the appropriate error checking front-ends.  Otherwise, map API
   functions to the core functions that actually perform the work.
   Note: error checking is enabled by default.  */

#ifdef FX_DISABLE_ERROR_CHECKING

/* Services without error checking.  */

#define fx_directory_attributes_read          _fx_directory_attributes_read
#define fx_directory_attributes_set           _fx_directory_attributes_set
#define fx_directory_create                   _fx_directory_create
#define fx_directory_default_get              _fx_directory_default_get
#define fx_directory_default_get_copy         _fx_directory_default_get_copy
#define fx_directory_default_set              _fx_directory_default_set
#define fx_directory_delete                   _fx_directory_delete
#define fx_directory_first_entry_find         _fx_directory_first_entry_find
#define fx_directory_first_full_entry_find    _fx_directory_first_full_entry_find
#define fx_directory_information_get          _fx_directory_information_get
#define fx_directory_local_path_clear         _fx_directory_local_path_clear
#define fx_directory_local_path_get           _fx_directory_local_path_get
#define fx_directory_local_path_get_copy      _fx_directory_local_path_get_copy
#define fx_directory_local_path_restore       _fx_directory_local_path_restore
#define fx_directory_local_path_set           _fx_directory_local_path_set
#define fx_directory_long_name_get            _fx_directory_long_name_get
#define fx_directory_long_name_get_extended   _fx_directory_long_name_get_extended
#define fx_directory_name_test                _fx_directory_name_test
#define fx_directory_next_entry_find          _fx_directory_next_entry_find
#define fx_directory_next_full_entry_find     _fx_directory_next_full_entry_find
#define fx_directory_rename                   _fx_directory_rename
#define fx_directory_short_name_get           _fx_directory_short_name_get
#define fx_directory_short_name_get_extended  _fx_directory_short_name_get_extended

#ifndef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_allocate                      _fx_file_allocate
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
#define fx_file_attributes_read               _fx_file_attributes_read
#define fx_file_attributes_set                _fx_file_attributes_set
#define fx_file_best_effort_allocate          _fx_file_best_effort_allocate
#define fx_file_close                         _fx_file_close
#define fx_file_create                        _fx_file_create
#define fx_file_date_time_set                 _fx_file_date_time_set
#define fx_file_delete                        _fx_file_delete
#define fx_file_open                          _fx_file_open
#define fx_file_read                          _fx_file_read
#ifndef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_relative_seek                 _fx_file_relative_seek
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
#define fx_file_rename                        _fx_file_rename
#ifndef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_seek                          _fx_file_seek
#define fx_file_truncate                      _fx_file_truncate
#define fx_file_truncate_release              _fx_file_truncate_release
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
#define fx_file_write                         _fx_file_write
#define fx_file_write_notify_set              _fx_file_write_notify_set
#define fx_file_extended_allocate             _fx_file_extended_allocate
#define fx_file_extended_best_effort_allocate _fx_file_extended_best_effort_allocate
#define fx_file_extended_relative_seek        _fx_file_extended_relative_seek
#define fx_file_extended_seek                 _fx_file_extended_seek
#define fx_file_extended_truncate             _fx_file_extended_truncate
#define fx_file_extended_truncate_release     _fx_file_extended_truncate_release

#define fx_media_abort                        _fx_media_abort
#define fx_media_cache_invalidate             _fx_media_cache_invalidate
#define fx_media_check                        _fx_media_check
#define fx_media_close                        _fx_media_close
#define fx_media_flush                        _fx_media_flush
#define fx_media_format                       _fx_media_format
#define fx_media_open                         _fx_media_open
#define fx_media_read                         _fx_media_read
#define fx_media_space_available              _fx_media_space_available
#define fx_media_volume_get                   _fx_media_volume_get
#define fx_media_volume_get_extended          _fx_media_volume_get_extended
#define fx_media_volume_set                   _fx_media_volume_set
#define fx_media_write                        _fx_media_write
#define fx_media_open_notify_set              _fx_media_open_notify_set
#define fx_media_close_notify_set             _fx_media_close_notify_set
#define fx_media_extended_space_available     _fx_media_extended_space_available

#define fx_unicode_directory_create           _fx_unicode_directory_create
#define fx_unicode_directory_rename           _fx_unicode_directory_rename
#define fx_unicode_file_create                _fx_unicode_file_create
#define fx_unicode_file_rename                _fx_unicode_file_rename
#define fx_unicode_length_get                 _fx_unicode_length_get
#define fx_unicode_length_get_extended        _fx_unicode_length_get_extended
#define fx_unicode_name_get                   _fx_unicode_name_get
#define fx_unicode_name_get_extended          _fx_unicode_name_get_extended
#define fx_unicode_short_name_get             _fx_unicode_short_name_get
#define fx_unicode_short_name_get_extended    _fx_unicode_short_name_get_extended

#define fx_system_date_get                    _fx_system_date_get
#define fx_system_date_set                    _fx_system_date_set
#define fx_system_time_get                    _fx_system_time_get
#define fx_system_time_set                    _fx_system_time_set
#define fx_system_initialize                  _fx_system_initialize

#ifdef FX_ENABLE_FAULT_TOLERANT
#define fx_fault_tolerant_enable              _fx_fault_tolerant_enable
#endif /* FX_ENABLE_FAULT_TOLERANT */

#else

/* Services with error checking.  */

#define fx_directory_attributes_read          _fxe_directory_attributes_read
#define fx_directory_attributes_set           _fxe_directory_attributes_set
#define fx_directory_create                   _fxe_directory_create
#define fx_directory_default_get              _fxe_directory_default_get
#define fx_directory_default_get_copy         _fxe_directory_default_get_copy
#define fx_directory_default_set              _fxe_directory_default_set
#define fx_directory_delete                   _fxe_directory_delete
#define fx_directory_first_entry_find         _fxe_directory_first_entry_find
#define fx_directory_first_full_entry_find    _fxe_directory_first_full_entry_find
#define fx_directory_information_get          _fxe_directory_information_get
#define fx_directory_local_path_clear         _fxe_directory_local_path_clear
#define fx_directory_local_path_get           _fxe_directory_local_path_get
#define fx_directory_local_path_get_copy      _fxe_directory_local_path_get_copy
#define fx_directory_local_path_restore       _fxe_directory_local_path_restore
#define fx_directory_local_path_set(m, l, n)  _fxe_directory_local_path_set(m, l, n, sizeof(FX_LOCAL_PATH))
#define fx_directory_long_name_get            _fxe_directory_long_name_get
#define fx_directory_long_name_get_extended   _fxe_directory_long_name_get_extended
#define fx_directory_name_test                _fxe_directory_name_test
#define fx_directory_next_entry_find          _fxe_directory_next_entry_find
#define fx_directory_next_full_entry_find     _fxe_directory_next_full_entry_find
#define fx_directory_rename                   _fxe_directory_rename
#define fx_directory_short_name_get           _fxe_directory_short_name_get
#define fx_directory_short_name_get_extended  _fxe_directory_short_name_get_extended

#ifndef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_allocate                      _fxe_file_allocate
#endif  /* FX_DISABLE_ONE_LINE_FUNCTION */
#define fx_file_attributes_read               _fxe_file_attributes_read
#define fx_file_attributes_set                _fxe_file_attributes_set
#define fx_file_best_effort_allocate          _fxe_file_best_effort_allocate
#define fx_file_close                         _fxe_file_close
#define fx_file_create                        _fxe_file_create
#define fx_file_date_time_set                 _fxe_file_date_time_set
#define fx_file_delete                        _fxe_file_delete
#define fx_file_open(m, f, n, t)              _fxe_file_open(m, f, n, t, sizeof(FX_FILE))
#define fx_file_read                          _fxe_file_read
#ifndef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_relative_seek                 _fxe_file_relative_seek
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
#define fx_file_rename                        _fxe_file_rename
#ifndef FX_DISABLE_ONE_LINE_FUNCTION
#define fx_file_seek                          _fxe_file_seek
#define fx_file_truncate                      _fxe_file_truncate
#define fx_file_truncate_release              _fxe_file_truncate_release
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
#define fx_file_write                         _fxe_file_write
#define fx_file_write_notify_set              _fxe_file_write_notify_set
#define fx_file_extended_allocate             _fxe_file_extended_allocate
#define fx_file_extended_best_effort_allocate _fxe_file_extended_best_effort_allocate
#define fx_file_extended_relative_seek        _fxe_file_extended_relative_seek
#define fx_file_extended_seek                 _fxe_file_extended_seek
#define fx_file_extended_truncate             _fxe_file_extended_truncate
#define fx_file_extended_truncate_release     _fxe_file_extended_truncate_release

#define fx_media_abort                        _fxe_media_abort
#define fx_media_cache_invalidate             _fxe_media_cache_invalidate
#define fx_media_check                        _fxe_media_check
#define fx_media_close                        _fxe_media_close
#define fx_media_flush                        _fxe_media_flush
#define fx_media_format                       _fxe_media_format
#define fx_media_open(m, n, d, i, p, s)       _fxe_media_open(m, n, d, i, p, s, sizeof(FX_MEDIA))
#define fx_media_read                         _fxe_media_read
#define fx_media_space_available              _fxe_media_space_available
#define fx_media_volume_get                   _fxe_media_volume_get
#define fx_media_volume_get_extended          _fxe_media_volume_get_extended
#define fx_media_volume_set                   _fxe_media_volume_set
#define fx_media_write                        _fxe_media_write
#define fx_media_open_notify_set              _fxe_media_open_notify_set
#define fx_media_close_notify_set             _fxe_media_close_notify_set
#define fx_media_extended_space_available     _fxe_media_extended_space_available

#define fx_unicode_directory_create           _fxe_unicode_directory_create
#define fx_unicode_directory_rename           _fxe_unicode_directory_rename
#define fx_unicode_file_create                _fxe_unicode_file_create
#define fx_unicode_file_rename                _fxe_unicode_file_rename
#define fx_unicode_length_get                 _fx_unicode_length_get
#define fx_unicode_length_get_extended        _fx_unicode_length_get_extended
#define fx_unicode_name_get                   _fxe_unicode_name_get
#define fx_unicode_name_get_extended          _fxe_unicode_name_get_extended
#define fx_unicode_short_name_get             _fxe_unicode_short_name_get
#define fx_unicode_short_name_get_extended    _fxe_unicode_short_name_get_extended

#define fx_system_date_get                    _fxe_system_date_get
#define fx_system_date_set                    _fxe_system_date_set
#define fx_system_time_get                    _fxe_system_time_get
#define fx_system_time_set                    _fxe_system_time_set
#define fx_system_initialize                  _fx_system_initialize

#ifdef FX_ENABLE_FAULT_TOLERANT
#define fx_fault_tolerant_enable              _fxe_fault_tolerant_enable
#endif /* FX_ENABLE_FAULT_TOLERANT */

#endif

/* Define the function prototypes of the FileX API.  */

UINT fx_directory_attributes_read(FX_MEDIA *media_ptr, CHAR *directory_name, UINT *attributes_ptr);
UINT fx_directory_attributes_set(FX_MEDIA *media_ptr, CHAR *directory_name, UINT attributes);
UINT fx_directory_create(FX_MEDIA *media_ptr, CHAR *directory_name);
UINT fx_directory_default_get(FX_MEDIA *media_ptr, CHAR **return_path_name);
UINT fx_directory_default_get_copy(FX_MEDIA *media_ptr, CHAR *return_path_name_buffer, UINT return_path_name_buffer_size);
UINT fx_directory_default_set(FX_MEDIA *media_ptr, CHAR *new_path_name);
UINT fx_directory_delete(FX_MEDIA *media_ptr, CHAR *directory_name);
UINT fx_directory_first_entry_find(FX_MEDIA *media_ptr, CHAR *directory_name);
UINT fx_directory_first_full_entry_find(FX_MEDIA *media_ptr, CHAR *directory_name, UINT *attributes,
                                        ULONG *size, UINT *year, UINT *month, UINT *day, UINT *hour, UINT *minute, UINT *second);
UINT fx_directory_information_get(FX_MEDIA *media_ptr, CHAR *directory_name, UINT *attributes, ULONG *size,
                                  UINT *year, UINT *month, UINT *day, UINT *hour, UINT *minute, UINT *second);
UINT fx_directory_local_path_clear(FX_MEDIA *media_ptr);
UINT fx_directory_local_path_get(FX_MEDIA *media_ptr, CHAR **return_path_name);
UINT fx_directory_local_path_get_copy(FX_MEDIA *media_ptr, CHAR *return_path_name_buffer, UINT return_path_name_buffer_size);
UINT fx_directory_local_path_restore(FX_MEDIA *media_ptr, FX_LOCAL_PATH *local_path_ptr);
#ifdef FX_DISABLE_ERROR_CHECKING
UINT _fx_directory_local_path_set(FX_MEDIA *media_ptr, FX_LOCAL_PATH *local_path_ptr, CHAR *new_path_name);
#else
UINT _fxe_directory_local_path_set(FX_MEDIA *media_ptr, FX_LOCAL_PATH *local_path_ptr, CHAR *new_path_name, UINT local_path_control_block_size);
#endif
UINT fx_directory_long_name_get(FX_MEDIA *media_ptr, CHAR *short_file_name, CHAR *long_file_name);
UINT fx_directory_long_name_get_extended(FX_MEDIA* media_ptr, CHAR* short_file_name, CHAR* long_file_name, UINT long_file_name_buffer_length);
UINT fx_directory_name_test(FX_MEDIA *media_ptr, CHAR *directory_name);
UINT fx_directory_next_entry_find(FX_MEDIA *media_ptr, CHAR *directory_name);
UINT fx_directory_next_full_entry_find(FX_MEDIA *media_ptr, CHAR *directory_name, UINT *attributes,
                                       ULONG *size, UINT *year, UINT *month, UINT *day, UINT *hour, UINT *minute, UINT *second);
UINT fx_directory_rename(FX_MEDIA *media_ptr, CHAR *old_directory_name, CHAR *new_directory_name);
UINT fx_directory_short_name_get(FX_MEDIA *media_ptr, CHAR *long_file_name, CHAR *short_file_name);
UINT fx_directory_short_name_get_extended(FX_MEDIA* media_ptr, CHAR* long_file_name, CHAR* short_file_name, UINT short_file_name_length);

#ifndef FX_DISABLE_ONE_LINE_FUNCTION
UINT fx_file_allocate(FX_FILE *file_ptr, ULONG size);
#endif /* FX_DISABLE_ONE_LINE_FUNCTION*/
UINT fx_file_attributes_read(FX_MEDIA *media_ptr, CHAR *file_name, UINT *attributes_ptr);
UINT fx_file_attributes_set(FX_MEDIA *media_ptr, CHAR *file_name, UINT attributes);
UINT fx_file_best_effort_allocate(FX_FILE *file_ptr, ULONG size, ULONG *actual_size_allocated);
UINT fx_file_close(FX_FILE *file_ptr);
UINT fx_file_create(FX_MEDIA *media_ptr, CHAR *file_name);
UINT fx_file_date_time_set(FX_MEDIA *media_ptr, CHAR *file_name,
                           UINT year, UINT month, UINT day, UINT hour, UINT minute, UINT second);
UINT fx_file_delete(FX_MEDIA *media_ptr, CHAR *file_name);
#ifdef FX_DISABLE_ERROR_CHECKING
UINT _fx_file_open(FX_MEDIA *media_ptr, FX_FILE *file_ptr, CHAR *file_name,
                   UINT open_type);
#else
UINT _fxe_file_open(FX_MEDIA *media_ptr, FX_FILE *file_ptr, CHAR *file_name,
                    UINT open_type, UINT file_control_block_size);
#endif
UINT fx_file_read(FX_FILE *file_ptr, VOID *buffer_ptr, ULONG request_size, ULONG *actual_size);
#ifndef FX_DISABLE_ONE_LINE_FUNCTION
UINT fx_file_relative_seek(FX_FILE *file_ptr, ULONG byte_offset, UINT seek_from);
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
UINT fx_file_rename(FX_MEDIA *media_ptr, CHAR *old_file_name, CHAR *new_file_name);
#ifndef FX_DISABLE_ONE_LINE_FUNCTION
UINT fx_file_seek(FX_FILE *file_ptr, ULONG byte_offset);
UINT fx_file_truncate(FX_FILE *file_ptr, ULONG size);
UINT fx_file_truncate_release(FX_FILE *file_ptr, ULONG size);
#endif /* FX_DISABLE_ONE_LINE_FUNCTION */
UINT fx_file_write(FX_FILE *file_ptr, VOID *buffer_ptr, ULONG size);
UINT fx_file_write_notify_set(FX_FILE *file_ptr, VOID (*file_write_notify)(FX_FILE *));
UINT fx_file_extended_allocate(FX_FILE *file_ptr, ULONG64 size);
UINT fx_file_extended_best_effort_allocate(FX_FILE *file_ptr, ULONG64 size, ULONG64 *actual_size_allocated);
UINT fx_file_extended_relative_seek(FX_FILE *file_ptr, ULONG64 byte_offset, UINT seek_from);
UINT fx_file_extended_seek(FX_FILE *file_ptr, ULONG64 byte_offset);
UINT fx_file_extended_truncate(FX_FILE *file_ptr, ULONG64 size);
UINT fx_file_extended_truncate_release(FX_FILE *file_ptr, ULONG64 size);

UINT fx_media_abort(FX_MEDIA *media_ptr);
UINT fx_media_cache_invalidate(FX_MEDIA *media_ptr);
UINT fx_media_check(FX_MEDIA *media_ptr, UCHAR *scratch_memory_ptr, ULONG scratch_memory_size, ULONG error_correction_option, ULONG *errors_detected);
UINT fx_media_close(FX_MEDIA *media_ptr);
UINT fx_media_flush(FX_MEDIA *media_ptr);
UINT fx_media_format(FX_MEDIA *media_ptr, VOID (*driver)(FX_MEDIA *media), VOID *driver_info_ptr, UCHAR *memory_ptr, UINT memory_size,
                     CHAR *volume_name, UINT number_of_fats, UINT directory_entries, UINT hidden_sectors,
                     ULONG total_sectors, UINT bytes_per_sector, UINT sectors_per_cluster,
                     UINT heads, UINT sectors_per_track);
#ifdef FX_DISABLE_ERROR_CHECKING
UINT _fx_media_open(FX_MEDIA *media_ptr, CHAR *media_name,
                    VOID (*media_driver)(FX_MEDIA *), VOID *driver_info_ptr,
                    VOID *memory_ptr, ULONG memory_size);
#else
UINT _fxe_media_open(FX_MEDIA *media_ptr, CHAR *media_name,
                     VOID (*media_driver)(FX_MEDIA *), VOID *driver_info_ptr,
                     VOID *memory_ptr, ULONG memory_size, UINT media_control_block_size);
#endif
UINT fx_media_read(FX_MEDIA *media_ptr, ULONG logical_sector, VOID *buffer_ptr);
UINT fx_media_space_available(FX_MEDIA *media_ptr, ULONG *available_bytes_ptr);
UINT fx_media_volume_get(FX_MEDIA *media_ptr, CHAR *volume_name, UINT volume_source);
UINT fx_media_volume_get_extended(FX_MEDIA *media_ptr, CHAR *volume_name, UINT volume_name_buffer_length, UINT volume_source);
UINT fx_media_volume_set(FX_MEDIA *media_ptr, CHAR *volume_name);
UINT fx_media_write(FX_MEDIA *media_ptr, ULONG logical_sector, VOID *buffer_ptr);
UINT fx_media_open_notify_set(FX_MEDIA *media_ptr, VOID (*media_open_notify)(FX_MEDIA *));
UINT fx_media_close_notify_set(FX_MEDIA *media_ptr, VOID (*media_close_notify)(FX_MEDIA *));
UINT fx_media_extended_space_available(FX_MEDIA *media_ptr, ULONG64 *available_bytes_ptr);

UINT fx_system_date_get(UINT *year, UINT *month, UINT *day);
UINT fx_system_date_set(UINT year, UINT month, UINT day);
VOID fx_system_initialize(VOID);
UINT fx_system_time_get(UINT *hour, UINT *minute, UINT *second);
UINT fx_system_time_set(UINT hour, UINT minute, UINT second);

UINT fx_unicode_directory_create(FX_MEDIA *media_ptr,
                                 UCHAR *source_unicode_name, ULONG source_unicode_length,
                                 CHAR *short_name);
UINT fx_unicode_directory_rename(FX_MEDIA *media_ptr,
                                 UCHAR *old_unicode_name, ULONG old_unicode_length,
                                 UCHAR *new_unicode_name, ULONG new_unicode_length,
                                 CHAR *new_short_name);
UINT fx_unicode_file_create(FX_MEDIA *media_ptr,
                            UCHAR *source_unicode_name, ULONG source_unicode_length,
                            CHAR *short_name);
UINT  fx_unicode_file_rename(FX_MEDIA *media_ptr, UCHAR *old_unicode_name, ULONG old_unicode_length,
                             UCHAR *new_unicode_name, ULONG new_unicode_length, CHAR *new_short_name);
ULONG fx_unicode_length_get(UCHAR *unicode_name);
ULONG fx_unicode_length_get_extended(UCHAR *unicode_name, UINT buffer_length);
UINT  fx_unicode_name_get(FX_MEDIA *media_ptr, CHAR *source_short_name,
                          UCHAR *destination_unicode_name, ULONG *destination_unicode_length);
UINT  fx_unicode_name_get_extended(FX_MEDIA *media_ptr, CHAR *source_short_name,
                          UCHAR *destination_unicode_name, ULONG *destination_unicode_length, ULONG unicode_name_buffer_length);
UINT  fx_unicode_short_name_get(FX_MEDIA *media_ptr,
                                UCHAR *source_unicode_name, ULONG source_unicode_length,
                                CHAR *destination_short_name);
UINT  fx_unicode_short_name_get_extended(FX_MEDIA *media_ptr,
                                UCHAR *source_unicode_name, ULONG source_unicode_length,
                                CHAR *destination_short_name, ULONG short_name_buffer_length);

#ifdef FX_ENABLE_FAULT_TOLERANT
UINT fx_fault_tolerant_enable(FX_MEDIA *media_ptr, VOID *memory_buffer, UINT memory_size);
#endif /* FX_ENABLE_FAULT_TOLERANT */


/* Define prototype for utility services commonly used by FileX I/O Drivers.  This eliminates the
   need to include internal FileX component files in I/O drivers.  */

UINT    _fx_utility_16_unsigned_read(UCHAR *source_ptr);
VOID    _fx_utility_16_unsigned_write(UCHAR *dest_ptr, UINT value);
ULONG   _fx_utility_32_unsigned_read(UCHAR *source_ptr);
VOID    _fx_utility_32_unsigned_write(UCHAR *dest_ptr, ULONG value);
ULONG64 _fx_utility_64_unsigned_read(UCHAR *source_ptr);
VOID    _fx_utility_64_unsigned_write(UCHAR *dest_ptr, ULONG64 value);
VOID    _fx_utility_memory_copy(UCHAR *source_ptr, UCHAR *dest_ptr, ULONG size);
VOID    _fx_utility_memory_set(UCHAR *dest_ptr, UCHAR value, ULONG size);

#endif

/* Determine if a C++ compiler is being used.  If so, complete the standard
   C conditional started above.  */
#ifdef __cplusplus
}
#endif

#endif