]> git.ipfire.org Git - thirdparty/u-boot.git/blob - drivers/net/fsl-mc/mc.c
projects / thirdparty / u-boot.git / blob
? search:


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