1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * (C) Copyright 2001-2015 4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 5 * Joe Hershberger, National Instruments 6 */ 7 8#define LOG_CATEGORY UCLASS_ETH 9 10#include <common.h> 11#include <bootdev.h> 12#include <bootstage.h> 13#include <dm.h> 14#include <env.h> 15#include <log.h> 16#include <net.h> 17#include <nvmem.h> 18#include <asm/global_data.h> 19#include <dm/device-internal.h> 20#include <dm/uclass-internal.h> 21#include <net/pcap.h> 22#include "eth_internal.h" 23#include <eth_phy.h> 24 25DECLARE_GLOBAL_DATA_PTR; 26 27/** 28 * struct eth_device_priv - private structure for each Ethernet device 29 * 30 * @state: The state of the Ethernet MAC driver (defined by enum eth_state_t) 31 */ 32struct eth_device_priv { 33 enum eth_state_t state; 34 bool running; 35}; 36 37/** 38 * struct eth_uclass_priv - The structure attached to the uclass itself 39 * 40 * @current: The Ethernet device that the network functions are using 41 * @no_bootdevs: true to skip binding Ethernet bootdevs (this is a negative flag 42 * so that the default value enables it) 43 */ 44struct eth_uclass_priv { 45 struct udevice *current; 46 bool no_bootdevs; 47}; 48 49/* eth_errno - This stores the most recent failure code from DM functions */ 50static int eth_errno; 51 52/* board-specific Ethernet Interface initializations. */ 53__weak int board_interface_eth_init(struct udevice *dev, 54 phy_interface_t interface_type) 55{ 56 return 0; 57} 58 59static struct eth_uclass_priv *eth_get_uclass_priv(void) 60{ 61 struct uclass *uc; 62 int ret; 63 64 ret = uclass_get(UCLASS_ETH, &uc); 65 if (ret) 66 return NULL; 67 68 assert(uc); 69 return uclass_get_priv(uc); 70} 71 72void eth_set_enable_bootdevs(bool enable) 73{ 74 struct eth_uclass_priv *priv = eth_get_uclass_priv(); 75 76 if (priv) 77 priv->no_bootdevs = !enable; 78} 79 80void eth_set_current_to_next(void) 81{ 82 struct eth_uclass_priv *uc_priv; 83 84 uc_priv = eth_get_uclass_priv(); 85 if (uc_priv->current) 86 uclass_next_device(&uc_priv->current); 87 if (!uc_priv->current) 88 uclass_first_device(UCLASS_ETH, &uc_priv->current); 89} 90 91/* 92 * Typically this will simply return the active device. 93 * In the case where the most recent active device was unset, this will attempt 94 * to return the device with sequence id 0 (which can be configured by the 95 * device tree). If this fails, fall back to just getting the first device. 96 * The latter is non-deterministic and depends on the order of the probing. 97 * If that device doesn't exist or fails to probe, this function will return 98 * NULL. 99 */ 100struct udevice *eth_get_dev(void) 101{ 102 struct eth_uclass_priv *uc_priv; 103 104 uc_priv = eth_get_uclass_priv(); 105 if (!uc_priv) 106 return NULL; 107 108 if (!uc_priv->current) { 109 eth_errno = uclass_get_device_by_seq(UCLASS_ETH, 0, 110 &uc_priv->current); 111 if (eth_errno) 112 eth_errno = uclass_first_device_err(UCLASS_ETH, 113 &uc_priv->current); 114 if (eth_errno) 115 uc_priv->current = NULL; 116 } 117 return uc_priv->current; 118} 119 120/* 121 * Typically this will just store a device pointer. 122 * In case it was not probed, we will attempt to do so. 123 * dev may be NULL to unset the active device. 124 */ 125void eth_set_dev(struct udevice *dev) 126{ 127 if (dev && !device_active(dev)) { 128 eth_errno = device_probe(dev); 129 if (eth_errno) 130 dev = NULL; 131 } 132 133 eth_get_uclass_priv()->current = dev; 134} 135 136/* 137 * Find the udevice that either has the name passed in as devname or has an 138 * alias named devname. 139 */ 140struct udevice *eth_get_dev_by_name(const char *devname) 141{ 142 int seq = -1; 143 char *endp = NULL; 144 const char *startp = NULL; 145 struct udevice *it; 146 struct uclass *uc; 147 int len = strlen("eth"); 148 int ret; 149 150 /* Must be longer than 3 to be an alias */ 151 if (!strncmp(devname, "eth", len) && strlen(devname) > len) { 152 startp = devname + len; 153 seq = dectoul(startp, &endp); 154 } 155 156 ret = uclass_get(UCLASS_ETH, &uc); 157 if (ret) 158 return NULL; 159 160 uclass_foreach_dev(it, uc) { 161 /* 162 * We don't care about errors from probe here. Either they won't 163 * match an alias or it will match a literal name and we'll pick 164 * up the error when we try to probe again in eth_set_dev(). 165 */ 166 if (device_probe(it)) 167 continue; 168 /* Check for the name or the sequence number to match */ 169 if (strcmp(it->name, devname) == 0 || 170 (endp > startp && dev_seq(it) == seq)) 171 return it; 172 } 173 174 return NULL; 175} 176 177unsigned char *eth_get_ethaddr(void) 178{ 179 struct eth_pdata *pdata; 180 181 if (eth_get_dev()) { 182 pdata = dev_get_plat(eth_get_dev()); 183 return pdata->enetaddr; 184 } 185 186 return NULL; 187} 188 189/* Set active state without calling start on the driver */ 190int eth_init_state_only(void) 191{ 192 struct udevice *current; 193 struct eth_device_priv *priv; 194 195 current = eth_get_dev(); 196 if (!current || !device_active(current)) 197 return -EINVAL; 198 199 priv = dev_get_uclass_priv(current); 200 priv->state = ETH_STATE_ACTIVE; 201 202 return 0; 203} 204 205/* Set passive state without calling stop on the driver */ 206void eth_halt_state_only(void) 207{ 208 struct udevice *current; 209 struct eth_device_priv *priv; 210 211 current = eth_get_dev(); 212 if (!current || !device_active(current)) 213 return; 214 215 priv = dev_get_uclass_priv(current); 216 priv->state = ETH_STATE_PASSIVE; 217} 218 219int eth_get_dev_index(void) 220{ 221 if (eth_get_dev()) 222 return dev_seq(eth_get_dev()); 223 return -1; 224} 225 226static int eth_write_hwaddr(struct udevice *dev) 227{ 228 struct eth_pdata *pdata; 229 int ret = 0; 230 231 if (!dev || !device_active(dev)) 232 return -EINVAL; 233 234 /* seq is valid since the device is active */ 235 if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev_seq(dev))) { 236 pdata = dev_get_plat(dev); 237 if (!is_valid_ethaddr(pdata->enetaddr)) { 238 printf("\nError: %s address %pM illegal value\n", 239 dev->name, pdata->enetaddr); 240 return -EINVAL; 241 } 242 243 /* 244 * Drivers are allowed to decide not to implement this at 245 * run-time. E.g. Some devices may use it and some may not. 246 */ 247 ret = eth_get_ops(dev)->write_hwaddr(dev); 248 if (ret == -ENOSYS) 249 ret = 0; 250 if (ret) 251 printf("\nWarning: %s failed to set MAC address\n", 252 dev->name); 253 } 254 255 return ret; 256} 257 258static int on_ethaddr(const char *name, const char *value, enum env_op op, 259 int flags) 260{ 261 int index; 262 int retval; 263 struct udevice *dev; 264 265 /* look for an index after "eth" */ 266 index = dectoul(name + 3, NULL); 267 268 retval = uclass_find_device_by_seq(UCLASS_ETH, index, &dev); 269 if (!retval) { 270 struct eth_pdata *pdata = dev_get_plat(dev); 271 switch (op) { 272 case env_op_create: 273 case env_op_overwrite: 274 string_to_enetaddr(value, pdata->enetaddr); 275 eth_write_hwaddr(dev); 276 break; 277 case env_op_delete: 278 memset(pdata->enetaddr, 0, ARP_HLEN); 279 } 280 } 281 282 return 0; 283} 284U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr); 285 286int eth_init(void) 287{ 288 char *ethact = env_get("ethact"); 289 char *ethrotate = env_get("ethrotate"); 290 struct udevice *current = NULL; 291 struct udevice *old_current; 292 int ret = -ENODEV; 293 294 /* 295 * When 'ethrotate' variable is set to 'no' and 'ethact' variable 296 * is already set to an ethernet device, we should stick to 'ethact'. 297 */ 298 if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) { 299 if (ethact) { 300 current = eth_get_dev_by_name(ethact); 301 if (!current) 302 return -EINVAL; 303 } 304 } 305 306 if (!current) { 307 current = eth_get_dev(); 308 if (!current) { 309 log_err("No ethernet found.\n"); 310 return -ENODEV; 311 } 312 } 313 314 old_current = current; 315 do { 316 if (current) { 317 debug("Trying %s\n", current->name); 318 319 if (device_active(current)) { 320 ret = eth_get_ops(current)->start(current); 321 if (ret >= 0) { 322 struct eth_device_priv *priv = 323 dev_get_uclass_priv(current); 324 325 priv->state = ETH_STATE_ACTIVE; 326 priv->running = true; 327 return 0; 328 } 329 } else { 330 ret = eth_errno; 331 } 332 333 debug("FAIL\n"); 334 } else { 335 debug("PROBE FAIL\n"); 336 } 337 338 /* 339 * If ethrotate is enabled, this will change "current", 340 * otherwise we will drop out of this while loop immediately 341 */ 342 eth_try_another(0); 343 /* This will ensure the new "current" attempted to probe */ 344 current = eth_get_dev(); 345 } while (old_current != current); 346 347 return ret; 348} 349 350void eth_halt(void) 351{ 352 struct udevice *current; 353 struct eth_device_priv *priv; 354 355 current = eth_get_dev(); 356 if (!current) 357 return; 358 359 priv = dev_get_uclass_priv(current); 360 if (!priv || !priv->running) 361 return; 362 363 eth_get_ops(current)->stop(current); 364 priv->state = ETH_STATE_PASSIVE; 365 priv->running = false; 366} 367 368int eth_is_active(struct udevice *dev) 369{ 370 struct eth_device_priv *priv; 371 372 if (!dev || !device_active(dev)) 373 return 0; 374 375 priv = dev_get_uclass_priv(dev); 376 return priv->state == ETH_STATE_ACTIVE; 377} 378 379int eth_send(void *packet, int length) 380{ 381 struct udevice *current; 382 int ret; 383 384 current = eth_get_dev(); 385 if (!current) 386 return -ENODEV; 387 388 if (!eth_is_active(current)) 389 return -EINVAL; 390 391 ret = eth_get_ops(current)->send(current, packet, length); 392 if (ret < 0) { 393 /* We cannot completely return the error at present */ 394 debug("%s: send() returned error %d\n", __func__, ret); 395 } 396#if defined(CONFIG_CMD_PCAP) 397 if (ret >= 0) 398 pcap_post(packet, length, true); 399#endif 400 return ret; 401} 402 403int eth_rx(void) 404{ 405 struct udevice *current; 406 uchar *packet; 407 int flags; 408 int ret; 409 int i; 410 411 current = eth_get_dev(); 412 if (!current) 413 return -ENODEV; 414 415 if (!eth_is_active(current)) 416 return -EINVAL; 417 418 /* Process up to 32 packets at one time */ 419 flags = ETH_RECV_CHECK_DEVICE; 420 for (i = 0; i < ETH_PACKETS_BATCH_RECV; i++) { 421 ret = eth_get_ops(current)->recv(current, flags, &packet); 422 flags = 0; 423 if (ret > 0) 424 net_process_received_packet(packet, ret); 425 if (ret >= 0 && eth_get_ops(current)->free_pkt) 426 eth_get_ops(current)->free_pkt(current, packet, ret); 427 if (ret <= 0) 428 break; 429 } 430 if (ret == -EAGAIN) 431 ret = 0; 432 if (ret < 0) { 433 /* We cannot completely return the error at present */ 434 debug("%s: recv() returned error %d\n", __func__, ret); 435 } 436 return ret; 437} 438 439int eth_initialize(void) 440{ 441 int num_devices = 0; 442 struct udevice *dev; 443 444 eth_common_init(); 445 446 /* 447 * Devices need to write the hwaddr even if not started so that Linux 448 * will have access to the hwaddr that u-boot stored for the device. 449 * This is accomplished by attempting to probe each device and calling 450 * their write_hwaddr() operation. 451 */ 452 uclass_first_device_check(UCLASS_ETH, &dev); 453 if (!dev) { 454 log_err("No ethernet found.\n"); 455 bootstage_error(BOOTSTAGE_ID_NET_ETH_START); 456 } else { 457 char *ethprime = env_get("ethprime"); 458 struct udevice *prime_dev = NULL; 459 460 if (ethprime) 461 prime_dev = eth_get_dev_by_name(ethprime); 462 if (prime_dev) { 463 eth_set_dev(prime_dev); 464 eth_current_changed(); 465 } else { 466 eth_set_dev(NULL); 467 } 468 469 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT); 470 do { 471 if (device_active(dev)) { 472 if (num_devices) 473 printf(", "); 474 475 printf("eth%d: %s", dev_seq(dev), dev->name); 476 477 if (ethprime && dev == prime_dev) 478 printf(" [PRIME]"); 479 } 480 481 eth_write_hwaddr(dev); 482 483 if (device_active(dev)) 484 num_devices++; 485 uclass_next_device_check(&dev); 486 } while (dev); 487 488 if (!num_devices) 489 log_err("No ethernet found.\n"); 490 putc('\n'); 491 } 492 493 return num_devices; 494} 495 496static int eth_post_bind(struct udevice *dev) 497{ 498 struct eth_uclass_priv *priv = uclass_get_priv(dev->uclass); 499 int ret; 500 501 if (strchr(dev->name, ' ')) { 502 printf("\nError: eth device name \"%s\" has a space!\n", 503 dev->name); 504 return -EINVAL; 505 } 506 507#ifdef CONFIG_DM_ETH_PHY 508 eth_phy_binds_nodes(dev); 509#endif 510 if (CONFIG_IS_ENABLED(BOOTDEV_ETH) && !priv->no_bootdevs) { 511 ret = bootdev_setup_for_dev(dev, "eth_bootdev"); 512 if (ret) 513 return log_msg_ret("bootdev", ret); 514 } 515 516 return 0; 517} 518 519static int eth_pre_unbind(struct udevice *dev) 520{ 521 /* Don't hang onto a pointer that is going away */ 522 if (dev == eth_get_uclass_priv()->current) 523 eth_set_dev(NULL); 524 525 return 0; 526} 527 528static bool eth_dev_get_mac_address(struct udevice *dev, u8 mac[ARP_HLEN]) 529{ 530#if CONFIG_IS_ENABLED(OF_CONTROL) 531 const uint8_t *p; 532 struct nvmem_cell mac_cell; 533 534 p = dev_read_u8_array_ptr(dev, "mac-address", ARP_HLEN); 535 if (!p) 536 p = dev_read_u8_array_ptr(dev, "local-mac-address", ARP_HLEN); 537 538 if (p) { 539 memcpy(mac, p, ARP_HLEN); 540 return true; 541 } 542 543 if (nvmem_cell_get_by_name(dev, "mac-address", &mac_cell)) 544 return false; 545 546 return !nvmem_cell_read(&mac_cell, mac, ARP_HLEN); 547#else 548 return false; 549#endif 550} 551 552static int eth_post_probe(struct udevice *dev) 553{ 554 struct eth_device_priv *priv = dev_get_uclass_priv(dev); 555 struct eth_pdata *pdata = dev_get_plat(dev); 556 unsigned char env_enetaddr[ARP_HLEN]; 557 char *source = "DT"; 558 559 priv->state = ETH_STATE_INIT; 560 priv->running = false; 561 562 /* Check if the device has a valid MAC address in device tree */ 563 if (!eth_dev_get_mac_address(dev, pdata->enetaddr) || 564 !is_valid_ethaddr(pdata->enetaddr)) { 565 /* Check if the device has a MAC address in ROM */ 566 if (eth_get_ops(dev)->read_rom_hwaddr) { 567 int ret; 568 569 ret = eth_get_ops(dev)->read_rom_hwaddr(dev); 570 if (!ret) 571 source = "ROM"; 572 } 573 } 574 575 eth_env_get_enetaddr_by_index("eth", dev_seq(dev), env_enetaddr); 576 if (!is_zero_ethaddr(env_enetaddr)) { 577 if (!is_zero_ethaddr(pdata->enetaddr) && 578 memcmp(pdata->enetaddr, env_enetaddr, ARP_HLEN)) { 579 printf("\nWarning: %s MAC addresses don't match:\n", 580 dev->name); 581 printf("Address in %s is\t\t%pM\n", 582 source, pdata->enetaddr); 583 printf("Address in environment is\t%pM\n", 584 env_enetaddr); 585 } 586 587 /* Override the ROM MAC address */ 588 memcpy(pdata->enetaddr, env_enetaddr, ARP_HLEN); 589 } else if (is_valid_ethaddr(pdata->enetaddr)) { 590 eth_env_set_enetaddr_by_index("eth", dev_seq(dev), 591 pdata->enetaddr); 592 } else if (is_zero_ethaddr(pdata->enetaddr) || 593 !is_valid_ethaddr(pdata->enetaddr)) { 594#ifdef CONFIG_NET_RANDOM_ETHADDR 595 net_random_ethaddr(pdata->enetaddr); 596 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n", 597 dev->name, dev_seq(dev), pdata->enetaddr); 598 eth_env_set_enetaddr_by_index("eth", dev_seq(dev), 599 pdata->enetaddr); 600#else 601 printf("\nError: %s No valid MAC address found.\n", 602 dev->name); 603 return -EINVAL; 604#endif 605 } 606 607 eth_write_hwaddr(dev); 608 609 return 0; 610} 611 612static int eth_pre_remove(struct udevice *dev) 613{ 614 struct eth_pdata *pdata = dev_get_plat(dev); 615 616 eth_get_ops(dev)->stop(dev); 617 618 /* clear the MAC address */ 619 memset(pdata->enetaddr, 0, ARP_HLEN); 620 621 return 0; 622} 623 624UCLASS_DRIVER(ethernet) = { 625 .name = "ethernet", 626 .id = UCLASS_ETH, 627 .post_bind = eth_post_bind, 628 .pre_unbind = eth_pre_unbind, 629 .post_probe = eth_post_probe, 630 .pre_remove = eth_pre_remove, 631 .priv_auto = sizeof(struct eth_uclass_priv), 632 .per_device_auto = sizeof(struct eth_device_priv), 633 .flags = DM_UC_FLAG_SEQ_ALIAS, 634}; 635