1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
7 // http://www.apache.org/licenses/LICENSE-2.0
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 #include <esp_types.h>
17 #include "esp_intr_alloc.h"
18 #include "freertos/FreeRTOS.h"
19 #include "freertos/xtensa_api.h"
20 #include "driver/gpio.h"
21 #include "driver/rtc_io.h"
24 #include "soc/gpio_periph.h"
26 static const char* GPIO_TAG = "gpio";
27 #define GPIO_CHECK(a, str, ret_val) \
29 ESP_LOGE(GPIO_TAG,"%s(%d): %s", __FUNCTION__, __LINE__, str); \
34 gpio_isr_t fn; /*!< isr function */
35 void* args; /*!< isr function args */
38 static gpio_isr_func_t* gpio_isr_func = NULL;
39 static gpio_isr_handle_t gpio_isr_handle;
40 static portMUX_TYPE gpio_spinlock = portMUX_INITIALIZER_UNLOCKED;
42 esp_err_t gpio_pullup_en(gpio_num_t gpio_num)
44 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
45 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
46 rtc_gpio_pullup_en(gpio_num);
48 REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU);
53 esp_err_t gpio_pullup_dis(gpio_num_t gpio_num)
55 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
56 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
57 rtc_gpio_pullup_dis(gpio_num);
59 REG_CLR_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU);
64 esp_err_t gpio_pulldown_en(gpio_num_t gpio_num)
66 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
67 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
68 rtc_gpio_pulldown_en(gpio_num);
70 REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD);
75 esp_err_t gpio_pulldown_dis(gpio_num_t gpio_num)
77 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
78 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
79 rtc_gpio_pulldown_dis(gpio_num);
81 REG_CLR_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD);
86 esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type)
88 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
89 GPIO_CHECK(intr_type < GPIO_INTR_MAX, "GPIO interrupt type error", ESP_ERR_INVALID_ARG);
90 GPIO.pin[gpio_num].int_type = intr_type;
94 static void gpio_intr_status_clr(gpio_num_t gpio_num)
97 GPIO.status_w1tc = BIT(gpio_num);
99 GPIO.status1_w1tc.intr_st = BIT(gpio_num - 32);
103 static esp_err_t gpio_intr_enable_on_core (gpio_num_t gpio_num, uint32_t core_id)
105 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
106 gpio_intr_status_clr(gpio_num);
108 GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA; //enable pro cpu intr
110 GPIO.pin[gpio_num].int_ena = GPIO_APP_CPU_INTR_ENA; //enable pro cpu intr
115 esp_err_t gpio_intr_enable(gpio_num_t gpio_num)
117 return gpio_intr_enable_on_core (gpio_num, xPortGetCoreID());
120 esp_err_t gpio_intr_disable(gpio_num_t gpio_num)
122 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
123 GPIO.pin[gpio_num].int_ena = 0; //disable GPIO intr
124 gpio_intr_status_clr(gpio_num);
128 static esp_err_t gpio_output_disable(gpio_num_t gpio_num)
130 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
132 GPIO.enable_w1tc = (0x1 << gpio_num);
134 GPIO.enable1_w1tc.data = (0x1 << (gpio_num - 32));
137 // Ensure no other output signal is routed via GPIO matrix to this pin
138 REG_WRITE(GPIO_FUNC0_OUT_SEL_CFG_REG + (gpio_num * 4),
144 static esp_err_t gpio_output_enable(gpio_num_t gpio_num)
146 GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error", ESP_ERR_INVALID_ARG);
148 GPIO.enable_w1ts = (0x1 << gpio_num);
150 GPIO.enable1_w1ts.data = (0x1 << (gpio_num - 32));
152 gpio_matrix_out(gpio_num, SIG_GPIO_OUT_IDX, false, false);
156 esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level)
158 GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error", ESP_ERR_INVALID_ARG);
161 GPIO.out_w1ts = (1 << gpio_num);
163 GPIO.out1_w1ts.data = (1 << (gpio_num - 32));
167 GPIO.out_w1tc = (1 << gpio_num);
169 GPIO.out1_w1tc.data = (1 << (gpio_num - 32));
175 int gpio_get_level(gpio_num_t gpio_num)
178 return (GPIO.in >> gpio_num) & 0x1;
180 return (GPIO.in1.data >> (gpio_num - 32)) & 0x1;
184 esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)
186 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
187 GPIO_CHECK(pull <= GPIO_FLOATING, "GPIO pull mode error", ESP_ERR_INVALID_ARG);
188 esp_err_t ret = ESP_OK;
190 case GPIO_PULLUP_ONLY:
191 gpio_pulldown_dis(gpio_num);
192 gpio_pullup_en(gpio_num);
194 case GPIO_PULLDOWN_ONLY:
195 gpio_pulldown_en(gpio_num);
196 gpio_pullup_dis(gpio_num);
198 case GPIO_PULLUP_PULLDOWN:
199 gpio_pulldown_en(gpio_num);
200 gpio_pullup_en(gpio_num);
203 gpio_pulldown_dis(gpio_num);
204 gpio_pullup_dis(gpio_num);
207 ESP_LOGE(GPIO_TAG, "Unknown pull up/down mode,gpio_num=%u,pull=%u", gpio_num, pull);
208 ret = ESP_ERR_INVALID_ARG;
214 esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode)
216 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
217 if (gpio_num >= 34 && (mode & GPIO_MODE_DEF_OUTPUT)) {
218 ESP_LOGE(GPIO_TAG, "io_num=%d can only be input", gpio_num);
219 return ESP_ERR_INVALID_ARG;
221 esp_err_t ret = ESP_OK;
222 if (mode & GPIO_MODE_DEF_INPUT) {
223 PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_num]);
225 PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_num]);
227 if (mode & GPIO_MODE_DEF_OUTPUT) {
228 gpio_output_enable(gpio_num);
230 gpio_output_disable(gpio_num);
232 if (mode & GPIO_MODE_DEF_OD) {
233 GPIO.pin[gpio_num].pad_driver = 1;
235 GPIO.pin[gpio_num].pad_driver = 0;
240 esp_err_t gpio_config(const gpio_config_t *pGPIOConfig)
242 uint64_t gpio_pin_mask = (pGPIOConfig->pin_bit_mask);
245 uint8_t input_en = 0;
246 uint8_t output_en = 0;
250 if (pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) {
251 ESP_LOGE(GPIO_TAG, "GPIO_PIN mask error ");
252 return ESP_ERR_INVALID_ARG;
254 if ((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) {
255 //GPIO 34/35/36/37/38/39 can only be used as input mode;
256 if ((gpio_pin_mask & ( GPIO_SEL_34 | GPIO_SEL_35 | GPIO_SEL_36 | GPIO_SEL_37 | GPIO_SEL_38 | GPIO_SEL_39))) {
257 ESP_LOGE(GPIO_TAG, "GPIO34-39 can only be used as input mode");
258 return ESP_ERR_INVALID_ARG;
262 io_reg = GPIO_PIN_MUX_REG[io_num];
263 if (((gpio_pin_mask >> io_num) & BIT(0))) {
265 ESP_LOGE(GPIO_TAG, "IO%d is not a valid GPIO",io_num);
266 return ESP_ERR_INVALID_ARG;
268 if(RTC_GPIO_IS_VALID_GPIO(io_num)){
269 rtc_gpio_deinit(io_num);
271 if ((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) {
273 PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]);
275 PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]);
277 if ((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) {
279 GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */
281 GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */
283 if ((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) {
285 gpio_output_enable(io_num);
287 gpio_output_disable(io_num);
289 if (pGPIOConfig->pull_up_en) {
291 gpio_pullup_en(io_num);
293 gpio_pullup_dis(io_num);
295 if (pGPIOConfig->pull_down_en) {
297 gpio_pulldown_en(io_num);
299 gpio_pulldown_dis(io_num);
301 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);
302 gpio_set_intr_type(io_num, pGPIOConfig->intr_type);
303 if (pGPIOConfig->intr_type) {
304 gpio_intr_enable(io_num);
306 gpio_intr_disable(io_num);
308 PIN_FUNC_SELECT(io_reg, PIN_FUNC_GPIO); /*function number 2 is GPIO_FUNC for each pin */
311 } while (io_num < GPIO_PIN_COUNT);
315 esp_err_t gpio_reset_pin(gpio_num_t gpio_num)
317 assert(gpio_num >= 0 && GPIO_IS_VALID_GPIO(gpio_num));
318 gpio_config_t cfg = {
319 .pin_bit_mask = BIT64(gpio_num),
320 .mode = GPIO_MODE_DISABLE,
321 //for powersave reasons, the GPIO should not be floating, select pullup
323 .pull_down_en = false,
324 .intr_type = GPIO_INTR_DISABLE,
330 void IRAM_ATTR gpio_intr_service(void* arg)
333 uint32_t gpio_num = 0;
334 //read status to get interrupt status for GPIO0-31
335 uint32_t gpio_intr_status;
336 gpio_intr_status = GPIO.status;
337 //read status1 to get interrupt status for GPIO32-39
338 uint32_t gpio_intr_status_h;
339 gpio_intr_status_h = GPIO.status1.intr_st;
341 if (gpio_isr_func == NULL) {
346 if (gpio_intr_status & BIT(gpio_num)) { //gpio0-gpio31
347 if (gpio_isr_func[gpio_num].fn != NULL) {
348 gpio_isr_func[gpio_num].fn(gpio_isr_func[gpio_num].args);
350 GPIO.status_w1tc = BIT(gpio_num);
353 if (gpio_intr_status_h & BIT(gpio_num - 32)) {
354 if (gpio_isr_func[gpio_num].fn != NULL) {
355 gpio_isr_func[gpio_num].fn(gpio_isr_func[gpio_num].args);
357 GPIO.status1_w1tc.intr_st = BIT(gpio_num - 32);
360 } while (++gpio_num < GPIO_PIN_COUNT);
363 esp_err_t gpio_isr_handler_add(gpio_num_t gpio_num, gpio_isr_t isr_handler, void* args)
365 GPIO_CHECK(gpio_isr_func != NULL, "GPIO isr service is not installed, call gpio_install_isr_service() first", ESP_ERR_INVALID_STATE);
366 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
367 portENTER_CRITICAL(&gpio_spinlock);
368 gpio_intr_disable(gpio_num);
370 gpio_isr_func[gpio_num].fn = isr_handler;
371 gpio_isr_func[gpio_num].args = args;
373 gpio_intr_enable_on_core (gpio_num, esp_intr_get_cpu(gpio_isr_handle));
374 portEXIT_CRITICAL(&gpio_spinlock);
378 esp_err_t gpio_isr_handler_remove(gpio_num_t gpio_num)
380 GPIO_CHECK(gpio_isr_func != NULL, "GPIO isr service is not installed, call gpio_install_isr_service() first", ESP_ERR_INVALID_STATE);
381 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
382 portENTER_CRITICAL(&gpio_spinlock);
383 gpio_intr_disable(gpio_num);
385 gpio_isr_func[gpio_num].fn = NULL;
386 gpio_isr_func[gpio_num].args = NULL;
388 portEXIT_CRITICAL(&gpio_spinlock);
392 esp_err_t gpio_install_isr_service(int intr_alloc_flags)
394 GPIO_CHECK(gpio_isr_func == NULL, "GPIO isr service already installed", ESP_ERR_INVALID_STATE);
396 portENTER_CRITICAL(&gpio_spinlock);
397 gpio_isr_func = (gpio_isr_func_t*) calloc(GPIO_NUM_MAX, sizeof(gpio_isr_func_t));
398 if (gpio_isr_func == NULL) {
399 ret = ESP_ERR_NO_MEM;
401 ret = gpio_isr_register(gpio_intr_service, NULL, intr_alloc_flags, &gpio_isr_handle);
403 portEXIT_CRITICAL(&gpio_spinlock);
407 void gpio_uninstall_isr_service()
409 if (gpio_isr_func == NULL) {
412 portENTER_CRITICAL(&gpio_spinlock);
413 esp_intr_free(gpio_isr_handle);
415 gpio_isr_func = NULL;
416 portEXIT_CRITICAL(&gpio_spinlock);
420 esp_err_t gpio_isr_register(void (*fn)(void*), void * arg, int intr_alloc_flags, gpio_isr_handle_t *handle)
422 GPIO_CHECK(fn, "GPIO ISR null", ESP_ERR_INVALID_ARG);
423 return esp_intr_alloc(ETS_GPIO_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
426 /*only level interrupt can be used for wake-up function*/
427 esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)
429 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
430 esp_err_t ret = ESP_OK;
431 if (( intr_type == GPIO_INTR_LOW_LEVEL ) || ( intr_type == GPIO_INTR_HIGH_LEVEL )) {
432 GPIO.pin[gpio_num].int_type = intr_type;
433 GPIO.pin[gpio_num].wakeup_enable = 0x1;
435 ESP_LOGE(GPIO_TAG, "GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u", gpio_num);
436 ret = ESP_ERR_INVALID_ARG;
441 esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num)
443 GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
444 GPIO.pin[gpio_num].wakeup_enable = 0;
448 esp_err_t gpio_set_drive_capability(gpio_num_t gpio_num, gpio_drive_cap_t strength)
450 GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
451 GPIO_CHECK(strength < GPIO_DRIVE_CAP_MAX, "GPIO drive capability error", ESP_ERR_INVALID_ARG);
453 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
454 rtc_gpio_set_drive_capability(gpio_num, strength);
456 SET_PERI_REG_BITS(GPIO_PIN_MUX_REG[gpio_num], FUN_DRV_V, strength, FUN_DRV_S);
461 esp_err_t gpio_get_drive_capability(gpio_num_t gpio_num, gpio_drive_cap_t* strength)
463 GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
464 GPIO_CHECK(strength != NULL, "GPIO drive capability pointer error", ESP_ERR_INVALID_ARG);
466 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
467 return rtc_gpio_get_drive_capability(gpio_num, strength);
469 *strength = GET_PERI_REG_BITS2(GPIO_PIN_MUX_REG[gpio_num], FUN_DRV_V, FUN_DRV_S);
474 static const uint32_t GPIO_HOLD_MASK[34] = {
511 esp_err_t gpio_hold_en(gpio_num_t gpio_num)
513 GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "Only output-capable GPIO support this function", ESP_ERR_NOT_SUPPORTED);
514 esp_err_t r = ESP_OK;
515 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
516 r = rtc_gpio_hold_en(gpio_num);
517 } else if (GPIO_HOLD_MASK[gpio_num]) {
518 SET_PERI_REG_MASK(RTC_IO_DIG_PAD_HOLD_REG, GPIO_HOLD_MASK[gpio_num]);
520 r = ESP_ERR_NOT_SUPPORTED;
522 return r == ESP_OK ? ESP_OK : ESP_ERR_NOT_SUPPORTED;
525 esp_err_t gpio_hold_dis(gpio_num_t gpio_num)
527 GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "Only output-capable GPIO support this function", ESP_ERR_NOT_SUPPORTED);
528 esp_err_t r = ESP_OK;
529 if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
530 r = rtc_gpio_hold_dis(gpio_num);
531 } else if (GPIO_HOLD_MASK[gpio_num]) {
532 CLEAR_PERI_REG_MASK(RTC_IO_DIG_PAD_HOLD_REG, GPIO_HOLD_MASK[gpio_num]);
534 r = ESP_ERR_NOT_SUPPORTED;
536 return r == ESP_OK ? ESP_OK : ESP_ERR_NOT_SUPPORTED;
539 void gpio_iomux_in(uint32_t gpio, uint32_t signal_idx)
541 GPIO.func_in_sel_cfg[signal_idx].sig_in_sel = 0;
542 PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio]);
545 void gpio_iomux_out(uint8_t gpio_num, int func, bool oen_inv)
547 GPIO.func_out_sel_cfg[gpio_num].oen_sel = 0;
548 GPIO.func_out_sel_cfg[gpio_num].oen_inv_sel = oen_inv;
549 PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio_num], func);