use crate::ddc::{DdcBus, DdcError, DdcHandle, SCDC};
pub trait ScdcTransport {
type Error: DdcError;
fn read(&self, reg: u8) -> Result<u8, Self::Error>;
fn write(&mut self, reg: u8, value: u8) -> Result<(), Self::Error>;
fn read_block(&self, reg: u8, buf: &mut [u8]) -> Result<(), Self::Error>;
}
pub fn read_block_bytewise<T: ScdcTransport + ?Sized>(
transport: &T,
reg: u8,
buf: &mut [u8],
) -> Result<(), T::Error> {
let mut addr = reg;
for byte in buf {
*byte = transport.read(addr)?;
addr = addr.wrapping_add(1);
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ScdcOverDdc<H> {
bus: H,
bytewise: bool,
}
impl<H: DdcHandle> ScdcOverDdc<H> {
pub fn new(bus: H) -> Result<Self, H> {
Self::checked(bus, 16, false)
}
pub fn bytewise(bus: H) -> Result<Self, H> {
Self::checked(bus, 1, true)
}
fn checked(bus: H, min_read: u16, bytewise: bool) -> Result<Self, H> {
let caps = bus.bus().capabilities();
let (write_part, read_part) = caps.write_read_max();
if caps.reaches(SCDC) && caps.write_max() >= 2 && write_part >= 1 && read_part >= min_read {
Ok(ScdcOverDdc { bus, bytewise })
} else {
Err(bus)
}
}
pub fn is_bytewise(&self) -> bool {
self.bytewise
}
pub fn into_inner(self) -> H {
self.bus
}
}
impl<H: DdcHandle> ScdcTransport for ScdcOverDdc<H> {
type Error = <H::Bus as DdcBus>::Error;
fn read(&self, reg: u8) -> Result<u8, Self::Error> {
let mut value = [0u8];
self.bus.bus().write_read(SCDC, &[reg], &mut value)?;
Ok(value[0])
}
fn write(&mut self, reg: u8, value: u8) -> Result<(), Self::Error> {
self.bus.bus().write(SCDC, &[reg, value])
}
fn read_block(&self, reg: u8, buf: &mut [u8]) -> Result<(), Self::Error> {
if self.bytewise {
read_block_bytewise(self, reg, buf)
} else {
self.bus.bus().write_read(SCDC, &[reg], buf)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use core::cell::Cell;
use core::ops::Deref;
#[derive(Debug, PartialEq)]
struct Fail(u8);
impl DdcError for Fail {
fn kind(&self) -> crate::ddc::DdcErrorKind {
crate::ddc::DdcErrorKind::Other
}
}
struct MockTransport {
registers: [u8; 256],
reads: Cell<u32>,
fail_at: Option<u8>,
}
impl MockTransport {
fn new() -> Self {
let mut registers = [0u8; 256];
for (i, r) in registers.iter_mut().enumerate() {
*r = i as u8;
}
Self {
registers,
reads: Cell::new(0),
fail_at: None,
}
}
}
impl ScdcTransport for MockTransport {
type Error = Fail;
fn read(&self, reg: u8) -> Result<u8, Self::Error> {
if self.fail_at == Some(reg) {
return Err(Fail(reg));
}
self.reads.set(self.reads.get() + 1);
Ok(self.registers[reg as usize])
}
fn write(&mut self, reg: u8, value: u8) -> Result<(), Self::Error> {
self.registers[reg as usize] = value;
Ok(())
}
fn read_block(&self, reg: u8, buf: &mut [u8]) -> Result<(), Self::Error> {
read_block_bytewise(self, reg, buf)
}
}
#[test]
fn bytewise_reads_consecutive_registers() {
let t = MockTransport::new();
let mut buf = [0u8; 3];
t.read_block(0x40, &mut buf).unwrap();
assert_eq!(buf, [0x40, 0x41, 0x42]);
assert_eq!(t.reads.get(), 3);
}
#[test]
fn bytewise_empty_buffer_reads_nothing() {
let t = MockTransport::new();
t.read_block(0x40, &mut []).unwrap();
assert_eq!(t.reads.get(), 0);
}
#[test]
fn bytewise_stops_at_first_error() {
let mut t = MockTransport::new();
t.fail_at = Some(0x41);
let mut buf = [0u8; 3];
assert_eq!(t.read_block(0x40, &mut buf), Err(Fail(0x41)));
assert_eq!(buf, [0x40, 0x00, 0x00]);
assert_eq!(t.reads.get(), 1);
}
#[test]
fn bytewise_wraps_past_0xff() {
let t = MockTransport::new();
let mut buf = [0u8; 2];
t.read_block(0xFF, &mut buf).unwrap();
assert_eq!(buf, [0xFF, 0x00]);
}
#[test]
fn write_then_read_block() {
let mut t = MockTransport::new();
t.write(0x20, 0xAB).unwrap();
let mut buf = [0u8; 1];
t.read_block(0x20, &mut buf).unwrap();
assert_eq!(buf, [0xAB]);
}
#[test]
fn bytewise_through_a_trait_object() {
let t = MockTransport::new();
let dyn_t: &dyn ScdcTransport<Error = Fail> = &t;
let mut buf = [0u8; 2];
read_block_bytewise(dyn_t, 0x50, &mut buf).unwrap();
assert_eq!(buf, [0x50, 0x51]);
}
use crate::ddc::{DdcCapabilities, DdcErrorKind, EddcTarget};
struct Bus {
caps: DdcCapabilities,
registers: [Cell<u8>; 256],
writes: Cell<u32>,
write_reads: Cell<u32>,
last_addr: Cell<u8>,
fail: Option<DdcErrorKind>,
}
impl Bus {
fn with(caps: DdcCapabilities) -> Self {
Bus {
caps,
registers: core::array::from_fn(|i| Cell::new(i as u8)),
writes: Cell::new(0),
write_reads: Cell::new(0),
last_addr: Cell::new(0),
fail: None,
}
}
fn scdc(read_limit: u16) -> Self {
Self::with(
DdcCapabilities::none()
.with_address_reachable(SCDC, true)
.with_write_max(2)
.with_write_read_max(1, read_limit),
)
}
}
impl DdcBus for Bus {
type Error = DdcErrorKind;
fn capabilities(&self) -> DdcCapabilities {
self.caps
}
fn write(&self, addr: u8, bytes: &[u8]) -> Result<(), DdcErrorKind> {
if let Some(kind) = self.fail {
return Err(kind);
}
self.last_addr.set(addr);
self.writes.set(self.writes.get() + 1);
self.registers[usize::from(bytes[0])].set(bytes[1]);
Ok(())
}
fn write_read(&self, addr: u8, bytes: &[u8], buf: &mut [u8]) -> Result<(), DdcErrorKind> {
if buf.is_empty() {
return Ok(());
}
if let Some(kind) = self.fail {
return Err(kind);
}
if buf.len() > usize::from(self.caps.write_read_max().1) {
return Err(DdcErrorKind::Unsupported);
}
self.last_addr.set(addr);
self.write_reads.set(self.write_reads.get() + 1);
for (i, b) in buf.iter_mut().enumerate() {
*b = self.registers[usize::from(bytes[0].wrapping_add(i as u8))].get();
}
Ok(())
}
fn read(&self, _addr: u8, _buf: &mut [u8]) -> Result<(), DdcErrorKind> {
Err(DdcErrorKind::Unsupported)
}
fn read_segmented(
&self,
_target: EddcTarget,
_segment: u8,
_offset: u8,
_buf: &mut [u8],
) -> Result<(), DdcErrorKind> {
Err(DdcErrorKind::Unsupported)
}
}
#[test]
fn over_ddc_reads_and_writes_at_0x54_in_one_transaction_each() {
let bus = Bus::scdc(32);
let mut scdc = ScdcOverDdc::new(&bus).ok().unwrap();
assert!(!scdc.is_bytewise());
scdc.write(0x20, 0x03).unwrap();
assert_eq!((bus.writes.get(), bus.last_addr.get()), (1, SCDC));
assert_eq!(scdc.read(0x20), Ok(0x03));
let mut ced = [0u8; 7];
scdc.read_block(0x50, &mut ced).unwrap();
assert_eq!(ced, [0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56]);
assert_eq!(bus.write_reads.get(), 2);
}
#[test]
fn over_ddc_empty_block_read_touches_nothing() {
let bus = Bus::scdc(32);
let scdc = ScdcOverDdc::new(&bus).ok().unwrap();
scdc.read_block(0x50, &mut []).unwrap();
assert_eq!(bus.write_reads.get(), 0);
}
#[test]
fn over_ddc_leaves_reads_beyond_the_bus_limit_to_the_bus() {
let bus = Bus::scdc(16);
let scdc = ScdcOverDdc::new(&bus).ok().unwrap();
let mut long = [0u8; 17];
assert_eq!(
scdc.read_block(0x00, &mut long),
Err(DdcErrorKind::Unsupported)
);
}
#[test]
fn over_ddc_passes_bus_errors_through() {
let mut bus = Bus::scdc(32);
bus.fail = Some(DdcErrorKind::Timeout);
let mut scdc = ScdcOverDdc::new(&bus).ok().unwrap();
assert_eq!(scdc.read(0x21), Err(DdcErrorKind::Timeout));
assert_eq!(scdc.write(0x30, 0x01), Err(DdcErrorKind::Timeout));
}
#[test]
fn over_ddc_refuses_a_bus_that_cannot_serve_scdc() {
let bus = Bus::with(DdcCapabilities::general().with_address_reachable(SCDC, false));
assert!(ScdcOverDdc::new(&bus).is_err());
assert!(ScdcOverDdc::bytewise(&bus).is_err());
let bus = Bus::with(DdcCapabilities::general().with_write_max(1));
assert!(ScdcOverDdc::new(&bus).is_err());
let bus = Bus::with(DdcCapabilities::general().with_write_read_max(0, 32));
assert!(ScdcOverDdc::new(&bus).is_err());
let bus = Bus::scdc(15);
assert!(ScdcOverDdc::new(&bus).is_err());
assert!(ScdcOverDdc::bytewise(&bus).is_ok());
let bus = Bus::scdc(0);
assert!(ScdcOverDdc::bytewise(&bus).is_err());
}
#[test]
fn over_ddc_hands_the_handle_back() {
let bus = Bus::scdc(1);
let refused = ScdcOverDdc::new(&bus).err().unwrap();
assert!(core::ptr::eq(refused, &bus));
let scdc = ScdcOverDdc::bytewise(&bus).ok().unwrap();
assert!(core::ptr::eq(scdc.into_inner(), &bus));
}
#[test]
fn over_ddc_bytewise_reads_one_register_per_transaction() {
let bus = Bus::scdc(1);
let scdc = ScdcOverDdc::bytewise(&bus).ok().unwrap();
assert!(scdc.is_bytewise());
let mut buf = [0u8; 3];
scdc.read_block(0x40, &mut buf).unwrap();
assert_eq!(buf, [0x40, 0x41, 0x42]);
assert_eq!(bus.write_reads.get(), 3);
}
struct Handle<'a>(&'a Bus);
impl Deref for Handle<'_> {
type Target = Bus;
fn deref(&self) -> &Bus {
self.0
}
}
#[test]
fn over_ddc_needs_no_plain_or_segmented_reads() {
let bus = Bus::scdc(32);
let mut buf = [0u8; 1];
assert_eq!(bus.read(SCDC, &mut buf), Err(DdcErrorKind::Unsupported));
assert_eq!(
bus.read_segmented(EddcTarget::Edid, 0, 0, &mut buf),
Err(DdcErrorKind::Unsupported)
);
assert_eq!(Fail(0).kind(), DdcErrorKind::Other);
}
#[test]
fn over_ddc_takes_any_handle() {
let bus = Bus::scdc(32);
let scdc = ScdcOverDdc::new(Handle(&bus)).ok().unwrap();
assert_eq!(scdc.read(0x07), Ok(0x07));
}
#[derive(Clone, Copy)]
struct View<'a>(&'a Bus);
impl DdcBus for View<'_> {
type Error = DdcErrorKind;
fn capabilities(&self) -> crate::ddc::DdcCapabilities {
self.0.capabilities()
}
fn write(&self, addr: u8, bytes: &[u8]) -> Result<(), DdcErrorKind> {
self.0.write(addr, bytes)
}
fn write_read(&self, addr: u8, bytes: &[u8], buf: &mut [u8]) -> Result<(), DdcErrorKind> {
self.0.write_read(addr, bytes, buf)
}
fn read(&self, addr: u8, buf: &mut [u8]) -> Result<(), DdcErrorKind> {
self.0.read(addr, buf)
}
fn read_segmented(
&self,
target: EddcTarget,
segment: u8,
offset: u8,
buf: &mut [u8],
) -> Result<(), DdcErrorKind> {
self.0.read_segmented(target, segment, offset, buf)
}
}
impl DdcHandle for View<'_> {
type Bus = Self;
fn bus(&self) -> &Self {
self
}
}
#[test]
fn over_ddc_takes_a_copy_handle_by_value() {
let bus = Bus::scdc(32);
let view = View(&bus);
let scdc = ScdcOverDdc::new(view).ok().unwrap();
assert_eq!(scdc.read(0x07), Ok(0x07));
assert_eq!(view.capabilities(), bus.capabilities());
assert_eq!(
view.write(SCDC, &[0x30, 0x01]),
bus.write(SCDC, &[0x30, 0x01])
);
let (mut through_view, mut direct) = ([0u8; 1], [0u8; 1]);
assert_eq!(
view.read(SCDC, &mut through_view),
bus.read(SCDC, &mut direct)
);
assert_eq!(
view.read_segmented(EddcTarget::Edid, 0, 0, &mut through_view),
bus.read_segmented(EddcTarget::Edid, 0, 0, &mut direct)
);
assert_eq!(through_view, direct);
}
}