able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/busdrv/agp/agp460/init.c

380 lines
11 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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;
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);
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.
//
ASSERT(CurrentCap.AGPCommand.RequestQueueDepth <= MasterCap.AGPCommand.RequestQueueDepth);
CurrentCap.AGPCommand.RequestQueueDepth = MasterCap.AGPCommand.RequestQueueDepth;
ASSERT(RtlEqualMemory(&CurrentCap.AGPCommand, &MasterCap.AGPCommand, sizeof(CurrentCap.AGPCommand)));
// Status = AgpLibGetPciDeviceCapability(0,0,&CurrentCap);
Status = AgpLibGetPciDeviceCapability(CBN,AGP460_GXB_SLOT_ID,&CurrentCap);
ASSERT(NT_SUCCESS(Status));
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);
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;
}
Reference in a new issue Copy permalink