#![no_std]
#![no_main]

extern crate alloc;

use core::{cmp, str};
use log::{info, warn};

use libcortex_a9::{asm, cache};
use libboard_zynq::{timer::GlobalTimer, logger, slcr};
use libsupport_zynq::ram;
use libconfig::Config;
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 = 128;

#[repr(C, align(128))]
struct DmaBuffer {
    data: [u8; BUFFER_SIZE],
}

static mut BUFFER: DmaBuffer = DmaBuffer { data: [0; BUFFER_SIZE] };

#[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()
        }
    };

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

        let busy = pl::csr::adc::busy_read();
        info!("started {}", busy);
        while pl::csr::adc::busy_read() != 0 {}
        info!("done, bus_error={}, overflow={}",
            pl::csr::adc::bus_error_read(), pl::csr::adc::overflow_read());
        cache::dcci_slice(&BUFFER.data);
        for i in 0..BUFFER_SIZE {
            info!("{:02x}", BUFFER.data[i]);
        }
    }

    loop {
        asm::wfe();
    }
}

#[no_mangle]
pub fn main_core1() {
    loop {
        asm::wfe();
    }
}