diff --git a/src/kernel/device/ata.rs b/src/kernel/device/ata.rs
index a52f40c3a59af24c6a1e214a0d005137ef544507..24db40824dcf8a0d7b7e3a7ed2c65e53f576cd02 100644
--- a/src/kernel/device/ata.rs
+++ b/src/kernel/device/ata.rs
@@ -1,8 +1,10 @@
//! Implementation of manipulation of Advanced Technology Attachment (ATA) compliant devices
use alloc::sync::Arc;
+use core::fmt::Display;
use core::mem;
+use anyhow::Result;
use bitflags::bitflags;
use spin::Mutex;
use x86_64::instructions::port::{Port, PortReadOnly, PortWriteOnly};
@@ -16,6 +18,9 @@ const IDENTIFY_DATA_INFORMATIONS_SIZE: usize = 512;
/// Size of a block in bytes
pub const BLOCK_SIZE: usize = 512;
+/// Maximal value of LBA if encoded on 28 bits
+const MAX_LBA_28_VALUE: usize = (1 << 28) - 1;
+
/// Commands that can be sent to an ATA drive's command port
///
/// See the [OSdev wiki](https://wiki.osdev.org/ATA_Command_Matrix) for more informations
@@ -335,6 +340,12 @@ enum Command {
SetMaxAddress = 0xF9,
}
+impl From<Command> for u8 {
+ fn from(value: Command) -> Self {
+ value as u8
+ }
+}
+
/// Kind of drives attached to a bus
#[repr(u8)]
#[derive(Debug)]
@@ -346,21 +357,64 @@ enum DriveRole {
Slave = 0x10,
}
+impl From<DriveRole> for u8 {
+ fn from(value: DriveRole) -> Self {
+ value as u8
+ }
+}
+
bitflags! {
/// Status register
///
/// See more informations on the [OSdev wiki](https://wiki.osdev.org/ATA_PIO_Mode#Status_Register_.28I.2FO_base_.2B_7.29)
struct Status: u8 {
- const ERR = 0b0000001;
- const IDX = 0b0000010;
- const CORR = 0b0000100;
- const DRQ = 0b0001000;
- const DF = 0b0010001;
- const RDY = 0b0100001;
- const BSY = 0b1000001;
+ /// Indicates an error occurred. Send a new command to clear it (or nuke it with a Software Reset).
+ const ERR = 0b00000001;
+
+ /// Index. Always set to zero.
+ const IDX = 0b00000010;
+
+ /// Corrected data. Always set to zero.
+ const CORR = 0b00000100;
+
+ /// Set when the drive has PIO data to transfer, or is ready to accept PIO data.
+ const DRQ = 0b00001000;
+
+ /// Overlapped Mode Service Request.
+ const SRV = 0b00010000;
+
+ /// Drive Fault Error (does not set ERR).
+ const DF = 0b00100000;
+
+ /// Bit is clear when drive is spun down, or after an error. Set otherwise.
+ const RDY = 0b01000000;
+
+ /// Indicates the drive is preparing to send/receive data (wait for it to clear). In case of 'hang' (it never clears), do a software reset.
+ const BSY = 0b10000000;
+ }
+}
+
+impl From<u8> for Status {
+ fn from(value: u8) -> Self {
+ Self::from_bits_retain(value)
+ }
+}
+
+#[derive(Debug)]
+enum BusError {
+ DriveWriteFault,
+}
+
+impl Display for BusError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ write!(f, "{}", match self {
+ Self::DriveWriteFault => "Drive Write Fault",
+ })
}
}
+impl core::error::Error for BusError {}
+
/// Representation of an ATA bus
///
/// See more informations on the [OSdev wiki](https://wiki.osdev.org/ATA_PIO_Mode#Registers)
@@ -430,15 +484,15 @@ impl Bus {
/// Reads the `status` register
///
/// The register is read 15 times before returning the value as suggested in the [OSdev wiki](https://wiki.osdev.org/ATA_PIO_Mode#400ns_delays)
- fn status(&mut self) -> u8 {
- for _ in 0..15 {
+ fn status(&mut self) -> Status {
+ for _ in 0..15_usize {
// SAFETY: the status register is assumed to be well-defined
unsafe {
self.status.read();
};
}
// SAFETY: the status register is assumed to be well-defined
- unsafe { self.status.read() }
+ unsafe { self.status.read() }.into()
}
/// Waits until the bus is ready to read or write data
@@ -446,26 +500,127 @@ impl Bus {
/// This function is intended to be used after a command have been issued.
///
/// Returns an error if the `status` port indicates an error
- fn wait_ready(&mut self) -> Result<(), ()> {
+ fn wait_ready(&mut self) -> Result<()> {
loop {
let status = self.status();
- todo!()
+
+ if status.intersects(Status::ERR | Status::DF) {
+ return Err(anyhow::Error::msg(BusError::DriveWriteFault));
+ };
+
+ if status.intersects(Status::BSY) {
+ continue;
+ };
+
+ if status.intersects(Status::DRQ) {
+ return Ok(());
+ }
}
}
+ /// Sends a I/O command to the ATA bus
+ ///
+ /// # Safety
///
- fn read_pio(
+ /// Must ensure that `lba_start` and `sector` are well-defined
+ unsafe fn initialize_io_pio(
&mut self,
- buffer: &mut [u8],
role: DriveRole,
lba_start: usize,
sector_count: usize,
- ) -> Result<usize, &'static str> {
+ command_24_bits: Command,
+ command_48_bits: Command,
+ ) {
+ if lba_start <= MAX_LBA_28_VALUE {
+ self.drive_head.write(0xE0 | Into::<u8>::into(role) | ((lba_start >> 24_u8) as u8 & 0x0F));
+ self.sector_count.write(sector_count as u8);
+ self.cylinder_high.write((lba_start >> 16_u8) as u8);
+ self.cylinder_low.write((lba_start >> 8_u8) as u8);
+ self.sector_number.write(lba_start as u8);
+ self.command.write(command_24_bits.into());
+ } else {
+ self.drive_head.write(0x40 | Into::<u8>::into(role));
+ self.sector_count.write((sector_count >> 8_u8) as u8);
+ self.cylinder_high.write((lba_start >> 40_u8) as u8);
+ self.cylinder_low.write((lba_start >> 32_u8) as u8);
+ self.sector_number.write((lba_start >> 24_u8) as u8);
+ self.sector_count.write(sector_count as u8);
+ self.cylinder_high.write((lba_start >> 16_u8) as u8);
+ self.cylinder_low.write((lba_start >> 8_u8) as u8);
+ self.sector_number.write(lba_start as u8);
+ self.command.write(command_48_bits.into());
+ };
+ }
+
+ /// Sends a `Read PIO` command to the ATA bus
+ ///
+ /// This function does not perform any bound check.
+ ///
+ /// See the [OSdev wiki](https://wiki.osdev.org/ATA_PIO_Mode#x86_Directions) for more informations on the algorithm
+ ///
+ /// # Safety
+ ///
+ /// Must ensure that `lba_start` and `sector` are well-defined
+ unsafe fn read_pio(&mut self, buffer: &mut [u8], role: DriveRole, lba_start: usize, sector_count: usize) -> Result<usize> {
if sector_count == 0 {
return Ok(0);
}
- todo!()
+ self.wait_ready()?;
+
+ self.initialize_io_pio(role, lba_start, sector_count, Command::ReadSectors, Command::ReadSectorsExt);
+
+ let mut buffer_offset = 0;
+ for _ in lba_start..(lba_start + sector_count) {
+ self.wait_ready()?;
+
+ for chunk in buffer[buffer_offset..(buffer_offset + BLOCK_SIZE)].chunks_exact(2) {
+ let word = (chunk[1] as u16) << 8_u8 | (chunk[0] as u16);
+ self.data.write(word);
+ }
+ buffer_offset += BLOCK_SIZE;
+ }
+
+ self.wait_ready()?;
+ Ok(sector_count)
+ }
+
+ /// Sends a `Write PIO` command to the ATA bus
+ ///
+ /// This function does not perform any bound check.
+ ///
+ /// See the [OSdev wiki](https://wiki.osdev.org/ATA_PIO_Mode#x86_Directions) for more informations on the algorithm
+ ///
+ /// # Safety
+ ///
+ /// Must ensure that `lba_start` and `sector` are well-defined
+ unsafe fn write_pio(&mut self, buffer: &mut [u8], role: DriveRole, lba_start: usize, sector_count: usize) -> Result<usize> {
+ if sector_count == 0 {
+ return Ok(0);
+ }
+
+ self.wait_ready()?;
+
+ self.initialize_io_pio(role, lba_start, sector_count, Command::WriteSectors, Command::WriteSectorsExt);
+
+ let mut buffer_offset = 0;
+ for _ in lba_start..(lba_start + sector_count) {
+ self.wait_ready()?;
+
+ for chunk in buffer[buffer_offset..(buffer_offset + BLOCK_SIZE)].chunks_exact(2) {
+ let word = (chunk[1] as u16) << 8_u8 | (chunk[0] as u16);
+ self.data.write(word);
+ }
+ buffer_offset += BLOCK_SIZE;
+ }
+
+ self.wait_ready()?;
+
+ let cache_flush_cmd = if lba_start < MAX_LBA_28_VALUE { Command::FlushCache } else { Command::FlushCacheExt };
+ self.command.write(cache_flush_cmd as u8);
+ self.wait_ready()?;
+
+ Ok(sector_count)
}
}
@@ -475,16 +630,16 @@ impl Bus {
#[derive(Debug)]
enum DriveType {
/// Used for most modern hard drives
- SATA,
+ Sata,
/// Commonly used for hard drives
- PATA,
+ Pata,
/// Used for most modern optical drives
- SATAPI,
+ Satapi,
/// Commonly used for optical drives
- PATAPI,
+ Patapi,
}
impl DriveType {
@@ -493,12 +648,12 @@ impl DriveType {
/// This function must be run after an identify device command has been sent and before the read of the response.
///
/// See the [OSdev wiki](https://wiki.osdev.org/ATA_PIO_Mode#Detecting_device_types) for more informations
- fn from_lba(lba_mid: u8, lba_high: u8) -> Option<Self> {
+ const fn from_lba(lba_mid: u8, lba_high: u8) -> Option<Self> {
match (lba_mid, lba_high) {
- (0x00, 0x00) => Some(Self::PATA),
- (0x14, 0xEB) => Some(Self::PATAPI),
- (0x3C, 0xC3) => Some(Self::SATA),
- (0x69, 0x96) => Some(Self::SATAPI),
+ (0x00, 0x00) => Some(Self::Pata),
+ (0x14, 0xEB) => Some(Self::Patapi),
+ (0x3C, 0xC3) => Some(Self::Sata),
+ (0x69, 0x96) => Some(Self::Satapi),
_ => None,
}
}
@@ -904,6 +1059,12 @@ impl Device for Drive {
}
}
+impl Drive {
+ fn read_pio(&mut self, buffer: &mut [u8], sector_offset: usize) -> Result<usize> {
+ todo!()
+ }
+}
+
/// Interface for the electrical specification of the cables connecting ATA drives
///
/// See the [OSdev wiki](https://wiki.osdev.org/PCI_IDE_Controller#IDE_Interface) for more informations
diff --git a/src/kernel/device/mod.rs b/src/kernel/device/mod.rs
index 8d73b9f76cc6633d558ff1ef940bc5d51f618604..9510c79f3485c9a43caf5c575cccfba5a82f9f25 100644
--- a/src/kernel/device/mod.rs
+++ b/src/kernel/device/mod.rs
@@ -7,6 +7,7 @@ use conquer_once::spin::OnceCell;
use log::info;
use spin::Mutex;
+#[allow(clippy::same_name_method)]
mod ata;
mod block;
mod pci;
diff --git a/src/main.rs b/src/main.rs
index 76c15250e9dd7835afaa6cc33401a8eccc2f3ab8..357314dc15d395e682e043f7868523f403ec06b4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -57,6 +57,7 @@
#![feature(const_mut_refs)]
#![feature(const_trait_impl)]
#![feature(custom_test_frameworks)]
+#![feature(error_in_core)]
#![feature(no_coverage)]
#![feature(strict_provenance)]
#![reexport_test_harness_main = "test_main"]