drivers/net/fsl-mc/mc.c

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