mirror of
https://github.com/ferrous-systems/embedded-trainings-2020.git
synced 2024-10-31 22:28:49 +00:00
192 lines
6.9 KiB
Rust
192 lines
6.9 KiB
Rust
#![no_main]
|
|
#![no_std]
|
|
|
|
// this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
|
|
use firmware as _;
|
|
|
|
#[rtic::app(device = dk, peripherals = false)]
|
|
mod app {
|
|
|
|
use core::num::NonZeroU8;
|
|
|
|
use dk::{
|
|
peripheral::USBD,
|
|
usbd::{self, Ep0In, Event},
|
|
Peripherals,
|
|
};
|
|
use usb2::{GetDescriptor as Descriptor, StandardRequest as Request, State};
|
|
|
|
#[local]
|
|
struct MyLocalResources {
|
|
usbd: USBD,
|
|
ep0in: Ep0In,
|
|
state: State,
|
|
}
|
|
|
|
#[shared]
|
|
struct MySharedResources {
|
|
|
|
}
|
|
#[init]
|
|
fn init(_cx: init::Context) -> (MySharedResources, MyLocalResources, init::Monotonics) {
|
|
let board = dk::init().unwrap();
|
|
|
|
usbd::init(board.power, &board.usbd);
|
|
|
|
(MySharedResources {}, MyLocalResources { usbd: board.usbd, ep0in: board.ep0in, state: State::Default, }, init::Monotonics())
|
|
}
|
|
|
|
#[task(binds = USBD, local = [usbd, ep0in, state])]
|
|
fn main(cx: main::Context) {
|
|
let usbd = cx.local.usbd;
|
|
let ep0in = cx.local.ep0in;
|
|
let state = cx.local.state;
|
|
|
|
while let Some(event) = usbd::next_event(usbd) {
|
|
on_event(usbd, ep0in, state, event)
|
|
}
|
|
}
|
|
fn on_event(usbd: &USBD, ep0in: &mut Ep0In, state: &mut State, event: Event) {
|
|
defmt::println!("USB: {:?} @ {:?}", event, dk::uptime());
|
|
|
|
match event {
|
|
Event::UsbReset => {
|
|
defmt::println!("USB reset condition detected");
|
|
*state = State::Default;
|
|
}
|
|
|
|
Event::UsbEp0DataDone => {
|
|
defmt::println!("EP0IN: transfer complete");
|
|
ep0in.end(usbd);
|
|
}
|
|
|
|
Event::UsbEp0Setup => {
|
|
if ep0setup(usbd, ep0in, state).is_err() {
|
|
defmt::warn!("EP0IN: unexpected request; stalling the endpoint");
|
|
usbd::ep0stall(usbd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The `bConfigurationValue` of the only supported configuration
|
|
const CONFIG_VAL: u8 = 42;
|
|
|
|
fn ep0setup(usbd: &USBD, ep0in: &mut Ep0In, state: &mut State) -> Result<(), ()> {
|
|
let bmrequesttype = usbd.bmrequesttype.read().bits() as u8;
|
|
let brequest = usbd.brequest.read().brequest().bits();
|
|
let wlength = usbd::wlength(usbd);
|
|
let windex = usbd::windex(usbd);
|
|
let wvalue = usbd::wvalue(usbd);
|
|
|
|
defmt::println!(
|
|
"bmrequesttype: {}, brequest: {}, wlength: {}, windex: {}, wvalue: {}",
|
|
bmrequesttype,
|
|
brequest,
|
|
wlength,
|
|
windex,
|
|
wvalue
|
|
);
|
|
|
|
let request = Request::parse(bmrequesttype, brequest, wvalue, windex, wlength)
|
|
.expect("Error parsing request");
|
|
defmt::println!("EP0: {:?}", defmt::Debug2Format(&request));
|
|
// ^^^^^^^^^^^^^^^^^^^ this adapter is currently needed to log
|
|
// `StandardRequest` with `defmt`
|
|
match request {
|
|
// section 9.4.3
|
|
// this request is valid in any state
|
|
Request::GetDescriptor { descriptor, length } => match descriptor {
|
|
Descriptor::Device => {
|
|
let desc = usb2::device::Descriptor {
|
|
bDeviceClass: 0,
|
|
bDeviceProtocol: 0,
|
|
bDeviceSubClass: 0,
|
|
bMaxPacketSize0: usb2::device::bMaxPacketSize0::B64,
|
|
bNumConfigurations: core::num::NonZeroU8::new(1).unwrap(),
|
|
bcdDevice: 0x01_00, // 1.00
|
|
iManufacturer: None,
|
|
iProduct: None,
|
|
iSerialNumber: None,
|
|
idProduct: consts::PID,
|
|
idVendor: consts::VID,
|
|
};
|
|
let bytes = desc.bytes();
|
|
let _ = ep0in.start(&bytes[..core::cmp::min(bytes.len(), length.into())], usbd);
|
|
}
|
|
|
|
Descriptor::Configuration { index } => {
|
|
if index == 0 {
|
|
let mut resp = heapless::Vec::<u8, 64>::new();
|
|
|
|
let conf_desc = usb2::configuration::Descriptor {
|
|
wTotalLength: (usb2::configuration::Descriptor::SIZE
|
|
+ usb2::interface::Descriptor::SIZE)
|
|
.into(),
|
|
bNumInterfaces: NonZeroU8::new(1).unwrap(),
|
|
bConfigurationValue: core::num::NonZeroU8::new(CONFIG_VAL).unwrap(),
|
|
iConfiguration: None,
|
|
bmAttributes: usb2::configuration::bmAttributes {
|
|
self_powered: true,
|
|
remote_wakeup: false,
|
|
},
|
|
bMaxPower: 250, // 500 mA
|
|
};
|
|
|
|
let iface_desc = usb2::interface::Descriptor {
|
|
bInterfaceNumber: 0,
|
|
bAlternativeSetting: 0,
|
|
bNumEndpoints: 0,
|
|
bInterfaceClass: 0,
|
|
bInterfaceSubClass: 0,
|
|
bInterfaceProtocol: 0,
|
|
iInterface: None,
|
|
};
|
|
|
|
resp.extend_from_slice(&conf_desc.bytes()).unwrap();
|
|
resp.extend_from_slice(&iface_desc.bytes()).unwrap();
|
|
ep0in.start(&resp[..core::cmp::min(resp.len(), length.into())], usbd);
|
|
} else {
|
|
// out of bounds access: stall the endpoint
|
|
return Err(());
|
|
}
|
|
}
|
|
|
|
_ => return Err(()),
|
|
},
|
|
|
|
Request::SetAddress { address } => {
|
|
match state {
|
|
State::Default => {
|
|
if let Some(address) = address {
|
|
*state = State::Address(address);
|
|
} else {
|
|
// stay in the default state
|
|
}
|
|
}
|
|
|
|
State::Address(..) => {
|
|
if let Some(address) = address {
|
|
// use the new address
|
|
*state = State::Address(address);
|
|
} else {
|
|
*state = State::Default;
|
|
}
|
|
}
|
|
|
|
// unspecified behavior
|
|
State::Configured { .. } => return Err(()),
|
|
}
|
|
|
|
// the response to this request is handled in hardware
|
|
}
|
|
|
|
// stall any other request
|
|
_ => return Err(()),
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
}
|
|
|