| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
 | 
					
						
							|  |  |  | //
 | 
					
						
							|  |  |  | // Licensed under the Apache License, Version 2.0 (the "License");
 | 
					
						
							|  |  |  | // you may not use this file except in compliance with the License.
 | 
					
						
							|  |  |  | // You may obtain a copy of the License at
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | //     http://www.apache.org/licenses/LICENSE-2.0
 | 
					
						
							|  |  |  | //
 | 
					
						
							|  |  |  | // Unless required by applicable law or agreed to in writing, software
 | 
					
						
							|  |  |  | // distributed under the License is distributed on an "AS IS" BASIS,
 | 
					
						
							|  |  |  | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 | 
					
						
							|  |  |  | // See the License for the specific language governing permissions and
 | 
					
						
							|  |  |  | // limitations under the License.
 | 
					
						
							|  |  |  | #include <esp_types.h>
 | 
					
						
							|  |  |  | #include "esp_err.h"
 | 
					
						
							|  |  |  | #include "freertos/FreeRTOS.h"
 | 
					
						
							|  |  |  | #include "freertos/xtensa_api.h"
 | 
					
						
							|  |  |  | #include "driver/gpio.h"
 | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  | #include "driver/rtc_io.h"
 | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | #include "soc/soc.h"
 | 
					
						
							| 
									
										
										
										
											2018-06-13 09:52:44 +05:00
										 |  |  | #include "soc/gpio_periph.h"
 | 
					
						
							| 
									
										
										
										
											2019-05-13 18:02:45 +08:00
										 |  |  | #include "esp_log.h"
 | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-07 12:01:30 +08:00
										 |  |  | static const char* GPIO_TAG = "gpio"; | 
					
						
							|  |  |  | #define GPIO_CHECK(a, str, ret_val) \
 | 
					
						
							|  |  |  |     if (!(a)) { \ | 
					
						
							|  |  |  |         ESP_LOGE(GPIO_TAG,"%s(%d): %s", __FUNCTION__, __LINE__, str); \ | 
					
						
							|  |  |  |         return (ret_val); \ | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | typedef struct { | 
					
						
							|  |  |  |     gpio_isr_t fn;   /*!< isr function */ | 
					
						
							|  |  |  |     void* args;      /*!< isr function args */ | 
					
						
							|  |  |  | } gpio_isr_func_t; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static gpio_isr_func_t* gpio_isr_func = NULL; | 
					
						
							|  |  |  | static gpio_isr_handle_t gpio_isr_handle; | 
					
						
							|  |  |  | static portMUX_TYPE gpio_spinlock = portMUX_INITIALIZER_UNLOCKED; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_pullup_en(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         rtc_gpio_pullup_en(gpio_num); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     } else { | 
					
						
							| 
									
										
										
										
											2016-12-08 22:22:10 +08:00
										 |  |  |         REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU); | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | esp_err_t gpio_pullup_dis(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         rtc_gpio_pullup_dis(gpio_num); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     } else { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         REG_CLR_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU); | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | esp_err_t gpio_pulldown_en(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         rtc_gpio_pulldown_en(gpio_num); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     } else { | 
					
						
							|  |  |  |         REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD); | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | esp_err_t gpio_pulldown_dis(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							|  |  |  |         rtc_gpio_pulldown_dis(gpio_num); | 
					
						
							|  |  |  |     } else { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         REG_CLR_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD); | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-11-15 10:29:52 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  |     GPIO_CHECK(intr_type < GPIO_INTR_MAX, "GPIO interrupt type error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     GPIO.pin[gpio_num].int_type = intr_type; | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2018-06-04 10:34:23 +08:00
										 |  |  | static void gpio_intr_status_clr(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     if (gpio_num < 32) { | 
					
						
							|  |  |  |         GPIO.status_w1tc = BIT(gpio_num); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         GPIO.status1_w1tc.intr_st = BIT(gpio_num - 32); | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2017-01-19 23:46:41 +11:00
										 |  |  | static esp_err_t gpio_intr_enable_on_core (gpio_num_t gpio_num, uint32_t core_id) | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2018-06-04 10:34:23 +08:00
										 |  |  |     gpio_intr_status_clr(gpio_num); | 
					
						
							| 
									
										
										
										
											2017-01-19 23:46:41 +11:00
										 |  |  |     if (core_id == 0) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA;     //enable pro cpu intr
 | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         GPIO.pin[gpio_num].int_ena = GPIO_APP_CPU_INTR_ENA;     //enable pro cpu intr
 | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2017-01-19 23:46:41 +11:00
										 |  |  | esp_err_t gpio_intr_enable(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     return gpio_intr_enable_on_core (gpio_num, xPortGetCoreID()); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | esp_err_t gpio_intr_disable(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     GPIO.pin[gpio_num].int_ena = 0;                             //disable GPIO intr
 | 
					
						
							| 
									
										
										
										
											2018-06-04 10:34:23 +08:00
										 |  |  |     gpio_intr_status_clr(gpio_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static esp_err_t gpio_output_disable(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (gpio_num < 32) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         GPIO.enable_w1tc = (0x1 << gpio_num); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         GPIO.enable1_w1tc.data = (0x1 << (gpio_num - 32)); | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2017-06-26 12:41:40 +10:00
										 |  |  | 
 | 
					
						
							|  |  |  |     // Ensure no other output signal is routed via GPIO matrix to this pin
 | 
					
						
							|  |  |  |     REG_WRITE(GPIO_FUNC0_OUT_SEL_CFG_REG + (gpio_num * 4), | 
					
						
							|  |  |  |               SIG_GPIO_OUT_IDX); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static esp_err_t gpio_output_enable(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (gpio_num < 32) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         GPIO.enable_w1ts = (0x1 << gpio_num); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         GPIO.enable1_w1ts.data = (0x1 << (gpio_num - 32)); | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2017-06-26 12:41:40 +10:00
										 |  |  |     gpio_matrix_out(gpio_num, SIG_GPIO_OUT_IDX, false, false); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-12-22 13:05:19 +11:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (level) { | 
					
						
							|  |  |  |         if (gpio_num < 32) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             GPIO.out_w1ts = (1 << gpio_num); | 
					
						
							|  |  |  |         } else { | 
					
						
							|  |  |  |             GPIO.out1_w1ts.data = (1 << (gpio_num - 32)); | 
					
						
							|  |  |  |         } | 
					
						
							|  |  |  |     } else { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         if (gpio_num < 32) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             GPIO.out_w1tc = (1 << gpio_num); | 
					
						
							|  |  |  |         } else { | 
					
						
							|  |  |  |             GPIO.out1_w1tc.data = (1 << (gpio_num - 32)); | 
					
						
							|  |  |  |         } | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | int gpio_get_level(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (gpio_num < 32) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         return (GPIO.in >> gpio_num) & 0x1; | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         return (GPIO.in1.data >> (gpio_num - 32)) & 0x1; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  |     GPIO_CHECK(pull <= GPIO_FLOATING, "GPIO pull mode error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     esp_err_t ret = ESP_OK; | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     switch (pull) { | 
					
						
							|  |  |  |     case GPIO_PULLUP_ONLY: | 
					
						
							|  |  |  |         gpio_pulldown_dis(gpio_num); | 
					
						
							|  |  |  |         gpio_pullup_en(gpio_num); | 
					
						
							|  |  |  |         break; | 
					
						
							|  |  |  |     case GPIO_PULLDOWN_ONLY: | 
					
						
							|  |  |  |         gpio_pulldown_en(gpio_num); | 
					
						
							|  |  |  |         gpio_pullup_dis(gpio_num); | 
					
						
							|  |  |  |         break; | 
					
						
							|  |  |  |     case GPIO_PULLUP_PULLDOWN: | 
					
						
							|  |  |  |         gpio_pulldown_en(gpio_num); | 
					
						
							|  |  |  |         gpio_pullup_en(gpio_num); | 
					
						
							|  |  |  |         break; | 
					
						
							|  |  |  |     case GPIO_FLOATING: | 
					
						
							|  |  |  |         gpio_pulldown_dis(gpio_num); | 
					
						
							|  |  |  |         gpio_pullup_dis(gpio_num); | 
					
						
							|  |  |  |         break; | 
					
						
							|  |  |  |     default: | 
					
						
							|  |  |  |         ESP_LOGE(GPIO_TAG, "Unknown pull up/down mode,gpio_num=%u,pull=%u", gpio_num, pull); | 
					
						
							|  |  |  |         ret = ESP_ERR_INVALID_ARG; | 
					
						
							|  |  |  |         break; | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     } | 
					
						
							|  |  |  |     return ret; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2017-11-21 15:06:32 +08:00
										 |  |  |     if (gpio_num >= 34 && (mode & GPIO_MODE_DEF_OUTPUT)) { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         ESP_LOGE(GPIO_TAG, "io_num=%d can only be input", gpio_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         return ESP_ERR_INVALID_ARG; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     esp_err_t ret = ESP_OK; | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (mode & GPIO_MODE_DEF_INPUT) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_num]); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_num]); | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (mode & GPIO_MODE_DEF_OUTPUT) { | 
					
						
							| 
									
										
										
										
											2017-06-26 12:41:40 +10:00
										 |  |  |         gpio_output_enable(gpio_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     } else { | 
					
						
							| 
									
										
										
										
											2017-06-26 12:41:40 +10:00
										 |  |  |         gpio_output_disable(gpio_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (mode & GPIO_MODE_DEF_OD) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         GPIO.pin[gpio_num].pad_driver = 1; | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         GPIO.pin[gpio_num].pad_driver = 0; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return ret; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2017-04-13 18:33:33 +01:00
										 |  |  | esp_err_t gpio_config(const gpio_config_t *pGPIOConfig) | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | { | 
					
						
							|  |  |  |     uint64_t gpio_pin_mask = (pGPIOConfig->pin_bit_mask); | 
					
						
							|  |  |  |     uint32_t io_reg = 0; | 
					
						
							|  |  |  |     uint32_t io_num = 0; | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     uint8_t input_en = 0; | 
					
						
							|  |  |  |     uint8_t output_en = 0; | 
					
						
							|  |  |  |     uint8_t od_en = 0; | 
					
						
							|  |  |  |     uint8_t pu_en = 0; | 
					
						
							|  |  |  |     uint8_t pd_en = 0; | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if (pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |         ESP_LOGE(GPIO_TAG, "GPIO_PIN mask error "); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         return ESP_ERR_INVALID_ARG; | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     if ((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         //GPIO 34/35/36/37/38/39 can only be used as input mode;
 | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |         if ((gpio_pin_mask & ( GPIO_SEL_34 | GPIO_SEL_35 | GPIO_SEL_36 | GPIO_SEL_37 | GPIO_SEL_38 | GPIO_SEL_39))) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |             ESP_LOGE(GPIO_TAG, "GPIO34-39 can only be used as input mode"); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             return ESP_ERR_INVALID_ARG; | 
					
						
							|  |  |  |         } | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     do { | 
					
						
							|  |  |  |         io_reg = GPIO_PIN_MUX_REG[io_num]; | 
					
						
							| 
									
										
										
										
											2018-06-04 10:34:23 +08:00
										 |  |  |         if (((gpio_pin_mask >> io_num) & BIT(0))) { | 
					
						
							|  |  |  |             if (!io_reg) { | 
					
						
							|  |  |  |                 ESP_LOGE(GPIO_TAG, "IO%d is not a valid GPIO",io_num); | 
					
						
							|  |  |  |                 return ESP_ERR_INVALID_ARG; | 
					
						
							|  |  |  |             } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |             if(RTC_GPIO_IS_VALID_GPIO(io_num)){ | 
					
						
							|  |  |  |                 rtc_gpio_deinit(io_num); | 
					
						
							|  |  |  |             } | 
					
						
							|  |  |  |             if ((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |                 input_en = 1; | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |                 PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]); | 
					
						
							|  |  |  |             } else { | 
					
						
							|  |  |  |                 PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]); | 
					
						
							|  |  |  |             } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |             if ((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |                 od_en = 1; | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |                 GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */ | 
					
						
							|  |  |  |             } else { | 
					
						
							|  |  |  |                 GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */ | 
					
						
							|  |  |  |             } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |             if ((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |                 output_en = 1; | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |                 gpio_output_enable(io_num); | 
					
						
							|  |  |  |             } else { | 
					
						
							|  |  |  |                 gpio_output_disable(io_num); | 
					
						
							|  |  |  |             } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |             if (pGPIOConfig->pull_up_en) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |                 pu_en = 1; | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |                 gpio_pullup_en(io_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             } else { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |                 gpio_pullup_dis(io_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             } | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |             if (pGPIOConfig->pull_down_en) { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |                 pd_en = 1; | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |                 gpio_pulldown_en(io_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             } else { | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |                 gpio_pulldown_dis(io_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             } | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |             ESP_LOGI(GPIO_TAG, "GPIO[%d]| InputEn: %d| OutputEn: %d| OpenDrain: %d| Pullup: %d| Pulldown: %d| Intr:%d ", io_num, input_en, output_en, od_en, pu_en, pd_en, pGPIOConfig->intr_type); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |             gpio_set_intr_type(io_num, pGPIOConfig->intr_type); | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |             if (pGPIOConfig->intr_type) { | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |                 gpio_intr_enable(io_num); | 
					
						
							|  |  |  |             } else { | 
					
						
							|  |  |  |                 gpio_intr_disable(io_num); | 
					
						
							|  |  |  |             } | 
					
						
							|  |  |  |             PIN_FUNC_SELECT(io_reg, PIN_FUNC_GPIO); /*function number 2 is GPIO_FUNC for each pin */ | 
					
						
							|  |  |  |         } | 
					
						
							|  |  |  |         io_num++; | 
					
						
							| 
									
										
										
										
											2016-12-07 14:18:10 +08:00
										 |  |  |     } while (io_num < GPIO_PIN_COUNT); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2018-06-08 15:33:04 +08:00
										 |  |  | esp_err_t gpio_reset_pin(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     assert(gpio_num >= 0 && GPIO_IS_VALID_GPIO(gpio_num)); | 
					
						
							|  |  |  |     gpio_config_t cfg = { | 
					
						
							| 
									
										
										
										
											2018-08-08 15:31:17 +03:00
										 |  |  |         .pin_bit_mask = BIT64(gpio_num), | 
					
						
							| 
									
										
										
										
											2018-06-08 15:33:04 +08:00
										 |  |  |         .mode = GPIO_MODE_DISABLE, | 
					
						
							|  |  |  |         //for powersave reasons, the GPIO should not be floating, select pullup
 | 
					
						
							|  |  |  |         .pull_up_en = true, | 
					
						
							|  |  |  |         .pull_down_en = false, | 
					
						
							|  |  |  |         .intr_type = GPIO_INTR_DISABLE, | 
					
						
							|  |  |  |     }; | 
					
						
							|  |  |  |     gpio_config(&cfg); | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2018-12-21 14:07:51 +00:00
										 |  |  | static inline void IRAM_ATTR gpio_isr_loop(uint32_t status, const uint32_t gpio_num_start) { | 
					
						
							|  |  |  |     while (status) { | 
					
						
							|  |  |  |         int nbit = __builtin_ffs(status) - 1; | 
					
						
							|  |  |  |         status &= ~(1 << nbit); | 
					
						
							|  |  |  |         int gpio_num = gpio_num_start + nbit; | 
					
						
							|  |  |  |         if (gpio_isr_func[gpio_num].fn != NULL) { | 
					
						
							|  |  |  |             gpio_isr_func[gpio_num].fn(gpio_isr_func[gpio_num].args); | 
					
						
							|  |  |  |         } | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static void IRAM_ATTR gpio_intr_service(void* arg) | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | { | 
					
						
							|  |  |  |     //GPIO intr process
 | 
					
						
							|  |  |  |     if (gpio_isr_func == NULL) { | 
					
						
							|  |  |  |         return; | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2018-12-21 14:07:51 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |     //read status to get interrupt status for GPIO0-31
 | 
					
						
							|  |  |  |     const uint32_t gpio_intr_status = GPIO.status; | 
					
						
							|  |  |  |     if (gpio_intr_status) { | 
					
						
							|  |  |  |         gpio_isr_loop(gpio_intr_status, 0); | 
					
						
							|  |  |  |         GPIO.status_w1tc = gpio_intr_status; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     //read status1 to get interrupt status for GPIO32-39
 | 
					
						
							|  |  |  |     const uint32_t gpio_intr_status_h = GPIO.status1.intr_st; | 
					
						
							|  |  |  |     if (gpio_intr_status_h) { | 
					
						
							|  |  |  |         gpio_isr_loop(gpio_intr_status_h, 32); | 
					
						
							|  |  |  |         GPIO.status1_w1tc.intr_st = gpio_intr_status_h; | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_isr_handler_add(gpio_num_t gpio_num, gpio_isr_t isr_handler, void* args) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO_CHECK(gpio_isr_func != NULL, "GPIO isr service is not installed, call gpio_install_isr_service() first", ESP_ERR_INVALID_STATE); | 
					
						
							|  |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  |     portENTER_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     gpio_intr_disable(gpio_num); | 
					
						
							|  |  |  |     if (gpio_isr_func) { | 
					
						
							|  |  |  |         gpio_isr_func[gpio_num].fn = isr_handler; | 
					
						
							|  |  |  |         gpio_isr_func[gpio_num].args = args; | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2017-01-19 23:46:41 +11:00
										 |  |  |     gpio_intr_enable_on_core (gpio_num, esp_intr_get_cpu(gpio_isr_handle)); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     portEXIT_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_isr_handler_remove(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO_CHECK(gpio_isr_func != NULL, "GPIO isr service is not installed, call gpio_install_isr_service() first", ESP_ERR_INVALID_STATE); | 
					
						
							|  |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  |     portENTER_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     gpio_intr_disable(gpio_num); | 
					
						
							|  |  |  |     if (gpio_isr_func) { | 
					
						
							|  |  |  |         gpio_isr_func[gpio_num].fn = NULL; | 
					
						
							|  |  |  |         gpio_isr_func[gpio_num].args = NULL; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     portEXIT_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_install_isr_service(int intr_alloc_flags) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2018-03-26 10:50:22 +08:00
										 |  |  |     GPIO_CHECK(gpio_isr_func == NULL, "GPIO isr service already installed", ESP_ERR_INVALID_STATE); | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     esp_err_t ret; | 
					
						
							|  |  |  |     portENTER_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     gpio_isr_func = (gpio_isr_func_t*) calloc(GPIO_NUM_MAX, sizeof(gpio_isr_func_t)); | 
					
						
							|  |  |  |     if (gpio_isr_func == NULL) { | 
					
						
							|  |  |  |         ret = ESP_ERR_NO_MEM; | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         ret = gpio_isr_register(gpio_intr_service, NULL, intr_alloc_flags, &gpio_isr_handle); | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     portEXIT_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     return ret; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | void gpio_uninstall_isr_service() | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     if (gpio_isr_func == NULL) { | 
					
						
							|  |  |  |         return; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     portENTER_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     esp_intr_free(gpio_isr_handle); | 
					
						
							|  |  |  |     free(gpio_isr_func); | 
					
						
							|  |  |  |     gpio_isr_func = NULL; | 
					
						
							|  |  |  |     portEXIT_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     return; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-07 21:30:21 +08:00
										 |  |  | esp_err_t gpio_isr_register(void (*fn)(void*), void * arg, int intr_alloc_flags, gpio_isr_handle_t *handle) | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(fn, "GPIO ISR null", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-12-07 21:30:21 +08:00
										 |  |  |     return esp_intr_alloc(ETS_GPIO_INTR_SOURCE, intr_alloc_flags, fn, arg, handle); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     esp_err_t ret = ESP_OK; | 
					
						
							| 
									
										
										
										
											2016-12-24 20:45:57 +08:00
										 |  |  |     if (( intr_type == GPIO_INTR_LOW_LEVEL ) || ( intr_type == GPIO_INTR_HIGH_LEVEL )) { | 
					
						
							| 
									
										
										
										
											2018-08-14 01:57:32 +03:00
										 |  |  |         if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							|  |  |  |             ret = rtc_gpio_wakeup_enable(gpio_num, intr_type); | 
					
						
							|  |  |  |         } else { | 
					
						
							|  |  |  |             GPIO.pin[gpio_num].int_type = intr_type; | 
					
						
							|  |  |  |             GPIO.pin[gpio_num].wakeup_enable = 0x1; | 
					
						
							|  |  |  |         } | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     } else { | 
					
						
							| 
									
										
										
										
											2018-08-14 01:57:32 +03:00
										 |  |  |         ESP_LOGE(GPIO_TAG, "GPIO wakeup only supports level mode, but edge mode set. gpio_num:%u", gpio_num); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |         ret = ESP_ERR_INVALID_ARG; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return ret; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2016-11-07 14:16:52 +08:00
										 |  |  |     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							| 
									
										
										
										
											2016-10-08 14:12:55 +08:00
										 |  |  |     GPIO.pin[gpio_num].wakeup_enable = 0; | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2017-07-17 15:38:19 +08:00
										 |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_set_drive_capability(gpio_num_t gpio_num, gpio_drive_cap_t strength) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  |     GPIO_CHECK(strength < GPIO_DRIVE_CAP_MAX, "GPIO drive capability error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							|  |  |  |         rtc_gpio_set_drive_capability(gpio_num, strength); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         SET_PERI_REG_BITS(GPIO_PIN_MUX_REG[gpio_num], FUN_DRV_V, strength, FUN_DRV_S); | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_get_drive_capability(gpio_num_t gpio_num, gpio_drive_cap_t* strength) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  |     GPIO_CHECK(strength != NULL, "GPIO drive capability pointer error", ESP_ERR_INVALID_ARG); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							|  |  |  |         return rtc_gpio_get_drive_capability(gpio_num, strength); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         *strength = GET_PERI_REG_BITS2(GPIO_PIN_MUX_REG[gpio_num], FUN_DRV_V, FUN_DRV_S); | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return ESP_OK; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2018-04-03 22:09:30 +08:00
										 |  |  | 
 | 
					
						
							|  |  |  | static const uint32_t GPIO_HOLD_MASK[34] = { | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     GPIO_SEL_1, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     GPIO_SEL_0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     GPIO_SEL_8, | 
					
						
							|  |  |  |     GPIO_SEL_2, | 
					
						
							|  |  |  |     GPIO_SEL_3, | 
					
						
							|  |  |  |     GPIO_SEL_4, | 
					
						
							|  |  |  |     GPIO_SEL_5, | 
					
						
							|  |  |  |     GPIO_SEL_6, | 
					
						
							|  |  |  |     GPIO_SEL_7, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     GPIO_SEL_9, | 
					
						
							|  |  |  |     GPIO_SEL_10, | 
					
						
							|  |  |  |     GPIO_SEL_11, | 
					
						
							|  |  |  |     GPIO_SEL_12, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     GPIO_SEL_14, | 
					
						
							|  |  |  |     GPIO_SEL_15, | 
					
						
							|  |  |  |     GPIO_SEL_16, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  |     0, | 
					
						
							|  |  |  | }; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_hold_en(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "Only output-capable GPIO support this function", ESP_ERR_NOT_SUPPORTED); | 
					
						
							|  |  |  |     esp_err_t r = ESP_OK; | 
					
						
							|  |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							|  |  |  |         r = rtc_gpio_hold_en(gpio_num); | 
					
						
							|  |  |  |     } else if (GPIO_HOLD_MASK[gpio_num]) { | 
					
						
							|  |  |  |         SET_PERI_REG_MASK(RTC_IO_DIG_PAD_HOLD_REG, GPIO_HOLD_MASK[gpio_num]); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         r = ESP_ERR_NOT_SUPPORTED; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return r == ESP_OK ? ESP_OK : ESP_ERR_NOT_SUPPORTED; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | esp_err_t gpio_hold_dis(gpio_num_t gpio_num) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "Only output-capable GPIO support this function", ESP_ERR_NOT_SUPPORTED); | 
					
						
							|  |  |  |     esp_err_t r = ESP_OK; | 
					
						
							|  |  |  |     if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) { | 
					
						
							|  |  |  |         r = rtc_gpio_hold_dis(gpio_num); | 
					
						
							|  |  |  |     } else if (GPIO_HOLD_MASK[gpio_num]) { | 
					
						
							|  |  |  |         CLEAR_PERI_REG_MASK(RTC_IO_DIG_PAD_HOLD_REG, GPIO_HOLD_MASK[gpio_num]); | 
					
						
							|  |  |  |     } else { | 
					
						
							|  |  |  |         r = ESP_ERR_NOT_SUPPORTED; | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     return r == ESP_OK ? ESP_OK : ESP_ERR_NOT_SUPPORTED; | 
					
						
							| 
									
										
										
										
											2018-04-24 01:23:12 +08:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2018-12-07 21:44:43 +08:00
										 |  |  | void gpio_deep_sleep_hold_en(void) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     portENTER_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     SET_PERI_REG_MASK(RTC_CNTL_DIG_ISO_REG, RTC_CNTL_DG_PAD_AUTOHOLD_EN_M); | 
					
						
							|  |  |  |     portEXIT_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | void gpio_deep_sleep_hold_dis(void) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     portENTER_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  |     CLEAR_PERI_REG_MASK(RTC_CNTL_DIG_ISO_REG, RTC_CNTL_DG_PAD_AUTOHOLD_EN_M); | 
					
						
							|  |  |  |     portEXIT_CRITICAL(&gpio_spinlock); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2018-04-24 01:23:12 +08:00
										 |  |  | void gpio_iomux_in(uint32_t gpio, uint32_t signal_idx) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO.func_in_sel_cfg[signal_idx].sig_in_sel = 0; | 
					
						
							|  |  |  |     PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio]); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | void gpio_iomux_out(uint8_t gpio_num, int func, bool oen_inv) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |     GPIO.func_out_sel_cfg[gpio_num].oen_sel = 0; | 
					
						
							|  |  |  |     GPIO.func_out_sel_cfg[gpio_num].oen_inv_sel = oen_inv; | 
					
						
							|  |  |  |     PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio_num], func); | 
					
						
							|  |  |  | } |