1
2
3
4
5
6
7
8#include <common.h>
9#include <errno.h>
10#include <image.h>
11#include <libfdt.h>
12#include <spl.h>
13
14
15
16
17
18
19
20
21
22
23
24
25
26static int spl_fit_get_image_node(const void *fit, int images,
27 const char *type, int index)
28{
29 const char *name, *str;
30 int node, conf_node;
31 int len, i;
32
33 conf_node = fit_find_config_node(fit);
34 if (conf_node < 0) {
35#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
36 printf("No matching DT out of these options:\n");
37 for (node = fdt_first_subnode(fit, conf_node);
38 node >= 0;
39 node = fdt_next_subnode(fit, node)) {
40 name = fdt_getprop(fit, node, "description", &len);
41 printf(" %s\n", name);
42 }
43#endif
44 return conf_node;
45 }
46
47 name = fdt_getprop(fit, conf_node, type, &len);
48 if (!name) {
49 debug("cannot find property '%s': %d\n", type, len);
50 return -EINVAL;
51 }
52
53 str = name;
54 for (i = 0; i < index; i++) {
55 str = strchr(str, '\0') + 1;
56 if (!str || (str - name >= len)) {
57 debug("no string for index %d\n", index);
58 return -E2BIG;
59 }
60 }
61
62 debug("%s: '%s'\n", type, str);
63 node = fdt_subnode_offset(fit, images, str);
64 if (node < 0) {
65 debug("cannot find image node '%s': %d\n", str, node);
66 return -EINVAL;
67 }
68
69 return node;
70}
71
72static int get_aligned_image_offset(struct spl_load_info *info, int offset)
73{
74
75
76
77
78
79 if (info->filename)
80 return offset & ~(ARCH_DMA_MINALIGN - 1);
81
82 return offset / info->bl_len;
83}
84
85static int get_aligned_image_overhead(struct spl_load_info *info, int offset)
86{
87
88
89
90
91
92
93 if (info->filename)
94 return offset & (ARCH_DMA_MINALIGN - 1);
95
96 return offset % info->bl_len;
97}
98
99static int get_aligned_image_size(struct spl_load_info *info, int data_size,
100 int offset)
101{
102 data_size = data_size + get_aligned_image_overhead(info, offset);
103
104 if (info->filename)
105 return data_size;
106
107 return (data_size + info->bl_len - 1) / info->bl_len;
108}
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127static int spl_load_fit_image(struct spl_load_info *info, ulong sector,
128 void *fit, ulong base_offset, int node,
129 struct spl_image_info *image_info)
130{
131 ulong offset;
132 size_t length;
133 ulong load_addr, load_ptr;
134 void *src;
135 ulong overhead;
136 int nr_sectors;
137 int align_len = ARCH_DMA_MINALIGN - 1;
138
139 offset = fdt_getprop_u32(fit, node, "data-offset");
140 if (offset == FDT_ERROR)
141 return -ENOENT;
142 offset += base_offset;
143 length = fdt_getprop_u32(fit, node, "data-size");
144 if (length == FDT_ERROR)
145 return -ENOENT;
146 load_addr = fdt_getprop_u32(fit, node, "load");
147 if (load_addr == FDT_ERROR && image_info)
148 load_addr = image_info->load_addr;
149 load_ptr = (load_addr + align_len) & ~align_len;
150
151 overhead = get_aligned_image_overhead(info, offset);
152 nr_sectors = get_aligned_image_size(info, length, offset);
153
154 if (info->read(info, sector + get_aligned_image_offset(info, offset),
155 nr_sectors, (void*)load_ptr) != nr_sectors)
156 return -EIO;
157 debug("image: dst=%lx, offset=%lx, size=%lx\n", load_ptr, offset,
158 (unsigned long)length);
159
160 src = (void *)load_ptr + overhead;
161#ifdef CONFIG_SPL_FIT_IMAGE_POST_PROCESS
162 board_fit_image_post_process(&src, &length);
163#endif
164
165 memcpy((void*)load_addr, src, length);
166
167 if (image_info) {
168 image_info->load_addr = load_addr;
169 image_info->size = length;
170 image_info->entry_point = fdt_getprop_u32(fit, node, "entry");
171 }
172
173 return 0;
174}
175
176int spl_load_simple_fit(struct spl_image_info *spl_image,
177 struct spl_load_info *info, ulong sector, void *fit)
178{
179 int sectors;
180 ulong size;
181 unsigned long count;
182 struct spl_image_info image_info;
183 int node, images, ret;
184 int base_offset, align_len = ARCH_DMA_MINALIGN - 1;
185 int index = 0;
186
187
188
189
190
191 size = fdt_totalsize(fit);
192 size = (size + 3) & ~3;
193 base_offset = (size + 3) & ~3;
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209 fit = (void *)((CONFIG_SYS_TEXT_BASE - size - info->bl_len -
210 align_len) & ~align_len);
211 sectors = get_aligned_image_size(info, size, 0);
212 count = info->read(info, sector, sectors, fit);
213 debug("fit read sector %lx, sectors=%d, dst=%p, count=%lu\n",
214 sector, sectors, fit, count);
215 if (count == 0)
216 return -EIO;
217
218
219 images = fdt_path_offset(fit, FIT_IMAGES_PATH);
220 if (images < 0) {
221 debug("%s: Cannot find /images node: %d\n", __func__, images);
222 return -1;
223 }
224
225
226 node = spl_fit_get_image_node(fit, images, "firmware", 0);
227 if (node < 0) {
228 debug("could not find firmware image, trying loadables...\n");
229 node = spl_fit_get_image_node(fit, images, "loadables", 0);
230
231
232
233
234 index = 1;
235 }
236 if (node < 0) {
237 debug("%s: Cannot find u-boot image node: %d\n",
238 __func__, node);
239 return -1;
240 }
241
242
243 ret = spl_load_fit_image(info, sector, fit, base_offset, node,
244 spl_image);
245 if (ret)
246 return ret;
247
248 spl_image->os = IH_OS_U_BOOT;
249
250
251 node = spl_fit_get_image_node(fit, images, FIT_FDT_PROP, 0);
252 if (node < 0) {
253 debug("%s: cannot find FDT node\n", __func__);
254 return node;
255 }
256
257
258
259
260
261 image_info.load_addr = spl_image->load_addr + spl_image->size;
262 ret = spl_load_fit_image(info, sector, fit, base_offset, node,
263 &image_info);
264 if (ret < 0)
265 return ret;
266
267
268 for (; ; index++) {
269 node = spl_fit_get_image_node(fit, images, "loadables", index);
270 if (node < 0)
271 break;
272
273 ret = spl_load_fit_image(info, sector, fit, base_offset, node,
274 &image_info);
275 if (ret < 0)
276 continue;
277
278
279
280
281
282 if (spl_image->entry_point == FDT_ERROR &&
283 image_info.entry_point != FDT_ERROR)
284 spl_image->entry_point = image_info.entry_point;
285 }
286
287
288
289
290
291
292 if (spl_image->entry_point == FDT_ERROR || spl_image->entry_point == 0)
293 spl_image->entry_point = spl_image->load_addr;
294
295 return 0;
296}
297