net/eth-uclass.c

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