From e611b132f9b8abe35b362e5870b74bce94a1e58e Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 16 May 2020 20:51:50 -0700 Subject: initial commit --- private/ntos/ndis/htdsu/card.c | 722 +++++ private/ntos/ndis/htdsu/card.h | 521 ++++ private/ntos/ndis/htdsu/debug.c | 112 + private/ntos/ndis/htdsu/debug.h | 137 + private/ntos/ndis/htdsu/htdsu.c | 1395 ++++++++++ private/ntos/ndis/htdsu/htdsu.h | 931 +++++++ private/ntos/ndis/htdsu/htdsu.rc | 9 + private/ntos/ndis/htdsu/interrup.c | 656 +++++ private/ntos/ndis/htdsu/keywords.h | 77 + private/ntos/ndis/htdsu/link.c | 587 ++++ private/ntos/ndis/htdsu/makefile | 7 + private/ntos/ndis/htdsu/oemsetnt.inf | 1241 +++++++++ private/ntos/ndis/htdsu/receive.c | 199 ++ private/ntos/ndis/htdsu/request.c | 661 +++++ private/ntos/ndis/htdsu/send.c | 502 ++++ private/ntos/ndis/htdsu/sources | 53 + private/ntos/ndis/htdsu/tapi.c | 5001 ++++++++++++++++++++++++++++++++++ private/ntos/ndis/htdsu/version.h | 62 + 18 files changed, 12873 insertions(+) create mode 100644 private/ntos/ndis/htdsu/card.c create mode 100644 private/ntos/ndis/htdsu/card.h create mode 100644 private/ntos/ndis/htdsu/debug.c create mode 100644 private/ntos/ndis/htdsu/debug.h create mode 100644 private/ntos/ndis/htdsu/htdsu.c create mode 100644 private/ntos/ndis/htdsu/htdsu.h create mode 100644 private/ntos/ndis/htdsu/htdsu.rc create mode 100644 private/ntos/ndis/htdsu/interrup.c create mode 100644 private/ntos/ndis/htdsu/keywords.h create mode 100644 private/ntos/ndis/htdsu/link.c create mode 100644 private/ntos/ndis/htdsu/makefile create mode 100644 private/ntos/ndis/htdsu/oemsetnt.inf create mode 100644 private/ntos/ndis/htdsu/receive.c create mode 100644 private/ntos/ndis/htdsu/request.c create mode 100644 private/ntos/ndis/htdsu/send.c create mode 100644 private/ntos/ndis/htdsu/sources create mode 100644 private/ntos/ndis/htdsu/tapi.c create mode 100644 private/ntos/ndis/htdsu/version.h (limited to 'private/ntos/ndis/htdsu') diff --git a/private/ntos/ndis/htdsu/card.c b/private/ntos/ndis/htdsu/card.c new file mode 100644 index 000000000..eb62fba71 --- /dev/null +++ b/private/ntos/ndis/htdsu/card.c @@ -0,0 +1,722 @@ +/***************************************************************************\ +|* 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: + + card.c + +Abstract: + + This module implements the low-level hardware control functions used by + the NDIS Minport driver on the HT DSU41 controller. You will need to + replace this module with the control functions required to support your + hardware. + CardIdentify() + CardDoCommand() + CardInitialize() + CardLineConfig() + CardLineDisconnect() + CardLineDisconnect() + CardPrepareTransmit() + CardGetReceiveInfo() + CardDialNumber() + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 2 // Unique file ID for error logging + +#include "htdsu.h" + + +NDIS_STATUS +CardIdentify( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine will attempt to verify that the controller is located in + memory where the driver has been configured to expect it. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + +Return Values: + + NDIS_STATUS_SUCCESS + NDIS_STATUS_ADAPTER_NOT_FOUND + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("CardIdentify") + + NDIS_STATUS Status; + + /* + // These values are read from the adapter to make sure this driver will + // work with the firmware on the adapter. + */ + USHORT CoProcessorId; + USHORT CoProcessorVersion; + USHORT DsuId; + USHORT DsuVersion; + + DBG_ENTER(Adapter); + + /* + // Read the configuration values from the card. + */ + CoProcessorId = READ_REGISTER_USHORT(&Adapter->AdapterRam->CoProcessorId); + CoProcessorVersion = READ_REGISTER_USHORT(&Adapter->AdapterRam->CoProcessorVersion); + DsuId = READ_REGISTER_USHORT(&Adapter->AdapterRam->DsuId); + DsuVersion = READ_REGISTER_USHORT(&Adapter->AdapterRam->DsuVersion); + + /* + // Make sure these values are what we expect. + */ + if ((CoProcessorId == HTDSU_COPROCESSOR_ID) && + (CoProcessorVersion >= HTDSU_COPROCESSOR_VERSION) && + ((DsuId & 0x00FF) == HTDSU_DSU_ID) && + (DsuVersion >= HTDSU_DSU_VERSION)) + { + /* + // Record the number of lines on this adapter. + */ + Adapter->NumLineDevs = HTDSU_NUM_LINKS; + if ((DsuId & 0xFF00) == 0) + { + --Adapter->NumLineDevs; + } + DBG_NOTICE(Adapter,("NumLineDevs=%d\n",Adapter->NumLineDevs)); + + Status = NDIS_STATUS_SUCCESS; + } + else + { + DBG_ERROR(Adapter,("Adapter not found or invalid firmware:\n" + "CoProcessorId = %Xh\n" + "CoProcessorVersion = %Xh\n" + "DsuId = %Xh\n" + "DsuVersion = %Xh\n", + CoProcessorId, + CoProcessorVersion, + DsuId, + DsuVersion + )); + + Status = NDIS_STATUS_ADAPTER_NOT_FOUND; + /* + // Log error message and return. + */ + NdisWriteErrorLogEntry( + Adapter->MiniportAdapterHandle, + NDIS_ERROR_CODE_ADAPTER_NOT_FOUND, + 7, + CoProcessorId, + CoProcessorVersion, + DsuId, + DsuVersion, + Status, + __FILEID__, + __LINE__ + ); + } + + DBG_LEAVE(Adapter); + + return (Status); +} + + +NDIS_STATUS +CardDoCommand( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine, /* HTDSU_CMD_LINE1 or HTDSU_CMD_LINE2 */ + IN USHORT CommandValue + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine routine will execute a command on the card after making + sure the previous command has completed properly. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + CardLine _ Specifies which line to use for the transmit (HTDSU_LINEx_ID). + + CommandValue _ HTDSU_CMD_??? command to be executed. + +Return Values: + + NDIS_STATUS_SUCCESS + NDIS_STATUS_HARD_ERRORS + +---------------------------------------------------------------------------*/ +{ + DBG_FUNC("CardDoCommand") + + ULONG TimeOut = 0; + + DBG_ENTER(Adapter); + DBG_FILTER(Adapter, DBG_PARAMS_ON,("Line=%d, Command=%04X, LineStatus=%Xh\n", + CardLine, CommandValue, + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) + )); + + /* + // Wait for command register to go idle - but don't wait too long. + // If we timeout here, there's gotta be something wrong with the adapter. + */ + while ((READ_REGISTER_USHORT(&Adapter->AdapterRam->Command) != + HTDSU_CMD_NOP) || + (READ_REGISTER_USHORT(&Adapter->AdapterRam->CoProcessorId) != + HTDSU_COPROCESSOR_ID)) + { + if (TimeOut++ > HTDSU_SELFTEST_TIMEOUT) + { + DBG_ERROR(Adapter,("Timeout waiting for %04X command to clear\n", + READ_REGISTER_USHORT(&Adapter->AdapterRam->Command))); + /* + // Ask for reset, and disable interrupts until we get it. + */ + Adapter->NeedReset = TRUE; + Adapter->InterruptEnableFlag = HTDSU_INTR_DISABLE; + CardDisableInterrupt(Adapter); + + return (NDIS_STATUS_HARD_ERRORS); + } + NdisStallExecution(_100_MICROSECONDS); + } + DBG_NOTICE(Adapter,("Timeout=%d waiting to submit %04X\n", + TimeOut, CommandValue)); + + /* + // Before starting a reset command, we clear the the co-processor ID + // which then gets set to the proper value when the reset is complete. + */ + if (CommandValue == HTDSU_CMD_RESET) + { + WRITE_REGISTER_USHORT(&Adapter->AdapterRam->CoProcessorId, 0); + } + + /* + // Send the command to the adapter. + */ + WRITE_REGISTER_USHORT( + &Adapter->AdapterRam->Command, + (USHORT) (CommandValue + CardLine) + ); + + DBG_LEAVE(Adapter); + + return (NDIS_STATUS_SUCCESS); +} + + +NDIS_STATUS +CardInitialize( + IN PHTDSU_ADAPTER Adapter, + IN BOOLEAN PerformSelfTest + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine will attempt to initialize the controller, but will not + enable transmits or receives. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + PerformSelfTest _ TRUE if caller wants to run selftest diagnostics. + This normally takes about 4 seconds to complete, so you + wouldn't want to do it every time you start up. + +Return Values: + + NDIS_STATUS_HARD_ERRORS + NDIS_STATUS_SUCCESS + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("CardInitialize") + + NDIS_STATUS Status; + + USHORT SelfTestStatus; + + UINT TimeOut; + + DBG_ENTER(Adapter); + + /* + // First we make sure the adapter is where we think it is. + */ + Status = CardIdentify(Adapter); + if (Status != NDIS_STATUS_SUCCESS) + { + return (Status); + } + + /* + // Reset the hardware to make sure we're in a known state. + */ + Status = CardDoCommand(Adapter, 0, HTDSU_CMD_RESET); + + if (PerformSelfTest) + { + /* + // Wait for the reset to complete before starting the self-test. + // Then issue the self-test command to see if the adapter firmware + // is happy with the situation. + */ + Status = CardDoCommand(Adapter, 0, HTDSU_CMD_SELFTEST); + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_ERROR(Adapter,("Failed HTDSU_CMD_RESET\n")); + /* + // Log error message and return. + */ + NdisWriteErrorLogEntry( + Adapter->MiniportAdapterHandle, + NDIS_ERROR_CODE_HARDWARE_FAILURE, + 3, + Status, + __FILEID__, + __LINE__ + ); + return (Status); + } + + /* + // Wait for the self test to complete, but don't wait forever. + */ + TimeOut = 0; + while (Status == NDIS_STATUS_SUCCESS && + READ_REGISTER_USHORT(&Adapter->AdapterRam->Command) != + HTDSU_CMD_NOP) + { + if (TimeOut++ > HTDSU_SELFTEST_TIMEOUT) + { + DBG_ERROR(Adapter,("Timeout waiting for SELFTEST to complete\n")); + Status = NDIS_STATUS_HARD_ERRORS; + } + else + { + NdisStallExecution(_100_MICROSECONDS); + } + } + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_ERROR(Adapter,("Failed HTDSU_CMD_SELFTEST\n")); + /* + // Log error message and return. + */ + NdisWriteErrorLogEntry( + Adapter->MiniportAdapterHandle, + NDIS_ERROR_CODE_HARDWARE_FAILURE, + 3, + Status, + __FILEID__, + __LINE__ + ); + return (Status); + } + + /* + // Verify that self test was successful. + */ + SelfTestStatus = READ_REGISTER_USHORT(&Adapter->AdapterRam->SelfTestStatus); + if (SelfTestStatus != 0 && SelfTestStatus != HTDSU_SELFTEST_OK) + { + DBG_ERROR(Adapter,("Failed HTDSU_CMD_SELFTEST (Status=%X)\n", + SelfTestStatus)); + /* + // Log error message and return. + */ + NdisWriteErrorLogEntry( + Adapter->MiniportAdapterHandle, + NDIS_ERROR_CODE_HARDWARE_FAILURE, + 3, + SelfTestStatus, + __FILEID__, + __LINE__ + ); + return (NDIS_STATUS_HARD_ERRORS); + } + } + + DBG_LEAVE(Adapter); + + return (NDIS_STATUS_SUCCESS); +} + + +VOID +CardLineConfig( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine /* HTDSU_CMD_LINE1 or HTDSU_CMD_LINE2 */ + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine will ready the controller to send and receive packets. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + CardLine _ Specifies which line to use for the transmit (HTDSU_LINEx_ID). + +Return Values: + + None + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("CardLineConfig") + + USHORT ClockCommand; + USHORT LineCommand; + + DBG_ENTER(Adapter); + + ASSERT((CardLine==HTDSU_CMD_LINE1) || (CardLine==HTDSU_CMD_LINE2)); + + /* + // Configure the line for HDLC framing and for leased or dialup mode. + */ + if (Adapter->LineType == HTDSU_LINEMODE_LEASED) + { + ClockCommand = HTDSU_CMD_INTERNAL_TX_CLOCK; + LineCommand = HTDSU_CMD_LEASED_LINE; + } + else + { + ClockCommand = HTDSU_CMD_DDS_TX_CLOCK; + LineCommand = HTDSU_CMD_DIALUP_LINE; + } + + CardDoCommand(Adapter, CardLine, ClockCommand); + CardDoCommand(Adapter, CardLine, HTDSU_CMD_HDLC_PROTOCOL); + CardDoCommand(Adapter, CardLine, LineCommand); + CardDoCommand(Adapter, CardLine, Adapter->LineRate); + + /* + // Clear any pending interrupts. + */ + CardDoCommand(Adapter, 0, HTDSU_CMD_CLEAR_INTERRUPT); + CardClearInterrupt(Adapter); + + DBG_LEAVE(Adapter); +} + + +VOID +CardLineDisconnect( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine /* HTDSU_CMD_LINE1 or HTDSU_CMD_LINE2 */ + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine will disconnect any call currently on the line. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + CardLine _ Specifies which line to use for the transmit (HTDSU_LINEx_ID). + +Return Values: + + None + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("CardLineDisconnect") + + DBG_ENTER(Adapter); + + ASSERT((CardLine==HTDSU_CMD_LINE1) || (CardLine==HTDSU_CMD_LINE2)); + + /* + // Disconnect the line and reconfigure the line for next time. + */ + CardDoCommand(Adapter, CardLine, HTDSU_CMD_DISCONNECT); + CardLineConfig(Adapter, CardLine); + + DBG_LEAVE(Adapter); +} + + +VOID +CardPrepareTransmit( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine, /* HTDSU_CMD_LINE1 or HTDSU_CMD_LINE2 */ + IN USHORT BytesToSend + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine will write the packet header information into the + transmit buffer. This assumes that the controller has notified the + driver that the transmit buffer is empty. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + CardLine _ Specifies which line to use for the transmit (HTDSU_LINEx_ID). + + BytesToSend _ Number of bytes to transmit. + +Return Values: + + None + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("CardPrepareTransmit") + + DBG_ENTER(Adapter); + + ASSERT((CardLine==HTDSU_CMD_LINE1) || (CardLine==HTDSU_CMD_LINE2)); + ASSERT(READ_REGISTER_USHORT(&Adapter->AdapterRam->TxDataEmpty)); + ASSERT(BytesToSend > 0); + + /* + // Tell the adapter how many bytes are to be sent, and which line to use. + */ + WRITE_REGISTER_USHORT( + &Adapter->AdapterRam->TxBuffer.Address, + (USHORT) (CardLine - HTDSU_CMD_LINE1) + ); + WRITE_REGISTER_USHORT( + &Adapter->AdapterRam->TxBuffer.Length, + BytesToSend + ); + + /* + // Mark the end of packet and end of packet list. + */ + WRITE_REGISTER_USHORT( + &Adapter->AdapterRam->TxBuffer.Data[(BytesToSend+1)/sizeof(USHORT)], + HTDSU_DATA_TERMINATOR + ); + WRITE_REGISTER_USHORT( + &Adapter->AdapterRam->TxBuffer.Data[(BytesToSend+3)/sizeof(USHORT)], + HTDSU_DATA_TERMINATOR + ); + + DBG_LEAVE(Adapter); +} + + +VOID +CardGetReceiveInfo( + IN PHTDSU_ADAPTER Adapter, + OUT PUSHORT CardLine, /* HTDSU_CMD_LINE1 or HTDSU_CMD_LINE2 */ + OUT PUSHORT BytesReceived, + OUT PUSHORT RxErrors + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine will retrieve the packet header information from the + receive buffer. This assumes that the controller has notified the + driver that a packet has been received. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + CardLine _ Specifies which line the packet was received on (HTDSU_LINEx_ID). + + BytesReceived _ Number of bytes received. + + RxErrors _ Receive error flags non-zero if packet has errors. + +Return Values: + + None + +---------------------------------------------------------------------------*/ +{ + DBG_FUNC("CardGetReceiveInfo") + + USHORT Length; + + DBG_ENTER(Adapter); + + /* + // This should be true if we're here, but there are race conditions + // on hangup where I've seen this condition hit. + */ + if (READ_REGISTER_USHORT(&Adapter->AdapterRam->RxDataAvailable) == 0) + { + *RxErrors = 0; + *BytesReceived = 0; + *CardLine = HTDSU_CMD_LINE1; // Don't return a bad line # + } + else + { + /* + // The length field tells us how many bytes are in the packet, and + // the most significant bit tells us whether the packet has a CRC error. + */ + Length = READ_REGISTER_USHORT(&Adapter->AdapterRam->RxBuffer.Length); + *BytesReceived = Length & ~HTDSU_CRC_ERROR; + *RxErrors = Length & HTDSU_CRC_ERROR; + + /* + // The least significant nibble of the address tells us what line the + // packet was received on -- at least it better... + */ + *CardLine = (READ_REGISTER_USHORT( + &Adapter->AdapterRam->RxBuffer.Address) & + 0x000F) + HTDSU_CMD_LINE1; + + if ((*CardLine != HTDSU_CMD_LINE1) && (*CardLine != HTDSU_CMD_LINE2)) + { + *RxErrors |= HTDSU_RX_ERROR; + *CardLine = HTDSU_CMD_LINE1; // Don't return a bad line # + } + else if (*BytesReceived > HTDSU_MAX_PACKET_SIZE) + { + *RxErrors |= HTDSU_RX_ERROR; + } + } + + DBG_LEAVE(Adapter); +} + + +VOID +CardDialNumber( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine, /* HTDSU_CMD_LINE1 or HTDSU_CMD_LINE2 */ + IN PUCHAR DialString, + IN ULONG DialStringLength + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + Place a dial string on the adapter and start the dialing sequence. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + CardLine _ Specifies which line to use for the transmit (HTDSU_LINEx_ID). + + DialString _ A pointer to an ASCII null-terminated string of digits. + + DialStringLength _ Number of bytes in dial string. + +Return Values: + + None + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("CardDialNumber") + + UINT Index; + UINT NumDigits; + + PUSHORT DialRam; + + DBG_ENTER(Adapter); + + ASSERT(READ_REGISTER_USHORT(&Adapter->AdapterRam->TxDataEmpty)); + ASSERT(READ_REGISTER_USHORT(&Adapter->AdapterRam->Command) == HTDSU_CMD_NOP); + + /* + // Copy the digits to be dialed onto the adapter. + // The adapter interprets phone numbers as high byte is valid digit, + // low byte is ignored, the last digit gets bit 15 set. + */ + DialRam = (PUSHORT) &Adapter->AdapterRam->TxBuffer; + + for (NumDigits = Index = 0; Index < DialStringLength && *DialString; Index++) + { + if ((*DialString >= '0') && (*DialString <= '9')) + { + WRITE_REGISTER_USHORT( + DialRam, + (USHORT) ((*DialString - '0') << 8) + ); + DialRam++; + + /* + // Make sure dial string is within the limit of the adapter. + */ + if (++NumDigits >= HTDSU_MAX_DIALING_DIGITS) + { + break; + } + } + DialString++; + } + + /* + // Set the MSB in the last digit. + */ + DialRam--; + WRITE_REGISTER_USHORT( + DialRam, + (USHORT) (READ_REGISTER_USHORT(DialRam) | 0x8000) + ); + + /* + // Initiate the dial sequence. + */ + CardDoCommand(Adapter, CardLine, HTDSU_CMD_DIAL); + + DBG_LEAVE(Adapter); +} + diff --git a/private/ntos/ndis/htdsu/card.h b/private/ntos/ndis/htdsu/card.h new file mode 100644 index 000000000..fe618d439 --- /dev/null +++ b/private/ntos/ndis/htdsu/card.h @@ -0,0 +1,521 @@ +/***************************************************************************\ +|* 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. *| +\***************************************************************************/ + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Module Name: + + card.h + +Abstract: + + This module defines the hardware specific structures and values used to + control the HT DSU41. You will need to replace this module with the + control functions required to support your hardware. + + This driver conforms to the NDIS 3.0 miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Include this file at the top of each module in the Miniport driver. + +Revision History: + +---------------------------------------------------------------------------*/ + +#ifndef _CARD_H +#define _CARD_H + +/* +// Maximum number of outstanding transmits allowed. Actually, the driver +// must queue all transmits internally if they can't be placed on the adapter. +*/ +#define HTDSU_MAX_TRANSMITS 1 + +/* +// Maximum packet size allowed by the adapter -- must be restricted to +// 1500 bytes at this point, and must also allow for frames at least 32 +// bytes longer. +*/ +#define HTDSU_MAX_PACKET_SIZE 1532 +#define HTDSU_MAX_FRAME_SIZE (HTDSU_MAX_PACKET_SIZE - 32) + +/* +// WAN packets don't have a MAC header. +*/ +#define HTDSU_MAC_HEADER_SIZE 0 + +/* +// The WAN miniport driver must indicate the entire packet when it is received. +*/ +#define HTDSU_MAX_LOOKAHEAD (HTDSU_MAX_PACKET_SIZE - HTDSU_MAC_HEADER_SIZE) + +/* +// Media link speed in bits per second. +*/ +#define HTDSU_LINK_SPEED 57600 // bits per second + +/* +// The maximum number of digits allowed to be in a dialing sequence. +*/ +#define HTDSU_MAX_DIALING_DIGITS 32 + +/* +// These time out values depend on the card firmware and media contraints. +// We should see a dial tone within 5 seconds, +// We should then see an answer within at most 30 seconds. +// When a call arrives, it should be accepted within 5 seconds. +// And after it is answer, we should get a connect within 2 seconds. +*/ +#define HTDSU_NO_DIALTONE_TIMEOUT 5000 // 5 seconds +#define HTDSU_NO_ANSWER_TIMEOUT 40000 // 40 seconds +#define HTDSU_NO_ACCEPT_TIMEOUT 5000 // 5 seconds +#define HTDSU_NO_CONNECT_TIMEOUT 2000 // 2 seconds +#define HTDSU_NO_CLOSECALL_TIMEOUT 2000 // 2 seconds + +/* +// Turn on structure packing to make sure these data structures stay +// aligned with the hardware. +*/ +#include + +/* +// Both the transmit and receive buffers have this same format on the card. +*/ +typedef struct _HTDSU_BUFFER +{ + /* + // The least significant nibble of the Address field specifies + // which line the data is associated with (0 = line 1, 1 = line 2). + // The most significant nibbles are used for sequencing information + // if line multiplexing is used (NOT SUPPORTED BY THIS DRIVER). + */ +# define HTDSU_LINE1_ID 0 +# define HTDSU_LINE2_ID 1 + USHORT Address; + + /* + // The length of the Data field in bytes. + // MSB of length field will be set if the HDLC framing detects a + // CRC error on any received packet. + */ +# define HTDSU_RX_ERROR 0x1000 +# define HTDSU_CRC_ERROR 0x8000 + USHORT Length; + + /* + // The Data field holds the data to be transmitted, or the data just + // received on the line. The data must be terminated with a 0x1616. + // Note that the data will be padded to an even byte count by the + // DSU firmware on incoming frames, and the driver will pad the outgoing + // frames so that the terminator is word aligned. Only 'Length' bytes + // will actually be transmitted on the line however. + */ +# define HTDSU_DATA_SIZE (2016 - (2 * sizeof(USHORT))) +# define HTDSU_DATA_TERMINATOR 0x1616 +# define HTDSU_DATA_ODDBYTE_MASK 0xFF00 + USHORT Data[HTDSU_DATA_SIZE/sizeof(USHORT)]; + +} HTDSU_BUFFER, *PHTDSU_BUFFER; + +/* +// This structure can be overlaid onto the DSU41 adapter memory for +// easy access to the hardware registers and data buffers. +// THIS ONLY WORKS IF THE COMPILER SUPPORTS STRUCTURE PACKING ON 16 BIT BOUNDRY. +*/ +typedef struct _HTDSU_REGISTERS +{ + /* 0x000 - 0x7DF + // The transmit buffer will hold a single packet. + */ + HTDSU_BUFFER TxBuffer; + + /* 0x7E0 - 0xFBF + // The receive buffer may hold more than one packet at a time. + */ + HTDSU_BUFFER RxBuffer; + + /* 0xFC0 - 0xFD5 + // Reserved hardware registers. + */ + USHORT Reserved1[0x0B]; + + /* 0xFD6 + // This register will be set to 1 by the interrupt handler to tell + // the hardware to clear the current interrupt from the adapter. + */ + USHORT InterruptClear; + + /* 0xFD8, 0xFDA + // When using transparent mode on line 1 or 2, these registers tell the + // adapter how many bytes are interrupt the CPU. + // (NOT SUPPORTED BY THIS DRIVER). + */ + USHORT Rx2Length; + USHORT Rx1Length; + + /* 0xFDC + // This register will be set to 1 when the adapter receives a frame + // from the remote unit. The driver must reset this register to zero + // after it has copied the frame from the adapter's RxBuffer. + */ + USHORT RxDataAvailable; + + /* 0xFDE + // This register will be set to 1 when the adapter copies the frame + // from the TxBuffer to its internal buffer. The driver must reset + // this register to zero after it fills the TxBuffer and places the + // termination flag at the end. + */ + USHORT TxDataEmpty; + + /* 0xFE0 + // The drivers uses this register to tell the adapter to perform various + // actions. The adapter will reset this register to zero when the + // command completes. + */ +# define HTDSU_CMD_NOP 0x0000 +# define HTDSU_CMD_ANSWER 0x0100 +# define HTDSU_CMD_DIAL 0x0200 +# define HTDSU_CMD_DISCONNECT 0x0300 +# define HTDSU_CMD_SELFTEST 0x0400 +# define HTDSU_CMD_CLEAR_ERRORS 0x0500 +# define HTDSU_CMD_LOCAL_LOOPBACK 0x0600 +# define HTDSU_CMD_LINE_LOOPBACK 0x0700 +# define HTDSU_CMD_REMOTE_LOOPBACK 0x0800 +# define HTDSU_CMD_REMOTETP_LOOPBACK 0x0900 +# define HTDSU_CMD_STOP_LOOPBACK 0x0A00 +# define HTDSU_CMD_LEASED_LINE 0x0B00 +# define HTDSU_CMD_DIALUP_LINE 0x0C00 +# define HTDSU_CMD_RX_BIT_SLIP 0x0D00 +# define HTDSU_CMD_DDS_TX_CLOCK 0x0E00 +# define HTDSU_CMD_INTERNAL_TX_CLOCK 0x0E10 +# define HTDSU_CMD_CLEAR_INTERRUPT 0x0F00 +# define HTDSU_CMD_FORCE_ERROR 0x1000 +# define HTDSU_CMD_RESET 0x1100 +# define HTDSU_CMD_HT_PROTOCOL 0x1200 +# define HTDSU_CMD_NO_PROTOCOL 0x1210 +# define HTDSU_CMD_HDLC_PROTOCOL 0x1220 +# define HTDSU_CMD_TX_RATE_MAX 0x1400 +# define HTDSU_CMD_TX_RATE_57600 0x1410 +# define HTDSU_CMD_TX_RATE_38400 0x1420 +# define HTDSU_CMD_TX_RATE_19200 0x1430 +# define HTDSU_CMD_TX_RATE_9600 0x1440 +# define HTDSU_CMD_LINE1 0x0001 +# define HTDSU_CMD_LINE2 0x0002 + USHORT Command; + + /* 0xFE2, 0xFE4 + // The InterruptEnable register provides control over which adapter events + // will signal an interrupt to the CPU. The InterruptStatus register is + // used by the driver to determine the cause of an interrupt. + */ +# define HTDSU_INTR_DISABLE 0x0000 +# define HTDSU_INTR_RX_FULL2 0x0001 +# define HTDSU_INTR_RX_FULL1 0x0002 +# define HTDSU_INTR_RX_PACKET2 0x0004 +# define HTDSU_INTR_RX_PACKET1 0x0008 +# define HTDSU_INTR_NO_SIGNAL2 0x0010 +# define HTDSU_INTR_NO_SIGNAL1 0x0020 +# define HTDSU_INTR_DISCONNECTED2 0x0040 +# define HTDSU_INTR_DISCONNECTED1 0x0080 +# define HTDSU_INTR_CONNECTED2 0x0100 +# define HTDSU_INTR_CONNECTED1 0x0200 +# define HTDSU_INTR_RINGING2 0x0400 +# define HTDSU_INTR_RINGING1 0x0800 +# define HTDSU_INTR_TX_PACKET2 0x1000 +# define HTDSU_INTR_TX_PACKET1 0x2000 +# define HTDSU_INTR_TX_EMPTY2 0x4000 +# define HTDSU_INTR_TX_EMPTY1 0x8000 +# define HTDSU_INTR_ALL_LINE1 (HTDSU_INTR_RX_FULL1 | \ + HTDSU_INTR_RX_PACKET1 | \ + HTDSU_INTR_TX_PACKET1 | \ + HTDSU_INTR_NO_SIGNAL1 | \ + HTDSU_INTR_DISCONNECTED1 | \ + HTDSU_INTR_CONNECTED1 | \ + HTDSU_INTR_RINGING1) +# define HTDSU_INTR_ALL_LINE2 (HTDSU_INTR_RX_FULL2 | \ + HTDSU_INTR_RX_PACKET2 | \ + HTDSU_INTR_TX_PACKET2 | \ + HTDSU_INTR_NO_SIGNAL2 | \ + HTDSU_INTR_DISCONNECTED2 | \ + HTDSU_INTR_CONNECTED2 | \ + HTDSU_INTR_RINGING2) + USHORT InterruptEnable; + USHORT InterruptStatus; + + /* 0xFE6, 0xFE8 + // The StatusLine registers are used by the driver to determine the + // current state of the associated phone line. + */ +# define HTDSU_STATUS_LOCAL_LOOPBACK 0x0001 +# define HTDSU_STATUS_CO_LOOPBACK 0x0002 +# define HTDSU_STATUS_REMOTE_LOOPBACK 0x0008 +# define HTDSU_STATUS_LINE_LOOPBACK 0x0010 +# define HTDSU_STATUS_OUT_OF_FRAME 0x0020 +# define HTDSU_STATUS_OUT_OF_SERVICE 0x0040 +# define HTDSU_STATUS_NO_SIGNAL 0x0080 +# define HTDSU_STATUS_NO_CURRENT 0x0100 +# define HTDSU_STATUS_NO_DIAL_TONE 0x0200 +# define HTDSU_STATUS_ON_LINE 0x0400 +# define HTDSU_STATUS_NO_ANSWER 0x0800 +# define HTDSU_STATUS_CARRIER_DETECT 0x1000 +# define HTDSU_STATUS_RINGING 0x2000 +# define HTDSU_STATUS_REMOTE_RESPONSE 0x4000 + USHORT StatusLine1; + USHORT StatusLine2; + + /* 0xFEA, 0xFEC + // The error counter registers are used when running the command: + // HTDSU_CMD_REMOTETP_LOOPBACK. The counters are incremented if a + // test pattern error is detected, and they are reset when the test + // is terminated. + */ +#define HTDSU_ERROR_COPROCESSOR 0x0800 +#define HTDSU_ERROR_DSU2 0x1000 +#define HTDSU_ERROR_DSU1 0x2000 +#define HTDSU_ERROR_LOW_BYTE 0x4000 +#define HTDSU_ERROR_HIGH_BYTE 0x8000 + USHORT ErrorsLine1; + USHORT ErrorsLine2; + + /* 0xFEE + // The adapter firmware sets test SelfTestStatus register if it detects + // an error during the HTDSU_CMD_SELFTEST command. Otherwise this register + // is reset to zero. + */ +#define HTDSU_SELFTEST_OK (HTDSU_ERROR_HIGH_BYTE | \ + HTDSU_ERROR_LOW_BYTE | \ + HTDSU_ERROR_COPROCESSOR) +#define HTDSU_SELFTEST_TIMEOUT 40000 // 4 seconds. + USHORT SelfTestStatus; + + /* 0xFF0 + // Reserved hardware register. + */ + USHORT Reserved2; + + /* 0xFF2 + // DSU serial number. + */ + USHORT SerialNumber; + + /* 0xFF4 + // Co-processor firmware checksum. + */ + USHORT CoProcessorCheckSum; + + /* 0xFF6 + // DSU firmware checksum. + */ + USHORT DsuCheckSum; + + /* 0xFF8 + // Co-processor firmware version. + */ +# define HTDSU_COPROCESSOR_VERSION 0x0340 + USHORT CoProcessorVersion; + + /* 0xFFA + // DSU firmware version. + */ +# define HTDSU_DSU_VERSION 0x0013 + USHORT DsuVersion; + + /* 0xFFC + // DSU hardware ID. + */ +# define HTDSU_DSU_ID 0x0050 + USHORT DsuId; + + /* 0xFFE + // Co-processor ID. + */ +# define HTDSU_COPROCESSOR_ID 0x0060 + USHORT CoProcessorId; + +} HTDSU_REGISTERS, * PHTDSU_REGISTERS; + + +/* +// Turn off structure packing. +*/ +#include + +/* +// The adapter memory structure must be sized the same as the hardware! +*/ +#define HTDSU_MEMORY_SIZE sizeof(HTDSU_REGISTERS) + +/* +// Enable the currently accepted interrupts on the adapter. +*/ +#define CardEnableInterrupt(Adapter) \ + {WRITE_REGISTER_USHORT(&Adapter->AdapterRam->InterruptEnable, \ + Adapter->InterruptEnableFlag);} + +/* +// Disable all interrupts on the adapter. +*/ +#define CardDisableInterrupt(Adapter) \ + {WRITE_REGISTER_USHORT(&Adapter->AdapterRam->InterruptEnable, \ + HTDSU_INTR_DISABLE);} + +/* +// Clear all the current interrupts on the adapter. +*/ +#define CardClearInterrupt(Adapter) \ + {WRITE_REGISTER_USHORT(&Adapter->AdapterRam->InterruptClear, 1);} + +/* +// Return TRUE if all interrupts are disabled on the adapter. +*/ +#define CardAreInterruptsDisabled(Adapter) \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->InterruptEnable) == \ + HTDSU_INTR_DISABLE) + +/* +// Return the current interrupt status from the adapter. +*/ +#define CardGetInterrupt(Adapter) \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->InterruptStatus)) + +/* +// Start sending the current packet out. +*/ +#define CardStartTransmit(Adapter) \ + {WRITE_REGISTER_USHORT(&Adapter->AdapterRam->TxDataEmpty, 0);} + +/* +// Return non-zero if transmit buffer is empty +*/ +#define CardTransmitEmpty(Adapter) \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->TxDataEmpty)) + +/* +// Tell the adapter we're done with the packet just received. +*/ +#define CardReceiveAvailable(Adapter) \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->RxDataAvailable)) + +/* +// Tell the adapter we're done with the packet just received. +*/ +#define CardReceiveComplete(Adapter) \ + {WRITE_REGISTER_USHORT(&Adapter->AdapterRam->RxDataAvailable, 0);} + +/* +// Tell the adapter to pick up the line. +*/ +#define CardLineAnswer(Adapter, CardLine) \ + CardDoCommand(Adapter, CardLine, HTDSU_CMD_ANSWER) + +/* +// Return non-zero if remote unit has responded to ring from this line. +*/ +#define CardStatusRingBack(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_REMOTE_RESPONSE) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_REMOTE_RESPONSE) \ + ) + +/* +// Return non-zero if this phone line is ringing. +*/ +#define CardStatusRinging(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_RINGING) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_RINGING) \ + ) + +/* +// Return non-zero if this line has detected a carrier signal. +*/ +#define CardStatusCarrierDetect(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_CARRIER_DETECT) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_CARRIER_DETECT) \ + ) + +/* +// Return non-zero if the number we dialed on this line did not answer. +*/ +#define CardStatusNoAnswer(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_NO_ANSWER) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_NO_ANSWER) \ + ) + +/* +// Return non-zero if the selected line is ready to use. +*/ +#define CardStatusOnLine(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_ON_LINE) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_ON_LINE) \ + ) + +/* +// Return non-zero if no dial tone is present on this line. +*/ +#define CardStatusNoDialTone(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_NO_DIAL_TONE) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_NO_DIAL_TONE) \ + ) + +/* +// Return non-zero if this line has no sealing current. +*/ +#define CardStatusNoCurrent(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_NO_CURRENT) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_NO_CURRENT) \ + ) + +/* +// Return non-zero if this line has no signal present. +*/ +#define CardStatusNoSignal(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_NO_SIGNAL) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_NO_SIGNAL) \ + ) + +/* +// Return non-zero if this line has been placed out of service by the switch. +*/ +#define CardStatusOutOfService(Adapter, CardLine) \ + ((CardLine == HTDSU_CMD_LINE1) ? \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) & \ + HTDSU_STATUS_OUT_OF_SERVICE) : \ + (READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2) & \ + HTDSU_STATUS_OUT_OF_SERVICE) \ + ) + +#endif // _CARD_H + diff --git a/private/ntos/ndis/htdsu/debug.c b/private/ntos/ndis/htdsu/debug.c new file mode 100644 index 000000000..846e51737 --- /dev/null +++ b/private/ntos/ndis/htdsu/debug.c @@ -0,0 +1,112 @@ +/***************************************************************************\ +|* 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: + + debug.c + +Abstract: + + This module contains code to support driver debugging. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Development only. + +Revision History: + +---------------------------------------------------------------------------*/ + +#include + +#if DBG + + +VOID +DbgPrintData( + IN PUCHAR Data, + IN UINT NumBytes, + IN ULONG Offset + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Routine Description: + + Dumps data to the debug display formated in hex and ascii for easy viewing. + Used for debug output only. It is not compiled into the retail version. + +Arguments: + + Data Buffer of data to be displayed + + NumBytes Number of bytes to display + + Offset Beginning offset to be displayed before each line + +Return Value: + + None + +---------------------------------------------------------------------------*/ + +{ + UINT i,j; + + for (i = 0; i < NumBytes; i += 16) + { + DbgPrint("%04lx: ", i + Offset); + + /* + // Output the hex bytes + */ + for (j = i; j < (i+16); j++) + { + if (j < NumBytes) + { + DbgPrint("%02x ",(UINT)((UCHAR)*(Data+j))); + } + else + { + DbgPrint(" "); + } + } + + DbgPrint(" "); + + /* + // Output the ASCII bytes + */ + for (j = i; j < (i+16); j++) + { + if (j < NumBytes) + { + char c = *(Data+j); + + if (c < ' ' || c > 'Z') + { + c = '.'; + } + DbgPrint("%c", (UINT)c); + } + else + { + DbgPrint(" "); + } + } + DbgPrint("\n"); + } +} + +#endif + diff --git a/private/ntos/ndis/htdsu/debug.h b/private/ntos/ndis/htdsu/debug.h new file mode 100644 index 000000000..5f3c6c581 --- /dev/null +++ b/private/ntos/ndis/htdsu/debug.h @@ -0,0 +1,137 @@ +/***************************************************************************\ +|* 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. *| +\***************************************************************************/ + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Module Name: + + debug.h + +Abstract: + + This file contains generic debug macros for driver development. + If (DBG == 0) no code is generated; Otherwise macros will expand. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Development Only. + + debug.c must be linked into the driver code to support output. + +Revision History: + +---------------------------------------------------------------------------*/ + +#ifndef _DEBUG_H +#define _DEBUG_H + +/* +// DEBUG FLAG DEFINITIONS +*/ + +#define DBG_ERROR_ON 0x0001L /* Display DBG_ERROR messages */ +#define DBG_WARNING_ON 0x0002L /* Display DBG_WARNING messages */ +#define DBG_NOTICE_ON 0x0004L /* Display DBG_NOTICE messages */ +#define DBG_TRACE_ON 0x0008L /* Display ENTER/TRACE/LEAVE messages */ +#define DBG_REQUEST_ON 0x0010L /* Enable set/query request display */ +#define DBG_PARAMS_ON 0x0020L /* Enable function parameter display */ +#define DBG_HEADERS_ON 0x0040L /* Enable Tx/Rx MAC header display */ +#define DBG_PACKETS_ON 0x0080L /* Enable Tx/Rx packet display */ +#define DBG_FILTER1_ON 0x0100L /* Display DBG_FILTER 1 messages */ +#define DBG_FILTER2_ON 0x0200L /* Display DBG_FILTER 2 messages */ +#define DBG_FILTER3_ON 0x0400L /* Display DBG_FILTER 3 messages */ +#define DBG_FILTER4_ON 0x0800L /* Display DBG_FILTER 4 messages */ +#define DBG_BREAK_ON 0x1000L /* Enable breakpoints */ +#define DBG_TAPICALL_ON 0x4000L /* Enable TAPI call state messages */ +#define DBG_HWTEST_ON 0x8000L /* Enable hardware self-test */ + +extern VOID +DbgPrintData( + IN PUCHAR Data, + IN UINT NumBytes, + IN ULONG Offset + ); + +extern VOID NTAPI DbgBreakPoint(VOID); + +#if defined(DBG) && (DBG != 0) + +/* +// A - is a pointer to the adapter structure +// S - is a parenthesised printf string +// e.g. DBG_PRINT(Adap,("ERR=%d",err)); +// F - is a function name +// e.g. DBG_FUNC("FunctionName") +// C - is a C conditional +// e.g. ASSERT(a <= b) +*/ + +# define BREAKPOINT DbgBreakPoint() + +# define STATIC + +# define DBG_FUNC(F) static const char __FUNC__[] = F; + +# define DBG_BREAK(A) {if ((A)->DbgFlags & DBG_BREAK_ON) BREAKPOINT;} + +// WARNING DBG_PRINT(A,S) (A) can be NULL!!! +# define DBG_PRINT(A,S) {DbgPrint("%s---%s @ %s:%d\n",(A)?(A)->DbgID:"?",__FUNC__,__FILE__,__LINE__);DbgPrint S;} + +# define DBG_ENTER(A) {if ((A)->DbgFlags & DBG_TRACE_ON) \ + {DbgPrint("%s>>>%s\n",(A)->DbgID,__FUNC__);}} + +# define DBG_TRACE(A) {if ((A)->DbgFlags & DBG_TRACE_ON) \ + {DbgPrint("%s---%s:%d\n",(A)->DbgID,__FUNC__,__LINE__);}} + +# define DBG_LEAVE(A) {if ((A)->DbgFlags & DBG_TRACE_ON) \ + {DbgPrint("%s<<<%s\n",(A)->DbgID,__FUNC__);}} + +# define DBG_ERROR(A,S) {if ((A)->DbgFlags & DBG_ERROR_ON) \ + {DbgPrint("%s---%s: ERROR: ",(A)->DbgID,__FUNC__);DbgPrint S;}} + +# define DBG_WARNING(A,S) {if ((A)->DbgFlags & DBG_WARNING_ON) \ + {DbgPrint("%s---%s: WARNING: ",(A)->DbgID,__FUNC__);DbgPrint S;}} + +# define DBG_NOTICE(A,S) {if ((A)->DbgFlags & DBG_NOTICE_ON) \ + {DbgPrint("%s---%s: NOTICE: ",(A)->DbgID,__FUNC__);DbgPrint S;}} + +# define DBG_FILTER(A,M,S){if ((A)->DbgFlags & (M)) \ + {DbgPrint("%s---%s: ",(A)->DbgID,__FUNC__);DbgPrint S;}} + +# define DBG_DISPLAY(S) {DbgPrint("?---%s: ",__FUNC__); DbgPrint S;} + +#ifdef ASSERT +#undef ASSERT +#endif +#define ASSERT(C) if (!(C)) { \ + DbgPrint("!---%s: ASSERT(%s) FAILED!\n%s #%d\n", \ + __FUNC__, #C, __FILE__, __LINE__); \ + BREAKPOINT; \ + } +#else + +# define BREAKPOINT +# define STATIC static +# define DBG_FUNC(F) +# define DBG_BREAK +# define DBG_PRINT(A,S) +# define DBG_ENTER(A) +# define DBG_TRACE(A) +# define DBG_LEAVE(A) +# define DBG_ERROR(A,S) +# define DBG_WARNING(A,S) +# define DBG_NOTICE(A,S) +# define DBG_FILTER(A,M,S) +# define DBG_DISPLAY(S) + +#endif + +#endif diff --git a/private/ntos/ndis/htdsu/htdsu.c b/private/ntos/ndis/htdsu/htdsu.c new file mode 100644 index 000000000..a1a48258d --- /dev/null +++ b/private/ntos/ndis/htdsu/htdsu.c @@ -0,0 +1,1395 @@ +/***************************************************************************\ +|* Copyright (c) 1994 Microsoft Corporation *| +|* Developed for Microsoft by TriplePoint, Inc. Beaverton, Oregon *| +|* *| +|* This file is part of the HT Communications DSU41 WAN Miniport Driver. *| +\***************************************************************************/ +#include "version.h" +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Module Name: + + htdsu.c + +Abstract: + + This module contains the DriverEntry() routine, which is the first + routine called when the driver is loaded into memory. The Miniport + initialization and termination routines are also implemented here: + MiniportInitialize() + MiniportHalt() + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 1 // Unique file ID for error logging + +#include "htdsu.h" + +/* +// This is defined here to avoid including all of ntddk.h which cannot +// normally be included by a miniport driver. +*/ +extern +NTSYSAPI +NTSTATUS +NTAPI +RtlUnicodeStringToAnsiString( + PANSI_STRING out, + PUNICODE_STRING in, + BOOLEAN allocate + ); + +/* +// Receives the context value representing the Miniport wrapper +// as returned from NdisMInitializeWrapper. +*/ +static NDIS_HANDLE +NdisWrapperHandle = NULL; + +/* +// This constant is used for places where NdisAllocateMemory needs to be +// called and the HighestAcceptableAddress does not matter. +*/ +static NDIS_PHYSICAL_ADDRESS +HighestAcceptableAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1,-1); + +/* +// This is used to assign a unique instance number to each adapter. +*/ +static UCHAR +HtDsuAdapterCount = 0; + +/* +// Tell the compiler which routines can be unloaded after initialization. +*/ +NTSTATUS +DriverEntry( + IN PDRIVER_OBJECT DriverObject, + IN PUNICODE_STRING RegistryPath + ); +#pragma NDIS_INIT_FUNCTION(DriverEntry) + +/* +// Tell the compiler which routines can be paged out. +// These can never be called from interrupt or DPC level! +*/ +NDIS_STATUS +HtDsuInitialize( + OUT PNDIS_STATUS OpenErrorStatus, + OUT PUINT SelectedMediumIndex, + IN PNDIS_MEDIUM MediumArray, + IN UINT MediumArraySize, + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE WrapperConfigurationContext + ); +#pragma NDIS_PAGABLE_FUNCTION(HtDsuInitialize) + +NDIS_STATUS +HtDsuRegisterAdapter( + IN PHTDSU_ADAPTER Adapter, + IN PSTRING AddressList + ); +#pragma NDIS_PAGABLE_FUNCTION(HtDsuRegisterAdapter) + +VOID +HtDsuHalt( + IN PHTDSU_ADAPTER Adapter + ); +#pragma NDIS_PAGABLE_FUNCTION(HtDsuHalt) + + +NTSTATUS +DriverEntry( + IN PDRIVER_OBJECT DriverObject, + IN PUNICODE_STRING RegistryPath + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The DriverEntry routine is the main entry point for the driver. + It is responsible for the initializing the Miniport wrapper and + registering the driver with the Miniport wrapper. + +Parameters: + + DriverObject _ Pointer to driver object created by the system. + + RegistryPath _ Pointer to registery path name used to read registry + parameters. + +Return Values: + + STATUS_SUCCESS + STATUS_UNSUCCESSFUL + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuDriverEntry") + + /* + // Receives the status of the NdisMWanRegisterMiniport operation. + */ + NDIS_STATUS Status; + + /* + // Characteristics table passed to NdisMWanRegisterMiniport. + */ + NDIS_WAN_MINIPORT_CHARACTERISTICS HtDsuChar; + +#if DBG + DbgPrint("?>>>%s: Build Date:"__DATE__" Time:"__TIME__"\n",__FUNC__); +#endif + + /* + // Initialize the Miniport wrapper - THIS MUST BE THE FIRST NDIS CALL. + */ + NdisMInitializeWrapper( + &NdisWrapperHandle, + DriverObject, + RegistryPath, + NULL + ); + + /* + // Initialize the characteristics table, exporting the Miniport's entry + // points to the Miniport wrapper. + */ + HtDsuChar.MajorNdisVersion = NDIS_MAJOR_VERSION; + HtDsuChar.MinorNdisVersion = NDIS_MINOR_VERSION; + HtDsuChar.Reserved = NDIS_USE_WAN_WRAPPER; + + HtDsuChar.CheckForHangHandler = HtDsuCheckForHang; + HtDsuChar.DisableInterruptHandler = HtDsuDisableInterrupt; + HtDsuChar.EnableInterruptHandler = HtDsuEnableInterrupt; + HtDsuChar.HaltHandler = HtDsuHalt; + HtDsuChar.HandleInterruptHandler = HtDsuHandleInterrupt; + HtDsuChar.InitializeHandler = HtDsuInitialize; + HtDsuChar.ISRHandler = HtDsuISR; + HtDsuChar.QueryInformationHandler = HtDsuQueryInformation; + HtDsuChar.ReconfigureHandler = NULL; // Hardware not reconfigurable + HtDsuChar.ResetHandler = HtDsuReset; + HtDsuChar.WanSendHandler = HtDsuWanSend; + HtDsuChar.SetInformationHandler = HtDsuSetInformation; + HtDsuChar.TransferDataHandler = NULL; // Not used by WAN drivers + + /* + // Register the driver with the Miniport wrapper. + */ + Status = NdisMRegisterMiniport( + NdisWrapperHandle, + (PNDIS_MINIPORT_CHARACTERISTICS) &HtDsuChar, + sizeof(HtDsuChar) + ); + + /* + // The driver will not load if this call fails. + // The system will log the error for us. + */ + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_DISPLAY(("ERROR: NdisMRegisterMiniport Status=%Xh\n",Status)); + return STATUS_UNSUCCESSFUL; + } + + return STATUS_SUCCESS; +} + + + +NDIS_STATUS +HtDsuInitialize( + OUT PNDIS_STATUS OpenErrorStatus, + OUT PUINT SelectedMediumIndex, + IN PNDIS_MEDIUM MediumArray, + IN UINT MediumArraySize, + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE WrapperConfigurationContext + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportInitialize request is called to have the Miniport driver + initialize the adapter. + + No other request will be outstanding on the Miniport when this routine + is called. No other request will be submitted to the Miniport until + the operation is completed. + + The wrapper will supply an array containing a list of the media types + that it supports. The Miniport driver reads this array and returns + the index of the media type that the wrapper should treat her as. + If the Miniport driver is impersonating a media type that is different + from the true media type, this must be done completely transparently to + the wrapper. + + If the Miniport driver cannot find a media type supported by both it + and the wrapper, it returns NDIS_STATUS_UNSUPPORTED_MEDIA. + + The status value NDIS_STATUS_OPEN_ERROR has a special meaning. It + indicates that the OpenErrorStatus parameter has returned a valid status + which the wrapper can examine to obtain more information about the error. + + This routine is called with interrupts enabled, and a call to MiniportISR + will occur if the adapter generates any interrupts. During this routine + MiniportDisableInterrupt and MiniportEnableInterrupt will not be called, + so it is the responsibility of the Miniport driver to acknowledge and + clear any interrupts generated. + +Parameters: + + OpenErrorStatus _ Returns more information about the reason for the + failure. Currently, the only values defined match those + specified as Open Error Codes in Appendix B of the IBM + Local Area Network Technical Reference. + + SelectedMediumIndex _ Returns the index in MediumArray of the medium type + that the Miniport driver wishes to be viewed as. + Note that even though the NDIS interface may complete + this request asynchronously, it must return this + index on completion of this function. + + MediumArray _ An array of medium types which the wrapper supports. + + MediumArraySize _ The number of elements in MediumArray. + + MiniportAdapterHandle _ A handle identifying the Miniport. The Miniport + driver must supply this handle in future requests + that refer to the Miniport. + + WrapperConfigurationContext _ The handle used for calls to NdisOpenConfiguration, + and the routines in section 4 of this document. + +Return Values: + + NDIS_STATUS_ADAPTER_NOT_FOUND + NDIS_STATUS_FAILURE + NDIS_STATUS_NOT_ACCEPTED + NDIS_STATUS_OPEN_ERROR + NDIS_STATUS_RESOURCES + NDIS_STATUS_SUCCESS + NDIS_STATUS_UNSUPPORTED_MEDIA + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuInitialize") + + /* + // Holds the status result returned from an NDIS function call. + */ + NDIS_STATUS Status; + + /* + // Pointer to our newly allocated adapter. + */ + PHTDSU_ADAPTER Adapter; + + /* + // The handle for reading from the registry. + */ + NDIS_HANDLE ConfigHandle; + + /* + // The value read from the registry. + */ + PNDIS_CONFIGURATION_PARAMETER ReturnedValue; + + UINT index; + + /* + // Define all the parameters that will be read. + */ + NDIS_STRING RamBaseString = HTDSU_PARAM_RAMBASE_STRING; + ULONG RamBaseAddress = 0; + + NDIS_STRING InterruptString = HTDSU_PARAM_INTERRUPT_STRING; + CCHAR InterruptNumber = 0; + + NDIS_STRING LineTypeString = HTDSU_PARAM_LINETYPE_STRING; + CCHAR LineType = 0; + + NDIS_STRING LineRateString = HTDSU_PARAM_LINERATE_STRING; + USHORT LineRate = 0; + + NDIS_STRING MediaTypeString = HTDSU_PARAM_MEDIATYPE_STRING; + ANSI_STRING MediaType; + + NDIS_STRING DeviceNameString = HTDSU_PARAM_DEVICENAME_STRING; + ANSI_STRING DeviceName; + + NDIS_STRING AddressListString = HTDSU_PARAM_ADDRLIST_STRING; + ANSI_STRING AddressList; + +#if DBG + NDIS_STRING DbgFlagsString = HTDSU_PARAM_DBGFLAGS_STRING; + ULONG DbgFlags = 0; +#endif + + /* + // Search the MediumArray for the WAN media type. + */ + for (index = 0; index < MediumArraySize; index++) + { + if (MediumArray[index] == NdisMediumWan) + { + break; + } + } + + /* + // Return if no supported medium is found. + */ + if (index >= MediumArraySize) + { + DBG_DISPLAY(("ERROR: No medium found (array=%X,size=%d)\n", + MediumArray, MediumArraySize)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, + 3, + index, + __FILEID__, + __LINE__ + ); + return NDIS_STATUS_UNSUPPORTED_MEDIA; + } + + /* + // Save the selected medium type. + */ + *SelectedMediumIndex = index; + + /* + // Open the configuration registry so we can get our config values. + */ + NdisOpenConfiguration( + &Status, + &ConfigHandle, + WrapperConfigurationContext + ); + + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_DISPLAY(("ERROR: NdisOpenConfiguration failed (Status=%X)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, + 3, + Status, + __FILEID__, + __LINE__ + ); + return NDIS_STATUS_FAILURE; + } + + /******************************************************************** + // Get InterruptNumber for this adapter. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &InterruptString, + NdisParameterInteger + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + InterruptNumber = (CCHAR)(ReturnedValue->ParameterData.IntegerData); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(InterruptNumber) failed (Status=%X)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER, + 3, + Status, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + + /* + // Make sure the interrupt IRQ is valid. + */ + if ((InterruptNumber != HTDSU_PARAM_IRQ03) && + (InterruptNumber != HTDSU_PARAM_IRQ04) && + (InterruptNumber != HTDSU_PARAM_IRQ10) && + (InterruptNumber != HTDSU_PARAM_IRQ11) && + (InterruptNumber != HTDSU_PARAM_IRQ12) && + (InterruptNumber != HTDSU_PARAM_IRQ15)) + { + DBG_DISPLAY(("ERROR: Invalid InterruptNumber=%d)\n",InterruptNumber)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, + 3, + InterruptNumber, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + + /******************************************************************** + // Get RambaseAddress for this adapter. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &RamBaseString, + NdisParameterHexInteger + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + RamBaseAddress = (ULONG)(ReturnedValue->ParameterData.IntegerData); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(RamBaseAddress) failed (Status=%X)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER, + 3, + Status, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + + /* + // Make sure the RambaseAddress is valid. + */ + if ((RamBaseAddress != HTDSU_PARAM_RAMBASE1) && + (RamBaseAddress != HTDSU_PARAM_RAMBASE2) && + (RamBaseAddress != HTDSU_PARAM_RAMBASE3) && + (RamBaseAddress != HTDSU_PARAM_RAMBASE4)) + { + DBG_DISPLAY(("ERROR: Invalid RamBaseAddress=%Xh\n",RamBaseAddress)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, + 3, + RamBaseAddress, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + + /******************************************************************** + // Get MediaType for this adapter. + // The MediaType and DeviceName values are used to construct the + // ProviderInfo strings required by HtTapiGetDevCaps. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &MediaTypeString, + NdisParameterString + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + RtlUnicodeStringToAnsiString( + &MediaType, + &(ReturnedValue->ParameterData.StringData), + TRUE + ); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(MediaType) failed (Status=%X)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER, + 3, + Status, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + + /******************************************************************** + // Get DeviceName for this adapter. + // The MediaType and DeviceName values are used to construct the + // ProviderInfo strings required by HtTapiGetDevCaps. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &DeviceNameString, + NdisParameterString + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + RtlUnicodeStringToAnsiString( + &DeviceName, + &(ReturnedValue->ParameterData.StringData), + TRUE + ); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(DeviceName) failed (Status=%X)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER, + 3, + Status, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + + /******************************************************************** + // Get AddressList for this adapter. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &AddressListString, + NdisParameterString + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + RtlUnicodeStringToAnsiString( + &AddressList, + &(ReturnedValue->ParameterData.StringData), + TRUE + ); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(AddressList) failed (Status=%X)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER, + 3, + Status, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + +#ifdef USE_LEASED_LINE + /******************************************************************** + // Get LineType for this adapter. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &LineTypeString, + NdisParameterInteger + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + LineType = (CCHAR)(ReturnedValue->ParameterData.IntegerData); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(LineType) failed (Status=%X)\n",Status)); + LineType = HTDSU_LINEMODE_DIALUP; + } + + /* + // Make sure the LineType is valid. + */ + if ((LineType != HTDSU_LINEMODE_LEASED) && + (LineType != HTDSU_LINEMODE_DIALUP)) + { + DBG_DISPLAY(("ERROR: Invalid LineType=%d\n",LineType)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, + 3, + LineType, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } +#else + LineType = HTDSU_LINEMODE_DIALUP; +#endif // USE_LEASED_LINE + + /******************************************************************** + // Get LineRate for this adapter. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &LineRateString, + NdisParameterInteger + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + LineRate = (USHORT)(ReturnedValue->ParameterData.IntegerData); + } + else + { + DBG_DISPLAY(("ERROR: NdisReadConfiguration(LineRate) failed (Status=%X)\n",Status)); + LineRate = 1; + } + + /* + // Make sure the LineRate is valid. + */ + LineRate = HTDSU_CMD_TX_RATE_MAX + (LineRate << 4); + if ((LineRate != HTDSU_CMD_TX_RATE_MAX) && + (LineRate != HTDSU_CMD_TX_RATE_57600) && + (LineRate != HTDSU_CMD_TX_RATE_38400) && + (LineRate != HTDSU_CMD_TX_RATE_19200) && + (LineRate != HTDSU_CMD_TX_RATE_9600)) + { + DBG_DISPLAY(("ERROR: Invalid LineRate=%d\n",LineRate)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, + 3, + LineRate, + __FILEID__, + __LINE__ + ); + NdisCloseConfiguration(ConfigHandle); + return NDIS_STATUS_FAILURE; + } + +#if DBG + /******************************************************************** + // Get DbgFlags for this adapter. + */ + NdisReadConfiguration( + &Status, + &ReturnedValue, + ConfigHandle, + &DbgFlagsString, + NdisParameterHexInteger + ); + + if (Status == NDIS_STATUS_SUCCESS) + { + DbgFlags = (ULONG)(ReturnedValue->ParameterData.IntegerData); + } + else + { + DbgFlags = 0; + } +#endif + + /* + // Close the configuration registry - we're done with it. + */ + NdisCloseConfiguration(ConfigHandle); + + /* + // Allocate memory for the adapter information structure. + */ + Status = NdisAllocateMemory( + (PVOID *)&Adapter, + sizeof(*Adapter), + 0, + HighestAcceptableAddress + ); + + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_DISPLAY(("ERROR: NdisAllocateMemory(Size=%d) failed (Status=%X)\n", + sizeof(*Adapter), Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + MiniportAdapterHandle, + NDIS_ERROR_CODE_OUT_OF_RESOURCES, + 3, + Status, + __FILEID__, + __LINE__ + ); + return NDIS_STATUS_FAILURE; + } + + /* + // Init the adapter structure values to NULL. + */ + NdisZeroMemory (Adapter, sizeof(*Adapter)); + + /* + // Assign a unique ID to this adapter instance. + */ + Adapter->InstanceNumber = ++HtDsuAdapterCount; + + /* + // We use the adapter id number in debug messages to help when debugging + // with multiple adapters. + */ +#if DBG + Adapter->DbgID[0] = (0x0F & HtDsuAdapterCount) + '0'; + Adapter->DbgID[1] = 0; + Adapter->DbgFlags = DbgFlags; +#endif + + DBG_DISPLAY(("HTDSU41(Adap=%08Xh,Ram=%05lXh,RamSiz=%04Xh,BufSiz=%04Xh,IRQ=%d)\n", + Adapter, RamBaseAddress, HTDSU_MEMORY_SIZE, + sizeof(HTDSU_BUFFER), InterruptNumber)); + + /* + // Make sure the adapter memory structure is sized properly. + */ + ASSERT(sizeof(HTDSU_BUFFER) == 2016); + ASSERT(HTDSU_MEMORY_SIZE == 4096); + + /* + // Save the config parameters in the adapter structure. + */ + Adapter->MiniportAdapterHandle = MiniportAdapterHandle; + Adapter->InterruptNumber = InterruptNumber; + Adapter->LineType = LineType; + Adapter->LineRate = LineRate; + Adapter->MemorySize = HTDSU_MEMORY_SIZE; + NdisSetPhysicalAddressLow(Adapter->PhysicalAddress, RamBaseAddress); + NdisSetPhysicalAddressHigh(Adapter->PhysicalAddress, 0); + + /* + // Construct the "MediaType\0DeviceName" string for use by TAPI. + */ + strcpy(Adapter->ProviderInfo, MediaType.Buffer); + strcpy(Adapter->ProviderInfo + MediaType.Length + 1, DeviceName.Buffer); + DBG_NOTICE(Adapter, ("Media=%s Device=%s\n", + Adapter->ProviderInfo, + &Adapter->ProviderInfo[MediaType.Length + 1] + )); + Adapter->ProviderInfoSize = MediaType.Length + 1 + DeviceName.Length + 1; + + /* + // Now it's time to initialize the hardware resources. + */ + Status = HtDsuRegisterAdapter(Adapter, &AddressList); + + if (Status != NDIS_STATUS_SUCCESS) + { + HtDsuHalt(Adapter); + } + + DBG_DISPLAY(("RETURN: Status=%Xh\n",Status)); + + return Status; +} + + +NDIS_STATUS +HtDsuRegisterAdapter( + IN PHTDSU_ADAPTER Adapter, + IN PSTRING AddressList + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This function is called when a new adapter is being registered. It + initializes the adapter information structure, allocate any resources + needed by the adapter/driver, registers with the wrapper, and initializes + the physical adapter. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + AddressList _ This is a list of MULTI_SZ strings which are to be assigned + to each link for use by TAPI HtTapiGetAddressCaps. + +Return Values: + + NDIS_STATUS_ADAPTER_NOT_FOUND + NDIS_STATUS_FAILURE + NDIS_STATUS_NOT_ACCEPTED + NDIS_STATUS_OPEN_ERROR + NDIS_STATUS_RESOURCES + NDIS_STATUS_SUCCESS + NDIS_STATUS_UNSUPPORTED_MEDIA + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuRegisterAdapter") + + /* + // Holds the status result returned from an NDIS function call. + */ + NDIS_STATUS Status; + + DBG_ENTER(Adapter); + + /* + // Initialize the WAN information structure to match the capabilities of + // the adapter. + */ + Adapter->WanInfo.MaxFrameSize = HTDSU_MAX_FRAME_SIZE; + Adapter->WanInfo.MaxTransmit = HTDSU_MAX_TRANSMITS; + + /* + // Since we copy the packets to/from adapter RAM, no padding information is + // needed in the WAN packets we get. We can just use adapter RAM as needed. + */ + Adapter->WanInfo.HeaderPadding = 0; + Adapter->WanInfo.TailPadding = 0; + + /* + // This value indicates how many point to point connections are allowed + // per WAN link. Currently, the WAN wrapper only supports 1 line per link. + */ + Adapter->WanInfo.Endpoints = 1; + + /* + // Transmits and received are copied to/from adapter RAM so cached memory + // can be used for packet allocation and we don't really care if it's + // physically contiguous or not, as long as it's virtually contiguous. + */ + Adapter->WanInfo.MemoryFlags = 0; + Adapter->WanInfo.HighestAcceptableAddress = HighestAcceptableAddress; + + /* + // We only support point to point framing, and we don't need to see the + // address or control fields. The TAPI_PROVIDER bit is set to indicate + // that we can accept the TAPI OID requests. + */ + Adapter->WanInfo.FramingBits = PPP_FRAMING | + PPP_COMPRESS_ADDRESS_CONTROL | + PPP_COMPRESS_PROTOCOL_FIELD | + TAPI_PROVIDER; + /* + // This value is ignored by this driver, but its default behavior is such + // that all these control bytes would appear to be handled transparently. + */ + Adapter->WanInfo.DesiredACCM = 0; + + /* + // Inform the wrapper of the physical attributes of this adapter. + // This must be called before any NdisMRegister functions! + // This call also associates the MiniportAdapterHandle with this Adapter. + */ + NdisMSetAttributes( + Adapter->MiniportAdapterHandle, + (NDIS_HANDLE)Adapter, + FALSE, // Not a BusMaster + NdisInterfaceIsa + ); + + /* + // Map the adapter's physical location into the system address space. + */ + Status = NdisMMapIoSpace( + &Adapter->VirtualAddress, + Adapter->MiniportAdapterHandle, + Adapter->PhysicalAddress, + Adapter->MemorySize + ); + DBG_NOTICE(Adapter, ("NdisMMapIoSpace(\n" + "VirtualAddress =%Xh\n" + "MiniportAdapterHandle=%Xh\n" + "PhysicalAddress =%X:%Xh\n" + "MemorySize =%Xh\n", + Adapter->VirtualAddress, + Adapter->MiniportAdapterHandle, + Adapter->PhysicalAddress, + Adapter->MemorySize + )); + + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_ERROR(Adapter,("NdisMMapIoSpace failed (status=%Xh)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + Adapter->MiniportAdapterHandle, + NDIS_ERROR_CODE_OUT_OF_RESOURCES, + 3, + Status, + __FILEID__, + __LINE__ + ); + goto EarlyOut; + } + + Adapter->AdapterRam = (PHTDSU_REGISTERS) Adapter->VirtualAddress; + + /* + // This is how we protect the driver from being re-entered when + // it's not safe to do so. Such as on a timer thread. Normally, + // the wrapper provides protection from re-entrancy, so SpinLocks + // are not needed. However, if your adapter requires asynchronous + // timer support routines, you will have to provide your own + // synchronization. + */ + NdisAllocateSpinLock(&Adapter->Lock); + + /* + // Set both the transmit busy and transmit idle lists to empty. + */ + InitializeListHead(&Adapter->TransmitIdleList); + InitializeListHead(&Adapter->TransmitBusyList); + + /* + // Initialize the interrupt - it can be disabled, but cannot be shared. + */ + Status = NdisMRegisterInterrupt( + &Adapter->Interrupt, + Adapter->MiniportAdapterHandle, + Adapter->InterruptNumber, + Adapter->InterruptNumber, + FALSE, /* We don't need a call to the ISR */ + FALSE, /* Interrupt is not sharable */ + NdisInterruptLatched + ); + + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_ERROR(Adapter,("NdisMRegisterInterrupt failed (status=%Xh)\n",Status)); + /* + // Log error message and exit. + */ + NdisWriteErrorLogEntry( + Adapter->MiniportAdapterHandle, + NDIS_ERROR_CODE_INTERRUPT_CONNECT, + 3, + Status, + __FILEID__, + __LINE__ + ); + goto EarlyOut; + } + + /* + // Try to initialize the adapter hardware. + */ +#if DBG + Status = CardInitialize(Adapter, + (BOOLEAN) ((Adapter->DbgFlags & DBG_HWTEST_ON) ? + TRUE : FALSE)); +#else + Status = CardInitialize(Adapter, FALSE); +#endif + + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_ERROR(Adapter,("CardInitialize failed (status=%Xh)\n",Status)); + /* + // Error message was already logged. + */ + goto EarlyOut; + } + + /* + // Initialize the adapter link structures. + */ + LinkInitialize(Adapter, AddressList); + +#ifdef USE_LEASED_LINE + if (Adapter->LineType == HTDSU_LINEMODE_LEASED) + { + /* + // Go ahead and allocate the lines and indicate them as up so we can + // work with leased line mode. + */ + PHTDSU_LINK Link; + + if (CardStatusOnLine(Adapter, HTDSU_CMD_LINE1)) + { + Link = LinkAllocate(Adapter, NULL, HTDSU_LINE1_ID); + LinkLineUp(Link); + } + if ((Adapter->NumLineDevs == HTDSU_NUM_LINKS) && + CardStatusOnLine(Adapter, HTDSU_CMD_LINE2)) + { + Link = LinkAllocate(Adapter, NULL, HTDSU_LINE2_ID); + LinkLineUp(Link); + } + } +#endif // USE_LEASED_LINE + +EarlyOut: + + DBG_LEAVE(Adapter); + + return Status; +} + + +VOID +HtDsuHalt( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportHalt request is used to halt the adapter such that it is + no longer functioning. The Miniport driver should stop the adapter + and deregister all of its resources before returning from this routine. + + It is not necessary for the Miniport to complete all outstanding + requests and no other requests will be submitted to the Miniport + until the operation is completed. + + Interrupts are enabled during the call to this routine. + +Parameters: + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuHalt") + + /* + // We use this message to make sure TAPI is cleaned up. + */ + NDIS_TAPI_PROVIDER_SHUTDOWN TapiShutDown; + + DBG_ENTER(Adapter); + + /* + // Make sure all the lines are hungup and indicated. + // This should already be the case, but let's be sure. + */ + TapiShutDown.ulRequestID = OID_TAPI_PROVIDER_SHUTDOWN; + HtTapiProviderShutdown(Adapter, &TapiShutDown); + + /* + // Disconnect the interrupt line. + */ + if (*(PULONG)&(Adapter->Interrupt)) + { + NdisMDeregisterInterrupt(&Adapter->Interrupt); + } + + /* + // Unmap the adapter memory from the system. + */ + if (Adapter->VirtualAddress != NULL) + { + NdisMUnmapIoSpace( + Adapter->MiniportAdapterHandle, + Adapter->VirtualAddress, + Adapter->MemorySize + ); + } + + /* + // Free the lock we aquired at startup. + */ + if (*(PULONG)&(Adapter->Lock)) + { + // FIXME - the latest version of NDIS does not define NdisFreeSpinLock + // NdisFreeSpinLock(&Adapter->Lock); + } + + DBG_LEAVE(Adapter); + + /* + // Free adapter instance. + */ + --HtDsuAdapterCount; + NdisFreeMemory(Adapter, sizeof(*Adapter), 0); +} + +#ifdef RECONFIGURE_SUPPORTED + + +NDIS_STATUS +HtDsuReconfigure( + OUT PNDIS_STATUS OpenErrorStatus, + IN PHTDSU_ADAPTER Adapter, + IN NDIS_HANDLE WrapperConfigurationContext + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine is called to have the Miniport reconfigure the adapter + to the new parameters available via the NDIS configuration routines. + Used to support plug and play adapters and software configurable + adapters, which may have the parameters changed during runtime. If + the Miniport driver does not support dynamic reconfiguration, then + the entry for W_RECONFIGURE_HANDLER in the NDIS_WIDGET_CHARACTERISTICS + should be NULL. + + No other request will be outstanding on the Miniport when this routine + is called. No other request will be submitted to the Miniport until + the operation is completed. + + The status value NDIS_STATUS_OPEN_ERROR has a special meaning. It + indicates that the OpenErrorStatus parameter has returned a valid + status which the wrapper can examine to obtain more information about + the error. + + This routine is called with interrupts enabled, and a call to MiniportISR + will occur if the adapter generates any interrupts. As long as this + routine is executing MiniportDisableInterrupt and MiniportEnableInterrupt + will not be called, so it is the responsibility of the Miniport driver + to acknowledge and clear any interrupts generated. + +Parameters: + + OpenErrorStatus _ Returns more information about the reason for the + failure. Currently, the only values defined match + those specified as Open Error Codes in Appendix B + of the IBM Local Area Network Technical Reference. + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + + WrapperConfigurationContext _ The handle to use for calls to + NdisOpenConfiguration, and the routines + in section 4 of this document. + +Return Values: + + NDIS_STATUS_FAILURE + NDIS_STATUS_NOT_ACCEPTED + NDIS_STATUS_SUCCESS + +---------------------------------------------------------------------------*/ + +{ + return (NDIS_STATUS_NOT_ACCEPTED); +} + +#endif // RECONFIGURE_SUPPORTED + + +NDIS_STATUS +HtDsuReset( + OUT PBOOLEAN AddressingReset, + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportReset request instructs the Miniport driver to issue a + hardware reset to the network adapter. The Miniport driver also + resets its software state. + + The MiniportReset request may also reset the parameters of the adapter. + If a hardware reset of the adapter resets the current station address + to a value other than what it is currently configured to, the Miniport + driver automatically restores the current station address following the + reset. Any multicast or functional addressing masks reset by the + hardware do not have to be reprogrammed by the Miniport. + NOTE: This is change from the NDIS 3.0 driver specification. If the + multicast or functional addressing information, the packet filter, the + lookahead size, and so on, needs to be restored, the Miniport indicates + this with setting the flag AddressingReset to TRUE. + + It is not necessary for the Miniport to complete all outstanding requests + and no other requests will be submitted to the Miniport until the + operation is completed. Also, the Miniport does not have to signal + the beginning and ending of the reset with NdisMIndicateStatus. + NOTE: These are different than the NDIS 3.0 driver specification. + + The Miniport driver must complete the original request, if the orginal + call to MiniportReset return NDIS_STATUS_PENDING, by calling + NdisMResetComplete. + + If the underlying hardware does not provide a reset function under + software control, then this request completes abnormally with + NDIS_STATUS_NOT_RESETTABLE. If the underlying hardware attempts a + reset and finds recoverable errors, the request completes successfully + with NDIS_STATUS_SOFT_ERRORS. If the underlying hardware resets and, + in the process, finds nonrecoverable errors, the request completes + successfully with the status NDIS_STATUS_HARD_ERRORS. If the + underlying hardware reset is accomplished without any errors, + the request completes successfully with the status NDIS_STATUS_SUCCESS. + + Interrupts are in any state during this call. + +Parameters: + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + + AddressingReset _ The Miniport indicates if the wrapper needs to call + MiniportSetInformation to restore the addressing + information to the current values by setting this + value to TRUE. + +Return Values: + + NDIS_STATUS_HARD_ERRORS + NDIS_STATUS_NOT_ACCEPTED + NDIS_STATUS_NOT_RESETTABLE + NDIS_STATUS_PENDING + NDIS_STATUS_SOFT_ERRORS + NDIS_STATUS_SUCCESS + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuReset") + + /* + // Holds the status result returned from an NDIS function call. + */ + NDIS_STATUS Status; + + DBG_ENTER(Adapter); + DBG_BREAK(Adapter); + + if (Adapter->NeedReset) + { + NdisAcquireSpinLock(&Adapter->Lock); + + /* + // Make sure TAPI is aware of the state change so it can do the + // right things. + */ + HtTapiResetHandler(Adapter); + + /* + // Attempt to issue a software reset on the adapter. + // It will only fail if the hardware is hung forever. + */ + Adapter->NeedReset = FALSE; + Status = CardInitialize(Adapter, FALSE); + + /* + // If anything gose wrong here, it's very likely an unrecoverable + // hardware failure. So we'll just shut this thing down for good. + */ + if (Status != NDIS_STATUS_SUCCESS) + { + DBG_ERROR(Adapter,("RESET Failed\n")); + Status = NDIS_STATUS_HARD_ERRORS; + } + else + { + /* + // If there were lines open, we must reset them back to + // LINECALLSTATE_IDLE, and configure them for use. + */ + if (Adapter->NumOpens) + { + if (Adapter->NumOpens == 1) + { + CardLineConfig(Adapter, HTDSU_CMD_LINE1); + HtTapiCallStateHandler(Adapter, + GET_LINK_FROM_LINKINDEX(Adapter, 0), + LINECALLSTATE_IDLE, + 0); + Adapter->InterruptEnableFlag |= HTDSU_INTR_ALL_LINE1; + } + if (Adapter->NumOpens == 2) + { + CardLineConfig(Adapter, HTDSU_CMD_LINE2); + HtTapiCallStateHandler(Adapter, + GET_LINK_FROM_LINKINDEX(Adapter, 1), + LINECALLSTATE_IDLE, + 0); + Adapter->InterruptEnableFlag |= HTDSU_INTR_ALL_LINE2; + } + CardEnableInterrupt(Adapter); + } + + DBG_WARNING(Adapter,("RESET Complete\n")); + *AddressingReset = TRUE; + } + + NdisReleaseSpinLock(&Adapter->Lock); + } + else + { + DBG_WARNING(Adapter, ("RESET Not Needed\n")); + } + + DBG_LEAVE(Adapter); + + return (Status); +} diff --git a/private/ntos/ndis/htdsu/htdsu.h b/private/ntos/ndis/htdsu/htdsu.h new file mode 100644 index 000000000..d0fa6f175 --- /dev/null +++ b/private/ntos/ndis/htdsu/htdsu.h @@ -0,0 +1,931 @@ +/***************************************************************************\ +|* 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. *| +\***************************************************************************/ + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Module Name: + + htdsu.h + +Abstract: + + This module defines the software structures and values used to support + the NDIS Minport driver on the HT DSU41 controller. It's a good place + to look when your trying to figure out how the driver structures are + related to each other. + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Include this file at the top of each module in the Miniport driver. + +Revision History: + +---------------------------------------------------------------------------*/ + +#ifndef _HTDSU_H +#define _HTDSU_H + +/* +// NDIS_MINIPORT_DRIVER must be defined before the NDIS include files. +// Normally, it is defined on the command line by setting the C_DEFINES +// variable in the sources build file. +*/ +#include +#include +#include // Force packing on variable length structures +# include +#include +#include + +/* +// Include everything here so the driver modules can just include this +// file and get all they need. +*/ +#include "debug.h" +#include "card.h" +#include "keywords.h" + +/* +// This constant is the maximum NdisStallExecution time allowed to be used +// in an NDIS driver. If you need longer delays, you must wrap the call +// in a loop. +*/ +#define _100_MICROSECONDS 100 + +/* +// The link speeds we support. +*/ +#define _64KBPS 64000 +#define _56KBPS 57600 + +/* +// How many logical links does this driver support. Actually, this driver +// defines logical links to be 1:1 with physical links. You are free to +// model them however is appropriate for your adapter. +*/ +#define HTDSU_NUM_LINKS 2 + +/* +// In this driver, there is only one TAPI line device per link structure. +*/ +#define HTDSU_TAPI_NUM_LINES HTDSU_NUM_LINKS + +/* +// There is only one TAPI address ID per line device (zero based). +*/ +#define HTDSU_TAPI_NUM_ADDRESSES 1 +#define HTDSU_TAPI_ADDRESSID 0 + +/* +// There is only one TAPI call per address/line instance. +*/ +#define HTDSU_TAPI_NUM_CALLS 1 + +/* +// This version number is used by the NDIS_TAPI_NEGOTIATE_EXT_VERSION request. +// It is not used by this driver or the current NDISTAPI release. +*/ +#define HTDSU_TAPI_EXT_VERSION 0x00010000 + +/* +// The line mode can be leased or dial-up. In leased mode we can present the +// WAN wrapper with a LINE_UP indication so it can use the connection without +// the TAPI interface. In dialup mode, we need to present a TAPI service +// provider interface so RAS or something else can select the phone number. +// Currently, this driver only supports a single line adapter, but it has +// been written to allow the addition of a second line if the adapter becomes +// available. +*/ +typedef enum _HTDSU_LINE_MODE +{ + HTDSU_LINEMODE_DIALUP, + HTDSU_LINEMODE_LEASED + +} HTDSU_LINE_MODE; + +/* +// This structure contains all the link information maintained by the +// Miniport driver. It encompasses both the TAPI and WAN connections. +*/ +typedef struct _HTDSU_LINK +{ + /* 000 + // Pointer back to the Adapter data structure so we can get at it + // when passed a pointer to this structure in NdisMWanSend(). + */ + struct _HTDSU_ADAPTER *Adapter; + + /* 004 + // This is used to select which card channel the link is associated with. + */ + USHORT CardLine; + + /* 006 + // This is a zero based index used to assign TAPI device ID to the + // link based on TAPI DeviceIdBase assigned to this driver. + */ + USHORT LinkIndex; + + /* 008 + // Remember what mode the line was set to. + */ + HTDSU_LINE_MODE LineMode; + + /* 00C + // The WAN wrapper supplied handle to be used on Miniport calls + // such as NdisMWanIndicateReceive(). + */ + NDIS_HANDLE NdisLinkContext; + + /* 010 + // The Connection wrapper supplied handle for use when indicating + // TAPI LINE_EVENT's. + */ + HTAPI_LINE htLine; + + /* 014 + // The Connection wrapper supplied handle for use when indicating + // TAPI LINECALLSTATE events. + */ + HTAPI_CALL htCall; + + /* 018 + // The current TAPI LINEDEVSTATE of the associated with the link. + */ + ULONG DevState; // Current state + ULONG DevStatesCaps; // Events currently supported + ULONG DevStatesMask; // Events currently enabled + + /* 024 + // The current TAPI LINEADDRESSSTATE of the associated with the link. + */ + ULONG AddressState; // Current state + ULONG AddressStatesCaps; // Events currently supported + ULONG AddressStatesMask; // Events currently enabled + + /* 030 + // The current TAPI LINECALLSTATE of the associated with the link. + */ + ULONG CallState; // Current state + ULONG CallStatesCaps; // Events currently supported + ULONG CallStatesMask; // Events currently enabled + + /* 03C + // The current TAPI media mode(s) supported by the card. + */ + ULONG MediaMode; // Current state + ULONG MediaModesCaps; // Events currently supported + ULONG MediaModesMask; // Events currently enabled + + /* 048 + // TAPI line address is assigned during installation and saved in the + // registry. It is read from the registry and saved here at init time. + */ + CHAR LineAddress[0x14]; + + /* 05C + // The speed provided by the link in bits per second. This value is + // passed up by the Miniport during the LINE_UP indication. + */ + ULONG LinkSpeed; + + /* 060 + // The quality of service provided by the link. This value is passed + // up by the Miniport during the LINE_UP indication. + */ + NDIS_WAN_QUALITY Quality; + + /* 064 + // The number of rings detected in the current ring sequence. + */ + USHORT RingCount; + + /* 066 + // The number of packets that should be sent before pausing to wait + // for an acknowledgement. This value is passed up by the Miniport + // during the LINE_UP indication. + */ + USHORT SendWindow; + + /* 068 + // The number of packets currently queued for transmission on this link. + */ + ULONG NumTxQueued; + + /* 06C + // Set TRUE if link is being closed. + */ + BOOLEAN Closing; + + /* 06D + // Set TRUE if call is being closed. + */ + BOOLEAN CallClosing; + + /* 070 + // The current settings associated with this link as passed in via + // the OID_WAN_SET_LINK_INFO request. + */ + NDIS_WAN_SET_LINK_INFO WanLinkInfo; + + /* + // This timer is used to keep track of the call state when a call is + // coming in or going out. + */ + NDIS_MINIPORT_TIMER CallTimer; + +} HTDSU_LINK, *PHTDSU_LINK; + +/* +// Use this macro to determine if a link structure pointer is really valid. +*/ +#define IS_VALID_LINK(Adapter, Link) \ + (Link && Link->Adapter == Adapter) + +/* +// Use this macro to get a pointer to a link structure from a CardLine ID. +*/ +#define GET_LINK_FROM_CARDLINE(Adapter, CardLine) \ + &(Adapter->WanLinkArray[CardLine-HTDSU_CMD_LINE1]) + +/* +// Use this macro to get a pointer to a link structure from a LinkIndex. +*/ +#define GET_LINK_FROM_LINKINDEX(Adapter, LinkIndex) \ + &(Adapter->WanLinkArray[LinkIndex]) + +/* +// Use this macro to get a pointer to a link structure from a TAPI DeviceID. +*/ +#define GET_LINK_FROM_DEVICEID(Adapter, ulDeviceID) \ + &(Adapter->WanLinkArray[ulDeviceID - Adapter->DeviceIdBase]); \ + ASSERT(ulDeviceID >= Adapter->DeviceIdBase); \ + ASSERT(ulDeviceID < Adapter->DeviceIdBase+Adapter->NumLineDevs) + +#define GET_DEVICEID_FROM_LINK(Adapter, Link) \ + (Link->LinkIndex + Adapter->DeviceIdBase) + +/* +// Use this macro to get a pointer to a link structure from a TAPI line handle. +*/ +#define GET_LINK_FROM_HDLINE(Adapter, hdLine) \ + (PHTDSU_LINK) \ + (((PHTDSU_LINK) (hdLine) == &(Adapter->WanLinkArray[0])) ? (hdLine) : \ + ((PHTDSU_LINK) (hdLine) == &(Adapter->WanLinkArray[1])) ? (hdLine) : 0) + +/* +// Use this macro to get a pointer to a link structure from a TAPI call handle. +*/ +#define GET_LINK_FROM_HDCALL(Adapter, hdCall) \ + (PHTDSU_LINK) \ + (((PHTDSU_LINK) (hdCall) == &(Adapter->WanLinkArray[0])) ? (hdCall) : \ + ((PHTDSU_LINK) (hdCall) == &(Adapter->WanLinkArray[1])) ? (hdCall) : 0) + +/* +// This structure contains all the information about a single adapter +// instance this Miniport driver is controlling. +*/ +typedef struct _HTDSU_ADAPTER +{ +#if DBG + /* 000 + // Debug flags control how much debug is displayed in the checked version. + */ + ULONG DbgFlags; + UCHAR DbgID[4]; +#endif + + /* 008 + // This is the handle given by the wrapper for calling ndis + // functions. + */ + NDIS_HANDLE MiniportAdapterHandle; + + /* 00C + // Spinlock to protect fields in this structure.. + */ + NDIS_SPIN_LOCK Lock; + + /* 014 + // Lets us know when a transmit is in progress. + */ + BOOLEAN TransmitInProgress; + + /* 018 + // Packets waiting to be sent when the controller is available. + */ + LIST_ENTRY TransmitIdleList; + + /* 020 + // Packets currently submitted to the controller waiting for completion. + */ + LIST_ENTRY TransmitBusyList; + + /* 028 + // Physical address where adapter memory is jumpered to. + */ + NDIS_PHYSICAL_ADDRESS PhysicalAddress; + + /* 030 + // System address where the adapter memory is mapped to. + */ + PVOID VirtualAddress; + + /* 034 + // Overlay the adapter memory structure on the virtual address + // where we've mapped it into system I/O (memory) space. + */ + PHTDSU_REGISTERS AdapterRam; + + /* 038 + // How much memory is on the adapter. + */ + USHORT MemorySize; + + /* 03A + // Currently enabled interrupts + */ + USHORT InterruptEnableFlag; + + /* 03C + // Currently pending interrupts + */ + USHORT InterruptStatusFlag; + + /* 03E + // Interrupt number this adapter is using. + */ + CHAR InterruptNumber; + + /* 03F + // A unique instance number to be used to generate a unique + // WAN permanent address (not really permanent, but it's unique). + */ + CHAR InstanceNumber; + + /* 040 + // Set TRUE if something goes terribly wrong with the hardware. + */ + BOOLEAN NeedReset; + + /* 041 + // Set TRUE when the DPC is entered, and reset to FALSE when it leaves. + */ + BOOLEAN InTheDpcHandler; + + /* 042 + // Specifies whether line is to be treated as a leased WAN line + // or a dialup TAPI line. + */ + USHORT LineType; + + /* 044 + // The DSU41 has only one line, DSU42 has two. + */ + UINT NumLineDevs; + + /* 048 + // The ulDeviceIDBase field passed in the PROVIDER_INIT request informs a miniport of the zero-based + // starting index that the Connection Wrapper will use when referring to a single adapter’s line devices by + // index. For example, if a ulDeviceIDBase of two is specified and the adapter supports three line devices, + // then the Connection Wrapper will use the identifiers two, three, and four to refer to the adapter’s three + // devices. + */ + ULONG DeviceIdBase; + + /* 04C + // The number of line open calls currently on this adapter. + */ + UINT NumOpens; + + /* 050 + // NDIS interrupt control structure. + */ + NDIS_MINIPORT_INTERRUPT Interrupt; + + /* + // Specifies whether what speed the line is to be configured to. + */ + USHORT LineRate; + + /* + // WAN info structure. + */ + NDIS_WAN_INFO WanInfo; + + /* + // This holds the TAPI ProviderInfo string returned from HtTapiGetDevCaps + // This is two null terminated strings packed end to end. + */ + CHAR ProviderInfo[48]; // This size is the max allowed by RAS + USHORT ProviderInfoSize; // Size in bytes of both strings. + + /* + // WAN/TAPI link managment object for each connection we support. + */ + HTDSU_LINK WanLinkArray[HTDSU_NUM_LINKS]; + + /* + // This contains the name of our TAPI configuration DLL which is read + // from the registry during initialization. The name of the DLL and + // its path will be saved in the registry during installation. + */ + CHAR ConfigDLLName[128]; + +} HTDSU_ADAPTER, * PHTDSU_ADAPTER; + + +/*************************************************************************** +// These routines are defined in htdsu.c +*/ +NTSTATUS +DriverEntry( + IN PDRIVER_OBJECT DriverObject, + IN PUNICODE_STRING RegistryPath + ); + +NDIS_STATUS +HtDsuInitialize( + OUT PNDIS_STATUS OpenErrorStatus, + OUT PUINT SelectedMediumIndex, + IN PNDIS_MEDIUM MediumArray, + IN UINT MediumArraySize, + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE WrapperConfigurationContext + ); + +NDIS_STATUS +HtDsuRegisterAdapter( + IN PHTDSU_ADAPTER Adapter, + IN PSTRING AddressList + ); + +VOID +HtDsuHalt( + IN PHTDSU_ADAPTER Adapter + ); + +NDIS_STATUS +HtDsuReconfigure( + OUT PNDIS_STATUS OpenErrorStatus, + IN PHTDSU_ADAPTER Adapter, + IN NDIS_HANDLE WrapperConfigurationContext + ); + +NDIS_STATUS +HtDsuReset( + OUT PBOOLEAN AddressingReset, + IN PHTDSU_ADAPTER Adapter + ); + +/*************************************************************************** +// These routines are defined in interrup.c +*/ +extern BOOLEAN +HtDsuCheckForHang( + IN PHTDSU_ADAPTER Adapter + ); + +extern VOID +HtDsuDisableInterrupt( + IN PHTDSU_ADAPTER Adapter + ); + +extern VOID +HtDsuEnableInterrupt( + IN PHTDSU_ADAPTER Adapter + ); + +extern VOID +HtDsuISR( + OUT PBOOLEAN InterruptRecognized, + OUT PBOOLEAN QueueMiniportHandleInterrupt, + IN PHTDSU_ADAPTER Adapter + ); + +VOID +HtDsuHandleInterrupt( + IN PHTDSU_ADAPTER Adapter + ); + +VOID +HtDsuPollAdapter( + IN PVOID SystemSpecific1, + IN PHTDSU_ADAPTER Adapter, + IN PVOID SystemSpecific2, + IN PVOID SystemSpecific3 + ); + +/*************************************************************************** +// These routines are defined in receive.c +*/ +VOID +HtDsuReceivePacket( + IN PHTDSU_ADAPTER Adapter + ); + +/*************************************************************************** +// These routines are defined in request.c +*/ +NDIS_STATUS +HtDsuQueryInformation( + IN PHTDSU_ADAPTER Adapter, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesWritten, + OUT PULONG BytesNeeded + ); + +NDIS_STATUS +HtDsuSetInformation( + IN PHTDSU_ADAPTER Adapter, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesRead, + OUT PULONG BytesNeeded + ); + +/*************************************************************************** +// These routines are defined in send.c +*/ +NDIS_STATUS +HtDsuWanSend( + IN NDIS_HANDLE MacBindingHandle, + IN PHTDSU_LINK Link, + IN PNDIS_WAN_PACKET Packet + ); + +VOID +HtDsuTransmitComplete( + IN PHTDSU_ADAPTER Adapter + ); + +/*************************************************************************** +// These routines are defined in card.c +*/ +NDIS_STATUS +CardIdentify( + IN PHTDSU_ADAPTER Adapter + ); + +NDIS_STATUS +CardDoCommand( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine, + IN USHORT CommandValue + ); + +NDIS_STATUS +CardInitialize( + IN PHTDSU_ADAPTER Adapter, + IN BOOLEAN PerformSelfTest + ); + +VOID +CardLineConfig( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine + ); + +VOID +CardLineDisconnect( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine + ); + +VOID +CardPrepareTransmit( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine, + IN USHORT Length + ); + +VOID +CardGetReceiveInfo( + IN PHTDSU_ADAPTER Adapter, + OUT PUSHORT CardLine, + OUT PUSHORT BytesReceived, + OUT PUSHORT Status + ); + +VOID +CardDialNumber( + IN PHTDSU_ADAPTER Adapter, + IN USHORT CardLine, + IN PUCHAR DialString, + IN ULONG DialStringLength + ); + +/*************************************************************************** +// These routines are defined in link.c +*/ +VOID +LinkInitialize( + IN PHTDSU_ADAPTER Adapter, + IN PSTRING AddressList + ); + +PHTDSU_LINK +LinkAllocate( + IN PHTDSU_ADAPTER Adapter, + IN HTAPI_LINE htLine, + IN USHORT LinkIndex + ); + +VOID +LinkRelease( + IN PHTDSU_LINK Link + ); + +VOID +LinkLineUp( + IN PHTDSU_LINK Link + ); + +VOID +LinkLineDown( + IN PHTDSU_LINK Link + ); + +VOID +LinkLineError( + IN PHTDSU_LINK Link, + IN ULONG Errors + ); + +/*************************************************************************** +// These routines are defined in tapi.c +*/ +NDIS_STATUS +HtTapiQueryInformation( + IN PHTDSU_ADAPTER Adapter, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesWritten, + OUT PULONG BytesNeeded + ); + +NDIS_STATUS +HtTapiSetInformation( + IN PHTDSU_ADAPTER Adapter, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesRead, + OUT PULONG BytesNeeded + ); + +NDIS_STATUS +HtTapiConfigDialog( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_CONFIG_DIALOG Request + ); + +NDIS_STATUS +HtTapiDevSpecific( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_DEV_SPECIFIC Request + ); + +NDIS_STATUS +HtTapiGetAddressCaps( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_ADDRESS_CAPS Request + ); + +NDIS_STATUS +HtTapiGetAddressID( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_ADDRESS_ID Request + ); + +NDIS_STATUS +HtTapiGetAddressStatus( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_ADDRESS_STATUS Request + ); + +NDIS_STATUS +HtTapiGetCallAddressID( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_CALL_ADDRESS_ID Request + ); + +NDIS_STATUS +HtTapiGetCallInfo( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_CALL_INFO Request + ); + +NDIS_STATUS +HtTapiGetCallStatus( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_CALL_STATUS Request + ); + +NDIS_STATUS +HtTapiGetDevCaps( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_DEV_CAPS Request + ); + +NDIS_STATUS +HtTapiGetDevConfig( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_DEV_CONFIG Request + ); + +NDIS_STATUS +HtTapiGetExtensionID( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_EXTENSION_ID Request + ); + +NDIS_STATUS +HtTapiGetID( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_ID Request + ); + +NDIS_STATUS +HtTapiGetLineDevStatus( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_GET_LINE_DEV_STATUS Request + ); + +NDIS_STATUS +HtTapiMakeCall( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_MAKE_CALL Request + ); + +NDIS_STATUS +HtTapiNegotiateExtVersion( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_NEGOTIATE_EXT_VERSION Request + ); + +NDIS_STATUS +HtTapiOpen( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_OPEN Request + ); + +NDIS_STATUS +HtTapiProviderInitialize( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_PROVIDER_INITIALIZE Request + ); + +NDIS_STATUS +HtTapiAccept( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_ACCEPT Request + ); + +NDIS_STATUS +HtTapiAnswer( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_ANSWER Request + ); + +NDIS_STATUS +HtTapiClose( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_CLOSE Request + ); + +NDIS_STATUS +HtTapiCloseCall( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_CLOSE_CALL Request + ); + +NDIS_STATUS +HtTapiConditionalMediaDetection( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION Request + ); + +NDIS_STATUS +HtTapiDial( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_DIAL Request + ); + +NDIS_STATUS +HtTapiDrop( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_DROP Request + ); + +NDIS_STATUS +HtTapiProviderShutdown( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_PROVIDER_SHUTDOWN Request + ); + +NDIS_STATUS +HtTapiSecureCall( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SECURE_CALL Request + ); + +NDIS_STATUS +HtTapiSelectExtVersion( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SELECT_EXT_VERSION Request + ); + +NDIS_STATUS +HtTapiSendUserUserInfo( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SEND_USER_USER_INFO Request + ); + +NDIS_STATUS +HtTapiSetAppSpecific( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SET_APP_SPECIFIC Request + ); + +NDIS_STATUS +HtTapiSetCallParams( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SET_CALL_PARAMS Request + ); + +NDIS_STATUS +HtTapiSetDefaultMediaDetection( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION Request + ); + +NDIS_STATUS +HtTapiSetDevConfig( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SET_DEV_CONFIG Request + ); + +NDIS_STATUS +HtTapiSetMediaMode( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SET_MEDIA_MODE Request + ); + +NDIS_STATUS +HtTapiSetStatusMessages( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_TAPI_SET_STATUS_MESSAGES Request + ); + +VOID +HtTapiAddressStateHandler( + IN PHTDSU_ADAPTER Adapter, + IN PHTDSU_LINK Link, + IN ULONG AddressState + ); + +VOID +HtTapiCallStateHandler( + IN PHTDSU_ADAPTER Adapter, + IN PHTDSU_LINK Link, + IN ULONG CallState, + IN ULONG StateParam + ); + +VOID +HtTapiLineDevStateHandler( + IN PHTDSU_ADAPTER Adapter, + IN PHTDSU_LINK Link, + IN ULONG LineDevState + ); + +VOID +HtTapiResetHandler( + IN PHTDSU_ADAPTER Adapter + ); + +VOID +HtTapiCallTimerHandler( + IN PVOID SystemSpecific1, + IN PHTDSU_LINK Link, + IN PVOID SystemSpecific2, + IN PVOID SystemSpecific3 + ); + +#endif // _HTDSU_H + diff --git a/private/ntos/ndis/htdsu/htdsu.rc b/private/ntos/ndis/htdsu/htdsu.rc new file mode 100644 index 000000000..c18ad93fc --- /dev/null +++ b/private/ntos/ndis/htdsu/htdsu.rc @@ -0,0 +1,9 @@ +#include +#include + +#define VER_FILETYPE VFT_DRV +#define VER_FILESUBTYPE VFT2_DRV_NETWORK + +#include "version.h" +#include + diff --git a/private/ntos/ndis/htdsu/interrup.c b/private/ntos/ndis/htdsu/interrup.c new file mode 100644 index 000000000..fad79ce79 --- /dev/null +++ b/private/ntos/ndis/htdsu/interrup.c @@ -0,0 +1,656 @@ +/***************************************************************************\ +|* 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: + + interrup.c + +Abstract: + + This module contains the Miniport interrupt processing routines: + MiniportCheckForHang() + MiniportDisableInterrupt() + MiniportEnableInterrupt() + MiniportISR() + MiniportHandleInterrupt() + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 3 // Unique file ID for error logging + +#include "htdsu.h" + + +BOOLEAN +HtDsuCheckForHang( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportCheckForHang request is used by the wrapper to periodically + have the miniport check if the adapter appears hung. + + The Miniport driver should do nothing more than check the internal state + and return if the adapter is hung. The wrapper will then attempt to + recover the adapter by calling MiniportReset. + + This routine will be called once every two seconds. + + Interrupts will be in any state when called. + +Parameters: + + MiniportAdapterContext _ The handle returned from MiniportInitialize. + +Return Values: + + TRUE if the driver believes that the underlying hardware is hung, + FALSE otherwise. + +---------------------------------------------------------------------------*/ + +{ + return (Adapter->NeedReset); +} + + +VOID +HtDsuDisableInterrupt( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportDisableInterrupt request is used to disable the adapter + from generating any interrupts. Typically this is done by writing a + mask which disables the adapter from generating hardware interrupts. + + If the underlying hardware does not support enabling and disabling + interrupts, the Miniport driver will have to register a MiniportISR + with the wrapper, and the Miniport driver will have to acknowledge + and save the interrupt information from within the interrupt service + routine. + + This routine may be called any time interrupts are enabled. If the + underlying hardware is required to be in a certain state for this + routine to execute correctly, the Miniport driver must encapsulate + all portions of the driver which violate the state and which may be + called when interrupts are enabled, with a function and call the + function through the NdisMSynchronizeWithInterrupt service. + + Interrupts will be in any state when called. + +Parameters: + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuDisableInterrupt") + + /* + // Save the current interrupt status on the card. + */ + USHORT InterruptStatus = CardGetInterrupt(Adapter); + +// DBG_ENTER(Adapter); + + /* + // Disable the interrupt at the card after saving the current state + // of the InterruptStatus register -- which will be reset by the clear + // interrupt command. + */ + Adapter->InterruptStatusFlag |= InterruptStatus; + CardClearInterrupt(Adapter); + CardDisableInterrupt(Adapter); + + DBG_NOTICE(Adapter, ("IntrStatus=%Xh LineStatus=%Xh\n", + InterruptStatus, + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) + )); + +// DBG_LEAVE(Adapter); +} + + +VOID +HtDsuEnableInterrupt( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportEnableInterrupt request is used to enable the adapter for + generating any interrupts. Typically this is done by writing a mask + which will reenable adapter interrupts. + + If the underlying hardware does not support enabling and disabling + interrupts, the Miniport driver will have to register a MiniportISR + with the wrapper, and the Miniport driver will have to acknowledge + and save the interrupt information from within the interrupt service + routine. + + Interrupts will be in any state when called. + +Parameters: + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuEnableInterrupt") + + /* + // Save the current interrupt status on the card. + */ + USHORT InterruptStatus = CardGetInterrupt(Adapter); + +// DBG_ENTER(Adapter); + + CardEnableInterrupt(Adapter); + + DBG_NOTICE(Adapter, ("IntrStatus=%Xh LineStatus=%Xh\n", + InterruptStatus, + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) + )); + +// DBG_LEAVE(Adapter); +} + + + +VOID +HtDsuISR( + OUT PBOOLEAN InterruptRecognized, + OUT PBOOLEAN QueueMiniportHandleInterrupt, + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportISR request is called if the adapter generates an + interrupt when there is an outstanding call to MiniportInitialize + or to MiniportReconfigure, if the Miniport driver supports sharing + its interrupt line with another adapter, or if the Miniport driver + specifies that the routine must be called for every interrupt (See + NdisMRegisterInterrupt's RequestIsr and SharedInterrupt parameters). + + This routine runs immediately after an interrupt, at very high priority, + and is subject to all the limitations of the interrupt service routine + in the NDIS 3.0 specification. The driver should do as little work as + possible in this routine. It should return TRUE in the parameter + InterruptRecognized if it recognizes the interrupt as belonging to its + adapter, or FALSE otherwise. It should return TRUE in the parameter + QueueMiniportHandleInterrupt if it needs a call to MiniportHandleInterrupt + at a lower priority to complete the handling of the interrupt, or FALSE + otherwise. + + Note that a Dpc will not be queued if the Miniport is currently executing + in any of the following routines: MiniportHalt, MiniportInitialize, + MiniportReconfigure. + +Parameters: + + InterruptRecognized _ If the Miniport is sharing an interrupt line, it + should set this parameter to TRUE if the Miniport + driver recognizes that the interrupt came from the + adapter it is supporting. + + QueueMiniportHandleInterrupt _ If the Miniport driver is sharing an + interrupt line, it sets this parameter to + TRUE if the driver needs to have + MiniportHandleInterrupt called. + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuISR") + + /* + // Save the current interrupt status on the card. + */ + USHORT InterruptStatus; + + DBG_ENTER(Adapter); + + /* + // This routine should never be called after initialization since we + // support the Enable/Disable Interrupt routines. + */ + if (InterruptStatus = CardGetInterrupt(Adapter)) + { + /* + // The adapter prevents the failure case where additional status + // bits could be set between the time we read the InterruptStatus + // and it is reset by the clear interrupt command... + */ + CardClearInterrupt(Adapter); + Adapter->InterruptStatusFlag |= InterruptStatus; + + /* + // The card generated an interrupt, we need to service it only if we are + // interested in it. In either case it must be dismissed from the card. + */ + *InterruptRecognized = TRUE; + *QueueMiniportHandleInterrupt = TRUE; + } + else + { + /* + // It's not our interrupt, so we don't need to service anything. + */ + *InterruptRecognized = FALSE; + } + + DBG_NOTICE(Adapter, ("IntrStatus=%Xh LineStatus=%Xh\n", + InterruptStatus, + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1) + )); + + DBG_LEAVE(Adapter); +} + + +VOID +HtDsuHandleInterrupt( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportHandleInterrupt routine is called from within a wrapper + deferred processing routine, and is used to process the reason an + interrupt was generated. The Miniport driver should handle all + outstanding interrupts and start any new operations. + + Interrupts will be disabled during the call to this routine. + +Parameters: + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuHandleInterrupt") + + /* + // A pointer to our link information structure. + */ + PHTDSU_LINK Link; + + UINT TimeOut; + + NdisAcquireSpinLock(&Adapter->Lock); + Adapter->InTheDpcHandler = TRUE; + + DBG_ENTER(Adapter); + + /* + // Loop thru here until all the interrupts are handled. + // This should not be allowed to take more than a few mili-seconds. + // If it does, the checked kernel will trap, and you'll have to + // find a way to leave the DPC early and handle the rest during + // the next pass. + */ + while (Adapter->InterruptStatusFlag) + { + /******************************************************************** + // Do we have a packet waiting in the adapter? + */ + if (Adapter->InterruptStatusFlag & (HTDSU_INTR_RX_PACKET1 | + HTDSU_INTR_RX_PACKET2)) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_RX_PACKET\n")); + + Adapter->InterruptStatusFlag &= ~(HTDSU_INTR_RX_PACKET1 | + HTDSU_INTR_RX_PACKET2); + HtDsuReceivePacket(Adapter); + } + + /******************************************************************** + // Has the packet been transmitted? + // Actually, this just means that the DSU firmware has moved the + // packet from our buffer area to its own buffer to be transmitted. + // It won't have actually completed until HTDSU_INTR_TX_EMPTY. + */ + if (Adapter->InterruptStatusFlag & (HTDSU_INTR_TX_PACKET1 | + HTDSU_INTR_TX_PACKET2)) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_TX_PACKET\n")); + + Adapter->InterruptStatusFlag &= ~(HTDSU_INTR_TX_PACKET1 | + HTDSU_INTR_TX_PACKET2); + HtDsuTransmitComplete(Adapter); + } + + /******************************************************************** + // Does somebody want to chat? + */ + if (Adapter->InterruptStatusFlag & HTDSU_INTR_RINGING1) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_RINGING1\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RINGING1; + + /* + // CAVEAT: Normally you don't want to stall execution in your + // DPC because locks are held and no other threads will run. + // However, I have seen some hardware/firmware anomallies + // on the answering side where we get here before the signal + // is established, so I double check here by waiting up to 100MS. + */ + TimeOut = 0; + while (!CardStatusRinging(Adapter, HTDSU_CMD_LINE1) || + CardStatusNoSignal(Adapter, HTDSU_CMD_LINE1)) + { + if (TimeOut++ > 1000) + { + DBG_ERROR(Adapter,("Timeout waiting for SIGNAL on line 1\n")); + break; + } + else + { + NdisStallExecution(_100_MICROSECONDS); + } + } + + if (TimeOut != 0) + { + DBG_WARNING(Adapter, ("Ring1 signal delay=%d*100us\n", TimeOut)); + } + + /* + // Make sure the ring is still asserted or it may + // just be noise from the cable being unplugged. + */ + if (CardStatusRinging(Adapter, HTDSU_CMD_LINE1)) + { + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_RINGING); + } + else + { + DBG_WARNING(Adapter, ("Ring1 lost - status=%Xh\n", + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1))); + } + } + if (Adapter->InterruptStatusFlag & HTDSU_INTR_RINGING2) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_RINGING2\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RINGING2; + + TimeOut = 0; + while (!CardStatusRinging(Adapter, HTDSU_CMD_LINE2) || + CardStatusNoSignal(Adapter, HTDSU_CMD_LINE2)) + { + if (TimeOut++ > 100) + { + DBG_ERROR(Adapter,("Timeout waiting for SIGNAL on line 2\n")); + break; + } + else + { + NdisStallExecution(_100_MICROSECONDS); + } + } + + if (TimeOut != 0) + { + DBG_WARNING(Adapter, ("Ring2 signal delay=%d*100us\n", TimeOut)); + } + + if (CardStatusRinging(Adapter, HTDSU_CMD_LINE2)) + { + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_RINGING); + } + else + { + DBG_WARNING(Adapter, ("Ring2 lost - status=%Xh\n", + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2))); + } + } + + /******************************************************************** + // Do we have a connection being established? + */ + if (Adapter->InterruptStatusFlag & HTDSU_INTR_CONNECTED1) + { + + DBG_NOTICE(Adapter,("HTDSU_INTR_CONNECTED1\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_CONNECTED1; + + /* + // CAVEAT: Normally you don't want to stall execution in your + // DPC because locks are held and no other threads will run. + // However, I have seen some hardware/firmware anomallies + // on the calling side where we get here before the carrier + // is established, so I double check here by waiting up to 100MS. + */ + TimeOut = 0; + while (!CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE1) || + !CardStatusOnLine(Adapter, HTDSU_CMD_LINE1)) + { + if (TimeOut++ > 1000) + { + DBG_ERROR(Adapter,("Timeout waiting for CARRIER/LINE 1\n")); + break; + } + else + { + NdisStallExecution(_100_MICROSECONDS); + } + } + + if (TimeOut != 0) + { + DBG_WARNING(Adapter, ("Connect1 carrier delay=%d*100us\n", TimeOut)); + } + + /* + // Make sure the connection is accompanied by a carrier and + // an online status, Otherwise, it's probably just cable bounce. + */ + if (CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE1) && + CardStatusOnLine(Adapter, HTDSU_CMD_LINE1)) + { + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_CONNECTED); + } + else + { + DBG_WARNING(Adapter, ("Connect1 but not ready - status=%X\n", + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1))); + } + } + if (Adapter->InterruptStatusFlag & HTDSU_INTR_CONNECTED2) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_CONNECTED2\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_CONNECTED2; + + TimeOut = 0; + while (!CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE2) || + !CardStatusOnLine(Adapter, HTDSU_CMD_LINE2)) + { + if (TimeOut++ > 1000) + { + DBG_ERROR(Adapter,("Timeout waiting for CARRIER/LINE 2\n")); + break; + } + else + { + NdisStallExecution(_100_MICROSECONDS); + } + } + + if (TimeOut != 0) + { + DBG_WARNING(Adapter, ("Connect2 carrier delay=%d*100us\n", TimeOut)); + } + + if (CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE2) && + CardStatusOnLine(Adapter, HTDSU_CMD_LINE2)) + { + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_CONNECTED); + } + else + { + DBG_WARNING(Adapter, ("Connect2 but not ready - status=%X\n", + READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2))); + } + } + + /******************************************************************** + // Did the other guy hung up on us? -- how rude... + */ + if (Adapter->InterruptStatusFlag & HTDSU_INTR_DISCONNECTED1) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_DISCONNECTED1\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_DISCONNECTED1; + + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED); + } + if (Adapter->InterruptStatusFlag & HTDSU_INTR_DISCONNECTED2) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_DISCONNECTED2\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_DISCONNECTED2; + + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED); + } + + /******************************************************************** + // Has the transmitter gone idle? Ask me if I care... + */ + if (Adapter->InterruptStatusFlag & (HTDSU_INTR_TX_EMPTY1 | + HTDSU_INTR_TX_EMPTY2)) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_TX_EMPTY\n")); + + Adapter->InterruptStatusFlag &= ~(HTDSU_INTR_TX_EMPTY1 | + HTDSU_INTR_TX_EMPTY2); + } + + /******************************************************************** + // Maybe somebody unplugged the phone line? + */ + if (Adapter->InterruptStatusFlag & HTDSU_INTR_NO_SIGNAL1) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_NO_SIGNAL1\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_NO_SIGNAL1; + + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_OUTOFSERVICE); + } + if (Adapter->InterruptStatusFlag & HTDSU_INTR_NO_SIGNAL2) + { + DBG_NOTICE(Adapter,("HTDSU_INTR_NO_SIGNAL2\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_NO_SIGNAL2; + + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_OUTOFSERVICE); + } + + /******************************************************************** + // What about a receive buffer overrun? -- This better never happen! + // However, if it does, we'll shut this sucker off til it's reset. + */ + if (Adapter->InterruptStatusFlag & HTDSU_INTR_RX_FULL1) + { + DBG_ERROR(Adapter,("HTDSU_INTR_RX_FULL1\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RX_FULL1; + + /* + // Ask for reset, and disable interrupts until we get it. + */ + Adapter->NeedReset = TRUE; + Adapter->InterruptEnableFlag = HTDSU_INTR_DISABLE; + + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1); + LinkLineError(Link, WAN_ERROR_BUFFEROVERRUN); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED); + } + if (Adapter->InterruptStatusFlag & HTDSU_INTR_RX_FULL2) + { + DBG_ERROR(Adapter,("HTDSU_INTR_RX_FULL2\n")); + + Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RX_FULL2; + + Adapter->NeedReset = TRUE; + Adapter->InterruptEnableFlag = HTDSU_INTR_DISABLE; + + Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2); + LinkLineError(Link, WAN_ERROR_BUFFEROVERRUN); + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED); + } + } + DBG_LEAVE(Adapter); + + Adapter->InTheDpcHandler = FALSE; + NdisReleaseSpinLock(&Adapter->Lock); +} + diff --git a/private/ntos/ndis/htdsu/keywords.h b/private/ntos/ndis/htdsu/keywords.h new file mode 100644 index 000000000..bb25cc7bd --- /dev/null +++ b/private/ntos/ndis/htdsu/keywords.h @@ -0,0 +1,77 @@ +/***************************************************************************\ +|* 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. *| +\***************************************************************************/ + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Module Name: + + keywords.h + +Abstract: + + This file contains the driver keyword parameters used in the registry. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Include this file in the module parsing the driver configuration + parameters. + +Revision History: + +---------------------------------------------------------------------------*/ + +#ifndef _KEYWORD_H +#define _KEYWORD_H + +/* +// The following parameter values are written to the configuration +// registry during installation and setup, and they are validated +// by the driver when the adapter is initialized. +*/ +#define HTDSU_PARAM_IRQ03 03 +#define HTDSU_PARAM_IRQ04 04 +#define HTDSU_PARAM_IRQ10 10 +#define HTDSU_PARAM_IRQ11 11 +#define HTDSU_PARAM_IRQ12 12 +#define HTDSU_PARAM_IRQ15 15 + +#define HTDSU_PARAM_RAMBASE1 (0x000D0000) +#define HTDSU_PARAM_RAMBASE2 (0x000E0000) +#define HTDSU_PARAM_RAMBASE3 (0x000DF000) +#define HTDSU_PARAM_RAMBASE4 (0x000CF000) + +#define HTDSU_PARAM_INTERRUPT_STRING NDIS_STRING_CONST("InterruptNumber") +#define HTDSU_PARAM_RAMBASE_STRING NDIS_STRING_CONST("RamBaseAddress") +#define HTDSU_PARAM_MEDIATYPE_STRING NDIS_STRING_CONST("MediaType") +#define HTDSU_PARAM_ADDRLIST_STRING NDIS_STRING_CONST("AddressList") +#define HTDSU_PARAM_DEVICENAME_STRING NDIS_STRING_CONST("DeviceName") +#define HTDSU_PARAM_LINETYPE_STRING NDIS_STRING_CONST("LineType") +#define HTDSU_PARAM_LINERATE_STRING NDIS_STRING_CONST("LineRate") + +#if DBG +#define HTDSU_PARAM_DBGFLAGS_STRING NDIS_STRING_CONST("DebugFlags") +#endif + +/* +// Returned from an OID_GEN_VENDOR_ID HtDsuQueryInformation request. +// The vendor's assigned ethernet vendor code should be used if possible. +*/ +#define HTDSU_VENDOR_ID "HTC" + +/* +// Returned from an OID_GEN_VENDOR_DESCRIPTION HtDsuQueryInformation request. +// This is an arbitrary string which may be used by upper layers to present +// a user friendly description of the adapter. +*/ +#define HTDSU_VENDOR_DESCRPTION "HT Communications 56kbps Digital Modem" + +#endif + diff --git a/private/ntos/ndis/htdsu/link.c b/private/ntos/ndis/htdsu/link.c new file mode 100644 index 000000000..1983c07dd --- /dev/null +++ b/private/ntos/ndis/htdsu/link.c @@ -0,0 +1,587 @@ +/***************************************************************************\ +|* 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: + + link.c + +Abstract: + + This module contains the WAN Miniport link management routines. All + information about the state of the link is stored in the Link structure. + LinkInitialize() + LinkAllocate() + LinkRelease() + LinkLineUp() + LinkLineDown() + LinkLineError() + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 4 // Unique file ID for error logging + +#include "htdsu.h" + + +VOID +LinkInitialize( + IN PHTDSU_ADAPTER Adapter, + IN PSTRING AddressList + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine initializes the Link structures within the Adapter + structure. We use the link structure to hold all the information about + a connection, whether the connection is made via TAPI calls or is a + leased line WAN connection. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + AddressList _ This is a list of MULTI_SZ strings which are to be assigned + to each link for use by TAPI HtTapiGetAddressCaps. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("LinkInitialize") + + /* + // A pointer to our link information structure for the selected line device. + */ + PHTDSU_LINK Link; + + /* + // Index into the link array. + */ + USHORT LinkIndex; + + /* + // A pointer to the RAS/TAPI line address assigned to each link. + */ + PUCHAR LineAddress = AddressList->Buffer; + + DBG_ENTER(Adapter); + + ASSERT(Adapter->NumLineDevs <= HTDSU_NUM_LINKS); + + /* + // Go through and initialize each link. + */ + for (LinkIndex = 0; LinkIndex < HTDSU_NUM_LINKS; ++LinkIndex) + { + Link = GET_LINK_FROM_LINKINDEX(Adapter, LinkIndex); + + /* + // Initially, the link is not allocated to anyone and these fields + // must be reset. + // We can assume the entire Adapter structure is zeroed to begin with. + */ + ASSERT(Link->Adapter == (PHTDSU_ADAPTER)0); + ASSERT(Link->htLine == (HTAPI_LINE)0); + ASSERT(Link->htCall == (HTAPI_CALL)0); + ASSERT(Link->NdisLinkContext == NULL); + + /* + // Setup the static features of the link. + */ + Link->CardLine = LinkIndex + HTDSU_CMD_LINE1; + Link->LinkIndex = LinkIndex; + Link->LinkSpeed = _56KBPS; + Link->LineMode = HTDSU_LINEMODE_DIALUP; + Link->MediaModesCaps = LINEMEDIAMODE_DIGITALDATA; + Link->Quality = NdisWanErrorControl; + + /* + // If we run off the end of the address list, we just point at the + // null terminator for the other addresses. This might happen if + // some of the lines were not configured for use with RAS/TAPI. + */ + strcpy(Link->LineAddress, LineAddress); + LineAddress += strlen(LineAddress) + 1; + if ((LineAddress - AddressList->Buffer) >= AddressList->Length) + { + --LineAddress; + } + + DBG_NOTICE(Adapter,("LineAddress=<%s>\n",Link->LineAddress)); + + /* + // Initialize the TAPI event capabilities supported by the link. + */ + Link->DevStatesCaps = LINEDEVSTATE_RINGING | + LINEDEVSTATE_CONNECTED | + LINEDEVSTATE_DISCONNECTED | + LINEDEVSTATE_OUTOFSERVICE | + LINEDEVSTATE_OPEN | + LINEDEVSTATE_CLOSE; + Link->AddressStatesCaps = 0; + Link->CallStatesCaps = LINECALLSTATE_IDLE | + LINECALLSTATE_OFFERING | + LINECALLSTATE_ACCEPTED | + LINECALLSTATE_DIALING | + LINECALLSTATE_BUSY | + LINECALLSTATE_CONNECTED | + LINECALLSTATE_PROCEEDING | + LINECALLSTATE_DISCONNECTED; + /* + // We use this timer to keep track of incoming and outgoing call + // status, and to provide timeouts for certain call states. + */ + NdisMInitializeTimer( + &Link->CallTimer, + Adapter->MiniportAdapterHandle, + HtTapiCallTimerHandler, + Link + ); + } + DBG_LEAVE(Adapter); +} + + +PHTDSU_LINK +LinkAllocate( + IN PHTDSU_ADAPTER Adapter, + IN HTAPI_LINE htLine, + IN USHORT LinkIndex + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine allocates a specific Link structure and passes back a + pointer which can be used by the driver to access the link. + +Parameters: + + Adapter _ A pointer ot our adapter information structure. + + Connection _ The TAPI connection handle to be associated with the link. + + LinkIndex _ The specific link structure being allocated. + +Return Values: + + A pointer to allocated link information structure, NULL if not allocated. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("LinkAllocate") + + /* + // A pointer to our link information structure for the selected line device. + */ + PHTDSU_LINK Link; + + DBG_ENTER(Adapter); + + Link = GET_LINK_FROM_LINKINDEX(Adapter, LinkIndex); + + if (Link->Adapter == (PHTDSU_ADAPTER) 0) + { + /* + // We use the Adapter field to flag whether the link has been allocated. + // The htLine field is used to associate this link with the TAPI + // connection wrapper. Reset all the state information for this link. + */ + Link->Adapter = Adapter; + Link->htLine = htLine; + Link->RingCount = 0; + Link->DevState = 0; + Link->DevStatesMask = 0; // Default to indicate no line events + Link->AddressState = 0; + Link->AddressStatesMask = 0; // Default to indicate no address events + Link->CallState = 0; + Link->CallStatesMask = Link->CallStatesCaps; + Link->MediaMode = Link->MediaModesCaps; + Link->MediaModesMask = 0; + Link->Closing = FALSE; + Link->CallClosing = FALSE; + + /* + // Initialize the default link information structure. It may be + // changed later by MiniportSetInformation. + */ + Link->WanLinkInfo.NdisLinkHandle = Link; + Link->WanLinkInfo.MaxSendFrameSize = Adapter->WanInfo.MaxFrameSize; + Link->WanLinkInfo.MaxRecvFrameSize = Adapter->WanInfo.MaxFrameSize; + Link->WanLinkInfo.SendFramingBits = Adapter->WanInfo.FramingBits; + Link->WanLinkInfo.RecvFramingBits = Adapter->WanInfo.FramingBits; + Link->WanLinkInfo.SendACCM = Adapter->WanInfo.DesiredACCM; + Link->WanLinkInfo.RecvACCM = Adapter->WanInfo.DesiredACCM; + } + else + { + /* + // The requested link has already been allocated. + */ + Link = NULL; + } + + DBG_LEAVE(Adapter); + + return (Link); +} + + +VOID +LinkRelease( + IN PHTDSU_LINK Link + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine releases a specific Link structure and makes it available + for future allocation. It is assumed that the caller has closed any + associated connection and notified TAPI and WAN with a LINE_DOWN. + +Parameters: + + Link _ A pointer to the link information structure to be released. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("LinkRelease") + DBG_ENTER(Link->Adapter); + + Link->Adapter = (PHTDSU_ADAPTER)0; + Link->htLine = (HTAPI_LINE)0; + Link->htCall = (HTAPI_CALL)0; + Link->NdisLinkContext = NULL; +} + + +VOID +LinkLineUp( + IN PHTDSU_LINK Link + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine marks a link as connected and sends a LINE_UP indication to + the WAN wrapper. + + A line up indication is generated when a new link becomes active. Prior + to this the MAC will accept frames and may let them succeed or fail, but + it is unlikely that they will actually be received by any remote. During + this state protocols are encouraged to reduce their timers and retry + counts so as to quickly fail any outgoing connection attempts. + + NOTE: This indication must be sent to the WAN wrapper prior to returning + from the OID_TAPI_ANSWER request, and prior to indicating the + LINECALLSTATE_CONNECTED to the connection wrapper. Otherwise, the + connection wrapper client might attempt to send data to the WAN wrapper + before it is aware of the line. + + The status code for the line up indication is NDIS_STATUS_WAN_LINE_UP. + The format of the StatusBuffer for this code is: + + typedef struct _NDIS_MAC_LINE_UP + { + IN ULONG LinkSpeed; + IN NDIS_WAN_QUALITY Quality; + IN USHORT SendWindow; + IN NDIS_HANDLE ConnectionWrapperID; + IN NDIS_HANDLE NdisLinkHandle; + OUT NDIS_HANDLE NdisLinkContext; + + } NDIS_MAC_LINE_UP, *PNDIS_MAC_LINE_UP; + + LinkSpeed _ The speed of the link, in 100 bps units. + + Quality _ The quality of the new line. + + SendWindow _ The recommended send window, i.e., the number of packets + that should be given to the adapter before pausing to wait + for an acknowledgement. Some devices achieve higher + throughput if they have several packets to send at once; + others are especially unreliable. A value of 0 indicates + no recommendation. + + ConnectionWrapperID _ The MAC supplied handle by which this line will be + known to the connection wrapper clients. This must + be a unique handle across all drivers using the + connection wrapper, so typically htCall should be + used to gaurantee it is unique. This must be the + same value returned from the OID_TAPI_GETID request + for the “ndis” device class. Refer to the + Connection Wrapper Interface Specification for + further details. If not using the connection + wrapper, the value is 0. + + NdisLinkHandle _ The MAC supplied handle passed down in future Miniport + calls (such as MiniportSend) for this link. Typically, + the MAC will provide a pointer to its control block for + that link. The value must be unique, for the first + LINE_UP for that link. Subsequent LINE_UPs may be + called if line characteristics change. When subsequent + LINE_UP calls are made, the MiniportLinkHandle must be + filled with the value returned on the first LINE_UP call. + + NdisLinkContext _ The WAN wrapper supplied handle to be used in future + Miniport calls (such as MiniportReceive) to the wrapper. + The WAN wrapper will provide a unique handle for every + unique LINE_UP. The MiniportLinkHandle must be 0 if + this is the first LINE_UP. It must contain the value + returned on the first LINE_UP for subsequent LINE_UP + calls. + +Parameters: + + Link _ A pointer to our link information structure, on which this LINE_UP + indication is being made. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("LinkLineUp") + + NDIS_MAC_LINE_UP LineUpInfo; + + DBG_ENTER(Link->Adapter); + + /* + // Initialize the LINE_UP event packet. + */ + LineUpInfo.LinkSpeed = Link->LinkSpeed / 100; + LineUpInfo.Quality = Link->Quality; + LineUpInfo.SendWindow = Link->SendWindow; + LineUpInfo.ConnectionWrapperID = (NDIS_HANDLE) Link->htCall; + LineUpInfo.NdisLinkHandle = Link; + LineUpInfo.NdisLinkContext = Link->NdisLinkContext; + + /* + // Indicate the event to the WAN wrapper. + */ + NdisMIndicateStatus(Link->Adapter->MiniportAdapterHandle, + NDIS_STATUS_WAN_LINE_UP, + &LineUpInfo, + sizeof(LineUpInfo) + ); + + /* + // Save the WAN wrapper link context for use when indicating received + // packets and errors. + */ + Link->NdisLinkContext = LineUpInfo.NdisLinkContext; + + DBG_NOTICE(Link->Adapter, + ("MAC_LINE_UP: LinkHandle=%Xh NdisHandle=%Xh WrapperID=%Xh\n", + LineUpInfo.NdisLinkHandle, + LineUpInfo.NdisLinkContext, + LineUpInfo.ConnectionWrapperID + )); + + DBG_LEAVE(Link->Adapter); +} + + +VOID +LinkLineDown( + IN PHTDSU_LINK Link + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine marks a link as disconnected and sends a LINE_DOWN + indication to the WAN wrapper. + + A line down indication is generated when a link goes down. Protocols + should again reduce their timers and retry counts until the next line + up indication. + + The status code for the line down indication is NDIS_STATUS_WAN_LINE_DOWN. + The format of the StatusBuffer for this code is: + + typedef struct _NDIS_MAC_LINE_DOWN + { + IN NDIS_HANDLE NdisLinkContext; + + } NDIS_MAC_LINE_DOWN, *PNDIS_MAC_LINE_DOWN; + + MiniportLinkContext _ Value returned in NDIS_WAN_LINE_UP. + +Parameters: + + Link _ A pointer to our link information structure, on which this LINE_DOWN + indication is being made. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("LinkLineDown") + + NDIS_MAC_LINE_DOWN LineDownInfo; + + DBG_ENTER(Link->Adapter); + + /* + // We can't allow indications to NULL... + */ + if (Link->NdisLinkContext) + { + DBG_NOTICE(Link->Adapter, + ("MAC_LINE_DOWN: NdisHandle=%Xh\n", + Link->NdisLinkContext + )); + + /* + // Setup the LINE_DOWN event packet and indicate the event to the + // WAN wrapper. + */ + LineDownInfo.NdisLinkContext = Link->NdisLinkContext; + + NdisMIndicateStatus(Link->Adapter->MiniportAdapterHandle, + NDIS_STATUS_WAN_LINE_DOWN, + &LineDownInfo, + sizeof(LineDownInfo) + ); + /* + // The line is down, so there's no more context for receives. + */ + Link->NdisLinkContext = NULL; + Link->CallClosing = FALSE; + } + + DBG_LEAVE(Link->Adapter); +} + + +VOID +LinkLineError( + IN PHTDSU_LINK Link, + IN ULONG Errors + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + This routine is used to indicate to the WAN wrapper that a partial + packet was received from the remote end. The NDIS_STATUS_WAN_FRAGMENT + indication is used to notify WAN wrapper. + + A fragment indication indicates that a partial packet was received from + the remote. The protocol is encouraged to send frames to the remote that + will notify it of this situation, rather than waiting for a timeout to + occur. + + The status code for the fragment indication is NDIS_STATUS_WAN_FRAGMENT. + The format of the StatusBuffer for this code is: + + typedef struct _NDIS_MAC_FRAGMENT + { + IN NDIS_HANDLE NdisLinkContext; + IN ULONG Errors; + + } NDIS_MAC_FRAGMENT, *PNDIS_MAC_FRAGMENT; + + NdisLinkContext _ Value returned in NDIS_WAN_LINE_UP. + + Errors _ A bit field set to one or more bits indicating the reason the + fragment was received. If no direct mapping from the WAN medium + error to one of the six errors listed below exists, choose the + most apropriate error: + + WAN_ERROR_CRC + WAN_ERROR_FRAMING + WAN_ERROR_HARDWAREOVERRUN + WAN_ERROR_BUFFEROVERRUN + WAN_ERROR_TIMEOUT + WAN_ERROR_ALIGNMENT + + NOTE: The WAN wrapper keeps track of dropped packets by counting the + number of fragment indications on the link. + +Parameters: + + Link _ A pointer to our link information structure, on which this error + was encountered. + +Return Values: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("LinkLineError") + + NDIS_MAC_FRAGMENT FragmentInfo; + + /* + // We can't allow indications to NULL... + */ + if (Link->NdisLinkContext) + { + DBG_ENTER(Link->Adapter); + + DBG_NOTICE(Link->Adapter, + ("MAC_LINE_ERROR: NdisHandle=%Xh Errors=%Xh\n", + Link->NdisLinkContext, + Errors + )); + + /* + // Setup the FRAGMENT event packet and indicate it to the WAN wrapper. + */ + FragmentInfo.NdisLinkContext = Link->NdisLinkContext; + FragmentInfo.Errors = Errors; + + NdisMIndicateStatus(Link->Adapter->MiniportAdapterHandle, + NDIS_STATUS_WAN_FRAGMENT, + &FragmentInfo, + sizeof(FragmentInfo) + ); + + DBG_LEAVE(Link->Adapter); + } +} + diff --git a/private/ntos/ndis/htdsu/makefile b/private/ntos/ndis/htdsu/makefile new file mode 100644 index 000000000..58189757d --- /dev/null +++ b/private/ntos/ndis/htdsu/makefile @@ -0,0 +1,7 @@ +# +# DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source +# file to this component. This file merely indirects to the real make file +# that is shared by all the driver components of the Windows NT DDK +# + +!INCLUDE $(NTMAKEENV)\makefile.def diff --git a/private/ntos/ndis/htdsu/oemsetnt.inf b/private/ntos/ndis/htdsu/oemsetnt.inf new file mode 100644 index 000000000..6b3a7882e --- /dev/null +++ b/private/ntos/ndis/htdsu/oemsetnt.inf @@ -0,0 +1,1241 @@ +;*********************************************************************** +; HT Communications DSU41/42 56kbps Digital Modem WindowsNT Setup File. +;*********************************************************************** +[Identification] + OptionType = NetAdapter + +;*********************************************************************** +; +;*********************************************************************** +[PlatformsSupported] + ISA + EISA + "Jazz-Internal Bus" + +;*********************************************************************** +; +;*********************************************************************** +[Options] + HTDSU41 +; HTDSU42 FIXME - The HTDSU42 does not yet support HDLC framing + +;*********************************************************************** +; +;*********************************************************************** +[FileConstants] + InfName = "OEMHTDSU.INF" + UtilityInf = "UTILITY.INF" + ParamInf = "NCPARAM.INF" + subroutineinf = "SUBROUTN.INF" + SoftwareType = "driver" + Exit_Code = 0 + NetEventDLL = "%SystemRoot%\System32\netevent.dll" + IoLogMsgDLL = "%SystemRoot%\System32\IoLogMsg.dll" + Manufacturer = "HT Communications" + ProductMajorVersion = "3" + ProductMinorVersion = "1" + ProductVersion = $(ProductMajorVersion)"."$(ProductMinorVersion) + ProductSoftwareName = "HTDSU41" + ProductSoftwareImagePath = "\SystemRoot\System32\drivers\HTDSU41.sys" + NetRuleSoftwareType = "HTDSU41Sys HTDSU41Driver" + NetRuleSoftwareUse = $(SoftwareType) + NetRuleSoftwareBindForm = """HTDSU41Sys"" yes no container" + NetRuleSoftwareClass = {"HTDSU41Driver basic"} + NetRuleSoftwareBindable = {"HTDSU41Driver HTDSU41Adapter non exclusive 100"} + ProductHardwareName = "HTDSU41" + NetRuleHardwareBindForm = " yes yes container" + NetRuleHardwareHTDSU41Type = "HTDSU41 HTDSU41Adapter" + NetRuleHardwareHTDSU41Class = {"HTDSU41Adapter basic"} + BindableHTDSU41Txt = {"HTDSU41Driver HTDSU41Adapter non exclusive 100"} + DeviceMap = "HARDWARE\DEVICEMAP" + TapiDevices = "TAPI DEVICES" + TapiDeviceKey = $(ProductHardwareName) + TapiMediaType = "Sw56_" + ProductKeyName = $(!NTN_SoftwareBase)"\"$(Manufacturer)"\"+ + $(ProductSoftwareName)"\CurrentVersion" + ParamKeyName = $(!NTN_ServiceBase)"\"$(ProductHardwareName)+ + "\Parameters" + +; FIXME - default to dialup line mode = 0 -- leased line = 1 +; In dialup mode we need to write the parameters so RAS/TAPI will bind to us +; In leased mode we need to write the parameters so NDIS/WAN will bind to us +; Right now this file only supports dialup mode - leased line changes are needed + LineType = 0 + +; FIXME - Set to zero before release + DebugFlags = 0 + + RAM_Addr_List = {851968, 917504, 913408, 847872} + IRQ_List = {15, 12, 11, 10, 4, 3} + +; Default here is 1=57.6kbps 0=max 2=38.4k 3=19.2k 4=9.6k + Rate_Strings = {"Max kbps", "57.6 kbps", "38.4 kbps", "19.2 kpbs", "9.6 kbps"} + Line_Rates = {0, 1, 2, 3, 4} + LineRate = 0 + +;*********************************************************************** +; +;*********************************************************************** +[GeneralConstants] + from = "" + to = "" + ExitCodeOk = 0 + ExitCodeCancel = 1 + ExitCodeFatal = 2 + KeyNull = "" + MAXIMUM_ALLOWED = 33554432 + RegistryErrorIndex = NO_ERROR + KeyProduct = "" + KeyParameters = "" + TRUE = 1 + FALSE = 0 + NoTitle = 0 + ExitState = "Active" + OldVersionExisted = $(FALSE) + DriverPath = $(!STF_NTPATH)\drivers + +;*********************************************************************** +; +;*********************************************************************** +[Date] + Now = {} ? $(!LIBHANDLE) GetSystemDate + +;*********************************************************************** +; +;*********************************************************************** +[Identify] + Read-Syms Identification + Set Status = STATUS_SUCCESSFUL + Set Identifier = $(OptionType) + Set Media = #("Source Media Descriptions", 1, 1) + Return $(Status) $(Identifier) $(Media) + +;*********************************************************************** +; +;*********************************************************************** +[ReturnOptions] + Set Status = STATUS_FAILED + Set OptionList = {} + Set OptionTextList = {} + Set LanguageList = ^(LanguagesSupported, 1) + + IfContains(i) $($0) in $(LanguageList) + IfStr(i) $($1) == "" + GoTo SetOptions + EndIf + Set PlatformList = ^(PlatformsSupported, 1) + IfContains(i) $($1) in $(PlatformList) + GoTo SetOptions + Else + Set Status = STATUS_NOTSUPPORTED + GoTo ExitReturnOptions + EndIf + Else + Set Status = STATUS_NOLANGUAGE + GoTo ExitReturnOptions + EndIf + +SetOptions = + + Set OptionList = ^(Options, 1) + Set OptionTextList = ^(OptionsText$($0), 1) + Set Status = STATUS_SUCCESSFUL + +ExitReturnOptions = + + Return $(Status) $(OptionList) $(OptionTextList) + +;*********************************************************************** +; +;*********************************************************************** +[InstallOption] + Set Status = STATUS_FAILED + Set Option = $($1) + Set SrcDir = $($2) + Set RasDir = $($2) + Set AddCopy = $($3) + Set DoCopy = $($4) + Set DoConfig = $($5) + Set LanguageList = ^(LanguagesSupported, 1) + + IfContains(i) $($0) NOT-IN $(LanguageList) + Return STATUS_NOLANGUAGE + EndIf + ; + ; FIXME - make sure this flag is disabled before shipping + ; + Set OldDebugControl = $(!DebugOutputControl) +; Set !DebugOutputControl = 1 + + Set-Subst LF = "\n" + + Read-Syms GeneralConstants + Read-Syms FileConstants + Read-Syms DialogConstants$(!STF_LANGUAGE) + + IfStr(i) $(!NTN_Origination) == "NCPA" + Set Continue = $(OK) + EndIf + + Read-Syms FileConstants$(!STF_LANGUAGE) + Detect Date + Set-Title $(FunctionTitle)$(Option) + + Set to = Begin + Set from = Begin + Set CommonStatus = STATUS_SUCCESSFUL + + EndWait + +;*********************************************************************** +; +;*********************************************************************** +Begin = + + Set ActivateDetection = FALSE + IfStr(i) $(!NTN_InstallMode) == deinstall + Set StartLabel = RemoveAdapter + Else-IfStr(i) $(!NTN_InstallMode) == Update + Set StartLabel = UpgradeSoftware + Else-IfStr(i) $(!NTN_InstallMode) == bind + Set StartLabel = BindingAdapter + Else-IfStr(i) $(!NTN_InstallMode) == configure + Set StartLabel = ConfigureAdapter + Set ActivateDetection = TRUE + Set CommonStatus = STATUS_REBOOT + IfStr(i) $(ProductKeyName) == $(!NTN_RegBase) + Debug-Output $(InfName)": Cannot configure the EtherWORKS 3 driver software." + Shell $(UtilityInf),RegistryErrorString,CANNOT_CONFIGURE_SOFTWARE + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error: cannot get an error string." + GoTo ShellCodeError + EndIf + Set Error = $($R0) + Set from = end + Set to = end + GoTo NonFatalInfo + EndIf + Else + Set StartLabel = InstallAdapter + Set ActivateDetection = TRUE + Set OEM_ABANDON_OPTIONS = {} + Set OEM_ABANDON_SOFTWARE = FALSE + Set OEM_ABANDON_ON = TRUE + EndIf + + Debug-Output $(InfName)": ==================================================" + Debug-Output $(InfName)": STF_CWDIR is: "$(!STF_CWDIR) + Debug-Output $(InfName)": STF_LANGUAGE is: "$(!STF_LANGUAGE) + Debug-Output $(InfName)": Option is: "$(Option) + Debug-Output $(InfName)": !STF_NCDETECT is: "$(!STF_NCDETECT) + Debug-Output $(InfName)": !STF_NCOPTION is: "$(!STF_NCOPTION) + Debug-Output $(InfName)": !STF_NCDETCARD is: "$(!STF_NCDETCARD) + Debug-Output $(InfName)": !STF_NCDETINFO is: "$(!STF_NCDETINFO) + Debug-Output $(InfName)": ==================================================" + + Set DetectedCard = FALSE + IfStr(i) $(ActivateDetection) != TRUE + GoTo $(StartLabel) + EndIf + + Debug-Output $(InfName)": Calling Param_SetDefaults" + Shell $(ParamInf) Param_SetDefaults {} + + Shell $(ParamInf) HexListFromDecList $(RAM_Addr_List) + Set RAM_Hex_List = $($R0) + + IfStr(i) $(!STF_NCDETECT) == YES + IfStr(i) $(!STF_NCOPTION) == $(Option) + Set DetectedCard = TRUE + Debug-Output $(InfName)": Setting DetectedCard to TRUE" + EndIf + EndIf + + Shell "" DebugConfiguration "After parameter querying" + Set from = FatalError + Set to = FatalError + GoTo $(StartLabel) + +;*********************************************************************** +; +;*********************************************************************** +InstallAdapter = + + OpenRegKey $(!REG_H_LOCAL) "" $(ProductKeyName) $(MAXIMUM_ALLOWED) KeyProduct + IfStr $(KeyProduct) != $(KeyNull) + CloseRegKey $(KeyProduct) + IfStr(i) !(NTN_RegBase) == $(ProductKeyName) + Shell $(UtilityInf), VerExistedDlg, $(ProductSoftwareTitle),+ + $(ProductVersion) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error: cannot get an error string." + GoTo ShellCodeError + EndIf + GoTo end + Else + Shell $(UtilityInf), CardExistedDlg + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error: cannot get an error string." + GoTo ShellCodeError + EndIf + IfStr(i) $($R1) != "OK" + Set CommonStatus = STATUS_USERCANCEL + GoTo end + EndIf + Set OldVersionExisted = $(TRUE) + EndIf + EndIf + + Set CurrParamSettings = {} + IfStr(i) $(DetectedCard) != TRUE + GoTo AdapterSetup + EndIf + + StartWait + Shell $(ParamInf) Param_QueryCard $(!STF_NCDETCARD) + EndWait + + IfStr(i) $($R0) != STATUS_SUCCESSFUL + GoTo AdapterSetup + EndIf + + Set DetectedParams = $($R1) + Debug-Output $(InfName)": Calling Param_SetDefaults to merge detected params" + Shell $(ParamInf) Param_SetDefaults $(DetectedParams) + GoTo AdapterSetup + +;*********************************************************************** +; +;*********************************************************************** +ConfigureAdapter = + + IfStr $(KeyProduct) == $(KeyNull) + OpenRegKey $(!REG_H_LOCAL) "" $(!NTN_RegBase) $(MAXIMUM_ALLOWED) KeyProduct + IfStr $(KeyProduct) == $(KeyNull) + Set RegistryErrorIndex = CANNOT_FIND_COMPONENT_SERVICE + Debug-Output $(InfName)": Cannot find component product key" + GoTo FatalRegistry + EndIf + EndIf + + Debug-Output $(InfName)": Shelling to FindService" + Shell $(UtilityInf) FindService, $(KeyProduct) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": FindService shell failure" + GoTo ShellCodeError + EndIf + IfStr(i) $($R0) != NO_ERROR + Debug-Output $(InfName)": FindService Shell error: "$($R0) + GoTo FatalRegistry + EndIf + + Set KeyParameters = $($R2) + CloseRegKey $($R1) + IfStr $(KeyParameters) == $(KeyNull) + Set RegistryErrorIndex = CANNOT_FIND_COMPONENT_SERVICE + Debug-Output $(InfName)": Cannot find component service" + GoTo FatalRegistry + EndIf + + Set OldVersionExisted = $(TRUE) + Set ValueName = "" + Set ValueData = "" + Set ValueStr = "" + Set ValueList = {} + EnumRegValue $(KeyParameters) ValueList + ForListDo $(ValueList) + Set ValueItem = $($) + Set ValueName = *($(ValueItem),1) + Set ValueData = *($(ValueItem),4) + Debug-Output $(InfName)": "$(ValueName)"="$(ValueData) + IfStr(i) $(ValueName) == "AddressList" + Set TapiAddressList = $(ValueData) + Else-IfStr(i) $(ValueName) == "RamBaseAddress" + Set RamBaseAddress = $(ValueData) + Else-IfStr(i) $(ValueName) == "InterruptNumber" + Set InterruptNumber = $(ValueData) + Else-IfStr(i) $(ValueName) == "LineType" + Set LineType = $(ValueData) + Else-IfStr(i) $(ValueName) == "LineRate" + Set LineRate = $(ValueData) + Else-IfStr(i) $(ValueName) == "BusNumber" + Set BusNumber = $(ValueData) + Else-IfStr(i) $(ValueName) == "BusType" + Set BusType = $(ValueData) + EndIf + EndForListDo + Shell $(ParamInf) Param_SaveValues + Set CurrParamSettings = $($R0) + +;*********************************************************************** +; +;*********************************************************************** +AdapterSetup = + + Shell "" DebugConfiguration "before displaying dialog" + Set from = AdapterOptions + Set InterruptNumber = *($(IRQ_List), ~($(IRQ_List),$(InterruptNumber))) + Set RAM_Hex_Value = *($(RAM_Hex_List), ~($(RAM_Addr_List),$(RamBaseAddress))) + Set RateString = *($(Rate_Strings), ~($(Line_Rates),$(LineRate))) + Shell $(ParamInf) Param_ParameterConfidence + IfStr(i) $($R0) != STATUS_SUCCESSFUL + Debug-Output $(InfName)": parameter confidence too low to bypass configuration" + GoTo AdapterOptions + EndIf + IfStr(i) $(DetectedCard) == TRUE + IfStr(i) $(!STF_INSTALL_MODE) != CUSTOM + GoTo AdapterVerify + EndIf + EndIf + +;*********************************************************************** +; +;*********************************************************************** +AdapterOptions = + + Read-Syms FileDependentDlg$(!STF_LANGUAGE) + UI Start "InputDlg" + IfStr(i) $(DLGEVENT) == "CONTINUE" + Set InterruptNumber = $(Combo1Out) + Set RAM_Hex_Value = $(Combo2Out) + Set RamBaseAddress = *($(RAM_Addr_List), ~($(RAM_Hex_List),$(RAM_Hex_Value))) + Set RateString = $(Combo3Out) + Set LineRate = *($(Line_Rates), ~($(Rate_Strings),$(RateString))) + ui pop 1 + Else-IfStr(i) $(DLGEVENT) == "BACK" + Set CommonStatus = STATUS_USERCANCEL + Debug-Output $(InfName)": Action: exit. Bye." + ui pop 1 + GoTo end + Else + Debug-Output $(InfName)": Action: unknown. Bye." + ui pop 1 + GoTo end + EndIf + IfStr(i) $(!STF_NCDETINFO) == {} + Shell $(UtilityInf),GetBusTypeDialog,$(ProductHardware$(Option)Description) $(BusType) $(BusNumber) + ifInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error." + GoTo ShellCodeError + EndIf + Set BusType = $($R1) + Set BusNumber = $($R2) + Else + Set BusType = *($(!STF_NCDETINFO),5) + Set BusNumber = *($(!STF_NCDETINFO),6) + EndIf + +;*********************************************************************** +; +;*********************************************************************** +AdapterVerify = + + Shell "" DebugConfiguration "after running dialog" + IfStr(i) $(DetectedCard) != TRUE + Shell $(ParamInf) Param_SaveValues + Set NewParamSettings = $($R0) + IfStr(i) $(CurrParamSettings) == {} + Set DiffParamSettings = $(NewParamSettings) + Else + Shell $(ParamInf) Param_DiffValues $(CurrParamSettings) + Set DiffParamSettings = $($R0) + EndIf + Debug-Output $(InfName)": Calling Param_VerifyResources" + Shell $(ParamInf) Param_VerifyResources $(DiffParamSettings) + IfStr(i) $($R0) == STATUS_SUCCESSFUL + Debug-Output $(InfName)": Param_VerifyResources succeeded" + GoTo SkipOptions + EndIf + Else + Set CardVerifyIndex = $(!STF_NCDETCARD) + Debug-Output $(InfName)": Calling Param_VerifyCard" + Shell $(ParamInf) Param_VerifyCard $(!STF_NCDETCARD) + IfStr(i) $($R0) == STATUS_SUCCESSFUL + Debug-Output $(InfName)": Param_VerifyCard succeeded" + GoTo SkipOptions + EndIf + EndIf + + Set from = AdapterOptions + Set to = SkipOptions + Shell $(UtilityInf),RegistryErrorString,VERIFY_WARNING + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error: cannot get an error string." + GoTo ShellCodeError + EndIf + Set Error = $($R0) + GoTo WarningMsg + +;*********************************************************************** +; +;*********************************************************************** +SkipOptions =+ + IfInt $(OldVersionExisted) == $(TRUE) + IfStr(i) $(!NTN_InstallMode) == configure + GoTo WriteParameters + EndIf + EndIf + StartWait + IfInt $(OldVersionExisted) == $(FALSE) + IfStr(i) $(!NTN_InstallMode) == "install" + IfStr(i) $(DoCopy) == "YES" + Shell $(UtilityInf), DoAskSource, $(!STF_CWDDIR), $(SrcDir) YES + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + Else-IfStr(i) $($R0) == STATUS_FAILED + Shell $(UtilityInf) RegistryErrorString "ASK_SOURCE_FAIL" + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + Set Error = $($R0) + GoTo FatalError + Else-IfStr(i) $($R0) == STATUS_USERCANCEL + GoTo SuccessfulOption + EndIf + Set SrcDir = $($R1) + EndIf + + Install "Install-Option" + IfStr(i) $(STF_INSTALL_OUTCOME) != STF_SUCCESS + Shell $(UtilityInf) RegistryErrorString "UNABLE_COPY_FILE" + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + Set Error = $($R0) + GoTo FatalError + EndIf + EndIf + + Shell $(UtilityInf), AddSoftwareComponent, $(Manufacturer), + + $(ProductSoftwareName), + + $(ProductSoftwareName), + + $(ProductSoftwareTitle), $(STF_CONTEXTINFNAME), + + $(ProductSoftwareImagePath), "kernelautostart", "NDIS", {}, "",+ + $(NetEventDLL) + Set OEM_ABANDON_SOFTWARE = TRUE + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + Set KeyProduct = $($R1) + Set SoftNetRulesKey = $($R2) + CloseRegKey $($R3) + CloseRegKey $($R4) + CloseRegKey $($R5) + + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + EndWait + Debug-Output $(InfName)": Registry error: add software components" + CloseRegKey $(KeyProduct) + CloseRegKey $(SoftNetRulesKey) + GoTo FatalRegistry + EndIf + + Set NewValueList = {{SoftwareType,$(NoTitle),$(!REG_VT_SZ),$(SoftwareType)},+ + {MajorVersion,$(NoTitle),$(!REG_VT_DWORD),$(ProductMajorVersion)},+ + {MinorVersion,$(NoTitle),$(!REG_VT_DWORD),$(ProductMinorVersion)},+ + {Title,$(NoTitle),$(!REG_VT_SZ),$(ProductSoftwareTitle)},+ + {Description,$(NoTitle),$(!REG_VT_SZ),$(ProductSoftwareDescription)},+ + {ServiceName,$(NoTitle),$(!REG_VT_SZ),$(ProductSoftwareName)},+ + {InstallDate,$(NoTitle),$(!REG_VT_DWORD),*($(Now),1)}} + Shell $(UtilityInf), AddValueList, $(KeyProduct), $(NewValueList) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error." + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + EndWait + Debug-Output $(InfName)": Registry error: add value list." + CloseRegKey $(KeyProduct) + CloseRegKey $(SoftNetRulesKey) + GoTo FatalRegistry + EndIf + + Set NewValueList = {{type,$(NoTitle),$(!REG_VT_SZ),$(NetRuleSoftwareType)},+ + {use,$(NoTitle),$(!REG_VT_SZ),$(NetRuleSoftwareUse)}, + + {bindform,$(NoTitle),$(!REG_VT_SZ),$(NetRuleSoftwareBindForm)}, + + {class,$(NoTitle),$(!REG_VT_MULTI_SZ),$(NetRuleSoftwareClass)}, + + {bindable,$(NoTitle),$(!REG_VT_MULTI_SZ),$(Bindable$(Option)Txt)}, + + {InfOption,$(NoTitle),$(!REG_VT_SZ),$(Option)}} + Shell $(UtilityInf), AddValueList, $(SoftNetRulesKey), $(NewValueList) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error." + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + CloseRegKey $(KeyProduct) + CloseRegKey $(SoftNetRulesKey) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + EndWait + Debug-Output $(InfName)": Resgitry error: add value list." + GoTo FatalRegistry + EndIf + EndIf + + Shell $(UtilityInf), AddHardwareComponent, $(ProductHardwareName),$(STF_CONTEXTINFNAME),$(ProductKeyName) + IfInt $($R4) != -1 + Set OEM_ABANDON_OPTIONS = >($(OEM_ABANDON_OPTIONS), $(!NTN_SoftwareBase)"\Microsoft\Windows NT\CurrentVersion\NetworkCards\"$($R4)) + EndIf + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": Cannot add hardware component" + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + EndWait + Debug-Output $(InfName)": Registry error: add hardware component" + CloseRegKey $($R1) + CloseRegKey $($R2) + CloseRegKey $($R3) + GoTo FatalRegistry + EndIf + + Set KeyParameters = $($R3) + Set KeyAdapterRules = $($R2) + Set AdapterNumber = $($R4) + Set NewValueList = {{Manufacturer,$(NoTitle),$(!REG_VT_SZ),$(Manufacturer)},+ + {Title,$(NoTitle),$(!REG_VT_SZ),"["$($R4)"] "$(ProductHardware$(Option)Title)},+ + {Description,$(NoTitle),$(!REG_VT_SZ),$(ProductHardware$(Option)Description)},+ + {ProductName,$(NoTitle),$(!REG_VT_SZ),$(ProductHardwareName)},+ + {ServiceName,$(NoTitle),$(!REG_VT_SZ),$($R5)},+ + {InstallDate,$(NoTitle),$(!REG_VT_DWORD),*($(Now),1)}} + Shell $(UtilityInf), AddValueList, $($R1), $(NewValueList) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + CloseRegKey $($R1) + +;;; You need one address entry in the list for each channel on your device. +;;; FIXME - at this point RAS requires there to be one logical line per address +;;; FIXME - so the address (channel) number is ignored and the line number is used + Set TapiAddressList = {$(AdapterNumber)"-1-0"} + IfStr(i) $(Option) == HTDSU42 + Set TapiAddressList = >($(TapiAddressList),$(AdapterNumber)"-2-0") + EndIf + + Set TempProdName = """"$(ProductHardwareName)$(AdapterNumber)"""" + Set TempBindForm = $(TempProdName)$(NetRuleHardwareBindForm) + Set NewValueList = {{type,$(NoTitle),$(!REG_VT_SZ),$(NetRuleHardware$(Option)Type)},+ + {bindform,$(NoTitle),$(!REG_VT_SZ),$(TempBindForm)}, + + {class,$(NoTitle),$(!REG_VT_MULTI_SZ),$(NetRuleHardware$(Option)Class)}, + + {InfOption,$(NoTitle),$(!REG_VT_SZ),$(Option)}} + Shell $(UtilityInf), AddValueList, $(KeyAdapterRules), $(NewValueList) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error." + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + EndWait + Debug-Output $(InfName)": Resgitry error: add value list." + CloseRegKey $(KeyParameters) + CloseRegKey $(KeyAdapterRules) + GoTo FatalRegistry + EndIf + CloseRegKey $(KeyAdapterRules) + + GoTo WriteParameters + +;*********************************************************************** +; +;*********************************************************************** +WriteParameters = + + Set NewValueList = {+ + {AddressList,$(NoTitle),$(!REG_VT_MULTI_SZ),$(TapiAddressList)},+ + {BusNumber,$(NoTitle),$(!REG_VT_DWORD),$(BusNumber)},+ + {BusType,$(NoTitle),$(!REG_VT_DWORD),$(BusType)},+ + {DeviceName,$(NoTitle),$(!REG_VT_SZ),$(ProductHardwareName)},+ + {InterruptNumber,$(NoTitle),$(!REG_VT_DWORD),$(InterruptNumber)},+ + {LineType,$(NoTitle),$(!REG_VT_DWORD),$(LineType)},+ + {LineRate,$(NoTitle),$(!REG_VT_DWORD),$(LineRate)},+ + {MediaType,$(NoTitle),$(!REG_VT_SZ),$(TapiMediaType)},+ + {RamBaseAddress,$(NoTitle),$(!REG_VT_DWORD),$(RamBaseAddress)}+ + } +;;; {DebugFlags,$(NoTitle),$(!REG_VT_DWORD),$(DebugFlags)},+ + Shell $(UtilityInf), AddValueList, $(KeyParameters), $(NewValueList) + CloseRegKey $(KeyParameters) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error." + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + Debug-Output $(InfName)": Registry error: Add value list" + GoTo FatalRegistry + EndIf + ; + ; Create the HARDWARE\DEVICEMAP\TAPI DEVICES\HTDSU41 key + ; + OpenRegKey $(!REG_H_LOCAL) "" "HARDWARE\DEVICEMAP" $(MAXIMUM_ALLOWED) BaseKey + shell "" HtCreateRegKey $(BaseKey) "TAPI DEVICES\HTDSU41" + IfStr(i) $($R0) != NO_ERROR + Debug-Output $(InfName)": Error creating registry key!" + GoTo FatalRegistry + EndIf + Set TapiDeviceKey = $($R1) + Set NewValueList = {+ + {Address,$(NoTitle),$(!REG_VT_MULTI_SZ),$(TapiAddressList)},+ + {"Media Type",$(NoTitle),$(!REG_VT_SZ),$(TapiMediaType)}} + Shell $(UtilityInf), AddValueList, $(TapiDeviceKey), $(NewValueList) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error." + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + Debug-Output $(InfName)": Registry error: Add value list" + GoTo FatalRegistry + EndIf + CloseRegKey $(TapiDeviceKey) + CloseRegKey $(BaseKey) + ; + ; if RAS is not installed, then shell ras setup INF file to install RAS + ; else invoke RAS to allow user to configure RAS for Switch56. + ; + Read-Syms InvokeRasDlg$(!STF_LANGUAGE) + Shell "oemnsvra.inf" CheckRasInstalled + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": Error Shelling the RAS INF file oemnsvra.inf" + Shell "subroutn.inf" SetupMessage, $(!STF_LANGUAGE), + + "STATUS", $(InvokeRasError) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + GoTo SuccessfulOption + EndIf + Set RasInstalled = $($R0) + Debug-Output $(InfName)": Is RAS Installed? "$(RasInstalled) + ; + ; display a message to the user that RAS setup will now be invoked + ; + IfStr(i) $(RasInstalled) == FALSE + Shell "subroutn.inf" SetupMessage, $(!STF_LANGUAGE), "STATUS", + + $(InvokeRasSetupMsg) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo SuccessfulOption + EndIf + Else + Shell "subroutn.inf" SetupMessage, $(!STF_LANGUAGE), "STATUS", + + $(InvokeRasConfigMsg) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo SuccessfulOption + EndIf + EndIf + ; + ; If this is a reconfiguration, skip the automatic call to RAS setup. + ; + IfInt $(OldVersionExisted) == $(TRUE) + IfStr(i) $(!NTN_InstallMode) == configure + GoTo SuccessfulOption + EndIf + EndIf + ; + ; Set the flags based on whether this is an IDW installation + ; + IfStr(i) $(!STF_IDW) == TRUE + Set AddCopy = NO + Set DoCopy = NO + Set DoConfig = NO + Else + Set AddCopy = YES + Set DoCopy = YES + Set DoConfig = YES + EndIf + ; + ; change the global install mode flag to configure if RAS is already installed + ; + Set SaveNTN_InstallMode = $(!NTN_InstallMode) + IfStr(i) $(RasInstalled) == TRUE + Set !NTN_InstallMode = configure + Else + Set !NTN_InstallMode = install + EndIf + ; + ; Override the default drive\directory selection so user can choose.. + ; + Set SaveSTF_SRCDIR_OVERRIDE = $(!STF_SRCDIR_OVERRIDE) + Set !STF_SRCDIR_OVERRIDE = "" + Set RasDir = "A:\"$(!STF_PLATFORM) + ; + ; now invoke RAS setup to do the right thing + ; + Debug-Output $(InfName)": Shelling to RAS:" + Shell "oemnsvra.inf" InstallOption $(!STF_LANGUAGE) "RAS" $(RasDir) $(AddCopy) $(DoCopy) $(DoConfig) + Debug-Output $(InfName)": Back from RAS: ShellCode="$($ShellCode) + ; + ; Restore the global install flags. + ; + Set !NTN_InstallMode = $(SaveNTN_InstallMode) + Set !STF_SRCDIR_OVERRIDE = $(SaveSTF_SRCDIR_OVERRIDE) + ; + ; Check for RAS errors. + ; + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": Error Shelling the RAS INF file oemnsvra.inf" + Shell "subroutn.inf" SetupMessage, $(!STF_LANGUAGE), "STATUS", + + $(InvokeRasError) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": Cannot run SetupMessage: ShellCode="$($ShellCode) + GoTo ShellCodeError + EndIf + GoTo SuccessfulOption + EndIf + ; + ; If RAS reports no change, warn the user that the driver may not + ; be configured properly. + ; + IfStr(i) $($R0) == STATUS_NO_EFFECT + Shell "subroutn.inf" SetupMessage, $(!STF_LANGUAGE), "STATUS", + + $(InvokeRasAgainMsg) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo SuccessfulOption + EndIf + EndIf + + Set CommonStatus = $($R0) + + GoTo SuccessfulOption + +;*********************************************************************** +; +;*********************************************************************** +BindingAdapter =+ + Set Error = "Binding: Sorry, not yet implemented." + GoTo FatalError + +;*********************************************************************** +; +;*********************************************************************** +RemoveAdapter = + + IfStr(i) $(ProductKeyName) == $(!NTN_RegBase) + Shell $(UtilityInf), RemoveSoftwareComponent, $(Manufacturer), + + $(ProductSoftwareName) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + GoTo FatalRegistry + EndIf + Else + Shell $(UtilityInf), RemoveHardwareComponent, $(Manufacturer), + + $(ProductSoftwareName), $(!NTN_RegBase) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + GoTo FatalRegistry + EndIf + EndIf + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +UpgradeSoftware = + + IfStr(i) $(ProductKeyName) == $(!NTN_RegBase) + OpenRegKey $(!REG_H_LOCAL) "" $(ProductKeyName) $(MAXIMUM_ALLOWED) KeyProduct + IfStr $(KeyProduct) != $(KeyNull) + GetRegValue $(KeyProduct),"MajorVersion", VersionInfo + Set Version = *($(VersionInfo), 4) + Shell $(UtilityInf), GetInfFileNameFromRegistry, $(KeyProduct) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + Set !UG_Filename = $($R0) + IfStr(i) $(!UG_Filename) != "" + install "Install-Update" + IfStr(i) $(STF_INSTALL_OUTCOME) != STF_SUCCESS + GoTo FatalError + EndIf + EndIf + SetRegValue $(KeyProduct) {MajorVersion,$(NoTitle),$(!REG_VT_SZ),$(ProductMajorVersion)} + SetRegValue $(KeyProduct) {MinorVersion,$(NoTitle),$(!REG_VT_SZ),$(ProductMinorVersion)} + IfInt $(Version) != $(ProductVersion) + EndIf + CloseRegKey $(KeyProduct) + Else + GoTo FatalRegistry + EndIf + Else + OpenRegKey $(!REG_H_LOCAL) "" $(!NTN_RegBase) + + $(MAXIMUM_ALLOWED) NetworkCardKey + IfStr(i) $(NetworkCardKey) != $(KeyNull) + GetRegValue $(NetworkCardKey),"ServiceName", ServiceNameInfo + Set ServiceName = *($(ServiceNameInfo), 4) + OpenRegKey $(NetworkCardKey) "" "NetRules" + + $(MAXIMUM_ALLOWED) NetRuleKey + IfStr(i) $(NetRuleKey) != $(KeyNull) + Else + GoTo FatalRegistry + EndIf + CloseRegKey $(NetRules) + CloseRegKey $(NetworkCardKey) + Else + GoTo FatalRegistry + EndIf + OpenRegKey $(!REG_H_LOCAL) "" + + $(!NTN_ServiceBase)"\"$(ServiceName) + + $(MAXIMUM_ALLOWED) ServiceKey + IfStr(i) $(ServiceKey) != $(KeyNull) + CloseRegKey $(ServiceKey) + Else + GoTo FatalRegistry + EndIf + EndIf + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +SuccessfulOption = + + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +Abandon = + + ForListDo $(OEM_ABANDON_OPTIONS) + Shell $(UtilityInf), RemoveHardwareComponent, $(Manufacturer), + + $(ProductSoftwareName), $($) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + GoTo FatalRegistry + EndIf + EndForListDo + IfStr(i) $(OEM_ABANDON_SOFTWARE) == TRUE + Shell $(UtilityInf), RemoveSoftwareComponent, $(Manufacturer), + + $(ProductSoftwareName), FALSE + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error" + GoTo ShellCodeError + EndIf + Set RegistryErrorIndex = $($R0) + IfStr(i) $(RegistryErrorIndex) != NO_ERROR + GoTo FatalRegistry + EndIf + EndIf + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +WarningMsg = + + Shell $(subroutineinf) SetupMessage, $(!STF_LANGUAGE), "WARNING", $(Error) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + IfStr(i) $($R1) == "OK" + GoTo $(to) + Else-IfStr(i) $($R1) == "CANCEL" + GoTo $(from) + EndIf + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +NonFatalInfo = + + Set Severity = STATUS + Set CommonStatus = STATUS_USERCANCEL + IfStr(i) $(Error) == "" + Set Severity = NONFATAL + Shell $(UtilityInf) RegistryErrorString "SETUP_FAIL" + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + Set Error = $($R0) + EndIf + Shell $(subroutineinf) SetupMessage, $(!STF_LANGUAGE), $(Severity), $(Error) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + IfStr(i) $($R1) == "OK" + GoTo $(from) + EndIf + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +FatalRegistry = + + Shell $(UtilityInf) RegistryErrorString $(RegistryErrorIndex) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + Set Error = $($R0) + GoTo FatalError + +;*********************************************************************** +; +;*********************************************************************** +FatalDetect = + + Shell $(UtilityInf),RegistryErrorString,CANNOT_DETECT + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + Debug-Output $(InfName)": ShellCode error: cannot get an error string." + GoTo ShellCodeError + EndIf + Set Error = $($R0) + GoTo FatalError + +;*********************************************************************** +; +;*********************************************************************** +FatalError = + + IfStr(i) $(Error) == "" + Shell $(UtilityInf) RegistryErrorString "SETUP_FAIL" + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + Set Error = $($R0) + EndIf + Shell $(subroutineinf) SetupMessage, $(!STF_LANGUAGE), "FATAL", $(Error) + IfInt $($ShellCode) != $(!SHELL_CODE_OK) + GoTo ShellCodeError + EndIf + GoTo SetFailed + +;*********************************************************************** +; +;*********************************************************************** +ShellCodeError = + + Set DlgType = "MessageBox" + Set STF_MB_TITLE = $(ShellCodeErrorTitle) + Set STF_MB_TEXT = $(ShellCodeErrorText) + Set STF_MB_TYPE = 1 + Set STF_MB_ICON = 3 + Set STF_MB_DEF = 1 + UI Start "Error Message" + GoTo SetFailed + +;*********************************************************************** +; +;*********************************************************************** +SetFailed = + + Set CommonStatus = STATUS_FAILED + IfStr(i) $(OEM_ABANDON_ON) == TRUE + Set OEM_ABANDON_ON = FALSE + GoTo Abandon + EndIf + GoTo end + +;*********************************************************************** +; +;*********************************************************************** +end = + + Set !DebugOutputControl = $(OldDebugControl) + Return $(CommonStatus) + +;*********************************************************************** +; +;*********************************************************************** +[HtCreateRegKey] + Debug-Output $(InfName)": Entering [HtCreateRegKey]" + Set ECR_Result = NO_ERROR + Set ECR_BaseKeyHandle = $($0) + Set ECR_NewPath = $($1) + Set KeyNull = "" + Set MAXIMUM_ALLOWED = 33554432 + + Debug-Output $(InfName)": HtCreateRegKey - ECR_BaseKeyHandle = "$(ECR_BaseKeyHandle) + Debug-Output $(InfName)": ECR_NewPath = "$(ECR_NewPath) + Debug-Output $(InfName)": MAXIMUM_ALLOWED = "$(MAXIMUM_ALLOWED) + Debug-Output $(InfName)": KeyNull = "$(KeyNull) + + OpenRegKey $(ECR_BaseKeyHandle) "" $(ECR_NewPath) $(MAXIMUM_ALLOWED) + + ECR_BaseKey + Debug-Output $(InfName)": ECR_BaseKey = "$(ECR_BaseKey) + Debug-Output $(InfName)": OpenRegKey returned "$($R0) + IfStr $(ECR_BaseKey) == $(KeyNull) + Debug-Output $(InfName)": ECR_BaseKey == KeyNull" + Else + Debug-Output $(InfName)": ECR_BaseKey != KeyNull" + Set ECR_KeyHandle = $(ECR_BaseKey) + GoTo ECR_Return + EndIf + + Set ECR_TmpPath = "" + Split-String $(ECR_NewPath) "\" ECR_PList + Debug-Output $(InfName)": ECR_PList = "$(ECR_PList) + ForListDo $(ECR_PList) + IfStr(i) $($) != "\" + IfInt $(#) == 1 + Set ECR_TmpPath = $($) + Else + Set ECR_TmpPath = $(ECR_TmpPath)"\"$($) + EndIf + Debug-Output $(InfName)": Determining if "$(ECR_TmpPath)" exists" + OpenRegKey $(ECR_BaseKeyHandle) "" $(ECR_TmpPath) $(MAXIMUM_ALLOWED) ECR_BaseKey + IfStr $(ECR_BaseKey) == $(KeyNull) + Debug-Output $(InfName)": Creating "$(ECR_TmpPath) + CreateRegKey $(ECR_BaseKeyHandle) {$(ECR_TmpPath),0,GenericClass} "" $(MAXIMUM_ALLOWED) "" ECR_KeyHandle + IfStr(i) $(ECR_KeyHandle) == $(KeyNull) + Set ECR_Result = $($R0) + GoTo ECR_Return + EndIf + EndIf + EndIf + EndForListDo +ECR_Return = + + Return $(ECR_Result) $(ECR_KeyHandle) + +;*********************************************************************** +; +;*********************************************************************** +[DebugConfiguration] + Debug-Output $(!p:InfName)": **CONFIGURATION STATE: "$($0) + Debug-Output $(!p:InfName)": InterruptNumber is "$(!p:InterruptNumber) + Debug-Output $(!p:InfName)": RamBaseAddress is "$(!p:RamBaseAddress) + Debug-Output $(!p:InfName)": LineType is "$(!p:LineType) + Debug-Output $(!p:InfName)": LineRate is "$(!p:LineRate) + Return + +;*********************************************************************** +; +;*********************************************************************** +[Install-Option] + Set STF_VITAL = "" + IfStr(i) $(AddCopy) == "YES" + AddSectionFilesToCopyList Files-$(Option) $(SrcDir) $(!STF_WINDOWSSYSPATH)\drivers + EndIf + IfStr(i) $(DoCopy) == "YES" + Set !STF_NCPA_FLUSH_COPYLIST = TRUE + CopyFilesInCopyList + EndIf + Exit + +;*********************************************************************** +; +;*********************************************************************** +[Install-Update] + Set STF_VITAL = "" + Set STF_OVERWRITE = "VERIFYSOURCEOLDER" + AddSectionFilesToCopyList Files-$(Option) $(SrcDir) $(!STF_WINDOWSSYSPATH)\drivers + AddSectionFilesToCopyList Files-Inf $(SrcDir) $(!STF_WINDOWSSYSPATH) + Set !STF_NCPA_FLUSH_COPYLIST = TRUE + CopyFilesInCopyList + Exit + +;*********************************************************************** +; +;*********************************************************************** +[Source Media Descriptions] + 1 = "Windows NT Setup Disk #1" , TAGFILE = HTDSU41.SYS + +;*********************************************************************** +; +;*********************************************************************** +[ProductType] + STF_PRODUCT = Winnt + STF_PLATFORM = I386 + +;*********************************************************************** +; +;*********************************************************************** +[Files-Inf] + 1, oemsetup.inf, SIZE=1000, RENAME=$(!UG_Filename) + +;*********************************************************************** +; +;*********************************************************************** +[Files-HTDSU41] + 1, HTDSU41.SYS, SIZE=65536 + +;*********************************************************************** +; +;*********************************************************************** +[LanguagesSupported] + ENG + +;*********************************************************************** +; +;*********************************************************************** +[OptionsTextENG] + HTDSU41 = "HT Communications DSU41" +; HTDSU42 = "HT Communications DSU42" + +;*********************************************************************** +; +;*********************************************************************** +[FileConstantsENG] + ProCaption = "Windows NT Setup" + ProCancel = "Cancel" + ProCancelMsg = "Windows NT Networking is not correctly installed. "+ + "Are you sure you want to cancel copying files?" + ProCancelCap = "Network Setup Message" + ProText1 = "Copying:" + ProText2 = "To:" + + FunctionTitleHTDSU41 = "HT Communications DSU41 Card Setup" + ProductSoftwareDescription = "HT Communications DSU41 Driver" + ProductHardwareHTDSU41Description = "HT Communications DSU41" + ProductSoftwareTitle = "HT Communications DSU41 Driver" + ProductHardwareHTDSU41Title = "HT Communications DSU41 Adapter" + + ShellCodeErrorTitle = "Error: "$(FunctionTitle)$(Option)) + ShellCodeErrorText = "Shell Code Error." + +;*********************************************************************** +; +;*********************************************************************** +[DialogConstantsENG] + Help = "&Help" + Exit = "Cancel" + OK = "OK" + HelpContext = "" + Continue = "Continue" + Cancel = "Cancel" + +;*********************************************************************** +; +;*********************************************************************** +[FileDependentDlgENG] + DlgType = "MultiCombo" + DlgTemplate = "WD" + Caption = $(FunctionTitle)$(Option) + + Combo1Label = "&IRQ Level:" + Combo1List = $(IRQ_List) + Combo1Out = $(InterruptNumber) + + Combo2Label = "&RAM Base Address:" + Combo2List = $(RAM_Hex_List) + Combo2Out = $(RAM_Hex_Value) + + Combo3Label = "&Transmit Rate:" + Combo3List = $(Rate_Strings) + Combo3Out = $(RateString) + + ComboListItemsIn = {Combo1List, Combo2List, Combo3List} + ComboListItemsOut = {Combo1Out, Combo2Out, Combo3Out} + EditTextIn = "" + EditTextLim = "" + CBOptionsGreyed = {} + NotifyFields = {NO, NO, NO} +; HelpContext = $(!IDH_DB_OEMNAD1_INS) + +;*********************************************************************** +; +;*********************************************************************** +[InvokeRasDlgENG] + InvokeRasSetupMsg = "HT Communications DSU41 setup is complete. "+ + "Remote Access Services (RAS) must now be installed. "+ + "Please configure the HTDSU41Sw56 ports in RAS "+ + "setup to enable you to use RAS over the HTDSU41." + InvokeRasConfigMsg = "HT Communications DSU41 setup is complete. "+ + "Remote Access Services (RAS) setup must now be invoked. "+ + "Please configure the HTDSU41Sw56 ports in RAS "+ + "setup to enable you to use RAS over the HTDSU41." + InvokeRasAgainMsg = "HT Communications DSU41 setup is NOT complete! "+ + "Remote Access Services (RAS) is not configured to use a "+ + "HTDSU41Sw56 port. You must configure at least one HTDSU41Sw56 "+ + "port in RAS setup now, or you will have reconfigure the adapter "+ + "before running RAS configuration again later." + InvokeRasError = "HT Communications DSU41 setup encountered an error "+ + "while invoking the RAS setup INF file (OEMNSVRA.INF). "+ + "Please make sure that the file is present in the "+ + "System32 directory and is the proper file." + diff --git a/private/ntos/ndis/htdsu/receive.c b/private/ntos/ndis/htdsu/receive.c new file mode 100644 index 000000000..08ddb1ab9 --- /dev/null +++ b/private/ntos/ndis/htdsu/receive.c @@ -0,0 +1,199 @@ +/***************************************************************************\ +|* 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: + + receive.c + +Abstract: + + This module contains the Miniport packet receive routines. + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 6 // Unique file ID for error logging + +#include "htdsu.h" + + +VOID +HtDsuReceivePacket( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Routine Description: + + This routine is called from HtDsuHandleInterrupt to handle a + packet receive interrupt. We enter here with interrupts enabled + on the adapter and the processor, but the Adapter->Lock is held. + + We examine the adapter memory beginning where the adapter would have + stored the next packet. + As we find each good packet it is passed up to the protocol stack. + This code assumes that the receive buffer holds a single packet. + + NOTE: The Adapter->Lock must be held before calling this routine. + +Arguments: + + Adapter _ A pointer ot our adapter information structure. + +Return Value: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuReceivePacket") + + NDIS_STATUS Status; + + /* + // A pointer to our link information structure for the selected line device. + */ + PHTDSU_LINK Link; + + /* + // Holds the card line number on which the packet is received. + */ + USHORT CardLine; + + /* + // How many bytes were received in this packet. + */ + USHORT BytesReceived; + + /* + // Non-zero if there were any errors detected in the packet. + */ + USHORT RxErrors; + + DBG_ENTER(Adapter); + + /* + // If the packet is good, we pass it up to the protocol stack. + // We just drop bad packets with no indication sent. + */ + CardGetReceiveInfo(Adapter, &CardLine, &BytesReceived, &RxErrors); + + /* + // Don't send any bad packets to the wrapper, just indicate the error. + */ + if (RxErrors) + { + DBG_WARNING(Adapter, ("RxError=%Xh on line %d\n",RxErrors, CardLine)); + + Link = GET_LINK_FROM_CARDLINE(Adapter, CardLine); + + if (RxErrors & HTDSU_CRC_ERROR) + { + LinkLineError(Link, WAN_ERROR_CRC); + } + else + { + LinkLineError(Link, WAN_ERROR_FRAMING); + } + } + else if (BytesReceived) + { +#if DBG + if (Adapter->DbgFlags & (DBG_PACKETS_ON | DBG_HEADERS_ON)) + { + DbgPrint("Rx:%03X:",BytesReceived); + if (Adapter->DbgFlags & DBG_PACKETS_ON) + DbgPrintData((PUCHAR)&(Adapter->AdapterRam->RxBuffer), BytesReceived+8, 0); + else + DbgPrintData((PUCHAR)&(Adapter->AdapterRam->RxBuffer), 0x10, 0); + } +#endif + /* + // Is there someone up there who cares? + */ + Link = GET_LINK_FROM_CARDLINE(Adapter, CardLine); + + if (Link->NdisLinkContext == NULL) + { + DBG_WARNING(Adapter, ("Packet recvd on disconnected line #%d",CardLine)); + } + else + { + /* + // We have to copy the data to a system buffer so it can be + // accessed one byte at a time by the protocols. + // The adapter memory only supports word wide access. + */ + { + // FIXME - can I use this much stack space? + USHORT TempBuf[HTDSU_MAX_PACKET_SIZE / sizeof(USHORT) + 1]; + + READ_REGISTER_BUFFER_USHORT( + &Adapter->AdapterRam->RxBuffer.Data[0], + &TempBuf[0], + (UINT)((BytesReceived + 1) / sizeof(USHORT)) + ); + + /* + // Spec sez we have to release the spinlock before calling + // up to indiciate the packet. + */ + NdisReleaseSpinLock(&Adapter->Lock); + + NdisMWanIndicateReceive( + &Status, + Adapter->MiniportAdapterHandle, + Link->NdisLinkContext, + (PUCHAR) TempBuf, + BytesReceived + ); + } + + /* + // Indicate receive complete if we had any that were accepted. + */ + if (Status == NDIS_STATUS_SUCCESS) + { + NdisMWanIndicateReceiveComplete( + Adapter->MiniportAdapterHandle, + Link->NdisLinkContext + ); + } + else + { + DBG_WARNING(Adapter,("NdisMWanIndicateReceive returned error 0x%X\n", + Status)); + } + + NdisAcquireSpinLock(&Adapter->Lock); + } + } + + /* + // Tell the adapter we have processed this packet so it can re-use the + // buffer. + */ + CardReceiveComplete(Adapter); + + DBG_LEAVE(Adapter); +} + diff --git a/private/ntos/ndis/htdsu/request.c b/private/ntos/ndis/htdsu/request.c new file mode 100644 index 000000000..7f9dd80c1 --- /dev/null +++ b/private/ntos/ndis/htdsu/request.c @@ -0,0 +1,661 @@ +/***************************************************************************\ +|* 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: + + request.c + +Abstract: + + This module implements the NDIS request routines for the Miniport driver. + MiniportQueryInformation() + MiniportSetInformation() + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 5 // Unique file ID for error logging + +#include "htdsu.h" + +/* +// The following is a list of all the possible NDIS QuereyInformation requests +// that might be directed to the miniport. +// Comment out any that are not supported by this driver. +*/ +static const NDIS_OID SupportedOidArray[] = +{ + OID_GEN_HARDWARE_STATUS, + OID_GEN_MEDIA_SUPPORTED, + OID_GEN_MEDIA_IN_USE, + OID_GEN_MAXIMUM_LOOKAHEAD, + OID_GEN_MAXIMUM_FRAME_SIZE, + OID_GEN_MAXIMUM_TOTAL_SIZE, + OID_GEN_MAC_OPTIONS, + OID_GEN_LINK_SPEED, + OID_GEN_TRANSMIT_BUFFER_SPACE, + OID_GEN_RECEIVE_BUFFER_SPACE, + OID_GEN_TRANSMIT_BLOCK_SIZE, + OID_GEN_RECEIVE_BLOCK_SIZE, + OID_GEN_VENDOR_ID, + OID_GEN_VENDOR_DESCRIPTION, + OID_GEN_DRIVER_VERSION, + OID_GEN_CURRENT_LOOKAHEAD, + + OID_WAN_MEDIUM_SUBTYPE, + OID_WAN_GET_INFO, + OID_WAN_PERMANENT_ADDRESS, + OID_WAN_CURRENT_ADDRESS, + OID_WAN_GET_LINK_INFO, + OID_WAN_SET_LINK_INFO, +#ifdef FUTURE_OIDS + OID_WAN_QUALITY_OF_SERVICE, + OID_WAN_PROTOCOL_TYPE, + OID_WAN_HEADER_FORMAT, + OID_WAN_LINE_COUNT, + OID_WAN_GET_BRIDGE_INFO, + OID_WAN_SET_BRIDGE_INFO, + OID_WAN_GET_COMP_INFO, + OID_WAN_SET_COMP_INFO, +#endif // FUTURE_OIDS + 0 +}; + +#if DBG + +/* +// Make sure the following list is in the same order as the list above! +*/ +static char *SupportedOidNames[] = +{ + "OID_GEN_HARDWARE_STATUS", + "OID_GEN_MEDIA_SUPPORTED", + "OID_GEN_MEDIA_IN_USE", + "OID_GEN_MAXIMUM_LOOKAHEAD", + "OID_GEN_MAXIMUM_FRAME_SIZE", + "OID_GEN_MAXIMUM_TOTAL_SIZE", + "OID_GEN_MAC_OPTIONS", + "OID_GEN_LINK_SPEED", + "OID_GEN_TRANSMIT_BUFFER_SPACE", + "OID_GEN_RECEIVE_BUFFER_SPACE", + "OID_GEN_TRANSMIT_BLOCK_SIZE", + "OID_GEN_RECEIVE_BLOCK_SIZE", + "OID_GEN_VENDOR_ID", + "OID_GEN_VENDOR_DESCRIPTION", + "OID_GEN_DRIVER_VERSION", + "OID_GEN_CURRENT_LOOKAHEAD", + + "OID_WAN_MEDIUM_SUBTYPE", + "OID_WAN_GET_INFO", + "OID_WAN_PERMANENT_ADDRESS", + "OID_WAN_CURRENT_ADDRESS", + "OID_WAN_GET_LINK_INFO", + "OID_WAN_SET_LINK_INFO", +#ifdef FUTURE_OIDS + "OID_WAN_QUALITY_OF_SERVICE", + "OID_WAN_PROTOCOL_TYPE", + "OID_WAN_HEADER_FORMAT", + "OID_WAN_LINE_COUNT", + "OID_WAN_GET_BRIDGE_INFO", + "OID_WAN_SET_BRIDGE_INFO", + "OID_WAN_GET_COMP_INFO", + "OID_WAN_SET_COMP_INFO", +#endif // FUTURE_OIDS + "OID_UNKNOWN" +}; + +#define NUM_OID_ENTRIES (sizeof(SupportedOidArray) / sizeof(SupportedOidArray[0])) + +/* +// This debug routine will lookup the printable name for the selected OID. +*/ +char * +HtGetOidString(NDIS_OID Oid) +{ + UINT i; + + for (i = 0; i < NUM_OID_ENTRIES-1; i++) + { + if (SupportedOidArray[i] == Oid) + { + break; + } + } + return(SupportedOidNames[i]); +} + +#endif // DBG + +/* +// Returned from an OID_WAN_PERMANENT_ADDRESS HtDsuQueryInformation request. +// The WAN wrapper wants the miniport to return a unique address for this +// adapter. This is used as an ethernet address presented to the protocols. +// The least significant bit of the first byte must not be a 1, or it could +// be interpreted as an ethernet multicast address. If the vendor has an +// assigned ethernet vendor code (the first 3 bytes), they should be used +// to assure that the address does not conflict with another vendor's address. +// The last digit is replaced during the call with the adapter instance number. +*/ +static UCHAR HtDsuWanAddress[6] = {'H','t','D','s','u','0'}; + +/* +// Returned from an OID_GEN_VENDOR_ID HtDsuQueryInformation request. +// Again, the vendor's assigned ethernet vendor code should be used if possible. +*/ +static UCHAR HtDsuVendorID[4] = HTDSU_VENDOR_ID; + +/* +// Returned from an OID_GEN_VENDOR_DESCRIPTION HtDsuQueryInformation request. +// This is an arbitrary string which may be used by upper layers to present +// a user friendly description of the adapter. +*/ +static UCHAR HtDsuVendorDescription[] = HTDSU_VENDOR_DESCRPTION; + + +NDIS_STATUS +HtDsuQueryInformation( + IN PHTDSU_ADAPTER Adapter, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesWritten, + OUT PULONG BytesNeeded + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportQueryInformation request allows the inspection of the + Miniport driver's capabilities and current 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. + + Note that the wrapper will intercept all queries of the following OIDs: + OID_GEN_CURRENT_PACKET_FILTER, + OID_GEN_PROTOCOL_OPTIONS, + OID_802_5_CURRENT_FUNCTIONAL, + OID_802_3_MULTICAST_LIST, + OID_FDDI_LONG_MULTICAST_LIST, + OID_FDDI_SHORT_MULTICAST_LIST. + + Interrupts are in any state during this call. + +Parameters: + + MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes + during MiniportInitialize. + + Oid _ The OID. (See section 7.4 of the NDIS 3.0 specification for a + complete description of OIDs.) + + InformationBuffer _ The buffer that will receive the information. + (See section 7.4 of the NDIS 3.0 specification + for a description of the length required for each + OID.) + + 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("HtDsuQueryInformation") + + /* + // Holds the status result returned by this function. + */ + NDIS_STATUS Status = NDIS_STATUS_NOT_SUPPORTED; + + /* + // Pointer to driver data to be copied back to caller's InformationBuffer + */ + PVOID SourceBuffer; + + /* + // Number of bytes to be copied from driver. + */ + ULONG SourceBufferLength; + + /* + // Most return values are long integers, so this is used to hold the + // return value of a constant or computed result. + */ + ULONG GenericUlong = 0; + + /* + // Like above, only short. + */ + USHORT GenericUshort; + + /* + // If this is a TAPI OID, pass it on over. + */ + if ((Oid & 0xFFFFFF00L) == (OID_TAPI_ACCEPT & 0xFFFFFF00L)) + { + Status = HtTapiQueryInformation(Adapter, + Oid, + InformationBuffer, + InformationBufferLength, + BytesWritten, + BytesNeeded + ); + return (Status); + } + + DBG_ENTER(Adapter); + DBG_FILTER(Adapter,DBG_REQUEST_ON, + ("(OID=%s=%08x)\n\t\tInfoLength=%d InfoBuffer=%Xh\n", + HtGetOidString(Oid),Oid, + InformationBufferLength, + InformationBuffer + )); + + /* + // Initialize these once, since this is the majority of cases. + */ + SourceBuffer = &GenericUlong; + SourceBufferLength = sizeof(ULONG); + + /* + // Determine which OID is being requested and do the right thing. + // Refer to section 7.4 of the NDIS 3.0 specification for a complete + // description of OIDs and their return values. + */ + switch (Oid) + { + case OID_GEN_HARDWARE_STATUS: + GenericUlong = Adapter->NeedReset ? + NdisHardwareStatusNotReady : + NdisHardwareStatusReady; + break; + + case OID_GEN_MEDIA_SUPPORTED: + GenericUlong = NdisMediumWan; + break; + + case OID_GEN_MEDIA_IN_USE: + GenericUlong = NdisMediumWan; + break; + + case OID_GEN_MAXIMUM_LOOKAHEAD: + GenericUlong = HTDSU_MAX_LOOKAHEAD; + break; + + case OID_GEN_MAXIMUM_FRAME_SIZE: + GenericUlong = HTDSU_MAX_FRAME_SIZE; + break; + + case OID_GEN_LINK_SPEED: + GenericUlong = HTDSU_LINK_SPEED; + break; + + case OID_GEN_TRANSMIT_BUFFER_SPACE: + GenericUlong = HTDSU_MAX_PACKET_SIZE; + break; + + case OID_GEN_RECEIVE_BUFFER_SPACE: + GenericUlong = HTDSU_MAX_PACKET_SIZE; + break; + + case OID_GEN_TRANSMIT_BLOCK_SIZE: + GenericUlong = HTDSU_MAX_PACKET_SIZE; + break; + + case OID_GEN_RECEIVE_BLOCK_SIZE: + GenericUlong = HTDSU_MAX_PACKET_SIZE; + break; + + case OID_GEN_VENDOR_ID: + SourceBuffer = HtDsuVendorID; + SourceBufferLength = sizeof(HtDsuVendorID); + break; + + case OID_GEN_VENDOR_DESCRIPTION: + SourceBuffer = HtDsuVendorDescription; + SourceBufferLength = strlen(HtDsuVendorDescription) + 1; + break; + + case OID_GEN_CURRENT_LOOKAHEAD: + GenericUlong = HTDSU_MAX_LOOKAHEAD; + break; + + case OID_GEN_MAC_OPTIONS: + GenericUlong = NDIS_MAC_OPTION_RECEIVE_SERIALIZED | + NDIS_MAC_OPTION_NO_LOOPBACK | + NDIS_MAC_OPTION_TRANSFERS_NOT_PEND; + break; + + case OID_GEN_DRIVER_VERSION: + GenericUshort = (NDIS_MAJOR_VERSION << 8) + NDIS_MINOR_VERSION; + SourceBuffer = &GenericUshort; + SourceBufferLength = sizeof(USHORT); + break; + + case OID_GEN_MAXIMUM_TOTAL_SIZE: + GenericUlong = HTDSU_MAX_PACKET_SIZE; + break; + + case OID_WAN_MEDIUM_SUBTYPE: + GenericUlong = NdisWanMediumSW56K; + break; + + case OID_WAN_GET_INFO: + SourceBuffer = &Adapter->WanInfo; + SourceBufferLength = sizeof(NDIS_WAN_INFO); + break; + + case OID_WAN_PERMANENT_ADDRESS: + case OID_WAN_CURRENT_ADDRESS: + HtDsuWanAddress[5] = Adapter->InstanceNumber + '0'; + SourceBuffer = HtDsuWanAddress; + SourceBufferLength = sizeof(HtDsuWanAddress); + break; + + case OID_WAN_GET_LINK_INFO: + { + /* + // The first field in the info buffer is a MiniportLinkContext + // which is really a pointer to an entry in our link information. + // If this aint so, bail out... + */ + PHTDSU_LINK Link = (PHTDSU_LINK) + (((PNDIS_WAN_SET_LINK_INFO)InformationBuffer)->NdisLinkHandle); + + if (!IS_VALID_LINK(Adapter, Link)) + { + SourceBufferLength = 0; + Status = NDIS_STATUS_INVALID_DATA; + break; + } + + DBG_NOTICE(Adapter,("Returning:\n" + "NdisLinkHandle = %08lX\n" + "MaxSendFrameSize = %08lX\n" + "MaxRecvFrameSize = %08lX\n" + "SendFramingBits = %08lX\n" + "RecvFramingBits = %08lX\n" + "SendACCM = %08lX\n" + "RecvACCM = %08lX\n", + Link->WanLinkInfo.NdisLinkHandle , + Link->WanLinkInfo.MaxSendFrameSize , + Link->WanLinkInfo.MaxRecvFrameSize , + Link->WanLinkInfo.SendFramingBits , + Link->WanLinkInfo.RecvFramingBits , + Link->WanLinkInfo.SendACCM , + Link->WanLinkInfo.RecvACCM )); + + SourceBuffer = &(Link->WanLinkInfo); + SourceBufferLength = sizeof(NDIS_WAN_GET_LINK_INFO); + } + break; + + default: + /* + // Unknown OID + */ + Status = NDIS_STATUS_INVALID_OID; + SourceBufferLength = 0; + break; + } + + /* + // Now we copy the data into the caller's buffer if there's enough room, + // otherwise, we report the error and tell em how much we need. + */ + if (SourceBufferLength > InformationBufferLength) + { + *BytesNeeded = SourceBufferLength; + Status = NDIS_STATUS_INVALID_LENGTH; + } + else if (SourceBufferLength) + { + NdisMoveMemory(InformationBuffer, + SourceBuffer, + SourceBufferLength + ); + *BytesNeeded = *BytesWritten = SourceBufferLength; + Status = NDIS_STATUS_SUCCESS; + } + else + { + *BytesNeeded = *BytesWritten = 0; + } + DBG_FILTER(Adapter,DBG_REQUEST_ON, + ("RETURN: Status=%Xh Needed=%d Written=%d\n", + Status, *BytesNeeded, *BytesWritten)); + DBG_LEAVE(Adapter); + + return (Status); +} + + +NDIS_STATUS +HtDsuSetInformation( + IN PHTDSU_ADAPTER Adapter, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesRead, + OUT PULONG BytesNeeded + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The MiniportSetInformation request allows for control of the Miniport + by changing information maintained by the Miniport driver. + + Any of the settable NDIS Global Oids may be used. (see section 7.4 of + the NDIS 3.0 specification for a complete description of the NDIS Oids.) + + 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 7.4 of the NDIS 3.0 specification for + a complete description of OIDs.) + + InformationBuffer _ The buffer that will receive the information. + (See section 7.4 of the NDIS 3.0 specification for + a description of the length required for each OID.) + + 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("HtDsuSetInformation") + + /* + // Holds the status result returned by this function. + */ + NDIS_STATUS Status; + + /* + // If this is a TAPI OID, pass it on over. + */ + if ((Oid & 0xFFFFFF00L) == (OID_TAPI_ACCEPT & 0xFFFFFF00L)) + { + Status = HtTapiSetInformation(Adapter, + Oid, + InformationBuffer, + InformationBufferLength, + BytesRead, + BytesNeeded + ); + return (Status); + } + + DBG_ENTER(Adapter); + DBG_FILTER(Adapter,DBG_REQUEST_ON, + ("(OID=%s=%08x)\n\t\tInfoLength=%d InfoBuffer=%Xh\n", + HtGetOidString(Oid),Oid, + InformationBufferLength, + InformationBuffer + )); + + /* + // Assume no extra bytes are needed. + */ + ASSERT(BytesRead && BytesNeeded); + *BytesRead = 0; + *BytesNeeded = 0; + + /* + // Determine which OID is being requested and do the right thing. + */ + switch (Oid) + { + case OID_GEN_CURRENT_LOOKAHEAD: + /* + // WAN drivers always indicate the entire packet regardless of the + // lookahead size. So this request should be politely ignored. + */ + DBG_NOTICE(Adapter,("OID_GEN_CURRENT_LOOKAHEAD: set=%d expected=%d\n", + *(PULONG) InformationBuffer, HTDSU_MAX_LOOKAHEAD)); + ASSERT(InformationBufferLength == sizeof(ULONG)); + *BytesNeeded = *BytesRead = sizeof(ULONG); + Status = NDIS_STATUS_SUCCESS; + break; + + case OID_WAN_SET_LINK_INFO: + + if (InformationBufferLength == sizeof(NDIS_WAN_SET_LINK_INFO)) + { + /* + // The first field in the info buffer is a MiniportLinkContext + // which is really a pointer to an entry in our WanLinkArray. + // If this aint so, bail out... + */ + PHTDSU_LINK Link = (PHTDSU_LINK) + (((PNDIS_WAN_SET_LINK_INFO)InformationBuffer)->NdisLinkHandle); + + if (Link == NULL) + { + Status = NDIS_STATUS_INVALID_DATA; + break; + } + + ASSERT(Link->WanLinkInfo.NdisLinkHandle == Link); + ASSERT(Link->WanLinkInfo.MaxSendFrameSize <= Adapter->WanInfo.MaxFrameSize); + ASSERT(Link->WanLinkInfo.MaxRecvFrameSize <= Adapter->WanInfo.MaxFrameSize); + ASSERT(!(Link->WanLinkInfo.SendFramingBits & ~Adapter->WanInfo.FramingBits)); + ASSERT(!(Link->WanLinkInfo.RecvFramingBits & ~Adapter->WanInfo.FramingBits)); + + /* + // Copy the data into our WanLinkInfo sturcture. + */ + NdisMoveMemory(&(Link->WanLinkInfo), + InformationBuffer, + InformationBufferLength + ); + *BytesRead = sizeof(NDIS_WAN_SET_LINK_INFO); + Status = NDIS_STATUS_SUCCESS; + + DBG_NOTICE(Adapter,("\n setting expected\n" + "NdisLinkHandle = %08lX=?=%08lX\n" + "MaxSendFrameSize = %08lX=?=%08lX\n" + "MaxRecvFrameSize = %08lX=?=%08lX\n" + "SendFramingBits = %08lX=?=%08lX\n" + "RecvFramingBits = %08lX=?=%08lX\n" + "SendACCM = %08lX=?=%08lX\n" + "RecvACCM = %08lX=?=%08lX\n", + Link->WanLinkInfo.NdisLinkHandle , Link, + Link->WanLinkInfo.MaxSendFrameSize , Adapter->WanInfo.MaxFrameSize, + Link->WanLinkInfo.MaxRecvFrameSize , Adapter->WanInfo.MaxFrameSize, + Link->WanLinkInfo.SendFramingBits , Adapter->WanInfo.FramingBits, + Link->WanLinkInfo.RecvFramingBits , Adapter->WanInfo.FramingBits, + Link->WanLinkInfo.SendACCM , Adapter->WanInfo.DesiredACCM, + Link->WanLinkInfo.RecvACCM , Adapter->WanInfo.DesiredACCM)); + } + else + { + DBG_WARNING(Adapter, ("OID_WAN_SET_LINK_INFO: Invalid size:%d expected:%d\n", + InformationBufferLength, sizeof(NDIS_WAN_SET_LINK_INFO))); + Status = NDIS_STATUS_INVALID_LENGTH; + } + *BytesNeeded = sizeof(NDIS_WAN_SET_LINK_INFO); + break; + + default: + /* + // Unknown OID + */ + Status = NDIS_STATUS_INVALID_OID; + break; + } + DBG_FILTER(Adapter,DBG_REQUEST_ON, + ("RETURN: Status=%Xh Needed=%d Read=%d\n", + Status, *BytesNeeded, *BytesRead)); + DBG_LEAVE(Adapter); + + return (Status); +} + diff --git a/private/ntos/ndis/htdsu/send.c b/private/ntos/ndis/htdsu/send.c new file mode 100644 index 000000000..575983bf0 --- /dev/null +++ b/private/ntos/ndis/htdsu/send.c @@ -0,0 +1,502 @@ +/***************************************************************************\ +|* 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: + + send.c + +Abstract: + + This module contains the Miniport packet send routines. + + This driver conforms to the NDIS 3.0 Miniport interface. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Windows NT 3.5 kernel mode Miniport driver or equivalent. + +Revision History: + +---------------------------------------------------------------------------*/ + +#define __FILEID__ 7 // Unique file ID for error logging + +#include "htdsu.h" + + +STATIC +BOOLEAN +QueueForTransmit( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_WAN_PACKET Packet + ); + +STATIC +VOID +HtDsuTransmitFrame( + IN PHTDSU_ADAPTER Adapter + ); + + +NDIS_STATUS +HtDsuWanSend( + IN NDIS_HANDLE MacBindingHandle, + IN PHTDSU_LINK Link, + IN PNDIS_WAN_PACKET Packet + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Functional Description: + + The Ndis(M)WanSend instructs a WAN driver to transmit a packet through the + adapter onto the medium. + + Ownership of both the packet descriptor and the packet data is transferred + to the WAN driver until the request is completed, either synchronously or + asynchronously. If the WAN driver returns a status other than + NDIS_STATUS_PENDING, then the request is complete, and ownership of the + packet immediately reverts to the protocol. If the WAN driver returns + NDIS_STATUS_PENDING, then the WAN driver must later indicate completion + of the request by calling Ndis(M)WanSendComplete. + + The WAN driver should NOT return a status of NDIS_STATUS_RESOURCES to + indicate that there are not enough resources available to process the + transmit. Instead, the miniport should queue the send for a later time + or lower the MaxTransmits value. + + The WAN miniport can NOT call NdisMSendResourcesAvailable. + + The packet passed in Ndis(M)WanSend will contain simple HDLC PPP framing + if PPP framing is set. For SLIP or RAS framing, the packet contains only + the data portion with no framing whatsoever. + + A WAN driver must NOT provide software loopback or promiscuous mode + loopback. Both of these are fully provided for in the WAN wrapper. + + NOTE: The MacReservedx section as well as the WanPacketQueue section of + the NDIS_WAN_PACKET is fully available for use by the WAN driver. + + Interrupts are in any state during this routine. + +Parameters: + + MacBindingHandle _ The handle to be passed to NdisMWanSendComplete(). + + NdisLinkHandle _ The Miniport link handle passed to NDIS_LINE_UP + + WanPacket _ A pointer to the NDIS_WAN_PACKET strucutre. The structure + contains a pointer to a contiguous buffer with guaranteed + padding at the beginning and end. The driver may manipulate + the buffer in any way. + + typedef struct _NDIS_WAN_PACKET + { + LIST_ENTRY WanPacketQueue; + PUCHAR CurrentBuffer; + ULONG CurrentLength; + PUCHAR StartBuffer; + PUCHAR EndBuffer; + PVOID ProtocolReserved1; + PVOID ProtocolReserved2; + PVOID ProtocolReserved3; + PVOID ProtocolReserved4; + PVOID MacReserved1; // Link + PVOID MacReserved2; // MacBindingHandle + PVOID MacReserved3; + PVOID MacReserved4; + + } NDIS_WAN_PACKET, *PNDIS_WAN_PACKET; + + The available header padding is simply CurrentBuffer-StartBuffer. + The available tail padding is EndBuffer-(CurrentBuffer+CurrentLength). + +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_SUCCESS + NDIS_STATUS_FAILURE + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuWanSend") + + /* + // The link is associated with the adapter with a back pointer. + */ + PHTDSU_ADAPTER Adapter = Link->Adapter; + + /* + // Tells us how many bytes are to be transmitted. + */ + UINT BytesToSend = Packet->CurrentLength; + + /* + // Holds the status that should be returned to the caller. + */ + NDIS_STATUS StatusToReturn; + + DBG_ENTER(Adapter); + + /* + // We grab the spin lock on entry so we don't accidently stomp on + // some data structure being twiddled with by the DPC or another + // client thread. + */ + NdisAcquireSpinLock(&Adapter->Lock); + + /* + // Make sure the packet size is something we can deal with. + */ + if ((BytesToSend == 0) || (BytesToSend > HTDSU_MAX_PACKET_SIZE)) + { + DBG_ERROR(Adapter,("Bad packet size = %d\n",BytesToSend)); + StatusToReturn = NDIS_STATUS_FAILURE; + } + /* + // Return if line is not connected. + */ + else if (!CardStatusOnLine(Adapter, Link->CardLine)) + { + DBG_ERROR(Adapter, ("Line Disconnected\n")); + StatusToReturn = NDIS_STATUS_FAILURE; + } + /* + // Return if line has been closed. + */ + else if (Link->Closing || Link->CallClosing) + { + DBG_ERROR(Adapter, ("Link Closed\n")); + StatusToReturn = NDIS_STATUS_FAILURE; + } + else + { + /* + // We have to accept the frame if possible, I just want to know + // if somebody has lied to us... + */ + if (BytesToSend > Link->WanLinkInfo.MaxSendFrameSize) + { + DBG_WARNING(Adapter,("Packet size=%d > %d\n", + BytesToSend, Link->WanLinkInfo.MaxSendFrameSize)); + } + + /* + // We'll need to use these when the transmit completes. + */ + Packet->MacReserved1 = (PVOID) Link; + Packet->MacReserved2 = (PVOID) MacBindingHandle; + + /* + // Place the packet in the transmit list. + */ + ++Link->NumTxQueued; + if (QueueForTransmit(Adapter, Packet)) + { + /* + // The queue was empty so we've gotta kick start it. + // Once it's going, it runs off the DPC. + */ + HtDsuTransmitFrame(Adapter); + } + StatusToReturn = NDIS_STATUS_PENDING; + } + + NdisReleaseSpinLock(&Adapter->Lock); + + DBG_LEAVE(Adapter); + + return StatusToReturn; +} + + +STATIC +BOOLEAN +QueueForTransmit( + IN PHTDSU_ADAPTER Adapter, + IN PNDIS_WAN_PACKET Packet + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Routine Description: + + This routine places the packet on the transmit queue. If the queue was + empty to begin with TRUE is returned so the caller can kick start the + transmiter. + + NOTE: The Adapter->Lock must be held before calling this routine. + +Arguments: + + Adapter _ A pointer ot our adapter information structure. + + Packet _ The packet that is to be transmitted. + +Return Value: + + TRUE if this is the only entry in the list; FALSE otherwise. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("QueueForTransmit") + + /* + // Note if the list is empty to begin with. + */ + BOOLEAN ListWasEmpty; + + DBG_ENTER(Adapter); + DBG_FILTER(Adapter, DBG_PARAMS_ON, ("(Packet=0x%08x)\n", Packet)); + + /* + // Place the packet on the transmit queue. + */ + ListWasEmpty = IsListEmpty(&Adapter->TransmitIdleList); + InsertTailList(&Adapter->TransmitIdleList, &Packet->WanPacketQueue); + + DBG_LEAVE(Adapter); + + return (ListWasEmpty); +} + + +STATIC +VOID +HtDsuTransmitFrame( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Routine Description: + + This routine removes an entry from the TransmitIdleList and places the + packet on the adapter and starts transmision. The packet is then placed + on the TransmitBusyList to await a transmit complete interrupt. + + NOTE: The Adapter->Lock must be held before calling this routine. + +Arguments: + + Adapter _ A pointer ot our adapter information structure. + +Return Value: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuTransmitFrame") + + /* + // A pointer to our link information structure for the selected line device. + */ + PHTDSU_LINK Link; + + /* + // Holds the packet being transmitted. + */ + PNDIS_WAN_PACKET Packet; + + /* + // Tells us how many bytes are to be transmitted. + */ + USHORT BytesToSend; + + DBG_ENTER(Adapter); + + /* + // This might be called when no packets are queued! + */ + if (!IsListEmpty(&Adapter->TransmitIdleList) && + !(Adapter->TransmitInProgress)) + { + Adapter->TransmitInProgress = TRUE; + + /* + // The TransmitIdleList contains a list of packets waiting to be + // transmitted. + */ + Packet = (PNDIS_WAN_PACKET)RemoveHeadList(&Adapter->TransmitIdleList); + DBG_FILTER(Adapter,DBG_PARAMS_ON,("(Packet=0x%08x)\n",Packet)); + + Link = (PHTDSU_LINK) Packet->MacReserved1; + + BytesToSend = (USHORT) Packet->CurrentLength; + + /* + // Move the packet data into our mapped memory buffer on the card. + */ + WRITE_REGISTER_BUFFER_USHORT( + &Adapter->AdapterRam->TxBuffer.Data[0], + (PUSHORT) &Packet->CurrentBuffer[0], + (UINT)((BytesToSend + 1) / sizeof(USHORT)) + ); + + /* + // Set the address, length, and closing flag. + */ + CardPrepareTransmit(Adapter, Link->CardLine, BytesToSend); + +#if DBG + if (Adapter->DbgFlags & (DBG_PACKETS_ON | DBG_HEADERS_ON)) + { + DbgPrint("Tx:%03X:", BytesToSend); + if (Adapter->DbgFlags & DBG_PACKETS_ON) + DbgPrintData((PUCHAR)&(Adapter->AdapterRam->TxBuffer), BytesToSend+8, 0); + else + DbgPrintData((PUCHAR)&(Adapter->AdapterRam->TxBuffer), 0x10, 0); + } +#endif + /* + // Insert packet into busy queue while the adapter is sending it out. + */ + InsertTailList(&Adapter->TransmitBusyList, &Packet->WanPacketQueue); + + /* + // Tell the adapter to send the packet out. + */ + CardStartTransmit(Adapter); + } + + DBG_LEAVE(Adapter); +} + + +VOID +HtDsuTransmitComplete( + IN PHTDSU_ADAPTER Adapter + ) + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Routine Description: + + This routine is called by HtDsuHandleInterrupt() to handle a transmit + complete interrupt. We enter here with interrupts disabled at the adapter, + but the Adapter->Lock is held. We walk the TransmitBusyList to find all + the transmits that have completed. + + NOTE: The Adapter->Lock must be held before calling this routine. + +Arguments: + + Adapter _ A pointer ot our adapter information structure. + +Return Value: + + None. + +---------------------------------------------------------------------------*/ + +{ + DBG_FUNC("HtDsuTransmitComplete") + + /* + // A pointer to our link information structure for the selected line device. + */ + PHTDSU_LINK Link; + + /* + // Holds the packet that's just been transmitted. + */ + PNDIS_WAN_PACKET Packet; + + DBG_ENTER(Adapter); + + /* + // Since we're here, the must be a packet on the busy list, + // and the adapter better be done with it. + */ + ASSERT(CardTransmitEmpty(Adapter)); + if (!IsListEmpty(&Adapter->TransmitBusyList) && + CardTransmitEmpty(Adapter)) + { + ASSERT(Adapter->TransmitInProgress); + + /* + // Remove the transmit from the transmit list + */ + Packet = (PNDIS_WAN_PACKET)RemoveHeadList(&Adapter->TransmitBusyList); + + Link = (PHTDSU_LINK) Packet->MacReserved1; + + /* + // Indicate send complete to the wrapper, and we can't hold the + // spin lock when we relinquish control or we may dead-lock. + */ + DBG_TRACE(Adapter); + NdisReleaseSpinLock(&Adapter->Lock); + + NdisMWanSendComplete( + Link->Adapter->MiniportAdapterHandle, + Packet, + NDIS_STATUS_SUCCESS + ); + + NdisAcquireSpinLock(&Adapter->Lock); + + /* + // If this is the last transmit queued on this link, and it has + // been closed, close the link and notify the protocol that the + // link has been closed. + */ + if (--Link->NumTxQueued == 0) + { + if (Link->CallClosing) + { + HtTapiCallStateHandler(Adapter, Link, LINECALLSTATE_IDLE, 0); + } + else if (Link->Closing) + { + HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_CLOSE); + LinkRelease(Link); + } + + /* + // Indicate close complete to the wrapper. + // Again, let go of the spin lock! + */ + NdisReleaseSpinLock(&Adapter->Lock); + NdisMSetInformationComplete( + Adapter->MiniportAdapterHandle, + NDIS_STATUS_SUCCESS + ); + NdisAcquireSpinLock(&Adapter->Lock); + } + + DBG_TRACE(Adapter); + + /* + // We're all done with the controller now. + */ + Adapter->TransmitInProgress = FALSE; + } + + /* + // Call HtDsuTransmitFrame() to start any other pending transmits. + */ + HtDsuTransmitFrame(Adapter); + + DBG_LEAVE(Adapter); +} + diff --git a/private/ntos/ndis/htdsu/sources b/private/ntos/ndis/htdsu/sources new file mode 100644 index 000000000..d25544860 --- /dev/null +++ b/private/ntos/ndis/htdsu/sources @@ -0,0 +1,53 @@ +!IF 0 + +Copyright (c) 1989 Microsoft Corporation + +Module Name: + + sources. + +Abstract: + + This file specifies the target component being built and the list of + sources files needed to build that component. Also specifies optional + compiler switches and libraries that are unique for the component being + built. + + +NOTE: Commented description of this file is in \nt\bak\bin\sources.tpl + +!ENDIF + +MAJORCOMP=ntos +MINORCOMP=ndis + +TARGETNAME=htdsu41 +TARGETPATH=$(BASEDIR)\public\sdk\lib +TARGETTYPE=DRIVER + +TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\ndis.lib $(BASEDIR)\public\sdk\lib\*\libc.lib + +INCLUDES=..\..\inc + +C_DEFINES=/DNDIS_MINIPORT_DRIVER + +SOURCES= htdsu.c \ + card.c \ + interrup.c \ + link.c \ + request.c \ + receive.c \ + send.c \ + tapi.c \ + debug.c \ + htdsu.rc + + +MSC_WARNING_LEVEL=/W3 /WX + +RELATIVE_DEPTH=..\.. + +# +# Sources file for DDK +# + diff --git a/private/ntos/ndis/htdsu/tapi.c b/private/ntos/ndis/htdsu/tapi.c new file mode 100644 index 000000000..f1622edda --- /dev/null +++ b/private/ntos/ndis/htdsu/tapi.c @@ -0,0 +1,5001 @@ +/***************************************************************************\ +|* 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); +} + diff --git a/private/ntos/ndis/htdsu/version.h b/private/ntos/ndis/htdsu/version.h new file mode 100644 index 000000000..9a3367cff --- /dev/null +++ b/private/ntos/ndis/htdsu/version.h @@ -0,0 +1,62 @@ +/***************************************************************************\ +|* 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. *| +\***************************************************************************/ + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Module Name: + + version.h + +Abstract: + + This file contains version definitions for the Miniport driver file. + +Author: + + Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94 + +Environment: + + Include this file at the top of each module in the driver to make sure + each module gets rebuilt when the version changes. + +Revision History: + +---------------------------------------------------------------------------*/ + +#ifndef _VERSION_H +#define _VERSION_H + +/* +// Used to add version information to driver file header. +*/ +#define VER_COMPANYNAME_STR "Microsoft Corporation" +#define VER_FILEDESCRIPTION_STR "NDIS 3.0 WAN Miniport Driver for Windows NT" +#define VER_FILEVERSION_STR "1.20" +#define VER_INTERNALNAME_STR "htdsu41.sys" +#define VER_LEGALCOPYRIGHT_STR "Copyright \251 1994 " VER_COMPANYNAME_STR +#define VER_ORIGINALFILENAME_STR VER_INTERNALNAME_STR +#undef VER_PRODUCTNAME_STR +#define VER_PRODUCTNAME_STR "HT Communications 56 kbps Digital Modem" +#undef VER_PRODUCTVERSION_STR +#define VER_PRODUCTVERSION_STR "DSU41 Digital Modem PC Card" + +/* +// Used to report driver version number. +*/ +#define HTDSU_MAJOR_VERSION 0x01 // Make sure you change above too +#define HTDSU_MINOR_VERSION 0x20 + +/* +// Used when registering MAC with NDIS wrapper. +// i.e. What NDIS version do we expect. +*/ +#define NDIS_MAJOR_VERSION 0x03 +#define NDIS_MINOR_VERSION 0x00 + +#endif + -- cgit v1.2.3