plumbob-async 0.1.0

Async FRL link training state machine for HDMI 2.1
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

extern crate std;
use std::collections::VecDeque;

use display_types::cea861::hdmi_forum::HdmiForumFrl;
use hdmi_hal_async::{LtpPattern, phy::HdmiPhy};

use crate::client::ScdcClient;
use crate::{CedCounters, FrlConfig, LtpReq, TrainingConfig, TrainingStatus};

// -------------------------------------------------------------------------
// SimScdc — scripted async SCDC client for state machine tests
// -------------------------------------------------------------------------

pub struct SimScdc {
    /// Scripted responses for `read_training_status`, consumed in order.
    pub statuses: VecDeque<Result<TrainingStatus, ()>>,
    pub fail_write_frl_config: bool,
    pub fail_read_ced: bool,
    /// The last config written via `write_frl_config`.
    pub written_config: Option<FrlConfig>,
    pub ced_calls: u32,
}

impl SimScdc {
    pub fn new() -> Self {
        Self {
            statuses: VecDeque::new(),
            fail_write_frl_config: false,
            fail_read_ced: false,
            written_config: None,
            ced_calls: 0,
        }
    }

    pub fn push(&mut self, status: TrainingStatus) {
        self.statuses.push_back(Ok(status));
    }

    pub fn push_err(&mut self) {
        self.statuses.push_back(Err(()));
    }
}

impl ScdcClient for SimScdc {
    type Error = ();

    async fn write_frl_config(&mut self, config: FrlConfig) -> Result<(), ()> {
        if self.fail_write_frl_config {
            return Err(());
        }
        self.written_config = Some(config);
        Ok(())
    }

    async fn read_training_status(&mut self) -> Result<TrainingStatus, ()> {
        self.statuses.pop_front().unwrap_or(Err(()))
    }

    async fn read_ced(&mut self) -> Result<CedCounters, ()> {
        if self.fail_read_ced {
            return Err(());
        }
        self.ced_calls += 1;
        Ok(CedCounters {
            lane0: None,
            lane1: None,
            lane2: None,
            lane3: None,
        })
    }
}

// -------------------------------------------------------------------------
// MockPhy — records calls and supports injectable errors
// -------------------------------------------------------------------------

pub struct MockPhy {
    pub fail_set_frl_rate: bool,
    pub fail_send_ltp: bool,
    pub frl_rate: Option<HdmiForumFrl>,
    pub last_ltp: Option<LtpPattern>,
}

impl MockPhy {
    pub fn new() -> Self {
        Self {
            fail_set_frl_rate: false,
            fail_send_ltp: false,
            frl_rate: None,
            last_ltp: None,
        }
    }
}

impl HdmiPhy for MockPhy {
    type Error = ();

    async fn set_frl_rate(&mut self, rate: HdmiForumFrl) -> Result<(), ()> {
        if self.fail_set_frl_rate {
            return Err(());
        }
        self.frl_rate = Some(rate);
        Ok(())
    }

    async fn send_ltp(&mut self, pattern: LtpPattern) -> Result<(), ()> {
        if self.fail_send_ltp {
            return Err(());
        }
        self.last_ltp = Some(pattern);
        Ok(())
    }

    async fn adjust_equalization(&mut self, _params: hdmi_hal_async::EqParams) -> Result<(), ()> {
        Ok(())
    }

    async fn set_scrambling(&mut self, _enabled: bool) -> Result<(), ()> {
        Ok(())
    }
}

// -------------------------------------------------------------------------
// Status helpers and fixtures
// -------------------------------------------------------------------------

pub fn not_ready() -> TrainingStatus {
    TrainingStatus {
        flt_ready: false,
        frl_start: false,
        ltp_req: LtpReq::None,
    }
}

pub fn flt_ready() -> TrainingStatus {
    TrainingStatus {
        flt_ready: true,
        frl_start: false,
        ltp_req: LtpReq::None,
    }
}

pub fn frl_started() -> TrainingStatus {
    TrainingStatus {
        flt_ready: true,
        frl_start: true,
        ltp_req: LtpReq::None,
    }
}

pub fn ltp(pattern: LtpReq) -> TrainingStatus {
    TrainingStatus {
        flt_ready: true,
        frl_start: true,
        ltp_req: pattern,
    }
}

pub const RATE: HdmiForumFrl = HdmiForumFrl::Rate6Gbps4Lanes;

pub fn cfg(flt: u32, frl: u32, ltp_t: u32) -> TrainingConfig {
    let mut c = TrainingConfig::default();
    c.flt_ready_timeout = flt;
    c.frl_start_timeout = frl;
    c.ltp_timeout = ltp_t;
    c
}