hardware 0.0.9

A no_std bare-metal hardware abstraction layer — all port I/O, memory and swap allocations are guarded at runtime. Do not consider this dependency stable before x.1.x
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

#[derive(Clone, Copy, PartialEq)]
pub enum EndpointType {
    Control,
    Bulk,
    Interrupt,
    Isochronous,
}

#[derive(Clone, Copy, PartialEq)]
pub enum Direction {
    In,
    Out,
}

#[derive(Clone, Copy)]
pub struct EndpointDescriptor {
    pub address: u8,
    pub ep_type: EndpointType,
    pub direction: Direction,
    pub max_packet_size: u16,
    pub interval: u8,
}

impl EndpointDescriptor {
    pub fn number(&self) -> u8 {
        self.address & 0x0F
    }

    pub fn from_raw(data: &[u8]) -> Option<Self> {
        if data.len() < 7 || data[1] != 0x05 {
            return None;
        }
        let address = data[2];
        let direction = if address & 0x80 != 0 {
            Direction::In
        } else {
            Direction::Out
        };
        let attr = data[3];
        let ep_type = match attr & 0x03 {
            0 => EndpointType::Control,
            1 => EndpointType::Isochronous,
            2 => EndpointType::Bulk,
            3 => EndpointType::Interrupt,
            _ => return None,
        };
        let max_packet_size = u16::from_le_bytes([data[4], data[5]]);
        let interval = data[6];
        Some(EndpointDescriptor {
            address,
            ep_type,
            direction,
            max_packet_size,
            interval,
        })
    }
}