net/eth.c

   1 /*
   2  * (C) Copyright 2001-2015
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  * Joe Hershberger, National Instruments
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <common.h>
  10 #include <command.h>
  11 #include <dm.h>
  12 #include <environment.h>
  13 #include <net.h>
  14 #include <miiphy.h>
  15 #include <phy.h>
  16 #include <asm/errno.h>
  17 #include <dm/device-internal.h>
  18 #include <dm/uclass-internal.h>
  19
  20 DECLARE_GLOBAL_DATA_PTR;
  21
  22 void eth_parse_enetaddr(const char *addr, uchar *enetaddr)
  23 {
  24         char *end;
  25         int i;
  26
  27         for (i = 0; i < 6; ++i) {
  28                 enetaddr[i] = addr ? simple_strtoul(addr, &end, 16) : 0;
  29                 if (addr)
  30                         addr = (*end) ? end + 1 : end;
  31         }
  32 }
  33
  34 int eth_getenv_enetaddr(const char *name, uchar *enetaddr)
  35 {
  36         eth_parse_enetaddr(getenv(name), enetaddr);
  37         return is_valid_ethaddr(enetaddr);
  38 }
  39
  40 int eth_setenv_enetaddr(const char *name, const uchar *enetaddr)
  41 {
  42         char buf[20];
  43
  44         sprintf(buf, "%pM", enetaddr);
  45
  46         return setenv(name, buf);
  47 }
  48
  49 int eth_getenv_enetaddr_by_index(const char *base_name, int index,
  50                                  uchar *enetaddr)
  51 {
  52         char enetvar[32];
  53         sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index);
  54         return eth_getenv_enetaddr(enetvar, enetaddr);
  55 }
  56
  57 static inline int eth_setenv_enetaddr_by_index(const char *base_name, int index,
  58                                  uchar *enetaddr)
  59 {
  60         char enetvar[32];
  61         sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index);
  62         return eth_setenv_enetaddr(enetvar, enetaddr);
  63 }
  64
  65 static int eth_mac_skip(int index)
  66 {
  67         char enetvar[15];
  68         char *skip_state;
  69
  70         sprintf(enetvar, index ? "eth%dmacskip" : "ethmacskip", index);
  71         skip_state = getenv(enetvar);
  72         return skip_state != NULL;
  73 }
  74
  75 static void eth_current_changed(void);
  76
  77 /*
  78  * CPU and board-specific Ethernet initializations.  Aliased function
  79  * signals caller to move on
  80  */
  81 static int __def_eth_init(bd_t *bis)
  82 {
  83         return -1;
  84 }
  85 int cpu_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init")));
  86 int board_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init")));
  87
  88 static void eth_common_init(void)
  89 {
  90         bootstage_mark(BOOTSTAGE_ID_NET_ETH_START);
  91 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB)
  92         miiphy_init();
  93 #endif
  94
  95 #ifdef CONFIG_PHYLIB
  96         phy_init();
  97 #endif
  98
  99         /*
 100          * If board-specific initialization exists, call it.
 101          * If not, call a CPU-specific one
 102          */
 103         if (board_eth_init != __def_eth_init) {
 104                 if (board_eth_init(gd->bd) < 0)
 105                         printf("Board Net Initialization Failed\n");
 106         } else if (cpu_eth_init != __def_eth_init) {
 107                 if (cpu_eth_init(gd->bd) < 0)
 108                         printf("CPU Net Initialization Failed\n");
 109         } else {
 110 #ifndef CONFIG_DM_ETH
 111                 printf("Net Initialization Skipped\n");
 112 #endif
 113         }
 114 }
 115
 116 #ifdef CONFIG_DM_ETH
 117 /**
 118  * struct eth_device_priv - private structure for each Ethernet device
 119  *
 120  * @state: The state of the Ethernet MAC driver (defined by enum eth_state_t)
 121  */
 122 struct eth_device_priv {
 123         enum eth_state_t state;
 124 };
 125
 126 /**
 127  * struct eth_uclass_priv - The structure attached to the uclass itself
 128  *
 129  * @current: The Ethernet device that the network functions are using
 130  */
 131 struct eth_uclass_priv {
 132         struct udevice *current;
 133 };
 134
 135 /* eth_errno - This stores the most recent failure code from DM functions */
 136 static int eth_errno;
 137
 138 static struct eth_uclass_priv *eth_get_uclass_priv(void)
 139 {
 140         struct uclass *uc;
 141
 142         uclass_get(UCLASS_ETH, &uc);
 143         assert(uc);
 144         return uc->priv;
 145 }
 146
 147 static void eth_set_current_to_next(void)
 148 {
 149         struct eth_uclass_priv *uc_priv;
 150
 151         uc_priv = eth_get_uclass_priv();
 152         if (uc_priv->current)
 153                 uclass_next_device(&uc_priv->current);
 154         if (!uc_priv->current)
 155                 uclass_first_device(UCLASS_ETH, &uc_priv->current);
 156 }
 157
 158 /*
 159  * Typically this will simply return the active device.
 160  * In the case where the most recent active device was unset, this will attempt
 161  * to return the first device. If that device doesn't exist or fails to probe,
 162  * this function will return NULL.
 163  */
 164 struct udevice *eth_get_dev(void)
 165 {
 166         struct eth_uclass_priv *uc_priv;
 167
 168         uc_priv = eth_get_uclass_priv();
 169         if (!uc_priv->current)
 170                 eth_errno = uclass_first_device(UCLASS_ETH,
 171                                     &uc_priv->current);
 172         return uc_priv->current;
 173 }
 174
 175 /*
 176  * Typically this will just store a device pointer.
 177  * In case it was not probed, we will attempt to do so.
 178  * dev may be NULL to unset the active device.
 179  */
 180 static void eth_set_dev(struct udevice *dev)
 181 {
 182         if (dev && !device_active(dev))
 183                 eth_errno = device_probe(dev);
 184         eth_get_uclass_priv()->current = dev;
 185 }
 186
 187 /*
 188  * Find the udevice that either has the name passed in as devname or has an
 189  * alias named devname.
 190  */
 191 struct udevice *eth_get_dev_by_name(const char *devname)
 192 {
 193         int seq = -1;
 194         char *endp = NULL;
 195         const char *startp = NULL;
 196         struct udevice *it;
 197         struct uclass *uc;
 198         int len = strlen("eth");
 199
 200         /* Must be longer than 3 to be an alias */
 201         if (!strncmp(devname, "eth", len) && strlen(devname) > len) {
 202                 startp = devname + len;
 203                 seq = simple_strtoul(startp, &endp, 10);
 204         }
 205
 206         uclass_get(UCLASS_ETH, &uc);
 207         uclass_foreach_dev(it, uc) {
 208                 /*
 209                  * We need the seq to be valid, so try to probe it.
 210                  * If the probe fails, the seq will not match since it will be
 211                  * -1 instead of what we are looking for.
 212                  * We don't care about errors from probe here. Either they won't
 213                  * match an alias or it will match a literal name and we'll pick
 214                  * up the error when we try to probe again in eth_set_dev().
 215                  */
 216                 device_probe(it);
 217                 /*
 218                  * Check for the name or the sequence number to match
 219                  */
 220                 if (strcmp(it->name, devname) == 0 ||
 221                     (endp > startp && it->seq == seq))
 222                         return it;
 223         }
 224
 225         return NULL;
 226 }
 227
 228 unsigned char *eth_get_ethaddr(void)
 229 {
 230         struct eth_pdata *pdata;
 231
 232         if (eth_get_dev()) {
 233                 pdata = eth_get_dev()->platdata;
 234                 return pdata->enetaddr;
 235         }
 236
 237         return NULL;
 238 }
 239
 240 /* Set active state without calling start on the driver */
 241 int eth_init_state_only(void)
 242 {
 243         struct udevice *current;
 244         struct eth_device_priv *priv;
 245
 246         current = eth_get_dev();
 247         if (!current || !device_active(current))
 248                 return -EINVAL;
 249
 250         priv = current->uclass_priv;
 251         priv->state = ETH_STATE_ACTIVE;
 252
 253         return 0;
 254 }
 255
 256 /* Set passive state without calling stop on the driver */
 257 void eth_halt_state_only(void)
 258 {
 259         struct udevice *current;
 260         struct eth_device_priv *priv;
 261
 262         current = eth_get_dev();
 263         if (!current || !device_active(current))
 264                 return;
 265
 266         priv = current->uclass_priv;
 267         priv->state = ETH_STATE_PASSIVE;
 268 }
 269
 270 int eth_get_dev_index(void)
 271 {
 272         if (eth_get_dev())
 273                 return eth_get_dev()->seq;
 274         return -1;
 275 }
 276
 277 static int eth_write_hwaddr(struct udevice *dev)
 278 {
 279         struct eth_pdata *pdata = dev->platdata;
 280         int ret = 0;
 281
 282         if (!dev || !device_active(dev))
 283                 return -EINVAL;
 284
 285         /* seq is valid since the device is active */
 286         if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev->seq)) {
 287                 if (!is_valid_ethaddr(pdata->enetaddr)) {
 288                         printf("\nError: %s address %pM illegal value\n",
 289                                dev->name, pdata->enetaddr);
 290                         return -EINVAL;
 291                 }
 292
 293                 /*
 294                  * Drivers are allowed to decide not to implement this at
 295                  * run-time. E.g. Some devices may use it and some may not.
 296                  */
 297                 ret = eth_get_ops(dev)->write_hwaddr(dev);
 298                 if (ret == -ENOSYS)
 299                         ret = 0;
 300                 if (ret)
 301                         printf("\nWarning: %s failed to set MAC address\n",
 302                                dev->name);
 303         }
 304
 305         return ret;
 306 }
 307
 308 static int on_ethaddr(const char *name, const char *value, enum env_op op,
 309         int flags)
 310 {
 311         int index;
 312         int retval;
 313         struct udevice *dev;
 314
 315         /* look for an index after "eth" */
 316         index = simple_strtoul(name + 3, NULL, 10);
 317
 318         retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev);
 319         if (!retval) {
 320                 struct eth_pdata *pdata = dev->platdata;
 321                 switch (op) {
 322                 case env_op_create:
 323                 case env_op_overwrite:
 324                         eth_parse_enetaddr(value, pdata->enetaddr);
 325                         break;
 326                 case env_op_delete:
 327                         memset(pdata->enetaddr, 0, 6);
 328                 }
 329         }
 330
 331         return 0;
 332 }
 333 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);
 334
 335 int eth_init(void)
 336 {
 337         struct udevice *current;
 338         struct udevice *old_current;
 339         int ret = -ENODEV;
 340
 341         current = eth_get_dev();
 342         if (!current) {
 343                 printf("No ethernet found.\n");
 344                 return -ENODEV;
 345         }
 346
 347         old_current = current;
 348         do {
 349                 debug("Trying %s\n", current->name);
 350
 351                 if (device_active(current)) {
 352                         ret = eth_get_ops(current)->start(current);
 353                         if (ret >= 0) {
 354                                 struct eth_device_priv *priv =
 355                                         current->uclass_priv;
 356
 357                                 priv->state = ETH_STATE_ACTIVE;
 358                                 return 0;
 359                         }
 360                 } else {
 361                         ret = eth_errno;
 362                 }
 363
 364                 debug("FAIL\n");
 365
 366                 /*
 367                  * If ethrotate is enabled, this will change "current",
 368                  * otherwise we will drop out of this while loop immediately
 369                  */
 370                 eth_try_another(0);
 371                 /* This will ensure the new "current" attempted to probe */
 372                 current = eth_get_dev();
 373         } while (old_current != current);
 374
 375         return ret;
 376 }
 377
 378 void eth_halt(void)
 379 {
 380         struct udevice *current;
 381         struct eth_device_priv *priv;
 382
 383         current = eth_get_dev();
 384         if (!current || !device_active(current))
 385                 return;
 386
 387         eth_get_ops(current)->stop(current);
 388         priv = current->uclass_priv;
 389         priv->state = ETH_STATE_PASSIVE;
 390 }
 391
 392 int eth_is_active(struct udevice *dev)
 393 {
 394         struct eth_device_priv *priv;
 395
 396         if (!dev || !device_active(dev))
 397                 return 0;
 398
 399         priv = dev_get_uclass_priv(dev);
 400         return priv->state == ETH_STATE_ACTIVE;
 401 }
 402
 403 int eth_send(void *packet, int length)
 404 {
 405         struct udevice *current;
 406         int ret;
 407
 408         current = eth_get_dev();
 409         if (!current)
 410                 return -ENODEV;
 411
 412         if (!device_active(current))
 413                 return -EINVAL;
 414
 415         ret = eth_get_ops(current)->send(current, packet, length);
 416         if (ret < 0) {
 417                 /* We cannot completely return the error at present */
 418                 debug("%s: send() returned error %d\n", __func__, ret);
 419         }
 420         return ret;
 421 }
 422
 423 int eth_rx(void)
 424 {
 425         struct udevice *current;
 426         uchar *packet;
 427         int flags;
 428         int ret;
 429         int i;
 430
 431         current = eth_get_dev();
 432         if (!current)
 433                 return -ENODEV;
 434
 435         if (!device_active(current))
 436                 return -EINVAL;
 437
 438         /* Process up to 32 packets at one time */
 439         flags = ETH_RECV_CHECK_DEVICE;
 440         for (i = 0; i < 32; i++) {
 441                 ret = eth_get_ops(current)->recv(current, flags, &packet);
 442                 flags = 0;
 443                 if (ret > 0)
 444                         net_process_received_packet(packet, ret);
 445                 if (ret >= 0 && eth_get_ops(current)->free_pkt)
 446                         eth_get_ops(current)->free_pkt(current, packet, ret);
 447                 if (ret <= 0)
 448                         break;
 449         }
 450         if (ret == -EAGAIN)
 451                 ret = 0;
 452         if (ret < 0) {
 453                 /* We cannot completely return the error at present */
 454                 debug("%s: recv() returned error %d\n", __func__, ret);
 455         }
 456         return ret;
 457 }
 458
 459 int eth_initialize(void)
 460 {
 461         int num_devices = 0;
 462         struct udevice *dev;
 463
 464         eth_common_init();
 465
 466         /*
 467          * Devices need to write the hwaddr even if not started so that Linux
 468          * will have access to the hwaddr that u-boot stored for the device.
 469          * This is accomplished by attempting to probe each device and calling
 470          * their write_hwaddr() operation.
 471          */
 472         uclass_first_device(UCLASS_ETH, &dev);
 473         if (!dev) {
 474                 printf("No ethernet found.\n");
 475                 bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
 476         } else {
 477                 char *ethprime = getenv("ethprime");
 478                 struct udevice *prime_dev = NULL;
 479
 480                 if (ethprime)
 481                         prime_dev = eth_get_dev_by_name(ethprime);
 482                 if (prime_dev) {
 483                         eth_set_dev(prime_dev);
 484                         eth_current_changed();
 485                 } else {
 486                         eth_set_dev(NULL);
 487                 }
 488
 489                 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
 490                 do {
 491                         if (num_devices)
 492                                 printf(", ");
 493
 494                         printf("eth%d: %s", dev->seq, dev->name);
 495
 496                         if (ethprime && dev == prime_dev)
 497                                 printf(" [PRIME]");
 498
 499                         eth_write_hwaddr(dev);
 500
 501                         uclass_next_device(&dev);
 502                         num_devices++;
 503                 } while (dev);
 504
 505                 putc('\n');
 506         }
 507
 508         return num_devices;
 509 }
 510
 511 static int eth_post_bind(struct udevice *dev)
 512 {
 513         if (strchr(dev->name, ' ')) {
 514                 printf("\nError: eth device name \"%s\" has a space!\n",
 515                        dev->name);
 516                 return -EINVAL;
 517         }
 518
 519         return 0;
 520 }
 521
 522 static int eth_pre_unbind(struct udevice *dev)
 523 {
 524         /* Don't hang onto a pointer that is going away */
 525         if (dev == eth_get_uclass_priv()->current)
 526                 eth_set_dev(NULL);
 527
 528         return 0;
 529 }
 530
 531 static int eth_post_probe(struct udevice *dev)
 532 {
 533         struct eth_device_priv *priv = dev->uclass_priv;
 534         struct eth_pdata *pdata = dev->platdata;
 535         unsigned char env_enetaddr[6];
 536
 537         priv->state = ETH_STATE_INIT;
 538
 539         /* Check if the device has a MAC address in ROM */
 540         if (eth_get_ops(dev)->read_rom_hwaddr)
 541                 eth_get_ops(dev)->read_rom_hwaddr(dev);
 542
 543         eth_getenv_enetaddr_by_index("eth", dev->seq, env_enetaddr);
 544         if (!is_zero_ethaddr(env_enetaddr)) {
 545                 if (!is_zero_ethaddr(pdata->enetaddr) &&
 546                     memcmp(pdata->enetaddr, env_enetaddr, 6)) {
 547                         printf("\nWarning: %s MAC addresses don't match:\n",
 548                                dev->name);
 549                         printf("Address in SROM is         %pM\n",
 550                                pdata->enetaddr);
 551                         printf("Address in environment is  %pM\n",
 552                                env_enetaddr);
 553                 }
 554
 555                 /* Override the ROM MAC address */
 556                 memcpy(pdata->enetaddr, env_enetaddr, 6);
 557         } else if (is_valid_ethaddr(pdata->enetaddr)) {
 558                 eth_setenv_enetaddr_by_index("eth", dev->seq, pdata->enetaddr);
 559                 printf("\nWarning: %s using MAC address from ROM\n",
 560                        dev->name);
 561         } else if (is_zero_ethaddr(pdata->enetaddr)) {
 562 #ifdef CONFIG_NET_RANDOM_ETHADDR
 563                 net_random_ethaddr(pdata->enetaddr);
 564                 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
 565                        dev->name, dev->seq, pdata->enetaddr);
 566 #else
 567                 printf("\nError: %s address not set.\n",
 568                        dev->name);
 569                 return -EINVAL;
 570 #endif
 571         }
 572
 573         return 0;
 574 }
 575
 576 static int eth_pre_remove(struct udevice *dev)
 577 {
 578         struct eth_pdata *pdata = dev->platdata;
 579
 580         eth_get_ops(dev)->stop(dev);
 581
 582         /* clear the MAC address */
 583         memset(pdata->enetaddr, 0, 6);
 584
 585         return 0;
 586 }
 587
 588 UCLASS_DRIVER(eth) = {
 589         .name           = "eth",
 590         .id             = UCLASS_ETH,
 591         .post_bind      = eth_post_bind,
 592         .pre_unbind     = eth_pre_unbind,
 593         .post_probe     = eth_post_probe,
 594         .pre_remove     = eth_pre_remove,
 595         .priv_auto_alloc_size = sizeof(struct eth_uclass_priv),
 596         .per_device_auto_alloc_size = sizeof(struct eth_device_priv),
 597         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 598 };
 599 #endif /* #ifdef CONFIG_DM_ETH */
 600
 601 #ifndef CONFIG_DM_ETH
 602
 603 #ifdef CONFIG_API
 604 static struct {
 605         uchar data[PKTSIZE];
 606         int length;
 607 } eth_rcv_bufs[PKTBUFSRX];
 608
 609 static unsigned int eth_rcv_current, eth_rcv_last;
 610 #endif
 611
 612 static struct eth_device *eth_devices;
 613 struct eth_device *eth_current;
 614
 615 static void eth_set_current_to_next(void)
 616 {
 617         eth_current = eth_current->next;
 618 }
 619
 620 static void eth_set_dev(struct eth_device *dev)
 621 {
 622         eth_current = dev;
 623 }
 624
 625 struct eth_device *eth_get_dev_by_name(const char *devname)
 626 {
 627         struct eth_device *dev, *target_dev;
 628
 629         BUG_ON(devname == NULL);
 630
 631         if (!eth_devices)
 632                 return NULL;
 633
 634         dev = eth_devices;
 635         target_dev = NULL;
 636         do {
 637                 if (strcmp(devname, dev->name) == 0) {
 638                         target_dev = dev;
 639                         break;
 640                 }
 641                 dev = dev->next;
 642         } while (dev != eth_devices);
 643
 644         return target_dev;
 645 }
 646
 647 struct eth_device *eth_get_dev_by_index(int index)
 648 {
 649         struct eth_device *dev, *target_dev;
 650
 651         if (!eth_devices)
 652                 return NULL;
 653
 654         dev = eth_devices;
 655         target_dev = NULL;
 656         do {
 657                 if (dev->index == index) {
 658                         target_dev = dev;
 659                         break;
 660                 }
 661                 dev = dev->next;
 662         } while (dev != eth_devices);
 663
 664         return target_dev;
 665 }
 666
 667 int eth_get_dev_index(void)
 668 {
 669         if (!eth_current)
 670                 return -1;
 671
 672         return eth_current->index;
 673 }
 674
 675 static int on_ethaddr(const char *name, const char *value, enum env_op op,
 676         int flags)
 677 {
 678         int index;
 679         struct eth_device *dev;
 680
 681         if (!eth_devices)
 682                 return 0;
 683
 684         /* look for an index after "eth" */
 685         index = simple_strtoul(name + 3, NULL, 10);
 686
 687         dev = eth_devices;
 688         do {
 689                 if (dev->index == index) {
 690                         switch (op) {
 691                         case env_op_create:
 692                         case env_op_overwrite:
 693                                 eth_parse_enetaddr(value, dev->enetaddr);
 694                                 break;
 695                         case env_op_delete:
 696                                 memset(dev->enetaddr, 0, 6);
 697                         }
 698                 }
 699                 dev = dev->next;
 700         } while (dev != eth_devices);
 701
 702         return 0;
 703 }
 704 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);
 705
 706 int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
 707                    int eth_number)
 708 {
 709         unsigned char env_enetaddr[6];
 710         int ret = 0;
 711
 712         eth_getenv_enetaddr_by_index(base_name, eth_number, env_enetaddr);
 713
 714         if (!is_zero_ethaddr(env_enetaddr)) {
 715                 if (!is_zero_ethaddr(dev->enetaddr) &&
 716                     memcmp(dev->enetaddr, env_enetaddr, 6)) {
 717                         printf("\nWarning: %s MAC addresses don't match:\n",
 718                                dev->name);
 719                         printf("Address in SROM is         %pM\n",
 720                                dev->enetaddr);
 721                         printf("Address in environment is  %pM\n",
 722                                env_enetaddr);
 723                 }
 724
 725                 memcpy(dev->enetaddr, env_enetaddr, 6);
 726         } else if (is_valid_ethaddr(dev->enetaddr)) {
 727                 eth_setenv_enetaddr_by_index(base_name, eth_number,
 728                                              dev->enetaddr);
 729                 printf("\nWarning: %s using MAC address from net device\n",
 730                        dev->name);
 731         } else if (is_zero_ethaddr(dev->enetaddr)) {
 732 #ifdef CONFIG_NET_RANDOM_ETHADDR
 733                 net_random_ethaddr(dev->enetaddr);
 734                 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
 735                        dev->name, eth_number, dev->enetaddr);
 736 #else
 737                 printf("\nError: %s address not set.\n",
 738                        dev->name);
 739                 return -EINVAL;
 740 #endif
 741         }
 742
 743         if (dev->write_hwaddr && !eth_mac_skip(eth_number)) {
 744                 if (!is_valid_ethaddr(dev->enetaddr)) {
 745                         printf("\nError: %s address %pM illegal value\n",
 746                                dev->name, dev->enetaddr);
 747                         return -EINVAL;
 748                 }
 749
 750                 ret = dev->write_hwaddr(dev);
 751                 if (ret)
 752                         printf("\nWarning: %s failed to set MAC address\n",
 753                                dev->name);
 754         }
 755
 756         return ret;
 757 }
 758
 759 int eth_register(struct eth_device *dev)
 760 {
 761         struct eth_device *d;
 762         static int index;
 763
 764         assert(strlen(dev->name) < sizeof(dev->name));
 765
 766         if (!eth_devices) {
 767                 eth_devices = dev;
 768                 eth_current = dev;
 769                 eth_current_changed();
 770         } else {
 771                 for (d = eth_devices; d->next != eth_devices; d = d->next)
 772                         ;
 773                 d->next = dev;
 774         }
 775
 776         dev->state = ETH_STATE_INIT;
 777         dev->next  = eth_devices;
 778         dev->index = index++;
 779
 780         return 0;
 781 }
 782
 783 int eth_unregister(struct eth_device *dev)
 784 {
 785         struct eth_device *cur;
 786
 787         /* No device */
 788         if (!eth_devices)
 789                 return -ENODEV;
 790
 791         for (cur = eth_devices; cur->next != eth_devices && cur->next != dev;
 792              cur = cur->next)
 793                 ;
 794
 795         /* Device not found */
 796         if (cur->next != dev)
 797                 return -ENODEV;
 798
 799         cur->next = dev->next;
 800
 801         if (eth_devices == dev)
 802                 eth_devices = dev->next == eth_devices ? NULL : dev->next;
 803
 804         if (eth_current == dev) {
 805                 eth_current = eth_devices;
 806                 eth_current_changed();
 807         }
 808
 809         return 0;
 810 }
 811
 812 int eth_initialize(void)
 813 {
 814         int num_devices = 0;
 815
 816         eth_devices = NULL;
 817         eth_current = NULL;
 818         eth_common_init();
 819
 820         if (!eth_devices) {
 821                 puts("No ethernet found.\n");
 822                 bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
 823         } else {
 824                 struct eth_device *dev = eth_devices;
 825                 char *ethprime = getenv("ethprime");
 826
 827                 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
 828                 do {
 829                         if (dev->index)
 830                                 puts(", ");
 831
 832                         printf("%s", dev->name);
 833
 834                         if (ethprime && strcmp(dev->name, ethprime) == 0) {
 835                                 eth_current = dev;
 836                                 puts(" [PRIME]");
 837                         }
 838
 839                         if (strchr(dev->name, ' '))
 840                                 puts("\nWarning: eth device name has a space!"
 841                                         "\n");
 842
 843                         eth_write_hwaddr(dev, "eth", dev->index);
 844
 845                         dev = dev->next;
 846                         num_devices++;
 847                 } while (dev != eth_devices);
 848
 849                 eth_current_changed();
 850                 putc('\n');
 851         }
 852
 853         return num_devices;
 854 }
 855
 856 #ifdef CONFIG_MCAST_TFTP
 857 /* Multicast.
 858  * mcast_addr: multicast ipaddr from which multicast Mac is made
 859  * join: 1=join, 0=leave.
 860  */
 861 int eth_mcast_join(struct in_addr mcast_ip, int join)
 862 {
 863         u8 mcast_mac[6];
 864         if (!eth_current || !eth_current->mcast)
 865                 return -1;
 866         mcast_mac[5] = htonl(mcast_ip.s_addr) & 0xff;
 867         mcast_mac[4] = (htonl(mcast_ip.s_addr)>>8) & 0xff;
 868         mcast_mac[3] = (htonl(mcast_ip.s_addr)>>16) & 0x7f;
 869         mcast_mac[2] = 0x5e;
 870         mcast_mac[1] = 0x0;
 871         mcast_mac[0] = 0x1;
 872         return eth_current->mcast(eth_current, mcast_mac, join);
 873 }
 874
 875 /* the 'way' for ethernet-CRC-32. Spliced in from Linux lib/crc32.c
 876  * and this is the ethernet-crc method needed for TSEC -- and perhaps
 877  * some other adapter -- hash tables
 878  */
 879 #define CRCPOLY_LE 0xedb88320
 880 u32 ether_crc(size_t len, unsigned char const *p)
 881 {
 882         int i;
 883         u32 crc;
 884         crc = ~0;
 885         while (len--) {
 886                 crc ^= *p++;
 887                 for (i = 0; i < 8; i++)
 888                         crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
 889         }
 890         /* an reverse the bits, cuz of way they arrive -- last-first */
 891         crc = (crc >> 16) | (crc << 16);
 892         crc = (crc >> 8 & 0x00ff00ff) | (crc << 8 & 0xff00ff00);
 893         crc = (crc >> 4 & 0x0f0f0f0f) | (crc << 4 & 0xf0f0f0f0);
 894         crc = (crc >> 2 & 0x33333333) | (crc << 2 & 0xcccccccc);
 895         crc = (crc >> 1 & 0x55555555) | (crc << 1 & 0xaaaaaaaa);
 896         return crc;
 897 }
 898
 899 #endif
 900
 901
 902 int eth_init(void)
 903 {
 904         struct eth_device *old_current;
 905
 906         if (!eth_current) {
 907                 puts("No ethernet found.\n");
 908                 return -ENODEV;
 909         }
 910
 911         old_current = eth_current;
 912         do {
 913                 debug("Trying %s\n", eth_current->name);
 914
 915                 if (eth_current->init(eth_current, gd->bd) >= 0) {
 916                         eth_current->state = ETH_STATE_ACTIVE;
 917
 918                         return 0;
 919                 }
 920                 debug("FAIL\n");
 921
 922                 eth_try_another(0);
 923         } while (old_current != eth_current);
 924
 925         return -ETIMEDOUT;
 926 }
 927
 928 void eth_halt(void)
 929 {
 930         if (!eth_current)
 931                 return;
 932
 933         eth_current->halt(eth_current);
 934
 935         eth_current->state = ETH_STATE_PASSIVE;
 936 }
 937
 938 int eth_is_active(struct eth_device *dev)
 939 {
 940         return dev && dev->state == ETH_STATE_ACTIVE;
 941 }
 942
 943 int eth_send(void *packet, int length)
 944 {
 945         if (!eth_current)
 946                 return -ENODEV;
 947
 948         return eth_current->send(eth_current, packet, length);
 949 }
 950
 951 int eth_rx(void)
 952 {
 953         if (!eth_current)
 954                 return -ENODEV;
 955
 956         return eth_current->recv(eth_current);
 957 }
 958 #endif /* ifndef CONFIG_DM_ETH */
 959
 960 #ifdef CONFIG_API
 961 static void eth_save_packet(void *packet, int length)
 962 {
 963         char *p = packet;
 964         int i;
 965
 966         if ((eth_rcv_last+1) % PKTBUFSRX == eth_rcv_current)
 967                 return;
 968
 969         if (PKTSIZE < length)
 970                 return;
 971
 972         for (i = 0; i < length; i++)
 973                 eth_rcv_bufs[eth_rcv_last].data[i] = p[i];
 974
 975         eth_rcv_bufs[eth_rcv_last].length = length;
 976         eth_rcv_last = (eth_rcv_last + 1) % PKTBUFSRX;
 977 }
 978
 979 int eth_receive(void *packet, int length)
 980 {
 981         char *p = packet;
 982         void *pp = push_packet;
 983         int i;
 984
 985         if (eth_rcv_current == eth_rcv_last) {
 986                 push_packet = eth_save_packet;
 987                 eth_rx();
 988                 push_packet = pp;
 989
 990                 if (eth_rcv_current == eth_rcv_last)
 991                         return -1;
 992         }
 993
 994         length = min(eth_rcv_bufs[eth_rcv_current].length, length);
 995
 996         for (i = 0; i < length; i++)
 997                 p[i] = eth_rcv_bufs[eth_rcv_current].data[i];
 998
 999         eth_rcv_current = (eth_rcv_current + 1) % PKTBUFSRX;
1000         return length;
1001 }
1002 #endif /* CONFIG_API */
1003
1004 static void eth_current_changed(void)
1005 {
1006         char *act = getenv("ethact");
1007         /* update current ethernet name */
1008         if (eth_get_dev()) {
1009                 if (act == NULL || strcmp(act, eth_get_name()) != 0)
1010                         setenv("ethact", eth_get_name());
1011         }
1012         /*
1013          * remove the variable completely if there is no active
1014          * interface
1015          */
1016         else if (act != NULL)
1017                 setenv("ethact", NULL);
1018 }
1019
1020 void eth_try_another(int first_restart)
1021 {
1022         static void *first_failed;
1023         char *ethrotate;
1024
1025         /*
1026          * Do not rotate between network interfaces when
1027          * 'ethrotate' variable is set to 'no'.
1028          */
1029         ethrotate = getenv("ethrotate");
1030         if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0))
1031                 return;
1032
1033         if (!eth_get_dev())
1034                 return;
1035
1036         if (first_restart)
1037                 first_failed = eth_get_dev();
1038
1039         eth_set_current_to_next();
1040
1041         eth_current_changed();
1042
1043         if (first_failed == eth_get_dev())
1044                 net_restart_wrap = 1;
1045 }
1046
1047 void eth_set_current(void)
1048 {
1049         static char *act;
1050         static int  env_changed_id;
1051         int     env_id;
1052
1053         env_id = get_env_id();
1054         if ((act == NULL) || (env_changed_id != env_id)) {
1055                 act = getenv("ethact");
1056                 env_changed_id = env_id;
1057         }
1058
1059         if (act == NULL) {
1060                 char *ethprime = getenv("ethprime");
1061                 void *dev = NULL;
1062
1063                 if (ethprime)
1064                         dev = eth_get_dev_by_name(ethprime);
1065                 if (dev)
1066                         eth_set_dev(dev);
1067                 else
1068                         eth_set_dev(NULL);
1069         } else {
1070                 eth_set_dev(eth_get_dev_by_name(act));
1071         }
1072
1073         eth_current_changed();
1074 }
1075
1076 const char *eth_get_name(void)
1077 {
1078         return eth_get_dev() ? eth_get_dev()->name : "unknown";
1079 }