windows-xp/Source/XPSP1/NT/base/busdrv/pccard/pcmcibus/tuples.c

/*++

Copyright (c) 1997-2000 Microsoft Corporation

Module Name:

    tuples.c

Abstract:

    This module contains the code that parses and processes
    the configuration tuples of the PC Cards in the PCMCIA sockets

Author:

    Bob Rinne (BobRi) 3-Aug-1994
    Jeff McLeman 12-Apr-1994
    Ravisankar Pudipeddi (ravisp) 1-Nov-1996
    Neil Sandlin (neilsa) 1-Jun-1999

Revision History:

    Lotsa cleaning up. Support for PnP.
    orthogonalized tuple processing.
    Support links etc.

     - Ravisankar Pudipeddi (ravisp) 1-Dec-1996


Environment:

    Kernel mode

Revision History :

--*/

#include "pch.h"

#define  MAX_MISSED_TUPLES     256    // how many bad tuples will we tolerate?
#define  MAX_TUPLE_DATA_LENGTH 128    // Enough for the longest tuple


BOOLEAN
CheckLinkTarget(
   IN PTUPLE_PACKET TuplePacket
   );

UCHAR
ConvertVoltage(
   UCHAR MantissaExponentByte,
   UCHAR ExtensionByte
   );

VOID
PcmciaProcessPower(
   IN PTUPLE_PACKET TuplePacket,
   UCHAR        FeatureByte
   );

VOID
PcmciaProcessIoSpace(
   IN PTUPLE_PACKET TuplePacket,
   PCONFIG_ENTRY ConfigEntry
   );

VOID
PcmciaProcessIrq(
   IN PTUPLE_PACKET TuplePacket,
   PCONFIG_ENTRY ConfigEntry
   );

VOID
PcmciaProcessTiming(
   IN PTUPLE_PACKET TuplePacket,
   IN PCONFIG_ENTRY ConfigEntry
   );

VOID
PcmciaProcessMemSpace(
   IN PTUPLE_PACKET TuplePacket,
   IN PCONFIG_ENTRY ConfigEntry,
   IN UCHAR         MemSpace
   );

VOID
PcmciaMiscFeatures(
   IN PTUPLE_PACKET TuplePacket
   );

PCONFIG_ENTRY
PcmciaProcessConfigTable(
   IN PTUPLE_PACKET TuplePacket
   );

VOID
ProcessConfig(
   IN PTUPLE_PACKET TuplePacket
   );

VOID
ProcessConfigCB(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
InitializeTuplePacket(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
GetFirstTuple(
   IN PTUPLE_PACKET TuplePacket
   );

BOOLEAN
TupleMatches(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
GetNextTuple(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
NextTupleInChain(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
GetAnyTuple(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
FollowLink(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
NextLink(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
GetTupleData(
   IN PTUPLE_PACKET TuplePacket
   );

UCHAR
GetTupleChar(
   IN PTUPLE_PACKET TuplePacket
   );

NTSTATUS
ProcessLinkTuple(
   IN PTUPLE_PACKET TuplePacket
   );

BOOLEAN
PcmciaQuickVerifyTupleChain(
   IN PUCHAR Buffer,
   IN ULONG Length
   );

NTSTATUS
PcmciaMemoryCardHack(
   IN PSOCKET Socket,
   PSOCKET_DATA SocketData
   );

VOID
PcmciaCheckForRecognizedDevice(
   IN PSOCKET Socket,
   IN OUT PSOCKET_DATA SocketData
   );


//
// Some useful macros
//
// VOID
// PcmciaCopyIrqConfig(
//                    IN CONFIG_ENTRY DestConfig,
//                    IN CONFIG_ENTRY SourceConfig
//                    )
// Routine Description:
//      Copies the IRQ information from SourceConfig to DestConfig
//
// Arguments:
//
//     DestConfig - a pointer to the destination configuration entry
//     SourceConfig - a pointer to the source configuration entry
//
// Return Values:
//     None
//

#define PcmciaCopyIrqConfig(DestConfig, SourceConfig)                         \
                        {                                                     \
                           DestConfig->IrqMask = SourceConfig->IrqMask;       \
                           DestConfig->LevelIrq = SourceConfig->LevelIrq;     \
                           DestConfig->ShareDisposition =                     \
                                             SourceConfig->ShareDisposition;  \
                        }

//
// VOID
// PcmciaCopyIoConfig(
//                    IN CONFIG_ENTRY DestConfig,
//                    IN CONFIG_ENTRY SourceConfig
//                    )
// Routine Description:
//      Copies the Io space information from SourceConfig to DestConfig
//
// Arguments:
//
//     DestConfig - a pointer to the destination configuration entry
//     SourceConfig - a pointer to the source configuration entry
//
// Return Values:
//     None
//

#define PcmciaCopyIoConfig(DestConfig, SourceConfig)                               \
                        {                                                          \
                           DestConfig->NumberOfIoPortRanges =                      \
                                  SourceConfig->NumberOfIoPortRanges;              \
                           DestConfig->Io16BitAccess =                             \
                                  SourceConfig->Io16BitAccess;                     \
                           DestConfig->Io8BitAccess =                              \
                                  SourceConfig->Io8BitAccess;                      \
                           RtlCopyMemory(DestConfig->IoPortBase,                   \
                                         SourceConfig->IoPortBase,                 \
                                         sizeof(SourceConfig->IoPortBase[0])*      \
                                         SourceConfig->NumberOfIoPortRanges);      \
                           RtlCopyMemory(DestConfig->IoPortLength,                 \
                                         SourceConfig->IoPortLength,               \
                                         sizeof(SourceConfig->IoPortLength[0])*    \
                                         SourceConfig->NumberOfIoPortRanges);      \
                           RtlCopyMemory(DestConfig->IoPortAlignment,              \
                                         SourceConfig->IoPortAlignment,            \
                                         sizeof(SourceConfig->IoPortAlignment[0])* \
                                         SourceConfig->NumberOfIoPortRanges);      \
                        }

//
// VOID
// PcmciaCopyMemConfig(
//                    IN CONFIG_ENTRY DestConfig,
//                    IN CONFIG_ENTRY SourceConfig
//                    )
// Routine Description:
//      Copies the Memory space information from SourceConfig to DestConfig
//
// Arguments:
//
//     DestConfig - a pointer to the destination configuration entry
//     SourceConfig - a pointer to the source configuration entry
//
// Return Values:
//     None
//

#define PcmciaCopyMemConfig(DestConfig,SourceConfig)                              \
                        {                                                         \
                           DestConfig->NumberOfMemoryRanges =                     \
                                  SourceConfig->NumberOfMemoryRanges;             \
                           RtlCopyMemory(DestConfig->MemoryHostBase,              \
                                         SourceConfig->MemoryHostBase,            \
                                         sizeof(SourceConfig->MemoryHostBase[0])* \
                                         SourceConfig->NumberOfMemoryRanges);     \
                           RtlCopyMemory(DestConfig->MemoryCardBase,              \
                                         SourceConfig->MemoryCardBase,            \
                                         sizeof(SourceConfig->MemoryCardBase[0])* \
                                         SourceConfig->NumberOfMemoryRanges);     \
                           RtlCopyMemory(DestConfig->MemoryLength,                \
                                         SourceConfig->MemoryLength,              \
                                         sizeof(SourceConfig->MemoryLength[0])*   \
                                         SourceConfig->NumberOfMemoryRanges);     \
                        }




USHORT VoltageConversionTable[16] = {
   10, 12, 13, 15, 20, 25, 30, 35,
   40, 45, 50, 55, 60, 70, 80, 90
};

UCHAR TplList[] = {
   CISTPL_DEVICE,
   CISTPL_VERS_1,
   CISTPL_CONFIG,
   CISTPL_CFTABLE_ENTRY,
   CISTPL_MANFID,
   CISTPL_END
};

static unsigned short crc16a[] = {
   0000000,  0140301,  0140601,  0000500,
   0141401,  0001700,  0001200,  0141101,
   0143001,  0003300,  0003600,  0143501,
   0002400,  0142701,  0142201,  0002100,
};
static unsigned short crc16b[] = {
   0000000,  0146001,  0154001,  0012000,
   0170001,  0036000,  0024000,  0162001,
   0120001,  0066000,  0074000,  0132001,
   0050000,  0116001,  0104001,  0043000,
};




UCHAR
GetCISChar(
   IN PTUPLE_PACKET TuplePacket,
   IN ULONG Offset
   )
/*++

Routine Description:

  Returns the contents of the CIS memory of the PC-Card
  in the given socket, at the specified offset

Arguments:

   TuplePacket    - Pointer to the initialized tuple packet
   Offset         - Offset at which the CIS memory contents need to be read
                    This offset is added to the current offset position
                    of the CIS being read as indicated through the TuplePacket
                    to obtain the actual offset

Return Value:

   The byte at the specified offset of the CIS


--*/

{
   PPDO_EXTENSION pdoExtension = TuplePacket->SocketData->PdoExtension;
   MEMORY_SPACE MemorySpace;

   if (Is16BitCardInSocket(pdoExtension->Socket)) {
      if (TuplePacket->Flags & TPLF_COMMON) {

         MemorySpace = (TuplePacket->Flags & TPLF_INDIRECT) ?
                           PCCARD_COMMON_MEMORY_INDIRECT :
                           PCCARD_COMMON_MEMORY;

      } else {

         MemorySpace = (TuplePacket->Flags & TPLF_INDIRECT) ?
                           PCCARD_ATTRIBUTE_MEMORY_INDIRECT :
                           PCCARD_ATTRIBUTE_MEMORY;

      }
   } else {
      switch((TuplePacket->Flags & TPLF_ASI) >> TPLF_ASI_SHIFT) {
      case 0:
         MemorySpace = PCCARD_PCI_CONFIGURATION_SPACE;
         break;
      case 1:
         MemorySpace = PCCARD_CARDBUS_BAR0;
         break;
      case 2:
         MemorySpace = PCCARD_CARDBUS_BAR1;
         break;
      case 3:
         MemorySpace = PCCARD_CARDBUS_BAR2;
         break;
      case 4:
         MemorySpace = PCCARD_CARDBUS_BAR3;
         break;
      case 5:
         MemorySpace = PCCARD_CARDBUS_BAR4;
         break;
      case 6:
         MemorySpace = PCCARD_CARDBUS_BAR5;
         break;
      case 7:
         MemorySpace = PCCARD_CARDBUS_ROM;
         break;
      }
   }

   return PcmciaReadCISChar(pdoExtension, MemorySpace, TuplePacket->CISOffset + Offset);
}



UCHAR
ConvertVoltage(
   UCHAR MantissaExponentByte,
   UCHAR ExtensionByte
   )

/*++

Routine Description:

    Convert the voltage requirements for the PCCARD based on the
    mantissa and extension byte.

Arguments:

    MantissaExponentByte
    ExtensionByte

Return Value:

    The voltage specified in tenths of a volt.

--*/

{
   SHORT power;
   USHORT value;

   value = (USHORT) VoltageConversionTable[(MantissaExponentByte >> 3) & 0x0f];
   power = 1;

   if ((MantissaExponentByte & EXTENSION_BYTE_FOLLOWS) &&
       (((value / 10) * 10) == value) &&
       (ExtensionByte < 100)) {
      value = (10 * value + (ExtensionByte & 0x7f));
      power += 1;
   }

   power = (MantissaExponentByte & 0x07) - 4 - power;

   while (power > 0) {
      value *= 10;
      power--;
   }

   while (power < 0) {
      value /= 10;
      power++;
   }

   return (UCHAR) value;
}


VOID
PcmciaProcessPower(
   IN PTUPLE_PACKET TuplePacket,
   UCHAR        FeatureByte
   )

/*++

Routine Description:

    Process power information from CIS.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet
    FeatureByte - the feature byte from the tuple containing power information.

Return Value:

    none

--*/

{
   PSOCKET_DATA SocketData = TuplePacket->SocketData;
   UCHAR  powerSelect;
   UCHAR  bit;
   UCHAR  item;
   UCHAR  rawItem;
   UCHAR  extensionByte;
   UCHAR  index = 0;
   UCHAR  count = FeatureByte;
   UCHAR  skipByte;

   ASSERT(count <= 3);

   while (index < count) {
      powerSelect = GetTupleChar(TuplePacket);
      for (bit = 0; bit < 7; bit++) {
         if (powerSelect & (1 << bit)) {

            rawItem = GetTupleChar(TuplePacket);
            if (rawItem & EXTENSION_BYTE_FOLLOWS) {
               extensionByte = GetTupleChar(TuplePacket);

               //
               // Skip the rest
               //
               skipByte = extensionByte;
               while (skipByte & EXTENSION_BYTE_FOLLOWS) {
                  skipByte = GetTupleChar(TuplePacket);
               }
            } else {
               extensionByte = (UCHAR) 0;
            }

            if (bit == 0) {

               //
               // Convert nominal power for output.
               //

               item = ConvertVoltage(rawItem, extensionByte);
               switch (index) {
               case 0:
                  SocketData->Vcc = item;
                  break;
               case 1:
                  SocketData->Vpp2 = SocketData->Vpp1 = item;
                  break;
               case 2:
                  SocketData->Vpp2 = item;
                  break;
               }
            }
         }
      }
      index++;
   }
}


VOID
PcmciaProcessIoSpace(
   IN PTUPLE_PACKET TuplePacket,
   PCONFIG_ENTRY ConfigEntry
   )

/*++

Routine Description:

    Process I/O space information from CIS.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet
    ConfigEntry - a config entry structure in which to store the information.

Return Value:

    none

--*/

{
   ULONG  address = 0;
   ULONG  index=0, i;
   UCHAR  item = GetTupleChar(TuplePacket);
   UCHAR  ioAddrLines = (item & IO_ADDRESS_LINES_MASK);
   UCHAR  ranges=0;
   UCHAR  addressSize=0;
   UCHAR  lengthSize=0;

   ConfigEntry->Io16BitAccess = Is16BitAccess(item);
   ConfigEntry->Io8BitAccess  = Is8BitAccess(item);

   ranges = HasRanges(item);

   if ((!ranges) && (!ioAddrLines)) {

      //
      // The IBM token ring card has a slightly different interpretation
      // of the tuple data here.  It isn't clear it is incorrect.
      //

      ranges = 0xFF;
   }

   if (ranges) {
      //
      // Specific ranges listed in the tuple.
      //
      if (ranges == 0xFF) {
         //
         // Special processing for IBM token ring IoSpace layout.
         //

         addressSize = 2;
         lengthSize = 1;
         ranges = 1;
      } else {
         item = GetTupleChar(TuplePacket);
         ranges = item & RANGE_MASK;
         ranges++;

         addressSize = GetAddressSize(item);
         lengthSize  = GetLengthSize(item);
      }
      index = 0;
      while (ranges) {
         address = 0;
         if (addressSize >= 1) {
            address = (ULONG) GetTupleChar(TuplePacket);
         }
         if (addressSize >= 2) {
            address |= (GetTupleChar(TuplePacket)) << 8;
         }
         if (addressSize >= 3) {
            address |= (GetTupleChar(TuplePacket)) << 16;
            address |= (GetTupleChar(TuplePacket)) << 24;
         }
         ConfigEntry->IoPortBase[index] = (USHORT) address;

         address = 0;
         if (lengthSize >= 1) {
            address = (ULONG) GetTupleChar(TuplePacket);
         }
         if (lengthSize >= 2) {
            address |= (GetTupleChar(TuplePacket)) << 8;
         }
         if (lengthSize >= 3) {
            address |= (GetTupleChar(TuplePacket)) << 16;
            address |= (GetTupleChar(TuplePacket)) << 24;
         }
         ConfigEntry->IoPortLength[index] = (USHORT) address;
         ConfigEntry->IoPortAlignment[index] = 1;

         index++;

         if (index == MAX_NUMBER_OF_IO_RANGES) {
            break;
         }
         ranges--;
      }
      ConfigEntry->NumberOfIoPortRanges = (USHORT) index;
   }

   //
   // Handle all combinations as specified in table on p. 80
   // (Basic compatibility Layer 1, i/o space encoding guidelines) of
   // PC Card standard Metaformat Specification, March 1997 (PCMCIA/JEIDA)
   //

   if (ioAddrLines) {
      //
      // A modulo base specified
      //
      if (addressSize == 0) {

         //
         // No I/O Base address specified
         //
         if (lengthSize == 0) {
            //
            // No ranges specified. This is a pure modulo base case
            //
            ConfigEntry->NumberOfIoPortRanges = 1;
            ConfigEntry->IoPortBase[0] = 0;
            ConfigEntry->IoPortLength[0] = (1 << ioAddrLines)-1;
            ConfigEntry->IoPortAlignment[0] = (1 << ioAddrLines);
         } else {
            //
            // Length specified. Modulo base is used only to specify alignment.
            //
            for (i=0; i < ConfigEntry->NumberOfIoPortRanges; i++) {
               ConfigEntry->IoPortBase[i] = 0;
               ConfigEntry->IoPortAlignment[i] = (1 << ioAddrLines);
            }
         }
      } else {
         //
         // Alignment specified..
         // This fix is for Xircom CE3 card
         //
         for (i=0; i < ConfigEntry->NumberOfIoPortRanges; i++) {
            if (ConfigEntry->IoPortBase[i] != 0) {
               //
               // Fixed base address supplied....
               // Don't specify alignment!
               //
               continue;
            }
            ConfigEntry->IoPortAlignment[i] = (1 << ioAddrLines);
         }
      }
   } else {
      //
      // No Modulo Base. So specific ranges should've been specified
      //
      if (lengthSize == 0) {
         //
         //   Error! Length HAS to be specified
         //
         DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaProcessIoSpace: Length not specified in TPCE_IO descriptor for PC Card\n"));
      } else if (addressSize == 0) {
         for (i = 0; i < ConfigEntry->NumberOfIoPortRanges; i++) {
            ConfigEntry->IoPortBase[i]  = 0x0;
            ConfigEntry->IoPortAlignment[i] = 2;
         }
      } else {
         //
         // Proper ranges specified
         // Don't change anything
      }
   }
}


VOID
PcmciaProcessIrq(
   IN PTUPLE_PACKET TuplePacket,
   PCONFIG_ENTRY ConfigEntry
   )

/*++

Routine Description:

    Process IRQ from CIS.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet
    ConfigEntry - a place to store the IRQ.

Return Value:

    none

--*/

{
   USHORT mask;
   UCHAR  level = GetTupleChar(TuplePacket);

   if (!level) {

      //
      // NOTE: It looks like Future Domain messed up on this
      // and puts an extra zero byte into the structure.
      // skip it for now.
      //

      level = GetTupleChar(TuplePacket);
   }

   if (level & 0x20) {
      ConfigEntry->LevelIrq = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
   } else {
      ConfigEntry->LevelIrq = CM_RESOURCE_INTERRUPT_LATCHED;
   }

   if (level & 0x80) {
      ConfigEntry->ShareDisposition = CmResourceShareShared;
   } else {
      ConfigEntry->ShareDisposition = CmResourceShareDeviceExclusive;
   }

   mask = level & 0x10;

   //
   // 3COM 3C589-75D5 has a peculiar problem
   // where mask bit is 0, but should have been 1.
   // Handle this case here
   //

   if ((mask==0) && ((level & 0xf) == 0)) {
      mask = 1;
   }

   if (mask) {
      //
      // Each bit set in the mask indicates the corresponding IRQ
      // (from 0-15) may be assigned to this card's interrupt req. pin
      //
      mask = (USHORT) GetTupleChar(TuplePacket);
      mask |= ((USHORT) GetTupleChar(TuplePacket)) << 8;
      ConfigEntry->IrqMask = mask;
   } else {
      ConfigEntry->IrqMask = 1 << (level & 0x0f);
   }
}


VOID
PcmciaProcessTiming(
   IN PTUPLE_PACKET TuplePacket,
   IN PCONFIG_ENTRY ConfigEntry
   )

/*++

Routine Description:

    Move the data pointer around the timing information structure.
    No processing of this data occurs at this time.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet
    ConfigEntry - currently unused.

Return Value:

    none

--*/

{
   UCHAR  item = GetTupleChar(TuplePacket);
   UCHAR  reservedScale = (item & 0xe0) >> 5;
   UCHAR  readyBusyScale = (item & 0x1c) >> 2;
   UCHAR  waitScale = (item & 0x03);

   //
   // NOTE: It looks like the processing of extension bytes is not
   // coded correctly in this routine.
   //

   if (waitScale != 3) {
      item = GetTupleChar(TuplePacket);
      while (item & EXTENSION_BYTE_FOLLOWS) {
         item = GetTupleChar(TuplePacket);
      }
   }

   if (readyBusyScale != 7) {
      item = GetTupleChar(TuplePacket);
      while (item & EXTENSION_BYTE_FOLLOWS) {
         item = GetTupleChar(TuplePacket);
      }
   }

   if (reservedScale != 7) {
      item = GetTupleChar(TuplePacket);
      while (item & EXTENSION_BYTE_FOLLOWS) {
         item = GetTupleChar(TuplePacket);
      }
   }
}


VOID
PcmciaProcessMemSpace(
   IN PTUPLE_PACKET TuplePacket,
   IN PCONFIG_ENTRY ConfigEntry,
   IN UCHAR         MemSpace
   )

/*++

Routine Description:

    Process memory space requirements from CIS.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet
    ConfigEntry - the socket configuration structure.
    MemSpace    - the memory space enumerator from the config table entry
                  structure.

Return Value:

    none

--*/

{
   ULONG  longValue;
   ULONG  index;
   UCHAR  lengthSize;
   UCHAR  addrSize;
   UCHAR  number;
   UCHAR  hasHostAddress;

   switch (MemSpace) {

   case 1: {
         //
         // Only length is specified
         //
         longValue = (ULONG) GetTupleChar(TuplePacket);
         longValue |= ((ULONG) GetTupleChar(TuplePacket)) << 8;
         ConfigEntry->MemoryLength[0] = longValue * 256;

         ConfigEntry->NumberOfMemoryRanges++;
         break;
      }

   case 2: {

         longValue = (ULONG) GetTupleChar(TuplePacket);
         longValue |= ((ULONG) GetTupleChar(TuplePacket)) << 8;
         ConfigEntry->MemoryLength[0] = longValue * 256;

         longValue = (ULONG) GetTupleChar(TuplePacket);
         longValue |= ((ULONG) GetTupleChar(TuplePacket)) << 8;
         ConfigEntry->MemoryCardBase[0] =
         ConfigEntry->MemoryHostBase[0] = longValue * 256;

         ConfigEntry->NumberOfMemoryRanges++;
         break;
      }

   case 3: {
         UCHAR  item  = GetTupleChar(TuplePacket);
         lengthSize = (item & 0x18) >> 3;
         addrSize   = (item & 0x60) >> 5;
         number     = (item & 0x07) + 1;
         hasHostAddress = item & 0x80;

         if (number > MAX_NUMBER_OF_MEMORY_RANGES) {
            number = MAX_NUMBER_OF_MEMORY_RANGES;
         }

         for (index = 0; index < (ULONG) number; index++) {
            longValue = 0;
            if (lengthSize >= 1) {
               longValue = (ULONG) GetTupleChar(TuplePacket);
            }
            if (lengthSize >= 2) {
               longValue |= (GetTupleChar(TuplePacket)) << 8;
            }
            if (lengthSize == 3) {
               longValue |= (GetTupleChar(TuplePacket)) << 16;
            }
            ConfigEntry->MemoryLength[index] = longValue * 256;

            longValue = 0;
            if (addrSize >= 1) {
               longValue = (ULONG) GetTupleChar(TuplePacket);
            }
            if (addrSize >= 2) {
               longValue |= (GetTupleChar(TuplePacket)) << 8;
            }
            if (addrSize == 3) {
               longValue |= (GetTupleChar(TuplePacket)) << 16;
            }
            ConfigEntry->MemoryCardBase[index] = longValue * 256;

            if (hasHostAddress) {
               longValue = 0;
               if (addrSize >= 1) {
                  longValue = (ULONG) GetTupleChar(TuplePacket);
               }
               if (addrSize >= 2) {
                  longValue |= (GetTupleChar(TuplePacket)) << 8;
               }
               if (addrSize == 3) {
                  longValue |= (GetTupleChar(TuplePacket)) << 16;
               }
               ConfigEntry->MemoryHostBase[index] = longValue * 256;
            }
         }
         ConfigEntry->NumberOfMemoryRanges = (USHORT) number;
         break;
      }
   }
}


PCONFIG_ENTRY
PcmciaProcessConfigTable(
   IN PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

    A pointer to a config entry structure if one is created.

--*/

{
   PSOCKET_DATA SocketData = TuplePacket->SocketData;
   PCONFIG_ENTRY configEntry;
   UCHAR         item;
   UCHAR         defaultBit;
   UCHAR         memSpace;
   UCHAR         power;
   UCHAR         misc;

   configEntry = ExAllocatePool(NonPagedPool, sizeof(CONFIG_ENTRY));
   if (!configEntry) {
      return NULL;
   }
   RtlZeroMemory(configEntry, sizeof(CONFIG_ENTRY));

   item = GetTupleChar(TuplePacket);
   defaultBit = Default(item);
   configEntry->IndexForThisConfiguration = ConfigEntryNumber(item);

   if (IntFace(item)) {

      //
      // This byte indicates type of interface in tuple (i.e. io or memory)
      // This could be processed, but for now is just skipped.
      //

      item = GetTupleChar(TuplePacket);
   }

   item = GetTupleChar(TuplePacket);
   memSpace = MemSpaceInformation(item);
   power    = PowerInformation(item);
   misc     = MiscInformation(item);

   if (power) {
      PcmciaProcessPower(TuplePacket, power);
   }

   if (TimingInformation(item)) {
      PcmciaProcessTiming(TuplePacket, configEntry);
   }

   if (IoSpaceInformation(item)) {
      PcmciaProcessIoSpace(TuplePacket, configEntry);
   } else if (!defaultBit && (SocketData->DefaultConfiguration != NULL)) {
      PcmciaCopyIoConfig(configEntry, SocketData->DefaultConfiguration);
   }

   if (IRQInformation(item)) {
      PcmciaProcessIrq(TuplePacket, configEntry);
   } else if (!defaultBit && (SocketData->DefaultConfiguration != NULL)) {
      PcmciaCopyIrqConfig(configEntry,SocketData->DefaultConfiguration);
   }

   if (memSpace) {
      PcmciaProcessMemSpace(TuplePacket, configEntry, memSpace);
   } else if (!defaultBit && (SocketData->DefaultConfiguration != NULL)) {
      PcmciaCopyMemConfig(configEntry,SocketData->DefaultConfiguration);
   }

   if (misc) {
      PcmciaMiscFeatures(TuplePacket);
   } // need default bit processing here too

   if (defaultBit) {
      //
      // Save this config as the default config for this pc-card (which
      // may be accessed by subsequent tuples)
      //
      SocketData->DefaultConfiguration = configEntry;
   }
   //
   // One more configuration
   //
   SocketData->NumberOfConfigEntries++;

   DebugPrint((PCMCIA_DEBUG_TUPLES,
                           "config entry %08x idx %x ccr %x\n",
                           configEntry,
                           configEntry->IndexForThisConfiguration,
                           SocketData->ConfigRegisterBase
                           ));
   return configEntry;
}

VOID
PcmciaMiscFeatures(
   IN PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

    Parse the miscellaneous features field and look for audio supported
    bit.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

    none

--*/

{
   PSOCKET_DATA SocketData = TuplePacket->SocketData;
   UCHAR item = GetTupleChar(TuplePacket);

   DebugPrint((PCMCIA_DEBUG_TUPLES,
               "TPCE_MS (%lx) is present in  CISTPL_CFTABLE_ENTRY \n",
               item));

   //
   // If the audio bit is set, remember this in the socket information
   // structure.
   //

   if (item & 0x8) {

      DebugPrint((PCMCIA_DEBUG_TUPLES,
                  "Audio bit set in TPCE_MS \n"));
      SocketData->Audio = TRUE;
   }

   //
   //  Step around the miscellaneous features and its extension bytes.
   //

   while (item & EXTENSION_BYTE_FOLLOWS) {
      item = GetTupleChar(TuplePacket);
   }
}



VOID
ProcessConfig(
   IN PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

    Parse the CISTPL_CONFIG to extract the last index value and the
    configuration register base for the PCCARD.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

    None

--*/

{
   PSOCKET_DATA SocketData = TuplePacket->SocketData;
   PUCHAR TupleData = TuplePacket->TupleData;
   ULONG  base = 0;
   UCHAR  widthOfBaseAddress;
   UCHAR  widthOfRegPresentMask;
   UCHAR  widthOfReservedArea;
   UCHAR  widthOfInterfaceId;
   UCHAR  index;
   UCHAR  subtupleCount = 0;
   ULONG  InterfaceId;

   widthOfBaseAddress = TpccRasz(TupleData[0]) + 1;
   widthOfRegPresentMask = TpccRmsz(TupleData[0]) + 1;
   widthOfReservedArea = TpccRfsz(TupleData[0]);

   ASSERT (widthOfReservedArea == 0);
   ASSERT (widthOfRegPresentMask <= 16);

   SocketData->LastEntryInCardConfig = TupleData[1];

   switch (widthOfBaseAddress) {
   case 4:
      base  = ((ULONG)TupleData[5] << 24);
   case 3:
      base |= ((ULONG)TupleData[4] << 16);
   case 2:
      base |= ((ULONG)TupleData[3] << 8);
   case 1:
      base |= TupleData[2];
      break;
   default:
      DebugPrint((PCMCIA_DEBUG_FAIL,
                  "ProcessConfig - bad number of bytes %d\n",
                  widthOfBaseAddress));
      break;
   }
   SocketData->ConfigRegisterBase = base;
   DebugPrint((PCMCIA_DEBUG_TUPLES,
               "ConfigRegisterBase in attribute memory is 0x%x\n",
               SocketData->ConfigRegisterBase));

   //
   // Copy the register presence mask
   //

   for (index = 0; index < widthOfRegPresentMask; index++) {
      SocketData->RegistersPresentMask[index] = TupleData[2 + widthOfBaseAddress + index];
   }   

   DebugPrint((PCMCIA_DEBUG_TUPLES,
               "First Byte in RegPresentMask=%x, width is %d\n",
               SocketData->RegistersPresentMask[0], widthOfRegPresentMask));

   //
   // Look for subtuples
   //
   index = 2 + widthOfBaseAddress + widthOfRegPresentMask + widthOfReservedArea;

   while (((index+5) < TuplePacket->TupleDataMaxLength) &&
          (++subtupleCount <= 4) &&
          (TupleData[index] == CCST_CIF)) {

      widthOfInterfaceId = ((TupleData[index+2] & 0xC0) >> 6) + 1 ;

      InterfaceId = 0;

      switch (widthOfInterfaceId) {
      case 4:
         InterfaceId  = ((ULONG)TupleData[index+5] << 24);
      case 3:
         InterfaceId |= ((ULONG)TupleData[index+4] << 16);
      case 2:
         InterfaceId |= ((ULONG)TupleData[index+3] << 8);
      case 1:
         InterfaceId |= TupleData[index+2];
         break;
      default:
         DebugPrint((PCMCIA_DEBUG_FAIL,
                     "ProcessConfig - bad number of bytes %d in subtuple\n",
                     widthOfInterfaceId));
         break;
      }

      DebugPrint((PCMCIA_DEBUG_TUPLES, "Custom Interface ID %8x\n", InterfaceId));
      //
      // Currently don't have generic code for recording sub-tuple information,
      // all we look for is Zoom Video.
      //
      if (InterfaceId == 0x141) {
         SocketData->Flags |= SDF_ZV;
      }

      index += (TupleData[index+1] + 2);
   }
}


VOID
ProcessConfigCB(
   IN PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

    Parse the CISTPL_CONFIG_CB to extract the last index value and the
    configuration register base for the PCCARD.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

    None

--*/

{
   PSOCKET_DATA SocketData = TuplePacket->SocketData;
   PUCHAR TupleData = TuplePacket->TupleData;
   ULONG base = 0;
   UCHAR widthOfFields;

   widthOfFields = TupleData[0];

   if (widthOfFields != 3) {
      DebugPrint((PCMCIA_DEBUG_FAIL, "ProcessConfigCB - bad width of fields %d\n", widthOfFields));
      return;
   }

   SocketData->LastEntryInCardConfig = TupleData[1];

   base  = ((ULONG)TupleData[5] << 24);
   base |= ((ULONG)TupleData[4] << 16);
   base |= ((ULONG)TupleData[3] << 8);
   base |= TupleData[2];

   SocketData->ConfigRegisterBase = base;
   DebugPrint((PCMCIA_DEBUG_TUPLES, "ConfigRegisterBase = %08x\n", SocketData->ConfigRegisterBase));

}



VOID
PcmciaSubstituteUnderscore(
   IN OUT PUCHAR Str
   )
/*++
Routine description

    Substitutes underscores ('_' character) for invalid device id
    characters such as spaces & commas in the supplied string

Parameters

    Str - The string for which the substitution is to take place in situ

Return Value

    None

--*/

{
   if (Str == NULL) {
      return;
   }
   while (*Str) {
      if (*Str == ' ' ||
          *Str == ',' ) {
         *Str = '_';
      }
      Str++;
   }
}



/*-------------- Tuple API starts here ----------------------------------------*/

NTSTATUS
InitializeTuplePacket(
   IN PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

      Initializes the supplied tuple packet

Arguments:

   TuplePacket - Pointer the caller supplied tuple packet

Return Value:

   Status

--*/
{
   TuplePacket->Flags = TPLF_IMPLIED_LINK;
   TuplePacket->LinkOffset = 0;
   TuplePacket->CISOffset   = 0;
   if (IsCardBusCardInSocket(TuplePacket->Socket)) {
      PPDO_EXTENSION pdoExtension = TuplePacket->SocketData->PdoExtension;

      GetPciConfigSpace(pdoExtension, CBCFG_CISPTR, &TuplePacket->CISOffset, sizeof(TuplePacket->CISOffset));
      DebugPrint((PCMCIA_DEBUG_TUPLES, "CardBus CISPTR = %08x\n", TuplePacket->CISOffset));

      TuplePacket->Flags = TPLF_COMMON | TPLF_IMPLIED_LINK;
      TuplePacket->Flags |= (TuplePacket->CISOffset & 7) << TPLF_ASI_SHIFT;
      TuplePacket->CISOffset &= 0x0ffffff8;
      TuplePacket->LinkOffset = TuplePacket->CISOffset;
   }
   return STATUS_SUCCESS;
}


NTSTATUS
GetFirstTuple(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

      Retrieves the very first tuple off the pc-card

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS if tuple was retrieved
   STATUS_NO_MORE_ENTRIES - if no tuples were found
                            this is possible if this is a flash memory card

--*/
{

   NTSTATUS status;

   status=InitializeTuplePacket(TuplePacket);
   if (!NT_SUCCESS(status)) {
      return status;
   }

   TuplePacket->TupleCode = GetCISChar(TuplePacket, 0);
   TuplePacket->TupleLink = GetCISChar(TuplePacket, 1);

   if (TuplePacket->TupleCode == CISTPL_LINKTARGET) {
      if ((status=FollowLink(TuplePacket)) == STATUS_NO_MORE_ENTRIES) {
         return status;
      }
   } else if (IsCardBusCardInSocket(TuplePacket->Socket)) {
      //
      // First tuple on Cardbus cards must be link target
      //
      return STATUS_NO_MORE_ENTRIES;
   }
   if (!NT_SUCCESS(status) || TupleMatches(TuplePacket)) {
      return status;
   }
   return GetNextTuple(TuplePacket);
}

BOOLEAN
TupleMatches(
   PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

      Checks if the retrieved tuple matches  what
      the caller requested

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   TRUE  - if the tuple matches
   FALSE - if not

--*/

{
   if (TuplePacket->TupleCode == TuplePacket->DesiredTuple) {
      return TRUE;
   }

   if (TuplePacket->DesiredTuple != 0xFF) {
      return FALSE;
   }

   //
   // Requested any tuple , but might not want link tuples
   //
   if (TuplePacket->Attributes & TPLA_RET_LINKS) {
      return TRUE;
   }
   return ((TuplePacket->TupleCode != CISTPL_LONGLINK_CB)       &&
           (TuplePacket->TupleCode != CISTPL_INDIRECT)          &&
           (TuplePacket->TupleCode != CISTPL_LONGLINK_MFC)      &&
           (TuplePacket->TupleCode != CISTPL_LONGLINK_A)        &&
           (TuplePacket->TupleCode != CISTPL_LONGLINK_C)        &&
           (TuplePacket->TupleCode != CISTPL_NO_LINK)  &&
           (TuplePacket->TupleCode != CISTPL_LINKTARGET));
}

NTSTATUS
GetNextTuple(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

      Retrieves the next unprocessed tuple that matches
      the caller requested tuple code off the pc-card

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS if tuple was retrieved
   STATUS_NO_MORE_ENTRIES - if no more tuples were found

--*/
{

   ULONG missCount;
   NTSTATUS status;

   for (missCount = 0; missCount < MAX_MISSED_TUPLES; missCount++) {
      if (((status = GetAnyTuple(TuplePacket)) != STATUS_SUCCESS) ||
          TupleMatches(TuplePacket)) {
         break;
      }
      status = STATUS_NO_MORE_ENTRIES;
   }
   return status;
}


NTSTATUS
NextTupleInChain(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

   Retrieves the immediately next unprocessed tuple on the pc-card

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   status

--*/
{
   NTSTATUS status;
   ULONG    i;
   UCHAR link;

   status = STATUS_SUCCESS;
   switch (GetCISChar(TuplePacket, 0)) {
   case CISTPL_END:{
         status = STATUS_NO_MORE_ENTRIES;
         break;
      }
   case CISTPL_NULL: {
         for (i = 0; i < MAX_MISSED_TUPLES; i++) {
            TuplePacket->CISOffset++;
            if (GetCISChar(TuplePacket, 0) != CISTPL_NULL) {
               break;
            }
         }
         if (i >= MAX_MISSED_TUPLES) {
            status = STATUS_DEVICE_NOT_READY;
         }
         break;
      }
   default: {
         link = GetCISChar(TuplePacket, 1);
         if (link == 0xFF) {
            status = STATUS_NO_MORE_ENTRIES;
         } else {
            TuplePacket->CISOffset += link+2;
         }
         break;
      }
   }
   return (status);
}


NTSTATUS
GetAnyTuple(
   IN PTUPLE_PACKET TuplePacket
   )

/*++

Routine Description:

      Retrieves the next tuple - regardless of tuple code-
      off the pc-card. If the end of chain is reached on the
      current tuple chain, any links are followed to obtain
      the next tuple.

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS if tuple was retrieved
   STATUS_NO_MORE_ENTRIES - if no tuples were found

--*/
{

   NTSTATUS status;

   if (!NT_SUCCESS((status = NextTupleInChain(TuplePacket)))) {
      /* End of this CIS. Follow a link if it exists */
      if (status == STATUS_DEVICE_NOT_READY) {
         return status;
      }
      if ((status = FollowLink(TuplePacket)) != STATUS_SUCCESS) {
         return status;
      }
   }
   TuplePacket->TupleCode = GetCISChar(TuplePacket, 0);
   TuplePacket->TupleLink = GetCISChar(TuplePacket, 1);
   return (ProcessLinkTuple(TuplePacket));
}



NTSTATUS
FollowLink(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

   Called when the end of tuple chain is encountered:
   this follows links, if any are present

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS if a link is present
   STATUS_NO_MORE_ENTRIES - if not

--*/
{
   if (NextLink(TuplePacket) == STATUS_SUCCESS) {
      return STATUS_SUCCESS;
   }

   // There is no implied or explicit link to follow.  If an indirect link
   // has been specified, indirect attribute memory is processed with an
   // implied link to common memory.

   if ((TuplePacket->Flags & TPLF_IND_LINK) && !(TuplePacket->Flags & TPLF_INDIRECT)) {

       // Link to indirect attribute memory at offset 0.

       TuplePacket->Flags &= ~(TPLF_COMMON | TPLF_IND_LINK | TPLF_LINK_MASK);
       TuplePacket->Flags |= TPLF_INDIRECT;
       TuplePacket->CISOffset = 0;

       if (CheckLinkTarget(TuplePacket)) {
           return STATUS_SUCCESS;
       }
       return(NextLink(TuplePacket));
   }
   return STATUS_NO_MORE_ENTRIES;
}


BOOLEAN
CheckLinkTarget(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

   Ensures that the target of a link has the signature
   'CIS' which indicates it is a valid target,
   as documented in the PC-Card standard

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS           if valid target
   STATUS_NO_MORE_ENTRIES - if not

--*/
{
   return (GetCISChar(TuplePacket, 0) == CISTPL_LINKTARGET &&
           GetCISChar(TuplePacket, 1) >= 3 &&
           GetCISChar(TuplePacket, 2) == 'C' &&
           GetCISChar(TuplePacket, 3) == 'I' &&
           GetCISChar(TuplePacket, 4) == 'S');

}


NTSTATUS
NextLink(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

      Fetches the next link off the pc-card tuple chain
      if any are present

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS if a link was present
   STATUS_NO_MORE_ENTRIES - if no links

--*/
{
   switch (TuplePacket->Flags & TPLF_LINK_MASK) {
   case TPLF_IMPLIED_LINK:
   case TPLF_LINK_TO_C:  {
         TuplePacket->Flags |= TPLF_COMMON;
         TuplePacket->CISOffset = TuplePacket->LinkOffset;
         break;
      }
   case TPLF_LINK_TO_A:{
         TuplePacket->Flags &= ~TPLF_COMMON;
         TuplePacket->CISOffset = TuplePacket->LinkOffset;
         break;
      }
   case TPLF_LINK_TO_CB: {
         //
         // Needs work! We have to switch to the appropriate
         // address space (BARs/Expansion Rom/Config space)
         // depending on the link offset
         //
         TuplePacket->Flags &= ~TPLF_ASI;
         TuplePacket->Flags |= (TuplePacket->LinkOffset & 7) << TPLF_ASI_SHIFT;
         TuplePacket->CISOffset = TuplePacket->LinkOffset & ~7 ;
         break;
      }
   case TPLF_NO_LINK:
      default: {
         return STATUS_NO_MORE_ENTRIES;
      }

   }
   // Validate the link target
   if (!CheckLinkTarget (TuplePacket)) {
      if (TuplePacket->Flags & (TPLF_COMMON | TPLF_INDIRECT)) {
          return(STATUS_NO_MORE_ENTRIES);
      }

      // The R2 PCMCIA spec was not clear on how the link off
      // memory was defined.  As a result the offset is often
      // by 2 as defined in the later specs.  Therefore if th
      // not found at the proper offset, the offset is divide
      // proper link target is checked for at that offset.

      TuplePacket->CISOffset >>= 1;       // Divide by 2
      if (!CheckLinkTarget(TuplePacket)) {
          return(STATUS_NO_MORE_ENTRIES);
      }
      return STATUS_NO_MORE_ENTRIES;
   }

   TuplePacket->Flags &= ~TPLF_LINK_MASK;
   return STATUS_SUCCESS;
}


NTSTATUS
ProcessLinkTuple(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

  Processes an encountered link while traversing the tuple chain
  by storing it for future use - when the link has to be followed
  after end of chain is encountered

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS

--*/
{
   ULONG k;

   switch (TuplePacket->TupleCode) {
   case CISTPL_LONGLINK_CB: {
         // needs to be filled in
         if (TuplePacket->TupleLink < 4) {
            return (STATUS_NO_MORE_ENTRIES);
         }
         TuplePacket->Flags = (TuplePacket->Flags & ~TPLF_LINK_MASK) | TPLF_LINK_TO_CB;
         TuplePacket->LinkOffset =  GetCISChar(TuplePacket, TPLL_ADDR) +
                                    (GetCISChar(TuplePacket, TPLL_ADDR + 1)<<8) +
                                    (GetCISChar(TuplePacket, TPLL_ADDR + 2)<<16) +
                                    (GetCISChar(TuplePacket, TPLL_ADDR + 3)<<24);

         break;
      }

   case CISTPL_INDIRECT: {
         TuplePacket->Flags |= TPLF_IND_LINK;
         TuplePacket->LinkOffset = 0;     // Don't set link offset for indirect
         SetPdoFlag(TuplePacket->SocketData->PdoExtension, PCMCIA_PDO_INDIRECT_CIS);
        break;
      }

   case CISTPL_LONGLINK_A:
   case CISTPL_LONGLINK_C: {
         if (TuplePacket->TupleLink < 4) {
            return STATUS_NO_MORE_ENTRIES;
         }
         TuplePacket->Flags = ((TuplePacket->Flags & ~TPLF_LINK_MASK) |
                               (TuplePacket->TupleCode == CISTPL_LONGLINK_A ?
                                TPLF_LINK_TO_A: TPLF_LINK_TO_C));
         TuplePacket->LinkOffset =  GetCISChar(TuplePacket, TPLL_ADDR) +
                                    (GetCISChar(TuplePacket, TPLL_ADDR+1) << 8)  +
                                    (GetCISChar(TuplePacket, TPLL_ADDR+2) << 16) +
                                    (GetCISChar(TuplePacket, TPLL_ADDR+3) << 24) ;

         break;
      }
   case CISTPL_LONGLINK_MFC:{
         k = TPLMFC_NUM;
         TuplePacket->Socket->NumberOfFunctions = GetCISChar(TuplePacket, TPLMFC_NUM);

         if ((TuplePacket->TupleLink < (TuplePacket->Function*5 + 6)) ||
             (GetCISChar(TuplePacket, k) <= TuplePacket->Function)) {
            return STATUS_NO_MORE_ENTRIES;
         }
         k += TuplePacket->Function*5 + 1;
         TuplePacket->Flags = (TuplePacket->Flags & ~TPLF_LINK_MASK) |
                              (GetCISChar(TuplePacket, k) == 0?TPLF_LINK_TO_A:
                               TPLF_LINK_TO_C);
         k++;
         TuplePacket->LinkOffset =  GetCISChar(TuplePacket, k) +
                                    (GetCISChar(TuplePacket, k+1) << 8) +
                                    (GetCISChar(TuplePacket, k+2) << 16) +
                                    (GetCISChar(TuplePacket, k+3) << 24);
         break;
      }
   case CISTPL_NO_LINK:{
         TuplePacket->Flags = (TuplePacket->Flags & ~TPLF_LINK_MASK) | TPLF_NO_LINK;
         break;
      }
   }
   return STATUS_SUCCESS;
}



NTSTATUS
GetTupleData(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

   Retrieves the tuple body for the currently requested
   tuple.
   NOTE: This function assumes that the caller provided
   a big enough buffer in the TuplePacket to hold the tuple
   data. No attempt is made to trap exceptions etc.

Arguments:

   TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

   STATUS_SUCCESS if tuple data was retrieved
   STATUS_NO_MORE_ENTRIES - otherwise

--*/
{
   PUCHAR bufferPointer;
   USHORT xferLength;
   USHORT tupleOffset;

   TuplePacket->TupleDataIndex = 0;
   xferLength = TuplePacket->TupleDataLength = GetCISChar(TuplePacket, 1);
   if ((tupleOffset = TuplePacket->TupleOffset) > xferLength) {
      return STATUS_NO_MORE_ENTRIES;
   }
   xferLength = MIN((xferLength - tupleOffset), TuplePacket->TupleDataMaxLength);
   for (bufferPointer = TuplePacket->TupleData; xferLength;
       tupleOffset++, bufferPointer++, xferLength--) {
      *bufferPointer = GetCISChar(TuplePacket, tupleOffset + 2);
   }
   return STATUS_SUCCESS;
}


UCHAR
GetTupleChar(
   IN PTUPLE_PACKET TuplePacket
   )
/*++

Routine Description:

    Returns the next byte in the current set of tuple data.

Arguments:

    TuplePacket - Pointer the caller supplied, initialized tuple packet

Return Value:

    tuple data byte

--*/
{
   UCHAR tupleChar = 0;

   if (TuplePacket->TupleDataIndex < TuplePacket->TupleDataMaxLength) {
      tupleChar = TuplePacket->TupleData[TuplePacket->TupleDataIndex++];
   }
   return tupleChar;
}



/*------------- End of Tuple API -----------------------*/


USHORT
GetCRC(
   IN PSOCKET_DATA SocketData
   )

/*++

Routine Description:

    Using the same algorithm as Windows 95, calculate the CRC value
    to be appended with the manufacturer name and device name to
    obtain the unique identifier for the PCCARD.

Arguments:

    Socket         - Pointer to the socket which contains the device
    Function       - function number of device

Return Value:

    A USHORT CRC value.

--*/

{
   PSOCKET Socket = SocketData->Socket;
   TUPLE_PACKET tuplePacket;
   PUCHAR  tupleData;
   PUCHAR  cp;
   PUCHAR  cpEnd;
   PUCHAR  tplBuffer;
   NTSTATUS     status;
   USHORT  crc = 0;
   USHORT  index;
   USHORT  length;
   UCHAR   tupleCode;
   UCHAR   tmp;

   RtlZeroMemory(&tuplePacket, sizeof(TUPLE_PACKET));

   tuplePacket.DesiredTuple = 0xFF;
   tuplePacket.TupleData = ExAllocatePool(NonPagedPool, MAX_TUPLE_DATA_LENGTH);
   if (tuplePacket.TupleData == NULL) {
      return 0;
   }

   tuplePacket.Socket             = Socket;
   tuplePacket.SocketData         = SocketData;
   tuplePacket.TupleDataMaxLength = MAX_TUPLE_DATA_LENGTH;
   tuplePacket.TupleOffset        = 0;
   tuplePacket.Function           = SocketData->Function;

   try{

      status = GetFirstTuple(&tuplePacket);

      //
      // Calculate CRC
      //
      while (NT_SUCCESS(status)) {

         tupleCode = tuplePacket.TupleCode;

         for (index = 0; TplList[index] != CISTPL_END; index++) {

            if (tupleCode == TplList[index]) {

               status = GetTupleData(&tuplePacket);
               if (!NT_SUCCESS(status)) {
                  //
                  // Bail...
                  //
                  crc = 0;
                  leave;
               };
               tupleData = tuplePacket.TupleData;
               length = tuplePacket.TupleDataLength;

               //
               // This one is included in the CRC calculation
               //

               if (tupleCode == CISTPL_VERS_1) {
                  cp = tupleData + 2;
                  cpEnd = tupleData + MAX_TUPLE_DATA_LENGTH;

                  //
                  // Include all of the manufacturer name.
                  //

                  while ((cp < cpEnd) && *cp) {
                     cp++;
                  }

                  //
                  // Include the product string
                  //

                  cp++;
                  while ((cp < cpEnd) && *cp) {
                     cp++;
                  }
                  cp++;

                  length = (USHORT)(cp - tupleData);
               }

               if (length >= MAX_TUPLE_DATA_LENGTH) {
                  crc = 0;
                  leave;
               }

               for (cp = tupleData; length; length--, cp++) {

                  tmp = *cp ^ (UCHAR)crc;
                  crc = (crc >> 8) ^ crc16a[tmp & 0x0f] ^ crc16b[tmp >> 4];
               }
               break;
            }
         }
         status = GetNextTuple(&tuplePacket);
      }

   } finally {

      if (tuplePacket.TupleData) {
         ExFreePool(tuplePacket.TupleData);
      }
   }

   DebugPrint((PCMCIA_DEBUG_TUPLES, "Checksum=%x\n", crc));
   return crc;
}



NTSTATUS
PcmciaParseFunctionData(
   IN PSOCKET Socket,
   IN PSOCKET_DATA SocketData
   )
/*++

Routine Description

   Parses the tuple data for the supplied function
   (SocketPtr->Function)

Arguments:

   Socket         - Pointer to the socket which contains the device
   SocketData - Pointer to the socket data structure for the function
                which will be filled with the parsed information

Return Value:

   Status
--*/

{
   PCONFIG_ENTRY configEntry, prevEntry = NULL;
   TUPLE_PACKET  tuplePacket;
   NTSTATUS      status;

   if (SocketData->Function >= Socket->NumberOfFunctions) {
      return STATUS_NO_MORE_ENTRIES;
   }

   if (Is16BitCardInSocket(Socket)) {
      //
      // Get the CIS checksum
      //
      SocketData->CisCrc = GetCRC(SocketData);
   }

   RtlZeroMemory(&tuplePacket, sizeof(TUPLE_PACKET));

   tuplePacket.DesiredTuple = 0xFF;
   tuplePacket.TupleData = ExAllocatePool(PagedPool, MAX_TUPLE_DATA_LENGTH);
   if (tuplePacket.TupleData == NULL) {
      return STATUS_INSUFFICIENT_RESOURCES;
   }
   tuplePacket.Socket             = Socket;
   tuplePacket.SocketData         = SocketData;
   tuplePacket.TupleDataMaxLength = MAX_TUPLE_DATA_LENGTH;
   tuplePacket.TupleOffset        = 0;
   tuplePacket.Function           = SocketData->Function;

   status = GetFirstTuple(&tuplePacket);

   if (!NT_SUCCESS(status) || (tuplePacket.TupleCode == CISTPL_END)) {

      if (IsCardBusCardInSocket(Socket)) {
         //
         // Couldn't get CIS of cardbus card, no big deal
         //
         status = STATUS_SUCCESS;

      } else if (status != STATUS_DEVICE_NOT_READY) {
         //
         // No CIS, munge it to look like a memory card
         //
         status = PcmciaMemoryCardHack(Socket, SocketData);
      }

     if (tuplePacket.TupleData) {
        ExFreePool(tuplePacket.TupleData);
     }
     return status;
   }

   while (NT_SUCCESS(status)) {

      status = GetTupleData(&tuplePacket);
      ASSERT (NT_SUCCESS(status));

      DebugPrint((PCMCIA_DEBUG_TUPLES, "%04x TUPLE %02x %s\n", tuplePacket.CISOffset,
                       tuplePacket.TupleCode, TUPLE_STRING(tuplePacket.TupleCode)));

      switch (tuplePacket.TupleCode) {

      case CISTPL_VERS_1: {
            ULONG         byteCount;
            PUCHAR        pStart, pCurrent;

            //
            // Extract manufacturer name and card name.
            //

            pStart = pCurrent = tuplePacket.TupleData+2;   // To string fields
            byteCount = 0;

            while ((*pCurrent != '\0') && (*pCurrent != (UCHAR)0xff)) {

               if ((byteCount >= MAX_MANFID_LENGTH-1) || (byteCount >= MAX_TUPLE_DATA_LENGTH)) {
                  status = STATUS_DEVICE_NOT_READY;
                  break;
               }

               byteCount++;
               pCurrent++;
            }

            if (!NT_SUCCESS(status)) {
               break;
            }

            RtlCopyMemory((PUCHAR)SocketData->Mfg, pStart, byteCount);
            //
            // Null terminate
            SocketData->Mfg[byteCount] = '\0';
            DebugPrint((PCMCIA_DEBUG_TUPLES, "Manufacturer: %s\n", SocketData->Mfg));

            PcmciaSubstituteUnderscore(SocketData->Mfg);

            pCurrent++;
            pStart = pCurrent;

            byteCount = 0;
            while ((*pCurrent != '\0') && (*pCurrent != (UCHAR)0xff)) {

               if ((byteCount >= MAX_IDENT_LENGTH-1) || (byteCount >= MAX_TUPLE_DATA_LENGTH)) {
                  status = STATUS_DEVICE_NOT_READY;
                  break;
               }

               byteCount++;
               pCurrent++;
            }

            if (!NT_SUCCESS(status)) {
               break;
            }

            RtlCopyMemory((PUCHAR)SocketData->Ident, pStart, byteCount);
            //
            // Null terminate
            SocketData->Ident[byteCount] = '\0';
            DebugPrint((PCMCIA_DEBUG_TUPLES, "Identifier: %s\n", SocketData->Ident));

            PcmciaSubstituteUnderscore(SocketData->Ident);
            break;
         }
         //
         // get the device configuration base
         //

      case CISTPL_CONFIG: {
            ProcessConfig(&tuplePacket);
            break;
         }

      case CISTPL_CONFIG_CB: {
            ProcessConfigCB(&tuplePacket);
            break;
         }

      case CISTPL_CFTABLE_ENTRY_CB:
      case CISTPL_CFTABLE_ENTRY:  {
            //
            // construct a possible configuration entry for this device
            //
            configEntry = PcmciaProcessConfigTable(&tuplePacket);
            if (configEntry) {

               //
               // Link configurations at the end of the list.
               //

               configEntry->NextEntry = NULL;
               if (prevEntry) {
                  prevEntry->NextEntry = configEntry;
               } else {
                  SocketData->ConfigEntryChain = configEntry;
               }
               prevEntry = configEntry;

            }
            break;
         }
      case CISTPL_FUNCID: {
            //  Mark device type..
            SocketData->DeviceType = * (tuplePacket.TupleData);
            DebugPrint((PCMCIA_DEBUG_TUPLES, "DeviceType: %x\n", SocketData->DeviceType));
            break;
         }
      case CISTPL_MANFID: {
            //
            PUCHAR localBufferPointer = tuplePacket.TupleData;

            SocketData->ManufacturerCode = *(localBufferPointer+1) << 8 | *localBufferPointer;
            SocketData->ManufacturerInfo = *(localBufferPointer+3)<<8 | *(localBufferPointer+2);
            DebugPrint((PCMCIA_DEBUG_TUPLES, "Code: %x, Info: %x\n", SocketData->ManufacturerCode,
                                                                     SocketData->ManufacturerInfo));
            break;
         }

      }  // end switch on Tuple code
      //
      // Skip to the next tuple
      //
      status = GetNextTuple(&tuplePacket);
   }

   if (tuplePacket.TupleData) {
      ExFreePool(tuplePacket.TupleData);
   }
   if (status == STATUS_DEVICE_NOT_READY) {
      return status;
   }

   //
   // Serial/modem/ATA devices recognized and appropriate
   // fixes for tuples applied here
   //

   PcmciaCheckForRecognizedDevice(Socket,SocketData);
   DebugPrint((PCMCIA_DEBUG_SOCKET, "skt %08x ParseFunctionData: Final PcCard type %x\n",
               Socket, SocketData->DeviceType));
   return STATUS_SUCCESS;
}


NTSTATUS
PcmciaParseFunctionDataForID(
   IN PSOCKET_DATA SocketData
   )
/*++

Routine Description

   Parses the tuple data for the supplied function
   (SocketPtr->Function)

Arguments:

   Socket         - Pointer to the socket which contains the device
   SocketData - Pointer to the socket data structure for the function
                which will be filled with the parsed information

Return Value:

   Status
--*/

{
   PSOCKET Socket = SocketData->Socket;
   TUPLE_PACKET  tuplePacket;
   PUCHAR        localBufferPointer;
   NTSTATUS      status;
   USHORT        ManufacturerCode = 0;
   USHORT        ManufacturerInfo = 0;
   USHORT        CisCrc;

   DebugPrint((PCMCIA_DEBUG_TUPLES, "Parsing function %d for ID...\n", SocketData->Function));


   RtlZeroMemory(&tuplePacket, sizeof(TUPLE_PACKET));

   tuplePacket.DesiredTuple = 0xFF;
   tuplePacket.TupleData = ExAllocatePool(NonPagedPool, MAX_TUPLE_DATA_LENGTH);
   if (tuplePacket.TupleData == NULL) {
      return STATUS_INSUFFICIENT_RESOURCES;
   }
   tuplePacket.Socket             = Socket;
   tuplePacket.SocketData         = SocketData;
   tuplePacket.TupleDataMaxLength = MAX_TUPLE_DATA_LENGTH;
   tuplePacket.TupleOffset        = 0;
   tuplePacket.Function           = SocketData->Function;

   status = GetFirstTuple(&tuplePacket);

   if (!NT_SUCCESS(status) ||
       (tuplePacket.TupleCode == CISTPL_END)) {

      if (status != STATUS_DEVICE_NOT_READY) {
         if (IsSocketFlagSet(Socket, SOCKET_CARD_MEMORY)) {
            status = STATUS_SUCCESS;
         }
         status = STATUS_NO_MORE_ENTRIES;
      }

      if (tuplePacket.TupleData) {
         ExFreePool(tuplePacket.TupleData);
      }
      return status;
   }

   while (NT_SUCCESS(status)) {

      status = GetTupleData(&tuplePacket);
      ASSERT (NT_SUCCESS(status));

      switch (tuplePacket.TupleCode) {

      case CISTPL_MANFID: {

            localBufferPointer = tuplePacket.TupleData;
            ManufacturerCode = *(localBufferPointer+1) << 8 | *localBufferPointer;
            ManufacturerInfo = *(localBufferPointer+3)<<8 | *(localBufferPointer+2);
            break;
         }

      }  // end switch on Tuple code
      //
      // Skip to the next tuple
      //
      status = GetNextTuple(&tuplePacket);
   }

   if (tuplePacket.TupleData) {
      ExFreePool(tuplePacket.TupleData);
   }

   if (SocketData->ManufacturerCode != ManufacturerCode) {
      DebugPrint((PCMCIA_DEBUG_TUPLES, "Verify failed on Manf. Code: %x %x\n", SocketData->ManufacturerCode, ManufacturerCode));
      return STATUS_UNSUCCESSFUL;
   }

   if (SocketData->ManufacturerInfo != ManufacturerInfo) {
      DebugPrint((PCMCIA_DEBUG_TUPLES, "Verify failed on Manf. Info: %x %x\n", SocketData->ManufacturerInfo, ManufacturerInfo));
      return STATUS_UNSUCCESSFUL;
   }

   //
   // Get the CIS checksum
   //
   CisCrc = GetCRC(SocketData);

   if (SocketData->CisCrc != CisCrc) {
      DebugPrint((PCMCIA_DEBUG_TUPLES, "Verify failed on CRC: %x %x\n", SocketData->CisCrc, CisCrc));
      return STATUS_UNSUCCESSFUL;
   }

   DebugPrint((PCMCIA_DEBUG_INFO, "skt %08x R2 CardId verified %x-%x-%x\n", Socket,
                                         ManufacturerCode,
                                         ManufacturerInfo,
                                         CisCrc
                                         ));
   return STATUS_SUCCESS;
}



VOID
PcmciaCheckForRecognizedDevice(
   IN PSOCKET  Socket,
   IN OUT PSOCKET_DATA SocketData
   )

/*++

Routine Description:

    Look at the configuration options on the PCCARD to determine if
    it is a serial port / modem / ATA device card.

Arguments:

    Socket         - Pointer to the socket which contains the device
    SocketData - the configuration information on the current PCCARD.

Return Value:

    None - Modifications are made to the socket data structure.

--*/

{
   ULONG         modemPorts[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8};
   ULONG         ataPorts0[2]  = { 0x1f0, 0x170};
   BOOLEAN       found = FALSE;
   UCHAR         dataByte;
   UCHAR         link;
   ULONG         index;
   PUCHAR        localBufferPointer;
   TUPLE_PACKET  tuplePacket;
   PUCHAR        tupleData;
   PCONFIG_ENTRY configEntry;
   NTSTATUS      status;

   //
   // This piece of code searches the config data for I/O ranges that start at
   // some known industry standard, and updates the devicetype accordingly.
   //
   // This is such an ugly hack, I'm really skeptical that we should be doing
   // this anymore. I assume there must have been some broken hardware that needed
   // it, but that information is now lost. At some point, this whole for loop
   // should just be removed.
   //
   for (configEntry = SocketData->ConfigEntryChain; configEntry; configEntry = configEntry->NextEntry) {
      for (index = 0; index < 4; index++) {
         if (modemPorts[index] == configEntry->IoPortBase[0]) {

            SocketData->DeviceType = PCCARD_TYPE_SERIAL;
            found = TRUE;
            break;
         }

         if (index < 2) {
            if (ataPorts0[index] == configEntry->IoPortBase[0]) {
               if (configEntry->IoPortBase[1] == 0x376 ||
                   configEntry->IoPortBase[1] == 0x3f6 ) {
                  SocketData->DeviceType = PCCARD_TYPE_ATA;
                  found = TRUE;
                  break;
               }
            }
         }
      }
   }

   switch(SocketData->DeviceType) {

   case PCCARD_TYPE_ATA:
      //
      // More smudges follow here for ATA cards to rub out buggy tuples
      //
      // Search for configurations which are not viable for ATA devices
      // and mark them invalid so they would not be reported to the I/O subsystem.
      // Also fix buggy tuples on ATA cards
      for (configEntry = SocketData->ConfigEntryChain;
          configEntry != NULL; configEntry = configEntry->NextEntry) {
         //
         // Adjust the IO resource requirement: ATA cards
         // typically have an incorrect length here
         // (+1)
         //
         if (configEntry->IoPortLength[1] > 0) {
            configEntry->IoPortLength[1]=0;
         }

         //
         // This next hack is to work around a problem with Viking SmartCard adapters.
         // This adapter doesn't like I/O ranges that are based at 0x70 or 0xf0,
         // so we bump up the alignment to 0x20 on unrestricted I/O ranges.
         //

         if ((SocketData->ManufacturerCode == 0x1df) && (configEntry->NumberOfIoPortRanges == 1) &&
             (configEntry->IoPortBase[0] == 0) && (configEntry->IoPortLength[0] == 0xf) &&
             (configEntry->IoPortAlignment[0] == 0x10)) {
             // alter alignment
             configEntry->IoPortAlignment[0] = 0x20;
         }

         if (configEntry->NumberOfMemoryRanges) {
            //
            // Don't use this configuration
            //
            configEntry->Flags |=  PCMCIA_INVALID_CONFIGURATION;
         }
      }
      break;

   case PCCARD_TYPE_PARALLEL:
      // Search for configurations which are not viable for Parallel devices
      for (configEntry = SocketData->ConfigEntryChain;
          configEntry != NULL; configEntry = configEntry->NextEntry) {

         if (configEntry->NumberOfMemoryRanges) {
            //
            // Don't use this configuration
            //
            configEntry->Flags |=  PCMCIA_INVALID_CONFIGURATION;
         }
      }
      break;

   case PCCARD_TYPE_SERIAL: {
      //
      // If card type is serial , check if it's actually a modem...
      //

      UCHAR  tupleDataBuffer[MAX_TUPLE_DATA_LENGTH];
      PUCHAR str, pChar;

      RtlZeroMemory(&tuplePacket, sizeof(TUPLE_PACKET));

      tuplePacket.DesiredTuple = CISTPL_FUNCE;
      tuplePacket.TupleData = tupleDataBuffer;

      tuplePacket.Socket             = Socket;
      tuplePacket.SocketData         = SocketData;
      tuplePacket.TupleDataMaxLength =  MAX_TUPLE_DATA_LENGTH;
      tuplePacket.TupleOffset        =  0;
      tuplePacket.Function           = SocketData->Function;
      status = GetFirstTuple(&tuplePacket);

      while (NT_SUCCESS(status)) {
         status = GetTupleData(&tuplePacket);
         if (!NT_SUCCESS(status) || (tuplePacket.TupleDataLength == 0)) {
            // something bad happened
            break;
         }

         if (tuplePacket.TupleData[0] >=1 &&
             tuplePacket.TupleData[0] <=3) {
            SocketData->DeviceType = PCCARD_TYPE_MODEM;
            return;
         }
         status = GetNextTuple(&tuplePacket);
      }

      if (status == STATUS_DEVICE_NOT_READY) {
         return;
      }

      tuplePacket.DesiredTuple = CISTPL_VERS_1;
      status = GetFirstTuple(&tuplePacket);

      if (!NT_SUCCESS(status)) {
         return;
      }
      status = GetTupleData(&tuplePacket);
      if (!NT_SUCCESS(status) || (tuplePacket.TupleDataLength < 3)) {
         // something bad happened
         return;
      }
      str = tuplePacket.TupleData+2;

      for (;;) {
         if ( *str == 0xFF ) {
            //
            // End of strings
            //
            break;
         }
         //
         // Convert to upper case
         //
         for (pChar = str; *pChar ; pChar++) {
            *pChar = (UCHAR)toupper(*pChar);
         }
         if (strstr(str, "MODEM") ||
             strstr(str, "FAX")) {
            SocketData->DeviceType = PCCARD_TYPE_MODEM;
            break;
         }
         //
         // Move onto next string..
         //
         str = str + strlen(str)+1;
         //
         // Just in case...
         //
         if (str >= (tuplePacket.TupleData + tuplePacket.TupleDataLength)) {
            break;
         }
      }
      break;
   }
   }


   // Search for configurations which are not viable - because
   // the resources requested are not supported by the controller
   // or the OS - and mark them invalid so they would not be requested

   for (configEntry = SocketData->ConfigEntryChain;
       configEntry != NULL; configEntry = configEntry->NextEntry) {

      if ((configEntry->IrqMask == 0) &&
          (configEntry->NumberOfIoPortRanges == 0) &&
          (configEntry->NumberOfMemoryRanges == 0)) {
         //
         // This configuration doesn't need any resources!!
         // Obviously bogus. (IBM Etherjet-3FE2 has one of these)
         //
         configEntry->Flags |= PCMCIA_INVALID_CONFIGURATION;
      }

   }
}


BOOLEAN
PcmciaQuickVerifyTupleChain(
   IN PUCHAR Buffer,
   IN ULONG Length
   )

/*++

Routine description:

   This routine is provided as a quick low-level check of the attribute
   data in the passed buffer. The tuples aren't interpreted in context,
   rather the tuple links are followed to see if the chain isn't total
   garbage.

   Note that none of the normal tuple handling functions are called, this
   is to avoid recursion, since this may be called from within normal
   tuple processing.


Arguments:
   Buffer, Length - defines the buffer that contains attribute data

Return Value:
   TRUE if the data in this buffer looks like a reasonable tuple chain,
   FALSE otherwise

--*/
{

   ULONG TupleCount = 0;
   UCHAR code, link;
   ULONG Offset = 0;
   BOOLEAN retval = TRUE;

   if (Length < 2) {
      return FALSE;
   }

   code = *(PUCHAR)((ULONG_PTR)(Buffer));
   link = *(PUCHAR)((ULONG_PTR)(Buffer)+1);

   while(code != CISTPL_END) {

      if (link == 0xff) {
         break;
      }

      if (code == CISTPL_NULL) {
         Offset += 1;
      } else if (code == CISTPL_NO_LINK) {
         Offset += 2;
      } else {
         Offset += (ULONG)link+2;
      }

      if (Offset >= (Length-1)) {
         retval = FALSE;
         break;
      }

      TupleCount++;

      code = *(PUCHAR)((ULONG_PTR)(Buffer)+Offset);
      link = *(PUCHAR)((ULONG_PTR)(Buffer)+Offset+1);
   }

   if (!TupleCount) {
      retval = FALSE;
   }

   return retval;
}



NTSTATUS
PcmciaMemoryCardHack(
   IN  PSOCKET Socket,
   IN PSOCKET_DATA SocketData
   )
/*++

Routine Description:

   This routine is called whenever we do not find a CIS of the card.
   We  probe the card to determine if it is sram or not.

Arguments

   SocketPtr   - Point to the socket in which this card was found
   SocketData  - Pointer to  a pointer to the data structure which normally contains
                 parsed tuple data. This will be filled in by this routine


Return Value

   STATUS_SUCCESS

--*/
{

#define JEDEC_SRAM 0x0000               // JEDEC ID for SRAM cards
#define JEDEC_ROM  0x0002               // JEDEC ID for ROM cards
#define READ_ID_CMD      0x9090

   PPDO_EXTENSION pdoExtension = SocketData->PdoExtension;
   USHORT OrigValue;
   USHORT ChkValue;
   USHORT ReadIdCmd = READ_ID_CMD;

   PAGED_CODE();

   SetSocketFlag(Socket, SOCKET_CARD_MEMORY);

   SocketData->DeviceType = PCCARD_TYPE_MEMORY;
   SocketData->Flags = SDF_JEDEC_ID;
   SocketData->JedecId = JEDEC_ROM;

   //
   // Like win9x, we probe the card's common memory with a write to offset zero to see if
   // it looks like sram
   //

   if (((*(Socket->SocketFnPtr->PCBReadCardMemory)) (pdoExtension, PCCARD_COMMON_MEMORY, 0, (PUCHAR)&OrigValue, 2) == 2) &&
       ((*(Socket->SocketFnPtr->PCBWriteCardMemory))(pdoExtension, PCCARD_COMMON_MEMORY, 0, (PUCHAR)&ReadIdCmd, 2) == 2) &&
       ((*(Socket->SocketFnPtr->PCBReadCardMemory)) (pdoExtension, PCCARD_COMMON_MEMORY, 0, (PUCHAR)&ChkValue, 2)  == 2) &&
       ((*(Socket->SocketFnPtr->PCBWriteCardMemory))(pdoExtension, PCCARD_COMMON_MEMORY, 0, (PUCHAR)&OrigValue, 2) == 2)) {

      if (ChkValue == ReadIdCmd) {
         SocketData->JedecId = JEDEC_SRAM;
      }
   }

   if (pcmciaReportMTD0002AsError && (SocketData->JedecId == JEDEC_ROM)) {
      return STATUS_DEVICE_NOT_READY;
   }

   return STATUS_SUCCESS;
}