230 lines
6.4 KiB
Rust
230 lines
6.4 KiB
Rust
#![no_std]
|
|
#![no_main]
|
|
|
|
extern crate alloc;
|
|
|
|
use core::{cmp, str};
|
|
use log::{info, warn};
|
|
use alloc::vec;
|
|
|
|
use libcortex_a9::{asm, cache};
|
|
use libboard_zynq::{
|
|
eth::Eth,
|
|
smoltcp::{
|
|
self,
|
|
iface::{EthernetInterfaceBuilder, NeighborCache},
|
|
time::Instant,
|
|
wire::IpCidr,
|
|
},
|
|
timer::GlobalTimer,
|
|
logger,
|
|
slcr
|
|
};
|
|
use libconfig::{net_settings, Config};
|
|
use libsupport_zynq::ram;
|
|
use libregister::RegisterW;
|
|
|
|
#[path = "../../../build/pl.rs"]
|
|
mod pl;
|
|
|
|
fn init_gateware() {
|
|
// Set up PS->PL clocks
|
|
slcr::RegisterBlock::unlocked(|slcr| {
|
|
// As we are touching the mux, the clock may glitch, so reset the PL.
|
|
slcr.fpga_rst_ctrl.write(
|
|
slcr::FpgaRstCtrl::zeroed()
|
|
.fpga0_out_rst(true)
|
|
.fpga1_out_rst(true)
|
|
.fpga2_out_rst(true)
|
|
.fpga3_out_rst(true)
|
|
);
|
|
slcr.fpga0_clk_ctrl.write(
|
|
slcr::Fpga0ClkCtrl::zeroed()
|
|
.src_sel(slcr::PllSource::IoPll)
|
|
.divisor0(8)
|
|
.divisor1(1)
|
|
);
|
|
slcr.fpga_rst_ctrl.write(
|
|
slcr::FpgaRstCtrl::zeroed()
|
|
);
|
|
});
|
|
}
|
|
|
|
fn identifier_read(buf: &mut [u8]) -> &str {
|
|
unsafe {
|
|
pl::csr::identifier::address_write(0);
|
|
let len = pl::csr::identifier::data_read();
|
|
let len = cmp::min(len, buf.len() as u8);
|
|
for i in 0..len {
|
|
pl::csr::identifier::address_write(1 + i);
|
|
buf[i as usize] = pl::csr::identifier::data_read();
|
|
}
|
|
str::from_utf8_unchecked(&buf[..len as usize])
|
|
}
|
|
}
|
|
|
|
|
|
const BUFFER_SIZE: usize = 300*1024*1024;
|
|
|
|
#[repr(C, align(128))]
|
|
struct DmaBuffer {
|
|
data: [u8; BUFFER_SIZE],
|
|
}
|
|
|
|
static mut BUFFER: DmaBuffer = DmaBuffer { data: [0; BUFFER_SIZE] };
|
|
|
|
|
|
fn start_sampling() {
|
|
unsafe {
|
|
let base_addr = &mut BUFFER.data[0] as *mut _ as usize;
|
|
pl::csr::adc::base_address_write(base_addr as u32);
|
|
pl::csr::adc::length_write(BUFFER_SIZE as u32);
|
|
|
|
cache::dcci_slice(&BUFFER.data);
|
|
pl::csr::adc::start_write(1);
|
|
}
|
|
}
|
|
|
|
fn sampling_done() -> bool {
|
|
unsafe {
|
|
let busy = pl::csr::adc::busy_read();
|
|
if busy == 0 {
|
|
info!("done, bus_error={}, overflow={}",
|
|
pl::csr::adc::bus_error_read(), pl::csr::adc::overflow_read());
|
|
cache::dcci_slice(&BUFFER.data);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq)]
|
|
enum State {
|
|
Idle,
|
|
Sampling,
|
|
SamplingAbort,
|
|
Transfer(usize)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub fn main_core0() {
|
|
GlobalTimer::start();
|
|
logger::init().unwrap();
|
|
log::set_max_level(log::LevelFilter::Info);
|
|
|
|
info!("Rust Pitaya firmware starting...");
|
|
|
|
ram::init_alloc_core0();
|
|
|
|
init_gateware();
|
|
info!("detected gateware: {}", identifier_read(&mut [0; 64]));
|
|
|
|
let cfg = match Config::new() {
|
|
Ok(cfg) => cfg,
|
|
Err(err) => {
|
|
warn!("config initialization failed: {}", err);
|
|
Config::new_dummy()
|
|
}
|
|
};
|
|
|
|
let net_addresses = net_settings::get_addresses(&cfg);
|
|
log::info!("Network addresses: {}", net_addresses);
|
|
let eth = Eth::eth0(net_addresses.hardware_addr.0.clone());
|
|
let eth = eth.start_rx(8);
|
|
let mut eth = eth.start_tx(8);
|
|
|
|
let mut neighbor_map = [None; 2];
|
|
let neighbor_cache = NeighborCache::new(&mut neighbor_map[..]);
|
|
let mut ip_addrs = [IpCidr::new(net_addresses.ipv4_addr, 0)];
|
|
let mut interface = EthernetInterfaceBuilder::new(&mut eth)
|
|
.ethernet_addr(net_addresses.hardware_addr)
|
|
.ip_addrs(&mut ip_addrs[..])
|
|
.neighbor_cache(neighbor_cache)
|
|
.finalize();
|
|
|
|
let mut rx_storage = vec![0; 64];
|
|
let mut tx_storage = vec![0; 4096];
|
|
|
|
let mut socket_set_entries: [_; 1] = Default::default();
|
|
let mut sockets = smoltcp::socket::SocketSet::new(&mut socket_set_entries[..]);
|
|
|
|
let tcp_rx_buffer = smoltcp::socket::TcpSocketBuffer::new(&mut rx_storage[..]);
|
|
let tcp_tx_buffer = smoltcp::socket::TcpSocketBuffer::new(&mut tx_storage[..]);
|
|
let tcp_socket = smoltcp::socket::TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
|
|
let tcp_handle = sockets.add(tcp_socket);
|
|
|
|
let timer = unsafe { GlobalTimer::get() };
|
|
let mut state = State::Idle;
|
|
|
|
log::info!("Waiting for connections...");
|
|
loop {
|
|
let timestamp = Instant::from_millis(timer.get_time().0 as i64);
|
|
{
|
|
let socket = &mut *sockets.get::<smoltcp::socket::TcpSocket>(tcp_handle);
|
|
|
|
if !socket.is_open() {
|
|
socket.listen(1550).unwrap();
|
|
}
|
|
|
|
if socket.may_recv() {
|
|
let start_cmd = socket.recv(|data| (data.len(), data.len() > 0)).unwrap();
|
|
if start_cmd && state == State::Idle {
|
|
log::info!("start sampling");
|
|
start_sampling();
|
|
state = State::Sampling;
|
|
}
|
|
} else if socket.may_send() {
|
|
log::info!("disconnected");
|
|
if state == State::Sampling {
|
|
state = State::SamplingAbort;
|
|
} else {
|
|
state = State::Idle;
|
|
}
|
|
socket.close();
|
|
}
|
|
|
|
if state == State::SamplingAbort {
|
|
if sampling_done() {
|
|
state = State::Idle;
|
|
}
|
|
}
|
|
if state == State::Sampling {
|
|
if sampling_done() {
|
|
state = State::Transfer(0);
|
|
}
|
|
}
|
|
if let State::Transfer(done) = state {
|
|
match socket.send_slice(unsafe { &BUFFER.data[done..] }) {
|
|
Ok(just_sent) => {
|
|
let done = done + just_sent;
|
|
if done == BUFFER_SIZE {
|
|
state = State::Idle;
|
|
} else {
|
|
state = State::Transfer(done);
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("error while transmitting: {}", e);
|
|
state = State::Idle;
|
|
socket.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
match interface.poll(&mut sockets, timestamp) {
|
|
Ok(_) => (),
|
|
Err(smoltcp::Error::Unrecognized) => (),
|
|
Err(err) => log::error!("Network error: {}", err),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub fn main_core1() {
|
|
loop {
|
|
asm::wfe();
|
|
}
|
|
}
|