Some were #if0'ed because they referenced non existing variables or parameters.
svn path=/trunk/; revision=16852
}
#endif
}
-
+#if 0
DPRINT("Tag = 0x%X, Type = 0x%X, Size = %d (%s)\n",
tag, *Type, *Size, TagName(*Type, *Small));
-
+#endif
/* Probably invalid data */
if ((*Type == 0xff) && (*Size == 0xffff)) {
DPRINT("Invalid data (Type 0x%X Size 0x%X)\n", *Type, *Size);
break;
default:
- DPRINT("IoControlCode: %x\n", IoStack->Parameters.FileSystemControl.FsControlCode)
+ DPRINT("IoControlCode: %x\n", IoStack->Parameters.FileSystemControl.FsControlCode);
Status = STATUS_UNSUCCESSFUL;
}
}
if (!DevExt->KeyboardExists) {
- DPRINT("Keyboard not detected\n")
+ DPRINT("Keyboard not detected\n");
if (DevExt->Settings.Headless)
/* Act as if it exists regardless */
DevExt->KeyboardExists = TRUE;
KeReleaseSpinLock(&ClassDeviceExtension->SpinLock, OldIrql);
(*ConsumedCount) += ReadSize;
} else {
- DPRINT("MouseClassCallBack() entered, InputCount = %d - DOING NOTHING\n", *InputCount);
+ DPRINT("MouseClassCallBack() entered, InputCount = %d - DOING NOTHING\n", InputCount);
}
DPRINT("Leaving MouseClassCallBack\n");
CylinderLow[1] = 0;
CylinderHigh[1] = 0;
DrvHead = (Srb->TargetId ? IDE_DH_DRV1 : 0) | IDE_DH_LBA;
-
+#if 0
DPRINT("%s:BUS=%04x:DRV=%d:LBA48=1:BLK=%08d:SC=%02x:CM=%02x\n",
(Srb->SrbFlags & SRB_FLAGS_DATA_IN) ? "READ" : "WRITE",
DeviceExtension->CommandPortBase,
(CylinderHigh[0] << 16) + (CylinderLow[0] << 8) + DectorNumberLow[0],
SectorCount,
Command);
+#endif
}
else if (DeviceParams->Capabilities & IDE_DRID_LBA_SUPPORTED)
{
*FunctionNameList + 2);
Hint = *(PWORD)((DWORD)DriverBase + *FunctionNameList);
}
+#if 0
DPRINT(" Hint:%04x Name:%s\n", Hint, pName);
+#endif
for (i = 0; i < (sizeof(DiskDumpExports) / sizeof(DiskDumpExports[0])); i++)
{
*/
{
UNREFERENCED_PARAMETER(UnusedCsq);
- DPRINT(("CSQ: Removing IRP 0x%x\n", Irp));
+ DPRINT("CSQ: Removing IRP 0x%x\n", Irp);
RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}
*/
{
UNREFERENCED_PARAMETER(UnusedCsq);
- DPRINT(("CSQ: Canceling irp 0x%x\n", Irp));
+ DPRINT("CSQ: Canceling irp 0x%x\n", Irp);
Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
*/
{
UNREFERENCED_PARAMETER(UnusedCsq);
- DPRINT(("CSQ: Inserting IRP 0x%x\n", Irp));
+ DPRINT("CSQ: Inserting IRP 0x%x\n", Irp);
InsertTailList(&IrpQueue, &Irp->Tail.Overlay.ListEntry);
KeReleaseSemaphore(&QueueSemaphore, 0, 1, FALSE);
}
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
ASSERT(ControllerInfo);
- DPRINT(("floppy: MotorStopDpcFunc called\n"));
+ DPRINT("floppy: MotorStopDpcFunc called\n");
HwTurnOffMotor(ControllerInfo);
ControllerInfo->StopDpcQueued = FALSE;
PAGED_CODE();
ASSERT(DriveInfo);
- DPRINT(("floppy: StartMotor called\n"));
+ DPRINT("floppy: StartMotor called\n");
if(DriveInfo->ControllerInfo->StopDpcQueued && !KeCancelTimer(&DriveInfo->ControllerInfo->MotorTimer))
{
/* Motor turner-offer is already running; wait for it to finish */
- DPRINT(("floppy: StartMotor: motor turner-offer is already running; waiting for it\n"));
+ DPRINT("floppy: StartMotor: motor turner-offer is already running; waiting for it\n");
KeWaitForSingleObject(&DriveInfo->ControllerInfo->MotorStoppedEvent, Executive, KernelMode, FALSE, NULL);
- DPRINT(("floppy: StartMotor: wait satisfied\n"));
+ DPRINT("floppy: StartMotor: wait satisfied\n");
}
DriveInfo->ControllerInfo->StopDpcQueued = FALSE;
if(HwTurnOnMotor(DriveInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: StartMotor(): warning: HwTurnOnMotor failed\n"));
+ DPRINT("floppy: StartMotor(): warning: HwTurnOnMotor failed\n");
}
}
ASSERT(ControllerInfo);
- DPRINT(("floppy: StopMotor called\n"));
+ DPRINT("floppy: StopMotor called\n");
/* one relative second, in 100-ns units */
StopTime.QuadPart = 10000000;
{
UNREFERENCED_PARAMETER(DeviceObject);
- DPRINT(("floppy: CreateClose called\n"));
+ DPRINT("floppy: CreateClose called\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
StartMotor(DriveInfo);
/* set the data rate */
- DPRINT(("floppy: FIXME: UN-HARDCODE DATA RATE\n"));
+ DPRINT("floppy: FIXME: UN-HARDCODE DATA RATE\n");
if(HwSetDataRate(DriveInfo->ControllerInfo, 0) != STATUS_SUCCESS)
{
- DPRINT(("floppy: Recalibrate: HwSetDataRate failed\n"));
+ DPRINT("floppy: Recalibrate: HwSetDataRate failed\n");
StopMotor(DriveInfo->ControllerInfo);
return STATUS_IO_DEVICE_ERROR;
}
Status = HwRecalibrate(DriveInfo);
if(Status != STATUS_SUCCESS)
{
- DPRINT(("floppy: Recalibrate: HwRecalibrate returned error\n"));
+ DPRINT("floppy: Recalibrate: HwRecalibrate returned error\n");
continue;
}
Status = HwRecalibrateResult(DriveInfo->ControllerInfo);
if(Status != STATUS_SUCCESS)
{
- DPRINT(("floppy: Recalibrate: HwRecalibrateResult returned error\n"));
+ DPRINT("floppy: Recalibrate: HwRecalibrateResult returned error\n");
break;
}
}
PAGED_CODE();
ASSERT(DriveInfo);
- DPRINT(("floppy: ResetChangeFlag called\n"));
+ DPRINT("floppy: ResetChangeFlag called\n");
/* Try to recalibrate. We don't care if it works. */
Recalibrate(DriveInfo);
/* Seek to 1 */
if(HwSeek(DriveInfo, 1) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n"));
+ DPRINT("floppy: ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n");
StopMotor(DriveInfo->ControllerInfo);
return STATUS_IO_DEVICE_ERROR;
}
if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ResetChangeFlag(): HwSenseInterruptStatus failed; bailing out\n"));
+ DPRINT("floppy: ResetChangeFlag(): HwSenseInterruptStatus failed; bailing out\n");
StopMotor(DriveInfo->ControllerInfo);
return STATUS_IO_DEVICE_ERROR;
}
/* Seek back to 0 */
if(HwSeek(DriveInfo, 0) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n"));
+ DPRINT("floppy: ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n");
StopMotor(DriveInfo->ControllerInfo);
return STATUS_IO_DEVICE_ERROR;
}
if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ResetChangeFlag(): HwSenseInterruptStatus #2 failed; bailing\n"));
+ DPRINT("floppy: ResetChangeFlag(): HwSenseInterruptStatus #2 failed; bailing\n");
StopMotor(DriveInfo->ControllerInfo);
return STATUS_IO_DEVICE_ERROR;
}
/* Check the change bit */
if(HwDiskChanged(DriveInfo, &DiskChanged) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ResetChangeFlag(): HwDiskChagned failed; returning STATUS_IO_DEVICE_ERROR\n"));
+ DPRINT("floppy: ResetChangeFlag(): HwDiskChagned failed; returning STATUS_IO_DEVICE_ERROR\n");
StopMotor(DriveInfo->ControllerInfo);
return STATUS_IO_DEVICE_ERROR;
}
PAGED_CODE();
UNREFERENCED_PARAMETER(DriverObject);
- DPRINT(("floppy: unloading\n"));
+ DPRINT("floppy: unloading\n");
KeSetEvent(&QueueThreadTerminate, 0, FALSE);
KeWaitForSingleObject(QueueThreadObject, Executive, KernelMode, FALSE, 0);
/* Power down the controller */
if(HwPowerOff(&gControllerInfo[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: unload: warning: HwPowerOff failed\n"));
+ DPRINT("floppy: unload: warning: HwPowerOff failed\n");
}
}
}
UNREFERENCED_PARAMETER(PathName);
- DPRINT(("floppy: ConfigCallback called with ControllerNumber %d\n", ControllerNumber));
+ DPRINT("floppy: ConfigCallback called with ControllerNumber %d\n", ControllerNumber);
gControllerInfo[gNumberOfControllers].ControllerNumber = ControllerNumber;
gControllerInfo[gNumberOfControllers].InterfaceType = BusType;
if(!HalTranslateBusAddress(BusType, BusNumber, PartialDescriptor->u.Port.Start, &AddressSpace, &TranslatedAddress))
{
- DPRINT(("floppy: HalTranslateBusAddress failed; returning\n"));
+ DPRINT("floppy: HalTranslateBusAddress failed; returning\n");
return STATUS_IO_DEVICE_ERROR;
}
ASSERT(ControllerInfo);
- DPRINT(("floppy: ISR called\n"));
+ DPRINT("floppy: ISR called\n");
/*
* Due to the stupidity of the drive/controller relationship on the floppy drive, only one device object
ASSERT(ControllerInfo);
- DPRINT(("floppy: DpcForIsr called\n"));
+ DPRINT("floppy: DpcForIsr called\n");
KeSetEvent(&ControllerInfo->SynchEvent, EVENT_INCREMENT, FALSE);
}
PAGED_CODE();
ASSERT(ControllerInfo);
- DPRINT(("floppy: InitController called with Controller 0x%x\n", ControllerInfo));
+ DPRINT("floppy: InitController called with Controller 0x%x\n", ControllerInfo);
KeClearEvent(&ControllerInfo->SynchEvent);
- DPRINT(("floppy: InitController: resetting the controller\n"));
+ DPRINT("floppy: InitController: resetting the controller\n");
/* Reset the controller */
if(HwReset(ControllerInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: InitController: unable to reset controller\n"));
+ DPRINT("floppy: InitController: unable to reset controller\n");
return STATUS_IO_DEVICE_ERROR;
}
- DPRINT(("floppy: InitController: setting data rate\n"));
+ DPRINT("floppy: InitController: setting data rate\n");
/* Set data rate */
if(HwSetDataRate(ControllerInfo, DRSR_DSEL_500KBPS) != STATUS_SUCCESS)
{
- DPRINT(("floppy: InitController: unable to set data rate\n"));
+ DPRINT("floppy: InitController: unable to set data rate\n");
return STATUS_IO_DEVICE_ERROR;
}
- DPRINT(("floppy: InitController: waiting for initial interrupt\n"));
+ DPRINT("floppy: InitController: waiting for initial interrupt\n");
/* Wait for an interrupt */
WaitForControllerInterrupt(ControllerInfo);
/* Reset means you have to clear each of the four interrupts (one per drive) */
for(i = 0; i < MAX_DRIVES_PER_CONTROLLER; i++)
{
- DPRINT(("floppy: InitController: Sensing interrupt %d\n", i));
+ DPRINT("floppy: InitController: Sensing interrupt %d\n", i);
if(HwSenseInterruptStatus(ControllerInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: InitController: Unable to clear interrupt 0x%x\n", i));
+ DPRINT("floppy: InitController: Unable to clear interrupt 0x%x\n", i);
return STATUS_IO_DEVICE_ERROR;
}
}
- DPRINT(("floppy: InitController: done sensing interrupts\n"));
+ DPRINT("floppy: InitController: done sensing interrupts\n");
/* Next, see if we have the right version to do implied seek */
if(HwGetVersion(ControllerInfo) == VERSION_ENHANCED)
/* If so, set that up -- all defaults below except first TRUE for EIS */
if(HwConfigure(ControllerInfo, TRUE, TRUE, FALSE, 0, 0) != STATUS_SUCCESS)
{
- DPRINT(("floppy: InitController: unable to set up implied seek\n"));
+ DPRINT("floppy: InitController: unable to set up implied seek\n");
ControllerInfo->ImpliedSeeks = FALSE;
}
else
{
- DPRINT(("floppy: InitController: implied seeks set!\n"));
+ DPRINT("floppy: InitController: implied seeks set!\n");
ControllerInfo->ImpliedSeeks = TRUE;
}
}
else
{
- DPRINT(("floppy: InitController: enhanced version not supported; disabling implied seeks\n"));
+ DPRINT("floppy: InitController: enhanced version not supported; disabling implied seeks\n");
ControllerInfo->ImpliedSeeks = FALSE;
ControllerInfo->Model30 = FALSE;
}
/* Specify */
- DPRINT(("FLOPPY: FIXME: Figure out speed\n"));
+ DPRINT("FLOPPY: FIXME: Figure out speed\n");
HeadLoadTime = SPECIFY_HLT_500K;
HeadUnloadTime = SPECIFY_HUT_500K;
StepRateTime = SPECIFY_SRT_500K;
- DPRINT(("floppy: InitController: issuing specify command to controller\n"));
+ DPRINT("floppy: InitController: issuing specify command to controller\n");
/* Don't disable DMA --> enable dma (dumb & confusing) */
if(HwSpecify(ControllerInfo, HeadLoadTime, HeadUnloadTime, StepRateTime, FALSE) != STATUS_SUCCESS)
{
- DPRINT(("floppy: InitController: unable to specify options\n"));
+ DPRINT("floppy: InitController: unable to specify options\n");
return STATUS_IO_DEVICE_ERROR;
}
*/
for(i = 0; i < ControllerInfo->NumberOfDrives; i++)
{
- DPRINT(("floppy: InitController: recalibrating drive 0x%x on controller 0x%x\n", i, ControllerInfo));
+ DPRINT("floppy: InitController: recalibrating drive 0x%x on controller 0x%x\n", i, ControllerInfo);
Recalibrate(&ControllerInfo->DriveInfo[i]);
}
- DPRINT(("floppy: InitController: done initializing; returning STATUS_SUCCESS\n"));
+ DPRINT("floppy: InitController: done initializing; returning STATUS_SUCCESS\n");
return STATUS_SUCCESS;
}
*/
if(!gControllerInfo[0].Populated)
{
- DPRINT(("floppy: AddControllers: failed to get controller info from registry\n"));
+ DPRINT("floppy: AddControllers: failed to get controller info from registry\n");
return FALSE;
}
/* Must set up the DPC before we connect the interrupt */
KeInitializeDpc(&gControllerInfo[i].Dpc, DpcForIsr, &gControllerInfo[i]);
- DPRINT(("floppy: Connecting interrupt %d to controller%d (object 0x%x)\n", gControllerInfo[i].MappedVector,
- i, &gControllerInfo[i]));
+ DPRINT("floppy: Connecting interrupt %d to controller%d (object 0x%x)\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)
{
- DPRINT(("floppy: AddControllers: unable to connect interrupt\n"));
+ DPRINT("floppy: AddControllers: unable to connect interrupt\n");
continue;
}
if(!gControllerInfo[i].AdapterObject)
{
- DPRINT(("floppy: AddControllers: unable to allocate an adapter object\n"));
+ DPRINT("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)
{
- DPRINT(("floppy: AddControllers():Unable to set up controller %d - initialization failed\n", i));
+ DPRINT("floppy: AddControllers():Unable to set up controller %d - initialization failed\n", i);
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
continue;
}
UNICODE_STRING ArcPath;
UCHAR DriveNumber;
- DPRINT(("floppy: AddControllers(): Configuring drive %d on controller %d\n", i, j));
+ DPRINT("floppy: AddControllers(): Configuring drive %d on controller %d\n", i, j);
/*
* 3a: create a device object for the drive
FILE_DEVICE_DISK, FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE, FALSE,
&gControllerInfo[i].DriveInfo[j].DeviceObject) != STATUS_SUCCESS)
{
- DPRINT(("floppy: AddControllers: unable to register a Device object\n"));
+ DPRINT("floppy: AddControllers: unable to register a Device object\n");
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
continue; /* continue on to next drive */
}
- DPRINT(("floppy: AddControllers: New device: %S (0x%x)\n", DeviceNameBuf, gControllerInfo[i].DriveInfo[j].DeviceObject));
+ DPRINT("floppy: AddControllers: New device: %S (0x%x)\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,
RtlInitUnicodeString(&LinkName, gControllerInfo[i].DriveInfo[j].SymLinkBuffer);
if(IoCreateSymbolicLink(&LinkName, &DeviceName) != STATUS_SUCCESS)
{
- DPRINT(("floppy: AddControllers: Unable to create a symlink for drive %d\n", DriveNumber));
+ DPRINT("floppy: AddControllers: Unable to create a symlink for drive %d\n", DriveNumber);
IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
IoDeassignArcName(&ArcPath);
continue; /* continue to next drive */
}
}
- DPRINT(("floppy: AddControllers: --------------------------------------------> finished adding controllers\n"));
+ DPRINT("floppy: AddControllers: --------------------------------------------> finished adding controllers\n");
return TRUE;
}
{
PDRIVE_INFO DriveInfo = DeviceObject->DeviceExtension;
- DPRINT(("floppy: SignalMediaChanged called\n"));
+ DPRINT("floppy: SignalMediaChanged called\n");
DriveInfo->DiskChangeCount++;
if(KeReadStateEvent(&QueueThreadTerminate))
{
- DPRINT(("floppy: QueueThread terminating\n"));
+ DPRINT("floppy: QueueThread terminating\n");
return;
}
- DPRINT(("floppy: QueueThread: servicing an IRP\n"));
+ DPRINT("floppy: QueueThread: servicing an IRP\n");
Irp = IoCsqRemoveNextIrp(&Csq, 0);
/* we won't get an irp if it was canceled */
if(!Irp)
{
- DPRINT(("floppy: QueueThread: IRP queue empty\n"));
+ DPRINT("floppy: QueueThread: IRP queue empty\n");
continue;
}
break;
default:
- DPRINT(("floppy: QueueThread(): Unrecognized irp: mj: 0x%x\n", Stack->MajorFunction));
+ DPRINT("floppy: QueueThread(): Unrecognized irp: mj: 0x%x\n", Stack->MajorFunction);
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
*/
if(PsCreateSystemThread(&ThreadHandle, 0, 0, 0, 0, QueueThread, 0) != STATUS_SUCCESS)
{
- DPRINT(("floppy: Unable to create system thread; failing init\n"));
+ DPRINT("floppy: Unable to create system thread; failing init\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
if(ObReferenceObjectByHandle(ThreadHandle, STANDARD_RIGHTS_ALL, NULL, KernelMode, &QueueThreadObject, NULL) != STATUS_SUCCESS)
{
- DPRINT(("floppy: Unable to reference returned thread handle; failing init\n"));
+ DPRINT("floppy: Unable to reference returned thread handle; failing init\n");
return STATUS_UNSUCCESSFUL;
}
{
UCHAR Status = READ_PORT_UCHAR(ControllerInfo->BaseAddress + MAIN_STATUS_REGISTER);
- if((Status & MSR_IO_DIRECTION)) /* 0 for out */
+ if(Status & MSR_IO_DIRECTION) /* 0 for out */
return FALSE;
if(!(Status & MSR_DATA_REG_READY_FOR_IO))
return STATUS_SUCCESS;
}
- DPRINT(("floppy: Send_Byte: timed out trying to write\n"));
+ DPRINT("floppy: Send_Byte: timed out trying to write\n");
HwDumpRegisters(ControllerInfo);
return STATUS_UNSUCCESSFUL;
}
return STATUS_SUCCESS;
}
- DPRINT(("floppy: Get_Byte: timed out trying to read\n"));
+ DPRINT("floppy: Get_Byte: timed out trying to read\n");
HwDumpRegisters(ControllerInfo);
return STATUS_UNSUCCESSFUL;
}
* STATUS_SUCCESS
*/
{
- DPRINT(("floppy: HwSetDataRate called; writing rate code 0x%x to offset 0x%x\n", DataRate, DATA_RATE_SELECT_REGISTER));
+ DPRINT("floppy: HwSetDataRate called; writing rate code 0x%x to offset 0x%x\n", DataRate, DATA_RATE_SELECT_REGISTER);
WRITE_PORT_UCHAR(ControllerInfo->BaseAddress + DATA_RATE_SELECT_REGISTER, DataRate);
* - Called at DISPATCH_LEVEL
*/
{
- DPRINT(("floppy: HwTurnOffMotor: writing byte 0x%x to offset 0x%x\n", DOR_FDC_ENABLE|DOR_DMA_IO_INTERFACE_ENABLE, DIGITAL_OUTPUT_REGISTER));
+ DPRINT("floppy: HwTurnOffMotor: writing byte 0x%x to offset 0x%x\n", DOR_FDC_ENABLE|DOR_DMA_IO_INTERFACE_ENABLE, DIGITAL_OUTPUT_REGISTER);
WRITE_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER, DOR_FDC_ENABLE|DOR_DMA_IO_INTERFACE_ENABLE);
else if (Unit == 3)
Buffer |= DOR_FLOPPY_MOTOR_ON_D;
- DPRINT(("floppy: HwTurnOnMotor: writing byte 0x%x to offset 0x%x\n", Buffer, DIGITAL_OUTPUT_REGISTER));
+ DPRINT("floppy: HwTurnOnMotor: writing byte 0x%x to offset 0x%x\n", Buffer, DIGITAL_OUTPUT_REGISTER);
WRITE_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER, Buffer);
return STATUS_SUCCESS;
PAGED_CODE();
- DPRINT(("floppy: HwSenseDriveStatus called\n"));
+ DPRINT("floppy: HwSenseDriveStatus called\n");
Buffer[0] = COMMAND_SENSE_DRIVE_STATUS;
Buffer[1] = DriveInfo->UnitNumber; /* hard-wired to head 0 for now */
for(i = 0; i < 2; i++)
if(Send_Byte(DriveInfo->ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwSenseDriveStatus: failed to write FIFO\n"));
+ DPRINT("floppy: HwSenseDriveStatus: failed to write FIFO\n");
return STATUS_UNSUCCESSFUL;
}
/* Send the command */
for(i = 0; i < 9; i++)
{
- DPRINT(("floppy: HwReadWriteData: Sending a command byte to the FIFO: 0x%x\n", Buffer[i]));
+ DPRINT("floppy: HwReadWriteData: Sending a command byte to the FIFO: 0x%x\n", Buffer[i]);
if(Send_Byte(ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("HwReadWriteData: Unable to write to the FIFO\n"));
+ DPRINT("HwReadWriteData: Unable to write to the FIFO\n");
return STATUS_UNSUCCESSFUL;
}
}
if(Send_Byte(ControllerInfo, COMMAND_SENSE_INTERRUPT_STATUS) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwRecalibrateResult: Unable to write the controller\n"));
+ DPRINT("floppy: HwRecalibrateResult: Unable to write the controller\n");
return STATUS_UNSUCCESSFUL;
}
for(i = 0; i < 2; i++)
if(Get_Byte(ControllerInfo, &Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwRecalibrateResult: unable to read FIFO\n"));
+ DPRINT("floppy: HwRecalibrateResult: unable to read FIFO\n");
return STATUS_UNSUCCESSFUL;
}
/* Validate that it did what we told it to */
- DPRINT(("floppy: HwRecalibrateResult results: ST0: 0x%x PCN: 0x%x\n", Buffer[0], Buffer[1]));
+ DPRINT("floppy: HwRecalibrateResult results: ST0: 0x%x PCN: 0x%x\n", Buffer[0], Buffer[1]);
/*
* Buffer[0] = ST0
/* Is the PCN 0? */
if(Buffer[1] != 0)
{
- DPRINT(("floppy: HwRecalibrateResult: PCN not 0\n"));
+ DPRINT("floppy: HwRecalibrateResult: PCN not 0\n");
return STATUS_UNSUCCESSFUL;
}
/* test seek complete */
if((Buffer[0] & SR0_SEEK_COMPLETE) != SR0_SEEK_COMPLETE)
{
- DPRINT(("floppy: HwRecalibrateResult: Failed to complete the seek\n"));
+ DPRINT("floppy: HwRecalibrateResult: Failed to complete the seek\n");
return STATUS_UNSUCCESSFUL;
}
/* Is the equipment check flag set? Could be no disk in drive... */
if((Buffer[0] & SR0_EQUIPMENT_CHECK) == SR0_EQUIPMENT_CHECK)
- DPRINT(("floppy: HwRecalibrateResult: Seeked to track 0 successfully, but EC is set; returning STATUS_SUCCESS anyway\n"));
+ DPRINT("floppy: HwRecalibrateResult: Seeked to track 0 successfully, but EC is set; returning STATUS_SUCCESS anyway\n");
return STATUS_SUCCESS;
}
for(i = 0; i < 7; i++)
if(Get_Byte(ControllerInfo, &Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwReadWriteResult: unable to read fifo\n"));
+ DPRINT("floppy: HwReadWriteResult: unable to read fifo\n");
return STATUS_UNSUCCESSFUL;
}
/* Validate that it did what we told it to */
- DPRINT(("floppy: HwReadWriteResult results: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", Buffer[0], Buffer[1], Buffer[2], Buffer[3],
- Buffer[4], Buffer[5], Buffer[6]));
+ DPRINT("floppy: HwReadWriteResult results: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", Buffer[0], Buffer[1], Buffer[2], Buffer[3],
+ Buffer[4], Buffer[5], Buffer[6]);
/* Last command successful? */
if((Buffer[0] & SR0_LAST_COMMAND_STATUS) != SR0_LCS_SUCCESS)
UCHAR Buffer[2];
int i;
- DPRINT(("floppy: HwRecalibrate called\n"));
+ DPRINT("floppy: HwRecalibrate called\n");
PAGED_CODE();
for(i = 0; i < 2; i++)
if(Send_Byte(ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwRecalibrate: unable to write FIFO\n"));
+ DPRINT("floppy: HwRecalibrate: unable to write FIFO\n");
return STATUS_UNSUCCESSFUL;
}
if(Send_Byte(ControllerInfo, COMMAND_SENSE_INTERRUPT_STATUS) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwSenseInterruptStatus: failed to write controller\n"));
+ DPRINT("floppy: HwSenseInterruptStatus: failed to write controller\n");
return STATUS_UNSUCCESSFUL;
}
{
if(Get_Byte(ControllerInfo, &Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwSenseInterruptStatus: failed to read controller\n"));
+ DPRINT("floppy: HwSenseInterruptStatus: failed to read controller\n");
return STATUS_UNSUCCESSFUL;
}
}
- DPRINT(("floppy: HwSenseInterruptStatus returned 0x%x 0x%x\n", Buffer[0], Buffer[1]));
+ DPRINT("floppy: HwSenseInterruptStatus returned 0x%x 0x%x\n", Buffer[0], Buffer[1]);
return STATUS_SUCCESS;
}
UCHAR Buffer[2];
int i;
- DPRINT(("floppy: HwReadId called\n"));
+ DPRINT("floppy: HwReadId called\n");
PAGED_CODE();
for(i = 0; i < 2; i++)
if(Send_Byte(DriveInfo->ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwReadId: unable to send bytes to fifo\n"));
+ DPRINT("floppy: HwReadId: unable to send bytes to fifo\n");
return STATUS_UNSUCCESSFUL;
}
UCHAR Buffer[6];
int i;
- DPRINT(("floppy: HwFormatTrack called\n"));
+ DPRINT("floppy: HwFormatTrack called\n");
PAGED_CODE();
for(i = 0; i < 6; i++)
if(Send_Byte(ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwFormatTrack: unable to send bytes to floppy\n"));
+ DPRINT("floppy: HwFormatTrack: unable to send bytes to floppy\n");
return STATUS_UNSUCCESSFUL;
}
UCHAR Buffer[3];
int i;
- DPRINT(("floppy: HwSeek called for cyl 0x%x\n", Cylinder));
+ DPRINT("floppy: HwSeek called for cyl 0x%x\n", Cylinder);
PAGED_CODE();
for(i = 0; i < 3; i++)
if(Send_Byte(DriveInfo->ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwSeek: failed to write fifo\n"));
+ DPRINT("floppy: HwSeek: failed to write fifo\n");
return STATUS_UNSUCCESSFUL;
}
UCHAR Buffer[4];
int i;
- DPRINT(("floppy: HwConfigure called\n"));
+ DPRINT("floppy: HwConfigure called\n");
PAGED_CODE();
for(i = 0; i < 4; i++)
if(Send_Byte(ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwConfigure: failed to write the fifo\n"));
+ DPRINT("floppy: HwConfigure: failed to write the fifo\n");
return STATUS_UNSUCCESSFUL;
}
if(Send_Byte(ControllerInfo, COMMAND_VERSION) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwGetVersion: unable to write fifo\n"));
+ DPRINT("floppy: HwGetVersion: unable to write fifo\n");
return STATUS_UNSUCCESSFUL;
}
if(Get_Byte(ControllerInfo, &Buffer) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwGetVersion: unable to write fifo\n"));
+ DPRINT("floppy: HwGetVersion: unable to write fifo\n");
return STATUS_UNSUCCESSFUL;
}
- DPRINT(("floppy: HwGetVersion returning version 0x%x\n", Buffer));
+ DPRINT("floppy: HwGetVersion returning version 0x%x\n", Buffer);
return Buffer;
}
Buffer = READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_INPUT_REGISTER);
- DPRINT(("floppy: HwDiskChanged: read 0x%x from DIR\n", Buffer));
+ DPRINT("floppy: HwDiskChanged: read 0x%x from DIR\n", Buffer);
if(ControllerInfo->Model30)
{
if(!(Buffer & DIR_DISKETTE_CHANGE))
{
- DPRINT(("floppy: HdDiskChanged - Model30 - returning TRUE\n"));
+ DPRINT("floppy: HdDiskChanged - Model30 - returning TRUE\n");
*DiskChanged = TRUE;
}
else
{
- DPRINT(("floppy: HdDiskChanged - Model30 - returning FALSE\n"));
+ DPRINT("floppy: HdDiskChanged - Model30 - returning FALSE\n");
*DiskChanged = FALSE;
}
}
{
if(Buffer & DIR_DISKETTE_CHANGE)
{
- DPRINT(("floppy: HdDiskChanged - PS2 - returning TRUE\n"));
+ DPRINT("floppy: HdDiskChanged - PS2 - returning TRUE\n");
*DiskChanged = TRUE;
}
else
{
- DPRINT(("floppy: HdDiskChanged - PS2 - returning FALSE\n"));
+ DPRINT("floppy: HdDiskChanged - PS2 - returning FALSE\n");
*DiskChanged = FALSE;
}
}
if(Get_Byte(ControllerInfo, Status) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwSenseDriveStatus: unable to read fifo\n"));
+ DPRINT("floppy: HwSenseDriveStatus: unable to read fifo\n");
return STATUS_UNSUCCESSFUL;
}
- DPRINT(("floppy: HwSenseDriveStatusResult: ST3: 0x%x\n", *Status));
+ DPRINT("floppy: HwSenseDriveStatusResult: ST3: 0x%x\n", *Status);
return STATUS_SUCCESS;
}
for(i = 0; i < 7; i++)
if(Get_Byte(ControllerInfo, &Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadIdResult(): can't read from the controller\n"));
+ DPRINT("floppy: ReadIdResult(): can't read from the controller\n");
return STATUS_UNSUCCESSFUL;
}
/* Validate that it did what we told it to */
- DPRINT(("floppy: ReadId results: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", Buffer[0], Buffer[1], Buffer[2], Buffer[3],
- Buffer[4], Buffer[5], Buffer[6]));
+ DPRINT("floppy: ReadId results: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", Buffer[0], Buffer[1], Buffer[2], Buffer[3],
+ Buffer[4], Buffer[5], Buffer[6]);
/* Last command successful? */
if((Buffer[0] & SR0_LAST_COMMAND_STATUS) != SR0_LCS_SUCCESS)
{
- DPRINT(("floppy: ReadId didn't return last command success\n"));
+ DPRINT("floppy: ReadId didn't return last command success\n");
return STATUS_UNSUCCESSFUL;
}
/* ID mark found? */
if(Buffer[1] & SR1_CANNOT_FIND_ID_ADDRESS)
{
- DPRINT(("floppy: ReadId didn't find an address mark\n"));
+ DPRINT("floppy: ReadId didn't find an address mark\n");
return STATUS_UNSUCCESSFUL;
}
Buffer[1] = 0xdf;
Buffer[2] = 0x2;
- //DPRINT(("HwSpecify: sending 0x%x 0x%x 0x%x to FIFO\n", Buffer[0], Buffer[1], Buffer[2]));
- DPRINT(("FLOPPY: HWSPECIFY: FIXME - sending 0x3 0xd1 0x2 to FIFO\n"));
+ //DPRINT("HwSpecify: sending 0x%x 0x%x 0x%x to FIFO\n", Buffer[0], Buffer[1], Buffer[2]);
+ DPRINT("FLOPPY: HWSPECIFY: FIXME - sending 0x3 0xd1 0x2 to FIFO\n");
for(i = 0; i < 3; i++)
if(Send_Byte(ControllerInfo, Buffer[i]) != STATUS_SUCCESS)
{
- DPRINT(("floppy: HwSpecify: unable to write to controller\n"));
+ DPRINT("floppy: HwSpecify: unable to write to controller\n");
return STATUS_UNSUCCESSFUL;
}
* - Generates an interrupt that must be serviced four times (one per drive)
*/
{
- DPRINT(("floppy: HwReset called\n"));
+ DPRINT("floppy: HwReset called\n");
/* Write the reset bit in the DRSR */
WRITE_PORT_UCHAR(ControllerInfo->BaseAddress + DATA_RATE_SELECT_REGISTER, DRSR_SW_RESET);
if(!(READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER) & DOR_RESET))
{
HwDumpRegisters(ControllerInfo);
- DPRINT(("floppy: HwReset: Setting Enable bit\n"));
+ DPRINT("floppy: HwReset: Setting Enable bit\n");
WRITE_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER, DOR_DMA_IO_INTERFACE_ENABLE|DOR_RESET);
HwDumpRegisters(ControllerInfo);
if(!(READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER) & DOR_RESET))
{
- DPRINT(("floppy: HwReset: failed to set the DOR enable bit!\n"));
+ DPRINT("floppy: HwReset: failed to set the DOR enable bit!\n");
HwDumpRegisters(ControllerInfo);
return STATUS_UNSUCCESSFUL;
}
* - Wake up with a hardware reset
*/
{
- DPRINT(("floppy: HwPowerOff called on controller 0x%x\n", ControllerInfo));
+ DPRINT("floppy: HwPowerOff called on controller 0x%x\n", ControllerInfo);
WRITE_PORT_UCHAR(ControllerInfo->BaseAddress + DATA_RATE_SELECT_REGISTER, DRSR_POWER_DOWN);
{
UNREFERENCED_PARAMETER(ControllerInfo);
- DPRINT(("floppy: STATUS: "));
- DPRINT(("STATUS_REGISTER_A = 0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + STATUS_REGISTER_A)));
- DPRINT(("STATUS_REGISTER_B = 0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + STATUS_REGISTER_B)));
- DPRINT(("DIGITAL_OUTPUT_REGISTER = 0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER)));
- DPRINT(("MAIN_STATUS_REGISTER =0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + MAIN_STATUS_REGISTER)));
- DPRINT(("DIGITAL_INPUT_REGISTER = 0x%x\n", READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_INPUT_REGISTER)));
+ DPRINT("floppy: STATUS: ");
+ DPRINT("STATUS_REGISTER_A = 0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + STATUS_REGISTER_A));
+ DPRINT("STATUS_REGISTER_B = 0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + STATUS_REGISTER_B));
+ DPRINT("DIGITAL_OUTPUT_REGISTER = 0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_OUTPUT_REGISTER));
+ DPRINT("MAIN_STATUS_REGISTER =0x%x ", READ_PORT_UCHAR(ControllerInfo->BaseAddress + MAIN_STATUS_REGISTER));
+ DPRINT("DIGITAL_INPUT_REGISTER = 0x%x\n", READ_PORT_UCHAR(ControllerInfo->BaseAddress + DIGITAL_INPUT_REGISTER));
}
ULONG Code = Stack->Parameters.DeviceIoControl.IoControlCode;
BOOLEAN DiskChanged;
- DPRINT(("floppy: DeviceIoctl called\n"));
+ DPRINT("floppy: DeviceIoctl called\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
if(Code == IOCTL_DISK_GET_MEDIA_TYPES)
{
PDISK_GEOMETRY Geometry = OutputBuffer;
- DPRINT(("floppy: IOCTL_DISK_GET_MEDIA_TYPES Called\n"));
+ DPRINT("floppy: IOCTL_DISK_GET_MEDIA_TYPES Called\n");
if(OutputLength < sizeof(DISK_GEOMETRY))
{
- DPRINT(("floppy: IOCTL_DISK_GET_MEDIA_TYPES: insufficient buffer; returning STATUS_INVALID_PARAMETER\n"));
+ DPRINT("floppy: IOCTL_DISK_GET_MEDIA_TYPES: insufficient buffer; returning STATUS_INVALID_PARAMETER\n");
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
- DPRINT(("floppy: Ioctl: completing with STATUS_SUCCESS\n"));
+ DPRINT("floppy: Ioctl: completing with STATUS_SUCCESS\n");
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return;
*/
if(DriveInfo->DeviceObject->Flags & DO_VERIFY_VOLUME && !(DriveInfo->DeviceObject->Flags & SL_OVERRIDE_VERIFY_VOLUME))
{
- DPRINT(("floppy: DeviceIoctl(): completing with STATUS_VERIFY_REQUIRED\n"));
+ DPRINT("floppy: DeviceIoctl(): completing with STATUS_VERIFY_REQUIRED\n");
Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
*/
if(HwDiskChanged(DriveInfo, &DiskChanged) != STATUS_SUCCESS)
{
- DPRINT(("floppy: DeviceIoctl(): unable to sense disk change; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: DeviceIoctl(): unable to sense disk change; completing with STATUS_UNSUCCESSFUL\n");
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
if(DiskChanged)
{
- DPRINT(("floppy: DeviceIoctl(): detected disk changed; signalling media change and completing\n"));
+ DPRINT("floppy: DeviceIoctl(): detected disk changed; signalling media change and completing\n");
SignalMediaChanged(DriveInfo->DeviceObject, Irp);
/*
{
UCHAR Status;
- DPRINT(("floppy: IOCTL_DISK_IS_WRITABLE Called\n"));
+ DPRINT("floppy: IOCTL_DISK_IS_WRITABLE Called\n");
/* This IRP always has 0 information */
Irp->IoStatus.Information = 0;
if(HwSenseDriveStatus(DriveInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: IoctlDiskIsWritable(): unable to sense drive status\n"));
+ DPRINT("floppy: IoctlDiskIsWritable(): unable to sense drive status\n");
Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
break;
}
/* Now, read the drive's status back */
if(HwSenseDriveStatusResult(DriveInfo->ControllerInfo, &Status) != STATUS_SUCCESS)
{
- DPRINT(("floppy: IoctlDiskIsWritable(): unable to read drive status result\n"));
+ DPRINT("floppy: IoctlDiskIsWritable(): unable to read drive status result\n");
Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
break;
}
/* Check to see if the write flag is set. */
if(Status & SR3_WRITE_PROTECT_STATUS_SIGNAL)
{
- DPRINT(("floppy: IOCTL_DISK_IS_WRITABLE: disk is write protected\n"));
+ DPRINT("floppy: IOCTL_DISK_IS_WRITABLE: disk is write protected\n");
Irp->IoStatus.Status = STATUS_MEDIA_WRITE_PROTECTED;
}
else
break;
case IOCTL_DISK_CHECK_VERIFY:
- DPRINT(("floppy: IOCTL_DISK_CHECK_VERIFY called\n"));
+ DPRINT("floppy: IOCTL_DISK_CHECK_VERIFY called\n");
if (OutputLength != 0)
{
if (OutputLength < sizeof(ULONG))
case IOCTL_DISK_GET_DRIVE_GEOMETRY:
{
- DPRINT(("floppy: IOCTL_DISK_GET_DRIVE_GEOMETRY Called\n"));
+ DPRINT("floppy: IOCTL_DISK_GET_DRIVE_GEOMETRY Called\n");
if(OutputLength < sizeof(DISK_GEOMETRY))
{
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
case IOCTL_DISK_FORMAT_TRACKS:
case IOCTL_DISK_FORMAT_TRACKS_EX:
- DPRINT(("floppy: Format called; not supported yet\n"));
+ DPRINT("floppy: Format called; not supported yet\n");
break;
case IOCTL_DISK_GET_PARTITION_INFO:
- DPRINT(("floppy: IOCTL_DISK_GET_PARTITION_INFO Called; not supported\n"));
+ DPRINT("floppy: IOCTL_DISK_GET_PARTITION_INFO Called; not supported\n");
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
Irp->IoStatus.Information = 0;
break;
default:
- DPRINT(("floppy: UNKNOWN IOCTL CODE: 0x%x\n", Code));
+ DPRINT("floppy: UNKNOWN IOCTL CODE: 0x%x\n", Code);
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
Irp->IoStatus.Information = 0;
break;
}
- DPRINT(("floppy: ioctl: completing with status 0x%x\n", Irp->IoStatus.Status));
+ DPRINT("floppy: ioctl: completing with status 0x%x\n", Irp->IoStatus.Status);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
UNREFERENCED_PARAMETER(DeviceObject);
UNREFERENCED_PARAMETER(Irp);
- DPRINT(("floppy: MapRegisterCallback Called\n"));
+ DPRINT("floppy: MapRegisterCallback Called\n");
ControllerInfo->MapRegisterBase = MapRegisterBase;
KeSetEvent(&ControllerInfo->SynchEvent, 0, FALSE);
* it onto the irp queue
*/
{
- DPRINT(("floppy: ReadWrite called\n"));
+ DPRINT("floppy: ReadWrite called\n");
ASSERT(DeviceObject);
ASSERT(Irp);
if(!Irp->MdlAddress)
{
- DPRINT(("floppy: ReadWrite(): MDL not found in IRP - Completing with STATUS_INVALID_PARAMETER\n"));
+ DPRINT("floppy: ReadWrite(): MDL not found in IRP - Completing with STATUS_INVALID_PARAMETER\n");
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
PAGED_CODE();
- DPRINT(("floppy: RWDetermineMediaType called\n"));
+ DPRINT("floppy: RWDetermineMediaType called\n");
/*
* This algorithm assumes that a 1.44MB floppy is in the drive. If it's not,
/* Program data rate */
if(HwSetDataRate(DriveInfo->ControllerInfo, DRSR_DSEL_500KBPS) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWDetermineMediaType(): unable to set data rate\n"));
+ DPRINT("floppy: RWDetermineMediaType(): unable to set data rate\n");
return STATUS_UNSUCCESSFUL;
}
/* Don't disable DMA --> enable dma (dumb & confusing) */
if(HwSpecify(DriveInfo->ControllerInfo, HeadLoadTime, HeadUnloadTime, StepRateTime, FALSE) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWDetermineMediaType(): specify failed\n"));
+ DPRINT("floppy: RWDetermineMediaType(): specify failed\n");
return STATUS_UNSUCCESSFUL;
}
if(HwRecalibrate(DriveInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWDetermineMediaType(): Recalibrate failed\n"));
+ DPRINT("floppy: RWDetermineMediaType(): Recalibrate failed\n");
return STATUS_UNSUCCESSFUL;
}
if(i == 1) /* failed for 2nd time */
{
- DPRINT(("floppy: RWDetermineMediaType(): RecalibrateResult failed\n"));
+ DPRINT("floppy: RWDetermineMediaType(): RecalibrateResult failed\n");
return STATUS_UNSUCCESSFUL;
}
}
/* Try to read an ID */
if(HwReadId(DriveInfo, 0) != STATUS_SUCCESS) /* read the first ID we find, from head 0 */
{
- DPRINT(("floppy: RWDetermineMediaType(): ReadId failed\n"));
+ DPRINT("floppy: RWDetermineMediaType(): ReadId failed\n");
return STATUS_UNSUCCESSFUL; /* if we can't even write to the controller, it's hopeless */
}
if(HwReadIdResult(DriveInfo->ControllerInfo, NULL, NULL) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWDetermineMediaType(): ReadIdResult failed; continuing\n"));
+ DPRINT("floppy: RWDetermineMediaType(): ReadIdResult failed; continuing\n");
continue;
}
/* Found the media; populate the geometry now */
- DPRINT(("FIXME: Hardcoded media type!\n"));
- DPRINT(("floppy: RWDetermineMediaType(): Found 1.44 media; returning success\n"));
+ DPRINT("FIXME: Hardcoded media type!\n");
+ DPRINT("floppy: RWDetermineMediaType(): Found 1.44 media; returning success\n");
DriveInfo->DiskGeometry.MediaType = GEOMETRY_144_MEDIATYPE;
DriveInfo->DiskGeometry.Cylinders.QuadPart = GEOMETRY_144_CYLINDERS;
DriveInfo->DiskGeometry.TracksPerCylinder = GEOMETRY_144_TRACKSPERCYLINDER;
}
while(FALSE);
- DPRINT(("floppy: RWDetermineMediaType(): failed to find media\n"));
+ DPRINT("floppy: RWDetermineMediaType(): failed to find media\n");
return STATUS_UNRECOGNIZED_MEDIA;
}
PAGED_CODE();
- DPRINT(("floppy: RWSeekToCylinder called drive 0x%x cylinder %d\n", DriveInfo, Cylinder));
+ DPRINT("floppy: RWSeekToCylinder called drive 0x%x cylinder %d\n", DriveInfo, Cylinder);
/* Clear any spurious interrupts */
KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
/* queue seek command */
if(HwSeek(DriveInfo, Cylinder) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWSeekToTrack(): unable to seek\n"));
+ DPRINT("floppy: RWSeekToTrack(): unable to seek\n");
return STATUS_UNSUCCESSFUL;
}
if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWSeekToTrack(): unable to get seek results\n"));
+ DPRINT("floppy: RWSeekToTrack(): unable to get seek results\n");
return STATUS_UNSUCCESSFUL;
}
/* read ID mark from head 0 to verify */
if(HwReadId(DriveInfo, 0) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWSeekToTrack(): unable to queue ReadId\n"));
+ DPRINT("floppy: RWSeekToTrack(): unable to queue ReadId\n");
return STATUS_UNSUCCESSFUL;
}
if(HwReadIdResult(DriveInfo->ControllerInfo, &CurCylinder, NULL) != STATUS_SUCCESS)
{
- DPRINT(("floppy: RWSeekToTrack(): unable to get ReadId result\n"));
+ DPRINT("floppy: RWSeekToTrack(): unable to get ReadId result\n");
return STATUS_UNSUCCESSFUL;
}
if(CurCylinder != Cylinder)
{
- DPRINT(("floppy: RWSeekToTrack(): Seeek to track failed; current cylinder is 0x%x\n", CurCylinder));
+ DPRINT("floppy: RWSeekToTrack(): Seeek to track failed; current cylinder is 0x%x\n", CurCylinder);
return STATUS_UNSUCCESSFUL;
}
- DPRINT(("floppy: RWSeekToCylinder: returning successfully, now on cyl %d\n", Cylinder));
+ DPRINT("floppy: RWSeekToCylinder: returning successfully, now on cyl %d\n", Cylinder);
return STATUS_SUCCESS;
}
ULONG AbsoluteSector;
UCHAR SectorsPerCylinder = (UCHAR)DriveInfo->DiskGeometry.SectorsPerTrack * (UCHAR)DriveInfo->DiskGeometry.TracksPerCylinder;
- DPRINT(("floppy: RWComputeCHS: Called with offset 0x%x\n", DiskByteOffset));
+ DPRINT("floppy: RWComputeCHS: Called with offset 0x%x\n", DiskByteOffset);
/* First calculate the 1-based "absolute sector" based on the byte offset */
ASSERT(!(DiskByteOffset % DriveInfo->DiskGeometry.BytesPerSector)); /* FIXME: Only handle full sector transfers atm */
*/
*Sector = ((UCHAR)(AbsoluteSector % SectorsPerCylinder) + 1) - ((*Head) * (UCHAR)DriveInfo->DiskGeometry.SectorsPerTrack);
- DPRINT(("floppy: RWComputeCHS: offset 0x%x is c:0x%x h:0x%x s:0x%x\n", DiskByteOffset, *Cylinder, *Head, *Sector));
+ DPRINT("floppy: RWComputeCHS: offset 0x%x is c:0x%x h:0x%x s:0x%x\n", DiskByteOffset, *Cylinder, *Head, *Sector);
/* Sanity checking */
ASSERT(*Cylinder <= DriveInfo->DiskGeometry.Cylinders.QuadPart);
PAGED_CODE();
- DPRINT(("floppy: ReadWritePassive called to %s 0x%x bytes from offset 0x%x\n",
+ DPRINT("floppy: ReadWritePassive called to %s 0x%x bytes from offset 0x%x\n",
(Stack->MajorFunction == IRP_MJ_READ ? "read" : "write"),
(Stack->MajorFunction == IRP_MJ_READ ? Stack->Parameters.Read.Length : Stack->Parameters.Write.Length),
(Stack->MajorFunction == IRP_MJ_READ ? Stack->Parameters.Read.ByteOffset.u.LowPart :
- Stack->Parameters.Write.ByteOffset.u.LowPart)));
+ Stack->Parameters.Write.ByteOffset.u.LowPart));
/* Default return codes */
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
*/
if(DeviceObject->Flags & DO_VERIFY_VOLUME && !(DeviceObject->Flags & SL_OVERRIDE_VERIFY_VOLUME))
{
- DPRINT(("floppy: ReadWritePassive(): DO_VERIFY_VOLUME set; Completing with STATUS_VERIFY_REQUIRED\n"));
+ DPRINT("floppy: ReadWritePassive(): DO_VERIFY_VOLUME set; Completing with STATUS_VERIFY_REQUIRED\n");
Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return;
StartMotor(DriveInfo);
if(HwDiskChanged(DeviceObject->DeviceExtension, &DiskChanged) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): unable to detect disk change; Completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): unable to detect disk change; Completing with STATUS_UNSUCCESSFUL\n");
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
return;
if(DiskChanged)
{
- DPRINT(("floppy: ReadWritePhase1(): signalling media changed; Completing with STATUS_MEDIA_CHANGED\n"));
+ DPRINT("floppy: ReadWritePhase1(): signalling media changed; Completing with STATUS_MEDIA_CHANGED\n");
/* The following call sets IoStatus.Status and IoStatus.Information */
SignalMediaChanged(DeviceObject, Irp);
{
if(RWDetermineMediaType(DriveInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): unable to determine media type; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): unable to determine media type; completing with STATUS_UNSUCCESSFUL\n");
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
return;
if(DriveInfo->DiskGeometry.MediaType == Unknown)
{
- DPRINT(("floppy: ReadWritePassive(): Unknown media in drive; completing with STATUS_UNRECOGNIZED_MEDIA\n"));
+ DPRINT("floppy: ReadWritePassive(): Unknown media in drive; completing with STATUS_UNRECOGNIZED_MEDIA\n");
Irp->IoStatus.Status = STATUS_UNRECOGNIZED_MEDIA;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
if(Status != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): unable allocate an adapter channel; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): unable allocate an adapter channel; completing with STATUS_UNSUCCESSFUL\n");
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
return ;
ULONG CurrentTransferBytes;
UCHAR CurrentTransferSectors;
- DPRINT(("floppy: ReadWritePassive(): iterating in while (TransferByteOffset = 0x%x of 0x%x total) - allocating %d registers\n",
- TransferByteOffset, Length, DriveInfo->ControllerInfo->MapRegisters));
+ DPRINT("floppy: ReadWritePassive(): iterating in while (TransferByteOffset = 0x%x of 0x%x total) - allocating %d registers\n",
+ TransferByteOffset, Length, DriveInfo->ControllerInfo->MapRegisters);
KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
*/
if(RWComputeCHS(DriveInfo, DiskByteOffset+TransferByteOffset, &Cylinder, &Head, &StartSector) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): unable to compute CHS; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): unable to compute CHS; completing with STATUS_UNSUCCESSFUL\n");
RWFreeAdapterChannel(DriveInfo->ControllerInfo->AdapterObject);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
{
if(RWSeekToCylinder(DriveInfo, Cylinder) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): unable to seek; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): unable to seek; completing with STATUS_UNSUCCESSFUL\n");
RWFreeAdapterChannel(DriveInfo->ControllerInfo->AdapterObject);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
* We can only ask for a transfer up to the end of the track. Then we have to re-seek and do more.
* TODO: Support the MT bit
*/
- DPRINT(("floppy: ReadWritePassive(): computing number of sectors to transfer (StartSector 0x%x): ", StartSector));
+ DPRINT("floppy: ReadWritePassive(): computing number of sectors to transfer (StartSector 0x%x): ", StartSector);
/* 1-based sector number */
if( (((DriveInfo->DiskGeometry.TracksPerCylinder - Head) * DriveInfo->DiskGeometry.SectorsPerTrack - StartSector) + 1 ) <
CurrentTransferSectors = (UCHAR)((Length - TransferByteOffset) / DriveInfo->DiskGeometry.BytesPerSector);
}
- DPRINT(("0x%x\n", CurrentTransferSectors));
+ DPRINT("0x%x\n", CurrentTransferSectors);
CurrentTransferBytes = CurrentTransferSectors * DriveInfo->DiskGeometry.BytesPerSector;
* Adjust to map registers
* BUG: Does this take into account page crossings?
*/
- DPRINT(("floppy: ReadWritePassive(): Trying to transfer 0x%x bytes\n", CurrentTransferBytes));
+ DPRINT("floppy: ReadWritePassive(): Trying to transfer 0x%x bytes\n", CurrentTransferBytes);
ASSERT(CurrentTransferBytes);
CurrentTransferBytes = CurrentTransferSectors * DriveInfo->DiskGeometry.BytesPerSector;
- DPRINT(("floppy: ReadWritePassive: limiting transfer to 0x%x bytes (0x%x sectors) due to map registers\n",
- CurrentTransferBytes, CurrentTransferSectors));
+ DPRINT("floppy: ReadWritePassive: limiting transfer to 0x%x bytes (0x%x sectors) due to map registers\n",
+ CurrentTransferBytes, CurrentTransferSectors);
}
/* set up this round's dma operation */
if(HwReadWriteData(DriveInfo->ControllerInfo, !WriteToDevice, DriveInfo->UnitNumber, Cylinder, Head, StartSector,
DriveInfo->BytesPerSectorCode, DriveInfo->DiskGeometry.SectorsPerTrack, Gap, 0xff) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): HwReadWriteData returned failure; unable to read; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): HwReadWriteData returned failure; unable to read; completing with STATUS_UNSUCCESSFUL\n");
RWFreeAdapterChannel(DriveInfo->ControllerInfo->AdapterObject);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
StopMotor(DriveInfo->ControllerInfo);
return ;
}
- DPRINT(("floppy: ReadWritePassive(): HwReadWriteData returned -- waiting on event\n"));
+ DPRINT("floppy: ReadWritePassive(): HwReadWriteData returned -- waiting on event\n");
/*
* At this point, we block and wait for an interrupt
/* Read the results from the drive */
if(HwReadWriteResult(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
{
- DPRINT(("floppy: ReadWritePassive(): HwReadWriteResult returned failure; unable to read; completing with STATUS_UNSUCCESSFUL\n"));
+ DPRINT("floppy: ReadWritePassive(): HwReadWriteResult returned failure; unable to read; completing with STATUS_UNSUCCESSFUL\n");
HwDumpRegisters(DriveInfo->ControllerInfo);
RWFreeAdapterChannel(DriveInfo->ControllerInfo->AdapterObject);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
RWFreeAdapterChannel(DriveInfo->ControllerInfo->AdapterObject);
/* That's all folks! */
- DPRINT(("floppy: ReadWritePassive(): success; Completing with STATUS_SUCCESS\n"));
+ DPRINT("floppy: ReadWritePassive(): success; Completing with STATUS_SUCCESS\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = Length;
IoCompleteRequest(Irp, IO_NO_INCREMENT);