1use core::task::Context;
6
7use crate::{
8 asynch::wake_at,
9 ethernet::{
10 mac::{Duplex, LinkState, Speed},
11 phy::{
12 ANAR,
13 ANLPAR,
14 BMCR,
15 BMSR,
16 EXSR,
17 GBCR,
18 GBSR,
19 MdioBus,
20 PHYIDR1,
21 PHYIDR2,
22 Phy,
23 PhyError,
24 an,
25 bmcr,
26 bmsr,
27 exsr,
28 gbcr,
29 gbsr,
30 },
31 },
32 time::{Duration, Instant},
33};
34
35const LINK_POLL_INTERVAL: Duration = Duration::from_millis(500);
37
38const LINK_STATE_DOWN: LinkState = LinkState {
39 up: false,
40 speed: Speed::_100M,
41 duplex: Duplex::Full,
42};
43
44const RESET_POLL_LIMIT: u32 = 500_000; const YT8531_ID: (u16, u16) = (0x4F51, 0xE91B);
49
50const REG_EXT_ADDR: u8 = 0x1E;
52const REG_EXT_DATA: u8 = 0x1F;
54
55const EXT_CHIP_CFG: u16 = 0xA001;
57const RXC_DLY_EN: u16 = 1 << 8;
58
59const EXT_RGMII_CFG1: u16 = 0xA003;
62const RGMII_TX_DLY_MASK: u16 = 0x00FF;
63const RGMII_DLY_2NS: u16 = 13;
64
65fn ext_read<M: MdioBus>(mdio: &mut M, addr: u8, ext: u16) -> u16 {
66 mdio.write(addr, REG_EXT_ADDR, ext);
67 mdio.read(addr, REG_EXT_DATA)
68}
69
70fn ext_write<M: MdioBus>(mdio: &mut M, addr: u8, ext: u16, val: u16) {
71 mdio.write(addr, REG_EXT_ADDR, ext);
72 mdio.write(addr, REG_EXT_DATA, val);
73}
74
75#[derive(Clone, Copy, Debug)]
86pub struct GenericPhy {
87 addr: Option<u8>,
89 link: LinkState,
91 next_poll: Instant,
93}
94
95impl GenericPhy {
96 pub const fn new(addr: u8) -> Self {
98 Self::with_addr(Some(addr))
99 }
100
101 pub const fn new_auto() -> Self {
106 Self::with_addr(None)
107 }
108
109 const fn with_addr(addr: Option<u8>) -> Self {
110 Self {
111 addr,
112 link: LINK_STATE_DOWN,
113 next_poll: Instant::EPOCH,
114 }
115 }
116
117 fn discover<M: MdioBus>(mdio: &mut M) -> Option<u8> {
123 for _ in 0..3 {
124 for addr in 0..32_u8 {
125 let id = mdio.read(addr, PHYIDR1);
126 if id != 0x0000 && id != 0xFFFF {
127 debug!("phy found at addr {} - id: {:x}", addr, id);
128 return Some(addr);
129 }
130 }
131 }
132 None
133 }
134
135 fn limit_advertisement<M: MdioBus>(mdio: &mut M, addr: u8, max_speed: Speed) -> bool {
142 let mut changed = false;
143
144 if max_speed != Speed::_1000M {
145 let gbcr_val = mdio.read(addr, GBCR);
146 if gbcr_val != 0xFFFF {
147 let limited = gbcr_val & !(gbcr::ADV_1000_FULL | gbcr::ADV_1000_HALF);
148 if limited != gbcr_val {
149 mdio.write(addr, GBCR, limited);
150 changed = true;
151 }
152 }
153 }
154
155 if max_speed == Speed::_10M {
156 let anar_val = mdio.read(addr, ANAR);
157 let limited = anar_val & !(an::BASE_100_FULL | an::BASE_100_HALF);
158 if limited != anar_val {
159 mdio.write(addr, ANAR, limited);
160 changed = true;
161 }
162 }
163
164 changed
165 }
166
167 fn init_yt8531<M: MdioBus>(mdio: &mut M, addr: u8) {
173 let chip = ext_read(mdio, addr, EXT_CHIP_CFG);
174 ext_write(mdio, addr, EXT_CHIP_CFG, chip | RXC_DLY_EN);
175
176 let mut rgmii = ext_read(mdio, addr, EXT_RGMII_CFG1);
177 rgmii = (rgmii & !RGMII_TX_DLY_MASK) | (RGMII_DLY_2NS << 4) | RGMII_DLY_2NS;
178 ext_write(mdio, addr, EXT_RGMII_CFG1, rgmii);
179
180 let ctrl = mdio.read(addr, BMCR);
182 mdio.write(addr, BMCR, ctrl | bmcr::RESTART_AN);
183 }
184}
185
186impl Phy for GenericPhy {
187 fn address(&self) -> u8 {
188 self.addr
189 .expect("GenericPhy address not yet resolved — call init() first")
190 }
191
192 fn init<M: MdioBus>(&mut self, mdio: &mut M, max_speed: Speed) -> Result<(), PhyError> {
193 if self.addr.is_none() {
195 self.addr = Some(Self::discover(mdio).ok_or(PhyError::NotFound)?);
196 }
197 let addr = self.addr.unwrap();
198
199 let ctrl = mdio.read(addr, BMCR);
203 if ctrl & bmcr::POWER_DOWN != 0 {
204 mdio.write(addr, BMCR, ctrl & !bmcr::POWER_DOWN);
205 for _ in 0..RESET_POLL_LIMIT {
206 if mdio.read(addr, BMCR) & bmcr::POWER_DOWN == 0 {
207 break;
208 }
209 crate::rom::ets_delay_us(1);
210 }
211 }
212
213 mdio.write(addr, BMCR, bmcr::RESET);
214 for _ in 0..RESET_POLL_LIMIT {
215 if mdio.read(addr, BMCR) & bmcr::RESET == 0 {
216 let ctrl = mdio.read(addr, BMCR);
219 if ctrl & bmcr::ANEN == 0 {
220 mdio.write(addr, BMCR, (ctrl & !bmcr::POWER_DOWN) | bmcr::ANEN);
221 }
222
223 let restart_an = Self::limit_advertisement(mdio, addr, max_speed);
224
225 let id = (mdio.read(addr, PHYIDR1), mdio.read(addr, PHYIDR2));
226 if id == YT8531_ID {
227 Self::init_yt8531(mdio, addr);
229 } else if restart_an {
230 let ctrl = mdio.read(addr, BMCR);
231 mdio.write(addr, BMCR, ctrl | bmcr::RESTART_AN);
232 }
233
234 return Ok(());
235 }
236 crate::rom::ets_delay_us(1);
237 }
238
239 Err(PhyError::Timeout)
240 }
241
242 fn poll_link<M: MdioBus>(&mut self, mdio: &mut M, cx: Option<&mut Context<'_>>) -> LinkState {
243 let Some(cx) = cx else {
244 return self.read_link(mdio);
245 };
246
247 let now = Instant::now();
250 if now >= self.next_poll {
251 self.link = self.read_link(mdio);
252 self.next_poll = now + LINK_POLL_INTERVAL;
253 }
254
255 wake_at(self.next_poll, cx);
258 self.link
259 }
260}
261
262impl GenericPhy {
263 fn read_link<M: MdioBus>(&self, mdio: &mut M) -> LinkState {
265 let Some(addr) = self.addr else {
266 debug!("poll_link called before init");
267 return LINK_STATE_DOWN;
268 };
269
270 let _ = mdio.read(addr, BMSR);
273 let bmsr_val = mdio.read(addr, BMSR);
274
275 trace!("bmsr_val: {:x}", bmsr_val);
276
277 if bmsr_val & bmsr::LINK_STATUS == 0 {
281 return LINK_STATE_DOWN;
282 }
283
284 let bmcr_val = mdio.read(addr, BMCR);
285 if bmcr_val & bmcr::ANEN == 0 {
286 let speed = if bmcr_val & bmcr::SPEED_1000 != 0 {
287 Speed::_1000M
288 } else if bmcr_val & bmcr::SPEED_100 != 0 {
289 Speed::_100M
290 } else {
291 Speed::_10M
292 };
293 let duplex = if bmcr_val & bmcr::FULL_DUPLEX != 0 {
294 Duplex::Full
295 } else {
296 Duplex::Half
297 };
298 return LinkState {
299 up: true,
300 speed,
301 duplex,
302 };
303 }
304
305 if bmsr_val & bmsr::EXTENDED_STATUS != 0 {
306 let exsr_val = mdio.read(addr, EXSR);
307 if exsr_val != 0xFFFF && (exsr_val & (exsr::BASE1000_T_HD | exsr::BASE1000_T_FD) != 0) {
308 let gbcr_val = mdio.read(addr, GBCR);
309 let gbsr_val = mdio.read(addr, GBSR);
310 if gbcr_val != 0xFFFF && gbsr_val != 0xFFFF {
311 if gbcr_val & gbcr::ADV_1000_FULL != 0 && gbsr_val & gbsr::LP_1000_FULL != 0 {
312 return LinkState {
313 up: true,
314 speed: Speed::_1000M,
315 duplex: Duplex::Full,
316 };
317 }
318 if gbcr_val & gbcr::ADV_1000_HALF != 0 && gbsr_val & gbsr::LP_1000_HALF != 0 {
319 return LinkState {
320 up: true,
321 speed: Speed::_1000M,
322 duplex: Duplex::Half,
323 };
324 }
325 }
326 }
327 }
328
329 let anar_val = mdio.read(addr, ANAR);
331 let anlpar_val = mdio.read(addr, ANLPAR);
332 let common = anar_val & anlpar_val;
333 let (speed, duplex) = if common & an::BASE_100_FULL != 0 {
334 (Speed::_100M, Duplex::Full)
335 } else if common & an::BASE_100_HALF != 0 {
336 (Speed::_100M, Duplex::Half)
337 } else if common & an::BASE_10_FULL != 0 {
338 (Speed::_10M, Duplex::Full)
339 } else if common & an::BASE_10_HALF != 0 {
340 (Speed::_10M, Duplex::Half)
341 } else {
342 (Speed::_100M, Duplex::Full)
343 };
344
345 LinkState {
346 up: true,
347 speed,
348 duplex,
349 }
350 }
351}