Add initial code

Author: GabrielMajeri

src/guid.rs

@@ -0,0 +1,58 @@
+use core::fmt;
+
+/// A globally unique identifier.
+///
+/// GUIDs are used by to identify protocols and other objects.
+///
+/// The difference from regular UUIDs is that the first 3 fields are
+/// always encoded as little endian.
+///
+/// The `Display` formatter prints GUIDs in the UEFI-defined format:
+/// `aabbccdd-eeff-gghh-iijj-kkllmmnnoopp`
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[repr(C)]
+pub struct Guid {
+    /// The low field of the timestamp.
+    a: u32,
+    /// The middle field of the timestamp.
+    b: u16,
+    /// The high field of the timestamp multiplexed with the version number.
+    c: u16,
+    /// Contains:
+    /// - The high field of the clock sequence multiplexed with the variant.
+    /// - The low field of the clock sequence.
+    /// - Spatially unique node identifier.
+    d: [u8; 8],
+}
+
+impl Guid {
+    /// Creates a new GUID from its component values.
+    pub const fn from_values(a: u32, b: u16, c: u16, d: [u8; 8]) -> Self {
+        Guid { a, b, c, d }
+    }
+}
+
+impl fmt::Display for Guid {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let (a, b, c) = (self.a, self.b, self.c);
+
+        let d = {
+            let (low, high) = (self.d[0] as u16, self.d[1] as u16);
+
+            (low << 8) | high
+        };
+
+        let e = {
+            let node = &self.d[2..8];
+            let mut e = 0;
+
+            for i in 0..6 {
+                e |= u64::from(node[5 - i]) << (i * 8);
+            }
+
+            e
+        };
+
+        write!(fmt, "{:08x}-{:04x}-{:04x}-{:04x}-{:012x}", a, b, c, d, e)
+    }
+}

src/lib.rs

@@ -0,0 +1,33 @@
+//! Rusty wrapper for the Unified Extensible Firmware Interface.
+
+#![feature(try_trait)]
+#![feature(optin_builtin_traits)]
+#![feature(const_fn)]
+#![feature(decl_macro)]
+#![feature(use_extern_macros)]
+#![feature(conservative_impl_trait)]
+
+#![no_std]
+
+#![warn(missing_docs)]
+#![cfg_attr(feature = "cargo-clippy", warn(clippy))]
+
+#[macro_use]
+extern crate bitflags;
+
+mod guid;
+pub use self::guid::Guid;
+
+mod status;
+pub use self::status::Status;
+
+use core::result;
+/// Return type of many UEFI functions.
+pub type Result<T> = result::Result<T, Status>;
+
+/// A pointer to an opaque data structure.
+pub type Handle = *mut ();
+
+pub mod table;
+
+pub mod proto;

src/proto/console/mod.rs

@@ -0,0 +1,6 @@
+//! Console support protocols.
+//!
+//! The console represents the various input and output methods
+//! used by the user to interact with the early boot platform.
+
+pub mod text;

src/proto/console/text/input.rs

@@ -0,0 +1,118 @@
+use {Status, Result, proto};
+use core::mem;
+
+/// Interface for text-based input devices.
+#[repr(C)]
+pub struct Input {
+    reset: extern fn(this: &mut Input, extended: bool) -> Status,
+    read_key_stroke: extern fn(this: &mut Input, key: &mut Key) -> Status,
+}
+
+impl Input {
+    /// Resets the input device hardware.
+    pub fn reset(&mut self, extended: bool) -> Result<()> {
+        (self.reset)(self, extended).into()
+    }
+
+    /// Reads the next keystroke from the input device.
+    ///
+    /// Returns `Err(NotReady)` if no keystroke is available yet.
+    pub fn read_key(&mut self) -> Result<Key> {
+        let mut key = unsafe { mem::uninitialized() };
+        (self.read_key_stroke)(self, &mut key)?;
+        Ok(key)
+    }
+
+    /// Blocks until a key is read from the device or an error occurs.
+    pub fn read_key_sync(&mut self) -> Result<Key> {
+        loop {
+            match self.read_key() {
+                // Received a key, exit loop.
+                Ok(key) => return Ok(key),
+                Err(code) => match code {
+                    // Wait for key press.
+                    Status::NotReady => (),
+                    // Exit on error, no point in looping.
+                    _ => return Err(code),
+                }
+            }
+        }
+    }
+}
+
+/// A key read from the console.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[repr(C)]
+pub struct Key {
+    /// The key's scan code.
+    pub scan_code: ScanCode,
+    /// Associated Unicode character,
+    /// or 0 if not printable.
+    pub unicode_char: u16,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[repr(u16)]
+#[allow(missing_docs)]
+pub enum ScanCode {
+    Null,
+    /// Move cursor up 1 row.
+    Up,
+    /// Move cursor down 1 row.
+    Down,
+    /// Move cursor right 1 column.
+    Right,
+    /// Move cursor left 1 column.
+    Left,
+    Home,
+    End,
+    Insert,
+    Delete,
+    PageUp,
+    PageDown,
+    Function1,
+    Function2,
+    Function3,
+    Function4,
+    Function5,
+    Function6,
+    Function7,
+    Function8,
+    Function9,
+    Function10,
+    Function11,
+    Function12,
+    Escape,
+
+    Function13 = 0x68,
+    Function14,
+    Function15,
+    Function16,
+    Function17,
+    Function18,
+    Function19,
+    Function20,
+    Function21,
+    Function22,
+    Function23,
+    Function24,
+
+    Mute = 0x7F,
+
+    VolumeUp = 0x80,
+    VolumeDown,
+
+    BrightnessUp = 0x100,
+    BrightnessDown,
+    Suspend,
+    Hibernate,
+    ToggleDisplay,
+    Recovery,
+    Eject,
+}
+
+proto::impl_proto! {
+    protocol Input {
+        GUID = 0x387477c1, 0x69c7, 0x11d2, [0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b];
+    }
+}

src/proto/console/text/mod.rs

@@ -0,0 +1,7 @@
+//! Text I/O.
+
+mod input;
+pub use self::input::{Input, Key, ScanCode};
+
+mod output;
+pub use self::output::{Output, OutputMode};

src/proto/console/text/output.rs

@@ -0,0 +1,150 @@
+use {Status, Result, proto};
+
+/// Interface for text-based output devices.
+#[repr(C)]
+pub struct Output {
+    reset: extern fn(this: &Output, extended: bool) -> Status,
+    output_string: extern fn(this: &Output, string: *const u16) -> Status,
+    test_string: extern fn(this: &Output, string: *const u16) -> Status,
+    query_mode: extern fn(this: &Output, mode: i32, columns: &mut usize, rows: &mut usize) -> Status,
+    set_mode: extern fn(this: &mut Output, mode: i32) -> Status,
+    _pad: [usize; 4],
+    data: &'static OutputData,
+}
+
+impl Output {
+    /// Resets the text output device hardware.
+    #[inline]
+    pub fn reset(&mut self, extended: bool) -> Result<()> {
+        (self.reset)(self, extended).into()
+    }
+
+    /// Writes a string to the output device.
+    #[inline]
+    pub fn output_string(&mut self, string: *const u16) -> Result<()> {
+        (self.output_string)(self, string).into()
+    }
+
+    /// Checks if a string contains only supported characters.
+    /// True indicates success.
+    ///
+    /// UEFI applications are encouraged to try to print a string even if it contains
+    /// some unsupported characters.
+    #[inline]
+    pub fn test_string(&mut self, string: *const u16) -> bool {
+        match (self.test_string)(self, string) {
+            Status::Success => true,
+            _ => false,
+        }
+    }
+
+    /// Returns an iterator of all supported text modes.
+    // TODO: fix the ugly lifetime parameter.
+    #[inline]
+    pub fn modes<'a>(&'a mut self) -> impl Iterator<Item = OutputMode> + 'a {
+        let max = self.data.max_mode;
+        OutputModeIter {
+            output: self,
+            current: 0,
+            max,
+        }
+    }
+
+    /// Returns the width (column count) and height (row count) of this mode.
+    fn query_mode(&self, index: i32) -> Result<(usize, usize)> {
+        let (mut columns, mut rows) = (0, 0);
+        (self.query_mode)(self, index, &mut columns, &mut rows)?;
+        Ok((columns, rows))
+    }
+
+    /// Sets a mode as current.
+    #[inline]
+    pub fn set_mode(&mut self, mode: OutputMode) -> Result<()> {
+        (self.set_mode)(self, mode.index).into()
+    }
+
+    /// Returns the the current text mode.
+    #[inline]
+    pub fn current_mode(&self) -> Result<OutputMode> {
+        let index = self.data.mode;
+        let dims = self.query_mode(index)?;
+        Ok(OutputMode { index, dims } )
+    }
+}
+
+/// The text mode (resolution) of the output device.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub struct OutputMode {
+    index: i32,
+    dims: (usize, usize),
+}
+
+impl OutputMode {
+    /// Returns the index of this mode.
+    #[inline]
+    pub fn index(&self) -> i32 {
+        self.index
+    }
+
+    /// Returns the width in columns.
+    #[inline]
+    pub fn columns(&self) -> usize {
+        self.dims.0
+    }
+
+    /// Returns the height in rows.
+    #[inline]
+    pub fn rows(&self) -> usize {
+        self.dims.1
+    }
+}
+
+/// An iterator of the text modes (possibly) supported by a device.
+struct OutputModeIter<'a> {
+    output: &'a mut Output,
+    current: i32,
+    max: i32,
+}
+
+impl<'a> Iterator for OutputModeIter<'a> {
+    type Item = OutputMode;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = self.current;
+        if index < self.max {
+            self.current += 1;
+
+            if let Ok(dims) = self.output.query_mode(index) {
+                Some(OutputMode { index, dims })
+            } else {
+                self.next()
+            }
+        } else {
+            None
+        }
+    }
+}
+
+/// Additional data of the output device.
+#[derive(Debug)]
+#[repr(C)]
+struct OutputData {
+    /// The number of modes supported by the device.
+    max_mode: i32,
+    /// The current output mode.
+    mode: i32,
+    /// The current character output attribute.
+    attribute: i32,
+    /// The cursor’s column.
+    cursor_column: i32,
+    /// The cursor’s row.
+    cursor_row: i32,
+    /// Whether the cursor is currently visible or not.
+    cursor_visible: bool,
+}
+
+proto::impl_proto! {
+    protocol Output {
+        GUID = 0x387477c2, 0x69c7, 0x11d2, [0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b];
+    }
+}

src/proto/macros.rs

@@ -0,0 +1,19 @@
+use super::Protocol;
+use Guid;
+
+/// Implements the `Protocol` trait for a type.
+/// Also marks the type as not sync and not send.
+pub macro impl_proto (
+    protocol $p:ident {
+        GUID = $a:expr, $b:expr, $c:expr, $d:expr;
+    }
+) {
+    impl Protocol for $p {
+        const GUID: Guid = Guid::from_values($a, $b, $c, $d);
+    }
+
+    // Most UEFI functions expect to be called on the bootstrap processor.
+    impl !Send for $p {}
+    // Most UEFI functions do not support multithreaded access.
+    impl !Sync for $p {}
+}