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
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

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

#[derive(Clone, Copy, PartialEq)]
pub enum TransferStatus {
    Pending,
    Active,
    Completed,
    Stalled,
    Error,
}

#[derive(Clone, Copy, PartialEq)]
pub enum SetupDirection {
    HostToDevice,
    DeviceToHost,
}

#[derive(Clone, Copy)]
pub struct SetupPacket {
    pub request_type: u8,
    pub request: u8,
    pub value: u16,
    pub index: u16,
    pub length: u16,
}

impl SetupPacket {
    pub const fn new(request_type: u8, request: u8, value: u16, index: u16, length: u16) -> Self {
        SetupPacket {
            request_type,
            request,
            value,
            index,
            length,
        }
    }

    pub fn direction(&self) -> SetupDirection {
        if self.request_type & 0x80 != 0 {
            SetupDirection::DeviceToHost
        } else {
            SetupDirection::HostToDevice
        }
    }

    pub fn get_descriptor(desc_type: u8, index: u8, length: u16) -> Self {
        SetupPacket::new(
            0x80,
            0x06,
            ((desc_type as u16) << 8) | index as u16,
            0,
            length,
        )
    }

    pub fn set_address(addr: u8) -> Self {
        SetupPacket::new(0x00, 0x05, addr as u16, 0, 0)
    }

    pub fn set_configuration(config: u8) -> Self {
        SetupPacket::new(0x00, 0x09, config as u16, 0, 0)
    }

    pub fn to_bytes(&self) -> [u8; 8] {
        let v = self.value.to_le_bytes();
        let i = self.index.to_le_bytes();
        let l = self.length.to_le_bytes();
        [
            self.request_type,
            self.request,
            v[0],
            v[1],
            i[0],
            i[1],
            l[0],
            l[1],
        ]
    }
}

pub struct Transfer {
    pub transfer_type: TransferType,
    pub endpoint: u8,
    pub buffer_addr: usize,
    pub buffer_len: usize,
    pub status: TransferStatus,
    pub actual_len: usize,
}

impl Transfer {
    pub fn control(endpoint: u8, buffer_addr: usize, buffer_len: usize) -> Self {
        Transfer {
            transfer_type: TransferType::Control,
            endpoint,
            buffer_addr,
            buffer_len,
            status: TransferStatus::Pending,
            actual_len: 0,
        }
    }

    pub fn bulk(endpoint: u8, buffer_addr: usize, buffer_len: usize) -> Self {
        Transfer {
            transfer_type: TransferType::Bulk,
            endpoint,
            buffer_addr,
            buffer_len,
            status: TransferStatus::Pending,
            actual_len: 0,
        }
    }

    pub fn interrupt(endpoint: u8, buffer_addr: usize, buffer_len: usize) -> Self {
        Transfer {
            transfer_type: TransferType::Interrupt,
            endpoint,
            buffer_addr,
            buffer_len,
            status: TransferStatus::Pending,
            actual_len: 0,
        }
    }

    pub fn is_complete(&self) -> bool {
        matches!(
            self.status,
            TransferStatus::Completed | TransferStatus::Stalled | TransferStatus::Error
        )
    }
}