#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]

mod api;
use core::convert::TryInto;

use api::*;
use com_rs::serdes::{Ipv4Conf, STR_32_WORDS, STR_64_WORDS, StringSer};
use com_rs::*;
use log::{error, info, trace};
use num_traits::{FromPrimitive, ToPrimitive};
use xous::{CID, msg_blocking_scalar_unpack, msg_scalar_unpack};
use xous_ipc::Buffer;

const LEGACY_REV: u32 = 0x8b5b_8e50; // this is the git rev shipped before we went to version tagging
const LEGACY_TAG: u32 = 0x00_09_05_00; // this is corresponding tag
const STD_TIMEOUT: u32 = 100;
const EC_BOOT_WAIT_MS: usize = 3500;
#[derive(Debug, Copy, Clone)]
pub struct WorkRequest {
    work: ComSpec,
    sender: CID,
}

fn return_battstats(cid: CID, stats: api::BattStats) -> Result<(), xous::Error> {
    let rawstats: [usize; 2] = stats.into();
    xous::send_message(
        cid,
        xous::Message::new_scalar(
            api::Callback::BattStats.to_usize().unwrap(),
            rawstats[0],
            rawstats[1],
            0,
            0,
        ),
    )
    .map(|_| ())
}

#[cfg(any(feature = "precursor", feature = "renode"))]
mod implementation {
    use com_rs::*;
    use log::error;
    use susres::{RegManager, RegOrField, SuspendResume};
    use utralib::generated::*;

    use crate::WorkRequest;
    use crate::api::BattStats;
    use crate::return_battstats;

    const STD_TIMEOUT: u32 = 100;

    pub struct XousCom {
        csr: utralib::CSR<u32>,
        susres: RegManager<{ utra::com::COM_NUMREGS }>,
        ticktimer: ticktimer_server::Ticktimer,
        pub workqueue: Vec<WorkRequest>,
        busy: bool,
        stby_current: Option<i16>,
    }

    fn handle_irq(_irq_no: usize, arg: *mut usize) {
        let xc = unsafe { &mut *(arg as *mut XousCom) };
        // just clear the pending request, as this is used as a "wait" until request function
        xc.csr.wo(utra::com::EV_PENDING, xc.csr.r(utra::com::EV_PENDING));
    }

    impl XousCom {
        pub fn new() -> XousCom {
            let csr = xous::syscall::map_memory(
                xous::MemoryAddress::new(utra::com::HW_COM_BASE),
                None,
                4096,
                xous::MemoryFlags::R | xous::MemoryFlags::W,
            )
            .expect("couldn't map COM CSR range");

            let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");

            XousCom {
                csr: CSR::new(csr.as_mut_ptr() as *mut u32),
                susres: RegManager::new(csr.as_mut_ptr() as *mut u32),
                ticktimer,
                workqueue: Vec::new(),
                busy: false,
                stby_current: None,
            }
        }

        pub fn init(&mut self) {
            xous::claim_interrupt(utra::com::COM_IRQ, handle_irq, self as *mut XousCom as *mut usize)
                .expect("couldn't claim irq");

            self.susres.push(RegOrField::Reg(utra::com::CONTROL), None);
            self.susres.push_fixed_value(RegOrField::Reg(utra::com::EV_PENDING), 0xFFFF_FFFF);
            self.susres.push(RegOrField::Reg(utra::com::EV_ENABLE), None);
        }

        pub fn suspend(&mut self) {
            self.susres.suspend();
            self.csr.wo(utra::com::EV_ENABLE, 0);
            self.csr.wo(utra::com::EV_PENDING, 0xFFFF_FFFF);
        }

        pub fn resume(&mut self) {
            self.susres.resume();
            // issue a "link sync" command because the COM had continued running, and we may have sent garbage
            // during suspend
            self.txrx(ComState::LINK_SYNC.verb);
            // wait a moment for the link to stabilize, before allowing any other commands to issue
            self.ticktimer.sleep_ms(5).unwrap();
        }

        pub fn txrx(&mut self, tx: u16) -> u16 {
            self.csr.wfo(utra::com::TX_TX, tx as u32);
            /* transaction is automatically initiated on write
            wait while transaction is in progress. A transaction takes about 80-100 CPU cycles;
            not quite enough to be worth the overhead of an interrupt, so we just yield our time slice */
            while self.csr.rf(utra::com::STATUS_TIP) == 1 {
                // xous::yield_slice();
                /* ... and it turns out yielding the slice is a bad idea, because you may not get re-scheduled
                for a very long time, which causes the COM responder to timeout. Just waste the cycles. */
            }

            // grab the RX value and return it
            self.csr.rf(utra::com::RX_RX) as u16
        }

        pub fn wait_txrx(&mut self, tx: u16, timeout: Option<u32>) -> u16 {
            if timeout.is_some() {
                let curtime = self.ticktimer.elapsed_ms();
                let mut timed_out = false;
                let to = timeout.unwrap() as u64;
                while self.csr.rf(utra::com::STATUS_HOLD) == 1 && !timed_out {
                    if (self.ticktimer.elapsed_ms() - curtime) > to {
                        log::warn!("COM timeout");
                        timed_out = true;
                    }
                    xous::yield_slice();
                }
            } else {
                while self.csr.rf(utra::com::STATUS_HOLD) == 1 {
                    self.csr.wfo(utra::com::EV_ENABLE_SPI_HOLD, 1);
                    xous::wait_event();
                    self.csr.wfo(utra::com::EV_ENABLE_SPI_HOLD, 0);
                }
            }

            self.txrx(tx)
        }

        pub fn try_wait_txrx(&mut self, tx: u16, timeout: u32) -> Option<u16> {
            let curtime = self.ticktimer.elapsed_ms();
            let mut timed_out = false;
            let to = timeout as u64;
            while self.csr.rf(utra::com::STATUS_HOLD) == 1 && !timed_out {
                if (self.ticktimer.elapsed_ms() - curtime) > to {
                    log::warn!("COM timeout");
                    timed_out = true;
                }
                xous::yield_slice();
            }
            if timed_out {
                self.txrx(tx); // still push the packet in, so that the interface is pumped
                None // but note the failure
            } else {
                Some(self.txrx(tx))
            }
        }

        pub fn process_queue(&mut self) -> Option<xous::CID> {
            if !self.workqueue.is_empty() && !self.busy {
                self.busy = true;
                let work_descriptor = self.workqueue.remove(0);
                let ret = if work_descriptor.work.verb == ComState::STAT.verb {
                    let stats = self.get_battstats();
                    match return_battstats(work_descriptor.sender, stats) {
                        Err(xous::Error::ServerNotFound) => {
                            // the callback target has quit, so de-allocate it from our list
                            Some(work_descriptor.sender)
                        }
                        Ok(()) => None,
                        _ => panic!("unhandled error in callback process_queue"),
                    }
                } else {
                    error!("unimplemented work queue responder 0x{:x}", work_descriptor.work.verb);
                    None
                };
                self.busy = false;
                ret
            } else {
                None
            }
        }

        pub fn stby_current(&self) -> Option<i16> { self.stby_current }

        pub fn get_battstats(&mut self) -> BattStats {
            let mut stats = BattStats::default();

            self.txrx(ComState::GAS_GAUGE.verb);
            stats.current = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as i16;
            self.stby_current = Some(self.wait_txrx(ComState::LINK_READ.verb, Some(100)) as i16);
            stats.voltage = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
            self.wait_txrx(ComState::LINK_READ.verb, Some(100)); // power register value, not used

            self.txrx(ComState::GG_SOC.verb);
            stats.soc = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u8;
            self.txrx(ComState::GG_REMAINING.verb);
            stats.remaining_capacity = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));

            stats
        }

        pub fn get_more_stats(&mut self) -> [u16; 15] {
            self.txrx(ComState::STAT.verb);
            let ack = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
            if ack != 0x8888 {
                log::error!("didn't receive the expected ack header to the stats readout");
            }
            let mut ret: [u16; 15] = [0; 15];
            for r in ret.iter_mut() {
                *r = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
            }
            ret
        }

        pub fn poll_usb_cc(&mut self) -> [u32; 2] {
            self.txrx(ComState::POLL_USB_CC.verb);
            let event = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
            let mut ret: [u16; 3] = [0; 3];
            for r in ret.iter_mut() {
                *r = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
            }
            let rev = self.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
            // pack into a format that can be returned as a scalar2
            [
                ((rev & 0xff) as u32) << 24 | (((event & 0xff) as u32) << 16) | ret[0] as u32,
                ret[1] as u32 | ((ret[2] as u32) << 16),
            ]
        }
    }
}

// a stub to try to avoid breaking hosted mode for as long as possible.
#[cfg(not(target_os = "xous"))]
mod implementation {
    use com_rs::*;
    use log::error;

    use crate::WorkRequest;
    use crate::api::BattStats;
    use crate::return_battstats;

    pub struct XousCom {
        pub workqueue: Vec<WorkRequest>,
        busy: bool,
    }

    impl XousCom {
        pub fn new() -> XousCom { XousCom { workqueue: Vec::new(), busy: false } }

        pub fn init(&mut self) {}

        pub fn suspend(&self) {}

        pub fn resume(&self) {}

        pub fn txrx(&mut self, _tx: u16) -> u16 { 0xDEAD as u16 }

        pub fn wait_txrx(&mut self, _tx: u16, _timeout: Option<u32>) -> u16 { 0xDEAD as u16 }

        pub fn try_wait_txrx(&mut self, _tx: u16, _timeout: u32) -> Option<u16> { None }

        pub fn get_battstats(&mut self) -> BattStats {
            BattStats { voltage: 3950, current: -110, soc: 85, remaining_capacity: 850 }
        }

        pub fn stby_current(&self) -> Option<i16> { None }

        pub fn process_queue(&mut self) -> Option<xous::CID> {
            if !self.workqueue.is_empty() && !self.busy {
                self.busy = true;
                let work_descriptor = self.workqueue.remove(0);
                let ret = if work_descriptor.work.verb == ComState::STAT.verb {
                    let stats = self.get_battstats();
                    match return_battstats(work_descriptor.sender, stats) {
                        Err(xous::Error::ServerNotFound) => {
                            // the callback target has quit, so de-allocate it from our list
                            Some(work_descriptor.sender)
                        }
                        Ok(()) => None,
                        _ => panic!("unhandled error in callback process_queue"),
                    }
                } else {
                    error!("unimplemented work queue responder 0x{:x}", work_descriptor.work.verb);
                    None
                };
                self.busy = false;
                ret
            } else {
                None
            }
        }

        pub fn get_more_stats(&mut self) -> [u16; 15] {
            let mut ret = [0u16; 15];
            ret[12] = 3950; // make the oqc test happy
            ret
        }

        pub fn poll_usb_cc(&mut self) -> [u32; 2] { [0; 2] }
    }
}

fn main() -> ! {
    use crate::implementation::XousCom;

    log_server::init_wait().unwrap();
    log::set_max_level(log::LevelFilter::Info);
    info!("my PID is {}", xous::process::id());

    let xns = xous_names::XousNames::new().unwrap();
    // reset the EC so we're in sync at boot on state
    let llio = llio::Llio::new(&xns);
    llio.ec_reset().unwrap();

    // unlimited connections allowed -- any server is currently allowed to talk to COM. This might need to be
    // revisited.
    let com_sid = xns.register_name(api::SERVER_NAME_COM, None).expect("can't register server");
    trace!("registered with NS -- {:?}", com_sid);

    // Create a new com object
    let mut com = Box::new(XousCom::new());
    com.init();
    let ticktimer = ticktimer_server::Ticktimer::new().unwrap();

    #[cfg(not(any(windows, unix)))] // avoid errors in hosted mode
    {
        ticktimer.sleep_ms(100).unwrap(); // give the EC a moment to de-chatter
        let mut attempts = 0;
        let ping_value = 0xaeedu16; // for various reasons, this is a string that is "unlikely" to happen randomly
        loop {
            com.txrx(ComState::LINK_PING.verb);
            com.txrx(ping_value);
            let pong = com.wait_txrx(ComState::LINK_READ.verb, Some(150)); // this should "stall" until the EC comes out of reset
            let phase = com.wait_txrx(ComState::LINK_READ.verb, Some(150));
            if pong == !ping_value && phase == 0x600d {
                // 0x600d is a hard-coded constant. It's included to confirm that we aren't "wedged" just
                // sending one value back at us
                log::info!("EC rebooting: link established");
                break;
            } else {
                log::info!(
                    "EC rebooting: establishing link sync, attempt {} [{:04x}/{:04x}]",
                    attempts,
                    pong,
                    phase
                );
                com.txrx(ComState::LINK_SYNC.verb);
                ticktimer.sleep_ms(200).unwrap();
                attempts += 1;
            }
            if attempts > 50 {
                log::error!("EC didn't sync out of reset...continuing and praying for the best.");
                break;
            }
        }
    }

    // register a suspend/resume listener
    let sr_cid = xous::connect(com_sid).expect("couldn't create suspend callback connection");
    let mut susres =
        susres::Susres::new(Some(susres::SuspendOrder::Late), &xns, Opcode::SuspendResume as u32, sr_cid)
            .expect("couldn't create suspend/resume object");

    // create an array to track return connections for battery stats TODO: refactor this to use a Vec instead
    // of static allocations
    let mut battstats_conns: [Option<xous::CID>; 32] = [None; 32];
    // other future notification vectors shall go here

    let mut bl_main = 0;
    let mut bl_sec = 0;

    let mut flash_id: Option<[u32; 4]> = None; // only one process can acquire this, and its ID is stored here.
    const FLASH_LEN: u32 = 0x10_0000;
    const FLASH_TIMEOUT: u32 = 250;

    // initial seed of the COM trng
    ticktimer.sleep_ms(100).unwrap(); // some time for the EC to catch up during boot
    let trng = trng::Trng::new(&xns).expect("couldn't connect to TRNG");
    com.txrx(ComState::TRNG_SEED.verb);
    for _ in 0..2 {
        let mut rng = trng.get_u64().expect("couldn't fetch rngs");
        for _ in 0..4 {
            com.txrx(rng as u16);
            rng >>= 16;
        }
    }

    // determine the version of the COM that we're talking to
    ticktimer.sleep_ms(100).unwrap(); // some time for the EC to catch up during boot
    let mut ec_git_rev = {
        com.txrx(ComState::EC_GIT_REV.verb);
        let rev_msb = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT * 2)) as u16;
        let rev_lsb = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT * 2)) as u16;
        let _dirty = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT * 2)) as u8;
        ((rev_msb as u32) << 16) | (rev_lsb as u32)
    };
    let mut ec_tag = { if ec_git_rev == LEGACY_REV { LEGACY_TAG } else { parse_version(&mut com) } };
    let mut desired_int_mask = 0;

    trace!("starting main loop");
    loop {
        let mut msg = xous::receive_message(com_sid).unwrap();
        let opcode: Option<Opcode> = FromPrimitive::from_usize(msg.body.id());
        log::debug!("{:?}", opcode);
        match opcode {
            Some(Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
                com.txrx(ComState::LINK_SET_INTMASK.verb);
                com.txrx(0); // suppress interrupts on suspend

                if bl_main != 0 || bl_sec != 0 {
                    com.txrx(ComState::BL_START.verb); // this will turn off the backlights
                }
                com.suspend();
                susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
                com.resume();

                com.txrx(ComState::LINK_SET_INTMASK.verb);
                com.txrx(desired_int_mask); // restore interrupts on resume

                if bl_main != 0 || bl_sec != 0 {
                    // restore the backlight settings, if they are not 0
                    com.txrx(
                        ComState::BL_START.verb | (bl_main as u16) & 0x1f | (((bl_sec as u16) & 0x1f) << 5),
                    );
                }
            }),
            Some(Opcode::Ping) => xous::msg_blocking_scalar_unpack!(msg, ping, _, _, _, {
                xous::return_scalar(msg.sender, !ping).unwrap();
            }),
            Some(Opcode::LinkReset) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::LINK_SYNC.verb);
                ticktimer.sleep_ms(200).unwrap(); // give some time for the link to reset - the EC does not have a guaranteed latency to respond to a link reset
                if ec_tag >= u32::from_be_bytes(ComState::LINK_PING.apilevel) {
                    let mut attempts = 0;
                    let ping_value = 0xaeedu16; // for various reasons, this is a string that is "unlikely" to happen randomly
                    loop {
                        com.txrx(ComState::LINK_PING.verb);
                        com.txrx(ping_value);
                        let pong = com.wait_txrx(ComState::LINK_READ.verb, Some(500));
                        let phase = com.wait_txrx(ComState::LINK_READ.verb, Some(500));
                        if pong == !ping_value && phase == 0x600d {
                            // 0x600d is a hard-coded constant. It's included to confirm that we aren't
                            // "wedged" just sending one value back at us
                            break;
                        } else {
                            log::warn!(
                                "Link reset: establishing link sync, attempt {} [{:04x}/{:04x}]",
                                attempts,
                                pong,
                                phase
                            );
                            com.txrx(ComState::LINK_SYNC.verb);
                            ticktimer.sleep_ms(200).unwrap();
                            attempts += 1;
                        }
                        if attempts > 50 {
                            // abort and return failure
                            xous::return_scalar(msg.sender, 0).unwrap();
                            continue;
                        }
                    }
                } else {
                    // replace with a dead wait loop for older revs
                    log::warn!("EC rev is too old: replacing link SYNC with a dead wait loop");
                    ticktimer.sleep_ms(5000).unwrap();
                }
                xous::return_scalar(msg.sender, 1).unwrap();
            }),
            Some(Opcode::ReseedTrng) => xous::msg_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::TRNG_SEED.verb);
                for _ in 0..2 {
                    let mut rng = trng.get_u64().expect("couldn't fetch rngs");
                    for _ in 0..4 {
                        com.txrx(rng as u16);
                        rng >>= 16;
                    }
                }
            }),
            Some(Opcode::GetUptime) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                let mut uptime: u64 = 0;
                com.txrx(ComState::UPTIME.verb);
                for _ in 0..4 {
                    uptime >>= 16;
                    uptime |= (com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u64) << 48;
                }
                xous::return_scalar2(msg.sender, uptime as usize, (uptime >> 32) as usize)
                    .expect("couldn't return uptime");
            }),
            Some(Opcode::FlashAcquire) => msg_blocking_scalar_unpack!(msg, id0, id1, id2, id3, {
                let acquired = if flash_id.is_none() {
                    flash_id = Some([id0 as u32, id1 as u32, id2 as u32, id3 as u32]);
                    1
                } else {
                    0
                };
                xous::return_scalar(msg.sender, acquired as usize)
                    .expect("couldn't acknowledge acquire message");
            }),
            Some(Opcode::FlashOp) => {
                let mut buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                let mut flash_op = buffer.to_original::<api::FlashRecord, _>().unwrap();
                let mut pass = false;
                if let Some(id) = flash_id {
                    if id == flash_op.id {
                        match &mut flash_op.op {
                            api::FlashOp::Erase(addr, len) => {
                                if *addr < FLASH_LEN && *len + *addr < FLASH_LEN {
                                    log::debug!(
                                        "Erasing EC region starting at 0x{:x}, lenth 0x{:x}",
                                        *addr,
                                        *len
                                    );
                                    com.txrx(ComState::FLASH_ERASE.verb);
                                    com.txrx((*addr >> 16) as u16);
                                    com.txrx(*addr as u16);
                                    com.txrx((*len >> 16) as u16);
                                    com.txrx(*len as u16);
                                    while ComState::FLASH_ACK.verb
                                        != com.wait_txrx(ComState::FLASH_WAITACK.verb, Some(FLASH_TIMEOUT))
                                    {
                                        xous::yield_slice();
                                    }
                                    pass = true;
                                } else {
                                    pass = false;
                                }
                            }
                            api::FlashOp::Program(addr, some_pages) => {
                                com.txrx(ComState::FLASH_LOCK.verb);
                                let mut prog_ptr = *addr;
                                // this will fill the 1280-deep FIFO with up to 4 pages of data for
                                // programming
                                pass = true;
                                for &maybe_page in some_pages.iter() {
                                    if prog_ptr < FLASH_LEN - 256 {
                                        log::trace!("Prog EC page at 0x{:x}", prog_ptr);
                                        if let Some(page) = maybe_page {
                                            com.txrx(ComState::FLASH_PP.verb);
                                            com.txrx((prog_ptr >> 16) as u16);
                                            com.txrx(prog_ptr as u16);
                                            for i in 0..128 {
                                                com.txrx(
                                                    page[i * 2] as u16 | ((page[i * 2 + 1] as u16) << 8),
                                                );
                                            }
                                        }
                                        prog_ptr += 256;
                                    } else {
                                        pass = false;
                                    }
                                }
                                // wait for completion only after all 4 pages are sent
                                while ComState::FLASH_ACK.verb
                                    != com.wait_txrx(ComState::FLASH_WAITACK.verb, Some(FLASH_TIMEOUT))
                                {
                                    xous::yield_slice();
                                }
                                com.txrx(ComState::FLASH_UNLOCK.verb);
                            }
                            api::FlashOp::Verify(addr, data) => {
                                if ec_tag >= u32::from_be_bytes(ComState::FLASH_VERIFY.apilevel) {
                                    com.txrx(ComState::FLASH_VERIFY.verb);
                                    com.txrx((*addr >> 16) as u16);
                                    com.txrx(*addr as u16);

                                    for word in data.chunks_mut(2) {
                                        let read = com
                                            .wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT))
                                            .to_le_bytes();
                                        word[0] = read[0];
                                        word[1] = read[1];
                                    }
                                    pass = true;
                                } else {
                                    for d in data.iter_mut() {
                                        *d = 0;
                                    }
                                    pass = false;
                                }
                            }
                        }
                    }
                } else {
                    pass = false;
                }
                match flash_op.op {
                    api::FlashOp::Verify(_a, data) => {
                        log::debug!("verify returning {:x?}", &data[..32]);
                        buffer.replace(flash_op).expect("couldn't return result on FlashOp");
                    }
                    _ => {
                        let response = if pass { api::FlashResult::Pass } else { api::FlashResult::Fail };
                        buffer.replace(response).expect("couldn't return result on FlashOp");
                    }
                }
            }
            Some(Opcode::RegisterBattStatsListener) => msg_scalar_unpack!(msg, sid0, sid1, sid2, sid3, {
                let sid = xous::SID::from_u32(sid0 as _, sid1 as _, sid2 as _, sid3 as _);
                let cid = Some(xous::connect(sid).unwrap());
                let mut found = false;
                for entry in battstats_conns.iter_mut() {
                    if *entry == None {
                        *entry = cid;
                        found = true;
                        break;
                    }
                }
                if !found {
                    error!("RegisterBattStatsListener ran out of space registering callback");
                }
            }),
            Some(Opcode::IsCharging) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::POWER_CHARGER_STATE.verb);
                let result = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                xous::return_scalar(msg.sender, result as usize).expect("couldn't return charging state");
            }),
            Some(Opcode::RequestCharging) => msg_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::CHG_START.verb);
            }),
            Some(Opcode::StandbyCurrent) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                if let Some(i) = com.stby_current() {
                    xous::return_scalar2(msg.sender, 1, i as usize).expect("couldn't return StandbyCurrent");
                } else {
                    xous::return_scalar2(msg.sender, 0, 0).expect("couldn't return StandbyCurrent");
                }
            }),
            Some(Opcode::Wf200PdsLine) => {
                let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
                let l = buffer.to_original::<String, _>().unwrap();
                info!("Wf200PdsLine got line {}", l);
                let line = l.as_bytes();
                let length = (l.len() + 0) as u16;
                //info!("0x{:04x}", ComState::WFX_PDS_LINE_SET.verb);
                com.txrx(ComState::WFX_PDS_LINE_SET.verb);
                //info!("0x{:04x}", length);
                com.txrx(length);
                //for i in 0..(ComState::WFX_PDS_LINE_SET.w_words as usize - 1) {
                for i in 0..128 {
                    let word: u16;
                    if (i * 2 + 1) == length as usize {
                        // odd last element
                        word = line[i * 2] as u16;
                    } else if i * 2 < length as usize {
                        word = (line[i * 2] as u16) | ((line[i * 2 + 1] as u16) << 8);
                    } else {
                        word = 0;
                    }
                    com.txrx(word);
                    //info!("0x{:04x}", word);
                }
            }
            Some(Opcode::PowerOffSoc) => {
                // NOTE: this is deprecated, use susres.immediate_poweroff() instead. Power sequencing
                // requirements have changed since this was created, this routine does not actually cut power
                // anymore.
                com.txrx(ComState::CHG_BOOST_OFF.verb);
                com.txrx(ComState::LINK_SET_INTMASK.verb);
                com.txrx(0); // suppress interrupts on suspend

                if bl_main != 0 || bl_sec != 0 {
                    com.txrx(ComState::BL_START.verb); // this will turn off the backlights
                }
                info!("power off called");
                com.txrx(ComState::POWER_OFF.verb);
                com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)); // consume the obligatory return value, even if not used
            }
            Some(Opcode::BoostOff) => {
                com.txrx(ComState::CHG_BOOST_OFF.verb);
            }
            Some(Opcode::BoostOn) => {
                com.txrx(ComState::CHG_BOOST_ON.verb);
            }
            Some(Opcode::SetBackLight) => msg_scalar_unpack!(msg, main, secondary, _, _, {
                #[cfg(not(target_os = "xous"))]
                log::info!("HOSTED: set backlight to {},{}", main, secondary);
                bl_main = main;
                bl_sec = secondary;
                com.txrx(ComState::BL_START.verb | (main as u16) & 0x1f | (((secondary as u16) & 0x1f) << 5));
            }),
            Some(Opcode::ImuAccelReadBlocking) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::GYRO_UPDATE.verb);
                com.txrx(ComState::GYRO_READ.verb);
                let x = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                let y = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                let z = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                let id = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                xous::return_scalar2(
                    msg.sender,
                    ((x as usize) << 16) | y as usize,
                    ((z as usize) << 16) | id as usize,
                )
                .expect("coludn't return accelerometer read data");
            }),
            Some(Opcode::BattStats) => {
                let stats = com.get_battstats();
                let raw_stats: [usize; 2] = stats.into();
                xous::return_scalar2(msg.sender, raw_stats[0], raw_stats[1])
                    .expect("couldn't return batt stats request");
            }
            Some(Opcode::MoreStats) => {
                let mut buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                let stats = com.get_more_stats();
                buffer.replace(stats).unwrap();
            }
            Some(Opcode::PollUsbCc) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                let usb_cc: [u32; 2] = com.poll_usb_cc();
                xous::return_scalar2(msg.sender, usb_cc[0] as usize, usb_cc[1] as usize)
                    .expect("couldn't return Usb CC result");
            }),
            Some(Opcode::BattStatsNb) => {
                for &maybe_conn in battstats_conns.iter() {
                    if let Some(conn) = maybe_conn {
                        com.workqueue.push(WorkRequest { work: ComState::STAT, sender: conn });
                        //.unwrap();
                    }
                }
            }
            Some(Opcode::ShipMode) => {
                com.txrx(ComState::POWER_SHIPMODE.verb);
                xous::return_scalar(msg.sender, 1).expect("couldn't ack ship mode");
            }
            Some(Opcode::Wf200Rev) => {
                com.txrx(ComState::WFX_FW_REV_GET.verb);
                let major = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u8;
                let minor = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u8;
                let build = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u8;
                xous::return_scalar(
                    msg.sender,
                    ((major as usize) << 16) | ((minor as usize) << 8) | (build as usize),
                )
                .expect("couldn't return WF200 firmware rev");
            }
            Some(Opcode::EcGitRev) => {
                com.txrx(ComState::EC_GIT_REV.verb);
                let rev_msb = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u16;
                let rev_lsb = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u16;
                let dirty = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u8;
                ec_git_rev = ((rev_msb as u32) << 16) | (rev_lsb as u32);
                xous::return_scalar2(msg.sender, ec_git_rev as usize, dirty as usize)
                    .expect("couldn't return WF200 firmware rev");
            }
            Some(Opcode::EcSwTag) => {
                if ec_git_rev == LEGACY_REV {
                    // this corresponds to a 0.9.5 tag -- the last tag shipped that lacked detailed versioning
                    xous::return_scalar(msg.sender, 0x00_09_05_00)
                        .expect("couldn't return WF200 revision tag");
                } else {
                    ec_tag = parse_version(&mut com);
                    xous::return_scalar(msg.sender, ec_tag as usize)
                        .expect("couldn't return WF200 revision tag");
                }
            }
            Some(Opcode::Wf200Reset) => {
                let start = ticktimer.elapsed_ms();
                com.txrx(ComState::WF200_RESET.verb);
                com.txrx(0);
                if ec_tag >= u32::from_be_bytes(ComState::LINK_PING.apilevel) {
                    let mut attempts = 0;
                    let ping_value = 0xaeedu16; // for various reasons, this is a string that is "unlikely" to happen randomly
                    loop {
                        com.txrx(ComState::LINK_PING.verb);
                        com.txrx(ping_value);
                        let pong = com.wait_txrx(ComState::LINK_READ.verb, Some(5000)); // should finish with 5 seconds
                        let phase = com.wait_txrx(ComState::LINK_READ.verb, Some(500));
                        if pong == !ping_value && phase == 0x600d {
                            // 0x600d is a hard-coded constant. It's included to confirm that we aren't
                            // "wedged" just sending one value back at us
                            break;
                        } else {
                            log::warn!(
                                "Wf200 reset: establishing link sync, attempt {} [{:04x}/{:04x}]",
                                attempts,
                                pong,
                                phase
                            );
                            com.txrx(ComState::LINK_SYNC.verb);
                            ticktimer.sleep_ms(200).unwrap();
                            attempts += 1;
                        }
                        if attempts > 50 {
                            // something has gone horribly wrong. Reset the EC entirely.
                            llio.ec_reset().unwrap();
                            ticktimer.sleep_ms(EC_BOOT_WAIT_MS).unwrap();
                            com.txrx(ComState::TRNG_SEED.verb);
                            for _ in 0..2 {
                                let mut rng = trng.get_u64().expect("couldn't fetch rngs");
                                for _ in 0..4 {
                                    com.txrx(rng as u16);
                                    rng >>= 16;
                                }
                            }
                            break;
                        }
                    }
                } else {
                    // replace with a dead wait loop for older revs
                    log::warn!("EC rev is too old: replacing EC RESET SYNC with a dead wait loop");
                    ticktimer.sleep_ms(7000).unwrap();
                }
                xous::return_scalar(msg.sender, (ticktimer.elapsed_ms() - start) as usize).unwrap();
            }
            Some(Opcode::Wf200Disable) => {
                com.txrx(ComState::WF200_RESET.verb);
                com.txrx(1);
            }
            Some(Opcode::ScanOn) => {
                com.txrx(ComState::SSID_SCAN_ON.verb);
            }
            Some(Opcode::ScanOff) => {
                com.txrx(ComState::SSID_SCAN_OFF.verb);
            }
            Some(Opcode::SsidCheckUpdate) => {
                com.txrx(ComState::SSID_CHECK.verb);
                let available = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u16;
                xous::return_scalar(msg.sender, available as usize).expect("couldn't return SsidCheckUpdate");
            }
            Some(Opcode::SsidFetchAsString) => {
                if ec_tag == LEGACY_TAG {
                    // this is kept around because the original firmware shipped with units don't support
                    // software tagging and the SSID API was modified. This allows the SOC
                    // to interop with older versions of the EC for SSID scanning. If it's
                    // 2023 and you're looking at this comment and thinking about removing this code, it might
                    // actually be ok to do that. Just check that the factory test
                    // infrastructure is fully updated to match a modern EC rev.
                    use core::fmt::Write;
                    let mut buffer =
                        unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };

                    com.txrx(ComState::SSID_FETCH.verb);
                    let mut ssid_list: [[u8; 32]; 6] = [[0; 32]; 6]; // index as ssid_list[6][32]
                    for i in 0..16 * 6 {
                        let data = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u16;
                        let lsb: u8 = (data & 0xff) as u8;
                        let msb: u8 = ((data >> 8) & 0xff) as u8;
                        //if lsb == 0 { lsb = 0x20; }
                        //if msb == 0 { msb = 0x20; }
                        ssid_list[i / 16][(i % 16) * 2] = lsb;
                        ssid_list[i / 16][(i % 16) * 2 + 1] = msb;
                    }
                    // this is a questionably useful return format -- maybe it's actually more useful to
                    // return the raw characters?? for now, this is good enough for human
                    // eyes, but a scrollable list of SSIDs might be more useful with the raw u8
                    // representation
                    let mut ssid_str = String::from("Top 6 SSIDs:\n");
                    let mut itemized = String::new();
                    for i in 0..6 {
                        let mut stop = 0;
                        // truncate the nulls
                        for l in 0..ssid_list[i].len() {
                            stop = l;
                            if ssid_list[i][l] == 0 {
                                break;
                            }
                        }
                        let ssid = core::str::from_utf8(&ssid_list[i][0..stop]);
                        match ssid {
                            Ok(textid) => {
                                itemized.clear();
                                write!(itemized, "{}. {}\n", i + 1, textid).unwrap();
                                ssid_str.push_str(&itemized);
                            }
                            _ => {
                                ssid_str.push_str("-Parse Error-\n");
                            }
                        }
                    }
                    buffer.replace(ssid_str).unwrap();
                } else {
                    log::error!("This API is not implemented for this EC firmware revision");
                }
            }
            Some(Opcode::SsidFetchAsStringV2) => {
                if ec_tag == LEGACY_TAG {
                    log::error!("This API is not implemented for legacy EC revs");
                    continue;
                }
                com.txrx(ComState::SSID_FETCH_STR.verb);
                // these sizes are hard-coded constants from the EC firmware. We don't have a good cross-code
                // base method for sharing these yet, so they are just magic numbers.
                let mut ssid_list: [[u8; 34]; 8] = [[0; 34]; 8];
                for record in ssid_list.iter_mut() {
                    for word in record.chunks_mut(2) {
                        let data = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u16;
                        word[0] = (data & 0xff) as u8;
                        word[1] = ((data >> 8) & 0xff) as u8;
                    }
                }
                let mut buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                let mut ssid_ret =
                    buffer.to_original::<SsidReturn, _>().expect("couldn't convert incoming storage");
                for (raw, ssid_rec) in ssid_list.iter().zip(ssid_ret.list.iter_mut()) {
                    ssid_rec.rssi = raw[0];
                    let len = if raw[1] < 32 { raw[1] as usize } else { 32 };
                    let ssid_str =
                        core::str::from_utf8(&raw[2..2 + len as usize]).unwrap_or("UTF-8 parse error");
                    ssid_rec.name.clear(); // should be pre-cleared, but let's just be safe about it
                    ssid_rec.name.push_str(ssid_str);
                }
                buffer.replace(ssid_ret).unwrap();
            }
            Some(Opcode::WlanOn) => {
                com.txrx(ComState::WLAN_ON.verb);
                // re-sync the link, because the COM will take about a second to reload the Wifi drivers
                #[cfg(not(any(windows, unix)))] // avoid errors in hosted mode
                {
                    ticktimer.sleep_ms(100).unwrap(); // give the EC a moment to de-chatter
                    let mut attempts = 0;
                    let ping_value = 0xaeedu16; // for various reasons, this is a string that is "unlikely" to happen randomly
                    loop {
                        com.txrx(ComState::LINK_PING.verb);
                        com.txrx(ping_value);
                        let pong = com.wait_txrx(ComState::LINK_READ.verb, Some(150)); // this should "stall" until the EC comes out of reset
                        let phase = com.wait_txrx(ComState::LINK_READ.verb, Some(150));
                        if pong == !ping_value && phase == 0x600d {
                            // 0x600d is a hard-coded constant. It's included to confirm that we aren't
                            // "wedged" just sending one value back at us
                            log::info!("Wifi on: link established");
                            break;
                        } else {
                            log::info!(
                                "Wifi on: establishing link sync, attempt {} [{:04x}/{:04x}]",
                                attempts,
                                pong,
                                phase
                            );
                            com.txrx(ComState::LINK_SYNC.verb);
                            ticktimer.sleep_ms(200).unwrap();
                            attempts += 1;
                        }
                        if attempts > 50 {
                            log::error!(
                                "EC didn't sync after wifi on...continuing and praying for the best."
                            );
                            break;
                        }
                    }
                }
                xous::return_scalar(msg.sender, 1).ok();
            }
            Some(Opcode::WlanOff) => {
                com.txrx(ComState::WLAN_OFF.verb);
            }
            Some(Opcode::WlanRssi) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::WLAN_GET_RSSI.verb);
                let maybe_rssi = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                // raw code sent, error interpretation done by lib function
                xous::return_scalar(msg.sender, maybe_rssi as usize).unwrap();
            }),
            Some(Opcode::WlanSyncState) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::WLAN_SYNC_STATE.verb);
                let link = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                let dhcp = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                xous::return_scalar2(msg.sender, link as usize, dhcp as usize).unwrap();
            }),
            Some(Opcode::WlanSetSSID) => {
                let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
                let ssid = buffer.to_original::<String, _>().unwrap();
                info!("WlanSetSSID: {}", ssid);
                let mut str_ser = StringSer::<STR_32_WORDS>::new();
                match str_ser.encode(&ssid) {
                    Ok(tx_words) => {
                        com.txrx(ComState::WLAN_SET_SSID.verb);
                        for w in tx_words.iter() {
                            com.txrx(*w);
                        }
                    }
                    _ => info!("WlanSetSSID FAIL"),
                }
            }
            Some(Opcode::WlanSetPass) => {
                let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
                let pass = buffer.to_original::<String, _>().unwrap();
                info!("WlanSetPass *ssssh!*");
                let mut str_ser = StringSer::<STR_64_WORDS>::new();
                match str_ser.encode(&pass) {
                    Ok(tx_words) => {
                        com.txrx(ComState::WLAN_SET_PASS.verb);
                        for w in tx_words.iter() {
                            com.txrx(*w);
                        }
                    }
                    _ => info!("WlanSetPASS FAIL"),
                }
            }
            Some(Opcode::WlanJoin) => {
                info!("Sent WlanJoin");
                com.txrx(ComState::WLAN_JOIN.verb);
            }
            Some(Opcode::WlanLeave) => {
                info!("Sent WlanLeave");
                com.txrx(ComState::WLAN_LEAVE.verb);
            }
            Some(Opcode::WlanStatus) => {
                if ec_tag <= LEGACY_TAG {
                    log::warn!("Legacy EC detected. Ignoring status request update");
                } else {
                    let mut buffer =
                        unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                    com.txrx(ComState::WLAN_BIN_STATUS.verb);
                    let maybe_rssi = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    let rssi = if (maybe_rssi >> 8) & 0xff != 0 {
                        None
                    } else {
                        // rssi as reported is a number from 0-110, where 110 is 0 dbm.
                        // a perhaps dubious decision was made to shift the reported value over by one before
                        // returning to the host, so we lost a 0.5dBm step. But...not a big deal, and not
                        // worth putting every user through an EC update to gain some
                        // resolution they never see. note there is also a function in
                        // lib.rs/wlan_get_rssi() that has to be patched if
                        // this is fixed.
                        Some((110 - maybe_rssi) & 0xff)
                    };
                    let link_state = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    let mut ipv4_raw = Ipv4Conf::default().encode_u16();
                    for dest in ipv4_raw.iter_mut() {
                        *dest = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    }
                    let mut ssid_buf = [0u8; 34];
                    for w in ssid_buf.chunks_mut(2) {
                        let word = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)).to_le_bytes();
                        w[0] = word[0];
                        w[1] = word[1];
                    }
                    let ssid_len = u16::from_le_bytes(ssid_buf[0..2].try_into().unwrap()) as usize;
                    let ssid_checked_len = if ssid_len < 32 { ssid_len } else { 32 };
                    let ssid_str =
                        core::str::from_utf8(&ssid_buf[2..2 + ssid_checked_len]).unwrap_or("Disconnected");
                    let status = WlanStatusIpc {
                        ssid: if let Some(rssi) = rssi {
                            log::debug!("RSSI: -{}dBm", rssi);
                            Some(SsidRecord { rssi: rssi as u8, name: String::from(ssid_str) })
                        } else {
                            None
                        },
                        link_state,
                        ipv4: ipv4_raw,
                    };
                    buffer.replace(status).unwrap();
                }
            }
            Some(Opcode::WlanGetConfig) => {
                let mut buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };

                com.txrx(ComState::WLAN_GET_IPV4_CONF.verb);
                let mut prealloc = Ipv4Conf::default().encode_u16();
                for dest in prealloc.iter_mut() {
                    *dest = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                }
                #[cfg(not(target_os = "xous"))]
                {
                    // assign a fake MAC address in hosted mode so we don't crash smoltcp
                    for i in 1..4 {
                        prealloc[i] = i as u16 - 1;
                    }
                }
                /*
                    ret[1] = self.mac[0] as u16 | (self.mac[1] as u16) << 8;
                    ret[2] = self.mac[2] as u16 | (self.mac[3] as u16) << 8;
                    ret[3] = self.mac[4] as u16 | (self.mac[5] as u16) << 8;
                    multicast is self.mac[0] & 0x1 == 1 -> this gets set when 0xDDDD or 0xDEAD is transmitted as EC is in reset
                    broadcast is 0xFF's -> this is unlikely to be sent, it only is sent if the EC won't configure at all
                */
                // punting this to the lib side of things, so we can return an error and not just a bogus
                // value. prealloc[1] &= 0xFF_FE; // this ensures the "safety" of a reported
                // MAC, even if the EC is broken and avoiding system panic (issue #152)
                buffer.replace(prealloc).expect("couldn't return result on FlashOp");
            }
            Some(Opcode::WlanFetchPacket) => {
                let mut buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                let mut retbuf = buffer.to_original::<[u8; NET_MTU], _>().unwrap();
                let be_bytes: [u8; 2] = [retbuf[0], retbuf[1]];
                let len_bytes = u16::from_be_bytes(be_bytes);
                let len_words = if len_bytes % 2 == 0 { len_bytes / 2 } else { len_bytes / 2 + 1 };
                if len_bytes > NET_MTU as u16 {
                    log::error!("invalid packet fetch length: {}, aborting without fetch", len_bytes);
                    continue;
                }
                com.txrx(ComState::NET_FRAME_FETCH_0.verb | len_bytes);
                for word_index in 0..len_words as usize {
                    let w = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    let be_bytes = w.to_be_bytes();
                    retbuf[word_index * 2] = be_bytes[0];
                    retbuf[word_index * 2 + 1] = be_bytes[1];
                }
                log::trace!("rx: {:?}", &retbuf[..len_bytes as usize]);
                buffer.replace(retbuf).expect("couldn't return packet");
            }
            Some(Opcode::WlanSendPacket) => {
                let buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                let txbuf = buffer.as_flat::<[u8; NET_MTU + 2], _>().unwrap();
                let be_bytes: [u8; 2] = [txbuf[0], txbuf[1]];
                let len_bytes = u16::from_be_bytes(be_bytes);
                let len_words = if len_bytes % 2 == 0 { len_bytes / 2 } else { len_bytes / 2 + 1 };
                if len_bytes > NET_MTU as u16 {
                    log::error!("invalid packet send length: {}, aborting without send", len_bytes);
                    continue;
                }
                log::trace!("tx: {:?}", &txbuf[2..len_bytes as usize + 2]);
                com.txrx(ComState::NET_FRAME_SEND_0.verb | len_bytes);
                for word_index in 0..len_words as usize {
                    let be_bytes: [u8; 2] = [txbuf[2 + word_index * 2], txbuf[2 + word_index * 2 + 1]];
                    com.txrx(u16::from_be_bytes(be_bytes));
                }
            }
            Some(Opcode::IntSetMask) => msg_blocking_scalar_unpack!(msg, mask_val, _, _, _, {
                desired_int_mask = mask_val as u16;
                com.txrx(ComState::LINK_SET_INTMASK.verb);
                com.txrx(mask_val as u16);
                xous::return_scalar(msg.sender, 1).expect("couldn't ack IntSetMask");
            }),
            Some(Opcode::IntAck) => msg_blocking_scalar_unpack!(msg, ack_val, _, _, _, {
                com.txrx(ComState::LINK_ACK_INTERRUPT.verb);
                com.txrx(ack_val as u16);
                xous::return_scalar(msg.sender, 1).expect("couldn't ack IntAck");
            }),
            Some(Opcode::IntGetMask) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::LINK_GET_INTMASK.verb);
                let mask = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                xous::return_scalar(msg.sender, mask as usize).expect("couldn't return mask value");
            }),
            Some(Opcode::IntFetchVector) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
                com.txrx(ComState::LINK_GET_INTERRUPT.verb);
                let maybe_vector = com.try_wait_txrx(ComState::LINK_READ.verb, 500); // longer timeout because interrupts tend to be busy times
                let rxlen = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                if let Some(vector) = maybe_vector {
                    log::debug!("vector: 0x{:x}, len: {}", vector, rxlen);
                    xous::return_scalar2(msg.sender, vector as _, rxlen as _)
                        .expect("couldn't return IntFetchVector");
                } else {
                    log::error!(
                        "Timeout during interrupt vector fetch. EC may not be responsive. Returning error vector...."
                    );
                    xous::return_scalar2(msg.sender, com_rs::INT_INVALID as usize, 0)
                        .expect("couldn't return IntFetchVector");
                }
            }),
            Some(Opcode::WlanDebug) => {
                com.txrx(ComState::WLAN_GET_ERRCOUNTS.verb);
                let mut tx_errs_16 = [0u16; 2];
                let mut drops_16 = [0u16; 2];
                tx_errs_16[0] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                tx_errs_16[1] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                drops_16[0] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                drops_16[1] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));

                let mut config_16 = [0u16; 2];
                let mut alloc_fail_16 = [0u16; 2];
                let mut alloc_oversize_16 = [0u16; 2];
                let mut control = 0;
                let mut alloc_free_count = 0;
                if ec_tag >= u32::from_be_bytes(ComState::WF200_DEBUG.apilevel) {
                    com.txrx(ComState::WF200_DEBUG.verb);
                    config_16[0] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    config_16[1] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    control = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    alloc_fail_16[0] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    alloc_fail_16[1] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    alloc_oversize_16[0] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    alloc_oversize_16[1] = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                    alloc_free_count = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT));
                }

                let mut buffer =
                    unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
                let debug = WlanDebug {
                    tx_errs: from_le_words(tx_errs_16),
                    drops: from_le_words(drops_16),
                    config: from_le_words(config_16),
                    control,
                    alloc_fail: from_le_words(alloc_fail_16),
                    alloc_oversize: from_le_words(alloc_oversize_16),
                    alloc_free_count,
                };
                buffer.replace(debug).unwrap();
            }
            None => {
                error!("unknown opcode");
                break;
            }
        }

        if let Some(dropped_cid) = com.process_queue() {
            for entry in battstats_conns.iter_mut() {
                if let Some(cid) = *entry {
                    if cid == dropped_cid {
                        *entry = None;
                        break;
                    }
                }
            }
        }
    }
    log::trace!("main loop exit, destroying servers");
    xns.unregister_server(com_sid).unwrap();
    xous::destroy_server(com_sid).unwrap();
    log::trace!("quitting");
    xous::terminate_process(0)
}

fn parse_version(com: &mut crate::implementation::XousCom) -> u32 {
    use xous_semver::SemVer;

    // this feature was only introduced since 0.9.6. Unfortunately, there is no good way to figure out
    // if we support it for earlier versions of the EC.
    com.txrx(ComState::EC_SW_TAG.verb);
    let mut rev_ret = [0u16; ComState::EC_SW_TAG.r_words as usize];
    for w in rev_ret.iter_mut() {
        *w = com.wait_txrx(ComState::LINK_READ.verb, Some(STD_TIMEOUT)) as u16;
    }
    // unpack u16 words into u8 array
    let mut rev_bytes = [0u8; (ComState::EC_SW_TAG.r_words as usize - 1) * 2];
    for (src, dst) in rev_ret[1..].iter().zip(rev_bytes.chunks_mut(2)) {
        dst[0] = src.to_le_bytes()[0];
        dst[1] = src.to_le_bytes()[1];
    }
    // translate u8 array into &str
    let len_checked =
        if rev_ret[0] as usize <= rev_bytes.len() { rev_ret[0] as usize } else { rev_bytes.len() };
    if len_checked < 2 {
        // something is very wrong if our length is too short
        return 0;
    }
    let revstr = core::str::from_utf8(&rev_bytes[..len_checked]).unwrap_or("v0.9.5-0"); // fake version number for hosted mode, equal to a very old version of the EC
    let ver = SemVer::from_str(revstr).unwrap_or(SemVer::from_str("v0.9.5-1").unwrap());
    (ver.extra & 0xff) as u32
        | ((ver.rev & 0xff) as u32) << 8
        | (((ver.min & 0xff) as u32) << 16)
        | (((ver.maj & 0xff) as u32) << 24)
}

fn from_le_words(words: [u16; 2]) -> u32 { words[0] as u32 | (words[1] as u32) << 16 }