use core::fmt;
use hdmi_hal::ddc::{DdcError, DdcErrorKind, NoAcknowledgeSource};
use super::Report;
use crate::bench::Bench;
use crate::fault::{Effect, Fault, Filter};
use crate::scdc::SCDC;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ScdcImage {
regs: [Option<u8>; 256],
}
impl ScdcImage {
pub const fn new() -> Self {
Self { regs: [None; 256] }
}
#[must_use]
pub const fn with(mut self, reg: u8, value: u8) -> Self {
self.regs[reg as usize] = Some(value);
self
}
pub fn of<const LOG: usize, const FAULTS: usize>(bench: &Bench<'_, LOG, FAULTS>) -> Self {
let sink = bench.sink();
let mut image = Self::new();
for reg in 0..=255u8 {
let moves = matches!(reg, 0x10 | 0x11 | 0x21 | 0x40..=0x42 | 0x50..=0x5A);
if !moves {
image.regs[usize::from(reg)] = sink.scdc(reg);
}
}
image
}
pub fn get(&self, reg: u8) -> Option<u8> {
self.regs[usize::from(reg)]
}
pub fn known(&self) -> usize {
self.regs.iter().flatten().count()
}
}
impl Default for ScdcImage {
fn default() -> Self {
Self::new()
}
}
pub trait FailNext {
fn fail_next(&self, kind: DdcErrorKind) -> bool;
fn withdraw(&self) {}
}
impl<const LOG: usize, const FAULTS: usize> FailNext for Bench<'_, LOG, FAULTS> {
fn fail_next(&self, kind: DdcErrorKind) -> bool {
self.arm(Fault::new(Effect::Fail(kind)).on(Filter::ANY.with_addr(SCDC)))
}
fn withdraw(&self) {
self.withdraw_armed();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ScdcOp {
Read,
ReadBlock,
Write,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ScdcTransportFailure {
Value {
op: ScdcOp,
reg: u8,
expected: u8,
found: u8,
},
Failed {
op: ScdcOp,
reg: u8,
kind: DdcErrorKind,
},
Hidden {
expected: DdcErrorKind,
found: Result<(), DdcErrorKind>,
},
NotArmed {
kind: DdcErrorKind,
},
}
impl fmt::Display for ScdcTransportFailure {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Value {
op,
reg,
expected,
found,
} => write!(
f,
"{op:?} of register {reg:#04x} gave {found:#04x}, not {expected:#04x}"
),
Self::Failed { op, reg, kind } => {
write!(f, "{op:?} at register {reg:#04x} failed: {kind:?}")
}
Self::Hidden { expected, found } => {
write!(f, "a transfer failed with {expected:?} came back {found:?}")
}
Self::NotArmed { kind } => write!(
f,
"could not make a transfer fail with {kind:?}: the setup, not the transport"
),
}
}
}
const RECOVERABLE: [DdcErrorKind; 3] = [
DdcErrorKind::NoAcknowledge(NoAcknowledgeSource::Data),
DdcErrorKind::Busy,
DdcErrorKind::Timeout,
];
#[derive(Clone, Copy)]
pub struct ScdcTransportCheck<'i> {
image: &'i ScdcImage,
faults: Option<&'i dyn FailNext>,
write: Option<(u8, u8)>,
}
impl<'i> ScdcTransportCheck<'i> {
pub const fn new(image: &'i ScdcImage) -> Self {
Self {
image,
faults: None,
write: None,
}
}
#[must_use]
pub const fn with_write(self, reg: u8, value: u8) -> Self {
Self {
write: Some((reg, value)),
..self
}
}
#[must_use]
pub const fn with_faults(self, faults: &'i dyn FailNext) -> Self {
Self {
faults: Some(faults),
..self
}
}
}
impl fmt::Debug for ScdcTransportCheck<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ScdcTransportCheck")
.field("known", &self.image.known())
.field("faults", &self.faults.is_some())
.field("write", &self.write)
.finish()
}
}
fn compare_block(
report: &mut Report<ScdcTransportFailure>,
image: &ScdcImage,
start: u8,
buf: &[u8],
) {
let mismatch = buf.iter().enumerate().find_map(|(i, &found)| {
let reg = start.wrapping_add(i as u8);
image
.get(reg)
.filter(|&expected| expected != found)
.map(|expected| ScdcTransportFailure::Value {
op: ScdcOp::ReadBlock,
reg,
expected,
found,
})
});
report.record(mismatch);
}
macro_rules! body {
($check:ident, $transport:ident, $($await:tt)*) => {{
let mut report = Report::new();
let image = $check.image;
for reg in 0..=255u8 {
let Some(expected) = image.get(reg) else { continue };
report.record(match $transport.read(reg) $($await)* {
Ok(found) if found == expected => None,
Ok(found) => Some(ScdcTransportFailure::Value {
op: ScdcOp::Read,
reg,
expected,
found,
}),
Err(error) => Some(ScdcTransportFailure::Failed {
op: ScdcOp::Read,
reg,
kind: error.kind(),
}),
});
}
let mut buf = [0u8; 16];
for start in 0..=0xF0u8 {
match $transport.read_block(start, &mut buf) $($await)* {
Ok(()) => compare_block(&mut report, image, start, &buf),
Err(error) => report.record(Some(ScdcTransportFailure::Failed {
op: ScdcOp::ReadBlock,
reg: start,
kind: error.kind(),
})),
}
}
for start in [0x00, 0x20, 0xFF] {
let result = $transport.read_block(start, &mut []) $($await)*;
report.record(result.err().map(|error| ScdcTransportFailure::Failed {
op: ScdcOp::ReadBlock,
reg: start,
kind: error.kind(),
}));
}
for (start, len) in [(0xF8u8, 16usize), (0xFF, 2)] {
let _ = $transport.read_block(start, &mut buf[..len]) $($await)*;
report.record(None);
}
if let Some((reg, value)) = $check.write {
let mut values = [Some(value), image.get(reg).filter(|&held| held != value)];
for value in values.iter_mut().filter_map(Option::take) {
match $transport.write(reg, value) $($await)* {
Err(error) => report.record(Some(ScdcTransportFailure::Failed {
op: ScdcOp::Write,
reg,
kind: error.kind(),
})),
Ok(()) => report.record(match $transport.read(reg) $($await)* {
Ok(found) if found == value => None,
Ok(found) => Some(ScdcTransportFailure::Value {
op: ScdcOp::Write,
reg,
expected: value,
found,
}),
Err(error) => Some(ScdcTransportFailure::Failed {
op: ScdcOp::Read,
reg,
kind: error.kind(),
}),
}),
}
}
}
let known = (0..=255u8).find_map(|reg| image.get(reg).map(|value| (reg, value)));
if let (Some(faults), Some((reg, value))) = ($check.faults, known) {
for kind in RECOVERABLE {
if !faults.fail_next(kind) {
report.record(Some(ScdcTransportFailure::NotArmed { kind }));
continue;
}
let found = $transport.read(reg) $($await)*;
faults.withdraw();
let found = found.map(|_| ()).map_err(|error| error.kind());
report.record((found != Err(kind)).then_some(ScdcTransportFailure::Hidden {
expected: kind,
found,
}));
report.record(match $transport.read(reg) $($await)* {
Ok(found) if found == value => None,
Ok(found) => Some(ScdcTransportFailure::Value {
op: ScdcOp::Read,
reg,
expected: value,
found,
}),
Err(error) => Some(ScdcTransportFailure::Failed {
op: ScdcOp::Read,
reg,
kind: error.kind(),
}),
});
}
}
report
}};
}
impl ScdcTransportCheck<'_> {
pub fn run<T>(&self, transport: &mut T) -> Report<ScdcTransportFailure>
where
T: hdmi_hal::scdc::ScdcTransport + ?Sized,
{
let check = self;
body!(check, transport,)
}
#[cfg(feature = "async")]
pub async fn run_async<T>(&self, transport: &mut T) -> Report<ScdcTransportFailure>
where
T: hdmi_hal_async::scdc::ScdcTransport + ?Sized,
{
let check = self;
body!(check, transport, .await)
}
}