projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Relative include path fixed to absolute path.
[reactos.git] / reactos / drivers / dd / ide / ide.c
1 /* $Id: ide.c,v 1.56 2002/09/08 10:22:04 chorns Exp $
2 *
3 * IDE.C - IDE Disk driver
4 * written by Rex Jolliff
5 * with help from various documentation sources and a few peeks at
6 * linux and freebsd sources.
7 *
8 * This driver supports PCI controllers and up to 4 ISA controllers
9 * with up to 2 drives each.
10 * The device names are assigned as follows:
11 * \Devices\HarddiskX\Partition0
12 * for the raw device, and
13 * \Devices\HarddiskX\PartitionY
14 * for partitions
15 * where:
16 * X is computed by counting the available drives from the following
17 * sequence: the controller number (0=0x1f0, 1=0x170, 2=0x1e8,
18 * 3=0x168) * 2 plus the drive number (0,1)
19 * Y is the partition number
20 *
21 * The driver exports the following function:
22 *
23 * DriverEntry() - NT device driver initialization routine
24 *
25 * And the following functions are exported implicitly:
26 *
27 * IDEStartIo() - called to start an I/O request packet
28 * IDEDispatchOpenClose() - Called to open/close the device. a NOOP
29 * IDEDispatchReadWrite() - Called to read/write the device.
30 * IDEDispatchQueryInformation() - Called to get device information
31 * IDEDispatchSetInformation() - Called to set device information
32 * IDEDispatchDeviceControl() - Called to execute device control requests
33 *
34 * Modification History:
35 * 05/25/98 RJJ Created.
36 * 05/30/98 RJJ Removed IRQ handler and inserted busy waits
37 * just to get something working...
38 * 07/18/98 RJJ Made drastic changes so that the driver
39 * resembles a WinNT driver.
40 * 08/05/98 RJJ Changed to .C extension
41 * 09/19/98 RJJ First release (run for cover!)
42 *
43 * Test List:
44 * 09/17/98 RJJ Pri/MST: 14.12X19 WDC AC31000H Test Passed
45 * Pri/SLV: None.
46 *
47 *
48 * To Do:
49 * FIXME: a timer should be used to watch for device timeouts and errors
50 * FIXME: errors should be retried
51 * FIXME: a drive reset/recalibrate should be attempted if errors occur
52 * FIXME: Use DMA for transfers if drives support it
53 * FIXME: should we support unloading of this driver???
54 * FIXME: the device information should come from AUTODETECT (via registry)
55 * FIXME: really big devices need to be handled correctly
56 * FIXME: should get device info from the registry
57 * FIXME: should report hardware usage to iomgr
58 * FIXME: finish implementation of QueryInformation
59 * FIXME: finish implementation of SetInformation
60 * FIXME: finish implementation of DeviceControl
61 * FIXME: bring up to ATA-3 spec
62 * FIXME: add general support for ATAPI devices
63 * FIXME: add support for ATAPI CDROMs
64 * FIXME: add support for ATAPI ZIP drives/RHDs
65 * FIXME: add support for ATAPI tape drives
66 */
67
68 // -------------------------------------------------------------------------
69
70 #include <ddk/ntddk.h>
71
72 #define NDEBUG
73 #include <debug.h>
74
75 #include "ide.h"
76 #include "partitio.h"
77
78 #define VERSION "V0.1.5"
79
80 /* uncomment the following line to enable the secondary ide channel */
81 //#define ENABLE_SECONDARY_IDE_CHANNEL
82
83 // ------------------------------------------------------- File Static Data
84
85
86 typedef struct _IDE_CONTROLLER_PARAMETERS
87 {
88 int CommandPortBase;
89 int CommandPortSpan;
90 int ControlPortBase;
91 int ControlPortSpan;
92 int Vector;
93 int IrqL;
94 int SynchronizeIrqL;
95 KINTERRUPT_MODE InterruptMode;
96 KAFFINITY Affinity;
97 } IDE_CONTROLLER_PARAMETERS, *PIDE_CONTROLLER_PARAMETERS;
98
99 // NOTE: Do not increase max drives above 2
100
101 #define IDE_MAX_DRIVES 2
102
103 #define IDE_MAX_CONTROLLERS 2
104 IDE_CONTROLLER_PARAMETERS Controllers[IDE_MAX_CONTROLLERS] =
105 {
106 {0x01f0, 8, 0x03f6, 1, 14, 14, 15, LevelSensitive, 0xffff},
107 {0x0170, 8, 0x0376, 1, 15, 15, 15, LevelSensitive, 0xffff}
108 /* {0x01E8, 8, 0x03ee, 1, 11, 11, 15, LevelSensitive, 0xffff},
109 {0x0168, 8, 0x036e, 1, 10, 10, 15, LevelSensitive, 0xffff}*/
110 };
111
112 static BOOLEAN IDEInitialized = FALSE;
113
114 // ----------------------------------------------- Discardable Declarations
115
116 #ifdef ALLOC_PRAGMA
117
118 // make the initialization routines discardable, so that they
119 // don't waste space
120
121 #pragma alloc_text(init, DriverEntry)
122 #pragma alloc_text(init, IDECreateController)
123 #pragma alloc_text(init, IDECreateDevices)
124 #pragma alloc_text(init, IDECreateDevice)
125 #pragma alloc_text(init, IDEPolledRead)
126
127 // make the PASSIVE_LEVEL routines pageable, so that they don't
128 // waste nonpaged memory
129
130 #pragma alloc_text(page, IDEShutdown)
131 #pragma alloc_text(page, IDEDispatchOpenClose)
132 #pragma alloc_text(page, IDEDispatchRead)
133 #pragma alloc_text(page, IDEDispatchWrite)
134
135 #endif /* ALLOC_PRAGMA */
136
137 // ---------------------------------------------------- Forward Declarations
138
139 static NTSTATUS
140 IdeFindControllers(IN PDRIVER_OBJECT DriverObject);
141
142 static NTSTATUS
143 IdeCreateController(IN PDRIVER_OBJECT DriverObject,
144 IN PIDE_CONTROLLER_PARAMETERS ControllerParams,
145 IN int ControllerIdx);
146
147 static BOOLEAN IDEResetController(IN WORD CommandPort, IN WORD ControlPort);
148 static BOOLEAN IDECreateDevices(IN PDRIVER_OBJECT DriverObject,
149 IN PCONTROLLER_OBJECT ControllerObject,
150 IN PIDE_CONTROLLER_EXTENSION ControllerExtension,
151 IN int DriveIdx,
152 IN int HarddiskIdx);
153 static BOOLEAN IDEGetDriveIdentification(IN int CommandPort,
154 IN int DriveNum,
155 OUT PIDE_DRIVE_IDENTIFY DrvParms);
156 static NTSTATUS IDECreateDiskDevice(IN PDRIVER_OBJECT DriverObject,
157 OUT PDEVICE_OBJECT *DeviceObject,
158 IN PCONTROLLER_OBJECT ControllerObject,
159 IN int UnitNumber,
160 IN ULONG DiskNumber,
161 IN PIDE_DRIVE_IDENTIFY DrvParms,
162 IN ULONG SectorCount);
163 static NTSTATUS IDECreatePartitionDevice(IN PDRIVER_OBJECT DriverObject,
164 OUT PDEVICE_OBJECT *DeviceObject,
165 IN PCONTROLLER_OBJECT ControllerObject,
166 IN PVOID DiskDeviceExtension,
167 IN int UnitNumber,
168 IN ULONG DiskNumber,
169 IN PIDE_DRIVE_IDENTIFY DrvParms,
170 IN PPARTITION_INFORMATION PartitionInfo);
171 static int IDEPolledRead(IN WORD Address,
172 IN BYTE PreComp,
173 IN BYTE SectorCnt,
174 IN BYTE SectorNum,
175 IN BYTE CylinderLow,
176 IN BYTE CylinderHigh,
177 IN BYTE DrvHead,
178 IN BYTE Command,
179 OUT BYTE *Buffer);
180 static NTSTATUS STDCALL IDEDispatchOpenClose(IN PDEVICE_OBJECT pDO, IN PIRP Irp);
181 static NTSTATUS STDCALL IDEDispatchReadWrite(IN PDEVICE_OBJECT pDO, IN PIRP Irp);
182 static NTSTATUS STDCALL IDEDispatchDeviceControl(IN PDEVICE_OBJECT pDO, IN PIRP Irp);
183 static VOID STDCALL IDEStartIo(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
184 static IO_ALLOCATION_ACTION STDCALL
185 IDEAllocateController(IN PDEVICE_OBJECT DeviceObject,
186 IN PIRP Irp,
187 IN PVOID MapRegisterBase,
188 IN PVOID Ccontext);
189 static BOOLEAN STDCALL
190 IDEStartController(IN OUT PVOID Context);
191 VOID IDEBeginControllerReset(PIDE_CONTROLLER_EXTENSION ControllerExtension);
192 static BOOLEAN STDCALL IDEIsr(IN PKINTERRUPT Interrupt, IN PVOID ServiceContext);
193 static VOID IDEDpcForIsr(IN PKDPC Dpc,
194 IN PDEVICE_OBJECT DpcDeviceObject,
195 IN PIRP DpcIrp,
196 IN PVOID DpcContext);
197 static VOID IDEFinishOperation(PIDE_CONTROLLER_EXTENSION ControllerExtension);
198 static VOID STDCALL IDEIoTimer(PDEVICE_OBJECT DeviceObject, PVOID Context);
199
200 // ---------------------------------------------------------------- Inlines
201
202 void
203 IDESwapBytePairs(char *Buf,
204 int Cnt)
205 {
206 char t;
207 int i;
208
209 for (i = 0; i < Cnt; i += 2)
210 {
211 t = Buf[i];
212 Buf[i] = Buf[i+1];
213 Buf[i+1] = t;
214 }
215 }
216
217 // ------------------------------------------------------- Public Interface
218
219 // DriverEntry
220 //
221 // DESCRIPTION:
222 // This function initializes the driver, locates and claims
223 // hardware resources, and creates various NT objects needed
224 // to process I/O requests.
225 //
226 // RUN LEVEL:
227 // PASSIVE_LEVEL
228 //
229 // ARGUMENTS:
230 // IN PDRIVER_OBJECT DriverObject System allocated Driver Object
231 // for this driver
232 // IN PUNICODE_STRING RegistryPath Name of registry driver service
233 // key
234 //
235 // RETURNS:
236 // NTSTATUS
237
238 STDCALL NTSTATUS
239 DriverEntry(IN PDRIVER_OBJECT DriverObject,
240 IN PUNICODE_STRING RegistryPath)
241 {
242 NTSTATUS Status;
243
244 DPRINT("IDE Driver %s\n", VERSION);
245
246 /* Export other driver entry points... */
247 DriverObject->DriverStartIo = IDEStartIo;
248 DriverObject->MajorFunction[IRP_MJ_CREATE] = IDEDispatchOpenClose;
249 DriverObject->MajorFunction[IRP_MJ_CLOSE] = IDEDispatchOpenClose;
250 DriverObject->MajorFunction[IRP_MJ_READ] = IDEDispatchReadWrite;
251 DriverObject->MajorFunction[IRP_MJ_WRITE] = IDEDispatchReadWrite;
252 // DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = IDEDispatchQueryInformation;
253 // DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = IDEDispatchSetInformation;
254 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IDEDispatchDeviceControl;
255
256 Status = IdeFindControllers(DriverObject);
257 if (NT_SUCCESS(Status))
258 {
259 IDEInitialized = TRUE;
260 }
261
262 return(Status);
263 }
264
265 // ---------------------------------------------------- Discardable statics
266
267 static NTSTATUS
268 IdeFindControllers(IN PDRIVER_OBJECT DriverObject)
269 {
270 PCI_COMMON_CONFIG PciConfig;
271 ULONG Bus;
272 ULONG Slot;
273 ULONG Size;
274 ULONG i;
275 NTSTATUS ReturnedStatus = STATUS_NO_SUCH_DEVICE;
276 NTSTATUS Status;
277 INT ControllerIdx = 0;
278 PCONFIGURATION_INFORMATION ConfigInfo;
279
280 DPRINT("IdeFindControllers() called!\n");
281
282 ConfigInfo = IoGetConfigurationInformation();
283
284 /* Search PCI busses for IDE controllers */
285 for (Bus = 0; Bus < 8; Bus++)
286 {
287 for (Slot = 0; Slot < 256; Slot++)
288 {
289 Size = HalGetBusData(PCIConfiguration,
290 Bus,
291 Slot,
292 &PciConfig,
293 sizeof(PCI_COMMON_CONFIG));
294 if (Size != 0)
295 {
296 if ((PciConfig.BaseClass == 0x01) &&
297 (PciConfig.SubClass == 0x01))
298 {
299 DPRINT("IDE controller found!\n");
300
301 DPRINT("Bus %1lu Device %2lu Func %1lu VenID 0x%04hx DevID 0x%04hx\n",
302 Bus,
303 Slot>>3,
304 Slot & 0x07,
305 PciConfig.VendorID,
306 PciConfig.DeviceID);
307 if ((PciConfig.HeaderType & 0x7FFFFFFF) == 0)
308 {
309 DPRINT(" IPR 0x%X ILR 0x%X\n",
310 PciConfig.u.type0.InterruptPin,
311 PciConfig.u.type0.InterruptLine);
312 }
313
314 if (PciConfig.ProgIf & 0x01)
315 {
316 DPRINT("Primary channel: PCI native mode\n");
317 }
318 else
319 {
320 DPRINT("Primary channel: Compatibility mode\n");
321 if (ConfigInfo->AtDiskPrimaryAddressClaimed == FALSE)
322 {
323 Status = IdeCreateController(DriverObject,
324 &Controllers[0],
325 ControllerIdx);
326 if (NT_SUCCESS(Status))
327 {
328 ControllerIdx++;
329 ConfigInfo->AtDiskPrimaryAddressClaimed = TRUE;
330 ConfigInfo->ScsiPortCount++;
331 ReturnedStatus = Status;
332 }
333 }
334 else
335 {
336 /*
337 * FIXME: Switch controller to native pci mode
338 * if it is programmable.
339 */
340 }
341 }
342 if (PciConfig.ProgIf & 0x02)
343 {
344 DPRINT("Primary channel: programmable\n");
345 }
346 else
347 {
348 DPRINT("Primary channel: not programmable\n");
349 }
350
351 #ifdef ENABLE_SECONDARY_IDE_CHANNEL
352 if (PciConfig.ProgIf & 0x04)
353 {
354 DPRINT("Secondary channel: PCI native mode\n");
355 }
356 else
357 {
358 DPRINT("Secondary channel: Compatibility mode\n");
359 if (ConfigInfo->AtDiskSecondaryAddressClaimed == FALSE)
360 {
361 Status = IdeCreateController(DriverObject,
362 &Controllers[1],
363 ControllerIdx);
364 if (NT_SUCCESS(Status))
365 {
366 ControllerIdx++;
367 ConfigInfo->AtDiskSecondaryAddressClaimed = TRUE;
368 ConfigInfo->ScsiPortCount++;
369 ReturnedStatus = Status;
370 }
371 }
372 else
373 {
374 /*
375 * FIXME: Switch controller to native pci mode
376 * if it is programmable.
377 */
378 }
379 }
380 if (PciConfig.ProgIf & 0x08)
381 {
382 DPRINT("Secondary channel: programmable\n");
383 }
384 else
385 {
386 DPRINT("Secondary channel: not programmable\n");
387 }
388
389 if (PciConfig.ProgIf & 0x80)
390 {
391 DPRINT("Master IDE device: 1\n");
392 }
393 else
394 {
395 DPRINT("Master IDE device: 0\n");
396 }
397
398 for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
399 {
400 DPRINT("BaseAddress: 0x%08X\n", PciConfig.u.type0.BaseAddresses[i]);
401 }
402 #endif
403 }
404 }
405 }
406 }
407
408 /* Search for ISA IDE controller if no primary controller was found */
409 if (ConfigInfo->AtDiskPrimaryAddressClaimed == FALSE)
410 {
411 DPRINT("Searching for primary ISA IDE controller!\n");
412
413 if (IDEResetController(Controllers[0].CommandPortBase,
414 Controllers[0].ControlPortBase))
415 {
416 Status = IdeCreateController(DriverObject,
417 &Controllers[0],
418 0);
419 if (NT_SUCCESS(Status))
420 {
421 DPRINT(" Found primary ISA IDE controller!\n");
422 ControllerIdx++;
423 ConfigInfo->AtDiskPrimaryAddressClaimed = TRUE;
424 ConfigInfo->ScsiPortCount++;
425 ReturnedStatus = Status;
426 }
427 }
428 }
429
430 /* Search for ISA IDE controller if no secondary controller was found */
431 #ifdef ENABLE_SECONDARY_IDE_CHANNEL
432 if (ConfigInfo->AtDiskSecondaryAddressClaimed == FALSE)
433 {
434 DPRINT("Searching for secondary ISA IDE controller!\n");
435
436 if (IDEResetController(Controllers[1].CommandPortBase,
437 Controllers[1].ControlPortBase))
438 {
439 Status = IdeCreateController(DriverObject,
440 &Controllers[1],
441 1);
442 if (NT_SUCCESS(Status))
443 {
444 DPRINT(" Found secondary ISA IDE controller!\n");
445 ControllerIdx++;
446 ConfigInfo->AtDiskSecondaryAddressClaimed = TRUE;
447 ConfigInfo->ScsiPortCount++;
448 ReturnedStatus = Status;
449 }
450 }
451 }
452 #endif
453
454 DPRINT("IdeFindControllers() done!\n");
455
456 return(ReturnedStatus);
457 }
458
459
460 // IdeCreateController
461 //
462 // DESCRIPTION:
463 // Creates a controller object and a device object for each valid
464 // device on the controller
465 //
466 // RUN LEVEL:
467 // PASSIVE LEVEL
468 //
469 // ARGUMENTS:
470 // IN PDRIVER_OBJECT DriverObject The system created driver object
471 // IN PIDE_CONTROLLER_PARAMETERS The parameter block for this
472 // ControllerParams controller
473 // IN int ControllerIdx The index of this controller
474 //
475 // RETURNS:
476 // TRUE Devices where found on this controller
477 // FALSE The controller does not respond or there are no devices on it
478 //
479
480 static NTSTATUS
481 IdeCreateController(IN PDRIVER_OBJECT DriverObject,
482 IN PIDE_CONTROLLER_PARAMETERS ControllerParams,
483 IN int ControllerIdx)
484 {
485 BOOLEAN CreatedDevices, ThisDriveExists;
486 int DriveIdx;
487 NTSTATUS RC;
488 PCONTROLLER_OBJECT ControllerObject;
489 PIDE_CONTROLLER_EXTENSION ControllerExtension;
490
491 ControllerObject = IoCreateController(sizeof(IDE_CONTROLLER_EXTENSION));
492 if (ControllerObject == NULL)
493 {
494 DbgPrint ("Could not create controller object for controller %d\n",
495 ControllerIdx);
496 return STATUS_NO_SUCH_DEVICE;
497 }
498
499 // Fill out Controller extension data
500 ControllerExtension = (PIDE_CONTROLLER_EXTENSION)
501 ControllerObject->ControllerExtension;
502 ControllerExtension->Number = ControllerIdx;
503 ControllerExtension->CommandPortBase = ControllerParams->CommandPortBase;
504 ControllerExtension->ControlPortBase = ControllerParams->ControlPortBase;
505 ControllerExtension->Vector = ControllerParams->Vector;
506 ControllerExtension->DMASupported = FALSE;
507 ControllerExtension->ControllerInterruptBug = FALSE;
508 ControllerExtension->OperationInProgress = FALSE;
509
510 // Initialize the spin lock in the controller extension
511 KeInitializeSpinLock(&ControllerExtension->SpinLock);
512
513 // Register an interrupt handler for this controller
514 RC = IoConnectInterrupt(&ControllerExtension->Interrupt,
515 IDEIsr,
516 ControllerExtension,
517 &ControllerExtension->SpinLock,
518 ControllerExtension->Vector,
519 ControllerParams->IrqL,
520 ControllerParams->SynchronizeIrqL,
521 ControllerParams->InterruptMode,
522 FALSE,
523 ControllerParams->Affinity,
524 FALSE);
525 if (!NT_SUCCESS(RC))
526 {
527 DbgPrint ("Could not Connect Interrupt %d\n",
528 ControllerExtension->Vector);
529 IoDeleteController (ControllerObject);
530 return RC;
531 }
532
533 /* TEST */
534 IDEInitialized = TRUE;
535
536 // Create device objects for each raw device (and for partitions)
537 CreatedDevices = FALSE;
538 for (DriveIdx = 0; DriveIdx < IDE_MAX_DRIVES; DriveIdx++)
539 {
540 ThisDriveExists = IDECreateDevices(DriverObject,
541 ControllerObject,
542 ControllerExtension,
543 DriveIdx,
544 ControllerIdx * 2 + DriveIdx);
545 if (ThisDriveExists)
546 {
547 CreatedDevices = TRUE;
548 }
549 }
550
551 if (!CreatedDevices)
552 {
553 DbgPrint ("Did not find any devices for controller %d\n",
554 ControllerIdx);
555 IoDisconnectInterrupt (ControllerExtension->Interrupt);
556 IoDeleteController (ControllerObject);
557 }
558 else
559 {
560 IDEResetController(ControllerParams->CommandPortBase,
561 ControllerParams->ControlPortBase);
562 IoStartTimer(ControllerExtension->TimerDevice);
563 }
564
565 return((CreatedDevices == TRUE)?STATUS_SUCCESS:STATUS_NO_SUCH_DEVICE);
566 }
567
568
569 // IDEResetController
570 //
571 // DESCRIPTION:
572 // Reset the controller and report completion status
573 //
574 // RUN LEVEL:
575 // PASSIVE_LEVEL
576 //
577 // ARGUMENTS:
578 // IN WORD CommandPort The address of the command port
579 // IN WORD ControlPort The address of the control port
580 //
581 // RETURNS:
582 //
583
584 BOOLEAN
585 IDEResetController(IN WORD CommandPort,
586 IN WORD ControlPort)
587 {
588 int Retries;
589
590 // Assert drive reset line
591 IDEWriteDriveControl(ControlPort, IDE_DC_SRST);
592
593 // Wait for min. 25 microseconds
594 KeStallExecutionProcessor(IDE_RESET_PULSE_LENGTH);
595
596 // Negate drive reset line
597 IDEWriteDriveControl(ControlPort, 0);
598
599 // Wait for BUSY negation
600 for (Retries = 0; Retries < IDE_RESET_BUSY_TIMEOUT * 1000; Retries++)
601 {
602 if (!(IDEReadStatus(CommandPort) & IDE_SR_BUSY))
603 {
604 break;
605 }
606 KeStallExecutionProcessor(10);
607 }
608 CHECKPOINT;
609 if (Retries >= IDE_RESET_BUSY_TIMEOUT * 1000)
610 {
611 return FALSE;
612 }
613 CHECKPOINT;
614 // return TRUE if controller came back to life. and
615 // the registers are initialized correctly
616 return IDEReadError(CommandPort) == 1;
617 }
618
619
620 // IDECreateDevices
621 //
622 // DESCRIPTION:
623 // Create the raw device and any partition devices on this drive
624 //
625 // RUN LEVEL:
626 // PASSIVE_LEVEL
627 //
628 // ARGUMENTS:
629 // IN PDRIVER_OBJECT DriverObject The system created driver object
630 // IN PCONTROLLER_OBJECT ControllerObject
631 // IN PIDE_CONTROLLER_EXTENSION ControllerExtension
632 // The IDE controller extension for
633 // this device
634 // IN int DriveIdx The index of the drive on this
635 // controller
636 // IN int HarddiskIdx The NT device number for this
637 // drive
638 //
639 // RETURNS:
640 // TRUE Drive exists and devices were created
641 // FALSE no devices were created for this device
642 //
643
644 BOOLEAN
645 IDECreateDevices(IN PDRIVER_OBJECT DriverObject,
646 IN PCONTROLLER_OBJECT ControllerObject,
647 IN PIDE_CONTROLLER_EXTENSION ControllerExtension,
648 IN int DriveIdx,
649 IN int HarddiskIdx)
650 {
651 WCHAR NameBuffer[IDE_MAX_NAME_LENGTH];
652 int CommandPort;
653 NTSTATUS Status;
654 IDE_DRIVE_IDENTIFY DrvParms;
655 PDEVICE_OBJECT DiskDeviceObject;
656 PDEVICE_OBJECT PartitionDeviceObject;
657 PIDE_DEVICE_EXTENSION DiskDeviceExtension;
658 UNICODE_STRING UnicodeDeviceDirName;
659 OBJECT_ATTRIBUTES DeviceDirAttributes;
660 HANDLE Handle;
661 ULONG SectorCount = 0;
662 PDRIVE_LAYOUT_INFORMATION PartitionList = NULL;
663 PPARTITION_INFORMATION PartitionEntry;
664 ULONG i;
665
666 /* Copy I/O port offsets for convenience */
667 CommandPort = ControllerExtension->CommandPortBase;
668 // ControlPort = ControllerExtension->ControlPortBase;
669 DPRINT("probing IDE controller %d Addr %04lx Drive %d\n",
670 ControllerExtension->Number,
671 CommandPort,
672 DriveIdx);
673
674 /* Get the Drive Identification Data */
675 if (!IDEGetDriveIdentification(CommandPort, DriveIdx, &DrvParms))
676 {
677 DPRINT("No ATA drive %d found on controller %d...\n",
678 DriveIdx,
679 ControllerExtension->Number);
680 return(FALSE);
681 }
682
683 DPRINT("Found ATA drive %d on controller %d...\n",
684 DriveIdx,
685 ControllerExtension->Number);
686
687 /* Create the harddisk device directory */
688 swprintf (NameBuffer,
689 L"\\Device\\Harddisk%d",
690 HarddiskIdx);
691 RtlInitUnicodeString(&UnicodeDeviceDirName,
692 NameBuffer);
693 InitializeObjectAttributes(&DeviceDirAttributes,
694 &UnicodeDeviceDirName,
695 0,
696 NULL,
697 NULL);
698 Status = ZwCreateDirectoryObject(&Handle, 0, &DeviceDirAttributes);
699 if (!NT_SUCCESS(Status))
700 {
701 DbgPrint("Could not create device dir object\n");
702 return(FALSE);
703 }
704
705 /* Create the disk device */
706 if (DrvParms.Capabilities & IDE_DRID_LBA_SUPPORTED)
707 {
708 SectorCount =
709 (ULONG)((DrvParms.TMSectorCountHi << 16) + DrvParms.TMSectorCountLo);
710 }
711 else
712 {
713 SectorCount =
714 (ULONG)(DrvParms.LogicalCyls * DrvParms.LogicalHeads * DrvParms.SectorsPerTrack);
715 }
716 DPRINT("SectorCount %lu\n", SectorCount);
717
718 Status = IDECreateDiskDevice(DriverObject,
719 &DiskDeviceObject,
720 ControllerObject,
721 DriveIdx,
722 HarddiskIdx,
723 &DrvParms,
724 SectorCount);
725 if (!NT_SUCCESS(Status))
726 {
727 DbgPrint("IDECreateDevice call failed for raw device\n");
728 return FALSE;
729 }
730
731 /* Increase number of available physical disk drives */
732 IoGetConfigurationInformation()->DiskCount++;
733
734 /*
735 * Initialize the controller timer here
736 * (since it has to be tied to a device)
737 */
738 if (DriveIdx == 0)
739 {
740 ControllerExtension->TimerState = IDETimerIdle;
741 ControllerExtension->TimerCount = 0;
742 ControllerExtension->TimerDevice = DiskDeviceObject;
743 IoInitializeTimer(DiskDeviceObject,
744 IDEIoTimer,
745 ControllerExtension);
746 }
747
748 DPRINT("DrvParms.BytesPerSector %ld\n",DrvParms.BytesPerSector);
749
750 /* Read partition table */
751 Status = IoReadPartitionTable(DiskDeviceObject,
752 DrvParms.BytesPerSector,
753 TRUE,
754 &PartitionList);
755 if (!NT_SUCCESS(Status))
756 {
757 DbgPrint("IoReadPartitionTable() failed\n");
758 return FALSE;
759 }
760
761 DPRINT(" Number of partitions: %u\n", PartitionList->PartitionCount);
762 for (i=0;i < PartitionList->PartitionCount; i++)
763 {
764 PartitionEntry = &PartitionList->PartitionEntry[i];
765
766 DPRINT("Partition %02ld: nr: %d boot: %1x type: %x offset: %I64d size: %I64d\n",
767 i,
768 PartitionEntry->PartitionNumber,
769 PartitionEntry->BootIndicator,
770 PartitionEntry->PartitionType,
771 PartitionEntry->StartingOffset.QuadPart / DrvParms.BytesPerSector,
772 PartitionEntry->PartitionLength.QuadPart / DrvParms.BytesPerSector);
773
774 /* Create device for partition */
775 Status = IDECreatePartitionDevice(DriverObject,
776 &PartitionDeviceObject,
777 ControllerObject,
778 DiskDeviceObject->DeviceExtension,
779 DriveIdx,
780 HarddiskIdx,
781 &DrvParms,
782 PartitionEntry);
783 if (!NT_SUCCESS(Status))
784 {
785 DbgPrint("IDECreateDevice() failed\n");
786 break;
787 }
788 }
789
790 if (PartitionList != NULL)
791 ExFreePool(PartitionList);
792
793 return TRUE;
794 }
795
796 // IDEGetDriveIdentification
797 //
798 // DESCRIPTION:
799 // Get the identification block from the drive
800 //
801 // RUN LEVEL:
802 // PASSIVE_LEVEL
803 //
804 // ARGUMENTS:
805 // IN int CommandPort Address of the command port
806 // IN int DriveNum The drive index (0,1)
807 // OUT PIDE_DRIVE_IDENTIFY DrvParms Address to write drive ident block
808 //
809 // RETURNS:
810 // TRUE The drive identification block was retrieved successfully
811 //
812
813 static BOOLEAN
814 IDEGetDriveIdentification(IN int CommandPort,
815 IN int DriveNum,
816 OUT PIDE_DRIVE_IDENTIFY DrvParms)
817 {
818
819 /* Get the Drive Identify block from drive or die */
820 if (IDEPolledRead(CommandPort, 0, 1, 0, 0, 0, (DriveNum ? IDE_DH_DRV1 : 0),
821 IDE_CMD_IDENT_DRV, (BYTE *)DrvParms) != 0)
822 {
823 return(FALSE);
824 }
825
826 /* Report on drive parameters if debug mode */
827 IDESwapBytePairs(DrvParms->SerialNumber, 20);
828 IDESwapBytePairs(DrvParms->FirmwareRev, 8);
829 IDESwapBytePairs(DrvParms->ModelNumber, 40);
830 DPRINT("Config:%04x Cyls:%5d Heads:%2d Sectors/Track:%3d Gaps:%02d %02d\n",
831 DrvParms->ConfigBits,
832 DrvParms->LogicalCyls,
833 DrvParms->LogicalHeads,
834 DrvParms->SectorsPerTrack,
835 DrvParms->InterSectorGap,
836 DrvParms->InterSectorGapSize);
837 DPRINT("Bytes/PLO:%3d Vendor Cnt:%2d Serial number:[%.20s]\n",
838 DrvParms->BytesInPLO,
839 DrvParms->VendorUniqueCnt,
840 DrvParms->SerialNumber);
841 DPRINT("Cntlr type:%2d BufSiz:%5d ECC bytes:%3d Firmware Rev:[%.8s]\n",
842 DrvParms->ControllerType,
843 DrvParms->BufferSize * IDE_SECTOR_BUF_SZ,
844 DrvParms->ECCByteCnt,
845 DrvParms->FirmwareRev);
846 DPRINT("Model:[%.40s]\n", DrvParms->ModelNumber);
847 DPRINT("RWMult?:%02x LBA:%d DMA:%d MinPIO:%d ns MinDMA:%d ns\n",
848 (DrvParms->RWMultImplemented) & 0xff,
849 (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED) ? 1 : 0,
850 (DrvParms->Capabilities & IDE_DRID_DMA_SUPPORTED) ? 1 : 0,
851 DrvParms->MinPIOTransTime,
852 DrvParms->MinDMATransTime);
853 DPRINT("TM:Cyls:%d Heads:%d Sectors/Trk:%d Capacity:%ld\n",
854 DrvParms->TMCylinders,
855 DrvParms->TMHeads,
856 DrvParms->TMSectorsPerTrk,
857 (ULONG)(DrvParms->TMCapacityLo + (DrvParms->TMCapacityHi << 16)));
858 DPRINT("TM:SectorCount: 0x%04x%04x = %lu\n",
859 DrvParms->TMSectorCountHi,
860 DrvParms->TMSectorCountLo,
861 (ULONG)((DrvParms->TMSectorCountHi << 16) + DrvParms->TMSectorCountLo));
862
863 /*
864 * Fix default ATA sector size.
865 * Attention: Default ATAPI sector size is 2048 bytes!!
866 */
867 DPRINT("BytesPerSector %d\n", DrvParms->BytesPerSector);
868 DrvParms->BytesPerSector = 512;
869 DPRINT("BytesPerSector %d\n", DrvParms->BytesPerSector);
870
871 return(TRUE);
872 }
873
874
875 // IDECreateDiskDevice
876 //
877 // DESCRIPTION:
878 // Creates the disk device object
879 //
880 // RUN LEVEL:
881 // PASSIVE_LEVEL
882 //
883 // ARGUMENTS:
884 // IN PDRIVER_OBJECT DriverObject The system supplied driver object
885 // OUT PDEVICE_OBJECT *DeviceObject The created device object
886 // IN PCONTROLLER_OBJECT ControllerObject The Controller for the device
887 // IN BOOLEAN LBASupported Does the drive support LBA addressing?
888 // IN BOOLEAN DMASupported Does the drive support DMA?
889 // IN int SectorsPerLogCyl Sectors per cylinder
890 // IN int SectorsPerLogTrk Sectors per track
891 // IN DWORD Offset First valid sector for this device
892 // IN DWORD Size Count of valid sectors for this device
893 //
894 // RETURNS:
895 // NTSTATUS
896 //
897
898 NTSTATUS
899 IDECreateDiskDevice(IN PDRIVER_OBJECT DriverObject,
900 OUT PDEVICE_OBJECT *DeviceObject,
901 IN PCONTROLLER_OBJECT ControllerObject,
902 IN int UnitNumber,
903 IN ULONG DiskNumber,
904 IN PIDE_DRIVE_IDENTIFY DrvParms,
905 IN ULONG SectorCount)
906 {
907 WCHAR NameBuffer[IDE_MAX_NAME_LENGTH];
908 UNICODE_STRING DeviceName;
909 NTSTATUS RC;
910 PIDE_DEVICE_EXTENSION DeviceExtension;
911
912 /* Create a unicode device name */
913 swprintf(NameBuffer,
914 L"\\Device\\Harddisk%d\\Partition0",
915 DiskNumber);
916 RtlInitUnicodeString(&DeviceName,
917 NameBuffer);
918
919 /* Create the device */
920 RC = IoCreateDevice(DriverObject,
921 sizeof(IDE_DEVICE_EXTENSION),
922 &DeviceName,
923 FILE_DEVICE_DISK,
924 0,
925 TRUE,
926 DeviceObject);
927 if (!NT_SUCCESS(RC))
928 {
929 DbgPrint("IoCreateDevice call failed\n");
930 return(RC);
931 }
932
933 /* Set the buffering strategy here... */
934 (*DeviceObject)->Flags |= DO_DIRECT_IO;
935 (*DeviceObject)->AlignmentRequirement = FILE_WORD_ALIGNMENT;
936
937 /* Fill out Device extension data */
938 DeviceExtension = (PIDE_DEVICE_EXTENSION) (*DeviceObject)->DeviceExtension;
939 DeviceExtension->DeviceObject = (*DeviceObject);
940 DeviceExtension->ControllerObject = ControllerObject;
941 DeviceExtension->DiskDeviceExtension = DeviceExtension;
942 DeviceExtension->UnitNumber = UnitNumber;
943 DeviceExtension->LBASupported =
944 (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED) ? 1 : 0;
945 DeviceExtension->DMASupported =
946 (DrvParms->Capabilities & IDE_DRID_DMA_SUPPORTED) ? 1 : 0;
947 DeviceExtension->BytesPerSector = DrvParms->BytesPerSector;
948 DeviceExtension->SectorsPerLogCyl =
949 DrvParms->LogicalHeads * DrvParms->SectorsPerTrack;
950 DeviceExtension->SectorsPerLogTrk = DrvParms->SectorsPerTrack;
951 DeviceExtension->LogicalHeads = DrvParms->LogicalHeads;
952 DeviceExtension->LogicalCylinders =
953 (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED) ? DrvParms->TMCylinders : DrvParms->LogicalCyls;
954
955 DeviceExtension->StartingOffset.QuadPart = 0;
956 DeviceExtension->PartitionLength.QuadPart = (ULONGLONG)SectorCount *
957 (ULONGLONG)DrvParms->BytesPerSector;
958 DeviceExtension->HiddenSectors = 0;
959 DeviceExtension->PartitionNumber = 0;
960 DeviceExtension->PartitionType = 0;
961 DeviceExtension->BootIndicator = FALSE;
962
963 DPRINT("%wZ: offset %I64d length %I64d\n",
964 &DeviceName,
965 DeviceExtension->StartingOffset.QuadPart,
966 DeviceExtension->PartitionLength.QuadPart);
967
968 /* Initialize the DPC object here */
969 IoInitializeDpcRequest(*DeviceObject,
970 IDEDpcForIsr);
971
972 return RC;
973 }
974
975
976 // IDECreatePartitionDevice
977 //
978 // DESCRIPTION:
979 // Creates a partition device object
980 //
981 // RUN LEVEL:
982 // PASSIVE_LEVEL
983 //
984 // ARGUMENTS:
985 // IN PDRIVER_OBJECT DriverObject The system supplied driver object
986 // OUT PDEVICE_OBJECT *DeviceObject The created device object
987 // IN PCONTROLLER_OBJECT ControllerObject The Controller for the device
988 // IN BOOLEAN LBASupported Does the drive support LBA addressing?
989 // IN BOOLEAN DMASupported Does the drive support DMA?
990 // IN int SectorsPerLogCyl Sectors per cylinder
991 // IN int SectorsPerLogTrk Sectors per track
992 // IN DWORD Offset First valid sector for this device
993 // IN DWORD Size Count of valid sectors for this device
994 //
995 // RETURNS:
996 // NTSTATUS
997 //
998
999 NTSTATUS
1000 IDECreatePartitionDevice(IN PDRIVER_OBJECT DriverObject,
1001 OUT PDEVICE_OBJECT *DeviceObject,
1002 IN PCONTROLLER_OBJECT ControllerObject,
1003 IN PVOID DiskDeviceExtension,
1004 IN int UnitNumber,
1005 IN ULONG DiskNumber,
1006 IN PIDE_DRIVE_IDENTIFY DrvParms,
1007 IN PPARTITION_INFORMATION PartitionInfo)
1008 {
1009 WCHAR NameBuffer[IDE_MAX_NAME_LENGTH];
1010 UNICODE_STRING DeviceName;
1011 NTSTATUS RC;
1012 PIDE_DEVICE_EXTENSION DeviceExtension;
1013
1014 /* Create a unicode device name */
1015 swprintf(NameBuffer,
1016 L"\\Device\\Harddisk%d\\Partition%d",
1017 DiskNumber,
1018 PartitionInfo->PartitionNumber);
1019 RtlInitUnicodeString(&DeviceName,
1020 NameBuffer);
1021
1022 /* Create the device */
1023 RC = IoCreateDevice(DriverObject, sizeof(IDE_DEVICE_EXTENSION),
1024 &DeviceName, FILE_DEVICE_DISK, 0, TRUE, DeviceObject);
1025 if (!NT_SUCCESS(RC))
1026 {
1027 DbgPrint ("IoCreateDevice call failed\n");
1028 return RC;
1029 }
1030
1031 /* Set the buffering strategy here... */
1032 (*DeviceObject)->Flags |= DO_DIRECT_IO;
1033 (*DeviceObject)->AlignmentRequirement = FILE_WORD_ALIGNMENT;
1034
1035 /* Fill out Device extension data */
1036 DeviceExtension = (PIDE_DEVICE_EXTENSION)(*DeviceObject)->DeviceExtension;
1037 DeviceExtension->DeviceObject = (*DeviceObject);
1038 DeviceExtension->ControllerObject = ControllerObject;
1039 DeviceExtension->DiskDeviceExtension = DiskDeviceExtension;
1040 DeviceExtension->UnitNumber = UnitNumber;
1041 DeviceExtension->LBASupported =
1042 (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED) ? 1 : 0;
1043 DeviceExtension->DMASupported =
1044 (DrvParms->Capabilities & IDE_DRID_DMA_SUPPORTED) ? 1 : 0;
1045 DeviceExtension->BytesPerSector = DrvParms->BytesPerSector;
1046 DeviceExtension->SectorsPerLogCyl = DrvParms->LogicalHeads *
1047 DrvParms->SectorsPerTrack;
1048 DeviceExtension->SectorsPerLogTrk = DrvParms->SectorsPerTrack;
1049 DeviceExtension->LogicalHeads = DrvParms->LogicalHeads;
1050 DeviceExtension->LogicalCylinders =
1051 (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED) ? DrvParms->TMCylinders : DrvParms->LogicalCyls;
1052
1053 DeviceExtension->StartingOffset = PartitionInfo->StartingOffset;
1054 DeviceExtension->PartitionLength = PartitionInfo->PartitionLength;
1055 DeviceExtension->HiddenSectors = PartitionInfo->HiddenSectors;
1056 DeviceExtension->PartitionNumber = PartitionInfo->PartitionNumber;
1057 DeviceExtension->PartitionType = PartitionInfo->PartitionType;
1058 DeviceExtension->BootIndicator = PartitionInfo->BootIndicator;
1059
1060 DPRINT("%wZ: offset %I64d size %I64d\n",
1061 &DeviceName,
1062 DeviceExtension->StartingOffset.QuadPart,
1063 DeviceExtension->PartitionLength.QuadPart);
1064
1065 /* Initialize the DPC object here */
1066 IoInitializeDpcRequest(*DeviceObject, IDEDpcForIsr);
1067
1068 DPRINT("%wZ %I64dMB\n",
1069 &DeviceName,
1070 DeviceExtension->PartitionLength.QuadPart >> 20);
1071
1072 return RC;
1073 }
1074
1075
1076 // IDEPolledRead
1077 //
1078 // DESCRIPTION:
1079 // Read a sector of data from the drive in a polled fashion.
1080 //
1081 // RUN LEVEL:
1082 // PASSIVE_LEVEL
1083 //
1084 // ARGUMENTS:
1085 // IN WORD Address Address of command port for drive
1086 // IN BYTE PreComp Value to write to precomp register
1087 // IN BYTE SectorCnt Value to write to sectorCnt register
1088 // IN BYTE SectorNum Value to write to sectorNum register
1089 // IN BYTE CylinderLow Value to write to CylinderLow register
1090 // IN BYTE CylinderHigh Value to write to CylinderHigh register
1091 // IN BYTE DrvHead Value to write to Drive/Head register
1092 // IN BYTE Command Value to write to Command register
1093 // OUT BYTE *Buffer Buffer for output data
1094 //
1095 // RETURNS:
1096 // int 0 is success, non 0 is an error code
1097 //
1098
1099 static int
1100 IDEPolledRead(IN WORD Address,
1101 IN BYTE PreComp,
1102 IN BYTE SectorCnt,
1103 IN BYTE SectorNum,
1104 IN BYTE CylinderLow,
1105 IN BYTE CylinderHigh,
1106 IN BYTE DrvHead,
1107 IN BYTE Command,
1108 OUT BYTE *Buffer)
1109 {
1110 BYTE Status;
1111 int RetryCount;
1112 BOOLEAN ReadJunk = FALSE;
1113 ULONG SectorCount = 0;
1114
1115 /* Wait for STATUS.BUSY and STATUS.DRQ to clear */
1116 for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
1117 {
1118 Status = IDEReadStatus(Address);
1119 if (!(Status & IDE_SR_BUSY) && !(Status & IDE_SR_DRQ))
1120 {
1121 break;
1122 }
1123 KeStallExecutionProcessor(10);
1124 }
1125 if (RetryCount == IDE_MAX_BUSY_RETRIES)
1126 {
1127 return IDE_ER_ABRT;
1128 }
1129
1130 /* Write Drive/Head to select drive */
1131 IDEWriteDriveHead(Address, IDE_DH_FIXED | DrvHead);
1132
1133 /* Wait for STATUS.BUSY and STATUS.DRQ to clear */
1134 for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
1135 {
1136 Status = IDEReadStatus(Address);
1137 if (!(Status & IDE_SR_BUSY) && !(Status & IDE_SR_DRQ))
1138 {
1139 break;
1140 }
1141 KeStallExecutionProcessor(10);
1142 }
1143 if (RetryCount == IDE_MAX_BUSY_RETRIES)
1144 {
1145 return IDE_ER_ABRT;
1146 }
1147
1148 /* Issue command to drive */
1149 if (DrvHead & IDE_DH_LBA)
1150 {
1151 DPRINT("READ:DRV=%d:LBA=1:BLK=%08d:SC=%02x:CM=%02x\n",
1152 DrvHead & IDE_DH_DRV1 ? 1 : 0,
1153 ((DrvHead & 0x0f) << 24) + (CylinderHigh << 16) + (CylinderLow << 8) + SectorNum,
1154 SectorCnt,
1155 Command);
1156 }
1157 else
1158 {
1159 DPRINT("READ:DRV=%d:LBA=0:CH=%02x:CL=%02x:HD=%01x:SN=%02x:SC=%02x:CM=%02x\n",
1160 DrvHead & IDE_DH_DRV1 ? 1 : 0,
1161 CylinderHigh,
1162 CylinderLow,
1163 DrvHead & 0x0f,
1164 SectorNum,
1165 SectorCnt,
1166 Command);
1167 }
1168
1169 /* Setup command parameters */
1170 IDEWritePrecomp(Address, PreComp);
1171 IDEWriteSectorCount(Address, SectorCnt);
1172 IDEWriteSectorNum(Address, SectorNum);
1173 IDEWriteCylinderHigh(Address, CylinderHigh);
1174 IDEWriteCylinderLow(Address, CylinderLow);
1175 IDEWriteDriveHead(Address, IDE_DH_FIXED | DrvHead);
1176
1177 /* Issue the command */
1178 IDEWriteCommand(Address, Command);
1179 KeStallExecutionProcessor(50);
1180
1181 /* wait for DRQ or error */
1182 for (RetryCount = 0; RetryCount < IDE_MAX_POLL_RETRIES; RetryCount++)
1183 {
1184 Status = IDEReadStatus(Address);
1185 if (!(Status & IDE_SR_BUSY))
1186 {
1187 if (Status & IDE_SR_ERR)
1188 {
1189 DPRINT("IDE_SR_ERR asserted!\n");
1190 }
1191 if ((Status & IDE_SR_DRQ) && !(Status & IDE_SR_ERR))
1192 {
1193 break;
1194 }
1195 else
1196 {
1197 return IDE_ER_ABRT;
1198 }
1199 }
1200 KeStallExecutionProcessor(10);
1201 }
1202 if (RetryCount >= IDE_MAX_POLL_RETRIES)
1203 {
1204 return IDE_ER_ABRT;
1205 }
1206
1207 while (1)
1208 {
1209 /* Read data into buffer */
1210 if (ReadJunk == TRUE)
1211 {
1212 UCHAR JunkBuffer[IDE_SECTOR_BUF_SZ];
1213 IDEReadBlock(Address, JunkBuffer, IDE_SECTOR_BUF_SZ);
1214 }
1215 else
1216 {
1217 IDEReadBlock(Address, Buffer, IDE_SECTOR_BUF_SZ);
1218 Buffer += IDE_SECTOR_BUF_SZ;
1219 }
1220 SectorCount++;
1221
1222 /* Check for more sectors to read */
1223 for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
1224 {
1225 Status = IDEReadStatus(Address);
1226 if (!(Status & IDE_SR_BUSY))
1227 {
1228 if (Status & IDE_SR_ERR)
1229 {
1230 DPRINT("IDE_SR_ERR asserted!\n");
1231 }
1232 if (Status & IDE_SR_DRQ)
1233 {
1234 if (SectorCount >= SectorCnt)
1235 ReadJunk = TRUE;
1236 break;
1237 }
1238 else
1239 {
1240 return 0;
1241 }
1242 }
1243 }
1244 }
1245 }
1246
1247 // ------------------------------------------- Nondiscardable statics
1248
1249 // IDEDispatchOpenClose
1250 //
1251 // DESCRIPTION:
1252 // Answer requests for Open/Close calls: a null operation
1253 //
1254 // RUN LEVEL:
1255 // PASSIVE_LEVEL
1256 //
1257 // ARGUMENTS:
1258 // Standard dispatch arguments
1259 //
1260 // RETURNS:
1261 // NTSTATUS
1262 //
1263
1264 static NTSTATUS STDCALL
1265 IDEDispatchOpenClose(IN PDEVICE_OBJECT pDO,
1266 IN PIRP Irp)
1267 {
1268 Irp->IoStatus.Status = STATUS_SUCCESS;
1269 Irp->IoStatus.Information = FILE_OPENED;
1270 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1271
1272 return STATUS_SUCCESS;
1273 }
1274
1275 // IDEDispatchReadWrite
1276 //
1277 // DESCRIPTION:
1278 // Answer requests for reads and writes
1279 //
1280 // RUN LEVEL:
1281 // PASSIVE_LEVEL
1282 //
1283 // ARGUMENTS:
1284 // Standard dispatch arguments
1285 //
1286 // RETURNS:
1287 // NTSTATUS
1288 //
1289
1290 static NTSTATUS STDCALL
1291 IDEDispatchReadWrite(IN PDEVICE_OBJECT DeviceObject,
1292 IN PIRP Irp)
1293 {
1294 ULONG IrpInsertKey;
1295 LARGE_INTEGER AdjustedOffset, AdjustedExtent, PartitionExtent, InsertKeyLI;
1296 PIO_STACK_LOCATION IrpStack;
1297 PIDE_DEVICE_EXTENSION DeviceExtension;
1298
1299 IrpStack = IoGetCurrentIrpStackLocation(Irp);
1300 DeviceExtension = (PIDE_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1301
1302 // Validate operation parameters
1303 AdjustedOffset.QuadPart = DeviceExtension->StartingOffset.QuadPart +
1304 IrpStack->Parameters.Read.ByteOffset.QuadPart;
1305 DPRINT("AdjustedOffset: %I64x\n", AdjustedOffset.QuadPart);
1306
1307 AdjustedExtent.QuadPart = AdjustedOffset.QuadPart +
1308 (ULONGLONG)IrpStack->Parameters.Read.Length;
1309 DPRINT("AdjustedExtent: %I64x\n", AdjustedExtent.QuadPart);
1310
1311 PartitionExtent.QuadPart = DeviceExtension->StartingOffset.QuadPart +
1312 DeviceExtension->PartitionLength.QuadPart;
1313 DPRINT("PartitionExtent: %I64x\n", PartitionExtent.QuadPart);
1314
1315 if ((AdjustedExtent.QuadPart > PartitionExtent.QuadPart) ||
1316 (IrpStack->Parameters.Read.Length & (DeviceExtension->BytesPerSector - 1)))
1317 {
1318 DPRINT("Request failed on bad parameters\n",0);
1319 DPRINT("AdjustedExtent=%I64x PartitionExtent=%I64x ReadLength=%lx\n",
1320 AdjustedExtent.QuadPart,
1321 PartitionExtent.QuadPart,
1322 IrpStack->Parameters.Read.Length);
1323 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
1324 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1325 return STATUS_INVALID_PARAMETER;
1326 }
1327
1328 // Adjust operation to absolute sector offset
1329 IrpStack->Parameters.Read.ByteOffset = AdjustedOffset;
1330
1331 // Start the packet and insert the request in order of sector offset
1332 assert(DeviceExtension->BytesPerSector == 512);
1333 InsertKeyLI.QuadPart = IrpStack->Parameters.Read.ByteOffset.QuadPart >> 9;
1334 IrpInsertKey = InsertKeyLI.u.LowPart;
1335 IoStartPacket(DeviceObject, Irp, &IrpInsertKey, NULL);
1336
1337 DPRINT("Returning STATUS_PENDING\n");
1338 return STATUS_PENDING;
1339 }
1340
1341 // IDEDispatchDeviceControl
1342 //
1343 // DESCRIPTION:
1344 // Answer requests for device control calls
1345 //
1346 // RUN LEVEL:
1347 // PASSIVE_LEVEL
1348 //
1349 // ARGUMENTS:
1350 // Standard dispatch arguments
1351 //
1352 // RETURNS:
1353 // NTSTATUS
1354 //
1355
1356 static NTSTATUS STDCALL
1357 IDEDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject,
1358 IN PIRP Irp)
1359 {
1360 NTSTATUS RC;
1361 ULONG ControlCode, InputLength, OutputLength;
1362 PIO_STACK_LOCATION IrpStack;
1363 PIDE_DEVICE_EXTENSION DeviceExtension;
1364 PIDE_DEVICE_EXTENSION DiskDeviceExtension;
1365 CCHAR Increment;
1366
1367 RC = STATUS_SUCCESS;
1368 IrpStack = IoGetCurrentIrpStackLocation(Irp);
1369 ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
1370 InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
1371 OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
1372 DeviceExtension = (PIDE_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
1373 DiskDeviceExtension = (PIDE_DEVICE_EXTENSION)DeviceExtension->DiskDeviceExtension;
1374 Increment = IO_NO_INCREMENT;
1375
1376 // A huge switch statement in a Windows program?! who would have thought?
1377 switch (ControlCode)
1378 {
1379 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
1380 if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY))
1381 {
1382 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
1383 }
1384 else
1385 {
1386 PDISK_GEOMETRY Geometry;
1387
1388 Geometry = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
1389
1390 Geometry->MediaType = FixedMedia;
1391 Geometry->Cylinders.QuadPart = DiskDeviceExtension->LogicalCylinders;
1392 Geometry->TracksPerCylinder = DiskDeviceExtension->SectorsPerLogCyl /
1393 DiskDeviceExtension->SectorsPerLogTrk;
1394 Geometry->SectorsPerTrack = DiskDeviceExtension->SectorsPerLogTrk;
1395 Geometry->BytesPerSector = DiskDeviceExtension->BytesPerSector;
1396 DPRINT("DiskDeviceExtension->BytesPerSector %lu\n", DiskDeviceExtension->BytesPerSector);
1397 Irp->IoStatus.Status = STATUS_SUCCESS;
1398 Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
1399 }
1400 break;
1401
1402 case IOCTL_DISK_GET_PARTITION_INFO:
1403 DPRINT("IOCTL_DISK_GET_PARTITION_INFO\n");
1404 if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
1405 sizeof(PARTITION_INFORMATION))
1406 {
1407 Irp->IoStatus.Status = STATUS_INFO_LENGTH_MISMATCH;
1408 }
1409 else if (DeviceExtension->PartitionNumber == 0)
1410 {
1411 Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
1412 }
1413 else
1414 {
1415 PPARTITION_INFORMATION PartitionInfo;
1416
1417 PartitionInfo = (PPARTITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
1418
1419 PartitionInfo->PartitionType = DeviceExtension->PartitionType;
1420 PartitionInfo->StartingOffset = DeviceExtension->StartingOffset;
1421 PartitionInfo->PartitionLength = DeviceExtension->PartitionLength;
1422 PartitionInfo->HiddenSectors = DeviceExtension->HiddenSectors;
1423 PartitionInfo->PartitionNumber = DeviceExtension->PartitionNumber;
1424 PartitionInfo->BootIndicator = DeviceExtension->BootIndicator;
1425 PartitionInfo->RewritePartition = FALSE;
1426 PartitionInfo->RecognizedPartition =
1427 IsRecognizedPartition(DeviceExtension->PartitionType);
1428
1429 Irp->IoStatus.Status = STATUS_SUCCESS;
1430 Irp->IoStatus.Information = sizeof(PARTITION_INFORMATION);
1431 }
1432 break;
1433
1434 case IOCTL_DISK_SET_PARTITION_INFO:
1435 RC = STATUS_INVALID_DEVICE_REQUEST;
1436 Irp->IoStatus.Status = RC;
1437 Irp->IoStatus.Information = 0;
1438 break;
1439
1440 case IOCTL_DISK_GET_DRIVE_LAYOUT:
1441 if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength <
1442 sizeof(DRIVE_LAYOUT_INFORMATION))
1443 {
1444 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
1445 }
1446 else
1447 {
1448 PDRIVE_LAYOUT_INFORMATION PartitionList;
1449
1450 RC = IoReadPartitionTable(DiskDeviceExtension->DeviceObject,
1451 DiskDeviceExtension->BytesPerSector,
1452 FALSE,
1453 &PartitionList);
1454 if (!NT_SUCCESS(RC))
1455 {
1456 Irp->IoStatus.Status = RC;
1457 }
1458 else
1459 {
1460 ULONG BufferSize;
1461
1462 BufferSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION,
1463 PartitionEntry[0]);
1464 BufferSize += PartitionList->PartitionCount * sizeof(PARTITION_INFORMATION);
1465
1466 if (BufferSize > IrpStack->Parameters.DeviceIoControl.OutputBufferLength)
1467 {
1468 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
1469 }
1470 else
1471 {
1472 RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
1473 PartitionList,
1474 BufferSize);
1475 Irp->IoStatus.Status = STATUS_SUCCESS;
1476 Irp->IoStatus.Information = BufferSize;
1477 }
1478 ExFreePool(PartitionList);
1479 }
1480 }
1481 Increment = IO_DISK_INCREMENT;
1482 break;
1483
1484 case IOCTL_DISK_SET_DRIVE_LAYOUT:
1485 case IOCTL_DISK_VERIFY:
1486 case IOCTL_DISK_FORMAT_TRACKS:
1487 case IOCTL_DISK_PERFORMANCE:
1488 case IOCTL_DISK_IS_WRITABLE:
1489 case IOCTL_DISK_LOGGING:
1490 case IOCTL_DISK_FORMAT_TRACKS_EX:
1491 case IOCTL_DISK_HISTOGRAM_STRUCTURE:
1492 case IOCTL_DISK_HISTOGRAM_DATA:
1493 case IOCTL_DISK_HISTOGRAM_RESET:
1494 case IOCTL_DISK_REQUEST_STRUCTURE:
1495 case IOCTL_DISK_REQUEST_DATA:
1496
1497 // If we get here, something went wrong. inform the requestor
1498 default:
1499 RC = STATUS_INVALID_DEVICE_REQUEST;
1500 Irp->IoStatus.Status = RC;
1501 Irp->IoStatus.Information = 0;
1502 break;
1503 }
1504
1505 IoCompleteRequest(Irp, Increment);
1506
1507 return RC;
1508 }
1509
1510 // IDEStartIo
1511 //
1512 // DESCRIPTION:
1513 // Get the next requested I/O packet started
1514 //
1515 // RUN LEVEL:
1516 // DISPATCH_LEVEL
1517 //
1518 // ARGUMENTS:
1519 // Dispatch routine standard arguments
1520 //
1521 // RETURNS:
1522 // NTSTATUS
1523 //
1524
1525 static VOID
1526 STDCALL IDEStartIo(IN PDEVICE_OBJECT DeviceObject,
1527 IN PIRP Irp)
1528 {
1529 LARGE_INTEGER SectorLI;
1530 PIO_STACK_LOCATION IrpStack;
1531 PIDE_DEVICE_EXTENSION DeviceExtension;
1532 KIRQL OldIrql;
1533
1534 DPRINT("IDEStartIo() called!\n");
1535
1536 IrpStack = IoGetCurrentIrpStackLocation(Irp);
1537 DeviceExtension = (PIDE_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
1538
1539 // FIXME: implement the supported functions
1540
1541 switch (IrpStack->MajorFunction)
1542 {
1543 case IRP_MJ_READ:
1544 case IRP_MJ_WRITE:
1545 DeviceExtension->Operation = IrpStack->MajorFunction;
1546 DeviceExtension->BytesRequested = IrpStack->Parameters.Read.Length;
1547 assert(DeviceExtension->BytesPerSector == 512);
1548 SectorLI = RtlLargeIntegerShiftRight(IrpStack->Parameters.Read.ByteOffset, 9);
1549 DeviceExtension->StartingSector = SectorLI.u.LowPart;
1550 if (DeviceExtension->BytesRequested > DeviceExtension->BytesPerSector *
1551 IDE_MAX_SECTORS_PER_XFER)
1552 {
1553 DeviceExtension->BytesToTransfer = DeviceExtension->BytesPerSector *
1554 IDE_MAX_SECTORS_PER_XFER;
1555 }
1556 else
1557 {
1558 DeviceExtension->BytesToTransfer = DeviceExtension->BytesRequested;
1559 }
1560 DeviceExtension->BytesRequested -= DeviceExtension->BytesToTransfer;
1561 DeviceExtension->SectorsTransferred = 0;
1562 DeviceExtension->TargetAddress = (BYTE *)MmGetSystemAddressForMdl(Irp->MdlAddress);
1563 KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
1564 IoAllocateController(DeviceExtension->ControllerObject,
1565 DeviceObject,
1566 IDEAllocateController,
1567 NULL);
1568 KeLowerIrql(OldIrql);
1569 break;
1570
1571 default:
1572 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
1573 Irp->IoStatus.Information = 0;
1574 KeBugCheck((ULONG)Irp);
1575 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1576 IoStartNextPacket(DeviceObject, FALSE);
1577 break;
1578 }
1579 DPRINT("IDEStartIo() finished!\n");
1580 }
1581
1582 // IDEAllocateController
1583
1584 static IO_ALLOCATION_ACTION STDCALL
1585 IDEAllocateController(IN PDEVICE_OBJECT DeviceObject,
1586 IN PIRP Irp,
1587 IN PVOID MapRegisterBase,
1588 IN PVOID Ccontext)
1589 {
1590 PIDE_DEVICE_EXTENSION DeviceExtension;
1591 PIDE_CONTROLLER_EXTENSION ControllerExtension;
1592
1593 DeviceExtension = (PIDE_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
1594 ControllerExtension = (PIDE_CONTROLLER_EXTENSION)
1595 DeviceExtension->ControllerObject->ControllerExtension;
1596 ControllerExtension->CurrentIrp = Irp;
1597 ControllerExtension->Retries = 0;
1598 return KeSynchronizeExecution(ControllerExtension->Interrupt,
1599 IDEStartController,
1600 DeviceExtension) ? KeepObject :
1601 DeallocateObject;
1602 }
1603
1604 // IDEStartController
1605
1606 BOOLEAN STDCALL
1607 IDEStartController(IN OUT PVOID Context)
1608 {
1609 BYTE SectorCnt, SectorNum, CylinderLow, CylinderHigh;
1610 BYTE DrvHead, Command;
1611 BYTE Status;
1612 int Retries;
1613 ULONG StartingSector;
1614 PIDE_DEVICE_EXTENSION DeviceExtension;
1615 PIDE_CONTROLLER_EXTENSION ControllerExtension;
1616 PIRP Irp;
1617
1618 DeviceExtension = (PIDE_DEVICE_EXTENSION) Context;
1619 ControllerExtension = (PIDE_CONTROLLER_EXTENSION)
1620 DeviceExtension->ControllerObject->ControllerExtension;
1621 ControllerExtension->OperationInProgress = TRUE;
1622 ControllerExtension->DeviceForOperation = DeviceExtension;
1623
1624 // Write controller registers to start opteration
1625 StartingSector = DeviceExtension->StartingSector;
1626 SectorCnt = DeviceExtension->BytesToTransfer /
1627 DeviceExtension->BytesPerSector;
1628 if (DeviceExtension->LBASupported)
1629 {
1630 SectorNum = StartingSector & 0xff;
1631 CylinderLow = (StartingSector >> 8) & 0xff;
1632 CylinderHigh = (StartingSector >> 16) & 0xff;
1633 DrvHead = ((StartingSector >> 24) & 0x0f) |
1634 (DeviceExtension->UnitNumber ? IDE_DH_DRV1 : 0) |
1635 IDE_DH_LBA;
1636 }
1637 else
1638 {
1639 SectorNum = (StartingSector % DeviceExtension->SectorsPerLogTrk) + 1;
1640 StartingSector /= DeviceExtension->SectorsPerLogTrk;
1641 DrvHead = (StartingSector % DeviceExtension->LogicalHeads) |
1642 (DeviceExtension->UnitNumber ? IDE_DH_DRV1 : 0);
1643 StartingSector /= DeviceExtension->LogicalHeads;
1644 CylinderLow = StartingSector & 0xff;
1645 CylinderHigh = StartingSector >> 8;
1646 }
1647 Command = DeviceExtension->Operation == IRP_MJ_READ ?
1648 IDE_CMD_READ : IDE_CMD_WRITE;
1649 if (DrvHead & IDE_DH_LBA)
1650 {
1651 DPRINT("%s:BUS=%04x:DRV=%d:LBA=1:BLK=%08d:SC=%02x:CM=%02x\n",
1652 DeviceExtension->Operation == IRP_MJ_READ ? "READ" : "WRITE",
1653 ControllerExtension->CommandPortBase,
1654 DrvHead & IDE_DH_DRV1 ? 1 : 0,
1655 ((DrvHead & 0x0f) << 24) +
1656 (CylinderHigh << 16) + (CylinderLow << 8) + SectorNum,
1657 SectorCnt,
1658 Command);
1659 }
1660 else
1661 {
1662 DPRINT("%s:BUS=%04x:DRV=%d:LBA=0:CH=%02x:CL=%02x:HD=%01x:SN=%02x:SC=%02x:CM=%02x\n",
1663 DeviceExtension->Operation == IRP_MJ_READ ? "READ" : "WRITE",
1664 ControllerExtension->CommandPortBase,
1665 DrvHead & IDE_DH_DRV1 ? 1 : 0,
1666 CylinderHigh,
1667 CylinderLow,
1668 DrvHead & 0x0f,
1669 SectorNum,
1670 SectorCnt,
1671 Command);
1672 }
1673
1674 /* wait for BUSY to clear */
1675 for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
1676 {
1677 Status = IDEReadStatus(ControllerExtension->CommandPortBase);
1678 if (!(Status & IDE_SR_BUSY))
1679 {
1680 break;
1681 }
1682 KeStallExecutionProcessor(10);
1683 }
1684 DPRINT ("status=%02x\n", Status);
1685 DPRINT ("waited %ld usecs for busy to clear\n", Retries * 10);
1686 if (Retries >= IDE_MAX_BUSY_RETRIES)
1687 {
1688 DPRINT ("Drive is BUSY for too long\n");
1689 if (++ControllerExtension->Retries > IDE_MAX_CMD_RETRIES)
1690 {
1691 DbgPrint ("Max Retries on Drive reset reached, returning failure\n");
1692 Irp = ControllerExtension->CurrentIrp;
1693 Irp->IoStatus.Status = STATUS_DISK_OPERATION_FAILED;
1694 Irp->IoStatus.Information = 0;
1695
1696 return FALSE;
1697 }
1698 else
1699 {
1700 DPRINT ("Beginning drive reset sequence\n");
1701 IDEBeginControllerReset(ControllerExtension);
1702
1703 return TRUE;
1704 }
1705 }
1706
1707 /* Select the desired drive */
1708 IDEWriteDriveHead(ControllerExtension->CommandPortBase, IDE_DH_FIXED | DrvHead);
1709
1710 /* wait for BUSY to clear and DRDY to assert */
1711 for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
1712 {
1713 Status = IDEReadStatus(ControllerExtension->CommandPortBase);
1714 // if (!(Status & IDE_SR_BUSY) && (Status & IDE_SR_DRDY))
1715 if (!(Status & IDE_SR_BUSY) && !(Status & IDE_SR_DRQ))
1716 {
1717 break;
1718 }
1719 KeStallExecutionProcessor(10);
1720 }
1721 DPRINT ("waited %ld usecs for busy to clear after drive select\n", Retries * 10);
1722 if (Retries >= IDE_MAX_BUSY_RETRIES)
1723 {
1724 DPRINT ("Drive is BUSY for too long after drive select\n");
1725 if (ControllerExtension->Retries++ > IDE_MAX_CMD_RETRIES)
1726 {
1727 DbgPrint ("Max Retries on Drive reset reached, returning failure\n");
1728 Irp = ControllerExtension->CurrentIrp;
1729 Irp->IoStatus.Status = STATUS_DISK_OPERATION_FAILED;
1730 Irp->IoStatus.Information = 0;
1731
1732 return FALSE;
1733 }
1734 else
1735 {
1736 DPRINT ("Beginning drive reset sequence\n");
1737 IDEBeginControllerReset(ControllerExtension);
1738
1739 return TRUE;
1740 }
1741 }
1742
1743 /* Setup command parameters */
1744 IDEWritePrecomp(ControllerExtension->CommandPortBase, 0);
1745 IDEWriteSectorCount(ControllerExtension->CommandPortBase, SectorCnt);
1746 IDEWriteSectorNum(ControllerExtension->CommandPortBase, SectorNum);
1747 IDEWriteCylinderHigh(ControllerExtension->CommandPortBase, CylinderHigh);
1748 IDEWriteCylinderLow(ControllerExtension->CommandPortBase, CylinderLow);
1749 IDEWriteDriveHead(ControllerExtension->CommandPortBase, IDE_DH_FIXED | DrvHead);
1750
1751 /* Issue command to drive */
1752 IDEWriteCommand(ControllerExtension->CommandPortBase, Command);
1753 ControllerExtension->TimerState = IDETimerCmdWait;
1754 ControllerExtension->TimerCount = IDE_CMD_TIMEOUT;
1755
1756 if (DeviceExtension->Operation == IRP_MJ_WRITE)
1757 {
1758
1759 // Wait for controller ready
1760 for (Retries = 0; Retries < IDE_MAX_WRITE_RETRIES; Retries++)
1761 {
1762 BYTE Status = IDEReadStatus(ControllerExtension->CommandPortBase);
1763 if (!(Status & IDE_SR_BUSY) || (Status & IDE_SR_ERR))
1764 {
1765 break;
1766 }
1767 KeStallExecutionProcessor(10);
1768 }
1769 if (Retries >= IDE_MAX_BUSY_RETRIES)
1770 {
1771 if (ControllerExtension->Retries++ > IDE_MAX_CMD_RETRIES)
1772 {
1773 Irp = ControllerExtension->CurrentIrp;
1774 Irp->IoStatus.Status = STATUS_DISK_OPERATION_FAILED;
1775 Irp->IoStatus.Information = 0;
1776
1777 return FALSE;
1778 }
1779 else
1780 {
1781 IDEBeginControllerReset(ControllerExtension);
1782
1783 return TRUE;
1784 }
1785 }
1786
1787 // Load the first sector of data into the controller
1788 IDEWriteBlock(ControllerExtension->CommandPortBase,
1789 DeviceExtension->TargetAddress,
1790 IDE_SECTOR_BUF_SZ);
1791 DeviceExtension->TargetAddress += IDE_SECTOR_BUF_SZ;
1792 DeviceExtension->BytesToTransfer -= DeviceExtension->BytesPerSector;
1793 DeviceExtension->SectorsTransferred++;
1794 }
1795 DPRINT ("Command issued to drive, IDEStartController done\n");
1796
1797 return TRUE;
1798 }
1799
1800 // IDEBeginControllerReset
1801
1802 VOID
1803 IDEBeginControllerReset(PIDE_CONTROLLER_EXTENSION ControllerExtension)
1804 {
1805 int Retries;
1806
1807 DPRINT("Controller Reset initiated on %04x\n",
1808 ControllerExtension->ControlPortBase);
1809
1810 /* Assert drive reset line */
1811 DPRINT("Asserting reset line\n");
1812 IDEWriteDriveControl(ControllerExtension->ControlPortBase, IDE_DC_SRST);
1813
1814 /* Wait for BSY assertion */
1815 DPRINT("Waiting for BSY assertion\n");
1816 for (Retries = 0; Retries < IDE_MAX_RESET_RETRIES; Retries++)
1817 {
1818 BYTE Status = IDEReadStatus(ControllerExtension->CommandPortBase);
1819 if ((Status & IDE_SR_BUSY))
1820 {
1821 break;
1822 }
1823 KeStallExecutionProcessor(10);
1824 }
1825 if (Retries == IDE_MAX_RESET_RETRIES)
1826 {
1827 DPRINT("Timeout on BSY assertion\n");
1828 }
1829
1830 /* Negate drive reset line */
1831 DPRINT("Negating reset line\n");
1832 IDEWriteDriveControl(ControllerExtension->ControlPortBase, 0);
1833
1834 // FIXME: handle case of no device 0
1835
1836 /* Set timer to check for end of reset */
1837 ControllerExtension->TimerState = IDETimerResetWaitForBusyNegate;
1838 ControllerExtension->TimerCount = IDE_RESET_BUSY_TIMEOUT;
1839 }
1840
1841 // IDEIsr
1842 //
1843 // DESCIPTION:
1844 // Handle interrupts for IDE devices
1845 //
1846 // RUN LEVEL:
1847 // DIRQL
1848 //
1849 // ARGUMENTS:
1850 // IN PKINTERRUPT Interrupt The interrupt level in effect
1851 // IN PVOID ServiceContext The driver supplied context
1852 // (the controller extension)
1853 // RETURNS:
1854 // TRUE This ISR handled the interrupt
1855 // FALSE Another ISR must handle this interrupt
1856
1857 static BOOLEAN STDCALL
1858 IDEIsr(IN PKINTERRUPT Interrupt,
1859 IN PVOID ServiceContext)
1860 {
1861 BOOLEAN IsLastBlock, AnErrorOccured, RequestIsComplete;
1862 BYTE *TargetAddress;
1863 int Retries;
1864 NTSTATUS ErrorStatus;
1865 ULONG ErrorInformation;
1866 PIRP Irp;
1867 PIDE_DEVICE_EXTENSION DeviceExtension;
1868 PIDE_CONTROLLER_EXTENSION ControllerExtension;
1869
1870 if (IDEInitialized == FALSE)
1871 {
1872 return FALSE;
1873 }
1874 DPRINT ("IDEIsr called\n");
1875
1876 ControllerExtension = (PIDE_CONTROLLER_EXTENSION) ServiceContext;
1877
1878 // Read the status port to clear the interrtupt (even if it's not ours).
1879 ControllerExtension->DeviceStatus = IDEReadStatus(ControllerExtension->CommandPortBase);
1880
1881 // If the interrupt is not ours, get the heck outta dodge.
1882 if (!ControllerExtension->OperationInProgress)
1883 {
1884 return FALSE;
1885 }
1886
1887 DeviceExtension = ControllerExtension->DeviceForOperation;
1888 IsLastBlock = FALSE;
1889 AnErrorOccured = FALSE;
1890 RequestIsComplete = FALSE;
1891 ErrorStatus = STATUS_SUCCESS;
1892 ErrorInformation = 0;
1893
1894 // Handle error condition if it exists
1895 if (ControllerExtension->DeviceStatus & IDE_SR_ERR)
1896 {
1897 BYTE ErrorReg, SectorCount, SectorNum, CylinderLow, CylinderHigh;
1898 BYTE DriveHead;
1899
1900 // Log the error
1901 ErrorReg = IDEReadError(ControllerExtension->CommandPortBase);
1902 CylinderLow = IDEReadCylinderLow(ControllerExtension->CommandPortBase);
1903 CylinderHigh = IDEReadCylinderHigh(ControllerExtension->CommandPortBase);
1904 DriveHead = IDEReadDriveHead(ControllerExtension->CommandPortBase);
1905 SectorCount = IDEReadSectorCount(ControllerExtension->CommandPortBase);
1906 SectorNum = IDEReadSectorNum(ControllerExtension->CommandPortBase);
1907 // FIXME: should use the NT error logging facility
1908 DbgPrint ("IDE Error: OP:%02x STAT:%02x ERR:%02x CYLLO:%02x CYLHI:%02x SCNT:%02x SNUM:%02x\n",
1909 DeviceExtension->Operation,
1910 ControllerExtension->DeviceStatus,
1911 ErrorReg,
1912 CylinderLow,
1913 CylinderHigh,
1914 SectorCount,
1915 SectorNum);
1916
1917 // FIXME: should retry the command and perhaps recalibrate the drive
1918
1919 // Set error status information
1920 AnErrorOccured = TRUE;
1921 ErrorStatus = STATUS_DISK_OPERATION_FAILED;
1922 ErrorInformation =
1923 (((((((CylinderHigh << 8) + CylinderLow) *
1924 DeviceExtension->LogicalHeads) +
1925 (DriveHead % DeviceExtension->LogicalHeads)) *
1926 DeviceExtension->SectorsPerLogTrk) + SectorNum - 1) -
1927 DeviceExtension->StartingSector) * DeviceExtension->BytesPerSector;
1928 }
1929 else
1930 {
1931
1932 // Check controller and setup for next transfer
1933 switch (DeviceExtension->Operation)
1934 {
1935 case IRP_MJ_READ:
1936
1937 // Update controller/device state variables
1938 TargetAddress = DeviceExtension->TargetAddress;
1939 DeviceExtension->TargetAddress += DeviceExtension->BytesPerSector;
1940 DeviceExtension->BytesToTransfer -= DeviceExtension->BytesPerSector;
1941 DeviceExtension->SectorsTransferred++;
1942
1943 // Remember whether DRQ should be low at end (last block read)
1944 IsLastBlock = DeviceExtension->BytesToTransfer == 0;
1945
1946 // Wait for DRQ assertion
1947 for (Retries = 0; Retries < IDE_MAX_DRQ_RETRIES &&
1948 !(IDEReadStatus(ControllerExtension->CommandPortBase) & IDE_SR_DRQ);
1949 Retries++)
1950 {
1951 KeStallExecutionProcessor(10);
1952 }
1953
1954 // Copy the block of data
1955 IDEReadBlock(ControllerExtension->CommandPortBase,
1956 TargetAddress,
1957 IDE_SECTOR_BUF_SZ);
1958
1959 // check DRQ
1960 if (IsLastBlock)
1961 {
1962 for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES &&
1963 (IDEReadStatus(ControllerExtension->CommandPortBase) & IDE_SR_BUSY);
1964 Retries++)
1965 {
1966 KeStallExecutionProcessor(10);
1967 }
1968
1969 // Check for data overrun
1970 if (IDEReadStatus(ControllerExtension->CommandPortBase) & IDE_SR_DRQ)
1971 {
1972 AnErrorOccured = TRUE;
1973 ErrorStatus = STATUS_DATA_OVERRUN;
1974 ErrorInformation = 0;
1975 }
1976 else
1977 {
1978
1979 // Setup next transfer or set RequestIsComplete
1980 if (DeviceExtension->BytesRequested >
1981 DeviceExtension->BytesPerSector * IDE_MAX_SECTORS_PER_XFER)
1982 {
1983 DeviceExtension->StartingSector += DeviceExtension->SectorsTransferred;
1984 DeviceExtension->SectorsTransferred = 0;
1985 DeviceExtension->BytesToTransfer =
1986 DeviceExtension->BytesPerSector * IDE_MAX_SECTORS_PER_XFER;
1987 DeviceExtension->BytesRequested -= DeviceExtension->BytesToTransfer;
1988 }
1989 else if (DeviceExtension->BytesRequested > 0)
1990 {
1991 DeviceExtension->StartingSector += DeviceExtension->SectorsTransferred;
1992 DeviceExtension->SectorsTransferred = 0;
1993 DeviceExtension->BytesToTransfer = DeviceExtension->BytesRequested;
1994 DeviceExtension->BytesRequested -= DeviceExtension->BytesToTransfer;
1995 }
1996 else
1997 {
1998 RequestIsComplete = TRUE;
1999 }
2000 }
2001 }
2002 break;
2003
2004 case IRP_MJ_WRITE:
2005
2006 // check DRQ
2007 if (DeviceExtension->BytesToTransfer == 0)
2008 {
2009 for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES &&
2010 (IDEReadStatus(ControllerExtension->CommandPortBase) & IDE_SR_BUSY);
2011 Retries++)
2012 {
2013 KeStallExecutionProcessor(10);
2014 }
2015
2016 // Check for data overrun
2017 if (IDEReadStatus(ControllerExtension->CommandPortBase) & IDE_SR_DRQ)
2018 {
2019 AnErrorOccured = TRUE;
2020 ErrorStatus = STATUS_DATA_OVERRUN;
2021 ErrorInformation = 0;
2022 }
2023 else
2024 {
2025
2026 // Setup next transfer or set RequestIsComplete
2027 IsLastBlock = TRUE;
2028 if (DeviceExtension->BytesRequested >
2029 DeviceExtension->BytesPerSector * IDE_MAX_SECTORS_PER_XFER)
2030 {
2031 DeviceExtension->StartingSector += DeviceExtension->SectorsTransferred;
2032 DeviceExtension->SectorsTransferred = 0;
2033 DeviceExtension->BytesToTransfer =
2034 DeviceExtension->BytesPerSector * IDE_MAX_SECTORS_PER_XFER;
2035 DeviceExtension->BytesRequested -= DeviceExtension->BytesToTransfer;
2036 }
2037 else if (DeviceExtension->BytesRequested > 0)
2038 {
2039 DeviceExtension->StartingSector += DeviceExtension->SectorsTransferred;
2040 DeviceExtension->SectorsTransferred = 0;
2041 DeviceExtension->BytesToTransfer = DeviceExtension->BytesRequested;
2042 DeviceExtension->BytesRequested -= DeviceExtension->BytesToTransfer;
2043 }
2044 else
2045 {
2046 RequestIsComplete = TRUE;
2047 }
2048 }
2049 }
2050 else
2051 {
2052
2053 // Update controller/device state variables
2054 TargetAddress = DeviceExtension->TargetAddress;
2055 DeviceExtension->TargetAddress += DeviceExtension->BytesPerSector;
2056 DeviceExtension->BytesToTransfer -= DeviceExtension->BytesPerSector;
2057 DeviceExtension->SectorsTransferred++;
2058
2059 // Write block to controller
2060 IDEWriteBlock(ControllerExtension->CommandPortBase,
2061 TargetAddress,
2062 IDE_SECTOR_BUF_SZ);
2063 }
2064 break;
2065 }
2066 }
2067
2068 // If there was an error or the request is done, complete the packet
2069 if (AnErrorOccured || RequestIsComplete)
2070 {
2071 // Set the return status and info values
2072 Irp = ControllerExtension->CurrentIrp;
2073 Irp->IoStatus.Status = ErrorStatus;
2074 Irp->IoStatus.Information = ErrorInformation;
2075
2076 // Clear out controller fields
2077 ControllerExtension->OperationInProgress = FALSE;
2078 ControllerExtension->DeviceStatus = 0;
2079
2080 // Queue the Dpc to finish up
2081 IoRequestDpc(DeviceExtension->DeviceObject,
2082 Irp,
2083 ControllerExtension);
2084 }
2085 else if (IsLastBlock)
2086 {
2087 // Else more data is needed, setup next device I/O
2088 IDEStartController((PVOID)DeviceExtension);
2089 }
2090
2091 return TRUE;
2092 }
2093
2094 // IDEDpcForIsr
2095 // DESCRIPTION:
2096 //
2097 // RUN LEVEL:
2098 //
2099 // ARGUMENTS:
2100 // IN PKDPC Dpc
2101 // IN PDEVICE_OBJECT DpcDeviceObject
2102 // IN PIRP DpcIrp
2103 // IN PVOID DpcContext
2104 //
2105 static VOID
2106 IDEDpcForIsr(IN PKDPC Dpc,
2107 IN PDEVICE_OBJECT DpcDeviceObject,
2108 IN PIRP DpcIrp,
2109 IN PVOID DpcContext)
2110 {
2111 DPRINT("IDEDpcForIsr()\n");
2112 IDEFinishOperation((PIDE_CONTROLLER_EXTENSION) DpcContext);
2113 }
2114
2115 // IDEFinishOperation
2116
2117 static VOID
2118 IDEFinishOperation(PIDE_CONTROLLER_EXTENSION ControllerExtension)
2119 {
2120 PIDE_DEVICE_EXTENSION DeviceExtension;
2121 PIRP Irp;
2122 ULONG Operation;
2123
2124 DeviceExtension = ControllerExtension->DeviceForOperation;
2125 Irp = ControllerExtension->CurrentIrp;
2126 Operation = DeviceExtension->Operation;
2127 ControllerExtension->OperationInProgress = FALSE;
2128 ControllerExtension->DeviceForOperation = 0;
2129 ControllerExtension->CurrentIrp = 0;
2130
2131 // Deallocate the controller
2132 IoFreeController(DeviceExtension->ControllerObject);
2133
2134 // Start the next packet
2135 IoStartNextPacketByKey(DeviceExtension->DeviceObject,
2136 FALSE,
2137 DeviceExtension->StartingSector);
2138
2139 // Flush cache if necessary
2140 if (Operation == IRP_MJ_READ)
2141 {
2142 KeFlushIoBuffers(Irp->MdlAddress, TRUE, FALSE);
2143 }
2144 // Issue completion of the current packet
2145 // return status information too
2146 Irp->IoStatus.Status = STATUS_SUCCESS;
2147 Irp->IoStatus.Information = DeviceExtension->SectorsTransferred * DeviceExtension->BytesPerSector;
2148 IoCompleteRequest(Irp, IO_DISK_INCREMENT);
2149 }
2150
2151 // IDEIoTimer
2152 // DESCRIPTION:
2153 // This function handles timeouts and other time delayed processing
2154 //
2155 // RUN LEVEL:
2156 //
2157 // ARGUMENTS:
2158 // IN PDEVICE_OBJECT DeviceObject Device object registered with timer
2159 // IN PVOID Context the Controller extension for the
2160 // controller the device is on
2161 //
2162 static VOID STDCALL
2163 IDEIoTimer(PDEVICE_OBJECT DeviceObject,
2164 PVOID Context)
2165 {
2166 PIDE_CONTROLLER_EXTENSION ControllerExtension;
2167
2168 // Setup Extension pointer
2169 ControllerExtension = (PIDE_CONTROLLER_EXTENSION) Context;
2170 DPRINT("Timer activated for %04lx\n", ControllerExtension->CommandPortBase);
2171
2172 // Handle state change if necessary
2173 switch (ControllerExtension->TimerState)
2174 {
2175 case IDETimerResetWaitForBusyNegate:
2176 if (!(IDEReadStatus(ControllerExtension->CommandPortBase) &
2177 IDE_SR_BUSY))
2178 {
2179 DPRINT("Busy line has negated, waiting for DRDY assert\n");
2180 ControllerExtension->TimerState = IDETimerResetWaitForDrdyAssert;
2181 ControllerExtension->TimerCount = IDE_RESET_DRDY_TIMEOUT;
2182 return;
2183 }
2184 break;
2185
2186 case IDETimerResetWaitForDrdyAssert:
2187 if (IDEReadStatus(ControllerExtension->CommandPortBase) &
2188 IDE_SR_DRQ)
2189 {
2190 DPRINT("DRDY has asserted, reset complete\n");
2191 ControllerExtension->TimerState = IDETimerIdle;
2192 ControllerExtension->TimerCount = 0;
2193
2194 // FIXME: get diagnostic code from drive 0
2195
2196 /* Start current packet command again */
2197 if (!KeSynchronizeExecution(ControllerExtension->Interrupt,
2198 IDEStartController,
2199 ControllerExtension->DeviceForOperation))
2200 {
2201 IDEFinishOperation(ControllerExtension);
2202 }
2203 return;
2204 }
2205 break;
2206
2207 default:
2208 break;
2209 }
2210
2211 // If we're counting down, then count.
2212 if (ControllerExtension->TimerCount > 0)
2213 {
2214 ControllerExtension->TimerCount--;
2215
2216 // Else we'll check the state and process if necessary
2217 }
2218 else
2219 {
2220 switch (ControllerExtension->TimerState)
2221 {
2222 case IDETimerIdle:
2223 break;
2224
2225 case IDETimerCmdWait:
2226 /* Command timed out, reset drive and try again or fail */
2227 DPRINT("Timeout waiting for command completion\n");
2228 if (++ControllerExtension->Retries > IDE_MAX_CMD_RETRIES)
2229 {
2230 if (ControllerExtension->CurrentIrp != NULL)
2231 {
2232 DbgPrint ("Max retries has been reached, IRP finished with error\n");
2233 ControllerExtension->CurrentIrp->IoStatus.Status = STATUS_IO_TIMEOUT;
2234 ControllerExtension->CurrentIrp->IoStatus.Information = 0;
2235 IDEFinishOperation(ControllerExtension);
2236 }
2237 ControllerExtension->TimerState = IDETimerIdle;
2238 ControllerExtension->TimerCount = 0;
2239 }
2240 else
2241 {
2242 IDEBeginControllerReset(ControllerExtension);
2243 }
2244 break;
2245
2246 case IDETimerResetWaitForBusyNegate:
2247 case IDETimerResetWaitForDrdyAssert:
2248 if (ControllerExtension->CurrentIrp != NULL)
2249 {
2250 DbgPrint ("Timeout waiting for drive reset, giving up on IRP\n");
2251 ControllerExtension->CurrentIrp->IoStatus.Status =
2252 STATUS_IO_TIMEOUT;
2253 ControllerExtension->CurrentIrp->IoStatus.Information = 0;
2254 IDEFinishOperation(ControllerExtension);
2255 }
2256 ControllerExtension->TimerState = IDETimerIdle;
2257 ControllerExtension->TimerCount = 0;
2258 break;
2259 }
2260 }
2261 }
2262
2263
A free Windows-compatible Operating System