You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
379 lines
12 KiB
379 lines
12 KiB
/*++
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
init.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the initialization code for AGP460.SYS.
|
|
|
|
Author:
|
|
|
|
Naga Gurumoorthy 6/11/1999
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "agp460.h"
|
|
|
|
ULONG AgpExtensionSize = sizeof(AGP460_EXTENSION);
|
|
PAGP_FLUSH_PAGES AgpFlushPages;
|
|
|
|
|
|
NTSTATUS
|
|
AgpInitializeTarget(
|
|
IN PVOID AgpExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Entrypoint for target initialization. This is called first.
|
|
|
|
Arguments:
|
|
|
|
AgpExtension - Supplies the AGP extension
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG DeviceVendorID = 0;
|
|
PAGP460_EXTENSION Extension = AgpExtension;
|
|
|
|
AGPLOG(AGP_NOISE, ("AGP460: AgpInitializeTarget entered.\n"));
|
|
|
|
//
|
|
// Initialize our Extension
|
|
//
|
|
RtlZeroMemory(Extension, sizeof(AGP460_EXTENSION));
|
|
|
|
|
|
//
|
|
// TO DO: Check the Device & Vendor ID for 82460GX. - Naga G
|
|
//
|
|
|
|
//
|
|
// Initialize our chipset-specific extension
|
|
//
|
|
Extension->ApertureStart.QuadPart = 0;
|
|
Extension->ApertureLength = 0;
|
|
Extension->Gart = NULL;
|
|
Extension->GartLength = 0;
|
|
Extension->GlobalEnable = FALSE;
|
|
Extension->ChipsetPageSize = PAGESIZE_460GX_CHIPSET;
|
|
Extension->GartPhysical.QuadPart = 0;
|
|
Extension->bSupportMultipleAGPDevices = FALSE;
|
|
Extension->bSupportsCacheCoherency = TRUE;
|
|
Extension->SpecialTarget = 0;
|
|
|
|
AgpFlushPages = Agp460FlushPages;
|
|
|
|
AGPLOG(AGP_NOISE, ("AGP460: Leaving AgpInitializeTarget.\n"));
|
|
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
AgpInitializeMaster(
|
|
IN PVOID AgpExtension,
|
|
OUT ULONG *AgpCapabilities
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Entrypoint for master initialization. This is called after target initialization
|
|
and should be used to initialize the AGP capabilities of both master and target.
|
|
|
|
This is also called when the master transitions into the D0 state.
|
|
|
|
Arguments:
|
|
|
|
AgpExtension - Supplies the AGP extension
|
|
|
|
AgpCapabilities - Returns the capabilities of this AGP device.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
PCI_AGP_CAPABILITY MasterCap;
|
|
PCI_AGP_CAPABILITY TargetCap;
|
|
PAGP460_EXTENSION Extension = AgpExtension;
|
|
ULONG SBAEnable;
|
|
ULONG DataRate;
|
|
ULONG FastWrite;
|
|
ULONG CBN;
|
|
BOOLEAN ReverseInit;
|
|
|
|
#if DBG
|
|
PCI_AGP_CAPABILITY CurrentCap;
|
|
#endif
|
|
|
|
AGPLOG(AGP_NOISE, ("AGP460: AgpInitializeMaster entered.\n"));
|
|
|
|
//
|
|
// VERY IMPORTANT: In 82460GX, the GART is not part of the main memory (though it
|
|
// occupies a range in the address space) and is instead hanging off the GXB. This
|
|
// will make accesses from the Graphics Card to the GART pretty fast. But, the price
|
|
// we pay - processor can't access the GART. Therefore, we tell the rest of the
|
|
// world that is NOT OK to map the physical addresses given by GART. Instead processor
|
|
// accesses should use the MDL. This is done by setting the capabilities to 0.
|
|
// - Naga G
|
|
//
|
|
*AgpCapabilities = 0;
|
|
|
|
//
|
|
// Get the master and target AGP capabilities
|
|
//
|
|
Status = AgpLibGetMasterCapability(AgpExtension, &MasterCap);
|
|
if (!NT_SUCCESS(Status)) {
|
|
AGPLOG(AGP_CRITICAL,
|
|
("AGP460InitializeDevice - AgpLibGetMasterCapability failed %08lx\n"));
|
|
return(Status);
|
|
}
|
|
|
|
//
|
|
// Some broken cards (Matrox Millenium II "AGP") report no valid
|
|
// supported transfer rates. These are not really AGP cards. They
|
|
// have an AGP Capabilities structure that reports no capabilities.
|
|
//
|
|
if (MasterCap.AGPStatus.Rate == 0) {
|
|
AGPLOG(AGP_CRITICAL,
|
|
("AGP460InitializeDevice - AgpLibGetMasterCapability returned no valid transfer rate\n"));
|
|
return(STATUS_INVALID_DEVICE_REQUEST);
|
|
}
|
|
|
|
// We can't get the capability for bus 0, dev 0 in 460GX. it is the SAC & we want the
|
|
// GXB (Target).
|
|
//Status = AgpLibGetPciDeviceCapability(0,0,&TargetCap);
|
|
|
|
Read460CBN((PVOID)&CBN);
|
|
// CBN is of one byte width, so zero out the other bits from 32-bits - Sunil
|
|
EXTRACT_LSBYTE(CBN);
|
|
|
|
Status = AgpLibGetPciDeviceCapability(CBN,AGP460_GXB_SLOT_ID,&TargetCap);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
AGPLOG(AGP_CRITICAL,
|
|
("AGP460InitializeDevice - AgpLibGetPciDeviceCapability failed %08lx\n"));
|
|
return(Status);
|
|
}
|
|
|
|
//
|
|
// Determine the greatest common denominator for data rate.
|
|
//
|
|
DataRate = TargetCap.AGPStatus.Rate & MasterCap.AGPStatus.Rate;
|
|
|
|
AGP_ASSERT(DataRate != 0);
|
|
|
|
//
|
|
// Select the highest common rate.
|
|
//
|
|
if (DataRate & PCI_AGP_RATE_4X) {
|
|
DataRate = PCI_AGP_RATE_4X;
|
|
} else if (DataRate & PCI_AGP_RATE_2X) {
|
|
DataRate = PCI_AGP_RATE_2X;
|
|
} else if (DataRate & PCI_AGP_RATE_1X) {
|
|
DataRate = PCI_AGP_RATE_1X;
|
|
}
|
|
|
|
//
|
|
// Previously a call was made to change the rate (successfully),
|
|
// use this rate again now
|
|
//
|
|
if (Extension->SpecialTarget & AGP_FLAG_SPECIAL_RESERVE) {
|
|
DataRate = (ULONG)((Extension->SpecialTarget &
|
|
AGP_FLAG_SPECIAL_RESERVE) >>
|
|
AGP_FLAG_SET_RATE_SHIFT);
|
|
}
|
|
|
|
//
|
|
// Enable SBA if both master and target support it.
|
|
//
|
|
SBAEnable = (TargetCap.AGPStatus.SideBandAddressing & MasterCap.AGPStatus.SideBandAddressing);
|
|
|
|
//
|
|
// Enable FastWrite if both master and target support it.
|
|
//
|
|
FastWrite = (TargetCap.AGPStatus.FastWrite & MasterCap.AGPStatus.FastWrite);
|
|
|
|
//
|
|
// Enable the Master first.
|
|
//
|
|
ReverseInit =
|
|
(Extension->SpecialTarget & AGP_FLAG_REVERSE_INITIALIZATION) ==
|
|
AGP_FLAG_REVERSE_INITIALIZATION;
|
|
if (ReverseInit) {
|
|
MasterCap.AGPCommand.Rate = DataRate;
|
|
MasterCap.AGPCommand.AGPEnable = TRUE;
|
|
MasterCap.AGPCommand.SBAEnable = SBAEnable;
|
|
MasterCap.AGPCommand.FastWriteEnable = FastWrite;
|
|
MasterCap.AGPCommand.FourGBEnable = FALSE;
|
|
MasterCap.AGPCommand.RequestQueueDepth = TargetCap.AGPStatus.RequestQueueDepthMaximum;
|
|
|
|
Status = AgpLibSetMasterCapability(AgpExtension, &MasterCap);
|
|
if (!NT_SUCCESS(Status)) {
|
|
AGPLOG(AGP_CRITICAL,
|
|
("AGP460InitializeDevice - AgpLibSetMasterCapability %08lx failed %08lx\n",
|
|
&MasterCap,
|
|
Status));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now enable the Target.
|
|
//
|
|
TargetCap.AGPCommand.Rate = DataRate;
|
|
TargetCap.AGPCommand.AGPEnable = TRUE;
|
|
TargetCap.AGPCommand.SBAEnable = SBAEnable;
|
|
TargetCap.AGPCommand.FastWriteEnable = FastWrite;
|
|
TargetCap.AGPCommand.FourGBEnable = FALSE;
|
|
|
|
Status = AgpLibSetPciDeviceCapability(CBN, AGP460_GXB_SLOT_ID, &TargetCap);
|
|
if (!NT_SUCCESS(Status)) {
|
|
AGPLOG(AGP_CRITICAL,
|
|
("AGP460InitializeDevice - AgpLibSetPciDeviceCapability %08lx for target failed %08lx\n",
|
|
&TargetCap,
|
|
Status));
|
|
return(Status);
|
|
}
|
|
|
|
if (!ReverseInit) {
|
|
MasterCap.AGPCommand.Rate = DataRate;
|
|
MasterCap.AGPCommand.AGPEnable = TRUE;
|
|
MasterCap.AGPCommand.SBAEnable = SBAEnable;
|
|
MasterCap.AGPCommand.FastWriteEnable = FastWrite;
|
|
MasterCap.AGPCommand.FourGBEnable = FALSE;
|
|
MasterCap.AGPCommand.RequestQueueDepth = TargetCap.AGPStatus.RequestQueueDepthMaximum;
|
|
|
|
Status = AgpLibSetMasterCapability(AgpExtension, &MasterCap);
|
|
if (!NT_SUCCESS(Status)) {
|
|
AGPLOG(AGP_CRITICAL,
|
|
("AGP460InitializeDevice - AgpLibSetMasterCapability %08lx failed %08lx\n",
|
|
&MasterCap,
|
|
Status));
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
//
|
|
// Read them back, see if it worked
|
|
//
|
|
Status = AgpLibGetMasterCapability(AgpExtension, &CurrentCap);
|
|
AGP_ASSERT(NT_SUCCESS(Status));
|
|
|
|
//
|
|
// If the target request queue depth is greater than the master will
|
|
// allow, it will be trimmed. Loosen the assert to not require an
|
|
// exact match.
|
|
//
|
|
AGP_ASSERT(CurrentCap.AGPCommand.RequestQueueDepth <= MasterCap.AGPCommand.RequestQueueDepth);
|
|
CurrentCap.AGPCommand.RequestQueueDepth = MasterCap.AGPCommand.RequestQueueDepth;
|
|
AGP_ASSERT(RtlEqualMemory(&CurrentCap.AGPCommand, &MasterCap.AGPCommand, sizeof(CurrentCap.AGPCommand)));
|
|
|
|
// Status = AgpLibGetPciDeviceCapability(0,0,&CurrentCap);
|
|
Status = AgpLibGetPciDeviceCapability(CBN,AGP460_GXB_SLOT_ID,&CurrentCap);
|
|
|
|
AGP_ASSERT(NT_SUCCESS(Status));
|
|
AGP_ASSERT(RtlEqualMemory(&CurrentCap.AGPCommand, &TargetCap.AGPCommand, sizeof(CurrentCap.AGPCommand)));
|
|
|
|
#endif
|
|
|
|
AGPLOG(AGP_NOISE, ("AGP460: Leaving AgpInitializeMaster.\n"));
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
Agp460FlushPages(
|
|
IN PAGP460_EXTENSION AgpContext,
|
|
IN PMDL Mdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Flush entries in the GART. Currently a stub for
|
|
Win64 version of 460GX filter driver. This flushing is done previously to
|
|
avoid any caching issues due to the same memory aliased with different caching
|
|
attributes. Now that is taken care by the memory manager calls themselves (Win64 only).
|
|
Therefore we just have a stub so that nothing gets executed in the AGPLIB code. (see
|
|
AGPLIB code for details)
|
|
|
|
Arguments:
|
|
|
|
AgpContext - Supplies the AGP context
|
|
|
|
Mdl - Supplies the MDL describing the physical pages to be flushed
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
AGPLOG(AGP_NOISE, ("AGP460: Entering AGPFlushPages.\n"));
|
|
AGPLOG(AGP_NOISE, ("AGP460: Leaving AGPFlushPages.\n"));
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
void Read460CBN(PVOID _CBN_)
|
|
{
|
|
ULONG _len_;
|
|
_len_ = HalGetBusDataByOffset(PCIConfiguration,
|
|
AGP460_SAC_BUS_ID,
|
|
AGP460_SAC_CBN_SLOT_ID,
|
|
_CBN_,
|
|
0x40,
|
|
1);
|
|
AGP_ASSERT(_len_ == 1);
|
|
return;
|
|
}
|
|
|
|
|
|
void Read460Config(ULONG _CBN_,PVOID _buf_,ULONG _offset_,ULONG _size_)
|
|
{
|
|
ULONG _len_;
|
|
_len_ = HalGetBusDataByOffset(PCIConfiguration,
|
|
_CBN_,
|
|
AGP460_GXB_SLOT_ID,
|
|
_buf_,
|
|
_offset_,
|
|
_size_);
|
|
ASSERT(_len_ == (_size_));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void Write460Config(ULONG _CBN_,PVOID _buf_,ULONG _offset_,ULONG _size_)
|
|
{
|
|
ULONG _len_;
|
|
_len_ = HalSetBusDataByOffset(PCIConfiguration,
|
|
(_CBN_),
|
|
AGP460_GXB_SLOT_ID,
|
|
(_buf_),
|
|
(_offset_),
|
|
(_size_));
|
|
ASSERT(_len_ == (_size_));
|
|
return;
|
|
}
|
|
|