{
			DPF(0,("TM:pnpConfigStart:BIOS:PCI Register #[%x] Retrive:FAIL\n", Idx ));
			return CR_FAILURE;
		}
	}
	
	DPF( 1,("tmman:pnpConfigStart:Bus[%x]:Device[%x]:Function[%x]\n",
		Config.BusNumber, 
		Config.DeviceNumber, 
		Config.FunctionNumber  ));

	DPF( 1,("tmman:pnpConfigStart:SDRAMBase[%x]:SDRAMLenL[%x]\n",
		Config.SDRAMAddrPhysical.LowPart, Config.SDRAMLength ));

	DPF( 1,("tmman:pnpConfigStart:MMIOBase[%x]:MMIOLen[%x]\n",
		Config.MMIOAddrPhysical.LowPart, Config.MMIOLength ));
		 
	DPF( 1,("tmman:pnpConfigStart:IRQ[%x]\n",
		Config.InterruptVector ));
	
	if ( ( AllocatedDevice = tmmanInit ( 
		TMManGlobal->DeviceCount , &Config ) ) == NULL )
	{
		return CR_FAILURE;
	}

	// insert the device we have just created into the global device list for this driver
	TMManGlobal->DeviceList[TMManGlobal->DeviceCount] = AllocatedDevice;
	TMManGlobal->DeviceCount++;


	return CR_SUCCESS;
}	


/*
	vxdPnpConfigHandler

	The generic Plug and Play configuration handler.
	call the pnpConfigXXX on receiving CONFIG_XXXX notifications.
*/

CONFIGRET  CM_HANDLER vxdPnPConfigHandler(
	CONFIGFUNC cfFuncName,
	SUBCONFIGFUNC scfSubFuncName,
	DEVNODE	dnToDevNode,
	DWORD dwRefData,
	ULONG ulFlags)
{

    DPF(0,("TM:vxdPnPConfigHandler:DN[0x%x]:Func[%s]:SubFunc[0x%x]\n",
		dnToDevNode, lpszConfigName[cfFuncName],scfSubFuncName ));

    switch (cfFuncName)
	{
		case CONFIG_FILTER:
		return CR_SUCCESS;

		case CONFIG_START:
		switch (scfSubFuncName)
		{
			case CONFIG_START_FIRST_START:
			case CONFIG_START_DYNAMIC_START:
			{ 	
				return pnpOnConfigStart ( dnToDevNode );
			}
			break;

			default:
			return CR_DEFAULT;
		}
		break;

		case CONFIG_TEST:
		switch (scfSubFuncName)
		{
			case CONFIG_TEST_CAN_STOP:
			case CONFIG_TEST_CAN_REMOVE:
			return pnpOnConfigTest ( dnToDevNode );

			default:
			break;
		}
		break;


		case CONFIG_STOP:
		return pnpOnConfigStop ( dnToDevNode );

		case CONFIG_REMOVE:
		case CONFIG_PREREMOVE:
		case CONFIG_PREREMOVE2:
		return pnpOnConfigRemove ( dnToDevNode );
		

		default:
		return CR_DEFAULT;
	}
}


ULONG	pnpDevNodeToDeviceIndex ( DEVNODE DevNode )
{
	ULONG	Idx;
 	
	for ( Idx = 0 ; Idx < TMManGlobal->DeviceCount ; Idx++ )
	{
		if ( TMManGlobal->DeviceList[Idx] &&
			( ((TMManDeviceObject*)TMManGlobal->DeviceList[Idx])->DevNode == 
			DevNode ) )
			return Idx;
	}

	return 0xffffffff;
}

PCHAR	strStr ( PCHAR String, PCHAR SubString )
{
	DWORD	StringIdx, StringIdx2, SubStringIdx, Mismatch;

	for ( StringIdx = 0 ; String[StringIdx] ; StringIdx ++ )
	{
		StringIdx2 = StringIdx;
		Mismatch = 0;		

		for ( SubStringIdx = 0 ; 
			SubString[SubStringIdx] ; 
			SubStringIdx++, StringIdx2++ )
		{
			if ( String[StringIdx2] != SubString[SubStringIdx] )
			{
				Mismatch = 1;
				break;
			}
		}

		if ( ! Mismatch ) return &String[StringIdx];
	}	

	return NULL;
}

ULONG	HexToNumber ( PCHAR Hex )
{
	ULONG	Value;
	CHAR	Char0, Char1;

	// revert the order due to difference between text and 
	// numeric representaions.

	Char0 = toupper( Hex[1]);
	Char1 = toupper( Hex[0]);
    
	if ( ( Char0 >= '0') && ( Char0 <= '9') )
	{
		Value = ( (ULONG)Char0 - (ULONG)'0' );
	}
	else
	{
		Value = ( ( (ULONG)Char0 - (ULONG)'A' ) + 10 );
	}

	if ( ( Char1 >= '0')  && ( Char1 <= '9') )
	{
		Value += ( (ULONG)Char1 - (ULONG)'0' ) * 16;
	}
	else
	{
		Value += ( ( (ULONG)Char1 - (ULONG)'A' ) + 10 ) * 16;
	}

	return Value;
}

ULONG	HexStrToNumber ( PCHAR Hex )
{
	ULONG	Value;
    CHAR Ch;
    Value = 0;
    while(*Hex != 0)
    {
        Ch = toupper(*Hex);
        if( (Ch >= '0') && (Ch <= '9') )
            Value = Value*16 + ( (ULONG)Ch - (ULONG)'0' );
        else
            Value = Value*16 + ( ( (ULONG)Ch - (ULONG)'A' ) + 10 );
        Hex++;
    }
	return Value;
}

BOOL	pnpPCIDeviceID2Number (
	ULONG	DeviceVendorID,
	PCI_DEVICE_COMPARE	ComparisonFunction, 
	PVOID				ComparisonContext,
	PULONG	Bus, 
	PULONG	Device, 
	PULONG	Function  )
{
	ULONG				BusNumber;
	ULONG				DeviceNumber;
	ULONG				PCIDeviceVendorID;
	ULONG				PCIBaseAddresses1;
	UCHAR				BusCount = 0;
	UCHAR				Dummy;
	ULONG				Idx;
	ULONG				PCIRegisters[constTMMANPCIRegisters];

	pciCheckBIOS ( &BusCount, &Dummy, &Dummy  );

    for (BusNumber = 0 ; BusNumber < (ULONG)(BusCount + 1); BusNumber++) 
	{
        for ( DeviceNumber = 0 ; DeviceNumber < 32 ; DeviceNumber++ ) 
		{
			// read the hardware revision ID
			if ( pciReadConfigDW (
				(BYTE)BusNumber,
    			DevFunc2BYTE(DeviceNumber,0), 
    			(WORD)0x0, 
				&PCIDeviceVendorID) == FALSE )
			{
    			DPF(0,("TM:pnpPCIDeviceID2Number:BIOS:PCI Vendor Device ID:FAIL\n"));
    			return FALSE;
			}

			/*
			DPF (0, 
				("pnpFindPCIDevices:[Bus:%x][Dev:%x][Func:%x][Vendor:%x][Device:%x]\n",
				BusNumber, i, j, PciData.VendorID, PciData.DeviceID ));
			*/

            if ( ( PCIDeviceVendorID  & 0x0000ffff ) == 0xffff ) 
			{
                continue;
            }

            if ( PCIDeviceVendorID == DeviceVendorID )
			{
				for ( Idx = 0 ; Idx < constTMMANPCIRegisters ; Idx++ )
				{
					if ( pciReadConfigDW (
						(BYTE)BusNumber,
    					DevFunc2BYTE(DeviceNumber,0), 
    					(WORD)Idx * sizeof(ULONG), 
						&PCIRegisters[Idx] ) == FALSE )
					{
    					DPF(0,("TM:pnpPCIDeviceID2Number:BIOS:PCI Base Address 1:FAIL\n"));
    					return FALSE;
					}
				}

				// have to call a chipset specific comparison function
				if ( (*ComparisonFunction )( PCIRegisters, ComparisonContext ) == TRUE )
				{
					*Bus = BusNumber;
					*Device = DeviceNumber;
					*Function = 0;
					return TRUE;
				}
			}
		}
	}

 	return FALSE;
}

BOOL	DECBridgeComparisonFunction ( PULONG PCIRegisters, PVOID Context )
{
	PCMCONFIG	CMConfig = (PCMCONFIG)Context;
	return ( CMConfig->dMemBase[1] == PCIRegisters[6] );
}

BOOL	TM1000ComparisonFunction ( PULONG PCIRegisters, PVOID Context  )
{
	PCMCONFIG CMConfig = (PCMCONFIG)Context;
	return ( CMConfig->dMemBase[1] == PCIRegisters[5] );
}

BOOL	TM2000ComparisonFunction ( PULONG PCIRegisters, PVOID Context  )
{
	PCMCONFIG CMConfig = (PCMCONFIG)Context;
	return ( CMConfig->dMemBase[1] == PCIRegisters[5] );
}


/*
BOOL	pnpPCIDeviceID2Number ( 
	PCHAR DeviceID, 
	PULONG Bus, 
	PULONG Device, 
	PULONG Function  )
{
	PCHAR	SubStr;

	// PCI\VEN_1131&DEV_5400\BUS_00&DEV_0D&FUNC_00

	if ( ( SubStr = strStr( DeviceID , "BUS" ) ) == NULL )
	{
		return FALSE;
	}

	
	SubStr += 4; //point to bus number

	*Bus = HexToNumber( SubStr );
		
	if ( ( SubStr = strStr( SubStr , "DEV" ) ) == NULL )
	{
		return FALSE;
	}

	SubStr += 4; //point to device number

	*Device = HexToNumber( SubStr );
	
	if ( ( SubStr = strStr( SubStr , "FUNC" ) ) == NULL )
	{
		return FALSE;
	}

	SubStr += 5; //point to device number

	*Function = HexToNumber( SubStr );
}
*/
/***********************************
Added by NM
**********************************
UInt32 GetBoardType(PCHAR DeviceID)
{
    UInt16 vendorID;
    PCHAR SubStr;
    CHAR localStr[100];


	if ( ( SubStr = strStr( DeviceID , "VEN" ) ) == NULL )
	{
		return UNKNOWN_BOARD;
	}
	SubStr += 4; //point to vendor
    strcpy(localStr,SubStr);
    localStr[4]=0;      // Vendor ID is 4 characters long
    DPF(1,(localStr));
    vendorID=HexStrToNumber( localStr );
    switch(vendorID)
    {
        case constTMMANVendorID:
            return TM_BOARD;
        case constTMMANDECBridgeVendorID:
            return DEC_BOARD;
        default:
            return UNKNOWN_BOARD;
    }
}
*/