1use super::SleepKind;
2use crate::{
3 peripherals::{APB_CTRL, BB, EXTMEM, LPWR, SPI0, SPI1, SYSTEM},
4 rtc_cntl::Rtc,
5 soc::regi2c,
6};
7
8pub const RTC_CNTL_DBIAS_0V90: u8 = 13;
13pub const RTC_CNTL_DBIAS_0V95: u8 = 16;
15pub const RTC_CNTL_DBIAS_1V00: u8 = 18;
17pub const RTC_CNTL_DBIAS_1V05: u8 = 20;
19pub const RTC_CNTL_DBIAS_1V10: u8 = 23;
21pub const RTC_CNTL_DBIAS_1V15: u8 = 25;
23pub const RTC_CNTL_DBIAS_1V20: u8 = 28;
25pub const RTC_CNTL_DBIAS_1V25: u8 = 30;
27pub const RTC_CNTL_DBIAS_1V30: u8 = 31;
29
30pub const RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_DEFAULT: u8 = 5;
32pub const RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_NODROP: u8 = 0;
34pub const RTC_CNTL_DBG_ATTEN_DEEPSLEEP_DEFAULT: u8 = 15;
36pub const RTC_CNTL_DBG_ATTEN_DEEPSLEEP_NODROP: u8 = 0;
38
39pub const RTC_CNTL_BIASSLP_SLEEP_DEFAULT: u8 = 1;
41pub const RTC_CNTL_BIASSLP_SLEEP_ON: u8 = 0;
43
44pub const RTC_CNTL_PD_CUR_SLEEP_DEFAULT: u8 = 1;
46pub const RTC_CNTL_PD_CUR_SLEEP_ON: u8 = 0;
48
49pub const RTC_CNTL_DG_VDD_DRV_B_SLP_DEFAULT: u8 = 254;
51
52pub const RTC_CNTL_DBG_ATTEN_MONITOR_DEFAULT: u8 = 0;
54pub const RTC_CNTL_BIASSLP_MONITOR_DEFAULT: bool = false;
56pub const RTC_CNTL_PD_CUR_MONITOR_DEFAULT: bool = false;
58
59pub const RTC_CNTL_PLL_BUF_WAIT_DEFAULT: u8 = 20;
61pub const RTC_CNTL_XTL_BUF_WAIT_DEFAULT: u8 = 100;
63pub const RTC_CNTL_CK8M_WAIT_DEFAULT: u8 = 20;
65pub const RTC_CK8M_ENABLE_WAIT_DEFAULT: u8 = 5;
67
68pub const RTC_CNTL_MIN_SLP_VAL_MIN: u8 = 2;
70
71pub const OTHER_BLOCKS_POWERUP: u8 = 1;
73pub const OTHER_BLOCKS_WAIT: u16 = 1;
75
76pub const GPIO_INTR_DISABLE: u8 = 0;
78pub const GPIO_INTR_LOW_LEVEL: u8 = 4;
80pub const GPIO_INTR_HIGH_LEVEL: u8 = 5;
82
83pub const PIN_FUNC_GPIO: u8 = 1;
85pub const SIG_GPIO_OUT_IDX: u32 = 128;
87pub const GPIO_NUM_MAX: usize = 22;
89
90bitfield::bitfield! {
91 #[derive(Clone, Copy)]
92 pub struct RtcConfig(u32);
94 impl Debug;
95 pub u8, ck8m_wait, set_ck8m_wait: 7, 0;
97 pub u8, xtal_wait, set_xtal_wait: 15, 8;
99 pub u8, pll_wait, set_pll_wait: 23, 16;
101 pub clkctl_init, set_clkctl_init: 24;
103 pub pwrctl_init, set_pwrctl_init: 25;
105 pub rtc_dboost_fpd, set_rtc_dboost_fpd: 26;
107 pub xtal_fpu, set_xtal_fpu: 27;
109 pub bbpll_fpu, set_bbpll_fpu: 28;
111 pub cpu_waiti_clk_gate, set_cpu_waiti_clk_gate: 29;
113 pub cali_ocode, set_cali_ocode: 30;
115}
116
117impl Default for RtcConfig {
118 fn default() -> Self {
119 let mut cfg = Self(Default::default());
120 cfg.set_ck8m_wait(RTC_CNTL_CK8M_WAIT_DEFAULT);
121 cfg.set_xtal_wait(RTC_CNTL_XTL_BUF_WAIT_DEFAULT);
122 cfg.set_pll_wait(RTC_CNTL_PLL_BUF_WAIT_DEFAULT);
123 cfg.set_clkctl_init(true);
124 cfg.set_pwrctl_init(true);
125 cfg.set_rtc_dboost_fpd(true);
126 cfg.set_cpu_waiti_clk_gate(true);
127 cfg
128 }
129}
130
131bitfield::bitfield! {
132 #[derive(Clone, Copy)]
133 pub struct RtcInitConfig(u128);
135 impl Debug;
136 pub u8, wifi_powerup_cycles, set_wifi_powerup_cycles: 6, 0;
138 pub u16, wifi_wait_cycles, set_wifi_wait_cycles: 15, 7;
140 pub u8, bt_powerup_cycles, set_bt_powerup_cycles: 22, 16;
142 pub u16, bt_wait_cycles, set_bt_wait_cycles: 31, 23;
144 pub u8, cpu_top_powerup_cycles, set_cpu_top_powerup_cycles: 38, 32;
146 pub u16, cpu_top_wait_cycles, set_cpu_top_wait_cycles: 47, 39;
148 pub u8, dg_wrap_powerup_cycles, set_dg_wrap_powerup_cycles: 54, 48;
150 pub u16, dg_wrap_wait_cycles, set_dg_wrap_wait_cycles: 63, 55;
152 pub u8, dg_peri_powerup_cycles, set_dg_peri_powerup_cycles: 70, 64;
154 pub u16, dg_peri_wait_cycles, set_dg_peri_wait_cycles: 79, 71;
156}
157
158impl Default for RtcInitConfig {
159 fn default() -> Self {
160 let mut cfg = Self(Default::default());
161 cfg.set_wifi_powerup_cycles(OTHER_BLOCKS_POWERUP);
162 cfg.set_bt_powerup_cycles(OTHER_BLOCKS_POWERUP);
163 cfg.set_cpu_top_powerup_cycles(OTHER_BLOCKS_POWERUP);
164 cfg.set_dg_wrap_powerup_cycles(OTHER_BLOCKS_POWERUP);
165 cfg.set_dg_peri_powerup_cycles(OTHER_BLOCKS_POWERUP);
166 cfg.set_wifi_wait_cycles(OTHER_BLOCKS_WAIT);
167 cfg.set_bt_wait_cycles(OTHER_BLOCKS_WAIT);
168 cfg.set_cpu_top_wait_cycles(OTHER_BLOCKS_WAIT);
169 cfg.set_dg_wrap_wait_cycles(OTHER_BLOCKS_WAIT);
170 cfg.set_dg_peri_wait_cycles(OTHER_BLOCKS_WAIT);
171 cfg
172 }
173}
174
175bitfield::bitfield! {
176 #[derive(Clone, Copy)]
177 pub struct RtcSleepConfig(u64);
179 impl Debug;
180 pub lslp_mem_inf_fpu, set_lslp_mem_inf_fpu: 0;
182 pub rtc_mem_inf_follow_cpu, set_rtc_mem_inf_follow_cpu: 1;
184 pub rtc_fastmem_pd_en, set_rtc_fastmem_pd_en: 2;
186 pub rtc_slowmem_pd_en, set_rtc_slowmem_pd_en: 3;
188 pub rtc_peri_pd_en, set_rtc_peri_pd_en: 4;
190 pub wifi_pd_en, set_wifi_pd_en: 5;
192 pub bt_pd_en, set_bt_pd_en: 6;
194 pub int_8m_pd_en, set_int_8m_pd_en: 8;
196 pub dig_peri_pd_en, set_dig_peri_pd_en: 9;
198 pub deep_slp, set_deep_slp: 10;
200 pub wdt_flashboot_mod_en, set_wdt_flashboot_mod_en: 11;
202 pub u8, dig_dbias_slp, set_dig_dbias_slp: 16, 12;
204 pub u8, rtc_dbias_slp, set_rtc_dbias_slp: 21, 17;
206 pub u8, dbg_atten_slp, set_dbg_atten_slp: 25, 22;
208 pub bias_sleep_monitor, set_bias_sleep_monitor: 26;
210 pub bias_sleep_slp, set_bias_sleep_slp: 27;
212 pub pd_cur_slp, set_pd_cur_slp: 28;
214 pub vddsdio_pd_en, set_vddsdio_pd_en: 29;
216 pub xtal_fpu, set_xtal_fpu: 30;
218 pub rtc_regulator_fpu, set_rtc_regulator_fpu: 31;
220 pub deep_slp_reject, set_deep_slp_reject: 32;
222 pub light_slp_reject, set_light_slp_reject: 33;
224}
225
226impl Default for RtcSleepConfig {
227 fn default() -> Self {
228 let mut cfg = Self(Default::default());
229 cfg.set_deep_slp_reject(true);
230 cfg.set_light_slp_reject(true);
231 cfg.set_rtc_dbias_slp(RTC_CNTL_DBIAS_1V10);
232 cfg.set_dig_dbias_slp(RTC_CNTL_DBIAS_1V10);
233
234 cfg.set_rtc_regulator_fpu(true);
238 cfg.set_bias_sleep_monitor(true);
239 cfg.set_bias_sleep_slp(true);
240 cfg.set_pd_cur_slp(true);
241 cfg
242 }
243}
244
245const DR_REG_NRX_BASE: u32 = 0x6001CC00;
246const DR_REG_FE_BASE: u32 = 0x60006000;
247const DR_REG_FE2_BASE: u32 = 0x60005000;
248
249const NRXPD_CTRL: u32 = DR_REG_NRX_BASE + 0x00d4;
250const FE_GEN_CTRL: u32 = DR_REG_FE_BASE + 0x0090;
251const FE2_TX_INTERP_CTRL: u32 = DR_REG_FE2_BASE + 0x00f0;
252
253const SYSCON_SRAM_POWER_UP: u8 = 0x0000000F;
254const SYSCON_ROM_POWER_UP: u8 = 0x00000003;
255
256const NRX_RX_ROT_FORCE_PU: u32 = 1 << 5;
257const NRX_VIT_FORCE_PU: u32 = 1 << 3;
258const NRX_DEMAP_FORCE_PU: u32 = 1 << 1;
259
260const FE_IQ_EST_FORCE_PU: u32 = 1 << 5;
261const FE2_TX_INF_FORCE_PU: u32 = 1 << 10;
262
263fn modify_register(reg: u32, mask: u32, value: u32) {
264 let reg = reg as *mut u32;
265
266 unsafe { reg.write_volatile((reg.read_volatile() & !mask) | value) };
267}
268
269fn register_modify_bits(reg: u32, bits: u32, set: bool) {
270 if set {
271 modify_register(reg, bits, bits);
272 } else {
273 modify_register(reg, bits, 0);
274 }
275}
276
277fn rtc_sleep_pu(val: bool) {
278 LPWR::regs()
279 .dig_pwc()
280 .modify(|_, w| w.lslp_mem_force_pu().bit(val));
281
282 APB_CTRL::regs().front_end_mem_pd().modify(|_r, w| {
283 w.dc_mem_force_pu().bit(val);
284 w.pbus_mem_force_pu().bit(val);
285 w.agc_mem_force_pu().bit(val)
286 });
287
288 BB::regs()
289 .bbpd_ctrl()
290 .modify(|_r, w| w.fft_force_pu().bit(val).dc_est_force_pu().bit(val));
291
292 register_modify_bits(
293 NRXPD_CTRL,
294 NRX_RX_ROT_FORCE_PU | NRX_VIT_FORCE_PU | NRX_DEMAP_FORCE_PU,
295 val,
296 );
297
298 register_modify_bits(FE_GEN_CTRL, FE_IQ_EST_FORCE_PU, val);
299
300 register_modify_bits(FE2_TX_INTERP_CTRL, FE2_TX_INF_FORCE_PU, val);
301
302 APB_CTRL::regs().mem_power_up().modify(|_r, w| unsafe {
303 w.sram_power_up()
304 .bits(if val { SYSCON_SRAM_POWER_UP } else { 0 });
305 w.rom_power_up()
306 .bits(if val { SYSCON_ROM_POWER_UP } else { 0 })
307 });
308}
309
310impl RtcSleepConfig {
311 pub fn deep() -> Self {
315 let mut cfg = Self::default();
320
321 cfg.set_lslp_mem_inf_fpu(false);
322 cfg.set_rtc_mem_inf_follow_cpu(true); cfg.set_rtc_fastmem_pd_en(true);
324 cfg.set_rtc_slowmem_pd_en(true);
325 cfg.set_rtc_peri_pd_en(true);
326 cfg.set_wifi_pd_en(true);
327 cfg.set_bt_pd_en(true);
328 cfg.set_int_8m_pd_en(true);
329
330 cfg.set_dig_peri_pd_en(true);
331 cfg.set_dig_dbias_slp(0); cfg.set_deep_slp(true);
334 cfg.set_wdt_flashboot_mod_en(false);
335 cfg.set_vddsdio_pd_en(true);
336 cfg.set_xtal_fpu(false);
337 cfg.set_deep_slp_reject(true);
338 cfg.set_light_slp_reject(true);
339 cfg.set_rtc_dbias_slp(RTC_CNTL_DBIAS_1V10);
340
341 cfg.set_rtc_regulator_fpu(false);
343 cfg.set_dbg_atten_slp(RTC_CNTL_DBG_ATTEN_DEEPSLEEP_DEFAULT);
344
345 cfg.set_bias_sleep_monitor(true);
347 cfg.set_bias_sleep_slp(true);
348 cfg.set_pd_cur_slp(true);
349
350 cfg
351 }
352
353 pub(crate) fn is_deep_sleep(&self) -> bool {
354 self.deep_slp()
355 }
356
357 pub(crate) fn set_sleep_kind(&mut self, kind: SleepKind) {
358 self.set_deep_slp(kind == SleepKind::Deep);
359 }
360
361 pub(crate) fn base_settings(_rtc: &Rtc<'_>) {
362 let cfg = RtcConfig::default();
363
364 let rtc_cntl = LPWR::regs();
366 let extmem = EXTMEM::regs();
367 let system = SYSTEM::regs();
368
369 regi2c::I2C_DIG_REG_XPD_RTC_REG.write_field(0);
370 regi2c::I2C_DIG_REG_XPD_DIG_REG.write_field(0);
371
372 unsafe {
373 rtc_cntl.timer1().modify(|_, w| {
374 w.pll_buf_wait().bits(cfg.pll_wait());
375 w.ck8m_wait().bits(cfg.ck8m_wait())
376 });
377
378 rtc_cntl
382 .timer5()
383 .modify(|_, w| w.min_slp_val().bits(RTC_CNTL_MIN_SLP_VAL_MIN));
384
385 regi2c::I2C_DIG_REG_EXT_RTC_DREG_SLEEP.write_field(RTC_CNTL_DBIAS_1V10);
389
390 regi2c::I2C_DIG_REG_EXT_RTC_DREG.write_field(RTC_CNTL_DBIAS_1V25);
396 regi2c::I2C_DIG_REG_EXT_DIG_DREG.write_field(RTC_CNTL_DBIAS_1V25);
397
398 if cfg.clkctl_init() {
399 extmem
402 .cache_mmu_power_ctrl()
403 .modify(|_, w| w.cache_mmu_mem_force_on().clear_bit());
404 extmem
407 .icache_tag_power_ctrl()
408 .modify(|_, w| w.icache_tag_mem_force_on().clear_bit());
409
410 SPI0::regs()
412 .clock_gate()
413 .modify(|_, w| w.clk_en().clear_bit());
414 SPI1::regs()
415 .clock_gate()
416 .modify(|_, w| w.clk_en().clear_bit());
417 }
418
419 if cfg.pwrctl_init() {
420 rtc_cntl
421 .clk_conf()
422 .modify(|_, w| w.ck8m_force_pu().clear_bit());
423
424 rtc_cntl
425 .options0()
426 .modify(|_, w| w.xtl_force_pu().bit(cfg.xtal_fpu() || cfg.bbpll_fpu()));
427
428 rtc_cntl.options0().modify(|_, w| {
431 w.bbpll_force_pu().bit(cfg.bbpll_fpu());
432 w.bbpll_i2c_force_pu().bit(cfg.bbpll_fpu());
433 w.bb_i2c_force_pu().bit(cfg.bbpll_fpu())
434 });
435
436 rtc_cntl
437 .rtc_cntl()
438 .modify(|_, w| w.regulator_force_pu().clear_bit());
439
440 system
445 .mem_pd_mask()
446 .modify(|_, w| w.lslp_mem_pd_mask().clear_bit());
447
448 rtc_sleep_pu(false);
452
453 rtc_cntl
454 .dig_pwc()
455 .modify(|_, w| w.dg_wrap_force_pu().clear_bit());
456
457 rtc_cntl
458 .dig_iso()
459 .modify(|_, w| w.dg_wrap_force_noiso().clear_bit());
460
461 system
465 .cpu_per_conf()
466 .modify(|_, w| w.cpu_wait_mode_force_on().bit(!cfg.cpu_waiti_clk_gate()));
467
468 rtc_cntl.dig_iso().modify(|_, w| {
471 w.dg_pad_force_unhold().clear_bit();
472 w.dg_pad_force_noiso().clear_bit()
473 });
474 }
475
476 rtc_cntl.int_ena().write(|w| w.bits(0));
477 rtc_cntl.int_clr().write(|w| w.bits(u32::MAX));
478
479 regi2c::I2C_ULP_IR_FORCE_XPD_CK.write_field(1);
480 }
481 }
482
483 pub(crate) fn apply(&self) {
484 let rtc_cntl = LPWR::regs();
486
487 if self.lslp_mem_inf_fpu() {
488 rtc_sleep_pu(true);
489 }
490
491 unsafe {
492 let xtal_on = self.xtal_fpu() && !self.deep_slp();
495 let bias_sleep_slp = self.bias_sleep_slp() && !xtal_on;
496 let pd_cur_slp = self.pd_cur_slp() && !xtal_on;
497 let dbg_atten_slp = if xtal_on {
498 RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_NODROP
499 } else {
500 self.dbg_atten_slp()
501 };
502
503 assert!(!pd_cur_slp || bias_sleep_slp);
504
505 regi2c::I2C_DIG_REG_EXT_RTC_DREG_SLEEP.write_field(self.rtc_dbias_slp());
506 regi2c::I2C_DIG_REG_EXT_DIG_DREG_SLEEP.write_field(self.dig_dbias_slp());
507
508 rtc_cntl.bias_conf().modify(|_, w| {
509 w.dbg_atten_monitor()
510 .bits(RTC_CNTL_DBG_ATTEN_MONITOR_DEFAULT);
511 w.bias_sleep_monitor().bit(RTC_CNTL_BIASSLP_MONITOR_DEFAULT);
514 w.pd_cur_monitor().bit(RTC_CNTL_PD_CUR_MONITOR_DEFAULT)
515 });
516
517 rtc_cntl.bias_conf().modify(|_, w| {
518 w.dbg_atten_deep_slp().bits(dbg_atten_slp);
519 w.bias_sleep_deep_slp().bit(bias_sleep_slp);
520 w.pd_cur_deep_slp().bit(pd_cur_slp)
521 });
522
523 if self.deep_slp() {
524 regi2c::I2C_ULP_IR_FORCE_XPD_CK.write_field(0);
525
526 rtc_cntl
527 .dig_pwc()
528 .modify(|_, w| w.dg_wrap_pd_en().set_bit());
529
530 rtc_cntl.ana_conf().modify(|_, w| {
531 w.ckgen_i2c_pu().clear_bit();
532 w.pll_i2c_pu().clear_bit();
533 w.rfrx_pbus_pu().clear_bit();
534 w.txrf_i2c_pu().clear_bit()
535 });
536
537 rtc_cntl
538 .options0()
539 .modify(|_, w| w.bb_i2c_force_pu().clear_bit());
540 } else {
541 rtc_cntl.bias_conf().modify(|_, w| {
542 w.dg_vdd_drv_b_slp_en().set_bit();
543 w.dg_vdd_drv_b_slp().bits(RTC_CNTL_DG_VDD_DRV_B_SLP_DEFAULT)
544 });
545
546 rtc_cntl
547 .dig_pwc()
548 .modify(|_, w| w.dg_wrap_pd_en().clear_bit());
549 }
550
551 rtc_cntl
552 .rtc_cntl()
553 .modify(|_, w| w.regulator_force_pu().bit(self.rtc_regulator_fpu()));
554
555 rtc_cntl.clk_conf().modify(|_, w| {
556 w.ck8m_force_pu().bit(!self.int_8m_pd_en());
557 w.ck8m_force_nogating().bit(!self.int_8m_pd_en())
558 });
559
560 rtc_cntl.dig_pwc().modify(|_, w| {
563 w.vdd_spi_pwr_force().clear_bit();
564 w.vdd_spi_pd_en().bit(self.vddsdio_pd_en())
565 });
566
567 rtc_cntl.slp_reject_conf().modify(|_, w| {
568 w.deep_slp_reject_en().bit(self.deep_slp_reject());
569 w.light_slp_reject_en().bit(self.light_slp_reject())
570 });
571
572 rtc_cntl
573 .options0()
574 .modify(|_, w| w.xtl_force_pu().bit(self.xtal_fpu()));
575
576 rtc_cntl
577 .clk_conf()
578 .modify(|_, w| w.xtal_global_force_nogating().bit(self.xtal_fpu()));
579 }
580 }
581
582 #[crate::ram]
587 pub(crate) fn start_sleep(&self, wakeup_mask: u32, reject_mask: u32) -> SavedState {
588 let cpu_clk = super::SleepCpuClock::switch_to_xtal();
589
590 LPWR::regs()
592 .wakeup_state()
593 .modify(|_, w| unsafe { w.wakeup_ena().bits(wakeup_mask) });
594
595 LPWR::regs()
598 .slp_reject_conf()
599 .modify(|_, w| unsafe { w.sleep_reject_ena().bits(reject_mask) });
600
601 SavedState { cpu_clk }
602 }
603
604 #[inline(always)]
608 pub(crate) fn enter_sleep(&self) -> bool {
609 LPWR::regs().state0().modify(|_, w| w.sleep_en().set_bit());
610 super::wait_for_sleep_result()
611 }
612
613 pub(crate) fn finish_sleep(&self) {
614 LPWR::regs().int_clr().write(|w| {
617 w.slp_reject().clear_bit_by_one();
618 w.slp_wakeup().clear_bit_by_one()
619 });
620
621 if self.lslp_mem_inf_fpu() {
623 rtc_sleep_pu(true);
624 }
625 }
626}
627
628#[must_use]
630pub(crate) struct SavedState {
631 cpu_clk: super::SleepCpuClock,
632}
633
634impl SavedState {
635 pub(crate) fn restore(self) {
637 self.cpu_clk.restore();
638 }
639}