NTSTATUS
SoundGetBusNumber(
IN OUT INTERFACE_TYPE InterfaceType,
OUT PULONG BusNumber
)
/*++
Routine Description :
Find the bus of the type we are looking for - and hope this is
the one with our card on! Actually if bus is not
bus number 0 we fail.
Arguments :
BusNumber - Where to put the answer
Return Value :
NT status code - STATUS_SUCCESS if no problems
--*/
{
ULONG TestBusNumber = 0;
NTSTATUS Status;
BOOLEAN Ok = FALSE; // Must match type passed by reference to
// SoundConfigurationCallout by
// IoQueryDeviceDescription.
//
// See if our bus type exists by calling IoQueryDeviceDescription
//
Status = IoQueryDeviceDescription(
&InterfaceType,
&TestBusNumber,
NULL,
NULL,
NULL,
NULL,
SoundConfigurationCallout,
(PVOID)&Ok);
if (Ok) {
*BusNumber = TestBusNumber;
}
return Ok ? STATUS_SUCCESS : STATUS_DEVICE_DOES_NOT_EXIST;
}
NTSTATUS FindParallelPort()
{
NTSTATUS status;
for( int BusType=0; BusType<MaximumInterfaceType; BusType++)
{
INTERFACE_TYPE iBusType = (INTERFACE_TYPE)BusType;
CONFIGURATION_TYPE CtrlrType = ParallelController;
ULONG BusNumber = 0;
while(true)
{
// See if this bus instance exists
status = IoQueryDeviceDescription(
&iBusType, &BusNumber,
NULL, NULL,
NULL, NULL,
AbcConfigCallback, NULL);
if( !NT_SUCCESS(status))
{
if( status != STATUS_OBJECT_NAME_NOT_FOUND)
return status;
break;
}
// See what printers exist on this bus instance
status = IoQueryDeviceDescription(
&iBusType, &BusNumber,
&CtrlrType, NULL,
NULL, NULL,
AbcConfigCallback, NULL);
if( !NT_SUCCESS(status) &&
(status != STATUS_OBJECT_NAME_NOT_FOUND))
return status;
BusNumber++;
}
}
return status;
}
NTSTATUS
SoundGetRegistryInformation(
OUT PCONFIG_CONTROLLER_DATA *ConfigData
)
/*++
Routine Description:
This routine is called by DriverEntry() to get information about the
devices to be supported from configuration mangement and/or the
hardware architecture layer (HAL).
Arguments:
ConfigData - a pointer to the pointer to a data structure that
describes the controllers and the drives attached to them
Return Value:
Returns STATUS_SUCCESS unless there is no drive 0 or we didn't get
any configuration information.
--*/
{
INTERFACE_TYPE InterfaceType;
NTSTATUS Status;
ULONG i;
CONFIGURATION_TYPE Dc;
CONFIGURATION_TYPE Fp;
*ConfigData = ExAllocatePool(
PagedPool,
sizeof(CONFIG_CONTROLLER_DATA)
);
if (!*ConfigData) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Zero out the config structure and fill in the actual
// controller numbers with -1's so that the callback routine
// can recognize a new controller.
//
RtlZeroMemory(
*ConfigData,
sizeof(CONFIG_CONTROLLER_DATA)
);
// Check ONLY Internal bus types.
// This Driver controlls audio controller that is on Internal
// bus.
InterfaceType = Internal;
Dc = AudioController;
Status = IoQueryDeviceDescription(
&InterfaceType,
NULL,
&Dc,
NULL,
NULL,
NULL,
SoundConfigCallBack,
*ConfigData
);
if (!NT_SUCCESS(Status) && (Status != STATUS_OBJECT_NAME_NOT_FOUND)) {
ExFreePool(*ConfigData);
*ConfigData = NULL;
return Status;
}
return STATUS_SUCCESS;
}
static BOOLEAN NTAPI
AddControllers(PDRIVER_OBJECT DriverObject)
/*
* FUNCTION: Called on initialization to find our controllers and build device and controller objects for them
* ARGUMENTS:
* DriverObject: Our driver's DriverObject (so we can create devices against it)
* RETURNS:
* FALSE if we can't allocate a device, adapter, or interrupt object, or if we fail to find any controllers
* TRUE otherwise (i.e. we have at least one fully-configured controller)
* NOTES:
* - Currently we only support ISA buses.
* - BUG: Windows 2000 seems to clobber the response from the IoQueryDeviceDescription callback, so now we
* just test a boolean value in the first object to see if it was completely populated. The same value
* is tested for each controller before we build device objects for it.
* TODO:
* - Report resource usage to the HAL
*/
{
INTERFACE_TYPE InterfaceType = Isa;
CONFIGURATION_TYPE ControllerType = DiskController;
CONFIGURATION_TYPE PeripheralType = FloppyDiskPeripheral;
KAFFINITY Affinity;
DEVICE_DESCRIPTION DeviceDescription;
UCHAR i;
UCHAR j;
PAGED_CODE();
/* Find our controllers on all ISA buses */
IoQueryDeviceDescription(&InterfaceType, 0, &ControllerType, 0, &PeripheralType, 0, ConfigCallback, 0);
/*
* w2k breaks the return val from ConfigCallback, so we have to hack around it, rather than just
* looking for a return value from ConfigCallback. We expect at least one controller.
*/
if(!gControllerInfo[0].Populated)
{
WARN_(FLOPPY, "AddControllers: failed to get controller info from registry\n");
return FALSE;
}
/* Now that we have a controller, set it up with the system */
for(i = 0; i < gNumberOfControllers; i++)
{
/* 0: Report resource usage to the kernel, to make sure they aren't assigned to anyone else */
/* FIXME: Implement me. */
/* 1: Set up interrupt */
gControllerInfo[i].MappedVector = HalGetInterruptVector(gControllerInfo[i].InterfaceType, gControllerInfo[i].BusNumber,
gControllerInfo[i].Level, gControllerInfo[i].Vector,
&gControllerInfo[i].MappedLevel, &Affinity);
/* Must set up the DPC before we connect the interrupt */
KeInitializeDpc(&gControllerInfo[i].Dpc, DpcForIsr, &gControllerInfo[i]);
INFO_(FLOPPY, "Connecting interrupt %d to controller%d (object 0x%p)\n", gControllerInfo[i].MappedVector,
i, &gControllerInfo[i]);
/* NOTE: We cannot share our interrupt, even on level-triggered buses. See Isr() for details. */
if(IoConnectInterrupt(&gControllerInfo[i].InterruptObject, Isr, &gControllerInfo[i], 0, gControllerInfo[i].MappedVector,
gControllerInfo[i].MappedLevel, gControllerInfo[i].MappedLevel, gControllerInfo[i].InterruptMode,
FALSE, Affinity, 0) != STATUS_SUCCESS)
{
WARN_(FLOPPY, "AddControllers: unable to connect interrupt\n");
continue;
}
/* 2: Set up DMA */
memset(&DeviceDescription, 0, sizeof(DeviceDescription));
DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
DeviceDescription.DmaChannel = gControllerInfo[i].Dma;
DeviceDescription.InterfaceType = gControllerInfo[i].InterfaceType;
DeviceDescription.BusNumber = gControllerInfo[i].BusNumber;
DeviceDescription.MaximumLength = 2*18*512; /* based on a 1.44MB floppy */
/* DMA 0,1,2,3 are 8-bit; 4,5,6,7 are 16-bit (4 is chain i think) */
DeviceDescription.DmaWidth = gControllerInfo[i].Dma > 3 ? Width16Bits: Width8Bits;
gControllerInfo[i].AdapterObject = HalGetAdapter(&DeviceDescription, &gControllerInfo[i].MapRegisters);
if(!gControllerInfo[i].AdapterObject)
{
WARN_(FLOPPY, "AddControllers: unable to allocate an adapter object\n");
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
continue;
}
/* 2b: Initialize the new controller */
if(InitController(&gControllerInfo[i]) != STATUS_SUCCESS)
{
WARN_(FLOPPY, "AddControllers(): Unable to set up controller %d - initialization failed\n", i);
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
continue;
}
/* 2c: Set the controller's initlized flag so we know to release stuff in Unload */
gControllerInfo[i].Initialized = TRUE;
/* 3: per-drive setup */
for(j = 0; j < gControllerInfo[i].NumberOfDrives; j++)
{
WCHAR DeviceNameBuf[MAX_DEVICE_NAME];
UNICODE_STRING DeviceName;
UNICODE_STRING LinkName;
UNICODE_STRING ArcPath;
UCHAR DriveNumber;
INFO_(FLOPPY, "AddControllers(): Configuring drive %d on controller %d\n", i, j);
/*
* 3a: create a device object for the drive
* Controllers and drives are 0-based, so the combos are:
* 0: 0,0
* 1: 0,1
* 2: 0,2
* 3: 0,3
* 4: 1,0
* 5: 1,1
* ...
* 14: 3,2
* 15: 3,3
*/
DriveNumber = (UCHAR)(i*4 + j); /* loss of precision is OK; there are only 16 of 'em */
RtlZeroMemory(&DeviceNameBuf, MAX_DEVICE_NAME * sizeof(WCHAR));
swprintf(DeviceNameBuf, L"\\Device\\Floppy%d", DriveNumber);
RtlInitUnicodeString(&DeviceName, DeviceNameBuf);
if(IoCreateDevice(DriverObject, sizeof(PVOID), &DeviceName,
FILE_DEVICE_DISK, FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE, FALSE,
&gControllerInfo[i].DriveInfo[j].DeviceObject) != STATUS_SUCCESS)
{
WARN_(FLOPPY, "AddControllers: unable to register a Device object\n");
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
continue; /* continue on to next drive */
}
INFO_(FLOPPY, "AddControllers: New device: %S (0x%p)\n", DeviceNameBuf, gControllerInfo[i].DriveInfo[j].DeviceObject);
/* 3b.5: Create an ARC path in case we're booting from this drive */
swprintf(gControllerInfo[i].DriveInfo[j].ArcPathBuffer,
L"\\ArcName\\multi(%d)disk(%d)fdisk(%d)", gControllerInfo[i].BusNumber, i, DriveNumber);
RtlInitUnicodeString(&ArcPath, gControllerInfo[i].DriveInfo[j].ArcPathBuffer);
IoAssignArcName(&ArcPath, &DeviceName);
/* 3c: Set flags up */
gControllerInfo[i].DriveInfo[j].DeviceObject->Flags |= DO_DIRECT_IO;
/* 3d: Create a symlink */
swprintf(gControllerInfo[i].DriveInfo[j].SymLinkBuffer, L"\\DosDevices\\%c:", DriveNumber + 'A');
RtlInitUnicodeString(&LinkName, gControllerInfo[i].DriveInfo[j].SymLinkBuffer);
if(IoCreateSymbolicLink(&LinkName, &DeviceName) != STATUS_SUCCESS)
{
WARN_(FLOPPY, "AddControllers: Unable to create a symlink for drive %d\n", DriveNumber);
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
IoDeassignArcName(&ArcPath);
continue; /* continue to next drive */
}
/* 3e: Increase global floppy drives count */
IoGetConfigurationInformation()->FloppyCount++;
/* 3f: Set up the DPC */
IoInitializeDpcRequest(gControllerInfo[i].DriveInfo[j].DeviceObject, (PIO_DPC_ROUTINE)DpcForIsr);
/* 3g: Point the device extension at our DriveInfo struct */
gControllerInfo[i].DriveInfo[j].DeviceObject->DeviceExtension = &gControllerInfo[i].DriveInfo[j];
/* 3h: neat comic strip */
/* 3i: set the initial media type to unknown */
memset(&gControllerInfo[i].DriveInfo[j].DiskGeometry, 0, sizeof(DISK_GEOMETRY));
gControllerInfo[i].DriveInfo[j].DiskGeometry.MediaType = Unknown;
/* 3j: Now that we're done, set the Initialized flag so we know to free this in Unload */
gControllerInfo[i].DriveInfo[j].Initialized = TRUE;
/* 3k: Clear the DO_DEVICE_INITIALIZING flag */
gControllerInfo[i].DriveInfo[j].DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
}
}
INFO_(FLOPPY, "AddControllers: --------------------------------------------> finished adding controllers\n");
return TRUE;
}
int FloppyStartDevice(int DeviceObject , int Irp )
{ int DeviceObject__DeviceExtension = __VERIFIER_nondet_int() ;
int Irp__Tail__Overlay__CurrentStackLocation = __VERIFIER_nondet_int() ;
int Irp__IoStatus__Status ;
int disketteExtension__TargetObject = __VERIFIER_nondet_int() ;
int disketteExtension__MaxTransferSize ;
int disketteExtension__DriveType = __VERIFIER_nondet_int() ;
int disketteExtension__PerpendicularMode ;
int disketteExtension__DeviceUnit ;
int disketteExtension__DriveOnValue ;
int disketteExtension__UnderlyingPDO = __VERIFIER_nondet_int() ;
int disketteExtension__InterfaceString = __VERIFIER_nondet_int() ;
int disketteExtension__IsStarted ;
int disketteExtension__HoldNewRequests ;
int ntStatus ;
int pnpStatus ;
int doneEvent = __VERIFIER_nondet_int() ;
int fdcInfo = __VERIFIER_nondet_int() ;
int fdcInfo__BufferCount ;
int fdcInfo__BufferSize ;
int fdcInfo__MaxTransferSize = __VERIFIER_nondet_int() ;
int fdcInfo__AcpiBios = __VERIFIER_nondet_int() ;
int fdcInfo__AcpiFdiSupported = __VERIFIER_nondet_int() ;
int fdcInfo__PeripheralNumber = __VERIFIER_nondet_int() ;
int fdcInfo__BusType ;
int fdcInfo__ControllerNumber = __VERIFIER_nondet_int() ;
int fdcInfo__UnitNumber = __VERIFIER_nondet_int() ;
int fdcInfo__BusNumber = __VERIFIER_nondet_int() ;
int Dc ;
int Fp ;
int disketteExtension ;
int irpSp ;
int irpSp___0 ;
int nextIrpSp ;
int nextIrpSp__Control ;
int irpSp___1 ;
int irpSp__Control ;
int irpSp__Context ;
int InterfaceType ;
int KUSER_SHARED_DATA__AlternativeArchitecture_NEC98x86 = __VERIFIER_nondet_int() ;
long __cil_tmp42 ;
int __cil_tmp43 ;
int __cil_tmp44 ;
int __cil_tmp45 ;
int __cil_tmp46 ;
int __cil_tmp47 ;
int __cil_tmp48 ;
int __cil_tmp49 ;
{
Dc = DiskController;
Fp = FloppyDiskPeripheral;
disketteExtension = DeviceObject__DeviceExtension;
irpSp = Irp__Tail__Overlay__CurrentStackLocation;
irpSp___0 = Irp__Tail__Overlay__CurrentStackLocation;
nextIrpSp = Irp__Tail__Overlay__CurrentStackLocation - 1;
nextIrpSp__Control = 0;
if (s != NP) {
{
errorFn();
}
} else {
if (compRegistered != 0) {
{
errorFn();
}
} else {
compRegistered = 1;
}
}
{
irpSp___1 = Irp__Tail__Overlay__CurrentStackLocation - 1;
irpSp__Context = doneEvent;
irpSp__Control = 224;
ntStatus = IofCallDriver(disketteExtension__TargetObject, Irp);
}
{
__cil_tmp42 = (long )ntStatus;
if (__cil_tmp42 == 259L) {
{
ntStatus = KeWaitForSingleObject(doneEvent, Executive, KernelMode, 0, 0);
ntStatus = myStatus;
}
}
}
{
fdcInfo__BufferCount = 0;
fdcInfo__BufferSize = 0;
__cil_tmp43 = 3080;
__cil_tmp44 = 458752;
__cil_tmp45 = 461832;
__cil_tmp46 = 461835;
ntStatus = FlFdcDeviceIo(disketteExtension__TargetObject, __cil_tmp46, fdcInfo);
}
if (ntStatus >= 0) {
disketteExtension__MaxTransferSize = fdcInfo__MaxTransferSize;
if (fdcInfo__AcpiBios) {
if (fdcInfo__AcpiFdiSupported) {
{
ntStatus = FlAcpiConfigureFloppy(disketteExtension, fdcInfo);
}
if (disketteExtension__DriveType == 4) {
//__cil_tmp47 = uninf1();
//disketteExtension__PerpendicularMode |= __cil_tmp47;
}
} else {
goto _L;
}
} else {
_L:
if (disketteExtension__DriveType == 4) {
//__cil_tmp48 = uninf1();
//disketteExtension__PerpendicularMode |= __cil_tmp48;
}
InterfaceType = 0;
{
while (1) {
while_0_continue: /* CIL Label */ ;
if (InterfaceType >= MaximumInterfaceType) {
goto while_1_break;
}
{
fdcInfo__BusType = InterfaceType;
ntStatus = IoQueryDeviceDescription(fdcInfo__BusType, fdcInfo__BusNumber,
Dc, fdcInfo__ControllerNumber, Fp, fdcInfo__PeripheralNumber,
FlConfigCallBack, disketteExtension);
}
if (ntStatus >= 0) {
goto while_1_break;
}
InterfaceType ++;
}
while_0_break: /* CIL Label */ ;
}
while_1_break: ;
}
if (ntStatus >= 0) {
if (KUSER_SHARED_DATA__AlternativeArchitecture_NEC98x86 != 0) {
disketteExtension__DeviceUnit = fdcInfo__UnitNumber;
//disketteExtension__DriveOnValue = fdcInfo__UnitNumber;
} else {
disketteExtension__DeviceUnit = fdcInfo__PeripheralNumber;
//__cil_tmp49 = 16 << fdcInfo__PeripheralNumber;
//disketteExtension__DriveOnValue = fdcInfo__PeripheralNumber | __cil_tmp49;
}
{
pnpStatus = IoRegisterDeviceInterface(disketteExtension__UnderlyingPDO, MOUNTDEV_MOUNTED_DEVICE_GUID,
0, disketteExtension__InterfaceString);
}
if (pnpStatus >= 0) {
{
pnpStatus = IoSetDeviceInterfaceState(disketteExtension__InterfaceString,
1);
}
}
disketteExtension__IsStarted = 1;
disketteExtension__HoldNewRequests = 0;
}
}
{
Irp__IoStatus__Status = ntStatus;
myStatus = ntStatus;
IofCompleteRequest(Irp, 0);
}
return (ntStatus);
}
}
int FloppyStartDevice(int DeviceObject , int Irp )
{ int DeviceObject__DeviceExtension = __VERIFIER_nondet_int() ;
int Irp__Tail__Overlay__CurrentStackLocation = __VERIFIER_nondet_int() ;
int Irp__IoStatus__Status ;
int disketteExtension__TargetObject = __VERIFIER_nondet_int() ;
int disketteExtension__MaxTransferSize ;
int disketteExtension__DriveType = __VERIFIER_nondet_int() ;
int disketteExtension__PerpendicularMode ;
int disketteExtension__DeviceUnit ;
int disketteExtension__DriveOnValue ;
int disketteExtension__UnderlyingPDO = __VERIFIER_nondet_int() ;
int disketteExtension__InterfaceString = __VERIFIER_nondet_int() ;
int disketteExtension__IsStarted ;
int disketteExtension__HoldNewRequests ;
int ntStatus ;
int pnpStatus ;
int doneEvent = __VERIFIER_nondet_int() ;
int fdcInfo = __VERIFIER_nondet_int() ;
int fdcInfo__BufferCount ;
int fdcInfo__BufferSize ;
int fdcInfo__MaxTransferSize = __VERIFIER_nondet_int() ;
int fdcInfo__AcpiBios = __VERIFIER_nondet_int() ;
int fdcInfo__AcpiFdiSupported = __VERIFIER_nondet_int() ;
int fdcInfo__PeripheralNumber = __VERIFIER_nondet_int() ;
int fdcInfo__BusType ;
int fdcInfo__ControllerNumber = __VERIFIER_nondet_int() ;
int fdcInfo__UnitNumber = __VERIFIER_nondet_int() ;
int fdcInfo__BusNumber = __VERIFIER_nondet_int() ;
int Dc ;
int Fp ;
int disketteExtension ;
int irpSp ;
int irpSp___0 ;
int nextIrpSp ;
int nextIrpSp__Control ;
int irpSp___1 ;
int irpSp__Control ;
int irpSp__Context ;
int InterfaceType ;
int KUSER_SHARED_DATA__AlternativeArchitecture_NEC98x86 = __VERIFIER_nondet_int() ;
long __cil_tmp42 ;
int __cil_tmp43 ;
int __cil_tmp44 ;
int __cil_tmp45 ;
int __cil_tmp46 ;
int __cil_tmp47 ;
int __cil_tmp48 ;
int __cil_tmp49 ;
{
#line 503
Dc = DiskController;
#line 504
Fp = FloppyDiskPeripheral;
#line 505
disketteExtension = DeviceObject__DeviceExtension;
#line 506
irpSp = Irp__Tail__Overlay__CurrentStackLocation;
#line 507
irpSp___0 = Irp__Tail__Overlay__CurrentStackLocation;
#line 508
nextIrpSp = Irp__Tail__Overlay__CurrentStackLocation - 1;
#line 509
nextIrpSp__Control = 0;
#line 510
if (s != NP) {
{
#line 512
errorFn();
}
} else {
#line 515
if (compRegistered != 0) {
{
#line 517
errorFn();
}
} else {
#line 520
compRegistered = 1;
}
}
{
#line 524
irpSp___1 = Irp__Tail__Overlay__CurrentStackLocation - 1;
#line 525
irpSp__Context = doneEvent;
#line 526
irpSp__Control = 224;
#line 530
ntStatus = IofCallDriver(disketteExtension__TargetObject, Irp);
}
{
#line 532
__cil_tmp42 = (long )ntStatus;
#line 532
if (__cil_tmp42 == 259L) {
{
#line 534
ntStatus = KeWaitForSingleObject(doneEvent, Executive, KernelMode, 0, 0);
#line 535
ntStatus = myStatus;
}
}
}
{
#line 541
fdcInfo__BufferCount = 0;
#line 542
fdcInfo__BufferSize = 0;
#line 543
__cil_tmp43 = 3080;
#line 543
__cil_tmp44 = 458752;
#line 543
__cil_tmp45 = 461832;
#line 543
__cil_tmp46 = 461835;
#line 543
ntStatus = FlFdcDeviceIo(disketteExtension__TargetObject, __cil_tmp46, fdcInfo);
}
#line 546
if (ntStatus >= 0) {
#line 547
disketteExtension__MaxTransferSize = fdcInfo__MaxTransferSize;
#line 548
if (fdcInfo__AcpiBios) {
#line 549
if (fdcInfo__AcpiFdiSupported) {
{
#line 551
ntStatus = FlAcpiConfigureFloppy(disketteExtension, fdcInfo);
}
#line 553
if (disketteExtension__DriveType == 4) {
#line 554
//__cil_tmp47 = uninf1();
#line 554
//disketteExtension__PerpendicularMode |= __cil_tmp47;
}
} else {
goto _L;
}
} else {
_L:
#line 563
if (disketteExtension__DriveType == 4) {
#line 564
//__cil_tmp48 = uninf1();
#line 564
//disketteExtension__PerpendicularMode |= __cil_tmp48;
}
#line 568
InterfaceType = 0;
{
#line 570
while (1) {
while_0_continue: /* CIL Label */ ;
#line 572
if (InterfaceType >= MaximumInterfaceType) {
goto while_1_break;
}
{
#line 578
fdcInfo__BusType = InterfaceType;
#line 579
ntStatus = IoQueryDeviceDescription(fdcInfo__BusType, fdcInfo__BusNumber,
Dc, fdcInfo__ControllerNumber, Fp, fdcInfo__PeripheralNumber,
FlConfigCallBack, disketteExtension);
}
#line 583
if (ntStatus >= 0) {
goto while_1_break;
}
#line 588
InterfaceType ++;
}
while_0_break: /* CIL Label */ ;
}
while_1_break: ;
}
#line 593
if (ntStatus >= 0) {
#line 594
if (KUSER_SHARED_DATA__AlternativeArchitecture_NEC98x86 != 0) {
#line 595
disketteExtension__DeviceUnit = fdcInfo__UnitNumber;
#line 596
//disketteExtension__DriveOnValue = fdcInfo__UnitNumber;
} else {
#line 598
disketteExtension__DeviceUnit = fdcInfo__PeripheralNumber;
#line 599
//__cil_tmp49 = 16 << fdcInfo__PeripheralNumber;
#line 599
//disketteExtension__DriveOnValue = fdcInfo__PeripheralNumber | __cil_tmp49;
}
{
#line 602
pnpStatus = IoRegisterDeviceInterface(disketteExtension__UnderlyingPDO, MOUNTDEV_MOUNTED_DEVICE_GUID,
0, disketteExtension__InterfaceString);
}
#line 605
if (pnpStatus >= 0) {
{
#line 607
pnpStatus = IoSetDeviceInterfaceState(disketteExtension__InterfaceString,
1);
}
}
#line 613
disketteExtension__IsStarted = 1;
#line 614
disketteExtension__HoldNewRequests = 0;
}
}
{
#line 622
Irp__IoStatus__Status = ntStatus;
#line 623
myStatus = ntStatus;
#line 624
IofCompleteRequest(Irp, 0);
}
#line 626
return (ntStatus);
}
}
static
NTSTATUS
FdcFdoQueryBusRelations(
IN PDEVICE_OBJECT DeviceObject,
OUT PDEVICE_RELATIONS *DeviceRelations)
{
PFDO_DEVICE_EXTENSION FdoDeviceExtension;
PPDO_DEVICE_EXTENSION PdoDeviceExtension;
INTERFACE_TYPE InterfaceType = Isa;
CONFIGURATION_TYPE ControllerType = DiskController;
CONFIGURATION_TYPE PeripheralType = FloppyDiskPeripheral;
PDEVICE_RELATIONS Relations;
PDRIVE_INFO DriveInfo;
PDEVICE_OBJECT Pdo;
WCHAR DeviceNameBuffer[80];
UNICODE_STRING DeviceName;
ULONG DeviceNumber = 0;
ULONG Size;
ULONG i;
NTSTATUS Status;
DPRINT1("FdcFdoQueryBusRelations() called\n");
FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
Status = IoQueryDeviceDescription(&InterfaceType,
NULL,
&ControllerType,
NULL,
&PeripheralType,
NULL,
FdcFdoConfigCallback,
FdoDeviceExtension);
if (!NT_SUCCESS(Status) && (Status != STATUS_NO_MORE_ENTRIES))
return Status;
Size = sizeof(DEVICE_RELATIONS) +
sizeof(Relations->Objects) * (FdoDeviceExtension->ControllerInfo.NumberOfDrives - 1);
Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, Size);
if (Relations == NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
Relations->Count = FdoDeviceExtension->ControllerInfo.NumberOfDrives;
for (i = 0; i < FdoDeviceExtension->ControllerInfo.NumberOfDrives; i++)
{
DriveInfo = &FdoDeviceExtension->ControllerInfo.DriveInfo[i];
if (DriveInfo->DeviceObject == NULL)
{
do
{
swprintf(DeviceNameBuffer, L"\\Device\\FloppyPDO%lu", DeviceNumber++);
RtlInitUnicodeString(&DeviceName, DeviceNameBuffer);
DPRINT1("Device name: %S\n", DeviceNameBuffer);
/* Create physical device object */
Status = IoCreateDevice(FdoDeviceExtension->Common.DeviceObject->DriverObject,
sizeof(PDO_DEVICE_EXTENSION),
&DeviceName,
FILE_DEVICE_MASS_STORAGE,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&Pdo);
}
while (Status == STATUS_OBJECT_NAME_COLLISION);
if (!NT_SUCCESS(Status))
{
DPRINT1("PDO creation failed (Status 0x%08lx)\n", Status);
goto done;
}
DPRINT1("PDO created: %S\n", DeviceNameBuffer);
DriveInfo->DeviceObject = Pdo;
PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)Pdo->DeviceExtension;
RtlZeroMemory(PdoDeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
PdoDeviceExtension->Common.IsFDO = FALSE;
PdoDeviceExtension->Common.DeviceObject = Pdo;
PdoDeviceExtension->Fdo = FdoDeviceExtension->Common.DeviceObject;
PdoDeviceExtension->DriveInfo = DriveInfo;
Pdo->Flags |= DO_DIRECT_IO;
Pdo->Flags |= DO_POWER_PAGABLE;
Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
/* Add Device ID string */
RtlCreateUnicodeString(&PdoDeviceExtension->DeviceId,
L"FDC\\GENERIC_FLOPPY_DRIVE");
DPRINT1("DeviceID: %S\n", PdoDeviceExtension->DeviceId.Buffer);
/* Add Hardware IDs string */
Status = PciCreateHardwareIDsString(&PdoDeviceExtension->HardwareIds);
if (!NT_SUCCESS(Status))
{
// ErrorStatus = Status;
// ErrorOccurred = TRUE;
break;
}
/* Add Compatible IDs string */
Status = PciCreateCompatibleIDsString(&PdoDeviceExtension->CompatibleIds);
if (!NT_SUCCESS(Status))
{
// ErrorStatus = Status;
// ErrorOccurred = TRUE;
break;
}
/* Add Instance ID string */
Status = PciCreateInstanceIDString(&PdoDeviceExtension->InstanceId,
DriveInfo->PeripheralNumber);
if (!NT_SUCCESS(Status))
{
// ErrorStatus = Status;
// ErrorOccurred = TRUE;
break;
}
#if 0
/* Add device description string */
Status = PciCreateDeviceDescriptionString(&PdoDeviceExtension->DeviceDescription, Device);
if (!NT_SUCCESS(Status))
{
// ErrorStatus = Status;
// ErrorOccurred = TRUE;
break;
}
/* Add device location string */
Status = PciCreateDeviceLocationString(&PdoDeviceExtension->DeviceLocation, Device);
if (!NT_SUCCESS(Status))
{
// ErrorStatus = Status;
// ErrorOccurred = TRUE;
break;
}
#endif
}
ObReferenceObject(DriveInfo->DeviceObject);
Relations->Objects[i] = DriveInfo->DeviceObject;
}
done:
if (NT_SUCCESS(Status))
{
*DeviceRelations = Relations;
}
else
{
if (Relations != NULL)
ExFreePool(Relations);
}
return Status;
}
NTSTATUS kdi_GetConfigurationInformation
(
/* INPUT PARAMETERS: */
/* UPDATE PARAMETERS: */
/* OUTPUT PARAMETERS: */
ConfigDataPtr *config_data_ptr_ptr
)
/* COMMENTS: *****************************************************************
*
* Routine Description:
*
* This routine is called by DriverEntry() to get information about the
* devices to be supported from configuration mangement and/or the
* hardware architecture layer (HAL).
*
* Arguments:
*
* config_data_ptr_ptr - a pointer to the pointer to a data structure that
* describes the controllers and the drives attached to them
*
* Return Value:
*
* Returns STATUS_SUCCESS unless there is no drive 0 or we didn't get
* any configuration information.
* NOTE: FUTURE return values may change when config mgr is finished.
*
* DEFINITIONS: *************************************************************/
{
/* DATA: ********************************************************************/
INTERFACE_TYPE interface_type;
NTSTATUS nt_status;
dUDWord i;
/* CODE: ********************************************************************/
*config_data_ptr_ptr = ExAllocatePool(
PagedPool,
sizeof(ConfigData)
);
if (*config_data_ptr_ptr == dNULL_PTR) {
return STATUS_INSUFFICIENT_RESOURCES;
}
/*
* Zero out the config structure and fill in the actual
* controller numbers with -1's so that the callback routine
* can recognize a new controller.
*/
RtlZeroMemory(
*config_data_ptr_ptr,
sizeof(ConfigData)
);
for (
i = 0;
i < MAXIMUM_CONTROLLERS_PER_MACHINE;
i++
) {
(*config_data_ptr_ptr)->controller[i].actual_controller_number = -1;
}
/*
* Go through all of the various bus types looking for
* disk controllers. The disk controller sections of the
* hardware registry only deal with the floppy drives.
* The callout routine that can get called will then
* look for information pertaining to a particular
* device on the controller.
*/
for (
interface_type = 0;
interface_type < MaximumInterfaceType;
interface_type++
) {
CONFIGURATION_TYPE Dc = DiskController;
CONFIGURATION_TYPE Fp = FloppyDiskPeripheral;
nt_status = IoQueryDeviceDescription(
&interface_type,
dNULL_PTR,
&Dc,
dNULL_PTR,
#if MULTI_CONTROLLER
dNULL_PTR, // Don't ask for a floppy disk drive
#else
&Fp,
#endif
dNULL_PTR,
kdi_ConfigCallBack,
*config_data_ptr_ptr
);
if (!NT_SUCCESS(nt_status) && (nt_status != STATUS_OBJECT_NAME_NOT_FOUND)) {
ExFreePool(*config_data_ptr_ptr);
*config_data_ptr_ptr = dNULL_PTR;
return nt_status;
}
}
return STATUS_SUCCESS;
}