2 * Copyright (C) 2014 Freescale Semiconductor
4 * SPDX-License-Identifier: GPL-2.0+
8 #include <fsl-mc/fsl_mc.h>
9 #include <fsl-mc/fsl_mc_sys.h>
10 #include <fsl-mc/fsl_mc_private.h>
11 #include <fsl-mc/fsl_dpmng.h>
12 #include <fsl-mc/fsl_dprc.h>
13 #include <fsl-mc/fsl_dpio.h>
14 #include <fsl-mc/fsl_qbman_portal.h>
16 #define MC_RAM_BASE_ADDR_ALIGNMENT (512UL * 1024 * 1024)
17 #define MC_RAM_BASE_ADDR_ALIGNMENT_MASK (~(MC_RAM_BASE_ADDR_ALIGNMENT - 1))
18 #define MC_RAM_SIZE_ALIGNMENT (256UL * 1024 * 1024)
20 #define MC_MEM_SIZE_ENV_VAR "mcmemsize"
21 #define MC_BOOT_TIMEOUT_ENV_VAR "mcboottimeout"
23 DECLARE_GLOBAL_DATA_PTR;
24 static int mc_boot_status;
25 struct fsl_mc_io *dflt_mc_io = NULL;
26 uint16_t dflt_dprc_handle = 0;
27 struct fsl_dpbp_obj *dflt_dpbp = NULL;
28 struct fsl_dpio_obj *dflt_dpio = NULL;
29 uint16_t dflt_dpio_handle = 0;
32 void dump_ram_words(const char *title, void *addr)
35 uint32_t *words = addr;
37 printf("Dumping beginning of %s (%p):\n", title, addr);
38 for (i = 0; i < 16; i++)
39 printf("%#x ", words[i]);
44 void dump_mc_ccsr_regs(struct mc_ccsr_registers __iomem *mc_ccsr_regs)
46 printf("MC CCSR registers:\n"
56 mc_ccsr_regs->reg_gcr1,
57 mc_ccsr_regs->reg_gsr,
58 mc_ccsr_regs->reg_sicbalr,
59 mc_ccsr_regs->reg_sicbahr,
60 mc_ccsr_regs->reg_sicapr,
61 mc_ccsr_regs->reg_mcfbalr,
62 mc_ccsr_regs->reg_mcfbahr,
63 mc_ccsr_regs->reg_mcfapr,
64 mc_ccsr_regs->reg_psr);
68 #define dump_ram_words(title, addr)
69 #define dump_mc_ccsr_regs(mc_ccsr_regs)
73 #ifndef CONFIG_SYS_LS_MC_FW_IN_DDR
75 * Copying MC firmware or DPL image to DDR
77 static int mc_copy_image(const char *title,
78 u64 image_addr, u32 image_size, u64 mc_ram_addr)
80 debug("%s copied to address %p\n", title, (void *)mc_ram_addr);
81 memcpy((void *)mc_ram_addr, (void *)image_addr, image_size);
82 flush_dcache_range(mc_ram_addr, mc_ram_addr + image_size);
87 * MC firmware FIT image parser checks if the image is in FIT
88 * format, verifies integrity of the image and calculates
89 * raw image address and size values.
90 * Returns 0 on success and a negative errno on error.
93 int parse_mc_firmware_fit_image(const void **raw_image_addr,
94 size_t *raw_image_size)
101 const char *uname = "firmware";
103 /* Check if the image is in NOR flash */
104 #ifdef CONFIG_SYS_LS_MC_FW_IN_NOR
105 fit_hdr = (void *)CONFIG_SYS_LS_MC_FW_ADDR;
107 #error "No CONFIG_SYS_LS_MC_FW_IN_xxx defined"
110 /* Check if Image is in FIT format */
111 format = genimg_get_format(fit_hdr);
113 if (format != IMAGE_FORMAT_FIT) {
114 printf("fsl-mc: ERROR: Bad firmware image (not a FIT image)\n");
118 if (!fit_check_format(fit_hdr)) {
119 printf("fsl-mc: ERROR: Bad firmware image (bad FIT header)\n");
123 node_offset = fit_image_get_node(fit_hdr, uname);
125 if (node_offset < 0) {
126 printf("fsl-mc: ERROR: Bad firmware image (missing subimage)\n");
130 /* Verify MC firmware image */
131 if (!(fit_image_verify(fit_hdr, node_offset))) {
132 printf("fsl-mc: ERROR: Bad firmware image (bad CRC)\n");
136 /* Get address and size of raw image */
137 fit_image_get_data(fit_hdr, node_offset, &data, &size);
139 *raw_image_addr = data;
140 *raw_image_size = size;
147 * Calculates the values to be used to specify the address range
148 * for the MC private DRAM block, in the MCFBALR/MCFBAHR registers.
149 * It returns the highest 512MB-aligned address within the given
150 * address range, in '*aligned_base_addr', and the number of 256 MiB
151 * blocks in it, in 'num_256mb_blocks'.
153 static int calculate_mc_private_ram_params(u64 mc_private_ram_start_addr,
155 u64 *aligned_base_addr,
156 u8 *num_256mb_blocks)
161 if (mc_ram_size % MC_RAM_SIZE_ALIGNMENT != 0) {
162 printf("fsl-mc: ERROR: invalid MC private RAM size (%lu)\n",
167 num_blocks = mc_ram_size / MC_RAM_SIZE_ALIGNMENT;
168 if (num_blocks < 1 || num_blocks > 0xff) {
169 printf("fsl-mc: ERROR: invalid MC private RAM size (%lu)\n",
174 addr = (mc_private_ram_start_addr + mc_ram_size - 1) &
175 MC_RAM_BASE_ADDR_ALIGNMENT_MASK;
177 if (addr < mc_private_ram_start_addr) {
178 printf("fsl-mc: ERROR: bad start address %#llx\n",
179 mc_private_ram_start_addr);
183 *aligned_base_addr = addr;
184 *num_256mb_blocks = num_blocks;
188 static int load_mc_dpc(u64 mc_ram_addr, size_t mc_ram_size)
191 #ifndef CONFIG_SYS_LS_MC_DPC_IN_DDR
197 #ifdef CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET
198 BUILD_BUG_ON((CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET & 0x3) != 0 ||
199 CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET > 0xffffffff);
201 mc_dpc_offset = CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET;
203 #error "CONFIG_SYS_LS_MC_DRAM_DPC_OFFSET not defined"
207 * Load the MC DPC blob in the MC private DRAM block:
209 #ifdef CONFIG_SYS_LS_MC_DPC_IN_DDR
210 printf("MC DPC is preloaded to %#llx\n", mc_ram_addr + mc_dpc_offset);
213 * Get address and size of the DPC blob stored in flash:
215 #ifdef CONFIG_SYS_LS_MC_DPC_IN_NOR
216 dpc_fdt_hdr = (void *)CONFIG_SYS_LS_MC_DPC_ADDR;
218 #error "No CONFIG_SYS_LS_MC_DPC_IN_xxx defined"
221 error = fdt_check_header(dpc_fdt_hdr);
224 * Don't return with error here, since the MC firmware can
225 * still boot without a DPC
227 printf("\nfsl-mc: WARNING: No DPC image found");
231 dpc_size = fdt_totalsize(dpc_fdt_hdr);
232 if (dpc_size > CONFIG_SYS_LS_MC_DPC_MAX_LENGTH) {
233 printf("\nfsl-mc: ERROR: Bad DPC image (too large: %d)\n",
238 mc_copy_image("MC DPC blob",
239 (u64)dpc_fdt_hdr, dpc_size, mc_ram_addr + mc_dpc_offset);
240 #endif /* not defined CONFIG_SYS_LS_MC_DPC_IN_DDR */
242 dump_ram_words("DPC", (void *)(mc_ram_addr + mc_dpc_offset));
246 static int load_mc_dpl(u64 mc_ram_addr, size_t mc_ram_size)
249 #ifndef CONFIG_SYS_LS_MC_DPL_IN_DDR
255 #ifdef CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET
256 BUILD_BUG_ON((CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET & 0x3) != 0 ||
257 CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET > 0xffffffff);
259 mc_dpl_offset = CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET;
261 #error "CONFIG_SYS_LS_MC_DRAM_DPL_OFFSET not defined"
265 * Load the MC DPL blob in the MC private DRAM block:
267 #ifdef CONFIG_SYS_LS_MC_DPL_IN_DDR
268 printf("MC DPL is preloaded to %#llx\n", mc_ram_addr + mc_dpl_offset);
271 * Get address and size of the DPL blob stored in flash:
273 #ifdef CONFIG_SYS_LS_MC_DPL_IN_NOR
274 dpl_fdt_hdr = (void *)CONFIG_SYS_LS_MC_DPL_ADDR;
276 #error "No CONFIG_SYS_LS_MC_DPL_IN_xxx defined"
279 error = fdt_check_header(dpl_fdt_hdr);
281 printf("\nfsl-mc: ERROR: Bad DPL image (bad header)\n");
285 dpl_size = fdt_totalsize(dpl_fdt_hdr);
286 if (dpl_size > CONFIG_SYS_LS_MC_DPL_MAX_LENGTH) {
287 printf("\nfsl-mc: ERROR: Bad DPL image (too large: %d)\n",
292 mc_copy_image("MC DPL blob",
293 (u64)dpl_fdt_hdr, dpl_size, mc_ram_addr + mc_dpl_offset);
294 #endif /* not defined CONFIG_SYS_LS_MC_DPL_IN_DDR */
296 dump_ram_words("DPL", (void *)(mc_ram_addr + mc_dpl_offset));
301 * Return the MC boot timeout value in milliseconds
303 static unsigned long get_mc_boot_timeout_ms(void)
305 unsigned long timeout_ms = CONFIG_SYS_LS_MC_BOOT_TIMEOUT_MS;
307 char *timeout_ms_env_var = getenv(MC_BOOT_TIMEOUT_ENV_VAR);
309 if (timeout_ms_env_var) {
310 timeout_ms = simple_strtoul(timeout_ms_env_var, NULL, 10);
311 if (timeout_ms == 0) {
312 printf("fsl-mc: WARNING: Invalid value for \'"
313 MC_BOOT_TIMEOUT_ENV_VAR
314 "\' environment variable: %lu\n",
317 timeout_ms = CONFIG_SYS_LS_MC_BOOT_TIMEOUT_MS;
324 static int wait_for_mc(bool booting_mc, u32 *final_reg_gsr)
327 u32 mc_fw_boot_status;
328 unsigned long timeout_ms = get_mc_boot_timeout_ms();
329 struct mc_ccsr_registers __iomem *mc_ccsr_regs = MC_CCSR_BASE_ADDR;
332 assert(timeout_ms > 0);
334 udelay(1000); /* throttle polling */
335 reg_gsr = in_le32(&mc_ccsr_regs->reg_gsr);
336 mc_fw_boot_status = (reg_gsr & GSR_FS_MASK);
337 if (mc_fw_boot_status & 0x1)
345 if (timeout_ms == 0) {
346 printf("ERROR: timeout\n");
348 /* TODO: Get an error status from an MC CCSR register */
352 if (mc_fw_boot_status != 0x1) {
354 * TODO: Identify critical errors from the GSR register's FS
355 * field and for those errors, set error to -ENODEV or other
356 * appropriate errno, so that the status property is set to
357 * failure in the fsl,dprc device tree node.
359 printf("WARNING: Firmware returned an error (GSR: %#x)\n",
366 *final_reg_gsr = reg_gsr;
374 struct mc_ccsr_registers __iomem *mc_ccsr_regs = MC_CCSR_BASE_ADDR;
378 #ifndef CONFIG_SYS_LS_MC_FW_IN_DDR
379 const void *raw_image_addr;
380 size_t raw_image_size = 0;
382 struct mc_version mc_ver_info;
383 u64 mc_ram_aligned_base_addr;
384 u8 mc_ram_num_256mb_blocks;
385 size_t mc_ram_size = mc_get_dram_block_size();
388 * The MC private DRAM block was already carved at the end of DRAM
389 * by board_init_f() using CONFIG_SYS_MEM_TOP_HIDE:
391 if (gd->bd->bi_dram[1].start) {
393 gd->bd->bi_dram[1].start + gd->bd->bi_dram[1].size;
396 gd->bd->bi_dram[0].start + gd->bd->bi_dram[0].size;
399 error = calculate_mc_private_ram_params(mc_ram_addr,
401 &mc_ram_aligned_base_addr,
402 &mc_ram_num_256mb_blocks);
407 * Management Complex cores should be held at reset out of POR.
408 * U-boot should be the first software to touch MC. To be safe,
409 * we reset all cores again by setting GCR1 to 0. It doesn't do
410 * anything if they are held at reset. After we setup the firmware
411 * we kick off MC by deasserting the reset bit for core 0, and
412 * deasserting the reset bits for Command Portal Managers.
413 * The stop bits are not touched here. They are used to stop the
414 * cores when they are active. Setting stop bits doesn't stop the
415 * cores from fetching instructions when they are released from
418 out_le32(&mc_ccsr_regs->reg_gcr1, 0);
421 #ifdef CONFIG_SYS_LS_MC_FW_IN_DDR
422 printf("MC firmware is preloaded to %#llx\n", mc_ram_addr);
424 error = parse_mc_firmware_fit_image(&raw_image_addr, &raw_image_size);
428 * Load the MC FW at the beginning of the MC private DRAM block:
430 mc_copy_image("MC Firmware",
431 (u64)raw_image_addr, raw_image_size, mc_ram_addr);
433 dump_ram_words("firmware", (void *)mc_ram_addr);
435 error = load_mc_dpc(mc_ram_addr, mc_ram_size);
439 error = load_mc_dpl(mc_ram_addr, mc_ram_size);
443 debug("mc_ccsr_regs %p\n", mc_ccsr_regs);
444 dump_mc_ccsr_regs(mc_ccsr_regs);
447 * Tell MC what is the address range of the DRAM block assigned to it:
449 reg_mcfbalr = (u32)mc_ram_aligned_base_addr |
450 (mc_ram_num_256mb_blocks - 1);
451 out_le32(&mc_ccsr_regs->reg_mcfbalr, reg_mcfbalr);
452 out_le32(&mc_ccsr_regs->reg_mcfbahr,
453 (u32)(mc_ram_aligned_base_addr >> 32));
454 out_le32(&mc_ccsr_regs->reg_mcfapr, MCFAPR_BYPASS_ICID_MASK);
457 * Tell the MC that we want delayed DPL deployment.
459 out_le32(&mc_ccsr_regs->reg_gsr, 0xDD00);
461 printf("\nfsl-mc: Booting Management Complex ... ");
464 * Deassert reset and release MC core 0 to run
466 out_le32(&mc_ccsr_regs->reg_gcr1, GCR1_P1_DE_RST | GCR1_M_ALL_DE_RST);
467 error = wait_for_mc(true, ®_gsr);
472 * TODO: need to obtain the portal_id for the root container from the
478 * Initialize the global default MC portal
479 * And check that the MC firmware is responding portal commands:
481 dflt_mc_io = (struct fsl_mc_io *)malloc(sizeof(struct fsl_mc_io));
483 printf(" No memory: malloc() failed\n");
487 dflt_mc_io->mmio_regs = SOC_MC_PORTAL_ADDR(portal_id);
488 debug("Checking access to MC portal of root DPRC container (portal_id %d, portal physical addr %p)\n",
489 portal_id, dflt_mc_io->mmio_regs);
491 error = mc_get_version(dflt_mc_io, &mc_ver_info);
493 printf("fsl-mc: ERROR: Firmware version check failed (error: %d)\n",
498 if (MC_VER_MAJOR != mc_ver_info.major)
499 printf("fsl-mc: ERROR: Firmware major version mismatch (found: %d, expected: %d)\n",
500 mc_ver_info.major, MC_VER_MAJOR);
502 if (MC_VER_MINOR != mc_ver_info.minor)
503 printf("fsl-mc: WARNING: Firmware minor version mismatch (found: %d, expected: %d)\n",
504 mc_ver_info.minor, MC_VER_MINOR);
506 printf("fsl-mc: Management Complex booted (version: %d.%d.%d, boot status: %#x)\n",
507 mc_ver_info.major, mc_ver_info.minor, mc_ver_info.revision,
508 reg_gsr & GSR_FS_MASK);
511 * Tell the MC to deploy the DPL:
513 out_le32(&mc_ccsr_regs->reg_gsr, 0x0);
514 printf("fsl-mc: Deploying data path layout ... ");
515 error = wait_for_mc(false, ®_gsr);
521 mc_boot_status = -error;
528 int get_mc_boot_status(void)
530 return mc_boot_status;
534 * Return the actual size of the MC private DRAM block.
536 unsigned long mc_get_dram_block_size(void)
538 unsigned long dram_block_size = CONFIG_SYS_LS_MC_DRAM_BLOCK_MIN_SIZE;
540 char *dram_block_size_env_var = getenv(MC_MEM_SIZE_ENV_VAR);
542 if (dram_block_size_env_var) {
543 dram_block_size = simple_strtoul(dram_block_size_env_var, NULL,
546 if (dram_block_size < CONFIG_SYS_LS_MC_DRAM_BLOCK_MIN_SIZE) {
547 printf("fsl-mc: WARNING: Invalid value for \'"
549 "\' environment variable: %lu\n",
552 dram_block_size = CONFIG_SYS_LS_MC_DRAM_BLOCK_MIN_SIZE;
556 return dram_block_size;
559 int dpio_init(struct dprc_obj_desc obj_desc)
561 struct qbman_swp_desc p_des;
562 struct dpio_attr attr;
565 dflt_dpio = (struct fsl_dpio_obj *)malloc(sizeof(struct fsl_dpio_obj));
567 printf(" No memory: malloc() failed\n");
571 dflt_dpio->dpio_id = obj_desc.id;
573 err = dpio_open(dflt_mc_io, obj_desc.id, &dflt_dpio_handle);
575 printf("dpio_open() failed\n");
579 err = dpio_get_attributes(dflt_mc_io, dflt_dpio_handle, &attr);
581 printf("dpio_get_attributes() failed %d\n", err);
585 err = dpio_enable(dflt_mc_io, dflt_dpio_handle);
587 printf("dpio_enable() failed %d\n", err);
590 debug("ce_paddr=0x%llx, ci_paddr=0x%llx, portalid=%d, prios=%d\n",
591 attr.qbman_portal_ce_paddr,
592 attr.qbman_portal_ci_paddr,
593 attr.qbman_portal_id,
594 attr.num_priorities);
596 p_des.cena_bar = (void *)attr.qbman_portal_ce_paddr;
597 p_des.cinh_bar = (void *)attr.qbman_portal_ci_paddr;
599 dflt_dpio->sw_portal = qbman_swp_init(&p_des);
600 if (dflt_dpio->sw_portal == NULL) {
601 printf("qbman_swp_init() failed\n");
602 goto err_get_swp_init;
608 dpio_disable(dflt_mc_io, dflt_dpio_handle);
610 dpio_close(dflt_mc_io, dflt_dpio_handle);
616 int dpbp_init(struct dprc_obj_desc obj_desc)
618 dflt_dpbp = (struct fsl_dpbp_obj *)malloc(sizeof(struct fsl_dpbp_obj));
620 printf(" No memory: malloc() failed\n");
623 dflt_dpbp->dpbp_attr.id = obj_desc.id;
628 int dprc_init_container_obj(struct dprc_obj_desc obj_desc, uint16_t dprc_handle)
630 int error = 0, state = 0;
631 struct dprc_endpoint dpni_endpoint, dpmac_endpoint;
632 if (!strcmp(obj_desc.type, "dpbp")) {
634 error = dpbp_init(obj_desc);
636 printf("dpbp_init failed\n");
638 } else if (!strcmp(obj_desc.type, "dpio")) {
640 error = dpio_init(obj_desc);
642 printf("dpio_init failed\n");
644 } else if (!strcmp(obj_desc.type, "dpni")) {
645 strcpy(dpni_endpoint.type, obj_desc.type);
646 dpni_endpoint.id = obj_desc.id;
647 error = dprc_get_connection(dflt_mc_io, dprc_handle,
648 &dpni_endpoint, &dpmac_endpoint, &state);
649 if (!strcmp(dpmac_endpoint.type, "dpmac"))
650 error = ldpaa_eth_init(obj_desc);
652 printf("ldpaa_eth_init failed\n");
658 int dprc_scan_container_obj(uint16_t dprc_handle, char *obj_type, int i)
661 struct dprc_obj_desc obj_desc;
663 memset((void *)&obj_desc, 0x00, sizeof(struct dprc_obj_desc));
665 error = dprc_get_obj(dflt_mc_io, dprc_handle,
668 printf("dprc_get_obj(i=%d) failed: %d\n",
673 if (!strcmp(obj_desc.type, obj_type)) {
674 debug("Discovered object: type %s, id %d, req %s\n",
675 obj_desc.type, obj_desc.id, obj_type);
677 error = dprc_init_container_obj(obj_desc, dprc_handle);
679 printf("dprc_init_container_obj(i=%d) failed: %d\n",
688 int fsl_mc_ldpaa_init(bd_t *bis)
691 int dprc_opened = 0, container_id;
692 int num_child_objects = 0;
698 error = dprc_get_container_id(dflt_mc_io, &container_id);
700 printf("dprc_get_container_id() failed: %d\n", error);
704 debug("fsl-mc: Container id=0x%x\n", container_id);
706 error = dprc_open(dflt_mc_io, container_id, &dflt_dprc_handle);
708 printf("dprc_open() failed: %d\n", error);
713 error = dprc_get_obj_count(dflt_mc_io,
717 printf("dprc_get_obj_count() failed: %d\n", error);
720 debug("Total child in container %d = %d\n", container_id,
723 if (num_child_objects != 0) {
725 * Discover objects currently in the DPRC container in the MC:
727 for (i = 0; i < num_child_objects; i++)
728 error = dprc_scan_container_obj(dflt_dprc_handle,
731 for (i = 0; i < num_child_objects; i++)
732 error = dprc_scan_container_obj(dflt_dprc_handle,
735 for (i = 0; i < num_child_objects; i++)
736 error = dprc_scan_container_obj(dflt_dprc_handle,
741 dprc_close(dflt_mc_io, dflt_dprc_handle);
746 void fsl_mc_ldpaa_exit(bd_t *bis)
750 if (get_mc_boot_status() == 0) {
751 err = dpio_disable(dflt_mc_io, dflt_dpio_handle);
753 printf("dpio_disable() failed: %d\n", err);
756 err = dpio_reset(dflt_mc_io, dflt_dpio_handle);
758 printf("dpio_reset() failed: %d\n", err);
761 err = dpio_close(dflt_mc_io, dflt_dpio_handle);
763 printf("dpio_close() failed: %d\n", err);