path: root/private/ntos/ndis/dc21x4/srom.c

/*+
 * file:        srom.c
 *
 * Copyright (C) 1992-1995 by
 * Digital Equipment Corporation, Maynard, Massachusetts.
 * All rights reserved.
 *
 * This software is furnished under a license and may be used and copied
 * only  in  accordance  of  the  terms  of  such  license  and with the
 * inclusion of the above copyright notice. This software or  any  other
 * copies thereof may not be provided or otherwise made available to any
 * other person.  No title to and  ownership of the  software is  hereby
 * transferred.
 *
 * The information in this software is  subject to change without notice
 * and  should  not  be  construed  as a commitment by digital equipment
 * corporation.
 *
 * Digital assumes no responsibility for the use  or  reliability of its
 * software on equipment which is not supplied by digital.
 *
 *
 * Abstract:    This file contains the code to access the onboard ROM of
 *              adapters based on DEC's DC21X4 Ethernet Controller.
 *
 * Author:      Philippe klein
 *
 * Revision History:
 *
 *  05-Oct-95   phk     Modified Miniport version
 *  10-Jan-95   phk     Add ParseSRom
 *  29-Nov-95   phk     Add parsing for SROM format V3 
 *  
-*/

#include <precomp.h>

#define SROM_93LC46B_SIZE               64 //words
#define SROM_93LC46B_MAX_CYCLES         25
#define SROM_93LC46B_ADDRESS_MSB         5
#define SROM_93LC46B_DATA_MSB           15
#define SROM_93LC46B_DATA_BIT            3

#define SROM_93LC46B_VALID_BITMASK     0x8

#define SROM_93LC46B_DELAY             (10)

#define CSR_READ   0x4000
#define CSR_WRITE  0x2000
#define SEL_SROM   0x0800
#define DATA_1     0x0004
#define DATA_0     0x0000
#define CLK        0x0002
#define CS         0x0001

#define DISABLE_AUTOSENSE 0x8000

#define EXT            0x40
#define DC21X4_MEDIA   0x3F


#define MODE       0x0071
#define SENSE_BN   0x000E
#define SENSE_DIS  0x8000
#define DEFAULT    0x4000
#define POLARITY   0x0080

#define SENSE_SHIFT   1
#define MODE_SHIFT   18

#define SROM_LEGACY  0x00
#define SROM_V1      0x01
#define SROM_V2      0x02
#define SROM_V3      0x03

#define SROM_SIZE (SROM_93LC46B_SIZE*2)

#define SROM_IEEE_LEN  32
#define TEST_PATTERN   0xAA5500FF
#define SROM_TIMEOUT   50

#define  ZX312_SIGNATURE 0x0095C000

#define GET_MODE(_command)      \
      ( (*(UNALIGNED ULONG *)(_command) & MODE) << MODE_SHIFT )

#define IF_DEFAULT_MEDIA(_command)   \
      ( *(UNALIGNED ULONG *)(_command) & DEFAULT )

#define GET_POLARITY(_command)  \
      ( (*(UNALIGNED ULONG *)(_command) & POLARITY) ? 0xffffffff : 0 )

#define GET_SENSE_MASK(_command)  \
      ((*(UNALIGNED ULONG *)(_command) & SENSE_DIS) ? \
        0 : (ULONG)(1 << ((*(UNALIGNED ULONG *)(_command) & SENSE_BN)>> SENSE_SHIFT )))

#pragma pack(1)
typedef struct _SROM_ID_BLOCK{
   
   USHORT  VendorID;
   USHORT  SysID;
   USHORT  Reserved[6];
   USHORT  ID_Checksum;
   UCHAR   FormatVersion;
   UCHAR   AdapterCount;
   UCHAR   NetworkAddress[ETH_LENGTH_OF_ADDRESS];
   
} SROM_ID_BLOCK, *PSROM_ID_BLOCK;

typedef struct _ADAPTER_ENTRIES{
   
   UCHAR DeviceNumber;
   USHORT Offset;
   
} ADAPTER_ENTRIES, *PADAPTER_ENTRIES;

#pragma pack()

#define DE500_STR  0x1D
#define BOARD_SIGNATURE(_srom) \
      ((*(UNALIGNED ULONG *)&(_srom)[DE500_STR] == *(PULONG)&DE500Strng[0]) && \
       (*(UNALIGNED ULONG *)&(_srom)[DE500_STR+sizeof(ULONG)] == *(PULONG)&DE500Strng[sizeof(ULONG)]))

// PHY Parsing definitions

#define EXTENDED_FORMAT 0x80

#define LENGTH 0x7f
#define TYPE_0  0x0
#define TYPE_1  0x1
#define TYPE_2  0x2
#define TYPE_3  0x3

#define MEDIA_CAPABILITIES_MASK 0xf800
#define NWAY_ADVERTISEMENT_MASK 0x03e0










#pragma NDIS_PAGABLE_FUNCTION(DC21X4ReadSerialRom)

/*+
 *
 * DC21X4ReadSerialRom
 *
 * Routine Description:
 *
 *    Read the Dc21X4 Serial Rom to retrieve the adapter information
 *
 * Arguments:
 *
 *    Adapter
 *
 * Return Value:
 *
 *    Status
 *
 *
-*/
extern
NDIS_STATUS
DC21X4ReadSerialRom (
    IN PDC21X4_ADAPTER Adapter
    )

{
   UNALIGNED UCHAR *EthAddress;
   UCHAR IdProm[SROM_IEEE_LEN *2];
   
   ULONG Value;
   INT Time;
   UINT i;

#if __DBG
   DbgPrint ("DC21X4ReadSerialROM\n");
#endif
   
   //Read the Station Address
   
   switch (Adapter->AdapterType) {
      
      case NdisInterfacePci:
         
          // Read the Network Address from the PCI board ID ROM
          // through DC21X4's Serial ROM port
      
          switch (Adapter->DeviceId) {
         
             default:
            
                return DC21X4ParseSRom(Adapter);
         
             case DC21040_CFID:

                Adapter->MediaCapable =
                    (MEDIUM_10BT | MEDIUM_10B2 | MEDIUM_10B5);
            
                //Initialize DC21040s ID_PROM pointer
         
                DC21X4_WRITE_PORT(
                    DC21X4_IDPROM,
                    0
                    );
         
                // Read the 32 bytes of the Ethernet ID PROM
         
                for (i = 0; i < SROM_IEEE_LEN; i++) {
            
                    Time = SROM_TIMEOUT;
            
                    do {
                       NdisStallExecution(1*MILLISECOND);      // Wait 1 ms
                          DC21X4_READ_PORT(
                          DC21X4_IDPROM,
                          &Value
                          );
                    }
                    while ((Value & DC21X4_IDPROM_DATA_UNVALID) && ((Time--)>0));
                    if (Time > 0) {
                       IdProm[i] = (UCHAR)(Value & DC21X4_IDPROM_DATA);
                    }
                    else {
                       return NDIS_STATUS_FAILURE;
                    }
                }
         
                EthAddress = &IdProm[0];
             
          }
          break;
      
      case NdisInterfaceEisa:
         
          Adapter->MediaCapable =
             (MEDIUM_10BT | MEDIUM_10B2 | MEDIUM_10B5);

          // Read the 32 bytes of the Ethernet ID PROM
      
          for (i = 0; i < SROM_IEEE_LEN; i++) {
         
             NdisRawReadPortUchar(
                Adapter->PortOffset + EISA_ID_PROM_OFFSET,
                &IdProm[i]
                );
#if __DBG
             DbgPrint ("Eisa: IDROM  @%x  %x  r\n",
             Adapter->PortOffset + EISA_ID_PROM_OFFSET, IdProm[i]);
#endif
          }
      
          // Duplicate the ID Prom data in the 32 upper bytes of
          // the array to cover the case where the 2 test patterns
          // rap around the 32 bytes block
      
          MOVE_MEMORY (
             &IdProm[SROM_IEEE_LEN],
             &IdProm[0],
             SROM_IEEE_LEN
             );
      
          //Align on the test patterns
      
          for (i=4; i <= SROM_IEEE_LEN*2; i++) {
         
             if ( (*(UNALIGNED ULONG *)&IdProm[i-4] == TEST_PATTERN) &&
                (*(UNALIGNED ULONG *)&IdProm[i] == TEST_PATTERN)
                ) break;
             }
         
             if ( i >= SROM_IEEE_LEN ) {
                 // The test patterns were not found
                 Adapter->PermanentAddressValid = FALSE;
                 return NDIS_STATUS_SUCCESS;
             }
             else {
                 EthAddress = &IdProm[i+4];
             }
      
          break;
      
   }
   
   if (IS_NULL_ADDRESS(EthAddress)) {
      Adapter->PermanentAddressValid = FALSE;
#if __DBG
      DbgPrint ("SROM: NULL Burnt_In Ethernet Address\n");
#endif
   }
   else if ((*(PULONG)EthAddress & 0xFFFFFF) ==  ZX312_SIGNATURE) {
      // Zynx ZX312 Rev3's SROM does not contain a checksum
      Adapter->PermanentAddressValid = TRUE;
#if __DBG
      DbgPrint ("SROM: ZX312 Rev3\n");
#endif
   }
   else {
      Adapter->PermanentAddressValid =
         VerifyChecksum(EthAddress);
#if __DBG
      if (!Adapter->PermanentAddressValid)
         DbgPrint ("SROM: Invalid CheckSum\n");
#endif
   }
      
   if (Adapter->PermanentAddressValid) {
      MOVE_MEMORY (
         &Adapter->PermanentNetworkAddress[0],
         EthAddress,
         ETH_LENGTH_OF_ADDRESS
         );
   }
   
   
   //Sia values
   
   Adapter->Media[Medium10BaseT].SiaRegister[0] =  DC21040_SIA0_10BT;
   Adapter->Media[Medium10BaseT].SiaRegister[1] =  DC21040_SIA1_10BT;
   Adapter->Media[Medium10BaseT].SiaRegister[2] =  DC21040_SIA2_10BT;
   
   Adapter->Media[Medium10Base2].SiaRegister[0] = DC21040_SIA0_10B2;
   Adapter->Media[Medium10Base2].SiaRegister[1] = DC21040_SIA1_10B2;
   Adapter->Media[Medium10Base2].SiaRegister[2] = DC21040_SIA2_10B2;
   
   Adapter->Media[Medium10Base5].SiaRegister[0] = DC21040_SIA0_10B5;
   Adapter->Media[Medium10Base5].SiaRegister[1] = DC21040_SIA1_10B5;
   Adapter->Media[Medium10Base5].SiaRegister[2] = DC21040_SIA2_10B5;
   
   return NDIS_STATUS_SUCCESS;
   
}










#pragma NDIS_PAGABLE_FUNCTION(VerifyChecksum)

/*+
 *
 * VerifyChecksum
 *
 * Routine Description:
 *
 *    Verify the checksum of an Ethernet Address
 *
 * Arguments:
 *
 *    Adapter - The adapter which is being verified.
 *
 *    EthAddress - A pointer to the address to be checked
 *                 This 6_byte Ethernet address is followed
 *                 by a zero byte, followed by a value such
 *                 that the sum of a checksum on the Ethernet
 *                 address and this value is 0xff.
 *
 * Return Value:
 *
 *    TRUE if success
 *
-*/


BOOLEAN
VerifyChecksum(
    IN UNALIGNED UCHAR *EthAddress
    )
{
   
   UINT i;
   UCHAR CheckSum[2];
   ULONG Sum = 0;
   
   // The checksum yields from the polynom:
   //        10       2        9                 8
   // (B[0]*2 + B[1]*2 + B[2]*2 + B[3]*2 + B[4]*2 + B[5]) mod (2**16-1)
   
   for (i=0; i<= 2; i++) {
      
      Sum *= 2;
      
      if (Sum > 0xffff) Sum -= 0xffff;
         
         Sum += (*(EthAddress+(2*i)) << 8) + *(EthAddress+(2*i)+1);
         
         if (Sum > 0xffff) Sum -= 0xffff;
      }
      
      if (Sum >= 0xffff) {
      Sum = 0;
   }
   
   CheckSum[0] = (UCHAR)(Sum / 0x100);
   CheckSum[1] = (UCHAR)(Sum % 0x100);
   
#if __DBG
   DbgPrint("  CheckSum = %02x %02x\n",CheckSum[0],CheckSum[1]);
#endif
   return  (*(UNALIGNED USHORT *)CheckSum == *(UNALIGNED USHORT *)(EthAddress + 6)) ;
   
}










/*+
 *   DC21X4ParseExtendedBlock
 *
 * Routine Description:
 *
 *   This routine is called by the SROM Parser and takes care of the
 *   parsing of the info block with Extended format (EXT=1) in the 21140's
 *   info leaf.
 *
 * Arguments:
 *
 *    Adapter     - Pointer to the Data Structure
 *    MediaBlock  - Pointer to the Serial Rom data.
 *    GeneralPurposeCtrl - Value of the General Purpose Ctrl
 *
 * Return Value:
 *
 *    None
 *
-*/
extern
VOID
DC21X4ParseExtendedBlock(
   IN PDC21X4_ADAPTER Adapter,
   IN OUT UNALIGNED UCHAR **MediaBlock,
   IN USHORT GeneralPurposeCtrl,
   OUT PUCHAR PMediaCode
   )
{

   UNALIGNED UCHAR  *DataBytePtr; 
   UNALIGNED USHORT *DataWordPtr;
   UNALIGNED UCHAR  *EndOfBlock;
   
   UCHAR MediaCode;  
   
   INT   i;
   INT   PhyNumber;
   UCHAR Length;
   UCHAR Type;
   USHORT External;

   DataBytePtr = (UNALIGNED CHAR *)(*MediaBlock); 

   Length = (*(DataBytePtr++) & LENGTH);
   EndOfBlock = DataBytePtr + Length;
   
   Type = *(DataBytePtr++);

#if __DBG
   DbgPrint("Block Length =%02x\n", Length);
   DbgPrint("Block Type   =%02x\n", Type);
#endif


   switch (Type) {

     case TYPE_0:

         DC21X4ParseFixedBlock(
              Adapter, 
              &DataBytePtr,
              GeneralPurposeCtrl,
              PMediaCode
              );
         break;

     case TYPE_1:
     case TYPE_3:

         PhyNumber = (INT) *(DataBytePtr++);
         if (PhyNumber >= MAX_PHY_TABLE) {
#if __DBG
            DbgPrint("PhyNumber =%02x  Out of RANGE!!!\n", PhyNumber);
#endif
            break;
         }

         //General Purpose Control
         Adapter->Phy[PhyNumber].GeneralPurposeCtrl = GeneralPurposeCtrl;

         //General Purpose Data

         Adapter->Phy[PhyNumber].GepSequenceLength = (INT) *(DataBytePtr++);

         if (Adapter->Phy[PhyNumber].GepSequenceLength > MAX_GPR_SEQUENCE) {
#if __DBG
            DbgPrint("GepSequence =%02x  Out of RANGE!!!\n",
                      Adapter->Phy[PhyNumber].GepSequenceLength );
#endif
            break;
         }

         switch (Type) {

            case TYPE_1:

               //GepSequence Length in bytes

               for (i=0; i < Adapter->Phy[PhyNumber].GepSequenceLength; i++) {
                   Adapter->Phy[PhyNumber].GepSequence[i] = *(DataBytePtr++);
               }
               break;

            case TYPE_3:

               //GepSequence Length in words

               for (i=0; i < Adapter->Phy[PhyNumber].GepSequenceLength; i++) {
                   Adapter->Phy[PhyNumber].GepSequence[i] = *(UNALIGNED USHORT *)(DataBytePtr);
                   DataBytePtr += sizeof(USHORT);
               }
               break;
         }  
         
         // Reset sequence

         Adapter->Phy[PhyNumber].ResetSequenceLength = (INT) *(DataBytePtr++);

         if (Adapter->Phy[PhyNumber].ResetSequenceLength > MAX_RESET_SEQUENCE) {
#if __DBG
            DbgPrint("ResetSequence =%02x  Out of RANGE!!!\n",
                      Adapter->Phy[PhyNumber].ResetSequenceLength );
#endif
            break;
         }

         for (i=0; i < Adapter->Phy[PhyNumber].ResetSequenceLength; i++) {
               Adapter->Phy[PhyNumber].ResetSequence[i] = *(DataBytePtr++);
         }

         // Capabilities,Nway,FullDuplex & TxmThreshold

         DataWordPtr = (UNALIGNED USHORT *) DataBytePtr;

         Adapter->Phy[PhyNumber].MediaCapabilities =
                                     (*(DataWordPtr++) & MEDIA_CAPABILITIES_MASK);
         Adapter->Phy[PhyNumber].NwayAdvertisement =
                                     (*(DataWordPtr++) & NWAY_ADVERTISEMENT_MASK);
         Adapter->Phy[PhyNumber].FullDuplexBits =
                                     (*(DataWordPtr++) & MEDIA_CAPABILITIES_MASK);
         Adapter->Phy[PhyNumber].TxThresholdModeBits =
                                     (*(DataWordPtr++) & MEDIA_CAPABILITIES_MASK);
         Adapter->Phy[PhyNumber].Present = TRUE;

         Adapter->PhyMediumInSrom = TRUE;

         DataBytePtr = (UNALIGNED UCHAR *) DataWordPtr;

         // GEP Interrupt

         switch (Type) {

            case TYPE_3:

               Adapter->Phy[PhyNumber].GepInterruptMask = 
                  *(DataBytePtr++) << DC21X4_GEP_INTERRUPT_BIT_SHIFT;
               break;
         }


#if __DBG
         DbgPrint("PHY Number= %02x\n", PhyNumber);
         DbgPrint("GPR Sequence Length= %d\n", Adapter->Phy[PhyNumber].GepSequenceLength);
         for (i=0; i < Adapter->Phy[PhyNumber].GepSequenceLength; i++) {
           DbgPrint("GPR Sequence[%d]=%02x\n", i, Adapter->Phy[PhyNumber].GepSequence[i]);
         }
         DbgPrint("RESET Sequence Length= %d\n", Adapter->Phy[PhyNumber].ResetSequenceLength);
         for (i=0; i < Adapter->Phy[PhyNumber].ResetSequenceLength; i++) {
           DbgPrint("RESET Sequence[%d]=%02x\n", i, Adapter->Phy[PhyNumber].ResetSequence[i]);
         }
         DbgPrint("Media Capabilities= %04x\n", Adapter->Phy[PhyNumber].MediaCapabilities);
         DbgPrint("NWAY Advertisement= %04x\n", Adapter->Phy[PhyNumber].NwayAdvertisement);
         DbgPrint("FD Bit map= %02x\n",Adapter->Phy[PhyNumber].FullDuplexBits);
         DbgPrint("TTM Bit map= %02x\n",Adapter->Phy[PhyNumber].TxThresholdModeBits);
         DbgPrint("GEP Interrupt mask = %01x\n",Adapter->Phy[PhyNumber].GepInterruptMask);
#endif

         break;

     case TYPE_2:

         MediaCode = *(DataBytePtr) & DC21X4_MEDIA;
         if (MediaCode >= MAX_MEDIA_TABLE) {
             break;
         }
         Adapter->MediaCapable |= 1 << MediaCode;
         External = *(DataBytePtr++) & EXT;
#if __DBG
         DbgPrint("SRom: Media Code= %02x\n", MediaCode);
         DbgPrint("SRom: Media Capable= %02x\n", Adapter->MediaCapable);
#endif

         DataWordPtr = (UNALIGNED USHORT *)DataBytePtr;

         if (External) {
            
             // EXT bit is set :
             // overwrite the SIA Registers default values
             // with the values stored into the SROM
            
             Adapter->Media[MediaCode].SiaRegister[0] =
                 ((ULONG)*(DataWordPtr++) & 0xFFFF);
             Adapter->Media[MediaCode].SiaRegister[1] =
                 ((ULONG)*(DataWordPtr++) & 0xFFFF);
             Adapter->Media[MediaCode].SiaRegister[2] =
                 ((ULONG)*(DataWordPtr++) & 0xFFFF);
#if __DBG
             DbgPrint("SRom: EXT= 1:\n");
             DbgPrint("SRom: SiaReg[0]= %08x\n",Adapter->Media[MediaCode].SiaRegister[0]);
             DbgPrint("SRom: SiaReg[1]= %08x\n",Adapter->Media[MediaCode].SiaRegister[1]);
             DbgPrint("SRom: SiaReg[2]= %08x\n",Adapter->Media[MediaCode].SiaRegister[2]);
#endif
         }
         Adapter->Media[MediaCode].GeneralPurposeCtrl =
                    ((ULONG)*(DataWordPtr++) & 0xFFFF);
         Adapter->Media[MediaCode].GeneralPurposeData =
                    ((ULONG)*(DataWordPtr) & 0xFFFF);
#if __DBG
         DbgPrint("SRom: Gep Ctrl = %08x\n",Adapter->Media[MediaCode].GeneralPurposeCtrl);
         DbgPrint("SRom: Gep Data = %08x\n",Adapter->Media[MediaCode].GeneralPurposeData);
#endif

         *PMediaCode = MediaCode;

         break;


     default:

#if __DBG
         DbgPrint("Type =%02x  unknown... skipping\n", Type );
#endif
         break;

   }

   *MediaBlock = EndOfBlock;

}










/*+
 *   DC21X4ParseFixedBlock
 *
 * Routine Description:
 *
 *   This routine is called by the SROM Parser and takes care of the
 *   parsing of the info block with fixed format (EXT=0) in the 21140's
 *   info leaf.
 *
 * Arguments:
 *
 *    Adapter     - Pointer to the Data Structure
 *    DataBytePtr  - Pointer to the Serial Rom data.
 *    GeneralPurposeCtrl - Value of the General Purpose Ctrl
 *
 * Return Value:
 *
 *    None.
 *
-*/
extern
VOID
DC21X4ParseFixedBlock(
   IN PDC21X4_ADAPTER Adapter,
   IN OUT UNALIGNED UCHAR **MediaBlock,
   IN USHORT GeneralPurposeCtrl,
   OUT PUCHAR PMediaCode
   ) 
{
   UNALIGNED UCHAR  *DataBytePtr; 
   UCHAR MediaCode;

   DataBytePtr = (UNALIGNED CHAR *)(*MediaBlock); 

   MediaCode = *(DataBytePtr) & DC21X4_MEDIA;

   if (MediaCode >= MAX_MEDIA_TABLE) {
        DataBytePtr += ((2*sizeof(DataBytePtr)) + sizeof(USHORT));
        *MediaBlock = DataBytePtr;
        return ;
   }
   Adapter->MediaCapable |= 1 << MediaCode;

   Adapter->Media[MediaCode].GeneralPurposeCtrl = 
                                      (ULONG)GeneralPurposeCtrl;
   Adapter->Media[MediaCode].GeneralPurposeData = 
                                      (ULONG)(*(++DataBytePtr) & 0xFF);
   Adapter->Media[MediaCode].Mode =
                                      GET_MODE(++DataBytePtr);
   Adapter->Media[MediaCode].Polarity =
                                      GET_POLARITY(DataBytePtr);
   Adapter->Media[MediaCode].SenseMask =
                                      GET_SENSE_MASK(DataBytePtr);

#if __DBG
   DbgPrint("Media Code= %02x\n", MediaCode);
   DbgPrint("Media Capable= %02x\n", Adapter->MediaCapable);
   DbgPrint("GPData= %02x\n",Adapter->Media[MediaCode].GeneralPurposeData);
   DbgPrint("Mode= %02x\n",Adapter->Media[MediaCode].Mode);
   DbgPrint("Polarity= %x\n",Adapter->Media[MediaCode].Polarity);
   DbgPrint("Sense Mask= %x\n",Adapter->Media[MediaCode].SenseMask);
#endif

   Adapter->Media[MediaCode].Mode |= 
       (Adapter->Media[MediaCode].Mode & DC21X4_TXM_THRESHOLD_MODE)?
       Adapter->Threshold10Mbps :  Adapter->Threshold100Mbps;

   if (  Adapter->Media[MediaCode].SenseMask
           && MediaCode != Medium10BaseTFd
           && MediaCode != Medium100BaseTxFd
           && MediaCode != Medium100BaseFxFd){

        //Add the media code to the MediaPrecedence table
        Adapter->MediaPrecedence[Adapter->MediaCount++] = MediaCode;
   }

   // Check if default media
   if (IF_DEFAULT_MEDIA(DataBytePtr)) {
        Adapter->DefaultMediumFlag = TRUE;
        Adapter->DefaultMedium = MediaCode;
#if __DBG
        DbgPrint("SRom: Default Media = %04x\n",MediaCode);
#endif
   }


   *PMediaCode = MediaCode;

   DataBytePtr += sizeof(USHORT);
   *MediaBlock = DataBytePtr;

}











#pragma NDIS_PAGABLE_FUNCTION(DC21X4ParseSRom)

/*
 *   DC21X4ParseSRom
 *
 * Routine Description:
 *
 *   ParseSRom parses the Serial ROM to retrieve the Ethernet Station
 *   address of the adapter and the adapter's media specific information
 *
 *    Adapter     - pointer to adapter structure
 *
 * Return Value:
 *
 *    Ndis Status
 *
-*/


NDIS_STATUS
DC21X4ParseSRom(
        IN PDC21X4_ADAPTER Adapter
        )
{
   
   PSROM_ID_BLOCK SRomIdBlock;
   UNALIGNED ADAPTER_ENTRIES *AdapterEntry;
   UNALIGNED UCHAR  *DataBytePtr;
   UNALIGNED USHORT *DataWordPtr;
   PUCHAR SRomData;
   
   USHORT GeneralPurposeCtrl;
   USHORT MediaCount;
   USHORT MediaType;
   UCHAR MediaCode;
   ULONG Offset = 0;
   INT Index = 0;
   INT i;
   
   BOOLEAN ExtendedFormat;
 
   ULONG CheckSum;
   UCHAR Tmp[ETH_LENGTH_OF_ADDRESS];
   
   UCHAR DC21140Leaf [] = {
      0x00,0x08,             // AutoSense
      0x1f,                  // General Purpose Ctrl
      0x04,                  // Media Count
      0x00,0x0b,0x8e,0x00,   // Tp
      0x03,0x1b,0x6d,0x00,   // 100BaseTx
      0x04,0x03,0x8e,0x00,   // TpFd
      0x05,0x1b,0x6d,0x00    // 100BaseTxFd
   };
   
UCHAR DE500Strng[] = {"DE500-XA"};


   NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;


   // Allocate space to dump the whole SROM

   ALLOC_MEMORY (&NdisStatus, &SRomData, SROM_SIZE);
   if (NdisStatus != NDIS_STATUS_SUCCESS) {
#if __DBG
      DbgPrint ( "SROM ALLOC_MEMORY FAILED\n");
#endif
      return NdisStatus;
   }

   // Read the whole ROM

   if (DC21X4ReadSRom(
                 Adapter,
                 &Offset,
                 SROM_SIZE,
                 SRomData)) {
   
       SRomIdBlock = (PSROM_ID_BLOCK)SRomData;
   }
   else {
#if __DBG
       DbgPrint ( "ReadSRom failed\n");
#endif
       FREE_MEMORY(SRomData, SROM_SIZE);
       return NDIS_STATUS_HARD_ERRORS;
   }

   // Check the Checksum

   CheckSum = CRC32(SRomData,SROM_SIZE-2) & 0xFFFF;
   if (CheckSum != *(PUSHORT)&SRomData[SROM_SIZE-2]) {
   
       // Check if the SROM is a "legacy" formated SROM
       // containing only the network address
   
       if ((Adapter-> DeviceId == DC21140_CFID)
          && !IS_NULL_ADDRESS(SRomData)
          && VerifyChecksum(SRomData)
          ) {
      
#if __DBG
          DbgPrint ( "Legacy SRom...\n");
#endif
          MOVE_MEMORY (
             &Adapter->PermanentNetworkAddress[0],
             &SRomData[0],
             ETH_LENGTH_OF_ADDRESS
             );
      
          Adapter->PermanentAddressValid = TRUE;
      
          SRomIdBlock->FormatVersion = SROM_LEGACY;
          DataBytePtr = &DC21140Leaf[0];
       }
   
       else {
#if __DBG
          DbgPrint ( "Invalid SROM Checksum - Expected:%04x  Read:%04x\n",
          CheckSum,*(PUSHORT)&SRomData[SROM_SIZE-2]);
#endif
          FREE_MEMORY(SRomData, SROM_SIZE);
          return NDIS_STATUS_SOFT_ERRORS;
       }
   }

   // Check the SROM Version

   switch (SRomIdBlock->FormatVersion) {
   
       default:
      
#if __DBG
         DbgPrint ("SRom: Unsupported Format Version (%x)!\n", 
         SRomIdBlock->FormatVersion);
#endif
         FREE_MEMORY(SRomData, SROM_SIZE);
         return NDIS_STATUS_SOFT_ERRORS;
   
       case SROM_V1:
       case SROM_V3:     

         // Parse the Adapter Device Number.
#if __DBG
         DbgPrint ("SRom: Version: %2x\n",SRomIdBlock->FormatVersion );
         DbgPrint ("SRom: Adapter Count: %2x\n", SRomIdBlock->AdapterCount);
         DbgPrint ("SRom: Network Base Address: %02x-%02x-%02x-%02x-%02x-%02x\n",
            SRomIdBlock->NetworkAddress[0],SRomIdBlock->NetworkAddress[1],
            SRomIdBlock->NetworkAddress[2],SRomIdBlock->NetworkAddress[3],
            SRomIdBlock->NetworkAddress[4],SRomIdBlock->NetworkAddress[5]);
#endif
   
         AdapterEntry = (PADAPTER_ENTRIES)&SRomData[sizeof(SROM_ID_BLOCK)];
   
         if ((INT)SRomIdBlock->AdapterCount > 1) {
      
            // Parse the Adapter's Device Number.
            for (; Index < (INT)SRomIdBlock->AdapterCount; Index++,AdapterEntry++) {
         
#if __DBG
               DbgPrint ("SRom: DeviceNumber, %2x\n",AdapterEntry->DeviceNumber );
               DbgPrint ("SRom: Offset, %4x\n", AdapterEntry->Offset);
#endif
               if (AdapterEntry->DeviceNumber == (UCHAR)Adapter->SlotNumber) {
                  break;
               }
            }
         }
   
         if (Index == (INT)SRomIdBlock->AdapterCount) {
#if __DBG
            DbgPrint("SRom: Adapter's Device Number %d not found in SROM\n",
            Adapter->SlotNumber);
#endif
            FREE_MEMORY(SRomData, SROM_SIZE);
            return NDIS_STATUS_ADAPTER_NOT_FOUND;
         }
   
         // Check if the Station Address is a NULL Address
   
         if IS_NULL_ADDRESS(SRomIdBlock->NetworkAddress) {
      
#if __DBG
            DbgPrint ("SRom: NULL Network Address\n");
#endif
            Adapter->PermanentAddressValid = FALSE;
         }
         else  {
      
            if (Index !=0) {
         
               // Add the adapter index to the base network Address
               // (The carry is propagated to the 3 lower bytes
               // of the address only (the 3 upper bytes are the vendor id))
         
               for (i=0;i<3;i++) {
                  Tmp[i] = SRomIdBlock->NetworkAddress[ETH_LENGTH_OF_ADDRESS-(i+1)];
               }
               *(UNALIGNED ULONG *)&Tmp[0] += Index;
               for (i=0;i<3;i++) {
                  SRomIdBlock->NetworkAddress[ETH_LENGTH_OF_ADDRESS-(i+1)] = Tmp[i];
               }
         
         
            }
#if __DBG
            DbgPrint ("SRom: Network Address: %02x-%02x-%02x-%02x-%02x-%02x\n",
               SRomIdBlock->NetworkAddress[0],SRomIdBlock->NetworkAddress[1],
               SRomIdBlock->NetworkAddress[2],SRomIdBlock->NetworkAddress[3],
               SRomIdBlock->NetworkAddress[4],SRomIdBlock->NetworkAddress[5]);
#endif
            MOVE_MEMORY (
               &Adapter->PermanentNetworkAddress[0],
               SRomIdBlock->NetworkAddress,
               ETH_LENGTH_OF_ADDRESS
               );
      
            Adapter->PermanentAddressValid = TRUE;
         }
   
         //Parse the Media Info Blocks.
   
         DataBytePtr = &(SRomData[AdapterEntry->Offset]);

       case SROM_LEGACY:
      
         Adapter->MediaCapable = 0;
   
         switch (Adapter-> DeviceId) {

             case DC21041_CFID:
         
                  // Initialize the Media table with the default values.
      
                  Adapter->Media[Medium10BaseT].SiaRegister[0] = DC21041_SIA0_10BT;
                  Adapter->Media[Medium10BaseT].SiaRegister[1] = DC21041_SIA1_10BT;
                  Adapter->Media[Medium10BaseT].SiaRegister[2] = DC21041_SIA2_10BT;
      
                  Adapter->Media[Medium10Base2].SiaRegister[0] = DC21041_SIA0_10B2;
                  Adapter->Media[Medium10Base2].SiaRegister[1] = DC21041_SIA1_10B2;
                  Adapter->Media[Medium10Base2].SiaRegister[2] = DC21041_SIA2_10B2;
      
                  Adapter->Media[Medium10Base5].SiaRegister[0] = DC21041_SIA0_10B5;
                  Adapter->Media[Medium10Base5].SiaRegister[1] = DC21041_SIA1_10B5;
                  Adapter->Media[Medium10Base5].SiaRegister[2] = DC21041_SIA2_10B5;
      
                  MediaType = *(UNALIGNED USHORT *)DataBytePtr;
                  DataBytePtr += sizeof(USHORT);
            
                  MediaCount = *(DataBytePtr++);
#if __DBG
                  DbgPrint("SRom: MediaType= %04x \n", MediaType);
                  DbgPrint("SRom: Media Count= %d \n", MediaCount);
#endif
                  for (Index=0; Index < MediaCount; Index++) {
         
                     MediaCode = *DataBytePtr & DC21X4_MEDIA;
                     
                     if (MediaCode >= MAX_MEDIA_TABLE) {
                        DataBytePtr += (sizeof(DataBytePtr) 
                           + ((*DataBytePtr & EXT) ? (3 * sizeof(DataWordPtr)):0));
                        continue;
                     }
         
                     Adapter->MediaCapable |= 1 << MediaCode;
#if __DBG
                     DbgPrint("SRom: Media Code= %02x\n", MediaCode);
                     DbgPrint("SRom: Media Capable= %02x\n", Adapter->MediaCapable);
#endif
         
                     if (*(DataBytePtr++) & EXT) {
            
                        // EXT bit is set :
                        // overwrite the SIA Registers default values
                        // with the values stored into the SROM
            
                        DataWordPtr = (UNALIGNED USHORT *) DataBytePtr;
                        Adapter->Media[MediaCode].SiaRegister[0] =
                           ((ULONG)*(DataWordPtr++) & 0xFFFF);
                        Adapter->Media[MediaCode].SiaRegister[1] =
                           ((ULONG)*(DataWordPtr++) & 0xFFFF);
                        Adapter->Media[MediaCode].SiaRegister[2] =
                           ((ULONG)*(DataWordPtr++) & 0xFFFF);
                        DataBytePtr = (UNALIGNED UCHAR *) DataWordPtr;
#if __DBG
                        DbgPrint("SRom: EXT= 1:\n");
                        DbgPrint("SRom: SiaReg[0]= %08x\n",Adapter->Media[MediaCode].SiaRegister[0]);
                        DbgPrint("SRom: SiaReg[1]= %08x\n",Adapter->Media[MediaCode].SiaRegister[1]);
                        DbgPrint("SRom: SiaReg[2]= %08x\n",Adapter->Media[MediaCode].SiaRegister[2]);
#endif
                     }
         
                  }

                  break;

             case DC21140_CFID:
         
                  switch (SRomIdBlock->FormatVersion) {
         
                     case SROM_LEGACY:
                     case SROM_V1:
            
                         if (Adapter->RevisionNumber == DC21140_REV1_1) {
                             Adapter->DynamicAutoSense = BOARD_SIGNATURE(SRomData);
                             break;
                         }
          
                     default:
            
                  //MediaType
      
                        MediaType = *(UNALIGNED USHORT *)DataBytePtr;
                        Adapter->DynamicAutoSense = ((MediaType & DISABLE_AUTOSENSE) == 0);
#if __DBG
                        DbgPrint("SRom: MediaType= %04x \n", MediaType);
#endif
                  }

#if __DBG
                  DbgPrint("SRom: Dynamic Autosense %s\n",
                            Adapter->DynamicAutoSense? "Enabled":"Disabled");
#endif
      
                  DataBytePtr += sizeof(USHORT);

                  GeneralPurposeCtrl = (((USHORT)*(DataBytePtr++) & 0xFF)|(0x100));
      
                  MediaCount = *(DataBytePtr++);
      
#if __DBG
                  DbgPrint("SRom: General Purpose Control= %08x \n", GeneralPurposeCtrl);
                  DbgPrint("SRom: MediaCount= %d \n", MediaCount);
#endif
                  for (Index=0; Index < MediaCount; Index++) {

                      ExtendedFormat = (*DataBytePtr & EXTENDED_FORMAT);

                      if ((SRomIdBlock->FormatVersion == SROM_V3) && ExtendedFormat) {
                         DC21X4ParseExtendedBlock(
                                Adapter, 
                                &DataBytePtr, 
                                GeneralPurposeCtrl,
                                &MediaCode
                                );
                      }
                      else {
                         DC21X4ParseFixedBlock(
                                Adapter, 
                                &DataBytePtr,
                                GeneralPurposeCtrl,
                                &MediaCode
                                );
                      }

                  }

                  if (!Adapter->DefaultMediumFlag && Adapter->MediaCount>0) {
                     Adapter->DefaultMedium =
                        Adapter->MediaPrecedence[Adapter->MediaCount-1];
                  }
                  break;
      
             case DC21142_CFID:
         
                  if (SRomIdBlock->FormatVersion < SROM_V3) {
#if __DBG
                      DbgPrint ("SRom: Unsupported Format Version (%x)!\n", 
                           SRomIdBlock->FormatVersion);
#endif
                      FREE_MEMORY(SRomData, SROM_SIZE);
                      return NDIS_STATUS_SOFT_ERRORS;
                  }

                  // Initialize the Media table with the default values.
      
                  Adapter->Media[Medium10BaseT].SiaRegister[0] = DC21142_SIA0_10BT;
                  Adapter->Media[Medium10BaseT].SiaRegister[1] = DC21142_SIA1_10BT;
                  Adapter->Media[Medium10BaseT].SiaRegister[2] = DC21142_SIA2_10BT;
      
                  Adapter->Media[Medium10Base2].SiaRegister[0] = DC21142_SIA0_10B2;
                  Adapter->Media[Medium10Base2].SiaRegister[1] = DC21142_SIA1_10B2;
                  Adapter->Media[Medium10Base2].SiaRegister[2] = DC21142_SIA2_10B2;
      
                  Adapter->Media[Medium10Base5].SiaRegister[0] = DC21142_SIA0_10B5;
                  Adapter->Media[Medium10Base5].SiaRegister[1] = DC21142_SIA1_10B5;
                  Adapter->Media[Medium10Base5].SiaRegister[2] = DC21142_SIA2_10B5;

      
                  MediaType = *(UNALIGNED USHORT *)DataBytePtr;
      
                  Adapter->DynamicAutoSense = ((MediaType & DISABLE_AUTOSENSE) == 0);
#if __DBG
                  DbgPrint("SRom: Dynamic Autosense %s\n",
                  Adapter->DynamicAutoSense? "Enabled":"Disabled");
#endif
                  DataBytePtr += sizeof(USHORT);
                  MediaCount = *(DataBytePtr++);
#if __DBG
                  DbgPrint("SRom: MediaType= %04x \n", MediaType);
                  DbgPrint("SRom: MediaCount= %d \n", MediaCount);
#endif

                  for (Index=0; Index < MediaCount; Index++) {

                         DC21X4ParseExtendedBlock(
                             Adapter, 
                             (PVOID)&DataBytePtr,
                             (USHORT)NULL,
                             &MediaCode
                             );
                  }

                  if (!Adapter->DefaultMediumFlag && Adapter->MediaCount>0) {
                     Adapter->DefaultMedium =
                        Adapter->MediaPrecedence[Adapter->MediaCount-1];
                  }

                  break;

             default:
         
                  NdisStatus = NDIS_STATUS_DEVICE_FAILED;
         }
   
         break;
   
   }

   if (  (MediaCount == 1) 
      && Adapter->MediaCapable 
      && !Adapter->PhyMediumInSrom
      ) {
  
      //Force MediaType to the single supported medium
#if __DBG
      DbgPrint("SRom: One single supported medium: Force MediaType %04x to ",Adapter->MediaType);
#endif
      Adapter->MediaType &= ~(MEDIA_MASK | MEDIA_AUTOSENSE);
      Adapter->MediaType |= MediaCode;
#if __DBG
      DbgPrint("%04x\n",Adapter->MediaType);
#endif
   }

   //if no 10Base port is populated, switch Port_Select to 100Base 

   if (!(Adapter->MediaCapable & (MEDIUM_10BT | MEDIUM_10B2 | MEDIUM_10B5))) {
      Adapter->OperationMode |= DC21X4_PORT_SELECT;
   }
  
   FREE_MEMORY(SRomData, SROM_SIZE);
   return NdisStatus;


}









#pragma NDIS_PAGABLE_FUNCTION(DC21X4ReadSRom)

/*
 *   DC21X4ReadSRom
 *
 * Routine Description:
 *
 *   ReadSRom is called by DC21X4RegisterAdapter to read the onboard ROM
 *   for the network address and other parameters.
 *   This routine reads the required number of bytes from the given
 *   offset in the ROM.
 *
 * Arguments:
 *
 *    Adapter     -
 *
 *    Offset      - byte offset into SROM to start reading from. Must
 *                  be word aligned
 *    Len         - number of bytes to read
 *    Data        - pointer to buffer to read data into.
 *                  if NULL, don't return data
 *
 * Return Value:
 *
 *   TRUE if success, FALSE if hardware failure encountered.
 *
-*/


BOOLEAN
DC21X4ReadSRom(
   IN PDC21X4_ADAPTER Adapter,
   IN OUT PULONG Offset,
   IN USHORT Len,
   OUT PUCHAR Buffer
   )
{
   
   INT i;
   INT j;
   ULONG  Dbit;
   ULONG  Dout;
   USHORT WOffset;
   USHORT WLen;
   USHORT WData;
   
   // Make sure the ROM_Address is EVEN.
   
   if (*Offset & 1)
      {
#if __DBG
      DbgPrint ("ReadSRom failure - Offset not word aligned\n");
#endif
      return FALSE;
   }
   
   // Round up the length to multiple of words.
   WLen = (Len + 1) / 2;
   
   // Convert the ROM_Address byte offset to word offset
   WOffset = (USHORT)(*Offset >> 1);
   
   // Make sure the requested read does not exceed the ROM size
   
   if ( (WOffset + WLen) > SROM_93LC46B_SIZE) {
#if __DBG
      DbgPrint ("ReadSRom warning - address range excedes ROM size\n");
#endif
      return FALSE;
   }
   
   
   // Switch CSR to work with new SROM interface
   
   DC21X4_WRITE_PORT(
      DC21X4_IDPROM,
      CSR_WRITE | SEL_SROM
      );
   
   // Make sure SROM is in idle state
   // (deliver it enough clocks with CS set, Din = 0).
   
   for (i = 0; i < SROM_93LC46B_MAX_CYCLES; i++) {
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | CLK
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
   }
   
   DC21X4_WRITE_PORT(
      DC21X4_IDPROM,
      CSR_WRITE | SEL_SROM
      );
   
   NdisStallExecution(SROM_93LC46B_DELAY);
   
   
   // Read the data
   
   for (j = 0; j < WLen; j++,WOffset++) {
      
      //Output the READ command to the SROM
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | DATA_1
         );
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | CLK | DATA_1
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | DATA_1
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | DATA_1
         );
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | CLK | DATA_1
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | DATA_1
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | DATA_0
         );
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | CLK | DATA_0
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM | CS | DATA_0
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
      
      // Output the WORD Address of the SROM
      
      for (i = SROM_93LC46B_ADDRESS_MSB; i>= 0; i--) {
         
         Dbit = (USHORT)((WOffset >> i) & 1) << 2;
         
         DC21X4_WRITE_PORT(
            DC21X4_IDPROM,
            CSR_WRITE | SEL_SROM | CS | Dbit
            );
         
         DC21X4_WRITE_PORT(
            DC21X4_IDPROM,
            CSR_WRITE | SEL_SROM | CS | CLK | Dbit
            );
         
         NdisStallExecution(SROM_93LC46B_DELAY);
         
         DC21X4_WRITE_PORT(
            DC21X4_IDPROM,
            CSR_WRITE | SEL_SROM | CS | Dbit
            );
         
         NdisStallExecution(SROM_93LC46B_DELAY);
         
      }
      
      
      // Verify that the SROM output data became now 0.
      
      DC21X4_READ_PORT(
         DC21X4_IDPROM,
         &Dout
         );
      
      if (Dout & SROM_93LC46B_VALID_BITMASK) {
#if __DBG
         DbgPrint ("ReadSRom failure - SROM didn't become busy in read command\n");
#endif
         return(FALSE);
      }
      
      // Read the data from the SROM
      
      WData = 0;
      for (i = SROM_93LC46B_DATA_MSB; i >= 0; i--) {
         
         DC21X4_WRITE_PORT(
            DC21X4_IDPROM,
            CSR_WRITE | SEL_SROM | CS | CLK
            );
         
         NdisStallExecution(SROM_93LC46B_DELAY);
         
         DC21X4_READ_PORT(
            DC21X4_IDPROM,
            &Dout
            );
         
         DC21X4_WRITE_PORT(
            DC21X4_IDPROM,
            CSR_WRITE | SEL_SROM | CS
            );
         
         WData |= ((Dout >> SROM_93LC46B_DATA_BIT) & 1) << i;
         
         NdisStallExecution(SROM_93LC46B_DELAY);
         
      }
      
#if _DBG
      DbgPrint("Data = %04x\n",WData);
#endif
      
      // Put our read data in user buffer
      
      if (Buffer) {
         
         if (Len >= 2) {
            
            *(PUSHORT)Buffer = WData;
            Buffer += 2;
            Len -= 2;
         }
         else {
            
            // Least significant byte only is copied
            *Buffer = WData & 0xff;
            Buffer++;
            Len--;
         }
         
      }
      
      //Negate the chip select (CS) to end the SROM command
      
      DC21X4_WRITE_PORT(
         DC21X4_IDPROM,
         CSR_WRITE | SEL_SROM
         );
      
      NdisStallExecution(SROM_93LC46B_DELAY);
      
   }
   
   *Offset = WOffset << 1;
   return TRUE;
   
}