musb 0.2.0

musb(Mentor USB) regs and `embassy-usb-driver`, `usb-device` impl
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

use super::*;

/// USB endpoint.
pub struct Endpoint<'d, T: MusbInstance, D> {
    pub(super) _phantom: PhantomData<(&'d mut T, D)>,
    pub(super) info: EndpointInfo,
}

// impl<'d, T: MusbInstance, > driver::Endpoint for Endpoint<'d, T, In> {
impl<'d, T: MusbInstance, D: Dir> driver::Endpoint for Endpoint<'d, T, D> {
    fn info(&self) -> &EndpointInfo {
        &self.info
    }

    async fn wait_enabled(&mut self) {
        let _ = poll_fn(|cx| {
            let index = self.info.addr.index();

            let enabled = match self.info.addr.direction() {
                Direction::Out => {
                    EP_RX_WAKERS[index].register(cx.waker());
                    EP_RX_ENABLED.load(Ordering::Acquire) & ((1 << index) as u16) != 0
                },
                Direction::In => {
                    EP_TX_WAKERS[index].register(cx.waker());
                    EP_TX_ENABLED.load(Ordering::Acquire) & ((1 << index) as u16) != 0
                }
            };
            if enabled {
                Poll::Ready(())
            } else {
                Poll::Pending
            }
        })
        .await;
        trace!("Endpoint {:#X} wait enabled OK", self.info.addr);
    }
}

impl<'d, T: MusbInstance> driver::EndpointOut for Endpoint<'d, T, Out> {
    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, EndpointError> {
        trace!("READ WAITING, buf.len() = {}", buf.len());
        let index = self.info.addr.index();
        let regs = T::regs();

        let _ = poll_fn(|cx| {
            EP_RX_WAKERS[index].register(cx.waker());
            regs.index().write(|w| w.set_index(index as _));
            let ready = regs.rxcsrl().read().rx_pkt_rdy();

            if ready {
                Poll::Ready(())
            } else {
                Poll::Pending
            }
        })
        .await;

        regs.index().write(|w| w.set_index(index as _));

        let read_count = regs.rxcount().read().count();
        
        if read_count as usize > buf.len() {
            return Err(EndpointError::BufferOverflow);
        }

        buf.into_iter().take(read_count as _).for_each(|b|
            *b = regs.fifo(index).read().data()

        );
        regs.rxcsrl().modify(|w| w.set_rx_pkt_rdy(false));
        trace!("READ OK, rx_len = {}", read_count);

        Ok(read_count as usize)
    }
}

impl<'d, T: MusbInstance> driver::EndpointIn for Endpoint<'d, T, In> {
    async fn write(&mut self, buf: &[u8]) -> Result<(), EndpointError> {
        if buf.len() > self.info.max_packet_size as usize {
            return Err(EndpointError::BufferOverflow);
        }

        let index = self.info.addr.index();
        let regs = T::regs();

        trace!("WRITE WAITING len = {}", buf.len());

        let _ = poll_fn(|cx| {
            EP_TX_WAKERS[index].register(cx.waker());
            regs.index().write(|w| w.set_index(index as _));

            let unready = regs.txcsrl().read().tx_pkt_rdy();

            if unready {
                Poll::Pending
            } else {
                Poll::Ready(())
            }
        })
        .await;

        regs.index().write(|w| w.set_index(index as _));


        buf.into_iter().for_each(|b|
            regs.fifo(index).write(|w| w.set_data(*b))

        );

        regs.txcsrl().modify(|w| w.set_tx_pkt_rdy(true));
        trace!("WRITE OK");

        Ok(())
    }
}