framework-tool-tui 0.8.5

TUI for controlling and monitoring Framework Computers hardware built in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::sync::Arc;

use color_eyre::eyre::Report;
use framework_lib::chromium_ec::CrosEc;
use framework_lib::chromium_ec::CrosEcDriver;
use framework_lib::chromium_ec::EcError;
use framework_lib::smbios;

use crate::framework::fingerprint::led_brightness_percentage_to_level;
use crate::framework::fingerprint::Fingerprint;
use crate::framework::fingerprint::FpLedBrightnessCapability;
use crate::framework::info::FrameworkInfo;

pub mod fingerprint;
pub mod info;

// Copied from framework_lib::power
const EC_MEMMAP_FAN: u16 = 0x10; // Fan speeds 0x10 - 0x17
const EC_FAN_SPEED_ENTRIES: usize = 4;
/// Used on old EC firmware (before 2023)
const EC_FAN_SPEED_NOT_PRESENT: u16 = 0xFFFF;

pub struct Framework {
    ec: CrosEc,
    fingerprint: Arc<Fingerprint>,
}

#[derive(Debug)]
pub struct EcErrorWrapper(pub EcError);

impl std::fmt::Display for EcErrorWrapper {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.0)
    }
}

impl std::error::Error for EcErrorWrapper {}

impl Framework {
    pub fn new(ec: CrosEc, fingerprint: Arc<Fingerprint>) -> Self {
        Framework { ec, fingerprint }
    }

    pub fn set_max_charge_limit(&self, value: u8) -> color_eyre::Result<()> {
        self.ec
            .set_charge_limit(0, value)
            .map_err(|error| Report::from(EcErrorWrapper(error)))
    }

    pub fn set_fp_brightness(&self, percentage: u8) -> color_eyre::Result<()> {
        let result = match self.fingerprint.led_brightness_capability {
            FpLedBrightnessCapability::Level => {
                let level = led_brightness_percentage_to_level(percentage);

                self.ec.set_fp_led_level(level)
            }
            FpLedBrightnessCapability::Percentage => self.ec.set_fp_led_percentage(percentage),
        };

        result.map_err(|error| Report::from(EcErrorWrapper(error)))
    }

    // NOTE: the underlying ec API is weird
    pub fn set_kb_brightness(&self, percentage: u8) {
        self.ec.set_keyboard_backlight(percentage);
    }

    pub fn get_info(&mut self) -> FrameworkInfo {
        let power = framework_lib::power::power_info(&self.ec);
        let charge_limit = self.ec.get_charge_limit().ok();
        let privacy = self.ec.get_privacy_info().ok();
        let fp_brightness = self.ec.get_fp_led_level().ok();
        let kb_brightness = self.ec.get_keyboard_backlight().ok();
        let smbios = smbios::get_smbios();
        let pd_ports = framework_lib::power::get_pd_info(&self.ec, 4)
            .into_iter()
            .map(Result::ok)
            .collect();
        let fan_rpm = self.get_fan_rpm().ok();
        let platform = smbios::get_platform();

        FrameworkInfo::new(
            &power,
            &charge_limit,
            &privacy,
            &fp_brightness,
            kb_brightness,
            &smbios,
            pd_ports,
            fan_rpm,
            platform,
        )
    }

    fn get_fan_rpm(&self) -> color_eyre::Result<Vec<u16>> {
        let fans = self
            .ec
            .read_memory(EC_MEMMAP_FAN, 0x08)
            .ok_or(Report::msg("Couldn't read fan info"))?;
        let mut rpms = Vec::new();

        for i in 0..EC_FAN_SPEED_ENTRIES {
            let rpm = u16::from_le_bytes([fans[i * 2], fans[1 + i * 2]]);

            if rpm == EC_FAN_SPEED_NOT_PRESENT {
                continue;
            }

            rpms.push(rpm);
        }

        Ok(rpms)
    }
}