if (MediumArray[i] == NdisMedium802_3){

            break;

        }

    }

    if (i == MediumArraySize){
        DEBUGMSG(ZONE_INIT|ZONE_ERROR,
            (TEXT("CELAN:Initialize: No supported media\r\n")));
        return( NDIS_STATUS_UNSUPPORTED_MEDIA );

    } else {
        DEBUGMSG(ZONE_INIT, (TEXT("CELAN:Selected media is %d.\r\n"),i));
    }

    *SelectedMediumIndex = i;


    //
    // Set default values.
    //
    IoBaseAddr = DEFAULT_IOBASEADDR;
    InterruptNumber = DEFAULT_INTERRUPTNUMBER;
    MaxMulticastList = DEFAULT_MULTICASTLISTMAX;

    //
    // Allocate memory for the adapter block now.
    //
    Status = NdisAllocateMemory( (PVOID *)&Adapter,
                   sizeof(CELAN_ADAPTER),
                   0,
                   HighestAcceptableMax
                   );

    if (Status != NDIS_STATUS_SUCCESS) {

        DEBUGMSG(ZONE_INIT|ZONE_ERROR,
            (TEXT("CELAN:Initialize: NdisAllocateMemory(CELAN_ADAPTER) failed\r\n")));
        return Status;

    }

    //
    // Clear out the adapter block, which sets all default values to FALSE,
    // or NULL.
    //
    NdisZeroMemory (Adapter, sizeof(CELAN_ADAPTER));

    //
    // Open the configuration space.
    //
    NdisOpenConfiguration(
            &Status,
            &ConfigHandle,
            ConfigurationHandle
            );

    if (Status != NDIS_STATUS_SUCCESS) {

        NdisFreeMemory(Adapter, sizeof(CELAN_ADAPTER), 0);

        DEBUGMSG(ZONE_INIT,
            (TEXT("CELAN:Initialize: NdisOpenconfiguration failed 0x%x\r\n"),
            Status));
        return Status;

    }
	
	//
    // Initialize Statistics
    // 
    Adapter->FrameAlignmentErrors = 0;
    Adapter->CrcErrors = 0;
    Adapter->MissedPackets = 0;

    //
    //  Read in the card type.
    //
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &CardTypeStr,
            NdisParameterHexInteger
            );
    if (Status == NDIS_STATUS_SUCCESS)
        Adapter->CardType = (UINT)ReturnedValue->ParameterData.IntegerData;
    else
        DEBUGMSG(ZONE_INIT, (TEXT("CELAN:NdisReadConfigration(CardType) failed.\r\n")));

    //
    // Read net address
    //
    NdisReadNetworkAddress(
                    &Status,
                    &NetAddress,
                    &Length,
                    ConfigHandle
                    );

    if ((Length == CELAN_LENGTH_OF_ADDRESS) &&
        (Status == NDIS_STATUS_SUCCESS)) {

        //
        // Save the address that should be used.
        //
        NdisMoveMemory(
                Adapter->StationAddress,
                NetAddress,
                CELAN_LENGTH_OF_ADDRESS
                );

    }

#if NDIS_NT
    //
    // Disallow multiple adapters in the same MP machine because of hardware
    // problems this results in random packet corruption.
    //
    if ((NdisSystemProcessorCount() > 1) &&
        (CelanMiniportBlock.AdapterQueue != NULL)) {

        ConfigError = TRUE;
        ConfigErrorValue = (ULONG)NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
        DEBUGMSG(ZONE_INIT,
            (TEXT("CELAN:Initialize: Invalid MP config\r\n")));
        goto RegisterAdapter;
    }
#endif


    //
    // Read Bus Type (for NE2/AE2 support)
    //

    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &BusTypeStr,
            NdisParameterHexInteger
            );

    if (Status == NDIS_STATUS_SUCCESS) {

        Adapter->BusType = (UCHAR)ReturnedValue->ParameterData.IntegerData;

    }
    else
        DEBUGMSG(ZONE_INIT, (TEXT("CELAN:NdisReadConfigration(BusType) failed.\r\n")));

    if (!SkipIobaseAndInterrupt) {

        //
        // Read I/O Address
        //
        NdisReadConfiguration(
                &Status,
                &ReturnedValue,
                ConfigHandle,
                &IOAddressStr,
                NdisParameterHexInteger
                );

        if (Status == NDIS_STATUS_SUCCESS) {

            IoBaseAddr = (PVOID)(ReturnedValue->ParameterData.IntegerData);

        } else
        	DEBUGMSG(ZONE_INIT, (TEXT("CELAN:NdisReadConfigration(IOAddress) failed.\r\n")));

        //
        // Check that the value is valid.
        //
        if ((IoBaseAddr < (PVOID)MIN_IOBASEADDR) ||
            (IoBaseAddr > (PVOID)MAX_IOBASEADDR)) {

            ConfigError = TRUE;
            ConfigErrorValue = (ULONG)IoBaseAddr;
            DEBUGMSG(ZONE_INIT,
                (TEXT("CELAN:Intialize: Invalid IoBaseAddr 0x%x\r\n"),
                IoBaseAddr));
            goto RegisterAdapter;

        }

        //
        // Read interrupt number
        //
#if NDIS_NT
        NdisReadConfiguration(
                &Status,
                &ReturnedValue,
                ConfigHandle,
                &InterruptStr,
                NdisParameterHexInteger
                );
#else

        NdisReadConfiguration(
                &Status,
                &ReturnedValue,
                ConfigHandle,
                &InterruptStr,
                NdisParameterInteger
                );
#endif

        if (Status == NDIS_STATUS_SUCCESS) {

            InterruptNumber = (CCHAR)(ReturnedValue->ParameterData.IntegerData);

        } else
        	DEBUGMSG(ZONE_INIT, (TEXT("CELAN:NdisReadConfigration(Interrupt) failed.\r\n")));

        //
        // Verify that the value is valid.
        //
        if ((InterruptNumber < MIN_IRQ) ||
            (InterruptNumber > MAX_IRQ)) {

            ConfigError = TRUE;
            ConfigErrorValue = (ULONG)InterruptNumber;
            DEBUGMSG(ZONE_INIT,
                (TEXT("CELAN:Intialize: Invalid Int 0x%x\r\n"),
                InterruptNumber));
            goto RegisterAdapter;

        }
    }

    //
    // Read MaxMulticastList
    //
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &MaxMulticastListStr,
            NdisParameterInteger
            );

    if (Status == NDIS_STATUS_SUCCESS) {

        MaxMulticastList = ReturnedValue->ParameterData.IntegerData;
		if (ReturnedValue->ParameterData.IntegerData <= DEFAULT_MULTICASTLISTMAX)
	        MaxMulticastList = ReturnedValue->ParameterData.IntegerData;
    } else
        	DEBUGMSG(ZONE_INIT, (TEXT("CELAN:NdisReadConfigration(Attrbute MemorySize) failed.\r\n")));
	        DEBUGMSG(ZONE_INIT, (TEXT("Status = 0x%x, NDIS_STATUS_SUCCESS = 0x%x\r\n"),Status,NDIS_STATUS_SUCCESS));


RegisterAdapter:

    //
    // Now to use this information and register with the wrapper
    // and initialize the adapter.
    //

    //
    // First close the configuration space.
    //
    NdisCloseConfiguration(ConfigHandle);

    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:Registering adapter # buffers %ld\r\n"),
        DEFAULT_NUMBUFFERS));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:Card type: 0x%x\r\n"), Adapter->CardType));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:I/O base addr 0x%lx\r\n"), IoBaseAddr));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:interrupt number %ld\r\n"),
        InterruptNumber));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:max multicast %ld\r\n"),
        DEFAULT_MULTICASTLISTMAX));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:attribute memory address 0x%X\r\n"),
        Adapter->AttributeMemoryAddress));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:attribute memory size 0x%X\r\n"),
        Adapter->AttributeMemorySize));
    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:Bus Type: %d\r\n"), Adapter->BusType));



    //
    // Set up the parameters.
    //
    Adapter->NumBuffers = DEFAULT_NUMBUFFERS;
    Adapter->IoBaseAddr = IoBaseAddr;

    Adapter->InterruptNumber = InterruptNumber;

    Adapter->MulticastListMax = MaxMulticastList;
    Adapter->MiniportAdapterHandle = MiniportAdapterHandle;

    Adapter->MaxLookAhead = CELAN_MAX_LOOKAHEAD;

    //
    // Now do the work.
    //
    if (CelanRegisterAdapter(Adapter,
          ConfigurationHandle,
          ConfigError,
          ConfigErrorValue
          ) != NDIS_STATUS_SUCCESS) {

        //
        // CelanRegisterAdapter failed.
        //
        NdisFreeMemory(Adapter, sizeof(CELAN_ADAPTER), 0);
        DEBUGMSG(ZONE_INIT, (TEXT("CELAN:NdisRegisterAdapter failed.\r\n")));

        return NDIS_STATUS_FAILURE;

    }


    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:Initialize succeeded\r\n")));

    DEBUGMSG(ZONE_FUNCTION, (TEXT("-CELAN:Initialize\r\n")));

    return NDIS_STATUS_SUCCESS;
}


#pragma NDIS_PAGEABLE_FUNCTION(CelanRegisterAdapter)
NDIS_STATUS
CelanRegisterAdapter(
    IN PCELAN_ADAPTER Adapter,
    IN NDIS_HANDLE ConfigurationHandle,
    IN BOOLEAN ConfigError,
    IN ULONG ConfigErrorValue
    )

/*++

Routine Description:

    Called when a new adapter should be registered. It allocates space for
    the adapter, initializes the adapter's block, registers resources
    with the wrapper and initializes the physical adapter.

Arguments:

    Adapter - The adapter structure.

    ConfigurationHandle - Handle passed to CelanInitialize.

    ConfigError - Was there an error during configuration reading.

    ConfigErrorValue - Value to log if there is an error.

Return Value:

    Indicates the success or failure of the registration.

--*/

{

    //
    // Temporary looping variable.
    //
//    UINT i;

    //
    // General purpose return from NDIS calls
    //
    NDIS_STATUS status;

    //
    // check that NumBuffers <= MAX_XMIT_BUFS
    //

    if (Adapter->NumBuffers > MAX_XMIT_BUFS)
        return(NDIS_STATUS_RESOURCES);

    //
    // Check for a configuration error
    //
    if (ConfigError)
    {
        //
        // Log Error and exit.
        //
        NdisWriteErrorLogEntry(
            Adapter->MiniportAdapterHandle,
            NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
            1,
            ConfigErrorValue
            );
        DEBUGMSG(ZONE_INIT,
            (TEXT("CELAN:RegisterAdapter: CelanInitialize had a config error %d\r\n"),
            ConfigErrorValue));

        return(NDIS_STATUS_FAILURE);
    }

    //
    // Inform the wrapper of the physical attributes of this adapter.
    //
    NdisMSetAttributes(
        Adapter->MiniportAdapterHandle,
        (NDIS_HANDLE)Adapter,
        FALSE,
        Adapter->BusType
    );

    //
    // Register the port addresses.
    //
    status = NdisMRegisterIoPortRange(
                 (PVOID *)(&(Adapter->IoPAddr)),
                 Adapter->MiniportAdapterHandle,
                 (ULONG)Adapter->IoBaseAddr,
                 0x20
             );

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

    if (Adapter->IoPAddr == 0)
        return NDIS_STATUS_FAILURE;

    //
    // Initialize the card.
    //
    DEBUGMSG(ZONE_INIT,
        (TEXT("CELAN:RegisterAdapter calling CardInitialize\r\n")));

    if (!CardInitialize(Adapter))
    {
        //
        // Card seems to have failed.
        //

        DEBUGMSG(ZONE_INIT,
            (TEXT("CELAN:RegisterAdapter CardInitialize -- Failed\r\n")));

        RETAILMSG(1,(TEXT("CELAN:RegisterAdapter CardInitialize -- Failed\r\n")));


        NdisWriteErrorLogEntry(
            Adapter->MiniportAdapterHandle,
            NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
            0
        );

        status = NDIS_STATUS_ADAPTER_NOT_FOUND;

        goto fail2;
    }

    DEBUGMSG(ZONE_INIT,
        (TEXT("CELAN:RegisterAdapter CardInitialize  -- Success\r\n")));


    //
    // Initialize the receive variables.
    //
    Adapter->NicReceiveConfig = RCR_ENABLE | 0x0200; // RCR_REJECT_ERR;


    //
    // Read the Ethernet address off of the PROM.
    //
    if (!CardReadEthernetAddress(Adapter))
    {
        DEBUGMSG(ZONE_INIT,
            (TEXT("CELAN:RegisterAdapter Could not read the ethernet address\r\n")));

        RETAILMSG(1,(TEXT("CELAN:RegisterAdapter Could not read the ethernet address\r\n")));

        NdisWriteErrorLogEntry(
            Adapter->MiniportAdapterHandle,
            NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
            0
            );

        status = NDIS_STATUS_ADAPTER_NOT_FOUND;

        goto fail2;
    }

    //
    // Now initialize the NIC and Gate Array registers.
    //
//for LAN91C96    Adapter->NicInterruptMask = IM_TX_INT | IM_RCV_INT | IM_RX_OVRN_INT;
	  Adapter->NicInterruptMask = IM_TX_INT | IM_RCV_INT | IM_RX_OVRN_INT | IM_MD_INT;//for LAN91C111

    //
    // Link us on to the chain of adapters for this driver.
    //
    Adapter->NextAdapter = CelanMiniportBlock.AdapterQueue;
    CelanMiniportBlock.AdapterQueue = Adapter;


    //
    // Setup the card based on the initialization information
    //

    DEBUGMSG(ZONE_INIT, (TEXT("CELAN:RegisterAdapter CardSetup\r\n")));

    if (!CardSetup(Adapter))
    {
        //
        // The NIC could not be written to.
        //

        NdisWriteErrorLogEntry(