/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1998 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
----------------------------------------------------------------------------*/
/*
	HISTORY
	980603	Tilakraj Roychoudhury	Created

    Following SCCS macros added by Nadeem:
    
    Module name              : tmpnp.c    1.4 
 
    Last update              : 18:27:07 - 99/02/21
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#define WANTVXDWRAPS
#include <basedef.h>
#include <vmm.h>
#include <vxdwraps.h>
#include <configmg.h>
#include <mmdevldr.h>
#include <vwin32.h>

/*----------------------------------------------------------------------------
          DRIVER SPECIFIC INCLUDE FILES
----------------------------------------------------------------------------*/
#include "vxstd.h"
#include "vxwin.h"

#include "tmmanlib.h"
#include "platform.h"

#define isdigit(x)      ((((x) >= 0) && ((x) <= 9)) ? TRUE : FALSE )
#define hexchar(x)      (CHAR)((isdigit(x) ? ((x) + '0') : (((x) - 0xa) + 'A')))
#define iscontrol(c)    ( (((c)<= 0) && ((c)<=32)) ? 1 : 0 )
#define toupper(c)      ( (((c) >='a') && ((c) <= 'z')) ? ((c) - 'a' + 'A') : (c) )


#pragma VxD_LOCKED_CODE_SEG
#pragma	VxD_LOCKED_DATA_SEG

DEBUG_CONFIG_NAMES

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

ULONG	pnpDevNodeToDeviceIndex ( DEVNODE DevNode );

typedef BOOL ( *PCI_DEVICE_COMPARE ) ( PULONG PCIRegisters, PVOID Context );

BOOL	pnpPCIDeviceID2Number (
	ULONG	DeviceVendorID,
	PCI_DEVICE_COMPARE	ComparisonFunction, 
	PVOID				ComparisonContext,
	PULONG	Bus, 
	PULONG	Device, 
	PULONG	Function  );

// Added by NM
//UInt32 GetBoardType(PCHAR DeviceID);

BOOL	DECBridgeComparisonFunction ( PULONG PCIRegisters, PVOID Context );
BOOL	TM1000ComparisonFunction ( PULONG PCIRegisters,  PVOID Context );
BOOL	TM2000ComparisonFunction ( PULONG PCIRegisters,  PVOID Context );

/*----------------------------------------------------------------------------
          GENERIC PNP FUNCTIONS
----------------------------------------------------------------------------*/
CONFIGRET CM_SYSCTRL
vxdConfigRegisterHandler ( DWORD DevNode, LOAD_TYPE LoadType, DWORD Constant )
{
	//LOAD_TYPE LoadType = (LOAD_TYPE)pvContext;

	switch (LoadType) 
	{
		case DLVXD_LOAD_ENUMERATOR:
			return(CR_DEFAULT);

		case DLVXD_LOAD_DRIVER:
			return 	CM_Register_Device_Driver(
				DevNode, vxdPnPConfigHandler, 0, CM_REGISTER_DEVICE_DRIVER_REMOVABLE);

		case DLVXD_LOAD_DEVLOADER:
			return(CR_DEFAULT);

		default:
			return(CR_DEFAULT);
	}

}


CONFIGRET	pnpOnConfigStop ( DEVNODE DevNode )
{
	return CR_SUCCESS;
}

CONFIGRET	pnpOnConfigTest ( DEVNODE DevNode )
{
	return CR_SUCCESS;
}

CONFIGRET	pnpOnConfigRemove ( DEVNODE DevNode )
{
	ULONG DeviceIndex;

	if ( 0xffffffff == ( DeviceIndex = pnpDevNodeToDeviceIndex ( DevNode ) ) )
	{
		DPF(0,("TM:pnpConfigStart:Devnode[0x%x]@[0x%x]:Already Removed:FAIL\n",
			DevNode, DeviceIndex ));
		return CR_SUCCESS;
	}

	tmmanExit ( DeviceIndex );

	TMManGlobal->DeviceList[DeviceIndex] = NULL;

	return CR_SUCCESS;
}


CONFIGRET	pnpOnConfigStart ( 
	DEVNODE DevNode )
{
	halParameters	Config;
	PVOID			AllocatedDevice;
	ULONG			LatencyTimer, CommandStatus;
	CHAR			DeviceID[MAX_DEVICE_ID_LEN];
	CONFIGRET		CMResult;
	CMCONFIG		CMConfig;
	ULONG			Idx, DevnodeIndex;
	ULONG			PCIVendorDeviceID;

	if ( 0xffffffff != ( DevnodeIndex = pnpDevNodeToDeviceIndex ( DevNode ) ) )
	{
		DPF(0,("TM:pnpConfigStart:Devnode[0x%x]@[0x%x]:Already Exits:FAIL\n",
			DevNode, DevnodeIndex ));
		return CR_SUCCESS;
	}

	if ( ( CMResult = CM_Get_Device_ID  ( 
		DevNode, DeviceID, MAX_DEVICE_ID_LEN, 0  ))
		!= CR_SUCCESS )
	{
		DPF(0,("TM:pnpConfigStart:CONFIGMG_Get_Device_ID:FAIL\n"));
		return CR_FAILURE;
	}


	DPF(1,("TM:pnpConfigStart:CONFIGMG_Get_Device_ID[%s]\n", DeviceID ));

	if ( ( CMResult = CM_Get_Alloc_Log_Conf ( 
		&CMConfig, DevNode, CM_GET_ALLOC_LOG_CONF_ALLOC ))
		!= CR_SUCCESS )
	{
		DPF(0,("TM:pnpConfigStart:CM_Get_Alloc_Log_Config:FAIL\n"));
		return CR_FAILURE;
	}

	// DEC Bridge
	if ( pnpPCIDeviceID2Number ( 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ),
		DECBridgeComparisonFunction,
		&CMConfig, 
		&Config.BusNumber, 
		&Config.DeviceNumber, 
		&Config.FunctionNumber  ) == FALSE )
	{
		// TM1000
		if ( pnpPCIDeviceID2Number ( 
			( ( constTMMANTM1000DeviceID << 16 ) | constTMMANTM1000VendorID ),
			TM1000ComparisonFunction,
			&CMConfig, 
			&Config.BusNumber, 
			&Config.DeviceNumber, 
			&Config.FunctionNumber  ) == FALSE )
		{
			// TM2000
			if ( pnpPCIDeviceID2Number ( 
				( ( constTMMANTM2000DeviceID << 16 ) | constTMMANTM2000VendorID ),
				TM2000ComparisonFunction,
				&CMConfig,
				&Config.BusNumber, 
				&Config.DeviceNumber, 
				&Config.FunctionNumber  ) == FALSE )
			{
				// TM1300
				if ( pnpPCIDeviceID2Number ( 
					( ( constTMMANTM1300DeviceID << 16 ) | constTMMANTM1300VendorID ),
					TM1000ComparisonFunction,
					&CMConfig,
					&Config.BusNumber, 
					&Config.DeviceNumber, 
					&Config.FunctionNumber  ) == FALSE )
				{
					return CR_FAILURE;
				}
			}
		}

	}


    // read the hardware revision ID
    if ( pciReadConfigDW ((BYTE)Config.BusNumber,
    	DevFunc2BYTE(Config.DeviceNumber,Config.FunctionNumber), 
    	(WORD)0x0, &PCIVendorDeviceID) == FALSE )
    {
    	DPF(0,("TM:pnpConfigStart:BIOS:PCI Vendor Device ID:FAIL\n"));
    	return CR_FAILURE;
    }


	// validate the resources count and fail if the resoruces are not OK
	// check for the DEC bridge chip of it is not then it is a TMX000
	if ( PCIVendorDeviceID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
    {
    	if ( ( CMConfig.wNumMemWindows != 3 ) ||
    		( CMConfig.wNumIRQs != 1 ) )
    	{
    		DPF(0,("TM:pnpConfigStart:iResource Validation:FAIL\n"));
    		return CR_FAILURE;
    	}
    }
	else
	{
    	if ( ( CMConfig.wNumMemWindows != 2 ) ||
    		( CMConfig.wNumIRQs != 1 ) )
    	{
    		DPF(0,("TM:pnpConfigStart:iResource Validation:FAIL\n"));
    		return CR_FAILURE;
    	}
	}

	// get the interrupt vector
	Config.InterruptVector				= CMConfig.bIRQRegisters[0];


	if ( PCIVendorDeviceID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
    {

		Config.BridgeDeviceVendorID = PCIVendorDeviceID;
		// Base 0 is not used. Start with Base 1
		Config.SDRAMAddrPhysical.HighPart	= 0;
		Config.SDRAMAddrPhysical.LowPart	= CMConfig.dMemBase[1];
		Config.SDRAMLength					= CMConfig.dMemLength[1];
		Config.MMIOAddrPhysical.HighPart	= 0;
		Config.MMIOAddrPhysical.LowPart		= CMConfig.dMemBase[2];
		Config.MMIOLength					= CMConfig.dMemLength[2];
    }
	else //TM1000 or TM2000
	{
		Config.TMDeviceVendorID				= PCIVendorDeviceID;
		Config.BridgeDeviceVendorID			= 0;
		Config.SDRAMAddrPhysical.HighPart	= 0;
		Config.SDRAMAddrPhysical.LowPart	= CMConfig.dMemBase[0];
		Config.SDRAMLength					= CMConfig.dMemLength[0];
		Config.MMIOAddrPhysical.HighPart	= 0;
		Config.MMIOAddrPhysical.LowPart		= CMConfig.dMemBase[1];
		Config.MMIOLength					= CMConfig.dMemLength[1];
    }

	Config.DevNode						= DevNode;


	if ( (  Config.TMDeviceVendorID == ( ( constTMMANTM1000DeviceID << 16 ) | constTMMANTM1000VendorID ) ) || 
		( Config.TMDeviceVendorID == ( ( constTMMANTM2000DeviceID << 16 ) | constTMMANTM2000VendorID ) ) ||
		( Config.TMDeviceVendorID == ( ( constTMMANTM1300DeviceID << 16 ) | constTMMANTM1300VendorID ) ) )
    {
    	// read the hardware revision ID
    	if ( pciReadConfigDW ((BYTE)Config.BusNumber,
    		DevFunc2BYTE(Config.DeviceNumber,Config.FunctionNumber), 
    		(WORD)0x8, &Config.TMClassRevisionID) == FALSE )
    	{
    		DPF(0,("TM:pnpConfigStart:BIOS:Revision ID Retrieve:FAIL\n"));
    		return CR_FAILURE;
    	}

    	// read the subsystem and subsystem vendor ID.
    	if ( pciReadConfigDW ((BYTE)Config.BusNumber,
    		DevFunc2BYTE(Config.DeviceNumber, Config.FunctionNumber), 
    		(WORD)0x2c, &Config.TMSubsystemID ) == FALSE )
    	{
    		DPF(0,("TM:pnpConfigStart:BIOS:Subsystem ID Retrieve:FAIL\n"));
    		return CR_FAILURE;
    	}

    	if ( pciReadConfigDW ((BYTE)Config.BusNumber,
    		DevFunc2BYTE(Config.DeviceNumber, Config.FunctionNumber), 
    		(WORD)0xc, &LatencyTimer ) == FALSE )
    	{
    		DPF(0,("TM:pnpConfigStart:BIOS:Latency Timer Retrive:FAIL\n"));
    		return CR_FAILURE;
    	}

    	// according to zcw latency 0f 0 is the maximum
    	LatencyTimer |=  ( ( 5 << 11) & ( ( 0 ) << 11 ) );

    	if ( pciWriteConfigDW ((BYTE)Config.BusNumber,
    		DevFunc2BYTE(Config.DeviceNumber, Config.FunctionNumber), 
    		(WORD)0xc, LatencyTimer ) == FALSE )
    	{
    		DPF(0,("TM:pnpConfigStart:BIOS:Latency Timer Write:FAIL\n"));
    		return CR_FAILURE;
    	}


    	// on some machine intel does not set the MA bit - so go ahead
    	// and set it.
    	if ( pciReadConfigDW ((BYTE)Config.BusNumber,
    		DevFunc2BYTE(Config.DeviceNumber, Config.FunctionNumber), 
    		(WORD)0x4, &CommandStatus ) == FALSE )
    	{
    		DPF(0,("TM:pnpConfigStart:BIOS:Command Status Retrieve:FAIL\n"));
    		return CR_FAILURE;
    	}


    	CommandStatus |=  1 << 1;

    	if ( pciWriteConfigDW ((BYTE)Config.BusNumber,
    		DevFunc2BYTE(Config.DeviceNumber, Config.FunctionNumber), 
    		(WORD)0x4, CommandStatus ) == FALSE )
    	{
    		DPF(0,("TM:pnpConfigStart:BIOS:Command Status Write:FAIL\n"));
    		return CR_FAILURE;
    	}
	}       // End TM Board specific code

	/* read the entire PCI space and store it */
	for ( Idx = 0 ; Idx < constTMMANPCIRegisters ; Idx++ )
	{
		if ( pciReadConfigDW (
			(BYTE)Config.BusNumber,
			DevFunc2BYTE(Config.DeviceNumber, Config.FunctionNumber), 
			(WORD)Idx * 4, 
			&Config.PCIRegisters[Idx] ) == FALSE )