From 45c90659e5c0aea84b5fc02b8089c3d40b310639 Mon Sep 17 00:00:00 2001 From: bunnie Date: Thu, 8 Apr 2021 02:30:57 +0800 Subject: [PATCH] rtc first draft --- Cargo.lock | 1 + emulation/renode.svd | 43 +-- services/llio/src/api.rs | 12 +- services/llio/src/i2c.rs | 83 ++--- services/llio/src/lib.rs | 65 +++- services/llio/src/main.rs | 8 +- services/rtc/Cargo.toml | 1 + services/rtc/src/api.rs | 13 +- services/rtc/src/lib.rs | 33 +- services/rtc/src/main.rs | 480 ++++++++++++++++++++------- services/ticktimer-server/Cargo.toml | 4 +- svd2utra/examples/soc.svd | 43 +-- xtask/src/main.rs | 1 + 13 files changed, 522 insertions(+), 265 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 28589ae2f..91603280e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1152,6 +1152,7 @@ version = "0.1.0" dependencies = [ "bitflags", "heapless", + "llio", "log", "log-server", "num-derive", diff --git a/emulation/renode.svd b/emulation/renode.svd index 70babeb36..9d394f73c 100644 --- a/emulation/renode.svd +++ b/emulation/renode.svd @@ -1328,10 +1328,10 @@ register to disable individual events.]]> GIT_GITREV 0x0014 - 0x8561717c + 0x79ae30c6 32 @@ -1348,7 +1348,7 @@ the exact git version used to build this firmware.]]> is ``1``, then the repository this was built from has one additional commit beyond the tag indicated in `MAJOR`, `MINOR`, and `REVISION`.]]> 0x0018 - 0x0f + 0x10 32 @@ -2550,6 +2550,10 @@ reset fashion]]> 0x14 registers + + power + 9 + SPINOR @@ -3044,7 +3048,7 @@ again until the interrupt is serviced.]]> keyboard - 9 + 10 @@ -3056,7 +3060,7 @@ again until the interrupt is serviced.]]> SEED1 0x0000 - 0x62e0ffce + 0x505c16c1 32 @@ -3071,7 +3075,7 @@ again until the interrupt is serviced.]]> SEED0 0x0004 - 0x629a6ab2 + 0x578f7014 32 @@ -3500,7 +3504,7 @@ I2S_FORMAT.I2S_STANDARD is I2S standard]]> audio - 10 + 11 @@ -3636,7 +3640,7 @@ I2S_FORMAT.I2S_STANDARD is I2S standard]]> trng_kernel - 11 + 12 @@ -3968,7 +3972,7 @@ to max field size]]> trng_server - 12 + 13 @@ -4776,7 +4780,7 @@ in bits]]> sha512 - 13 + 14 @@ -5005,7 +5009,7 @@ exactly reflects the binary layout of an Engine instruction.]]> engine - 14 + 15 @@ -5223,7 +5227,7 @@ register to disable individual events.]]> wdt - 15 + 16 @@ -5294,21 +5298,22 @@ register to disable individual events.]]> - + - + - - + + + - - + + - + \ No newline at end of file diff --git a/services/llio/src/api.rs b/services/llio/src/api.rs index 9e1b060c7..b2fafb224 100644 --- a/services/llio/src/api.rs +++ b/services/llio/src/api.rs @@ -75,12 +75,14 @@ pub struct I2cTransaction { pub txlen: u32, pub rxbuf: Option<[u8; 258]>, pub rxlen: u32, + pub listener: Option<(u32, u32, u32, u32)>, // where Rx split transactions should be routed to pub timeout_ms: u32, pub status: I2cStatus, + pub callback_id: u32, // used by callback routines to help identify a return value } impl I2cTransaction { pub fn new() -> Self { - I2cTransaction{ bus_addr: 0, txbuf: None, txlen: 0, rxbuf: None, rxlen: 0, timeout_ms: 100, status: I2cStatus::Uninitialized } + I2cTransaction{ bus_addr: 0, txbuf: None, txlen: 0, rxbuf: None, rxlen: 0, timeout_ms: 100, status: I2cStatus::Uninitialized, listener: None, callback_id: 0 } } } @@ -195,10 +197,10 @@ pub(crate) enum Opcode { /// not tested - I2C functions I2cTxRx, //(I2cTransaction), // type (tx or rx) encoded in struct - /// callback repsonses from the I2C engine - I2cRegisterCallback, //(String<64>), // if TxRx is issued without first subscribing to responses, the read data is just "lost" - /// from i2c interrupt handler - IrqI2cTxrxDone, // internal API only + /// from i2c interrupt handler (internal API only) + IrqI2cTxrxDone, + /// checks if the I2C engine is currently busy, for polling implementations + I2cIsBusy, /// not tested -- events EventComSubscribe, //(String<64>), diff --git a/services/llio/src/i2c.rs b/services/llio/src/i2c.rs index 5be3ef39e..99030e461 100644 --- a/services/llio/src/i2c.rs +++ b/services/llio/src/i2c.rs @@ -24,9 +24,6 @@ impl I2cStateMachine { pub fn initiate(&mut self, _transaction: I2cTransaction ) -> I2cStatus { I2cStatus::ResponseInProgress } - pub fn register_listener(&mut self, _listener: xous::CID) -> Result<(), xous::CID> { - Ok(()) - } pub fn handler(&mut self) { } } @@ -38,13 +35,15 @@ pub struct I2cStateMachine { timestamp: u64, // timestamp of the last transaction ticktimer: ticktimer_server::Ticktimer, // a connection to the ticktimer so we can measure timeouts i2c_csr: utralib::CSR, - listeners: [Option; 32], + listener: Option, } #[cfg(target_os = "none")] -fn send_i2c_response(listener: xous::CID, trans: I2cTransaction) -> Result<(), xous::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(listener, I2cCallback::Result.to_u32().unwrap()).map(|_|()) + buf.lend(cid, I2cCallback::Result.to_u32().unwrap()).map(|_|())?; + unsafe{xous::disconnect(cid)} } #[cfg(target_os = "none")] @@ -57,7 +56,7 @@ impl I2cStateMachine { ticktimer, i2c_csr: CSR::new(i2c_base), index: 0, - listeners: [None; 32], + listener: None, } } pub fn initiate(&mut self, transaction: I2cTransaction ) -> I2cStatus { @@ -81,6 +80,10 @@ impl I2cStateMachine { } self.timestamp = now; self.transaction = transaction.clone(); + match transaction.listener { + None => self.listener = None, + Some((s0, s1, s2, s3)) => self.listener = Some(xous::SID::from_u32(s0, s1, s2, s3)), + } if self.transaction.status == I2cStatus::RequestIncoming { self.transaction.status = I2cStatus::ResponseInProgress; @@ -117,57 +120,40 @@ impl I2cStateMachine { } } fn report_nack(&mut self) { - // report the NACK situation to all the listeners + // report the NACK situation to the listener let mut nack = I2cTransaction::new(); nack.status = I2cStatus::ResponseNack; - for &l in self.listeners.iter() { - if let Some(listener) = l { - send_i2c_response(listener, nack).expect("LLIO|I2C: couldn't send NACK to listeners"); - }; - } + if let Some(listener) = self.listener { + send_i2c_response(listener, nack).expect("LLIO|I2C: couldn't send NACK to listeners"); + }; } fn report_timeout(&mut self) { let mut timeout = I2cTransaction::new(); timeout.status = I2cStatus::ResponseTimeout; - for &l in self.listeners.iter() { - if let Some(listener) = l { - send_i2c_response(listener, timeout).expect("LLIO|I2c: couldn't send timeout error to liseners"); - }; - } + if let Some(listener) = self.listener { + send_i2c_response(listener, timeout).expect("LLIO|I2c: couldn't send timeout error to liseners"); + }; } fn report_write_done(&mut self) { // report the end of a write-only transaction to all the listeners let mut ack = I2cTransaction::new(); ack.status = I2cStatus::ResponseWriteOk; - for &l in self.listeners.iter() { - if let Some(listener) = l { - send_i2c_response(listener, ack).expect("LLIO|I2C: couldn't send write ACK to listeners"); - }; - } + if let Some(listener) = self.listener { + send_i2c_response(listener, ack).expect("LLIO|I2C: couldn't send write ACK to listeners"); + }; } fn report_read_done(&mut self) { // report the result of a read transaction to all the listeners self.transaction.status = I2cStatus::ResponseReadOk; - for &l in self.listeners.iter() { - if let Some(listener) = l { - send_i2c_response(listener, self.transaction).expect("LLIO|I2C: couldn't send read response to listeners"); - }; - } + if let Some(listener) = self.listener { + send_i2c_response(listener, self.transaction).expect("LLIO|I2C: couldn't send read response to listeners"); + }; } - pub fn register_listener(&mut self, listener: xous::CID) -> Result<(), xous::CID> { - let mut found = false; - for entry in self.listeners.iter_mut() { - if *entry == None { - *entry = Some(listener); - found = true; - break; - } - } - if !found { - log::error!("I2cRegisterCallback ran out of space registering callback"); - Err(listener) + pub fn is_busy(&self) -> bool { + if self.state == I2cState::Idle { + false } else { - Ok(()) + true } } pub fn handler(&mut self) { @@ -246,6 +232,7 @@ impl I2cStateMachine { } else { self.report_read_done(); self.state = I2cState::Idle; + self.listener = None; } } else { // we should never get here, because rxbuf was checked as Some() by the setup routine @@ -258,17 +245,3 @@ impl I2cStateMachine { } } } - -#[cfg(target_os = "none")] -impl Drop for I2cStateMachine { - fn drop(&mut self) { - for &l in self.listeners.iter() { - if let Some(listener) = l { - let dummy = I2cTransaction::new(); - let buf = xous_ipc::Buffer::into_buf(dummy).or(Err(xous::Error::InternalError)).unwrap(); - buf.lend(listener, I2cCallback::Drop.to_u32().unwrap()).map(|_|()).unwrap(); - unsafe{xous::disconnect(listener).unwrap();} - }; - } - } -} diff --git a/services/llio/src/lib.rs b/services/llio/src/lib.rs index 050a44ad0..bdde8b3ca 100644 --- a/services/llio/src/lib.rs +++ b/services/llio/src/lib.rs @@ -3,13 +3,13 @@ /// This is the API that other servers use to call the COM. Read this code as if you /// are calling these functions inside a different process. pub mod api; -use api::*; +pub use api::*; use xous::{send_message, CID, Message, msg_scalar_unpack}; use xous_ipc::Buffer; use num_traits::{ToPrimitive, FromPrimitive}; -// this hooks the responce of the I2C bus +// this hooks the response of the I2C bus static mut I2C_CB: Option = None; #[derive(Debug)] @@ -44,21 +44,41 @@ impl Llio { 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(); - xous::send_message(self.conn, - Message::new_scalar(Opcode::I2cRegisterCallback.to_usize().unwrap(), - 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 } Ok(()) } // used by other servers to request an I2C transaction pub fn send_i2c_request(&self, transaction: I2cTransaction) -> Result { - let mut buf = Buffer::into_buf(transaction).or(Err(xous::Error::InternalError))?; + // copy the transaction, and annotate with our private callback listener server address + // the server is used only for this connection, and shared only to the LLIO server + // it's sanitized on the callback response. It's not the end of the world if this server address is + // discovered, just unhygenic. + let mut local_transaction = transaction; + match self.i2c_sid { + None => local_transaction.listener = None, + Some(sid) => local_transaction.listener = Some(sid.to_u32()), + } + let mut buf = Buffer::into_buf(local_transaction).or(Err(xous::Error::InternalError))?; buf.lend_mut(self.conn, Opcode::I2cTxRx.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; let status = buf.to_original::().unwrap(); Ok(status) } + pub fn poll_i2c_busy(&self) -> Result { + let response = send_message(self.conn, + Message::new_blocking_scalar(Opcode::I2cIsBusy.to_usize().unwrap(), 0, 0, 0, 0))?; + if let xous::Result::Scalar1(val) = response { + if val != 0 { + Ok(true) + } else { + Ok(false) + } + } else { + log::error!("LLIO: unexpected return value: {:#?}", response); + Err(xous::Error::InternalError) + } + } pub fn allow_power_off(&self, allow: bool) -> Result<(), xous::Error> { let arg = if allow { 1 } else { 0 }; @@ -255,21 +275,29 @@ impl Llio { } } } +fn drop_conn(sid: xous::SID) { + let cid = xous::connect(sid).unwrap(); + xous::send_message(cid, + Message::new_blocking_scalar(EventCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0)).unwrap(); + unsafe{xous::disconnect(cid).unwrap();} + xous::destroy_server(sid).unwrap(); +} impl Drop for Llio { fn drop(&mut self) { if let Some(sid) = self.i2c_sid.take() { - let cid = xous::connect(sid).unwrap(); - xous::send_message(cid, - Message::new_blocking_scalar(I2cCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0)).unwrap(); - unsafe{xous::disconnect(cid).unwrap();} - xous::destroy_server(sid).unwrap(); + drop_conn(sid); } if let Some(sid) = self.usb_sid.take() { - let cid = xous::connect(sid).unwrap(); - xous::send_message(cid, - Message::new_blocking_scalar(EventCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0)).unwrap(); - unsafe{xous::disconnect(cid).unwrap();} - xous::destroy_server(sid).unwrap(); + drop_conn(sid); + } + if let Some(sid) = self.rtc_sid.take() { + drop_conn(sid); + } + if let Some(sid) = self.com_sid.take() { + drop_conn(sid); + } + if let Some(sid) = self.gpio_sid.take() { + drop_conn(sid); } unsafe{xous::disconnect(self.conn).unwrap();} } @@ -283,7 +311,8 @@ fn i2c_cb_server(sid0: usize, sid1: usize, sid2: usize, sid3: usize) { match FromPrimitive::from_usize(msg.body.id()) { Some(I2cCallback::Result) => { let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let i2cresult = buffer.to_original::().unwrap(); + let mut i2cresult = buffer.to_original::().unwrap(); + i2cresult.listener = None; // don't leak our local server address to the callback unsafe { if let Some(cb) = I2C_CB { cb(i2cresult) diff --git a/services/llio/src/main.rs b/services/llio/src/main.rs index ef2a4a310..5c97cd69a 100644 --- a/services/llio/src/main.rs +++ b/services/llio/src/main.rs @@ -19,6 +19,7 @@ mod implementation { use utralib::generated::*; use num_traits::ToPrimitive; + #[allow(dead_code)] pub struct Llio { reboot_csr: utralib::CSR, crg_csr: utralib::CSR, @@ -684,10 +685,9 @@ fn xmain() -> ! { let status = i2c_machine.initiate(i2c_txrx); buffer.replace(status).unwrap(); } - Some(Opcode::I2cRegisterCallback) => msg_scalar_unpack!(msg, sid0, sid1, sid2, sid3, { - let sid = xous::SID::from_u32(sid0 as _, sid1 as _, sid2 as _, sid3 as _); - let cid = xous::connect(sid).unwrap(); - i2c_machine.register_listener(cid).unwrap(); + Some(Opcode::I2cIsBusy) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { + let busy = if i2c_machine.is_busy() {1} else {0}; + xous::return_scalar(msg.sender, busy as _).expect("couldn't return I2cIsBusy"); }), Some(Opcode::EventUsbAttachSubscribe) => { let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; diff --git a/services/rtc/Cargo.toml b/services/rtc/Cargo.toml index 807958959..cadf374c6 100644 --- a/services/rtc/Cargo.toml +++ b/services/rtc/Cargo.toml @@ -13,6 +13,7 @@ ticktimer-server = { path = "../ticktimer-server" } xous-names = { path = "../xous-names" } log = "0.4" bitflags = "1.2.1" +llio = {path = "../llio"} xous-ipc = {path = "../../xous-ipc"} num-derive = {version = "0.3", default-features = false} diff --git a/services/rtc/src/api.rs b/services/rtc/src/api.rs index 4bcdb04e0..3d6fcf5d0 100644 --- a/services/rtc/src/api.rs +++ b/services/rtc/src/api.rs @@ -1,6 +1,5 @@ -use xous::{Message, ScalarMessage}; -#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)] pub enum Weekday { Sunday, Monday, @@ -32,18 +31,18 @@ pub struct DateTime { pub(crate) const SERVER_NAME_RTC: &str = "_Real time clock application server_"; #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] -pub enum Opcode { +pub(crate) enum Opcode { /// register a callback for the datetime RegisterDateTimeCallback, - /// register a callback for the RTC alarm event - RegisterAlarmCallback, + /// sets the datetime + SetDateTime, //(DateTime), /// Get datetime. Causes users with registered callbacks to receive the current DateTime RequestDateTime, - /// sets the datetime - SetDateTime, //(DateTime), + /// the datetime response, used internally from the callback manager + ResponseDateTime, /// sets a wake-up alarm. This forces the SoC into power-on state, if it happens to be off. /// primarily used to trigger cold reboots, but could have other reasons diff --git a/services/rtc/src/lib.rs b/services/rtc/src/lib.rs index 4247d6254..88db12092 100644 --- a/services/rtc/src/lib.rs +++ b/services/rtc/src/lib.rs @@ -2,14 +2,15 @@ pub mod api; -use api::{Return, Opcode}; // if you prefer to map the api into your local namespace -use xous::{send_message, Error, CID, Message, msg_scalar_unpack}; -use xous_ipc::{String, Buffer}; -use num_traits::{ToPrimitive, FromPrimitive}; +use api::{Return, Opcode, DateTime}; // if you prefer to map the api into your local namespace +use xous::{send_message, CID, Message}; +use xous_ipc::Buffer; +use num_traits::ToPrimitive; pub struct Rtc { conn: CID, callback_sid: Option, + llio: llio::Llio, } static mut RTC_CB: Option = None; impl Rtc { @@ -18,6 +19,7 @@ impl Rtc { Ok(Rtc { conn, callback_sid: None, + llio: llio::Llio::new(&xns).expect("Can't connect to LLIO on behalf of RTC library"), }) } @@ -25,7 +27,7 @@ impl Rtc { let buf = Buffer::into_buf(dt).or(Err(xous::Error::InternalError))?; buf.lend(self.conn, Opcode::SetDateTime.to_u32().unwrap()).map(|_| ()) } - pub fn rtc_callback(&mut self, cb: fn(DateTime)) -> Result<(), xous::Error> { + pub fn hook_rtc_callback(&mut self, cb: fn(DateTime)) -> Result<(), xous::Error> { if unsafe{RTC_CB}.is_some() { return Err(xous::Error::MemoryInUse) } @@ -42,21 +44,38 @@ impl Rtc { } Ok(()) } + // this simply forwards the hook on to the LLIO library, which actually owns the Event peripheral where the interrupt is generated + pub fn hook_rtc_alarm_callback(&mut self, id: u32, cid: CID) -> Result<(), xous::Error> { + self.llio.hook_rtc_alarm_callback(id, cid) + } + pub fn request_datetime(&self) -> Result<(), xous::Error> { send_message(self.conn, Message::new_scalar(Opcode::RequestDateTime.to_usize().unwrap(), 0, 0, 0, 0) ).map(|_|()) } - pub fn set_alarm(&self, seconds_from_now: u8) -> Result<(), xous::Error> { + /// wakeup alarm will force the system on if it is off, but does not trigger an interrupt on the CPU + pub fn set_wakeup_alarm(&self, seconds_from_now: u8) -> Result<(), xous::Error> { send_message(self.conn, Message::new_scalar(Opcode::SetWakeupAlarm.to_usize().unwrap(), seconds_from_now as _, 0, 0, 0) ).map(|_|()) } - pub fn clear_alarm(&self) -> Result<(), xous::Error> { + pub fn clear_wakeup_alarm(&self) -> Result<(), xous::Error> { send_message(self.conn, Message::new_scalar(Opcode::ClearWakeupAlarm.to_usize().unwrap(), 0, 0, 0, 0) ).map(|_|()) } + /// the rtc alarm will not turn the system on, but it will trigger an interrupt on the CPU + pub fn set_rtc_alarm(&self, seconds_from_now: u8) -> Result<(), xous::Error> { + send_message(self.conn, + Message::new_scalar(Opcode::SetRtcAlarm.to_usize().unwrap(), seconds_from_now as _, 0, 0, 0) + ).map(|_|()) + } + pub fn clear_rtc_alarm(&self) -> Result<(), xous::Error> { + send_message(self.conn, + Message::new_scalar(Opcode::ClearRtcAlarm.to_usize().unwrap(), 0, 0, 0, 0) + ).map(|_|()) + } } impl Drop for Rtc { diff --git a/services/rtc/src/main.rs b/services/rtc/src/main.rs index 4002beaa7..feec614e1 100644 --- a/services/rtc/src/main.rs +++ b/services/rtc/src/main.rs @@ -2,18 +2,21 @@ #![cfg_attr(target_os = "none", no_main)] mod api; -use api::*; use num_traits::FromPrimitive; -use xous_ipc::{String, Buffer}; -use api::{Return, Opcode}; -use xous::{CID, msg_scalar_unpack, msg_blocking_scalar_unpack}; +use xous_ipc::Buffer; +use api::{Return, Opcode, DateTime}; +use xous::{CID, msg_scalar_unpack}; #[cfg(target_os = "none")] mod implementation { - use log::info; - #[macro_use] + #![allow(dead_code)] use bitflags::*; + use crate::CB_TO_MAIN_CONN; + use llio::{I2cStatus, I2cTransaction, Llio}; + use crate::api::{Opcode, DateTime, Weekday}; + use xous_ipc::Buffer; + use num_traits::ToPrimitive; const ABRTCMC_I2C_ADR: u8 = 0x68; const ABRTCMC_CONTROL1: u8 = 0x00; @@ -194,144 +197,256 @@ mod implementation { (bcd & 0xf) + ((bcd >> 4) * 10) } - fn to_weekday(bcd: u8) -> Weekdays { + fn to_weekday(bcd: u8) -> Weekday { match bcd { - 0 => Weekdays::SUNDAY, - 1 => Weekdays::MONDAY, - 2 => Weekdays::TUESDAY, - 3 => Weekdays::WEDNESDAY, - 4 => Weekdays::THURSDAY, - 5 => Weekdays::FRIDAY, - 6 => Weekdays::SATURDAY, - _ => Weekdays::SUNDAY, + 0 => Weekday::Sunday, + 1 => Weekday::Monday, + 2 => Weekday::Tuesday, + 3 => Weekday::Wednesday, + 4 => Weekday::Thursday, + 5 => Weekday::Friday, + 6 => Weekday::Saturday, + _ => Weekday::Sunday, + } + } + + fn i2c_callback(trans: I2cTransaction) { + if trans.status == I2cStatus::ResponseReadOk { + if let Some(cb_to_main_conn) = unsafe{CB_TO_MAIN_CONN} { + // we expect this to be 0, as we don't set it + assert!(trans.callback_id == 0, "callback ID was incorrect!"); + if let Some(rxbuf) = trans.rxbuf { + let dt = DateTime { + seconds: to_binary(rxbuf[0] & 0x7f), + minutes: to_binary(rxbuf[1] & 0x7f), + hours: to_binary(rxbuf[2] & 0x3f), + days: to_binary(rxbuf[3] & 0x3f), + weekday: to_weekday(rxbuf[4] & 0x7f), + months: to_binary(rxbuf[5] & 0x1f), + years: to_binary(rxbuf[6]), + }; + let buf = Buffer::into_buf(dt).unwrap(); + buf.send(cb_to_main_conn, Opcode::ResponseDateTime.to_u32().unwrap()).unwrap(); + } else { + log::error!("i2c_callback: no rx data to unpack!") + } + } else { + log::error!("i2c_callback happened, but no connection to the main server!"); + } } } pub struct Rtc { - pub seconds: u8, - pub minutes: u8, - pub hours: u8, - pub days: u8, - pub months: u8, - pub years: u8, - pub weekday: Weekdays, - updated_ticks: u64, + llio: Llio, + rtc_alarm_enabled: bool, + wakeup_alarm_enabled: bool, } impl Rtc { - pub fn new() -> Rtc { - info!("RTC: hardware initialized"); - + pub fn new(xns: &xous_names::XousNames) -> Rtc { + log::trace!("hardware initialized"); + let mut llio = Llio::new(xns).expect("can't connect to LLIO"); + llio.hook_i2c_callback(i2c_callback).expect("can't hook I2C callback"); Rtc { - seconds: 0, - minutes: 0, - hours: 0, - days: 0, - months: 0, - years: 0, - weekday: Weekdays::SUNDAY, - updated_ticks: 0, + llio, + rtc_alarm_enabled: false, + wakeup_alarm_enabled: false, } } - /// we only support 24 hour mode - /// TODO: sanity check arguments - /// TODO: write accesses should happen in a single block, to guarante atomicity of the operation - pub fn rtc_set(&mut self, secs: u8, mins: u8, hours: u8, days: u8, months: u8, years: u8, d: Weekdays) -> bool { - let mut txbuf: [u8; 2]; + 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]; + + if secs > 59 { return Ok(false); } + if mins > 59 { return Ok(false); } + if hours > 23 { return Ok(false); } + if days > 31 { return Ok(false); } + if months > 12 { return Ok(false); } + if years > 99 { return Ok(false); } + + // convert enum to bitfields + let d = match day { + Weekday::Monday => Weekdays::MONDAY, + Weekday::Tuesday => Weekdays::TUESDAY, + Weekday::Wednesday => Weekdays::WEDNESDAY, + Weekday::Thursday => Weekdays::THURSDAY, + Weekday::Friday => Weekdays::FRIDAY, + Weekday::Saturday => Weekdays::SATURDAY, + Weekday::Sunday => Weekdays::SUNDAY, + }; // make sure battery switchover is enabled, otherwise we won't keep time when power goes off - txbuf = [ABRTCMC_CONTROL3, (Control3::BATT_STD_BL_EN).bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); + txbuf[0] = ABRTCMC_CONTROL3; + txbuf[1] = (Control3::BATT_STD_BL_EN).bits(); + txbuf[2] = to_bcd(secs); + txbuf[3] = to_bcd(mins); + txbuf[4] = to_bcd(hours); + txbuf[5] = to_bcd(days); + txbuf[6] = to_bcd(d.bits); + txbuf[7] = to_bcd(months); + txbuf[8] = to_bcd(years); - txbuf = [ABRTCMC_SECONDS, to_bcd(secs)]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.updated_ticks = get_ticks(&self.p); - self.seconds = secs; - - txbuf = [ABRTCMC_MINUTES, to_bcd(mins)]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.minutes = mins; - - txbuf = [ABRTCMC_HOURS, to_bcd(hours)]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.hours = hours; - - txbuf = [ABRTCMC_DAYS, to_bcd(days)]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.days = days; - - txbuf = [ABRTCMC_MONTHS, to_bcd(months)]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.months = months; - - txbuf = [ABRTCMC_YEARS, to_bcd(years)]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.years = years; - - txbuf = [ABRTCMC_WEEKDAYS, d.bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - self.weekday = d; - - true // sanity check args would return false on fail - } - - pub fn rtc_update(&mut self) { - let txbuf: [u8; 1]; - let mut rxbuf: [u8; 7] = [0; 7]; - - // only update from RTC if more than 1 second has passed since the last update - if get_ticks(&self.p) - self.updated_ticks > 1000 { - // read as a single block to make the time readout atomic - txbuf = [ABRTCMC_SECONDS]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), Some(&mut rxbuf), I2C_TIMEOUT); - - self.seconds = to_binary(rxbuf[0] & 0x7f); - self.minutes = to_binary(rxbuf[1] & 0x7f); - self.hours = to_binary(rxbuf[2] & 0x3f); - self.days = to_binary(rxbuf[3] & 0x3f); - self.weekday = to_weekday(rxbuf[4] & 0x7f); - self.months = to_binary(rxbuf[5] & 0x1f); - self.years = to_binary(rxbuf[6]); - - self.updated_ticks = get_ticks(&self.p); + transaction.bus_addr = ABRTCMC_I2C_ADR; + transaction.txbuf = Some(txbuf); + transaction.txlen = 9; + transaction.status = I2cStatus::RequestIncoming; + match self.llio.send_i2c_request(transaction) { + Ok(status) => { + match status { + I2cStatus::ResponseInProgress => Ok(true), + I2cStatus::ResponseBusy => Err(xous::Error::ServerQueueFull), + _ => Err(xous::Error::InternalError), + } + } + _ => Err(xous::Error::InternalError) } } - /// testing-only routine -- wakeup self after designated number of seconds - pub fn wakeup_alarm(&mut self, seconds: u8) { - let mut txbuf: [u8; 2]; - - // make sure battery switchover is enabled - txbuf = [ABRTCMC_CONTROL3, (Control3::BATT_STD_BL_EN).bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - - // set clock units to 1 second, output pulse length to ~218ms - txbuf = [ABRTCMC_TIMERB_CLK, (TimerClk::CLK_1_S | TimerClk::PULSE_218_MS).bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - - // program elapsed time - txbuf = [ABRTCMC_TIMERB, seconds]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - - // enable timerb countdown interrupt, also clears any prior interrupt flag - txbuf = [ABRTCMC_CONTROL2, (Control2::COUNTDOWN_B_INT).bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); - - // turn on the timer proper -- the system will restart in 5...4..3.... - txbuf = [ABRTCMC_CONFIG, (Config::TIMER_B_ENABLE | Config::CLKOUT_DISABLE).bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); + pub fn rtc_get(&mut self) -> Result<(), xous::Error> { + let mut transaction = I2cTransaction::new(); + let mut txbuf = [0; 258]; + let rxbuf = [0; 258]; + txbuf[0] = ABRTCMC_SECONDS; + transaction.bus_addr = ABRTCMC_I2C_ADR; + transaction.txlen = 1; + transaction.rxlen = 7; + transaction.txbuf = Some(txbuf); + transaction.rxbuf = Some(rxbuf); + transaction.status = I2cStatus::RequestIncoming; + match self.llio.send_i2c_request(transaction) { + Ok(status) => { + match status { + I2cStatus::ResponseInProgress => Ok(()), + I2cStatus::ResponseBusy => Err(xous::Error::ServerQueueFull), + _ => Err(xous::Error::InternalError), + } + } + _ => Err(xous::Error::InternalError) + } } - pub fn clear_alarm(&mut self) { - // turn off RTC wakeup timer, in case previously set - let mut txbuf : [u8; 2] = [ABRTCMC_CONFIG, (Config::CLKOUT_DISABLE).bits()]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); + fn blocking_i2c_write2(&self, tx: [u8; 2]) -> bool { + let mut transaction = I2cTransaction::new(); + let mut txbuf: [u8; 258] = [0; 258]; + txbuf[0] = tx[0]; + txbuf[1] = tx[1]; + transaction.bus_addr = ABRTCMC_I2C_ADR; + transaction.txbuf = Some(txbuf); + transaction.txlen = 2; + transaction.status = I2cStatus::RequestIncoming; - // clear all interrupts and flags - txbuf = [ABRTCMC_CONTROL2, 0]; - i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT); + while self.llio.poll_i2c_busy().unwrap() { + xous::yield_slice(); + } + let mut sent = false; + while !sent { + match self.llio.send_i2c_request(transaction) { + Ok(status) => { + match status { + I2cStatus::ResponseInProgress => sent = true, + I2cStatus::ResponseBusy => sent = false, + _ => {log::error!("try_send_i2c unhandled response"); return false;}, + } + } + _ => {log::error!("try_send_i2c unhandled error"); return false;} + } + xous::yield_slice(); + } + true + } + + /// wakeup self after designated number of seconds + pub fn wakeup_alarm(&mut self, seconds: u8) { + self.wakeup_alarm_enabled = true; + + // make sure battery switchover is enabled, otherwise we won't keep time when power goes off + self.blocking_i2c_write2([ABRTCMC_CONTROL3, (Control3::BATT_STD_BL_EN).bits()]); + + // set clock units to 1 second, output pulse length to ~218ms + self.blocking_i2c_write2([ABRTCMC_TIMERB_CLK, (TimerClk::CLK_1_S | TimerClk::PULSE_218_MS).bits()]); + + // program elapsed time + self.blocking_i2c_write2([ABRTCMC_TIMERB, seconds]); + + // enable timerb countdown interrupt, also clears any prior interrupt flag + let mut control2 = (Control2::COUNTDOWN_B_INT).bits(); + if self.rtc_alarm_enabled { + control2 |= Control2::COUNTDOWN_A_INT.bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONTROL2, control2]); + + // turn on the timer proper -- the system will wakeup in 5..4..3.... + let mut config = (Config::CLKOUT_DISABLE | Config::TIMER_B_ENABLE | Config::TIMERB_INT_PULSED).bits(); + if self.rtc_alarm_enabled { + config |= (Config::TIMER_A_COUNTDWN | Config::TIMERA_SECONDS_INT_PULSED).bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONFIG, config]); + } + + pub fn clear_wakeup_alarm(&mut self) { + self.wakeup_alarm_enabled = false; + + let mut config = Config::CLKOUT_DISABLE.bits(); + if self.rtc_alarm_enabled { + config |= (Config::TIMER_A_COUNTDWN | Config::TIMERA_SECONDS_INT_PULSED).bits(); + } + // turn off RTC wakeup timer, in case previously set + self.blocking_i2c_write2([ABRTCMC_CONFIG, config]); + + // clear my interrupts and flags + let mut control2 = 0; + if self.rtc_alarm_enabled { + control2 |= Control2::COUNTDOWN_A_INT.bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONTROL2, control2]); + } + + + + pub fn rtc_alarm(&mut self, seconds: u8) { + self.rtc_alarm_enabled = true; + // make sure battery switchover is enabled, otherwise we won't keep time when power goes off + self.blocking_i2c_write2([ABRTCMC_CONTROL3, (Control3::BATT_STD_BL_EN).bits()]); + + // set clock units to 1 second, output pulse length to ~218ms + self.blocking_i2c_write2([ABRTCMC_TIMERA_CLK, (TimerClk::CLK_1_S | TimerClk::PULSE_218_MS).bits()]); + + // program elapsed time + self.blocking_i2c_write2([ABRTCMC_TIMERA, seconds]); + + // enable timerb countdown interrupt, also clears any prior interrupt flag + let mut control2 = (Control2::COUNTDOWN_A_INT).bits(); + if self.wakeup_alarm_enabled { + control2 |= Control2::COUNTDOWN_B_INT.bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONTROL2, control2]); + + // turn on the timer proper -- interrupt in 5..4..3.... + let mut config = (Config::CLKOUT_DISABLE | Config::TIMER_A_COUNTDWN | Config::TIMERA_SECONDS_INT_PULSED).bits(); + if self.wakeup_alarm_enabled { + config |= (Config::TIMER_B_ENABLE | Config::TIMERB_INT_PULSED).bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONFIG, config]); + } + + pub fn clear_rtc_alarm(&mut self) { + self.rtc_alarm_enabled = false; + // turn off RTC wakeup timer, in case previously set + let mut config = Config::CLKOUT_DISABLE.bits(); + if self.wakeup_alarm_enabled { + config |= (Config::TIMER_B_ENABLE | Config::TIMERB_INT_PULSED).bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONFIG, config]); + + // clear my interrupts and flags + let mut control2 = 0; + if self.wakeup_alarm_enabled { + control2 |= Control2::COUNTDOWN_B_INT.bits(); + } + self.blocking_i2c_write2([ABRTCMC_CONTROL2, control2]); } } } @@ -369,39 +484,146 @@ mod implementation { } } +static mut CB_TO_MAIN_CONN: Option = None; #[xous::xous_main] fn xmain() -> ! { use crate::implementation::Rtc; log_server::init_wait().unwrap(); log::set_max_level(log::LevelFilter::Trace); - log::info!("RTC: my PID is {}", xous::process::id()); + log::info!("my PID is {}", xous::process::id()); let xns = xous_names::XousNames::new().unwrap(); - let rtc_sid = xns.register_name(api::SERVER_NAME_RTC).expect("RTC: can't register server"); - log::trace!("RTC: registered with NS -- {:?}", rtc_sid); + let rtc_sid = xns.register_name(api::SERVER_NAME_RTC).expect("can't register server"); + log::trace!("registered with NS -- {:?}", rtc_sid); + unsafe{CB_TO_MAIN_CONN = Some(xous::connect(rtc_sid).unwrap())}; #[cfg(target_os = "none")] - let rtc = Rtc::new(); + let mut rtc = Rtc::new(&xns); #[cfg(not(target_os = "none"))] let mut rtc = Rtc::new(); - let mut cb_conns: [Option; 32] = [None; 32]; - log::trace!("RTC: ready to accept requests"); + let ticktimer = ticktimer_server::Ticktimer::new().expect("can't connect to ticktimer"); + let mut dt_cb_conns: [Option; 32] = [None; 32]; + log::trace!("ready to accept requests"); loop { let msg = xous::receive_message(rtc_sid).unwrap(); log::trace!("Message: {:?}", msg); match FromPrimitive::from_usize(msg.body.id()) { Some(Opcode::SetDateTime) => { let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let dt = buffer.as_flat::().unwrap(); + let dt = buffer.to_original::().unwrap(); + let mut sent = false; + while !sent { + match rtc.rtc_set( + dt.seconds, + dt.minutes, + dt.hours, + dt.days, + dt.months, + dt.years, + dt.weekday, + ) { + Ok(true) => {sent = true;}, + Ok(false) => {sent = true; log::error!("badly formatted arguments setting RTC date and time");} + Err(xous::Error::ServerQueueFull) => { + sent = false; + log::trace!("I2C interface was busy setting date and time, retrying"); + ticktimer.sleep_ms(1).unwrap(); // wait a quanta of time and then retry + }, + _ => { + sent = true; + log::error!("error setting RTC date time"); + } + } + } + }, + Some(Opcode::RegisterDateTimeCallback) => 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 dt_cb_conns.iter_mut() { + if *entry == None { + *entry = cid; + found = true; + break; + } + } + if !found { + log::error!("RegisterDateTimeCallback listener ran out of space registering callback"); + } + }), + Some(Opcode::ResponseDateTime) => { + let incoming_buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let dt = incoming_buffer.to_original::().unwrap(); + let ret = Return::ReturnDateTime(dt); + let outgoing_buf = Buffer::into_buf(ret).or(Err(xous::Error::InternalError)).unwrap(); + for maybe_conn in dt_cb_conns.iter_mut() { + if let Some(conn) = maybe_conn { + match outgoing_buf.lend(*conn, 0) { // the ID field is ignored on the callback server + Err(xous::Error::ServerNotFound) => { + *maybe_conn = None + }, + Ok(_) => {}, + _ => panic!("unhandled error or result in callback processing") + } + } + } + }, + Some(Opcode::RequestDateTime) => { + let mut sent = false; + while !sent { + match rtc.rtc_get() { + Ok(_) => sent = true, + Err(xous::Error::ServerQueueFull) => { + sent = false; + log::trace!("I2C interface was busy getting date and time, retrying"); + ticktimer.sleep_ms(1).unwrap(); + }, + _ => { + sent = true; + log::error!("error requesting RTC date and time"); + } + } + } + } + Some(Opcode::SetWakeupAlarm) => msg_scalar_unpack!(msg, delay, _, _, _, { + rtc.wakeup_alarm(delay as u8); // this will block until finished, no callbacks used + }), + Some(Opcode::ClearWakeupAlarm) => msg_scalar_unpack!(msg, _, _, _, _, { + rtc.clear_wakeup_alarm(); // blocks until transaction is finished + }), + Some(Opcode::SetRtcAlarm) => msg_scalar_unpack!(msg, delay, _, _, _, { + rtc.rtc_alarm(delay as u8); // this will block until finished, no callbacks used + }), + Some(Opcode::ClearRtcAlarm) => msg_scalar_unpack!(msg, _, _, _, _, { + rtc.clear_rtc_alarm(); // blocks until transaction is finished + }), + None => { + log::error!("unknown opcode received, exiting"); + break; } } } // clean up our program log::trace!("main loop exit, destroying servers"); + unsafe{ + if let Some(cb)= CB_TO_MAIN_CONN { + xous::disconnect(cb).unwrap(); + } + } + for entry in dt_cb_conns.iter_mut() { + if let Some(conn) = entry { + let dropmsg = Return::Drop; + let buf = Buffer::into_buf(dropmsg).unwrap(); + buf.lend(*conn, 0).unwrap(); // the ID is ignored for this server + unsafe{xous::disconnect(*conn).unwrap();} + } + *entry = None; + } xns.unregister_server(rtc_sid).unwrap(); xous::destroy_server(rtc_sid).unwrap(); log::trace!("quitting"); + xous::terminate_process(); loop {} } diff --git a/services/ticktimer-server/Cargo.toml b/services/ticktimer-server/Cargo.toml index b80f6af5b..c85bc9d1e 100644 --- a/services/ticktimer-server/Cargo.toml +++ b/services/ticktimer-server/Cargo.toml @@ -21,7 +21,7 @@ utralib = {path = "../../utralib"} [features] debug-print = [] watchdog = [] -# generally you want to disable watchdog if you're doing development. +# generally you want to disable watchdog if you're doing development default = ["watchdog"] -#default = [] +# default = [] # default = ["debug-print"] diff --git a/svd2utra/examples/soc.svd b/svd2utra/examples/soc.svd index 70babeb36..9d394f73c 100644 --- a/svd2utra/examples/soc.svd +++ b/svd2utra/examples/soc.svd @@ -1328,10 +1328,10 @@ register to disable individual events.]]> GIT_GITREV 0x0014 - 0x8561717c + 0x79ae30c6 32 @@ -1348,7 +1348,7 @@ the exact git version used to build this firmware.]]> is ``1``, then the repository this was built from has one additional commit beyond the tag indicated in `MAJOR`, `MINOR`, and `REVISION`.]]> 0x0018 - 0x0f + 0x10 32 @@ -2550,6 +2550,10 @@ reset fashion]]> 0x14 registers + + power + 9 + SPINOR @@ -3044,7 +3048,7 @@ again until the interrupt is serviced.]]> keyboard - 9 + 10 @@ -3056,7 +3060,7 @@ again until the interrupt is serviced.]]> SEED1 0x0000 - 0x62e0ffce + 0x505c16c1 32 @@ -3071,7 +3075,7 @@ again until the interrupt is serviced.]]> SEED0 0x0004 - 0x629a6ab2 + 0x578f7014 32 @@ -3500,7 +3504,7 @@ I2S_FORMAT.I2S_STANDARD is I2S standard]]> audio - 10 + 11 @@ -3636,7 +3640,7 @@ I2S_FORMAT.I2S_STANDARD is I2S standard]]> trng_kernel - 11 + 12 @@ -3968,7 +3972,7 @@ to max field size]]> trng_server - 12 + 13 @@ -4776,7 +4780,7 @@ in bits]]> sha512 - 13 + 14 @@ -5005,7 +5009,7 @@ exactly reflects the binary layout of an Engine instruction.]]> engine - 14 + 15 @@ -5223,7 +5227,7 @@ register to disable individual events.]]> wdt - 15 + 16 @@ -5294,21 +5298,22 @@ register to disable individual events.]]> - + - + - - + + + - - + + - + \ No newline at end of file diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 1b50dc848..f1072a387 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -49,6 +49,7 @@ fn try_main() -> Result<(), DynError> { "keyboard", "trng", "llio", + "rtc", ]; let fcc_pkgs = [ "fcc-agent",