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