Added writers and cleanup

src/configurations.rs

@@ -1,4 +1,4 @@
-use super::vga_registers::{
+use super::registers::{
     AttributeControllerIndex, CrtcControllerIndex, GraphicsControllerIndex, SequencerIndex,
 };
 

src/lib.rs

@@ -4,13 +4,15 @@
 #![no_std]
 #![warn(missing_docs)]
 
+pub mod colors;
+mod configurations;
+mod fonts;
+mod registers;
 pub mod vga;
-pub mod vga_colors;
-mod vga_configurations;
-mod vga_fonts;
-mod vga_registers;
+mod writers;
 
 pub use self::vga::VGA;
+pub use self::writers::{Graphics640x480x16, Text40x25, Text40x50, Text80x25};
 
 #[cfg(test)]
 mod tests {

src/vga.rs

@@ -1,12 +1,12 @@
 //! Provides access to the vga graphics card.
 
 use super::{
-    vga_configurations::{
+    configurations::{
         VgaConfiguration, MODE_40X25_CONFIGURATION, MODE_40X50_CONFIGURATION,
         MODE_640X480X16_CONFIGURATION, MODE_80X25_CONFIGURATION,
     },
-    vga_fonts::{VgaFont, TEXT_8X16_FONT, TEXT_8X8_FONT},
-    vga_registers::{
+    fonts::{VgaFont, TEXT_8X16_FONT, TEXT_8X8_FONT},
+    registers::{
         AttributeControllerRegisters, CrtcControllerIndex, CrtcControllerRegisters, EmulationMode,
         GeneralRegisters, GraphicsControllerIndex, GraphicsControllerRegisters, SequencerIndex,
         SequencerRegisters,

src/writers/graphics_640x480x16.rs

@@ -0,0 +1,82 @@
+use crate::{
+    colors::Color16Bit,
+    vga::{Plane, Vga, VideoMode, VGA},
+};
+use spinning_top::SpinlockGuard;
+
+const WIDTH: usize = 640;
+const HEIGHT: usize = 480;
+
+static PLANES: &'static [Plane] = &[Plane::Plane0, Plane::Plane1, Plane::Plane2, Plane::Plane3];
+
+/// A basic interface for interacting with vga graphics mode 640x480x16
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// let graphics_mode = Graphics640x480x16::new();
+/// graphics_mode.set_mode();
+/// graphics_mode.clear_screen();
+/// ```
+pub struct Graphics640x480x16;
+
+impl Graphics640x480x16 {
+    /// Creates a new `Graphics640x480x16`.
+    pub fn new() -> Graphics640x480x16 {
+        Graphics640x480x16 {}
+    }
+
+    /// Clears the screen by setting all pixels to `Color16Bit::Black`.
+    pub fn clear_screen(&self) {
+        for x in 0..WIDTH {
+            for y in 0..HEIGHT {
+                self.set_pixel(x, y, Color16Bit::Yellow);
+            }
+        }
+    }
+
+    /// Sets the given pixel at `(x, y)` to the given `color`.
+    ///
+    /// Panics if `x >= 640` or `y >= 480`.
+    pub fn set_pixel(&self, x: usize, y: usize, color: Color16Bit) {
+        assert!(x < WIDTH, "x >= {}", WIDTH);
+        assert!(y < HEIGHT, "y >= {}", HEIGHT);
+        let (mut vga, frame_buffer) = self.get_frame_buffer();
+        let offset = (x / 8 + (WIDTH / 8) * y) as isize;
+
+        // Store the current value for masking.
+        let x = x & 7;
+        let mask = 0x80 >> (x & 7);
+        let mut plane_mask = 0x01;
+
+        for plane in PLANES {
+            vga.set_plane(*plane);
+            let current_value = unsafe { frame_buffer.offset(offset).read_volatile() };
+            let new_value = if plane_mask & color as u8 != 0 {
+                current_value | mask
+            } else {
+                current_value & !mask
+            };
+            unsafe {
+                frame_buffer.offset(offset).write_volatile(new_value);
+            }
+            plane_mask <<= 1;
+        }
+    }
+
+    /// Sets the graphics device to `VideoMode::Mode640x480x16`.
+    pub fn set_mode(&self) {
+        VGA.lock().set_video_mode(VideoMode::Mode640x480x16);
+    }
+
+    /// Returns the start of the `FrameBuffer` as `*mut u8` as
+    /// well as a lock to the vga driver. This ensures the vga
+    /// driver stays locked while the frame buffer is in use.
+    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut u8) {
+        let mut vga = VGA.lock();
+        let frame_buffer = vga.get_frame_buffer();
+        (vga, u32::from(frame_buffer) as *mut u8)
+    }
+}

src/writers/mod.rs

@@ -0,0 +1,18 @@
+mod graphics_640x480x16;
+mod text_40x25;
+mod text_40x50;
+mod text_80x25;
+
+use super::colors::TextModeColor;
+
+pub use graphics_640x480x16::Graphics640x480x16;
+pub use text_40x25::Text40x25;
+pub use text_40x50::Text40x50;
+pub use text_80x25::Text80x25;
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+struct ScreenCharacter {
+    character: u8,
+    color: TextModeColor,
+}

src/writers/text_40x25.rs

@@ -0,0 +1,78 @@
+use super::ScreenCharacter;
+use crate::{
+    colors::{Color16Bit, TextModeColor},
+    vga::{Vga, VideoMode, VGA},
+};
+use spinning_top::SpinlockGuard;
+
+const WIDTH: usize = 40;
+const HEIGHT: usize = 25;
+const SCREEN_SIZE: usize = WIDTH * HEIGHT;
+
+static BLANK_CHARACTER: ScreenCharacter = ScreenCharacter {
+    character: b' ',
+    color: TextModeColor::new(Color16Bit::Yellow, Color16Bit::Black),
+};
+
+/// A basic interface for interacting with vga text mode 40x25
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// let text_mode = Text40x25::new();
+/// text_mode.set_mode();
+/// text_mode.clear_screen();
+/// ```
+pub struct Text40x25;
+
+impl Text40x25 {
+    /// Creates a new `Text40x25`.
+    pub fn new() -> Text40x25 {
+        Text40x25 {}
+    }
+
+    /// Clears the screen by setting all cells to `b' '` with
+    /// a background color of `Color16Bit::Black` and a foreground
+    /// color of `Color16Bit::Yellow`.
+    pub fn clear_screen(&self) {
+        let (_vga, frame_buffer) = self.get_frame_buffer();
+        for i in 0..SCREEN_SIZE {
+            unsafe {
+                frame_buffer
+                    .offset(i as isize)
+                    .write_volatile(BLANK_CHARACTER);
+            }
+        }
+    }
+
+    /// Prints the given `character` and `color` at `(x, y)`.
+    ///
+    /// Panics if `x >= 40` or `y >= 25`.
+    pub fn write_character(&self, x: usize, y: usize, character: u8, color: TextModeColor) {
+        assert!(x < WIDTH, "x >= {}", WIDTH);
+        assert!(y < HEIGHT, "y >= {}", HEIGHT);
+        let (_vga, frame_buffer) = self.get_frame_buffer();
+        let offset = (WIDTH * y + x) as isize;
+        unsafe {
+            frame_buffer
+                .offset(offset)
+                .write_volatile(ScreenCharacter { character, color });
+        }
+    }
+
+    /// Sets the graphics device to `VideoMode::Mode40x25`.
+    pub fn set_mode(&self) {
+        VGA.lock().set_video_mode(VideoMode::Mode40x25);
+    }
+
+    /// Returns the start of the `FrameBuffer` as `*mut ScreenCharacter`
+    /// as well as a lock to the vga driver. This ensures the vga
+    /// driver stays locked while the frame buffer is in use.
+    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut ScreenCharacter) {
+        let mut vga = VGA.lock();
+        let frame_buffer = vga.get_frame_buffer();
+        (vga, u32::from(frame_buffer) as *mut ScreenCharacter)
+    }
+}

src/writers/text_40x50.rs

@@ -0,0 +1,78 @@
+use super::ScreenCharacter;
+use crate::{
+    colors::{Color16Bit, TextModeColor},
+    vga::{Vga, VideoMode, VGA},
+};
+use spinning_top::SpinlockGuard;
+
+const WIDTH: usize = 40;
+const HEIGHT: usize = 50;
+const SCREEN_SIZE: usize = WIDTH * HEIGHT;
+
+static BLANK_CHARACTER: ScreenCharacter = ScreenCharacter {
+    character: b' ',
+    color: TextModeColor::new(Color16Bit::Yellow, Color16Bit::Black),
+};
+
+/// A basic interface for interacting with vga text mode 40x50
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// let text_mode = Text40x50::new();
+/// text_mode.set_mode();
+/// text_mode.clear_screen();
+/// ```
+pub struct Text40x50;
+
+impl Text40x50 {
+    /// Creates a new `Text40x50`.
+    pub fn new() -> Text40x50 {
+        Text40x50 {}
+    }
+
+    /// Clears the screen by setting all cells to `b' '` with
+    /// a background color of `Color16Bit::Black` and a foreground
+    /// color of `Color16Bit::Yellow`.
+    pub fn clear_screen(&self) {
+        let (_vga, frame_buffer) = self.get_frame_buffer();
+        for i in 0..SCREEN_SIZE {
+            unsafe {
+                frame_buffer
+                    .offset(i as isize)
+                    .write_volatile(BLANK_CHARACTER);
+            }
+        }
+    }
+
+    /// Prints the given `character` and `color` at `(x, y)`.
+    ///
+    /// Panics if `x >= 40` or `y >= 50`.
+    pub fn write_character(&self, x: usize, y: usize, character: u8, color: TextModeColor) {
+        assert!(x < WIDTH, "x >= {}", WIDTH);
+        assert!(y < HEIGHT, "y >= {}", HEIGHT);
+        let (_vga, frame_buffer) = self.get_frame_buffer();
+        let offset = (WIDTH * y + x) as isize;
+        unsafe {
+            frame_buffer
+                .offset(offset)
+                .write_volatile(ScreenCharacter { character, color });
+        }
+    }
+
+    /// Sets the graphics device to `VideoMode::Mode40x50`.
+    pub fn set_mode(&self) {
+        VGA.lock().set_video_mode(VideoMode::Mode40x50);
+    }
+
+    /// Returns the start of the `FrameBuffer` as `*mut ScreenCharacter`
+    /// as well as a lock to the vga driver. This ensures the vga
+    /// driver stays locked while the frame buffer is in use.
+    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut ScreenCharacter) {
+        let mut vga = VGA.lock();
+        let frame_buffer = vga.get_frame_buffer();
+        (vga, u32::from(frame_buffer) as *mut ScreenCharacter)
+    }
+}

src/writers/text_80x25.rs

@@ -0,0 +1,78 @@
+use super::ScreenCharacter;
+use crate::{
+    colors::{Color16Bit, TextModeColor},
+    vga::{Vga, VideoMode, VGA},
+};
+use spinning_top::SpinlockGuard;
+
+const WIDTH: usize = 80;
+const HEIGHT: usize = 25;
+const SCREEN_SIZE: usize = WIDTH * HEIGHT;
+
+static BLANK_CHARACTER: ScreenCharacter = ScreenCharacter {
+    character: b' ',
+    color: TextModeColor::new(Color16Bit::Yellow, Color16Bit::Black),
+};
+
+/// A basic interface for interacting with vga text mode 80x25
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// let text_mode = Text80x25::new();
+/// text_mode.set_mode();
+/// text_mode.clear_screen();
+/// ```
+pub struct Text80x25;
+
+impl Text80x25 {
+    /// Creates a new `Text80x25`.
+    pub fn new() -> Text80x25 {
+        Text80x25 {}
+    }
+
+    /// Clears the screen by setting all cells to `b' '` with
+    /// a background color of `Color16Bit::Black` and a foreground
+    /// color of `Color16Bit::Yellow`.
+    pub fn clear_screen(&self) {
+        let (_vga, frame_buffer) = self.get_frame_buffer();
+        for i in 0..SCREEN_SIZE {
+            unsafe {
+                frame_buffer
+                    .offset(i as isize)
+                    .write_volatile(BLANK_CHARACTER);
+            }
+        }
+    }
+
+    /// Prints the given `character` and `color` at `(x, y)`.
+    ///
+    /// Panics if `x >= 80` or `y >= 25`.
+    pub fn write_character(&self, x: usize, y: usize, character: u8, color: TextModeColor) {
+        assert!(x < WIDTH, "x >= {}", WIDTH);
+        assert!(y < HEIGHT, "y >= {}", HEIGHT);
+        let (_vga, frame_buffer) = self.get_frame_buffer();
+        let offset = (WIDTH * y + x) as isize;
+        unsafe {
+            frame_buffer
+                .offset(offset)
+                .write_volatile(ScreenCharacter { character, color });
+        }
+    }
+
+    /// Sets the graphics device to `VideoMode::Mode80x25`.
+    pub fn set_mode(&self) {
+        VGA.lock().set_video_mode(VideoMode::Mode80x25);
+    }
+
+    /// Returns the start of the `FrameBuffer` as `*mut ScreenCharacter`
+    /// as well as a lock to the vga driver. This ensures the vga
+    /// driver stays locked while the frame buffer is in use.
+    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut ScreenCharacter) {
+        let mut vga = VGA.lock();
+        let frame_buffer = vga.get_frame_buffer();
+        (vga, u32::from(frame_buffer) as *mut ScreenCharacter)
+    }
+}