add wfi & ldo settings to repl

unit can now enter deep powerdown mode and wake up demonstrating
that the system can achieve the power numbers needed for the
product spec
This commit is contained in:
bunnie 2025-08-19 19:00:11 +08:00
parent 13b048089b
commit 29b524375b
3 changed files with 457 additions and 53 deletions

View file

@ -1,3 +1,6 @@
use cramium_api::*;
use cramium_hal::iox::Iox;
use cramium_hal::udma;
use utralib::CSR;
use utralib::utra;
use utralib::utra::sysctrl;
@ -29,26 +32,27 @@ pub const SYSTEM_CLOCK_FREQUENCY: u32 = 800_000_000;
pub const SYSTEM_TICK_INTERVAL_MS: u32 = 1;
pub fn early_init() {
let iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32);
#[cfg(not(feature = "nto-evb"))]
{
iox.set_gpio_pin_value(IoxPort::PA, 5, IoxValue::High);
iox.setup_pin(
IoxPort::PA,
5,
Some(IoxDir::Output),
Some(IoxFunction::Gpio),
None,
Some(IoxEnable::Enable),
None,
Some(IoxDriveStrength::Drive2mA),
);
}
let uart = crate::debug::Uart {};
uart.putc('*' as u32 as u8);
let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32;
let ao_sysctrl = utra::ao_sysctrl::HW_AO_SYSCTRL_BASE as *mut u32;
unsafe {
// this turns off the VDD85D (doesn't work)
// ao_sysctrl.add(utra::ao_sysctrl::SFR_PMUCSR.offset()).write_volatile(0x6c);
// this sets VDD85D to 0.90V
ao_sysctrl.add(utra::ao_sysctrl::SFR_PMUTRM0CSR.offset()).write_volatile(0x0842_1FF1); // 0x0842_1080 default
daric_cgu.add(utra::sysctrl::SFR_IPCARIPFLOW.offset()).write_volatile(0x57);
}
let uart = crate::debug::Uart {};
for _ in 0..100 {
uart.putc('a' as u32 as u8);
}
unsafe {
// this block is mandatory in all cases to get clocks set into some consistent, expected mode
{
@ -215,10 +219,47 @@ pub fn early_init() {
udma_uart.write("console up\r\n".as_bytes());
// Setup I/Os so things that should be powered off are actually off
cramium_hal::board::setup_display_pins(&iox);
cramium_hal::board::setup_memory_pins(&iox);
cramium_hal::board::setup_i2c_pins(&iox);
cramium_hal::board::setup_camera_pins(&iox);
cramium_hal::board::setup_kb_pins(&iox);
cramium_hal::board::setup_oled_power_pin(&iox);
cramium_hal::board::setup_trng_power_pin(&iox);
#[cfg(not(feature = "nto-evb"))]
{
crate::println!("Engage DCDC2");
let i2c_channel = cramium_hal::board::setup_i2c_pins(&iox);
use cramium_hal::udma::GlobalConfig;
let udma_global = GlobalConfig::new();
udma_global.clock(PeriphId::from(i2c_channel), true);
let i2c_ifram = unsafe {
cramium_hal::ifram::IframRange::from_raw_parts(
cramium_hal::board::I2C_IFRAM_ADDR,
cramium_hal::board::I2C_IFRAM_ADDR,
4096,
)
};
let mut i2c = unsafe {
cramium_hal::udma::I2c::new_with_ifram(i2c_channel, 400_000, perclk, i2c_ifram, &udma_global)
};
if let Ok(mut pmic) = cramium_hal::axp2101::Axp2101::new(&mut i2c) {
match pmic.set_dcdc(&mut i2c, Some((0.88, true)), cramium_hal::axp2101::WhichDcDc::Dcdc2) {
Ok(_) => crate::println!("turned on DCDC2"),
Err(_) => crate::println!("couldn't turn off DCDC2"),
}
pmic.set_pwm_mode(&mut i2c, cramium_hal::axp2101::WhichDcDc::Dcdc2, true).ok();
}
// this does nothing on boards without the FET rework
crate::println!("Engage DCDC2 FET");
iox.set_gpio_pin_value(IoxPort::PA, 5, IoxValue::Low);
}
// code to setup PWM, for testing the PWM pin
if false {
use cramium_api::*;
use cramium_hal::iox::Iox;
let iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32);
iox.setup_pin(IoxPort::PF, 9, Some(IoxDir::Input), Some(IoxFunction::Gpio), None, None, None, None);
iox.setup_pin(
@ -243,11 +284,12 @@ pub fn early_init() {
);
let mut timer = CSR::new(utra::pwm::HW_PWM_BASE as *mut u32);
timer.wo(utra::pwm::REG_CH_EN, 1);
timer.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW, 0);
timer.rmwf(utra::pwm::REG_TIM0_CFG_R_TIMER0_SAW, 1);
timer.rmwf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_TH, 0);
timer.rmwf(utra::pwm::REG_TIM0_CH0_TH_R_TIMER0_CH0_MODE, 3);
let pwm = utra::pwm::HW_PWM_BASE as *mut u32;
unsafe { pwm.add(2).write_volatile(1 << 16) };
// unsafe { pwm.add(2).write_volatile(1 << 16) };
unsafe { pwm.add(2).write_volatile(0) };
timer.rmwf(utra::pwm::REG_TIM0_CMD_R_TIMER0_START, 1);
crate::println!("PWM running on PA0?");
for i in 0..12 {
@ -288,6 +330,21 @@ pub fn setup_alloc() {
}
}
/// Delay with a given system clock frequency. Useful during power mode switching.
pub fn delay_at_sysfreq(ms: usize, sysclk_freq: u32) {
let mut timer = utralib::CSR::new(utra::timer0::HW_TIMER0_BASE as *mut u32);
timer.wfo(utra::timer0::EN_EN, 0b0); // disable the timer
timer.wfo(utra::timer0::LOAD_LOAD, 0);
timer.wfo(utra::timer0::RELOAD_RELOAD, sysclk_freq / 1000);
timer.wfo(utra::timer0::EN_EN, 1);
timer.wfo(utra::timer0::EV_PENDING_ZERO, 1);
for _ in 0..ms {
// comment this out for testing on MPW
while timer.rf(utra::timer0::EV_PENDING_ZERO) == 0 {}
timer.wfo(utra::timer0::EV_PENDING_ZERO, 1);
}
}
/// Delay function that delays a given number of milliseconds.
pub fn delay(ms: usize) {
let mut timer = utralib::CSR::new(utra::timer0::HW_TIMER0_BASE as *mut u32);
@ -444,7 +501,15 @@ pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
// commit dividers
daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32);
// TODO select int/ext osc/xtal
// set voltage regulators to 0.893v. This is necessary because lp mode may set it lower.
crate::println!("setting vdd85 to 0.893v");
let mut ao_sysctrl = CSR::new(utralib::HW_AO_SYSCTRL_BASE as *mut u32);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRM0CSR, 0x08421FF1);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRM1CSR, 0x2);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x57);
crate::platform::delay_at_sysfreq(20, 48_000_000);
crate::println!("...done");
// DARIC_CGU->cgusel1 = 1; // 0: RC, 1: XTAL
cgu.wo(sysctrl::SFR_CGUSEL1, 1);
// DARIC_CGU->cgufscr = FREQ_OSC_MHZ; // external crystal is 48MHz
@ -460,7 +525,7 @@ pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
duart.add(utra::duart::SFR_ETUC.offset()).write_volatile(FREQ_OSC_MHZ);
duart.add(utra::duart::SFR_CR.offset()).write_volatile(1);
if freq_hz <= 48_000_000 {
if freq_hz <= 1_000_000 {
// DARIC_IPC->osc = freqHz;
cgu.wo(sysctrl::SFR_IPCOSC, freq_hz);
// __DSB();
@ -476,7 +541,7 @@ pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
cgu.wo(sysctrl::SFR_CGUSET, 0x32);
//__DSB();
if freq_hz <= 48_000_000 {
if freq_hz <= 1_000_000 {
} else {
let n_fxp24: u64; // fixed point
let f16mhz_log2: u32 = (freq_hz / FREQ_0).ilog2();
@ -497,7 +562,8 @@ pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
unsafe { core::arch::asm!("nop") };
}
crate::println!("PLL delay 1");
// why is this print needed for the code not to crash?
crate::println!("freq_hz {} log2 {}", freq_hz, f16mhz_log2);
n_fxp24 = (((freq_hz as u64) << 24) * TBL_MUL[f16mhz_log2 as usize] as u64
+ PFD_F_MHZ as u64 * UNIT_MHZ as u64 / 2)
/ (PFD_F_MHZ as u64 * UNIT_MHZ as u64); // rounded
@ -597,3 +663,138 @@ pub fn lfsr_next_u32(state: u32) -> u32 {
(state << 1) + bit
}
pub fn clockset_wrapper(freq: u32) -> u32 {
// reset the baud rate on the console UART
let perclk = unsafe { crate::platform::init_clock_asic(freq) };
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
#[cfg(feature = "nto-evb")]
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(utra::udma_uart_1::HW_UDMA_UART_1_BASE, uart_buf_addr, uart_buf_addr)
};
#[cfg(not(feature = "nto-evb"))]
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(utra::udma_uart_2::HW_UDMA_UART_2_BASE, uart_buf_addr, uart_buf_addr)
};
let baudrate: u32 = 115200;
let freq: u32 = perclk / 2;
udma_uart.set_baud(baudrate, freq);
crate::println!("clock set done, perclk is {} MHz", perclk / 1_000_000);
udma_uart.write("console up with clocks\r\n".as_bytes());
perclk
}
#[allow(dead_code)]
pub unsafe fn low_power() -> u32 {
const FREQ_OSC_MHZ: u32 = 48; // 48MHz
use utra::sysctrl;
let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32;
let mut cgu = CSR::new(daric_cgu);
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0.offset()).write_volatile(0x3f3f); // fclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1.offset()).write_volatile(0x3f3f); // aclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2.offset()).write_volatile(0x1f1f); // hclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3.offset()).write_volatile(0x0f0f); // iclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4.offset()).write_volatile(0x0707); // pclk
let (min_cycle, fd, perclk) = if let Some((min_cycle, fd, perclk)) = clk_to_per(48, 24) {
daric_cgu
.add(utra::sysctrl::SFR_CGUFDPER.offset())
.write_volatile((min_cycle as u32) << 16 | (fd as u32) << 8 | fd as u32);
crate::println!("perclk {}", perclk);
(min_cycle, fd, perclk * 1_000_000)
} else {
crate::println!("couldn't find perclk solution");
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x03_ff_ff);
(3, 0xff, 48_000_000 / 4)
};
let perclk = perclk;
// DARIC_CGU->cgusel1 = 1; // 0: RC, 1: XTAL
cgu.wo(sysctrl::SFR_CGUSEL0, 0);
cgu.wo(sysctrl::SFR_CGUSEL1, 1);
cgu.wo(sysctrl::SFR_CGUFSCR, FREQ_OSC_MHZ);
cgu.wo(sysctrl::SFR_CGUSET, 0x32);
let duart = utra::duart::HW_DUART_BASE as *mut u32;
duart.add(utra::duart::SFR_CR.offset()).write_volatile(0);
// set the ETUC now that we're on the xosc.
duart.add(utra::duart::SFR_ETUC.offset()).write_volatile(FREQ_OSC_MHZ);
duart.add(utra::duart::SFR_CR.offset()).write_volatile(1);
cgu.wo(sysctrl::SFR_IPCOSC, FREQ_OSC_MHZ * 1_000_000);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32);
// lower core voltage to 0.7v
let mut ao_sysctrl = CSR::new(utralib::HW_AO_SYSCTRL_BASE as *mut u32);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRM0CSR, 0x08420002);
// ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRM1CSR, 0x1);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x57);
// power down the PLL
cgu.wo(sysctrl::SFR_IPCLPEN, cgu.r(sysctrl::SFR_IPCLPEN) & !0x2);
cgu.wo(sysctrl::SFR_IPCCR, 0x53);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32);
for _ in 0..1024 {
unsafe { core::arch::asm!("nop") };
}
crate::println!("PLL pd delay 1");
crate::println!("fsvalid: {}", daric_cgu.add(sysctrl::SFR_CGUFSVLD.offset()).read_volatile());
let clk_desc: [(&'static str, u32, usize); 8] = [
("fclk", 16, 0x40 / size_of::<u32>()),
("pke", 0, 0x40 / size_of::<u32>()),
("ao", 16, 0x44 / size_of::<u32>()),
("aoram", 0, 0x44 / size_of::<u32>()),
("osc", 16, 0x48 / size_of::<u32>()),
("xtal", 0, 0x48 / size_of::<u32>()),
("pll0", 16, 0x4c / size_of::<u32>()),
("pll1", 0, 0x4c / size_of::<u32>()),
];
for (name, shift, offset) in clk_desc {
let fsfreq = (daric_cgu.add(offset).read_volatile() >> shift) & 0xffff;
crate::println!("{}: {} MHz", name, fsfreq);
}
// gates off
daric_cgu.add(utra::sysctrl::SFR_ACLKGR.offset()).write_volatile(0x00);
daric_cgu.add(utra::sysctrl::SFR_HCLKGR.offset()).write_volatile(0x00);
daric_cgu.add(utra::sysctrl::SFR_ICLKGR.offset()).write_volatile(0x00);
daric_cgu.add(utra::sysctrl::SFR_PCLKGR.offset()).write_volatile(0x00);
// commit dividers
daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32);
let mut udmacore = CSR::new(utra::udma_ctrl::HW_UDMA_CTRL_BASE as *mut u32);
udmacore.wo(utra::udma_ctrl::REG_CG, 0x0000_000F); // lower four are the UART
// reset the UART
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
#[cfg(feature = "nto-evb")]
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(utra::udma_uart_1::HW_UDMA_UART_1_BASE, uart_buf_addr, uart_buf_addr)
};
#[cfg(not(feature = "nto-evb"))]
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(utra::udma_uart_2::HW_UDMA_UART_2_BASE, uart_buf_addr, uart_buf_addr)
};
let baudrate: u32 = 115200;
let freq: u32 = perclk / 2;
udma_uart.set_baud(baudrate, freq);
crate::println!("Perclk solution: {:x}|{:x} -> {} MHz", min_cycle, fd, perclk / 1_000_000);
crate::println!("powerdown: perclk is {} MHz", perclk / 1_000_000);
udma_uart.write("powerdown with clocks\r\n".as_bytes());
perclk
}

View file

@ -195,6 +195,12 @@ pub extern "C" fn trap_handler(
timer0.wfo(utra::timer0::RELOAD_RELOAD, (SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);
} else if (irqs_pending & (1 << utra::irqarray5::IRQARRAY5_IRQ)) != 0 {
crate::uart_irq_handler();
} else if (irqs_pending & (1 << utra::irqarray2::IRQARRAY2_IRQ)) != 0 {
// just clear it for now
let mut irqarray2 = CSR::new(utralib::HW_IRQARRAY2_BASE as *mut u32);
let pending = irqarray2.r(utra::irqarray2::EV_PENDING);
crate::println!("keypress interrupt {:x}", pending);
irqarray2.wo(utra::irqarray2::EV_PENDING, pending);
}
}

View file

@ -3,6 +3,9 @@ use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
#[allow(unused_imports)]
#[cfg(feature = "cramium-soc")]
use cramium_api::*;
#[allow(unused_imports)]
use utralib::*;
#[cfg(any(feature = "artybio", feature = "nto-bio"))]
@ -364,7 +367,6 @@ impl Repl {
}
#[cfg(feature = "cramium-soc")]
"clocks" => {
use cramium_hal::udma;
if args.len() == 1 {
let f = u32::from_str_radix(&args[0], 10)
.map_err(|_| Error::help("clock <freq>, where freq is a number from 100-1600"))
@ -375,35 +377,7 @@ impl Repl {
})?;
crate::println!("Setting clock to: {} MHz", f / 1_000_000);
// reset the baud rate on the console UART
let perclk = unsafe { crate::platform::init_clock_asic(f) };
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
#[cfg(feature = "nto-evb")]
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(
utra::udma_uart_1::HW_UDMA_UART_1_BASE,
uart_buf_addr,
uart_buf_addr,
)
};
#[cfg(not(feature = "nto-evb"))]
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(
utra::udma_uart_2::HW_UDMA_UART_2_BASE,
uart_buf_addr,
uart_buf_addr,
)
};
let baudrate: u32 = 115200;
let freq: u32 = perclk / 2;
udma_uart.set_baud(baudrate, freq);
crate::println!("clock set done, perclk is {} MHz", perclk / 1_000_000);
udma_uart.write("console up with clocks\r\n".as_bytes());
crate::platform::clockset_wrapper(f);
} else {
return Err(Error::help("clocks <CPU freq in MHz, 100-1600>"));
}
@ -672,7 +646,228 @@ impl Repl {
}
}
}
#[cfg(all(feature = "cramium-soc", not(feature = "nto-evb")))]
"ldo" => {
if args.len() != 1 {
return Err(Error::help("vdd85 [on|off]"));
}
use cramium_hal::iox::Iox;
let iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32);
if args[0] == "off" {
crate::println!("Check DCDC2");
let i2c_channel = cramium_hal::board::setup_i2c_pins(&iox);
use cramium_hal::udma::GlobalConfig;
let udma_global = GlobalConfig::new();
udma_global.clock(PeriphId::from(i2c_channel), true);
let i2c_ifram = unsafe {
cramium_hal::ifram::IframRange::from_raw_parts(
cramium_hal::board::I2C_IFRAM_ADDR,
cramium_hal::board::I2C_IFRAM_ADDR,
4096,
)
};
let perclk = 100_000_000; // assume this value
let mut i2c = unsafe {
cramium_hal::udma::I2c::new_with_ifram(
i2c_channel,
400_000,
perclk,
i2c_ifram,
&udma_global,
)
};
if let Ok(mut pmic) = cramium_hal::axp2101::Axp2101::new(&mut i2c) {
pmic.update(&mut i2c).ok();
if let Some((voltage, _dvm)) = pmic.get_dcdc(cramium_hal::axp2101::WhichDcDc::Dcdc2) {
crate::println!("DCDC2 is on and {:.2}v", voltage);
} else {
crate::println!("DCDC is off, turning it on!");
match pmic.set_dcdc(
&mut i2c,
Some((0.88, true)),
cramium_hal::axp2101::WhichDcDc::Dcdc2,
) {
Ok(_) => crate::println!("turned on DCDC2"),
Err(_) => {
return Err(Error::help("coludn't turn off DCDC2, aborted!"));
}
}
}
}
// shut down LDO
crate::println!("Engage DCDC2 FET");
iox.set_gpio_pin_value(IoxPort::PA, 5, IoxValue::Low);
// just "Lower the voltage"
let mut ao_sysctrl = CSR::new(utralib::HW_AO_SYSCTRL_BASE as *mut u32);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRMLP0, 0x08420002); // 0.7v
let mut cgu = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32);
cgu.wo(utra::sysctrl::SFR_IPCARIPFLOW, 0x57);
} else {
crate::println!("Disengage DCDC2 FET");
iox.set_gpio_pin_value(IoxPort::PA, 5, IoxValue::High);
}
}
#[cfg(all(feature = "cramium-soc", not(feature = "nto-evb")))]
"wfi" => {
let iox = cramium_hal::iox::Iox::new(utra::iox::HW_IOX_BASE as *mut u32);
let ao_bkupreg = CSR::new(utralib::HW_AOBUREG_BASE as *mut u32);
for i in 0..8 {
crate::println!("backup reg {}: {:08x}", i, unsafe {
ao_bkupreg.base().add(i).read_volatile()
});
}
let bkp = ao_bkupreg.r(utra::aobureg::SFR_BUREG_CR_BUREGS0);
// this will cause the backup regs to increment every wakeup cycle
for i in 0..8 {
unsafe {
ao_bkupreg.base().add(i).write_volatile(0xcafe_0001 + i as u32 + (bkp & 0xFFFF))
};
}
// pin map to PF is controlled here, for some reason...
let mut ao_sysctrl = CSR::new(utralib::HW_AO_SYSCTRL_BASE as *mut u32);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_IOX, 1);
// ao_sysctrl.wo(utra::ao_sysctrl::CR_WKUPMASK, 0x10_10);
// ao_sysctrl.wo(utra::ao_sysctrl::CR_WKUPMASK, 0x3FFFF);
ao_sysctrl.wo(utra::ao_sysctrl::CR_WKUPMASK, 0x3F);
crate::println!("ao wkupmsk: {:x}", ao_sysctrl.r(utra::ao_sysctrl::CR_WKUPMASK));
for pin in 2..=9 {
iox.setup_pin(
IoxPort::PF,
pin,
Some(IoxDir::Input),
Some(IoxFunction::AF1),
Some(IoxEnable::Enable),
Some(IoxEnable::Enable),
Some(IoxEnable::Enable),
Some(IoxDriveStrength::Drive2mA),
);
}
let mut dkpc = CSR::new(utralib::HW_DKPC_BASE as *mut u32);
dkpc.wo(utra::dkpc::SFR_CFG0, 0x1d);
dkpc.wo(utra::dkpc::SFR_CFG1, 0x04_02_02);
dkpc.wo(utra::dkpc::SFR_CFG2, 0x0804_02_02);
dkpc.wo(utra::dkpc::SFR_CFG4, 20);
while dkpc.r(utra::dkpc::SFR_SR1) != 0 {
// this register didn't get mapped in register extraction because its type
// is `apb_buf2`: FIXME - adjust the register extraction script to capture this type.
// this register drains the pending interrupts from the wakeup/keyboard queue
let _ = unsafe { dkpc.base().add(8).read_volatile() };
}
let mut irqarray2 = CSR::new(utralib::HW_IRQARRAY2_BASE as *mut u32);
irqarray2.wo(utra::irqarray2::EV_PENDING, 0xFFFF_FFFF);
irqarray2.wo(utra::irqarray2::EV_ENABLE, 0xFFFF_FFFF);
// crate::platform::irq::enable_irq(utra::irqarray2::IRQARRAY2_IRQ);
let forever = if args.len() > 0 { args[0] == "loop" } else { false };
// current status of WFI:
// - we can scan the KP inputs using the KP scan mechanism
// - stuff queues up in the fifo
// - we see the vld bit set
// - we can't get an interrupt to fire.
let mut count = 0; // just so we know the machine hasn't crashed
loop {
crate::print!("{}|", count);
for i in (0..6).chain(12..13).chain(8..9) {
crate::print!("{:x}: {:x} ", i * 4, unsafe { dkpc.base().add(i).read_volatile() });
}
let fr = ao_sysctrl.r(utra::ao_sysctrl::SFR_AOFR);
crate::print!(
"int: {:x}/{:x}/{:x}",
irqarray2.r(utra::irqarray2::EV_PENDING),
irqarray2.r(utra::irqarray2::EV_STATUS),
fr
);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_AOFR, fr);
crate::println!("");
if !forever {
break;
} else {
crate::platform::delay(500);
}
count += 1;
}
// vexriscv::register::vexriscv::mim::write(0x0); // disable all interrupts
crate::println!("entering wfi");
// bring us down to 100MHz so we can turn off regulators
let perclk = crate::platform::clockset_wrapper(100_000_000);
crate::println!("clocks @ 100MHz");
// configure PMIC to be off
let i2c_channel = cramium_hal::board::setup_i2c_pins(&iox);
use cramium_hal::udma::GlobalConfig;
let udma_global = GlobalConfig::new();
udma_global.clock(PeriphId::from(i2c_channel), true);
let i2c_ifram = unsafe {
cramium_hal::ifram::IframRange::from_raw_parts(
cramium_hal::board::I2C_IFRAM_ADDR,
cramium_hal::board::I2C_IFRAM_ADDR,
4096,
)
};
let mut i2c = unsafe {
cramium_hal::udma::I2c::new_with_ifram(
i2c_channel,
400_000,
perclk,
i2c_ifram,
&udma_global,
)
};
if let Ok(mut pmic) = cramium_hal::axp2101::Axp2101::new(&mut i2c) {
match pmic.set_dcdc(&mut i2c, None, cramium_hal::axp2101::WhichDcDc::Dcdc2) {
Ok(_) => crate::println!("turned off DCDC2"),
Err(_) => crate::println!("couldn't turn off DCDC2"),
}
}
unsafe {
crate::platform::low_power();
}
crate::println!("pmu cr: {:x}", ao_sysctrl.r(utra::ao_sysctrl::SFR_PMUCSR));
crate::println!("pmu status: {:x}", ao_sysctrl.r(utra::ao_sysctrl::SFR_PMUSR));
crate::println!("pmu err: {:x}", ao_sysctrl.r(utra::ao_sysctrl::SFR_PMUFR));
crate::println!("trying PD mode");
ao_sysctrl.wo(utra::ao_sysctrl::CR_CR, 7);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUCRPD, 0x4c);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRMLP0, 0x08420002); // 0.7v
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUPDAR, 0x5a);
crate::println!("entered PD mode");
// turn regulator off - system of course does not work
/*
crate::println!("attempting to turn off VDD085");
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUCSR, 0x4c);
let mut cgu = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32);
cgu.wo(utra::sysctrl::SFR_IPCARIPFLOW, 0x57);
for _ in 0..1024 {
unsafe { core::arch::asm!("nop") };
}
crate::println!("PD pmu cr: {:x}", ao_sysctrl.r(utra::ao_sysctrl::SFR_PMUCSR));
*/
unsafe { core::arch::asm!("wfi", "nop", "nop", "nop", "nop") };
// turn regulator back on
/*
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUCSR, 0x7c);
let mut cgu = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32);
cgu.wo(utra::sysctrl::SFR_IPCARIPFLOW, 0x57);
for _ in 0..1024 {
unsafe { core::arch::asm!("nop") };
}
crate::println!("PU pmu cr: {:x}", ao_sysctrl.r(utra::ao_sysctrl::SFR_PMUCSR));
*/
crate::platform::clockset_wrapper(800_000_000);
crate::println!("exiting wfi");
}
"echo" => {
for word in args {
crate::print!("{} ", word);
@ -688,6 +883,8 @@ impl Repl {
crate::print!(", mon");
#[cfg(feature = "nto-bio")]
crate::print!(", bio, pin");
#[cfg(all(feature = "cramium-soc", not(feature = "nto-evb")))]
crate::print!(", ldo, wfi");
crate::println!("");
}
}