w5500_regsim/
lib.rs

1//! Register simulation for the [Wiznet W5500] internet offload chip.
2//!
3//! This implements the [`w5500_ll::Registers`] trait using [`std::net`] sockets
4//! to simulate the W5500 on your local PC.
5//!
6//! This is a best-effort implementation to aid in development of application
7//! code, not all features of the W5500 will be fully simulated.
8//!
9//! # Notes
10//!
11//! This is in an early alpha state, there are many todos throughout the code.
12//!
13//! ## Not-implemented
14//!
15//! * MR (Mode Register)
16//!     * Wake on LAN
17//!     * Ping block
18//!     * PPPoE mode
19//!     * Force ARP
20//! * INTLEVEL (Interrupt Low Level Timer Register)
21//! * IR (Interrupt Register)
22//! * IMR (Interrupt Mask Register)
23//! * GAR (Gateway IP Address Register)
24//! * SUBR (Subnet Mask Register)
25//! * SHAR (Source Hardware Address Register)
26//! * SIPR (Source IP Address Register)
27//! * INTLEVEL (Interrupt Low Level Timer Register)
28//! * IR (Interrupt Register)
29//! * IMR (Interrupt Mask Register)
30//! * SIR (Socket Interrupt Register)
31//!     * Partial; see SN_IR
32//! * SIMR (Socket Interrupt Mask Register)
33//! * RTR (Retry Time Register)
34//! * RCR (Retry Count Register)
35//! * PTIMER (PPP LCP Request Timer Register)
36//! * PMAGIC (PPP LCP Magic Number Register)
37//! * PHAR (PPP Destination MAC Address Register)
38//! * PSID (PPP Session Identification Register)
39//! * PMRU (PPP Maximum Segment Size Register)
40//! * UIPR (Unreachable IP Address Register)
41//! * UPORT (Unreachable Port Register)
42//! * PHYCFGR (PHY Configuration Register)
43//! * SN_MR (Socket n Mode Register)
44//! * SN_IR (Socket n Interrupt Register)
45//!     * DISCON
46//!     * TIMEOUT
47//!     * SENDOK
48//! * SN_SR (Socket n Status Register)
49//!     * SynSent
50//!     * SynRecv
51//!     * FinWait
52//!     * Closing
53//!     * TimeWait
54//!     * CloseWait
55//!     * LastAck
56//!     * Macraw
57//! * SN_MSSR (Socket n Maximum Segment Size Register)
58//! * SN_TOS (Socket n IP TOS Register)
59//! * SN_IMR (Socket n Interrupt Mask Register)
60//! * SN_FRAG (Socket n Fragment Offset in IP Header Register)
61//! * SN_KPALVTR (Socket n Keep Alive Timer Register)
62//!
63//! Believe it or not that is not simply a list of all registers.
64//!
65//! [Wiznet W5500]: https://docs.wiznet.io/Product/iEthernet/W5500/overview
66//! [`std::net`]: https://doc.rust-lang.org/std/net/index.html
67//! [`w5500-hl`]: https://crates.io/crates/w5500-hl
68//! [`w5500_ll::Registers`]: https://docs.rs/w5500-ll/latest/w5500_ll/trait.Registers.html
69#![cfg_attr(docsrs, feature(doc_cfg), feature(doc_auto_cfg))]
70
71use std::{
72    fs::File,
73    io::{self, Read, Write},
74    net::{SocketAddrV4, TcpListener, TcpStream, UdpSocket},
75};
76
77pub use w5500_ll::{self, Registers};
78
79use w5500_ll::{
80    net::{Eui48Addr, Ipv4Addr},
81    BufferSize, Mode, Protocol, Reg, Sn, SnReg, SocketCommand, SocketInterrupt, SocketMode,
82    SocketStatus, SOCKETS, VERSION,
83};
84
85// Socket spacing between blocks.
86const SOCKET_SPACING: u8 = 0x04;
87
88const NUM_SOCKETS: usize = SOCKETS.len();
89const DEFAULT_BUF_SIZE: usize = BufferSize::KB2.size_in_bytes();
90
91#[derive(Debug)]
92enum SocketType {
93    Udp(UdpSocket),
94    TcpListener(TcpListener),
95    TcpStream(TcpStream),
96}
97
98impl PartialEq for SocketType {
99    fn eq(&self, other: &Self) -> bool {
100        matches!(
101            (self, other),
102            (Self::Udp(_), Self::Udp(_))
103                | (Self::TcpListener(_), Self::TcpListener(_))
104                | (Self::TcpStream(_), Self::TcpStream(_))
105        )
106    }
107}
108
109#[derive(PartialEq, Eq)]
110enum BlockType {
111    Common,
112    Socket(Sn),
113    Tx(Sn),
114    Rx(Sn),
115}
116impl std::fmt::Display for BlockType {
117    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
118        match self {
119            BlockType::Common => write!(f, "REG"),
120            BlockType::Socket(n) => {
121                write!(f, "SN{}", u8::from(*n))
122            }
123            BlockType::Tx(n) => {
124                write!(f, "TX{}", u8::from(*n))
125            }
126            BlockType::Rx(n) => {
127                write!(f, "RX{}", u8::from(*n))
128            }
129        }
130    }
131}
132
133fn block_type(block: u8) -> BlockType {
134    if block == 0 {
135        BlockType::Common
136    } else {
137        let sn_val: u8 = block / SOCKET_SPACING;
138        let sn: Sn =
139            Sn::try_from(sn_val).unwrap_or_else(|_| panic!("Invalid block address: 0x{block:02X}"));
140        match block - (sn_val * SOCKET_SPACING) {
141            1 => BlockType::Socket(sn),
142            2 => BlockType::Tx(sn),
143            3 => BlockType::Rx(sn),
144            _ => panic!("Invalid block address: 0x{block:02X}"),
145        }
146    }
147}
148
149#[derive(Debug, PartialEq, Eq)]
150struct CommonRegs {
151    mr: u8,
152    gar: Ipv4Addr,
153    subr: Ipv4Addr,
154    shar: Eui48Addr,
155    sipr: Ipv4Addr,
156    intlevel: u16,
157    ir: u8,
158    imr: u8,
159    sir: u8,
160    simr: u8,
161    rtr: u16,
162    rcr: u8,
163    ptimer: u8,
164    pmagic: u8,
165    phar: Eui48Addr,
166    psid: u16,
167    pmru: u16,
168    uipr: Ipv4Addr,
169    uportr: u16,
170    phycfgr: u8,
171    versionr: u8,
172}
173
174impl CommonRegs {
175    /// Reset value of the common registers.
176    const RESET: Self = Self {
177        mr: 0x00,
178        gar: Ipv4Addr::UNSPECIFIED,
179        subr: Ipv4Addr::UNSPECIFIED,
180        shar: Eui48Addr::UNSPECIFIED,
181        sipr: Ipv4Addr::UNSPECIFIED,
182        intlevel: 0x00,
183        ir: 0x00,
184        imr: 0x00,
185        sir: 0x00,
186        simr: 0x00,
187        rtr: 0x07D0,
188        rcr: 0x08,
189        ptimer: 0x0028,
190        pmagic: 0x00,
191        phar: Eui48Addr::UNSPECIFIED,
192        psid: 0x00,
193        pmru: 0xFFFF,
194        uipr: Ipv4Addr::UNSPECIFIED,
195        uportr: 0x0000,
196        phycfgr: 0b10111111,
197        versionr: VERSION,
198    };
199}
200
201#[derive(Debug, PartialEq, Eq)]
202struct SocketRegs {
203    mr: u8,
204    cr: u8,
205    ir: SocketInterrupt,
206    sr: SocketStatus,
207    port: u16,
208    dhar: Eui48Addr,
209    dipr: Ipv4Addr,
210    dport: u16,
211    mssr: u16,
212    tos: u8,
213    ttl: u8,
214    rxbuf_size: BufferSize,
215    txbuf_size: BufferSize,
216    tx_fsr: u16,
217    tx_rd: u16,
218    tx_wr: u16,
219    rx_rsr: u16,
220    rx_rd: u16,
221    rx_wr: u16,
222    imr: u8,
223    frag: u16,
224    kpalvtr: u8,
225}
226
227impl SocketRegs {
228    /// Reset value of the socket registers.
229    const RESET: Self = Self {
230        mr: 0x00,
231        cr: 0x00,
232        ir: SocketInterrupt::DEFAULT,
233        sr: SocketStatus::Closed,
234        port: 0x0000,
235        dhar: Eui48Addr::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF),
236        dipr: Ipv4Addr::UNSPECIFIED,
237        dport: 0x00,
238        mssr: 0x0000,
239        tos: 0x00,
240        ttl: 0x80,
241        rxbuf_size: BufferSize::KB2,
242        txbuf_size: BufferSize::KB2,
243        tx_fsr: 0x0800,
244        tx_rd: 0x0000,
245        tx_wr: 0x0000,
246        rx_rsr: 0x0000,
247        rx_rd: 0x0000,
248        rx_wr: 0x0000,
249        imr: 0xFF,
250        frag: 0x4000,
251        kpalvtr: 0x00,
252    };
253
254    pub fn dest(&self) -> std::net::SocketAddrV4 {
255        SocketAddrV4::new(self.dipr, self.dport)
256    }
257}
258
259#[derive(Debug)]
260struct Socket {
261    regs: SocketRegs,
262    tx_buf: Vec<u8>,
263    rx_buf: Vec<u8>,
264    inner: Option<SocketType>,
265    client: Option<TcpStream>,
266}
267
268impl PartialEq for Socket {
269    fn eq(&self, other: &Self) -> bool {
270        self.regs == other.regs
271            && self.tx_buf == other.tx_buf
272            && self.rx_buf == other.rx_buf
273            && self.inner == other.inner
274            && ((self.client.is_some() && other.client.is_some())
275                || (self.client.is_none() && other.client.is_none()))
276    }
277}
278
279impl Default for Socket {
280    fn default() -> Self {
281        Self {
282            regs: SocketRegs::RESET,
283            tx_buf: vec![0; DEFAULT_BUF_SIZE],
284            rx_buf: vec![0; DEFAULT_BUF_SIZE],
285            inner: None,
286            client: None,
287        }
288    }
289}
290
291/// Simulated W5500.
292#[derive(Debug)]
293pub struct W5500 {
294    regs: CommonRegs,
295    sn: [Socket; NUM_SOCKETS],
296    socket_buffer_logging: bool,
297    corpus: Option<File>,
298}
299
300impl PartialEq for W5500 {
301    fn eq(&self, other: &Self) -> bool {
302        self.regs == other.regs
303            && self.sn == other.sn
304            && self.socket_buffer_logging == other.socket_buffer_logging
305            && ((self.corpus.is_some() && other.corpus.is_some())
306                || (self.corpus.is_none() && other.corpus.is_none()))
307    }
308}
309
310impl W5500 {
311    /// Enable or disable socket buffer logging.
312    ///
313    /// Socket buffer reads and writes get logged at the trace level.
314    /// For some protocols with large packets you may trace logs without the
315    /// verbose socket buffer logging.
316    ///
317    /// This is enabled by default.
318    ///
319    /// # Example
320    ///
321    /// Disable socket buffer logging.
322    ///
323    /// ```
324    /// let mut w5500 = w5500_regsim::W5500::default();
325    ///
326    /// w5500.set_socket_buffer_logging(false);
327    /// ```
328    pub fn set_socket_buffer_logging(&mut self, enable: bool) {
329        self.socket_buffer_logging = enable
330    }
331
332    /// Record the byte value of each read in a file.
333    ///
334    /// This is useful for generating a corpus for AFL or cargo-fuzz.
335    ///
336    /// # Example
337    ///
338    /// ```
339    /// use std::fs::File;
340    ///
341    /// let file: File = File::create("/tmp/w5500-corpus")?;
342    /// let mut w5500 = w5500_regsim::W5500::default();
343    ///
344    /// w5500.set_corpus_file(file);
345    /// # Ok::<(), std::io::Error>(())
346    /// ```
347    pub fn set_corpus_file(&mut self, file: File) {
348        self.corpus.replace(file);
349    }
350
351    fn log_byte(&mut self, byte: u8) {
352        if let Some(mut file) = self.corpus.as_ref() {
353            file.write_all(&[byte])
354                .expect("failed to write to read log");
355        }
356    }
357
358    fn reset(&mut self) {
359        *self = Self::default();
360    }
361
362    fn socket_cmd_open(&mut self, sn: Sn) -> io::Result<()> {
363        let sipr = self.regs.sipr;
364        let socket = self.socket_mut(sn);
365
366        // These registers are initialized by the OPEN command
367        socket.regs.rx_wr = 0;
368        socket.regs.rx_rd = 0;
369        socket.regs.tx_rd = 0;
370        socket.regs.tx_wr = 0;
371
372        let mr = SocketMode::from(socket.regs.mr);
373
374        match mr.protocol() {
375            Ok(Protocol::Closed) => {
376                log::error!("[{sn:?}] ignoring OPEN command, socket protocol is not yet")
377            }
378            Ok(Protocol::Tcp) => {
379                socket.inner = None;
380                self.sim_set_sn_sr(sn, SocketStatus::Init);
381            }
382            Ok(Protocol::Udp) => {
383                let local = SocketAddrV4::new(sipr, socket.regs.port);
384                log::info!("[{sn:?}] binding UDP socket to {local}");
385
386                match UdpSocket::bind(local) {
387                    Ok(udp_socket) => {
388                        log::info!("[{sn:?}] bound to {local}");
389                        udp_socket.set_nonblocking(true)?;
390                        udp_socket.set_ttl(socket.regs.ttl.into())?;
391                        socket.inner = Some(SocketType::Udp(udp_socket));
392                        self.sim_set_sn_sr(sn, SocketStatus::Udp);
393                    }
394                    Err(e) => {
395                        log::warn!("[{sn:?}] failed to bind socket {local}: {e}");
396                        self.sim_set_sn_sr(sn, SocketStatus::Closed);
397                    }
398                }
399            }
400            Ok(Protocol::Macraw) => {
401                if sn == Sn::Sn0 {
402                    unimplemented!("MACRAW")
403                } else {
404                    log::error!("[{sn:?}] ignoring OPEN command, MACRAW can only be used on Sn0")
405                }
406            }
407            Err(x) => log::error!("[{sn:?}] ignoring OPEN command, invalid protocol bits {x:#02X}"),
408        }
409        Ok(())
410    }
411
412    fn socket_cmd_connect(&mut self, sn: Sn) -> io::Result<()> {
413        let socket = self.socket_mut(sn);
414        assert_eq!(socket.regs.sr, SocketStatus::Init);
415
416        let addr = socket.regs.dest();
417        log::info!("[{sn:?}] opening a TCP stream to {addr}");
418
419        match TcpStream::connect(addr) {
420            Ok(stream) => {
421                log::info!("[{sn:?}] established TCP connection with {addr}");
422                stream.set_nonblocking(true)?;
423                stream.set_ttl(socket.regs.ttl.into())?;
424                socket.inner = Some(SocketType::TcpStream(stream));
425                self.raise_sn_ir(sn, SocketInterrupt::CON_MASK);
426                self.sim_set_sn_sr(sn, SocketStatus::Established);
427            }
428            Err(e) => {
429                log::warn!("[{sn:?}] TCP stream to {addr} failed: {e}");
430                self.raise_sn_ir(sn, SocketInterrupt::DISCON_MASK);
431                self.sim_set_sn_sr(sn, SocketStatus::Closed);
432            }
433        }
434
435        Ok(())
436    }
437
438    fn socket_cmd_listen(&mut self, sn: Sn) -> io::Result<()> {
439        let socket = self.socket_mut(sn);
440        assert_eq!(socket.regs.sr, SocketStatus::Init);
441
442        let addr = std::net::SocketAddrV4::new(std::net::Ipv4Addr::LOCALHOST, socket.regs.port);
443        log::info!("[{sn:?}] Opening a TCP listener on port {addr}");
444        match TcpListener::bind(addr) {
445            Ok(listener) => {
446                log::info!("[{sn:?}] Bound listener on {addr}");
447                listener.set_nonblocking(true)?;
448                listener.set_ttl(socket.regs.ttl.into())?;
449                socket.inner = Some(SocketType::TcpListener(listener));
450                self.sim_set_sn_sr(sn, SocketStatus::Listen);
451            }
452            Err(e) => {
453                log::warn!("[{sn:?}] TCP listener failed to bind to {addr}: {e}");
454                self.sim_set_sn_sr(sn, SocketStatus::Closed);
455                self.raise_sn_ir(sn, SocketInterrupt::TIMEOUT_MASK);
456            }
457        }
458
459        Ok(())
460    }
461
462    fn socket(&self, sn: Sn) -> &Socket {
463        &self.sn[usize::from(sn)]
464    }
465
466    fn socket_mut(&mut self, sn: Sn) -> &mut Socket {
467        &mut self.sn[usize::from(sn)]
468    }
469
470    fn sim_set_sn_sr(&mut self, sn: Sn, status: SocketStatus) {
471        let socket: &mut Socket = self.socket_mut(sn);
472        let old: SocketStatus = socket.regs.sr;
473        socket.regs.sr = status;
474        if old != status {
475            log::info!("[{sn:?}] {old:?} -> {status:?}");
476        }
477    }
478
479    fn socket_cmd_close(&mut self, sn: Sn) {
480        let socket = self.socket_mut(sn);
481        socket.inner = None;
482        self.sim_set_sn_sr(sn, SocketStatus::Closed);
483    }
484
485    fn socket_cmd_send(&mut self, sn: Sn) -> io::Result<()> {
486        let socket = self.socket_mut(sn);
487        let tail: usize = socket.regs.tx_rd.into();
488        let head: usize = socket.regs.tx_wr.into();
489        if head == tail {
490            log::error!("[{sn:?}] nothing to send");
491            return Ok(());
492        }
493        let size: usize = if head >= tail {
494            head - tail
495        } else {
496            usize::from(u16::MAX) + head - tail
497        };
498
499        log::debug!("[{sn:?}] tx_rd=0x{tail:04X}");
500        log::debug!("[{sn:?}] tx_wr=0x{head:04X}");
501        log::debug!("[{sn:?}] size=0x{size:04X}");
502
503        debug_assert!(
504            size <= socket.regs.txbuf_size.size_in_bytes(),
505            "[{sn:?}] Send data size exceeds buffer size",
506        );
507
508        let mut local_tx_buf: Vec<u8> = Vec::with_capacity(size);
509
510        // convert the circular buffer to somthing more usable
511        if head >= tail {
512            for buffer_adr in tail..head {
513                let buf_idx = buffer_adr % socket.tx_buf.len();
514                local_tx_buf.push(socket.tx_buf[buf_idx]);
515            }
516        } else {
517            for buffer_adr in tail..usize::from(u16::MAX) {
518                let buf_idx = buffer_adr % socket.tx_buf.len();
519                local_tx_buf.push(socket.tx_buf[buf_idx]);
520            }
521            for buffer_adr in 0..head {
522                let buf_idx = buffer_adr % socket.tx_buf.len();
523                local_tx_buf.push(socket.tx_buf[buf_idx]);
524            }
525        }
526
527        debug_assert!(!local_tx_buf.is_empty());
528
529        let dest = socket.regs.dest();
530
531        match socket.inner {
532            Some(SocketType::TcpStream(ref mut stream)) => {
533                stream.write_all(&local_tx_buf)?;
534                stream.flush()?;
535            }
536            Some(SocketType::Udp(ref mut udp)) => {
537                log::info!("[{sn:?}] sending to {dest}");
538                let num: usize = udp.send_to(&local_tx_buf, dest)?;
539                assert_eq!(num, local_tx_buf.len());
540            }
541            Some(SocketType::TcpListener(_)) => {
542                if let Some(ref mut stream) = socket.client {
543                    stream.write_all(&local_tx_buf)?;
544                    stream.flush()?;
545                }
546            }
547            None => {
548                panic!("[{sn:?}] Unable to send data, socket is closed")
549            }
550        }
551
552        socket.regs.tx_rd = socket.regs.tx_wr;
553
554        Ok(())
555    }
556
557    /// The RECV command is used to indicate that the microcontroller has read
558    /// an amount of data from the W5500, as indicated by the `sn_rx_rd`
559    /// pointer.
560    fn socket_cmd_recv(&mut self, sn: Sn) -> io::Result<()> {
561        let socket = self.socket_mut(sn);
562        socket.regs.rx_rsr = {
563            if socket.regs.rx_wr >= socket.regs.rx_rd {
564                socket.regs.rx_wr - socket.regs.rx_rd
565            } else {
566                u16::try_from(socket.regs.rxbuf_size.size_in_bytes()).unwrap() - socket.regs.rx_wr
567                    + socket.regs.rx_rd
568            }
569        };
570
571        Ok(())
572    }
573
574    fn sim_set_sn_rx_buf(&mut self, sn: Sn, data: &[u8]) {
575        let socket = self.socket_mut(sn);
576        let buf_len: usize = socket.rx_buf.len();
577
578        for byte in data.iter() {
579            let buf_idx: usize = usize::from(socket.regs.rx_wr) % buf_len;
580            if usize::from(socket.regs.rx_rsr).saturating_add(1) > buf_len {
581                log::error!("[{sn:?}] RX buffer overflow");
582                return;
583            }
584            socket.rx_buf[buf_idx] = *byte;
585            socket.regs.rx_wr = socket.regs.rx_wr.wrapping_add(1);
586            socket.regs.rx_rsr = socket.regs.rx_rsr.checked_add(1).unwrap();
587        }
588    }
589
590    fn raise_sn_ir(&mut self, sn: Sn, int: u8) {
591        self.regs.sir |= sn.bitmask();
592        self.socket_mut(sn).regs.ir =
593            SocketInterrupt::from(u8::from(self.socket(sn).regs.ir) | int);
594    }
595
596    fn check_socket(&mut self, sn: Sn) -> io::Result<()> {
597        let socket = self.socket_mut(sn);
598        let bufsize: usize = socket.regs.rxbuf_size.size_in_bytes();
599        let mut buf: Vec<u8> = vec![0; bufsize];
600
601        match socket.inner {
602            Some(SocketType::Udp(ref udp)) => match udp.recv_from(&mut buf) {
603                Ok((num, origin)) => {
604                    let origin = match origin {
605                        std::net::SocketAddr::V4(origin) => origin,
606                        other => {
607                            panic!("Internal error, got a non-IPV4 addr from recv_from: {other:?}")
608                        }
609                    };
610                    log::info!("[{sn:?}] recv datagram of len {num} from {origin}");
611                    let num: u16 = u16::try_from(num).unwrap_or(u16::MAX);
612                    // write out the header
613                    self.sim_set_sn_rx_buf(sn, &origin.ip().octets());
614                    self.sim_set_sn_rx_buf(sn, &origin.port().to_be_bytes());
615                    self.sim_set_sn_rx_buf(sn, &num.to_be_bytes());
616                    // write the rest of the data
617                    self.sim_set_sn_rx_buf(sn, &buf[..usize::from(num)]);
618                    self.raise_sn_ir(sn, SocketInterrupt::RECV_MASK);
619                }
620                Err(e) => match e.kind() {
621                    io::ErrorKind::WouldBlock => {}
622                    _ => return Err(e),
623                },
624            },
625            Some(SocketType::TcpStream(ref mut stream)) => match stream.read(&mut buf) {
626                Ok(num @ 1..=usize::MAX) => {
627                    log::info!("[{sn:?}] recv {num} bytes");
628                    self.sim_set_sn_rx_buf(sn, &buf[..num]);
629                    self.raise_sn_ir(sn, SocketInterrupt::RECV_MASK);
630                }
631                Err(e) => match e.kind() {
632                    io::ErrorKind::WouldBlock => {}
633                    _ => return Err(e),
634                },
635                _ => {}
636            },
637            Some(SocketType::TcpListener(ref mut listener)) => {
638                if let Some(ref mut stream) = socket.client {
639                    match stream.read(&mut buf) {
640                        Ok(num @ 1..=usize::MAX) => {
641                            log::info!("[{sn:?}] recv {num} bytes");
642                            self.sim_set_sn_rx_buf(sn, &buf[..num]);
643                            self.raise_sn_ir(sn, SocketInterrupt::RECV_MASK);
644                        }
645                        Err(e) => match e.kind() {
646                            io::ErrorKind::WouldBlock => {}
647                            _ => return Err(e),
648                        },
649                        _ => {}
650                    }
651                } else {
652                    match listener.accept() {
653                        Ok((stream, addr)) => {
654                            log::info!("[{sn:?}] Accepted a new stream from {addr}");
655                            stream.set_nonblocking(true)?;
656                            socket.client = Some(stream);
657                            self.raise_sn_ir(sn, SocketInterrupt::CON_MASK);
658                            self.sim_set_sn_sr(sn, SocketStatus::Established);
659                        }
660                        Err(e) => match e.kind() {
661                            io::ErrorKind::WouldBlock => {}
662                            _ => return Err(e),
663                        },
664                    }
665                }
666            }
667            None => {}
668        };
669        Ok(())
670    }
671
672    fn common_reg_rd(&self, addr: u16) -> u8 {
673        let decoded = Reg::try_from(addr);
674
675        let ret: u8 = match decoded {
676            Ok(Reg::MR) => self.regs.mr,
677            Ok(Reg::GAR0) => self.regs.gar.octets()[0],
678            Ok(Reg::GAR1) => self.regs.gar.octets()[1],
679            Ok(Reg::GAR2) => self.regs.gar.octets()[2],
680            Ok(Reg::GAR3) => self.regs.gar.octets()[3],
681            Ok(Reg::SUBR0) => self.regs.subr.octets()[0],
682            Ok(Reg::SUBR1) => self.regs.subr.octets()[1],
683            Ok(Reg::SUBR2) => self.regs.subr.octets()[2],
684            Ok(Reg::SUBR3) => self.regs.subr.octets()[3],
685            Ok(Reg::SHAR0) => self.regs.shar.octets[0],
686            Ok(Reg::SHAR1) => self.regs.shar.octets[1],
687            Ok(Reg::SHAR2) => self.regs.shar.octets[2],
688            Ok(Reg::SHAR3) => self.regs.shar.octets[3],
689            Ok(Reg::SHAR4) => self.regs.shar.octets[4],
690            Ok(Reg::SHAR5) => self.regs.shar.octets[5],
691            Ok(Reg::SIPR0) => self.regs.sipr.octets()[0],
692            Ok(Reg::SIPR1) => self.regs.sipr.octets()[1],
693            Ok(Reg::SIPR2) => self.regs.sipr.octets()[2],
694            Ok(Reg::SIPR3) => self.regs.sipr.octets()[3],
695            Ok(Reg::INTLEVEL0) => self.regs.intlevel.to_be_bytes()[0],
696            Ok(Reg::INTLEVEL1) => self.regs.intlevel.to_be_bytes()[1],
697            Ok(Reg::IR) => self.regs.ir,
698            Ok(Reg::IMR) => self.regs.imr,
699            Ok(Reg::SIR) => self.regs.sir,
700            Ok(Reg::SIMR) => self.regs.simr,
701            Ok(Reg::RTR0) => self.regs.rtr.to_be_bytes()[0],
702            Ok(Reg::RTR1) => self.regs.rtr.to_be_bytes()[1],
703            Ok(Reg::RCR) => self.regs.rcr,
704            Ok(Reg::PTIMER) => self.regs.ptimer,
705            Ok(Reg::PMAGIC) => self.regs.pmagic,
706            Ok(Reg::PHAR0) => self.regs.phar.octets[0],
707            Ok(Reg::PHAR1) => self.regs.phar.octets[1],
708            Ok(Reg::PHAR2) => self.regs.phar.octets[2],
709            Ok(Reg::PHAR3) => self.regs.phar.octets[3],
710            Ok(Reg::PHAR4) => self.regs.phar.octets[4],
711            Ok(Reg::PHAR5) => self.regs.phar.octets[5],
712            Ok(Reg::PSID0) => self.regs.psid.to_be_bytes()[0],
713            Ok(Reg::PSID1) => self.regs.psid.to_be_bytes()[1],
714            Ok(Reg::PMRU0) => self.regs.pmru.to_be_bytes()[0],
715            Ok(Reg::PMRU1) => self.regs.pmru.to_be_bytes()[1],
716            Ok(Reg::UIPR0) => self.regs.uipr.octets()[0],
717            Ok(Reg::UIPR1) => self.regs.uipr.octets()[1],
718            Ok(Reg::UIPR2) => self.regs.uipr.octets()[2],
719            Ok(Reg::UIPR3) => self.regs.uipr.octets()[3],
720            Ok(Reg::UPORTR0) => self.regs.uportr.to_be_bytes()[0],
721            Ok(Reg::UPORTR1) => self.regs.uportr.to_be_bytes()[1],
722            Ok(Reg::PHYCFGR) => self.regs.phycfgr,
723            Ok(Reg::VERSIONR) => self.regs.versionr,
724            Err(_) => 0x00,
725        };
726
727        let (name, level): (String, log::Level) = match decoded {
728            Ok(reg) => (format!("{reg:?}"), log::Level::Trace),
729            Err(_) => (String::from("INVALID"), log::Level::Error),
730        };
731        log::log!(level, "[R] [COM] {addr:04X} -> {ret:02X} {name}");
732
733        ret
734    }
735
736    fn common_reg_wr(&mut self, addr: u16, byte: u8) -> io::Result<()> {
737        let decoded = Reg::try_from(addr);
738
739        match decoded {
740            Ok(Reg::MR) => {
741                self.regs.mr = byte;
742                if byte & Mode::RST_MASK != 0 {
743                    self.reset()
744                }
745                let mode: Mode = byte.into();
746                if mode.wol_enabled() != Mode::default().wol_enabled() {
747                    log::warn!("[W] [COM] MR wake on lan bit unimplemented");
748                }
749                if mode.pb_enabled() != Mode::default().pb_enabled() {
750                    log::warn!("[W] [COM] MR ping block bit unimplemented");
751                }
752                if mode.pppoe_enabled() != Mode::default().pppoe_enabled() {
753                    log::warn!("[W] [COM] MR PPPoE bit unimplemented");
754                }
755                if mode.farp_enabled() != Mode::default().farp_enabled() {
756                    log::warn!("[W] [COM] MR force ARP bit unimplemented");
757                }
758            }
759            Ok(Reg::GAR0) => {
760                let [_, b, c, d] = self.regs.gar.octets();
761                self.regs.gar = Ipv4Addr::new(byte, b, c, d);
762            }
763            Ok(Reg::GAR1) => {
764                let [a, _, c, d] = self.regs.gar.octets();
765                self.regs.gar = Ipv4Addr::new(a, byte, c, d);
766            }
767            Ok(Reg::GAR2) => {
768                let [a, b, _, d] = self.regs.gar.octets();
769                self.regs.gar = Ipv4Addr::new(a, b, byte, d);
770            }
771            Ok(Reg::GAR3) => {
772                let [a, b, c, _] = self.regs.gar.octets();
773                self.regs.gar = Ipv4Addr::new(a, b, c, byte);
774            }
775            Ok(Reg::SUBR0) => {
776                let [_, b, c, d] = self.regs.subr.octets();
777                self.regs.subr = Ipv4Addr::new(byte, b, c, d);
778            }
779            Ok(Reg::SUBR1) => {
780                let [a, _, c, d] = self.regs.subr.octets();
781                self.regs.subr = Ipv4Addr::new(a, byte, c, d);
782            }
783            Ok(Reg::SUBR2) => {
784                let [a, b, _, d] = self.regs.subr.octets();
785                self.regs.subr = Ipv4Addr::new(a, b, byte, d);
786            }
787            Ok(Reg::SUBR3) => {
788                let [a, b, c, _] = self.regs.subr.octets();
789                self.regs.subr = Ipv4Addr::new(a, b, c, byte);
790            }
791            Ok(Reg::SHAR0) => self.regs.shar.octets[0] = byte,
792            Ok(Reg::SHAR1) => self.regs.shar.octets[1] = byte,
793            Ok(Reg::SHAR2) => self.regs.shar.octets[2] = byte,
794            Ok(Reg::SHAR3) => self.regs.shar.octets[3] = byte,
795            Ok(Reg::SHAR4) => self.regs.shar.octets[4] = byte,
796            Ok(Reg::SHAR5) => self.regs.shar.octets[5] = byte,
797            Ok(Reg::SIPR0) => {
798                let [_, b, c, d] = self.regs.sipr.octets();
799                self.regs.sipr = Ipv4Addr::new(byte, b, c, d);
800            }
801            Ok(Reg::SIPR1) => {
802                let [a, _, c, d] = self.regs.sipr.octets();
803                self.regs.sipr = Ipv4Addr::new(a, byte, c, d);
804            }
805            Ok(Reg::SIPR2) => {
806                let [a, b, _, d] = self.regs.sipr.octets();
807                self.regs.sipr = Ipv4Addr::new(a, b, byte, d);
808            }
809            Ok(Reg::SIPR3) => {
810                let [a, b, c, _] = self.regs.sipr.octets();
811                self.regs.sipr = Ipv4Addr::new(a, b, c, byte);
812            }
813            Ok(Reg::INTLEVEL0) => {
814                self.regs.intlevel &= 0x00FF;
815                self.regs.intlevel |= u16::from(byte) << 8;
816            }
817            Ok(Reg::INTLEVEL1) => {
818                self.regs.intlevel &= 0xFF00;
819                self.regs.intlevel |= u16::from(byte);
820            }
821            Ok(Reg::IR) => self.regs.ir = byte,
822            Ok(Reg::IMR) => self.regs.imr = byte,
823            Ok(Reg::SIR) => self.regs.sir = byte,
824            Ok(Reg::SIMR) => self.regs.simr = byte,
825            Ok(Reg::RTR0) => {
826                self.regs.rtr &= 0x00FF;
827                self.regs.rtr |= u16::from(byte) << 8;
828            }
829            Ok(Reg::RTR1) => {
830                self.regs.rtr &= 0xFF00;
831                self.regs.rtr |= u16::from(byte);
832            }
833            Ok(Reg::RCR) => self.regs.rcr = byte,
834            Ok(Reg::PTIMER) => self.regs.ptimer = byte,
835            Ok(Reg::PMAGIC) => self.regs.pmagic = byte,
836            Ok(Reg::PHAR0) => self.regs.phar.octets[0] = byte,
837            Ok(Reg::PHAR1) => self.regs.phar.octets[1] = byte,
838            Ok(Reg::PHAR2) => self.regs.phar.octets[2] = byte,
839            Ok(Reg::PHAR3) => self.regs.phar.octets[3] = byte,
840            Ok(Reg::PHAR4) => self.regs.phar.octets[4] = byte,
841            Ok(Reg::PHAR5) => self.regs.phar.octets[5] = byte,
842            Ok(Reg::PSID0) => {
843                self.regs.psid &= 0x00FF;
844                self.regs.psid |= u16::from(byte) << 8;
845            }
846            Ok(Reg::PSID1) => {
847                self.regs.psid &= 0xFF00;
848                self.regs.psid |= u16::from(byte);
849            }
850            Ok(Reg::PMRU0) => {
851                self.regs.pmru &= 0x00FF;
852                self.regs.pmru |= u16::from(byte) << 8;
853            }
854            Ok(Reg::PMRU1) => {
855                self.regs.pmru &= 0xFF00;
856                self.regs.pmru |= u16::from(byte);
857            }
858            Ok(Reg::UIPR0) => (),
859            Ok(Reg::UIPR1) => (),
860            Ok(Reg::UIPR2) => (),
861            Ok(Reg::UIPR3) => (),
862            Ok(Reg::UPORTR0) => (),
863            Ok(Reg::UPORTR1) => (),
864            Ok(Reg::PHYCFGR) => self.regs.phycfgr = byte,
865            Ok(Reg::VERSIONR) => (),
866            Err(_) => (),
867        };
868
869        let (name, level): (String, log::Level) = match decoded {
870            Ok(reg) => {
871                if reg.is_ro() {
872                    (format!("{reg:?} is read-only"), log::Level::Error)
873                } else {
874                    (format!("{reg:?}"), log::Level::Trace)
875                }
876            }
877            Err(_) => (String::from("INVALID"), log::Level::Error),
878        };
879
880        log::log!(level, "[W] [COM] {addr:04X} <- {byte:02X} {name}");
881
882        Ok(())
883    }
884
885    fn socket_reg_rd(&mut self, addr: u16, sn: Sn) -> io::Result<u8> {
886        let decoded = SnReg::try_from(addr);
887        let socket: &Socket = self.socket(sn);
888
889        let ret: u8 = match decoded {
890            Ok(SnReg::MR) => socket.regs.mr,
891            Ok(SnReg::CR) => socket.regs.cr,
892            Ok(SnReg::IR) => socket.regs.ir.into(),
893            Ok(SnReg::SR) => socket.regs.sr.into(),
894            Ok(SnReg::PORT0) => socket.regs.port.to_be_bytes()[0],
895            Ok(SnReg::PORT1) => socket.regs.port.to_be_bytes()[1],
896            Ok(SnReg::DHAR0) => socket.regs.dhar.octets[0],
897            Ok(SnReg::DHAR1) => socket.regs.dhar.octets[1],
898            Ok(SnReg::DHAR2) => socket.regs.dhar.octets[2],
899            Ok(SnReg::DHAR3) => socket.regs.dhar.octets[3],
900            Ok(SnReg::DHAR4) => socket.regs.dhar.octets[4],
901            Ok(SnReg::DHAR5) => socket.regs.dhar.octets[5],
902            Ok(SnReg::DIPR0) => socket.regs.dipr.octets()[0],
903            Ok(SnReg::DIPR1) => socket.regs.dipr.octets()[1],
904            Ok(SnReg::DIPR2) => socket.regs.dipr.octets()[2],
905            Ok(SnReg::DIPR3) => socket.regs.dipr.octets()[3],
906            Ok(SnReg::DPORT0) => socket.regs.dport.to_be_bytes()[0],
907            Ok(SnReg::DPORT1) => socket.regs.dport.to_be_bytes()[1],
908            Ok(SnReg::MSSR0) => socket.regs.mssr.to_be_bytes()[0],
909            Ok(SnReg::MSSR1) => socket.regs.mssr.to_be_bytes()[1],
910            Ok(SnReg::TOS) => socket.regs.tos,
911            Ok(SnReg::TTL) => socket.regs.ttl,
912            Ok(SnReg::RXBUF_SIZE) => socket.regs.rxbuf_size.into(),
913            Ok(SnReg::TXBUF_SIZE) => socket.regs.txbuf_size.into(),
914            Ok(SnReg::TX_FSR0) => socket.regs.tx_fsr.to_be_bytes()[0],
915            Ok(SnReg::TX_FSR1) => socket.regs.tx_fsr.to_be_bytes()[1],
916            Ok(SnReg::TX_RD0) => socket.regs.tx_rd.to_be_bytes()[0],
917            Ok(SnReg::TX_RD1) => socket.regs.tx_rd.to_be_bytes()[1],
918            Ok(SnReg::TX_WR0) => socket.regs.tx_wr.to_be_bytes()[0],
919            Ok(SnReg::TX_WR1) => socket.regs.tx_wr.to_be_bytes()[1],
920            Ok(SnReg::RX_RSR0) => socket.regs.rx_rsr.to_be_bytes()[0],
921            Ok(SnReg::RX_RSR1) => socket.regs.rx_rsr.to_be_bytes()[1],
922            Ok(SnReg::RX_RD0) => socket.regs.rx_rd.to_be_bytes()[0],
923            Ok(SnReg::RX_RD1) => socket.regs.rx_rd.to_be_bytes()[1],
924            Ok(SnReg::RX_WR0) => socket.regs.rx_wr.to_be_bytes()[0],
925            Ok(SnReg::RX_WR1) => socket.regs.rx_wr.to_be_bytes()[1],
926            Ok(SnReg::IMR) => socket.regs.imr,
927            Ok(SnReg::FRAG0) => socket.regs.frag.to_be_bytes()[0],
928            Ok(SnReg::FRAG1) => socket.regs.frag.to_be_bytes()[1],
929            Ok(SnReg::KPALVTR) => socket.regs.kpalvtr,
930            Err(_) => 0x00,
931        };
932
933        let (name, level): (String, log::Level) = match decoded {
934            Ok(reg) => (format!("{reg:?}"), log::Level::Trace),
935            Err(_) => (String::from("INVALID"), log::Level::Error),
936        };
937        log::log!(level, "[R] [{sn:?}] {addr:04X} -> {ret:02X} {name}");
938
939        if !matches!(decoded, Ok(SnReg::RX_RSR0)) {
940            self.check_socket(sn)?;
941        }
942
943        Ok(ret)
944    }
945
946    fn socket_reg_wr(&mut self, addr: u16, byte: u8, sn: Sn) -> io::Result<()> {
947        let decoded = SnReg::try_from(addr);
948        let socket: &mut Socket = self.socket_mut(sn);
949
950        match decoded {
951            Ok(SnReg::MR) => {
952                socket.regs.mr = byte;
953            }
954            Ok(SnReg::CR) => match SocketCommand::try_from(byte) {
955                Ok(SocketCommand::Open) => self.socket_cmd_open(sn)?,
956                Ok(SocketCommand::Connect) => self.socket_cmd_connect(sn)?,
957                Ok(SocketCommand::Close) => self.socket_cmd_close(sn),
958                Ok(SocketCommand::Send) => self.socket_cmd_send(sn)?,
959                Ok(SocketCommand::Recv) => self.socket_cmd_recv(sn)?,
960                Ok(SocketCommand::Listen) => self.socket_cmd_listen(sn)?,
961                cmd => unimplemented!("[W] [{sn:?}] command {cmd:?}"),
962            },
963            Ok(SnReg::IR) => {
964                let ir: SocketInterrupt = byte.into();
965
966                if socket.regs.ir.con_raised() & ir.con_raised() {
967                    log::debug!("[{sn:?}] clearing CON_MASK interrupt");
968                    socket.regs.ir = (!SocketInterrupt::CON_MASK & u8::from(socket.regs.ir)).into();
969                }
970                if socket.regs.ir.discon_raised() & ir.discon_raised() {
971                    log::debug!("[{sn:?}] clearing DISCON_MASK interrupt");
972                    socket.regs.ir =
973                        (!SocketInterrupt::DISCON_MASK & u8::from(socket.regs.ir)).into();
974                }
975                if socket.regs.ir.recv_raised() & ir.recv_raised() {
976                    log::debug!("[{sn:?}] clearing RECV_MASK interrupt");
977                    socket.regs.ir =
978                        (!SocketInterrupt::RECV_MASK & u8::from(socket.regs.ir)).into();
979                }
980                if socket.regs.ir.timeout_raised() & ir.timeout_raised() {
981                    log::debug!("[{sn:?}] clearing TIMEOUT_MASK interrupt");
982                    socket.regs.ir =
983                        (!SocketInterrupt::TIMEOUT_MASK & u8::from(socket.regs.ir)).into();
984                }
985                if socket.regs.ir.sendok_raised() & ir.sendok_raised() {
986                    log::debug!("[{sn:?}] clearing SENDOK_MASK interrupt");
987                    socket.regs.ir =
988                        (!SocketInterrupt::SENDOK_MASK & u8::from(socket.regs.ir)).into();
989                }
990
991                if u8::from(socket.regs.ir) & socket.regs.imr & 0x1F == 0 {
992                    self.regs.sir &= !sn.bitmask();
993                }
994            }
995            Ok(SnReg::SR) => (),
996            Ok(SnReg::PORT0) => {
997                socket.regs.port &= 0x00FF;
998                socket.regs.port |= u16::from(byte) << 8;
999            }
1000            Ok(SnReg::PORT1) => {
1001                socket.regs.port &= 0xFF00;
1002                socket.regs.port |= u16::from(byte);
1003            }
1004            Ok(SnReg::DHAR0) => socket.regs.dhar.octets[0] = byte,
1005            Ok(SnReg::DHAR1) => socket.regs.dhar.octets[1] = byte,
1006            Ok(SnReg::DHAR2) => socket.regs.dhar.octets[2] = byte,
1007            Ok(SnReg::DHAR3) => socket.regs.dhar.octets[3] = byte,
1008            Ok(SnReg::DHAR4) => socket.regs.dhar.octets[4] = byte,
1009            Ok(SnReg::DHAR5) => socket.regs.dhar.octets[5] = byte,
1010            Ok(SnReg::DIPR0) => {
1011                let [_, b, c, d] = socket.regs.dipr.octets();
1012                socket.regs.dipr = Ipv4Addr::new(byte, b, c, d);
1013            }
1014            Ok(SnReg::DIPR1) => {
1015                let [a, _, c, d] = socket.regs.dipr.octets();
1016                socket.regs.dipr = Ipv4Addr::new(a, byte, c, d);
1017            }
1018            Ok(SnReg::DIPR2) => {
1019                let [a, b, _, d] = socket.regs.dipr.octets();
1020                socket.regs.dipr = Ipv4Addr::new(a, b, byte, d);
1021            }
1022            Ok(SnReg::DIPR3) => {
1023                let [a, b, c, _] = socket.regs.dipr.octets();
1024                socket.regs.dipr = Ipv4Addr::new(a, b, c, byte);
1025            }
1026            Ok(SnReg::DPORT0) => {
1027                socket.regs.dport &= 0x00FF;
1028                socket.regs.dport |= u16::from(byte) << 8;
1029            }
1030            Ok(SnReg::DPORT1) => {
1031                socket.regs.dport &= 0xFF00;
1032                socket.regs.dport |= u16::from(byte);
1033            }
1034            Ok(SnReg::MSSR0) => todo!(),
1035            Ok(SnReg::MSSR1) => todo!(),
1036            Ok(SnReg::TOS) => todo!(),
1037            Ok(SnReg::TTL) => socket.regs.ttl = byte,
1038            Ok(SnReg::RXBUF_SIZE) => {
1039                socket.regs.rxbuf_size = match BufferSize::try_from(byte) {
1040                    Ok(bs) => {
1041                        socket.rx_buf.resize(bs.size_in_bytes(), 0);
1042                        bs
1043                    }
1044                    Err(e) => panic!("RX buffer size of {e:#02X} is invalid"),
1045                }
1046            }
1047            Ok(SnReg::TXBUF_SIZE) => {
1048                socket.regs.txbuf_size = match BufferSize::try_from(byte) {
1049                    Ok(bs) => {
1050                        socket.tx_buf.resize(bs.size_in_bytes(), 0);
1051                        bs
1052                    }
1053                    Err(e) => panic!("TX buffer size of {e:#02X} is invalid"),
1054                }
1055            }
1056            Ok(SnReg::TX_FSR0) => (),
1057            Ok(SnReg::TX_FSR1) => (),
1058            Ok(SnReg::TX_RD0) => (),
1059            Ok(SnReg::TX_RD1) => (),
1060            Ok(SnReg::TX_WR0) => {
1061                socket.regs.tx_wr &= 0x00FF;
1062                socket.regs.tx_wr |= u16::from(byte) << 8;
1063            }
1064            Ok(SnReg::TX_WR1) => {
1065                socket.regs.tx_wr &= 0xFF00;
1066                socket.regs.tx_wr |= u16::from(byte);
1067            }
1068            Ok(SnReg::RX_RSR0) => (),
1069            Ok(SnReg::RX_RSR1) => (),
1070            Ok(SnReg::RX_RD0) => {
1071                socket.regs.rx_rd &= 0x00FF;
1072                socket.regs.rx_rd |= u16::from(byte) << 8;
1073            }
1074            Ok(SnReg::RX_RD1) => {
1075                socket.regs.rx_rd &= 0xFF00;
1076                socket.regs.rx_rd |= u16::from(byte);
1077            }
1078            Ok(SnReg::RX_WR0) => todo!(),
1079            Ok(SnReg::RX_WR1) => todo!(),
1080            Ok(SnReg::IMR) => socket.regs.imr = byte,
1081            Ok(SnReg::FRAG0) => todo!(),
1082            Ok(SnReg::FRAG1) => todo!(),
1083            Ok(SnReg::KPALVTR) => todo!(),
1084            Err(_) => (),
1085        }
1086
1087        let (name, level): (String, log::Level) = match decoded {
1088            Ok(reg) => {
1089                if reg.is_ro() {
1090                    (format!("{reg:?} is read-only"), log::Level::Error)
1091                } else {
1092                    (format!("{reg:?}"), log::Level::Trace)
1093                }
1094            }
1095            Err(_) => (String::from("INVALID"), log::Level::Error),
1096        };
1097
1098        log::log!(level, "[W] [{sn:?}] {addr:04X} <- {byte:02X} {name}");
1099
1100        Ok(())
1101    }
1102}
1103
1104impl Default for W5500 {
1105    fn default() -> Self {
1106        Self {
1107            regs: CommonRegs::RESET,
1108            sn: Default::default(),
1109            socket_buffer_logging: true,
1110            corpus: None,
1111        }
1112    }
1113}
1114
1115impl Registers for W5500 {
1116    type Error = std::io::ErrorKind;
1117
1118    fn read(&mut self, addr: u16, block: u8, data: &mut [u8]) -> Result<(), Self::Error> {
1119        let mut addr: u16 = addr;
1120
1121        match block_type(block) {
1122            BlockType::Common => {
1123                data.iter_mut().for_each(|byte| {
1124                    *byte = self.common_reg_rd(addr);
1125                    self.log_byte(*byte);
1126                    addr = addr.wrapping_add(1);
1127                });
1128                Ok(())
1129            }
1130            BlockType::Socket(sn) => {
1131                for byte in data.iter_mut() {
1132                    *byte = self.socket_reg_rd(addr, sn).map_err(|e| e.kind())?;
1133                    self.log_byte(*byte);
1134                    addr = addr.wrapping_add(1);
1135                }
1136                Ok(())
1137            }
1138            BlockType::Rx(sn) => {
1139                data.iter_mut().for_each(|byte| {
1140                    let buf_size: usize = self.sn[usize::from(sn)].rx_buf.len();
1141                    *byte = self.sn[usize::from(sn)].rx_buf[usize::from(addr) % buf_size];
1142                    self.log_byte(*byte);
1143                    if self.socket_buffer_logging {
1144                        log::trace!("[R] [RXB] {addr:04X} -> {:02X}", *byte);
1145                    }
1146                    addr = addr.wrapping_add(1);
1147                });
1148                Ok(())
1149            }
1150            BlockType::Tx(sn) => {
1151                data.iter_mut().for_each(|byte| {
1152                    let buf_size: usize = self.sn[usize::from(sn)].tx_buf.len();
1153                    *byte = self.sn[usize::from(sn)].tx_buf[usize::from(addr) % buf_size];
1154                    self.log_byte(*byte);
1155                    if self.socket_buffer_logging {
1156                        log::trace!("[R] [TXB] {addr:04X} -> {:02X}", *byte);
1157                    }
1158                    addr = addr.wrapping_add(1);
1159                });
1160                Ok(())
1161            }
1162        }
1163    }
1164
1165    /// Write to the W5500.
1166    fn write(&mut self, addr: u16, block: u8, data: &[u8]) -> Result<(), Self::Error> {
1167        let mut addr: u16 = addr;
1168
1169        match block_type(block) {
1170            BlockType::Common => {
1171                for byte in data {
1172                    self.common_reg_wr(addr, *byte).map_err(|e| e.kind())?;
1173                    addr = addr.wrapping_add(1);
1174                }
1175                Ok(())
1176            }
1177            BlockType::Socket(sn) => {
1178                for byte in data {
1179                    self.socket_reg_wr(addr, *byte, sn).map_err(|e| e.kind())?;
1180                    addr = addr.wrapping_add(1);
1181                }
1182                Ok(())
1183            }
1184            BlockType::Rx(sn) => {
1185                data.iter().for_each(|byte| {
1186                    if self.socket_buffer_logging {
1187                        log::trace!("[W] [RXB] {addr:04X} <- {:02X}", *byte);
1188                    }
1189                    let buf_size: usize = self.sn[usize::from(sn)].rx_buf.len();
1190                    self.sn[usize::from(sn)].rx_buf[usize::from(addr) % buf_size] = *byte;
1191                    addr = addr.wrapping_add(1);
1192                });
1193                Ok(())
1194            }
1195            BlockType::Tx(sn) => {
1196                data.iter().for_each(|byte| {
1197                    if self.socket_buffer_logging {
1198                        log::trace!("[W] [TXB] {addr:04X} <- {:02X}", *byte);
1199                    }
1200                    let buf_size: usize = self.sn[usize::from(sn)].tx_buf.len();
1201                    self.sn[usize::from(sn)].tx_buf[usize::from(addr) % buf_size] = *byte;
1202                    addr = addr.wrapping_add(1);
1203                });
1204                Ok(())
1205            }
1206        }
1207    }
1208}
1209
1210impl w5500_ll::aio::Registers for W5500 {
1211    type Error = std::io::ErrorKind;
1212
1213    async fn read(&mut self, address: u16, block: u8, data: &mut [u8]) -> Result<(), Self::Error> {
1214        w5500_ll::Registers::read(self, address, block, data)
1215    }
1216
1217    async fn write(&mut self, address: u16, block: u8, data: &[u8]) -> Result<(), Self::Error> {
1218        w5500_ll::Registers::write(self, address, block, data)
1219    }
1220}
w5500_regsim/lib.rs

w5500_regsim/
lib.rs
