mirror of
https://github.com/ziglang/zig.git
synced 2024-11-16 17:15:37 +00:00
126 lines
3.6 KiB
Zig
126 lines
3.6 KiB
Zig
const std = @import("../std.zig");
|
|
|
|
/// A protocol is an interface identified by a GUID.
|
|
pub const protocols = @import("uefi/protocols.zig");
|
|
|
|
/// Status codes returned by EFI interfaces
|
|
pub const Status = @import("uefi/status.zig").Status;
|
|
pub const tables = @import("uefi/tables.zig");
|
|
|
|
/// The memory type to allocate when using the pool
|
|
/// Defaults to .LoaderData, the default data allocation type
|
|
/// used by UEFI applications to allocate pool memory.
|
|
pub var efi_pool_memory_type: tables.MemoryType = .LoaderData;
|
|
pub const pool_allocator = @import("uefi/pool_allocator.zig").pool_allocator;
|
|
pub const raw_pool_allocator = @import("uefi/pool_allocator.zig").raw_pool_allocator;
|
|
|
|
/// The EFI image's handle that is passed to its entry point.
|
|
pub var handle: Handle = undefined;
|
|
|
|
/// A pointer to the EFI System Table that is passed to the EFI image's entry point.
|
|
pub var system_table: *tables.SystemTable = undefined;
|
|
|
|
/// A handle to an event structure.
|
|
pub const Event = *opaque {};
|
|
|
|
/// GUIDs must be align(8)
|
|
pub const Guid = extern struct {
|
|
time_low: u32,
|
|
time_mid: u16,
|
|
time_high_and_version: u16,
|
|
clock_seq_high_and_reserved: u8,
|
|
clock_seq_low: u8,
|
|
node: [6]u8,
|
|
|
|
/// Format GUID into hexadecimal lowercase xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format
|
|
pub fn format(
|
|
self: @This(),
|
|
comptime f: []const u8,
|
|
options: std.fmt.FormatOptions,
|
|
writer: anytype,
|
|
) !void {
|
|
_ = options;
|
|
if (f.len == 0) {
|
|
return std.fmt.format(writer, "{x:0>8}-{x:0>4}-{x:0>4}-{x:0>2}{x:0>2}-{x:0>12}", .{
|
|
self.time_low,
|
|
self.time_mid,
|
|
self.time_high_and_version,
|
|
self.clock_seq_high_and_reserved,
|
|
self.clock_seq_low,
|
|
self.node,
|
|
});
|
|
} else {
|
|
@compileError("Unknown format character: '" ++ f ++ "'");
|
|
}
|
|
}
|
|
|
|
pub fn eql(a: std.os.uefi.Guid, b: std.os.uefi.Guid) bool {
|
|
return a.time_low == b.time_low and
|
|
a.time_mid == b.time_mid and
|
|
a.time_high_and_version == b.time_high_and_version and
|
|
a.clock_seq_high_and_reserved == b.clock_seq_high_and_reserved and
|
|
a.clock_seq_low == b.clock_seq_low and
|
|
std.mem.eql(u8, &a.node, &b.node);
|
|
}
|
|
};
|
|
|
|
/// An EFI Handle represents a collection of related interfaces.
|
|
pub const Handle = *opaque {};
|
|
|
|
/// This structure represents time information.
|
|
pub const Time = extern struct {
|
|
/// 1900 - 9999
|
|
year: u16,
|
|
|
|
/// 1 - 12
|
|
month: u8,
|
|
|
|
/// 1 - 31
|
|
day: u8,
|
|
|
|
/// 0 - 23
|
|
hour: u8,
|
|
|
|
/// 0 - 59
|
|
minute: u8,
|
|
|
|
/// 0 - 59
|
|
second: u8,
|
|
_pad1: u8,
|
|
|
|
/// 0 - 999999999
|
|
nanosecond: u32,
|
|
|
|
/// The time's offset in minutes from UTC.
|
|
/// Allowed values are -1440 to 1440 or unspecified_timezone
|
|
timezone: i16,
|
|
daylight: packed struct {
|
|
_pad1: u6,
|
|
|
|
/// If true, the time has been adjusted for daylight savings time.
|
|
in_daylight: bool,
|
|
|
|
/// If true, the time is affected by daylight savings time.
|
|
adjust_daylight: bool,
|
|
},
|
|
_pad2: u8,
|
|
|
|
/// Time is to be interpreted as local time
|
|
pub const unspecified_timezone: i16 = 0x7ff;
|
|
};
|
|
|
|
/// Capabilities of the clock device
|
|
pub const TimeCapabilities = extern struct {
|
|
/// Resolution in Hz
|
|
resolution: u32,
|
|
|
|
/// Accuracy in an error rate of 1e-6 parts per million.
|
|
accuracy: u32,
|
|
|
|
/// If true, a time set operation clears the device's time below the resolution level.
|
|
sets_to_zero: bool,
|
|
};
|
|
|
|
/// File Handle as specified in the EFI Shell Spec
|
|
pub const FileHandle = *opaque {};
|