2.3-InternetRadio/fat.c

/****************************************************************************
*  This file is part of the AVRIDE device driver.
*
*  Copyright (c) 2002-2004 by Michael Fischer. All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without 
*  modification, are permitted provided that the following conditions 
*  are met:
*  
*  1. Redistributions of source code must retain the above copyright 
*     notice, this list of conditions and the following disclaimer.
*  2. Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the 
*     documentation and/or other materials provided with the distribution.
*  3. Neither the name of the author nor the names of its contributors may 
*     be used to endorse or promote products derived from this software 
*     without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
*  SUCH DAMAGE.
*
****************************************************************************
*  History:
*
*  14.12.02  mifi   First Version 
*  23.12.02  mifi   Add FileOpen, FileClose, FileError, FileSize,
*                   FileSeek and FileRead. But the FileSeek function.
*                   does not work in the moment, later...
*  28.12.02  mifi   Now support FAT16 AND FAT32.
*  01.01.03  mifi   Support long directory entries, but without to 
*                   check the checksum of the short entry.
*                   Change FAT32FileSize return value from int to long.
*                   The max size of a long filename segment is
*                   (FAT_LONG_NAME_LEN-1). But the complete filename can
*                   be longer. 
*
*                   segment1/segment2/segment3/index.html
*
*                   segmentX max length = (FAT_LONG_NAME_LEN-1)
*
*  04.01.03  mifi   Take a look at the return values...
*  18.01.03  mifi   Change Licence from GPL to BSD.
*  25.01.03  mifi   Implement a new FindFile function.
*                   I have some trouble with short file names under
*                   Win98. Win98 store a short name like "enlogo.gif"
*                   as a long name, nasty OS. 
*                   Remove FAT32_MAX_FILES and the array aFileHandle,
*                   a file handle will now be allocated by NutHeapAlloc, 
*                   therefore we have no restrictions about the count of 
*                   the open file handle. (Only by available memory)
*  27.01.03  mifi   Rename all FAT32xxx function to FATxxx.
*
*  28.01.03  mifi   Start porting to Nut/OS 3.X.X
*  19.06.03  mifi   Change the call of IDEInit, now we use the BaseAddress
*                   of 0. Because the fat module does not need to know the
*                   address. It will be handled in ide.c.
*  29.06.03  mifi   First ATAPI-Version
*                   Now we can read files from a CD-ROM. But there exist
*                   some open points:
*                   - only first session from a multisession CD is supported
*                   - only iso9660, no Joliet support now, later
*  24.07.04  mifi   Some changes to support more than one drive (datanut)
*  25.07.04  mifi   Add support for the PCMCIA_11 hardware.
*  27.07.04  mifi   Start to add functionality for write function.
*  03.08.04  mifi   Add format function.
****************************************************************************/
#define __FAT_C__

#define LOG_MODULE  LOG_FAT_MODULE

#include <string.h>
#include <stddef.h>
#include <ctype.h>
#include <time.h>

#include <sys/heap.h>
#include <sys/event.h>
#include <sys/thread.h>

#include <sys/device.h>

#include "typedefs.h"

#include "fat.h"
#include "fatdrv.h"
#include "portio.h"
#include "log.h"


/*==========================================================*/
/*  DEFINE: All Structures and Common Constants             */
/*==========================================================*/
//
// FAT return codes
//
#define FAT_OK                0
#define FAT_ERROR             -1
#define FAT_ERROR_EOF         -2
#define FAT_ERROR_IDE         -3

//
// Define for correct return values Nut/OS
//
#define NUTDEV_OK                       0
#define NUTDEV_ERROR                    -1
#define NUTDEV_WRONG_HW                 -2

#define FAT_MAX_DRIVE                   3

//
// Some defines for the FAT structures
//
#define ZIP_DRIVE_BR_SECTOR             32

#define BPB_RsvdSecCnt                  32
#define BPB_NumFATs                     2
#define BPB_HiddSec                     63

#define FAT32_MEDIA                     0xf8
#define FAT32_SECTOR_SIZE               HW_SECTOR_SIZE

#define FAT32_OFFSET_FSINFO             1
#define FAT32_OFFSET_BACKUP_BOOT        6

#define FAT16_CLUSTER_EOF               0x0000FFFF
#define FAT16_CLUSTER_ERROR             0x0000FFF7
#define FAT16_CLUSTER_MASK              0x0000FFFF

#define FAT32_CLUSTER_EOF               0x0FFFFFFF
#define FAT32_CLUSTER_ERROR             0x0FFFFFF7
#define FAT32_CLUSTER_MASK              0x0FFFFFFF

#define FAT_SIGNATURE                   0xAA55

#define MBR_SIGNATURE                   FAT_SIGNATURE
#define MBR_FAT32                       0x0B

#define FSINFO_FIRSTSIGNATURE           0x41615252
#define FSINFO_FSINFOSIGNATURE          0x61417272
#define FSINFO_SIGNATURE                FAT_SIGNATURE

#define DIRECTORY_ATTRIBUTE_READ_ONLY   0x01
#define DIRECTORY_ATTRIBUTE_HIDDEN      0x02
#define DIRECTORY_ATTRIBUTE_SYSTEM_FILE 0x04
#define DIRECTORY_ATTRIBUTE_VOLUME_ID   0x08
#define DIRECTORY_ATTRIBUTE_DIRECTORY   0x10
#define DIRECTORY_ATTRIBUTE_ARCHIVE     0x20

//
// DIRECTORY_ATTRIBUTE_READ_ONLY   |
// DIRECTORY_ATTRIBUTE_HIDDEN      |
// DIRECTORY_ATTRIBUTE_SYSTEM_FILE |
// DIRECTORY_ATTRIBUTE_VOLUME_ID
//
#define DIRECTORY_ATTRIBUTE_LONG_NAME   0x0F

//
// DIRECTORY_ATTRIBUTE_READ_ONLY   |
// DIRECTORY_ATTRIBUTE_HIDDEN      |
// DIRECTORY_ATTRIBUTE_SYSTEM_FILE |
// DIRECTORY_ATTRIBUTE_VOLUME_ID   |
// DIRECTORY_ATTRIBUTE_DIRECTORY   |
// DIRECTORY_ATTRIBUTE_ARCHIVE
// 
#define DIRECTORY_ATTRIBUTE_LONG_NAME_MASK  0x3F

#define FAT_NAME_LEN                    8
#define FAT_EXT_LEN                     3

//
// FAT_SHORT_NAME_LEN name len = 
// name + ext + 1 for the point
//
#define FAT_SHORT_NAME_LEN              (FAT_NAME_LEN+FAT_EXT_LEN+1)
#define FAT_LONG_NAME_LEN               64


//
// Some stuff for HD and CD, DRIVE_INFO Flags
// 
//
#define FLAG_FAT_IS_CDROM               0x0001
#define FLAG_FAT_IS_ZIP                 0x0002

//
//  DiskSize to SectorPerCluster table
//
typedef struct
{
    DWORD DiskSize;
    BYTE  SecPerClusVal;
} DSKSZTOSECPERCLUS;

typedef struct _FAT32FileDataTime
{
    unsigned Seconds:5;
    unsigned Minute:6;
    unsigned Hour:5;
    unsigned Day:5;
    unsigned Month:4;
    unsigned Year:7;
} FAT32_FILEDATETIME, *PFAT32_FILEDATETIME;

typedef struct _FAT32DirectoryEntry
{
    BYTE               Name[FAT_NAME_LEN];
    BYTE               Extension[FAT_EXT_LEN];
    BYTE               Attribute;
    BYTE               Reserved[8];
    WORD               HighCluster;
    FAT32_FILEDATETIME Date;
    WORD               LowCluster;
    DWORD              FileSize;
} FAT32_DIRECTORY_ENTRY;

typedef struct _FAT32DirectoryEntryLong
{
    BYTE Order;
    WORD Name1[5];
    BYTE Attribute;
    BYTE Type;
    BYTE Chksum;
    WORD Name2[6];
    WORD LowCluster;
    WORD Name3[2];
} FAT32_DIRECTORY_ENTRY_LONG;

typedef struct _FAT32FileSystemInformation
{
    DWORD FirstSignature;
    BYTE  Reserved1[480];
    DWORD FSInfoSignature;
    DWORD NumberOfFreeClusters;
    DWORD MostRecentlyAllocatedCluster;
    BYTE  Reserved2[12];
    BYTE  Reserved3[2];
    WORD  Signature;
} FAT32_FSINFO;

typedef struct _FAT32PartitionEntry
{
    BYTE  BootInd;
    BYTE  FirstHead;
    BYTE  FirstSector;
    BYTE  FirstTrack;
    BYTE  FileSystem;
    BYTE  LastHead;
    BYTE  LastSector;
    BYTE  LastTrack;
    DWORD StartSectors;
    DWORD NumSectors;
} FAT32_PARTITION_ENTRY;

typedef struct _FAT32PartionTable
{
    BYTE                  LoadInstruction[446];
    FAT32_PARTITION_ENTRY Partition[4];
    WORD                  Signature;               /* AA55 */
} FAT32_PARTITION_TABLE;

typedef struct _bpbfat16
{
    BYTE  DrvNum;
    BYTE  Reserved1;
    BYTE  BootSig;
    DWORD VollID;
    BYTE  VolLab[11];
    BYTE  FilSysType[8];
    BYTE  Reserved2[28];
} BPBFAT16;

typedef struct _bpbfat32
{
    DWORD FATSz32;          // xxx
    WORD  ExtFlags;         // 0
    WORD  FSVer;            // must 0
    DWORD RootClus;         // 
    WORD  FSInfo;           // typically 1
    WORD  BkBootSec;        // typically 6
    BYTE  Reserved[12];     // set all to zero
    BYTE  DrvNum;           // must 0x80
    BYTE  Reserved1;        // set all to zero
    BYTE  BootSig;          // must 0x29 
    DWORD VollID;           // xxx
    BYTE  VolLab[11];       // "abcdefghijk"
    BYTE  FilSysType[8];    // "FAT32   "
} BPBFAT32;

typedef union _bpboffset36
{
    BPBFAT16 FAT16;
    BPBFAT32 FAT32;
} BPBOFFSET36;

typedef struct _FAT32BootRecord
{
    BYTE        JumpBoot[3];    // 0xeb, 0x58, 0x90
    BYTE        OEMName[8];     // "MSWIN4.1"
    WORD        BytsPerSec;     // must 512
    BYTE        SecPerClus;     // 8 for 4K cluster
    WORD        RsvdSecCnt;     // typically 32 for FAT32
    BYTE        NumFATs;        // always 2
    WORD        RootEntCnt;     // must 0 for FAT32
    WORD        TotSec16;       // must 0 for FAT32
    BYTE        Media;          // must 0xf8

    WORD        FATSz16;        // 0   for FAT32
    WORD        SecPerTrk;      // 63  for FAT32
    WORD        NumHeads;       // 255 for FAT32
    DWORD       HiddSec;        // 63  for FAT32

    DWORD       TotSec32;       // xxx

    BPBOFFSET36 Off36;

    BYTE        Reserved[420];
    WORD        Signature;      // must 0xAA55
} FAT32_BOOT_RECORD, *PFAT32_BOOT_RECORD;

typedef struct _fat_entry_table16
{
    WORD aEntry[256];
} FAT_ENTRY_TABLE16;

typedef struct _fat_entry_table32
{
    DWORD aEntry[128];
} FAT_ENTRY_TABLE32;

typedef union _fat_dir_table
{
    FAT32_DIRECTORY_ENTRY      aShort[16];
    FAT32_DIRECTORY_ENTRY_LONG aLong[16];
} FAT_DIR_TABLE;

typedef struct _drive_info
{
    BYTE  bIsFAT32;
    BYTE  bDevice;
    BYTE  bSectorsPerCluster;
    BYTE  bFlags;

    WORD  wSectorSize;

    DWORD dwRootDirSectors;
    DWORD dwFirstRootDirSector;

    DWORD dwRootCluster;
    DWORD dwFAT1StartSector;
    DWORD dwFAT2StartSector;
    DWORD dwCluster2StartSector;

    DWORD dwClusterSize;
} DRIVE_INFO;

typedef struct _fhandle
{
    DWORD      dwFileSize;
    DWORD      dwStartCluster;
    DWORD      dwReadCluster;
    DWORD      dwFilePointer;          /* total file pointer   */
    DWORD      dwClusterPointer;       /* cluster read pointer */

    int         nLastError;
    int         nEOF;

    DRIVE_INFO *pDrive;
} FHANDLE;

static int QuickFormat(NUTDEVICE *dev, DRIVE_INFO *pDrive);

/*==========================================================*/
/*  DEFINE: Definition of all local Data                    */
/*==========================================================*/
static int        nIsInit = FALSE;

static BYTE      *pSectorBuffer = NULL;
static char      *pLongName1 = NULL;
static char      *pLongName2 = NULL;
static DRIVE_INFO sDriveInfo[FAT_MAX_DRIVE];

static HANDLE hFATSemaphore;

static DSKSZTOSECPERCLUS DskTableFAT32[] = {
    {      66600,  0}, /* disks up to 32.5MB, the 0 value for SecPerClusVal trips an error */
    {     532480,  1}, /* disks up to 260 MB, 0.5k cluster */
    {   16777216,  8}, /* disks up to   8 GB,   4k cluster */
    {   33554432, 16}, /* disks up to  16 GB,   8k cluster */
    {   67108864, 32}, /* disks up to  32 GB,  16k cluster */
    { 0xFFFFFFFF, 64}  /* disks greather than 32GB, 32k cluster */
};

#define DSK_TABLE_FAT32_ENTRY_COUNT (sizeof(DskTableFAT32) / sizeof(DSKSZTOSECPERCLUS))
/*==========================================================*/
/*  DEFINE: Definition of all local Procedures              */
/*==========================================================*/

void FATRelease()
{
    nIsInit=FALSE;
}
/************************************************************/
/*  FATLock                                                 */
/************************************************************/
void FATLock(void)
{
    NutEventWait(&hFATSemaphore, 0);
}

/************************************************************/
/*  FATFree                                                 */
/************************************************************/
void FATFree(void)
{
    NutEventPost(&hFATSemaphore);
}

/************************************************************/
/*  FATSemaInit                                             */
/************************************************************/
void FATSemaInit(void)
{
    NutEventPost(&hFATSemaphore);
}

/************************************************************/
/*  GetFirstSectorOfCluster                                 */
/************************************************************/
static DWORD GetFirstSectorOfCluster(DRIVE_INFO *pDrive, DWORD dwCluster)
{
    DWORD dwSector;

    if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
    {
        dwSector  = dwCluster;
    }
    else
    {
        dwSector  = (dwCluster - 2) * pDrive->bSectorsPerCluster;
        dwSector += pDrive->dwCluster2StartSector;
    }

    return(dwSector);
}

/************************************************************/
/*  GetNextCluster                                          */
/************************************************************/
static DWORD GetNextCluster(DRIVE_INFO *pDrive, DWORD dwCluster)
{
    DWORD             dwNextCluster;
    DWORD             dwSector;
    DWORD             dwIndex;
    FAT_ENTRY_TABLE16 *pFatTable16;
    FAT_ENTRY_TABLE32 *pFatTable32;

    if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
    {
        dwNextCluster = dwCluster + 1;
    }
    else
    {
        if (pDrive->bIsFAT32 == TRUE)
        {
            //
            //  (HW_SECTOR_SIZE / sizeof(long)) == 128
            // 
            dwSector = (dwCluster / 128) + pDrive->dwFAT1StartSector;
            dwIndex  = dwCluster % 128;

            HWReadSectors(pDrive->bDevice, pSectorBuffer, dwSector, 1);
            pFatTable32 = (FAT_ENTRY_TABLE32 *) pSectorBuffer;

            dwNextCluster = (pFatTable32->aEntry[dwIndex] & FAT32_CLUSTER_MASK);
            if ((dwNextCluster == FAT32_CLUSTER_EOF) || (dwNextCluster == FAT32_CLUSTER_ERROR))
            {
                dwNextCluster = 0;
            }

        }
        else
        {  /* FAT16 */
            //
            //  (HW_SECTOR_SIZE / sizeof(word)) == 256
            // 
            dwSector = (dwCluster / 256) + pDrive->dwFAT1StartSector;
            dwIndex  = dwCluster % 256;

            HWReadSectors(pDrive->bDevice, pSectorBuffer, dwSector, 1);
            pFatTable16 = (FAT_ENTRY_TABLE16 *) pSectorBuffer;

            dwNextCluster = (pFatTable16->aEntry[dwIndex] & FAT16_CLUSTER_MASK);
            if ((dwNextCluster == FAT16_CLUSTER_EOF) || (dwNextCluster == FAT16_CLUSTER_ERROR))
            {
                dwNextCluster = 0;
            }

        } /* endif pDrive->bIsFAT32 */
    }

    return(dwNextCluster);
}

/************************************************************/
/*  GetLongChar                                             */
/************************************************************/
static char GetLongChar(WORD wValue)
{
    BYTE Value;

    Value = (BYTE)(wValue & 0x00FF);
    if (Value == 0xFF)
    {
        Value = 0;
    }

    if (Value != 0)
    {
        Value = toupper(Value);
    }

    return((char)Value);
}

/************************************************************/
/*  FindFile                                                */
/*                                                          */
/*  Find a file by a given name pLongName.                  */
/*                                                          */
/*  It is possible that a SHORT name like "enlogo.gif"      */
/*  is stored as a LONG name. I have seen this              */
/*  nasty behaviour by Win98. Therefore I will check        */
/*  the long name too, even if nIsLongName is FALSE.        */
/************************************************************/
static DWORD FindFile(DRIVE_INFO            *pDrive,
                      FAT32_DIRECTORY_ENTRY *pSearchEntry, 
                      char                  *pLongName,
                      DWORD                 dwDirCluster, 
                      DWORD                 *pFileSize, 
                      int                    nIsLongName)
{
    int                       i, x;
    BYTE                      bError;
    int                       nNameLen;
    int                       nMaxLen;
    BYTE                      bFound;
    BYTE                      bEndLoop;
    BYTE                      bOrder;
    BYTE                      bMaxOrder;
    int                       nDirMaxSector;
    DWORD                     dwSector;
    DWORD                     dwNewCluster;
    FAT32_DIRECTORY_ENTRY      *pDirEntryShort;
    FAT32_DIRECTORY_ENTRY_LONG *pDirEntryLong;
    char                       *pDirName = 0;
    FAT_DIR_TABLE              *pDirTable;

    bError       = FALSE;
    *pFileSize   = 0;
    dwNewCluster = 0;

    nNameLen  = strlen(pLongName);

    bMaxOrder = (BYTE) ((nNameLen + 12) / 13);
    nMaxLen   = (int) (bMaxOrder * 13);
    if (nMaxLen >= (FAT_LONG_NAME_LEN - 1))
    {
        bError = TRUE;
    }

    bOrder = (BYTE) (0x40 | bMaxOrder);
    if (bOrder == 0xE5)
    {
        //
        // I do not know what should I do if the bOrder is 0xe5.
        // This is a sign for a "empty" entry. 
        //
        bError = TRUE;
    }

    if (bError == FALSE)
    {
        bFound   = FALSE;
        bEndLoop = FALSE;
        while ((bEndLoop == FALSE) && (dwDirCluster != 0))
        {
            dwSector = GetFirstSectorOfCluster(pDrive, dwDirCluster);
            nDirMaxSector = (int) pDrive->bSectorsPerCluster;

            //
            // Test for special case dwDirCluster and FAT16.
            //
            if ((dwDirCluster == 1) && (pDrive->bIsFAT32 == FALSE))
            {
                dwSector = pDrive->dwFirstRootDirSector;
                nDirMaxSector = (int) pDrive->dwRootDirSectors;
            }
            //
            // One cluster has SecPerCluster sectors.
            //
            for (i = 0; i < nDirMaxSector; i++)
            {
                HWReadSectors(pDrive->bDevice, pSectorBuffer, dwSector + i, 1);
                pDirTable = (FAT_DIR_TABLE *) pSectorBuffer;

                //
                // And one sector has 16 entries.
                //
                // HW_SECTOR_SIZE / sizeof(FAT32_DIRECTORY_ENTRY) = 16
                //
                for (x = 0; x < 16; x++)
                {
                    if (bFound == TRUE)
                    {
                        pDirEntryShort = (FAT32_DIRECTORY_ENTRY *) & pDirTable->aShort[x];
                        dwNewCluster   = pDirEntryShort->HighCluster;
                        dwNewCluster   = (dwNewCluster << 16) | (DWORD) pDirEntryShort->LowCluster;
                        *pFileSize     = pDirEntryShort->FileSize;
                        bEndLoop       = TRUE;
                        break;
                    }
                    //
                    // Check for valid entry.
                    //
                    pDirEntryShort = (FAT32_DIRECTORY_ENTRY *) & pDirTable->aShort[x];
                    pDirEntryLong = (FAT32_DIRECTORY_ENTRY_LONG *) & pDirTable->aLong[x];

                    if (nIsLongName == FALSE)
                    {
                        //
                        // Check if it could be a short name. If Win2000 tell us it
                        // is a short name, it is true. But with Win98 we must
                        // test both, short and long...
                        //
                        if ((pDirEntryShort->Name[0] != 0xE5) && (pDirEntryShort->Name[0] != 0x00))
                        {
                            if (memcmp(pDirEntryShort, pSearchEntry, 11) == 0)
                            {
                                //
                                // Check for the correct attribute, this is done with
                                // the '&' and not with the memcmp.
                                // With the '&' it is possible to find a hidden archive too :-)
                                //
                                if ((pDirEntryShort->Attribute & pSearchEntry->Attribute) ==
                                    pSearchEntry->Attribute)
                                {

                                    dwNewCluster = pDirEntryShort->HighCluster;
                                    dwNewCluster = (dwNewCluster << 16) | (DWORD) pDirEntryShort->LowCluster;
                                    *pFileSize   = pDirEntryShort->FileSize;

                                    bEndLoop = TRUE;
                                    break;

                                } /* endif Attribute */
                            } /* endif test Name+Ext */
                        } /* endif Name[0] != 0xe5, 0x00 */
                    }
                    /*
                     * endif nIsLongName == FALSE 
                     */
                    if ((pDirEntryLong->Attribute == DIRECTORY_ATTRIBUTE_LONG_NAME)
                        && (pDirEntryLong->Order == bOrder))
                    {
                        //
                        // Next bOrder is bOrder--
                        //  
                        if (bOrder & 0x40)
                        {
                            bOrder &= ~0x40;

                            //
                            // Get the space for the name.
                            //
                            pDirName = pLongName2;

                            //
                            // Set the end of string.
                            //
                            pDirName[nMaxLen--] = 0;
                        }

                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name3[1]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name3[0]);

                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[5]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[4]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[3]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[2]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[1]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[0]);

                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[4]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[3]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[2]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[1]);
                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[0]);

                        bOrder--;
                        if (bOrder == 0)
                        {
                            //
                            // Now compare the name.
                            //
                            bOrder = (BYTE) (0x40 | bMaxOrder);
                            nMaxLen = (int) (bMaxOrder * 13);
                            if (memcmp(pLongName, pDirName, strlen(pLongName)) == 0)
                            {
                                //
                                // The next entry will be the correct entry.
                                //
                                bFound = TRUE;
                            }
                        }
                    }
                    /*
                     * pDirEntryLong->Order == bOrder 
                     */
                } /* endfor x<16 */

                if (bEndLoop == TRUE)
                {
                    break;
                }
            }

            if (bEndLoop == FALSE)
            {
                //
                // No file found in this cluster, get the next one.
                //
                dwDirCluster = GetNextCluster(pDrive, dwDirCluster);
            }
        } /* endwhile */

    }
    /*
     * endif bError == FALSE 
     */
    return(dwNewCluster);
}

/************************************************************/
/*  MountHW                                                 */
/************************************************************/
static int MountHW(int nDrive)
{
    int                    nError;
    int                    i;
    DWORD                 dwSector;
    DWORD                 dwFATSz;
    DWORD                 dwRootDirSectors;
    FAT32_PARTITION_TABLE *pPartitionTable;
    FAT32_BOOT_RECORD     *pBootRecord;
    DRIVE_INFO            *pDrive;

    nError   = HW_OK;
    i        = nDrive;
    pDrive   = &sDriveInfo[nDrive];
    dwSector = 0;

    if (pDrive->bFlags & FLAG_FAT_IS_ZIP)
    {
        dwSector = ZIP_DRIVE_BR_SECTOR;
    }
    else
    {
        //
        // Try to find a PartitionTable.
        // 
        nError = HWReadSectors(nDrive, pSectorBuffer, 0, 1);
        if (nError == HW_OK)
        {
            pPartitionTable = (FAT32_PARTITION_TABLE *) pSectorBuffer;

            if (pPartitionTable->Signature == FAT_SIGNATURE)
            {
                if (pPartitionTable->Partition[0].NumSectors)
                {
                    //
                    // We found a PartitionTable, read BootRecord.
                    // 
                    dwSector = pPartitionTable->Partition[0].StartSectors;
                }
            }
        }
    }

    if (dwSector != 0)
    {
        HWReadSectors(i, pSectorBuffer, dwSector, 1);
        pBootRecord = (FAT32_BOOT_RECORD *) pSectorBuffer;

        //
        // Test valid BootRecord.
        //
        if (pBootRecord->Signature == FAT_SIGNATURE)
        {
            pDrive->bSectorsPerCluster = pBootRecord->SecPerClus;

            if (pBootRecord->FATSz16 != 0)
            {
                dwFATSz = pBootRecord->FATSz16;
                pDrive->bIsFAT32 = FALSE;
                pDrive->dwRootCluster = 1;  /* special value, see */
                                            /* FindFile           */
            }
            else
            {
                dwFATSz               = pBootRecord->Off36.FAT32.FATSz32;
                pDrive->bIsFAT32      = TRUE;
                pDrive->dwRootCluster = pBootRecord->Off36.FAT32.RootClus;
            }

            dwRootDirSectors =
            ((pBootRecord->RootEntCnt * 32) +
             (pBootRecord->BytsPerSec - 1)) / pBootRecord->BytsPerSec;

            pDrive->dwFAT1StartSector = pBootRecord->HiddSec + pBootRecord->RsvdSecCnt;
            pDrive->dwFAT2StartSector = pDrive->dwFAT1StartSector + dwFATSz;

            pDrive->dwCluster2StartSector =
            pBootRecord->HiddSec + pBootRecord->RsvdSecCnt +
            (pBootRecord->NumFATs * dwFATSz) + dwRootDirSectors;

            pDrive->dwClusterSize = pBootRecord->SecPerClus * pDrive->wSectorSize;

            pDrive->dwRootDirSectors = dwRootDirSectors;
            pDrive->dwFirstRootDirSector = pDrive->dwFAT2StartSector + dwFATSz;

        } /* endif pBootRecord->Signature */
    }
    /*
     * endif dwSector != 0 
     */
    return(nError);
}

/************************************************************/
/*  MountAllDrives                                          */
/************************************************************/
static int MountDrive(BYTE bDrive)
{
    int nError;

    nError = HW_OK;

    FATLock();

    if (pLongName1 == NULL)
    {
        pLongName1 = (char *)NutHeapAlloc(FAT_LONG_NAME_LEN);
    }
    if (pLongName2 == NULL)
    {
        pLongName2 = (char *)NutHeapAlloc(FAT_LONG_NAME_LEN);
    }
    if (pSectorBuffer == NULL)
    {
        pSectorBuffer = (BYTE *)NutHeapAlloc(MAX_SECTOR_SIZE);
    }

    if ((pSectorBuffer != NULL) && (pLongName1 != NULL) && (pLongName2 != NULL))
    {
        memset((BYTE *) & sDriveInfo[bDrive], 0x00, sizeof(DRIVE_INFO));

        sDriveInfo[bDrive].bDevice     = bDrive;
        sDriveInfo[bDrive].wSectorSize = HWGetSectorSize(bDrive);

        if (HWIsCDROMDevice(bDrive) == TRUE)
        {
            sDriveInfo[bDrive].bFlags |= FLAG_FAT_IS_CDROM;
        }

        if (HWIsZIPDevice(bDrive) == TRUE)
        {
            sDriveInfo[bDrive].bFlags |= FLAG_FAT_IS_ZIP;
        }

        switch (sDriveInfo[bDrive].wSectorSize)
        {
            case HW_SECTOR_SIZE:{
                    nError = MountHW(bDrive);
                    break;
                }
            default:{
                    nError = HW_ERROR;
                    break;
                }
        }
    }
    /*
     * endif pSectorBuffer != NULL 
     */
    FATFree();

    return(nError);
}

/************************************************************/
/*  MountAllDrives                                          */
/************************************************************/
static int MountAllDrives(void)
{
    BYTE  i;
    int  nError = HW_OK;

    for (i = 0; i < FAT_MAX_DRIVE; i++)
    {
        MountDrive(i);
    }

    return(nError);
}

/*==========================================================*/
/*  DEFINE: All code exported by the NUTDEVICE              */
/*==========================================================*/
/************************************************************/
/*  FATUnMountDrive                                         */
/************************************************************/
static int FATUnMountDrive(int nDrive)
{
    int         nError;
    DRIVE_INFO *pDrive;

    FATLock();

    nError = FAT_OK;

    if ((nDrive >= HW_DRIVE_C) && (nDrive <= HW_DRIVE_D))
    {
        pDrive = &sDriveInfo[nDrive];
        pDrive->bSectorsPerCluster = 0;
    }
    else
    {
        nError = FAT_ERROR;
    }

    FATFree();

    return(nError);
}

/************************************************************/
/*  CFMount                                                 */
/************************************************************/
static void CFMount(int nDrive)
{
    BYTE *pSectorBuffer;

    pSectorBuffer = (BYTE *) NutHeapAlloc(MAX_SECTOR_SIZE);
    if (pSectorBuffer != NULL)
    {
        MountDrive(nDrive);
        NutHeapFree(pSectorBuffer);
    }
}

/************************************************************/
/*  CFUnMount                                               */
/************************************************************/
static void CFUnMount(int nDrive)
{
    FATUnMountDrive(nDrive);
}

/************************************************************/
/*  FATInit                                                 */
/************************************************************/
static int FATInit(NUTDEVICE * pDevice)
{
    int   nError;
    int   nHWMode;  
    BYTE *pSectorBuffer;

    nError        = NUTDEV_ERROR;
    nHWMode       = 0;
    pSectorBuffer = NULL;

    if ((nIsInit              == FALSE) && 
        (pDevice->dev_name[0] == 'F')   &&
        (pDevice->dev_name[1] == 'A')   &&
        (pDevice->dev_name[2] == 'T'))
    {
        nError = NUTDEV_OK;      

        //
        // Get the mode.
        //    
        switch (pDevice->dev_base)
        {

#if (FAT_USE_MMC_INTERFACE >= 1)
            case FAT_MODE_MMC:
                nHWMode = 0;   
                break; 
#endif        
            default:
                nError = NUTDEV_ERROR;
                break;
        }

        if (nError == NUTDEV_OK)
        {
            //
            // Init my semaphore.
            //
            FATSemaInit();

            pSectorBuffer = (BYTE *) NutHeapAlloc(MAX_SECTOR_SIZE);
            if (pSectorBuffer != NULL)
            {
                /*
                 * HW init
                 */
                nError = HWInit(nHWMode, CFMount, CFUnMount);
                if (nError == HW_OK)
                {
                    HWMountAllDevices(nHWMode, pSectorBuffer);

                    /*
                     * FAT init
                     */
                    MountAllDrives();

                    nError  = NUTDEV_OK;
                    nIsInit = TRUE;    
                }
                else
                {
                    nError  = NUTDEV_WRONG_HW;
                }  

                NutHeapFree(pSectorBuffer);
            } /* endif pSectorBuffer != NULL */
        } /* endif nError == NUTDEV_OK */
    }
    else
    {
        if (nIsInit == TRUE)
        {
#if (FAT_USE_MMC_INTERFACE >= 1)
            if ((pDevice->dev_name[0] == 'F')   &&
                (pDevice->dev_name[1] == 'M')   &&
                (pDevice->dev_name[2] == '0'))
            {
                /*
                 * Always OK, because the MMC card
                 * can be inserted later.
                 */
                nError = NUTDEV_OK;  
            }
#endif /* (FAT_USE_MMC_INTERFACE >= 0) */      

        } /* endif (nIsInit == TRUE) */
    } /* endif nIsInit == FALSE */

    return(nError);
}

/************************************************************/
/*  GetDriveByDevice                                        */
/************************************************************/
static DRIVE_INFO* GetDriveByDevice (NUTDEVICE *pDevice)
{
    DRIVE_INFO* pDrive = NULL;

    if (pDevice != NULL)
    {
        switch (pDevice->dev_name[2])
        {
            case 'F':{
                    pDrive = &sDriveInfo[HW_DRIVE_C];
                    break;
                }
            case '0':{
                    pDrive = &sDriveInfo[HW_DRIVE_D];
                    break;
                }
            case '1':{
                    pDrive = &sDriveInfo[HW_DRIVE_E];
                    break;        
                }      
        }
    }

    return(pDrive);
}  

/************************************************************/
/*  FATFileOpen                                             */
/*                                                          */
/*  Opens an existing file for reading.                     */
/*                                                          */
/*  Parameters: pName points to a string that specifies the */
/*              name of the file to open. The name must     */
/*              exactly match the full pathname of the file.*/
/*                                                          */
/*  Returns:    A pointer to a FILE structure that can be   */
/*              used to read the file and retrieve          */
/*              information about the file.                 */
/*                                                          */
/*              A return value of -1 indicates an error.    */
/************************************************************/
static NUTFILE *FATFileOpen(NUTDEVICE *pDevice, CONST char *pName, int nMode,
                            int nAccess)
{
    int                    i, x;
    int                    nError;
    int                    nEndWhile;
    DWORD                 dwFileSize;
    DWORD                 dwCluster;
    FHANDLE               *hFile;
    DRIVE_INFO            *pDrive;
    FAT32_DIRECTORY_ENTRY  sDirEntry;
    NUTFILE               *hNUTFile;
    int                    nLongName;
    char                  *pLongName;
    char                  *pShortName;
    char                  *pExtension;

    //
    // If the user has forgotten to call NUTDeviceOpen,
    // we must call FATInit.
    //
    if (nIsInit == FALSE)
    {
        FATInit(pDevice);
    }

    FATLock();

    pDrive    = NULL;
    nError    = TRUE;
    nLongName = FALSE;
    pLongName = (char *)pLongName1;

    //
    // hFile is our FAT-Handle.
    //
    hFile = NULL;

    //
    // hNUTFile is the.... correct, NUT handle.
    //   
    hNUTFile = (NUTFILE *) NUTDEV_ERROR;

    pDrive = GetDriveByDevice(pDevice);

    if ((pDrive != NULL) && (pDrive->bSectorsPerCluster != 0) && (pName[0] != 0))
    {

        //
        // Create a new file handle.
        //    
        hFile = (FHANDLE *) NutHeapAlloc(sizeof(FHANDLE));

        if ((pDrive->dwFAT1StartSector) && (hFile != NULL) && (*pName != '.'))
        {

            memset(hFile, 0x00, sizeof(FHANDLE));

            //
            // Start by the ROOT dir...
            //
            dwCluster = pDrive->dwRootCluster;

            //
            // If the first char a "/", jump over, e.g. "/index.html"
            // 
            //
            if (*pName == '/')
            {
                pName++;
            }

            nEndWhile = FALSE;
            while (nEndWhile == FALSE)
            {  /* master loop */

                nLongName = FALSE;

                //
                // Get Name
                //
                i = 0;
                while ((*pName != '/') && (*pName != '\\') && (*pName != 0))
                {

                    if (i >= (FAT_LONG_NAME_LEN - 1))
                    {
                        nEndWhile = TRUE;
                        break;
                    }

                    pLongName[i] = toupper(*pName);

                    i++;
                    pName++;
                } /* endwhile Name */

                if (nEndWhile == FALSE)
                {
                    pLongName[i] = 0;

                    //
                    // Check if it is a Long Directory Entry.
                    // Yes, I know that 'i' is the length of the string.
                    // But the code is easier to read with the next strlen.
                    //
                    if (strlen(pLongName) <= FAT_SHORT_NAME_LEN)
                    {
                        //
                        // It could be a ShortName, but "abc.defg" is possible
                        // and this is a long name too. Therfore we need some tests.
                        //
                        pExtension = strchr(pLongName, '.');
                        if (pExtension == NULL)
                        {
                            if (strlen(pLongName) > FAT_NAME_LEN)
                            {
                                nLongName = TRUE;
                            }
                            else
                            {
                                nLongName = FALSE;
                            }
                        }
                        else
                        {
                            //
                            // Check the length of the extensions.
                            //
                            pExtension++; /* jump over the '.' */
                            if (strlen(pExtension) > 3)
                            {
                                nLongName = TRUE;
                            }
                        }
                    }
                    else
                    {  /* Len > FAT_SHORT_NAME_LEN */
                        //
                        // Now we have a LongName, sure.
                        // See the "nasty Win98" in FindFile :-)
                        //
                        nLongName = TRUE;
                    }

                    //
                    // Here we knows, if we have a LongName or ShortName.
                    //
                    if (nLongName == FALSE)
                    {
                        //
                        // ShortName
                        //
                        pShortName = pLongName;
                        memset(&sDirEntry, 0x00, sizeof(FAT32_DIRECTORY_ENTRY));
                        memset(sDirEntry.Name, 0x20, FAT_NAME_LEN);
                        memset(sDirEntry.Extension, 0x20, FAT_EXT_LEN);

                        //
                        // Get the name
                        //
                        i = 0;
                        while ((pShortName[i] != '.') && (pShortName[i] != 0))
                        {
                            sDirEntry.Name[i] = pShortName[i];
                            i++;
                        }
                        //
                        // And the extension
                        //
                        if (pShortName[i] == '.')
                        {
                            i++;  /* jump over the '.' */
                            x = 0;
                            while (pShortName[i] != 0)
                            {
                                sDirEntry.Extension[x] = pShortName[i];
                                i++;
                                x++;
                            }
                        }
                    }
                    //
                    // The file could be a long or short one.
                    // I have seen that Win98 store the short filename
                    // in a long one :-(
                    //
                    switch (*pName)
                    {
                        //
                        // The file is an ARCHIVE
                        //
                        case 0:{
                                nEndWhile = TRUE;
                                sDirEntry.Attribute = DIRECTORY_ATTRIBUTE_ARCHIVE;

                                if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
                                {
                                    dwCluster = 0;
                                }
                                else
                                {
                                    dwCluster =
                                    FindFile(pDrive, &sDirEntry, pLongName, dwCluster, &dwFileSize,
                                             nLongName);
                                }
                                if (dwCluster != 0)
                                {
                                    hFile->dwFileSize       = dwFileSize;
                                    hFile->dwStartCluster   = dwCluster;
                                    hFile->dwReadCluster    = dwCluster;
                                    hFile->dwFilePointer    = 0;
                                    hFile->dwClusterPointer = 0;
                                    hFile->pDrive           = pDrive;
                                    hFile->nLastError       = FAT_OK;
                                    hFile->nEOF             = FALSE;

                                    nError                  = FALSE;
                                }
                                break;
                            } /* endcase 0 */

                            //
                            // The file is a DIRECTORY
                            //
                        case '/':
                        case '\\':{
                                pName++;  /* jump over the char */

                                sDirEntry.Attribute = DIRECTORY_ATTRIBUTE_DIRECTORY;

                                if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
                                {
                                    dwCluster = 0;
                                }
                                else
                                {
                                    dwCluster =
                                    FindFile(pDrive, &sDirEntry, pLongName, dwCluster, &dwFileSize,
                                             nLongName);
                                }
                                if (dwCluster != 0)
                                {

                                    //
                                    // The new Cluster is the Cluster of the directory
                                    //

                                }
                                else
                                {
                                    nEndWhile = TRUE;
                                }
                                break;
                            } /* endcase / \ */

                        default:{
                                nEndWhile = TRUE;
                                break;
                            }
                    } /* end switch */

                }
                /*
                 * endif nEndWhile == FALSE 
                 */
            } /* end while */

        }
        /*
         * endif pDrive->dwFAT1StartSector 
         */
        if (nError == TRUE)
        {
            //
            // We found no file, therefore we can delete our FAT-Handle
            //
            if (hFile != NULL)
            {
                NutHeapFree(hFile);
            }
        }
        else
        {
            //
            // We have found a FILE and can create a NUT-Handle.
            //
            hNUTFile = NutHeapAlloc(sizeof(NUTFILE));
            if (hNUTFile != NULL)
            {
                hNUTFile->nf_next = 0;
                hNUTFile->nf_dev  = pDevice;
                hNUTFile->nf_fcb  = hFile;
            }
            else
            {
                //
                // Error, no mem for the NUT-Handle, therefore we 
                // can delete our FAT-Handle too.
                //
                NutHeapFree(hFile);
            }
        }

    }
    /*
     * endif pName[0] != 0 
     */
    FATFree();

    return(hNUTFile);
}

/************************************************************/
/*  FATFileClose                                            */
/*                                                          */
/*  Close a previously opened file.                         */
/*                                                          */
/*  Parameters: hNUTFile Identifies the file to close.      */
/*              This pointer must have been created by      */
/*              calling FAT32FileOpen().                    */
/*                                                          */
/*  Returns:    0 if the function is successfully closed,   */
/*              -1 otherwise.                               */
/************************************************************/
static int FATFileClose(NUTFILE * hNUTFile)
{
    int      nError;
    FHANDLE *hFile;

    nError = NUTDEV_ERROR;

    FATLock();

    if (hNUTFile != NULL)
    {
        hFile = (FHANDLE *) hNUTFile->nf_fcb;
        if (hFile != NULL)
        {
            //
            // Clear our FAT-Handle
            //
            NutHeapFree(hFile);
        }
        //
        // Clear the NUT-Handle
        //
        NutHeapFree(hNUTFile);

        nError = NUTDEV_OK;
    }

    FATFree();

    return(nError);
}

/************************************************************/
/*  FATFileSize                                             */
/*                                                          */
/*  Retrieve the size of a file.                            */
/*                                                          */
/*  Parameters: pFile Identifies the file to query.         */
/*              This pointer must have been created by      */
/*              calling FAT32FileOpen().                    */
/*                                                          */
/*  Returns:    The number of bytes in this file or         */
/*              -1 if an error occured                      */
/************************************************************/
long FATFileSize(NUTFILE * hNUTFile)
{
    long     lSize;
    FHANDLE *hFile;

    FATLock();

    lSize = NUTDEV_ERROR;

    if (hNUTFile != NULL)
    {
        hFile = (FHANDLE *) hNUTFile->nf_fcb;
        if (hFile != NULL)
        {
            lSize = hFile->dwFileSize;
        }
    }

    FATFree();

    return(lSize);
}

#if 0
/************************************************************/
/*  FATFileSeek                                             */
/*                                                          */
/*  Move the file pointer to a new position.                */
/*  It points to the next byte to be read from a file.      */
/*  The file pointer is automatically incremented for       */
/*  each byte read. When the file is opened, it is at       */
/*  position 0, the beginning of the file.                  */
/*                                                          */
/*  Parameters: pFile Identifies the file to seek.          */
/*              This pointer must have been created by      */
/*              calling FAT32FileOpen().                    */
/*                                                          */
/*              lPos Specifies the new absolute position    */
/*              of the file pointer.                        */
/*                                                          */
/*  Returns:    0 if the function is successful,            */
/*              -1 otherwise.                               */
/************************************************************/
int FATFileSeek(FILE * pFile, long lPos)
{
    int      nError = NUTDEV_ERROR;
    FHANDLE *hFile;

    FATLock();

    hFile = (FHANDLE *) pFile;

    //
    // We must do some work here...
    //
    nError = FAT32_ERROR;

    FATFree();

    return(nError);
}
#endif

/************************************************************/
/*  FATFileRead                                             */
/*                                                          */
/*  Read data from a file.                                  */
/*                                                          */
/*  Parameters: pFile Identifies the file to read from.     */
/*              This pointer must have been created by      */
/*              calling FAT32FileOpen().                    */
/*                                                          */
/*              pData Points to the buffer that receives    */
/*              the data.                                   */
/*                                                          */
/*              nSize Specifies the number of bytes to      */
/*              read from the file.                         */
/*                                                          */
/*  Returns:    The number of bytes read from the file or   */
/*               -1 if an error occured.                    */
/************************************************************/
int FATFileRead(NUTFILE * hNUTFile, void *pData, int nSize)
{
    int         nError;
    int         nBytesRead;
    int         nBytesToRead;
    FHANDLE    *hFile;
    DRIVE_INFO *pDrive;
    BYTE       *pByte;
    DWORD      dwReadSector;
    DWORD      dwSector;
    int         nSectorCount;
    int         nSectorOffset;
    WORD        wSectorSize;

    nBytesRead = 0;

    FATLock();

    hFile  = NULL;
    nError = NUTDEV_ERROR;

    if (hNUTFile != NULL)
    {
        hFile = (FHANDLE *) hNUTFile->nf_fcb;
    }

    if ((hFile != NULL) && (nSize != 0))
    {
        if (hFile->dwFilePointer < hFile->dwFileSize)
        {

            if ((hFile->dwFilePointer + nSize) > hFile->dwFileSize)
            {
                nSize = (int) (hFile->dwFileSize - hFile->dwFilePointer);
            }

            pDrive = (DRIVE_INFO *) hFile->pDrive;
            pByte  = (BYTE *) pData;

            nBytesRead  = nSize;
            wSectorSize = pDrive->wSectorSize;

            while (nSize)
            {
                dwSector = GetFirstSectorOfCluster(pDrive, hFile->dwReadCluster);
                nSectorCount = hFile->dwClusterPointer / wSectorSize;
                nSectorOffset = hFile->dwClusterPointer % wSectorSize;

                //
                // (Sector + SectorCount) is the sector to read
                // SectorOffset is the start position in the sector itself
                //
                dwReadSector = dwSector + nSectorCount;

                nError = HWReadSectors(pDrive->bDevice, pSectorBuffer, dwReadSector, 1);
                if (nError == HW_OK)
                {
                    //
                    // Find the size we can read from ONE sector
                    //
                    if (nSize > (int) wSectorSize)
                    {
                        nBytesToRead = wSectorSize;
                    }
                    else
                    {
                        nBytesToRead = nSize;
                    }

                    //
                    // Test inside a sector
                    //
                    if ((nSectorOffset + nBytesToRead) > (int) wSectorSize)
                    {
                        nBytesToRead = wSectorSize - nSectorOffset;
                    }

                    memcpy(pByte, &pSectorBuffer[nSectorOffset], nBytesToRead);
                    pByte += nBytesToRead;

                    hFile->dwFilePointer    += nBytesToRead;
                    hFile->dwClusterPointer += nBytesToRead;

                    //
                    // Check for EOF
                    if (hFile->dwFilePointer >= hFile->dwFileSize)
                    {
                        hFile->nEOF = TRUE;
                    }

                    if (hFile->dwClusterPointer >= pDrive->dwClusterSize)
                    {
                        //
                        // We must switch to the next cluster
                        //
                        hFile->dwReadCluster = GetNextCluster(pDrive, hFile->dwReadCluster);
                        hFile->dwClusterPointer = 0;
                    }

                    nSize -= nBytesToRead;

                }
                else
                {  /* HWReadSectors Error */

                    nBytesRead = 0;
                    hFile->nLastError = FAT_ERROR_IDE;
                    break;
                } /* endif nError == HW_OK */

            } /* endwhile */

        }
        else
        {  /* reached the EOF */
            hFile->nLastError = FAT_ERROR_EOF;
        } /* endif hFile->dwFilePointer < hFile->dwFileSize */

    }
    /*
     * endif (hFile != NULL) && (nSize != 0) 
     */
    FATFree();

    return(nBytesRead);
}

/************************************************************/
/*  FATFileWrite                                            */
/*                                                          */
/*  Write data to a file.                                   */
/*                                                          */
/*  Parameters: pFile Identifies the file to write to.      */
/*              This pointer must have been created by      */
/*              calling FAT32FileOpen().                    */
/*                                                          */
/*              pData Points to the buffer that holds       */
/*              the data.                                   */
/*                                                          */
/*              nSize Specifies the number of bytes to      */
/*              write to the file.                          */
/*                                                          */
/*  Returns:    The number of bytes written to the file or  */
/*               -1 if an error occured.                    */
/************************************************************/
static int FATFileWrite(NUTFILE * hNUTFile, CONST void *pData, int nSize)
{
    int nError;

    nError = NUTDEV_ERROR;

    return(nError);
}

#ifdef __HARVARD_ARCH__
static int FATFileWriteP(NUTFILE * hNUTFile, PGM_P pData, int nSize)
{
    int nError;

    nError = NUTDEV_ERROR;

    return(nError);
}
#endif

/************************************************************/
/*  FATIOCtl                                                */
/*                                                          */
/*  Perform IOCTL control functions.                        */
/*                                                          */
/*  reg May be set to one of the following constants:       */
/*                                                          */
/*  Parameters: dev  Identifies the device to use.          */
/*              reg  Requested control function.            */
/*              conf Points to a buffer that contains any   */
/*                   data required for the given control    */
/*                   function or receives data from that    */
/*                   function.                              */
/*  Returns:    0 on success, or -1 if an error occured.    */
/************************************************************/
int FATIOCtl(NUTDEVICE *dev, int req, void *conf)
{
    int         nError = NUTDEV_ERROR;
    DRIVE_INFO *pDrive = GetDriveByDevice(dev);

    if (pDrive != NULL)
    {
        switch (req)
        {

#if (FAT_SUPPORT_FORMAT >= 1)    
            case FAT_IOCTL_QUICK_FORMAT: {
                    nError = QuickFormat(dev, pDrive);
                    break;
                }
#endif

            default: {
                    nError = NUTDEV_ERROR;
                    break; 
                }

        }  
    }

    return(nError);
}

//
// FAT Device information structure.
// Is mapped to the FAT-Device.
// The user MUST first register the FAT hardware.
//
NUTDEVICE devFAT = {
    0,              /* Pointer to next device. */

    /*
     * Unique device name.     
     */
    {'F', 'A', 'T', 0, 0, 0, 0, 0, 0},

    IFTYP_STREAM,   /* Type of device.                   */
    2,              /* Base address.                     */
    0,              /* First interrupt number.           */
    0,              /* Interface control block.          */
    0,              /* Driver control block.             */
    FATInit,        /* Driver initialization routine.    */
    0,              /* Driver specific control function. */
    0,              /* Driver specific read function.    */
    0,              /* Driver specific write function.   */

#ifdef __HARVARD_ARCH__
    0,              /* Driver specific write_p function. */
#endif

    0,              /* Driver specific open function.    */
    0,              /* Driver specific close function.   */
    0
};

#if (FAT_USE_MMC_INTERFACE >= 1)
//
// FATUSB Device information structure.
// Is mapped to the first USB drive
//
NUTDEVICE devFATMMC0 = {
    0,              /* Pointer to next device. */

    /*
     * Unique device name.     
     */
    {'F', 'M', '0', 0, 0, 0, 0, 0, 0},

    IFTYP_STREAM,   /* Type of device.                   */
    2,              /* Base address.                     */
    0,              /* First interrupt number.           */
    0,              /* Interface control block.          */
    0,              /* Driver control block.             */
    FATInit,        /* Driver initialization routine.    */
    FATIOCtl,       /* Driver specific control function. */
    FATFileRead,    /* Driver specific read function.    */
    FATFileWrite,   /* Driver specific write function.   */

#ifdef __HARVARD_ARCH__
    FATFileWriteP,  /* Driver specific write_p function. */
#endif

    FATFileOpen,    /* Driver specific open function.    */
    FATFileClose,   /* Driver specific close function.   */
    FATFileSize
};
#endif /* (FAT_USE_MMC_INTERFACE >= 1) */


#if (FAT_SUPPORT_FORMAT >= 1)
/************************************************************/
/*  GetClusterSize                                          */
/************************************************************/
static BYTE GetClusterSize (DWORD dTotalSectors)
{
    BYTE bIndex;
    BYTE bSecPerClus = 0;

    for (bIndex=0; bIndex<DSK_TABLE_FAT32_ENTRY_COUNT; bIndex++)
    {
        if (dTotalSectors <= DskTableFAT32[bIndex].DiskSize)
        {
            bSecPerClus = DskTableFAT32[bIndex].SecPerClusVal;
            break;      
        }
    }

    return(bSecPerClus);
}

/************************************************************/
/*  QuickFormat                                             */
/************************************************************/
static int QuickFormat(NUTDEVICE *dev, DRIVE_INFO *pDrive)
{
    DWORD                   i;
    int                    nError = NUTDEV_ERROR;
    BYTE                  *pBuffer;
    BYTE                   bDevice;
    BYTE                   bSecPerClus;  
    DWORD                  dSector;
    DWORD                  dFirstDataSector;
    DWORD                  dLastDataSector;
    DWORD                  dMaxClusterCount;
    DWORD                  dFAT1StartSector=0;
    DWORD                  dFAT2StartSector=0;
    DWORD                  dCluster2StartSector;
    DWORD                  dClearCount;
    DWORD                  dTotalSectors;
    DWORD                  dPossibleClusterCount;
    DWORD                  dFATSz32;
    FAT32_PARTITION_TABLE *pPartitionTable;  
    FAT32_BOOT_RECORD     *pBootRecord;
    FAT32_FSINFO          *pFSInfo;
    FAT32_DIRECTORY_ENTRY *pDirEntry;
    LONG                  *pLong;
    DWORD                  dVollID;

    FATLock();

    /*
     * Get the sector buffer
     */  
    pBuffer = (u_char *)NutHeapAlloc(pDrive->wSectorSize);
    if (pBuffer != NULL)
    {

        bDevice        = pDrive->bDevice;    
        dTotalSectors  = HWGetTotalSectors(bDevice);
        dTotalSectors -= BPB_RsvdSecCnt;

        bSecPerClus = GetClusterSize(dTotalSectors);     
        if (bSecPerClus == 0)
        {
            /*
             * Sorry, to small for FAT32,
             * the lib will support FAT16 later....
             */
            NutHeapFree(pBuffer);  
            return(NUTDEV_ERROR);    
        }

        dPossibleClusterCount = (dTotalSectors / (LONG)bSecPerClus);

        dFATSz32              = (dPossibleClusterCount * sizeof(long) + 
                                 (FAT32_SECTOR_SIZE -1) ) / FAT32_SECTOR_SIZE; 

        /*
         * First we will clear the sectors which we will use
         * for the MBR, BPB and the FA's.
         */
        dClearCount  = BPB_HiddSec + BPB_RsvdSecCnt;
        dClearCount += (BPB_NumFATs * dFATSz32) + bSecPerClus;

        memset(pBuffer, 0x00, pDrive->wSectorSize);        
        for (i=0; i<dClearCount; i++)
        {
            nError = HWWriteSectors(bDevice, pBuffer, i, 1);    
            if (nError != HW_OK)
            {
                break;
            }
        }

        /*
         * Create the Volume serial number,
         * we have no random value, therefore
         * use the dTotalSectors and time.
         */
        dVollID = (DWORD)time(NULL) * dTotalSectors;

        /*
         * Create MBR (MasterBootRecord)
         */
        memset(pBuffer, 0x00, pDrive->wSectorSize);
        pPartitionTable = (FAT32_PARTITION_TABLE *)pBuffer;

        pPartitionTable->Partition[0].BootInd      = 0x00;
        pPartitionTable->Partition[0].FirstHead    = 1;
        pPartitionTable->Partition[0].FirstSector  = 1;
        pPartitionTable->Partition[0].FirstTrack   = 0;
        pPartitionTable->Partition[0].FileSystem   = MBR_FAT32;
        pPartitionTable->Partition[0].LastHead     = 0;
        pPartitionTable->Partition[0].LastSector   = 0;
        pPartitionTable->Partition[0].StartSectors = BPB_HiddSec;
        pPartitionTable->Partition[0].NumSectors   = dTotalSectors;
        pPartitionTable->Signature                 = MBR_SIGNATURE;

        /*
         * Write the MBR to the drive
         */
        nError = HWWriteSectors(bDevice, pBuffer, 0, 1);    
        if (nError == HW_OK)
        {
            /*
             * Create the BPB
             */
            memset(pBuffer, 0x00, pDrive->wSectorSize);
            pBootRecord = (FAT32_BOOT_RECORD *)pBuffer;

            pBootRecord->JumpBoot[0] = 0xEB;
            pBootRecord->JumpBoot[1] = 0x58;
            pBootRecord->JumpBoot[2] = 0x90;

            pBootRecord->OEMName[0]  = 'M';
            pBootRecord->OEMName[1]  = 'S';
            pBootRecord->OEMName[2]  = 'D';
            pBootRecord->OEMName[3]  = 'O';
            pBootRecord->OEMName[4]  = 'S';
            pBootRecord->OEMName[5]  = '5';
            pBootRecord->OEMName[6]  = '.';
            pBootRecord->OEMName[7]  = '0';

            pBootRecord->BytsPerSec  = FAT32_SECTOR_SIZE;
            pBootRecord->SecPerClus  = bSecPerClus;
            pBootRecord->RsvdSecCnt  = BPB_RsvdSecCnt;
            pBootRecord->NumFATs     = BPB_NumFATs;
            pBootRecord->RootEntCnt  = 0;
            pBootRecord->TotSec16    = 0;
            pBootRecord->Media       = FAT32_MEDIA;      

            pBootRecord->FATSz16     = 0;
            pBootRecord->SecPerTrk   = 63;
            pBootRecord->NumHeads    = 255;

            pBootRecord->HiddSec     = BPB_HiddSec;
            pBootRecord->TotSec32    = dTotalSectors;

            pBootRecord->Off36.FAT32.FATSz32       = dFATSz32;
            pBootRecord->Off36.FAT32.ExtFlags      = 0;
            pBootRecord->Off36.FAT32.FSVer         = 0;
            pBootRecord->Off36.FAT32.RootClus      = 2;
            pBootRecord->Off36.FAT32.FSInfo        = FAT32_OFFSET_FSINFO;
            pBootRecord->Off36.FAT32.BkBootSec     = FAT32_OFFSET_BACKUP_BOOT;

            pBootRecord->Off36.FAT32.DrvNum        = 0x00; 
            pBootRecord->Off36.FAT32.BootSig       = 0x29;
            pBootRecord->Off36.FAT32.VollID        = dVollID;
            pBootRecord->Off36.FAT32.VolLab[0]     = 'N';
            pBootRecord->Off36.FAT32.VolLab[1]     = 'O';
            pBootRecord->Off36.FAT32.VolLab[2]     = ' ';
            pBootRecord->Off36.FAT32.VolLab[3]     = 'N';
            pBootRecord->Off36.FAT32.VolLab[4]     = 'A'; 
            pBootRecord->Off36.FAT32.VolLab[5]     = 'M'; 
            pBootRecord->Off36.FAT32.VolLab[6]     = 'E'; 
            pBootRecord->Off36.FAT32.VolLab[7]     = ' '; 
            pBootRecord->Off36.FAT32.VolLab[8]     = ' '; 
            pBootRecord->Off36.FAT32.VolLab[9]     = ' '; 
            pBootRecord->Off36.FAT32.VolLab[10]    = ' '; 

            pBootRecord->Off36.FAT32.FilSysType[0] = 'F';
            pBootRecord->Off36.FAT32.FilSysType[1] = 'A';
            pBootRecord->Off36.FAT32.FilSysType[2] = 'T';
            pBootRecord->Off36.FAT32.FilSysType[3] = '3';
            pBootRecord->Off36.FAT32.FilSysType[4] = '2';
            pBootRecord->Off36.FAT32.FilSysType[5] = ' ';
            pBootRecord->Off36.FAT32.FilSysType[6] = ' ';
            pBootRecord->Off36.FAT32.FilSysType[7] = ' ';

            pBootRecord->Signature                 = FAT_SIGNATURE;

            /*
             * Write the BPB to the drive
             */
            dSector = BPB_HiddSec;
            nError  = HWWriteSectors(bDevice, pBuffer, dSector, 1);    
            if (nError == HW_OK)
            {
                dSector += FAT32_OFFSET_BACKUP_BOOT;
                nError   = HWWriteSectors(bDevice, pBuffer, dSector, 1);            
            }
        }

        /*
         * Create the FSINFO
         */
        if (nError == HW_OK)
        {
            memset(pBuffer, 0x00, pDrive->wSectorSize);
            pFSInfo = (FAT32_FSINFO *)pBuffer;

            dFirstDataSector = BPB_HiddSec + BPB_RsvdSecCnt;
            dLastDataSector  = dTotalSectors;
            dMaxClusterCount = dLastDataSector - dFirstDataSector;
            dMaxClusterCount = dMaxClusterCount / (LONG)bSecPerClus;

            pFSInfo->FirstSignature               = FSINFO_FIRSTSIGNATURE;
            pFSInfo->FSInfoSignature              = FSINFO_FSINFOSIGNATURE;
            pFSInfo->NumberOfFreeClusters         = dMaxClusterCount;
            pFSInfo->MostRecentlyAllocatedCluster = 2;
            pFSInfo->Signature                    = FSINFO_SIGNATURE;

            /*
             * Write the FSINFO to the drive
             */      
            dSector = BPB_HiddSec + FAT32_OFFSET_FSINFO;
            nError  = HWWriteSectors(bDevice, pBuffer, dSector, 1);        
        }

        /*
         * Write first FAT entry after format.
         */
        if (nError == HW_OK)
        {
            dFAT1StartSector = BPB_HiddSec + BPB_RsvdSecCnt;    
            dFAT2StartSector = dFAT1StartSector + dFATSz32; 

            memset(pBuffer, 0x00, pDrive->wSectorSize);
            pLong = (LONG *)pBuffer;

            /*
             * Set the two reserved cluster after the format,
             * take a look in the MS Hardware White Paper
             * Version 1.03, December 6, 2000 for more information.
             */
            *pLong++ = 0x0FFFFFF8;
            *pLong++ = FAT32_CLUSTER_EOF;
            *pLong++ = FAT32_CLUSTER_EOF;

            nError = HWWriteSectors(bDevice, pBuffer, dFAT1StartSector, 1);        
            if (nError == HW_OK)
            {
                nError = HWWriteSectors(bDevice, pBuffer, dFAT2StartSector, 1);              
            }
        }

        /*
         * Create RootDir
         */
        if (nError == HW_OK)
        {
            memset(pBuffer, 0x00, pDrive->wSectorSize);
            pDirEntry = (FAT32_DIRECTORY_ENTRY *)pBuffer;

            pDirEntry->Name[0]      = 'E'; 
            pDirEntry->Name[1]      = 'T';
            pDirEntry->Name[2]      = 'H';
            pDirEntry->Name[3]      = 'E';
            pDirEntry->Name[4]      = 'R';
            pDirEntry->Name[5]      = 'N';
            pDirEntry->Name[6]      = 'U';
            pDirEntry->Name[7]      = 'T';

            pDirEntry->Extension[0] = ' ';
            pDirEntry->Extension[1] = ' ';
            pDirEntry->Extension[2] = ' ';

            pDirEntry->Attribute    = DIRECTORY_ATTRIBUTE_VOLUME_ID;
            pDirEntry->HighCluster  = 0;
            pDirEntry->LowCluster   = 0;
            pDirEntry->FileSize     = 0;

            dCluster2StartSector = dFAT2StartSector + dFATSz32;
            nError = HWWriteSectors(bDevice, pBuffer, dCluster2StartSector, 1);                    
        }

        NutHeapFree(pBuffer);  

        FATFree();


        /*
         * Don't forget to mount the drive
         */   
        if (nError == HW_OK)
        {
            nError = MountDrive(bDevice);
        }

        if (nError == HW_OK)
        {
            nError = NUTDEV_OK;        
        }
        else
        {
            nError = NUTDEV_ERROR;    
        }    
    }

    return(nError);
}
#endif /* (FAT_SUPPORT_FORMAT >= 1) */