/* * This file is part of the MicroPython project, http://micropython.org/ * * The MIT License (MIT) * * Copyright (c) 2016 Scott Shawcroft for Adafruit Industries * Copyright (c) 2019 Lucian Copeland 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. */ #include "shared-bindings/microcontroller/Pin.h" #include "shared-bindings/digitalio/DigitalInOut.h" #include "py/mphal.h" #include "components/driver/include/driver/gpio.h" #include "components/hal/include/hal/gpio_hal.h" STATIC uint64_t never_reset_pins; STATIC uint64_t in_use; // 64-bit pin mask for a single bit #define PIN_BIT(pin_number) (((uint64_t)1) << pin_number) // Bit mask of all pins that should never ever be reset. // Typically these are SPI flash and PSRAM control pins, and communication pins. static const uint64_t pin_mask_reset_forbidden = #if defined(CONFIG_IDF_TARGET_ESP32) // Never ever reset serial pins for bootloader and possibly USB-serial converter. GPIO_SEL_1 | // TXD0 GPIO_SEL_3 | // RXD0 // Never ever reset pins used to communicate with SPI flash and PSRAM. GPIO_SEL_6 | // CLK GPIO_SEL_9 | // (PSRAM) SD2 GPIO_SEL_10 | // (PSRAM) SD3 GPIO_SEL_11 | // CMD GPIO_SEL_16 | // SPIHD GPIO_SEL_17 | // SPIDO GPIO_SEL_18 | // SPIWP GPIO_SEL_23 | // SPIDI #endif // ESP32 #if defined(CONFIG_IDF_TARGET_ESP32C3) // Never ever reset pins used to communicate with SPI flash. GPIO_SEL_11 | // VDD_SPI GPIO_SEL_12 | // SPIHD GPIO_SEL_13 | // SPIWP GPIO_SEL_14 | // SPICS0 GPIO_SEL_15 | // SPICLK GPIO_SEL_16 | // SPID GPIO_SEL_17 | // SPIQ #if CIRCUITPY_ESP_USB_SERIAL_JTAG // Never ever reset serial/JTAG communication pins. GPIO_SEL_18 | // USB D- GPIO_SEL_19 | // USB D+ #endif #endif // ESP32C3 #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3) // Never ever reset pins used to communicate with SPI flash and PSRAM. GPIO_SEL_19 | // USB D- GPIO_SEL_20 | // USB D+ #if defined (CONFIG_ESP32_SPIRAM_SUPPORT) || defined(CONFIG_ESP32S2_SPIRAM_SUPPORT) || defined(CONFIG_ESP32S3_SPIRAM_SUPPORT) // Note ESP32-C3 does not have SPIRAM support. // Board uses PSRAM, and needs another chip select. GPIO_SEL_26 | // SPICS1 #endif GPIO_SEL_27 | // SPIHD GPIO_SEL_28 | // SPIWP GPIO_SEL_29 | // SPICS0 GPIO_SEL_30 | // SPICLK GPIO_SEL_31 | // SPIHD GPIO_SEL_32 | // SPIQ #if defined(CONFIG_SPIRAM_MODE_OCT) // Never reset octal SPI flash pins DQ4-DQ7 and DQS/DM. GPIO_SEL_33 | // SPIIO4 GPIO_SEL_34 | // SPIIO5 GPIO_SEL_35 | // SPIIO6 GPIO_SEL_36 | // SPIIO7 GPIO_SEL_37 | // SPIDQS #endif #if CIRCUITPY_USB // Never ever reset USB pins. GPIO_SEL_19 | // USB D- GPIO_SEL_20 | // USB D+ #endif #endif // ESP32S2, ESP32S3 0; // Terminate last "|". void never_reset_pin_number(gpio_num_t pin_number) { if (pin_number == NO_PIN) { return; } never_reset_pins |= PIN_BIT(pin_number); } void common_hal_never_reset_pin(const mcu_pin_obj_t *pin) { if (pin == NULL) { return; } never_reset_pin_number(pin->number); } MP_WEAK bool espressif_board_reset_pin_number(gpio_num_t pin_number) { return false; } STATIC void _reset_pin(gpio_num_t pin_number) { // Never ever reset pins used for flash, RAM, and basic communication. if (pin_mask_reset_forbidden & PIN_BIT(pin_number)) { return; } // Give the board a chance to reset the pin in a particular way. if (espressif_board_reset_pin_number(pin_number)) { return; } gpio_reset_pin(pin_number); #ifdef DOUBLE_TAP_PIN // Pull the double tap pin down so that resets come back to CircuitPython. if (pin_number == DOUBLE_TAP_PIN->number) { gpio_pullup_dis(pin_number); gpio_pulldown_en(pin_number); } #endif } // Mark pin as free and return it to a quiescent state. void reset_pin_number(gpio_num_t pin_number) { if (pin_number == NO_PIN) { return; } never_reset_pins &= ~PIN_BIT(pin_number); in_use &= ~PIN_BIT(pin_number); _reset_pin(pin_number); } void common_hal_mcu_pin_reset_number(uint8_t i) { reset_pin_number((gpio_num_t)i); } void common_hal_reset_pin(const mcu_pin_obj_t *pin) { if (pin == NULL) { return; } reset_pin_number(pin->number); } 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 & PIN_BIT(i))) { continue; } _reset_pin(i); } in_use = never_reset_pins; } void claim_pin_number(gpio_num_t pin_number) { if (pin_number == NO_PIN) { return; } in_use |= PIN_BIT(pin_number); } void claim_pin(const mcu_pin_obj_t *pin) { claim_pin_number(pin->number); } void common_hal_mcu_pin_claim(const mcu_pin_obj_t *pin) { claim_pin(pin); } bool pin_number_is_free(gpio_num_t pin_number) { return !(in_use & PIN_BIT(pin_number)); } bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t *pin) { return pin_number_is_free(pin->number); } uint8_t common_hal_mcu_pin_number(const mcu_pin_obj_t *pin) { return pin ? pin->number : NO_PIN; }