dospci.c

PNX系列设备驱动 PNX系列设备驱动

			}
			else
			{
				if ( Value == ( ( ((ULONG)DeviceID)  << 16 ) | (ULONG)VendorID) )
				{
					PRINTF(("dospci:DEBUG:PCIFindDevice:Value[%lx]:FOUND\n", 
						Value ));
					return PCI_ERR_OK;
				}
			}

		}
		*DeviceNumberPtr = 0;
	}

	return PCI_ERR_NOMOREDEVICES;
}

	


void main ( int argc, char *argv[] )
{   
	UCHAR	Return;   
	UCHAR	BusNumber;
	UCHAR	DeviceNumber;
	UCHAR	FunctionNumber;
	
	USHORT	Register, VendorID = VENDOR_ID, DeviceID = DEVICE_ID;
	UCHAR	BIOSHardwareMechanism;
	USHORT	BIOSInterfaceVersion;
	UCHAR	BIOSBusCount;
	USHORT	DeviceCount;

	ULONG	Value;
	USHORT	wIdxArg;

	BOOLEAN fAllDevices=0;
	BOOLEAN fFindClass =0;
	BOOLEAN fWritePCI = 0;
	BOOLEAN fFindDevice = 0;
	BOOLEAN fReadDevice = 0;
	BOOLEAN fGetIRQRouting = 0;

	USHORT Class;
	
	printf (
		"\nPCI Configuration Tool v2.0 - Copyright (c) Philips Semiconductors 1998\n");

	if ( argc < 2 )
	{
		fFindDevice = TRUE;
		fReadDevice = TRUE;
	}
		
	/* parse the command line arguments to figure out what we have to do */
	for ( wIdxArg = 1; wIdxArg < (USHORT)argc ; wIdxArg++ )
	{
		if( argv[wIdxArg][0] != '-' )
		{
			goto main_usage;
		}

		switch ( toupper ( argv[wIdxArg][1]) )
		{
			case 'W' :
			fWritePCI = TRUE;
			if ( sscanf(&argv[wIdxArg+1][0], "%x", &Register ) != 1 )
			{
				goto main_usage;
			}
			if ( sscanf(&argv[wIdxArg+2][0], "%lx", &Value ) != 1 )
			{
				goto main_usage;
			}
			wIdxArg += 2;
			break;


			case 'V' :     
			fFindDevice = TRUE;
			fReadDevice = TRUE;
			if  ( sscanf(&argv[wIdxArg][2], "%x", &VendorID ) != 1 )
			{
				goto main_usage;
			}
			break;

			case 'D' :
			if ( sscanf(&argv[wIdxArg][2], "%x", &DeviceID ) != 1 )
			{
				goto main_usage;
			}
			DeviceNumber = (UCHAR)DeviceID;
			break;

			case 'B' :     
			fFindDevice = FALSE;
			fReadDevice = TRUE;
			if  ( sscanf(&argv[wIdxArg][2], "%x", &BusNumber ) != 1 )
			{
				goto main_usage;
			}
			break;

			case 'F' :     
			if  ( sscanf(&argv[wIdxArg][2], "%x", &FunctionNumber ) != 1 )
			{
				goto main_usage;
			}
			break;

			case 'H' :
			fFindDevice = TRUE;     
			fReadDevice = FALSE;
			break;
			
			case 'A' :
			fAllDevices = TRUE;
			break;
			
			case 'C' :
			fFindClass = 1;
			if ( sscanf(&argv[wIdxArg][2], "%x", &Class ) != 1 )
			{
				goto main_usage;
			}
			break;

			case 'S' :
			printf ( "\ndospci : Option not yet implemented\n");
			break;
			
			case 'I' :
			fGetIRQRouting = TRUE;
			break;
			
			case '?':
			default :
			goto main_usage;
			break;
 
		}
	}	

	Return = PCIBIOSPresent (
		&BIOSHardwareMechanism,
		&BIOSInterfaceVersion,
		&BIOSBusCount );

	if ( Return != PCI_ERR_OK )
	{
		printf ( "dospci : PCIBIOSPresent : FAIL [%x]\n",
			Return );
		return;
	}

	printf ( "PCI BIOS : Interface Version [%u.%u] : Bus Count [%x]\n",
		(BIOSInterfaceVersion & 0xff00) >> 8,
		(BIOSInterfaceVersion & 0x00ff),
		BIOSBusCount );

	
	if ( fGetIRQRouting )
	{             
		USHORT IdxTable, IdxIRQ;
		PVOID	pRoutingBuffer = &RoutingBuffer; 
		PVOID	pRoutingTable = &RoutingTable; 
		
		RoutingBuffer.wBufferSize = sizeof (RoutingTable);
		RoutingBuffer.wDataSegment = ((PUSHORT)(&pRoutingTable))[1]; 
		RoutingBuffer.wDataOffset = ((PUSHORT)(&pRoutingTable))[0];
		
		Return = PCIIRQRouting ( ((PUSHORT)(&pRoutingBuffer))[1],
			((PUSHORT)(&pRoutingBuffer))[0] );

		if ( Return != PCI_ERR_OK )
		{
			printf ( "dospci : PCIIRQRouting : FAIL [%x]\n",
				Return );
			return;
		}
			
		printf ( 
		"\nPCI Bus Slot Count[%x]", 
			RoutingBuffer.wBufferSize / sizeof ( IRQROUTINGTABLE ) );
			
		for ( IdxTable = 0 ; 
			IdxTable <  RoutingBuffer.wBufferSize / sizeof ( IRQROUTINGTABLE ) ;
			IdxTable ++ )
		{
			printf ( "\nPCI Slot : Bus#[%02x]:Device#[%02x]:Slot#[%02x]",
				(USHORT)RoutingTable[IdxTable].bBusNumber,
				(USHORT)RoutingTable[IdxTable].bDeviceNumber,
				(USHORT)RoutingTable[IdxTable].bSlotNumber );
				
			for  ( IdxIRQ = 0 ; IdxIRQ < 0x4 ; IdxIRQ ++ )
			{
				printf ( "\n\tINT%c# : Link[%02x] : Bitmap[%04x]", IdxIRQ + 'A',
					(USHORT)RoutingTable[IdxTable].IRQ[IdxIRQ].bLink,
					RoutingTable[IdxTable].IRQ[IdxIRQ].wBitmap );
			}
		}
		
		return;   
	}
	
	if ( fFindDevice )
	{
		BusNumber = 0; 
		DeviceNumber = 0; 
		FunctionNumber = 0;

		PRINTF(("dospci:DEBUG:VendorID[%x] DeviceID[%x] : Find Devices\n", 
			VendorID, DeviceID ));

		Return = PCI_ERR_OK;

		for ( DeviceCount = 0 ; ; DeviceCount++, DeviceNumber++ )
		{
			Return = PCIFindDevice ( 
				VendorID, DeviceID, 
				BIOSBusCount,
				&BusNumber, &DeviceNumber, &FunctionNumber );

			if ( Return == PCI_ERR_NOMOREDEVICES )
				break;

			if ( Return != PCI_ERR_OK )
			{
				printf ( "dospci : PCIFindDevice : FAIL [%x]\n",
					Return );
				return;
			}

			printf ( 
				"\nPCI Device#[%02x] : VendorID[%04x] DeviceID[%04x] : Bus#[%02x] Dev#[%02x] Func#[%01x]\n",
				DeviceCount, VendorID, DeviceID, BusNumber, DeviceNumber, FunctionNumber );

			if ( fReadDevice )
			{
				PCIREGISTERS	PCIRegisters;
				UCHAR			Return;
				UCHAR			RegisterIndex;
				
				Return = PCIReadDevice ( 
					BusNumber, DeviceNumber, FunctionNumber, (PULONG)&PCIRegisters );

				if ( Return != PCI_ERR_OK )
				{
					printf ( "dospci : PCIReadDevice : FAIL [%x]\n",
						Return );
					return;
				}

				for ( RegisterIndex = 0 ; RegisterIndex <= PCI_MAX_REGISTERS ; RegisterIndex ++ )
				{
					printf ( "PCI Reg#[%02x] : Offset[%02x] : Value [%08lx]\n",
						RegisterIndex, (RegisterIndex * 4), ((PULONG)&PCIRegisters)[RegisterIndex] );
				}	

			}
		}
		printf ("\n");
		return;
	}


	/* if we have to write then do that first */
	if ( fWritePCI )
	{
		PCIREGISTERS	PCIRegisters;
		UCHAR			RegisterIndex;
		
		if ( Register > 0x10 )
		{
			printf ( "\ndospci : ERROR : Register > 0x10");
			return;
		}
		
		Return = PCIWriteULONG (
			BusNumber,
			DeviceNumber,
			FunctionNumber,
			(Register * 4 ),
			Value );

		if ( Return != PCI_ERR_OK )
		{
			printf ( "dospci : PCIWriteULONG : FAIL [%x]\n",
				Return );
			return;
		}


		printf ( "PCI :Write : Reg#[%x] : Offset[%02x] : Value [%08lx]\n",
			Register, (Register * 4), Value );

		printf("\n");
		
		Return = PCIReadDevice ( 
			BusNumber, DeviceNumber, FunctionNumber, (PULONG)&PCIRegisters );

		if ( Return != PCI_ERR_OK )
		{
			printf ( "dospci : PCIReadDevice : FAIL [%x]\n",
				Return );
			return;
		}

		for ( RegisterIndex = 0 ; RegisterIndex <= PCI_MAX_REGISTERS ; RegisterIndex ++ )
		{
			printf ( "PCI Reg#[%02x] : Offset[%02x] : Value [%08lx]\n",
				RegisterIndex, (RegisterIndex * 4), ((PULONG)&PCIRegisters)[RegisterIndex] );
		}	
		printf ("\n");
		return;
	}
	
	if ( fAllDevices || fFindClass)
	{
		UCHAR			Return;
		UCHAR			RegisterIndex;

		PCIREGISTERS	PCIRegisters;

		PRINTF(("dospci:DEBUG:Find All Devices\n" ));

		BusNumber = 0; 
		DeviceNumber = 0; 
		FunctionNumber = 0;

		for ( DeviceCount = 0 ; ; DeviceCount++, DeviceNumber++ )
		{
			Return = PCIFindDevice ( 
				0xffff, 0xffff,
				BIOSBusCount, 
				&BusNumber, &DeviceNumber, &FunctionNumber );

			if ( Return == PCI_ERR_NOMOREDEVICES )
				break;

			if ( Return != PCI_ERR_OK )
			{
				printf ( "dospci : PCIFindDevice : FAIL [%x]\n",
					Return );
				return;
			}

			Return = PCIReadDevice ( 
				BusNumber, DeviceNumber, FunctionNumber, (PULONG)&PCIRegisters );

			if ( Return != PCI_ERR_OK )
			{
				printf ( "dospci : PCIReadDevice : FAIL [%x]\n",
					Return );
				return;
			}

			if ( fAllDevices )
			{
				printf ( 
					"\nPCI Device#[%02x] : VendorID[%04x] DeviceID[%04x] : Bus#[%02x] Dev#[%02x] Func#[%01x]\n",
					DeviceCount, PCIRegisters.wVendorID, PCIRegisters.wDeviceID, BusNumber, DeviceNumber, FunctionNumber );
			}

			if ( fFindClass && ( Class == (USHORT)PCIRegisters.bBaseClass ) )
			{
				printf ( 
					"\nPCI Device#[%02x] : VendorID [%04x] DeviceID [%04x] : Bus#[%02x] Dev#[%02x] Func#[%01x]\n",
					DeviceCount, PCIRegisters.wVendorID, PCIRegisters.wDeviceID, BusNumber, DeviceNumber, FunctionNumber );

				for ( RegisterIndex = 0 ; RegisterIndex <= PCI_MAX_REGISTERS ; RegisterIndex ++ )
				{
					printf ( "PCI Reg#[%02x] : Offset[%02x] : Value [%08lx]\n",
						RegisterIndex, (RegisterIndex * 4), ((PULONG)&PCIRegisters)[RegisterIndex] );
				}	

			}
		}

		printf ("\n");
		return;
			
	}
	
	

main_usage :
	printf (
	"\ndospci [-vVendorID -dDeviceID] : Print devices matching Vendor & Device ID");

	printf (
	"\ndospci [-vVendorID -dDeviceID] -h : Print only Bus, Device & Function Info");

	printf (
	"\ndospci -bBus# -dDev# -fFunc# -w Register Value : Write to a PCI register");

	printf (
	"\ndospci -cClass	: Find PCI devices for this Base Class Code" );

	printf (
	"\ndospci -a : List all PCI devices on this system");

	printf (
	"\ndospci -i : Get PCI Interrupt Routing options" );
}