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 <platform_def.h>
38 #include <semihosting.h> /* For FOPEN_MODE_... */
39 #include <string.h>
40
41 /* IO devices */
42 static const io_dev_connector_t *fip_dev_con;
43 static uintptr_t fip_dev_spec;
44 static uintptr_t fip_dev_handle;
45 static const io_dev_connector_t *memmap_dev_con;
46 static uintptr_t memmap_dev_spec;
47 static uintptr_t memmap_init_params;
48 static uintptr_t memmap_dev_handle;
49
50 static const io_block_spec_t fip_block_spec = {
51 .offset = FLASH_BASE,
52 .length = FLASH_SIZE
53 };
54
55 static const io_file_spec_t bl2_file_spec = {
56 .path = BL2_IMAGE_NAME,
57 .mode = FOPEN_MODE_RB
58 };
59
60 static const io_file_spec_t bl30_file_spec = {
61 .path = BL30_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 const 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 BL30_IMAGE_NAME,
155 &fip_dev_handle,
156 (uintptr_t)&bl30_file_spec,
157 open_fip
158 }, {
159 BL31_IMAGE_NAME,
160 &fip_dev_handle,
161 (uintptr_t)&bl31_file_spec,
162 open_fip
163 }, {
164 BL32_IMAGE_NAME,
165 &fip_dev_handle,
166 (uintptr_t)&bl32_file_spec,
167 open_fip
168 }, {
169 BL33_IMAGE_NAME,
170 &fip_dev_handle,
171 (uintptr_t)&bl33_file_spec,
172 open_fip
173 }, {
174 #if TRUSTED_BOARD_BOOT
175 BL2_CERT_NAME,
176 &fip_dev_handle,
177 (uintptr_t)&bl2_cert_file_spec,
178 open_fip
179 }, {
180 TRUSTED_KEY_CERT_NAME,
181 &fip_dev_handle,
182 (uintptr_t)&trusted_key_cert_file_spec,
183 open_fip
184 }, {
185 BL30_KEY_CERT_NAME,
186 &fip_dev_handle,
187 (uintptr_t)&bl30_key_cert_file_spec,
188 open_fip
189 }, {
190 BL31_KEY_CERT_NAME,
191 &fip_dev_handle,
192 (uintptr_t)&bl31_key_cert_file_spec,
193 open_fip
194 }, {
195 BL32_KEY_CERT_NAME,
196 &fip_dev_handle,
197 (uintptr_t)&bl32_key_cert_file_spec,
198 open_fip
199 }, {
200 BL33_KEY_CERT_NAME,
201 &fip_dev_handle,
202 (uintptr_t)&bl33_key_cert_file_spec,
203 open_fip
204 }, {
205 BL30_CERT_NAME,
206 &fip_dev_handle,
207 (uintptr_t)&bl30_cert_file_spec,
208 open_fip
209 }, {
210 BL31_CERT_NAME,
211 &fip_dev_handle,
212 (uintptr_t)&bl31_cert_file_spec,
213 open_fip
214 }, {
215 BL32_CERT_NAME,
216 &fip_dev_handle,
217 (uintptr_t)&bl32_cert_file_spec,
218 open_fip
219 }, {
220 BL33_CERT_NAME,
221 &fip_dev_handle,
222 (uintptr_t)&bl33_cert_file_spec,
223 open_fip
224 }, {
225 #endif /* TRUSTED_BOARD_BOOT */
226 0, 0, 0
227 }
228 };
229
230
open_fip(const uintptr_t spec)231 static int open_fip(const uintptr_t spec)
232 {
233 int result = IO_FAIL;
234
235 /* See if a Firmware Image Package is available */
236 result = io_dev_init(fip_dev_handle, (uintptr_t)FIP_IMAGE_NAME);
237 if (result == IO_SUCCESS) {
238 INFO("Using FIP\n");
239 /*TODO: Check image defined in spec is present in FIP. */
240 }
241 return result;
242 }
243
244
open_memmap(const uintptr_t spec)245 static int open_memmap(const uintptr_t spec)
246 {
247 int result = IO_FAIL;
248 uintptr_t local_image_handle;
249
250 result = io_dev_init(memmap_dev_handle, memmap_init_params);
251 if (result == IO_SUCCESS) {
252 result = io_open(memmap_dev_handle, spec, &local_image_handle);
253 if (result == IO_SUCCESS) {
254 /* INFO("Using Memmap IO\n"); */
255 io_close(local_image_handle);
256 }
257 }
258 return result;
259 }
260
io_setup(void)261 void io_setup(void)
262 {
263 int io_result = IO_FAIL;
264
265 /* Register the IO devices on this platform */
266 io_result = register_io_dev_fip(&fip_dev_con);
267 assert(io_result == IO_SUCCESS);
268
269 io_result = register_io_dev_memmap(&memmap_dev_con);
270 assert(io_result == IO_SUCCESS);
271
272 /* Open connections to devices and cache the handles */
273 io_result = io_dev_open(fip_dev_con, fip_dev_spec, &fip_dev_handle);
274 assert(io_result == IO_SUCCESS);
275
276 io_result = io_dev_open(memmap_dev_con, memmap_dev_spec,
277 &memmap_dev_handle);
278 assert(io_result == IO_SUCCESS);
279
280 /* Ignore improbable errors in release builds */
281 (void)io_result;
282 }
283
284
285 /* Return an IO device handle and specification which can be used to access
286 * 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)287 int plat_get_image_source(const char *image_name, uintptr_t *dev_handle,
288 uintptr_t *image_spec)
289 {
290 int result = IO_FAIL;
291 const struct plat_io_policy *policy;
292
293 if ((image_name != NULL) && (dev_handle != NULL) &&
294 (image_spec != NULL)) {
295 policy = policies;
296 while (policy->image_name != NULL) {
297 if (strcmp(policy->image_name, image_name) == 0) {
298 result = policy->check(policy->image_spec);
299 if (result == IO_SUCCESS) {
300 *image_spec = policy->image_spec;
301 *dev_handle = *(policy->dev_handle);
302 break;
303 }
304 }
305 policy++;
306 }
307 } else {
308 result = IO_FAIL;
309 }
310 return result;
311 }
312