1 files changed, 1327 insertions, 0 deletions

diff --git a/private/ntos/fw/mips/fwio.c b/private/ntos/fw/mips/fwio.c
new file mode 100644
index 000000000..7b66eb5e4
--- /dev/null
+++ b/private/ntos/fw/mips/fwio.c
@@ -0,0 +1,1327 @@
+/*++
+
+Copyright (c) 1991  Microsoft Corporation
+
+Module Name:
+
+    fwio.c
+
+Abstract:
+
+    This module implements the ARC firmware I/O operations for a MIPS
+    R3000 or R3000 Jazz system.
+
+Author:
+
+    David N. Cutler (davec) 14-May-1991
+
+
+Revision History:
+
+    Lluis Abello (lluis) 20-Jun-1991
+
+--*/
+
+#include "fwp.h"
+#include "string.h"
+#include "fwstring.h"
+
+
+//
+// Define file table.
+//
+
+BL_FILE_TABLE BlFileTable[BL_FILE_TABLE_SIZE];
+
+#define DEVICE_DEVICE 0xDEAD
+
+extern BL_DEVICE_ENTRY_TABLE OmfEntryTable;
+extern BL_DEVICE_ENTRY_TABLE OmfFileEntryTable;
+
+//
+// Declare the table of opened devices.
+//
+OPENED_PATHNAME_ENTRY OpenedPathTable[SIZE_OF_OPENED_PATHNAME_TABLE];
+
+//
+// Declare the table of opened drivers.
+//
+DRIVER_LOOKUP_ENTRY DeviceLookupTable[SIZE_OF_LOOKUP_TABLE];
+
+//
+// Define data structure for the file system structure context.
+//
+
+typedef union _FILE_SYSTEM_STRUCTURE {
+    FAT_STRUCTURE_CONTEXT   FatContext;
+    ULONG                   Tmp;
+} FILE_SYSTEM_STRUCTURE, *PFILE_SYSTEM_STRUCTURE;
+
+typedef struct _FS_POOL_ENTRY {
+    BOOLEAN     InUse;
+    FILE_SYSTEM_STRUCTURE Fs;
+} FS_POOL_ENTRY, *PFS_POOL_ENTRY;
+
+#define FS_POOL_SIZE 8
+PFS_POOL_ENTRY FileSystemStructurePool;
+
+//
+// Declare local procedures
+//
+
+VOID
+FiFreeFsStructure(
+    IN PFILE_SYSTEM_STRUCTURE PFs
+    );
+
+PVOID
+FiAllocateFsStructure(
+    VOID
+    );
+
+
+ARC_STATUS
+FiGetFileTableEntry(
+    OUT PULONG  Entry
+    );
+
+PFAT_STRUCTURE_CONTEXT
+FiAllocateFatStructure(
+    VOID
+    );
+
+
+VOID
+HalFlushIoBuffers (
+    IN PMDL Mdl,
+    IN BOOLEAN ReadOperation,
+    IN BOOLEAN DmaOperation
+    )
+
+/*++
+
+Routine Description:
+
+    This function flushes the I/O buffer specified by the memory descriptor
+    list from the data cache on the current processor.
+
+Arguments:
+
+    Mdl - Supplies a pointer to a memory descriptor list that describes the
+        I/O buffer location.
+
+    ReadOperation - Supplies a boolean value that determines whether the I/O
+        operation is a read into memory.
+
+    DmaOperation - Supplies a boolean value that determines whether the I/O
+        operation is a DMA operation.
+
+Return Value:
+
+    None.
+
+--*/
+
+{
+
+    ULONG CacheSegment;
+    ULONG Length;
+    ULONG Offset;
+    KIRQL OldIrql;
+    PULONG PageFrame;
+    ULONG Source;
+
+    //
+    // The Jazz R4000 uses a write back data cache and, therefore, must be
+    // flushed on reads and writes.
+    //
+    // Raise IRQL to dispatch level to prevent a context switch.
+    //
+
+//    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+    //
+    // If the length of the I/O operation is greater than the size of the
+    // data cache, then sweep the entire data cache. Otherwise, export or
+    // purge individual pages from the data cache as appropriate.
+    //
+
+    Offset = Mdl->ByteOffset & PCR->DcacheAlignment;
+
+#if DBG
+
+//    if (ReadOperation != FALSE) {
+//        if (Offset != 0) {
+//            DbgPrint("\n*** CAUTION *** unaliged transfer - proceed at your own risk\n");
+//            DbgBreakPoint();
+//        }
+//    }
+
+#endif
+
+    Length = (Mdl->ByteCount +
+                        PCR->DcacheAlignment + Offset) & ~PCR->DcacheAlignment;
+
+    if ((Length > PCR->FirstLevelDcacheSize) &&
+        (Length > PCR->SecondLevelDcacheSize)) {
+
+        //
+        // If the I/O operation is a DMA operation, or the I/O operation is
+        // not a DMA operation and the I/O operation is a page read operation,
+        // then sweep (index/writeback/invalidate) the entire data cache.
+        //
+
+        if ((DmaOperation != FALSE) ||
+            ((DmaOperation == FALSE) &&
+            (ReadOperation != FALSE) &&
+            ((Mdl->MdlFlags & MDL_IO_PAGE_READ) != 0))) {
+            HalSweepDcache();
+        }
+
+        //
+        // If the I/O operation is a page read, then sweep (index/invalidate)
+        // the entire instruction cache.
+        //
+
+        if ((ReadOperation != FALSE) &&
+            ((Mdl->MdlFlags & MDL_IO_PAGE_READ) != 0)) {
+            HalSweepIcache();
+        }
+
+    } else {
+
+        //
+        // Export or purge the specified pages from the data cache and
+        // instruction caches as appropriate.
+        //
+        // Compute the number of pages to flush and the starting MDL page
+        // frame address.
+        //
+
+        Offset = Mdl->ByteOffset & ~PCR->DcacheAlignment;
+        PageFrame = (PULONG)(Mdl + 1);
+        Source = ((ULONG)(Mdl->StartVa) & 0xfffff000) | Offset;
+
+        //
+        // Export or purge the specified page segments from the data and
+        // instruction caches as appropriate.
+        //
+
+        do {
+            if (Length >= (PAGE_SIZE - Offset)) {
+                CacheSegment = PAGE_SIZE - Offset;
+
+            } else {
+                CacheSegment = Length;
+            }
+
+            if (ReadOperation == FALSE) {
+
+                //
+                // The I/O operation is a write and the data only needs to
+                // to be copied back into memory if the operation is also
+                // a DMA operation.
+                //
+
+                if (DmaOperation != FALSE) {
+                    HalExportDcachePage((PVOID)Source, *PageFrame, CacheSegment);
+                }
+
+            } else {
+
+                //
+                // If the I/O operation is a DMA operation, then purge the
+                // data cache. Otherwise, is the I/O operation is a page read
+                // operation, then export the data cache.
+                //
+
+                //
+                // This has been to flush rather than purge the D cache on DMA
+                // operations.  The ARC firmware allows non-aligned reads, and
+                // the purge operation can destroy information that is in the
+                // same cache line as the DMA.
+                //
+
+                if (DmaOperation != FALSE) {
+//                    HalPurgeDcachePage((PVOID)Source, *PageFrame, CacheSegment);
+                    HalFlushDcachePage((PVOID)Source, *PageFrame, CacheSegment);
+
+                } else if ((Mdl->MdlFlags & MDL_IO_PAGE_READ) != 0) {
+                    HalExportDcachePage((PVOID)Source, *PageFrame, CacheSegment);
+                }
+
+                //
+                // If the I/O operation is a page read, then the instruction
+                // cache must be purged.
+                //
+
+                if ((Mdl->MdlFlags & MDL_IO_PAGE_READ) != 0) {
+//                    HalPurgeIcachePage((PVOID)Source, *PageFrame, CacheSegment);
+                    HalFlushDcachePage((PVOID)Source, *PageFrame, CacheSegment);
+                }
+            }
+
+            PageFrame += 1;
+            Length -= CacheSegment;
+            Offset = 0;
+            Source += CacheSegment;
+        } while(Length != 0);
+    }
+
+    //
+    // Lower IRQL to its previous value.
+    //
+
+//    KeLowerIrql(OldIrql);
+    return;
+}
+
+
+ARC_STATUS
+FwGetFileInformation (
+    IN ULONG FileId,
+    OUT PFILE_INFORMATION Finfo
+    )
+
+/*++
+
+Routine Description:
+
+    This function gets the file information for the specified FileId.
+
+Arguments:
+
+    FileId - Supplies the file table index.
+
+    Finfo - Supplies a pointer to where the File Informatino is stored.
+
+Return Value:
+
+    If the specified file is open then this routine dispatches to the
+    File routine.
+    Otherwise, returns an unsuccessful status.
+
+--*/
+
+{
+
+    if (BlFileTable[FileId].Flags.Open == 1) {
+        return (BlFileTable[FileId].DeviceEntryTable->GetFileInformation)(FileId,
+                                                                          Finfo);
+    } else {
+        return EACCES;
+    }
+}
+
+ARC_STATUS
+FwSetFileInformation (
+    IN ULONG FileId,
+    IN ULONG AttributeFlags,
+    IN ULONG AttributeMask
+    )
+
+/*++
+
+Routine Description:
+
+    This function sets the file attributes for the specified FileId.
+
+Arguments:
+
+    FileId - Supplies the file table index.
+
+    AttributeFlags - Supply the attributes to be set for the file.
+    AttributeMask
+
+Return Value:
+
+    If the specified file is open and is not a device then this routine
+    dispatches to the file system  routine.
+    Otherwise, returns an unsuccessful status.
+
+--*/
+
+{
+
+    if ((BlFileTable[FileId].Flags.Open == 1) &&
+        (BlFileTable[FileId].DeviceId != DEVICE_DEVICE)) {
+        return (BlFileTable[FileId].DeviceEntryTable->SetFileInformation)(FileId,
+                                                                          AttributeFlags,
+                                                                          AttributeMask);
+    } else {
+        return EACCES;
+    }
+}
+
+
+ARC_STATUS
+FwMount (
+    IN PCHAR MountPath,
+    IN MOUNT_OPERATION Operation
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+
+Return Value:
+
+
+--*/
+
+{
+
+    return ESUCCESS;
+}
+
+ARC_STATUS
+FwRead (
+    IN ULONG FileId,
+    OUT PVOID Buffer,
+    IN ULONG Length,
+    OUT PULONG Count
+    )
+
+/*++
+
+Routine Description:
+
+    This function reads from a file or a device that is open.
+
+Arguments:
+
+    FileId - Supplies the file table index.
+
+    Buffer - Supplies a pointer to the buffer that receives the data
+        read.
+
+    Length - Supplies the number of bytes that are to be read.
+
+    Count - Supplies a pointer to a variable that receives the number of
+        bytes actually transfered.
+
+Return Value:
+
+    If the specified file is open for read, then a read is attempted
+    and the status of the operation is returned. Otherwise, return an
+    unsuccessful status.
+
+--*/
+
+{
+
+    //
+    // If the file is open for read, then attempt to read from it. Otherwise
+    // return an access error.
+    //
+
+    if ((BlFileTable[FileId].Flags.Open == 1) &&
+        (BlFileTable[FileId].Flags.Read == 1)) {
+        return (BlFileTable[FileId].DeviceEntryTable->Read)(FileId,
+                                                            Buffer,
+                                                            Length,
+                                                            Count);
+
+    } else {
+        return EACCES;
+    }
+}
+
+ARC_STATUS
+FwGetReadStatus (
+    IN ULONG FileId
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+
+Return Value:
+
+
+--*/
+
+{
+
+    //
+    // If the file is open for read, then call the call the specific routine.
+    // Otherwise return an access error.
+
+    if ((BlFileTable[FileId].Flags.Open == 1) &&
+        (BlFileTable[FileId].Flags.Read == 1)) {
+
+        //
+        // Make sure there is a valid GetReadStatus entry.
+        //
+
+        if (BlFileTable[FileId].DeviceEntryTable->GetReadStatus != NULL) {
+            return(BlFileTable[FileId].DeviceEntryTable->GetReadStatus)(FileId);
+        } else {
+            return(EACCES);
+        }
+
+    } else {
+        return EACCES;
+    }
+
+    return ESUCCESS;
+}
+
+ARC_STATUS
+FwSeek (
+    IN ULONG FileId,
+    IN PLARGE_INTEGER Offset,
+    IN SEEK_MODE SeekMode
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+
+Return Value:
+
+    If the specified file is open, then a seek is attempted and
+    the status of the operation is returned. Otherwise, return an
+    unsuccessful status.
+
+--*/
+
+{
+
+    //
+    // If the file is open, then attempt to seek on it. Otherwise return an
+    // access error.
+    //
+
+    if (BlFileTable[FileId].Flags.Open == 1) {
+        return (BlFileTable[FileId].DeviceEntryTable->Seek)(FileId,
+                                                            Offset,
+                                                            SeekMode);
+    } else {
+        return EACCES;
+    }
+}
+
+ARC_STATUS
+FwWrite (
+    IN ULONG FileId,
+    IN PVOID Buffer,
+    IN ULONG Length,
+    OUT PULONG Count
+    )
+
+/*++
+
+Routine Description:
+
+    This function writes to a file or a device that is open.
+
+Arguments:
+
+    FileId - Supplies the file table index.
+
+    Buffer - Supplies a pointer to the buffer that contains the data
+        to write.
+
+    Length - Supplies the number of bytes that are to be written.
+
+    Count - Supplies a pointer to a variable that receives the number of
+        bytes actually transfered.
+
+Return Value:
+
+    If the specified file is open for write, then a write is attempted
+    and the status of the operation is returned. Otherwise, return an
+    unsuccessful status.
+
+--*/
+
+{
+    //
+    // If the file is open for write, then attempt to write to it. Otherwise
+    // return an access error.
+    //
+
+    if ((BlFileTable[FileId].Flags.Open == 1) &&
+        (BlFileTable[FileId].Flags.Write == 1)) {
+        return (BlFileTable[FileId].DeviceEntryTable->Write)(FileId,
+                                                            Buffer,
+                                                            Length,
+                                                            Count);
+
+    } else {
+        return EACCES;
+    }
+}
+
+
+ARC_STATUS
+FwGetDirectoryEntry (
+    IN  ULONG FileId,
+    OUT PDIRECTORY_ENTRY Buffer,
+    IN  ULONG Length,
+    OUT PULONG Count
+    )
+
+/*++
+
+Routine Description:
+
+    This function reads from a file the requested number of directory entries.
+
+Arguments:
+
+    FileId - Supplies the file table index.
+
+    Buffer - Supplies a pointer to the buffer to receive the directory
+             entries.
+
+    Length - Supplies the number of directory entries to be read.
+
+    Count - Supplies a pointer to a variable that receives the number of
+        directory entries actually read..
+
+Return Value:
+
+    If the specified file is open for read, then a read is attempted
+    and the status of the operation is returned. Otherwise, return an
+    unsuccessful status.
+
+--*/
+{
+    //
+    //  If the file is open for read, then call the call the specific routine.
+    //  Otherwise return an access error.
+    //
+
+    if ((FileId < BL_FILE_TABLE_SIZE) &&
+        (BlFileTable[FileId].Flags.Open  == 1) &&
+        (BlFileTable[FileId].Flags.Read  == 1) &&
+        (BlFileTable[FileId].DeviceId != DEVICE_DEVICE)) {
+
+        //
+        // Check to make sure a GetDirectoryEntry routine exists
+        //
+
+        if (BlFileTable[FileId].DeviceEntryTable->GetDirectoryEntry != NULL) {
+            return (BlFileTable[FileId].DeviceEntryTable->GetDirectoryEntry)
+                         (FileId, Buffer, Length, Count);
+        }
+    } else {
+        return EBADF;
+    }
+}
+
+
+ARC_STATUS
+FwClose (
+    IN ULONG FileId
+    )
+
+/*++
+
+Routine Description:
+
+    This function closes a file or a device if it's open.
+    The DeviceId field indicates if the FileId is a device
+    (it has the value DEVICE_DEVICE) or is a file.
+    When closing a file, after the file is closed the
+    reference counter for the device is decremented and if zero
+    the device is also closed and the device name removed from
+    the table of opened devices.
+    If FileId specifies a device, the reference counter is
+    decremented and if zero the device is closed and the device
+    name removed from the table of opened devices.
+
+Arguments:
+
+    FileId - Supplies the file table index.
+
+Return Value:
+
+    If the specified file is open, then a close is attempted and
+    the status of the operation is returned. Otherwise, return an
+    unsuccessful status.
+
+--*/
+
+{
+    ULONG DeviceId;
+    ARC_STATUS Status;
+    if (BlFileTable[FileId].Flags.Open == 1) {
+        //
+        // Check if closing a file or a device
+        //
+        if (BlFileTable[FileId].DeviceId == DEVICE_DEVICE) {
+            //
+            // Decrement reference counter, if it's zero call the device
+            // close routine.
+            //
+            OpenedPathTable[FileId].ReferenceCounter--;
+            if (OpenedPathTable[FileId].ReferenceCounter == 0) {
+                //
+                // Remove the name of the device from the table of opened devices.
+                //
+                OpenedPathTable[FileId].DeviceName[0] = '\0';
+
+                //
+                // Call the device specific close routine.
+                //
+                Status = (BlFileTable[FileId].DeviceEntryTable->Close)(FileId);
+
+                //
+                //  If the device has a file system, free the memory used for
+                //  the STRUCTURE_CONTEXT.
+                //
+                if (BlFileTable[FileId].StructureContext != NULL) {
+                    FiFreeFsStructure(BlFileTable[FileId].StructureContext);
+                }
+                return Status;
+            } else {
+                return ESUCCESS;
+            }
+        } else {
+            //
+            // Close the file
+            //
+            DeviceId= BlFileTable[FileId].DeviceId;
+            Status = (BlFileTable[FileId].DeviceEntryTable->Close)(FileId);
+            if (Status) {
+                return Status;
+            }
+
+            //
+            // Close also the device
+            //
+            return FwClose(DeviceId);
+        }
+    } else {
+        return EACCES;
+    }
+}
+
+ARC_STATUS
+FwOpen (
+    IN PCHAR OpenPath,
+    IN OPEN_MODE OpenMode,
+    OUT PULONG FileId
+    )
+
+/*++
+
+Routine Description:
+
+    This function opens the file specified by OpenPath.
+    If the device portion of the pathanme is already opened, it reuses
+    the fid. Otherwise it looks for a driver able to handle this
+    device and logs the opened device so that it can be reused.
+
+Arguments:
+
+    OpenPath   -    ARC compliant pathname of the device/file to be opened.
+    OpenMode   -    Supplies the mode in wich the file is opened.
+    FileId     -    Pointer to a variable that receives the fid for this
+                    pathname.
+
+Return Value:
+
+    If the file is successfully opened returns ESUCCESS otherwise
+    returns an unsuccessfull status.
+
+--*/
+
+{
+    ULONG i;
+    ULONG DeviceId;
+    PCHAR FileName ;
+    PCHAR TempString1;
+    PCHAR TempString2;
+    ARC_STATUS Status;
+    CHAR DeviceName[80];
+    PVOID TmpStructureContext;
+    OPEN_MODE DeviceOpenMode;
+    BOOLEAN OmfProtocol;
+
+    //
+    // Split OpenPath into DeviceName and FileName.
+    // Search for the last ')'
+    //
+    FileName = OpenPath;
+    for (TempString1 = OpenPath; *TempString1; TempString1++) {
+        if ( *TempString1 == ')') {
+            FileName = TempString1+1;
+        }
+    }
+    if (FileName == OpenPath) {
+        return ENODEV;
+    }
+
+    //
+    //  Extract the device pathname, convert it to lower case and
+    //  put zeros where the "key" is not specified.
+    //
+    TempString1=DeviceName;
+    for (TempString2=OpenPath;TempString2 != FileName ;TempString2++) {
+        //
+        // If about to copy ')' and previous char was '('
+        // put a zero in between.
+        //
+        if (((*TempString2 == ')') && (*(TempString1-1)) == '(')){
+            *TempString1++ = '0';
+        }
+        *TempString1++ = tolower(*TempString2);
+    }
+    *TempString1 = '\0';
+
+    //
+    // Translate the open mode to its equivalent for devices.
+    //
+    DeviceOpenMode = OpenMode;
+
+    if (FileName[0] == '\0') {
+        //
+        // On an attempt to open a device with an invalid OpenMode
+        // return an error.
+        //
+        if (OpenMode > ArcOpenReadWrite) {
+            return EINVAL;
+        }
+    } else {
+
+        //
+        // A file is being open, set the right Open Mode for the device.
+        //
+        if (OpenMode > ArcOpenReadOnly)  {
+            DeviceOpenMode = ArcOpenReadWrite;
+        }
+    }
+
+    //
+    // Check for OMF protocol.
+    //
+
+    if ( strstr(DeviceName, ")omf(0)" ) != NULL ) {
+        OmfProtocol = TRUE;
+    } else {
+        OmfProtocol = FALSE;
+    }
+
+    //
+    // Search for a matching entry in the table of opened devices.
+    //
+    for (DeviceId = 0;DeviceId < SIZE_OF_OPENED_PATHNAME_TABLE;DeviceId++) {
+        if (strcmp(DeviceName,OpenedPathTable[DeviceId].DeviceName)==0) {
+            //
+            // device already opened. Check that it's also opened in
+            // the same mode.
+            //
+            if ((DeviceOpenMode != ArcOpenWriteOnly) && (BlFileTable[DeviceId].Flags.Read != 1)) {
+                continue;
+            }
+            if ((DeviceOpenMode != ArcOpenReadOnly) && (BlFileTable[DeviceId].Flags.Write != 1)) {
+                continue;
+            }
+            //
+            // If opened for the same Mode then just increment reference counter.
+            //
+            OpenedPathTable[DeviceId].ReferenceCounter++;
+            Status = ESUCCESS;
+            break;
+        }
+    }
+    if (DeviceId == SIZE_OF_OPENED_PATHNAME_TABLE) {
+
+        //
+        // Device not opened. Look for a driver that handles this device.
+        //
+
+        if ( OmfProtocol ) {
+
+            //
+            //  omf protocol, let the omf software layer validate the path.
+            //  Get a free entry in the file table for the device.
+            //
+
+            if ( Status = FiGetFileTableEntry( &DeviceId ) ) {
+                return Status;
+            }
+
+            BlFileTable[DeviceId].DeviceEntryTable = &OmfEntryTable;
+
+        } else {
+
+            for (i=0;i < SIZE_OF_LOOKUP_TABLE; i++) {
+                if (DeviceLookupTable[i].DevicePath == NULL) {
+
+                    //
+                    // Driver not found
+                    //
+
+                    return ENODEV;
+                }
+                if (strstr(DeviceName,DeviceLookupTable[i].DevicePath) == DeviceName) {
+
+                    //
+                    // Get a free entry in the file table for the device.
+                    //
+
+                    if (Status = FiGetFileTableEntry(&DeviceId)) {
+                        return Status;
+                    }
+
+                    //
+                    // Set the dispatch table in the file table.
+                    //
+
+                    BlFileTable[DeviceId].DeviceEntryTable = DeviceLookupTable[i].DispatchTable;
+                    break;
+                }
+            }
+
+            //
+            //  if end of table, drive not found
+            //
+
+            if ( i == SIZE_OF_LOOKUP_TABLE )
+            {
+                return ENODEV;
+            }
+        }
+
+        //
+        // Call the device specific open routine.  Use the DeviceName instead of
+        // the OpenPath so that the drivers always see a lowercase name.
+        //
+
+        Status = (BlFileTable[DeviceId].DeviceEntryTable->Open)(DeviceName,
+                                                                DeviceOpenMode,
+                                                                &DeviceId);
+        if (Status != ESUCCESS) {
+            return Status;
+        }
+
+        //
+        // if the device was successfully opened. Log this device name
+        // and initialize the file table.
+        //
+
+        strcpy(OpenedPathTable[DeviceId].DeviceName,DeviceName);
+        OpenedPathTable[DeviceId].ReferenceCounter =  1;
+
+        //
+        // Set flags in file table.
+        //
+
+        BlFileTable[DeviceId].Flags.Open = 1;
+
+        if (DeviceOpenMode != ArcOpenWriteOnly) {
+            BlFileTable[DeviceId].Flags.Read = 1;
+        }
+        if (DeviceOpenMode != ArcOpenReadOnly) {
+            BlFileTable[DeviceId].Flags.Write = 1;
+        }
+
+        //
+        // Mark this entry in the file table as a device itself.
+        //
+
+        BlFileTable[DeviceId].DeviceId = DEVICE_DEVICE;
+        BlFileTable[DeviceId].StructureContext = NULL;
+    }
+
+    //
+    // If we get here the device was successfully open and DeviceId contains
+    // the entry in the file table for this device.
+    //
+
+    if (FileName[0]) {
+
+        //
+        // Get an entry for the file.
+        //
+
+        if (Status=FiGetFileTableEntry(FileId)) {
+            FwClose( DeviceId );
+            return Status;
+
+        //
+        // check if "omf" file system
+        //
+
+        } else if ( OmfProtocol ) {
+            BlFileTable[ *FileId ].DeviceEntryTable = &OmfFileEntryTable;
+
+        //
+        // Check if the device has a recognized file system on it.  If not
+        // present, allocate a structure context.
+        //
+
+        } else if (((TmpStructureContext = BlFileTable[DeviceId].StructureContext) == NULL) &&
+                   ((TmpStructureContext = FiAllocateFsStructure()) == NULL)) {
+            FwClose( DeviceId );
+            return EMFILE;
+
+        //
+        // Check for FAT filesystem.
+        //
+
+        } else if ((BlFileTable[*FileId].DeviceEntryTable =
+                    IsFatFileStructure(DeviceId,TmpStructureContext))
+                       != NULL) {
+            BlFileTable[DeviceId].StructureContext = TmpStructureContext;
+
+        //
+        // Check for CD filesystem.
+        //
+
+        } else if ((BlFileTable[*FileId].DeviceEntryTable =
+                    IsCdfsFileStructure(DeviceId,TmpStructureContext))
+                       != NULL) {
+            BlFileTable[DeviceId].StructureContext = TmpStructureContext;
+
+        } else {
+
+            FiFreeFsStructure(TmpStructureContext);
+            FwClose(DeviceId);
+            FwPrint(FW_FILESYSTEM_NOT_REQ_MSG);
+            return EIO;
+        }
+
+        //
+        //  Set the DeviceId in the file table.
+        //
+
+        BlFileTable[*FileId].DeviceId = DeviceId;
+
+        //
+        // Copy the pointer to FatStructureContext from the device entry
+        // to the file entry.
+        //
+
+        BlFileTable[*FileId].StructureContext = BlFileTable[DeviceId].StructureContext;
+        Status = (BlFileTable[*FileId].DeviceEntryTable->Open)(FileName,
+                                                               OpenMode,
+                                                               FileId);
+
+
+        //
+        // If the file could not be opened. Then close the device and
+        // return the error
+        //
+
+        if (Status != ESUCCESS) {
+            FiFreeFsStructure(TmpStructureContext);
+            FwClose(DeviceId);
+            return Status;
+        }
+    } else {
+
+        //
+        //  No file specified return the fid for the device.
+        //
+        *FileId = DeviceId;
+        return Status;
+    }
+}
+
+ARC_STATUS
+FiGetFileTableEntry(
+    OUT PULONG  Entry
+    )
+
+/*++
+
+Routine Description:
+
+    This function looks for an unused entry in the FileTable.
+
+Arguments:
+
+    Entry - Pointer to the variable that gets an index for the file table.
+
+Return Value:
+
+    Returns ESUCCESS if a free entry is found
+    or      EMFILE  if no entry is available.
+
+--*/
+
+{
+    ULONG   Index;
+    for (Index=0;Index < BL_FILE_TABLE_SIZE;Index++) {
+        if (BlFileTable[Index].Flags.Open == 0) {
+            *Entry = Index;
+            return ESUCCESS;
+        }
+    }
+    return EMFILE;
+}
+ULONG
+FiGetFreeLookupEntry (
+    VOID
+    )
+
+/*++
+
+Routine Description:
+
+    This routine looks for the first available entry in the device
+    lookup table, that is the entry where DevicePath is NULL.
+
+Arguments:
+
+    None.
+
+Return Value:
+
+    Returns the Index of the first free entry of the DeviceLookupTable
+    or SIZE_OF_LOOKUP_TABLE is the table is full.
+
+
+--*/
+
+{
+ULONG  Index;
+    //
+    // Search for the first free entry in the Lookup table
+    //
+    for (Index=0;Index < SIZE_OF_LOOKUP_TABLE;Index++) {
+        if (DeviceLookupTable[Index].DevicePath == NULL) {
+            break;
+        }
+    }
+    return Index;
+}
+
+VOID
+FwIoInitialize1(
+    VOID
+    )
+
+/*++
+
+Routine Description:
+
+    This routine initializes the file table used by the firmware to
+    export I/O functions to client programs loaded from the system
+    partition, initializes the I/O entry points in the firmware
+    transfer vector and initializes the display driver.
+
+    Note: This routine is caleld at phase 1 initialization.
+
+Arguments:
+
+    None.
+
+Return Value:
+
+    None.
+
+--*/
+
+{
+
+    ULONG Index;
+    //
+    // Initialize the I/O entry points in the firmware transfer vector.
+    //
+
+    (PARC_CLOSE_ROUTINE)SYSTEM_BLOCK->FirmwareVector[CloseRoutine] = FwClose;
+    (PARC_MOUNT_ROUTINE)SYSTEM_BLOCK->FirmwareVector[MountRoutine] = FwMount;
+    (PARC_OPEN_ROUTINE)SYSTEM_BLOCK->FirmwareVector[OpenRoutine] = FwOpen;
+    (PARC_READ_ROUTINE)SYSTEM_BLOCK->FirmwareVector[ReadRoutine] = FwRead;
+    (PARC_READ_STATUS_ROUTINE)SYSTEM_BLOCK->FirmwareVector[ReadStatusRoutine] =
+                                                                FwGetReadStatus;
+    (PARC_SEEK_ROUTINE)SYSTEM_BLOCK->FirmwareVector[SeekRoutine] = FwSeek;
+    (PARC_WRITE_ROUTINE)SYSTEM_BLOCK->FirmwareVector[WriteRoutine] = FwWrite;
+    (PARC_GET_FILE_INFO_ROUTINE)SYSTEM_BLOCK->FirmwareVector[GetFileInformationRoutine] = FwGetFileInformation;
+    (PARC_SET_FILE_INFO_ROUTINE)SYSTEM_BLOCK->FirmwareVector[SetFileInformationRoutine] = FwSetFileInformation;
+    (PARC_GET_DIRECTORY_ENTRY_ROUTINE)SYSTEM_BLOCK->FirmwareVector[GetDirectoryEntryRoutine] = FwGetDirectoryEntry;
+
+    //
+    // Initialize the file table.
+    //
+
+    for (Index = 0; Index < BL_FILE_TABLE_SIZE; Index += 1) {
+        BlFileTable[Index].Flags.Open = 0;
+    }
+
+    //
+    // Initialize the driver lookup table.
+    //
+    for (Index=0;Index < SIZE_OF_LOOKUP_TABLE;Index++) {
+        DeviceLookupTable[Index].DevicePath = NULL;
+    }
+
+    //
+    // Initialize the table of opened devices.
+    //
+    for (Index = 0;Index < SIZE_OF_OPENED_PATHNAME_TABLE;Index++) {
+        OpenedPathTable[Index].DeviceName[0]='\0';
+    }
+
+    //
+    // Call the Display driver initialization routine
+    //
+    DisplayInitialize(&DeviceLookupTable[0],
+                      SIZE_OF_LOOKUP_TABLE);
+    return;
+}
+
+VOID
+FwIoInitialize2(
+    VOID
+    )
+
+/*++
+
+Routine Description:
+
+    This routine calls the device driver initialization routines.
+
+Arguments:
+
+    None.
+
+Return Value:
+
+    None.
+
+--*/
+{
+    ULONG Index;
+
+    //
+    // Call the Keyboard driver initialization routine
+    //
+    if ((Index=FiGetFreeLookupEntry()) == SIZE_OF_LOOKUP_TABLE) {
+        FwPrint(FW_NOT_ENOUGH_ENTRIES_MSG);
+    } else {
+        KeyboardInitialize(&DeviceLookupTable[Index],
+                           SIZE_OF_LOOKUP_TABLE-Index);
+    }
+
+#ifndef DUO
+    //
+    // Look for first free entry and call
+    // floppy driver initialization routine
+    //
+    if ((Index=FiGetFreeLookupEntry()) == SIZE_OF_LOOKUP_TABLE) {
+        FwPrint(FW_NOT_ENOUGH_ENTRIES_MSG);
+    } else {
+        FloppyInitialize(&DeviceLookupTable[Index],
+                         SIZE_OF_LOOKUP_TABLE-Index);
+    }
+
+#endif
+
+    //
+    // Call the mini-port driver initialization routine.
+    //
+
+    DriverEntry(NULL);
+
+    //
+    // Call the scsi driver initialization routine
+    //
+    if ((Index=FiGetFreeLookupEntry()) == SIZE_OF_LOOKUP_TABLE) {
+        FwPrint(FW_NOT_ENOUGH_ENTRIES_MSG);
+    } else {
+        HardDiskInitialize(&DeviceLookupTable[Index],
+                          SIZE_OF_LOOKUP_TABLE-Index);
+    }
+
+    //
+    // Call the serial port driver initialization routine
+    //
+    if ((Index=FiGetFreeLookupEntry()) == SIZE_OF_LOOKUP_TABLE) {
+        FwPrint(FW_NOT_ENOUGH_ENTRIES_MSG);
+    } else {
+        SerialInitialize(&DeviceLookupTable[Index],
+                           SIZE_OF_LOOKUP_TABLE-Index);
+    }
+
+    //
+    // Pre allocate memory for the File system structures.
+    //
+
+    FileSystemStructurePool =
+        FwAllocatePool(sizeof(FS_POOL_ENTRY) * FS_POOL_SIZE);
+
+    return;
+}
+
+PVOID
+FiAllocateFsStructure(
+    VOID
+    )
+
+/*++
+
+Routine Description:
+
+    This routine allocates a File System structure
+
+Arguments:
+
+    None.
+
+Return Value:
+
+    Returns a pointer to the Allocated File System structure or NULL.
+
+--*/
+
+{
+
+    PFS_POOL_ENTRY TmpPointer,Last;
+
+    TmpPointer =  FileSystemStructurePool;
+
+    Last = FileSystemStructurePool+FS_POOL_SIZE;
+    do {
+        if (TmpPointer->InUse == FALSE) {
+            TmpPointer->InUse = TRUE;
+            return &TmpPointer->Fs;
+        }
+        TmpPointer++;
+    } while (TmpPointer != Last);
+    return NULL;
+}
+VOID
+FiFreeFsStructure(
+    IN PFILE_SYSTEM_STRUCTURE PFs
+    )
+
+/*++
+
+Routine Description:
+
+    This routine frees a File System structure previously allocated.
+
+Arguments:
+
+    PFs pointer to the file system structure to free.
+
+Return Value:
+
+    None.
+
+--*/
+
+{
+    CONTAINING_RECORD(PFs, FS_POOL_ENTRY, Fs)->InUse = FALSE;
+    return;
+}