wehub-resource-sync
362 lines
12 KiB
C
362 lines
12 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
* NOTICE
|
|
* The hal is not public api, don't use in application code.
|
|
* See readme.md in hal/include/hal/readme.md
|
|
******************************************************************************/
|
|
|
|
// The HAL layer for RTC IO master (common part)
|
|
|
|
#pragma once
|
|
|
|
#include <esp_err.h>
|
|
|
|
#include "soc/soc_caps.h"
|
|
#if SOC_RTCIO_PIN_COUNT > 0
|
|
#include "hal/rtc_io_periph.h"
|
|
#include "hal/rtc_io_ll.h"
|
|
#if SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
|
|
#include "hal/rtc_io_types.h"
|
|
#endif
|
|
#endif //SOC_RTCIO_PIN_COUNT > 0
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if SOC_RTCIO_PIN_COUNT > 0
|
|
|
|
#if SOC_LP_IO_CLOCK_IS_INDEPENDENT
|
|
/**
|
|
* Enable rtcio module clock.
|
|
*
|
|
* @param enable True to enable the clock, false to disable.
|
|
*/
|
|
#define rtcio_hal_enable_io_clock(enable) rtcio_ll_enable_io_clock(enable)
|
|
#endif
|
|
|
|
/**
|
|
* Select the rtcio function.
|
|
*
|
|
* @note The RTC function must be selected before the pad analog function is enabled.
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param func Select pin function.
|
|
*/
|
|
#define rtcio_hal_function_select(rtcio_num, func) rtcio_ll_function_select(rtcio_num, func)
|
|
|
|
#if SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
|
|
/**
|
|
* Enable rtcio output.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_output_enable(rtcio_num) rtcio_ll_output_enable(rtcio_num)
|
|
|
|
/**
|
|
* Disable rtcio output.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_output_disable(rtcio_num) rtcio_ll_output_disable(rtcio_num)
|
|
|
|
/**
|
|
* Enable rtcio input.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_input_enable(rtcio_num) rtcio_ll_input_enable(rtcio_num)
|
|
|
|
/**
|
|
* Disable rtcio input.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_input_disable(rtcio_num) rtcio_ll_input_disable(rtcio_num)
|
|
|
|
/**
|
|
* @brief Set RTC GPIO pad drive capability.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param strength Drive capability of the pad. Range: 0 ~ 3.
|
|
*/
|
|
#define rtcio_hal_set_drive_capability(rtcio_num, strength) rtcio_ll_set_drive_capability(rtcio_num, strength)
|
|
|
|
/**
|
|
* @brief Get RTC GPIO pad drive capability.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @return Drive capability of the pad. Range: 0 ~ 3.
|
|
*/
|
|
#define rtcio_hal_get_drive_capability(rtcio_num) rtcio_ll_get_drive_capability(rtcio_num)
|
|
|
|
/**
|
|
* Set RTCIO output level.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param level 0: output low; ~0: output high.
|
|
*/
|
|
#define rtcio_hal_set_level(rtcio_num, level) rtcio_ll_set_level(rtcio_num, level)
|
|
|
|
/**
|
|
* Get RTCIO input level.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @return 0: input low; ~0: input high.
|
|
*/
|
|
#define rtcio_hal_get_level(rtcio_num) rtcio_ll_get_level(rtcio_num)
|
|
|
|
/**
|
|
* Set RTC IO direction.
|
|
*
|
|
* Configure RTC IO direction, such as output only, input only,
|
|
* output and input.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param mode IO direction.
|
|
*/
|
|
void rtcio_hal_set_direction(int rtcio_num, rtc_gpio_mode_t mode);
|
|
|
|
/**
|
|
* Set RTC IO direction in deep sleep or disable sleep status.
|
|
*
|
|
* NOTE: ESP32 supports INPUT_ONLY mode.
|
|
* The rest targets support INPUT_ONLY, OUTPUT_ONLY, INPUT_OUTPUT mode.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param mode IO direction.
|
|
*/
|
|
void rtcio_hal_set_direction_in_sleep(int rtcio_num, rtc_gpio_mode_t mode);
|
|
|
|
/**
|
|
* RTC GPIO pullup enable.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_pullup_enable(rtcio_num) rtcio_ll_pullup_enable(rtcio_num)
|
|
|
|
/**
|
|
* RTC GPIO pullup disable.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_pullup_disable(rtcio_num) rtcio_ll_pullup_disable(rtcio_num)
|
|
|
|
/**
|
|
* @brief Get RTC GPIO pad pullup status.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @return Whether the pullup of the pad is enabled or not.
|
|
*/
|
|
#define rtcio_hal_is_pullup_enabled(rtcio_num) rtcio_ll_is_pullup_enabled(rtcio_num)
|
|
|
|
/**
|
|
* RTC GPIO pulldown enable.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_pulldown_enable(rtcio_num) rtcio_ll_pulldown_enable(rtcio_num)
|
|
|
|
/**
|
|
* RTC GPIO pulldown disable.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_pulldown_disable(rtcio_num) rtcio_ll_pulldown_disable(rtcio_num)
|
|
|
|
/**
|
|
* @brief Get RTC GPIO pad pulldown status.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @return Whether the pulldown of the pad is enabled or not.
|
|
*/
|
|
#define rtcio_hal_is_pulldown_enabled(rtcio_num) rtcio_ll_is_pulldown_enabled(rtcio_num)
|
|
|
|
/**
|
|
* Select a RTC IOMUX function for the RTC IO
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param func Function to assign to the pin
|
|
*/
|
|
#define rtcio_hal_iomux_func_sel(rtcio_num, func) rtcio_ll_iomux_func_sel(rtcio_num, func)
|
|
|
|
/**
|
|
* @brief Set pad input to an LP peripheral signal through the LP(RTC) IOMUX
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param func The index number of the IOMUX function to be selected for the pin.
|
|
* @param signal_idx Peripheral signal index to input. One of the ``*_IN_IDX`` signals in ``soc/lp_gpio_sig_map.h``.
|
|
*/
|
|
void rtcio_hal_iomux_input(int rtcio_num, int func, uint32_t signal_idx);
|
|
|
|
/**
|
|
* @brief Set LP peripheral output to an RTC IO pad through the LP(RTC) IOMUX
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param func The index number of the LP(RTC) IOMUX function to be selected for the pin
|
|
*/
|
|
void rtcio_hal_iomux_output(int rtcio_num, int func);
|
|
|
|
#if SOC_LP_GPIO_MATRIX_SUPPORTED
|
|
/**
|
|
* @brief Set pad input to a LP peripheral signal through the LP GPIO matrix
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param signal_idx LP peripheral signal index.
|
|
* @param inv True to invert input signal; False then no invert.
|
|
*/
|
|
void rtcio_hal_matrix_in(int rtcio_num, uint32_t signal_idx, bool inv);
|
|
|
|
/**
|
|
* @brief Set LP peripheral output to an RTC IO pad through the LP GPIO matrix
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param signal_idx LP peripheral signal index.
|
|
* @param out_inv True to invert output signal; False then no invert.
|
|
* @param oen_inv True to invert output enable signal; False then no invert.
|
|
*/
|
|
void rtcio_hal_matrix_out(int rtcio_num, uint32_t signal_idx, bool out_inv, bool oen_inv);
|
|
#endif // SOC_LP_GPIO_MATRIX_SUPPORTED
|
|
|
|
#endif // SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
|
|
|
|
#if SOC_RTCIO_HOLD_SUPPORTED
|
|
|
|
/**
|
|
* Enable force hold function on an RTC IO pad.
|
|
*
|
|
* Enabling HOLD function will cause the pad to lock current status, such as,
|
|
* input/output enable, input/output value, function, drive strength values.
|
|
* This function is useful when going into light or deep sleep mode to prevent
|
|
* the pin configuration from changing.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_hold_enable(rtcio_num) rtcio_ll_force_hold_enable(rtcio_num)
|
|
|
|
/**
|
|
* Disable hold function on an RTC IO pad.
|
|
*
|
|
* @note If disable the pad hold, the status of pad maybe changed in sleep mode.
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_hold_disable(rtcio_num) rtcio_ll_force_hold_disable(rtcio_num)
|
|
|
|
/**
|
|
* Enable force hold function on all RTC IO pads.
|
|
*
|
|
* Enabling HOLD function will cause the pad to lock current status, such as,
|
|
* input/output enable, input/output value, function, drive strength values.
|
|
* This function is useful when going into light or deep sleep mode to prevent
|
|
* the pin configuration from changing.
|
|
*/
|
|
#define rtcio_hal_hold_all() rtcio_ll_force_hold_all()
|
|
|
|
/**
|
|
* Disable hold function on all RTC IO pads.
|
|
*
|
|
* @note If disable the pad hold, the status of pad maybe changed in sleep mode.
|
|
*/
|
|
#define rtcio_hal_unhold_all() rtcio_ll_force_unhold_all()
|
|
#endif // SOC_RTCIO_HOLD_SUPPORTED
|
|
|
|
#if SOC_RTCIO_WAKE_SUPPORTED
|
|
|
|
/**
|
|
* Enable wakeup function and set wakeup type from light sleep status for rtcio.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param type Wakeup on high level or low level.
|
|
*/
|
|
#define rtcio_hal_wakeup_enable(rtcio_num, type) rtcio_ll_wakeup_enable(rtcio_num, type)
|
|
|
|
/**
|
|
* Disable wakeup function from light sleep status for rtcio.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_wakeup_disable(rtcio_num) rtcio_ll_wakeup_disable(rtcio_num)
|
|
|
|
/**
|
|
* Set specific logic level on an RTC IO pin as a ext0 wakeup trigger.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @param level Logic level (0: low level trigger, 1: high level trigger)
|
|
*/
|
|
#define rtcio_hal_ext0_set_wakeup_pin(rtcio_num, level) rtcio_ll_ext0_set_wakeup_pin(rtcio_num, level)
|
|
|
|
#endif
|
|
|
|
#if SOC_RTCIO_HOLD_SUPPORTED && SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
|
|
|
|
/**
|
|
* Helper function to disconnect internal circuits from an RTC IO
|
|
* This function disables input, output, pullup, pulldown, and enables
|
|
* hold feature for an RTC IO.
|
|
* Use this function if an RTC IO needs to be disconnected from internal
|
|
* circuits in deep sleep, to minimize leakage current.
|
|
*
|
|
* In particular, for ESP32-WROVER module, call
|
|
* rtc_gpio_isolate(GPIO_NUM_12) before entering deep sleep, to reduce
|
|
* deep sleep current.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
void rtcio_hal_isolate(int rtcio_num);
|
|
|
|
#endif
|
|
|
|
#endif //SOC_RTCIO_PIN_COUNT > 0
|
|
|
|
#if SOC_GPIO_SUPPORT_HP_PERIPH_PD_SLEEP_WAKEUP && (SOC_RTCIO_PIN_COUNT > 0)
|
|
|
|
#define gpio_hal_wakeup_enable_on_hp_periph_powerdown_sleep(hal, gpio_num, intr_type) rtcio_hal_wakeup_enable(rtc_io_num_map[gpio_num], intr_type)
|
|
#define gpio_hal_wakeup_disable_on_hp_periph_powerdown_sleep(hal, gpio_num) rtcio_hal_wakeup_disable(rtc_io_num_map[gpio_num])
|
|
#define gpio_hal_wakeup_is_enabled_on_hp_periph_powerdown_sleep(hal, gpio_num) rtcio_hal_wakeup_is_enabled(rtc_io_num_map[gpio_num])
|
|
#define rtc_hal_gpio_get_wakeup_status() rtcio_hal_get_interrupt_status()
|
|
#define rtc_hal_gpio_clear_wakeup_status() rtcio_hal_clear_interrupt_status()
|
|
|
|
#if SOC_RTC_GPIO_EDGE_WAKEUP_SUPPORTED
|
|
/**
|
|
* @brief Clear the latched edge-wakeup state for a GPIO that is enabled for
|
|
* peripheral-powerdown-sleep wakeup in edge mode.
|
|
*
|
|
* Must be called before entering sleep on every pin configured for posedge/negedge/anyedge
|
|
* wakeup, otherwise a stale latched edge would immediately wake the chip.
|
|
*
|
|
* @param hal Context of the HAL layer (unused, kept for API symmetry).
|
|
* @param gpio_num GPIO number.
|
|
*/
|
|
#define gpio_hal_clear_hp_periph_pd_sleep_edge_wakeup_latch(hal, gpio_num) rtcio_ll_clear_edge_wakeup_latch(rtc_io_num_map[gpio_num])
|
|
#endif //SOC_RTC_GPIO_EDGE_WAKEUP_SUPPORTED
|
|
|
|
/**
|
|
* @brief Get the status of whether an IO is used for sleep wake-up.
|
|
*
|
|
* @param rtcio_num The index of rtcio. 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
* @return True if the pin is enabled to wake up from deep-sleep
|
|
*/
|
|
#define rtcio_hal_wakeup_is_enabled(rtcio_num) rtcio_ll_wakeup_is_enabled(rtcio_num)
|
|
|
|
/**
|
|
* @brief Get the rtc io interrupt status
|
|
*
|
|
* @return bit 0~7 corresponding to 0 ~ SOC_RTCIO_PIN_COUNT.
|
|
*/
|
|
#define rtcio_hal_get_interrupt_status() rtcio_ll_get_interrupt_status()
|
|
|
|
/**
|
|
* @brief Clear all LP IO pads status
|
|
*/
|
|
#define rtcio_hal_clear_interrupt_status() rtcio_ll_clear_interrupt_status()
|
|
|
|
#endif //SOC_GPIO_SUPPORT_HP_PERIPH_PD_SLEEP_WAKEUP && (SOC_RTCIO_PIN_COUNT > 0)
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|