nt-lite/code/drivers/net/rtl8139/rtl8139.c

// rtl8139.c - packet I/O, interrupt, and DriverEntry path.
#include "rtl8139.h"

const HAL_API* gHal;
RTL8139_DEVICE gDevice;
bool gDevicePresent = false;

static __forceinline void Rtl8139MemoryBarrier(void) {
    _ReadWriteBarrier();
    _mm_mfence();
    _ReadWriteBarrier();
}

static uint8_t Rtl8139Read8(RTL8139_DEVICE* r, uint32_t reg) {
    if (r->UseMmio)
        return *(volatile uint8_t*)(r->Mmio + reg);
    return __inbyte((unsigned short)(r->IoBase + reg));
}

static uint16_t Rtl8139Read16(RTL8139_DEVICE* r, uint32_t reg) {
    if (r->UseMmio)
        return *(volatile uint16_t*)(r->Mmio + reg);
    return __inword((unsigned short)(r->IoBase + reg));
}

static uint32_t Rtl8139Read32(RTL8139_DEVICE* r, uint32_t reg) {
    if (r->UseMmio)
        return *(volatile uint32_t*)(r->Mmio + reg);
    return __indword((unsigned short)(r->IoBase + reg));
}

static void Rtl8139Write8(RTL8139_DEVICE* r, uint32_t reg, uint8_t value) {
    if (r->UseMmio) *(volatile uint8_t*)(r->Mmio + reg) = value;
    else __outbyte((unsigned short)(r->IoBase + reg), value);
}

static void Rtl8139Write16(RTL8139_DEVICE* r, uint32_t reg, uint16_t value) {
    if (r->UseMmio) *(volatile uint16_t*)(r->Mmio + reg) = value;
    else __outword((unsigned short)(r->IoBase + reg), value);
}

static void Rtl8139Write32(RTL8139_DEVICE* r, uint32_t reg, uint32_t value) {
    if (r->UseMmio) *(volatile uint32_t*)(r->Mmio + reg) = value;
    else __outdword((unsigned short)(r->IoBase + reg), value);
}





static KSTATUS Rtl8139Reset(RTL8139_DEVICE* r) {
    Rtl8139Write8(r, RTL8139_REG_CMD, RTL8139_CMD_RST);
    for (uint32_t i = 0; i < 1000; i++) {
        if ((Rtl8139Read8(r, RTL8139_REG_CMD) & RTL8139_CMD_RST) == 0)
            return STATUS_SUCCESS;
        if (gHal->Timer.Stall)
            gHal->Timer.Stall(1000);
    }
    return STATUS_TIMEOUT;
}

static void Rtl8139ReadMac(RTL8139_DEVICE* r) {
    for (uint32_t i = 0; i < 6; i++)
        r->NetDevice.HardwareAddress[i] = Rtl8139Read8(r, RTL8139_REG_IDR0 + i);
    r->NetDevice.HardwareAddressLength = 6;
}

static KSTATUS Rtl8139AllocateDma(RTL8139_DEVICE* r) {
    r->RxPhys = MmAllocateContiguous(RTL8139_RX_PAGES);
    r->TxPhys = MmAllocateContiguous(RTL8139_TX_PAGES);
    if (!r->RxPhys || !r->TxPhys)
        return STATUS_NO_MEMORY;

    // RTL8139 has 32-bit DMA address registers.  This is fine for typical QEMU
    // and low-memory hobby OS configs, but make failure explicit.
    if ((r->RxPhys + RTL8139_RX_ALLOC_SIZE - 1) > 0xFFFFFFFFULL ||
        (r->TxPhys + RTL8139_TX_SLOTS * RTL8139_TX_BUF_SIZE - 1) > 0xFFFFFFFFULL) {
        DbgPrint("RTL8139: DMA allocation above 4GiB is not supported by this NIC\n");
        return STATUS_NOT_SUPPORTED;
    }

    r->RxBuffer = (uint8_t*)gHal->PhysToVirt(r->RxPhys);
    r->TxBuffers = (uint8_t*)gHal->PhysToVirt(r->TxPhys);
    memset(r->RxBuffer, 0, PAGE_SIZE * RTL8139_RX_PAGES);
    memset(r->TxBuffers, 0, PAGE_SIZE * RTL8139_TX_PAGES);

    DbgPrint("RTL8139: rx=0x%016llX tx=0x%016llX\n",
             (unsigned long long)r->RxPhys,
             (unsigned long long)r->TxPhys);
    return STATUS_SUCCESS;
}

static uint16_t Rtl8139RxRead16(RTL8139_DEVICE* r, uint32_t offset) {
    offset %= RTL8139_RX_RING_SIZE;
    uint16_t lo = r->RxBuffer[offset];
    uint16_t hi = r->RxBuffer[(offset + 1u) % RTL8139_RX_RING_SIZE];
    return (uint16_t)(lo | (hi << 8));
}

static void Rtl8139RxCopy(RTL8139_DEVICE* r, uint32_t offset, void* dst, uint32_t length) {
    uint8_t* out = (uint8_t*)dst;
    offset %= RTL8139_RX_RING_SIZE;

    uint32_t first = RTL8139_RX_RING_SIZE - offset;
    if (first > length)
        first = length;
    memcpy(out, r->RxBuffer + offset, first);
    if (first < length)
        memcpy(out + first, r->RxBuffer, length - first);
}

static void Rtl8139ProgramHardware(RTL8139_DEVICE* r) {
    // Wake the device and clear stale interrupts before installing buffers.
    Rtl8139Write8(r, RTL8139_REG_CONFIG1, 0x00);
    Rtl8139Write16(r, RTL8139_REG_IMR, 0);
    Rtl8139Write16(r, RTL8139_REG_ISR, 0xFFFFu);

    Rtl8139Write32(r, RTL8139_REG_RBSTART, (uint32_t)r->RxPhys);
    r->RxOffset = 0;
    Rtl8139Write16(r, RTL8139_REG_CAPR, 0xFFF0u); // CAPR is rxOffset - 16.

    for (uint32_t i = 0; i < RTL8139_TX_SLOTS; i++) {
        PHYSICAL_ADDRESS p = r->TxPhys + (PHYSICAL_ADDRESS)i * RTL8139_TX_BUF_SIZE;
        Rtl8139Write32(r, RTL8139_REG_TSAD(i), (uint32_t)p);
    }

    Rtl8139Write32(r, RTL8139_REG_TCR,
                   RTL8139_TCR_IFG_NORMAL | RTL8139_TCR_MXDMA_UNLIMITED);
    Rtl8139Write32(r, RTL8139_REG_RCR,
                   RTL8139_RCR_APM | RTL8139_RCR_AB | RTL8139_RCR_AM |
                   RTL8139_RCR_WRAP | RTL8139_RCR_RBLEN_8K |
                   RTL8139_RCR_MXDMA_UNLIMITED);

    Rtl8139MemoryBarrier();
    Rtl8139Write8(r, RTL8139_REG_CMD, RTL8139_CMD_RE | RTL8139_CMD_TE);
    Rtl8139Write16(r, RTL8139_REG_ISR, 0xFFFFu);
    Rtl8139Write16(r, RTL8139_REG_IMR, RTL8139_INTR_ENABLES);
}

static void Rtl8139HandleRx(RTL8139_DEVICE* r) {
    for (uint32_t budget = 0; budget < 64; budget++) {
        uint8_t cmd = Rtl8139Read8(r, RTL8139_REG_CMD);
        if (cmd & RTL8139_CMD_BUFE)
            break;

        uint32_t off = r->RxOffset % RTL8139_RX_RING_SIZE;
        uint16_t status = Rtl8139RxRead16(r, off);
        uint16_t packetLength = Rtl8139RxRead16(r, off + 2u);

        if (packetLength < 4 || packetLength > RTL8139_RX_WIRE_MAX) {
            DbgPrint("RTL8139: bad rx length %u status=0x%04x, resetting rx pointer\n",
                     packetLength, status);
            r->RxOffset = Rtl8139Read16(r, RTL8139_REG_CBR) % RTL8139_RX_RING_SIZE;
            Rtl8139Write16(r, RTL8139_REG_CAPR, (uint16_t)(r->RxOffset - 16u));
            break;
        }

        uint32_t frameLength = packetLength;
        if (frameLength > 4)
            frameLength -= 4; // Strip Ethernet FCS before upper-layer handoff.

        bool goodFrame = (status & RTL8139_RX_OK) &&
                         !(status & RTL8139_RX_BAD_BITS) &&
                         frameLength >= NET_ETHERNET_HEADER_LENGTH &&
                         frameLength <= NET_ETHERNET_MAX_FRAME;
        if (goodFrame) {
            if ((off + 4u + frameLength) <= RTL8139_RX_RING_SIZE) {
                NetReceiveFrame(&r->NetDevice, r->RxBuffer + off + 4u, frameLength);
            } else {
                Rtl8139RxCopy(r, off + 4u, r->RxScratch, frameLength);
                NetReceiveFrame(&r->NetDevice, r->RxScratch, frameLength);
            }
        } else {
            DbgPrint("RTL8139: rx error status=0x%04x len=%u\n", status, packetLength);
        }

        r->RxOffset = (r->RxOffset + 4u + packetLength + 3u) & ~3u;
        r->RxOffset %= RTL8139_RX_RING_SIZE;
        Rtl8139MemoryBarrier();
        Rtl8139Write16(r, RTL8139_REG_CAPR, (uint16_t)(r->RxOffset - 16u));
    }
}

static void Rtl8139DpcRoutine(KDPC* dpc, void* context, void* systemArgument1, void* systemArgument2) {
    (void)dpc;
    (void)systemArgument1;
    (void)systemArgument2;

    RTL8139_DEVICE* r = (RTL8139_DEVICE*)context;
    uint16_t status = (uint16_t)r->PendingIsr;
    r->PendingIsr = 0;

    if (status & (RTL8139_ISR_ROK | RTL8139_ISR_RER | RTL8139_ISR_RXOVW | RTL8139_ISR_FOVW))
        Rtl8139HandleRx(r);

    if (status & (RTL8139_ISR_PUN | RTL8139_ISR_LENCHG))
        DbgPrint("RTL8139: link/status change isr=0x%04x\n", status);

    if (status & (RTL8139_ISR_RER | RTL8139_ISR_TER | RTL8139_ISR_RXOVW |
                  RTL8139_ISR_FOVW | RTL8139_ISR_SYSERR))
        DbgPrint("RTL8139: interrupt error bits=0x%04x\n", status);
}

static void Rtl8139Isr(void) {
    if (!gDevicePresent)
        return;

    RTL8139_DEVICE* r = &gDevice;
    uint16_t status = Rtl8139Read16(r, RTL8139_REG_ISR);
    status &= RTL8139_INTR_ENABLES;
    if (!status || status == 0xFFFFu)
        return;

    Rtl8139Write16(r, RTL8139_REG_ISR, status);
    r->PendingIsr |= status;
    KeInsertQueueDpc(&r->Dpc, (void*)0, (void*)0);
}

static KSTATUS Rtl8139SendFrame(NET_DEVICE* device, const void* frame, size_t length) {
    if (!device || !frame)
        return STATUS_INVALID_PARAMETER;
    if (length > NET_ETHERNET_MAX_FRAME)
        return STATUS_BUFFER_TOO_SMALL;
    if (length < NET_ETHERNET_HEADER_LENGTH)
        return STATUS_INVALID_PARAMETER;

    RTL8139_DEVICE* r = (RTL8139_DEVICE*)device->DriverContext;
    if (!r)
        return STATUS_INVALID_PARAMETER;

    uintptr_t flags = KeAcquireSpinlock(&r->TxLock);
    uint32_t slot = r->TxSlot;
    uint32_t tsd = Rtl8139Read32(r, RTL8139_REG_TSD(slot));
    // RTL8139 TSD.OWN is 1 when the descriptor is idle/free.
    // Writing a command with OWN cleared hands the slot to the NIC.
    if (!(tsd & RTL8139_TSD_OWN)) {
        KeReleaseSpinlock(&r->TxLock, flags);
        return STATUS_QUEUE_FULL;
    }

    size_t wireLength = length < NET_ETHERNET_MIN_FRAME ? NET_ETHERNET_MIN_FRAME : length;
    uint8_t* buf = r->TxBuffers + slot * RTL8139_TX_BUF_SIZE;
    memcpy(buf, frame, length);
    if (wireLength > length)
        memset(buf + length, 0, wireLength - length);

    Rtl8139MemoryBarrier();
    Rtl8139Write32(r, RTL8139_REG_TSD(slot), (uint32_t)wireLength & RTL8139_TSD_SIZE_MASK);

    r->TxSlot = (slot + 1u) % RTL8139_TX_SLOTS;
    KeReleaseSpinlock(&r->TxLock, flags);
    return STATUS_SUCCESS;
}

static KSTATUS Rtl8139Initialize(const HAL_API* hal) {
    gHal = hal;
    memset(&gDevice, 0, sizeof(gDevice));
    gDevice.TxLock = (SPINLOCK)SPINLOCK_INIT;

    if (!gHal->Pci.FindDevice(RTL8139_VENDOR_REALTEK, RTL8139_DEVICE_ID,
                              &gDevice.Bus, &gDevice.Dev, &gDevice.Fn)) {
        DbgPrint("RTL8139: no PCI device 10ec:8139 found; skipping\n");
        return STATUS_SUCCESS;
    }

    DbgPrint("RTL8139: found Realtek PCI device 10ec:8139 at %u:%u.%u\n",
             gDevice.Bus, gDevice.Dev, gDevice.Fn);

    KSTATUS st = Rtl8139SelectRegisterBar(&gDevice);
    if (!KSUCCESS(st)) {
        DbgPrint("RTL8139: no usable register BAR (0x%x)\n", st);
        return st;
    }

    Rtl8139EnablePci(&gDevice);

    gDevice.Irq = hal->Pci.GetIrqLine(gDevice.Bus, gDevice.Dev, gDevice.Fn);
    if (gDevice.Irq == 0xFFu) {
        DbgPrint("RTL8139: no legacy PCI IRQ line wired\n");
        return STATUS_NOT_SUPPORTED;
    }

    // Wake, reset, then read the station address.
    Rtl8139Write8(&gDevice, RTL8139_REG_CONFIG1, 0x00);
    st = Rtl8139Reset(&gDevice);
    if (!KSUCCESS(st)) {
        DbgPrint("RTL8139: reset timed out\n");
        return st;
    }

    Rtl8139ReadMac(&gDevice);
    DbgPrint("RTL8139: MAC %02x:%02x:%02x:%02x:%02x:%02x irq=%u\n",
             gDevice.NetDevice.HardwareAddress[0], gDevice.NetDevice.HardwareAddress[1],
             gDevice.NetDevice.HardwareAddress[2], gDevice.NetDevice.HardwareAddress[3],
             gDevice.NetDevice.HardwareAddress[4], gDevice.NetDevice.HardwareAddress[5],
             gDevice.Irq);

    st = Rtl8139AllocateDma(&gDevice);
    if (!KSUCCESS(st))
        return st;

    KeInitializeDpc(&gDevice.Dpc, Rtl8139DpcRoutine, &gDevice);

    gDevice.NetDevice.Mtu = NET_MTU_ETHERNET;
    gDevice.NetDevice.DriverContext = &gDevice;
    gDevice.NetDevice.SendFrame = Rtl8139SendFrame;

    Rtl8139ProgramHardware(&gDevice);

    gDevicePresent = true;
    KeIrqRegister(gDevice.Irq, Rtl8139Isr);

    st = NetRegisterDevice(&gDevice.NetDevice);
    if (!KSUCCESS(st))
        return st;

    DbgPrint("RTL8139: initialized; RX/TX enabled on IRQ %u\n", gDevice.Irq);
    return STATUS_SUCCESS;
}

KSTATUS DriverEntry(const HAL_API* hal) {
    DbgPrint("RTL8139: driver loading...\n");
    KSTATUS st = Rtl8139Initialize(hal);
    if (!KSUCCESS(st))
        DbgPrint("RTL8139: init failed: 0x%x\n", st);
    return st;
}