mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
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:
parent
13b048089b
commit
29b524375b
3 changed files with 457 additions and 53 deletions
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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!("");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue