From b596c40dd69885f5098e798c2cafb9d16d009436 Mon Sep 17 00:00:00 2001 From: bunnie Date: Thu, 6 May 2021 03:40:04 +0800 Subject: [PATCH] refactor I2C to have work queue, cleaner (but untested) APIs --- Cargo.lock | 157 +++++++++++++-- services/codec/src/backend/tlv320aic3100.rs | 8 +- services/llio/Cargo.toml | 2 + services/llio/src/api.rs | 31 +-- services/llio/src/i2c/hardware.rs | 58 ++++-- services/llio/src/lib.rs | 207 +++++++++++++++++++- services/llio/src/main.rs | 2 +- services/rtc/src/main.rs | 8 +- services/shellchat/src/cmds/audio.rs | 4 +- 9 files changed, 410 insertions(+), 67 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b97a522a9..c419f6c43 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -44,6 +44,15 @@ dependencies = [ "stable_deref_trait", ] +[[package]] +name = "atomic-polyfill" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30302dda7a66f8c55932ebf208f7def840743ff64d495e9ceffcd97c18f11d39" +dependencies = [ + "cortex-m", +] + [[package]] name = "atty" version = "0.2.14" @@ -61,6 +70,15 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" +[[package]] +name = "bare-metal" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3" +dependencies = [ + "rustc_version", +] + [[package]] name = "benchmark" version = "0.1.0" @@ -118,6 +136,12 @@ dependencies = [ "which", ] +[[package]] +name = "bitfield" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46afbd2983a5d5a7bd740ccb198caf5b82f45c40c09c0eed36052d91cb92e719" + [[package]] name = "bitflags" version = "1.2.1" @@ -169,7 +193,7 @@ name = "cb-test-c1" version = "0.1.0" dependencies = [ "cb-test-srv", - "heapless", + "heapless 0.5.6", "log", "log-server", "num-derive", @@ -187,7 +211,7 @@ name = "cb-test-c2" version = "0.1.0" dependencies = [ "cb-test-srv", - "heapless", + "heapless 0.5.6", "log", "log-server", "num-derive", @@ -296,7 +320,7 @@ dependencies = [ name = "codec" version = "0.1.0" dependencies = [ - "heapless", + "heapless 0.5.6", "llio", "log", "log-server", @@ -316,7 +340,7 @@ name = "com" version = "0.1.0" dependencies = [ "com_rs-ref", - "heapless", + "heapless 0.5.6", "log", "log-server", "num-derive", @@ -369,6 +393,18 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" +[[package]] +name = "cortex-m" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "643a210c1bdc23d0db511e2a576082f4ff4dcae9d0c37f50b431b8f8439d6d6b" +dependencies = [ + "bare-metal", + "bitfield", + "embedded-hal", + "volatile-register", +] + [[package]] name = "crc" version = "1.8.1" @@ -415,6 +451,16 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650" +[[package]] +name = "embedded-hal" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db184d3fa27bc7a2344250394c0264144dfe0bc81a4401801dcb964b8dd172ad" +dependencies = [ + "nb 0.1.3", + "void", +] + [[package]] name = "encoding_rs" version = "0.8.28" @@ -483,7 +529,7 @@ dependencies = [ "com", "content-plugin-api", "graphics-server", - "heapless", + "heapless 0.5.6", "ime-plugin-api", "keyboard", "log", @@ -550,7 +596,7 @@ name = "graphics-server" version = "0.1.0" dependencies = [ "blitstr-ref", - "hash32", + "hash32 0.1.1", "hash32-derive", "keyboard", "log", @@ -575,6 +621,15 @@ dependencies = [ "byteorder", ] +[[package]] +name = "hash32" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" +dependencies = [ + "byteorder", +] + [[package]] name = "hash32-derive" version = "0.1.0" @@ -594,7 +649,18 @@ checksum = "74911a68a1658cfcfb61bc0ccfbd536e3b6e906f8c2f7883ee50157e3e2184f1" dependencies = [ "as-slice", "generic-array 0.13.3", - "hash32", + "hash32 0.1.1", + "stable_deref_trait", +] + +[[package]] +name = "heapless" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e94c13b78b595d2adbd708bce276664f1047f98fc32ddbf463b4c191158334a6" +dependencies = [ + "atomic-polyfill", + "hash32 0.2.1", "stable_deref_trait", ] @@ -667,7 +733,7 @@ dependencies = [ name = "ime-plugin-shell" version = "0.1.0" dependencies = [ - "heapless", + "heapless 0.5.6", "ime-plugin-api", "log", "log-server", @@ -702,7 +768,7 @@ dependencies = [ name = "keyboard" version = "0.1.0" dependencies = [ - "heapless", + "heapless 0.5.6", "llio", "log", "log-server", @@ -749,6 +815,7 @@ dependencies = [ name = "llio" version = "0.1.0" dependencies = [ + "heapless 0.7.0", "log", "log-server", "num-derive", @@ -832,6 +899,21 @@ dependencies = [ "autocfg", ] +[[package]] +name = "nb" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f" +dependencies = [ + "nb 1.0.0", +] + +[[package]] +name = "nb" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae" + [[package]] name = "nix" version = "0.20.0" @@ -1221,7 +1303,7 @@ version = "0.1.0" dependencies = [ "bitflags", "chrono", - "heapless", + "heapless 0.5.6", "llio", "log", "log-server", @@ -1247,6 +1329,15 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c" +[[package]] +name = "rustc_version" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a" +dependencies = [ + "semver", +] + [[package]] name = "ryu" version = "1.0.5" @@ -1281,6 +1372,21 @@ dependencies = [ "version-compare", ] +[[package]] +name = "semver" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" +dependencies = [ + "semver-parser", +] + +[[package]] +name = "semver-parser" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" + [[package]] name = "serde" version = "1.0.123" @@ -1296,7 +1402,7 @@ dependencies = [ "content-plugin-api", "gam", "graphics-server", - "heapless", + "heapless 0.5.6", "ime-plugin-api", "keyboard", "llio", @@ -1441,7 +1547,7 @@ dependencies = [ name = "ticktimer-server" version = "0.1.0" dependencies = [ - "heapless", + "heapless 0.5.6", "log", "log-server", "num-derive", @@ -1480,7 +1586,7 @@ dependencies = [ name = "trng" version = "0.1.0" dependencies = [ - "heapless", + "heapless 0.5.6", "log", "log-server", "num-derive", @@ -1534,6 +1640,12 @@ dependencies = [ "svd2utra", ] +[[package]] +name = "vcell" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77439c1b53d2303b20d9459b1ade71a83c716e3f9c34f3228c00e6f185d6c002" + [[package]] name = "vec_map" version = "0.8.2" @@ -1562,6 +1674,21 @@ version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed" +[[package]] +name = "void" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" + +[[package]] +name = "volatile-register" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d67cb4616d99b940db1d6bd28844ff97108b498a6ca850e5b6191a532063286" +dependencies = [ + "vcell", +] + [[package]] name = "wasi" version = "0.10.2+wasi-snapshot-preview1" @@ -1781,9 +1908,9 @@ dependencies = [ name = "xous-names" version = "0.1.0" dependencies = [ - "hash32", + "hash32 0.1.1", "hash32-derive", - "heapless", + "heapless 0.5.6", "log", "log-server", "num-derive", diff --git a/services/codec/src/backend/tlv320aic3100.rs b/services/codec/src/backend/tlv320aic3100.rs index c2d5ef9f4..d964bc5c8 100644 --- a/services/codec/src/backend/tlv320aic3100.rs +++ b/services/codec/src/backend/tlv320aic3100.rs @@ -212,14 +212,14 @@ impl Codec { fn w(&mut self, adr: u8, data: &[u8]) -> bool { let mut transaction = I2cTransaction::new(); - let mut txbuf: [u8; 258] = [0; 258]; + let mut txbuf: [u8; llio::I2C_MAX_LEN] = [0; llio::I2C_MAX_LEN]; txbuf[0] = adr; for i in 0..data.len() { txbuf[i+1] = data[i]; } transaction.bus_addr = TLV320AIC3100_I2C_ADR; transaction.txbuf = Some(txbuf); - transaction.txlen = data.len() as u32; + transaction.txlen = (data.len() + 1) as u32; transaction.status = I2cStatus::RequestIncoming; transaction.timeout_ms = I2C_TIMEOUT; @@ -254,7 +254,7 @@ impl Codec { } fn r(&mut self, adr: u8, data: &mut[u8]) -> bool { let mut transaction = I2cTransaction::new(); - let mut txbuf: [u8; 258] = [0; 258]; + let mut txbuf: [u8; llio::I2C_MAX_LEN] = [0; llio::I2C_MAX_LEN]; txbuf[0] = adr; transaction.bus_addr = TLV320AIC3100_I2C_ADR; transaction.txbuf = Some(txbuf); @@ -262,7 +262,7 @@ impl Codec { transaction.status = I2cStatus::RequestIncoming; transaction.timeout_ms = I2C_TIMEOUT; - let rxbuf: [u8; 258] = [0; 258]; + let rxbuf: [u8; llio::I2C_MAX_LEN] = [0; llio::I2C_MAX_LEN]; transaction.rxbuf = Some(rxbuf); transaction.rxlen = data.len() as u32; diff --git a/services/llio/Cargo.toml b/services/llio/Cargo.toml index 7818d6c80..dd31938f7 100644 --- a/services/llio/Cargo.toml +++ b/services/llio/Cargo.toml @@ -18,6 +18,8 @@ num-derive = {version = "0.3", default-features = false} num-traits = {version = "0.2", default-features = false} rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]} +heapless = "0.7" + [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = {path = "../../utralib"} diff --git a/services/llio/src/api.rs b/services/llio/src/api.rs index 1f6e1bc13..f5d080243 100644 --- a/services/llio/src/api.rs +++ b/services/llio/src/api.rs @@ -40,6 +40,8 @@ impl Into for UartType { } /////////////////////// I2C +// TODO: change this to pub(crate) once we've gotten rid of legacy API +pub const I2C_MAX_LEN: usize = 33; // a small book-keeping struct used to report back to I2C requestors as to the status of a transaction #[derive(Debug, Copy, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Eq, PartialEq)] pub enum I2cStatus { @@ -71,9 +73,9 @@ pub enum I2cCallback { pub struct I2cTransaction { pub bus_addr: u8, // write address and read address are encoded in the packet field below - pub txbuf: Option<[u8; 258]>, // long enough for a 256-byte operation + 2 bytes of "register address" + pub txbuf: Option<[u8; I2C_MAX_LEN]>, // long enough for a 256-byte operation + 2 bytes of "register address" pub txlen: u32, - pub rxbuf: Option<[u8; 258]>, + pub rxbuf: Option<[u8; I2C_MAX_LEN]>, pub rxlen: u32, pub listener: Option<(u32, u32, u32, u32)>, // where Rx split transactions should be routed to pub timeout_ms: u32, @@ -85,6 +87,19 @@ impl I2cTransaction { I2cTransaction{ bus_addr: 0, txbuf: None, txlen: 0, rxbuf: None, rxlen: 0, timeout_ms: 500, status: I2cStatus::Uninitialized, listener: None, callback_id: 0 } } } +#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] +pub enum I2cOpcode { + /// initiate an I2C transaction + I2cTxRx, + /// from i2c interrupt handler (internal API only) + IrqI2cTxrxWriteDone, + IrqI2cTxrxReadDone, + /// checks if the I2C engine is currently busy, for polling implementations + I2cIsBusy, + /// SuspendResume callback + SuspendResume, + Quit, +} ////////////////////////////////// VIBE #[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] @@ -205,18 +220,6 @@ pub(crate) enum Opcode { /// Exit the server Quit, } -#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] -pub enum I2cOpcode { - I2cTxRx, //(I2cTransaction), // type (tx or rx) encoded in struct - /// from i2c interrupt handler (internal API only) - IrqI2cTxrxWriteDone, - IrqI2cTxrxReadDone, - /// checks if the I2C engine is currently busy, for polling implementations - I2cIsBusy, - /// SuspendResume callback - SuspendResume, - Quit, -} #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] pub(crate) enum EventCallback { diff --git a/services/llio/src/i2c/hardware.rs b/services/llio/src/i2c/hardware.rs index f5ce95d9a..ddf19c8e7 100644 --- a/services/llio/src/i2c/hardware.rs +++ b/services/llio/src/i2c/hardware.rs @@ -4,6 +4,7 @@ use utralib::*; use num_traits::ToPrimitive; use susres::{RegManager, RegOrField, SuspendResume}; +use heapless::spsc::Queue; #[derive(Eq, PartialEq)] enum I2cState { @@ -53,13 +54,8 @@ pub(crate) struct I2cStateMachine { ticktimer: ticktimer_server::Ticktimer, // a connection to the ticktimer so we can measure timeouts listener: Option, error: bool, // set if the interrupt handler encountered some kind of error -} -fn send_i2c_response(listener: xous::SID, trans: I2cTransaction) -> Result<(), xous::Error> { - let cid = xous::connect(listener).unwrap(); - let buf = xous_ipc::Buffer::into_buf(trans).or(Err(xous::Error::InternalError))?; - buf.lend(cid, I2cCallback::Result.to_u32().unwrap()).map(|_|())?; - unsafe{xous::disconnect(cid)} + workqueue: Queue, } impl I2cStateMachine { @@ -85,6 +81,8 @@ impl I2cStateMachine { index: 0, listener: None, error: false, + + workqueue: Queue::new(), }; // disable interrupt, just in case it's enabled from e.g. a warm boot @@ -126,6 +124,17 @@ impl I2cStateMachine { } pub fn initiate(&mut self, transaction: I2cTransaction ) -> I2cStatus { + if !self.workqueue.is_empty() { + match self.workqueue.enqueue(transaction) { + Ok(_) => return I2cStatus::ResponseInProgress, + _ => return I2cStatus::ResponseBusy, + } + } else { + self.checked_initiate(transaction) + } + } + + fn checked_initiate(&mut self, transaction: I2cTransaction) -> I2cStatus { log::trace!("I2C initated with {:x?}", transaction); // sanity-check the bounds limits if transaction.txlen > 258 || transaction.rxlen > 258 { @@ -194,43 +203,50 @@ impl I2cStateMachine { } } } + + fn i2c_followup(&mut self, trans: I2cTransaction) -> Result<(), xous::Error> { + if let Some(listener) = self.listener.take() { + let cid = xous::connect(listener).unwrap(); + let buf = xous_ipc::Buffer::into_buf(trans).or(Err(xous::Error::InternalError))?; + buf.lend(cid, I2cCallback::Result.to_u32().unwrap()).map(|_|())?; + unsafe{xous::disconnect(cid)}; + }; + if let Some(work) = self.workqueue.dequeue() { + if self.checked_initiate(work) != I2cStatus::ResponseInProgress { + log::error!("Unable to initiate I2C transaction even though machine should be idle: {:?}.", work); + log::error!("Probably, the I2C engine is going off the rails from here..."); + } + }; + Ok(()) + } + #[allow(dead_code)] // keep this around in case we figure out the NACK issue fn report_nack(&mut self) { log::trace!("NACK"); // report the NACK situation to the listener let mut nack = I2cTransaction::new(); nack.status = I2cStatus::ResponseNack; - if let Some(listener) = self.listener { - send_i2c_response(listener, nack).expect("LLIO|I2C: couldn't send NACK to listeners"); - }; + self.i2c_followup(nack).expect("couldn't send NACK to listeners"); } fn report_timeout(&mut self) { log::error!("I2C timeout on transaction {:?}", self.transaction); let mut timeout = I2cTransaction::new(); timeout.status = I2cStatus::ResponseTimeout; - if let Some(listener) = self.listener { - send_i2c_response(listener, timeout).expect("LLIO|I2c: couldn't send timeout error to liseners"); - }; + self.i2c_followup(timeout).expect("couldn't send timeout error to liseners"); } pub fn report_write_done(&mut self) { log::trace!("write_done"); // report the end of a write-only transaction to all the listeners let mut ack = I2cTransaction::new(); ack.status = I2cStatus::ResponseWriteOk; - if let Some(listener) = self.listener { - send_i2c_response(listener, ack).expect("LLIO|I2C: couldn't send write ACK to listeners"); - }; + self.i2c_followup(ack).expect("couldn't send write ACK to listeners"); } pub fn report_read_done(&mut self) { log::trace!("read_done"); // report the result of a read transaction to all the listeners self.transaction.status = I2cStatus::ResponseReadOk; - if let Some(listener) = self.listener.take() { - log::trace!("Sending read done to {:?} of {:?}", listener, self.transaction); - send_i2c_response(listener, self.transaction).expect("LLIO|I2C: couldn't send read response to listeners"); - } else { - log::error!("No listener for my read done resopnse!"); - } + log::trace!("Sending read done {:?}", self.transaction); + self.i2c_followup(self.transaction).expect("couldn't send read response to listeners"); } pub fn is_busy(&self) -> bool { if self.state == I2cState::Idle { diff --git a/services/llio/src/lib.rs b/services/llio/src/lib.rs index bfa8448c4..1b5677ac0 100644 --- a/services/llio/src/lib.rs +++ b/services/llio/src/lib.rs @@ -12,6 +12,21 @@ use num_traits::{ToPrimitive, FromPrimitive}; // this hooks the response of the I2C bus static mut I2C_CB: Option = None; +use core::sync::atomic::{AtomicBool, Ordering}; +static I2C_IN_PROGRESS_MUTEX: AtomicBool = AtomicBool::new(false); +static mut I2C_RX_HANDOFF: [u8; I2C_MAX_LEN] = [0; I2C_MAX_LEN]; // this is protected by the above mutex + +fn sync_i2c_cb(transaction: I2cTransaction) { + if let Some(rxbuf) = transaction.rxbuf { + unsafe { + for i in 0..transaction.rxlen as usize { + I2C_RX_HANDOFF[i] = rxbuf[i]; + } + } + } + I2C_IN_PROGRESS_MUTEX.store(false, Ordering::Relaxed); +} + #[derive(Debug)] pub struct Llio { conn: CID, @@ -21,6 +36,7 @@ pub struct Llio { rtc_sid: Option, usb_sid: Option, gpio_sid: Option, + i2c_timeout_ms: u32, } impl Llio { pub fn new(xns: &xous_names::XousNames) -> Result { @@ -34,6 +50,7 @@ impl Llio { usb_sid: None, gpio_sid: None, i2c_conn, + i2c_timeout_ms: 10, }) } pub fn vibe(&self, pattern: VibePattern) -> Result<(), xous::Error> { @@ -95,14 +112,194 @@ impl Llio { } } - /* - pub fn i2c_sync_request(&self, transaction: &mut I2cTransaction) -> Result { - + fn check_cb_init(&mut self) { + if self.i2c_sid.is_none() { + let sid = xous::create_server().unwrap(); + self.i2c_sid = Some(sid); + let sid_tuple = sid.to_u32(); + xous::create_thread_4(i2c_cb_server, sid_tuple.0 as usize, sid_tuple.1 as usize, sid_tuple.2 as usize, sid_tuple.3 as usize).unwrap(); + // note: we don't register a callback, because we hand our SID directly to the i2c request for a 1:1 message return + } } + pub fn i2c_set_timeout(&mut self, timeout: u32) { + self.i2c_timeout_ms = timeout; + } + pub fn i2c_write_async(&mut self, dev: u8, adr: u8, data: &[u8], maybe_cb: Option) -> Result { + if data.len() > I2C_MAX_LEN - 1 { + return Err(xous::Error::OutOfMemory) + } + let mut transaction = I2cTransaction::new(); + if let Some(cb) = maybe_cb { + self.check_cb_init(); + unsafe { + if let Some(old_cb) = I2C_CB { + if old_cb != cb { + log::warn!("Multiple outstanding write transactions, with different callbacks. You are probably making an error!"); + } + } + I2C_CB = Some(cb); + } + match self.i2c_sid { + Some(sid) => transaction.listener = Some(sid.to_u32()), + None => log::error!("We requested a local listener, but somehow it's not there!"), + } + } + let mut txbuf = [0; I2C_MAX_LEN]; + txbuf[0] = adr; + for i in 0..data.len() { + txbuf[i+1] = data[i]; + } + transaction.bus_addr = dev; + transaction.txbuf = Some(txbuf); + transaction.txlen = (data.len() + 1) as u32; + transaction.status = I2cStatus::RequestIncoming; + transaction.timeout_ms = self.i2c_timeout_ms; - pub fn i2c_async_request(&self, transaction: I2cTransaction, cb: fn(I2cTransaction)) -> Result { + let mut buf = Buffer::into_buf(transaction).or(Err(xous::Error::InternalError))?; + buf.lend_mut(self.i2c_conn, I2cOpcode::I2cTxRx.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; + let result = buf.to_original::().unwrap(); + Ok(result) + } + pub fn i2c_read_async(&mut self, dev: u8, adr: u8, data: &mut[u8], read_cb: fn(I2cTransaction)) -> Result { + if data.len() > I2C_MAX_LEN - 1 { + return Err(xous::Error::OutOfMemory) + } + let mut transaction = I2cTransaction::new(); + self.check_cb_init(); + unsafe { + if let Some(old_cb) = I2C_CB { + if old_cb != read_cb { + log::warn!("Multiple outstanding read transactions, with different callbacks. Hope you know what you are doing!"); + } + } + I2C_CB = Some(read_cb); + } + match self.i2c_sid { + Some(sid) => transaction.listener = Some(sid.to_u32()), + None => log::error!("We requested a local listener, but somehow it's not there!"), + } + match self.i2c_sid { + Some(sid) => transaction.listener = Some(sid.to_u32()), + None => log::error!("We requested a local listener, but somehow it's not there!"), + } + let mut txbuf = [0; I2C_MAX_LEN]; + txbuf[0] = adr; + let rxbuf = [0; I2C_MAX_LEN]; + transaction.bus_addr = dev; + transaction.txbuf = Some(txbuf); + transaction.txlen = 1; + transaction.rxbuf = Some(rxbuf); + transaction.rxlen = data.len() as u32; + transaction.status = I2cStatus::RequestIncoming; + transaction.timeout_ms = self.i2c_timeout_ms; - }*/ + let mut buf = Buffer::into_buf(transaction).or(Err(xous::Error::InternalError))?; + buf.lend_mut(self.i2c_conn, I2cOpcode::I2cTxRx.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; + let result = buf.to_original::().unwrap(); + Ok(result) + } + // used by async callback handlers to indicate their completion, allowing e.g. later synchronous operations + pub fn i2c_async_done(&self) { + unsafe{I2C_CB = None}; + } + pub fn i2c_write_sync(&mut self, dev: u8, adr: u8, data: &[u8]) -> Result { + if I2C_IN_PROGRESS_MUTEX.load(Ordering::Relaxed) { + log::error!("entering a synchronous routine, but somehow something was already in progress!"); + return Err(xous::Error::InternalError); + } + + if data.len() > I2C_MAX_LEN - 1 { + return Err(xous::Error::OutOfMemory) + } + let mut transaction = I2cTransaction::new(); + self.check_cb_init(); + unsafe { + if let Some(old_cb) = I2C_CB { + if old_cb != sync_i2c_cb { + log::error!("Mix-and-match of sync and async callbacks is not allowed. Finish your async callbacks first, and call i2c_async_done!"); + return Err(xous::Error::ShareViolation); + } + } + I2C_CB = Some(sync_i2c_cb); + } + match self.i2c_sid { + Some(sid) => transaction.listener = Some(sid.to_u32()), + None => log::error!("We requested a local listener, but somehow it's not there!"), + } + let mut txbuf = [0; I2C_MAX_LEN]; + txbuf[0] = adr; + for i in 0..data.len() { + txbuf[i+1] = data[i]; + } + transaction.bus_addr = dev; + transaction.txbuf = Some(txbuf); + transaction.txlen = (data.len() + 1) as u32; + transaction.status = I2cStatus::RequestIncoming; + transaction.timeout_ms = self.i2c_timeout_ms; + + I2C_IN_PROGRESS_MUTEX.store(true, Ordering::Relaxed); + let mut buf = Buffer::into_buf(transaction).or(Err(xous::Error::InternalError))?; + buf.lend_mut(self.i2c_conn, I2cOpcode::I2cTxRx.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; + let result = buf.to_original::().unwrap(); + if result != I2cStatus::ResponseInProgress { + return Err(xous::Error::OutOfMemory); + } + while I2C_IN_PROGRESS_MUTEX.load(Ordering::Relaxed) { + xous::yield_slice(); + } + Ok(I2cStatus::ResponseWriteOk) + } + pub fn i2c_read_sync(&mut self, dev: u8, adr: u8, data: &mut[u8]) -> Result { + if I2C_IN_PROGRESS_MUTEX.load(Ordering::Relaxed) { + log::error!("entering a synchronous routine, but somehow something was already in progress!"); + return Err(xous::Error::InternalError); + } + if data.len() > I2C_MAX_LEN - 1 { + return Err(xous::Error::OutOfMemory) + } + let mut transaction = I2cTransaction::new(); + self.check_cb_init(); + unsafe { + if let Some(old_cb) = I2C_CB { + if old_cb != sync_i2c_cb { + log::error!("Mix-and-match of sync and async callbacks is not allowed. Finish your async callbacks first, and call i2c_async_done!"); + return Err(xous::Error::ShareViolation); + } + } + I2C_CB = Some(sync_i2c_cb); + } + match self.i2c_sid { + Some(sid) => transaction.listener = Some(sid.to_u32()), + None => log::error!("We requested a local listener, but somehow it's not there!"), + } + let mut txbuf = [0; I2C_MAX_LEN]; + txbuf[0] = adr; + let rxbuf = [0; I2C_MAX_LEN]; + transaction.bus_addr = dev; + transaction.txbuf = Some(txbuf); + transaction.txlen = 1; + transaction.rxbuf = Some(rxbuf); + transaction.rxlen = data.len() as u32; + transaction.status = I2cStatus::RequestIncoming; + transaction.timeout_ms = self.i2c_timeout_ms; + + I2C_IN_PROGRESS_MUTEX.store(true, Ordering::Relaxed); + let mut buf = Buffer::into_buf(transaction).or(Err(xous::Error::InternalError))?; + buf.lend_mut(self.i2c_conn, I2cOpcode::I2cTxRx.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; + let result = buf.to_original::().unwrap(); + if result != I2cStatus::ResponseInProgress { + return Err(xous::Error::OutOfMemory); + } + while I2C_IN_PROGRESS_MUTEX.load(Ordering::Relaxed) { + xous::yield_slice(); + } + unsafe { + for (&src, dst) in I2C_RX_HANDOFF.iter().zip(data.iter_mut()) { + *dst = src; + } + } + Ok(I2cStatus::ResponseReadOk) + } ///////////////////////// I2C /////////////// diff --git a/services/llio/src/main.rs b/services/llio/src/main.rs index 5d671b1b3..c4174bda2 100644 --- a/services/llio/src/main.rs +++ b/services/llio/src/main.rs @@ -503,7 +503,7 @@ fn i2c_thread(sid0: usize, sid1: usize, sid2: usize, sid3: usize) { let i2c_txrx = buffer.to_original::().unwrap(); let status = i2c.initiate(i2c_txrx); buffer.replace(status).unwrap(); - } + }, Some(I2cOpcode::I2cIsBusy) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { let busy = if i2c.is_busy() {1} else {0}; xous::return_scalar(msg.sender, busy as _).expect("couldn't return I2cIsBusy"); diff --git a/services/rtc/src/main.rs b/services/rtc/src/main.rs index 77bbd595e..e3f0ace59 100644 --- a/services/rtc/src/main.rs +++ b/services/rtc/src/main.rs @@ -267,7 +267,7 @@ mod implementation { pub fn rtc_set(&mut self, secs: u8, mins: u8, hours: u8, days: u8, months: u8, years: u8, day: Weekday) -> Result { let mut transaction = I2cTransaction::new(); - let mut txbuf: [u8; 258] = [0; 258]; + let mut txbuf: [u8; llio::I2C_MAX_LEN] = [0; llio::I2C_MAX_LEN]; if secs > 59 { return Ok(false); } if mins > 59 { return Ok(false); } @@ -316,8 +316,8 @@ mod implementation { pub fn rtc_get(&mut self) -> Result<(), xous::Error> { let mut transaction = I2cTransaction::new(); - let mut txbuf = [0; 258]; - let rxbuf = [0; 258]; + let mut txbuf = [0; llio::I2C_MAX_LEN]; + let rxbuf = [0; llio::I2C_MAX_LEN]; txbuf[0] = ABRTCMC_SECONDS; transaction.bus_addr = ABRTCMC_I2C_ADR; transaction.txlen = 1; @@ -339,7 +339,7 @@ mod implementation { fn blocking_i2c_write2(&self, tx: [u8; 2]) -> bool { let mut transaction = I2cTransaction::new(); - let mut txbuf: [u8; 258] = [0; 258]; + let mut txbuf: [u8; llio::I2C_MAX_LEN] = [0; llio::I2C_MAX_LEN]; txbuf[0] = tx[0]; txbuf[1] = tx[1]; transaction.bus_addr = ABRTCMC_I2C_ADR; diff --git a/services/shellchat/src/cmds/audio.rs b/services/shellchat/src/cmds/audio.rs index de5681a5e..78fc795bb 100644 --- a/services/shellchat/src/cmds/audio.rs +++ b/services/shellchat/src/cmds/audio.rs @@ -31,7 +31,6 @@ impl Audio { unsafe{ raw_header[i] = (*samples)[i] }; log::trace!("0x{:x}", raw_header[i]); } - /* log::trace!("setting up audio stream"); codec.setup_8k_stream().expect("couldn't set the CODEC to expected defaults"); @@ -40,8 +39,7 @@ impl Audio { log::trace!("hooking frame callback"); codec.hook_frame_callback(0xDEAD_BEEF, callback_conn).unwrap(); // any non-handled IDs get routed to our callback port log::trace!("returning from setup"); - */ - + */ Audio { codec, sample,