rewrite comments into one, unified style

2026-06-15 10:17:48 +02:00
1 parent 6260de0085
commit 467a58c9c6
@@ -1,4 +1,5 @@
-// ata.c - PCI IDE / ATA disk driver.
+// ATA compatibility storage driver. This file owns legacy IDE probing and PIO disk access for older virtual hardware.
+
 #include "ata.h"

 const HAL_API* gAtaHal;
@@ -15,30 +16,37 @@ static const IO_DRIVER_ID_TABLE gAtaIdTable = {
    sizeof(gAtaIds) / sizeof(gAtaIds[0]),
 };

+// Implements the in8 operation.
 static uint8_t AtaIn8(ATA_CHANNEL* ch, uint8_t reg) {
    return __inbyte((unsigned short)(ch->CommandBase + reg));
 }

+// Implements the in16 operation.
 static uint16_t AtaIn16(ATA_CHANNEL* ch, uint8_t reg) {
    return __inword((unsigned short)(ch->CommandBase + reg));
 }

+// Implements the out8 operation.
 static void AtaOut8(ATA_CHANNEL* ch, uint8_t reg, uint8_t value) {
    __outbyte((unsigned short)(ch->CommandBase + reg), value);
 }

+// Implements the out16 operation.
 static void AtaOut16(ATA_CHANNEL* ch, uint8_t reg, uint16_t value) {
    __outword((unsigned short)(ch->CommandBase + reg), value);
 }

+// Implements the alt Status operation.
 static uint8_t AtaAltStatus(ATA_CHANNEL* ch) {
    return __inbyte((unsigned short)(ch->ControlBase + ATA_REG_ALT_STATUS));
 }

+// Implements the device Control operation.
 static void AtaDeviceControl(ATA_CHANNEL* ch, uint8_t value) {
    __outbyte((unsigned short)(ch->ControlBase + ATA_REG_DEVICE_CONTROL), value);
 }

+// Implements the delay400ns operation.
 static void AtaDelay400ns(ATA_CHANNEL* ch) {
    (void)AtaAltStatus(ch);
    (void)AtaAltStatus(ch);
@@ -46,6 +54,7 @@ static void AtaDelay400ns(ATA_CHANNEL* ch) {
    (void)AtaAltStatus(ch);
 }

+// Waits for not Busy.
 static KSTATUS AtaWaitNotBusy(ATA_CHANNEL* ch) {
    for (uint32_t i = 0; i < ATA_POLL_LIMIT; i++) {
        if (!(AtaIn8(ch, ATA_REG_STATUS) & ATA_STATUS_BSY))
@@ -55,6 +64,7 @@ static KSTATUS AtaWaitNotBusy(ATA_CHANNEL* ch) {
    return STATUS_TIMEOUT;
 }

+// Waits for drq.
 static KSTATUS AtaWaitDrq(ATA_CHANNEL* ch) {
    for (uint32_t i = 0; i < ATA_POLL_LIMIT; i++) {
        uint8_t st = AtaIn8(ch, ATA_REG_STATUS);
@@ -69,12 +79,14 @@ static KSTATUS AtaWaitDrq(ATA_CHANNEL* ch) {
    return STATUS_TIMEOUT;
 }

+// Implements the select Drive operation.
 static void AtaSelectDrive(ATA_DEVICE* dev) {
    ATA_CHANNEL* ch = dev->Channel;
    AtaOut8(ch, ATA_REG_DRIVE_HEAD, (uint8_t)(0xA0u | (dev->Drive ? 0x10u : 0u)));
    AtaDelay400ns(ch);
 }

+// Implements the identify operation.
 static KSTATUS AtaIdentify(ATA_DEVICE* dev) {
    ATA_CHANNEL* ch = dev->Channel;
    uint16_t ident[256];
@@ -139,6 +151,7 @@ static KSTATUS AtaIdentify(ATA_DEVICE* dev) {
    return dev->SectorCount ? STATUS_SUCCESS : STATUS_NOT_FOUND;
 }

+// Implements the program Lba operation.
 static KSTATUS AtaProgramLba(ATA_DEVICE* dev, uint64_t lba, uint16_t count, bool write) {
    ATA_CHANNEL* ch = dev->Channel;

@@ -168,6 +181,7 @@ static KSTATUS AtaProgramLba(ATA_DEVICE* dev, uint64_t lba, uint16_t count, bool
    return STATUS_SUCCESS;
 }

+// Returns pio.
 static KSTATUS AtaReadPio(ATA_DEVICE* dev, uint64_t lba, uint32_t count, void* buffer) {
    if (!dev || !buffer)
        return STATUS_INVALID_PARAMETER;
@@ -210,6 +224,7 @@ static KSTATUS AtaReadPio(ATA_DEVICE* dev, uint64_t lba, uint32_t count, void* b
    return st;
 }

+// Flushes the requested operation.
 static KSTATUS AtaFlush(ATA_DEVICE* dev) {
    ATA_CHANNEL* ch = dev->Channel;
    KSTATUS st = AtaWaitNotBusy(ch);
@@ -219,6 +234,7 @@ static KSTATUS AtaFlush(ATA_DEVICE* dev) {
    return AtaWaitNotBusy(ch);
 }

+// Updates pio.
 static KSTATUS AtaWritePio(ATA_DEVICE* dev, uint64_t lba, uint32_t count, const void* buffer) {
    if (!dev || !buffer)
        return STATUS_INVALID_PARAMETER;
@@ -285,6 +301,7 @@ static KSTATUS AtaGetIrpReadWrite(IRP* irp, bool* outWrite, uint64_t* outLba,
    return STATUS_SUCCESS;
 }

+// Implements the worker operation.
 static void AtaWorker(uintptr_t arg) {
    ATA_DEVICE* dev = (ATA_DEVICE*)arg;
    if (!dev)
@@ -315,6 +332,7 @@ static void AtaWorker(uintptr_t arg) {
    }
 }

+// Dispatches read Write.
 KSTATUS AtaDispatchReadWrite(DEVICE_OBJECT* device, IRP* irp) {
    if (!device || !irp || !device->DeviceExtension)
        return STATUS_INVALID_PARAMETER;
@@ -345,6 +363,7 @@ KSTATUS AtaDispatchReadWrite(DEVICE_OBJECT* device, IRP* irp) {
    return STATUS_PENDING;
 }

+// Returns free Disk Index.
 static uint8_t AtaFindFreeDiskIndex(void) {
    for (uint8_t i = 0; i < 8; i++) {
        if (!IoDiskDevicePresent(i))
@@ -353,6 +372,7 @@ static uint8_t AtaFindFreeDiskIndex(void) {
    return 0xFFu;
 }

+// Implements the bar Io Base operation.
 static uint16_t AtaBarIoBase(ATA_CONTROLLER* ctl, uint8_t barIndex, uint16_t fallback) {
    PCI_BAR bar;
    KSTATUS st = PciGetBar(ctl->Pdo, barIndex, &bar);
@@ -361,6 +381,7 @@ static uint16_t AtaBarIoBase(ATA_CONTROLLER* ctl, uint8_t barIndex, uint16_t fal
    return fallback;
 }

+// Initializes channel.
 static KSTATUS AtaInitChannel(ATA_CONTROLLER* ctl, uint8_t index) {
    ATA_CHANNEL* ch = &ctl->Channels[index];
    memset(ch, 0, sizeof(*ch));
@@ -398,6 +419,7 @@ static KSTATUS AtaInitChannel(ATA_CONTROLLER* ctl, uint8_t index) {
    return STATUS_SUCCESS;
 }

+// Registers disk.
 static KSTATUS AtaRegisterDisk(ATA_DEVICE* dev) {
    DEVICE_OBJECT* disk = (DEVICE_OBJECT*)0;
    KSTATUS st = IoCreateDevice(&gAtaDriver, 0, &disk);
@@ -433,6 +455,7 @@ static KSTATUS AtaRegisterDisk(ATA_DEVICE* dev) {
    return STATUS_SUCCESS;
 }

+// Probes drive.
 static KSTATUS AtaProbeDrive(ATA_CONTROLLER* ctl, ATA_CHANNEL* ch, uint8_t drive) {
    ATA_DEVICE* dev = &ch->Devices[drive];
    memset(dev, 0, sizeof(*dev));
@@ -470,6 +493,7 @@ static KSTATUS AtaProbeDrive(ATA_CONTROLLER* ctl, ATA_CHANNEL* ch, uint8_t drive
    return STATUS_SUCCESS;
 }

+// Registers controller.
 static KSTATUS AtaRegisterController(ATA_CONTROLLER* ctl) {
    if (!ctl) return STATUS_INVALID_PARAMETER;
    for (uint32_t i = 0; i < gAtaControllerCount; i++) {
@@ -482,6 +506,7 @@ static KSTATUS AtaRegisterController(ATA_CONTROLLER* ctl) {
    return STATUS_SUCCESS;
 }

+// Starts controller.
 static KSTATUS AtaStartController(ATA_CONTROLLER* ctl) {
    if (!ctl || ctl->Magic != ATA_CONTROLLER_MAGIC || !ctl->Pdo || !ctl->Fdo)
        return STATUS_INVALID_PARAMETER;
@@ -538,12 +563,14 @@ static KSTATUS AtaStartController(ATA_CONTROLLER* ctl) {
    return STATUS_SUCCESS;
 }

+// Cancels release Remove Lock.
 static void AtaCancelReleaseRemoveLock(IRP* irp, void* context) {
    ATA_DEVICE* dev = (ATA_DEVICE*)context;
    if (dev)
        IoReleaseRemoveLock(&dev->RemoveLock, irp);
 }

+// Releases controller Devices.
 static void AtaRemoveControllerDevices(ATA_CONTROLLER* ctl, IO_DEVICE_CHANGE change) {
    if (!ctl) return;
    for (uint8_t c = 0; c < ATA_CHANNEL_COUNT; c++) {
@@ -566,6 +593,7 @@ static void AtaRemoveControllerDevices(ATA_CONTROLLER* ctl, IO_DEVICE_CHANGE cha
    }
 }

+// Dispatches pnp.
 KSTATUS AtaDispatchPnp(DEVICE_OBJECT* device, IRP* irp) {
    if (!device || !irp || !device->DeviceExtension)
        return STATUS_INVALID_PARAMETER;
@@ -637,6 +665,7 @@ KSTATUS AtaDispatchPnp(DEVICE_OBJECT* device, IRP* irp) {
    return STATUS_INVALID_PARAMETER;
 }

+// Implements the add Device operation.
 KSTATUS AtaAddDevice(DRIVER_OBJECT* driver, DEVICE_OBJECT* physicalDeviceObject) {
    if (!driver || !physicalDeviceObject || physicalDeviceObject->Type != DeviceObjectPhysical)
        return STATUS_INVALID_PARAMETER;
@@ -663,6 +692,7 @@ KSTATUS AtaAddDevice(DRIVER_OBJECT* driver, DEVICE_OBJECT* physicalDeviceObject)
    return STATUS_SUCCESS;
 }

+// Implements the driver Entry operation.
 KSTATUS DriverEntry(const HAL_API* hal) {
    if (!hal)
        return STATUS_INVALID_PARAMETER;