Add Phat detection support

Author: IridescentRose

src/pspsdk.zig

@@ -342,6 +342,10 @@ pub const sceJpegInitMJpeg = jpeg.init_mjpeg;
 // -- kermit (sceKermitPeripheral) --
 pub const kermit = @import("sdk/kermit.zig");
 
+// -- model (Zig-only utility: PSP Phat/Slim detection) --
+pub const model = @import("sdk/model.zig");
+pub const PspModel = model.PspModel;
+
 // -- kernel (LoadExecForUser, ThreadManForUser, SysMemUserForUser, ModuleMgrForUser, etc.) --
 pub const kernel = @import("sdk/kernel.zig");
 pub const sceKernelAllocPartitionMemory = kernel.alloc_partition_memory;

src/sdk/model.zig

@@ -0,0 +1,38 @@
+//! PSP hardware model detection.
+//!
+//! Populated once at startup from kernel.max_free_mem_size(); see
+//! src/utils/module.zig.
+
+/// PSP hardware model.
+pub const PspModel = enum {
+    /// PSP-1000 ("Phat") -- 32 MB system RAM.
+    phat,
+    /// PSP-2000/3000/N1000 ("Slim" and later) -- 64 MB system RAM.
+    slim,
+};
+
+/// Threshold (bytes) used to discriminate Phat from Slim.
+/// Phat's hard ceiling is 32 MB of system RAM; Slim+ reports far more.
+/// Anything >= 32 MB free at boot must be Slim+.
+const slim_threshold_bytes: usize = 32 * 1024 * 1024;
+
+var detected: PspModel = .phat;
+var boot_max_free: usize = 0;
+
+/// Internal: called once during startup with the result of
+/// kernel.max_free_mem_size(). Not intended for user code.
+pub fn _set_from_max_free(bytes: usize) void {
+    boot_max_free = bytes;
+    detected = if (bytes >= slim_threshold_bytes) .slim else .phat;
+}
+
+/// Returns the detected PSP model. Valid after startup runs
+/// (i.e. anywhere user code executes).
+pub fn current() PspModel {
+    return detected;
+}
+
+/// Returns the max-free-mem value sampled at boot, in bytes.
+pub fn boot_max_free_mem_size() usize {
+    return boot_max_free;
+}

src/utils/module.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 
 const kernel = @import("../sdk/kernel.zig");
+const model = @import("../sdk/model.zig");
 
 const debug = @import("debug.zig");
 const fpu = @import("fpu.zig");
@@ -40,10 +41,18 @@ pub fn _module_main_thread(argc: usize, argv: ?*anyopaque) callconv(.c) c_int {
     // defaults to all available memory minus a 512 KB reserve.
     const heap_kb: u32 = if (@hasDecl(root, "psp_heap_kb_size")) root.psp_heap_kb_size else 0;
     const heap_reserve: u32 = if (@hasDecl(root, "psp_heap_reserve_kb_size")) root.psp_heap_reserve_kb_size else 512;
+
+    // Sample max-free-mem once: it doubles as the heap sizing input AND the
+    // discriminator for PSP Phat vs Slim+ hardware detection. Stash it in
+    // the model module so user code can query it later via
+    // pspsdk.model.current().
+    const max_free = kernel.max_free_mem_size();
+    model._set_from_max_free(max_free);
+
     const heap_size: usize = if (heap_kb > 0)
         @as(usize, heap_kb) * 1024
     else
-        kernel.max_free_mem_size() -| (@as(usize, heap_reserve) * 1024);
+        max_free -| (@as(usize, heap_reserve) * 1024);
 
     const heap_uid = kernel.alloc_partition_memory(.user, "psp_heap", .mem_low, heap_size, null) catch return 1;
     defer kernel.free_partition_memory(heap_uid) catch {};