cmd/net.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   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 #ifdef CONFIG_CMD_RARP
 101 int do_rarpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 102 {
 103         return netboot_common(RARP, cmdtp, argc, argv);
 104 }
 105
 106 U_BOOT_CMD(
 107         rarpboot,       3,      1,      do_rarpb,
 108         "boot image via network using RARP/TFTP protocol",
 109         "[loadAddress] [[hostIPaddr:]bootfilename]"
 110 );
 111 #endif
 112
 113 #if defined(CONFIG_CMD_DHCP6)
 114 static int do_dhcp6(struct cmd_tbl *cmdtp, int flag, int argc,
 115                     char *const argv[])
 116 {
 117         int i;
 118         int dhcp_argc;
 119         char *dhcp_argv[] = {NULL, NULL, NULL, NULL};
 120
 121         /* Add -ipv6 flag for autoload */
 122         for (i = 0; i < argc; i++)
 123                 dhcp_argv[i] = argv[i];
 124         dhcp_argc = argc + 1;
 125         dhcp_argv[dhcp_argc - 1] =  USE_IP6_CMD_PARAM;
 126
 127         return netboot_common(DHCP6, cmdtp, dhcp_argc, dhcp_argv);
 128 }
 129
 130 U_BOOT_CMD(dhcp6,       3,      1,      do_dhcp6,
 131            "boot image via network using DHCPv6/TFTP protocol.\n"
 132            "Use IPv6 hostIPaddr framed with [] brackets",
 133            "[loadAddress] [[hostIPaddr:]bootfilename]");
 134 #endif
 135
 136 #if defined(CONFIG_CMD_DHCP)
 137 static int do_dhcp(struct cmd_tbl *cmdtp, int flag, int argc,
 138                    char *const argv[])
 139 {
 140         return netboot_common(DHCP, cmdtp, argc, argv);
 141 }
 142
 143 U_BOOT_CMD(
 144         dhcp,   3,      1,      do_dhcp,
 145         "boot image via network using DHCP/TFTP protocol",
 146         "[loadAddress] [[hostIPaddr:]bootfilename]"
 147 );
 148
 149 int dhcp_run(ulong addr, const char *fname, bool autoload)
 150 {
 151         char *dhcp_argv[] = {"dhcp", NULL, (char *)fname, NULL};
 152         struct cmd_tbl cmdtp = {};      /* dummy */
 153         char file_addr[17];
 154         int old_autoload;
 155         int ret, result;
 156
 157         log_debug("addr=%lx, fname=%s, autoload=%d\n", addr, fname, autoload);
 158         old_autoload = env_get_yesno("autoload");
 159         ret = env_set("autoload", autoload ? "y" : "n");
 160         if (ret)
 161                 return log_msg_ret("en1", -EINVAL);
 162
 163         if (autoload) {
 164                 sprintf(file_addr, "%lx", addr);
 165                 dhcp_argv[1] = file_addr;
 166         }
 167
 168         result = do_dhcp(&cmdtp, 0, !autoload ? 1 : fname ? 3 : 2, dhcp_argv);
 169
 170         ret = env_set("autoload", old_autoload == -1 ? NULL :
 171                       old_autoload ? "y" : "n");
 172         if (ret)
 173                 return log_msg_ret("en2", -EINVAL);
 174
 175         if (result)
 176                 return log_msg_ret("res", -ENOENT);
 177
 178         return 0;
 179 }
 180 #endif
 181
 182 #if defined(CONFIG_CMD_NFS)
 183 static int do_nfs(struct cmd_tbl *cmdtp, int flag, int argc,
 184                   char *const argv[])
 185 {
 186         return netboot_common(NFS, cmdtp, argc, argv);
 187 }
 188
 189 U_BOOT_CMD(
 190         nfs,    3,      1,      do_nfs,
 191         "boot image via network using NFS protocol",
 192         "[loadAddress] [[hostIPaddr:]bootfilename]"
 193 );
 194 #endif
 195
 196 #if defined(CONFIG_CMD_WGET)
 197 static int do_wget(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
 198 {
 199         return netboot_common(WGET, cmdtp, argc, argv);
 200 }
 201
 202 U_BOOT_CMD(
 203         wget,   3,      1,      do_wget,
 204         "boot image via network using HTTP protocol",
 205         "[loadAddress] [[hostIPaddr:]path and image name]"
 206 );
 207 #endif
 208
 209 static void netboot_update_env(void)
 210 {
 211         char tmp[46];
 212
 213         if (net_gateway.s_addr) {
 214                 ip_to_string(net_gateway, tmp);
 215                 env_set("gatewayip", tmp);
 216         }
 217
 218         if (net_netmask.s_addr) {
 219                 ip_to_string(net_netmask, tmp);
 220                 env_set("netmask", tmp);
 221         }
 222
 223 #ifdef CONFIG_CMD_BOOTP
 224         if (net_hostname[0])
 225                 env_set("hostname", net_hostname);
 226 #endif
 227
 228 #ifdef CONFIG_CMD_BOOTP
 229         if (net_root_path[0])
 230                 env_set("rootpath", net_root_path);
 231 #endif
 232
 233         if (net_ip.s_addr) {
 234                 ip_to_string(net_ip, tmp);
 235                 env_set("ipaddr", tmp);
 236         }
 237         /*
 238          * Only attempt to change serverip if net/bootp.c:store_net_params()
 239          * could have set it
 240          */
 241         if (!IS_ENABLED(CONFIG_BOOTP_SERVERIP) && net_server_ip.s_addr) {
 242                 ip_to_string(net_server_ip, tmp);
 243                 env_set("serverip", tmp);
 244         }
 245         if (net_dns_server.s_addr) {
 246                 ip_to_string(net_dns_server, tmp);
 247                 env_set("dnsip", tmp);
 248         }
 249 #if defined(CONFIG_BOOTP_DNS2)
 250         if (net_dns_server2.s_addr) {
 251                 ip_to_string(net_dns_server2, tmp);
 252                 env_set("dnsip2", tmp);
 253         }
 254 #endif
 255 #ifdef CONFIG_CMD_BOOTP
 256         if (net_nis_domain[0])
 257                 env_set("domain", net_nis_domain);
 258 #endif
 259
 260 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_TIMEOFFSET)
 261         if (net_ntp_time_offset) {
 262                 sprintf(tmp, "%d", net_ntp_time_offset);
 263                 env_set("timeoffset", tmp);
 264         }
 265 #endif
 266 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_NTPSERVER)
 267         if (net_ntp_server.s_addr) {
 268                 ip_to_string(net_ntp_server, tmp);
 269                 env_set("ntpserverip", tmp);
 270         }
 271 #endif
 272
 273         if (IS_ENABLED(CONFIG_IPV6)) {
 274                 if (!ip6_is_unspecified_addr(&net_ip6) ||
 275                     net_prefix_length != 0) {
 276                         if (net_prefix_length != 0)
 277                                 snprintf(tmp, sizeof(tmp), "%pI6c/%d", &net_ip6, net_prefix_length);
 278                         else
 279                                 snprintf(tmp, sizeof(tmp), "%pI6c", &net_ip6);
 280                         env_set("ip6addr", tmp);
 281                 }
 282
 283                 if (!ip6_is_unspecified_addr(&net_server_ip6)) {
 284                         snprintf(tmp, sizeof(tmp), "%pI6c", &net_server_ip6);
 285                         env_set("serverip6", tmp);
 286                 }
 287
 288                 if (!ip6_is_unspecified_addr(&net_gateway6)) {
 289                         snprintf(tmp, sizeof(tmp), "%pI6c", &net_gateway6);
 290                         env_set("gatewayip6", tmp);
 291                 }
 292         }
 293 }
 294
 295 /**
 296  * parse_addr_size() - parse address and size arguments for tftpput
 297  *
 298  * @argv:       command line arguments
 299  * Return:      0 on success
 300  */
 301 static int parse_addr_size(char * const argv[])
 302 {
 303         if (strict_strtoul(argv[1], 16, &image_save_addr) < 0 ||
 304             strict_strtoul(argv[2], 16, &image_save_size) < 0) {
 305                 printf("Invalid address/size\n");
 306                 return CMD_RET_USAGE;
 307         }
 308         return 0;
 309 }
 310
 311 /**
 312  * parse_args() - parse command line arguments
 313  *
 314  * @proto:      command prototype
 315  * @argc:       number of arguments
 316  * @argv:       command line arguments
 317  * Return:      0 on success
 318  */
 319 static int parse_args(enum proto_t proto, int argc, char *const argv[])
 320 {
 321         ulong addr;
 322         char *end;
 323
 324         switch (argc) {
 325         case 1:
 326                 if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT)
 327                         return 1;
 328
 329                 /* refresh bootfile name from env */
 330                 copy_filename(net_boot_file_name, env_get("bootfile"),
 331                               sizeof(net_boot_file_name));
 332                 break;
 333
 334         case 2:
 335                 if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT)
 336                         return 1;
 337                 /*
 338                  * Only one arg - accept two forms:
 339                  * Just load address, or just boot file name. The latter
 340                  * form must be written in a format which can not be
 341                  * mis-interpreted as a valid number.
 342                  */
 343                 addr = hextoul(argv[1], &end);
 344                 if (end == (argv[1] + strlen(argv[1]))) {
 345                         image_load_addr = addr;
 346                         /* refresh bootfile name from env */
 347                         copy_filename(net_boot_file_name, env_get("bootfile"),
 348                                       sizeof(net_boot_file_name));
 349                 } else {
 350                         net_boot_file_name_explicit = true;
 351                         copy_filename(net_boot_file_name, argv[1],
 352                                       sizeof(net_boot_file_name));
 353                 }
 354                 break;
 355
 356         case 3:
 357                 if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT) {
 358                         if (parse_addr_size(argv))
 359                                 return 1;
 360                 } else {
 361                         image_load_addr = hextoul(argv[1], NULL);
 362                         net_boot_file_name_explicit = true;
 363                         copy_filename(net_boot_file_name, argv[2],
 364                                       sizeof(net_boot_file_name));
 365                 }
 366                 break;
 367
 368 #ifdef CONFIG_CMD_TFTPPUT
 369         case 4:
 370                 if (parse_addr_size(argv))
 371                         return 1;
 372                 net_boot_file_name_explicit = true;
 373                 copy_filename(net_boot_file_name, argv[3],
 374                               sizeof(net_boot_file_name));
 375                 break;
 376 #endif
 377         default:
 378                 return 1;
 379         }
 380         return 0;
 381 }
 382
 383 static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc,
 384                           char *const argv[])
 385 {
 386         char *s;
 387         int   rcode = 0;
 388         int   size;
 389
 390         net_boot_file_name_explicit = false;
 391         *net_boot_file_name = '\0';
 392
 393         /* pre-set image_load_addr */
 394         s = env_get("loadaddr");
 395         if (s != NULL)
 396                 image_load_addr = hextoul(s, NULL);
 397
 398         if (IS_ENABLED(CONFIG_IPV6)) {
 399                 use_ip6 = false;
 400
 401                 /* IPv6 parameter has to be always *last* */
 402                 if (!strcmp(argv[argc - 1], USE_IP6_CMD_PARAM)) {
 403                         use_ip6 = true;
 404                         /* It is a hack not to break switch/case code */
 405                         --argc;
 406                 }
 407         }
 408
 409         if (parse_args(proto, argc, argv)) {
 410                 bootstage_error(BOOTSTAGE_ID_NET_START);
 411                 return CMD_RET_USAGE;
 412         }
 413
 414         bootstage_mark(BOOTSTAGE_ID_NET_START);
 415
 416         if (IS_ENABLED(CONFIG_IPV6) && !use_ip6) {
 417                 char *s, *e;
 418                 size_t len;
 419
 420                 s = strchr(net_boot_file_name, '[');
 421                 e = strchr(net_boot_file_name, ']');
 422                 if (s && e) {
 423                         len = e - s;
 424                         if (!string_to_ip6(s + 1, len - 1, &net_server_ip6))
 425                                 use_ip6 = true;
 426                 }
 427         }
 428
 429         size = net_loop(proto);
 430         if (size < 0) {
 431                 bootstage_error(BOOTSTAGE_ID_NET_NETLOOP_OK);
 432                 return CMD_RET_FAILURE;
 433         }
 434         bootstage_mark(BOOTSTAGE_ID_NET_NETLOOP_OK);
 435
 436         /* net_loop ok, update environment */
 437         netboot_update_env();
 438
 439         /* done if no file was loaded (no errors though) */
 440         if (size == 0) {
 441                 bootstage_error(BOOTSTAGE_ID_NET_LOADED);
 442                 return CMD_RET_SUCCESS;
 443         }
 444
 445         bootstage_mark(BOOTSTAGE_ID_NET_LOADED);
 446
 447         rcode = bootm_maybe_autostart(cmdtp, argv[0]);
 448
 449         if (rcode == CMD_RET_SUCCESS)
 450                 bootstage_mark(BOOTSTAGE_ID_NET_DONE);
 451         else
 452                 bootstage_error(BOOTSTAGE_ID_NET_DONE_ERR);
 453         return rcode;
 454 }
 455
 456 #if defined(CONFIG_CMD_PING)
 457 static int do_ping(struct cmd_tbl *cmdtp, int flag, int argc,
 458                    char *const argv[])
 459 {
 460         if (argc < 2)
 461                 return CMD_RET_USAGE;
 462
 463         net_ping_ip = string_to_ip(argv[1]);
 464         if (net_ping_ip.s_addr == 0)
 465                 return CMD_RET_USAGE;
 466
 467         if (net_loop(PING) < 0) {
 468                 printf("ping failed; host %s is not alive\n", argv[1]);
 469                 return CMD_RET_FAILURE;
 470         }
 471
 472         printf("host %s is alive\n", argv[1]);
 473
 474         return CMD_RET_SUCCESS;
 475 }
 476
 477 U_BOOT_CMD(
 478         ping,   2,      1,      do_ping,
 479         "send ICMP ECHO_REQUEST to network host",
 480         "pingAddress"
 481 );
 482 #endif
 483
 484 #if IS_ENABLED(CONFIG_CMD_PING6)
 485 int do_ping6(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
 486 {
 487         if (string_to_ip6(argv[1], strlen(argv[1]), &net_ping_ip6))
 488                 return CMD_RET_USAGE;
 489
 490         use_ip6 = true;
 491         if (net_loop(PING6) < 0) {
 492                 use_ip6 = false;
 493                 printf("ping6 failed; host %pI6c is not alive\n",
 494                        &net_ping_ip6);
 495                 return 1;
 496         }
 497
 498         use_ip6 = false;
 499         printf("host %pI6c is alive\n", &net_ping_ip6);
 500         return 0;
 501 }
 502
 503 U_BOOT_CMD(
 504         ping6,  2,      1,      do_ping6,
 505         "send ICMPv6 ECHO_REQUEST to network host",
 506         "pingAddress"
 507 );
 508 #endif /* CONFIG_CMD_PING6 */
 509
 510 #if defined(CONFIG_CMD_CDP)
 511
 512 static void cdp_update_env(void)
 513 {
 514         char tmp[16];
 515
 516         if (cdp_appliance_vlan != htons(-1)) {
 517                 printf("CDP offered appliance VLAN %d\n",
 518                        ntohs(cdp_appliance_vlan));
 519                 vlan_to_string(cdp_appliance_vlan, tmp);
 520                 env_set("vlan", tmp);
 521                 net_our_vlan = cdp_appliance_vlan;
 522         }
 523
 524         if (cdp_native_vlan != htons(-1)) {
 525                 printf("CDP offered native VLAN %d\n", ntohs(cdp_native_vlan));
 526                 vlan_to_string(cdp_native_vlan, tmp);
 527                 env_set("nvlan", tmp);
 528                 net_native_vlan = cdp_native_vlan;
 529         }
 530 }
 531
 532 int do_cdp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 533 {
 534         int r;
 535
 536         r = net_loop(CDP);
 537         if (r < 0) {
 538                 printf("cdp failed; perhaps not a CISCO switch?\n");
 539                 return CMD_RET_FAILURE;
 540         }
 541
 542         cdp_update_env();
 543
 544         return CMD_RET_SUCCESS;
 545 }
 546
 547 U_BOOT_CMD(
 548         cdp,    1,      1,      do_cdp,
 549         "Perform CDP network configuration",
 550         "\n"
 551 );
 552 #endif
 553
 554 #if defined(CONFIG_CMD_SNTP)
 555 static struct udp_ops sntp_ops = {
 556         .prereq = sntp_prereq,
 557         .start = sntp_start,
 558         .data = NULL,
 559 };
 560
 561 int do_sntp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 562 {
 563         char *toff;
 564
 565         if (argc < 2) {
 566                 net_ntp_server = env_get_ip("ntpserverip");
 567                 if (net_ntp_server.s_addr == 0) {
 568                         printf("ntpserverip not set\n");
 569                         return CMD_RET_FAILURE;
 570                 }
 571         } else {
 572                 net_ntp_server = string_to_ip(argv[1]);
 573                 if (net_ntp_server.s_addr == 0) {
 574                         printf("Bad NTP server IP address\n");
 575                         return CMD_RET_FAILURE;
 576                 }
 577         }
 578
 579         toff = env_get("timeoffset");
 580         if (toff == NULL)
 581                 net_ntp_time_offset = 0;
 582         else
 583                 net_ntp_time_offset = simple_strtol(toff, NULL, 10);
 584
 585         if (udp_loop(&sntp_ops) < 0) {
 586                 printf("SNTP failed: host %pI4 not responding\n",
 587                        &net_ntp_server);
 588                 return CMD_RET_FAILURE;
 589         }
 590
 591         return CMD_RET_SUCCESS;
 592 }
 593
 594 U_BOOT_CMD(
 595         sntp,   2,      1,      do_sntp,
 596         "synchronize RTC via network",
 597         "[NTP server IP]\n"
 598 );
 599 #endif
 600
 601 #if defined(CONFIG_CMD_DNS)
 602 int do_dns(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 603 {
 604         if (argc == 1)
 605                 return CMD_RET_USAGE;
 606
 607         /*
 608          * We should check for a valid hostname:
 609          * - Each label must be between 1 and 63 characters long
 610          * - the entire hostname has a maximum of 255 characters
 611          * - only the ASCII letters 'a' through 'z' (case-insensitive),
 612          *   the digits '0' through '9', and the hyphen
 613          * - cannot begin or end with a hyphen
 614          * - no other symbols, punctuation characters, or blank spaces are
 615          *   permitted
 616          * but hey - this is a minimalist implmentation, so only check length
 617          * and let the name server deal with things.
 618          */
 619         if (strlen(argv[1]) >= 255) {
 620                 printf("dns error: hostname too long\n");
 621                 return CMD_RET_FAILURE;
 622         }
 623
 624         net_dns_resolve = argv[1];
 625
 626         if (argc == 3)
 627                 net_dns_env_var = argv[2];
 628         else
 629                 net_dns_env_var = NULL;
 630
 631         if (net_loop(DNS) < 0) {
 632                 printf("dns lookup of %s failed, check setup\n", argv[1]);
 633                 return CMD_RET_FAILURE;
 634         }
 635
 636         return CMD_RET_SUCCESS;
 637 }
 638
 639 U_BOOT_CMD(
 640         dns,    3,      1,      do_dns,
 641         "lookup the IP of a hostname",
 642         "hostname [envvar]"
 643 );
 644
 645 #endif  /* CONFIG_CMD_DNS */
 646
 647 #if defined(CONFIG_CMD_LINK_LOCAL)
 648 static int do_link_local(struct cmd_tbl *cmdtp, int flag, int argc,
 649                          char *const argv[])
 650 {
 651         char tmp[22];
 652
 653         if (net_loop(LINKLOCAL) < 0)
 654                 return CMD_RET_FAILURE;
 655
 656         net_gateway.s_addr = 0;
 657         ip_to_string(net_gateway, tmp);
 658         env_set("gatewayip", tmp);
 659
 660         ip_to_string(net_netmask, tmp);
 661         env_set("netmask", tmp);
 662
 663         ip_to_string(net_ip, tmp);
 664         env_set("ipaddr", tmp);
 665         env_set("llipaddr", tmp); /* store this for next time */
 666
 667         return CMD_RET_SUCCESS;
 668 }
 669
 670 U_BOOT_CMD(
 671         linklocal,      1,      1,      do_link_local,
 672         "acquire a network IP address using the link-local protocol",
 673         ""
 674 );
 675
 676 #endif  /* CONFIG_CMD_LINK_LOCAL */