use core::fmt;
use hdmi_hal::ddc::{
DdcBus, DdcCapabilities, DdcError, DdcErrorKind, EDID, EddcTarget, MAX_SEGMENT,
is_usable_address,
};
use super::Report;
use crate::fault::OpKind;
const UNUSABLE: u8 = 0x7F;
const MAX_LEN: usize = 512;
static ZEROS: [u8; MAX_LEN] = [0; MAX_LEN];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct DdcDevice<'d> {
pub edid: Option<&'d [u8]>,
pub segment_pointer: bool,
pub silent: Option<u8>,
}
impl<'d> DdcDevice<'d> {
pub const fn new() -> Self {
Self {
edid: None,
segment_pointer: true,
silent: None,
}
}
#[must_use]
pub const fn with_edid(self, edid: &'d [u8]) -> Self {
Self {
edid: Some(edid),
..self
}
}
#[must_use]
pub const fn without_segment_pointer(self) -> Self {
Self {
segment_pointer: false,
..self
}
}
#[must_use]
pub const fn with_silent(self, addr: u8) -> Self {
Self {
silent: Some(addr),
..self
}
}
}
impl Default for DdcDevice<'_> {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum DdcBusFailure {
NotRefused {
op: OpKind,
addr: u8,
found: Result<(), DdcErrorKind>,
},
Failed {
op: OpKind,
addr: u8,
kind: DdcErrorKind,
},
Answered {
op: OpKind,
addr: u8,
found: Result<(), DdcErrorKind>,
},
Data {
segment: u8,
offset: u8,
expected: u8,
found: u8,
},
Panicked,
}
impl fmt::Display for DdcBusFailure {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NotRefused { op, addr, found } => {
write!(f, "{op:?} at {addr:#04x} was not refused: {found:?}")
}
Self::Failed { op, addr, kind } => write!(f, "{op:?} at {addr:#04x} failed: {kind:?}"),
Self::Answered { op, addr, found } => write!(
f,
"{op:?} at {addr:#04x}, where nothing answers, ended {found:?}"
),
Self::Data {
segment,
offset,
expected,
found,
} => write!(
f,
"EDID segment {segment} byte {offset:#04x} read {found:#04x}, not {expected:#04x}"
),
Self::Panicked => f.write_str("a thread panicked"),
}
}
}
#[derive(Debug, Clone, Copy)]
enum Call {
Write {
addr: u8,
len: usize,
},
WriteRead {
addr: u8,
write: usize,
read: usize,
},
Read {
addr: u8,
len: usize,
},
Segmented {
target: EddcTarget,
segment: u8,
offset: u8,
len: usize,
},
SetOffset {
addr: u8,
offset: u8,
},
ReadAt {
addr: u8,
offset: u8,
len: usize,
},
}
impl Call {
fn op(self) -> OpKind {
match self {
Self::Write { .. } | Self::SetOffset { .. } => OpKind::Write,
Self::WriteRead { .. } | Self::ReadAt { .. } => OpKind::WriteRead,
Self::Read { .. } => OpKind::Read,
Self::Segmented { .. } => OpKind::ReadSegmented,
}
}
fn addr(self) -> u8 {
match self {
Self::Write { addr, .. }
| Self::WriteRead { addr, .. }
| Self::Read { addr, .. }
| Self::SetOffset { addr, .. }
| Self::ReadAt { addr, .. } => addr,
Self::Segmented { target, .. } => target.address(),
}
}
}
#[derive(Debug, Clone, Copy)]
enum Expect<'d> {
Ok,
Refused,
Silent,
Data {
segment: u8,
offset: u8,
bytes: &'d [u8],
},
}
const PLAN: usize = 32;
type Point<'d> = (Call, Expect<'d>, bool);
struct Plan<'d> {
points: [Option<Point<'d>>; PLAN],
len: usize,
}
impl<'d> Plan<'d> {
fn push(&mut self, call: Call, expect: Expect<'d>) {
self.push_point((call, expect, false));
}
fn push_sequenced(&mut self, call: Call, expect: Expect<'d>) {
self.push_point((call, expect, true));
}
fn push_point(&mut self, point: Point<'d>) {
if let Some(slot) = self.points.get_mut(self.len) {
*slot = Some(point);
self.len += 1;
}
}
fn iter(&self, concurrent: bool) -> impl Iterator<Item = (Call, Expect<'d>)> + '_ {
self.points[..self.len]
.iter()
.flatten()
.filter(move |&&(_, _, sequenced)| !(concurrent && sequenced))
.map(|&(call, expect, _)| (call, expect))
}
fn new(device: &DdcDevice<'d>, caps: DdcCapabilities) -> Self {
let mut plan = Self {
points: [None; PLAN],
len: 0,
};
let some = |len: u16| usize::from(len) < MAX_LEN;
if !is_usable_address(UNUSABLE) {
plan.push(
Call::Read {
addr: UNUSABLE,
len: 1,
},
Expect::Refused,
);
}
let quiet = device.silent.unwrap_or(EDID);
plan.push(
Call::Write {
addr: quiet,
len: 0,
},
Expect::Refused,
);
plan.push(Call::Read { addr: EDID, len: 0 }, Expect::Ok);
plan.push(
Call::WriteRead {
addr: EDID,
write: 1,
read: 0,
},
Expect::Ok,
);
let segmented = |segment, offset, len| Call::Segmented {
target: EddcTarget::Edid,
segment,
offset,
len,
};
plan.push(segmented(0, 0, 0), Expect::Ok);
plan.push(segmented(MAX_SEGMENT + 1, 0, 1), Expect::Refused);
plan.push(segmented(0, 0xFF, 2), Expect::Refused);
if let Some(addr) = (0x08..=0x77).find(|&addr| !caps.reaches(addr)) {
plan.push(Call::Read { addr, len: 1 }, Expect::Refused);
}
if caps.reaches(EDID) && some(caps.read_max()) {
let len = usize::from(caps.read_max()) + 1;
plan.push(Call::Read { addr: EDID, len }, Expect::Refused);
}
let (write_part, read_part) = caps.write_read_max();
if caps.reaches(EDID) && some(read_part) {
let read = usize::from(read_part) + 1;
plan.push(
Call::WriteRead {
addr: EDID,
write: 1,
read,
},
Expect::Refused,
);
}
if let Some(silent) = device.silent.filter(|&addr| caps.reaches(addr)) {
if some(write_part) {
let write = usize::from(write_part) + 1;
plan.push(
Call::WriteRead {
addr: silent,
write,
read: 1,
},
Expect::Refused,
);
}
if some(caps.write_max()) {
let len = usize::from(caps.write_max()) + 1;
plan.push(Call::Write { addr: silent, len }, Expect::Refused);
}
}
for target in [EddcTarget::Edid, EddcTarget::DisplayId] {
if !caps.reads_target(target) {
plan.push(
Call::Segmented {
target,
segment: 0,
offset: 0,
len: 1,
},
Expect::Refused,
);
}
}
match caps.max_segment() {
None => plan.push(segmented(0, 0, 1), Expect::Refused),
Some(max) if max < MAX_SEGMENT => {
plan.push(segmented(max + 1, 0, 1), Expect::Refused);
}
Some(_) => {}
}
if let Some(edid) = device.edid {
let data = |segment, offset: u8, len: usize| {
let start = usize::from(segment) * 256 + usize::from(offset);
let bytes = edid.get(start..start + len)?;
Some(Expect::Data {
segment,
offset,
bytes,
})
};
if caps.reads_target(EddcTarget::Edid) && caps.max_segment().is_some() {
let first = &edid[..edid.len().min(128)];
if !first.is_empty() {
plan.push(
segmented(0, 0, first.len()),
Expect::Data {
segment: 0,
offset: 0,
bytes: first,
},
);
}
for (offset, len) in [(128, 128), (0x11, 16)] {
if let Some(expect) = data(0, offset, len) {
plan.push(segmented(0, offset, len), expect);
}
}
let reaches_1 = caps.max_segment().is_some_and(|max| max >= 1);
if device.segment_pointer && reaches_1 && edid.len() > 256 {
let block = &edid[256..edid.len().min(384)];
plan.push(
segmented(1, 0, block.len()),
Expect::Data {
segment: 1,
offset: 0,
bytes: block,
},
);
}
}
let (write_part, read_part) = caps.write_read_max();
if caps.reaches(EDID) && write_part >= 1 && read_part >= 16 {
if let Some(expect) = data(0, 0x20, 16) {
plan.push(
Call::ReadAt {
addr: EDID,
offset: 0x20,
len: 16,
},
expect,
);
}
}
if caps.reaches(EDID) && caps.write_max() >= 1 && caps.read_max() >= 16 {
if let Some(expect) = data(0, 0x40, 16) {
plan.push(
Call::SetOffset {
addr: EDID,
offset: 0x40,
},
Expect::Ok,
);
plan.push_sequenced(
Call::Read {
addr: EDID,
len: 16,
},
expect,
);
}
}
}
if let Some(silent) = device.silent.filter(|&addr| caps.reaches(addr)) {
if caps.read_max() >= 1 {
plan.push(
Call::Read {
addr: silent,
len: 1,
},
Expect::Silent,
);
}
if caps.write_max() >= 1 {
plan.push(
Call::Write {
addr: silent,
len: 1,
},
Expect::Silent,
);
}
}
plan
}
}
fn judge(
call: Call,
expect: Expect<'_>,
result: Result<(), DdcErrorKind>,
read: &[u8],
) -> Option<DdcBusFailure> {
let (op, addr) = (call.op(), call.addr());
match expect {
Expect::Ok => result
.err()
.map(|kind| DdcBusFailure::Failed { op, addr, kind }),
Expect::Refused => {
(result != Err(DdcErrorKind::Unsupported)).then_some(DdcBusFailure::NotRefused {
op,
addr,
found: result,
})
}
Expect::Silent => (!matches!(result, Err(DdcErrorKind::NoAcknowledge(_)))).then_some(
DdcBusFailure::Answered {
op,
addr,
found: result,
},
),
Expect::Data {
segment,
offset,
bytes,
} => match result {
Err(kind) => Some(DdcBusFailure::Failed { op, addr, kind }),
Ok(()) => bytes
.iter()
.zip(read)
.position(|(expected, found)| expected != found)
.map(|i| DdcBusFailure::Data {
segment,
offset: offset.wrapping_add(i as u8),
expected: bytes[i],
found: read[i],
}),
},
}
}
fn call<B: DdcBus + ?Sized>(
bus: &B,
call: Call,
buf: &mut [u8; MAX_LEN],
) -> (Result<(), DdcErrorKind>, usize) {
let kind = |result: Result<(), B::Error>| result.map_err(|error| error.kind());
match call {
Call::Write { addr, len } => (kind(bus.write(addr, &ZEROS[..len])), 0),
Call::WriteRead { addr, write, read } => (
kind(bus.write_read(addr, &ZEROS[..write], &mut buf[..read])),
read,
),
Call::Read { addr, len } => (kind(bus.read(addr, &mut buf[..len])), len),
Call::Segmented {
target,
segment,
offset,
len,
} => (
kind(bus.read_segmented(target, segment, offset, &mut buf[..len])),
len,
),
Call::SetOffset { addr, offset } => (kind(bus.write(addr, &[offset])), 0),
Call::ReadAt { addr, offset, len } => {
(kind(bus.write_read(addr, &[offset], &mut buf[..len])), len)
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DdcBusCheck<'d> {
device: DdcDevice<'d>,
}
impl<'d> DdcBusCheck<'d> {
pub const fn new(device: DdcDevice<'d>) -> Self {
Self { device }
}
pub fn run<B: DdcBus + ?Sized>(&self, bus: &B) -> Report<DdcBusFailure> {
self.run_points(bus, false)
}
fn run_points<B: DdcBus + ?Sized>(&self, bus: &B, concurrent: bool) -> Report<DdcBusFailure> {
let mut report = Report::new();
let plan = Plan::new(&self.device, bus.capabilities());
let mut buf = [0u8; MAX_LEN];
for (point, expect) in plan.iter(concurrent) {
let (result, read) = call(bus, point, &mut buf);
report.record(judge(point, expect, result, &buf[..read]));
}
report
}
#[cfg(feature = "std")]
pub fn run_threads<B: DdcBus + Sync + ?Sized>(
&self,
bus: &B,
threads: usize,
) -> Report<DdcBusFailure> {
assert!(threads > 0, "run_threads needs at least one thread");
let mut report = Report::new();
std::thread::scope(|scope| {
let handles: std::vec::Vec<_> = (0..threads)
.map(|_| scope.spawn(|| self.run_points(bus, true)))
.collect();
for handle in handles {
match handle.join() {
Ok(thread) => report.absorb(thread),
Err(_) => report.record(Some(DdcBusFailure::Panicked)),
}
}
});
report
}
#[cfg(feature = "async")]
pub async fn run_async<B>(&self, bus: &B) -> Report<DdcBusFailure>
where
B: hdmi_hal_async::ddc::DdcBus + ?Sized,
{
let mut report = Report::new();
let plan = Plan::new(&self.device, bus.capabilities());
let mut buf = [0u8; MAX_LEN];
for (point, expect) in plan.iter(false) {
let kind = |result: Result<(), B::Error>| result.map_err(|error| error.kind());
let (result, read) = match point {
Call::Write { addr, len } => (kind(bus.write(addr, &ZEROS[..len]).await), 0),
Call::WriteRead { addr, write, read } => (
kind(
bus.write_read(addr, &ZEROS[..write], &mut buf[..read])
.await,
),
read,
),
Call::Read { addr, len } => (kind(bus.read(addr, &mut buf[..len]).await), len),
Call::Segmented {
target,
segment,
offset,
len,
} => (
kind(
bus.read_segmented(target, segment, offset, &mut buf[..len])
.await,
),
len,
),
Call::SetOffset { addr, offset } => (kind(bus.write(addr, &[offset]).await), 0),
Call::ReadAt { addr, offset, len } => (
kind(bus.write_read(addr, &[offset], &mut buf[..len]).await),
len,
),
};
report.record(judge(point, expect, result, &buf[..read]));
}
report
}
}