Added start of ata device

src/cpus/m68k/execute.rs

@@ -343,7 +343,7 @@ impl MC68010 {
                 let sp = *self.get_stack_pointer_mut();
                 let addr = self.get_a_reg_mut(reg);
                 *addr = sp;
-                *self.get_stack_pointer_mut() = sp + (offset as i32) as u32;
+                *self.get_stack_pointer_mut() = sp.wrapping_add((offset as i32) as u32);
             },
             Instruction::LSd(count, target, size, shift_dir) => {
                 let count = self.get_target_value(space, count, size)? % 64;

src/devices/ata.rs

@@ -0,0 +1,81 @@
+
+use std::fs;
+
+use crate::error::Error;
+use crate::memory::{Address, Addressable};
+
+
+const ATA_REG_DEV_CONTROL: Address      = 0x1D;
+const ATA_REG_DEV_ADDRESS: Address      = 0x1F;
+const ATA_REG_DATA: Address             = 0x20;
+const ATA_REG_DATA_BYTE: Address        = 0x21;
+const ATA_REG_FEATURE: Address          = 0x23;
+const ATA_REG_ERROR: Address            = 0x23;
+const ATA_REG_SECTOR_COUNT: Address     = 0x25;
+const ATA_REG_SECTOR_NUM: Address       = 0x27;
+const ATA_REG_CYL_LOW: Address          = 0x29;
+const ATA_REG_CYL_HIGH: Address         = 0x2B;
+const ATA_REG_DRIVE_HEAD: Address       = 0x2D;
+const ATA_REG_STATUS: Address           = 0x2F;
+const ATA_REG_COMMAND: Address          = 0x2F;
+
+const ATA_CMD_READ_SECTORS: u8          = 0x20;
+const ATA_CMD_WRITE_SECTORS: u8         = 0x30;
+const ATA_CMD_IDENTIFY: u8              = 0xEC;
+const ATA_CMD_SET_FEATURE: u8           = 0xEF;
+
+
+const DEV_NAME: &'static str = "ata";
+
+pub struct AtaDevice {
+    pub read_addr: u32,
+    pub read_count: u32,
+    pub contents: Vec<u8>,
+}
+
+
+impl AtaDevice {
+    pub fn new() -> Self {
+        AtaDevice {
+            read_addr: 0,
+            read_count: 0,
+            contents: vec![],
+        }
+    }
+
+    pub fn load(&mut self, filename: &str) -> Result<(), Error> {
+        match fs::read(filename) {
+            Ok(contents) => {
+                self.contents = contents;
+                Ok(())
+            },
+            Err(_) => Err(Error::new(&format!("Error reading contents of {}", filename))),
+        }
+    }
+}
+
+impl Addressable for AtaDevice {
+    fn len(&self) -> usize {
+        0x30
+    }
+
+    fn read(&mut self, addr: Address, count: usize) -> Vec<u8> {
+        let mut data = vec![0; count];
+
+        match addr {
+            ATA_REG_COMMAND => {
+                //data[0] = self.input;
+            },
+            _ => { println!("{}: reading from {:0x}", DEV_NAME, addr); },
+        }
+
+        data
+    }
+
+    fn write(&mut self, mut addr: Address, data: &[u8]) {
+        match addr {
+            _ => { println!("{}: writing {:0x} to {:0x}", DEV_NAME, data[0], addr); },
+        }
+    }
+}
+

src/devices/mod.rs

@@ -1,3 +1,4 @@
  
+pub mod ata;
 pub mod mc68681;
 

src/main.rs

@@ -9,6 +9,7 @@ mod devices;
 use crate::memory::{AddressSpace, MemoryBlock};
 use crate::cpus::m68k::MC68010;
 use crate::devices::mc68681::MC68681;
+use crate::devices::ata::AtaDevice;
 
 fn main() {
     let mut space = AddressSpace::new();
@@ -22,6 +23,10 @@ fn main() {
     ram.load_at(0, "binaries/kernel.bin").unwrap();
     space.insert(0x00100000, Box::new(ram));
 
+    let mut ata = AtaDevice::new();
+    ata.load("binaries/compactflash.img").unwrap();
+    space.insert(0x00600000, Box::new(ata));
+
     let mut serial = MC68681::new();
     serial.open().unwrap();
     space.insert(0x00700000, Box::new(serial));