path: root/private/ntos/ndis/htdsu/htdsu.c

/***************************************************************************\
|* Copyright (c) 1994  Microsoft Corporation                               *|
|* Developed for Microsoft by TriplePoint, Inc. Beaverton, Oregon          *|
|*                                                                         *|
|* This file is part of the HT Communications DSU41 WAN Miniport Driver.   *|
\***************************************************************************/
#include "version.h"
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Module Name:

    htdsu.c

Abstract:

    This module contains the DriverEntry() routine, which is the first
    routine called when the driver is loaded into memory.  The Miniport
    initialization and termination routines are also implemented here:
        MiniportInitialize()
        MiniportHalt()

    This driver conforms to the NDIS 3.0 Miniport interface.

Author:

    Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94

Environment:

    Windows NT 3.5 kernel mode Miniport driver or equivalent.

Revision History:

---------------------------------------------------------------------------*/

#define  __FILEID__     1       // Unique file ID for error logging

#include "htdsu.h"

/*
// This is defined here to avoid including all of ntddk.h which cannot
// normally be included by a miniport driver.
*/
extern
NTSYSAPI
NTSTATUS
NTAPI
RtlUnicodeStringToAnsiString(
        PANSI_STRING out,
        PUNICODE_STRING in,
        BOOLEAN allocate
        );

/*
// Receives the context value representing the Miniport wrapper
// as returned from NdisMInitializeWrapper.
*/
static NDIS_HANDLE
NdisWrapperHandle = NULL;

/*
// This constant is used for places where NdisAllocateMemory needs to be
// called and the HighestAcceptableAddress does not matter.
*/
static NDIS_PHYSICAL_ADDRESS
HighestAcceptableAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1,-1);

/*
// This is used to assign a unique instance number to each adapter.
*/
static UCHAR
HtDsuAdapterCount = 0;

/*
// Tell the compiler which routines can be unloaded after initialization.
*/
NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    );
#pragma NDIS_INIT_FUNCTION(DriverEntry)

/*
// Tell the compiler which routines can be paged out.
// These can never be called from interrupt or DPC level!
*/
NDIS_STATUS
HtDsuInitialize(
    OUT PNDIS_STATUS OpenErrorStatus,
    OUT PUINT SelectedMediumIndex,
    IN PNDIS_MEDIUM MediumArray,
    IN UINT MediumArraySize,
    IN NDIS_HANDLE MiniportAdapterHandle,
    IN NDIS_HANDLE WrapperConfigurationContext
    );
#pragma NDIS_PAGABLE_FUNCTION(HtDsuInitialize)

NDIS_STATUS
HtDsuRegisterAdapter(
    IN PHTDSU_ADAPTER Adapter,
    IN PSTRING AddressList
    );
#pragma NDIS_PAGABLE_FUNCTION(HtDsuRegisterAdapter)

VOID
HtDsuHalt(
    IN PHTDSU_ADAPTER Adapter
    );
#pragma NDIS_PAGABLE_FUNCTION(HtDsuHalt)


NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    The DriverEntry routine is the main entry point for the driver.
    It is responsible for the initializing the Miniport wrapper and
    registering the driver with the Miniport wrapper.

Parameters:

    DriverObject _ Pointer to driver object created by the system.

    RegistryPath _ Pointer to registery path name used to read registry
                   parameters.

Return Values:

    STATUS_SUCCESS
    STATUS_UNSUCCESSFUL

---------------------------------------------------------------------------*/

{
    DBG_FUNC("HtDsuDriverEntry")

    /*
    // Receives the status of the NdisMWanRegisterMiniport operation.
    */
    NDIS_STATUS Status;

    /*
    // Characteristics table passed to NdisMWanRegisterMiniport.
    */
    NDIS_WAN_MINIPORT_CHARACTERISTICS HtDsuChar;

#if DBG
    DbgPrint("?>>>%s: Build Date:"__DATE__" Time:"__TIME__"\n",__FUNC__);
#endif

    /*
    // Initialize the Miniport wrapper - THIS MUST BE THE FIRST NDIS CALL.
    */
    NdisMInitializeWrapper(
            &NdisWrapperHandle,
            DriverObject,
            RegistryPath,
            NULL
            );

    /*
    // Initialize the characteristics table, exporting the Miniport's entry
    // points to the Miniport wrapper.
    */
    HtDsuChar.MajorNdisVersion        = NDIS_MAJOR_VERSION;
    HtDsuChar.MinorNdisVersion        = NDIS_MINOR_VERSION;
    HtDsuChar.Reserved                = NDIS_USE_WAN_WRAPPER;

    HtDsuChar.CheckForHangHandler     = HtDsuCheckForHang;
    HtDsuChar.DisableInterruptHandler = HtDsuDisableInterrupt;
    HtDsuChar.EnableInterruptHandler  = HtDsuEnableInterrupt;
    HtDsuChar.HaltHandler             = HtDsuHalt;
    HtDsuChar.HandleInterruptHandler  = HtDsuHandleInterrupt;
    HtDsuChar.InitializeHandler       = HtDsuInitialize;
    HtDsuChar.ISRHandler              = HtDsuISR;
    HtDsuChar.QueryInformationHandler = HtDsuQueryInformation;
    HtDsuChar.ReconfigureHandler      = NULL;   // Hardware not reconfigurable
    HtDsuChar.ResetHandler            = HtDsuReset;
    HtDsuChar.WanSendHandler          = HtDsuWanSend;
    HtDsuChar.SetInformationHandler   = HtDsuSetInformation;
    HtDsuChar.TransferDataHandler     = NULL;   // Not used by WAN drivers

    /*
    // Register the driver with the Miniport wrapper.
    */
    Status = NdisMRegisterMiniport(
                    NdisWrapperHandle,
                    (PNDIS_MINIPORT_CHARACTERISTICS) &HtDsuChar,
                    sizeof(HtDsuChar)
                    );

    /*
    // The driver will not load if this call fails.
    // The system will log the error for us.
    */
    if (Status != NDIS_STATUS_SUCCESS)
    {
        DBG_DISPLAY(("ERROR: NdisMRegisterMiniport Status=%Xh\n",Status));
        return STATUS_UNSUCCESSFUL;
    }

    return STATUS_SUCCESS;
}



NDIS_STATUS
HtDsuInitialize(
    OUT PNDIS_STATUS OpenErrorStatus,
    OUT PUINT SelectedMediumIndex,
    IN PNDIS_MEDIUM MediumArray,
    IN UINT MediumArraySize,
    IN NDIS_HANDLE MiniportAdapterHandle,
    IN NDIS_HANDLE WrapperConfigurationContext
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    The MiniportInitialize request is called to have the Miniport driver
    initialize the adapter.

    No other request will be outstanding on the Miniport when this routine
    is called.  No other request will be submitted to the Miniport until
    the operation is completed.

    The wrapper will supply an array containing a list of the media types
    that it supports.  The Miniport driver reads this array and returns
    the index of the media type that the wrapper should treat her as.
    If the Miniport driver is impersonating a media type that is different
    from the true media type, this must be done completely transparently to
    the wrapper.

    If the Miniport driver cannot find a media type supported by both it
    and the wrapper, it returns NDIS_STATUS_UNSUPPORTED_MEDIA.

    The status value NDIS_STATUS_OPEN_ERROR has a special meaning.  It
    indicates that the OpenErrorStatus parameter has returned a valid status
    which the wrapper can examine to obtain more information about the error.

    This routine is called with interrupts enabled, and a call to MiniportISR
    will occur if the adapter generates any interrupts.  During this routine
    MiniportDisableInterrupt and MiniportEnableInterrupt will not be called,
    so it is the responsibility of the Miniport driver to acknowledge and
    clear any interrupts generated.

Parameters:

    OpenErrorStatus _ Returns more information about the reason for the
                      failure. Currently, the only values defined match those
                      specified as Open Error Codes in Appendix B of the IBM
                      Local Area Network Technical Reference.

    SelectedMediumIndex _ Returns the index in MediumArray of the medium type
                          that the Miniport driver wishes to be viewed as.
                          Note that even though the NDIS interface may complete
                          this request asynchronously, it must return this
                          index on completion of this function.

    MediumArray _ An array of medium types which the wrapper supports.

    MediumArraySize _ The number of elements in MediumArray.

    MiniportAdapterHandle _ A handle identifying the Miniport.  The Miniport
                            driver must supply this handle in future requests
                            that refer to the Miniport.

    WrapperConfigurationContext _ The handle used for calls to NdisOpenConfiguration,
                                  and the routines in section 4 of this document.

Return Values:

    NDIS_STATUS_ADAPTER_NOT_FOUND
    NDIS_STATUS_FAILURE
    NDIS_STATUS_NOT_ACCEPTED
    NDIS_STATUS_OPEN_ERROR
    NDIS_STATUS_RESOURCES
    NDIS_STATUS_SUCCESS
    NDIS_STATUS_UNSUPPORTED_MEDIA

---------------------------------------------------------------------------*/

{
    DBG_FUNC("HtDsuInitialize")

    /*
    // Holds the status result returned from an NDIS function call.
    */
    NDIS_STATUS Status;

    /*
    // Pointer to our newly allocated adapter.
    */
    PHTDSU_ADAPTER Adapter;

    /*
    // The handle for reading from the registry.
    */
    NDIS_HANDLE ConfigHandle;

    /*
    // The value read from the registry.
    */
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;

    UINT index;

    /*
    // Define all the parameters that will be read.
    */
    NDIS_STRING RamBaseString = HTDSU_PARAM_RAMBASE_STRING;
    ULONG RamBaseAddress      = 0;

    NDIS_STRING InterruptString = HTDSU_PARAM_INTERRUPT_STRING;
    CCHAR InterruptNumber       = 0;

    NDIS_STRING LineTypeString = HTDSU_PARAM_LINETYPE_STRING;
    CCHAR LineType             = 0;

    NDIS_STRING LineRateString = HTDSU_PARAM_LINERATE_STRING;
    USHORT LineRate             = 0;

    NDIS_STRING MediaTypeString = HTDSU_PARAM_MEDIATYPE_STRING;
    ANSI_STRING MediaType;

    NDIS_STRING DeviceNameString = HTDSU_PARAM_DEVICENAME_STRING;
    ANSI_STRING DeviceName;

    NDIS_STRING AddressListString = HTDSU_PARAM_ADDRLIST_STRING;
    ANSI_STRING AddressList;

#if DBG
    NDIS_STRING DbgFlagsString = HTDSU_PARAM_DBGFLAGS_STRING;
    ULONG DbgFlags             = 0;
#endif

    /*
    // Search the MediumArray for the WAN media type.
    */
    for (index = 0; index < MediumArraySize; index++)
    {
        if (MediumArray[index] == NdisMediumWan)
        {
            break;
        }
    }

    /*
    // Return if no supported medium is found.
    */
    if (index >= MediumArraySize)
    {
        DBG_DISPLAY(("ERROR: No medium found (array=%X,size=%d)\n",
                    MediumArray, MediumArraySize));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
                3,
                index,
                __FILEID__,
                __LINE__
                );
        return NDIS_STATUS_UNSUPPORTED_MEDIA;
    }

    /*
    // Save the selected medium type.
    */
    *SelectedMediumIndex = index;

    /*
    // Open the configuration registry so we can get our config values.
    */
    NdisOpenConfiguration(
            &Status,
            &ConfigHandle,
            WrapperConfigurationContext
            );

    if (Status != NDIS_STATUS_SUCCESS)
    {
        DBG_DISPLAY(("ERROR: NdisOpenConfiguration failed (Status=%X)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        return NDIS_STATUS_FAILURE;
    }

    /********************************************************************
    // Get InterruptNumber for this adapter.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &InterruptString,
            NdisParameterInteger
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        InterruptNumber = (CCHAR)(ReturnedValue->ParameterData.IntegerData);
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(InterruptNumber) failed (Status=%X)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

    /*
    // Make sure the interrupt IRQ is valid.
    */
    if ((InterruptNumber != HTDSU_PARAM_IRQ03) &&
        (InterruptNumber != HTDSU_PARAM_IRQ04) &&
        (InterruptNumber != HTDSU_PARAM_IRQ10) &&
        (InterruptNumber != HTDSU_PARAM_IRQ11) &&
        (InterruptNumber != HTDSU_PARAM_IRQ12) &&
        (InterruptNumber != HTDSU_PARAM_IRQ15))
    {
        DBG_DISPLAY(("ERROR: Invalid InterruptNumber=%d)\n",InterruptNumber));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
                3,
                InterruptNumber,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

    /********************************************************************
    // Get RambaseAddress for this adapter.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &RamBaseString,
            NdisParameterHexInteger
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        RamBaseAddress = (ULONG)(ReturnedValue->ParameterData.IntegerData);
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(RamBaseAddress) failed (Status=%X)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

    /*
    // Make sure the RambaseAddress is valid.
    */
    if ((RamBaseAddress != HTDSU_PARAM_RAMBASE1) &&
        (RamBaseAddress != HTDSU_PARAM_RAMBASE2) &&
        (RamBaseAddress != HTDSU_PARAM_RAMBASE3) &&
        (RamBaseAddress != HTDSU_PARAM_RAMBASE4))
    {
        DBG_DISPLAY(("ERROR: Invalid RamBaseAddress=%Xh\n",RamBaseAddress));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
                3,
                RamBaseAddress,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

    /********************************************************************
    // Get MediaType for this adapter.
    // The MediaType and DeviceName values are used to construct the
    // ProviderInfo strings required by HtTapiGetDevCaps.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &MediaTypeString,
            NdisParameterString
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        RtlUnicodeStringToAnsiString(
                &MediaType,
                &(ReturnedValue->ParameterData.StringData),
                TRUE
                );
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(MediaType) failed (Status=%X)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

    /********************************************************************
    // Get DeviceName for this adapter.
    // The MediaType and DeviceName values are used to construct the
    // ProviderInfo strings required by HtTapiGetDevCaps.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &DeviceNameString,
            NdisParameterString
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        RtlUnicodeStringToAnsiString(
                &DeviceName,
                &(ReturnedValue->ParameterData.StringData),
                TRUE
                );
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(DeviceName) failed (Status=%X)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

    /********************************************************************
    // Get AddressList for this adapter.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &AddressListString,
            NdisParameterString
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        RtlUnicodeStringToAnsiString(
                &AddressList,
                &(ReturnedValue->ParameterData.StringData),
                TRUE
                );
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(AddressList) failed (Status=%X)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

#ifdef USE_LEASED_LINE
    /********************************************************************
    // Get LineType for this adapter.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &LineTypeString,
            NdisParameterInteger
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        LineType = (CCHAR)(ReturnedValue->ParameterData.IntegerData);
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(LineType) failed (Status=%X)\n",Status));
        LineType = HTDSU_LINEMODE_DIALUP;
    }

    /*
    // Make sure the LineType is valid.
    */
    if ((LineType != HTDSU_LINEMODE_LEASED) &&
        (LineType != HTDSU_LINEMODE_DIALUP))
    {
        DBG_DISPLAY(("ERROR: Invalid LineType=%d\n",LineType));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
                3,
                LineType,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }
#else
    LineType = HTDSU_LINEMODE_DIALUP;
#endif // USE_LEASED_LINE

    /********************************************************************
    // Get LineRate for this adapter.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &LineRateString,
            NdisParameterInteger
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        LineRate = (USHORT)(ReturnedValue->ParameterData.IntegerData);
    }
    else
    {
        DBG_DISPLAY(("ERROR: NdisReadConfiguration(LineRate) failed (Status=%X)\n",Status));
        LineRate = 1;
    }

    /*
    // Make sure the LineRate is valid.
    */
    LineRate = HTDSU_CMD_TX_RATE_MAX + (LineRate << 4);
    if ((LineRate != HTDSU_CMD_TX_RATE_MAX) &&
        (LineRate != HTDSU_CMD_TX_RATE_57600) &&
        (LineRate != HTDSU_CMD_TX_RATE_38400) &&
        (LineRate != HTDSU_CMD_TX_RATE_19200) &&
        (LineRate != HTDSU_CMD_TX_RATE_9600))
    {
        DBG_DISPLAY(("ERROR: Invalid LineRate=%d\n",LineRate));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
                3,
                LineRate,
                __FILEID__,
                __LINE__
                );
        NdisCloseConfiguration(ConfigHandle);
        return NDIS_STATUS_FAILURE;
    }

#if DBG
    /********************************************************************
    // Get DbgFlags for this adapter.
    */
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &DbgFlagsString,
            NdisParameterHexInteger
            );

    if (Status == NDIS_STATUS_SUCCESS)
    {
        DbgFlags = (ULONG)(ReturnedValue->ParameterData.IntegerData);
    }
    else
    {
        DbgFlags = 0;
    }
#endif

    /*
    // Close the configuration registry - we're done with it.
    */
    NdisCloseConfiguration(ConfigHandle);

    /*
    // Allocate memory for the adapter information structure.
    */
    Status = NdisAllocateMemory(
                    (PVOID *)&Adapter,
                    sizeof(*Adapter),
                    0,
                    HighestAcceptableAddress
                    );

    if (Status != NDIS_STATUS_SUCCESS)
    {
        DBG_DISPLAY(("ERROR: NdisAllocateMemory(Size=%d) failed (Status=%X)\n",
                    sizeof(*Adapter), Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                MiniportAdapterHandle,
                NDIS_ERROR_CODE_OUT_OF_RESOURCES,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        return NDIS_STATUS_FAILURE;
    }

    /*
    // Init the adapter structure values to NULL.
    */
    NdisZeroMemory (Adapter, sizeof(*Adapter));

    /*
    // Assign a unique ID to this adapter instance.
    */
    Adapter->InstanceNumber = ++HtDsuAdapterCount;

    /*
    // We use the adapter id number in debug messages to help when debugging
    // with multiple adapters.
    */
#if DBG
    Adapter->DbgID[0] = (0x0F & HtDsuAdapterCount) + '0';
    Adapter->DbgID[1] = 0;
    Adapter->DbgFlags = DbgFlags;
#endif

    DBG_DISPLAY(("HTDSU41(Adap=%08Xh,Ram=%05lXh,RamSiz=%04Xh,BufSiz=%04Xh,IRQ=%d)\n",
               Adapter, RamBaseAddress, HTDSU_MEMORY_SIZE,
               sizeof(HTDSU_BUFFER), InterruptNumber));

    /*
    // Make sure the adapter memory structure is sized properly.
    */
    ASSERT(sizeof(HTDSU_BUFFER) == 2016);
    ASSERT(HTDSU_MEMORY_SIZE == 4096);

    /*
    // Save the config parameters in the adapter structure.
    */
    Adapter->MiniportAdapterHandle = MiniportAdapterHandle;
    Adapter->InterruptNumber = InterruptNumber;
    Adapter->LineType = LineType;
    Adapter->LineRate = LineRate;
    Adapter->MemorySize = HTDSU_MEMORY_SIZE;
    NdisSetPhysicalAddressLow(Adapter->PhysicalAddress, RamBaseAddress);
    NdisSetPhysicalAddressHigh(Adapter->PhysicalAddress, 0);

    /*
    // Construct the "MediaType\0DeviceName" string for use by TAPI.
    */
    strcpy(Adapter->ProviderInfo, MediaType.Buffer);
    strcpy(Adapter->ProviderInfo + MediaType.Length + 1, DeviceName.Buffer);
    DBG_NOTICE(Adapter, ("Media=%s Device=%s\n",
            Adapter->ProviderInfo,
            &Adapter->ProviderInfo[MediaType.Length + 1]
            ));
    Adapter->ProviderInfoSize = MediaType.Length + 1 + DeviceName.Length + 1;

    /*
    // Now it's time to initialize the hardware resources.
    */
    Status = HtDsuRegisterAdapter(Adapter, &AddressList);

    if (Status != NDIS_STATUS_SUCCESS)
    {
        HtDsuHalt(Adapter);
    }

    DBG_DISPLAY(("RETURN: Status=%Xh\n",Status));

    return Status;
}


NDIS_STATUS
HtDsuRegisterAdapter(
    IN PHTDSU_ADAPTER Adapter,
    IN PSTRING AddressList
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    This function is called when a new adapter is being registered. It
    initializes the adapter information structure, allocate any resources
    needed by the adapter/driver, registers with the wrapper, and initializes
    the physical adapter.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    AddressList _ This is a list of MULTI_SZ strings which are to be assigned
                  to each link for use by TAPI HtTapiGetAddressCaps.

Return Values:

    NDIS_STATUS_ADAPTER_NOT_FOUND
    NDIS_STATUS_FAILURE
    NDIS_STATUS_NOT_ACCEPTED
    NDIS_STATUS_OPEN_ERROR
    NDIS_STATUS_RESOURCES
    NDIS_STATUS_SUCCESS
    NDIS_STATUS_UNSUPPORTED_MEDIA

---------------------------------------------------------------------------*/

{
    DBG_FUNC("HtDsuRegisterAdapter")

    /*
    // Holds the status result returned from an NDIS function call.
    */
    NDIS_STATUS Status;

    DBG_ENTER(Adapter);

    /*
    // Initialize the WAN information structure to match the capabilities of
    // the adapter.
    */
    Adapter->WanInfo.MaxFrameSize   = HTDSU_MAX_FRAME_SIZE;
    Adapter->WanInfo.MaxTransmit    = HTDSU_MAX_TRANSMITS;

    /*
    // Since we copy the packets to/from adapter RAM, no padding information is
    // needed in the WAN packets we get.  We can just use adapter RAM as needed.
    */
    Adapter->WanInfo.HeaderPadding  = 0;
    Adapter->WanInfo.TailPadding    = 0;

    /*
    // This value indicates how many point to point connections are allowed
    // per WAN link.  Currently, the WAN wrapper only supports 1 line per link.
    */
    Adapter->WanInfo.Endpoints      = 1;

    /*
    // Transmits and received are copied to/from adapter RAM so cached memory
    // can be used for packet allocation and we don't really care if it's
    // physically contiguous or not, as long as it's virtually contiguous.
    */
    Adapter->WanInfo.MemoryFlags    = 0;
    Adapter->WanInfo.HighestAcceptableAddress = HighestAcceptableAddress;

    /*
    // We only support point to point framing, and we don't need to see the
    // address or control fields.  The TAPI_PROVIDER bit is set to indicate
    // that we can accept the TAPI OID requests.
    */
    Adapter->WanInfo.FramingBits    = PPP_FRAMING |
                                      PPP_COMPRESS_ADDRESS_CONTROL |
                                      PPP_COMPRESS_PROTOCOL_FIELD |
                                      TAPI_PROVIDER;
    /*
    // This value is ignored by this driver, but its default behavior is such
    // that all these control bytes would appear to be handled transparently.
    */
    Adapter->WanInfo.DesiredACCM    = 0;

    /*
    // Inform the wrapper of the physical attributes of this adapter.
    // This must be called before any NdisMRegister functions!
    // This call also associates the MiniportAdapterHandle with this Adapter.
    */
    NdisMSetAttributes(
            Adapter->MiniportAdapterHandle,
            (NDIS_HANDLE)Adapter,
            FALSE,                      // Not a BusMaster
            NdisInterfaceIsa
            );

    /*
    // Map the adapter's physical location into the system address space.
    */
    Status = NdisMMapIoSpace(
                    &Adapter->VirtualAddress,
                    Adapter->MiniportAdapterHandle,
                    Adapter->PhysicalAddress,
                    Adapter->MemorySize
                    );
    DBG_NOTICE(Adapter, ("NdisMMapIoSpace(\n"
                    "VirtualAddress       =%Xh\n"
                    "MiniportAdapterHandle=%Xh\n"
                    "PhysicalAddress      =%X:%Xh\n"
                    "MemorySize           =%Xh\n",
                    Adapter->VirtualAddress,
                    Adapter->MiniportAdapterHandle,
                    Adapter->PhysicalAddress,
                    Adapter->MemorySize
                    ));

    if (Status != NDIS_STATUS_SUCCESS)
    {
        DBG_ERROR(Adapter,("NdisMMapIoSpace failed (status=%Xh)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                Adapter->MiniportAdapterHandle,
                NDIS_ERROR_CODE_OUT_OF_RESOURCES,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        goto EarlyOut;
    }

    Adapter->AdapterRam = (PHTDSU_REGISTERS) Adapter->VirtualAddress;

    /*
    // This is how we protect the driver from being re-entered when
    // it's not safe to do so.  Such as on a timer thread.  Normally,
    // the wrapper provides protection from re-entrancy, so SpinLocks
    // are not needed.  However, if your adapter requires asynchronous
    // timer support routines, you will have to provide your own
    // synchronization.
    */
    NdisAllocateSpinLock(&Adapter->Lock);

    /*
    // Set both the transmit busy and transmit idle lists to empty.
    */
    InitializeListHead(&Adapter->TransmitIdleList);
    InitializeListHead(&Adapter->TransmitBusyList);

    /*
    // Initialize the interrupt - it can be disabled, but cannot be shared.
    */
    Status = NdisMRegisterInterrupt(
                    &Adapter->Interrupt,
                    Adapter->MiniportAdapterHandle,
                    Adapter->InterruptNumber,
                    Adapter->InterruptNumber,
                    FALSE,      /* We don't need a call to the ISR */
                    FALSE,      /* Interrupt is not sharable */
                    NdisInterruptLatched
                    );

    if (Status != NDIS_STATUS_SUCCESS)
    {
        DBG_ERROR(Adapter,("NdisMRegisterInterrupt failed (status=%Xh)\n",Status));
        /*
        // Log error message and exit.
        */
        NdisWriteErrorLogEntry(
                Adapter->MiniportAdapterHandle,
                NDIS_ERROR_CODE_INTERRUPT_CONNECT,
                3,
                Status,
                __FILEID__,
                __LINE__
                );
        goto EarlyOut;
    }

    /*
    // Try to initialize the adapter hardware.
    */
#if DBG
    Status = CardInitialize(Adapter,
                            (BOOLEAN) ((Adapter->DbgFlags & DBG_HWTEST_ON) ? 
                            TRUE : FALSE));
#else
    Status = CardInitialize(Adapter, FALSE);
#endif

    if (Status != NDIS_STATUS_SUCCESS)
    {
        DBG_ERROR(Adapter,("CardInitialize failed (status=%Xh)\n",Status));
        /*
        // Error message was already logged.
        */
        goto EarlyOut;
    }

    /*
    // Initialize the adapter link structures.
    */
    LinkInitialize(Adapter, AddressList);

#ifdef USE_LEASED_LINE
    if (Adapter->LineType == HTDSU_LINEMODE_LEASED)
    {
        /*
        // Go ahead and allocate the lines and indicate them as up so we can
        // work with leased line mode.
        */
        PHTDSU_LINK Link;

        if (CardStatusOnLine(Adapter, HTDSU_CMD_LINE1))
        {
            Link = LinkAllocate(Adapter, NULL, HTDSU_LINE1_ID);
            LinkLineUp(Link);
        }
        if ((Adapter->NumLineDevs == HTDSU_NUM_LINKS) &&
            CardStatusOnLine(Adapter, HTDSU_CMD_LINE2))
        {
            Link = LinkAllocate(Adapter, NULL, HTDSU_LINE2_ID);
            LinkLineUp(Link);
        }
    }
#endif  // USE_LEASED_LINE

EarlyOut:

    DBG_LEAVE(Adapter);

    return Status;
}


VOID
HtDsuHalt(
    IN PHTDSU_ADAPTER Adapter
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    The MiniportHalt request is used to halt the adapter such that it is
    no longer functioning.  The Miniport driver should stop the adapter
    and deregister all of its resources before returning from this routine.

    It is not necessary for the Miniport to complete all outstanding
    requests and no other requests will be submitted to the Miniport
    until the operation is completed.

    Interrupts are enabled during the call to this routine.

Parameters:

    MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
                             during MiniportInitialize.

Return Values:

    None.

---------------------------------------------------------------------------*/

{
    DBG_FUNC("HtDsuHalt")

    /*
    // We use this message to make sure TAPI is cleaned up.
    */
    NDIS_TAPI_PROVIDER_SHUTDOWN TapiShutDown;

    DBG_ENTER(Adapter);

    /*
    // Make sure all the lines are hungup and indicated.
    // This should already be the case, but let's be sure.
    */
    TapiShutDown.ulRequestID = OID_TAPI_PROVIDER_SHUTDOWN;
    HtTapiProviderShutdown(Adapter, &TapiShutDown);

    /*
    // Disconnect the interrupt line.
    */
    if (*(PULONG)&(Adapter->Interrupt))
    {
        NdisMDeregisterInterrupt(&Adapter->Interrupt);
    }

    /*
    // Unmap the adapter memory from the system.
    */
    if (Adapter->VirtualAddress != NULL)
    {
        NdisMUnmapIoSpace(
            Adapter->MiniportAdapterHandle,
            Adapter->VirtualAddress,
            Adapter->MemorySize
            );
    }

    /*
    // Free the lock we aquired at startup.
    */
    if (*(PULONG)&(Adapter->Lock))
    {
        // FIXME - the latest version of NDIS does not define NdisFreeSpinLock
        // NdisFreeSpinLock(&Adapter->Lock);
    }

    DBG_LEAVE(Adapter);

    /*
    // Free adapter instance.
    */
    --HtDsuAdapterCount;
    NdisFreeMemory(Adapter, sizeof(*Adapter), 0);
}

#ifdef RECONFIGURE_SUPPORTED


NDIS_STATUS
HtDsuReconfigure(
    OUT PNDIS_STATUS OpenErrorStatus,
    IN PHTDSU_ADAPTER Adapter,
    IN NDIS_HANDLE WrapperConfigurationContext
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    This routine is called to have the Miniport reconfigure the adapter
    to the new parameters available via the NDIS configuration routines.
    Used to support plug and play adapters and software configurable
    adapters, which may have the parameters changed during runtime.  If
    the Miniport driver does not support dynamic reconfiguration, then
    the entry for W_RECONFIGURE_HANDLER in the NDIS_WIDGET_CHARACTERISTICS
    should be NULL.

    No other request will be outstanding on the Miniport when this routine
    is called.  No other request will be submitted to the Miniport until
    the operation is completed.

    The status value NDIS_STATUS_OPEN_ERROR has a special meaning.  It
    indicates that the OpenErrorStatus parameter has returned a valid
    status which the wrapper can examine to obtain more information about
    the error.

    This routine is called with interrupts enabled, and a call to MiniportISR
    will occur if the adapter generates any interrupts.  As long as this
    routine is executing MiniportDisableInterrupt and MiniportEnableInterrupt
    will not be called, so it is the responsibility of the Miniport driver
    to acknowledge and clear any interrupts generated.

Parameters:

    OpenErrorStatus _ Returns more information about the reason for the
                      failure.  Currently, the only values defined match
                      those specified as Open Error Codes in Appendix B
                      of the IBM Local Area Network Technical Reference.

    MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
                             during MiniportInitialize.

    WrapperConfigurationContext _ The handle to use for calls to
                                  NdisOpenConfiguration, and the routines
                                  in section 4 of this document.

Return Values:

    NDIS_STATUS_FAILURE
    NDIS_STATUS_NOT_ACCEPTED
    NDIS_STATUS_SUCCESS

---------------------------------------------------------------------------*/

{
    return (NDIS_STATUS_NOT_ACCEPTED);
}

#endif  // RECONFIGURE_SUPPORTED


NDIS_STATUS
HtDsuReset(
    OUT PBOOLEAN AddressingReset,
    IN PHTDSU_ADAPTER Adapter
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    The MiniportReset request instructs the Miniport driver to issue a
    hardware reset to the network adapter.  The Miniport driver also
    resets its software state.

    The MiniportReset request may also reset the parameters of the adapter.
    If a hardware reset of the adapter resets the current station address
    to a value other than what it is currently configured to, the Miniport
    driver automatically restores the current station address following the
    reset.  Any multicast or functional addressing masks reset by the
    hardware do not have to be reprogrammed by the Miniport.
    NOTE: This is change from the NDIS 3.0 driver specification.  If the
    multicast or functional addressing information, the packet filter, the
    lookahead size, and so on, needs to be restored, the Miniport indicates
    this with setting the flag AddressingReset to TRUE.

    It is not necessary for the Miniport to complete all outstanding requests
    and no other requests will be submitted to the Miniport until the
    operation is completed.  Also, the Miniport does not have to signal
    the beginning and ending of the reset with NdisMIndicateStatus.
    NOTE: These are different than the NDIS 3.0 driver specification.

    The Miniport driver must complete the original request, if the orginal
    call to MiniportReset return NDIS_STATUS_PENDING, by calling
    NdisMResetComplete.

    If the underlying hardware does not provide a reset function under
    software control, then this request completes abnormally with
    NDIS_STATUS_NOT_RESETTABLE.  If the underlying hardware attempts a
    reset and finds recoverable errors, the request completes successfully
    with NDIS_STATUS_SOFT_ERRORS.  If the underlying hardware resets and,
    in the process, finds nonrecoverable errors, the request completes
    successfully with the status NDIS_STATUS_HARD_ERRORS.  If the
    underlying  hardware reset is accomplished without any errors,
    the request completes successfully with the status NDIS_STATUS_SUCCESS.

    Interrupts are in any state during this call.

Parameters:

    MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
                             during MiniportInitialize.

    AddressingReset _ The Miniport indicates if the wrapper needs to call
                      MiniportSetInformation to restore the addressing
                      information to the current values by setting this
                      value to TRUE.

Return Values:

    NDIS_STATUS_HARD_ERRORS
    NDIS_STATUS_NOT_ACCEPTED
    NDIS_STATUS_NOT_RESETTABLE
    NDIS_STATUS_PENDING
    NDIS_STATUS_SOFT_ERRORS
    NDIS_STATUS_SUCCESS

---------------------------------------------------------------------------*/

{
    DBG_FUNC("HtDsuReset")

    /*
    // Holds the status result returned from an NDIS function call.
    */
    NDIS_STATUS Status;

    DBG_ENTER(Adapter);
    DBG_BREAK(Adapter);

    if (Adapter->NeedReset)
    {
        NdisAcquireSpinLock(&Adapter->Lock);

        /*
        // Make sure TAPI is aware of the state change so it can do the
        // right things.
        */
        HtTapiResetHandler(Adapter);

        /*
        // Attempt to issue a software reset on the adapter.
        // It will only fail if the hardware is hung forever.
        */
        Adapter->NeedReset = FALSE;
        Status = CardInitialize(Adapter, FALSE);

        /*
        // If anything gose wrong here, it's very likely an unrecoverable
        // hardware failure.  So we'll just shut this thing down for good.
        */
        if (Status != NDIS_STATUS_SUCCESS)
        {
            DBG_ERROR(Adapter,("RESET Failed\n"));
            Status = NDIS_STATUS_HARD_ERRORS;
        }
        else
        {
            /*
            // If there were lines open, we must reset them back to
            // LINECALLSTATE_IDLE, and configure them for use.
            */
            if (Adapter->NumOpens)
            {
                if (Adapter->NumOpens == 1)
                {
                    CardLineConfig(Adapter, HTDSU_CMD_LINE1);
                    HtTapiCallStateHandler(Adapter,
                            GET_LINK_FROM_LINKINDEX(Adapter, 0),
                            LINECALLSTATE_IDLE,
                            0);
                    Adapter->InterruptEnableFlag |= HTDSU_INTR_ALL_LINE1;
                }
                if (Adapter->NumOpens == 2)
                {
                    CardLineConfig(Adapter, HTDSU_CMD_LINE2);
                    HtTapiCallStateHandler(Adapter,
                            GET_LINK_FROM_LINKINDEX(Adapter, 1),
                            LINECALLSTATE_IDLE,
                            0);
                    Adapter->InterruptEnableFlag |= HTDSU_INTR_ALL_LINE2;
                }
                CardEnableInterrupt(Adapter);
            }
            
            DBG_WARNING(Adapter,("RESET Complete\n"));
            *AddressingReset = TRUE;
        }

        NdisReleaseSpinLock(&Adapter->Lock);
    }
    else
    {
        DBG_WARNING(Adapter, ("RESET Not Needed\n"));
    }

    DBG_LEAVE(Adapter);

    return (Status);
}