Simplify features and detect based on OS

Now we can build on Windows just with `cargo build`!

Signed-off-by: Daniel Schaefer <dhs@frame.work>

Author: JohnAZoidberg

.github/workflows/ci.yml

@@ -93,15 +93,15 @@ jobs:
 
     # Build debug library first to fail fast
     - name: Build library (Windows)
-      run: cargo build -p framework_lib --no-default-features --features "windows"
+      run: cargo build -p framework_lib
 
     - name: Build Windows tool
       run: |
-        cargo build -p framework_tool --no-default-features --features "windows"
-        cargo build -p framework_tool --no-default-features --features "windows" --release
+        cargo build -p framework_tool
+        cargo build -p framework_tool --release
 
     - name: Check if Windows tool can start
-      run: cargo run --no-default-features --features "windows" -- --help --release
+      run: cargo run -- --help --release
 
     # Upload release build so that vcruntime is statically linked
     - name: Upload Windows App

README.md

@@ -130,10 +130,10 @@ Building on Windows or in general with fewer features:
 
 ```ps1
 # Build the library and tool
-cargo build --no-default-features --features "windows"
+cargo build
 
 # Running the tool
-cargo run --no-default-features --features "windows"
+cargo run
 ```
 
 Cross compile from Linux to FreeBSD:
@@ -146,7 +146,7 @@ cargo install cross
 sudo systemctl start docker
 
 # Build
-cross build --target=x86_64-unknown-freebsd --no-default-features --features unix
+cross build --target=x86_64-unknown-freebsd --no-default-features --features cross_freebsd
 ```
 
 ## Running
@@ -375,8 +375,8 @@ Keyboard backlight: 0%
 sudo pkg install hidapi
 
 # Build the library and tool
-cargo build --no-default-features --features freebsd
+cargo build
 
 # Running the tool
-cargo run --no-default-features --features freebsd
+cargo run
 ```

framework_lib/Cargo.toml

@@ -8,79 +8,66 @@ rust-version = "1.74"
 build = "build.rs"
 
 [features]
-default = ["linux"]
-# Linux/FreeBSD
-unix = ["std", "raw_pio", "smbios", "dep:nix", "dep:libc"]
-linux = ["unix", "linux_pio", "cros_ec_driver", "hidapi", "rusb"]
-freebsd = ["unix", "freebsd_pio", "hidapi", "rusb"]
+default = ["std"]
+std = ["hidapi", "rusb"]
+
 # hidapi and rusb don't seem to build in the cross container at the moment
-cross_freebsd = ["unix", "freebsd_pio"]
-# Windows does not have the cros_ec driver nor raw port I/O access to userspace
-windows = ["std", "smbios", "dep:windows", "win_driver", "raw_pio", "hidapi", "rusb", "dep:wmi"]
-smbios = ["dep:smbios-lib"]
-std = ["dep:clap", "dep:clap-num", "dep:clap-verbosity-flag", "dep:env_logger", "smbios-lib?/std"]
+cross_freebsd = []
 rusb = ["dep:rusb"]
 hidapi = ["dep:hidapi"]
 uefi = [
-    "dep:plain", "raw_pio", "smbios", "lazy_static/spin_no_std", "dep:uefi", "dep:uefi-services",
+    "lazy_static/spin_no_std",
     # Otherwise I get: `LLVM ERROR: Do not know how to split the result of this operator!`
     # Seems to be a Ruset/LLVM bug when SSE is enabled.
     # See: https://github.com/rust-lang/rust/issues/61721
     "sha2/force-soft"
 ]
 
-# EC communication via Port I/O on FreeBSD
-freebsd_pio = ["redox_hwio/std"]
-# EC communication via Port I/O on Linux
-linux_pio = ["dep:libc", "redox_hwio/std"]
-# EC communication via raw Port I/O (e.g. UEFI or other ring 0 code)
-raw_pio = []
-# EC communication via cros_ec driver on Linux
-cros_ec_driver = []
-
-# Chromium EC driver by DHowett
-win_driver = []
-
 [build-dependencies]
 built = { version = "0.5", features = ["chrono", "git2"] }
 
 [dependencies]
 lazy_static = "1.4.0"
 sha2 = { version = "0.10.8", default-features = false, features = [ "force-soft" ] }
 regex = { version = "1.11.1", default-features = false }
-redox_hwio = { git = "https://github.com/FrameworkComputer/rust-hwio", branch = "freebsd", default-features = false }
-libc = { version = "0.2.155", optional = true }
-clap = { version = "4.5", features = ["derive", "cargo"], optional = true }
-clap-num = { version = "1.2.0", optional = true }
-clap-verbosity-flag = { version = "2.2.1", optional = true }
-nix = { version = "0.29.0", features = ["ioctl", "user"], optional = true }
 num = { version = "0.4", default-features = false }
 num-derive = { version = "0.4", default-features = false }
 num-traits = { version = "0.2", default-features = false }
-env_logger = { version = "0.11", optional = true }
 log = { version = "0.4", default-features = true }
-uefi = { version = "0.20", features = ["alloc"], optional = true }
-uefi-services = { version = "0.17", optional = true }
-plain = { version = "0.2.3", optional = true }
-spin = { version = "0.9.8", optional = false }
-hidapi = { version = "2.6.3", optional = true, features = [ "windows-native" ] }
-rusb = { version = "0.9.4", optional = true }
+spin = { version = "0.9.8" }
 no-std-compat = { version = "0.4.1", features = [ "alloc" ] }
 guid_macros = { path = "../guid_macros" }
-wmi = { version = "0.15.0", optional = true }
 
-[dependencies.smbios-lib]
-git = "https://github.com/FrameworkComputer/smbios-lib.git"
-branch = "no-std"
-optional = true
-default-features = false
-# Local development
-#path = "../../smbios-lib"
-# After my changes are upstreamed
-#version = "0.9.0"
+[target.'cfg(target_os = "uefi")'.dependencies]
+uefi = { version = "0.20", features = ["alloc"] }
+uefi-services = "0.17"
+plain = "0.2.3"
+redox_hwio = { git = "https://github.com/FrameworkComputer/rust-hwio", branch = "freebsd", default-features = false }
+smbios-lib = { git = "https://github.com/FrameworkComputer/smbios-lib.git", branch = "no-std", default-features = false }
+
+[target.'cfg(windows)'.dependencies]
+wmi = "0.15.0"
+smbios-lib = { git = "https://github.com/FrameworkComputer/smbios-lib.git", branch = "no-std" }
+env_logger = "0.11"
+clap = { version = "4.5", features = ["derive", "cargo"] }
+clap-num = { version = "1.2.0" }
+clap-verbosity-flag = { version = "2.2.1" }
+hidapi = { version = "2.6.3", features = [ "windows-native" ] }
+rusb = "0.9.4"
+
+[target.'cfg(unix)'.dependencies]
+libc = "0.2.155"
+nix = { version = "0.29.0", features = ["ioctl", "user"] }
+redox_hwio = { git = "https://github.com/FrameworkComputer/rust-hwio", branch = "freebsd" }
+smbios-lib = { git = "https://github.com/FrameworkComputer/smbios-lib.git", branch = "no-std" }
+env_logger = "0.11"
+clap = { version = "4.5", features = ["derive", "cargo"] }
+clap-num = { version = "1.2.0" }
+clap-verbosity-flag = { version = "2.2.1" }
+hidapi = { version = "2.6.3", features = [ "windows-native" ], optional = true }
+rusb = { version = "0.9.4", optional = true }
 
-[dependencies.windows]
-optional = true
+[target.'cfg(windows)'.dependencies.windows]
 version = "0.59.0"
 features = [
     "Win32_Foundation",

framework_lib/src/chromium_ec/command.rs

@@ -173,9 +173,9 @@ pub trait EcRequestRaw<R> {
     {
         let response = self.send_command_vec_extra(ec, extra_data)?;
         // TODO: The Windows driver seems to return 20 more bytes than expected
-        #[cfg(feature = "win_driver")]
+        #[cfg(windows)]
         let expected = response.len() != std::mem::size_of::<R>() + 20;
-        #[cfg(not(feature = "win_driver"))]
+        #[cfg(not(windows))]
         let expected = response.len() != std::mem::size_of::<R>();
         if expected {
             return Err(EcError::DeviceError(format!(

framework_lib/src/chromium_ec/mod.rs

@@ -21,13 +21,17 @@ use num_derive::FromPrimitive;
 
 pub mod command;
 pub mod commands;
-#[cfg(feature = "cros_ec_driver")]
+#[cfg(target_os = "linux")]
 mod cros_ec;
 pub mod i2c_passthrough;
 pub mod input_deck;
+#[cfg(not(windows))]
 mod portio;
+#[cfg(not(windows))]
 mod portio_mec;
-#[cfg(feature = "win_driver")]
+#[allow(dead_code)]
+mod protocol;
+#[cfg(windows)]
 mod windows;
 
 use alloc::format;
@@ -224,15 +228,15 @@ impl Default for CrosEc {
 fn available_drivers() -> Vec<CrosEcDriverType> {
     let mut drivers = vec![];
 
-    #[cfg(feature = "win_driver")]
+    #[cfg(windows)]
     drivers.push(CrosEcDriverType::Windows);
 
-    #[cfg(feature = "cros_ec_driver")]
+    #[cfg(target_os = "linux")]
     if std::path::Path::new(cros_ec::DEV_PATH).exists() {
         drivers.push(CrosEcDriverType::CrosEc);
     }
 
-    #[cfg(not(feature = "windows"))]
+    #[cfg(not(windows))]
     drivers.push(CrosEcDriverType::Portio);
 
     drivers
@@ -1320,10 +1324,11 @@ impl CrosEcDriver for CrosEc {
 
         // TODO: Change this function to return EcResult instead and print the error only in UI code
         print_err(match self.driver {
+            #[cfg(not(windows))]
             CrosEcDriverType::Portio => portio::read_memory(offset, length),
-            #[cfg(feature = "win_driver")]
+            #[cfg(windows)]
             CrosEcDriverType::Windows => windows::read_memory(offset, length),
-            #[cfg(feature = "cros_ec_driver")]
+            #[cfg(target_os = "linux")]
             CrosEcDriverType::CrosEc => cros_ec::read_memory(offset, length),
             _ => Err(EcError::DeviceError("No EC driver available".to_string())),
         })
@@ -1341,10 +1346,11 @@ impl CrosEcDriver for CrosEc {
         }
 
         match self.driver {
+            #[cfg(not(windows))]
             CrosEcDriverType::Portio => portio::send_command(command, command_version, data),
-            #[cfg(feature = "win_driver")]
+            #[cfg(windows)]
             CrosEcDriverType::Windows => windows::send_command(command, command_version, data),
-            #[cfg(feature = "cros_ec_driver")]
+            #[cfg(target_os = "linux")]
             CrosEcDriverType::CrosEc => cros_ec::send_command(command, command_version, data),
             _ => Err(EcError::DeviceError("No EC driver available".to_string())),
         }

framework_lib/src/chromium_ec/portio.rs

@@ -4,130 +4,21 @@ use alloc::string::ToString;
 use alloc::vec;
 use alloc::vec::Vec;
 use core::convert::TryInto;
-#[cfg(any(feature = "linux_pio", feature = "freebsd_pio", feature = "raw_pio"))]
+#[cfg(not(windows))]
 use hwio::{Io, Pio};
-#[cfg(all(feature = "linux_pio", target_os = "linux"))]
+#[cfg(target_os = "linux")]
 use libc::ioperm;
 use log::Level;
-#[cfg(feature = "linux_pio")]
+#[cfg(target_os = "linux")]
 use nix::unistd::Uid;
 use num::FromPrimitive;
 use spin::Mutex;
 
+use crate::chromium_ec::protocol::*;
 use crate::chromium_ec::{portio_mec, EC_MEMMAP_ID};
 use crate::os_specific;
 use crate::util;
 
-/*
- * Value written to legacy command port / prefix byte to indicate protocol
- * 3+ structs are being used.  Usage is bus-dependent.
- */
-const EC_COMMAND_PROTOCOL_3: u8 = 0xda;
-
-// LPC command status byte masks
-/// EC has written data but host hasn't consumed it yet
-const _EC_LPC_STATUS_TO_HOST: u8 = 0x01;
-/// Host has written data/command but EC hasn't consumed it yet
-const EC_LPC_STATUS_FROM_HOST: u8 = 0x02;
-/// EC is still processing a command
-const EC_LPC_STATUS_PROCESSING: u8 = 0x04;
-/// Previous command wasn't data but command
-const _EC_LPC_STATUS_LAST_CMD: u8 = 0x08;
-/// EC is in burst mode
-const _EC_LPC_STATUS_BURST_MODE: u8 = 0x10;
-/// SCI event is pending (requesting SCI query)
-const _EC_LPC_STATUS_SCI_PENDING: u8 = 0x20;
-/// SMI event is pending (requesting SMI query)
-const _EC_LPC_STATUS_SMI_PENDING: u8 = 0x40;
-/// Reserved
-const _EC_LPC_STATUS_RESERVED: u8 = 0x80;
-
-/// EC is busy
-const EC_LPC_STATUS_BUSY_MASK: u8 = EC_LPC_STATUS_FROM_HOST | EC_LPC_STATUS_PROCESSING;
-
-// I/O addresses for ACPI commands
-const _EC_LPC_ADDR_ACPI_DATA: u16 = 0x62;
-const _EC_LPC_ADDR_ACPI_CMD: u16 = 0x66;
-
-// I/O addresses for host command
-const EC_LPC_ADDR_HOST_DATA: u16 = 0x200;
-const EC_LPC_ADDR_HOST_CMD: u16 = 0x204;
-
-// I/O addresses for host command args and params
-// Protocol version 2
-const EC_LPC_ADDR_HOST_ARGS: u16 = 0x800; /* And 0x801, 0x802, 0x803 */
-const _EC_LPC_ADDR_HOST_PARAM: u16 = 0x804; /* For version 2 params; size is
-                                             * EC_PROTO2_MAX_PARAM_SIZE */
-// Protocol version 3
-const _EC_LPC_ADDR_HOST_PACKET: u16 = 0x800; /* Offset of version 3 packet */
-const EC_LPC_HOST_PACKET_SIZE: u16 = 0x100; /* Max size of version 3 packet */
-
-const MEC_MEMMAP_OFFSET: u16 = 0x100;
-const NPC_MEMMAP_OFFSET: u16 = 0xE00;
-
-// The actual block is 0x800-0x8ff, but some BIOSes think it's 0x880-0x8ff
-// and they tell the kernel that so we have to think of it as two parts.
-const _EC_HOST_CMD_REGION0: u16 = 0x800;
-const _EC_HOST_CMD_REGION1: u16 = 0x8800;
-const _EC_HOST_CMD_REGION_SIZE: u16 = 0x80;
-
-// EC command register bit functions
-const _EC_LPC_CMDR_DATA: u16 = 1 << 0; // Data ready for host to read
-const _EC_LPC_CMDR_PENDING: u16 = 1 << 1; // Write pending to EC
-const _EC_LPC_CMDR_BUSY: u16 = 1 << 2; // EC is busy processing a command
-const _EC_LPC_CMDR_CMD: u16 = 1 << 3; // Last host write was a command
-const _EC_LPC_CMDR_ACPI_BRST: u16 = 1 << 4; // Burst mode (not used)
-const _EC_LPC_CMDR_SCI: u16 = 1 << 5; // SCI event is pending
-const _EC_LPC_CMDR_SMI: u16 = 1 << 6; // SMI event is pending
-
-const EC_HOST_REQUEST_VERSION: u8 = 3;
-
-/// Request header of version 3
-#[repr(C, packed)]
-struct EcHostRequest {
-    /// Version of this request structure (must be 3)
-    pub struct_version: u8,
-
-    /// Checksum of entire request (header and data)
-    /// Everything added together adds up to 0 (wrapping around u8 limit)
-    pub checksum: u8,
-
-    /// Command number
-    pub command: u16,
-
-    /// Command version, usually 0
-    pub command_version: u8,
-
-    /// Reserved byte in protocol v3. Must be 0
-    pub reserved: u8,
-
-    /// Data length. Data is immediately after the header
-    pub data_len: u16,
-}
-
-const EC_HOST_RESPONSE_VERSION: u8 = 3;
-
-/// Response header of version 3
-#[repr(C, packed)]
-struct EcHostResponse {
-    /// Version of this request structure (must be 3)
-    pub struct_version: u8,
-
-    /// Checksum of entire request (header and data)
-    pub checksum: u8,
-
-    /// Status code of response. See enum _EcStatus
-    pub result: u16,
-
-    /// Data length. Data is immediately after the header
-    pub data_len: u16,
-
-    /// Reserved byte in protocol v3. Must be 0
-    pub reserved: u16,
-}
-#[allow(dead_code)]
-pub const HEADER_LEN: usize = std::mem::size_of::<EcHostResponse>();
-
 fn transfer_write(buffer: &[u8]) {
     if has_mec() {
         return portio_mec::transfer_write(buffer);
@@ -209,13 +100,13 @@ fn init() -> bool {
 
     // In Linux userspace has to first request access to ioports
     // TODO: Close these again after we're done
-    #[cfg(feature = "linux_pio")]
+    #[cfg(target_os = "linux")]
     if !Uid::effective().is_root() {
         error!("Must be root to use port based I/O for EC communication.");
         *init = Initialized::Failed;
         return false;
     }
-    #[cfg(feature = "linux_pio")]
+    #[cfg(target_os = "linux")]
     unsafe {
         // 8 for request/response header, 0xFF for response
         let res = ioperm(EC_LPC_ADDR_HOST_ARGS as u64, 8 + 0xFF, 1);