diff --git a/Cargo.toml b/Cargo.toml index b2d98ed..e7590f3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "system76_ecflash" version = "0.1.3" -edition = "2018" +edition = "2024" description = "Flashing and querying with System76 Embedded Controllers" license = "LGPL-2.1-or-later" authors = ["Jeremy Soller "] diff --git a/examples/flash.rs b/examples/flash.rs index 4ff6779..41b2589 100644 --- a/examples/flash.rs +++ b/examples/flash.rs @@ -6,7 +6,7 @@ use ecflash::{EcFlash, Flasher}; use std::{env, fs, io, process, thread, time}; fn main() { - extern { + unsafe extern "C" { fn iopl(level: isize) -> isize; } @@ -26,7 +26,10 @@ fn main() { // Get I/O Permission unsafe { if iopl(3) < 0 { - eprintln!("Failed to get I/O permission: {}", io::Error::last_os_error()); + eprintln!( + "Failed to get I/O permission: {}", + io::Error::last_os_error() + ); process::exit(1); } @@ -44,7 +47,10 @@ fn main() { if let Ok(_original) = flasher.read(|x| eprint!("\rRead: {} KB", x / 1024)) { eprintln!(); - if flasher.erase(|x| eprint!("\rErase: {} KB", x / 1024)).is_ok() { + if flasher + .erase(|x| eprint!("\rErase: {} KB", x / 1024)) + .is_ok() + { eprintln!(); if let Ok(erased) = flasher.read(|x| eprint!("\rRead: {} KB", x / 1024)) { @@ -53,18 +59,19 @@ fn main() { //TODO: retry erase on fail for i in 0..erased.len() { if erased[i] != 0xFF { - println!( - "0x{:X}: 0x{:02X} != 0xFF", - i, - erased[i] - ); + println!("0x{:X}: 0x{:02X} != 0xFF", i, erased[i]); } } - if flasher.write(&data, |x| eprint!("\rWrite {} KB", x / 1024)).is_ok() { + if flasher + .write(&data, |x| eprint!("\rWrite {} KB", x / 1024)) + .is_ok() + { eprintln!(); - if let Ok(written) = flasher.read(|x| eprint!("\rRead: {} KB", x / 1024)) { + if let Ok(written) = + flasher.read(|x| eprint!("\rRead: {} KB", x / 1024)) + { eprintln!(); success = true; @@ -72,9 +79,7 @@ fn main() { if written[i] != data[i] { println!( "0x{:X}: 0x{:02X} != 0x{:02X}", - i, - written[i], - data[i] + i, written[i], data[i] ); success = false; } diff --git a/examples/isp.rs b/examples/isp.rs index fb60d89..4ff7d21 100644 --- a/examples/isp.rs +++ b/examples/isp.rs @@ -9,15 +9,12 @@ use std::env; use std::fs; use std::io::{self, Read, Write}; use std::process; -use std::time::Duration; use std::thread; +use std::time::Duration; use ecflash::EcFlash; -const EC_KNOWN_IDS: &[u16] = &[ - 0x5570, - 0x8587, -]; +const EC_KNOWN_IDS: &[u16] = &[0x5570, 0x8587]; #[repr(u8)] pub enum Address { @@ -111,7 +108,10 @@ pub trait Smfi { } } -impl Smfi for T where T: Debugger { +impl Smfi for T +where + T: Debugger, +{ /// Set indar1 register (special case for follow mode) fn flash_indar1(&mut self, data: u8) -> Result<()> { self.write_at(Address::INDAR1, &[data])?; @@ -145,9 +145,7 @@ pub struct SpiBus<'a, T: Smfi> { impl<'a, T: Smfi> SpiBus<'a, T> { pub fn new(port: &'a mut T, eflash: bool) -> Result { - port.flash_address( - if eflash { 0x7FFF_FE00 } else { 0xFFFF_FE00 }, - )?; + port.flash_address(if eflash { 0x7FFF_FE00 } else { 0xFFFF_FE00 })?; let mut spi = Self { port, data: false }; spi.reset()?; @@ -183,7 +181,7 @@ impl<'a, T: Smfi> SpiBus<'a, T> { } } -impl<'a, T: Smfi> Drop for SpiBus<'a, T> { +impl Drop for SpiBus<'_, T> { fn drop(&mut self) { let _ = self.reset(); } @@ -249,7 +247,7 @@ impl<'a, 't, T: Smfi> SpiRom<'a, 't, T> { if (address & 0xFF00_0000) > 0 { return Err(Error::new( ErrorKind::InvalidInput, - format!("address {:X} exceeds 24 bits", address) + format!("address {:X} exceeds 24 bits", address), )); } @@ -276,7 +274,7 @@ impl<'a, 't, T: Smfi> SpiRom<'a, 't, T> { if (address & 0xFF00_0000) > 0 { return Err(Error::new( ErrorKind::InvalidInput, - format!("address {:X} exceeds 24 bits", address) + format!("address {:X} exceeds 24 bits", address), )); } @@ -295,7 +293,7 @@ impl<'a, 't, T: Smfi> SpiRom<'a, 't, T> { if (address & 0xFF00_0000) > 0 { return Err(Error::new( ErrorKind::InvalidInput, - format!("address {:X} exceeds 24 bits", address) + format!("address {:X} exceeds 24 bits", address), )); } @@ -303,7 +301,7 @@ impl<'a, 't, T: Smfi> SpiRom<'a, 't, T> { if (data.len() % 2) != 0 { return Err(Error::new( ErrorKind::InvalidInput, - format!("length {} is not a multiple of 2", data.len()) + format!("length {} is not a multiple of 2", data.len()), )); } @@ -318,14 +316,10 @@ impl<'a, 't, T: Smfi> SpiRom<'a, 't, T> { (address >> 8) as u8, address as u8, word[0], - word[1] + word[1], ])?; } else { - self.bus.write(&[ - 0xAD, - word[0], - word[1] - ])?; + self.bus.write(&[0xAD, word[0], word[1]])?; } // Poll status for busy flag @@ -339,7 +333,7 @@ impl<'a, 't, T: Smfi> SpiRom<'a, 't, T> { } } -impl<'a, 't, T: Smfi> Drop for SpiRom<'a, 't, T> { +impl Drop for SpiRom<'_, '_, T> { fn drop(&mut self) { let _ = self.write_disable(); } @@ -361,7 +355,10 @@ impl ParallelArduino { .timeout(Duration::new(1, 0)) .open_native()?; - let mut port = Self { tty, buffer_size: 0 }; + let mut port = Self { + tty, + buffer_size: 0, + }; // Wait until programmer is ready thread::sleep(Duration::new(1, 0)); // Check that programmer is ready @@ -373,28 +370,21 @@ impl ParallelArduino { } fn echo(&mut self) -> Result<()> { - self.tty.write_all(&[ - b'E', - 0, - 0x76, - ])?; + self.tty.write_all(&[b'E', 0, 0x76])?; let mut b = [0]; self.tty.read_exact(&mut b)?; if b[0] != 0x76 { return Err(Error::new( ErrorKind::InvalidInput, - format!("received echo of {:02X} instead of {:02X}", b[0], 0x76) + format!("received echo of {:02X} instead of {:02X}", b[0], 0x76), )); } Ok(()) } fn update_buffer_size(&mut self) -> Result<()> { - self.tty.write_all(&[ - b'B', - 0, - ])?; + self.tty.write_all(&[b'B', 0])?; let mut b = [0; 1]; self.tty.read_exact(&mut b)?; @@ -408,10 +398,7 @@ impl ParallelArduino { impl Debugger for ParallelArduino { fn address(&mut self, address: u8) -> Result<()> { - self.tty.write_all(&[ - b'A', - address, - ])?; + self.tty.write_all(&[b'A', address])?; Ok(()) } @@ -419,10 +406,7 @@ impl Debugger for ParallelArduino { fn read(&mut self, data: &mut [u8]) -> Result { for chunk in data.chunks_mut(self.buffer_size) { let param = (chunk.len() - 1) as u8; - self.tty.write_all(&[ - b'R', - param, - ])?; + self.tty.write_all(&[b'R', param])?; self.tty.read_exact(chunk)?; } @@ -432,10 +416,7 @@ impl Debugger for ParallelArduino { fn write(&mut self, data: &[u8]) -> Result { for chunk in data.chunks(self.buffer_size) { let param = (chunk.len() - 1) as u8; - self.tty.write_all(&[ - b'W', - param, - ])?; + self.tty.write_all(&[b'W', param])?; self.tty.write_all(chunk)?; let mut b = [0]; @@ -443,7 +424,7 @@ impl Debugger for ParallelArduino { if b[0] != param { return Err(Error::new( ErrorKind::InvalidInput, - format!("received ack of {:02X} instead of {:02X}", b[0], param) + format!("received ack of {:02X} instead of {:02X}", b[0], param), )); } } @@ -461,9 +442,7 @@ impl I2EC { pub fn new() -> Result { //TODO: check EC ID using super i/o if unsafe { libc::iopl(3) } != 0 { - return Err(Error::from( - io::Error::last_os_error() - )); + return Err(Error::from(io::Error::last_os_error())); } Ok(Self { @@ -528,32 +507,36 @@ impl Pmc { pub unsafe fn command(&mut self, data: u8) { //eprintln!("PMC command {:02X}", data); - while ! self.can_write() {} + unsafe { while !self.can_write() {} } self.cmd.write(data); } pub unsafe fn read(&mut self) -> u8 { //eprintln!("PMC read"); - while ! self.can_read() {} + unsafe { while !self.can_read() {} } self.data.read() } pub unsafe fn write(&mut self, data: u8) { //eprintln!("PMC write {:02X}", data); - while ! self.can_write() {} + unsafe { while !self.can_write() {} } self.data.write(data); } pub unsafe fn acpi_read(&mut self, address: u8) -> u8 { - self.command(0x80); - self.write(address); - self.read() + unsafe { + self.command(0x80); + self.write(address); + self.read() + } } pub unsafe fn acpi_write(&mut self, address: u8, data: u8) { - self.command(0x81); - self.write(address); - self.write(data); + unsafe { + self.command(0x81); + self.write(address); + self.write(data); + } } } @@ -609,7 +592,11 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { if firmware.len() > rom_size { return Err(Error::new( ErrorKind::InvalidInput, - format!("firmware size {} exceeds rom size {}", firmware.len(), rom_size) + format!( + "firmware size {} exceeds rom size {}", + firmware.len(), + rom_size + ), )); } @@ -650,7 +637,7 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { let mut erased = true; for &b in &rom[address..address + 1024] { if b != 0xFF { - erased =false; + erased = false; break; } } @@ -674,7 +661,10 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { if rom[i] != 0xFF { return Err(Error::new( ErrorKind::InvalidInput, - format!("Failed to erase: {:X} is {:X} instead of {:X}", i, rom[i], 0xFF) + format!( + "Failed to erase: {:X} is {:X} instead of {:X}", + i, rom[i], 0xFF + ), )); } } @@ -688,15 +678,14 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { { eprintln!("SPI AAI word program (accelerated)"); - let port = (spi.bus.port as &mut dyn Any).downcast_mut::().unwrap(); + let port = (spi.bus.port as &mut dyn Any) + .downcast_mut::() + .unwrap(); for (i, chunk) in firmware.chunks(port.buffer_size).enumerate() { eprint!(" program {} / {}\r", i * port.buffer_size, firmware.len()); let param = (chunk.len() - 1) as u8; - port.tty.write_all(&[ - b'P', - param - ])?; + port.tty.write_all(&[b'P', param])?; port.tty.write_all(chunk)?; let mut b = [0]; @@ -704,7 +693,7 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { if b[0] != param { return Err(Error::new( ErrorKind::InvalidInput, - format!("received ack of {:02X} instead of {:02X}", b[0], param) + format!("received ack of {:02X} instead of {:02X}", b[0], param), )); } } @@ -717,7 +706,6 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { spi.write_at(0, firmware)?; } - // Read entire ROM eprintln!("SPI read"); spi.read_at(0, &mut rom)?; @@ -728,7 +716,10 @@ fn isp_inner(port: &mut T, firmware: &[u8]) -> Result<()> { if &rom[i] != firmware.get(i).unwrap_or(&0xFF) { return Err(Error::new( ErrorKind::InvalidInput, - format!("Failed to program: {:X} is {:X} instead of {:X}", i, rom[i], firmware[i]) + format!( + "Failed to program: {:X} is {:X} instead of {:X}", + i, rom[i], firmware[i] + ), )); } } @@ -759,7 +750,10 @@ fn isp(internal: bool, file: &str) -> Result<()> { if internal { unsafe { if libc::iopl(3) < 0 { - eprintln!("Failed to get I/O permission: {}", io::Error::last_os_error()); + eprintln!( + "Failed to get I/O permission: {}", + io::Error::last_os_error() + ); process::exit(1); } @@ -804,7 +798,7 @@ fn isp(internal: bool, file: &str) -> Result<()> { .expect("failed to run shutdown"); Ok(()) - }, + } Err(err) => { eprintln!("Failed to flash EC: {}", err); Err(err) diff --git a/examples/read.rs b/examples/read.rs index 7bd1eb9..505dbd6 100644 --- a/examples/read.rs +++ b/examples/read.rs @@ -4,14 +4,17 @@ use ecflash::{EcFlash, Flasher}; use std::{fs, io, process}; fn main() { - extern { + unsafe extern "C" { fn iopl(level: isize) -> isize; } // Get I/O Permission unsafe { if iopl(3) < 0 { - eprintln!("Failed to get I/O permission: {}", io::Error::last_os_error()); + eprintln!( + "Failed to get I/O permission: {}", + io::Error::last_os_error() + ); process::exit(1); } @@ -20,7 +23,7 @@ fn main() { let mut flasher = Flasher::new(ec); if flasher.start() == Ok(51) { - if let Ok(data) = flasher.read(|x| { eprint!("\r{} KB", x / 1024) }) { + if let Ok(data) = flasher.read(|x| eprint!("\r{} KB", x / 1024)) { eprintln!(); let _ = fs::write("read.rom", data); } else { diff --git a/examples/tcpc.rs b/examples/tcpc.rs index 24b058f..635e747 100644 --- a/examples/tcpc.rs +++ b/examples/tcpc.rs @@ -4,67 +4,57 @@ use ecflash::EcFlash; use std::{io, process}; fn tcpc_read(ec: &mut EcFlash, command: u8) -> Result { - let mut buf = [ - 0x2c, - command, - 0x00, - 0x00 - ]; + let mut buf = [0x2c, command, 0x00, 0x00]; unsafe { - ec.fcommand( - 0x76, - 0x10, - &mut buf - )?; + ec.fcommand(0x76, 0x10, &mut buf)?; } - Ok( - (buf[2] as u16) | - (buf[3] as u16) << 8 - ) + Ok((buf[2] as u16) | ((buf[3] as u16) << 8)) } fn tcpc_test() -> Result<(), ()> { - let mut ec = EcFlash::new(true).map_err(|_| ())?; - - let mut i = 0; - while i < 256 { - if i % 16 == 0 { - if i == 0 { - print!(" "); - for j in 0 .. 16 { - print!(" _{:01X}", j); - } + let mut ec = EcFlash::new(true).map_err(|_| ())?; + + let mut i = 0; + while i < 256 { + if i % 16 == 0 { + if i == 0 { + print!(" "); + for j in 0..16 { + print!(" _{:01X}", j); } - println!(); - print!("{:02X}:", i); } + println!(); + print!("{:02X}:", i); + } - let word = tcpc_read(&mut ec, i as u8)?; + let word = tcpc_read(&mut ec, i as u8)?; - print!(" {:02X}", word as u8); - print!(" {:02X}", (word >> 8) as u8); + print!(" {:02X}", word as u8); + print!(" {:02X}", (word >> 8) as u8); - i += 2; - } - println!(); + i += 2; + } + println!(); - Ok(()) + Ok(()) } fn main() { - extern { + unsafe extern "C" { fn iopl(level: isize) -> isize; } // Get I/O Permission unsafe { if iopl(3) < 0 { - eprintln!("Failed to get I/O permission: {}", io::Error::last_os_error()); + eprintln!( + "Failed to get I/O permission: {}", + io::Error::last_os_error() + ); process::exit(1); } - } tcpc_test().expect("Failed to run TCPM test"); diff --git a/src/flash.rs b/src/flash.rs index c9be247..ca00185 100644 --- a/src/flash.rs +++ b/src/flash.rs @@ -12,112 +12,112 @@ const TIMEOUT: usize = 100000; pub struct EcFlash { primary: bool, data_port: u16, - cmd_port: u16 + cmd_port: u16, } impl EcFlash { pub unsafe fn sts(&mut self) -> u8 { - inb(self.cmd_port) + unsafe { inb(self.cmd_port) } } pub unsafe fn can_read(&mut self) -> bool { - self.sts() & 1 == 1 + unsafe { self.sts() & 1 == 1 } } pub unsafe fn wait_read(&mut self, mut timeout: usize) -> Result<(), ()> { - while ! self.can_read() && timeout > 0 { + while !unsafe { self.can_read() } && timeout > 0 { timeout -= 1; } - if timeout == 0 { - Err(()) - } else { - Ok(()) - } + if timeout == 0 { Err(()) } else { Ok(()) } } pub unsafe fn can_write(&mut self) -> bool { - self.sts() & 2 == 0 + unsafe { self.sts() & 2 == 0 } } pub unsafe fn wait_write(&mut self, mut timeout: usize) -> Result<(), ()> { - while ! self.can_write() && timeout > 0 { + while !unsafe { self.can_write() } && timeout > 0 { timeout -= 1; } - if timeout == 0 { - Err(()) - } else { - Ok(()) - } + if timeout == 0 { Err(()) } else { Ok(()) } } pub unsafe fn flush(&mut self) -> Result<(), ()> { let mut i = TIMEOUT; - while self.can_read() && i > 0 { - inb(self.data_port); + while unsafe { self.can_read() } && i > 0 { + unsafe { inb(self.data_port) }; i -= 1; } - if i == 0 { - Err(()) - } else { - Ok(()) - } + if i == 0 { Err(()) } else { Ok(()) } } pub unsafe fn cmd(&mut self, data: u8) -> Result<(), ()> { - self.wait_write(TIMEOUT)?; - outb(self.cmd_port, data); - self.wait_write(TIMEOUT) + unsafe { + self.wait_write(TIMEOUT)?; + outb(self.cmd_port, data); + self.wait_write(TIMEOUT) + } } pub unsafe fn read(&mut self) -> Result { - self.wait_read(TIMEOUT)?; - Ok(inb(self.data_port)) + unsafe { + self.wait_read(TIMEOUT)?; + Ok(inb(self.data_port)) + } } pub unsafe fn write(&mut self, data: u8) -> Result<(), ()> { - self.wait_write(TIMEOUT)?; - outb(self.data_port, data); - self.wait_write(TIMEOUT) + unsafe { + self.wait_write(TIMEOUT)?; + outb(self.data_port, data); + self.wait_write(TIMEOUT) + } } pub unsafe fn get_param(&mut self, param: u8) -> Result { - self.cmd(0x80)?; - self.write(param)?; - self.read() + unsafe { + self.cmd(0x80)?; + self.write(param)?; + self.read() + } } pub unsafe fn set_param(&mut self, param: u8, data: u8) -> Result<(), ()> { - self.cmd(0x81)?; - self.write(param)?; - self.write(data) + unsafe { + self.cmd(0x81)?; + self.write(param)?; + self.write(data) + } } pub unsafe fn fcommand(&mut self, cmd: u8, dat: u8, buf: &mut [u8; 4]) -> Result<(), ()> { - self.set_param(0xF9, dat)?; - self.set_param(0xFA, buf[0])?; - self.set_param(0xFB, buf[1])?; - self.set_param(0xFC, buf[2])?; - self.set_param(0xFD, buf[3])?; + unsafe { + self.set_param(0xF9, dat)?; + self.set_param(0xFA, buf[0])?; + self.set_param(0xFB, buf[1])?; + self.set_param(0xFC, buf[2])?; + self.set_param(0xFD, buf[3])?; - self.set_param(0xF8, cmd)?; + self.set_param(0xF8, cmd)?; - buf[0] = self.get_param(0xFA)?; - buf[1] = self.get_param(0xFB)?; - buf[2] = self.get_param(0xFC)?; - buf[3] = self.get_param(0xFD)?; + buf[0] = self.get_param(0xFA)?; + buf[1] = self.get_param(0xFB)?; + buf[2] = self.get_param(0xFC)?; + buf[3] = self.get_param(0xFD)?; - self.set_param(0xF8, 0x00) + self.set_param(0xF8, 0x00) + } } pub unsafe fn get_str(&mut self, index: u8) -> Result { let mut string = String::new(); - self.cmd(index)?; + unsafe { self.cmd(index)? }; for _i in 0..16 { - let byte = self.read()?; + let byte = unsafe { self.read()? }; if byte == b'$' { break; } else { @@ -142,11 +142,7 @@ impl EcFlash { return Err(format!("Unknown EC ID: 0x{:>04X}", id)); } - let (data_port, cmd_port) = if primary { - (0x62, 0x66) - } else { - (0x68, 0x6c) - }; + let (data_port, cmd_port) = if primary { (0x62, 0x66) } else { (0x68, 0x6c) }; let ec = Self { primary, diff --git a/src/flasher.rs b/src/flasher.rs index 6c37048..ef460a4 100644 --- a/src/flasher.rs +++ b/src/flasher.rs @@ -14,109 +14,124 @@ pub struct Flasher { impl Flasher { pub fn new(mut ec: EcFlash) -> Self { let size = ec.size(); - Self { - ec, - size, - } + Self { ec, size } } unsafe fn enter_follow_mode(&mut self) -> Result<(), ()> { - self.ec.cmd(1) + unsafe { self.ec.cmd(1) } } unsafe fn spi_cmd(&mut self, cmd: u8) -> Result<(), ()> { - self.ec.cmd(2)?; - self.ec.cmd(cmd) + unsafe { + self.ec.cmd(2)?; + self.ec.cmd(cmd) + } } unsafe fn spi_write(&mut self, value: u8) -> Result<(), ()> { - self.ec.cmd(3)?; - self.ec.cmd(value) + unsafe { + self.ec.cmd(3)?; + self.ec.cmd(value) + } } unsafe fn spi_read(&mut self) -> Result { - self.ec.cmd(4)?; - self.ec.read() + unsafe { + self.ec.cmd(4)?; + self.ec.read() + } } unsafe fn exit_follow_mode(&mut self) -> Result<(), ()> { - self.ec.cmd(5) + unsafe { self.ec.cmd(5) } } unsafe fn spi_wait(&mut self) -> Result<(), ()> { - self.enter_follow_mode()?; - self.spi_cmd(5)?; - while self.spi_read()? & 1 > 0 {} - self.exit_follow_mode() + unsafe { + self.enter_follow_mode()?; + self.spi_cmd(5)?; + while self.spi_read()? & 1 > 0 {} + self.exit_follow_mode() + } } unsafe fn spi_write_enable(&mut self) -> Result<(), ()> { - self.spi_wait()?; - self.enter_follow_mode()?; - self.spi_cmd(6)?; - //TODO: extra spi command 80 based on device id 0xbf - self.enter_follow_mode()?; - self.spi_cmd(5)?; - while self.spi_read()? & 3 != 2 {} - self.exit_follow_mode() + unsafe { + self.spi_wait()?; + self.enter_follow_mode()?; + self.spi_cmd(6)?; + //TODO: extra spi command 80 based on device id 0xbf + self.enter_follow_mode()?; + self.spi_cmd(5)?; + while self.spi_read()? & 3 != 2 {} + self.exit_follow_mode() + } } unsafe fn spi_write_disable(&mut self) -> Result<(), ()> { - self.spi_wait()?; - self.enter_follow_mode()?; - self.spi_cmd(4)?; - self.enter_follow_mode()?; - self.spi_cmd(5)?; - while self.spi_read()? & 2 > 0 {} - self.exit_follow_mode() + unsafe { + self.spi_wait()?; + self.enter_follow_mode()?; + self.spi_cmd(4)?; + self.enter_follow_mode()?; + self.spi_cmd(5)?; + while self.spi_read()? & 2 > 0 {} + self.exit_follow_mode() + } } pub unsafe fn start(&mut self) -> Result { - self.ec.cmd(0xDC)?; - self.ec.read() + unsafe { + self.ec.cmd(0xDC)?; + self.ec.read() + } } pub unsafe fn read(&mut self, callback: F) -> Result, ()> { let mut buf = Vec::with_capacity(self.size); - for sector in 0..self.size/65536 { - self.spi_write_disable()?; - self.spi_wait()?; + unsafe { + for sector in 0..self.size / 65536 { + self.spi_write_disable()?; + self.spi_wait()?; - self.enter_follow_mode()?; + self.enter_follow_mode()?; - self.spi_cmd(0x0B)?; - self.spi_write(sector as u8)?; - self.spi_write(0)?; - self.spi_write(0)?; - self.spi_write(0)?; + self.spi_cmd(0x0B)?; + self.spi_write(sector as u8)?; + self.spi_write(0)?; + self.spi_write(0)?; + self.spi_write(0)?; - for _block in 0..64 { - for _ in 0..1024 { - buf.push(self.spi_read()?); + for _block in 0..64 { + for _ in 0..1024 { + buf.push(self.spi_read()?); + } + callback(buf.len()); } - callback(buf.len()); - } - self.spi_wait()?; + self.spi_wait()?; + } } Ok(buf) } pub unsafe fn erase(&mut self, callback: F) -> Result<(), ()> { - for sector in 0..self.size/65536 { + for sector in 0..self.size / 65536 { for block in 0..64 { let index = sector * 65536 + block * 1024; - self.spi_write_enable()?; - self.enter_follow_mode()?; - self.spi_cmd(0xD7)?; - self.spi_write(sector as u8)?; - self.spi_write(block as u8)?; - self.spi_write(0)?; - self.exit_follow_mode()?; - self.spi_wait()?; + unsafe { + self.spi_write_enable()?; + self.enter_follow_mode()?; + self.spi_cmd(0xD7)?; + self.spi_write(sector as u8)?; + self.spi_write(block as u8)?; + self.spi_write(0)?; + self.exit_follow_mode()?; + self.spi_wait()?; + } callback(index + 1024); } @@ -126,37 +141,41 @@ impl Flasher { } pub unsafe fn write(&mut self, buf: &[u8], callback: F) -> Result<(), ()> { - for sector in 0..self.size/65536 { - self.spi_write_enable()?; - - for block in 0..64 { - let index = sector * 65536 + block * 1024; + for sector in 0..self.size / 65536 { + unsafe { + self.spi_write_enable()?; - for word in 0..512 { - self.enter_follow_mode()?; - self.spi_cmd(0xAD)?; - if block == 0 && word == 0 { - self.spi_write(sector as u8)?; - self.spi_write((sector >> 8) as u8)?; - self.spi_write((sector >> 16) as u8)?; + for block in 0..64 { + let index = sector * 65536 + block * 1024; + + for word in 0..512 { + self.enter_follow_mode()?; + self.spi_cmd(0xAD)?; + if block == 0 && word == 0 { + self.spi_write(sector as u8)?; + self.spi_write((sector >> 8) as u8)?; + self.spi_write((sector >> 16) as u8)?; + } + self.spi_write(buf.get(index + word * 2).map_or(0xFF, |x| *x))?; + self.spi_write(buf.get(index + word * 2 + 1).map_or(0xFF, |x| *x))?; + self.spi_wait()?; } - self.spi_write(buf.get(index + word * 2).map_or(0xFF, |x| *x))?; - self.spi_write(buf.get(index + word * 2 + 1).map_or(0xFF, |x| *x))?; - self.spi_wait()?; + + callback(index + 1024); } - callback(index + 1024); + self.spi_write_disable()?; + self.spi_wait()?; } - - self.spi_write_disable()?; - self.spi_wait()?; } Ok(()) } pub unsafe fn stop(&mut self) -> Result<(), ()> { - self.ec.cmd(0x95)?; - self.ec.cmd(0xFC) + unsafe { + self.ec.cmd(0x95)?; + self.ec.cmd(0xFC) + } } } diff --git a/src/io.rs b/src/io.rs index 86545bb..709d042 100644 --- a/src/io.rs +++ b/src/io.rs @@ -1,13 +1,15 @@ -use core::arch::asm; - #[inline(always)] pub unsafe fn inb(port: u16) -> u8 { let value: u8; - asm!("in al, dx", out("al") value, in("dx") port, options(nostack)); + unsafe { + core::arch::asm!("in al, dx", out("al") value, in("dx") port, options(nostack)); + } value } #[inline(always)] pub unsafe fn outb(port: u16, value: u8) { - asm!("out dx, al", in("al") value, in("dx") port, options(nostack)); + unsafe { + core::arch::asm!("out dx, al", in("al") value, in("dx") port, options(nostack)); + } } diff --git a/src/main.rs b/src/main.rs index e0450c4..d17991a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,9 +1,9 @@ extern crate ecflash; -use std::{env, process}; use std::fmt::Display; use std::fs::File; -use std::io::{stdout, stderr, BufWriter, Error, Read, Write}; +use std::io::{BufWriter, Error, Read, Write, stderr, stdout}; +use std::{env, process}; use ecflash::{Ec, EcFile, EcFlash}; @@ -21,14 +21,18 @@ fn validate T>(mut f: F, attempts: usize) } fn main() { - extern { + unsafe extern "C" { fn iopl(level: isize) -> isize; } // Get I/O Permission unsafe { if iopl(3) < 0 { - let _ = writeln!(stderr(), "Failed to get I/O permission: {}", Error::last_os_error()); + let _ = writeln!( + stderr(), + "Failed to get I/O permission: {}", + Error::last_os_error() + ); process::exit(1); } } @@ -40,7 +44,7 @@ fn main() { "-1" => match EcFlash::new(true) { Ok(ec_flash) => { ecs.push((String::new(), Box::new(ec_flash))); - }, + } Err(err) => { let _ = writeln!(stderr(), "Failed to open EC flash 1: {}", err); process::exit(1); @@ -49,7 +53,7 @@ fn main() { "-2" => match EcFlash::new(false) { Ok(ec_flash) => { ecs.push((String::new(), Box::new(ec_flash))); - }, + } Err(err) => { let _ = writeln!(stderr(), "Failed to open EC flash 2: {}", err); process::exit(1); @@ -65,12 +69,12 @@ fn main() { process::exit(1); } } - }, + } Err(err) => { let _ = writeln!(stderr(), "Failed to open EC file '{}': {}", arg, err); process::exit(1); } - } + }, } } @@ -86,7 +90,7 @@ fn main() { match validate(|| ec.project(), 8) { Ok(project) => { let _ = writeln!(stdout, " Project: {}", project); - }, + } Err(()) => { let _ = writeln!(stderr(), "Failed to read EC project"); process::exit(1); @@ -96,7 +100,7 @@ fn main() { match validate(|| ec.version(), 8) { Ok(version) => { let _ = writeln!(stdout, " Version: {}", version); - }, + } Err(()) => { let _ = writeln!(stderr(), "Failed to read EC version"); process::exit(1); @@ -105,8 +109,8 @@ fn main() { match validate(|| ec.size(), 8) { Ok(size) => { - let _ = writeln!(stdout, " Size: {} KB", size/1024); - }, + let _ = writeln!(stdout, " Size: {} KB", size / 1024); + } Err(()) => { let _ = writeln!(stderr(), "Failed to read EC size"); process::exit(1);