drivers/net/fsl-mc/mc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2014 Freescale Semiconductor, Inc.
   4  * Copyright 2017-2018, 2020 NXP
   5  */
   6 #include <common.h>
   7 #include <command.h>
   8 #include <cpu_func.h>
   9 #include <env.h>
  10 #include <errno.h>
  11 #include <malloc.h>
  12 #include <linux/bug.h>
  13 #include <asm/io.h>
  14 #include <linux/libfdt.h>
  15 #include <net.h>
  16 #include <fdt_support.h>
  17 #include <fsl-mc/fsl_mc.h>
  18 #include <fsl-mc/fsl_mc_sys.h>
  19 #include <fsl-mc/fsl_mc_private.h>
  20 #include <fsl-mc/fsl_dpmng.h>
  21 #include <fsl-mc/fsl_dprc.h>
  22 #include <fsl-mc/fsl_dpio.h>
  23 #include <fsl-mc/fsl_dpni.h>
  24 #include <fsl-mc/fsl_dpsparser.h>
  25 #include <fsl-mc/fsl_qbman_portal.h>
  26 #include <fsl-mc/ldpaa_wriop.h>
  27
  28 #define MC_RAM_BASE_ADDR_ALIGNMENT  (512UL * 1024 * 1024)
  29 #define MC_RAM_BASE_ADDR_ALIGNMENT_MASK (~(MC_RAM_BASE_ADDR_ALIGNMENT - 1))
  30 #define MC_RAM_SIZE_ALIGNMENT       (256UL * 1024 * 1024)
  31
  32 #define MC_MEM_SIZE_ENV_VAR     "mcmemsize"
  33 #define MC_BOOT_TIMEOUT_ENV_VAR "mcboottimeout"
  34 #define MC_BOOT_ENV_VAR         "mcinitcmd"
  35 #define MC_DRAM_BLOCK_DEFAULT_SIZE (512UL * 1024 * 1024)
  36
  37 DECLARE_GLOBAL_DATA_PTR;
  38 static int mc_memset_resv_ram;
  39 static struct mc_version mc_ver_info;
  40 static int mc_boot_status = -1;
  41 static int mc_dpl_applied = -1;
  42 #ifdef CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET
  43 static int mc_aiop_applied = -1;
  44 #endif
  45 struct fsl_mc_io *root_mc_io = NULL;
  46 struct fsl_mc_io *dflt_mc_io = NULL; /* child container */
  47 uint16_t root_dprc_handle = 0;
  48 uint16_t dflt_dprc_handle = 0;
  49 int child_dprc_id;
  50 struct fsl_dpbp_obj *dflt_dpbp = NULL;
  51 struct fsl_dpio_obj *dflt_dpio = NULL;
  52 struct fsl_dpni_obj *dflt_dpni = NULL;
  53 static u64 mc_lazy_dpl_addr;
  54 static u32 dpsparser_obj_id;
  55 static u16 dpsparser_handle;
  56 static char *mc_err_msg_apply_spb[] = MC_ERROR_MSG_APPLY_SPB;
  57
  58 #ifdef DEBUG
  59 void dump_ram_words(const char *title, void *addr)
  60 {
  61         int i;
  62         uint32_t *words = addr;
  63
  64         printf("Dumping beginning of %s (%p):\n", title, addr);
  65         for (i = 0; i < 16; i++)
  66                 printf("%#x ", words[i]);
  67
  68         printf("\n");
  69 }
  70
  71 void dump_mc_ccsr_regs(struct mc_ccsr_registers __iomem *mc_ccsr_regs)
  72 {
  73         printf("MC CCSR registers:\n"
  74                 "reg_gcr1 %#x\n"
  75                 "reg_gsr %#x\n"
  76                 "reg_sicbalr %#x\n"
  77                 "reg_sicbahr %#x\n"
  78                 "reg_sicapr %#x\n"
  79                 "reg_mcfbalr %#x\n"
  80                 "reg_mcfbahr %#x\n"
  81                 "reg_mcfapr %#x\n"
  82                 "reg_psr %#x\n",
  83                 mc_ccsr_regs->reg_gcr1,
  84                 mc_ccsr_regs->reg_gsr,
  85                 mc_ccsr_regs->reg_sicbalr,
  86                 mc_ccsr_regs->reg_sicbahr,
  87                 mc_ccsr_regs->reg_sicapr,
  88                 mc_ccsr_regs->reg_mcfbalr,
  89                 mc_ccsr_regs->reg_mcfbahr,
  90                 mc_ccsr_regs->reg_mcfapr,
  91                 mc_ccsr_regs->reg_psr);
  92 }
  93 #else
  94
  95 #define dump_ram_words(title, addr)
  96 #define dump_mc_ccsr_regs(mc_ccsr_regs)
  97
  98 #endif /* DEBUG */
  99
 100 /**
 101  * Copying MC firmware or DPL image to DDR
 102  */
 103 static int mc_copy_image(const char *title,
 104                          u64 image_addr, u32 image_size, u64 mc_ram_addr)
 105 {
 106         debug("%s copied to address %p\n", title, (void *)mc_ram_addr);
 107         memcpy((void *)mc_ram_addr, (void *)image_addr, image_size);
 108         flush_dcache_range(mc_ram_addr, mc_ram_addr + image_size);
 109         return 0;
 110 }
 111
 112 #ifndef CONFIG_SYS_LS_MC_FW_IN_DDR
 113 /**
 114  * MC firmware FIT image parser checks if the image is in FIT
 115  * format, verifies integrity of the image and calculates
 116  * raw image address and size values.
 117  * Returns 0 on success and a negative errno on error.
 118  * task fail.
 119  **/
 120 int parse_mc_firmware_fit_image(u64 mc_fw_addr,
 121                                 const void **raw_image_addr,
 122                                 size_t *raw_image_size)
 123 {
 124         int format;
 125         void *fit_hdr;
 126         int node_offset;
 127         const void *data;
 128         size_t size;
 129         const char *uname = "firmware";
 130
 131         fit_hdr = (void *)mc_fw_addr;
 132
 133         /* Check if Image is in FIT format */
 134         format = genimg_get_format(fit_hdr);
 135
 136         if (format != IMAGE_FORMAT_FIT) {
 137                 printf("fsl-mc: ERR: Bad firmware image (not a FIT image)\n");
 138                 return -EINVAL;
 139         }
 140
 141         if (!fit_check_format(fit_hdr)) {
 142                 printf("fsl-mc: ERR: Bad firmware image (bad FIT header)\n");
 143                 return -EINVAL;
 144         }
 145
 146         node_offset = fit_image_get_node(fit_hdr, uname);
 147
 148         if (node_offset < 0) {
 149                 printf("fsl-mc: ERR: Bad firmware image (missing subimage)\n");
 150                 return -ENOENT;
 151         }
 152
 153         /* Verify MC firmware image */
 154         if (!(fit_image_verify(fit_hdr, node_offset))) {
 155                 printf("fsl-mc: ERR: Bad firmware image (bad CRC)\n");
 156                 return -EINVAL;
 157         }
 158
 159         /* Get address and size of raw image */
 160         fit_image_get_data(fit_hdr, node_offset, &data, &size);
 161
 162         *raw_image_addr = data;
 163         *raw_image_size = size;
 164
 165         return 0;
 166 }
 167 #endif
 168
 169 #define MC_DT_INCREASE_SIZE     64
 170
 171 enum mc_fixup_type {
 172         MC_FIXUP_DPL,
 173         MC_FIXUP_DPC
 174 };
 175
 176 static int mc_fixup_mac_addr(void *blob, int nodeoffset,
 177 #ifdef CONFIG_DM_ETH
 178                              const char *propname, struct udevice *eth_dev,
 179 #else
 180                              const char *propname, struct eth_device *eth_dev,
 181 #endif
 182                              enum mc_fixup_type type)
 183 {
 184 #ifdef CONFIG_DM_ETH
 185         struct eth_pdata *plat = dev_get_platdata(eth_dev);
 186         unsigned char *enetaddr = plat->enetaddr;
 187         int eth_index = eth_dev->seq;
 188 #else
 189         unsigned char *enetaddr = eth_dev->enetaddr;
 190         int eth_index = eth_dev->index;
 191 #endif
 192         int err = 0, len = 0, size, i;
 193         unsigned char env_enetaddr[ARP_HLEN];
 194         unsigned int enetaddr_32[ARP_HLEN];
 195         void *val = NULL;
 196
 197         switch (type) {
 198         case MC_FIXUP_DPL:
 199                 /* DPL likes its addresses on 32 * ARP_HLEN bits */
 200                 for (i = 0; i < ARP_HLEN; i++)
 201                         enetaddr_32[i] = cpu_to_fdt32(enetaddr[i]);
 202                 val = enetaddr_32;
 203                 len = sizeof(enetaddr_32);
 204                 break;
 205         case MC_FIXUP_DPC:
 206                 val = enetaddr;
 207                 len = ARP_HLEN;
 208                 break;
 209         }
 210
 211         /* MAC address property present */
 212         if (fdt_get_property(blob, nodeoffset, propname, NULL)) {
 213                 /* u-boot MAC addr randomly assigned - leave the present one */
 214                 if (!eth_env_get_enetaddr_by_index("eth", eth_index,
 215                                                    env_enetaddr))
 216                         return err;
 217         } else {
 218                 size = MC_DT_INCREASE_SIZE + strlen(propname) + len;
 219                 /* make room for mac address property */
 220                 err = fdt_increase_size(blob, size);
 221                 if (err) {
 222                         printf("fdt_increase_size: err=%s\n",
 223                                fdt_strerror(err));
 224                         return err;
 225                 }
 226         }
 227
 228         err = fdt_setprop(blob, nodeoffset, propname, val, len);
 229         if (err) {
 230                 printf("fdt_setprop: err=%s\n", fdt_strerror(err));
 231                 return err;
 232         }
 233
 234         return err;
 235 }
 236
 237 #define is_dpni(s) (s != NULL ? !strncmp(s, "dpni@", 5) : 0)
 238
 239 const char *dpl_get_connection_endpoint(void *blob, char *endpoint)
 240 {
 241         int connoffset = fdt_path_offset(blob, "/connections"), off;
 242         const char *s1, *s2;
 243
 244         for (off = fdt_first_subnode(blob, connoffset);
 245              off >= 0;
 246              off = fdt_next_subnode(blob, off)) {
 247                 s1 = fdt_stringlist_get(blob, off, "endpoint1", 0, NULL);
 248                 s2 = fdt_stringlist_get(blob, off, "endpoint2", 0, NULL);
 249
 250                 if (!s1 || !s2)
 251                         continue;
 252
 253                 if (strcmp(endpoint, s1) == 0)
 254                         return s2;
 255
 256                 if (strcmp(endpoint, s2) == 0)
 257                         return s1;
 258         }
 259
 260         return NULL;
 261 }
 262
 263 static int mc_fixup_dpl_mac_addr(void *blob, int dpmac_id,
 264 #ifdef CONFIG_DM_ETH
 265                                  struct udevice *eth_dev)
 266 #else
 267                                  struct eth_device *eth_dev)
 268 #endif
 269 {
 270         int objoff = fdt_path_offset(blob, "/objects");
 271         int dpmacoff = -1, dpnioff = -1;
 272         const char *endpoint;
 273         char mac_name[10];
 274         int err;
 275
 276         sprintf(mac_name, "dpmac@%d", dpmac_id);
 277         dpmacoff = fdt_subnode_offset(blob, objoff, mac_name);
 278         if (dpmacoff < 0)
 279                 /* dpmac not defined in DPL, so skip it. */
 280                 return 0;
 281
 282         err = mc_fixup_mac_addr(blob, dpmacoff, "mac_addr", eth_dev,
 283                                 MC_FIXUP_DPL);
 284         if (err) {
 285                 printf("Error fixing up dpmac mac_addr in DPL\n");
 286                 return err;
 287         }
 288
 289         /* now we need to figure out if there is any
 290          * DPNI connected to this MAC, so we walk the
 291          * connection list
 292          */
 293         endpoint = dpl_get_connection_endpoint(blob, mac_name);
 294         if (!is_dpni(endpoint))
 295                 return 0;
 296
 297         /* let's see if we can fixup the DPNI as well */
 298         dpnioff = fdt_subnode_offset(blob, objoff, endpoint);
 299         if (dpnioff < 0)
 300                 /* DPNI not defined in DPL in the objects area */
 301                 return 0;
 302
 303         return mc_fixup_mac_addr(blob, dpnioff, "mac_addr", eth_dev,
 304                                  MC_FIXUP_DPL);
 305 }
 306
 307 void fdt_fixup_mc_ddr(u64 *base, u64 *size)
 308 {
 309         u64 mc_size = mc_get_dram_block_size();
 310
 311         if (mc_size < MC_DRAM_BLOCK_DEFAULT_SIZE) {
 312                 *base = mc_get_dram_addr() + mc_size;
 313                 *size = MC_DRAM_BLOCK_DEFAULT_SIZE - mc_size;
 314         }
 315 }
 316
 317 void fdt_fsl_mc_fixup_iommu_map_entry(void *blob)
 318 {
 319         u32 *prop;
 320         u32 iommu_map[4], phandle;
 321         int offset;
 322         int lenp;
 323
 324         /* find fsl-mc node */
 325         offset = fdt_path_offset(blob, "/soc/fsl-mc");
 326         if (offset < 0)
 327                 offset = fdt_path_offset(blob, "/fsl-mc");
 328         if (offset < 0) {
 329                 printf("%s: fsl-mc: ERR: fsl-mc node not found in DT, err %d\n",
 330                        __func__, offset);
 331                 return;
 332         }
 333
 334         prop = fdt_getprop_w(blob, offset, "iommu-map", &lenp);
 335         if (!prop) {
 336                 debug("%s: fsl-mc: ERR: missing iommu-map in fsl-mc bus node\n",
 337                       __func__);
 338                 return;
 339         }
 340
 341         iommu_map[0] = cpu_to_fdt32(FSL_DPAA2_STREAM_ID_START);
 342         iommu_map[1] = *++prop;
 343         iommu_map[2] = cpu_to_fdt32(FSL_DPAA2_STREAM_ID_START);
 344         iommu_map[3] = cpu_to_fdt32(FSL_DPAA2_STREAM_ID_END -
 345                 FSL_DPAA2_STREAM_ID_START + 1);
 346
 347         fdt_setprop_inplace(blob, offset, "iommu-map",
 348                             iommu_map, sizeof(iommu_map));
 349
 350         /* get phandle to MSI controller */
 351         prop = (u32 *)fdt_getprop(blob, offset, "msi-parent", 0);
 352         if (!prop) {
 353                 debug("\n%s: ERROR: missing msi-parent\n", __func__);
 354                 return;
 355         }
 356         phandle = fdt32_to_cpu(*prop);
 357
 358         /* also set msi-map property */
 359         fdt_appendprop_u32(blob, offset, "msi-map", FSL_DPAA2_STREAM_ID_START);
 360         fdt_appendprop_u32(blob, offset, "msi-map", phandle);
 361         fdt_appendprop_u32(blob, offset, "msi-map", FSL_DPAA2_STREAM_ID_START);
 362         fdt_appendprop_u32(blob, offset, "msi-map", FSL_DPAA2_STREAM_ID_END -
 363                            FSL_DPAA2_STREAM_ID_START + 1);
 364 }
 365
 366 static int mc_fixup_dpc_mac_addr(void *blob, int dpmac_id,
 367 #ifdef CONFIG_DM_ETH
 368                                  struct udevice *eth_dev)
 369 #else
 370                                  struct eth_device *eth_dev)
 371 #endif
 372 {
 373         int nodeoffset = fdt_path_offset(blob, "/board_info/ports"), noff;
 374         int err = 0;
 375         char mac_name[10];
 376         const char link_type_mode[] = "MAC_LINK_TYPE_FIXED";
 377
 378         sprintf(mac_name, "mac@%d", dpmac_id);
 379
 380         /* node not found - create it */
 381         noff = fdt_subnode_offset(blob, nodeoffset, (const char *)mac_name);
 382         if (noff < 0) {
 383                 err = fdt_increase_size(blob, 200);
 384                 if (err) {
 385                         printf("fdt_increase_size: err=%s\n",
 386                                 fdt_strerror(err));
 387                         return err;
 388                 }
 389
 390                 noff = fdt_add_subnode(blob, nodeoffset, mac_name);
 391                 if (noff < 0) {
 392                         printf("fdt_add_subnode: err=%s\n",
 393                                fdt_strerror(err));
 394                         return err;
 395                 }
 396
 397                 /* add default property of fixed link */
 398                 err = fdt_appendprop_string(blob, noff,
 399                                             "link_type", link_type_mode);
 400                 if (err) {
 401                         printf("fdt_appendprop_string: err=%s\n",
 402                                 fdt_strerror(err));
 403                         return err;
 404                 }
 405         }
 406
 407         return mc_fixup_mac_addr(blob, noff, "port_mac_address", eth_dev,
 408                                  MC_FIXUP_DPC);
 409 }
 410
 411 static int mc_fixup_mac_addrs(void *blob, enum mc_fixup_type type)
 412 {
 413         int i, err = 0, ret = 0;
 414 #ifdef CONFIG_DM_ETH
 415 #define ETH_NAME_LEN 20
 416         struct udevice *eth_dev;
 417 #else
 418         struct eth_device *eth_dev;
 419 #endif
 420         char ethname[ETH_NAME_LEN];
 421
 422         for (i = WRIOP1_DPMAC1; i < NUM_WRIOP_PORTS; i++) {
 423                 /* port not enabled */
 424                 if (wriop_is_enabled_dpmac(i) != 1)
 425                         continue;
 426
 427                 snprintf(ethname, ETH_NAME_LEN, "DPMAC%d@%s", i,
 428                          phy_interface_strings[wriop_get_enet_if(i)]);
 429
 430                 eth_dev = eth_get_dev_by_name(ethname);
 431                 if (eth_dev == NULL)
 432                         continue;
 433
 434                 switch (type) {
 435                 case MC_FIXUP_DPL:
 436                         err = mc_fixup_dpl_mac_addr(blob, i, eth_dev);
 437                         break;
 438                 case MC_FIXUP_DPC:
 439                         err = mc_fixup_dpc_mac_addr(blob, i, eth_dev);
 440                         break;
 441                 default:
 442                         break;
 443                 }
 444
 445                 if (err)
 446                         printf("fsl-mc: ERROR fixing mac address for %s\n",
 447                                ethname);
 448                 ret |= err;
 449         }
 450
 451         return ret;
 452 }
 453
 454 static int mc_fixup_dpc(u64 dpc_addr)
 455 {
 456         void *blob = (void *)dpc_addr;
 457         int nodeoffset, err = 0;
 458
 459         /* delete any existing ICID pools */
 460         nodeoffset = fdt_path_offset(blob, "/resources/icid_pools");
 461         if (fdt_del_node(blob, nodeoffset) < 0)
 462                 printf("\nfsl-mc: WARNING: could not delete ICID pool\n");
 463
 464         /* add a new pool */
 465         nodeoffset = fdt_path_offset(blob, "/resources");
 466         if (nodeoffset < 0) {
 467                 printf("\nfsl-mc: ERROR: DPC is missing /resources\n");
 468                 return -EINVAL;
 469         }
 470         nodeoffset = fdt_add_subnode(blob, nodeoffset, "icid_pools");
 471         nodeoffset = fdt_add_subnode(blob, nodeoffset, "icid_pool@0");
 472         do_fixup_by_path_u32(blob, "/resources/icid_pools/icid_pool@0",
 473                              "base_icid", FSL_DPAA2_STREAM_ID_START, 1);
 474         do_fixup_by_path_u32(blob, "/resources/icid_pools/icid_pool@0",
 475                              "num",
 476                              FSL_DPAA2_STREAM_ID_END -
 477                              FSL_DPAA2_STREAM_ID_START + 1, 1);
 478
 479         /* fixup MAC addresses for dpmac ports */
 480         nodeoffset = fdt_path_offset(blob, "/board_info/ports");
 481         if (nodeoffset < 0) {
 482                 err = fdt_increase_size(blob, 512);
 483                 if (err) {
 484                         printf("fdt_increase_size: err=%s\n",
 485                                fdt_strerror(err));
 486                         goto out;
 487                 }
 488                 nodeoffset = fdt_path_offset(blob, "/board_info");
 489                 if (nodeoffset < 0)
 490                         nodeoffset = fdt_add_subnode(blob, 0, "board_info");
 491
 492                 nodeoffset = fdt_add_subnode(blob, nodeoffset, "ports");
 493         }
 494
 495         err = mc_fixup_mac_addrs(blob, MC_FIXUP_DPC);
 496
 497 out:
 498         flush_dcache_range(dpc_addr, dpc_addr + fdt_totalsize(blob));
 499
 500         return err;
 501 }
 502
 503 static int load_mc_dpc(u64 mc_ram_addr, size_t mc_ram_size, u64 mc_dpc_addr)
 504 {
 505         u64 mc_dpc_offset;
 506 #ifndef CONFIG_SYS_LS_MC_DPC_IN_DDR
 507         int error;
 508         void *dpc_fdt_hdr;
 509         int dpc_size;
 510 #endif
 511
 512 #ifdef CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET
 513         BUILD_BUG_ON((CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET & 0x3) != 0 ||
 514                      CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET > 0xffffffff);
 515
 516         mc_dpc_offset = CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET;
 517 #else
 518 #error "CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET not defined"
 519 #endif
 520
 521         /*
 522          * Load the MC DPC blob in the MC private DRAM block:
 523          */
 524 #ifdef CONFIG_SYS_LS_MC_DPC_IN_DDR
 525         printf("MC DPC is preloaded to %#llx\n", mc_ram_addr + mc_dpc_offset);
 526 #else
 527         /*
 528          * Get address and size of the DPC blob stored in flash:
 529          */
 530         dpc_fdt_hdr = (void *)mc_dpc_addr;
 531
 532         error = fdt_check_header(dpc_fdt_hdr);
 533         if (error != 0) {
 534                 /*
 535                  * Don't return with error here, since the MC firmware can
 536                  * still boot without a DPC
 537                  */
 538                 printf("\nfsl-mc: WARNING: No DPC image found");
 539                 return 0;
 540         }
 541
 542         dpc_size = fdt_totalsize(dpc_fdt_hdr);
 543         if (dpc_size > CONFIG_SYS_LS_MC_DPC_MAX_LENGTH) {
 544                 printf("\nfsl-mc: ERROR: Bad DPC image (too large: %d)\n",
 545                        dpc_size);
 546                 return -EINVAL;
 547         }
 548
 549         mc_copy_image("MC DPC blob",
 550                       (u64)dpc_fdt_hdr, dpc_size, mc_ram_addr + mc_dpc_offset);
 551 #endif /* not defined CONFIG_SYS_LS_MC_DPC_IN_DDR */
 552
 553         if (mc_fixup_dpc(mc_ram_addr + mc_dpc_offset))
 554                 return -EINVAL;
 555
 556         dump_ram_words("DPC", (void *)(mc_ram_addr + mc_dpc_offset));
 557         return 0;
 558 }
 559
 560
 561 static int mc_fixup_dpl(u64 dpl_addr)
 562 {
 563         void *blob = (void *)dpl_addr;
 564         u32 ver = fdt_getprop_u32_default(blob, "/", "dpl-version", 0);
 565         int err = 0;
 566
 567         /* The DPL fixup for mac addresses is only relevant
 568          * for old-style DPLs
 569          */
 570         if (ver >= 10)
 571                 return 0;
 572
 573         err = mc_fixup_mac_addrs(blob, MC_FIXUP_DPL);
 574         flush_dcache_range(dpl_addr, dpl_addr + fdt_totalsize(blob));
 575
 576         return err;
 577 }
 578
 579 static int load_mc_dpl(u64 mc_ram_addr, size_t mc_ram_size, u64 mc_dpl_addr)
 580 {
 581         u64 mc_dpl_offset;
 582 #ifndef CONFIG_SYS_LS_MC_DPL_IN_DDR
 583         int error;
 584         void *dpl_fdt_hdr;
 585         int dpl_size;
 586 #endif
 587
 588 #ifdef CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET
 589         BUILD_BUG_ON((CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET & 0x3) != 0 ||
 590                      CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET > 0xffffffff);
 591
 592         mc_dpl_offset = CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET;
 593 #else
 594 #error "CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET not defined"
 595 #endif
 596
 597         /*
 598          * Load the MC DPL blob in the MC private DRAM block:
 599          */
 600 #ifdef CONFIG_SYS_LS_MC_DPL_IN_DDR
 601         printf("MC DPL is preloaded to %#llx\n", mc_ram_addr + mc_dpl_offset);
 602 #else
 603         /*
 604          * Get address and size of the DPL blob stored in flash:
 605          */
 606         dpl_fdt_hdr = (void *)mc_dpl_addr;
 607
 608         error = fdt_check_header(dpl_fdt_hdr);
 609         if (error != 0) {
 610                 printf("\nfsl-mc: ERROR: Bad DPL image (bad header)\n");
 611                 return error;
 612         }
 613
 614         dpl_size = fdt_totalsize(dpl_fdt_hdr);
 615         if (dpl_size > CONFIG_SYS_LS_MC_DPL_MAX_LENGTH) {
 616                 printf("\nfsl-mc: ERROR: Bad DPL image (too large: %d)\n",
 617                        dpl_size);
 618                 return -EINVAL;
 619         }
 620
 621         mc_copy_image("MC DPL blob",
 622                       (u64)dpl_fdt_hdr, dpl_size, mc_ram_addr + mc_dpl_offset);
 623 #endif /* not defined CONFIG_SYS_LS_MC_DPL_IN_DDR */
 624
 625         if (mc_fixup_dpl(mc_ram_addr + mc_dpl_offset))
 626                 return -EINVAL;
 627         dump_ram_words("DPL", (void *)(mc_ram_addr + mc_dpl_offset));
 628         return 0;
 629 }
 630
 631 /**
 632  * Return the MC boot timeout value in milliseconds
 633  */
 634 static unsigned long get_mc_boot_timeout_ms(void)
 635 {
 636         unsigned long timeout_ms = CONFIG_SYS_LS_MC_BOOT_TIMEOUT_MS;
 637
 638         char *timeout_ms_env_var = env_get(MC_BOOT_TIMEOUT_ENV_VAR);
 639
 640         if (timeout_ms_env_var) {
 641                 timeout_ms = simple_strtoul(timeout_ms_env_var, NULL, 10);
 642                 if (timeout_ms == 0) {
 643                         printf("fsl-mc: WARNING: Invalid value for \'"
 644                                MC_BOOT_TIMEOUT_ENV_VAR
 645                                "\' environment variable: %lu\n",
 646                                timeout_ms);
 647
 648                         timeout_ms = CONFIG_SYS_LS_MC_BOOT_TIMEOUT_MS;
 649                 }
 650         }
 651
 652         return timeout_ms;
 653 }
 654
 655 #ifdef CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET
 656
 657 __weak bool soc_has_aiop(void)
 658 {
 659         return false;
 660 }
 661
 662 static int load_mc_aiop_img(u64 aiop_fw_addr)
 663 {
 664         u64 mc_ram_addr = mc_get_dram_addr();
 665 #ifndef CONFIG_SYS_LS_MC_DPC_IN_DDR
 666         void *aiop_img;
 667 #endif
 668
 669         /* Check if AIOP is available */
 670         if (!soc_has_aiop())
 671                 return -ENODEV;
 672         /*
 673          * Load the MC AIOP image in the MC private DRAM block:
 674          */
 675
 676 #ifdef CONFIG_SYS_LS_MC_DPC_IN_DDR
 677         printf("MC AIOP is preloaded to %#llx\n", mc_ram_addr +
 678                CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET);
 679 #else
 680         aiop_img = (void *)aiop_fw_addr;
 681         mc_copy_image("MC AIOP image",
 682                       (u64)aiop_img, CONFIG_SYS_LS_MC_AIOP_IMG_MAX_LENGTH,
 683                       mc_ram_addr + CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET);
 684 #endif
 685         mc_aiop_applied = 0;
 686
 687         return 0;
 688 }
 689 #endif
 690
 691 static int wait_for_mc(bool booting_mc, u32 *final_reg_gsr)
 692 {
 693         u32 reg_gsr;
 694         u32 mc_fw_boot_status;
 695         unsigned long timeout_ms = get_mc_boot_timeout_ms();
 696         struct mc_ccsr_registers __iomem *mc_ccsr_regs = MC_CCSR_BASE_ADDR;
 697
 698         dmb();
 699         assert(timeout_ms > 0);
 700         for (;;) {
 701                 udelay(1000);   /* throttle polling */
 702                 reg_gsr = in_le32(&mc_ccsr_regs->reg_gsr);
 703                 mc_fw_boot_status = (reg_gsr & GSR_FS_MASK);
 704                 if (mc_fw_boot_status & 0x1)
 705                         break;
 706
 707                 timeout_ms--;
 708                 if (timeout_ms == 0)
 709                         break;
 710         }
 711
 712         if (timeout_ms == 0) {
 713                 printf("ERROR: timeout\n");
 714
 715                 /* TODO: Get an error status from an MC CCSR register */
 716                 return -ETIMEDOUT;
 717         }
 718
 719         if (mc_fw_boot_status != 0x1) {
 720                 /*
 721                  * TODO: Identify critical errors from the GSR register's FS
 722                  * field and for those errors, set error to -ENODEV or other
 723                  * appropriate errno, so that the status property is set to
 724                  * failure in the fsl,dprc device tree node.
 725                  */
 726                 printf("WARNING: Firmware returned an error (GSR: %#x)\n",
 727                        reg_gsr);
 728         } else {
 729                 printf("SUCCESS\n");
 730         }
 731
 732
 733         *final_reg_gsr = reg_gsr;
 734         return 0;
 735 }
 736
 737 int mc_init(u64 mc_fw_addr, u64 mc_dpc_addr)
 738 {
 739         int error = 0;
 740         int portal_id = 0;
 741         struct mc_ccsr_registers __iomem *mc_ccsr_regs = MC_CCSR_BASE_ADDR;
 742         u64 mc_ram_addr = mc_get_dram_addr();
 743         u32 reg_gsr;
 744         u32 reg_mcfbalr;
 745 #ifndef CONFIG_SYS_LS_MC_FW_IN_DDR
 746         const void *raw_image_addr;
 747         size_t raw_image_size = 0;
 748 #endif
 749         u8 mc_ram_num_256mb_blocks;
 750         size_t mc_ram_size = mc_get_dram_block_size();
 751
 752         mc_ram_num_256mb_blocks = mc_ram_size / MC_RAM_SIZE_ALIGNMENT;
 753
 754         if (mc_ram_num_256mb_blocks >= 0xff) {
 755                 error = -EINVAL;
 756                 printf("fsl-mc: ERROR: invalid MC private RAM size (%lu)\n",
 757                        mc_ram_size);
 758                 goto out;
 759         }
 760
 761         /*
 762          * To support 128 MB DDR Size for MC
 763          */
 764         if (mc_ram_num_256mb_blocks == 0)
 765                 mc_ram_num_256mb_blocks = 0xFF;
 766
 767         /*
 768          * Management Complex cores should be held at reset out of POR.
 769          * U-Boot should be the first software to touch MC. To be safe,
 770          * we reset all cores again by setting GCR1 to 0. It doesn't do
 771          * anything if they are held at reset. After we setup the firmware
 772          * we kick off MC by deasserting the reset bit for core 0, and
 773          * deasserting the reset bits for Command Portal Managers.
 774          * The stop bits are not touched here. They are used to stop the
 775          * cores when they are active. Setting stop bits doesn't stop the
 776          * cores from fetching instructions when they are released from
 777          * reset.
 778          */
 779         out_le32(&mc_ccsr_regs->reg_gcr1, 0);
 780         dmb();
 781
 782 #ifdef CONFIG_SYS_LS_MC_FW_IN_DDR
 783         printf("MC firmware is preloaded to %#llx\n", mc_ram_addr);
 784 #else
 785         error = parse_mc_firmware_fit_image(mc_fw_addr, &raw_image_addr,
 786                                             &raw_image_size);
 787         if (error != 0)
 788                 goto out;
 789         /*
 790          * Load the MC FW at the beginning of the MC private DRAM block:
 791          */
 792         mc_copy_image("MC Firmware",
 793                       (u64)raw_image_addr, raw_image_size, mc_ram_addr);
 794 #endif
 795         dump_ram_words("firmware", (void *)mc_ram_addr);
 796
 797         error = load_mc_dpc(mc_ram_addr, mc_ram_size, mc_dpc_addr);
 798         if (error != 0)
 799                 goto out;
 800
 801         debug("mc_ccsr_regs %p\n", mc_ccsr_regs);
 802         dump_mc_ccsr_regs(mc_ccsr_regs);
 803
 804         /*
 805          * Tell MC what is the address range of the DRAM block assigned to it:
 806          */
 807         if (mc_ram_num_256mb_blocks < 0xFF) {
 808                 reg_mcfbalr = (u32)mc_ram_addr |
 809                                 (mc_ram_num_256mb_blocks - 1);
 810         } else {
 811                 reg_mcfbalr = (u32)mc_ram_addr |
 812                                 (mc_ram_num_256mb_blocks);
 813         }
 814
 815         out_le32(&mc_ccsr_regs->reg_mcfbalr, reg_mcfbalr);
 816         out_le32(&mc_ccsr_regs->reg_mcfbahr,
 817                  (u32)(mc_ram_addr >> 32));
 818         out_le32(&mc_ccsr_regs->reg_mcfapr, FSL_BYPASS_AMQ);
 819
 820         /*
 821          * Tell the MC that we want delayed DPL deployment.
 822          */
 823         out_le32(&mc_ccsr_regs->reg_gsr, 0xDD00);
 824
 825         printf("\nfsl-mc: Booting Management Complex ... ");
 826
 827         /*
 828          * Deassert reset and release MC core 0 to run
 829          */
 830         out_le32(&mc_ccsr_regs->reg_gcr1, GCR1_P1_DE_RST | GCR1_M_ALL_DE_RST);
 831         error = wait_for_mc(true, &reg_gsr);
 832         if (error != 0)
 833                 goto out;
 834
 835         /*
 836          * TODO: need to obtain the portal_id for the root container from the
 837          * DPL
 838          */
 839         portal_id = 0;
 840
 841         /*
 842          * Initialize the global default MC portal
 843          * And check that the MC firmware is responding portal commands:
 844          */
 845         root_mc_io = (struct fsl_mc_io *)calloc(sizeof(struct fsl_mc_io), 1);
 846         if (!root_mc_io) {
 847                 printf(" No memory: calloc() failed\n");
 848                 return -ENOMEM;
 849         }
 850
 851         root_mc_io->mmio_regs = SOC_MC_PORTAL_ADDR(portal_id);
 852         debug("Checking access to MC portal of root DPRC container (portal_id %d, portal physical addr %p)\n",
 853               portal_id, root_mc_io->mmio_regs);
 854
 855         error = mc_get_version(root_mc_io, MC_CMD_NO_FLAGS, &mc_ver_info);
 856         if (error != 0) {
 857                 printf("fsl-mc: ERROR: Firmware version check failed (error: %d)\n",
 858                        error);
 859                 goto out;
 860         }
 861
 862         printf("fsl-mc: Management Complex booted (version: %d.%d.%d, boot status: %#x)\n",
 863                mc_ver_info.major, mc_ver_info.minor, mc_ver_info.revision,
 864                reg_gsr & GSR_FS_MASK);
 865
 866 out:
 867         if (error != 0)
 868                 mc_boot_status = error;
 869         else
 870                 mc_boot_status = 0;
 871
 872         return error;
 873 }
 874
 875 int mc_apply_dpl(u64 mc_dpl_addr)
 876 {
 877         struct mc_ccsr_registers __iomem *mc_ccsr_regs = MC_CCSR_BASE_ADDR;
 878         int error = 0;
 879         u32 reg_gsr;
 880         u64 mc_ram_addr = mc_get_dram_addr();
 881         size_t mc_ram_size = mc_get_dram_block_size();
 882
 883         if (!mc_dpl_addr)
 884                 return -1;
 885
 886         error = load_mc_dpl(mc_ram_addr, mc_ram_size, mc_dpl_addr);
 887         if (error != 0)
 888                 return error;
 889
 890         /*
 891          * Tell the MC to deploy the DPL:
 892          */
 893         out_le32(&mc_ccsr_regs->reg_gsr, 0x0);
 894         printf("fsl-mc: Deploying data path layout ... ");
 895         error = wait_for_mc(false, &reg_gsr);
 896
 897         if (!error)
 898                 mc_dpl_applied = 0;
 899
 900         return error;
 901 }
 902
 903 int get_mc_boot_status(void)
 904 {
 905         return mc_boot_status;
 906 }
 907
 908 #ifdef CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET
 909 int get_aiop_apply_status(void)
 910 {
 911         return mc_aiop_applied;
 912 }
 913 #endif
 914
 915 int get_dpl_apply_status(void)
 916 {
 917         return mc_dpl_applied;
 918 }
 919
 920 int is_lazy_dpl_addr_valid(void)
 921 {
 922         return !!mc_lazy_dpl_addr;
 923 }
 924
 925 /*
 926  * Return the MC address of private DRAM block.
 927  * As per MC design document, MC initial base address
 928  * should be least significant 512MB address of MC private
 929  * memory, i.e. address should point to end address masked
 930  * with 512MB offset in private DRAM block.
 931  */
 932 u64 mc_get_dram_addr(void)
 933 {
 934         size_t mc_ram_size = mc_get_dram_block_size();
 935
 936         if (!mc_memset_resv_ram || (get_mc_boot_status() < 0)) {
 937                 mc_memset_resv_ram = 1;
 938                 memset((void *)gd->arch.resv_ram, 0, mc_ram_size);
 939         }
 940
 941         return (gd->arch.resv_ram + mc_ram_size - 1) &
 942                 MC_RAM_BASE_ADDR_ALIGNMENT_MASK;
 943 }
 944
 945 /**
 946  * Return the actual size of the MC private DRAM block.
 947  */
 948 unsigned long mc_get_dram_block_size(void)
 949 {
 950         unsigned long dram_block_size = CONFIG_SYS_LS_MC_DRAM_BLOCK_MIN_SIZE;
 951
 952         char *dram_block_size_env_var = env_get(MC_MEM_SIZE_ENV_VAR);
 953
 954         if (dram_block_size_env_var) {
 955                 dram_block_size = simple_strtoul(dram_block_size_env_var, NULL,
 956                                                  16);
 957
 958                 if (dram_block_size < CONFIG_SYS_LS_MC_DRAM_BLOCK_MIN_SIZE) {
 959                         printf("fsl-mc: WARNING: Invalid value for \'"
 960                                MC_MEM_SIZE_ENV_VAR
 961                                "\' environment variable: %lu\n",
 962                                dram_block_size);
 963
 964                         dram_block_size = MC_DRAM_BLOCK_DEFAULT_SIZE;
 965                 }
 966         }
 967
 968         return dram_block_size;
 969 }
 970
 971 int fsl_mc_ldpaa_init(bd_t *bis)
 972 {
 973         int i;
 974
 975         for (i = WRIOP1_DPMAC1; i < NUM_WRIOP_PORTS; i++)
 976                 if (wriop_is_enabled_dpmac(i) == 1)
 977                         ldpaa_eth_init(i, wriop_get_enet_if(i));
 978         return 0;
 979 }
 980
 981 static int dprc_version_check(struct fsl_mc_io *mc_io, uint16_t handle)
 982 {
 983         int error;
 984         uint16_t major_ver, minor_ver;
 985
 986         error = dprc_get_api_version(mc_io, 0,
 987                                      &major_ver,
 988                                      &minor_ver);
 989         if (error < 0) {
 990                 printf("dprc_get_api_version() failed: %d\n", error);
 991                 return error;
 992         }
 993
 994         if (major_ver < DPRC_VER_MAJOR || (major_ver == DPRC_VER_MAJOR &&
 995                                            minor_ver < DPRC_VER_MINOR)) {
 996                 printf("DPRC version mismatch found %u.%u,",
 997                        major_ver, minor_ver);
 998                 printf("supported version is %u.%u\n",
 999                        DPRC_VER_MAJOR, DPRC_VER_MINOR);
1000         }
1001
1002         return error;
1003 }
1004
1005 static int dpio_init(void)
1006 {
1007         struct qbman_swp_desc p_des;
1008         struct dpio_attr attr;
1009         struct dpio_cfg dpio_cfg;
1010         int err = 0;
1011         uint16_t major_ver, minor_ver;
1012
1013         dflt_dpio = (struct fsl_dpio_obj *)calloc(
1014                                         sizeof(struct fsl_dpio_obj), 1);
1015         if (!dflt_dpio) {
1016                 printf("No memory: calloc() failed\n");
1017                 err = -ENOMEM;
1018                 goto err_calloc;
1019         }
1020         dpio_cfg.channel_mode = DPIO_LOCAL_CHANNEL;
1021         dpio_cfg.num_priorities = 8;
1022
1023         err = dpio_create(dflt_mc_io,
1024                           dflt_dprc_handle,
1025                           MC_CMD_NO_FLAGS,
1026                           &dpio_cfg,
1027                           &dflt_dpio->dpio_id);
1028         if (err < 0) {
1029                 printf("dpio_create() failed: %d\n", err);
1030                 err = -ENODEV;
1031                 goto err_create;
1032         }
1033
1034         err = dpio_get_api_version(dflt_mc_io, 0,
1035                                    &major_ver,
1036                                    &minor_ver);
1037         if (err < 0) {
1038                 printf("dpio_get_api_version() failed: %d\n", err);
1039                 goto err_get_api_ver;
1040         }
1041
1042         if (major_ver < DPIO_VER_MAJOR || (major_ver == DPIO_VER_MAJOR &&
1043                                            minor_ver < DPIO_VER_MINOR)) {
1044                 printf("DPRC version mismatch found %u.%u,",
1045                        major_ver,
1046                        minor_ver);
1047         }
1048
1049         err = dpio_open(dflt_mc_io,
1050                         MC_CMD_NO_FLAGS,
1051                         dflt_dpio->dpio_id,
1052                         &dflt_dpio->dpio_handle);
1053         if (err) {
1054                 printf("dpio_open() failed\n");
1055                 goto err_open;
1056         }
1057
1058         memset(&attr, 0, sizeof(struct dpio_attr));
1059         err = dpio_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
1060                                   dflt_dpio->dpio_handle, &attr);
1061         if (err < 0) {
1062                 printf("dpio_get_attributes() failed: %d\n", err);
1063                 goto err_get_attr;
1064         }
1065
1066         if (dflt_dpio->dpio_id != attr.id) {
1067                 printf("dnpi object id and attribute id are not same\n");
1068                 goto err_attr_not_same;
1069         }
1070
1071 #ifdef DEBUG
1072         printf("Init: DPIO id=0x%d\n", dflt_dpio->dpio_id);
1073 #endif
1074         err = dpio_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
1075         if (err < 0) {
1076                 printf("dpio_enable() failed %d\n", err);
1077                 goto err_get_enable;
1078         }
1079         debug("ce_offset=0x%llx, ci_offset=0x%llx, portalid=%d, prios=%d\n",
1080               attr.qbman_portal_ce_offset,
1081               attr.qbman_portal_ci_offset,
1082               attr.qbman_portal_id,
1083               attr.num_priorities);
1084
1085         p_des.cena_bar = (void *)(SOC_QBMAN_PORTALS_BASE_ADDR
1086                                         + attr.qbman_portal_ce_offset);
1087         p_des.cinh_bar = (void *)(SOC_QBMAN_PORTALS_BASE_ADDR
1088                                         + attr.qbman_portal_ci_offset);
1089
1090         dflt_dpio->sw_portal = qbman_swp_init(&p_des);
1091         if (dflt_dpio->sw_portal == NULL) {
1092                 printf("qbman_swp_init() failed\n");
1093                 goto err_get_swp_init;
1094         }
1095         return 0;
1096
1097 err_get_swp_init:
1098         dpio_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
1099 err_get_enable:
1100 err_get_attr:
1101 err_attr_not_same:
1102         dpio_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
1103 err_open:
1104 err_get_api_ver:
1105         dpio_destroy(dflt_mc_io,
1106                      dflt_dprc_handle,
1107                      MC_CMD_NO_FLAGS,
1108                      dflt_dpio->dpio_id);
1109 err_create:
1110         free(dflt_dpio);
1111 err_calloc:
1112         return err;
1113 }
1114
1115 static int dpio_exit(void)
1116 {
1117         int err;
1118
1119         err = dpio_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
1120         if (err < 0) {
1121                 printf("dpio_disable() failed: %d\n", err);
1122                 goto err;
1123         }
1124
1125         dpio_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
1126         if (err < 0) {
1127                 printf("dpio_close() failed: %d\n", err);
1128                 goto err;
1129         }
1130
1131         err = dpio_destroy(dflt_mc_io,
1132                            dflt_dprc_handle,
1133                            MC_CMD_NO_FLAGS,
1134                            dflt_dpio->dpio_id);
1135         if (err < 0) {
1136                 printf("dpio_destroy() failed: %d\n", err);
1137                 goto err;
1138         }
1139
1140 #ifdef DEBUG
1141         printf("Exit: DPIO id=0x%d\n", dflt_dpio->dpio_id);
1142 #endif
1143
1144         if (dflt_dpio)
1145                 free(dflt_dpio);
1146
1147         return 0;
1148 err:
1149         return err;
1150 }
1151
1152 static int dprc_init(void)
1153 {
1154         int err, child_portal_id, container_id;
1155         struct dprc_cfg cfg;
1156         uint64_t mc_portal_offset;
1157
1158         /* Open root container */
1159         err = dprc_get_container_id(root_mc_io, MC_CMD_NO_FLAGS, &container_id);
1160         if (err < 0) {
1161                 printf("dprc_get_container_id(): Root failed: %d\n", err);
1162                 goto err_root_container_id;
1163         }
1164
1165 #ifdef DEBUG
1166         printf("Root container id = %d\n", container_id);
1167 #endif
1168         err = dprc_open(root_mc_io, MC_CMD_NO_FLAGS, container_id,
1169                         &root_dprc_handle);
1170         if (err < 0) {
1171                 printf("dprc_open(): Root Container failed: %d\n", err);
1172                 goto err_root_open;
1173         }
1174
1175         if (!root_dprc_handle) {
1176                 printf("dprc_open(): Root Container Handle is not valid\n");
1177                 goto err_root_open;
1178         }
1179
1180         err = dprc_version_check(root_mc_io, root_dprc_handle);
1181         if (err < 0) {
1182                 printf("dprc_version_check() failed: %d\n", err);
1183                 goto err_root_open;
1184         }
1185
1186         memset(&cfg, 0, sizeof(struct dprc_cfg));
1187         cfg.options = DPRC_CFG_OPT_TOPOLOGY_CHANGES_ALLOWED |
1188                       DPRC_CFG_OPT_OBJ_CREATE_ALLOWED |
1189                       DPRC_CFG_OPT_ALLOC_ALLOWED;
1190         cfg.icid = DPRC_GET_ICID_FROM_POOL;
1191         cfg.portal_id = DPRC_GET_PORTAL_ID_FROM_POOL;
1192         err = dprc_create_container(root_mc_io, MC_CMD_NO_FLAGS,
1193                         root_dprc_handle,
1194                         &cfg,
1195                         &child_dprc_id,
1196                         &mc_portal_offset);
1197         if (err < 0) {
1198                 printf("dprc_create_container() failed: %d\n", err);
1199                 goto err_create;
1200         }
1201
1202         dflt_mc_io = (struct fsl_mc_io *)calloc(sizeof(struct fsl_mc_io), 1);
1203         if (!dflt_mc_io) {
1204                 err  = -ENOMEM;
1205                 printf(" No memory: calloc() failed\n");
1206                 goto err_calloc;
1207         }
1208
1209         child_portal_id = MC_PORTAL_OFFSET_TO_PORTAL_ID(mc_portal_offset);
1210         dflt_mc_io->mmio_regs = SOC_MC_PORTAL_ADDR(child_portal_id);
1211
1212 #ifdef DEBUG
1213         printf("MC portal of child DPRC container: %d, physical addr %p)\n",
1214                child_dprc_id, dflt_mc_io->mmio_regs);
1215 #endif
1216
1217         err = dprc_open(dflt_mc_io, MC_CMD_NO_FLAGS, child_dprc_id,
1218                         &dflt_dprc_handle);
1219         if (err < 0) {
1220                 printf("dprc_open(): Child container failed: %d\n", err);
1221                 goto err_child_open;
1222         }
1223
1224         if (!dflt_dprc_handle) {
1225                 printf("dprc_open(): Child container Handle is not valid\n");
1226                 goto err_child_open;
1227         }
1228
1229         return 0;
1230 err_child_open:
1231         free(dflt_mc_io);
1232 err_calloc:
1233         dprc_destroy_container(root_mc_io, MC_CMD_NO_FLAGS,
1234                                root_dprc_handle, child_dprc_id);
1235 err_create:
1236         dprc_close(root_mc_io, MC_CMD_NO_FLAGS, root_dprc_handle);
1237 err_root_open:
1238 err_root_container_id:
1239         return err;
1240 }
1241
1242 static int dprc_exit(void)
1243 {
1244         int err;
1245
1246         err = dprc_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dprc_handle);
1247         if (err < 0) {
1248                 printf("dprc_close(): Child failed: %d\n", err);
1249                 goto err;
1250         }
1251
1252         err = dprc_destroy_container(root_mc_io, MC_CMD_NO_FLAGS,
1253                                      root_dprc_handle, child_dprc_id);
1254         if (err < 0) {
1255                 printf("dprc_destroy_container() failed: %d\n", err);
1256                 goto err;
1257         }
1258
1259         err = dprc_close(root_mc_io, MC_CMD_NO_FLAGS, root_dprc_handle);
1260         if (err < 0) {
1261                 printf("dprc_close(): Root failed: %d\n", err);
1262                 goto err;
1263         }
1264
1265         if (dflt_mc_io)
1266                 free(dflt_mc_io);
1267
1268         if (root_mc_io)
1269                 free(root_mc_io);
1270
1271         return 0;
1272
1273 err:
1274         return err;
1275 }
1276
1277 static int dpbp_init(void)
1278 {
1279         int err;
1280         struct dpbp_attr dpbp_attr;
1281         struct dpbp_cfg dpbp_cfg;
1282         uint16_t major_ver, minor_ver;
1283
1284         dflt_dpbp = (struct fsl_dpbp_obj *)calloc(
1285                                         sizeof(struct fsl_dpbp_obj), 1);
1286         if (!dflt_dpbp) {
1287                 printf("No memory: calloc() failed\n");
1288                 err = -ENOMEM;
1289                 goto err_calloc;
1290         }
1291
1292         dpbp_cfg.options = 512;
1293
1294         err = dpbp_create(dflt_mc_io,
1295                           dflt_dprc_handle,
1296                           MC_CMD_NO_FLAGS,
1297                           &dpbp_cfg,
1298                           &dflt_dpbp->dpbp_id);
1299
1300         if (err < 0) {
1301                 err = -ENODEV;
1302                 printf("dpbp_create() failed: %d\n", err);
1303                 goto err_create;
1304         }
1305
1306         err = dpbp_get_api_version(dflt_mc_io, 0,
1307                                    &major_ver,
1308                                    &minor_ver);
1309         if (err < 0) {
1310                 printf("dpbp_get_api_version() failed: %d\n", err);
1311                 goto err_get_api_ver;
1312         }
1313
1314         if (major_ver < DPBP_VER_MAJOR || (major_ver == DPBP_VER_MAJOR &&
1315                                            minor_ver < DPBP_VER_MINOR)) {
1316                 printf("DPBP version mismatch found %u.%u,",
1317                        major_ver, minor_ver);
1318                 printf("supported version is %u.%u\n",
1319                        DPBP_VER_MAJOR, DPBP_VER_MINOR);
1320         }
1321
1322         err = dpbp_open(dflt_mc_io,
1323                         MC_CMD_NO_FLAGS,
1324                         dflt_dpbp->dpbp_id,
1325                         &dflt_dpbp->dpbp_handle);
1326         if (err) {
1327                 printf("dpbp_open() failed\n");
1328                 goto err_open;
1329         }
1330
1331         memset(&dpbp_attr, 0, sizeof(struct dpbp_attr));
1332         err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
1333                                   dflt_dpbp->dpbp_handle,
1334                                   &dpbp_attr);
1335         if (err < 0) {
1336                 printf("dpbp_get_attributes() failed: %d\n", err);
1337                 goto err_get_attr;
1338         }
1339
1340         if (dflt_dpbp->dpbp_id != dpbp_attr.id) {
1341                 printf("dpbp object id and attribute id are not same\n");
1342                 goto err_attr_not_same;
1343         }
1344
1345 #ifdef DEBUG
1346         printf("Init: DPBP id=0x%x\n", dflt_dpbp->dpbp_attr.id);
1347 #endif
1348
1349         err = dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
1350         if (err < 0) {
1351                 printf("dpbp_close() failed: %d\n", err);
1352                 goto err_close;
1353         }
1354
1355         return 0;
1356
1357 err_get_attr:
1358 err_attr_not_same:
1359         dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
1360         dpbp_destroy(dflt_mc_io,
1361                      dflt_dprc_handle,
1362                      MC_CMD_NO_FLAGS,
1363                      dflt_dpbp->dpbp_id);
1364 err_get_api_ver:
1365 err_close:
1366 err_open:
1367 err_create:
1368         free(dflt_dpbp);
1369 err_calloc:
1370         return err;
1371 }
1372
1373 static int dpbp_exit(void)
1374 {
1375         int err;
1376
1377         err = dpbp_destroy(dflt_mc_io, dflt_dprc_handle, MC_CMD_NO_FLAGS,
1378                            dflt_dpbp->dpbp_id);
1379         if (err < 0) {
1380                 printf("dpbp_destroy() failed: %d\n", err);
1381                 goto err;
1382         }
1383
1384 #ifdef DEBUG
1385         printf("Exit: DPBP id=0x%d\n", dflt_dpbp->dpbp_attr.id);
1386 #endif
1387
1388         if (dflt_dpbp)
1389                 free(dflt_dpbp);
1390         return 0;
1391
1392 err:
1393         return err;
1394 }
1395
1396 static int dpni_init(void)
1397 {
1398         int err;
1399         uint8_t cfg_buf[256] = {0};
1400         struct dpni_cfg dpni_cfg;
1401         uint16_t major_ver, minor_ver;
1402
1403         dflt_dpni = (struct fsl_dpni_obj *)calloc(
1404                                         sizeof(struct fsl_dpni_obj), 1);
1405         if (!dflt_dpni) {
1406                 printf("No memory: calloc() failed\n");
1407                 err = -ENOMEM;
1408                 goto err_calloc;
1409         }
1410
1411         memset(&dpni_cfg, 0, sizeof(dpni_cfg));
1412         err = dpni_prepare_cfg(&dpni_cfg, &cfg_buf[0]);
1413         if (err < 0) {
1414                 err = -ENODEV;
1415                 printf("dpni_prepare_cfg() failed: %d\n", err);
1416                 goto err_prepare_cfg;
1417         }
1418
1419         err = dpni_create(dflt_mc_io,
1420                           dflt_dprc_handle,
1421                           MC_CMD_NO_FLAGS,
1422                           &dpni_cfg,
1423                           &dflt_dpni->dpni_id);
1424         if (err < 0) {
1425                 err = -ENODEV;
1426                 printf("dpni create() failed: %d\n", err);
1427                 goto err_create;
1428         }
1429
1430         err = dpni_get_api_version(dflt_mc_io, 0,
1431                                    &major_ver,
1432                                    &minor_ver);
1433         if (err < 0) {
1434                 printf("dpni_get_api_version() failed: %d\n", err);
1435                 goto err_get_version;
1436         }
1437
1438         if (major_ver < DPNI_VER_MAJOR || (major_ver == DPNI_VER_MAJOR &&
1439                                            minor_ver < DPNI_VER_MINOR)) {
1440                 printf("DPNI version mismatch found %u.%u,",
1441                        major_ver, minor_ver);
1442                 printf("supported version is %u.%u\n",
1443                        DPNI_VER_MAJOR, DPNI_VER_MINOR);
1444         }
1445
1446         err = dpni_open(dflt_mc_io,
1447                         MC_CMD_NO_FLAGS,
1448                         dflt_dpni->dpni_id,
1449                         &dflt_dpni->dpni_handle);
1450         if (err) {
1451                 printf("dpni_open() failed\n");
1452                 goto err_open;
1453         }
1454
1455 #ifdef DEBUG
1456         printf("Init: DPNI id=0x%d\n", dflt_dpni->dpni_id);
1457 #endif
1458         err = dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
1459         if (err < 0) {
1460                 printf("dpni_close() failed: %d\n", err);
1461                 goto err_close;
1462         }
1463
1464         return 0;
1465
1466 err_close:
1467         dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
1468 err_open:
1469 err_get_version:
1470         dpni_destroy(dflt_mc_io,
1471                      dflt_dprc_handle,
1472                      MC_CMD_NO_FLAGS,
1473                      dflt_dpni->dpni_id);
1474 err_create:
1475 err_prepare_cfg:
1476         free(dflt_dpni);
1477 err_calloc:
1478         return err;
1479 }
1480
1481 static int dpni_exit(void)
1482 {
1483         int err;
1484
1485         err = dpni_destroy(dflt_mc_io, dflt_dprc_handle, MC_CMD_NO_FLAGS,
1486                            dflt_dpni->dpni_id);
1487         if (err < 0) {
1488                 printf("dpni_destroy() failed: %d\n", err);
1489                 goto err;
1490         }
1491
1492 #ifdef DEBUG
1493         printf("Exit: DPNI id=0x%d\n", dflt_dpni->dpni_id);
1494 #endif
1495
1496         if (dflt_dpni)
1497                 free(dflt_dpni);
1498         return 0;
1499
1500 err:
1501         return err;
1502 }
1503
1504 static bool is_dpsparser_supported(void)
1505 {
1506         /* dpsparser support was first introduced in MC version: 10.12.0 */
1507         if (mc_ver_info.major < 10)
1508                 return false;
1509         if (mc_ver_info.major == 10)
1510                 return (mc_ver_info.minor >= 12);
1511         return true;
1512 }
1513
1514 static int dpsparser_version_check(struct fsl_mc_io *mc_io)
1515 {
1516         int error;
1517         u16 major_ver, minor_ver;
1518
1519         if (!is_dpsparser_supported())
1520                 return 0;
1521
1522         error = dpsparser_get_api_version(mc_io, 0,
1523                                           &major_ver,
1524                                           &minor_ver);
1525         if (error < 0) {
1526                 printf("dpsparser_get_api_version() failed: %d\n", error);
1527                 return error;
1528         }
1529
1530         if (major_ver < DPSPARSER_VER_MAJOR || (major_ver ==
1531             DPSPARSER_VER_MAJOR && minor_ver < DPSPARSER_VER_MINOR)) {
1532                 printf("DPSPARSER version mismatch found %u.%u,",
1533                        major_ver, minor_ver);
1534                 printf("supported version is %u.%u\n",
1535                        DPSPARSER_VER_MAJOR, DPSPARSER_VER_MINOR);
1536         }
1537
1538         return error;
1539 }
1540
1541 static int dpsparser_init(void)
1542 {
1543         int err = 0;
1544
1545         if (!is_dpsparser_supported())
1546                 return 0;
1547
1548         err = dpsparser_create(dflt_mc_io,
1549                                dflt_dprc_handle,
1550                                MC_CMD_NO_FLAGS,
1551                                &dpsparser_obj_id);
1552         if (err)
1553                 printf("dpsparser_create() failed\n");
1554
1555         err = dpsparser_version_check(dflt_mc_io);
1556         if (err < 0) {
1557                 printf("dpsparser_version_check() failed: %d\n", err);
1558                 goto err_version_check;
1559         }
1560
1561         err = dpsparser_open(dflt_mc_io,
1562                              MC_CMD_NO_FLAGS,
1563                              &dpsparser_handle);
1564         if (err < 0) {
1565                 printf("dpsparser_open() failed: %d\n", err);
1566                 goto err_open;
1567         }
1568
1569         return err;
1570
1571 err_open:
1572 err_version_check:
1573         dpsparser_destroy(dflt_mc_io,
1574                           dflt_dprc_handle,
1575                           MC_CMD_NO_FLAGS, dpsparser_obj_id);
1576
1577         return err;
1578 }
1579
1580 #ifdef DPSPARSER_DESTROY
1581 /* TODO: refactoring needed in the future to allow DPSPARSER object destroy
1582  * Workaround: DO NOT destroy DPSPARSER object because it needs to be available
1583  * on Apply DPL
1584  */
1585 static int dpsparser_exit(void)
1586 {
1587         int err;
1588
1589         if (!is_dpsparser_supported())
1590                 return 0;
1591
1592         dpsparser_close(dflt_mc_io, MC_CMD_NO_FLAGS, dpsparser_handle);
1593         if (err < 0) {
1594                 printf("dpsparser_close() failed: %d\n", err);
1595                 goto err;
1596         }
1597
1598         err = dpsparser_destroy(dflt_mc_io, dflt_dprc_handle,
1599                                 MC_CMD_NO_FLAGS, dpsparser_obj_id);
1600         if (err < 0) {
1601                 printf("dpsparser_destroy() failed: %d\n", err);
1602                 goto err;
1603         }
1604         return 0;
1605
1606 err:
1607         return err;
1608 }
1609 #endif
1610
1611 int mc_apply_spb(u64 mc_spb_addr)
1612 {
1613         int err = 0;
1614         u16 error, err_arr_size;
1615         u64 mc_spb_offset;
1616         u32 spb_size;
1617         struct sp_blob_header *sp_blob;
1618         u64 mc_ram_addr = mc_get_dram_addr();
1619
1620         if (!is_dpsparser_supported())
1621                 return 0;
1622
1623         if (!mc_spb_addr) {
1624                 printf("fsl-mc: Invalid Blob address\n");
1625                 return -1;
1626         }
1627
1628 #ifdef CONFIG_MC_DRAM_SPB_OFFSET
1629         mc_spb_offset = CONFIG_MC_DRAM_SPB_OFFSET;
1630 #else
1631 #error "CONFIG_MC_DRAM_SPB_OFFSET not defined"
1632 #endif
1633
1634         // Read blob header and get size of SPB blob
1635         sp_blob = (struct sp_blob_header *)mc_spb_addr;
1636         spb_size = le32_to_cpu(sp_blob->length);
1637         if (spb_size > CONFIG_MC_SPB_MAX_SIZE) {
1638                 printf("\nfsl-mc: ERROR: Bad SPB image (too large: %d)\n",
1639                        spb_size);
1640                 return -EINVAL;
1641         }
1642
1643         mc_copy_image("MC SP Blob", mc_spb_addr, spb_size,
1644                       mc_ram_addr + mc_spb_offset);
1645
1646         //Invoke MC command to apply SPB blob
1647         printf("fsl-mc: Applying soft parser blob... ");
1648         err = dpsparser_apply_spb(dflt_mc_io, MC_CMD_NO_FLAGS, dpsparser_handle,
1649                                   mc_spb_offset, &error);
1650         if (err)
1651                 return err;
1652
1653         if (error == 0) {
1654                 printf("SUCCESS\n");
1655         } else {
1656                 printf("FAILED with error code = %d:\n", error);
1657                 err_arr_size = (u16)ARRAY_SIZE(mc_err_msg_apply_spb);
1658
1659                 if (error > 0 && error < err_arr_size)
1660                         printf(mc_err_msg_apply_spb[error]);
1661                 else
1662                         printf(MC_ERROR_MSG_SPB_UNKNOWN);
1663         }
1664
1665         return err;
1666 }
1667
1668 static int mc_init_object(void)
1669 {
1670         int err = 0;
1671
1672         err = dprc_init();
1673         if (err < 0) {
1674                 printf("dprc_init() failed: %d\n", err);
1675                 goto err;
1676         }
1677
1678         err = dpbp_init();
1679         if (err < 0) {
1680                 printf("dpbp_init() failed: %d\n", err);
1681                 goto err;
1682         }
1683
1684         err = dpio_init();
1685         if (err < 0) {
1686                 printf("dpio_init() failed: %d\n", err);
1687                 goto err;
1688         }
1689
1690         err = dpni_init();
1691         if (err < 0) {
1692                 printf("dpni_init() failed: %d\n", err);
1693                 goto err;
1694         }
1695
1696         err = dpsparser_init();
1697         if (err < 0) {
1698                 printf("dpsparser_init() failed: %d\n", err);
1699                 goto err;
1700         }
1701
1702         return 0;
1703 err:
1704         return err;
1705 }
1706
1707 int fsl_mc_ldpaa_exit(bd_t *bd)
1708 {
1709         int err = 0;
1710         bool is_dpl_apply_status = false;
1711         bool mc_boot_status = false;
1712
1713         if (bd && mc_lazy_dpl_addr && !fsl_mc_ldpaa_exit(NULL)) {
1714                 err = mc_apply_dpl(mc_lazy_dpl_addr);
1715                 if (!err)
1716                         fdt_fixup_board_enet(working_fdt);
1717                 mc_lazy_dpl_addr = 0;
1718         }
1719
1720         if (!get_mc_boot_status())
1721                 mc_boot_status = true;
1722
1723         /* MC is not loaded intentionally, So return success. */
1724         if (bd && !mc_boot_status)
1725                 return 0;
1726
1727         /* If DPL is deployed, set is_dpl_apply_status as TRUE. */
1728         if (!get_dpl_apply_status())
1729                 is_dpl_apply_status = true;
1730
1731         /*
1732          * For case MC is loaded but DPL is not deployed, return success and
1733          * print message on console. Else FDT fix-up code execution hanged.
1734          */
1735         if (bd && mc_boot_status && !is_dpl_apply_status) {
1736                 printf("fsl-mc: DPL not deployed, DPAA2 ethernet not work\n");
1737                 goto mc_obj_cleanup;
1738         }
1739
1740         if (bd && mc_boot_status && is_dpl_apply_status)
1741                 return 0;
1742
1743 mc_obj_cleanup:
1744         err = dpbp_exit();
1745         if (err < 0) {
1746                 printf("dpbp_exit() failed: %d\n", err);
1747                 goto err;
1748         }
1749
1750         err = dpio_exit();
1751         if (err < 0) {
1752                 printf("dpio_exit() failed: %d\n", err);
1753                 goto err;
1754         }
1755
1756         err = dpni_exit();
1757         if (err < 0) {
1758                 printf("dpni_exit() failed: %d\n", err);
1759                 goto err;
1760         }
1761
1762         err = dprc_exit();
1763         if (err < 0) {
1764                 printf("dprc_exit() failed: %d\n", err);
1765                 goto err;
1766         }
1767
1768         return 0;
1769 err:
1770         return err;
1771 }
1772
1773 static int do_fsl_mc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1774 {
1775         int err = 0;
1776         if (argc < 3)
1777                 goto usage;
1778
1779         switch (argv[1][0]) {
1780         case 's': {
1781                         char sub_cmd;
1782                         u64 mc_fw_addr, mc_dpc_addr;
1783 #ifdef CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET
1784                         u64 aiop_fw_addr;
1785 #endif
1786
1787                         sub_cmd = argv[2][0];
1788
1789                         switch (sub_cmd) {
1790                         case 'm':
1791                                 if (argc < 5)
1792                                         goto usage;
1793
1794                                 if (get_mc_boot_status() == 0) {
1795                                         printf("fsl-mc: MC is already booted");
1796                                         printf("\n");
1797                                         return err;
1798                                 }
1799                                 mc_fw_addr = simple_strtoull(argv[3], NULL, 16);
1800                                 mc_dpc_addr = simple_strtoull(argv[4], NULL,
1801                                                               16);
1802
1803                                 if (!mc_init(mc_fw_addr, mc_dpc_addr))
1804                                         err = mc_init_object();
1805                                 break;
1806
1807 #ifdef CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET
1808                         case 'a':
1809                                 if (argc < 4)
1810                                         goto usage;
1811                                 if (get_aiop_apply_status() == 0) {
1812                                         printf("fsl-mc: AIOP FW is already");
1813                                         printf(" applied\n");
1814                                         return err;
1815                                 }
1816
1817                                 aiop_fw_addr = simple_strtoull(argv[3], NULL,
1818                                                                16);
1819
1820                                 /* if SoC doesn't have AIOP, err = -ENODEV */
1821                                 err = load_mc_aiop_img(aiop_fw_addr);
1822                                 if (!err)
1823                                         printf("fsl-mc: AIOP FW applied\n");
1824                                 break;
1825 #endif
1826                         default:
1827                                 printf("Invalid option: %s\n", argv[2]);
1828                                 goto usage;
1829
1830                                 break;
1831                         }
1832                 }
1833                 break;
1834
1835         case 'l': {
1836                 /* lazyapply */
1837                 u64 mc_dpl_addr;
1838
1839                 if (argc < 4)
1840                         goto usage;
1841
1842                 if (get_dpl_apply_status() == 0) {
1843                         printf("fsl-mc: DPL already applied\n");
1844                         return err;
1845                 }
1846
1847                 mc_dpl_addr = simple_strtoull(argv[3], NULL, 16);
1848
1849                 if (get_mc_boot_status() != 0) {
1850                         printf("fsl-mc: Deploying data path layout ..");
1851                         printf("ERROR (MC is not booted)\n");
1852                         return -ENODEV;
1853                 }
1854
1855                 /*
1856                  * We will do the actual dpaa exit and dpl apply
1857                  * later from announce_and_cleanup().
1858                  */
1859                 mc_lazy_dpl_addr = mc_dpl_addr;
1860                 break;
1861                 }
1862
1863         case 'a': {
1864                 /* apply */
1865                 char sub_cmd;
1866                 u64 mc_apply_addr;
1867
1868                 if (argc < 4)
1869                         goto usage;
1870
1871                 sub_cmd = argv[2][0];
1872
1873                 switch (sub_cmd) {
1874                 case 'd':
1875                 case 'D':
1876                         if (get_dpl_apply_status() == 0) {
1877                                 printf("fsl-mc: DPL already applied\n");
1878                                 return err;
1879                         }
1880                         if (get_mc_boot_status() != 0) {
1881                                 printf("fsl-mc: Deploying data path layout ..");
1882                                 printf("ERROR (MC is not booted)\n");
1883                                 return -ENODEV;
1884                         }
1885
1886                         mc_apply_addr = simple_strtoull(argv[3], NULL, 16);
1887
1888                         /* The user wants DPL applied now */
1889                         if (!fsl_mc_ldpaa_exit(NULL))
1890                                 err = mc_apply_dpl(mc_apply_addr);
1891                         break;
1892
1893                 case 's':
1894                         if (!is_dpsparser_supported()) {
1895                                 printf("fsl-mc: apply spb command .. ");
1896                                 printf("ERROR: requires at least MC 10.12.0\n");
1897                                 return err;
1898                         }
1899                         if (get_mc_boot_status() != 0) {
1900                                 printf("fsl-mc: Deploying Soft Parser Blob...");
1901                                 printf("ERROR (MC is not booted)\n");
1902                                 return err;
1903                         }
1904
1905                         mc_apply_addr = simple_strtoull(argv[3], NULL, 16);
1906
1907                         /* Apply spb (Soft Parser Blob) */
1908                         err = mc_apply_spb(mc_apply_addr);
1909                         break;
1910
1911                 default:
1912                         printf("Invalid option: %s\n", argv[2]);
1913                         goto usage;
1914                 }
1915                 break;
1916                 }
1917         default:
1918                 printf("Invalid option: %s\n", argv[1]);
1919                 goto usage;
1920                 break;
1921         }
1922         return err;
1923  usage:
1924         return CMD_RET_USAGE;
1925 }
1926
1927 U_BOOT_CMD(
1928         fsl_mc,  CONFIG_SYS_MAXARGS,  1,   do_fsl_mc,
1929         "DPAA2 command to manage Management Complex (MC)",
1930         "start mc [FW_addr] [DPC_addr] - Start Management Complex\n"
1931         "fsl_mc apply DPL [DPL_addr] - Apply DPL file\n"
1932         "fsl_mc lazyapply DPL [DPL_addr] - Apply DPL file on exit\n"
1933         "fsl_mc apply spb [spb_addr] - Apply SPB Soft Parser Blob\n"
1934         "fsl_mc start aiop [FW_addr] - Start AIOP\n"
1935 );
1936
1937 void mc_env_boot(void)
1938 {
1939 #if defined(CONFIG_FSL_MC_ENET)
1940         char *mc_boot_env_var;
1941         /* The MC may only be initialized in the reset PHY function
1942          * because otherwise U-Boot has not yet set up all the MAC
1943          * address info properly. Without MAC addresses, the MC code
1944          * can not properly initialize the DPC.
1945          */
1946         mc_boot_env_var = env_get(MC_BOOT_ENV_VAR);
1947         if (mc_boot_env_var)
1948                 run_command_list(mc_boot_env_var, -1, 0);
1949 #endif /* CONFIG_FSL_MC_ENET */
1950 }