Merge pull request #613 from betrusted-io/usb-irq

USB IRQ integration
This commit is contained in:
bunnie 2025-01-02 22:14:17 +02:00 committed by GitHub
commit e0d1085ec7
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
16 changed files with 408 additions and 43 deletions

1
Cargo.lock generated
View file

@ -957,6 +957,7 @@ dependencies = [
name = "cram-hal-service" name = "cram-hal-service"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"bitfield",
"cramium-hal", "cramium-hal",
"log", "log",
"num-derive 0.4.2", "num-derive 0.4.2",

View file

@ -30,6 +30,41 @@ const REG_DLDO1_V: usize = 0x99;
#[allow(dead_code)] #[allow(dead_code)]
const REG_DLDO2_V: usize = 0x9A; const REG_DLDO2_V: usize = 0x9A;
const REG_IRQ_ENABLE0: u8 = 0x40;
#[allow(dead_code)]
const REG_IRQ_ENABLE1: u8 = 0x41;
#[allow(dead_code)]
const REG_IRQ_ENABLE2: u8 = 0x42;
const REG_IRQ_STATUS0: u8 = 0x48;
const REG_IRQ_STATUS1: u8 = 0x49;
#[allow(dead_code)]
const REG_IRQ_STATUS2: u8 = 0x4A;
const VBUS_INSERT_MASK: u8 = 0x80;
const VBUS_REMOVE_MASK: u8 = 0x40;
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub enum VbusIrq {
None,
Insert,
Remove,
InsertAndRemove,
}
/// From the raw u8 read back from the register
impl From<u8> for VbusIrq {
fn from(value: u8) -> Self {
if (value & VBUS_INSERT_MASK) == 0 && (value & VBUS_REMOVE_MASK) == 0 {
VbusIrq::None
} else if (value & VBUS_INSERT_MASK) != 0 && (value & VBUS_REMOVE_MASK) == 0 {
VbusIrq::Insert
} else if (value & VBUS_INSERT_MASK) == 0 && (value & VBUS_REMOVE_MASK) != 0 {
VbusIrq::Remove
} else {
VbusIrq::InsertAndRemove
}
}
}
#[repr(u8)] #[repr(u8)]
#[derive(PartialEq, Eq, Clone, Copy)] #[derive(PartialEq, Eq, Clone, Copy)]
pub enum WhichLdo { pub enum WhichLdo {
@ -215,6 +250,37 @@ impl Axp2101 {
} }
ctl ctl
} }
/// This will clear all other IRQ sources except VBUS IRQ
/// If we need to take more IRQ sources then this API will need to be refactored.
pub fn setup_vbus_irq(&mut self, i2c: &mut dyn i2c::I2cApi, mode: VbusIrq) -> Result<(), xous::Error> {
let data = match mode {
VbusIrq::None => 0u8,
VbusIrq::Insert => VBUS_INSERT_MASK,
VbusIrq::Remove => VBUS_REMOVE_MASK,
VbusIrq::InsertAndRemove => VBUS_INSERT_MASK | VBUS_REMOVE_MASK,
};
// ENABLE1 has the code we want to target, but the rest also needs to be cleared so
// fill the values in with 0.
i2c.i2c_write(AXP2101_DEV, REG_IRQ_ENABLE0, &[0, data, 0]).map(|_| ())?;
// clear the status bits
let mut status = [0u8; 3];
i2c.i2c_read(AXP2101_DEV, REG_IRQ_STATUS0, &mut status, false)?;
i2c.i2c_write(AXP2101_DEV, REG_IRQ_STATUS0, &status).map(|_| ())
}
pub fn get_vbus_irq_status(&self, i2c: &mut dyn i2c::I2cApi) -> Result<VbusIrq, xous::Error> {
let mut buf = [0u8];
i2c.i2c_read(AXP2101_DEV, REG_IRQ_STATUS1, &mut buf, false)?;
Ok(VbusIrq::from(buf[0]))
}
/// This will clear all pending IRQs, regardless of the setup
pub fn clear_vbus_irq_pending(&mut self, i2c: &mut dyn i2c::I2cApi) -> Result<(), xous::Error> {
let data = VBUS_INSERT_MASK | VBUS_REMOVE_MASK;
i2c.i2c_write(AXP2101_DEV, REG_IRQ_STATUS1, &[data]).map(|_| ())
}
} }
pub fn parse_dcdc_ena(d: u8) -> ([bool; 4], bool, bool) { pub fn parse_dcdc_ena(d: u8) -> ([bool; 4], bool, bool) {

View file

@ -1,7 +1,7 @@
// Constants that define pin locations, RAM offsets, etc. for the BaoSec board // Constants that define pin locations, RAM offsets, etc. for the BaoSec board
use crate::iox; use crate::iox;
use crate::iox::IoSetup;
use crate::iox::*; use crate::iox::*;
use crate::iox::{IoIrq, IoSetup};
pub const I2C_AXP2101_ADR: u8 = 0x34; pub const I2C_AXP2101_ADR: u8 = 0x34;
pub const I2C_TUSB320_ADR: u8 = 0x47; pub const I2C_TUSB320_ADR: u8 = 0x47;
@ -150,6 +150,7 @@ pub fn setup_memory_pins(iox: &dyn IoSetup) -> crate::udma::SpimChannel {
crate::udma::SpimChannel::Channel1 crate::udma::SpimChannel::Channel1
} }
/// This also sets up I2C-adjacent interrupt inputs as well
pub fn setup_i2c_pins(iox: &dyn IoSetup) -> crate::udma::I2cChannel { pub fn setup_i2c_pins(iox: &dyn IoSetup) -> crate::udma::I2cChannel {
// I2C_SCL_B[0] // I2C_SCL_B[0]
iox.setup_pin( iox.setup_pin(
@ -173,6 +174,17 @@ pub fn setup_i2c_pins(iox: &dyn IoSetup) -> crate::udma::I2cChannel {
Some(IoxEnable::Enable), Some(IoxEnable::Enable),
Some(IoxDriveStrength::Drive2mA), Some(IoxDriveStrength::Drive2mA),
); );
// PB13 -> PMIC IRQ
iox.setup_pin(
IoxPort::PB,
13,
Some(IoxDir::Input),
Some(IoxFunction::Gpio),
Some(IoxEnable::Enable),
Some(IoxEnable::Enable),
None,
None,
);
crate::udma::I2cChannel::Channel0 crate::udma::I2cChannel::Channel0
} }
@ -260,3 +272,7 @@ pub fn setup_kb_pins<T: IoSetup + IoGpio>(iox: &T) -> ([(IoxPort, u8); 3], [(Iox
(KB_PORT, C_PINS[2]), (KB_PORT, C_PINS[2]),
]) ])
} }
pub fn setup_pmic_irq<T: IoIrq>(iox: &T, server: &str, opcode: usize) {
iox.set_irq_pin(IoxPort::PB, 13, IoxValue::Low, server, opcode);
}

View file

@ -101,6 +101,14 @@ pub trait IoGpio {
fn set_gpio_pin_dir(&self, port: IoxPort, pin: u8, dir: IoxDir); fn set_gpio_pin_dir(&self, port: IoxPort, pin: u8, dir: IoxDir);
} }
pub trait IoIrq {
/// This hooks a given port/pin to generate a message to the server specified
/// with `server` and the opcode number `usize` when an IRQ is detected on the port/pin.
/// The active state of the IRQ is defined by `active`; the transition edge from inactive
/// to active is when the event is generated.
fn set_irq_pin(&self, port: IoxPort, pin: u8, active: IoxValue, server: &str, opcode: usize);
}
pub struct Iox { pub struct Iox {
pub csr: SharedCsr<u32>, pub csr: SharedCsr<u32>,
} }

View file

@ -36,7 +36,7 @@ const CRG_EVENT_RING_NUM: usize = 1;
const CRG_ERST_SIZE: usize = 1; const CRG_ERST_SIZE: usize = 1;
const CRG_EVENT_RING_SIZE: usize = 128; const CRG_EVENT_RING_SIZE: usize = 128;
const CRG_EP0_TD_RING_SIZE: usize = 16; const CRG_EP0_TD_RING_SIZE: usize = 16;
const CRG_EP_NUM: usize = 4; pub const CRG_EP_NUM: usize = 4;
const CRG_TD_RING_SIZE: usize = 512; // was 1280 in original code. not even sure we need ... 64? const CRG_TD_RING_SIZE: usize = 512; // was 1280 in original code. not even sure we need ... 64?
const CRG_UDC_MAX_BURST: u32 = 15; const CRG_UDC_MAX_BURST: u32 = 15;
const CRG_UDC_ISO_INTERVAL: u8 = 3; const CRG_UDC_ISO_INTERVAL: u8 = 3;
@ -1243,10 +1243,6 @@ impl CorigineUsb {
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
// Set up storage for Endpoint contexts // Set up storage for Endpoint contexts
#[cfg(feature = "std")]
log::trace!("Begin init_device_context");
#[cfg(not(feature = "std"))]
println!("Begin init_device_context");
// init device context and ep context, refer to 7.6.2 // init device context and ep context, refer to 7.6.2
self.p_epcx = AtomicPtr::new((self.ifram_base_ptr + CRG_UDC_EPCX_OFFSET) as *mut EpCxS); self.p_epcx = AtomicPtr::new((self.ifram_base_ptr + CRG_UDC_EPCX_OFFSET) as *mut EpCxS);
self.p_epcx_len = CRG_EP_NUM * 2 * size_of::<EpCxS>(); self.p_epcx_len = CRG_EP_NUM * 2 * size_of::<EpCxS>();
@ -1265,13 +1261,12 @@ impl CorigineUsb {
// disable 2.0 LPM // disable 2.0 LPM
self.csr.wo(U2PORTPMSC, 0); self.csr.wo(U2PORTPMSC, 0);
#[cfg(feature = "std")] crate::println!("USB hw init done");
log::trace!("USB init done");
} }
pub fn init_ep0(&mut self) { pub fn init_ep0(&mut self) {
#[cfg(feature = "std")] #[cfg(feature = "verbose-debug")]
log::trace!("Begin init_ep0"); crate::println!("Begin init_ep0");
let udc_ep = &mut self.udc_ep[0]; let udc_ep = &mut self.udc_ep[0];
udc_ep.ep_num = 0; udc_ep.ep_num = 0;
@ -1311,15 +1306,7 @@ impl CorigineUsb {
let cmd_param0: u32 = (udc_ep.tran_ring_info.vaddr.load(Ordering::SeqCst) as u32) & 0xFFFF_FFF0 let cmd_param0: u32 = (udc_ep.tran_ring_info.vaddr.load(Ordering::SeqCst) as u32) & 0xFFFF_FFF0
| self.csr.ms(CMDPARA0_CMD0_INIT_EP0_DCS, udc_ep.pcs as u32); | self.csr.ms(CMDPARA0_CMD0_INIT_EP0_DCS, udc_ep.pcs as u32);
let cmd_param1: u32 = 0; let cmd_param1: u32 = 0;
#[cfg(feature = "std")] #[cfg(feature = "verbose-debug")]
{
log::debug!(
"ep0 ring dma addr = {:x}",
udc_ep.tran_ring_info.vaddr.load(Ordering::SeqCst) as usize
);
log::debug!("INIT EP0 CMD par0 = {:x} par1 = {:x}", cmd_param0, cmd_param1);
}
#[cfg(not(feature = "std"))]
{ {
println!("ep0 ring dma addr = {:x}", udc_ep.tran_ring_info.vaddr.load(Ordering::SeqCst) as usize); println!("ep0 ring dma addr = {:x}", udc_ep.tran_ring_info.vaddr.load(Ordering::SeqCst) as usize);
println!("INIT EP0 CMD par0 = {:x} par1 = {:x}", cmd_param0, cmd_param1); println!("INIT EP0 CMD par0 = {:x} par1 = {:x}", cmd_param0, cmd_param1);
@ -1329,8 +1316,6 @@ impl CorigineUsb {
.expect("couldn't issue ep0 init command"); .expect("couldn't issue ep0 init command");
self.ep0_buf = AtomicPtr::new((self.ifram_base_ptr + CRG_UDC_EP0_BUF_OFFSET) as *mut u8); self.ep0_buf = AtomicPtr::new((self.ifram_base_ptr + CRG_UDC_EP0_BUF_OFFSET) as *mut u8);
#[cfg(feature = "std")]
log::trace!("End init_ep0");
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
@ -2168,7 +2153,7 @@ pub struct CorigineWrapper {
/// Tuple is (type of endpoint, max packet size) /// Tuple is (type of endpoint, max packet size)
pub ep_meta: [Option<(EpType, usize)>; CRG_EP_NUM], pub ep_meta: [Option<(EpType, usize)>; CRG_EP_NUM],
pub ep_out_ready: Box<[AtomicBool]>, pub ep_out_ready: Box<[AtomicBool]>,
pub address_is_set: AtomicBool, pub address_is_set: Arc<AtomicBool>,
pub event: Option<CrgEvent>, pub event: Option<CrgEvent>,
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
@ -2183,7 +2168,7 @@ impl CorigineWrapper {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.into_boxed_slice(), .into_boxed_slice(),
event: None, event: None,
address_is_set: AtomicBool::new(false), address_is_set: Arc::new(AtomicBool::new(false)),
}; };
c c
} }
@ -2198,7 +2183,7 @@ impl CorigineWrapper {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.into_boxed_slice(), .into_boxed_slice(),
event: None, event: None,
address_is_set: AtomicBool::new(self.address_is_set.load(Ordering::SeqCst)), address_is_set: self.address_is_set.clone(),
}; };
c.ep_meta.copy_from_slice(&self.ep_meta); c.ep_meta.copy_from_slice(&self.ep_meta);
for (dst, src) in c.ep_out_ready.iter().zip(self.ep_out_ready.iter()) { for (dst, src) in c.ep_out_ready.iter().zip(self.ep_out_ready.iter()) {
@ -2327,7 +2312,7 @@ impl UsbBus for CorigineWrapper {
let irq_csr = { let irq_csr = {
let mut hw = self.core(); let mut hw = self.core();
// disable IRQs // disable IRQs
hw.irq_csr.wfo(utralib::utra::irqarray1::EV_ENABLE_USBC_DUPE, 0); hw.irq_csr.wo(utralib::utra::irqarray1::EV_ENABLE, 0);
hw.reset(); hw.reset();
hw.init(); hw.init();
hw.start(); hw.start();
@ -2337,7 +2322,7 @@ impl UsbBus for CorigineWrapper {
}; };
// the lock is released, now we can enable irqs // the lock is released, now we can enable irqs
irq_csr.wo(utralib::utra::irqarray1::EV_PENDING, 0xffff_ffff); // blanket clear irq_csr.wo(utralib::utra::irqarray1::EV_PENDING, 0xffff_ffff); // blanket clear
irq_csr.wfo(utralib::utra::irqarray1::EV_ENABLE_USBC_DUPE, 1); irq_csr.wo(utralib::utra::irqarray1::EV_ENABLE, 3); // FIXME: hard coded value that enables CORIGINE_IRQ_MASK | SW_IRQ_MASK
// TODO -- figure out what this means // TODO -- figure out what this means
// self.force_reset().ok(); // self.force_reset().ok();
@ -2530,9 +2515,11 @@ impl UsbBus for CorigineWrapper {
let ret = if let Some((ptr, len)) = self.core().app_ptr.take() { let ret = if let Some((ptr, len)) = self.core().app_ptr.take() {
self.ep_out_ready[ep_addr.index()].store(false, Ordering::SeqCst); self.ep_out_ready[ep_addr.index()].store(false, Ordering::SeqCst);
let app_buf = unsafe { core::slice::from_raw_parts(ptr as *const u8, len) }; let app_buf = unsafe { core::slice::from_raw_parts(ptr as *const u8, len) };
if buf.len() > app_buf.len() { if buf.len() < app_buf.len() {
Err(UsbError::BufferOverflow) Err(UsbError::BufferOverflow)
} else { } else {
#[cfg(feature = "verbose-debug")]
crate::println!("copy into len {} from len {}", buf.len(), app_buf.len());
buf[..app_buf.len()].copy_from_slice(app_buf); buf[..app_buf.len()].copy_from_slice(app_buf);
crate::println!(" {:x?}", &buf[..app_buf.len().min(8)]); crate::println!(" {:x?}", &buf[..app_buf.len().min(8)]);
Ok(app_buf.len()) Ok(app_buf.len())
@ -2681,9 +2668,25 @@ impl UsbBus for CorigineWrapper {
fn force_reset(&self) -> Result<()> { fn force_reset(&self) -> Result<()> {
crate::println!(" ******* force_reset"); crate::println!(" ******* force_reset");
// This is the minimum we need to do to restart EP0, but, I think we also need to reset self.address_is_set.store(false, Ordering::SeqCst);
// TRB pointers etc. See page 67 of the manual. for eor in self.ep_out_ready.iter() {
self.core().update_current_speed(); eor.store(false, Ordering::SeqCst);
}
crate::println!(" ******** reset");
let irq_csr = {
let mut hw = self.core();
// disable IRQs
hw.irq_csr.wo(utralib::utra::irqarray1::EV_ENABLE, 0);
hw.reset();
hw.init();
hw.start();
hw.update_current_speed();
// IRQ enable must happen without dependency on the hardware lock
hw.irq_csr.clone()
};
// the lock is released, now we can enable irqs
irq_csr.wo(utralib::utra::irqarray1::EV_PENDING, 0xffff_ffff); // blanket clear
irq_csr.wo(utralib::utra::irqarray1::EV_ENABLE, 3); // FIXME: hard coded value that enables CORIGINE_IRQ_MASK | SW_IRQ_MASK
Ok(()) Ok(())
} }

View file

@ -1542,6 +1542,11 @@ unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2.offset()).write_volatile(0x1f3f); // hclk daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2.offset()).write_volatile(0x1f3f); // hclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3.offset()).write_volatile(0x0f1f); // iclk daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3.offset()).write_volatile(0x0f1f); // iclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4.offset()).write_volatile(0x070f); // pclk daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4.offset()).write_volatile(0x070f); // pclk
#[cfg(not(feature = "cramium-mpw"))]
// perclk divider - set to divide by 8 off of an 800Mhz base. Only found on NTO.
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x03_ff_ff);
// commit dividers // commit dividers
daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32); daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32);
} }

View file

@ -148,6 +148,9 @@ impl Mbox {
} }
pub fn try_send(&mut self, to_cm7: MboxToCm7Pkt) -> Result<(), MboxError> { pub fn try_send(&mut self, to_cm7: MboxToCm7Pkt) -> Result<(), MboxError> {
// clear any pending bits from previous transactions
self.csr.wo(mailbox::EV_PENDING, self.csr.r(mailbox::EV_PENDING));
if to_cm7.data.len() > MAX_PKT_LEN { if to_cm7.data.len() > MAX_PKT_LEN {
Err(MboxError::TxOverflow) Err(MboxError::TxOverflow)
} else { } else {

View file

@ -27,6 +27,7 @@ pio-proc = "0.2.2"
pio = "0.2.1" pio = "0.2.1"
rand_core = "0.6.4" rand_core = "0.6.4"
rand_chacha = "0.3.1" rand_chacha = "0.3.1"
bitfield = "0.13.2"
num-derive = { version = "0.4.2", default-features = false } num-derive = { version = "0.4.2", default-features = false }
num-traits = { version = "0.2.14", default-features = false } num-traits = { version = "0.2.14", default-features = false }
@ -45,4 +46,4 @@ swap = []
mpw = ["cramium-hal/mpw"] mpw = ["cramium-hal/mpw"]
# add this feature to enable pre-emption # add this feature to enable pre-emption
quantum-timer = ["utralib", "pio"] quantum-timer = ["utralib", "pio"]
default = ["app-uart"] default = ["app-uart", "utralib"]

View file

@ -1,5 +1,5 @@
pub mod keyboard; pub mod keyboard;
use cramium_hal::iox; use cramium_hal::iox::{self, IoxPort, IoxValue};
pub use keyboard::*; pub use keyboard::*;
/// The Opcode numbers here should not be changed. You can add new ones, /// The Opcode numbers here should not be changed. You can add new ones,
@ -47,6 +47,10 @@ pub enum Opcode {
/// Peripheral reset /// Peripheral reset
PeriphReset = 10, PeriphReset = 10,
/// Configure Iox IRQ
ConfigureIoxIrq = 11,
IrqLocalHandler = 12,
/// Exit server /// Exit server
Quit = 255, Quit = 255,
@ -145,3 +149,12 @@ pub struct I2cTransactions {
impl From<Vec<I2cTransaction>> for I2cTransactions { impl From<Vec<I2cTransaction>> for I2cTransactions {
fn from(value: Vec<I2cTransaction>) -> Self { Self { transactions: value } } fn from(value: Vec<I2cTransaction>) -> Self { Self { transactions: value } }
} }
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub struct IoxIrqRegistration {
pub server: String,
pub opcode: usize,
pub port: IoxPort,
pub pin: u8,
pub active: IoxValue,
}

View file

@ -1,11 +1,14 @@
use core::sync::atomic::Ordering; use core::sync::atomic::Ordering;
use cramium_hal::iox::{ use cramium_hal::iox::{
IoGpio, IoSetup, IoxDir, IoxDriveStrength, IoxEnable, IoxFunction, IoxPort, IoxValue, IoGpio, IoIrq, IoSetup, IoxDir, IoxDriveStrength, IoxEnable, IoxFunction, IoxPort, IoxValue,
}; };
use num_traits::*; use num_traits::*;
use crate::{Opcode, SERVER_NAME_CRAM_HAL, api::IoxConfigMessage}; use crate::{
Opcode, SERVER_NAME_CRAM_HAL,
api::{IoxConfigMessage, IoxIrqRegistration},
};
pub struct IoxHal { pub struct IoxHal {
conn: xous::CID, conn: xous::CID,
@ -176,3 +179,11 @@ impl Drop for IoxHal {
} }
} }
} }
impl IoIrq for IoxHal {
fn set_irq_pin(&self, port: IoxPort, pin: u8, active: IoxValue, server: &str, opcode: usize) {
let msg = IoxIrqRegistration { server: server.to_owned(), opcode, port, pin, active };
let buf = xous_ipc::Buffer::into_buf(msg).unwrap();
buf.lend(self.conn, Opcode::ConfigureIoxIrq.to_u32().unwrap()).expect("Couldn't set up IRQ");
}
}

View file

@ -2,17 +2,20 @@ mod api;
mod hw; mod hw;
use api::*; use api::*;
use bitfield::*;
use cramium_hal::{ use cramium_hal::{
iox, iox::{self, IoxPort, IoxValue},
udma::{EventChannel, GlobalConfig, I2cApi, PeriphId}, udma::{EventChannel, GlobalConfig, I2cApi, PeriphId},
}; };
use num_traits::*;
use utralib::CSR;
#[cfg(feature = "quantum-timer")] #[cfg(feature = "quantum-timer")]
use utralib::utra; use utralib::utra;
#[cfg(feature = "quantum-timer")] #[cfg(feature = "quantum-timer")]
use utralib::*; use utralib::*;
#[cfg(feature = "swap")] #[cfg(feature = "swap")]
use xous::SWAPPER_PID; use xous::SWAPPER_PID;
use xous::sender::Sender; use xous::{ScalarMessage, sender::Sender};
#[cfg(feature = "pio")] #[cfg(feature = "pio")]
use xous_pio::*; use xous_pio::*;
@ -37,6 +40,57 @@ fn timer_tick(_irq_no: usize, arg: *mut usize) {
ptimer.irq_csr.wo(utra::irqarray18::EV_PENDING, ptimer.irq_csr.r(utra::irqarray18::EV_PENDING)); ptimer.irq_csr.wo(utra::irqarray18::EV_PENDING, ptimer.irq_csr.r(utra::irqarray18::EV_PENDING));
} }
#[repr(u32)]
#[allow(dead_code)]
enum IntMode {
RisingEdge = 0,
FallingEdge = 1,
HighLevel = 2,
LowLevel = 3,
}
bitfield! {
#[derive(Copy, Clone, PartialEq, Eq, Default)]
pub struct IntCr(u32);
impl Debug;
pub u32, select, set_select: 6, 0;
pub u32, mode, set_mode: 8, 7;
pub enable, set_enable: 9;
pub wakeup, set_wakeup: 10;
}
fn irq_select_from_port(port: IoxPort, pin: u8) -> u32 { (port as u32) * 16 + pin as u32 }
fn find_first_none<T>(arr: &[Option<T>]) -> Option<usize> { arr.iter().position(|item| item.is_none()) }
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)]
struct IrqLocalRegistration {
pub cid: xous::CID,
pub opcode: usize,
pub port: IoxPort,
pub pin: u8,
pub active: IoxValue,
}
struct IrqHandler {
pub irq_csr: CSR<u32>,
pub cid: xous::CID,
}
fn iox_irq_handler(_irq_no: usize, arg: *mut usize) {
let handler = unsafe { &mut *(arg as *mut IrqHandler) };
let pending = handler.irq_csr.r(utralib::utra::irqarray10::EV_PENDING);
handler.irq_csr.wo(utralib::utra::irqarray10::EV_PENDING, pending);
xous::try_send_message(
handler.cid,
xous::Message::Scalar(ScalarMessage::from_usize(
Opcode::IrqLocalHandler.to_usize().unwrap(),
pending as usize,
0,
0,
0,
)),
)
.ok();
}
fn try_alloc(ifram_allocs: &mut Vec<Option<Sender>>, size: usize, sender: Sender) -> Option<usize> { fn try_alloc(ifram_allocs: &mut Vec<Option<Sender>>, size: usize, sender: Sender) -> Option<usize> {
let mut size_pages = size / 4096; let mut size_pages = size / 4096;
if size % 4096 != 0 { if size % 4096 != 0 {
@ -94,6 +148,7 @@ fn main() {
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
let sid = xns.register_name(cram_hal_service::SERVER_NAME_CRAM_HAL, None).expect("can't register server"); let sid = xns.register_name(cram_hal_service::SERVER_NAME_CRAM_HAL, None).expect("can't register server");
let self_cid = xous::connect(sid).expect("couldn't create self-connection");
let mut ifram_allocs = [Vec::new(), Vec::new()]; let mut ifram_allocs = [Vec::new(), Vec::new()];
// code is written assuming the IFRAM blocks have the same size. Since this is fixed in // code is written assuming the IFRAM blocks have the same size. Since this is fixed in
@ -229,6 +284,28 @@ fn main() {
} }
// -------------------- end timer workaround code // -------------------- end timer workaround code
// ---- "own" the Iox IRQ bank. This might need revision once NTO aliasing is available. ---
let irq_page = xous::syscall::map_memory(
xous::MemoryAddress::new(utralib::utra::irqarray10::HW_IRQARRAY10_BASE),
None,
4096,
xous::MemoryFlags::R | xous::MemoryFlags::W,
)
.expect("couldn't claim IRQ control page");
let irq_csr = CSR::new(irq_page.as_mut_ptr() as *mut u32);
let mut irq = IrqHandler { irq_csr, cid: self_cid };
xous::claim_interrupt(
utralib::utra::irqarray10::IRQARRAY10_IRQ,
iox_irq_handler,
&mut irq as *mut IrqHandler as *mut usize,
)
.expect("couldn't claim Iox interrupt");
irq.irq_csr.wo(utralib::utra::irqarray10::EV_PENDING, 0xFFFF_FFFF);
irq.irq_csr.wfo(utralib::utra::irqarray10::EV_ENABLE_IOXIRQ, 1);
// Up to 8 slots where we can populate interrupt mappings in the hardware
// The index of the array corresponds to the slot.
let mut irq_table: [Option<IrqLocalRegistration>; 8] = [None; 8];
// start keyboard emulator service // start keyboard emulator service
hw::keyboard::start_keyboard_service(); hw::keyboard::start_keyboard_service();
@ -339,6 +416,89 @@ fn main() {
iox.set_drive_strength(config.port, config.pin, s); iox.set_drive_strength(config.port, config.pin, s);
} }
} }
Opcode::ConfigureIoxIrq => {
let buf =
unsafe { xous_ipc::Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let registration = buf.to_original::<IoxIrqRegistration, _>().unwrap();
log::info!("Got registration request: {:?}", registration);
if let Some(index) = find_first_none(&irq_table) {
// create the reverse-lookup registration
let local_conn = xns
.request_connection(&registration.server)
.expect("couldn't connect to IRQ registree");
let local_reg = IrqLocalRegistration {
cid: local_conn,
opcode: registration.opcode,
port: registration.port,
pin: registration.pin,
active: registration.active,
};
irq_table[index] = Some(local_reg);
// now activate the hardware register
let select = irq_select_from_port(registration.port, registration.pin);
let mut int_cr = IntCr(0);
int_cr.set_select(select);
match registration.active {
IoxValue::Low => int_cr.set_mode(IntMode::FallingEdge as u32),
IoxValue::High => int_cr.set_mode(IntMode::RisingEdge as u32),
}
int_cr.set_enable(true);
// safety: the index and offset are mapped to the intended range because the index is
// bounded by the size of irq_table, and the offset comes from the generated header file.
log::debug!(
"writing {:x} to {:x} at index {}",
int_cr.0,
unsafe {
iox.csr.base().add(utralib::utra::iox::SFR_INTCR_CRINT0.offset()).add(index)
as usize
},
index
);
unsafe {
iox.csr
.base()
.add(utralib::utra::iox::SFR_INTCR_CRINT0.offset())
.add(index)
.write_volatile(int_cr.0);
}
} else {
panic!("Ran out of Iox interrupt slots: maximum 8 available");
}
}
Opcode::IrqLocalHandler => {
// Figure out which port(s) caused the IRQ
let irq_flag = iox.csr.r(utralib::utra::iox::SFR_INTFR);
// clear the set bit by writing it back
iox.csr.wo(utralib::utra::iox::SFR_INTFR, irq_flag);
let mut found = false;
for bitpos in 0..8 {
// the bit position is flipped versus register order in memory
if ((irq_flag << (bitpos as u32)) & 0x80) != 0 {
if let Some(local_reg) = irq_table[bitpos] {
found = true;
// interrupts are "Best effort" and can gracefully fail if the receiver has been
// overwhelmed by too many interrupts
xous::try_send_message(
local_reg.cid,
xous::Message::new_scalar(local_reg.opcode, 0, 0, 0, 0),
)
.ok();
} else {
log::warn!(
"Got IRQ on position {} but no registration was found, ignoring!",
bitpos
);
}
}
}
if !found {
log::warn!(
"No handler was found for raw flag: {:x} (note bit order is reversed)",
irq_flag
);
}
}
Opcode::SetGpioBank => { Opcode::SetGpioBank => {
if let Some(scalar) = msg.body.scalar_message() { if let Some(scalar) = msg.body.scalar_message() {
let port: cramium_hal::iox::IoxPort = let port: cramium_hal::iox::IoxPort =

View file

@ -16,6 +16,8 @@ num-traits = { version = "0.2.14", default-features = false }
cramium-hal = { path = "../../libs/cramium-hal", features = [ cramium-hal = { path = "../../libs/cramium-hal", features = [
"std", "std",
"debug-print-usb", "debug-print-usb",
# "verbose-debug",
"axp2101",
] } ] }
cram-hal-service = { path = "../cram-hal-service" } cram-hal-service = { path = "../cram-hal-service" }
xous-usb-hid = { git = "https://github.com/betrusted-io/xous-usb-hid.git", branch = "main" } xous-usb-hid = { git = "https://github.com/betrusted-io/xous-usb-hid.git", branch = "main" }

View file

@ -67,6 +67,10 @@ pub(crate) enum Opcode {
#[cfg(feature = "mass-storage")] #[cfg(feature = "mass-storage")]
ResetBlockDevice = 1026, ResetBlockDevice = 1026,
/// Platform-specific messages for callback handlers
#[cfg(feature = "cramium-soc")]
PmicIrq = 1536,
// HIDv2 // HIDv2
/// Read a HID report /// Read a HID report
HIDReadReport = 1027, HIDReadReport = 1027,

View file

@ -320,4 +320,31 @@ impl<'a> CramiumUsb<'a> {
self.irq_req = Some(request_type); self.irq_req = Some(request_type);
self.irq_csr.wfo(utra::irqarray1::EV_SOFT_TRIGGER, SW_IRQ_MASK); self.irq_csr.wfo(utra::irqarray1::EV_SOFT_TRIGGER, SW_IRQ_MASK);
} }
/// Process an unplug event
pub fn unplug(&mut self) {
// disable all interrupts so we can safely go through initialization routines
self.irq_csr.wo(utra::irqarray1::EV_ENABLE, 0);
self.wrapper.hw.lock().unwrap().reset();
self.wrapper.hw.lock().unwrap().init();
self.wrapper.hw.lock().unwrap().start();
self.wrapper.hw.lock().unwrap().update_current_speed();
// reset all shared data structures
self.device.force_reset().ok();
self.fido_tx_queue = RefCell::new(VecDeque::new());
self.kbd_tx_queue = RefCell::new(VecDeque::new());
self.irq_req = None;
self.wrapper.event = None;
self.wrapper.address_is_set.store(false, Ordering::SeqCst);
self.wrapper.ep_out_ready = (0..cramium_hal::usb::driver::CRG_EP_NUM + 1)
.map(|_| core::sync::atomic::AtomicBool::new(false))
.collect::<Vec<_>>()
.into_boxed_slice();
// re-enable IRQs
self.irq_csr.wo(utra::irqarray1::EV_PENDING, 0xFFFF_FFFF);
self.irq_csr.wo(utra::irqarray1::EV_ENABLE, CORIGINE_IRQ_MASK | SW_IRQ_MASK);
}
} }

View file

@ -16,6 +16,7 @@ use std::sync::Arc;
use api::{HIDReport, LogLevel, Opcode, U2fCode, U2fMsgIpc, UsbListenerRegistration}; use api::{HIDReport, LogLevel, Opcode, U2fCode, U2fMsgIpc, UsbListenerRegistration};
use cram_hal_service::api::KeyMap; use cram_hal_service::api::KeyMap;
use cramium_hal::axp2101::VbusIrq;
use cramium_hal::usb::driver::{CorigineUsb, CorigineWrapper}; use cramium_hal::usb::driver::{CorigineUsb, CorigineWrapper};
use hw::CramiumUsb; use hw::CramiumUsb;
use hw::UsbIrqReq; use hw::UsbIrqReq;
@ -36,10 +37,6 @@ enum TimeoutOp {
/* /*
TODO: TODO:
- [ ] USB stack doesn't know when the cable is unplugged. This is a hardware issue right now
with MPW hardware. Wait until NTO chips come back to try and solve this? and if the bug isn't fixed
there we can either work around this by adding a sense I/O for this purpose or we can use a timer
to poll USB connection status.
- [ ] Reduce debug spew. This is left in place for now because we will definitely need it in the - [ ] Reduce debug spew. This is left in place for now because we will definitely need it in the
future and it hasn't seemed to affect the stack operation like it did in the user-space implementation. future and it hasn't seemed to affect the stack operation like it did in the user-space implementation.
*/ */
@ -239,6 +236,17 @@ pub(crate) fn main_hw() -> ! {
} }
}); });
log::info!("Registering PMIC handler to detect USB plug/unplug events");
let iox = cram_hal_service::iox_lib::IoxHal::new();
cramium_hal::board::setup_pmic_irq(
&iox,
api::SERVER_NAME_USB_DEVICE,
Opcode::PmicIrq.to_usize().unwrap(),
);
let mut i2c = cram_hal_service::I2c::new();
let mut pmic = cramium_hal::axp2101::Axp2101::new(&mut i2c).expect("couldn't open PMIC");
pmic.setup_vbus_irq(&mut i2c, cramium_hal::axp2101::VbusIrq::Remove).expect("couldn't setup IRQ");
log::info!("Entering main loop"); log::info!("Entering main loop");
let mut msg_opt = None; let mut msg_opt = None;
@ -248,6 +256,21 @@ pub(crate) fn main_hw() -> ! {
let opcode = num_traits::FromPrimitive::from_usize(msg.body.id()).unwrap_or(Opcode::InvalidCall); let opcode = num_traits::FromPrimitive::from_usize(msg.body.id()).unwrap_or(Opcode::InvalidCall);
log::info!("{:?}", opcode); log::info!("{:?}", opcode);
match opcode { match opcode {
Opcode::PmicIrq => match pmic.get_vbus_irq_status(&mut i2c).unwrap() {
VbusIrq::Insert => {
log::error!("VBUS insert reported by PMIC, but we didn't ask for the event!");
}
VbusIrq::Remove => {
log::info!("VBUS removed. Resetting stack.");
cu.unplug();
}
VbusIrq::InsertAndRemove => {
panic!("Unexpected report from vbus_irq status");
}
VbusIrq::None => {
log::warn!("Received an interrupt but no actual event reported");
}
},
Opcode::U2fRxDeferred => { Opcode::U2fRxDeferred => {
// notify the event listener, if any // notify the event listener, if any
if observer_conn.is_some() && observer_op.is_some() { if observer_conn.is_some() && observer_op.is_some() {

View file

@ -2674,7 +2674,7 @@ pub mod utra {
} }
pub mod sysctrl { pub mod sysctrl {
pub const SYSCTRL_NUMREGS: usize = 35; pub const SYSCTRL_NUMREGS: usize = 37;
pub const SFR_CGUSEC: crate::Register = crate::Register::new(0, 0xffff); pub const SFR_CGUSEC: crate::Register = crate::Register::new(0, 0xffff);
pub const SFR_CGUSEC_SFR_CGUSEC: crate::Field = crate::Field::new(16, 0, SFR_CGUSEC); pub const SFR_CGUSEC_SFR_CGUSEC: crate::Field = crate::Field::new(16, 0, SFR_CGUSEC);
@ -2715,8 +2715,14 @@ pub mod utra {
pub const SFR_CGUSEL1: crate::Register = crate::Register::new(12, 0x1); pub const SFR_CGUSEL1: crate::Register = crate::Register::new(12, 0x1);
pub const SFR_CGUSEL1_SFR_CGUSEL1: crate::Field = crate::Field::new(1, 0, SFR_CGUSEL1); pub const SFR_CGUSEL1_SFR_CGUSEL1: crate::Field = crate::Field::new(1, 0, SFR_CGUSEL1);
pub const SFR_CGUFDPKE: crate::Register = crate::Register::new(13, 0x1ff); pub const SFR_CGUFDPKE: crate::Register = crate::Register::new(13, 0xff);
pub const SFR_CGUFDPKE_SFR_CGUFDPKE: crate::Field = crate::Field::new(9, 0, SFR_CGUFDPKE); pub const SFR_CGUFDPKE_SFR_CGUFDPKE: crate::Field = crate::Field::new(8, 0, SFR_CGUFDPKE);
pub const SFR_CGUFDAORAM: crate::Register = crate::Register::new(14, 0xffff);
pub const SFR_CGUFDAORAM_SFR_CGUFDAORAM: crate::Field = crate::Field::new(16, 0, SFR_CGUFDAORAM);
pub const SFR_CGUFDPER: crate::Register = crate::Register::new(15, 0xffffff);
pub const SFR_CGUFDPER_SFR_CGUFDPER: crate::Field = crate::Field::new(24, 0, SFR_CGUFDPER);
pub const SFR_CGUFSSR_FSFREQ0: crate::Register = crate::Register::new(16, 0xffff); pub const SFR_CGUFSSR_FSFREQ0: crate::Register = crate::Register::new(16, 0xffff);
pub const SFR_CGUFSSR_FSFREQ0_FSFREQ0: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ0); pub const SFR_CGUFSSR_FSFREQ0_FSFREQ0: crate::Field = crate::Field::new(16, 0, SFR_CGUFSSR_FSFREQ0);
@ -13438,6 +13444,22 @@ mod tests {
baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, 1); baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, 1);
sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, baz); sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDPKE_SFR_CGUFDPKE, baz);
let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFDAORAM);
sysctrl_csr.wo(utra::sysctrl::SFR_CGUFDAORAM, foo);
let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFDAORAM_SFR_CGUFDAORAM);
sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFDAORAM_SFR_CGUFDAORAM, bar);
let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFDAORAM_SFR_CGUFDAORAM, bar);
baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDAORAM_SFR_CGUFDAORAM, 1);
sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDAORAM_SFR_CGUFDAORAM, baz);
let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFDPER);
sysctrl_csr.wo(utra::sysctrl::SFR_CGUFDPER, foo);
let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFDPER_SFR_CGUFDPER);
sysctrl_csr.rmwf(utra::sysctrl::SFR_CGUFDPER_SFR_CGUFDPER, bar);
let mut baz = sysctrl_csr.zf(utra::sysctrl::SFR_CGUFDPER_SFR_CGUFDPER, bar);
baz |= sysctrl_csr.ms(utra::sysctrl::SFR_CGUFDPER_SFR_CGUFDPER, 1);
sysctrl_csr.wfo(utra::sysctrl::SFR_CGUFDPER_SFR_CGUFDPER, baz);
let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ0); let foo = sysctrl_csr.r(utra::sysctrl::SFR_CGUFSSR_FSFREQ0);
sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0, foo); sysctrl_csr.wo(utra::sysctrl::SFR_CGUFSSR_FSFREQ0, foo);
let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0); let bar = sysctrl_csr.rf(utra::sysctrl::SFR_CGUFSSR_FSFREQ0_FSFREQ0);