/*++ Copyright (c) 1992 Microsoft Corporation Module Name: det1000.c Abstract: This is the main file for the autodetection DLL for all the ne1000.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 // // // Helper functions // BOOLEAN Ne1000CardAt( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PUCHAR Interrupt ); VOID Ne1000CardCopyDownBuffer( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, IN ULONG MemoryBaseAddress, IN PUCHAR Buffer, IN ULONG Length ); ULONG Ne1000NextIoAddr( IN ULONG IoBaseAddress ); VOID Ne1000CardSetup( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PULONG MemoryBaseAddress, IN BOOLEAN EightBitSlot ); BOOLEAN Ne1000CardSlotTest( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PBOOLEAN EightBitSlot ); BOOLEAN Ne1000CheckForNovellAddress( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress ); #ifdef WORKAROUND UCHAR Ne1000FirstTime = 1; // // 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 // Ne1000QueryCfgHandler() and Ne1000VerifyCfgHandler() as well! // static ADAPTER_INFO Adapters[] = { { 1000, L"NE1000", L"IRQ 1 80 IRQTYPE 2 100 IOADDR 1 100 IOADDRLENGTH 2 100 ", NULL, 502 } }; #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 // Ne1000QueryCfgHandler() and Ne1000VerifyCfgHandler() as well! // static ADAPTER_INFO Adapters[] = { { 1000, L"NE1000", L"IRQ\0" L"1\0" L"80\0" L"IRQTYPE\0" L"2\0" L"100\0" L"IOADDR\0" L"1\0" L"100\0" L"IOADDRLENGTH\0" L"2\0" L"100\0", NULL, 502 } }; #endif // // Structure for holding state of a search // typedef struct _SEARCH_STATE { ULONG IoBaseAddress; UCHAR Interrupt; } 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 _NE1000_ADAPTER { LONG CardType; INTERFACE_TYPE InterfaceType; ULONG BusNumber; ULONG IoBaseAddress; UCHAR Interrupt; } NE1000_ADAPTER, *PNE1000_ADAPTER; extern LONG Ne1000IdentifyHandler( 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 (Ne1000FirstTime) { Ne1000FirstTime = 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 Ne1000FirstNextHandler( 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. 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. --*/ { 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 = 0x300; } else if (SearchStates[0].IoBaseAddress < 0x400) { SearchStates[0].IoBaseAddress = Ne1000NextIoAddr(SearchStates[0].IoBaseAddress); } while (SearchStates[0].IoBaseAddress < 0x400) { if (Ne1000CardAt( InterfaceType, BusNumber, SearchStates[0].IoBaseAddress, &SearchStates[0].Interrupt)) { break; } SearchStates[0].IoBaseAddress = Ne1000NextIoAddr(SearchStates[0].IoBaseAddress); } if (SearchStates[0].IoBaseAddress == 0x400) { *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 Ne1000OpenHandleHandler( 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. --*/ { PNE1000_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 = (PNE1000_ADAPTER)DetectAllocateHeap(sizeof(NE1000_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->CardType = Adapters[AdapterNumber].Index; Handle->InterfaceType = InterfaceType; Handle->BusNumber = BusNumber; *ppvHandle = (PVOID)Handle; return(0); } LONG Ne1000CreateHandleHandler( 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. --*/ { PNE1000_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 = (PNE1000_ADAPTER)DetectAllocateHeap(sizeof(NE1000_ADAPTER)); if (Handle == NULL) { return(ERROR_NOT_ENOUGH_MEMORY); } // // Copy across memory address // Handle->IoBaseAddress = 0x300; Handle->CardType = lNetcardId; Handle->InterfaceType = InterfaceType; Handle->BusNumber = BusNumber; Handle->Interrupt = 3; // // 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 = 0x20; DetectTemporaryClaimResource(&Resource); Resource.Type = NETDTECT_IRQ_RESOURCE; Resource.Value = 3; Resource.Length = 0; DetectTemporaryClaimResource(&Resource); *ppvHandle = (PVOID)Handle; return(0); } } return(ERROR_INVALID_PARAMETER); } extern LONG Ne1000CloseHandleHandler( 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 Ne1000QueryCfgHandler( 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. --*/ { PNE1000_ADAPTER Adapter = (PNE1000_ADAPTER)(pvHandle); LONG OutputLengthLeft = cwchBuffSize; LONG CopyLength; ULONG StartPointer = (ULONG)pwchBuffer; if ((Adapter->InterfaceType != Isa) && (Adapter->InterfaceType != Eisa)) { return(ERROR_INVALID_PARAMETER); } if (Adapter->Interrupt != 0) { 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 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); } // // LATCHED (0 == latched) // CopyLength = wsprintf(pwchBuffer,L"0"); if (CopyLength < 0) { return(ERROR_INSUFFICIENT_BUFFER); } CopyLength++; // Add in the \0 pwchBuffer = &(pwchBuffer[CopyLength]); OutputLengthLeft -= CopyLength; } // // 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; // // 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"0x20"); 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 Ne1000VerifyCfgHandler( 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. --*/ { PNE1000_ADAPTER Adapter = (PNE1000_ADAPTER)(pvHandle); ULONG IoBaseAddress; WCHAR *Place; ULONG Interrupt; BOOLEAN Found; NETDTECT_RESOURCE Resource; 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 Interrupt number // 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); } } else { // // Error! // return(ERROR_INVALID_DATA); } // // Verify IoAddress // if ((IoBaseAddress != Adapter->IoBaseAddress) || (Interrupt != Adapter->Interrupt)) { UCHAR TempInterrupt = 0; // // See if we can find a nic at their resources... // if (!Ne1000CardAt(Adapter->InterfaceType, Adapter->BusNumber, IoBaseAddress, &TempInterrupt)) { return(ERROR_INVALID_DATA); } // // Did we find their interrupt? // if (Interrupt != TempInterrupt) { return(ERROR_INVALID_DATA); } // // Looks like there is a nic their. Free up the // resources that we acquired and acquire the new ones. // Resource.InterfaceType = Adapter->InterfaceType; Resource.BusNumber = Adapter->BusNumber; // // Free up the detected port. // Resource.Type = NETDTECT_PORT_RESOURCE; Resource.Value = Adapter->IoBaseAddress; Resource.Length = 0x20; Resource.Flags = 0; DetectFreeSpecificTemporaryResource(&Resource); // // Acquire the new port. // Resource.Value = IoBaseAddress; DetectTemporaryClaimResource(&Resource); // // Free up the detected interrupt. // Resource.Type = NETDTECT_IRQ_RESOURCE; Resource.Value = Adapter->Interrupt; Resource.Length = 0; DetectFreeSpecificTemporaryResource(&Resource); // // Acquire the new interrupt. // Resource.Value = Interrupt; DetectTemporaryClaimResource(&Resource); // // Save the new resources. // Adapter->IoBaseAddress = IoBaseAddress; Adapter->Interrupt = (UCHAR)Interrupt; } return(0); } extern LONG Ne1000QueryMaskHandler( 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 Ne1000ParamRangeHandler( 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 < 4) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 0x300; plValues[1] = 0x320; plValues[2] = 0x340; plValues[3] = 0x360; *plBuffSize = 4; return(0); } else if (memcmp(pwchParam, IrqString, (UnicodeStrLen(IrqString) + 1) * sizeof(WCHAR)) == 0) { // // Is there enough space // if (*plBuffSize < 13) { *plBuffSize = 0; return(ERROR_INSUFFICIENT_BUFFER); } plValues[0] = 2; plValues[1] = 3; plValues[2] = 4; plValues[3] = 5; plValues[4] = 7; plValues[5] = 10; plValues[6] = 11; plValues[7] = 13; plValues[8] = 14; plValues[9] = 15; *plBuffSize = 10; return(0); } return(ERROR_INVALID_PARAMETER); } extern LONG Ne1000QueryParameterNameHandler( 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 Ne1000CardAt( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PUCHAR Interrupt ) /*++ Routine Description: This routine checks for the instance of an Ne1000 card at the Io location given. 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. --*/ { NETDTECT_RESOURCE Resource; UCHAR Value; UCHAR TempInterrupt = 0; ULONG RamAddr = 0; HANDLE TrapHandle; UCHAR InterruptList[13]; UCHAR ResultList[13] = {0}; NTSTATUS NtStatus; UINT i; if (DetectCheckPortUsage(InterfaceType, BusNumber, IoBaseAddress, 0x20) != STATUS_SUCCESS) { return(FALSE); } if (!CheckFor8390(InterfaceType, BusNumber, IoBaseAddress)) { return(FALSE); } if (!Ne1000CheckForNovellAddress(InterfaceType, BusNumber, IoBaseAddress)) { // // Stop the 8390 // DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x1F, // RESET &Value); DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x1F, // RESET 0xFF); DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress, // COMMAND 0x21); return(FALSE); } DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x1F, // RESET &Value); DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x1F, // RESET 0xFF); DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress, // COMMAND 0x21); // // Acquire the resource // Resource.InterfaceType = InterfaceType; Resource.BusNumber = BusNumber; Resource.Type = NETDTECT_PORT_RESOURCE; Resource.Value = SearchStates[0].IoBaseAddress; Resource.Length = 0x20; DetectTemporaryClaimResource(&Resource); // // Find the interrupt // InterruptList[0] = 2; InterruptList[1] = 3; InterruptList[2] = 4; InterruptList[3] = 5; InterruptList[4] = 7; InterruptList[5] = 10; InterruptList[6] = 11; InterruptList[7] = 13; InterruptList[8] = 14; InterruptList[9] = 15; // // Set the interrupt trap -- we are checking the interrupt number now // NtStatus = DetectSetInterruptTrap( InterfaceType, BusNumber, &TrapHandle, InterruptList, 10); if (NtStatus == STATUS_SUCCESS) { Ne1000CardSlotTest( InterfaceType, BusNumber, IoBaseAddress, &Value); // // CardSetup // Ne1000CardSetup( InterfaceType, BusNumber, IoBaseAddress, &RamAddr, Value); // // Check for interrupt // DetectQueryInterruptTrap(TrapHandle, ResultList, 13); // // Stop the chip // DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x1F, // RESET &Value); DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x1F, // RESET 0xFF); DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress, // COMMAND 0x21); // // Remove interrupt trap // DetectRemoveInterruptTrap(TrapHandle); // // Search resulting buffer to find the right interrupt // for (i = 0; i < 10; i++) { if ((ResultList[i] == 1) || (ResultList[i] == 2)) { if (TempInterrupt != 0) { // // Uh-oh, looks like interrupts on two different IRQs. // TempInterrupt = 0; break; } TempInterrupt = InterruptList[i]; } } } if (TempInterrupt != 0) { Resource.Type = NETDTECT_IRQ_RESOURCE; Resource.Value = TempInterrupt; Resource.Length = 0; DetectTemporaryClaimResource(&Resource); *Interrupt = TempInterrupt; } return(TRUE); } BOOLEAN Ne1000CheckForNovellAddress( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress ) /*++ Routine Description: This routine will determine if the network address of the card is (indeed) the Novell prefix (or compatible from another company). 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: TRUE if it is an NE1000 identification, else FALSE. --*/ { UCHAR Value; NTSTATUS NtStatus; ULONG RamAddr; BOOLEAN Result; if (!Ne1000CardSlotTest(InterfaceType, BusNumber, IoBaseAddress, &Result)) { return(FALSE); } Ne1000CardSetup( InterfaceType, BusNumber, IoBaseAddress, &RamAddr, Result); Result = TRUE; // // Read in the station address. (We have to read words -- 2 * 3 -- bytes) // NtStatus = DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0xA, // RBC0 6); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0xB, // RBC1 0); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x8, // RADDR0 0); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x9, // RADDR1 0); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar( InterfaceType, BusNumber, IoBaseAddress, // START | DMA_READ 0xA); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x10, // RACK_NIC &Value); if (NtStatus != STATUS_SUCCESS) { Result = FALSE; } if (Value != 0x00) { Result = FALSE; } NtStatus = DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x10, // RACK_NIC &Value); if (NtStatus != STATUS_SUCCESS) { Result = FALSE; } if (Value != 0x00) { Result = FALSE; } NtStatus = DetectReadPortUchar( InterfaceType, BusNumber, IoBaseAddress + 0x10, // RACK_NIC &Value); if (NtStatus != STATUS_SUCCESS) { Result = FALSE; } if (Value == 0x1D) { // // Here we are checking for the IEEE address of Cabletron. Turns out // that there are many many companies that make Ne1000 compatible // cards and checking for Novell only would be a small subset of // the market. The only known card that detects just like an Ne1000 // but is not an Ne1000 compatible card is the Cabletron card. // Result = FALSE; } return(Result); } VOID Ne1000CardCopyDownBuffer( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, IN ULONG MemoryBaseAddress, IN PUCHAR Buffer, IN ULONG Length ) /*++ Routine Description: This routine will copy down a buffer to the address given on the card. Arguments: InterfaceType - The type of bus, ISA or EISA. BusNumber - The bus number in the system. IoBaseAddress - The IO port address of the card. MemoryBaseAddress - The destination of the buffer, if in memory mapped mode, else it is the value to be stored in the Gate Array Control Register when doing Programmed I/O. Buffer - The buffer to copy Length - Number of bytes to copy to the card. Return: none. --*/ { NTSTATUS NtStatus; UCHAR Tmp; USHORT OldAddr, NewAddr, Count; PUCHAR ReadBuffer; // // Do Write errata as described on pages 1-143 and 1-144 of the 1992 // LAN databook // // // Set Count and destination address // ReadBuffer = ((PUCHAR)(MemoryBaseAddress + (MemoryBaseAddress & 1))); OldAddr = NewAddr = (USHORT)(ReadBuffer); NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x00 // PAGE0 ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x8, // NIC_RMT_ADDR_LSB (UCHAR)ReadBuffer ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x9, // NIC_RMT_ADDR_MSB (UCHAR)((ULONG)ReadBuffer >> 8) ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xA, //NIC_RMT_COUNT_LSB 0x2 ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xB, // NIC_RMT_COUNT_MSB 0x0 ); if (NtStatus != STATUS_SUCCESS) { return; } // // Set direction (Read) // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x2A // CR_START | CR_PAGE0 | CR_DMA_READ ); if (NtStatus != STATUS_SUCCESS) { return; } // // Read from port // NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x10, // RACK_NIC &Tmp ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x10, // NIC_RACK_NIC &Tmp ); if (NtStatus != STATUS_SUCCESS) { return; } // // Wait for addr to change // Count = 0xFF; while (Count != 0) { NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1, // NIC_CRDA_LSB &Tmp ); if (NtStatus != STATUS_SUCCESS) { return; } NewAddr = Tmp; NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x2, // NIC_CRDA_MSB &Tmp ); if (NtStatus != STATUS_SUCCESS) { return; } NewAddr |= (Tmp << 8); if (NewAddr != OldAddr) { break; } Count--; } if (NewAddr == OldAddr) { return; } // // Now we can do write // // // Set Count and destination address // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x0 // PAGE0 ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x8, // NIC_RMT_ADDR_LSB (UCHAR)MemoryBaseAddress ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x9, // NIC_RMT_ADDR_MSB (UCHAR)(MemoryBaseAddress >> 8) ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xA, // NIC_RMT_COUNT_LSB (UCHAR)Length ); if (NtStatus != STATUS_SUCCESS) { return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xB, // NIC_RMT_COUNT_MSB (UCHAR)(Length >> 8) ); if (NtStatus != STATUS_SUCCESS) { return; } // // Set direction (Write) // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x32 // CR_START | CR_PAGE0 | CR_DMA_WRITE ); if (NtStatus != STATUS_SUCCESS) { return; } // // Repeatedly write to out port // for (; Length > 0; Length--) { NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x10, // NIC_RACK_NIC *Buffer ); if (NtStatus != STATUS_SUCCESS) { return; } Buffer++; } // // Wait for DMA to complete // Count = 10; while (Count) { NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x7, // NIC_INTR_STATUS &Tmp ); if (NtStatus != STATUS_SUCCESS) { return; } if (Tmp & 0x40) { // ISR_DMA_DONE break; } else { Count--; } } return; } VOID Ne1000CardSetup( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PULONG MemoryBaseAddress, IN BOOLEAN EightBitSlot ) /*++ Routine Description: Sets up the card, using the sequence given in the Etherlink II technical reference. Arguments: InterfaceType - The type of bus, ISA or EISA. BusNumber - The bus number in the system. IoBaseAddress - The IO port address of the card. MemoryBaseAddress - Pointer to store the base address of card memory. Return Value: None. --*/ { UINT i; UCHAR Tmp; NTSTATUS NtStatus; LARGE_INTEGER Delay; // // Stop the card. // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x21 // STOP | ABORT_DMA ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Initialize the Data Configuration register. // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xE, // NIC_DATA_CONFIG 0x50 // DCR_AUTO_INIT | DCR_FIFO_8_BYTE ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Xmit start location // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x4, // NIC_XMIT_START 0xA0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Xmit configuration // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xD, // NIC_XMIT_CONFIG 0x0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Receive configuration // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xC, // NIC_RCV_CONFIG 0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Receive start // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1, // NIC_PAGE_START 0x4 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Receive end // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x2, // NIC_PAGE_STOP 0xFF ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Receive boundary // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x3, // NIC_BOUNDARY 0x4 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set Xmit bytes // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x5, // NIC_XMIT_COUNT_LSB 0x3C ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x6, // NIC_XMIT_COUNT_MSB 0x0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Pause // // // Wait for reset to complete. (100 ms) // Delay.LowPart = 100000; Delay.HighPart = 0; NtDelayExecution( FALSE, &Delay ); // // Ack all interrupts that we might have produced // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x7, // NIC_INTR_STATUS 0xFF ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Change to page 1 // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x61 // CR_PAGE1 | CR_STOP ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Set current // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x7, // NIC_CURRENT 0x4 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Back to page 0 // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x21 // CR_PAGE0 | CR_STOP ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Pause // Delay.LowPart = 1000; Delay.HighPart = 0; NtDelayExecution( FALSE, &Delay ); // // Do initialization errata // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xA, // NIC_RMT_COUNT_LSB 55 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Reset the chip // NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1F, // NIC_RESET &Tmp ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1F, // NIC_RESET 0xFF ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Start the chip // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x22 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Mask Interrupts // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xF, // NIC_INTR_MASK 0xFF ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } if (EightBitSlot) { NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xE, // NIC_DATA_CONFIG 0x48 // DCR_FIFO_8_BYTE | DCR_NORMAL | DCR_BYTE_WIDE ); } else { NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xE, // NIC_DATA_CONFIG 0x49 // DCR_FIFO_8_BYTE | DCR_NORMAL | DCR_WORD_WIDE ); } if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xD, // NIC_XMIT_CONFIG 0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xC, // NIC_RCV_CONFIG 0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x7, // NIC_INTR_STATUS 0xFF ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x21 // CR_NO_DMA | CR_STOP ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xA, // NIC_RMT_COUNT_LSB 0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xB, // NIC_RMT_COUNT_MSB 0 ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // Wait for STOP to complete // i = 0xFF; while (--i) { NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x7, // NIC_INTR_STATUS &Tmp ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } if (Tmp & 0x80) { // ISR_RESET break; } } // // Put card in loopback mode // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xD, // NIC_XMIT_CONFIG 0x2 // TCR_LOOPBACK ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x22 // CR_NO_DMA | CR_START ); if (NtStatus != STATUS_SUCCESS) { *MemoryBaseAddress = 0; return; } // // ... but it is still in loopback mode. // return; } ULONG Ne1000NextIoAddr( IN ULONG IoBaseAddress ) /*++ Routine Description: Gets the next IoBaseAddress. Arguments: IoBaseAddress - The IO port address of the card. Return Value: BaseAddress --*/ { IoBaseAddress += 0x20; if (IoBaseAddress > 0x380) { IoBaseAddress = 0x400; } return(IoBaseAddress); } BOOLEAN Ne1000CardSlotTest( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN ULONG IoBaseAddress, OUT PBOOLEAN EightBitSlot ) /*++ Routine Description: Checks if the card is in an 8 or 16 bit slot and sets a flag in the adapter structure. Arguments: InterfaceType - The type of bus, ISA or EISA. BusNumber - The bus number in the system. IoBaseAddress - The IO port address of the card. EightBitSlot - Result of test. Return Value: TRUE, if all goes well, else FALSE. --*/ { UCHAR Tmp; UCHAR RomCopy[32]; UCHAR i; NTSTATUS NtStatus; LARGE_INTEGER Delay; // // Reset the chip // NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1F, // NIC_RESET &Tmp ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1F, // NIC_RESET 0xFF ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Go to page 0 and stop // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0x21 // CR_STOP | CR_NO_DMA ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Pause // Delay.LowPart = 1000; Delay.HighPart = 0; NtDelayExecution( FALSE, &Delay ); // // Setup to read from ROM // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xE, // NIC_DATA_CONFIG 0x48 // DCR_BYTE_WIDE | DCR_FIFO_8_BYTE | DCR_NORMAL ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xF, // NIC_INTR_MASK 0x0 ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Ack any interrupts that may be hanging around // NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x7, // NIC_INTR_STATUS 0xFF ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x8, // NIC_RMT_ADDR_LSB 0x0 ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x9, // NIC_RMT_ADDR_MSB, 0x0 ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xA, // NIC_RMT_COUNT_LSB 32 ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0xB, // NIC_RMT_COUNT_MSB 0x0 ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress, 0xA // CR_DMA_READ | CR_START ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Read first 32 bytes in 16 bit mode // for (i = 0; i < 32; i++) { NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x10, // NIC_RACK_NIC RomCopy + i ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } } // // Reset the chip // NtStatus = DetectReadPortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1F, // NIC_RESET &Tmp ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } NtStatus = DetectWritePortUchar(InterfaceType, BusNumber, IoBaseAddress + 0x1F, // NIC_RESET 0xFF ); if (NtStatus != STATUS_SUCCESS) { return(FALSE); } // // Check address being singular // for (i = 6; i < 31; i++) { if ((RomCopy[i] != 'B') && (RomCopy[i+1] == 'B')) { // // Now check that the address is singular. On an Ne1000 the // ethernet address is store in offsets 0 thru 5. On the Ne2000 // the address is stored in offsets 0 thru 11, where each byte // is duplicated. // // Here we only check the first two bytes because some of the // other bytes may be accidentally equal. // if ((RomCopy[0] != RomCopy[1]) || (RomCopy[2] != RomCopy[3]) || (RomCopy[4] != RomCopy[5])) { return(TRUE); } return(FALSE); } } // // If no 'B' found, then not an NE1000. // return(FALSE); }