1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * (C) Copyright 2017 Theobroma Systems Design und Consulting GmbH
4 */
5
6#include <common.h>
7#include <dm.h>
8#include <fdt_support.h>
9#include <log.h>
10#include <mmc.h>
11#include <spl.h>
12#include <asm/global_data.h>
13#include <dm/uclass-internal.h>
14
15#if CONFIG_IS_ENABLED(OF_LIBFDT)
16/**
17 * spl_node_to_boot_device() - maps from a DT-node to a SPL boot device
18 * @node:	of_offset of the node
19 *
20 * The SPL framework uses BOOT_DEVICE_... constants to identify its boot
21 * sources.  These may take on a device-specific meaning, depending on
22 * what nodes are enabled in a DTS (e.g. BOOT_DEVICE_MMC1 may refer to
23 * different controllers/block-devices, depending on which SD/MMC controllers
24 * are enabled in any given DTS).  This function maps from a DT-node back
25 * onto a BOOT_DEVICE_... constant, considering the currently active devices.
26 *
27 * Returns
28 *   -ENOENT, if no device matching the node could be found
29 *   -ENOSYS, if the device matching the node can not be mapped onto a
30 *            SPL boot device (e.g. the third MMC device)
31 *   -1, for unspecified failures
32 *   a positive integer (from the BOOT_DEVICE_... family) on success.
33 */
34
35static int spl_node_to_boot_device(int node)
36{
37	struct udevice *parent;
38
39	/*
40	 * This should eventually move into the SPL code, once SPL becomes
41	 * aware of the block-device layer.  Until then (and to avoid unneeded
42	 * delays in getting this feature out), it lives at the board-level.
43	 */
44	if (!uclass_get_device_by_of_offset(UCLASS_MMC, node, &parent)) {
45		struct udevice *dev;
46		struct blk_desc *desc = NULL;
47
48		for (device_find_first_child(parent, &dev);
49		     dev;
50		     device_find_next_child(&dev)) {
51			if (device_get_uclass_id(dev) == UCLASS_BLK) {
52				desc = dev_get_uclass_plat(dev);
53				break;
54			}
55		}
56
57		if (!desc)
58			return -ENOENT;
59
60		switch (desc->devnum) {
61		case 0:
62			return BOOT_DEVICE_MMC1;
63		case 1:
64			return BOOT_DEVICE_MMC2;
65		default:
66			return -ENOSYS;
67		}
68	}
69
70	/*
71	 * SPL doesn't differentiate SPI flashes, so we keep the detection
72	 * brief and inaccurate... hopefully, the common SPL layer can be
73	 * extended with awareness of the BLK layer (and matching OF_CONTROL)
74	 * soon.
75	 */
76	if (!uclass_get_device_by_of_offset(UCLASS_SPI_FLASH, node, &parent))
77		return BOOT_DEVICE_SPI;
78
79	return -1;
80}
81
82/**
83 * board_spl_was_booted_from() - retrieves the of-path the SPL was loaded from
84 *
85 * To support a 'same-as-spl' specification in the search-order for the next
86 * stage, we need a SoC- or board-specific way to handshake with what 'came
87 * before us' (either a BROM or TPL stage) and map the info retrieved onto
88 * a OF path.
89 *
90 * Returns
91 *   NULL, on failure or if the device could not be identified
92 *   a of_path (a string), on success
93 */
94__weak const char *board_spl_was_booted_from(void)
95{
96	debug("%s: no support for 'same-as-spl' for this board\n", __func__);
97	return NULL;
98}
99
100void board_boot_order(u32 *spl_boot_list)
101{
102	/* In case of no fdt (or only plat), use spl_boot_device() */
103	if (!CONFIG_IS_ENABLED(OF_CONTROL) || CONFIG_IS_ENABLED(OF_PLATDATA)) {
104		spl_boot_list[0] = spl_boot_device();
105		return;
106	}
107
108	const void *blob = gd->fdt_blob;
109	int chosen_node = fdt_path_offset(blob, "/chosen");
110	int idx = 0;
111	int elem;
112	int boot_device;
113	int node;
114	const char *conf;
115
116	if (chosen_node < 0) {
117		debug("%s: /chosen not found, using spl_boot_device()\n",
118		      __func__);
119		spl_boot_list[0] = spl_boot_device();
120		return;
121	}
122
123	for (elem = 0;
124	     (conf = fdt_stringlist_get(blob, chosen_node,
125					"u-boot,spl-boot-order", elem, NULL));
126	     elem++) {
127		const char *alias;
128
129		/* Handle the case of 'same device the SPL was loaded from' */
130		if (strncmp(conf, "same-as-spl", 11) == 0) {
131			conf = board_spl_was_booted_from();
132			if (!conf)
133				continue;
134		}
135
136		/* First check if the list element is an alias */
137		alias = fdt_get_alias(blob, conf);
138		if (alias)
139			conf = alias;
140
141		/* Try to resolve the config item (or alias) as a path */
142		node = fdt_path_offset(blob, conf);
143		if (node < 0) {
144			debug("%s: could not find %s in FDT\n", __func__, conf);
145			continue;
146		}
147
148		/* Try to map this back onto SPL boot devices */
149		boot_device = spl_node_to_boot_device(node);
150		if (boot_device < 0) {
151			debug("%s: could not map node %s to a boot-device\n",
152			      __func__, conf);
153			continue;
154		}
155
156		spl_boot_list[idx++] = boot_device;
157	}
158
159	/* If we had no matches, fall back to spl_boot_device */
160	if (idx == 0)
161		spl_boot_list[0] = spl_boot_device();
162}
163
164int spl_decode_boot_device(u32 boot_device, char *buf, size_t buflen)
165{
166	struct udevice *dev;
167#if CONFIG_IS_ENABLED(BLK)
168	int dev_num;
169#endif
170	int ret;
171
172	if (boot_device == BOOT_DEVICE_SPI) {
173		/* Revert spl_node_to_boot_device() logic to find appropriate SPI flash device */
174
175		/*
176		 * Devices with multiple SPI flash devices will take the first SPI flash found in
177		 * /chosen/u-boot,spl-boot-order.
178		 */
179		const void *blob = gd->fdt_blob;
180		int chosen_node = fdt_path_offset(blob, "/chosen");
181		int elem;
182		int node;
183		const char *conf;
184
185		if (chosen_node < 0) {
186			debug("%s: /chosen not found\n", __func__);
187			return -ENODEV;
188		}
189
190		for (elem = 0;
191		     (conf = fdt_stringlist_get(blob, chosen_node,
192						"u-boot,spl-boot-order", elem, NULL));
193		     elem++) {
194			const char *alias;
195
196			/* Handle the case of 'same device the SPL was loaded from' */
197			if (strncmp(conf, "same-as-spl", 11) == 0) {
198				conf = board_spl_was_booted_from();
199				if (!conf)
200					continue;
201			}
202
203			/* First check if the list element is an alias */
204			alias = fdt_get_alias(blob, conf);
205			if (alias)
206				conf = alias;
207
208			/* Try to resolve the config item (or alias) as a path */
209			node = fdt_path_offset(blob, conf);
210			if (node < 0) {
211				debug("%s: could not find %s in FDT\n", __func__, conf);
212				continue;
213			}
214
215			ret = uclass_find_device_by_of_offset(UCLASS_SPI_FLASH, node, &dev);
216			if (ret) {
217				debug("%s: could not find udevice for %s\n", __func__, conf);
218				continue;
219			}
220
221			return ofnode_get_path(dev_ofnode(dev), buf, buflen);
222		}
223
224		return -ENODEV;
225	}
226
227#if CONFIG_IS_ENABLED(BLK)
228	dev_num = (boot_device == BOOT_DEVICE_MMC1) ? 0 : 1;
229
230	ret = blk_find_device(UCLASS_MMC, dev_num, &dev);
231	if (ret) {
232		debug("%s: could not find blk device for MMC device %d: %d\n",
233		      __func__, dev_num, ret);
234		return ret;
235	}
236
237	dev = dev_get_parent(dev);
238	return ofnode_get_path(dev_ofnode(dev), buf, buflen);
239#else
240	return -ENODEV;
241#endif
242}
243
244void spl_perform_fixups(struct spl_image_info *spl_image)
245{
246	void *blob = spl_image_fdt_addr(spl_image);
247	char boot_ofpath[512];
248	int chosen, ret;
249
250	/*
251	 * Inject the ofpath of the device the full U-Boot (or Linux in
252	 * Falcon-mode) was booted from into the FDT, if a FDT has been
253	 * loaded at the same time.
254	 */
255	if (!blob)
256		return;
257
258	ret = spl_decode_boot_device(spl_image->boot_device, boot_ofpath, sizeof(boot_ofpath));
259	if (ret) {
260		pr_err("%s: could not map boot_device to ofpath: %d\n", __func__, ret);
261		return;
262	}
263
264	chosen = fdt_find_or_add_subnode(blob, 0, "chosen");
265	if (chosen < 0) {
266		pr_err("%s: could not find/create '/chosen'\n", __func__);
267		return;
268	}
269	fdt_setprop_string(blob, chosen,
270			   "u-boot,spl-boot-device", boot_ofpath);
271}
272#endif
273