commit 3ba5665754be9783f009ea8139e8ff288c4e831a · pci.express/frostium

+2 -5

components/ukernel/arch/amd64/boot.zig

···

       2
       2
        
       const std = @import("std");

     

       3
       3
        
       const arch = @import("root.zig");

     

       4
       4
        
       const common = @import("common");

     

       5
       5
       -
       const console = @import("console");

     

       6
       5
        
       const flanterm = @import("flanterm");

     

       7
       6
        
       const log = std.log.scoped(.amd64_init);

     

       8
       7
        
       const StandardGdt = arch.structures.gdt.StandardGdt;

     
···

       233
       232
        
                   break :blk .{ .xapic = apic_base };

     

       234
       233
        
               },

     

       235
       234
        
           };

     

       236
       236
       -
           // Set up the spurious vector and the TPR

     

       235
       235
       +
           // Set up the spurious vector, TPR, and

     

       236
       236
       +
           // calibrate the timer

     

       237
       237
        
           arch.interrupts.apic.init.initialSetup();

     

       238
       238
       -
       

     

       239
       239
       -
           // Calibrate the APIC timer

     

       240
       240
       -
           arch.interrupts.apic.init.calibrateTimer();

     

       241
       238
        
       

     

       242
       239
        
           // Enable one-shot interrupts

     

       243
       240
        
           arch.interrupts.apic.init.enableOneshotInterrupt();

+2 -2

components/ukernel/arch/amd64/instructions/cpuid.zig

···

       24
       24
        
       }

     

       25
       25
        
       

     

       26
       26
        
       const FeaturesEcx = packed struct(u32) {

     

       27
       27
       -
           _reserved0: u23,

     

       27
       27
       +
           _reserved0: u24,

     

       28
       28
        
           tsc_deadline: bool,

     

       29
       29
       -
           _reserved1: u8,

     

       29
       29
       +
           _reserved1: u7,

     

       30
       30
        
       };

     

       31
       31
        
       

     

       32
       32
        
       pub inline fn cpuid(leaf: u32, sub: u32) DefaultResults {

+3 -1

components/ukernel/arch/amd64/interrupts/apic.zig

···

       237
       237
        
               // });

     

       238
       238
        
               arch.interrupts.idt.add_handler(.{ .interrupt = 0xFF }, spurious_interrupt_handler, 3, 0);

     

       239
       239
        
               arch.interrupts.idt.add_handler(.{ .interrupt = 48 }, periodic_handler, 3, 0);

     

       240
       240
       +
       

     

       241
       241
       +
               calibrateTimer();

     

       240
       242
        
           }

     

       241
       243
        
       

     

       242
       242
       -
           pub fn calibrateTimer() void {

     

       244
       244
       +
           fn calibrateTimer() void {

     

       243
       245
        
               singleton.setDivideConfigurationRegister(.div2);

     

       244
       246
        
               singleton.setLVTTimerRegister(.{

     

       245
       247
        
                   .idt_entry = 0x69,

+15 -6

components/ukernel/arch/amd64/interrupts/root.zig

···

       12
       12
        
           asm volatile ("cli");

     

       13
       13
        
       }

     

       14
       14
        
       

     

       15
       15
       +
       fn print_regs(frame: *idt.InterruptFrame(u64)) void {

     

       16
       16
       +
           std.log.err("CR3: 0x{x:0>16}", .{frame.cr3});

     

       17
       17
       +
           std.log.err("RAX: 0x{x:0>16}, RBX: 0x{x:0>16}, RCX: 0x{x:0>16}, RDX: 0x{x:0>16}", .{ frame.regs.rax, frame.regs.rbx, frame.regs.rcx, frame.regs.rdx });

     

       18
       18
       +
           std.log.err("RSI: 0x{x:0>16}, RDI: 0x{x:0>16}, RBP: 0x{x:0>16}, RSP: 0x{x:0>16}", .{ frame.regs.rsi, frame.regs.rdi, frame.regs.rbp, frame.rsp });

     

       19
       19
       +
           std.log.err("R8:  0x{x:0>16}, R9:  0x{x:0>16}, R10: 0x{x:0>16}, R11: 0x{x:0>16}", .{ frame.regs.r8, frame.regs.r9, frame.regs.r10, frame.regs.r11 });

     

       20
       20
       +
           std.log.err("R12: 0x{x:0>16}, R13: 0x{x:0>16}, R14: 0x{x:0>16}, R15: 0x{x:0>16}", .{ frame.regs.r12, frame.regs.r13, frame.regs.r14, frame.regs.r15 });

     

       21
       21
       +
           std.log.err("RFL: 0x{x:0>16}, RIP: 0x{x:0>16}, CS:  0x{x:0>16}, SS:  0x{x:0>16}", .{ frame.eflags, frame.rip, frame.cs, frame.ss });

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       15
       24
        
       pub fn unhandled_interrupt(frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       16
       25
        
           if (std.enums.tagName(idt.Exception, frame.int_num.exception)) |exception_name| {

     

       17
       26
        
               std.log.err("Unhandled interrupt (0x{x} : {s})!!!", .{ frame.int_num.interrupt, exception_name });

     

       18
       27
        
           } else {

     

       19
       28
        
               std.log.err("Unhandled interrupt (0x{x})!!!", .{frame.int_num.interrupt});

     

       20
       29
        
           }

     

       21
       21
       -
           std.log.err("CR3: 0x{x:0>16}", .{frame.cr3});

     

       22
       22
       -
           std.log.err("RAX: 0x{x:0>16}, RBX: 0x{x:0>16}, RCX: 0x{x:0>16}, RDX: 0x{x:0>16}", .{ frame.regs.rax, frame.regs.rbx, frame.regs.rcx, frame.regs.rdx });

     

       23
       23
       -
           std.log.err("RSI: 0x{x:0>16}, RDI: 0x{x:0>16}, RBP: 0x{x:0>16}, RSP: 0x{x:0>16}", .{ frame.regs.rsi, frame.regs.rdi, frame.regs.rbp, frame.rsp });

     

       24
       24
       -
           std.log.err("R8:  0x{x:0>16}, R9:  0x{x:0>16}, R10: 0x{x:0>16}, R11: 0x{x:0>16}", .{ frame.regs.r8, frame.regs.r9, frame.regs.r10, frame.regs.r11 });

     

       25
       25
       -
           std.log.err("R12: 0x{x:0>16}, R13: 0x{x:0>16}, R14: 0x{x:0>16}, R15: 0x{x:0>16}", .{ frame.regs.r12, frame.regs.r13, frame.regs.r14, frame.regs.r15 });

     

       26
       26
       -
           std.log.err("RFL: 0x{x:0>16}, RIP: 0x{x:0>16}, CS:  0x{x:0>16}, SS:  0x{x:0>16}", .{ frame.eflags, frame.rip, frame.cs, frame.ss });

     

       30
       30
       +
       

     

       31
       31
       +
           print_regs(frame);

     

       32
       32
       +
       

     

       27
       33
        
           arch.interrupts.disable();

     

       28
       34
        
           arch.instructions.die();

     

       29
       35
        
       }

     
···

       34
       40
        
       

     

       35
       41
        
       pub fn double_fault(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       36
       42
        
           std.log.err("Double fault @ 0x{x}, dying!!!", .{stack_frame.rip});

     

       43
       43
       +
           print_regs(stack_frame);

     

       44
       44
       +
           arch.interrupts.disable();

     

       37
       45
        
           arch.instructions.die();

     

       38
       46
        
       }

     

       39
       47
        
       

     
···

       56
       64
        
                   std.log.warn("LDT selector: 0x{x}", .{ldt_sel});

     

       57
       65
        
               },

     

       58
       66
        
           }

     

       67
       67
       +
           print_regs(@ptrCast(stack_frame));

     

       59
       68
        
           arch.instructions.die();

     

       60
       69
        
       }