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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
use super::pipe::{DataBuf, PipeErr, PipeTable};
use super::usbproto::*;
use core::convert::TryInto;
use log::{debug, error, trace};
// FIXME: once again, this doesn't belong here. The issue is that
// we're using `pipe_for`, which requires it.
use atsamd_hal::target_device::usb;
const MAX_DEVICES: usize = 16;
const MAX_ENDPOINTS: usize = 8;
// How long to wait before talking to the device again after setting
// its address. cf §9.2.6.3 of USB 2.0
const SETTLE_DELAY: usize = 300;
#[derive(Copy, Clone, Debug, PartialEq)]
pub(crate) enum Error {
PipeErr(PipeErr),
}
impl From<PipeErr> for Error {
fn from(e: PipeErr) -> Self {
Self::PipeErr(e)
}
}
enum FSM {
AddressSet,
WaitForSettle(usize),
GetConfigDescriptor,
SetConfig,
Steady,
}
pub(crate) struct DeviceTable {
devices: [Option<Device>; MAX_DEVICES],
}
// TODO: Untie device address from table index. Right now it's wasting
// a table slot because addr 0 isn't used here. And rather than just
// putting in an offset, which can be forgotten, it's better to let
// something else handle address assignment.
impl DeviceTable {
pub(crate) fn new() -> Self {
// TODO: should we create addr 0 here for use during
// enumeration? Probably.
Self {
devices: Default::default(),
}
}
/// Return the device at address `addr`.
pub(crate) fn device_for(&mut self, addr: u8) -> Option<&mut Device> {
if let Some(ref mut d) = self.devices[addr as usize] {
Some(d)
} else {
None
}
}
/// Allocate a device with the next available address.
// TODO: get rid of the millis argument somehow, but the device
// does need a way of tracking time for Settle reasons.
pub(crate) fn next(&mut self, millis: &'static dyn Fn() -> usize) -> Option<&mut Device> {
for i in 1..self.devices.len() {
if self.devices[i].is_none() {
let a = i.try_into().unwrap();
let d = Device::new(a, millis);
self.devices[i] = Some(d);
return self.device_for(a);
}
}
None
}
/// Remove the device at address `addr`.
pub(crate) fn remove(&mut self, addr: u8) -> Option<Device> {
let v = core::mem::replace(&mut self.devices[addr as usize], None);
v
}
pub(crate) fn run(&mut self, pipe_table: &mut PipeTable, host: &mut usb::HOST) {
for i in 1..self.devices.len() {
// TODO: Woof, this is ugly, but I'm not sure of a better
// way to avoid mutably borrowing self twice.
let mut remove_addr: Option<u8> = None;
if let Some(ref mut d) = self.devices[i] {
if let Err(e) = d.fsm(pipe_table, host) {
error!("Removing device {}: {:?}", d.addr, e);
remove_addr = Some(d.addr);
} else {
remove_addr = None;
}
}
if let Some(addr) = remove_addr {
self.remove(addr);
}
}
}
}
pub struct Device {
pub addr: u8,
pub max_packet_size: u8,
pub endpoints: [Option<Endpoint>; MAX_ENDPOINTS],
state: FSM,
millis: &'static dyn Fn() -> usize,
}
impl Device {
fn new(addr: u8, millis: &'static dyn Fn() -> usize) -> Self {
Self {
addr: addr,
max_packet_size: 8,
endpoints: Default::default(),
state: FSM::AddressSet,
// TODO: This doesn't belong here. Ideally the current
// time is passed in to the FSM routine.
millis: millis,
}
}
}
impl Device {
pub(crate) fn fsm(
&mut self,
pipe_table: &mut PipeTable,
host: &mut usb::HOST,
) -> Result<(), Error> {
match self.state {
FSM::AddressSet => self.state = FSM::WaitForSettle((self.millis)() + SETTLE_DELAY),
FSM::WaitForSettle(until) => {
if (self.millis)() >= until {
// Dunno why we get the device descriptor a second time.
let mut pipe = pipe_table.pipe_for(host, self.addr, 0);
let mut vol_descr =
::vcell::VolatileCell::<USBDeviceDescriptor>::new(Default::default());
pipe.control_req(
BMRequestType::get_descr(),
USBRequest::GetDescriptor,
WValue::from((0, USBDescriptor::Device as u8)),
0,
Some(DataBuf::from(&mut vol_descr)),
self.millis,
)?;
let desc = vol_descr.get();
trace!(" -- devDesc: {:?}", desc);
self.state = FSM::GetConfigDescriptor
}
}
FSM::GetConfigDescriptor => {
// Get config descriptor with minimal data, to see how much we need to allocate for the full descriptor.
let mut pipe = pipe_table.pipe_for(host, self.addr, 0);
let mut vol_descr =
::vcell::VolatileCell::<USBConfigurationDescriptor>::new(Default::default());
pipe.control_req(
BMRequestType::get_descr(),
USBRequest::GetDescriptor,
WValue::from((0, USBDescriptor::Configuration as u8)),
0,
Some(DataBuf::from(&mut vol_descr)),
self.millis,
)?;
let desc = vol_descr.get();
debug!("config: {:?}", desc);
// TODO: do real allocation later.
assert!(desc.w_total_length < 64);
let buf: [u8; 64] = [0; 64];
let mut tmp = &buf[..desc.w_total_length as usize];
pipe.control_req(
BMRequestType::get_descr(),
USBRequest::GetDescriptor,
WValue::from((0, USBDescriptor::Configuration as u8)),
0,
Some(DataBuf::from(&mut tmp)),
self.millis,
)?;
self.state = FSM::SetConfig
}
FSM::SetConfig => {
let mut pipe = pipe_table.pipe_for(host, self.addr, 0);
debug!("+++ setting configuration");
let conf: u8 = 1;
pipe.control_req(
BMRequestType::set(),
USBRequest::SetConfiguration,
WValue::from((conf, 0)),
0,
None,
self.millis,
)?;
debug!(" -- configuration set");
self.state = FSM::Steady
}
FSM::Steady => {
// Now we should be able to access it normally.
}
}
Ok(())
}
}
pub struct Endpoint {
num: u8,
typ: EndpointType,
}
impl Default for Endpoint {
fn default() -> Self {
Self {
num: 0,
typ: EndpointType::Control,
}
}
}
enum EndpointType {
Control,
In,
Out,
}
|
