path: root/private/ntos/ndis/madge/driver/madge.c

/***************************************************************************
*
* MADGE.C
*
* FastMAC Plus based NDIS3 miniport driver entry, initialisation and
* closedown module.
*
* Copyright (c) Madge Networks Ltd 1994                                     
*
* COMPANY CONFIDENTIAL
*
* Created: PBA 21/06/1994
*                                                                          
****************************************************************************/

#include <ndis.h>

#include "ftk_defs.h"
#include "ftk_extr.h"
#include "ftk_intr.h"

#include "mdgmport.upd"
#include "ndismod.h"

/*---------------------------------------------------------------------------
|
| Identification string for MVER.
|
---------------------------------------------------------------------------*/

char MVerString[] = MVER_STRING;


/*---------------------------------------------------------------------------
|
| Option strings for registry queries.
|
| There is a lot of fuss here to get the various strings defined in the 
| correct way - those that are optional need to be defined in the parm. 
| table as string constants, while those that are passed directly to the
| registry query functions need to be explicitly defined outside any 
| structures.
|
|--------------------------------------------------------------------------*/

#define HIDDEN_OFFS 0x80

#define EmptyString           NDIS_STRING_CONST("")

//
// These are the NT versions of the option strings.
//

#define IOAddrString          NDIS_STRING_CONST("IoLocation")
#define IOBaseString          NDIS_STRING_CONST("IoBaseAddress")
#define InterruptNumString    NDIS_STRING_CONST("InterruptNumber")
#define DMAChanString         NDIS_STRING_CONST("DmaChannel")
#define TxSlotNumString       NDIS_STRING_CONST("TxSlots")
#define RxSlotNumString       NDIS_STRING_CONST("RxSlots")
#define MaxFrameSizeString    NDIS_STRING_CONST("MaxFrameSize")
#define CardBuffSizeString    NDIS_STRING_CONST("CardBufferSize")
#define AlternateIoString     NDIS_STRING_CONST("Alternate")
#define TestAndXIDString      NDIS_STRING_CONST("TestAndXIDEnabled")
#define RxTxSlotsString       NDIS_STRING_CONST("RxTxSlots")
#define ForceOpenString       NDIS_STRING_CONST("ForceOpen")
#define Force4String          NDIS_STRING_CONST("Force4")
#define Force16String         NDIS_STRING_CONST("Force16")
#define SlotNumString         NDIS_STRING_CONST("SlotNumber")
#define NoPciMmioString       NDIS_STRING_CONST("NoMmio")
#define RingSpeedString       NDIS_STRING_CONST("RingSpeed")
#define AdapterTypeString     NDIS_STRING_CONST("AdapterType")
#define MmioAddrString        NDIS_STRING_CONST("MemBase")
#define PlatformTypeString    NDIS_STRING_CONST("PlatformType")
#define TransferTypeString    NDIS_STRING_CONST("TransferType")

WCHAR PromModeString[] = 
    { L'P' + HIDDEN_OFFS, L'r' + HIDDEN_OFFS, L'o' + HIDDEN_OFFS, 
      L'm' + HIDDEN_OFFS, L'i' + HIDDEN_OFFS, L's' + HIDDEN_OFFS, 
      L'c' + HIDDEN_OFFS, L'u' + HIDDEN_OFFS, L'o' + HIDDEN_OFFS, 
      L'u' + HIDDEN_OFFS, L's' + HIDDEN_OFFS, L'M' + HIDDEN_OFFS, 
      L'o' + HIDDEN_OFFS, L'd' + HIDDEN_OFFS, L'e' + HIDDEN_OFFS, 
      L'X' + HIDDEN_OFFS, 000 };

#define PromiscuousString { sizeof(PromModeString) - 2, \
                            sizeof(PromModeString),     \
                            PromModeString }

//
// These strings are passed direct to NdisReadConfiguration.
//

STATIC NDIS_STRING BusTypeString         = NDIS_STRING_CONST("BusType");
STATIC NDIS_STRING BusNumberString       = NDIS_STRING_CONST("BusNumber");
STATIC NDIS_STRING IOAddressString       = IOAddrString;
STATIC NDIS_STRING IOBaseAddrString      = IOBaseString;
STATIC NDIS_STRING InterruptNumberString = InterruptNumString;
STATIC NDIS_STRING DMAChannelString      = DMAChanString;
STATIC NDIS_STRING SlotNumberString      = SlotNumString;
STATIC NDIS_STRING NoMmioString          = NoPciMmioString;
STATIC NDIS_STRING AdapterString         = AdapterTypeString;
STATIC NDIS_STRING MmioAddressString     = MmioAddrString;
STATIC NDIS_STRING PlatformString        = PlatformTypeString;
STATIC NDIS_STRING TransferModeString    = TransferTypeString;

STATIC NDIS_STRING NullString            = EmptyString;


/*---------------------------------------------------------------------------
|
| Optional parameter structure.
|
|--------------------------------------------------------------------------*/

//
// The Keyword parameters here use the #define's above, so the compiler is
// kept happy about string initialisers. 
//

STATIC struct
{
    MADGE_PARM_DEFINITION               TxSlots;
    MADGE_PARM_DEFINITION               RxSlots;
    MADGE_PARM_DEFINITION               MaxFrameSize;
    MADGE_PARM_DEFINITION               CardBufferSize;
    MADGE_PARM_DEFINITION               PromiscuousMode;
    MADGE_PARM_DEFINITION               AlternateIo;
    MADGE_PARM_DEFINITION               TestAndXIDEnabled;
    MADGE_PARM_DEFINITION               RxTxSlots;
    MADGE_PARM_DEFINITION               ForceOpen;
    MADGE_PARM_DEFINITION               Force4;
    MADGE_PARM_DEFINITION               Force16;
    MADGE_PARM_DEFINITION               RingSpeed;
    MADGE_PARM_DEFINITION               NullParm;
}
MadgeParmTable =
{
    {TxSlotNumString,      2,    32,      {NdisParameterInteger, 0}},
    {RxSlotNumString,      2,    32,      {NdisParameterInteger, 0}},
    {MaxFrameSizeString,   1024, 17839,   {NdisParameterInteger, 4096}},
    {CardBuffSizeString,   0,    0xFFFF,  {NdisParameterInteger, 0}},
    {PromiscuousString,    0,    1,       {NdisParameterInteger, 0}},
    {AlternateIoString,    0,    1,       {NdisParameterInteger, 0}},
    {TestAndXIDString,     0,    1,       {NdisParameterInteger, 0}},
    {RxTxSlotsString,      0,    5,       {NdisParameterInteger, 2}},
    {ForceOpenString,      0,    1,       {NdisParameterInteger, 0}},
    {Force4String,         0,    1,       {NdisParameterInteger, 0}},
    {Force16String,        0,    1,       {NdisParameterInteger, 0}},
    {RingSpeedString,      0,    2,       {NdisParameterInteger, 0}},
    {EmptyString}
};


/*---------------------------------------------------------------------------
|
| Name of the FastMAC Plus image file.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STRING FmpImageFileName = MADGE_FMP_NAME;


/*---------------------------------------------------------------------------
|
| List of PCI adapters in use.
|
---------------------------------------------------------------------------*/

STATIC struct 
{
    UINT BusNumber;
    UINT SlotNumber;
}
PciSlotsUsedList[MAX_NUMBER_OF_ADAPTERS];

STATIC int 
PciSlotsUsedCount = 0;


/****************************************************************************
*
* NDIS3 level adapter structure pointer table.
*
****************************************************************************/


/*---------------------------------------------------------------------------
|
| Function    - MadgeReadRegistryForMC
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
|
| Purpose     - Read configuration information for MC adapters out of 
Ý               the registry.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeReadRegistryForMC(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap
    );

#pragma FTK_INIT_FUNCTION(MadgeReadRegistryForMC)

STATIC NDIS_STATUS
MadgeReadRegistryForMC(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap
    )
{
    static WORD mcaIrqMap[4] = {     0,      3,      9,     10};
    static WORD mcaIoMap[8]  = {0x0a20, 0x1a20, 0x2a20, 0x3a20,
                                0x0e20, 0x1e20, 0x2e20, 0x3e20};

    NDIS_STATUS                    status;
    PNDIS_CONFIGURATION_PARAMETER  configParam;
    UINT                           slotNumber;
    NDIS_MCA_POS_DATA              mcaData;
    BYTE                           iOSelect;

    //
    // Note the information that is always true for MC adapters.
    //

    ndisAdap->NTCardBusType  = NdisInterfaceMca;
    ndisAdap->FTKCardBusType = ADAPTER_CARD_MC_BUS_TYPE;
    ndisAdap->TransferMode   = DMA_DATA_TRANSFER_MODE;

    //
    // MicroChannel is easy - the POS registers contain all the info 
    // we need, so read those and save the information.
    //

    NdisReadMcaPosInformation(
    	&status,
    	wrapperConfigHandle,
    	&slotNumber,
    	&mcaData
    	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_MCA_POS
            );

	return status;
    }

    //
    // Decode the Interrupt Number. Note: the FTK will throw
    // IRQ 0 out as invalid.
    //

    ndisAdap->UsedInISR.InterruptNumber = mcaIrqMap[mcaData.PosData1 >> 6];

    //
    // NB: Arbitration Level 15 => PIO, which we do not allow - 
    //     the FTK will throw this out as an invalid DMA channel.
    // NB: We call it DmaChannel to be compatible with ISA cards.
    //

    ndisAdap->DmaChannel = (mcaData.PosData1 >> 1) & 0x0F;

    //
    // Build the IO Location select value from several sources.
    //

    iOSelect  = (mcaData.PosData1 >> 5) & 0x01;
    iOSelect |= (mcaData.PosData4 >> 4) & 0x02;
    iOSelect |= (mcaData.PosData3 >> 0) & 0x04;

    //
    // NB: IO locations 0x2e20 and 0x3e20 are only valid for 
    // MC32 cards, but the .ADF file will have prevented them 
    // being set for MC16s.
    //

    ndisAdap->IoLocation1               = mcaIoMap[iOSelect];
    ndisAdap->UsedInISR.InterruptMode   = NdisInterruptLevelSensitive;
    ndisAdap->UsedInISR.InterruptShared = TRUE;
    ndisAdap->IORange1                  = MC_IO_RANGE;

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeReadRegistryForEISA
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
|
| Purpose     - Read configuration information for an EISA adapter
Ý               out of the registry.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeReadRegistryForEISA(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap
    );

#pragma FTK_INIT_FUNCTION(MadgeReadRegistryForEISA)

STATIC NDIS_STATUS
MadgeReadRegistryForEISA(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap
    )
{
    NDIS_STATUS                    status;
    PNDIS_CONFIGURATION_PARAMETER  configParam;
    UINT                           slotNumber;
    NDIS_EISA_FUNCTION_INFORMATION eisaData;

    //
    // For Eisa bus systems, we could have an Isa card or an Eisa
    // card - try to read the Eisa information, and if that fails
    // MadgeReadRegistry will assume it is an Isa card instead.
    //

    NdisReadEisaSlotInformation(
        &status,
	wrapperConfigHandle,
	&slotNumber,
	&eisaData
	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        return status;
    }

    //
    // Note the information that is always true for EISA
    // adapters.
    //

    ndisAdap->NTCardBusType  = NdisInterfaceEisa;
    ndisAdap->FTKCardBusType = ADAPTER_CARD_EISA_BUS_TYPE;
    ndisAdap->TransferMode   = DMA_DATA_TRANSFER_MODE;

    //
    // Got EISA configuration data - decode the relevant bits.
    //

    ndisAdap->IoLocation1 = slotNumber << 12;

    //
    // Get the Interrupt number from the NVRAM data - we know it
    // is going to be the first Irq element in the Irq array
    // because the card only uses one interrupt. 
    //

    ndisAdap->UsedInISR.InterruptNumber = 
        eisaData.EisaIrq[0].ConfigurationByte.Interrupt;

    ndisAdap->UsedInISR.InterruptMode = (NDIS_INTERRUPT_MODE)
        (eisaData.EisaIrq[0].ConfigurationByte.LevelTriggered 
    	    ? NdisInterruptLevelSensitive 
	    : NdisInterruptLatched);

    ndisAdap->UsedInISR.InterruptShared = (BOOLEAN)
        eisaData.EisaIrq[0].ConfigurationByte.Shared;

    //
    // For EISA cards we don't care what the DMA setting is. So 
    // we leave it set to 0 forget about it.
    //

    ndisAdap->IORange1    = EISA_IO_RANGE;
    ndisAdap->IoLocation2 = ndisAdap->IoLocation1 + EISA_IO_RANGE2_BASE;
    ndisAdap->IORange2    = EISA_IO_RANGE2;

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeReadRegistryForISA
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
Ý               adapterType          -> Adapter type.
|
| Purpose     - Read configuration information for ISA adapters out 
Ý               of the registry.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeReadRegistryForISA(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap,
    ULONG          adapterType
    );

#pragma FTK_INIT_FUNCTION(MadgeReadRegistryForISA)

STATIC NDIS_STATUS
MadgeReadRegistryForISA(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap,
    ULONG          adapterType
    )
{
    NDIS_STATUS                    status;
    PNDIS_CONFIGURATION_PARAMETER  configParam;

    //
    // Note the information that is always TRUE for ISA adapters.
    //

    ndisAdap->NTCardBusType = NdisInterfaceIsa;

    //
    // Do some adapter type specific setup. If we don't
    // know what sort of adapter it is we'll assume it's
    // an ATULA adapter so we are backwards compatible.
    //

    switch (adapterType)
    {
        case MADGE_ADAPTER_UNKNOWN:
        case MADGE_ADAPTER_ATULA: 
                
            ndisAdap->FTKCardBusType = ADAPTER_CARD_ATULA_BUS_TYPE;
            ndisAdap->IORange1       = ATULA_IO_RANGE;
            ndisAdap->TransferMode   = DMA_DATA_TRANSFER_MODE;
            break;

        case MADGE_ADAPTER_SMART16:
                
            ndisAdap->FTKCardBusType = ADAPTER_CARD_SMART16_BUS_TYPE;
            ndisAdap->IORange1       = SMART16_IO_RANGE;
            ndisAdap->TransferMode   = PIO_DATA_TRANSFER_MODE;
            break;

        case MADGE_ADAPTER_PCMCIA: 
                
            ndisAdap->FTKCardBusType = ADAPTER_CARD_PCMCIA_BUS_TYPE;
            ndisAdap->IORange1       = PCMCIA_IO_RANGE;
            ndisAdap->TransferMode   = PIO_DATA_TRANSFER_MODE;
            break;

        case MADGE_ADAPTER_PNP:

            ndisAdap->FTKCardBusType = ADAPTER_CARD_PNP_BUS_TYPE;
            ndisAdap->IORange1       = PNP_IO_RANGE;
            ndisAdap->TransferMode   = PIO_DATA_TRANSFER_MODE;
            break;

        default:

            return NDIS_STATUS_FAILURE;
    }

    //
    // Get the IO location - must have this. First try 
    // "IoLocation" and then "IoBaseAddress".
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&IOAddressString,
    	NdisParameterHexInteger
    	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisReadConfiguration(
     	    &status,
     	    &configParam,
     	    registryConfigHandle,
     	    &IOBaseAddrString,
     	    NdisParameterHexInteger
     	    );
    }

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_ISA_IO
            );

	return status;
    }

    ndisAdap->IoLocation1 = configParam->ParameterData.IntegerData;

    //
    // Er, slight hack here. We used to pretend that Smart16 
    // adapters were ATULA adapters. We now don't. So to
    // be backwards compatible, if we have an unknown adapter
    // with an IO base >= 0x4a20 and <= 0x6e20 we'll assume it's
    // really a Smart16.
    //

    if (adapterType           == MADGE_ADAPTER_UNKNOWN &&
        ndisAdap->IoLocation1 >= 0x4a20                &&
        ndisAdap->IoLocation1 <= 0x6e20)
    {
        adapterType              = MADGE_ADAPTER_SMART16;
        ndisAdap->FTKCardBusType = ADAPTER_CARD_SMART16_BUS_TYPE;
        ndisAdap->IORange1       = SMART16_IO_RANGE;
        ndisAdap->TransferMode   = PIO_DATA_TRANSFER_MODE;
    }

    //
    // Get the IRQ number - we must have this.
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&InterruptNumberString,
    	NdisParameterInteger
    	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_ISA_IRQ
            );

	return status;
    }

    ndisAdap->UsedInISR.InterruptNumber = 
        configParam->ParameterData.IntegerData;

    ndisAdap->UsedInISR.InterruptMode   = NdisInterruptLatched;
    ndisAdap->UsedInISR.InterruptShared = FALSE;

    //
    // Read the TransferType parameter and switch into PIO
    // mode if specified.
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&TransferModeString,
    	NdisParameterInteger
    	);

    if (status == NDIS_STATUS_SUCCESS)
    {
        if (configParam->ParameterData.IntegerData == MADGE_PIO_MODE)
        {
            ndisAdap->TransferMode = PIO_DATA_TRANSFER_MODE;
        }
    }

    //
    // Get the DMA channel (PIO is specified as channel 0,
    // multiprocessor safe PIO is specified as 0x8000). We
    // don't need a DMA channel if the adapter isn't an ATULA so
    // the only reason for reading the DMA channel for none
    // ATULA adapters is to allow backwards compatability with old 
    // registry set ups that specify multiprocessor safe PIO
    // with the DmaChannel == 0x8000. Using the DMA channel
    // to specify PIO is retained for backwards compatibility
    // the correct way is to set the TransferType parameter.
    //

    NdisReadConfiguration(
        &status,
        &configParam,
        registryConfigHandle,
        &DMAChannelString,
        NdisParameterInteger
        );

    if (status != NDIS_STATUS_SUCCESS)
    {
        ndisAdap->DmaChannel = 0;
    }
    else
    {
        ndisAdap->DmaChannel = configParam->ParameterData.IntegerData;
    }

    //
    // Note if we should be using multiprocessor safe PIO.
    //

    if (ndisAdap->DmaChannel == 0x8000)
    {
         ndisAdap->DmaChannel   = 0;
         ndisAdap->UseMPSafePIO = TRUE;
    }

    //
    // If we did not get a DMA channel then we must use PIO.
    //

    if (ndisAdap->DmaChannel == 0)
    {
        ndisAdap->TransferMode = PIO_DATA_TRANSFER_MODE;
    }

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeFindPciInfoForWin95
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
Ý               pciSlotInfo          -> Pointer to a buffer that will
Ý                                       be filled with the configuration 
Ý                                       data for the adapter.
|
| Purpose     - Read configuration information for PCI adapters out 
Ý               of the registry when running on Windows95. The slot
Ý               containing the adapter is also found and the configuration
Ý               data from the slot returned in the pciSlotInfo buffer.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeFindPciInfoForWin95(
    NDIS_HANDLE      wrapperConfigHandle,
    NDIS_HANDLE      registryConfigHandle,
    PMADGE_ADAPTER   ndisAdap,
    BYTE           * pciSlotInfo
    );

#pragma FTK_INIT_FUNCTION(MadgeFindPciInfoForWin95)

STATIC NDIS_STATUS
MadgeFindPciInfoForWin95(
    NDIS_HANDLE      wrapperConfigHandle,
    NDIS_HANDLE      registryConfigHandle,
    PMADGE_ADAPTER   ndisAdap,
    BYTE           * pciSlotInfo

    )
{
    NDIS_STATUS                   status;
    PNDIS_CONFIGURATION_PARAMETER configParam;
    UINT                          i;

    //
    // Unfortunately Windows95 (M7) and NT handle PCI configuration
    // in different ways. Under NT one has to read the slot
    // configuration. Under Windows95 the resource information
    // is faked up by the configuration manager and can be read 
    // directly from the wrapper.
    //

    //
    // Get the IO location - must have this. First try 
    // "IoLocation" and then "IoBaseAddress".
    //

    NdisReadConfiguration(
        &status,
	&configParam,
	registryConfigHandle,
	&IOAddressString,
	NdisParameterHexInteger
	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisReadConfiguration(
    	    &status,
    	    &configParam,
    	    registryConfigHandle,
    	    &IOBaseAddrString,
    	    NdisParameterHexInteger
    	    );
    }
                
    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_PCI_IO
            );

	return status;
    }

    ndisAdap->IoLocation1 = configParam->ParameterData.IntegerData;

    //
    // Get the IRQ number - we must have this.
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&InterruptNumberString,
    	NdisParameterInteger
    	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_PCI_IRQ
            );

	return status;
    }

    ndisAdap->UsedInISR.InterruptNumber = 
        configParam->ParameterData.IntegerData;

    //
    // Get the MMIO base address - optional. 
    //

    NdisReadConfiguration(
        &status,
        &configParam,
        registryConfigHandle,
        &MmioAddressString,
        NdisParameterInteger
        );

    if (status == NDIS_STATUS_SUCCESS)
    {
        ndisAdap->MmioRawAddress = 
            configParam->ParameterData.IntegerData;
    }

    //
    // We also need to know which slot the adapter is in so we can
    // read and write configuration space directly. We'll search for
    // a slot which contains a Madge adapter which the correct I/O
    // location. As a side effect we'll store the configuration data 
    // for the slot in pciSlotInfo. Note: Under Windows 95 (build 490)
    // NdisReadPciSlotInformation does appear to return the number
    // of bytes read as it does under NT - not sure what it returns ...
    //

    ndisAdap->SlotNumber = PCI_FIND_ADAPTER;

    for (i = 0; i < MAX_PCI_SLOTS; i++)
    {
        NdisReadPciSlotInformation(
            ndisAdap->UsedInISR.MiniportHandle,
            i,
            0,
            (VOID *) pciSlotInfo,
            PCI_CONFIG_SIZE
            );

        if (PCI_VENDOR_ID(pciSlotInfo) == MADGE_PCI_VENDOR_ID &&
            PCI_IO_BASE(pciSlotInfo)   == ndisAdap->IoLocation1)
        {
            ndisAdap->SlotNumber = i;
            break;
        }
    }

    if (ndisAdap->SlotNumber == PCI_FIND_ADAPTER)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_DRIVER_FAILURE,
            2,
            readRegistry,
            MADGE_ERRMSG_BAD_PCI_SLOTNUMBER
            );

        return NDIS_STATUS_FAILURE;
    }
    
    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
Ý
Ý Function    - MadgePciSlotUsed
Ý
Ý Parameters  - busNumber  -> Bus number containing the adapter.
Ý               slotNumber -> Slot number containing the adapter.
Ý 
Ý Purpose     - Check if a PCI slot is already in use.
Ý
Ý Returns     - TRUE if the slot is in use or FALSE if not.
Ý
Ý--------------------------------------------------------------------------*/

STATIC BOOLEAN
MadgePciSlotUsed(
    UINT busNumber,
    UINT slotNumber
    );

#pragma FTK_INIT_FUNCTION(MadgePciSlotUsed)

STATIC BOOLEAN
MadgePciSlotUsed(
    UINT busNumber,
    UINT slotNumber
    )
{
    int i;

    for (i = 0; i < PciSlotsUsedCount; i++)
    {
        if (PciSlotsUsedList[i].BusNumber  == busNumber &&
            PciSlotsUsedList[i].SlotNumber == slotNumber)
        {
            return TRUE;
        }
    }

    return FALSE;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeFindPciInfoForNt
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
Ý               pciSlotInfo          -> Pointer to a buffer that will
Ý                                       be filled with the configuration 
Ý                                       data for the adapter.
|
| Purpose     - Read configuration information for PCI adapters out 
Ý               of the registry when running on Windows95. The slot
Ý               containing the adapter is also found and the configuration
Ý               data from the slot returned in the pciSlotInfo buffer.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeFindPciInfoForNt(
    NDIS_HANDLE      wrapperConfigHandle,
    NDIS_HANDLE      registryConfigHandle,
    PMADGE_ADAPTER   ndisAdap,
    BYTE           * pciSlotInfo
    );

#pragma FTK_INIT_FUNCTION(MadgeFindPciInfoForNt)

STATIC NDIS_STATUS
MadgeFindPciInfoForNt(
    NDIS_HANDLE      wrapperConfigHandle,
    NDIS_HANDLE      registryConfigHandle,
    PMADGE_ADAPTER   ndisAdap,
    BYTE           * pciSlotInfo
    )
{
    NDIS_STATUS                     status;
    PNDIS_CONFIGURATION_PARAMETER   configParam;
    UINT                            slotNumber;
    BOOLEAN                         pciSlotRead;
    BOOLEAN                         useMmio;
    UINT                            i;
    PNDIS_RESOURCE_LIST             pciResources;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR resDesc;
    UINT                            busNumber;

    //
    // Unfortunately Windows95 (M7) and NT handle PCI configuration
    // in different ways. Under NT one has to read the slot
    // configuration. Under Windows95 the resource information
    // is faked up by the configuration manager and can be read 
    // directly from the wrapper. 
    //
     
    //
    // Find out what the slot number is. This is in fact the
    // PCI device number. Values 0 through 31 represent real
    // slot numbers. 0xffff means we should search for the
    // first unused Madge PCI adapter.
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&SlotNumberString,
    	NdisParameterInteger
    	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_PCI_SLOTNUMBER
            );

	return status;
    }

    slotNumber  = configParam->ParameterData.IntegerData;
    pciSlotRead = FALSE;

    //
    // Read the bus number.
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&BusNumberString,
    	NdisParameterInteger
    	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_PCI_SLOTNUMBER
            );

	return status;
    }

    busNumber = configParam->ParameterData.IntegerData;

    //
    // If the slot number is PCI_FIND_ADAPTER (0xffff) then we 
    // will attempt to search for the first Madge PCI adapter 
    // that is not already in use.
    //

    if (slotNumber == PCI_FIND_ADAPTER)
    {
        for (i = 0; !pciSlotRead && i < MAX_PCI_SLOTS; i++)
        {
            if (!MadgePciSlotUsed(busNumber, i))
            {
                //
                // Extract the PCI configuration information from 
                // the slot.
                //

                status = NdisReadPciSlotInformation(
                             ndisAdap->UsedInISR.MiniportHandle,
                             i,
                             0,
                             (VOID *) pciSlotInfo,
                             PCI_CONFIG_SIZE
                             );
                //
                // Check if the slot contains a Madge adapter and 
                // break out of the loop if it does.
                //

                if (status                     == PCI_CONFIG_SIZE && 
                    PCI_VENDOR_ID(pciSlotInfo) == MADGE_PCI_VENDOR_ID)
                {
                    slotNumber  = i;
                    pciSlotRead = TRUE;
                }
            }
        }
    }

    //
    // Check if the slotNumber is valid. This will fail if the
    // above adapter search failed.
    //

    if (slotNumber <  0             || 
        slotNumber >= MAX_PCI_SLOTS || 
        MadgePciSlotUsed(busNumber, slotNumber))
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_DRIVER_FAILURE,
            2,
            readRegistry,
            MADGE_ERRMSG_BAD_PCI_SLOTNUMBER
            );

        return NDIS_STATUS_FAILURE;
    }
                
    //
    // Note that the PCI slot is in use.
    //

    PciSlotsUsedList[PciSlotsUsedCount].BusNumber  = busNumber;
    PciSlotsUsedList[PciSlotsUsedCount].SlotNumber = slotNumber;
    PciSlotsUsedCount++;

    ndisAdap->SlotNumber = slotNumber;

    //
    // There two methods for getting the PCI configuration. One is
    // to read it directly from the PCI configuration space. This
    // works for Intel patforms where a PCI BIOS has configured
    // all of the adapters at boot time. It does not work for
    // none Intel platforms where the PCI devices are not
    // configured at boot time. Unfortunately the call which
    // provokes NT to configure a PCI device, NdisMPciAssignResources
    // is not available in the NT 3.5 wrapper. So, until NT 3.51
    // becomes dominant we must support both configuration methods.
    //

    //
    // If we haven't already extracted the PCI configuration 
    // information from the slot and check that it is valid.
    //

    if (!pciSlotRead)
    {
        status = NdisReadPciSlotInformation(
                     ndisAdap->UsedInISR.MiniportHandle,
                     slotNumber,
                     0,
                     (VOID *) pciSlotInfo,
                     PCI_CONFIG_SIZE
                     );

        if (status                     != PCI_CONFIG_SIZE || 
            PCI_VENDOR_ID(pciSlotInfo) != MADGE_PCI_VENDOR_ID)
        {
            MadgePrint1("No Madge adapter in slot\n");

            NdisWriteErrorLogEntry(
                ndisAdap->UsedInISR.MiniportHandle,
                NDIS_ERROR_CODE_DRIVER_FAILURE,
                2,
                readRegistry,
                MADGE_ERRMSG_BAD_PCI_SLOTNUMBER
                );

            return NDIS_STATUS_FAILURE;
        }
    }

    //
    // Call NdisMPciAssignResources for the specified slot to
    // get the adapter configuration.
    //

    status = NdisMPciAssignResources(
                 ndisAdap->UsedInISR.MiniportHandle,
                 slotNumber,
                 &pciResources
                 );

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_DRIVER_FAILURE,
            2,
            readRegistry,
            MADGE_ERRMSG_BAD_PCI_SLOTNUMBER
            );

        return NDIS_STATUS_FAILURE;
    }

    //
    // Iterate through the returned resource list recording the values
    // in the PCI configuration
    //

    for (i = 0; i < pciResources->Count; i++) 
    {
        resDesc = &pciResources->PartialDescriptors[i];

        switch (resDesc->Type) 
        {
	    case CmResourceTypeInterrupt:
  
                ndisAdap->UsedInISR.InterruptNumber =
                    (ULONG) resDesc->u.Interrupt.Vector;
		break;

	    case CmResourceTypePort: 

		ndisAdap->IoLocation1 = 
                    (UINT) NdisGetPhysicalAddressLow(resDesc->u.Port.Start);
		break;

            case CmResourceTypeMemory:

		ndisAdap->MmioRawAddress = 
                    (DWORD) NdisGetPhysicalAddressLow(resDesc->u.Memory.Start);
		break;
        }
    }           


    //
    // On none-Intel platforms it's possible for the PCI adapter's I/O
    // base to be greater than 0xffff. Since the FTK uses 16bit
    // I/O locations we make a note of the I/O base in a 32bit cell
    // that we can add in inside the I/O functions in sys_mem.c
    // 

#ifndef _M_IX86

    ndisAdap->IoLocationBase = ndisAdap->IoLocation1;
    ndisAdap->IoLocation1    = 0;

#endif

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeReadRegistryForPCI
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
Ý               platformType         -> Type of platform: NT or Win95.
|
| Purpose     - Read configuration information for PCI.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeReadRegistryForPCI(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap,
    UINT           platformType
    );

#pragma FTK_INIT_FUNCTION(MadgeReadRegistryForPCI)

STATIC NDIS_STATUS
MadgeReadRegistryForPCI(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap,
    UINT           platformType
    )
{
    NDIS_STATUS                     status;
    PNDIS_CONFIGURATION_PARAMETER   configParam;
    BYTE                            pciSlotInfo[PCI_CONFIG_SIZE];
    BOOLEAN                         useMmio;

    //
    // Note the information that is always true for PCI adapters.
    //

    ndisAdap->NTCardBusType  = NdisInterfacePci;

    //
    // Set up the fixed configuration information.
    //

    ndisAdap->UsedInISR.InterruptMode   = NdisInterruptLevelSensitive;
    ndisAdap->UsedInISR.InterruptShared = TRUE;

    //
    // We know need to find the PCI adapter and read in the configuration
    // information for the slot. Unfortunatetly the method we have to use
    // is different for NT and Win95.
    //

    if (platformType == MADGE_OS_WIN95)
    {
        status = MadgeFindPciInfoForWin95(
                     wrapperConfigHandle,
                     registryConfigHandle,
                     ndisAdap,
                     pciSlotInfo
                     );
    }
    else
    {
        status = MadgeFindPciInfoForNt(
                     wrapperConfigHandle,
                     registryConfigHandle,
                     ndisAdap,
                     pciSlotInfo
                     );
    }

    if (status != NDIS_STATUS_SUCCESS)
    {
        return status;
    }

    //
    // Now we know we have a Madge PCI adapter of some sort but
    // as yet we don't know what type. We'll work this out by
    // looking at the device/revision ID in the slot's configuration
    // data. At the same time we'll note the default transfer type
    // for the adapter.
    //

    switch (PCI_REVISION(pciSlotInfo))
    {
        case MADGE_PCI_RAP1B_REVISION:

            ndisAdap->FTKCardBusType = ADAPTER_CARD_PCI_BUS_TYPE;
            ndisAdap->TransferMode   = MMIO_DATA_TRANSFER_MODE;
            ndisAdap->IORange1       = PCI_IO_RANGE;
            break;

        case MADGE_PCI_PCI2_REVISION:

            ndisAdap->FTKCardBusType = ADAPTER_CARD_PCI2_BUS_TYPE;
            ndisAdap->TransferMode   = DMA_DATA_TRANSFER_MODE;
            ndisAdap->IORange1       = PCI2_IO_RANGE;
            break;

        case MADGE_PCI_PCIT_REVISION:

            ndisAdap->FTKCardBusType = ADAPTER_CARD_TI_PCI_BUS_TYPE;
            ndisAdap->TransferMode   = DMA_DATA_TRANSFER_MODE;
            ndisAdap->IORange1       = SIF_IO_RANGE;
            break;

        default:

            return NDIS_STATUS_FAILURE;
    }

    //
    // Now we need to work out the transfer type. There are three
    // things that affect the transfer type: the setting of
    // the TransferType registry parameter, the setting of the
    // NoMmio registry flag and whether we have been allocated any
    // MMIO memory. Ideally we would just use the TransferType flag.
    // The NoMmio flag is to preserve backwards compatibility with old
    // registry set ups.
    //

    //
    // Read the transfer type flag if possible.
    //

    NdisReadConfiguration(
    	&status,
    	&configParam,
    	registryConfigHandle,
    	&TransferModeString,
    	NdisParameterInteger
    	);

    if (status == NDIS_STATUS_SUCCESS)
    {
        //
        // Set the transfer type depending on the TransferType parameter
        // and the adapter type.
        //

        if (configParam->ParameterData.IntegerData == MADGE_DMA_MODE)
        {
            if (ndisAdap->FTKCardBusType == ADAPTER_CARD_PCI2_BUS_TYPE ||
                ndisAdap->FTKCardBusType == ADAPTER_CARD_TI_PCI_BUS_TYPE)
            {
                ndisAdap->TransferMode = DMA_DATA_TRANSFER_MODE;
            }
        }

        if (configParam->ParameterData.IntegerData == MADGE_PIO_MODE)
        {
            ndisAdap->TransferMode = PIO_DATA_TRANSFER_MODE;
        }

        if (configParam->ParameterData.IntegerData == MADGE_MMIO_MODE)
        {
            if (ndisAdap->FTKCardBusType == ADAPTER_CARD_PCI_BUS_TYPE)
            {
                ndisAdap->TransferMode = MMIO_DATA_TRANSFER_MODE;
            }
        }
    }

    //
    // To preserve backwards compatibility if we find the NoMmio flag
    // set then switch to PIO mode.
    //

    if (ndisAdap->TransferMode == MMIO_DATA_TRANSFER_MODE)
    {
        NdisReadConfiguration(
    	    &status,
    	    &configParam,
    	    registryConfigHandle,
    	    &NoMmioString,
    	    NdisParameterInteger
    	    );

        if (status == NDIS_STATUS_SUCCESS)
        {
            if (configParam->ParameterData.IntegerData != 0)
            {
                ndisAdap->TransferMode = PIO_DATA_TRANSFER_MODE;
            }
        }
    }

    //
    // If we are in MMIO mode then check that we were allocated some MMIO
    // memory. If not switch to PIO mode.
    //

    if (ndisAdap->TransferMode == MMIO_DATA_TRANSFER_MODE)
    {
        if (ndisAdap->MmioRawAddress == 0)
        {
            NdisWriteErrorLogEntry(
                ndisAdap->UsedInISR.MiniportHandle,
                NDIS_ERROR_CODE_MEMORY_CONFLICT,
                2,
                readRegistry,
                MADGE_ERRMSG_BAD_PCI_MMIO
                );

            ndisAdap->TransferMode == PIO_DATA_TRANSFER_MODE;

        }    
    }

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeReadRegistry
|
| Parameters  - wrapperConfigHandle  -> Wrapper context handle.
|               registryConfigHandle -> Already open registry query handle.
|               ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
|
| Purpose     - Read configuration information out of the registry.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeReadRegistry(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap
    );

#pragma FTK_INIT_FUNCTION(MadgeReadRegistry)

STATIC NDIS_STATUS
MadgeReadRegistry(
    NDIS_HANDLE    wrapperConfigHandle,
    NDIS_HANDLE    registryConfigHandle,
    PMADGE_ADAPTER ndisAdap
    )
{
    NDIS_STATUS                     status;
    PNDIS_CONFIGURATION_PARAMETER   configParam;
    MADGE_PARM_DEFINITION         * pMadgeParmTable;
    PVOID                           networkAddress;
    ULONG                           networkAddressLength;
    UINT                            adapterType;
    UINT                            platformType;

    //
    // Try to read the OS platform type. If we don't find one then 
    // assume we are running on NT.
    //

    NdisReadConfiguration(
	&status,
	&configParam,
	registryConfigHandle,
	&PlatformString,
	NdisParameterInteger
	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        platformType = MADGE_OS_NT;
    }
    else
    {
        platformType = configParam->ParameterData.IntegerData;
    }

    //
    // Read the system bus type - that will give us a direction
    // in which to search for further details.
    //

    NdisReadConfiguration(
	&status,
	&configParam,
	registryConfigHandle,
	&BusTypeString,
	NdisParameterInteger
	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
            2,
            readRegistry,
            MADGE_ERRMSG_NO_BUS_TYPE
            );

	return status;
    }

    ndisAdap->BusType = configParam->ParameterData.IntegerData;

    //
    // Originally we determined what sort of adapter we had based
    // on the bus type returned by the configuration call to the
    // wrapper. This works for NT but doesn't for Windows95 (M7)
    // which seems to fail to identify a card as being in a PCI
    // bus. We also cannot tell between the various sorts of ISA
    // adapter now available. To fix this we look in the registry 
    // for an adapter type parameter. We use this and the bus type
    // returned by the wrapper to work out where to start. We don't
    // fail if we can't read an adapter type so that we will work with
    // old registry set ups.
    //
    // Build 310 of Windows95 seems to return the native bus type of the 
    // PC. This means on a PCI machine we always get NdisInterfacePci.
    // To get around this problem we will work out the bus type from 
    // the adapter type parameter if one is present.
    //
    // Unfortunately we can't just abandon the bus type de-multiplexing
    // if we are to work with old NT registry set ups.
    //

    NdisReadConfiguration(
	&status,
	&configParam,
	registryConfigHandle,
	&AdapterString,
	NdisParameterInteger
	);

    if (status != NDIS_STATUS_SUCCESS)
    {
        adapterType = MADGE_ADAPTER_UNKNOWN;
    }
    else
    {
        adapterType = configParam->ParameterData.IntegerData;
    }

    switch (adapterType)
    {
        case MADGE_ADAPTER_ATULA:
        case MADGE_ADAPTER_PCMCIA:
        case MADGE_ADAPTER_PNP:
        case MADGE_ADAPTER_SMART16:

            ndisAdap->BusType = NdisInterfaceIsa;
            break;

        case MADGE_ADAPTER_EISA:

            ndisAdap->BusType = NdisInterfaceEisa;
            break;

        case MADGE_ADAPTER_MC:

            ndisAdap->BusType = NdisInterfaceMca;
            break;

        case MADGE_ADAPTER_PCI:

            ndisAdap->BusType = NdisInterfacePci;
            break;

        default:

            //
            // We don't have a valid adapter type parameter so we'll
            // just have to beleive the bus type the wrapper passed
            // us.
            //

            break;
    }

    //
    // Based on the determined Bus Type, try to find details of the card.
    //

    //
    // Remember, all fields of the MADGE_ADAPTER structure were zeroed
    // after the structure's allocation.
    //

    switch (ndisAdap->BusType)
    {
	case NdisInterfaceMca:

            status = MadgeReadRegistryForMC(
                         wrapperConfigHandle,
                         registryConfigHandle,
                         ndisAdap
                         );

	    if (status != NDIS_STATUS_SUCCESS)
	    {
		return status;
	    }

	    break;

	case NdisInterfaceEisa:

            //
	    // For Eisa bus systems, we could have an Isa card or an Eisa
	    // card - try to read the Eisa information, and if that fails
	    // assume it is an Isa card instead.
            //

            status = MadgeReadRegistryForEISA(
                         wrapperConfigHandle,
                         registryConfigHandle,
                         ndisAdap
                         );

            if (status == NDIS_STATUS_SUCCESS)
            {
                break;
            }

            //
	    // Failed to read EISA data for this card, so it is unlikely 
	    // to be one - try ISA instead - fall through.
            //

	case NdisInterfaceIsa:

            status = MadgeReadRegistryForISA(
                         wrapperConfigHandle,
                         registryConfigHandle,
                         ndisAdap,
                         adapterType
                         );

	    if (status != NDIS_STATUS_SUCCESS)
	    {
		return status;
	    }

	    break;

        case NdisInterfacePci:

            status = MadgeReadRegistryForPCI(
                         wrapperConfigHandle,
                         registryConfigHandle,
                         ndisAdap,
                         platformType
                         );

	    if (status != NDIS_STATUS_SUCCESS)
	    {
		return status;
	    }

	    break;


	default:

            //
	    // Unsupported Bus Type, so return failure - no point being more 
	    // explicit than that at the moment since any of the bits above  
	    // could have failed too, and they do not return anything more
	    // meaningful either. 
            //

	    return NDIS_STATUS_FAILURE;
    }

    MadgePrint2("FTKCardBusType  = %d\n", ndisAdap->FTKCardBusType);
    MadgePrint2("SlotNumber      = %d\n", ndisAdap->SlotNumber);
    MadgePrint2("IoLocation1     = %lx\n", ndisAdap->IoLocation1);
    MadgePrint2("MmioAddress     = %lx\n", ndisAdap->MmioRawAddress);
    MadgePrint2("InterruptNumber = %lx\n", ndisAdap->UsedInISR.InterruptNumber);
    MadgePrint2("TransferMode    = %d\n", ndisAdap->TransferMode);
    MadgePrint2("DmaChannel      = %d\n", ndisAdap->DmaChannel);

    //
    // To get here, we must have worked out the IO Address, IRQ number, DMA
    // channel/arbitration level, and all the interrupt details. This just
    // leaves the optional parameters for tuning the performance of the MAC
    // code.
    //

    pMadgeParmTable = (MADGE_PARM_DEFINITION *) &MadgeParmTable;

    while (!NdisEqualString(&pMadgeParmTable->Keyword, &NullString, TRUE))
    {
	NdisReadConfiguration(
	    &status,
	    &configParam,
	    registryConfigHandle,
	    &pMadgeParmTable->Keyword,
	    pMadgeParmTable->DefaultValue.ParameterType
	    );

	if (status == NDIS_STATUS_SUCCESS)
	{
            //
	    // Did read something. Check bounds. We assume all are Integers.
            //

	    if (configParam->ParameterData.IntegerData < 
                    pMadgeParmTable->Minimum ||
		configParam->ParameterData.IntegerData > 
                    pMadgeParmTable->Maximum)
            {
                NdisWriteErrorLogEntry(
                    ndisAdap->UsedInISR.MiniportHandle,
                    NDIS_ERROR_CODE_DRIVER_FAILURE,
                    2,
                    readRegistry,
                    MADGE_ERRMSG_BAD_PARAMETER
                    );

	        pMadgeParmTable->ActualValue = pMadgeParmTable->DefaultValue;
            }
            else
            {
	        pMadgeParmTable->ActualValue = *configParam;
            }
	}
	else
	{
            //
	    // We didn't read anything, so use the default value.
            //

	    pMadgeParmTable->ActualValue = pMadgeParmTable->DefaultValue;
	}

	pMadgeParmTable++;
    }
      
    //                                                    
    // We have successfully read any optional keywords and none of them is 
    // too small or big. The other thing we need the registry for is the 
    // locally administered address, for which there is a specific NDIS call
    //

    NdisReadNetworkAddress( 
        &status,
	&networkAddress,
	&networkAddressLength,
	registryConfigHandle
        );

    if (status               == NDIS_STATUS_SUCCESS &&
	networkAddressLength == TR_LENGTH_OF_ADDRESS)
    {
        //
	// We read a valid length TR address, but if the
	// top two bits are not "01", it is not legal.
        //

	if ((((BYTE *) networkAddress)[0] & 0xc0) == 0x40)
	{
	    ndisAdap->OpeningNodeAddress =
                *((NODE_ADDRESS *) networkAddress);
	}
    }

    return NDIS_STATUS_SUCCESS;
}


/****************************************************************************
*
* Function    - MadgeShutdown
*
* Parameters  - context -> Adapter context.
*
* Purpose     - Quickly shutdown the adapter.
*
* Returns     - Nothing.
*
****************************************************************************/

VOID
MadgeShutdown(
    NDIS_HANDLE context
    )
{
    MADGE_ADAPTER * ndisAdap;

    ndisAdap = PMADGE_ADAPTER_FROM_CONTEXT(context);

    MadgePrint1("MadgeShutdown called\n");

    if (ndisAdap->TimerInitialized)
    {
        BOOLEAN timerOutstanding;
        
        NdisMCancelTimer(&ndisAdap->WakeUpTimer, &timerOutstanding);
        NdisMCancelTimer(&ndisAdap->CompletionTimer, &timerOutstanding);
        
        ndisAdap->TimerInitialized = FALSE;
    }

    //
    // Just call the FTK to shutdown the adapter.
    //

    if (ndisAdap->FtkInitialized)
    {
        rxtx_await_empty_tx_slots(ndisAdap->FtkAdapterHandle);
        driver_remove_adapter(ndisAdap->FtkAdapterHandle);
        ndisAdap->FtkInitialized = FALSE;
        ndisAdap->AdapterRemoved = TRUE;
    }

    MadgePrint1("MadgeShutdown ended\n");
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeRegisterAdapter
|
| Parameters  - ndisAdap             -> Pointer to an NDIS3 level adapter
|                                       structure.
|               wrapperConfigHandle  -> Wrapper context handle.
|
| Purpose     - Register an adapter instance with the NDIS3 wrapper.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeRegisterAdapter(
    PMADGE_ADAPTER ndisAdap,
    NDIS_HANDLE    wrapperConfigHandle
    );

#pragma FTK_INIT_FUNCTION(MadgeRegisterAdapter)

STATIC NDIS_STATUS
MadgeRegisterAdapter(
    PMADGE_ADAPTER ndisAdap,
    NDIS_HANDLE    wrapperConfigHandle
    )
{
    NDIS_STATUS status;
    BOOLEAN     busMaster;

    MadgePrint1("MadgeRegisterAdapter started\n");

    //
    // Register a shutdown handler with the wrapper.
    //

    NdisMRegisterAdapterShutdownHandler(
        ndisAdap->UsedInISR.MiniportHandle,
        ndisAdap,
        MadgeShutdown
        );

    ndisAdap->ShutdownHandlerRegistered = TRUE;

    //
    // Register our attributes with the wrapper. These are our adapter
    // context (i.e. a pointer to our adapter structure), whether we
    // are a bus master device and our bus type.
    //

    busMaster = (ndisAdap->TransferMode == DMA_DATA_TRANSFER_MODE);

    MadgePrint1("NdisMSetAttributes called\n");
    MadgePrint2("busMaster = %d\n", (UINT) busMaster);

    NdisMSetAttributes(
        ndisAdap->UsedInISR.MiniportHandle,
        (NDIS_HANDLE) ndisAdap,
        busMaster,
        ndisAdap->NTCardBusType
        );

    MadgePrint1("NdisMSetAttributes returned\n");

    //
    // Register our IO port usage. 
    //

    MadgePrint1("NdisMRegisterIoPortRange called\n");

    status = NdisMRegisterIoPortRange(
                 &ndisAdap->MappedIOLocation1,
                 ndisAdap->UsedInISR.MiniportHandle,
                 ndisAdap->IoLocation1 + ndisAdap->IoLocationBase,
                 ndisAdap->IORange1
                 );

    MadgePrint1("NdisMRegisterIoPortRange returned\n");
    MadgePrint2("MappedIORange1 = %x\n", (UINT) ndisAdap->MappedIOLocation1);

    if (status != NDIS_STATUS_SUCCESS)
    {
        MadgePrint2("NdisMRegisterIoPortRange failed rc = %x\n", status);
        return status;
    }

    ndisAdap->IORange1Initialized = TRUE;

    //
    // If we are using an EISA card then we have a second range of IO
    // locations.
    //

    if (ndisAdap->IORange2 > 0)
    {
        MadgePrint1("NdisMRegisterIoPortRange called\n");

        status = NdisMRegisterIoPortRange(
                     &ndisAdap->MappedIOLocation2,
                     ndisAdap->UsedInISR.MiniportHandle,
                     ndisAdap->IoLocation2 + ndisAdap->IoLocationBase,
                     ndisAdap->IORange2
                     );

        MadgePrint1("NdisMRegisterIoPortRange returned\n");
        MadgePrint2("MappedIORange2 = %x\n", (UINT) ndisAdap->MappedIOLocation2);

        if (status != NDIS_STATUS_SUCCESS)
        {
            MadgePrint2("NdisMRegisterIoPortRange failed rc = %x\n", status);
            return status;
        }

        ndisAdap->IORange2Initialized = TRUE;
    }

    MadgePrint1("MadgeRegisterAdapter finished\n");

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - FlagIsTrue
|
| Parameters  - flag -> Pointer to a flag to find the value of.
|
| Purpose     - Return the value of a flag. Can be called by a function
Ý               that polls a flag to avoid the compiler optimising out
Ý               the test of the flag.
|
| Returns     - The value of the flag.
|
|--------------------------------------------------------------------------*/

STATIC BOOLEAN
FlagIsTrue(BOOLEAN * flag);

#pragma FTK_INIT_FUNCTION(FlagIsTrue)

STATIC BOOLEAN
FlagIsTrue(BOOLEAN * flag)
{
    MadgePrint1("FlagIsTrue\n");

    return *flag;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeMapMmioMemory
|
| Parameters  - ndisAdap -> Pointer to an NDIS3 level adapter structure.
|
| Purpose     - Attempt to map in our MMIO memory.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeMapMmioMemory(PMADGE_ADAPTER ndisAdap);

#pragma FTK_INIT_FUNCTION(MadgeMapMmioMemory)

STATIC NDIS_STATUS
MadgeMapMmioMemory(PMADGE_ADAPTER ndisAdap)
{
    NDIS_PHYSICAL_ADDRESS mmioPhysAddr = NDIS_PHYSICAL_ADDRESS_CONST(0, 0);
    UINT                  status;

    NdisSetPhysicalAddressLow(
        mmioPhysAddr,
        ndisAdap->MmioRawAddress
        );
          
    status = NdisMMapIoSpace(
                 &ndisAdap->MmioVirtualAddress,
                 ndisAdap->UsedInISR.MiniportHandle,
                 mmioPhysAddr,
                 PCI_MMIO_SIZE
                 );

    if (status != NDIS_STATUS_SUCCESS) 
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_MEMORY_CONFLICT,
            2,
            initAdapter,
            MADGE_ERRMSG_MAPPING_PCI_MMIO
            );
    }
    else
    {
        ndisAdap->MmioMapped = TRUE;
    }

    return status;
}


#ifndef LINK_FMPLUS

/*---------------------------------------------------------------------------
|
| Function    - MadgeReadDownload
|
| Parameters  - ndisAdap     -> Pointer to an NDIS3 level adapter structure.
Ý               downloadFile -> Pointer to as handle for the download file.
|               download     -> Pointer to a holder for a pointer to the
Ý                               download image read into memory.
Ý
| Purpose     - Read the download into memory. If the function returns
Ý               success then must unmap and close *downloadFile.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeReadDownload(
    PMADGE_ADAPTER     ndisAdap,
    NDIS_HANDLE      * downloadFile,
    void           * * download
    );

#pragma FTK_INIT_FUNCTION(MadgeReadDownload)

STATIC NDIS_STATUS
MadgeReadDownload(
    PMADGE_ADAPTER     ndisAdap,
    NDIS_HANDLE      * downloadFile,
    void           * * download
    )
{
    NDIS_STATUS            status;
    NDIS_HANDLE            imageFile;
    UINT                   imageLength;
    PVOID                  imagePtr;
    NDIS_PHYSICAL_ADDRESS  highestAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
    DOWNLOAD_FILE_HEADER * downHdrPtr;
    UCHAR                * chkPtr;
    ULONG                  chkSum;
    UINT                   i;

    //
    // Open the FastMAC Plus image file.
    //

    MadgePrint1("NdisOpenFile called\n");

    NdisOpenFile(
        &status, 
        &imageFile, 
        &imageLength, 
        &FmpImageFileName, 
        highestAddress
        );

    MadgePrint1("NdisOpenFile returned\n");

    if (status != NDIS_STATUS_SUCCESS)
    {
        MadgePrint2("NdisOpenFile failed rc= %x\n", status);

        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_INVALID_DOWNLOAD_FILE_ERROR,
            2,
            initAdapter,
            MADGE_ERRMSG_OPEN_IMAGE_FILE
            );

        return NDIS_STATUS_RESOURCES;
    }

    //
    // Map in the FastMAC Plus image file.
    //

    NdisMapFile(&status, &imagePtr, imageFile);

    if (status != NDIS_STATUS_SUCCESS)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_OUT_OF_RESOURCES,
            2,
            initAdapter,
            MADGE_ERRMSG_MAP_IMAGE_FILE
            );

        NdisCloseFile(imageFile);

        return NDIS_STATUS_RESOURCES;
    }

    //
    // Make sure that the image file is valid by checking its checksum,
    // version number and signature.
    //

    downHdrPtr = (DOWNLOAD_FILE_HEADER *) imagePtr;
    chkPtr     = ((UCHAR *) imagePtr) + DOWNLOAD_CHECKSUM_SKIP;
    chkSum     = 0;

    for (i = DOWNLOAD_CHECKSUM_SKIP; i < imageLength; i++)
    {
        DOWNLOAD_CHECKSUM_BYTE(chkSum, *chkPtr);
        chkPtr++;
    }

    if (!IS_DOWNLOAD_OK(downHdrPtr, chkSum))
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_INVALID_DOWNLOAD_FILE_ERROR,
            2,
            initAdapter,
            MADGE_ERRMSG_BAD_IMAGE_FILE
            );

        NdisUnmapFile(imageFile);
        NdisCloseFile(imageFile);

        return NDIS_STATUS_RESOURCES;
    }

    *downloadFile = imageFile;
    *download     = imagePtr;

    return NDIS_STATUS_SUCCESS;
}

#else

#include "fmplus.c"

#endif

#ifdef _M_IX86

/*---------------------------------------------------------------------------
|
| Function    - MadgeArbitrateBufferMemory
|
| Parameters  - ndisAdap -> Pointer to an NDIS3 level adapter structure.
|
| Purpose     - Determine if we can allocate all the shared memory
Ý               we need for DMA buffer space and if we can't then
Ý               reduce our requirements until we can or we reach
Ý               our minimum requirements. If the buffer space cannot
Ý               be aribtrated then the requirements are left as is and
Ý               it is assumed that the FTK initialisation will fail
Ý               and generate an out of memory error.
|
| Returns     - Nothing.
|
|--------------------------------------------------------------------------*/

STATIC VOID
MadgeArbitrateBufferMemory(PMADGE_ADAPTER ndisAdap);

#pragma FTK_INIT_FUNCTION(MadgeArbitrateBufferMemory)

STATIC VOID
MadgeArbitrateBufferMemory(PMADGE_ADAPTER ndisAdap)
{
    VOID                  * testVirt;
    VOID                  * rxVirt;
    VOID                  * txVirt;
    NDIS_PHYSICAL_ADDRESS   testPhys;
    NDIS_PHYSICAL_ADDRESS   rxPhys;
    NDIS_PHYSICAL_ADDRESS   txPhys;
    ULONG                   rxBufferSize;
    ULONG                   txBufferSize;
    UINT                    maxFrameSize;
    UINT                    rxSlots;
    UINT                    txSlots;
    BOOLEAN                 succeeded;
    BOOLEAN                 failed;
    BOOLEAN                 arbitrated;

    //
    // There doesn't seem to be a problem allocating none
    // shared memory so if we aren't in DMA mode then 
    // don't do anything.
    //

    if (ndisAdap->TransferMode != DMA_DATA_TRANSFER_MODE)
    {
        return;
    }

    //
    // The first bit of shared memory we must have is for the DMA
    // test buffers.
    //

    testVirt = NULL;

    NdisMAllocateSharedMemory(
        ndisAdap->UsedInISR.MiniportHandle,
        SCB_TEST_PATTERN_LENGTH + SSB_TEST_PATTERN_LENGTH,
        FALSE,
        &testVirt,
        &testPhys
        );

    //
    // If we can't allocate the test buffer then just give up.
    //

    if (testVirt == NULL)
    {
        return;
    }

    //
    // We've got the test buffer memory so now arbitrate the 
    // RX/TX buffers. Note: the buffer allocation MUST MATCH
    // THAT IN FTK_USER.C.
    //

    maxFrameSize = ndisAdap->MaxFrameSize;
    rxSlots      = ndisAdap->FastmacRxSlots;
    txSlots      = ndisAdap->FastmacTxSlots;

    failed       = FALSE;
    succeeded    = FALSE;
    arbitrated   = FALSE;

    while (!failed && !succeeded)
    {
        rxVirt = NULL;
        txVirt = NULL;

        //
        // Try to allocate the receive buffer.
        //

        rxBufferSize = ((maxFrameSize + 4 + 32 + 3) & ~3) * rxSlots;
        
        NdisMAllocateSharedMemory(
            ndisAdap->UsedInISR.MiniportHandle,
            rxBufferSize,
            FALSE,
            &rxVirt,
            &rxPhys
            );

        //
        // If we allocated the RX buffer space then try to allocate
        // the TX buffer space.
        //

        if (rxVirt != NULL)
        {
            txBufferSize = ((maxFrameSize + 3) & ~3) * txSlots;

            NdisMAllocateSharedMemory(
                ndisAdap->UsedInISR.MiniportHandle,
                txBufferSize,
                FALSE,
                &txVirt,
                &txPhys
                );
        }

        //
        // Free any buffers we managed to allocate.
        //

        if (rxVirt != NULL)
        {
            NdisMFreeSharedMemory(
                ndisAdap->UsedInISR.MiniportHandle,
                rxBufferSize,
                FALSE,
                rxVirt,
                rxPhys
                );
        }

        if (txVirt != NULL)
        {
            NdisMFreeSharedMemory(
                ndisAdap->UsedInISR.MiniportHandle,
                txBufferSize,
                FALSE,
                txVirt,
                txPhys
                );
        }

        //
        // If we managed to allocate both buffers then we have
        // succeeded.
        //

        if (rxVirt != NULL && txVirt != NULL)
        {
            succeeded = TRUE;
        }

        //
        // Otherwise we must reduce our memory requirements.
        //

        else
        {
            arbitrated = TRUE;

            //
            // First try reducing the number of transmit slots.
            //

            if (txSlots > FMPLUS_MIN_TX_SLOTS)
            {
                txSlots--;
            }

            //
            // Next try reducing the number of receive slots.
            //

            else if (rxSlots > FMPLUS_MIN_RX_SLOTS)
            {
                rxSlots--;
            }

            //
            // Finally try reducing the frame size. 1800 bytes has
            // empirically shown to be the minimum value required
            // for the DOMAIN server startup to work at NT installation.
            //

            else if (maxFrameSize > 1800)
            {
                maxFrameSize -= 512;

                if (maxFrameSize < 1800)
                {
                    maxFrameSize = 1800;
                }
            }

            //
            // If we can't reduce our buffer requirements any further
            // then fail.
            //

            else
            {
                failed = TRUE;
            }
        }
    }

    //
    // Free the memory for the DMA test buffer.
    //

    NdisMFreeSharedMemory(
        ndisAdap->UsedInISR.MiniportHandle,
        SCB_TEST_PATTERN_LENGTH + SSB_TEST_PATTERN_LENGTH,
        FALSE,
        testVirt,
        testPhys
        );

    //
    // If we have succeded then we must update the requirements in 
    // adapter structure and if we have changed any values we must
    // write a message to the event log.
    //

    if (succeeded && arbitrated)
    {
        ndisAdap->MaxFrameSize   = maxFrameSize;
        ndisAdap->FastmacRxSlots = rxSlots;
        ndisAdap->FastmacTxSlots = txSlots;

        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
            1,
            initAdapter
            );
    }
}

#endif


/*---------------------------------------------------------------------------
|
| Function    - MadgeInitAdapter
|
| Parameters  - ndisAdap -> Pointer to an NDIS3 level adapter structure.
|
| Purpose     - Initialise an adapter.
|
| Returns     - An NDIS3 status code.
|
|--------------------------------------------------------------------------*/

STATIC NDIS_STATUS
MadgeInitAdapter(PMADGE_ADAPTER ndisAdap);

#pragma FTK_INIT_FUNCTION(MadgeInitAdapter)

STATIC NDIS_STATUS
MadgeInitAdapter(PMADGE_ADAPTER ndisAdap)
{
    WORD         ftkStatus;
    NDIS_STATUS  status;
    PREPARE_ARGS prepare;
    START_ARGS   start;

#ifndef LINK_FMPLUS

    NDIS_HANDLE  imageFile;
    PVOID        imagePtr;

#endif

    MadgePrint1("MadgeInitAdapter started\n");

    //
    // If we are doing MMIO then we need to map in the MMIO memory.
    // If we fail to map in the memory then default ti PIO.
    //

    if (ndisAdap->TransferMode == MMIO_DATA_TRANSFER_MODE)
    {
        if (MadgeMapMmioMemory(ndisAdap) != NDIS_STATUS_SUCCESS)
        {
            ndisAdap->TransferMode = PIO_DATA_TRANSFER_MODE;
        }
    }

#ifdef _M_IX86

    //
    // Arbitrate "DMA" buffer memory.
    //

    MadgeArbitrateBufferMemory(ndisAdap);

#endif

    //
    // Set up the arguments to pass to driver_prepare_adapter.
    //

    MADGE_ZERO_MEMORY(&prepare, sizeof(PREPARE_ARGS));

    prepare.user_information   = (void *) ndisAdap;
    prepare.number_of_rx_slots = (WORD) ndisAdap->FastmacRxSlots;
    prepare.number_of_tx_slots = (WORD) ndisAdap->FastmacTxSlots;
    prepare.max_frame_size     = (WORD) ndisAdap->MaxFrameSize;

    //
    // Try to prepare the adapter for use.
    //

    //
    // Mark the fact that the FTK has been called, so that we know if we
    // have to call driver_remove_adapter() when doing clean up.
    //

    ndisAdap->FtkInitialized = TRUE;

    MadgePrint1("driver_prepare_adapter called\n");

    if (!driver_prepare_adapter(&prepare, &(ndisAdap->FtkAdapterHandle)))
    {
	return NDIS_STATUS_FAILURE;
    }

    MadgePrint1("driver_prepare_adapter returned\n");
    MadgePrint2("adapter_handle = %d\n", ndisAdap->FtkAdapterHandle);

#ifndef LINK_FMPLUS

    //
    // Read in the download file.
    //

    status = MadgeReadDownload(ndisAdap, &imageFile, &imagePtr);

    if (status != NDIS_STATUS_SUCCESS)
    {
        return status;
    }

#endif

    //
    // Set up the arguments to driver_start_adapter.
    //

    MADGE_ZERO_MEMORY(&start, sizeof(START_ARGS));

    start.adapter_card_bus_type = (UINT) ndisAdap->FTKCardBusType;

    start.io_location           = (WORD) ndisAdap->IoLocation1;
    start.transfer_mode         = (UINT) ndisAdap->TransferMode;
    start.dma_channel           = (WORD) ndisAdap->DmaChannel;
    start.interrupt_number      = (WORD) ndisAdap->UsedInISR.InterruptNumber;
    start.set_dma_channel       = TRUE;
    start.set_interrupt_number  = TRUE;
    start.mmio_base_address     = (DWORD) ndisAdap->MmioVirtualAddress;
    start.pci_handle            = (DWORD) ndisAdap->SlotNumber;

    if (ndisAdap->Force16)
    {
        start.set_ring_speed = 16;
    }
    else if (ndisAdap->Force4)
    {
        start.set_ring_speed = 4;
    }

    start.opening_node_address = ndisAdap->OpeningNodeAddress;
    start.auto_open_option     = TRUE;

    if (ndisAdap->ForceOpen)
    {
        ndisAdap->OpenOptions |= OPEN_OPT_FORCE_OPEN;
    }

    start.open_options      = (WORD) ndisAdap->OpenOptions;

    start.rx_tx_buffer_size = (WORD) ndisAdap->CardBufferSize;

#ifndef LINK_FMPLUS

    start.code = (DOWNLOAD_IMAGE *) 
                     (((UCHAR *) imagePtr) + sizeof(DOWNLOAD_FILE_HEADER));

#else

    start.code = (DOWNLOAD_IMAGE *) fmplus_image;

#endif

    MadgePrint1("driver_start_adapter called\n");

    ftkStatus = driver_start_adapter(
                    ndisAdap->FtkAdapterHandle,
                    &start,
                    &ndisAdap->PermanentNodeAddress
                    );

    MadgePrint1("driver_start_adapter returned\n");
    MadgePrint2("MAC buffer size = %d\n", 
        adapter_record[ndisAdap->FtkAdapterHandle
            ]->init_block->smart_parms.rx_tx_buffer_size
            );

#ifndef LINK_FMPLUS

    //
    // No matter what we have finished with the FastMAC Plus image file.
    //

    NdisUnmapFile(imageFile);
    NdisCloseFile(imageFile);

#endif

    if (!ftkStatus)
    {
        MadgePrint1("driver_start_adapter failed\n");

        //
        // Were it not for the fact that we are going to clean up and fail
        // as soon as we return, we ought to set the CurrentRingState to
        // NdisRingStateOpenFailure here if AutoOpen was selected.
        //

        return NDIS_STATUS_FAILURE;
    }

    //
    // Warn the user if FastMAC Plus had to reduce the frame size.
    //

    if (ndisAdap->MaxFrameSize > start.max_frame_size)
    {
        NdisWriteErrorLogEntry(
            ndisAdap->UsedInISR.MiniportHandle,
            NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
            3,
            initAdapter,
            MADGE_ERRMSG_REDUCE_MAX_FSIZE,
            ndisAdap->MaxFrameSize
            );
    }

    ndisAdap->MaxFrameSize = start.max_frame_size;

    //
    // If we did not specify a locally administered address then copy the
    // permanent one across to the local one.
    //

    if (ndisAdap->OpeningNodeAddress.byte[0] == 0)
    {
        MADGE_MOVE_MEMORY(
            &ndisAdap->OpeningNodeAddress,
            &ndisAdap->PermanentNodeAddress,
            sizeof(ndisAdap->PermanentNodeAddress)
            );
    }

    //
    // Note that the adapter is open.
    //

    ndisAdap->CurrentRingState = NdisRingStateOpened;
    ndisAdap->LastOpenStatus   = start.open_status;

    //
    // Nasty hack. If we have a PciT atapter with broken dma and we are 
    // running on a multiprocessor we need set the multiprocessor safe
    // PIO flag to make sure that we don't do DIO whilst our interrupt
    // hander is running. Unfortunately we don't know if we have
    // broken DMA until after we've started the adapter.
    //  

    if (ndisAdap->Multiprocessor && 
        adapter_record[ndisAdap->FtkAdapterHandle]->mc32_config == 
            TRN_PCIT_BROKEN_DMA)
    {
        MadgePrint1("Using MP sfae PIO because of PCIT DMA.\n");
        ndisAdap->UseMPSafePIO = TRUE;
    }

    //
    // Note that we MUST start the receive process, even if we are NOT using
    // auto-open, because FastmacPlus ignores SRBs (including OPEN SRBs) if 
    // this has not been done.
    //

    driver_start_receive_process(ndisAdap->FtkAdapterHandle);

    //
    // We now need to set the product instance ID. The product instance
    // ID will be set to the contents of ftk_product_inst_id[] if we
    // issue an open SRB, but since Miniports always auto-open we 
    // need to generate a set product instance SRB to set it.
    //

    //
    // Note that we are generating a private SRB (not to be treated
    // as a normal NDIS request), generate the SRB and then wait
    // for it to finish.
    //

    ndisAdap->PrivateSrbInProgress = TRUE;

    MadgePrint1("Calling driver_set_product_instance_id\n");

    driver_set_product_instance_id(
        ndisAdap->FtkAdapterHandle, 
        NT_PRODUCT_INSTANCE_ID
        );

    MadgePrint1("Waiting for SRB to complete\n");

    while (FlagIsTrue(&ndisAdap->PrivateSrbInProgress))
		NdisMSleep(100);

    MadgePrint1("MadgeInitAdapter finished\n");

    return NDIS_STATUS_SUCCESS;
}


/*---------------------------------------------------------------------------
|
| Function    - MadgeCleanupAdapter
|
| Parameters  - ndisAdap -> Pointer to an NDIS3 level adapter structure.
|
| Purpose     - Deallocate the resources associated with an adapter.
|
| Returns     - Nothing.
|
|--------------------------------------------------------------------------*/

STATIC VOID
MadgeCleanupAdapter(PMADGE_ADAPTER ndisAdap)
{
    BOOLEAN timerOutstanding;

    MadgePrint1("MadgeCleanupAdapter 1\n");

    if (ndisAdap->TimerInitialized)
    {
        NdisMCancelTimer(&ndisAdap->WakeUpTimer, &timerOutstanding);
        NdisMCancelTimer(&ndisAdap->CompletionTimer, &timerOutstanding);
        ndisAdap->TimerInitialized = FALSE;
    }

    MadgePrint1("MadgeCleanupAdapter 2\n");

    if (ndisAdap->FtkInitialized)
    {
        rxtx_await_empty_tx_slots(ndisAdap->FtkAdapterHandle);
        driver_remove_adapter(ndisAdap->FtkAdapterHandle);
        ndisAdap->FtkInitialized = FALSE;
    }
    
    if (ndisAdap->MapRegistersAllocated > 0)
    {
  	    NdisMFreeMapRegisters(ndisAdap->UsedInISR.MiniportHandle);
  	    ndisAdap->MapRegistersAllocated = 0;
    }

    MadgePrint1("MadgeCleanupAdapter 3\n");

    if (ndisAdap->MmioMapped)
    {
        NdisMUnmapIoSpace(
            ndisAdap->UsedInISR.MiniportHandle,
            ndisAdap->MmioVirtualAddress,
            PCI_MMIO_SIZE
            );
        ndisAdap->MmioMapped = FALSE;
    }

    MadgePrint1("MadgeCleanupAdapter 4\n");

    if (ndisAdap->IORange1Initialized)
    {
        NdisMDeregisterIoPortRange(
            ndisAdap->UsedInISR.MiniportHandle,
            ndisAdap->IoLocation1 + ndisAdap->IoLocationBase,
            ndisAdap->IORange1,
            ndisAdap->MappedIOLocation1
            );
        ndisAdap->IORange1Initialized = FALSE;
    }

    MadgePrint1("MadgeCleanupAdapter 5\n");

    if (ndisAdap->IORange2Initialized)
    {
        NdisMDeregisterIoPortRange(
            ndisAdap->UsedInISR.MiniportHandle,
            ndisAdap->IoLocation2 + ndisAdap->IoLocationBase,
            ndisAdap->IORange2,
            ndisAdap->MappedIOLocation2
            );
        ndisAdap->IORange2Initialized = FALSE;
    }

    MadgePrint1("MadgeCleanupAdapter 6\n");

    if (ndisAdap->ShutdownHandlerRegistered)
    {
        NdisMDeregisterAdapterShutdownHandler(
            ndisAdap->UsedInISR.MiniportHandle
            );
        ndisAdap->ShutdownHandlerRegistered = FALSE;

        MadgePrint1("De-registered shutdown handler\n");
    }
   
    MADGE_FREE_MEMORY(ndisAdap, sizeof(MADGE_ADAPTER));
}


/***************************************************************************
*
* Function    - MadgeHalt
*
* Parameters  - adapterContext -> Pointer to our NDIS level adapter 
*                                 structure.
*
* Purpose     - Process a call from the NDIS3 wrapper to remove an
*               adapter instance.
*
* Returns     - Nothing.
*
****************************************************************************/

VOID
MadgeHalt(NDIS_HANDLE adapterContext)
{
    PMADGE_ADAPTER ndisAdap;

    MadgePrint1("MadgeHalt started\n");

    ndisAdap = PMADGE_ADAPTER_FROM_CONTEXT(adapterContext);

    //
    // The NDIS interface guarantees that all bindings are closed, i.e. all
    // MadgeCloseAdapter calls have completed successfully.
    //

    ndisAdap->HardwareStatus = NdisHardwareStatusClosing;

    MadgeCleanupAdapter(ndisAdap);

    MadgePrint1("MadgeHalt finished\n");
}


/****************************************************************************
*
* Function    - MadgeTxCompletion
*
* Parameters  - systemSpecific1 -> Unused.
*               context         -> Actually a pointer to our NDIS3 level
*                                  adapter structure.
*               systemSpecific2 -> Unused.
*               systemSpecific3 -> Unused.
*
* Purpose     - Call our TX competion routine as a result of a timer.
*
* Returns     - Nothing.
*
****************************************************************************/

VOID
MadgeTxCompletion(
    PVOID systemSpecific1,
    PVOID context,
    PVOID systemSpecific2,
    PVOID systemSpecific3
    )
{
    PMADGE_ADAPTER ndisAdap = (PMADGE_ADAPTER) context;
    
    //
    // Call the TX completion function.
    //
    
    rxtx_irq_tx_completion_check(
        ndisAdap->FtkAdapterHandle,
        adapter_record[ndisAdap->FtkAdapterHandle]
        );
}


/***************************************************************************
*
* Function    - MadgeInitialise
*
* Parameters  - openErrorStatus      -> Pointer to a holder for an open
*                                       error status.
*               selectedMediumIndex  -> Pointer to a holder for the index
*                                       of the medium selected.
*               mediumArray          -> Array of media types.
*               mediumArraySize      -> Size of the media array.
*               miniportHandle       -> Miniport adapter handle.
*               wrapperConfigContext -> Handle used when querying the 
*                                       registry.
*
* Purpose     - Carry out adapter instance initialisation.
*
* Returns     - An NDIS3 status code.
*
***************************************************************************/

NDIS_STATUS
MadgeInitialize(
    PNDIS_STATUS openErrorStatus,
    PUINT        selectedMediumIndex,
    PNDIS_MEDIUM mediumArray,
    UINT         mediumArraySize,
    NDIS_HANDLE  miniportHandle,
    NDIS_HANDLE  wrapperConfigContext
    );

#pragma FTK_INIT_FUNCTION(MadgeInitialize)

NDIS_STATUS
MadgeInitialize(
    PNDIS_STATUS openErrorStatus,
    PUINT        selectedMediumIndex,
    PNDIS_MEDIUM mediumArray,
    UINT         mediumArraySize,
    NDIS_HANDLE  miniportHandle,
    NDIS_HANDLE  wrapperConfigContext
    )
{
    NDIS_STATUS    status;
    PMADGE_ADAPTER ndisAdap;
    NDIS_HANDLE    configHandle;
    UINT           i;

    MadgePrint1("MadgeInitialize started\n");

    //
    // ---------------------------------------------------------------------
    // Check that the upper protocol knows about token ring and if
    // it does set the index.
    //

    for (i = 0; i < mediumArraySize; i++)
    {
	if (mediumArray[i] == NdisMedium802_5)
        {
	    break;
        }
    }
	
    if (i == mediumArraySize)
    {
	return NDIS_STATUS_UNSUPPORTED_MEDIA;
    }
	
    *selectedMediumIndex = i;

    //
    // ---------------------------------------------------------------------
    // Doing basic sanity checks and allocating some memory for our 
    // per-adapter structure.
    //

    if (wrapperConfigContext == NULL)
    {
        //
        // No registry config. information found by NDIS library for us.
        // We cannot proceed without it.
        //

	return NDIS_STATUS_FAILURE;
    }

    //
    // Allocate memory for the adapter structure.
    //

    MADGE_ALLOC_MEMORY(&status, &ndisAdap, sizeof(MADGE_ADAPTER));

    if (status != NDIS_STATUS_SUCCESS)
    {
        //
        // Failed to allocate adapter structure. Can't go on without it.
        //

	return status;
    }

    MADGE_ZERO_MEMORY(ndisAdap, sizeof(MADGE_ADAPTER));

    MadgePrint2("ndisAdap = %x\n", ndisAdap);

    //
    // We need the mini port handle early on.
    //

    ndisAdap->UsedInISR.MiniportHandle = miniportHandle;

    //
    // ---------------------------------------------------------------------
    // Read the registry: open the registry, read the contents, and close it
    // again. This will handle adapter parameters and LAAs, and also working
    // out various values to do with interrupt modes. 
    //

    MadgePrint1("NdisOpenConfiguration called\n");

    NdisOpenConfiguration(
        &status,
        &configHandle,
        wrapperConfigContext
        );

    MadgePrint1("NdisOpenConfiguration returned\n");

    if (status != NDIS_STATUS_SUCCESS)
    {
        MadgePrint2("NdisOpenConfiguration failed rc=%x\n", status);
	MADGE_FREE_MEMORY(ndisAdap, sizeof(MADGE_ADAPTER));
	return status;
    }

    status = MadgeReadRegistry(
                 wrapperConfigContext,
                 configHandle,
		 ndisAdap
                 );

    NdisCloseConfiguration(configHandle);

    //
    // We have gleaned all we can from the registry - was it all OK?
    //

    if (status != NDIS_STATUS_SUCCESS)
    {
        //
        // If Status is not success, it will be either NDIS_STATUS_FAILURE 
        // if a parameter was out of range, or it will be the error code
        // returned by NdisReadConfiguration().
        //

        MadgePrint2("MadgeReadRegistry failed rc = %x\n", status);
	MADGE_FREE_MEMORY(ndisAdap, sizeof(MADGE_ADAPTER));
	return status;
    }

    //
    // ---------------------------------------------------------------------
    // Having read the registry, we can initialize the rest of the fields in
    // the adapter structure. 
    // 

    #define I_DATA ActualValue.ParameterData.IntegerData

    //
    // Copy the values from the Parameter table into the per-adapter struct.
    // This is necessary because the Parameter table will be used again for
    // the next card that is added.
    //
    // Note that we handle the rx/tx slots configuration in a special way. 
    // The value of rx/tx slots is set by indexing into a table with the
    // single paramter RxTxSlots, unless RxSlots or TxSlots have been set in
    // which case these values override the values derived from RxTxSlots.
    //

    switch (MadgeParmTable.RxTxSlots.I_DATA)
    {
        case 0: 
            ndisAdap->FastmacTxSlots = 2;
            ndisAdap->FastmacRxSlots = 2;
            break;
        case 1: 
            ndisAdap->FastmacTxSlots = 3;
            ndisAdap->FastmacRxSlots = 3;
            break;
        case 2: 
            ndisAdap->FastmacTxSlots = 4;
            ndisAdap->FastmacRxSlots = 4;
            break;
        case 3: 
            ndisAdap->FastmacTxSlots = 6;
            ndisAdap->FastmacRxSlots = 6;
            break;
        case 4: 
            ndisAdap->FastmacTxSlots = 8;
            ndisAdap->FastmacRxSlots = 8;
            break;
        case 5: 
            ndisAdap->FastmacTxSlots = 10;
            ndisAdap->FastmacRxSlots = 10;
            break;
        default: 
            ndisAdap->FastmacTxSlots = 4;
            ndisAdap->FastmacRxSlots = 4;
            break;
    }

    if (MadgeParmTable.TxSlots.I_DATA != 0)
    {
        ndisAdap->FastmacTxSlots = MadgeParmTable.TxSlots.I_DATA;
    }

    if (MadgeParmTable.RxSlots.I_DATA != 0)
    {
        ndisAdap->FastmacRxSlots = MadgeParmTable.RxSlots.I_DATA;
    }

    MadgePrint3("TX slots = %d RX slots = %d\n",
        ndisAdap->FastmacTxSlots,
        ndisAdap->FastmacRxSlots
        );

    ndisAdap->MaxFrameSize      = MadgeParmTable.MaxFrameSize.I_DATA;
    ndisAdap->CardBufferSize    = MadgeParmTable.CardBufferSize.I_DATA;
    ndisAdap->PromiscuousMode   = (MadgeParmTable.PromiscuousMode.I_DATA == 1);
    ndisAdap->AlternateIo       = (MadgeParmTable.AlternateIo.I_DATA == 1);
    ndisAdap->TestAndXIDEnabled = (MadgeParmTable.TestAndXIDEnabled.I_DATA == 1);
    ndisAdap->ForceOpen         = (MadgeParmTable.ForceOpen.I_DATA == 1);
    ndisAdap->Force4            = (MadgeParmTable.Force4.I_DATA == 1);
    ndisAdap->Force16           = (MadgeParmTable.Force16.I_DATA == 1);
    ndisAdap->Multiprocessor    = (NdisSystemProcessorCount() > 1);

    if (ndisAdap->TransferMode != DMA_DATA_TRANSFER_MODE &&
        ndisAdap->Multiprocessor)
    {
        ndisAdap->UseMPSafePIO = TRUE;
    }

    //
    // If the RingSpeed parameter is present then this overrides the
    // Force4 and Force16 parameters. RingSpeed == 0 means either not
    // present or don't care. RingSpeed == 1 means 4MBits. RingSpeed == 2
    // means 16MBits.
    //

    switch (MadgeParmTable.RingSpeed.I_DATA)
    {
        case 1:
            ndisAdap->Force4  = TRUE;
            ndisAdap->Force16 = FALSE;
            break;

        case 2:
            ndisAdap->Force4  = FALSE;
            ndisAdap->Force16 = TRUE;

        default:
            break;
    }

    //
    // Initialize the rest of the Adapter structure. 
    //

    ndisAdap->UsedInISR.MiniportHandle = miniportHandle;
    ndisAdap->CurrentLookahead         = ndisAdap->MaxFrameSize - FRAME_HEADER_SIZE;
    ndisAdap->CurrentRingState         = NdisRingStateClosed;
    ndisAdap->HardwareStatus           = NdisHardwareStatusNotReady;

    //
    // These next few lines are strictly unnecessary because their fields in
    // the structure are already zero from our earlier ZERO_MEMORY() call.
    //

    ndisAdap->UsedInISR.SrbRequestCompleted = FALSE;
    ndisAdap->UsedInISR.SrbRequestStatus    = FALSE;
    ndisAdap->DprInProgress                 = FALSE;
    
    //
    // One nasty piece of hackery for Smart16 cards, whereby we must add to
    // the IoLocation 0x1000 if the Alternate switch is true.
    //

    if (ndisAdap->NTCardBusType == NdisInterfaceIsa &&
        ndisAdap->IoLocation1   >  0x3a20           &&
        ndisAdap->AlternateIo)
    {
        ndisAdap->IoLocation1 += 0x1000;
    }

    //
    // We need to know where the end of the first range of IO locations 
    // we use is.
    //

    ndisAdap->IORange1End = ndisAdap->IoLocation1 + ndisAdap->IORange1 - 1;

    //
    // ---------------------------------------------------------------------
    // We can now try to register the adapter. This involves filling in the
    // AdapterInformation structure and calling NdisRegisterAdapter(). See
    // the function MadgeRegisterAdapter for details. 
    //

    if ((status = MadgeRegisterAdapter(
                      ndisAdap,
                      wrapperConfigContext
                      )) != NDIS_STATUS_SUCCESS)
    {
        //
        // Either we failed to allocate memory for the adapter information
        // structure, or the NdisRegisterAdapter() call failed.
        //

        MadgePrint2("MadgeRegisterAdapter failed rc = %x\n", status);
	MADGE_FREE_MEMORY(ndisAdap, sizeof(MADGE_ADAPTER));
	return status;
    }

    //
    // ---------------------------------------------------------------------
    // We are now into the last stages of initialization. This is going to
    // cause to be allocated several more resources (in the form of kernel
    // objects, filter databases, FTK structures, interrupt channels, ...)
    // so from here on we have to be a lot more careful about cleaning up.
    // 

    ndisAdap->HardwareStatus = NdisHardwareStatusInitializing;

    //
    // Call the FTK to download the MAC code to the card and initialize it.
    //

    status = MadgeInitAdapter(ndisAdap);

    if (status != NDIS_STATUS_SUCCESS)
    {
        //
        // If it was an FTK generated error then log an appropriate event.
        //

        if (status == NDIS_STATUS_FAILURE)
        {
            BYTE   error_type;
            BYTE   error_value;
            char * error_message;

            driver_explain_error(
                ndisAdap->FtkAdapterHandle,
                &error_type,
                &error_value,
                &error_message
                );

            MadgePrint3("FTK error %02x, %02x\n", error_type, error_value);

            //
            // To keep Microsoft happy we will generate special error
            // messages for some of the more common error conditions.
            //

            //
            // An open error is probably because the cable isn't plugged in.
            //

            if (error_type == ERROR_TYPE_OPEN || 
                error_type == ERROR_TYPE_AUTO_OPEN)
            {
                NdisWriteErrorLogEntry(
	            ndisAdap->UsedInISR.MiniportHandle,
	            NDIS_ERROR_CODE_INVALID_VALUE_FROM_ADAPTER,
    	            4,
                    madgeInitialize,
                    MADGE_ERRMSG_INITIAL_INIT,
	            (ULONG) error_type,
	            (ULONG) error_value
                    );
            }
            else
            {
                NdisWriteErrorLogEntry(
	            ndisAdap->UsedInISR.MiniportHandle,
	            NDIS_ERROR_CODE_HARDWARE_FAILURE,
		    4,
                    madgeInitialize,
                    MADGE_ERRMSG_INITIAL_INIT,
		    (ULONG) error_type,
		    (ULONG) error_value
                    );
            }
        }

        //
        // In any case, tidy up the adapter and abort.
        //

        MadgeCleanupAdapter(ndisAdap);
	return status;
    }

    ndisAdap->HardwareStatus = NdisHardwareStatusReady;

    //
    // Set up the ring status monitor function.
    //

    NdisMInitializeTimer(
        &ndisAdap->WakeUpTimer,
        ndisAdap->UsedInISR.MiniportHandle,
        (PVOID) MadgeGetAdapterStatus,
        ndisAdap
        );

    NdisMSetTimer(&ndisAdap->WakeUpTimer, EVERY_2_SECONDS);

    NdisMInitializeTimer(
        &ndisAdap->CompletionTimer,
        ndisAdap->UsedInISR.MiniportHandle,
        (PVOID) MadgeTxCompletion,
        ndisAdap
        );

    ndisAdap->TimerInitialized = TRUE;

    MadgePrint1("MadgeInitialize finished\n");

    return NDIS_STATUS_SUCCESS;
}


/***************************************************************************
*
* Function    - DriverEntry
*
* Parameters  - driverObject -> Pointer to a driver object.
*               registryPath -> Path to our configuration information in
*                               the registry.
*
* Purpose     - Carry out the driver (as opposed to adapter instance)
*               initialisation. This is the main entry point.
*
* Returns     - An NDIS3 status code.
*
***************************************************************************/

NDIS_STATUS
DriverEntry(PDRIVER_OBJECT driverObject, PUNICODE_STRING registryPath);

#pragma FTK_INIT_FUNCTION(DriverEntry)
        
NDIS_STATUS
DriverEntry(PDRIVER_OBJECT driverObject, PUNICODE_STRING registryPath)
{
    NDIS_HANDLE                   ndisWrapperHandle;
    NDIS_STATUS                   status;
    NDIS_MINIPORT_CHARACTERISTICS madgeChar;
    UINT                          i;

    MadgePrint1("DriverEntry starting\n");

    //
    // We are obliged first of all to initialize the NDIS wrapper.
    //

    MadgePrint1("NdisMInitializeWrapper called\n");

    NdisMInitializeWrapper(
        &ndisWrapperHandle,
	driverObject,
	registryPath,
	NULL
	);

    MadgePrint1("NdisMInitializeWrapper returned\n");

    //
    // Decode any hidden strings here, for use later in MacAddAdapter. This
    // only applies to PromiscuousMode support at the moment.
    //

    for (i = 0;
         i < MadgeParmTable.PromiscuousMode.Keyword.Length / 
             sizeof(*(MadgeParmTable.PromiscuousMode.Keyword.Buffer));
         i++)
    {
        MadgeParmTable.PromiscuousMode.Keyword.Buffer[i] -= HIDDEN_OFFS;
    }

    //
    // Fill in the characteristics table - this lists all the driver entry
    // points that may be called by the NDIS wrapper.
    //

    madgeChar.MajorNdisVersion             = MADGE_NDIS_MAJOR_VERSION;
    madgeChar.MinorNdisVersion             = MADGE_NDIS_MINOR_VERSION;
    madgeChar.CheckForHangHandler          = MadgeCheckForHang;
    madgeChar.DisableInterruptHandler      = MadgeDisableInterrupts;
    madgeChar.EnableInterruptHandler       = MadgeEnableInterrupts;
    madgeChar.HaltHandler                  = MadgeHalt;
    madgeChar.HandleInterruptHandler       = MadgeHandleInterrupt;
    madgeChar.InitializeHandler            = MadgeInitialize;
    madgeChar.ISRHandler                   = MadgeISR;
    madgeChar.QueryInformationHandler      = MadgeQueryInformation;
    madgeChar.ReconfigureHandler           = NULL;
    madgeChar.ResetHandler                 = MadgeReset;
    madgeChar.SendHandler                  = MadgeSend;
    madgeChar.SetInformationHandler        = MadgeSetInformation;
    madgeChar.TransferDataHandler          = MadgeTransferData;

    //
    // Register the miniport driver with NDIS library. 
    //

    MadgePrint1("NdisMRegisterMiniport called\n");

    status = NdisMRegisterMiniport(
                 ndisWrapperHandle,
                 &madgeChar,
                 sizeof(madgeChar)
                 );

    MadgePrint1("NdisMRegisterMiniport returned\n");

    if (status != NDIS_STATUS_SUCCESS)
    {
        MadgePrint2("NdisMRegisterMiniport failed rc=%x\n", status);
	NdisTerminateWrapper(ndisWrapperHandle, NULL);
	return NDIS_STATUS_FAILURE;
    }

    MadgePrint1("DriverEntry finished\n");

    return NDIS_STATUS_SUCCESS;
}


/******** End of MADGE.C ***************************************************/