path: root/private/ntos/ndis/htdsu/tapi.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:

    tapi.c

Abstract:

    This module contains all the Miniport TAPI OID processing routines.  It
    is called by the MiniportSetInformation and MiniportQueryInformation
    routines to handle the TAPI OIDs.

    This driver conforms to the NDIS 3.0 Miniport interface and provides
    extensions to support Telephonic Services.

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__     8       // Unique file ID for error logging

#include "htdsu.h"

#   define TAPI_DEVICECLASS_NAME        "tapi/line"
#   define TAPI_DEVICECLASS_ID          1
#   define NDIS_DEVICECLASS_NAME        "ndis"
#   define NDIS_DEVICECLASS_ID          2

/*
// The following is a list of all the possible TAPI OIDs.
*/
const NDIS_OID TapiSupportedArray[] =
{
/*
// REQUIRED TAPI SPECIFIC OIDS
*/
    OID_TAPI_ANSWER,
    OID_TAPI_CLOSE,
    OID_TAPI_CLOSE_CALL,
    OID_TAPI_CONDITIONAL_MEDIA_DETECTION,
    OID_TAPI_DROP,
    OID_TAPI_GET_ADDRESS_CAPS,
    OID_TAPI_GET_ADDRESS_ID,
    OID_TAPI_GET_ADDRESS_STATUS,
    OID_TAPI_GET_CALL_ADDRESS_ID,
    OID_TAPI_GET_CALL_INFO,
    OID_TAPI_GET_CALL_STATUS,
    OID_TAPI_GET_DEV_CAPS,
    OID_TAPI_GET_DEV_CONFIG,
    OID_TAPI_GET_EXTENSION_ID,
    OID_TAPI_GET_ID,
    OID_TAPI_GET_LINE_DEV_STATUS,
    OID_TAPI_MAKE_CALL,
    OID_TAPI_OPEN,
    OID_TAPI_PROVIDER_INITIALIZE,
    OID_TAPI_PROVIDER_SHUTDOWN,
    OID_TAPI_SET_APP_SPECIFIC,
    OID_TAPI_SET_CALL_PARAMS,
    OID_TAPI_SET_DEFAULT_MEDIA_DETECTION,
    OID_TAPI_SET_DEV_CONFIG,
    OID_TAPI_SET_MEDIA_MODE,
    OID_TAPI_SET_STATUS_MESSAGES,
/*
// OPTIONAL TAPI SPECIFIC OIDS
*/
    OID_TAPI_ACCEPT,
    OID_TAPI_CONFIG_DIALOG,
    OID_TAPI_DEV_SPECIFIC,
    OID_TAPI_DIAL,
    OID_TAPI_NEGOTIATE_EXT_VERSION,
    OID_TAPI_SECURE_CALL,
    OID_TAPI_SELECT_EXT_VERSION,
    OID_TAPI_SEND_USER_USER_INFO,
};

#if DBG

/*
// Make sure the following list is in the same order as the list above!
*/
char *TapiSupportedNames[] =
{
/*
// REQUIRED TAPI SPECIFIC OIDS
*/
    "OID_TAPI_ANSWER",
    "OID_TAPI_CLOSE",
    "OID_TAPI_CLOSE_CALL",
    "OID_TAPI_CONDITIONAL_MEDIA_DETECTION",
    "OID_TAPI_DROP",
    "OID_TAPI_GET_ADDRESS_CAPS",
    "OID_TAPI_GET_ADDRESS_ID",
    "OID_TAPI_GET_ADDRESS_STATUS",
    "OID_TAPI_GET_CALL_ADDRESS_ID",
    "OID_TAPI_GET_CALL_INFO",
    "OID_TAPI_GET_CALL_STATUS",
    "OID_TAPI_GET_DEV_CAPS",
    "OID_TAPI_GET_DEV_CONFIG",
    "OID_TAPI_GET_EXTENSION_ID",
    "OID_TAPI_GET_ID",
    "OID_TAPI_GET_LINE_DEV_STATUS",
    "OID_TAPI_MAKE_CALL",
    "OID_TAPI_OPEN",
    "OID_TAPI_PROVIDER_INITIALIZE",
    "OID_TAPI_PROVIDER_SHUTDOWN",
    "OID_TAPI_SET_APP_SPECIFIC",
    "OID_TAPI_SET_CALL_PARAMS",
    "OID_TAPI_SET_DEFAULT_MEDIA_DETECTION",
    "OID_TAPI_SET_DEV_CONFIG",
    "OID_TAPI_SET_MEDIA_MODE",
    "OID_TAPI_SET_STATUS_MESSAGES",
/*
// OPTIONAL TAPI SPECIFIC OIDS
*/
    "OID_TAPI_ACCEPT",
    "OID_TAPI_CONFIG_DIALOG",
    "OID_TAPI_DEV_SPECIFIC",
    "OID_TAPI_DIAL",
    "OID_TAPI_NEGOTIATE_EXT_VERSION",
    "OID_TAPI_SECURE_CALL",
    "OID_TAPI_SELECT_EXT_VERSION",
    "OID_TAPI_SEND_USER_USER_INFO",

    "OID_TAPI_UNKNOWN"
};

#define NUM_OID_ENTRIES (sizeof(TapiSupportedArray) / sizeof(TapiSupportedArray[0]))

/*
// This debug routine will lookup the printable name for the selected OID.
*/
char *
HtTapiGetOidString(NDIS_OID Oid)
{
    UINT i;

    for (i = 0; i < NUM_OID_ENTRIES-1; i++)
    {
        if (TapiSupportedArray[i] == Oid)
        {
            break;
        }
    }
    return(TapiSupportedNames[i]);
}

#endif // DBG


NDIS_STATUS
HtTapiQueryInformation(
    IN PHTDSU_ADAPTER Adapter,
    IN NDIS_OID Oid,
    IN PVOID InformationBuffer,
    IN ULONG InformationBufferLength,
    OUT PULONG BytesWritten,
    OUT PULONG BytesNeeded
    )

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

Functional Description:

    The HtTapiQueryInformation request allows for inspection of the TAPI
    portion of the driver's capabilities and current line status.

    If the Miniport does not complete the call immediately (by returning
    NDIS_STATUS_PENDING), it must call NdisMQueryInformationComplete to
    complete the call.  The Miniport controls the buffers pointed to by
    InformationBuffer, BytesWritten, and BytesNeeded until the request
    completes.

    No other requests will be submitted to the Miniport driver until
    this request has been completed.

    Interrupts are in any state during this call.

Parameters:

    MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
                             during MiniportInitialize.

    Oid _ The OID.  (See section 2.2.1 of the Extensions to NDIS 3.0 Miniports
          to support Telephonic Services specification for a complete 
          description of the OIDs.)

    InformationBuffer _ The buffer that will receive the information.

    InformationBufferLength _ The length in bytes of InformationBuffer.

    BytesWritten _ Returns the number of bytes written into
                   InformationBuffer.

    BytesNeeded _ This parameter returns the number of additional bytes
                  needed to satisfy the OID.

Return Values:

    NDIS_STATUS_INVALID_DATA
    NDIS_STATUS_INVALID_LENGTH
    NDIS_STATUS_INVALID_OID
    NDIS_STATUS_NOT_ACCEPTED
    NDIS_STATUS_NOT_SUPPORTED
    NDIS_STATUS_PENDING
    NDIS_STATUS_RESOURCES
    NDIS_STATUS_SUCCESS

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

{
    DBG_FUNC("HtTapiQueryInformation")

    /*
    // Assume the worst, and initialize to handle failure.
    */
    NDIS_STATUS Status = NDIS_STATUS_INVALID_LENGTH;
    ULONG NumBytesNeeded  = 0;
    ULONG NumBytesWritten = 0;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter,DBG_REQUEST_ON,
              ("(OID=%s=%08x)\n\t\tInfoLength=%d InfoBuffer=%Xh\n",
               HtTapiGetOidString(Oid),Oid,
               InformationBufferLength,
               InformationBuffer
              ));

    /*
    // Determine which OID is being requested and do the right thing.
    // The switch code will just call the approriate service function
    // to do the real work, so there's not much to worry about here.
    */
    switch (Oid)
    {
    case OID_TAPI_CONFIG_DIALOG:        // OPTIONAL
        if(InformationBufferLength < sizeof(NDIS_TAPI_CONFIG_DIALOG))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_CONFIG_DIALOG);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiConfigDialog(Adapter,
                        (PNDIS_TAPI_CONFIG_DIALOG) InformationBuffer);
        break;

    case OID_TAPI_DEV_SPECIFIC:         // OPTIONAL
        if(InformationBufferLength < sizeof(NDIS_TAPI_DEV_SPECIFIC))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_DEV_SPECIFIC);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiDevSpecific(Adapter,
                        (PNDIS_TAPI_DEV_SPECIFIC) InformationBuffer);
        break;

    case OID_TAPI_GET_ADDRESS_CAPS:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_ADDRESS_CAPS))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_ADDRESS_CAPS);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetAddressCaps(Adapter,
                        (PNDIS_TAPI_GET_ADDRESS_CAPS) InformationBuffer);
        break;

    case OID_TAPI_GET_ADDRESS_ID:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_ADDRESS_ID))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_ADDRESS_ID);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetAddressID(Adapter,
                        (PNDIS_TAPI_GET_ADDRESS_ID) InformationBuffer);
        break;

    case OID_TAPI_GET_ADDRESS_STATUS:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_ADDRESS_STATUS))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_ADDRESS_STATUS);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetAddressStatus(Adapter,
                        (PNDIS_TAPI_GET_ADDRESS_STATUS) InformationBuffer);
        break;

    case OID_TAPI_GET_CALL_ADDRESS_ID:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_CALL_ADDRESS_ID))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_CALL_ADDRESS_ID);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetCallAddressID(Adapter,
                        (PNDIS_TAPI_GET_CALL_ADDRESS_ID) InformationBuffer);
        break;

    case OID_TAPI_GET_CALL_INFO:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_CALL_INFO))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_CALL_INFO);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetCallInfo(Adapter,
                        (PNDIS_TAPI_GET_CALL_INFO) InformationBuffer);
        break;

    case OID_TAPI_GET_CALL_STATUS:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_CALL_STATUS))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_CALL_STATUS);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetCallStatus(Adapter,
                        (PNDIS_TAPI_GET_CALL_STATUS) InformationBuffer);
        break;

    case OID_TAPI_GET_DEV_CAPS:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_DEV_CAPS))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_DEV_CAPS);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetDevCaps(Adapter,
                        (PNDIS_TAPI_GET_DEV_CAPS) InformationBuffer);
        break;

    case OID_TAPI_GET_DEV_CONFIG:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_DEV_CONFIG))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_DEV_CONFIG);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetDevConfig(Adapter,
                        (PNDIS_TAPI_GET_DEV_CONFIG) InformationBuffer);
        break;

    case OID_TAPI_GET_EXTENSION_ID:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_EXTENSION_ID))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_EXTENSION_ID);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetExtensionID(Adapter,
                        (PNDIS_TAPI_GET_EXTENSION_ID) InformationBuffer);
        break;

    case OID_TAPI_GET_ID:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_ID))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_ID);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetID(Adapter,
                        (PNDIS_TAPI_GET_ID) InformationBuffer);
        break;

    case OID_TAPI_GET_LINE_DEV_STATUS:
        if(InformationBufferLength < sizeof(NDIS_TAPI_GET_LINE_DEV_STATUS))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_GET_LINE_DEV_STATUS);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiGetLineDevStatus(Adapter,
                        (PNDIS_TAPI_GET_LINE_DEV_STATUS) InformationBuffer);
        break;

    case OID_TAPI_MAKE_CALL:
        if(InformationBufferLength < sizeof(NDIS_TAPI_MAKE_CALL))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_MAKE_CALL);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiMakeCall(Adapter,
                        (PNDIS_TAPI_MAKE_CALL) InformationBuffer);
        break;

    case OID_TAPI_NEGOTIATE_EXT_VERSION:// OPTIONAL
        if(InformationBufferLength < sizeof(NDIS_TAPI_NEGOTIATE_EXT_VERSION))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_NEGOTIATE_EXT_VERSION);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiNegotiateExtVersion(Adapter,
                        (PNDIS_TAPI_NEGOTIATE_EXT_VERSION) InformationBuffer);
        break;

    case OID_TAPI_OPEN:
        if(InformationBufferLength < sizeof(NDIS_TAPI_OPEN))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_OPEN);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiOpen(Adapter,
                        (PNDIS_TAPI_OPEN) InformationBuffer);
        break;

    case OID_TAPI_PROVIDER_INITIALIZE:
        if(InformationBufferLength < sizeof(OID_TAPI_PROVIDER_INITIALIZE))
        {
            NumBytesNeeded = sizeof(OID_TAPI_PROVIDER_INITIALIZE);
            break;
        }
        NumBytesWritten = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiProviderInitialize(Adapter,
                        (PNDIS_TAPI_PROVIDER_INITIALIZE) InformationBuffer);
        break;

    default:
        /*
        // Unknown OID
        */
        Status = NDIS_STATUS_INVALID_OID;
        break;
    }

    /*
    // Fill in the size fields before we leave as indicated by the
    // status we are returning.
    */
    if (Status == NDIS_STATUS_INVALID_LENGTH)
    {
        *BytesNeeded = NumBytesNeeded;
        *BytesWritten = 0;
    }
    else
    {
        *BytesNeeded = *BytesWritten = NumBytesWritten;
    }
    DBG_FILTER(Adapter,DBG_REQUEST_ON,
              ("RETURN: Status=%Xh Needed=%d Written=%d\n",
               Status, *BytesNeeded, *BytesWritten));

    DBG_LEAVE(Adapter);

    return (Status);
}


NDIS_STATUS
HtTapiSetInformation(
    IN PHTDSU_ADAPTER Adapter,
    IN NDIS_OID Oid,
    IN PVOID InformationBuffer,
    IN ULONG InformationBufferLength,
    OUT PULONG BytesRead,
    OUT PULONG BytesNeeded
    )

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

Functional Description:

    The HtTapiQueryInformation request allows for control of the TAPI
    portion of the driver's settings and current line status.

    If the Miniport does not complete the call immediately (by returning
    NDIS_STATUS_PENDING), it must call NdisMSetInformationComplete to
    complete the call.  The Miniport controls the buffers pointed to by
    InformationBuffer, BytesRead, and BytesNeeded until the request completes.

    Interrupts are in any state during the call, and no other requests will
    be submitted to the Miniport until this request is completed.

Parameters:

    MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
                             during MiniportInitialize.

    Oid _ The OID.  (See section 2.2.2 of the Extensions to NDIS 3.0 Miniports
          to support Telephonic Services specification for a complete 
          description of the OIDs.)

    InformationBuffer _ The buffer that will receive the information.

    InformationBufferLength _ The length in bytes of InformationBuffer.

    BytesRead_ Returns the number of bytes read from InformationBuffer.

    BytesNeeded _ This parameter returns the number of additional bytes
                  expected to satisfy the OID.

Return Values:

    NDIS_STATUS_INVALID_DATA
    NDIS_STATUS_INVALID_LENGTH
    NDIS_STATUS_INVALID_OID
    NDIS_STATUS_NOT_ACCEPTED
    NDIS_STATUS_NOT_SUPPORTED
    NDIS_STATUS_PENDING
    NDIS_STATUS_RESOURCES
    NDIS_STATUS_SUCCESS

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

{
    DBG_FUNC("HtTapiSetInformation")

    /*
    // Assume the worst, and initialize to handle failure.
    */
    NDIS_STATUS Status = NDIS_STATUS_INVALID_LENGTH;
    ULONG NumBytesNeeded  = 0;
    ULONG NumBytesRead = 0;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter,DBG_REQUEST_ON,
              ("(OID=%s=%08x)\n\t\tInfoLength=%d InfoBuffer=%Xh\n",
               HtTapiGetOidString(Oid),Oid,
               InformationBufferLength,
               InformationBuffer
              ));

    /*
    // Determine which OID is being requested and do the right thing.
    // The switch code will just call the approriate service function
    // to do the real work, so there's not much to worry about here either.
    */
    switch (Oid)
    {
    case OID_TAPI_ACCEPT:               // OPTIONAL
        if (InformationBufferLength < sizeof(NDIS_TAPI_ACCEPT))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_ACCEPT);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiAccept(Adapter,
                        (PNDIS_TAPI_ACCEPT) InformationBuffer);
        break;

    case OID_TAPI_ANSWER:
        if (InformationBufferLength < sizeof(NDIS_TAPI_ANSWER))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_ANSWER);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiAnswer(Adapter,
                        (PNDIS_TAPI_ANSWER) InformationBuffer);
        break;

    case OID_TAPI_CLOSE:
        if (InformationBufferLength < sizeof(NDIS_TAPI_CLOSE))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_CLOSE);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiClose(Adapter,
                        (PNDIS_TAPI_CLOSE) InformationBuffer);
        break;

    case OID_TAPI_CLOSE_CALL:
        if (InformationBufferLength < sizeof(NDIS_TAPI_CLOSE_CALL))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_CLOSE_CALL);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiCloseCall(Adapter,
                        (PNDIS_TAPI_CLOSE_CALL) InformationBuffer);
        break;

    case OID_TAPI_CONDITIONAL_MEDIA_DETECTION:
        if (InformationBufferLength < sizeof(NDIS_TAPI_CONDITIONAL_MEDIA_DETECTION))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_CONDITIONAL_MEDIA_DETECTION);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiConditionalMediaDetection(Adapter,
                        (PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION) InformationBuffer);
        break;

    case OID_TAPI_DIAL:                 // OPTIONAL
        if (InformationBufferLength < sizeof(NDIS_TAPI_DIAL))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_DIAL);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiDial(Adapter,
                        (PNDIS_TAPI_DIAL) InformationBuffer);
        break;

    case OID_TAPI_DROP:
        if (InformationBufferLength < sizeof(NDIS_TAPI_DROP))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_DROP);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiDrop(Adapter,
                        (PNDIS_TAPI_DROP) InformationBuffer);
        break;

    case OID_TAPI_PROVIDER_SHUTDOWN:
        if (InformationBufferLength < sizeof(NDIS_TAPI_PROVIDER_SHUTDOWN))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_PROVIDER_SHUTDOWN);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiProviderShutdown(Adapter,
                        (PNDIS_TAPI_PROVIDER_SHUTDOWN) InformationBuffer);
        break;

    case OID_TAPI_SECURE_CALL:          // OPTIONAL
        if (InformationBufferLength < sizeof(NDIS_TAPI_SECURE_CALL))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SECURE_CALL);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSecureCall(Adapter,
                        (PNDIS_TAPI_SECURE_CALL) InformationBuffer);
        break;

    case OID_TAPI_SELECT_EXT_VERSION:   // OPTIONAL
        if (InformationBufferLength < sizeof(NDIS_TAPI_SELECT_EXT_VERSION))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SELECT_EXT_VERSION);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSelectExtVersion(Adapter,
                        (PNDIS_TAPI_SELECT_EXT_VERSION) InformationBuffer);
        break;

    case OID_TAPI_SEND_USER_USER_INFO:  // OPTIONAL
        if (InformationBufferLength < sizeof(NDIS_TAPI_SEND_USER_USER_INFO))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SEND_USER_USER_INFO);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSendUserUserInfo(Adapter,
                        (PNDIS_TAPI_SEND_USER_USER_INFO) InformationBuffer);
        break;

    case OID_TAPI_SET_APP_SPECIFIC:
        if (InformationBufferLength < sizeof(NDIS_TAPI_SET_APP_SPECIFIC))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SET_APP_SPECIFIC);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSetAppSpecific(Adapter,
                        (PNDIS_TAPI_SET_APP_SPECIFIC) InformationBuffer);
        break;

    case OID_TAPI_SET_CALL_PARAMS:
        if (InformationBufferLength < sizeof(NDIS_TAPI_SET_CALL_PARAMS))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SET_CALL_PARAMS);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSetCallParams(Adapter,
                        (PNDIS_TAPI_SET_CALL_PARAMS) InformationBuffer);
        break;

    case OID_TAPI_SET_DEFAULT_MEDIA_DETECTION:
        if (InformationBufferLength < sizeof(NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSetDefaultMediaDetection(Adapter,
                        (PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION) InformationBuffer);
        break;

    case OID_TAPI_SET_DEV_CONFIG:
        if (InformationBufferLength < sizeof(NDIS_TAPI_SET_DEV_CONFIG))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SET_DEV_CONFIG);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSetDevConfig(Adapter,
                        (PNDIS_TAPI_SET_DEV_CONFIG) InformationBuffer);
        break;

    case OID_TAPI_SET_MEDIA_MODE:
        if (InformationBufferLength < sizeof(NDIS_TAPI_SET_MEDIA_MODE))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SET_MEDIA_MODE);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSetMediaMode(Adapter,
                        (PNDIS_TAPI_SET_MEDIA_MODE) InformationBuffer);
        break;

    case OID_TAPI_SET_STATUS_MESSAGES:
        if (InformationBufferLength < sizeof(NDIS_TAPI_SET_STATUS_MESSAGES))
        {
            NumBytesNeeded = sizeof(NDIS_TAPI_SET_STATUS_MESSAGES);
            break;
        }
        NumBytesRead = NumBytesNeeded = InformationBufferLength;
        Status = HtTapiSetStatusMessages(Adapter,
                        (PNDIS_TAPI_SET_STATUS_MESSAGES) InformationBuffer);
        break;

    default:
        Status = NDIS_STATUS_INVALID_OID;
        break;
    }

    /*
    // Fill in the size fields before we leave as indicated by the
    // status we are returning.
    */
    if (Status == NDIS_STATUS_INVALID_LENGTH)
    {
        *BytesNeeded = NumBytesNeeded;
        *BytesRead = 0;
    }
    else
    {
        *BytesNeeded = *BytesRead = NumBytesRead;
    }
    DBG_FILTER(Adapter,DBG_REQUEST_ON,
              ("RETURN: Status=%Xh Needed=%d Read=%d\n",
               Status, *BytesNeeded, *BytesRead));

    DBG_LEAVE(Adapter);

    return (Status);
}


NDIS_STATUS
HtTapiGetID(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_ID                Request
    )

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

Functional Description:

    This request returns a device ID for the specified device class
    associated with the selected line, address or call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_ID
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulAddressID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulSelect;
        IN  ULONG       ulDeviceClassSize;
        IN  ULONG       ulDeviceClassOffset;
        OUT VAR_STRING  DeviceID;

    } NDIS_TAPI_GET_ID, *PNDIS_TAPI_GET_ID;

    typedef struct _VAR_STRING
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulStringFormat;
        ULONG   ulStringSize;
        ULONG   ulStringOffset;

    } VAR_STRING, *PVAR_STRING;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALDEVICECLASS
    NDIS_STATUS_TAPI_INVALLINEHANDLE
    NDIS_STATUS_TAPI_INVALADDRESSID
    NDIS_STATUS_TAPI_INVALCALLHANDLE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiGetID")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;
    
    /*
    // Remember which device class is being requested.
    */
    UINT DeviceClass;

    /*
    // A pointer to the requested device ID, and its size in bytes.
    */
    PUCHAR IDPtr;
    UINT  IDLength;
    ULONG DeviceID;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulAddressID=%d\n"
               "hdCall=%Xh\n"
               "ulSelect=%Xh\n"
               "ulDeviceClassSize=%d\n"
               "ulDeviceClassOffset=%Xh\n",
               Request->hdLine,
               Request->ulAddressID,
               Request->hdCall,
               Request->ulSelect,
               Request->ulDeviceClassSize,
               Request->ulDeviceClassOffset
              ));
    /*
    // Make sure this is a tapi/line or ndis request.
    */
    if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  NDIS_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = NDIS_DEVICECLASS_ID;
    }
    else if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  TAPI_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = TAPI_DEVICECLASS_ID;
    }
    else
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
        return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
    }

    /*
    // Find the link structure associated with the request/deviceclass.
    */
    if (Request->ulSelect == LINECALLSELECT_LINE)
    {
        Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
        if (Link == NULL)
        {
            DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
            return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
        }
        if (DeviceClass == TAPI_DEVICECLASS_ID)
        {
            /*
            // TAPI just wants the ulDeviceID for this line.
            */
            DeviceID = (ULONG) GET_DEVICEID_FROM_LINK(Adapter, Link);
            IDLength = sizeof(DeviceID);
            IDPtr = (PUCHAR) &DeviceID;
        }
        else    // UNSUPPORTED DEVICE CLASS
        {
            DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
            return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
        }
    }
    else if (Request->ulSelect == LINECALLSELECT_ADDRESS)
    {
        Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
        if (Link == NULL)
        {
            DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
            return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
        }

        if (Request->ulAddressID >= HTDSU_TAPI_NUM_ADDRESSES)
        {
            DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALADDRESSID\n"));
            return (NDIS_STATUS_TAPI_INVALADDRESSID);
        }
        
        /*
        // Currently, there is no defined return value for this case...
        // This is just a place holder for future extensions.
        */
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
        return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
    }
    else if (Request->ulSelect == LINECALLSELECT_CALL)
    {
        Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
        if (Link == NULL)
        {
            DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
            return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
        }
        if (DeviceClass == NDIS_DEVICECLASS_ID)
        {
            /*
            // This must match ConnectionWrapperID used in LINE_UP event!
            */
            DeviceID = (ULONG) Link->htCall;
            IDLength = sizeof(DeviceID);
            IDPtr = (PUCHAR) &DeviceID;
        }
        else    // UNSUPPORTED DEVICE CLASS
        {
            DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
            return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
        }
    }
    else
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_FAILURE\n"));
        return (NDIS_STATUS_FAILURE);
    }

    DBG_NOTICE(Adapter, ("GETID-%d=%Xh\n",Request->ulSelect,DeviceID));
    
    /*
    // Now we need to adjust the variable field to place the device ID.
    */
    Request->DeviceID.ulNeededSize = sizeof(VAR_STRING) + IDLength;
    if (Request->DeviceID.ulTotalSize >= Request->DeviceID.ulNeededSize)
    {
        Request->DeviceID.ulUsedSize     = Request->DeviceID.ulNeededSize;
        Request->DeviceID.ulStringFormat = STRINGFORMAT_BINARY;
        Request->DeviceID.ulStringSize   = IDLength;
        Request->DeviceID.ulStringOffset = sizeof(VAR_STRING);

        /*
        // Now we return the requested ID value.
        */
        NdisMoveMemory(
                (PCHAR) &Request->DeviceID + sizeof(VAR_STRING),
                IDPtr,
                IDLength
                );
    }

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetDevConfig(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_DEV_CONFIG        Request
    )

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

Functional Description:

    This request returns a data structure object, the contents of which are
    specific to the line (miniport) and device class, giving the current
    configuration of a device associated one-to-one with the line device.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_DEV_CONFIG
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  ULONG       ulDeviceClassSize;
        IN  ULONG       ulDeviceClassOffset;
        OUT VAR_STRING  DeviceConfig;

    } NDIS_TAPI_GET_DEV_CONFIG, *PNDIS_TAPI_GET_DEV_CONFIG;

    typedef struct _VAR_STRING
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulStringFormat;
        ULONG   ulStringSize;
        ULONG   ulStringOffset;

    } VAR_STRING, *PVAR_STRING;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALDEVICECLASS
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiGetDevConfig")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    /*
    // Remember which device class is being requested.
    */
    UINT DeviceClass;
    
    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "ulDeviceClassSize=%d\n"
               "ulDeviceClassOffset=%Xh\n",
               Request->ulDeviceID,
               Request->ulDeviceClassSize,
               Request->ulDeviceClassOffset
              ));
    /*
    // Make sure this is a tapi/line or ndis request.
    */
    if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  NDIS_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = NDIS_DEVICECLASS_ID;
    }
    else if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  TAPI_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = TAPI_DEVICECLASS_ID;
    }
    else
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
        return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
    }

    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

    /* 
    // Now we need to adjust the variable field to place the requested device 
    // configuration.
    */
#   define SIZEOF_DEVCONFIG        sizeof(ULONG)
    Request->DeviceConfig.ulNeededSize = sizeof(VAR_STRING) + SIZEOF_DEVCONFIG;
    if (Request->DeviceConfig.ulTotalSize >= Request->DeviceConfig.ulNeededSize)
    {
        Request->DeviceConfig.ulUsedSize     = Request->DeviceConfig.ulNeededSize;
        Request->DeviceConfig.ulStringFormat = STRINGFORMAT_BINARY;
        Request->DeviceConfig.ulStringSize   = SIZEOF_DEVCONFIG;
        Request->DeviceConfig.ulStringOffset = sizeof(VAR_STRING);

        /*
        // There are currently no return values defined for this case.
        // This is just a place holder for future extensions.
        */
        *((ULONG *) ((PCHAR) &Request->DeviceConfig + sizeof(VAR_STRING))) = 
                                0xDEADBEEF;
    }

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiSetDevConfig(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SET_DEV_CONFIG        Request
    )

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

Functional Description:

    This request restores the configuration of a device associated one-to-one
    with the line device from an “” data structure previously obtained using
    OID_TAPI_GET_DEV_CONFIG.  The contents of this data structure are specific
    to the line (miniport) and device class.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SET_DEV_CONFIG
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  ULONG       ulDeviceClassSize;
        IN  ULONG       ulDeviceClassOffset;
        IN  ULONG       ulDeviceConfigSize;
        IN  UCHAR       DeviceConfig[1];

    } NDIS_TAPI_SET_DEV_CONFIG, *PNDIS_TAPI_SET_DEV_CONFIG;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALDEVICECLASS
    NDIS_STATUS_TAPI_INVALPARAM
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiSetDevConfig")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;
    
    /*
    // Remember which device class is being requested.
    */
    UINT DeviceClass;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "ulDeviceClassSize=%d\n"
               "ulDeviceClassOffset=%d\n"
               "ulDeviceConfigSize=%d\n",
               Request->ulDeviceID,
               Request->ulDeviceClassSize,
               Request->ulDeviceClassOffset,
               Request->ulDeviceConfigSize
              ));
    /*
    // Make sure this is a tapi/line or ndis request.
    */
    if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  NDIS_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = NDIS_DEVICECLASS_ID;
    }
    else if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  TAPI_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = TAPI_DEVICECLASS_ID;
    }
    else
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
        return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
    }

    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

    /*
    // Make sure this configuration is the proper size.
    */
    if (Request->ulDeviceConfigSize != SIZEOF_DEVCONFIG)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALPARAM\n"));
        return (NDIS_STATUS_TAPI_INVALPARAM);
    }

    /*
    // Retore the configuration information returned by HtTapiGetDevConfig.
    //
    // There are currently no configuration values defined this case.
    // This is just a place holder for future extensions.
    */
    if (*((ULONG *) ((PCHAR) Request->DeviceConfig)) != 0xDEADBEEF)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALPARAM\n"));
        return (NDIS_STATUS_TAPI_INVALPARAM);
    }

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiConfigDialog(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_CONFIG_DIALOG         Request
    )

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

Functional Description:

    This request retrieves the name of a user-mode dynamic link library that
    can be loaded and called to configure the specified device.  The
    configuration DLL shall export the following function by name:

    LONG WINAPI
    ConfigDialog(
        IN HWND   hwndOwner,
        IN ULONG  ulDeviceID,
        IN LPCSTR lpszDeviceClass
        );

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_CONFIG_DIALOG
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  ULONG       ulDeviceClassSize;
        IN  ULONG       ulDeviceClassOffset;
        IN  ULONG       ulLibraryNameTotalSize;
        OUT ULONG       ulLibraryNameNeededSize;
        OUT CHAR        szLibraryName[1];

    } NDIS_TAPI_CONFIG_DIALOG, *PNDIS_TAPI_CONFIG_DIALOG;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALDEVICECLASS
    NDIS_STATUS_STRUCTURETOOSMALL
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiConfigDialog")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;
    
    /*
    // Remember which device class is being requested.
    */
    UINT DeviceClass;
    
    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "ulDeviceClassSize=%d\n"
               "ulDeviceClassOffset=%Xh\n"
               "ulLibraryNameTotalSize=%d\n",
               Request->ulDeviceID,
               Request->ulDeviceClassSize,
               Request->ulDeviceClassOffset,
               Request->ulLibraryNameTotalSize
              ));
    /*
    // Make sure this is a tapi/line or ndis request.
    */
    if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  NDIS_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = NDIS_DEVICECLASS_ID;
    }
    else if (_strnicmp((PCHAR) Request + Request->ulDeviceClassOffset,
                  TAPI_DEVICECLASS_NAME, Request->ulDeviceClassSize) == 0)
    {
        DeviceClass = TAPI_DEVICECLASS_ID;
    }
    else
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALDEVICECLASS\n"));
        return (NDIS_STATUS_TAPI_INVALDEVICECLASS);
    }

    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

    /*
    // Copy the name of our configuration DLL which we read from the registry
    // during startup, and which was placed there during installation.
    //
    // This driver does not provide a configuration DLL.
    // This is just a place holder for future extensions.
    */
    Request->ulLibraryNameNeededSize = strlen(Adapter->ConfigDLLName) + 1;
    if (Request->ulLibraryNameTotalSize < Request->ulLibraryNameNeededSize)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_STRUCTURETOOSMALL\n"));
        return (NDIS_STATUS_TAPI_STRUCTURETOOSMALL);
    }
    NdisMoveMemory(
            Request->szLibraryName,
            Adapter->ConfigDLLName,
            Request->ulLibraryNameNeededSize
            );

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiDevSpecific(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_DEV_SPECIFIC          Request
    )

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

Functional Description:

    This request is used as a general extension mechanism to enable miniports
    to provide access to features not described in other operations. The meaning
    of the extensions are device-specific, and taking advantage of these
    extensions requires the application to be fully aware of them.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_DEV_SPECIFIC
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulAddressID;
        IN  HDRV_CALL   hdCall;
        IN OUT  ULONG   ulParamsSize;
        IN OUT  UCHAR   Params[1];

    } NDIS_TAPI_DEV_SPECIFIC, *PNDIS_TAPI_DEV_SPECIFIC;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiDevSpecific")

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulAddressID=%d\n"
               "hdCall=%Xh\n"
               "ulParamsSize=%d\n"
               "Params=%Xh\n",
               Request->hdLine,
               Request->ulAddressID,
               Request->hdCall,
               Request->ulParamsSize,
               Request->Params
              ));
    /*
    // You can do what ever you want here, so long as the application
    // agrees with you.
    */

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
}


NDIS_STATUS
HtTapiGetAddressID(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_ADDRESS_ID        Request
    )

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

Functional Description:

    This request returns the address ID associated with address in a different
    format on the specified line.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_ADDRESS_ID
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        OUT ULONG       ulAddressID;
        IN  ULONG       ulAddressMode;
        IN  ULONG       ulAddressSize;
        IN  CHAR        szAddress[1];

    } NDIS_TAPI_GET_ADDRESS_ID, *PNDIS_TAPI_GET_ADDRESS_ID;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALLINEHANDLE
    NDIS_STATUS_TAPI_RESOURCEUNAVAIL

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

{
    DBG_FUNC("HtTapiGetAddressID")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulAddressMode=%Xh\n"
               "ulAddressSize=%d\n"
               "szAddress=%Xh\n",
               Request->hdLine,
               Request->ulAddressMode,
               Request->ulAddressSize,
               Request->szAddress
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

    /*
    // The spec sez it has to be this mode!  Otherwise, we already know
    // that the address ID is (0..N-1).
    */
    if (Request->ulAddressMode != LINEADDRESSMODE_DIALABLEADDR)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_FAILURE\n"));
        return (NDIS_STATUS_FAILURE);
    }

    /*
    // Make sure we have enough room set aside for this address string.
    */
    if (Request->ulAddressSize > sizeof(Link->LineAddress)-1)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_RESOURCEUNAVAIL\n"));
        return (NDIS_STATUS_TAPI_RESOURCEUNAVAIL);
    }

    /*
    // You may need to search each link to find the associated Address.
    // However, this adapter has only one address per link so it's an 
    // easy task.
    */
    Request->ulAddressID = HTDSU_TAPI_ADDRESSID;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetAddressCaps(
    PHTDSU_ADAPTER                      Adapter,
    PNDIS_TAPI_GET_ADDRESS_CAPS         Request
    )

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

Functional Description:

    This request queries the specified address on the specified line device
    to determine its telephony capabilities.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_ADDRESS_CAPS
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  ULONG       ulAddressID;
        IN  ULONG       ulExtVersion;
        OUT LINE_ADDRESS_CAPS   LineAddressCaps;

    } NDIS_TAPI_GET_ADDRESS_CAPS, *PNDIS_TAPI_GET_ADDRESS_CAPS;

    typedef struct _LINE_ADDRESS_CAPS
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulLineDeviceID;

        ULONG   ulAddressSize;
        ULONG   ulAddressOffset;

        ULONG   ulDevSpecificSize;
        ULONG   ulDevSpecificOffset;

        ULONG   ulAddressSharing;
        ULONG   ulAddressStates;
        ULONG   ulCallInfoStates;
        ULONG   ulCallerIDFlags;
        ULONG   ulCalledIDFlags;
        ULONG   ulConnectedIDFlags;
        ULONG   ulRedirectionIDFlags;
        ULONG   ulRedirectingIDFlags;
        ULONG   ulCallStates;
        ULONG   ulDialToneModes;
        ULONG   ulBusyModes;
        ULONG   ulSpecialInfo;
        ULONG   ulDisconnectModes;

        ULONG   ulMaxNumActiveCalls;
        ULONG   ulMaxNumOnHoldCalls;
        ULONG   ulMaxNumOnHoldPendingCalls;
        ULONG   ulMaxNumConference;
        ULONG   ulMaxNumTransConf;

        ULONG   ulAddrCapFlags;
        ULONG   ulCallFeatures;
        ULONG   ulRemoveFromConfCaps;
        ULONG   ulRemoveFromConfState;
        ULONG   ulTransferModes;
        ULONG   ulParkModes;

        ULONG   ulForwardModes;
        ULONG   ulMaxForwardEntries;
        ULONG   ulMaxSpecificEntries;
        ULONG   ulMinFwdNumRings;
        ULONG   ulMaxFwdNumRings;

        ULONG   ulMaxCallCompletions;
        ULONG   ulCallCompletionConds;
        ULONG   ulCallCompletionModes;
        ULONG   ulNumCompletionMessages;
        ULONG   ulCompletionMsgTextEntrySize;
        ULONG   ulCompletionMsgTextSize;
        ULONG   ulCompletionMsgTextOffset;

    } LINE_ADDRESS_CAPS, *PLINE_ADDRESS_CAPS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALADDRESSID
    NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiGetAddressCaps")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    /*
    // Length of the address string assigned to this line device.
    */
    UINT AddressLength;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "ulAddressID=%d\n"
               "ulExtVersion=%Xh\n",
               Request->ulDeviceID,
               Request->ulAddressID,
               Request->ulExtVersion
              ));
    /*
    // Make sure the address is within range - we only support one per line.
    */
    if (Request->ulAddressID >= HTDSU_TAPI_NUM_ADDRESSES)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALADDRESSID\n"));
        return (NDIS_STATUS_TAPI_INVALADDRESSID);
    }

    /*
    // Make sure we are speaking the same language.
    */
#ifdef NDISTAPI_BUG_FIXED
    if (Request->ulExtVersion != 0 &&
        Request->ulExtVersion != HTDSU_TAPI_EXT_VERSION)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION\n"));
        return (NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION);
    }
#endif

    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

#ifndef NDISTAPI_BUG_FIXED
    Request->LineAddressCaps.ulNeededSize =
    Request->LineAddressCaps.ulUsedSize = sizeof(Request->LineAddressCaps);
#endif

    Request->LineAddressCaps.ulLineDeviceID = Request->ulDeviceID;

    /*
    // RASTAPI requires the "I L A" be placed in the Address field at the end
    // of this structure.  Where:
    // I = The device intance assigned to this adapter in the registry
    //     \LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards\I
    // L = The device line number associated with this line (1..NumLines)
    // A = The address (channel) to be used on this line (0..NumAddresses-1)
    */
    AddressLength = strlen(Link->LineAddress) + 1;
    Request->LineAddressCaps.ulNeededSize += AddressLength;
    if (Request->LineAddressCaps.ulNeededSize <= Request->LineAddressCaps.ulTotalSize)
    {
        Request->LineAddressCaps.ulAddressSize = AddressLength;
        Request->LineAddressCaps.ulAddressOffset = sizeof(Request->LineAddressCaps);
        NdisMoveMemory((PUCHAR) &Request->LineAddressCaps +
                                 Request->LineAddressCaps.ulAddressOffset,
                Link->LineAddress,
                AddressLength
                );
        Request->LineAddressCaps.ulUsedSize += AddressLength;
    }
    
    /*
    // Return the various address capabilites for the adapter.
    */
    Request->LineAddressCaps.ulAddressSharing = LINEADDRESSSHARING_PRIVATE;
    Request->LineAddressCaps.ulAddressStates = Link->AddressStatesCaps;
    Request->LineAddressCaps.ulCallStates = Link->CallStatesCaps;
    Request->LineAddressCaps.ulDialToneModes = LINEDIALTONEMODE_NORMAL;
    Request->LineAddressCaps.ulSpecialInfo = LINESPECIALINFO_UNAVAIL;
    Request->LineAddressCaps.ulDisconnectModes =
            LINEDISCONNECTMODE_NORMAL |
            LINEDISCONNECTMODE_UNKNOWN |
            LINEDISCONNECTMODE_BUSY |
            LINEDISCONNECTMODE_NOANSWER;
    /*
    // This device does not support conference calls, transfers, or holds.
    */
    Request->LineAddressCaps.ulMaxNumActiveCalls = 1;
    Request->LineAddressCaps.ulMaxNumTransConf = 1;
    Request->LineAddressCaps.ulAddrCapFlags =
            Link->LineMode == HTDSU_LINEMODE_LEASED ? 0 : LINEADDRCAPFLAGS_DIALED;
    Request->LineAddressCaps.ulCallFeatures =
            LINECALLFEATURE_ACCEPT |
            LINECALLFEATURE_ANSWER |
            LINECALLFEATURE_COMPLETECALL |
            LINECALLFEATURE_DIAL |
            LINECALLFEATURE_DROP;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetAddressStatus(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_ADDRESS_STATUS    Request
    )

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

Functional Description:

    This request queries the specified address for its current status.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_ADDRESS_STATUS
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulAddressID;
        OUT LINE_ADDRESS_STATUS LineAddressStatus;

    } NDIS_TAPI_GET_ADDRESS_STATUS, *PNDIS_TAPI_GET_ADDRESS_STATUS;

    typedef struct _LINE_ADDRESS_STATUS
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulNumInUse;
        ULONG   ulNumActiveCalls;
        ULONG   ulNumOnHoldCalls;
        ULONG   ulNumOnHoldPendCalls;
        ULONG   ulAddressFeatures;

        ULONG   ulNumRingsNoAnswer;
        ULONG   ulForwardNumEntries;
        ULONG   ulForwardSize;
        ULONG   ulForwardOffset;

        ULONG   ulTerminalModesSize;
        ULONG   ulTerminalModesOffset;

        ULONG   ulDevSpecificSize;
        ULONG   ulDevSpecificOffset;

    } LINE_ADDRESS_STATUS, *PLINE_ADDRESS_STATUS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALLINEHANDLE
    NDIS_STATUS_TAPI_INVALADDRESSID

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

{
    DBG_FUNC("HtTapiGetAddressStatus")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulAddressID=%d\n",
               Request->hdLine,
               Request->ulAddressID
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

    /*
    // Make sure the address is within range - we only support one per line.
    */
    if (Request->ulAddressID >= HTDSU_TAPI_NUM_ADDRESSES)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALADDRESSID\n"));
        return (NDIS_STATUS_TAPI_INVALADDRESSID);
    }

#ifndef NDISTAPI_BUG_FIXED
    Request->LineAddressStatus.ulNeededSize =
    Request->LineAddressStatus.ulUsedSize = sizeof(Request->LineAddressStatus);
#endif

    /*
    // Return the current status information for the line.
    */
    Request->LineAddressStatus.ulNumInUse =
            Link->CallState == LINECALLSTATE_IDLE ? 0 : 1;
    Request->LineAddressStatus.ulNumActiveCalls =
            Link->CallState == LINECALLSTATE_IDLE ? 0 : 1;
    Request->LineAddressStatus.ulAddressFeatures =
            Link->CallState == LINECALLSTATE_IDLE ?
                LINEADDRFEATURE_MAKECALL : 0;
    Request->LineAddressStatus.ulNumRingsNoAnswer = 999;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetCallAddressID(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_CALL_ADDRESS_ID   Request
    )

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

Functional Description:

    This request retrieves the address ID for the indicated call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_CALL_ADDRESS_ID
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        OUT ULONG       ulAddressID;

    } NDIS_TAPI_GET_CALL_ADDRESS_ID, *PNDIS_TAPI_GET_CALL_ADDRESS_ID;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiGetCallAddressID")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n",
               Request->hdCall
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // Return the address ID associated with this call.
    */
    Request->ulAddressID = HTDSU_TAPI_ADDRESSID;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetCallInfo(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_CALL_INFO         Request
    )

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

Functional Description:

    This request returns detailed information about the specified call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_CALL_INFO
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        OUT LINE_CALL_INFO  LineCallInfo;

    } NDIS_TAPI_GET_CALL_INFO, *PNDIS_TAPI_GET_CALL_INFO;

    typedef struct _LINE_CALL_INFO
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   hLine;
        ULONG   ulLineDeviceID;
        ULONG   ulAddressID;

        ULONG   ulBearerMode;
        ULONG   ulRate;
        ULONG   ulMediaMode;

        ULONG   ulAppSpecific;
        ULONG   ulCallID;
        ULONG   ulRelatedCallID;
        ULONG   ulCallParamFlags;
        ULONG   ulCallStates;

        ULONG   ulMonitorDigitModes;
        ULONG   ulMonitorMediaModes;
        LINE_DIAL_PARAMS    DialParams;

        ULONG   ulOrigin;
        ULONG   ulReason;
        ULONG   ulCompletionID;
        ULONG   ulNumOwners;
        ULONG   ulNumMonitors;

        ULONG   ulCountryCode;
        ULONG   ulTrunk;

        ULONG   ulCallerIDFlags;
        ULONG   ulCallerIDSize;
        ULONG   ulCallerIDOffset;
        ULONG   ulCallerIDNameSize;
        ULONG   ulCallerIDNameOffset;

        ULONG   ulCalledIDFlags;
        ULONG   ulCalledIDSize;
        ULONG   ulCalledIDOffset;
        ULONG   ulCalledIDNameSize;
        ULONG   ulCalledIDNameOffset;

        ULONG   ulConnectedIDFlags;
        ULONG   ulConnectedIDSize;
        ULONG   ulConnectedIDOffset;
        ULONG   ulConnectedIDNameSize;
        ULONG   ulConnectedIDNameOffset;

        ULONG   ulRedirectionIDFlags;
        ULONG   ulRedirectionIDSize;
        ULONG   ulRedirectionIDOffset;
        ULONG   ulRedirectionIDNameSize;
        ULONG   ulRedirectionIDNameOffset;

        ULONG   ulRedirectingIDFlags;
        ULONG   ulRedirectingIDSize;
        ULONG   ulRedirectingIDOffset;
        ULONG   ulRedirectingIDNameSize;
        ULONG   ulRedirectingIDNameOffset;

        ULONG   ulAppNameSize;
        ULONG   ulAppNameOffset;

        ULONG   ulDisplayableAddressSize;
        ULONG   ulDisplayableAddressOffset;

        ULONG   ulCalledPartySize;
        ULONG   ulCalledPartyOffset;

        ULONG   ulCommentSize;
        ULONG   ulCommentOffset;

        ULONG   ulDisplaySize;
        ULONG   ulDisplayOffset;

        ULONG   ulUserUserInfoSize;
        ULONG   ulUserUserInfoOffset;

        ULONG   ulHighLevelCompSize;
        ULONG   ulHighLevelCompOffset;

        ULONG   ulLowLevelCompSize;
        ULONG   ulLowLevelCompOffset;

        ULONG   ulChargingInfoSize;
        ULONG   ulChargingInfoOffset;

        ULONG   ulTerminalModesSize;
        ULONG   ulTerminalModesOffset;

        ULONG   ulDevSpecificSize;
        ULONG   ulDevSpecificOffset;

    } LINE_CALL_INFO, *PLINE_CALL_INFO;

    typedef struct _LINE_DIAL_PARAMS
    {
        ULONG   ulDialPause;
        ULONG   ulDialSpeed;
        ULONG   ulDigitDuration;
        ULONG   ulWaitForDialtone;

    } LINE_DIAL_PARAMS, *PLINE_DIAL_PARAMS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiGetCallInfo")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n",
               Request->hdCall
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

#ifndef NDISTAPI_BUG_FIXED
    Request->LineCallInfo.ulNeededSize =
    Request->LineCallInfo.ulUsedSize = sizeof(Request->LineCallInfo);
#endif

    /*
    // We don't expect user user info.
    */
    ASSERT(Request->LineCallInfo.ulUserUserInfoSize == 0);

    /*
    // The link has all the call information we need to return.
    */
    Request->LineCallInfo.hLine = (ULONG) Link;
    Request->LineCallInfo.ulLineDeviceID = GET_DEVICEID_FROM_LINK(Adapter, Link);
    Request->LineCallInfo.ulAddressID = HTDSU_TAPI_ADDRESSID;

    Request->LineCallInfo.ulBearerMode = LINEBEARERMODE_DATA;
    Request->LineCallInfo.ulRate = Link->LinkSpeed;
    Request->LineCallInfo.ulMediaMode = Link->MediaModesMask;

    Request->LineCallInfo.ulCallParamFlags = LINECALLPARAMFLAGS_IDLE;
    Request->LineCallInfo.ulCallStates = Link->CallStatesMask;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetCallStatus(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_CALL_STATUS       Request
    )

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

Functional Description:

    This request returns detailed information about the specified call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_CALL_STATUS
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        OUT LINE_CALL_STATUS    LineCallStatus;

    } NDIS_TAPI_GET_CALL_STATUS, *PNDIS_TAPI_GET_CALL_STATUS;

    typedef struct _LINE_CALL_STATUS
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulCallState;
        ULONG   ulCallStateMode;
        ULONG   ulCallPrivilege;
        ULONG   ulCallFeatures;

        ULONG   ulDevSpecificSize;
        ULONG   ulDevSpecificOffset;

    } LINE_CALL_STATUS, *PLINE_CALL_STATUS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiGetCallStatus")

    /*
    // Holds the status result returned this function.
    */
    NDIS_STATUS Status;

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n",
               Request->hdCall
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

#ifndef NDISTAPI_BUG_FIXED
    Request->LineCallStatus.ulNeededSize =
    Request->LineCallStatus.ulUsedSize = sizeof(Request->LineCallStatus);
#endif

    /*
    // The link has all the call information.
    */
    Request->LineCallStatus.ulCallPrivilege = LINECALLPRIVILEGE_OWNER;
    Request->LineCallStatus.ulCallState = Link->CallState;

    /*
    // Tag CallStateMode with appropriate value for the current CallState.
    */
    if (Link->CallState == LINECALLSTATE_DIALTONE)
    {
        Request->LineCallStatus.ulCallStateMode = LINEDIALTONEMODE_NORMAL;
    }
    else if (Link->CallState == LINECALLSTATE_BUSY)
    {
        Request->LineCallStatus.ulCallStateMode = LINEBUSYMODE_STATION;
    }
    else if (Link->CallState == LINECALLSTATE_DISCONNECTED)
    {
        /*
        // We need to query/save the line status to find out what happened.
        */
        if (CardStatusNoAnswer(Adapter, Link->CardLine))
        {
            Request->LineCallStatus.ulCallStateMode = LINEDISCONNECTMODE_NOANSWER;
        }
        else if (CardStatusNoDialTone(Adapter, Link->CardLine))
        {
            Request->LineCallStatus.ulCallStateMode = LINEDISCONNECTMODE_BUSY;
        }
        else
        {
            Request->LineCallStatus.ulCallStateMode = LINEDISCONNECTMODE_UNKNOWN;
        }
    }

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetDevCaps(
    PHTDSU_ADAPTER                      Adapter,
    PNDIS_TAPI_GET_DEV_CAPS             Request
    )

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

Functional Description:

    This request queries a specified line device to determine its telephony
    capabilities. The returned information is valid for all addresses on the
    line device.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_DEV_CAPS
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  ULONG       ulExtVersion;
        OUT LINE_DEV_CAPS   LineDevCaps;

    } NDIS_TAPI_GET_DEV_CAPS, *PNDIS_TAPI_GET_DEV_CAPS;

    typedef struct _LINE_DEV_CAPS
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulProviderInfoSize;
        ULONG   ulProviderInfoOffset;

        ULONG   ulSwitchInfoSize;
        ULONG   ulSwitchInfoOffset;

        ULONG   ulPermanentLineID;
        ULONG   ulLineNameSize;
        ULONG   ulLineNameOffset;
        ULONG   ulStringFormat;

        ULONG   ulAddressModes;
        ULONG   ulNumAddresses;
        ULONG   ulBearerModes;
        ULONG   ulMaxRate;
        ULONG   ulMediaModes;

        ULONG   ulGenerateToneModes;
        ULONG   ulGenerateToneMaxNumFreq;
        ULONG   ulGenerateDigitModes;
        ULONG   ulMonitorToneMaxNumFreq;
        ULONG   ulMonitorToneMaxNumEntries;
        ULONG   ulMonitorDigitModes;
        ULONG   ulGatherDigitsMinTimeout;
        ULONG   ulGatherDigitsMaxTimeout;

        ULONG   ulMedCtlDigitMaxListSize;
        ULONG   ulMedCtlMediaMaxListSize;
        ULONG   ulMedCtlToneMaxListSize;
        ULONG   ulMedCtlCallStateMaxListSize;

        ULONG   ulDevCapFlags;
        ULONG   ulMaxNumActiveCalls;
        ULONG   ulAnswerMode;
        ULONG   ulRingModes;
        ULONG   ulLineStates;

        ULONG   ulUUIAcceptSize;
        ULONG   ulUUIAnswerSize;
        ULONG   ulUUIMakeCallSize;
        ULONG   ulUUIDropSize;
        ULONG   ulUUISendUserUserInfoSize;
        ULONG   ulUUICallInfoSize;

        LINE_DIAL_PARAMS    MinDialParams;
        LINE_DIAL_PARAMS    MaxDialParams;
        LINE_DIAL_PARAMS    DefaultDialParams;

        ULONG   ulNumTerminals;
        ULONG   ulTerminalCapsSize;
        ULONG   ulTerminalCapsOffset;
        ULONG   ulTerminalTextEntrySize;
        ULONG   ulTerminalTextSize;
        ULONG   ulTerminalTextOffset;

        ULONG   ulDevSpecificSize;
        ULONG   ulDevSpecificOffset;

    } LINE_DEV_CAPS, *PLINE_DEV_CAPS;

    typedef struct _LINE_DIAL_PARAMS
    {
        ULONG   ulDialPause;
        ULONG   ulDialSpeed;
        ULONG   ulDigitDuration;
        ULONG   ulWaitForDialtone;

    } LINE_DIAL_PARAMS, *PLINE_DIAL_PARAMS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiGetDevCaps")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "ulExtVersion=%Xh\n"
               "LineDevCaps=%Xh\n",
               Request->ulDeviceID,
               Request->ulExtVersion,
               &Request->LineDevCaps
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

#ifndef NDISTAPI_BUG_FIXED
    Request->LineDevCaps.ulNeededSize =
    Request->LineDevCaps.ulUsedSize = sizeof(Request->LineDevCaps);
#endif

    /*
    // The driver numbers lines sequentially from 1, so this will always
    // be the same number.
    */
    Request->LineDevCaps.ulPermanentLineID = Link->CardLine;

    /*
    // RASTAPI requires the "MediaType\0DeviceName" be placed in the
    // ProviderInfo field at the end of this structure.
    */
    Request->LineDevCaps.ulNeededSize += Adapter->ProviderInfoSize;
    if (Request->LineDevCaps.ulNeededSize <= Request->LineDevCaps.ulTotalSize)
    {
        Request->LineDevCaps.ulProviderInfoSize = Adapter->ProviderInfoSize;
        Request->LineDevCaps.ulProviderInfoOffset = sizeof(Request->LineDevCaps);
        NdisMoveMemory((PUCHAR) &Request->LineDevCaps +
                                 Request->LineDevCaps.ulProviderInfoOffset,
                Adapter->ProviderInfo,
                Adapter->ProviderInfoSize
                );
        Request->LineDevCaps.ulUsedSize += Adapter->ProviderInfoSize;
    }
    Request->LineDevCaps.ulStringFormat = STRINGFORMAT_ASCII;

    /*
    // This device is a switched 56kb line for digital data only.
    */
    Request->LineDevCaps.ulAddressModes = LINEADDRESSMODE_ADDRESSID |
                                          LINEADDRESSMODE_DIALABLEADDR;
    Request->LineDevCaps.ulNumAddresses = 1;
    Request->LineDevCaps.ulBearerModes  = LINEBEARERMODE_DATA;
    Request->LineDevCaps.ulMaxRate      = Link->LinkSpeed;
    Request->LineDevCaps.ulMediaModes   = Link->MediaModesCaps;

    /*
    // Each line on the DSU only supports a single call.
    */
    Request->LineDevCaps.ulDevCapFlags = LINEDEVCAPFLAGS_CLOSEDROP;
    Request->LineDevCaps.ulMaxNumActiveCalls = 1;
    Request->LineDevCaps.ulAnswerMode = LINEANSWERMODE_DROP;
    Request->LineDevCaps.ulRingModes  = 1;
    Request->LineDevCaps.ulLineStates = Link->DevStatesCaps;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetExtensionID(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_EXTENSION_ID      Request
    )

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

Functional Description:

    This request returns the extension ID that the miniport supports for the
    indicated line device.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_EXTENSION_ID
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        OUT LINE_EXTENSION_ID   LineExtensionID;

    } NDIS_TAPI_GET_EXTENSION_ID, *PNDIS_TAPI_GET_EXTENSION_ID;

    typedef struct _LINE_EXTENSION_ID
    {
        ULONG   ulExtensionID0;
        ULONG   ulExtensionID1;
        ULONG   ulExtensionID2;
        ULONG   ulExtensionID3;

    } LINE_EXTENSION_ID, *PLINE_EXTENSION_ID;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiGetExtensionID")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n",
               Request->ulDeviceID
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

    /*
    // This driver does not support any extensions, so we return zeros.
    */
    Request->LineExtensionID.ulExtensionID0 = 0;
    Request->LineExtensionID.ulExtensionID1 = 0;
    Request->LineExtensionID.ulExtensionID2 = 0;
    Request->LineExtensionID.ulExtensionID3 = 0;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiGetLineDevStatus(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_GET_LINE_DEV_STATUS   Request
    )

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

Functional Description:

    This request queries the specified open line device for its current status.
    The information returned is global to all addresses on the line.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_GET_LINE_DEV_STATUS
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        OUT LINE_DEV_STATUS LineDevStatus;

    } NDIS_TAPI_GET_LINE_DEV_STATUS, *PNDIS_TAPI_GET_LINE_DEV_STATUS;

    typedef struct _LINE_DEV_STATUS
    {
        ULONG   ulTotalSize;
        ULONG   ulNeededSize;
        ULONG   ulUsedSize;

        ULONG   ulNumOpens;
        ULONG   ulOpenMediaModes;
        ULONG   ulNumActiveCalls;
        ULONG   ulNumOnHoldCalls;
        ULONG   ulNumOnHoldPendCalls;
        ULONG   ulLineFeatures;
        ULONG   ulNumCallCompletions;
        ULONG   ulRingMode;
        ULONG   ulSignalLevel;
        ULONG   ulBatteryLevel;
        ULONG   ulRoamMode;

        ULONG   ulDevStatusFlags;

        ULONG   ulTerminalModesSize;
        ULONG   ulTerminalModesOffset;

        ULONG   ulDevSpecificSize;
        ULONG   ulDevSpecificOffset;

    } LINE_DEV_STATUS, *PLINE_DEV_STATUS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALLINEHANDLE

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

{
    DBG_FUNC("HtTapiGetLineDevStatus")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n",
               Request->hdLine
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

#ifndef NDISTAPI_BUG_FIXED
    Request->LineDevStatus.ulNeededSize =
    Request->LineDevStatus.ulUsedSize = sizeof(Request->LineDevStatus);
#endif

    /*
    // Return the current line status information.
    */
    Request->LineDevStatus.ulNumActiveCalls;
            Link->CallState == LINECALLSTATE_IDLE ? 0 : 1;
    Request->LineDevStatus.ulLineFeatures;
            Link->CallState == LINECALLSTATE_IDLE ?
                LINEFEATURE_MAKECALL : 0;
    Request->LineDevStatus.ulRingMode =
            Link->DevState == LINEDEVSTATE_RINGING ? 1: 0;
    Request->LineDevStatus.ulDevStatusFlags =
            Link->DevState == LINEDEVSTATE_CONNECTED ?
                LINEDEVSTATUSFLAGS_INSERVICE | LINEDEVSTATUSFLAGS_CONNECTED : 0;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiMakeCall(
    PHTDSU_ADAPTER                      Adapter,
    PNDIS_TAPI_MAKE_CALL                Request
    )

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

Functional Description:

    This request places a call on the specified line to the specified
    destination address. Optionally, call parameters can be specified if
    anything but default call setup parameters are requested.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_MAKE_CALL
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  HTAPI_CALL  htCall;
        OUT HDRV_CALL   hdCall;
        IN  ULONG       ulDestAddressSize;
        IN  ULONG       ulDestAddressOffset;
        IN  BOOLEAN     bUseDefaultLineCallParams;
        IN  LINE_CALL_PARAMS    LineCallParams;

    } NDIS_TAPI_MAKE_CALL, *PNDIS_TAPI_MAKE_CALL;

    typedef struct _LINE_CALL_PARAMS        // Defaults:
    {
        ULONG   ulTotalSize;                // ---------

        ULONG   ulBearerMode;               // voice
        ULONG   ulMinRate;                  // (3.1kHz)
        ULONG   ulMaxRate;                  // (3.1kHz)
        ULONG   ulMediaMode;                // interactiveVoice

        ULONG   ulCallParamFlags;           // 0
        ULONG   ulAddressMode;              // addressID
        ULONG   ulAddressID;                // (any available)

        LINE_DIAL_PARAMS DialParams;        // (0, 0, 0, 0)

        ULONG   ulOrigAddressSize;          // 0
        ULONG   ulOrigAddressOffset;
        ULONG   ulDisplayableAddressSize;
        ULONG   ulDisplayableAddressOffset;

        ULONG   ulCalledPartySize;          // 0
        ULONG   ulCalledPartyOffset;

        ULONG   ulCommentSize;              // 0
        ULONG   ulCommentOffset;

        ULONG   ulUserUserInfoSize;         // 0
        ULONG   ulUserUserInfoOffset;

        ULONG   ulHighLevelCompSize;        // 0
        ULONG   ulHighLevelCompOffset;

        ULONG   ulLowLevelCompSize;         // 0
        ULONG   ulLowLevelCompOffset;

        ULONG   ulDevSpecificSize;          // 0
        ULONG   ulDevSpecificOffset;

    } LINE_CALL_PARAMS, *PLINE_CALL_PARAMS;

    typedef struct _LINE_DIAL_PARAMS
    {
        ULONG   ulDialPause;
        ULONG   ulDialSpeed;
        ULONG   ulDigitDuration;
        ULONG   ulWaitForDialtone;

    } LINE_DIAL_PARAMS, *PLINE_DIAL_PARAMS;

Return Values:

    NDIS_STATUS_TAPI_ADDRESSBLOCKED
    NDIS_STATUS_TAPI_BEARERMODEUNAVAIL
    NDIS_STATUS_TAPI_CALLUNAVAIL
    NDIS_STATUS_TAPI_DIALBILLING
    NDIS_STATUS_TAPI_DIALQUIET
    NDIS_STATUS_TAPI_DIALDIALTONE
    NDIS_STATUS_TAPI_DIALPROMPT
    NDIS_STATUS_TAPI_INUSE
    NDIS_STATUS_TAPI_INVALADDRESSMODE
    NDIS_STATUS_TAPI_INVALBEARERMODE
    NDIS_STATUS_TAPI_INVALMEDIAMODE
    NDIS_STATUS_TAPI_INVALLINESTATE
    NDIS_STATUS_TAPI_INVALRATE
    NDIS_STATUS_TAPI_INVALLINEHANDLE
    NDIS_STATUS_TAPI_INVALADDRESS
    NDIS_STATUS_TAPI_INVALADDRESSID
    NDIS_STATUS_TAPI_INVALCALLPARAMS
    NDIS_STATUS_RESOURCES
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_RESOURCEUNAVAIL
    NDIS_STATUS_TAPI_RATEUNAVAIL
    NDIS_STATUS_TAPI_USERUSERINFOTOOBIG

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

{
    DBG_FUNC("HtTapiMakeCall")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "htCall=%Xh\n"
               "ulDestAddressSize=%d\n"
               "ulDestAddressOffset=%Xh\n"
               "bUseDefaultLineCallParams=%d\n"
               "LineCallParams=%Xh\n",
               Request->hdLine,
               Request->htCall,
               Request->ulDestAddressSize,
               Request->ulDestAddressOffset,
               Request->bUseDefaultLineCallParams,
               Request->LineCallParams
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }
    
    /*
    // We should be idle when this call comes down, but if we're out of
    // state for seom reason, don't let this go any further.
    */
    if (Link->CallState != LINECALLSTATE_IDLE)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INUSE\n"));
        return (NDIS_STATUS_TAPI_INUSE);
    }

    /*
    // Currently, the defaultCallParams feature is not used by RASTAPI.
    // Normally, you would save the default params passed into 
    // OID_TAPI_SET_CALL_PARAM and apply them here.
    */
    ASSERT(Request->bUseDefaultLineCallParams == FALSE);

    /*
    // We don't expect user user info.
    */
    ASSERT(Request->LineCallParams.ulUserUserInfoSize == 0);
    
    /*
    // We gotta make sure the line is in the right state before attempt.
    */
    if (Link->LineMode != HTDSU_LINEMODE_DIALUP ||
        CardStatusNoSignal(Adapter, Link->CardLine) ||
        CardStatusOutOfService(Adapter, Link->CardLine) ||
        CardStatusCarrierDetect(Adapter, Link->CardLine))
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_OPERATIONUNAVAIL\n"));
        return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
    }

    /*
    // Remember the TAPI call connection handle.
    */
    Link->htCall = Request->htCall;

    /*
    // Since we only allow one call per line, we use the same handle.
    */
    Request->hdCall = (HDRV_CALL)Link;

    /*
    // Dial the number if it's available, otherwise it may come via
    // OID_TAPI_DIAL.  Be aware the the phone number format may be
    // different for other applications.  I'm assuming an ASCII digits
    // string.
    */
    if (Request->ulDestAddressSize)
    {
        PUCHAR DialString = ((PUCHAR)Request) + Request->ulDestAddressOffset;

        DBG_NOTICE(Adapter,("Dialing: '%s'\n",DialString));

        HtTapiCallStateHandler(Adapter, Link,
                LINECALLSTATE_DIALTONE, LINEDIALTONEMODE_NORMAL);
        CardDialNumber(Adapter,
                Link->CardLine,
                DialString,
                Request->ulDestAddressSize
                );
        /*
        // We should see a HTDSU_NO_DIAL_TONE within 5 seconds if the
        // call will not go through.
        */
        HtTapiCallStateHandler(Adapter, Link, LINECALLSTATE_DIALING, 0);
        NdisMSetTimer(&Link->CallTimer, HTDSU_NO_DIALTONE_TIMEOUT);
    }

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiNegotiateExtVersion(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_NEGOTIATE_EXT_VERSION Request
    )

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

Functional Description:

    This request returns the highest extension version number the service
    provider is willing to operate under for this device given the range of
    possible extension versions.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_NEGOTIATE_EXT_VERSION
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  ULONG       ulLowVersion;
        IN  ULONG       ulHighVersion;
        OUT ULONG       ulExtVersion;
    } NDIS_TAPI_NEGOTIATE_EXT_VERSION, *PNDIS_TAPI_NEGOTIATE_EXT_VERSION;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION

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

{
    DBG_FUNC("HtTapiNegotiateExtVersion")

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "ulLowVersion=%Xh\n"
               "ulHighVersion=%Xh\n",
               Request->ulDeviceID,
               Request->ulLowVersion,
               Request->ulHighVersion
              ));
    /*
    // Make sure the miniport's version number is within the allowable
    // range requested by the caller.  We ignore the ulDeviceID because
    // the version information applies to all devices on this adapter.
    */
    if (HTDSU_TAPI_EXT_VERSION < Request->ulLowVersion ||
        HTDSU_TAPI_EXT_VERSION > Request->ulHighVersion)
    {
        DBG_WARNING(Adapter, ("NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION\n"));
        return (NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION);
    }

    /*
    // Looks like we're compatible, so tell the caller what we expect.
    */
    Request->ulExtVersion = HTDSU_TAPI_EXT_VERSION;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiOpen(
    PHTDSU_ADAPTER                      Adapter,
    PNDIS_TAPI_OPEN                     Request
    )

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

Functional Description:

    This function opens the line device whose device ID is given, returning
    the miniport’s handle for the device. The miniport must retain the
    Connection Wrapper's handle for the device for use in subsequent calls to
    the LINE_EVENT callback procedure.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request - A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_OPEN
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceID;
        IN  HTAPI_LINE  htLine;
        OUT HDRV_LINE   hdLine;

    } NDIS_TAPI_OPEN, *PNDIS_TAPI_OPEN;

Return Values:

    NDIS_STATUS_PENDING
    NDIS_STATUS_TAPI_ALLOCATED
    NDIS_STATUS_TAPI_NODRIVER

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

{
    DBG_FUNC("HtTapiOpen")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceID=%d\n"
               "htLine=%Xh\n",
               Request->ulDeviceID,
               Request->htLine
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_DEVICEID(Adapter, Request->ulDeviceID);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_NODRIVER\n"));
        return (NDIS_STATUS_TAPI_NODRIVER);
    }

    /*
    // Make sure the requested line device is not already in use.
    */
    Link = LinkAllocate(Adapter, Request->htLine,
                        (USHORT) (Link->CardLine-HTDSU_CMD_LINE1));
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_ALLOCATED\n"));
        return (NDIS_STATUS_TAPI_ALLOCATED);
    }

    /*
    // Tell the wrapper the line context and set the line/call state.
    */
    Request->hdLine = (HDRV_LINE)Link;
    HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_OPEN);

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiProviderInitialize(
    PHTDSU_ADAPTER                      Adapter,
    PNDIS_TAPI_PROVIDER_INITIALIZE      Request
    )

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

Functional Description:

    This request initializes the TAPI portion of the miniport.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_PROVIDER_INITIALIZE
    {
        IN  ULONG       ulRequestID;
        IN  ULONG       ulDeviceIDBase;
        OUT ULONG       ulNumLineDevs;
        OUT ULONG       ulProviderID;

    } NDIS_TAPI_PROVIDER_INITIALIZE, *PNDIS_TAPI_PROVIDER_INITIALIZE;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_RESOURCES
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_RESOURCEUNAVAIL

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

{
    DBG_FUNC("HtTapiProviderInitialize")

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("ulDeviceIDBase=%d\n",
               Request->ulDeviceIDBase
              ));
    /*
    // Save the device ID base value.
    */
    Adapter->DeviceIdBase = Request->ulDeviceIDBase;

    /*
    // Return the number of DSU lines. Assumes the miniport has initialized,
    // self-tested, etc.
    */
    Request->ulNumLineDevs = Adapter->NumLineDevs;

    /*
    // Before completing the PROVIDER_INIT request, the miniport should fill
    // in the ulNumLineDevs field of the request with the number of line
    // devices supported by the adapter. The miniport should also set the
    // ulProviderID field to a unique (per adapter) value. (There is no
    // method currently in place to guarantee unique ulProviderID values,
    // so we use the virtual address of our adapter structure.)
    */
    Request->ulProviderID = (ULONG)Adapter;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiAccept(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_ACCEPT                Request
    )

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

Functional Description:

    This request accepts the specified offered call. It may optionally send
    the specified user-to-user information to the calling party.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_ACCEPT
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulUserUserInfoSize;
        IN  UCHAR       UserUserInfo[1];

    } NDIS_TAPI_ACCEPT, *PNDIS_TAPI_ACCEPT;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiAccept")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulUserUserInfoSize=%d\n"
               "UserUserInfo=%Xh\n",
               Request->hdCall,
               Request->ulUserUserInfoSize,
               Request->UserUserInfo
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // We don't expect user user info.
    */
    ASSERT(Request->ulUserUserInfoSize == 0);
    
    /*
    // Note that the call has been accepted, we should see and answer soon.
    */
    HtTapiCallStateHandler(Adapter, Link, LINECALLSTATE_ACCEPTED, 0);

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiAnswer(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_ANSWER                Request
    )

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

Functional Description:

    This request answers the specified offering call.  It may optionally send
    the specified user-to-user information to the calling party.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_ANSWER
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulUserUserInfoSize;
        IN  UCHAR       UserUserInfo[1];

    } NDIS_TAPI_ANSWER, *PNDIS_TAPI_ANSWER;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiAnswer")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulUserUserInfoSize=%d\n"
               "UserUserInfo=%Xh\n",
               Request->hdCall,
               Request->ulUserUserInfoSize,
               Request->UserUserInfo
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // We don't expect user user info.
    */
    ASSERT(Request->ulUserUserInfoSize == 0);

    /*
    // Tell the adapter to pick up the line, and wait for a connect interrupt.
    */
    CardLineAnswer(Adapter, Link->CardLine);
    NdisMSetTimer(&Link->CallTimer, HTDSU_NO_CONNECT_TIMEOUT);

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiClose(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_CLOSE                 Request
    )

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

Functional Description:

    This request closes the specified open line device after completing or
    aborting all outstanding calls and asynchronous requests on the device.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_CLOSE
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;

    } NDIS_TAPI_CLOSE, *PNDIS_TAPI_CLOSE;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_PENDING
    NDIS_STATUS_TAPI_INVALLINEHANDLE

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

{
    DBG_FUNC("HtTapiClose")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    /*
    // The results of this call.
    */
    NDIS_STATUS Status;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n",
               Request->hdLine
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

    /*
    // Mark the link as closing, so no more packets will be accepted,
    // and when the last transmit is complete, the link will be closed.
    */
    if (Link->NumTxQueued)
    {
        Status = NDIS_STATUS_PENDING;
        Link->Closing = TRUE;
    }
    else
    {
        HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_CLOSE);
        LinkRelease(Link);
        Status = NDIS_STATUS_SUCCESS;
    }

    DBG_LEAVE(Adapter);

    return (Status);
}


NDIS_STATUS
HtTapiCloseCall(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_CLOSE_CALL            Request
    )

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

Functional Description:

    This request deallocates the call after completing or aborting all
    outstanding asynchronous requests on the call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_CLOSE_CALL
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;

    } NDIS_TAPI_CLOSE_CALL, *PNDIS_TAPI_CLOSE_CALL;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiCloseCall")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    /*
    // The results of this call.
    */
    NDIS_STATUS Status;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n",
               Request->hdCall
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // Mark the link as closing, so no more packets will be accepted,
    // and when the last transmit is complete, the link will be closed.
    */
    if (Link->NumTxQueued)
    {
        Link->CallClosing = TRUE;
        Status = NDIS_STATUS_PENDING;
    }
    else
    {
        HtTapiCallStateHandler(Adapter, Link, LINECALLSTATE_IDLE, 0);
        Status = NDIS_STATUS_SUCCESS;
    }

    DBG_LEAVE(Adapter);

    return (Status);
}


NDIS_STATUS
HtTapiConditionalMediaDetection(
    IN PHTDSU_ADAPTER                           Adapter,
    IN PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION   Request
    )

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

Functional Description:

    This request is invoked by the Connection Wrapper whenever a client 
    application uses LINEMAPPER as the dwDeviceID in the lineOpen function 
    to request that lines be scanned to find one that supports the desired 
    media mode(s) and call parameters. The Connection Wrapper scans based on
    the union of the desired media modes and the other media modes currently 
    being monitored on the line, to give the miniport the opportunity to 
    indicate if it cannot simultaneously monitor for all of the requested 
    media modes. If the miniport can monitor for the indicated set of media 
    modes AND support the capabilities indicated in CallParams, it replies 
    with a “success” inidication. It leaves the active media monitoring modes 
    for the line unchanged.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_CONDITIONAL_MEDIA_DETECTION
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulMediaModes;
        IN  LINE_CALL_PARAMS    LineCallParams;

    } NDIS_TAPI_CONDITIONAL_MEDIA_DETECTION, *PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION;

    typedef struct _LINE_CALL_PARAMS        // Defaults:
    {
        ULONG   ulTotalSize;                // ---------

        ULONG   ulBearerMode;               // voice
        ULONG   ulMinRate;                  // (3.1kHz)
        ULONG   ulMaxRate;                  // (3.1kHz)
        ULONG   ulMediaMode;                // interactiveVoice

        ULONG   ulCallParamFlags;           // 0
        ULONG   ulAddressMode;              // addressID
        ULONG   ulAddressID;                // (any available)

        LINE_DIAL_PARAMS DialParams;        // (0, 0, 0, 0)

        ULONG   ulOrigAddressSize;          // 0
        ULONG   ulOrigAddressOffset;
        ULONG   ulDisplayableAddressSize;
        ULONG   ulDisplayableAddressOffset;

        ULONG   ulCalledPartySize;          // 0
        ULONG   ulCalledPartyOffset;

        ULONG   ulCommentSize;              // 0
        ULONG   ulCommentOffset;

        ULONG   ulUserUserInfoSize;         // 0
        ULONG   ulUserUserInfoOffset;

        ULONG   ulHighLevelCompSize;        // 0
        ULONG   ulHighLevelCompOffset;

        ULONG   ulLowLevelCompSize;         // 0
        ULONG   ulLowLevelCompOffset;

        ULONG   ulDevSpecificSize;          // 0
        ULONG   ulDevSpecificOffset;

    } LINE_CALL_PARAMS, *PLINE_CALL_PARAMS;

    typedef struct _LINE_DIAL_PARAMS
    {
        ULONG   ulDialPause;
        ULONG   ulDialSpeed;
        ULONG   ulDigitDuration;
        ULONG   ulWaitForDialtone;

    } LINE_DIAL_PARAMS, *PLINE_DIAL_PARAMS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALLINEHANDLE

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

{
    DBG_FUNC("HtTapiConditionalMediaDetection")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulMediaModes=%Xh\n"
               "LineCallParams=%Xh\n",
               Request->hdLine,
               Request->ulMediaModes,
               &Request->LineCallParams
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

    /*
    // We don't expect user user info.
    */
    ASSERT(Request->LineCallParams.ulUserUserInfoSize == 0);
    
    /*
    // I pretty much ignore all this since this adapter only supports 
    // digital data.  If your adapter supports different medias or
    // voice and data,  you will need to save the necessary paramters.
    */
    Link->MediaModesMask = Request->ulMediaModes;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiDial(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_DIAL                  Request
    )

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

Functional Description:

    This request dials the specified dialable number on the specified call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_DIAL
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulDestAddressSize;
        IN  CHAR        szDestAddress[1];

    } NDIS_TAPI_DIAL, *PNDIS_TAPI_DIAL;

Return Values:

    NDIS_STATUS_TAPI_INVALCALLHANDLE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiDial")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulDestAddressSize=%d\n"
               "szDestAddress=%Xh\n",
               Request->hdCall,
               Request->ulDestAddressSize,
               Request->szDestAddress
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // RASTAPI only places calls through the MAKE_CALL interface.
    */
    
    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
}


NDIS_STATUS
HtTapiDrop(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_DROP                  Request
    )

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

Functional Description:

    This request drops or disconnects the specified call. User-to-user 
    information can optionally be transmitted as part of the call disconnect. 
    This function can be called by the application at any time. When 
    OID_TAPI_DROP returns with success, the call should be idle.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_DROP
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulUserUserInfoSize;
        IN  UCHAR       UserUserInfo[1];

    } NDIS_TAPI_DROP, *PNDIS_TAPI_DROP;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiDrop")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulUserUserInfoSize=%d\n"
               "UserUserInfo=%Xh\n",
               Request->hdCall,
               Request->ulUserUserInfoSize,
               Request->UserUserInfo
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }
    
    /*
    // We don't expect user user info.
    */
    ASSERT(Request->ulUserUserInfoSize == 0);

    /*
    // The user wants to disconnect, so make it happen cappen.
    */
    HtTapiCallStateHandler(Adapter, Link,
            LINECALLSTATE_DISCONNECTED, LINEDISCONNECTMODE_NORMAL);
    
    /*
    // Under some conditions, we may not get a CLOSE_CALL, so the
    // line would be left unusable if we don't timeout and force a
    // close call condition.
    */
    NdisMSetTimer(&Link->CallTimer, HTDSU_NO_CLOSECALL_TIMEOUT);

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiProviderShutdown(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_PROVIDER_SHUTDOWN     Request
    )

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

Functional Description:

    This request shuts down the miniport. The miniport should terminate any 
    activities it has in progress.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_PROVIDER_SHUTDOWN
    {
        IN  ULONG       ulRequestID;

    } NDIS_TAPI_PROVIDER_SHUTDOWN, *PNDIS_TAPI_PROVIDER_SHUTDOWN;

Return Values:

    NDIS_STATUS_SUCCESS

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

{
    DBG_FUNC("HtTapiProviderShutdown")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    /*
    // Used to interate over the links.
    */
    USHORT LinkIndex;

    DBG_ENTER(Adapter);

    /*
    // Hangup all of the lines.
    */
    for (LinkIndex = 0; LinkIndex < Adapter->NumLineDevs; LinkIndex++)
    {
        Link = GET_LINK_FROM_LINKINDEX(Adapter, LinkIndex);

        if (Link->Adapter)
        {
            /*
            // Force the call to drop
            */
            if (Link->CallState != LINECALLSTATE_IDLE)
            {
                CardLineDisconnect(Adapter, Link->CardLine);
            }

            /*
            // Indicate LINE_DOWN status and release the link structure.
            */
            LinkLineDown(Link);
            LinkRelease(Link);
        }
    }
    Adapter->NumOpens = 0;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiSecureCall(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SECURE_CALL           Request
    )

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

Functional Description:

    This request secures the call from any interruptions or interference that 
    may affect the call’s media stream.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SECURE_CALL
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;

    } NDIS_TAPI_SECURE_CALL, *PNDIS_TAPI_SECURE_CALL;

Return Values:

    NDIS_STATUS_TAPI_INVALCALLHANDLE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiSecureCall")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n",
               Request->hdCall
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // RASTAPI has no support for this feature yet.
    */
    
    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
}


NDIS_STATUS
HtTapiSelectExtVersion(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SELECT_EXT_VERSION    Request
    )

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

Functional Description:

    This request selects the indicated extension version for the indicated 
    line device. Subsequent requests operate according to that extension 
    version.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SELECT_EXT_VERSION
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulExtVersion;

    } NDIS_TAPI_SELECT_EXT_VERSION, *PNDIS_TAPI_SELECT_EXT_VERSION;

Return Values:

    NDIS_STATUS_TAPI_INVALLINEHANDLE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiSelectExtVersion")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulExtVersion=%Xh\n",
               Request->hdLine,
               Request->ulExtVersion
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }
    
    /*
    // NDISTAPI does not support this feature yet.
    */
    
    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
}


NDIS_STATUS
HtTapiSendUserUserInfo(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SEND_USER_USER_INFO   Request
    )

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

Functional Description:

    This request sends user-to-user information to the remote party on the 
    specified call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SEND_USER_USER_INFO
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulUserUserInfoSize;
        IN  UCHAR       UserUserInfo[1];

    } NDIS_TAPI_SEND_USER_USER_INFO, *PNDIS_TAPI_SEND_USER_USER_INFO;

Return Values:

    NDIS_STATUS_TAPI_INVALCALLHANDLE
    NDIS_STATUS_TAPI_OPERATIONUNAVAIL

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

{
    DBG_FUNC("HtTapiSendUserUserInfo")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulUserUserInfoSize=%d\n"
               "UserUserInfo=%Xh\n",
               Request->hdCall,
               Request->ulUserUserInfoSize,
               Request->UserUserInfo
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // We don't expect user user info.
    */
    ASSERT(Request->ulUserUserInfoSize == 0);
    
    /*
    // If your adapter has support for this feature, or uses it like
    // ISDN, you need to find all occurances of ulUserUserInfoSize.
    // It is included in a number of service provider calls.
    */
    
    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
}


NDIS_STATUS
HtTapiSetAppSpecific(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SET_APP_SPECIFIC      Request
    )

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

Functional Description:

    This request sets the application-specific field of the specified call’s 
    LINECALLINFO structure.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SET_APP_SPECIFIC
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulAppSpecific;

    } NDIS_TAPI_SET_APP_SPECIFIC, *PNDIS_TAPI_SET_APP_SPECIFIC;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiSetAppSpecific")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulAppSpecific=%d\n",
               Request->hdCall,
               Request->ulAppSpecific
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }
    
    /*
    // You can do what ever you want here, so long as the application
    // agrees with you.
    */

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_TAPI_OPERATIONUNAVAIL);
}


NDIS_STATUS
HtTapiSetCallParams(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SET_CALL_PARAMS       Request
    )

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

Functional Description:

    This request sets certain call parameters for an existing call.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SET_CALL_PARAMS
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulBearerMode;
        IN  ULONG       ulMinRate;
        IN  ULONG       ulMaxRate;
        IN  BOOLEAN     bSetLineDialParams;
        IN  LINE_DIAL_PARAMS    LineDialParams;

    } NDIS_TAPI_SET_CALL_PARAMS, *PNDIS_TAPI_SET_CALL_PARAMS;

    typedef struct _LINE_DIAL_PARAMS
    {
        ULONG   ulDialPause;
        ULONG   ulDialSpeed;
        ULONG   ulDigitDuration;
        ULONG   ulWaitForDialtone;

    } LINE_DIAL_PARAMS, *PLINE_DIAL_PARAMS;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiSetCallParams")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulBearerMode=%Xh\n",
               "ulMinRate=%d\n",
               "ulMaxRate=%d\n",
               "bSetLineDialParams=%d\n",
               "LineDialParams=%Xh\n",
               Request->hdCall,
               Request->ulBearerMode,
               Request->ulMinRate,
               Request->ulMaxRate,
               Request->bSetLineDialParams,
               Request->LineDialParams
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // RASTAPI only places calls through the MAKE_CALL interface.
    // So there's nothing to do here for the time being.
    */
    
    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiSetDefaultMediaDetection(
    IN PHTDSU_ADAPTER                           Adapter,
    IN PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION   Request
    )

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

Functional Description:

    This request informs the miniport of the new set of media modes to detect 
    for the indicated line (replacing any previous set).

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulMediaModes;

    } NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION, *PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALLINEHANDLE

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

{
    DBG_FUNC("HtTapiSetDefaultMediaDetection")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulMediaModes=%Xh\n",
               Request->hdLine,
               Request->ulMediaModes
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

    /*
    // Set the media modes mask and make sure the adapter is ready to 
    // accept incoming calls.  If you can detect different medias, you
    // will need to notify the approriate interface for the media detected.
    */
    Link->MediaModesMask = Request->ulMediaModes;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiSetMediaMode(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SET_MEDIA_MODE        Request
    )

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

Functional Description:

    This request changes a call’s media mode as stored in the call’s 
    LINE_CALL_INFO structure.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SET_MEDIA_MODE
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_CALL   hdCall;
        IN  ULONG       ulMediaMode;

    } NDIS_TAPI_SET_MEDIA_MODE, *PNDIS_TAPI_SET_MEDIA_MODE;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_TAPI_INVALCALLHANDLE

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

{
    DBG_FUNC("HtTapiSetMediaMode")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdCall=%Xh\n"
               "ulMediaMode=%Xh\n",
               Request->hdCall,
               Request->ulMediaMode
              ));
    /*
    // This request must be associated with a call.
    */
    Link = GET_LINK_FROM_HDCALL(Adapter, Request->hdCall);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALCALLHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALCALLHANDLE);
    }

    /*
    // If you can detect different medias, you will need to setup to use 
    // the selected media here.
    */
    Link->MediaModesMask = Request->ulMediaMode;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
HtTapiSetStatusMessages(
    IN PHTDSU_ADAPTER                   Adapter,
    IN PNDIS_TAPI_SET_STATUS_MESSAGES   Request
    )

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

Functional Description:

    This request enables the Connection Wrapper to specify which notification 
    messages the miniport should generate for events related to status changes 
    for the specified line or any of its addresses. By default, address and 
    line status reporting is initially disabled for a line.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Request _ A pointer to the NDIS_TAPI request structure for this call.

    typedef struct _NDIS_TAPI_SET_STATUS_MESSAGES
    {
        IN  ULONG       ulRequestID;
        IN  HDRV_LINE   hdLine;
        IN  ULONG       ulLineStates;
        IN  ULONG       ulAddressStates;

    } NDIS_TAPI_SET_STATUS_MESSAGES, *PNDIS_TAPI_SET_STATUS_MESSAGES;

Return Values:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_TAPI_INVALLINEHANDLE
    NDIS_STATUS_TAPI_INVALLINESTATE
    NDIS_STATUS_TAPI_INVALADDRESSSTATE

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

{
    DBG_FUNC("HtTapiSetStatusMessages")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("hdLine=%Xh\n"
               "ulLineStates=%Xh\n"
               "ulAddressStates=%Xh\n",
               Request->hdLine,
               Request->ulLineStates,
               Request->ulAddressStates
              ));
    /*
    // This request must be associated with a line device.
    */
    Link = GET_LINK_FROM_HDLINE(Adapter, Request->hdLine);
    if (Link == NULL)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINEHANDLE\n"));
        return (NDIS_STATUS_TAPI_INVALLINEHANDLE);
    }

    /*
    // Make sure the line settings are all within the supported list.
    */
    if (Request->ulLineStates & ~Link->DevStatesCaps)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALLINESTATE\n"));
        return (NDIS_STATUS_TAPI_INVALLINESTATE);
    }

    /*
    // Make sure the address settings are all within the supported list.
    */
    if (Request->ulAddressStates & ~Link->AddressStatesCaps)
    {
        DBG_WARNING(Adapter, ("Returning NDIS_STATUS_TAPI_INVALADDRESSSTATE\n"));
        return (NDIS_STATUS_TAPI_INVALADDRESSSTATE);
    }

    /*
    // Save the new event notification masks so we will only indicate the
    // appropriate events.
    */
    Link->DevStatesMask     = Request->ulLineStates;
    Link->AddressStatesMask = Request->ulAddressStates;

    DBG_LEAVE(Adapter);

    return (NDIS_STATUS_SUCCESS);
}


VOID
HtTapiCallStateHandler(
    IN PHTDSU_ADAPTER       Adapter,
    IN PHTDSU_LINK          Link,
    IN ULONG                CallState,
    IN ULONG                StateParam
    )

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

Functional Description:

    This routine will indicate the given LINECALLSTATE to the Connection
    wrapper if the event has been enabled by the wrapper.  Otherwise the state
    information is saved, but no indication is made.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Link _ A pointer to our link information structure for the selected
           line device.

    CallState _ The LINECALLSTATE event to be posted to TAPI/WAN.

    StateParam _ This value depends on the event being posted, and some
                 events will pass in zero if they don't use this parameter.

Return Values:

    None

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

{
    DBG_FUNC("HtTapiCallStateHandler")

    /*
    // The event structure passed to the connection wrapper.
    */
    NDIS_TAPI_EVENT CallEvent;

    /*
    // Flag tells whether call time-out routine was cancelled.
    */
    BOOLEAN TimerCancelled;

    DBG_ENTER(Adapter);
    DBG_FILTER(Adapter, DBG_PARAMS_ON,
              ("OldState=%Xh "
               "NewState=%Xh\n",
               Link->CallState,
               CallState
              ));
    /*
    // Cancel any call time-outs events associated with this link.
    */
    NdisMCancelTimer(&Link->CallTimer, &TimerCancelled);

    /*
    // Init the optional parameters.  They will be set as needed below.
    */
    CallEvent.ulParam2 = StateParam;
    CallEvent.ulParam3 = Link->MediaMode;

    /*
    // OUTGOING) The expected sequence of events for outgoing calls is:
    // LINECALLSTATE_IDLE, LINECALLSTATE_DIALTONE, LINECALLSTATE_DIALING,
    // LINECALLSTATE_PROCEEDING, (LINECALLSTATE_RINGBACK | LINECALLSTATE_BUSY),
    // LINECALLSTATE_CONNECTED, LINECALLSTATE_DISCONNECTED, LINECALLSTATE_IDLE
    //
    // INCOMING) The expected sequence of events for incoming calls is:
    // LINECALLSTATE_IDLE, LINECALLSTATE_OFFERING, LINECALLSTATE_ACCEPTED,
    // LINECALLSTATE_CONNECTED, LINECALLSTATE_DISCONNECTED, LINECALLSTATE_IDLE
    //
    // Under certain failure conditions, these sequences may be violated.
    // So I used ASSERTs to verify the normal state transitions which will
    // cause a debug break point if an unusual transition is detected.
    */
    switch (CallState)
    {
    case LINECALLSTATE_IDLE:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_IDLE line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        /*
        // Make sure that an idle line is disconnected.
        */
        if (Link->CallState &&
            Link->CallState != LINECALLSTATE_IDLE &&
            Link->CallState != LINECALLSTATE_DISCONNECTED)
        {
            DBG_WARNING(Adapter, ("Disconnecting Line=%d\n",Link->CardLine));
            HtTapiCallStateHandler(Adapter, Link,
                    LINECALLSTATE_DISCONNECTED, LINEDISCONNECTMODE_UNKNOWN);
        }
        Link->RingCount = 0;
        break;

    case LINECALLSTATE_DIALTONE:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_DIALTONE line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_IDLE);
        break;

    case LINECALLSTATE_DIALING:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_DIALING line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_DIALTONE);
        break;

    case LINECALLSTATE_PROCEEDING:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_PROCEEDING line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_DIALING);
        LinkLineUp(Link);
        break;

    case LINECALLSTATE_RINGBACK:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_RINGBACK line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_PROCEEDING);
        break;

    case LINECALLSTATE_BUSY:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_BUSY line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_DIALING);
        break;

    case LINECALLSTATE_CONNECTED:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_CONNECTED line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_PROCEEDING ||
               Link->CallState == LINECALLSTATE_ACCEPTED);
        break;

    case LINECALLSTATE_DISCONNECTED:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_DISCONNECTED line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        CardLineDisconnect(Adapter, Link->CardLine);
        LinkLineDown(Link);
        break;

    case LINECALLSTATE_OFFERING:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_OFFERING line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_IDLE);
        LinkLineUp(Link);
        NdisMSetTimer(&Link->CallTimer, HTDSU_NO_ACCEPT_TIMEOUT);
        break;

    case LINECALLSTATE_ACCEPTED:
        DBG_FILTER(Adapter, DBG_TAPICALL_ON,
                  ("LINECALLSTATE_ACCEPTED line=0x%x call=0x%x\n",
                  Link->CardLine, Link->htCall));
        ASSERT(Link->CallState == LINECALLSTATE_OFFERING);
        break;
    }
    /*
    // Change the current CallState and notify the connection wrapper if it
    // wants to know about this event.
    */
    if (Link->CallState != CallState)
    {
        Link->CallState = CallState;
        if (Link->CallStatesMask & CallState)
        {
            CallEvent.htLine   = Link->htLine;
            CallEvent.htCall   = Link->htCall;
            CallEvent.ulMsg    = LINE_CALLSTATE;
            CallEvent.ulParam1 = CallState;
            NdisMIndicateStatus(
                    Adapter->MiniportAdapterHandle,
                    NDIS_STATUS_TAPI_INDICATION,
                    &CallEvent,
                    sizeof(CallEvent)
                    );
            DBG_NOTICE(Adapter, ("LINE_CALLSTATE:\n"
                       "htLine=%Xh\n"
                       "htCall=%Xh\n",
                       Link->htLine,
                       Link->htCall
                       ));
        }
        else
        {
            DBG_NOTICE(Adapter, ("CallState Event=%Xh is not enabled\n", CallState));
        }
    }

    DBG_LEAVE(Adapter);
}


VOID
HtTapiAddressStateHandler(
    IN PHTDSU_ADAPTER       Adapter,
    IN PHTDSU_LINK          Link,
    IN ULONG                AddressState
    )

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

Functional Description:

    This routine will indicate the given LINEADDRESSSTATE to the Connection
    wrapper if the event has been enabled by the wrapper.  Otherwise the state
    information is saved, but no indication is made.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Link _ A pointer to our link information structure for the selected
           line device.

    AddressState _ The LINEADDRESSSTATE event to be posted to TAPI/WAN.

Return Values:

    None

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

{
    DBG_FUNC("HtTapiAddressStateHandler")

    /*
    // The event structure passed to the connection wrapper.
    */
    NDIS_TAPI_EVENT Event;

    DBG_ENTER(Adapter);

    if (Link->AddressStatesMask & AddressState)
    {
        Event.htLine   = Link->htLine;
        Event.htCall   = Link->htCall;
        Event.ulMsg    = LINE_CALLSTATE;
        Event.ulParam1 = AddressState;
        Event.ulParam2 = 0;
        Event.ulParam3 = 0;

        /*
        // We really don't have much to do here with this adapter.
        // And RASTAPI doesn't accept these events anyway...
        */
        switch (AddressState)
        {
        case LINEADDRESSSTATE_INUSEZERO:
            break;

        case LINEADDRESSSTATE_INUSEONE:
            break;
        }
        NdisMIndicateStatus(
                Adapter->MiniportAdapterHandle,
                NDIS_STATUS_TAPI_INDICATION,
                &Event,
                sizeof(Event)
                );
    }
    else
    {
        DBG_NOTICE(Adapter, ("AddressState Event=%Xh is not enabled\n", AddressState));
    }

    DBG_LEAVE(Adapter);
}


VOID
HtTapiLineDevStateHandler(
    IN PHTDSU_ADAPTER       Adapter,
    IN PHTDSU_LINK          Link,
    IN ULONG                LineDevState
    )

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

Functional Description:

    This routine will indicate the given LINEDEVSTATE to the Connection wrapper
    if the event has been enabled by the wrapper.  Otherwise the state
    information is saved, but no indication is made.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

    Link _ A pointer to our link information structure for the selected
           line device.

    LineDevState _ The LINEDEVSTATE event to be posted to TAPI/WAN.

Return Values:

    None

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

{
    DBG_FUNC("HtTapiLineDevStateHandler")

    /*
    // The event structure passed to the connection wrapper.
    */
    NDIS_TAPI_EVENT LineEvent;
    NDIS_TAPI_EVENT CallEvent;

    /*
    // The line state change may cause a call state change as well.
    */
    ULONG NewCallState = 0;
    ULONG StateParam = 0;

    DBG_ENTER(Adapter);

    LineEvent.ulParam2 = 0;
    LineEvent.ulParam3 = 0;

    /*
    // Handle the line state transition as needed.
    */
    switch (LineDevState)
    {
    case LINEDEVSTATE_RINGING:
        LineEvent.ulParam2 = 1;     // only one RingMode
        if ((LineEvent.ulParam3 = ++Link->RingCount) == 1)
        {
            NewCallState = LINECALLSTATE_OFFERING;
        }
        break;

    case LINEDEVSTATE_CONNECTED:
        NewCallState = LINECALLSTATE_CONNECTED;
        break;

    case LINEDEVSTATE_DISCONNECTED:
        if (Link->CallState != LINECALLSTATE_IDLE &&
            Link->CallState != LINECALLSTATE_DISCONNECTED)
        {
            NewCallState = LINECALLSTATE_DISCONNECTED;
            StateParam = LINEDISCONNECTMODE_NORMAL;
        }
        break;

    case LINEDEVSTATE_OUTOFSERVICE:
        if (Link->CallState != LINECALLSTATE_IDLE &&
            Link->CallState != LINECALLSTATE_DISCONNECTED)
        {
            NewCallState = LINECALLSTATE_DISCONNECTED;
            StateParam = LINEDISCONNECTMODE_UNKNOWN;
        }
        break;

    case LINEDEVSTATE_OPEN:
        /*
        // Make sure the line is configured for dialing when we open up.
        // Then enable the interrupts we're interested in now.
        */
        if (Link->CardLine == HTDSU_CMD_LINE1)
        {
            Adapter->InterruptEnableFlag |= HTDSU_INTR_ALL_LINE1;
        }
        else
        {
            Adapter->InterruptEnableFlag |= HTDSU_INTR_ALL_LINE2;
        }
        ++Adapter->NumOpens;
        CardLineConfig(Adapter, Link->CardLine);
        CardEnableInterrupt(Adapter);
        NewCallState = LINECALLSTATE_IDLE;
        break;

    case LINEDEVSTATE_CLOSE:
        /*
        // This must not be called until all transmits have been dequeued 
        // and ack'd.  Otherwise the wrapper will hang waiting for transmit 
        // request to complete.
        */
        if (Link->CardLine == HTDSU_CMD_LINE1)
        {
            Adapter->InterruptEnableFlag &= ~HTDSU_INTR_ALL_LINE1;
        }
        else
        {
            Adapter->InterruptEnableFlag &= ~HTDSU_INTR_ALL_LINE2;
        }
        CardEnableInterrupt(Adapter);
        --Adapter->NumOpens;
        NewCallState = LINECALLSTATE_IDLE;
        break;
    }
    Link->DevState = LineDevState;

    /*
    // If this is the first indication of an incoming call, we need to
    // let TAPI know about it so we can get a htCall handle associated
    // with it.
    */
    if (NewCallState == LINECALLSTATE_OFFERING)
    {
        CallEvent.htLine   = Link->htLine;
        CallEvent.htCall   = (HTAPI_CALL)0;
        CallEvent.ulMsg    = LINE_NEWCALL;
        CallEvent.ulParam1 = (ULONG) Link;
        CallEvent.ulParam2 = 0;
        CallEvent.ulParam3 = 0;

        NdisMIndicateStatus(
                Adapter->MiniportAdapterHandle,
                NDIS_STATUS_TAPI_INDICATION,
                &CallEvent,
                sizeof(CallEvent)
                );
        Link->htCall = (HTAPI_CALL)CallEvent.ulParam2;
        DBG_NOTICE(Adapter, ("NEW_CALL htCall=%Xh\n",Link->htCall));
    }

    /*
    // Tell TAPI what's going on here, if she cares.
    */
    if (Link->DevStatesMask & LineDevState)
    {
        LineEvent.htLine   = Link->htLine;
        LineEvent.htCall   = Link->htCall;
        LineEvent.ulMsg    = LINE_LINEDEVSTATE;
        LineEvent.ulParam1 = LineDevState;

        NdisMIndicateStatus(
                Adapter->MiniportAdapterHandle,
                NDIS_STATUS_TAPI_INDICATION,
                &LineEvent,
                sizeof(LineEvent)
                );
    }
    else
    {
        DBG_NOTICE(Adapter, ("LineDevEvent %Xh is not enabled\n", LineDevState));
    }

    /*
    // Tell TAPI what this event does to any call that may be in progress.
    */
    if (NewCallState)
    {
        HtTapiCallStateHandler(Adapter, Link, NewCallState, StateParam);
    }

    DBG_LEAVE(Adapter);
}


VOID
HtTapiResetHandler(
    IN PHTDSU_ADAPTER       Adapter
    )

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

Functional Description:

    This rouine is called by the MiniportReset routine after the hardware
    has been reset due to some failure detection.  We need to make sure the
    line and call state information is conveyed properly to the connection
    wrapper.

Parameters:

    Adapter _ A pointer ot our adapter information structure.

Return Values:

    None

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

{
    DBG_FUNC("HtTapiResetHandler")

    /*
    // A pointer to our link information structure for the selected line device.
    */
    PHTDSU_LINK Link;

    DBG_ENTER(Adapter);

    /*
    // Force disconnect on both lines.
    */
    Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
    HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED);

    if (Adapter->NumLineDevs == HTDSU_NUM_LINKS)
    {
        Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
        HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED);
    }

    DBG_LEAVE(Adapter);
}


VOID
HtTapiCallTimerHandler(
    IN PVOID                SystemSpecific1,
    IN PHTDSU_LINK          Link,
    IN PVOID                SystemSpecific2,
    IN PVOID                SystemSpecific3
    )

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

Functional Description:

    This routine is called when the CallTimer timeout occurs.  It will
    handle the event according to the current CallState and make the
    necessary indications and changes to the call state.

Parameters:

    Link _ A pointer to our link information structure on which a call event
           is in progress.

Return Values:

    None

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

{
    DBG_FUNC("HtTapiCallTimerHandler")

    PHTDSU_ADAPTER Adapter = Link->Adapter;

    DBG_ENTER(Adapter);

    NdisAcquireSpinLock(&Adapter->Lock);

    switch (Link->CallState)
    {
    case LINECALLSTATE_DIALING:
        if (CardStatusNoDialTone(Adapter, Link->CardLine))
        {
            LinkLineError(Link, WAN_ERROR_TIMEOUT);
            HtTapiCallStateHandler(Adapter, Link,
                    LINECALLSTATE_DISCONNECTED, LINEDISCONNECTMODE_BUSY);
        }
        else
        {
            /*
            // We got a signal, so dialing must be proceeding
            */
            HtTapiCallStateHandler(Adapter, Link, LINECALLSTATE_PROCEEDING, 0);
            NdisMSetTimer(&Link->CallTimer, HTDSU_NO_ANSWER_TIMEOUT);
        }
        break;

    case LINECALLSTATE_PROCEEDING:
        if (CardStatusNoAnswer(Adapter, Link->CardLine) ||
            !CardStatusCarrierDetect(Adapter, Link->CardLine) ||
            !CardStatusOnLine(Adapter, Link->CardLine))
        {
            /*
            // We did not get answer, so hangup and abort the call.
            */
            LinkLineError(Link, WAN_ERROR_TIMEOUT);
            HtTapiCallStateHandler(Adapter, Link,
                    LINECALLSTATE_DISCONNECTED, LINEDISCONNECTMODE_NOANSWER);
        }
        break;

    case LINECALLSTATE_OFFERING:
        /*
        // We did not get an accept or answer, so hangup and abort the call.
        */
        LinkLineError(Link, WAN_ERROR_TIMEOUT);
        HtTapiCallStateHandler(Adapter, Link,
                LINECALLSTATE_DISCONNECTED, LINEDISCONNECTMODE_NOANSWER);
        break;

    case LINECALLSTATE_ACCEPTED:
        /*
        // We did not get connected after answer, so hangup and abort the call.
        */
        LinkLineError(Link, WAN_ERROR_TIMEOUT);
        HtTapiCallStateHandler(Adapter, Link,
                LINECALLSTATE_DISCONNECTED, LINEDISCONNECTMODE_NOANSWER);
        break;

    case LINECALLSTATE_DISCONNECTED:
        /*
        // We did not get CloseCall after DropCall, so force a close.
        */
        HtTapiCallStateHandler(Adapter, Link, LINECALLSTATE_IDLE, 0);
        break;

    default:
        DBG_WARNING(Adapter, ("TIMEOUT in CallState=%Xh\n",Link->CallState));
        break;
    }

    NdisReleaseSpinLock(&Adapter->Lock);

    DBG_LEAVE(Adapter);
}