Fully implement digitalio and pin-in-use tracking.

Fixes #2901

Author: tannewt

ports/esp32s2/Makefile

@@ -149,6 +149,7 @@ SRC_C += \
 	mphalport.c \
 	boards/$(BOARD)/board.c \
 	boards/$(BOARD)/pins.c \
+	modules/$(CIRCUITPY_MODULE).c \
 	lib/libc/string0.c \
 	lib/mp-readline/readline.c \
 	lib/oofatfs/ff.c \

ports/esp32s2/boards/espressif_saola_1_wroom/board.c

@@ -26,8 +26,16 @@
 
 #include "boards/board.h"
 #include "mpconfigboard.h"
+#include "shared-bindings/microcontroller/Pin.h"
 
 void board_init(void) {
+    // USB
+    never_reset_pin(&pin_GPIO19);
+    never_reset_pin(&pin_GPIO20);
+
+    // Debug UART
+    never_reset_pin(&pin_GPIO43);
+    never_reset_pin(&pin_GPIO44);
 }
 
 bool board_requests_safe_mode(void) {

ports/esp32s2/boards/espressif_saola_1_wroom/mpconfigboard.mk

@@ -18,3 +18,5 @@ CIRCUITPY_MICROCONTROLLER = 0
 CIRCUITPY_ESP_FLASH_MODE=dio
 CIRCUITPY_ESP_FLASH_FREQ=40m
 CIRCUITPY_ESP_FLASH_SIZE=4MB
+
+CIRCUITPY_MODULE=wroom

ports/esp32s2/boards/espressif_saola_1_wrover/board.c

@@ -28,6 +28,13 @@
 #include "mpconfigboard.h"
 
 void board_init(void) {
+    // USB
+    never_reset_pin(&pin_GPIO19);
+    never_reset_pin(&pin_GPIO20);
+
+    // Debug UART
+    never_reset_pin(&pin_GPIO43);
+    never_reset_pin(&pin_GPIO44);
 }
 
 bool board_requests_safe_mode(void) {

ports/esp32s2/boards/espressif_saola_1_wrover/mpconfigboard.mk

@@ -18,3 +18,5 @@ CIRCUITPY_MICROCONTROLLER = 0
 CIRCUITPY_ESP_FLASH_MODE=dio
 CIRCUITPY_ESP_FLASH_FREQ=40m
 CIRCUITPY_ESP_FLASH_SIZE=4MB
+
+CIRCUITPY_MODULE=wrover

ports/esp32s2/common-hal/digitalio/DigitalInOut.c

@@ -30,24 +30,18 @@
 
 #include "driver/gpio.h"
 
-
-#include "esp_log.h"
-
-static const char* TAG = "CircuitPython digitalio";
+#include "esp-idf/components/soc/include/hal/gpio_hal.h"
 
 void common_hal_digitalio_digitalinout_never_reset(
         digitalio_digitalinout_obj_t *self) {
-    (void)self;
+    never_reset_pin_number(self->pin->number);
 }
 
 digitalinout_result_t common_hal_digitalio_digitalinout_construct(
         digitalio_digitalinout_obj_t *self, const mcu_pin_obj_t *pin) {
-
-    // claim_pin(pin);
+    claim_pin(pin);
     self->pin = pin;
 
-    ESP_EARLY_LOGW(TAG, "construct %d", pin->number);
-
     return DIGITALINOUT_OK;
 }
 
@@ -60,78 +54,86 @@ void common_hal_digitalio_digitalinout_deinit(digitalio_digitalinout_obj_t *self
         return;
     }
 
-    // reset_pin_number(0, self->pin->number);
+    reset_pin_number(self->pin->number);
     self->pin = mp_const_none;
 }
 
 void common_hal_digitalio_digitalinout_switch_to_input(
         digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
-    gpio_config_t config = {
-        .pin_bit_mask = 1 << self->pin->number,
-        .mode = GPIO_MODE_INPUT
-    };
-    if (pull == PULL_UP) {
-        config.pull_up_en = GPIO_PULLUP_ENABLE;
-    } else if (pull == PULL_DOWN) {
-        config.pull_down_en = GPIO_PULLDOWN_ENABLE;
-    }
-
-    gpio_config(&config);
+    common_hal_digitalio_digitalinout_set_pull(self, pull);
+    gpio_set_direction(self->pin->number, GPIO_MODE_DEF_INPUT);
 }
 
-void common_hal_digitalio_digitalinout_switch_to_output(
+digitalinout_result_t common_hal_digitalio_digitalinout_switch_to_output(
         digitalio_digitalinout_obj_t *self, bool value,
         digitalio_drive_mode_t drive_mode) {
-    gpio_config_t config = {
-        .pin_bit_mask = 1ULL << self->pin->number,
-        .mode = GPIO_MODE_OUTPUT
-    };
-    if (drive_mode == DRIVE_MODE_OPEN_DRAIN) {
-        config.mode = GPIO_MODE_OUTPUT_OD;
-    }
     gpio_set_level(self->pin->number, value);
-    gpio_config(&config);
+    return common_hal_digitalio_digitalinout_set_drive_mode(self, drive_mode);
 }
 
 digitalio_direction_t common_hal_digitalio_digitalinout_get_direction(
         digitalio_digitalinout_obj_t *self) {
-
+    uint32_t iomux = READ_PERI_REG(GPIO_PIN_MUX_REG[self->pin->number]);
+    if ((iomux & FUN_IE) != 0) {
+        return DIRECTION_INPUT;
+    }
     return DIRECTION_OUTPUT;
 }
 
 void common_hal_digitalio_digitalinout_set_value(
         digitalio_digitalinout_obj_t *self, bool value) {
-    ESP_EARLY_LOGW(TAG, "set %d %d", self->pin->number, value);
     gpio_set_level(self->pin->number, value);
 }
 
 bool common_hal_digitalio_digitalinout_get_value(
         digitalio_digitalinout_obj_t *self) {
-    return true;
+    return gpio_get_level(self->pin->number) == 1;
 }
 
-void common_hal_digitalio_digitalinout_set_drive_mode(
+digitalinout_result_t common_hal_digitalio_digitalinout_set_drive_mode(
         digitalio_digitalinout_obj_t *self,
         digitalio_drive_mode_t drive_mode) {
-    (void)self;
-    (void)drive_mode;
+    gpio_num_t number = self->pin->number;
+    gpio_mode_t mode;
+    if (drive_mode == DRIVE_MODE_OPEN_DRAIN) {
+        mode = GPIO_MODE_DEF_OD;
+    } else {
+        mode = GPIO_MODE_DEF_OUTPUT;
+    }
+    esp_err_t result = gpio_set_direction(number, mode);
+    if (result != ESP_OK) {
+        return DIGITALINOUT_INPUT_ONLY;
+    }
+    return DIGITALINOUT_OK;
 }
 
 digitalio_drive_mode_t common_hal_digitalio_digitalinout_get_drive_mode(
         digitalio_digitalinout_obj_t *self) {
-    // if (common_hal_digitalio_digitalinout_get_direction(self) == DIRECTION_OUTPUT)
-    //     return DRIVE_MODE_PUSH_PULL;
-    // else
-    return DRIVE_MODE_OPEN_DRAIN;
+    if (GPIO_HAL_GET_HW(GPIO_PORT_0)->pin[self->pin->number].pad_driver == 1) {
+        return DRIVE_MODE_OPEN_DRAIN;
+    }
+    return DRIVE_MODE_PUSH_PULL;
 }
 
 void common_hal_digitalio_digitalinout_set_pull(
         digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
-    (void)self;
-    (void)pull;
+    gpio_num_t number = self->pin->number;
+    gpio_pullup_dis(number);
+    gpio_pulldown_dis(number);
+    if (pull == PULL_UP) {
+        gpio_pullup_en(number);
+    } else if (pull == PULL_DOWN) {
+        gpio_pulldown_en(number);
+    }
 }
 
 digitalio_pull_t common_hal_digitalio_digitalinout_get_pull(
         digitalio_digitalinout_obj_t *self) {
+    gpio_num_t gpio_num = self->pin->number;
+    if (REG_GET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU) == 1) {
+        return PULL_UP;
+    } else if (REG_GET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD) == 1) {
+        return PULL_DOWN;
+    }
     return PULL_NONE;
 }

ports/esp32s2/common-hal/microcontroller/Pin.c

@@ -29,18 +29,51 @@
 
 #include "py/mphal.h"
 
+#include "esp-idf/components/driver/include/driver/gpio.h"
+#include "esp-idf/components/soc/include/hal/gpio_hal.h"
+
+STATIC uint32_t never_reset_pins[2];
+STATIC uint32_t in_use[2];
+
+void never_reset_pin_number(gpio_num_t pin_number) {
+    never_reset_pins[pin_number / 32] |= 1 << pin_number % 32;
+}
+
+void never_reset_pin(const mcu_pin_obj_t* pin) {
+    never_reset_pin_number(pin->number);
+}
+
 // Mark pin as free and return it to a quiescent state.
-void reset_pin_number(uint8_t pin_port, uint8_t pin_number) {
+void reset_pin_number(gpio_num_t pin_number) {
+    never_reset_pins[pin_number / 32] &= ~(1 << pin_number % 32);
+    in_use[pin_number / 32] &= ~(1 << pin_number % 32);
 }
 
+void reset_all_pins(void) {
+    for (uint8_t i = 0; i < GPIO_PIN_COUNT; i++) {
+        uint32_t iomux_address = GPIO_PIN_MUX_REG[i];
+        if (iomux_address == 0 ||
+            (never_reset_pins[i / 32] & (1 << i % 32)) != 0) {
+            continue;
+        }
+        gpio_set_direction(i, GPIO_MODE_DEF_INPUT);
+        gpio_pullup_dis(i);
+        gpio_pulldown_dis(i);
+    }
+    in_use[0] = 0;
+    in_use[1] = 0;
+}
 
 void claim_pin(const mcu_pin_obj_t* pin) {
+    in_use[pin->number / 32] |= (1 << pin->number % 32);
 }
 
-bool pin_number_is_free(uint8_t pin_port, uint8_t pin_number) {
-    return true;
+bool pin_number_is_free(gpio_num_t pin_number) {
+    uint8_t offset = pin_number / 32;
+    uint8_t mask = 1 << pin_number % 32;
+    return (never_reset_pins[offset] & mask) == 0 && (in_use[offset] & mask) == 0;
 }
 
 bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t *pin) {
-    return pin_number_is_free(0, pin->number);
+    return pin_number_is_free(pin->number);
 }

ports/esp32s2/common-hal/microcontroller/Pin.h

@@ -34,11 +34,10 @@
 void reset_all_pins(void);
 // reset_pin_number takes the pin number instead of the pointer so that objects don't
 // need to store a full pointer.
-void reset_pin_number(uint8_t pin_port, uint8_t pin_number);
+void reset_pin_number(gpio_num_t pin_number);
 void claim_pin(const mcu_pin_obj_t* pin);
-bool pin_number_is_free(uint8_t pin_port, uint8_t pin_number);
-void never_reset_pin_number(uint8_t pin_port, uint8_t pin_number);
-// GPIO_TypeDef * pin_port(uint8_t pin_port);
-uint16_t pin_mask(uint8_t pin_number);
+bool pin_number_is_free(gpio_num_t pin_number);
+void never_reset_pin_number(gpio_num_t pin_number);
+void never_reset_pin(const mcu_pin_obj_t* pin);
 
 #endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_MICROCONTROLLER_PIN_H

ports/esp32s2/modules/module.h

@@ -0,0 +1,35 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+#ifndef MICROPY_INCLUDED_ESP32S2_MODULES_MODULE_H
+#define MICROPY_INCLUDED_ESP32S2_MODULES_MODULE_H
+
+#include "shared-bindings/microcontroller/Pin.h"
+
+void never_reset_module_internal_pins(void);
+
+#endif // MICROPY_INCLUDED_ESP32S2_MODULES_MODULE_H

ports/esp32s2/modules/none.c

@@ -0,0 +1,28 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+void never_reset_module_internal_pins(void) {
+}