Turn off local APIC timer

README.md

@@ -17,8 +17,6 @@ the build command.
 
 # Running HOS
 
-HOS can run on a physical machine, in VirtualBox, or in QEMU.
-
 ## Physical Machine
 
 To install HOS to an EFI partition, follow these steps:
@@ -71,10 +69,3 @@ To create a VM in VirtualBox:
 14. Under System, check the Enable EFI checkbox.
 15. Under Storage, add a hard disk and browse to select the HOS.vmdk file.
 16. To run HOS, either start the VM through VirtualBox or with "./rscons run-vb".
-
-## QEMU
-
-Make sure QEMU is installed (possibly the `qemu-desktop` package). Then:
-
-1. Build HOS ("./rscons").
-2. Run `./rscons run` to run HOS in QEMU.

Rsconscript

@@ -162,10 +162,6 @@ hello_env = env "hello", use: %w[ldc2 x86_64-w64-mingw32-gcc] do |env|
   env.add_builder(CheckThreadLocal)
   env.add_builder(HulkBinObj)
   env["sources"] = glob("src/hello/**/*.d")
-  env["sources"] += %w[
-    src/hulk/serial.d
-    src/hulk/writef.d
-  ]
   env["sources"] += glob("uefi-d/source/**/*.d")
   env.HulkBinObj("^/hulk_bin.S", hulk_env.expand("^/hulk.bin"))
   env.Object("^/hulk_bin.o", "^/hulk_bin.S")
@@ -190,11 +186,7 @@ task "run", desc: "Run HOS in QEMU" do
   Dir.mktmpdir do |tmpdir|
     img = hello_env.expand("^/HOS.img")
     FileUtils.cp(img, tmpdir)
-    ovmf = "OVMF.fd"
+    sh %W[qemu-system-x86_64 -cpu max -bios OVMF.fd -drive file=#{tmpdir}/HOS.img,format=raw -device qemu-xhci -device usb-tablet]
-    if File.exist?("/usr/share/edk2/x64/OVMF.fd")
-      ovmf = "/usr/share/edk2/x64/OVMF.fd"
-    end
-    sh %W[qemu-system-x86_64 -cpu max -bios #{ovmf} -drive file=#{tmpdir}/HOS.img,format=raw -device qemu-xhci -device usb-tablet]
   end
 end
 

src/fontgen/fontgen.c

@@ -103,7 +103,7 @@ static void generate(const char * d_file_name)
     fprintf(fh, "    int baseline_offset;\n");
     fprintf(fh, "    const CharInfo[] chars;\n");
     fprintf(fh, "};\n");
-    fprintf(fh, "__gshared const FontInfo Kfont = {\n");
+    fprintf(fh, "__gshared const FontInfo kfont = {\n");
     fprintf(fh, "    %du,\n", line_height);
     fprintf(fh, "    %du,\n", max_advance);
     fprintf(fh, "    %d,\n", baseline_offset);

src/hello/console.d

@@ -6,62 +6,155 @@ module hello.console;
 import uefi;
 import hello.hello;
 import core.stdc.stdarg;
-import hulk.writef;
 
-struct Console
+struct console
 {
     /**
-     * Write a character to the console.
+     * Format a hexadecimal value to a string.
      *
-     * @param ch Character to write.
+     * @param s String buffer.
+     * @param v Value to format.
+     * @param ptr If true, always output all 16 digits, and separate the upper and
+     *   lower halves with an underscore.
      */
-    public static void write(ubyte ch)
+    private static size_t format_hex(CHAR16 * s, ulong v, bool ptr)
     {
-        if (ch == '\n')
+        string hex_chars = "0123456789ABCDEF";
+        bool print = ptr;
+        size_t si = 0u;
+        for (size_t i = 0u; i < 16u; i++)
         {
-            write('\r');
+            if (ptr && (i == 8u))
+            {
+                s[si++] = '_';
             }
-        CHAR16[2] s16 = [ch, 0];
+            ulong n = (v >> (60u - 4u * i)) & 0xFu;
-        st.ConOut.OutputString(st.ConOut, &s16[0]);
+            if (n != 0u)
+            {
+                print = true;
+            }
+            if (print || (i == 15u))
+            {
+                s[si++] = hex_chars[n];
+            }
+        }
+        return si;
     }
 
     /**
-     * Write a formatted string to the console.
+     * Format a decimal value to a string.
+     *
+     * @param s String buffer.
+     * @param v Value to format.
+     */
+    private static size_t format_dec(CHAR16 * s, ulong v)
+    {
+        string dec_chars = "0123456789";
+        bool print;
+        char[20] buf;
+        size_t buf_i;
+        while ((buf_i == 0u) || (v != 0u))
+        {
+            ulong n = v % 10u;
+            buf[buf_i++] = dec_chars[n];
+            v /= 10u;
+        }
+        for (size_t si = 0u; si < buf_i; si++)
+        {
+            s[si] = buf[buf_i - si - 1u];
+        }
+        return buf_i;
+    }
+
+    /**
+     * Write a string to the console.
      *
      * @param s Format string.
      * @param args Variable arguments structure.
      */
-    public static void writef(string s, va_list args)
+    public static void write(string s, va_list args)
     {
-        hulk.writef.writef(s, args, function void(ubyte ch) {
+        __gshared static CHAR16[256] s16;
-                    Console.write(ch);
+        size_t i = 0u;
-                });
+        bool escape = false;
+        foreach (char c; s)
+        {
+            if (escape)
+            {
+                if (c == '%')
+                {
+                    s16[i++] = '%';
+                }
+                else if (c == 'x')
+                {
+                    ulong v;
+                    va_arg(args, v);
+                    i += format_hex(&s16[i], v, false);
+                }
+                else if (c == 'p')
+                {
+                    ulong v;
+                    va_arg(args, v);
+                    i += format_hex(&s16[i], v, true);
+                }
+                else if (c == 'S')
+                {
+                    const(CHAR16) * s2;
+                    va_arg(args, s2);
+                    for (size_t s2_i = 0u; s2[s2_i] != 0; s2_i++)
+                    {
+                        s16[i++] = s2[s2_i];
+                    }
+                }
+                else if (c == 'u')
+                {
+                    ulong v;
+                    va_arg(args, v);
+                    i += format_dec(&s16[i], v);
+                }
+                else
+                {
+                    s16[i++] = c;
+                }
+                escape = false;
+            }
+            else if (c == '%')
+            {
+                escape = true;
+            }
+            else
+            {
+                s16[i++] = c;
+            }
+        }
+        s16[i++] = 0u;
+        st.ConOut.OutputString(st.ConOut, &s16[0]);
     }
 
     /**
-     * Write a formatted string to the console.
+     * Write a string to the console.
      *
      * @param s Format string.
      */
-    public static extern (C) void writef(string s, ...)
+    public static extern (C) void write(string s, ...)
     {
         va_list args;
         va_start(args, s);
-        writef(s, args);
+        write(s, args);
         va_end(args);
     }
 
     /**
-     * Write a formatted string and newline to the console.
+     * Write a string to the console.
      *
      * @param s Format string.
      */
-    public static extern (C) void writefln(string s, ...)
+    public static extern (C) void writeln(string s, ...)
     {
         va_list args;
         va_start(args, s);
-        writef(s, args);
+        write(s, args);
-        writef("\n", args);
+        write("\r\n", args);
         va_end(args);
     }
 
@@ -70,7 +163,7 @@ struct Console
      */
     public static void wait_key()
     {
-        writefln("Press any key...");
+        writeln("Press any key...");
         st.ConIn.Reset(st.ConIn, FALSE);
         EFI_INPUT_KEY key;
         while (st.ConIn.ReadKeyStroke(st.ConIn, &key) == EFI_NOT_READY)

src/hello/hello.d

@@ -11,7 +11,6 @@ import hulk.pagetable;
 import hulk.cpu;
 import hulk.memory;
 import ldc.llvmasm;
-import hulk.serial;
 
 __gshared EFI_SYSTEM_TABLE * st;
 /** HULK binary start address, 4KB-aligned. */
@@ -94,7 +93,7 @@ private bool set_graphics_mode()
             &gop_guid, null, &buffer_size, handles);
     if (status != EFI_SUCCESS)
     {
-        Console.writefln("LocateHandle: error %x", status);
+        console.writeln("LocateHandle: error %x", status);
         return false;
     }
     EFI_HANDLE gop_handle = handles[0];
@@ -103,12 +102,12 @@ private bool set_graphics_mode()
             &gop_guid, &gop_interface);
     if (status != EFI_SUCCESS)
     {
-        Console.writefln("HandleProtocol: error %x", status);
+        console.writeln("HandleProtocol: error %x", status);
         return false;
     }
     if (gop_interface == null)
     {
-        Console.writefln("null interface from HandleProtocol");
+        console.writeln("null interface from HandleProtocol");
         return false;
     }
     EFI_GRAPHICS_OUTPUT_PROTOCOL * gop = cast(EFI_GRAPHICS_OUTPUT_PROTOCOL *)gop_interface;
@@ -130,7 +129,7 @@ private bool set_graphics_mode()
     }
     if ((status = gop.SetMode(gop, best_mode_number)) != EFI_SUCCESS)
     {
-        Console.writefln("SetMode: Error %x\n", status);
+        console.writeln("SetMode: Error %x\n", status);
         return false;
     }
     bootinfo().fb.buffer = cast(uint *)gop.Mode.FrameBufferBase;
@@ -175,7 +174,7 @@ private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_k
             &descriptor_version);
     if (status != EFI_SUCCESS)
     {
-        Console.writefln("GetMemoryMap: Error %x", status);
+        console.writeln("GetMemoryMap: Error %x", status);
         for (;;) {}
     }
     size_t n_entries = memory_map_size / descriptor_size;
@@ -188,7 +187,7 @@ private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_k
     {
         if (count > bootinfo().memory_map.length)
         {
-            Console.writefln("Memory map too large");
+            console.writeln("Memory map too large");
             for (;;) {}
         }
         EFI_MEMORY_DESCRIPTOR * descriptor = cast(EFI_MEMORY_DESCRIPTOR *)&scratch_base[count * descriptor_size];
@@ -206,7 +205,6 @@ private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_k
         }
         if (descriptor.Type >= efi_to_hulk_memory_map_type.length)
         {
-            Serial.writefln("Unexpected descriptor type %u", descriptor.Type);
             continue;
         }
         bootinfo().memory_map[count].base = descriptor.PhysicalStart;
@@ -219,7 +217,6 @@ private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_k
             bootinfo().bss_phys = bootinfo().memory_map[count].base;
             bootinfo().memory_map[count].base += hulk_bss_size();
             bootinfo().memory_map[count].size -= hulk_bss_size();
-            Serial.writefln("Locating HULK BSS at %x", bootinfo().bss_phys);
             found_bss = true;
         }
         if ((!found_stack) &&
@@ -229,7 +226,6 @@ private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_k
             bootinfo().stack_phys = bootinfo().memory_map[count].base;
             bootinfo().memory_map[count].base += hulk_stack_size();
             bootinfo().memory_map[count].size -= hulk_stack_size();
-            Serial.writefln("Locating HULK stack at %x", bootinfo().stack_phys);
             found_stack = true;
         }
         if ((!found_fb_buffer1) &&
@@ -239,13 +235,8 @@ private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_k
             bootinfo().fb_buffer1_phys = bootinfo().memory_map[count].base;
             bootinfo().memory_map[count].base += fb_size;
             bootinfo().memory_map[count].size -= fb_size;
-            Serial.writefln("Locating HULK FB1 at %x", bootinfo().fb_buffer1_phys);
             found_fb_buffer1 = true;
         }
-        Serial.writefln("Memory range %x:%x (%u)",
-                bootinfo().memory_map[count].base,
-                bootinfo().memory_map[count].base + bootinfo().memory_map[count].size - 1u,
-                bootinfo().memory_map[count].type);
     }
     bootinfo().memory_map_count = count;
     if ((!found_bss) || (!found_stack) || (!found_fb_buffer1))
@@ -520,21 +511,21 @@ extern (C) EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE * st)
 {
     .st = st;
 
-    Console.clear();
+    console.clear();
 
-    Console.writefln("Welcome to HELLO, HOS EFI Lightweight LOader, v0.1.0");
+    console.writeln("Welcome to HELLO, HOS EFI Lightweight LOader, v0.1.0");
-    Console.writefln("Firmware vendor: '%S', version: 0x%x", st.FirmwareVendor, st.FirmwareVendor);
+    console.writeln("Firmware vendor: '%S', version: 0x%x", st.FirmwareVendor, st.FirmwareVendor);
 
     if (!find_acpi_xsdt())
     {
-        Console.writefln("Error: Could not locate ACPI XSDT");
+        console.writeln("Error: Could not locate ACPI XSDT");
-        Console.wait_key();
+        console.wait_key();
         return EFI_SUCCESS;
     }
 
     if (!set_graphics_mode())
     {
-        Console.wait_key();
+        console.wait_key();
         return EFI_SUCCESS;
     }
 
@@ -553,8 +544,8 @@ extern (C) EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE * st)
         {
             break;
         }
-        Console.writefln("ExitBootServices: Error %x", status);
+        console.writeln("ExitBootServices: Error %x", status);
-        Console.wait_key();
+        console.wait_key();
         return EFI_SUCCESS;
     }
 

src/hulk/acpi.d

@@ -7,7 +7,7 @@ import hulk.hurl;
 import hulk.klog;
 import hulk.memory;
 
-struct Acpi
+struct acpi
 {
     enum uint APIC_SIGNATURE = 0x43495041u;
     enum uint XSDT_SIGNATURE = 0x54445358u;
@@ -58,40 +58,34 @@ struct Acpi
     public static void initialize(ulong acpi_xsdt_phys)
     {
         /* Map the XSDT header. */
-        Hurl.identity_map_range(acpi_xsdt_phys, Xsdt.sizeof, 0u);
+        hurl.identity_map_range(acpi_xsdt_phys, Xsdt.sizeof, 0u);
         const(Xsdt) * xsdt = cast(const(Xsdt) *)acpi_xsdt_phys;
         if (xsdt.header.signature != XSDT_SIGNATURE)
         {
-            Klog.writef("XSDT signature invalid\n");
+            klog.writef("XSDT signature invalid\n");
             return;
         }
         /* Map the entire XSDT. */
-        Hurl.identity_map_range(acpi_xsdt_phys, xsdt.header.length, 0u);
+        hurl.identity_map_range(acpi_xsdt_phys, xsdt.header.length, 0u);
         size_t n_entries = (xsdt.header.length - xsdt.header.sizeof) / xsdt.tables[0].sizeof;
         for (size_t i = 0u; i < n_entries; i++)
         {
             ulong address = xsdt.tables[i];
-            Hurl.identity_map_range(address, 4u, 0u);
+            hurl.identity_map_range(address, 4u, 0u);
             uint signature = *cast(const(uint) *)address;
             if (signature == APIC_SIGNATURE)
             {
                 parse_apic_table(address);
             }
-            Klog.writefln("Found ACPI table %08x (%c%c%c%c)",
-                    signature,
-                    signature & 0xFFu,
-                    (signature >> 8u) & 0xFFu,
-                    (signature >> 16u) & 0xFFu,
-                    (signature >> 24u) & 0xFFu);
         }
     }
 
     private static parse_apic_table(ulong address)
     {
         const(MadtHeader) * madt_header = cast(const(MadtHeader) *)address;
-        Hurl.identity_map_range(address, madt_header.length, 0u);
+        hurl.identity_map_range(address, madt_header.length, 0u);
         apic_address = madt_header.local_apic_address;
-        Klog.writefln("Found 32-bit APIC address: 0x%x", apic_address);
+        klog.writefln("Found 32-bit APIC address: 0x%x", apic_address);
         const(void) * madt_end = cast(const(void) *)(address + madt_header.length);
         const(MadtEntry) * madt_entry = cast(const(MadtEntry) *)(address + 0x2Cu);
         while (madt_entry < madt_end)
@@ -101,7 +95,7 @@ struct Acpi
             {
                 /* Found a 64-bit Local APIC Address Override entry. */
                 memcpy(cast(void *)&apic_address, cast(const(void) *)madt_entry + 4u, 8u);
-                Klog.writefln("Found 64-bit APIC address: 0x%x", apic_address);
+                klog.writefln("Found 64-bit APIC address: 0x%x", apic_address);
             }
         }
     }

src/hulk/apic.d

@@ -7,14 +7,11 @@ import hulk.klog;
 import hulk.hurl;
 import hulk.acpi;
 import hulk.idt;
-import hulk.rtc;
 
-struct Apic
+struct apic
 {
     private enum uint PERIODIC_MODE = 0x2_0000u;
 
-    private enum ulong IRQ_RTC = 8u;
-
     static struct ApicRegister
     {
         public uint value;
@@ -66,22 +63,23 @@ struct Apic
 
     public static void initialize()
     {
-        apic_registers = cast(ApicRegisters *)Acpi.apic_address;
+        apic_registers = cast(ApicRegisters *)acpi.apic_address;
         io_apic_registers = cast(IoApicRegisters *)0xFEC0_0000u;
-        Hurl.map(cast(ulong)apic_registers, cast(ulong)apic_registers,
+        hurl.map(cast(ulong)apic_registers, cast(ulong)apic_registers,
                 PT_WRITABLE | PT_WRITE_THROUGH | PT_DISABLE_CACHE | PT_NO_EXECUTE);
-        Hurl.map(cast(ulong)io_apic_registers, cast(ulong)io_apic_registers,
+        hurl.map(cast(ulong)io_apic_registers, cast(ulong)io_apic_registers,
                 PT_WRITABLE | PT_WRITE_THROUGH | PT_DISABLE_CACHE | PT_NO_EXECUTE);
-        Klog.writefln("LAPIC ID: 0x%08x", apic_registers.lapic_id.value);
+        klog.writefln("LAPIC ID: 0x%08x", apic_registers.lapic_id.value);
-        Klog.writefln("LAPIC version: 0x%08x", apic_registers.lapic_version.value);
+        klog.writefln("LAPIC version: 0x%08x", apic_registers.lapic_version.value);
         /* Enable local APIC to receive interrupts and set spurious interrupt
          * vector to 0xFF. */
-        apic_registers.spurious_interrupt_vector.value = 0x100u | Idt.INT_APIC_SPURIOUS;
+        apic_registers.spurious_interrupt_vector.value = 0x1FFu;
-        apic_registers.lvt_timer.value = Idt.INT_APIC_TIMER;
+//        apic_registers.lvt_timer.value = idt.INT_LAPIC_TIMER | PERIODIC_MODE;
-        apic_registers.lvt_lint[0].value = Idt.INT_APIC_LINT0;
+        apic_registers.lvt_timer.value = idt.INT_LAPIC_TIMER;
-        apic_registers.lvt_lint[1].value = Idt.INT_APIC_LINT1;
+        apic_registers.lvt_lint[0].value = idt.INT_LAPIC_LINT0;
-        /* Enable RTC interrupt. */
+        apic_registers.lvt_lint[1].value = idt.INT_LAPIC_LINT1;
-        configure_io_apic_irq(IRQ_RTC, Idt.INT_APIC_BASE + IRQ_RTC);
+//        apic_registers.divide_configuration.value = 3u;
+        configure_io_apic_irq(8u, 0x48u);
     }
 
     private static void configure_io_apic_irq(size_t io_apic_irq, size_t interrupt_id)
@@ -100,15 +98,7 @@ struct Apic
 
     public static void isr(ulong vector)
     {
-        switch (vector)
+        klog.writefln("APIC ISR 0x%x", vector);
-        {
-        case Idt.INT_APIC_BASE + IRQ_RTC:
-            Rtc.isr();
-            break;
-
-        default:
-            break;
-        }
         eoi();
     }
 }

src/hulk/console.d

@@ -6,7 +6,7 @@ module hulk.console;
 import hulk.fb;
 import hulk.kfont;
 
-struct Console
+struct console
 {
     /** Console width in text columns. */
     private static __gshared size_t m_width;
@@ -25,8 +25,8 @@ struct Console
      */
     public static void initialize()
     {
-        m_width = Fb.width / Kfont.advance;
+        m_width = fb.width / kfont.advance;
-        m_height = Fb.height / Kfont.line_height;
+        m_height = fb.height / kfont.line_height;
     }
 
     /**
@@ -34,7 +34,7 @@ struct Console
      */
     public static void clear()
     {
-        Fb.clear();
+        fb.clear();
         m_x = 0u;
         m_y = 0u;
     }
@@ -64,10 +64,10 @@ struct Console
         if (m_y == m_height)
         {
             m_y--;
-            Fb.copy_rows_up(fb_y(m_height - 1u),
+            fb.copy_rows_up(fb_y(m_height - 1u),
-                    (m_height - 1u) * Kfont.line_height,
+                    (m_height - 1u) * kfont.line_height,
-                    Kfont.line_height);
+                    kfont.line_height);
-            Fb.rect(0u, fb_y(m_height - 1u), fb_x(m_width), Kfont.line_height, 0u);
+            fb.rect(0u, fb_y(m_height - 1u), fb_x(m_width), kfont.line_height, 0u);
         }
     }
 
@@ -80,8 +80,8 @@ struct Console
      */
     private static void render_char(size_t x, size_t y, char ch)
     {
-        const(CharInfo) * ci = &Kfont.chars[ch];
+        const(CharInfo) * ci = &kfont.chars[ch];
-        Fb.blit_alpha_bitmap(fb_x(x) + ci.left, fb_y(y) + ci.top - ci.height, ci.bitmap, ci.width, ci.height);
+        fb.blit_alpha_bitmap(fb_x(x) + ci.left, fb_y(y) + ci.top - ci.height, ci.bitmap, ci.width, ci.height);
     }
 
     /**
@@ -89,7 +89,7 @@ struct Console
      */
     private static size_t fb_x(size_t x)
     {
-        return x * Kfont.advance;
+        return x * kfont.advance;
     }
 
     /**
@@ -97,6 +97,6 @@ struct Console
      */
     private static size_t fb_y(size_t y)
     {
-        return Fb.height - ((y + 1u) * Kfont.line_height);
+        return fb.height - ((y + 1u) * kfont.line_height);
     }
 }

src/hulk/cpu.d

@@ -221,9 +221,9 @@ ushort in16(ushort ioaddr)
     return __asm!ushort("inw %dx, %ax", "={ax},{dx}", ioaddr);
 }
 
-uint in32(ushort ioaddr)
+ulong in32(ushort ioaddr)
 {
-    return __asm!uint("inl %dx, %eax", "={eax},{dx}", ioaddr);
+    return __asm!ulong("inl %dx, %eax", "={eax},{dx}", ioaddr);
 }
 
 void out8(ushort ioaddr, ubyte v)
@@ -236,7 +236,7 @@ void out16(ushort ioaddr, ushort v)
     __asm("outw %ax, %dx", "{dx},{ax}", ioaddr, v);
 }
 
-void out32(ushort ioaddr, uint v)
+void out32(ushort ioaddr, ulong v)
 {
     __asm("outl %eax, %dx", "{dx},{eax}", ioaddr, v);
 }

src/hulk/fb.d

@@ -11,7 +11,7 @@ import hulk.kfont;
  *
  * TODO: Handle other pixel formats. Currently only BGRx is supported.
  */
-struct Fb
+struct fb
 {
     /** Device frame buffer base address. */
     private __gshared static uint * m_device_buffer;
@@ -141,8 +141,8 @@ struct Fb
      */
     static void character(int x, int y, char ch, uint color)
     {
-        const(CharInfo) * ci = &Kfont.chars[ch];
+        const(CharInfo) * ci = &kfont.chars[ch];
-        blend_alpha_bitmap(x + ci.left, y + Kfont.baseline_offset + ci.top - ci.height, ci.bitmap, ci.width, ci.height, color);
+        blend_alpha_bitmap(x + ci.left, y + kfont.baseline_offset + ci.top - ci.height, ci.bitmap, ci.width, ci.height, color);
     }
 
     /**

src/hulk/gdt.d

@@ -5,7 +5,7 @@ module hulk.gdt;
 
 import ldc.llvmasm;
 
-struct Gdt
+struct gdt
 {
     struct gdtr_t
     {

src/hulk/hippo.d

@@ -7,7 +7,7 @@
  */
 module hulk.hippo;
 
-struct Hippo
+struct hippo
 {
     /**
      * Linked list node entry for a physical page.

src/hulk/hulk.d

@@ -21,7 +21,7 @@ import hulk.pic;
 import hulk.acpi;
 import hulk.apic;
 import hulk.rtc;
-import hulk.serial;
+import hulk.pit;
 
 extern extern(C) __gshared ubyte _hulk_bss_size;
 
@@ -30,9 +30,9 @@ private __gshared HulkHeader hulk_header = {
     &_hulk_bss_size, /* hulk_bss_size */
     &hulk_start, /* entry */
     16u * 1024u, /* stack_size */
-    Hurl.HULK_BASE, /* virt_base */
+    HULK_VIRTUAL_BASE_ADDRESS, /* virt_base */
-    Hurl.HULK_STACK_TOP, /* virt_stack_top */
+    HULK_VIRTUAL_STACK_TOP_ADDRESS, /* virt_stack_top */
-    Hurl.HULK_FRAMEBUFFER, /* virt_fb_buffer */
+    HULK_VIRTUAL_FRAMEBUFFER_ADDRESS, /* virt_fb_buffer */
 };
 
 private void initialize_cpu()
@@ -57,26 +57,26 @@ void hulk_start()
 {
     cli();
     initialize_cpu();
-    Serial.initialize();
+    gdt.initialize();
-    Gdt.initialize();
+    idt.initialize();
-    Idt.initialize();
+    fb.initialize(cast(uint *)HULK_VIRTUAL_FRAMEBUFFER_ADDRESS,
-    Fb.initialize(cast(uint *)Hurl.HULK_FRAMEBUFFER,
             cast(uint *)hulk_header.bootinfo.fb_buffer1_phys,
             hulk_header.bootinfo.fb.width,
             hulk_header.bootinfo.fb.height,
             hulk_header.bootinfo.fb.stride);
-    Console.initialize();
+    console.initialize();
-    Console.clear();
+    console.clear();
-    Klog.initialize();
+    klog.initialize();
 
-    Klog.writefln("Welcome to HULK, the HOS UltraLight Kernel!");
+    klog.writefln("Welcome to HULK, the HOS UltraLight Kernel!");
 
-    Hurl.initialize(&hulk_header);
+    hurl.initialize(&hulk_header);
-    Pci.initialize();
+    pci.initialize();
-    Pic.initialize();
+    pic.initialize();
-    Acpi.initialize(hulk_header.bootinfo.acpi_xsdt_phys);
+    acpi.initialize(hulk_header.bootinfo.acpi_xsdt_phys);
-    Apic.initialize();
+    apic.initialize();
-    Rtc.initialize();
+    rtc.initialize();
+    pit.initialize();
     sti();
 
     for (;;)

src/hulk/hurl.d

@@ -3,7 +3,7 @@
  *
  * HURL provides virtual memory management for HULK.
  */
-module hulk.hurl.hurl;
+module hulk.hurl;
 
 public import hulk.pagetable;
 import hulk.cpu;
@@ -13,22 +13,18 @@ import hulk.klog;
 import hulk.bootinfo;
 import hulk.header;
 import hulk.linker_addresses;
-import hulk.util;
 
-struct Hurl
+/** HULK virtual base address. */
+enum ulong HULK_VIRTUAL_BASE_ADDRESS = 0xFFFF_8000_0000_0000u;
+
+/** HULK virtual stack top address. */
+enum ulong HULK_VIRTUAL_STACK_TOP_ADDRESS = 0xFFFF_A000_0000_0000u;
+
+/** HULK virtual framebuffer address. */
+enum ulong HULK_VIRTUAL_FRAMEBUFFER_ADDRESS = 0xFFFF_A000_0000_0000u;
+
+struct hurl
 {
-    /** HULK base address. */
-    enum ulong HULK_BASE = 0xFFFF_8000_0000_0000u;
-
-    /** HULK stack top address. */
-    enum ulong HULK_STACK_TOP = 0xFFFF_8001_0000_0000u;
-
-    /** HULK framebuffer address. */
-    enum ulong HULK_FRAMEBUFFER = 0xFFFF_8001_0000_0000u;
-
-    /** A1 allocator range base address. */
-    enum ulong A1_BASE = 0xFFFF_8002_0000_0000u;
-
     /**
      * Pointer to the base page table.
      */
@@ -49,7 +45,7 @@ struct Hurl
                 physical_address_limit,
                 PT_WRITABLE | PT_NO_EXECUTE);
         ulong phys_address = header.bootinfo.hulk_phys;
-        ulong virt_address = HULK_BASE;
+        ulong virt_address = HULK_VIRTUAL_BASE_ADDRESS;
         /* Map HULK header region. */
         map_range(virt_address,
                 phys_address,
@@ -83,12 +79,12 @@ struct Hurl
                 LinkerAddresses.hulk_bss_size,
                 PT_WRITABLE | PT_NO_EXECUTE);
         /* Map HULK stack. */
-        map_range(HULK_STACK_TOP - header.stack_size,
+        map_range(HULK_VIRTUAL_STACK_TOP_ADDRESS - header.stack_size,
                 header.bootinfo.stack_phys,
                 header.stack_size,
                 PT_WRITABLE | PT_NO_EXECUTE);
         /* Map device framebuffer. */
-        map_range(HULK_FRAMEBUFFER,
+        map_range(HULK_VIRTUAL_FRAMEBUFFER_ADDRESS,
                 cast(ulong)header.bootinfo.fb.buffer,
                 header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u,
                 PT_WRITABLE | PT_NO_EXECUTE);
@@ -125,7 +121,7 @@ struct Hurl
                 reclaimed_pages += reclaim_bootloader_page_table_pages(pte.follow(), level + 1u);
             }
         }
-        Hippo.free_page(pt);
+        hippo.free_page(pt);
         reclaimed_pages++;
         return reclaimed_pages;
     }
@@ -156,7 +152,7 @@ struct Hurl
          */
         size_t usable_memory;
         size_t physical_address_limit;
-        const(size_t) fb_size = round_up_power_2(header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u, PAGE_SIZE);
+        const(size_t) fb_size = (header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
         ulong[2][2] reserved = [
             [header.bootinfo.hulk_phys, LinkerAddresses.hulk_binary_size],
             [cast(ulong)header.bootinfo.fb.buffer, fb_size],
@@ -190,7 +186,7 @@ struct Hurl
                     }
                     if (!is_reserved)
                     {
-                        Hippo.free_page(phys);
+                        hippo.free_page(phys);
                     }
                     phys += PAGE_SIZE;
                 }
@@ -217,11 +213,11 @@ struct Hurl
         usable_memory += LinkerAddresses.hulk_bss_size;
         usable_memory += header.stack_size;
         usable_memory += fb_size;
-        Klog.writefln("Usable memory: %uKB", usable_memory >> 10u);
+        klog.writefln("Usable memory: %uKB", usable_memory >> 10u);
-        Klog.writefln("Kernel size: %uKB", (LinkerAddresses.hulk_binary_size + LinkerAddresses.hulk_bss_size + header.stack_size) >> 10u);
+        klog.writefln("Kernel size: %uKB", (LinkerAddresses.hulk_binary_size + LinkerAddresses.hulk_bss_size + header.stack_size) >> 10u);
     }
 
-    public static void map(ulong virtual, ulong physical, ulong flags)
+    public static void map(T, U)(T virtual, U physical, ulong flags)
     {
         PageTable * pt = m_pt_base;
         for (size_t level = 0; level < 4u; level++)
@@ -248,12 +244,7 @@ struct Hurl
         }
     }
 
-    public static void map(T, U)(T virtual, U physical, ulong flags)
+    public static void map_range(size_t virtual, size_t physical, size_t length, ulong flags)
-    {
-        map(cast(ulong)virtual, cast(ulong)physical, flags);
-    }
-
-    public static void map_range(ulong virtual, ulong physical, size_t length, ulong flags)
     {
         size_t end = virtual + length;
         while (virtual < end)
@@ -264,33 +255,23 @@ struct Hurl
         }
     }
 
-    public static void map_range(T, U)(T virtual, U physical, size_t length, ulong flags)
+    public static void identity_map_range(size_t address, size_t length, ulong flags)
-    {
-        map_range(cast(ulong)virtual, cast(ulong)physical, length, flags);
-    }
-
-    public static void identity_map_range(ulong address, size_t length, ulong flags)
     {
         size_t end = address + length;
-        for (size_t page = address & 0xFFFF_FFFF_FFFF_F000u; page < end; page += PAGE_SIZE)
+        for (size_t page = address & ~0xFFFu; page < end; page += PAGE_SIZE)
         {
             map(page, page, flags);
         }
     }
 
-    public static void identity_map_range(T)(T address, size_t length, ulong flags)
-    {
-        identity_map_range(cast(ulong)address, length, flags);
-    }
-
     public static void debug_lookup(void * address)
     {
-        Klog.writefln("Debugging page table lookup of 0x%x", address);
+        klog.writefln("Debugging page table lookup of 0x%x", address);
         PageTable * pt = m_pt_base;
         for (size_t level = 0; level < 4u; level++)
         {
             PageTableEntry pte = *pt.entry(address, level);
-            Klog.writefln("Level %u, index %u, entry = 0x%x", level, pt.index(address, level), pte);
+            klog.writefln("Level %u, index %u, entry = 0x%x", level, pt.index(address, level), pte);
             if (pte.present)
             {
                 pt = pte.follow();
@@ -308,7 +289,7 @@ struct Hurl
 
     private static PageTable * allocate_pt()
     {
-        PageTable * pt = cast(PageTable *)Hippo.allocate_page();
+        PageTable * pt = cast(PageTable *)hippo.allocate_page();
         memset64(pt, 0u, PAGE_SIZE / 8u);
         return pt;
     }

src/hulk/hurl/a1.d

@@ -1,64 +0,0 @@
-/**
- * A1 memory allocator.
- */
-module hulk.hurl.a1;
-
-import hulk.hurl;
-import hulk.hippo;
-import hulk.util;
-import hulk.pagetable;
-
-/**
- * The A1 memory allocator is a one-shot memory allocator for kernel memory
- * that is allocated but never freed.
- */
-struct A1
-{
-    /**
-     * Number of bytes allocated in the A1 region so far.
-     */
-    private static __gshared size_t allocated;
-
-    /**
-     * Allocate memory.
-     *
-     * @param size
-     *   Size of memory to allocate.
-     *
-     * @return Address of allocated memory. This address will always be aligned
-     *   to a multiple of 16 bytes.
-     */
-    public static void * allocate(size_t size)
-    {
-        /* Round size up to a multiple of 16. */
-        size = round_up_power_2(size, 16u);
-
-        ulong address = Hurl.A1_BASE + allocated;
-
-        ulong current_limit = round_up_power_2(address, PAGE_SIZE);
-
-        allocated += size;
-
-        ulong desired_limit = round_up_power_2(Hurl.A1_BASE + allocated, PAGE_SIZE);
-
-        while (desired_limit > current_limit)
-        {
-            void * page = Hippo.allocate_page();
-            Hurl.map(current_limit, page, PT_WRITABLE);
-            current_limit += PAGE_SIZE;
-        }
-
-        return cast(void *)address;
-    }
-
-    /**
-     * Allocate memory to store an instance of a given type.
-     *
-     * @return Address of allocated memory. This address will always be aligned
-     *   to a multiple of 16 bytes.
-     */
-    public static T * allocate(T)()
-    {
-        return cast(T *)allocate(T.sizeof);
-    }
-}

src/hulk/hurl/package.d

@@ -1,3 +0,0 @@
-module hulk.hurl;
-
-public import hulk.hurl.hurl;

src/hulk/idt.d

@@ -9,17 +9,16 @@ import hulk.fb;
 import hulk.console;
 import hulk.klog;
 import hulk.apic;
+import hulk.rtc;
 
-struct Idt
+struct idt
 {
     /* The I/O APIC is configured to map IRQ 0 to interrupt 64 (0x40). */
-    public static enum ulong INT_APIC_BASE = 0x40u; /* IRQ 0 */
+    public static enum ulong INT_RTC = 0x48u; /* IRQ 8 */
-    public static enum ulong INT_APIC_COUNT = 24u;
 
-    public static enum ulong INT_APIC_TIMER = 0x70u;
+    public static enum ulong INT_LAPIC_TIMER = 0x70u;
-    public static enum ulong INT_APIC_LINT0 = 0x71u;
+    public static enum ulong INT_LAPIC_LINT0 = 0x71u;
-    public static enum ulong INT_APIC_LINT1 = 0x72u;
+    public static enum ulong INT_LAPIC_LINT1 = 0x72u;
-    public static enum ulong INT_APIC_SPURIOUS = 0xFFu;
 
     struct idtr_t
     {
@@ -96,7 +95,7 @@ struct Idt
             ((offset & 0xFFFF_0000u) << 32u) |
             (dpl << 45u) |
             ((trap ? 1uL : 0uL) << 40u) |
-            (Gdt.SELECTOR_KERNEL_CODE << 16u) |
+            (gdt.SELECTOR_KERNEL_CODE << 16u) |
             (offset & 0xFFFFu);
         idt[index][1] = offset >> 32u;
     }
@@ -104,30 +103,26 @@ struct Idt
 
 public extern(C) void isr(ulong vector, ulong arg)
 {
-    if ((vector >= Idt.INT_APIC_BASE) && (vector < (Idt.INT_APIC_BASE + Idt.INT_APIC_COUNT)))
-    {
-        Apic.isr(vector);
-    }
-    else
-    {
     switch (vector)
     {
-        case Idt.INT_APIC_TIMER:
+    case idt.INT_RTC:
-        case Idt.INT_APIC_LINT0:
+        rtc.isr();
-        case Idt.INT_APIC_LINT1:
+        break;
-        case Idt.INT_APIC_SPURIOUS:
+
-            Apic.isr(vector);
+    case idt.INT_LAPIC_TIMER:
+    case idt.INT_LAPIC_LINT0:
+    case idt.INT_LAPIC_LINT1:
+        apic.isr(vector);
         break;
 
     default:
-            Console.clear();
+        console.clear();
-            Fb.clear(0xFF8000u);
+        fb.clear(0xFF8000u);
-            Klog.writefln("ISR %u, 0x%x", vector, arg);
+        klog.writefln("ISR %u, 0x%x", vector, arg);
         __asm("cli", "");
         for (;;)
         {
             __asm("hlt", "");
         }
     }
-    }
 }

src/hulk/klog.d

@@ -7,7 +7,7 @@ import core.stdc.stdarg;
 import hulk.console;
 static import hulk.writef;
 
-struct Klog
+struct klog
 {
     /**
      * Kernel buffer size log.
@@ -40,7 +40,7 @@ struct Klog
     public static void writef(string s, va_list args)
     {
         hulk.writef.writef(s, args, function void(ubyte ch) {
-                    Console.write(ch);
+                    console.write(ch);
                 });
     }
 
@@ -58,7 +58,7 @@ struct Klog
     }
 
     /**
-     * Write a formatted string and newline to the kernel log.
+     * Write a formatted string and newline to the console.
      *
      * @param s Format string.
      */

src/hulk/mtrr.d

@@ -31,7 +31,7 @@ enum ulong MTRRPHYSBASE_TYPE_MASK = 0xFFu;
 enum ulong MTRRPHYSMASK_PHYSMASK_MASK = 0x000F_FFFF_FFFF_F000u;
 enum ulong MTRRPHYSMASK_VALID = 0x800u;
 
-struct Mtrr
+struct mtrr
 {
     public static void initialize()
     {
@@ -41,7 +41,7 @@ struct Mtrr
         cpuid1(&ebx, &ecx, &edx);
         if ((edx & CPUID_1_EDX_MTRR) == 0u)
         {
-            Klog.writefln("CPU does not support MTRR");
+            klog.writefln("CPU does not support MTRR");
             return;
         }
         const(ulong) mtrrcap = rdmsr(MSR_MTRRCAP);

src/hulk/pci.d

@@ -2,12 +2,8 @@ module hulk.pci;
 
 import hulk.cpu;
 import hulk.klog;
-import hulk.hurl;
-import hulk.hurl.a1;
-import hulk.range;
-import hulk.usb.xhci;
 
-struct Pci
+struct pci
 {
     /* IO address for PCI configuration address. */
     enum IO_ADDR_CONFIG_ADDRESS = 0xCF8u;
@@ -15,214 +11,38 @@ struct Pci
     /* IO address for PCI configuration data. */
     enum IO_ADDR_CONFIG_DATA = 0xCFCu;
 
-    struct Address
+    private static ulong read_config_register(ulong bus_id, ulong device_id, ulong register_id)
     {
-        /** Bus number (0-255). */
+        ulong addr = 0x8000_0000u | (bus_id << 16u) | (device_id << 11u) | (register_id << 2u);
-        ubyte bus_nr;
+        out32(IO_ADDR_CONFIG_ADDRESS, addr);
-
-        /** Device number (0-31). */
-        ubyte device_nr;
-
-        /** Function number (0-7). */
-        ubyte function_nr;
-    }
-
-    struct Device
-    {
-        Address address;
-        ushort vendor_id;
-        ushort device_id;
-        ubyte class_id;
-        ubyte subclass_id;
-        ubyte if_id;
-        bool multifunction;
-        ubyte header_type;
-        Range[6] memory_ranges;
-
-        void initialize(Address address, ushort vendor_id, ushort device_id)
-        {
-            this.address = address;
-            this.vendor_id = vendor_id;
-            this.device_id = device_id;
-            uint reg2 = read_config_register(address, 2u);
-            class_id = (reg2 >> 24u) & 0xFFu;
-            subclass_id = (reg2 >> 16u) & 0xFFu;
-            if_id = (reg2 >> 8u) & 0xFFu;
-            Klog.writefln("Found PCI device %04x:%04x (%02x:%02x:%02x) at %02u:%02u.%u",
-                    vendor_id, device_id,
-                    class_id, subclass_id, if_id,
-                    address.bus_nr, address.device_nr, address.function_nr);
-            uint reg3 = read_config_register(address, 3u);
-            header_type = (reg3 >> 16u) & 0x7Fu;
-            multifunction = (address.function_nr == 0u) && ((reg3 & (1u << 23u)) != 0u);
-
-            if (header_type == 0u)
-            {
-                map_memory_regions();
-            }
-        }
-
-        private void map_memory_regions()
-        {
-            size_t range_index;
-            uint[2] r;
-            uint[2] s;
-            for (uint reg_no = 4u; reg_no <= 9u; reg_no++)
-            {
-                /* Read the BAR. */
-                r[0] = read_config_register(address, reg_no);
-                /* Skip zeroed BARs. */
-                if (r[0] == 0u)
-                {
-                    continue;
-                }
-                /* Skip I/O BARs. */
-                if ((r[0] & 1u) != 0u)
-                {
-                    continue;
-                }
-                bool is_64bit;
-                uint bar_type = (r[0] >> 1u) & 0x3u;
-                if (bar_type == 0u)
-                {
-                    /* 32-bit region. */
-                    r[1] = 0u;
-                }
-                else if ((bar_type == 2u) && (reg_no < 9u))
-                {
-                    /* 64-bit region. */
-                    is_64bit = true;
-                    r[1] = read_config_register(address, reg_no + 1);
-                }
-                else
-                {
-                    continue;
-                }
-
-                /* Determine the region length. */
-                write_config_register(address, reg_no, 0xFFFF_FFFFu);
-                s[0] = read_config_register(address, reg_no);
-                write_config_register(address, reg_no, r[0]);
-                if (is_64bit)
-                {
-                    write_config_register(address, reg_no + 1, 0xFFFF_FFFFu);
-                    s[1] = read_config_register(address, reg_no + 1);
-                    write_config_register(address, reg_no + 1, r[1]);
-                }
-                else
-                {
-                    s[1] = 0xFFFF_FFFFu;
-                }
-                ulong mm_region_address = (cast(ulong)r[0] & 0xFFFF_FFF0u) | (cast(ulong)r[1] << 32u);
-                ulong length = ~((cast(ulong)s[0] & 0xFFFF_FFF0u) | (cast(ulong)s[1] << 32u)) + 1u;
-                ulong flags = (r[0] & 0x8) != 0u ? PT_WRITE_THROUGH : 0u;
-                Hurl.identity_map_range(mm_region_address, length, flags);
-                memory_ranges[range_index].address = mm_region_address;
-                memory_ranges[range_index].length = length;
-                range_index++;
-                if (is_64bit)
-                {
-                    reg_no++;
-                }
-            }
-        }
-
-        private void spawn_device_instance()
-        {
-            switch (class_id)
-            {
-            case SerialBusController.ID:
-                switch (subclass_id)
-                {
-                case SerialBusController.USBController.ID:
-                    switch (if_id)
-                    {
-                    case SerialBusController.USBController.XHCIController.ID:
-                        XHCI.build(&this);
-                        break;
-
-                    default:
-                        break;
-                    }
-                    break;
-
-                default:
-                    break;
-                }
-                break;
-
-            default:
-                break;
-            }
-        }
-    }
-
-    struct SerialBusController
-    {
-        enum ID = 0x0Cu;
-
-        struct USBController
-        {
-            enum ID = 0x03u;
-
-            struct XHCIController
-            {
-                enum ID = 0x30u;
-            }
-        }
-    }
-
-    private static uint read_config_register(Address address, uint register_id)
-    {
-        uint cfg_addr = 0x8000_0000u |
-            (address.bus_nr << 16u) |
-            (address.device_nr << 11u) |
-            (address.function_nr << 8u) |
-            (register_id << 2u);
-        out32(IO_ADDR_CONFIG_ADDRESS, cfg_addr);
         return in32(IO_ADDR_CONFIG_DATA);
     }
 
-    private static void write_config_register(Address address, uint register_id, uint value)
+    private static void scan(ulong bus_id, ulong device_id)
     {
-        uint cfg_addr = 0x8000_0000u |
+        ulong reg0 = read_config_register(bus_id, device_id, 0u);
-            (address.bus_nr << 16u) |
-            (address.device_nr << 11u) |
-            (address.function_nr << 8u) |
-            (register_id << 2u);
-        out32(IO_ADDR_CONFIG_ADDRESS, cfg_addr);
-        out32(IO_ADDR_CONFIG_DATA, value);
-    }
-
-    private static void scan(Address address)
-    {
-        ulong reg0 = read_config_register(address, 0u);
         if (reg0 != 0xFFFFFFFFu)
         {
-            ushort vendor_id = reg0 & 0xFFFFu;
+            ulong reg2 = read_config_register(bus_id, device_id, 2u);
-            ushort device_id = (reg0 >> 16u) & 0xFFFFu;
+            klog.writefln("Found PCI device %04x:%04x (%02x:%02x:%02x) at %02u:%02u",
-            Device * device = A1.allocate!Device();
+                    (reg0 & 0xFFFFu), (reg0 >> 16u),
-            device.initialize(address, vendor_id, device_id);
+                    (reg2 >> 24u) & 0xFFu,
-            if (device.multifunction)
+                    (reg2 >> 16u) & 0xFFu,
-            {
+                    (reg2 >> 8u) & 0xFFu,
-                for (address.function_nr = 1u; address.function_nr < 8u; address.function_nr++)
+                    bus_id, device_id);
-                {
-                    scan(address);
-                }
-            }
         }
     }
 
     public static void initialize()
     {
-        Klog.writefln("Scanning PCI devices...");
+        klog.writefln("Scanning PCI devices...");
-        for (uint bus_nr = 0u; bus_nr < 256u; bus_nr++)
+        for (ulong bus_id = 0u; bus_id < 256u; bus_id++)
         {
-            for (ubyte device_nr = 0u; device_nr < 32u; device_nr++)
+            for (ulong device_id = 0u; device_id < 32u; device_id++)
             {
-                scan(Address(cast(ubyte)bus_nr, device_nr, 0u));
+                scan(bus_id, device_id);
             }
         }
-        Klog.writefln("PCI scan complete.");
+        klog.writefln("PCI scan complete.");
     }
 }

src/hulk/pic.d

@@ -5,7 +5,7 @@ module hulk.pic;
 
 import hulk.cpu;
 
-struct Pic
+struct pic
 {
     public static void initialize()
     {

src/hulk/pit.d

@@ -6,7 +6,7 @@ module hulk.pit;
 import hulk.cpu;
 import hulk.klog;
 
-struct Pit
+struct pit
 {
     /** PIT input frequency in 1/1000 Hz. */
     private enum ulong PIT_FREQUENCY_1000HZ = 1_193_181_667u;
@@ -37,6 +37,6 @@ struct Pit
 
     public static void isr()
     {
-        Klog.writefln("PIT ISR");
+        klog.writefln("PIT ISR");
     }
 }

src/hulk/range.d

@@ -1,27 +0,0 @@
-module hulk.range;
-
-/**
- * Representation of a memory range.
- */
-struct Range
-{
-    /** Range base address. */
-    void * _address;
-
-    /** Range length. */
-    size_t length;
-
-    /** Set the range address. */
-    @property void * address(T)(T a)
-    {
-        static assert(T.sizeof == size_t.sizeof);
-        _address = cast(void *)a;
-        return _address;
-    }
-
-    /** Get the range address. */
-    @property void * address()
-    {
-        return _address;
-    }
-}

src/hulk/rtc.d

@@ -5,77 +5,41 @@ module hulk.rtc;
 
 import hulk.cpu;
 import hulk.klog;
+import hulk.apic;
 
-struct Rtc
+struct rtc
 {
     private enum ubyte PORT_SELECT = 0x70u;
     private enum ubyte PORT_DATA = 0x71u;
 
     private enum ubyte DISABLE_NMI = 0x80u;
 
-    private enum ubyte REG_RTC_SECONDS = 0x0u;
+    private enum ubyte SR_A = 0xAu;
-    private enum ubyte REG_RTC_MINUTES = 0x2u;
+    private enum ubyte SR_B = 0xBu;
-    private enum ubyte REG_RTC_HOURS = 0x4u;
+    private enum ubyte SR_C = 0xCu;
-    private enum ubyte REG_RTC_DAY = 0x7u;
-    private enum ubyte REG_RTC_MONTH = 0x8u;
-    private enum ubyte REG_RTC_YEAR = 0x9u;
-    private enum ubyte REG_SR_A = 0xAu;
-    private enum ubyte REG_SR_B = 0xBu;
-    private enum ubyte REG_SR_C = 0xCu;
 
-    private enum ubyte SR_A_RTC_UPDATE_IN_PROGRESS = 0x80u;
-    private enum ubyte SR_B_24HOUR = 0x02u;
-    private enum ubyte SR_B_BINARY = 0x04u;
     private enum ubyte SR_B_ENABLE_IRQ = 0x40u;
 
-    private static __gshared bool rtc_24hour_mode;
-    private static __gshared bool rtc_binary_mode;
-
-    static struct time
-    {
-        public ubyte year;
-        public ubyte month;
-        public ubyte day;
-        public ubyte hour;
-        public ubyte minute;
-        public ubyte second;
-    }
-
     public static void initialize()
     {
         /* Enable IRQ 8 to receive RTC interrupts. */
-        ubyte sr_b = read_register(REG_SR_B, true);
+        out8(PORT_SELECT, DISABLE_NMI | SR_B);
-        write_register(REG_SR_B, sr_b | SR_B_ENABLE_IRQ, true);
+        ubyte sr_b = in8(PORT_DATA);
+        out8(PORT_SELECT, DISABLE_NMI | SR_B);
+        out8(PORT_DATA, sr_b | SR_B_ENABLE_IRQ);
 
-        /* Record RTC mode flags from status register B. */
+        out8(PORT_SELECT, DISABLE_NMI | SR_A);
-        rtc_24hour_mode = (sr_b & SR_B_24HOUR) != 0u;
+        klog.writefln("SR_A = 0x%x", in8(PORT_DATA));
-        rtc_binary_mode = (sr_b & SR_B_BINARY) != 0u;
-
-        /* Read the current system time. */
-        time t = read_rtc_time();
-        Klog.writefln("System time is 20%02u-%02u-%02u %02u:%02u:%02u",
-                t.year, t.month, t.day, t.hour, t.minute, t.second);
 
         /* Send EOI to enable more RTC interrupts and re-enable NMIs. */
         eoi();
     }
 
-    private static ubyte read_register(ubyte register, bool disable_nmi = false)
-    {
-        out8(PORT_SELECT, register | (disable_nmi ? DISABLE_NMI : 0u));
-        return in8(PORT_DATA);
-    }
-
-    private static void write_register(ubyte register, ubyte value, bool disable_nmi = false)
-    {
-        out8(PORT_SELECT, register | (disable_nmi ? DISABLE_NMI : 0u));
-        out8(PORT_DATA, value);
-    }
-
     private static void eoi()
     {
         /* Read from status register C to clear the interrupt. */
-        read_register(REG_SR_C);
+        out8(PORT_SELECT, SR_C);
+        in8(PORT_DATA);
     }
 
     public static void isr()
@@ -86,64 +50,9 @@ struct Rtc
         if ((count % 1024) == 0u)
         {
             seconds++;
+            klog.writefln("Seconds: %u", seconds);
         }
         eoi();
-    }
+        apic.eoi();
-
-    private static time read_rtc_time()
-    {
-        time[2] times;
-        size_t reads;
-        do
-        {
-            times[reads & 1] = read_rtc_time_unsafe();
-            reads++;
-        } while ((reads < 2u) || (times[0] != times[1]));
-        return times[0];
-    }
-
-    private static time read_rtc_time_unsafe()
-    {
-        time t;
-        while ((read_register(REG_SR_A) & SR_A_RTC_UPDATE_IN_PROGRESS) != 0u)
-        {
-        }
-        t.year = read_rtc_time_register(REG_RTC_YEAR);
-        t.month = read_rtc_time_register(REG_RTC_MONTH);
-        t.day = read_rtc_time_register(REG_RTC_DAY);
-        t.minute = read_rtc_time_register(REG_RTC_MINUTES);
-        t.second = read_rtc_time_register(REG_RTC_SECONDS);
-        /* Hour field is treated differently because it might have 'PM' flag
-         * in highest bit if we're in 24-hour mode. */
-        ubyte hour = read_register(REG_RTC_HOURS);
-        ubyte pm = hour >> 7u;
-        hour &= 0x7Fu;
-        if (!rtc_binary_mode)
-        {
-            /* Hour is in BCD format; convert to binary. */
-            hour = bcd_to_binary(hour);
-        }
-        if (!rtc_24hour_mode)
-        {
-            /* Hour is in 12-hour format; convert to 24-hour format. */
-            hour = cast(ubyte)((hour % 12u) + pm * 12u);
-        }
-        t.hour = hour;
-        return t;
-    }
-
-    private static ubyte read_rtc_time_register(ubyte register)
-    {
-        ubyte value = read_register(register);
-        if (!rtc_binary_mode)
-        {
-            value = bcd_to_binary(value);
-        }
-        return value;
-    }
-
-    private static ubyte bcd_to_binary(ubyte bcd)
-    {
-        return (bcd & 0xFu) + ((bcd & 0xF0u) >> 4u) * 10u;
     }
 }

src/hulk/serial.d

@@ -1,74 +0,0 @@
-/**
- * Serial port access.
- */
-module hulk.serial;
-
-import hulk.cpu;
-import core.stdc.stdarg;
-static import hulk.writef;
-
-struct Serial
-{
-    enum BASE_PORT = 0x3F8;
-
-    /**
-     * Initialize the serial module.
-     */
-    static void initialize()
-    {
-    }
-
-    /**
-     * Write a character to the serial port.
-     *
-     * @param ch Character to write.
-     */
-    static void write(ubyte ch)
-    {
-        if (ch == '\n')
-        {
-            out8(BASE_PORT, '\r');
-        }
-        out8(BASE_PORT, ch);
-    }
-
-    /**
-     * Write a formatted string to the serial port.
-     *
-     * @param s Format string.
-     * @param args Variable arguments structure.
-     */
-    public static void writef(string s, va_list args)
-    {
-        hulk.writef.writef(s, args, function void(ubyte ch) {
-                    Serial.write(ch);
-                });
-    }
-
-    /**
-     * Write a formatted string to the serial port.
-     *
-     * @param s Format string.
-     */
-    public static extern (C) void writef(string s, ...)
-    {
-        va_list args;
-        va_start(args, s);
-        writef(s, args);
-        va_end(args);
-    }
-
-    /**
-     * Write a formatted string and newline to the serial port.
-     *
-     * @param s Format string.
-     */
-    public static extern (C) void writefln(string s, ...)
-    {
-        va_list args;
-        va_start(args, s);
-        writef(s, args);
-        writef("\n", args);
-        va_end(args);
-    }
-}

src/hulk/usb/xhci.d

@@ -1,89 +0,0 @@
-/**
- * eXtensible Host Controller Interface for Universal Serial Bus
- *
- * Documentation:
- * - https://wiki.osdev.org/EXtensible_Host_Controller_Interface
- * - https://www.intel.com/content/dam/www/public/us/en/documents/technical-specifications/extensible-host-controler-interface-usb-xhci.pdf
- */
-
-module hulk.usb.xhci;
-
-import hulk.pci;
-import hulk.hurl.a1;
-
-struct XHCI
-{
-    /**
-     * Located at PCI base address.
-     */
-    struct CapabilityRegisters
-    {
-        ubyte capability_length;
-        ubyte _reserved01;
-        ushort hci_version;
-        uint[3] hcs_params;
-        uint hcc_params1;
-        uint doorbell_offset;
-        uint rts_offset;
-        uint hcc_params2;
-    }
-    static assert(CapabilityRegisters.sizeof == 0x20u);
-
-    /**
-     * Located at offset capability_length from PCI base address.
-     */
-    struct OperationalRegisters
-    {
-        uint usb_command;
-        uint usb_status;
-        uint page_size;
-        uint[2] _reserved01;
-        uint dn_ctrl;
-        ulong cr_ctrl;
-        uint[4] _reserved02;
-        ulong dcbaap;
-        uint config;
-        uint _reserved03;
-    }
-    static assert(OperationalRegisters.sizeof == 0x40u);
-
-    /**
-     * Located at offset 0x400 from start of Operational Registers.
-     */
-    struct PortRegisters
-    {
-        uint portsc;
-        uint portpmsc;
-        uint portli;
-        uint porthlpmc;
-    }
-    static assert(PortRegisters.sizeof == 0x10u);
-
-    struct RuntimeRegisters
-    {
-        uint mfindex;
-        uint[7] _reserved01;
-        uint ir;
-    }
-
-    struct DoorbellRegister
-    {
-        ubyte target;
-        ubyte _reserved01;
-        ushort task_id;
-    }
-    static assert(DoorbellRegister.sizeof == 4u);
-
-    void initialize(Pci.Device * pci_device)
-    {
-    }
-
-    static void build(Pci.Device * pci_device)
-    {
-        if (pci_device.memory_ranges[0].address != null)
-        {
-            XHCI * xhci = A1.allocate!XHCI();
-            xhci.initialize(pci_device);
-        }
-    }
-}

src/hulk/util.d

@@ -1,17 +0,0 @@
-/**
- * HULK utility functions.
- */
-module hulk.util;
-
-/**
- * Round a value up to the next power of 2.
- *
- * @param v Value to round up.
- * @param p Power of 2 to round up to.
- *
- * @return Rounded up value.
- */
-ulong round_up_power_2(ulong v, ulong p)
-{
-    return (v + p - 1u) & ~(p - 1u);
-}

src/hulk/writef.d

@@ -26,15 +26,7 @@ size_t writef(string s, va_list args, ch_out_fn ch_out)
     {
         if (escape)
         {
-            if (c == 'c')
+            if (c == 'x')
-            {
-                ulong ch;
-                va_arg(args, ch);
-                ch_out(cast(ubyte)ch);
-                length_written++;
-                escape = false;
-            }
-            else if (c == 'x')
             {
                 ulong v;
                 va_arg(args, v);