use core::time::Duration;
use hdmi_hal::ddc::{DdcErrorKind, NoAcknowledgeSource};
use hdmi_hal::phy::TmdsClockRatio;
use hdmi_hal::time::Timestamp;
use crate::config::{
CedRead, CedUpdate, DuringHpdLow, DuringRead, FrlPass, HpdReset, OwnedWrite, Refusal,
RefusalKind, RegisterGroup, ScdcPastEnd, SinkConfig, StatusUpdate, Trigger,
};
use crate::hook::{HookWrite, ScdcHook, ScdcRegisters};
use crate::line::{ErrorRates, Line, LinkLanes, RATIO_40_ABOVE_KHZ};
use crate::target::{Env, Operation, Target};
use crate::transcript::{Actor, Event, Ignored};
use hdmi_hal::HdmiForumFrl;
use hdmi_hal::phy::{EqParams, LanePatterns, LtpPattern, TxFfeLevel};
const SCRAMBLING_ENABLE: u8 = 1 << 0;
const RATIO_40: u8 = 1 << 1;
const STATUS: u8 = 1 << 0;
const STATUS_UPDATE: u8 = 1 << 0;
const CED_UPDATE: u8 = 1 << 1;
const CED_CHECK: Duration = Duration::from_secs(1);
const CLOCK_DETECTED: u8 = 1 << 0;
const LANES_LOCKED: u8 = 0b1110;
const FOUR_LANES_LOCKED: u8 = 0b1_1110;
const FLT_READY: u8 = 1 << 6;
const FRL_START: u8 = 1 << 4;
const FLT_UPDATE: u8 = 1 << 5;
const LTP_REQ_01: u8 = 0x41;
const LTP_REQ_23: u8 = 0x42;
const LTP_RATE_CHANGE: u8 = 0xF;
const LTP_FFE_CHANGE: u8 = 0xE;
const FLT_CLEAR_WAIT: Duration = Duration::from_millis(100);
const FFE_LEVELS_MAX: u8 = 3;
const FLT_NO_TIMEOUT: u8 = 1 << 5;
const FLT_NO_RETRAIN: u8 = 1 << 1;
const FRL_RATE_MAX: u8 = 6;
const FRL_3_LANES_MAX: u8 = 2;
const RATIO_RESUME_MIN: Duration = Duration::from_millis(1);
pub(crate) const SCDC: u8 = 0x54;
pub(crate) const SINK_VERSION: u8 = 0x01;
pub(crate) const SOURCE_VERSION: u8 = 0x02;
pub(crate) const UPDATE_0: u8 = 0x10;
pub(crate) const UPDATE_1: u8 = 0x11;
pub(crate) const TMDS_CONFIG: u8 = 0x20;
pub(crate) const SCRAMBLING_STATUS: u8 = 0x21;
pub(crate) const CONFIG_0: u8 = 0x30;
pub(crate) const CONFIG_1: u8 = 0x31;
const SOURCE_TEST_CONFIGURATION: u8 = 0x35;
const CED: u8 = 0x50;
const CED_CHECKSUM: u8 = 0x56;
const CED_LAST: u8 = 0x5A;
const COUNTERS: [u8; 5] = [0x50, 0x52, 0x54, 0x57, 0x59];
const RS: usize = 4;
const RSED_UPDATE: u8 = 1 << 6;
const CED_VALID: u8 = 1 << 7;
const CED_MAX: u64 = 0x7FFF;
const CED_UNIT: u64 = 1_000_000;
pub(crate) const STATUS_FLAGS_0: u8 = 0x40;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Role {
Source,
WriteOneToClear,
Sink,
}
fn role(reg: u8) -> Role {
match reg {
UPDATE_0 | UPDATE_1 => Role::WriteOneToClear,
SINK_VERSION
| SCRAMBLING_STATUS
| SOURCE_TEST_CONFIGURATION
| 0x40..=0x42
| 0x50..=0x5A
| 0xD0..=0xDD => Role::Sink,
_ => Role::Source,
}
}
#[derive(Debug)]
pub(crate) struct Scdc {
regs: [u8; 256],
offset: u8,
owned_write: OwnedWrite,
past_end: ScdcPastEnd,
during_hpd_low: DuringHpdLow,
trigger: Trigger,
strict: bool,
refusal: Refusal,
enable_timeout: Option<Duration>,
line: Line,
line_since: Timestamp,
armed_at: Option<Timestamp>,
ratio_at: Option<Timestamp>,
seen_since_enable: bool,
attempts: u32,
withheld: bool,
lock_from: Option<Timestamp>,
reads: u32,
locked: bool,
hpd_resets: [HpdReset; RegisterGroup::COUNT],
status_update: StatusUpdate,
lanes_from: Option<Timestamp>,
flag_reads: u32,
flags: u8,
ced: [u64; 5],
counted_to: Timestamp,
errors: ErrorRates,
ced_shown: [u8; 11],
ced_update: CedUpdate,
ced_read: CedRead,
during_read: DuringRead,
checked_at: Timestamp,
pending_update: u8,
ced_checked: [u64; 5],
max_frl: u8,
ltp_requests: [u8; 4],
training: Training,
flt_ready_shown: bool,
match_from: Option<Timestamp>,
match_reads: u32,
wanted: [u8; 4],
lts3_timeout: Option<Duration>,
lts3_from: Timestamp,
timeouts: u32,
ffe_levels: u8,
lanes_seen: LinkLanes,
max_tmds_rate_khz: Option<u32>,
frl_pass: FrlPass,
update_set_at: Timestamp,
hpd_low_since: Option<Timestamp>,
reset_done: [bool; RegisterGroup::COUNT],
}
impl Scdc {
pub(crate) fn new(config: &SinkConfig) -> Option<Self> {
if !config.scdc {
return None;
}
let mut regs = [0; 256];
regs[usize::from(SINK_VERSION)] = config.sink_version;
let max_frl = config.max_frl_rate.map_or(0, frl_value);
if max_frl != 0 {
regs[usize::from(STATUS_FLAGS_0)] = FLT_READY;
}
Some(Self {
regs,
offset: 0,
owned_write: config.owned_scdc_write,
past_end: config.scdc_past_end,
during_hpd_low: config.scdc_during_hpd_low,
trigger: config.scrambling_lock,
strict: config.strict_lock,
refusal: config.refusal,
enable_timeout: config.enable_timeout,
line: Line::Off,
line_since: Timestamp::from_micros(0),
armed_at: None,
ratio_at: None,
seen_since_enable: false,
attempts: 0,
withheld: false,
lock_from: None,
reads: 0,
locked: false,
hpd_resets: config.hpd_resets,
status_update: config.status_update,
lanes_from: None,
flag_reads: 0,
flags: 0,
ced: [0; 5],
counted_to: Timestamp::from_micros(0),
errors: ErrorRates::NONE,
ced_shown: [0; 11],
ced_update: config.ced_update,
ced_read: config.ced_read,
during_read: config.during_read,
checked_at: Timestamp::from_micros(0),
pending_update: 0,
ced_checked: [0; 5],
max_frl,
ltp_requests: {
let lanes = config.ltp_requests;
[lanes.lane0, lanes.lane1, lanes.lane2, lanes.lane3]
.map(|pattern| pattern.map_or(0, LtpPattern::value))
},
training: Training::Legacy,
flt_ready_shown: max_frl != 0,
match_from: None,
match_reads: 0,
wanted: [0; 4],
lts3_timeout: config.lts3_timeout,
lts3_from: Timestamp::from_micros(0),
timeouts: 0,
ffe_levels: 0,
lanes_seen: LinkLanes::NONE,
frl_pass: config.frl_pass,
max_tmds_rate_khz: config.max_tmds_rate_khz,
update_set_at: Timestamp::from_micros(0),
hpd_low_since: None,
reset_done: [false; RegisterGroup::COUNT],
})
}
pub(crate) fn get(&self, reg: u8) -> u8 {
self.regs[usize::from(reg)]
}
pub(crate) fn preset(&mut self, reg: u8, value: u8, env: &mut Env<'_>) {
self.set(reg, value, Actor::Test, env);
}
fn set(&mut self, reg: u8, to: u8, by: Actor, env: &mut Env<'_>) {
let from = self.regs[usize::from(reg)];
self.regs[usize::from(reg)] = to;
env.record(Event::Register {
addr: SCDC,
reg,
from,
to,
by,
});
if reg == TMDS_CONFIG {
let now = env.now();
let ratio_changed = (from ^ to) & RATIO_40 != 0;
if ratio_changed {
self.ratio_at = Some(now);
}
let (was, is) = (from & SCRAMBLING_ENABLE != 0, to & SCRAMBLING_ENABLE != 0);
if is && (!was || ratio_changed) {
self.armed_at = Some(now);
self.seen_since_enable = false;
} else if !is {
self.armed_at = None;
}
}
if reg == CONFIG_1 && self.max_frl != 0 {
self.start_training(to, env);
}
}
fn start_training(&mut self, config: u8, env: &mut Env<'_>) {
let rate = config & 0x0F;
self.match_from = None;
if rate == 0 {
self.training = Training::Legacy;
self.post_requests([0; 4], false, env);
return;
}
let update = self.get(UPDATE_0);
if update & FRL_START != 0 {
self.set(UPDATE_0, update & !FRL_START, Actor::Sink, env);
}
self.training = Training::Requesting { rate };
self.lts3_from = env.now();
self.timeouts = 0;
self.ffe_levels = (config >> 4).min(FFE_LEVELS_MAX);
self.wanted = if rate > self.max_frl {
[LTP_RATE_CHANGE; 4]
} else {
self.ltp_requests
};
self.post_requests(self.wanted, true, env);
}
fn post_requests(&mut self, requests: [u8; 4], update: bool, env: &mut Env<'_>) {
for (reg, [low, high]) in [
(LTP_REQ_01, [requests[0], requests[1]]),
(LTP_REQ_23, [requests[2], requests[3]]),
] {
let value = (low & 0x0F) | (high << 4);
if self.get(reg) != value {
self.set(reg, value, Actor::Sink, env);
}
}
let flags = self.get(UPDATE_0);
if update {
self.update_set_at = env.now();
if flags & FLT_UPDATE == 0 {
self.set(UPDATE_0, flags | FLT_UPDATE, Actor::Sink, env);
}
}
}
fn past_flt_update(&self, now: Timestamp) -> (bool, Option<Timestamp>) {
if self.get(UPDATE_0) & FLT_UPDATE == 0 {
return (true, None);
}
let waited = self.update_set_at.checked_add(FLT_CLEAR_WAIT);
match waited {
Some(end) if self.frl_pass == FrlPass::Unchecked && end <= now => (true, Some(end)),
_ => (false, None),
}
}
fn posted(&self) -> [u8; 4] {
let (a, b) = (self.get(LTP_REQ_01), self.get(LTP_REQ_23));
[a & 0x0F, a >> 4, b & 0x0F, b >> 4]
}
fn lane_passes(lane: usize, rate: u8, posted: [u8; 4], line: Line, limits: LinkLanes) -> bool {
if posted[lane] == 0 {
return true;
}
let Line::Frl {
rate: line_rate,
patterns,
equalization,
..
} = line
else {
return false;
};
let carried = [
patterns.lane0,
patterns.lane1,
patterns.lane2,
patterns.lane3,
]
.map(|pattern| pattern.map_or(0, LtpPattern::value));
frl_value(line_rate) == rate
&& posted[lane] == carried[lane]
&& within_limits(lane, rate, equalization, limits)
}
fn run_timeouts(&mut self, now: Timestamp) {
let Training::Requesting { rate } = self.training else {
return;
};
let Some(budget) = self.lts3_timeout else {
return;
};
if self.frl_pass == FrlPass::Unchecked {
return;
}
let no_timeout = self.get(SOURCE_TEST_CONFIGURATION) & FLT_NO_TIMEOUT != 0;
let no_retrain = self.get(CONFIG_0) & FLT_NO_RETRAIN != 0;
if no_timeout || no_retrain {
return;
}
let step = budget / (u32::from(self.ffe_levels) + 1);
let elapsed = now.saturating_duration_since(self.lts3_from);
let due = if step.is_zero() {
u128::from(u32::MAX)
} else {
elapsed.as_micros() / step.as_micros().max(1)
};
let due = u32::try_from(due).unwrap_or(u32::MAX);
if due <= self.timeouts {
return;
}
let posted = self.posted();
let failing: [bool; 4] = core::array::from_fn(|lane| {
lane < frl_lanes(rate)
&& !Self::lane_passes(lane, rate, posted, self.line, self.lanes_seen)
});
let levels = u32::from(self.ffe_levels);
if self.timeouts < levels {
for (wanted, &failing) in self.wanted.iter_mut().zip(&failing) {
if failing {
*wanted = LTP_FFE_CHANGE;
}
}
}
if due > levels && failing.contains(&true) {
self.wanted = [LTP_RATE_CHANGE; 4];
}
self.timeouts = due;
}
fn evaluate_training(&mut self, env: &mut Env<'_>, reading_update: bool) {
let Training::Requesting { rate } = self.training else {
return;
};
let now = env.now();
let cleared = self.get(UPDATE_0) & FLT_UPDATE == 0;
if cleared && self.wanted != self.posted() {
self.post_requests(self.wanted, true, env);
for (wanted, &first) in self.wanted.iter_mut().zip(&self.ltp_requests) {
if *wanted == LTP_FFE_CHANGE {
*wanted = first;
}
}
self.match_from = None;
return;
}
let posted = self.posted();
let limits = env.lane_limits();
let (past, waited_until) = self.past_flt_update(now);
let lanes_pass = match self.frl_pass {
FrlPass::Unchecked => true,
_ => (0..frl_lanes(rate))
.all(|lane| Self::lane_passes(lane, rate, posted, self.line, limits)),
};
let matches = past
&& !posted
.iter()
.any(|&request| matches!(request, LTP_FFE_CHANGE | LTP_RATE_CHANGE))
&& lanes_pass;
let match_from = matches.then(|| self.match_from.or(waited_until).unwrap_or(now));
if match_from != self.match_from {
self.match_from = match_from;
self.match_reads = 0;
}
if reading_update && match_from.is_some() {
self.match_reads = self.match_reads.saturating_add(1);
}
if match_from.is_some_and(|from| self.passed(from, now, self.match_reads)) {
self.match_from = None;
self.training = Training::Passed { rate };
self.wanted = [0; 4];
self.post_requests([0; 4], true, env);
}
}
fn evaluate_start(&mut self, env: &mut Env<'_>) {
if self.max_frl == 0 {
return;
}
if !self.flt_ready_shown {
self.flt_ready_shown = true;
let flags = self.get(STATUS_FLAGS_0);
if flags & FLT_READY == 0 {
self.set(STATUS_FLAGS_0, flags | FLT_READY, Actor::Sink, env);
}
}
let Training::Passed { rate } = self.training else {
return;
};
let update = self.get(UPDATE_0);
let start = match self.frl_pass {
FrlPass::Unchecked => self.past_flt_update(env.now()).0,
_ => update & FLT_UPDATE == 0 && self.flags & LANES_LOCKED != 0,
};
if start {
self.training = Training::Started { rate };
self.set(UPDATE_0, update | FRL_START, Actor::Sink, env);
}
}
fn lose_lock(&mut self, env: &mut Env<'_>) {
let status = self.get(SCRAMBLING_STATUS);
if status & STATUS != 0 {
self.set(SCRAMBLING_STATUS, status & !STATUS, Actor::Sink, env);
}
self.locked = false;
self.lock_from = None;
}
fn hpd_resets(&mut self, env: &mut Env<'_>) {
let now = env.now();
let low_since = match (self.hpd_low_since, env.hpd()) {
(None, true) => return,
(None, false) => {
self.hpd_low_since = Some(now);
self.reset_done = [false; RegisterGroup::COUNT];
now
}
(Some(since), _) => since,
};
for &group in RegisterGroup::ALL {
let due = match self.hpd_resets[group.index()] {
HpdReset::OnHpdLow => true,
HpdReset::OnHpdRise => env.hpd(),
HpdReset::After(low_for) => {
low_since.checked_add(low_for).is_some_and(|due| now >= due)
}
HpdReset::Never => false,
};
if due && !self.reset_done[group.index()] {
self.reset_done[group.index()] = true;
for ® in group.registers() {
if self.get(reg) != 0 {
self.set(reg, 0, Actor::Sink, env);
}
if reg == SCRAMBLING_STATUS {
self.locked = false;
self.lock_from = None;
}
if reg == STATUS_FLAGS_0 {
self.flags = 0;
self.lanes_from = None;
self.flt_ready_shown = false;
self.training = Training::Legacy;
self.match_from = None;
}
if reg == CED {
self.ced = [0; 5];
self.ced_shown = [0; 11];
self.ced_checked = [0; 5];
}
}
}
}
if env.hpd() {
self.hpd_low_since = None;
}
}
fn evaluate(&mut self, env: &mut Env<'_>, reading: Option<u8>) {
self.count_and_check(env);
self.run_timeouts(env.now());
self.hpd_resets(env);
let now = env.now();
let line = env.line();
if line != self.line {
if !same_lanes(self.line, line) {
self.lanes_from = None;
}
self.line = line;
self.line_since = now;
self.lock_from = None;
}
let config = self.get(TMDS_CONFIG);
let matching = match line {
Line::Tmds {
character_rate_khz,
ratio,
scrambled: true,
} => {
let div40 = ratio == TmdsClockRatio::Div40;
let fits = div40 == (character_rate_khz > RATIO_40_ABOVE_KHZ);
fits && div40 == (config & RATIO_40 != 0) && self.takes(character_rate_khz)
}
_ => false,
};
if let Some(at) = self.armed_at {
let deadline = self
.enable_timeout
.and_then(|timeout| at.checked_add(timeout));
let in_time = deadline.is_none_or(|deadline| now < deadline);
self.seen_since_enable |= matching && in_time;
if !in_time && !self.seen_since_enable {
self.set(TMDS_CONFIG, config & !SCRAMBLING_ENABLE, Actor::Sink, env);
}
}
let holds = self
.armed_at
.is_some_and(|at| matching && !self.withheld && !(self.strict && self.too_early(at)));
let lock_from = holds.then(|| self.lock_from.unwrap_or(now));
if lock_from != self.lock_from {
self.lock_from = lock_from;
self.reads = 0;
}
if reading == Some(SCRAMBLING_STATUS) && lock_from.is_some() {
self.reads = self.reads.saturating_add(1);
}
let locked = lock_from.is_some_and(|from| self.passed(from, now, self.reads));
if locked != self.locked {
self.locked = locked;
let status = self.get(SCRAMBLING_STATUS);
let to = if locked {
status | STATUS
} else {
status & !STATUS
};
if to != status {
self.set(SCRAMBLING_STATUS, to, Actor::Sink, env);
}
}
self.evaluate_training(env, reading == Some(UPDATE_0));
self.evaluate_flags(env, reading == Some(STATUS_FLAGS_0));
self.evaluate_start(env);
self.errors = env.character_errors();
self.lanes_seen = env.lane_limits();
self.show_errors();
}
fn count_and_check(&mut self, env: &mut Env<'_>) {
if self.pending_update != 0 {
let update = self.get(UPDATE_0);
if update | self.pending_update != update {
self.set(UPDATE_0, update | self.pending_update, Actor::Sink, env);
}
self.pending_update = 0;
}
self.count_and_check_to(env.now(), env);
}
fn count_and_check_to(&mut self, now: Timestamp, env: &mut Env<'_>) {
let CedUpdate::EverySecond { rise } = self.ced_update else {
self.count_errors(now);
return;
};
let rise = u64::from(rise.max(1));
while let Some(next) = self.checked_at.checked_add(CED_CHECK) {
if next > now {
break;
}
self.count_errors(next);
self.see_counts(next, rise, env);
if !self.check_can_set(next) {
let seconds = now.saturating_duration_since(next).as_secs();
let seconds = u32::try_from(seconds).unwrap_or(u32::MAX);
if let Some(last) = next.checked_add(CED_CHECK.saturating_mul(seconds)) {
self.count_errors(last);
self.see_counts(last, rise, env);
}
break;
}
}
self.count_errors(now);
}
fn check_can_set(&self, at: Timestamp) -> bool {
let rates = self.counter_rates();
let flags = self.flags_at(at);
let update = self.get(UPDATE_0) | self.pending_update;
(0..COUNTERS.len()).any(|i| {
let flag = if i == RS { RSED_UPDATE } else { CED_UPDATE };
self.counting(i, flags)
&& rates[i] > 0
&& self.ced[i] < CED_MAX * CED_UNIT
&& update & flag == 0
})
}
fn counting(&self, i: usize, flags: u8) -> bool {
if i == RS {
matches!(self.line, Line::Frl { .. }) && flags & LANES_LOCKED != 0
} else {
flags & (1 << (i + 1)) != 0
}
}
fn lock_due(&self) -> Option<Timestamp> {
if self.flags & LANES_LOCKED != 0 {
return None;
}
let Trigger::After(delay) = self.trigger else {
return None;
};
self.lanes_from?.checked_add(delay)
}
fn flags_at(&self, at: Timestamp) -> u8 {
match self.lock_due() {
Some(due) if due <= at => {
let lanes = match self.line {
Line::Frl { rate, .. } if frl_lanes(frl_value(rate)) == 4 => FOUR_LANES_LOCKED,
_ => LANES_LOCKED,
};
self.flags | lanes
}
_ => self.flags,
}
}
fn counter_rates(&self) -> [u32; 5] {
let [a, b, c, d] = self.errors.lanes();
[a, b, c, d, self.errors.rs_corrections]
}
fn see_counts(&mut self, at: Timestamp, rise: u64, env: &mut Env<'_>) {
self.checked_at = at;
let flags = self.flags_at(at);
let mut set = 0;
for i in 0..COUNTERS.len() {
if !self.counting(i, flags) {
continue;
}
let count = (self.ced[i] / CED_UNIT).min(CED_MAX);
let checked = self.ced_checked[i];
if count >= checked.saturating_add(rise) || (count != checked && count == CED_MAX) {
set |= if i == RS { RSED_UPDATE } else { CED_UPDATE };
}
self.ced_checked[i] = count;
}
if at > env.now() {
self.pending_update |= set;
return;
}
let update = self.get(UPDATE_0);
if update | set != update {
self.set(UPDATE_0, update | set, Actor::Sink, env);
}
}
fn count_errors(&mut self, now: Timestamp) {
if let Some(due) = self
.lock_due()
.filter(|&due| self.counted_to < due && due <= now)
{
self.count_span(due, self.flags);
}
self.count_span(now, self.flags_at(now));
}
fn count_span(&mut self, to: Timestamp, flags: u8) {
if to <= self.counted_to {
return;
}
let micros = to.saturating_duration_since(self.counted_to).as_micros();
let micros = u64::try_from(micros).unwrap_or(u64::MAX);
self.counted_to = to;
let rates = self.counter_rates();
for (i, rate) in rates.into_iter().enumerate() {
if self.counting(i, flags) {
let more = u64::from(rate).saturating_mul(micros);
self.ced[i] = self.ced[i].saturating_add(more).min(CED_MAX * CED_UNIT);
}
}
}
fn clear_on_read(&mut self, reg: u8) {
if let Some(i) = COUNTERS.iter().position(|&low| low + 1 == reg) {
self.ced[i] = 0;
self.ced_checked[i] = 0;
}
}
fn show_errors(&mut self) {
let mut bytes = [0u8; 11];
for (i, &low) in COUNTERS.iter().enumerate() {
let [count_low, count_high, ..] = (self.ced[i] / CED_UNIT).to_le_bytes();
let valid = if self.counting(i, self.flags) {
CED_VALID
} else {
0
};
let at = usize::from(low - CED);
bytes[at] = count_low;
bytes[at + 1] = count_high | valid;
}
let rate = self.get(CONFIG_1) & 0x0F;
let four_lanes = (1..=FRL_RATE_MAX).contains(&rate) && frl_lanes(rate) == 4;
let mut summed: u8 = bytes[..6]
.iter()
.fold(0, |sum, &byte| sum.wrapping_add(byte));
if four_lanes {
summed = summed.wrapping_add(bytes[7]).wrapping_add(bytes[8]);
}
bytes[usize::from(CED_CHECKSUM - CED)] = summed.wrapping_neg();
for (i, (&byte, shown)) in bytes.iter().zip(&mut self.ced_shown).enumerate() {
if byte != *shown {
*shown = byte;
self.regs[usize::from(CED) + i] = byte;
}
}
}
fn passed(&self, from: Timestamp, now: Timestamp, reads: u32) -> bool {
match self.trigger {
Trigger::After(delay) => from.checked_add(delay).is_some_and(|due| now >= due),
Trigger::AfterReads(n) => reads >= n.max(1),
}
}
fn evaluate_flags(&mut self, env: &mut Env<'_>, reading_flags: bool) {
let now = env.now();
let config = self.get(TMDS_CONFIG);
let (clock, decodable) = match self.line {
Line::Tmds {
character_rate_khz,
ratio,
scrambled,
} => {
let div40 = ratio == TmdsClockRatio::Div40;
let high = character_rate_khz > RATIO_40_ABOVE_KHZ;
let decodable = div40 == high
&& div40 == (config & RATIO_40 != 0)
&& scrambled == (config & SCRAMBLING_ENABLE != 0)
&& (scrambled || !high)
&& self.takes(character_rate_khz);
(true, decodable)
}
Line::Frl {
rate,
patterns,
equalization,
..
} => {
let trained = match self.training {
Training::Passed { rate: at } | Training::Started { rate: at } => {
frl_value(rate) == at
}
_ => false,
};
let value = frl_value(rate);
let limits = env.lane_limits();
let within = (0..frl_lanes(value))
.all(|lane| within_limits(lane, value, equalization, limits));
(
false,
trained && patterns == LanePatterns::default() && within,
)
}
Line::Off => (false, false),
};
let lanes = match self.line {
Line::Frl { rate, .. } if frl_lanes(frl_value(rate)) == 4 => FOUR_LANES_LOCKED,
_ => LANES_LOCKED,
};
let lanes_from = decodable.then(|| self.lanes_from.unwrap_or(now));
if lanes_from != self.lanes_from {
self.lanes_from = lanes_from;
self.flag_reads = 0;
}
if reading_flags && lanes_from.is_some() {
self.flag_reads = self.flag_reads.saturating_add(1);
}
let locked = lanes_from.is_some_and(|from| self.passed(from, now, self.flag_reads));
let flags = if clock { CLOCK_DETECTED } else { 0 } | if locked { lanes } else { 0 };
if flags == self.flags {
return;
}
self.flags = flags;
let held = self.get(STATUS_FLAGS_0);
let to = (held & !(CLOCK_DETECTED | FOUR_LANES_LOCKED)) | flags;
if to == held {
return;
}
self.set(STATUS_FLAGS_0, to, Actor::Sink, env);
let update = self.get(UPDATE_0);
if self.status_update == StatusUpdate::OnChange && update & STATUS_UPDATE == 0 {
self.set(UPDATE_0, update | STATUS_UPDATE, Actor::Sink, env);
}
}
fn takes(&self, character_rate_khz: u32) -> bool {
self.max_tmds_rate_khz
.is_none_or(|max| character_rate_khz <= max)
}
fn too_early(&self, at: Timestamp) -> bool {
let resume_from = self
.ratio_at
.and_then(|ratio_at| ratio_at.checked_add(RATIO_RESUME_MIN));
self.line_since < at || resume_from.is_some_and(|from| self.line_since < from)
}
fn advance(&mut self) -> bool {
let (next, wrapped) = self.offset.overflowing_add(1);
self.offset = next;
wrapped
}
fn write_byte(&mut self, value: u8, env: &mut Env<'_>) -> Result<(), DdcErrorKind> {
let reg = self.offset;
let mut value = value;
if reg == TMDS_CONFIG && value & SCRAMBLING_ENABLE != 0 {
self.attempts = self.attempts.saturating_add(1);
self.withheld = false;
if self.attempts <= self.refusal.attempts {
env.record(Event::Refusal {
attempt: self.attempts,
kind: self.refusal.kind,
});
match self.refusal.kind {
RefusalKind::WithholdStatus => self.withheld = true,
RefusalKind::DropEnable => value &= !SCRAMBLING_ENABLE,
}
}
}
match role(reg) {
Role::Source => self.set(reg, value, Actor::Source, env),
Role::WriteOneToClear => {
let to = self.get(reg) & !value;
self.set(reg, to, Actor::Source, env);
}
Role::Sink => match self.owned_write {
OwnedWrite::Ignore => env.record(Event::IgnoredWrite {
addr: SCDC,
reg,
value,
why: Ignored::SinkOwned,
}),
OwnedWrite::Nack => return Err(NACK_DATA),
},
}
Ok(())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Training {
Legacy,
Requesting { rate: u8 },
Passed { rate: u8 },
Started { rate: u8 },
}
const fn frl_value(rate: HdmiForumFrl) -> u8 {
match rate {
HdmiForumFrl::Rate3Gbps3Lanes => 1,
HdmiForumFrl::Rate6Gbps3Lanes => 2,
HdmiForumFrl::Rate6Gbps4Lanes => 3,
HdmiForumFrl::Rate8Gbps4Lanes => 4,
HdmiForumFrl::Rate10Gbps4Lanes => 5,
HdmiForumFrl::Rate12Gbps4Lanes => FRL_RATE_MAX,
_ => 0,
}
}
fn same_lanes(a: Line, b: Line) -> bool {
match (a, b) {
(
Line::Frl { rate, patterns, .. },
Line::Frl {
rate: other_rate,
patterns: other_patterns,
..
},
) => rate == other_rate && patterns == other_patterns,
_ => a == b,
}
}
fn within_limits(lane: usize, rate: u8, equalization: Option<EqParams>, limits: LinkLanes) -> bool {
let limit = limits.lanes()[lane];
limit.max_rate.is_none_or(|max| rate <= frl_value(max))
&& tx_ffe_levels(equalization)[lane] >= limit.min_tx_ffe
}
fn tx_ffe_levels(equalization: Option<EqParams>) -> [TxFfeLevel; 4] {
equalization.map_or([TxFfeLevel::default(); 4], |eq| {
[
eq.lane0.tx_ffe_level,
eq.lane1.tx_ffe_level,
eq.lane2.tx_ffe_level,
eq.lane3
.map_or(TxFfeLevel::default(), |lane| lane.tx_ffe_level),
]
})
}
const fn frl_lanes(rate: u8) -> usize {
if rate <= FRL_3_LANES_MAX { 3 } else { 4 }
}
const NACK_DATA: DdcErrorKind = DdcErrorKind::NoAcknowledge(NoAcknowledgeSource::Data);
impl Target for Scdc {
fn answers(&self, addr: u8, env: &Env<'_>) -> bool {
addr == SCDC && (env.hpd() || self.during_hpd_low == DuringHpdLow::Answers)
}
fn update(&mut self, env: &mut Env<'_>) {
self.evaluate(env, None);
}
fn transaction(
&mut self,
ops: &mut [Operation<'_>],
env: &mut Env<'_>,
) -> Result<(), DdcErrorKind> {
self.hooked_transaction(ops, env, None)
}
}
impl Scdc {
pub(crate) fn hooked_transaction(
&mut self,
ops: &mut [Operation<'_>],
env: &mut Env<'_>,
mut hook: Option<&mut (dyn ScdcHook + Send)>,
) -> Result<(), DdcErrorKind> {
self.evaluate(env, None);
let refuse_past_end = self.past_end == ScdcPastEnd::Nack;
let mut wire: u32 = 0;
for op in ops.iter_mut() {
wire = wire.saturating_add(1).saturating_add(match op {
Operation::Write { bytes, .. } => u32::try_from(bytes.len()).unwrap_or(u32::MAX),
Operation::Read { .. } => 0,
});
match op {
Operation::Write { addr: SCDC, bytes } => {
let Some((&offset, data)) = bytes.split_first() else {
continue;
};
self.offset = offset;
let mut past_end = false;
for &value in data {
if past_end && refuse_past_end {
return Err(NACK_DATA);
}
let reg = self.offset;
let decision = match hook.as_deref_mut() {
Some(hook) => {
hook.write(reg, value, &ScdcRegisters::new(&self.regs), env)
}
None => HookWrite::Store(value),
};
match decision {
HookWrite::Store(value) => self.write_byte(value, env)?,
HookWrite::StoreRelocking(value) => {
self.write_byte(value, env)?;
self.lose_lock(env);
}
HookWrite::Drop | HookWrite::Nack => {
env.record(Event::IgnoredWrite {
addr: SCDC,
reg,
value,
why: Ignored::Hook,
});
if decision == HookWrite::Nack {
return Err(NACK_DATA);
}
}
}
self.evaluate(env, None);
past_end |= self.advance();
}
}
Operation::Read { addr: SCDC, buf } => {
for byte in buf.iter_mut() {
if matches!(self.offset, UPDATE_0 | SCRAMBLING_STATUS | STATUS_FLAGS_0) {
self.evaluate(env, Some(self.offset));
}
let counter = (CED..=CED_LAST).contains(&self.offset);
if counter && self.during_read == DuringRead::Moving {
let ahead = env.byte_time().saturating_mul(wire);
let at = env.now().checked_add(ahead).unwrap_or(env.now());
self.count_and_check_to(at, env);
self.show_errors();
}
let value = self.get(self.offset);
*byte = match hook.as_deref_mut() {
Some(hook) => {
hook.read(self.offset, value, &ScdcRegisters::new(&self.regs), env)
}
None => value,
};
if self.ced_read == CedRead::ClearOnRead {
self.clear_on_read(self.offset);
}
wire = wire.saturating_add(1);
self.advance();
}
}
_ => {
return Err(DdcErrorKind::NoAcknowledge(NoAcknowledgeSource::Address));
}
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::line::Line;
use crate::transcript::Transcript;
use hdmi_hal::time::Timestamp;
fn run(ops: &mut [Operation<'_>]) -> (Scdc, Result<(), DdcErrorKind>) {
let mut scdc = Scdc::new(&SinkConfig::new()).unwrap();
let mut transcript = Transcript::<8>::new();
let mut env = Env::new(Timestamp::from_micros(0), true, Line::Off, &mut transcript);
let result = scdc.transaction(ops, &mut env);
(scdc, result)
}
#[test]
fn an_empty_write_changes_nothing() {
let mut buf = [0u8; 1];
let (scdc, result) = run(&mut [
Operation::Write {
addr: SCDC,
bytes: &[],
},
Operation::Read {
addr: SCDC,
buf: &mut buf,
},
]);
assert_eq!(result, Ok(()));
assert_eq!(scdc.offset, 1);
assert_eq!(buf, [0]);
}
#[test]
fn another_address_in_its_transaction_is_not_acknowledged() {
let (scdc, result) = run(&mut [
Operation::Write {
addr: SCDC,
bytes: &[0x20, 0x03],
},
Operation::Write {
addr: 0x30,
bytes: &[1],
},
]);
assert_eq!(
result,
Err(DdcErrorKind::NoAcknowledge(NoAcknowledgeSource::Address))
);
assert_eq!(scdc.get(TMDS_CONFIG), 3, "what came before stays");
}
#[test]
fn roles_follow_the_sources() {
for reg in [
SOURCE_VERSION,
TMDS_CONFIG,
CONFIG_0,
CONFIG_1,
0xC0,
0xDE,
0xFF,
] {
assert_eq!(role(reg), Role::Source, "{reg:#04x}");
}
for reg in [UPDATE_0, UPDATE_1] {
assert_eq!(role(reg), Role::WriteOneToClear, "{reg:#04x}");
}
for reg in [
SINK_VERSION,
SCRAMBLING_STATUS,
SOURCE_TEST_CONFIGURATION,
0x40,
0x42,
0x50,
0x5A,
0xD0,
0xDD,
] {
assert_eq!(role(reg), Role::Sink, "{reg:#04x}");
}
}
#[test]
fn no_register_file_without_scdc() {
assert!(Scdc::new(&SinkConfig::new().without_scdc()).is_none());
}
}