ethernet_component_esp32.cpp

Go to the documentation of this file.

#include "ethernet_component.h"
 
#if defined(USE_ETHERNET) && defined(USE_ESP32)
 
#include "esphome/components/network/util.h"
#include "esphome/core/application.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "w5500_custom_spi.h"
 
#include <lwip/dns.h>
#include <cinttypes>
#include "esp_event.h"
#if USE_NETWORK_IPV6
#include <esp_netif_net_stack.h>
#include <lwip/netif.h>
#endif
#ifdef USE_PSRAM
#include <esp_psram.h>
#endif
 
// IDF 6.0 moved per-chip PHY/MAC drivers to the Espressif Component Registry;
// they are no longer included via esp_eth.h and need explicit includes.
// On IDF 5.x these headers don't exist as standalone files.
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
#ifdef USE_ETHERNET_LAN8720
#include "esp_eth_phy_lan87xx.h"
#endif
#ifdef USE_ETHERNET_RTL8201
#include "esp_eth_phy_rtl8201.h"
#endif
#ifdef USE_ETHERNET_DP83848
#include "esp_eth_phy_dp83848.h"
#endif
#ifdef USE_ETHERNET_IP101
#include "esp_eth_phy_ip101.h"
#endif
#ifdef USE_ETHERNET_KSZ8081
#include "esp_eth_phy_ksz80xx.h"
#endif
#ifdef USE_ETHERNET_W5500
#include "esp_eth_mac_w5500.h"
#include "esp_eth_phy_w5500.h"
#endif
#ifdef USE_ETHERNET_DM9051
#include "esp_eth_mac_dm9051.h"
#include "esp_eth_phy_dm9051.h"
#endif
#ifdef USE_ETHERNET_KSZ8851SNL
#include "esp_eth_mac_ksz8851snl.h"
#include "esp_eth_phy_ksz8851snl.h"
#endif
#endif  // ESP_IDF_VERSION >= 6.0.0
 
// LAN867x header exists on all IDF versions (external component since IDF 5.3)
#ifdef USE_ETHERNET_LAN8670
#include "esp_eth_phy_lan867x.h"
#endif
 
// ENC28J60 header exists on all IDF versions (always an external component)
#ifdef USE_ETHERNET_ENC28J60
#include "esp_eth_enc28j60.h"
#endif
 
// CH390 headers exist on all IDF versions (always an external component)
#ifdef USE_ETHERNET_CH390
#include "esp_eth_mac_ch390.h"
#include "esp_eth_phy_ch390.h"
#endif
 
#ifdef USE_ETHERNET_SPI
#include <driver/gpio.h>
#include <driver/spi_master.h>
#ifdef USE_SPI
#include "esphome/components/spi/spi.h"
#endif
#endif
 
namespace esphome::ethernet {
 
ESPHOME_LOG_TAG(TAG, "ethernet");
 
// PHY register size for hex logging
static constexpr size_t PHY_REG_SIZE = 2;
 
// Dual wifi + ethernet SPI builds: the one place internal RAM is short and lwip's other buffers are
// already in PSRAM. Not with L2 TAP, whose filter lives in the glue's input path this replaces.
#if defined(USE_PSRAM) && defined(USE_ETHERNET_SPI) && defined(USE_WIFI) && !defined(CONFIG_ESP_NETIF_L2_TAP)
#define USE_ETHERNET_RX_PSRAM
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - reported by dump_config()
static bool rx_psram_installed = false;
 
// ESP-IDF ethernet drivers malloc() every received frame in internal RAM, where it stays until lwIP
// hands it to the application. Move it to PSRAM; if that fails the frame is passed on where it is.
static esp_err_t eth_input_to_psram(esp_eth_handle_t handle, uint8_t *buffer, uint32_t length, void *priv) {
  auto *copy = static_cast<uint8_t *>(heap_caps_malloc(length, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
  if (copy != nullptr) {
    memcpy(copy, buffer, length);
    free(buffer);  // NOLINT(cppcoreguidelines-no-malloc) - allocated by the driver with malloc()
    buffer = copy;
  } else {
    static bool warned = false;  // once, this runs per frame in the driver's task
    if (!warned) {
      warned = true;
      ESP_LOGW(TAG, "PSRAM allocation failed, frame kept in internal RAM (reported once)");
    }
  }
  return esp_netif_receive(static_cast<esp_netif_t *>(priv), buffer, length, nullptr);
}
#endif
 
void EthernetComponent::log_error_and_mark_failed_(esp_err_t err, const char *message) {
  ESP_LOGE(TAG, "%s: (%d) %s", message, err, esp_err_to_name(err));
  this->mark_failed();
}
 
#define ESPHL_ERROR_CHECK(err, message) \
  if ((err) != ESP_OK) { \
    this->log_error_and_mark_failed_(err, message); \
    return; \
  }
 
#define ESPHL_ERROR_CHECK_RET(err, message, ret) \
  if ((err) != ESP_OK) { \
    this->log_error_and_mark_failed_(err, message); \
    return ret; \
  }
 
void EthernetComponent::loop() {
  const uint32_t now = App.get_loop_component_start_time();
 
  switch (this->state_) {
    case EthernetComponentState::STOPPED:
      if (this->started_) {
        ESP_LOGI(TAG, "Starting connection");
        this->state_ = EthernetComponentState::CONNECTING;
        this->start_connect_();
      }
      break;
    case EthernetComponentState::CONNECTING:
      if (!this->started_) {
        ESP_LOGI(TAG, "Stopped connection");
        this->state_ = EthernetComponentState::STOPPED;
      } else if (this->connected_) {
        // connection established
        ESP_LOGI(TAG, "Connected");
        this->state_ = EthernetComponentState::CONNECTED;
 
        this->dump_connect_params_();
        this->status_clear_warning();
#ifdef USE_ETHERNET_CONNECT_TRIGGER
        this->connect_trigger_.trigger();
#endif
      } else if (now - this->connect_begin_ > 15000) {
        ESP_LOGW(TAG, "Connecting failed; reconnecting");
        this->start_connect_();
      }
      break;
    case EthernetComponentState::CONNECTED:
      if (!this->started_) {
        ESP_LOGI(TAG, "Stopped connection");
        this->state_ = EthernetComponentState::STOPPED;
#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
        this->disconnect_trigger_.trigger();
#endif
      } else if (!this->connected_) {
        ESP_LOGW(TAG, "Connection lost; reconnecting");
        this->state_ = EthernetComponentState::CONNECTING;
        this->start_connect_();
#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
        this->disconnect_trigger_.trigger();
#endif
      } else {
        this->finish_connect_();
        // When connected and stable, disable the loop to save CPU cycles
        this->disable_loop();
      }
      break;
  }
}
 
void EthernetComponent::setup() {
  if (esp_reset_reason() != ESP_RST_DEEPSLEEP) {
    // Delay here to allow power to stabilise before Ethernet is initialized.
    delay(300);  // NOLINT
  }
 
  if (this->enable_on_boot_) {
    this->ethernet_lazy_init_();
    if (!this->ethernet_initialized_) {
      // lazy_init bailed early via ESPHL_ERROR_CHECK or mark_failed; nothing more to do.
      return;
    }
    esp_err_t err = esp_eth_start(this->eth_handle_);
    ESPHL_ERROR_CHECK(err, "ETH start error");
  } else {
    ESP_LOGCONFIG(TAG, "Skipping init (enable_on_boot: false)");
    this->disabled_ = true;
  }
}
 
void EthernetComponent::ethernet_lazy_init_() {
  if (this->ethernet_initialized_)
    return;
 
  esp_err_t err;
 
#ifdef USE_ETHERNET_SPI
  // Install GPIO ISR handler to be able to service SPI Eth modules interrupts
  gpio_install_isr_service(0);
 
  spi_host_device_t host;
#ifdef USE_SPI
  if (this->spi_parent_ != nullptr) {
    // The bus is owned and already initialized by the spi component; share its host.
    host = this->spi_parent_->get_interface();
  } else
#endif
  {
    spi_bus_config_t buscfg = {
        .mosi_io_num = this->mosi_pin_,
        .miso_io_num = this->miso_pin_,
        .sclk_io_num = this->clk_pin_,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .data4_io_num = -1,
        .data5_io_num = -1,
        .data6_io_num = -1,
        .data7_io_num = -1,
        .max_transfer_sz = 0,
        .flags = 0,
        .intr_flags = 0,
    };
 
    host = this->interface_;
 
    err = spi_bus_initialize(host, &buscfg, SPI_DMA_CH_AUTO);
    ESPHL_ERROR_CHECK(err, "SPI bus initialize error");
  }
#endif
  // Network interface setup handled by network component
 
  esp_netif_config_t cfg = ESP_NETIF_DEFAULT_ETH();
  this->eth_netif_ = esp_netif_new(&cfg);
 
  // Init MAC and PHY configs to default
  eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
  eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
 
#ifdef USE_ETHERNET_SPI  // Configure SPI interface and Ethernet driver for specific SPI module
  spi_device_interface_config_t devcfg = {
      .command_bits = 0,
      .address_bits = 0,
      .dummy_bits = 0,
      .mode = 0,
      .duty_cycle_pos = 0,
      .cs_ena_pretrans = 0,
      .cs_ena_posttrans = 0,
      .clock_speed_hz = this->clock_speed_,
      .input_delay_ns = 0,
      .spics_io_num = this->cs_pin_,
      .flags = 0,
      .queue_size = 20,
      .pre_cb = nullptr,
      .post_cb = nullptr,
  };
 
#if defined(USE_ETHERNET_W5500)
  eth_w5500_config_t w5500_config = ETH_W5500_DEFAULT_CONFIG(host, &devcfg);
#elif defined(USE_ETHERNET_DM9051)
  eth_dm9051_config_t dm9051_config = ETH_DM9051_DEFAULT_CONFIG(host, &devcfg);
#elif defined(USE_ETHERNET_ENC28J60)
  eth_enc28j60_config_t enc28j60_config = ETH_ENC28J60_DEFAULT_CONFIG(host, &devcfg);
#elif defined(USE_ETHERNET_CH390)
  eth_ch390_config_t ch390_config = ETH_CH390_DEFAULT_CONFIG(host, &devcfg);
#elif defined(USE_ETHERNET_KSZ8851SNL)
  eth_ksz8851snl_config_t ksz8851snl_config = ETH_KSZ8851SNL_DEFAULT_CONFIG(host, &devcfg);
#endif
 
#if defined(USE_ETHERNET_W5500)
  w5500_config.int_gpio_num = this->interrupt_pin_;
#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  w5500_config.poll_period_ms = this->polling_interval_;
#endif
  // Install the custom SPI driver that offloads the bulk RX/TX frame transfers off the busy-wait
  // path. w5500_config (and the devcfg it references) outlives esp_eth_mac_new_w5500() below, which
  // runs the driver's init().
  install_w5500_async_spi(w5500_config);
#elif defined(USE_ETHERNET_DM9051)
  dm9051_config.int_gpio_num = this->interrupt_pin_;
#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  dm9051_config.poll_period_ms = this->polling_interval_;
#endif
#elif defined(USE_ETHERNET_ENC28J60)
  // ENC28J60 does not support poll_period_ms. CS must stay asserted for the chip's CS hold
  // time (t10, 210 ns) after the last clock or MAC/MII register reads fail ("wrong chip ID")
  enc28j60_config.spi_devcfg->cs_ena_posttrans = enc28j60_cal_spi_cs_hold_time((this->clock_speed_ + 999999) / 1000000);
  enc28j60_config.int_gpio_num = this->interrupt_pin_;
#elif defined(USE_ETHERNET_CH390)
  ch390_config.int_gpio_num = this->interrupt_pin_;
#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  ch390_config.poll_period_ms = this->polling_interval_;
#endif
#elif defined(USE_ETHERNET_KSZ8851SNL)
  ksz8851snl_config.int_gpio_num = this->interrupt_pin_;
#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  ksz8851snl_config.poll_period_ms = this->polling_interval_;
#endif
#endif
 
  phy_config.phy_addr = this->phy_addr_spi_;
  phy_config.reset_gpio_num = this->reset_pin_;
 
  esp_eth_mac_t *mac = nullptr;
#elif defined(USE_ETHERNET_OPENETH)
  esp_eth_mac_t *mac = esp_eth_mac_new_openeth(&mac_config);
#else
  phy_config.phy_addr = this->phy_addr_;
  phy_config.reset_gpio_num = this->power_pin_;
 
  eth_esp32_emac_config_t esp32_emac_config = eth_esp32_emac_default_config();
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
  esp32_emac_config.smi_gpio.mdc_num = this->mdc_pin_;
  esp32_emac_config.smi_gpio.mdio_num = this->mdio_pin_;
#else
  esp32_emac_config.smi_mdc_gpio_num = this->mdc_pin_;
  esp32_emac_config.smi_mdio_gpio_num = this->mdio_pin_;
#endif
  // The RGMII types (GENERIC, YT8531) use the RGMII interface and default GPIO map from
  // eth_esp32_emac_default_config(); writing the RMII clock config would clobber that
  // union, so skip the RMII clock override for them.
  if (this->type_ != ETHERNET_TYPE_GENERIC && this->type_ != ETHERNET_TYPE_YT8531) {
    esp32_emac_config.clock_config.rmii.clock_mode = this->clk_mode_;
    esp32_emac_config.clock_config.rmii.clock_gpio =
        static_cast<decltype(esp32_emac_config.clock_config.rmii.clock_gpio)>(this->clk_pin_);
  }
 
  esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
#endif
 
  switch (this->type_) {
#ifdef USE_ETHERNET_OPENETH
    case ETHERNET_TYPE_OPENETH: {
      phy_config.autonego_timeout_ms = 1000;
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
      this->phy_ = esp_eth_phy_new_generic(&phy_config);
#else
      this->phy_ = esp_eth_phy_new_dp83848(&phy_config);
#endif
      break;
    }
#endif
#if CONFIG_ETH_USE_ESP32_EMAC
#ifdef USE_ETHERNET_LAN8720
    case ETHERNET_TYPE_LAN8720: {
      this->phy_ = esp_eth_phy_new_lan87xx(&phy_config);
      break;
    }
#endif
#ifdef USE_ETHERNET_RTL8201
    case ETHERNET_TYPE_RTL8201: {
      this->phy_ = esp_eth_phy_new_rtl8201(&phy_config);
      break;
    }
#endif
#ifdef USE_ETHERNET_DP83848
    case ETHERNET_TYPE_DP83848: {
      this->phy_ = esp_eth_phy_new_dp83848(&phy_config);
      break;
    }
#endif
#ifdef USE_ETHERNET_IP101
    case ETHERNET_TYPE_IP101: {
      this->phy_ = esp_eth_phy_new_ip101(&phy_config);
      break;
    }
#endif
#ifdef USE_ETHERNET_JL1101
    case ETHERNET_TYPE_JL1101: {
      // PlatformIO (pioarduino): builtin esp_eth_phy_new_jl1101() on all IDF versions
      // Non-PlatformIO: custom ESPHome driver (esp_eth_phy_jl1101.c)
      this->phy_ = esp_eth_phy_new_jl1101(&phy_config);
      break;
    }
#endif
#ifdef USE_ETHERNET_KSZ8081
    case ETHERNET_TYPE_KSZ8081:
    case ETHERNET_TYPE_KSZ8081RNA: {
      this->phy_ = esp_eth_phy_new_ksz80xx(&phy_config);
      break;
    }
#endif
#ifdef USE_ETHERNET_LAN8670
    case ETHERNET_TYPE_LAN8670: {
      this->phy_ = esp_eth_phy_new_lan867x(&phy_config);
      break;
    }
#endif
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
    // GENERIC and YT8531 both use the built-in generic 802.3 PHY driver; YT8531 gets
    // extra chip-specific tuning applied later in ethernet_lazy_init_().
#ifdef USE_ETHERNET_GENERIC
    case ETHERNET_TYPE_GENERIC:
#endif
#ifdef USE_ETHERNET_YT8531
    case ETHERNET_TYPE_YT8531:
#endif
#if defined(USE_ETHERNET_GENERIC) || defined(USE_ETHERNET_YT8531)
      this->phy_ = esp_eth_phy_new_generic(&phy_config);
      break;
#endif
#endif
#endif
#ifdef USE_ETHERNET_SPI
#if defined(USE_ETHERNET_W5500)
    case ETHERNET_TYPE_W5500: {
      mac = esp_eth_mac_new_w5500(&w5500_config, &mac_config);
      this->phy_ = esp_eth_phy_new_w5500(&phy_config);
      break;
    }
#elif defined(USE_ETHERNET_DM9051)
    case ETHERNET_TYPE_DM9051: {
      mac = esp_eth_mac_new_dm9051(&dm9051_config, &mac_config);
      this->phy_ = esp_eth_phy_new_dm9051(&phy_config);
      break;
    }
#elif defined(USE_ETHERNET_ENC28J60)
    case ETHERNET_TYPE_ENC28J60: {
      mac = esp_eth_mac_new_enc28j60(&enc28j60_config, &mac_config);
      this->phy_ = esp_eth_phy_new_enc28j60(&phy_config);
      break;
    }
#elif defined(USE_ETHERNET_CH390)
    case ETHERNET_TYPE_CH390: {
      mac = esp_eth_mac_new_ch390(&ch390_config, &mac_config);
      this->phy_ = esp_eth_phy_new_ch390(&phy_config);
      break;
    }
#elif defined(USE_ETHERNET_KSZ8851SNL)
    case ETHERNET_TYPE_KSZ8851SNL: {
      mac = esp_eth_mac_new_ksz8851snl(&ksz8851snl_config, &mac_config);
      this->phy_ = esp_eth_phy_new_ksz8851snl(&phy_config);
      break;
    }
#endif
#endif
    default: {
      this->mark_failed();
      return;
    }
  }
 
  esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(mac, this->phy_);
  this->eth_handle_ = nullptr;
  err = esp_eth_driver_install(&eth_config, &this->eth_handle_);
  ESPHL_ERROR_CHECK(err, "ETH driver install error");
 
#ifndef USE_ETHERNET_SPI
#ifdef USE_ETHERNET_KSZ8081
  if (this->type_ == ETHERNET_TYPE_KSZ8081RNA && this->clk_mode_ == EMAC_CLK_OUT) {
    // KSZ8081RNA default is incorrect. It expects a 25MHz clock instead of the 50MHz we provide.
    this->ksz8081_set_clock_reference_(mac);
  }
#endif  // USE_ETHERNET_KSZ8081
 
#ifdef ESPHOME_ETHERNET_PHY_REGISTER_COUNT
  for (const auto &phy_register : this->phy_registers_) {
    this->write_phy_register_(mac, phy_register);
  }
#endif
 
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
#ifdef USE_ETHERNET_GENERIC
  // The generic 802.3 PHY driver only resets the PHY in its init; it never enables
  // auto-negotiation. A PHY that resets into a forced-speed mode (BMCR auto-nego bit
  // clear) therefore stays there, and esp_eth_start() skips negotiation because the
  // driver cached auto_nego_en=false at install time. Force auto-negotiation on here
  // (which also updates that cached state) so esp_eth_start() restarts a proper
  // negotiation. (YT8531 does this as part of its own chip-specific init below.)
  if (this->type_ == ETHERNET_TYPE_GENERIC) {
    bool autoneg_enable = true;
    err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_S_AUTONEGO, &autoneg_enable);
    ESPHL_ERROR_CHECK(err, "Enable auto-negotiation failed");
  }
#endif
#ifdef USE_ETHERNET_YT8531
  if (this->type_ == ETHERNET_TYPE_YT8531) {
    this->yt8531_phy_init_();
    if (this->is_failed())
      return;
  }
#endif
#endif  // ESP_IDF_VERSION >= 6.0.0
#endif  // !USE_ETHERNET_SPI
 
  // use ESP internal eth mac
  uint8_t mac_addr[MAC_ADDRESS_SIZE];
  if (this->fixed_mac_.has_value()) {
    memcpy(mac_addr, this->fixed_mac_->data(), MAC_ADDRESS_SIZE);
  } else {
    esp_read_mac(mac_addr, ESP_MAC_ETH);
  }
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_S_MAC_ADDR, mac_addr);
  ESPHL_ERROR_CHECK(err, "set mac address error");
 
  /* attach Ethernet driver to TCP/IP stack */
  err = esp_netif_attach(this->eth_netif_, esp_eth_new_netif_glue(this->eth_handle_));
  ESPHL_ERROR_CHECK(err, "ETH netif attach error");
#ifdef USE_ETHERNET_RX_PSRAM
  // The glue frees every receive buffer with free(), so the replacement buffer must come from the heap
  if (esp_psram_is_initialized()) {
    err = esp_eth_update_input_path(this->eth_handle_, eth_input_to_psram, this->eth_netif_);
    rx_psram_installed = err == ESP_OK;
    if (!rx_psram_installed) {
      ESP_LOGW(TAG, "PSRAM RX path not installed: %s", esp_err_to_name(err));
    }
  }
#endif
#if USE_NETWORK_IPV6 && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
  // Since IDF 5.5 the internal EMAC drops multicast groups that were never added (before,
  // it passed all multicast), and lwIP never adds all-nodes, so router advertisements
  // were lost and SLAAC never ran.
  {
    uint8_t all_nodes[6] = {0x33, 0x33, 0x00, 0x00, 0x00, 0x01};
    if (esp_err_t filter_err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_ADD_MAC_FILTER, all_nodes);
        filter_err != ESP_OK) {
      ESP_LOGD(TAG, "IPv6 all-nodes multicast filter not added: %s", esp_err_to_name(filter_err));
    }
  }
#endif
 
  // Register user defined event handers
  err = esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, &EthernetComponent::eth_event_handler, nullptr);
  ESPHL_ERROR_CHECK(err, "ETH event handler register error");
  err = esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &EthernetComponent::got_ip_event_handler, nullptr);
  ESPHL_ERROR_CHECK(err, "GOT IP event handler register error");
#if USE_NETWORK_IPV6
  err = esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, &EthernetComponent::got_ip6_event_handler, nullptr);
  ESPHL_ERROR_CHECK(err, "GOT IPv6 event handler register error");
#endif /* USE_NETWORK_IPV6 */
 
  this->ethernet_initialized_ = true;
}
 
void EthernetComponent::enable() {
  if (!this->disabled_)
    return;
 
  ESP_LOGD(TAG, "Enabling");
  this->ethernet_lazy_init_();
  if (!this->ethernet_initialized_) {
    ESP_LOGE(TAG, "Cannot enable - init failed");
    return;
  }
  esp_err_t err = esp_eth_start(this->eth_handle_);
  if (err != ESP_OK) {
    ESP_LOGE(TAG, "esp_eth_start failed: %s", esp_err_to_name(err));
    return;
  }
  this->disabled_ = false;
  // The ETH_EVENT_START handler will set started_=true; the loop state machine
  // will then drive the STOPPED -> CONNECTING -> CONNECTED transitions.
  this->enable_loop();
}
 
void EthernetComponent::disable() {
  if (this->disabled_)
    return;
 
  ESP_LOGD(TAG, "Disabling");
  esp_err_t err = esp_eth_stop(this->eth_handle_);
  if (err != ESP_OK) {
    ESP_LOGW(TAG, "esp_eth_stop failed: %s — disabling anyway", esp_err_to_name(err));
  }
  this->disabled_ = true;
  // ETH_EVENT_STOP will clear started_; loop() will transition to STOPPED.
}
 
void EthernetComponent::dump_config() {
  const char *eth_type;
  switch (this->type_) {
#ifdef USE_ETHERNET_LAN8720
    case ETHERNET_TYPE_LAN8720:
      eth_type = "LAN8720";
      break;
#endif
#ifdef USE_ETHERNET_RTL8201
    case ETHERNET_TYPE_RTL8201:
      eth_type = "RTL8201";
      break;
#endif
#ifdef USE_ETHERNET_DP83848
    case ETHERNET_TYPE_DP83848:
      eth_type = "DP83848";
      break;
#endif
#ifdef USE_ETHERNET_IP101
    case ETHERNET_TYPE_IP101:
      eth_type = "IP101";
      break;
#endif
#ifdef USE_ETHERNET_JL1101
    case ETHERNET_TYPE_JL1101:
      eth_type = "JL1101";
      break;
#endif
#ifdef USE_ETHERNET_KSZ8081
    case ETHERNET_TYPE_KSZ8081:
      eth_type = "KSZ8081";
      break;
 
    case ETHERNET_TYPE_KSZ8081RNA:
      eth_type = "KSZ8081RNA";
      break;
#endif
#if defined(USE_ETHERNET_W5500)
    case ETHERNET_TYPE_W5500:
      eth_type = "W5500";
      break;
#elif defined(USE_ETHERNET_DM9051)
    case ETHERNET_TYPE_DM9051:
      eth_type = "DM9051";
      break;
#elif defined(USE_ETHERNET_ENC28J60)
    case ETHERNET_TYPE_ENC28J60:
      eth_type = "ENC28J60";
      break;
#elif defined(USE_ETHERNET_CH390)
    case ETHERNET_TYPE_CH390:
      eth_type = "CH390";
      break;
#elif defined(USE_ETHERNET_KSZ8851SNL)
    case ETHERNET_TYPE_KSZ8851SNL:
      eth_type = "KSZ8851SNL";
      break;
#endif
#ifdef USE_ETHERNET_OPENETH
    case ETHERNET_TYPE_OPENETH:
      eth_type = "OPENETH";
      break;
#endif
#ifdef USE_ETHERNET_LAN8670
    case ETHERNET_TYPE_LAN8670:
      eth_type = "LAN8670";
      break;
#endif
#ifdef USE_ETHERNET_GENERIC
    case ETHERNET_TYPE_GENERIC:
      eth_type = "Generic (RGMII)";
      break;
#endif
#ifdef USE_ETHERNET_YT8531
    case ETHERNET_TYPE_YT8531:
      eth_type = "YT8531 (RGMII)";
      break;
#endif
 
    default:
      eth_type = "Unknown";
      break;
  }
 
  ESP_LOGCONFIG(TAG,
                "Ethernet:\n"
                "  Connected: %s",
                YESNO(this->is_connected()));
  this->dump_connect_params_();
#ifdef USE_ETHERNET_SPI
#ifdef USE_SPI
  if (this->spi_parent_ != nullptr) {
    // Pins and interface come from the shared spi bus; only CS is ours.
    ESP_LOGCONFIG(TAG, "  CS Pin: %u", this->cs_pin_);
  } else
#endif
  {
    ESP_LOGCONFIG(TAG,
                  "  CLK Pin: %u\n"
                  "  MISO Pin: %u\n"
                  "  MOSI Pin: %u\n"
                  "  CS Pin: %u",
                  this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_);
    const char *spi_interface = "spi3";
    if (this->interface_ == SPI2_HOST) {
      spi_interface = "spi2";
    }
    ESP_LOGCONFIG(TAG, "  Interface: %s", spi_interface);
  }
#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  if (this->polling_interval_ != 0) {
    ESP_LOGCONFIG(TAG, "  Polling Interval: %" PRIu32 " ms", this->polling_interval_);
  } else
#endif
  {
    ESP_LOGCONFIG(TAG, "  IRQ Pin: %d", this->interrupt_pin_);
  }
  ESP_LOGCONFIG(TAG,
                "  Reset Pin: %d\n"
                "  Clock Speed: %d MHz",
                this->reset_pin_, this->clock_speed_ / 1000000);
#else
  if (this->power_pin_ != -1) {
    ESP_LOGCONFIG(TAG, "  Power Pin: %u", this->power_pin_);
  }
  ESP_LOGCONFIG(TAG,
                "  CLK Pin: %u\n"
                "  MDC Pin: %u\n"
                "  MDIO Pin: %u\n"
                "  PHY addr: %u",
                this->clk_pin_, this->mdc_pin_, this->mdio_pin_, this->phy_addr_);
#endif
  ESP_LOGCONFIG(TAG, "  Type: %s", eth_type);
#ifdef USE_ETHERNET_RX_PSRAM
  // Only known once the driver is up; with enable_on_boot: false that is after this dump
  if (this->ethernet_initialized_) {
    ESP_LOGCONFIG(TAG, "  RX frames: %s",
                  rx_psram_installed ? LOG_STR_LITERAL("PSRAM") : LOG_STR_LITERAL("internal RAM"));
  }
#endif
}
 
network::IPAddresses EthernetComponent::get_ip_addresses() {
  network::IPAddresses addresses;
  if (!this->ethernet_initialized_)
    return addresses;  // all-zero IPs
  esp_netif_ip_info_t ip;
  esp_err_t err = esp_netif_get_ip_info(this->eth_netif_, &ip);
  if (err != ESP_OK) {
    ESP_LOGV(TAG, "esp_netif_get_ip_info failed: %s", esp_err_to_name(err));
    // TODO: do something smarter
    // return false;
  } else {
    addresses[0] = network::IPAddress(&ip.ip);
  }
#if USE_NETWORK_IPV6
  network::fill_ip6_addresses(this->eth_netif_, addresses);
#endif /* USE_NETWORK_IPV6 */
 
  return addresses;
}
 
network::IPAddress EthernetComponent::get_dns_address(uint8_t num) {
  LwIPLock lock;
  const ip_addr_t *dns_ip = dns_getserver(num);
  return dns_ip;
}
 
void EthernetComponent::eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event, void *event_data) {
  const char *event_name;
 
  switch (event) {
    case ETHERNET_EVENT_START:
      event_name = "ETH started";
      global_eth_component->started_ = true;
      global_eth_component->enable_loop_soon_any_context();
      break;
    case ETHERNET_EVENT_STOP:
      event_name = "ETH stopped";
      global_eth_component->started_ = false;
      global_eth_component->connected_ = false;
      global_eth_component->enable_loop_soon_any_context();  // Enable loop when connection state changes
      break;
    case ETHERNET_EVENT_CONNECTED:
      event_name = "ETH connected";
      // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
#if defined(USE_ETHERNET_IP_STATE_LISTENERS) && defined(USE_ETHERNET_MANUAL_IP)
      if (global_eth_component->manual_ip_.has_value()) {
        global_eth_component->notify_ip_state_listeners_();
      }
#endif
#if USE_NETWORK_IPV6
      // Start SLAAC on link-up, not after the DHCPv4 lease. This also restores the
      // link-local after a link flap, which clears the IPv6 addresses.
      if (esp_err_t ll_err = esp_netif_create_ip6_linklocal(global_eth_component->eth_netif_); ll_err != ESP_OK) {
        ESP_LOGW(TAG, "esp_netif_create_ip6_linklocal failed on link-up: %s", esp_err_to_name(ll_err));
      }
#endif /* USE_NETWORK_IPV6 */
      break;
    case ETHERNET_EVENT_DISCONNECTED:
      event_name = "ETH disconnected";
      global_eth_component->connected_ = false;
      global_eth_component->enable_loop_soon_any_context();  // Enable loop when connection state changes
      break;
    default:
      return;
  }
 
  ESP_LOGV(TAG, "[Ethernet event] %s (num=%" PRId32 ")", event_name, event);
}
 
void EthernetComponent::got_ip_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id,
                                             void *event_data) {
  ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
  const esp_netif_ip_info_t *ip_info = &event->ip_info;
  ESP_LOGV(TAG, "[Ethernet event] ETH Got IP " IPSTR, IP2STR(&ip_info->ip));
  global_eth_component->got_ipv4_address_ = true;
#if USE_NETWORK_IPV6 && (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
  global_eth_component->connected_ = global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT;
  global_eth_component->enable_loop_soon_any_context();  // Enable loop when connection state changes
#else
  global_eth_component->connected_ = true;
  global_eth_component->enable_loop_soon_any_context();  // Enable loop when connection state changes
#endif /* USE_NETWORK_IPV6 */
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
  global_eth_component->notify_ip_state_listeners_();
#endif
}
 
#if USE_NETWORK_IPV6
void EthernetComponent::got_ip6_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id,
                                              void *event_data) {
  ip_event_got_ip6_t *event = (ip_event_got_ip6_t *) event_data;
  ESP_LOGV(TAG, "[Ethernet event] ETH Got IPv6: " IPV6STR, IPV62STR(event->ip6_info.ip));
  // Count the addresses on the interface, not the events: recreating the link-local
  // after a link flap fires another event for the same address.
  struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
  global_eth_component->ipv6_count_ = esp_netif_get_all_ip6(global_eth_component->eth_netif_, if_ip6s);
#if (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
  global_eth_component->connected_ =
      global_eth_component->got_ipv4_address_ && (global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT);
  global_eth_component->enable_loop_soon_any_context();  // Enable loop when connection state changes
#else
  global_eth_component->connected_ = global_eth_component->got_ipv4_address_;
  global_eth_component->enable_loop_soon_any_context();  // Enable loop when connection state changes
#endif
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
  global_eth_component->notify_ip_state_listeners_();
#endif
}
#endif /* USE_NETWORK_IPV6 */
 
#if USE_NETWORK_IPV6
// Create the link-local address unless the interface already has one, including one still in
// duplicate address detection: recreating it would restart DAD. esp_netif_get_ip6_linklocal()
// only reports a preferred address, so ask lwIP for the slot state instead.
esp_err_t EthernetComponent::ensure_ip6_linklocal_() {
  if (auto *netif = static_cast<struct netif *>(esp_netif_get_netif_impl(this->eth_netif_)); netif != nullptr) {
    u8_t state;
    {
      LwIPLock lock;
      state = netif_ip6_addr_state(netif, 0);
    }
    if (ip6_addr_istentative(state) || ip6_addr_isvalid(state)) {
      return ESP_OK;
    }
  }
  esp_err_t err = esp_netif_create_ip6_linklocal(this->eth_netif_);
  if (err == ESP_OK) {
    ESP_LOGD(TAG, "IPv6 link-local address created");
  }
  return err;
}
#endif /* USE_NETWORK_IPV6 */
 
void EthernetComponent::finish_connect_() {
#if USE_NETWORK_IPV6
  // Retry IPv6 link-local setup if it failed during initial connect
  // This handles the case where min_ipv6_addr_count is NOT set (or is 0),
  // allowing us to reach CONNECTED state with just IPv4.
  // If IPv6 setup failed in start_connect_() because the interface wasn't ready:
  // - Bootup timing issues (#10281)
  // - Cable unplugged/network interruption (#10705)
  // We can now retry since we're in CONNECTED state and the interface is definitely up.
  if (!this->ipv6_setup_done_) {
    this->ensure_ip6_linklocal_();
    // Always set the flag to prevent continuous retries
    // If IPv6 setup fails here with the interface up and stable, it's
    // likely a persistent issue (IPv6 disabled at router, hardware
    // limitation, etc.) that won't be resolved by further retries.
    // The device continues to work with IPv4.
    this->ipv6_setup_done_ = true;
  }
#endif /* USE_NETWORK_IPV6 */
}
 
void EthernetComponent::start_connect_() {
  global_eth_component->got_ipv4_address_ = false;
#if USE_NETWORK_IPV6
  // Recount rather than zero: addresses that survive a reconnect are not announced again.
  struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
  global_eth_component->ipv6_count_ = esp_netif_get_all_ip6(this->eth_netif_, if_ip6s);
  this->ipv6_setup_done_ = false;
#endif /* USE_NETWORK_IPV6 */
  this->connect_begin_ = millis();
  this->status_set_warning(LOG_STR("waiting for IP configuration"));
 
  esp_err_t err;
  err = esp_netif_set_hostname(this->eth_netif_, App.get_name().c_str());
  if (err != ERR_OK) {
    ESP_LOGW(TAG, "esp_netif_set_hostname failed: %s", esp_err_to_name(err));
  }
 
  esp_netif_ip_info_t info;
#ifdef USE_ETHERNET_MANUAL_IP
  if (this->manual_ip_.has_value()) {
    info.ip = this->manual_ip_->static_ip;
    info.gw = this->manual_ip_->gateway;
    info.netmask = this->manual_ip_->subnet;
  } else
#endif
  {
    info.ip.addr = 0;
    info.gw.addr = 0;
    info.netmask.addr = 0;
  }
 
  esp_netif_dhcp_status_t status = ESP_NETIF_DHCP_INIT;
 
  err = esp_netif_dhcpc_get_status(this->eth_netif_, &status);
  ESPHL_ERROR_CHECK(err, "DHCPC Get Status Failed!");
 
  ESP_LOGV(TAG, "DHCP Client Status: %d", status);
 
  err = esp_netif_dhcpc_stop(this->eth_netif_);
  if (err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STOPPED) {
    ESPHL_ERROR_CHECK(err, "DHCPC stop error");
  }
 
  err = esp_netif_set_ip_info(this->eth_netif_, &info);
  ESPHL_ERROR_CHECK(err, "DHCPC set IP info error");
 
#ifdef USE_ETHERNET_MANUAL_IP
  if (this->manual_ip_.has_value()) {
    // Set DNS through esp_netif so the servers are stored in the netif's own
    // dns[] array; raw dns_setserver() would be lost when the default-route
    // arbitration re-applies the default netif's DNS.
    // Log-only on failure: the link still has a working IP/gateway, so degraded
    // name resolution does not justify marking the whole component failed.
    esp_netif_dns_info_t dns{};
    if (this->manual_ip_->dns1.is_set()) {
      dns.ip = this->manual_ip_->dns1;
      err = esp_netif_set_dns_info(this->eth_netif_, ESP_NETIF_DNS_MAIN, &dns);
      if (err != ESP_OK) {
        ESP_LOGE(TAG, "Set main DNS failed: %s", esp_err_to_name(err));
      }
    }
    if (this->manual_ip_->dns2.is_set()) {
      dns.ip = this->manual_ip_->dns2;
      err = esp_netif_set_dns_info(this->eth_netif_, ESP_NETIF_DNS_BACKUP, &dns);
      if (err != ESP_OK) {
        ESP_LOGE(TAG, "Set backup DNS failed: %s", esp_err_to_name(err));
      }
    }
  } else
#endif
  {
    err = esp_netif_dhcpc_start(this->eth_netif_);
    if (err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STARTED) {
      ESPHL_ERROR_CHECK(err, "DHCPC start error");
    }
  }
#if USE_NETWORK_IPV6
  // Attempt to create IPv6 link-local address
  // We MUST attempt this here, not just in finish_connect_(), because with
  // min_ipv6_addr_count set, the component won't reach CONNECTED state without IPv6.
  // However, this may fail with ESP_FAIL if the interface is not up yet:
  // - At bootup when link isn't ready (#10281)
  // - After disconnection/cable unplugged (#10705)
  // We'll retry in finish_connect_() if it fails here.
  err = this->ensure_ip6_linklocal_();
  if (err != ESP_OK) {
    if (err == ESP_ERR_ESP_NETIF_INVALID_PARAMS) {
      // This is a programming error, not a transient failure
      ESPHL_ERROR_CHECK(err, "esp_netif_create_ip6_linklocal invalid parameters");
    } else {
      // ESP_FAIL means the interface isn't up yet
      // This is expected and non-fatal, happens in multiple scenarios:
      // - During reconnection after network interruptions (#10705)
      // - At bootup when the link isn't ready yet (#10281)
      // We'll retry once we reach CONNECTED state and the interface is up
      ESP_LOGW(TAG, "esp_netif_create_ip6_linklocal failed: %s", esp_err_to_name(err));
      // Don't mark component as failed - this is a transient error
    }
  }
#endif /* USE_NETWORK_IPV6 */
 
  this->connect_begin_ = millis();
  this->status_set_warning();
}
 
void EthernetComponent::dump_connect_params_() {
  if (!this->ethernet_initialized_) {
    ESP_LOGCONFIG(TAG, "  uninitialized/disabled");
    return;
  }
  esp_netif_ip_info_t ip;
  esp_netif_get_ip_info(this->eth_netif_, &ip);
  const ip_addr_t *dns_ip1;
  const ip_addr_t *dns_ip2;
  {
    LwIPLock lock;
    dns_ip1 = dns_getserver(0);
    dns_ip2 = dns_getserver(1);
  }
 
  // Use stack buffers for IP address formatting to avoid heap allocations
  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
  char subnet_buf[network::IP_ADDRESS_BUFFER_SIZE];
  char gateway_buf[network::IP_ADDRESS_BUFFER_SIZE];
  char dns1_buf[network::IP_ADDRESS_BUFFER_SIZE];
  char dns2_buf[network::IP_ADDRESS_BUFFER_SIZE];
  char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
  uint16_t link_speed = 10;
  switch (this->get_link_speed()) {
    case ETH_SPEED_100M:
      link_speed = 100;
      break;
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 1, 0)
    case ETH_SPEED_1000M:
      link_speed = 1000;
      break;
#endif
    default:
      break;
  }
  ESP_LOGCONFIG(TAG,
                "  IP Address: %s\n"
                "  Hostname: '%s'\n"
                "  Subnet: %s\n"
                "  Gateway: %s\n"
                "  DNS1: %s\n"
                "  DNS2: %s\n"
                "  MAC Address: %s\n"
                "  Is Full Duplex: %s\n"
                "  Link Speed: %u",
                network::IPAddress(&ip.ip).str_to(ip_buf), App.get_name().c_str(),
                network::IPAddress(&ip.netmask).str_to(subnet_buf), network::IPAddress(&ip.gw).str_to(gateway_buf),
                network::IPAddress(dns_ip1).str_to(dns1_buf), network::IPAddress(dns_ip2).str_to(dns2_buf),
                this->get_eth_mac_address_pretty_into_buffer(mac_buf),
                YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL), link_speed);
 
#if USE_NETWORK_IPV6
  struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
  uint8_t count = 0;
  count = esp_netif_get_all_ip6(this->eth_netif_, if_ip6s);
  assert(count <= CONFIG_LWIP_IPV6_NUM_ADDRESSES);
  for (int i = 0; i < count; i++) {
    ESP_LOGCONFIG(TAG, "  IPv6: " IPV6STR, IPV62STR(if_ip6s[i]));
  }
#endif /* USE_NETWORK_IPV6 */
}
 
void EthernetComponent::get_eth_mac_address_raw(uint8_t *mac) {
  if (!this->ethernet_initialized_) {
    // External callers (mdns, ethernet_info, etc.) may ask for the MAC before/regardless
    // of whether ethernet is enabled. Use the configured MAC if set, else the system ETH MAC.
    if (this->fixed_mac_.has_value()) {
      memcpy(mac, this->fixed_mac_->data(), MAC_ADDRESS_SIZE);
    } else {
      esp_read_mac(mac, ESP_MAC_ETH);
    }
    return;
  }
  esp_err_t err;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_G_MAC_ADDR, mac);
  ESPHL_ERROR_CHECK(err, "ETH_CMD_G_MAC error");
}
 
const char *EthernetComponent::get_eth_mac_address_pretty_into_buffer(
    std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf) {
  uint8_t mac[MAC_ADDRESS_SIZE];
  get_eth_mac_address_raw(mac);
  format_mac_addr_upper(mac, buf.data());
  return buf.data();
}
 
eth_duplex_t EthernetComponent::get_duplex_mode() {
  if (!this->ethernet_initialized_)
    return ETH_DUPLEX_HALF;
  esp_err_t err;
  eth_duplex_t duplex_mode;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_G_DUPLEX_MODE, &duplex_mode);
  ESPHL_ERROR_CHECK_RET(err, "ETH_CMD_G_DUPLEX_MODE error", ETH_DUPLEX_HALF);
  return duplex_mode;
}
 
eth_speed_t EthernetComponent::get_link_speed() {
  if (!this->ethernet_initialized_)
    return ETH_SPEED_10M;
  esp_err_t err;
  eth_speed_t speed;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_G_SPEED, &speed);
  ESPHL_ERROR_CHECK_RET(err, "ETH_CMD_G_SPEED error", ETH_SPEED_10M);
  return speed;
}
 
bool EthernetComponent::powerdown() {
  ESP_LOGI(TAG, "Powering down ethernet PHY");
  if (this->phy_ == nullptr) {
    ESP_LOGE(TAG, "Ethernet PHY not assigned");
    return false;
  }
  this->connected_ = false;
  this->started_ = false;
  // No need to enable_loop() here as this is only called during shutdown/reboot
  if (this->phy_->pwrctl(this->phy_, false) != ESP_OK) {
    ESP_LOGE(TAG, "Error powering down ethernet PHY");
    return false;
  }
  return true;
}
 
#ifndef USE_ETHERNET_SPI
 
#ifdef USE_ETHERNET_KSZ8081
constexpr uint8_t KSZ80XX_PC2R_REG_ADDR = 0x1F;
 
void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
  esp_err_t err;
 
  uint32_t phy_control_2;
  err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
  ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
  char hex_buf[format_hex_pretty_size(PHY_REG_SIZE)];
#endif
  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 
  /*
   * Bit 7 is `RMII Reference Clock Select`. Default is `0`.
   * KSZ8081RNA:
   *   0 - clock input to XI (Pin 8) is 25 MHz for RMII - 25 MHz clock mode.
   *   1 - clock input to XI (Pin 8) is 50 MHz for RMII - 50 MHz clock mode.
   * KSZ8081RND:
   *   0 - clock input to XI (Pin 8) is 50 MHz for RMII - 50 MHz clock mode.
   *   1 - clock input to XI (Pin 8) is 25 MHz (driven clock only, not a crystal) for RMII - 25 MHz clock mode.
   */
  if ((phy_control_2 & (1 << 7)) != (1 << 7)) {
    phy_control_2 |= 1 << 7;
    err = mac->write_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, phy_control_2);
    ESPHL_ERROR_CHECK(err, "Write PHY Control 2 failed");
    err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
    ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
    ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s",
              format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
  }
}
#endif  // USE_ETHERNET_KSZ8081
 
#ifdef ESPHOME_ETHERNET_PHY_REGISTER_COUNT
void EthernetComponent::write_phy_register_(esp_eth_mac_t *mac, PHYRegister register_data) {
  esp_err_t err;
 
#ifdef USE_ETHERNET_RTL8201
  constexpr uint8_t eth_phy_psr_reg_addr = 0x1F;
  if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
    ESP_LOGD(TAG, "Select PHY Register Page: 0x%02" PRIX32, register_data.page);
    err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, register_data.page);
    ESPHL_ERROR_CHECK(err, "Select PHY Register page failed");
  }
#endif
 
  ESP_LOGD(TAG, "Writing PHY reg 0x%02" PRIX32 " = 0x%04" PRIX32, register_data.address, register_data.value);
  err = mac->write_phy_reg(mac, this->phy_addr_, register_data.address, register_data.value);
  ESPHL_ERROR_CHECK(err, "Writing PHY Register failed");
 
#ifdef USE_ETHERNET_RTL8201
  if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
    ESP_LOGD(TAG, "Select PHY Register Page 0x00");
    err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, 0x0);
    ESPHL_ERROR_CHECK(err, "Select PHY Register Page 0 failed");
  }
#endif
}
#endif  // ESPHOME_ETHERNET_PHY_REGISTER_COUNT
 
#ifdef USE_ETHERNET_YT8531
void EthernetComponent::yt8531_phy_init_() {
  esp_err_t err;
 
  // The YT8531 disables auto-negotiation on hardware reset (undocumented behavior), and the
  // generic 802.3 driver only resets the PHY, so re-enable it (this also updates the driver's
  // cached auto-nego state used by esp_eth_start()).
  bool autoneg_enable = true;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_S_AUTONEGO, &autoneg_enable);
  ESPHL_ERROR_CHECK(err, "YT8531 enable auto-negotiation failed");
 
  // RGMII needs ~2 ns Tx and Rx clock delays for reliable data sampling. These are set through
  // the YT8531 extended-register interface: write the ext-register address to 0x1E, then
  // read/modify/write its value via 0x1F.
  esp_eth_phy_reg_rw_data_t phy_reg;
  uint32_t reg_val;
  phy_reg.reg_value_p = &reg_val;
 
  // RX ~2 ns coarse delay: EXT_CHIP_CONFIG (0xA001), set rxc_dly_en (bit 8).
  reg_val = 0xA001;
  phy_reg.reg_addr = 0x1E;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_WRITE_PHY_REG, &phy_reg);
  ESPHL_ERROR_CHECK(err, "YT8531 select Chip_Config failed");
  phy_reg.reg_addr = 0x1F;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_READ_PHY_REG, &phy_reg);
  ESPHL_ERROR_CHECK(err, "YT8531 read Chip_Config failed");
  reg_val |= (1U << 8);
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_WRITE_PHY_REG, &phy_reg);
  ESPHL_ERROR_CHECK(err, "YT8531 write Chip_Config failed");
 
  // TX ~2 ns delay: EXT_RGMII_CONFIG1 (0xA003), tx_delay_sel[3:0] and tx_delay_sel_fe[7:4] = 13.
  reg_val = 0xA003;
  phy_reg.reg_addr = 0x1E;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_WRITE_PHY_REG, &phy_reg);
  ESPHL_ERROR_CHECK(err, "YT8531 select RGMII_Config1 failed");
  phy_reg.reg_addr = 0x1F;
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_READ_PHY_REG, &phy_reg);
  ESPHL_ERROR_CHECK(err, "YT8531 read RGMII_Config1 failed");
  reg_val = (reg_val & ~0x00FFU) | (13U << 4) | (13U << 0);
  err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_WRITE_PHY_REG, &phy_reg);
  ESPHL_ERROR_CHECK(err, "YT8531 write RGMII_Config1 failed");
}
#endif
 
#endif
 
}  // namespace esphome::ethernet
 
#endif  // USE_ETHERNET && USE_ESP32