able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/busdrv/pccard/pcmcibus/ctlr.c

1339 lines
36 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997-2000 Microsoft Corporation
Module Name:
ctlr.c
Abstract:
This module contains code to support starting and stopping the
pcmcia controller.
Author:
Neil Sandlin (neilsa) 1-Jun-1999
Environment:
Kernel mode
Revision History :
--*/
#include "pch.h"
//
// Internal References
//
NTSTATUS
PcmciaInitializeController(
IN PDEVICE_OBJECT Fdo
);
NTSTATUS
PcmciaGetPciControllerType(
IN PDEVICE_OBJECT Pdo,
IN PDEVICE_OBJECT Fdo
);
NTSTATUS
PcmciaCreateFdo(
IN PDRIVER_OBJECT DriverObject,
OUT PDEVICE_OBJECT *NewDeviceObject
);
BOOLEAN
PcmciaInterrupt(
IN PKINTERRUPT InterruptObject,
IN PVOID Context
);
VOID
PcmciaInterruptDpc(
IN PKDPC Dpc,
IN PDEVICE_OBJECT DeviceObject,
IN PVOID SystemContext1,
IN PVOID SystemContext2
);
VOID
PcmciaTimerDpc(
IN PKDPC Dpc,
IN PDEVICE_OBJECT DeviceObject,
IN PVOID SystemContext1,
IN PVOID SystemContext2
);
VOID
PcmciaDpc(
IN PKDPC Dpc,
IN PDEVICE_OBJECT DeviceObject,
IN PVOID SystemContext1,
IN PVOID SystemContext2
);
PUNICODE_STRING DriverRegistryPath;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, PcmciaAddDevice)
#pragma alloc_text(PAGE, PcmciaCreateFdo)
#pragma alloc_text(PAGE, PcmciaStartPcmciaController)
#pragma alloc_text(PAGE, PcmciaSetControllerType)
#pragma alloc_text(PAGE, PcmciaGetPciControllerType)
#endif
NTSTATUS
PcmciaAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT Pdo
)
/*++
Routine Description:
This routine creates functional device objects for each Pcmcia controller in the
system and attaches them to the physical device objects for the controllers
Arguments:
DriverObject - a pointer to the object for this driver
PhysicalDeviceObject - a pointer to the physical object we need to attach to
Return Value:
Status from device creation and initialization
--*/
{
PDEVICE_OBJECT fdo = NULL;
PDEVICE_OBJECT lowerDevice = NULL;
PFDO_EXTENSION deviceExtension;
ULONG resultLength;
NTSTATUS status;
PAGED_CODE();
DebugPrint((PCMCIA_DEBUG_PNP, "AddDevice Entered with pdo %x\n", Pdo));
if (Pdo == NULL) {
//
// Have we been asked to do detection on our own?
// if so just return no more devices
//
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaAddDevice - asked to do detection\n"));
return STATUS_NO_MORE_ENTRIES;
}
//
// create and initialize the new functional device object
//
status = PcmciaCreateFdo(DriverObject, &fdo);
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaAddDevice - error creating Fdo [%#08lx]\n",
status));
return status;
}
deviceExtension = fdo->DeviceExtension;
KeInitializeTimer(&deviceExtension->EventTimer);
KeInitializeDpc(&deviceExtension->EventDpc, PcmciaDpc, fdo);
KeInitializeTimer(&deviceExtension->PowerTimer);
KeInitializeDpc(&deviceExtension->PowerDpc, PcmciaFdoPowerWorkerDpc, deviceExtension);
InitializeListHead(&deviceExtension->PdoPowerRetryList);
KeInitializeDpc(&deviceExtension->PdoPowerRetryDpc, PcmciaFdoRetryPdoPowerRequest, deviceExtension);
//
// Layer our FDO on top of the PDO
//
//
lowerDevice = IoAttachDeviceToDeviceStack(fdo,Pdo);
//
// No status. Do the best we can.
//
if (lowerDevice == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanupExit;
};
deviceExtension->LowerDevice = lowerDevice;
deviceExtension->Pdo = Pdo;
status = IoGetDeviceProperty(Pdo,
DevicePropertyLegacyBusType,
sizeof(INTERFACE_TYPE),
(PVOID)&deviceExtension->InterfaceType,
&resultLength);
if (!NT_SUCCESS(status)) {
//
// Probably a legacy pcic device
//
deviceExtension->InterfaceType = InterfaceTypeUndefined;
}
//
// Get our controller type
//
deviceExtension->ControllerType = PcmciaInvalidControllerType;
if (deviceExtension->InterfaceType == PCIBus) {
status = PcmciaGetPciControllerType(Pdo, fdo);
if (!NT_SUCCESS(status)) {
goto cleanupExit;
}
} else {
PCMCIA_CONTROLLER_TYPE controllerType;
status = PcmciaGetLegacyDetectedControllerType(deviceExtension->Pdo,
&controllerType);
if (NT_SUCCESS(status)) {
PcmciaSetControllerType(deviceExtension, controllerType);
}
}
//
// Do some cardbus specific initialization
//
if (CardBusExtension(deviceExtension)) {
BOOLEAN OnDebugPath;
ACPI_INTERFACE_STANDARD AcpiInterface;
USHORT word;
//
// Get the pci/cardbus private interface
//
status = PcmciaGetInterface(Pdo,
&GUID_PCI_CARDBUS_INTERFACE_PRIVATE,
sizeof(PCI_CARDBUS_INTERFACE_PRIVATE),
(PINTERFACE) &deviceExtension->PciCardBusInterface
);
if (!NT_SUCCESS(status)) {
goto cleanupExit;
}
status = deviceExtension->PciCardBusInterface.GetLocation(Pdo,
&deviceExtension->PciBusNumber,
&deviceExtension->PciDeviceNumber,
&deviceExtension->PciFunctionNumber,
&OnDebugPath);
if (!NT_SUCCESS(status)) {
goto cleanupExit;
}
if (OnDebugPath) {
SetDeviceFlag(deviceExtension, PCMCIA_FDO_ON_DEBUG_PATH);
}
//
// Get the pci interface for reading/writing to config header space
//
status = PcmciaGetInterface(Pdo,
&GUID_BUS_INTERFACE_STANDARD,
sizeof(BUS_INTERFACE_STANDARD),
(PINTERFACE) &deviceExtension->PciBusInterface);
if (!NT_SUCCESS(status)) {
goto cleanupExit;
}
//
// Make sure IRQ routing is to isa. This has come up when installing from a pcmcia CD-rom.
// What happens is that, after we start booting GUI mode, the controller is at first
// in legacy PCIC mode (set by the bios to accomplish boot). At some point, the _INIT
// method is run, and we switch to cardbus mode. So, under the following conditions:
// 1) irq routing bit is still off
// 2) cd-rom is asserting its interrupt
// 3) host controller routes cd-rom interrupt to PCI
// then we hang.
//
GetPciConfigSpace(deviceExtension, CFGSPACE_BRIDGE_CTRL, &word, 2);
word |= BCTRL_IRQROUTING_ENABLE;
SetPciConfigSpace(deviceExtension, CFGSPACE_BRIDGE_CTRL, &word, 2);
if (!(PcmciaGlobalFlags & PCMCIA_DISABLE_ACPI_NAMESPACE_CHECK)) {
status = PcmciaGetInterface(fdo,
&GUID_ACPI_INTERFACE_STANDARD,
sizeof(ACPI_INTERFACE_STANDARD),
(PINTERFACE) &AcpiInterface
);
if (NT_SUCCESS(status)) {
SetFdoFlag(deviceExtension, PCMCIA_FDO_IN_ACPI_NAMESPACE);
}
}
}
//
// Get settings from registry (potentially also compatible ControllerType)
//
PcmciaGetControllerRegistrySettings(deviceExtension);
if ((deviceExtension->ControllerType == PcmciaInvalidControllerType)) {
//
// not really sure what this is... maybe it's a PNP0E00 on a boot. Just do
// the least common denominator
//
PcmciaSetControllerType(deviceExtension, PcmciaIntelCompatible);
}
//
// Link this fdo to the list of fdo's managed by the driver
//
DebugPrint((PCMCIA_DEBUG_PNP, "FDO %08X now linked to fdolist by AddDevice\n", fdo));
deviceExtension->NextFdo = FdoList;
FdoList = fdo;
fdo->Flags &= ~DO_DEVICE_INITIALIZING;
return STATUS_SUCCESS;
cleanupExit:
MarkDeviceDeleted(deviceExtension);
//
// Cannot support a controller without knowing its type etc.
//
if (deviceExtension->LinkName.Buffer) {
IoDeleteSymbolicLink(&deviceExtension->LinkName);
ExFreePool(deviceExtension->LinkName.Buffer);
}
if (deviceExtension->LowerDevice) {
IoDetachDevice(deviceExtension->LowerDevice);
}
IoDeleteDevice(fdo);
return status;
}
NTSTATUS
PcmciaCreateFdo(
IN PDRIVER_OBJECT DriverObject,
OUT PDEVICE_OBJECT *NewDeviceObject
)
/*++
Routine Description:
This routine will create and initialize a functional device object to
be attached to a Pcmcia controller PDO.
Arguments:
DriverObject - a pointer to the driver object this is created under
DeviceObject - a location to store the pointer to the new device object
Return Value:
STATUS_SUCCESS if everything was successful
reason for failure otherwise
--*/
{
UCHAR deviceNameBuffer[64];
LONG deviceNumber = -1;
ANSI_STRING ansiDeviceName;
UNICODE_STRING unicodeDeviceName;
UNICODE_STRING unicodeLinkName;
PDEVICE_OBJECT deviceObject = NULL;
PFDO_EXTENSION deviceExtension = NULL;
BOOLEAN LinkCreated = FALSE;
ULONG count;
NTSTATUS status=STATUS_SUCCESS;
PAGED_CODE();
//
// Zero out allocated memory pointers so we know if they must be freed
//
RtlZeroMemory(&ansiDeviceName, sizeof(ANSI_STRING));
RtlZeroMemory(&unicodeDeviceName, sizeof(UNICODE_STRING));
RtlZeroMemory(&unicodeLinkName, sizeof(UNICODE_STRING));
//
// Run in a loop incrementing the device number count until we either
// get an error or find a name that's not taken
//
try {
do {
//
// free buffer from previous loop
//
if (unicodeDeviceName.Buffer != NULL) {
RtlFreeUnicodeString(&unicodeDeviceName);
unicodeDeviceName.Buffer = NULL;
}
//
// create the device name
//
sprintf(deviceNameBuffer, "%s%d", PCMCIA_DEVICE_NAME, ++deviceNumber);
RtlInitAnsiString(&ansiDeviceName, deviceNameBuffer);
status = RtlAnsiStringToUnicodeString(
&unicodeDeviceName,
&ansiDeviceName,
TRUE);
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaCreateFdo: Error creating unicode "
"string [%#08lx]\n",
status));
leave;
}
//
// create the device object
//
status = IoCreateDevice(DriverObject,
sizeof(FDO_EXTENSION),
&unicodeDeviceName,
FILE_DEVICE_CONTROLLER,
0L,
FALSE,
&deviceObject);
} while ((status == STATUS_OBJECT_NAME_EXISTS) ||
(status == STATUS_OBJECT_NAME_COLLISION));
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaCreateFdo: Error creating device object "
"[%#08lx]\n",
status));
leave;
}
// Setup symbolic link for VDDs
//
//
// create the link name (reuse the device name buffers for this)
//
sprintf(deviceNameBuffer,"%s%d", PCMCIA_LINK_NAME, deviceNumber);
RtlInitAnsiString(&ansiDeviceName, deviceNameBuffer);
status = RtlAnsiStringToUnicodeString(
&unicodeLinkName,
&ansiDeviceName,
TRUE);
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaCreateFdo: Error creating unicode "
"string [%#08lx]\n",
status));
leave;
}
status = IoCreateSymbolicLink(&unicodeLinkName, &unicodeDeviceName);
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaCreateFdo: Symbolic Link was not created\n"));
leave;
}
LinkCreated = TRUE;
//
// Set up the device extension.
//
deviceExtension = deviceObject->DeviceExtension;
deviceExtension->DeviceObject = deviceObject;
deviceExtension->LinkName = unicodeLinkName;
deviceExtension->RegistryPath = DriverRegistryPath;
deviceExtension->DriverObject = DriverObject;
deviceExtension->DeviceObject = deviceObject;
deviceExtension->PdoList = NULL;
deviceExtension->LivePdoCount = 0;
deviceExtension->Flags = PCMCIA_FDO_OFFLINE;
deviceExtension->WaitWakeState= WAKESTATE_DISARMED;
//
// Lock for synching device access
//
PCMCIA_INITIALIZE_DEVICE_LOCK(deviceExtension);
*NewDeviceObject = deviceObject;
} finally {
DebugPrint((PCMCIA_DEBUG_INFO, "PcmciaCreateFdo: Cleanup\n"));
//
//
// deallocate temporary objects
//
if (unicodeDeviceName.Buffer != NULL) {
RtlFreeUnicodeString(&unicodeDeviceName);
}
//
// destroy objects if there was an error
//
if (!NT_SUCCESS(status)) {
if (LinkCreated) {
IoDeleteSymbolicLink(&unicodeLinkName);
}
if (unicodeLinkName.Buffer != NULL) {
RtlFreeUnicodeString(&unicodeLinkName);
}
if (deviceObject != NULL) {
MarkDeviceDeleted(deviceExtension);
IoDeleteDevice(deviceObject);
}
}
}
return status;
}
NTSTATUS
PcmciaStartPcmciaController(
IN PDEVICE_OBJECT Fdo
)
/*++
Routine Description:
Arguments:
Return value:
--*/
{
PFDO_EXTENSION deviceExtension = Fdo->DeviceExtension;
PSOCKET socket;
BOOLEAN sharedInterrupt;
KINTERRUPT_MODE interruptMode;
NTSTATUS status;
INTERFACE_TYPE interfaceType;
//
// Now the controller registers should be accessible
//
deviceExtension->Flags &= ~PCMCIA_FDO_OFFLINE;
//
// Set up the socket list
//
if (!deviceExtension->SocketList) {
if (CardBusExtension(deviceExtension)) {
status = CBBuildSocketList(deviceExtension);
} else {
switch (deviceExtension->ControllerType) {
case PcmciaIntelCompatible:
case PcmciaElcController:
case PcmciaCLPD6729:
case PcmciaPciPcmciaBridge:
case PcmciaNEC98:
case PcmciaNEC98102: {
status = PcicBuildSocketList(deviceExtension);
break;
}
case PcmciaDatabook: {
status = TcicBuildSocketList(deviceExtension);
break;
}
default:
status = STATUS_UNSUCCESSFUL;
}
}
if (!NT_SUCCESS(status)) {
return status;
}
}
//
// Get the IRQ mask for the controller. This is based on several
// values in the registry.
//
PcmciaGetRegistryFdoIrqMask(deviceExtension);
deviceExtension->SystemPowerState = PowerSystemWorking;
deviceExtension->DevicePowerState = PowerDeviceD0;
//
// Initialize our DpcForIsr
//
IoInitializeDpcRequest(Fdo, PcmciaInterruptDpc);
//
// Initialize socket objects
//
for (socket = deviceExtension->SocketList; socket; socket = socket->NextSocket) {
socket->PdoList = NULL;
//
// Initialize the ready enable event.
//
KeInitializeEvent(&socket->PCCardReadyEvent,
SynchronizationEvent,
FALSE
);
//
// Initialize power objects
//
KeInitializeTimer(&socket->PowerTimer);
KeInitializeDpc(&socket->PowerDpc, PcmciaSocketPowerWorker, socket);
socket->FdoIrq = deviceExtension->Configuration.Interrupt.u.Interrupt.Vector;
}
//
// Assume we are going to poll
//
deviceExtension->Flags |= PCMCIA_USE_POLLED_CSC;
deviceExtension->PcmciaInterruptObject = NULL;
if ((deviceExtension->Configuration.Interrupt.u.Interrupt.Level != 0) &&
CardBusExtension(deviceExtension) &&
!(PcmciaGlobalFlags & PCMCIA_GLOBAL_FORCE_POLL_MODE)) {
//
// Hook up the controller interrupt for detecting pc-card plug ins/outs
//
interruptMode=((deviceExtension->Configuration.Interrupt.Flags & CM_RESOURCE_INTERRUPT_LATCHED) == CM_RESOURCE_INTERRUPT_LATCHED) ? Latched:LevelSensitive;
sharedInterrupt=(deviceExtension->Configuration.Interrupt.ShareDisposition == CmResourceShareShared)?
TRUE:FALSE;
status = IoConnectInterrupt(&(deviceExtension->PcmciaInterruptObject),
(PKSERVICE_ROUTINE) PcmciaInterrupt,
(PVOID) Fdo,
NULL,
deviceExtension->Configuration.TranslatedInterrupt.u.Interrupt.Vector,
(KIRQL) deviceExtension->Configuration.TranslatedInterrupt.u.Interrupt.Level,
(KIRQL) deviceExtension->Configuration.TranslatedInterrupt.u.Interrupt.Level,
interruptMode,
sharedInterrupt,
(KAFFINITY) deviceExtension->Configuration.TranslatedInterrupt.u.Interrupt.Affinity,
FALSE);
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "Unable to connect interrupt\n"));
} else {
//
// We connected. Turn off poll mode
//
deviceExtension->Flags &= ~PCMCIA_USE_POLLED_CSC;
}
}
status = PcmciaInitializeController(Fdo);
if (!NT_SUCCESS(status)) {
DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaStartAdapter: PcmciaInitializeFdo failed\n"));
return status;
}
if (deviceExtension->Flags & PCMCIA_USE_POLLED_CSC) {
LARGE_INTEGER dueTime;
KeInitializeDpc(&deviceExtension->TimerDpc, PcmciaTimerDpc, deviceExtension->DeviceObject);
KeInitializeTimer(&deviceExtension->PollTimer);
//
// Set first fire to twice the peroidic interval - just
//
dueTime.QuadPart = -PCMCIA_CSC_POLL_INTERVAL * 1000 * 10 * 2;
KeSetTimerEx(&(deviceExtension->PollTimer),
dueTime,
PCMCIA_CSC_POLL_INTERVAL,
&deviceExtension->TimerDpc
);
}
return STATUS_SUCCESS;
}
NTSTATUS
PcmciaInitializeController(
IN PDEVICE_OBJECT Fdo
)
/*++
Routine Description:
Initializes the pcmcia controller
Arguments:
Fdo - pointer to the device object for the controller
Return value:
STATUS_SUCCESS - if initialization is successful
--*/
{
PFDO_EXTENSION fdoExtension=Fdo->DeviceExtension;
PSOCKET socket;
NTSTATUS status = STATUS_SUCCESS;
//
// do vendor-specific init of controller
//
if (DeviceDispatchTable[fdoExtension->DeviceDispatchIndex].InitController) {
(*DeviceDispatchTable[fdoExtension->DeviceDispatchIndex].InitController)(fdoExtension);
}
//
// If LegacyIrqMask is not filled in, put a generic mask there in case we need it
//
if (fdoExtension->LegacyIrqMask == 0) {
fdoExtension->LegacyIrqMask = (USHORT)(*(fdoExtension->SocketList->SocketFnPtr->PCBGetIrqMask))(fdoExtension);
}
fdoExtension->LegacyIrqMask &= ~globalFilterIrqMask;
for (socket = fdoExtension->SocketList; socket; socket = socket->NextSocket) {
if (!(*(socket->SocketFnPtr->PCBInitializePcmciaSocket))(socket)) {
status = STATUS_UNSUCCESSFUL;
break;
}
PcmciaGetSocketStatus(socket);
PcmciaSetZV(fdoExtension, socket, FALSE);
ResetSocketFlag(socket, SOCKET_ENABLED_FOR_CARD_DETECT);
if (!(fdoExtension->Flags & PCMCIA_USE_POLLED_CSC) && (socket->FdoIrq != 0)) {
if ((*(socket->SocketFnPtr->PCBEnableDisableCardDetectEvent))(socket, TRUE)) {
//
// card detect event was successfully enabled
//
SetSocketFlag(socket, SOCKET_ENABLED_FOR_CARD_DETECT);
} else {
DebugPrint((PCMCIA_DEBUG_FAIL, "fdo %x failed to enable card detect event on IRQ %x\n",
Fdo, fdoExtension->Configuration.Interrupt.u.Interrupt.Vector));
}
}
}
return status;
}
VOID
PcmciaTimerDpc(
IN PKDPC Dpc,
IN PDEVICE_OBJECT DeviceObject,
IN PVOID SystemContext1,
IN PVOID SystemContext2
)
/*++
Routine Description
This routine polls for card insertions or deletions
for the given PCMCIA controller. If a card status change
condition is detected, it invokes the appropriate DPC
to process the card arrival/departure.
Arguments
Dpc - Pointer to the Dpc object
DeviceObject - Pointer to the FDO of the PCMCIA controller that should be polled
Return Value
None
--*/
{
PFDO_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
PSOCKET socket;
BOOLEAN isCardInSocket, wasCardInSocket, callDpc = FALSE;
if (fdoExtension->Flags & PCMCIA_FDO_OFFLINE) {
return;
}
if (!ValidateController(fdoExtension)) {
//
// Something is wrong with the controller, hopefully it is just
// temporary. For now, do nothing
//
return;
}
for (socket = fdoExtension->SocketList; socket; socket = socket->NextSocket) {
isCardInSocket = (*(socket->SocketFnPtr->PCBDetectCardInSocket))(socket);
wasCardInSocket = IsCardInSocket(socket);
if (isCardInSocket != wasCardInSocket) {
DebugPrint((PCMCIA_DEBUG_INFO, "PcmciaTimerDpc: Setting socket %x change interrupt, cardInSocket=%x Socket->Flags=%x\n", socket, isCardInSocket, socket->Flags));
SetSocketFlag(socket, SOCKET_CHANGE_INTERRUPT);
callDpc = TRUE;
}
}
if (callDpc) {
LARGE_INTEGER dueTime;
KeCancelTimer(&fdoExtension->EventTimer);
dueTime.QuadPart = -((LONG)EventDpcDelay*10);
KeSetTimer(&fdoExtension->EventTimer, dueTime, &fdoExtension->EventDpc);
}
}
BOOLEAN
PcmciaInterrupt(
IN PKINTERRUPT InterruptObject,
PVOID Context
)
/*++
Routine Description:
interrupt handler
Arguments:
InterruptObject - Pointer to the interrupt object.
Context - Pointer to the device context.
Return Value:
Status
--*/
{
PFDO_EXTENSION deviceExtension;
PSOCKET socket;
BOOLEAN statusChanged = FALSE;
deviceExtension=((PDEVICE_OBJECT)Context)->DeviceExtension;
if (deviceExtension->Flags & PCMCIA_FDO_OFFLINE) {
return FALSE;
}
if (!ValidateController(deviceExtension)) {
//
// the controller is broken in some way. Treat like a spurious int
//
ASSERT(FALSE);
return FALSE;
}
//
// Interrupted because of a card removal, or a card insertion.
//
for (socket = deviceExtension->SocketList; socket; socket = socket->NextSocket) {
//
// Check if the card status changed
//
if ((*(socket->SocketFnPtr->PCBDetectCardChanged))(socket)) {
DebugPrint((PCMCIA_DEBUG_ISR, "skt %x card change\n", socket));
if (deviceExtension->DevicePowerState == PowerDeviceD0) {
SetSocketFlag(socket, SOCKET_CHANGE_INTERRUPT);
}
statusChanged = TRUE;
}
socket->ReadyChanged = (*(socket->SocketFnPtr->PCBDetectReadyChanged))(socket);
if (socket->ReadyChanged) {
DebugPrint((PCMCIA_DEBUG_ISR, "skt %x Ready changed\n", socket));
statusChanged = TRUE;
}
//
// Clear card status interrupt, probably leftover from wait/wake
//
if ((socket->SocketFnPtr->PCBDetectCardStatus)) {
(*(socket->SocketFnPtr->PCBDetectCardStatus))(socket);
}
}
if (statusChanged && (deviceExtension->DevicePowerState == PowerDeviceD0)) {
//
// Something changed out there.. could be
// a card insertion/removal.
// Request a DPC to check it out.
//
IoRequestDpc((PDEVICE_OBJECT) Context, NULL, NULL);
}
return statusChanged;
}
VOID
PcmciaInterruptDpc(
IN PKDPC Dpc,
IN PDEVICE_OBJECT DeviceObject,
IN PVOID SystemContext1,
IN PVOID SystemContext2
)
/*++
Routine Description:
This DPC is just an intermediate step in getting to the main DPC
handler. This is used to "debounce" hardware and give it some time after
the physical interrupt has come in.
Arguments:
DeviceObject - Pointer to the device object.
Return Value:
--*/
{
PFDO_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
LARGE_INTEGER dueTime;
KeCancelTimer(&deviceExtension->EventTimer);
dueTime.QuadPart = -((LONG)EventDpcDelay*10);
KeSetTimer(&deviceExtension->EventTimer, dueTime, &deviceExtension->EventDpc);
}
VOID
PcmciaDpc(
IN PKDPC Dpc,
IN PDEVICE_OBJECT DeviceObject,
IN PVOID SystemContext1,
IN PVOID SystemContext2
)
/*++
Routine Description:
This deferred procedure will be called due to a request for DPC
from the interrupt routine. The device object passed contains
information concerning which sockets have changed. Search this
list and free/clean up any sockets that used to have PCCards.
Arguments:
DeviceObject - Pointer to the device object.
Return Value:
--*/
{
PFDO_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
PSOCKET socket;
if (fdoExtension->Flags & PCMCIA_FDO_OFFLINE) {
return;
}
DebugPrint((PCMCIA_DEBUG_DPC, "PcmciaDpc: Card Status Change DPC entered...\n"));
//
// For synchronization with the enumeration & removal
// routines which have a tendency to pop off pdo's
// etc
//
PCMCIA_ACQUIRE_DEVICE_LOCK_AT_DPC_LEVEL(fdoExtension);
for (socket = fdoExtension->SocketList; socket; socket = socket->NextSocket) {
if (socket->ReadyChanged) {
KeSetEvent(&socket->PCCardReadyEvent, 0, FALSE);
}
if (IsSocketFlagSet(socket,SOCKET_CHANGE_INTERRUPT)) {
DebugPrint((PCMCIA_DEBUG_DPC, "PcmciaDpc: Socket %x has SOCKET_CHANGE_INTERRUPT set\n", socket));
//
// This socket has changed status
//
ResetSocketFlag(socket, SOCKET_CHANGE_INTERRUPT);
ResetSocketFlag(socket, SOCKET_SUPPORT_MESSAGE_SENT);
SetSocketFlag(socket, SOCKET_CARD_STATUS_CHANGE);
if ((*(socket->SocketFnPtr->PCBDetectCardInSocket))(socket)) {
SetSocketFlag(socket, SOCKET_INSERTED_SOUND_PENDING);
//
// Assume we have a single function card here.
// This will be corrected by when we parse the tuple data (for an R2 card)
// or PCI returns more than one PDO (for a cardbus card)
//
socket->NumberOfFunctions = 1;
ResetSocketFlag(socket, SOCKET_CARD_MULTIFUNCTION);
//
// If we get a physical plug in, then we better clean up even if we didn't
// get the remove yet.
//
ResetSocketFlag(socket, SOCKET_CLEANUP_PENDING);
ResetSocketFlag(socket, SOCKET_ENUMERATE_PENDING);
} else {
if (IsSocketFlagSet(socket, SOCKET_REMOVED_SOUND_PENDING)) {
ResetSocketFlag(socket, SOCKET_REMOVED_SOUND_PENDING);
PcmciaPlaySound(CARD_REMOVED_SOUND);
}
if (socket->PdoList) {
PPDO_EXTENSION pdoExtension;
PDEVICE_OBJECT pdo, nextPdo;
//
// Mark all the pdo's which hang off this socket (more than one possible only
// if this is a Multifunction PC-Card)
//
for (pdo = socket->PdoList; pdo!=NULL; pdo=nextPdo) {
pdoExtension = pdo->DeviceExtension;
nextPdo = pdoExtension->NextPdoInSocket;
pdoExtension->NextPdoInSocket = NULL;
MarkDevicePhysicallyRemoved(pdoExtension);
}
socket->PdoList = NULL;
}
//
// Hack for Topic95 controllers staying in 3.3v
//
if (fdoExtension->ControllerType == PcmciaTopic95) {
ULONG state = CBReadSocketRegister(socket, CARDBUS_SOCKET_PRESENT_STATE_REG);
if ((state & CARDBUS_CB_CARD) && !(state & (CARDBUS_CD1 | CARDBUS_CD2))) {
state &= ~(SKTFORCE_CBCARD | SKTFORCE_3VCARD);
CBWriteSocketRegister(socket, CARDBUS_SOCKET_FORCE_EVENT_REG, state);
}
}
//
// Clear power requirements
//
socket->Vcc = socket->Vpp1 = socket->Vpp2 = 0;
//
// Make sure i/o arbiter is not hanging on the devnode
//
if (CardBusExtension(fdoExtension)) {
IoInvalidateDeviceState(fdoExtension->Pdo);
}
}
}
}
PCMCIA_RELEASE_DEVICE_LOCK_FROM_DPC_LEVEL(fdoExtension);
IoInvalidateDeviceRelations(fdoExtension->Pdo, BusRelations);
return;
}
VOID
PcmciaSetControllerType(
IN PFDO_EXTENSION FdoExtension,
IN PCMCIA_CONTROLLER_TYPE ControllerType
)
/*++
Routine Description
This routine does the housekeeping for setting the controller type,
and the corresponding device index.
Arguments
FdoExtension - Pointer to device extension for the pcmcia controller
ControllerType - new controller type to set into the extension
Return Value
None. Must succeed.
--*/
{
PCMCIA_CONTROLLER_CLASS ctlClass;
ULONG index;
FdoExtension->ControllerType = ControllerType;
ctlClass = PcmciaClassFromControllerType(FdoExtension->ControllerType);
//
// first assume cardbus
//
MarkDeviceCardBus(FdoExtension);
switch(ctlClass) {
case PcmciaIntelCompatible:
case PcmciaPciPcmciaBridge:
case PcmciaElcController:
case PcmciaDatabook:
case PcmciaNEC_98:
MarkDevice16Bit(FdoExtension);
break;
case PcmciaCirrusLogic:
if (ControllerType == PcmciaCLPD6729) {
MarkDevice16Bit(FdoExtension);
}
break;
}
//
// Look up the device in our dispatch table
//
for (index = 0; DeviceDispatchTable[index].ControllerClass != PcmciaInvalidControllerClass; index++) {
if (DeviceDispatchTable[index].ControllerClass == ctlClass) {
FdoExtension->DeviceDispatchIndex = index;
break;
}
}
FdoExtension->Flags &= ~PCMCIA_MEMORY_24BIT;
if (!HasWindowPageRegister(FdoExtension)) {
FdoExtension->Flags |= PCMCIA_MEMORY_24BIT;
}
if ((FdoExtension->InterfaceType == InterfaceTypeUndefined) ||
(FdoExtension->InterfaceType == Isa)) {
FdoExtension->Flags |= PCMCIA_MEMORY_24BIT;
}
switch(ControllerType) {
case PcmciaTI1031:
case PcmciaTI1130:
//
// restrict memory ranges for PDO's to 24bit
// (because of missing "window page" functionality).
//
FdoExtension->Flags |= PCMCIA_MEMORY_24BIT;
break;
}
DebugPrint((PCMCIA_DEBUG_INFO, "fdo %08x Controller Type %x\n",
FdoExtension->DeviceObject, ControllerType));
}
NTSTATUS
PcmciaGetPciControllerType(
IN PDEVICE_OBJECT Pdo,
IN PDEVICE_OBJECT Fdo
)
/*++
Routine Description:
Look at the PCI hardware ID to see if it is already a device we know about. If so,
set the appropriate controller type in the fdoExtension.
Arguments:
Pdo - Physical Device object for the Pcmcia controller owned by the PCI driver
Fdo - Functional Device object for the pcmcia controller owned by this driver, whose
extension will store the relevant controller information upon exit from this routine.
Return Value:
STATUS_SUCCESS Things are fine and information obtained
STATUS_NOT_SUPPORTED This is actually a healthy status for this routine: all it means
is that this PDO is not on a PCI bus, so no information needs to be
obtained anyways.
Any other status Failure. Caller probably needs to back out & not support this controller
--*/
{
PFDO_EXTENSION fdoExtension = Fdo->DeviceExtension;
PIRP irp;
IO_STATUS_BLOCK statusBlock;
PIO_STACK_LOCATION irpSp;
PCI_COMMON_CONFIG pciConfig;
PPCI_CONTROLLER_INFORMATION id;
PPCI_VENDOR_INFORMATION vid;
KEVENT event;
NTSTATUS status;
BOOLEAN foundController = FALSE;
PAGED_CODE();
//
// Allocate & initialize an Irp (IRP_MN_READ_CONFIG) to be sent down
// to the PCI bus driver to get config. header for this controller
//
// Following is all standard stuff to send an IRP down - needs no documentation
//
// Fresh PDO. No need to jump through hoops to get attached devices
//
KeInitializeEvent (&event, NotificationEvent, FALSE);
irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP,
Pdo,
NULL,
0,
0,
&event,
&statusBlock
);
if (irp == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
irp->IoStatus.Information = 0;
irpSp = IoGetNextIrpStackLocation(irp);
irpSp->MinorFunction = IRP_MN_READ_CONFIG;
irpSp->Parameters.ReadWriteConfig.WhichSpace = PCI_WHICHSPACE_CONFIG;
irpSp->Parameters.ReadWriteConfig.Buffer = &pciConfig;
irpSp->Parameters.ReadWriteConfig.Offset = 0;
irpSp->Parameters.ReadWriteConfig.Length = sizeof(pciConfig);
status = IoCallDriver(Pdo, irp);
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = statusBlock.Status;
}
if (!NT_SUCCESS(status)) {
return status;
}
//
// Now weed out the critical information from the config header and
// store it away in the fdo's extension
//
if (pciConfig.SubClass == PCI_SUBCLASS_BR_PCMCIA) {
PcmciaSetControllerType(fdoExtension, PcmciaPciPcmciaBridge);
} else if (pciConfig.SubClass == PCI_SUBCLASS_BR_CARDBUS) {
PcmciaSetControllerType(fdoExtension, PcmciaCardBusCompatible);
} else {
//
// Unknown controller
//
return STATUS_UNSUCCESSFUL;
}
//
// Look up the PCI device id in our table
//
for (id = (PPCI_CONTROLLER_INFORMATION) PciControllerInformation;id->VendorID != PCI_INVALID_VENDORID; id++) {
if ((id->VendorID == pciConfig.VendorID) && (id->DeviceID == pciConfig.DeviceID)) {
PcmciaSetControllerType(fdoExtension, id->ControllerType);
foundController = TRUE;
break;
}
}
//
// Didn't find a specific vendor/device id, try to just base it on the vendor id
//
if (!foundController) {
for (vid = (PPCI_VENDOR_INFORMATION) PciVendorInformation;vid->VendorID != PCI_INVALID_VENDORID; vid++) {
if (vid->VendorID == pciConfig.VendorID) {
PcmciaSetControllerType(fdoExtension, vid->ControllerClass);
break;
}
}
}
return STATUS_SUCCESS;
}
Reference in a new issue Copy permalink