From 8b8cad067cf387f7e0ea0c162403c93e03cfec7a Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 16 Mar 2021 15:52:30 +0800 Subject: [PATCH] add the i2c file proper --- services/llio/src/i2c.rs | 204 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 services/llio/src/i2c.rs diff --git a/services/llio/src/i2c.rs b/services/llio/src/i2c.rs new file mode 100644 index 000000000..9ed5e9c9e --- /dev/null +++ b/services/llio/src/i2c.rs @@ -0,0 +1,204 @@ +use heapless::Vec; +use heapless::consts::*; + +use crate::api::*; +use utralib::*; + +enum I2cState { + Idle, + Write, + Read, +} +struct I2cStateMachine { + transaction: I2cTransaction, + state: I2cState, + index: u32, // index of the current buffer in the state machine + timestamp: u64, // timestamp of the last transaction + ticktimer: xous::CID, // a connection to the ticktimer so we can measure timeouts + i2c_csr: utralib::CSR, + listeners: Vec, +} +impl I2cStateMachine { + pub fn new(ticktimer: xous::CID, i2c_csr: utralib::CSR) -> Self { + I2cStateMachine { + transaction: I2cTransaction::new(), + state: I2cState::Idle, + timestamp: ticktimer_server::elapsed_ms(ticktimer).unwrap(), + ticktimer, + i2c_csr, + index: 0, + listeners: Vec::new(), + } + } + pub fn initiate(&mut self, transaction: I2cTransaction ) -> I2cStatus { + // sanity-check the bounds limits, currently imposed by trait implementations available in rkyv + if transaction.txlen > 31 || transaction.rxlen > 31 { + return I2cStatus::ResponseFormatError + } + + let now = ticktimer_server::elapsed_ms(ticktimer).unwrap(); + if self.state != I2cState::Idle && ((now - self.timestamp) < self.transaction.timeout_ms) { + // we're in a transaction that hadn't timed out, can't accept a new one + I2cStatus::ResponseBusy + } else { + if self.state != I2cState::Idle { + // we're in a transaction, but previous transaction had timed out... + self.report_timeout(); + // reset our state parameter + self.state = I2cState::Idle; + self.index = 0; + // now we're ready to move on and try a new transaction. We hope! Maybe the block should be reset?? TBD. Need to understand the nature of the timeouts better, if and when they do happen. + } + self.timestamp = now; + self.transaction = transaction.clone(); + + if self.transaction.status == I2cStatus::RequestIncoming { + self.transaction.status = I2cStatus::ResponseInProgress; + // now do the BusAddr stuff, so that the we can get the irq response + if let Some(txbuf) = self.transaction.txbuf { + self.state = I2cState::Write; + self.i2c_csr.wfo(utra::i2c::TXR_TXR, (self.transaction.bus_addr << 1 | 0) as u32); + self.index = 0; + self.i2c_csr.wo(utra::i2c::COMMAND, + self.i2c_csr.ms(utra::i2c::COMMAND_WR, 1) | + self.i2c_csr.ms(utra::i2c::COMMAND_STA, 1) + ); + I2cStatus::ResponseInProgress + } else if let Some(rxbuf) = self.transaction.rxbuf { + self.state = I2cState::Read; + self.i2c_csr.wfo(utra::i2c::TXR_TXR, (self.transaction.bus_addr << 1 | 1) as u32); + self.index = 0; + self.i2c_csr.wo(utra::i2c::COMMAND, + self.i2c_csr.ms(utra::i2c::COMMAND_WR, 1) | + self.i2c_csr.ms(utra::i2c::COMMAND_STA, 1) + ); + I2cStatus::ResponseInProgress + } else { + // no buffers specified, erase everything and go to idle + self.state = I2cState::Idle; + self.transaction = I2cTransaction::new(); + I2cStatus::ResponseFormatError + } + } + } + } + fn report_nack(&mut self) { + // report the NACK situation to all the listeners + let mut nack = I2cTransaction::new(); + nack.status = I2cStatus::ResponseNack; + for listener in self.listeners { + 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 listener in self.listeners { + 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 listener in self.listeners { + 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 listener in self.listeners { + 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> { + self.listeners.push(listener) + } + pub fn handler(&mut self) { + // check if the transaction had actually timed out + let now = ticktimer_server::elapsed_ms(ticktimer).unwrap(); + if now - self.timestamp > self.transaction.timeout_ms { + // previous transaction had timed out... + self.report_timeout(); + // reset our state parameter + self.state = I2cState::Idle; + self.index = 0; + self.timestamp = now; + return; + } + self.timestamp = now; + + match self.state { + I2cState::Write => { + if let Some(txbuf) = self.transaction.txbuf { + // check ack bit + if self.i2c_csr.rf(utra::i2c::STATUS_RXACK) != 1 { + self.state = I2cState::Idle; + self.transaction = I2cTransaction::new(); + self.report_nack(); + } + // send next byte if there is one + if self.index < self.transaction.txlen { + self.i2c_csr.wfo(utra::i2c::TXR_TXR, txbuf[self.index as usize] as u32); + if self.index == (self.transaction.txlen - 1) && self.transaction.rxbuf.is_none() { + // send a stop bit if this is the very last in the series + self.i2c_csr.wo(utra::i2c::COMMAND, + self.i2c_csr.ms(utra::i2c::COMMAND_WR, 1) | + self.i2c_csr.ms(utra::i2c::COMMAND_STO, 1) + ); + } else { + self.i2c_csr.wfo(utra::i2c::COMMAND_WR, 1); + } + self.index += 1; + } else { + if let Some(rxbuf) = self.transaction.rxbuf { + self.state = I2cState::Read; + self.i2c_csr.wfo(utra::i2c::TXR_TXR, (self.transaction.bus_addr << 1 | 1) as u32); + self.index = 0; + self.i2c_csr.wo(utra::i2c::COMMAND, + self.i2c_csr.ms(utra::i2c::COMMAND_WR, 1) | + self.i2c_csr.ms(utra::i2c::COMMAND_STA, 1) + ); + } else { + self.report_write_done(); + self.state = I2cState::Idle; + } + } + } else { + // we should never get here, because txbuf was checked as Some() by the setup routine + log::error!("LLIO|I2C: illegal write state"); + } + }, + I2cState::Read => { + if let Some(rxbuf) = self.transaction.rxbuf { + if self.index > 0 { + // we are re-entering from a previous call, store the read value from the previous call + rxbuf[index - 1] = self.i2c_csr.rf(utra::i2c::RXR_RXR) as u8; + } + if self.index < self.transaction.rxlen { + if self.index == (self.transaction.rxlen - 1) { + self.i2c_csr.wo(utra::i2c::COMMAND, + self.i2c_csr.ms(utra::i2c::COMMAND_RD, 1) | + self.i2c_csr.ms(utra::i2c::COMMAND_STO, 1) | + self.i2c_csr.ms(utra::i2c::COMMAND_ACK, 1) + ); + } else { + self.i2c_csr.wfo(utra::i2c::COMMAND_RD, 1); + } + self.index += 1; + } else { + self.report_read_done(); + self.state = I2cState::Idle; + } + } else { + // we should never get here, because rxbuf was checked as Some() by the setup routine + log::error!("LLIO|I2C: illegal read state"); + } + }, + I2cState::Idle => { + log::error!("LLIO|I2C: received interrupt event when no transaciton pending!"); + } + } + } +}