use hdmi_hal::ddc::DdcError;
use crate::event::{TmdsEvent, TmdsEventKind, TmdsStep};
use crate::outcome::ReconnectCheck;
use crate::params::TmdsLinkParams;
use crate::types::SinkTmdsFacts;
use super::TmdsIo;
pub async fn check_reconnect<Io: TmdsIo, F: FnMut(TmdsEvent)>(
io: &mut Io,
link: &TmdsLinkParams,
current_sink: SinkTmdsFacts,
record: &mut F,
) -> ReconnectCheck<Io::ScdcError> {
let mut emit = |io: &Io, kind| record(TmdsEvent::new(io.now(), kind));
emit(
io,
TmdsEventKind::ReconnectCheckStarted {
link: *link,
current_sink,
},
);
let result = if !link.fits(current_sink) {
ReconnectCheck::SinkChanged
} else if let Some(expected) = link.sink_config() {
match io.read_tmds_config().await {
Ok(read) => {
emit(io, TmdsEventKind::TmdsConfigRead { reading: read });
if read.config == expected {
ReconnectCheck::Matches
} else {
ReconnectCheck::Lost { read }
}
}
Err(error) => {
emit(
io,
TmdsEventKind::ScdcStepFailed {
step: TmdsStep::ReadTmdsConfig,
kind: error.kind(),
ends: true,
},
);
ReconnectCheck::Unreadable(error)
}
}
} else {
ReconnectCheck::NotApplicable
};
emit(
io,
TmdsEventKind::ReconnectCheckEnded {
result: result.kinds(),
},
);
result
}
#[cfg(test)]
mod tests {
use hdmi_hal::ddc::DdcErrorKind;
use super::*;
use crate::MAX_RECONNECT_CHECK_EVENTS;
use crate::procedure::test_io::{Op, TestIo, block_on};
use crate::types::{SinkTmdsConfig, SourceTmdsFacts, TmdsPolicy};
const SINK: SinkTmdsFacts = SinkTmdsFacts::new(true, true, false);
fn link(rate_khz: u32, sink: SinkTmdsFacts) -> TmdsLinkParams {
TmdsLinkParams::choose(
rate_khz,
sink,
SourceTmdsFacts::new(false),
TmdsPolicy::DEFAULT,
)
.unwrap()
}
fn check(
io: &mut TestIo,
link: &TmdsLinkParams,
current: SinkTmdsFacts,
) -> (ReconnectCheck<DdcErrorKind>, usize, Option<TmdsEventKind>) {
let mut count = 0;
let mut last = None;
let result = block_on(check_reconnect(io, link, current, &mut |e| {
count += 1;
last = Some(e.kind);
}));
(result, count, last)
}
#[test]
fn a_sink_that_kept_its_config_matches() {
let mut io = TestIo::new();
io.tmds_config = 0x03;
let (result, count, last) = check(&mut io, &link(594_000, SINK), SINK);
assert_eq!(result, ReconnectCheck::Matches);
assert_eq!(io.ops(), [Op::ReadTmdsConfig]);
assert_eq!(count, MAX_RECONNECT_CHECK_EVENTS);
assert_eq!(
last,
Some(TmdsEventKind::ReconnectCheckEnded {
result: ReconnectCheck::Matches
})
);
}
#[test]
fn a_reset_sink_lost_its_config_and_the_bits_read_are_kept() {
let mut io = TestIo::new();
io.tmds_config = 0x80; let (result, ..) = check(&mut io, &link(594_000, SINK), SINK);
assert!(matches!(
result,
ReconnectCheck::Lost { read }
if read.config == SinkTmdsConfig::new(false, false) && read.raw == 0x80
));
}
#[test]
fn both_bits_are_compared() {
let mut io = TestIo::new();
io.tmds_config = 0x01; let (result, ..) = check(&mut io, &link(594_000, SINK), SINK);
assert!(matches!(result, ReconnectCheck::Lost { .. }));
}
#[test]
fn a_plain_link_expects_both_bits_clear() {
let plain = link(148_500, SINK);
let mut io = TestIo::new();
assert_eq!(check(&mut io, &plain, SINK).0, ReconnectCheck::Matches);
io.tmds_config = 0x03;
assert!(matches!(
check(&mut io, &plain, SINK).0,
ReconnectCheck::Lost { .. }
));
}
#[test]
fn a_failed_read_is_reported_not_acted_on() {
let mut io = TestIo::new();
io.fail_scdc = Some(DdcErrorKind::Detached);
let (result, count, _) = check(&mut io, &link(594_000, SINK), SINK);
assert_eq!(result, ReconnectCheck::Unreadable(DdcErrorKind::Detached));
assert_eq!(io.ops(), [Op::ReadTmdsConfig]);
assert_eq!(count, MAX_RECONNECT_CHECK_EVENTS);
let mut io = TestIo::new();
io.fail_scdc = Some(DdcErrorKind::Detached);
let mut ended = false;
block_on(check_reconnect(
&mut io,
&link(594_000, SINK),
SINK,
&mut |e| {
ended |= e.kind
== TmdsEventKind::ScdcStepFailed {
step: TmdsStep::ReadTmdsConfig,
kind: DdcErrorKind::Detached,
ends: true,
};
},
));
assert!(ended);
}
#[test]
fn changed_facts_or_no_scdc_read_nothing() {
let mut io = TestIo::new();
let other = SinkTmdsFacts::new(true, false, false);
let (result, count, _) = check(&mut io, &link(594_000, SINK), other);
assert_eq!(result, ReconnectCheck::SinkChanged);
assert_eq!(count, 2);
io.tmds_config = 0x03;
let frl_off = SINK.with_frl_capable(false);
assert_eq!(
check(&mut io, &link(594_000, SINK), frl_off).0,
ReconnectCheck::Matches
);
let lte = SinkTmdsFacts::new(true, true, true);
assert_eq!(
check(&mut io, &link(594_000, SINK), lte).0,
ReconnectCheck::Matches
);
let low = TmdsLinkParams::choose(
297_000,
lte,
SourceTmdsFacts::new(true),
TmdsPolicy::DEFAULT,
)
.unwrap();
assert!(low.scrambling());
assert_eq!(check(&mut io, &low, SINK).0, ReconnectCheck::SinkChanged);
io = TestIo::new();
let no_scdc = link(148_500, SinkTmdsFacts::NONE);
let (result, count, _) = check(&mut io, &no_scdc, SinkTmdsFacts::NONE);
assert_eq!(result, ReconnectCheck::NotApplicable);
assert_eq!(count, 2);
assert_eq!(io.ops().len(), 0);
}
}