ESPHome 2025.6.3
Loading...
Searching...
No Matches
ethernet_component.cpp
Go to the documentation of this file.
3#include "esphome/core/log.h"
4#include "esphome/core/util.h"
5
6#ifdef USE_ESP32
7
8#include <lwip/dns.h>
9#include <cinttypes>
10#include "esp_event.h"
11
12#ifdef USE_ETHERNET_SPI
13#include <driver/gpio.h>
14#include <driver/spi_master.h>
15#endif
16
17namespace esphome {
18namespace ethernet {
19
20static const char *const TAG = "ethernet";
21
22EthernetComponent *global_eth_component; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
23
24#define ESPHL_ERROR_CHECK(err, message) \
25 if ((err) != ESP_OK) { \
26 ESP_LOGE(TAG, message ": (%d) %s", err, esp_err_to_name(err)); \
27 this->mark_failed(); \
28 return; \
29 }
30
31#define ESPHL_ERROR_CHECK_RET(err, message, ret) \
32 if ((err) != ESP_OK) { \
33 ESP_LOGE(TAG, message ": (%d) %s", err, esp_err_to_name(err)); \
34 this->mark_failed(); \
35 return ret; \
36 }
37
39
41 ESP_LOGCONFIG(TAG, "Running setup");
42 if (esp_reset_reason() != ESP_RST_DEEPSLEEP) {
43 // Delay here to allow power to stabilise before Ethernet is initialized.
44 delay(300); // NOLINT
45 }
46
47 esp_err_t err;
48
49#ifdef USE_ETHERNET_SPI
50 // Install GPIO ISR handler to be able to service SPI Eth modules interrupts
51 gpio_install_isr_service(0);
52
53 spi_bus_config_t buscfg = {
54 .mosi_io_num = this->mosi_pin_,
55 .miso_io_num = this->miso_pin_,
56 .sclk_io_num = this->clk_pin_,
57 .quadwp_io_num = -1,
58 .quadhd_io_num = -1,
59 .data4_io_num = -1,
60 .data5_io_num = -1,
61 .data6_io_num = -1,
62 .data7_io_num = -1,
63 .max_transfer_sz = 0,
64 .flags = 0,
65 .intr_flags = 0,
66 };
67
68#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || \
69 defined(USE_ESP32_VARIANT_ESP32C6)
70 auto host = SPI2_HOST;
71#else
72 auto host = SPI3_HOST;
73#endif
74
75 err = spi_bus_initialize(host, &buscfg, SPI_DMA_CH_AUTO);
76 ESPHL_ERROR_CHECK(err, "SPI bus initialize error");
77#endif
78
79 err = esp_netif_init();
80 ESPHL_ERROR_CHECK(err, "ETH netif init error");
81 err = esp_event_loop_create_default();
82 ESPHL_ERROR_CHECK(err, "ETH event loop error");
83
84 esp_netif_config_t cfg = ESP_NETIF_DEFAULT_ETH();
85 this->eth_netif_ = esp_netif_new(&cfg);
86
87 // Init MAC and PHY configs to default
88 eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
89 eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
90
91#ifdef USE_ETHERNET_SPI // Configure SPI interface and Ethernet driver for specific SPI module
92 spi_device_interface_config_t devcfg = {
93 .command_bits = 16, // Actually it's the address phase in W5500 SPI frame
94 .address_bits = 8, // Actually it's the control phase in W5500 SPI frame
95 .dummy_bits = 0,
96 .mode = 0,
97 .duty_cycle_pos = 0,
98 .cs_ena_pretrans = 0,
99 .cs_ena_posttrans = 0,
100 .clock_speed_hz = this->clock_speed_,
101 .input_delay_ns = 0,
102 .spics_io_num = this->cs_pin_,
103 .flags = 0,
104 .queue_size = 20,
105 .pre_cb = nullptr,
106 .post_cb = nullptr,
107 };
108
109#if USE_ESP_IDF && (ESP_IDF_VERSION_MAJOR >= 5)
110 eth_w5500_config_t w5500_config = ETH_W5500_DEFAULT_CONFIG(host, &devcfg);
111#else
112 spi_device_handle_t spi_handle = nullptr;
113 err = spi_bus_add_device(host, &devcfg, &spi_handle);
114 ESPHL_ERROR_CHECK(err, "SPI bus add device error");
115
116 eth_w5500_config_t w5500_config = ETH_W5500_DEFAULT_CONFIG(spi_handle);
117#endif
118 w5500_config.int_gpio_num = this->interrupt_pin_;
119#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
120 w5500_config.poll_period_ms = this->polling_interval_;
121#endif
122 phy_config.phy_addr = this->phy_addr_spi_;
123 phy_config.reset_gpio_num = this->reset_pin_;
124
125 esp_eth_mac_t *mac = esp_eth_mac_new_w5500(&w5500_config, &mac_config);
126#elif defined(USE_ETHERNET_OPENETH)
127 esp_eth_mac_t *mac = esp_eth_mac_new_openeth(&mac_config);
128#else
129 phy_config.phy_addr = this->phy_addr_;
130 phy_config.reset_gpio_num = this->power_pin_;
131
132#if ESP_IDF_VERSION_MAJOR >= 5
133 eth_esp32_emac_config_t esp32_emac_config = ETH_ESP32_EMAC_DEFAULT_CONFIG();
134 esp32_emac_config.smi_mdc_gpio_num = this->mdc_pin_;
135 esp32_emac_config.smi_mdio_gpio_num = this->mdio_pin_;
136 esp32_emac_config.clock_config.rmii.clock_mode = this->clk_mode_;
137 esp32_emac_config.clock_config.rmii.clock_gpio = this->clk_gpio_;
138
139 esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
140#else
141 mac_config.smi_mdc_gpio_num = this->mdc_pin_;
142 mac_config.smi_mdio_gpio_num = this->mdio_pin_;
143 mac_config.clock_config.rmii.clock_mode = this->clk_mode_;
144 mac_config.clock_config.rmii.clock_gpio = this->clk_gpio_;
145
146 esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&mac_config);
147#endif
148#endif
149
150 switch (this->type_) {
151#ifdef USE_ETHERNET_OPENETH
153 phy_config.autonego_timeout_ms = 1000;
154 this->phy_ = esp_eth_phy_new_dp83848(&phy_config);
155 break;
156 }
157#endif
158#if CONFIG_ETH_USE_ESP32_EMAC
160 this->phy_ = esp_eth_phy_new_lan87xx(&phy_config);
161 break;
162 }
164 this->phy_ = esp_eth_phy_new_rtl8201(&phy_config);
165 break;
166 }
168 this->phy_ = esp_eth_phy_new_dp83848(&phy_config);
169 break;
170 }
171 case ETHERNET_TYPE_IP101: {
172 this->phy_ = esp_eth_phy_new_ip101(&phy_config);
173 break;
174 }
176 this->phy_ = esp_eth_phy_new_jl1101(&phy_config);
177 break;
178 }
181#if ESP_IDF_VERSION_MAJOR >= 5
182 this->phy_ = esp_eth_phy_new_ksz80xx(&phy_config);
183#else
184 this->phy_ = esp_eth_phy_new_ksz8081(&phy_config);
185#endif
186 break;
187 }
188#endif
189#ifdef USE_ETHERNET_SPI
190 case ETHERNET_TYPE_W5500: {
191 this->phy_ = esp_eth_phy_new_w5500(&phy_config);
192 break;
193 }
194#endif
195 default: {
196 this->mark_failed();
197 return;
198 }
199 }
200
201 esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(mac, this->phy_);
202 this->eth_handle_ = nullptr;
203 err = esp_eth_driver_install(&eth_config, &this->eth_handle_);
204 ESPHL_ERROR_CHECK(err, "ETH driver install error");
205
206#ifndef USE_ETHERNET_SPI
207 if (this->type_ == ETHERNET_TYPE_KSZ8081RNA && this->clk_mode_ == EMAC_CLK_OUT) {
208 // KSZ8081RNA default is incorrect. It expects a 25MHz clock instead of the 50MHz we provide.
210 }
211
212 for (const auto &phy_register : this->phy_registers_) {
213 this->write_phy_register_(mac, phy_register);
214 }
215#endif
216
217 // use ESP internal eth mac
218 uint8_t mac_addr[6];
219 esp_read_mac(mac_addr, ESP_MAC_ETH);
220 err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_S_MAC_ADDR, mac_addr);
221 ESPHL_ERROR_CHECK(err, "set mac address error");
222
223 /* attach Ethernet driver to TCP/IP stack */
224 err = esp_netif_attach(this->eth_netif_, esp_eth_new_netif_glue(this->eth_handle_));
225 ESPHL_ERROR_CHECK(err, "ETH netif attach error");
226
227 // Register user defined event handers
228 err = esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, &EthernetComponent::eth_event_handler, nullptr);
229 ESPHL_ERROR_CHECK(err, "ETH event handler register error");
230 err = esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &EthernetComponent::got_ip_event_handler, nullptr);
231 ESPHL_ERROR_CHECK(err, "GOT IP event handler register error");
232#if USE_NETWORK_IPV6
233 err = esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, &EthernetComponent::got_ip6_event_handler, nullptr);
234 ESPHL_ERROR_CHECK(err, "GOT IPv6 event handler register error");
235#endif /* USE_NETWORK_IPV6 */
236
237 /* start Ethernet driver state machine */
238 err = esp_eth_start(this->eth_handle_);
239 ESPHL_ERROR_CHECK(err, "ETH start error");
240}
241
243 const uint32_t now = App.get_loop_component_start_time();
244
245 switch (this->state_) {
247 if (this->started_) {
248 ESP_LOGI(TAG, "Starting connection");
250 this->start_connect_();
251 }
252 break;
254 if (!this->started_) {
255 ESP_LOGI(TAG, "Stopped connection");
257 } else if (this->connected_) {
258 // connection established
259 ESP_LOGI(TAG, "Connected");
261
262 this->dump_connect_params_();
263 this->status_clear_warning();
264 } else if (now - this->connect_begin_ > 15000) {
265 ESP_LOGW(TAG, "Connecting failed; reconnecting");
266 this->start_connect_();
267 }
268 break;
270 if (!this->started_) {
271 ESP_LOGI(TAG, "Stopped connection");
273 } else if (!this->connected_) {
274 ESP_LOGW(TAG, "Connection lost; reconnecting");
276 this->start_connect_();
277 }
278 break;
279 }
280}
281
283 const char *eth_type;
284 switch (this->type_) {
286 eth_type = "LAN8720";
287 break;
288
290 eth_type = "RTL8201";
291 break;
292
294 eth_type = "DP83848";
295 break;
296
298 eth_type = "IP101";
299 break;
300
302 eth_type = "JL1101";
303 break;
304
306 eth_type = "KSZ8081";
307 break;
308
310 eth_type = "KSZ8081RNA";
311 break;
312
314 eth_type = "W5500";
315 break;
316
318 eth_type = "OPENETH";
319 break;
320
321 default:
322 eth_type = "Unknown";
323 break;
324 }
325
326 ESP_LOGCONFIG(TAG, "Ethernet:");
327 this->dump_connect_params_();
328#ifdef USE_ETHERNET_SPI
329 ESP_LOGCONFIG(TAG,
330 " CLK Pin: %u\n"
331 " MISO Pin: %u\n"
332 " MOSI Pin: %u\n"
333 " CS Pin: %u",
334 this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_);
335#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
336 if (this->polling_interval_ != 0) {
337 ESP_LOGCONFIG(TAG, " Polling Interval: %lu ms", this->polling_interval_);
338 } else
339#endif
340 {
341 ESP_LOGCONFIG(TAG, " IRQ Pin: %d", this->interrupt_pin_);
342 }
343 ESP_LOGCONFIG(TAG,
344 " Reset Pin: %d\n"
345 " Clock Speed: %d MHz",
346 this->reset_pin_, this->clock_speed_ / 1000000);
347#else
348 if (this->power_pin_ != -1) {
349 ESP_LOGCONFIG(TAG, " Power Pin: %u", this->power_pin_);
350 }
351 ESP_LOGCONFIG(TAG,
352 " MDC Pin: %u\n"
353 " MDIO Pin: %u\n"
354 " PHY addr: %u",
355 this->mdc_pin_, this->mdio_pin_, this->phy_addr_);
356#endif
357 ESP_LOGCONFIG(TAG, " Type: %s", eth_type);
358}
359
361
363
365 network::IPAddresses addresses;
366 esp_netif_ip_info_t ip;
367 esp_err_t err = esp_netif_get_ip_info(this->eth_netif_, &ip);
368 if (err != ESP_OK) {
369 ESP_LOGV(TAG, "esp_netif_get_ip_info failed: %s", esp_err_to_name(err));
370 // TODO: do something smarter
371 // return false;
372 } else {
373 addresses[0] = network::IPAddress(&ip.ip);
374 }
375#if USE_NETWORK_IPV6
376 struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
377 uint8_t count = 0;
378 count = esp_netif_get_all_ip6(this->eth_netif_, if_ip6s);
379 assert(count <= CONFIG_LWIP_IPV6_NUM_ADDRESSES);
380 for (int i = 0; i < count; i++) {
381 addresses[i + 1] = network::IPAddress(&if_ip6s[i]);
382 }
383#endif /* USE_NETWORK_IPV6 */
384
385 return addresses;
386}
387
389 const ip_addr_t *dns_ip = dns_getserver(num);
390 return dns_ip;
391}
392
393void EthernetComponent::eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event, void *event_data) {
394 const char *event_name;
395
396 switch (event) {
397 case ETHERNET_EVENT_START:
398 event_name = "ETH started";
400 break;
401 case ETHERNET_EVENT_STOP:
402 event_name = "ETH stopped";
405 break;
406 case ETHERNET_EVENT_CONNECTED:
407 event_name = "ETH connected";
408 break;
409 case ETHERNET_EVENT_DISCONNECTED:
410 event_name = "ETH disconnected";
412 break;
413 default:
414 return;
415 }
416
417 ESP_LOGV(TAG, "[Ethernet event] %s (num=%" PRId32 ")", event_name, event);
418}
419
420void EthernetComponent::got_ip_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id,
421 void *event_data) {
422 ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
423 const esp_netif_ip_info_t *ip_info = &event->ip_info;
424 ESP_LOGV(TAG, "[Ethernet event] ETH Got IP " IPSTR, IP2STR(&ip_info->ip));
426#if USE_NETWORK_IPV6 && (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
427 global_eth_component->connected_ = global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT;
428#else
430#endif /* USE_NETWORK_IPV6 */
431}
432
433#if USE_NETWORK_IPV6
434void EthernetComponent::got_ip6_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id,
435 void *event_data) {
436 ip_event_got_ip6_t *event = (ip_event_got_ip6_t *) event_data;
437 ESP_LOGV(TAG, "[Ethernet event] ETH Got IPv6: " IPV6STR, IPV62STR(event->ip6_info.ip));
439#if (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
441 global_eth_component->got_ipv4_address_ && (global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT);
442#else
444#endif
445}
446#endif /* USE_NETWORK_IPV6 */
447
450#if USE_NETWORK_IPV6
452#endif /* USE_NETWORK_IPV6 */
453 this->connect_begin_ = millis();
454 this->status_set_warning("waiting for IP configuration");
455
456 esp_err_t err;
457 err = esp_netif_set_hostname(this->eth_netif_, App.get_name().c_str());
458 if (err != ERR_OK) {
459 ESP_LOGW(TAG, "esp_netif_set_hostname failed: %s", esp_err_to_name(err));
460 }
461
462 esp_netif_ip_info_t info;
463 if (this->manual_ip_.has_value()) {
464 info.ip = this->manual_ip_->static_ip;
465 info.gw = this->manual_ip_->gateway;
466 info.netmask = this->manual_ip_->subnet;
467 } else {
468 info.ip.addr = 0;
469 info.gw.addr = 0;
470 info.netmask.addr = 0;
471 }
472
473 esp_netif_dhcp_status_t status = ESP_NETIF_DHCP_INIT;
474
475 err = esp_netif_dhcpc_get_status(this->eth_netif_, &status);
476 ESPHL_ERROR_CHECK(err, "DHCPC Get Status Failed!");
477
478 ESP_LOGV(TAG, "DHCP Client Status: %d", status);
479
480 err = esp_netif_dhcpc_stop(this->eth_netif_);
481 if (err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STOPPED) {
482 ESPHL_ERROR_CHECK(err, "DHCPC stop error");
483 }
484
485 err = esp_netif_set_ip_info(this->eth_netif_, &info);
486 ESPHL_ERROR_CHECK(err, "DHCPC set IP info error");
487
488 if (this->manual_ip_.has_value()) {
489 if (this->manual_ip_->dns1.is_set()) {
490 ip_addr_t d;
491 d = this->manual_ip_->dns1;
492 dns_setserver(0, &d);
493 }
494 if (this->manual_ip_->dns2.is_set()) {
495 ip_addr_t d;
496 d = this->manual_ip_->dns2;
497 dns_setserver(1, &d);
498 }
499 } else {
500 err = esp_netif_dhcpc_start(this->eth_netif_);
501 if (err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STARTED) {
502 ESPHL_ERROR_CHECK(err, "DHCPC start error");
503 }
504 }
505#if USE_NETWORK_IPV6
506 err = esp_netif_create_ip6_linklocal(this->eth_netif_);
507 if (err != ESP_OK) {
508 ESPHL_ERROR_CHECK(err, "Enable IPv6 link local failed");
509 }
510#endif /* USE_NETWORK_IPV6 */
511
512 this->connect_begin_ = millis();
513 this->status_set_warning();
514}
515
517
519 esp_netif_ip_info_t ip;
520 esp_netif_get_ip_info(this->eth_netif_, &ip);
521 const ip_addr_t *dns_ip1 = dns_getserver(0);
522 const ip_addr_t *dns_ip2 = dns_getserver(1);
523
524 ESP_LOGCONFIG(TAG,
525 " IP Address: %s\n"
526 " Hostname: '%s'\n"
527 " Subnet: %s\n"
528 " Gateway: %s\n"
529 " DNS1: %s\n"
530 " DNS2: %s",
531 network::IPAddress(&ip.ip).str().c_str(), App.get_name().c_str(),
532 network::IPAddress(&ip.netmask).str().c_str(), network::IPAddress(&ip.gw).str().c_str(),
533 network::IPAddress(dns_ip1).str().c_str(), network::IPAddress(dns_ip2).str().c_str());
534
535#if USE_NETWORK_IPV6
536 struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
537 uint8_t count = 0;
538 count = esp_netif_get_all_ip6(this->eth_netif_, if_ip6s);
539 assert(count <= CONFIG_LWIP_IPV6_NUM_ADDRESSES);
540 for (int i = 0; i < count; i++) {
541 ESP_LOGCONFIG(TAG, " IPv6: " IPV6STR, IPV62STR(if_ip6s[i]));
542 }
543#endif /* USE_NETWORK_IPV6 */
544
545 ESP_LOGCONFIG(TAG,
546 " MAC Address: %s\n"
547 " Is Full Duplex: %s\n"
548 " Link Speed: %u",
549 this->get_eth_mac_address_pretty().c_str(), YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL),
550 this->get_link_speed() == ETH_SPEED_100M ? 100 : 10);
551}
552
553#ifdef USE_ETHERNET_SPI
554void EthernetComponent::set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
555void EthernetComponent::set_miso_pin(uint8_t miso_pin) { this->miso_pin_ = miso_pin; }
556void EthernetComponent::set_mosi_pin(uint8_t mosi_pin) { this->mosi_pin_ = mosi_pin; }
557void EthernetComponent::set_cs_pin(uint8_t cs_pin) { this->cs_pin_ = cs_pin; }
558void EthernetComponent::set_interrupt_pin(uint8_t interrupt_pin) { this->interrupt_pin_ = interrupt_pin; }
559void EthernetComponent::set_reset_pin(uint8_t reset_pin) { this->reset_pin_ = reset_pin; }
560void EthernetComponent::set_clock_speed(int clock_speed) { this->clock_speed_ = clock_speed; }
561#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
562void EthernetComponent::set_polling_interval(uint32_t polling_interval) { this->polling_interval_ = polling_interval; }
563#endif
564#else
565void EthernetComponent::set_phy_addr(uint8_t phy_addr) { this->phy_addr_ = phy_addr; }
566void EthernetComponent::set_power_pin(int power_pin) { this->power_pin_ = power_pin; }
567void EthernetComponent::set_mdc_pin(uint8_t mdc_pin) { this->mdc_pin_ = mdc_pin; }
568void EthernetComponent::set_mdio_pin(uint8_t mdio_pin) { this->mdio_pin_ = mdio_pin; }
569void EthernetComponent::set_clk_mode(emac_rmii_clock_mode_t clk_mode, emac_rmii_clock_gpio_t clk_gpio) {
570 this->clk_mode_ = clk_mode;
571 this->clk_gpio_ = clk_gpio;
572}
573void EthernetComponent::add_phy_register(PHYRegister register_value) { this->phy_registers_.push_back(register_value); }
574#endif
576void EthernetComponent::set_manual_ip(const ManualIP &manual_ip) { this->manual_ip_ = manual_ip; }
577
579 if (this->use_address_.empty()) {
580 return App.get_name() + ".local";
581 }
582 return this->use_address_;
583}
584
585void EthernetComponent::set_use_address(const std::string &use_address) { this->use_address_ = use_address; }
586
588 esp_err_t err;
589 err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_G_MAC_ADDR, mac);
590 ESPHL_ERROR_CHECK(err, "ETH_CMD_G_MAC error");
591}
592
594 uint8_t mac[6];
596 return str_snprintf("%02X:%02X:%02X:%02X:%02X:%02X", 17, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
597}
598
600 esp_err_t err;
601 eth_duplex_t duplex_mode;
602 err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_G_DUPLEX_MODE, &duplex_mode);
603 ESPHL_ERROR_CHECK_RET(err, "ETH_CMD_G_DUPLEX_MODE error", ETH_DUPLEX_HALF);
604 return duplex_mode;
605}
606
608 esp_err_t err;
609 eth_speed_t speed;
610 err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_G_SPEED, &speed);
611 ESPHL_ERROR_CHECK_RET(err, "ETH_CMD_G_SPEED error", ETH_SPEED_10M);
612 return speed;
613}
614
616 ESP_LOGI(TAG, "Powering down ethernet PHY");
617 if (this->phy_ == nullptr) {
618 ESP_LOGE(TAG, "Ethernet PHY not assigned");
619 return false;
620 }
621 this->connected_ = false;
622 this->started_ = false;
623 if (this->phy_->pwrctl(this->phy_, false) != ESP_OK) {
624 ESP_LOGE(TAG, "Error powering down ethernet PHY");
625 return false;
626 }
627 return true;
628}
629
630#ifndef USE_ETHERNET_SPI
631
632constexpr uint8_t KSZ80XX_PC2R_REG_ADDR = 0x1F;
633
635 esp_err_t err;
636
637 uint32_t phy_control_2;
638 err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
639 ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
640 ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty((u_int8_t *) &phy_control_2, 2).c_str());
641
642 /*
643 * Bit 7 is `RMII Reference Clock Select`. Default is `0`.
644 * KSZ8081RNA:
645 * 0 - clock input to XI (Pin 8) is 25 MHz for RMII - 25 MHz clock mode.
646 * 1 - clock input to XI (Pin 8) is 50 MHz for RMII - 50 MHz clock mode.
647 * KSZ8081RND:
648 * 0 - clock input to XI (Pin 8) is 50 MHz for RMII - 50 MHz clock mode.
649 * 1 - clock input to XI (Pin 8) is 25 MHz (driven clock only, not a crystal) for RMII - 25 MHz clock mode.
650 */
651 if ((phy_control_2 & (1 << 7)) != (1 << 7)) {
652 phy_control_2 |= 1 << 7;
653 err = mac->write_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, phy_control_2);
654 ESPHL_ERROR_CHECK(err, "Write PHY Control 2 failed");
655 err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
656 ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
657 ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty((u_int8_t *) &phy_control_2, 2).c_str());
658 }
659}
660
661void EthernetComponent::write_phy_register_(esp_eth_mac_t *mac, PHYRegister register_data) {
662 esp_err_t err;
663 constexpr uint8_t eth_phy_psr_reg_addr = 0x1F;
664
665 if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
666 ESP_LOGD(TAG, "Select PHY Register Page: 0x%02" PRIX32, register_data.page);
667 err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, register_data.page);
668 ESPHL_ERROR_CHECK(err, "Select PHY Register page failed");
669 }
670
671 ESP_LOGD(TAG, "Writing to PHY Register Address: 0x%02" PRIX32, register_data.address);
672 ESP_LOGD(TAG, "Writing to PHY Register Value: 0x%04" PRIX32, register_data.value);
673 err = mac->write_phy_reg(mac, this->phy_addr_, register_data.address, register_data.value);
674 ESPHL_ERROR_CHECK(err, "Writing PHY Register failed");
675
676 if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
677 ESP_LOGD(TAG, "Select PHY Register Page 0x00");
678 err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, 0x0);
679 ESPHL_ERROR_CHECK(err, "Select PHY Register Page 0 failed");
680 }
681}
682
683#endif
684
685} // namespace ethernet
686} // namespace esphome
687
688#endif // USE_ESP32
uint8_t status
Definition bl0942.h:8
const std::string & get_name() const
Get the name of this Application set by pre_setup().
uint32_t IRAM_ATTR HOT get_loop_component_start_time() const
Get the cached time in milliseconds from when the current component started its loop execution.
virtual void mark_failed()
Mark this component as failed.
void status_set_warning(const char *message="unspecified")
void status_clear_warning()
std::vector< PHYRegister > phy_registers_
static void got_ip_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
void set_polling_interval(uint32_t polling_interval)
void set_manual_ip(const ManualIP &manual_ip)
void write_phy_register_(esp_eth_mac_t *mac, PHYRegister register_data)
Set arbitratry PHY registers from config.
static void got_ip6_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
network::IPAddress get_dns_address(uint8_t num)
void add_phy_register(PHYRegister register_value)
void ksz8081_set_clock_reference_(esp_eth_mac_t *mac)
Set RMII Reference Clock Select bit for KSZ8081.
void set_use_address(const std::string &use_address)
void set_clk_mode(emac_rmii_clock_mode_t clk_mode, emac_rmii_clock_gpio_t clk_gpio)
void set_interrupt_pin(uint8_t interrupt_pin)
static void eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
uint8_t type
int speed
Definition fan.h:1
in_addr ip_addr_t
Definition ip_address.h:22
constexpr uint8_t KSZ80XX_PC2R_REG_ADDR
esp_eth_phy_t * esp_eth_phy_new_jl1101(const eth_phy_config_t *config)
EthernetComponent * global_eth_component
std::array< IPAddress, 5 > IPAddresses
Definition ip_address.h:143
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
std::string str_snprintf(const char *fmt, size_t len,...)
Definition helpers.cpp:309
void IRAM_ATTR HOT delay(uint32_t ms)
Definition core.cpp:29
uint32_t IRAM_ATTR HOT millis()
Definition core.cpp:28
Application App
Global storage of Application pointer - only one Application can exist.
std::string format_hex_pretty(const uint8_t *data, size_t length)
Format the byte array data of length len in pretty-printed, human-readable hex.
Definition helpers.cpp:372
std::string str() const
Definition ip_address.h:52
uint8_t event_id
Definition tt21100.cpp:3