commit 765e551a1bf7c0dc5b4c4f44d30ce6d7bfa63fe6 · pci.express/frostium

+2 -2

components/root_server/src/main.zig

···

       2
       2
        
       const os = @import("os.zig");

     

       3
       3
        
       

     

       4
       4
        
       export fn _start() callconv(.c) noreturn {

     

       5
       5
       -
           // _ = os.syscall1(SYS_poke, 0xB16B00B5BADBABE);

     

       6
       6
       -
           // _ = os.syscall1(SYS_exit, 0x69696969);

     

       5
       5
       +
           _ = os.syscall1(SYS_poke, 0xB16B00B5BADBABE);

     

       6
       6
       +
           _ = os.syscall1(SYS_exit, 0x69696969);

     

       7
       7
        
           asm volatile ("int3");

     

       8
       8
        
           asm volatile (

     

       9
       9
        
               \\ mov $0x69696969, %%rdi

+10 -17

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 flanterm = @import("flanterm");

     

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

     

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

     

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

     

       8
       8
        
       const Tss = arch.structures.tss.Tss;

     
···

       48
       48
        
           const hhdm_offset = limine_requests.hhdm.response.?.offset;

     

       49
       49
        
           common.init_data.hhdm_slide = hhdm_offset;

     

       50
       50
        
       

     

       51
       51
       +
           // Set up the temporary Physical Memory Allocator

     

       52
       52
       +
           common.mm.bootmem.init();

     

       53
       53
       +
       

     

       51
       54
        
           // Add in a framebuffer if found

     

       52
       55
        
           initConsole();

     

       56
       56
       +
       

     

       53
       57
        
           // Get basic information through CPUID

     

       54
       58
        
           arch.instructions.cpuid.init();

     

       55
       59
        
       

     

       56
       60
        
           // Add in ACPI/dtb if found, prefer ACPI

     

       57
       61
        
           initHwDesc();

     

       58
       58
       -
       

     

       59
       59
       -
           // Set up the temporary Physical Memory Allocator

     

       60
       60
       -
           common.mm.bootmem.init();

     

       61
       62
        
       

     

       62
       63
        
           // Attach the root task

     

       63
       64
        
           if (limine_requests.modules.response) |module_response| {

     
···

       243
       244
        
       fn initConsole() void {

     

       244
       245
        
           if (limine_requests.framebuffer.response) |fb_response| {

     

       245
       246
        
               if (fb_response.framebuffer_count > 0) {

     

       246
       246
       -
                   const fb = common.aux.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       247
       247
       +
                   const fb = common.aux.fb_from_limine(fb_response.getFramebuffers()[0]);

     

       247
       248
        
                   common.init_data.framebuffer = fb;

     

       249
       249
       +
                   // Create a canvas for the console to render to

     

       250
       250
       +
                   const canvas: [*]u8 = @ptrFromInt(common.init_data.bootmem.allocMem(fb.width * fb.height * fb.bypp) catch @panic("Couldn't allocate a canvas"));

     

       251
       251
       +
                   @memset(canvas[0 .. fb.width * fb.height * fb.bypp], 0);

     

       248
       252
        
       

     

       249
       249
       -
                   common.init_data.console = flanterm.Context.init(.{

     

       250
       250
       -
                       .fb = fb.address,

     

       251
       251
       -
                       .width = fb.width,

     

       252
       252
       -
                       .height = fb.height,

     

       253
       253
       -
                       .pitch = fb.pitch,

     

       254
       254
       -
                       .red_mask_size = fb.red_mask_size,

     

       255
       255
       -
                       .red_mask_shift = fb.red_mask_shift,

     

       256
       256
       -
                       .green_mask_size = fb.green_mask_size,

     

       257
       257
       -
                       .green_mask_shift = fb.green_mask_shift,

     

       258
       258
       -
                       .blue_mask_size = fb.blue_mask_size,

     

       259
       259
       -
                       .blue_mask_shift = fb.blue_mask_shift,

     

       260
       260
       -
                   });

     

       253
       253
       +
                   common.init_data.console = console.Console.init(fb, canvas);

     

       261
       254
        
               }

     

       262
       255
        
           }

     

       263
       256
        
       }

+6 -3

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

···

       1
       1
        
       pub const cpuid = @import("cpuid.zig");

     

       2
       2
        
       

     

       3
       3
        
       pub inline fn die() noreturn {

     

       4
       4
       -
           while (true) {

     

       5
       5
       -
               asm volatile ("hlt");

     

       6
       6
       -
           }

     

       4
       4
       +
           asm volatile (

     

       5
       5
       +
               \\ mov $0xDEADDEADDEADDEAD, %%rax

     

       6
       6
       +
               \\ 1: hlt

     

       7
       7
       +
               \\ jmp 1b

     

       8
       8
       +
           );

     

       9
       9
       +
           unreachable;

     

       7
       10
        
       }

+4 -4

components/ukernel/build.zig

···

       63
       63
        
               .api_revision = 3,

     

       64
       64
        
           });

     

       65
       65
        
           const spinlock_dep = b.dependency("spinlock", .{});

     

       66
       66
       -
           const flanterm_dep = b.dependency("flanterm", .{});

     

       66
       66
       +
           const console_dep = b.dependency("console", .{});

     

       67
       67
        
       

     

       68
       68
        
           const limine_mod = limine_dep.module("limine");

     

       69
       69
        
           const spinlock_mod = spinlock_dep.module("spinlock");

     

       70
       70
       -
           const flanterm_mod = flanterm_dep.module("flanterm");

     

       70
       70
       +
           const console_mod = console_dep.module("console");

     

       71
       71
        
       

     

       72
       72
        
           const common_mod = b.createModule(.{

     

       73
       73
        
               .root_source_file = b.path("common/root.zig"),

     

       74
       74
        
           });

     

       75
       75
        
       

     

       76
       76
        
           arch_module.addImport("limine", limine_mod);

     

       77
       77
       -
           arch_module.addImport("flanterm", flanterm_mod);

     

       77
       77
       +
           arch_module.addImport("console", console_mod);

     

       78
       78
        
           arch_module.addImport("common", common_mod);

     

       79
       79
        
       

     

       80
       80
        
           common_mod.addImport("arch", arch_module);

     

       81
       81
        
           common_mod.addImport("spinlock", spinlock_mod);

     

       82
       82
       -
           common_mod.addImport("flanterm", flanterm_mod);

     

       82
       82
       +
           common_mod.addImport("console", console_mod);

     

       83
       83
        
           common_mod.addImport("limine", limine_mod);

     

       84
       84
        
       

     

       85
       85
        
           const kernel = b.addExecutable(.{

+1 -4

components/ukernel/build.zig.zon

···

       7
       7
        
               .limine = .{ .path = "deps/limine-zig" },

     

       8
       8
        
               .spinlock = .{ .path = "deps/spinlock" },

     

       9
       9
        
               .build_helpers = .{ .path = "../build_helpers" },

     

       10
       10
       -
               .flanterm = .{

     

       11
       11
       -
                   .url = "git+https://tangled.sh/@sydney.blue/flanterm.zig?ref=trunk#8071c825750c415b9e5502cdff34efc9c6dfeab7",

     

       12
       12
       -
                   .hash = "flanterm-2.0.0-QnufngHlAQCGtHyca0PrvRvoOldHdJG4DdSz437r9fRr",

     

       13
       13
       -
               },

     

       10
       10
       +
               .console = .{ .path = "deps/console" },

     

       14
       11
        
           },

     

       15
       12
        
           .paths = .{

     

       16
       13
        
               "build.zig",

+26 -45

components/ukernel/common/aux/root.zig

···

       1
       1
        
       const console = @import("console");

     

       2
       2
       -
       const flanterm = @import("flanterm");

     

       3
       2
        
       const common = @import("../root.zig");

     

       4
       3
        
       const mm = common.mm;

     

       5
       4
        
       const std = @import("std");

     
···

       18
       17
        
       

     

       19
       18
        
       pub const InitState = struct {

     

       20
       19
        
           bootmem: mm.bootmem.BootPmm = .{},

     

       21
       21
       -
           console: ?flanterm.Context = null,

     

       22
       22
       -
           framebuffer: ?common.aux.Framebuffer = null,

     

       20
       20
       +
           console: ?console.Console = null,

     

       21
       21
       +
           framebuffer: ?console.Framebuffer = null,

     

       23
       22
        
           hardware_description: HardwareDescription = .none,

     

       24
       23
        
           root_task: []align(4096) u8 = undefined,

     

       25
       24
        
           hhdm_slide: usize = 0,

     

       26
       25
        
       };

     

       27
       26
        
       

     

       28
       28
       -
       pub const Framebuffer = struct {

     

       29
       29
       -
           const Self = @This();

     

       30
       30
       -
           address: [*]u32,

     

       31
       31
       -
           width: u64,

     

       32
       32
       -
           height: u64,

     

       33
       33
       -
           pitch: u64,

     

       34
       34
       -
           bypp: u16,

     

       35
       35
       -
           red_mask_size: u8,

     

       36
       36
       -
           red_mask_shift: u8,

     

       37
       37
       -
           green_mask_size: u8,

     

       38
       38
       -
           green_mask_shift: u8,

     

       39
       39
       -
           blue_mask_size: u8,

     

       40
       40
       -
           blue_mask_shift: u8,

     

       41
       41
       -
       

     

       42
       42
       -
           pub fn from_limine(fb: *const limine.Framebuffer) Self {

     

       43
       43
       -
               return .{

     

       44
       44
       -
                   .address = @ptrCast(@alignCast(fb.address)),

     

       45
       45
       -
                   .width = fb.width,

     

       46
       46
       -
                   .height = fb.height,

     

       47
       47
       -
                   .pitch = fb.pitch,

     

       48
       48
       -
                   .red_mask_size = fb.red_mask_size,

     

       49
       49
       -
                   .red_mask_shift = fb.red_mask_shift,

     

       50
       50
       -
                   .green_mask_size = fb.green_mask_size,

     

       51
       51
       -
                   .green_mask_shift = fb.green_mask_shift,

     

       52
       52
       -
                   .blue_mask_size = fb.blue_mask_size,

     

       53
       53
       -
                   .blue_mask_shift = fb.blue_mask_shift,

     

       54
       54
       -
                   .bypp = fb.bpp / 8,

     

       55
       55
       -
               };

     

       56
       56
       -
           }

     

       57
       57
       -
       };

     

       27
       27
       +
       pub fn fb_from_limine(fb: *const limine.Framebuffer) console.Framebuffer {

     

       28
       28
       +
           return .{

     

       29
       29
       +
               .address = @ptrCast(@alignCast(fb.address)),

     

       30
       30
       +
               .width = fb.width,

     

       31
       31
       +
               .height = fb.height,

     

       32
       32
       +
               .pitch = fb.pitch,

     

       33
       33
       +
               .red_mask_size = fb.red_mask_size,

     

       34
       34
       +
               .red_mask_shift = fb.red_mask_shift,

     

       35
       35
       +
               .green_mask_size = fb.green_mask_size,

     

       36
       36
       +
               .green_mask_shift = fb.green_mask_shift,

     

       37
       37
       +
               .blue_mask_size = fb.blue_mask_size,

     

       38
       38
       +
               .blue_mask_shift = fb.blue_mask_shift,

     

       39
       39
       +
               .bypp = fb.bpp / 8,

     

       40
       40
       +
           };

     

       41
       41
       +
       }

     

       58
       42
        
       

     

       59
       43
        
       var stdout_lock: spinlock.Spinlock = .{};

     

       60
       44
        
       

     
···

       67
       51
        
           if (common.init_data.console == null) return;

     

       68
       52
        
       

     

       69
       53
        
           // Use the same naming as the default logger

     

       70
       70
       -
           const level, const color: flanterm.Colors.Color = switch (message_level) {

     

       71
       71
       -
               .debug => .{ "D", .green },

     

       72
       72
       -
               .err => .{ "E", .red },

     

       73
       73
       -
               .info => .{ "I", .cyan },

     

       74
       74
       -
               .warn => .{ "W", .yellow },

     

       54
       54
       +
           const level, const color: u32 = switch (message_level) {

     

       55
       55
       +
               .debug => .{ "D", 0x3bcf1d },

     

       56
       56
       +
               .err => .{ "E", 0xff0000 },

     

       57
       57
       +
               .info => .{ "I", 0x00bbbb },

     

       58
       58
       +
               .warn => .{ "W", 0xfee409 },

     

       75
       59
        
           };

     

       76
       60
        
           // Use same format as default once again

     

       77
       61
        
           const scope_text = switch (scope) {

     
···

       81
       65
        
           const prefix = std.fmt.comptimePrint("{s}{s}: ", .{ level, scope_text });

     

       82
       66
        
       

     

       83
       67
        
           {

     

       84
       84
       -
               const color_default: flanterm.Colors.Color = .default;

     

       85
       68
        
               stdout_lock.lock();

     

       86
       69
        
               defer stdout_lock.unlock();

     

       87
       70
        
       

     

       88
       88
       -
               var backing_buf = std.mem.zeroes([512]u8);

     

       89
       89
       -
               const buf = std.fmt.bufPrint(backing_buf[0..], color.esc_seq() ++ prefix ++ format ++ color_default.esc_seq() ++ "\n", args) catch return;

     

       90
       90
       -
       

     

       91
       91
       -
               common.init_data.console.?.write_slice(buf);

     

       92
       92
       -
               // cons.setColor(color, 0);

     

       93
       93
       -
               // cons.writer().print(prefix ++ format ++ "\n", args) catch return;

     

       71
       71
       +
               common.init_data.console.?.setColor(color, 0);

     

       72
       72
       +
               // No buffering for now

     

       73
       73
       +
               var writer = console.Console.Writer.init(&common.init_data.console.?, &.{});

     

       74
       74
       +
               writer.interface.print(prefix ++ format ++ "\n", args) catch return;

     

       94
       75
        
           }

     

       95
       76
        
       }

     

       96
       77

-1

components/ukernel/common/mm/bootmem.zig

···

       142
       142
        
       

     

       143
       143
        
           // Finally, initialize the global bootmem

     

       144
       144
        
           common.init_data.bootmem.initialize(bootmem_struct);

     

       145
       145
       -
           common.init_data.bootmem.debugInfo();

     

       146
       145
        
       }

components/ukernel/deps/console/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       pub fn build(b: *std.Build) void {

     

       3
       3
       +
           _ = b.addModule("console", .{

     

       4
       4
       +
               .root_source_file = b.path("src/root.zig"),

     

       5
       5
       +
           });

     

       6
       6
       +
       }

+13

components/ukernel/deps/console/build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .console,

     

       3
       3
       +
           .version = "0.0.0",

     

       4
       4
       +
           .fingerprint = 0x3603cfb621692996, // Changing this has security and trust implications.

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{},

     

       7
       7
       +
           .paths = .{

     

       8
       8
       +
               "build.zig",

     

       9
       9
       +
               "build.zig.zon",

     

       10
       10
       +
               "src",

     

       11
       11
       +
               "fonts",

     

       12
       12
       +
           },

     

       13
       13
       +
       }

+24

components/ukernel/deps/console/flake.lock

···

       1
       1
       +
       {

     

       2
       2
       +
         "nodes": {

     

       3
       3
       +
           "nixpkgs": {

     

       4
       4
       +
             "locked": {

     

       5
       5
       +
               "lastModified": 315532800,

     

       6
       6
       +
               "narHash": "sha256-t4zrLJk1EZWk1lUnvNEVjPBVNBHVzS3A0RsxkRSwwSE=",

     

       7
       7
       +
               "rev": "6d7ec06d6868ac6d94c371458fc2391ded9ff13d",

     

       8
       8
       +
               "type": "tarball",

     

       9
       9
       +
               "url": "https://releases.nixos.org/nixpkgs/nixpkgs-25.11pre861040.6d7ec06d6868/nixexprs.tar.xz?rev=6d7ec06d6868ac6d94c371458fc2391ded9ff13d"

     

       10
       10
       +
             },

     

       11
       11
       +
             "original": {

     

       12
       12
       +
               "type": "tarball",

     

       13
       13
       +
               "url": "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz"

     

       14
       14
       +
             }

     

       15
       15
       +
           },

     

       16
       16
       +
           "root": {

     

       17
       17
       +
             "inputs": {

     

       18
       18
       +
               "nixpkgs": "nixpkgs"

     

       19
       19
       +
             }

     

       20
       20
       +
           }

     

       21
       21
       +
         },

     

       22
       22
       +
         "root": "root",

     

       23
       23
       +
         "version": 7

     

       24
       24
       +
       }

+23

components/ukernel/deps/console/flake.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         inputs = {

     

       3
       3
       +
           nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz";

     

       4
       4
       +
         };

     

       5
       5
       +
         outputs =

     

       6
       6
       +
           { nixpkgs, ... }@inputs:

     

       7
       7
       +
           let

     

       8
       8
       +
             inherit (inputs.nixpkgs) lib;

     

       9
       9
       +
             forAllSystems =

     

       10
       10
       +
               body: lib.genAttrs lib.systems.flakeExposed (system: body nixpkgs.legacyPackages.${system});

     

       11
       11
       +
           in

     

       12
       12
       +
           {

     

       13
       13
       +
             devShells = forAllSystems (pkgs: {

     

       14
       14
       +
               default = pkgs.mkShell {

     

       15
       15
       +
                 packages = with pkgs; [

     

       16
       16
       +
                   zig_0_15

     

       17
       17
       +
                 ];

     

       18
       18
       +
               };

     

       19
       19
       +
             });

     

       20
       20
       +
       

     

       21
       21
       +
             formatter = forAllSystems (pkgs: pkgs.nixfmt-rfc-style);

     

       22
       22
       +
           };

     

       23
       23
       +
       }

+24

components/ukernel/deps/console/src/fonts/LICENSE.spleen

···

       1
       1
       +
       Copyright (c) 2018-2024, Frederic Cambus

     

       2
       2
       +
       All rights reserved.

     

       3
       3
       +
       

     

       4
       4
       +
       Redistribution and use in source and binary forms, with or without

     

       5
       5
       +
       modification, are permitted provided that the following conditions are met:

     

       6
       6
       +
       

     

       7
       7
       +
         * Redistributions of source code must retain the above copyright

     

       8
       8
       +
           notice, this list of conditions and the following disclaimer.

     

       9
       9
       +
       

     

       10
       10
       +
         * Redistributions in binary form must reproduce the above copyright

     

       11
       11
       +
           notice, this list of conditions and the following disclaimer in the

     

       12
       12
       +
           documentation and/or other materials provided with the distribution.

     

       13
       13
       +
       

     

       14
       14
       +
       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       15
       15
       +
       AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       16
       16
       +
       IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       17
       17
       +
       ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS

     

       18
       18
       +
       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       19
       19
       +
       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       20
       20
       +
       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       21
       21
       +
       INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       22
       22
       +
       CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       23
       23
       +
       ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       24
       24
       +
       POSSIBILITY OF SUCH DAMAGE.

components/ukernel/deps/console/src/fonts/spleen-12x24.psf

This is a binary file and will not be displayed.

+39

components/ukernel/deps/console/src/psf2.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub const Psf2Header = extern struct {

     

       4
       4
       +
           magic: u32 = 0x864ab572,

     

       5
       5
       +
           version: u32,

     

       6
       6
       +
           header_size: u32,

     

       7
       7
       +
           flags: u32,

     

       8
       8
       +
           numglyph: u32,

     

       9
       9
       +
           bytes_per_glyph: u32,

     

       10
       10
       +
           height: u32,

     

       11
       11
       +
           width: u32,

     

       12
       12
       +
       

     

       13
       13
       +
           pub fn bytesPerLine(self: *const Psf2Header) u32 {

     

       14
       14
       +
               return (self.width + 7) / 8;

     

       15
       15
       +
           }

     

       16
       16
       +
       };

     

       17
       17
       +
       

     

       18
       18
       +
       pub const Font = struct {

     

       19
       19
       +
           const Self = @This();

     

       20
       20
       +
           fontdata: []const u8 align(4),

     

       21
       21
       +
           pub fn new(fontdata: []const u8) Self {

     

       22
       22
       +
               return .{

     

       23
       23
       +
                   .fontdata = fontdata,

     

       24
       24
       +
               };

     

       25
       25
       +
           }

     

       26
       26
       +
       

     

       27
       27
       +
           pub fn getHdr(self: *const Self) *const Psf2Header {

     

       28
       28
       +
               return @ptrCast(@alignCast(self.fontdata));

     

       29
       29
       +
           }

     

       30
       30
       +
       

     

       31
       31
       +
           pub fn getGlyph(self: *const Self, ch: u8) ![]const u8 {

     

       32
       32
       +
               const hdr = self.getHdr();

     

       33
       33
       +
               const startpos: u64 = @as(u64, hdr.header_size) + @as(u64, ch) * @as(u64, hdr.bytes_per_glyph);

     

       34
       34
       +
       

     

       35
       35
       +
               if (self.fontdata.len < startpos + @as(u64, hdr.bytes_per_glyph)) return error.InvalidCharacter;

     

       36
       36
       +
       

     

       37
       37
       +
               return self.fontdata[startpos..][0..hdr.bytes_per_glyph];

     

       38
       38
       +
           }

     

       39
       39
       +
       };

+278

components/ukernel/deps/console/src/root.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const builtin = @import("builtin");

     

       3
       3
       +
       pub const psf2 = @import("psf2.zig");

     

       4
       4
       +
       const are_we_le = builtin.cpu.arch.endian() == .little;

     

       5
       5
       +
       

     

       6
       6
       +
       const fontdata_embed = @embedFile("fonts/spleen-12x24.psf");

     

       7
       7
       +
       const fontdata: [fontdata_embed.len]u8 align(@alignOf(u32)) = fontdata_embed.*;

     

       8
       8
       +
       

     

       9
       9
       +
       /// Basic framebuffer container

     

       10
       10
       +
       pub const Framebuffer = struct {

     

       11
       11
       +
           const Self = @This();

     

       12
       12
       +
           address: [*]u32,

     

       13
       13
       +
           width: u64,

     

       14
       14
       +
           height: u64,

     

       15
       15
       +
           pitch: u64,

     

       16
       16
       +
           bypp: u16,

     

       17
       17
       +
           red_mask_size: u8,

     

       18
       18
       +
           red_mask_shift: u8,

     

       19
       19
       +
           green_mask_size: u8,

     

       20
       20
       +
           green_mask_shift: u8,

     

       21
       21
       +
           blue_mask_size: u8,

     

       22
       22
       +
           blue_mask_shift: u8,

     

       23
       23
       +
       };

     

       24
       24
       +
       

     

       25
       25
       +
       /// Framebuffer based console

     

       26
       26
       +
       pub const Console = struct {

     

       27
       27
       +
           fb: Framebuffer,

     

       28
       28
       +
           canvas: [*]u8,

     

       29
       29
       +
           font: psf2.Font,

     

       30
       30
       +
           x_pos: usize = 0,

     

       31
       31
       +
           y_pos: usize = 0,

     

       32
       32
       +
           x_chrs_max: usize,

     

       33
       33
       +
           y_chrs_max: usize,

     

       34
       34
       +
           fg_color: u32 = 0xFFFFFFFF,

     

       35
       35
       +
           bg_color: u32 = 0,

     

       36
       36
       +
       

     

       37
       37
       +
           /// Create an instance given a framebuffer

     

       38
       38
       +
           /// Canvas must be exactly fb.width * fb.height * fb.bypp bytes

     

       39
       39
       +
           pub fn init(fb: Framebuffer, canvas: [*]u8) Console {

     

       40
       40
       +
               const font = psf2.Font.new(&fontdata);

     

       41
       41
       +
               return init_with_font(fb, canvas, font);

     

       42
       42
       +
           }

     

       43
       43
       +
       

     

       44
       44
       +
           /// Create an instance given a framebuffer and font

     

       45
       45
       +
           pub fn init_with_font(fb: Framebuffer, canvas: [*]u8, font: psf2.Font) Console {

     

       46
       46
       +
               const font_hdr = font.getHdr();

     

       47
       47
       +
               return .{

     

       48
       48
       +
                   .fb = fb,

     

       49
       49
       +
                   .font = font,

     

       50
       50
       +
                   .canvas = canvas,

     

       51
       51
       +
                   // TODO: implement spacing between chars?

     

       52
       52
       +
                   .x_chrs_max = fb.width / font_hdr.width,

     

       53
       53
       +
                   .y_chrs_max = fb.height / font_hdr.height,

     

       54
       54
       +
               };

     

       55
       55
       +
           }

     

       56
       56
       +
       

     

       57
       57
       +
           /// Write a string to the console

     

       58
       58
       +
           pub fn puts(self: *Console, msg: []const u8) usize {

     

       59
       59
       +
               var written: usize = 0;

     

       60
       60
       +
       

     

       61
       61
       +
               const start_line, const num_lines = blk: {

     

       62
       62
       +
                   const start_line = self.y_pos;

     

       63
       63
       +
                   var scrolled: bool = false;

     

       64
       64
       +
                   for (msg) |ch| {

     

       65
       65
       +
                       // TODO: handle characters that failed to print

     

       66
       66
       +
                       scrolled |= self.putc(ch) catch false;

     

       67
       67
       +
                       written += 1;

     

       68
       68
       +
                   }

     

       69
       69
       +
                   if (scrolled) break :blk .{ 0, self.y_chrs_max };

     

       70
       70
       +
                   break :blk .{ start_line, self.y_pos - start_line + 1 };

     

       71
       71
       +
               };

     

       72
       72
       +
               self.renderCanvas(start_line, num_lines);

     

       73
       73
       +
               return written;

     

       74
       74
       +
           }

     

       75
       75
       +
       

     

       76
       76
       +
           // Copy in the given lines from the canvas to the framebuffer

     

       77
       77
       +
           fn renderCanvas(

     

       78
       78
       +
               self: *Console,

     

       79
       79
       +
               start_line: usize,

     

       80
       80
       +
               num_lines: usize,

     

       81
       81
       +
           ) void {

     

       82
       82
       +
               const glyph_height: usize = @intCast(self.font.getHdr().height);

     

       83
       83
       +
               // Not necessarily fb pitch!

     

       84
       84
       +
               const canvas_pitch = self.fb.width * self.fb.bypp;

     

       85
       85
       +
               const byte_fb: [*]u8 = @ptrCast(self.fb.address);

     

       86
       86
       +
       

     

       87
       87
       +
               const src_buf = self.canvas[canvas_pitch * glyph_height * start_line ..][0 .. canvas_pitch * glyph_height * num_lines];

     

       88
       88
       +
               const dst_buf = byte_fb[self.fb.pitch * glyph_height * start_line ..][0 .. self.fb.pitch * glyph_height * num_lines];

     

       89
       89
       +
               @memcpy(dst_buf, src_buf);

     

       90
       90
       +
           }

     

       91
       91
       +
       

     

       92
       92
       +
           /// Write a character to the console, return true if scrolled

     

       93
       93
       +
           /// If putchar failed we did not scroll for sure

     

       94
       94
       +
           fn putc(self: *Console, ch: u8) !bool {

     

       95
       95
       +
               var scrolled: bool = false;

     

       96
       96
       +
               // Handle newlines

     

       97
       97
       +
               if (ch == '\r') return scrolled;

     

       98
       98
       +
               if (ch == '\n') {

     

       99
       99
       +
                   // Reset to the beginning of the next line

     

       100
       100
       +
                   self.x_pos = 0;

     

       101
       101
       +
                   self.y_pos += 1;

     

       102
       102
       +
                   // If we've overrun, scroll the entire framebuffer up one

     

       103
       103
       +
                   // and then reset to the last line

     

       104
       104
       +
                   if (self.y_pos >= self.y_chrs_max) {

     

       105
       105
       +
                       self.scrollUp();

     

       106
       106
       +
                       scrolled = true;

     

       107
       107
       +
                   }

     

       108
       108
       +
                   return scrolled;

     

       109
       109
       +
               }

     

       110
       110
       +
               // TODO: color palette and escape codes?

     

       111
       111
       +
               try self.putchar(ch, self.x_pos, self.y_pos, self.fg_color, self.bg_color);

     

       112
       112
       +
               self.x_pos += 1;

     

       113
       113
       +
       

     

       114
       114
       +
               // If our x is too far, go down a line

     

       115
       115
       +
               if (self.x_pos < self.x_chrs_max) return scrolled;

     

       116
       116
       +
               self.x_pos = 0;

     

       117
       117
       +
               self.y_pos += 1;

     

       118
       118
       +
               if (self.y_pos >= self.y_chrs_max) {

     

       119
       119
       +
                   self.scrollUp();

     

       120
       120
       +
                   scrolled = true;

     

       121
       121
       +
               }

     

       122
       122
       +
               return scrolled;

     

       123
       123
       +
           }

     

       124
       124
       +
       

     

       125
       125
       +
           fn putchar(self: *const Console, ch: u8, x_pos: usize, y_pos: usize, fg_val: u32, bg_val: u32) !void {

     

       126
       126
       +
               const raw_color_choice: [2]u32 = [2]u32{

     

       127
       127
       +
                   if (are_we_le) bg_val else @byteSwap(bg_val),

     

       128
       128
       +
                   if (are_we_le) fg_val else @byteSwap(fg_val),

     

       129
       129
       +
               };

     

       130
       130
       +
       

     

       131
       131
       +
               const font = self.font;

     

       132
       132
       +
               const hdr = font.getHdr();

     

       133
       133
       +
       

     

       134
       134
       +
               const bytes_per_line = hdr.bytesPerLine();

     

       135
       135
       +
               const mask_shamt: u5 = @truncate(bytes_per_line * 8 - 1);

     

       136
       136
       +
               const mask_initial: u32 = @as(u32, 1) << mask_shamt;

     

       137
       137
       +
               const glyph = try font.getGlyph(ch);

     

       138
       138
       +
       

     

       139
       139
       +
               // Offset into framebuffer of the beginning of the character

     

       140
       140
       +
               const canvas_pitch: usize = self.fb.width * self.fb.bypp;

     

       141
       141
       +
               var offset: usize = (y_pos * @as(usize, hdr.height) * canvas_pitch) + (x_pos * @as(usize, hdr.width) * self.fb.bypp);

     

       142
       142
       +
               // run for every line

     

       143
       143
       +
               var glyph_y: u32 = 0;

     

       144
       144
       +
               var mask: u32 = 0;

     

       145
       145
       +
               while (glyph_y < hdr.height) : (glyph_y += 1) {

     

       146
       146
       +
                   // initialize the mask and current line

     

       147
       147
       +
                   mask = mask_initial;

     

       148
       148
       +
                   // TODO: endian

     

       149
       149
       +
                   const line_value: u32 = std.mem.readVarInt(u32, glyph[glyph_y * bytes_per_line ..][0..bytes_per_line], .big);

     

       150
       150
       +
                   // offset into the fb of the current line

     

       151
       151
       +
                   var line_offset: usize = offset;

     

       152
       152
       +
                   var glyph_x: u32 = 0;

     

       153
       153
       +
                   while (glyph_x < hdr.width) : (glyph_x += 1) {

     

       154
       154
       +
                       // Write the fb or bg color

     

       155
       155
       +
                       const color: [4]u8 = @bitCast(raw_color_choice[@intFromBool(line_value & mask != 0)]);

     

       156
       156
       +
                       @memcpy(self.canvas[line_offset..][0..self.fb.bypp], color[0..]);

     

       157
       157
       +
                       // Move right a pixel

     

       158
       158
       +
                       line_offset += self.fb.bypp;

     

       159
       159
       +
                       mask >>= 1;

     

       160
       160
       +
                   }

     

       161
       161
       +
                   // Move down a line

     

       162
       162
       +
                   offset += canvas_pitch;

     

       163
       163
       +
               }

     

       164
       164
       +
           }

     

       165
       165
       +
       

     

       166
       166
       +
           // Set the fg and bg color

     

       167
       167
       +
           pub fn setColor(self: *Console, new_fg: u32, new_bg: u32) void {

     

       168
       168
       +
               self.fg_color = self.convertColor(new_fg);

     

       169
       169
       +
               self.bg_color = self.convertColor(new_bg);

     

       170
       170
       +
           }

     

       171
       171
       +
       

     

       172
       172
       +
           // Convert a normal _RGB u32 to the actual framebuffer format

     

       173
       173
       +
           fn convertColor(self: *const Console, color: u32) u32 {

     

       174
       174
       +
               // The color value also needs to be scaled. For example,

     

       175
       175
       +
               // if it's 10 bits per color and we're starting from 8 bits,

     

       176
       176
       +
               // Full bright will only be 0xFF/0x3FF or about 25% brightness.

     

       177
       177
       +
               // To fix this hypothetical, shift left by (10 - 8). This isn't

     

       178
       178
       +
               // perfectly accurate but close enough.

     

       179
       179
       +
               const red_left_shift: u5 = @truncate(self.fb.red_mask_size);

     

       180
       180
       +
               const green_left_shift: u5 = @truncate(self.fb.red_mask_size);

     

       181
       181
       +
               const blue_left_shift: u5 = @truncate(self.fb.red_mask_size);

     

       182
       182
       +
       

     

       183
       183
       +
               // Get our source RGB 888

     

       184
       184
       +
               const right_shift = 8;

     

       185
       185
       +
               const red_src: u32 = (color >> 16) & 0xFF;

     

       186
       186
       +
               const green_src: u32 = (color >> 8) & 0xFF;

     

       187
       187
       +
               const blue_src: u32 = color & 0xFF;

     

       188
       188
       +
       

     

       189
       189
       +
               // These shifts are the offsets to place each color.

     

       190
       190
       +
               const red_dest_shift: u5 = @truncate(self.fb.red_mask_shift);

     

       191
       191
       +
               const green_dest_shift: u5 = @truncate(self.fb.green_mask_shift);

     

       192
       192
       +
               const blue_dest_shift: u5 = @truncate(self.fb.blue_mask_shift);

     

       193
       193
       +
       

     

       194
       194
       +
               // Do the calculations

     

       195
       195
       +
               const red_dst = switch (std.math.order(red_left_shift, right_shift)) {

     

       196
       196
       +
                   .gt => red_src << (red_left_shift - right_shift),

     

       197
       197
       +
                   .lt => red_src >> (right_shift - red_left_shift),

     

       198
       198
       +
                   .eq => red_src,

     

       199
       199
       +
               } << red_dest_shift;

     

       200
       200
       +
       

     

       201
       201
       +
               const green_dst = switch (std.math.order(green_left_shift, right_shift)) {

     

       202
       202
       +
                   .gt => green_src << (green_left_shift - right_shift),

     

       203
       203
       +
                   .lt => green_src >> (right_shift - green_left_shift),

     

       204
       204
       +
                   .eq => green_src,

     

       205
       205
       +
               } << green_dest_shift;

     

       206
       206
       +
       

     

       207
       207
       +
               const blue_dst = switch (std.math.order(blue_left_shift, right_shift)) {

     

       208
       208
       +
                   .gt => blue_src << (blue_left_shift - right_shift),

     

       209
       209
       +
                   .lt => blue_src >> (right_shift - blue_left_shift),

     

       210
       210
       +
                   .eq => blue_src,

     

       211
       211
       +
               } << blue_dest_shift;

     

       212
       212
       +
       

     

       213
       213
       +
               return red_dst | green_dst | blue_dst;

     

       214
       214
       +
           }

     

       215
       215
       +
       

     

       216
       216
       +
           // Make sure to set damage to the entire screen!

     

       217
       217
       +
           fn scrollUp(self: *Console) void {

     

       218
       218
       +
               const glyph_height: usize = @intCast(self.font.getHdr().height);

     

       219
       219
       +
               const canvas_pitch: usize = self.fb.width * self.fb.bypp;

     

       220
       220
       +
       

     

       221
       221
       +
               // Copy 1:n line up to 0:n-1 with memmove

     

       222
       222
       +
               const dst_buf = self.canvas[0 .. canvas_pitch * glyph_height * (self.y_chrs_max - 1)];

     

       223
       223
       +
               const src_buf = self.canvas[canvas_pitch * glyph_height ..][0 .. canvas_pitch * glyph_height * (self.y_chrs_max - 1)];

     

       224
       224
       +
               @memmove(dst_buf, src_buf);

     

       225
       225
       +
       

     

       226
       226
       +
               // Clear last line

     

       227
       227
       +
               const last_line = self.canvas[canvas_pitch * glyph_height * (self.y_chrs_max - 1) ..][0 .. canvas_pitch * glyph_height];

     

       228
       228
       +
               @memset(last_line, 0);

     

       229
       229
       +
               self.x_pos = 0;

     

       230
       230
       +
               self.y_pos = self.y_chrs_max - 1;

     

       231
       231
       +
           }

     

       232
       232
       +
       

     

       233
       233
       +
           // Get a writer with optional buffering

     

       234
       234
       +
           pub fn writer(self: *Console, buffer: []u8) Writer {

     

       235
       235
       +
               return Writer.init(self, buffer);

     

       236
       236
       +
           }

     

       237
       237
       +
       

     

       238
       238
       +
           // Writer with the new std.Io.Writer interface

     

       239
       239
       +
           pub const Writer = struct {

     

       240
       240
       +
               console: *Console,

     

       241
       241
       +
               interface: std.Io.Writer,

     

       242
       242
       +
       

     

       243
       243
       +
               pub fn init(console: *Console, buffer: []u8) Writer {

     

       244
       244
       +
                   return .{

     

       245
       245
       +
                       .console = console,

     

       246
       246
       +
                       .interface = .{

     

       247
       247
       +
                           .buffer = buffer,

     

       248
       248
       +
                           .vtable = &.{ .drain = Writer.drain },

     

       249
       249
       +
                       },

     

       250
       250
       +
                   };

     

       251
       251
       +
               }

     

       252
       252
       +
       

     

       253
       253
       +
               pub fn drain(w: *std.Io.Writer, data: []const []const u8, splat: usize) !usize {

     

       254
       254
       +
                   // fieldParentPtr is so cool

     

       255
       255
       +
                   const self: *Writer = @fieldParentPtr("interface", w);

     

       256
       256
       +
                   var written: usize = 0;

     

       257
       257
       +
                   // First, consume the buffer

     

       258
       258
       +
                   if (w.end < w.buffer.len) {

     

       259
       259
       +
                       const n = self.console.puts(w.buffer[w.end..]);

     

       260
       260
       +
                       written += n;

     

       261
       261
       +
                       w.end += n;

     

       262
       262
       +
                   }

     

       263
       263
       +
       

     

       264
       264
       +
                   // Iterate over all the provided slices

     

       265
       265
       +
                   for (data, 0..) |slice, i| {

     

       266
       266
       +
                       // If we are the last slice, splat by the amount

     

       267
       267
       +
                       if (i == data.len - 1) {

     

       268
       268
       +
                           for (0..splat) |_| {

     

       269
       269
       +
                               written += self.console.puts(slice);

     

       270
       270
       +
                           }

     

       271
       271
       +
                           break;

     

       272
       272
       +
                       }

     

       273
       273
       +
                       written += self.console.puts(slice);

     

       274
       274
       +
                   }

     

       275
       275
       +
                   return written;

     

       276
       276
       +
               }

     

       277
       277
       +
           };

     

       278
       278
       +
       };