cmd/net.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000
   4  * Wolfgang Denk, DENX Software Engineering, [email protected].
   5  */
   6
   7 #define LOG_CATEGORY    UCLASS_ETH
   8
   9 /*
  10  * Boot support
  11  */
  12 #include <bootstage.h>
  13 #include <command.h>
  14 #include <dm.h>
  15 #include <dm/devres.h>
  16 #include <env.h>
  17 #include <image.h>
  18 #include <log.h>
  19 #include <net.h>
  20 #include <net6.h>
  21 #include <net/udp.h>
  22 #include <net/sntp.h>
  23 #include <net/ncsi.h>
  24
  25 static int netboot_common(enum proto_t, struct cmd_tbl *, int, char * const []);
  26
  27 #ifdef CONFIG_CMD_BOOTP
  28 static int do_bootp(struct cmd_tbl *cmdtp, int flag, int argc,
  29                     char *const argv[])
  30 {
  31         return netboot_common(BOOTP, cmdtp, argc, argv);
  32 }
  33
  34 U_BOOT_CMD(
  35         bootp,  3,      1,      do_bootp,
  36         "boot image via network using BOOTP/TFTP protocol",
  37         "[loadAddress] [[hostIPaddr:]bootfilename]"
  38 );
  39 #endif
  40
  41 #ifdef CONFIG_CMD_TFTPBOOT
  42 int do_tftpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
  43 {
  44         int ret;
  45
  46         bootstage_mark_name(BOOTSTAGE_KERNELREAD_START, "tftp_start");
  47         ret = netboot_common(TFTPGET, cmdtp, argc, argv);
  48         bootstage_mark_name(BOOTSTAGE_KERNELREAD_STOP, "tftp_done");
  49         return ret;
  50 }
  51
  52 #if IS_ENABLED(CONFIG_IPV6)
  53 U_BOOT_CMD(
  54         tftpboot,       4,      1,      do_tftpb,
  55         "boot image via network using TFTP protocol\n"
  56         "To use IPv6 add -ipv6 parameter or use IPv6 hostIPaddr framed "
  57         "with [] brackets",
  58         "[loadAddress] [[hostIPaddr:]bootfilename] [" USE_IP6_CMD_PARAM "]"
  59 );
  60 #else
  61 U_BOOT_CMD(
  62         tftpboot,       3,      1,      do_tftpb,
  63         "load file via network using TFTP protocol",
  64         "[loadAddress] [[hostIPaddr:]bootfilename]"
  65 );
  66 #endif
  67 #endif
  68
  69 #ifdef CONFIG_CMD_TFTPPUT
  70 static int do_tftpput(struct cmd_tbl *cmdtp, int flag, int argc,
  71                       char *const argv[])
  72 {
  73         return netboot_common(TFTPPUT, cmdtp, argc, argv);
  74 }
  75
  76 U_BOOT_CMD(
  77         tftpput,        4,      1,      do_tftpput,
  78         "TFTP put command, for uploading files to a server",
  79         "Address Size [[hostIPaddr:]filename]"
  80 );
  81 #endif
  82
  83 #ifdef CONFIG_CMD_TFTPSRV
  84 static int do_tftpsrv(struct cmd_tbl *cmdtp, int flag, int argc,
  85                       char *const argv[])
  86 {
  87         return netboot_common(TFTPSRV, cmdtp, argc, argv);
  88 }
  89
  90 U_BOOT_CMD(
  91         tftpsrv,        2,      1,      do_tftpsrv,
  92         "act as a TFTP server and boot the first received file",
  93         "[loadAddress]\n"
  94         "Listen for an incoming TFTP transfer, receive a file and boot it.\n"
  95         "The transfer is aborted if a transfer has not been started after\n"
  96         "about 50 seconds or if Ctrl-C is pressed."
  97 );
  98 #endif
  99
 100
 101 #ifdef CONFIG_CMD_RARP
 102 int do_rarpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 103 {
 104         return netboot_common(RARP, cmdtp, argc, argv);
 105 }
 106
 107 U_BOOT_CMD(
 108         rarpboot,       3,      1,      do_rarpb,
 109         "boot image via network using RARP/TFTP protocol",
 110         "[loadAddress] [[hostIPaddr:]bootfilename]"
 111 );
 112 #endif
 113
 114 #if defined(CONFIG_CMD_DHCP6)
 115 static int do_dhcp6(struct cmd_tbl *cmdtp, int flag, int argc,
 116                     char *const argv[])
 117 {
 118         int i;
 119         int dhcp_argc;
 120         char *dhcp_argv[] = {NULL, NULL, NULL, NULL};
 121
 122         /* Add -ipv6 flag for autoload */
 123         for (i = 0; i < argc; i++)
 124                 dhcp_argv[i] = argv[i];
 125         dhcp_argc = argc + 1;
 126         dhcp_argv[dhcp_argc - 1] =  USE_IP6_CMD_PARAM;
 127
 128         return netboot_common(DHCP6, cmdtp, dhcp_argc, dhcp_argv);
 129 }
 130
 131 U_BOOT_CMD(dhcp6,       3,      1,      do_dhcp6,
 132            "boot image via network using DHCPv6/TFTP protocol.\n"
 133            "Use IPv6 hostIPaddr framed with [] brackets",
 134            "[loadAddress] [[hostIPaddr:]bootfilename]");
 135 #endif
 136
 137 #if defined(CONFIG_CMD_DHCP)
 138 static int do_dhcp(struct cmd_tbl *cmdtp, int flag, int argc,
 139                    char *const argv[])
 140 {
 141         return netboot_common(DHCP, cmdtp, argc, argv);
 142 }
 143
 144 U_BOOT_CMD(
 145         dhcp,   3,      1,      do_dhcp,
 146         "boot image via network using DHCP/TFTP protocol",
 147         "[loadAddress] [[hostIPaddr:]bootfilename]"
 148 );
 149
 150 int dhcp_run(ulong addr, const char *fname, bool autoload)
 151 {
 152         char *dhcp_argv[] = {"dhcp", NULL, (char *)fname, NULL};
 153         struct cmd_tbl cmdtp = {};      /* dummy */
 154         char file_addr[17];
 155         int old_autoload;
 156         int ret, result;
 157
 158         log_debug("addr=%lx, fname=%s, autoload=%d\n", addr, fname, autoload);
 159         old_autoload = env_get_yesno("autoload");
 160         ret = env_set("autoload", autoload ? "y" : "n");
 161         if (ret)
 162                 return log_msg_ret("en1", -EINVAL);
 163
 164         if (autoload) {
 165                 sprintf(file_addr, "%lx", addr);
 166                 dhcp_argv[1] = file_addr;
 167         }
 168
 169         result = do_dhcp(&cmdtp, 0, !autoload ? 1 : fname ? 3 : 2, dhcp_argv);
 170
 171         ret = env_set("autoload", old_autoload == -1 ? NULL :
 172                       old_autoload ? "y" : "n");
 173         if (ret)
 174                 return log_msg_ret("en2", -EINVAL);
 175
 176         if (result)
 177                 return log_msg_ret("res", -ENOENT);
 178
 179         return 0;
 180 }
 181 #endif
 182
 183 #if defined(CONFIG_CMD_NFS)
 184 static int do_nfs(struct cmd_tbl *cmdtp, int flag, int argc,
 185                   char *const argv[])
 186 {
 187         return netboot_common(NFS, cmdtp, argc, argv);
 188 }
 189
 190 U_BOOT_CMD(
 191         nfs,    3,      1,      do_nfs,
 192         "boot image via network using NFS protocol",
 193         "[loadAddress] [[hostIPaddr:]bootfilename]"
 194 );
 195 #endif
 196
 197 #if defined(CONFIG_CMD_WGET)
 198 static int do_wget(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
 199 {
 200         return netboot_common(WGET, cmdtp, argc, argv);
 201 }
 202
 203 U_BOOT_CMD(
 204         wget,   3,      1,      do_wget,
 205         "boot image via network using HTTP protocol",
 206         "[loadAddress] [[hostIPaddr:]path and image name]"
 207 );
 208 #endif
 209
 210 static void netboot_update_env(void)
 211 {
 212         char tmp[46];
 213
 214         if (net_gateway.s_addr) {
 215                 ip_to_string(net_gateway, tmp);
 216                 env_set("gatewayip", tmp);
 217         }
 218
 219         if (net_netmask.s_addr) {
 220                 ip_to_string(net_netmask, tmp);
 221                 env_set("netmask", tmp);
 222         }
 223
 224 #ifdef CONFIG_CMD_BOOTP
 225         if (net_hostname[0])
 226                 env_set("hostname", net_hostname);
 227 #endif
 228
 229 #ifdef CONFIG_CMD_BOOTP
 230         if (net_root_path[0])
 231                 env_set("rootpath", net_root_path);
 232 #endif
 233
 234         if (net_ip.s_addr) {
 235                 ip_to_string(net_ip, tmp);
 236                 env_set("ipaddr", tmp);
 237         }
 238         /*
 239          * Only attempt to change serverip if net/bootp.c:store_net_params()
 240          * could have set it
 241          */
 242         if (!IS_ENABLED(CONFIG_BOOTP_SERVERIP) && net_server_ip.s_addr) {
 243                 ip_to_string(net_server_ip, tmp);
 244                 env_set("serverip", tmp);
 245         }
 246         if (net_dns_server.s_addr) {
 247                 ip_to_string(net_dns_server, tmp);
 248                 env_set("dnsip", tmp);
 249         }
 250 #if defined(CONFIG_BOOTP_DNS2)
 251         if (net_dns_server2.s_addr) {
 252                 ip_to_string(net_dns_server2, tmp);
 253                 env_set("dnsip2", tmp);
 254         }
 255 #endif
 256 #ifdef CONFIG_CMD_BOOTP
 257         if (net_nis_domain[0])
 258                 env_set("domain", net_nis_domain);
 259 #endif
 260
 261 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_TIMEOFFSET)
 262         if (net_ntp_time_offset) {
 263                 sprintf(tmp, "%d", net_ntp_time_offset);
 264                 env_set("timeoffset", tmp);
 265         }
 266 #endif
 267 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_NTPSERVER)
 268         if (net_ntp_server.s_addr) {
 269                 ip_to_string(net_ntp_server, tmp);
 270                 env_set("ntpserverip", tmp);
 271         }
 272 #endif
 273
 274         if (IS_ENABLED(CONFIG_IPV6)) {
 275                 if (!ip6_is_unspecified_addr(&net_ip6) ||
 276                     net_prefix_length != 0) {
 277                         if (net_prefix_length != 0)
 278                                 snprintf(tmp, sizeof(tmp), "%pI6c/%d", &net_ip6, net_prefix_length);
 279                         else
 280                                 snprintf(tmp, sizeof(tmp), "%pI6c", &net_ip6);
 281                         env_set("ip6addr", tmp);
 282                 }
 283
 284                 if (!ip6_is_unspecified_addr(&net_server_ip6)) {
 285                         snprintf(tmp, sizeof(tmp), "%pI6c", &net_server_ip6);
 286                         env_set("serverip6", tmp);
 287                 }
 288
 289                 if (!ip6_is_unspecified_addr(&net_gateway6)) {
 290                         snprintf(tmp, sizeof(tmp), "%pI6c", &net_gateway6);
 291                         env_set("gatewayip6", tmp);
 292                 }
 293         }
 294 }
 295
 296 /**
 297  * parse_addr_size() - parse address and size arguments for tftpput
 298  *
 299  * @argv:       command line arguments
 300  * Return:      0 on success
 301  */
 302 static int parse_addr_size(char * const argv[])
 303 {
 304         if (strict_strtoul(argv[1], 16, &image_save_addr) < 0 ||
 305             strict_strtoul(argv[2], 16, &image_save_size) < 0) {
 306                 printf("Invalid address/size\n");
 307                 return CMD_RET_USAGE;
 308         }
 309         return 0;
 310 }
 311
 312 /**
 313  * parse_args() - parse command line arguments
 314  *
 315  * @proto:      command prototype
 316  * @argc:       number of arguments
 317  * @argv:       command line arguments
 318  * Return:      0 on success
 319  */
 320 static int parse_args(enum proto_t proto, int argc, char *const argv[])
 321 {
 322         ulong addr;
 323         char *end;
 324
 325         switch (argc) {
 326         case 1:
 327                 if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT)
 328                         return 1;
 329
 330                 /* refresh bootfile name from env */
 331                 copy_filename(net_boot_file_name, env_get("bootfile"),
 332                               sizeof(net_boot_file_name));
 333                 break;
 334
 335         case 2:
 336                 if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT)
 337                         return 1;
 338                 /*
 339                  * Only one arg - accept two forms:
 340                  * Just load address, or just boot file name. The latter
 341                  * form must be written in a format which can not be
 342                  * mis-interpreted as a valid number.
 343                  */
 344                 addr = hextoul(argv[1], &end);
 345                 if (end == (argv[1] + strlen(argv[1]))) {
 346                         image_load_addr = addr;
 347                         /* refresh bootfile name from env */
 348                         copy_filename(net_boot_file_name, env_get("bootfile"),
 349                                       sizeof(net_boot_file_name));
 350                 } else {
 351                         net_boot_file_name_explicit = true;
 352                         copy_filename(net_boot_file_name, argv[1],
 353                                       sizeof(net_boot_file_name));
 354                 }
 355                 break;
 356
 357         case 3:
 358                 if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT) {
 359                         if (parse_addr_size(argv))
 360                                 return 1;
 361                 } else {
 362                         image_load_addr = hextoul(argv[1], NULL);
 363                         net_boot_file_name_explicit = true;
 364                         copy_filename(net_boot_file_name, argv[2],
 365                                       sizeof(net_boot_file_name));
 366                 }
 367                 break;
 368
 369 #ifdef CONFIG_CMD_TFTPPUT
 370         case 4:
 371                 if (parse_addr_size(argv))
 372                         return 1;
 373                 net_boot_file_name_explicit = true;
 374                 copy_filename(net_boot_file_name, argv[3],
 375                               sizeof(net_boot_file_name));
 376                 break;
 377 #endif
 378         default:
 379                 return 1;
 380         }
 381         return 0;
 382 }
 383
 384 static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc,
 385                           char *const argv[])
 386 {
 387         char *s;
 388         int   rcode = 0;
 389         int   size;
 390
 391         net_boot_file_name_explicit = false;
 392         *net_boot_file_name = '\0';
 393
 394         /* pre-set image_load_addr */
 395         s = env_get("loadaddr");
 396         if (s != NULL)
 397                 image_load_addr = hextoul(s, NULL);
 398
 399         if (IS_ENABLED(CONFIG_IPV6)) {
 400                 use_ip6 = false;
 401
 402                 /* IPv6 parameter has to be always *last* */
 403                 if (!strcmp(argv[argc - 1], USE_IP6_CMD_PARAM)) {
 404                         use_ip6 = true;
 405                         /* It is a hack not to break switch/case code */
 406                         --argc;
 407                 }
 408         }
 409
 410         if (parse_args(proto, argc, argv)) {
 411                 bootstage_error(BOOTSTAGE_ID_NET_START);
 412                 return CMD_RET_USAGE;
 413         }
 414
 415         bootstage_mark(BOOTSTAGE_ID_NET_START);
 416
 417         if (IS_ENABLED(CONFIG_IPV6) && !use_ip6) {
 418                 char *s, *e;
 419                 size_t len;
 420
 421                 s = strchr(net_boot_file_name, '[');
 422                 e = strchr(net_boot_file_name, ']');
 423                 if (s && e) {
 424                         len = e - s;
 425                         if (!string_to_ip6(s + 1, len - 1, &net_server_ip6))
 426                                 use_ip6 = true;
 427                 }
 428         }
 429
 430         size = net_loop(proto);
 431         if (size < 0) {
 432                 bootstage_error(BOOTSTAGE_ID_NET_NETLOOP_OK);
 433                 return CMD_RET_FAILURE;
 434         }
 435         bootstage_mark(BOOTSTAGE_ID_NET_NETLOOP_OK);
 436
 437         /* net_loop ok, update environment */
 438         netboot_update_env();
 439
 440         /* done if no file was loaded (no errors though) */
 441         if (size == 0) {
 442                 bootstage_error(BOOTSTAGE_ID_NET_LOADED);
 443                 return CMD_RET_SUCCESS;
 444         }
 445
 446         bootstage_mark(BOOTSTAGE_ID_NET_LOADED);
 447
 448         rcode = bootm_maybe_autostart(cmdtp, argv[0]);
 449
 450         if (rcode == CMD_RET_SUCCESS)
 451                 bootstage_mark(BOOTSTAGE_ID_NET_DONE);
 452         else
 453                 bootstage_error(BOOTSTAGE_ID_NET_DONE_ERR);
 454         return rcode;
 455 }
 456
 457 #if defined(CONFIG_CMD_PING)
 458 static int do_ping(struct cmd_tbl *cmdtp, int flag, int argc,
 459                    char *const argv[])
 460 {
 461         if (argc < 2)
 462                 return CMD_RET_USAGE;
 463
 464         net_ping_ip = string_to_ip(argv[1]);
 465         if (net_ping_ip.s_addr == 0)
 466                 return CMD_RET_USAGE;
 467
 468         if (net_loop(PING) < 0) {
 469                 printf("ping failed; host %s is not alive\n", argv[1]);
 470                 return CMD_RET_FAILURE;
 471         }
 472
 473         printf("host %s is alive\n", argv[1]);
 474
 475         return CMD_RET_SUCCESS;
 476 }
 477
 478 U_BOOT_CMD(
 479         ping,   2,      1,      do_ping,
 480         "send ICMP ECHO_REQUEST to network host",
 481         "pingAddress"
 482 );
 483 #endif
 484
 485 #if IS_ENABLED(CONFIG_CMD_PING6)
 486 int do_ping6(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
 487 {
 488         if (string_to_ip6(argv[1], strlen(argv[1]), &net_ping_ip6))
 489                 return CMD_RET_USAGE;
 490
 491         use_ip6 = true;
 492         if (net_loop(PING6) < 0) {
 493                 use_ip6 = false;
 494                 printf("ping6 failed; host %pI6c is not alive\n",
 495                        &net_ping_ip6);
 496                 return 1;
 497         }
 498
 499         use_ip6 = false;
 500         printf("host %pI6c is alive\n", &net_ping_ip6);
 501         return 0;
 502 }
 503
 504 U_BOOT_CMD(
 505         ping6,  2,      1,      do_ping6,
 506         "send ICMPv6 ECHO_REQUEST to network host",
 507         "pingAddress"
 508 );
 509 #endif /* CONFIG_CMD_PING6 */
 510
 511 #if defined(CONFIG_CMD_CDP)
 512
 513 static void cdp_update_env(void)
 514 {
 515         char tmp[16];
 516
 517         if (cdp_appliance_vlan != htons(-1)) {
 518                 printf("CDP offered appliance VLAN %d\n",
 519                        ntohs(cdp_appliance_vlan));
 520                 vlan_to_string(cdp_appliance_vlan, tmp);
 521                 env_set("vlan", tmp);
 522                 net_our_vlan = cdp_appliance_vlan;
 523         }
 524
 525         if (cdp_native_vlan != htons(-1)) {
 526                 printf("CDP offered native VLAN %d\n", ntohs(cdp_native_vlan));
 527                 vlan_to_string(cdp_native_vlan, tmp);
 528                 env_set("nvlan", tmp);
 529                 net_native_vlan = cdp_native_vlan;
 530         }
 531 }
 532
 533 int do_cdp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 534 {
 535         int r;
 536
 537         r = net_loop(CDP);
 538         if (r < 0) {
 539                 printf("cdp failed; perhaps not a CISCO switch?\n");
 540                 return CMD_RET_FAILURE;
 541         }
 542
 543         cdp_update_env();
 544
 545         return CMD_RET_SUCCESS;
 546 }
 547
 548 U_BOOT_CMD(
 549         cdp,    1,      1,      do_cdp,
 550         "Perform CDP network configuration",
 551         "\n"
 552 );
 553 #endif
 554
 555 #if defined(CONFIG_CMD_SNTP)
 556 static struct udp_ops sntp_ops = {
 557         .prereq = sntp_prereq,
 558         .start = sntp_start,
 559         .data = NULL,
 560 };
 561
 562 int do_sntp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 563 {
 564         char *toff;
 565
 566         if (argc < 2) {
 567                 net_ntp_server = env_get_ip("ntpserverip");
 568                 if (net_ntp_server.s_addr == 0) {
 569                         printf("ntpserverip not set\n");
 570                         return CMD_RET_FAILURE;
 571                 }
 572         } else {
 573                 net_ntp_server = string_to_ip(argv[1]);
 574                 if (net_ntp_server.s_addr == 0) {
 575                         printf("Bad NTP server IP address\n");
 576                         return CMD_RET_FAILURE;
 577                 }
 578         }
 579
 580         toff = env_get("timeoffset");
 581         if (toff == NULL)
 582                 net_ntp_time_offset = 0;
 583         else
 584                 net_ntp_time_offset = simple_strtol(toff, NULL, 10);
 585
 586         if (udp_loop(&sntp_ops) < 0) {
 587                 printf("SNTP failed: host %pI4 not responding\n",
 588                        &net_ntp_server);
 589                 return CMD_RET_FAILURE;
 590         }
 591
 592         return CMD_RET_SUCCESS;
 593 }
 594
 595 U_BOOT_CMD(
 596         sntp,   2,      1,      do_sntp,
 597         "synchronize RTC via network",
 598         "[NTP server IP]\n"
 599 );
 600 #endif
 601
 602 #if defined(CONFIG_CMD_DNS)
 603 int do_dns(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 604 {
 605         if (argc == 1)
 606                 return CMD_RET_USAGE;
 607
 608         /*
 609          * We should check for a valid hostname:
 610          * - Each label must be between 1 and 63 characters long
 611          * - the entire hostname has a maximum of 255 characters
 612          * - only the ASCII letters 'a' through 'z' (case-insensitive),
 613          *   the digits '0' through '9', and the hyphen
 614          * - cannot begin or end with a hyphen
 615          * - no other symbols, punctuation characters, or blank spaces are
 616          *   permitted
 617          * but hey - this is a minimalist implmentation, so only check length
 618          * and let the name server deal with things.
 619          */
 620         if (strlen(argv[1]) >= 255) {
 621                 printf("dns error: hostname too long\n");
 622                 return CMD_RET_FAILURE;
 623         }
 624
 625         net_dns_resolve = argv[1];
 626
 627         if (argc == 3)
 628                 net_dns_env_var = argv[2];
 629         else
 630                 net_dns_env_var = NULL;
 631
 632         if (net_loop(DNS) < 0) {
 633                 printf("dns lookup of %s failed, check setup\n", argv[1]);
 634                 return CMD_RET_FAILURE;
 635         }
 636
 637         return CMD_RET_SUCCESS;
 638 }
 639
 640 U_BOOT_CMD(
 641         dns,    3,      1,      do_dns,
 642         "lookup the IP of a hostname",
 643         "hostname [envvar]"
 644 );
 645
 646 #endif  /* CONFIG_CMD_DNS */
 647
 648 #if defined(CONFIG_CMD_LINK_LOCAL)
 649 static int do_link_local(struct cmd_tbl *cmdtp, int flag, int argc,
 650                          char *const argv[])
 651 {
 652         char tmp[22];
 653
 654         if (net_loop(LINKLOCAL) < 0)
 655                 return CMD_RET_FAILURE;
 656
 657         net_gateway.s_addr = 0;
 658         ip_to_string(net_gateway, tmp);
 659         env_set("gatewayip", tmp);
 660
 661         ip_to_string(net_netmask, tmp);
 662         env_set("netmask", tmp);
 663
 664         ip_to_string(net_ip, tmp);
 665         env_set("ipaddr", tmp);
 666         env_set("llipaddr", tmp); /* store this for next time */
 667
 668         return CMD_RET_SUCCESS;
 669 }
 670
 671 U_BOOT_CMD(
 672         linklocal,      1,      1,      do_link_local,
 673         "acquire a network IP address using the link-local protocol",
 674         ""
 675 );
 676
 677 #endif  /* CONFIG_CMD_LINK_LOCAL */
 678
 679 static int do_net_list(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 680 {
 681         const struct udevice *current = eth_get_dev();
 682         unsigned char env_enetaddr[ARP_HLEN];
 683         const struct udevice *dev;
 684         struct uclass *uc;
 685
 686         uclass_id_foreach_dev(UCLASS_ETH, dev, uc) {
 687                 eth_env_get_enetaddr_by_index("eth", dev_seq(dev), env_enetaddr);
 688                 printf("eth%d : %s %pM %s\n", dev_seq(dev), dev->name, env_enetaddr,
 689                        current == dev ? "active" : "");
 690         }
 691         return CMD_RET_SUCCESS;
 692 }
 693
 694 static int do_net_stats(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 695 {
 696         int nstats, err, i, off;
 697         struct udevice *dev;
 698         u64 *values;
 699         u8 *strings;
 700
 701         if (argc < 2)
 702                 return CMD_RET_USAGE;
 703
 704         err = uclass_get_device_by_name(UCLASS_ETH, argv[1], &dev);
 705         if (err) {
 706                 printf("Could not find device %s\n", argv[1]);
 707                 return CMD_RET_FAILURE;
 708         }
 709
 710         if (!eth_get_ops(dev)->get_sset_count ||
 711             !eth_get_ops(dev)->get_strings ||
 712             !eth_get_ops(dev)->get_stats) {
 713                 printf("Driver does not implement stats dump!\n");
 714                 return CMD_RET_FAILURE;
 715         }
 716
 717         nstats = eth_get_ops(dev)->get_sset_count(dev);
 718         strings = kcalloc(nstats, ETH_GSTRING_LEN, GFP_KERNEL);
 719         if (!strings)
 720                 return CMD_RET_FAILURE;
 721
 722         values = kcalloc(nstats, sizeof(u64), GFP_KERNEL);
 723         if (!values)
 724                 goto err_free_strings;
 725
 726         eth_get_ops(dev)->get_strings(dev, strings);
 727         eth_get_ops(dev)->get_stats(dev, values);
 728
 729         off = 0;
 730         for (i = 0; i < nstats; i++) {
 731                 printf("  %s: %llu\n", &strings[off], values[i]);
 732                 off += ETH_GSTRING_LEN;
 733         };
 734
 735         return CMD_RET_SUCCESS;
 736
 737 err_free_strings:
 738         kfree(strings);
 739
 740         return CMD_RET_FAILURE;
 741 }
 742
 743 static struct cmd_tbl cmd_net[] = {
 744         U_BOOT_CMD_MKENT(list, 1, 0, do_net_list, "", ""),
 745         U_BOOT_CMD_MKENT(stats, 2, 0, do_net_stats, "", ""),
 746 };
 747
 748 static int do_net(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 749 {
 750         struct cmd_tbl *cp;
 751
 752         cp = find_cmd_tbl(argv[1], cmd_net, ARRAY_SIZE(cmd_net));
 753
 754         /* Drop the net command */
 755         argc--;
 756         argv++;
 757
 758         if (!cp || argc > cp->maxargs)
 759                 return CMD_RET_USAGE;
 760         if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
 761                 return CMD_RET_SUCCESS;
 762
 763         return cp->cmd(cmdtp, flag, argc, argv);
 764 }
 765
 766 U_BOOT_CMD(
 767         net, 3, 1, do_net,
 768         "NET sub-system",
 769         "list - list available devices\n"
 770         "stats <device> - dump statistics for specified device\n"
 771 );
 772
 773 #if defined(CONFIG_CMD_NCSI)
 774 static int do_ncsi(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
 775 {
 776         if (!phy_interface_is_ncsi() || !ncsi_active()) {
 777                 printf("Device not configured for NC-SI\n");
 778                 return CMD_RET_FAILURE;
 779         }
 780
 781         if (net_loop(NCSI) < 0)
 782                 return CMD_RET_FAILURE;
 783
 784         return CMD_RET_SUCCESS;
 785 }
 786
 787 U_BOOT_CMD(
 788         ncsi,   1,      1,      do_ncsi,
 789         "Configure attached NIC via NC-SI",
 790         ""
 791 );
 792 #endif  /* CONFIG_CMD_NCSI */