Skip to main content

esp_hal/rtc_cntl/sleep/
esp32c2.rs

1use super::SleepKind;
2use crate::{
3    peripherals::{APB_CTRL, BB, EXTMEM, LPWR, SPI0, SPI1, SYSTEM},
4    rtc_cntl::Rtc,
5    soc::regi2c,
6};
7
8// Approximate mapping of voltages to RTC_CNTL_DBIAS_WAK, RTC_CNTL_DBIAS_SLP,
9// RTC_CNTL_DIG_DBIAS_WAK, RTC_CNTL_DIG_DBIAS_SLP values.
10// Valid if RTC_CNTL_DBG_ATTEN is 0.
11/// Digital bias voltage level of 0.90V.
12pub const RTC_CNTL_DBIAS_0V90: u8 = 13;
13/// Digital bias voltage level of 0.95V.
14pub const RTC_CNTL_DBIAS_0V95: u8 = 16;
15/// Digital bias voltage level of 1.00V.
16pub const RTC_CNTL_DBIAS_1V00: u8 = 18;
17/// Digital bias voltage level of 1.05V.
18pub const RTC_CNTL_DBIAS_1V05: u8 = 20;
19/// Digital bias voltage level of 1.10V.
20pub const RTC_CNTL_DBIAS_1V10: u8 = 23;
21/// Digital bias voltage level of 1.15V.
22pub const RTC_CNTL_DBIAS_1V15: u8 = 25;
23/// Digital bias voltage level of 1.20V.
24pub const RTC_CNTL_DBIAS_1V20: u8 = 28;
25/// Digital bias voltage level of 1.25V.
26pub const RTC_CNTL_DBIAS_1V25: u8 = 30;
27/// Digital bias voltage level of approximately 1.34V.
28pub const RTC_CNTL_DBIAS_1V30: u8 = 31;
29
30/// Default attenuation setting during light sleep, with a voltage drop.
31pub const RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_DEFAULT: u8 = 5;
32/// No attenuation (no voltage drop) during light sleep.
33pub const RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_NODROP: u8 = 0;
34/// Default attenuation setting during deep sleep, with maximum voltage drop.
35pub const RTC_CNTL_DBG_ATTEN_DEEPSLEEP_DEFAULT: u8 = 15;
36/// No attenuation (no voltage drop) during deep sleep.
37pub const RTC_CNTL_DBG_ATTEN_DEEPSLEEP_NODROP: u8 = 0;
38
39/// Default bias setting during sleep mode.
40pub const RTC_CNTL_BIASSLP_SLEEP_DEFAULT: u8 = 1;
41/// Keeps the bias for ultra-low power sleep mode always on.
42pub const RTC_CNTL_BIASSLP_SLEEP_ON: u8 = 0;
43
44/// Default power-down current setting during sleep mode.
45pub const RTC_CNTL_PD_CUR_SLEEP_DEFAULT: u8 = 1;
46/// Keeps the power-down current setting for sleep mode always on.
47pub const RTC_CNTL_PD_CUR_SLEEP_ON: u8 = 0;
48
49/// Default driver bias setting for the digital domain during sleep mode.
50pub const RTC_CNTL_DG_VDD_DRV_B_SLP_DEFAULT: u8 = 254;
51
52/// Default debug attenuation setting for the monitor mode.
53pub const RTC_CNTL_DBG_ATTEN_MONITOR_DEFAULT: u8 = 0;
54/// Default bias setting for sleep mode in the monitor mode.
55pub const RTC_CNTL_BIASSLP_MONITOR_DEFAULT: bool = false;
56/// Default power-down current setting for the monitor mode.
57pub const RTC_CNTL_PD_CUR_MONITOR_DEFAULT: bool = false;
58
59/// Default number of cycles to wait for the PLL buffer to stabilize.
60pub const RTC_CNTL_PLL_BUF_WAIT_DEFAULT: u8 = 20;
61/// Default number of cycles to wait for the XTL buffer to stabilize.
62pub const RTC_CNTL_XTL_BUF_WAIT_DEFAULT: u8 = 100;
63/// Default number of cycles to wait for the internal 8 MHz clock to stabilize.
64pub const RTC_CNTL_CK8M_WAIT_DEFAULT: u8 = 20;
65/// Default number of cycles required to enable the internal 8 MHz clock.
66pub const RTC_CK8M_ENABLE_WAIT_DEFAULT: u8 = 5;
67
68/// Minimum number of cycles for sleep duration.
69pub const RTC_CNTL_MIN_SLP_VAL_MIN: u8 = 2;
70
71/// Power-up cycles for other hardware blocks.
72pub const OTHER_BLOCKS_POWERUP: u8 = 1;
73/// Waits cycles for other hardware blocks to stabilize.
74pub const OTHER_BLOCKS_WAIT: u16 = 1;
75
76/// Disables GPIO interrupt.
77pub const GPIO_INTR_DISABLE: u8 = 0;
78/// Sets GPIO interrupt to trigger on a low level signal.
79pub const GPIO_INTR_LOW_LEVEL: u8 = 4;
80/// Sets GPIO interrupt to trigger on a high level signal.
81pub const GPIO_INTR_HIGH_LEVEL: u8 = 5;
82
83/// Specifies the function configuration for GPIO pins.
84pub const PIN_FUNC_GPIO: u8 = 1;
85/// Index for signaling GPIO output.
86pub const SIG_GPIO_OUT_IDX: u32 = 128;
87/// Maximum number of GPIO pins supported.
88pub const GPIO_NUM_MAX: usize = 22;
89
90bitfield::bitfield! {
91    #[derive(Clone, Copy)]
92    /// RTC Configuration.
93    pub struct RtcConfig(u32);
94    impl Debug;
95    /// Number of rtc_fast_clk cycles to wait for 8M clock to be ready
96    pub u8, ck8m_wait, set_ck8m_wait: 7, 0;
97    /// Number of rtc_fast_clk cycles to wait for XTAL clock to be ready
98    pub u8, xtal_wait, set_xtal_wait: 15, 8;
99    /// Number of rtc_fast_clk cycles to wait for PLL clock to be ready
100    pub u8, pll_wait, set_pll_wait: 23, 16;
101    /// Performs clock control related initialization.
102    pub clkctl_init, set_clkctl_init: 24;
103    /// Performs power control related initialization.
104    pub pwrctl_init, set_pwrctl_init: 25;
105    /// Forces power-down of RTC_DBOOST.
106    pub rtc_dboost_fpd, set_rtc_dboost_fpd: 26;
107    /// Keeps the XTAL oscillator powered up in sleep.
108    pub xtal_fpu, set_xtal_fpu: 27;
109    /// Keeps the BBPLL oscillator powered up in sleep.
110    pub bbpll_fpu, set_bbpll_fpu: 28;
111    /// Enables clock gating when the CPU is in wait-for-interrupt state.
112    pub cpu_waiti_clk_gate, set_cpu_waiti_clk_gate: 29;
113    /// Calibrates Ocode to make bandgap voltage more precise.
114    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    /// Configuration for RTC initialization.
134    pub struct RtcInitConfig(u128);
135    impl Debug;
136    /// Number of cycles required to power up WiFi
137    pub u8, wifi_powerup_cycles, set_wifi_powerup_cycles: 6, 0;
138    /// Number of wait cycles for WiFi to stabilize
139    pub u16, wifi_wait_cycles, set_wifi_wait_cycles: 15, 7;
140    /// Number of cycles required to power up Bluetooth
141    pub u8, bt_powerup_cycles, set_bt_powerup_cycles: 22, 16;
142    /// Number of wait cycles for Bluetooth to stabilize
143    pub u16, bt_wait_cycles, set_bt_wait_cycles: 31, 23;
144    /// Number of cycles required to power up the top CPU
145    pub u8, cpu_top_powerup_cycles, set_cpu_top_powerup_cycles: 38, 32;
146    /// Number of wait cycles for the top CPU to stabilize
147    pub u16, cpu_top_wait_cycles, set_cpu_top_wait_cycles: 47, 39;
148    /// Number of cycles required to power up the digital wrapper
149    pub u8, dg_wrap_powerup_cycles, set_dg_wrap_powerup_cycles: 54, 48;
150    /// Number of wait cycles for the digital wrapper to stabilize
151    pub u16, dg_wrap_wait_cycles, set_dg_wrap_wait_cycles: 63, 55;
152    /// Number of cycles required to power up the digital peripherals
153    pub u8, dg_peri_powerup_cycles, set_dg_peri_powerup_cycles: 70, 64;
154    /// Number of wait cycles for the digital peripherals to stabilize
155    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    /// Configuration for RTC sleep mode.
178    pub struct RtcSleepConfig(u64);
179    impl Debug;
180    /// force normal voltage in sleep mode (digital domain memory)
181    pub lslp_mem_inf_fpu, set_lslp_mem_inf_fpu: 0;
182    /// keep low voltage in sleep mode (even if ULP/touch is used)
183    pub rtc_mem_inf_follow_cpu, set_rtc_mem_inf_follow_cpu: 1;
184    /// power down RTC fast memory
185    pub rtc_fastmem_pd_en, set_rtc_fastmem_pd_en: 2;
186    /// power down RTC slow memory
187    pub rtc_slowmem_pd_en, set_rtc_slowmem_pd_en: 3;
188    /// power down RTC peripherals
189    pub rtc_peri_pd_en, set_rtc_peri_pd_en: 4;
190    /// power down WiFi
191    pub wifi_pd_en, set_wifi_pd_en: 5;
192    /// power down BT
193    pub bt_pd_en, set_bt_pd_en: 6;
194    /// Powers down Internal 8M oscillator.
195    pub int_8m_pd_en, set_int_8m_pd_en: 8;
196    /// power down digital peripherals
197    pub dig_peri_pd_en, set_dig_peri_pd_en: 9;
198    /// power down digital domain
199    pub deep_slp, set_deep_slp: 10;
200    /// enable WDT flashboot mode
201    pub wdt_flashboot_mod_en, set_wdt_flashboot_mod_en: 11;
202    /// set bias for digital domain, in sleep mode
203    pub u8, dig_dbias_slp, set_dig_dbias_slp: 16, 12;
204    /// set bias for RTC domain, in sleep mode
205    pub u8, rtc_dbias_slp, set_rtc_dbias_slp: 21, 17;
206    /// voltage parameter, in sleep mode
207    pub u8, dbg_atten_slp, set_dbg_atten_slp: 25, 22;
208    /// circuit control parameter, in monitor mode
209    pub bias_sleep_monitor, set_bias_sleep_monitor: 26;
210    /// circuit control parameter, in sleep mode
211    pub bias_sleep_slp, set_bias_sleep_slp: 27;
212    /// circuit control parameter, in monitor mode
213    pub pd_cur_slp, set_pd_cur_slp: 28;
214    /// power down VDDSDIO regulator
215    pub vddsdio_pd_en, set_vddsdio_pd_en: 29;
216    /// keep main XTAL powered up in sleep
217    pub xtal_fpu, set_xtal_fpu: 30;
218    /// keep rtc regulator powered up in sleep
219    pub rtc_regulator_fpu, set_rtc_regulator_fpu: 31;
220    /// enable deep sleep reject
221    pub deep_slp_reject, set_deep_slp_reject: 32;
222    /// enable light sleep reject
223    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        // This is the light-sleep config. The main XTAL is powered down in sleep
235        // (`xtal_fpu` stays false), so the analog regulator/bias must use the
236        // same XTAL-down settings that `deep()` applies "because of xtal_fpu".
237        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    /// Configures the RTC for deep sleep mode.
312    ///
313    /// The RTC regulator is off in this mode, for the lowest current.
314    pub fn deep() -> Self {
315        // Set up for ultra-low power sleep. Wakeup sources may modify these settings. ESP-IDF
316        // uses this mode only on request, and does not support RTC IO inputs in it:
317        // https://github.com/espressif/esp-idf/blob/fff9895c82d/components/esp_hw_support/sleep_modes.c#L3083-L3085
318        // https://github.com/espressif/esp-idf/blob/fff9895c82d/components/esp_hw_support/port/esp32c2/rtc_sleep.c#L91-L101
319        let mut cfg = Self::default();
320
321        cfg.set_lslp_mem_inf_fpu(false);
322        cfg.set_rtc_mem_inf_follow_cpu(true); // ?
323        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); // because of dig_peri_pd_en
332
333        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        // because of dig_peri_pd_en
342        cfg.set_rtc_regulator_fpu(false);
343        cfg.set_dbg_atten_slp(RTC_CNTL_DBG_ATTEN_DEEPSLEEP_DEFAULT);
344
345        // because of xtal_fpu
346        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        // settings derived from esp_clk_init -> rtc_init
365        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            // Moved from rtc sleep to rtc init to save sleep function running time
379            // set shortest possible sleep time limit
380
381            rtc_cntl
382                .timer5()
383                .modify(|_, w| w.min_slp_val().bits(RTC_CNTL_MIN_SLP_VAL_MIN));
384
385            // TODO: something about cali_ocode
386
387            // Reset RTC bias to default value (needed if waking up from deep sleep)
388            regi2c::I2C_DIG_REG_EXT_RTC_DREG_SLEEP.write_field(RTC_CNTL_DBIAS_1V10);
389
390            // LDO dbias initialization
391            // TODO: this modifies g_rtc_dbias_pvt_non_240m and g_dig_dbias_pvt_non_240m.
392            //       We're using a high enough default but we should read from the efuse.
393            // set_rtc_dig_dbias();
394
395            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                // clear CMMU clock force on
400
401                extmem
402                    .cache_mmu_power_ctrl()
403                    .modify(|_, w| w.cache_mmu_mem_force_on().clear_bit());
404                // clear tag clock force on
405
406                extmem
407                    .icache_tag_power_ctrl()
408                    .modify(|_, w| w.icache_tag_mem_force_on().clear_bit());
409
410                // clear register clock force on
411                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                // cancel bbpll force pu if setting no force power up
429
430                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                // If this mask is enabled, all soc memories cannot enter power down mode
441                // We should control soc memory power down mode from RTC, so we will not touch
442                // this register any more
443
444                system
445                    .mem_pd_mask()
446                    .modify(|_, w| w.lslp_mem_pd_mask().clear_bit());
447
448                // If this pd_cfg is set to 1, all memory won't enter low power mode during
449                // light sleep If this pd_cfg is set to 0, all memory will enter low
450                // power mode during light sleep
451                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                // if SYSTEM_CPU_WAIT_MODE_FORCE_ON == 0 , the cpu clk will be closed when cpu
462                // enter WAITI mode
463
464                system
465                    .cpu_per_conf()
466                    .modify(|_, w| w.cpu_wait_mode_force_on().bit(!cfg.cpu_waiti_clk_gate()));
467
468                // cancel digital PADS force no iso
469
470                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        // like esp-idf rtc_sleep_init()
485        let rtc_cntl = LPWR::regs();
486
487        if self.lslp_mem_inf_fpu() {
488            rtc_sleep_pu(true);
489        }
490
491        unsafe {
492            // Like `rtc_sleep_get_default_config`: a crystal that stays on through a light sleep
493            // needs the bias current and the voltage of the active mode.
494            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                // We have config values for this in self, so I don't know why we're setting
512                // hardcoded defaults for these next two. It's what IDF does...
513                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            // enable VDDSDIO control by state machine
561
562            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    /// Configures the wakeup and reject sources of the sleep.
583    ///
584    /// [`Self::enter_sleep`] requests the sleep after this call. The caller calls
585    /// [`SavedState::restore`] on the return value after [`Self::finish_sleep`].
586    #[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        // set bits for what can wake us up
591        LPWR::regs()
592            .wakeup_state()
593            .modify(|_, w| unsafe { w.wakeup_ena().bits(wakeup_mask) });
594
595        // Set the bits of the sources that reject the sleep. The reject enables that `apply` wrote
596        // arm those sources.
597        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    /// Requests the sleep.
605    ///
606    /// The caller waits for the result of the request.
607    #[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        // In deep sleep mode, we never get here
615
616        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        // restore config if it is a light sleep
622        if self.lslp_mem_inf_fpu() {
623            rtc_sleep_pu(true);
624        }
625    }
626}
627
628/// The state that [`RtcSleepConfig::start_sleep`] changes for the length of the sleep.
629#[must_use]
630pub(crate) struct SavedState {
631    cpu_clk: super::SleepCpuClock,
632}
633
634impl SavedState {
635    /// Restores the state. Runs after a wakeup and after a rejected sleep.
636    pub(crate) fn restore(self) {
637        self.cpu_clk.restore();
638    }
639}