/*++ Copyright (c) 1992 Microsoft Corporation Module Name: detelk16.c Abstract: This is the main file for the autodetection DLL for all the elnk16.sys which MS is shipping with Windows NT. Author: Sean Selitrennikoff (SeanSe) October 1992. Environment: Revision History: --*/ #include #include #include #include #include #include #include #include "ntddnetd.h" #include "detect.h" // // Individual card detection routines // BOOLEAN Elnk16CardAt( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PUCHAR Interrupt, OUT PUCHAR Transceiver, OUT PUCHAR ZeroWaitState, OUT PULONG MemoryAddress, OUT PULONG MemoryLength ); ULONG Elnk16NextIoBaseAddress( IN ULONG IoBaseAddress ); VOID Elnk16GenerateIdPattern( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber ); UCHAR Elnk16FirstTime = 1; #ifdef WORKAROUND // // List of all the adapters supported in this file, this cannot be > 256 // because of the way tokens are generated. // // // NOTE : If you change the index of an adapter, be sure the change it in // Elnk16QueryCfgHandler() and Elnk16VerifyCfgHandler() as well! // static ADAPTER_INFO Adapters[] = { { 1000, L"ELNK16", L"IRQ 0 100 IRQTYPE 2 100 IOADDR 0 100 IOADDRLENGTH 2 100 MEMADDR 0 100 MEMADDRLENGTH 0 100 TRANSCEIVER 0 0 ZEROWAITSTATE 0 0 ", NULL, 200 } }; #else // // List of all the adapters supported in this file, this cannot be > 256 // because of the way tokens are generated. // // // NOTE : If you change the index of an adapter, be sure the change it in // Elnk16QueryCfgHandler() and Elnk16VerifyCfgHandler() as well! // static ADAPTER_INFO Adapters[] = { { 1000, L"ELNK16", L"IRQ\0" L"0\0" L"100\0" L"IRQTYPE\0" L"2\0" L"100\0" L"IOADDR\0" L"0\0" L"100\0" L"IOADDRLENGTH\0" L"2\0" L"100\0" L"MEMADDR\0" L"0\0" L"100\0" L"MEMADDRLENGTH\0" L"0\0" L"100\0" L"TRANSCEIVER\0" L"0\0" L"0\0" L"ZEROWAITSTATE\0" L"0\0" L"0\0", NULL, 200 } }; #endif // // Structure for holding state of a search // typedef struct _SEARCH_STATE { ULONG IoBaseAddress; UCHAR Interrupt; UCHAR Transceiver; UCHAR ZeroWaitState; ULONG MemoryAddress; ULONG MemoryLength; } SEARCH_STATE, *PSEARCH_STATE; // // This is an array of search states. We need one state for each type // of adapter supported. // static SEARCH_STATE SearchStates[sizeof(Adapters) / sizeof(ADAPTER_INFO)] = {0}; // // Structure for holding a particular adapter's complete information // typedef struct _ELNK16_ADAPTER { LONG CardType; INTERFACE_TYPE InterfaceType; ULONG BusNumber; ULONG IoBaseAddress; UCHAR Interrupt; UCHAR Transceiver; UCHAR ZeroWaitState; ULONG MemoryAddress; ULONG MemoryLength; } ELNK16_ADAPTER, *PELNK16_ADAPTER; extern LONG Elnk16IdentifyHandler( IN LONG lIndex, IN WCHAR * pwchBuffer, IN LONG cwchBuffSize ) /*++ Routine Description: This routine returns information about the netcards supported by this file. Arguments: lIndex - The index of the netcard being address. The first cards information is at index 1000, the second at 1100, etc. pwchBuffer - Buffer to store the result into. cwchBuffSize - Number of bytes in pwchBuffer Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { LONG NumberOfAdapters; LONG Code = lIndex % 100; LONG Length; LONG i; NumberOfAdapters = sizeof(Adapters) / sizeof(ADAPTER_INFO); #ifdef WORKAROUND if (Elnk16FirstTime) { Elnk16FirstTime = 0; for (i = 0; i < NumberOfAdapters; i++) { Length = UnicodeStrLen(Adapters[i].Parameters); for (; Length > 0; Length--) { if (Adapters[i].Parameters[Length] == L' ') { Adapters[i].Parameters[Length] = UNICODE_NULL; } } } } #endif lIndex = lIndex - Code; if (((lIndex / 100) - 10) < NumberOfAdapters) { for (i=0; i < NumberOfAdapters; i++) { if (Adapters[i].Index == lIndex) { switch (Code) { case 0: // // Find the string length // Length = UnicodeStrLen(Adapters[i].InfId); Length ++; if (cwchBuffSize < Length) { return(ERROR_INSUFFICIENT_BUFFER); } memcpy((PVOID)pwchBuffer, Adapters[i].InfId, Length * sizeof(WCHAR)); break; case 3: // // Maximum value is 1000 // if (cwchBuffSize < 5) { return(ERROR_INSUFFICIENT_BUFFER); } wsprintf((PVOID)pwchBuffer, L"%d", Adapters[i].SearchOrder); break; default: return(ERROR_INVALID_PARAMETER); } return(0); } } return(ERROR_INVALID_PARAMETER); } return(ERROR_NO_MORE_ITEMS); } extern LONG Elnk16FirstNextHandler( IN LONG lNetcardId, IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN BOOL fFirst, OUT PVOID *ppvToken, OUT LONG *lConfidence ) /*++ Routine Description: This routine finds the instances of a physical adapter identified by the NetcardId. NOTE: That for now there is only one card supported by this file, so we ignore the specific FirstNext handler in Adapters to save some processing time. Arguments: lNetcardId - The index of the netcard being address. The first cards information is id 1000, the second id 1100, etc. InterfaceType - Either Isa, or Eisa. BusNumber - The bus number of the bus to search. fFirst - TRUE is we are to search for the first instance of an adapter, FALSE if we are to continue search from a previous stopping point. ppvToken - A pointer to a handle to return to identify the found instance lConfidence - A pointer to a long for storing the confidence factor that the card exists. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { NTSTATUS NtStatus; NETDTECT_RESOURCE Resource; if ((InterfaceType != Isa) && (InterfaceType != Eisa)) { *lConfidence = 0; return(0); } if (lNetcardId != 1000) { *lConfidence = 0; return(ERROR_INVALID_PARAMETER); } // // If fFirst, reset search state // if (fFirst) { SearchStates[0].IoBaseAddress = 0x200; } else { SearchStates[0].IoBaseAddress = Elnk16NextIoBaseAddress( SearchStates[0].IoBaseAddress); } // // Find an adapter // // // Put all cards in RUN state. // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, 0x100, 0x00); if (NtStatus != STATUS_SUCCESS) { *lConfidence = 0; return(0); } Elnk16GenerateIdPattern(InterfaceType, BusNumber); NtStatus = DetectWritePortUchar( InterfaceType, BusNumber, 0x100, 0x00); if (NtStatus != STATUS_SUCCESS) { *lConfidence = 0; return(0); } while (SearchStates[0].IoBaseAddress != 0x3F0) { if (Elnk16CardAt( InterfaceType, BusNumber, SearchStates[0].IoBaseAddress, &SearchStates[0].Interrupt, &SearchStates[0].Transceiver, &SearchStates[0].ZeroWaitState, &SearchStates[0].MemoryAddress, &SearchStates[0].MemoryLength)) { break; } SearchStates[0].IoBaseAddress = Elnk16NextIoBaseAddress( SearchStates[0].IoBaseAddress); } if (SearchStates[0].IoBaseAddress == 0x3F0) { *lConfidence = 0; return(0); } // // In this module I use the token as follows: Remember that // the token can only be 2 bytes long (the low 2) because of // the interface to the upper part of this DLL. // // The high bit of the short is boolean for ISA (else, EISA). // The rest of the high byte is the the bus number. // The low byte is the driver index number into Adapters. // // NOTE: This presumes that there are < 129 buses in the // system. Is this reasonable? // if (InterfaceType == Isa) { *ppvToken = (PVOID)0x8000; } else { *ppvToken = (PVOID)0x0; } *ppvToken = (PVOID)(((ULONG)*ppvToken) | ((BusNumber & 0x7F) << 8)); *ppvToken = (PVOID)(((ULONG)*ppvToken) | 0); // index *lConfidence = 100; return(0); } extern LONG Elnk16OpenHandleHandler( IN PVOID pvToken, OUT PVOID *ppvHandle ) /*++ Routine Description: This routine takes a token returned by FirstNext and converts it into a permanent handle. Arguments: Token - The token. ppvHandle - A pointer to the handle, so we can store the resulting handle. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { PELNK16_ADAPTER Handle; LONG AdapterNumber; ULONG BusNumber; INTERFACE_TYPE InterfaceType; // // Get info from the token // if (((ULONG)pvToken) & 0x8000) { InterfaceType = Isa; } else { InterfaceType = Eisa; } BusNumber = (ULONG)(((ULONG)pvToken >> 8) & 0x7F); AdapterNumber = ((ULONG)pvToken) & 0xFF; // // Store information // Handle = (PELNK16_ADAPTER)DetectAllocateHeap(sizeof(ELNK16_ADAPTER)); if (Handle == NULL) { return(ERROR_NOT_ENOUGH_MEMORY); } // // Copy across address // Handle->IoBaseAddress = SearchStates[(ULONG)AdapterNumber].IoBaseAddress; Handle->Interrupt = SearchStates[(ULONG)AdapterNumber].Interrupt; Handle->Transceiver = SearchStates[(ULONG)AdapterNumber].Transceiver; Handle->ZeroWaitState = SearchStates[(ULONG)AdapterNumber].ZeroWaitState; Handle->MemoryAddress = SearchStates[(ULONG)AdapterNumber].MemoryAddress; Handle->MemoryLength = SearchStates[(ULONG)AdapterNumber].MemoryLength; Handle->CardType = Adapters[AdapterNumber].Index; Handle->InterfaceType = InterfaceType; Handle->BusNumber = BusNumber; *ppvHandle = (PVOID)Handle; return(0); } extern LONG Elnk16CreateHandleHandler( IN LONG lNetcardId, IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, OUT PVOID *ppvHandle ) /*++ Routine Description: This routine is used to force the creation of a handle for cases where a card is not found via FirstNext, but the user says it does exist. Arguments: lNetcardId - The id of the card to create the handle for. InterfaceType - Isa or Eisa. BusNumber - The bus number of the bus in the system. ppvHandle - A pointer to the handle, for storing the resulting handle. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { PELNK16_ADAPTER Handle; LONG NumberOfAdapters; LONG i; NETDTECT_RESOURCE Resource; if ((InterfaceType != Isa) && (InterfaceType != Eisa)) { return(ERROR_INVALID_PARAMETER); } NumberOfAdapters = sizeof(Adapters) / sizeof(ADAPTER_INFO); for (i = 0; i < NumberOfAdapters; i++) { if (Adapters[i].Index == lNetcardId) { // // Store information // Handle = (PELNK16_ADAPTER)DetectAllocateHeap(sizeof(ELNK16_ADAPTER)); if (Handle == NULL) { return(ERROR_NOT_ENOUGH_MEMORY); } // // Copy across memory address // Handle->IoBaseAddress = 0x300; Handle->Interrupt = 3; Handle->MemoryAddress = 0xD0000; Handle->MemoryLength = 0x4000; Handle->Transceiver = 2; Handle->ZeroWaitState = 0; Handle->CardType = lNetcardId; Handle->InterfaceType = InterfaceType; Handle->BusNumber = BusNumber; // // We need to claim this port so no one else uses it.... // Resource.InterfaceType = InterfaceType; Resource.BusNumber = BusNumber; Resource.Type = NETDTECT_PORT_RESOURCE; Resource.Value = 0x300; Resource.Length = 0x10; DetectTemporaryClaimResource(&Resource); Resource.Type = NETDTECT_IRQ_RESOURCE; Resource.Value = 3; Resource.Length = 0; DetectTemporaryClaimResource(&Resource); Resource.Type = NETDTECT_MEMORY_RESOURCE; Resource.Value = 0xD0000; Resource.Length = 0x4000; DetectTemporaryClaimResource(&Resource); *ppvHandle = (PVOID)Handle; return(0); } } return(ERROR_INVALID_PARAMETER); } extern LONG Elnk16CloseHandleHandler( IN PVOID pvHandle ) /*++ Routine Description: This frees any resources associated with a handle. Arguments: pvHandle - The handle. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { DetectFreeHeap(pvHandle); return(0); } LONG Elnk16QueryCfgHandler( IN PVOID pvHandle, OUT WCHAR *pwchBuffer, IN LONG cwchBuffSize ) /*++ Routine Description: This routine calls the appropriate driver's query config handler to get the parameters for the adapter associated with the handle. Arguments: pvHandle - The handle. pwchBuffer - The resulting parameter list. cwchBuffSize - Length of the given buffer in WCHARs. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { PELNK16_ADAPTER Adapter = (PELNK16_ADAPTER)(pvHandle); LONG OutputLengthLeft = cwchBuffSize; LONG CopyLength; ULONG StartPointer = (ULONG)pwchBuffer; if ((Adapter->InterfaceType != Isa) && (Adapter->InterfaceType != Eisa)) { return(ERROR_INVALID_PARAMETER); } // // First put in memory addr // if ((Adapter->MemoryAddress == 0) || (Adapter->MemoryLength == 0)) { goto SkipMemory; } // // Copy in the title string // CopyLength = UnicodeStrLen(MemAddrString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)MemAddrString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 8) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"0x%x", Adapter->MemoryAddress); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Now the amount of memory // // // Copy in the title string // CopyLength = UnicodeStrLen(MemLengthString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)MemLengthString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 8) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"0x%x", Adapter->MemoryLength); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; SkipMemory: // // Now the IoBaseAddress // // // Copy in the title string // CopyLength = UnicodeStrLen(IoAddrString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)IoAddrString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 6) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"0x%x", Adapter->IoBaseAddress); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Now the IoAddressLength // // // Copy in the title string // CopyLength = UnicodeStrLen(IoLengthString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)IoLengthString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 5) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"0x10"); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Now the interrupt number // // // Copy in the title string // CopyLength = UnicodeStrLen(IrqString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)IrqString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 3) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"%d", Adapter->Interrupt); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the title string (IRQTYPE) // CopyLength = UnicodeStrLen(IrqTypeString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)IrqTypeString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 2) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"0"); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Now the ZeroWaitState // // // Copy in the title string // CopyLength = UnicodeStrLen(ZeroWaitStateString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)ZeroWaitStateString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 2) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"%d", Adapter->ZeroWaitState); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Now the transceiver // // // Copy in the title string // CopyLength = UnicodeStrLen(TransceiverString) + 1; if (OutputLengthLeft < CopyLength) { return(ERROR_INSUFFICIENT_BUFFER); } RtlMoveMemory((PVOID)pwchBuffer, (PVOID)TransceiverString, (CopyLength * sizeof(WCHAR))); pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in the value // if (OutputLengthLeft < 2) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = wsprintf(pwchBuffer,L"%d", Adapter->Transceiver); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; // // Copy in final \0 // if (OutputLengthLeft < 1) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength = (ULONG)pwchBuffer - StartPointer; ((PUCHAR)StartPointer)[CopyLength] = L'\0'; return(0); } extern LONG Elnk16VerifyCfgHandler( IN PVOID pvHandle, IN WCHAR *pwchBuffer ) /*++ Routine Description: This routine verifys that a given parameter list is complete and correct for the adapter associated with the handle. Arguments: pvHandle - The handle. pwchBuffer - The parameter list. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { PELNK16_ADAPTER Adapter = (PELNK16_ADAPTER)(pvHandle); NTSTATUS NtStatus; ULONG IoBaseAddress; ULONG MemAddress; ULONG MemLength; ULONG Transceiver; ULONG Interrupt; ULONG ZeroWaitState; UCHAR TmpValue; WCHAR *Place; BOOLEAN Found; if ((Adapter->InterfaceType != Isa) && (Adapter->InterfaceType != Eisa)) { return(ERROR_INVALID_DATA); } if (Adapter->CardType == 1000) { // // Parse out the parameter. // // // Get the IoBaseAddress // Place = FindParameterString(pwchBuffer, IoAddrString); if (Place == NULL) { return(ERROR_INVALID_DATA); } Place += UnicodeStrLen(IoAddrString) + 1; // // Now parse the thing. // ScanForNumber(Place, &IoBaseAddress, &Found); if (Found == FALSE) { return(ERROR_INVALID_DATA); } // // Get the Interrupt // Place = FindParameterString(pwchBuffer, IrqString); if (Place == NULL) { return(ERROR_INVALID_DATA); } Place += UnicodeStrLen(IrqString) + 1; // // Now parse the thing. // ScanForNumber(Place, &Interrupt, &Found); if (Found == FALSE) { return(ERROR_INVALID_DATA); } // // Get the MemAddress // Place = FindParameterString(pwchBuffer, MemAddrString); if (Place == NULL) { return(ERROR_INVALID_DATA); } Place += UnicodeStrLen(MemAddrString) + 1; // // Now parse the thing. // ScanForNumber(Place, &MemAddress, &Found); if (Found == FALSE) { return(ERROR_INVALID_DATA); } // // Get the MemLength // Place = FindParameterString(pwchBuffer, MemLengthString); if (Place == NULL) { return(ERROR_INVALID_DATA); } Place += UnicodeStrLen(MemLengthString) + 1; // // Now parse the thing. // ScanForNumber(Place, &MemLength, &Found); if (Found == FALSE) { return(ERROR_INVALID_DATA); } // // Get the Transceiver // Place = FindParameterString(pwchBuffer, TransceiverString); if (Place == NULL) { return(ERROR_INVALID_DATA); } Place += UnicodeStrLen(TransceiverString) + 1; // // Now parse the thing. // ScanForNumber(Place, &Transceiver, &Found); if (Found == FALSE) { return(ERROR_INVALID_DATA); } // // Get the ZeroWaitState // Place = FindParameterString(pwchBuffer, ZeroWaitStateString); if (Place == NULL) { return(ERROR_INVALID_DATA); } Place += UnicodeStrLen(ZeroWaitStateString) + 1; // // Now parse the thing. // ScanForNumber(Place, &ZeroWaitState, &Found); if (Found == FALSE) { return(ERROR_INVALID_DATA); } } else { // // Error! // return(ERROR_INVALID_DATA); } // // Verify these with the parameters that we detected earlier. // if (Adapter->IoBaseAddress != IoBaseAddress) { return(ERROR_INVALID_DATA); } if (Adapter->Interrupt != Interrupt) { return(ERROR_INVALID_DATA); } if (Adapter->MemoryAddress != MemAddress) { return(ERROR_INVALID_DATA); } if (Adapter->MemoryLength != MemLength) { return(ERROR_INVALID_DATA); } if (Adapter->Transceiver != Transceiver) { return(ERROR_INVALID_DATA); } if (Adapter->ZeroWaitState != ZeroWaitState) { return(ERROR_INVALID_DATA); } return(0); } extern LONG Elnk16QueryMaskHandler( IN LONG lNetcardId, OUT WCHAR *pwchBuffer, IN LONG cwchBuffSize ) /*++ Routine Description: This routine returns the parameter list information for a specific network card. Arguments: lNetcardId - The id of the desired netcard. pwchBuffer - The buffer for storing the parameter information. cwchBuffSize - Length of pwchBuffer in WCHARs. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { WCHAR *Result; LONG Length; LONG NumberOfAdapters; LONG i; // // Find the adapter // NumberOfAdapters = sizeof(Adapters) / sizeof(ADAPTER_INFO); for (i=0; i < NumberOfAdapters; i++) { if (Adapters[i].Index == lNetcardId) { Result = Adapters[i].Parameters; // // Find the string length (Ends with 2 NULLs) // for (Length=0; ; Length++) { if (Result[Length] == L'\0') { ++Length; if (Result[Length] == L'\0') { break; } } } Length++; if (cwchBuffSize < Length) { return(ERROR_NOT_ENOUGH_MEMORY); } memcpy((PVOID)pwchBuffer, Result, Length * sizeof(WCHAR)); return(0); } } return(ERROR_INVALID_PARAMETER); } extern LONG Elnk16ParamRangeHandler( IN LONG lNetcardId, IN WCHAR *pwchParam, OUT LONG *plValues, OUT LONG *plBuffSize ) /*++ Routine Description: This routine returns a list of valid values for a given parameter name for a given card. Arguments: lNetcardId - The Id of the card desired. pwchParam - A WCHAR string of the parameter name to query the values of. plValues - A pointer to a list of LONGs into which we store valid values for the parameter. plBuffSize - At entry, the length of plValues in LONGs. At exit, the number of LONGs stored in plValues. Return Value: 0 if nothing went wrong, else the appropriate WINERROR.H value. --*/ { // // Do we want the IoBaseAddress // if (memcmp(pwchParam, IoAddrString, (UnicodeStrLen(IoAddrString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 25) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 0x300; plValues[1] = 0x210; plValues[2] = 0x220; plValues[3] = 0x230; plValues[4] = 0x240; plValues[5] = 0x250; plValues[6] = 0x260; plValues[7] = 0x280; plValues[8] = 0x2A0; plValues[9] = 0x2B0; plValues[10] = 0x2C0; plValues[11] = 0x2D0; plValues[12] = 0x2E0; plValues[13] = 0x200; plValues[14] = 0x310; plValues[15] = 0x320; plValues[16] = 0x330; plValues[17] = 0x340; plValues[18] = 0x350; plValues[19] = 0x360; plValues[20] = 0x370; plValues[21] = 0x380; plValues[22] = 0x390; plValues[23] = 0x3A0; plValues[24] = 0x3E0; *plBuffSize = 25; return(0); } else if (memcmp(pwchParam, IrqString, (UnicodeStrLen(IrqString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 8) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 3; plValues[1] = 5; plValues[2] = 7; plValues[3] = 9; plValues[4] = 10; plValues[5] = 11; plValues[6] = 12; plValues[7] = 15; *plBuffSize = 8; return(0); } else if (memcmp(pwchParam, MemAddrString, (UnicodeStrLen(MemAddrString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 9) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 0xD0000; plValues[1] = 0xC8000; plValues[2] = 0xC0000; plValues[3] = 0xD8000; plValues[4] = 0xF0000; plValues[5] = 0xF2000; plValues[6] = 0xF4000; plValues[7] = 0xF6000; plValues[8] = 0xF8000; *plBuffSize = 9; return(0); } else if (memcmp(pwchParam, MemLengthString, (UnicodeStrLen(MemLengthString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 4) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 0x4000; plValues[1] = 0x8000; plValues[2] = 0xC000; plValues[3] = 0x10000; *plBuffSize = 4; return(0); } else if (memcmp(pwchParam, TransceiverString, (UnicodeStrLen(TransceiverString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 2) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 0x2; plValues[1] = 0x1; *plBuffSize = 2; return(0); } else if (memcmp(pwchParam, ZeroWaitStateString, (UnicodeStrLen(ZeroWaitStateString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 2) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 0x0; plValues[1] = 0x1; *plBuffSize = 2; return(0); } return(ERROR_INVALID_PARAMETER); } extern LONG Elnk16QueryParameterNameHandler( IN WCHAR *pwchParam, OUT WCHAR *pwchBuffer, IN LONG cwchBufferSize ) /*++ Routine Description: Returns a localized, displayable name for a specific parameter. All the parameters that this file uses are define by MS, so no strings are needed here. Arguments: pwchParam - The parameter to be queried. pwchBuffer - The buffer to store the result into. cwchBufferSize - The length of pwchBuffer in WCHARs. Return Value: ERROR_INVALID_PARAMETER -- To indicate that the MS supplied strings should be used. --*/ { return(ERROR_INVALID_PARAMETER); } BOOLEAN Elnk16CardAt( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PUCHAR Interrupt, OUT PUCHAR Transceiver, OUT PUCHAR ZeroWaitState, OUT PULONG MemoryAddress, OUT PULONG MemoryLength ) /*++ Routine Description: This routine checks for the instance of a Elnk16 card at the Io location given. This is done by checking for the *3COM* string in the ports Arguments: InterfaceType - The type of bus, ISA or EISA. BusNumber - The bus number in the system. IoBaseAddress - The IO port address of the card. Return Value: TRUE if a card is found, else FALSE. --*/ { NTSTATUS NtStatus; UCHAR TmpValue; UCHAR TransceiverType; UCHAR ZeroWaitStateNumber; ULONG MemAddress; ULONG MemLength; NETDTECT_RESOURCE Resource; // // Check for resource conflict // NtStatus = DetectCheckPortUsage(InterfaceType, BusNumber, IoBaseAddress, 0x10); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Write CSR to be bank 0 // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x6, 0x00); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Read for the signature // NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } if (TmpValue != '*') { return(FALSE); } NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 1, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } if (TmpValue != '3') { return(FALSE); } NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 2, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } if (TmpValue != 'C') { return(FALSE); } NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 3, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } if (TmpValue != 'O') { return(FALSE); } NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 4, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } if (TmpValue != 'M') { return(FALSE); } NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 5, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } if (TmpValue != '*') { return(FALSE); } // // Acquire the port. // Resource.InterfaceType = InterfaceType; Resource.BusNumber = BusNumber; Resource.Type = NETDTECT_PORT_RESOURCE; Resource.Value = IoBaseAddress; Resource.Length = 0x10; Resource.Flags = 0; DetectTemporaryClaimResource(&Resource); // // Reach the ROM configuration register // NtStatus = DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0xD, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // What transceiver are we configured for? // if (TmpValue & 0x80) { TransceiverType = 2; } else { TransceiverType = 1; } *Transceiver = TransceiverType; // // Now get the MemoryMappedBaseAddress // // // Read the RAM configuration register // NtStatus = DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0xE, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Where is the starting memory? // MemAddress = 0; switch (TmpValue & 0x3C) { case 0x00: MemAddress = 0xC0000; break; case 0x08: MemAddress = 0xC8000; break; case 0x10: MemAddress = 0xD0000; break; case 0x18: MemAddress = 0xD8000; break; case 0x30: switch (TmpValue & 0x03) { case 0x00 : MemAddress = 0xF0000; break; case 0x01 : MemAddress = 0xF2000; break; case 0x02 : MemAddress = 0xF4000; break; case 0x03 : MemAddress = 0xF6000; break; } break; case 0x38: MemAddress = 0xF8000; break; default: MemAddress = 0; } MemLength = 0; switch (TmpValue & 0x3) { case 0x00 : MemLength = 0x4000; break; case 0x01 : MemLength = 0x8000; break; case 0x02 : MemLength = 0xC000; break; case 0x03 : MemLength = 0x10000; break; } *MemoryAddress = MemAddress; *MemoryLength = MemLength; // // If it's not disabled then acquire it. // if ((MemoryAddress != 0) && (MemoryLength != 0)) { Resource.Type = NETDTECT_MEMORY_RESOURCE; Resource.Value = MemAddress; Resource.Length = MemLength; DetectTemporaryClaimResource(&Resource); } // // Zero Wait State? // if (TmpValue & 0x80) { *ZeroWaitState = 1; } else { *ZeroWaitState = 0; } // // Read the Interrupt Config register // NtStatus = DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0xF, &TmpValue); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } *Interrupt = (UCHAR)(TmpValue & 0xF); return(TRUE); } ULONG Elnk16NextIoBaseAddress( IN ULONG IoBaseAddress ) /*++ Routine Description: Returns the next in a sequence on good IoBaseAddresses for an Elnk16 card. Arguments: IoBaseAddress - Current IO port address. Return Value: Next IoBaseAddress --*/ { IoBaseAddress += 0x10; if (IoBaseAddress > 0x3E0) { return(0x3F0); } if ((IoBaseAddress == 0x270) || (IoBaseAddress == 0x290) || (IoBaseAddress == 0x2F0) || (IoBaseAddress == 0x3B0)) { if (IoBaseAddress == 0x3B0) { return(0x3E0); } IoBaseAddress += 0x10; } return(IoBaseAddress); } VOID Elnk16GenerateIdPattern( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber ) /*++ Routine Description: This routine will write the ID pattern to port 0x100h. Arguments: InterfaceType - Bus type, either EISA or ISA. BusNumber - Number of the bus in the system. Return Value: None. --*/ { UCHAR Value; UINT i; Value = 0xff; for (i = 0 ; i < 255 ; i++) { DetectWritePortUchar(InterfaceType, BusNumber, 0x100, Value); if (Value & 0x80) { Value = (UCHAR) (Value << 1); Value ^= 0xe7; } else { Value = (UCHAR) (Value << 1); } } return; }