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