use core::fmt;
use core::time::Duration;
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct BringUpConfig {
pub ratio_wait: Duration,
pub scrambling_deadline: Duration,
pub check_window: Duration,
pub check_interval: Duration,
pub clear_frl: ClearFrl,
pub source_version: SourceVersionWrite,
pub output_during_sink_write: OutputDuringSinkWrite,
pub tmds_config_write: TmdsConfigWrite,
pub on_tmds_config_failure: OnTmdsConfigFailure,
pub tear_down_on_error: bool,
pub tear_down: TearDownConfig,
}
impl BringUpConfig {
pub const DEFAULT: Self = Self {
ratio_wait: Duration::from_millis(1),
scrambling_deadline: Duration::from_millis(100),
check_window: Duration::from_millis(200),
check_interval: Duration::from_millis(1),
clear_frl: ClearFrl::IfSinkDeclaresFrl,
source_version: SourceVersionWrite::EveryBringUp,
output_during_sink_write: OutputDuringSinkWrite::Stopped,
tmds_config_write: TmdsConfigWrite::ReadModifyWrite,
on_tmds_config_failure: OnTmdsConfigFailure::CarryOn,
tear_down_on_error: true,
tear_down: TearDownConfig::DEFAULT,
};
pub const fn validate(&self) -> Result<(), ConfigError> {
let error = ConfigError {
deadline_always_missed: self.scrambling_deadline.as_nanos()
<= self.ratio_wait.as_nanos(),
check_reads_once: self.check_interval.as_nanos() >= self.check_window.as_nanos(),
check_interval_zero: self.check_interval.is_zero(),
};
if error.deadline_always_missed || error.check_reads_once || error.check_interval_zero {
Err(error)
} else {
Ok(())
}
}
#[must_use]
pub const fn with_ratio_wait(mut self, ratio_wait: Duration) -> Self {
self.ratio_wait = ratio_wait;
self
}
#[must_use]
pub const fn with_scrambling_deadline(mut self, scrambling_deadline: Duration) -> Self {
self.scrambling_deadline = scrambling_deadline;
self
}
#[must_use]
pub const fn with_check_window(mut self, check_window: Duration) -> Self {
self.check_window = check_window;
self
}
#[must_use]
pub const fn with_check_interval(mut self, check_interval: Duration) -> Self {
self.check_interval = check_interval;
self
}
#[must_use]
pub const fn with_clear_frl(mut self, clear_frl: ClearFrl) -> Self {
self.clear_frl = clear_frl;
self
}
#[must_use]
pub const fn with_source_version(mut self, source_version: SourceVersionWrite) -> Self {
self.source_version = source_version;
self
}
#[must_use]
pub const fn with_output_during_sink_write(
mut self,
output_during_sink_write: OutputDuringSinkWrite,
) -> Self {
self.output_during_sink_write = output_during_sink_write;
self
}
#[must_use]
pub const fn with_tmds_config_write(mut self, tmds_config_write: TmdsConfigWrite) -> Self {
self.tmds_config_write = tmds_config_write;
self
}
#[must_use]
pub const fn with_on_tmds_config_failure(
mut self,
on_tmds_config_failure: OnTmdsConfigFailure,
) -> Self {
self.on_tmds_config_failure = on_tmds_config_failure;
self
}
#[must_use]
pub const fn with_tear_down_on_error(mut self, tear_down_on_error: bool) -> Self {
self.tear_down_on_error = tear_down_on_error;
self
}
#[must_use]
pub const fn with_tear_down(mut self, tear_down: TearDownConfig) -> Self {
self.tear_down = tear_down;
self
}
}
impl Default for BringUpConfig {
fn default() -> Self {
Self::DEFAULT
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ConfigError {
pub deadline_always_missed: bool,
pub check_reads_once: bool,
pub check_interval_zero: bool,
}
impl fmt::Display for ConfigError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let problems = [
(
self.deadline_always_missed,
"the scrambling deadline is not longer than the ratio wait",
),
(
self.check_reads_once,
"the check interval is not shorter than the check window",
),
(self.check_interval_zero, "the check interval is 0"),
];
let mut first = true;
for (found, text) in problems {
if found {
if !first {
f.write_str("; ")?;
}
f.write_str(text)?;
first = false;
}
}
if first {
f.write_str("the bring-up settings are inconsistent")?;
}
Ok(())
}
}
impl core::error::Error for ConfigError {}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum OutputDuringSinkWrite {
#[default]
Stopped,
Running,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum TmdsConfigWrite {
#[default]
ReadModifyWrite,
WholeByte,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum OnTmdsConfigFailure {
#[default]
CarryOn,
Stop,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum ClearFrl {
#[default]
IfSinkDeclaresFrl,
EveryScdcSink,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum SourceVersionWrite {
#[default]
EveryBringUp,
IfSinkVersion1,
WhenScrambling,
Never,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TearDownConfig {
pub clear_sink: bool,
pub sink_clear_timing: SinkClearTiming,
pub scrambler_off: ScramblerOff,
}
impl TearDownConfig {
pub const DEFAULT: Self = Self {
clear_sink: false,
sink_clear_timing: SinkClearTiming::BeforeOutputStops,
scrambler_off: ScramblerOff::AfterSink,
};
#[must_use]
pub const fn with_clear_sink(mut self, clear_sink: bool) -> Self {
self.clear_sink = clear_sink;
self
}
#[must_use]
pub const fn with_sink_clear_timing(mut self, sink_clear_timing: SinkClearTiming) -> Self {
self.sink_clear_timing = sink_clear_timing;
self
}
#[must_use]
pub const fn with_scrambler_off(mut self, scrambler_off: ScramblerOff) -> Self {
self.scrambler_off = scrambler_off;
self
}
}
impl Default for TearDownConfig {
fn default() -> Self {
Self::DEFAULT
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum SinkClearTiming {
#[default]
BeforeOutputStops,
AfterOutputStops,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum ScramblerOff {
#[default]
AfterSink,
BeforeSink,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SinkPresence {
Present,
Gone,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn defaults_are_the_documented_ones() {
let c = BringUpConfig::default();
assert_eq!(c, BringUpConfig::DEFAULT);
assert_eq!(c.ratio_wait, Duration::from_millis(1));
assert_eq!(c.scrambling_deadline, Duration::from_millis(100));
assert_eq!(c.check_window, Duration::from_millis(200));
assert_eq!(c.check_interval, Duration::from_millis(1));
assert_eq!(c.clear_frl, ClearFrl::IfSinkDeclaresFrl);
assert_eq!(c.source_version, SourceVersionWrite::EveryBringUp);
assert_eq!(c.output_during_sink_write, OutputDuringSinkWrite::Stopped);
assert_eq!(c.tmds_config_write, TmdsConfigWrite::ReadModifyWrite);
assert_eq!(c.on_tmds_config_failure, OnTmdsConfigFailure::CarryOn);
assert!(c.tear_down_on_error);
assert_eq!(c.tear_down, TearDownConfig::default());
let t = TearDownConfig::default();
assert!(!t.clear_sink);
assert_eq!(t.sink_clear_timing, SinkClearTiming::BeforeOutputStops);
assert_eq!(t.scrambler_off, ScramblerOff::AfterSink);
assert_eq!(
OutputDuringSinkWrite::default(),
OutputDuringSinkWrite::Stopped
);
assert_eq!(TmdsConfigWrite::default(), TmdsConfigWrite::ReadModifyWrite);
assert_eq!(OnTmdsConfigFailure::default(), OnTmdsConfigFailure::CarryOn);
assert_eq!(ClearFrl::default(), ClearFrl::IfSinkDeclaresFrl);
assert_eq!(
SourceVersionWrite::default(),
SourceVersionWrite::EveryBringUp
);
assert_eq!(
SinkClearTiming::default(),
SinkClearTiming::BeforeOutputStops
);
assert_eq!(ScramblerOff::default(), ScramblerOff::AfterSink);
}
const _: BringUpConfig = BringUpConfig::DEFAULT
.with_ratio_wait(Duration::from_millis(2))
.with_scrambling_deadline(Duration::from_millis(50))
.with_check_window(Duration::from_millis(300))
.with_check_interval(Duration::from_millis(5))
.with_clear_frl(ClearFrl::EveryScdcSink)
.with_source_version(SourceVersionWrite::Never)
.with_output_during_sink_write(OutputDuringSinkWrite::Running)
.with_tmds_config_write(TmdsConfigWrite::WholeByte)
.with_on_tmds_config_failure(OnTmdsConfigFailure::Stop)
.with_tear_down_on_error(false)
.with_tear_down(
TearDownConfig::DEFAULT
.with_clear_sink(true)
.with_sink_clear_timing(SinkClearTiming::AfterOutputStops)
.with_scrambler_off(ScramblerOff::BeforeSink),
);
#[test]
fn each_setter_changes_its_field_alone() {
let tear_down = TearDownConfig::DEFAULT
.with_clear_sink(true)
.with_sink_clear_timing(SinkClearTiming::AfterOutputStops)
.with_scrambler_off(ScramblerOff::BeforeSink);
let config = BringUpConfig::DEFAULT
.with_ratio_wait(Duration::from_millis(2))
.with_scrambling_deadline(Duration::from_millis(50))
.with_check_window(Duration::from_millis(300))
.with_check_interval(Duration::from_millis(5))
.with_clear_frl(ClearFrl::EveryScdcSink)
.with_source_version(SourceVersionWrite::Never)
.with_output_during_sink_write(OutputDuringSinkWrite::Running)
.with_tmds_config_write(TmdsConfigWrite::WholeByte)
.with_on_tmds_config_failure(OnTmdsConfigFailure::Stop)
.with_tear_down_on_error(false)
.with_tear_down(tear_down);
assert_eq!(config.ratio_wait, Duration::from_millis(2));
assert_eq!(config.scrambling_deadline, Duration::from_millis(50));
assert_eq!(config.check_window, Duration::from_millis(300));
assert_eq!(config.check_interval, Duration::from_millis(5));
assert_eq!(config.clear_frl, ClearFrl::EveryScdcSink);
assert_eq!(config.source_version, SourceVersionWrite::Never);
assert_eq!(
config.output_during_sink_write,
OutputDuringSinkWrite::Running
);
assert_eq!(config.tmds_config_write, TmdsConfigWrite::WholeByte);
assert_eq!(config.on_tmds_config_failure, OnTmdsConfigFailure::Stop);
assert!(!config.tear_down_on_error);
assert_eq!(config.tear_down, tear_down);
assert!(tear_down.clear_sink);
assert_eq!(
tear_down.sink_clear_timing,
SinkClearTiming::AfterOutputStops
);
assert_eq!(tear_down.scrambler_off, ScramblerOff::BeforeSink);
assert_eq!(
BringUpConfig::DEFAULT.with_tear_down_on_error(false),
BringUpConfig {
tear_down_on_error: false,
..BringUpConfig::DEFAULT
}
);
}
#[test]
fn validate_reports_every_problem() {
const { assert!(BringUpConfig::DEFAULT.validate().is_ok()) };
let none = ConfigError {
deadline_always_missed: false,
check_reads_once: false,
check_interval_zero: false,
};
let wait = Duration::from_millis(50);
let late = BringUpConfig::DEFAULT
.with_ratio_wait(wait)
.with_scrambling_deadline(wait);
assert_eq!(
late.validate(),
Err(ConfigError {
deadline_always_missed: true,
..none
})
);
assert!(
late.with_scrambling_deadline(wait + Duration::from_nanos(1))
.validate()
.is_ok()
);
let once = BringUpConfig::DEFAULT.with_check_interval(BringUpConfig::DEFAULT.check_window);
assert_eq!(
once.validate(),
Err(ConfigError {
check_reads_once: true,
..none
})
);
let zero = BringUpConfig::DEFAULT.with_check_interval(Duration::ZERO);
assert_eq!(
zero.validate(),
Err(ConfigError {
check_interval_zero: true,
..none
})
);
extern crate std;
use std::string::ToString;
assert_eq!(
late.validate().unwrap_err().to_string(),
"the scrambling deadline is not longer than the ratio wait"
);
let all = late
.with_check_window(Duration::ZERO)
.with_check_interval(Duration::ZERO)
.validate()
.unwrap_err();
assert_eq!(
all.to_string(),
"the scrambling deadline is not longer than the ratio wait; the check interval \
is not shorter than the check window; the check interval is 0"
);
assert_eq!(none.to_string(), "the bring-up settings are inconsistent");
}
#[test]
fn sink_presence_is_exhaustive() {
let gone = |p: SinkPresence| match p {
SinkPresence::Present => false,
SinkPresence::Gone => true,
};
assert!(gone(SinkPresence::Gone) && !gone(SinkPresence::Present));
}
}