Remove mutex from GPIO driver code. Replace uint8_t/uint16_t with uint32_t

components/driver/gpio.c

@@ -16,7 +16,6 @@
 #include "esp_err.h"
 #include "esp_intr.h"
 #include "freertos/FreeRTOS.h"
-#include "freertos/semphr.h"
 #include "freertos/xtensa_api.h"
 #include "soc/soc.h"
 #include "driver/gpio.h"
@@ -49,7 +48,7 @@
 #define GPIO_ERROR(...)
 #endif 
 
-const uint32_t GPIO_PIN_MUX_REG[40] = {
+const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT] = {
     GPIO_PIN_REG_0,
     GPIO_PIN_REG_1,
     GPIO_PIN_REG_2,
@@ -92,8 +91,7 @@ const uint32_t GPIO_PIN_MUX_REG[40] = {
     GPIO_PIN_REG_39
 };
 
-static SemaphoreHandle_t gpio_mutex = NULL;
-
+#define IS_VALID_GPIO(gpio_num)  ( (gpio_num < GPIO_PIN_COUNT && GPIO_PIN_MUX_REG[gpio_num] != 0))
 static int is_valid_gpio(int gpio_num)
 {
     if(gpio_num >= GPIO_PIN_COUNT || GPIO_PIN_MUX_REG[gpio_num] == 0) {
@@ -103,17 +101,7 @@ static int is_valid_gpio(int gpio_num)
     return 1;
 }
 
-static esp_err_t gpio_mutex_init()
-{
-    if(gpio_mutex == NULL) {
-        gpio_mutex = xSemaphoreCreateRecursiveMutex();
-        if(gpio_mutex == NULL)
-            return ESP_FAIL;
-    }
-    return ESP_OK;
-}
-
-static esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, uint8_t intr_type)
+esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type)
 {
     if(!is_valid_gpio(gpio_num))
         return ESP_ERR_INVALID_ARG;
@@ -121,79 +109,28 @@ static esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, uint8_t intr_type)
         GPIO_ERROR("Unknown GPIO intr:%u\n",intr_type);
         return ESP_ERR_INVALID_ARG;
     }
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        GPIO.pin[gpio_num].int_type = intr_type;
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
-    }
-}
-
-static esp_err_t gpio_intr_enable(gpio_num_t gpio_num)
-{
-    if(!is_valid_gpio(gpio_num))
-        return ESP_ERR_INVALID_ARG;
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        if(xPortGetCoreID() == 0) {
-            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
-        }
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
-    }
-}
-
-static esp_err_t gpio_intr_disable(gpio_num_t gpio_num)
-{
-    if(!is_valid_gpio(gpio_num))
-        return ESP_ERR_INVALID_ARG;
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        GPIO.pin[gpio_num].int_ena = 0;                        //disable GPIO intr
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
-    }
+    GPIO.pin[gpio_num].int_type = intr_type;
+    return ESP_OK;
 }
 
-static esp_err_t gpio_input_enable(gpio_num_t gpio_num)
+esp_err_t gpio_intr_enable(gpio_num_t gpio_num)
 {
     if(!is_valid_gpio(gpio_num))
         return ESP_ERR_INVALID_ARG;
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_num]);
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
+    if(xPortGetCoreID() == 0) {
+        GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA;     //enable pro cpu intr
     } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
+        GPIO.pin[gpio_num].int_ena = GPIO_APP_CPU_INTR_ENA;     //enable pro cpu intr
     }
+    return ESP_OK;
 }
 
-static esp_err_t gpio_input_disable(gpio_num_t gpio_num)
+esp_err_t gpio_intr_disable(gpio_num_t gpio_num)
 {
     if(!is_valid_gpio(gpio_num))
         return ESP_ERR_INVALID_ARG;
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_num]);
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
-    }
+    GPIO.pin[gpio_num].int_ena = 0;                             //disable GPIO intr
+    return ESP_OK;
 }
 
 static esp_err_t gpio_output_disable(gpio_num_t gpio_num)
@@ -214,10 +151,8 @@ static esp_err_t gpio_output_enable(gpio_num_t gpio_num)
         GPIO_ERROR("io_num=%d can only be input\n",gpio_num);
         return ESP_ERR_INVALID_ARG;
     }
-    if(gpio_num >= GPIO_PIN_COUNT || GPIO_PIN_MUX_REG[gpio_num] == 0) {
-        GPIO_ERROR("io_num=%d does not exist\n",gpio_num);
+    if(!is_valid_gpio(gpio_num))
         return ESP_ERR_INVALID_ARG;
-    }
     if(gpio_num < 32) {
         GPIO.enable_w1ts = (0x1 << gpio_num);
     } else {
@@ -228,7 +163,7 @@ static esp_err_t gpio_output_enable(gpio_num_t gpio_num)
 
 esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level)
 {
-    if(!is_valid_gpio(gpio_num))
+    if(!IS_VALID_GPIO(gpio_num))
         return ESP_ERR_INVALID_ARG;
     if(level) {
         if(gpio_num < 32)
@@ -255,127 +190,108 @@ int gpio_get_level(gpio_num_t gpio_num)
 
 esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)
 {
-    if(gpio_mutex != NULL) {
-        if(!is_valid_gpio(gpio_num))
-            return ESP_ERR_INVALID_ARG;
-
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        esp_err_t ret = ESP_OK;
-        switch(pull) {
-            case GPIO_PULLUP_ONLY:
-                PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);
-                PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);
-                break;
-            case GPIO_PULLDOWN_ONLY:
-                PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);
-                PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);
-                break;
-            case GPIO_PULLUP_PULLDOWN:
-                PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);
-                PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);
-                break;
-            case GPIO_FLOATING:
-                PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);
-                PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);
-                break;
-            default:
-                GPIO_ERROR("Unknown pull up/down mode,gpio_num=%u,pull=%u\n",gpio_num,pull);
-                ret = ESP_ERR_INVALID_ARG;
-                break;
-        }
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ret;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
+    if(!is_valid_gpio(gpio_num))
+        return ESP_ERR_INVALID_ARG;
+    esp_err_t ret = ESP_OK;
+    switch(pull) {
+        case GPIO_PULLUP_ONLY:
+            PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);
+            PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);
+            break;
+        case GPIO_PULLDOWN_ONLY:
+            PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);
+            PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);
+            break;
+        case GPIO_PULLUP_PULLDOWN:
+            PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);
+            PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);
+            break;
+        case GPIO_FLOATING:
+            PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);
+            PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);
+            break;
+        default:
+            GPIO_ERROR("Unknown pull up/down mode,gpio_num=%u,pull=%u\n",gpio_num,pull);
+            ret = ESP_ERR_INVALID_ARG;
+            break;
     }
+    return ret;
 }
 
-esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_direction_t direction)
+esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode)
 {
-    if(gpio_mutex != NULL) {
-        if(!is_valid_gpio(gpio_num))
-            return ESP_ERR_INVALID_ARG;
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        esp_err_t ret = ESP_OK;
-        switch(direction) {
-            case GPIO_DIR_OUTPUT_ONLY:
-                gpio_input_disable(gpio_num);
-                gpio_output_enable(gpio_num);
-                break;
-            case GPIO_DIR_INPUT_ONLY:
-                gpio_input_enable(gpio_num);
-                gpio_output_disable(gpio_num);
-                break;
-            case GPIO_DIR_INPUT_AND_OUTPUT:
-                gpio_input_enable(gpio_num);
-                gpio_output_enable(gpio_num);
-                break;
-            case GPIO_DIR_DISABLE_IO:
-                gpio_input_disable(gpio_num);
-                gpio_output_disable(gpio_num);
-                break;
-            default:
-                GPIO_ERROR("Unknown direction type,gpio_num=%u,direction=%u\n",gpio_num,direction);
-                ret = ESP_ERR_INVALID_ARG;
-                break;
+    if(!is_valid_gpio(gpio_num))
+        return ESP_ERR_INVALID_ARG;
+    if(gpio_num >= 34 && (mode & (GPIO_MODE_DEF_OUTPUT))) {
+        GPIO_ERROR("io_num=%d can only be input\n",gpio_num);
+        return ESP_ERR_INVALID_ARG;
+    }
+    esp_err_t ret = ESP_OK;
+    if(mode & GPIO_MODE_DEF_INPUT) {
+        PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_num]);
+    } else {
+        PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_num]);
+    }
+    if(mode & GPIO_MODE_DEF_OUTPUT) {
+        if(gpio_num < 32) {
+            GPIO.enable_w1ts = (0x1 << gpio_num);
+        } else {
+            GPIO.enable1_w1ts.data = (0x1 << (gpio_num - 32));
         }
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ret;
     } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
+        if(gpio_num < 32) {
+            GPIO.enable_w1tc = (0x1 << gpio_num);
+        } else {
+            GPIO.enable1_w1tc.data = (0x1 << (gpio_num - 32));
+        }
+    }
+    if(mode & GPIO_MODE_DEF_OD) {
+        GPIO.pin[gpio_num].pad_driver = 1;
+    } else {
+        GPIO.pin[gpio_num].pad_driver = 0;
     }
+    return ret;
 }
 
 esp_err_t gpio_config(gpio_config_t *pGPIOConfig)
 {
-    if(gpio_mutex == NULL) {
-        gpio_mutex = xSemaphoreCreateRecursiveMutex();
-        if(gpio_mutex == NULL) {
-            GPIO_ERROR("Mutex null\n");
-            return ESP_FAIL;
-        }
-    }
     uint64_t gpio_pin_mask = (pGPIOConfig->pin_bit_mask);
     uint32_t io_reg = 0;
-    uint8_t io_num = 0;
+    uint32_t io_num = 0;
     uint64_t bit_valid = 0;
-    if(pGPIOConfig->pin_bit_mask == 0) {
-        GPIO_ERROR("GPIO_PIN = 0 \n");
+    if(pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) {
+        GPIO_ERROR("GPIO_PIN mask error \n");
         return ESP_ERR_INVALID_ARG;
     }
-    if((pGPIOConfig->mode) & (BIT1)) {
+    if((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) {
         //GPIO 34/35/36/37/38/39 can only be used as input mode;
         if((gpio_pin_mask & ( GPIO_SEL_34 | GPIO_SEL_35 | GPIO_SEL_36 | GPIO_SEL_37 | GPIO_SEL_38 | GPIO_SEL_39))) {
             GPIO_ERROR("GPIO34-39 can only be used as input mode\n");
             return ESP_ERR_INVALID_ARG;
         }
     }
-    xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
     do {
         io_reg = GPIO_PIN_MUX_REG[io_num];
         if(((gpio_pin_mask >> io_num) & BIT(0)) && io_reg) {
             GPIO_INFO("Gpio%02d |Mode:",io_num);
-            if((pGPIOConfig->mode) & GPIO_MODE_INPUT) {
+            if((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) {
                 GPIO_INFO("INPUT ");
-                gpio_input_enable(io_num);
+                PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]);
             } else {
-                gpio_input_disable(io_num);
+                PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]);
             }
-            if((pGPIOConfig->mode) & BIT2) {
+            if((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) {
                 GPIO_INFO("OD ");
                 GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */
             } else {
                 GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */
             }
-            if((pGPIOConfig->mode) & GPIO_MODE_OUTPUT) {
+            if((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) {
                 GPIO_INFO("OUTPUT ");
                 gpio_output_enable(io_num);
             } else {
                 gpio_output_disable(io_num);
-            }
-            GPIO_INFO("|");
+            }GPIO_INFO("|");
             if(pGPIOConfig->pull_up_en) {
                 GPIO_INFO("PU ");
                 PIN_PULLUP_EN(io_reg);
@@ -401,57 +317,40 @@ esp_err_t gpio_config(gpio_config_t *pGPIOConfig)
         }
         io_num++;
     } while(io_num < GPIO_PIN_COUNT);
-    xSemaphoreGiveRecursive(gpio_mutex);
     return ESP_OK;
 }
 
-esp_err_t gpio_intr_handler_register(uint8_t gpio_intr_num, void (*fn)(void*), void * arg)
+esp_err_t gpio_intr_handler_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg)
 {
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        ESP_INTR_DISABLE(gpio_intr_num);
-        intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num);
-        xt_set_interrupt_handler(gpio_intr_num, fn, arg);
-        ESP_INTR_ENABLE(gpio_intr_num);
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
-    }
+    if(fn == NULL)
+        return ESP_ERR_INVALID_ARG;
+    ESP_INTR_DISABLE(gpio_intr_num);
+    intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num);
+    xt_set_interrupt_handler(gpio_intr_num, fn, arg);
+    ESP_INTR_ENABLE(gpio_intr_num);
+    return ESP_OK;
 }
 
 /*only level interrupt can be used for wake-up function*/
 esp_err_t gpio_pin_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)
 {
-    if(gpio_mutex != NULL) {
-        esp_err_t ret = ESP_OK;
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        if((intr_type == GPIO_PIN_INTR_LOW_LEVEL) || (intr_type == GPIO_PIN_INTR_HIGH_LEVEL)) {
-            GPIO.pin[gpio_num].int_type = intr_type;
-            GPIO.pin[gpio_num].wakeup_enable = 0x1;
-        } else {
-            GPIO_ERROR("GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u\n",gpio_num);
-            ret = ESP_ERR_INVALID_ARG;
-        }
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ret;
+    if(!is_valid_gpio(gpio_num))
+        return ESP_ERR_INVALID_ARG;
+    esp_err_t ret = ESP_OK;
+    if((intr_type == GPIO_PIN_INTR_LOW_LEVEL) || (intr_type == GPIO_PIN_INTR_HIGH_LEVEL)) {
+        GPIO.pin[gpio_num].int_type = intr_type;
+        GPIO.pin[gpio_num].wakeup_enable = 0x1;
     } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
+        GPIO_ERROR("GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u\n",gpio_num);
+        ret = ESP_ERR_INVALID_ARG;
     }
+    return ret;
 }
 
 esp_err_t gpio_pin_wakeup_disable(gpio_num_t gpio_num)
 {
-    if(gpio_mutex != NULL) {
-        xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);
-        GPIO.pin[gpio_num].wakeup_enable = 0;
-        xSemaphoreGiveRecursive(gpio_mutex);
-        return ESP_OK;
-    } else {
-        GPIO_ERROR("Mutex null\n");
-        return ESP_FAIL;
-    }
-
+    if(!is_valid_gpio(gpio_num))
+        return ESP_ERR_INVALID_ARG;
+    GPIO.pin[gpio_num].wakeup_enable = 0;
+    return ESP_OK;
 }

components/driver/include/driver/gpio.h

@@ -26,8 +26,6 @@
 extern "C" {
 #endif
 
-extern const uint32_t GPIO_PIN_MUX_REG[40];
-
 #define GPIO_SEL_0              (BIT(0))                         /* Pin 0 selected */
 #define GPIO_SEL_1              (BIT(1))                         /* Pin 1 selected */
 #define GPIO_SEL_2              (BIT(2))                         /* Pin 2 selected */
@@ -115,6 +113,12 @@ extern const uint32_t GPIO_PIN_MUX_REG[40];
 #define GPIO_ID_PIN(n)              (GPIO_ID_PIN0 + (n))
 #define GPIO_PIN_ADDR(i)            (GPIO_PIN0_REG + i * 4)
 
+#define GPIO_MODE_DEF_INPUT           (BIT0)
+#define GPIO_MODE_DEF_OUTPUT          (BIT1)
+#define GPIO_MODE_DEF_OD              (BIT2)
+
+extern const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT];
+
 typedef enum {
     GPIO_NUM_0 = 0,
     GPIO_NUM_1 = 1,
@@ -166,11 +170,11 @@ typedef enum {
 } gpio_int_type_t;
 
 typedef enum {
-    GPIO_MODE_INPUT = (BIT0),                           /* GPIO mode : input only                           */
-    GPIO_MODE_OUTPUT = (BIT1),                          /* GPIO mode : output only mode                     */
-    GPIO_MODE_OUTPUT_OD = ((BIT1)|(BIT2)),              /* GPIO mode : output only with open-drain mode     */
-    GPIO_MODE_INPUT_OUTPUT_OD = ((BIT0)|(BIT1)|(BIT2)), /* GPIO mode : output and input with open-drain mode*/
-    GPIO_MODE_INPUT_OUTPUT = ((BIT0)|(BIT1)),           /* GPIO mode : output and input mode                */
+    GPIO_MODE_INPUT = GPIO_MODE_DEF_INPUT,                                                         /* GPIO mode : input only                           */
+    GPIO_MODE_OUTPUT = GPIO_MODE_DEF_OUTPUT,                                                       /* GPIO mode : output only mode                     */
+    GPIO_MODE_OUTPUT_OD = ((GPIO_MODE_DEF_OUTPUT)|(GPIO_MODE_DEF_OD)),                             /* GPIO mode : output only with open-drain mode     */
+    GPIO_MODE_INPUT_OUTPUT_OD = ((GPIO_MODE_DEF_INPUT)|(GPIO_MODE_DEF_OUTPUT)|(GPIO_MODE_DEF_OD)), /* GPIO mode : output and input with open-drain mode*/
+    GPIO_MODE_INPUT_OUTPUT = ((GPIO_MODE_DEF_INPUT)|(GPIO_MODE_DEF_OUTPUT)),                       /* GPIO mode : output and input mode                */
 } gpio_mode_t;
 
 typedef enum {
@@ -191,13 +195,6 @@ typedef struct {
     gpio_int_type_t intr_type;      /* GPIO interrupt type                                  */
 } gpio_config_t;
 
-typedef enum {
-    GPIO_DIR_OUTPUT_ONLY,          /* GPIO output         */
-    GPIO_DIR_INPUT_ONLY,           /* GPIO input          */
-    GPIO_DIR_INPUT_AND_OUTPUT,     /* GPIO input + output */
-    GPIO_DIR_DISABLE_IO,           /* GPIO disable        */
-} gpio_direction_t;
-
 typedef enum {
     GPIO_LOW_LEVEL = 0,
     GPIO_HIGH_LEVEL = 1,
@@ -242,21 +239,59 @@ typedef void (*gpio_event_callback)(gpio_num_t gpio_intr_num);
  *                 pGPIOConfig.pull_down_en   : Enable or Disable pull-down
  *                 pGPIOConfig.intr_type : Configure GPIO interrupt trigger type
  * @return	       ESP_OK: success ;
- *                 ESP_ERR_INVALID_ARG: parameters error
- *                 ESP_FAIL : GPIO mutex error
+ *                 ESP_ERR_INVALID_ARG: parameter error
+ *                 ESP_FAIL : GPIO error
  *
  */
 esp_err_t gpio_config(gpio_config_t *pGPIOConfig);
 
+
+/**
+ * @brief      GPIO set interrupt trigger type
+ *
+ * @parameter[in]  gpio_num : GPIO number.
+ *                            If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ * @parameter[in]  intr_type: interrupt type, select from gpio_int_type_t
+ *
+ * @return         ESP_OK   : success
+ *                 ESP_ERR_INVALID_ARG: parameter error
+ *
+ */
+esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type);
+
+/**
+ * @brief      enable GPIO module interrupt signal
+ *
+ * @parameter[in]  gpio_num : GPIO number.
+ *                            If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ *
+ * @return         ESP_OK   : success
+ *                 ESP_ERR_INVALID_ARG: parameter error
+ *
+ */
+esp_err_t gpio_intr_enable(gpio_num_t gpio_num);
+
+/**
+ * @brief      disable GPIO module interrupt signal
+ *
+ * @parameter[in]  gpio_num : GPIO number.
+ *                            If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ *
+ * @return         ESP_OK   : success
+ *                 ESP_ERR_INVALID_ARG: parameter error
+ *
+ */
+esp_err_t gpio_intr_disable(gpio_num_t gpio_num);
+
 /**
  * @brief	   GPIO set output level
  *
  * @parameter[in]  gpio_num : GPIO number.
- *                            If you want to set output level of GPIO16, gpio_num should be  GPIO_NUM_16 (16);
+ *                            If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
  * @parameter[in]  level    : Output level. 0: low ; 1: high
  *
  * @return	       ESP_OK   : success
- *                 ESP_FAIL : GPIO mutex error
+ *                 ESP_FAIL : GPIO error
  *
  */
 esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level);
@@ -265,7 +300,7 @@ esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level);
  * @brief	   GPIO get input level
  *
  * @parameter[in]  gpio_num : GPIO number.
- *                            If you want to get level of pin GPIO16, gpio_num should be  GPIO_NUM_16 (16);
+ *                            If you want to get level of pin GPIO16, gpio_num should be GPIO_NUM_16 (16);
  *
  * @return	    0  : the GPIO input level is 0
  *              1  : the GPIO input level is 1
@@ -278,29 +313,29 @@ int gpio_get_level(gpio_num_t gpio_num);
  *
  * Configure GPIO direction,such as output_only,input_only,output_and_input
  *
- * @parameter[in]  gpio_num : Configure GPIO pins number,it should  GPIO number.
- *                            If you want to set direction of GPIO16, gpio_num should be  GPIO_NUM_16 (16);
- * @parameter[in]  direction: Configure GPIO direction,such as output_only,input_only,...
+ * @parameter[in]  gpio_num : Configure GPIO pins number,it should be GPIO number.
+ *                            If you want to set direction of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ * @parameter[in]  mode     : Configure GPIO direction,such as output_only,input_only,...
  *
  * @return	       ESP_OK   : success
  *                 ESP_ERR_INVALID_ARG : fail
- *                 ESP_FAIL : GPIO mutex error
+ *                 ESP_FAIL : GPIO error
  *
  */
-esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_direction_t direction);
+esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode);
 
 /**
  * @brief	   GPIO set pull
  *
  * User this Function,configure GPIO pull mode,such as pull-up,pull-down
  *
- * @parameter[in]  gpio_num : Configure GPIO pins number,it should  GPIO number.
+ * @parameter[in]  gpio_num : Configure GPIO pins number,it should be GPIO number.
  *                            If you want to set pull up or down mode for GPIO16,gpio_num should be GPIO_NUM_16 (16);
  * @parameter[in]  pull     : Configure GPIO pull up/down mode,such as pullup_only,pulldown_only,pullup_and_pulldown,...
  *
  * @return	       ESP_OK   : success
  *                 ESP_ERR_INVALID_ARG : fail
- *                 ESP_FAIL : GPIO mutex error
+ *                 ESP_FAIL : GPIO error
  *
  */
 esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull);
@@ -313,7 +348,7 @@ esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull);
  * Second , enable the GPIO input,if you use pin_func_as_gpio,you can use gpio_set_direction function
  * Third ,  call gpio_matrix_in function
  *
- * @parameter[in]  GPIO       : Configure GPIO pins number,it should  GPIO number.
+ * @parameter[in]  GPIO       : Configure GPIO pins number,it should be GPIO number.
  *                              If you want to configure GPIO16, gpio_num should be GPIO_NUM_16 (16);
  * @parameter[in]  signal_idx : the signal_idx,find the signal index from gpio_sig_map.h
  *
@@ -351,19 +386,30 @@ void gpio_matrix_out(uint32_t GPIO, uint32_t signal_idx, bool out_inv, bool oen_
  *          Users should know that which CPU is running and then pick a INUM that is not used by system.
  *          We can find the information of INUM and interrupt level in soc.h.
  *          TODO: to move INUM options to menu_config
- * @parameter   uint8_t gpio_intr_num     : GPIO interrupt number,check the info in soc.h, and please see the core-isa.h for more details
+ * @parameter   uint32_t gpio_intr_num     : GPIO interrupt number,check the info in soc.h, and please see the core-isa.h for more details
  * @parameter   void (* fn)(void* )       : interrupt handler function.
  *                                          Note that the handler function MUST be defined with attribution of "IRAM_ATTR".
  * @parameter   void * arg                : parameter for handler function
  *
  * @return      ESP_OK : success ;
- *              ESP_FAIL: gpio_mutex error
+ *              ESP_FAIL: gpio_ error
  */
-esp_err_t gpio_intr_handler_register(uint8_t gpio_intr_num, void (*fn)(void*), void * arg);
+esp_err_t gpio_intr_handler_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg);
 
 
 
 
+/**
+ * ***************        ATTENTION       ********************/
+/**
+ *
+ * Each GPIO have their separated registers, so we don't have to use
+ * lock for multi-task issues.
+ * Please make sure that there would be no such situation, in which,
+ * different tasks read-then-write the same GPIO register.
+ */
+
+
 /*----------EXAMPLE TO CONIFGURE GPIO AS OUTPUT ------------ */
 /*     gpio_config_t io_conf;
  *     io_conf.intr_type = GPIO_PIN_INTR_DISABLE;             //disable interrupt
@@ -425,8 +471,6 @@ esp_err_t gpio_intr_handler_register(uint8_t gpio_intr_num, void (*fn)(void*), v
  *
  */
 
-
-
 /**
  * @}
  */