1 /*
2 * Copyright (c) 2014, ARM Limited and Contributors. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * Redistributions of source code must retain the above copyright notice, this
8 * list of conditions and the following disclaimer.
9 *
10 * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * Neither the name of ARM nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific
16 * prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include <assert.h>
32 #include <debug.h>
33 #include <io_driver.h>
34 #include <io_fip.h>
35 #include <io_memmap.h>
36 #include <io_storage.h>
37 #include <io_semihosting.h>
38 #include <platform_def.h>
39 #include <semihosting.h> /* For FOPEN_MODE_... */
40 #include <string.h>
41
42 /* IO devices */
43 static const io_dev_connector_t *sh_dev_con;
44 static uintptr_t sh_dev_spec;
45 static uintptr_t sh_init_params;
46 static uintptr_t sh_dev_handle;
47 static const io_dev_connector_t *fip_dev_con;
48 static uintptr_t fip_dev_spec;
49 static uintptr_t fip_dev_handle;
50 static const io_dev_connector_t *memmap_dev_con;
51 static uintptr_t memmap_dev_spec;
52 static uintptr_t memmap_init_params;
53 static uintptr_t memmap_dev_handle;
54
55 static const io_block_spec_t fip_block_spec = {
56 .offset = FLASH0_BASE,
57 .length = FLASH0_SIZE
58 };
59
60 static const io_file_spec_t bl2_file_spec = {
61 .path = BL2_IMAGE_NAME,
62 .mode = FOPEN_MODE_RB
63 };
64
65 static const io_file_spec_t bl31_file_spec = {
66 .path = BL31_IMAGE_NAME,
67 .mode = FOPEN_MODE_RB
68 };
69
70 static const io_file_spec_t bl32_file_spec = {
71 .path = BL32_IMAGE_NAME,
72 .mode = FOPEN_MODE_RB
73 };
74
75 static const io_file_spec_t bl33_file_spec = {
76 .path = BL33_IMAGE_NAME,
77 .mode = FOPEN_MODE_RB
78 };
79
80 #if TRUSTED_BOARD_BOOT
81 static const io_file_spec_t bl2_cert_file_spec = {
82 .path = BL2_CERT_NAME,
83 .mode = FOPEN_MODE_RB
84 };
85
86 static const io_file_spec_t trusted_key_cert_file_spec = {
87 .path = TRUSTED_KEY_CERT_NAME,
88 .mode = FOPEN_MODE_RB
89 };
90
91 static const io_file_spec_t bl30_key_cert_file_spec = {
92 .path = BL30_KEY_CERT_NAME,
93 .mode = FOPEN_MODE_RB
94 };
95
96 static const io_file_spec_t bl31_key_cert_file_spec = {
97 .path = BL31_KEY_CERT_NAME,
98 .mode = FOPEN_MODE_RB
99 };
100
101 static const io_file_spec_t bl32_key_cert_file_spec = {
102 .path = BL32_KEY_CERT_NAME,
103 .mode = FOPEN_MODE_RB
104 };
105
106 static const io_file_spec_t bl33_key_cert_file_spec = {
107 .path = BL33_KEY_CERT_NAME,
108 .mode = FOPEN_MODE_RB
109 };
110
111 static const io_file_spec_t bl30_cert_file_spec = {
112 .path = BL30_CERT_NAME,
113 .mode = FOPEN_MODE_RB
114 };
115
116 static const io_file_spec_t bl31_cert_file_spec = {
117 .path = BL31_CERT_NAME,
118 .mode = FOPEN_MODE_RB
119 };
120
121 static const io_file_spec_t bl32_cert_file_spec = {
122 .path = BL32_CERT_NAME,
123 .mode = FOPEN_MODE_RB
124 };
125
126 static const io_file_spec_t bl33_cert_file_spec = {
127 .path = BL33_CERT_NAME,
128 .mode = FOPEN_MODE_RB
129 };
130 #endif /* TRUSTED_BOARD_BOOT */
131
132 static int open_fip(const uintptr_t spec);
133 static int open_memmap(const uintptr_t spec);
134
135 struct plat_io_policy {
136 char *image_name;
137 uintptr_t *dev_handle;
138 uintptr_t image_spec;
139 int (*check)(const uintptr_t spec);
140 };
141
142 static const struct plat_io_policy policies[] = {
143 {
144 FIP_IMAGE_NAME,
145 &memmap_dev_handle,
146 (uintptr_t)&fip_block_spec,
147 open_memmap
148 }, {
149 BL2_IMAGE_NAME,
150 &fip_dev_handle,
151 (uintptr_t)&bl2_file_spec,
152 open_fip
153 }, {
154 BL31_IMAGE_NAME,
155 &fip_dev_handle,
156 (uintptr_t)&bl31_file_spec,
157 open_fip
158 }, {
159 BL32_IMAGE_NAME,
160 &fip_dev_handle,
161 (uintptr_t)&bl32_file_spec,
162 open_fip
163 }, {
164 BL33_IMAGE_NAME,
165 &fip_dev_handle,
166 (uintptr_t)&bl33_file_spec,
167 open_fip
168 }, {
169 #if TRUSTED_BOARD_BOOT
170 BL2_CERT_NAME,
171 &fip_dev_handle,
172 (uintptr_t)&bl2_cert_file_spec,
173 open_fip
174 }, {
175 TRUSTED_KEY_CERT_NAME,
176 &fip_dev_handle,
177 (uintptr_t)&trusted_key_cert_file_spec,
178 open_fip
179 }, {
180 BL30_KEY_CERT_NAME,
181 &fip_dev_handle,
182 (uintptr_t)&bl30_key_cert_file_spec,
183 open_fip
184 }, {
185 BL31_KEY_CERT_NAME,
186 &fip_dev_handle,
187 (uintptr_t)&bl31_key_cert_file_spec,
188 open_fip
189 }, {
190 BL32_KEY_CERT_NAME,
191 &fip_dev_handle,
192 (uintptr_t)&bl32_key_cert_file_spec,
193 open_fip
194 }, {
195 BL33_KEY_CERT_NAME,
196 &fip_dev_handle,
197 (uintptr_t)&bl33_key_cert_file_spec,
198 open_fip
199 }, {
200 BL30_CERT_NAME,
201 &fip_dev_handle,
202 (uintptr_t)&bl30_cert_file_spec,
203 open_fip
204 }, {
205 BL31_CERT_NAME,
206 &fip_dev_handle,
207 (uintptr_t)&bl31_cert_file_spec,
208 open_fip
209 }, {
210 BL32_CERT_NAME,
211 &fip_dev_handle,
212 (uintptr_t)&bl32_cert_file_spec,
213 open_fip
214 }, {
215 BL33_CERT_NAME,
216 &fip_dev_handle,
217 (uintptr_t)&bl33_cert_file_spec,
218 open_fip
219 }, {
220 #endif /* TRUSTED_BOARD_BOOT */
221 0, 0, 0
222 }
223 };
224
225
open_fip(const uintptr_t spec)226 static int open_fip(const uintptr_t spec)
227 {
228 int result = IO_FAIL;
229
230 /* See if a Firmware Image Package is available */
231 result = io_dev_init(fip_dev_handle, (uintptr_t)FIP_IMAGE_NAME);
232 if (result == IO_SUCCESS) {
233 VERBOSE("Using FIP\n");
234 /*TODO: Check image defined in spec is present in FIP. */
235 }
236 return result;
237 }
238
239
open_memmap(const uintptr_t spec)240 static int open_memmap(const uintptr_t spec)
241 {
242 int result = IO_FAIL;
243 uintptr_t local_image_handle;
244
245 result = io_dev_init(memmap_dev_handle, memmap_init_params);
246 if (result == IO_SUCCESS) {
247 result = io_open(memmap_dev_handle, spec, &local_image_handle);
248 if (result == IO_SUCCESS) {
249 VERBOSE("Using Memmap IO\n");
250 io_close(local_image_handle);
251 }
252 }
253 return result;
254 }
255
256
open_semihosting(const uintptr_t spec)257 static int open_semihosting(const uintptr_t spec)
258 {
259 int result = IO_FAIL;
260 uintptr_t local_image_handle;
261
262 /* See if the file exists on semi-hosting.*/
263 result = io_dev_init(sh_dev_handle, sh_init_params);
264 if (result == IO_SUCCESS) {
265 result = io_open(sh_dev_handle, spec, &local_image_handle);
266 if (result == IO_SUCCESS) {
267 VERBOSE("Using Semi-hosting IO\n");
268 io_close(local_image_handle);
269 }
270 }
271 return result;
272 }
273
fvp_io_setup(void)274 void fvp_io_setup (void)
275 {
276 int io_result = IO_FAIL;
277
278 /* Register the IO devices on this platform */
279 io_result = register_io_dev_sh(&sh_dev_con);
280 assert(io_result == IO_SUCCESS);
281
282 io_result = register_io_dev_fip(&fip_dev_con);
283 assert(io_result == IO_SUCCESS);
284
285 io_result = register_io_dev_memmap(&memmap_dev_con);
286 assert(io_result == IO_SUCCESS);
287
288 /* Open connections to devices and cache the handles */
289 io_result = io_dev_open(sh_dev_con, sh_dev_spec, &sh_dev_handle);
290 assert(io_result == IO_SUCCESS);
291
292 io_result = io_dev_open(fip_dev_con, fip_dev_spec, &fip_dev_handle);
293 assert(io_result == IO_SUCCESS);
294
295 io_result = io_dev_open(memmap_dev_con, memmap_dev_spec,
296 &memmap_dev_handle);
297 assert(io_result == IO_SUCCESS);
298
299 /* Ignore improbable errors in release builds */
300 (void)io_result;
301 }
302
303
304 /* Return an IO device handle and specification which can be used to access
305 * an image. Use this to enforce platform load policy */
plat_get_image_source(const char * image_name,uintptr_t * dev_handle,uintptr_t * image_spec)306 int plat_get_image_source(const char *image_name, uintptr_t *dev_handle,
307 uintptr_t *image_spec)
308 {
309 int result = IO_FAIL;
310 const struct plat_io_policy *policy;
311
312 if ((image_name != NULL) && (dev_handle != NULL) &&
313 (image_spec != NULL)) {
314 policy = policies;
315 while (policy->image_name != NULL) {
316 if (strcmp(policy->image_name, image_name) == 0) {
317 result = policy->check(policy->image_spec);
318 if (result == IO_SUCCESS) {
319 *image_spec = policy->image_spec;
320 *dev_handle = *(policy->dev_handle);
321 break;
322 } else {
323 result = open_semihosting(
324 policy->image_spec);
325 if (result == IO_SUCCESS) {
326 *dev_handle = sh_dev_handle;
327 *image_spec =
328 policy->image_spec;
329 }
330 }
331 }
332 policy++;
333 }
334 } else {
335 result = IO_FAIL;
336 }
337 return result;
338 }
339