windows-nt-4.0/private/ntos/fw/mips/eisaini.c

// ----------------------------------------------------------------------------
// Copyright (c) 1992 Olivetti
//
// File:            eisaini.c
//
// Description:     EISA initialization routines.
// ----------------------------------------------------------------------------
//

#include "fwp.h"
#include "oli2msft.h"
#include "arceisa.h"
#include "inc.h"
#include "string.h"
#include "debug.h"
#include "eisastr.h"


//extern BL_DEVICE_ENTRY_TABLE OmfEntryTable[];

// NOTE: Not used in JAZZ.
//extern ULONG    ErrorWord;                      // POD error flags
//extern ULONG    FlagWord;                       // system flags
extern ULONG    MemorySize;                     // size of memory in Mb

extern PCHAR    MnemonicTable[];

extern ULONG    EisaPoolSize;                   // # bytes really used
extern ULONG    EisaDynMemSize;                 // dynamic memory size (bytes)
extern ULONG    EisaFreeTop;                    // top of free mem
extern ULONG    EisaFreeBytes;                  // free bytes left



// remove the following function prototypes when using common code

PFW_MD
GetFwMd
    (
    VOID
    );

PFW_MD
LinkPhysFwMd
    (
    PFW_MD * pFwMdBase,
    PFW_MD   pFwMd
    );





// ----------------------------------------------------------------------------
//  Declare Function Prototypes
// ----------------------------------------------------------------------------


VOID
EisaIni
    (
    VOID
    );

VOID
EisaGeneralIni
    (
    VOID
    );

BOOLEAN
EisaBusStructIni
    (
    IN ULONG    BusNumber
    );

BOOLEAN
EisaCheckAdapterComponent
    (
    IN  ULONG                     BusNumber,
    OUT PCONFIGURATION_COMPONENT *pEisaComp
    );

BOOLEAN
EisaBusPod
    (
    IN ULONG    BusNumber
    );

BOOLEAN
EisaPortIni
    (
    IN PUCHAR   EisaIoStart
    );

BOOLEAN
EisaIntIni
    (
    IN PUCHAR           EisaIoStart,
    IN PEISA_INT_INFO   pIntInfo
    );

BOOLEAN
EisaDmaIni
    (
    IN PUCHAR           EisaIoStart,
    IN PEISA_DMA_INFO   pDmaInfo
    );

BOOLEAN
EisaBusCfg
    (
    IN PCONFIGURATION_COMPONENT EisaComponent
    );

BOOLEAN
EisaPhysSlotCfg
    (
    IN ULONG    BusNumber,
    IN PCONFIGURATION_COMPONENT Controller,
    IN ULONG    AdapId
    );

BOOLEAN
EisaVirSlotCfg
    (
    IN ULONG    BusNumber,
    IN PCONFIGURATION_COMPONENT Controller
    );

BOOLEAN
EisaSlotCfg
    (
    IN ULONG    BusNumber,
    IN PCONFIGURATION_COMPONENT Controller,
    IN UCHAR    FunctionsNumber
    );

BOOLEAN
EisaSlotCfgMem
    (
    IN ULONG    BusNumber,
    IN ULONG    SlotNumber,
    IN PUCHAR   EisaFuncInfo
    );

BOOLEAN
EisaSlotCfgIrq
    (
    IN PUCHAR           EisaIoStart,
    IN PEISA_INT_INFO   pIntInfo,
    IN PUCHAR           EisaFuncInfo
    );

BOOLEAN
EisaSlotCfgDma
    (
    IN PUCHAR           EisaIoStart,
    IN PEISA_DMA_INFO   pDmaInfo,
    IN PUCHAR           EisaFuncInfo
    );

BOOLEAN
EisaSlotCfgIni
    (
    IN PUCHAR    EisaIoStart,
    IN PUCHAR    EisaFuncInfo,
    OUT PBOOLEAN EnabAdapter
    );

VOID
EisaSlotErrorLog
    (
    IN ULONG            BusNumber,
    IN ULONG            SlotNumber,
    IN EISA_CFG_ERROR   ErrorCode
    );

VOID
EisaPathErrorLog
    (
    IN PCONFIGURATION_COMPONENT Controller,
    IN EISA_CFG_ERROR           ErrorCode
    );

VOID
EisaStrErrorLog
    (
    IN PCHAR            Str,
    IN EISA_CFG_ERROR   ErrorCode
    );

VOID
EisaCheckpointFirstFase
    (
    IN EISA_CHECKPOINT  Chk
    );

BOOLEAN
EisaCheckpointFinalFase
    (
    IN EISA_CHECKPOINT  Chk,
    IN BOOLEAN          Passed
    );

BOOLEAN
EisaReadReadyId
    (
    IN PUCHAR EisaIoStart,
    IN ULONG SlotNumber,
    OUT PULONG AdapId
    );

VOID
EisaReadId
    (
    IN PUCHAR EisaIoStart,
    IN ULONG SlotNumber,
    OUT PULONG AdapId
    );

BOOLEAN
EisaMemIni
    (
    VOID
    );

VOID
EisaDynMemIni
    (
    VOID
    );

PCONFIGURATION_COMPONENT
FwGetChild
    (
    IN PCONFIGURATION_COMPONENT Component OPTIONAL
    );

PCONFIGURATION_COMPONENT
FwGetPeer
    (
    IN PCONFIGURATION_COMPONENT Component
    );

PCONFIGURATION_COMPONENT
FwAddChild
    (
    IN PCONFIGURATION_COMPONENT Component,
    IN PCONFIGURATION_COMPONENT NewComponent,
    IN PVOID ConfigurationData OPTIONAL
    );

PCONFIGURATION_COMPONENT
FwGetComponent
    (
    IN PCHAR Pathname
    );

PCONFIGURATION_COMPONENT
FwGetParent
    (
    IN PCONFIGURATION_COMPONENT Component
    );

VOID
FwStallExecution
    (
    IN ULONG Seconds
    );

ARC_STATUS
AllocateMemoryResources
    (
    IN OUT PFW_MD       pBuffFwMd
    );


// ----------------------------------------------------------------------------
//  Declare General Function Prototypes
// ----------------------------------------------------------------------------

PCHAR
FwToUpperStr
    (
    IN OUT PCHAR s
    );

PCHAR
FwToLowerStr
    (
    IN OUT PCHAR s
    );

PCHAR
FwGetPath
    (
    IN PCONFIGURATION_COMPONENT Component,
    OUT PCHAR String
    );

VOID
FwDelCfgTreeNode
    (
    IN PCONFIGURATION_COMPONENT pComp,
    IN BOOLEAN                  Peer
    );

PCHAR
FwGetMnemonic
    (
    IN PCONFIGURATION_COMPONENT Component
    );

BOOLEAN
FwValidMnem
    (
    IN PCHAR Str
    );

ULONG
Fw2UcharToUlongLSB
    (
    IN PUCHAR String
    );

ULONG
Fw3UcharToUlongLSB
    (
    IN PUCHAR String
    );

ULONG
Fw4UcharToUlongLSB
    (
    IN PUCHAR String
    );

ULONG
Fw4UcharToUlongMSB
    (
    IN PUCHAR String
    );

PCHAR
FwStoreStr
    (
    IN PCHAR Str
    );


// ----------------------------------------------------------------------------
// GLOBAL:      EISA configuration variables
// ----------------------------------------------------------------------------


// EISA buses info

EISA_BUS_INFO EisaBusInfo[ EISA_BUSES ];        // eisa bus info pointers

// descriptor pointers

PFW_MD  LogFwMdBase = NULL;             // starting logical descriptors pointer
PFW_MD  VirFwMdBase = NULL;             // starting virtual descriptors pointer
PFW_MD  pFwMdPool;                      // descriptors pool





// ----------------------------------------------------------------------------
// PROCEDURE:           EisaIni:
//
// DESCRIPTION:         This function does the eisa controller configuration.
//
// ARGUMENTS:           none
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:             ErrorWord
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
EisaIni
    (
    VOID
    )
{
    // define local variables

    PCONFIGURATION_COMPONENT pEisaComp;         // eisa bus component
    CHAR    EisaMnemonic[MAX_MNEMONIC_LEN +1];  // to hold the eisa path
    ULONG   EisaBus;                            // eisa bus number
    BOOLEAN IniOk;                              // EISA configuration bus status

    PRINTDBG("EisaIni\n\r");                    // DEBUG SUPPORT

    //
    // perform any general initialization
    //

    EisaGeneralIni();

// NOTE: EisaMemIni not used on JAZZ.
//    if ( !EisaMemIni() )
//    {
//        EisaStrErrorLog("EISA Initialization", MemAllocError);
//        return;
//    }

    //
    // initialize and configure the eisa buses (one per loop)
    //

    for ( EisaBus = 0;  EisaBus < EISA_BUSES;  EisaBus++ )
    {
        //
        // display message
        //

        FwPrint(EISA_INIT_MSG, EisaBus);

        //
        // eisa bus structures initialization
        //

        if ( !EisaBusStructIni( EisaBus ))
        {
            EisaStrErrorLog( EISA_BUS_MSG, MemAllocError);
            return;
        }

        //
        // eisa bus hardware test and initialization
        //

        if ( EisaBusInfo[ EisaBus ].Flags.Error = !EisaBusPod( EisaBus ))
        {
//            ErrorWord |= E_HARDWARE_ERROR;
        }

        //
        // check the EISA adapter component
        //

        IniOk = TRUE;
        EisaCheckpointFirstFase( EisaCfg );
        if ( !EisaCheckAdapterComponent( EisaBus, &pEisaComp ))
        {
                IniOk = FALSE;
	}

	//
	// Return if no EISA information available.
	//

	if (pEisaComp == NULL) {
	    return;
	}

        //
        // configure the bus if no hardware errors and configuration jumper not
        // present.
        //

// NOTE: FlagWord is not used in JAZZ.
//        if (!EisaBusInfo[EisaBus].Flags.Error && !(FlagWord & F_CONFIG_JUMPER))
        if (!EisaBusInfo[EisaBus].Flags.Error)
        {
            if ( !EisaBusCfg( pEisaComp ))
            {
                IniOk = FALSE;
            }
        }
        EisaCheckpointFinalFase( EisaCfg, IniOk );

        if ( IniOk != TRUE )
        {
// NOTE: Not used in JAZZ.
//            ErrorWord |= E_CONFIG_ERROR;
        }

        //
        // store the POD initialization status
        //

        EisaBusInfo[ EisaBus ].Flags.IniDone    = 1;
        pEisaComp->Flags.Failed = EisaBusInfo[ EisaBus ].Flags.Error;

        if (IniOk == TRUE) {
            FwPrint(EISA_OK_MSG);
            FwStallExecution(500000);
        }
        FwPrint(EISA_CRLF_MSG);
    }

    //
    // Big Endian initialization
    //

// NOTE: BigEndian is not used on JAZZ.
//    BiEndianIni();

    //
    // EISA dynamic memory initializzation
    //

// NOTE: EisaDynMemIni not used on JAZZ.
//    EisaDynMemIni();

    //
    // OMF initialization:  final phase
    //

// NOTE: EisaOmfIni not used on JAZZ.
//    EisaOmfIni();

    //
    // Write out the hardware id, JAZZ only.  The first page of the EISA
    // I/O control space is actually translated into a page of memory, where
    // the hardware ID is stored.
    //

    *(PUCHAR)(EISA_EXTERNAL_IO_VIRTUAL_BASE + 0x0c80) = (('J' - 'A' + 1) << 2) +
                                                        (('A' - 'A' + 1) >> 3);
    *(PUCHAR)(EISA_EXTERNAL_IO_VIRTUAL_BASE + 0x0c81) = (('A' - 'A' + 1) << 5) +
                                                         ('Z' - 'A' + 1);
    *(PUCHAR)(EISA_EXTERNAL_IO_VIRTUAL_BASE + 0x0c82) = 0;
    *(PUCHAR)(EISA_EXTERNAL_IO_VIRTUAL_BASE + 0x0c83) = 0;

    //
    // all done
    //

    return;
}






// ----------------------------------------------------------------------------
// PROCEDURE:           EisaGeneralIni:
//
// DESCRIPTION:         This function performs general initialization
//                      for the EISA buses.
//
// ARGUMENTS:           none
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
EisaGeneralIni
    (
    VOID
    )
{
    PRINTDBG("EisaGeneralIni\n\r");             // DEBUG SUPPORT

    //
    // update system parameter block
    //

    SYSTEM_BLOCK->AdapterCount      = 1;

    SYSTEM_BLOCK->Adapter0Type      = EisaAdapter;

    SYSTEM_BLOCK->Adapter0Length    = (ULONG)MaximumEisaRoutine * sizeof(ULONG);

    SYSTEM_BLOCK->Adapter0Vector    = (PVOID)(SYSTEM_BLOCK->VendorVector +
                                              SYSTEM_BLOCK->VendorVectorLength);

    //
    // initialize EISA call back vectors
    //

    (PEISA_PROCESS_EOI_RTN)SYSTEM_BLOCK->Adapter0Vector
    [ProcessEOIRoutine] = EisaProcessEndOfInterrupt;
//    [ProcessEOIRoutine] = FwpReservedRoutine;

    (PEISA_TEST_INT_RTN)SYSTEM_BLOCK->Adapter0Vector
    [TestIntRoutine] = EisaTestEisaInterrupt;
//    [TestIntRoutine] = FwpReservedRoutine;

    (PEISA_REQ_DMA_XFER_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [RequestDMARoutine] = EisaRequestEisaDmaTransfer;
    [RequestDMARoutine] = FwpReservedRoutine;

    (PEISA_ABORT_DMA_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [AbortDMARoutine] = EisaAbortEisaDmaTransfer;
    [AbortDMARoutine] = FwpReservedRoutine;

    (PEISA_DMA_XFER_STATUS_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [GetDMAStatusRoutine] = EisaGetEisaDmaTransferStatus;
    [GetDMAStatusRoutine] = FwpReservedRoutine;

    (PEISA_LOCK_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [DoLockRoutine] = EisaDoLockedOperation;
    [DoLockRoutine] = FwpReservedRoutine;

    (PEISA_REQUEST_BUS_MASTER_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [RequestBusMasterRoutine] = EisaRequestEisaBusMasterTransfer;
    [RequestBusMasterRoutine] = FwpReservedRoutine;

    (PEISA_RELEASE_BUS_MASTER_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [ReleaseBusMasterRoutine] = EisaReleaseEisaBusMasterTransfer;
    [ReleaseBusMasterRoutine] = FwpReservedRoutine;

    (PEISA_REQUEST_CPU_TO_BUS_ACCESS_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [RequestCpuAccessToBusRoutine] = EisaRequestCpuAccessToEisaBus;
    [RequestCpuAccessToBusRoutine] = FwpReservedRoutine;

    (PEISA_RELEASE_CPU_TO_BUS_ACCESS_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [ReleaseCpuAccessToBusRoutine] = EisaReleaseCpuAccessToEisaBus;
    [ReleaseCpuAccessToBusRoutine] = FwpReservedRoutine;

    (PEISA_FLUSH_CACHE_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [FlushCacheRoutine] = EisaFlushCache;
    [FlushCacheRoutine] = FwpReservedRoutine;

    (PEISA_INVALIDATE_CACHE_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [InvalidateCacheRoutine] = EisaInvalidateCache;
    [InvalidateCacheRoutine] = FwpReservedRoutine;

    (PEISA_BEGIN_CRITICAL_SECTION_RTN)SYSTEM_BLOCK->Adapter0Vector
    [BeginCriticalSectionRoutine] = EisaBeginCriticalSection;
//    [BeginCriticalSectionRoutine] = FwpReservedRoutine;

    (PEISA_RESERVED_RTN)SYSTEM_BLOCK->Adapter0Vector
    [ReservedRoutine] = NULL;

    (PEISA_END_CRITICAL_SECTION_RTN)SYSTEM_BLOCK->Adapter0Vector
    [EndCriticalSectionRoutine] = EisaEndCriticalSection;
//    [EndCriticalSectionRoutine] = FwpReservedRoutine;

    (PEISA_GENERATE_TONE_RTN)SYSTEM_BLOCK->Adapter0Vector
    [GenerateToneRoutine] = EisaGenerateTone;

    (PEISA_FLUSH_WRITE_BUFFER_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [FlushWriteBuffersRoutine] = EisaFlushWriteBuffers;
    [FlushWriteBuffersRoutine] = FwpReservedRoutine;

    (PEISA_YIELD_RTN)SYSTEM_BLOCK->Adapter0Vector
//    [YieldRoutine] = EisaYield;
    [YieldRoutine] = FwpReservedRoutine;

    (PEISA_STALL_PROCESSOR_RTN)SYSTEM_BLOCK->Adapter0Vector
    [StallProcessorRoutine] = FwStallExecution;

    //
    // all done
    //

    return;
}








// ----------------------------------------------------------------------------
// PROCEDURE:           EisaBusStructIni:
//
// DESCRIPTION:         This function builds all the required structures
//                      for the specified EISA bus.
//
// ARGUMENTS:           BusNumber       EISA bus number
//
// RETURN:              TRUE            All done
//                      FALSE           Error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:               This routine is hardware design dependent.
//
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaBusStructIni
    (
    IN ULONG BusNumber
    )
{

    //
    // define local variables
    //

    PVOID               pInfo;                  // General pointer
    PEISA_BUS_INFO      pBusInfo;               // EISA bus info pointer
    PFW_MD              pIoBusInfo;             // I/O info pointer
    PFW_MD              pMemBusInfo;            // Memory info pointer
    PEISA_SLOTS_INFO    pSlotsInfo;             // Slots info pointer
    PEISA_DMA_INFO      pDmaInfo;               // DMA info pointer
    PEISA_INT_INFO      pIntInfo;               // INT info pointer
    PEISA_PORT_INFO     pPortInfo;              // port info pointer
    ULONG               Index;                  // general index

    PRINTDBG("EisaBusStructIni\n\r");           // DEBUG SUPPORT

    //
    // initialize variables
    //

    pBusInfo = &EisaBusInfo[ BusNumber ];
    pBusInfo->Flags.IniDone = 0;

    //
    // first EISA bus
    //

    if ( BusNumber == 0 )
    {
        //
        // perform any info structure initialization
        //

        if ((pInfo = (PVOID)FwAllocatePool( sizeof( FW_MD ) +
                                            sizeof( FW_MD ) +
                                            sizeof( EISA_SLOTS_INFO ) +
                                            sizeof( EISA_DMA_INFO ) +
                                            sizeof( EISA_INT_INFO ))) == NULL )
        {
            return FALSE;
        }


        //
        // I/O bus info initialization
        //

        pBusInfo->IoBusInfo = pIoBusInfo = (PFW_MD)pInfo;

        // set link and flags

        pIoBusInfo->Link                = NULL;
        pIoBusInfo->Flags.Busy          = 1;
        pIoBusInfo->Counter             = 1;

        // set window size in 4k units

        pIoBusInfo->PhysAddr            = EISA_IO_PHYSICAL_BASE/PAGE_SIZE;
        pIoBusInfo->PagOffs             = 0;
        pIoBusInfo->VirAddr             = (PVOID)EISA_EXTERNAL_IO_VIRTUAL_BASE;
        pIoBusInfo->Size                = 64 * 1024;
        pIoBusInfo->PagNumb             = 64/4;

        ((PFW_MD)pInfo)++;


        //
        // memory bus info initialization
        //

        pBusInfo->MemBusInfo = pMemBusInfo      = (PFW_MD)pInfo;

        // set link and flags

        pMemBusInfo->Link               = NULL;
        pMemBusInfo->Flags.Busy         = 0;  // window busy flag
        pMemBusInfo->Counter            = 0;

#ifdef  KPW4010

        // set size of window in 4k units

        pMemBusInfo->PhysAddr           = EISA_MEM_PHYSBASE_KPW4010; // #4kpages
        pMemBusInfo->PagOffs            = 0;
        pMemBusInfo->VirAddr            = (PVOID)EISA_VIR_MEM;
        pMemBusInfo->Size               = 0;                         // 4 Gbytes
        pMemBusInfo->PagNumb            = PAGES_IN_4G;

        //
        // Because the EISA memory space in some designs can reach
        // 4Gbytes of length, it is not possible to map the entire area.
        // The allocation of the TLB entries for this space is done at
        // run time using the general calls to the TLB services.
        //

        pMemBusInfo->u.em.WinRelAddr     = 0;
        pMemBusInfo->u.em.WinRelAddrCtrl = NULL;
        pMemBusInfo->u.em.WinShift       = PAGE_4G_SHIFT;

#else // KPW 4000

        // set size of window in 4k units

        pMemBusInfo->PhysAddr           = EISA_MEMORY_PHYSICAL_BASE/PAGE_SIZE;
        pMemBusInfo->PagOffs            = 0;
        pMemBusInfo->VirAddr            = (PVOID)EISA_MEMORY_VIRTUAL_BASE;
        pMemBusInfo->Size               = PAGE_16M_SIZE;
        pMemBusInfo->PagNumb            = PAGE_16M_SIZE/PAGE_SIZE;

        //
        // Because the EISA memory space in some designs can reach
        // 4Gbytes of length, it is not possible to map the entire area.
        // The allocation of the TLB entries for this space is done at
        // run time using the general calls to the TLB services.
        //

        pMemBusInfo->u.em.WinRelAddr     = 0;
        pMemBusInfo->u.em.WinRelAddrCtrl = (PVOID)EISA_LATCH_VIRTUAL_BASE;
        pMemBusInfo->u.em.WinShift       = PAGE_16M_SHIFT;

#endif

        ((PFW_MD)pInfo)++;


        //
        // slot info initialization
        //

        pBusInfo->SlotsInfo = pSlotsInfo        = (PEISA_SLOTS_INFO)pInfo;
        pSlotsInfo->PhysSlots = PHYS_0_SLOTS;
        pSlotsInfo->VirSlots = VIR_0_SLOTS;
        ((PEISA_SLOTS_INFO)pInfo)++;


        //
        // DMA info initialization
        //

        pBusInfo->DmaInfo       = pDmaInfo      = (PEISA_DMA_INFO)pInfo;
        pDmaInfo->Flags.IniDone = 0;
        ((PEISA_DMA_INFO)pInfo)++;


        //
        // PIC info initialization
        //

        pBusInfo->IntInfo       = pIntInfo      = (PEISA_INT_INFO)pInfo;
        pIntInfo->Flags.IniDone = 0;
        ((PEISA_INT_INFO)pInfo)++;


        //
        // port info initialization
        //

        pBusInfo->PortInfo      = pPortInfo     = (PEISA_PORT_INFO)pInfo;
        pPortInfo->Flags.IniDone = 0;

    }
    else
    {
        //
        // invalid bus number
        //

        return FALSE;
    }

    //
    // all done
    //

    return TRUE;
}








// ----------------------------------------------------------------------------
// PROCEDURE:           EisaCheckAdapterComponent:
//
// DESCRIPTION:         This function makes sure that there is an EISA adapter
//                      component with the correct configuration data for the
//                      specified EISA bus number.  The routine uses the
//                      following logic :
//
//                      if !(ARC component present)
//                      {
//                          add ARC component;
//                      }
//                      if (EISA bus component present)
//                      {
//                         if !(configuration data correct)
//                         {
//                              display error message;
//                              delete EISA bus node;
//                              add EISA bus component;
//                              return FALSE;
//                         }
//                      }
//                      else
//                      {
//                          add EISA bus component;
//                      }
//                      return TRUE;
//
// ARGUMENTS:           BusNumber       EISA bus number
//                      pEisaComp       address where to store the EISA
//                                      configuration pointer
//
// RETURN:              FALSE           The configuration tree was incorrect.
//                      TRUE            The configuration tree is correct.
//
// ASSUMPTIONS:         The ARC component is present.
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaCheckAdapterComponent
    (
    IN  ULONG                     BusNumber,
    OUT PCONFIGURATION_COMPONENT *pEisaComp
    )
{
    //
    // define local variables
    //

    PCONFIGURATION_COMPONENT    pComp;
    CONFIGURATION_COMPONENT     Comp;
    EISA_ADAPTER_DETAILS        ConfigData;
    BOOLEAN     CfgOk = TRUE;
    CHAR        EisaMnemonic[MAX_MNEMONIC_LEN +1];
    PVOID       IoStart;
    ULONG       IoSize;
    ULONG       Slots;

    PRINTDBG("EisaCheckAdapterComponent\n\r");          // DEBUG SUPPORT

    //
    // initialize varables
    //

    sprintf( EisaMnemonic, "eisa(%lu)", BusNumber );
    *pEisaComp  = NULL;
    IoStart     = EisaBusInfo[ BusNumber ].IoBusInfo->VirAddr;
    IoSize      = EisaBusInfo[ BusNumber ].SlotsInfo->PhysSlots * 0x1000;
    Slots       = EisaBusInfo[ BusNumber ].SlotsInfo->VirSlots ?
                  EisaBusInfo[ BusNumber ].SlotsInfo->VirSlots + 16 :
                  EisaBusInfo[ BusNumber ].SlotsInfo->PhysSlots;

    //
    // if EISA adapter component is present, check its configuration data
    //

    if ((*pEisaComp = FwGetComponent(EisaMnemonic)) != NULL)
    {
        if ((*pEisaComp)->ConfigurationDataLength !=
                     sizeof(EISA_ADAPTER_DETAILS) ||
             FwGetConfigurationData( (PVOID)&ConfigData, *pEisaComp ) ||
             ConfigData.NumberOfSlots !=  Slots   ||
             ConfigData.IoStart       !=  IoStart ||
             ConfigData.IoSize        !=  IoSize   )
        {
            EisaPathErrorLog( *pEisaComp, CfgIncorrect );
            FwDelCfgTreeNode( *pEisaComp, FALSE );
            *pEisaComp  = NULL;
            CfgOk       = FALSE;
        }
    }

    //
    // add EISA adapter component if not present
    //

    if ( *pEisaComp == NULL )
    {
        // get the root component pointer

        if ((pComp = FwGetChild(NULL)) == NULL) {
            return(FALSE);
        }

        // component structure

        RtlZeroMemory( &Comp, sizeof(CONFIGURATION_COMPONENT));
        Comp.Class                              = AdapterClass;
        Comp.Type                               = EisaAdapter;
        Comp.Version                            = ARC_VERSION;
        Comp.Revision                           = ARC_REVISION;
        Comp.Key                                = BusNumber;
        Comp.ConfigurationDataLength            = sizeof(EISA_ADAPTER_DETAILS);
        Comp.IdentifierLength                   = sizeof("EISA");
        Comp.Identifier                         = "EISA";

        // configuration data structure

        RtlZeroMemory( &ConfigData, sizeof(EISA_ADAPTER_DETAILS));
// NOTE: ConfigDataHeader is not used in JAZZ.
//        ConfigData.ConfigDataHeader.Version     = ARC_VERSION;
//        ConfigData.ConfigDataHeader.Revision    = ARC_REVISION;
//        ConfigData.ConfigDataHeader.Type        = NULL;
//        ConfigData.ConfigDataHeader.Vendor      = NULL;
//        ConfigData.ConfigDataHeader.ProductName = NULL;
//        ConfigData.ConfigDataHeader.SerialNumber = NULL;
        ConfigData.NumberOfSlots                = Slots;
        ConfigData.IoStart                      = IoStart;
        ConfigData.IoSize                       = IoSize;

        *pEisaComp = FwAddChild( pComp, &Comp, (PVOID)&ConfigData );
    }

    //
    // return status
    //

    return CfgOk;
}









// ----------------------------------------------------------------------------
// PROCEDURE:           EisaBusCfg:
//
// DESCRIPTION:         This function configures the slots of the specified
//                      eisa bus.
//
//                      if we detect a "not-ready" board, we have to retry
//                      reading the ID again and report a time-out error if
//                      the ID is still not available after 100 msecs.
//                      (according to the EISA specs, the board should be
//                      ready within 100 msecs after reporting the "not-ready"
//                      status).  However, due to the slow init process of
//                      the ESC-1, we need to go with the following algorithm:
//                      - cfg the physical slots, marking the ones not ready.
//                      - cfg the virtual slots
//                      - go back to cfg the not-ready physical slots.
//                      A time of 2 sec will be given to all these not-ready
//                      slots : 200 loops of 10 msec. This period does not
//                      include configuration time for any slot which now
//                      comes up with a valid ID.
//
// ARGUMENTS:           EisaComponent   EISA component pointer
//
// RETURN:              TRUE            Configuration completed successfully
//                      FALSE           At least one configuration error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaBusCfg
    (
    IN PCONFIGURATION_COMPONENT EisaComponent
    )
{

    //
    // define local variables
    //

    BOOLEAN     CfgOk = TRUE;                   // starting value: all fine
    ULONG       IdTimeoutFlags = 0;             // eisa controllers in time-out
    USHORT      WaitTimeout=TIMEOUT_UNITS;      // time to wait before aborting
    PCONFIGURATION_COMPONENT FirstController;   // first eisa controller
    PCONFIGURATION_COMPONENT Controller;        // eisa controller to configure
    ULONG       BusNumber;                      // eisa bus number
    ULONG       PhysSlots;                      // eisa physical slots
    ULONG       MaxSlots;                       // eisa last slot
    ULONG       SlotNumber;                     // slot number configured
    PULONG      pSlotCfgMap;                    // slot cfg map pointer
    PUCHAR      EisaIoStart;                    // i/o eisa starting space
    ULONG       AdapId;                         // eisa controller id

    PRINTDBG("EisaBusCfg\n\r");                 // DEBUG SUPPORT

    //
    // initialize same variables using the eisa component structure
    //

    BusNumber   = EisaComponent->Key;
    EisaIoStart = EisaBusInfo[ BusNumber ].IoBusInfo->VirAddr;
    PhysSlots   = EisaBusInfo[ BusNumber ].SlotsInfo->PhysSlots;
    MaxSlots    = EisaBusInfo[ BusNumber ].SlotsInfo->VirSlots + 16;
    pSlotCfgMap = &EisaBusInfo[ BusNumber ].SlotsInfo->SlotCfgMap;
    *pSlotCfgMap    = 0;
    FirstController = FwGetChild(EisaComponent);

    //
    // physical slot initialization : one loop per physical slot
    //

    for (SlotNumber=0; SlotNumber<PhysSlots; SlotNumber++)
    {
        // read eisa controller id

        if (!EisaReadReadyId(EisaIoStart, SlotNumber, &AdapId))
        {
            IdTimeoutFlags |= 1<<SlotNumber;
            continue;
        }

        // find the eisa controller for the specified slot

        for (Controller = FirstController;
             Controller!=NULL  && Controller->Key!=SlotNumber;
             Controller = FwGetPeer(Controller));

        // skip cfg if empty slot; report an error if ARC cfg is missing

        if (Controller==NULL)
        {
            if (AdapId!=NO_ADAP_ID)
            {
                EisaSlotErrorLog( BusNumber, SlotNumber, CfgMissing );
                CfgOk = FALSE;
            }
            continue;
        }

        // one physical slot configuration

        if (!EisaPhysSlotCfg(BusNumber, Controller, AdapId))
        {
            CfgOk = FALSE;
            continue;
        }

        // set the "slot" bit to indicate configuration ok

        *pSlotCfgMap |= 1<<SlotNumber;

        // I/O function structures initialization

// NOTE: EisaOmf is not supported in JAZZ.
//        EisaOmfCheck( BusNumber, Controller, AdapId );

    }



    //
    // virtual slot initialization : one loop per virtual slot
    //

    for (SlotNumber=16; SlotNumber<MaxSlots; SlotNumber++)
    {
        // find the eisa controller for the specified slot

        for (Controller = FirstController;
             Controller!=NULL  && Controller->Key!=SlotNumber;
             Controller = FwGetPeer(Controller));

        // if component not present, skip to next virtual slot

        if (Controller==NULL)
        {
            continue;
        }

        // one virtual slot configuration

        if(!EisaVirSlotCfg(BusNumber, Controller))
        {
            CfgOk = FALSE;
            continue;
        }

        // set the "slot" bit to indicate configuration ok

        *pSlotCfgMap |= 1<<SlotNumber;
    }



    //
    // time-out slot initialization
    //

    while(IdTimeoutFlags && WaitTimeout--)
    {
        for ( SlotNumber = 0;
              IdTimeoutFlags && SlotNumber < PHYS_0_SLOTS;
              SlotNumber++ )
        {
            // check if the slot wasn't ready.

            if ( !(IdTimeoutFlags & 1<<SlotNumber))
            {
                continue;
            }

            // read eisa controller id

            if (!EisaReadReadyId(EisaIoStart, SlotNumber, &AdapId))
            {
                continue;
            }
            IdTimeoutFlags &= ~(1<<SlotNumber);

            // find the eisa controller for the specified slot

            for (Controller = FirstController;
                 Controller!=NULL  && Controller->Key!=SlotNumber;
                 Controller = FwGetPeer(Controller));

            // skip cfg if empty slot; report an error if ARC cfg is missing

            if (Controller==NULL)
            {
                if (AdapId!=NO_ADAP_ID)
                {
                    EisaSlotErrorLog(BusNumber, SlotNumber, CfgMissing);
                    CfgOk = FALSE;
                }
                continue;
            }

            // one physical slot configuration

            if (!EisaPhysSlotCfg(BusNumber, Controller, AdapId))
            {
                CfgOk = FALSE;
                continue;
            }

            // set the "slot" bit to indicate configuration ok

            *pSlotCfgMap |= 1<<SlotNumber;

            // I/O function structures initialization

// NOTE: EisaOmf is not supported in JAZZ.
//            EisaOmfCheck( BusNumber, Controller, AdapId );
        }

        // if there are still some slots in time-out stall execution
        // for 10 msec (10,000 usec).

        if (IdTimeoutFlags)
        {
            FwStallExecution (10000l);
        }
    }

    //
    // if controllers in time-out, display error messages and set the
    // failed bit within the associated "components".
    //

    if (IdTimeoutFlags)
    {
        for ( SlotNumber = 0;  SlotNumber < PHYS_0_SLOTS;  SlotNumber++ )
        {
            if ( IdTimeoutFlags & 1<<SlotNumber )
            {
                // display error message

                EisaSlotErrorLog( BusNumber, SlotNumber, IdTimeout );

                // find the eisa controller for the specified slot

                for (Controller = FirstController;
                     Controller!=NULL  &&  Controller->Key!=SlotNumber;
                     Controller = FwGetPeer(Controller));

                // if component present, set failed bit

                if (Controller != NULL)
                {
                    Controller->Flags.Failed = 1;
                }
            }
        }
        CfgOk = FALSE;
    }

//    //
//    // add a wild omf path name for the physical slots non configurated.
//    //
//
//    for ( SlotNumber = 0;  SlotNumber < PHYS_0_SLOTS;  SlotNumber++ )
//    {
//      if ( !(*pSlotCfgMap & 1<<SlotNumber) )
//      {
//          EisaOtherOmfIni( EisaComponent, SlotNumber );
//      }
//    }

    //
    // return configuration status
    //

    return CfgOk;
}








// ----------------------------------------------------------------------------
// PROCEDURE:           EisaPhysSlotCfg:
//
// DESCRIPTION:         This function configures the specified physical slot.
//
// ARGUMENTS:           BusNumber       EISA bus number
//                      Controller      eisa controller component pointer.
//                      AdapId          Eisa Id read from hardware.
//
//
// RETURN:              FALSE           Error
//                      TRUE            All done
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaPhysSlotCfg
    (
    IN ULONG BusNumber,
    IN PCONFIGURATION_COMPONENT Controller,
    IN ULONG AdapId
    )
{
    //
    // define local variables
    //

    EISA_SLOT_INFO EisaSlotInfo;                // pointer to first eisa info
    EISA_CFG_ERROR ErrMessage = CfgNoErrCode;   // eisa cfg error code

    PRINTDBG("EisaPhysSlotCfg\n\r");            // DEBUG SUPPORT

    //
    // validate physical slot configuration
    //

    if (Controller->Flags.Failed)
    {
        ErrMessage = CfgDeviceFailed;   // device failure
    }

    else if ( !(Controller->ConfigurationDataLength) )
    {
        ErrMessage = CfgMissing;        // eisa configuration missing
    }

    else if (Controller->ConfigurationDataLength < EISA_SLOT_MIN_INFO)
    {
        ErrMessage = CfgIncorrect;      // configuration length incorrect
    }

    else if (FwGetConfigurationDataIndex( (PVOID)&EisaSlotInfo,
                                          Controller,
                                          CONFIGDATAHEADER_SIZE,
                                          EISA_SLOT_INFO_SIZE ))
    {
        ErrMessage = CfgIncorrect;      // invalid component
    }

    else if (EisaSlotInfo.FunctionsNumber * EISA_FUNC_INFO_SIZE +
                EISA_SLOT_MIN_INFO != Controller->ConfigurationDataLength)
    {
        ErrMessage = CfgIncorrect;      // configuration length incorrect
    }

    else if (!(EisaSlotInfo.IdInfo & CFG_UNREADABLE_ID)^(AdapId != NO_ADAP_ID))
    {
        ErrMessage = CfgIdError;        // wrong configuration
    }

    else if (AdapId != NO_ADAP_ID  &&
                AdapId != Fw4UcharToUlongMSB(&EisaSlotInfo.Id1stChar))
    {
        ErrMessage = CfgIdError;        // wrong configuration
    }

    else if ((EisaSlotInfo.IdInfo & CFG_SLOT_MASK) != CFG_SLOT_EXP &&
             (EisaSlotInfo.IdInfo & CFG_SLOT_MASK) != CFG_SLOT_EMB )
    {
        ErrMessage = CfgIncorrect;      // wrong configuration
    }

    //
    // if any error, dispaly error message and set the failed bit
    //

    if (ErrMessage != CfgNoErrCode)
    {
        EisaSlotErrorLog( BusNumber, Controller->Key, ErrMessage );
        Controller->Flags.Failed = 1;
        return FALSE;
    }

    //
    // eisa adapter configuration
    //

    return( EisaSlotCfg( BusNumber,
                         Controller,
                         EisaSlotInfo.FunctionsNumber ));
}






// ----------------------------------------------------------------------------
// PROCEDURE:           EisaVirSlotCfg:
//
// DESCRIPTION:         This function configures the specified virtual slot.
//
// ARGUMENTS:           BusNumber       EISA bus number
//                      Controller      eisa controller component pointer.
//
//
// RETURN:              FALSE           Error
//                      TRUE            All done
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaVirSlotCfg
    (
    IN ULONG BusNumber,
    IN PCONFIGURATION_COMPONENT Controller
    )
{
    //
    // define local variables
    //

    EISA_SLOT_INFO EisaSlotInfo;                // pointer to first eisa info
    EISA_CFG_ERROR ErrMessage = CfgNoErrCode;   // eisa cfg error code

    PRINTDBG("EisaVirSlotCfg\n\r");     // DEBUG SUPPORT

    //
    // validate virtual slot configuration
    //

    if (Controller->Flags.Failed)
    {
        ErrMessage = CfgDeviceFailed;   // device failure
    }

    else if ( !(Controller->ConfigurationDataLength) )
    {
        ErrMessage = CfgMissing;        // configuration missing
    }

    if (Controller->ConfigurationDataLength < EISA_SLOT_MIN_INFO)
    {
        ErrMessage = CfgIncorrect;      // configuration length incorrect
    }

    else if (FwGetConfigurationDataIndex( (PVOID)&EisaSlotInfo,
                                          Controller,
                                          CONFIGDATAHEADER_SIZE,
                                          EISA_SLOT_INFO_SIZE ))
    {
        ErrMessage = CfgIncorrect;      // invalid component
    }

    else if (EisaSlotInfo.FunctionsNumber * EISA_FUNC_INFO_SIZE +
                EISA_SLOT_MIN_INFO != Controller->ConfigurationDataLength)
    {
        ErrMessage = CfgIncorrect;      // configuration length incorrect
    }

    else if ( !(EisaSlotInfo.IdInfo & CFG_UNREADABLE_ID) )
    {
        ErrMessage = CfgIdError;                // wrong configuration
    }

    else if ( (EisaSlotInfo.IdInfo & CFG_SLOT_MASK) != CFG_SLOT_VIR)
    {
        ErrMessage = CfgIncorrect;      // wrong configuration
    }

    //
    // if any error, display error message and set the failed bit
    //

    if (ErrMessage != CfgNoErrCode)
    {
        EisaSlotErrorLog( BusNumber, Controller->Key, ErrMessage );
        Controller->Flags.Failed = 1;
        return FALSE;
    }

    //
    // eisa adapter configuration
    //

    return( EisaSlotCfg( BusNumber,
                         Controller,
                         EisaSlotInfo.FunctionsNumber ));
}





// ----------------------------------------------------------------------------
// PROCEDURE:           EisaSlotCfg:
//
// DESCRIPTION:         This function configures the specified slot.
//
// ARGUMENTS:           BusNumber       EISA bus number
//                      Controller      Controller component pointer
//                      FunctionsNumber Number of function to configure
//
// RETURN:              TRUE            Configuration done
//                      FALSE           Error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaSlotCfg
    (
    IN ULONG    BusNumber,
    IN PCONFIGURATION_COMPONENT Controller,
    IN UCHAR    FunctionsNumber
    )
{
    //
    // define local variables
    //

    UCHAR       FuncFlags;              // function info flags
    UCHAR       Function;               // current function number
    BOOLEAN     CfgOk       = TRUE;     // local configuration status
    BOOLEAN     EnabAdapter = TRUE;     // adapter enable flag
    PUCHAR      EnabPort;               // used to enable the adapter
    PUCHAR      EisaIoStart;            // Eisa I/O virtual space
    PEISA_DMA_INFO pDmaInfo;            // DMA info pointer
    PEISA_INT_INFO pIntInfo;            // interrupts info pointer
    BOOLEAN     CfgMemOk    = TRUE;     // prevent multiple messages
    BOOLEAN     CfgIrqOk    = TRUE;     //      "       "       "
    BOOLEAN     CfgDmaOk    = TRUE;     //      "       "       "
    BOOLEAN     CfgIniOk    = TRUE;     //      "       "       "
    UCHAR       EisaFuncInfo[ EISA_FUNC_INFO_SIZE ];
    ULONG       EisaFuncIndex;

    PRINTDBG("EisaSlotCfg\n\r");        // DEBUG SUPPORT

    //
    // initialize variables
    //

    EisaIoStart = (PUCHAR)EisaBusInfo[ BusNumber ].IoBusInfo->VirAddr;
    pDmaInfo    = EisaBusInfo[ BusNumber ].DmaInfo;
    pIntInfo    = EisaBusInfo[ BusNumber ].IntInfo;
    EisaFuncIndex = EISA_SLOT_MIN_INFO;

    //
    // one function per loop
    //

    for ( Function = 0;
          Function < FunctionsNumber;
          Function++, EisaFuncIndex += EISA_FUNC_INFO_SIZE )
    {
        //
        // read function info
        //

        FwGetConfigurationDataIndex( (PVOID)EisaFuncInfo,
                                     Controller,
                                     EisaFuncIndex,
                                     EISA_FUNC_INFO_SIZE );
        //
        // check if configuration complete, exit if not.
        //

        if ( EisaFuncInfo[ CFG_SLOT_INFO_OFS ] & CFG_INCOMPLETE )
        {
            EisaSlotErrorLog( BusNumber, Controller->Key, CfgIncomplete );
            CfgOk = FALSE;
            break;
        }

        // update eisa function flags

        FuncFlags = EisaFuncInfo[ CFG_FN_INFO_OFS ];

        // skip if free form function

        if ( FuncFlags & CFG_FREE_FORM )
        {
            continue;
        }

        //
        // check if there is any memory entry
        //

// NOTE: Eisa memory not supported on JAZZ.
//        if ( FuncFlags & CFG_MEM_ENTRY )
//        {
//            if ( !EisaSlotCfgMem( BusNumber, Controller->Key, EisaFuncInfo ) &&
//                 CfgMemOk )
//            {
//                EisaSlotErrorLog( BusNumber, Controller->Key, CfgMemError );
//                CfgOk = CfgMemOk = FALSE;
//            }
//        }


        //
        // check if there is any interrupt entry
        //

        if ( FuncFlags & CFG_IRQ_ENTRY )
        {
            if (!EisaSlotCfgIrq( EisaIoStart, pIntInfo, EisaFuncInfo ) &&
                 CfgIrqOk )
            {
                EisaSlotErrorLog( BusNumber, Controller->Key, CfgIrqError );
                CfgOk = CfgIrqOk = FALSE;
            }
        }


        //
        // check if there is any DMA entry
        //

        if ( FuncFlags & CFG_DMA_ENTRY )
        {
            if ( !EisaSlotCfgDma( EisaIoStart, pDmaInfo, EisaFuncInfo ) &&
                 CfgDmaOk )
            {
                EisaSlotErrorLog( BusNumber, Controller->Key, CfgDmaError );
                CfgOk = CfgDmaOk = FALSE;
            }
        }


        //
        // check if there is any port init entry
        //

        if ( FuncFlags & CFG_INI_ENTRY )
        {
            if ( !EisaSlotCfgIni( EisaIoStart, EisaFuncInfo, &EnabAdapter ) &&
                 CfgIniOk )
            {
                EisaSlotErrorLog( BusNumber, Controller->Key, CfgIniError );
                CfgOk = CfgIniOk = FALSE;
            }
        }
    }

    //
    // if all fine, enable the adapter
    //

    if (CfgOk && EnabAdapter)
    {
        EnabPort=EisaIoStart+ Controller->Key*0x1000 +EXPANSION_BOARD_CTRL_BITS;
        EisaOutUchar(EnabPort, EisaInUchar(EnabPort) | 0x01);
    }

    //
    // return status of configuration process
    //

    return CfgOk;
}






// ----------------------------------------------------------------------------
// PROCEDURE:           EisaSlotCfgMem:
//
// DESCRIPTION:         This function configures the eisa memory registers
//                      based on info from NVRAM.
//
// ARGUMENTS:           BusNumber       EISA bus number.
//                      SlotNumber      EISA slot number.
//                      EisaFuncInfo    Function info pointer.
//
// RETURN:              TRUE            All done
//                      FALSE           Error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

// NOTE: Eisa memory not supported on JAZZ.
#if 0

BOOLEAN
EisaSlotCfgMem
    (
    IN ULONG  BusNumber,
    IN ULONG  SlotNumber,
    IN PUCHAR EisaFuncInfo
    )
{
    //
    // define local variables
    //

    BOOLEAN     CfgOk = TRUE;           // local configuration status
    PUCHAR      MemBlock;               // start of DMA data buffer
    USHORT      Index = 0;              // index within the memory block
    PFW_MD      pFwMd;                  // memory decriptor pointer
    ULONG       Addr;                   // address in 256 units
    ULONG       Size;                   // size in 1k units
    ULONG       WinSize, WinOffs;       // EISA windows characteristic
    PFW_MD      pMemInfo;               // EISA memory address space info

    PRINTDBG("EisaSlotCfgMem\n\r");     // DEBUG SUPPORT

    //
    // initialize variables
    //

    pMemInfo = EisaBusInfo[ BusNumber ].MemBusInfo;
    MemBlock = &EisaFuncInfo[ CFG_MEM_BLK_OFS ];

    //
    // one loop per each memory entry
    //

    do
    {
        //
        // get a memory descriptor
        //

        if ( (pFwMd = GetFwMd()) == NULL )
        {
            EisaSlotErrorLog( BusNumber, SlotNumber, MemAllocError);
            return FALSE;
        }

        //
        // memory block start and length
        //

        Addr = Fw3UcharToUlongLSB( &MemBlock[Index + 2] );
        Size = Fw2UcharToUlongLSB( &MemBlock[Index + 5] );

        pFwMd->VirAddr  = NULL;
        pFwMd->PhysAddr = Addr >> 4;
        pFwMd->PagOffs  = (Addr << 8) & (PAGE_SIZE - 1);
        pFwMd->Size     = Size ? Size << 10 : 64*1024*1024 ;
        pFwMd->PagNumb  = (pFwMd->PagOffs + Size + PAGE_SIZE - 1) >> PAGE_SHIFT;
        pFwMd->Cache    = FALSE;
        pFwMd->u.m.BusNumber  = BusNumber;
        pFwMd->u.m.SlotNumber = SlotNumber;
        pFwMd->u.m.Type       = MemBlock[ Index ] & CFG_MEM_TYPE;

        //
        // check if the memory size fits within the EISA window
        //

        if ( pMemInfo->u.em.WinShift != PAGE_4G_SHIFT )
        {
            // window size < 4 Gbytes

            WinSize  = 1 << pMemInfo->u.em.WinShift;
            WinOffs  = (Addr << 8) & (WinSize - 1);
            if ( WinSize - WinOffs < pFwMd->Size )
            {
                ReleaseFwMd( &pMemInfo->Link, pFwMd );
                CfgOk = FALSE;
                continue;
            }
        }

        //
        // link the memory descriptor
        //

        if ( LinkPhysFwMd( &pMemInfo->Link, pFwMd ) == NULL )
        {
            ReleaseFwMd( &pMemInfo->Link, pFwMd );
            CfgOk = FALSE;
            continue;
        }
    }
    while ((MemBlock[Index]&CFG_MORE_ENTRY) && ((Index+=7)<CFG_MEM_BLK_LEN));

    //
    // check final index
    //

    if ( !(Index < CFG_MEM_BLK_LEN) )
    {
        CfgOk=FALSE;
    }

    //
    // return configuration status
    //

    return CfgOk;
}
#endif // 0




// ----------------------------------------------------------------------------
// PROCEDURE:           EisaSlotCfgIrq:
//
// DESCRIPTION:         This function configures the interrupt registers
//                      based on info from NVRAM.
//
// ARGUMENTS:           EisaIoStart     EISA I/O virtual address
//                      pIntInfo        interrupt info pointer
//                      EisaFuncInfo    function info pointer.
//
// RETURN:              TRUE            All done
//                      FALSE           Error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaSlotCfgIrq
    (
    IN PUCHAR           EisaIoStart,
    IN PEISA_INT_INFO   pIntInfo,
    IN PUCHAR           EisaFuncInfo
    )
{
    //
    // define local variables
    //

    BOOLEAN     CfgOk   = TRUE;         // local configuration status
    PUCHAR      IrqBlock;               // start of IRQ data buffer
    USHORT      Index   = 0;            // index within the IRQ block
    USHORT      IrqBit;                 // 0x1=IRQ0... 0x8000=IRQ15
    UCHAR       Register;               // used to update the registers

    PRINTDBG("EisaSlotCfgIrq\n\r");     // DEBUG SUPPORT

    //
    // initialize variables
    //

    IrqBlock = &EisaFuncInfo[ CFG_IRQ_BLK_OFS ];

    //
    // one loop per each IRQ entries
    //

    do
    {
        IrqBit = 1 << ( IrqBlock[ Index ] & CFG_IRQ_MASK ); // compute IRQ bit

        //
        // check shareable and edge/level trigger mode
        //

        if ( pIntInfo->IrqPresent & IrqBit )
        {
            //
            // IRQ already used: check if it is shareabe
            //

            if ( !(pIntInfo->IrqShareable & IrqBit) )
            {
                CfgOk = FALSE;
                continue;
            }
            else if ( !(IrqBlock[Index] & CFG_IRQ_SHARE) )
            {
                CfgOk = FALSE;
                continue;
            }

            //
            // IRQ is shareable: check if the levels are compatible
            //

            else if (  (pIntInfo->IrqLevel & IrqBit) &&
                      !(IrqBlock[Index] & CFG_IRQ_LEVEL)  )
            {
                CfgOk=FALSE;
                continue;
            }
            else if ( !(pIntInfo->IrqLevel & IrqBit) &&
                       (IrqBlock[Index] & CFG_IRQ_LEVEL)  )
            {
                CfgOk=FALSE;
                continue;
            }
        }
        else
        {
            //
            // new IRQ: check if the IRQ 0, 1, 2, 8 and 13 are configurated
            //          for edge triggered.
            //

            switch(IrqBit)
            {
                case (0x0001):  // IRQ 0        only edge triggered
                case (0x0002):  // IRQ 1         "    "    "
                case (0x0004):  // IRQ 2         "    "    "
                case (0x0100):  // IRQ 8         "    "    "
                case (0x2000):  // IRQ 13        "    "    "

                    if (IrqBlock[Index] & CFG_IRQ_LEVEL)
                    {
                        CfgOk=FALSE;
                        continue;
                    }
                    break;

                default:
                    break;
            }
        }

        //
        // set the present bit and update sharable and edge/level
        // triggered variables
        //

        pIntInfo->IrqPresent |= IrqBit;

        if (IrqBlock[Index] & CFG_IRQ_SHARE)
        {
            pIntInfo->IrqShareable |= IrqBit;
        }

        if (IrqBlock[Index] & CFG_IRQ_LEVEL)
        {
            pIntInfo->IrqLevel |= IrqBit;
        }
    }
    while ((IrqBlock[Index]&CFG_MORE_ENTRY) && ((Index+=2)<CFG_IRQ_BLK_LEN));

    //
    // check final index
    //

    if ( !( Index < CFG_IRQ_BLK_LEN ) )
    {
        CfgOk=FALSE;
    }

    //
    // initialize ELCR registers with new values.
    //

    Register  = EisaInUchar(EisaIoStart + PIC1_ELCR);
    Register &= ~(pIntInfo->IrqPresent);
    Register |=   pIntInfo->IrqLevel;
    EisaOutUchar(EisaIoStart + PIC1_ELCR, Register);

    Register = EisaInUchar(EisaIoStart + PIC2_ELCR);
    Register &= ~(pIntInfo->IrqPresent >> BITSXBYTE);
    Register |=   pIntInfo->IrqLevel >> BITSXBYTE;
    EisaOutUchar(EisaIoStart + PIC2_ELCR, Register);

    //
    // return configuration status
    //

    return CfgOk;
}







// ----------------------------------------------------------------------------
// PROCEDURE:           EisaSlotCfgDma:
//
// DESCRIPTION:         This function configures the DMA registers
//                      based on info from NVRAM.
//
// ARGUMENTS:           EisaIoStart     EISA I/O virtual address
//                      pDmaInfo        DMA info pointer
//                      EisaFuncInfo    function info pointer.
//
// RETURN:              TRUE            All done
//                      FALSE           Error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaSlotCfgDma
    (
    IN PUCHAR           EisaIoStart,
    IN PEISA_DMA_INFO   pDmaInfo,
    IN PUCHAR           EisaFuncInfo
    )
{
    //
    // define local variables
    //

    BOOLEAN CfgOk=TRUE;                 // local configuration status
    PUCHAR DmaBlock;                    // start of DMA data buffer
    USHORT Index=0;                     // index within the DMA block
    UCHAR DmaNumber;                    // DMA under configuration
    UCHAR Register;                     // used to update the registers

    PRINTDBG("EisaSlotCfgDma\n\r");     // DEBUG SUPPORT

    //
    // initialize variables
    //

    DmaBlock = &EisaFuncInfo[ CFG_DMA_BLK_OFS ];

    //
    // one loop per each DMA entry
    //

    do
    {
        //
        // skip if shareable. device drivers should init DMA, not ROM
        //

        // NOTE: the following code has been removed because all the
        //       EISA cards that share the same DMA channel have the
        //       same value in this register.  This is guaranteed by
        //       the configuration utility.

        //if ( DmaBlock[Index] & CFG_DMA_SHARED )
        //{
        //    continue;
        //}

        //
        // Program the specified DMA channel using the new info.
        //

        DmaNumber = DmaBlock[Index] & CFG_DMA_MASK;

        // keep the "stop register" and "T-C" bits

        Register  = pDmaInfo->DmaExtReg[ DmaNumber ] & ~CFG_DMA_CFG_MASK;

        // use the new timing and bit I/O selection

        Register |= DmaBlock[Index+1] & CFG_DMA_CFG_MASK;

        // update the register

        if (DmaNumber < 4)
        {
            EisaOutUchar(EisaIoStart + DMA_EXTMODE03, Register);
        }
        else
        {
            EisaOutUchar(EisaIoStart + DMA_EXTMODE47, Register);
        }

        // This register value is used to validate the DMA requestes
        // (see the "EisaRequestEisaDmaTransfer" function).
        // The DMA channels used by more than one card have always the
        // same value ( check with the configuration guys ).

        pDmaInfo->DmaExtReg[ DmaNumber ] = Register;

    }
    while ((DmaBlock[Index]&CFG_MORE_ENTRY) && ((Index+=2)<CFG_DMA_BLK_LEN));

    //
    // check final index
    //

    if ( !(Index < CFG_DMA_BLK_LEN) )
    {
        CfgOk=FALSE;
    }

    //
    // return configuration status
    //

    return CfgOk;
}




// ----------------------------------------------------------------------------
// PROCEDURE:           EisaSlotCfgIni:
//
// DESCRIPTION:         This function configures the I/O port registers
//                      based on info from NVRAM.
//
// ARGUMENTS:           EisaIoStart     Starting eisa I/O area.
//                      EisaFuncInfo    Function info pointer.
//                      EnabAdapter     Enable adapter flag pointer.
//
// RETURN:              TRUE            All done
//                      FALSE           Error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaSlotCfgIni
    (
    IN PUCHAR    EisaIoStart,
    IN PUCHAR    EisaFuncInfo,
    OUT PBOOLEAN EnabAdapter
    )
{
    //
    // define local variables
    //

    BOOLEAN CfgOk = TRUE;               // local configuration status
    PUCHAR IniBlock;                    // start of init data buffer
    USHORT Index = 0;                   // index within the init block
    USHORT Next = 0;                    // index within the entry
    USHORT IoPort;                      // I/O address port
    UCHAR ByteValue;                    // used to init the registers
    UCHAR ByteMask;                     //
    USHORT ShortValue;                  // used to init the registers
    USHORT ShortMask;                   //
    ULONG WordValue;                    // used to init the registers
    ULONG WordMask;                     //

    PRINTDBG("EisaSlotCfgIni\n\r");     // DEBUG SUPPORT

    // initialize variables

    IniBlock = &EisaFuncInfo[CFG_INI_BLK_OFS];

    //
    // one loop per each init entries
    //

    do
    {
        // load the i/o address port

        Next = 1;
        IoPort  = IniBlock[Index + Next++];
        IoPort |= IniBlock[Index + Next++] << BITSXBYTE;

        switch(IniBlock[Index] & CFG_INI_MASK)
        {
            //
            // 8-bit I/O access
            //

            case(CFG_INI_BYTE):

                ByteValue = IniBlock[Index + Next++];

                if (IniBlock[Index] & CFG_INI_PMASK)    // use the mask
                {
                    ByteMask   = IniBlock[Index + Next++];
                    ByteValue |= READ_REGISTER_UCHAR(EisaIoStart+IoPort) & ByteMask;
                    EISA_IO_DELAY;
                }

                if ((IoPort & 0x0FFF) == EXPANSION_BOARD_CTRL_BITS)
                {
                    *EnabAdapter=FALSE;
                }
                WRITE_REGISTER_UCHAR(EisaIoStart+IoPort, ByteValue);
                EISA_IO_DELAY;
                break;

            //
            // 16-bit I/O access
            //

            case(CFG_INI_HWORD):

                ShortValue  = IniBlock[Index + Next++];
                ShortValue |= IniBlock[Index + Next++] << BITSXBYTE;

                if (IniBlock[Index] & CFG_INI_PMASK)    // use the mask
                {
                    ShortMask   = IniBlock[Index + Next++];
                    ShortMask  |= IniBlock[Index + Next++] << BITSXBYTE;
                    ShortValue |= READ_REGISTER_USHORT(EisaIoStart + IoPort) &
                                        ShortMask;
                    EISA_IO_DELAY;
                }

                WRITE_REGISTER_USHORT(EisaIoStart + IoPort, ShortValue);
                EISA_IO_DELAY;
                break;

            //
            // 32-bit I/O access
            //

            case(CFG_INI_WORD):

                WordValue = Fw4UcharToUlongLSB( &IniBlock[Index + Next] );
                Next += 4;

                if (IniBlock[Index]&CFG_INI_PMASK)      // use the mask
                {
                    WordMask   = Fw4UcharToUlongLSB( &IniBlock[Index + Next] );
                    Next += 4;
                    WordValue |= READ_REGISTER_ULONG(EisaIoStart + IoPort) &
                                        WordMask;
                    EISA_IO_DELAY;
                }

                WRITE_REGISTER_ULONG(EisaIoStart + IoPort, WordValue);
                EISA_IO_DELAY;
                break;

            //
            // error
            //

            default:
                CfgOk=FALSE;
                break;
        }
    }
    while ((IniBlock[Index]&CFG_MORE_ENTRY) && ((Index+=Next)<CFG_INI_BLK_LEN));

    //
    // check final index
    //

    if ( !(Index < CFG_INI_BLK_LEN) )
    {
        CfgOk=FALSE;
    }

    //
    // return configuration status
    //

    return CfgOk;
}







// ----------------------------------------------------------------------------
// PROCEDURE:           EisaSlotErrorLog:
//
// DESCRIPTION:         This function displays the corresponding eisa
//                      error message.
//
// ARGUMENTS:           BusNumber               BusNumber (not used)
//                      SlotNumber              Slot in error
//                      ErrorCode               Error number.
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
EisaSlotErrorLog
    (
    IN ULONG            BusNumber,
    IN ULONG            SlotNumber,
    IN EISA_CFG_ERROR   ErrorCode
    )
{
    PRINTDBG("EisaSlotErrorLog\n\r");   // DEBUG SUPPORT

    // display the error message

    FwPrint( EISA_ERROR_SLOT_MSG, SlotNumber, EisaCfgMessages[ErrorCode] );
    FwMoveCursorToColumn( 37 );
    FwPrint( EISA_ERROR1_MSG );
    FwStallExecution(1500000);

    // all done

    return;
}







// ----------------------------------------------------------------------------
// PROCEDURE:           EisaPathErrorLog:
//
// DESCRIPTION:         This function displays the corresponding eisa
//                      error message.
//
// ARGUMENTS:           Component               Component in error.
//                      ErrorCode               Error number.
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
EisaPathErrorLog
    (
    IN PCONFIGURATION_COMPONENT Controller,
    IN EISA_CFG_ERROR           ErrorCode
    )
{
    CHAR        Path[ MAX_DEVICE_PATH_LEN +1 ];

    PRINTDBG("EisaPathErrorLog\n\r");           // DEBUG SUPPORT

    EisaStrErrorLog( FwGetPath( Controller, Path ), ErrorCode );

    return;
}







// ----------------------------------------------------------------------------
// PROCEDURE:           EisaStrErrorLog:
//
// DESCRIPTION:         This function displays the corresponding eisa
//                      error message.
//
// ARGUMENTS:           Str                     String Message
//                      ErrorCode               Error number.
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
EisaStrErrorLog
    (
    IN PCHAR            Str,
    IN EISA_CFG_ERROR   ErrorCode
    )
{
    PRINTDBG("EisaStrErrorLog\n\r");    // DEBUG SUPPORT

    FwPrint( "\r\n %s %s ", Str, EisaCfgMessages[ErrorCode] );
    if ( strlen(Str) + strlen(EisaCfgMessages[ErrorCode]) + 2 < 36 )
    {
        FwMoveCursorToColumn( 37 );
    }
    FwPrint( EISA_ERROR1_MSG );
    FwStallExecution(1500000);

    return;
}







// ----------------------------------------------------------------------------
// PROCEDURE:           EisaCheckpointFirstFase:
//
// DESCRIPTION:         This function displays the specified checkpoint
//                      number on the internal LED and sends it to the
//                      parallel port.
//
// ARGUMENTS:           Chk             checkpoint number
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
//
// ----------------------------------------------------------------------------
//

VOID
EisaCheckpointFirstFase
    (
    IN EISA_CHECKPOINT  Chk
    )
{
    ULONG TestFlags;

    PRINTDBG("EisaCheckpointFirstFase\n\r");    // DEBUG SUPPORT

    TestFlags = ( (ULONG)EisaCheckpointInfo[ Chk ].SubLed << 28 ) +
                ( (ULONG)EisaCheckpointInfo[ Chk ].Led    << 24 ) +
                ( (ULONG)EisaCheckpointInfo[ Chk ].SubPar << 8  ) +
                ( (ULONG)EisaCheckpointInfo[ Chk ].Par          );

// NOTE: The parallel port test flag support is not used on JAZZ.
//    DisplayOnParallelPort( TestFlags );

    return;
}








// ----------------------------------------------------------------------------
// PROCEDURE:           EisaCheckpointFinalFase:
//
// DESCRIPTION:         This function returns the value of the specified
//                      real-time clock internal address.
//
// ARGUMENTS:           Chk             checkpoint number
//                      Passed          pass or fail
//
// RETURN:              Repeat          = TRUE  repeat checkpoint
//                                      = FALSE continue
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
//
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaCheckpointFinalFase
    (
    IN EISA_CHECKPOINT  Chk,
    IN BOOLEAN          Passed
    )
{
    ULONG       TestFlags;

    PRINTDBG("EisaCheckpointFinalFase\n\r");    // DEBUG SUPPORT

    if ( Passed )
    {
        EisaCheckpointInfo[ Chk ].Flags &= ~0x01;       // all fine
        EisaCheckpointInfo[ Chk ].Flags &= ~0x08;       // no message
    }
    else
    {
        EisaCheckpointInfo[ Chk ].Flags |= 0x01;        // error

        if ( EisaCheckpointInfo[ Chk ].Flags & 0x08 )   // display message
        {
            FwPrint( "%s", EisaCheckpointInfo[ Chk ].Msg );
            FwStallExecution(1500000);
        }
    }

    TestFlags = (( (ULONG)EisaCheckpointInfo[ Chk ].SubLed << 28 ) +
                 ( (ULONG)EisaCheckpointInfo[ Chk ].Led    << 24 ) +
                 ( (ULONG)EisaCheckpointInfo[ Chk ].Flags  << 16 ) +
                 ( (ULONG)EisaCheckpointInfo[ Chk ].SubPar << 8  ) +
                 ( (ULONG)EisaCheckpointInfo[ Chk ].Par          ));

// TEMPTEMP: Changed until we get the EvaluateTestResult routine from Olivetti.
//    return EvaluateTestResult( TestFlags ) == ESUCCESS ? FALSE : TRUE;

    return(FALSE);  // Never repeat.
}










// ----------------------------------------------------------------------------
// PROCEDURE:           EisaReadReadyId:
//
// DESCRIPTION:         This function reads the eisa id of the specified
//                      slot.
//
// ARGUMENTS:           EisaIoStart     Starting eisa I/O address.
//                      SlotNumber      Eisa slot number.
//                      AdapId          Eisa ID returned.
//
// RETURN:              FALSE           Time-out error
//                      TRUE            Valid adapter Id
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
EisaReadReadyId
        (
        IN PUCHAR EisaIoStart,
        IN ULONG SlotNumber,
        OUT PULONG AdapId
        )
{
    // define local variables

    BOOLEAN Ready=TRUE;

    PRINTDBG("EisaReadReadyId\n\r");    // DEBUG SUPPORT


    //
    // read adapter id
    //

    EisaReadId(EisaIoStart, SlotNumber, AdapId);


    //
    // check if adapter id is ready
    //

    if ( *AdapId & NO_ADAP_ID )
    {
        *AdapId = NO_ADAP_ID;                   // empty slot
    }
    else if ((*AdapId & WAIT_ADAP_ID) == WAIT_ADAP_ID)
    {
        Ready = FALSE;                          // adapter not ready
    }

    return Ready;
}




// ----------------------------------------------------------------------------
// PROCEDURE:           EisaReadId:
//
// DESCRIPTION:         This function reads the eisa id of the specified
//                      slot.
//
// ARGUMENTS:           EisaIoStart     Starting eisa I/O address.
//                      SlotNumber      Eisa slot number.
//                      AdapId          Eisa ID returned.
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
EisaReadId
        (
        IN PUCHAR EisaIoStart,
        IN ULONG SlotNumber,
        OUT PULONG AdapId
        )
{
    // define local variables

    PUCHAR AdapIdPort;                  // eisa I/O ID port
    PUCHAR RefreshPort;                 // eisa refresh port
    UCHAR  RefreshStatus;               // eisa refresh status (port 61h)
    ULONG  Retry;                       // # retry

    PRINTDBG("EisaReadId\n\r");         // DEBUG SUPPORT

    // initialize variables

    AdapIdPort = EisaIoStart + SlotNumber * 0x1000 + EISA_PRODUCT_ID;
    RefreshPort = EisaIoStart + EISA_SYS_CTRL_PORTB;

    // wait for the end of a refresh cycle (bit 4 of port 61h toggles)

    for ( Retry = EISA_RFR_RETRY,
          RefreshStatus = READ_REGISTER_UCHAR(RefreshPort) & EISA_REFRESH;

          Retry &&
          RefreshStatus == (READ_REGISTER_UCHAR(RefreshPort) & EISA_REFRESH);

          Retry-- );

    // write 0xFF to the adapter ID port

    EisaOutUchar(AdapIdPort, 0xFF);

    // read adapter id

    *AdapId = EisaInUchar(AdapIdPort++);
    *AdapId = *AdapId << BITSXBYTE | EisaInUchar(AdapIdPort++);
    *AdapId = *AdapId << BITSXBYTE | EisaInUchar(AdapIdPort++);
    *AdapId = *AdapId << BITSXBYTE | EisaInUchar(AdapIdPort++);

    // all done, return.

    return;
}







// ----------------------------------------------------------------------------
// PROCEDURE:           EisaMemIni:
//
// DESCRIPTION:         This function allocates memory for the descriptor
//                      pool and computes the top address and the length
//                      of a physical contiguous memory block to be used as
//                      OMF device drivers and dynamic memory pool.
//                      Note that only the memory really used will be
//                      allocated.
//
// ARGUMENTS:           none
//
// RETURN:              TRUE            all done
//                      FALSE           memory initialization error
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:             pFwMdPool               // descriptor pool
//                      MemorySize              // memory size in Mbytes
//                      EisaPoolSize            // # bytes really used
//                      EisaFreeTop             // top of free mem
//                      EisaDynMemSize          // dynamic memory size (bytes)
//                      EisaFreeBytes           // free bytes left
//
// NOTES:
// ----------------------------------------------------------------------------
//

// NOTE: Not used for JAZZ.
#if 0

BOOLEAN
EisaMemIni
    (
    VOID
    )
{
    FW_MD BuffFwMd;
    PVOID Dummy;

    PRINTDBG("EisaMemIni\n\r");                 // DEBUG SUPPORT

    //
    // allocate descriptor pool
    //

    if ( (pFwMdPool = (PFW_MD)FwAllocatePool( sizeof(FW_MD)*FW_MD_POOL ))
                    == NULL )
    {
        return FALSE;
    }

    //
    // set all the necessary TLB entries to map the whole system memory
    //

    RtlZeroMemory( &BuffFwMd, sizeof(FW_MD));
    BuffFwMd.Size       = 256 << 20;
    BuffFwMd.PagNumb    = 256 << (20 - PAGE_SHIFT);
    BuffFwMd.Cache      = TRUE;

    if ( AllocateMemoryResources( &BuffFwMd ) != ESUCCESS )
    {
        return FALSE;
    }

    //
    // compute OMF device drivers and dynamic memory pool area
    //

    EisaPoolSize = EisaDynMemSize = EISA_DYN_MEM_SIZE;

    if ( MemorySize >= 16 )
    {
        //
        // we don't use the memory above 16Mbytes because in this way we
        // can use this logic in a machine without translation registers
        // (logical I/O to physical) for the ISA boards which have a
        // transfer range of 24 bits (16Mbytes).
        //

        EisaFreeTop      = EISA_FREE_TOP_16;
        EisaFreeBytes    = EISA_FREE_BYTES_16;
    }
    else if ( MemorySize >= 12 )
    {
        EisaFreeTop      = EISA_FREE_TOP_12;
        EisaFreeBytes    = EISA_FREE_BYTES_12;
    }
    else if ( MemorySize >= 8 )
    {
        EisaFreeTop     = EISA_FREE_TOP_8;
        EisaFreeBytes   = EISA_FREE_BYTES_8;
    }
    else
    {
        return FALSE;
    }

    EisaFreeBytes   -= EisaDynMemSize;

    return TRUE;
}

#endif // 0






// ----------------------------------------------------------------------------
// PROCEDURE:           EisaDynMemIni:
//
// DESCRIPTION:         This function allocates the requested space for the
//                      the dynamic memory allocation.
//
// ARGUMENTS:           none
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:             EisaFreeTop             top of free mem
//                      EisaDynMemSize          dynamic memory size (bytes)
//                      EisaPoolSize            EISA pool size (bytes)
//
// NOTES:
// ----------------------------------------------------------------------------
//

// NOTE: Not used for JAZZ.
#if 0

VOID
EisaDynMemIni
    (
    VOID
    )
{
    //
    // define local variables
    //

    ULONG       BytesToPage;                    // bytes left to make a page
    PHEADER     pHdr;                           // memory descriptor header ptr
    PVOID       Buffer;                         // data area

    PRINTDBG("EisaDynMemIni\n\r");              // DEBUG SUPPORT

    //
    // align the dynamic memory buffer on a page boundary
    //

    BytesToPage      = PAGE_SIZE - (EisaDynMemSize & ((1 << PAGE_SHIFT) - 1));
    EisaDynMemSize  += BytesToPage;
    EisaPoolSize    += BytesToPage;
    EisaFreeTop     -= EisaDynMemSize;

    //
    // initialize first memory descriptor
    //

    pHdr         = (PHEADER)EisaFreeTop;
    Buffer       = (PVOID)(pHdr + 1);
    pHdr->m.id   = Buffer;
    pHdr->m.size = EisaDynMemSize/sizeof(HEADER);
    EisaFreeMemory( Buffer );

    return;
}

#endif // 0


// ----------------------------------------------------------------------------
// PROCEDURE:           FwGetPath:
//
// DESCRIPTION:         This function builds the path name for the specified
//                      component.
//
// ARGUMENTS:           Component       Component pointer.
//                      Str             Path name pointer.
//
// RETURN:              Str             Path name pointer.
//
// ASSUMPTIONS:         The string must be large enoungh to hold the
//                      requested path name.
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

PCHAR
FwGetPath
        (
        IN PCONFIGURATION_COMPONENT Component,
        OUT PCHAR Str
        )
{
    PCONFIGURATION_COMPONENT    pComp;

    PRINTDBG("FwGetPath\n\r");  // DEBUG SUPPORT

    if ( (pComp = FwGetParent( Component )) != NULL )
    {
        FwGetPath( pComp, Str);
        strcat( Str, FwGetMnemonic( Component ) );
        sprintf( Str + strlen( Str ), "(%lu)", Component->Key);
    }
    else
    {
        *Str = '\0';
    }
    return Str;
}








// ----------------------------------------------------------------------------
// PROCEDURE:           FwDelCfgTreeNode:
//
// DESCRIPTION:         This function removes from the configuration tree
//                      the specified component and all its children.
//
// ARGUMENTS:           pComp           component pointer.
//                      Peer            = TRUE  delete all its peers.
//                                      = FALSE delete just this branch.
//
// RETURN:              none
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

VOID
FwDelCfgTreeNode
    (
    IN PCONFIGURATION_COMPONENT pComp,
    IN BOOLEAN                  Peer
    )
{
    //
    // define local variables
    //

    PCONFIGURATION_COMPONENT NextComp;

    PRINTDBG("FwDelCfgTreeNode\n\r");           // DEBUG SUPPORT

    //
    // check for a child
    //

    if ( (NextComp = FwGetChild( pComp )) != NULL )
    {
        FwDelCfgTreeNode( NextComp, TRUE );
    }

    //
    // check for a peer.
    //

    if ( Peer  &&  (NextComp = FwGetPeer( pComp )) != NULL )
    {
        FwDelCfgTreeNode( NextComp, TRUE );
    }

    //
    // this is a leaf, delete it
    //

    FwDeleteComponent( pComp );

    //
    // all done
    //

    return;
}








// ----------------------------------------------------------------------------
// PROCEDURE:           FwGetMnemonic:
//
// DESCRIPTION:         This function stores the mnemonic name for the
//                      requested component type.
//
// ARGUMENTS:           Component       Component pointer.
//
// RETURN:              Str             Mnemonic pointer
//
// ASSUMPTIONS:         none
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

PCHAR
FwGetMnemonic
        (
        IN PCONFIGURATION_COMPONENT Component
        )
{
    PRINTDBG("FwGetMnemonic\n\r");      // DEBUG SUPPORT

    return MnemonicTable[Component->Type];
}






// ----------------------------------------------------------------------------
// PROCEDURE:           FwValidMnem:
//
// DESCRIPTION:         This function validates the specified mnemonic.
//                      If the mnemonic is valid, a TURE value is returned,
//                      otherwise a FALSE is returned.
//
// ARGUMENTS:           Str             Mnemonic pointer
//
// RETURN:              FALSE           Mnemonic incorrect
//                      TRUE            Mnemonic correct
//
// ASSUMPTIONS:         none
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

BOOLEAN
FwValidMnem
        (
        IN PCHAR Str
        )
{
    // define local variables

    CONFIGURATION_TYPE CfgType;

    PRINTDBG("FwValidMnem\n\r");        // DEBUG SUPPORT

    // check the mnemonic table

    for ( CfgType = ArcSystem;
          CfgType < MaximumType  &&  strcmp( MnemonicTable[ CfgType ], Str );
          CfgType++ );

    return CfgType < MaximumType ? TRUE : FALSE;
}



// ----------------------------------------------------------------------------
// GLOBAL:      I/O functions variables
// ----------------------------------------------------------------------------

PCHAR   AsciiBlock;                     // pointer the ASCII block
ULONG   AsciiBlockLength = 0;           // length of the ASCII block




// ----------------------------------------------------------------------------
// PROCEDURE:           FwStoreStr:
//
// DESCRIPTION:         This function stores the specified string within
//                      the ASCII block.  The NULL pointer is returned if
//                      there isn't space available for the string.
//
// ARGUMENTS:           Str             String pointer
//
// RETURN:              Str             String pointer
//
// ASSUMPTIONS:
//
// CALLS:
//
// GLOBALS:
//
// NOTES:
// ----------------------------------------------------------------------------
//

PCHAR
FwStoreStr
    (
    IN PCHAR Str
    )
{

    PRINTDBG("FwStoreStr\n\r");         // DEBUG SUPPORT

    // if not enough space, allocate new ASCII block

    if ( AsciiBlockLength < strlen( Str ) + 1 )
    {
        if((AsciiBlock = (PUCHAR)FwAllocatePool(ASCII_BLOCK_SIZE)) == NULL)
        {
            return NULL;
        }
    }

    // store the string and update the pointers.

    Str = strcpy( AsciiBlock, Str );
    AsciiBlock       += strlen( Str ) + 1;
    AsciiBlockLength  = ASCII_BLOCK_SIZE - (strlen( Str ) + 1);

    // all done, return the new string pointer

    return Str;
}