[people/ms/u-boot.git] / board / MAI / bios_emulator / scitech / src / pm / tests / uswc.c

/****************************************************************************
*
*                   SciTech OS Portability Manager Library
*
*  ========================================================================
*
*    The contents of this file are subject to the SciTech MGL Public
*    License Version 1.0 (the "License"); you may not use this file
*    except in compliance with the License. You may obtain a copy of
*    the License at http://www.scitechsoft.com/mgl-license.txt
*
*    Software distributed under the License is distributed on an
*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*    implied. See the License for the specific language governing
*    rights and limitations under the License.
*
*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
*
*    The Initial Developer of the Original Code is SciTech Software, Inc.
*    All Rights Reserved.
*
*  ========================================================================
*
* Language:     ANSI C
* Environment:  any
*
* Description:  Simple test program to test the write combine functions.
*
*               Note that this program should never be used in a production
*               environment, because write combining needs to be handled
*               with more intimate knowledge of the display hardware than
*               you can obtain by simply examining the PCI configuration
*               space.
*
****************************************************************************/

#include "pmapi.h"
#include "pcilib.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

/*------------------------- Global Variables ------------------------------*/

static int              NumPCI = -1;
static PCIDeviceInfo    *PCI;
static int              *BridgeIndex;
static int              *DeviceIndex;
static int              NumBridges;
static PCIDeviceInfo    *AGPBridge = NULL;
static int              NumDevices;

/*-------------------------- Implementation -------------------------------*/

/****************************************************************************
RETURNS:
Number of display devices found.

REMARKS:
This function enumerates the number of available display devices on the
PCI bus, and returns the number found.
****************************************************************************/
static int PCI_enumerateDevices(void)
{
    int             i,j;
    PCIDeviceInfo   *info;

    /* If this is the first time we have been called, enumerate all */
    /* devices on the PCI bus. */
    if (NumPCI == -1) {
	if ((NumPCI = PCI_getNumDevices()) == 0)
	    return -1;
	PCI = malloc(NumPCI * sizeof(PCI[0]));
	BridgeIndex = malloc(NumPCI * sizeof(BridgeIndex[0]));
	DeviceIndex = malloc(NumPCI * sizeof(DeviceIndex[0]));
	if (!PCI || !BridgeIndex || !DeviceIndex)
	    return -1;
	for (i = 0; i < NumPCI; i++)
	    PCI[i].dwSize = sizeof(PCI[i]);
	if (PCI_enumerate(PCI) == 0)
	    return -1;

	/* Build a list of all PCI bridge devices */
	for (i = 0,NumBridges = 0,BridgeIndex[0] = -1; i < NumPCI; i++) {
	    if (PCI[i].BaseClass == PCI_BRIDGE_CLASS)
		BridgeIndex[NumBridges++] = i;
	    }

	/* Now build a list of all display class devices */
	for (i = 0,NumDevices = 1,DeviceIndex[0] = -1; i < NumPCI; i++) {
	    if (PCI_IS_DISPLAY_CLASS(&PCI[i])) {
		if ((PCI[i].Command & 0x3) == 0x3)
		    DeviceIndex[0] = i;
		else
		    DeviceIndex[NumDevices++] = i;
		if (PCI[i].slot.p.Bus != 0) {
		    /* This device is on a different bus than the primary */
		    /* PCI bus, so it is probably an AGP device. Find the */
		    /* AGP bus device that controls that bus so we can */
		    /* control it. */
		    for (j = 0; j < NumBridges; j++) {
			info = (PCIDeviceInfo*)&PCI[BridgeIndex[j]];
			if (info->u.type1.SecondayBusNumber == PCI[i].slot.p.Bus) {
			    AGPBridge = info;
			    break;
			    }
			}
		    }
		}
	    }
	}
    return NumDevices;
}

/****************************************************************************
REMARKS:
Enumerates useful information about attached display devices.
****************************************************************************/
static void ShowDisplayDevices(void)
{
    int i,index;

    printf("Displaying enumeration of %d PCI display devices\n", NumDevices);
    printf("\n");
    printf("DeviceID  SubSystem  Base10h  (length  )  Base14h  (length  )\n");
    for (index = 0; index < NumDevices; index++) {
	i = DeviceIndex[index];
	printf("%04X:%04X %04X:%04X  %08lX (%6ld KB) %08lX (%6ld KB)\n",
	    PCI[i].VendorID,
	    PCI[i].DeviceID,
	    PCI[i].u.type0.SubSystemVendorID,
	    PCI[i].u.type0.SubSystemID,
	    PCI[i].u.type0.BaseAddress10,
	    PCI[i].u.type0.BaseAddress10Len / 1024,
	    PCI[i].u.type0.BaseAddress14,
	    PCI[i].u.type0.BaseAddress14Len / 1024);
	}
    printf("\n");
}

/****************************************************************************
REMARKS:
Dumps the value for a write combine region to the display.
****************************************************************************/
static char *DecodeWCType(
    uint type)
{
    static char *names[] = {
	"UNCACHABLE",
	"WRCOMB",
	"UNKNOWN",
	"UNKNOWN",
	"WRTHROUGH",
	"WRPROT",
	"WRBACK",
	};
    if (type <= PM_MTRR_MAX)
	return names[type];
    return "UNKNOWN";
}

/****************************************************************************
REMARKS:
Dumps the value for a write combine region to the display.
****************************************************************************/
static void PMAPI EnumWriteCombine(
    ulong base,
    ulong length,
    uint type)
{
    printf("%08lX %-10ld %s\n", base, length / 1024, DecodeWCType(type));
}

/****************************************************************************
PARAMETERS:
err - Error to log

REMARKS:
Function to log an error message if the MTRR write combining attempt failed.
****************************************************************************/
static void LogMTRRError(
    int err)
{
    if (err == PM_MTRR_ERR_OK)
	return;
    switch (err) {
	case PM_MTRR_NOT_SUPPORTED:
	    printf("Failed: MTRR is not supported by host CPU\n");
	    break;
	case PM_MTRR_ERR_PARAMS:
	    printf("Failed: Invalid parameters passed to PM_enableWriteCombined!\n");
	    break;
	case PM_MTRR_ERR_NOT_4KB_ALIGNED:
	    printf("Failed: Address is not 4Kb aligned!\n");
	    break;
	case PM_MTRR_ERR_BELOW_1MB:
	    printf("Failed: Addresses below 1Mb cannot be write combined!\n");
	    break;
	case PM_MTRR_ERR_NOT_ALIGNED:
	    printf("Failed: Address is not correctly aligned for processor!\n");
	    break;
	case PM_MTRR_ERR_OVERLAP:
	    printf("Failed: Address overlaps an existing region!\n");
	    break;
	case PM_MTRR_ERR_TYPE_MISMATCH:
	    printf("Failed: Adress is contained with existing region, but type is different!\n");
	    break;
	case PM_MTRR_ERR_NONE_FREE:
	    printf("Failed: Out of MTRR registers!\n");
	    break;
	case PM_MTRR_ERR_NOWRCOMB:
	    printf("Failed: This processor does not support write combining!\n");
	    break;
	case PM_MTRR_ERR_NO_OS_SUPPORT:
	    printf("Failed: MTRR is not supported by host OS\n");
	    break;
	default:
	    printf("Failed: UNKNOWN ERROR!\n");
	    break;
	}
    exit(-1);
}

/****************************************************************************
REMARKS:
Shows all write combine regions.
****************************************************************************/
static void ShowWriteCombine(void)
{
    printf("Base     Length(KB) Type\n");
    LogMTRRError(PM_enumWriteCombine(EnumWriteCombine));
    printf("\n");
}

/****************************************************************************
REMARKS:
Dumps the value for a write combine region to the display.
****************************************************************************/
static void EnableWriteCombine(void)
{
    int i,index;

    for (index = 0; index < NumDevices; index++) {
	i = DeviceIndex[index];
	if (PCI[i].u.type0.BaseAddress10 & 0x8) {
	    LogMTRRError(PM_enableWriteCombine(
		PCI[i].u.type0.BaseAddress10 & 0xFFFFFFF0,
		PCI[i].u.type0.BaseAddress10Len,
		PM_MTRR_WRCOMB));
	    }
	if (PCI[i].u.type0.BaseAddress14 & 0x8) {
	    LogMTRRError(PM_enableWriteCombine(
		PCI[i].u.type0.BaseAddress14 & 0xFFFFFFF0,
		PCI[i].u.type0.BaseAddress14Len,
		PM_MTRR_WRCOMB));
	    }
	}
    printf("\n");
    ShowDisplayDevices();
    ShowWriteCombine();
}

/****************************************************************************
REMARKS:
Dumps the value for a write combine region to the display.
****************************************************************************/
static void DisableWriteCombine(void)
{
    int i,index;

    for (index = 0; index < NumDevices; index++) {
	i = DeviceIndex[index];
	if (PCI[i].u.type0.BaseAddress10 & 0x8) {
	    LogMTRRError(PM_enableWriteCombine(
		PCI[i].u.type0.BaseAddress10 & 0xFFFFFFF0,
		PCI[i].u.type0.BaseAddress10Len,
		PM_MTRR_UNCACHABLE));
	    }
	if (PCI[i].u.type0.BaseAddress14 & 0x8) {
	    LogMTRRError(PM_enableWriteCombine(
		PCI[i].u.type0.BaseAddress14 & 0xFFFFFFF0,
		PCI[i].u.type0.BaseAddress14Len,
		PM_MTRR_UNCACHABLE));
	    }
	}
    printf("\n");
    ShowDisplayDevices();
    ShowWriteCombine();
}

int main(int argc,char *argv[])
{
    PM_init();
    if (PCI_enumerateDevices() < 1) {
	printf("No PCI display devices found!\n");
	return -1;
	}
    if (argc < 2) {
	printf("usage: uswc [-show -on -off]\n\n");
	ShowDisplayDevices();
	return -1;
	}
    if (stricmp(argv[1],"-show") == 0)
	ShowWriteCombine();
    else if (stricmp(argv[1],"-on") == 0)
	EnableWriteCombine();
    else if (stricmp(argv[1],"-off") == 0)
	DisableWriteCombine();
    return 0;
}
Commit	Line	Data
c7de829c WD	1	/****************************************************************************
	2	*
	3	* SciTech OS Portability Manager Library
	4	*
	5	* ========================================================================
	6	*
	7	* The contents of this file are subject to the SciTech MGL Public
	8	* License Version 1.0 (the "License"); you may not use this file
	9	* except in compliance with the License. You may obtain a copy of
	10	* the License at http://www.scitechsoft.com/mgl-license.txt
	11	*
	12	* Software distributed under the License is distributed on an
	13	* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	14	* implied. See the License for the specific language governing
	15	* rights and limitations under the License.
	16	*
	17	* The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
	18	*
	19	* The Initial Developer of the Original Code is SciTech Software, Inc.
	20	* All Rights Reserved.
	21	*
	22	* ========================================================================
	23	*
	24	* Language: ANSI C
	25	* Environment: any
	26	*
	27	* Description: Simple test program to test the write combine functions.
	28	*
	29	* Note that this program should never be used in a production
	30	* environment, because write combining needs to be handled
	31	* with more intimate knowledge of the display hardware than
	32	* you can obtain by simply examining the PCI configuration
	33	* space.
	34	*
	35	****************************************************************************/
	36
	37	#include "pmapi.h"
	38	#include "pcilib.h"
	39	#include <stdio.h>
	40	#include <stdlib.h>
	41	#include <string.h>
	42	#include <stdarg.h>
	43
	44	/------------------------- Global Variables ------------------------------/
	45
	46	static int NumPCI = -1;
	47	static PCIDeviceInfo *PCI;
	48	static int *BridgeIndex;
	49	static int *DeviceIndex;
	50	static int NumBridges;
	51	static PCIDeviceInfo *AGPBridge = NULL;
	52	static int NumDevices;
	53
	54	/-------------------------- Implementation -------------------------------/
	55
	56	/****************************************************************************
	57	RETURNS:
	58	Number of display devices found.
	59
	60	REMARKS:
	61	This function enumerates the number of available display devices on the
	62	PCI bus, and returns the number found.
	63	****************************************************************************/
	64	static int PCI_enumerateDevices(void)
65	{
66	int i,j;
67	PCIDeviceInfo *info;
68
8bde7f77 WD	69	/* If this is the first time we have been called, enumerate all */
8bde7f77 WD	70	/* devices on the PCI bus. */
c7de829c	71	if (NumPCI == -1) {
8bde7f77 WD	72	if ((NumPCI = PCI_getNumDevices()) == 0)
	73	return -1;
	74	PCI = malloc(NumPCI * sizeof(PCI[0]));
	75	BridgeIndex = malloc(NumPCI * sizeof(BridgeIndex[0]));
	76	DeviceIndex = malloc(NumPCI * sizeof(DeviceIndex[0]));
	77	if (!PCI \|\| !BridgeIndex \|\| !DeviceIndex)
	78	return -1;
	79	for (i = 0; i < NumPCI; i++)
	80	PCI[i].dwSize = sizeof(PCI[i]);
	81	if (PCI_enumerate(PCI) == 0)
	82	return -1;
c7de829c	83
8bde7f77 WD	84	/* Build a list of all PCI bridge devices */
	85	for (i = 0,NumBridges = 0,BridgeIndex[0] = -1; i < NumPCI; i++) {
	86	if (PCI[i].BaseClass == PCI_BRIDGE_CLASS)
	87	BridgeIndex[NumBridges++] = i;
	88	}
c7de829c	89
8bde7f77 WD	90	/* Now build a list of all display class devices */
	91	for (i = 0,NumDevices = 1,DeviceIndex[0] = -1; i < NumPCI; i++) {
	92	if (PCI_IS_DISPLAY_CLASS(&PCI[i])) {
	93	if ((PCI[i].Command & 0x3) == 0x3)
	94	DeviceIndex[0] = i;
	95	else
	96	DeviceIndex[NumDevices++] = i;
	97	if (PCI[i].slot.p.Bus != 0) {
	98	/* This device is on a different bus than the primary */
	99	/* PCI bus, so it is probably an AGP device. Find the */
	100	/* AGP bus device that controls that bus so we can */
	101	/* control it. */
	102	for (j = 0; j < NumBridges; j++) {
	103	info = (PCIDeviceInfo*)&PCI[BridgeIndex[j]];
	104	if (info->u.type1.SecondayBusNumber == PCI[i].slot.p.Bus) {
	105	AGPBridge = info;
	106	break;
	107	}
	108	}
	109	}
	110	}
	111	}
	112	}
c7de829c WD	113	return NumDevices;
	114	}
	115
	116	/****************************************************************************
	117	REMARKS:
	118	Enumerates useful information about attached display devices.
	119	****************************************************************************/
	120	static void ShowDisplayDevices(void)
	121	{
	122	int i,index;
	123
	124	printf("Displaying enumeration of %d PCI display devices\n", NumDevices);
	125	printf("\n");
	126	printf("DeviceID SubSystem Base10h (length ) Base14h (length )\n");
	127	for (index = 0; index < NumDevices; index++) {
8bde7f77 WD	128	i = DeviceIndex[index];
	129	printf("%04X:%04X %04X:%04X %08lX (%6ld KB) %08lX (%6ld KB)\n",
	130	PCI[i].VendorID,
	131	PCI[i].DeviceID,
	132	PCI[i].u.type0.SubSystemVendorID,
	133	PCI[i].u.type0.SubSystemID,
	134	PCI[i].u.type0.BaseAddress10,
	135	PCI[i].u.type0.BaseAddress10Len / 1024,
	136	PCI[i].u.type0.BaseAddress14,
	137	PCI[i].u.type0.BaseAddress14Len / 1024);
	138	}
c7de829c WD	139	printf("\n");
	140	}
	141
	142	/****************************************************************************
	143	REMARKS:
	144	Dumps the value for a write combine region to the display.
	145	****************************************************************************/
	146	static char *DecodeWCType(
	147	uint type)
	148	{
	149	static char *names[] = {
8bde7f77 WD	150	"UNCACHABLE",
	151	"WRCOMB",
	152	"UNKNOWN",
	153	"UNKNOWN",
	154	"WRTHROUGH",
	155	"WRPROT",
	156	"WRBACK",
	157	};
c7de829c	158	if (type <= PM_MTRR_MAX)
8bde7f77	159	return names[type];
c7de829c WD	160	return "UNKNOWN";
	161	}
	162
	163	/****************************************************************************
	164	REMARKS:
	165	Dumps the value for a write combine region to the display.
	166	****************************************************************************/
	167	static void PMAPI EnumWriteCombine(
	168	ulong base,
	169	ulong length,
	170	uint type)
	171	{
	172	printf("%08lX %-10ld %s\n", base, length / 1024, DecodeWCType(type));
	173	}
	174
	175	/****************************************************************************
	176	PARAMETERS:
	177	err - Error to log
	178
	179	REMARKS:
	180	Function to log an error message if the MTRR write combining attempt failed.
	181	****************************************************************************/
	182	static void LogMTRRError(
	183	int err)
	184	{
	185	if (err == PM_MTRR_ERR_OK)
8bde7f77	186	return;
c7de829c	187	switch (err) {
8bde7f77 WD	188	case PM_MTRR_NOT_SUPPORTED:
	189	printf("Failed: MTRR is not supported by host CPU\n");
	190	break;
	191	case PM_MTRR_ERR_PARAMS:
	192	printf("Failed: Invalid parameters passed to PM_enableWriteCombined!\n");
	193	break;
	194	case PM_MTRR_ERR_NOT_4KB_ALIGNED:
	195	printf("Failed: Address is not 4Kb aligned!\n");
	196	break;
	197	case PM_MTRR_ERR_BELOW_1MB:
	198	printf("Failed: Addresses below 1Mb cannot be write combined!\n");
	199	break;
	200	case PM_MTRR_ERR_NOT_ALIGNED:
	201	printf("Failed: Address is not correctly aligned for processor!\n");
	202	break;
	203	case PM_MTRR_ERR_OVERLAP:
	204	printf("Failed: Address overlaps an existing region!\n");
	205	break;
	206	case PM_MTRR_ERR_TYPE_MISMATCH:
	207	printf("Failed: Adress is contained with existing region, but type is different!\n");
	208	break;
	209	case PM_MTRR_ERR_NONE_FREE:
	210	printf("Failed: Out of MTRR registers!\n");
	211	break;
	212	case PM_MTRR_ERR_NOWRCOMB:
	213	printf("Failed: This processor does not support write combining!\n");
	214	break;
	215	case PM_MTRR_ERR_NO_OS_SUPPORT:
	216	printf("Failed: MTRR is not supported by host OS\n");
	217	break;
	218	default:
	219	printf("Failed: UNKNOWN ERROR!\n");
	220	break;
	221	}
c7de829c WD	222	exit(-1);
	223	}
	224
	225	/****************************************************************************
	226	REMARKS:
	227	Shows all write combine regions.
	228	****************************************************************************/
	229	static void ShowWriteCombine(void)
	230	{
	231	printf("Base Length(KB) Type\n");
	232	LogMTRRError(PM_enumWriteCombine(EnumWriteCombine));
	233	printf("\n");
	234	}
	235
	236	/****************************************************************************
	237	REMARKS:
	238	Dumps the value for a write combine region to the display.
	239	****************************************************************************/
	240	static void EnableWriteCombine(void)
	241	{
	242	int i,index;
	243
	244	for (index = 0; index < NumDevices; index++) {
8bde7f77 WD	245	i = DeviceIndex[index];
	246	if (PCI[i].u.type0.BaseAddress10 & 0x8) {
	247	LogMTRRError(PM_enableWriteCombine(
	248	PCI[i].u.type0.BaseAddress10 & 0xFFFFFFF0,
	249	PCI[i].u.type0.BaseAddress10Len,
	250	PM_MTRR_WRCOMB));
	251	}
	252	if (PCI[i].u.type0.BaseAddress14 & 0x8) {
	253	LogMTRRError(PM_enableWriteCombine(
	254	PCI[i].u.type0.BaseAddress14 & 0xFFFFFFF0,
	255	PCI[i].u.type0.BaseAddress14Len,
	256	PM_MTRR_WRCOMB));
	257	}
	258	}
c7de829c WD	259	printf("\n");
	260	ShowDisplayDevices();
	261	ShowWriteCombine();
	262	}
	263
	264	/****************************************************************************
	265	REMARKS:
	266	Dumps the value for a write combine region to the display.
	267	****************************************************************************/
	268	static void DisableWriteCombine(void)
	269	{
	270	int i,index;
	271
	272	for (index = 0; index < NumDevices; index++) {
8bde7f77 WD	273	i = DeviceIndex[index];
	274	if (PCI[i].u.type0.BaseAddress10 & 0x8) {
	275	LogMTRRError(PM_enableWriteCombine(
	276	PCI[i].u.type0.BaseAddress10 & 0xFFFFFFF0,
	277	PCI[i].u.type0.BaseAddress10Len,
	278	PM_MTRR_UNCACHABLE));
	279	}
	280	if (PCI[i].u.type0.BaseAddress14 & 0x8) {
	281	LogMTRRError(PM_enableWriteCombine(
	282	PCI[i].u.type0.BaseAddress14 & 0xFFFFFFF0,
	283	PCI[i].u.type0.BaseAddress14Len,
	284	PM_MTRR_UNCACHABLE));
	285	}
	286	}
c7de829c WD	287	printf("\n");
	288	ShowDisplayDevices();
	289	ShowWriteCombine();
	290	}
	291
	292	int main(int argc,char *argv[])
	293	{
	294	PM_init();
	295	if (PCI_enumerateDevices() < 1) {
8bde7f77 WD	296	printf("No PCI display devices found!\n");
	297	return -1;
	298	}
c7de829c	299	if (argc < 2) {
8bde7f77 WD	300	printf("usage: uswc [-show -on -off]\n\n");
	301	ShowDisplayDevices();
	302	return -1;
	303	}
c7de829c	304	if (stricmp(argv[1],"-show") == 0)
8bde7f77	305	ShowWriteCombine();
c7de829c	306	else if (stricmp(argv[1],"-on") == 0)
8bde7f77	307	EnableWriteCombine();
c7de829c	308	else if (stricmp(argv[1],"-off") == 0)
8bde7f77	309	DisableWriteCombine();
c7de829c WD	310	return 0;
c7de829c WD	311	}